函数初级

今日内容概要

今日内容概要

函数参数
名称空间与作用域
名字查找顺序

函数参数之位置参数

"""补充：当子代码只有一行并且很简单的情况下可以直接在冒号后编写 不用换行"""
位置形数
  函数定义阶段括号内从左到右依次填写的变量名
    def func1(a, b, c):pass
位置实参
   函数调用阶段括号内从左往右依次填写的数据值
   func1(1, 2, 3)
# def func1(a, b):
#     print(a, b)


# func1(1, 2)  # 按照位置一一对应传值
# # func1(1)  # 少一个不行
# # func1(1, 2, 3)  # 多一个也不行
# func1(b=1, a=2)  # 关键字传参(指名道姓的传)
# func1(b=1, 2)  # 位置实参一定要在关键字实参之前
# func1(2, b=2)
# func1(1, a=2, b=3)  # 同一个参数在调用的时候不能接收多个值

# def func1(a, b):
#     print(a, b)
#
#
# name = "jason"
# pwd = 123
# # func1(name, pwd)  # 实参没有固定的定义 可以传数据值 也可以传绑定了数据值的变量名
# func1(a=name, b=pwd)
"""
参数的规律
越短的越简单的越靠前
越长的越复杂的越靠后
但是遇到下列的情况除外
  同一个形参在调用的时候不能多次赋值
"""

默认参数

"""本质其实就是关键字形参 别名叫默认参数:提前就已经给了 
   用户可以不传 也可以传
默认参数的定义也遵循短的简单的靠前 
长的复杂的靠后"""

# def register(name, age, gender="male"):
#     print(f"""
#     --------学员信息--------
#      姓名:{name}
#      年龄:{age}
#      性别:{gender}
#      ----------------------
#     """)
#
#
# register("jason", 18)
# register("kevin", 28)
# register("lili", 28, "female")
# register("lili", 28, gender="female")

# def aa(a: str, b: int):
#     print(a, b)
#
#
# aa(1, 1)

# a = ["1", "2"]
# b = [1, 2]
#
# s = dict(zip(a,b))
# print(s)
# a = list(zip('abcdefg', range(8), range(8)))
# print(a)

可变长参数

# 可变形参
# def func(*a):
#     print(a)
#
#
# func()  # ()
# func(1)  # (1,)
# func(1, 2)  # (1, 2)

# def func(b, *a):
#     print(a, b)


# func()  # 函数至少需要传一个参数给b
# func(1)  # () 1
# func(1, 2, 3, 4)  # (2, 3, 4) 1
# func(1, 2, 3, b=222)  # 前面位置实参已经给b值了 后面关键字实参又给了一个 所以报错
"""
*号在形参中
  用于接收多余的位置参数 组织成元组赋值给*号后面的变量名
"""

# def func3(**k):
#     print(k)
#
#
# func3()  # {}
# func3(a=1)  # {'a': 1}
# func3(a=1, b=2, c=3)  # {'a': 1, 'b': 2, 'c': 3}


# def func4(a, **k):
#     print(a, k)
#
#
# # func4()  # 函数至少需要一个参数给到a
# func4(a=1)  # 1, {}
# func4(a=1, b=2, c=3)  # 1 {'b': 2, 'c': 3}
# func4(a=1, b=2, c=3, x='jason', y='kevin')  # 1 {'b': 2, 'c': 3, 'x': 'jason', 'y': 'kevin'}
"""
**号在形参中
  用于接收多余的关键字参数 组成字典的形式赋值给**号后面的变量名
"""

# def func5(*a, **k):
#     print(a, k)
#
#
# func5()  # () {}
# func5(1, 2, 3)  # (1, 2, 3) {}
# func5(a=1, b=2, c=3)  # () {'a': 1, 'b': 2, 'c': 3}
# func5(1, 2, 3, a=1, b=2, c=3)  # (1, 2, 3) {'a': 1, 'b': 2, 'c': 3}


# def func5(n, *a, **k):
#     print(n, a, k)


# func5()  # 函数至少需要一个参数给到n
# func5(1, 2, 3)  # 1 (2, 3) {}
# func5(111, a=1, b=2, c=3)  # 111 () {'a': 1, 'b': 2, 'c': 3}
# func5(n=111, a=1, b=2, c=3)  # 111 () {'a': 1, 'b': 2, 'c': 3}
# func5(a=1, b=2, c=3, n=111)  # 111 () {'a': 1, 'b': 2, 'c': 3}
"""
由于*和**在函数的形参中使用频率很高 
后面跟的变量名推荐使用
   *args
   **kwargs
def index(*args, **kwargs): pass
"""

可变长实参

