[Python知识库]python常见数据结构

python常见数据结构

使用列表

列表是一种结构化的、非标量类型，它的值是有序序列，每个值都可以通过索引进行标识，定义列表可以将列表的元素放在[]中，多个元素用，进行分隔，可以使用for循环对列表元素进行遍历，也可以使用[]和[:]运算符取出列表中的一个或多个元素。

下面的代码演示了如何定义列表、如何遍历列表以及列表的下标运算。

list1 = [1, 3, 5, 7, 100]
print(list1) # [1, 3, 5, 7, 100]
# 乘号表示列表元素的重复
list2 = ['hello'] * 3
print(list2) # ['hello', 'hello', 'hello']
# 计算列表长度(元素个数)
print(len(list1)) # 5
# 下标(索引)运算
print(list1[0]) # 1
print(list1[4]) # 100
# print(list1[5])  # IndexError: list index out of range
print(list1[-1]) # 100
print(list1[-3]) # 5
list1[2] = 300
print(list1) # [1, 3, 300, 7, 100]
# 通过循环用下标遍历列表元素
for index in range(len(list1)):
    print(list1[index])
# 通过for循环遍历列表元素
for elem in list1:
    print(elem)
# 通过enumerate函数处理列表之后再遍历可以同时获得元素索引和值
for index, elem in enumerate(list1):
    print(index, elem)

列表中添加元素

append
append() 追加单个元素到List的尾部，只接受一个参数，参数可以是任何数据类型，被追加的元素在List中保持着原结构类型。

extend
extend() 将一个列表中每个元素分别添加到另一个列表中，只接受一个参数。

insert
insert() 将一个元素插入到列表中，但其参数有两个（如insert(1,”g”)），第一个参数是索引点，即插入的位置，第二个参数是插入的元素。

三种方法（append, extend, insert）可对列表增加元素的操作，他们没有返回值，是直接修改了原数据对象

列表删除元素

del
del是python语句，不是list方法，无法使用list调用，使用del可以删除一个元素，当元素删除之后，位于它后面的元素会自动移动填补空出来的位置。

remove
remove() 函数用于移除列表中某个值的第一个匹配项。

pop
pop() 函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。obj – 可选参数，要移除列表元素的索引值，不能超过列表总长度，默认为 index=-1，删除最后一个列表值。

下面的代码演示了如何向列表中添加元素以及如何从列表中移除元素。

list1 = [1, 3, 5, 7, 100]
# 添加元素
list1.append(200)
list1.insert(1, 400)
# 合并两个列表
# list1.extend([1000, 2000])
list1 += [1000, 2000]#加号，将两个list相加，会返回到一个新的list对象
print(list1) # [1, 400, 3, 5, 7, 100, 200, 1000, 2000]
print(len(list1)) # 9
# 先通过成员运算判断元素是否在列表中，如果存在就删除该元素
if 3 in list1:
	list1.remove(3)
if 1234 in list1:
    list1.remove(1234)
print(list1) # [1, 400, 5, 7, 100, 200, 1000, 2000]
# 从指定的位置删除元素
list1.pop(0)
list1.pop(len(list1) - 1)
print(list1) # [400, 5, 7, 100, 200, 1000]
# 清空列表元素
list1.clear()
print(list1) # []

和字符串一样，列表也可以做切片操作，通过切片操作我们可以实现对列表的复制或者将列表中的一部分取出来创建出新的列表，代码如下所示。

fruits = ['grape', 'apple', 'strawberry', 'waxberry']
fruits += ['pitaya', 'pear', 'mango']
# 列表切片
fruits2 = fruits[1:4]
print(fruits2) # apple strawberry waxberry
# 可以通过完整切片操作来复制列表
fruits3 = fruits[:]
print(fruits3) # ['grape', 'apple', 'strawberry', 'waxberry', 'pitaya', 'pear', 'mango']
fruits4 = fruits[-3:-1]
print(fruits4) # ['pitaya', 'pear']
# 可以通过反向切片操作来获得倒转后的列表的拷贝
fruits5 = fruits[::-1]
print(fruits5) # ['mango', 'pear', 'pitaya', 'waxberry', 'strawberry', 'apple', 'grape']

