函数参数

函数参数

目录

• 函数参数
  • 函数参数之位置参数
  • 默认参数
  • 可变长形参
  • 可变长实参
  • 命名关键参数
• 名称空间与作用域
  • 名称空间
    • 1.内置名称空间
    • 2.全局名称空间
    • 3局部名称空间
  • 名称空间存活周期及作用域
• 名字的查找顺序
• 查找顺序案例
• 作业

函数参数之位置参数

位置参数指的是按顺序定义的参数，需要从两个角度去看：
1位置形参
	在定义函数时，按照从左到右的顺序依次定义形参,称为位置形参，凡是按照这种形式定义的形参都必须被传值
    def funcl(a,b,c):pass 代码行只有一行可以直接写在冒号后面       
2位置实参
	在调用函数时，按照从左到右的顺序依次定义实参，称为位置实参，凡是按照这种形式定义的实参会按照从左到右的顺序与形参一一对应
    funcl(1,2,3)
 
 
eg:
    def a(a,b):
        print(a,b)
	a(1,2)  # 按照位置一一对应传值
   a(1) # 少一个会报错
	a(1,2,3) # 多一个也会报错
   a(b=1,a=2) # 关键字传值（使用变量名定义）
	a(b=1,2)# 关键字传参一定要跟在位置传参的后面  报错
   a(2,b=1) # 可以
	a(1,a=2,b=3)# 同一个形参在调用的时候不能多次赋值
    name='jason'
    pwd=123
    a(name,pwd) # 实参没有固定的定义 可以传数据值 也可以传绑定了数据值的变量名
    a(a=name,b=pwd) # 实参没有固定的定义 可以传数据值 也可以传绑定了数据值的变量名
    口诀：
   越短的越简单的越靠前
	越长的越复杂的越靠后
	但是遇到下列的情况除外
   同一个形参在调用的时候不能多次赋值
    

默认参数

本质其实就是关键字形参(关键字实参上述内容已经讲了)
	别名叫默认参数:提前就已经给了 用户可以不传 也可以传
定义时应遵循：
  默认参数的定义也遵循短的简单的靠前 长的复杂的靠后。
def a(name,age,gender='male'):
    print("""
    --------学员信息----------
    姓名:{name}
    年龄:{age}
    性别:{gender}
    -------------------------
    """)
a('tom',18)
a('jerk',28,'female')
a('jerry',10,gender="female")   
 

运行结果

可变长形参

一个函数能处理比当初声明时更多的参数。这些参数叫做可变长参数
基本语法如下：
def functionname([formal_args,] *var_args_tuple ):
   "函数_文档字符串"
   function_suite
   return [expression]
加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。
def a(*args):
    print(args)
a()  # ()
a(1)  # (1,)
a(1, 2)  # (1, 2)
def a(**kwargs):
    print(kwargs)
a()  # {}
a(a=1)  # {'a': 1}
a(a=1, b=2)  # {'a': 1, 'b': 2}
混合使用：
def a(*args, **kwargs):
    print(args, kwargs)
 
 
a()  # () {}
a(a=1)  # () {'a': 1}
a(a=1, b=2, c=3)  # () {'a': 1, 'b': 2, 'c': 3}
a(a=1, b=2, c=3, x='jason', y='kevin')  # () {'a': 1, 'b': 2, 'c': 3, 'x': 'jason', 'y': 'kevin'}
 
def a(n, *args, **kwargs):
    print(n, args, kwargs)
 
 
# a()  # 报错至少有一个b参数
a(1, 2, 3)  # 1 (2, 3) {}
a(111, a=1, b=2, c=3)  # 111 () {'a': 1, 'b': 2, 'c': 3}
a(n=111, a=1, b=2, c=3)  # 111 () {'a': 1, 'b': 2, 'c': 3}
a(a=1, b=2, c=3, n=111)  # 111 () {'a': 1, 'b': 2, 'c': 3}
a(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 a(a, b, c):
    print(a, b, c)
 
 
l1 = [123, 321, 132]
# 方法1索引取值（不推荐）
a(l1[0], l1[1], l1[2])  # 123 321 132
# 方法二用*来进行赋值
a(*l1)  # 123 321 132
l2 = ['aaa', 'bbb', 'ccc']
a(*l2)  # aaa bbb ccc
s1 = 'tom'
a(*s1)  # t o m
set1 = {123, 1231, 321}  # 集合不能重复否则会报错
a(*set1)  # 321 123 1231
dic1 = {'username': 'jason', 'pwd': 123, 'age': 18}
a(*dic1)  # username pwd age取的是键
a(*dic1.values())  # jason 123 18取的是值
*在实参中
    类似于for循环 将所有循环遍历出来的数据按照位置参数一次性传给函数
def user_info(name, password, age):
    print(name, password, age)
 
 
d1 = {'name': 'mingming', 'password': 123, 'age': 18}
user_info(name=d1['name'], password=d1['password'], age=d1['age'])  # mingming 123 18
user_info(*d1.values())  # mingming 123 18
user_info(**d1)  # mingming 123 18
user_info(name='mingming', password=123, age=18)  # mingming 123 18
**在实参中
    将字典打散成关键字参数的形式传递给函数
def a(*args, **kwargs):
    print(args, kwargs)
a(*[11, 22, 33, 44])  # (11, 22, 33, 44) {}
a(*(11, 22, 33, 44))  # (11, 22, 33, 44) {}
 

命名关键参数

形参必须按照关键字参数传值>>>:命名关键字参数
def a(name, *args, gender='male', **kwargs):
	print(name, args, gender, kwargs)
 
 
a('mingming', 1, 2, 3, 4, 5, a=1, b=2)  # mingming (1, 2, 3, 4, 5) male {'a': 1, 'b': 2}
a('leilei', 1, 2, 2, 2, gender='female', a=1, b=2)  # leilei (1, 2, 2, 2) female {'a': 1, 'b': 2}
 

名称空间与作用域

名称空间

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

1.内置名称空间

python解释器打开会自动加载内置的名称空间，储存的多是内置关键字名字
eg :open input print with def

2.全局名称空间

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	

3局部名称空间

函数的调用/结束而临时产生/回收，函数的形参、函数内定义的名字都会被存放于该名称空间中
def foo(x):
    y=3

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

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

名字的查找顺序

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

查找顺序案例

1在python文件中相互独立的方法的命名空间默认是不能够互相访问的
	 def a():
    	name = 'jason'
    	print(age)
 
    def b():
       age = 18
       print(name)
2局部空间嵌套
  先从自己的局部名称空间查找 之后由内而外依次查找
x = '123321'
def func1():
    x = 1
    def func2():
        x = 2
        def func3():
            x = 3
            print(x)#3
        func3()
        print(x)#2
    func2()
    print(x)#1
func1()
print(x)#123321

作业

# .判断下列money的值是多少并说明理由
# 思考如何修改而不是新增绑定关系
money = 100
def index():
    money = 666
print(money)#100因为money用的是全局名称空间
 
 
money = 100
def func1():
    money = 666
def func2():
    money = 888
    func2()
print(money)#100100因为money用的是全局名称空间没有调用里面变量，如果使用局部名称空间就必须在空间内。
money = 100
def index():
    money = 666
    print(money)
index()#666
money = 100
def func1():
    money = 666
    def func2():
        money = 888
        print(money)#888
    func2()
    print(money)#666
func1()
print(money)#100