标签：use 权限 错误 简单 嵌套使用 color 用户 argument list
函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。
函数能提高应用的模块性，和代码的重复利用率。可以自己创建函数，这被叫做用户自定义函数。
python定义函数使用def关键字，格式如下：
def 函数名(参数列表):
函数体
>>> def hello(): #定义简单函数 ... print(‘hello world‘) ... >>> hello() #执行函数 hello world >>> def yourname(name): #传参函数 ... print(‘your are name is:‘,name) ... >>> yourname(‘qi‘) #执行传参函数 your are name is: qi >>> def multiplication(x,y): #传参运算函数 ... return x*y ... >>> multiplication(8,9) 72
定义一个函数：给函数一个名称，并指定了函数里包含的参数和代码块结构。这个函数的基本结构完成以后。
可以通过另一个函数调用执行，也可以直接从python命令提示符执行
>>> def times(date): ... ‘打印当前时间‘ ... print(date); ... return time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()) ... >>> import time >>> times(‘当前时间是‘) 当前时间是 ‘2017-09-30 23:23:27‘
在 python 中，类型属于对象，变量是没有类型。
可更改(mutable)与不可更改(immutable)对象
在 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 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。不可变实例：
>>> def changeint(x): #定义函数传参赋值 ... x = 100 ... >>> i1 = 200 >>> changeint(i1) #当将定义的变量赋值给函数调用后，原变量还是不变，只是把i1变量的值复制给了x，它们同时指向这个对象。 >>> print(i1) 200
传可变对象实例：
可变对象在函数里修改了参数，那么在调用这个函数的函数里，原始的参数也被改变了。
>>> def changelist(l1,v): #定义列表插入函数 ... l1.insert(2,v) ... return l1 ... >>> list1 = [1,2,3,4] #列表 >>> changelist(list1,‘python‘) #应用外面的列表，即会影响外面列表的内容 [1, 2, ‘python‘, 3, 4] >>> print(list1) #列表内容被改变 [1, 2, ‘python‘, 3, 4]
必须参数：在一个函数指定需要参数时，在执行函数是必须指定参数，否则会报错
关键字参数：使用关键字传递参数时，参数顺序可以随意，解释器会根据参数名来匹配参数传递
默认参数：调用函数时，如果没有传递参数，则会使用默认参数。
不定长参数：如传递列表，元祖，字典时，参数的个数不定长，可以使用（*）代表不定长，
>>> def foo(user): #必须参数 ... print(user,‘去旅游‘) ... >>> foo(‘张三‘) 张三 去旅游 >>> foor() #如不传递参数执行函数会报错 Traceback (most recent call last): File "<stdin>", line 1, in <module> NameError: name ‘foor‘ is not defined >>> def foo(user,action): ... print(action,‘去了‘,user) #通过关键字传递参数给函数实体调用，不用不按顺序 ... >>> foo(‘李四‘,‘上班‘) 上班 去了 李四 >>> def foo(user,action=‘北京‘): #定义默认参数是必须在最后定义 ... print(user,‘来自‘,action) ... >>> foo(‘zhangsan‘,‘shanghai‘) #如指定则输出指定值 zhangsan 来自 shanghai >>> foo(‘shangsan‘) #如指定一个参数则输出默认值 shangsan 来自 北京 >>> def foo(user,where=‘北京‘,action=‘旅游‘): #定义默认参数 ... print(user,‘去‘,where,action) ... >>> foo(‘zhangsan‘,‘shanghai‘,‘gongzuo‘) #指定参数输出 zhangsan 去 shanghai gongzuo >>> foo(‘lisi‘) #如只指定一个参数则使用默认参数 lisi 去 北京 旅游 >>> foo(‘lisi‘,action=‘工作‘) #在有多个默认参数时，需指定参数名传参 lisi 去 北京 工作 >>> foo(‘lisi‘,where=‘上海‘,action=‘学习‘) lisi 去 上海 学习 >>> def show(*args): #不定长传参 ... for i in args: ... print(i) ... >>> show(‘zhangsan‘,‘lisi‘,‘wangwu‘) zhangsan lisi wangwu >>> l1 = [1,2,3,4] >>> show(l1) [1, 2, 3, 4] >>> show(*l1) #在列表传参是必须使用*来不定长传参 1 2 3 4 >>> def show(**kargs): #两参数不定长传参，也就是字典传参 ... for i in kargs.items(): ... print(i) ... >>> show(name=‘zhangsan‘,age=9999) (‘age‘, 9999) (‘name‘, ‘zhangsan‘) >>> dict = {‘k1‘:123,‘k2‘:456,‘k3‘:678} >>> show(dict) #在传参字典时会将字典当一个参数传入会报错 Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: show() takes 0 positional arguments but 1 was given >>> show(**dict) #必须使用（**）将参数分隔传参 (‘k1‘, 123) (‘k2‘, 456) (‘k3‘, 678)
return [表达式] 语句用于退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None。
>>> def foo(): ... 1+1 ... return ... >>> print(foo()) #默认返回None None >>> def foo(): ... 1+1 ... return 0 #指定返回值 ... >>> print(foo()) 0 >>> def foo(): ... return 1+1 ... >>> print(foo()) 2 >>> def foo(): ... print(1+1) ... return 1+2 ... >>> print(foo()) 2 3
Python 中，程序的变量并不是在哪个位置都可以访问的，访问权限决定于这个变量是在哪里赋值的。
变量的作用域决定了在哪一部分程序可以访问哪个特定的变量名称。Python的作用域一共有4种，分别是：
以 L –> E –> G –>B 的规则查找，即：在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，再者去内建中找。
>>> m = ‘girl‘ #全局作用域变量 >>> def func(): ... m = ‘boy‘ #局部作用域变量 ... return m ... >>> func() #优先使用局部作用域变量 ‘boy‘ >>> print(m) #但不改变全局作用域的变量 girl >>> def foo(): ... num = x + 100 #变量x没有定义会报错 ... return num ... >>> foo() Traceback (most recent call last): File "<stdin>", line 1, in <module> File "<stdin>", line 2, in foo NameError: name ‘x‘ is not defined >>> x = 11 #定义一个全局变量 >>> foo() #则函数会调用全局变量 111 >>> num = 100 >>> def func(): ... num = 200 ... x = num + 100 ... return x ... >>> func() 300 >>> n = 10 #全局 >>> def foo(): ... global n #使用global定义局部变量为全局变量，并会覆盖前面的变量值 ... n = 100 ... return n ... >>> foo() 100 >>> print(n) #全局变量值会改变 100 >>> def foo(): #定义一个嵌套函数 ... num = 5 ... def bar(): #嵌套使用闭包作用域变量 ... print(num) ... bar() ... print(num) ... >>> foo() 5 5 >>> def foo(): ... num1 = 20 ... def bar(): ... z = 30 ... print(num1) ... bar() ... print(z) ... >>> foo() 20 Traceback (most recent call last): #而当嵌套内闭包作用域在未定义时引用就会报错 File "<stdin>", line 1, in <module> File "<stdin>", line 7, in foo NameError: name ‘z‘ is not defined >>> def foo(): ... m = 111 ... def bar(): ... n = 222 ... print(m+n) #在bar()函数中的m就是一个既不属于全局域又不属于局部域的闭包变量，它存活在一个函数的名称空间和作用域，即嵌套作用域 ... bar() ... print(m) ... >>> foo() 333 111 def foo(): num2 = 400 def bar(): print(num2) num2 = 333 print(num2) bar() foo() Traceback (most recent call last): #错误原因为num2为不可变类型，此处不能重新定义 File "<stdin>", line 1, in <module> File "<stdin>", line 7, in foo File "<stdin>", line 4, in bar UnboundLocalError: local variable ‘num2‘ referenced before assignment def foo(): num2 = [400] def bar(): print(num2[0]) num2[0] = 333 #如果定义为列表则不会报错了 print(num2[0]) bar() foo() 400 333
python 使用 lambda 来创建匿名函数。
所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。
lambda函数的语法只包含一个语句
lambda [arg1 [,arg2....argn]]:expression
>>> funct1 = lambda x,y:x+y #生成一个匿名函数 >>> print(funct1(10,43)) 53 >>> funct2 = lambda x:x**3 >>> print(funct2(2)) 8 >>> funct3 = lambda x,y=3,z=4:x+y+z #参数可以设置默认值 >>> print(funct3(3)) 10 >>> print(funct3(3,4,5)) 12 >>> print(funct3(3,y=9)) #注意多参数传值时需指定参数名 16 >>> print(funct3(3,z=8,y=9)) 20 >>> list(map(lambda x:x**3,[1,2,3,4,5])) #使map生成序列 [1, 8, 27, 64, 125] >>> list(map(lambda x,y:x+y,[11,22,33,44],[1,2,3,4])) #多个参数传值，如不匹配则以最少为准 [12, 24, 36, 48] >>> list(map((lambda x:x+5),range(10))) #使用迭代器 [5, 6, 7, 8, 9, 10, 11, 12, 13, 14] >>> l1 = [(lambda x:x+5),(lambda x:x**2),(lambda x:x/2)] #生成可变列表 >>> print(l1[0](5),l1[1](3),l1[2](10)) 10 9 5.0 >>> dict1 = {‘k1‘:(lambda x:x**2),‘k2‘:(lambda x:x**3),‘k3‘:(lambda x:x**4)} >>> print(dict1[‘k1‘](2),dict1[‘k2‘](2),dict1[‘k3‘](2)) #生成可变字典 4 8 16
标签：use 权限 错误 简单 嵌套使用 color 用户 argument list
原文地址：http://www.cnblogs.com/zhangxinqi/p/7616610.html
