学习日志(三)Python函数

函数知识点思维导图

1.函数的定义及使用

函数代码块以 def 关键词开头&＃xff0c;后接函数标识符名称和圆括号()。

def 函数名(args,*args,**args):#args元组,**args字典函数内容return something#选择性地返回一个值给调用方。不带表达式的return相当于返回 None

创建和调用函数

def funB(a):a&＃61;3return a
a&＃61;2
print(&＃39;调用前&＃39;,id(a))
print(id(funB(a)))
print(&＃39;调用后&＃39;,id(a))def funcB(mylist):mylist.append(100)print(&＃39;修改后的mylist:&＃39;,mylist)return
mylist&＃61;[10,20,30]
print(&＃39;调用前mylist:&＃39;,mylist)
funcB(mylist)
print(&＃39;调用后mylist:&＃39;,mylist)


2.参数传递

python中对一个函数可以传递参数,
但是如何分辨是值传递还是引用传递,不是程序员手动控制的,而是Python根据你传入的数据对象,自动识别的.
如果传入的参数是可变对象:列表,字典,这时候为引用传递

python中对一个函数可以传递参数&＃xff0c;但是如何分辨是值传递还是引用传递&＃xff0c;不是程序员手动控制的&＃xff0c;而是python根据你传入的数据对象&＃xff0c;自动识别的。
如果你传入的参数对象是可变对象&＃xff1a;列表&＃xff0c;字典&＃xff0c;这个时候就是引用传递&＃xff0c;如果参数在函数体内被修改&＃xff0c;那么源对象也会被修改。
如果你传入的参数对象是不可变的对象&＃xff1a;数字&＃xff0c;元组&＃xff0c;字符串&＃xff0c;这个时候就是值传递。那么源对象是不会改变的

2.1参数类型

• 必备参数

必备参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。调用funcA() 函数&＃xff0c;你必须传入一个参数&＃xff0c;不然会出现语法错误

def funcA(str):#必备参数print(str)returnfuncA(&＃39;bxfg&＃39;)

• 关键字参数

def funcA(name,age):print(name)print(age)returnfuncA(age&＃61;30,name&＃61;&＃39;python&＃39;)

• 缺省参数

def funcA(name,age&＃61;421.3):print(name)print(age)returnfuncA(age&＃61;30,name&＃61;&＃39;python&＃39;)funcA(name&＃61;&＃39;python&＃39;)

• 不定长参数

def funcB(x,*args):print(x)print(args)returnfuncB(2,3,4,&＃39;python&＃39;,&＃39;java&＃39;,None)args为元组类型def funcB(x,y,z,*args,**kwargs):print(x,y,z)print(args)print(kwargs)returnfuncB(1,2,3,4,5,c&＃61;6,a&＃61;&＃39;hello&＃39;,b&＃61;10)

3.return返回值

return语句表示退出函数&＃xff0c;在函数中可存在可不存在&＃xff0c;当存在时向调用方返回一个表达式的值

def add(a,b):total &＃61; a &＃43; breturn totalprint(add(10,20))def ass(a,b):total&＃61;a&＃43;bprint(total)returnass(10,20)

4.变量作用域

作用域分为全局变量及局部变量。定义在函数内部的变量拥有一个局部作用域&＃xff0c;定义在函数外的拥有全局作用域。局部变量只能在其被声明的函数内部访问&＃xff0c;而全局变量可以在整个程序范围内访问。调用函数时&＃xff0c;所有在函数内声明的变量名称都将被加入到作用域中。

5.python匿名函数

lambda [arg1 [,arg2,…,argn]]:expression


例:

a&＃61;lambda : &＃39;rongda&＃39;
print(a())a&＃61;lambda x: x**2
print(a(10))b&＃61;lambda x:[i for i in x if i%2&＃61;&＃61;0]
print(b([1,2,3,4,5,6]))sum1&＃61;lambda arg1,arg2:arg1&＃43;arg2
print(sum1(10,20))


练习

1. 输出索引为奇数位的并加入新的列表

def choose(lt):lt1&＃61;[]for i in range(len(lt)):if i%2&＃61;&＃61;1:# print(lt[i])lt1.append(lt[i])print(lt1)returnlt&＃61;[25,15,231,256,2541,21]choose(lt)

