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 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

>>> 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