Python：lambda函数

目录

调试---debug

tuple（元组）

set（集合）

dict（字典）

转换

推导式

上机练习 3

函数

参数

不定长参数

值传递与引用传递

局部和全局变量

上机练习 4

调试---debug

1. 先设置断点

2. 点击调试

3. 下一步执行，观察，分析，排错

4. 自己修改错误

tuple（元组）

元组（ tuple ），只读的列表。

tuple1 = (1,2,34,5,6)

print(type(tuple1))

print(tuple1[3])

for i in tuple1:

print(i)

set（集合）

集合（ set ），无序，去掉重复数据。

list1 = [1,2,2,3,34,46,7,7,8,5,55,7]

set1 = {1,2,3,4,5,5,4,3,2,1}

print(type(set1))

print(set1)

set2 = set(list1)

set2.add(66666)

set2.remove(55)

# 不能使用下标访问 set ，所以修改操作一般为 remove 操作 + add 操作

print(set2)

for i in set2:

print(i)

dict（字典）

字典（ dict ）是 Python 中另一个非常有用的内置数据类型。字典是键 (key) :

值 (value) 的集合。

在同一个字典中，键 (key) 必须是唯一的。创建空字典使用 { } 。 student = { "name" : "liubei" , "age" : 40 }

student[ "money" ] = 100

student[ "age" ] = 50

del student[ 'money' ]

print (student)

movie = {

"episodes_info" : "" ,

"rate" : "7.3" ,

"cover_x" : 1052 ,

"title" : " 空白 " ,

"url" : "https://movie.douban.com/subject/34990918\/" ,

"playable" : False ,

"cover" :

"https://img9.doubanio.com/view/photo/s_ratio_poster/public/p2

673290266.webp" ,

"id" : "34990918" ,

"cover_y" : 1499 ,

"is_new" : True

}

print ( type (movie))

for i in movie:

print (i,movie[i])

for i in movie.keys():

print (i)

for i in movie.values():

print (i)

转换

list(x) tuple(x) set(x)

eval(str) 将字符串转成相应对象

# 字典转换为列表

d1={"name":" 张三 ","class":4}

list1=list(d1.values())

print(list1)

# 字符串转成字典

s = '{"name":" 张三 ","sex":" 男 ","age":18,"class":43}'

d = eval(s)

print(type(d))

推导式

Python 支持各种数据结构的推导式：

列表 (list) 推导式

字典 (dict) 推导式

集合 (set) 推导式

元组 (tuple) 推导式 （生成器表达式）

四种可以交互使用

输入源： range list tuple set dict 输出源： list tuple set dict

推导式格式为：表达式 for 变量 in 输入源 if 条件

推导式格式为：表达式 for 变量 in 输入源 if 条件 for 变量 in 输入源

if 条件

# 给定一个列表 , 将每一位数字变成它的平方 alist = [1, 2, 3, 4, 5, 6, 7]

# 输出结果： [1, 4, 9, 16, 25, 36, 49]

alist = [1, 2, 3, 4, 5, 6, 7]

list1=[]

for i in alist:

list1.append(i**2)

print(list1)

# 改写

alist = [1, 2, 3, 4, 5, 6, 7]

print([i**2 for i in alist])

print([i**2 for i in alist if i+2>5])

print({i**2 for i in alist})

print(tuple((i**2 for i in alist)))

print({i**2:f"test{i}" for i in alist})

# 推导 30 以内可以被 3 整除的整数为列表：

print([i for i in range(30) if i % 3 == 0])

数据源使用字典 d1={" 张三 ":20," 李四 ":30," 王五 ":40}

# 推导列表

print([i for i in d1.values()])

# 推导字典

print({i:i**2 for i in d1.values() if i>20})

# 推导集合

print({i for i in d1.values() if i>20})

# 推导元组

print(tuple((i for i in d1.values() if i>20)))

# 二重循环 提取数字

l1=[[45,67,45,"hhh"],[34,65,78,"test"]]

