python--4函数def,本质、值传递、引用传递、默认值参数、*参数名、**变量、lambda [参数]: 函数、偏函数、递归、递归练习

学习目标：

函数def,本质、值传递、引用传递、默认值参数、*参数名、**变量、lambda [参数]: 函数、偏函数、递归、递归练习

学习内容：

函数def,本质、值传递、引用传递、默认值参数、*参数名、**变量、lambda [参数]: 函数、偏函数、递归、递归练习

学习目标：

学习内容：

函数定义方式：---复用def 函数名([形参,...,...])/([参数列表...]):

一行或者多行的函数体

[return 返回值]

调用函数函数名(形参,...,...)

return关键字调用后需要接受返回值/print（）

局部函数不能改全局变量---除global 变量，变量(放第一)

global 变量=全局变量

函数调用的本质：

值传递:变量之间，数值的传递，这种传递相当于变量赋值--变量--数值

引用传递：传递的地址（指针），对象，引用--对象

函数的参数def func_name([arge...])# （默认值、可变、关键字参数） # 函数体 # [return 返回值]

默认值参数指向不可变数据---默认值可以user改

参数：--可以附加默认值

给了另一个值，用给定值，不用默认值

默认值参数一定要写在普通值参数之后，否则会报错。

可变参数： *参数名--存储额外的参数

多个输入，它只传前面两个值-计算;()/(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)

递归练习

学习时间：

学习产出：

函数定义方式：---复用
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 1return 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 1return 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 1return 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 1return n + get_count(n - 1)
count = get_count(1500)
print(f"0-100的和是{count}")
>>>
0-100的和是1125750

>>> 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():"""求圆的面积"""passprint(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)
>>>
74
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)
>>>{}
74
{'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 += 10b += 30print(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 agea = 20print(name)print(age)print(a)a += 10print(a)age += 1print(age)work_1("哦","聊天止于哦哦")print(name)
print(age)
# print(a)
>>>>>
张三
16
20
30
17
张三
17name = "张三"
age = 16def work_1(msg,show):a = 20print(name)print(age)print(a)a += 10print(a)age += 1print(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_1print(age)^^^
UnboundLocalError: cannot access local variable 'age' where it is not associated with a valueD:\soft\pythonworkplace>我们可以看到这里报错了，又是什么原因呢？
这里它的意思是找不到局部变量age。
这又是什么原因呢？
正常情况，python拒绝在函数中修改全局变量，但是考虑到特殊情况下的需求，python中如果要修改全局变量，需要提前声明！！！！
如果说我们此时加上一个局部变量age：name = "张三"
age = 16def work_1(msg,show):age = 1a = 20print(name)print(age)print(a)a += 10print(a)age += 1print(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 = 16def work_1(msg,show):global agea = 20print(name)print(age)print(a)a += 10print(a)age += 1print(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