Chapter 2 Python基础

2.2 Python数据结构

数据结构（Data Structures）是结构化的变量，可以理解为变量的集合（collection）。

2.2.1 列表（List）

列表由一系列按特定顺序排列的元素组成。列表根据索引，按照0, 1, 2, . . .的顺序存储值。在Python中， 用方括号[ ] 来表示列表， 并用逗号来分隔其中的元素。

>>> list() #创建空列表
>>> [ ] #创建空列表
>>> a = [1, 2, 3, 4, 5] # 生成列表
>>> print(a) # 输出列表的内容
>>> len(a) # 获取列表的长度
>>> a[0] # 访问第一个元素的值,索引由0开始
>>> a[4] = 99 # 赋值（team assignment）

（1）List 添加

添加列表最简单的方法是通过逻辑运算符进行：

>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> c = a + b
>>> print(c)
[1, 2, 3, 4, 5, 6]
>>> print(a)
[1, 2, 3]

• list.append()尾部添加

>>> girls = []
>>> girls.append('Mary')
>>> print(girls)
['Mary']

• list.extend()列表追加

>>> models = ['Amy']
>>> girls.extend(models)
>>> print(girls)
['Mary','Amy']

• list.insert()指定位置添加

>>> girls.insert(1,'Cindy')
>>> print(girls)
['Mary', 'Cindy', 'Amy']

（2）List 移除

• 用del进行删除列表元素

words = ['cat','hello','pen','pencil','ruler']
del words[0]
print(words)

['hello', 'pen', 'pencil', 'ruler']

• list.remove(x) 删除列表第一个出现值为x的项或指定成员

>>> a = [1,2,3,4,1,1,-1]
>>>a.remove(2) # 删除列表中第一个出现的值为2的项
>>>print(a)
> [1, 3, 4, 1, 1, -1]

words = ['cat','hello','pen','pencil','ruler']
words.remove('cat')
print(words)

['hello', 'pen', 'pencil', 'ruler']

• 用list.pop删除指定索引

words = ['cat','hello','pen','pencil','ruler']
words.pop(0)
print(words)

['hello', 'pen', 'pencil', 'ruler']

（3）List 索引及切片

• 显示特定位

>>>a = [1,2,3,4,1,1,-1]
print(a[0])  # 显示列表a的第0位的值
> 1

>>>print(a[-1]) # 显示列表a的最末位的值
> -1

• 在Python中处理列表的部分元素，称之为切片。
  创建切片，可指定要使用的第一个元素和最后一个元素的索引。注意：左闭右开
  将截取的结果再次存放在一个列表中并返回。
  Python提供slicing切片标记，可访问子列表。

>>> a[0:2] # 获取索引为0到2（不包括2！）的元素
>[1, 2]
>>> a[1:] # 获取从索引为1的元素到最后一个元素
>[2, 3, 4, 99]
>>> a[:3] # 获取从第一个元素到索引为3**（不包括3！）**的元素
>[1, 2, 3]
>>> a[:-1] # 获取从第一个元素到最后一个元素的前一个元素之间的元素
>[1, 2, 3, 4]
>>> a[:-2] # 获取从第一个元素到最后一个元素的前二个元素之间的元素
>[1, 2, 3]

• list.index()打印某个值的索引

>>>a = [1,2,3,4,1,1,-1]
>>>print(a.index(2)) # 显示列表a中第一次出现的值为2的项的索引
> 1

• list.count()统计列表中某个值出现的次数

>>>a = [4,1,2,3,4,1,1,-1]
>>>print(a.count(-1))
> 1

（4）List 排序

• 列表排序

list.sort() 从小到大排序

>>> a = [4,1,2,3,4,1,1,-1]
>>> a.sort() # 默认从小到大排序
>>> print(a)
> [-1, 1, 1, 1, 2, 3, 4, 4]

list.sort(reverse=True) 从大到小排序

>>> a.sort(reverse=True) # 从大到小排序
>>> print(a)
> [4, 4, 3, 2, 1, 1, 1, -1]
> 1

（5）List 元素修改

• 通过下标找到元素，然后用=赋值

fruits = ['apple','pear','banana','pineapple','草莓']
fruits[-1] = 'strawberry'
print(fruits)

['apple', 'pear', 'banana', 'pineapple', 'strawberry']

• 用判断语句进行寻找，进行赋值

for fruit in fruits:
    if '草莓' in fruit:
        fruit = 'strawberry'
