python 五大容器

目录

一 Python中的数据容器

二 List（列表）

1，列表的特点

1.1 有序的，所以支持下标索引， (列表支持while，for 循环)

1.2 可以为不同的数据类型，支持嵌套

1.3 可以修改（增加或删除元素等）

1.4 允许重复数据存在 （与集合的不同点）

2，列表的格式

3，下标索引：

3.1 正向索引

3.2逆向索引

3.3嵌套索引

4列表的常用操作

4.1查询功能

4.2更改赋值功能

4.3插入功能

5 删除功能

5.1索引删除

5.2 指定元素print(name_list)

5.3 清空列表内容，

6查询功能

6.1 统计某元素在列表内的数量

6.2 统计列表内，有多少元素

三 元组

1 元组的特点

1.1 不可以修改

1.2 数据是有序存储的（下标索引）

1.3 可以为不同的数据类型，支持嵌套

1.4允许重复数据存在 （和列表一样可以允许数据重复，与集合的不同点）

2元组的格式

3元组的操作

四 字符串

1 字符串的格式和定义

2 字符串的特点

2.1 只可以存储字符串

2.2 支持下标索引

2.3 允许重复字符串存在

2.4 不可以修改（增加或删除元素等）

3字符串的常规操作

3.1通过下标获取特定位置的字符

3.2 查找特定字符串的下标索引值

3.3统计字符串中某字符串的出现次数

3.3统计字符串的长度

4字符串的特有操作

4.1字符串的替换

4.2字符串的分割

4.3字符串的规整操作（去除前后两端空格或其他指定字符）

5 序列的切片

5.1序列的定义

5.2切片的定义和格式

5.3序列的操作

五 集合

1 集合的格式

2 集合的特点

2.1 集合内不允许重复元素（去重）

2.2集合内元素是无序的（不支持下标索引）

2.3可以修改（增加或删除元素等）

2.4可以容纳不同类型的数据（混装）

3 集合的操作

3.1 添加和移除集合中的元素

3.2从集合中随机取出元素

3.3清空集合

3.4修改为和另外一个集合的差集

3.6 查看集合的元素数量      

六 字典

1 字典的定义与格式

2 字典的特点

2.1 可以容纳不同类型的数据

2.2 每一份数据是KeyValue键值对

2.3 可以通过Key获取到Value，Key不可重复（重复会覆盖）

2.4 不支持下标索引

2.5 可以修改（增加或删除更新元素等）

2.6 可以嵌套

3 字典的常用操作

3.1 新增和更新元素     

3.2删除元素

3.3清空字典     

3.4获取全部的key     

3.5计算字典内的全部元素（键值对）数量     

七 总结

---

一 Python中的数据容器

一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素

每一个元素，可以是任意类型的数据，如字符串、数字、布尔等。

数据容器根据特点的不同，如：

是否支持重复元素

是否可以修改

是否有序，等

分为5类，分别是：

列表（list）、元组（tuple）、字符串（str）、集合（set）、字典（dict）

二 List（列表）

1，列表的特点

1.1 有序的，所以支持下标索引， (列表支持while，for 循环)

1.2 可以为不同的数据类型，支持嵌套

1.3 可以修改（增加或删除元素等）

1.4 允许重复数据存在 （与集合的不同点）

2，列表的格式

列表内的每一个数据，称之为元素

以 [ ] 作为标识

列表内每一个元素之间用, 逗号隔开

name =['abc','666',True]

name1=[[1,2,3],[4,5,6]]

注意：列表可以一次存储多个数据，且可以为不同的数据类型，支持嵌套

3，下标索引：

3.1 正向索引

如图，列表中的每一个元素，都有其位置下标索引，从前向后的方向，从0开始，依次递增

我们只需要按照下标索引，即可取得对应位置的元素。

name_list=['tom','lily','sam']

print(name_list[0]) # 列表的第一个元素 结果是tom

3.2逆向索引

列表中的每一个元素，从后向前的方向，从-1开始，依次递减

print(name_list(-1)) # 从后往前第一个元素 结果是sam

