python学习 day09 (3月14日)----函数

一.函数的进阶

  1.1 动态参数

   1.2* **

  1.3*args , **kwargs

  1.4 函数的注释

 1.5名称空间 
  
 1.6函数的嵌套
全局变量 : 贴边写的
局部变量 : 不是贴边写的。
'''
函数执行流程:
1.定义函数  
2.在内存中开辟地址空间
3.调用函数
4.执行函数体
5.销毁函数开辟的内存空间
'''

1.1动态参数

静态

def func():  #  形参
    pass
func()   #实参
#不确定 变化的  动态位置参数
def func(a,b,c,*args ):  #在形参位置*叫做聚合
    print(args)   #元组形式
func(1,2,3,4,5,6,7,8,9)
#位置参数》动态的位置参数 》默认参数》动态(关键字)默认参数

错误用法:

#*args 在前 后面的不能得值 出错
#TypeError: func() missing 3 required keyword-only arguments: 'a', 'b', and 'c'
# def func(*args , a, b,c):
# 在后可以!  和 a =1  一样出错的吗

动态默认参数

def func(**kwargs):     #动态默认参数
    print(kwargs)       #字典
func(a=1, b=2, c=3)     #关键字的形式传参
# args 和 kwargs 是可以更换的,但是程序员约定用它
#在不明确 接受参数 数量时 使用 *args **kwargs

总的写法:

def func(*args , **kwargs):
    print(args , kwargs)
func(a = 1, b=1 , c= 1)#() {'a': 1, 'b': 1, 'c': 1}
# func(a = 1, b=1 , c= 1 ,1,2,3,4)# error
func(1,2,3,4 , a = 1, b=1 , c= 1 )# (1, 2, 3, 4) {'a': 1, 'b': 1, 'c': 1}

#四个 一起的位置顺序  形参  实参 是两个

#位置参数必须得有值 一一对应
# def func(a,b,c,*args ,x  ,y , **kwargs):  #error: 没对应
def func(a,b,c,*args ,x = 1 ,y =1 ,**kwargs):
# def func(a, b, c, *args, **kwargs , x=1, y=1):  #SyntaxError: invalid syntax
    print(a,b,c)
    print(x,y)
    print(args , kwargs)
    # print(**kwargs)
# func(1, 2, 3, 4, a=1, b=1, c=1)  #  a,b,c  不行 重复变量
func(1, 2, 3, 4, 5, e=1, d=1, f=1)  # (4,) {'e': 1, 'd': 1, 'f': 1}
#形参(在前): 位置> 动态位置> =默认参数(也可以出来)  >动态默认参数
#实参:    位置> 关键字参数
1.2* 实参是打散 *形参是聚合

def func(*args , **kwargs):  # 聚合(1,2,3)
    print(*args  , *kwargs)  #* 打散 1 2 3
func(1,2,3,e=1)

li = [1,2,3,4]
def fuc(*args):
    print(args)
    print(*args)
# func(li)   # 先[1,2,3,4]
func(*li)  #先打散  1,2,3,4
1.3
'''
在实参调用的时候 *是将可迭代的对象打散,(字典是将键取出)**就是将关键字参数聚合成一个字典
在形参处 出现 * 就是在聚合() 和 **字典打散成键=值 在函数中第一次出现是 打散 第二次出现 聚合
'''
dic = {'a' :1 , 'b':2}
def func(*args , **kwargs):
    print(args,kwargs)   # 给args  如果给了就是字典() {'a': 1, 'b': 2}
    print(args, *kwargs)  # 给args  给了的话是 键() a b
    print(args,**kwargs)  # 出错 不可以打印 此种格式print(a = 1, c=2)
# func(*dic)
#func(*可迭代)
#func(*[1,2,3])
func(**dic)#给了kwargs#func(a = 1 , b= 2)

def func(a):#返回值 **twargs
print(a)
func(**{'a':1})
 