print([j for i in l1 for j in i if type(j)==int])

上机练习 3

# 1. 已知列表 li= [11,22,100,33,44,66,55,77,88,99,90] ,将所有大于
66 的值保存至字典的
# 第一个 key 对应的列表中，将小于 66 的值保存至第二个 key 对应的列表中。
# 输出结果{'key1':[100,77,88,99,90],'key2':[11,22,33,44,55]}
# li= [11,22,100,33,44,66,55,77,88,99,90]
# liBiggerThen66=[]
# liLowerThen66=[]
# for i in li:
#
if i<66:
#
liLowerThen66.append(i)
#
elif i>66:
#
liBiggerThen66.append(i)
# di={'key1':liBiggerThen66,'key2':liLowerThen66}
# print(di)
# 2. list_three=["good", "nice", "see you", "bye"]，根据列表利用
推导式存放指定列表中
# 字符串的长度如下
# {'good':4, 'nice':4, 'see you':7, 'bye':3}
# list_three=["good", "nice", "see you", "bye"]
# print({i:len(i) for i in list_three})
# 3. 已知数据 t1=((1,100),(2,30),(3,80),(4,234))
# 推导成列表[100,30,80,234]
# 推导成字典{1: 100, 2: 30, 3: 80, 4: 234}
# 推导成列表[{'name': 1, 'value': 100}, {'name': 2, 'value': 30},
{'name': 3, 'value': 80},
# {'name': 4, 'value': 234}]
# t1=((1,100),(2,30),(3,80),(4,234))
# print([i[-1] for i in t1])
# print({i[0]:i[-1] for i in t1})# print([{'name':i[0],'value':i[-1]} for i in t1])
# 4. 已知如下数据
# d1 = {
# '192.168.1.1':{'cpu':'0.23','内存':'16','硬盘':'500'},
# '192.168.1.2':{'cpu':'3.22','内存':'64','硬盘':'700'},
# '192.168.1.3':{'cpu':'1.99','内存':'32','硬盘':'800'}
# }
# 处理显示成如下格式输出：
# 192.168.1.1: cpu 0.23 内存 16 硬盘 500
# 192.168.1.2: cpu 3.22 内存 64 硬盘 700
# 192.168.1.3: cpu 1.99 内存 32 硬盘 800
# d1 = {
# '192.168.1.1':{'cpu':'0.23','内存':'16','硬盘':'500'},
# '192.168.1.2':{'cpu':'3.22','内存':'64','硬盘':'700'},
# '192.168.1.3':{'cpu':'1.99','内存':'32','硬盘':'800'}
# }
# for i in d1:
#
print(f"{i}:",end=" ")
#
for j in d1[i]:
#
print(f"{j} {d1[i][j]}",end=" ")
#
print()
# 5. 有字符串"k: 1|k1:2|k2:3 |k3 :4" 处理成字典 { 'k': 1, 'k1': 2,
'k3': 4}
# str1="k: 1|k1:2|k2:3 |k3 :4"
# list1=":".join(str1.split("|")).split(":")
# print({list1[i]:int(list1[i+1]) for i in range(0,len(list1),2)
if i!=4})
# 6. 已知如下列表 students，在列表中保存了 6 个学生的信息，根据要求完
成下面的题目
# students = [
# {'name': '小花', 'age': 19, 'score': 90, 'gender': '女',
'tel':'15300022839'},
# {'name': '明明', 'age': 20, 'score': 40, 'gender': '男',
'tel':'15300022838'},
# {'name': '华仔', 'age': 18, 'score': 100, 'gender': '女',
'tel':'15300022839'},
# {'name': '静静', 'age': 16, 'score': 90, 'gender': '不明',
'tel':'15300022428'},
# {'name': 'Tom', 'age': 17, 'score': 59, 'gender': '不明',
'tel':'15300022839'},
# {'name': 'Bob', 'age': 18, 'score': 90, 'gender': '男',
'tel':'15300022839'}
# ]
# students = [# {'name': '小花', 'age': 19, 'score': 90, 'gender': '女',
'tel':'15300022839'},
# {'name': '明明', 'age': 20, 'score': 40, 'gender': '男',
'tel':'15300022838'},
# {'name': '华仔', 'age': 18, 'score': 100, 'gender': '女',
'tel':'15300022839'},
# {'name': '静静', 'age': 16, 'score': 90, 'gender': '不明',
'tel':'15300022428'},
# {'name': 'Tom', 'age': 17, 'score': 59, 'gender': '不明',
'tel':'15300022839'},
# {'name': 'Bob', 'age': 18, 'score': 90, 'gender': '男',
'tel':'15300022839'}
# ]
# 打印学生分数列表
# print([i['score'] for i in students])
# # # 打印手机尾号是 8 的学生的名字列表
# print([i['name'] for i in students if i['tel'][-1]=='8'])
# # 打印最高分和对应的学生的名字列表
# print([f"{j['name']} {j['score']}" for j in students if
j['score']==max([i['score'] for i in students])])
# 打印不及格的同学的所有信息列表，效果如下：
# print([j for i in students if i['score']<60 for j in i.values()])

