如何调用形参数组_函数的参数

# 一。形参和实参
# 1.形参：在定义函数阶段定义的参数称之为形式参数，简称形参
# 2.实参：在调用函数阶段传简称实参入的值称为实际参数，
# 形参与实参的关系：
# 1.在调用阶段，实参（变量值）会赋值给形参（变量名） 形参（变量） = 实参（值）
# 2.这种绑定关系只能在函数体内使用
# 3.实参与形参的绑定关系在函数调用时生效，函数调用结束后解除绑定关系
# 实参是传入的值，但值可以是以下几种形式：
# 1.func（1，2）
# 2.func（x，y）
# 3.func（int('1'), 2）
# func(func(1,2), func(2, 3))
# 二。位置参数 最常见的函数参数的形式
# 2.1 位置参数：按照从左到右的顺序依次定义的参数称之为位置参数
# 2.1.1位置形参：在函数定义的阶段按照从左到右的顺序直接定义的‘变量名’
# 特点：必须被传值，多一个不行少一个也不行
# def func(x, y):
# print(x, y)
# func（值1， 值2）
# 2.1.2位置实参:在函数调用阶段按照从左到右的顺序依次传入的值
# 特点：按照顺序与形参一一对应
# func(1) # TypeError: func() missing 1 required positional argument: 'y'
# func(1, 2, 3) # TypeError: func() takes 2 positional arguments but 3 were given
# func(1, 2)
# func(2, 1)
# 2.2关键字参数：
# 关键字实参：在函数调用阶段，按照key=value的形式传入的值
# 特点：指定道姓给某个形参传值，可以完全不参照顺序
# def func(x, y):
# print(x, y)
# func(y=2, x=1)
# func（x=1， y=2）
# 混合使用，强调
# 1.位置实参必须放在关键字实参前
# 2.不能为同一个形参重复传值
#
# 2.3默认参数
# 默认参数：在定义函数阶段，就已经被赋值的形参，称之为默认参数
# 特点：在定义阶段就一定被赋值，意味这在调用阶段可以不赋值
# def func(x, y=3):
# print(x, y)
# func(1)
# func(1, y=2)
# 位置形参与默认形参混用，强调：
# 1.位置形参必须在默认形参的左边
# 2.默认参数的值是在函数定义阶段被赋值的, 准确的说被赋予的值的内存地址
# 示范一:
'''
m = 2
def func(x, y=m): # y = 2的内存地址
print(x, y)
m = 33333333333 # 把333333的内存地址给了m 但是已经给不了y了
func(1) # (1, 2)
'''
# 示范二：'''m = [11111111,]def func(x, y=m): # 因为列表是可变的，所以后期可以append y只是保存了内存地址 print(x, y)m.append(3333333333)func(1) # (1, [11111111,3333333333])'''
# 3.虽然默认值可以被指定为任意数据类型，但是不推荐使用可变类型'''def func(x, y, z, l=None): if l is None: l = [] l.append(x) l.append(y) l.append(z) print(l)func(1, 2, 3)'''
# 买烤冷面 口味 ：酸甜 两张 糖，辣椒，葱，姜，蒜
# x y *args
# 2.4可变长度的参数（*与**） *args元组 **kwargs字典
# 可变长度：在调用函数时，传入的值（实参）的个数不固定
# 而实参是为形参赋值的，所以对应着，针对溢出的实参，必须有对应的形参来接收
# def func(x, y, z,):
# pass
# func(1, 2, 3, 4, 5, 6)
# func(x=1, y=2, z=3, i=4, j=5)
# 2.4.1 可变长度的位置参数
# Ⅰ：*形参名：用来接收溢出的位置实参， 溢出的位置实参会被*保存成元组 ()
# *后跟的可以是任意名字，但最好写args
# def func(x, y, *z): # z 把参数保存成元组的形式
# print(x, y, z)
#
# func(1, 2, 3, 4, 5, 6) # z把3456保存成元组形式了'''def my_sum(*args): res = 0 for i in args: res += i return resprint(my_sum(1, 5, 7, 10))'''
# Ⅱ：*可以用在实参中，实参中带*，先讲*后的值打散成位置实参'''def func(x, y, z): print(x, y, z)# func([1, 2, 3]) # 这只是传了一个值func(*[1, 2, 3]) # 其实就是func(1, 2, 3) x=1 y=2 z=3l = [1, 2, 3]func(*l)'''
# Ⅲ：形参与实参中都带*'''def func(x, y, *args): # x=1 y=2 args = () print(x, y, args)l = (1, 2)func(*l)'''
# 2.4.2 可变长度的关键字参数
# Ⅰ：**形参名：用来接收溢出的关键字实参， **会将溢出的关键字实参保存成字典格式，然后赋值给紧跟**后、
# **后跟的可以是任意名字，默认kwargs'''def func(x, y, **kwargs): print(x, y, kwargs)func(1, y=2, a=1, b=2, c=3) # 1 2 {'a': 1, 'b': 2, 'c': 3}'''
# Ⅱ：**可以用在实参中（**后只能跟字典），实参中带**，先将**后的值打散成关键字实参'''def func(x, y ,z): print(x, y, z)func(*{'x': 1, 'y': 2, 'z': 3}) # x y z for i in dict.keys()func(**{'x': 1, 'y': 2, 'z': 3}) # 1 2 3func(**{'x': 1, 'a': 2, 'z': 3}) # 错的 func(x=1, a=2, z=3)'''
# Ⅲ：形参与实参中都带**'''def func(x, y, **kwargs): print(x, y, kwargs)func(**{'y': 111, 'x': 222, 'a': 333, 'b': 444}) # 222 111 {'a': 333, 'b': 444}'''
# 总结：混用*与**
# *args必须在**args之前'''def index(x, y, z): print(x, y, z) # 1 {'z':2, 'y':3} => 1 , z=2, y = 3 1 3 2def wrapper(*args, **kwargs): index(*args, **kwargs) # (x, y, z) 1, 2, 3 x=1, y=2, z=3 # index(*(1,), '**{z'=2, 'y'=3}) # index(1, z=2, y=3) ==>> index(1, 3, 2)wrapper(1, z=2, y=3) # 1 3 2'''
# 原格式--》汇总--》打回原形
# 2.5 命名关键字参数
# 总结：位置，关键字，*args, **kwargs
# 位置参数 》 *args > 关键字参数 > **kwargs
# 位置 》 关键字参数
def a(x, *args, y=2, **kwargs):
print(x, args, y, kwargs)
a(1, 3, 5, 6 ,7 ,8, a=9)

