Python的一些基础实操练习题

书接上文多看一眼多进步，python入门到放弃，是根据python的知识点的一些基础练习题，说了是基础练习题，基础练习题，基础练习题，水平高的就别看了，平高的就别看了，高的就别看了，的就别看了，就别看了，别看了，看了，了，，也是B站python上的内容。

实操案例一

向文件输出“奋斗成就更好的你”

#方式一：使用print方式输出（输出的目的地是文件）
fp=open('d:/demo.txt','w')
print('奋斗成就更好的你',file=fp)
fp.close()
#方式二：使用文件读写操作
with open('d:/demo1.txt','w') as file:
    file.write('奋斗成就更好的你')
1
2
3
4
5
6
7

实操案例二

1.输出一本书的基本信息

book_name='Java程序设计教程'
publish='西安电子科技大学出版社'
pub_date='2019-02-02'
price=56.8
print('------------------------')
print('《',book_name,'》\t\t')
print('出版社：',publish,'\t')
print('出版时间：',pub_date,'\t')
print('定价：',price,'\t')
1
2
3
4
5
6
7
8
9

运行结果：

------------------------
《 Java程序设计教程 》		
出版社： 西安电子科技大学出版社 	
出版时间： 2019-02-02 	
定价： 56.8 	
1
2
3
4
5

2.按顺序：名字输出相应内容

#列表
lst_sng=['1:','2:','3:','4:','5:']
lst_name=['林黛玉','薛宝钗','贾元春','贾探春','史湘云']
for i in range(5):
    print(lst_sng[i],lst_name[i])
print('------------------------------')
#字典
d={'1:':'林黛玉','2:':'薛宝钗','3:':'贾元春','4:':'贾探春','5:':'史湘云'}
for key in d:
    print(key,d[key])
print('-------------zip---------')
for s,name in zip(lst_sng,lst_name):
    print(s,name)
1
2
3
4
5
6
7
8
9
10
11
12
13

运行结果：

1: 林黛玉
2: 薛宝钗
3: 贾元春
4: 贾探春
5: 史湘云
------------------------------
1: 林黛玉
2: 薛宝钗
3: 贾元春
4: 贾探春
5: 史湘云
-------------zip---------
1: 林黛玉
2: 薛宝钗
3: 贾元春
4: 贾探春
5: 史湘云
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

3.输出BMI指数

#输出BMI指数
height=170#身高
weight=50.5#体重
bmi=weight/(height+weight)
print('你的身高是：'+str(height))
print('你的体重是：'+str(weight))
print('你的bmi指数是：{:0.2f}'.format(bmi))
1
2
3
4
5
6
7

运行结果：

你的身高是：170
你的体重是：50.5
你的bmi指数是：0.23
1
2
3

实操案例三

1.输入一个十进制整数，分别将其转换为二进制，八进制，十六进制

def fun():
    num = int(input('请输入一个人十进制的整数'))  # 将str类型转换为int类型
    print(num, '的二进制数为：', bin(num))  # 第一种，使用了个数可变的位置参数
    print(str(num) + '的二进制数为“：' + bin(num))  # 第二种，使用+作为连接符（+的左右为str类型）
    print('%s的二进制数为：%s' % (num, bin(num)))  # 第三种，格式化字符串  %作占位符 %s：字符串
    print('{0}的二进制数为：{1}'.format(num, bin(num)))  #第三种，格式化字符串  {}作占位符
    print(f'{num}的二进制数为：{bin(num)}')  # 第三种，格式化字符串   f-string
    print('-----------------------------')
    print(f'{num}的八进制数为：{oct(num)}')
    print(f'{num}的十六进制数为:{hex(num)}')
'''
if__name__== '__main__'的意思是:
当py文件被直接运行时,if__name__=='__main__'之下的代码将被运行;
当py文件以模块形式被导入时,if __name__=='__main__'之下的代码块不被运行。
'''
if __name__ == '__main__':
    while True:
        try:
            fun()
            break
        except:
            print('只能输入整数！程序出错，请重新输入！')

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

运行结果：

请输入一个人十进制的整数8
8 的二进制数为： 0b1000
8的二进制数为“：0b1000
8的二进制数为：0b1000
8的二进制数为：0b1000
8的二进制数为：0b1000
-----------------------------
8的八进制数为：0o10
8的十六进制数为:0x8
1
2
3
4
5
6
7
8
9

2.给手机充话费，输出一共多少话费

#\033[0:35m8元\033[m  意思是给“8”设定颜色
print('用户手机账户原有话费余额为：\033[0:35m8元\033[m')
money=int(input('请输入用户充值金额：'))
money+=8
print('当前的余额为：\033[0:35m',money,'元\033[m')
1
2
3
4
5

运行结果：

