数据容器

一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素，每一个数据元素，可以使任意类型的数据，如字符串、数字、布尔等。

数据容器分为五类：
list（列表）、tuple（元组）、str（字符串）、set（集合）、dict（字典）

list（列表）

定义格式：
变量初始化时直接通过字面量方式定义，在打印时会直接输出列表里面的内容（和java不同，java是输出地址值）

并且在Python中，同一个list可以存储不同类型的数据

列表嵌套

list 列表的下标

就和java数组一样，索引从0开始。

奇葩的是，索引可以为负数！！！！！！！！
最后一个元素索引为 -1，倒数倒数第二个元素索引为 -2，以此类推
超出索引取数据，程序报错。

list列表的常用操作

先区别函数和方法。写在类里面的函数称为方法，但是你在类里面调用又可以称为函数，你在类外面调用称为方法。反正一回事，差别不大，叫法不一样而已。类的定义和java差不多，但是这儿先不说类的含义。
查询元素
语法：列表.index(元素) 返回下标值。如果元素不存在会报错
如果有相同元素，则会返回第一个的索引

修改元素
语法 ： 列表[索引值] = 新值

插入元素
语法： 列表.insert(索引值，元素值) 在指定位置插入指定的元素，那么原本位置包括后面的元素一次向后挪一位

语法： 列表.append(元素值) 追加元素到末尾
语法： 列表.extend(其他数据容器) 将其他数据容器内容取出来，一次追加到列表尾部。
list_1 = [1,2,3]
list_1.extend([4,5,6]) # list_1 = [1,2,3,4,5,6]

删除元素
语法： del 列表[索引值] # 删除指定位置的元素，后面的自动补齐
语法： 列表.pop(索引值) # 删除指定位置的元素，并且会返回被删除的元素
语法： 列表.remove(元素值) # 删除匹配的第一个元素，有多个相同元素时，只删除匹配到的第一个

清空列表
语法： 列表.clear()

统计元素个数
语法： 列表.count(元素) 统计指定元素在列表中的个数(就是计算相同元素的个数)
语法： len(列表) 统计列表的长度

总结

列表存在上限， 2^63 -1
同一个列表可以容纳不同类型的元素
列表内的数据时有序存储的
允许重复元素
可以修改元素

list 列表的遍历

while 循环

for 循环

truple元组

元组同列表一样，都是可以封装多个，不同类型的元素。
但是！元组一旦定义完成，就不可以修改 用于只读数据的封装，防止数据被篡改，强制修改会报错。
定义语法：
变量名称 = (元素1，元素2 …)
定义空元组 ： 变量名称 = （） 或者 变量名称 = truple()
元组.index(元素值) 返回索引值
len(元组) 获取元组长度
元组可以嵌套，和list一样
根据索引值获取元素 元组[索引值]
count(元素值) 获取指定元素值出现的次数
元组遍历和 list列表一样

！！注意：当你元组只有一个元素时，后面需要使用 ， 结尾，不然系统会认为时 字符串

！！奇葩内容来了，如果元组里面有一个 list 列表，那么 这个list 列表里面的内容是可以修改的。
结合java理解，元组里面 存放的是 list 的地址值，这个地址指向对应的list，list 列表里面的内容变了，但是元组存放的地址值没有变。 这就和java 基本类型 和 对象类型 是一样的。
当你元组存储的基本数据类型时，对应的值不能改变，当你存放的对象数据类型时，地址值没变，但是对应的对象里面的内容是可以改变的。不知道Python有没有对象的概念。（复习一下java，就像你方法传参数一样，当你实参传递的是基本数据类型是值传递，你在方法内部修改传递的值，不影响外面的值。当你实参传递的是对象，这个是址传递，传递的是地址值，你在方法内部修改对象，对外面也是生效的）

str 字符串

以数据容器的视角学习字符串
字符串是 字符 的容器，可以存放任意个字符（不绝对，取决于你电脑内存大小）

和元组一样，字符串是一个无法修改的数据容器。无法单个字符
无法进行类似操作： 字符串[0] = ”a“ del 字符串[0] 字符串.append(“a”)
你只能将变量指向另一个字符串(我想和java常量池是一个概念吧)

