Python入门教程[2]–列表,元祖,集合,字典

王 茂南
王 茂南
王 茂南
3296
文章
75
评论
2018年2月10日06:09:45
评论1 6900字阅读23分0秒
摘要这一篇讲python中常见的四种数据类型，,列表,元祖,集合,字典，并介绍了他们的一些操作，如增删改查，即各自的一些特性。

简介

这一篇我们会讲python中常用的四种数据结构,列表,元祖,集合,字典

  • List []
  • Tuple ()
  • set {}
  • dict {key:value}

在讲具体内容之前, 我们补充一个知识点, 就是查看变量在内存中的地址, 我们使用id(变量名)来查看变量在内存中的地址.

  1. a = [1,2,3]
  2. print(id(a))

更多入门教程链接

关于更多入门教程, 可以通过下面的链接查看.

 

列表 List

定义列表

  1. animals = ['tiger','bear','lion']

 

同时打印index和value

我们使用enumerate来同时打印list的index和value. 看一个简单的例子.

  1. In [1]: a = [1,2,3]
  3. In [2]: for index, value in enumerate(a):
  4.    ...:     print(index, value)
  5.    ...:
  6. 0 1
  7. 1 2
  8. 2 3

 

末尾增加-append

调用 append 方法向列表末尾添加元素。

  1. animals.append('horse')
  2. animals
  3. # >> ['tiger','bear','lion','horse']

 

任意位置添加--insert

上面我们讲了 append 是向列表的末尾进行添加，下面我们讲得 insert 可以向列表任意位置进行添加

  1. animals.insert(1,'eagle')
  2. animals
  3. # >> ['tiger', 'eagle', 'bear', 'lion', 'horse']

 

索引

我们可以通过索引来访问列表中的每个元素,第一个元素的索引是０,最后一个元素的索引是-1

animals[0]
>> 'tiger'
animals[-1]
>> 'horse'

我们可以使用len获取列表长度

len(animals)
>> 4

这里我们也可以返回某个值的索引，使用 index 来返回需要的值，下面看一个例子：

Python入门教程[2]–列表,元祖,集合,字典

但是如果一个 list 中有多个相同的元素，使用上面 index 的方式只可以找到第一个元素。如果想要找到所有的全部元素，可以使用下面的方式：

  1. indices = [i for i, x in enumerate(my_list) if x == "whatever"]

 

对 List 进行去重

对于一个嵌套的 list 来说，我们是不能直接使用 set 来进行去重的。但是我们可以将其转换为 tuple，然后使用 set 来进行去重。

  1.  a = [[1, 2], [1, 2], [3, 4]]
  3. # 转换为 tuple 来进行去重
  4. b_set = set(tuple(x) for x in a)
  5. b = [ list(x) for x in b_set ]

 

对嵌套的 list 进行展开（flatten list）

有的时候 list 会出现嵌套的情况，如下所示：

  1. a = [[1,2,3], [4,5], [6]]

我们希望将上面的 list 展开，展开为一维的 list，我们可以使用下面的方式。

  1. a = [[1,2,3], [4,5], [6]]
  2. flat_list = [item for sublist in a for item in sublist]

最终的输出的内容如下所示，可以看到将列表 a 展开了：

Python入门教程[2]–列表,元祖,集合,字典

参考资料，How to make a flat list out of a list of lists?

 

统计 List 每个元素出现次数

我们可以使用 Python 中的 collection 包下 Counter 的类来完成统计，具体的例子如下所示：

  1. from collections import Counter
  2. a = [1,1,1,1,2,2,2,2,2,2]
  3. Counter(a)
  4. # >> Counter({1: 4, 2: 6})

 

删除任意指定值

我们使用remove删除指定的值

  1. animals.remove('tiger')
  2. animals
  3. # >> ['eagle', 'bear', 'lion', 'horse']

注意: 如果tiger出现多次，只有第一个 tiger 会被删除。下面这个例子就是当有值重复时，remove 只可以删除第一个值。

Python入门教程[2]–列表,元祖,集合,字典

那么我们如何将所有的值都删除呢，可以使用下面的列表表达式来完成。

