1.2.2. 基本类型

1.2.2.1. 数值类型

提示

Python 支持以下数值标量类型

整数:

>>> 1 + 1
2
>>> a = 4
>>> type(a)
<class 'int'>

浮点数:

>>> c = 2.1
>>> type(c)
<class 'float'>

复数:

>>> a = 1.5 + 0.5j
>>> a.real
1.5
>>> a.imag
0.5
>>> type(1. + 0j)
<class 'complex'>

布尔值:

>>> 3 > 4
False
>>> test = (3 > 4)
>>> test
False
>>> type(test)
<class 'bool'>

提示

因此，Python shell 可以替代您的袖珍计算器，并原生实现了基本算术运算 +、-、*、/、%（取模）

>>> 7 * 3.
21.0
>>> 2**10
1024
>>> 8 % 3
2

类型转换（强制转换）

>>> float(1)
1.0

1.2.2.2. 容器

提示

Python 提供了许多高效的容器类型，可以在其中存储对象的集合。

列表

提示

列表是有序的对象集合，这些对象可以具有不同的类型。例如

>>> colors = ['red', 'blue', 'green', 'black', 'white']
>>> type(colors)
<class 'list'>

索引：访问列表中包含的单个对象

>>> colors[2]
'green'

使用负索引从末尾开始计数

>>> colors[-1]
'white'
>>> colors[-2]
'black'

警告

索引从 0 开始（如 C 语言），而不是从 1 开始（如 Fortran 或 Matlab）！

切片：获取等间隔元素的子列表

>>> colors
['red', 'blue', 'green', 'black', 'white']
>>> colors[2:4]
['green', 'black']

警告

请注意，colors[start:stop] 包含索引为 i 的元素，其中 start<= i < stop（i 的范围是从 start 到 stop-1）。因此，colors[start:stop] 有 (stop - start) 个元素。

切片语法：colors[start:stop:stride]

提示

所有切片参数都是可选的

>>> colors
['red', 'blue', 'green', 'black', 'white']
>>> colors[3:]
['black', 'white']
>>> colors[:3]
['red', 'blue', 'green']
>>> colors[::2]
['red', 'green', 'white']

列表是可变对象，可以修改

>>> colors[0] = 'yellow'
>>> colors
['yellow', 'blue', 'green', 'black', 'white']
>>> colors[2:4] = ['gray', 'purple']
>>> colors
['yellow', 'blue', 'gray', 'purple', 'white']

注意

列表的元素可以具有不同的类型

>>> colors = [3, -200, 'hello']
>>> colors
[3, -200, 'hello']
>>> colors[1], colors[2]
(-200, 'hello')

提示

对于所有元素都具有相同类型的数值数据集合，通常使用 numpy 模块提供的 array 类型会更高效。NumPy 数组是一块包含固定大小项目的内存块。使用 NumPy 数组，对元素的操作可以更快，因为元素在内存中是等间隔的，并且更多操作是通过专门的 C 函数而不是 Python 循环来执行的。

提示

Python 提供了许多修改或查询列表的函数。以下是一些示例；有关更多详细信息，请参阅 https://docs.pythonlang.cn/3/tutorial/datastructures.html#more-on-lists

添加和删除元素

>>> colors = ['red', 'blue', 'green', 'black', 'white']
>>> colors.append('pink')
>>> colors
['red', 'blue', 'green', 'black', 'white', 'pink']
>>> colors.pop() # removes and returns the last item
'pink'
>>> colors
['red', 'blue', 'green', 'black', 'white']
>>> colors.extend(['pink', 'purple']) # extend colors, in-place
>>> colors
['red', 'blue', 'green', 'black', 'white', 'pink', 'purple']
>>> colors = colors[:-2]
>>> colors
['red', 'blue', 'green', 'black', 'white']

反转

>>> rcolors = colors[::-1]
>>> rcolors
['white', 'black', 'green', 'blue', 'red']
>>> rcolors2 = list(colors) # new object that is a copy of colors in a different memory area
>>> rcolors2
['red', 'blue', 'green', 'black', 'white']
>>> rcolors2.reverse() # in-place; reversing rcolors2 does not affect colors
>>> rcolors2
['white', 'black', 'green', 'blue', 'red']

连接和重复列表

>>> rcolors + colors
['white', 'black', 'green', 'blue', 'red', 'red', 'blue', 'green', 'black', 'white']
>>> rcolors * 2
['white', 'black', 'green', 'blue', 'red', 'white', 'black', 'green', 'blue', 'red']

提示

排序

>>> sorted(rcolors) # new object
['black', 'blue', 'green', 'red', 'white']
>>> rcolors
['white', 'black', 'green', 'blue', 'red']
>>> rcolors.sort()  # in-place
>>> rcolors
['black', 'blue', 'green', 'red', 'white']

方法和面向对象编程

表示法 rcolors.method()（例如 rcolors.append(3) 和 colors.pop()）是我们面向对象编程 (OOP) 的第一个示例。作为 list，对象 rcolors 拥有使用表示法 . 调用的方法 函数。在学习本教程的过程中，无需了解 OOP 的任何其他知识，只需理解表示法 . 即可。

发现方法

提醒：在 Ipython 中：制表符补全（按 Tab 键）

In [1]: rcolors.<TAB>
                 append()  count()   insert()  reverse()
                 clear()   extend()  pop()     sort()
                 copy()    index()   remove()