1.4 函数的注释
官方推荐‘’‘’‘’‘’‘’‘’
----------便于合作
def login(user, pwd):
    '''
    登录函数
    :param user: 用户
    :param pwd: 密码
    :return:  校验后的帐号和密码
    '''
    print(111)
print(login.__doc__)# 文件内容
# 返回文件名 __shenme__
print(login.__name__)     数据库__doc__  把等于化成 字典格式 
'''
1.5名称空间
1.内置空间中的所有代码 ---内置空间
2.自己写的文件 ---全局空间
3.函数中的代码 ---局部空间
'''
#加载顺序:
'''
内置空间
全局空间
局部空间
'''
#查找值的顺序
'''
1.局部空间
2.全局空间
3.内置空间
4.找不到就报错
''' #可以查找值,但是不可以改值 所以有: gal no
a = 10
def func():
    a = 1
    print(a)
func()
#作用域
'''
1.全局作用域 内置+全局=全局作用域
2.局部作用域 函数内的就是局部作用域
'''

#global : 在局部修改全局变量,如果没有就创建一个新的  只操作全局

a = 10
# print(id(a))
def func():
    # print(id(func))
    # a = 1
    # a += 1
    global a  #找到要修改的值,修改完重新放回
    print(id(a))  #地址 不同  付给他的吗?
    a += 1    #可以改值?但是作用域作用不出去 没法赋值给a?
    # print(id(a))
print(a , id(a))#10 490696448
func()
print(a , id(a)) #11 490696480  此a 非彼a
print(id(a))
#1.6函数的嵌套
#方式1 在函数func 内
def func1():
    print(3)
    def f():  # 没执行 定义了 只打印32
        print(1)
    print(2)
    # f()  #321
func1()
# 方式2  多个函数嵌套调用
def func2():
    print(1)
    log()
# func2()          # error
def func3():
    print(1)
def log():
    func3()
    print(1)
func2()  #启动口  前面是定义开辟空间

 3'''nonlocal   操作局部 函数里

在一个局部全局内,nonlocal 会修改离他最近的那个
变量,如果上一层没有就继续上找,知道找到局部空间头部
''' #没有找到就报错
 def func():
    a =1
    def log():
        a =5
        def info():
            # global a
            nonlocal a  #重新放回去
            a+=10  #  5+10 =15
            print(a)
        info()
        print(a)    #15
    log()
    print(a)
func()
def f():
    a = 1
    print(id(a))
    def a():
        a = 5
        print(a)
    print(a)  #直接打 函数的地址 不是1
    print(id(a))
f()
def f():
    a = 1
    print(a)
    def a1():
        a= 5
        print(a)
        def l():
            nonlocal a
            a = 8
            print(a)
        l()
        print(a)
    print(a1())
f()

 

 

老师说,排bug 从下往上  读 从上往下 花时间在理思路?

 #从最里层返回任意一个字符串,在最外层打印

def fua(args):
    def fub(args):
        def fuc(args):
            def fud(args):
                a = 8
                return a
            a = fud(0)
            return a
        a = fuc(0)
        return a
    a = fub(0)
    return a
print(fua(0))

a = 10
def outer():
    a = 20
    def inner():
        #在内层函数中使用和全局变量同名的变量
        #1.直接使用
        #2.更改
        #如果直接使用一个变量,默认是全局,不能在内层函数中对全局变量进行更改
        #python中使用global 关键字指定全局变量  进行更改和使用
        print('a')
        global a
        # a = 100
        print(id(a))
        print(a)
        a = 100
    inner()
outer()
def wrapper():
    def inner():
        print(666)
    # 直接调用
    # inner()

    # 把函数定义返回
    # 不要加()
    return inner
fun = wrapper()
#
# fun就是函数名了
# 相当于 def fun() -------
fun()
#() 调用操作符
#[] 索引操作符
posted @ 2019-03-14 12:41  learnacode  阅读(204)  评论(0编辑  收藏  举报