函数参数与名称空间

今日内容详细

目录

• 今日内容详细
  • 函数参数
    • 位置参数
    • 默认参数
    • 可变长参数
      • 可变长形参
      • 可变长实参
    • 命名关键字参数(了解)
  • 名称空间
    • 存活周期
    • 作用范围(域)
  • 名字的查找顺序
  • 查找顺序案例
  • 作业

函数参数

位置参数

位置形参
	函数定义阶段括号内从左往右依次填写的变量名
	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=1)  # 可以
func1(1, a=2, b=3)  # 同一个形参在调用的时候不能多次赋值
name = 'qyf'
pwd = 123
funcl(name, pwd)  # 实参没有固定的定义 可以传数据值 也可以传绑定了数据值的变量名
func1(a=name, b=pwd)  # 实参没有固定的定义 可以传数据值 也可以传绑定了数据值的变量名
"""
越短的越简单的越靠前
越长的越复杂的越靠后
但是遇到下列的情况除外
	同一个形参在调用的时候不能多次赋值
"""

默认参数

本质其实就是关键字形参(指定有默认值的形式参数必须在所有没默认值参数的最后，否则会产生语法错误)
	别名叫默认参数:提前就已经给了 用户可以不传 也可以传
"""
默认参数的定义也遵循短的简单的靠前 长的复杂的靠后
"""
def register(name, age, gender='male'):
    print(f"""
    --------学员信息--------
    姓名：{name}
    年龄:{age}
    性别:{gender}
    ----------------------
    """)


register('qyf', 18)
register('wei', 23, 'female')
register('lili', 34, 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()  # 报错 函数至少需要一个参数给到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='qyf', y='wei')  # 1 {'b': 2, 'c': 3, 'x': 'qyf', 'y': 'wei'}
"""
**号在形参中
	用于接收多余的关键字参数 组织成字典的额形式赋值给**号后面的变量名
"""
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}
func5(1, 2, 3, a=1, b=2, c=3)  # 1 (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 = (11, 22, 33)
s1 = 'qyf'
se = {123, 231, 222}
d1 = {'username': 'qyf', 'pwd': 123, 'age': 23}
'''将列表中三个数据值取出来传给函数的三个形参'''
index(*l1)  # 11 22 33
index(*t1)  # 11 22 33
index(*s1)  # q y f
index(*se)  # 123 222 231 集合本身就是无序的
index(*d1)  # username pwd age
"""
*在实参中
	类似于for循环 将所有循环遍历出来的数据按照位置参数一次性传给函数
"""
def index(username, pwd, age):
    print(username, pwd, age)


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


index(*[11, 22, 33, 44], x=3, y=4)  # (11, 22, 33, 44) {'x': 3, 'y': 4}
index(*(11, 22, 33, 44))  # (11, 22, 33, 44) {}

命名关键字参数(了解)

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


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


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

名称空间

"""
name = 'qyf'
1.申请内存空间存储qyf
2.给qyf绑定一个变量名name
3.后续通过变量名name就可以访问到qyf
"""
名称空间就是用来存储变量名与数据值绑定关系的地方(我们也可以简单的理解为就是存储变量名的地方)
1.内置名称空间
	解释器运行自动产生 里面包含了很多名字 
		eg: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():
                x = 3
                print(x)
            func3()
        func2()

    func1()
"""

作业

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

money的值是100    函数未调用函数体代码不用看

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

money的值是100    函数未调用函数体代码不用看