Python入门教程[2]–列表,元祖,集合,字典

 

按索引删除关键字

  1. del animals[1]
  2. animals
  3. # >> ['eagle', 'lion', 'horse']

 

列表反转

我们要记住列表是有序的，这个可以与其他数据结构进行比较，所以我们可以对有序的列表进行反转

  1. animals.reverse()
  2. animals
  3. # >> ['horse', 'lion', 'eagle']

 

列表的合并-extend

可以使用 extend 来对两个列表进行合并，如下所示。

  1. animals.extend(['tiger','bear'])
  2. animals
  3. # >> ['horse', 'lion', 'eagle', 'tiger', 'bear']

当列表是嵌套的, 同样可以使用这样的方式进行合并. 例如我们希望将a与后面的b, c, d都进行合并. 使用下面的方式进行合并即可.

Python入门教程[2]–列表,元祖,集合,字典

我们也可以使用加号（+）来进行列表的合并，如下所示：

Python入门教程[2]–列表,元祖,集合,字典

查找

animals.index('lion')#返回索引
>> 1
animals.count('lion')#返回出现次数
>> 1
'lion' in animls#返回布尔类型
>> True

修改

animals[0] = 'horses'
animals
>> ['horses', 'lion', 'eagle', 'tiger', 'bear']

按列取值

  1. scores = [[1,0], [2,0], [3,0], [4,0], [5,0],[5.5,0],[2,1],
  2.           [6,1], [7,1], [8,1], [9,1], [10,1]]
  4. x = [x[0] for x in scores]
  5. y = [x[1] for x in scores]
Python入门教程[2]–列表,元祖,集合,字典

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来完成

  1. In [1]: a = ['1','2','3']
  3. In [2]: ','.join(a)
  4. Out[2]: '1,2,3'

但是很多时候，list中不是str类型，这时候我们首先需要转换一下

  1. In [3]: a = [1,2,3]
  3. In [4]: ','.join([str(i) for i in a])
  4. Out[4]: '1,2,3'

 

元祖 Tuple

元祖是一种特殊的列表，不同点是元祖一旦创建就不能修改，上述修改列表内容的操作例如sort(),append()等对元祖都不在适用。

在编写程序的时候，元祖比列表更安全，如果是只读数据，尽可能使用元祖。

创建元祖

animals = ('tiger','lion','bear')

创建一个元素的元组

如果创建的元祖只有一个元素，需要在元素后面跟一个逗号。这是因为小括号也有数学运算符的含义，如果没有逗号，例如只有 (123)，则 Python 会按照小括号这个运算符处理。

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]–列表,元祖,集合,字典

 

字典 dict

字典是无序的键值对集合。字典中的每一个元素都是一个key和一个value的组合，key值在字典中必须是唯一的，因此很方便的从字典中使用key来获取其对应的value的值。

在使用 dict 的时候，我们可以使用 Easydict 来帮助我们像访问属性一样来访问字典中的值。关于 Easydict 的使用介绍，查看链接，Python 中 EasyDict 的使用。

字典的创建

  1. animals = {1:'tiger',2:'lion',3:'horse'}
  2. animals[1]
  3. >> 'tiger'

字典中 value 的获取

如果key不存在，那么dict[key]会抛出错误，有时候为了避免错误的出现，我们会使用get()函数来获取key对应的value，如果这个key不存在，那么就默认返回None

  1. animals.get(1)
  2. >> 'tiger'
  4. animals.get(4,'default')
  5. >> 'default' #key不存在的时候，返回默认值

字典中所有 values 求和

可以直接使用 sum 来对 dict 中所有 value 来进行求和。如下所示：

  1. sum(d.values())

下面是一个实际的例子，对 a 这个 dict 中的 value 来进行求和：

Python入门教程[2]–列表,元祖,集合,字典

增加元素

  1. animals[4]='eagle' #只需要为字典中key进行赋值
  2. animals
  3. >> {1: 'tiger', 2: 'lion', 3: 'horse', 4: 'eagle'}

删除元素

  1. del animals[4]
  2. animals
  3. >> {1: 'tiger', 2: 'lion', 3: 'horse'}

