list，tuple，dict，set的使用方法

list

 

list是一种有序的集合，可以随时添加和删除其中的元素

classmates = ['Michael', 'Bob', 'Tracy']

len()函数可以获得list元素的个数。list长度比索引小1.

list的索引是从0开始的，-1做索引，获取最后一个元素。索引超出范围，会报IndexError的错误。

例：（切片）

>>>L=['Google', 'Runoob', 'Taobao'] 

>>> L[2] 'Taobao' 

>>> L[-2] 'Runoob' 

>>> L[1:] ['Runoob', 'Taobao']

 

append方法可以将元素追加到列表末尾

例：

 

>>> classmates.append('Adam')

>>> classmates

['Michael', 'Bob', 'Tracy', 'Adam']

 

也可以将元素插入到指定的位置insert()

例：

>>> classmates.insert(1, 'Jack')

>>> classmates

['Michael', 'Jack', 'Bob', 'Tracy', 'Adam']

 

删除list末尾的元素，pop()方法

例：

classmates.pop()

'Adam'>>> classmates

['Michael', 'Jack', 'Bob', 'Tracy']

 

删除指定位置的元素，pop(i)方法

例：

>>> classmates.pop(1)

'Jack'>>> classmates

['Michael', 'Bob', 'Tracy']

 

删除元素还有一个方法del

例:

>>> list = ['Google', 'Runoob', 1997, 2000]

>>> del list[2]

>>> print(list)

['Google', 'Runoob', 2000]

 

要把某个元素替换成别的元素，可以直接赋值给对应的索引位置：

例：

>>> classmates[1] = 'Sarah'>>> classmates

['Michael', 'Sarah', 'Tracy']

 

list里面的数据类型可以是不同的，list的元素也可以是另外一个list。

例：

>>> s = ['python', 'java', ['asp', 'php'], 'scheme']

>>> len(s)

4

 

例：

>>>a = ['a', 'b', 'c'] 

>>> n = [1, 2, 3] 

>>> x = [a, n] 

>>> x 

[['a', 'b', 'c'], [1, 2, 3]] 

>>> x[0] 

['a', 'b', 'c'] 

>>> x[0][1] 

'b'

 

空的list的长度为0

 

列表脚本操作符：

 

Python 表达式                              结果                                 描述

[1, 2, 3] + [4, 5, 6]                  [1, 2, 3, 4, 5, 6]                   组合，列表拼接

['Hi!'] * 4                            ['Hi!', 'Hi!', 'Hi!', 'Hi!']         重复

3 in [1, 2, 3]                         True                                 元素是否存在于列表中（not in相反）

for x in [1, 2, 3]: print(x, end=" ")  1 2 3                                迭代

 

列表的一些方法

max(list) 返回列表元素最大值

min(list) 返回列表元素最小值

list(seq) 将元组转化为列表

list.count(obj)     统计某个元素在列表中出现的次数

list.clear()           清空列表

list.sort([func])     对列表进行排序  func -- 可选参数, 如果指定了该参数会使用该参数的方法进行排序。

list.reverse() 反向列表中元素

list.remove(obj)移除列表中某个值的第一个匹配项

list.index(obj)  从列表中找出某个值第一个匹配项的索引位置

list.extend(seq)  在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）

 

tuple

 

另一种有序列表叫做元组。tuple一旦初始化就不能修改。不能被改变会更安全。

例：

>>> classmates = ('Michael', 'Bob', 'Tracy')

取classmates中的值 classmates[-1],classmates[1]，通过下标

 

当tuple中只有一个元素时，要这样定义：t = (1,),多加一个逗号来消除歧义，不加逗号。t=（1）（）相当于小括号，赋值。

“可变”的tuple：

例：

>>> t = ('a', 'b', ['A', 'B'])

>>> t[2][0] = 'X'>>> t[2][1] = 'Y'>>> t

('a', 'b', ['X', 'Y'])

表面上元素变了，但tuple一开始指向的list并没有改成别的list，对于tuple来说还是没变。指向不变。

 

# 创建一个新的元组

tup3 = tup1 + tup2

 

del tup3 #删除tup3

 

Python 表达式                              结果                                 描述

(1, 2, 3) + (4, 5, 6)                  (1, 2, 3, 4, 5, 6)                   组合，列表拼接

('Hi!') * 4                            ('Hi!', 'Hi!', 'Hi!', 'Hi!')         重复

3 in (1, 2, 3)                         True                                 元素是否存在于列表中（not in相反）

for x in (1, 2, 3]) print(x)   1 2 3                                迭代

 

内置函数

len(tuple)   计算元组元素个数。

max(tuple)   返回元组中元素最大值。

min(tuple)   返回元组中元素最小值。

tuple(seq)   将列表转换为元组。

 

dict

 

dict 字典，全称dictionary，使用键-值（key-value）存储。字典的每个键值对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中

例：

>>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}

>>> d['Michael']

95

 

除了初始化时指定外，还可以通过key放入：

>>> d['Adam'] = 67

>>> d['Adam']

67

 

由于一个key只能对应一个value，所以，多次对一个key放入value，后面的值会把前面的值冲掉

 

key不存在，会报错。可以使用两种方法，一是通过in来判断key是否存在

例：

>>> 'Thomas' in d

False

二是通过get（）方法，如果key不存在，返回None，或者自己指定的value

