文章目录
数据结构
1、列表详解
list = []
list.append(x)
在列表末尾添加一个元素，相当于 a[len(a):] = [x] 。
list.extend(iterable)
用可迭代对象的元素扩展列表。相当于 a[len(a):] = iterable 。
list.insert(i, x)
在指定位置插入元素。第一个参数是插入元素的索引，因此，a.insert(0, x) 在列表开头插入元素， a.insert(len(a), x) 等同于 a.append(x) 。
list.remove(x)
从列表中删除第一个值为 x 的元素。未找到指定元素时，触发 ValueError 异常。
list.pop([i])
删除列表中指定位置的元素，并返回被删除的元素。未指定位置时，a.pop() 删除并返回列表的最后一个元素。（方法签名中 i 两边的方括号表示该参数是可选的，不是要求输入方括号。这种表示法常见于 Python 参考库）。
list.clear()
删除列表里的所有元素，相当于 del a[:] 。
list.index(x, start, end)
返回列表中第一个值为 x 的元素的零基索引。未找到指定元素时，触发 ValueError 异常。
可选参数 start 和 end 是切片符号，用于将搜索限制为列表的特定子序列。返回的索引是相对于整个序列的开始计算的，而不是 start 参数。
list.count(x)
返回列表中元素 x 出现的次数。
list.sort(*, key=None, reverse=False)
就地排序列表中的元素（要了解自定义排序参数，详见 sorted()）。
list.reverse()
翻转列表中的元素。
list.copy()
返回列表的浅拷贝。相当于 a[:] 。
水果 = ['橘子', '苹果', '梨', '香蕉', '苹果', '香蕉']
print(水果.count('苹果'))
print(水果.index('香蕉'))
print(水果.reverse())
print(水果)
print(水果.append('葡萄'))
print(水果.sort())
print(水果)
print(水果.pop([1]))
1.1 用列表实现堆栈
使用列表方法实现堆栈非常容易，最后插入的最先取出（“后进先出”）。把元素添加到堆栈的顶端，使用 append() 。从堆栈顶部取出元素，使用 pop() ，不用指定索引
print(水果)
print(水果.append('葡萄')) # 在堆栈顶添加元素
print(水果)
print(水果.pop()) # 在堆栈顶删除刚才添加的元素
print(水果)
1.2 用列表实现队列
列表也可以用作队列，最先加入的元素，最先取出（“先进先出”），然而，列表作为队列的效率很低。因为，在列表末尾添加和删除元素非常快，但在列表开头插入或移除元素却很慢（因为所有其他元素都必须移动一位），实现队列最好用 collections.deque，可以快速从两端添加或删除元素。例如：
from _collections import deque
queue = deque(["eric", 'john', 'micheal'])
print(queue.append('terry'))
print(queue.append('graham'))
print(queue.popleft())
print(queue.popleft())
print(queue)
C:\Python39\python.exe C:/Users/mc/Desktop/python基础/tiaoce.py
None
None
eric
john
deque(['micheal', 'terry', 'graham'])
1.3 列表推导式
列表推导式创建列表的方式更简洁
常见的用法为：对序列或可迭代对象中的每个元素应用某种操作，用生成的结果创建新的列表；或用满足特定条件的元素创建子序列
squares1 = []
for x in range(10):
squares1.append(x**2)
print(squares1)
squares2 = list(map(lambda x: x*2, range(10)))
squares3 = [x**2 for x in range(10)]
列表推导式的方括号：
- 一个表达式，后面为一个 for 子句，
- 然后，是零个或多个 for 或 if 子句。结果是由表达式依据 for 和 if 子句求值计算而得出一个新列表。
- 下面两段代码中，for 和 if 的顺序相同
l1 = [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
print(l1)
l2 = []
for x in [1,2,3]:
for y in [3,1,4]:
if x != y:
l2.append((x,y))
print(l2)
C:\Python39\python.exe C:/Users/mc/Desktop/python基础/tiaoce.py
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
>>> vec = [-4, -2, 0, 2, 4]
>>> # create a new list with the values doubled
>>> [x*2 for x in vec]
[-8, -4, 0, 4, 8]
>>> # filter the list to exclude negative numbers
>>> [x for x in vec if x >= 0]
[0, 2, 4]
>>> # apply a function to all the elements
>>> [abs(x) for x in vec]
[4, 2, 0, 2, 4]
>>> # call a method on each element
>>> freshfruit = [' banana', ' loganberry ', 'passion fruit ']
>>> [weapon.strip() for weapon in freshfruit]
['banana', 'loganberry', 'passion fruit']
>>> # create a list of 2-tuples like (number, square)
>>> [(x, x**2) for x in range(6)]
[(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25)]
>>> # the tuple must be parenthesized, otherwise an error is raised
>>> [x, x**2 for x in range(6)]
File "<stdin>", line 1, in <module>
[x, x**2 for x in range(6)]
^
SyntaxError: invalid syntax
>>> # flatten a list using a listcomp with two 'for'
>>> vec = [[1,2,3], [4,5,6], [7,8,9]]
>>> [num for elem in vec for num in elem]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
from math import pi
l = [str(round(pi,i)) for i in range(1, 6)]
print(l)
C:\Python39\python.exe C:/Users/mc/Desktop/python基础/tiaoce.py
['3.1', '3.14', '3.142', '3.1416', '3.14159']
1.4 嵌套的列表推导式
matrix = [
[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12],
]
# 嵌套的列表推导式
l1 = [[row[i] for row in matrix] for i in range(4)]
print(l1)
# 单for循环
l2 = []
for i in range(4):
l2.append([row[i] for row in matrix])
print(l2)
# 双for循环
l3 = []
for i in range(4):
l4 = []
for row in matrix:
l4.append(row[i])
l3.append(l4)
print(l3)
# 实际应用中，最好用内置函数替代复杂的流程语句
l5 = list(zip(*matrix))
print(l5)
2、del语句
del 语句按索引，而不是值从列表中移除元素。与返回值的 pop() 方法不同， del 语句也可以从列表中移除切片，或清空整个列表（之前是将空列表赋值给切片
a = [-1, 1, 66.25, 333, 333, 1234.5]
del a[0]
print(a)
del a[2:4]
print(a)
del a[:]
print(a)
C:\Python39\python.exe C:/Users/mc/Desktop/python基础/tiaoce.py
[1, 66.25, 333, 333, 1234.5]
[1, 66.25, 1234.5]
[]
3、元组和序列
- 元组由多个用逗号隔开的值组成，输入时，圆括号可有可无，不过经常是必须的，输出时，元组都要由圆括号标注，这样才能正确地解释嵌套元组，例如：
>>> t = 12345, 54321, 'hello!' # 或者 12345, 54321, 'hello!' = t
>>> t[0]
12345
>>> t
(12345, 54321, 'hello!')
>>> # Tuples may be nested:
... u = t, (1, 2, 3, 4, 5)
>>> u
((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))
>>> # Tuples are immutable:
... t[0] = 88888
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> # but they can contain mutable objects:
... v = ([1, 2, 3], [3, 2, 1])
>>> v
([1, 2, 3], [3, 2, 1])
- 创建空元组、创建只有一个元素的元组
>>> empty = ()
>>> singleton = 'hello', # <-- note trailing comma
>>> len(empty)
0
>>> len(singleton)
1
>>> singleton
('hello',)
4、集合
- 集合是由不重复元素组成的无序容器。基本用法包括成员检测、消除重复元素。集合对象支持合集、交集、差集、对称差分等数学运算
- 建集合用花括号或 set() 函数，空集合只能是set函数
>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket) # show that duplicates have been removed
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket # fast membership testing
True
>>> 'crabgrass' in basket
False
>>> # Demonstrate set operations on unique letters from two words
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a # 集合元素的唯一性
{'a', 'r', 'b', 'c', 'd'}
>>> a - b # x与y的差集
{'r', 'd', 'b'}
>>> a | b # 并集
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b # 交集
{'a', 'c'}
>>> a ^ b # 对称差集
{'r', 'd', 'b', 'm', 'z', 'l'}
5、字典
- 字典 （参见 映射类型 — dict） 也是一种常用的 Python 內置数据类型，字典以 关键字 为索引，关键字通常是字符串或数字，也可以是其他任意不可变类型。
- 可以把字典理解为 键值对 的集合，但字典的键必须是唯一的。花括号 {} 用于创建空字典。另一种初始化字典的方式是，在花括号里输入逗号分隔的键值对，这也是字典的输出方式。
- 字典的主要用途是通过关键字存储、提取值。用 del 可以删除键值对。用已存在的关键字存储值，与该关键字关联的旧值会被取代。通过不存在的键提取值，则会报错。
tel = {'jack': 4098, 'sape': 4139}
tel['guido'] = 4127
print(tel)
print(tel['jack'])
del tel['sape']
tel['irv'] = 4127
print(tel)
print(list(tel))
print(sorted(tel))
# 检查字典里是否存在某个键，使用关键字 in。
if 'guido' in tel:
print("cunzia")
- dict() 构造函数可以直接用键值对序列创建字典：
a = dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
print(a)
C:\Python39\python.exe C:/Users/mc/Desktop/python基础/tiaoce.py
{'sape': 4139, 'guido': 4127, 'jack': 4098}
- 关键字是比较简单的字符串时，直接用关键字参数指定键值对更便捷：
a = dict(sape=4139, guido=4127, jack=4098)
print(a)
C:\Python39\python.exe C:/Users/mc/Desktop/python基础/tiaoce.py
{'sape': 4139, 'guido': 4127, 'jack': 4098}
- 字典推导式可以用任意键值表达式创建字典：
a = {x: x**2 for x in (2, 4, 6)}
print(a)
C:\Python39\python.exe C:/Users/mc/Desktop/python基础/tiaoce.py
{2: 4, 4: 16, 6: 36}
6、循环的技巧
- 在字典中循环时，用 items() 方法可同时取出键和对应的值：
>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}
>>> for k, v in knights.items():
... print(k, v)
- 在序列中循环时，用 enumerate() 函数可以同时取出位置索引和对应的值：
>>> for i, v in enumerate(['tic', 'tac', 'toe']):
... print(i, v)
...
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(q,a)
- 逆向循环序列时，先正向定位序列，然后调用 reversed() 函数
for i in reversed(range(1, 10, 2)):
print(i)
- 按指定顺序循环序列，可以用 sorted() 函数，在不改动原序列的基础上，返回一个重新的序列：
basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> for i in sorted(basket):
... print(i)
- 使用 sorted() 加 set() 则按排序后的顺序，循环遍历序列中的唯一元
>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> for f in sorted(set(basket)):
... print(f)
...
apple
banana
orange
pear
7、深入条件控制
- while 和 if 条件句不只可以进行比较，还可以使用任意运算符。
- 比较操作支持链式操作。例如，a < b == c 校验 a 是否小于 b，且 b 是否等于 c。
- 比较操作可以用布尔运算符 and 和 or 组合,因此，A and not B or C 等价于 (A and (not B)) or C。与其他运算符操作一样，此处也可以用圆括号表示想要的组合
8、序列和其他类型的对比
序列对象可以与相同序列类型的其他对象比较。这种比较使用 字典式 顺序：首先，比较前两个对应元素，如果不相等，则可确定比较结果；如果相等，则比较之后的两个元素，以此类推，直到其中一个序列结束。如果要比较的两个元素本身是相同类型的序列，则递归地执行字典式顺序比较。如果两个序列中所有的对应元素都相等，则两个序列相等。如果一个序列是另一个的初始子序列，则较短的序列可被视为较小（较少）的序列。 对于字符串来说，字典式顺序使用 Unicode 码位序号排序单个字符。下面列出了一些比较相同类型序列的例子：
(1, 2, 3) < (1, 2, 4)
[1, 2, 3] < [1, 2, 4]
'ABC' < 'C' < 'Pascal' < 'Python'
(1, 2, 3, 4) < (1, 2, 4)
(1, 2) < (1, 2, -1)
(1, 2, 3) == (1.0, 2.0, 3.0)
(1, 2, ('aa', 'ab')) < (1, 2, ('abc', 'a'), 4)
扫一扫
523
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