用户手机账户原有话费余额为：8元
请输入用户充值金额：100
当前的余额为： 108 元
1
2
3

为了更清晰的看到颜色，截图如下：

3.输入行走步数，计算消耗卡路里

num=int(input('请输入您当天行走的步数'))
calorie=num*28
print(f'今天共消耗了卡路里{calorie},即{calorie/1000}千卡')#{}作占位符
1
2
3

运行结果：

请输入您当天行走的步数20000
今天共消耗了卡路里560000,即560.0千卡
1
2

4.输入父亲母亲身高，估算孩子身高

father_height=float(input('请输入父亲身高：'))#身高一般有小数，所以转换为float类型
mother_height=float(input('请输入母亲身高'))
child_height=(father_height+mother_height)*0.54
print('预测子女的身高为：{}cm'.format(child_height))#{}占位符
print(f'预测子女的身高为：{child_height}cm')#f-string
print('预测子女的身高为：%.3fcm'%(child_height))#%作占位符
1
2
3
4
5
6

运行结果：

请输入父亲身高：170
请输入母亲身高170
预测子女的身高为：183.60000000000002cm
预测子女的身高为：183.60000000000002cm
预测子女的身高为：183.600cm
1
2
3
4
5

实操案例四

1.判断输入的密码是否正确

pwd=input('支付宝支付密码：')
#法一
if pwd.isdigit():#判断输入的是否全是数字
    print('支付数据合法')
else:
    print('支付密码不合法，密码只能是数字')

print('-----------------------')
#法二
print('支付数据合法' if pwd.isdigit() else '支付密码不合法，密码只能是数字')
1
2
3
4
5
6
7
8
9
10

运行结果：

支付宝支付密码：123f
支付密码不合法，密码只能是数字
-----------------------
支付密码不合法，密码只能是数字

1
2
3
4
5

2.验证qq登录

qq=input('请输入QQ号：')
pwd=input('请输入密码：')
if '123'==qq and '123' == pwd:
    print('登录成功')
else:
    print('对不起，账号或密码不正确')
1
2
3
4
5
6

运行结果：

请输入QQ号：123
请输入密码：123
登录成功
1
2
3

3.竞猜商品价格

import random#导入random包
price=random.randint(1000,1500)#随机生成一个1000-1500的数字
print('今日竞猜的商品为小米扫地机器人，价格范围在1000-1500之间:')
while True:
    guess = int(input('请输入你猜测的价格：'))
    if guess > price:
        print('大了')
    elif guess < price:
        print('小了')
    else:
        print('猜对了')
        break
print('真实的价格为：',price)
1
2
3
4
5
6
7
8
9
10
11
12
13

今日竞猜的商品为小米扫地机器人，价格范围在1000-1500之间:
请输入你猜测的价格：1250
小了
请输入你猜测的价格：1375
小了
请输入你猜测的价格：1450
大了
请输入你猜测的价格：1410
小了
请输入你猜测的价格：1430
小了
请输入你猜测的价格：1440
大了
请输入你猜测的价格：1435
大了
请输入你猜测的价格：1433
大了
请输入你猜测的价格：1432
大了
请输入你猜测的价格：1431
猜对了
真实的价格为： 1431

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

实操案例五

1.输出26个英文字母对应的ASCII

x=97#代表的是a的ASCII值
for _ in range(1,27):#for _ 代表只起到迭代作用从1到26
    print(chr(x),'--->',x)#内置函数chr可以得到对应的字符
    x=x+1

print('-----------------')
x=97
while x<123:
    print(chr(x),'-->',x)
    x=x+1
1
2
3
4
5
6
7
8
9
10

运行结果：

a ---> 97
b ---> 98
c ---> 99
d ---> 100
e ---> 101
f ---> 102
g ---> 103
h ---> 104
i ---> 105
j ---> 106
k ---> 107
l ---> 108
m ---> 109
n ---> 110
o ---> 111
p ---> 112
q ---> 113
r ---> 114
s ---> 115
t ---> 116
u ---> 117
v ---> 118
w ---> 119
x ---> 120
y ---> 121
z ---> 122
-----------------
a --> 97
b --> 98
c --> 99
d --> 100
e --> 101
f --> 102
g --> 103
h --> 104
i --> 105
j --> 106
k --> 107
l --> 108
m --> 109
n --> 110
o --> 111
p --> 112
q --> 113
r --> 114
s --> 115
t --> 116
u --> 117
v --> 118
w --> 119
x --> 120
y --> 121
z --> 122
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

2.有三次输入账号和密码的机会

for i in range(1,4):
    user_name=input('请输入用户名：')
    user_pwd=input('请输入密码：')
    if user_name=='admin' and user_pwd=='8888':
        print('登录成功')
        break
    else:
        print('用户名或密码不正确')
        if i<3:
            print(f'您还有{3-i}次机会')