# 1、写函数，，用户传入修改的文件名，与要修改的内容，执行函数，完成批了修改操作
# import os
#
#
# def zuoye(file, my_str):
# with open(file, 'r', encoding='utf-8') as f, open('2.txt', 'w', encoding='utf-8') as f1:
# while True:
# line = f.readline()
# if len(line) == 0:
# f1.write(my_str)
# break
# else:
# f1.write(line)
# os.remove(file)
# os.rename('2.txt', file)
#
#
# zuoye('1.txt', '批了')
# 2、写函数，计算传入字符串中【数字】、【字母】、【空格] 以及 【其他】的个数
# def analysis_str(my_str):
# a, b, c, d = 0, 0, 0, 0
# for i in my_str:
# if i.isalpha():
# a += 1
# elif i.isalnum():
# b += 1
# elif i.isspace():
# c += 1
# else:
# d +=1
# print('字母：%d，数字：%d，空格：%d，其他：%d' % (a, b, c, d))
#
#
# analysis_str('asd 2343 32 eda哈哈哈&……%￥……')
# 3、写函数，判断用户传入的对象（字符串、列表、元组）长度是否大于5。
# def _analusis(a):
# if len(a) > 5:
# print('大于5')
# else:
# print('不大于5')
#
# _analusis([1, 2, 3, 4, 5, 5, 6])
# 4、写函数，检查传入列表的长度，如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。
# def analysis(a):
# if len(a) > 2:
# return a[:2]
# else:
# return a
#
#
# print(analysis([3, 2, 1]))
# 5、写函数，检查获取传入列表或元组对象的所有奇数位索引对应的元素，并将其作为新列表返回给调用者。
# def analysis_1(a):
# my_list = []
# for i in range(0, len(a), 2):
# my_list.append(a[i])
# return my_list
#
#
# print(analysis_1([1, 2, 3, 4, 5, 6, 7, 8]))
# 6、写函数，检查字典的每一个value的长度,如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。
# dic = {"k1": "v1v1", "k2": [11,22,33,44]}
# PS:字典中的value只能是字符串或列表
# def analysis_dict(a):
# for key, value in a.items():
# if len(value) > 2:
# value = value[:2]
# a[key] = value
# else:
# a[key] = value
# return a
#
#
# dic = {"k1": "v1v1", "k2": [11,22,33,44]}
# print(analysis_dict(dic))