铜川做网站的公司电话,机械手表网站,网站开发是否用html5,wordpress标签使用方法列表
Python中列表是可变的#xff0c;这是它区别于字符串和元组的最重要的特点#xff0c;一句话概括即#xff1a;列表可以修改#xff0c;而字符串和元组不能。
以下是 Python 中列表的方法#xff1a;
方法描述list.append(x)把一个元素添加到列表的结尾#xff0…列表
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 两边的方括号表示这个参数是可选的而不是要求你输入一对方括号你会经常在 Python 库参考手册中遇到这样的标记。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))
2 1 0
\ a.insert(2, -1)
\ a.append(333)
\ a
\[66.25, 333, -1, 333, 1, 1234.5, 333\]
\ a.index(333)
1
\ a.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\] 注意类似 insert, remove 或 sort 等修改列表的方法没有返回值。 将列表当做栈使用
在 Python 中可以使用列表list来实现栈的功能。栈是一种后进先出LIFO, Last-In-First-Out数据结构意味着最后添加的元素最先被移除。列表提供了一些方法使其非常适合用于栈操作特别是 append() 和 pop() 方法。
用 append() 方法可以把一个元素添加到栈顶用不指定索引的 pop() 方法可以把一个元素从栈顶释放出来。
栈操作
压入Push: 将一个元素添加到栈的顶端。弹出Pop: 移除并返回栈顶元素。查看栈顶元素Peek/Top: 返回栈顶元素而不移除它。检查是否为空IsEmpty: 检查栈是否为空。获取栈的大小Size: 获取栈中元素的数量。
以下是如何在 Python 中使用列表实现这些操作的详细说明
1、创建一个空栈
2、压入Push操作
使用 append() 方法将元素添加到栈的顶端
实例
stack.append(1)
stack.append(2)
stack.append(3)
print(stack) \# 输出: \[1, 2, 3\] 3、弹出Pop操作
使用 pop() 方法移除并返回栈顶元素
实例
top\_element \ stack.pop()
print(top\_element) \# 输出: 3
print(stack) \# 输出: \[1, 2\] 4、查看栈顶元素Peek/Top
直接访问列表的最后一个元素不移除
实例
top\_element \ stack\[\-1\]
print(top\_element) \# 输出: 2 5、检查是否为空IsEmpty
检查列表是否为空
实例
is\_empty \ len(stack) \ 0
print(is\_empty) \# 输出: False 6、获取栈的大小Size
使用 len() 函数获取栈中元素的数量
实例
size \ len(stack)
print(size) \# 输出: 2 实例
以下是一个完整的实例展示了如何使用上述操作来实现一个简单的栈
class Stack: def \_\_init\_\_(self): self.stack \ \[\]def push(self, item): self.stack.append(item)def pop(self): if not self.is\_empty(): return self.stack.pop() else: raise IndexError(pop from empty stack)def peek(self): if not self.is\_empty(): return self.stack\[\-1\] else: raise IndexError(peek from empty stack)def is\_empty(self): return len(self.stack) \ 0def size(self): return len(self.stack)# 使用示例
stack \ Stack()
stack.push(1)
stack.push(2)
stack.push(3)print(栈顶元素:, stack.peek()) \# 输出: 栈顶元素: 3
print(栈大小:, stack.size()) \# 输出: 栈大小: 3print(弹出元素:, stack.pop()) \# 输出: 弹出元素: 3
print(栈是否为空:, stack.is\_empty()) \# 输出: 栈是否为空: False
print(栈大小:, stack.size()) \# 输出: 栈大小: 2以上代码中我们定义了一个 Stack 类封装了列表作为底层数据结构并实现了栈的基本操作。
输出结果如下
span栈顶元素:/spanspan /spanspan3/spanspan
/spanspan栈大小:/spanspan /spanspan3/spanspan
/spanspan弹出元素:/spanspan /spanspan3/spanspan
/spanspan栈是否为空:/spanspan /spanspanFalse/spanspan
/spanspan栈大小:/spanspan /spanspan2/span将列表当作队列使用
在 Python 中列表list可以用作队列queue但由于列表的特点直接使用列表来实现队列并不是最优的选择。
队列是一种先进先出FIFO, First-In-First-Out的数据结构意味着最早添加的元素最先被移除。
使用列表时如果频繁地在列表的开头插入或删除元素性能会受到影响因为这些操作的时间复杂度是 O(n)。为了解决这个问题Python 提供了 collections.deque它是双端队列可以在两端高效地添加和删除元素。
使用 collections.deque 实现队列
collections.deque 是 Python 标准库的一部分非常适合用于实现队列。
以下是使用 deque 实现队列的示例
实例
from collections import deque\# 创建一个空队列
queue \ deque()\# 向队尾添加元素
queue.append(a)
queue.append(b)
queue.append(c)print(队列状态:, queue) \# 输出: 队列状态: deque(\[a, b, c\])\# 从队首移除元素
first\_element \ queue.popleft()
print(移除的元素:, first\_element) \# 输出: 移除的元素: a
print(队列状态:, queue) \# 输出: 队列状态: deque(\[b, c\])\# 查看队首元素不移除
front\_element \ queue\[0\]
print(队首元素:, front\_element) \# 输出: 队首元素: b\# 检查队列是否为空
is\_empty \ len(queue) \ 0
print(队列是否为空:, is\_empty) \# 输出: 队列是否为空: False\# 获取队列大小
size \ len(queue)
print(队列大小:, size) \# 输出: 队列大小: 2使用列表实现队列
虽然 deque更高效但如果坚持使用列表来实现队列也可以这么做。以下是如何使用列表实现队列的示例
1. 创建队列
2. 向队尾添加元素
使用 append() 方法将元素添加到队尾
实例
queue.append(a)
queue.append(b)
queue.append(c)
print(队列状态:, queue) \# 输出: 队列状态: \[a, b, c\] 3. 从队首移除元素
使用 pop(0) 方法从队首移除元素
实例
first\_element \ queue.pop(0)
print(移除的元素:, first\_element) \# 输出: 移除的元素: a
print(队列状态:, queue) \# 输出: 队列状态: \[b, c\] 4. 查看队首元素不移除
直接访问列表的第一个元素
实例
front\_element \ queue\[0\]
print(队首元素:, front\_element) \# 输出: 队首元素: b 5. 检查队列是否为空
检查列表是否为空
实例
is\_empty \ len(queue) \ 0
print(队列是否为空:, is\_empty) \# 输出: 队列是否为空: False 6. 获取队列大小
使用 len() 函数获取队列的大小
实例
size \ len(queue)
print(队列大小:, size) \# 输出: 队列大小: 2 实例使用列表实现队列
实例
class Queue: def \_\_init\_\_(self): self.queue \ \[\]def enqueue(self, item): self.queue.append(item)def dequeue(self): if not self.is\_empty(): return self.queue.pop(0) else: raise IndexError(dequeue from empty queue)def peek(self): if not self.is\_empty(): return self.queue\[0\] else: raise IndexError(peek from empty queue)def is\_empty(self): return len(self.queue) \ 0def size(self): return len(self.queue)\# 使用示例
queue \ Queue()
queue.enqueue(a)
queue.enqueue(b)
queue.enqueue(c)print(队首元素:, queue.peek()) \# 输出: 队首元素: a
print(队列大小:, queue.size()) \# 输出: 队列大小: 3print(移除的元素:, queue.dequeue()) \# 输出: 移除的元素: a
print(队列是否为空:, queue.is\_empty()) \# 输出: 队列是否为空: False
print(队列大小:, queue.size()) \# 输出: 队列大小: 2虽然可以使用列表来实现队列但使用 collections.deque 会更高效和简洁。它提供了 O(1) 时间复杂度的添加和删除操作非常适合队列这种数据结构。 列表推导式
列表推导式提供了从序列创建列表的简单途径。通常应用程序将一些操作应用于某个序列的每个元素用其获得的结果作为生成新列表的元素或者根据确定的判定条件创建子序列。
每个列表推导式都在 for 之后跟一个表达式然后有零到多个 for 或 if 子句。返回结果是一个根据表达从其后的 for 和 if 上下文环境中生成出来的列表。如果希望表达式推导出一个元组就必须使用括号。
这里我们将列表中每个数值乘三获得一个新的列表 vec [2, 4, 6] [3*x for x in vec] [6, 12, 18]
现在我们玩一点小花样 [[x, x**2] for x in vec] [[2, 4], [4, 16], [6, 36]]
这里我们对序列里每一个元素逐个调用某方法
实例
\ freshfruit \ \[ banana, loganberry , passion fruit \]
\ \[weapon.strip() for weapon in freshfruit\]
\[banana, loganberry, passion fruit\] 我们可以用 if 子句作为过滤器
\ \[3\*x for x in vec if x \ 3\]
\[12, 18\]
\ \[3\*x for x in vec if x 2\]
\[\] 以下是一些关于循环和其它技巧的演示
\ 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\]
\ \[xy 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\] 列表推导式可以使用复杂表达式或嵌套函数
\ \[str(round(355/113, i)) for i in range(1, 6)\]
\[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列表
\ \[\[row\[i\] for row in matrix\] for i in range(4)\]
\[\[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\])
...
\ transposed
\[\[1, 5, 9\], \[2, 6, 10\], \[3, 7, 11\], \[4, 8, 12\]\] 另外一种实现方法
\ transposed \ \[\]
\ for i in range(4):
... \# the following 3 lines implement the nested listcomp
... transposed\_row \ \[\]
... for row in matrix:
... transposed\_row.append(row\[i\])
... transposed.append(transposed\_row)
...
\ transposed
\[\[1, 5, 9\], \[2, 6, 10\], \[3, 7, 11\], \[4, 8, 12\]\] del 语句
使用 del 语句可以从一个列表中根据索引来删除一个元素而不是值来删除元素。这与使用 pop() 返回一个值不同。可以用 del 语句从列表中删除一个切割或清空整个列表我们以前介绍的方法是给该切割赋一个空列表。例如
\ 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
\[\] 也可以用 del 删除实体变量
spangt;gt;gt;/spanspan /spanspandel/spanspan a/span元组和序列
元组由若干逗号分隔的值组成例如
\ t \ 12345, 54321, hello!
\ 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)) 如你所见元组在输出时总是有括号的以便于正确表达嵌套结构。在输入时可能有或没有括号 不过括号通常是必须的如果元组是更大的表达式的一部分。 集合
集合是一个无序不重复元素的集。基本功能包括关系测试和消除重复元素。
可以用大括号({})创建集合。注意如果要创建一个空集合你必须用 set() 而不是 {} 后者创建一个空的字典下一节我们会介绍这个数据结构。
以下是一个简单的演示
\ 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}集合也支持推导式\ a \ {x for x in abracadabra if x not in abc}
\ a
{r, d} 字典
另一个非常有用的 Python 内建数据类型是字典。
序列是以连续的整数为索引与此不同的是字典以关键字为索引关键字可以是任意不可变类型通常用字符串或数值。
理解字典的最佳方式是把它看做无序的键值对集合。在同一个字典之内关键字必须是互不相同。
一对大括号创建一个空的字典{}。
这是一个字典运用的简单例子
\ tel \ {jack: 4098, sape: 4139}
\ tel\[guido\] \ 4127
\ tel
{sape: 4139, guido: 4127, jack: 4098}
\ tel\[jack\]
4098
\ del 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 构造函数 dict() 直接从键值对元组列表中构建字典。如果有固定的模式列表推导式指定特定的键值对
\ dict(\[(sape, 4139), (guido, 4127), (jack, 4098)\])
{sape: 4139, jack: 4098, guido: 4127} 此外字典推导可以用来创建任意键和值的表达式词典
\ {x: x\*\*2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36} 如果关键字只是简单的字符串使用关键字参数指定键值对有时候更方便
\ dict(sape\4139, guido\4127, jack\4098)
{sape: 4139, jack: 4098, guido: 4127} 遍历技巧
在字典中遍历时关键字和对应的值可以使用 items() 方法同时解读出来
\ knights \ {gallahad: the pure, robin: the brave}
\ for k, v in knights.items():
... print(k, v)
...
gallahad the pure
robin the brave 在序列中遍历时索引位置和对应值可以使用 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(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. 要反向遍历一个序列首先指定这个序列然后调用 reversed() 函数
\ for i in reversed(range(1, 10, 2)):
... print(i)
...
9
7
5
3
1 要按顺序遍历一个序列使用 sorted() 函数返回一个已排序的序列并不修改原值
\ basket \ \[apple, orange, apple, pear, orange, banana\]
\ for f in sorted(set(basket)):
... print(f)
...
apple
banana
orange
pear