语法：下面对字符串的一系列操作(针对修改值得)，都不会改变原有的字符串，只是生成一个新字符串进行返回。
字符串[索引值] # 支持正向索引和反向索引
字符串.index(“and”) # 查找指定字符串 第一次出现的索引值
字符串.replace(字符串1，字符串2) # 它并不是修改字符串，它是生成一个新的字符串进行返回。
字符串.split(分割符) # 将字符串按照指定分隔符进行分割为多个字符串，并存入列表对象，返回list 列表对象。字符串本身是不会变换
字符串.strip（） # 去除字符串前后的空格以及回车
字符串.strip（字符串） # 去除字符串前后的指定字符串
例如： my_str = “12test and 21 test21”
my_str.strip(“12”) 输出为： “test and 21test”
这个去除字符串是按照单个字符进行去除的
字符串.count(字符串) # 指定字符串出现次数
len(字符串)

序列

序列是指：内容连续、有序，可以使用下标索引得一类数据容器
列表、元组、字符串均可以视为序列

序列操作操作----切片

切片：从一个序列中，取出一个子序列
例如： [1、2、3、4、5] —> [2、3、4] 这就是切片操作
语法： 序列[起始下标：结束下标：步长]
表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列
起始下标表示从何处开始，可以留空，留空表示从头开始
结束下标表示何处结束（不含末尾元素），留空视作截取到末尾，
步长表示，依次取元素的间隔
步长1：一个一个取元素
步长2：每次跳过1个元素取
步长为负数，反向取（起始下标和结束下标也要反向标记）
注意：此操作不会影响序列本身，而是会得到一个新的序列

总结分析：
列表可以修改，支持重复元素且有序
元组和字符串不可以修改，支持重复元素且有序

set集合

不支持重复元素，并且不是有序的
列表使用 ： []
元组使用 ： ()
字符串使用： “”
集合使用 ： {}

集合定义：
变量名 = {元素1，元素2…}
变量名 = set() # 定义一个空集合
类型是

集合无序，不支持索引访问。允许修改

下面程序运行多次，首先 3，6，9行代码打印结果顺序会不一样。每次取出元素也会不一样。
如果你放的是纯数字，那么结果都是一样的。

清空集合
集合.clear()

取两个集合的差集
集合1 . defference（集合2） 取出集合1和集合2的差集，（集合1有但是集合2没有的）
得到一个新集合，集合1和集合2不变

消除两个集合的相同元素
语法： 集合1 . difference_update（集合2）
功能： 对比集合1 和 集合2 ， 在集合1内，删除和集合2 相同的元素
结果： 集合1被修改，集合2 不变

合并两个集合
语法： 集合1 . union(集合2)
功能： 将集合1 和 集合2 组合成新集合
结果： 得到新集合，集合1和集合2不变

集合遍历
因为没有下标索引，所以只能使用for循环进行遍历

dict 字典

就和java的map集合是一样的， key----value的形式

定义字典：
变量名 = { key1 ： value1，key2 ： value2…}
定义空字典
变量名 = dict() 或者 变量名 = {}

key 值不允许重复，重复时，后面的会覆盖前面的。value可以时不同类型，也可以字典嵌套

字典嵌套

字典的操作

针对 字典的for循环，可以直接对字典for循环，不用先去取key

数据容器总结

数据容器有：
list 列表 ： 这个就和java数组类似，但是呢，类型不严格
truple 元组：这个就是不能只读的java数组，还是类型不严格
字符串：感觉这个没啥好说的
集合：对应java中的set集合，不能重复
字典：这个就是对应java的map集合

数据容器的通用操作：
len(容器) ：统计容器元素的个数
max(容器) ： 找出容器中的最大值
min(容器) ： 找出容器的最小值 # 字符串根据ASCII码（从前往后的一位一位的比较），字典根据key判断

容器的通用转换：
list(容器) 将给定容器转换为列表 # 字典转list只剩key值
tuple(容器) 将给定容器转换为元组 # 字段转元组 只剩key值
set(容器) 将给定容器转换为集合 # 数据无序，重复的删除，字典只有key
str(容器) 将给定容器转换为字符串

其他数据容器转字符串之后，都是原样的，只是输出的时候，将双引号省略了。

通用排序
语法： sorted(容器，reverse = True)
reverse = True ，默认false 升序，true降序
排序的结果 返回的是列表！！！！！！！！！所以字典排序会丢失value