else:#说明三次机会用完了
    print('对不起，三次均输入错误，请联系后台管理员')
1
2
3
4
5
6
7
8
9
10
11
12

运行结果：

请输入用户名：admin
请输入密码：88
用户名或密码不正确
您还有2次机会
请输入用户名：admin
请输入密码：8888
登录成功
1
2
3
4
5
6
7

3.玩游戏猜测随机生成的一个数是多少

import random#导入包
rand=random.randint(1,100)#随机生成一个1-100的数
for i in range(1,11):#最多猜10次
    num=int(input('在我心中想了一个1-100，请您猜一猜：\n'))
    if num<rand:
        print('小了')
    elif num>rand:
        print('大了')
    else:
        print('恭喜您，猜对了')
        break
if i<3:
    print(f'猜了{i}次真聪明')
elif i<7:
    print(f'猜了{i}次还凑合')
else:
    print(f'猜了{i}次得加油学习一下折半查找')

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

运行结果：

在我心中想了一个1-100，请您猜一猜：
50
小了
在我心中想了一个1-100，请您猜一猜：
75
小了
在我心中想了一个1-100，请您猜一猜：
88
大了
在我心中想了一个1-100，请您猜一猜：
81
大了
在我心中想了一个1-100，请您猜一猜：
78
大了
在我心中想了一个1-100，请您猜一猜：
77
恭喜您，猜对了
猜了6次还凑合

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

4.找一下100-1000之内的水仙花数

