day10

一.今日内容大纲

1. 如何在工作中不让别人看出你是培训出来的？

   • 第一天环境安装等等，小白各种问。

   • 项目需求不清晰，也不敢问。

   • 我们6个月一定要学会自主学习，自己解决问题的能力。

2. 形参角度：

   • 万能参数。

   • *的魔性用法。

   • 仅限关键字参数（了解）。

   • 形参的最终顺序。

3. 名称空间。

   1. 全局名称空间，局部........

   2. 加载顺序，取值顺序。

   3. 作用域。

4. 函数的嵌套（高阶函数）。

5. 内置函数 globals locals

6. 关键字：nonlocal global。

二.昨日内容以及作业讲解

1. • 函数是以功能为导向，减少重复代码，提高代码的可读性。

     def func():
         函数体

   • 函数的调用：func（）

     func()
     func()
     func()

   • 函数的返回值 return

     • 终止函数。

     • return 单个值：

     • return 多个值：(1,2,3,'alex')

   • 函数的参数：

     • 实参角度：位置参数，关键字参数，混合参数。

     • 形参角度：位置参数，默认参数。

三.具体内容

1.如何在工作中不让别人看出你是培训出来的？

• 第一天环境安装等等，小白各种问。

• 项目需求不清晰，也不敢问。

• 我们6个月一定要学会自主学习，自己解决问题的能力。

2.形参角度：

• 万能参数。

• *的魔性用法。

# 万能参数。
# def eat(a,b,c,d):
#     print('我请你吃：%s,%s,%s,%s' %(a,b,c,d))
#
# eat('蒸羊羔', '蒸熊掌', '蒸鹿邑','烧花鸭')

# def eat(a,b,c,d,e,f):
#     print('我请你吃：%s,%s,%s,%s,%s,%s' %(a,b,c,d,e,f))
#
# eat('蒸羊羔', '蒸熊掌', '蒸鹿邑','烧花鸭','烧雏鸡','烧子鹅')

# 急需要一种形参，可以接受所有的实参。#万能参数。
# 万能参数： *args, 约定俗称：args，
# 函数定义时，*代表聚合。 他将所有的位置参数聚合成一个元组，赋值给了 args。

# def eat(*args):
#     print(args)
#     print('我请你吃：%s,%s,%s,%s,%s,%s' % args)
#
# eat('蒸羊羔', '蒸熊掌', '蒸鹿邑','烧花鸭','烧雏鸡','烧子鹅')

# 写一个函数：计算你传入函数的所有的数字的和。
# def func(*args):
#     count = 0
#     for i in args:
#         count += i
#     return count
# print(func(1,2,3,4,5,6,7))

# tu1 = (1, 2, 3, 4, 5, 6, 7)
# count = 0
# for i in tu1:
#     count += i
# print(count)

# **kwargs
# 函数的定义时： ** 将所有的关键字参数聚合到一个字典中，将这个字典赋值给了kwargs.
# def func(**kwargs):
#     print(kwargs)
# func(name='alex',age=73,sex='laddyboy')

# 万能参数：*args, **kwargs，
# def func(*args,**kwargs):
#     print(args)
#     print(kwargs)
# func()
# print()

# * **在函数的调用时，*代表打散。
def func(*args,**kwargs):
    print(args) # (1,2,3,22,33)
    print(kwargs)

# func(*[1,2,3],*[22,33])  # func(1,2,3,22,33)
# func(*'fjskdfsa',*'fkjdsal')  # func(1,2,3,22,33)
func(**{'name': '太白'},**{'age': 18})  #func(name='太白',age='18')

• 仅限关键字参数（了解）。

1. • 仅限关键字参数是python3x更新的新特性，他的位置要放在*args后面，kwargs前面（如果有kwargs），也就是默认参数的位置，它与默认参数的前后顺序无所谓，它只接受关键字传的参数:

   • # 这样传参是错误的，因为仅限关键字参数c只接受关键字参数
     def func(a,b,*args,c):
     print(a,b) # 1 2
     print(args) # (4, 5)
     # func(1, 2, 3, 4, 5)
     # 这样就正确了：
     def func(a,b,*args,c):
     print(a,b) # 1 2
     print(args) # (3, 4)
     print(5)
     func(1, 2, 3, 4, c=5) 