下面的代码实现了对列表的排序操作

#列表元素的排序操作
"""
1.使用函数sort(),列中所有元素默认从小到大排序，指定reverse为true进行降序排序
2.调用内置函数sorted(),指定reverse=true，进行降序排序，原列表不发生变化
"""
lst=[20,30,5,98,1]
print('排序前的列表',lst,id(lst))
lst.sort()
print('排序后的列表',lst,id(lst))

#通过指定列表关键字参数，将列表中的元素进行降序排序
lst.sort(reverse=True)
print(lst)#降序排序 [98, 30, 20, 5, 1]
lst.sort(reverse=False)
print(lst)#升序排序 [1, 5, 20, 30, 98]

#使用内置函数sorted()进行排序，将产生一个新的列表对象
lst=[10,1,23,54,98,22]
newlist=sorted(lst)
print(lst)
print(newlist)#[1, 10, 22, 23, 54, 98]
declist=sorted(lst,reverse=True)#设置关键字，使列表降序
print(declist)#[98, 54, 23, 22, 10, 1]

key参数/函数

从python2.4开始，list.sort()和sorted()函数增加了key参数来指定一个函数，此函数将在每个元素比较前被调用。

student_tuples = [
        ('john', 'A', 15),
        ('jane', 'B', 12),
        ('dave', 'B', 10),
]
sorted(student_tuples, key=lambda student: student[2])   # sort by age
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

生成式和生成器

我们还可以使用列表的生成式语法来创建列表，代码如下所示。

"""
列表生成式

一个用来生成列表的特定语法形式的表达式。可以对一组元素进行过滤或得到对列表元素进行处理后得到的结果
可以快速的根据已存在的可迭代对象推导出一个新的list

语法格式：
[exp for val in collection if condition]
执行过程：
先对传入的列表进行for循环得到将符合条件的元素再进行if判断返回给exp
执行exp表达式，最后将处理后的结果以列表的形式返回一个列表

"""
tuple_test = [x*x for x in xrange(10) if x*x%2 == 0]
print(type(tuple_test))
print(tuple_test)
# 执行结果：
# <type 'list'>
# [0, 4, 16, 36, 64]
# 等价于
tuple_test1 = []
for i in xrange(10):
    if i*i%2 == 0:
        tuple_test1.append(i)
print(type(tuple_test1))
print(tuple_test1)
# # 执行结果：
# <type 'list'>
# [0, 2, 4, 6, 8]

"""
生成器
在Python中，这种一边循环一边计算的机制，称为生成器
生成器是按照某种算法不断生成新的数据，直到满足某一个指定的条件结束
每次只生成一个元素，不必创建完整的list，从而节省大量的空间

构造生成器的两种方式：

1、使用类似列表生成式的方式生成 (2*n + 1 for n in range(3, 11)) 将生成式的[],换为（）
2、使用包含yield的函数来生成

如果计算过程比较简单，可以直接把列表生成式改成generator；
但是，如果计算过程比较复杂，就只能通过包含yield的函数来构造generator，就是通过`yield`关键字将一个普通函数改造成生成器函数。
"""
# 使用类似于列表生成式的方式来构造生成器
print('使用类似于列表生成式的方式来构造生成器')
generatot = (x*x for x in xrange(10) if x*x%2 == 0)
print(type(generatot))
print(generatot)
for i in generatot:
    print(i)

print('使用包含yield的函数构造生成器')
def func1():
    for i in xrange(10):
        if i*i%2 == 0:
            yield i*i
generatot1 = func1()
print(type(generatot1))
print(generatot1)
for i in generatot1:
    print(i)