import math#导包
for i in range(100,1000):
    if math.pow((i%10),3)+math.pow((i//10%10),3)+math.pow((i//100),3)==i:
        print(i,'i的百位:',(i//100),'i的十位:',(i//10%10),'i的个位:',(i%10))
1
2
3
4

运行结果：

153 i的百位: 1 i的十位: 5 i的个位: 3
370 i的百位: 3 i的十位: 7 i的个位: 0
371 i的百位: 3 i的十位: 7 i的个位: 1
407 i的百位: 4 i的十位: 0 i的个位: 7
1
2
3
4

实操案例六

1.千年虫

year=[82,89,88,86,85,00,99]
print('原列表：',year)
for index,value in enumerate(year):
    # print(index,value)
    if str(value)!='0':
        year[index]=int('19'+str(value))
    else:
        year[index]=int('200'+str(value))

print('修改之后的列表：',year)
#对列表进行排序
year.sort()
print('排序之后的列表为:',year)
1
2
3
4
5
6
7
8
9
10
11
12
13

运行结果：

原列表： [82, 89, 88, 86, 85, 0, 99]
修改之后的列表： [1982, 1989, 1988, 1986, 1985, 2000, 1999]
排序之后的列表为: [1982, 1985, 1986, 1988, 1989, 1999, 2000]
1
2
3

2.为购物车加商品

#一个空列表
lst=[]
for i in range(0,3):
    goods=input('请输入商品编号和商品名称，一次输入一个:\n')
    lst.append(goods)#在列表的末尾添加一个元素
for item in lst:#遍历一下你所添加的商品
    print(item)

#购物车
cart=[]
while True:
    num = input('请输入你所选的商品编号：\n')
    for item in lst:
        if item.find(num) != -1:
            cart.append(item)
            break  # 说明该商品编号存在，此时已加入购物车，退出for循环
    else:#把商品列表遍历完发现没有你要加入购物车的内容
        print('你所输入的商品编号不存在，请重新输入吧！')
    if num=='q':
        break#退出while循环
print('你所选购的商品为：')
# for item in cart:
#     print(item)
for i in range(len(cart)-1,-1,-1):
    print(cart[i])#保证最后加入购物车的在最上面
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

运行结果：

请输入商品编号和商品名称，一次输入一个:
1001 手机
请输入商品编号和商品名称，一次输入一个:
1002 电脑
请输入商品编号和商品名称，一次输入一个:
1003 书包
1001 手机
1002 电脑
1003 书包
请输入你所选的商品编号：
1001
请输入你所选的商品编号：
1002
请输入你所选的商品编号：
1003
请输入你所选的商品编号：
1000
你所输入的商品编号不存在，请重新输入吧！
请输入你所选的商品编号：
q
你所输入的商品编号不存在，请重新输入吧！
你所选购的商品为：
1003 书包
1002 电脑
1001 手机
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

实操案例七

部分几个星座的性格，没写全

con=['白羊座','金牛座','双子座','巨蟹座','狮子座','处女座']
nature=['积极乐观','固执内向','圆滑世故','多愁善感','蜜汁自信','精明计较']
a=zip(con,nature)
for item in a:
    print(item)
print('-------------------')
#将两个列表转成字典
d=dict(zip(con,nature))
for item in d:
    print(item,d[item])
print(d)
print('-----------------------')
a=1
while a:
    flag = False  # 一个标志
    key = input('请输入您的星座名称：')
    for item in d:
        if item == key:
            print(key, '您的性格特点为：', d.get(key))
            flag = True
            a=0
            break

    else:
        flag = False

    if not flag:
        print('您输入的星座有误，请重新输入')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

运行结果：

('白羊座', '积极乐观')
('金牛座', '固执内向')
('双子座', '圆滑世故')
('巨蟹座', '多愁善感')
('狮子座', '蜜汁自信')
('处女座', '精明计较')
-------------------
白羊座 积极乐观
金牛座 固执内向
双子座 圆滑世故
巨蟹座 多愁善感
狮子座 蜜汁自信
处女座 精明计较
{'白羊座': '积极乐观', '金牛座': '固执内向', '双子座': '圆滑世故', '巨蟹座': '多愁善感', '狮子座': '蜜汁自信', '处女座': '精明计较'}
-----------------------
请输入您的星座名称：b
您输入的星座有误，请重新输入
请输入您的星座名称：白羊座
白羊座 您的性格特点为： 积极乐观
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

2.购票进站

dict_ticket={#key:value。其中key为车次，value为列表
    'G1569':['北京南-天津南','18:05','18:39','00:34'],
    'G1967':['北京南-天津南','18:15','18:49','00:34'],
    'G1917':['北京南-天津南','18:20','19:39','00:38'],
    'G2023':['北京南-天津南','18:35','18:37','00:54']
}#此内容为胡编乱造，如有雷同，纯属巧合，可改
print('车次\t\t出发站-到达站\t\t出发时间\t\t到达时间\t\t历时时长')
for item in dict_ticket:
    print(item,end='   ')
    for i in dict_ticket[item]:
        print(i,end='\t\t')
    print()#换行
flag=True
while flag:
    # 输入要购买的车次
    train_no = input('请输入本次要购买的车次：')
    for item in dict_ticket:
        if train_no == item:
            flag=False
            break
    else:
        flag=True
        print('您输入的车次有误，请检查是否输入正确')
persons=input('请输入乘车人，如果是多人请您以逗号分割')
s=f'您已购买了{train_no}次列车'
s_info=dict_ticket[train_no]#获取车次详细信息
s+=s_info[0]+'  '+s_info[1]+'  开，'
print(f'{s}请{persons}尽快取纸质车票')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

车次		出发站-到达站		出发时间		到达时间		历时时长
G1569   北京南-天津南		18:05		18:39		00:34		
G1967   北京南-天津南		18:15		18:49		00:34		
G1917   北京南-天津南		18:20		19:39		00:38		
G2023   北京南-天津南		18:35		18:37		00:54		
请输入本次要购买的车次：acs
您输入的车次有误，请检查是否输入正确
请输入本次要购买的车次：G2023
请输入乘车人，如果是多人请您以逗号分割呜哈哈，嘻哈哈
您已购买了G2023次列车北京南-天津南  18:35  开，请呜哈哈，嘻哈哈尽快取纸质车票
1
2
3
4
5
6
7
8
9
10

实操案例八

1.咖啡馆喝咖啡

#喝咖啡 本案例使用元组实现
coffee_name=('蓝山','卡布奇诺','拿铁','皇家咖啡')
print('您好！欢迎光临')
print('本店经营的咖啡有：')
for index,item in enumerate(coffee_name):
    print(index+1,'.',item,end='   ')
print()
index=int(input('请输入你选购的咖啡编号：'))
if 0<=index<=len(coffee_name):
    print(f'您的咖啡【{coffee_name[index-1]}】好了，请您慢用！')
1
2
3
4
5
6
7
8
9
10

运行结果：

您好！欢迎光临
本店经营的咖啡有：
1 . 蓝山   2 . 卡布奇诺   3 . 拿铁   4 . 皇家咖啡   
请输入你选购的咖啡编号：3
您的咖啡【拿铁】好了，请您慢用！
1
2
3
4
5

2.显示五名的排行

#输出前五名 此案例为元组里套元组
scores=(('广州恒大',72),('北京国安',7),('上海上港',66),('江苏苏宁',53),('山东鲁能',51))
for index,item in enumerate(scores):
    print(index+1,'.',end=' ')
    for score in item:
        print(score,end='  ')
    print()
1
2
3
4
5
6
7

运行结果：

1 . 广州恒大  72  
2 . 北京国安  7  
3 . 上海上港  66  
4 . 江苏苏宁  53  
5 . 山东鲁能  51  
1
2
3
4
5

3.模拟手机通讯录

#模拟手机通讯录
phones=set()
for i in range(5):
    info=input(f'请输入第{i+1}个联系人的姓名与电话：\n')
    phones.add(info)
print('------------------')
for item in phones:
    print(item)
1
2
3
4
5
6
7
8

运行结果：

请输入第1个联系人的姓名与电话：
张三111
请输入第2个联系人的姓名与电话：
李四222
请输入第3个联系人的姓名与电话：
王五333
请输入第4个联系人的姓名与电话：
赵六444
请输入第5个联系人的姓名与电话：
马奇555
------------------
赵六444
王五333
李四222
张三111
马奇555
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

实操案例九

1.统计字符串中出现指定字符的次数

#统计字符串中出现指定字符的次数
def getCount(ch,s):
    count=0
    for item in s:
        if ch.upper()==item or ch.lower()==item:
            count=count+1
    return count

if __name__ == '__main__':
    str=input('请输入字符串')
    ch=input('请输入你要查找的字符')
    count=getCount(ch,str)
    print(f'你查找的{ch}字符在{str}字符串中出现的次数为{count}')
1
2
3
4
5
6
7
8
9
10
11
12
13

运行结果：

请输入字符串123sss
请输入你要查找的字符1
你查找的1字符在123sss字符串中出现的次数为1
1
2
3

2.格式化输出商品的名称和单价

def show(lst):
    for item in lst:
        for i in item:
            print(i,end='\t\t')
        print()

lst=[['01','电风扇','美的',500],
     ['02','洗衣机','TCL',1000],
     ['03','空 调','格力',2500]]
print('编号\t\t名称\t\t\t品牌\t\t单价')
show(lst)#调用show方法
print('-------------格式化-----------------')
print('编号\t\t\t名称\t\t\t品牌\t\t单价')
for item in lst:
    item[0]='0000'+item[0]
    item[3]='${:.2f}'.format(item[3])
show(lst)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

运行结果：

编号		名称			品牌		单价
01		电风扇		美的		500		
02		洗衣机		TCL		1000		
03		空 调		格力		2500		
-------------格式化-----------------
编号			名称			品牌		单价
000001		电风扇		美的		$500.00		
000002		洗衣机		TCL		$1000.00		
000003		空 调		格力		$2500.00	
1
2
3
4
5
6
7
8
9

实操案例十

1.mini计算器

def calc(a,b,op):
    if op=='+':
        return add(a,b)
    elif op=='-':
        return sub(a,b)
    elif op=='*':
        return mul(a,b)
    elif op=='/':
        if b==0:
            return '分母不能为0'
        return div(a,b)
def add(a,b):
    return a+b
def sub(a,b):
    return a-b
def mul(a,b):
    return a*b
def div(a,b):
    return a/b
if __name__ == '__main__':
    a=int(input('请输入第一个整数：\n'))
    b=int(input('请输入第二个整数：\n'))
    op=input('请输入运算符：\n')
    print(calc(a,b,op))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

运行结果：

请输入第一个整数：
1
请输入第二个整数：
2
请输入运算符：
*
2
1
2
3
4
5
6
7

2.猜数小游戏

import random
def guessNum(randNum,guess_num):
    if randNum==guess_num:
        return 0
    elif randNum<guess_num:
        return 1
    else:
        return -1
randomNum=random.randint(1,100)
for i in range(10):
    guess_Num=int(input('我心里想了一个1-100的随机数，请您猜一猜：\n'))
    result=guessNum(randomNum,guess_Num)
    if result==0:
        print(f'猜对了这个数是{randomNum}')
        break
    elif result==1:
        print('猜大了')
    else:
        print('猜小了')
else:
    print('真笨，猜了十次都猜不对，加油啊')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

运行结果：

我心里想了一个1-100的随机数，请您猜一猜：
50
猜大了
我心里想了一个1-100的随机数，请您猜一猜：
15
猜小了
我心里想了一个1-100的随机数，请您猜一猜：
25
猜小了
我心里想了一个1-100的随机数，请您猜一猜：
40
猜小了
我心里想了一个1-100的随机数，请您猜一猜：
45
猜大了
我心里想了一个1-100的随机数，请您猜一猜：
42
猜小了
我心里想了一个1-100的随机数，请您猜一猜：
43
猜对了这个数是43
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

实操案例十一

当出异常时捕获异常，会手动抛异常

1.输入成绩

#1.手动报异常
'''
score=int(input('请输入分数'))
if 0<=score<=100:
    print(f'分数为{score}')
else:
    raise Exception('分数不正确')
'''
#2.try...except捕获异常
try:
    score = int(input('请输入分数'))
    if 0 <= score <= 100:
        print(f'分数为{score}')
    else:
        raise Exception('分数不正确')
except Exception as e:
    print(e)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

运行结果：

请输入分数102
分数不正确
1
2

2.判断能否构成三角形

def is_triangle(a,b,c):
    if a<=0 or b<=0 or c<=0:
        raise Exception('三条边的值不能含有负数与0')
    #判断能否构成三角形
    if a+b>c and a+c>b and b+c>a:
        print(f'三角形的边长分别是a={a},b={b},c={c}')
    else:#raise Exception()手动抛异常
        raise Exception(f'a={a},b={b},c={c}不能构成三角形')

if __name__ == '__main__':
    try:
        a = int(input('请输入第一条边长：\n'))
        b = int(input('请输入第二条边长：\n'))
        c = int(input('请输入第三条边长：\n'))
        is_triangle(a, b, c)
    except Exception as e:
        print(e)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

运行结果：

请输入第一条边长：
1
请输入第二条边长：
1
请输入第三条边长：
1
三角形的边长分别是a=1,b=1,c=1
1
2
3
4
5
6
7

实操案例十二

类和对象的知识点，主要是面向对象

1.定义一个圆的类，计算面积和周长

import math
class Circle():
    def __init__(self,r):#初始化函数
        self.r=r
    def getArea(self):#计算圆的面积
        return math.pi*math.pow(self.r,2)
    def getZhouchang(self):#计算圆的周长
        return math.pi*self.r*2
if __name__ == '__main__':
    r=int(input('请输入圆的半径：\n'))
    cir=Circle(r)
    print(f'半径为{r}的圆的面积为{cir.getArea()}')
    print(f'半径为{r}的圆的周长为{cir.getZhouchang()}')
    #可以定义保留多少小数
    print('半径为{}的圆的面积为{:.2f}'.format(r,cir.getArea()))
    print('半径为{}的圆的周长为{:.2f}'.format(r,cir.getZhouchang()))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

运行结果：

请输入圆的半径：
4
半径为4的圆的面积为50.26548245743669
半径为4的圆的周长为25.132741228718345
半径为4的圆的面积为50.27
半径为4的圆的周长为25.13
1
2
3
4
5
6

2.定义学生类录入5个学生信息存储到列表中

#定义学生类录入5个学生信息存储到列表中
class Student():
    def __init__(self,name,age,gender,grade):
        self.name=name
        self.age=age
        self.gender=gender
        self.grade=grade
    def show(self):
        print(self.name,self.age,self.gender,self.grade)


if __name__ == '__main__':
    print('请输入5位学生的信息：（姓名#年龄#性别#成绩）')
    lst=[]
    i=0
    # for j in range(0,5):
    while i!=5:#如果输错，不计算循环次数，自己加着玩的，可以直接用for
        s=input(f'请输入第{i+1}位学生的信息和成绩')
        s_lst=s.split('#')
        if len(s_lst)!=4:
            print('请检查格式')#简易版筛选可能出错的地方
            i=i
            continue
        #创建学生对象
        stu=Student(s_lst[0],int(s_lst[1]),s_lst[2],float(s_lst[3]))
        lst.append(stu)
        i=i+1
for i in lst:
    i.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

运行结果：

请输入5位学生的信息：（姓名#年龄#性别#成绩）
请输入第1位学生的信息和成绩张三#23#男#99
请输入第2位学生的信息和成绩张三#23#男#100
请输入第3位学生的信息和成绩李四#24#男#98
请输入第4位学生的信息和成绩111
请检查格式
请输入第4位学生的信息和成绩王五#25#男#99
请输入第5位学生的信息和成绩花朵#18#女100
请检查格式
请输入第5位学生的信息和成绩花朵#18#女#100
张三 23 男 99.0
张三 23 男 100.0
李四 24 男 98.0
王五 25 男 99.0
花朵 18 女 100.0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

实操案例十三

python中关于多态的问题

1.编写程序实现弹奏乐器。不同乐器发出不同声音。

class Instrument():
    def make_sound(self):
        pass

class ErHu(Instrument):
    def make_sound(self):
        print('二胡在演奏')

class Piano(Instrument):
    def make_sound(self):
        print('钢琴在演奏')

class Violin(Instrument):
    def make_sound(self):
        print('小提琴在演奏')
#演奏的函数
def play(instrument):
    instrument.make_sound()

class Bird():
    def make_sound(self):
        print('小鸟在唱歌')
        
if __name__ == '__main__':
    play(ErHu())
    play(Piano())
    play(Violin())
    play(Bird())
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

运行结果：

二胡在演奏
钢琴在演奏
小提琴在演奏
小鸟在唱歌
1
2
3
4

2.使用面向对象思想，输出出租车和私家车的信息

class Car():
    def __init__(self,type,no):
        self.type=type
        self.no=no
    def start(self):
        pass
    def stop(self):
        pass

class Taxi(Car):
    def __init__(self,type,no,company):
        super().__init__(type,no)#别忘了传参
        self.company=company
    def start(self):
        print('乘客您好！')
        print(f'我是{self.company}出租车公司的，我的车牌是:{self.no}，请问您要去哪里？')
    def stop(self):
        print('目的地到了，请您付款下车，欢迎下次乘坐')


class FamilyCar(Car):
    def __init__(self,type,no,name):
        super().__init__(type,no)
        self.name=name
    def start(self):
        print(f'我是{self.name},我的汽车我做主')
    def stop(self):
        print('目的地到了,我们去玩吧！')
#main
if __name__ == '__main__':
    taxi=Taxi('上海大众','京AXXXX','长城')
    taxi.start()
    taxi.stop()
    print('-'*30)
    familyCar=FamilyCar('五菱宏光','京AYYYY','武大郎')
    familyCar.start()
    familyCar.stop()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

运行结果：

乘客您好！
我是长城出租车公司的，我的车牌是:京AXXXX，请问您要去哪里？
目的地到了，请您付款下车，欢迎下次乘坐
------------------------------
我是武大郎,我的汽车我做主
目的地到了,我们去玩吧！
1
2
3
4
5
6

实操案例十四

模块

1.模拟高铁售票系统

import prettytable as pt

#显示坐席
def show_ticket(row_num):
    tb=pt.PrettyTable()#创建对象
    #表头
    tb.field_names=['行号','座位1','座位2','座位3','座位4','座位5']
    for i in range(row_num):
        lst=[f'第{i+1}行','有票','有票','有票','有票','有票']
        tb.add_row(lst)
    print(tb)

#订票
def order_ticket(row_num,row,colum):
    tb=pt.PrettyTable()
    tb.field_names=['行号','座位1','座位2','座位3','座位4','座位5']
    for i in range(row_num):
        if int(row)==i+1:
            lst=[f'第{i+1}行','有票','有票','有票','有票','有票']
            lst[int(colum)]='已售'
            tb.add_row(lst)
        else:
            lst = [f'第{i + 1}行', '有票', '有票', '有票', '有票', '有票']
            tb.add_row(lst)
    print(tb)

if __name__ == '__main__':
    row_num=13
    show_ticket(row_num)
    choose_num=input('请输入选择的座位，如13,5表示13排5号座位')
    try:
        row,column=choose_num.split(',')
    except:
        print('输入格式有误，如13排5号座位，应该输入13,5')
    order_ticket(row_num,row,column)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

运行结果：

+--------+-------+-------+-------+-------+-------+
|  行号  | 座位1 | 座位2 | 座位3 | 座位4 | 座位5 |
+--------+-------+-------+-------+-------+-------+
| 第1行  |  有票 |  有票 |  有票 |  有票 |  有票 |
| 第2行  |  有票 |  有票 |  有票 |  有票 |  有票 |
| 第3行  |  有票 |  有票 |  有票 |  有票 |  有票 |
| 第4行  |  有票 |  有票 |  有票 |  有票 |  有票 |
| 第5行  |  有票 |  有票 |  有票 |  有票 |  有票 |
| 第6行  |  有票 |  有票 |  有票 |  有票 |  有票 |
| 第7行  |  有票 |  有票 |  有票 |  有票 |  有票 |
| 第8行  |  有票 |  有票 |  有票 |  有票 |  有票 |
| 第9行  |  有票 |  有票 |  有票 |  有票 |  有票 |
| 第10行 |  有票 |  有票 |  有票 |  有票 |  有票 |
| 第11行 |  有票 |  有票 |  有票 |  有票 |  有票 |
| 第12行 |  有票 |  有票 |  有票 |  有票 |  有票 |
| 第13行 |  有票 |  有票 |  有票 |  有票 |  有票 |
+--------+-------+-------+-------+-------+-------+
请输入选择的座位，如13,5表示13排5号座位13,5
+--------+-------+-------+-------+-------+-------+
|  行号  | 座位1 | 座位2 | 座位3 | 座位4 | 座位5 |
+--------+-------+-------+-------+-------+-------+
| 第1行  |  有票 |  有票 |  有票 |  有票 |  有票 |
| 第2行  |  有票 |  有票 |  有票 |  有票 |  有票 |
| 第3行  |  有票 |  有票 |  有票 |  有票 |  有票 |
| 第4行  |  有票 |  有票 |  有票 |  有票 |  有票 |
| 第5行  |  有票 |  有票 |  有票 |  有票 |  有票 |
| 第6行  |  有票 |  有票 |  有票 |  有票 |  有票 |
| 第7行  |  有票 |  有票 |  有票 |  有票 |  有票 |
| 第8行  |  有票 |  有票 |  有票 |  有票 |  有票 |
| 第9行  |  有票 |  有票 |  有票 |  有票 |  有票 |
| 第10行 |  有票 |  有票 |  有票 |  有票 |  有票 |
| 第11行 |  有票 |  有票 |  有票 |  有票 |  有票 |
| 第12行 |  有票 |  有票 |  有票 |  有票 |  有票 |
| 第13行 |  有票 |  有票 |  有票 |  有票 |  已售 |
+--------+-------+-------+-------+-------+-------+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

扩展版：

2.推算几天后的日期

import datetime
def inputdate():
    indate=input('请输入开始日期：(20200808)后按回车键')
    indate=indate.strip()#去除空格
    dateStr=indate[0:4]+'-'+indate[4:6]+'-'+indate[6:]
    #datetime.strptime 时间日期格式化
    return datetime.datetime.strptime(dateStr,'%Y-%m-%d')

if __name__ == '__main__':
    print('-----------推算几天后的日期-------------')
    sdate=inputdate()
    in_num=int(input('请输入间隔天数：'))
    #表示两个 date 对象或者 time 对象,或者 datetime 对象之间的时间间隔，精确到微秒。
    fdate=sdate+datetime.timedelta(days=in_num)
    print('您推算的日期是：'+str(fdate).split(' ')[0])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

运行结果：

-----------推算几天后的日期-------------
请输入开始日期：(20200808)后按回车键20201010
请输入间隔天数：-100
您推算的日期是：2020-07-02
1
2
3
4

实操案例十五

文件的读写

1.记录用户登录日志

import time
def show_info():
    print('输入提示数字，执行相应操作：0.退出  1.查看登录日志')

#记录日志
def write_logininfo(username):
    #上下文管理器
    with open('log.txt','a') as file:
        s=f'用户名{username},登录时间:{time.strftime("%Y-%m-%d %H:%M:%S",time.localtime(time.time()))}'
        file.write(s)
        file.write('\n')

#读取日志
def read_logininfo():
    #上下文管理器
    with open('log.txt','r') as file:
        while True:
            line=file.readline()
            if line=='':
                break
            else:
                print(line,end='')
if __name__ == '__main__':
    '''print(time.time())#秒
    print(time.localtime(time.time()))
    print(time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time())))'''
    username=input('请输入用户名：')
    pwd=input('请输入密码：')
    if 'admin'==username and 'admin'==pwd:
        print('登录成功')
        write_logininfo(username)#记录日志
        show_info()#提示用户要执行什么操作
        num=int(input('输入操作数字：'))
        while True:
            if num==0:
                print('退出成功')
                break
            elif num==1:
                print('查看登录日志')
                read_logininfo()#读取日志
                num=int(input('输入操作数字：'))
            else:
                print('你输入的数字有误')
                show_info()
                num=int(input('输入操作数字：'))
    else:
        print('对不起，用户名或密码不正确')

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

运行结果：

请输入用户名：admin
请输入密码：admin
登录成功
输入提示数字，执行相应操作：0.退出  1.查看登录日志
输入操作数字：1
查看登录日志
用户名admin,登录时间:2023-05-26 13:37:28
输入操作数字：1
查看登录日志
用户名admin,登录时间:2023-05-26 13:37:28
输入操作数字：0
退出成功
1
2
3
4
5
6
7
8
9
10
11
12

2.模拟淘宝客服

def find_answer(question):
    with open('reply.txt','r',encoding='utf-8') as file:
       while True:
           line=file.readline()
           if not line:#if line==''到文件末尾退出
               break
            #字符串的分割
           keyword=line.split('|')[0]
           reply=line.split('|')[1]
           if keyword in question:
               return reply
    return False

if __name__ == '__main__':
    question=input('Hi，您好，小秘在此等候您很久了，有什么烦恼和小秘说吧')
    while True:
        if question=='bye':
            break
        reply=find_answer(question)
        if not reply:#如果回复的是False，not False-->True
            question=input('小秘还在努力中，不太理解您的意思，您可以问：订单、物流、账户、支付等问题，退出请输入bye')
        else:
            print(reply)
            question=input('小主，您还有关于订单、物流、账户、支付等问题吗？退出请输入bye')
    print('小主，期待您的下次光临！再见')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

运行结果：

Hi，您好，小秘在此等候您很久了，有什么烦恼和小秘说吧物流
如果您有任何物流问题，可以登录淘宝账号，点击我的订单，查看商品物流

小主，您还有关于订单、物流、账户、支付等问题吗？退出请输入bye支付
如果您有任何支付问题，可以联系支付宝客户，QQ:XXX

小主，您还有关于订单、物流、账户、支付等问题吗？退出请输入bye就是就是
小秘还在努力中，不太理解您的意思，您可以问：订单、物流、账户、支付等问题，退出请输入byebye
小主，期待您的下次光临！再见
1
2
3
4
5
6
7
8
9