1.函数的定义及使用
函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
def 函数名(args,*args,**args):#args元组,**args字典
函数内容
return something#选择性地返回一个值给调用方。不带表达式的return相当于返回 None创建和调用函数
def funB(a):
a=3
return a
a=2
print('调用前',id(a))
print(id(funB(a)))
print('调用后',id(a))
def funcB(mylist):
mylist.append(100)
print('修改后的mylist:',mylist)
return
mylist=[10,20,30]
print('调用前mylist:',mylist)
funcB(mylist)
print('调用后mylist:',mylist)
2.参数传递
python中对一个函数可以传递参数,
但是如何分辨是值传递还是引用传递,不是程序员手动控制的,而是Python根据你传入的数据对象,自动识别的.
如果传入的参数是可变对象:列表,字典,这时候为引用传递
python中对一个函数可以传递参数，但是如何分辨是值传递还是引用传递，不是程序员手动控制的，而是python根据你传入的数据对象，自动识别的。
如果你传入的参数对象是可变对象：列表，字典，这个时候就是引用传递，如果参数在函数体内被修改，那么源对象也会被修改。
如果你传入的参数对象是不可变的对象：数字，元组，字符串，这个时候就是值传递。那么源对象是不会改变的
2.1参数类型
- 必备参数
必备参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。调用funcA() 函数，你必须传入一个参数，不然会出现语法错误
def funcA(str):#必备参数
print(str)
return
funcA('bxfg')- 关键字参数
def funcA(name,age):
print(name)
print(age)
return
funcA(age=30,name='python')- 缺省参数
def funcA(name,age=421.3):
print(name)
print(age)
return
funcA(age=30,name='python')
funcA(name='python')- 不定长参数
def funcB(x,*args):
print(x)
print(args)
return
funcB(2,3,4,'python','java',None)
args为元组类型
def funcB(x,y,z,*args,**kwargs):
print(x,y,z)
print(args)
print(kwargs)
return
funcB(1,2,3,4,5,c=6,a='hello',b=10)3.return返回值
return语句表示退出函数，在函数中可存在可不存在，当存在时向调用方返回一个表达式的值
def add(a,b):
total = a + b
return total
print(add(10,20))
def ass(a,b):
total=a+b
print(total)
return
ass(10,20)4.变量作用域
作用域分为全局变量及局部变量。定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。
5.python匿名函数
lambda [arg1 [,arg2,…,argn]]:expression
例:
a=lambda : 'rongda'
print(a())
a=lambda x: x**2
print(a(10))
b=lambda x:[i for i in x if i%2==0]
print(b([1,2,3,4,5,6]))
sum1=lambda arg1,arg2:arg1+arg2
print(sum1(10,20))
练习
- 输出索引为奇数位的并加入新的列表
def choose(lt):
lt1=[]
for i in range(len(lt)):
if i%2==1:
# print(lt[i])
lt1.append(lt[i])
print(lt1)
return
lt=[25,15,231,256,2541,21]
choose(lt)- 冒泡法函数表示
def pao(lt):
for i in range(len(lt)-1):
for j in range(len(lt)-1-i):
if lt[j]>lt[j+1]:
lt[j],lt[j+1]=lt[j+1],lt[j]
print(lt)
return
pao([12,453,43,123,153])- 定义一个函数，传入列表并判断其长度，如果大于2，那么仅仅保留前两个长度的内容，并将新内容返回给调用者
def length(lt):
if len(lt)>2:
lt=lt[0:2]
return lt
lt=[3,12,43,45,23]
print(length(lt))- 定义函数，传入列表或元组对象,并判断所有奇数位索引对应的元素，并将其作为新的列表返回给调用者
def choose(lt):
lt1=[]
for i in range(len(lt)):
if i%2==1:
# print(lt[i])
lt1.append(lt[i])
print(lt1)
return
lt=[25,15,231,256,2541,21]
choose(lt)- 定义函数，传入字典判断的每一个value的长度，如果大于2，那么仅仅保留前两个长度的内容，并将新内容返回给调用者
def funcdict(**dict1):
for i,j in dict1.items():
if len(dict1[i])>2:
dict1[i]=dict1[i][0:2]
print(dict1)
return
funcdict(k1="python",k2=[11,22,33,44,55])5.1 filter函数
filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。 该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判， 然后返回 True 或 False，最后将返回 True 的元素放到新列表中。
filter(function , iterable)
list1=[1,2,3,4,5,6]
def my_filter(n):
return n%2==1
list2=(filter(my_filter,list1))
print(list(list2))
#匿名函数
print(list(filter(lambda x:x%2==1,list1)))5.2 map函数
map的作用是以参数序列中的每一个元素调用 function函数，返回包含每次function函数返回值的list
def add(x,y):
return x + y
list1=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+y
list1=reduce(add, [1,2,3,4,5])
print(list1)6. 函数扩展
#字符串操作
s='i love you so'
print(s.ljust(30,'*'))#右边补充到30个字符
print(s.rjust(30,'*'))#左边补充到30个字符
print(s.center(30,"*"))#两边进行补充
print(s.zfill(22)) #使用0在开头进行补充
print(s.replace('love','like',1))
print(s.replace('o','O',3))#替换字符
print(s.split('y'))#切割函数，返回值为列表
print(s.capitalize())#整个字符串中首字母大写
print(s.title())#字符串中每个单词的首字母大写
print(s.swapcase())#字符串中每一个字母大小写反转
print(s.count('love'))#统计字符串中字符的数目
print(s.startswith('i'))#匹配第一个字符,判断字符串第一个字符是否与所传字符相同,返回结果为Boll值
print(s.endswith('o'))#匹配最后字符,判断字符串最后一个字符是否与所传字符相同,返回结果为Boll值
print(s.isalnum())#判断字符串中是否包含数字,返回Boll值
print(s.isalpha())#判断字符串中是否全为字母,返回Boll值,包含空格等其他字符也会返回False
print(s.islower())#判断字符串中是否都为小写字母
print(s.isupper())#判断字符串中是否都为大写字母
print(s.istitle())#判断每个单词的首字母是否为大写
#列表操作
lt = [1,125,3]
print(lt.index(2))#返回元素对应的索引值
lt.reverse()#反转列表
print(lt)
lt[::-1]#同反转列表
print(lt)
lt.sort()#从小到大排
print(lt)
d={'name':'abc','age':123}
print(d.keys())#取出键
print(d.values())#取出值7. 函数对象
def funcF(x,y,z):
print(x,y,z)
funcF(1,2,3)
funcF.b='hello python'
print(funcF.b)#加点.的方法来给函数对象增加属性8. 函数闭包
1、概念： 在一个外函数中定义了一个内函数
内函数里运用了外函数的临时变量
并且外函数的返回值是内函数的引用
2、作用：保存函数的状态信息，使函数的局部变量信息依然可以保存下来
def outer(a):#外函数
b=10
def inner():#内函数
print(a+b)
return inner#外函数的返回值是内函数的引用
demo=outer(5)
demo()
#或
outer(5)()9. 装饰器
装饰器的作用是为已存在的函数添加新的功能,缓存,权限等方面运用
通过变量调用该函数
def hello(): print('我是最初的hello函数') f=hello f() print(hello.__name__)函数对象有一个name属性,可以获取函数的名字
print(hello.__name__)假设增加hello()函数的功能,且完全不改变原来的代码,并完成功能的添加：用@语法,把装饰器至于函数的定义处
def outer(fune): def inner(*args,**kwargs): print('我是%s()函数'%fune.__name__) return fune(*args,**kwargs) return inner @outer#写在谁的前面即装饰哪个函数 def hello(): print('我是最初的helllo函数') hello()
练习
一.定义一个函数,需求:去除列表中重复的元素
def dele(ls):
lm=[]
for i in ls:
if i not in lm:
lm.append(i)
return lm
ls=[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=[1,2,34,56]
y=[3,56,12,78]
print(reunion(x,y)) 三.定义一个函数, 需求:判断三个数中的最大值
def compare(ls):
ls.sort(reverse=True)
return ls[0]
ls=[12,58,25]
print(compare(ls)) 四.定义一个函数, 需求:实现斐波那契数列
def fei(n):
ls=[]
a,b=0,1
while b < n:
ls.append(b)
a,b=b,a+b
return ls
n=10000
print(fei(n)) 五.lt = [{‘name’:’a’,’age’:20},{‘name’:’b’,’age’:50},{‘name’:’c’,’age’:12}]， 请将lt 中元素的age 由大到小排序
lt = [{'name':'a','age':20},{'name':'b','age':50},{'name':'c','age':12}]
lt.sort(key=lambda x:x['age'], reverse=True)
print(lt)
六.将字符串：”k:1|k1:2|k2:3|k3:4”，处理成 python 字典：{‘k’:’1’, ‘k1’:’2’, ‘k2’:’3’,’k3’:’4’ }
s='k:1|k1:2|k2:3|k3:4'
s_list = s.split('|')
# print(s_list)
d={}
for i in s_list:
key, value = i.split(':')
# print(key,value)
d[key] = value
print(d)