除了上述删除 dict 中 key 的方式外，我们还可以使用 pop 的方式来进行删除。

  1. my_dict.pop('key', None)

如果字典中有这个key，则会返回相应的 value，如果没有，则会返回 None。实验结果如下图所示：

Python入门教程[2]–列表,元祖,集合,字典

 

获取keys和values

  1. list(animals.keys())
  2. >> [1,2,3]
  4. list(animals.values())
  5. >>  ['tiger', 'lion', 'horse']
  7. for value in animals.values():
  8.     print(value)
  10. >>
  11. tiger
  12. lion
  13. horse

除了上面这种获取key与value的方法外，我们还可以通过items进行获取，如下所示：

  1. In [13]: a
  2. Out[13]: {1: 'a', 2: 'b', 3: 'c'}
  4. In [14]: for key,value in a.items():
  5.     ...:     print("key:{0}, value:{1}".format(key,value))
  6.     ...:
  7. key:1, value:a
  8. key:2, value:b
  9. key:3, value:c

key与value值互换

例如我们有一个字典类型的数据:

  1. my_map = {'a': 1, 'b': 2}

我们希望可以变成下面这个样子:

  1. inv_map = {1: 'a', 2: 'b'}

我们可以使用如下的方法进行操作:

  1. inv_map = {v: k for k, v in my_map.items()}

参考资料, Reverse / invert a dictionary mapping

字典的合并

两个字典的合并可以使用update来完成. 下面看一个简单的例子. 现在我们有一个空的字典x, 我们首先将其与y进行合并, 使用x.update(y)即可完成.

Python入门教程[2]–列表,元祖,集合,字典

现在我们希望x与z进行合并, 同样使用x.update(z)即可.

Python入门教程[2]–列表,元祖,集合,字典

字典值排序

有的时候，我们需要对dict中的值进行排序，我们分情况，分别是对key进行排序和对values进行排序。

根据value进行排序

  1. test = {}
  2. test['a']=1
  3. test['b']=3
  4. test['c']=2
  5. test
  7. # 根据value排序
  8. sorted(test.items(), key=lambda d: d[1])
Python入门教程[2]–列表,元祖,集合,字典

根据key进行排序

  1. test = {}
  2. test[1]='a'
  3. test[3]='c'
  4. test[2]='b'
  5. test
  7. # 根据key进行排序
  8. sorted(test.items(), key=lambda d:d[0])
Python入门教程[2]–列表,元祖,集合,字典

关于排序的问题, 有的时候我们可以转换为dataframe进行排序, 下面放一个简单的例子.

  1. # 将name和value保存为dataframe
  2. Name2Value = pd.DataFrame(list(dfDataTrain.columns[:-4]), columns=['Name'])
  3. Name2Value['Value'] = lr.coef_[0]
  4. Name2Value['abs_Value'] = Name2Value['Value'].apply(lambda x : abs(x))
  5. # 从大大小进行排序
  6. Name2Value = Name2Value.sort_values(by=['abs_Value'], ascending=False)
  7. Name2Value.head(10)

赋值与浅拷贝与深拷贝

  1. col = ['red','blue','green']
  2. col_new = col
  3. col_new.append('black')
  4. col_new
  5. >> ['red', 'blue', 'green', 'black']
  6. col
  7. >> ['red', 'blue', 'green', 'black'] #这个是赋值
  9. id_row = [id(ele) for ele in col]
  10. id_new = [id(ele) for ele in col_new]
  11. #我们可以看到上面两个是一样的

下面说一下深拷贝，浅拷感兴趣可以看一下

  1. import copy
  2. col = ['red','blue','green']
  3. col_new = copy.deepcopy(col)
  4. col_new.append('black')
  5. col_new
  6. >> ['red', 'blue', 'green', 'black']
  7. col
  8. >> ['red', 'blue', 'green']

  • 微信公众号
  • 关注微信公众号
  • weinxin
  • QQ群
  • 我们的QQ群号
  • weinxin
王 茂南
  • 本文由 发表于 2018年2月10日06:09:45
  • 转载请务必保留本文链接：https://mathpretty.com/8946.html
匿名

发表评论

匿名网友 填写信息

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen: