Python 学习日记 第十天

日常鸡汤：

　　　　自律才能更好的享受生活

---

 一、函数参数----动态传参

1.位置参数的动态参数：*args

 1 def func(*food):
 2     print('我爱吃 ',food)
 3 # 传多少个参数就会输出多少参数
 4 func('a','b','c')
 5 # 输出  我爱吃  ('a', 'b', 'c')
 6 
 7 
 8 #  注意：动态参数输出的是一个元组的类型
 9 #  注意：同时，在动态参数后面，不能再输入位置参数，因为所有的参数都被动态参数接受
10 #  注意：而且位置参数写到位置动态参数的后面，程序会报错

注意：使用的时候，动态参数必须在位置参数的后面。但是还有另外一种情况就是默认值参数

def func(a,b,*food,c = '娃哈哈'):
    print('我爱吃 ',a,b,c,food)
# 传多少个参数就会输出多少参数
func('a','b','c','c','c')


# 输出    我爱吃  a b 娃哈哈 ('c', 'c', 'c')
# 所以在普通传参的时候，默认值函数也是同样得不到参数的，想要得到参数只能

def func(a,b,*food,c = '娃哈哈'):
    print('我爱吃 ',a,b,c,food)
# 传多少个参数就会输出多少参数
func('a','b','c','c','c',c='你好')

# 输出  我爱吃  a b 你好 ('c', 'c', 'c')

根据以上的结果，我们发现所有的默认值都生效了，如果不给出关键字参数，那么设定的默认值是永远都生效的，如果想要更改，只要使用关键字参数就可以

所以目前位置的顺序是：位置参数，*动态参数，默认值参数

2.动态接受关键字参数

　　在pyhton中可以动态的设置动态参数，但是*这种情况只能接受位置参数，无法接受关键字参数

所以，在python中使用**来接收动态关键字参数

def func(**kwargs):
    print(kwargs)
# **kwargs 动态关键字参数
func(a=1,b=2,c=3,d=4)
# 输出  {'a': 1, 'b': 2, 'c': 3, 'd': 4}

**kwargs 接受的是一个字典，同时，在函数调用的时候，如果先给出关键字参数，则整个参数列表会报错，所以关键字参数必须在位置参数后面。由于实参是这个顺序，所以形参接收的时候也是这个顺序，所以得到了最终的顺序：

位置参数 > * args >默认值参数>**kwargs，这四种参数可以任意的进行调用

如果要接收所有的参数：

1 def func(*args,**kwargs):
2     print(args,kwargs)
3 func(1, 2, 3, e = 'b')
4 # 输出    (1, 2, 3) {'e': 'b'}

一定要记住的是，*args 最终的表现形式是元组，**kwargs最终表现形式是字典

3.传参的其他方式：

需求：在实参位置上给一个序列，列表，可迭代对象 

第一个我们可以使用最笨的方法，依次取值，放入

# 正常情况下我要把一个列表等里面的所有内容一下都传进参数中
# 我们可以使用最笨的方法
def fun(*args):
    print(args)

lst = [1,4,6]
fun(lst[0],lst[1],lst[2])

# 输出(1, 4, 6)     

第二个，我们可以在传参的时候使用 *

 1 def func(*args):
 2     print(args)
 3 
 4 lst = [1,2,3,4]
 5 s = "abcde"
 6 
 7 func(*lst)
 8 func(*s)
 9 
10 # 输出(1, 2, 3, 4)
11 # 输出('a', 'b', 'c', 'd', 'e')

所以，在实参位置上给一个序列，列表，可迭代对象前面加入* 表示把这个序列按顺序打散

在形参的位置上的* 表示把可接收的参数组成一个元组，如果是一个字典，也可以的，需要两个**

def fun(**kwargs):
    print(kwargs)
dic = {'a':1,'b':2,'c':3}

fun(**dic)

# 输出{'a': 1, 'b': 2, 'c': 3}

4.函数的注释：

"""

第一行，函数的注释，表达这个函数是干什么的

:praam *args      表达参数是什么意思

:return                 返回的是什么东西

"""

二、命名空间　

　　在python解释器开始执行之后，就会在内存中开辟一个空间，每当遇到一个变量的时候，就会把变量名和值之间的关系记录下来，其他的也一样，我们给存放名字和值的关系的空间起一个名字叫：命名空间

1.命名空间分类：

• 全局命名空间：我们直接在py文件中，函数外声明的变量都属于全局命名空间
• 局部命名空间：在函数中声明的变量会放在局部命名空间
• 内置命名空间：存在python解释器为我们提供的名字，像list tuple等这些都是内置命名空间

2.加载顺序;

• 内置命名空间
• 全局命名空间
• 局部命名空间（当函数被执行的时候）

3.取值顺序（与加载顺序刚好相反）：

• 局部命名空间
• 全局命名空间
• 内置命名空间

三、作用域

作用域：就是作用范围，按照生效范围来看， 分为全局作用域和局部作用域

全局作用域：包含内置命名空间和全局命名空间，在整个文件的任何位置都可以使用（从上到下）

局部作用域：在函数内部可以使用

 

作用域命名空间：

• 全局作用域：全局命名空间+内置命名空间
• 局部作用域：局部命名空间

globals() 函数      locals() 函数

a = 10
def func():
    a = 40
    b = 20
    def abc():
        print('哈哈哈')
    print(a,b)        # 这里使用的是局部作用域
    print(globals())  # 打印全局作用域中的内容
    print(locals())   # 打印局部作用域中的内容

func()

# 输出40 20
# 输出{'__name__': '__main__', '__doc__': None, '__package__': None, #'__loader__': <_frozen_importlib_external.SourceFileLoader object at #0x00000290CE2586A0>
#{'abc': <function func.<locals>.abc at 0x00000290CE32B8C8>, 'b': 20, 'a': 40}

globals() 函数---- 查询全局作用域中的内容

locals() 函数 -----查询局部作用域中内容

四、函数的嵌套

1.遇见（）就是函数的调用，如果没有（）就不是函数的调用

2.函数的执行顺序是从上到下，依次执行的

3.关键字global和nonlocal

global 表示：不再使用局部作用域中的内容，而改用全局作用域中的变量，如果全局作用域中没有这个变量，就把局部变量升华为全局变量

nonlocal 表示：表示在局部作用域中，调用父级命名空间的变量，如果上一次没有，就继续往上寻找，但是并不会调用到全局的变量

 1 a = 1
 2 def fun_1():
 3     a = 2
 4     def fun_2():
 5          def fun_3():
 6              nonlocal a
 7              a =  4
 8              print(a)
 9          print(a)
10          fun_3()
11          print(a)
12     print(a)
13     fun_2()
14     print(a)
15 print(a)
16 fun_1()
17 print(a)
18  
19 输出  1224441

 

转载于:https://www.cnblogs.com/Chamster/p/9304549.html