字符串格式化——
占位类型：%s——将内容转换成字符串
%d——将内容转换成整形
%f——将内容转换成浮点型
数字精度控制——m,控制宽度，要求数字（宽度小于数字自身）——.n ,控制小数点精度，要求是数字（四舍五入）
f内容{内容}——不做精准控制，原样输出
定义一个变量num,变量内存储随机数字
import random
num=random.randint(1,10)
while循环——
while嵌套循环——
print输出不换行 ,end=’’
for循环——遍历循环——for 临时变量 in 待处理数据集：——待处理数据称为序列类型，包括字符串，列表，元组，等
for嵌套循环——
continue——跳过本次循环，进行下次循环
break——结束循环
函数————组织好的，可重复使用，特定功能的代码段
优点——提高程序的重复性，减少重复性代码，提高开发效率
return 返回值
传入参数——函数进行计算的时候，接受外部(调用时)提供的数据
函数返回值——关键字return返回给函数调用者，变量接收函数的执行结果
函数体在遇到return后就结束了，所以写在return后面的代码不会执行
None-空——return None—无返回值函数内容是None，类型是None
if中None等于False，声明无内容的变量
通过注释对函数进行解释说明——通过多行注释对函数进行解释，内容应写在函数体之前
函数嵌套调用——
变量的作用域——指变量的作用范围，哪里可以用，哪里不可用
(1)局部变量——定义在函数体内部的变量，只在函数体内部生效，临时保存数据
(2)全局变量—在函数体内外都可以使用的，在函数外定义
函数内声明变量为全局变量——关键字global——global 变量名
数据容器——一种可以容纳多份数据的数据类型，每一份数据称之为1个元素，可以是任意类型的数据
类数据容器总结对比——
数据容器的通用操作——
List(容器)转换为列表———Str(容器)转换为字符串———Tuple(容器)转换为元组———Set(容器)转换为集合———len(容器)统计容器的元素个数———max(容器)统计容器的最大元素———min(容器)统计容器的最小元素———
容器的通用排序功能sorted(容器,[reverse=True])reverse默认等于flase，等于true相当于反转———
字符串大小比较—ASCII码—一位一位进行比较
列表(list)—以[]作为标识—逗号分隔—
查找指定元素下标变量名.index(元素)——修改元素变量名[下标]=值——指定位置增加元素变量名.insert(下标,元素)——尾部追加单个元素变量名.append(元素)——尾部追加多个元素变量名.extend(其它容器数据)——删除元素1.del 变量名[下标]2.变量名.pop(下标)不仅可以删除掉还可以把元素返回出去——删除元素在列表中的第一个匹配值.remove(元素)从前到后删除找到的第一个——清空列表变量名.clear()——统计某元素在列表内的数量变量名.count(元素)——统计列表内，有多少个元素len(变量名)
遍历——while——可以自定循环条件，并自行控制——可通过条件做到无限循环，适用于任何想要循环的场景
for——不可以自定循环条件，只可以一个一个从容器取出数据——不能无限循环，遍历的容器不是无限的——适用于，遍历数据容器场景，或简单的固定次数循环场景
元组(tuple)—可容纳多个数据，不同类型，有序存储(下标索引)，允许重复存在，不可修改—一但定义就不能修改—()定义，逗号分隔—变量名=()—如果只有一个数据后面要有逗号—可通过下标索引取内容
查找指定元组的元素—元组变量名.index()—统计某个元素出现的次数—元组变量名.count(元素)—len(元组变量名)
元组内嵌套list可以增，删，改，查
元组的遍历——while——
for——
字典(dict)——
集合(set)——
字符串(str)—每一个字符就是一个元素—支持下标索引———变量名.index(元素)查找指定元素下标———字符串的替换，将字符串的全部：字符串1替换为字符串2，不是修改字符串而是得到一个新字符串新变量=变量名.replace(被替换元素，替换元素)———字符串的分割，指定分割字符串，将字符串划分为多个字符串并存入列表对象中，字符串本身不变，而是得到了一个列表对象新变量名=变量名.split(“以什么分隔例（”空格分隔“）“)———字符串的规整操作(去前后空格)—新变量=变量名.strip())去首尾空格—新变量=strip(“12”)去首尾12，按照单个字符移除——统计某个字符出现的次数—新变量=变量.count(字符串)———统计字符长度len()
序列—内容连续，有序，可使用下标索引—列表，元组，字符串均可视为序列
序列切片———序列(变量名)[起始下标:结束下标:步长]—从起始开始到结束起始为空视为从头开始(不含结束下标)留空视为结尾———步长：1时一个一个取，2时跳过一个去，n时跳过n-1取——步长为负数表示，反向取(起始下标和结束下标也要反向标记)
不会影响序列本身，而是得到一个新的序列
从头开始到最后结束—变量名[:]———从头开始步长为2—变量命[::2]
对str切片，从头开始，到最后结束——变量名[::-1]——从3开始到1结束步长-1—变量名[3:1:-1]—等同于序列反转
集合set—不支持元素的重复(自带去重复功能)，内容无序—{}定义，逗号分隔
不支持下标索引
添加新元素—集合.add(元素)———移除元素—集合.remove(元素)———随机取出一个元素—集合.pop()元素从集合中被移除———清空集合—集合.clear———消除两个集合的差集—集合1.difference(集合2)得到一个新集合，集合1和集合2不变———消除差集—集合1.difference_update(集合2)集合1被修改，集合2不变———2个集合合并为一个集合— 集合1.union(集合2)得到新集合，集合1集合2不变———统计集合元素数量len(集合)——
集合的遍历——不支持下标索引，所以不支持while
for——
字典dict—{}定义，存储的元素是一一个的：键值对—key和value可以是任意数据类型——
可以通过key值来取得Value字典[key]———
字典的嵌套——
常用操作———新增元素—字典[key]=value（key不可以重复如果重复就是更新value）———删除元素—字典.pop(key)（获得指定key的value,自定被修改，指定key数据被删除）———清空字典—字典.clear()（字典被修改，元素被清空）———获取全部的(key)—字典.keys()（得到字典中的全部key）———统计字典内的元素数量—len(字典)
循环遍历字典——由于不能下标所以所以只支持for循环，不支持while循环
函数的多返回值——按照返回值的顺序，写对应顺序的多个变量接收即可，变量之间用逗号隔开，支持不同类型的数据return
函数的多种传参方式——使用方式上有4种常见参数使用方式-位置参数-关键参数-缺省参数-不定长参数
位置参数：调用函数时根据函数定义的参数位置来传递参数
关键字参数：函数调用时通过“键=值”形式传递参数。作用：函数更加清晰，容易使用，清除了参数的顺序需求——注意：调用函数时如果有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序
缺省参数：也叫默认参数，定义函数，为参数提供默认值，调用函数时可不传该默认参数的值（注意，所有位置参数必须出现在默认参数前，包括函数定义和调用）——作用：当调用函数时没有传递参数，就会使用默认是用缺省参数对应的值
不定长参数：也叫可变参数，用于不确定调用的时候会传递多少个参数(不传参也可以)的场景——作用：当调用函数时不确定参数个数时，可以使用不定长参数
不定长参数的类型：1，位置传递，2.关键字传递
位置传递注意：传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组(tuple),args是元组类型，这就是位置传递
关键字传递注意:参数是“键=值“形式的形式的情况下，所有的”键=值“都会被kwargs接受，同时会根据”键=值“组成字典
匿名函数——
这是一种：计算逻辑的传递，而非数据的传递，任何逻辑都可以自行定义并作为函数传入
Lambda匿名函数的语法——lambda关键字，可以定义匿名函数（无名称），匿名函数只能临时使用一次——lambda 传入参数: 函数体（一行代码）——lambda是关键字，表示定义匿名函数，传入参数表示匿名函数的形式参数，函数体就是函数的执行逻辑
Def 和 lambda定义函数的功能是完全一致的，只是lambda关键字定义的函数是匿名的，无法二次使用
文件——open(name,mode,encoding)—name:要打开的目标文件名的字符串(可包含文件所在的具体路径)-mode:设置打开文件的模式-confing:编码格式推荐UTF-8
创建文件—对象=open(“文件”,w)—关闭对象.close——写入数据(write)—对象.write(“写入数据”)——读取数据(read)对象.read()——读取数据(readlines)没有参数时和read一样，额可以按照行的方式把整个文件中的内容进行一次性读取，返回一个列表，每一行的数据为一个元素——读数据(readline)按照行的方式把整个文件中的内容进行一个一个的读取—
可写(a)——对象=open(“”,a)——读数据(rb)1.对象=open(“二进制文件”，rb)2.with open(“二进制文件”，“rb”)as 对象:
关闭文件—close()
文件写入——f.write(“内容”)——内容刷新f.flush()——直接调用write内容并未真正写入文件，调用flush时，内容真正写入文件——避免频繁的操作硬盘，导致效率下降
注意——文件不存在时，w会为我们创建文件，当文件存在时，w会全部清空文件close()带有flush()功能
文件追加——f=open(“文件”，“a“)—f.write(“内容”)—f.flush
注意a模式，文件不存在会创建文件，文件存在时会在最后追加写入文件
对文件进行备份——
异常——程序检测到一个错误，python解释器无法继续执行了，出现了一些错误的提示，这就是所谓的异常，也就是常说的BUG
异常的捕获——异常处理(捕获异常)
遇到bug有两种情况:——1.整个程序因为一个BUG停止运行。——2.对BUG进行提醒，整个程序继续运行。
捕获异常的作用在于：提前假设某处会出现异常，做好提前准备，当真的出现异常的时候，可以有后续手段。
1. 如果尝试执行的代码块的异常类型和要捕获的异常类型不一致，则无法捕获异常。
2. 一般try下方只放一行尝试执行的代码。
异常的种类多种多样，如果想要不管什么类型都能捕获到，那么使用
1. except:
2. except Exception:
异常的传递性——所有函数都没有捕获异常的是时候，程序就会报错
模块(Module)——是一个python文件，里面有类，函数，变量等，我们可以拿过来用(导入模块去使用)
———模块的导入—
———自定义模块—自己写一些，个性化的模块，通过自定义模块实现，也就是自己制作一个模块
不同模块，同名的功能，如果都被导入，那么后导入的会覆盖先导入的
每个文件都可以作为一个模块，模块的名字就是文件的名字，也就是说自定义模块必须要符合标识符命名规则。
变量main——只有当程序是直接执行的的才会进入if内部，如果是被导入的，则if无法进入
变量all——如果一个模块文件中有“-all-变量”，当使用“from xxx import *”导入时，只能导入这个列表中的元素
Python包——从物理上看，就是一个文件夹，包含了一个_init_.py文件，该文件可用于包含多个模块文件
从逻辑上看，本质依然是模块
作用：模块文件越来越多，包可以帮助我们管理这些模块，作用就是包含多个模块，本质依然是模块
创建包——新建包——新建包内模块——注意:新建包后，包内部会自动创建_init_.py文件，这个文件控制着包的导入行为
导入包
方式1：import 包名.模块名 换行 包名.模块名.目标
方式2：from 包名 import * 换行 模块名.目标 ——注意:必须在_init_.py文件中添加_all_=[]控制允许导入的模块列表
安装第三方包——第三方包，极大的丰富了python的生态，提高开发效率，由于是第三方，所以没有内置，所以我们需要安装它们才可以导入使用
pip install 包名称
install -i https://pypi.tuna.stinghua.edu.cn/simple 包名称pip
数据可视化——折线图可视化
Json——轻量级的数据交互格式，按照json指定的格式去组织和封装数据
本质上是一个带有特定格式的字符串
功能——数据格式，数据传递和交互字符串格式化——
占位类型：%s——将内容转换成字符串
%d——将内容转换成整形
%f——将内容转换成浮点型
数字精度控制——m,控制宽度，要求数字（宽度小于数字自身）——.n ,控制小数点精度，要求是数字（四舍五入）
f内容{内容}——不做精准控制，原样输出
定义一个变量num,变量内存储随机数字
import random
num=random.randint(1,10)
while循环——
while嵌套循环——
print输出不换行 ,end=’’
for循环——遍历循环——for 临时变量 in 待处理数据集：——待处理数据称为序列类型，包括字符串，列表，元组，等
for嵌套循环——
continue——跳过本次循环，进行下次循环
break——结束循环
函数————组织好的，可重复使用，特定功能的代码段
优点——提高程序的重复性，减少重复性代码，提高开发效率
return 返回值
传入参数——函数进行计算的时候，接受外部(调用时)提供的数据
函数返回值——关键字return返回给函数调用者，变量接收函数的执行结果
函数体在遇到return后就结束了，所以写在return后面的代码不会执行
None-空——return None—无返回值函数内容是None，类型是None
if中None等于False，声明无内容的变量
通过注释对函数进行解释说明——通过多行注释对函数进行解释，内容应写在函数体之前
函数嵌套调用——
变量的作用域——指变量的作用范围，哪里可以用，哪里不可用
(1)局部变量——定义在函数体内部的变量，只在函数体内部生效，临时保存数据
(2)全局变量—在函数体内外都可以使用的，在函数外定义
函数内声明变量为全局变量——关键字global——global 变量名
数据容器——一种可以容纳多份数据的数据类型，每一份数据称之为1个元素，可以是任意类型的数据
类数据容器总结对比——
数据容器的通用操作——
List(容器)转换为列表———Str(容器)转换为字符串———Tuple(容器)转换为元组———Set(容器)转换为集合———len(容器)统计容器的元素个数———max(容器)统计容器的最大元素———min(容器)统计容器的最小元素———
容器的通用排序功能sorted(容器,[reverse=True])reverse默认等于flase，等于true相当于反转———
字符串大小比较—ASCII码—一位一位进行比较
列表(list)—以[]作为标识—逗号分隔—
查找指定元素下标变量名.index(元素)——修改元素变量名[下标]=值——指定位置增加元素变量名.insert(下标,元素)——尾部追加单个元素变量名.append(元素)——尾部追加多个元素变量名.extend(其它容器数据)——删除元素1.del 变量名[下标]2.变量名.pop(下标)不仅可以删除掉还可以把元素返回出去——删除元素在列表中的第一个匹配值.remove(元素)从前到后删除找到的第一个——清空列表变量名.clear()——统计某元素在列表内的数量变量名.count(元素)——统计列表内，有多少个元素len(变量名)
遍历——while——可以自定循环条件，并自行控制——可通过条件做到无限循环，适用于任何想要循环的场景
for——不可以自定循环条件，只可以一个一个从容器取出数据——不能无限循环，遍历的容器不是无限的——适用于，遍历数据容器场景，或简单的固定次数循环场景
元组(tuple)—可容纳多个数据，不同类型，有序存储(下标索引)，允许重复存在，不可修改—一但定义就不能修改—()定义，逗号分隔—变量名=()—如果只有一个数据后面要有逗号—可通过下标索引取内容
查找指定元组的元素—元组变量名.index()—统计某个元素出现的次数—元组变量名.count(元素)—len(元组变量名)
元组内嵌套list可以增，删，改，查
元组的遍历——while——
for——
字典(dict)——
集合(set)——
字符串(str)—每一个字符就是一个元素—支持下标索引———变量名.index(元素)查找指定元素下标———字符串的替换，将字符串的全部：字符串1替换为字符串2，不是修改字符串而是得到一个新字符串新变量=变量名.replace(被替换元素，替换元素)———字符串的分割，指定分割字符串，将字符串划分为多个字符串并存入列表对象中，字符串本身不变，而是得到了一个列表对象新变量名=变量名.split(“以什么分隔例（”空格分隔“）“)———字符串的规整操作(去前后空格)—新变量=变量名.strip())去首尾空格—新变量=strip(“12”)去首尾12，按照单个字符移除——统计某个字符出现的次数—新变量=变量.count(字符串)———统计字符长度len()
序列—内容连续，有序，可使用下标索引—列表，元组，字符串均可视为序列
序列切片———序列(变量名)[起始下标:结束下标:步长]—从起始开始到结束起始为空视为从头开始(不含结束下标)留空视为结尾———步长：1时一个一个取，2时跳过一个去，n时跳过n-1取——步长为负数表示，反向取(起始下标和结束下标也要反向标记)
不会影响序列本身，而是得到一个新的序列
从头开始到最后结束—变量名[:]———从头开始步长为2—变量命[::2]
对str切片，从头开始，到最后结束——变量名[::-1]——从3开始到1结束步长-1—变量名[3:1:-1]—等同于序列反转
集合set—不支持元素的重复(自带去重复功能)，内容无序—{}定义，逗号分隔
不支持下标索引
添加新元素—集合.add(元素)———移除元素—集合.remove(元素)———随机取出一个元素—集合.pop()元素从集合中被移除———清空集合—集合.clear———消除两个集合的差集—集合1.difference(集合2)得到一个新集合，集合1和集合2不变———消除差集—集合1.difference_update(集合2)集合1被修改，集合2不变———2个集合合并为一个集合— 集合1.union(集合2)得到新集合，集合1集合2不变———统计集合元素数量len(集合)——
集合的遍历——不支持下标索引，所以不支持while
for——
字典dict—{}定义，存储的元素是一一个的：键值对—key和value可以是任意数据类型——
可以通过key值来取得Value字典[key]———
字典的嵌套——
常用操作———新增元素—字典[key]=value（key不可以重复如果重复就是更新value）———删除元素—字典.pop(key)（获得指定key的value,自定被修改，指定key数据被删除）———清空字典—字典.clear()（字典被修改，元素被清空）———获取全部的(key)—字典.keys()（得到字典中的全部key）———统计字典内的元素数量—len(字典)
循环遍历字典——由于不能下标所以所以只支持for循环，不支持while循环
函数的多返回值——按照返回值的顺序，写对应顺序的多个变量接收即可，变量之间用逗号隔开，支持不同类型的数据return
函数的多种传参方式——使用方式上有4种常见参数使用方式-位置参数-关键参数-缺省参数-不定长参数
位置参数：调用函数时根据函数定义的参数位置来传递参数
关键字参数：函数调用时通过“键=值”形式传递参数。作用：函数更加清晰，容易使用，清除了参数的顺序需求——注意：调用函数时如果有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序
缺省参数：也叫默认参数，定义函数，为参数提供默认值，调用函数时可不传该默认参数的值（注意，所有位置参数必须出现在默认参数前，包括函数定义和调用）——作用：当调用函数时没有传递参数，就会使用默认是用缺省参数对应的值
不定长参数：也叫可变参数，用于不确定调用的时候会传递多少个参数(不传参也可以)的场景——作用：当调用函数时不确定参数个数时，可以使用不定长参数
不定长参数的类型：1，位置传递，2.关键字传递
位置传递注意：传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组(tuple),args是元组类型，这就是位置传递
关键字传递注意:参数是“键=值“形式的形式的情况下，所有的”键=值“都会被kwargs接受，同时会根据”键=值“组成字典
匿名函数——
这是一种：计算逻辑的传递，而非数据的传递，任何逻辑都可以自行定义并作为函数传入
Lambda匿名函数的语法——lambda关键字，可以定义匿名函数（无名称），匿名函数只能临时使用一次——lambda 传入参数: 函数体（一行代码）——lambda是关键字，表示定义匿名函数，传入参数表示匿名函数的形式参数，函数体就是函数的执行逻辑
Def 和 lambda定义函数的功能是完全一致的，只是lambda关键字定义的函数是匿名的，无法二次使用
文件——open(name,mode,encoding)—name:要打开的目标文件名的字符串(可包含文件所在的具体路径)-mode:设置打开文件的模式-confing:编码格式推荐UTF-8
创建文件—对象=open(“文件”,w)—关闭对象.close——写入数据(write)—对象.write(“写入数据”)——读取数据(read)对象.read()——读取数据(readlines)没有参数时和read一样，额可以按照行的方式把整个文件中的内容进行一次性读取，返回一个列表，每一行的数据为一个元素——读数据(readline)按照行的方式把整个文件中的内容进行一个一个的读取—
可写(a)——对象=open(“”,a)——读数据(rb)1.对象=open(“二进制文件”，rb)2.with open(“二进制文件”，“rb”)as 对象:
关闭文件—close()
文件写入——f.write(“内容”)——内容刷新f.flush()——直接调用write内容并未真正写入文件，调用flush时，内容真正写入文件——避免频繁的操作硬盘，导致效率下降
注意——文件不存在时，w会为我们创建文件，当文件存在时，w会全部清空文件close()带有flush()功能
文件追加——f=open(“文件”，“a“)—f.write(“内容”)—f.flush
注意a模式，文件不存在会创建文件，文件存在时会在最后追加写入文件
对文件进行备份——
异常——程序检测到一个错误，python解释器无法继续执行了，出现了一些错误的提示，这就是所谓的异常，也就是常说的BUG
异常的捕获——异常处理(捕获异常)
遇到bug有两种情况:——1.整个程序因为一个BUG停止运行。——2.对BUG进行提醒，整个程序继续运行。
捕获异常的作用在于：提前假设某处会出现异常，做好提前准备，当真的出现异常的时候，可以有后续手段。
1. 如果尝试执行的代码块的异常类型和要捕获的异常类型不一致，则无法捕获异常。
2. 一般try下方只放一行尝试执行的代码。
异常的种类多种多样，如果想要不管什么类型都能捕获到，那么使用
1. except:
2. except Exception:
异常的传递性——所有函数都没有捕获异常的是时候，程序就会报错
模块(Module)——是一个python文件，里面有类，函数，变量等，我们可以拿过来用(导入模块去使用)
———模块的导入—
———自定义模块—自己写一些，个性化的模块，通过自定义模块实现，也就是自己制作一个模块
不同模块，同名的功能，如果都被导入，那么后导入的会覆盖先导入的
每个文件都可以作为一个模块，模块的名字就是文件的名字，也就是说自定义模块必须要符合标识符命名规则。
变量main——只有当程序是直接执行的的才会进入if内部，如果是被导入的，则if无法进入
变量all——如果一个模块文件中有“-all-变量”，当使用“from xxx import *”导入时，只能导入这个列表中的元素
Python包——从物理上看，就是一个文件夹，包含了一个_init_.py文件，该文件可用于包含多个模块文件
从逻辑上看，本质依然是模块
作用：模块文件越来越多，包可以帮助我们管理这些模块，作用就是包含多个模块，本质依然是模块
创建包——新建包——新建包内模块——注意:新建包后，包内部会自动创建_init_.py文件，这个文件控制着包的导入行为
导入包
方式1：import 包名.模块名 换行 包名.模块名.目标
方式2：from 包名 import * 换行 模块名.目标 ——注意:必须在_init_.py文件中添加_all_=[]控制允许导入的模块列表
安装第三方包——第三方包，极大的丰富了python的生态，提高开发效率，由于是第三方，所以没有内置，所以我们需要安装它们才可以导入使用
pip install 包名称
install -i https://pypi.tuna.stinghua.edu.cn/simple 包名称pip
数据可视化——折线图可视化
Json——轻量级的数据交互格式，按照json指定的格式去组织和封装数据
本质上是一个带有特定格式的字符串
功能——数据格式，数据传递和交互字符串格式化——
占位类型：%s——将内容转换成字符串
%d——将内容转换成整形
%f——将内容转换成浮点型
数字精度控制——m,控制宽度，要求数字（宽度小于数字自身）——.n ,控制小数点精度，要求是数字（四舍五入）
f内容{内容}——不做精准控制，原样输出
定义一个变量num,变量内存储随机数字
import random
num=random.randint(1,10)
while循环——
while嵌套循环——
print输出不换行 ,end=’’
for循环——遍历循环——for 临时变量 in 待处理数据集：——待处理数据称为序列类型，包括字符串，列表，元组，等
for嵌套循环——
continue——跳过本次循环，进行下次循环
break——结束循环
函数————组织好的，可重复使用，特定功能的代码段
优点——提高程序的重复性，减少重复性代码，提高开发效率
return 返回值
传入参数——函数进行计算的时候，接受外部(调用时)提供的数据
函数返回值——关键字return返回给函数调用者，变量接收函数的执行结果
函数体在遇到return后就结束了，所以写在return后面的代码不会执行
None-空——return None—无返回值函数内容是None，类型是None
if中None等于False，声明无内容的变量
通过注释对函数进行解释说明——通过多行注释对函数进行解释，内容应写在函数体之前
函数嵌套调用——
变量的作用域——指变量的作用范围，哪里可以用，哪里不可用
(1)局部变量——定义在函数体内部的变量，只在函数体内部生效，临时保存数据
(2)全局变量—在函数体内外都可以使用的，在函数外定义
函数内声明变量为全局变量——关键字global——global 变量名
数据容器——一种可以容纳多份数据的数据类型，每一份数据称之为1个元素，可以是任意类型的数据
类数据容器总结对比——
数据容器的通用操作——
List(容器)转换为列表———Str(容器)转换为字符串———Tuple(容器)转换为元组———Set(容器)转换为集合———len(容器)统计容器的元素个数———max(容器)统计容器的最大元素———min(容器)统计容器的最小元素———
容器的通用排序功能sorted(容器,[reverse=True])reverse默认等于flase，等于true相当于反转———
字符串大小比较—ASCII码—一位一位进行比较
列表(list)—以[]作为标识—逗号分隔—
查找指定元素下标变量名.index(元素)——修改元素变量名[下标]=值——指定位置增加元素变量名.insert(下标,元素)——尾部追加单个元素变量名.append(元素)——尾部追加多个元素变量名.extend(其它容器数据)——删除元素1.del 变量名[下标]2.变量名.pop(下标)不仅可以删除掉还可以把元素返回出去——删除元素在列表中的第一个匹配值.remove(元素)从前到后删除找到的第一个——清空列表变量名.clear()——统计某元素在列表内的数量变量名.count(元素)——统计列表内，有多少个元素len(变量名)
遍历——while——可以自定循环条件，并自行控制——可通过条件做到无限循环，适用于任何想要循环的场景
for——不可以自定循环条件，只可以一个一个从容器取出数据——不能无限循环，遍历的容器不是无限的——适用于，遍历数据容器场景，或简单的固定次数循环场景
元组(tuple)—可容纳多个数据，不同类型，有序存储(下标索引)，允许重复存在，不可修改—一但定义就不能修改—()定义，逗号分隔—变量名=()—如果只有一个数据后面要有逗号—可通过下标索引取内容
查找指定元组的元素—元组变量名.index()—统计某个元素出现的次数—元组变量名.count(元素)—len(元组变量名)
元组内嵌套list可以增，删，改，查
元组的遍历——while——
for——
字典(dict)——
集合(set)——
字符串(str)—每一个字符就是一个元素—支持下标索引———变量名.index(元素)查找指定元素下标———字符串的替换，将字符串的全部：字符串1替换为字符串2，不是修改字符串而是得到一个新字符串新变量=变量名.replace(被替换元素，替换元素)———字符串的分割，指定分割字符串，将字符串划分为多个字符串并存入列表对象中，字符串本身不变，而是得到了一个列表对象新变量名=变量名.split(“以什么分隔例（”空格分隔“）“)———字符串的规整操作(去前后空格)—新变量=变量名.strip())去首尾空格—新变量=strip(“12”)去首尾12，按照单个字符移除——统计某个字符出现的次数—新变量=变量.count(字符串)———统计字符长度len()
序列—内容连续，有序，可使用下标索引—列表，元组，字符串均可视为序列
序列切片———序列(变量名)[起始下标:结束下标:步长]—从起始开始到结束起始为空视为从头开始(不含结束下标)留空视为结尾———步长：1时一个一个取，2时跳过一个去，n时跳过n-1取——步长为负数表示，反向取(起始下标和结束下标也要反向标记)
不会影响序列本身，而是得到一个新的序列
从头开始到最后结束—变量名[:]———从头开始步长为2—变量命[::2]
对str切片，从头开始，到最后结束——变量名[::-1]——从3开始到1结束步长-1—变量名[3:1:-1]—等同于序列反转
集合set—不支持元素的重复(自带去重复功能)，内容无序—{}定义，逗号分隔
不支持下标索引
添加新元素—集合.add(元素)———移除元素—集合.remove(元素)———随机取出一个元素—集合.pop()元素从集合中被移除———清空集合—集合.clear———消除两个集合的差集—集合1.difference(集合2)得到一个新集合，集合1和集合2不变———消除差集—集合1.difference_update(集合2)集合1被修改，集合2不变———2个集合合并为一个集合— 集合1.union(集合2)得到新集合，集合1集合2不变———统计集合元素数量len(集合)——
集合的遍历——不支持下标索引，所以不支持while
for——
字典dict—{}定义，存储的元素是一一个的：键值对—key和value可以是任意数据类型——
可以通过key值来取得Value字典[key]———
字典的嵌套——
常用操作———新增元素—字典[key]=value（key不可以重复如果重复就是更新value）———删除元素—字典.pop(key)（获得指定key的value,自定被修改，指定key数据被删除）———清空字典—字典.clear()（字典被修改，元素被清空）———获取全部的(key)—字典.keys()（得到字典中的全部key）———统计字典内的元素数量—len(字典)
循环遍历字典——由于不能下标所以所以只支持for循环，不支持while循环
函数的多返回值——按照返回值的顺序，写对应顺序的多个变量接收即可，变量之间用逗号隔开，支持不同类型的数据return
函数的多种传参方式——使用方式上有4种常见参数使用方式-位置参数-关键参数-缺省参数-不定长参数
位置参数：调用函数时根据函数定义的参数位置来传递参数
关键字参数：函数调用时通过“键=值”形式传递参数。作用：函数更加清晰，容易使用，清除了参数的顺序需求——注意：调用函数时如果有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序
缺省参数：也叫默认参数，定义函数，为参数提供默认值，调用函数时可不传该默认参数的值（注意，所有位置参数必须出现在默认参数前，包括函数定义和调用）——作用：当调用函数时没有传递参数，就会使用默认是用缺省参数对应的值
不定长参数：也叫可变参数，用于不确定调用的时候会传递多少个参数(不传参也可以)的场景——作用：当调用函数时不确定参数个数时，可以使用不定长参数
不定长参数的类型：1，位置传递，2.关键字传递
位置传递注意：传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组(tuple),args是元组类型，这就是位置传递
关键字传递注意:参数是“键=值“形式的形式的情况下，所有的”键=值“都会被kwargs接受，同时会根据”键=值“组成字典
匿名函数——
这是一种：计算逻辑的传递，而非数据的传递，任何逻辑都可以自行定义并作为函数传入
Lambda匿名函数的语法——lambda关键字，可以定义匿名函数（无名称），匿名函数只能临时使用一次——lambda 传入参数: 函数体（一行代码）——lambda是关键字，表示定义匿名函数，传入参数表示匿名函数的形式参数，函数体就是函数的执行逻辑
Def 和 lambda定义函数的功能是完全一致的，只是lambda关键字定义的函数是匿名的，无法二次使用
文件——open(name,mode,encoding)—name:要打开的目标文件名的字符串(可包含文件所在的具体路径)-mode:设置打开文件的模式-confing:编码格式推荐UTF-8
创建文件—对象=open(“文件”,w)—关闭对象.close——写入数据(write)—对象.write(“写入数据”)——读取数据(read)对象.read()——读取数据(readlines)没有参数时和read一样，额可以按照行的方式把整个文件中的内容进行一次性读取，返回一个列表，每一行的数据为一个元素——读数据(readline)按照行的方式把整个文件中的内容进行一个一个的读取—
可写(a)——对象=open(“”,a)——读数据(rb)1.对象=open(“二进制文件”，rb)2.with open(“二进制文件”，“rb”)as 对象:
关闭文件—close()
文件写入——f.write(“内容”)——内容刷新f.flush()——直接调用write内容并未真正写入文件，调用flush时，内容真正写入文件——避免频繁的操作硬盘，导致效率下降
注意——文件不存在时，w会为我们创建文件，当文件存在时，w会全部清空文件close()带有flush()功能
文件追加——f=open(“文件”，“a“)—f.write(“内容”)—f.flush
注意a模式，文件不存在会创建文件，文件存在时会在最后追加写入文件
对文件进行备份——
异常——程序检测到一个错误，python解释器无法继续执行了，出现了一些错误的提示，这就是所谓的异常，也就是常说的BUG
异常的捕获——异常处理(捕获异常)
遇到bug有两种情况:——1.整个程序因为一个BUG停止运行。——2.对BUG进行提醒，整个程序继续运行。
捕获异常的作用在于：提前假设某处会出现异常，做好提前准备，当真的出现异常的时候，可以有后续手段。
1. 如果尝试执行的代码块的异常类型和要捕获的异常类型不一致，则无法捕获异常。
2. 一般try下方只放一行尝试执行的代码。
异常的种类多种多样，如果想要不管什么类型都能捕获到，那么使用
1. except:
2. except Exception:
异常的传递性——所有函数都没有捕获异常的是时候，程序就会报错
模块(Module)——是一个python文件，里面有类，函数，变量等，我们可以拿过来用(导入模块去使用)
———模块的导入—
———自定义模块—自己写一些，个性化的模块，通过自定义模块实现，也就是自己制作一个模块
不同模块，同名的功能，如果都被导入，那么后导入的会覆盖先导入的
每个文件都可以作为一个模块，模块的名字就是文件的名字，也就是说自定义模块必须要符合标识符命名规则。
变量main——只有当程序是直接执行的的才会进入if内部，如果是被导入的，则if无法进入
变量all——如果一个模块文件中有“-all-变量”，当使用“from xxx import *”导入时，只能导入这个列表中的元素
Python包——从物理上看，就是一个文件夹，包含了一个_init_.py文件，该文件可用于包含多个模块文件
从逻辑上看，本质依然是模块
作用：模块文件越来越多，包可以帮助我们管理这些模块，作用就是包含多个模块，本质依然是模块
创建包——新建包——新建包内模块——注意:新建包后，包内部会自动创建_init_.py文件，这个文件控制着包的导入行为
导入包
方式1：import 包名.模块名 换行 包名.模块名.目标
方式2：from 包名 import * 换行 模块名.目标 ——注意:必须在_init_.py文件中添加_all_=[]控制允许导入的模块列表
安装第三方包——第三方包，极大的丰富了python的生态，提高开发效率，由于是第三方，所以没有内置，所以我们需要安装它们才可以导入使用
pip install 包名称
install -i https://pypi.tuna.stinghua.edu.cn/simple 包名称pip
数据可视化——折线图可视化
Json——轻量级的数据交互格式，按照json指定的格式去组织和封装数据
本质上是一个带有特定格式的字符串
功能——数据格式，数据传递和交互字符串格式化——
占位类型：%s——将内容转换成字符串
%d——将内容转换成整形
%f——将内容转换成浮点型
数字精度控制——m,控制宽度，要求数字（宽度小于数字自身）——.n ,控制小数点精度，要求是数字（四舍五入）
f内容{内容}——不做精准控制，原样输出
定义一个变量num,变量内存储随机数字
import random
num=random.randint(1,10)
while循环——
while嵌套循环——
print输出不换行 ,end=’’
for循环——遍历循环——for 临时变量 in 待处理数据集：——待处理数据称为序列类型，包括字符串，列表，元组，等
for嵌套循环——
continue——跳过本次循环，进行下次循环
break——结束循环
函数————组织好的，可重复使用，特定功能的代码段
优点——提高程序的重复性，减少重复性代码，提高开发效率
return 返回值
传入参数——函数进行计算的时候，接受外部(调用时)提供的数据
函数返回值——关键字return返回给函数调用者，变量接收函数的执行结果
函数体在遇到return后就结束了，所以写在return后面的代码不会执行
None-空——return None—无返回值函数内容是None，类型是None
if中None等于False，声明无内容的变量
通过注释对函数进行解释说明——通过多行注释对函数进行解释，内容应写在函数体之前
函数嵌套调用——
变量的作用域——指变量的作用范围，哪里可以用，哪里不可用
(1)局部变量——定义在函数体内部的变量，只在函数体内部生效，临时保存数据
(2)全局变量—在函数体内外都可以使用的，在函数外定义
函数内声明变量为全局变量——关键字global——global 变量名
数据容器——一种可以容纳多份数据的数据类型，每一份数据称之为1个元素，可以是任意类型的数据
类数据容器总结对比——
数据容器的通用操作——
List(容器)转换为列表———Str(容器)转换为字符串———Tuple(容器)转换为元组———Set(容器)转换为集合———len(容器)统计容器的元素个数———max(容器)统计容器的最大元素———min(容器)统计容器的最小元素———
容器的通用排序功能sorted(容器,[reverse=True])reverse默认等于flase，等于true相当于反转———
字符串大小比较—ASCII码—一位一位进行比较
列表(list)—以[]作为标识—逗号分隔—
查找指定元素下标变量名.index(元素)——修改元素变量名[下标]=值——指定位置增加元素变量名.insert(下标,元素)——尾部追加单个元素变量名.append(元素)——尾部追加多个元素变量名.extend(其它容器数据)——删除元素1.del 变量名[下标]2.变量名.pop(下标)不仅可以删除掉还可以把元素返回出去——删除元素在列表中的第一个匹配值.remove(元素)从前到后删除找到的第一个——清空列表变量名.clear()——统计某元素在列表内的数量变量名.count(元素)——统计列表内，有多少个元素len(变量名)
遍历——while——可以自定循环条件，并自行控制——可通过条件做到无限循环，适用于任何想要循环的场景
for——不可以自定循环条件，只可以一个一个从容器取出数据——不能无限循环，遍历的容器不是无限的——适用于，遍历数据容器场景，或简单的固定次数循环场景
元组(tuple)—可容纳多个数据，不同类型，有序存储(下标索引)，允许重复存在，不可修改—一但定义就不能修改—()定义，逗号分隔—变量名=()—如果只有一个数据后面要有逗号—可通过下标索引取内容
查找指定元组的元素—元组变量名.index()—统计某个元素出现的次数—元组变量名.count(元素)—len(元组变量名)
元组内嵌套list可以增，删，改，查
元组的遍历——while——
for——
字典(dict)——
集合(set)——
字符串(str)—每一个字符就是一个元素—支持下标索引———变量名.index(元素)查找指定元素下标———字符串的替换，将字符串的全部：字符串1替换为字符串2，不是修改字符串而是得到一个新字符串新变量=变量名.replace(被替换元素，替换元素)———字符串的分割，指定分割字符串，将字符串划分为多个字符串并存入列表对象中，字符串本身不变，而是得到了一个列表对象新变量名=变量名.split(“以什么分隔例（”空格分隔“）“)———字符串的规整操作(去前后空格)—新变量=变量名.strip())去首尾空格—新变量=strip(“12”)去首尾12，按照单个字符移除——统计某个字符出现的次数—新变量=变量.count(字符串)———统计字符长度len()
序列—内容连续，有序，可使用下标索引—列表，元组，字符串均可视为序列
序列切片———序列(变量名)[起始下标:结束下标:步长]—从起始开始到结束起始为空视为从头开始(不含结束下标)留空视为结尾———步长：1时一个一个取，2时跳过一个去，n时跳过n-1取——步长为负数表示，反向取(起始下标和结束下标也要反向标记)
不会影响序列本身，而是得到一个新的序列
从头开始到最后结束—变量名[:]———从头开始步长为2—变量命[::2]
对str切片，从头开始，到最后结束——变量名[::-1]——从3开始到1结束步长-1—变量名[3:1:-1]—等同于序列反转
集合set—不支持元素的重复(自带去重复功能)，内容无序—{}定义，逗号分隔
不支持下标索引
添加新元素—集合.add(元素)———移除元素—集合.remove(元素)———随机取出一个元素—集合.pop()元素从集合中被移除———清空集合—集合.clear———消除两个集合的差集—集合1.difference(集合2)得到一个新集合，集合1和集合2不变———消除差集—集合1.difference_update(集合2)集合1被修改，集合2不变———2个集合合并为一个集合— 集合1.union(集合2)得到新集合，集合1集合2不变———统计集合元素数量len(集合)——
集合的遍历——不支持下标索引，所以不支持while
for——
字典dict—{}定义，存储的元素是一一个的：键值对—key和value可以是任意数据类型——
可以通过key值来取得Value字典[key]———
字典的嵌套——
常用操作———新增元素—字典[key]=value（key不可以重复如果重复就是更新value）———删除元素—字典.pop(key)（获得指定key的value,自定被修改，指定key数据被删除）———清空字典—字典.clear()（字典被修改，元素被清空）———获取全部的(key)—字典.keys()（得到字典中的全部key）———统计字典内的元素数量—len(字典)
循环遍历字典——由于不能下标所以所以只支持for循环，不支持while循环
函数的多返回值——按照返回值的顺序，写对应顺序的多个变量接收即可，变量之间用逗号隔开，支持不同类型的数据return
函数的多种传参方式——使用方式上有4种常见参数使用方式-位置参数-关键参数-缺省参数-不定长参数
位置参数：调用函数时根据函数定义的参数位置来传递参数
关键字参数：函数调用时通过“键=值”形式传递参数。作用：函数更加清晰，容易使用，清除了参数的顺序需求——注意：调用函数时如果有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序
缺省参数：也叫默认参数，定义函数，为参数提供默认值，调用函数时可不传该默认参数的值（注意，所有位置参数必须出现在默认参数前，包括函数定义和调用）——作用：当调用函数时没有传递参数，就会使用默认是用缺省参数对应的值
不定长参数：也叫可变参数，用于不确定调用的时候会传递多少个参数(不传参也可以)的场景——作用：当调用函数时不确定参数个数时，可以使用不定长参数
不定长参数的类型：1，位置传递，2.关键字传递
位置传递注意：传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组(tuple),args是元组类型，这就是位置传递
关键字传递注意:参数是“键=值“形式的形式的情况下，所有的”键=值“都会被kwargs接受，同时会根据”键=值“组成字典
匿名函数——
这是一种：计算逻辑的传递，而非数据的传递，任何逻辑都可以自行定义并作为函数传入
Lambda匿名函数的语法——lambda关键字，可以定义匿名函数（无名称），匿名函数只能临时使用一次——lambda 传入参数: 函数体（一行代码）——lambda是关键字，表示定义匿名函数，传入参数表示匿名函数的形式参数，函数体就是函数的执行逻辑
Def 和 lambda定义函数的功能是完全一致的，只是lambda关键字定义的函数是匿名的，无法二次使用
文件——open(name,mode,encoding)—name:要打开的目标文件名的字符串(可包含文件所在的具体路径)-mode:设置打开文件的模式-confing:编码格式推荐UTF-8
创建文件—对象=open(“文件”,w)—关闭对象.close——写入数据(write)—对象.write(“写入数据”)——读取数据(read)对象.read()——读取数据(readlines)没有参数时和read一样，额可以按照行的方式把整个文件中的内容进行一次性读取，返回一个列表，每一行的数据为一个元素——读数据(readline)按照行的方式把整个文件中的内容进行一个一个的读取—
可写(a)——对象=open(“”,a)——读数据(rb)1.对象=open(“二进制文件”，rb)2.with open(“二进制文件”，“rb”)as 对象:
关闭文件—close()
文件写入——f.write(“内容”)——内容刷新f.flush()——直接调用write内容并未真正写入文件，调用flush时，内容真正写入文件——避免频繁的操作硬盘，导致效率下降
注意——文件不存在时，w会为我们创建文件，当文件存在时，w会全部清空文件close()带有flush()功能
文件追加——f=open(“文件”，“a“)—f.write(“内容”)—f.flush
注意a模式，文件不存在会创建文件，文件存在时会在最后追加写入文件
对文件进行备份——
异常——程序检测到一个错误，python解释器无法继续执行了，出现了一些错误的提示，这就是所谓的异常，也就是常说的BUG
异常的捕获——异常处理(捕获异常)
遇到bug有两种情况:——1.整个程序因为一个BUG停止运行。——2.对BUG进行提醒，整个程序继续运行。
捕获异常的作用在于：提前假设某处会出现异常，做好提前准备，当真的出现异常的时候，可以有后续手段。
1. 如果尝试执行的代码块的异常类型和要捕获的异常类型不一致，则无法捕获异常。
2. 一般try下方只放一行尝试执行的代码。
异常的种类多种多样，如果想要不管什么类型都能捕获到，那么使用
1. except:
2. except Exception:
异常的传递性——所有函数都没有捕获异常的是时候，程序就会报错
模块(Module)——是一个python文件，里面有类，函数，变量等，我们可以拿过来用(导入模块去使用)
———模块的导入—
———自定义模块—自己写一些，个性化的模块，通过自定义模块实现，也就是自己制作一个模块
不同模块，同名的功能，如果都被导入，那么后导入的会覆盖先导入的
每个文件都可以作为一个模块，模块的名字就是文件的名字，也就是说自定义模块必须要符合标识符命名规则。
变量main——只有当程序是直接执行的的才会进入if内部，如果是被导入的，则if无法进入
变量all——如果一个模块文件中有“-all-变量”，当使用“from xxx import *”导入时，只能导入这个列表中的元素
Python包——从物理上看，就是一个文件夹，包含了一个_init_.py文件，该文件可用于包含多个模块文件
从逻辑上看，本质依然是模块
作用：模块文件越来越多，包可以帮助我们管理这些模块，作用就是包含多个模块，本质依然是模块
创建包——新建包——新建包内模块——注意:新建包后，包内部会自动创建_init_.py文件，这个文件控制着包的导入行为
导入包
方式1：import 包名.模块名 换行 包名.模块名.目标
方式2：from 包名 import * 换行 模块名.目标 ——注意:必须在_init_.py文件中添加_all_=[]控制允许导入的模块列表
安装第三方包——第三方包，极大的丰富了python的生态，提高开发效率，由于是第三方，所以没有内置，所以我们需要安装它们才可以导入使用
pip install 包名称
install -i https://pypi.tuna.stinghua.edu.cn/simple 包名称pip
数据可视化——折线图可视化
Json——轻量级的数据交互格式，按照json指定的格式去组织和封装数据
本质上是一个带有特定格式的字符串
功能——数据格式，数据传递和交互字符串格式化——
占位类型：%s——将内容转换成字符串
%d——将内容转换成整形
%f——将内容转换成浮点型
数字精度控制——m,控制宽度，要求数字（宽度小于数字自身）——.n ,控制小数点精度，要求是数字（四舍五入）
f内容{内容}——不做精准控制，原样输出
定义一个变量num,变量内存储随机数字
import random
num=random.randint(1,10)
while循环——
while嵌套循环——
print输出不换行 ,end=’’
for循环——遍历循环——for 临时变量 in 待处理数据集：——待处理数据称为序列类型，包括字符串，列表，元组，等
for嵌套循环——
continue——跳过本次循环，进行下次循环
break——结束循环
函数————组织好的，可重复使用，特定功能的代码段
优点——提高程序的重复性，减少重复性代码，提高开发效率
return 返回值
传入参数——函数进行计算的时候，接受外部(调用时)提供的数据
函数返回值——关键字return返回给函数调用者，变量接收函数的执行结果
函数体在遇到return后就结束了，所以写在return后面的代码不会执行
None-空——return None—无返回值函数内容是None，类型是None
if中None等于False，声明无内容的变量
通过注释对函数进行解释说明——通过多行注释对函数进行解释，内容应写在函数体之前
函数嵌套调用——
变量的作用域——指变量的作用范围，哪里可以用，哪里不可用
(1)局部变量——定义在函数体内部的变量，只在函数体内部生效，临时保存数据
(2)全局变量—在函数体内外都可以使用的，在函数外定义
函数内声明变量为全局变量——关键字global——global 变量名
数据容器——一种可以容纳多份数据的数据类型，每一份数据称之为1个元素，可以是任意类型的数据
类数据容器总结对比——
数据容器的通用操作——
List(容器)转换为列表———Str(容器)转换为字符串———Tuple(容器)转换为元组———Set(容器)转换为集合———len(容器)统计容器的元素个数———max(容器)统计容器的最大元素———min(容器)统计容器的最小元素———
容器的通用排序功能sorted(容器,[reverse=True])reverse默认等于flase，等于true相当于反转———
字符串大小比较—ASCII码—一位一位进行比较
列表(list)—以[]作为标识—逗号分隔—
查找指定元素下标变量名.index(元素)——修改元素变量名[下标]=值——指定位置增加元素变量名.insert(下标,元素)——尾部追加单个元素变量名.append(元素)——尾部追加多个元素变量名.extend(其它容器数据)——删除元素1.del 变量名[下标]2.变量名.pop(下标)不仅可以删除掉还可以把元素返回出去——删除元素在列表中的第一个匹配值.remove(元素)从前到后删除找到的第一个——清空列表变量名.clear()——统计某元素在列表内的数量变量名.count(元素)——统计列表内，有多少个元素len(变量名)
遍历——while——可以自定循环条件，并自行控制——可通过条件做到无限循环，适用于任何想要循环的场景
for——不可以自定循环条件，只可以一个一个从容器取出数据——不能无限循环，遍历的容器不是无限的——适用于，遍历数据容器场景，或简单的固定次数循环场景
元组(tuple)—可容纳多个数据，不同类型，有序存储(下标索引)，允许重复存在，不可修改—一但定义就不能修改—()定义，逗号分隔—变量名=()—如果只有一个数据后面要有逗号—可通过下标索引取内容
查找指定元组的元素—元组变量名.index()—统计某个元素出现的次数—元组变量名.count(元素)—len(元组变量名)
元组内嵌套list可以增，删，改，查
元组的遍历——while——
for——
字典(dict)——
集合(set)——
字符串(str)—每一个字符就是一个元素—支持下标索引———变量名.index(元素)查找指定元素下标———字符串的替换，将字符串的全部：字符串1替换为字符串2，不是修改字符串而是得到一个新字符串新变量=变量名.replace(被替换元素，替换元素)———字符串的分割，指定分割字符串，将字符串划分为多个字符串并存入列表对象中，字符串本身不变，而是得到了一个列表对象新变量名=变量名.split(“以什么分隔例（”空格分隔“）“)———字符串的规整操作(去前后空格)—新变量=变量名.strip())去首尾空格—新变量=strip(“12”)去首尾12，按照单个字符移除——统计某个字符出现的次数—新变量=变量.count(字符串)———统计字符长度len()
序列—内容连续，有序，可使用下标索引—列表，元组，字符串均可视为序列
序列切片———序列(变量名)[起始下标:结束下标:步长]—从起始开始到结束起始为空视为从头开始(不含结束下标)留空视为结尾———步长：1时一个一个取，2时跳过一个去，n时跳过n-1取——步长为负数表示，反向取(起始下标和结束下标也要反向标记)
不会影响序列本身，而是得到一个新的序列
从头开始到最后结束—变量名[:]———从头开始步长为2—变量命[::2]
对str切片，从头开始，到最后结束——变量名[::-1]——从3开始到1结束步长-1—变量名[3:1:-1]—等同于序列反转
集合set—不支持元素的重复(自带去重复功能)，内容无序—{}定义，逗号分隔
不支持下标索引
添加新元素—集合.add(元素)———移除元素—集合.remove(元素)———随机取出一个元素—集合.pop()元素从集合中被移除———清空集合—集合.clear———消除两个集合的差集—集合1.difference(集合2)得到一个新集合，集合1和集合2不变———消除差集—集合1.difference_update(集合2)集合1被修改，集合2不变———2个集合合并为一个集合— 集合1.union(集合2)得到新集合，集合1集合2不变———统计集合元素数量len(集合)——
集合的遍历——不支持下标索引，所以不支持while
for——
字典dict—{}定义，存储的元素是一一个的：键值对—key和value可以是任意数据类型——
可以通过key值来取得Value字典[key]———
字典的嵌套——
常用操作———新增元素—字典[key]=value（key不可以重复如果重复就是更新value）———删除元素—字典.pop(key)（获得指定key的value,自定被修改，指定key数据被删除）———清空字典—字典.clear()（字典被修改，元素被清空）———获取全部的(key)—字典.keys()（得到字典中的全部key）———统计字典内的元素数量—len(字典)
循环遍历字典——由于不能下标所以所以只支持for循环，不支持while循环
函数的多返回值——按照返回值的顺序，写对应顺序的多个变量接收即可，变量之间用逗号隔开，支持不同类型的数据return
函数的多种传参方式——使用方式上有4种常见参数使用方式-位置参数-关键参数-缺省参数-不定长参数
位置参数：调用函数时根据函数定义的参数位置来传递参数
关键字参数：函数调用时通过“键=值”形式传递参数。作用：函数更加清晰，容易使用，清除了参数的顺序需求——注意：调用函数时如果有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序
缺省参数：也叫默认参数，定义函数，为参数提供默认值，调用函数时可不传该默认参数的值（注意，所有位置参数必须出现在默认参数前，包括函数定义和调用）——作用：当调用函数时没有传递参数，就会使用默认是用缺省参数对应的值
不定长参数：也叫可变参数，用于不确定调用的时候会传递多少个参数(不传参也可以)的场景——作用：当调用函数时不确定参数个数时，可以使用不定长参数
不定长参数的类型：1，位置传递，2.关键字传递
位置传递注意：传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组(tuple),args是元组类型，这就是位置传递
关键字传递注意:参数是“键=值“形式的形式的情况下，所有的”键=值“都会被kwargs接受，同时会根据”键=值“组成字典
匿名函数——
这是一种：计算逻辑的传递，而非数据的传递，任何逻辑都可以自行定义并作为函数传入
Lambda匿名函数的语法——lambda关键字，可以定义匿名函数（无名称），匿名函数只能临时使用一次——lambda 传入参数: 函数体（一行代码）——lambda是关键字，表示定义匿名函数，传入参数表示匿名函数的形式参数，函数体就是函数的执行逻辑
Def 和 lambda定义函数的功能是完全一致的，只是lambda关键字定义的函数是匿名的，无法二次使用
文件——open(name,mode,encoding)—name:要打开的目标文件名的字符串(可包含文件所在的具体路径)-mode:设置打开文件的模式-confing:编码格式推荐UTF-8
创建文件—对象=open(“文件”,w)—关闭对象.close——写入数据(write)—对象.write(“写入数据”)——读取数据(read)对象.read()——读取数据(readlines)没有参数时和read一样，额可以按照行的方式把整个文件中的内容进行一次性读取，返回一个列表，每一行的数据为一个元素——读数据(readline)按照行的方式把整个文件中的内容进行一个一个的读取—
可写(a)——对象=open(“”,a)——读数据(rb)1.对象=open(“二进制文件”，rb)2.with open(“二进制文件”，“rb”)as 对象:
关闭文件—close()
文件写入——f.write(“内容”)——内容刷新f.flush()——直接调用write内容并未真正写入文件，调用flush时，内容真正写入文件——避免频繁的操作硬盘，导致效率下降
注意——文件不存在时，w会为我们创建文件，当文件存在时，w会全部清空文件close()带有flush()功能
文件追加——f=open(“文件”，“a“)—f.write(“内容”)—f.flush
注意a模式，文件不存在会创建文件，文件存在时会在最后追加写入文件
对文件进行备份——
异常——程序检测到一个错误，python解释器无法继续执行了，出现了一些错误的提示，这就是所谓的异常，也就是常说的BUG
异常的捕获——异常处理(捕获异常)
遇到bug有两种情况:——1.整个程序因为一个BUG停止运行。——2.对BUG进行提醒，整个程序继续运行。
捕获异常的作用在于：提前假设某处会出现异常，做好提前准备，当真的出现异常的时候，可以有后续手段。
1. 如果尝试执行的代码块的异常类型和要捕获的异常类型不一致，则无法捕获异常。
2. 一般try下方只放一行尝试执行的代码。
异常的种类多种多样，如果想要不管什么类型都能捕获到，那么使用
1. except:
2. except Exception:
异常的传递性——所有函数都没有捕获异常的是时候，程序就会报错
模块(Module)——是一个python文件，里面有类，函数，变量等，我们可以拿过来用(导入模块去使用)
———模块的导入—
———自定义模块—自己写一些，个性化的模块，通过自定义模块实现，也就是自己制作一个模块
不同模块，同名的功能，如果都被导入，那么后导入的会覆盖先导入的
每个文件都可以作为一个模块，模块的名字就是文件的名字，也就是说自定义模块必须要符合标识符命名规则。
变量main——只有当程序是直接执行的的才会进入if内部，如果是被导入的，则if无法进入
变量all——如果一个模块文件中有“-all-变量”，当使用“from xxx import *”导入时，只能导入这个列表中的元素
Python包——从物理上看，就是一个文件夹，包含了一个_init_.py文件，该文件可用于包含多个模块文件
从逻辑上看，本质依然是模块
作用：模块文件越来越多，包可以帮助我们管理这些模块，作用就是包含多个模块，本质依然是模块
创建包——新建包——新建包内模块——注意:新建包后，包内部会自动创建_init_.py文件，这个文件控制着包的导入行为
导入包
方式1：import 包名.模块名 换行 包名.模块名.目标
方式2：from 包名 import * 换行 模块名.目标 ——注意:必须在_init_.py文件中添加_all_=[]控制允许导入的模块列表
安装第三方包——第三方包，极大的丰富了python的生态，提高开发效率，由于是第三方，所以没有内置，所以我们需要安装它们才可以导入使用
pip install 包名称
install -i https://pypi.tuna.stinghua.edu.cn/simple 包名称pip
数据可视化——折线图可视化
Json——轻量级的数据交互格式，按照json指定的格式去组织和封装数据
本质上是一个带有特定格式的字符串
功能——数据格式，数据传递和交互字符串格式化——
占位类型：%s——将内容转换成字符串
%d——将内容转换成整形
%f——将内容转换成浮点型
数字精度控制——m,控制宽度，要求数字（宽度小于数字自身）——.n ,控制小数点精度，要求是数字（四舍五入）
f内容{内容}——不做精准控制，原样输出
定义一个变量num,变量内存储随机数字
import random
num=random.randint(1,10)
while循环——
while嵌套循环——
print输出不换行 ,end=’’
for循环——遍历循环——for 临时变量 in 待处理数据集：——待处理数据称为序列类型，包括字符串，列表，元组，等
for嵌套循环——
continue——跳过本次循环，进行下次循环
break——结束循环
函数————组织好的，可重复使用，特定功能的代码段
优点——提高程序的重复性，减少重复性代码，提高开发效率
return 返回值
传入参数——函数进行计算的时候，接受外部(调用时)提供的数据
函数返回值——关键字return返回给函数调用者，变量接收函数的执行结果
函数体在遇到return后就结束了，所以写在return后面的代码不会执行
None-空——return None—无返回值函数内容是None，类型是None
if中None等于False，声明无内容的变量
通过注释对函数进行解释说明——通过多行注释对函数进行解释，内容应写在函数体之前
函数嵌套调用——
变量的作用域——指变量的作用范围，哪里可以用，哪里不可用
(1)局部变量——定义在函数体内部的变量，只在函数体内部生效，临时保存数据
(2)全局变量—在函数体内外都可以使用的，在函数外定义
函数内声明变量为全局变量——关键字global——global 变量名
数据容器——一种可以容纳多份数据的数据类型，每一份数据称之为1个元素，可以是任意类型的数据
类数据容器总结对比——
数据容器的通用操作——
List(容器)转换为列表———Str(容器)转换为字符串———Tuple(容器)转换为元组———Set(容器)转换为集合———len(容器)统计容器的元素个数———max(容器)统计容器的最大元素———min(容器)统计容器的最小元素———
容器的通用排序功能sorted(容器,[reverse=True])reverse默认等于flase，等于true相当于反转———
字符串大小比较—ASCII码—一位一位进行比较
列表(list)—以[]作为标识—逗号分隔—
查找指定元素下标变量名.index(元素)——修改元素变量名[下标]=值——指定位置增加元素变量名.insert(下标,元素)——尾部追加单个元素变量名.append(元素)——尾部追加多个元素变量名.extend(其它容器数据)——删除元素1.del 变量名[下标]2.变量名.pop(下标)不仅可以删除掉还可以把元素返回出去——删除元素在列表中的第一个匹配值.remove(元素)从前到后删除找到的第一个——清空列表变量名.clear()——统计某元素在列表内的数量变量名.count(元素)——统计列表内，有多少个元素len(变量名)
遍历——while——可以自定循环条件，并自行控制——可通过条件做到无限循环，适用于任何想要循环的场景
for——不可以自定循环条件，只可以一个一个从容器取出数据——不能无限循环，遍历的容器不是无限的——适用于，遍历数据容器场景，或简单的固定次数循环场景
元组(tuple)—可容纳多个数据，不同类型，有序存储(下标索引)，允许重复存在，不可修改—一但定义就不能修改—()定义，逗号分隔—变量名=()—如果只有一个数据后面要有逗号—可通过下标索引取内容
查找指定元组的元素—元组变量名.index()—统计某个元素出现的次数—元组变量名.count(元素)—len(元组变量名)
元组内嵌套list可以增，删，改，查
元组的遍历——while——
for——
字典(dict)——
集合(set)——
字符串(str)—每一个字符就是一个元素—支持下标索引———变量名.index(元素)查找指定元素下标———字符串的替换，将字符串的全部：字符串1替换为字符串2，不是修改字符串而是得到一个新字符串新变量=变量名.replace(被替换元素，替换元素)———字符串的分割，指定分割字符串，将字符串划分为多个字符串并存入列表对象中，字符串本身不变，而是得到了一个列表对象新变量名=变量名.split(“以什么分隔例（”空格分隔“）“)———字符串的规整操作(去前后空格)—新变量=变量名.strip())去首尾空格—新变量=strip(“12”)去首尾12，按照单个字符移除——统计某个字符出现的次数—新变量=变量.count(字符串)———统计字符长度len()
序列—内容连续，有序，可使用下标索引—列表，元组，字符串均可视为序列
序列切片———序列(变量名)[起始下标:结束下标:步长]—从起始开始到结束起始为空视为从头开始(不含结束下标)留空视为结尾———步长：1时一个一个取，2时跳过一个去，n时跳过n-1取——步长为负数表示，反向取(起始下标和结束下标也要反向标记)
不会影响序列本身，而是得到一个新的序列
从头开始到最后结束—变量名[:]———从头开始步长为2—变量命[::2]
对str切片，从头开始，到最后结束——变量名[::-1]——从3开始到1结束步长-1—变量名[3:1:-1]—等同于序列反转
集合set—不支持元素的重复(自带去重复功能)，内容无序—{}定义，逗号分隔
不支持下标索引
添加新元素—集合.add(元素)———移除元素—集合.remove(元素)———随机取出一个元素—集合.pop()元素从集合中被移除———清空集合—集合.clear———消除两个集合的差集—集合1.difference(集合2)得到一个新集合，集合1和集合2不变———消除差集—集合1.difference_update(集合2)集合1被修改，集合2不变———2个集合合并为一个集合— 集合1.union(集合2)得到新集合，集合1集合2不变———统计集合元素数量len(集合)——
集合的遍历——不支持下标索引，所以不支持while
for——
字典dict—{}定义，存储的元素是一一个的：键值对—key和value可以是任意数据类型——
可以通过key值来取得Value字典[key]———
字典的嵌套——
常用操作———新增元素—字典[key]=value（key不可以重复如果重复就是更新value）———删除元素—字典.pop(key)（获得指定key的value,自定被修改，指定key数据被删除）———清空字典—字典.clear()（字典被修改，元素被清空）———获取全部的(key)—字典.keys()（得到字典中的全部key）———统计字典内的元素数量—len(字典)
循环遍历字典——由于不能下标所以所以只支持for循环，不支持while循环
函数的多返回值——按照返回值的顺序，写对应顺序的多个变量接收即可，变量之间用逗号隔开，支持不同类型的数据return
函数的多种传参方式——使用方式上有4种常见参数使用方式-位置参数-关键参数-缺省参数-不定长参数
位置参数：调用函数时根据函数定义的参数位置来传递参数
关键字参数：函数调用时通过“键=值”形式传递参数。作用：函数更加清晰，容易使用，清除了参数的顺序需求——注意：调用函数时如果有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序
缺省参数：也叫默认参数，定义函数，为参数提供默认值，调用函数时可不传该默认参数的值（注意，所有位置参数必须出现在默认参数前，包括函数定义和调用）——作用：当调用函数时没有传递参数，就会使用默认是用缺省参数对应的值
不定长参数：也叫可变参数，用于不确定调用的时候会传递多少个参数(不传参也可以)的场景——作用：当调用函数时不确定参数个数时，可以使用不定长参数
不定长参数的类型：1，位置传递，2.关键字传递
位置传递注意：传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组(tuple),args是元组类型，这就是位置传递
关键字传递注意:参数是“键=值“形式的形式的情况下，所有的”键=值“都会被kwargs接受，同时会根据”键=值“组成字典
匿名函数——
这是一种：计算逻辑的传递，而非数据的传递，任何逻辑都可以自行定义并作为函数传入
Lambda匿名函数的语法——lambda关键字，可以定义匿名函数（无名称），匿名函数只能临时使用一次——lambda 传入参数: 函数体（一行代码）——lambda是关键字，表示定义匿名函数，传入参数表示匿名函数的形式参数，函数体就是函数的执行逻辑
Def 和 lambda定义函数的功能是完全一致的，只是lambda关键字定义的函数是匿名的，无法二次使用
文件——open(name,mode,encoding)—name:要打开的目标文件名的字符串(可包含文件所在的具体路径)-mode:设置打开文件的模式-confing:编码格式推荐UTF-8
创建文件—对象=open(“文件”,w)—关闭对象.close——写入数据(write)—对象.write(“写入数据”)——读取数据(read)对象.read()——读取数据(readlines)没有参数时和read一样，额可以按照行的方式把整个文件中的内容进行一次性读取，返回一个列表，每一行的数据为一个元素——读数据(readline)按照行的方式把整个文件中的内容进行一个一个的读取—
可写(a)——对象=open(“”,a)——读数据(rb)1.对象=open(“二进制文件”，rb)2.with open(“二进制文件”，“rb”)as 对象:
关闭文件—close()
文件写入——f.write(“内容”)——内容刷新f.flush()——直接调用write内容并未真正写入文件，调用flush时，内容真正写入文件——避免频繁的操作硬盘，导致效率下降
注意——文件不存在时，w会为我们创建文件，当文件存在时，w会全部清空文件close()带有flush()功能
文件追加——f=open(“文件”，“a“)—f.write(“内容”)—f.flush
注意a模式，文件不存在会创建文件，文件存在时会在最后追加写入文件
对文件进行备份——
异常——程序检测到一个错误，python解释器无法继续执行了，出现了一些错误的提示，这就是所谓的异常，也就是常说的BUG
异常的捕获——异常处理(捕获异常)
遇到bug有两种情况:——1.整个程序因为一个BUG停止运行。——2.对BUG进行提醒，整个程序继续运行。
捕获异常的作用在于：提前假设某处会出现异常，做好提前准备，当真的出现异常的时候，可以有后续手段。
1. 如果尝试执行的代码块的异常类型和要捕获的异常类型不一致，则无法捕获异常。
2. 一般try下方只放一行尝试执行的代码。
异常的种类多种多样，如果想要不管什么类型都能捕获到，那么使用
1. except:
2. except Exception:
异常的传递性——所有函数都没有捕获异常的是时候，程序就会报错
模块(Module)——是一个python文件，里面有类，函数，变量等，我们可以拿过来用(导入模块去使用)
———模块的导入—
———自定义模块—自己写一些，个性化的模块，通过自定义模块实现，也就是自己制作一个模块
不同模块，同名的功能，如果都被导入，那么后导入的会覆盖先导入的
每个文件都可以作为一个模块，模块的名字就是文件的名字，也就是说自定义模块必须要符合标识符命名规则。
变量main——只有当程序是直接执行的的才会进入if内部，如果是被导入的，则if无法进入
变量all——如果一个模块文件中有“-all-变量”，当使用“from xxx import *”导入时，只能导入这个列表中的元素
Python包——从物理上看，就是一个文件夹，包含了一个_init_.py文件，该文件可用于包含多个模块文件
从逻辑上看，本质依然是模块
作用：模块文件越来越多，包可以帮助我们管理这些模块，作用就是包含多个模块，本质依然是模块
创建包——新建包——新建包内模块——注意:新建包后，包内部会自动创建_init_.py文件，这个文件控制着包的导入行为
导入包
方式1：import 包名.模块名 换行 包名.模块名.目标
方式2：from 包名 import * 换行 模块名.目标 ——注意:必须在_init_.py文件中添加_all_=[]控制允许导入的模块列表
安装第三方包——第三方包，极大的丰富了python的生态，提高开发效率，由于是第三方，所以没有内置，所以我们需要安装它们才可以导入使用
pip install 包名称
install -i https://pypi.tuna.stinghua.edu.cn/simple 包名称pip
数据可视化——折线图可视化
Json——轻量级的数据交互格式，按照json指定的格式去组织和封装数据
本质上是一个带有特定格式的字符串
功能——数据格式，数据传递和交互字符串格式化——
占位类型：%s——将内容转换成字符串
%d——将内容转换成整形
%f——将内容转换成浮点型
数字精度控制——m,控制宽度，要求数字（宽度小于数字自身）——.n ,控制小数点精度，要求是数字（四舍五入）
f内容{内容}——不做精准控制，原样输出
定义一个变量num,变量内存储随机数字
import random
num=random.randint(1,10)
while循环——
while嵌套循环——
print输出不换行 ,end=’’
for循环——遍历循环——for 临时变量 in 待处理数据集：——待处理数据称为序列类型，包括字符串，列表，元组，等
for嵌套循环——
continue——跳过本次循环，进行下次循环
break——结束循环
函数————组织好的，可重复使用，特定功能的代码段
优点——提高程序的重复性，减少重复性代码，提高开发效率
return 返回值
传入参数——函数进行计算的时候，接受外部(调用时)提供的数据
函数返回值——关键字return返回给函数调用者，变量接收函数的执行结果
函数体在遇到return后就结束了，所以写在return后面的代码不会执行
None-空——return None—无返回值函数内容是None，类型是None
if中None等于False，声明无内容的变量
通过注释对函数进行解释说明——通过多行注释对函数进行解释，内容应写在函数体之前
函数嵌套调用——
变量的作用域——指变量的作用范围，哪里可以用，哪里不可用
(1)局部变量——定义在函数体内部的变量，只在函数体内部生效，临时保存数据
(2)全局变量—在函数体内外都可以使用的，在函数外定义
函数内声明变量为全局变量——关键字global——global 变量名
数据容器——一种可以容纳多份数据的数据类型，每一份数据称之为1个元素，可以是任意类型的数据
类数据容器总结对比——
数据容器的通用操作——
List(容器)转换为列表———Str(容器)转换为字符串———Tuple(容器)转换为元组———Set(容器)转换为集合———len(容器)统计容器的元素个数———max(容器)统计容器的最大元素———min(容器)统计容器的最小元素———
容器的通用排序功能sorted(容器,[reverse=True])reverse默认等于flase，等于true相当于反转———
字符串大小比较—ASCII码—一位一位进行比较
列表(list)—以[]作为标识—逗号分隔—
查找指定元素下标变量名.index(元素)——修改元素变量名[下标]=值——指定位置增加元素变量名.insert(下标,元素)——尾部追加单个元素变量名.append(元素)——尾部追加多个元素变量名.extend(其它容器数据)——删除元素1.del 变量名[下标]2.变量名.pop(下标)不仅可以删除掉还可以把元素返回出去——删除元素在列表中的第一个匹配值.remove(元素)从前到后删除找到的第一个——清空列表变量名.clear()——统计某元素在列表内的数量变量名.count(元素)——统计列表内，有多少个元素len(变量名)
遍历——while——可以自定循环条件，并自行控制——可通过条件做到无限循环，适用于任何想要循环的场景
for——不可以自定循环条件，只可以一个一个从容器取出数据——不能无限循环，遍历的容器不是无限的——适用于，遍历数据容器场景，或简单的固定次数循环场景
元组(tuple)—可容纳多个数据，不同类型，有序存储(下标索引)，允许重复存在，不可修改—一但定义就不能修改—()定义，逗号分隔—变量名=()—如果只有一个数据后面要有逗号—可通过下标索引取内容
查找指定元组的元素—元组变量名.index()—统计某个元素出现的次数—元组变量名.count(元素)—len(元组变量名)
元组内嵌套list可以增，删，改，查
元组的遍历——while——
for——
字典(dict)——
集合(set)——
字符串(str)—每一个字符就是一个元素—支持下标索引———变量名.index(元素)查找指定元素下标———字符串的替换，将字符串的全部：字符串1替换为字符串2，不是修改字符串而是得到一个新字符串新变量=变量名.replace(被替换元素，替换元素)———字符串的分割，指定分割字符串，将字符串划分为多个字符串并存入列表对象中，字符串本身不变，而是得到了一个列表对象新变量名=变量名.split(“以什么分隔例（”空格分隔“）“)———字符串的规整操作(去前后空格)—新变量=变量名.strip())去首尾空格—新变量=strip(“12”)去首尾12，按照单个字符移除——统计某个字符出现的次数—新变量=变量.count(字符串)———统计字符长度len()
序列—内容连续，有序，可使用下标索引—列表，元组，字符串均可视为序列
序列切片———序列(变量名)[起始下标:结束下标:步长]—从起始开始到结束起始为空视为从头开始(不含结束下标)留空视为结尾———步长：1时一个一个取，2时跳过一个去，n时跳过n-1取——步长为负数表示，反向取(起始下标和结束下标也要反向标记)
不会影响序列本身，而是得到一个新的序列
从头开始到最后结束—变量名[:]———从头开始步长为2—变量命[::2]
对str切片，从头开始，到最后结束——变量名[::-1]——从3开始到1结束步长-1—变量名[3:1:-1]—等同于序列反转
集合set—不支持元素的重复(自带去重复功能)，内容无序—{}定义，逗号分隔
不支持下标索引
添加新元素—集合.add(元素)———移除元素—集合.remove(元素)———随机取出一个元素—集合.pop()元素从集合中被移除———清空集合—集合.clear———消除两个集合的差集—集合1.difference(集合2)得到一个新集合，集合1和集合2不变———消除差集—集合1.difference_update(集合2)集合1被修改，集合2不变———2个集合合并为一个集合— 集合1.union(集合2)得到新集合，集合1集合2不变———统计集合元素数量len(集合)——
集合的遍历——不支持下标索引，所以不支持while
for——
字典dict—{}定义，存储的元素是一一个的：键值对—key和value可以是任意数据类型——
可以通过key值来取得Value字典[key]———
字典的嵌套——
常用操作———新增元素—字典[key]=value（key不可以重复如果重复就是更新value）———删除元素—字典.pop(key)（获得指定key的value,自定被修改，指定key数据被删除）———清空字典—字典.clear()（字典被修改，元素被清空）———获取全部的(key)—字典.keys()（得到字典中的全部key）———统计字典内的元素数量—len(字典)
循环遍历字典——由于不能下标所以所以只支持for循环，不支持while循环
函数的多返回值——按照返回值的顺序，写对应顺序的多个变量接收即可，变量之间用逗号隔开，支持不同类型的数据return
函数的多种传参方式——使用方式上有4种常见参数使用方式-位置参数-关键参数-缺省参数-不定长参数
位置参数：调用函数时根据函数定义的参数位置来传递参数
关键字参数：函数调用时通过“键=值”形式传递参数。作用：函数更加清晰，容易使用，清除了参数的顺序需求——注意：调用函数时如果有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序
缺省参数：也叫默认参数，定义函数，为参数提供默认值，调用函数时可不传该默认参数的值（注意，所有位置参数必须出现在默认参数前，包括函数定义和调用）——作用：当调用函数时没有传递参数，就会使用默认是用缺省参数对应的值
不定长参数：也叫可变参数，用于不确定调用的时候会传递多少个参数(不传参也可以)的场景——作用：当调用函数时不确定参数个数时，可以使用不定长参数
不定长参数的类型：1，位置传递，2.关键字传递
位置传递注意：传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组(tuple),args是元组类型，这就是位置传递
关键字传递注意:参数是“键=值“形式的形式的情况下，所有的”键=值“都会被kwargs接受，同时会根据”键=值“组成字典
匿名函数——
这是一种：计算逻辑的传递，而非数据的传递，任何逻辑都可以自行定义并作为函数传入
Lambda匿名函数的语法——lambda关键字，可以定义匿名函数（无名称），匿名函数只能临时使用一次——lambda 传入参数: 函数体（一行代码）——lambda是关键字，表示定义匿名函数，传入参数表示匿名函数的形式参数，函数体就是函数的执行逻辑
Def 和 lambda定义函数的功能是完全一致的，只是lambda关键字定义的函数是匿名的，无法二次使用
文件——open(name,mode,encoding)—name:要打开的目标文件名的字符串(可包含文件所在的具体路径)-mode:设置打开文件的模式-confing:编码格式推荐UTF-8
创建文件—对象=open(“文件”,w)—关闭对象.close——写入数据(write)—对象.write(“写入数据”)——读取数据(read)对象.read()——读取数据(readlines)没有参数时和read一样，额可以按照行的方式把整个文件中的内容进行一次性读取，返回一个列表，每一行的数据为一个元素——读数据(readline)按照行的方式把整个文件中的内容进行一个一个的读取—
可写(a)——对象=open(“”,a)——读数据(rb)1.对象=open(“二进制文件”，rb)2.with open(“二进制文件”，“rb”)as 对象:
关闭文件—close()
文件写入——f.write(“内容”)——内容刷新f.flush()——直接调用write内容并未真正写入文件，调用flush时，内容真正写入文件——避免频繁的操作硬盘，导致效率下降
注意——文件不存在时，w会为我们创建文件，当文件存在时，w会全部清空文件close()带有flush()功能
文件追加——f=open(“文件”，“a“)—f.write(“内容”)—f.flush
注意a模式，文件不存在会创建文件，文件存在时会在最后追加写入文件
对文件进行备份——
异常——程序检测到一个错误，python解释器无法继续执行了，出现了一些错误的提示，这就是所谓的异常，也就是常说的BUG
异常的捕获——异常处理(捕获异常)
遇到bug有两种情况:——1.整个程序因为一个BUG停止运行。——2.对BUG进行提醒，整个程序继续运行。
捕获异常的作用在于：提前假设某处会出现异常，做好提前准备，当真的出现异常的时候，可以有后续手段。
1. 如果尝试执行的代码块的异常类型和要捕获的异常类型不一致，则无法捕获异常。
2. 一般try下方只放一行尝试执行的代码。
异常的种类多种多样，如果想要不管什么类型都能捕获到，那么使用
1. except:
2. except Exception:
异常的传递性——所有函数都没有捕获异常的是时候，程序就会报错
模块(Module)——是一个python文件，里面有类，函数，变量等，我们可以拿过来用(导入模块去使用)
———模块的导入—
———自定义模块—自己写一些，个性化的模块，通过自定义模块实现，也就是自己制作一个模块
不同模块，同名的功能，如果都被导入，那么后导入的会覆盖先导入的
每个文件都可以作为一个模块，模块的名字就是文件的名字，也就是说自定义模块必须要符合标识符命名规则。
变量main——只有当程序是直接执行的的才会进入if内部，如果是被导入的，则if无法进入
变量all——如果一个模块文件中有“-all-变量”，当使用“from xxx import *”导入时，只能导入这个列表中的元素
Python包——从物理上看，就是一个文件夹，包含了一个_init_.py文件，该文件可用于包含多个模块文件
从逻辑上看，本质依然是模块
作用：模块文件越来越多，包可以帮助我们管理这些模块，作用就是包含多个模块，本质依然是模块
创建包——新建包——新建包内模块——注意:新建包后，包内部会自动创建_init_.py文件，这个文件控制着包的导入行为
导入包
方式1：import 包名.模块名 换行 包名.模块名.目标
方式2：from 包名 import * 换行 模块名.目标 ——注意:必须在_init_.py文件中添加_all_=[]控制允许导入的模块列表
安装第三方包——第三方包，极大的丰富了python的生态，提高开发效率，由于是第三方，所以没有内置，所以我们需要安装它们才可以导入使用
pip install 包名称
install -i https://pypi.tuna.stinghua.edu.cn/simple 包名称pip
数据可视化——折线图可视化
Json——轻量级的数据交互格式，按照json指定的格式去组织和封装数据
本质上是一个带有特定格式的字符串
功能——数据格式，数据传递和交互字符串格式化——
占位类型：%s——将内容转换成字符串
%d——将内容转换成整形
%f——将内容转换成浮点型
数字精度控制——m,控制宽度，要求数字（宽度小于数字自身）——.n ,控制小数点精度，要求是数字（四舍五入）
f内容{内容}——不做精准控制，原样输出
定义一个变量num,变量内存储随机数字
import random
num=random.randint(1,10)
while循环——
while嵌套循环——
print输出不换行 ,end=’’
for循环——遍历循环——for 临时变量 in 待处理数据集：——待处理数据称为序列类型，包括字符串，列表，元组，等
for嵌套循环——
continue——跳过本次循环，进行下次循环
break——结束循环
函数————组织好的，可重复使用，特定功能的代码段
优点——提高程序的重复性，减少重复性代码，提高开发效率
return 返回值
传入参数——函数进行计算的时候，接受外部(调用时)提供的数据
函数返回值——关键字return返回给函数调用者，变量接收函数的执行结果
函数体在遇到return后就结束了，所以写在return后面的代码不会执行
None-空——return None—无返回值函数内容是None，类型是None
if中None等于False，声明无内容的变量
通过注释对函数进行解释说明——通过多行注释对函数进行解释，内容应写在函数体之前
函数嵌套调用——
变量的作用域——指变量的作用范围，哪里可以用，哪里不可用
(1)局部变量——定义在函数体内部的变量，只在函数体内部生效，临时保存数据
(2)全局变量—在函数体内外都可以使用的，在函数外定义
函数内声明变量为全局变量——关键字global——global 变量名
数据容器——一种可以容纳多份数据的数据类型，每一份数据称之为1个元素，可以是任意类型的数据
类数据容器总结对比——
数据容器的通用操作——
List(容器)转换为列表———Str(容器)转换为字符串———Tuple(容器)转换为元组———Set(容器)转换为集合———len(容器)统计容器的元素个数———max(容器)统计容器的最大元素———min(容器)统计容器的最小元素———
容器的通用排序功能sorted(容器,[reverse=True])reverse默认等于flase，等于true相当于反转———
字符串大小比较—ASCII码—一位一位进行比较
列表(list)—以[]作为标识—逗号分隔—
查找指定元素下标变量名.index(元素)——修改元素变量名[下标]=值——指定位置增加元素变量名.insert(下标,元素)——尾部追加单个元素变量名.append(元素)——尾部追加多个元素变量名.extend(其它容器数据)——删除元素1.del 变量名[下标]2.变量名.pop(下标)不仅可以删除掉还可以把元素返回出去——删除元素在列表中的第一个匹配值.remove(元素)从前到后删除找到的第一个——清空列表变量名.clear()——统计某元素在列表内的数量变量名.count(元素)——统计列表内，有多少个元素len(变量名)
遍历——while——可以自定循环条件，并自行控制——可通过条件做到无限循环，适用于任何想要循环的场景
for——不可以自定循环条件，只可以一个一个从容器取出数据——不能无限循环，遍历的容器不是无限的——适用于，遍历数据容器场景，或简单的固定次数循环场景
元组(tuple)—可容纳多个数据，不同类型，有序存储(下标索引)，允许重复存在，不可修改—一但定义就不能修改—()定义，逗号分隔—变量名=()—如果只有一个数据后面要有逗号—可通过下标索引取内容
查找指定元组的元素—元组变量名.index()—统计某个元素出现的次数—元组变量名.count(元素)—len(元组变量名)
元组内嵌套list可以增，删，改，查
元组的遍历——while——
for——
字典(dict)——
集合(set)——
字符串(str)—每一个字符就是一个元素—支持下标索引———变量名.index(元素)查找指定元素下标———字符串的替换，将字符串的全部：字符串1替换为字符串2，不是修改字符串而是得到一个新字符串新变量=变量名.replace(被替换元素，替换元素)———字符串的分割，指定分割字符串，将字符串划分为多个字符串并存入列表对象中，字符串本身不变，而是得到了一个列表对象新变量名=变量名.split(“以什么分隔例（”空格分隔“）“)———字符串的规整操作(去前后空格)—新变量=变量名.strip())去首尾空格—新变量=strip(“12”)去首尾12，按照单个字符移除——统计某个字符出现的次数—新变量=变量.count(字符串)———统计字符长度len()
序列—内容连续，有序，可使用下标索引—列表，元组，字符串均可视为序列
序列切片———序列(变量名)[起始下标:结束下标:步长]—从起始开始到结束起始为空视为从头开始(不含结束下标)留空视为结尾———步长：1时一个一个取，2时跳过一个去，n时跳过n-1取——步长为负数表示，反向取(起始下标和结束下标也要反向标记)
不会影响序列本身，而是得到一个新的序列
从头开始到最后结束—变量名[:]———从头开始步长为2—变量命[::2]
对str切片，从头开始，到最后结束——变量名[::-1]——从3开始到1结束步长-1—变量名[3:1:-1]—等同于序列反转
集合set—不支持元素的重复(自带去重复功能)，内容无序—{}定义，逗号分隔
不支持下标索引
添加新元素—集合.add(元素)———移除元素—集合.remove(元素)———随机取出一个元素—集合.pop()元素从集合中被移除———清空集合—集合.clear———消除两个集合的差集—集合1.difference(集合2)得到一个新集合，集合1和集合2不变———消除差集—集合1.difference_update(集合2)集合1被修改，集合2不变———2个集合合并为一个集合— 集合1.union(集合2)得到新集合，集合1集合2不变———统计集合元素数量len(集合)——
集合的遍历——不支持下标索引，所以不支持while
for——
字典dict—{}定义，存储的元素是一一个的：键值对—key和value可以是任意数据类型——
可以通过key值来取得Value字典[key]———
字典的嵌套——
常用操作———新增元素—字典[key]=value（key不可以重复如果重复就是更新value）———删除元素—字典.pop(key)（获得指定key的value,自定被修改，指定key数据被删除）———清空字典—字典.clear()（字典被修改，元素被清空）———获取全部的(key)—字典.keys()（得到字典中的全部key）———统计字典内的元素数量—len(字典)
循环遍历字典——由于不能下标所以所以只支持for循环，不支持while循环
函数的多返回值——按照返回值的顺序，写对应顺序的多个变量接收即可，变量之间用逗号隔开，支持不同类型的数据return
函数的多种传参方式——使用方式上有4种常见参数使用方式-位置参数-关键参数-缺省参数-不定长参数
位置参数：调用函数时根据函数定义的参数位置来传递参数
关键字参数：函数调用时通过“键=值”形式传递参数。作用：函数更加清晰，容易使用，清除了参数的顺序需求——注意：调用函数时如果有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序
缺省参数：也叫默认参数，定义函数，为参数提供默认值，调用函数时可不传该默认参数的值（注意，所有位置参数必须出现在默认参数前，包括函数定义和调用）——作用：当调用函数时没有传递参数，就会使用默认是用缺省参数对应的值
不定长参数：也叫可变参数，用于不确定调用的时候会传递多少个参数(不传参也可以)的场景——作用：当调用函数时不确定参数个数时，可以使用不定长参数
不定长参数的类型：1，位置传递，2.关键字传递
位置传递注意：传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组(tuple),args是元组类型，这就是位置传递
关键字传递注意:参数是“键=值“形式的形式的情况下，所有的”键=值“都会被kwargs接受，同时会根据”键=值“组成字典
匿名函数——
这是一种：计算逻辑的传递，而非数据的传递，任何逻辑都可以自行定义并作为函数传入
Lambda匿名函数的语法——lambda关键字，可以定义匿名函数（无名称），匿名函数只能临时使用一次——lambda 传入参数: 函数体（一行代码）——lambda是关键字，表示定义匿名函数，传入参数表示匿名函数的形式参数，函数体就是函数的执行逻辑
Def 和 lambda定义函数的功能是完全一致的，只是lambda关键字定义的函数是匿名的，无法二次使用
文件——open(name,mode,encoding)—name:要打开的目标文件名的字符串(可包含文件所在的具体路径)-mode:设置打开文件的模式-confing:编码格式推荐UTF-8
创建文件—对象=open(“文件”,w)—关闭对象.close——写入数据(write)—对象.write(“写入数据”)——读取数据(read)对象.read()——读取数据(readlines)没有参数时和read一样，额可以按照行的方式把整个文件中的内容进行一次性读取，返回一个列表，每一行的数据为一个元素——读数据(readline)按照行的方式把整个文件中的内容进行一个一个的读取—
可写(a)——对象=open(“”,a)——读数据(rb)1.对象=open(“二进制文件”，rb)2.with open(“二进制文件”，“rb”)as 对象:
关闭文件—close()
文件写入——f.write(“内容”)——内容刷新f.flush()——直接调用write内容并未真正写入文件，调用flush时，内容真正写入文件——避免频繁的操作硬盘，导致效率下降
注意——文件不存在时，w会为我们创建文件，当文件存在时，w会全部清空文件close()带有flush()功能
文件追加——f=open(“文件”，“a“)—f.write(“内容”)—f.flush
注意a模式，文件不存在会创建文件，文件存在时会在最后追加写入文件
对文件进行备份——
异常——程序检测到一个错误，python解释器无法继续执行了，出现了一些错误的提示，这就是所谓的异常，也就是常说的BUG
异常的捕获——异常处理(捕获异常)
遇到bug有两种情况:——1.整个程序因为一个BUG停止运行。——2.对BUG进行提醒，整个程序继续运行。
捕获异常的作用在于：提前假设某处会出现异常，做好提前准备，当真的出现异常的时候，可以有后续手段。
1. 如果尝试执行的代码块的异常类型和要捕获的异常类型不一致，则无法捕获异常。
2. 一般try下方只放一行尝试执行的代码。
异常的种类多种多样，如果想要不管什么类型都能捕获到，那么使用
1. except:
2. except Exception:
异常的传递性——所有函数都没有捕获异常的是时候，程序就会报错
模块(Module)——是一个python文件，里面有类，函数，变量等，我们可以拿过来用(导入模块去使用)
———模块的导入—
———自定义模块—自己写一些，个性化的模块，通过自定义模块实现，也就是自己制作一个模块
不同模块，同名的功能，如果都被导入，那么后导入的会覆盖先导入的
每个文件都可以作为一个模块，模块的名字就是文件的名字，也就是说自定义模块必须要符合标识符命名规则。
变量main——只有当程序是直接执行的的才会进入if内部，如果是被导入的，则if无法进入
变量all——如果一个模块文件中有“-all-变量”，当使用“from xxx import *”导入时，只能导入这个列表中的元素
Python包——从物理上看，就是一个文件夹，包含了一个_init_.py文件，该文件可用于包含多个模块文件
从逻辑上看，本质依然是模块
作用：模块文件越来越多，包可以帮助我们管理这些模块，作用就是包含多个模块，本质依然是模块
创建包——新建包——新建包内模块——注意:新建包后，包内部会自动创建_init_.py文件，这个文件控制着包的导入行为
导入包
方式1：import 包名.模块名 换行 包名.模块名.目标
方式2：from 包名 import * 换行 模块名.目标 ——注意:必须在_init_.py文件中添加_all_=[]控制允许导入的模块列表
安装第三方包——第三方包，极大的丰富了python的生态，提高开发效率，由于是第三方，所以没有内置，所以我们需要安装它们才可以导入使用
pip install 包名称
install -i https://pypi.tuna.stinghua.edu.cn/simple 包名称pip
数据可视化——折线图可视化
Json——轻量级的数据交互格式，按照json指定的格式去组织和封装数据
本质上是一个带有特定格式的字符串
功能——数据格式，数据传递和交互