1. 冒泡法函数表示

def pao(lt):for i in range(len(lt)-1):for j in range(len(lt)-1-i):if lt[j]>lt[j&＃43;1]:lt[j],lt[j&＃43;1]&＃61;lt[j&＃43;1],lt[j]print(lt)returnpao([12,453,43,123,153])

1. 定义一个函数&＃xff0c;传入列表并判断其长度&＃xff0c;如果大于2&＃xff0c;那么仅仅保留前两个长度的内容&＃xff0c;并将新内容返回给调用者

def length(lt):if len(lt)>2:lt&＃61;lt[0:2]return ltlt&＃61;[3,12,43,45,23]print(length(lt))

1. 定义函数&＃xff0c;传入列表或元组对象,并判断所有奇数位索引对应的元素&＃xff0c;并将其作为新的列表返回给调用者

def choose(lt):lt1&＃61;[]for i in range(len(lt)):if i%2&＃61;&＃61;1:# print(lt[i])lt1.append(lt[i])print(lt1)returnlt&＃61;[25,15,231,256,2541,21]choose(lt)

1. 定义函数&＃xff0c;传入字典判断的每一个value的长度&＃xff0c;如果大于2&＃xff0c;那么仅仅保留前两个长度的内容&＃xff0c;并将新内容返回给调用者

def funcdict(**dict1):for i,j in dict1.items():if len(dict1[i])>2:dict1[i]&＃61;dict1[i][0:2]print(dict1)returnfuncdict(k1&＃61;"python",k2&＃61;[11,22,33,44,55])

5.1 filter函数

​ filter() 函数用于过滤序列&＃xff0c;过滤掉不符合条件的元素&＃xff0c;返回由符合条件元素组成的新列表。 该接收两个参数&＃xff0c;第一个为函数&＃xff0c;第二个为序列&＃xff0c;序列的每个元素作为参数传递给函数进行判&＃xff0c; 然后返回 True 或 False&＃xff0c;最后将返回 True 的元素放到新列表中。

filter(function , iterable) list1&＃61;[1,2,3,4,5,6]
def my_filter(n):return n%2&＃61;&＃61;1
list2&＃61;(filter(my_filter,list1))
print(list(list2))#匿名函数
print(list(filter(lambda x:x%2&＃61;&＃61;1,list1)))

5.2 map函数

map的作用是以参数序列中的每一个元素调用 function函数&＃xff0c;返回包含每次function函数返回值的list

def add(x,y):return x &＃43; y
list1&＃61;map(add, [1,3,5,7,9],[2,4,6,8,10])
print(next(list1))
print(next(list1))
print(next(list1))
print(next(list1))
print(next(list1))

5.3 reduce函数

reduce函数会对参数序列中元素进行总体计算。

from functools import reduce
def add(x,y):return x&＃43;y
list1&＃61;reduce(add, [1,2,3,4,5])
print(list1)

6. 函数扩展

#字符串操作
s&＃61;&＃39;i love you so&＃39;
print(s.ljust(30,&＃39;*&＃39;))#右边补充到30个字符
print(s.rjust(30,&＃39;*&＃39;))#左边补充到30个字符
print(s.center(30,"*"))#两边进行补充
print(s.zfill(22)) #使用0在开头进行补充
print(s.replace(&＃39;love&＃39;,&＃39;like&＃39;,1))
print(s.replace(&＃39;o&＃39;,&＃39;O&＃39;,3))#替换字符
print(s.split(&＃39;y&＃39;))#切割函数&＃xff0c;返回值为列表
print(s.capitalize())#整个字符串中首字母大写
print(s.title())#字符串中每个单词的首字母大写
print(s.swapcase())#字符串中每一个字母大小写反转
print(s.count(&＃39;love&＃39;))#统计字符串中字符的数目
print(s.startswith(&＃39;i&＃39;))#匹配第一个字符,判断字符串第一个字符是否与所传字符相同,返回结果为Boll值
print(s.endswith(&＃39;o&＃39;))#匹配最后字符,判断字符串最后一个字符是否与所传字符相同,返回结果为Boll值
print(s.isalnum())#判断字符串中是否包含数字,返回Boll值
print(s.isalpha())#判断字符串中是否全为字母,返回Boll值,包含空格等其他字符也会返回False
print(s.islower())#判断字符串中是否都为小写字母
print(s.isupper())#判断字符串中是否都为大写字母
print(s.istitle())#判断每个单词的首字母是否为大写#列表操作
lt &＃61; [1,125,3]
print(lt.index(2))#返回元素对应的索引值
lt.reverse()#反转列表
print(lt)
lt[::-1]#同反转列表
print(lt)
lt.sort()#从小到大排
print(lt)
d&＃61;{&＃39;name&＃39;:&＃39;abc&＃39;,&＃39;age&＃39;:123}
print(d.keys())#取出键
print(d.values())#取出值