print(fruits)

for i in range(len(fruits)):
    if '草莓' in fruits[i]:
        fruits[i] = 'strawberry'
        break
print(fruits)

• 常见的列表操作函数
  

（6）多维列表 Multi-dimension List

一维的List是线性的List，多维List是一个平面的List，相当于矩阵

>>>a = [1,2,3,4,5] # 一行五列

>>> multi_dim_a = [[1,2,3],
			      [2,3,4],
			      [3,4,5]] # 三行三列

• 根据索引检索

>>>print(a[1])
>2
>>>print(multi_dim_a[0][1])
>2

2.2.2 元组（Tuple）

用小括号、或者无括号来表述，是一连串有顺序的数字。特殊的列表，建立后不能改变数据项。

与字符串类似，元组的元素不可改变，也不能排序。因此元组更为高效。
注意：元组中只有一个元素时，需要在后面加逗号！

>>> () #创建空元组
>>> tuple() #创建空元组
>>> (1,) #创建只有一个元素的元组
>>> print(a) # 输出列表的内容
>>> len(a) # 获取列表的长度
>>> a[0] # 访问第一个元素的值,索引由0开始
>>> a[4] = 99 # 赋值

可以同时赋值：

>>> (x, y) = (4, 'fred')
>>> print(y)
fred
>>> (a, b) = (99, 98)
>>> print(a)
99

元组可以比较：

>>> (0, 1, 2) < (5, 1, 2)
True
>>> (0, 1, 200000) < (0, 3, -4)
True

>>> ('Jones', 'Sally') < ('Jones', 'Sam')
True
>>> ('Jones', 'Sally') > ('Adams', 'Sam')
True

list和tuple的元素均可以逐个迭代、输出、运用和定位

• 逐个输出

>>> for content in a_list:
    print(content)
>>> for content_tuple in a_tuple:
    print(content_tuple)

• 带索引依次输出

>>> for index in range(len(a_list)):
   print("index = ", index, ", number in list = ", a_list[index])
>>> for index in range(len(a_tuple)):
   print("index = ", index, ", number in tuple = ", a_tuple[index])

2.2.3 字典（dictionary）

字典以键值对的形式存储数据。List是有顺序地输出输入，字典的存档形式则无需顺序。
列表采取的是遍历搜索，但是字典直接计算存放位置，就像查字典一样，速度更快。
但是字典需要占用大量内存，产生浪费。

字典包括关键字和值，称为键值对（Associative arrays）。

可以将字典理解成每个元组带有两个元素的无序列表。

• 结构

dictionary ={key:value} 

（1）基本用法

• dictionary = {key:value} 生成字典

>>> me = {'height':180} 

• dictionary[key] 访问元素

>>> me['height'] 
180

• dictionary[key]=value添加元素

>>> me['weight'] = 70
>>> print(me)
{'height': 180, 'weight': 70}

• key或者value可以是数字或字符串

>>> d = {1:'a','c':'b'} 

• 可嵌套列表、字典和函数

>>> d4 = {'apple':[1,2,3], 'pear':{1:3, 3:'a'}, 'orange':func}
>>> print(d4['pear'][3])    
> a

• 列表可转换字典，前提是列表元素成对出现

>>> d5 = dict([('name','Mary'),('weight',45)])
>>> print(d5)
{'name': 'Mary', 'weight': 45}

• 一个key只对应一个value，多次赋值会更新。

>>> me['weight'] = 90
>>> me['weight']
90
>>> me['weight'] = 80
>>> me['weight']
80

• 若key不存在，会报错。为避免错误，可以通过in判断键是否存在

>>> d['age']
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'age'

>>> 'age' in me
False

（2）dict获得键、值、键值对

• dict.get() 获得值
  与直接访问类似

语法：

dict.get(key, default=None)

key – 字典中要查找的键。
default – 如果指定键的值不存在时，返回该默认值。
除了用in方法，dict.get()也可以判断键是否存在，不存在返回None，交互环境不显示结果。

设置默认值为0

>>> me = {'height':180,'weight':70}
>>> me.get('height', 0) 
180

• dict.keys() 获得键的迭代器，保存在列表中

>>> d6.keys()
dict_keys(['me', 'Mary', 'Amy'])

• dict.values() 获得值的迭代器，保存在列表中

>>> d6.values()
dict_values([180, 160, 170])