这个仅限关键字参数从名字定义就可以看出他只能通过关键字参数传参，其实可以把它当成不设置默认值的默认参数而且必须要传参数，不传就报错。

所以形参角度的所有形参的最终顺序为：位置参数，*args，默认参数，仅限关键字参数，**kwargs。

• 形参的最终顺序。

# 形参角度的参数的顺序
# *args 的位置？
# def func(*args,a,b,sex= '男'):
#     print(a,b)
# func(1,2,3,4)
# args得到实参的前提，sex必须被覆盖了。
# def func(a,b,sex= '男',*args,):
#     print(a,b)
#     print(sex)
#     print(args)
# func(1,2,3,4,5,6,7,)

# def func(a,b,*args,sex= '男'):
#     print(a,b)
#     print(sex)
#     print(args)
# func(1,2,3,4,5,6,7,sex='女')

# **kwargs 位置？
def func(a,b,*args,sex= '男',**kwargs,):
    print(a,b)
    print(sex)
    print(args)
    print(kwargs)
# func(1,2,3,4,5,6,7,sex='女',name='Alex',age=80)

# 形参角度第四个参数：仅限关键字参数 (了解)

def func(a,b,*args,sex= '男',c,**kwargs,):
    print(a,b)
    print(sex)
    print(args)
    print(c)
    print(kwargs)
# func(1,2,3,4,5,6,7,sex='女',name='Alex',age=80,c='666')

# 形参角度最终的顺序：位置参数,*args,默认参数，仅限关键字参数，**kwargs

3.名称空间。

接下来我们从空间角度，内存级别去研究python。首先我们看看什么是全局名称空间：

​ 在python解释器开始执行之后, 就会在内存中开辟一个空间, 每当遇到一个变量的时候, 就把变量名和值之间的关系记录下来, 但是当遇到函数定义的时候, 解释器只是把函数名读入内存, 表示这个函数存在了, 至于函数内部的变量和逻辑, 解释器是不关心的. 也就是说一开始的时候函数只是加载进来, 仅此而已, 只有当函数被调用和访问的时候, 解释器才会根据函数内部声明的变量来进行开辟变量的内部空间. 随着函数执行完毕, 这些函数内部变量占用的空间也会随着函数执行完毕而被清空.

​ 我们首先回忆一下Python代码运行的时候遇到函数是怎么做的，从Python解释器开始执行之后，就在内存中开辟里一个空间，每当遇到一个变量的时候，就把变量名和值之间对应的关系记录下来，但是当遇到函数定义的时候，解释器只是象征性的将函数名读如内存，表示知道这个函数存在了，至于函数内部的变量和逻辑，解释器根本不关心。

​ 等执行到函数调用的时候，Python解释器会再开辟一块内存来储存这个函数里面的内容，这个时候，才关注函数里面有哪些变量，而函数中的变量回储存在新开辟出来的内存中，函数中的变量只能在函数内部使用，并且会随着函数执行完毕，这块内存中的所有内容也会被清空。

我们给这个‘存放名字与值的关系’的空间起了一个名字-------命名空间。

代码在运行伊始，创建的存储“变量名与值的关系”的空间叫做全局命名空间；

在函数的运行中开辟的临时的空间叫做局部命名空间也叫做临时名称空间

1.全局名称空间：

 

2.局部名称空间（临时名称空间）：

3.加载顺序，取值顺序

#名称空间；命名空间。

# a = 1
# b = 2
# def func():
#     f = 5
#     print(f)
# c = 3
# func()

# 内置名称空间：python源码给你提供的一些内置的函数，print input
# print(666)
# python分为三个空间：
    # 内置名称空间（builtins.py）
    # 全局名称空间（当前py文件）
    # 局部名称空间（函数，函数执行时才开辟）

# 加载顺序：
# 内置名称空间 ---> 全局名称空间  ----> 局部名称空间（函数执行时）
# def func():
#     pass
# func()
# a = 5
# print(666)

# 加载顺序：
# 内置名称空间 ---> 全局名称空间  ----> 局部名称空间（函数执行时）
# def func():
#     pass
# func()
# a = 5
# print(666)

# 取值顺序（就近原则） 单向不可逆
# LEGB原则
# input = '太白金星'
def func():
    # input = 'alex'
    print(input)