# 执行结果：
# 使用类似于列表生成式的方式来构造生成器
# <type 'generator'>
# <generator object <genexpr> at 0x0000000002BA1480>
# 0
# 4
# 16
# 36
# 64
# 使用包含yield的函数构造生成器
# <type 'generator'>
# <generator object func1 at 0x0000000002C2AF78>
# 0
# 4
# 16
# 36
# 64

生成式与生成器的区别：

生成式直接返回了表达式的结果列表， 
生成器返回的是一个对象，该对象包含了对表达式结果的计算引用， 通过循环可以直接输出
生成器不会一次性列出所有的数据，当你用到的时候，在列出来，更加节约内存的使用率。

使用元组

Python中的元组与列表类似也是一种容器数据类型，可以用一个变量（对象）来存储多个数据，不同之处在于元组的元素不能修改。我们把多个元素组合到一起就形成了一个元组，所以它和列表一样可以保存多条数据。下面的代码演示了如何定义和使用元组。

#在python中，元组使用小括号，列表使用方括号
tup= ('physics', 'chemistry', 1997, 2000,3.14) 
#创建一个空元组
tup = () 或 tup=tuple()
#元组中只包含一个元素时，需要在元素后面添加逗号
tup= (50,)
#访问元组中的元素，可以使用下标索来进行访问
#访问元组的第一个元素
print(tup[0])
#访问元组的最后一个元素
print(tup[-1])
#访问元组索引为1,2,3的元素
print(tup[1:4])
#元组中的元素值是不可以修改上的，但是元组可以进行连接
tup1= ('physics', 'chemistry', 1997, 2000,3.14)
tup2=('physics', 'chemistry', 1997, 2000,3.14)
tup3=tup1+tup2
print(tup3)
#元组不可以进行更改
tup1[0]=666
print(tup1)
结果如下：
('physics', 'chemistry', 1997, 2000, 3.14, 'physics', 'chemistry', 1997, 2000, 3.14)
    tup1[0]=666
TypeError: 'tuple' object does not support item assignment

    #删除元组中的元素：元组的的元素值是不允许删除的，但是可以使用del语句来删除整个元组，使用del删除整个元组后，在打印就会报错，因为元组此时没有定义。
    del tup

元组的常用操作符

• len()可以求取元组的长度
• + 号用于组合元组，* 号用于重复元组
• in，not in判断元素是否在元组中
• for x in （1, 2, 3）: print x 元组的遍历

元组与列表的转化

元组----->列表：my_list=list（元组名）

列表----->元组：my_tuple=tuple（列表名

使用集合

python中的集合跟数学上的集合是一致的，不允许有重复元素，而且可以进行交集、并集、差集等运算。

无序的数据类型，添加顺序和在集合中的存储顺序不一样。

！！不支持索引，重复，连接，切片

可以按照下面代码所示的方式来创建和使用集合。

>>>basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket)                      # 这里演示的是去重功能
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket                 # 快速判断元素是否在集合内
True
>>> 'crabgrass' in basket
False

>>> # 下面展示两个集合间的运算.
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  
{'a', 'r', 'b', 'c', 'd'}
>>> a - b                              # 求差集（只有a中拥有的而b集合没有的元素）
{'r', 'd', 'b'}
>>> a | b                              # 并集（集合a或b中包含的所有元素）
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b                             # a和b的交集（集合a和b中都包含了的元素）
{'a', 'c'}
>>> a ^ b            # 元素在a或b中，但不会同时出现在a和b的集合之中（对称差集）
{'r', 'd', 'b', 'm', 'z', 'l'}

集合去重复有局限性

1.只能针对不可变类型 2.集合本身是无序的，去重之后无法保留原来的顺序

>>> l=['a','b',1,'a','a']
>>> s=set(l)
>>> s # 将列表转成了集合 {'b', 'a', 1}
>>> l_new=list(s) # 再将集合转回列表
>>> l_new ['b', 'a', 1] # 去除了重复，但是打乱了顺序
# 针对不可变类型，并且保证顺序则需要我们自己写代码实现，例如
l=[
　　{'name':'lili','age':18,'sex':'male'},
　　{'name':'jack','age':73,'sex':'male'},
　　{'name':'tom','age':20,'sex':'female'},
　　{'name':'lili','age':18,'sex':'male'},
　　{'name':'lili','age':18,'sex':'male'},
]

