一：函数
#函数的使用必须遵循：先定义后使用的原则
#函数的定义，与变量的定义是相似的,如果没有事先定义函数而直接引用
#就相当于在引用一个不存在变量名
x=1 变量名==函数名
def func(): 值 == 函数值
print('hello world')
定义阶段： 只检测语法，不执行代码/
# #定义阶段 # def foo(): # print('from foo') # bar() # # def bar(): # print('from bar') # # #调用阶段 # foo() #定义阶段:只检测语法，不执行代码 # def func(): # if 2>1: # print('hahahahahahah') # # func() def func(): #语法没问题，逻辑有问题，引用一个不存在的变量名 asdfasdfasdfasdfasdf
定义函数的几种方法：
#函数的使用：先定义，后调用 #如何定义函数之定义函数的三种形式 #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返回值：如果只有一个则返回本身，多个值则为元组形式
返回值：可以返回任意类型 没有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 函数（）：》
#注意的问题一：位置实参必须在关键字实参的前面
#注意的问题二：实参的形式既可以用位置实参又可以是关键字实参，但是一个形参不能重复传值
#形参与实参： # 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)
有参函数调用的装饰器为什么是三层？
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')
函数对象:
函数是第一类对象：指的是函数可以被当作数据传递
可被引用
可当作函数的参数
可以当作函数的返回值
可做容器类的元素
#函数是第一类对象： 指的是函数可以被当做数据传递 # 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():...
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()
作用域：作用范围 ---->在定义阶段，作用域就固定死了。
分两种：
全局作用域：包含内置名称空间与全局名称空间的名字属于全局范围，
在整个文件的任意位置都能被引用，全局有效
局部作用域：局部名称空间属于局部范围，
只在函数内部可以被引用，局部有效。
# 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