# func()

# （从局部找时）局部名称空间  ---> 全局名称空间  --->  内置名称名称空间


# input = '太白金星'
# def func():
#     input = 'alex'
#
# func()
# print(input)

4.作用域

# 作用域：
# 两个作用域：
    # 全局作用域 ：内置名称空间 全局名称空间
    # 局部作用域：局部名称空间

#  局部作用域可以引用全局作用域的变量
# date = '周五'
# def func():
#     a = 666
#     print(date)
# print(a)
# func()
# print(a)

# 局部作用域不能改变全局变量。
# count = 1
# # def func():
# #     count += 2
# #     print(count)
# # func()  # local variable 'count' referenced before assignment
# 局部作用域不能改变全局作用域的变量，当python解释器读取到局部作用域时，发现了你对一个变量进行修改的操作，
# 解释器会认为你在局部已经定义过这个局部变量了，他就从局部找这个局部变量，报错了。

# 使用可以，不能改变
# def func():
#     count = 1
#     def inner():
#         print(count)
#     inner()
# func()

def func():
    count = 1
    def inner():
        count += 1
        print(count)
    inner()
func()

4.函数的嵌套（高阶函数）

# 例1：
def func1():
    print('in func1')
    print(3)

def func2():
    print('in func2')
    print(4)

func1()
print(1)
func2()
print(2)
# in func1 3 1 in func2 4 2



# 例2：
def func1():
    print('in func1')
    print(3)

def func2():
    print('in func2')
    func1()
    print(4)

print(1)
func2()
print(2)


# 例3：
def fun2():
    print(2)

    def fun3():
        print(6)

    print(4)
    fun3()
    print(8)

print(3)
fun2()
print(5)


# glbals() locals()

5.内置函数 globals locals

"""
本文件：研究内置函数：globals locals
"""
a = 1
b = 2
def func():
    name = 'alex'
    age = 73
    print(globals())  # 返回的是字典：字典里面的键值对：全局作用域的所有内容。
    print(locals())  # 返回的是字典：字典里面的键值对：当前作用域的所有的内容。
# print(globals())  # 返回的是字典：字典里面的键值对：全局作用域的所有内容。
# print(locals())  # # 返回的是字典：字典里面的键值对：当前作用域的所有的内容。
func()

6.关键字：global  nonlocal 

1.global 

讲这个关键字之前，先给大家看一个现象：

a = 1
def func():
    print(a)
func()
a = 1
def func():
    a += 1 # 报错
func()

局部作用域对全局作用域的变量（此变量只能是不可变的数据类型）只能进行引用，而不能进行改变，只要改变就会报错，但是有些时候，我们程序中会遇到局部作用域去改变全局作用域的一些变量的需求，这怎么做呢？这就得用到关键字global：
global第一个功能：在局部作用域中可以更改全局作用域的变量。

count = 1
def search():
    global count
    count = 2
search()
print(count)

利用global在局部作用域也可以声明一个全局变量。

def func():
    global a
    a = 3
func()
print(a)

所以global关键字有两个作用：

1，声明一个全局变量。

2，在局部作用域想要对全局作用域的全局变量进行修改时，需要用到 global(限于字符串，数字)。

2.nonlocal 

nonlocal是python3x新加的功能，与global用法差不多，就是在局部作用域如果想对父级作用域的变量进行改变时，需要用到nonlocal，当然这个用的不是很多，了解即可。

def add_b():
    b = 42
    def do_global():
        b = 10
        print(b)
        def dd_nonlocal():
            nonlocal b
            b = b + 20
            print(b)
        dd_nonlocal()
        print(b)
    do_global()
    print(b)
add_b()

nonlocal关键字举例

nonlocal的总结：

1，不能更改全局变量。

2，在局部作用域中，对父级作用域（或者更外层作用域非全局作用域）的变量进行引用和修改，并且引用的哪层，从那层及以下此变量全部发生改变。

四.今日总结

1. 1. 参数：万能参数，仅限关键字参数（了解）,参数的顺序，*的魔性用法：聚合，打散。

   2. 名称空间，作用域，取值顺序，加载顺序。

   3. globals locals

   4. 高阶函数：执行顺序。

   5. 以上全部都是重点。