目录
调试---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))