在上一期的末尾我们说到一段代码

1
2
3
4
5

a=100
if a>=0:
    print(a)
else:
    print(-a)

缩进及注释

我们发现它采用缩进的方式

缩进有利有弊，好处是强迫你格式化写代码，但没有规定缩进是几个空格或Tab。按照我们约定俗成的规定，应始终坚持使用 4个空格 的缩进。

缩进的另一个好处是强迫你写出缩进较少的代码，你会倾向于把一段很长的代码拆成若干个函数，从而得到缩进较少的代码。

当然，坏处就是“复制”——“粘贴”失效了，当你重构代码时，需要检查缩进是否正确。

务必注意，Python是大小写敏感的，这意味着你不能用错大小写（例如将input()打成Input()或INPUT()）。

如果我们要注释一些给人看的，程序会忽略的语句，可以在该行最开头写上符号#，例如

1
2
3
4
5
6

# 打印绝对值
a=100
if a>=0:
    print(a)
else:
    print(-a)

这样有‘#’的那一行的代码都不会执行

数据类型和变量

计算机最早就是用于数学计算的机器，因此计算机理所当然可以处理各种数值。
但是计算机还可以处理文本、图形、音频、视频、网页等数据，这就需要定义不同的数据类型。

整数

Python可以处理任意大小的整数，这包括负整数，写法与数学上相同，例如

1
2
3
4

1
100
-8080
0

等。

由于计算机内部采用二进制存储，所以有时候采用一些特定的进制比较方便。

我们就通常采用十六进制表示一个整数，我们用 0x 前缀表示这个数是一个十六进制数，对于十六进制数的一个位上的数，0-9正常表示，10-15分别对应a-f（或A-F）。例如

1
2

0xff00 # 十进制下的65280
0xa5b4c3d2 # 十进制下的2780087250

浮点数

浮点数就是小数。我们在计算机中采用科学计数法方式表示，小数点位置可变（例如$1.23\times10^9 = 12.3\times10^8$），就像来回浮动一样，故得名 浮点数 。
当然也可以采用数学写法，$1.23\times10^9 = 1,230,000,000$，$31.4\times10^{-1} = 3.14\times10^0 = 3.14$
对于一个很大或很小的浮点数，我们再采用数学写法未免有些困难，所以我们采用合理的科学计数法表示，我们用$e$来表示$10$，$AeX$就是$A\times10^X$，例如
$1,230,000,000 = 1.23\times10^9 = 1.23e9$
$0.000,012 = 1.2\times10^{-5} = 1.2e-5$

注意：整数和浮点数在计算机上存储方式不同，整数运算永远是精确的（包括除法），浮点数存在一定的四舍五入精度误差。

字符串

字符串是以单引号’或者双引号”括起来的文本，单引号和双引号本身不是字符串的内容，它这表示这是个字符串。
例如

1
2

`abc`和"xyz"
中第一个字符串中只有`a、b和c`三个字符，第二个字符串中只有`x、y和z`三个字符

事实上，如果你要单独使用'这个符号，可以用双引号

1

"I'm Peter_Matthew."

但是如果你需要使用”，你需要使用 转义字符\来表示。

1

'I\'m \"Peter_Matthew\".'

表示的内容为

1

I'm "Peter_Matthew".

转义字符\的作用是将这里的内容转换为别的字符而不是保留，它可以转义很多字符，例如

1
2
3

\n 表示换行符
\t 表示制表符
\\ 表示\

使用print可以打印字符串而不会显示最外边的'和"。

1
2
3
4
5

>>> print('I\'m \"Peter_Matthew\".')
'I\'m \"Peter_Matthew\".'
>>> print('\\\n\\')
\
\

Python在通常情况下默认转义，当你不想它帮你转义时，你可以在前面加上r

1
2
3
4
5

>>> print('\\\n\\')
\
\
>>> print(r'\\\n\\')
\\\n\\

同时，由于多行用\n写在一行内会十分影响阅读，所以可以采用'''...'''方式表示多行字符串

1
2
3

'''line1
line2
line3'''

输出它

在Python交互模式下，...在提示你可以接着上一行输入，...不是代码的一部分。

1
2
3
4
5
6

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

在程序中，请这么写

1
2
3

print('''line1
line2
line3''')

布尔值

布尔值只有True和False两个值，Python中采用此方式表示布尔值，可以通过布尔运算计算出来

1
2
3
4
5
6
7
8

>>> True
True
>>> False
False
>>> 3 > 2
True
>>> 3 > 4
False

布尔值可以采用and、or和not逻辑运算。

and

与运算，只有值均为True时才会返回True。

1
2
3
4
5
6
7
8
9
10

