python中fun函数_Python基础教程（七） Python中的函数

本节开始介绍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本身