单行注释：#注释内容
多行注释："""注释内容"""
查看数据类型：type()
字符串变量存储字符串而不是变量就是字符串
标识符命名只允许 英文，中文，数字，下划线（数字不可以在开头）区分大小写
取整数 //
取余%
指数**
字符串定义方式：' '," ",""" """ 三引号可以定义多行
使用转义字符\解除引号效果
例如 print("\"黎明\"") 会打印"黎明"
字符串格式化
可通过占位的形式将数字或字符串拼接
格式符号转化
%s将内容转化成字符串，放入占位位置
%d将内容转化成整数，放入占位位置
%f将内容转化成浮点型，放入占位位置
例如
a=123
name="李明"
price=654.123
print("我的姓名是：%s，我的学号是：%d,我的学费是%f"%(name,a,price))
使用辅助符号"m.n"来控制数组的宽度和精度
m控制宽度，要求是数字，设置的宽度小于自身不生效
.n控制小鼠的精度，要求是数字，会惊醒小数点的四舍五入
如%5d %5.4f
字符串格式化快速书写
f"内容{变量}"来快速格式化（不理会类型，不精准化控制）
input输入
python判断句
布尔类型
python中常用的六种数据类型
类型描述
数字（number）整数（int）
浮点型（float）
复数（complex）
布尔（bool）
字符串（String）描述文本的一种数据类型
列表（list）有序的可变序列
元组（Tuple）有序的不可变序列
集合（Set）无序不重复集合
字典（Dictionary）无序Key-Value集合
True表示真1，False表示假0
for 临时变量 in 待处理的数据集
range语句
1.range（num）
获得一个从0开始，到num结束的数字序列（不包含num本身）
2.range（num1，num2）
获得一个从num1到num2的数字序列（不包含num2）
3.range（num1，num2，step）
获得一个从num1到num2的数字序列（不包含num2）
数字之间的步长为step
continue
continue关键字用于：中断本次循环，直接进入下次循环，for循环与while循环效果一样
break
break关键字用于直接结束循环
函数
len（）统计长度的函数
函数必须先定义后使用，括号内的参数可以省略
return返回结果，函数体在遇到return后就结束了，所以写在return后面的代码不会执行
函数没有返回值时也可以返回，返回结果为None，可以表示为False
使用global关键字，global 可以将函数内定义的变量声明为全局变量
python数据容器
数据容器是一种可以储存多个元素的python数据类型
list（列表），tuple（元组），str（字符串），set（集合），dict（字典）
列表
列表定义语法 ：
字面量：[元素1，元素2，元素3，。。。。]
定义变量： 变量名称=[元素1，元素2，元素3，。。。。]
定义空列表： 变量名称=[]或 变量名称=list()
嵌套列表：[[元素1，元素2，元素3],[元素1，元素2，元素3],[元素1，元素2，元素3]]
数据容器内的每一份数据都为元素
注意：列表的下标索引从0开始
正向索引：0，1，2，3 反向索引：-4，-3，-2，-1
列表的查询功能index
功能：查询指定元素在列表的下标，如果找不到会报错ValueError
语法：列表.index（元素）
修改特定位置的元素值
语法：列表[下标]=值
插入元素
语法：列表.insert（下标，元素），在指定的下标位置，插入指定的元素
追加元素
1.语法：列表.append（元素），将指定的元素追加到列表尾部
2.语法：列表.extend（其他数据容器），将其他数据容器的内容取出，依次追加到列表尾部
删除元素
语法1：del 列表[下标]
语法2：列表.pop（下标）
删除元素在列表的第一个匹配项
语法：列表.remover（元素）
清空列表内容
语法：列表.clear（）
统计某个元素在列表的数量
语法：列表.count（元素）
统计列表内元素的数量
语法：len（列表）
将列表排序
1.sorted（list）
2.list.sort（）
reverse=True表示对列表进行反转
.list.sort（reverse=True）反转排序
sort（）方法
my_list=[['a',1],['b',2],['c',3],['f',6],['d',4],['e',5],['g',7]]
print(my_list)
def a(element):#用a（）方法来确定按照谁来排序
return element[1]
my_list.sort(key=a,reverse=True)#reverse=True表示对列表进行反转
print(my_list)
元组
定义元组
定义元组字面量：（元素，元素，......，元素）
定义元组变量：（元素，元素，......，元素）
定义空元组：变量名称=（）或 变量名称=tuple（）
注意：元组只是一个数据，这个数据后要添加逗号
元组的查询功能index
功能：查询指定元素在元组的下标
语法：元组.index（元素）
统计某个元素在元组的数量
语法：元组.count（元素）
统计元组内元素的数量
语法：len（元组）
注意：元组是有序不可变数列，不可以修改neirong，元组里面的列表可以修改
将元组的Value组成一个列表
列表名=[item[key]for item in 元组名]
列表名=[]
for item in 元组名：
列表名.append(item[key])
字符串
像列表元组一样，可以通过下标访问
字符串是一个无法修改的数据容器，只可以存储字符串
字符串的替换
语法：字符串.replace（字符串1，字符串2）
功能：将字符串内部的全部：字符串1改为字符串2
注意：不是修改字符串本身，而是得到新的字符串
字符串的分割
语法：字符串.split(分割符字符串)
功能：按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中
注意：字符串本身不变，而是得到了一个列表对象
字符串的规整
语法：字符串.strip（字符串）
注意：str.strip（“123”）传入的是单个字符1，2，3.所以str中所有的1，2，3都会删除
统计某个字符在字符串的数量
语法：字符串.count（字符串）
统计字符串内字符的数量
语法：len（字符串）
序列
序列是指：内容连续，有序，可以使用下标索引的一类数据容器
有字符串，列表，元组
序列切片
语法：序列[起始下标：结束下标：步长]
表示从序列中，从指定位置开始，依次取出元素到指定位置结束，得到一个新的序列
起始下标留空表示从头开始，结束下标留空表示截至到结尾
每次跳步长-1个，步长为-1表示倒序执行
集合
不支持下标索引，可以修改，无序不重复
集合的定义
基本语法：
定义集合字面量：{元素，元素，····，元素}
定义集合变量：变量名：{元素，元素，····，元素}
定义空集合：变量名=set（）
添加新元素
语法：集合.add（元素）将指定元素添加到集合内
移除元素
语法：集合.remove（元素） 将指定元素从集合中移除
从集合中随机取一个元素
语法：集合.pop（）从集合中随机取一个元素
结果：得到一个元素的结果，同时集合本身会被修改，元素被移除
清空集合
语法：集合.clear（）清空集合
结果：集合自身被清除
取出两个集合的差集
语法：集合1.difference（集合20）
功能：取出集合1和集合2的差集（集合1有集合2没有的）
结果：得到一个集合，集合1集合2不变
消除2个集合的差集
语法：集合1.difference_update（集合2）
功能：对比集合1和集合2，在集合1内删除集合2相同的元素
结果：集合1被修改，集合2不变
两个集合合并
语法：集合1.union（集合2）
功能 ：将集合1和集合2组成新的集合
结果：得到新的集合，集合1，集合2不变
统计集合元素的数量
语法:len（集合）
集合的遍历
集合不支持while循环，可以用for循环
字典
通过字典可以实现用key取出Value的操作
字典的定义
储存的是键值对
定义字典字面量：{key：value，key：value，···key：value，}
定义字典变量：变量名={key：value，key：value，···key：value，}
定义空字典：变量名={}或 变量名=dict（）
不允许key的重复，重复会覆盖原有的数据
字典数据的获取
基于key获得Value：变量名[key]
字典的嵌套
字典的key和Value可以是任意的数据类型（key不可以是字典）
字典的常用操作
新增元素
语法：字典[key]=value
结果：字典被修改，新增了新的元素
更新元素
语法：字典[key]=value
结果：字典被修改，元素被更新
注意：字典key不可以重复，所以元素被覆盖，就是更新value值
删除元素
语法：字典.pop（key）
结果：获取指定key的value值，同时字典被修改，指定的key的数据被删除
清空字典
语法：字典.clear（）
结果：字典被修改，元素被清除
获取字典中全部的key
语法：字典.keys（）
结果：得到字典中全部的key
统计字典的元素数量
len（字典）
数据元素的通用操作
数据容器的通用统计功能
最大元素：max（容器）
最小元素：min（容器）
元素个数：len（容器）
数据容器的类型转换
转列表：list（容器）
转元组：tuple（容器）
转字符串：str（容器）
转集合：set（容器）
容器的通用排序功能
排序：sorted（容器）
降序：sorted（容器，[reverse=Ture]）
字符串比较
基于ASCLL表比较数字的码值
字符串按位比较，一位一位进行对比，只要有以为大，那么整体就大
函数的进阶
函数的多返回值
def main():
return 1,2,3
a,b,c=main()
得到a=1,b=2,c=3
函数多种传参方式
位置参数
调用函数时根据定义的参数位置来传递参数
注意：传递的参数和定义的参数的顺序及个数必须一致
关键字参数
函数调用时通过“键=值”形式传递参数
注意：函数调用时，如果有位置参数时，位置参数必须放在关键字参数的前面，但关键字参数之间不存在先后顺序
位置传递
def 函数名（*args）：
位置传递：传进的所有参数都会被args变量收集，会根据传进参数的位置合成一个元组，args是元组类型
关键字传递
def 函数名（**kwargs）：
注意：参数是“键=值”形式的形式的情况下，所有的“键=值”都会被kwargs接受，会根据”键=值“组成字典
匿名函数
函数作为参数传递
计算逻辑的传递，而非数据的传递，任何逻辑都可以自定义并作为函数传入
def test(compute):
result=compute(1,2)
print(result)
def compute(x,y):
return x+y
方法名->返回值类型：
-> 用于指定函数的返回值类型。
list[Record] 表示返回一个列表，且列表中的每个元素都必须是 Record 类型（Record 通常是自定义的类 / 数据模型，用于封装一条数据，比如你的 GDP 数据中的 “国家、GDP、年份” 组合）。
lambda匿名函数
函数定义中：
def关键字，可以定义带有名称的函数
lambda关键字，可以定义匿名函数（无名称）
有名称的函数，可以基于名称重复使用
无名称的匿名函数，只可临时使用一次
匿名函数的定义语法：
lambda 传入函数：函数体（一行代码）
lambda是关键字，表示定义匿名函数
传入函数表示匿名函数的形式参数
函数体就是函数的执行逻辑，只能写一行
def test(compute):
result=compute(1,2)
print(result)
test(lambda x,y:x+y)
面向对象
成员方法，成员变量
类的定义和使用
class 类名称： //class是关键字，表示定义类
类的属性 //定义类中的变量（成员变量）
类的行为 //定义类中的函数（成员方法）
创建类对象的语法：
对象=类名称（）
成员方法的定义
def 方法名（self，形参1，····，形参n）
方法体
self关键字是成员方法定义的时候必须要写的
1.它表示类对象自身的意思
2.当我们使用类对象调用方法的时候，self会自动被python传入
3.在方法内部，想要访问类的成员变量，必须使用self
构造方法
python类可以使用：__init__（）方法，称之为构造方法（成员变量可以省略）
在创建类对象的时候，会自动执行
在创建类对象的时候，将闯入的参数自动传入给__init__方法使用
魔术方法
构造方法在魔术方法内
__str__字符串方法
当对象需要被转换为字符串时，会输出内存地址，可以用__str__方法，控制类转换成字符串
返回值：字符串，内容：自定义
class Student:
def __init__(self, name, age):
self.name = name
self.age = age
def __str__(self):
return f"student:{self.name},age:{self.age}"
stu=Student("John", 22)
print(stu)
print(str(stu))
__lt__小于符号比较方法
class Student:
def __init__(self, name, age):
self.name = name
self.age = age
def __lt__(self,other):
return self.age<other.age
stu1=Student("John", 22)
stu2=Student("Join", 25)
print(stu1>stu2)
print(stu1<stu2)
返回值：True或False
传入参数：other，另一个对象
__le__小于等于比较符号方法
用于：<=,>=两种比较运算符上
class Student:
def __init__(self, name, age):
self.name = name
self.age = age
def __le__(self,other):
return self.age<=other.age
stu1=Student("John", 22)
stu2=Student("Join", 25)
print(stu1>=stu2)
print(stu1<=stu2)
__eq__小于等于比较符号方法
用于：==比较运算符上
class Student:
def __init__(self, name, age):
self.name = name
self.age = age
def __eq__(self,other):
return self.age==other.age
stu1=Student("John", 22)
stu2=Student("Join", 25)
print(stu1==stu2)
封装
将现实中的事物在类中描述为属性和方法
私有成员
事物的部分属性和行为不对使用者开放
私有成员变量：变量名以__开头（2个下划线）
私有成员方法：方法名以__开头（2个下划线）
私有成员的访问限制：
1.类对象无法访问私有成员
2.类中的其他成员可以访问私有成员
在同一个类中可以访问私有成员变量和私有成员方法
可以在同一个类中创建一个非私有的方法去访问私有变量和私有方法，类对象可以访问非私有方法来访问私有
继承
单继承：一个子类只能继承一个父类
class 类名（父类名）：
类内容
多继承：一个子类可以继承多个父类
class 类名（父类1，父类2，···父类n）：
类内容
pass表示空的类内容
如果有同名的成员，会以默认的继承顺序（从左到右）为优先级
复写
子类继承父类的成员属性或成员方法后，如有对其不满意，可以进行复写
即：在子类中重新定义同名的属性或方法
调用父类同名成员：
方式1：调用父类成员
使用成员变量：父类名.成员变量
使用成员方法：父类名.成员方法（self）
方式2：使用super（）调用父类成员
使用成员变量：super（）.成员变量
使用成员方法：super（）.成员方法（）
类型的注解
类型注解的语法
为变量设置类型注解
1.基础语法：变量：类型
2.在注释中进行类型注解： #type：类型
对函数进行注解
变量：类型
def 函数名（）->类型：
union类型
使用union可以定义联合类型注解
Union的使用方法：
导包：from typing import Union
使用：Union[类型，···，类型]
多态
同样的函数，传入不同的对象，得到不同的状态
抽象类
抽象类就好比定义一个标准，包含了一些抽象的方法，要求子类必须实现
抽象类：包含抽象方法的类
抽象方法：没有具体实现的方法
作用：
1.多用于做顶层设计（设计标准），以便子类做具体实现
2.也是对子类的一种软性约束，要求子类必须复写（实现）父类的一些方法
文件编码
编码就是一种规则集合，记录了内容和二进制键进行相互转换的逻辑
常用的编码为UTF-8编码
计算机只认识0和1，需要将内容翻译成0和1才能保存到计算机中，也可将计算机保存的0和1翻译成可以识别的内容
