学习网址：https://www.runoob.com/python/python-basic-syntax.html
运行代码后即可生成笔记
未完成部分：数据类型的使用需要练习
#代码如下：
# chapter15:Python3 数据结构
print("\nchapter15:Python3 数据结构\n")
print("1.列表")
print("1)Python中列表是可变的，这是它区别于字符串和元组的最重要的特点，一句话概括即：列表可以修改，而字符串和元组不能。")
print("2)以下是 Python 中列表的方法：")
print("方法 描述\n"
"list.append(x) 把一个元素添加到列表的结尾，相当于 a[len(a):] = [x]。\n"
"list.extend(L) 通过添加指定列表的所有元素来扩充列表，相当于 a[len(a):] = L。\n"
"list.insert(i, x) 在指定位置插入一个元素。第一个参数是准备插入到其前面的那个元素的索引，例如 a.insert(0, x) 会插入到整个列表之前，而 a.insert(len(a), x) 相当于 a.append(x) 。\n"
"list.remove(x) 删除列表中值为 x 的第一个元素。如果没有这样的元素，就会返回一个错误。\n"
"list.pop([i]) 从列表的指定位置移除元素，并将其返回。如果没有指定索引，a.pop()返回最后一个元素。元素随即从列表中被移除。（方法中 i 两边的方括号表示这个参数是可选的，而不是要求你输入一对方括号，你会经常在 Python 库参考手册中遇到这样的标记。）\n"
"list.clear() 移除列表中的所有项，等于del a[:]。\n"
"list.index(x) 返回列表中第一个值为 x 的元素的索引。如果没有匹配的元素就会返回一个错误。\n"
"list.count(x) 返回 x 在列表中出现的次数。\n"
"list.sort() 对列表中的元素进行排序。\n"
"list.reverse() 倒排列表中的元素。\n"
"list.copy() 返回列表的浅复制，等于a[:]。")
print("eg:")
print(">>> a = [66.25, 333, 333, 1, 1234.5]\n"
">>> print(a.count(333), a.count(66.25), a.count('x'))\n"
"2 1 0\n"
">>> a.insert(2, -1)\n"
">>> a.append(333)\n"
">>> a\n"
"[66.25, 333, -1, 333, 1, 1234.5, 333]\n"
">>> a.index(333)\n"
"1\n"
">>> a.remove(333)\n"
">>> a\n"
"[66.25, -1, 333, 1, 1234.5, 333]\n"
">>> a.reverse()\n"
">>> a\n"
"[333, 1234.5, 1, 333, -1, 66.25]\n"
">>> a.sort()\n"
">>> a\n"
"[-1, 1, 66.25, 333, 333, 1234.5]")
print("3)将列表当做堆栈使用")
print("(1)列表方法使得列表可以很方便的作为一个堆栈来使用，堆栈作为特定的数据结构，最先进入的元素最后一个被释放（后进先出）。用 append() 方法可以把一个元素添加到堆栈顶。用不指定索引的 pop() 方法可以把一个元素从堆栈顶释放出来。")
print("eg:")
print(">>> stack = [3, 4, 5]\n"
">>> stack.append(6)\n"
">>> stack.append(7)\n"
">>> stack\n"
"[3, 4, 5, 6, 7]\n"
">>> stack.pop()\n"
"7\n"
">>> stack\n"
"[3, 4, 5, 6]\n"
">>> stack.pop()\n"
"6\n"
">>> stack.pop()\n"
"5\n"
">>> stack\n"
"[3, 4]")
print("4)将列表当作队列使用")
print("(1)也可以把列表当做队列用，只是在队列里第一加入的元素，第一个取出来；但是拿列表用作这样的目的效率不高。在列表的最后添加或者弹出元素速度快，然而在列表里插入或者从头部弹出速度却不快（因为所有其他的元素都得一个一个地移动）。")
print("5)列表推导式")
print("(1)列表推导式提供了从序列创建列表的简单途径。通常应用程序将一些操作应用于某个序列的每个元素，用其获得的结果作为生成新列表的元素，或者根据确定的判定条件创建子序列。")
print("(2)每个列表推导式都在 for 之后跟一个表达式，然后有零到多个 for 或 if 子句。返回结果是一个根据表达从其后的 for 和 if 上下文环境中生成出来的列表。如果希望表达式推导出一个元组，就必须使用括号。")
print("(3)eg:这里我们将列表中每个数值乘三，获得一个新的列表：")
print(">>> vec = [2, 4, 6]\n"
">>> [3*x for x in vec]\n"
"[6, 12, 18]")
print("\neg:")
print(">>> [[x, x**2] for x in vec]\n"
"[[2, 4], [4, 16], [6, 36]]")
print("\neg:对序列里每一个元素逐个调用某方法")
print(">>> freshfruit = [' banana', ' loganberry ', 'passion fruit ']\n"
">>> [weapon.strip() for weapon in freshfruit]\n"
"['banana', 'loganberry', 'passion fruit']")
print("\neg:我们可以用 if 子句作为过滤器：")
print(">>> [3*x for x in vec if x > 3]\n"
"[12, 18]\n"
">>> [3*x for x in vec if x < 2]\n"
"[]")
print("\neg:以下是一些关于循环和其它技巧的演示：")
print(">>> vec1 = [2, 4, 6]\n"
">>> vec2 = [4, 3, -9]\n"
">>> [x*y for x in vec1 for y in vec2]\n"
"[8, 6, -18, 16, 12, -36, 24, 18, -54]\n"
">>> [x+y for x in vec1 for y in vec2]\n"
"[6, 5, -7, 8, 7, -5, 10, 9, -3]\n"
">>> [vec1[i]*vec2[i] for i in range(len(vec1))]\n"
"[8, 12, -54]")
print("\neg:列表推导式可以使用复杂表达式或嵌套函数")
print(">>> [str(round(355/113, i)) for i in range(1, 6)]\n"
"['3.1', '3.14', '3.142', '3.1416', '3.14159']")
print("6)嵌套列表解析")
print("(1)Python的列表还可以嵌套")
print("7)del 语句")
print("(1)使用 del 语句可以从一个列表中依索引而不是值来删除一个元素。这与使用 pop() 返回一个值不同。可以用 del 语句从列表中删除一个切割，或清空整个列表（我们以前介绍的方法是给该切割赋一个空列表）。")
print("eg:")
print(">>> a = [-1, 1, 66.25, 333, 333, 1234.5]\n"
">>> del a[0]\n"
">>> a\n"
"[1, 66.25, 333, 333, 1234.5]\n"
">>> del a[2:4]\n"
">>> a\n"
"[1, 66.25, 1234.5]\n"
">>> del a[:]\n"
">>> a\n"
"[]")
print("(2)也可以用 del 删除实体变量")
print("2.元组和序列")
print("1)元组由若干逗号分隔的值组成")
print("eg:")
print(">>> t = 12345, 54321, 'hello!'\n"
">>> t[0]\n"
"12345\n"
">>> t\n"
"(12345, 54321, 'hello!')\n"
">>> # Tuples may be nested:\n"
"... u = t, (1, 2, 3, 4, 5)\n"
">>> u\n"
"((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))")
print("2)如你所见，元组在输出时总是有括号的，以便于正确表达嵌套结构。在输入时可能有或没有括号， 不过括号通常是必须的（如果元组是更大的表达式的一部分）。")
print("3.集合")
print("1)集合是一个无序不重复元素的集。基本功能包括关系测试和消除重复元素")
print("2)可以用大括号({})创建集合。注意：如果要创建一个空集合，你必须用 set() 而不是 {} ；后者创建一个空的字典")
print("eg:")
print(">>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}\n"
">>> print(basket) # 删除重复的\n"
"{'orange', 'banana', 'pear', 'apple'}\n"
">>> 'orange' in basket # 检测成员\n"
"True\n"
">>> 'crabgrass' in basket\n"
"False\n"
">>> # 以下演示了两个集合的操作\n"
"...\n"
">>> a = set('abracadabra')\n"
">>> b = set('alacazam')\n"
">>> a # a 中唯一的字母\n"
"{'a', 'r', 'b', 'c', 'd'}\n"
">>> a - b # 在 a 中的字母，但不在 b 中\n"
"{'r', 'd', 'b'}\n"
">>> a | b # 在 a 或 b 中的字母\n"
"{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}\n"
">>> a & b # 在 a 和 b 中都有的字母\n"
"{'a', 'c'}\n"
">>> a ^ b # 在 a 或 b 中的字母，但不同时在 a 和 b 中\n"
"{'r', 'd', 'b', 'm', 'z', 'l'}")
print("3)集合也支持推导式：")
print("eg:")
print(">>> a = {x for x in 'abracadabra' if x not in 'abc'}\n"
">>> a\n"
"{'r', 'd'}")
print("4.字典")
print("1)另一个非常有用的 Python 内建数据类型是字典。")
print("2)序列是以连续的整数为索引，与此不同的是，字典以关键字为索引，关键字可以是任意不可变类型，通常用字符串或数值。")
print("3)理解字典的最佳方式是把它看做无序的键=>值对集合。在同一个字典之内，关键字必须是互不相同。")
print("4)一对大括号创建一个空的字典：{}。")
print("eg:")
print(">>> tel = {'jack': 4098, 'sape': 4139}\n"
">>> tel['guido'] = 4127\n"
">>> tel\n"
"{'sape': 4139, 'guido': 4127, 'jack': 4098}\n"
">>> tel['jack']\n"
"4098\n"
">>> del tel['sape']\n"
">>> tel['irv'] = 4127\n"
">>> tel\n"
"{'guido': 4127, 'irv': 4127, 'jack': 4098}\n"
">>> list(tel.keys())\n"
"['irv', 'guido', 'jack']\n"
">>> sorted(tel.keys())\n"
"['guido', 'irv', 'jack']\n"
">>> 'guido' in tel\n"
"True\n"
">>> 'jack' not in tel\n"
"False")
print("5)构造函数 dict() 直接从键值对元组列表中构建字典。如果有固定的模式，列表推导式指定特定的键值对：")
print("eg:")
print(">>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])\n"
"{'sape': 4139, 'jack': 4098, 'guido': 4127}")
print("6)此外，字典推导可以用来创建任意键和值的表达式词典：")
print("eg:")
print(">>> {x: x**2 for x in (2, 4, 6)}\n"
"{2: 4, 4: 16, 6: 36}")
print("7)如果关键字只是简单的字符串，使用关键字参数指定键值对有时候更方便：")
print("eg:")
print(">>> dict(sape=4139, guido=4127, jack=4098)\n"
"{'sape': 4139, 'jack': 4098, 'guido': 4127}")
print("5.遍历技巧")
print("1)在字典中遍历时，关键字和对应的值可以使用 items() 方法同时解读出来：")
print("eg:")
print(">>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}\n"
">>> for k, v in knights.items():\n"
"... print(k, v)\n"
"...\n"
"gallahad the pure\n"
"robin the brave")
print("2)在序列中遍历时，索引位置和对应值可以使用 enumerate() 函数同时得到：")
print("eg:")
print(">>> for i, v in enumerate(['tic', 'tac', 'toe']):\n"
"... print(i, v)\n"
"...\n"
"0 tic\n"
"1 tac\n"
"2 toe")
print("3)同时遍历两个或更多的序列，可以使用 zip() 组合：")
print("eg:")
print(">>> questions = ['name', 'quest', 'favorite color']\n"
">>> answers = ['lancelot', 'the holy grail', 'blue']\n"
">>> for q, a in zip(questions, answers):\n"
"... print('What is your {0}? It is {1}.'.format(q, a))\n"
"...\n"
"What is your name? It is lancelot.\n"
"What is your quest? It is the holy grail.\n"
"What is your favorite color? It is blue.")
print("4)要反向遍历一个序列，首先指定这个序列，然后调用 reversed() 函数：")
print("eg:")
print(">>> for i in reversed(range(1, 10, 2)):\n"
"... print(i)\n"
"...\n"
"9\n"
"7\n"
"5\n"
"3\n"
"1")
print("5)要按顺序遍历一个序列，使用 sorted() 函数返回一个已排序的序列，并不修改原值：")
print("eg:")
print(">>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']\n"
">>> for f in sorted(set(basket)):\n"
"... print(f)\n"
"...\n"
"apple\n"
"banana\n"
"orange\n"
"pear")
#代码运行结果如下：
chapter15:Python3 数据结构
1.列表
1)Python中列表是可变的，这是它区别于字符串和元组的最重要的特点，一句话概括即：列表可以修改，而字符串和元组不能。
2)以下是 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 两边的方括号表示这个参数是可选的，而不是要求你输入一对方括号，你会经常在 Python 库参考手册中遇到这样的标记。）
list.clear() 移除列表中的所有项，等于del a[:]。
list.index(x) 返回列表中第一个值为 x 的元素的索引。如果没有匹配的元素就会返回一个错误。
list.count(x) 返回 x 在列表中出现的次数。
list.sort() 对列表中的元素进行排序。
list.reverse() 倒排列表中的元素。
list.copy() 返回列表的浅复制，等于a[:]。
eg:
a = [66.25, 333, 333, 1, 1234.5]
print(a.count(333), a.count(66.25), a.count(‘x’))
2 1 0a.insert(2, -1)
a.append(333)
a
[66.25, 333, -1, 333, 1, 1234.5, 333]a.index(333)
1a.remove(333)
a
[66.25, -1, 333, 1, 1234.5, 333]a.reverse()
a
[333, 1234.5, 1, 333, -1, 66.25]a.sort()
a
[-1, 1, 66.25, 333, 333, 1234.5]
3)将列表当做堆栈使用
(1)列表方法使得列表可以很方便的作为一个堆栈来使用，堆栈作为特定的数据结构，最先进入的元素最后一个被释放（后进先出）。用 append() 方法可以把一个元素添加到堆栈顶。用不指定索引的 pop() 方法可以把一个元素从堆栈顶释放出来。
eg:stack = [3, 4, 5]
stack.append(6)
stack.append(7)
stack
[3, 4, 5, 6, 7]stack.pop()
7stack
[3, 4, 5, 6]stack.pop()
6stack.pop()
5stack
[3, 4]
4)将列表当作队列使用
(1)也可以把列表当做队列用，只是在队列里第一加入的元素，第一个取出来；但是拿列表用作这样的目的效率不高。在列表的最后添加或者弹出元素速度快，然而在列表里插入或者从头部弹出速度却不快（因为所有其他的元素都得一个一个地移动）。
5)列表推导式
(1)列表推导式提供了从序列创建列表的简单途径。通常应用程序将一些操作应用于某个序列的每个元素，用其获得的结果作为生成新列表的元素，或者根据确定的判定条件创建子序列。
(2)每个列表推导式都在 for 之后跟一个表达式，然后有零到多个 for 或 if 子句。返回结果是一个根据表达从其后的 for 和 if 上下文环境中生成出来的列表。如果希望表达式推导出一个元组，就必须使用括号。
(3)eg:这里我们将列表中每个数值乘三，获得一个新的列表：vec = [2, 4, 6]
[3*x for x in vec]
[6, 12, 18]
eg:
[[x, x**2] for x in vec]
[[2, 4], [4, 16], [6, 36]]
eg:对序列里每一个元素逐个调用某方法
freshfruit = [’ banana’, ’ loganberry ', 'passion fruit ']
[weapon.strip() for weapon in freshfruit]
[‘banana’, ‘loganberry’, ‘passion fruit’]
eg:我们可以用 if 子句作为过滤器：
[3*x for x in vec if x > 3]
[12, 18][3*x for x in vec if x < 2]
[]
eg:以下是一些关于循环和其它技巧的演示：
vec1 = [2, 4, 6]
vec2 = [4, 3, -9]
[x*y for x in vec1 for y in vec2]
[8, 6, -18, 16, 12, -36, 24, 18, -54][x+y for x in vec1 for y in vec2]
[6, 5, -7, 8, 7, -5, 10, 9, -3][vec1[i]*vec2[i] for i in range(len(vec1))]
[8, 12, -54]
eg:列表推导式可以使用复杂表达式或嵌套函数
[str(round(355/113, i)) for i in range(1, 6)]
[‘3.1’, ‘3.14’, ‘3.142’, ‘3.1416’, ‘3.14159’]
6)嵌套列表解析
(1)Python的列表还可以嵌套
7)del 语句
(1)使用 del 语句可以从一个列表中依索引而不是值来删除一个元素。这与使用 pop() 返回一个值不同。可以用 del 语句从列表中删除一个切割，或清空整个列表（我们以前介绍的方法是给该切割赋一个空列表）。
eg:a = [-1, 1, 66.25, 333, 333, 1234.5]
del a[0]
a
[1, 66.25, 333, 333, 1234.5]del a[2:4]
a
[1, 66.25, 1234.5]del a[:]
a
[]
(2)也可以用 del 删除实体变量
2.元组和序列
1)元组由若干逗号分隔的值组成
eg:t = 12345, 54321, ‘hello!’
t[0]
12345t
(12345, 54321, ‘hello!’)Tuples may be nested:
… u = t, (1, 2, 3, 4, 5)
u
((12345, 54321, ‘hello!’), (1, 2, 3, 4, 5))
2)如你所见，元组在输出时总是有括号的，以便于正确表达嵌套结构。在输入时可能有或没有括号， 不过括号通常是必须的（如果元组是更大的表达式的一部分）。
3.集合
1)集合是一个无序不重复元素的集。基本功能包括关系测试和消除重复元素
2)可以用大括号({})创建集合。注意：如果要创建一个空集合，你必须用 set() 而不是 {} ；后者创建一个空的字典
eg: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 中唯一的字母
{‘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’, ‘c’}a ^ b # 在 a 或 b 中的字母，但不同时在 a 和 b 中
{‘r’, ‘d’, ‘b’, ‘m’, ‘z’, ‘l’}
3)集合也支持推导式：
eg:a = {x for x in ‘abracadabra’ if x not in ‘abc’}
a
{‘r’, ‘d’}
4.字典
1)另一个非常有用的 Python 内建数据类型是字典。
2)序列是以连续的整数为索引，与此不同的是，字典以关键字为索引，关键字可以是任意不可变类型，通常用字符串或数值。
3)理解字典的最佳方式是把它看做无序的键=>值对集合。在同一个字典之内，关键字必须是互不相同。
4)一对大括号创建一个空的字典：{}。
eg:tel = {‘jack’: 4098, ‘sape’: 4139}
tel[‘guido’] = 4127
tel
{‘sape’: 4139, ‘guido’: 4127, ‘jack’: 4098}tel[‘jack’]
4098del tel[‘sape’]
tel[‘irv’] = 4127
tel
{‘guido’: 4127, ‘irv’: 4127, ‘jack’: 4098}list(tel.keys())
[‘irv’, ‘guido’, ‘jack’]sorted(tel.keys())
[‘guido’, ‘irv’, ‘jack’]‘guido’ in tel
True‘jack’ not in tel
False
5)构造函数 dict() 直接从键值对元组列表中构建字典。如果有固定的模式，列表推导式指定特定的键值对：
eg:dict([(‘sape’, 4139), (‘guido’, 4127), (‘jack’, 4098)])
{‘sape’: 4139, ‘jack’: 4098, ‘guido’: 4127}
6)此外，字典推导可以用来创建任意键和值的表达式词典：
eg:{x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}
7)如果关键字只是简单的字符串，使用关键字参数指定键值对有时候更方便：
eg:dict(sape=4139, guido=4127, jack=4098)
{‘sape’: 4139, ‘jack’: 4098, ‘guido’: 4127}
5.遍历技巧
1)在字典中遍历时，关键字和对应的值可以使用 items() 方法同时解读出来：
eg:knights = {‘gallahad’: ‘the pure’, ‘robin’: ‘the brave’}
for k, v in knights.items():
… print(k, v)
…
gallahad the pure
robin the brave
2)在序列中遍历时，索引位置和对应值可以使用 enumerate() 函数同时得到：
eg:for i, v in enumerate([‘tic’, ‘tac’, ‘toe’]):
… print(i, v)
…
0 tic
1 tac
2 toe
3)同时遍历两个或更多的序列，可以使用 zip() 组合：
eg: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))
…
What is your name? It is lancelot.
What is your quest? It is the holy grail.
What is your favorite color? It is blue.
4)要反向遍历一个序列，首先指定这个序列，然后调用 reversed() 函数：
eg:for i in reversed(range(1, 10, 2)):
… print(i)
…
9
7
5
3
1
5)要按顺序遍历一个序列，使用 sorted() 函数返回一个已排序的序列，并不修改原值：
eg:basket = [‘apple’, ‘orange’, ‘apple’, ‘pear’, ‘orange’, ‘banana’]
for f in sorted(set(basket)):
… print(f)
…
apple
banana
orange
pear