new_l=[]

for dic in l:
　　if dic not in new_l:
　　　　new_l.append(dic)
print(new_l)
# 结果：既去除了重复，又保证了顺序，而且是针对不可变类型的去重
[
　　{'age': 18, 'sex': 'male', 'name': 'lili'},
　　{'age': 73, 'sex': 'male', 'name': 'jack'},
　　{'age': 20, 'sex': 'female', 'name': 'tom'}
]

集合推导式

a = {x for x in 'abracadabra' if x not in 'abc'}      
print(a)
//执行结果
{'r', 'd'}
//解释
a = {x for x in 'abracadabra' if x not in 'abc'}
从'abracadabra'中用for循环，取出，如果x不在其中则x存到a集合中

集合的基本操作

1.添加元素

语法格式如下：
s.add( x ) #添加一项
将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。

还有一个方法，也可以添加元素，且参数可以是列表，元组，字典等，语法格式如下：

s.update( x ) #添加多项

x 可以有多个，用逗号分开。

2.移除元素

s.remove( x )
将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。

此外还有一个方法也是移除集合中的元素，且如果元素不存在，不会发生错误。格式如下所示： s.discard( x )

我们也可以设置随机删除集合中的一个元素，语法格式如下：s.pop()

3.计算集合元素个数

语法格式如下：len(s)

4.清空集合

s.clear()

5.判断元素是否在集合中存在

x in s，判断元素x是否在集合s中，存在返回True，不存在返回False。

6.拷贝一个集合

copy()方法用于拷贝一个集合，无返回值。

7.differenc()返回集合间的差集

返回一个集合，元素包含在集合 x ，但不在集合 y ：

x = {"apple", "banana", "cherry"}
y = {"google", "microsoft", "apple"} 
z = x.difference(y) 
print(z)
输出结果为：
{'cherry', 'banana'}

8.移除两个集合都包含的元素

x = {"apple", "banana", "cherry"}
y = {"google", "microsoft", "apple"}
x.difference_update(y) 
print(x)
输出结果为：
{'cherry', 'banana'}

9.返回集合的交集

intersection() 方法用于返回两个或更多集合中都包含的元素，即交集

x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "apple"}
z = x.intersection(y) 
print(z)
输出结果为：
{'apple'}

#计算多个集合
x = {"a", "b", "c"}
y = {"c", "d", "e"}
z = {"f", "g", "c"}
result = x.intersection(y, z)
print(result)
输出结果为：
{'c'}

10.判断集合是否包含相同的元素

isdisjoint() 方法用于判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False

x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "facebook"}
z = x.isdisjoint(y) 
print(z)
输出结果为：
True

使用字典

字典是另一种可变容器模型，python中的字典跟我们生活中使用的字典是一样的，它可以存储任意类型对象，与列表、集合不同的是，字典中的每个元素都是由一个键和一个值组成的“键值对”，键和值通过冒号分开。

1.创建字典

Python有两种方法可以创建字典,第一种是使用花括号,另一种是使用内建 函数dict

>>> info = {}
>>> info = dict()

2.初始化字典

python可以在创建字典的时候初始化字典。

>>> info = {"name" : 'cold'}
>>> info = dict(name = 'cold')       # 更优雅

3.字典的基本用法

 scores = {'语文': 89}  # 通过key访问value  
 print(scores['语文'])

 #如果要为 dict 添加 key-value 对，只需为不存在的 key 赋值即可：
 # 对不存在的key赋值，就是增加key-value对 
 scores['数学'] = 93  scores[92] = 5.7 
 print(scores) 
 # {'语文': 89, '数学': 93, 92: 5.7}
    
 #如果要删除宇典中的 key-value 对，则可使用 del 语句。
 del scores['语文']
 del scores['数学']  
 print(scores) # {92: 5.7}
    
 #如果对 dict 中存在的 key-value 对赋值，新赋的 value 就会覆盖原有的 value，这样即可改变 dict 中的 key-value 对。
