数据类型和变量

Python数据类型一览

在Python中，能够直接处理的基本数据类型有以下几种：

整数

Python可以处理任意大小的整数，当然包括负整数，在程序中的表示方法和数学上的写法一模一样：

>>> 1
1
>>> 100
100
>>> -8080
-8080
>>> 0
0
 

十六进制表示

计算机由于使用二进制，所以，有时候用十六进制表示整数比较方便。十六进制用0x前缀和0-9、a-f表示：

>>> 0xff00
65280
>>> 0xa5b4c3d2
2775680978
 

大数字分隔符

对于很大的数，例如10000000000，很难数清楚0的个数。Python允许在数字中间以下划线_分隔：

>>> 10_000_000_000
10000000000
>>> 0xa1b2_c3d4
2708615124
 

浮点数

浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的：

• 1.23x10⁹ 和 12.3x10⁸ 是完全相等的

浮点数的表示方法：

>>> 1.23
1.23
>>> 3.14
3.14
>>> -9.01
-9.01
 

科学计数法

对于很大或很小的浮点数，必须用科学计数法表示，用e替代10：

>>> 1.23e9
1230000000.0
>>> 12.3e8
1230000000.0
>>> 1.2e-5
0.000012
 

>>> 0.1 + 0.2
0.30000000000000004
 

字符串

字符串是以单引号'或双引号"括起来的任意文本：

>>> print('hello, world')
hello, world
>>> print("hello, world")
hello, world
 

转义字符

如果字符串内部既包含'又包含"，可以用转义字符\来标识：

>>> print('I\'m \"OK\"!')
I'm "OK"!
 

常用转义字符

raw字符串

如果字符串里面有很多字符都需要转义，可以用raw字符串r''，内部默认不转义：

>>> print('\\\t\\')
\	\
>>> print(r'\\\t\\')
\\\t\\
 

多行字符串

如果字符串内部有很多换行，可以用三引号'''...'''的格式表示多行内容：

>>> print('''line1
... line2
... line3''')
line1
line2
line3
 

┌─────────────────────────────────────────────────────────────┐
│Windows PowerShell                                         - □ x │
├─────────────────────────────────────────────────────────────┤
│>>> print('''line1                                       │
│... line2                                                │
│... line3''')                                            │
│line1                                                    │
│line2                                                    │
│line3                                                    │
│                                                         │
│>>>                                                      │
│                                                         │
└─────────────────────────────────────────────────────────────┘ 

布尔值

布尔值和布尔代数的表示完全一致，一个布尔值只有True和False两种值：

>>> True
True
>>> False
False
>>> 3 > 2
True
>>> 3 > 5
False
 

布尔运算

布尔值可以用and（与）、or（或）、not（非）运算：

and（与运算）

所有都为True，结果才是True：

>>> True and True
True
>>> True and False
False
>>> False and False
False
>>> 5 > 3 and 3 > 1
True
 

or（或运算）

只要其中有一个为True，结果就是True：

>>> True or True
True
>>> True or False
True
>>> False or False
False
>>> 5 > 3 or 1 > 3
True
 

not（非运算）

把True变成False，False变成True：

>>> not True
False
>>> not False
True
>>> not 1 > 2
True
 

空值

空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值：

>>> None
None
>>> print(None)

 

变量

变量的概念基本上和初中代数的方程变量是一致的，只是在计算机程序中，变量不仅可以是数字，还可以是任意数据类型。

变量命名规则

变量名必须是大小写英文、数字和_的组合，且不能用数字开头：

>>> a = 1           # 正确：变量a是整数
>>> t_007 = 'T007'   # 正确：变量t_007是字符串
>>> Answer = True    # 正确：变量Answer是布尔值
 

变量赋值

在Python中，等号=是赋值语句，可以把任意数据类型赋值给变量。同一个变量可以反复赋值，而且可以是不同类型的变量：

>>> a = 123          # a是整数
>>> print(a)
123
>>> a = 'ABC'        # a变为字符串
>>> print(a)
ABC
 

动态语言 vs 静态语言

这种变量本身类型不固定的语言称之为动态语言，与之对应的是静态语言。静态语言在定义变量时必须指定变量类型，如果赋值的时候类型不匹配，就会报错：

int a = 123;           // a是整数类型
a = "ABC";           // 错误！不能把字符串赋给整型变量
 

a = 123    # a是整数
a = 'ABC'  # a变为字符串，完全OK！
 

变量的内存管理

理解变量在计算机内存中的表示非常重要！

变量赋值原理

当我们执行a = 'ABC'时，Python解释器干了两件事情：

1. 在内存中创建了一个'ABC'的字符串
2. 在内存中创建了一个名为a的变量，并把它指向'ABC'

执行 a = 'ABC' 后：
┌────────────────────────────────────────────┐
│                  内存                       │
├────────────────────────────────────────────┤
│                                            │
│    变量a                                   │
│  ┌───────┐                                 │
│  │   a   │ ─────────────────┐            │
│  └───────┘                  │             │
│                             ▼             │
│                      ┌─────────────┐      │
│                      │   'ABC'     │      │
│                      └─────────────┘      │
│                                            │
└────────────────────────────────────────────┘ 

变量指向的深入理解

也可以把一个变量a赋值给另一个变量b，这个操作实际上是把变量b指向变量a所指向的数据：

a = 'ABC'
b = a
a = 'XYZ'
print(b)
 

问：b的值是'ABC'还是'XYZ'？让我们一步步执行：

第一步：执行 a = 'ABC'

┌────────────────────────────────────────────┐
│                  内存                       │
├────────────────────────────────────────────┤
│                                            │
│    变量a          字符串'ABC'              │
│  ┌───────┐      ┌─────────────┐           │
│  │   a   │ ────▶│   'ABC'     │           │
│  └───────┘      └─────────────┘           │
│                                            │
└────────────────────────────────────────────┘ 

第二步：执行 b = a

┌────────────────────────────────────────────┐
│                  内存                       │
├────────────────────────────────────────────┤
│                                            │
│    变量a, b        字符串'ABC'             │
│  ┌───────┐      ┌─────────────┐           │
│  │   a   │ ────▶│             │           │
│  ├───────┤      │             │           │
│  │   b   │ ────▶│             │           │
│  └───────┘      └─────────────┘           │
│                                            │
└────────────────────────────────────────────┘ 

第三步：执行 a = 'XYZ'

┌────────────────────────────────────────────┐
│                  内存                       │
├────────────────────────────────────────────┤
│                                            │
│    变量a ──────▶┌─────────────┐           │
│  ┌───────┐      │   'XYZ'    │           │
│  │   a   │ ────▶│             │           │
│  ├───────┤      └─────────────┘           │
│  │   b   │ ──┐                            │
│  └───────┘   │                            │
│              ▼                             │
│        ┌─────────────┐                    │
│        │   'ABC'     │  ← b仍然指向这里    │
│        └─────────────┘                    │
│                                            │
└────────────────────────────────────────────┘ 

所以，最后打印变量b的值是'ABC'！

常量

常量就是不能变的变量。在Python中，通常用全部大写的变量名表示常量：

>>> PI = 3.14159265359
>>> print(PI)
3.14159265359
 

精确的整数运算

Python的整数运算永远是精确的！

除法：/

/除法计算结果是浮点数：

>>> 10 / 3
3.3333333333333335
>>> 9 / 3
3.0
 

地板除：//

//地板除只取结果的整数部分：

>>> 10 // 3
3
>>> -10 // 3
-4
 

取余：%

%取余运算可以得到两个整数相除的余数：

>>> 10 % 3
1
>>> 9 % 3
0
 

除法小结

练习题