函数的定义与调用
s="csaicja ics"
def my_len():
i=0
for k in s:
i+=1
print(i)
length=my_len()
print(length)#函数定义了之后可以再任何地方调用#没有返回值，只是单纯的打印
返回的重要性
len()是内置函数
def my_len():
i=0
for k in s:
i+=1
print(i) 是自定义函数
len()的缺点：
#不能变，只是计算s字符串的长度
#只是输出了结果
s="csaicja ics"
def my_len():
i=0
for k in s:
i+=1
print(i)
return i
length=my_len()
print(length)
#返回值的三种情况
#没有返回值
1.不写return
2.只写return：结束一个函数的继续
3.return None——不常用
def func():
l=["haha","hehe"]
for i in l :
print(i)
if i =="haha":
return 跳出整个函数，不打印（“=”*10）
print("="*10)
ret=func() print(ret)
def func():
l=["haha","hehe"]
for i in l :
print(i)
if i =="haha":
break 只是跳出“break”以下的部分，继续打印（“=”*10）
print("="*10)
ret=func()
print(ret)
def func():
l=["haha","hehe"]
for i in l :
print(i)
if i =="haha":
return None
print("="*10)
ret=func()
print(ret)
#返回一个值
1.可以返回任何数据类型
2.只要返回就可以接收到
3.如果在一个程序里有多个return，那么只执行第一个
def func():
return {"k":"v"}
print(func())
def func():
return {"k":"v"}
return [1,2,3]
print(func()) 输出结果{"k":"v"}
#多个返回值def func2():
return 1,2
r1,r2=func2()
print(r1,r2) 输出结果 1 2
def func2():
return 1,2
r1,r2,r3=func2() 错误
print(r1,r2)
def func2():
return 1,2
r=func2()
print(r) 输出结果（1，2）
def func2():
return (1,2,3)
r=func2()
print(r) 输出结果（1，2，3）
#返回多个值
1.多个返回值用多个变量接收：有多少返回值就用多少变量接收
2.用一个变量接收，得到的是一个元组
s="csaicja ics"
def my_len(s): #接收参数，形式参数
i=0
for k in s:
i+=1
print(i)
return i #返回值
length=my_len(s) #传递参数，实际参数
print(length)
#形参与实参的概念
def f1(l1):
for i in l1:
print(i)
def f2(l2):
for i in l2:
print(i)
f1([1,2,3,4,5])
f2([6,7,8,9,10])
def f1(l1): 1
for i in l1: 5
print(i) 6
def f2(l1): 2 f1(l1) 4
for i in l1: 7
print(i) 8
f2([6,7,8,9,10]) 3
def f2(l1): 1 f1(l1) 4
for i in l1: 7
print(i) 8
def f1(l1): 2
for i in l1: 5
print(i) 6
f2([6,7,8,9,10]) 3
def f2(l1):
f1(l1)
for i in l1:
print(i)
f2([6,7,8,9,10]) 错误（f2函数接收到参数，不会再往下走，f1只是调用函数，但没有定义）
def f1(l1):
for i in l1:
print(i)
def my_sum(a,b):
res=a+b
return res #result
ret=my_sum(1,2)
print(ret)
def my_sum(a,b): print（a,b） 1 2 res=a+b
return res
ret=my_sum(b=2，a=1)
print(ret) 输出结果 3
def my_sum(a,b): print(a,b) 2 1 res=a+b
return res
ret=my_sum(1,a=2) 错误
print(ret)
#站在实参的角度上：
#按照位置传参
#按照关键字传参
#混着用可以，但是必须是位置参数在前，关键字参数在后
#不能给同一个变量传多个值
def my_sum(a,b):
res=a+b
return res
ret=my_sum(a=1,2) 错误
print(ret)
def my_sum(a,b):
res=a+b
return res
ret=my_sum(1,2，3) 错误
print(ret)
def classmate(name,sex="男"):
print('{}:{}'.format(name,sex))
classmate("大熊","男")
classmate("小静","女")
classmate("胖虎","男")
classmate("小夫","女") 输出 小夫：女 不受定义参数控制
#只有调用函数的时候
#按照位置传：直接写参数的值
#按照关键字：关键字=值
#定义函数的时候：
#位置参数：直接定义参数
#默认参数，关键字参数：参数值=“默认的值”
def classmate(sex="男"，name): 错误，关键字参数不能在前
print('{}:{}'.format(name,sex))
classmate("大熊","男")
classmate("小静","女")
classmate("胖虎","男")
classmate("小夫",sex="女") 不能都赋给一个参数
定义，传递多个位置参数
def my_sum(*args):
print(args)
n=0
for i in args:
n+=i
return n
ret=my_sum(1,2,3,4,5)
print(ret) 输出结果 15
#动态参数有两种：可以接收任意个参数
#参数名前加*，习惯参数名args，可以变，但必须加*
#参数名前加**，习惯参数名kwargs，可以变，但必须加**
#*args：接收的是按照位置传参的值，组织成一个元组
#**kwargs：接收的是按照关键字传参的值，组织成一个字典
#*args必须在**kwargs之前
#顺序：位置参数，*args，默认参数**kwargs
def func(*args,l=[]):
print(args,l) 输出结果 （1，2，“str”，[1,2,3]）[]
func(1,2,"str",[1,2,3])func(1,2,"str",l=[1,2,3]) (1, 2, 'str') [1, 2, 3]
def func(**kwargs):
print(kwargs)
func(a=1,b=2,c=3)
def func(*args,**kwargs):
print(args,kwargs) 输出结果 （1，2，3，“str”）{“a”：1，“b”：2}
func(1,2,3,"str",a=1,b=2)
def func(*args):
print(args)
func(1,2,3,4,5) 第一种写法
l=[1,2,3,4,5] 第二种写法
func(*l)
def func(**kwargs): 站在形参的角度上，给变量加上**，就是组合所有传来的值
print(kwargs)
func(a=1,b=2) 第一种写法
dic={"a":1,"b":2} 第二种写法，定义一个字典
func(**dic) 站在实参的角度上，给一个序列加上**，就是把这个序列按照顺序打散
#函数的注释
'''
这个函数实现了什么功能
参数1：
参数2：
return：是字符串或列表的长度
'''
#函数的参数
#形参：
#位置参数：必须传
#*args：可以接收任意多个位置参数
#默认参数：可以不传
**kwargs：可以接收多个关键字参数
#实参：按照位置传参，按照关键字传参
#函数名（） #不接收返回值
#返回值=函数名（）#接收返回值
#返回值
#没有返回值，默认返回 None
#不写return：函数内的代码执行完毕自动结束
#只写return，结束一个函数
#return None
#返回一个值：结束了一个函数且返回一个值，可以是任意值
#返回多个值：多个值之间用逗号隔开，接收的时候可以用一个变量接收（元组），也可以用等量的多个变量接收
#默认参数的陷阱
def func(l=[]):
l.append(1)
print(l)
func() [1]
func() [1,1]
func() [1,1,1]
#如果默认参数的值是一个可变数据类型，那么每一次调用函数的时候，如果不传值就公用这个数据类型的资源
def func(l={}):
l["k"]="v"
print(l)
func() {“k”：“v”}
func() {“k”：“v”} 无键添加，有键覆盖
func() {“k”：“v”}
def func(k,l={}):
l[k]="v"
print(l)
func(1)
func(2)
func(3)
{1: 'v'}
{1: 'v', 2: 'v'}
{1: 'v', 2: 'v', 3: 'v'}
#命名空间和作用域
print（）
input（）
list
tuple
#内置命名空间————python解释器
#就是python解释器一启动就可以使用的名字存储在内置命名空间里·
#内置的名字在启动解释器的时候被加载进内存里
#全局命名空间————我们写的代码但不是函数中的代码
#是在程序从上到下被执行的过程中依次加载进内存里
#放置了我们设置的所有的变量名和函数名
#局部命名空间————函数
#就是函数内部定义的名字
#当调用函数的时候才会产生这个名称空间，随着函数执行的结束，这个命名空间就消失了
#在局部：可以使用全局.内置命名空间里的名字
#在全局：可以使用内置命名空间里的名字，但不可以使用局部
def func()
a=1
func()
print(a) 错误 内置不能使用局部
def max(l):
print("in max func")
print(max([1,2,3])) #没有返回值
in max func
None
#正常情况下，直接使用内置的名字
#当我们在全局定义了和内置名字空间中同名的名字时，会使用全局的名字
#当我自己有的时候，我就不找我的上级要了
#如果我自己没有，就找上级要
#如果上一级也没有，就报错
def input():
print("in max func")
def func():
input()
func()
in max func
def input():
print("in max func")
def func():
input=1
print(input)
func()
1
func——>函数的内存地址
#函数名（）函数的调用
||
||
#函数的内存地址（）函数的调用
print（func）
def func1（）：
a=1
def func2（）：
print(a) 错误，不用调用
#多个函数应该拥有多个独立的局部名字空间，不互相共享
#作用域，两种
#全局作用域——作用在全局——内置和全局名字空间中的名字都属于全局作用域
#局部作用域——作用在局部——函数（局部名字空间里的名字只属于局部作用域）
a=1
def func（）
a+=1 错误
#对于不可变数据类型，在局部可以查看全局作用域中的变量，但是不可以修改，如果想要修改，需要在程序的一开始添加global声明
a=1
def func（）
global a
a+=1
func（）
print（a） 2
a=1
b=2
def func():
x="aaa"
y="bbb"
print(locals()) 本地的
func()
print(globals())
{'x': 'aaa', 'y': 'bbb'}
{'a': 1, 'b': 2}
#如果在一个局部函数内声明了一个global变量，那么这个变量在局部的所有操作将对全局的变量有效
#globals永远打印全局的名字
#locals输出什么，根据locals所在的位置
a=1
def func(a):
a=2
return a
a=func(a)
print(a)
2
def max(a,b):
return a if a>b else bmax（1，2） 2
def the_max(a,b,c):函数的嵌套调用
d=max(a,b)
return max(d,c)
print(the_max(1,2,3))
3
#函数的嵌套定义
def outer（）
a=1
def inner()
print(a) a
print("inner") inner
inner（）
outer（）
def outer():
a=1
def inner():
b=1
print(a) 1
print("inner") inner
def inner2():
print(a,b) 1 1
print("inner2") inner2
inner2()
inner()
outer()
a=1
def outer():
a=3
def inner():
b=2
print(a) 3
print("inner") inner
def inner2():
global a 声明了一个全局变量
a+=1 2=1+1 不可变数据类型的修改
print("inner2") inner2
inner2()
inner()
print("**a**",a) **a**，3
outer()
print("全局",a) **全局**，2
#内部函数可以使用外部函数的变量
a=1
def outer():
b=3
def inner():
b=2
print(a)
print("inner")
def inner2():
nonlocal a
a+=1
print("inner2")
inner2()
inner()
print("**a**",a)
outer()
print("全局",a)
SyntaxError: no binding for nonlocal 'a' found
a=1
def outer():
a=3
def inner():
b=2
print(a)
print("inner")
def inner2():
nonlocal a
a+=1
print("inner2")
inner2()
inner()
print("**a**",a)
outer()
print("全局",a)
3
inner
inner2
**a** 4
全局 1
a=1
def outer():
a=3
def inner():
b=2
print(a)
print("inner")
def inner2():
nonlocal a
a+=1
print("inner2")
inner2()
print("##a##",a)
inner()
print("**a**",a)
outer()
print("全局",a)
3
inner
inner2
##a## 4
**a** 4
全局 1
#nonlocal 只能用于局部变量，找上层中距离当前函数最近一层的局部变量
#声明了nonlocal的内部函数的变量修改会影响到离当前函数最近的一层的局部变量
#对全局无效
#对局部也只是对最近的一层有影响
def func（）
print（123）
#func（）#函数名就是内存地址
func2=func #函数名可以赋值
func2（）
l=[func,func2] #函数名可以作为容器类型的元素
print（l） [<function func at 0x02C194B0>, <function func at 0x02C194B0>]内存地址
for i in l：
i（）
def func():
print(123)
#func2=func
#l=[func,func2]
#print(l)
def haha(f):
f()
haha(func) #函数名可以作为函数的参数
def func():
print(123)
#func2=func
#l=[func,func2]
#print(l)
def haha(f):
f()
return f #函数名可以作为函数的返回值
hehe=haha(func)
hehe()
123
123
#闭包：嵌套函数，内部函数调用外部函数的变量
def outer():
a=1
def inner():
print(a)
inner()
outer()
a = 1
def outer():
#a=1
def inner():
print(a)
inner() 不是闭包
outer()
def outer():
a=1
def inner():
print(a)
print(inner.__closure__)
outer()
print(outer.__closure__)
(<cell at 0x012FEBB0: int object at 0x569E6460>,)
None
a=1
def outer():
def inner():
print(a)
print(inner.__closure__)
outer()
print(outer.__closure__)
None
None
def outer():
a = 1
def inner():
print(1)
print(inner.__closure__)
outer()
print(outer.__closure__)
None
None
def outer():
a=1
def inner():
print(a)
return inner
inn=outer()
inn()
a=10
b=20
def tt5(a,b):
a=3
b=5
print(a,b)
c=tt5(b,a)
print(c)
3 5
None
#三元运算
a=1
b=2
c=a if a>b else b
print(c)
变量=条件返回True的结果 if 条件 else 条件返回else的结果
#必须要有结果
#必须有if和else
#只能是简单的情况
###每一个函数 都应只负责一项具体的工作，这样优于使用一个函数来完成两项工作。编写函数时，如果发现它执行的任务太多，请尝试将这些代码划分到多个函数里。别忘了，总是可以在一个函数里调用另一个函数，这有助于将复杂的任务划分成一系列的步骤。
来源：https://www.cnblogs.com/qwer-123/p/11196268.html