cars = {'BMW': 8.5, 'BENS': 8.3, 'AUDI': 7.9} 
cars['BENS'] = 4.3  
cars['AUDI'] = 3.8 
print(cars)
# {'BMW': 8.5, 'BENS': 4.3, 'AUDI': 3.8}

#如果要判断字典是否包含指定的 key，则可以使用 in 或 not in 运算符。
 # 判断cars是否包含名为'AUDI'的key 
 print('AUDI' in cars)
 # True  
 # 判断cars是否包含名为'PORSCHE'的key  
 print('PORSCHE' in cars) 
 # False 
 print('LAMBORGHINI' not in cars) 
 # True

通过上面介绍可以看出，字典的 key 是它的关键。换个角度来看，字典的 key 就相当于它的索引，只不过这些索引不一定是整数类型，字典的 key 可以是任意不可变类型。

可以这样说，字典相当于索引是任意不可变类型的列表：而列表则相当于 key 只能是整数的字典。因此，如果程序中要使用的字典的 key 都是整数类型，则可考虑能否换成列表。

此外，还有一点需要指出，列表的索引总是从 0 开始、连续增大的；但字典的索引即使是整数类型，也不需要从 0 开始，而且不需要连续。因此，列表不允许对不存在的索引赋值：但字典则允许直接对不存在的 key 赋值，这样就会为字典增加一个 key-value 对。

列表不允许对不存在的索引赋值，但字典则允许直接对不存在的 key 赋值。

4.字典的常用方法

1.clear()方法

clear() 用于清空字典中所有的 key-value 对，对一个字典执行 clear() 方法之后，该字典就会变成一个空字典

2.get()方法

get() 方法其实就是根据 key 来获取 value，它相当于方括号语法的增强版，当使用方括号语法访问并不存在的 key 时，字典会引发 KeyError 错误；但如果使用 get() 方法访问不存在的 key，该方法会简单地返回 None，不会导致错误。例如如下代码：get() 方法其实就是根据 key 来获取 value，它相当于方括号语法的增强版，当使用方括号语法访问并不存在的 key 时，字典会引发 KeyError 错误；但如果使用 get() 方法访问不存在的 key，该方法会简单地返回 None，不会导致错误。例如如下代码：

 cars = {'BMW': 8.5, 'BENS': 8.3, 'AUDI': 7.9}  
   # 获取'BMW'对应的value 
print(cars.get('BMW')) 
# 8.5 
print(cars.get('PORSCHE')) 
# None  
print(cars['PORSCHE']) 
# KeyError

3.update()方法

update() 方法可使用一个字典所包含的 key-value 对来更新己有的字典。在执行 update() 方法时，如果被更新的字典中己包含对应的 key-value 对，那么原 value 会被覆盖；如果被更新的字典中不包含对应的 key-value 对，则该 key-value 对被添加进去。例如如下代码：

 cars = {'BMW': 8.5, 'BENS': 8.3, 'AUDI': 7.9}  
 cars.update({'BMW':4.5, 'PORSCHE': 9.3}) 
 print(cars)

4.items()、keys()、values()

tems()、keys()、values() 分别用于获取字典中的所有 key-value 对、所有 key、所有 value。这三个方法依次返回 dict_items、dict_keys 和 dict_values 对象，Python 不希望用户直接操作这几个方法，但可通过 list() 函数把它们转换成列表。如下代码示范了这三个方法的用法：

