一:函数
#函数的使用必须遵循:先定义后使用的原则
#函数的定义,与变量的定义是相似的,如果没有事先定义函数而直接引用
#就相当于在引用一个不存在变量名
x=1 变量名==函数名
def func(): 值 == 函数值
print('hello world')
定义阶段: 只检测语法,不执行代码/
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
# #定义阶段 # def foo(): # print('from foo') # bar() # # def bar(): # print('from bar') # # #调用阶段 # foo() #定义阶段:只检测语法,不执行代码 # def func(): # if 2>1: # print('hahahahahahah') # # func() def func(): #语法没问题,逻辑有问题,引用一个不存在的变量名 asdfasdfasdfasdfasdf
定义函数的几种方法:
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
#函数的使用:先定义,后调用 #如何定义函数之定义函数的三种形式 #1 定义无参函数:函数的执行不依赖于调用者传入的参数就能执行时,需要定义为无参函数 # def print_tag(): # print('*************************') # def main(): # print_tag('*',20,3) # print_msg('hello world') # print_tag('*',20,3) # # main() #2 定义有参数:函数的执行需要依赖于调用者传入的参数才能执行时,需要定义为有参函数 # def print_tag(tag,count,line_num): # for i in range(line_num): # print(tag*count) #3 定义空函数:函数体为pass # def func(x,y,z): # pass #如何调用函数? # def func(): # print('from func') # # func()
return返回值类型:
效果:只能返回一次值,终止函数的执行
无return 默认 None; return返回值:如果只有一个则返回本身,多个值则为元组形式
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
返回值:可以返回任意类型 没有return:None return value: value return val1,val2,val3 :(val1,val2,val3) return的效果:只能返回一次值,终止函数的执行 '''
# def func(x): # print('somethings good') # return None # print(func(2)) # def foo(): # return {'a':1},1,'a',[1,2]
形参与实参《定义函数里的参数 def 函数():》
#注意的问题一:位置实参必须在关键字实参的前面
#注意的问题二:实参的形式既可以用位置实参又可以是关键字实参,但是一个形参不能重复传值
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
#形参与实参: # def foo(x,y): #x=1,y=2 # return x+y # # foo(1,2) #===================================part1 #位置参数:按照从左到右的顺序依次定义的参数 def foo(x,y): print(x) print(y) #按位置定义的形参,必须被传值,多一个不行,少一个也不行 # foo(1,2,3) #按位置定义的实参,与形参一一对应 # foo(2,10) #===================================part2 #关键字参数:实参在定义时,按照key=value形式定义 # def foo(x,y): # print(x) # print(y) # # # foo(y=10,x=1) # foo(y=10,x=1) #关键字参数可以不用像位置实参一样与形参一一对应,指名道姓地传值
形参<形式上存在,而实际不存在,变量名> 与实参<实际存在,变量值>:
def foo(x,y): #形参 return x+y foo(1,2) #实参
位置参数:按照从左到右的顺序依次定义的参数
def foo(x,y):
return x+y #按位置定义的形参必须传值,多一个不行,少一个不行
foo(1,2) #按位置定义的实参,与形参一一对应
关键词实参数:实参在定义时,按key=value形式定义
def foo(x,y):
print(x)
print(y)
foo(y=10,x=1) #关键词参数不受位置影响,不像位置实参与形参那样一一对应
注意:位置实参必须在关键字实参前面
既可以用位置实参又可以是关键词实参《实参的形式》,但是一个形参只能被传值一次
默认参数<形参>:定义阶段有值,默认阶段无值
#默认参数需要注意的问题一:必须放在位置形参后面
#默认参数需要注意的问题二:默认参数通常要定义成不可变类型
#默认参数需要注意的问题三:默认参数只在定义阶段被赋值一次
def foo(x,y=10): print(x) print(y)
#形参的应用:值经常变化定义为位置形参,值大多数情况不变则可定义为默认实参
默认参数通常定义为不可变类型
默认参数只在被定义时赋值一次
注意:默认参数必须放在位置形参后面
可变长参数:指实参的个数不固定
#按位置定义的可变长度的实参:* #()元组形式保存 *等同于位置参数
#按关键字定义的可变长度的实参:** #{}字典格式保存
def func(x,y,*args): #x=1.y=2,args=(3,4,5,6) print(x,y) print(args) fuc(1,2,3,4,5,6)
命名关键字参数:
定义在*后的形参,此类形参必须被传值,而且要求实参必须以关键字的形式传入
def register(name,age,**kwargs): print(kwargs) register(name='jason',age=18)
有参函数调用的装饰器为什么是三层?
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
def deco(key): def deco2(func): def wrapper(*args,**kwargs): func(*args,**kwargs) return wrapper return deco2 @deco('key') #--------->有参函数定义的装饰器有三层,f1内部函数消耗一层,deco(f1)消耗一层,deco('key')消耗一层 def f1(): print('kate parry is god')
函数对象:
函数是第一类对象:指的是函数可以被当作数据传递
可被引用
可当作函数的参数
可以当作函数的返回值
可做容器类的元素
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
#函数是第一类对象: 指的是函数可以被当做数据传递 # def func(): # print('from func') # func() # # 可被引用 # f=func -------->当做函数的参数 #可以当做函数的参数 # def func(): # print('from func') # def foo(x): # print(x) # x() # # foo(func) --------->当做函数的参数 #可以当做函数的返回值 # def foo(): # print('from foo') # def bar(): # return foo ----------->当做函数的返回值 #可以当做容器类型的元素 # def select(): # print('select function') # # func_dic={ # 'select':select, ---------->当做容器类型的元素 # } # # # print(func_dic['select']) # func_dic['select']()
函数嵌套调用:
函数内部调用另外一个函数
def max(x,y): if x>y: print(x) if x<y: print(y)
函数调用则是;
def max1(x,y,z): a=max(x,y) b=max(a,z) return b
函数嵌套定义:
def f1():
def f2():
def f3():...
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
def f1(): def f2(): def f3(): print('f3') print('f2') f3() print('f1') f2() f1()
三:名称空间与作用域
名称空间: cmd/python/import this 最后一行有提示<windows中执行>
存放名字与值的绑定关系
分三种:<加载顺序由上到下>
内置名称空间:python解释器自带的名字 ,解释器启动就生成这个空间
全局名称空间:文件级别定义的名字都会存放在全局名称空间,执行python文件时产生
不是内置定义的也不是函数内部的就是全局
局部名称空间:定义在函数内部的名字,局部名称空间只有在调用函数时才会生效
def func(x,y):
z=3
加载顺序:内置名称空间>>>全局名称空间>>>>局部名称空间
取值:局部名称空间>>>全局名称空间>>>>内置名称空间
# # max=10 # def func(): #x=1 # # max=20 # print(max) # # func()
作用域:作用范围 ---->在定义阶段,作用域就固定死了。
分两种:
全局作用域:包含内置名称空间与全局名称空间的名字属于全局范围,
在整个文件的任意位置都能被引用,全局有效
局部作用域:局部名称空间属于局部范围,
只在函数内部可以被引用,局部有效。
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
# x=1 # def foo(): # def f2(): # print(x) # f2() # def bar(): # print(x) # # foo() # bar()
局部作用域------>全局作用域
x=1 def func(): x=2 def f1():pass # print(dir(globals()['__builtins__'])) #全局作用域name # print(locals()) #局部作用域name