1 前言
记录自己的学习过程，方便回头查看。整理不易，若有错误，还请多指出改正。
2 变量和简单数据类型
2.1字符串
字符串是一系列字符，可以用单引号，也可以用双引号括起来。
"This is a string."
'This is also a string.'
2.1.1 使用方法修改字符串的大小写
name="ada lovelace"
print(name.title())#title()以首字母大写的方式显示每个单词
print(name.upper())#将字符串全部改为大写
print(name.lower())#将字符串全部改为小写
运行截图：
2.1.2 在字符串中使用变量
要在字符串中插入变量的值，可在前引号前加上字母f ，再将要插入的变量放在花括号内。这样，当Python显示字符串时，将把每个变量都替换为其值。
irst_name="ada"
last_name="lovelace"
full_name=f"{first_name} {last_name}"#合并字符串，要在字符串中插入变量的值，可在前引号前加上字母f
print(f"hello {full_name.title()}")
print(f"hello,{first_name} {last_name}!")#利用f字符串可以把花括号内的变量替换为其值
运行截图：
2.1.3 删除空白
rstrip()---------删除末尾空白
lstrip()---------删除开头空白
strip()---------删除两边空白
print("\tpython")#\t为制表符
favorite_language='python '
print(favorite_language)
print(favorite_language.rstrip())#rstrip删除字符串末尾的空白
#lstrip()删除字符串开头的空白 strip()删除两边的空白
运行截图：
2.2 数
2.2.1 整数和浮点数
将任意两个数相除，结果总是浮点数，即使这两个数都是整数且能整除。
2.2.2 数中的下划线
当书写很大的数字时，可使用下划线将其中的数字分组，比如14000000000可表示成14_000_000_000
universe_age=14_000_000_000#书写很大的数字时，可以用下划线将其中的数字分组
print(universe_age)
运行结果
2.2.3 常量
常量类似于变量，但其值在程序的整个生命周期内保持不变。Python没有内置的常量类型，但Python程序员会使用全大写来指出应将某个变量视为常量，其值应始终不变：
MAX_CONNECTIONS = 5000
2.3 注释
1.单行注释，使用#
2.多行注释，使用’’‘代码块’’’，一对三个单引号括起来
3 列表
3.1 列表含义
列表由一系列按特定顺序排列的元素组成。你可以创建包含字母表中所有字母、数字0～9或所有家庭成员姓名的列表；也可以将任何东西加入列表中，其中的元素之间可以没有任何关系。
在Python中，用方括号（[] ）表示列表，并用逗号分隔其中的元素。
bicycles=['trek','cannondale','redline','specialized',4]#列表
print(bicycles)#打印列表中的内容，包括方括号
运行截图：
3.1.1 访问列表元素
要访问列表的任意元素，只需将该元素的位置（索引 ）告诉Python即可。要访问列表元素，可指出列表的名称，再指出元素的索引，并将后者放在方括号内。
bicycles=['trek','cannondale','redline','specialized',4]#列表
print(bicycles)#打印列表中的内容，包括方括号
print(bicycles[0])#访问列表元素，不包括方括号
print(bicycles[0].title())
print(bicycles[-1])#访问最后一个元素，经常用于不知道列表长度的情况下
运行截图：
1.当请求获取列表元素时，Python只返回该元素，而不包括方括号
2.第一个列表元素的索引为0
3.python可指定最后一个列表元素的索引为-1，以此类推，-2指的是倒数第二个元素，经常用于不知道列表长度的情况下
3.1.2 使用列表各个值
像使用其他变量一样使用列表中的各个值。例如，可以使用f字符串根据列表中的值来创建消息
message=f"my first bicyle was a {bicycles[0].title()}"
print(message)
运行截图：
3.2 修改、添加和删除元素
3.2.1 修改列表元素
要修改列表元素，可指定列表名和要修改的元素的索引，再指定该元素的新值。
bicycles[0]='duck'#修改列表元素的某个值
print(bicycles)
运行截图：
3.2.2 在列表中添加元素
1.在列表末尾添加元素
将元素附加(append)到列表。给列表附加元素时，它将添加到列表末尾。
调用append( )函数从列表末尾添加元素。
bicycles.append('mike')#将元素附加到元素末尾
print(bicycles)
运行截图：
2.在列表中插入元素
使用insert( )可在列表的任何位置添加新元素。指定新元素的索引和值。
bicycles.insert(0,'kile')#在列表中插入元素
print(bicycles)
运行截图：
3.2.3 从列表中删除元素
1.使用del语句删除元素
若知道要删除的元素在列表中的位置，可使用del语句。但这种删除是不可逆的，也就是说列表中真的删除了该元素，且找不回该元素。
del bicycles[0]#使用del删除列表中的元素，且不再使用它
print(bicycles)
2.使用方法pop( )删除元素
有时候，需要将元素从列表中删除，并接着使用它的值。方法pop()删除列表末尾，并让你能够接着使用它。术语弹出 （pop）源自这样的类比：列表就像一个栈，而删除列表末尾的元素相当于弹出栈顶元素。但这种删除是不可逆的，也就是说列表中真的删除了该元素。
b=bicycles.pop()#使用pop()删除列表中末尾的一位元素
print(bicycles)
3.弹出列表中任何位置处的元素
可以使用pop() 来删除列表中任意位置的元素，只需在圆括号中指定要删除元素的索引即可
b=bicycles.pop(2)#使用pop()删除列表中指定的元素，用b记录要删除的值，后续还要使用它
print(bicycles)
4.根据值删除元素
若只知道要删除的元素的值，可使用方法remove()
bicycles.remove('duck')#根据值删除元素
print(bicycles)
同样，也可将删除的元素赋给另外一个变量，接着使用它的值。
remove()只删除第一个指定的值。
3.3 组织列表
3.3.1 使用sort()对列表永久排序
sort()对列表按字母顺序排序，彻底修改列表顺序。
cars=['bmw','audi','toyota','subaru']
cars.sort()#sort对列表按字母顺序排序，彻底修改列表顺序
print(cars)
还可以按与字母顺序相反的顺序排列列表元素，只需向sort() 方法传递参数reverse=True 即可。
cars.sort(reverse=True)#向sort传递参数reverse=True，对列表按字母反顺序排序，彻底修改列表顺序
print(cars)
3.3.2 使用函数sorted()对列表临时排序
要保留列表元素原来的排列顺序，同时以特定的顺序呈现它们，可使用函数sorted() 。函数sorted() 让你能够按特定顺序显示列表元素，同时不影响它们在列表中的原始排列顺序。
carss=['bmw','audi','toyota','subaru']
print("here is the original list:")
print(carss)
print("\nhere is the sorted list:")
print(sorted(carss))#sorted对列表临时按字母顺序排序
print(sorted(carss,reverse=True))#sorted对列表临时按字母顺反序排序
print("\nhere is the original list again:")
print(carss)
运行截图：
3.3.3 倒着打印列表
要反转列表元素的排列顺序，可使用方法reverse()
cars.reverse()#永久倒着打印列表
print(cars)
cars.reverse()#反转为原列表
print(cars)
注意，reverse() 不是按与字母顺序相反的顺序排列列表元素，而只是反转列表元素的排列顺序
方法reverse() 永久性地修改列表元素的排列顺序，但可随时恢复到原来的排列顺序，只需对列表再次调用reverse() 即可。
3.3.4 确定列表的长度
使用len()函数求列表的长度。
print(len(cars))#确定列表长度
4 操作列表
4.1 遍历整个列表
利用for循环
格式：
for x(变量名字) in y(列表名字):
相同缩进的代码
在for循环后面，没有缩进的代码只执行一次。
magicians=['alice','david','carolina']
for magician in magicians:#for循环
print(magician)
print(f"{magician.title()},that was a great trick!")
print("end")#没有缩进的代码只执行一次
运行截图：
4.2 创建数值列表
4.2.1 使用函数range()
Python函数range() 能够生成一系列数。
for vaule in range(1,6):#range随机打印1-5个数字
print(vaule)
函数range() 让Python从指定的第一个值开始数，并在到达你指定的第二个值时停止。因为它在第二个值处停止，所以输出不包含该值（这里为6）。
运行截图：
4.2.2 使用range()创建数字列表
要创建数字列表，可使用函数list()将range()的结果直接转换成列表。如果将range() 作为list() 的参数，输出将是一个数字列表。
numbers=list(range(1,6))#使用range创建数字列表
print(numbers)
运行截图：
使用函数range() 时，还可指定步长。为此，可给这个函数指定第三个参数，Python将根据这个步长来生成数。
此时步长为2
even_numbers=list(range(2,11,2))#利用range的第三个参数可以指定步长
print(even_numbers)
运行截图：
创建一个列表，其中包含前10个整数的平方。用两个星号**表示乘方运算。
squares=[]
for value in range(1,11):
square=value**2 #**表示乘方运算
squares.append(square)
print(squares)
运行截图：
4.2.3 对数字列表执行简单的统计运算
min()--------求最小值
max()-------求最大值
sum()-------求和
digits=[1,2,3,4,5,6,7,8,9,10]
print(f"min:{min(digits)}")#几个针对数字的函数，求最小值，最大值，求和
print(f"max:{max(digits)}")
print(f"sum:{sum(digits)}")
运行截图：
4.2.4 列表解析
列表解析，把for循环和创建新元素的代码合并成一行，并自动附加新元素。
squares=[]
ss=[v**2 for v in range(1,11)]#列表解析，把for循环和创建新元素的代码合并成一行
print("ss:",ss)
运行截图：
4.3 使用列表的一部分
处理列表的一部分，python称之为切片。
4.3.1 切片
要创建切片，可指定要使用的第一个元素和最后一个元素的索引。也可指定步长。
print(digits[-10::2])#切片，处理列表中的部分元素,每隔两个元素输出
运行截图:
4.3.2 遍历切片
如果要遍历列表的部分元素，可在for循环中使用切片。
for d in digits[:3]:#利用切片，只遍历前三个元素
print(d)
由于没有指定起始索引，从列表开头开始提取
运行截图：
4.3.3 复制列表
要复制列表，可创建一个包含整个列表的切片，方法是同时省略起始索引和终止索引（[:] )。这让Python创建一个始于第一个元素、终止于最后一个元素的切片，即整个列表的副本。
digits=[1,2,3,4,5,6,7,8,9,10]
dd=digits[:]#利用切片复制列表，dd是副本
print(dd)
ddd=digits#ddd与digits共用一个空间，不是副本
4.4 元组
列表是可修改的，不可变的列表称为元组。
4.4.1 定义元组
元组使用圆括号来标识。定义元组后，可使用索引来访问。
dimensions=(200,5)#定义元组
print(dimensions)
print(dimensions[0])#访问元组数据
#dimensions[0]=30 不可修改元组数据
#my_t=(3,)定义只包含一个元素的元组，必须在这个元素后面加上逗号
运行截图：
4.4.2 遍历元组中的所有值
可使用for循环来遍历
for d in dimensions:#遍历元组
print(d)
4.4.3 修改元组变量
虽然不能修改元组的元素，但可以给存储元组的变量赋值。
dimensions=(400,100)#修改元组变量，共用一个空间
print(dimensions)
运行截图：
5 if语句
示例1
carrs=['audi','bmw','subaru','toyota']
for car in carrs:
if car=='bmw':# if else用法
print(car.upper())
else:
print(car.title())
示例2
car='AUDI'
print(car.lower()=='audi')#检查是否相等时忽略大小写
if car!='annn':#检查不相等
print("false")
示例3
age=18
if age<4:
print("0")
elif age<=18:#只想执行一个代码块，就是用if-elif-else结构，如果要执行多个代码块，就使用一系列独立的if语句
print("1")
else:
print("2")
示例4
requested_toppings=['mushrooms','green peppers','extra cheese']
for r in requested_toppings:
if r=='green peppers':
print("sorry")
else:
print(f"Adding {r}")
6 字典
6.1 一个简单的字典
alien_0={'color':'green','points':5}
print(alien_0['color'])
print(alien_0['points'])
new_points=alien_0['points']
print(f"you just earned {new_points} points!")
运行截图：
6.2 使用字典
字典是一系列键值对。每个键都与一个值相关联，可以使用键来访问相关联的值。
与键相关联的值可以是数、字符串、列表乃至字典。事实上，可将任何Python对象用作字典中的值。
在Python中，字典用放在花括号（{} ）中的一系列键值对表示
alien_0['x']=0#添加键值对
alien_0['y']=25
print(alien_0)
运行截图：
6.2.1 修改字典中的值
要修改字典中的值，可依次指定字典名、用方括号括起的键，以及与该键相关联的新值。
alien_0['color']='yellow'#修改字典中的值
print(alien_0['color'])
6.2.2 删除键值对
使用del彻底删除键值对 ，使用del语句时，必须指定字典名和要删除的键。
del alien_0['x']#使用del彻底删除键值对
print(alien_0)
6.2.3 由类似对象组成的字典
确定需要使用多行来定义字典时，要在输入左花括号后按回车键。在下一行缩进四个空格，指定第一个键值对，并在它后面加上一个逗号。此后再按回车键时，文本编辑器将自动缩进后续键值对，且缩进量与第一个键值对相同。
favorite_language={
'jen':'python',
'sarah':'c',
'edward':'ruby',
'phil':'python',
}#由类似对象组成的字典
language=favorite_language['sarah'].title()
print(f"sarah's favorite language is {language}")
运行截图：
6.2.4 使用get()来访问值
使用get来访问值，get的第一参数用于指定键，第二个参数当指定的键不存在时要返回的值，是可选的
point_value=alien_0.get('points','no')#使用get来访问值，get的第一参数用于指定键，第二个参数当指定的键不存在时要返回的值，是可选的
print(point_value)
6.3 遍历字典
6.3.1 遍历所有键值对
user_0={
'username':'efermi',
'first':'enrico',
'last':'fermi',
}
for k,v in user_0.items():#遍历字典中的所有键值对
print(f"key:{k},value:{v}")
运行截图：
要编写遍历字典的for 循环，可声明两个变量，用于存储键值对中的键和值。这两个变量可以使用任意名称。
for k, v in user_0.items()
6.3.2 遍历字典中的所有键
在不需要使用字典中的值时，方法keys()很有用。也可以忽略它。
for name in favorite_language.keys():#遍历字典中的所有键，或者替换成favorite_language，输出不变
print(name)
示例1
friends=['phil','sarah']
for name in favorite_language.keys():
print(f"hi,{name.title()}")
if name in friends:
language=favorite_language[name].title() #在名字为指定朋友的名字时，打印一条消息
print(f"\t{name.title()}, I see you love {language}")
运行截图
6.3.3 按特定顺序遍历字典中的所有键
要以特定顺序返回元素，一种办法是在for 循环中对返回的键进行排序。为此，可使用函数sorted() 来获得按特定顺序排列的键列表的副本，按字母顺序
#以特定的顺序遍历字典中的所有键，使用函数sorted
for name in sorted(favorite_language.keys()): #对返回的键进行排序
print(f"{name.title()}")
运行截图：
6.3.4 遍历字典中的所有值
可使用values()来返回一个值列表，不包含任何键。
for lan in favorite_language.values():#遍历字典中所有的值，但是没有考虑重复的值
print(f"{lan.title()}")
for lan in set(favorite_language.values()):#遍历字典中所有的值，使用set,去除重复项
print(f"hello,{lan.title()}")
这种做法提取字典中所有的值，而没有考虑是否重复。涉及的值很少时，这也许不是问题，但如果被调查者很多，最终的列表可能包含大量重复项。为剔除重复项，可使用集合(set)。集合中的每个元素都必须是独一无二的.
#####集合与字典的区别#####
lang={'python','ruby','python','c'}#用一对花括号直接创建集合，并在其中用逗号分割元素
print(lang)#输出没有重复的元素，当花括号内没有键值对时，定义的很可能是集合
运行截图：
可以看出集合lang中有两个重复的元素’python’，但是输出只有一个。
6.4 嵌套
有时候，需要将一系列字典存储在列表中，或将列表作为值存储在字典中，这称为嵌套 。可以在列表中嵌套字典、在字典中嵌套列表甚至在字典中嵌套字典。
6.4.1 字典列表
在列表中嵌套字典
alien_0={'color':'green','points':5}
alien_1={'color':'green','points':10}
alien_2={'color':'green','points':15}
aliens=[alien_0,alien_1,alien_2]#在列表中嵌套字典
for alien in aliens:
print(alien)
运行截图：
示例1
#创建一个用于存储外星人的空列表
aliens=[]
#创建30个绿色的外星人
for alien_n in range(30):
new_alien={'color':"green",'points':5,"speed":'slow'}
aliens.append(new_alien)
for a in aliens[:3]:
if a['color']=='green':
a['color']='yellow'
a['points']=10
a['speed']='fast'
for a in aliens[:5]:
print(a)
print(f"共有:{len(aliens)}")
运行截图：
6.4.2 在字典中存储列表
将列表存储在字典中。
#存储所点比萨的信息
pizza={
'crust':'thick',
'toppings':['mushrooms','extra cheese']
}
#概述所点的比萨
print(f"{pizza['crust']}:")
for topping in pizza['toppings']:
print("\t"+topping)
运行截图：
示例1
favorite_languages={
'jen':['python','ruby'],
'sarah':['c'],
'edward':['ruby','go'],
'phil':['python','haskell']
}
for n,ls in favorite_languages.items():
print(f"{n.title():}")
for l in ls:
print(f"\t{l.title()}")
运行截图：
6.4.3 在字典中存储字典
###############在字典中存储字典
users={
'aeinstein':{
'first':'albert',
'last':'einstein',
'location':'princeton',
},
'mcurie':{
'first':'marie',
'last':'curie',
'location':'paries',
}
}
for username,user_info in users.items():
print(f"\nusername:{username}")
full_name=f"{user_info['first']} {user_info['last']}"
location=user_info['location']
print(f"\tfullname:{full_name.title()}")
print(f"\tlocation:{location.title()}")
运行截图：
7 用户输入和while循环
7.1 函数input()的工作原理
函数input()让程序暂停运行，等待用户输入一些文本。获取用户输入后，python将其赋给一个变量。
#函数input让程序暂停运行，等待用户输入一些文本
'''
prompt='tell me something'
prompt+='\nyou age:' #创建多行字符串
message=input(prompt)
print(F"\nhello,{message}")
运行截图：
7.1.1 使用int()来获取数值输入
使用函数input()时，python将用户输入解读为字符串。
#if message>19:
# print("yes")#报错，因为使用input时，python将用户输入解读成字符串，数字字符串是无法比较大小
#使用int()来获取数值输入
m=int(message)
if m>19:
print("yes")
7.2 while循环简介
##########while中使用标志
prompt='tell me something'
prompt+='\nyou message:'
active=True #标志 程序在标志为True继续运行
while active:
message=input(prompt)
if message=='quit':
break #使用break退出循环 continue根据条件测试结果决定是否继续执行循环
active=False
else:
print(message)
7.3 使用while循环处理列表和字典
7.3.1 在列表之间移动元素
###################在列表之间移动元素####################
u_users=['alice','brain','candace']
c_users=[]
while u_users:
c_user=u_users.pop()#类似于元素出栈
print(f"verifying user:{c_user.title()}")
c_users.append(c_user)#把出栈的元素加到另外一个列表中
#显示所有已验证的用户
for c_user in c_users:
print(c_user.title())
7.3.2 删除为特定值的所有列表元素
使用remove()来删除列表中的特定值。
##################删除为特定值的所有列表元素###################
pets=['dog','cat','dog','cat','duck']
print(pets)
while 'cat' in pets:
pets.remove('cat')#使用remove
print(pets)
7.3.3 使用用户输入来填充词典
#设置一个标志
responses={}
p=True
while p:
name=input("\nname:")
r=input("do:")
#将回答存储在词典中
responses[name]=r
rr=input("yes/no:")
if rr=='no':
p=False
print("\n----results------")
for name,r in responses.items():
print(f"{name}：{r}")
8 函数
8.1 定义函数
def function_name(函数名):
示例1
def greet_user(name): #向函数传递信息
print(f"hello,{name.title()}")
greet_user('alice')
greet_user(name='pite') #关键字实参
示例2
def get_formatted_name(first_name,last_name):
full_name=f"{first_name} {last_name}"
return full_name.title() #返回简单值
m=get_formatted_name('chen','jie')
print(m)
运行截图：
示例3
########返回字典
def build_person(first_name,last_name,age=None):#新增可选参数age None视为占空位
person={'first':first_name,'last':last_name}
if age:
person['age']=age #None在条件测试中相当于False
return person
m=build_person('jimi','hendrix',age=27)
print(m)
运行截图：
示例4
##########传递列表
def greet_users(names):
for name in names:
masg=f"hello,{name.title()}"
print(masg)
usernames=['liu','li','chen']
greet_users(usernames)
运行截图：
示例5
将列表传递给函数后，函数就可对其进行修改。
###在函数中修改列表
def print_models(u_designs,c_models):
while u_designs:
c=u_designs.pop()
print(f"printing model:{c}")
c_models.append(c)
def show(c_models):
print("\nthe following models have been printed:")
for cc in c_models:
print(cc)
u_designs=['phone','root','dodo']
c_models=[]
print_models(u_designs,c_models)#注意两种传递列表方法的不同
print_models(u_designs[:],c_models) #[:]切片法，将列表的副本传递给函数，函数所做的任何修改只影响副本，但是会浪费空间
show(c_models)
运行截图：
示例6
若预先不知道函数需要接受多少实参。
形参*toppings可以传递任意数量的实参,创建一个空元组。
####################传递任意数量的实参##################
def make_pizza(*toppings):#形参*toppings可以传递任意数量的实参,创建一个空元组
print(toppings)
make_pizza('pepi')
make_pizza('kk','mm')
运行截图：
示例7
若预先不知道传递给函数的会是什么样的信息。可将函数编写成能够接受任意数量的键值对-----调用语句提供了多少就接受多少。
####################使用任意数量的关键字实参#############
#可将函数编写成能接受任意数量的键值对
def build_profile(first,last,**user_info): #形参 **user_info创建一个空词典
user_info['first_name']=first
user_info['last_name']=last
return user_info
user=build_profile('you','are',name='liming',age='27')
print(user)
运行截图：
可以观察一下参数输出的位置
8.2 将函数存在模块中
1.导入整个模块
要让函数是可导入的，得先创建模块。模块是扩展名为.py的文件，包含要导入到程序中的代码。
先创建一个pizza.py的文件
#pizza.py
def make_pizza(size,*toppings):
print(f"\nmaking a {size}:")
for topping in toppings:
print(f"-{topping}")
接着在同一目录下创建另外一个文件first.py，使用import导入该pizza.py模块，就可在程序中使用该模块中的所有函数。
import 模块名
使用该模块下的某个函数：
模块名.函数名
#first.py
##import 允许在当前运行的程序文件中使用模块中的代码
import pizza
list=['ppie','mimi','vv']
pizza.make_pizza(16,list)
运行截图：
2.导入某个特定的函数
from module_name(模块名) import function_name(函数名)
#from module_name import function_name
from pizza import make_pizza #导入特定的函数
make_pizza(17,'kki')
运行截图：
3.使用as给函数指定别名
#from module_name(模块名) import function_name(函数名) as fn(函数别名)
#使用as给函数指定别名
from pizza import make_pizza as mp
mp(15,'gg')
4.使用as给模块指定别名
#from module_name(模块名) as mn(模块别名)
#使用as给模块指定别名
import pizza as p
p.make_pizza(13,'llp')
5.导入模块中的所有函数
from module_name(模块名) import *
#使用*导入模块中的所有函数
from pizza import *
9 类
9.1 创建类
1.在python中，首字母大写的名称指的是类。类中的函数称为方法。
2.self是一个指向实例本身的引用，让实例能够访问类中的属性和方法，不需要传值
def__init__(self,name,age)
3.方法__init__() 是一个特殊方法，每当你根据Dog 类创建新实例时，Python都会自动运行它。在这个方法的名称
中，开头和末尾各有两个下划线，这是一种约定，旨在避免Python默认方法与普通方法发生名称冲突。
class Dog:
def __init__(self,name,age): #self是一个指向实例本身的引用，让实例能够访问类中的属性和方法，不需要传值
self.name=name #以self为前缀的变量可供类中的所有方法使用
self.age=age
def sit(self): #类中的函数称为方法
print(f"{self.name} is now sitting")
def roll_over(self):
print(f"{self.age} rolled over!")
my_dog=Dog("wilily",6)
my_dog.sit()#调用方法
my_dog.roll_over()
print(f"my dog's name is {my_dog.name}")
print(f"my dog's age is {my_dog.age}")
运行截图：
9.2 使用类和实例
class Car:
def __init__(self,make,model,year):
self.make=make
self.model=model
self.year=year
self.read_mee=0 #给属性指定默认值，创建实例时，有些属性无须通过形参来定义，可在方法__init__中为其指定默认值
def get_name(self):
long_name=f"{self.year},{self.model},{self.make}"
return long_name.title()
def readd_self(self):
print(f"this car has {self.read_mee} miles on it")
my_carr=Car('doir','a3',2019)
print(my_carr.get_name())
my_carr.readd_self()
运行截图：
9.3 继承
1.定义子类时，必须在圆括号内指定父类的名称
2.使用super()，能够调用父类的方法，这行代码让Python调用Car 类的方法__init__() ，让ElectricCar 实例包含这个方法中定义的所有属性。父类也称为超类 （superclass）
class Battery:
def __init__(self,battery_size=80):
self.battery_size=battery_size
def describe_battery(self):
print(f"this car has a {self.battery_size}-kwh battery")
##############继承--子类的方法
class ElectriCar(Car): #定义子类时，必须在圆括号内指定父类的名称
def __init__(self,make,model,year):
super().__init__(make,model,year)#使用super()，能够调用父类的方法
self.battery=Battery() #添加一个新属性battery 创建一个新的Battery实例
# self.battery_size=75 #给子类定义属性和方法
# def readd_self(self): #重写父类的方法
# print(f"hello,{self.battery_size}")
my_tesla=ElectriCar('tesla','model s',2019)
print(my_tesla.get_name())
my_tesla.battery.describe_battery()
运行截图：
3.导入模块–使用模块中的类
#second.py
class Car:
def __init__(self,make,model,year):
self.make=make
self.model=model
self.year=year
self.battery_size = 88 #给属性指定默认值，创建实例时，有些属性无须通过形参来定义，可在方法__init__中为其指定默认值
def get_name(self):
long_name=f"{self.year},{self.model},{self.make}"
return long_name.title()
def read_odometer(self):
print(f"this car has {self.battery_size} miles on it")
my_carr=Car('doir','a3',2019)
print(my_carr.get_name())
my_carr.battery_size=23
my_carr.read_odometer()
#first.py
##############################导入整个模块############
import second
my_beetle=second.Car('volk','bett',2019)
print(my_beetle.get_name())
运行截图：
9.4 python标准库
from random import randint
print(randint(1,6)) #randint()随机返回一个位于这两个整数之间含的整数
from random import choice
players=['a','b','c','d','e']
print(choice(players)) #choice()，它将一个列表或元组作为参数，并随机返回其中的一个元素
运行截图：
练习9-13：骰子 创建一个Die 类，它包含一个名为sides 的属性，该属性的默认值为6。编写一个名为roll_die() 的方法，它打印位于1和骰子面数之间的随机数。创建一个6面的骰子再掷10次。创建一个10面的骰子和一个20面的骰子，再分别掷10次。
from random import randint
class Die:
def __init__(self,sides=6):
self.sides=sides
def roll_die(self,count=1):
while count:
count=count+1
m=randint(1,self.sides)
if count==11:
print("result:",m)
break
my_die=Die(10) #可改20
my_die.roll_die(1)
运行截图：
10 文件和异常
10.1 读入文件
1.关键字with在不再需要访问文件时将其关闭
2.open()打开，read()读取，因为read到达文件末尾时返回一个空字符串，所以需要用rstrip()删除末尾的空白
#############################文件#####################################
with open('pi_digits') as file_object: #关键字with在不再需要访问文件时将其关闭
contents=file_object.read() #打开文件，并读取
print(contents) #末尾会多了一个空行，因为read到达文件末尾时返回一个空字符串
print(contents.rstrip())#删除字符串末尾的空白
可通过文件路径访问文件
#文件路径
file_path='C:/Users/qing/Desktop/data.txt'
with open(file_path) as file_first:
print(file_first.read().rstrip())
#逐行读取
filename='pi_digits' #将要读取的文件的名称赋给变量filename
with open(filename) as file_ject:
for liness in file_ject:
print(liness.rstrip())
readlines()从文件中读取每一行，并将其存储在一个列表中
#创建一个包含文件各行内容的列表
with open(filename) as file_object:
lines=file_object.readlines() #readlines()从文件中读取每一行，并将其存储在一个列表中
for line in lines:
print(line.rstrip())
#使用文件的内容
pi_string='' #创建一个空字符串
for line in lines:
pi_string+=line.strip()
print(pi_string)
print(len(pi_string))
#包含一百万位的大型文件
filename='pi_million_digits.txt'
with open(filename) as file_second:
lin=file_second.readlines()
p_string=''
for line in lin:
p_string+=line.strip() #去掉前后空白
print(f"{p_string[:52]}...") #打印圆周率小数点后50位
print(len(p_string))
10.2 写入文件
调用open() 时提供了两个实参。第一个实参也是要打开的文件的名称。第二个实参（‘w’ ）告诉Python，要以写入模式打开这个文件。打开文件时，可指定读取模式 （‘r’ ）、写入模式 （‘w’ ）、附加模式 （‘a’ ）或读写模式 （‘r+’ ）。如果省略了模式实参，Python将以默认的只读模式打开文件。
如果要写入的文件不存在，函数open() 将自动创建它。然而，以写入模式（‘w’）打开文件时千万要小心，因为如果指定的文件已经存在，Python将在返回文件对象前清空该文件的内容。
##############写入文件##################
filename_s='programming.txt'
with open(filename_s,'w') as file_third: #w为写入模式
file_third.write("I love programming.\n") #文件不会自动换行 需要手动加换行符
file_third.write("yes,and you\n")
with open(filename_s,'a') as file_third: #a表示附加到文件，不是覆盖原来内容
file_third.write("hello,my world!\n")
with open('programming.txt') as file_thirds:
c=file_thirds.read()
print(c.strip())
运行截图：
10.3 异常
示例1
#编写一个ZeroDivisionError异常的try-except代码块来处理可能发生的异常
try:
print(5/0)
except ZeroDivisionError:
print("you can't divide by zero!")
#将可能发生的错误放在try-except代码块中
示例2
print("give me two numbers,enter 'q' to quit.")
while True:
first_number=input("\nfirst number:")
if first_number=='q':
break
second_number=input("second number:")
if second_number=='q':
break
try:
answer=int(first_number)/int(second_number)
except ZeroDivisionError:
print("you can't divide by zero!")
else:
print(answer)
通过将可能引发错误的代码放在try-except 代码块中，可提高程序抵御错误的能力。还包含一个else 代码块。依赖try 代码块成功执行的代码都应放到else 代码块中。
示例3
#########################处理FileNotFoundError异常#############
#尝试读一个不存在的文件
filename='alice.txt'
try:
with open(filename,encoding='utf-8') as f: #给参数encoding指定了值，防止系统的默认编码与要读取文件使用的编码不一致
contents=f.read()
except FileNotFoundError:
print(f"sorry,the file {filename} does not exist.")
else:
words=contents.split() #split()以空格为分隔符将字符串分拆成多个部分，并将这些部分都存储到一个列表中。可能有些单词包含标点
num_words=len(words)
print(f"the file {filename} has about {num_words} words")
#####split()以空格为分隔符分割字符串######
title='alice in wonderland!'
print(title.split())
运行截图：
##############使用多个文件#############
def count_words(filename): #计算一个文件中包含多少单词
try:
with open(filename,encoding='utf8') as f:
contents=f.read()
except FileNotFoundError:
print(f"sorry,the file {filename} does not exist.")
#pass #pass语句让程序发生异常时保持静默，继续运行
else:
words=contents.split()
num_words=len(words)
print(f"the file {filename} has about {num_words} words.")
filename='alice.txt'
count_words(filename)
filenames=['alice.txt','siddhartha.txt','moby_dick.txt','little_woman.txt']
for filename in filenames:
count_words(filename)
运行截图：
10.4 存储数据
使用模块json 来存储数据。
模块json 让你能够将简单的Python数据结构转储到文件中，并在程序再次运行时加载该文件中的数据。还可以使用json 在Python程序之间分享数据。
JSON（JavaScript Object Notation）格式最初是为JavaScript开发的，但随后成了一种常见格式，被包括Python在内的众多语言采用。
10.4.1 使用json.dump()和json.load()
函数json.dump() 接受两个实参：要存储的数据，以及可用于存储数据的文件对象。
使用json.load() 将列表读取到内存中。
###################使用json.dump()和json.load()
import json
numbers=[2,3,5,7,11,13]
filename='numbers.json'
with open(filename,'w') as f:
json.dump(numbers,f) #使用json.dump()将数字列表存储到文件numbers.json中，包括要存储的数据以及可用于存储数据的文件对象
import json
filename='numbers.json'
with open(filename) as f:
numbers=json.load(f) #使用json.load()将列表读取到内存中
print(numbers)
10.4.2 保存和读取用户生成的数据
提示用户首次运行程序时输入自己的名字，并在再次运行程序时记住他。
####################保存和读取用户生成的数据
'''
import json
#如果以前存储了用户名，就加载它
#否则，提示用户输入用户名并存储它
filename='username.json'
try:
with open(filename) as f:
username=json.load(f)
except FileNotFoundError:
username=input("what is your name?")
with open(filename,'w') as f:
json.dump(username,f)
print(f"we'll remember you when you come back,{username}!")
else:
print(f"welcome back,{username}")
10.4.3 重构
代码能够正确地运行，但通过将其划分为一系列完成具体工作的函数，还可以改进。这样的过程称为重构 。重构让代码更清晰、更易于理解、更容易扩展。
########################重构###############
'''
import json
def get_stored_username():
#如果存储了用户名，就获取它
filename='username.json'
try:
with open(filename) as f:
username=json.load(f)
except FileNotFoundError:
return None
else:
return username
def get_new_username():
#提示用户输入用户名
username=input("what is your name?")
filename='username.json'
with open(filename,'w') as f:
json.dump(username,f)
return username
def greet_user():
username=get_stored_username()
if username:
print(f"welcome back,{username}")
else:
username=get_new_username()
print(f"we'll remember you when you come back,{username}! ")
greet_user()
首次运行截图：
再次运行截图：
练习10-11：喜欢的数 编写一个程序，提示用户输入喜欢的数，并使用json.dump() 将这个数存储到文件中。再编写一个程序，从文件中读取这个值，并打印如下所示的消息。
I know your favorite number! It’s _____.
import json
filename='fa_numbers.json'
with open(filename,'w') as f:
n=input("please input you favorite number:")
json.dump(n,f)
with open(filename) as f:
n=json.load(f)
print(f"I know your favorite number!It's {n}")
运行截图：
练习10-12：记住喜欢的数 将练习10-11中的程序合二为一。如果存储了用户喜欢的数，就向用户显示它，否则提示用户输入喜欢的数并将其存储到文件中。运行这个程序两次，看看它能否像预期的那样工作。
filename='f_numbers.json'
try:
with open(filename) as f:
n = json.load(f)
print(f"number:{n}")
except FileNotFoundError:
with open(filename, 'w') as f:
n = input("please input you favorite number:")
json.dump(n, f)
print(f"we'll remember you when you come back,{n}")
else:
print(f"welcome back,{n}")
首次运行截图：
再次运行截图：
后记
已经完成这本基础书的一半整理了，后续有些python项目，我觉得还挺有价值，后续有时间会慢慢补上的。一定要边练习边整理笔记，否则像我这样回头整理笔记----真要命。
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
