初始函数
一、定义函数
s="太白金鑫老师" def my_len(): #def定义函数关键字 my_len()函数名 i=0 for k in s: i+=1 print(i) my_len() #调用函数
函数特点:
1、定义了之后,可以在任何需要他的地方调用
2、没有返回长度,只是单纯的打印
len()
1、不能变,只能计算s字符串的长度
2、只是输出了结果
自定义函数:
s="太白金鑫老师" def my_len(): #自定义函数 i=0 for k in s: i+=1 return i #返回值 length=my_len() print(length)
二、返回值的三个情况:
没有返回值 —— 返回None
不写return
只写return:结束一个函数的继续
return None —— 不常用
返回1个值
可以返回任何数据类型
只要返回就可以接收到
如果在一个程序中有多个return,那么只执行第一个
返回多个值
用多个变量接收:有多少返回值就用多少变量接收
用一个变量接收: 得到的是一个元组
def func(): l = ['金老板','二哥'] for i in l: print(i) if i=='金老板': return None print('='*10) ret = func() print(ret)
三、参数
def my_len(s): #自定义函数只需要0个参数,接收参数,形式参数,形参 i = 0 for k in s: i += 1 return i #返回值 ret = my_len('金老板小护士') #传递参数:传参,实际参数,实参 ret = my_len([1,2,3,4,5]) #传递参数:传参 print(ret)
参数三种情况
没有参数
定义函数和调用函数时括号里都不写内容
有一个参数
传什么就是什么
有多个参数
位置参数
def my_sum(a,b): print(a,b) res = a+b #result return res ret = my_sum(1,2) print(ret)
站在实参的角度上:
按照位置传参
按照关键字传参
混着用可以:但是 必须先按照位置传参,再按照关键字传参数
不能给同一个变量传多个值
站在形参的角度上:
位置参数:必须传,且有几个参数就传几个值
默认参数: 可以不传,如果不传就是用默认的参数,如果传了就用传的
#默认参数 def classmate(name,sex='男'): print('%s : %s'%(name,sex)) classmate('二哥') classmate('小孟') classmate('大猛') classmate('朗哥','女')
调用函数的时候
按照位置传 : 直接写参数的值
按照关键字: 关键字 = 值
定义函数的时候:
位置参数 : 直接定义参数
默认参数,关键字参数 :参数名 = '默认的值'
动态参数 : 可以接受任意多个参数
参数名之前加*,习惯参数名args,
参数名之前加**,习惯参数名kwargs
顺序:位置参数,*args,默认参数,**kwargs
#关键字传参 def classmate(name,sex): print('%s : %s'%(name,sex)) classmate('二哥','男') classmate(sex='男',name = '二哥')
注意:使用关键字传参,位置随意放
#默认值传参 def classmate(name,sex='男'): #默认性别为男 print('%s : %s'%(name,sex)) classmate('二哥') #使用默认值 classmate('朗哥',sex= '女') #使用实参女
注意:没有特意强调就用默认值,提供实参就用传递的值
动态参数有两种:可以接受任意个参数
*args : 接收的是按照位置传参的值,组织成一个元组
**kwargs: 接受的是按照关键字传参的值,组织成一个字典
args必须在kwargs之前
#添加无数多个值都行 def sum(*args): n = 0 for i in args: n+=i return n print(sum(1,2)) #3 print(sum(1,2,3)) #6 print(sum(1,2,3,4)) #10
注意:*args : 接收的是按照位置传参的值,组织成一个元组
def func(**kwargs): print(kwargs) func(a = 1,b = 2,c =3) #{'a': 1, 'c': 3, 'b': 2} func(a = 1,b = 2) #{'a': 1, 'b': 2} func(a = 1) #{'a': 1}
注意:**kwargs: 接受的是按照关键字传参的值,组织成一个字典
def func(*args,default = 1,**kwargs): print(args,kwargs) func(1,2,3,4,5,default=2,a = 'aaaa',b = 'bbbb',) #*args 位置传参的值,组织成一个元组;**kwargs:关键字传参的值,组织成一个字典 #调用结果:(1, 2, 3, 4, 5) {'a': 'aaaa', 'b': 'bbbb'}
注意:args必须在kwargs之前
动态参数的另一种传参方式:
def func(*args):#站在形参的角度上,给变量加上*,就是组合所有传来的值。 print(args) func(1,2,3,4,5) l = [1,2,3,4,5] func(*l) #站在实参的角度上,给一个序列加上*,就是将这个序列按照顺序打散
四、函数的注释:
def func():
'''
这个函数实现了什么功能
参数1:
参数2:
:return: 是字符串或者列表的长度
'''
pass
五、三元运算
变量=条件返回True的结果 if条件 else 条件返回False的结果
#返回最大值 def func(a,b): c=a if a>b else b return c print(func(1,5))
注意点:
1)、必须要有结果
2)、必须要有if 和else
3)、只能是简单的情况
六、命名空间
1、内置命名空间-------python解释器
#就是python解释器一启动,就可以使用的名字存储在内置命名空间中。
#内置的名字启动解释器的时候被加载进内存里
2、全局命名空间-------我们写的代码但不是函数中的代码
#是在程序从上至下被执行的过程中依次加载在内存的
#放置了我们设置的所有变量名和函数
3、局部命名空间-------函数
#就是函数内部定义的名字
#当调用这个函数的时候,才会产生这个名称空间,随着函数执行的结束,这个命名空间有有消失啦。
注意:
在局部,可以使用全局,内置命名空间中的名字;
在全局,可以使用内置命名空间中的名字,但是不能用局部中使用
在内置,不能使用全局和局部的名字的
def max(l): print('in max func') print(max([1,2,3])) #in max func #None
注意:
#在正常情况下,直接使用内置的名字
#当我们在全局定义了和内置名字空间中同名的名字时,会使用全局的名字
#当我自己有的时候 我就不找我的上级要了
#如果自己没有 就找上一级要 上一级没有再找上一级 如果内置的名字空间都没有 就报错
# 多个函数应该拥有多个独立的局部名字空间,不互相共享
func --> 函数的内存地址
#函数名() 函数的调用
#函数的内存地址() 函数的调用
七、作用域
作用域两种
全局作用域 —— 作用在全局 —— 内置和全局名字空间中的名字都属于全局作用域 ——globals()
局部作用域 —— 作用在局部 —— 函数(局部名字空间中的名字属于局部作用域) ——locals()
a = 1 def func(): global a a = 2 func() print(a) #2
注意点:
1)、对于不可变数据类型 在局部可以查看全局作用域中的变量,但是不能直接修改
2)、如果想要修改,需要在程序的一开始添加global声明
3)、如果在一个局部(函数)内声明了一个global变量,那么这个变量在局部的所有操作将对全局的变量有效
globals: 永远打印全局的名字
locals: 输出什么 根据locals所在的位置
八、函数的嵌套和作用域链
函数的嵌套定义:内部函数可以使用外部函数的变量
def max(a,b): return a if a>b else b def the_max(x,y,z): #函数的嵌套调用 c = max(x,y) return max(c,z) print(the_max(1,2,3))
a = 1 def outer(): a = 1 def inner(): a = 2 def inner2(): nonlocal a #声明了一个上面第一层局部变量 a += 1 #不可变数据类型的修改 inner2() print('##a## : ', a) inner() print('**a** : ',a) outer() print('全局 :',a)
nonlocal:
1)、只能用于局部变量,找上层中离当前函数最近一层的局部变量
2)、声明了nonlocal的内部函数的变量修改会影响到 离当前函数最近一层的局部变量
3)、对全局无效
4)、对局部 也只是对 最近的 一层 有影响
函数名的用法:
1)、函数名就是内存地址
2)、函数名可以赋值
3)、函数名可以作为容器类型的元素
4)、函数名可以作为函数的返回值
5)、函数名可以作为函数的参数
九、闭包
闭包:嵌套函数,内部函数调用外部函数的变量
def outer(): a = 1 def inner(): print(a) return inner inn = outer() inn() #1