1.数据容器
（1）定义：一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素，每一个元素，可以是任意类型的数据，如字符串、数字、布尔等。
（2）类别：列表（list）、元组（tuple）、字符串（str）、集合（set）、字典（dict）
2.列表（list）
（1）基本语法
# 字面量 [元素1,元素2,元素3,···] # 定义变量 变量名称 = [元素1,元素2,元素3,···] #定义空列表 变量名称=[] 变量名称=list()
列表内的每一个数据，称之为元素。
·以[]作为标识
·列表内每一个元素之间用，逗号隔开
·列表可以一次存储多个数据，且可以为不同的数据类型，支持嵌套,即元素也可以是列表。
eg:
list2 = [2,3]
list1 =[1,'name']
list3 = [[1,2,3],[4,5,6]]（2）列表的下表索引
1）列表中的每一个元素，都有其位置下标索引，从前向后的方向，从0开始，依次递增。只需按照下标索引，即可取得对应位置的元素。
语法：列表[下标索引]
eg:
list1 = ['apple','pear','pineapple']
print(list1[0]) # output:apple
print(list1[1]) # output:pear
print(list1[2]) # output:pineapple也可以反向索引，从后往前：从-1开始，依次递减（-1、-2、-3···）
list1 = ['apple','pear','pineapple']
print(list1[-1]) # output:pineapple
print(list1[-2]) # output:pear
print(list1[-3]) # output:apple2）如果列表是嵌套的列表，同样支持下标索引
语法：列表[下标索引][下标索引]
list3 = [[1,2,3],[4,5,6]]
print(list3[1][0]) # output：4
print(list3[0][1]) #output:2通过下标索引取数据，一定不要超出范围，否则会报错。
3）列表的常用操作（方法）
回忆：若将函数定义为class（类）的成员，那么函数会称之为：方法。
方法和函数功能一样，有传入参数，有返回值，只是方法的使用格式不同：
函数可以直接通过函数名，传入参数就可以直接调用了，而方法的调用，则需要先获得方法所在的class类对象，然后通过类对象里面一个点，把方法点出来即可，即class类对象.方法名（）。
·查找某元素的下标
功能：查找指定元素在列表的下标，如果找不到，报错ValueError
语法：列表.index（元素）（index就是列表对象（变量）内置的方法（函数））
list2 = [1,2,4,8]
index = list2.index(8)
print(index) # output:3·修改特定位置（索引）的元素值
功能：直接对指定下标（正向、反向下标均可）的值进行：直接赋值（修改）
语法：列表[下标]=值
list2 = [1,2,4,8]
list2[3] = 9
print(list2) # output:[1, 2, 4, 9]
·插入元素
语法：列表.insert（下标，元素），在指定的下标位置，插入指定的元素。
list2 = [1,2,4,8]
list2.insert(2,9)
print(list2) # output:[1, 2, 9, 4, 8]
·追加元素
语法：列表.append（元素），将指定元素，追加到列表的尾部。
list2 = [1,2,4,8]
list2.append(9)
print(list2) # output:[1, 2, 4, 8, 9]
·追加元素2
语法：列表.extend（其他数据容器），将其他数据容器的内容取出，依次追加到列表尾部。
list2 = [1,2,4,8]
list2.extend([3,9])
print(list2) # output:[1, 2, 4, 8, 3, 9]
·删除元素
语法1：del 列表[下标]
list2 = [1,2,4,8]
del list2[2]
print(list2) # output:[1, 2, 8]
语法2：列表.pop（下标）
list2 = [1,2,4,8]
list2.pop(2)
print(list2) # output:[1, 2, 8]
·删除某元素在列表中的第一个匹配项（从前到后搜索）
语法：列表.remove（元素）
list2 = [1,2,4,8]
list2.remove(2)
print(list2) # output:[1, 4, 8]
·清空列表内容
语法：列表.clear（）
list2 = [1,2,4,8]
list2.clear()
print(list2) # output:[]
·统计某元素在列表内的数量
语法：列表.count（元素）
list2 = [1,2,4,8,7,8,8]
print(list2.count(8)) # output:3
·统计列表内，有多少元素
语法：len（列表）
list2 = [1,2,4,8,7,8,8]
print(len(list2)) # output:7
4）列表的特点：
·可以容纳多个元素（上限为2**63-1、9223372036854775807个）
·可以容纳不同类型的元素（混装）
·数据是有序存储的（有下标序号）
·允许重复数据存在
·可以修改（增加或删除元素等）
5）list（列表）的遍历
将容器内的元素依次取出进行处理的行为，称之为：遍历、迭代。
·while循环
要素：
·使用列表[下标]的方式取出列表的元素。
·定义一个变量表示下标，从0开始，循环条件为下标值<列表的元素数量。
mylist = [21, 25, 21, 23, 22, 20]
def list_while_func():
i = 0
while i < len(mylist):
element = mylist[i]
print(f"{i+1}.{element}")
i +=1
list_while_func()
"""
output:
1.21
2.25
3.21
4.23
5.22
6.20
"""
# 6.20
·for循环
对比while，for循环更加适合对列表等数据容器进行遍历。
语法：
for 临时变量 in 数据容器：
对临时变量进行处理
表示，从容器内，依次取出元素并赋值到临时变量上，在每一次的循环中，可以对临时变量(元素进行处理）
def list_for_func():
mylist = [1,2,3,4,5]
for i in mylist:
print(i)
list_for_func()
"""
output:
1
2
3
4
5
"""while循环和for循环，都是循环语句，但细节不同：
·在循环控制上：
·while循环可以自定循环条件，并自行控制
·for循环不可以自定循环条件，只可以一个个从容器内取出数据。
·在无限循环上：
·while循环可以通过条件控制做到无限循环
·for循环理论上不可以，因为被遍历的容器容量不是无限的。
·在使用场景上：
·while循环适用于任何想要循环的场景
·for循环适用于，从数据容器内依次取出元素并处理的场景或简单的固定次数循环场景。
3.元组（tuple）
元组同列表一样，都是可以封装多个、不同类型的元素在内，但最大的不同点在于：元组一旦定义完成，就不可修改。（相当于只读的list）
（1）元组定义：定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型。
# 定义元组字面量
（元素，元素，·······）
# 定义元组变量
变量名称 = （元素，元素，········）
# 定义空元组
变量名称 = （）# 方式1
变量名称 = tuple（） # 方式2
注意：
元组只有一个数据，这个数据后面要添加逗号，否则不是元组类型。
t1=(1,)
print(type(t1)) # output:<class 'tuple'>
t2=(1)
print(type(t2)) # output:<class 'int'>元组可以进行嵌套：
t3=((1,2,3),(4,5,6))
print(type(t3)) # output:<class 'tuple'>下标索引取出内容：
t3=((1,2,3),(4,5,6))
print(t3[0][2]) # output:3（2）元组相关操作
·index() 查找某个数据，若数据存在返回对应的下标，否则报错
·count() 统计某个数据在当前元组出现的次数
·len（元组） 统计元组内的元素个数
·元组的遍历
t1 =(1,2,3)
index = 0
while index < len(t1):
print(t1[index])
index +=1
for i in t1:
print(i)（3）注意事项
·不可以修改元组的内容，否则会直接报错。
· 支持修改元组内的list的内容（修改元素、增加、删除、反转等）
t1=(1,3,[True,False])
t1[2][1]='best'
print(t1) # output:(1, 3, [True, 'best'])（4）元组特点
·可以容纳多个数据
·可以容纳不同类型的数据（混装）
·数据是有序存储的（下标索引）
·允许重复数据存在
·不可以修改（增加或删除元素等），可以修改内部list的内部元素
·支持for循环
4.字符串（str）
字符串是字符的容器，一个字符串可以存放任意数量的字符。
（1）字符串的下标（索引）
和其他容器如：列表、元组一样，字符串也可以通过下标进行访问。
·从前往后，下标从0开始
·从后往前，下标从-1开始
my_str = "Hello world"
print(my_str[4])
print(my_str[-7])
"""
output:
o
o
"""同元组一样，字符串是一个无法修改的数据容器。
所以修改指定下标的字符、移除特定下标的字符，追加字符等均无法完成。如果必须要做，只能得到一个新字符串，老的字符串是无法修改的。
（2）字符串的常用操作
·查找特定字符串的下标索引值
语法：字符串.index(字符串)
my_str = "Hello world"
print(my_str.index("world")) # output: 6·字符串的替换
语法：字符串.replace（字符串1，字符串2）
功能：将字符串内的全部：字符串1，替换为字符串2
注意：不是修改字符串本身，而是得到了一个新的字符串
my_str = "Hello world"
my_str2 = my_str.replace("Hello","my")
print(my_str)
print(my_str2)
"""
output:
Hello world
my world
"""·字符串的分割
语法：字符串.split(分隔符字符串）
功能：按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中
注意：字符串本身不变，而是得到了一个列表对象。
my_str = "Hello world"
my_str_list = my_str.split(" ")
print(my_str_list) # output:['Hello', 'world']
print(type(my_str_list)) # output: <class 'list'>·字符串的规整操作（去前后空格）
语法：字符串.strip()
my_str = " Hello world "
print(my_str.strip()) # output:"Hello world"·字符串的规整操作（去前后指定字符）
语法：字符串.strip(字符串）
my_str = "567Hello world765"
print(my_str.strip("567")) # output:"Hello world"注意：传入的是“567”，其实就是：“5”、“6”和“7”都会移除，是按照单个字符。
·统计字符串中某字符串的出现次数
语法：字符串.count("某字符串")
·统计字符串的长度/字符个数
语法：len(字符串)
（3）字符串的遍历
my_str = "Hello world"
i=0
while i<len(my_str):
print(my_str[i])
i += 1
for i in my_str:
print(i)
（4）字符串的特点
·只可以存储字符串
·长度任意（取决于内存大小）
·支持下标索引
·允许重复字符串存在
·不可以修改（增加或是删除元素等）
·支持for循环
5.序列
（1）定义：内容连续、有序，可使用下标索引的一类数据容器。
列表、元组、字符串，均可以视为序列。
（2）序列的操作——切片
序列支持切片，即：列表、元组、字符串，均支持进行切片操作。
切片：从一个序列中，取出一个子序列。
语法：序列[起始下标：结束下标：步长]
表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列：
·起始下标表示从何处开始，可以留空，留空视作从头开始。
·结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾。
·步长表示，依次取元素的间隙。
·步长1表示，一个个取出元素
·步长N表示，每次跳过N-1个元素取
·步长为负数表示，反向取（注意，起始下标和结束下标也要反向标记）
注意：
·起始可以省略，省略从头开始
·结束可以省略，省略到尾结束
·步长可以省略，省略步长为1（可以为负数，表示倒序执行）
6.集合（set）
·最主要的特点：不支持元素的重复（自带去重功能），并且内容无序
（1）定义：和列表、元组、字符串等定义基本相同：
·列表使用：[]
·元组使用：（）
·字符串使用：""
·集合使用：{}
（2）基本语法：
#定义集合字面量
{元素，元素，······，元素}
#定义集合变量
变量名称={元素，元素，······元素}
#定义空集合
变量名称=set()
（3）集合的常用操作——修改
·添加新元素
语法：集合.add(元素)。将指定元素，添加到集合内。
结果：集合本身被修改，添加了新元素。
my_set={3,7,9,7,8}
print(my_set) # Output:{8, 9, 3, 7}
my_set.add(10)
print(my_set) # Output:{3, 7, 8, 9, 10}·移除元素
语法：集合.remove(元素），将指定元素，从集合内移除。
结果：集合本身被修改，移除了元素。
my_set={3,7,9,7,8}
print(my_set) # Output:{8, 9, 3, 7}
my_set.remove(9)
print(my_set) # Output:{8, 3, 7}·从集合中随机取出元素
语法：集合.pop()
结果：会得到一个元素的结果，同时集合本身被修改，元素被移除
my_set={"hello","world",1,2}
i=my_set.pop()
print(i) # output:world
print(my_set) # output:{1, 2, 'hello'}·清空集合
语法：集合.clear()
结果：集合本身被清空
·取出2个集合的差集
语法：集合1.difference(集合2），取出集合1有而集合2没有的
结果：得到一个新集合，集合1和集合2不变
my_set1={"hello","world",1,2}
my_set2={1,2,3}
my_set3=my_set1.difference(my_set2)
print(my_set1) # output:{1, 2, 'hello', 'world'}
print(my_set2) # output:{1, 2, 3}
print(my_set3) # output:{'hello', 'world'}·消除2个集合的差集
语法:集合1.difference_update(集合2）
功能：对比集合1和集合2，在集合1内，删除和集合2相同的元素
结果：集合1被修改，集合2不变
my_set1={"hello","world",1,2}
my_set2={1,2,3}
my_set1.difference_update(my_set2)
print(my_set1) # output:{'hello', 'world'}
print(my_set2) # output:{1, 2, 3}
·2个集合合并
语法：集合1.union(集合2）
功能：将集合1和集合2组合成新集合
结果：得到新集合，集合1和集合2不变
my_set1={"hello","world",1,2}
my_set2={1,2,3}
my_set3=my_set1.union(my_set2)
print(my_set1) # output:{'hello', 2, 'world', 1}
print(my_set2) # output:{1, 2, 3}
print(my_set3) # output:{'hello', 2, 1, 3, 'world'}·统计集合元素数量
语法：len（集合）
·集合的遍历
ps:集合不支持下标索引，不能用while循环
my_set1={"hello","world",1,2}
for i in my_set1:
print(i)
"""
output:
hello
1
2
world
"""(4)集合的特点
·可以容纳多个数据
·可以容纳不同类型的数据（混装）
·数据是无序存储的（不支持下标索引）
·不允许重复数据存在
·可以修改（增加或删除元素等）
·支持for循环
7.字典（dict）
（1）定义：同样使用{}，不过存储的元素是一个个的：键值对。
# 定义字典字面量
{key:value,key:value,·······}
# 定义字典变量
my_dict={key:value,key:value,·······，key:value}
# 定义空字典
my_dict={} # 空字典定义方式1
my_dict=dict(） # 空字典定义方式2
dict1={"red":1,"green":2,"yellow":3,"green":4}
print(dict1)
# output:{'red': 1, 'green': 4, 'yellow': 3}Key是不允许重复的，因此重复添加等同于覆盖原有数据。
（2）字典数据的获取
字典同集合一样，不可以使用下标索引。但是字典可以通过Key值来取得对应的Value。
dict1={"red":1,"green":2,"yellow":3,"green":4}
print(dict1["red"]) # output: 1（3）字典的嵌套
字典的Key和Value可以是任意数据类型（Key不可为字典），那么就表明，字典可以嵌套。
score_dict={
"John":{
"Maths":87,
"English":90
},"Lucy":{
"Maths":92,
"English":85
},"Tom":{
"Maths":96,
"English":96
}
}
print(score_dict ["John"]["Maths"]) # output:87（4）字典的常用操作
注意：新增和更新元素语法一致，如果Key不存在即新增，如果Key存在即更新（Key不可重复）
·新增元素
语法：字典[Key]=Value
结果：字典被修改，新增了元素
score={"John":90,"Jane":96}
score["Jenny"]=89
print(score) # output:{'John': 90, 'Jane': 96, 'Jenny': 89}·更新元素
语法：字典[Key]=Value
结果：字典被修改，元素被更新
注意：字典Key不可以重复，所以对已存在的Key执行上述操作，就是更新Value值
score={"John": 90,"Jane": 96,"Jenny": 89}
score["Jenny"]= 97
print(score) # output: {'John': 90, 'Jane': 96, 'Jenny': 97}·删除元素
语法：字典.pop(Key)
结果：获得指定Key的Value，同时字典被修改，指定Key的数据被删除
score={"John": 90,"Jane": 96,"Jenny": 89}
score.pop("Jenny")
print(score) # output: {'John': 90, 'Jane': 96}·清空字典
语法：字典.clear(）
结果：字典被修改，元素被清空
score={"John": 90,"Jane": 96,"Jenny": 89}
score.clear()
print(score) # output: {}·获取全部的Key
语法：字典.keys()
结果：得到字典中的全部Key
score={"John": 90,"Jane": 96,"Jenny": 89}
keys=score.keys()
print(keys) # output:dict_keys(['John', 'Jane', 'Jenny'])·统计字典内的元素数据
语法：len(字典)
（5）遍历字典
1）通过获取全部的Key来完成遍历
score={"John": 90,"Jane": 96,"Jenny": 89}
keys=score.keys()
for key in keys:
print(key,score[key])
"""
output:
John 90
Jane 96
Jenny 89
"""2）直接对字典进行for循环，每一次循环都是直接得到key
score={"John": 90,"Jane": 96,"Jenny": 89}
keys=score.keys()
for key in score:
print(key,score[key])
"""
output:
John 90
Jane 96
Jenny 89
"""（6）字典的特点
·可以容纳多个数据
·可以容纳不同类型的数据
·每一份数据是KeyValue键值对
·可以通过Key获取到Value，Key不可重复（重复会覆盖）
·不支持下标索引
·可以修改（增加或删除更新元素等）
·支持for循环，不支持while循环
8.数据容器的总结对比
列表 元组 字符串 集合 字典
元素数量 支持多个 支持多个 支持多个 支持多个 支持多个
元素类型 任意 任意 仅字符 任意 Key:Value
（Key:除字典外任意类型 Value:任意类型）
下标索引 支持 支持 支持 不支持 不支持
重复类型 支持 支持 支持 不支持 不支持
可修改性 支持 不支持 不支持 支持 支持
数据有序 是 是 是 否 否
使用场景 可修改、可 不可修改、 一串字符 不可重复 以Key检索
重复的一批 可重复的 的记录场 的数据记 Value的数
数据记录 一批数据 景 录场景 据记录场
场景 场景 景
9.数据容器的通用操作
（1）遍历
·5类数据容器都支持for循环遍历
·列表、元组、字符串支持while循环，集合、字典不支持（无法下标索引）
（2）通用统计功能
·len(容器） 统计容器的元素个数
·max(容器） 统计容器的最大元素
·min(容器） 统计容器的最小元素
·list（容器） 将给定容器转换为列表
·tuple（容器） 将给定容器转换为元组
·str（容器） 将给定容器转换为字符串
·set（容器） 将给定容器转换为集合
score={"John": 90,"Jane": 96,"Jenny": 89}
str="abcdefg"
print(list(score))
print(list(str))
"""
output:
['John', 'Jane', 'Jenny']
['a', 'b', 'c', 'd', 'e', 'f', 'g']
"""
注意：字符串转列表、元组、集合，将字符串每一个元素都取出来了，作为列表或元组或集合的每一个元素；而字典转列表或元组或集合，会将字典的Value通通舍弃，只剩下Key。但是字典转换为字符串，Value值是不会被舍弃的。
我们的列表、元组、集合、字符串等都是没办法转成字典，因为缺少键值对的关键要素，但是反过来，字典是可以转换成别的容器的，转成字符串，其Value会保存，转成其他类型，Value就丢弃了。
（3）容器通用排序功能
·通用排序功能
sorted(容器，[reverse=True]） 将给定容器进行排序，对内容进行排序，然后放到列表之中
my_list=[3,6,4,7,2,9]
print(sorted(my_list))
# output: [2, 3, 4, 6, 7, 9]
print(sorted(my_list,reverse=True))
# output: [9, 7, 6, 4, 3, 2]reverse=True表示降序，得到一个排好序的列表。
10.字符串大小比较
引入：字符串所用的所有字符如大小写英文单词、数字、特殊符号等都有其对应的ASCII码表值
每一个字符都能对应上一个：数字的码值。
字符串进行比较就是基于数字的码值大小进行比较的。
字符串是按位比较，也就是一位位进行比较，只要有一位大，那么整体就大。
print('abc'>'abd')
# output: False
print('ab'>'a')
# output: True
print('A'>'a')
# output: False
扫一扫
5914
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
