目录
2.在字符串中使用变量：（某些情况下想在定义的字符串中）py3.6版本之后的格式。f就是format的简写
一、变量
1.变量的命名与使用：
命名：字母数字与下划线，只能以字母或下划线开头
使用：不需要先声明变量以及类型、直接赋值就可以创建，在程序中随时可以修改变量的值，始终记录变量最新的值。
几个注意点：尽量使用小写字母，中间不可以使用空格，不要将关键字与函数名作为变量名。
常见报错：name ‘mesage' is not defined （忘记赋值或拼写错误）
变量的组成：①标识：表示变量所存储的内存地址。使用内置函数id（obj）获取
②类型：表示对象的数据类型，用type（obj）获取
③值：表示对象存储得到具体数据，用print（obj）输出
变量就是一个储物间的名字，用来存放值，无论变量的名字怎么改，但是值的位置是不变的。
同时给多个变量赋值：
x,y,z=1,2,3 用逗号将变量分开，变量和值一一对应。
二、字符串
在py中用引号引起来的都是字符串，没有单引号双引号的区分。灵活使用双引号单引可以避免转义字符，尽量使用双引号，避免单引号与撇号发生冲突。
1.操作字符串的相关函数：
obj.tile（）：以首字母大小写的方式显示每个单词。
obj .upper():将字符串全部改为大写
obj .lower():将字符串全部改为小写
2.在字符串中使用变量：（某些情况下想在定义的字符串中）py3.6版本之后的格式。f就是format的简写
A="zhang"
B="sanfeng"
name=f"{A} {B}"#3.6版本之后的写法
name2="{} {}".format(A,B)#3.5之前 之后的版本还能用
print(name)
print(name2)#区别就是3.5的不能直接输出，需要用变量存储3.制表符与换行符的使用
制表符\t,换行符号\n
print（i,"\n"）# 输出并换行
printf(i,end=" ")#将多行字符写在一行上并间隔一个空格
4.字符串的相关操作：
①暂时的删除字符串末尾空白：obj.rstrip（）
要想永久的删除，则需要将结果储存到一个新的变量当中。
②删除字符串开头空白：obj.lstrip（）
③删除两边空白：obj.strip()
2.4数的处理
1.整数
运算：加减乘除 类型转化操作
2.浮点数
小数点的处理
3.整数与浮点数的运算
结果总是浮点数
4.常数：全部大写字母定义
运算符
基本输入与输出
1.键盘输入：在py3.x中无论是输入数字还是字符串都被视作字符串的读取，如果想要接收数值需要进行类型转换。input的知识将输入的信息展示给用户 ，从而进行输入操作。
age=int(input("请输入数字:"))#tip=input("输入文字")2.输出print：默认情况下输出一条语句会自动换行。在后面加上，end=”分隔符“
三、列表
1.表示：[,,,]方括号，并用逗号分隔元素，元素之间可以没有任何的联系。
2.创建：直接创建，创建空列表，
a=[],直接这样定义空列表
使用list（range(10))创建数值列表
range（）函数的使用(搭配for循环)几乎可以创建任何需要的数集：
range（a）:创建一个[0-a]之间的整数序列，步长为1
range（a，b）创建一个[a-b]之间的整数序列，步长为1
range(a,b,step)创建一个[a-b]之间的整数序列，步长为step
3.列表操作：
访问列表元素：指出列表名称、在指出元素的索引,放在方括号中[]
索引：从0开始，而不是1，若要访问第n个列表元素，那么索引为n-1，索引为-1，则返回的是最后的一个列表元素，然后依次类推。
索引错误问题：List index out of range
①：索引越界,超过了原始列表索引的大小
②：列表为空时候，访问最后一个元素出错
解决方法：输出列表或打印列表长度 进行分析。
使用列表的值：通过索引调用即可。
修改：指定列表名和要修改的元素索引，再指定该元素的新值。
添加：①在末尾插入元素：append(' ')
可以将一个列表的值利用for循环插入到一个新的列表中
②在列表中插入元素:insert(' ')在任意位置插入，指定新元素的位置与值，
删除：①利用索引删除：del A[n] 可以删除任意为位置的元素，在知道索引的前提下。可以精确删除，避免重复值。
del还可以删指定范围索引的值 del A[a:b]，也可以删除整个列表。
②按值删除：A.remove(x)，删除首个符合值的元素，删除多个相同的值则需要，循环多次。删除之后也可以通过变量接着使用它的值。
③删除列表元素且继续使用该元素：x=A.pop（）弹出列表末尾元素,并用一个变量接收。也可以弹出任意位置的元素，指定元素的索引即可，
排序：①永久性排序：sort()对列表元素永久性的排序，正序排列，也可以倒叙排列 A.sort(reverse=True) 只能调用使用，A.sort(reverse=True)
②临时排序：sorted(),按特定顺序呈现且不影响原始的排列顺序。使用方式 print(sorted(A,reverse=True)) 对象写在里面。
③反转列表：A.reserse（）
打印输出：①输出列表长度：a=len(A) print(a)
遍历：利用for循环依次从列表中取出元素并与一个临时变量进行关联。变量的命名尽量与列表元素相关。for cat in cats:
常与缩进换行结合，for循环中可以有任意多行代码。 结束后添加无缩进的代码块，表示循环结束
常见错误：忘记缩进：expected an indented block
忘记需要缩进的代码行
不必要的缩进 unexpected indent
循环结束后不必要的代码
for 第一行的冒号：
数字列表的计算：min（） max() sum() 求最小 最大 求和
列表解析（简化生成列表）：将for循环和创建新元素的代码合并成一行，并自动附加新元素。
例：将10个整数的平方加入到一个列表中
A=[x**2 for x in range(1,11)]
print(A)
#等同于
A=[]
for x in range (1,11):
y=x**2
A.append(y)
print(A)
切片：处理列表中的部分元素，同样通过索引处理，在需要遍历（读取）部分元素的时候就可以在for循环中使用切片。
A[a:b]:从a开始，到b结束，不包含b
A[:b]:没有指定第一个索引，则自动从列表开头开始。
A[a:]:从a开始到列表末尾
A[a:b:c]:从a到b每间隔c个步长取一个元素
复制列表：一般是通过创建包含整个列表的切片，省去其实索引与终止索引（[:]）:有些问题不太清楚
连接和联合列表: +号 或者追个元素extend添加进去
四、元组
1.定义：有时候我们需要储存一些不可修改的元素，不可修改的列表就叫元组。是比列表更见到那的数据结构。如果需要存储的一组值在程序的整个生命周期内部不变，就可以使用元组。
区别：列表适合存储在程序运行期间可能变化的数据集，是可以修改的。
使用圆括号来进行标识，实际上是逗号是标识，定义单个元素的元组需要在后面加个逗号A=（a,）同列表一样通过索引进行访问。
2.创建:
逗号分隔序列值
tup=1,2.3
tup
>>(1,2)32.遍历元组（同列表一样）利用索引从0开始
3.修改元组变量：（不能修改元组内的值，但是可以给储存元组的变量赋值）
代码格式上的问题
五、字典
1.定义：字典是通过名字来引用值的数据结构，并且把这种数据结构称为映射，字典中的值没有特殊的顺序，都存储在一个特定的键（key）下，键可以是数字、字符串甚至元组。字典也是python中唯一内建的映射类型。字典是一系列的键值对，之间用冒号相隔，键值对之间用逗号分隔，每一个键都与一个值相关联，值可以是数、字符串、列表、字典，可以是任何python对象，用一对花括号来存储一系列键值对。
2.创建：①单行增加：使用一个花括号创建一个空字典，再分行添加各个键值对。就像一个属性集合，描述了一个对象的各个信息，或者众多对象的同一种信息。
student={}
student['name']='zhangsan'
student['age']='22'
print(student)② ：定义多个对象的同一信息：例如学生选课.使用多行来定义字典时，要在输入左花括号后按回车再缩襟四空格，指定第一个键值对，再后面加上一个逗号，回车继续输入其他键值对，最好在最后一个键值对后加个逗号。
student_subject={
'zhangsan':'python',
'lisi' :'java',
'wangwu' : 'english',
}③通过映射函数创建字典：
dictname= dict(zip(list1,list2)) #字典名称、zip()函数将多个列表或元组对应的位置的元素组合为元组，如果想获取元组利用tuple()强转,如果想获取列表，利用list()强转。
name=['zhangsan','lisi','wangwu']
age=['20','21','22']
info=dict(zip(name,age))#将key、value两个列表元素一一对应形成字典的键值对
》》{'zhangsan': '20', 'lisi': '21', 'wangwu': '22'}
info=tuple(zip(name,age)) #强转成元组形式，元组里是一个个对应元素的元组组合
》》(('zhangsan', '20'), ('lisi', '21'), ('wangwu', '22'))
info=list(zip(name,age))#转成列表的形式，列表中储存的也是一个个对应的元组组合
print(info)
》》[('zhangsan', '20'), ('lisi', '21'), ('wangwu', '22')]3.访问：
①依次指定字典名称和放在方括号内的键即可。在输出不存在的键值对的时候会报错。
print(student['name'])②使用get（）来访问值，在指定的键不存在的时候会返回一个默认值，直接调用即可。程序正常运行不会报错，而是返回一个提示信息。若没有指定第二个参数且指定键不存在，则返回None（并非错，而是所需值不存在的特殊值）
student={'name':'zhangsan','age':'18'}
print(student)
#print(student['adress'])
print(student.get('address','not fond')) #第一个参数指定键，第二个不存在时，返回信息4.修改：依次指定字典名、方括号的键和与该键相对应的新值即可。
student['name']='lisi'
5.删除：del 指定字典名和要删除的键
del student['name']6.遍历：①通过遍历可以获得字典中的全部键值对，使用items()可以获得字典的元组列表（这里字典的键值对是由元组的列表的形式存储的），然后for循环取出对应的键值对。
name=['zhangsan','lisi','wangwu']
age=['20','21','22']
a=zip((name,age))
info=dict(zip(name,age))
b=info.items()#输出的是包含一个字典的键值对的元组列表
print(b)
》》dict_items([('zhangsan', '20'), ('lisi', '21'), ('wangwu', '22')])
# 然后 通过for循环获取字典的各个元素
for item in info.items():
print(item)
》》('zhangsan', '20') #元组列表的元素
('lisi', '21')
('wangwu', '22')
#最后获取具体的键值，利用for循环依次将每个键值对赋给指定的两个变量
for key,value in info.items():#和元组的元素对应
print(key,value) #或者分开写 输出键与值
》》zhangsan 20
lisi 21
wangwu 22
-----------------------------------------------------------------------------------------
student={
'name':'zhangsan',
'age':'22',
}
for name,age in student.items():
print(f"name:{name}")
print(f"age:{age}")
》》key:name
value:zhangsan
key:age
value:22
②仅遍历键或值：
仅需要键：keys()实际上返回的是一个列表，包含字典的所有的键
student = {
'张三':'20',
'李四':'21',
'王五':'22',
}
key=student.keys() #key()实际上返回的是一个列表，包含字典的所有的键
print(key)
for name in student.keys():
print(name)
>>dict_keys(['张三', '李四', '王五'])
张三
李四
王五按特定顺序遍历字典中的所有的键：3.7之后遍历字典时候将按插入的顺序返回其中的元素。在遍历前对键的列表进行排序
for age in sorted(student.keys()):#对student.keys()的结果（是个列表）进行排序
print(age)③遍历字典中的所有值
使用方法value()来返回一个值的列表.for循环提取字典中的每个值，并将其依次付给变量，打印这些值就得到了一个列表。
for age in sorted(student.values()):#对student.values()的结果（是个列表）进行排序
print(age)
>>dict_values(['20', '21', '22'])
20
21
22④剔除重复值：使用values（）提取值没有考虑是否重复，使用集合set，会自动剔除重复数据，就可以得到一个不重复的列表。集合也是用一对花括号定义，当花括号内没有键值对时，定义的很可能是集合，不同于列表与字典，集合不会以特定的顺序储存元素。
student = {'zhangsan','lisi','wangwu','lisi'}#集合的创建
print(student)
print(type(student))
>>{'wangwu', 'lisi', 'zhangsan'}#而且不会按照特定顺序存储
<class 'set'>
#通过对包含重复元素的列表调用set（）就可以找到不含重复值的列表
for name in set(student.values()):
print(name)
7.嵌套：有时候需要将一系列字典存在列表中，或将列表作为值存在字典中，列表中嵌套字典，字典中嵌套列表，字典中嵌套字典等等，都称为嵌套
①列表中嵌套字典：一个字典包含了一个学生的信息，无法储存其他学生的信息，如何管理许多学生？创建一个学生的列表，其中每一个元素都是一个学生信息的字典，最后遍历这个列表就可以将每个学生信息打印出来,并且可以处理其中的每个字典。
student_0={'name':'zhangsan','age':20}
student_1={'name':'lisi','age':21}
student_2={'name':'wangwu','age':22}
students=[student_0,student_1,student_2]
for student in students:
print(student)
if student['name']=='zhangsan':#修改满足条件的学生信息
student['age']='21'
print(students)
>>{'name': 'zhangsan', 'age': 20}
{'name': 'lisi', 'age': 21}
{'name': 'wangwu', 'age': 22}
>>[{'name': 'zhangsan', 'age': '21'}, {'name': 'lisi', 'age': 21}, {'name': 'wangwu', 'age': 22}] #列表嵌套字典②字典中嵌套列表（值是列表）： 如何丰富学生信息，如描述一个学生的选课情况，如添加一个学生的选课信息，只用列表只能表述选课信息，如果使用字典，不仅可以看到选课信息，还可以看到学生的其他信息。
student_0={
'name':'zhangsan',
'age':'22',
'subject':['python','java','English'],
}
print(student_0['name']+"的所选课程为:")
for subject in student_0['subject']:
print(subject)
>>zhangsan的所选课程为:
python
java
English③字典中嵌套字典（值是字典）：
如在教务系统中，用户信息存储着许多学生的账号信息，用户名作为键，用户信息储存在字典中作为与用户名对应的值。为访问这些信息，遍历所有用户名和相关联的信息字典。
users={
'张三':{
'id':'00000001',
'passsword':'12345678'
},
'李四':{
'id':'00000002',
'passsword':'12345678',
},
'王五':{
'id':'00000003',
'passsword':'12345678',
},
}
print(users)#字典里套字典
#按照前面的取值方法 依次提取我们想要的信息即可.
for usersname,user_info in users.items():
print("用户名:"+usersname)
id=user_info['id']
password=user_info['passsword']
print("账号:"+id)
print("密码:"+password+"\n")
>>{'张三': {'id': '00000001', 'passsword': '12345678'}, '李四': {'id': '00000002', 'passsword': '12345678'}, '王五': {'id': '00000003', 'passsword': '12345678'}}
用户名:张三
账号:00000001
密码:12345678
用户名:李四
账号:00000002
密码:12345678
用户名:王五
账号:00000003
密码:12345678六、流程控制语句
1.程序结构：顺序结构、选择结构、循环结构、
3.条件表达式：①检查是否相等== ②检查是否不等！= ③使用and、or检查多个条件 ④检查是否包含在列表中 in 、not in
3.选择语句：常见结构 if else if-elif-else 多个elif语句 ，若要执行多个代码块，就使用一些列的if语句。常与for 循环列表结合
if 条件表达式：#注意有冒号
执行语句块 4.循环语句：
①while循环：不断运行直到指定条件不满足为止，避免无限循环要设置至少一个出口。
结合break退出循环
结合continue满足条件时返回循环的开头。
应用：用while处理列表与字典
②for循环：
③嵌套循环：
应用：
5.跳转语句
6.空语句
七、函数
1.定义：是一个带名字的代码块，用于完成具体工作，可以重复调用函数，无需反复编写完成该任务的代码（主要作用），函数中的变量属于局部变量，不能拿到外面使用，但是函数返回值可以在函数外部使用。
2.定义函数：调用的时候只需要指出函数名和圆括号括起来的必要信息，类似与定义变量，只是用函数的形式来写。
def print_message(): #函数名称以及参数
print("hello word")#函数实现的功能
greet_user()#调用
>>hello word
3.向函数传递信息：在圆括号中添加参数，可以让函数接收你指定的任何值
4.实参与形参：形参是一个变量，用于完成函数中的功能所需要的信息，实参是具体的值，调用函数时传递给函数的信息，实参中的值赋予给了函数，用形参变量进行接收。
传递实参的两个方式
①位置实参：一一对应
def print_name(username,project): #用多个形参一一接收，类似与定义变量，只是用函数的形式来写
print(username+"所选课程为"+project)#函数实现的功能
print_name('张三','英语')#传递多个实参②关键字实参：无需考虑顺序，还给出了函数调用各个值的用途
def print_name(username,project): #函数名称以及参数
print(username+"所选课程为"+project)#函数实现的功能
print_name(username='张三',project='英语')#调用，直接指定值③默认值：类似与不变的变量值，无需重复定义，在形参中直接定义，但是仍要注意位置实参。如下，每个学生都选了英语课，直接在形参中定义，避免每次在实参中的赋值。
def print_name(username,course='英语'): #函数名称以及参数
print(username+"所选课程为"+course)#函数实现的功能
print_name(username='张三')#调用
print_name(username='李四')#
>>张三所选课程为英语
李四所选课程为英语5.返回值： 并非所有的函数都是直接显示输出的，可以返回一个或者一组值，使用return可以将值返回到调用函数的代码行中，用于各种操作，调用返回值的函数时，需要提供一个变量，以便于将返回值赋值给他。
def get_name(first_name,last_name):
name=first_name+last_name#f"{'first_nmae'}{'last_name'}"}
return name
name=get_name('张','三')
print(name)
>>张三6.实参可选：实参有时可有可无，这样使用函数的时候，只在必要时候使用某一形参值，使用默认值空字符串，并放在形参列表的末尾。
例如：并非所有的人的名字都是三个字，三个字的名字我们可以设置中间的字为默认值，只在需要时候调用即可。
def get_name(first_name,last_name,mid_name=''):
if mid_name:
name=first_name+mid_name+last_name#f"{'first_nmae'}{'last_name'}"}
else:
name = first_name + last_name # f"{'first_nmae'}{'last_name'}"}
return name
name=get_name('张','三')
print(name)
name2=get_name('张','三','二')#这里的位置依旧要对应
print(name2)7.返回字典（在函数中操作字典）：函数可以返回任何类型的值，包括列表和字典等复杂的数据结构、（在函数中将形参传递的变量值进行一系列操作而已）
例如：返回一个包含学生的字典的信息
def student_message(name,age,course):
student={'name':name,'age':age,'course':course}
return student
student=student_message('张三','22','pythohn')
print(student)
>>{'name': '张三', 'age': '22', 'course': 'pythohn'}8.与while结合使用：
9.在函数中操作列表：将列表传递给函数后，函数就可以直接访问其内容，提高处理列表的效率。
例如：有一个学生的名单列表，在函数中进行读取操作.再有读取学生名单的操作，只需要调用一次这个函数即可。另外声明了一个删除学生信息的函数，以后想删除某个学生信息，只需要调用传参调用这个函数即可，类似与c语言的封装，将某一功能的代码封装在一起。
student=['zhangsan','lsii','wangwu']
def student_name(name):
for studentname in name:
print(studentname)
student_name(student)
>>zhangsan
lsii
wangwu
#定义了一个读取学生信息的函数
def student_name(name):
for studentname in name:
print(studentname)
#定义了一个删除学生信息的函数
def del_student(name_list,def_name):
if def_name in name_list:
student_list.remove(def_name)
print(student_list)
else:
return 0
student_name(student_list)#分别传参调用函数
del_student(student_list,'zhangsan')
print(student_list)
>>zhangsan
lsii
wangwu
['lsii', 'wangwu']
['lsii', 'wangwu']
10.传递任意数量的实参：预先不知道函数需要接收多少个实参，使用*形参名来定义形参，创建一个形参名的空元组，收到的所有值都放在这个元组中，然后在函数体中利用元组的相关操作即可。
def student(*course):
print(course)
student('python','java','english')
>>('python', 'java', 'english')
11.任意数量的关键字实参：例如创建用户简介，我们只知道要接收相关用户信息，但是我们不知道要接收多少个用户信息，，用位置参数接收已知的参数信息，然后利用**形参名来创建一个空字典，接收的所有键值对都放在这个字典中，我们便可以像访问其他字典一样在函数中对这个字典进行访问。
def student_info(name,age,**other_info):
other_info['name']=name
other_info['age']=age
return other_info
student=student_info('张三','22',sex='男',phone='123456')#按这种关键字实参来进行传递
print(student)
>>{'sex': '男', 'phone': '123456', 'name': '张三', 'age': '22'} #字典是没有顺序的
12.将函数储存在模块中：将函数的代码库储存在称为模块的代码库中，利用import 导入到主程序中，就可以调用模块中定义的函数，就相当于自己封装一个函数库。
1.导入模块的方法有很多种；
①导入整个模块：
首先创建模块，即创建一个只包含函数的py文件，删除其余无关的代码。创建函数模块py文件function_main如下(注意文件名后面不可以加括号)，另外注意函数的返回值是用return来返回，不要直接print：
#功能模块
def add_function(x,y):
result=x+y
return result
def minus_function(x,y):
result=x-y
return result
def multiply_function(x,y):
result=x*y
return result
def student_name(username,course): #函数名称以及参数
x=print(username+"所选课程为"+course)#函数实现的功能
return x
然后在程序中导入并调用函数即可吗
import function_main #导入模块
x=function_main.add_function(8,8) #传参，调用函数
print(x)
from function_main import minus_function
function_main.minus_function(9,6) #直接调用也可以
#如果函数的结果使用print打印输出，调用输出的话不需要二次打印，否则后面会跟着一个None,直接调用就表示打印输出即可。
function_main.minus_function(9,8)
#如果函数的返回值是用return，那么这个值可以用既可以一个变量进行接收，然后二次打印，也可以直接调用函数。因此函数的返回值尽量使用return避免出错
print(function_main.minus_function(9,6))#调用方式1
function_main.minus_function(9,8)#调用方式2②导入模块中特定的函数
from function_main import minus_function③给函数指定别名as：
from function_main import minus_function as ms#将函数名重命名，避免和重名函数混肴
④给模块指定别名：简化代码，避免重名
import function_main as fm
fm.minus_function(1,2)⑤导入模块中所有的函数（不实用）：
from function_main import *最好的做法是值导入需要使用的函数或者导入整个模块并使用句点表示法。
函数编写指南：给函数指定描述性的名称，且只使用小写字母和下划线，在函数的后面进行注解简要的描述函数功能。
九、类
1.定义：面向对象编程，编写表现现实世界中的事物或者情景的类，当一大类对象都有着通用的行为，就可以将这些行为写进类中，然后基于类创建实例化对象，使每个对象自动具备这种通用行为，根据需要还可以赋予每个对象独特的个性。类编好后大部分时间都用来根据类创建的实例，重要的任务就是修改实例的属性，可以直接修改（键值），也可以按照特定的方法修改（传参）。
2.创建和使用类：
①创建类：使用类几乎可以模拟任何事物，下面编写一个小狗的类，因为大多数小狗都具备名字年龄两项信息和蹲下、打滚两种行为，将这些共有的信息写进类中，我们将使用类来创建一个小狗的实例，而不是一个个的赋值。
class Dog:#首字母大写的名称指的是类 没有圆括号，要从空白中创建
''' 跟一句对类功能的描述性语句'''
def __init__(self,name,age):#主函数，有关的参数在这里进行，型参传参，特殊的方法，每当创建实例就会自动运行它,无法通过函数调用来使用
self.name=name #创建实例的时候会自动传入实参self，指向实例本身的引用，让实例能访问类中的属性和方法
self.age=age#以self为前缀定义的变量可以让类中的所有方法使用， 通过实例来访问。这样的变量称为属性
def sit(self):#方法1蹲下
print(self.name+'is now sitting')
def roll(self):#方法2打滚
print(self.name+'is rolling')②：根据类创建实例：
class Dog:...
dog1=Dog('zhangsan','1')#传参设置属性值，调用Dog类方法创建特定小狗的实例，并赋给变量dog1
dog2=Dog('lisi','2')#创建多个实例
print(dog1.name)#访问属性
print(dog1.age)
dog1.sit()#利用句点表示法调用函数方法
>>zhangsan
1
zhangsanis now sitting
③几种常见操作：
给属性指定默认值：
self.属性名=默认值修改属性的值：
类名.属性名=值#直接修改
def update（self,形参）：#通过方法修改属性值
self.属性值=形参
3.继承：类并非总从空白开始，要编写的类可以是另一个类的进阶版，使用继承，将获得另一个类的所有属性和方法，原有的类叫父类，新的类叫子类，子类继承了父类的所有属性和方法，而且可以定义属于自己的属性和方法。调用父类的方法_init_(),将初始化在父类_init_()方法中定义的所有属性，从而让子类包含这些属性。(下面这个例子除了ini外没有其他特有的属性与方法)
class Car:
'''父类简单的描述一个汽车'''
def __init__(self,make,modle,year):
self.make=make
self.modle=modle
self.year=year
self.odometer_reading=0
def get_descriptive_name(self,ceshi):
long_name=f"{self.year} {self.make} {self.modle}"#这里只能用这种f“”形式输出字符串。
self.ceshi=ceshi
return long_name
class ElectricCar(Car):
'''父类的属性都包含之外，电动车类的独特之处'''
def __init__(self,make,modle,year):#初始化父类的属性，不然会存留上次实例化对象传的值。
super().__init__(make,modle,year)#super()特殊的函数，让子类可以调用父类的所有方法中的属性
my_tesla=ElectricCar('tesla','modle s',2019) #只需在子类中编写特殊的方法即可。
print(my_tesla.get_descriptive_name(0))#有参数的方法调用都需要传参
print(my_tesla.ceshi)
>>2019 tesla modle s
0
②给子类定义特有的属性：在一个类继承另一个类之后，就可以添加区分子类和父类所需的新属性和方法了。
下面添加一个电车的特有属性，电瓶，和一个描述该属性的方法。我们将储存电瓶容量并编写打印电瓶描述的方法代码。
def __init__(self,make,modle,year):#初始化父类的属性，不然会存留上次实例化对象传的值。
super().__init__(make,modle,year)#super()特殊的函数，让子类可以调用父类的所有方法中的属性
self.battery_size=75#所有创建的电车实例都包含这个属性
def describle_battery(self):#电车特有的方法
print(f"这是一个{self.battery_size}kwh的电车")
my_tesla.describle_battery()
>>这是一个75kwh的电车③重写父类的方法：有些方法并不适用于子类，因此可以在子类中定义一个与父类中函数名相同的方法，
④将实例作为属性：
4.导入类：
导入单个类：
from py文件名 import 类名在一个模块中保存多个类：
从一个模块中导入多个类：
使用别名：
__name__ 属性
有时候我们想将一个 .py 文件既当作脚本，又能当作模块用，这个时候可以使用 __name__ 这个属性。
只有当文件被当作脚本执行的时候， __name__的值才会是 '__main__'，当作模块导入， test() 不会执行，但是可以使用其中的变量，所以我们可以：
import ex2
ex2.PI
>>3.1416
一旦 try 块中的内容出现了异常，那么 try 块后面的内容会被忽略，Python会寻找 except 里面有没有对应的内容，如果找到，就执行对应的块，没有则抛出这个异常。
八、读取与写入文件
1.相对路径读取文件
2.绝对路径读取文件：
file_path='C:\\Users\\yuyi\\Desktop\\ceshi.csv'#指定文件路径
with open(file_path, encoding='utf-8') as file_project:#指定打开路径和编码格式
# for line in file_project:
# print(line,end='')
contents=file_project.read()
print(contents.rstrip(),end='')
'''输出文件后有空白1行的原因 ：
每一行末尾都有一个\n换行符，print()执行一次末尾也是有个换行，
所以两个加一起看起来是多了一个空行，输出的时候改成print(line,end='')
'''
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
