1. 动态参数
位置参数的动态参数
def chi(*food):
print("我要吃",food)
chi("小米粥","绿豆粥","八宝粥") #多个参数传递进去,收到的是元祖tuple
def func(a,b,c,*args,d=5):
print(a,b,c,d,args)
func(1,2,3)
func(1,2,3,4,56,7)
func(1,2,3,4,5,6,7,"马大哈")
关键字参数的动态参数
def func(**food): # **food动态接收关键字参数
print(food) # 接收到的是字典
func(good_food="盖浇饭", bad_food="辣条", drink="冰封") #结果是我要吃 {'good_food': '火锅', 'bad_food': '快餐'}
顺序:位置参数,*args,默认值,**args
这个函数可以接受所有的参数(无敌)
可以接收所有的参数(无敌的)
def func(*args, **kwargs):
print(args)
print(kwargs)
func(1, 2, 5, 6, name="taibai",age=18, sex="不详")
在形参上*聚合,**聚合;在实参上*打散,**打散.
# 把列表中的每一个元素作为参数, 传递给函数. 一次都传过去
def func(*args,**kwargs): #*表示聚合,所有的位置参数,聚合成元祖
print(args)
print(kwargs)
lst = ["马虎疼","大眼哥","小花生","毛尖妹妹"]
func(*lst) #实参打散,迭代产生的. #结果是('马虎疼', '大眼哥', '小花生', '毛尖妹妹')
def func(*args,**kwargs): #**表示聚合成字典
print(args)
print(kwargs)
dic={"name":"太白","alex":"wusir"}
func(**dic) #将字典打散,以key:value的形式进行传参.
给函数传递任意个整数,返回和.
#给函数传递任意个整数,返回和 # def func(*n): # s = 0 # for i in n: # s = s + i # return s # print(func(1,3,5,6,8))
注意点:
def func(*args, **kwargs):
# args = (1,2,3) #接收的是元祖
#kwargs = {'name':'alex,'age':23} #接受的是字典
print(*args) # print(*(1,2,3)) #print(函数中有*args对象) 打印1,2,3
print(**kwargs) # print(**{'name':'alex', 'age':1000}) #print(函数中没有**args对象) 报错
# 当定义一个函数的时候:* 代表 聚合.
# 当执行一个函数的时候:* 代表 打散.
func(1, 2, 3, name='alex', age=1000)
2. 命名空间和作用域:
命名空间:
1.内置命名空间:python解释器内部运行时的变量函数
2.全局命名空间:我们在py文件中直接声明出来的变量,函数
3.局部命名变量:在函数内部声明的变量和函数
作用域:
1.全局作用域:内置+全局
2.局部作用域:局部
globals()查看全局作用域中的名字
locals()查看当前作用域中的名字
a = 10
def func():
a = 20
print(a)
print(globals()) #globals() 获取到全局作用域(内置,全局)中的所有名字
print(locals()) #locals() 查看当前作用域中的所有名字
func()
3. global和nonlocal
glocal:把全局变量拿到局部来用
a = 20
def func():
global a #a不在是局部变量,是全局变量
a = 30 #把全局中的a重新赋值成30
print(a) 30
func()
print(a) 30
nonlocal:把离他最近的一层变量拿过来,不会找全局.
a = 10
def fun1():
a = 3
def func2():
nonlocal a # 找局部作用域中 离他最近的那个变量引入进来
a = 20
print(a) #结果是:20
func2()
print(a) #结果是:20
fun1()
接收n个参数,返回最大值和最小值
接收n个参数. 返回最大值和最小值(字典)
def func(*args):
m = args[0] # 假设第0项就是最大值
mi = args[0]
for el in args:
if el > m:
m = el # 当前这个元素比假设的那个大. 记录当前这个比较大的数
if el < mi:
mi = el
return {"最大值":m, "最小值":mi}
如果默认值参数是一个可变的数据类型,如果有人调用的时候改变了他,其他的位置看到的也跟着改变了.
# 如果默认值参数是一个可变的数据类型, 如果有人调用的时候改变了他. 其他位置看到的也跟着改变了
def extendList(val, list=[]):
list.append(val)
return list
list1 = extendList(10) #列表[10],列表指向的内存地址中存有10
list2 = extendList(123, []) #给了一个空的列表,默认值参数改变了成[],此时向里加了[123]
list3 = extendList('a') #此时向列表中加a,列表指向的是同一个内存地址,所以是[10,a]
print('list1=%s' % list1) [10,a] #如果默认值参数是一个可变的数据类型, 如果有人调用的时候改变了他. 其他位置看到的也跟着改变了
print('list2=%s' % list2) [123 ]
print('list3=%s' % list3) [10,a]
9*9乘法表
a = 1
while a <=9:
b = 1
while b <= a:
print("%dx%d=%d " % (a, b, a*b), end="")
b = b + 1
print() # 换行
a = a + 1
考试题;
user_list=[
{"name": "alex", "hobby": "抽烟"},
{"name": "alex", "hobby": "喝酒"},
{"name": "alex", "hobby": "烫头"},
{"name": "wusir", "hobby": "喊麦"},
{"name": "wusir", "hobby": "街舞"},
{"name": "alex", "hobby": "泡吧"},
{"name":"太白", "hobby":"开车"}
]
# [{"name": "alex", "hobby_list": ["抽烟","喝酒","烫头","泡吧"]},{"name": "wusir", "hobby_list": ["喊麦", "街舞"]},]
result = [] # {'name': 'alex', 'hobby_list': ['抽烟']}
for user in user_list:
# 1.判断是否在result里面存在了这个人, 如果存在. 把hobby_list添加一个hobby
# 2.不存在. 创建一个新字典
for new_user in result:
if user['name'] == new_user['name']:
new_user['hobby_list'].append(user['hobby'])
break
else:
dic = {}
dic["name"] = user['name']
dic['hobby_list'] = [user['hobby']]
result.append(dic)
print(result)