3.3嵌套索引

如果列表是嵌套的列表，同样支持下标索引

name_list=[['tom','sam'],['lily','nannan']]

print(name_list[1][1]) #第2个列表的第2个元素，结果是nannan

4列表的常用操作

4.1查询功能

查找某元素的下标

功能：查找指定元素在列表的下标，如果找不到，报错ValueError

语法：列表.index(元素)

name_list=['tom','lily','sam']

print(name_list.index(o)) # 列表的第一个元素 结果是tom

4.2更改赋值功能

改特定位置（索引）的元素值：

语法：列表[下标] = 值

可以使用如上语法，直接对指定下标（正向、反向下标均可）的值进行：重新赋值（修改）

#正向下标

name_list=[1,2,3]

name_list[0]=4

print(name_list) #结果为[4,2,3]

#反向下标

name_list=[1,2,3]

name_list[-1]=4

print(name_list) #结果为[1,2,4]

4.3插入功能

插入元素：

语法：列表.insert(下标, 元素)，在指定的下标位置，插入指定的元素

name_list=[1,2,3]

name_list.insert(1,'a')

print(name_list) #结果为1,a,2,3 在第二个位置插入元素‘a’,其他元素往后挪

追加元素：

语法：列表.append(元素)，用于在列表末尾添加一个新的元素。这个元素可以是任何数据类型，如数字、字符串、列表、字典等。

name_list=[1,2,3]

name_list.append([4,5,6])

print(name_list) #结果为 [1,2,3,[4,5,6]]

语法：列表.extend(元素)，用于在列表末尾一次性追加另一个序列中的多个值（例如，另一个列表、元组、字符串等）。

name_list=[1,2,3]

name_list.extend([4,5,6])

print(name_list) #结果为[1,2,3,4,5,6]

# append 和extend 的区别是

append 是一个元素，不管加入的是单个元素，还是一个列表，字符串，元组等，单个元素加在列表元素后面，加入的是列表等就嵌套在列表中。而extend 加入的元素不管是单个元素还是列表，字符串等，都取出来依次加在列表后面。

5 删除功能

5.1索引删除

语法1： del 列表[下标]

name_list=[1,2,3]

del name_list[0]

print(name_list) # 结果是[2,3]

语法2：列表.pop(下标)

name_list=[1,2,3]

a=name_list.pop[0]

print(name_list) #结果为[2,3]

print(a) #结果为1,

pop和del 的区别是 pop是把列表中的指定元素取出来并且可以赋值给一个变量，而del仅仅是把列表中的指定元素删除

5.2 指定元素print(name_list)

语法：列表.remove(元素) 移除列表中第一个匹配的指定的元素

name_list=[1,2,3,2]

name_list.remove(2)

print(name_list) #结果为 [1,3,2]

5.3 清空列表内容，

语法：列表.clear()

name_list=[1,2,3,2]

name_list.clear()

print(name_list) #结果为 []

6查询功能

6.1 统计某元素在列表内的数量

语法：列表.count(元素) 统计指定元素在列表中的个数

name_list=[1,2,3,2]

name_list.count(2)

print(name_list.count(2)) #结果为2 列表中元素2一共有2个

6.2 统计列表内，有多少元素

语法：len(列表)

name_list=[1,2,3,2]

print(len(name_list)) #结果为4 列表中一共有4个元素

编号	使用方式	作用
1	列表.append(元素)	向列表中追加一个元素
2	列表.extend(容器)	将数据容器的内容依次取出，追加到列表尾部
3	列表.insert(下标, 元素)	在指定下标处，插入指定的元素
4	del 列表[下标]	删除列表指定下标元素
5	列表.pop(下标)	删除列表指定下标元素
6	列表.remove(元素)	从前向后，删除此元素第一个匹配项
7	列表.clear()	清空列表
8	列表.count(元素)	统计此元素在列表中出现的次数
9	列表.index(元素)	查找指定元素在列表的下标 找不到报错ValueError
10	len(列表)	统计容器内有多少元素

三 元组

1 元组的特点

1.1 不可以修改

1.2 数据是有序存储的（下标索引）

1.3 可以为不同的数据类型，支持嵌套

1.4允许重复数据存在 （和列表一样可以允许数据重复，与集合的不同点）

2元组的格式

变量名称=元素,元素,…,元素）

#定义空元组

变量名称=() #方式1

变量名称=tuple() #方式2

元组也支持嵌套

t1=((1,2,3),(4,5,6))

print(t1[0][0]) #结果为1

t1=(1,'hello',True)

t2=('a',)

注意事项 元组可以包含不同的数据类型,元组只有一个数据，这个数据后面要添加逗号

3元组的操作

编号	方法	作用
1	index()	查找某个数据，如果数据存在返回对应的下标，否则报错
2	count()	统计某个数据在当前元组出现的次数
3	len(元组)	统计元组内的元素个数

元组由于不可修改的特性，所以其操作方法非常少，其他的和列表的功能一样

元组的内容不可以被修改，但是元组内嵌套的其他的数据容器里的内容可以被修改，例如列表和字符串，但是不能直接替换或者修改嵌套的整个容器，只能修改里面的内容，因为修改整个容器就等于修改了元组的内容

t1=(1,2,3,[,'a','b','c'])

t1[3][1]=1

print(t1) #结果为[1,2,3,[1,'b','c']]

四 字符串

1 字符串的格式和定义

字符串是字符的容器，一个字符串可以存放任意数量的字符。

如，字符串："itheima"

2 字符串的特点

2.1 只可以存储字符串

2.2 支持下标索引

2.3 允许重复字符串存在

2.4 不可以修改（增加或删除元素等）

3字符串的常规操作

3.1通过下标获取特定位置的字符

t1='abcdefg'

print(t1[1]) #结果为b

同元组一样，字符串是一个：无法修改的数据容器，如果要修改字符串，如果必须要做，只能得到一个新的字符串，旧的字符串是无法修改

3.2 查找特定字符串的下标索引值

语法：字符串.index(字符串)

t1='abcdefg'

print(t1.index(b)) #结果为1

3.3统计字符串中某字符串的出现次数

语法：字符串.count(字符串)

t1='abcabcab'

print(t1.count('a')) #结果为3 因为a出现了3次

3.3统计字符串的长度

语法：len(字符串)

t1='a b c a b c a b 1 !'

print(len(t1)) #结果为20 每个数字，大小写字母，符号空格感叹号等，中文都是算一个字符

4字符串的特有操作

4.1字符串的替换

