fruits=["apple","pear","orange"]
for x in fruits:
print(f"这叫{x}的水果")
print(f"我喜欢{x},它非常好吃")
'''结果如下，且 f必须写，不然结果就为 x：
这叫apple的水果
这叫pear的水果
这叫orange的水果
我喜欢orange,它非常好吃
'''
----------------------
fruits=["apple","pear","orange"]
for y in fruits:
print(f"这叫{y}的水果")
print(f"我喜欢{y},它非常好吃")
'''结果如下：
这叫apple的水果
我喜欢apple,它非常好吃
这叫pear的水果
我喜欢pear,它非常好吃
这叫orange的水果
我喜欢orange,它非常好吃
'''
'''----range 生成数字函数------'''
data=range(10)
print(data) # 结果：range(0, 10)
print(type(data)) # 结果：<class 'range'>
data1=list(data)
print(data1) # 结果 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(type(data1)) # 结果 <class 'list'>
print(data1,type(data1)) # 结果：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] <class 'list'>
'''----------统计数字的函数'''
data=range(100)
print("最小值：",min(data))
print("最大值：",max(data))
print("求和值：",sum(data))
print("长度值：",len(data))
print("平均值：",sum(data)/len(data))
'''-------结果如下：
最小值： 0
最大值： 99
求和值： 4950
长度值： 100
平均值： 49.5
-----'''
'''---------结算1--100数字的平方和'''
data=range(1,101)
sum=0
for i in data:
i=i*i
sum=sum+i
print("1--100的平方和",sum) #结果 1--100的平方和 338350
data1=list(range(1,101))
sum1=0
for i in data1:
sum1=sum1+i*i
print("1--100的平方和是",sum1) # 结果：1--100的平方和是 338350
'''-----------求前3名等'''
score11=[77,88,73,99,82,95,86,93]
score11.sort(reverse=True) # 倒叙排列
print("最高分",max(score11))
print("最低分",min(score11))
print("前3名：")
for w in score11[:3]:
print(w)
print("平均分",sum(score11)/len(score11)) # 平均分 86.625
---------------------------
'''----元组可拆包，不支持单个修改，支持整体修改---------'''
student=(1001,"小张",20,176)
print(student,type(student)) #结果 (1001, '小张', 20, 176) <class 'tuple'>
print("for循环遍历元组：")
for u in student:
print(u)
'''---结果：
for循环遍历元组：
1001
小张
20
176
'''
print("拆包后的多个变量：")
学号,姓名,年龄,身高=student
print("学号",学号)
print("姓名",姓名)
print("年龄",年龄)
print("身高",身高)
'''结果：
拆包后的多个变量：
学号 1001
姓名 小张
年龄 20
身高 176
'''
student[1]="张梅" # 报错：TypeError: 'tuple' object does not support item assignment
#student[1]="张梅" # 报错：TypeError: 'tuple' object does not support item assignment 不允许单个修改
student=(1002,"小丽",20,176)
print("修改后：",student) #结果 ：修改后： (1002, '小丽', 20, 176)
'''---以下是学生的爱好数据，实现代码，输出爱好名字的去重后的列表'''
#字段的value是列表，表达每个人列表类型信息
students={
"xiaozhang":{"足球","篮球"},
"xiaowang":{"篮球","兵乓球"},
"xiaoli":{"篮球","棒球","台球"},
"xiaozhao":{"羽毛球","兵乓球"},
}
likes=set()
for value in students.values():
for like in value:
likes.add(like)
print(likes)
'''结果：{'足球', '篮球'}
{'足球', '篮球', '兵乓球'}
{'棒球', '兵乓球', '足球', '台球', '篮球'}
{'棒球', '兵乓球', '羽毛球', '足球', '台球', '篮球'}'''
print(likes) # 结果 ：{'台球', '羽毛球', '棒球', '足球', '兵乓球', '篮球'}
numbers=range(10)
#1个列表，里面是每个䦹数字的平方
data_list=[x*x for x in numbers if x%2==0]
print("data_list",data_list,type(data_list))
#1个字典，里面的key是偶数数字，value是它的平方，注意字典key是无序的
data_list={x:x*x for x in numbers if x%2==0}
print("data_list",data_list,type(data_list))
#1个集合，每个元素是偶数数字的平方，注意集合是无序的
data_set={x*x for x in numbers if x%2==0}
print("data_set",data_set,type(data_set))
'''结果如下：
data_list [0, 4, 16, 36, 64] <class 'list'>
data_list {0: 0, 2: 4, 4: 16, 6: 36, 8: 64} <class 'dict'>
data_set {0, 64, 4, 36, 16} <class 'set'>
'''
number1=input("请输入数字：")
print("类型:",type(number1),"值：",number1)
number1=int(number1)
print("类型:",type(number1),"值：",number1*number1)
''' 结果如下，注意：input返回的都是str字符串类型，想计算则需要转换：
请输入数字：8
类型: <class 'str'> 值： 8
类型: <class 'int'> 值： 64
'''
number1=input("请输入数字：")
print("类型:",type(number1),"值：",number1)
number1=int(number1)
if number1%2==0:
print(f"你输入的{number1}是偶数")
else:
print(f"你输入的{number1}是奇数")
'''
类型: <class 'str'> 值： 8
你输入的8是偶数
类型: <class 'str'> 值： 7
你输入的7是奇数
'''
'''-----------------'''
while True:
print("#"*20)
info=input("请输入一个你喜欢的颜色，输入quit则是退出：")
if info=="quit":
break
else:
print("很好，你喜欢的颜色是{info")
'''结果如下：
####################
请输入一个你喜欢的颜色，输入quit则是退出：red
很好，你喜欢的颜色是{info
####################
请输入一个你喜欢的颜色，输入quit则是退出：quit
'''
---------------------------函数 如下：------------------------------------
def print_hello(name):
print(f"大家好，我叫{name}") # f 必须有，不然结果为大家好，我叫{name}
print_hello("小王") # 结果 大家好，我叫小王
print_hello("小李") # 结果 大家好，我叫小李
------------------------------------------------------
def sum_numbers(number):
sum_values=0
for i in range(1,number+1):
sum_values+=i
print(f"{number}的和:",sum_values)
print(number,sum_values)
print(f"{number}的和:",f"{sum_values}")
print(f"{number}的和:,{sum_values}")
sum_numbers(100)
sum_numbers(1000)
'''结果如下：
100的和: 5050
100 5050
100的和: 5050
1000的和: 500500
1000 500500
1000的和: 500500
'''
'''-----位置实参需要按顺序、关键字参数用key-value可以换顺序、默认值参数可以不填-------'''
def introduce(name,age=6):
print(f"大家好，我的名字是：{name},我今年{age}岁了")
#如下的调用方式都可以
introduce("小明")
introduce(name="小张")
introduce("小白",5)
introduce(name="小丽",age=5)
introduce(age=5,name="小王")
'''----结果如下：---
大家好，我的名字是：小明,我今年6岁了
大家好，我的名字是：小张,我今年6岁了
大家好，我的名字是：小白,我今年5岁了
大家好，我的名字是：小丽,我今年5岁了
大家好，我的名字是：小王,我今年5岁了
'''
'''-----------------'''
def compute(x,y,method="add"):
if method=="add":
print(f"{x}+{y}=",x+y)
elif method=="sub":
print(f"{x}-{y}=", x - y)
elif method=="mul":
print(f"{x}*{y}=", x * y)
elif method=="div":
print(f"{x}/{y}=", x / y)
compute(3,4,"add") # 结果 3+4= 7
compute(3,4,"sub") # 结果 3-4= -1
compute(x=3,y=4,method="sub") # 结果 3-4= -1
compute(3,y=4,method="sub") # 结果 3-4= -1
compute(3,4,method="sub") # 结果 3-4= -1
compute(3,4) # 结果 3+4= 7
compute(3,y=4) # 结果 3+4= 7
compute(x=3,y=4) # 结果 3+4= 7
'''----------函数可以放开变量接收 、可以单个变量接收，这时候返回的是一个元组------------'''
student1={
"小明": {"id": 101, "age": 18,"gender":"boy"},
"小张": {"id": 102, "age": 19, "gender": "girl"},
"小明": {"id": 103, "age": 17, "gender": "boy"}
}
def get_student(name):
if name in student1:
return student1[name]["age"],student1[name]["gender"]
else:
return None,None
age,gender=get_student("小明")
print(age,gender,type(age),type(gender)) # 结果 17 boy <class 'int'> <class 'str'>
info=get_student("小明")
print(info,type(info)) # 结果 (17, 'boy') <class 'tuple'>
'''------------第2个函数add(x,y)调用第1个函数compute(x,y,method=add)得到结果返回----------------------'''
def compute(x,y,method1):
if method1=='add':
return x+y
elif method1=='sub':
return x-y
elif method1=='mul':
return x*y
elif method1 == 'div':
return x / y
def add(x,y):
return compute(x,y,"add")
def sub(x,y):
return compute(x,y,"sub")
print("相加的和为",add(3,4)) # 结果 相加的和为 7
print("相减的差为",sub(8,3)) # 结果 相减的差为 5
该57节了
compute.py模块如下：
def add(x,y):
return x+y
def sub(x,y):
return x-y
def mul(x,y):
return x*y
def div(x,y):
return x/y
另一个模块调用 compute.py此模块的函数人 add sub等：
：
''---引用模块的函数'''
import compute
print(compute.add(3,5))
print(compute.sub(3,5))
import compute as cp
print(cp.add(3,5))
print(cp.sub(3,5))
from compute import add,sub
print(add(3,5))
print(sub(3,5))
from compute import * # 尽量不用*的
print(add(3,5))
print(sub(3,5))
'''-----------lambda函数和列表的排序----------'''
'''------对学生数据按成绩排序-------'''
sqrades=[("xiaoming",89),("xiaozhao",77),("xiaoxiaozhang",99)]
print(sqrades.sort()) #结果为 None 不能这样用print，
print(sqrades) #结果 [('xiaoming', 89), ('xiaoxiaozhang', 99), ('xiaozhao', 77)]
#此种方法结果不错，它只会按照第一项排序 不可行的方法
sqrades.sort(key=lambda x:x[1])
print(sqrades) # 结果为 [('xiaozhao', 77), ('xiaoming', 89), ('xiaoxiaozhang', 99)]
new_list=sorted(sqrades,key=lambda x:x[1],reverse=True)
print(new_list) # 结果为 [('xiaoxiaozhang', 99), ('xiaoming', 89), ('xiaozhao', 77)]
print(sorted(sqrades,key=lambda x:x[1],reverse=True)) # 结果为[('xiaoxiaozhang', 99), ('xiaoming', 89), ('xiaozhao', 77)]
def mfunc(x):
return x[1]
mfunc(sqrades) # 结果 [('xiaoxiaozhang', 99), ('xiaoming', 89), ('xiaozhao', 77)]
-----------------------9、面向对象编程--------------------
对象这个函数叫方法，如果一个函数属于某个对象，则叫方法， 如果不属于对象，则叫函数
'''对象这个函数叫方法，如果一个函数属于某个对象，则叫方法， 如果不属于对象，则叫函数'''
class Student:
def __init__(self, name, age):
# 初始化方法 构造函数
# 普通实例变量，每个实例独有'''
self.name = name
self.age = age
def introduce(self):
#普通方法
return f"大家伙，我叫{self.name},我{self.age}岁了" #此处需是return 不然返回none
xiaoming=Student("小明",18)
xiaozhang=Student("小张",17)
xiaozhao=Student("小赵",19)
#使用对象.属性来访问属性：使用对象.方法来调用方法
print(xiaoming.name,xiaoming.age,xiaoming.introduce()) # 小明 18 大家伙，我叫小明,我18岁了
print(xiaozhang.name,xiaozhang.age,xiaozhang.introduce()) # 小张 17 大家伙，我叫小张,我17岁了
'''------------类与对象练习题'-----------'''
class Phone:
def __init__(self,model,price):
self.model=model
self.price=price
def describe(self):
return f"这是{self.model}手机，价格是{self.price}"
# print(f"这是{self.model}手机，价格是{self.price}") # print(f"这是{self.model}手机，价格是{self.price}")时，则返回None 不能用
def call_friend(self,friend_name):
print(f"我在用手机{self.model}打电话给{friend_name}")
iphone13=Phone("iphone",6000)
huawei=Phone("huawe",3000)
print(iphone13.describe())
iphone13.call_friend("小明")
# iphone13.describe() # 如果 函数中 print(f"这是{self.model}手机，价格是{self.price}") 则用此结果正确这是iphone手机，价格是6000
'''运行结果如下：
这是iphone手机，价格是6000
我在用手机iphone打电话给小明
'''
'''**************修改对象的属性值***********'''
class StundentGrade:
"学生成绩"
def __init__(self,name,yuwen,shuxue):
self.name=name
self.yuwen=yuwen
self.shuxue=shuxue
def update(self,course,grade):
if course=="语文":
self.yuwen=grade
if course=="数学":
self.shuxue=grade
xiaoming=StundentGrade("小明",88,99)
xiaoming.yuwen=10
xiaoming.shuxue=60
print("小明",xiaoming.yuwen,xiaoming.shuxue) # 小明 10 60
xiaoming.update("语文",66)
xiaoming.update("数学",56)
print("小明",xiaoming.yuwen,xiaoming.shuxue) # 结果：小明 66 56
'''---------------对象存到列表或字典中--------------'''
class StundentGrade1:
"学生成绩"
def __init__(self,name,yuwen,shuxue):
self.name=name
self.yuwen=yuwen
self.shuxue=shuxue
def update(self,course,grade):
if course=="语文":
self.yuwen=grade
if course=="数学":
self.shuxue=grade
xiaoming=StundentGrade1("小明",88,99)
xiaozhang=StundentGrade1("小张",100,100)
xiaozhao=StundentGrade1("小赵",60,70)
#把对象放列表里
student_list=[xiaoming,xiaozhang,xiaozhao]
print("--------#把对象放列表里----------------------------")
for student in student_list:
print(student.name,student.yuwen,student.shuxue)
'''结果如下：------------------------------------
--------#把对象放列表里----------------------------
小明 88 99
小张 100 100
小赵 60 70
'''
#--------把对象放到字典中----------
student_dict={
"小明":xiaoming,
"小张": xiaozhang,
"小赵": xiaozhao
}
print("*****把类的对象放到字典中*********")
for name,student in student_dict.items():
print(f"学生{name}的成绩是语文{student.yuwen},数学是{student.shuxue}")
'''
*****把类的对象放到字典中*********
学生小明的成绩是语文88,数学是99
学生小张的成绩是语文100,数学是100
学生小赵的成绩是语文60,数学是70
Process finished with exit code 0
'''
'''''''''-----------面向对象编程类的练习题 课时64 礼金-----------'''
class Customer:
def __init__(self,name,money):
self.name=name
self.money=money
customers=[]
while True:
print("*"*20)
info=input("请输入来人姓名和金额：")
if info=="quit" :
break
name,money=info.split()
money=int(money)
customer=Customer(name,money)
customers.append(customer)
print("请客总人数:",len(customers))
moneys=[c.money for c in customers]
print("总金额：",sum(moneys))
print("最大金额：", max(moneys))
print("最小金额：", min(moneys))
print("平均金额：", sum(moneys)/len(moneys))
'''结果如下 1000 2000 3000：
请客总人数: 3
总金额： 6000
最大金额： 3000
最小金额： 1000
平均金额： 2000.0
'''
![]()
'''------------面向类的继承--------------'''
class Car: #父类
def __init__(self,model,price):
self.model=model
self.price=price
def info(self):
print(f"车型是{self.model},价格是{self.price}万元")
class OilCar(Car):
def __init__(self,model,price,box_size):
super().__init__(model,price) #子类继承父类
self.box_size=box_size
def add_oil(self,money):
print(f"老板，加{money}元的汽油")
def info(self):
super().info()
print("我的油车，跑起来比电脑车动力更足")
class ElectricCar(Car):
def __init__(self,model,price,battery_size):
super().__init__(model,price)
self.battery_size=battery_size
def add_electric(self,money):
print(f"车是{self.price}元，充电花了{money}元")
print("------面向类的继承------")
ocar01=OilCar("路虎",60,80)
print(ocar01.model,ocar01.price,ocar01.box_size)
ocar01.info()
ocar01.add_oil(200)
ecar01=OilCar("特斯拉",100,200)
print(ecar01.model,ecar01.price,ecar01.box_size)
ecar01.info()
ecar01.add_oil(300)
'''结果如下：
------面向类的继承------
路虎 60 80
车型是路虎,价格是60万元
我的油车，跑起来比电脑车动力更足
老板，加200元的汽油
特斯拉 100 200
车型是特斯拉,价格是100万元
我的油车，跑起来比电脑车动力更足
老板，加300元的汽油
'''
![]()
66课时：
'''---------66节 继承练习题------'''
print("--------------66节 继承练习题-------------")
class User: #父类
def __init__(self,name,password):
self.name=name
self.password=password
def welcome(self):
print(f"你好{self.name},欢迎到来")
class Admin(User): #子类
def __init__(self,name,password):
super().__init__(name,password)
def manager(self):
print("我在管理系统")
class VipUser(User):
def __init__(self,name,password,money):
super().__init__(name,password)
self.money=money
def welcome(self):
print(f"你好，尊贵的Vip用户{self.name},欢迎归来")
def vip_service(self):
print("您好，尊贵的贵宾服务")
admin01=Admin("Admin01",1234)
admin02=Admin("Admin02",1234)
Vip01=VipUser("Vip01",1234,1000)
Vip02=VipUser("Vip02",1234,2000)
user01=User("user01",1234)
user02=User("user02",1234)
admin01.welcome()
admin01.manager()
admin02.welcome()
admin02.manager()
Vip01.welcome()
Vip01.vip_service()
Vip02.welcome()
Vip02.vip_service()
user01.welcome()
user02.welcome()
'''
你好Admin01,欢迎到来
我在管理系统
你好Admin02,欢迎到来
我在管理系统
你好，尊贵的Vip用户Vip01,欢迎归来
您好，尊贵的贵宾服务
你好，尊贵的Vip用户Vip02,欢迎归来
您好，尊贵的贵宾服务
你好user01,欢迎到来
你好user02,欢迎到来
'''
car.py # 把类写到不同文件（模块）中
class Car:
def __init__(self,model,price):
self.model=model
self.price=price
def info(self):
print(f"车型是{self.model},价格是{self.price}万元")
#以下为 引用文件/模块的类:
import car
my_car=car.Car("路虎",60)
my_car.info() # 结果 车型是路虎,价格是60万元
import car as c
my_car=c.Car("红旗",70)
my_car.info() # 结果 车型是红旗,价格是70万元
from car import Car
my_car=Car("宝马",100)
my_car.info() # 结果 车型是宝马,价格是100万元
from car import *
my_car=Car("五菱",10)
my_car.info() # 结果 车型是五菱,价格是10万元
![]()
# -------------以下为68节 将类写到不同模块中-------------------------
animal.py:
class Animal:
def __init__(self,name):
self.name=name
def run(self):
print(f"我是动物，爱奔跑")
sheep.py:
import animal
class Sheep(animal.Animal):
def __init__(self,name):
super().__init__(name)
def eat_grass(self):
print(f"我是羊,在吃草")
tiger.py:
from animal import Animal
class Tiger(Animal):
def __init__(self,name):
self.name=name
def eat_meat(self,param_animals):
print(f"我是老虎,在吃{param_animals.name}") #?????
main.py:
from sheep import Sheep
from tiger import Tiger
one_sheep=Sheep("小羊")
one_sheep.eat_grass()
one_tiger=Tiger("大老虎") # 结果：我是羊,在吃草
one_tiger.eat_meat(one_sheep) # 结果：我是老虎,在吃小羊
该文件处理操作：
![]()
读取文件方法如下：
'''-----读取方法一：-----------'''
f=open("input.txt",encoding='utf8')
content=f.read()
print(content)
f.close()
'''-----读取方法二：用with 此方法不用f.close()-----------'''
print("------读取方法二：用with 此方法不用f.close()-----------")
with open("input.txt",encoding='utf8') as f:
content=f.read()
print(content)
'''-----读取方法三：按行读取-----------'''
print("-------读取方法三：按行读取-----------")
with open("input.txt",encoding='utf8') as f:
for line in f:
# line=line[:-1] #去掉行尾空格方法1
line=line.rstrip() #去掉行尾空格方法1
print(line)
'''-----读取方法四：按行读取并把各行整合为1行显示----------'''
print("-------读取方法四：按行读取并把各行整合为1行显示-----------")
with open("input.txt",encoding='utf8') as f:
lines=f.readlines()
print(lines) # 结果 ['小王\n', '小张\n', '小赵\n', '小李\n']
'''-----读取方法五：按行读取并把各行整合为1行显示，且去掉了换行符-------'''
print("-------读取方法五：按行读取并把各行整合为1行显示-----------")
with open("input.txt",encoding='utf8') as f:
lines=f.readlines()
lines=[x[:-1] for x in lines]
print(lines) # 结果 ['小王', '小张', '小赵', '小李']
'''----结合文件实现英汉互译------'''
eng_dict={}
with open("英汉字典.txt",encoding='utf8') as f:
for line in f:
line=line.rstrip()
fields=line.split(",") # 重点，拆分到各字段
if len(fields)!=2: #？？？？
continue
print(f"fields的值是{fields}")
english,chinese=fields
eng_dict[english]=chinese
while True:
print("***结合文件实现英汉互译***")
info=input("请输入英文词语：")
if info=="quit":
break
if info in eng_dict:
print("查询结果，汉语是：",eng_dict[info])
else:
print("没有这个词语",info)
'''结果如下：
***结合文件实现英汉互译***
fields的值是['sheep', '羊']
fields的值是['tiger', '老虎']
fields的值是['duck', '鸭子']
fields的值是['fish', '鱼']
请输入英文词语：fish
查询结果，汉语是： 鱼
请输入英文词语：
'''
'''----写数据到文件----'''
print("******写数据到文件******")
with open("写到数字列表.txt","w",encoding="utf8") as f:
for number in range(10):
# f.write(str(number)) # 结果 0123456789
f.write(str(number)+"\n")
'''
# 结果
01
2
3
4
5
6
7
8
9
'''
![]()
fname="婚礼礼金.txt"
print("--------婚礼礼金-------")
with open(fname,"w",encoding="utf8") as f:
while True:
info=input("请输入来人和金额：")
if info=='quit':
break
fields=info.split()
if len(fields)==2:
name,money=fields
else:
continue
money=int(money)
f.write(f"{name},{money}\n")
'''----------以上为把姓名和礼金写到txt文档中--------'''
with open(fname,encoding="utf8") as f:
moneys=[] #列表
for line in f:
line=line[:-1]
fields=line.split(",")
if len(fields)==2:
name,money=fields
else:
continue
moneys.append(int(money))
print("加和：",sum(moneys))
print("最高：",max(moneys))
print("最低：",min(moneys))
print("平均值：",sum(moneys)/len(moneys))
'''结果如下：
-------婚礼礼金-------
请输入来人和金额：小张 1000
请输入来人和金额：小李 2000
请输入来人和金额：小王 3000
请输入来人和金额：小赵 4000
请输入来人和金额：quit
加和： 10000
最高： 4000
最低： 1000
平均值： 2500.0
Process finished with exit code 0
'''
'''---------判断礼金是否存在---------'''
file='婚礼礼金.txt'
import os
print(f"{file}",os.path.exists(file)) # 结果 婚礼礼金.txt True
print(f"xx.txt",os.path.exists("xx.txt")) # 结果 xx.txt False
file=r"C:\Users\Administrator\PycharmProjects\视频2023.04\一、入门基础\compute.py"
print(f"{file}",os.path.exists(file)) # 结果 C:\Users\Administrator\PycharmProjects\视频2023.04\一、入门基础\compute.py True
![]()
![]()
![]()
![]()
'''------json格式与文件，json.dumps()用来将对象转换为大字符串----'''
import json
data=list(range(5))
print(json.dumps(data),type(json.dumps(data))) # [0, 1, 2, 3, 4] <class 'str'>
# 使用dumps函数将Python数据结构转换成字符串
# 如要处理的是文件而不是字符串，你可以使用 json.dump() 和 json.load() 来编码和解码JSON数据
data_dict={
number:number*number
for number in data
if number%2==0
}
print(json.dumps(data_dict),type(json.dumps(data_dict))) # 结果 {"0": 0, "2": 4, "4": 16} <class 'str'>
![]()
#---------------------
print("-------json格式与文件，json.loads()用来将字符串加载成对象，直接变成Python对象，如字典--------")
info1="""
{"0":0,"2":4,"4":16}
"""
print(type(info1)) #结果 ：<class 'str'>
import json
data=json.loads(info1)
print(data,type(data)) # 结果：{'0': 0, '2': 4, '4': 16} <class 'dict'>
print(f"值为：{data},类型为：{type(data)}") # 结果：值为：{'0': 0, '2': 4, '4': 16},类型为：<class 'dict'>
print(type(data)) # 结果 <class 'dict'>
try:
a=5
b=1
print(a/b)
except ZeroDivisionError as e:
print("出现问题了：",e)
print("异常处理的方法一")
try:
with open("xxxx.txt") as f:
print(f.read())
except Exception as e:
print("读取文件错误",e)
print("异常处理方法二")
'''结果如下：
5.0
异常处理的方法一
读取文件错误 [Errno 2] No such file or directory: 'xxxx.txt'
异常处理方法二
'''
78节 异常处理练习题 print("---练习学生成绩带异常处理---")
file_name="学生成绩带异常处理.txt"
with open(file_name,"w",encoding="utf8") as f:
while True:
info=input("请输入姓名和成绩：")
try:
if info=="quit":
break
name,grade=info.split()
grade=int(grade)
print(f"姓名：{name},成绩：{grade}")
except Exception as e:
print("出现问题了：",e,"你输入的是：",info)
continue
f.write(f"姓名是：{name},成绩为：{grade}\n")
print("success")
'''结果如下：
---练习学生成绩带异常处理---
请输入姓名和成绩：小张 100
姓名：小张,成绩：100
请输入姓名和成绩：小李 90
姓名：小李,成绩：90
请输入姓名和成绩：小王 80
姓名：小王,成绩：80
请输入姓名和成绩：孙老师
出现问题了： not enough values to unpack (expected 2, got 1) 你输入的是： 孙老师
请输入姓名和成绩：quit
success
'''
import requests
r=requests.get("https://www.baidu.com/") # 发送get请求获取url返回结果
print(r.status_code) # 结果 200 查看返回状态码，如果==200代表返回成功
print(r.text) #获取返回王爷的内容
"""
有个网站地址是：http://antpython.net/
用requests.get请求这个网页，查看状态码和结果文件
讲文本存储到一个本地的电脑文件antpyton.html文件中
打开自己的电脑文件夹，双击该文件，查看效果
"""
'''----------用requests来抓取网站的内容，存到电脑，并可查看效果---'''
print("----用requests来抓取网站的内容，存到电脑，并可查看效果-----")
import requests
url="http://antpython.net"
r1=requests.get(url)
print(r1.status_code)
with open("antpyton.html","w",encoding="utf8") as f:
f.write(r1.text)
'''''-----------------------'''
print("---Python数据分析库 pandas 用于数据运算，如整理、清洗、归并等---")
print("---讲数据生成一个Excel文件---")
data1=[
["s001", "小明",89],
["s002", "小张", 90],
["s003", "小赵", 66],
]
import pandas as pd
df=pd.DataFrame(data1,columns=["学号","姓名","成绩"])
df.to_excel("学生成绩Excel文件.xlsx")
文件打开如图：
#------pandas练习题：结婚礼金录入后存到Excele文件------
# 编写结婚礼金录入程序，存到Excele文件
# 建立datas一个列表，将来要存储成["小明:"1000],["小张:"2000]的形式
# while True循环
# 输入quit退出循环
# 输入小明 1000，分割姓名，金额字段，存入列表
# 退出循环
# 创建pd.DataFrame
# 存入Excel文件
import pandas as pd
datas=[]
while True:
info = input("请输入随礼人员姓名，金额：")
if info=="quit":
break
fields=info.split()
print(fields)
if len(fields)!=2:
print("输入有问题，请再次输入")
continue
name,money=fields
datas.append([name,money])
df=pd.DataFrame(datas, columns=["姓名", "金额"])
df.to_excel("结婚礼金汇总表.xlsx")
df.to_excel("结婚礼金汇总表.xlsx",index=False)
浙公网安备 33010602011771号