菜鸟教程 -- 学的不仅是技术,更是梦想!

Python 3 教程
Python3 教程 Python3 简介 Python3 环境搭建 Python3 VScode Python3 基础语法 Python3 基本数据类型 Python3 数据类型转换 Python3 解释器 Python3 注释 Python3 运算符 Python3 数字(Number) Python3 字符串 Python3 列表 Python3 元组 Python3 字典 Python3 集合 Python3 条件控制 Python3 循环语句 Python3 编程第一步 Python3 推导式 Python3 迭代器与生成器 Python3 with Python3 函数 Python3 lambda Python3 装饰器 Python3 数据结构 Python3 模块 Python __name__ Python3 输入和输出 Python3 File Python3 OS Python3 错误和异常 Python3 面向对象 Python3 命名空间/作用域 Python 虚拟环境的创建 Python 类型注解 Python3 标准库概览 Python3 实例 Python 测验

Python3 高级教程

Python3 正则表达式 Python3 CGI编程 Python3 MySQL(mysql-connector) Python3 MySQL(PyMySQL) Python3 网络编程 Python3 SMTP发送邮件 Python3 多线程 Python3 XML 解析 Python3 JSON Python3 日期和时间 Python3 内置函数 Python3 MongoDB Python3 urllib Python uWSGI 安装配置 Python3 pip Python3 operator Python math Python requests Python random Python OpenAI Python 有用的资源 Python AI 绘画 Python statistics Python hashlib Python 量化 Python pyecharts Python selenium 库 Python 爬虫 Python Scrapy 库 Python Markdown Python sys 模块 Python Pickle 模块 Python subprocess 模块 Python queue 模块 Python StringIO 模块 Python logging 模块 Python datetime 模块 Python re 模块 Python csv 模块 Python threading 模块 Python asyncio 模块 Python PyQt Python for 循环 Python while 循环
(追記) (追記ここまで)

Python3 数据结构

本章节我们主要结合前面所学的知识点来介绍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 两边的方括号表示这个参数是可选的,而不是要求你输入一对方括号,你会经常在 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、创建一个空栈

实例

stack = []

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) == 0

def size(self):
return len(self.stack)

# 使用示例
stack = Stack()
stack.push(1)
stack.push(2)
stack.push(3)

print("栈顶元素:", stack.peek()) # 输出: 栈顶元素: 3
print("栈大小:", stack.size()) # 输出: 栈大小: 3

print("弹出元素:", stack.pop()) # 输出: 弹出元素: 3
print("栈是否为空:", stack.is_empty()) # 输出: 栈是否为空: False
print("栈大小:", stack.size()) # 输出: 栈大小: 2

以上代码中,我们定义了一个 Stack 类,封装了列表作为底层数据结构,并实现了栈的基本操作。

输出结果如下:

栈顶元素: 3
栈大小: 3
弹出元素: 3
栈是否为空: False
栈大小: 2

将列表当作队列使用

在 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. 创建队列

实例

queue = []

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) == 0

def size(self):
return len(self.queue)

# 使用示例
queue = Queue()
queue.enqueue('a')
queue.enqueue('b')
queue.enqueue('c')

print("队首元素:", queue.peek()) # 输出: 队首元素: a
print("队列大小:", queue.size()) # 输出: 队列大小: 3

print("移除的元素:", 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]
>>> [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]

列表推导式可以使用复杂表达式或嵌套函数:

>>> [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 删除实体变量: 

>>> del a

元组和序列

元组由若干逗号分隔的值组成,例如:

>>> 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

参阅文档

AI 思考中...

9 篇笔记 写笔记

  1. #0

    reinhard

    mrl***[email protected]

    73

    元组不可变,若元组的成员可变类型,则成员可编辑。 

    a = [1,2,3,4]
b = [5,6,7,8]
c = [9,10,11,12]
t = a,b,c
print(t)
del b[1:4]
print(t)

    输出: 

    ([1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12])
([1, 2, 3, 4], [5], [9, 10, 11, 12])

    reinhard

    mrl***[email protected]

    9年前 (2017年06月21日)
  2. #0

    。。。

    928***[email protected]

    224

    列表推导式(又称列表解析式)提供了一种简明扼要的方法来创建列表。

    它的结构是在一个中括号里包含一个表达式,然后是一个for语句,然后是 0 个或多个 for 或者 if 语句。那个表达式可以是任意的,意思是你可以在列表中放入任意类型的对象。返回结果将是一个新的列表,在这个以 if 和 for 语句为上下文的表达式运行完成之后产生。

    列表推导式的执行顺序:各语句之间是嵌套关系,左边第二个语句是最外层,依次往右进一层,左边第一条语句是最后一层。

    [x*y for x in range(1,5) if x > 2 for y in range(1,4) if y < 3]

    他的执行顺序是:

    for x in range(1,5)
 if x > 2
 for y in range(1,4)
 if y < 3
 x*y
    。。。

    。。。

    928***[email protected]

    9年前 (2017年08月03日)
  3. #0

    小盟主

    165***[email protected]

    81

    有多个列表需要遍历时,需要zip,除了用'{0}{1}'.format(q,a)的方法,还可以使用%s方法(两者效果一样一样的):

    questions=['name','quest','favorite color']
answers=['qinshihuang','the holy','blue']
for q,a in zip(questions,answers):
 print('what is your %s? it is %s' %(q,a))
 print('what is your {0}? it is {1}'.format(q,a))

    小盟主

    165***[email protected]

    9年前 (2017年09月13日)
  4. #0

    空白runoob

    tia***[email protected]

    90

    教程中遍历 dict 使用的 .items() 方法配合 for 循环,非常简明易懂,但有一项需要注意的是,在 for 循环中,使用单个变量和双变量的区别,注意观察以下两个例子的区别:

    >>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}
