针对为什么python不允许在函数和变量名中使用连字符？和python变量为什么不能以数字开头这两个问题，本篇文章进行了详细的解答，同时本文还将给你拓展C++函数名中使用哪些字符是不允许的？、pyth

针对为什么python不允许在函数和变量名中使用连字符？和python变量为什么不能以数字开头这两个问题，本篇文章进行了详细的解答，同时本文还将给你拓展C++ 函数名中使用哪些字符是不允许的？、python – cython：不允许在主包之外的相对cimport、Python 中函数和变量的作用域、Python3 参数和变量等相关知识，希望可以帮助到你。

• 为什么python不允许在函数和变量名中使用连字符？（python变量为什么不能以数字开头）
• C++ 函数名中使用哪些字符是不允许的？
• python – cython：不允许在主包之外的相对cimport
• Python 中函数和变量的作用域
• Python3 参数和变量

为什么python不允许在函数和变量名中使用连字符？（python变量为什么不能以数字开头）

我一直想知道为什么我们不能在python中的函数名和变量名之间使用连字符

尝试过使用Lisp和Clojure之类的功能编程语言，允许使用连字符。为什么python不这样做。

# This won''t work -- SyntaxErrordef is-even(num):    return num % 2# This will workdef is_even(num):    return num % 2

我确信，由于某些原因，圭多爵士一定会这样做。我用谷歌搜索，但找不到答案。谁能给我一点启示吗？

答案1

因为连字符用作减法运算符。想象一下，您 可以 拥有一个is-even函数，然后拥有如下代码：

my_var = is-even(another_var)

是is-even(another_var)对函数的调用is-even，还是even从名为的变量中减去函数的结果is？

Lisp方言不存在此问题，因为它们使用前缀表示法。例如，两者之间有明显的区别

(is-even 4)

和

(- is (even 4))

在Lisps。

C++ 函数名中使用哪些字符是不允许的？

以下字符不允许出现在 c++++ 函数名中：关键字（如 int、void、bool 等）特殊符号（如 #、%、&、*、- 等）空格（函数名不得包含空格）例外：下划线 (_) 允许用作函数名中的字符美元符号 ($) 和范围运算符 (::) 仅允许用在类的成员函数中

C++ 函数名中不允许使用的字符

在 C++ 中，函数名遵循与标识符相同的命名规则，以下字符不允许出现在函数名中：

• 关键字：例如 int、void、bool 等。
• 特殊符号：例如 #、%、&、*、- 等。
• 空格：函数名不得包含空格。

例外：

• 下划线 (_) 允许用作函数名中的字符。
• 美元符号 ($) 和范围运算符 (::) 仅允许用在类的成员函数中。

实战案例：

立即学习“C++免费学习笔记（深入）”；

// 合法的函数名
int add(int a, int b);
float calculateArea(float radius);

// 非法的函数名（包含关键字）
int void();

// 非法的函数名（包含空格）
double find distance(double x1, double y1, double x2, double y2);

// 合法的函数名（包含下划线）
bool is_valid(int value);

提示：

• 函数名应以小写字母开头，并使用驼峰命名法（例如 calculateArea）。
• 避免使用太长的函数名或难以理解的名称。
• 确保函数名清楚且准确地描述了函数的功能。

以上就是C++ 函数名中使用哪些字符是不允许的？的详细内容，更多请关注php中文网其它相关文章！

python – cython：不允许在主包之外的相对cimport

driver.pyx:4:0: relative cimport beyond main package is not allowed

myProject/
    setup.py
    __init__.py
    test/
        driver.pyx
        other.pyx
        other.pxd

from setuptools import setup
from distutils.extension import Extension
from Cython.distutils import build_ext

