注释
注释是对代码解释说明的文字，不会执行，可以增加代码的可读性
单行注释：使用#空格进行注释 快捷键ctrl/
多行注释：使用三对双引号或单引号包括起来的内容，多行注释中的内容可以换行书写
三对引号注释一般写在文件的最开始部分，或者文档注释处（函数）
文档注释
文档注释的本质还是注释，只不过书写的位置和作用比较特殊
书写位置，在函数名的下方使用三对双引号进行的注释
作用：告诉别人这个函数如何使用的，干什么的
查看，在调用的时候，将光标放到函数名上，使用快捷键Ctrl q
三种波浪线和PEP8
红色波浪线： 是代码的错误，必须处理 ，代码才能继续执行
注意：某些代码没有写完，也会出现红色波浪线
灰色波浪线：不会影响代码的正常执行，基本上所有的灰色波浪线都是PEP8造成的
PEP8：是Python代码的书写规范，如果不按照这个规范书写，会给灰色波浪线提示
在书写代码的时候注意PEP8的代码规范
可以在书写完成之后，使用快捷键Ctrl Alt L来按照PEP8的规范自动格式化代码
绿色波浪线：不影响代码的正常执行，在引号中，认为你书写的内容不是一个单词
变量
作用：用来存储数据的（在程序代码中出现的数据，想要保存下来使用，就必须使用变量）
注意：变量必须先定义后使用
定义变量
变量名 = 数据值 （可以理解为将数据值保存到变量中）
使用变量
变量定义之后，想要使用变量中的数据，直接使用变量名即可
变量名的命名规范
必须由字母 数字和下划线组成，并且不能以数字开头
不能使用Python中的关键字作为变量名
区分大小写
数据类型
数字类型
整型（int），就是整数
浮点型（float），就是小数
布尔类型（bool），只有两个值，为真True和假False
复数类型
非数字类型
字符串（str），使用引号引起来的就是字符串
列表（list）
元组（tuple）
字典（dict）
type（）函数：可以获取变量的数据类型
输入
获取用户使用键盘录入的内容
变量 = input（‘提示的信息’）
代码从上到下执行，遇到 input 函数之后，会暂停执行，等待用户的输入
在输入的过程中，遇到回车，代表本次输入结束
将输入的内容保存到等号左边的变量中，并且变量的数据类型一定是str
输出
输出使用的函数是print（）函数，将程序中的数据或者结果打印到控制台
格式化输出
在字符串指定的位置，输出变量中存储的值
在需要使用变量的地方，使用特殊符号占位
使用变量填充占位的数据
%格式化输出占位符号
%d占位，填充整型数据
%f占位，填充浮点型数据
%s占位，填充字符串数据
F-string（f字符串的格式化方法） 需要Python版本>=3.6
需要在字符串的前边加上f""或者F“”
占位符号统一变为{}
需要填充的变量写在{}中
字符串格式化的补充
字符串.format（） 可以在任意版本中使用
在需要使用变量的地方使用{}占位
'{}，{}…'.format（变量，变量，…）
类型转换
根据代码的需要，将一种数据类型转换为另一种数据类型
数据类型转换，不会改变原来数据的类型，会生成一个新的数据类型
变量 = 要转换的类型（原数据）
注意：数据原来是什么类型，要转换为什么类型
int（）将其他类型转换为int类型
可以将float类型的数字转换为整型
可以将整数类型的字符串转换为整型
float（）将其他类型转换为浮点型
可以将int类型转换为浮点型
可以将数字类型的字符串（整数类型和小数类型）转换为浮点型
str（）将其他类型转换为字符串类型
任何类型都可以使用str（）将其转换为字符串，一般都是直接加上引号
运算符
算术运算符
比较运算符
比较运算符得到都是bool类型
> < >= <=
==判断两个数是否相等
!=判断两个数是否不相等
逻辑运算符
逻辑运算符可以连接多个条件，在判断和循环中使用
and 逻辑与，和，并且
条件都需要为真，即一假为假，当第一个条件为假，后面的条件不再判断
or 逻辑或，或者，
满足一个条件即可，即一真为真，当第一个条件为真时，后面的条件不再判断
not 逻辑非，取反
赋值运算符
赋值运算符 = ，作用就是将等号右边的值保存到等号左边的变量中
复合赋值运算符（将算术运算符和赋值运算符进行结合）
运算符优先级
优先级：先算谁，再算谁。不确定优先级，就用（）
（）> ** > * / // % > + –
判断
在程序代码中需要使用 if elif else 三个关键字来实现
在代码中有判断语句，代码不会全部执行，会有一部分不会执行
if 的基本结构
基本语法
if 判断条件：
书写条件成立（真），执行的代码
注意：
if是一个关键字，和后续的判断条件之间需要一个空格
判断条件后边需要一个冒号
冒号之后会策划，代码需要缩进，一般是4个空格或一个tab键
所有在if代码下方的缩进中书写的代码，都属于if语句的代码块，判断条件为True的时候会执行
if代码块中的代码，要么都执行，要么都不执行
if代码块结束之后，代码要顶格书写（不再有缩进），表示是和if无关的代码
if-else结构
基本语法
if 判断条件：
书写条件成立（真），执行的代码
else：
书写条件不成立（假），执行的代码
注意：
else是关键字，后边需要冒号
冒号之后回车，同样需要缩进
处于else代码下方缩进中的内容，属于else的代码块
if和else的代码块，只会执行其中的一个
else需要结合if使用
if elif else结构
如果某个判断条件有多个，建议使用 if elif else 结构来实现
基本语法：
if 条件1：
条件1成立执行的代码
elif 条件2：
条件2成立执行的代码
else：
以上条件都不成立，执行的代码
注意：
elif是关键字，后边和判断条件之间需要一个空格，判断条件之后需要冒号
冒号之后回车需要缩进，处在这个缩进中的代码表示是elif的代码块
在一个if判断中，可以有多个elif
只有if的条件不成立，才会去判断elif的条件
在一个if中，如果有多个elif，只要有一个条件成立，后续的所有都不再判断
if 嵌套
if 嵌套是指在一个if（elif else）中嵌套另一个if
使用场景：判断条件存在递进关系（只有第一个条件满足了，才会判断第二个条件）
Debug调试代码
debug在代码中出现问题错误（bug），可以使用debug来调试代码，查找错误
循环
程序开发中，有三大流程（三大结构）：
顺序，代码从上到下，全部执行
分支，判断语句，代码有选择性的执行
循环，重复执行某一部分的代码
循环的作用：让指定的代码重复的执行
while 循环
基本语法结构：
1.设置循环的初始条件（计数器）
2.书写循环的判断条件
while 判断条件：
3.需要重复执行的代码
4.改变循环的初始条件（计数器）
for 循环
for 循环可以遍历容器中的数据（遍历：从容器中把数据一个一个取出）（容器：可以简单理解成盒子，盒子中可以存放很多的数据，如字符串、列表、元组、字典）
for 循环也可以称为 for 遍历
基本语法结构：
for 变量名 in 容器：
重复执行的代码
注意：
for 和 in 都是关键字
容器中有多少个数据，循环会执行多少次
每次循环，会将容器中数据取出一个保存到 in 关键字前边的变量中
指定次数的循环语法：
for 变量 in range（n）：
重复执行的代码
注意：
range（）是python中的函数，作用是可以生成[0,n)之间的整数，不包含n，一共有n个数字，即循环n次
想让for循环多少次，n就写几
变量的值，也是每次循环从[0,n)取出一个值，第一次取得是0，最后一次取得是n-1
range（a，b）作用是生成[a，b）之间的整数数字
死循环和无限循环
死循环：一般是由写代码的人不小心造成的bug，代码一直不停的运行下去
无限循环：写代码的人故意让代码无限制的去执行，代码一直不停的运行下去
无限循环的使用场景：在书写循环的时候，不确定循环要执行多少次
无限循环的使用一般会在循环中添加一个 if 判断，当 if 条件成立，使用关键字break来终止循环
break和continue
break和continue是python中的两个关键字，只能在循环中使用
break：终止循环，即代码不再执行，立即结束
continue：跳过本次循环，即本次循环剩下的代码不再执行，继续下一次循环
容器
容器也可以称为是数据序列，或者高级数据类型，也是python中的数据类型
容器中可以存放多个数据
字符串
字符串是容器，因为字符串中可以包含多个字符
使用引号（单引号、双引号、三引号和特殊引号）引起来的内容
字符串本身包含单引号，则在定义的时候不能使用单引号，可以使用双引号或转义字符\\
下标（索引）：就是指字符在字符串中的位置编号，这个编号就是下标
这个编号一般来说都是从左到右进行编号的，从0开始的（python中支持负数下标，从右到左进行编号，从-1开始，倒数第二个为-2）
下标作用：可以使用下标获取字符串中某个位置的字符
字符串的查找方法 find
语法：字符串.find（sub_str,start,end）
sub_str：要查找的子字符串
start：开始位置，从哪个下标位置开始查找，一般不写，默认为0
end：结束位置，查找到哪个下标结束，一般不写，默认是len（）
作用：在字符串中查找是否存在 sub_str 这样的子字符串
返回：
如果找到了子字符串，返回子字符串第一次出现的下标
如果没有找到，返回 -1
字符串的替换 replace
语法：字符串.replace（old_str,new_str,count)
old_str：被替换的内容
new_str：新的内容
count：替换的次数，一般不写，默认是全部替换
返回：替换之后的完整的字符串，注意（原来的字符串没有发生改变）
字符串的拆分 split
语法：字符串.split（sep，max_split）
sep：字符串按照什么进行拆分，默认为空白字符
max_split：分割次数，一般不写，全部分割
返回：将一个字符串拆分为多个，存到列表中
注意：若sep不写，想要指定分割次数，则为字符串.split（max_split=n）
字符串的连接 join
语法：需要连接的字符串.join（列表）
作用：将需要连接的字符串插入到列表中每相邻的两个数据之间，组成一个新的字符串
列表中的数据是使用逗号隔开的
列表中的数据必须都是字符串，否则会报错
切片
切片：可以获取字符串中多个字符（多个字符的下标是有规律的，等差数列）
语法：字符串[start：end：step]
start是开始位置的下标，end是结束位置的下标（注意，不能取到这个位置的字符），step是步长，等差数列的差值，所取的相邻字符下标之间的插值，默认是1，可以不写
特殊应用：步长为负数，开始和结束不写，为反转（逆置）字符串
列表
列表 list ，是使用最多的一种容器（数据类型）
列表中可以存储多个数据，每个数据之间使用逗号隔开
列表中可以存放任意类型的数据
语法：
类实例化的方式（不常用）
定义空列表：变量=list（）
直接使用[]进行定义（常用）
定义空列表：变量=[]
列表支持下标和切片
使用方法和字符串中的使用方法一致
区别：列表的切片得到的是列表
查找列表中数据下标的方法
在字符串中使用的find方法查找下标，不存在返回的是-1
在列表中没有find方法，想要查找数据的下标，使用的是index方法
语法：列表.index（数据，start，end）
使用和find一样，同时在字符串中也有index方法
区别：返回，index（）方法，找到返回第一次出现的下标，没有找到则代码直接报错
查找-判断是否存在
判断容器中某个数据是否存在可以使用 in 关键字
数据 in 容器
若存在返回True，不存在返回False
查找-统计出现的次数
统计出现的次数，使用的是 count（）方法
列表.count（数据）
返回数据出现的次数
添加数据的方法
尾部添加（最常用）
列表.append（数据） 将数据添加到列表的尾部
返回：返回的None（关键字），一般就不再使用变量来保存返回的内容，想要查看添加后的列表，需要打印的是列表
指定下标位置添加
列表.insert（下标，数据） 在指定的下标位置添加数据，如果指定的下标位置本来有数据，原数据会后移
返回：返回的None（关键字），一般就不再使用变量来保存返回的内容，想要查看添加后的列表，需要打印的是列表
列表合并
列表1.extend（列表2） 将列表2中的所有数据逐个添加到列表1的尾部
返回：返回的None（关键字），一般就不再使用变量来保存返回的内容，想要查看添加后的列表，需要打印的是列表
修改操作
想要修改列表中的指定下标位置的数据，则列表[下标] = 数据
注意：字符串中字符不能使用下标修改
删除操作
在列表中删除中间的数据，后面的数据会向前移动
根据下标删除
列表.pop（下标） 删除指定下标位置对应的数据
下标不写，默认删除最后一个数据（常用）
书写存在的下标，删除对应下标位置的数据
返回：返回删除的数据
根据数据值删除
列表.remove（数据值）
注意：只能删除第一个，如果删除的数据不存在，会报错
返回：None
清空数据（一般不用）
列表.clear（）
列表的反转（倒置）
字符串中反转导致：字符串[::-1]
列表中反转和倒置：
1.列表[::-1] 使用切片的方法，会得到一个新列表，原列表不会发生改变
2.列表.reverse（） 直接修改原列表，返回None
列表的复制
将列表中的数据复制一份，给到一个新的列表
1.使用切片 变量=列表[:]
2.使用copy方法 变量 = 列表.copy（）
列表的排序
列表的排序，一般来说都是对数字进行排序
列表.sort（） 按照升序排序，从小到大
列表.sort（reverse=True） 降序排序，从大到小
列表的嵌套
列表嵌套，列表中的内容还是列表
使用下标来确定获取的是什么类型的数据，然后确定可以继续进行什么操作
列表去重
列表去重：列表中存在多个数据，去除列表中重复的数据
方式1：遍历原列表中的数据判断在新列表中是否存在，如果不存在放入新的列表中
方式2：在python中有一种数据类型（容器），称为是集合（set），可以使用集合的特点对列表去重
集合的特点：集合中不能有重复的数据（如果有重复的数据会自动去重）
方式2的缺点：不能保证数据在原列表中出现的顺序
元组
元组：tuple，元组的特点和列表非常相似
1.元组中可以存放任意类型的数据
2.元组中可以存放任意多个数据
区别：
1.元组中的数据内容不能改变，列表中的可以改变
2.元组使用（），列表使用[ ]
应用：在函数的传参或者返回值中使用，保证数据不会被修改
定义
1.使用类实例化的方式
2.直接使用（）方式
注意：定义只有一个数据的元组时，数据后边必须有一个逗号
常用方法
由于元组中的数据不能修改，所以只有查看的方法
1.在元组中可以使用下标和切片获取数据
2.在元组中存在 index 方法
3.在元组中存在 count 方法
4.在元组中可以使用 in 方法
以上方法的使用，与列表一样
字典
1.字典dict，字典中的数据是由键（key）值（value）对组成的（键表示数据的名字，值是具体的数据）
2.在字典中一组键值对是一个数据，多个键值对之间使用逗号隔开
变量 = {key：value，key：value}
3.一个字典中的键是唯一的，不能重复的，值可以是任意数据
4.字典中的键一般都是字符串，可以是数字，不能是列表
定义
1.使用类实例化的方法
dict（）不能转列表、元组和字符串
2.直接使用{}定义
增加和修改操作
语法：字典[键] = 数据值
注意：1.如果键已经存在，就是修改数据值
2.如果键不存在，就是添加数据（即添加键值对）
删除操作
删除指定键值对：
del 字典[键]
字典.pop（键）
清空：字典.clear（）
查询-根据键获取对应的值
字典中没有下标的概念，想要获取数据值，要使用key（键）来获取
1.使用字典[键]
如果键存在，返回键对应的数据值
如果键不存在，会报错
2.使用字典.get（键，数据值）
数据值一般不写，默认是None
返回：如果键存在，返回键对应的数据值；如果不存在，返回的是括号中书写的数据值（None）
遍历
对字典的键进行遍历
for 变量 in 字典
for 变量 in 字典.keys（）
对字典的值进行遍历
for 变量 in 字典.values（）
对字典的键值对进行遍历
for 变量1，变量2 in 字典.items()
容器部分总结
1.字符串，列表，元组支持加法运算
2.字符串，列表，元组支持乘一个数字
3.len（）在容器中都可以使用
4.in 关键字在容器中都可以使用，注意，在字典中判断的是字典的键是否存在
函数
1.函数就是把具有独立功能的代码块组织为一个小模块，在需要的时候调用
2.函数，通俗理解，将多行代码写在一块，起个名字，在需要这多行代码的时候，可以直接使用这个名字来代替
3.函数的好处：减少代码的冗余，提高程序的编写效率
定义
1.将多行代码放在一块，起名字的过程，称为函数定义
2.函数必须先定义后调用
语法：
def 函数名（）：
函数中的代码
函数中的代码
注意：
def是关键字，用来定义函数的（define的缩写）
函数名需要遵守标识符的规则
处于def缩进中的代码，称为函数体
函数定义的时候，函数体中的代码不会执行，在调用的时候才会执行
调用
使用多行代码的时候，称为函数调用
语法：函数名（）
注意：
函数调用的时候会执行函数体中代码
函数调用的代码命令，要写在函数体外边
函数的嵌套调用
在一个函数定义中调用另一个函数
注意：
1.函数定义不会执行函数体中的代码
2.函数调用会执行函数体中的代码
3.函数体中代码执行结束会回到函数被调用的地方继续向下执行
函数的参数
函数参数：在函数定义的时候，使用变量代替具体的数据值（进行占位），在函数调用的时候，传递具体的数据值
函数传参的方式
位置传参：在函数调用的时候，按照形参的顺序，将实参值传递给形参
关键字传参：在函数调用的时候，指定数据值给到那个形参
混合使用：
1.关键字传参必须写在位置传参的后面
2.不要给一个形参传递多个数据值
默认参数（缺省参数）
定义方式：在函数定义的时候，给形参一个默认的数据值，这个形参就变为缺省参数，注意，缺省参数的书写要放在普通参数的后边
特点：缺省参数在函数调用的时候，可以传递实参值，也可以不传递实参值；如果传参，使用的就是传递的实参值，如果不传参，使用的就是默认值
多值参数（可变参数/不定长参数）
当在书写函数的时候，不确定参数的具体个数时，可以使用不定长参数
不定长位置参数（不定长元组参数）
1.在普通参数的前边，加上一个*，这个参数就变为不定长位置参数
2.特点：这个形参可以接收任意多个位置传参的数据
3.数据类型，形参的类型是元组
4.注意，不定长位置参数要写在普通参数的后面
5.一般写法，不定长位置参数的名字为args
不定长关键字参数（不定长字典参数）
1.书写，在普通参数的前边加上两个**，这个参数就变为不定长关键字参数
2.特点，这个形参可以接收任意多个关键字传参的数据
3.数据类型，形参的类型是字典
4.注意，不定长关键字参数要写在所有参数的最后边
5.一般写法，不定长关键字参数的名字为kwargs
完整的参数顺序
def 函数名（普通函数，*args ，缺省参数，**kwargs）：
pass
一般在使用的时候，使用1-2种，按照这个顺序挑选书写即可
注意：
1.想要将列表（元组）中的数据分别作为位置参数，进行传参，需要对列表进行拆包操作（*列表名）
2.想要将字典中的数据，作为关键字传参，需要使用**对字典进行拆包（**字典名）
函数的返回值
函数的返回值可以理解为是函数整体执行的结果是什么
什么时候需要书写返回值：函数中得到的数据在后续的代码中还要使用，这个时候就应该将这个数据作为返回值返回，以供后续使用
在函数中想要将一个数据作为返回值返回，需要使用return关键字（这个关键字只能在在函数中使用）
return作用：将数据值作为返回值返回；函数代码执行遇到return，会结束函数的执行
返回值的说明
返回多个数据值：将多个数据值组成容器进行返回，一般是元组（组包）
匿名函数
匿名函数：就是使用lambda关键字定义的函数
一般称为使用def关键字定义的函数为标准函数
匿名函数只能书写一行代码
匿名函数的返回值不需要return，一行代码（表达式）的结果就是返回值
语法结构： lambda 参数：一行代码
匿名函数一般不需要主动的调用，一般作为函数的参数使用
如果想要调用匿名函数：在定义的时候，将匿名函数的引用保存到一个变量中，使用变量进行调用
匿名函数作为函数的参数-列表中的字典排序
思路：匿名函数中的参数是列表中的数据，在sort函数内部，会调用key这个函数（将列表中每个数据作为实参传递给形参）
语法：列表名.sort（key=lambda x：x['键']）
ord（字符） 获取字符对应的ASCII值
chr（ASCII值）获取对应的字符
变量进阶
这一部分主要是了解python底层是如何处理数据的
变量的引用
1.在定义变量的时候 变量 = 数据值，python解释器会在内存中开辟两块空间
2.变量和数据都有自己的空间
3.日常简单理解，将数据保存到变量的内存中，本质是将数据的地址保存到变量对应的内存中
4.变量中存储数据地址的行为就是引用（变量引用了数据的地址，简单说就是变量中存储数据），存储的地址称为引用地址
5.可以使用id（）来获取变量中的引用地址（即数据的地址），如果两个变量的id（）获取的引用地址一样，即代表着，两个变量引用了同一个数据，是同一个数据
6.只有赋值运算符=，可以改变变量的引用（等号左边数据的引用）
7.python中数据的传递，都是传递的引用
可变类型和不可变类型
可变不可变是指：数据所在的内存是否允许修改，允许修改就是可变类型，不允许修改就是不可变类型（不使用=，变量引用的数据中的内容是否会变化，会变化是可变的，不会变化是不可变的）
可变类型：列表list、字典dict、集合set
不可变类型：int、float、bool、str、tuple
组包和拆包
组包（pack）：将多个数据值使用逗号连接，组成元组
拆包（unpack）：将容器中的数据值使用多个变量分别保存的过程，注意，变量的个数和容器中数据的个数要保持一致
局部变量和全局变量
变量：根据变量的定义位置，可以将变量分为局部变量和全局变量
局部变量
局部变量：在函数内部定义的变量，称为是局部变量
特点：
1.局部变量只能在当前函数内部使用，不能在其他函数和函数外部使用
2.在不同函数中，可以定义名字相同的局部变量，两者之间没有影响
3.生存周期（生命周期，作用范围）：在函数被调用的时候，局部变量被创建，函数调用结束，局部变量的值被销毁（删除），不能使用
函数中的局部变量的值，如果想要在函数外部使用，需要使用return关键字，将这个值进行返回
全局变量
定义位置：在函数外部定义的变量，称为是全局变量
特点：
1.可以在任何函数中读取（获取）全局变量的值
2.如果在函数中存在和全局变量名字相同的局部变量，在函数中使用的是局部变量的值（就近）
3.在函数内部想要修改全局变量的引用，需要添加global关键字，对变量进行声明为全局变量
4.生命周期：代码执行的时候被创建，代码执行结束被销毁（删除）
面向对象
面向对象是一个编程思想（写代码的套路）
面向对象和面向过程都属于写代码的方法，最终目的是为了将代码书写出来，只不过过程和思考方法不一样
面向过程关注的是具体步骤的实现，所有的功能都是自己书写；定义一个个函数，最终按照顺序调用函数
面向对象关注的是结构，谁（对象）能帮我做这件事；找一个对象，让对象去做
类和对象
面向对象的核心思想是找一个对象去帮我们处理事情
在程序代码中，对象是由类创建的
类和对象是面向对象编程思想中非常重要的两个概念
类
类是抽象的概念，对多个特征和行为相同或者相似事物的统称
泛指的，指代多个，而不是具体的一个
类的组成
类名（给这多个事物起一个名字，在代码中满足大驼峰命名法（每个单词的首字母大写））
属性（事物的特征，一般文字中的名词）
方法（事物的行为，即做什么事，一般是动词）
类的抽象（类的设计）
类的抽象其实就是找到类的类名，属性和方法
对象
具体存在的一个事物，看得见摸得着的
特指的（指代一个）
面向对象代码的书写步骤
1.定义类，在定义类之前先设计类
在python中定义类需要使用关键字 class
方法：方法的本质是在类中定义的函数，只不过第一个参数是self
对self的说明：
从函数的语法上讲，self是形参，就可以是任意的变量名，只不过习惯性将这个形参写作self
self是普通的形参，但是在调用的时候没有传递实参值，原因是，python解释器在执行代码的时候，自动的将调用这个方法的对象传递给了self，即self的本质是对象
验证，只需要确定通过哪个对象调用，对象的引用和self的引用是一样的
self是函数中的局部变量，直接创建的对象是全局变量
class 类名：
#在缩进中书写的内容，都是类中的代码
def 方法名（self）：
pass
2.创建对象，使用第一步定义的类型创建对象
创建对象是使用类名（）进行创建
一个类可以创建多个对象，只要出现类名（）就是创建一个对象，每个对象的地址是不一样的
3.通过对象调用方法
对象.方法名（）
对象的属性操作
添加属性
对象.属性名=属性值
类内部添加：在内部方法中，self是对象，即self.属性名=属性值
类外部添加：对象.属性名=属性值（一般不使用）
获取属性
对象.属性名
类内部获取：self.属性名
类外部获取：对象.属性名（一般不使用）
魔法方法
python中有一类方法，以两个下划线开头，两个下划线结尾，并且在满足某个条件的情况下，会自动调用，这类方法称为魔法方法
__init__方法
什么情况下自动调用：创建对象之后会自动调用
有什么用，用在哪：给对象添加属性的（初始化方法，构造方法）；某些代码，在每次创建对象之后都要执行，就可以将这行代码写在__init__方法
__str__方法
什么情况下自动调用：使用print（）打印对象的时候，会自动调用
有什么用，用在哪：在这个方法中一般书写对象的属性信息，即打印对象的时候想要查看什么信息，在这个方法中进行定义的；如果类中没有定义__str__方法，print（）默认输出对象的引用地址
书写注意事项：必须返回一个字符串
__del__方法（了解）
__del__方法：对象被删除销毁时，自动调用的
调用场景：程序代码运行结束，所有对象都被销毁
如果直接使用del删除对象（若对象有多个名字（多个对象引用一个对象），需要把所有的对象都删除才行）
