- A+
文章目录(Table of Contents)
简介
这一篇我们会讲python中常用的四种数据结构,列表,元祖,集合,字典
- List []
- Tuple ()
- set {}
- dict {key:value}
在讲具体内容之前, 我们补充一个知识点, 就是查看变量在内存中的地址, 我们使用id(变量名)来查看变量在内存中的地址.
- a = [1,2,3]
- print(id(a))
更多入门教程链接
关于更多入门教程, 可以通过下面的链接查看.
列表 List
定义
animals = ['tiger','bear','lion']
同时打印index和value
我们使用enumerate来同时打印list的index和value. 看一个简单的例子.
- In [1]: a = [1,2,3]
- In [2]: for index, value in enumerate(a):
- ...: print(index, value)
- ...:
- 0 1
- 1 2
- 2 3
末尾增加-append
调用append方法向列表末尾添加元素
animals.append('horse')
animals
>> ['tiger','bear','lion','horse']
索引
我们可以通过索引来访问列表中的每个元素,第一个元素的索引是0,最后一个元素的索引是-1
animals[0]
>> 'tiger'
animals[-1]
>> 'horse'
我们可以使用len
获取列表长度
len(animals)
>> 4
任意位置添加--insert
上面我们讲了append是向列表的末尾进行添加,下面我们讲得insert可以向列表任意位置进行添加
animals.insert(1,'eagle')
animals
>> ['tiger', 'eagle', 'bear', 'lion', 'horse']
删除任意指定值
我们使用remove
删除指定的值
animals.remove('tiger')
animals
>> ['eagle', 'bear', 'lion', 'horse']
注意:如果tiger
出现多次,只有第一个tiger会被删除
按索引删除关键字
del animals[1]
animals
>> ['eagle', 'lion', 'horse']
列表反转
我们要记住列表是有序的,这个可以与其他数据结构进行比较,所以我们可以对有序的列表进行反转
animals.reverse()
animals
>> ['horse', 'lion', 'eagle']
列表的合并-extend
animals.extend(['tiger','bear'])
animals
>> ['horse', 'lion', 'eagle', 'tiger', 'bear']
当列表是嵌套的, 同样可以使用这样的方式进行合并. 例如我们希望将a与后面的b, c, d都进行合并. 使用下面的方式进行合并即可.
![Python入门教程[2]--列表,元祖,集合,字典](https://img.mathpretty.com/20201010_100205_irpzjuk.jpg)
我们也可以使用加号(+)来进行列表的合并,如下所示:
![Python入门教程[2]--列表,元祖,集合,字典](https://img.mathpretty.com/20210105_152107_uifredv.jpg)
查找
animals.index('lion')#返回索引
>> 1
animals.count('lion')#返回出现次数
>> 1
'lion' in animls#返回布尔类型
>> True
修改
animals[0] = 'horses'
animals
>> ['horses', 'lion', 'eagle', 'tiger', 'bear']
按列取值
- scores = [[1,0], [2,0], [3,0], [4,0], [5,0],[5.5,0],[2,1],
- [6,1], [7,1], [8,1], [9,1], [10,1]]
- x = [x[0] for x in scores]
- y = [x[1] for x in scores]
![Python入门教程[2]--列表,元祖,集合,字典](https://img.mathpretty.com/20181129_224803_yvx0ffl.jpg)
pop的使用
pop返回列表的最后一个元素,在返回这个元素的同时也会删除这个元素,若传入一个参数pop(i)
则将第i个元素弹出
for i in range(len(animals)):
animal = animals.pop()
print(animal) #把整个列表倒叙输出
>>
bear
tiger
eagle
lion
horses
animals #此时列表是空的
>> []
animals.append('tiger')#我们可以往里面添加值
animals
>> ['tiger']
List乘法
list1 = [1,2,3]
list1*3
>> [1, 2, 3, 1, 2, 3, 1, 2, 3]#列表重复三次
list转str
很多时候,我们会将list转为str,我们会使用join来完成
- In [1]: a = ['1','2','3']
- In [2]: ','.join(a)
- Out[2]: '1,2,3'
但是很多时候,list中不是str类型,这时候我们首先需要转换一下
- In [3]: a = [1,2,3]
- In [4]: ','.join([str(i) for i in a])
- Out[4]: '1,2,3'
元祖 Tuple
元祖是一种特殊的列表,不同点是元祖一旦创建就不能修改,上述修改列表内容的操作例如sort()
,append()
等对元祖都不在适用。
在编写程序的时候,元祖比列表更安全,如果是只读数据,尽可能使用元祖。
创建元祖
animals = ('tiger','lion','bear')
注意
如果创建的元祖只有一个元素,需要在元素后面跟一个逗号
animals = ('tiger')
type(animals) #可以看到这里是str类型
>> str
animals
>> 'tiger'
animals = ('tiger',)
type(animals)
>> tuple
animals
>> ('tiger',)
集合 Set
集合是一个无序不重复的数据集,对比列表,首先是无序的,不可以使用索引来进行访问,另一个特点是不能有重复的数据
集合支持数学上的一些运算,例如:union(并集)
,intersection(交集)
,difference(补集)
集合的创建
集合的创建使用set
函数或者{}
,注意空集合的创建只能使用set
函数,使用{}
创建的是一个空的字典。
animals = {'tiger','bear','lion','eagle','tiger'}
animals
>> {'bear', 'eagle', 'lion', 'tiger'} #可以看到重复的元素已经被去除
animals = set(['tiger','bear','lion','eagle','tiger'])
type(animals)
>> set
animals
>> {'bear', 'eagle', 'lion', 'tiger'} #可以看到重复的元素已经被去除
查看元素是否在集合中
'tiger' in animals
>> True
'tigers' in animals
>> False
'tigers' not in animals #注意这里是 not in
>> True
集合的增删
animals.add('horse')
animals
>> {'bear', 'eagle', 'horse', 'lion', 'tiger'}
animals.remove('horse')
animals
>> {'bear', 'eagle', 'lion', 'tiger'}
集合子集的概念
<=
--属于
set1 = {1,2,3}
set2 = {2,3}
set2 in set1
>> False #思考这是为什么
set2 <= set1
>> True
集合的运算
set1 = {1,2,3,4}
set2 = {3,4,5,6}
|
操作,存在 set1 中或 set2 中的元素,等效于 union 操作
set1|set2
>> {1,2,3,4,5,6}
set1.union(set2)
>> {1,2,3,4,5,6}
&
操作,返回即在 set1 又在 set2 的元素
set1&set2
>> {3,4}
-
返回在 set1 不在 set2 的元素
set1-set2
>> {1,2}
^
操作,返回只存在两个集合中的元素
set1^set2
>> {1,2,5,6}
利用集合去重
因为集合有集合内的元素不重复的特点,所以我们可以利用这一个特点来对 List 中的内容来进行去重。可以参考此链接,Removing duplicates in the lists
![Python入门教程[2]--列表,元祖,集合,字典](https://img.mathpretty.com/20201026_171048_x2ig434.jpg)
字典 dict
字典是无序的键值对集合。字典中的每一个元素都是一个key和一个value的组合,key值在字典中必须是唯一的,因此很方便的从字典中使用key来获取其对应的value的值。
在使用 dict 的时候,我们可以使用 Easydict 来帮助我们像访问属性一样来访问字典中的值。关于 Easydict 的使用介绍,查看链接,Python 中 EasyDict 的使用。
字典的创建
- animals = {1:'tiger',2:'lion',3:'horse'}
- animals[1]
- >> 'tiger'
字典中value的获取
如果key不存在,那么dict[key]会抛出错误,有时候为了避免错误的出现,我们会使用get()函数来获取key对应的value,如果这个key不存在,那么就默认返回None
- animals.get(1)
- >> 'tiger'
- animals.get(4,'default')
- >> 'default' #key不存在的时候,返回默认值
字典中所有 values 求和
可以直接使用 sum
来对 dict
中所有 value
来进行求和。如下所示:
- sum(d.values())
下面是一个实际的例子,对 a 这个 dict 中的 value 来进行求和:
![Python入门教程[2]--列表,元祖,集合,字典](https://img.mathpretty.com/20201230_150159_xynggwx.jpg)
增加元素
- animals[4]='eagle' #只需要为字典中key进行赋值
- animals
- >> {1: 'tiger', 2: 'lion', 3: 'horse', 4: 'eagle'}
删除元素
- del animals[4]
- animals
- >> {1: 'tiger', 2: 'lion', 3: 'horse'}
除了上述删除 dict 中 key 的方式外,我们还可以使用 pop 的方式来进行删除。
- my_dict.pop('key', None)
如果字典中有这个key,则会返回相应的 value,如果没有,则会返回 None。实验结果如下图所示:
![Python入门教程[2]--列表,元祖,集合,字典](https://img.mathpretty.com/20201229_173106_pkevm60.jpg)
获取keys和values
- list(animals.keys())
- >> [1,2,3]
- list(animals.values())
- >> ['tiger', 'lion', 'horse']
- for value in animals.values():
- print(value)
- >>
- tiger
- lion
- horse
除了上面这种获取key与value的方法外,我们还可以通过items进行获取,如下所示:
- In [13]: a
- Out[13]: {1: 'a', 2: 'b', 3: 'c'}
- In [14]: for key,value in a.items():
- ...: print("key:{0}, value:{1}".format(key,value))
- ...:
- key:1, value:a
- key:2, value:b
- key:3, value:c
key与value值互换
例如我们有一个字典类型的数据:
- my_map = {'a': 1, 'b': 2}
我们希望可以变成下面这个样子:
- inv_map = {1: 'a', 2: 'b'}
我们可以使用如下的方法进行操作:
- inv_map = {v: k for k, v in my_map.items()}
参考资料, Reverse / invert a dictionary mapping
字典的合并
两个字典的合并可以使用update
来完成. 下面看一个简单的例子. 现在我们有一个空的字典x, 我们首先将其与y进行合并, 使用x.update(y)
即可完成.
![Python入门教程[2]--列表,元祖,集合,字典](https://img.mathpretty.com/20201010_095431_vayrlhw.jpg)
现在我们希望x与z进行合并, 同样使用x.update(z)
即可.
![Python入门教程[2]--列表,元祖,集合,字典](https://img.mathpretty.com/20201010_095638_h7bpd83.jpg)
字典值排序
有的时候,我们需要对dict中的值进行排序,我们分情况,分别是对key进行排序和对values进行排序。
根据value进行排序
- test = {}
- test['a']=1
- test['b']=3
- test['c']=2
- test
- # 根据value排序
- sorted(test.items(), key=lambda d: d[1])
![Python入门教程[2]--列表,元祖,集合,字典](https://img.mathpretty.com/20190429_114450_7rqgu2i.jpg)
根据key进行排序
- test = {}
- test[1]='a'
- test[3]='c'
- test[2]='b'
- test
- # 根据key进行排序
- sorted(test.items(), key=lambda d:d[0])
![Python入门教程[2]--列表,元祖,集合,字典](https://img.mathpretty.com/20190429_114508_pxfkxfb.jpg)
关于排序的问题, 有的时候我们可以转换为dataframe进行排序, 下面放一个简单的例子.
- # 将name和value保存为dataframe
- Name2Value = pd.DataFrame(list(dfDataTrain.columns[:-4]), columns=['Name'])
- Name2Value['Value'] = lr.coef_[0]
- Name2Value['abs_Value'] = Name2Value['Value'].apply(lambda x : abs(x))
- # 从大大小进行排序
- Name2Value = Name2Value.sort_values(by=['abs_Value'], ascending=False)
- Name2Value.head(10)
赋值与浅拷贝与深拷贝
- col = ['red','blue','green']
- col_new = col
- col_new.append('black')
- col_new
- >> ['red', 'blue', 'green', 'black']
- col
- >> ['red', 'blue', 'green', 'black'] #这个是赋值
- id_row = [id(ele) for ele in col]
- id_new = [id(ele) for ele in col_new]
- #我们可以看到上面两个是一样的
下面说一下深拷贝,浅拷感兴趣可以看一下
- import copy
- col = ['red','blue','green']
- col_new = copy.deepcopy(col)
- col_new.append('black')
- col_new
- >> ['red', 'blue', 'green', 'black']
- col
- >> ['red', 'blue', 'green']
- 微信公众号
- 关注微信公众号
-
- QQ群
- 我们的QQ群号
-
感谢你能看到最后,谢谢对本站的支持!!!
谢谢支持!
记得推荐给大家!
点