例：

>>> d.get('Thomas') #None交互环境不显示结果

>>> d.get('Thomas', -1)

-1

 

要删除一个key，用po(key)方法，对应的value也会从dict中删除。

例：

>>> d.pop('Bob')

75

>>> d

{'Michael': 95, 'Tracy': 85}

 

del dict['Name'] # 删除键 'Name'

dict.clear() # 清空字典

del dict # 删除字典

 

 

请务必注意，dict内部存放的顺序和key放入的顺序是没有关系的。

和list比较，dict有以下几个特点：

1. 查找和插入的速度极快，不会随着key的增加而变慢；
2. 需要占用大量的内存，内存浪费多。

而list相反：

1. 查找和插入的时间随着元素的增加而增加；
2. 占用空间小，浪费内存很少。

所以，dict是用空间来换取时间的一种方法。

 

dict的key必须是不可变对象，通过key计算位置的算法称为哈希算法

键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行

 

 

内置函数

len(dict)       计算字典元素个数，即键的总数。

str(dict)       输出字典，以可打印的字符串表示。

type(variable)  返回输入的变量类型，如果变量是字典就返回字典类型。

 

内置方法

序号 函数及描述

1 radiansdict.clear() 删除字典内所有元素

2 radiansdict.copy() 返回一个字典的浅复制

3 radiansdict.fromkeys() 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值

4 radiansdict.get(key, default=None) 返回指定键的值，如果值不在字典中返回default值

5 key in dict 如果键在字典dict里返回true，否则返回false

6 radiansdict.items() 以列表返回可遍历的(键, 值) 元组数组

7 radiansdict.keys() 以列表返回一个字典所有的键

8 radiansdict.setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default

9 radiansdict.update(dict2) 把字典dict2的键/值对更新到dict里

10 radiansdict.values() 以列表返回字典中的所有值

11 pop(key[,default]) 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。

12 popitem() 随机返回并删除字典中的一对键和值(一般删除末尾对)。

 

set

 

set是一组key的集合，key不能重复。

要创建一个set，需要提供一个list作为输入集合

例：

>>> s = set([1, 2, 3])

>>> s

{1, 2, 3}

set不是有序的

重复元素在set中自动过滤

add(key)方法添加元素到set中，可以重复添加，但不会有效果。

例：

>>> s.add(4)

>>> s

{1, 2, 3, 4}

>>> s.add(4)

>>> s

{1, 2, 3, 4}

 

通过remove(key)可以删除元素

例：

>>> s.remove(4)

>>> s

{1, 2, 3}

 

set可以看成数学意义上的无序和无重复元素的集合，因此，两个set可以做数学意义上的交集、并集等操作：

>>> s1 = set([1, 2, 3])

>>> s2 = set([2, 3, 4])

>>> s1 & s2

{2, 3}

>>> s1 | s2

{1, 2, 3, 4}

 

set中不能放入可变对象。

 

#关系测试

#交集(两个列表里面都有的值，这里是4、6)：

print(list_1.intersection(list_2))

 

#并集（把两个列别合并起来，然后去重）：

print(list_1.union(list_2))

 

#差集（把list_1里面有的而list_2里面没有的取出来）：

print(list_1.difference(list_2))

 

#对称差集（两个列表里面，互相没有的取出来，也就是只去掉那些互相都有的值）

print(list_1.symmetric_difference(list_2))

 

#子集（判断list_1是否包含了list_3里面的所有值）

print(list_3.issubset(list_1))

 

#父集（判断list_1是否为list_3的父集）

print(list_1.issuperset(list_3))

 

#无交集（判断list_3和list_4是否完全没有任何交集）

list_4 = set([5,6,8])

print(list_3.isdisjoint(list_4))

 

#-----------------------关系测试的另一种写法：

'''

s = set([3,5,9,10]) #创建一个数值集合

 

t = set("Hello") #创建一个唯一字符的集合

 

 

a = t | s # t 和 s的并集

 

b = t & s # t 和 s的交集

 

c = t – s # 求差集（项在t中，但不在s中）

 

d = t ^ s # 对称差集（项在t或s中，但不会同时出现在二者中）

 

基本操作：

 

t.add('x') # 添加一项

 

s.update([10,37,42]) # 在s中添加多项

 

 

 

使用remove()可以删除一项：

 

t.remove('H') #有就删除，没有就报错

t.pop() #随机弹出一个

t.discard('H') #有就删除，没有也不会报错

 

len(s)

set 的长度

 

x in s

测试 x 是否是 s 的成员

 

x not in s

测试 x 是否不是 s 的成员

 

s.issubset(t)

s <= t

测试是否 s 中的每一个元素都在 t 中

 

s.issuperset(t)

s >= t

测试是否 t 中的每一个元素都在 s 中

 

s.union(t)

s | t

返回一个新的 set 包含 s 和 t 中的每一个元素

 

s.intersection(t)

s & t

返回一个新的 set 包含 s 和 t 中的公共元素

 

s.difference(t)

s - t

返回一个新的 set 包含 s 中有但是 t 中没有的元素

 

s.symmetric_difference(t)

s ^ t

返回一个新的 set 包含 s 和 t 中不重复的元素

 

s.copy()

返回 set “s”的一个浅复制

 

 

 参考：https://www.liaoxuefeng.com

            http://www.runoob.com