从零到一学习python（基础篇）

python:从零到一 作者：羡鱼肘子

可运行代码和详细教程见：PythonFromZeroToOne/python从零到一(基础篇） at main · lnbhy/PythonFromZeroToOne · GitHub
CodeMarkdown
一个简单的开始，变量和简单的数据类型
print('hello_world')
hello_world
1.varible
message='hello_world'#varible=value
print(message)
#变量是可以被赋值的标签
hello_world
2.string
str1='this is a string'
str2="this is also a string"
print(str1.title())
print(str1.upper())
print(str1.lower())
This Is A String
THIS IS A STRING
this is a string
2.1 f string
name='Li Hua'
print(name)
first_name='Hua'
last_name='Li'
full_name=f'{last_name} {first_name}'
print(full_name)
Li Hua
Li Hua
3.number
3.1 int
# + - * / ** //
a=2
b=9
print(a+b)
print(a-b)
print(a*b)
print(a/b)
print(a//b)
print(b**a)
11
-7
18
0.2222222222222222
0
81
3.2 float
a=0.1
b=0.2
print(a+b)
print(a-b)
print(a*b)
print(a/b)
print(a//b)
print(b**a)
0.30000000000000004
-0.1
0.020000000000000004
0.5
0.0
0.8513399225207846
#任意两个数相除，结果总是浮点数
print(4/2)
2.0
#大数可以有下划线,便于阅读
num=140_000_000_000
print(num)
140000000000
#多变量赋值,按序赋值
x,y,z=1,2,3
print(x)
print(y)
print(z)
1
2
3
constant
#在程序的生命周期内保持不变的量（一般大写）
MAX_CONSTANT=5000_000_000
print(MAX_CONSTANT)
5000000000
#interesting
import this
The Zen of Python, by Tim Peters
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!
开始探索之旅
1.列表
#一系列按特定顺序排列的元素
list=[1,'a',"this is a string"]
print(list)
#访问列表元素(正向索引从0,1,2...，负向索引从-1，-2，-3...)
print(list[0])
print(list[-1])
1
this is a string
#增，删，改
list=[1,'a',"this is a string"]
list_modify=[1,'a',"this is a string"]
list_modify[0]='LiLi'
print(list)
print(list_modify)
print()
list_add=[1,'a',"this is a string"]
list_add.append(2)
list_add.insert(0,'hellow')
#列表管理
#sort() vs sorted()
#sort()是原地排序不保留原来的顺序，sorted()返回新列表，保留原来的顺序
print("----sort()----")
list1 = [3, 1, 2]
list1.sort()#原地排序，不返回新列表，递增排序
print(list1)
list1.sort(reverse=True)#递减排序
print(list1)
print("----sorted()----")
----sort()----
----sorted()----
----反向打印列表----
----确定列表长度----
the length of list5 is 3
#列表操作
#遍历
print("遍历列表")
nums=[1,2,3,4,5]
for num in nums:
    print(num)
遍历列表
1
2
3
4
5
#创建数值列表
#range(start,stop,step)
print("创建数值列表")
nums=list(range(1,10,2))#创建1到9的奇数列表
print(nums)
squares=[]
for num in range(1,10,2):
    num_square=num**2
    squares.append(num_square)#创建平方数列表
print(squares)
创建数值列表
#数值列统计计算
nums=list(range(1,10,2))
print(nums)
print(max(nums))
print(min(nums))
print(sum(nums))
9
1
25
#列表推导式
nums=[value**2 for value in range(1,10,2)]
print(nums)
#列表切片
list1=list(range(10))
print(list1)
print(list1[2:5])
print(list1[2:]) 
print(list1[:5])
print(list1[-3:])
#遍历切片
nums=list(range(10))
print(nums[2:5])
for num in nums[2:5]:
    print(num)
2
3
4
#复制列表
listx=list(range(10))
#对比list1和list2
list1=listx#将list1关联到listx关联的列表，指向同一对象。
list2=listx[:]#将listx的副本赋给list2。
print(list1)
print(list2)
#修改listx,观察到list1和list2的输出结果是不一样的。
print('修改listx后,list1和list2的结果：')
listx.append(10)
修改list后的结果：
2.元组
#定义元组,
point=(1,2)
print(point[0])
print(point[1])
print(point)
#严格来说元组是由逗号来定义的不是括号
point1=1,2
print(point1)
1
2
(1, 2)
(1, 2)
#元组元素不可修改(TypeError: 'tuple' object does not support item assignment)
point=(1,2)
point[0]=2
print(point)
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[5], line 3
      1 #元组元素不可修改
      2 point=(1,2)
----> 3 point[0]=2
      4 print(point)
TypeError: 'tuple' object does not support item assignment
 #遍历元组
points=((1,2),(3,4),(5,6))
for point in points:
    print(point)
#修改元组变量
print("修改元组变量结果：")
points=((1,2),(3,4))
for point in points:
    print(point)
(1, 2)
(3, 4)
(5, 6)
修改元组变量结果：
(1, 2)
(3, 4)
if 语句
#本质条件测试，为true执行语句，为false不执行语句 ==  != < > <= >=
num=10
print(num==10)
print(num!=10)
print(num<10)
print(num>10)
print(num<=10)
print(num>=10)
True
False
False
False
True
True
 #and与 or或 not非 逻辑运算符
num1=10
num2=20
num=int(input("请输入一个数字："))
if(num>num1 and num     print("num介于10和20之间")
if(numnum2):
    print("num不介于10和20之间")
if(not num>num1):
    print("num不大于10")
num不介于10和20之间
#检查值是否在列表中 in not in 
nums=list(range(10))
print(nums)
if 9 in nums:
    print("9在nums列表中")
if 12 not in nums:
    print("12不在nums列表中")
9在nums列表中
#布尔表达式
ACTION=True
END=False
if(ACTION):
    print("游戏开始")
if (not END):
    print("游戏结束")
游戏开始
游戏结束
#if 语句类型
num=10
if(num>5):
    print("num>5")
#一下两种适合于只有一种情况合适的场景
if(num>5):
    print("num>5")
else:
    print("num<=5")
num>5
num>5
num>5
#if语句+列表
#输出1-10
nums=list(range(0,15))
for num in nums:
    if num<=10 and num>0:
        print(num)
    else:
        print("超出范围")
#确定列表是否为空
nums=[]
超出范围
1
2
3
4
5
6
7
8
9
10
超出范围
超出范围
超出范围
超出范围
列表为空
3.字典
#简单的字典示例
student={'name':"羡鱼肘子",'age':18,'sex':'男','score':98.5}
print(student['name'])
print(student['score'])
羡鱼肘子
98.5
#如何使用字典？字典本质：键值对集合,注意3.7后是有序的。
#访问字典值 通过[键]来访问与之关联的字典值。
student={'name':"羡鱼肘子",'age':18,'sex':'男','score':98.5}
print(student['name'])
#问题：如果访问不存在的键，则会报错 ,可以使用get方法来避免报错
# print(student['height'])  #报错KeyError: 'height'
height=student.get('height','无此项数据')
print(height)
#添加字典值 直接通过键来添加新的变量
羡鱼肘子
无此项数据
{'name': '羡鱼肘子', 'age': 18, 'sex': '男', 'score': 98.5, 'height': 180}
{'name': '羡鱼肘子', 'age': 18, 'sex': '男', 'score': 99.5, 'height': 180}
{'name': '羡鱼肘子', 'score': 99.5, 'height': 180}
#遍历字典 键和值
student={'name':"羡鱼肘子",'age':18,'sex':'男','score':98.5}
for key,value in student.items():
    print(key,value)
#解释：items()方法返回一个字典的视图对象，该对象包含字典中的键值对。
m_items=student.items()
print(m_items)
#键
print("键：")
for key in student.keys():
name 羡鱼肘子
age 18
sex 男
score 98.5
dict_items([('name', '羡鱼肘子'), ('age', 18), ('sex', '男'), ('score', 98.5)])
键：
name
age
sex
score
值：
羡鱼肘子
18
男
98.5
#问题：如果字典的遍历值的话有重复的，那么如何处理？--集合 set()
courses={
    "羡鱼肘子":'计算机科学',
    "鱼鱼":'通信工程',
    '肘肘':'计算机科学'
    }
#想知道有哪几门学科
for course in set(courses.values()):
    print(course)
通信工程
计算机科学
#按某种顺序读取字典值 sorted()
student={'name':"羡鱼肘子",'age':18,'sex':'男','score':98.5}#按key中字母顺序排序
for key in sorted(student):
    print(key,student[key])
age 18
name 羡鱼肘子
score 98.5
sex 男
4.嵌套
#字典列表
#问题：如何存储一个足球队的球员信息，其中包括姓名、年龄和位置？
player1 = {'name': 'John', 'age': 25, 'position': 'Goalkeeper'}
player2 = {'name': 'Mike', 'age': 28, 'position': 'Defender'}
player3 = {'name': 'Tom', 'age': 22, 'position': 'Midfielder'}
team = [player1, player2, player3]
for player in team:
    print(player)
{'name': 'John', 'age': 25, 'position': 'Goalkeeper'}
{'name': 'Mike', 'age': 28, 'position': 'Defender'}
{'name': 'Tom', 'age': 22, 'position': 'Midfielder'}
#在字典中存储列表
#问题：如何描述一个外卖订单
order = {
    "phone_number": "1234567890",
    'name': '羡鱼肘子',
    'items': ['肘子', '鱼香肉丝'],
    "price": 120.5,
    }
#问题：如何输出菜品
for item in order['items']:
肘子
鱼香肉丝
#在字典中存储字典
#问题：qq是如何描述用户的呢？
qq_users={
    '羡鱼肘子':{'qq_number':3063320431,'qq_name':'羡鱼肘子','qq_age':18,'qq_sex':'男'},
    '鱼鱼':{'qq_number':3063320431,'qq_name':'鱼鱼','qq_age':18,'qq_sex':'女'},
    '仔仔':{'qq_number':3063320431,'qq_name':'鱼仔','qq_age':18,'qq_sex':'男'},
}
for qq_user in qq_users:
    print(qq_users[qq_user])
    for key in qq_users[qq_user]:
{'qq_number': 3063320431, 'qq_name': '羡鱼肘子', 'qq_age': 18, 'qq_sex': '男'}
qq_number
qq_name
qq_age
qq_sex
{'qq_number': 3063320431, 'qq_name': '鱼鱼', 'qq_age': 18, 'qq_sex': '女'}
qq_number
qq_name
qq_age
qq_sex
{'qq_number': 3063320431, 'qq_name': '鱼仔', 'qq_age': 18, 'qq_sex': '男'}
qq_number
qq_name
qq_age
qq_sex
5.用户输入和while
#input（）返回字符串
msssage=input("请输入信息：")
print(type(msssage))

#input()获取数值输入
num=int(input("请输入一个数字："))
print(type(num))

#while 循环
#问题：while循环与for循环的区别是什么？
#for循环通常用于遍历一个序列（如列表、元组或字符串）中的每个元素，而while循环则根据条件判断是否继续执行。
print("for循环：")
for i in range(5):
    print(i)
print("\nwhile循环：")
i=0
while i < 5:
    print(i)
for循环：
0
1
2
3
4
while循环：
0
1
2
3
4
#问题：如何在一个游戏循环里让用户自己选择退出呢？
message=''
while message != "quit":
    message=input("是否继续游戏呢？\n输入'quit'退出游戏。\n")
    if message != "quit":
        print("游戏继续")
游戏继续
#问题：坦克大战这个游戏中，游戏结束的条件是什么？自己的坦克被敌方坦克击毁，或者敌方的大本营被击毁。
#如何去实现这个游戏结束的条件？
#用标志法来实现游戏结束的条件。
active = True
Tank_Hp=100
Base_Hp=100
game_round=1
while active:
    Tank_Hp=int(input("请输入坦克血量："))  
    Base_Hp=int(input("请输入基地血量："))
当前坦克血量90
当前基地血量100
当前回合数0
当前坦克血量0
当前基地血量0
当前回合数1
游戏结束！
#break continue
#break 用于完全退出循环，而continue 用于跳过当前循环的剩余部分并继续下一次迭代。
#问题：在回合制的模拟卡牌游戏中，玩家想在任意时刻立即退出而不是本回合结束后才退出，如何实现？
QUIT=True
while True:
    print("我们来到了一个新的回合")
    if QUIT:
        print("玩家退出了")
        break
    print("新回合开始")
我们来到了一个新的回合
玩家退出了
#问题：在回合制的模拟卡牌游戏中，玩家可以选择跳过自己的回合，直到轮到对手的回合。如何实现呢？
PASS=True
ROUND=2
game_round=1
while game_round<=2:
    print("我方回合")
    game_round+=1
    if PASS:
        print("跳过，到对方回合开始")
        continue
我方回合
跳过，到对方回合开始
我方回合
跳过，到对方回合开始
#while循环处理列表和字典
#问题：某公司有一份原始客户名单，其中包括客户的姓名和联系方式，现在需要验证每位客户的联系方式是否有效并移动到有效客户名单上。
customers= [{'name': '羡鱼肘子', 'phone': '13800138000'},
        {'name': '鱼鱼', 'phone': '13900139000'}]
valid_customers = []
while customers:
    customer=customers.pop()
    print('验证客户：',customer['name'])
    valid_customers.append(customer)
print('原始客户名单：',customers)
验证客户： 鱼鱼
验证客户： 羡鱼肘子
原始客户名单： []
有效客户名单： [{'name': '鱼鱼', 'phone': '13900139000'}, {'name': '羡鱼肘子', 'phone': '13800138000'}]
#问题：有一个数字游戏，在一系列数字删除所有的数字9？
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9,10,9,3,9,6,5,9]
while 9 in numbers:
    numbers.remove(9)
print(numbers)
5.函数 和积木类似的有趣的东西，但是更灵活。
#如何定义函数
def greeting(name):
    ''' 定义一个打招呼的函数 '''#这是一个良好的习惯
    print('你好, ' + name)
# 调用函数
greeting('鱼鱼')
你好, 鱼鱼
#实参和形参
def greeting(name):
    print('你好, ' + name)
greeting("鱼鱼")
#name是形参,"鱼鱼"是实参,为了便于理解（简单看为name="鱼鱼"）
#传递实参
#位置实参  实参的顺序要和形参的顺序一致
def greeting(name,msg):
    ''' 定义一个可以自定义招呼语的打招呼的函数 '''
    print(f"{msg}{name}")
greeting('鱼鱼','早上好！')
#关键字实参  可以不按照顺序传递
greeting(name='鱼鱼',msg='晚上好！')
#默认参数
def greeting(name,msg='中午好！'):
早上好！鱼鱼
晚上好！鱼鱼
中午好！鱼鱼
#返回简单值
def confess__love(crush):
    '''定义一个表白函数，crush是喜欢的人的名字，返回一句表白的话'''
    msg=f"{crush}，我一直在想，世界上有那么多的人,而我却偏偏遇到了你。这或许就是命运最好的安排。每次看到你，我的心里就像洒满了阳光，温暖而明亮。我喜欢和你在一起的每一刻，喜欢听你的声音，喜欢看你笑的样子。"
    return msg
msg=confess__love("鱼鱼")
print(msg)
鱼鱼，我一直在想，世界上有那么多的人,而我却偏偏遇到了你。这或许就是命运最好的安排。每次看到你，我的心里就像洒满了阳光，温暖而明亮。我喜欢和你在一起的每一刻，喜欢听你的声音，喜欢看你笑的样子。
#返回字典值
def my_girl(crush):
    '''定义一个爱人信息的函数，传入名字，返回字典信息'''
    crush={'name':crush,'age':20,'height':160,'brief_discribtion':'鱼鱼可爱又美丽，大方又优雅'}
    return crush
crush=my_girl('鱼鱼')
print(crush)
{'name': '鱼鱼', 'age': 20, 'height': 160, 'brief_discribtion': '鱼鱼可爱又美丽，大方又优雅'}
#传递列表
#问题：如何实现一个游戏的装备栏，可以修改装备?
equipments=['40米大刀','盾牌','弓箭','红太狼的平底锅']
def modify_equipment(equipments):
    equipment=input('请输入你想要修改的装备：')
    count=0
    while equipment  in equipments:
        if equipments[count]==equipment:
            equipments[count]=input('请输入你想要修改的装备：')
原始列表：
修改后的装备栏：
装备栏副本：
#传递任意数量的实参 *args 是元组类型，最后
#幸运数字游戏
def lucky_numbers(*args):
    '''幸运数字游戏，返回任意数量的幸运数字'''
    for number in args:
        print(f"Lucky number: {number}")
    return args
args=lucky_numbers(1,2,3,4,5)
print(args)
print(type(args))
Lucky number: 1
Lucky number: 2
Lucky number: 3
Lucky number: 4
Lucky number: 5
(1, 2, 3, 4, 5)

{'鱼鱼': 6, '肘子': 8, '羡鱼肘子': 8}

羡鱼肘子's lucky numbers are: 
1    
2    
3    
4    
5    
(1, 2, 3, 4, 5)
#函数 模块
#import 模块名 导入模块
#from 模块名 import 函数  导入模块中的函数
#from 模块名 import *  导入模块中的所有函数
很棒！我们的旅途已经过了十分之一啦！感觉如何？是不是so easy？接下来，我们继续前进！
OOP(object-oriented programming)面向对象编程
1.类、对象、实例
#问题：什么是类呢？简单来说（便于理解）： 类=属性+方法，目的是描述客观事物 
# 举个例子：比如说我需要描述一个人，我会说他的长相，身材等等归结为有什么这就是属性，
# 然后我可能会说他会做什么，有什么能力归结为他的行为这就是方法。
1.1简单的开始，构建 Crush类
class Crush:
    #定义初始化方法 self代表类的实例对象(必不可少，且必须位于其他参数前面），name和age是属性
    #简单理解：self 代表Crush类的实例对象，通过这个可以访问到Dog类中的属性和方法
    def __init__(self, name,age):
        '''初始化属性'''
        self.name = name
        self.age = age
    def eat(self):
        '''模拟吃东西'''
        print(f'{self.name} is eating...')
yy的名字是：鱼鱼，年龄为：20
鱼鱼 is eating...
鱼鱼 is sleeping...
鱼鱼是我的crush，xx是你的crush
1.2如何去使用类呢？
#在1.1的基础上我们知道了如何构建一个类，现在我们尝试一下。
#构建Car类，属性：价格，品牌，颜色 方法：显示车辆信息
class Car:
    def __init__(self,price,brand,color):
        '''初始化属性'''
        self.price = price
        self.brand = brand
        self.color = color
        self.mileage = 0
    def show_info(self):
价格：100000000，品牌：鱼鱼牌,颜色：五彩斑斓的黑
我新买的车的信息是价格：100000000，品牌：鱼鱼牌,颜色：五彩斑斓的黑，出厂时的行驶里程为：0公里
跑了10公里后，我的车现在是行驶里程为：10
跑了100公里后，我的车现在是行驶里程为：110
跑了200公里后，我的车现在行驶里程为：310
又跑了200公里后，我的车现在是行驶里程为：310
1.3继承（父类，子类）
#子类继承父类 class 子类名(父类名):
#问题：如何去模拟电动汽车呢？
class ElectricCar(Car):
    def __init__(self, price, brand, color, battery_size):
        '''
        初始化电动汽车的属性
        调用父类构造器,先初始化父类属性，再初始化子类属性
        '''
        super().__init__(price, brand, color)
        #子类特有的属性
#将实例用作属性 简洁优雅
class Battery:
    def __init__(self,battery_capacity):
        '''初始化电池容量 '''
        self.battery_capacity = battery_capacity
    def show_battery(self):
        '''显示当前电池容量 '''
        return self.battery_capacity
class ElectricCar(Car):
    def __init__ (self,battery_capacity,price,brand,color):
我的车的电池容量为80-kWh battery.
续航里程为80+公里
1.4导入类(从一个模块内导入类)
#导入单个类
from car import Car
my_new_car = Car('20W','鱼鱼牌','black')
print(my_new_car.show_info())
my_new_car.update_mileage(100)
价格：20W，品牌：鱼鱼牌,颜色：black
增加了100公里,当前行驶里程为100
#导入多个类
#导入car模块中的Car类和ElectricCar类，并给ElectricCar起一个别名eCar
from car import Car,ElectricCar as eCar 
my_new_eCar = eCar(100,'20万', '鱼鱼牌','black')
my_new_Car=Car('20万', '鱼鱼牌','black')
print(my_new_eCar.show_info())
print(my_new_Car.show_info())
print(my_new_eCar.battery.battery_capacity)
my_new_eCar.show_range()
价格：20万，品牌：鱼鱼牌,颜色：black
价格：20万，品牌：鱼鱼牌,颜色：black
100
续航里程为100+公里
#导入整个模块 模块号.类名
import car
my_new_car=car.Car('20W','yy','black')
my_new_ecar=car.ElectricCar(100,'20W','yy','black')
print(my_new_eCar.show_info())
print(my_new_Car.show_info())
print(my_new_eCar.battery.battery_capacity)
my_new_eCar.show_range()
价格：20万，品牌：鱼鱼牌,颜色：black
价格：20万，品牌：鱼鱼牌,颜色：black
100
续航里程为100+公里
能坚持到这里，已经很不错啦，相信你已经掌握了如何导入和使用模块。接下来，让我们一起看看python标准库（简单看看）
1.4python标准库:一组python内置模块
#random module
import random as rd
#生成一个1到10的随机数
print(rd.randint(1, 10))
#生成一个0到1之间的随机数
print(rd.random())
yy_like_list = ['东坡肘子', '糖醋排骨', '油闷大虾', '红烧狮子头', '清炒虾仁', '清蒸鲈鱼','醋溜白菜']
yy_like_tuple = ('东坡肘子', '糖醋排骨', '油闷大虾', '红烧狮子头', '清炒虾仁', '清蒸鲈鱼','醋溜白菜')
#我需要随机选择一个鱼鱼喜欢吃的菜如何实现呢？
print(rd.choice(yy_like_list))
6
0.18011515228347297
糖醋排骨
清炒虾仁
2.文件和异常
2.1读文件
#读取文件
#如何去读取一个文件呢？是不是需要一条指向文件的路径？
from pathlib import Path
path=Path("/home/aistudio/num.txt")
#读取文件内容,read_text()方法可以读取文件内容，读到文件末时会返回空字符串。
contents=path.read_text()
#去掉末尾的空白字符
contents=contents.rstrip()
print(contents)
1314520
1314520
8888888
9999999
6666666
2.2相对文件路径VS绝对文件路径
from pathlib import Path
#相对文件路径：是在当前工作目录下相对于当前文件的位置(简单理解就是和你的代码在同一个文件夹下)
relatiive_path=Path('num.txt')
numbers1=relatiive_path.read_text().rstrip()
print(numbers1)
#绝对文件路径：是从根目录开始的完整路径
absolut_path=Path('/home/aistudio/num.txt')
numbers2=relatiive_path.read_text().rstrip()
print(numbers2)
1314520
1314520
8888888
9999999
6666666
1314520
1314520
8888888
9999999
6666666
2.3文件访问
#逐行访问
from pathlib import Path
path=Path('num.txt')
numbers=path.read_text().splitlines()#逐行读取,返回一个列表
print(type(numbers))
print(numbers)
for num in numbers:
    print(num)

1314520
1314520
8888888
9999999
6666666
2.4文件内容使用示例
from pathlib import Path
path = Path('/home/aistudio/num.txt') #路径对象
numbers=path.read_text() #读取文本
print(type(numbers))
print(numbers)
#问题如何合成一行输出？
numbers_line_split=numbers.splitlines()
print(type(numbers_line_split))
str_numbers=""
for num in numbers_line_split:

1314520
1314520
8888888
9999999
6666666


13145201314520888888899999996666666
2.5写文件
#写文件
from pathlib import Path
path=Path('告白.txt')
#写入文本,如果文件不存在,则会创建,如果文件存在,则会覆写
#write_text()方法返回写入文件的字节数
txt_num=path.write_text('我喜欢你')
print(path.read_text())
print(txt_num)
#追加文本
with path.open('a',encoding='utf-8') as f:
我喜欢你
4
我喜欢你,鱼鱼
#写入多行
from pathlib import Path
path=Path('告白1.txt')
msg='我\n'
msg+='爱\n'
msg+='你\n'
path.write_text(msg)
print(path.read_text())
我
爱
你
3.异常：是一种特殊对象用来处理程序错误
#try-except代码块
try:
    # 这里放可能会产生异常的代码
    print(10/0)
except ZeroDivisionError:#匹配异常类型
    # 这里放异常处理代码
    print("Cannot divide by zero!")
Cannot divide by zero!
#else 代码块
#让我们一起实现一个简单的除法程序
while True:
    first_num=int(input("请输入被除数："))
    second_num=int(input("请输入除数："))
    try:
        answer=first_num/second_num
    except ZeroDivisionError:
        print("除数不能为0")
    else:
除数不能为0
程序结束
4.数据存储（JSON格式）json.dumps(data)和json.loads(data)(好处：通用性更强，便于跨语言传输和存储)
from pathlib import Path
import json
numbers=list(range(1,21))
print(type(numbers))  
path=Path('numbers.json')
data_numbers=json.dumps(numbers)
print(type(data_numbers))
print(data_numbers)
#写入文件
path.write_text(data_numbers)



#很不错啦，让我们用数据存储来实现一个很简单的游戏登陆问候程序吧。
from pathlib import Path
import json
path = Path("user.txt")
# 判断用户是否存在
if path.exists():
    data=path.read_text()
    user=json.loads(data)
    print(f"欢迎回来，{user['name']}!")
else:
欢迎回来，鱼鱼!
5.重构：简单来说是把一个功能完备的整体划分为各个独立的模块，每个模块完成一个特定的功能。
#重构上述的游戏登陆问候程序
from pathlib import Path
import json
def read_user_name(path):
    """尝试从文件中读取用户姓名"""
    if path.exists():
        data = path.read_text()
        user_name = json.loads(data)['name']
        return user_name
欢迎回来，鱼鱼!
6.测试(使用pytest)
#安装pytest
#在终端输入 py -m pip install --user pytest
6.1针对函数的测试
  #编写测试函数如test_name_function.py所示，再运行pytest test_name_function.py
6.2针对类的测试

#断言-->任意的条件语句 assert 条件表达式

#编写一个用于测试的类如:survey.py所示

#编写测试代码test_survey.py

#夹具的应用@pytest.fixture 如test_survey_new.py