fasionchan

读万卷书,行万里路,品万味肴,撸万行码。

Python常用数据类型

开始介绍Python数据类型前,先来看看注释。 注释是代码或指令里的解释性文本,比如注解代码的目的等,方便阅读理解代码。 Python的注释是从井号#开始,一直到行尾。 也就是说,从#开始的所有内容,Python解释器会自动忽略。

1
2
3
4
5
>>> # 演示计算
... 1 + 1
2
>>> 7 * 8    # 乘法
56

数值

Python解释器一节,我们将解释器当做计算器来用,做一些数值运算。 准确地讲,我们输入的加法算式是一个表达式,表达式由数值和运算符组成。 括号可以对表达式进行分组,并定义优先级。 常用的数学操作符包括:+-*/等,跟其他语言类似,学过数学的应该都不陌生。

1
2
3
4
5
6
7
8
9
>>> 1           # 这是一个数值
1
>>> 1 + 1       # 这是一个表达式
2
>>> 50 - 5*6    # 乘法优先级更高
20
>>>
>>> 8 / 5       # 除法返回的是浮点数
1.6

注意到,数值分两种类似。一种是int,即整数,例如1250等等;还有一种是float,即浮点数,例如1.6

另外,对两个整数做除法/,返回一个浮点数。如果想返回整数商,可以使用另一种除法//

1
2
3
4
5
6
7
8
>>> 17 / 3          # 浮点除法
5.666666666666667
>>> 17 // 3         # 整数除法
5
>>> 17 % 3          # 求余数
2
>>> 5 * 3 + 2       # 商 * 除数 + 余数 = 被除数
17

Python计算乘方也很方便,操作符是**

1
2
3
4
>>> 5 ** 2      # 5的2次方
25
>>> 2 ** 7      # 2的7次方
128

看到没有,你得到一个免费的计算器!但Python能做的远远不止这些。

变量

假设笔者在外汇兑换点工作,每天要做大量换算。 今天,港元的汇率目前是1人民币兑换0.8452港元。 有个顾客前来兑换500人民币,怎么算呢?

1
2
>>> 500 * 1.1831    # 太容易了
591.5500000000001

结果是591港元,零头自己赚了。 如果要换,600人民币呢?每次都输1.1831很烦躁有木有!

可以定义一个变量,把1.1831这个数值存储起来,在接下来的计算中用。 Python使用等号=定义变量:

1
2
3
4
5
6
7
>>> hkd_rate = 1.1831
>>> hkd_rate
1.1831
>>> 600 * hkd_rate          # 换600元
709.86
>>> 700 * hkd_rate          # 换700元
828.1700000000001

准确讲,=是一个赋值操作符,赋值操作将一个值1.1831和一个名字hkd_rate关联起来。 注意到,输入赋值语句后,解释器并没有任何输出便提示输入下一条语句了。 这是因为,赋值语句并没有值,它将一个值与一个名字关联而已。

看到没有,定义变量后,想算多少就算多少,完全不需要记汇率,也完全不用担心输错数值。

可以接着定义其他变量,比如需要美元汇率:

1
2
3
4
5
>>> dollar_rate = 0.1515
>>> 300 * dollar_rate
45.449999999999996
>>> 900 * dollar_rate
136.35

如果一个变量未定义就使用了,Python会报错——抛出一个异常。 忘记定义日元汇率的后果:

1
2
3
4
5
6
7
>>> jpy_rate
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'jpy_rate' is not defined
>>> jpy_rate = 16.899   # 重新定义jpy_rate后Python便相安无事
>>> jpy_rate
16.899

字符串

Python用'或者"定义str,这样刚好规定了开头及结尾,中间所有字符就组成了字符串:

1
2
3
4
5
6
>>> 'python'
'python'
>>> "python"
'python'
>>> print('python')
python

想输出多行字符串呢?\n表示换行:

1
2
3
>>> print('python2\npython3')
python2
python3

