Python基础教程(七) Python中的函数-张柏沛IT博客

正文内容

Python基础教程(七) Python中的函数

栏目:Python 发布时间:2019-10-30 14:31 浏览量:152

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

 

还有默认参数,就不说了

 

收集参数:类似于phpfunc_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")

3print会返回什么:

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

 

内嵌函数和闭包:

内嵌函数意思是,允许在函数内定义另一个函数,这个是和jsphp不一样的,jsphp不会这么干

内嵌函数的缩进就是两个tab了。

外面的那个函数叫做外函数,内部的叫做内函数

 

比如:

def func1():
    print("func1")
	def func2():
	    print("func2")
	func2()

注意:func2func1中定义的话,就只能在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本身

如果您需要转载,可以点击下方按钮可以进行复制粘贴;本站博客文章为原创,请转载时注明以下信息

张柏沛IT技术博客 > Python基础教程(七) Python中的函数

热门推荐
推荐新闻