函数理论部分

今日内容概要

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

今日内容详细

函数参数

1.形式参数
	函数定义阶段括号内填写的参数 形参
2.实际参数
	函数调用阶段括号内填写的参数 实参
"""
形参类似于变量名
实参类似于数据值
形参与实参在函数调用阶段动态绑定 在函数结束阶段动态解除
"""

位置参数

1.位置形参：函数定义阶段，括号内从左往右依次填写的'变量名'
	def func1(a, b,):pass # 子代码只有一行且很简单的情况下不需要换行
2.位置实参：函数调用阶段，括号内从左往右依次填写的'数据值'
	func1(1, 2)
    def func1(a, b):
        print(a, b)
    # func1(1, 2) # 位置形参的变量名和位置实参数据值一一对应
    # func1(1) # 少一个不行，会报错
    # func1(1, 2, 3) # d多一个也不行，会报错
    # func1(b=1, a=2) # 关键字传参(指名道姓的传参)
    # func1(b=2, 1) # 关键字传参一定要在位置传参的后面 报错
    # func1(1, b=2) # 可以
    # func1(1,a=2) # 同一个形参调用期间不能多次赋值
    """
    越简单的越短的越靠前
    越复杂的越长的越靠后
    同一个形参调用期间不能多次赋值
    """
    # name = 'almira'
    # pwd = 12345
    # func1(name, pwd) # 实参没有固定的定义，可以传数据值也可以传绑定数据值的变量名
    # func1(a=name, b=pwd) # 实参没有固定的定义，可以传数据值也可以传绑定数据值的变量名
		

默认参数

默认参数的本质就是关键字形参(提前已经给了，用户可以不写)

    def register(name, age, gender='fmale'):
        print(f"""
        -----------student information---------
        name:{name}
        age:{age}
        gender:{gender}
        -----------------------------------------
        """)
    # register('almira', 24, 'female')
    # register('lina', 22, 'female')
    # register('linda', 20, 'female')


    register('almira', 24,)
    register('lina', 22,)
    register('linda', 20,)

可变长形参

# 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()  # 函数至少需要一个参数给到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(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(a=1, b=2, c=3, n=111)  # () {'a': 1, 'b': 2, 'c': 3}
# 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]
# index(*l1) # 相当于index(11, 22, 33) ;11 22 33

# t1 = (11, 22, 33)
# index(*t1) # 相当于index(11, 22, 33) ;11 22 33

# st ='bob'
# index(*st) # 相当于index('b', 'o', 'b') ;b o b

# se = {123, 342, 133}
# index(*se) # 相当于index(123 133 342) ；123 133 342集合是无序的，随机拆分

# d1 = {'username':'almira', 'pwd':123, 'gender':'female'}
# index(*d1) # username pwd gender
# *号在实参中相当于for循环，将遍历出来的数据按照位置参数的形式一次性传给函数


# def index(username, pwd, gender):
#     print(username, pwd, gender)
# d1 = {'username':'almira', 'pwd':123, 'gender':'female'}
# index(**d1) # index(username='almira', pwd=123, gender='female') ; almira 123 female 只针对字典
# **在实参中将字典打散成关键字参数的形式传给函数


def index(*args, **kwargs):
    print(args) # (11, 22, 33, 44)
    print(kwargs) # {}
index(*[11, 22, 33, 44]) # index(11, 22, 33, 44)
index(*(11, 22, 33, 44)) # index(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)
index('jason', 1, 2, 3, 4, 'female', b=2)

名称空间(很重要)

"""
name = 'alimra' 底层原理：
1.首先申请内存空间存储almira
2.给almira绑定一个变量名
3.后续通过变量名找到name就可以访问到almira
"""
名称空间：用来存储变量名与数据值绑定关系的地方(存储变量名的的地方)
1.内置名称空间
	# 只要安装了python解释器那内置名称空间就存在
	解释器运行自动产生，里面包含了很多名字
    	ge:len input print...
2.全部名称空间
	# 只要运行了py文件就会立刻产生全局名称空间
	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 = 'almira'
    print(age)


def func2():
    age = 24
    print(name)
    
func1()
func2()

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

作业

2.判断下列money的值是多少并说明理由 思考如何修改而不是新增绑定关系
	money = 100
	def index():
        money = 666	
 	print(money)
    
   答：money = 100,因为index函数没有调用，所以寻找的是全局空间的money

	money = 100
 	def func1():
        money = 666
        def func2():
            money = 888
        func2()
   print(money)

答：money = 100，func1没有调用，所以它往全局名称空间去找，所以寻找的是全局空间的money