cars = {'BMW': 8.5, 'BENS': 8.3, 'AUDI': 7.9} 
# 获取字典所有的key-value对，返回一个dict_items对象  
ims = cars.items()  
print(type(ims))
# <class 'dict_items'>  
# 将dict_items转换成列表  
print(list(ims)) 
# [('BMW', 8.5), ('BENS', 8.3), ('AUDI', 7.9)]  
# 访问第2个key-value对 
print(list(ims)[1]) 
# ('BENS', 8.3)  
# 获取字典所有的key，返回一个dict_keys对象 
kys = cars.keys()  
print(type(kys)) 
# <class 'dict_keys'> 
# 将dict_keys转换成列表  
print(list(kys))
# ['BMW', 'BENS', 'AUDI']  
# 访问第2个key  
print(list(kys)[1]) 
# 'BENS' 
# 获取字典所有的value，返回一个dict_values对象 
vals = cars.values()  
# 将dict_values转换成列表 
print(type(vals))
# [8.5, 8.3, 7.9] 
# 访问第2个value 
print(list(vals)[1]) # 8.3

5.pop()方法

pop() 方法用于获取指定 key 对应的 value，并删除这个 key-value 对。如下方法示范了 pop() 方法的用法：

cars = {'BMW': 8.5, 'BENS': 8.3, 'AUDI': 7.9} 
print(cars.pop('AUDI')) # 7.9 
print(cars) # {'BMW': 8.5, 'BENS': 8.3}

6.popitem()方法

popitem() 方法用于随机弹出字典中的一个 key-value 对。

此处的随机其实是假的，正如列表的 pop() 方法总是弹出列表中最后一个元素，实际上字典的 popitem() 其实也是弹出字典中最后一个 key-value 对。由于字典存储 key-value 对的顺序是不可知的，因此开发者感觉字典的 popitem() 方法是“随机”弹出的，但实际上字典的 popitem() 方法总是弹出底层存储的最后一个 key-value 对。

cars = {'AUDI': 7.9, 'BENS': 8.3, 'BMW': 8.5}  
print(cars) 
# 弹出字典底层存储的最后一个key-value对   
print(cars.popitem()) # ('AUDI', 7.9) 
print(cars) # {'BMW': 8.5, 'BENS': 8.3}

7.setdefault()方法

setdefault() 方法也用于根据 key 来获取对应 value 的值。但该方法有一个额外的功能，即当程序要获取的 key 在字典中不存在时，该方法会先为这个不存在的 key 设置一个默认的 value，然后再返回该 key 对应的 value。

总之，setdefault() 方法总能返回指定 key 对应的 value；如果该 key-value 对存在，则直接返回该 key 对应的 value；如果该 key-value 对不存在，则先为该 key 设置默认的 value，然后再返回该 key 对应的 value。

如下代码示范了 setdefault() 方法的用法：

  cars = {'BMW': 8.5, 'BENS': 8.3, 'AUDI': 7.9}  
  # 设置默认值，该key在dict中不存在，新增key-value对 
  print(cars.setdefault('PORSCHE', 9.2)) # 9.2  
  print(cars)  # 设置默认值，该key在dict中存在，不会修改dict内容  
  print(cars.setdefault('BMW', 3.4)) # 8.5  
  print(cars)

使用字典格式化字符串

如果要格式化的字符串模板中包含多个变量，后面就需要按顺序给出多个变量，这种方式对于字符串模板中包含少量变量的情形是合适的，但如果字符串模板中包含大量变量，这种按顺序提供变量的方式则有些不合适。可改为在字符串模板中按 key 指定变量，然后通过字典为字符串模板中的 key 设置值。

# 字符串模板中使用key
temp = '教程是:%(name)s, 价格是:%(price)010.2f, 出版社是:%(publish)s' 
book = {'name':'Python基础教程', 'price': 99, 'publish': 'C语言中文网'}  
# 使用字典为字符串模板中的key传入值 
print(temp % book) 
book = {'name':'C语言小白变怪兽', 'price':159, 'publish': 'C语言中文网'} # 使用字典为字符串模板中的key传入值 
print(temp % book)

>>>教程是:Python基础教程, 价格是:0000099.00, 出版社是:C语言中文网
>>>教程是:C语言小白变怪兽, 价格是:0000159.00, 出版社是:C语言中文网