一、函数基础 上
1.1 函数简介 function
input(),print(),range()函数等等
现在的代码可复用性非常差
函数是干嘛的?就是存数据的
总结我们函数的优点:
1.遇到重复功能的时候,直接调用就可以,减少代码量
2.提升代码,项目的结构性,分工明确,提高代码的可读性
3.遇到扩展功能时,修改比较方便
自定义函数,将一段有规律的、可重复使用的代码定义成函数,一次编写,多次调用
n = 0
for i in 'https://www.baidu.com/':
n += 1
print(n)
print(len('https://www.baidu.com/'))
函数的本质就是一段有特定功能、可以重复使用的代码
这段代码已经被提前编写好了,并且起了一个好听的名字
def my_len(str):
lenght = 0
for c in str:
lenght += 1
return lenght
lenght = my_len('https://www.baidu.com/')
print(lenght)
1.2 函数的定义
定义函数
def 函数名(形参1,形参2,形参n):
代码块
1.3 函数的调用
语法: 函数名()
要先创建,在调用
def fn():
print('这是我的第一个函数')
print('hello')
print('吃了吗')
print('再见')
fn()
注意:
fn 是什么 函数对象
fn() 是什么 调用函数
print 是什么 函数对象
print() 是什么 调用函数
练习:
定义一个login函数,功能是输入用户名和密码,验证是否正确
def login():
username = input('用户名:')
password = input('密码:')
if username == 'root' and password == '123':
print('登陆成功')
else:
print('登陆失败')
login()
1.4函数的参数
1.4.1 形参和实参
参数可以分为有参和无参
什么是无参?就是在定义函数时,括号里面没有东西就是无参
有参指的就是括号里面有参数
定义函数一般都是需要实现某种功能的
定义一个函数,可以用来求任意两个数的和
def sum():
print(1+1)
sum()
def sum():
a = 66
b = 99
print(a+b)
sum()
函数的参数:在定义函数时,可以再函数名后()中定义数量不等的形参,注意 :可以有也可以没有,可以有一个也可以有很多个,多个形参之间我们使用逗号隔开
什么叫形参? 形式参数,定义形参就相当于在函数内部声明了变量,但是没有赋值
实参:实际参数,在函数定义时制定了形参,在调用的时候必须传递实参,实参会赋值给对应的形参,有几个形参就必须传递几个实参
fn(a,b):
print('a=',a)
print('b=',b)
fn(666,888)
def sum(a,b):
print(a,'+',b,'=',a+b)
sum(5.5,1.4)
总结:我们在定义函数的时候叫形参,为什么叫形参,因为那个参数是形式的,并没有值,需要调用的时候才可以确定值
调用的时候叫实参
注意:定义了多少个形参就要传递多少个实参
1.4.2 参数的传递方式
参数呢他在传递的时候也是有不同的方式,在形参中,有我们的一个默认值参数
def fn(a,b,c=10):
print('a=',a)
print('b=',b)
print('c=',c)
fn(1,2)
1.4.3 位置参数和关键字参数
1.位置参数就是将对应位置的实参赋值给对应位置的形参
def ms(年龄,姓名,手机号,qq号,微信号,国家,父亲名字,省份,母亲名字)
pass
ms()
2.关键字参数:可以不按照形参定义的顺序来传递,而是直接会根据参数名来传递参数
def fn(a,b,c):
print('a=',a)
print('b=',b)
print('c=',c)
fn(a=2,c=3,b=2)
好处是什么:不需要记忆我们参数的一个顺序,只需要记住名字就可以了
位置参数和关键字参数可以混合使用
混合使用关键字和位置参数时,位置参数必须在关键字参数的前面
2.4.4实参的类型
函数在调用的时候不会限制你的类型,实参可以传递任意类型
def fn(a):
print('a=',a)
b = [True]
b = fn
fn(b)
a= <function fn at 0x000002880C7385E0>
实参可以是任意一个类型,什么都行
二、函数基础下
2.1 函数参数
2.1.1 * args
定义函数时,可以再形参的前面加一个 * 号,我们的形参就能获得我们所有实参。这个 * 代表所有的意思 他会将我们所有的实参保存到一个元组当中
def fn(*a):
print(a)
print(type(a))
fn(1,2,3,4,5)
(1, 2, 3, 4, 5)
<class 'tuple'>
*a能接受所有的实参,并且将实参保存到一个元祖中
装包,我们把这些散开的数据,转到一个元祖中,这就叫装包
好处就是相传几个就是几个,不传也可以
def sum(*a):
result = 0 #初始化
for i in a:
result += i #result = result + i
print(result)
sum(1,2,3,4,5,6,7,8,9)
45
#带*号的形参只有一个,因为你写多了就没法分值
#带*号的参数可以和其他参数配合使用,但是得写在最后面
def fn(a,b,*c):
print('a=', a)
print('b=', b)
print('c=', c)
fn(1,2,3,4,5,6,7,8,9,10)
def fn(*a,b,c):
print('a=', a)
print('b=', b)
print('c=', c)
fn(1,2,3,4,5,6,7,8,b=9,c=10)
a= 1
b= 2
c= (3, 4, 5, 6, 7, 8, 9, 10)
a= (1, 2, 3, 4, 5, 6, 7, 8)
b= 9
c= 10
使用带 * 号的参数一般取名为args
*args弊端就是只能接受位置参数
2.1.2 * * kwargs
def fn(**args):
print('args=',args)
print(type(args))
fn(a=1,b=2,c=3)
args= {'a': 1, 'b': 2, 'c': 3}
<class 'dict'>
总结:
**形参可以接收任意的关键字参数,会将这些参数统一保存到字典当中,字典的键就是参数的名字,字典的值就是参数的值,所以现在这个键a值是1,b值是2,c值是3
注意:**形参也是只能有一个,并且必须写在所有参数最后,他必须得是最后一个,他的命名潜规则是kwargs
2.1.3 同时使用不定长参数
**当要同时使用 * args和 * *kwargs的时候, * args是必须写在 * *kwargs的前面,这是规定
def fn(a,b,*args,**kwargs):
print(a)
print(b)
print(args)
print(kwargs)
fn(1,2,3,4,5,6,1,6,3,k=1,ww=3,c=5)
1
2
(3, 4, 5, 6, 1, 6, 3)
{'k': 1, 'ww': 3, 'c': 5}
2.1.4 参数的解包
def fn(a,b,c,d,e,f):
print('a=', a)
print('b=', b)
print('c=', c)
print('d=', d)
print('e=', e)
print('f=', f)
t = (1,2,3,4,5,6)
# fn(t[0],t[1],t[2])
fn(*t)
a= 1
b= 2
c= 3
d= 4
e= 5
f= 6
传递实参时,也可以在序列类型的参数前面添加 * 号,这样会自动将序列中的元素依次作为参数传递
注意:序列中的元素的个数必须和我们函数形参的个数一致
def fn(a,b,c):
print('a=', a)
print('b=', b)
print('c=', c)
# fn(*[1,2,3]) # 列表也行
fn(*[1,2,3,4]) # 报错, 序列元素和形参必须一致
a= 1
b= 2
c= 3
def fn(a,b,c):
print('a=', a)
print('b=', b)
print('c=', c)
d = {'a':10, 'b':20, 'c':30}
fn(**d)
总结:
1.*args适用于接收多个未命名的位置参数,**kwargs用于接收关键字参数,其中args是一个元组类型,而kwargs是一个字典类型的数据
2.*args也就是把元组中的数据拆分成单个的数据
**kwargs吧字典中的数据拆分成单个的键值对
2.2 函数的返回值
返回值就是函数执行以后返回的结果
f(x) = 2x+1
x=1 ==>3 f(1)=3
x=2 ==>5 f(2)=5
def fn():
return [1,2,3,4]
# 获取返回值我们的方式是 把函数调用当做一个值来输出
x = fn()
print(x)
print(fn())
return后面是什么, 返回的结果就是什么
return后面可以是任意的值,包括函数,跟什么就返回什么
无论定义的是返回什么类型,return只能返回单个值,但是值可以有多个元素
def fn1():
return [1,3,5]
print(fn1())
print(type(fn1()))
def fn2():
return ('1,3,5')
print(fn2())
print(type(fn2()))
(1, 3, 5)
<class 'tuple'>
[1, 3, 5]
<class 'list'>
1,3,5
<class 'str'>
def fn():
def fn2():
print('hello')
return fn2
r = fn()
print(r)
r()
<function fn.<locals>.fn2 at 0x00000175C0F389D0>
hello
None是python一个特别空值,用来代表空的
def fn():
pass
print(fn()) # None ==> 空值,不可以理解为0
print(type(None))
None
<class 'NoneType'>
如果不给一个函数返回值,那么他的返回值就是空的None
只要函数不带return,那么返回的是None
def fn():
return
print(fn())
总结:如果仅仅写一个return或者不写return,就等价于return None
None是python一个特别空值,用来代表空的
def fn():
print('抄一遍')
print('抄两遍')
print('抄三遍')
return
print('抄四遍')
fn()
抄一遍
抄两遍
抄三遍
在函数中,return代表函数执行结束
def fn():
for i in range(1,101):
if i == 66:
print('分手心痛了,提前结束')
#break
return
print(f'抄{i}遍')
fn()
break:退出当前循环
continue;跳过本次循环,但是对于后面没有影响
return:用来结束函数
def sum(*args):
result = 0
for i in args:
result += i
return result
r = sum(1,2,3,4)
print(r+10)
print(print())
a = len('hello')
print(a)
fn()和fn的区别:
fn==》函数对象,打印它其实就是在打印函数对象
fn()==》调用函数,打印fn()其实就是在打印fn()的返回值
总结;
return语句的作用
结束函数调用,返回值
函数体中return语句有指定的返回值 时 返回的是 其值
函数体中没有return语句,函数运行结束会隐含返回一个None作为返回值,类型是Nonetype,与return,returnNone等效,都是返回None
print和return
print仅仅是打印在控制台上,而return则是将return后面的部分作为返回值,作为函数的输出,可以用来变量接收,继续使用这个返回值做其他事
三、匿名函数和递归函数
3.1 匿名函数 lambda
lambda 参数列表:运算表达式
def fn(x):
return x*x
print(fn(5))
f = lambda x:x*x
print(f(5))
总结:
1.lambda并不会带来程序运行效率的提高,只会使代码更加的简洁
2.如果使用lambda,lambda内不要有循环,因为可读性不好,有的话请使用标准函数来完成,目的是为了代码有可重用性和可读性
3.lambda只是为了减少单行函数的定义而存在,如果一个函数只有一个返回值,只有一句代码,就可以使用lambda
3.2 高阶函数
3.2.1 简介
高阶函数其实就是把函数作为参数传入
就是把一个函数作为另一个函数的参数传入
abs()==》完成对数字绝对值计算
print(abs(-5))
sum()==》求和
sum(可迭代对象,指定一个相加的参数如果没有默认为0)
print(sum([1,2,3,4,5]))
print(sum((1,2,3,4,5),1))
round()==》四舍五入
print(round(4.3))
print(round(4.8))
print(round(4.5)) # 4 坑
https://www.cnblogs.com/bigc008/p/9682105.html
任意两个数字,对两个数字求绝对值后进行求和
def ab_sum(a,b,f):
return f(a)+f(b)
res = ab_sum(-1,-4,abs) #把abs作为参数传入到函数里面,传的是函数本身不是传函数调用
print(res)
def xfs(x):
return -x
def ab_sum(a,b,f): # f是一个函数参数
return f(a)+f(b)
res = ab_sum(-1,-4,xfs) # 求的是相反数的和
print(res)
函数作为参数的函数
函数三剑客:map , reduce filter
3.2.2 map()
map(func,seq)第一个参数是给一个函数,第二个是给一个序列类型
将列表序列中各个元素加一
# 普通写法
list1 = [1,2,3,4,5]
list2 = []
for i in list1:
list2.append(i+1)
print(list2)
#map用法
list1 = [1,2,3,4,5]
print(list(map(abs,list1)))
list1 = [1,2,3,4,5]
def add1(x):
return x+1
print(list(map(add1,list1)))
[2, 3, 4, 5, 6]
list1 = [1,2,3,4,5]
print(list(map(lambda x:x+1,list1)))
总结:
1.map内置函数的作用是操作序列中的所有元素,并返回一个迭代器,迭代器要转列表才能得到最终的值
2.我们的lambda表达式可以专门配合我们的高阶内置函数来做简单实现
3.2.3 reduce
reduce(func,seq)将每次函数计算的结果继续和序列的下一个元素做累积计算,最终结果只有一个值
注意:reduce传入的参数func必须接受两个参数
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VjGO3mhH-1689409273495)(C:\Users\18361\AppData\Roaming\Typora\typora-user-images\image-20220929212315534.png)]
计算列表中各个数字的和
list1 = [1,2,3,4,5]
sum = 0
for i in list1:
sum += i
print(sum)
list1 = [1,2,3,4,5]
def f(a,b):
#print('进入f')
#print('a=',a)
#print('b=',b)
return a+b
res = reduce(f,list1)
print(res)
3.2.4 filter()==》过滤
filter(func,seq)结果可以通过list转换
保留一个序列中所有偶数
list1 = [1,2,3,4,5,6,7,8,9,10]
for i in list1:
if i %2 != 0:
list1.remove(i)
print(list1)
list1 = [1,2,3,4,5,6,7,8,9,10]
def os(x):
return x%2 == 0
print(list(filter(os,list1)))
print(list(filter(lambda x:x%2==0,list1)))
3.2.5 sorted
list1 = [2,4,1,3,5,6,9,7]
print(sorted(list1)) # 升序
print(sorted(list1,reverse=True)) # reverse=True 是反转的意思
list1 = ['天天:69','二则:78','涛婆:89','广广:100','左手:95']
print(sorted(list1))
def f(x):
arr = x.split(':')
return int(arr[1])
print(sorted(list1,key=f))
print(sorted(list1,key=lambda x:int(x.split(':')[1])))
3.3 递归函数
有可能搞得我们内存崩溃
如果一个函数的内部调用了自己,就叫递归
内存溢出
1.如果要定义递归函数,不想让他报错的话,必须要有出口
2.不断的向出口接近
打印1到500
x = 1
def func():
global x
if x == 500:
print(x)
else:
print(x)
x += 1
return func()
func()
def func(1):
if x == 501:
return
print(x)
return func(x+1)
func(1)
9! = 9*8*7*6*5*4*3*2*1
9! = 9*8!
9! = 9*8*7!
def f(n):
if n == 1:
return True
return n*f(n-1)
a = f(9)
print(a)