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

  • A+
所属分类：python快速入门
摘要这一篇讲python中常见的四种数据类型，,列表,元祖,集合,字典，并介绍了他们的一些操作，如增删改查，即各自的一些特性。

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

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

列表 List

定义

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

末尾增加-append

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

animals.append('horse')
animals
>> ['tiger','bear','lion','horse']

索引

我们可以通过索引来访问列表中的每个元素,第一个元素的索引是０,最后一个元素的索引是-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']

列表的合并

animals.extend(['tiger','bear'])
animals
>> ['horse', 'lion', 'eagle', 'tiger', 'bear']

查找

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')

注意

如果创建的元祖只有一个元素，需要在元素后面跟一个逗号

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}

字典 dict

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

字典的创建

  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不存在的时候，返回默认值

增加元素

  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'}

获取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

字典值排序

有的时候，我们需要对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
王 茂南

发表评论

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