语法：字符串.replace(字符串1，字符串2）

功能：将字符串内的全部：字符串1，替换为字符串2

注意：因为字符串是不可以修改的，所以是得到了一个新字符串哦

t1='abcdefg'

t2=t1.replace('a','b')

print(t2) #结果为bbcdefg

print(t1) #结果为abcdefg 可以看到原字符串不变，是得到了一个新的字符串

4.2字符串的分割

语法：字符串.split(分隔符字符串）

功能：按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中

注意：字符串本身不变，而是得到了一个列表对象

t1='a b c d'

t2=t1.split(' ')

print(t1) #结果为a b c d

print(t2) #结果为'a','b','c','d' 可以看到，字符串按照给定的 进行了分割，变成多个子字符串，并存入一个列表对象中。

4.3字符串的规整操作（去除前后两端空格或其他指定字符）

语法：字符串.strip()

t1='!abcd!'

t2=t1.strip('!')

print(t1) # '!abcd!'

print(t2) # abcd

# 同列表、元组一样，字符串也支持while循环和for循环进行遍历

5 序列的切片

5.1序列的定义

序列是指：内容连续、有序，可使用下标索引的一类数据容器

列表、元组、字符串，均可以可以视为序列。序列的典型特征就是：有序并可用下标索引，字符串、元组、列表均满足这个要求

5.2切片的定义和格式

切片：从一个序列中，取出一个子序列

语法：序列[起始下标:结束下标:步长]

表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列：

起始下标表示从何处开始，可以留空，留空视作从头开始

结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾

步长表示，依次取元素的间隔

步长1表示，一个个取元素

步长2表示，每次跳过1个元素取

步长N表示，每次跳过N-1个元素取

步长为负数表示，反向取（注意，起始下标和结束下标也要反向标记）

注意，此操作不会影响序列本身，而是会得到一个新的序列（列表、元组、字符串）

5.3序列的操作

序列的切片演示

my_list = [1, 2, 3, 4, 5]

new_list = my_list[1:4] # 下标1开始，下标4（不含）结束，步长1

print(new_list) # 结果：[2, 3, 4]

my_tuple = (1, 2, 3, 4, 5)

new_tuple = my_tuple[:] # 从头开始，到最后结束，步长1

print(new_tuple) # 结果：(1, 2, 3, 4, 5)

my_list = [1, 2, 3, 4, 5]

new_list = my_list[::2] # 从头开始，到最后结束，步长2

print(new_list) # 结果：[1, 3, 5]

my_str = "12345"

new_str = my_str[:4:2] # 从头开始，到下标4（不含）结束，步长2

print(new_str) # 结果："13"

my_str = "12345"

new_str = my_str[::-1] # 从头（最后）开始，到尾结束，步长-1（倒序）

print(new_str) # 结果："54321"

my_list = [1, 2, 3, 4, 5]

new_list = my_list[3:1:-1] # 从下标3开始，到下标1（不含）结束，步长-1（倒序）

print(new_list) # 结果：[4, 3]

my_tuple = (1, 2, 3, 4, 5)

new_tuple = my_tuple[:1:-2] # 从头（最后）开始，到下标1(不含)结束，步长-2（倒序）

print(new_tuple) # 结果：(5, 3)

五 集合

1 集合的格式

 # 定义集合变量

t1={元素,元素,元素}

# 定义空集合

t1=set()

2 集合的特点

2.1 集合内不允许重复元素（去重）

因为集合不允许有重复元素，所以当集合内的元素出现了重复，或者把有重复元素的数据容器放进集合中，集合会自动去重.

 这里经常用集合的这一特性来对其他数据容器实现去重的功能

t1 ={1,2,3,3,4}

print(t1)   #结果是1，2，3，4  集合对元素3进行了去重

2.2集合内元素是无序的（不支持下标索引）

所以集合不支持while循环，但支持for循环

2.3可以修改（增加或删除元素等）

2.4可以容纳不同类型的数据（混装）

3 集合的操作

首先，因为集合是无序的，所以集合不支持：下标索引访问 但是集合和列表一样，是允许修改的，所以我们来看看集合的修改方法。

3.1 添加和移除集合中的元素

添加新元素      

语法：集合.add(元素)。将指定元素，添加到集合内      

结果：集合本身被修改，添加了新元素

t1=set{}

t1.add('a')

print(t1)  a

移除元素

语法：集合.remove(元素)，将指定元素，从集合内移除      

结果：集合本身被修改，移除了元素

t1={'a','b','c','d'}

t1.remove(‘a')

print(t1)  #结果为 b，c，d

3.2从集合中随机取出元素

语法：集合.pop()，功能，从集合中随机取出一个元素      

结果：会得到一个元素的结果。同时集合本身被修改，元素被移除

t1={'a','b','c','d'}

t2=t1.pop('a')        从集合t1取出元素a 放到集合t2中， t1,t2都发生了改变

print(t1)   #结果为b,c,d

print(t2)   #结果为 a     

3.3清空集合

语法：集合.clear()，功能，清空集合      

结果：集合本身被清空

t1={'a','b','c','d'}

t1.clear()

print(t1)   #结果为set()

3.4修改为和另外一个集合的差集

语法：集合1.difference_update(集合2)      

功能：对比集合1和集合2，在集合1内，删除和集合2相同的元素。      

结果：集合1被修改，集合2不变

t1={1,2,3,4}

t2={2,3,4,5}

t1.difference_update(t2)   #在集合t1中删除t1和t2中相同的元素 2,3,4 

print(t1)    # 1

print(t2)   #  集合t2不变，还是2,3,4,5

3.5 修改为和另外一个集合的并集      

语法：集合1.update(集合2)      

功能：将集合1和集合2组合成新集合

 set1 = {1,2,3}  

set2 = {1,5,6}  

set1.update(set2)  

结果:  set1 = {1,2,3,5,6}  set2 = {1,5,6}      

结果：修改集合1:保留和集合2的并集,集合2不变

3.6 查看集合的元素数量      

语法：len(集合)      

功能：统计集合内有多少元素      

结果：得到一个整数结果

set1 ={1,2,3}

print(set1)  #结果为3 集合中有3个元素

六 字典

1 字典的定义与格式

字典的定义，同样使用{}，不过存储的元素是一个个的：键值对，如下语法：

#定义字典变量

my_dict={key:value,key:value,key:value}

#定义空字典

my_dict={}

my_dict=dict()

使用{}存储原始，每一个元素是一个键值对

每一个键值对包含Key和Value（用冒号分隔）

键值对之间使用逗号分隔

注意: key不能是可变类型

Value可以是任意类型的数据

Key不可重复，重复会对原有数据覆盖

my_dict={'a':1,'b':2,'c':3}

2 字典的特点

2.1 可以容纳不同类型的数据

2.2 每一份数据是KeyValue键值对

2.3 可以通过Key获取到Value，Key不可重复（重复会覆盖）

2.4 不支持下标索引

字典同集合一样，不可以使用下标索引 但是字典可以通过Key值来取得对应的Value

my_dict={'a':1,'b':2,'c':3}

print(my_dict['a']) #结果为 1

2.5 可以修改（增加或删除更新元素等）

2.6 可以嵌套

字典的Key不能是可变类型数据,Value可以是任意数据类型

那么，就表明，字典是可以嵌套的 需求如下：记录学生各科的考试信息

从这里可以看出，字典里的value又是一个字典        

3 字典的常用操作

3.1 新增和更新元素     

语法：字典[Key] = Value，

结果：字典被修改，新增了元素

stu_score={'王力宏':77,'周杰伦':88,’林俊杰‘:99}

#新增张学友的成绩

stu_score['张学友']=66

print(stu_score)  #结果为{'王力宏':77,'周杰伦':88,’林俊杰‘:99,'张学友':66}

#修改张学友的成绩

stu_score['张学友']=100

print(stu_score)  #结果为{'王力宏':77,'周杰伦':88,’林俊杰‘:99,'张学友':100}

字典中的key有对应值则为修改，如果没有key的对应值，则为新增

3.2删除元素

语法：字典.pop(Key)，

结果：获得指定Key的Value，同时字典被修改，指定Key的数据被删除

stu_score={'王力宏':77,'周杰伦':88,’林俊杰‘:99}

value=stu_score.pop('王力宏')

print(value)    # 结果为77   从字典中取出对应key的value值并赋值给value

print(stu_score)  #结果为{'周杰伦':88,’林俊杰‘:99}   字典中的对应的键值对被取出。

3.3清空字典     

语法：字典.clear()，

结果：字典被修改，元素被清空

stu_score={'王力宏':77,'周杰伦':88,’林俊杰‘:99}

stu.score.clear()

print(stu_score) #结果为dict()

3.4获取全部的key     

语法：字典.keys()，

结果：得到字典中的全部Key

stu_score={'王力宏':77,'周杰伦':88,’林俊杰‘:99}

keys=stu_score.keys()

print(keys)   #结果为{'王力宏','周杰伦',’林俊杰’}

3.5计算字典内的全部元素（键值对）数量     

语法：len(字典)     

结果：得到一个整数，表示字典内元素（键值对）的数量

stu_score={'王力宏':77,'周杰伦':88,’林俊杰‘:99}

len(stu_score)

print(stu_score)    #结果为3

七 总结

数据容器可以从以下视角进行简单的分类：

是否是序列

序列：列表 元组 字符串

非序列: 集合  字典

是否是可变类型

可变类型：列表、集合、字典

不可变类型：元组、字符串

作者：cent un