写在前面
数据容器时指一种可存储多个元素的Python数据类型，主要包含list(列表)、tuple(元组)、str(字符串)、set(集合)、dict(字典)。
一、列表
9.1.1 列表定义
定义新的列表：
变量名称 = [元素1, 元素2, 元素3, 元素4, ....]
定义空列表:
变量名称 = []
变量名称 = list()
9.1.2 嵌套列表
列表中的元素比较灵活，可以均互不相同：
# 可以发现，下面列表的三个元素均不同
bioinformatic = [2023, 'Biomamba',True]
print(type(bioinformatic))
# 这意味着列表里可以"套"列表，称为嵌套列表
## <class 'list'>
bioinformatic = [2023, 'Biomamba',True,[2023, 'subBiomamba',True]]
print(type(bioinformatic))
## <class 'list'>
9.1.3 列表下标索引
列表中元素的索引有些反人类，第一个元素的索引编号为0，第二个索引编号为1，一次类推，可用list[索引编号的方式取出]
bioinformatic = [2023, 'Biomamba',True]
print(bioinformatic[0])
## 2023
print(bioinformatic[1])
## Biomamba
print(bioinformatic[2])
## True
不仅可以正着数，列表索引还支持倒着数，最后一个元素的索引为-1，倒数第二个的索引为-2，依次类推：
bioinformatic = [2023, 'Biomamba',True]
print(bioinformatic[-1])
## True
print(bioinformatic[-2])
## Biomamba
print(bioinformatic[-3])
## 2023
那么问题来了，嵌套的索引如何取出元素呢：
# 取出subBiomamba这个元素
bioinformatic = [2023, 'Biomamba',True,[2023, 'subBiomamba',True]]
print(bioinformatic[3][1])
# 倒着取：
## subBiomamba
print(bioinformatic[-1][-2])
## subBiomamba
记得索引不要超出范围，否则会报错list index out of range：
9.1.4 list中的方法与操作
list.index(元素) 该方法可以根据元素的内容找出元素在列表中对应的下标：
bioinformatic = [2023, 'Biomamba',True,[2023, 'subBiomamba',True]]
bioinformatic.index('Biomamba')
#返回了`Biomamba`字符所在的正向索引：
## 1
# 若查找的元素不存在，则会报错：
bioinformatic.index('Bioinformatics')
ValueError: ‘Bioinformatics’ is not in list
修改已有元素值
bioinformatic[1] = "我是一个修改后的元素"
print(bioinformatic)
# 可以看到bioinformatic这个列表中索引1对应的元素已被替换：
## [2023, '我是一个修改后的元素', True, [2023, 'subBiomamba', True]]
插入新元素
bioinformatic.insert(1,'新插入的元素')
print(bioinformatic)
# 可以看到元素被插入索引1的位置，后面的元素被依次推后
## [2023, '新插入的元素', '我是一个修改后的元素', True, [2023, 'subBiomamba', True]]
追加元素
# 如果像R语言那样输入一个不存在的索引去追加，就会出现如下报错
bioinformatic[6] = '我是一个追加的元素'
IndexError: list assignment index out of range
# 通过append方法可以做到我们设想的追加功能：
bioinformatic.append('我是一个追加的元素')
print(bioinformatic)
# 只能写入尾部
## [2023, '新插入的元素', '我是一个修改后的元素', True, [2023, 'subBiomamba', True], '我是一个追加的元素']
追加多个元素
list.append的方式只能向尾部添加单个字面量，而list.extend可以直接把其它数据容器中的内容整个取出，依次追加到列表尾部：
new_list = [1,2,3]
print(new_list)
## [1, 2, 3]
bioinformatic.extend(new_list)
print(bioinformatic)
## [2023, '新插入的元素', '我是一个修改后的元素', True, [2023, 'subBiomamba', True], '我是一个追加的元素', 1, 2, 3]
元素删除
# 方式一
# del 列表[下标]
print(bioinformatic)
## [2023, '新插入的元素', '我是一个修改后的元素', True, [2023, 'subBiomamba', True], '我是一个追加的元素', 1, 2, 3]
del bioinformatic[-1]
print(bioinformatic)
## [2023, '新插入的元素', '我是一个修改后的元素', True, [2023, 'subBiomamba', True], '我是一个追加的元素', 1, 2]
# 方式二
# 列表.pop(下标)
print(bioinformatic)
## [2023, '新插入的元素', '我是一个修改后的元素', True, [2023, 'subBiomamba', True], '我是一个追加的元素', 1, 2]
bioinformatic.pop(-1)
## 2
print(bioinformatic)
## [2023, '新插入的元素', '我是一个修改后的元素', True, [2023, 'subBiomamba', True], '我是一个追加的元素', 1]
# pop方法的实质是从列表中取出对应元素，因此，pop方法可以返回对应的值：print(bioinformatic)
## [2023, '新插入的元素', '我是一个修改后的元素', True, [2023, 'subBiomamba', True], '我是一个追加的元素', 1]
my_value = bioinformatic.pop(-1)
print(my_value)
## 1
# 方式3 list.remove()
new_list = ['num_1','num_2','num_3','num_1','num_4']
new_list.remove('num_1')
print(new_list)
# 可以看出remove方法通过给定内容，在列表中正序检索，删除对应的元素
## ['num_2', 'num_3', 'num_1', 'num_4']
列表清空
print(new_list)
## ['num_2', 'num_3', 'num_1', 'num_4']
new_list.clear()
print(new_list)
## []
统计某一内容在列表中的数量
new_list = ['Biomamba','bioinformatics','Biomamba','Biomamba']
new_list.count('Biomamba')
## 3
统计列表中元素数量
len(new_list)
## 4
9.1.5 遍历列表
由于列表的索引结构，我们可以让列表的索引与循环发生一些交互：
while循环：
my_list = ['Biomamba_1','Biomamba_2','Biommaba_3']
temp_num = 0
while temp_num < len(my_list):
print(f"这是list中的第{temp_num+1}个元素，它的索引为:{temp_num},它的值为{my_list[temp_num]}")
temp_num += 1
## 这是list中的第1个元素，它的索引为:0,它的值为Biomamba_1
## 这是list中的第2个元素，它的索引为:1,它的值为Biomamba_2
## 这是list中的第3个元素，它的索引为:2,它的值为Biommaba_3
for循环
my_list = ['Biomamba_1','Biomamba_2','Biommaba_3']
for temp_ele in my_list:
print(f"这是list中的第{my_list.index(temp_ele)+1}个元素，它的索引值为：{my_list.index(temp_ele)+1},它的值为{temp_ele}")
temp_num += 1
## 这是list中的第1个元素，它的索引值为：1,它的值为Biomamba_1
## 这是list中的第2个元素，它的索引值为：2,它的值为Biomamba_2
## 这是list中的第3个元素，它的索引值为：3,它的值为Biommaba_3
二、元组
9.2.1 元组的定义格式
元组与列表一样，是可封装多个、不同类型的元素的数据容器。但元组一旦定义，便不可修改、不可修改、不可修改(重说三)。
元组的定义方法主要有以下几种方式：
定义元组字面量
(元素,元素,元素,…,元素,)
('Biomamba',2023,'bioinformatic')
## ('Biomamba', 2023, 'bioinformatic')
定义元组变量
变量名 = (元素,元素,元素,…,元素,)
my_tuple = ('Biomamba',2023,'bioinformatic')
print(my_tuple)
## ('Biomamba', 2023, 'bioinformatic')
定义空元组
变量名称 = () 变量名称 = tuple()
print(tuple())
## ()
print(type(tuple()))
## <class 'tuple'>
单元素元组
单元素的元组需要在元素后加上一个”,“，否则默认为字串类型
# 不加逗号
print(type(('Biomamba')))
# 加上一个逗号
## <class 'str'>
print(type(('Biomamba',)))
## <class 'tuple'>
9.2.2 元组元素索引
无需过多介绍，与列表的索引使用方法基本一致，甚至各类方法也一致：
my_tuple = ('Biomamba',2023,'Biomamba','bioinformatic')
print(my_tuple[0])
## Biomamba
print(my_tuple[-1])
## bioinformatic
print(my_tuple.index('Biomamba'))
## 0
print(my_tuple.count('Biomamba'))
## 2
9.2.3 元组修改
# 简单元素的元组不可修改
my_tuple = ('Biomamba',2023,'Biomamba','bioinformatic')
my_tuple[0] = '我是一个修改后的数据'
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
Cell In[292], line 3
1 # 简单元素的元组不可修改
2 my_tuple = ('Biomamba',2023,'Biomamba','bioinformatic')
----> 3 my_tuple[0] = '我是一个修改后的数据'
TypeError: 'tuple' object does not support item assignment
# 当元组里有列表内容时：
my_tuple = ('Biomamba',2023,'Biomamba','bioinformatic',['subBiomamba',2023,'subBiomamba','subbioinformatic'])
# 可以进行修改
my_tuple[-1][1] = "我是一个修改后的数据"
print(my_tuple[-1][1] )
三、字符串
字符串是字符的容器，一个字符串可以存放任意数量的字符(只要内存够大，字符串长度就可继续增加)
9.3.1 字符串格式化
字符串格式化的内容我们在5.1.2中已经提前详细介绍过，此处不再重复
9.3.2 字符串索引
注意字符串的索引为对应字节的索引，而非”单词”的索引，例如：
my_chr = 'I am Biomamba'
print(my_chr[0])
## I
print(my_chr[2])
## a
print(my_chr[-1])
## a
print(f"注意，空格也占一个字节：这里有一个空格：{my_chr[1]}。")
## 注意，空格也占一个字节：这里有一个空格：。
# 各类方法也依旧可以使用：
print(my_chr.index('a'))
# 也支持多个字符的检索
## 2
print(my_chr.index('Biomamba'))
# 返回的索引是多字符的起始索引
## 5
9.3.3 字符串替换
字符串有一个list与tuple不具备的方法：.replace。顾名思义，这一方法可以做字符串的替换:
# 当元组里有列表内容时：
my_tuple = ('Biomamba',2023,'Biomamba','bioinformatic',['subBiomamba',2023,'subBiomamba','subbioinformatic'])
# 可以进行修改
my_tuple[-1][1] = "我是一个修改后的数据"
print(my_tuple[-1][1] )
print(new_mychr)
# 可以看出，原本的字符串并没有发生改变
# 即.replace并不是修改原字符串，而是替换原字符串内容后输出了一个新的字符串
## I am the autuor of this tutorial
9.3.4 字符串分割
通过.split(分隔符)可以对字符串进行分割，分隔后的数据类型为list
# 例如这里我有三段话，我希望通过句号来分割。
my_chr = 'I am Biomamba. I am the autuor of this tutorial. Today is Friday'
split_result = my_chr.split('.')
print(split_result)
## ['I am Biomamba', ' I am the autuor of this tutorial', ' Today is Friday']
print(type(split_result))
# 分割后的结果为返回的list
## <class 'list'>
9.3.5 字符串规整操作
用于去除字符串中的一些字符，语法:
字符串.strip(字符)
# 不传入任何参数，既是去除字符串首尾空格以及换行符
my_chr = ' I am Biomamba '
print(my_chr)
## I am Biomamba
print(my_chr.strip())
# 空格本来就是隐藏的，不太能看出来
# 大家可以通过下面的缩进体会：
## I am Biomamba
my_chr = 'I am Biomamba'
print(my_chr)
## I am Biomamba
my_chr = 'I am Biomamba'
print(my_chr)
## I am Biomamba
9.3.6 统计字符串出现次数
my_chr = 'I am Biomamba'print(my_chr.count('am'))# 这时输入字符作为一个整体用于字数统计
## 2
9.3.7 字符串个数(长度)统计
len('I am Biomamba')
## 13
9.3.8 字符串遍历
与此前其它数据容器的操作方法类似：
my_chr = 'I am Biomamba'
for temp_chr in my_chr:
print(f"{temp_chr}是字符串的第{my_chr.index(temp_chr)}个字符")
## I是字符串的第0个字符
## 是字符串的第1个字符
## a是字符串的第2个字符
## m是字符串的第3个字符
## 是字符串的第1个字符
## B是字符串的第5个字符
## i是字符串的第6个字符
## o是字符串的第7个字符
## m是字符串的第3个字符
## a是字符串的第2个字符
## m是字符串的第3个字符
## b是字符串的第11个字符
## a是字符串的第2个字符
四、序列及序列切片
序列为内容连续、有序、可使用下标索引的一类数据容器。我们此前介绍的列表、元组、字符串均属于序列。
序列切片：从一个序列中取出一个子序列，序列切片的操作并不会影响序列本身，而是得到一个新的序列。语法为：
序列[起始下标:结束下标:步长]
若起始下标留空视为从头开始，若结束下标留空视作截取到结尾，步长为依次取元素的间隔，若步长省略则视为1。注意，取出的内容不包含结束下标本身
my_chr = ['num_1','num_2','num_3','num_4','num_5','num_6','num_7','num_8','num_9']print(my_chr[1:4]) # 省略步长#
这样用起来还是跟R语言非常类似的
# 但是不包含索引4本身，即实际取的索引为1、2、3
## ['num_2', 'num_3', 'num_4']
# 来一个究极省略的，省略起始下标、结束下标、步长：
print(my_chr[:])
# 这时整个序列会被输出
## ['num_1', 'num_2', 'num_3', 'num_4', 'num_5', 'num_6', 'num_7', 'num_8', 'num_9']
# 省略起始步长为3切片print(my_chr[::3])
## ['num_1', 'num_4', 'num_7']
# 在1到6个索引中以步长为2进行切片
print(my_chr[0:5:2])
## ['num_1', 'num_3', 'num_5']
# 反向切片也支持
print(my_chr[-1:-6:-2])
# 步长也需要为负数
# 那么给出的结果顺序为原序列的倒序
## ['num_9', 'num_7', 'num_5']
五、集合
集合(set)是一个无序的不重复元素。而此前介绍的列表、元组均是有序且可出现重复元素的。由于集合的无序性，自然也就不支持通过下标索引进行访问。但集合支持修改。
9.5.1 定义集合
定义集合字面量
{元素,元素,元素,...,元素}
定义集合变量
变量名称 = {元素,元素,元素,...,元素}
定义空集合
变量名称 = set()
例如:
# 定义集合
my_set = {'Biomamba',2023,'Biomamba'}
print(my_set)
# 可以看到重复的'Biomamba'字样被直接去除
## {'Biomamba', 2023}
9.5.2 集合修改
# 添加集合元素
my_set = {'Biomamba',2023,'Biomamba'}
my_set.add('Study Python') #没有返回值，直接修改原集合
print(my_set)
# 可以看到Study Python被添加
## {'Biomamba', 'Study Python', 2023}
# 删除集合元素
my_set = {'Biomamba',2023,'Biomamba'}
my_set.remove(2023)
print(my_set)
## {'Biomamba'}
9.5.3 取出集合元素
由于集合没有下标索引，.pop也就没有任何参数，只能随机取出集合重的一个元素并给出返回值。
# 删除集合元素
my_set = {'Biomamba',2023}
my_set.pop()
## 'Biomamba'
print(my_set)
## {2023}
9.5.4 清空集合
与各类序列的清空方法类似
my_set = {'Biomamba',2023}
my_set.clear()
print(my_set)
# 清空并不是删除，还会存在一个空集合：
## set()
9.5.5 集合取差集
# 返回的结果是在my_set1中包含，但在my_set2中不包含的元素
my_set1 = {'Biomamba',2023,'Study Python'}
my_set2 = {'Biomamba',2023,'Study R'}
my_set3 = my_set1.difference(my_set2)
print(my_set3)
## {'Study Python'}
# 但对原集合本身的值无任何影响
print(my_set1)
## {'Biomamba', 'Study Python', 2023}
print(my_set2)
## {'Biomamba', 'Study R', 2023}
# 在集合1内，删除与集合2相同的元素
my_set1 = {'Biomamba',2023,'Study Python'}
my_set2 = {'Biomamba',2023,'Study R'}
my_set1.difference_update(my_set2)
print(my_set1)
# 也就是把集合一直接变成上一步的差集，但集合2不会发生变化
## {'Study Python'}
print(my_set2)
## {'Biomamba', 'Study R', 2023}
9.5.6 集合合并
my_set1 = {'Set1','Biomamba',2023,'Study Python'}
my_set2 = {'Set2','Biomamba',2023,'Study R'}
my_set3 = my_set1.union(my_set2)
print(my_set3)
## {'Biomamba', 'Set2', 2023, 'Set1', 'Study Python', 'Study R'}
9.5.7 统计集合元素数量
len(my_set3)
## 6
9.5.8 遍历集合
由于集合不存在下标索引，那么while循环的方式无法应用于集合，但for循环依旧可以使用
# 利用for循环遍历打印出集合内的元素
my_set = {'Set1','Biomamba',2023,'Study Python'}
for temp_set in my_set:
print(temp_set)
## Set1
## Biomamba
## Study Python
## 2023
六、字典
字典是Python中的可变容器模型，且可存储任意类型对象。有些类似于哈希，可以通过特定的键值(key)返回对应的内容(value)
字典的key和value可以是任意数据类型，但key不可为字典类型。
9.6.1 字典定义
字典的每个键值对key:value用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中 ,格式如下所示：
d = {key1 : value1, key2 : value2 }
例如如下的字典:
mydict = {"name":"Biomamba","Date":2023,"major":"Bioinformatics"}
print(mydict)
## {'name': 'Biomamba', 'Date': 2023, 'major': 'Bioinformatics'}
定义空字典:
mydict = {}
print(mydict)
## {}
或者用函数定义空字典:
mydict = {}
print(mydict)
## {}
print(type(mydict))
## <class 'dict'>
字典会自动去除重复的key所在键值对:
mydict = {"name":"Biomamba","name":"Bioinformatic-base","Date":2023}print(mydict) # 可以看出保留的是最后一个重复的key对应的值
## {'name': 'Bioinformatic-base', 'Date': 2023}
9.6.2 字典值的获取
字典也不支持下标索引，可以通过字典[key]获取对应的值，例如：
mydict = {"name":"Biomamba","Date":2023,"major":"Bioinformatics"}
print(mydict["name"])
## Biomamba
9.6.3 字典嵌套
例如value可以是一个子字典:
mydict = {
'information':{
'language':'python',
'skill':'scRNA-Seq'},
'Date':{
'year':2023},
'month':5,
'Day':4}
print(mydict)
## {'information': {'language': 'python', 'skill': 'scRNA-Seq'}, 'Date': {'year': 2023}, 'month': 5, 'Day': 4}
# 获取嵌套字典的内容，例如查询information里的language对应的值：
print(mydict["information"]["language"])
## python
9.6.4 修改字典
新增元素
mydict = {"name":"Biomamba"}
print(mydict)
## {'name': 'Biomamba'}
mydict["Date"] = 2023
print(mydict) # 可以看出无需再赋值给原字典，也可以添加元素
## {'name': 'Biomamba', 'Date': 2023}
更新元素
由于字典的key无法重复，因此对已存在的key执行类似于添加的操作，即可更新value值
mydict = {"name":"Biomamba","Date":2023}
print(mydict)
## {'name': 'Biomamba', 'Date': 2023}
mydict["Date"] = 2000
print(mydict) # 可以看出无需再赋值给原字典，也可以添加元素
## {'name': 'Biomamba', 'Date': 2000}
删除同时取出元素
mydict = {"name":"Biomamba","Date":2023}
print(mydict)
## {'name': 'Biomamba', 'Date': 2023}
newdict = mydict.pop('Date')
print(mydict)
## {'name': 'Biomamba'}
print(newdict)
## 2023
清空字典
mydict = {"name":"Biomamba","Date":2023}
print(mydict)
## {'name': 'Biomamba', 'Date': 2023}
mydict.clear()
print(mydict)
## {}
获取字典中全部的key
mydict = {"name":"Biomamba","Date":2023}
mykeys = mydict.keys()
print(mykeys)
## dict_keys(['name', 'Date'])
获取字典的元素数量
mydict = {"name":"Biomamba","Date":2023}
len(mydict)
## 2
9.6.5 遍历字典
通过获得的key遍历字典：
mydict = {"name":"Biomamba","Date":2023,"major":"Bioinformatics"}
for mytemp in mydict.keys():
print(f"键值{mytemp}对应的value为:{mydict[mytemp]}")
## 键值name对应的value为:Biomamba
## 键值Date对应的value为:2023
## 键值major对应的value为:Bioinformatics
直接用for循环遍历字典，获得的临时变量就是key值:
mydict = {"name":"Biomamba","Date":2023,"major":"Bioinformatics"}
for mytemp in mydict:
print(f"键值{mytemp}对应的value为:{mydict[mytemp]}")
## 键值name对应的value为:Biomamba
## 键值Date对应的value为:2023
## 键值major对应的value为:Bioinformatics
因为字典没有下标索引，因此无法直接用于while循环，若通过len来取key的值则有些低效且不优雅:
mydict = {"name":"Biomamba","Date":2023,"major":"Bioinformatics"}
mylen = len(mydict)
print(mylen)
## 3
temp_len = 0
while temp_len < mylen:
print(f"键值{list(mydict.keys())[temp_len]}对应的value为:{mydict[list(mydict.keys())[temp_len]]}")
temp_len += 1
# 多写了很多行
## 键值name对应的value为:Biomamba
## 键值Date对应的value为:2023
## 键值major对应的value为:Bioinformatics
七、总结
9.7.1 分类
是否支持下标索引:
支持: 列表、元组、字符串 - 序列类型
不支持：集合、字典 - 非序列类型
是否支持重复元素:
支持：列表、元组、字符串 - 序列类型
不支持：集合、字典 - 非序列类型
是否可以修改：
支持：列表、集合、字典 - 序列类型
不支持：元组、字符串 - 非序列类型
是否支持遍历:
for循环：五类数据容器都支持
while循环：列表、元组、字符串支持，集合、字典无法直接参与while循环
9.7.2 通用操作
max()：得到最大的元素
min()：得到最小的元素
sorted(容器,[reverse = False])：ASCII码升序排序
sorted(容器,[reverse = True])：ASCII码降序排序
9.7.3 容器相互转换
list(其它容器)
tuple(其它容器)
str(其它容器)
set(其它容器)
往期回顾
如何联系我们
公众号后台消息更新不及时，超过48h便不允许回复读者消息，这里给大家留一下领取资料、免费服务器(有root权限的共享服务器,注册即送200￥)的微信号，方便各位随时交流、提建议(科研任务繁重，回复不及时请见谅)。此外呼声一直很高的交流群也建好了，欢迎大家入群讨论：永久免费的千人生信、科研交流群
大家可以阅读完这几篇之后添加
给生信入门初学者的小贴士
如何搜索公众号过往发布内容
