1.2.2. 基本类型

1.2.2.1. 数值类型

Python支持以下数字,标量类型:

整数:
>>> 1 + 1
2
>>> a = 4
>>> type(a)
<type 'int'>
浮点数:
>>> c = 2.1
>>> type(c)
<type 'float'>
复数:
>>> a = 1.5 + 0.5j
>>> a.real
1.5
>>> a.imag
0.5
>>> type(1. + 0j)
<type 'complex'>
布尔:
>>> 3 > 4
False
>>> test = (3 > 4)
>>> test
False
>>> type(test)
<type 'bool'>

因此,Python shell可以代替你的便携式计算器,其基本的算术运算+-*/(取模)由原生实现

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

类型转换(casting):

>>> float(1)
1.0

警告

整数除法

在Python 2中:

>>> 3 / 2   
1

在Python 3:

>>> 3 / 2   
1.5

为了安全起见:使用浮点数:

>>> 3 / 2.
1.5
>>> a = 3
>>> b = 2
>>> a / b # In Python 2
1
>>> a / float(b)
1.5

未来行为:始终获得Python3的行为

>>> from __future__ import division  
>>> 3 / 2
1.5

如果你明确想要整数除法,使用//

>>> 3.0 // 2
1.0

Python 3中,除法运算符的行为已更改。

1.2.2.2. 容器

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

1.2.2.2.1. 列表

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

>>> colors = ['red', 'blue', 'green', 'black', 'white']
>>> type(colors)
<type '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 < stopi的范围为从startstop-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循环执行更多的操作。

这里有几个例子;有关详情,请参阅https://docs.python.org/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)
>>> rcolors2
['red', 'blue', 'green', 'black', 'white']
>>> rcolors2.reverse() # in-place
>>> 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)的例子。作为列表,对象rcolors拥有方法函数,它使用记号.调用。对于阅读本教程,OOP的知识只需理解记号.

发现方法:

提醒:在Ipython中:制表符补全(按Tab)

In [28]: rcolors.<TAB>
rcolors.__add__ rcolors.__iadd__ rcolors.__setattr__
rcolors.__class__ rcolors.__imul__ rcolors.__setitem__
rcolors.__contains__ rcolors.__init__ rcolors.__setslice__
rcolors.__delattr__ rcolors.__iter__ rcolors.__sizeof__
rcolors.__delitem__ rcolors.__le__ rcolors.__str__
rcolors.__delslice__ rcolors.__len__ rcolors.__subclasshook__
rcolors.__doc__ rcolors.__lt__ rcolors.append
rcolors.__eq__ rcolors.__mul__ rcolors.count
rcolors.__format__ rcolors.__ne__ rcolors.extend
rcolors.__ge__ rcolors.__new__ rcolors.index
rcolors.__getattribute__ rcolors.__reduce__ rcolors.insert
rcolors.__getitem__ rcolors.__reduce_ex__ rcolors.pop
rcolors.__getslice__ rcolors.__repr__ rcolors.remove
rcolors.__gt__ rcolors.__reversed__ rcolors.reverse
rcolors.__hash__ rcolors.__rmul__ rcolors.sort

1.2.2.2.2. 字符串

不同的字符串语法(单引号、双引号或三引号):

s = 'Hello, how are you?'
s = "Hi, what's up"
s = '''Hello, # tripling the quotes allows the
how are you''' # the string to span more than one line
s = """Hi,
what's up?"""
In [1]: 'Hi, what's up?'
------------------------------------------------------------
File "<ipython console>", line 1
'Hi, what's up?'
^
SyntaxError: invalid syntax

换行符为\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!'

重音符号和特殊字符也可以在Unicode字符串中处理(请参阅https://docs.python.org/tutorial/introduction.html#unicode-strings)。

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

In [53]: a = "hello, world!"
In [54]: a[2] = 'z'
---------------------------------------------------------------------------
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
In [55]: a.replace('l', 'z', 1)
Out[55]: 'hezlo, world!'
In [56]: a.replace('l', 'z')
Out[56]: 'hezzo, worzd!'

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

另见

Python提供了操作字符串、寻找模式或格式化的高级操作。感兴趣的读者可以参考https://docs.python.org/library/stdtypes.html#string-methodshttps://docs.python.org/library/string。 html#new-string-formatting

字符串格式化:

>>> 'An integer: %i; a float: %f; another string: %s' % (1, 0.1, 'string')
'An integer: 1; a float: 0.100000; another string: string'
>>> i = 102
>>> filename = 'processing_of_dataset_%d.txt' % i
>>> filename
'processing_of_dataset_102.txt'

1.2.2.2.3. 字典

字典基本上是将键映射到值的高效的表。它是一个无序容器

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

它可以用于方便地存储和检索与名称(日期,名称等的字符串)相关联的值。有关详细信息,请参阅https://docs.python.org/tutorial/datastructures.html#dictionaries

字典可以具有不同类型的键(和相应的值):

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

1.2.2.2.4. 更多容器类型

元组

元组基本上是不可变的列表。元组的元素写在括号之间,或者只是用逗号分隔:

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

集合:元素无序、唯一:

>>> s = set(('a', 'b', 'c', 'a'))
>>> s
set(['a', 'c', 'b'])
>>> s.difference(('a', 'b'))
set(['c'])

1.2.2.3. 赋值运算符

Python库参考说:

赋值语句用于(重新)将名称绑定到值和修改可变对象的属性或元素。

简而言之,它的工作原理如下(简单赋值):

  1. 计算右手侧的表达式,创建/获得相应的对象
  2. 在左手侧的名称被赋值或绑定到r.h.s.的对象

注意事项:

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

    In [1]: a = [1, 2, 3]
    
    In [2]: b = a
    In [3]: a
    Out[3]: [1, 2, 3]
    In [4]: b
    Out[4]: [1, 2, 3]
    In [5]: a is b
    Out[5]: True
    In [6]: b[1] = 'hi!'
    In [7]: a
    Out[7]: [1, 'hi!', 3]
  • 原地更改列表,请使用索引/切片:

    In [1]: a = [1, 2, 3]
    
    In [3]: a
    Out[3]: [1, 2, 3]
    In [4]: a = ['a', 'b', 'c'] # Creates another object.
    In [5]: a
    Out[5]: ['a', 'b', 'c']
    In [6]: id(a)
    Out[6]: 138641676
    In [7]: a[:] = [1, 2, 3] # Modifies object in place.
    In [8]: a
    Out[8]: [1, 2, 3]
    In [9]: id(a)
    Out[9]: 138641676 # Same as in Out[6], yours will differ...
  • 这里的关键概念是可变对象和不可变对象

    • 可变对象可以在适当位置更改
    • 不可变对象一旦创建就不能被修改

另见

上述问题的非常好和详细的解释可以在David M. Beazley的文章Python中的类型和对象中找到。