>>> for k, v in knights.items():
... print(k, v)
...
gallahad the pure
robin the brave

    ===========================分隔线===========================

    >>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}
>>> for k in knights.items():
... print(k)
...
('gallahad', 'the pure')
('robin', 'the brave')

    使用 k 和 v 两个变量时,将键与值分别赋予 k 和 v。使用 k 一个变量时,将对应的键与值作为一个整体赋给 k。所以,最终 print 的显示内容是有区别的。不只是此例,程序设计过程中有很多地方都会体现个体与整体的差异,虽然显示出来的结果非常相似,但逻辑上却是完全不同的。

    空白runoob

    tia***[email protected]

    7年前 (2019年04月19日)
  5. #0

    Cxj

    150***[email protected]

    91

    针对上述所讲的的执行顺序介绍,讲解一下正文中的一个例子:

    >>> 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]]

    这个例子中的执行顺序应该为:

    for i in range(4)
 for row in matrix
 row[i]

    即将每一个 matrix 中的列表元素的第一个放在一起、第二个放在一起、第三个放在一起、第四个元素放在一起作为一个新的列表元素。

    Cxj

    150***[email protected]

    7年前 (2019年08月14日)
  6. #0

    小闪闪

    517***[email protected]

    81

    使用小括号包裹推导式会生成生成器对象,而不是元组。

    >>> a = (2*x for x in range(2))
>>> type(a)
<class 'generator'>
>>> next(a)
0
>>> next(a)
2
>>> next(a)
Traceback (most recent call last):
 File "<pyshell#691>", line 1, in <module>
 next(a)
StopIteration

    小闪闪

    517***[email protected]

    7年前 (2019年09月06日)
  7. #0

    higandown

    hig***[email protected]

    31

    推导式不仅还能加人三元表达式进行一些更加复杂的多层判断:

    array = []
for i in range(30):
 if i%3==0 and i%5==0:
 array.append("能被3-5整除")
 elif i%5==0:
 array.append("能被5整除")
 elif i%3==0:
 array.append("能被3整除")
 else:
 array.append("不能能被3-5整除")
array = ["能被3-5整除" if i%3==0 and i%5==0 else "能被5整除" if i%5==0 else "能被3整除" if i%3==0 else "不能被3-5整除" for i in range(30)]
print(array)

    higandown

    hig***[email protected]

    6年前 (2020年05月29日)
  8. #0

    Indecision

    153***[email protected]

    43

    针对上述所讲的的执行顺序介绍,讲解一下正文中的一个例子:

    matrix = [ [7, 2, 9, 4], [5, 6, 9, 8], [9, 10, 11, 12],]
relist1 = [row[i] for i in range(4) for row in matrix]
relist2 = [[row[i] for row in matrix] for i in range(4)]
print(relist1)
print(relist2)

    输出:

    [7, 5, 9, 2, 6, 10, 9, 9, 11, 4, 8, 12]
[[7, 5, 9], [2, 6, 10], [9, 9, 11], [4, 8, 12]]

    relist1 返回为一个单层列表。

    relist2。内部循环结果先生成一个列表,并以子列表的形式添加到外层列表中。

    Indecision

    153***[email protected]

    6年前 (2020年09月24日)
  9. #0

    於黾

    252***[email protected]

    187

    楼上很多人都在讨论推导式,这个东西在我看来是可有可无的,除了节省代码之外没什么用处,反而影响可读性(对于新手会不友好)

    反而是另一个问题值得详细的说明:元组的装包与拆包

    先看下面的代码:

    a=1
b=2
a,b=b,a
print(a,b)

    我们都知道这样可以很方便的对2个值进行互换,然而这个操作其实涉及到元组的装包与拆包

    完全的写法应该是下面这样的:

    (a,b)=(b,a)

    将a和b放入一个元组中,然后通过元组赋值

    但是python会自动进行元组的装包与拆包操作,因此下面2个式子与上面是等价的:

    a,b=(b,a)
(a,b)=b,a

    理解了元组的自动装包拆包,再回头看函数的返回值,就可以更深入的理解了

    函数其实并不能返回多个值,只能返回一个值。

    当有多个返回值时,其实是自动将他们放入一个元组中,然后返回这个元组

    def f():
 return 1,2,3
print(f())

    此时函数返回值其实是(1,2,3),是个元组

    但是当我们用3个变量同时去接收这个返回值时

    a,b,c=f()

    相当于

    a,b,c=(1,2,3)

    由于元组自动拆包,造成a=1,b=2,c=3,看似返回了多个值一样

    如果不理解这一点,就会搞不清为什么有时候就有括号,有时候就没括号

    关键有括号和没括号类型完全不一样,搞混了可是不行的

    於黾

    252***[email protected]

    5年前 (2021年08月06日)

点我分享笔记

  • 昵称 (必填)
  • 邮箱 (必填)
  • 引用地址

AltStyle によって変換されたページ (->オリジナル) /