目录

函数的基础

形参：

实参：

动态传参：

位置参数>动态位置参数>关键字参数>动态关键字参数

*args  接受所有位置参数

**wargs 接受所有关键字参数*******************************************

不容易理解的地方：

return   返回值

命名空间

内置命名空间（优先级最高）

全局命名空间

局部命名空间：函数内部

函数名：

函数名可以当作值去赋值给变量

函数名可以当作参数传递给函数

函数名可以当作函数返回值，注意：返回值不能加括号

函数名可以当作元素存放一个容器里

查看函数的内存地址 print(函数名)

闭包

如何分辨闭包：

闭包的作用：

迭代器：

递归：

 

 

函数的基础

1. # 申明方法

             def 方法名（形参）：

                    代码块

1. # 调用方法

              方法名（实参）

[code]def demo(name,age):
print(f'(我是{name}，我今年{age}岁))

#调用方法
demo('admin',12)

形参：

位置形参：def demo(name,age)

默认值形参：def demo(name,age=12)

二者可以混合使用，但是 位置形参 必须在默认值形参之前

实参：

位置实参：demo('admin',12)

关键字实参： demo('admin',age=12)

二者可以混合使用，但是 位置实参 必须在关键字实参之前

动态传参：

*参数   是位置参数

**参数  是关键字参数 方法接受到的是字典 

位置参数>动态位置参数>关键字参数>动态关键字参数

 

在形参上：*聚合   **聚合

在实参上：*打散   **打散

格式：

*args  接受所有位置参数

[code]lis = [1,2,3,4]
def function(*args): # 聚合 将打散的 内容 再次组成元组形式 （1，2，3，4）
print(args)
print(*args)

function(lis)   #
function(*lis)    #打散   *lis实际上就是 1，2，3，4

#结果：
([1, 2, 3, 4],)
[1, 2, 3, 4]

(1, 2, 3, 4)
1 2 3 4

**wargs 接受所有关键字参数*******************************************

[code]dir = {'a':1,'b':2,"c":3,"d":4}
def function(**kargs): #这里将其聚合成 {'a':1,'b':2,"c":3,"d":4}
# print(**kargs)  #报错 TypeError: 'a' is an invalid keyword argument for this function
# print(*kargs)  # a b c d
print(kargs)     #{'a': 1, 'b': 2, 'c': 3, 'd': 4}

function(**dir)  # 其实这里的是  a=1  b=2   c=3   d=4
# function(*dir) #报错 TypeError: function() takes 0 positional arguments but 4 were given
# function(dir) #报错 TypeError: function() takes 0 positional arguments but 1 was given

#注意 ：
dir = {'a':1,'b':2,"c":3,"d":4}
def function(**kwargs):
print(**kwargs)   #报错 TypeError: 'a' is an invalid keyword argument for this function
function(**dir)

为什么打印 **kwargs 会报错的原因是：
字典前加 ** 会将字典打散为 a=1,b=2,c=3,d=4。
传入 function（**kwargs）方法后会被 **kwargs 全部接受 聚合成 {'a': 1, 'b': 2, 'c': 3, 'd': 4}
而 print(**字典)   则会将 字典再次打散为关键字参数，
但是print 的方法的参数中是没有 **kwargs（接受所有的关键字参数的） ， 因此会报错
但是 print()方法中是有 *args 参数的，也就是为什么print(*args) 并不会报错

不容易理解的地方：

[code]def func(**kwargs):
print(kwargs)

dic = {"1":1}
func(**dic)

#结果：  {'1': 1}

#减少写参数量
# dic = {"1":1}
# func(**dic)  等同于 func("1"=1) 虽然后者报错，但是在实际空间中是以这种方式存储

 

 

 

 

return   返回值

[code]def demo(name,age):
print(f'(我是{name}，我今年{age}岁))
return
print("这句话不会执行")

#调用方法
demo('admin',12)

注意：在一个方法体内，return之后的代码都不会执行到

 

命名空间

内置命名空间（优先级最高）

存放Python解释器为我们提供的名字，其中就包括内置函数，list,dict,tuple,set,str,int等都属于内置空间的。  

全局命名空间

局部命名空间：函数内部

 

取值顺序：就进原则

globals()函数来查看全局作用域中的内容

locals()来查看当前作用域的内容

 

global 变量名  ： 表示使用全局变量

 在局部变量中使用，当全局变量中没有该参数时，则会将局部变量升级为 全局变量   （不推荐）

nonlocal  变量名 ： 找局部作用域中，离他最近的那层的变量给引用过来，。如果除全局外的局部都不存在改变量则会报错（No find）
 

函数名：

[code]def func():
pass

函数名可以当作值去赋值给变量

[code]a = func
a()      #调用的是func()

函数名可以当作参数传递给函数

[code]def func2(msg):
print(msg)
func2(func)        #执行后的结果 打印的是 func方法的内存地址

函数名可以当作函数返回值，注意：返回值不能加括号

[code]def func():
def func_copy():
pass
return func_copy
print(func())        #打印的是 func_copy的内存地址
print(func()())         #打印的是 func_copy的方法内容

函数名可以当作元素存放一个容器里

[code]def func():pass
def func2():pass
def func3():pass
li = [func,func2,func3]    #列表中存的其实是 每个方法的内存地址
for i in li:
i()            #打印每一个方法

查看函数的内存地址 print(函数名)

[code]print(func)

 

闭包

如何分辨闭包：

闭包必须是嵌套函数，内部函数在使用外部变量（非全局变量）就是闭包。

可以使用方法名.__closure__   查看该函数是否为闭包   只要返回值不是None,他就是闭包

[code]def func():
n = 1
def func2():
print(n)
return func2     #注意这里的返回值 只是func2的方法名，也就是将其的地址返回。
func()()

闭包的作用：

1.可以读取到其他函数内部的变量

2.可以将变量保存在内存中，使其生命周期增强

3.可以保护其内部变量不受外界影响，不被修改，做到私有化

 

迭代器：

[code]lst = [1,2,3,4,5]
l = lst.__iter__()   # 从一个可迭代对象转换成迭代器
print(l.__next__())    #从迭代器中读取第一个

可迭代对象：具有 __iter__(）方法   

print(isinstance('列表等'，Iterable))        判断是否为可迭代对象

迭代器：拥有 __iter__(）方法和__next__() 方法

print(isinstance('列表等'，Iterator))        判断是否为迭代器

[code]# for循环机制
li = [1,2,3,4,5,6]
for i in li:
print(i)

#  等价于
li2 = li.__iter__()
while True:        # 循环:
try:
print(li2.__next__())    # 获得下一个值:
except StopIteration:
break             # 遇到StopIteration就退出循环

 

递归：

其实就是方法自己本身再调用自己

[code]# 一个简单的递归
def fun(n):
print(n)
n += 1
fun(n)

fun(1)

#结果会报
#  RecursionError: maximum recursion depth exceeded while calling a Python object

递归注意事项：有进也有出

递归的最大深度：官方定义是 1000，而实际上测试 只是 998

[code]# 递归求阶乘
def factorial(n):
if n == 1 :
return 1
else:
return n*factorial(n-1)

递归的深度可以修改：

[code]import sys
sys.setrecursionlimit(int num)   #调用sys系统模块