学习目标:
- 函数def,本质、值传递、引用传递、默认值参数、*参数名、**变量、lambda [参数]: 函数、偏函数、递归、 递归练习
学习内容:
- 函数def,本质、值传递、引用传递、默认值参数、*参数名、**变量、lambda [参数]: 函数、偏函数、递归、 递归练习
目录
函数定义方式:---复用def 函数名([形参,...,...])/([参数列表...]):
局部函数不能改全局变量---除global 变量,变量(放第一)
值传递:变量之间,数值的传递,这种传递相当于变量赋值--变量--数值
函数的参数def func_name([arge...])# (默认值、可变、关键字参数) # 函数体 # [return 返回值]
多个输入,它只传前面两个值-计算;()/(4, 5, 6, 7,..)--元组--可变数量的参数
print(*args, sep=' ', end='\n', file=None, flush=False)
def xingxi (name,age,**happy):
print(f"name={name},age={age},happy={happy}")
dict1={'job':'xs','happy':'sport'}
匿名函数---lambda (参数:) 函数--不能直接调用,简化函数
#偏函数---为已有的函数重新固定下来某个默认参数的值-修改,返回一个新的函数
递归函数---函数内部调用自身,需要终止条件,return,出口不满足表达式,先写出口
import functools>>> dir(functools)
函数定义方式:---复用
def 函数名([形参,...,...])/([参数列表...]):
一行或者多行的函数体
[return 返回值]
调用函数
函数名(形参,...,...)
这里其实已经是返回了一个结果,我们只是没有进行接收这个值,所以:
return关键字 调用后需要接受返回值/print()
局部函数不能改全局变量---除global 变量,变量(放第一)
global 变量=全局变量
函数调用的本质:
程序启动的瞬间,会生成至少一个执行栈,函数是在堆中存放的,每当函数被调用时,会进行压栈,调用结束之后,会立刻进行弹栈
下面我们接着分析;
在python中,函数本质也是一种对象!!!!!
对象则会存在堆里面,栈空间有限。
我们将函数的地址存在了栈中,和C中指针有点像。
程序调用的:本质就是将函数临时压入执行栈!!!
也就是我们将test函数压入栈中进行执行,当执行完最后一行代码就会立即进行弹栈操作,以避免长时间占用内存。
这里我们就可以理解为什么局部变量不能够被外面访问到,因为函数执行完毕立即弹栈,栈已经不存在局部变量的值了
值传递:变量之间,数值的传递,这种传递相当于变量赋值--变量--数值
引用传递:传递的地址(指针),对象,引用--对象
函数的参数
def func_name([arge...])# (默认值、可变、关键字参数)
# 函数体
# [return 返回值]
默认值参数指向不可变数据---默认值可以user改
参数:--可以附加默认值
给了另一个值,用给定值,不用默认值
默认值参数一定要写在普通值参数之后,否则会报错。
def get_circle_area(r,PI=3.14):print(get_circle_area(r1,3.1415926))
可变参数: *参数名--存储额外的参数
不是C语言中指针,它主要用来存储额外的参数!!!!,会将参数封装到元组
多个输入,它只传前面两个值-计算;()/(4, 5, 6, 7,..)--元组--可变数量的参数
def ji (*num):
ji=1
for i in num:
ji*=i
return ji
print(ji(5,5,5))
list1=[5,5,5]
print(ji(*list1))
print(*args, sep=' ', end='\n', file=None, flush=False)
关键字参数:**变量--可变数量的键值对参数
def xingxi (name,age,**happy):
print(f"name={name},age={age},happy={happy}")
dict1={'job':'xs','happy':'sport'}
xingxi('luan',13,**dict1)
匿名函数---lambda (参数:) 函数--不能直接调用,简化函数
lambda [参数]: 函数
不需要return
def test1(fn):
print(fn(1,2))
print('test1')
test1(lambda a,b:a+b)
#偏函数---为已有的函数重新固定下来某个默认参数的值-修改,返回一个新的函数
# import functools
from functools import partial
int2 = partial(int, base=2)
# print(a)
print(int2("10010"))
递归函数---函数内部调用自身,需要终止条件,return,出口不满足表达式,先写出口
def jiecheng(num):
if num == 1:
return 1
else:
return jiecheng(num-1)*num
print(jiecheng(3))
帮助文档:
print(函数名)---注释
help(print)
import functools
>>> dir(functools)
......未完end
函数的分类
以函数是否存在返回值:
有返回值的函数 return关键字 调用后需要接受返回值
无返回值的函数 没有return关键字 返回值为None
以函数是否存在参数:
有参数函数
无参数函数
4、局部变量和全局变量:
1、局部变量(local variable):又叫做本地变量,定义在函数内部的变量
局部变量只能在当前定义的函数内部有效
2、全局变量(global variable):直接定义在模块中的变量,叫做全局变量
在python中,函数内部不允许修改全局变量!!!!
值传递和引用传递:
值传递:变量之间,数值的传递,这种传递相当于变量赋值
引用传递:传递的地址(指针),对象,引用
参数:--可以附加默认值
默认值参数:大多情况下,该参数值不需要改变,书写位置一般在正常参数的后面。方便用户调用函数
注意:默认值参数指向不可变数据---默认值可以user改
可变参数 *参数名
*args
如果说要传进去的参数是元组或者列表,只需要在元组或者列表前面添加*,就会吧元祖或列表作为可变参数穿进去
关键字参数(命名参数):
**kwargs
函数传递--demo(print_msg)
函数作为参数传递函数内部:
python中函数是对象,python中函数的参数只要是对象即可,所以pyhton中函数可以作为参数传递到函数内部。
注意如下两种情况的不同之处:
所以,python中函数是可以以参数的形式存入函数内部的。带了括号相当于传了函数的返回值。函数带括号表示函数调用,不带括号表示函数引用,代表函数本身。
def a()
pass
def b()
pass
b(a) # 函数作为参数传递到函数中
b(a())# 将a的返回值作为参数传递到函数中
def demo(fn):
# 下面这行代码就是一个函数调用
# fn是一个函数
fn("hello,函数你好")
def print_msg(msg):
print(msg)
demo(print_msg)
匿名函数以及lambda表达式---简化函数
匿名函数:没有名称的函数,不能直接调用
python在lambda引入之前是没有匿名函数的!
lambda表达式之后,才通过lambda实现了匿名函数
lambda(x,b,c):函数体
同样是以上案例:
def demo(fn):
# 下面这行代码就是一个函数调用
# fn是一个函数
fn("hello,函数你好")
demo(lambda msg:print(msg))
>>>hello,函数你好
这里lambda使用后面加参数这里也就是函数名,冒号后面加返回值,这里则为函数内容。
使用lambda主要用于匿名场景中,进行简化。
lambda本质是简化编写程序的难度!!!!!
偏函数
# int(x, base=10) -> integer 默认是按照十进制进行转换的
# functools
# 偏函数:
# 为已有的函数重新固定下来某个默认参数的值,并返回一个全新的函数,这个函数就是偏函数
# import functools
from functools import partial
int2 = partial(int, base=2)
# print(a)
print(int2("10010"))
可能存在某个函数,该函数中存在默认值
如果后面调用时,多次需要修改为一个相同的默认值【变成另外一个值】可以使用偏函数实现
我们可以看下int:
int(x, base=10)
我们可以看到base=10,这里int就是整型10进制不用改默认值。如果我们需要进行进制转换:
>>> int("123456")
123456
>>> int("123456",base = 10)
123456
>>> int("123456",base = 8)
42798
>>> int("11111",base = 2)
31
我们可以重新构建一个函数,只是这里不是10进制,而是二进制,引入functools模块。
1、import functools
functools.partial()
2、from functools import partial
# 返回一个新的函数 = partial(原函数, 默认值=新值)
递归练习
......未完end
递归
递归(recursion):函数自身调用自身,需要设置递归的终止条件
一定要有终止条件,否则是个死循环。
案例:求 0-n的和
# 求0-n的和
def get_count(n:int):
if n == 1:
return 1
return n + get_count(n - 1)
count = get_count(100)
print(f"0-100的和是{count}")
>>>
0-100的和是5050
递归的内存分析以及优缺点
这里也就牵扯了压栈,弹栈。
这就是栈内进行大量调用执行从而占用大量空间。
这里我们可以尝试着让其调用1000多次:
# 求0-n的和
def get_count(n:int):
if n == 1:
return 1
return n + get_count(n - 1)
count = get_count(1000)
print(f"0-100的和是{count}")
>>>这里报错,递归错误,已经超过了递归最大数量。
同时,我们可以调用sys内置模块来看递归最大次数:
import sys
print(sys.getrecursionlimit())
# 求0-n的和
def get_count(n:int):
if n == 1:
return 1
return n + get_count(n - 1)
count = get_count(1000)
print(f"0-100的和是{count}")
当然,我们如果真的要求1到1000以上的和或者其他,我们也可以进行自己设置递归的次数,这里设置2000次最大次数,从而输出1到1500的求和:
import sys
# print(sys.getrecursionlimit())
sys.setrecursionlimit(2000)
# 求0-n的和
def get_count(n:int):
if n == 1:
return 1
return n + get_count(n - 1)
count = get_count(1500)
print(f"0-100的和是{count}")
>>>
0-100的和是1125750
![递归](https://i-blog.csdnimg.cn/blog_migrate/7cf58ca85a62516452a0cccf678003b1.png)
>>> import functools
>>> dir(functools)
['GenericAlias', 'RLock', 'WRAPPER_ASSIGNMENTS', 'WRAPPER_UPDATES', '_CacheInfo', '_HashedSeq', '_NOT_FOUND', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_c3_merge', '_c3_mro', '_compose_mro', '_convert', '_find_impl', '_ge_from_gt', '_ge_from_le', '_ge_from_lt', '_gt_from_ge', '_gt_from_le', '_gt_from_lt', '_initial_missing', '_le_from_ge', '_le_from_gt', '_le_from_lt', '_lru_cache_wrapper', '_lt_from_ge', '_lt_from_gt', '_lt_from_le', '_make_key', '_unwrap_partial', 'cache', 'cached_property', 'cmp_to_key', 'get_cache_token', 'lru_cache', 'namedtuple', 'partial', 'partialmethod', 'recursive_repr', 'reduce', 'singledispatch', 'singledispatchmethod', 'total_ordering', 'update_wrapper', 'wraps']
>>> functools.partial
<class 'functools.partial'>
>>> from functools import partial
>>> partial(int,base=2)
functools.partial(<class 'int'>, base=2)
>>> a = partial(int,base=2)
>>> a
functools.partial(<class 'int'>, base=2)
>>> a("100")
4
>>> a("100",base=10)
100
>>> int("100")
100
>>>
帮助文档
def get_circle_area():
"""
求圆的面积
"""
pass
print(get_circle_area.__doc__)
>>>
求圆的面积
*args
def test(x,y,*args):
print(args)
print(x + y)
test(2,5)
test(2,3,4,5,6,7)
>>>
()
7
(4, 5, 6, 7)
5
**变量
def test(x,y,*args,**kwargs):
if len(args) > 0:
print(args[0])
if len(kwargs) > 0:
print(kwargs["name"])
print(x + y)
test(2,5)
test(2,3,4,5,6,7,a = 123,b = 456,name = "xxx",age = 16)
>>>
7
4
xxx
5
默认值参数:
如果函数中的某个或者某些参数,在调用时大多数情况下,是一个固定值。
为了调用方便,可以设定默认值。
默认值参数一定要写在普通值参数之后,否则会报错。
如果一个值在大多数情况下取一个值,我们可以默认给他一个值,比如这里PI大多数情况下使用3.14,则:
def get_circle_area(r,PI=3.14):
"""
求圆的面积
"""
return r * r * PI
r1 = float(input("请输入圆的半径:"))
print(get_circle_area(r1))
》》》
请输入圆的半径:4
50.24
当然,如果我给了PI另一个值,那么他肯定是使用给定值,如果没有才采用默认值:
def get_circle_area(r,PI=3.14):
"""
求圆的面积
"""
return r * r * PI
r1 = float(input("请输入圆的半径:"))
print(get_circle_area(r1))
print(get_circle_area(r1,3.1415926))
输出结果:
》》》
请输入圆的半径:3
28.26
28.2743334
可变参数:
*变量 这种形式定义的,注意:不是C语言中指针
它主要用来存储额外的参数!!!!,会将参数封装到元组中
依然是上一个案例,我们如果说想要进行加入别的功能,我们可以进行加入函数,当然,python中也可以加入可变参数。加上*arges不影响原来的代码,可以给他不进行传值。
def test(x,y,*args):
print(x + y)
test(2,5)
test(2,3,4,5,6,7)
》》》
7
5
这里我们可以看到,我们给它进行多传几个值依然不会影响原来的代码,但是,最终执行的功能我们可以看到进行多个输入,它只传前面两个值,从而输出了5
而这里我们加入arges又有什么用呢?
def test(x,y,*args):
print(args)
print(x + y)
test(2,5)
test(2,3,4,5,6,7)
>>>
()
7
(4, 5, 6, 7)
5
这里我们可以看到里面存进了4567,也就是你传了多余的参数他会把这些存进去。扩展了程序的功能也不影响原有的代码。
def test(x,y,*args):
if len(args) > 0:
print(args[0])
print(x + y)
test(2,5)
test(2,3,4,5,6,7)
>>>
7
4
5
print函数:
print(*args, sep=' ', end='\n', file=None, flush=False)
可变参数,因此它可以直接传入多个值
命名参数:
又叫做关键字参数
**变量
可变参数和关键字参数,主要的功能就是配合装饰器进行功能扩展的!!!
print函数:
print(*args, sep=' ', end='\n', file=None, flush=False)
def test(x,y,*args,**kwargs):
if len(args) > 0:
print(args[0])
print(kwargs)
print(x + y)
test(2,5)
test(2,3,4,5,6,7,a = 123,b = 456,name = "xxx",age = 16)
>>>{}
7
4
{'a': 123, 'b': 456, 'name': 'xxx', 'age': 16}
5
{'a': 123, 'b': 456, 'name': 'xxx', 'age': 16}这个我们叫做字典。
我们也试着去拿值:
def test(x,y,*args,**kwargs):
if len(args) > 0:
print(args[0])
if len(kwargs) > 0:
print(kwargs["name"])
print(x + y)
test(2,5)
test(2,3,4,5,6,7,a = 123,b = 456,name = "xxx",age = 16)
>>>
7
4
xxx
5
引用传递:传递的地址(指针),对象,引用--对象
def add(nums):
nums.append(100)
nums.append(200)
print(nums)
ages = [10,20,30]
print(ages)
add(ages)
print(ages)
>>>
[10, 20, 30]
[10, 20, 30, 100, 200]
[10, 20, 30, 100, 200]
这里我们可以看到,我们最终将100以及200存了进去。
这又是什么原因呢?
ages在这里也就是对象,对象我们都是存放在堆中的,堆中地址则存在了栈中,而这里add则传递的是地址,也就相当于nums变量拿到的是ages的存放堆中的地址,也就相当于指向了这一变量,而这里ages则将值存了进去,那么nums也会将100以及200存到这个地址中去。
值传递:变量之间,数值的传递,这种传递相当于变量赋值--变量--数值
def change(a,b):
a += 10
b += 30
print(a,b)
x = 100
y = 200
print(x,y)
change(x,y)
print(x,y)
>>>
100 200
110 230
100 200
global
name = "张三"
age = 16
def work_1(msg,show):
global age
a = 20
print(name)
print(age)
print(a)
a += 10
print(a)
age += 1
print(age)
work_1("哦","聊天止于哦哦")
print(name)
print(age)
# print(a)
>>>>>
张三
16
20
30
17
张三
17
name = "张三"
age = 16
def work_1(msg,show):
a = 20
print(name)
print(age)
print(a)
a += 10
print(a)
age += 1
print(age)
work_1("哦","聊天止于哦哦")
print(name)
print(age)
# print(a)
D:\soft\pythonworkplace>test.py
张三
Traceback (most recent call last):
File "D:\soft\pythonworkplace\test.py", line 599, in <module>
work_1("哦","聊天止于哦哦")
File "D:\soft\pythonworkplace\test.py", line 590, in work_1
print(age)
^^^
UnboundLocalError: cannot access local variable 'age' where it is not associated with a value
D:\soft\pythonworkplace>
我们可以看到这里报错了,又是什么原因呢?
这里它的意思是找不到局部变量age。
这又是什么原因呢?
正常情况,python拒绝在函数中修改全局变量,但是考虑到特殊情况下的需求,python中如果要修改全局变量,需要提前声明!!!!
如果说我们此时加上一个局部变量age:
name = "张三"
age = 16
def work_1(msg,show):
age = 1
a = 20
print(name)
print(age)
print(a)
a += 10
print(a)
age += 1
print(age)
work_1("哦","聊天止于哦哦")
print(name)
print(age)
# print(a)
D:\soft\pythonworkplace>test.py
张三
1
20
30
2
张三
16
我们可以看到内部输出的age最后加了1,而最终输出的age值依然为我们定义的值16。
下面这个便是全局变量确实需要修改的时候,我们则需要在其使用内部加上声明global:
关键字 global 来声明
name = "张三"
age = 16
def work_1(msg,show):
global age
a = 20
print(name)
print(age)
print(a)
a += 10
print(a)
age += 1
print(age)
work_1("哦","聊天止于哦哦")
print(name)
print(age)
# print(a)
张三
16
20
30
17
张三
17
函数是什么??一段实现某一特定功能的代码的集合
本质上实现了代码的高度复用
函数定义方式:
def 函数名([形参]):
一行或者多行的函数体
[return 返回值]
回顾:
函数:实现某一特定功能的代码的集合
函数碰见return会立刻进行返回,不会在执行函数内return下边的代码
本地变量(局部变量)和全局变量
本地变量(局部变量):声明在函数内部的变量
全局变量:
全局变量在任何位置都能够被读取,
默认情况下,全局变量不允许被函数内部进行更改
局部变量只能在函数内部进行访问。外部要进行访问,通过return返回出去
‘’‘
局部函数不能改全局变量---除global 变量,变量(放第一)
’‘’
函数调用的本质:
程序启动的瞬间,会生成至少一个执行栈,函数是在堆中存放的,每当函数被调用时,会进行压栈,调用结束之后,会立刻进行弹栈
值传递和引用传递
值传递传递的是值,引用传递传递的是内存地址
参数:
默认值参数:大多情况下,该参数值不需要改变,书写位置一般在正常参数的后面。方便用户调用函数
注意:默认值参数指向不可变数据
可变参数 *参数名
*args
如果说要传进去的参数是元组或者列表,只需要在元组或者列表前面添加*,就会吧元祖或列表作为可变参数穿进去
关键字参数(命名参数):
**kwargs
匿名函数 lambda表达式
lambda [参数]: 函数
不需要return
学习时间:
学习时间为不运动的时候,作者咕咕了是去运动(无氧运动和有氧运动都做最好)了,请饶恕。
学习产出:
画工
python---3--sort、lambdalen(list1)、sorted_numbers = sorted(numbers)、list.sort()
python--2作业66,69,71,84;85;数据类型:int()float()TrueFalsestr()list()set()dict()tuple()class
python--1作业,注释、输入输出、运算符、运算结果、三目运算符、关系表达、多值交换、偶数、随机数、三目运算、if、elif、else、while、for、break、contince、pass http://t.csdnimg.cn/0KDeU
计算机网络第1章:计算机网络的概念、组成与功能;计算机网络的分类、标准化工作及相关组织
计算机网络第一章:性能指标:带宽、时延、时延带宽积、RTT、吞吐量、速率、信道利用率
计算机网络体系结构——PDU、SDU、PCI、协议、访问、接口、SAP
计算机网络分层结构——OSI/ISO、TCP/IP http://t.csdnimg.cn/hLrqY
2章选择、解答 http://t.csdnimg.cn/ONrER
通信基本概念:数据、信号、码元、信源、信道、信宿、速率、波特、带宽 http://t.csdnimg.cn/TKnyM
数据、信号、码元、信源、信道、信宿、速率、波特、带宽-通信基本概念
HCIA——30奈奎斯特定理、香农定理 http://t.csdnimg.cn/Yqtch
HCIA——20应用层:C/S、P2P、peer http://t.csdnimg.cn/4i4Og
HCIA——21C/S、P2P、peer的选择
DNS层次域名空间、域名服务器、域名解析的原理 http://t.csdnimg.cn/yeWd6
HCIA——23DNS层次域名空间、域名服务器、域名解析的原理的选择、解答 http://t.csdnimg.cn/RXPNV
HCIA——24FTP 的工作原理、功能、TFTP、控制连接、数据连接
HCIA——25FTP 的工作原理、功能、TFTP、控制连接、数据连接的选择、解答
HCIA——26E-mall、MIME、POP3、IMAP、电子邮件系统的组成结构、电子邮件的发送,接收过程、MIME 与SMTP 的关系 http://t.csdnimg.cn/smTaR
HCIA——27E-mall、MIME;POP3、IMAP的选择,解答 http://t.csdnimg.cn/xnsXP
HCIIA——28HTTP、万维网、HTML;万维网的工作过程;HTTP 的特点——无连接-TCP、无状态-Cookie、非持久连接-非流水线和流水线;HTTP 的报文结构 http://t.csdnimg.cn/cRcxY
- 技术笔记 1遍
- 有错误请指出,作者会及时改正