python 函数嵌套的参数_Python-函数：参数类型、传参、嵌套

函数类型

必须参数

函数调用时必须要传的参数，必须以正确的顺序传入，调用的时候必须和声明的时候保持一致

def f(name, age):

print('I am %s , I am %d years old'%(name, age))

f(18, 'eric')

关键字参数

在函数调用时，通过“键-值”形式加以指定。清除了参数的顺序需求，允许函数调用时和声明时顺序不一致

f(age=18, name='eric')

默认参数

定义函数时为参数提供默认值，调用函数时可传也可不传该默认参数的值(所有必须参数必须出现在默认参数前，包括函数定义和调用)。当缺省参数没有传入，默认值会生效

def f(name, age, sex = 'male' ):

print('I am %s , I am %d years old'%(name, age))

print('Sex : %s'%sex)

f(name='李四', age=19)

f('张三', 88, sex='female')

可变长度参数

以*开头代表着一个任意长度的元组，可将一连串参数都放到一个元组中

def self_print(name,*a):

print(a)

print(type(a))

self_print(1,2,3,4,5)

>>>

(2, 3, 4, 5)

以**开头代表着一个字典，参数的形式是“key=value”，可以接受连续任意多个参数

def d_self_print(**kwargs):

print(kwargs)

print(type(kwargs))

d_self_print(last_name="dsf",first_name="Af")

>>>

{'last_name': 'dsf', 'first_name': 'Af'}

*有拆开元组、列表的作用

t=(1,2,3,4,5)

print(*t)

def f(*tt):

print(tt)

f(*[1,2,3,4,5])

>>>

1 2 3 4 5

(1, 2, 3, 4, 5)

**有拆字典的作用

def ff(**kwargs):

print(kwargs)

ff(**{'name':'zhangsan','age':20})

>>>

{'name': 'zhangsan', 'age': 20}

形参顺序：位置参数->元组->字典

def mix(name,*t,**kw):

print(name)

print(t)

print(kw)

mix("zhangsan",20,'dongqin',gender="女")

>>>

zhangsan

(20, 'dongqin')

{'gender': '女'}

return 返回值，可用逗号分隔，返回多个值

def sum_and_avg(*numbers):

total = sum(numbers)

avg_number = total /len(numbers)

return total,avg_number

sum,avg = sum_and_avg(1,2,3,4,5,6,7,8,9,10)

print("%f %f"%(sum,avg))

>>>

55.000000 5.500000

函数传参

数据分为引用类型，普通类型

Pyhton中基本类型都是普通类型，如：数、布尔型、字符串、

其他都为引用类型

普通类型赋值的时候，传的是值本身

引用类型赋值的时候，传的是值地址

传参的本质就是赋值操作，引用类型原数据会被修改

l1=[1,2,3,4,5]

l2=l1

l1[0]=4

print(l1)

print(l2)

>>>

[4, 2, 3, 4, 5]

[4, 2, 3, 4, 5]

def power(numbers):

# numbers=[x**2 for x in numbers]

numbers=numbers[:] #通过复制避免了被引用修改

numbers[3]=10

return numbers

nums=[1,2,3,4,5,6,7,8,9,10]

print(power(nums))

print(nums)

>>>

[1, 2, 3, 10, 5, 6, 7, 8, 9, 10]

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

闭包——函数嵌套

函数名的本质就是函数的地址

内层函数可以访问外层函数的变量但是不能修改

内层函数访问变量时会先从自己内部查找变量，找不到则层层向上查找

Pyhton中，变量的作用域是以函数为单位的

global修饰变量，说明使用的是最外层的全局变量

nolocal修饰变量，说明使用的嵌套层函数的变量

def fun():

print("hello world!")

f=fun

f()

aa=10

def outter():

aa=20

def inner():

global aa

aa-=1

print(aa)

return inner

fo =outter()

fo()

>>>

hello world!

9