>>> True and True
True
>>> True and False
False
>>> False and True
False
>>> False and False
False
>>> 4 > 3 and 3 > 2
True

or

或运算，只要有值为True时就会返回True。

1
2
3
4
5
6
7
8
9
10

>>> True or True
True
>>> True or False
True
>>> False or True
True
>>> False or False
False
>>> 4 > 3 or 2 > 3
True

not

非运算，又称取反运算，会将值的真假反相，也就是值为False时为True，反之亦然。

1
2
3
4
5
6

>>> not True
False
>>> not False
True
>>> not 2 > 3
True

空值

Python当中的一个特殊值，用None表示。注意None不能理解为0。

其他

Python开还提供了列表、字典等数据类型，支持自定义数据类型，后续会讲到。

变量

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

变量在程序中用一个变量名表示了，变量名必须是大小写英文字母、数字和_的组合，且不能以数字开头。

1
2
3

a=1
t_007='T007'
Answer=True

其中，a是整数，t_007是字符串，Answer是布尔值。

并且在其中，这里的=符号是赋值，意思是把等式后面的值给变量，同一个变量可以被反复赋值，而且同一个数据变量每次被赋值时的数据类型可以不同

1
2
3
4
5

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

这种变量类型不固定的语言称为 动态语言 ，与之对应的是静态语言，静态语言必须指定变量类型，如赋值时不匹配，就会报错。
例如java和C++中

1 2	int a=123;//a是整数 a="ABC";//赋值错误：变量类型不匹配

和静态语言相比，动态语言更灵活。

请区分Python中，赋值语句的=符号和数学的等号区别，请看下面的例子。

1
2
3
4
5
6

>>> x=10
>>> print(x)
10
>>> x=x+2
>>> print(x)
12

如果从数学上理解x=x+2，那么是不成立的。在赋值语句中，程序先计算右侧的表达式x+2的值，得到12，然后在进行赋值，x的值就变成了12

变量在计算机内存中的表示：
当我们写

1

a='ABC'

Python解释器做了两件事：

1. 在内存中创建了一个’ABC’的字符串。
2. 在内存中创建了一个名为a的变量，并把它指向’ABC’。（这与C++的内存表示存在差异）

当然你也可以把a的值赋给b，这实际是将b指向a所指的数据。
对于下面这个例子

1 2 3 4

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

最后一行打印出b的内容是'ABC'还是'XYZ'？从数学上会错误地认为a和b相同都是'XYZ'，实际上b的值是'ABC'，程序是一行一行执行的，所以我们也一行一行执行。

第一：a='ABC'，解释器创建了字符串'ABC'和变量a，并把a指向字符串'ABC'

第二：b=a，解释器创建了变量b，并把它指向a所指向的字符串'ABC'

第三：a='XYZ'，解释器创建了字符串'XYZ'，并把a的指向改为'XYZ'，此时b是没有变的。

所以最后b的值就是'ABC'了。

常量

常量就是不能更改的变量，比如π在数学上就是个常量，通常用全部大写的变量名表示常量

1

PI=3.141592653589793

但事实上PI仍是变量，Python没有机制阻止变量不更改，所以，这样的写法只是一个习惯用法，没有人拦得住你更改PI的值。

关于整数除法

Python中有两种除法。
第一种是/：

1
2
3
4

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

/的除法结果是浮点数，即使整除也是浮点数。

还有一种是//：

1
2
3
4
5
6
7
8

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

这样的结果永远是整数，永远向下取整。

同时还有一个余数运算%，可以得到相除的余数

1
2
3
4
5
6
7
8

>>> 10%3
1
>>> 10%-3
-2
>>> -10%3
2
>>> -10%-3
-1

我们可以看到余数的正负与除数有关

1
2
3
4
5

# 以下是数学解释
10=3*3+1			10%3=1
10=(-4)*(-3)+(-2)	10%(-3)=-2
-10=(-4)*3+2		(-10)%3=2
-10=3*(-3)+(-1)		(-10)%(-3)=-1

由于//除法和%取余的结果总是整数，所以整数的除法是精确的。

提前尝试

复习知识点并尝试打印下列变量的值

1
2
3
4
5
6
7
8

# -*- coding: utf-8 -*-
n = 123
f = 456.789
s1 = 'Hello, world'
s2 = 'Hello, \'Adam\''
s3 = r'Hello, "Bart"'
s4 = r'''Hello,
Lisa!'''

请执行此代码

1
2
3
4
5

a=100
if a>=0:
    print(a)
else:
    print(-a)

观察显示的的结果并尝试完成以下任务：

1. 思考这段代码中每行都表示什么意思
2. 修改a的值或将a的值变为输入时赋值

本作品采用知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议进行许可。