# 可变长实参
# def index(a, b, c):
#     print(a, b, c)
#
#
# l1 = [11, 22, 33]
# t1 = (33, 22, 11)
# s1 = "tom"
# se = {123, 321, 222}
# d1 = {"username": "jason", "pwd": 123, "age": 18}
# """将数据中的三个值取出来传给函数的三个参数"""
# index(*l1)  # 11 22 33
# index(*t1)  # 33 22 11
# index(*s1)  # t o m
# index(*se)  # 321 123 222
# index(*d1)  # username pwd age

"""在实参中
类似与for循环 将所有循环遍历出来的数据按照位置参数一次性传给参数

"""

# def index(username, pwd, age):
#     print(username, pwd, age)


# d1 = {"username": "jason", "pwd": 123, "age": 18}
# index(**d1)  # jason 123 18
#
# d2 = [1, 2, 3]
# index(*d2)  # 1 2 3
"""
**在实参中
  将字典打散成关键字参数的形式传递给函数

其实形参只是起到提示作用 你传什么 他就接收什么
"""

#
# def index(*args, **kwargs):
#     print(args)
#     print(kwargs)

# index(*[11, 22, 33, 44])  # (11, 22, 33, 44)  {}
# index(*(11, 22, 33, 44))  # (11, 22, 33, 44) {}

命名关键字参数(了解)

"""
形参必须按照关键字参数传值>>>:命名关键字参数
"""


def index(name, *args, gender="male", **kwargs):
    print(name, args, gender, kwargs)


# index("jason", 1, 2, 3, 4, a=1, b=2)  # jason (1, 2, 3, 4) male {'a': 1, 'b': 2}

index('jason', 1, 2, 3, 4, 'female', b=2)  # jason (1, 2, 3, 4, 'female') male {'b': 2}
index('jason', 1, 2, 3, 4, gender='female', b=2)  # jason (1, 2, 3, 4) female {'b': 2}

名称空间

name = "jason"

"""
1.会申请内存空间存储jason
2.给jason绑定一个变量名name
3.后续通过变量名name就可以访问到jason
"""

名称空间就是来存储变量名与数据值绑定关系的地方（我们也可以简单的理解为就是存储变量名的地方）

内置名称空间

解释器运行自动产生里面包含很多名字

eg：len print input

全局名称空间

py文件运行产生里面存放文件级别的名字

name = "jason"

if name:
    age = 18

while True:
    gender = "male"


def index():
    pass


class MyClass(object):
    pass


"""
name/age/gender/index/MyClass
"""

都是全局名称空间

局部名称空间

函数代码运行\类替代码运行\ 产生的名称空间

名称空间存活周期及其作用域

存活周期
- 内置名称空间
  
  python解释器启动则创建关闭则销毁
- 全局名称空间
  
  py文件执行则创建运行结束则销毁
- 局部名称空间
  
  函数替代码运行则创建函数体代码结束则销毁（类暂且不考虑）
作用域
- 内置名称空间
  
  解释器级别的全局有效
- 全局名称空间
  
  py文件级别的全局有效
- 局部名称空间
  
  函数体代码内有效

名字查找顺序

涉及到名字的查找一定要先搞明白自己在那个空间

当我们在局部名称空间中的时候

局部名称空间>>>全局名称空间>>>内置名称空间
当我们在全局名称空间中的时候

全局名称空间>>>内置名称空间

查找顺序案例

相互独立的局部名称空间默认不能够互相访问

def func1():
    name = "jason"
    print(age)


def func2():
    age = 18
    print(name)

局部名称空间嵌套

先从自己的局部名称空间去找之后由内而外依次查找

x = '干饭了'


def func1():
    x = 1

    def func2():
        x = 2

        def func3():
            print(x)  # 因为顺序已经在定义的时候就固定死了
            x = 3     # 因为他本身有 但是执行到print就停止运行了所以
                      # 报错局部变量x 在赋值前就调用了

        func3()

    func2()


func1()

因为顺序已经在定义的时候就固定死了
因为他本身有但是执行到print就停止运行了所以
报错局部变量x 在赋值前就调用了

作业

# 判断下列money的值是多少并说明理由
# 思考如何修改而不是新增绑定关系
money = 100


def index():
    money = 666


print(money)  # 100

# 因为print打印的是全局变量的x 函数都没有调用没有执行函数体代码


money = 100


def func1():
    money = 666


def func2():
    money = 888


func2()
print(money)
# 因为print打印的是全局变量的x 函数调用执行函数体代码
# 局部名称空间执行函数体启动 函数执行结束空间结束
# 所以打印的还是全局的money

posted @ 2022-10-10 17:10 可否阅读(26) 评论(0) 收藏举报

可否