ext_modules = [
    Extension(''other'',[''test/other.pyx''],),Extension(''driver'',[''test/driver.pyx''],]

setup(
    name=''Test'',ext_modules=ext_modules,include_dirs=["test/"],cmdclass={''build_ext'': build_ext},)

#!/usr/bin/env python
from . import other
from . cimport other

#!/usr/bin/env python

HI = "Hello"

cdef class Other:
    def __init__(self):
        self.name = "Test"

    cdef get_name(self):
        return self.name

cdef class Other:
    cdef get_name(self)

ValueError: Attempted relative import in non-package

from setuptools import setup
from distutils.extension import Extension
from Cython.distutils import build_ext

ext_modules = [
    Extension(''other'',include_dirs=["."],)

Python 中函数和变量的作用域

正常的函数和变量是公开的（public），可以被直接引用，比如：abc，x123，PI等；

类似__xxx__这样的变量是特殊变量，可以被直接引用，但是有特殊用途，比如模块中的的__author__，__name__就是特殊变量；

类似_xxx和__xxx这样的函数或变量就是非公开的（private），不应该被直接引用；但Python中并没有一种方法可以完全限制访问非公开的函数或变量，不直接引用是一种约定。

# 非公开，不应直接引用
def _private_1(name):
    return ''Hello, %s'' % name

# 非公开，不应直接引用
def _private_2(name):
    return ''Hi, %s'' % name

# 公开，可以直接引用
def greeting(name):
    if len(name) > 3:
        return _private_1(name)
    else:
        return _private_2(name)

Python3 参数和变量

在 python 中，类型属于对象，变量是没有类型的。

可更改与不可更改对象

在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。

• 不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。

• 可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

python 函数的参数传递：

• 不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。

• 可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响

python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

传不可变对象实例

#!/usr/bin/python3
def ChangeInt( a ):
    a = 10
b = 2
ChangeInt(b)
print( b ) # 结果是 2

实例中有 int 对象 2，指向它的变量是 b，在传递给 ChangeInt 函数时，按传值的方式复制了变量 b，a 和 b 都指向了同一个 Int 对象，在 a=10 时，则新生成一个 int 值对象 10，并让 a 指向它。

传可变对象实例

可变对象在函数里修改了参数，那么在调用这个函数的函数里，原始的参数也被改变了。例如：

#!/usr/bin/python3
# 可写函数说明
def changeme( mylist ):
   "修改传入的列表"
   mylist.append([1,2,3,4]);
   print ("函数内取值: ", mylist)
   return
# 调用changeme函数
mylist = [10,20,30];
changeme( mylist );
print ("函数外取值: ", mylist)

传入函数的和在末尾添加新内容的对象用的是同一个引用。故输出结果如下：

函数内取值:  [10, 20, 30, [1, 2, 3, 4]]
函数外取值:  [10, 20, 30, [1, 2, 3, 4]]

变量作用域

Python 中，程序的变量并不是在哪个位置都可以访问的，访问权限决定于这个变量是在哪里赋值的。

变量的作用域决定了在哪一部分程序可以访问哪个特定的变量名称。Python的作用域一共有4种，分别是：

• L （Local） 局部作用域
• E （Enclosing） 闭包函数外的函数中
• G （Global） 全局作用域
• B （Built-in） 内建作用域

以 L –> E –> G –>B 的规则查找，即：在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，再者去内建中找。

Python 中只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域，其它的代码块（如 if/elif/else/、try/except、for/while等）是不会引入新的作用域的，也就是说这些语句内定义的变量，外部也可以访问，

全局变量和局部变量

定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。

局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。

#!/usr/bin/python3

total = 0; # 这是一个全局变量
# 可写函数说明
def sum( arg1, arg2 ):
    #返回2个参数的和."
    total = arg1 + arg2; # total在这里是局部变量.
    print ("函数内是局部变量 : ", total)
    return total;

#调用sum函数
sum( 10, 20 );
print ("函数外是全局变量 : ", total)

global 和 nonlocal关键字

当内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字了。

以下实例修改全局变量 num：

#!/usr/bin/python3

num = 1
def fun1():
    global num  # 需要使用 global 关键字声明
    print(num) 
    num = 123
    print(num)
fun1()

如果要修改嵌套作用域（enclosing 作用域，外层非全局作用域）中的变量则需要 nonlocal 关键字了，如下实例：

#!/usr/bin/python3
 
def outer():
    num = 10
    def inner():
        nonlocal num   # nonlocal关键字声明
        num = 100
        print(num)
    inner()
    print(num)
outer()

参数

必需参数

必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。

#!/usr/bin/python3
 
#可写函数说明
def printme( str ):
   "打印任何传入的字符串"
   print (str);
   return;
 
#调用printme函数
printme("geng");

关键字参数

关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。

使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。

必须参数要求顺序一致，多余的参数做关键字参数时则不必须顺序一致。

lambda 匿名函数也是可以使用"关键字参数"进行参数传递。

#!/usr/bin/python3
 
#可写函数说明
def printme( str ):
   "打印任何传入的字符串"
   print (str);
   return;
 
#调用printme函数
printme( str = "菜鸟教程");

默认参数

调用函数时，如果没有传递参数，则会使用默认参数。默认参数必须放在最后面，否则会报错。

#!/usr/bin/python3
 
#可写函数说明
def printinfo( name, age = 35 ):
   "打印任何传入的字符串"
   print ("名字: ", name);
   print ("年龄: ", age);
   return;
 
#调用printinfo函数
printinfo( age=50, name="runoob" );
print ("------------------------")
printinfo( name="runoob" );

不定长参数

你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述2种参数不同，声明时不会命名。

#!/usr/bin/python3
 
# 可写函数说明
def printinfo( arg1, *vartuple ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   for var in vartuple:
      print (var)
   return;
 
# 调用printinfo 函数
printinfo( 10 );
printinfo( 70, 60, 50 ); # 70是arg1的值

加了星号（*）的变量名会存放所有未命名的变量参数。如果在函数调用时没有指定参数，它就是一个空元组。我们也可以不向函数传递未命名的变量。

如果存在一个**vardict形式的形式参数，它将接收一个字典（参见映射类型——字典），这个字典包含除形式参数之外的所有关键字参数。
它可以与*vartup形式的形式参数组合，这种形式接收一个元组，这个元组包含除形式参数之外的所有位置参数。(*vartup必须出现在**vardict之前）

def test(**kr):
    return kr
def test2(*z):
    return z
def test3(*kr,**z):
    return kr,z
def test4(a,b=1,e=3,*c,**d):
    return a,b,e,c,d
print(test(a=4,b=2,c=5))    
print(test2(1,2,3,4))
print(test3(''a'',''b'',''c'',a=1,b=3))
print(test4(1,1,2,2,3,4,c=5))
#输出
{''a'': 4, ''b'': 2, ''c'': 5}
(1, 2, 3, 4)
((''a'', ''b'', ''c''), {''a'': 1, ''b'': 3})
(1, 1, 2, (2, 3, 4), {''c'': 5})

我们今天的关于为什么python不允许在函数和变量名中使用连字符？和python变量为什么不能以数字开头的分享已经告一段落，感谢您的关注，如果您想了解更多关于C++ 函数名中使用哪些字符是不允许的？、python – cython：不允许在主包之外的相对cimport、Python 中函数和变量的作用域、Python3 参数和变量的相关信息，请在本站查询。