标签：解释器 app print strong 处理 class 创建 font 未定义
函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。函数能提高应用的模块性，和代码的重复利用率。Python提供了许多内建函数。但我们可以创建函数，这被叫做用户自定义函数。
在python中使用def关键字定义函数具体格式如下：
def 函数名 (参数)：
代码块
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
在 python 中，类型属于对象，变量是没有类型的，它仅仅是一个对象的引用（一个指针）。
python 函数的参数传递：
不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比
如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。
可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响
python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。
不可变类型传递：
1 def ChangeInt( a ): 2 a = 10 3 4 b = 2 5 ChangeInt(b) 6 print( b ) # 结果是 2
可变类型传递：
2 def changeme( mylist ): 3 "修改传入的列表" 4 mylist.append([1,2,3,4]) 5 print ("函数内取值: ", mylist) 6 return 7 8 # 调用changeme函数 9 mylist = [10,20,30] 10 changeme( mylist ) 11 print ("函数外取值: ", mylist)
参数类型
参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
关键字参数
关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。
使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。
1 def printinfo( name, age ): 2 "打印任何传入的字符串" 3 print ("名字: ", name) 4 print ("年龄: ", age) 5 return 6 7 #调用printinfo函数 8 printinfo( age=50, name="lisi" )
调用函数时，如果没有传递参数，则会使用默认参数。以下实例中如果没有传入 age 参数，则使用默认值：
def printinfo( name, age = 35 ): "打印任何传入的字符串" print ("名字: ", name) print ("年龄: ", age) return #调用printinfo函数 printinfo( age=50, name="lisi" ) print ("------------------------") printinfo( name="lisi" ) # 输出结果 名字: runoob 年龄: 50 ------------------------ 名字: runoob 年龄: 35
你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述 2 种参数不同，声明时不会命名。
加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。
def printinfo( arg1, *vartuple ): "打印任何传入的参数" print ("输出: ") print (arg1) print (vartuple) # 调用printinfo 函数 printinfo( 70, 60, 50 ) 以上实例输出结果： 输出: 70 (60, 50)
加了两个星号 ** 的参数会以字典的形式导入。
def printinfo( arg1, **vardict ): "打印任何传入的参数" print ("输出: ") print (arg1) print (vardict) # 调用printinfo 函数 printinfo(1, a=2,b=3) 输出: 1 {‘a‘: 2, ‘b‘: 3}
python 使用 lambda 来创建匿名函数。
所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。
lambda 函数的语法只包含一个语句，如下：
lambda [arg1 [,arg2,.....argn]]:expression
sum = lambda arg1, arg2: arg1 + arg2 # 调用sum函数 print ("相加后的值为 : ", sum( 10, 20 )) print ("相加后的值为 : ", sum( 20, 20 ))
return
return [表达式] 语句用于退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None。
def sum( arg1, arg2 ): # 返回2个参数的和." total = arg1 + arg2 print ("函数内 : ", total) return total # 调用sum函数 total = sum( 10, 20 ) print ("函数外 : ", total)
Python 中，程序的变量并不是在哪个位置都可以访问的，访问权限决定于这个变量是在哪里赋值的。
变量的作用域决定了在哪一部分程序可以访问哪个特定的变量名称。Python的作用域一共有4种，分别是：
以 L –> E –> G –>B 的规则查找，即：在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，再者去内建中找。
x = int(2.9) # 内建作用域
g_count = 0 # 全局作用域
def outer():
o_count = 1 # 闭包函数外的函数中
def inner():
i_count = 2 # 局部作用域
Python 中只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域，其它的代码块（如 if/elif/else/、try/except、for/while等）是不会引入新的作用域的，也就是说这些语句内定义的变量，外部也可以访问，如下代码：
>>> if True:
... msg = ‘I am from Runoob‘
...
>>> msg
‘I am from Runoob‘
>>>
实例中 msg 变量定义在 if 语句块中，但外部还是可以访问的。
如果将 msg 定义在函数中，则它就是局部变量，外部不能访问：
>>> def test():
... msg_inner = ‘I am from Runoob‘
...
>>> msg_inner
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name ‘msg_inner‘ is not defined
>>>
从报错的信息上看，说明了 msg_inner 未定义，无法使用，因为它是局部变量，只有在函数内可以使用。
定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。
局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。如下实例：
total = 0 # 这是一个全局变量 def sum( arg1, arg2 ): #返回2个参数的和." total = arg1 + arg2 # total在这里是局部变量. print ("函数内是局部变量 : ", total) return total #调用sum函数 sum( 10, 20 ) print ("函数外是全局变量 : ", total)
以上实例输出结果：
函数内是局部变量 : 30
函数外是全局变量 : 0
当内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字了。
以下实例修改全局变量 num：
num = 1 def fun1(): global num # 需要使用 global 关键字声明 print(num) num = 123 print(num) fun1() print(num)
以上实例输出结果：
1
123
123
如果要修改嵌套作用域（enclosing 作用域，外层非全局作用域）中的变量则需要 nonlocal 关键字了，如下实例：
def outer(): num = 10 def inner(): nonlocal num # nonlocal关键字声明 num = 100 print(num) inner() print(num) outer()
以上实例输出结果：
100
100
标签：解释器 app print strong 处理 class 创建 font 未定义
原文地址：https://www.cnblogs.com/lizhihoublog/p/10142748.html
