函数及名称空间和作用域

目录

• 函数参数之位置参数
• 默认参数
• 可变长形参（重点）
• 可变长实参（重点）
• 命名关键字参数（了解）
• 名称空间
• 名称空间存活周期及作用范围（域）
• 名字的查找顺序
• 查找顺序案例
• 作业

函数参数之位置参数

位置形参
    函数定义阶段括号内从左往右依次填写的变量名
    def func1(a, b, c):pass
位置实参
    函数调用阶段括号内从左往右依次填写的数据值
    func1(1, 2, 3)

def func1(a, b):
    print(a, b)
# func1(1,2)  # 1 2
# func1(1)  # 少一个不行，都会报错
# func1(1, 2, 3)  # 多一个也不行
# func1(b=1, a=2)  # 关键字传参(指名道姓的传)  2 1
# func1(b=1, 2)  #关键字传参一定要跟在位置传参的后面  报错
# func1(2 , b=1)  # 可以 2 1
# func1(1, a=2, b=3) # 同一个形参在调用的时候不能多次赋值
name ='jason'
pwd = 123
func1(a=name, b=pwd) # 实参没有固定的定义，可以传数据值，也可以传绑定了数据值的变量名 jason 123
func1(a=name, b=pwd) # 实参没有固定的定义，可以传数据值，也可以传绑定了数据值的变量名 jason 123
"""
越短的越简单的越靠前
越长的越复杂的越靠后
但是遇到下列情况除外：同一个形参在调用的时候不能多次赋值
"""

默认参数

本质其实就是关键字形参（关键字实参上述内容已经讲了）
别名叫默认参数：提前已经给了，用户可以不传，也可以传

"""默认参数的定义也遵循短的简单的靠前 长的复杂的靠后"""

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 func1(*a):
    print(a)

func1()  # ()
func1(1)  # (1,)
func1(1,2)  # (1, 2)

def func2(b, *a):
    print(a, b)

# func2()  # 报错，函数至少需要一个参数给到b
func2(1)  # () 1
func2(1, 2, 3, 4)  # (2, 3, 4) 1
"""
*星号在形参中
   用于接收多余的位置参数 组织成元组赋值给*号后面的变量名
"""

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()
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(a, k)

# func5()  # 报错，函数至少需要一个参数给到n
func5(1, 2, 3)  # (2, 3) {}
func5(111, a=1, b=2, c=3)  # () {'a': 1, 'b': 2, 'c': 3}
func5(n=111, a=1, b=2, c=3)  # () {'a': 1, 'b': 2, 'c': 3}
# func5(n=1, b=2, c=3, n=111) # 报错，不能重复赋值
func5(1, 2, 3, a=1 ,b=2, c=3)  # (2, 3) {'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[0], l1[1], l1[2])  # 太low了，如果有10,100个数据值呢
index(*l1)  # 等价于index(11,22,33)
index(*t1)  # 等价于index(11,22,33)
index(*s1)  # 等价于index('t','o','m')
index(*se)  # 等价于index(321, 123, 222)
index(*d1)  # 等价于index('username', 'pwd', 'age')
"""
*在实参中
     类似于for循环 将所有循环遍历出来的数据按照位置参数一次性传给函数
"""

def index(username, pwd, age):
    print(username, pwd, age)
d1 = {'username':'jason', 'pwd':123, 'age':18}
index(username=d1.get('username'), pwd=d1.get('pwd'), age=d1.get('age'))
index(**d1)  # 等价于 index(username='jason', pwd=123, age=18)
"""
**在实参中
    将字典打散成关键字参数的形式传递给函数
"""

def index(*args, **kwargs):
    print(args)
    print(kwargs)
index(*[11, 22, 33, 44])  # 等价于 index(11, 22, 33, 44)
index(*(11, 22, 33, 44))  # 等价于 index(11, 22, 33, 44)

补充：
def test(a, b, c, d):
    print(a, b, c, d)

test(**{'a': 1, 'b': 2, 'c': 3, 'd': 4})    # 1 2 3 4

def test(**args):
    print(args, type(args))

test(**{'a': 1, 'b': 2, 'c': 3, 'd': 4})     # {'a': 1, 'b': 2, 'c': 3, 'd': 4} <class 'dict'>

命名关键字参数（了解）

'''形参必须按照关键字参数传值>>>：命名关键字参数'''

def index(name, *args, gender='male', **kwargs):  # gender就是命名关键字参数，一般很少这样用
    print(name, args, gender, kwargs)

# index('jason',1,2,3,4,a=1,b=2)
index('jason',1,2,3,4,'female',b=2)

名称空间

"""
name = 'jason'
1.申请内存空间存储jason
2. 给jason绑定一个变量名name
3. 后续通过变量名name就可以访问到jason
"""
名称空间就是用来存储变量名与数据值绑定关系的地方(我们也可以简单的理解为就是存储变量名的地方)

1. 内置名称空间
   解释器运行自动产生，里面包含了很多名字，例如len print input

2. 全局名称空间
py文件运行产生，里面存放文件级别的名字
  name = 'jason'
  if name:
      age = 18
  while True:
      gender = 'male'
  def index():
      pass
  class MyClass(object):
      pass
全局名称空间：name/age/gender/index/MyClass

3. 局部名称空间
  函数体代码运行\类体代码运行 产生的空间

名称空间存活周期及作用范围（域）

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

作用域
   内置名称空间
       解释器级别的全局有效
   全局名称空间
       py文件级别的全局有效
   局部名称空间
      函数体代码内有效

名字的查找顺序

涉及到名字的查找一定要先搞明白自己在哪个空间
1. 当我们在局部名称空间中的时候
   局部名称空间>>>全局名称空间>>>内置名称空间

2. 当我们在全局名称空间中的时候
   全局名称空间 >>> 内置名称空间
ps：其实名字的查找顺序是可以打破的

查找顺序案例

1. 相互独立的局部名称空间默认不能够互相访问
    def func1():
        name = 'jason'
        print(age)

    def func2():
        age = 18
        print(name)
2. 局部名称空间嵌套
    先从自己的局部名称空间查找 之后由内而外依次查找
"""
函数体代码中名字的查找顺序在函数定义阶段就已经固定死了
x = '干饭了'
def func1():
    x = 1
    def func2():
        x = 2
        def func3():
            print(x)
            x = 3
        func3()
    func2()
func1()

"""

作业

2.判断下列money的值是多少并说明理由 思考如何修改而不是新增绑定关系
money = 100
def index():
    money = 666	
print(money)

#解题思路：在index函数内加个全局声明并执行index()函数来修改当前全局的变量值
money = 100
def index():
    global money
    money = 666
index()
print(money)

money = 100
def func1():
    money = 666
    def func2():
        money = 888
    func2()
print(money)
#解题思路：在func2函数内加个全局声明并执行func1函数来修改当前全局的变量值
money = 100
def func1():
    money = 666
    def func2():
        global money
        money = 888
    func2()
func1()
print(money)