函数小节汇总

函数参数之位置参数

默认参数

可变长参数

名称空间

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

名字的查找顺序

查找顺序案例

目录内容详解

函数参数之位置参数

"""
当子代码只有一行并且很简单的情况下，可以直接在冒号后编写不用换行
"""
# 函数位置形参和位置实参
# def funcl(a, b, c): pass  # 位置形参 定义阶段括号内从左往右依次填写的变量名
# funcl(1, 2, 3)  #位置实参 调用阶段括号内从左往右依次填写的数据值
def funcl(a, b):
    print(a, b)
# funcl(1, 2)  # 安装位置一一对应
# funcl(1)  # 直接报错少一个也不行 同理多一个也不行
# funcl(b=1, a=2)  # 关键字传参(指名道姓的传)
# funcl(b=1, 2)  # 直接报错，关键字传参一定要跟在位置传参后面
# funcl(2, b=1)  # ture
# funcl(1, b=1, a=2)  # 报错，同一个形参调用的时候不能多次赋值
name = 'Gao'
pwd = '123'
# funcl(name, pwd)  # 实参没有固定的定义 可以传数据值 也可以绑定数据值的变量名
# funcl(a=name, b=pwd)  # 实参没有固定的定义 可以传数据值 也可以绑定数据值的变量名
"""
越短的越简单的越靠前
越长的越复杂的越靠后
但遇到一下情况例外
        同一个形参在调用的时候不能多次赋值
"""

默认参数

• 默认参数可以简化函数的调用,降低调用函数的难度

• 设置默认参数时，有几点要注意：

  • 必选参数在前，默认参数在后，否则Python的解释器会报错
  • 如何设置默认参数
    • 当函数有多个参数时，把变化大的参数放前面，变化小的参数放后面。变化小的参数就可以作为默认参数

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

def student (name, age, gender='girl'):
    print(f"""
    ----------学生信息----------
    姓名：{name}
    年龄：{age}
    性别：{gender}
    ---------------------------
    """)
student('gaoli', 23, 'boy')
student('dudu', 18)
student('jiajia', 19)
student('weiwei', 20)

可变长参数

• 可变长参数：指的是在调用函数时，传入的参数个数可以不固定
• 调用函数时，传值的方式无非两种，一种是位置实参，另一种是关键字实参，因此形参也必须得有两种解决方法，以此来分别接收溢出的位置实参(*)与关键字实参(**)

1.可变长形参之*

• 形参中的会将溢出的位置实参全部接收，然后存储元组的形式，然后把元组赋值给后的变量名-参数。需要注意的是：*后的变量名名约定俗成为args——参数。

def funcl(*a):
    print(a)
funcl()  # ()
funcl(1)  # (1,)
funcl(1, 2, 3, 4)  # (1, 2, 3, 4)

def func2(b, *a):
    print(a, b)
func2()  # 报错 函数至少需要一个参数给到b
func2(1)  # () 1
func2(1, 2, 3, 4)  # (2, 3, 4) 1

2.可变长形参之**

• 形参中的会将溢出的关键字实参全部接收，然后存储字典的形式，然后把字典赋值给后的参数——变量名。需要注意的是：**后的变量名约定俗成为kwargs——关键字参数。

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='Gaoli',d='jiajia') # 1 {'b': 2, 'c': 'Gaoli', 'd': 'jiajia'}

3.可变长形参之*与可变长形参之**混合使用

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 func6(n, *a, **k):
    print(n, a, k)


func6()  # 函数至少需要一个参数给到n
func6(1, 2, 3)  # 1 (2, 3) {}
func6(111, a=1, b=2, c=3)  # 111 () {'a': 1, 'b': 2, 'c': 3}
func6(n=111, a=1, b=2, c=3)  # 111 () {'a': 1, 'b': 2, 'c': 3}
func6(a=1, b=2, c=3, n=111)  # 111 () {'a': 1, 'b': 2, 'c': 3}
func6(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

4.可变长实参之*

• 实参中的，会将后参数的值循环取出，打散成位置实参。以后但凡碰到实参中带的，它就是位置实参，应该马上打散成位置实参去看。(类似于for循环 将所有循环遍历出来的数据按照位置参数一次性传给函数)

def index(a, b, c):
    print(a, b, c)


l1 = [123, 321, 132]
# 方法1索引取值（不推荐）
index(l1[0], l1[1], l1[2])  # 123 321 13
# 方法二用*来进行赋值
index(*l1)  # 123 321 132
l2 = ['aaa', 'bbb', 'ccc']
index(*l2)  # aaa bbb ccc
s1 = 'tom'
index(*s1)  # t o m
set1 = {123, 1231, 321}  # 集合不能重复否则会报错
index(*set1)  # 321 123 1231
dic1 = {'username': 'Gaoli', 'pwd': 123, 'age': 23}
index(*dic1)  # username pwd age取的是键
index(*dic1.values())  # Gaoli 123 23取的是值

5.可变长实参之**

• 实参中的，会将后参数的值循环取出，打散成关键字实参。以后但凡碰到实参中带的它就是关键字实参，应该马上打散成关键字实参去看(将字典打散成关键字参数的形式传递给函数)

def user_info(username, password, age):
    print(name, password, age)


d1 = {'username': 'Gaoli', 'password': 123, 'age': 18}
user_info(username=d1['username'], password=d1['password'], age=d1['age'])  # Gaoli 123 18
user_info(*d1.values())  # Gaoli 123 18
user_info(**d1)  # Gaoli 123 18
user_info(username='Gaoli', password=123, age=18)  # Gaoli 123 18

6.可变长实参*与可变长实参**使用

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)

7.命名关键字形参（了解一下就好）

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

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 = 'Gaoli'
1.申请内存空间存储Gaoli
2.给Gaoli绑定一个变量名name
3.后续通过变量名name就可以访问到Gaoli
名称空间即存放名字与对象映射/绑定关系的地方。对于y=6，Python会申请内存空间存放对象6，然后将名字y与6的绑定关系存放于名称空间中，del x表示清除该绑定关系。
在程序执行期间最多会存在三种名称空间

• 内置名称空间
  • 解释器运行自动产生 里面包含了很多名字
    • eg:len print input
• 全局名称空间

py文件执行过程中产生的名字都会存放于该名称空间中
import sys #模块名sys
x=1 #变量名x
if x == 1:
    y=2 #变量名y
def foo(x): #函数名foo
    y=1
   def bar():
        pass
Class Bar: #类名Bar
	pass

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

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

存活周期

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

名字的查找顺序

• 涉及到名字的查找 一定要先搞明白自己在哪个空间
  • 当我们在局部名称空间中的时候
    • 局部名称空间 >>> 全局名称空间 >>> 内置名称空间
  • 当我们在全局名称空间中的时候
    • 全局名称空间 >>> 内置名称空间
• 其实名字的查找顺序是可以打破的

查找顺序案例

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

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

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

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

x = '123321'  # D1
def func1():  # D3
    x = 1
    def func2():  # D5
        x = 2
        def func3():  # D7
            x = 3
            print(x)#3
        func3()  # D6
        print(x)#2
    func2()  # D4
    print(x)#1
func1()  # D2
print(x)#123321