函数

函数代码块以 def 关键词开头，后接函数标识符名称

return [ 表达式 ] 结束函数，返回一个或多个值给调用方，不带表达式的

return 相当于返

回 None ，多个值为元组。

命名方式：

变量名函数名 骆驼命名法 sayHelloTest

面向对象 类 帕斯卡命名法 SayHelloTest

# 声明

def sayHello():

print(" 你好 ")

# 调用

sayHello()

# 根据两个数求和

def getSum(n1,n2):

he=n1+n2

return he

result=getSum(5,3)

print(f" 结果是： {result}") # 根据两个数求和和差和积

def getJiSuan(n1,n2):

he=n1+n2

cha=n1-n2

ji=n1*n2

return he,cha,ji

result=getJiSuan(5,2)

print(result)

print(f" 和是： {result[0]}")

参数

位置参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。

使用关键字参数允许函数调用时参数的顺序与声明时不一致。

def getInfo(name,age):

print(f" 姓名是： {name}")

print(f" 年龄是： {age}")

getInfo(" 周杰伦 ",50)

getInfo(age=50,name=" 周杰伦 ")

# 默认值 放在最后

def getInfo(name,age=18):

print(f" 姓名是： {name}")

print(f" 年龄是： {age}")

getInfo(" 刘德华 ")

getInfo(name=" 刘德华 ")

不定长参数

加了星号 * 的参数会以元组 (tuple) 的形式导入，存放所有未命名的变量参数。

加了两个

星号 ** 的参数会以字典的形式导入。

def getNumTuple(n1, *n):

print(n1)

print(n)

getNumTuple(8,9,90,100,"hello",True,3.5)

def getNumDict(n1, **n):

print(n1)

print(n)

getNumDict(8,age=40,name=" 周杰伦 ")

值传递与引用传递

值传递：变量之间，数值的传递，这种传递相当于变量赋值；适用于实参类型为

不可变

类型（ int,float,bool,str,tuple ）

引用传递：传递的是地址（指针 / 对象）引用；适用于实参类型为可变类型

（ list,set,dict,class ） age=18

score=[60,80,90]

def update(age1,score1):

print(age1,score1)

age1=28

score1[0]=100

print(age1,score1)

print(age,score)

update(age,score)

print(age,score)

局部和全局变量

若想函数内部的变量能在外部访问，就需要在函数内部将其声明其为 global 变

量。

x = 4

def my():

global n

n = 8

print(n)

print("x 内 = ", x)

print("x 外 = ", x)

my()

print(n)

main 函数 --- 程序的入口

if __name__=="__main__":

print("test")

上机练习 4

