Python3简单教程（六）数据结构

相关文件及后续更新会上传至：https://github.com/bloodymandoo/Python3_lesson

#Python数据结构
#列表
#Python中列表是可变的，这是它区别于字符串和元组的重要的特点，一句话概括即：列表可以修改，而字符串和元组不能。
#以下是Python中列表的方法：
# list.append(x)          把一个元素添加到列表的结尾，相当于a[len(a):]=[x]
# list.extend(L)          通过添加指定列表的所有元素来扩充列表，相当于a[len(a):]=L
# list.insert(i,x)        在指定位置插入一个元素。第一个参数是准备插入到其前面的那个元素的索引，例如a.insert(0,x)会插入到整个列表之前，而a.insert(len(a),x)相当于a.append(x)
# list.remove(x)          删除列表中值为x的第一个元素。如果没有这样的元素，就会返回一个错误
# list.pop([i])           从列表的指定位置删除元素，并将其返回。如果没有指定索引，a.pop()返回最后一个元素。
#                         元素随即从列表中被删除。（方法中i两边的方括号表示这个参数是可选的）
# list.clear()            移出列表中的所有项，等于del a[:]
# list.index(x)           返回列表中第一个值为x的元素的索引。如果没有匹配的元素就会返回一个错误
# list.count(x)           返回x在列表中出现的次数
# list.sort()             对列表中的元素进行排序
# list.reverse()          倒排列表中的元素
# list.copy()             返回列表的浅赋值，等于a[:]
a = [66.25,333,333,1,1234.5]
print(a.count(333),a.count(66.25),a.count('x'))         #return 2 1 0
a.insert(2,-1)
a.append(333)
print(a)                                                #return [66.25, 333, -1, 333, 1, 1234.5, 333]
print(a.index(333))                                     #return 1
a.remove(333)
print(a)                                                #return [66.25, -1, 333, 1, 1234.5, 333]
a.reverse()
print(a)                                                #return [333, 1234.5, 1, 333, -1, 66.25]
a.sort()
print(a)                                                #return [-1, 1, 66.25, 333, 333, 1234.5]




# 将列表当做堆栈使用
# 列表方法使得列表可以很方便的作为一个堆栈来使用，堆栈作为特定的数据结构，最先进入的元素最后一个释放
# （后进先出）。用append()方法可以把一个元素添加到堆栈顶。用不指定索引的pop()方法可以把一个元素从堆栈顶
# 释放出来。

from collections import deque
queue = deque(['Eric','John','Michael'])
queue.append('Terry')
queue.append('Graham')
print(queue)                                            #return deque(['Eric', 'John', 'Michael', 'Terry', 'Graham'])
queue.popleft()
queue.popleft()
print(queue)                                            #return deque(['Michael', 'Terry', 'Graham'])



#列表推到式
#列表推导式提供了从序列创建列表的简单途径。通常应用程序将一些操作应用于某个序列的每个元素，用其获得的
# 结果作为生成新列表的元素，或者根据确定的判定条件创建子序列。
# 每个列表推导式都在for之后跟一个表达式，然后有零到多个for或if子句。返回结果是一个根据表达
# 从其后的for和if上下文环境中生成出来的列表。如果希望表达式推到出一个元组，就必须使用括号。
vec = [2,4,6]
print([3*x for x in vec])                               #return [6, 12, 18]
print([[x,x**2] for x in vec])                          #return [[2, 4], [4, 16], [6, 36]]

freshfruit = ['  banana','  loganberry ','passion fruit  ']
print([weapon.strip() for weapon in freshfruit])        #return ['banana', 'loganberry', 'passion fruit']

print([3*x for x in vec if x>3])                        #return [12, 18]
print([3*x for x in vec if x<2])                        #return []

vec1 = [2,4,6]
vec2 = [4,3,-9]
print([x*y for x in vec1 for y in vec2])                #return [8, 6, -18, 16, 12, -36, 24, 18, -54]
print([x+y for x in vec1 for y in vec2])                #return [6, 5, -7, 8, 7, -5, 10, 9, -3]
print([vec1[i]*vec2[i] for i in range(len(vec1))])       #return [8, 12, -54]

print([str(round(355/113,i)) for i in range(1,6)])       #return ['3.1', '3.14', '3.142', '3.1416', '3.14159']



#嵌套列表解析
#Python的列表还可以嵌套
#以下实例展示了3X4的矩阵列表：
matrix = [
    [1,2,3,4],
    [5,6,7,8],
    [9,10,11,12]
]
#以下实例将3X4的矩阵列表转换为4X3列表：
print([[row[i] for row in matrix] for i in range(4)])
#return [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

transposed = []
for i in range(4):
    transposed.append([row[i] for row in matrix])
print(transposed)                                       #return [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]




#del语句
# 使用del语句可以从一个列表中依索引而不是值来删除一个元素。这与使用pop()返回一个值不同。可以用del
# 语句从列表中删除一个切割，或清空整个列表（我们以前介绍的方法是给该切割赋一个空列表）。
a = [0,1,2,3,4,5]
del a[0]
print(a)                                                #return [1, 2, 3, 4, 5]
del a[2:4]
print(a)                                                #return [1, 2, 5]
del a[:]
print(a)                                                #return []



#元组和序列
#元组由若干逗号分隔的值组成，例如：
t = 12345,54321,'hello'
print(t[0])                                             #return 12345
print(t)                                                #return (12345, 54321, 'hello')
u = t , (1,2,3,4,5)
print(u)                                                #return ((12345, 54321, 'hello'), (1, 2, 3, 4, 5))




#集合
# 集合是一个无序不重复元素的集。基本功能包括关系测试和消除重复元素。
# 可以用大括号（{}）创建集合。注意：如果要创建一个集合，你必须用set()而不是{}；后者创建一个空的
# 字典。
basket = {'apple','orange','apple','pear','orange','banana'}
print(basket)                                           #return {'banana', 'apple', 'orange', 'pear'}
print('orange' in basket)                              #return True
a = {x for x in 'asdasfjads' if x not in 'sad'}
print(a)                                                #return {'j', 'f'}



#字典
#另一个非常有用的Python内建数据类型是字典。
#序列事宜连续的整数位索引，与此不同的是，字典以关键字位索引，关键字可以是任意类型，通常用字符串或数值
#理解字典的最佳方法是把它看做无序的键=>值对集合。在同一个字典之内，关键字必须是互不相同
tel = {'jack':4098,'sape':4139}
tel['guido'] = 4127
print(tel)                                              #return {'jack': 4098, 'sape': 4139, 'guido': 4127}
print(list(tel.keys()))                                 #return ['jack', 'sape', 'guido']
print(sorted(tel.keys()))                               #return ['guido', 'jack', 'sape']



#遍历技巧
#在字典中遍历时，关键字和对应的值可以使用items()方法同时解读出来：
knights = {'gallahad':'the pure','robin':'the brave'}
for k,v in knights.items():
    print(k,v)
#return
# gallahad the pure
# robin the brave

#在序列中遍历时，索引位置和对应值可以使用enumerate()函数同时得到：
for i,v in enumerate(['tic','tac','toe']):
    print(i,v)
#return
# 0 tic
# 1 tac
# 2 toe

#同时遍历两个或更多的序列，可以使用zip()组合：
questions = ['name','quest','favorite color']
answers = ['lancelot','the holy grail','blue']
for q,a in zip(questions,answers):
    print('What is your {0}? It is {1}.'.format(q,a))
#return
# What is your name? It is lancelot.
# What is your quest? It is the holy grail.
# What is your favorite color? It is blue.