更多优质内容
请关注公众号
请关注公众号
本节开始介绍Python中的函数
列表、元组和字符串都可以通过索引得到每一个元素
列表、元组和字符串统称为序列
list() 转为列表
没有参数就生成一个空列表
传参的话可以传字符串和元组
b="abc"
b=list(b)
print(b) #会将每一个字符变成一个元素
类似的还有
tuple(param) 转化为元组
str(param) 将对象转为字符串
如[1,2,3,4]
会转为
'[1,2,3,4]'
len(param) 返回长度
max(param) 返回序列中的最大值,但是列表或者元组里面的元素要是同一类型的，又有数字又有字符串是不行的
sum(param) 返回列表和元组元素值的总和，字符串不行
sorted(param) 排序，可以给字符串排序，返回一个列表
reversed(param) 反转 返回一个迭代器对象，但是可以对其返回值使用list转为列表
enumerate(param) 返回一个迭代器对象
如：
list1=["a","b","c","d","e"]
list(enumerate(list1))
#得到：
#[(0,"a"),(1,"b"),(2,"c"),(3,"d"),(4,"e")]
zip(param) 返回迭代器 如：
a=[1,2,3,4,5,6,7]
b=["a","b","c"]
print(list(zip(a,b)))
#[(1, 'a'), (2, 'b'), (3, 'c')]
自定义函数：
创建函数 def关键字
def 函数名(参数1，参数2，...):
代码块
有返回值用 return 即可
不return就会返回 None
关键字参数：
比如说，
def Myfunc(name,age):
print("名字："+name+" 年龄+"："+age)
然后你可以
Myfunc("zbp",21)
来调用
如果你记不住参数的顺序，可以在调用函数的时候指定关键字
Myfunc(age=21,name="zbp")
还有默认参数，就不说了
收集参数：类似于php的func_get_args()
def Myfunc(*params)
print(params)
调用的时候：
Myfunc(1,"aa",[1,2,3])
此时函数会将params解析为一个元组,你传入Myfunc内也必须传的是一个元组
print(params)时他也会输出一个元组
(1,"aa",[1,2,3])
如果函数又有收集参数，又有其他不同参数
def Myfunc(*args,name)
print(args)
print(name)
此时调用的时候
Myfunc(1,2,3,4,5)
他就会报错
此时应该用关键字参数指定一下实参中哪个参数是属于name的
Myfunc(1,2,3,4,name="zbp")
如果将普通参数放在收集参数之前,也是可以的:
def Myfunc(name,*args)
print(args)
print(name)
Myfunc("zbp",1,2,3)
输出
(1,2,3)
zbp
下面说一下
*
*args
**
**kargs
这4种情况,其中*args说过了,就是传入普通的参数,然后函数将这些参数解析为元组
但是对于*args还提多一点:
def Myfunc(*args,name)
print(args)
print(name)
print(*args)
Myfunc("a","b","c",name="zbp")
第3个print会返回什么:
a b c
我们知道args是一个元组 ("a","b","c")
*args就会将这个元组拆开,变成普通的3个东西
*的用法:
例如,定义一个含三个位置参数的函数”fun”
def fun(a,b,c):
print a,b,c
fun(1,2,3)
#1 2 3 #输出
#可以看到出入三个位置参数调用此函数，会打印出三个参数
#现在我们定义一个含三个整数的列表，并使用’*’来将列表作为参数传入
l = [1,2,3]
fun(*l)
#1 2 3 #输出
可以看出 fun(1,2,3)和fun(*l)的效果是一样的,*的作用就是将列表中的元素分拆为多个单独的参数传到函数当中
**的用法
举例说明:
def fun(a, b, c):
print a, b, c
fun(1,5,7)
# 得到1 5 7
fun(a=1,b=5,c=7)
# 得到1 5 7
d={'b':5, 'c':7}
fun(1, **d)
# 得到1 5 7
使用**的时候,传入的是一个字典,字典的下标是函数的形参名,函数会将字典里的元素一一填进fun()相对应字典下标的形参中
**kwargs用法
举例说明:
def fun(a, **kwargs):
print a, kwargs
fun(1, b=4, c=5)
# 输出 1 {'c': 5, 'b': 4}
fun(45, b=6, c=7, d=8)
# 输出 45 {'c': 7, 'b': 6, 'd': 8}
fun函数只用一个位置参数，因为常规参数中只有一个变量’a’.但是通过”**kwargs”,可以传多个键值参数。
使用**kwargs时,传入常规参数(而且这些常规参数必须设置形参名),函数会将多余的常规参数解析为一个字典
调用的时候 fun(1,2,3,4) 会报错; fun(1,b=2,c=3,d=4)才对
*args 和 **kargs 是两种相似用法,都是传入普通参数,但前者函数将其解析为元组,后者函数将其解析为字典
二者还可以合作:
def fun(a,*args,**kargs):
print(a)
print(args)
print(kargs)
fun(1,3,5,6,s1="hi",s2="hello")
#结果:
#1
#(3, 5, 6)
#{'s1': 'hi', 's2': 'hello'}
对于*args和**kargs你可以不传,但是要传,顺序就不能错
pthyon的函数可以返回多个值
def Myfunc()
return 1,2,3,4,5
其实它返回的只是一个元组而已
作用域：
函数中可以获取到函数外的全局变量的值(不使用global也行)，但是在函数中无法修改函数外的变量的值，如果修改的话，就会报错
如果真的想修改，并且影响到函数外的该变量，可以先用global声明一下
比如：
def Myfunc():
global a
print(a)
a=30
print(a)
a=1
Myfunc()
print(a)
#得到：1 30 30
内嵌函数和闭包：
内嵌函数意思是，允许在函数内定义另一个函数，这个是和js和php不一样的，js和php不会这么干
内嵌函数的缩进就是两个tab了。
外面的那个函数叫做外函数，内部的叫做内函数
比如：
def func1():
print("func1")
def func2():
print("func2")
func2()
注意：func2在func1中定义的话，就只能在func1中调用，无法在func1外调用
说一下内嵌函数的一个点：
如果在内函数想要改变外函数的变量
def func1():
x=5
def func2():
x*=x
return x
return func2()
此时会报错说x没定义
如果加个global
def func1():
x=5
def func2():
global x
x*=x
return x
return func2()
还是会报错，因为x不是全局变量
此时应该用另外一个关键字声明nonlocal
def func1():
x=5
def func2():
nonlocal x
x*=x
return x
return func2()
func1()
得到25
pthyon的闭包和js的闭包不会一个概念
pthyon的闭包有两个条件：
在一个外函数中定义了一个内函数，内函数里运用了外函数的临时变量，并
且外函数的返回值是内函数的引用。这样就构成了一个闭包。
如：
def func1(x):
def func2(y):
print(x+y) #调用了外函数的变量
return func2
#调用闭包
a=func1(5) #此时a的类型是一个function
print(a(10))
#得到15
#或者
func1(5)(10)
lambda表达式：
可以使用lambda表达式定义一个匿名函数：
lambda 参数1,参数2,... : 返回值
比如：
a=lambda x : 2*x+1
print(a(5)) #得到11
两个BIF：
filter() 过滤器，第一参是个函数，第二参是个迭代器对象，会将第二参中的元素放到第一参的函数中处理，
只会返回处理为TRUE的元素。返回值还是个迭代器对象
比如一个只选出奇数的过滤器
list(filter(lambda x:x%2,[1,2,3,4,5,6,7,8,9,10]))
map() 参数和上面的一样。但他不是过滤，而是对每个元素加工
list(map(lambda x:x+2,list1))
但是它不会改变list1本身