• dict.items() 返回所有键值对组成的迭代器

>>> me.items()
dict_items([('height', 180), ('weight', 70)])

>>> d6.items()
dict_items([('me', 180), ('Mary', 160), ('Amy', 170)])
>>> for key,value in d6.items():
	if value>165:
		print(key)
me
Amy

（2）dict删除键

• del dict[key] 删除键值对

>>> del me['height'] 

• dict.pop() 删除键值对

>>>me.pop('weight')
80
>>>print(me）
{'height': 180}

（2）dict排序

按键排序：

>>> d = { 'a': 10, 'b': 1, 'c': 22}
>>> t = sorted(d.items())
>>> t
[('a', 10), ('b', 1), ('c', 22)]
>>> for k, v in sorted(d.items()):
	print(k, v)

	
a 10
b 1
c 22

按值排序， 增加临时的列表：
法一：利用for语句

>>> c = { 'a': 10, 'b': 1, 'c': 22}
>>> tmp = list()
>>> for k,v in c.items() :
	tmp.append( (v, k) )

	
>>> print(tmp)
[(10, 'a'), (1, 'b'), (22, 'c')]
>>> tmp = sorted(tmp, reverse = True)
>>> print(tmp)
[(22, 'c'), (10, 'a'), (1, 'b')]

法二：利用列表推导式（list comprehension）

>>> c = { 'a': 10, 'b': 1, 'c': 22}
>>> print( sorted ([ (v, k) for k,v in c.items()] ) )
[(1, 'b'), (10, 'a'), (22, 'c')]

• 常见的字典操作函数
  

dict的key必须是不可变对象。因为需要根据key计算value（Hash算法）。字符串、整数等可作为键，列表就不能作为键。

2.2.4 集合（set）

set() 的特点是会去除重复项，输出结果无序。可以理解成集合的元素具有唯一性。

（1）基本用法

• set 序列

>>> s = set(['python', 'python2', 'python3','python'])
>>> for item in s:
>    print(item)

输出

python, python3, python2

• set 字符串

sentence = 'Welcome Back to This Tutorial'
print(set(sentence))

输出 {‘l’, ‘m’, ‘a’, ‘c’, ‘t’, ‘r’, ‘s’, ’ ', ‘o’, ‘W’, ‘T’, ‘B’, ‘i’, ‘e’, ‘u’, ‘h’, ‘k’}

• set 集合相加
  两者要为同个数据类型

print(set(char_list + list(sentence)))

输出 {‘l’, ‘m’, ‘a’, ‘c’, ‘t’, ‘r’, ‘s’, ’ ', ‘d’, ‘o’, ‘W’, ‘T’, ‘B’, ‘i’, ‘e’, ‘k’, ‘h’, ‘u’, ‘b’}

• set 交集

>>> s1 = set([1, 2, 3])
>>> s2 = set([2, 3, 4])
>>> s1 & s2
{2, 3}

• set 并集

>>> s1 = set([1, 2, 3])
>>> s2 = set([2, 3, 4])
>>> s1 | s2
{1, 2, 3, 4}

（2）操作函数

• set.add() 添加元素
  只能一个个元素加，不能加列表等。重复元素不累加。

unique_char.add('x')
print(unique_char)

输出

 {'x', 'b', 'd', 'c', 'a'}

• set.remove()清除元素

unique_char.remove('x')
print(unique_char)

输出

{'b', 'd', 'c', 'a'}

但是如果集合没有该元素，使用set.remove()，系统会报错

• set.discard()清除元素

如果集合没有该元素，使用set.discard()，系统就不会报错

同理：

unique_char.discard('d')
print(unique_char)

输出{'b', 'c', 'a'}

• set.clear() 清除集合所有元素

unique_char.clear()
print(unique_char)

输出 set()

• set.difference()寻找差集

set1 = set(['x', 'b', 'd', 'c', 'a'])
set2 = set(['a','e','i'])
print(set1.difference(set2))

输出{'d','b','x','c'}

• set.intersection()寻找交集

print(set1.intersection(set2))

输出{'a'}

2.2.5 序列操作

序列表示索引为非负整数的有序对象的集合，包括字符串、列表和元组。序列切片操作已在列表中介绍。
序列常用操作函数：
===============================================================================================
Python学习的内容参考
《Python编程：从入门到实践》-[美] Eric Matthes
《21天学通PYTHON》
莫烦Python
廖雪峰的Python教程
等