day09 10 11 12 三天函数内容

小括号、中括号名字
()函数调用符
[] 索引调用符

函数的注释：
官方推荐： 查看注释 ：funcming.__doc__      funcming.__name__

def func(name, age, sex):       #形参
     print(name,age,sex)
info = func(name, age，sex)
实参的形参位置必须一一对应
def func(name, age, sex='男'):   #混合型参    
     print(name,age,sex)
info = func(name, age，sex)
实参的形参位置必须一一对应
 实参可以是三个也可以是两个，当是三个的时候会覆盖sex='男'的值,并传递到函数内执行
当实参是两个的时候，sex='男'的值不会被改变

def func(name, age, sex): 
   print(name,age,sex) 
info = func(name, age，sex)  
   print（name，age，sex='男'） #混合实参
       实参sex='男'  会传递给形参sex
这种情况，实参的形参位置必须一

args和kwarga 是可以更换的，但是程序员约定都用它
用途：在不明确接受参数，数量时使用*args和**kwargs
动态位置参数>动态关键字参数
形参：位置>动态位置>默认位置>动态默认参数
实参：位置>关键字参数
在实参调用的时候*将可迭代的对象打散，字典是将键取出
在形参处出现*就是聚合
在实参调用**就是将字典打散成  关键字（键 = 值）
在形参处出现**就是将关键字参数聚合成一个字典

在一个局部空间内，nonlocal还修改离他最近的变量，如果上一层没有就继续向上找，直到找到局部变量顶层，如果局部空间中没有就报错
global：在局部修改全局变量，如果没有就创建一个新的

3.空间名称

命名空间一共分为三种：

　　全局命名空间

　　局部命名空间

　　内置命名空间

*内置命名空间中存放了python解释器为我们提供的名字：input,print,str,list,tuple...它们都是我们熟悉的，拿过来就可以用的方法。

三种命名空间之间的加载与取值顺序：

加载顺序：内置命名空间(程序运行前加载)->全局命名空间(程序运行中：从上到下加载)->局部命名空间(程序运行中：调用时才加载)

取值顺序：

　　在局部调用：局部命名空间->全局命名空间->内置命名空间

　　在全局调用：全局命名空间->内置命名空间

综上所述，在找寻变量时，从小范围，一层一层到大范围去找寻。

作用域

作用域就是作用范围，按照生效范围可以分为全局作用域和局部作用域。

全局作用域：包含内置名称空间、全局名称空间，在整个文件的任意位置都能被引用、全局有效

局部作用域：局部名称空间，只能在局部范围内生效

global关键字，nonlocal关键字。

global：

　　1，声明一个全局变量。

global （声明）我要修改，找到要修改的值，修改   在局部修改全局

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

li = [1,2,3]
dic = {'a':'b'}

def change():
    li.append('a')
    dic['q'] = 'g'
    print(dic)
    print(li)
change()
print(li)
print(dic)

对于可变数据类型的应用举例

nonlocal:

　　1，不能修改全局变量。

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

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关键字举例

 

 

函数名本质上就是函数的内存地址。

1.可以被引用

 可以被引用

2.可以被当作容器类型的元素

 可以当做容器类型的元素

3.可以当作函数的参数和返回值

 可以当做函数的参数和返回值

 第一类对象的概念

*不明白？那就记住一句话，就当普通变量用

五，闭包

def func():
    name = '太白金星'
    def inner():
        print(name)

# 1.一个嵌套函数

# 在嵌套函数的内部函数使用外部(非全局的变量)
# 满足以上两条就是闭包

# python中闭包,会进行内存驻留, 普通函数执行完后就销毁了
# 全局里存放会有污染和不安全的现象
# 面试必问,装饰器 -- 装饰器的本质就是闭包
# 闭包有个弊端:会出现内存泄漏

# def wrapper():
#     a = 10
#     def inner():
#        print(a)
#     # print(inner.__closure__) # 不是None 就是闭包
#     inner()
# wrapper()

生成器

生成器本质是一个迭代器

生成器一定是迭代器，迭代器不一定是一个生成器

生成器是可以让程序员自己定义的一个迭代器

生成器的好处，节省内存空间

生成器的特性一次性的，惰性机制，从上向下

send相当于next+传值，第一次触发商城器的时候，第一次使用生成器的时候使用send里面的值必须是None

一般建议使用__next__

python 2 iter()  next()

python 3 iter()  next()        __iter__( )      __next__()

# def f():
#     def a():
#         def b():
#             def c():
#                 return '哈撒给!'
#             return c()
#         return b()
#     return a()
# print(f())

# for i in range(3):
#     def func(x):
#         print(x*i)
#     func(2)  # 0 2 4

# li = [] # [func,func,func]
# for i in range(3):
#     def func(x):
#         print(x*i)
#     li.append(func)
#
# for func in li: # [func,func,func]
#     func(2) 

    #结果：  4 4 

可变参数 

传入一个可迭代对象，迭代元素求和

def add(nums):

    sum = 0

    for x in nums:

        sum += x

    return sum

out = add([1,3,5,7])

out1 = add((1,3,4,5,6))

print(out)

print(out1)

 

一个形参可以匹配任意个参数

位置参数的可变参数

def add(*nums):

    sum = 0

    print(type(nums))

    for x in nums:

        sum += x

    return sum

out = add(1,3,5,7)

print(out)

在形参前使用*表示该参数是可变参数，可以接受多个参数

收集多个实参为一个tuple

 

关键字参数的可变参数

def showconfig(**kwargs):

    for k,v in kwargs.items():

        print('{}={}'.format(k,v))

 

showconfig(host='127.0.0.0',port='8080',username='vayne',passwd='magedu')

形参前使用**符号，表示可以接收多个关键字参数

收集的实参名和值组成一个字典

def showconfig(**kwargs):

    print(type(kwargs))

    print(kwargs)

    for k, v in kwargs.items():

        print('{}={}'.format(k, v))

 

showconfig(host='127.0.0.0',port='8080',username='vayne',passwd='magedu')

 

{'passwd': 'magedu', 'port': '8080', 'host': '127.0.0.0', 'username': 'vayne'}

passwd=magedu

port=8080

host=127.0.0.0

 

总结

位置可变参数在形参前使用一个*号

关键字可变参数在形参前使用列个**号

位置可变参数和关键字可变参数可以收集若干个实参，位置可变参数收集形成一个tuple，关键字可变参数

收集形成一个dict

混合使用参数的时候，可变参数要放在参数列表的最后，普通参数需要放到参数列表的前面，位置可变参数

需要放在关键字可变参数之前

def fn(x,y,*args,**kwargs):

    print(x)

    print(y)

    print(args)

    print(kwargs)

 

 

 

fn(3,5,7,9,2,a=1,b='python')

fn(3,5)

fn(3,5,7)

fn(3,4,a=1,b='python')