当然了,也可以用'''或者""",中间的换行会包含在字符串里:

1
2
3
4
5
6
7
>>> print('''python2
... python3''')
python2
python3
>>> '''python2
... python3'''
'python2\npython3'

如果字符串的值包含了',那可怎么办,不是跟开头结尾的特殊符号冲突了吗? 比如,python's fans,不意外Python会报语法错误:

1
2
3
4
5
>>> 'python's fans'
  File "<stdin>", line 1
    'python's fans'
            ^
SyntaxError: invalid syntax

这是因为,Python会认为第二个'是字符串结尾,然后紧跟着的s就不符合正常语法了。 有一个解决方案,就是对'进行转义,明确告诉Python这是字符串值的一部分,不是结尾语法标志。 Python中,\开头表示转义,\'就表示对'的转义:

1
2
>>> 'python\'s fans'
"python's fans"

终于解决了!然而,又有新问题了。 如果字符串包含\怎么办呢?

1
2
3
>>> print('C:\some\name')
C:\some
ame

输出一个Window路径,包含\\n被解释成换行符了…… 解决答案还是转义,\\就是自己的转义:

1
2
>>> print('C:\\some\\name')
C:\some\name

还有一种方法,在字符串前加一个标志r,表示不特殊处理\

1
2
>>> print(r'C:\some\name')
C:\some\name

另外,使用"时对'就不需要做转义,因为完全没有歧义(反之亦然):

1
2
>>> "python's fans"
"python's fans"

str支持+运算符,将两个str拼接在一起:

1
2
3
4
>>> print('python' + '2')
python2
>>> print('python2' + ' ' + 'python3')
python2 python3

str也支持*运算符,将str与自身拼接n次:

1
2
>>> print('python2' * 3)
python2python2python2

字符串是一个字符组成的序列,每个字符都有一个特定的序号。 以字符串python为例:

1
2
3
4
5
6
7
+----+----+----+----+----+----+
| p  | y  | t  | h  | o  | n  |
+----+----+----+----+----+----+
| 0  | 1  | 2  | 3  | 4  | 5  |
+----+----+----+----+----+----+
| -6 | -5 | -4 | -3 | -2 | -1 |
+----+----+----+----+----+----+

计算机中,计数一般从0开始。 因此,第0个字符是p,第1个字符是y,以此类推。 Python还支持倒数的序号,第-1个字符表示倒数第一个字符,也就是n。 注意,倒数就不是从0开始的,因为数学中0只有一个,没有正负。

通过中括号[]和序号,可以确定字符串的某个字符。 如果序号不在合法范围内,Python将抛一个IndexError异常:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
>>> a = 'python'
>>> a[0]
'p'
>>> a[1]
'y'
>>> a[5]
'n'
>>> a[6]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: string index out of range
>>> a[-1]
'n'
>>> a[-6]
'p'
>>> a[-7]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: string index out of range

还可以通过切片(slice)取出一个包含若干个字符的子串。 例如,取出第234个字符组成的子串:

1
2
3
>>> a = 'python'
>>> a[2:5]
'tho'

注意到,切片数学书采用半开半闭区间,包括第一个序号,但不包括第二个序号:[2, 5)。 从以上序号表可以看到,2对应t3对应h4对应o,不包括5。 因此,结果是tho

左边界缺省,表示从开头开始;右边界缺省,表示到结尾为止:

1
2
3
4
5
6
>>> a[1:]    # 从序号1到结尾
'ython'
>>> a[:4]    # 从开头到序号3(序号4不包括)
'pyth'
>>> a[:]     # 从开头到结尾,相当于将字符串复制了一份(一模一样)
'python'

切片还支持每n个字符抽取(默认正好是每1个字符抽取一次):

1
2
3
4
5
6
>>> a[1:6:2]    # 逢二取一
'yhn'
>>> a[::2]
'pto'
>>> a[1::2]
'yhn'

列表

有一类数据类型是复合型的,用来组织其他值,成为容器。 最简单的容器是list列表,用来组织一系列相关的值。 先来看看list怎么定义:

1
2
3
>>> squares = [1, 4, 9, 16, 25]
>>> squares
[1, 4, 9, 16, 25]

这样,我们就得到一个由五个平方数组成的列表。 其中,第一个平法数为1,下标为0;第二个平方数为4,下标为1;以此类推最后一个平方数是25,下标是4。 需要注意,在计算机中,序号经常是从0开始的,而不是1

1
2
3
4
5
6
7
8
9
10
>>> squares[0]
1
>>> squares[1]
4
>>> squares[4]
25
>>> squares[5]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

可以看到,在下标超出list范围时,Python会抛出一个异常,通知错误发生。 Python还支持反向下标,-1对应最后一个值;-2对应倒数第二个值;以此类推:

1
2
3
4
5
6
7
8
9
10
>>> squares[-1]
25
>>> squares[-2]
16
>>> squares[-5]
1
>>> squares[-6]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

反向下标超过合法范围照样会报错。

1
2
3
4
5
6
7
8
>>> squares[2:]
[9, 16, 25]
>>> squares[-2:]
[16, 25]
>>> squares[:3]
[1, 4, 9]
>>> squares[2:4]
[9, 16]

Comments