字符串

不同的字符串语法（单引号、双引号或三引号）

s = 'Hello, how are you?'
s = "Hi, what's up"
s = '''Hello,
       how are you'''         # tripling the quotes allows the
                              # string to span more than one line
s = """Hi,
what's up?"""

In [2]: 'Hi, what's up?'
  Cell In[2], line 1
    'Hi, what's up?'
                   ^
SyntaxError: unterminated string literal (detected at line 1)

可以通过将字符串用双引号而不是单引号括起来来避免此语法错误。或者，可以在第二个单引号前面加上反斜杠。反斜杠的其他用法是，例如，换行符 \n 和制表符 \t。

提示

字符串类似于列表的集合。因此，可以使用相同的语法和规则对其进行索引和切片。

索引

>>> a = "hello"
>>> a[0]
'h'
>>> a[1]
'e'
>>> a[-1]
'o'

提示

（请记住，负索引对应于从右端开始计数。）

切片

>>> a = "hello, world!"
>>> a[3:6] # 3rd to 6th (excluded) elements: elements 3, 4, 5
'lo,'
>>> a[2:10:2] # Syntax: a[start:stop:step]
'lo o'
>>> a[::3] # every three characters, from beginning to end
'hl r!'

提示

重音符号和特殊字符也可以像在 Python 3 中一样处理，因为 Python 3 字符串由 Unicode 字符组成。

字符串是不可变对象，无法修改其内容。但是，可以从原始字符串创建新字符串。

In [3]: a = "hello, world!"

In [4]: a.replace('l', 'z', 1)
Out[4]: 'hezlo, world!'

提示

字符串有很多有用的方法，例如上面看到的 a.replace。请记住 a. 面向对象表示法，并使用制表符补全或 help(str) 搜索新方法。

另请参阅

Python 提供了用于操作字符串、查找模式或格式化的更高级功能。感兴趣的读者可以参考 https://docs.pythonlang.cn/3/library/stdtypes.html#string-methods 和 https://docs.pythonlang.cn/3/library/string.html#format-string-syntax

字符串格式化

>>> 'An integer: %i; a float: %f; another string: %s' % (1, 0.1, 'string') # with more values use tuple after %
'An integer: 1; a float: 0.100000; another string: string'

>>> i = 102
>>> filename = 'processing_of_dataset_%d.txt' % i   # no need for tuples with just one value after %
>>> filename
'processing_of_dataset_102.txt'

字典

提示

字典基本上是一个高效的表，用于将键映射到值。

>>> tel = {'emmanuelle': 5752, 'sebastian': 5578}
>>> tel['francis'] = 5915
>>> tel
{'emmanuelle': 5752, 'sebastian': 5578, 'francis': 5915}
>>> tel['sebastian']
5578
>>> tel.keys()
dict_keys(['emmanuelle', 'sebastian', 'francis'])
>>> tel.values()
dict_values([5752, 5578, 5915])
>>> 'francis' in tel
True

提示

它可以方便地存储和检索与名称关联的值（日期的字符串、名称等）。有关更多信息，请参阅 https://docs.pythonlang.cn/3/tutorial/datastructures.html#dictionaries。

字典可以具有不同类型的键（或值）

>>> d = {'a':1, 'b':2, 3:'hello'}
>>> d
{'a': 1, 'b': 2, 3: 'hello'}

更多容器类型

元组

元组基本上是不可变的列表。元组的元素用括号括起来，或者仅用逗号分隔

>>> t = 12345, 54321, 'hello!'
>>> t[0]
12345
>>> t
(12345, 54321, 'hello!')
>>> u = (0, 2)

集合：无序的、唯一的项目

>>> s = set(('a', 'b', 'c', 'a'))
>>> s    
{'a', 'b', 'c'}
>>> s.difference(('a', 'b'))
{'c'}

1.2.2.3. 赋值运算符

提示

Python 库参考 指出

赋值语句用于将名称（重新）绑定到值，以及修改可变对象的属性或项目。

简而言之，其工作原理如下（简单赋值）

1. 计算右侧的表达式，创建/获取相应的对象

2. 左侧的名称被分配或绑定到右侧的对象

需要注意的事项

• 单个对象可以有多个名称绑定到它

In [5]: a = [1, 2, 3]

In [6]: b = a

In [7]: a
Out[7]: [1, 2, 3]

In [8]: b
Out[8]: [1, 2, 3]

In [9]: a is b
Out[9]: True

In [10]: b[1] = 'hi!'

In [11]: a
Out[11]: [1, 'hi!', 3]

• 要就地更改列表，请使用索引/切片

In [12]: a = [1, 2, 3]

In [13]: a
Out[13]: [1, 2, 3]

In [14]: a = ['a', 'b', 'c'] # Creates another object.

In [15]: a
Out[15]: ['a', 'b', 'c']

In [16]: id(a)
Out[16]: 140157216637376

In [17]: a[:] = [1, 2, 3] # Modifies object in place.

In [18]: a
Out[18]: [1, 2, 3]

In [19]: id(a)
Out[19]: 140157216637376

• 这里的关键概念是可变与不可变

  • 可变对象可以在原地更改

  • 不可变对象一旦创建就不能修改

另请参阅

David M. Beazley 的文章 Python 中的类型和对象 对上述问题进行了非常详细的解释。