7. 函数对象

def funcF(x,y,z):print(x,y,z)
funcF(1,2,3)
funcF.b&＃61;&＃39;hello python&＃39;
print(funcF.b)#加点.的方法来给函数对象增加属性

8. 函数闭包

1、概念&＃xff1a; 在一个外函数中定义了一个内函数

​ 内函数里运用了外函数的临时变量

​ 并且外函数的返回值是内函数的引用

2、作用&＃xff1a;保存函数的状态信息&＃xff0c;使函数的局部变量信息依然可以保存下来

def outer(a):#外函数b&＃61;10def inner():#内函数print(a&＃43;b)return inner#外函数的返回值是内函数的引用
demo&＃61;outer(5)
demo()
#或
outer(5)()

9. 装饰器

装饰器的作用是为已存在的函数添加新的功能,缓存,权限等方面运用

1. 通过变量调用该函数

   def hello():print(&＃39;我是最初的hello函数&＃39;)
f&＃61;hello
f()
print(hello.__name__)

2. 函数对象有一个name属性,可以获取函数的名字

   print(hello.__name__)

3. 假设增加hello()函数的功能,且完全不改变原来的代码,并完成功能的添加&＃xff1a;用&＃64;语法,把装饰器至于函数的定义处

   def outer(fune):def inner(*args,**kwargs):print(&＃39;我是%s()函数&＃39;%fune.__name__)return fune(*args,**kwargs)return inner
&＃64;outer#写在谁的前面即装饰哪个函数
def hello():print(&＃39;我是最初的helllo函数&＃39;)
hello()

练习

一.定义一个函数,需求:去除列表中重复的元素

def dele(ls):lm&＃61;[]for i in ls:if i not in lm:lm.append(i)return lm
ls&＃61;[2,13,2,45,13,2,45,13]
print(dele(ls))

二.定义一个函数,需求:合并两个列表

def reunion(x,y):for i in y:x.append(i)return x
x&＃61;[1,2,34,56]
y&＃61;[3,56,12,78]
print(reunion(x,y))

三.定义一个函数, 需求:判断三个数中的最大值

def compare(ls):ls.sort(reverse&＃61;True)return ls[0]
ls&＃61;[12,58,25]
print(compare(ls))

四.定义一个函数, 需求:实现斐波那契数列

def fei(n):ls&＃61;[]a,b&＃61;0,1while b return ls
n&＃61;10000
print(fei(n))

五.lt &＃61; [{‘name’:’a’,’age’:20},{‘name’:’b’,’age’:50},{‘name’:’c’,’age’:12}]&＃xff0c; 请将lt 中元素的age 由大到小排序

lt &＃61; [{&＃39;name&＃39;:&＃39;a&＃39;,&＃39;age&＃39;:20},{&＃39;name&＃39;:&＃39;b&＃39;,&＃39;age&＃39;:50},{&＃39;name&＃39;:&＃39;c&＃39;,&＃39;age&＃39;:12}]
lt.sort(key&＃61;lambda x:x[&＃39;age&＃39;], reverse&＃61;True)
print(lt)


六.将字符串&＃xff1a;”k:1|k1:2|k2:3|k3:4”&＃xff0c;处理成 python 字典&＃xff1a;{‘k’:’1’, ‘k1’:’2’, ‘k2’:’3’,’k3’:’4’ }

s&＃61;&＃39;k:1|k1:2|k2:3|k3:4&＃39;
s_list &＃61; s.split(&＃39;|&＃39;)
# print(s_list)
d&＃61;{}
for i in s_list:key, value &＃61; i.split(&＃39;:&＃39;)# print(key,value)d[key] &＃61; value
print(d)