# 1. 写函数,输入一个数字，传递到函数中，输出从 1 到此数
# def onetonum(number):
#
if number>1:
#
for i in range(1,number+1):
#
print(i)
#
else:
#
for i in range(1,number-1,-1):
#
print(i)
# if __name__=="__main__":
#
number=int(input("输入一个数字:"))
#
onetonum(number)
# 2. 写函数,接收两个数字参数,返回较大的那个数字
# def twonummax(n1,n2):
#
if not n1.isdigit() or not n2.isdigit():
#
print("有字符不是数字！")#
else:
#
if float(n1)>=float(n2):
#
print(n1,end=" ")
#
elif float(n1)<float(n2):
#
print(n2,end=" ")
#
print("这个大！")
# if __name__=="__main__":
#
print("输入两个数，比比看谁大！")
#
n1=input()
#
n2=input()
#
twonummax(n1,n2)
# 3. 写函数,输入账号和密码，传递到函数中，如果账号等于 admin,密码等于
123456 则输
# 出登录成功，否则输出登录失败
# def Admin_account(admin,password):
#
if admin=="admin" and password=="123456":
#
print("登录成功！")
#
else:
#
print("登录失败！")
# if __name__=="__main__":
#
print("输入账号密码：")
#
user=input("账号:")
#
password=input("密码:")
#
Admin_account(user,password)
# 4. 写函数,接收 n 个数字,返回这些数字的和、最小值、最大值
# def receiver(*n):
#
print(f"""它们的和：{sum(n)}
# 它们的最小值:{min(n)}
# 它们的最大值：{max(n)}""")
# if __name__=="__main__":
#
receiver(9,10,43,23)
#
receiver(10,80,40,20)
# 5. 写函数，接收一个不定长参数，为多个字符串，判断每个字符串的长度是
否为大于
# 5，如：isLen5("hello","worldd","test") 返回[False,True,False]
# 注：使用推导式
# def EstimateLen(*n):
#
return [len(i)>5 for i in n]
# if __name__=="__main__":
#
print(EstimateLen("hello","worldd","test"))
# 6. 写函数，接收一个字符串和一个不定长字符串，返回第一个字符串在不定
长字符串# 中出现几次,如：getNum("ab","b","a","ab","abc","ab","aabb","cd")
返回 2
# def getNum(str,*n):
#
count=0
#
for i in n:
#
if i==str:
#
count+=1
#
return count
# if __name__=="__main__":
#
print(getNum("ab","b","a","ab","abc","ab","aabb","cd"))
#
print(getNum("b","b","a","ab","abc","ab","aabb","cd"))
#
print(getNum("a","b","a","ab","abc","ab","aabb","cd"))
# 7. 写函数，传入一个不定长字典，检查传入字典的每一个 value 的长度，如
果大于 2，
# 那么仅仅保留前两个长度的内容，并将新内容作为列表返回
# 如：
getValue2(name1="jerry",name2="tom",name3="lily",name4="hh",na
me5="s")
# 返回['je','to','li','hh','s']
# def getValue2(**dict):
#
list1=[]
#
for i in dict.values():
#
if len(i)>2:
#
list1.append(i[:2])
#
else:
#
list1.append(i)
#
return list1
# if __name__=="__main__":
#
print(getValue2(name1="jerry",name2="tom",name3="lily",na
me4="hh",name5="s"))
# 8. 写函数，传入两个列表参数,返回一个扑克牌列表,里面有 52 项,每一项都
是一个 tuple
# list1=["红心","梅花","方块","黑桃"]
# list2=["A","2","3","4","5","6","7","8","9","10","j","q","k"]
# 结果输出如:[('红心','A'),('梅花','A')…('黑桃','k')]
# 注：使用推导式
# def joker(n,m):
#
return [(i,j) for i in m for j in n ]
# if __name__=="__main__":
#
list1=["红心","梅花","方块","黑桃"]
#
list2=["A","2","3","4","5","6","7","8","9","10","j","q","
k"]
#
print(joker(list1,list2))