常量和表达式

我们可以把 Python 当成一个计算器，来进行一些算术运算

print(1 + 2 - 3) # 0
print(1 + 2 * 3) # 7
print(1 + 2 / 3) # 1.6666666666666665

注意：

• print 是一个 Python 内置的 函数
• 可以使用 + - * / () 等运算符进行算术运算，先算乘除，后算加减
• 运算符和数字之间，可以没有空格，也可以有多个空格，但是一般习惯上写一个空格(比较美观)

形如 1 + 2 - 3 这样是算式，在编程语言中称为 表达式，算式的运算结果, 称为 表达式的返回值
其中 1 , 2 , 3 这种称为 字面值常量，+ - * / 这种称为 运算符 或者 操作符

在 Python 中，2/3 => 0.666666 而不是 0!!
在 C/Java 中，整数除以整数结果还是整数! 并且会把小数部分直接舍弃!

1.6666666666666665
为什么不是 667 ??
编程中，一般没有“四舍五入”这样的规则
浮点数 IEEE754 标准，这套规则下，在内存中表示浮点数的时候，可能会存在微小的误差

——示例
给定四个分数，67.5, 89.0, 12.9, 32.2， 编写代码，求这四个分数的平均数

print( (67.5 + 89.0 + 12.9 + 32.2) / 4 )

---

变量的类型

1、变量是什么

有的时候，我们需要进行的计算可能更复杂一些，需要把一些计算的中间结果保存起来，这个时候就需要用到变量

print(type(avg))

Python 中的变量的类型，不需要在定义变量的时候显式声明，而只是依靠初始化语句，根据初始化的值的类型来进行确定的

——示例
给定四个分数，67.5, 89.0, 12.9, 32.2， 编写代码，求这四个分数的方差

方差：
1.计算平均值
⒉针对每个数字，分别计算数字和平均值的差值，再平方
3.把上述的平方值相加
4.除以项数 -1

# 求四个数字的方差
avg = (67.5 + 89.0 + 12.9 + 32.2) / 4
total = (67.5 - avg) ** 2 + (89.0 - avg) ** 2 + (12.9 - avg) ** 2 + (32.2 - avg)
result = total / 3
print(result) # 1056.8066666666666

在这个代码中，就需要先计算这四个数字的平均值，然后再计算方差，这就需要把计算的平均值使用变量保存起来

注意：

• avg, total, result 均为变量

• ** 在 Python 中表示乘方运算，** 2 即为求平方

就像计算器中的 M 键功能类似，通过变量就可以保存计算过程中的中间结果

只不过计算器一般只能保存一个数据，而在 Python 代码中，可以创建任意多的变量，来随心所欲的保存很多很多的数据

变量可以视为是一块能够容纳数据的空间，这个空间往往对应到 “内存” 这样的硬件设备上

PS: 我们可以把内存想像成是一个宿舍楼，这个宿舍楼上有很多的房间，每个房间都可以存放数据
衡量内存的一个重要指标就是内存空间的大小，比如我的电脑内存是 16GB，这个数字越大，意味着内存的存储空间就越大，能够存放的数据(变量) 就越多

---

2、变量的语法

2.1、定义变量

a = 0

创建变量的语句非常简单，其中

• a 为变量名，当我们创建很多个变量的时候，就可以用名字来进行区分
• = 为赋值运算符，表示把 = 右侧的数据放到 = 左侧的空间中

注意： 变量的名字要遵守一定规则

——硬性规则(务必遵守)

• 变量名由数字字母下划线构成
• 数字不能开头
• 变量名不能和 “关键字” 重复
• 变量名大小写敏感，num 和 Num 是两个不同的变量名

——软性规则(建议遵守)

• 变量名使用有描述性的单词来表示，尽量表达出变量的作用

• 一个变量名可以由多个单词构成，长一点没关系，但是含义要清晰

• 当变量名包含多个单词的时候，建议使用 “驼峰命名法”，形如 totalCount , personInfo 这种，除了首个单词外，剩余单词首字母大写

数学上，变量通常使用 x, y, z 这种简单的英文字母或者拉丁字母表示，但是在编程中不建议这样使用
原因是编程中，一个程序里通常会同时创建出很多个变量，如果只是使用单个字母表示，在变量多了
的时候，就很难记住哪个变量是做什么的，从而给维护程序带来了一定的困难，因此我们更建议使用带
有明确描述性的名字，来表示变量的用途

---

2.2、使用变量

读取变量的值

a = 10
print(a)

修改变量的值

a = 20
print(a)

注意： 在 Python 中，修改变量也是使用 = 运算，看起来和定义变量没有明显区别

也可以用一个变量的值赋给另外一个变量

a = 10
b = 20

a = b

print(a)
print(b)

---

3、变量的类型

变量里面存储的不仅仅是数字，还可以存储其它种类的数据，为了区分不同种类的数据，我们引入了 "类型"这样的概念

注意： 和 C++ / Java 等语言不同，Python 变量的类型不需要显式指定，而是在赋值的时候确定的

1）整数 int

a = 10
print(type(a))

<class ‘int’>

PS: type 和 print 类似，也是 python 内置的函数，可以使用 type 来查看一个变量的类型

注意： 和 C++ / Java 等语言不同，Python 的 int 类型变量，表示的数据范围是没有上限，可以根据要表示的数据的大小自动扩容，只要内存足够大，理论上就可以表示无限大小的数据

因此 Python 这里就没有 long 这样的类型了，像 byte, short 这些类型在 Python 中也不存在

---

2、浮点数(小数) float

a = 0.5
print(type(a))

<class ‘float’>

注意： 和 C++ / Java 等语言不同，Python 的小数只有 float 一种类型，没有 double 类型，但是实际上 Python 的 float 就相当于 C++/Java 的 double, 表示双精度浮点数

PS: 关于单精度浮点数和双精度浮点数的问题，我们此处不做过多讨论，大家只要知道，相比于单精度浮点数，双精度浮点数占用的内存空间更多，同时表示的数据精度更高即可 (大概精确到小数点后 15 位)

Python 的一个设计哲学：解决一个问题，只提供一种方案

---

3、字符串

s = 'py'
print(type(s))

<class 'str '>

羊肉串把一块块羊肉串在一起，字符串把一个个字符放到一起
英文字母，阿拉伯数字，标点符号，甚至汉字符号，都可以认为是"字符"

Python 中要求使用 ’ ’ 或者 " " 引起来的，称为 字符串，可以用来表示文本

字符串这个单词，string = > str

注意： 在 Python 中，单引号构成的字符串和双引号构成的字符串，没有区别，‘hello’ 和 “hello” 是完全等价的

有一段话：My name is “Gwen” 如果把这段话作为字符串，中间这部分，Python不认识了!!

因此，如果字符串里面包含了双引号，表示字符串就可以用单引号引起来，如果字符串里面包含了单引号，表示字符串就可以使用双引号引起来

如果同时有单引号，和双引号，
Python 中还有一种字符串，使用三引号表示 ''' 或 """

可以使用 len 函数来获取字符串的长度

a = 'hello'
print(len(a))

可以使用 + 针对两个字符串进行拼接

a = 'hello'
b = 'world'
print(a + b)

形如这样的代码，就是“字符串拼接"
也就是把后面的字符串，拼接到前一个字符串的末尾，得到了一个更大的字符串!
(对于原来的 a1, a2 是没有影响的)

此处是两个字符串相加，不能拿字符串和整数/浮点数相加

在Python 中报错，有两种情况：

1. 语法错误：在程序运行之前，Python 解释器，就能把错误识别出来
2. 运行错误：在程序运行之前，识别不了的，必须要执行到对应的代码，才能发现问题

4、布尔

布尔类型是一个特殊的类型，取值只有两种，True (真) 和 False (假)

因此布尔类型主要用于逻辑判定

在 java/C++ 中是 true / false

PS: 布尔类型也是数学上的一个概念，我们初中就学过一个概念叫做 “命题”，进一步的就可以判定命题的真假

例如：

地球环绕太阳(真命题)
水是剧毒的(假命题)

a = True
print(type(a))
b = False
print(type(b))

<class ‘bool’>
<class ‘bool’>

---

5、其他

除了上述类型之外，Python 中还有 list, tuple, dict，自定义类型 等等，我们后续再介绍

---

6、为什么要有这么多类型

(1) 类型决定了数据在内存中占据多大空间

例如 float 类型在内存中占据 8 个字节

PS: 计算机里面使用二进制来表示数据。也就是每个位只能表示 0 或者 1
1 个二进制位，就称为是一个 “比特”，8 个二进制位，就称为一个 “字节” (Byte)
一个 float 变量在内存中占据 8 个字节空间，也就是 64 个二进制位
我的电脑有 16GB 的内存空间，也就是一共有 1024 * 1024 * 1024 * 8 这么多的二进制位

(2) 类型其实约定了能对这个变量做什么样的操作

例如 int / float 类型的变量，可以进行 + - * / 等操作
而 str 类型的变量，只能进行 + (并且行为是字符串拼接)，不能进行 - * / , 但是还能使用 len 等其他操作

总结： 类型系统其实是在对变量进行 “归类”，相同类型的变量(数据) 往往具有类似的特性和使用规则

---

7、动态类型特性

在 Python 中，一个变量是什么类型，是可以在 “程序运行” 过程中发生变化的，这个特性称为 “动态类型”

a = 'py'
print(type(a))
a = 10
print(type(a))
a = True
print(type(a))

a 的类型随着程序的运行，就发生改变

C++/Java 这样的语言则不允许这样的操作，一个变量定义后类型就是固定的了，这种特性则称为 “静态类型”

静态类型——程序运行过程中，变量的类型始终不变
Java 中的 int a = 10;
a 这个变量在程序运行的整个过程中，始终都是 int，如果尝试 a = “hello”，编译阶段就会报错

动态类型特性是一把双刃剑
对于中小型程序，可以大大的解约代码量 (比如写一段代码就可以同时支持多种类型)
对于大型程序，则提高了模块之间的交互成本 (程序猿 A 提供的代码难以被 B 理解)

一个编程语言，是否是动态类型，只是取决于运行时，类型是否发生改变，不取决于变量定义的时候是否声明类型!

Python 作为一个动态类型的语言，在定义变量的时候，也是可以写类型的!

a:int = 'py'
print(type(a))
a:str = 10
print(type(a))
a = True
print(type(a))

动态类型写法比较灵活的，提高了语言的表达能力
然而，在编程中，"灵活"这个词往往是“贬义”，更容易出错!!!
相比之下，静态类型的语言还是更好一些的
尤其是在大型的程序中，多人协作开发

因此很多公司，在创业之初，喜欢使用 Python，来开发
产品规模小，也就是一两个程序猿，很快的就能搞出来
但是当项目达到一定的规模之后，动态类型的劣势就逐渐体现了，很多公司就会针对之前 Python 写的代码使用其他语言进行重构

---

注释

注释是一种特殊的代码，它不会影响到程序的执行，但是能够起到解释说明的作用，能够帮助程序猿理解程序代码的执行逻辑

PS: 写代码是一件比较烧脑的事情，读代码同样也非常烧脑，相比于一板一眼的代码，一些口语化的描述能更好的帮助程序猿理解程序

PS: 代码的第一目标是容易理解，第二目标才是执行正确
写注释不光是为了方便别人来理解，也是方便三个月之后的自己理解

——注释的语法
Python 中有两种风格的注释

1）注释行

使用 # 开头的行都是注释，一般是写在要注释的代码的上方，也有少数情况下是写在要注释代码的右侧的，很少会写在代码的下方，更不能写到代码的左侧

# 这是一行注释

2）文档字符串

使用三引号引起来的称为 “文档字符串”，也可以视为是一种注释

• 可以包含多行内容
• 一般放在 文件/函数/类 的开头
• “”" 或者 ‘’’ 均可 (等价)

"""
这是文档字符串
这是文档字符串
"""

——如何写出比较好的注释：

注释的规范

1. 内容准确：注释内容要和代码一致，匹配，并在代码修改时及时更新

公司中的项目要经常进行“迭代”
本来代码和注释都写好了，后来代码一更新，但是注释忘记同步修改了，导致代码和注释逐渐对不上了
但凡要修改代码,务必要记得更新注释!!

2. 篇幅合理：注释既不应该太精简，也不应该长篇大论

3. 使用中文：一般中国公司都要求使用中文写注释，外企另当别论

4. 积极向上：注释中不要包含负能量

---

输入输出

1、和用户交互

程序需要和用户进行交互

• 用户把信息传递给程序的过程，称为 “输入”
• 程序把结果展示给用户的过程，称为 “输出”

输入输出的最基本的方法就是控制台， 用户通过控制台输入一些字符串，程序再通过控制台打印出一些字符串

PyCharm 运行程序，下方弹出的窗口就可以视为是控制台

windows 自带的 cmd 程序，也可以视为是控制台

输入输出的最常见方法是图形化界面，如我们平时用到的 QQ, 浏览器, steam 等，都不需要用户输入命令，而只是通过鼠标点击窗口点击按钮的方式来操作

Python 当然也可以用来开发图形化界面的程序，但是图形化程序开发本身是一个大话题，此处暂时不做介绍

---

2、通过控制台输出

Python 使用 print 函数输出到控制台

print('hello')

不仅能输出一个字符串，还可以输出一个其他类型的变量

a = 10
print(a)
b = True
print(b)

更多的时候，我们希望能够输出的内容是混合了字符串和变量的

a = 10
# print("a = " +a) # err

# 变量
print(f"a = {a}")
# 表达式
print(f"a = {a + 10}")

这个语法，是叫做"格式化字符串"，

• 使用 f 作为前缀的字符串，称为 f-string，f: format
• 里面可以使用 { } 来内嵌一个其他的变量/表达式

PS: Python 中还支持其他的格式化字符串的方法，咱们此处只了解这个最简单的即可，其他的暂时不做介绍

像格式化打印字符串，很多编程语言都进行了各自的探索
C printf，使用 %d， %s 这样的占位符
C++ 采用了 std::cout，使用 <<
Java 采用了字符串拼接,允许字符串和其他类型的值进行拼接
Python 最早支持的格式化字符串，也是效仿 C 的 printf… 并做出了改进 Python 3.6 版本才开始支持 f-string

---

3、通过控制台输入

python 使用 input 函数，从控制台读取用户的输入

input 执行的时候，就会等待用户输入!
这个等待可能是一个非常长的等待，完全就看用户啥时候去输入
如果用户始终不输入，就会一直在这里死等，不见不散

注意：

• input 的参数相当于一个 “提示信息”，也可以没有
• input 的返回值就是用户输入的内容，是字符串类型
  如果只是单纯的拿到用户的输入，然后打印，此时就按照 str 打印即可
  如果需要根据用户输入的内容进行算术计算，此时就需要先把读到的 str -> int
  可以使用 int ()

例：此处的结果是字符串拼接，不是算术运算，如果要想进行算术运算，需要先转换类型
字符串拼接：

整数相加：a, b 类型转换为 int

通过 int() 把变量转成了 int 类型
类似地，使用 float( ), bool( ), str( ) 等可以完成对应的类型转换

代码示例： 输入 4 个小数，求 4 个小数的平均值

a = input('请输入第一个数字：')
b = input('请输入第二个数字：')
c = input('请输入第三个数字：')
d = input('请输入第四个数字：')

a = float(a)
b = float(b)
c = float(c)
d = float(d)

avg = (a + b + c + d) / 4

print(f'平均值: {avg}')

请输入第一个数字：11.1
请输入第二个数字：22.2
请输入第三个数字：33.3
请输入第四个数字：44.4
平均值：27.75

---

运算符

1、算术运算符

像 + - * / % ** // 这种进行算术运算的运算符，称为 算术运算符

注意1： / 中不能用 0 作为除数，否则会抛出异常

print(10 / 0)
print(10 / 0.0)

这种运行时出现的错误，也叫做 “抛出异常"
异常 是编程语言中的一种常见机制，表示程序运行过程中，出现了一些 “意外情况”，导致程序不能继续往下执行了

有些编程语言中，除整数 0 也是会抛出异常，除浮点数 0.0 会得到无穷大，而 Python 都认为是 除 0 异常

注意2： 整数 / 整数 结果可能是小数，而不会截断

print(1 / 2) # 0.5

除了 Python 之外，大部分的编程语言，都是整数防以整数，结果还是整数

注意3： % 不是 “百分数”，而是求余数

print(7 % 2) # 1

注意4： ** 是求乘方，不光能算整数次方，还能算小数次方(开方运算)

$4^2$

print(4 ** 2) # 16

$\sqrt{4}$

print(4 ** 0.5) # 2.0

注意5： // 是取整除法(也叫地板除)，整数除以整数，结果还是整数 (舍弃小数部分，并向下取整，不是四舍五
入)

print(7 // 2) # 3
print(-7 // 2) # -4

---

2、关系运算符

像 < <= > >= == != 这一系列的运算符称为 关系运算符，它们是在比较操作数之间的关系
其中

• <= 是 “小于等于”
• >= 是 “大于等于”
• == 是 “等于”
• != 是 "不等于

(1) 关系运算符对应的表达式，值是布尔类型，如果关系符合，则表达式返回 True，如果关系不符合，则表达式返回 False

a = 10
b = 20

print(a < b)
print(a <= b)
print(a > b)
print(a >= b)
print(a == b)
print(a != b)

True

True
False
False
False
True

(2) 关系运算符不光针对整数/浮点数进行比较，还能针对字符串进行比较

a = 'hello'
b = 'world'

print(a < b)
print(a <= b)
print(a > b)
print(a >= b)
print(a == b)
print(a != b)

True
True
False
False
False
True

注意：

• 直接使用 == 或者 != 即可对字符串内容判定相等 (这一点和 C / Java 不同)

  • C——strcmp，如果直接使用 == 本质上在比较两个字符串首元素地址
    Java——equals方法，如果直接使用 == 本质上在比较这两个字符串是否是同一个对象
    这是一个小众的行为
    像Python直接使用==和!=来比较字符串内容相同是大部分编程语言遵守的规则

• 字符串比较大小，规则是 “字典序”

关于字典序：
想象一个英文词典，上面的单词都是按照字母顺序排列，在英文词典上，单词是按照一定的顺序来排列的，如果首个字母相同，就比较第二个字母 (就比如著名单词 abandon)
我们认为一个单词在词典上越靠前，就越小，越靠后，就越大

针对中文进行字符串大小比较，是没有意义的，至少按照默认的字典序来说，是没意义的!
在计算机里，表示中文，其实是用多个字节构成的

(3) 对于浮点数来说，不要使用 == 判定相等

针对浮点数来说，使用 == 比较相等，存在一定的风险!!!
因为浮点数在内存中的存储和表示，是可能存在误差的!! 这样的误差在进行算术运算的时候就可能被放大，从而导致 == 的判定出现误判!

print(0.1 + 0.2 == 0.3)
print(0.1)
print(0.2)
print(0.1 + 0.2)
print(0.3)

可以看到，0.1 + 0.2 的结果并非是 0.3， 而是带了个小尾巴，虽然这个尾巴非常小了，但是 == 是锱铢必较的，仍然会导致 == 的结果为 False

不止是 Python 如此, 主流编程语言都是如此. 这个是 IEEE754 标准规定的浮点数格式所引入的问题. 此处我们不做过多讨论

正确的比较方式： 不再严格比较相等了，而是作差，判定差值小于允许的误差范围

a = 0.1 + 0.2
b = 0.3
# 这个代码是看a-b差是否是一个非常小的数字，是否在误差范围之内
print(-0.000001 < (a - b) < 0.000001)

注： Python 中支持这种连续小于的写法，判定 a - b 既是 <0.000001 又是大于 -0.000001

实际工程实践中，误差在所难免，只要保证误差在合理范围内即可

---

3、逻辑运算符

像 and or not 这一系列的运算符称为 逻辑运算符

• and 并且，两侧操作数均为 True，最终结果为 True，否则为 False (一假则假)
• or 或者，两侧操作数均为 False，最终结果为 False，否则为 True (一真则真)
• not 逻辑取反，操作数本身为 True，则返回 False，本身为 False，则返回 True

a = 10
b = 20
c = 30

print(a < b < c) # print(a < b and b < c)
print(a < b and b > c)
print(a > b or b > c)
print(a < b or b > c)
print(not a < b)
print(not a > b)

True
False
False
True
False
True

一种特殊写法
a < b and b < c 这个操作等价于 a < b < c . 这个设定和大部分编程语言都不相同

C++ 或者 Java 里，使用
&& 表示逻辑与 —— 并且
|| 表示逻辑或 —— 或者
! 表示逻辑非 —— 逻辑取反

关于短路求值 (物理上的术语)
和其他编程语言类似，Python 也存在短路求值的规则.
对于 and，如果左侧表达式为 False，则整体一定为 False，右侧表达式不再执行
对于 or，如果左侧表达式为 True，则整体一定为 True，右侧表达式不再执行

print(10 > 20 and 10 / 0 == 1)
print(10 < 20 or 10 / 0 == 1)

False
True

右侧 10 / 0 == 1 就不再求值了
所以一旦右侧求值了，是能够看到代码出现异常的! 如果代码没有抛出异常，右侧没有求值!

上述代码没有抛出异常，说明右侧的除以 0 操作没有真正执行

---

4、赋值运算符

(1) = 的使用
=表示赋值，意思就是把右侧的值填充到左侧的空间中! 注意和 == 区分

10 = 20 # err 左侧不是变量

= 除了基本的用法之外，还可以同时针对多个变量进行赋值

1）链式赋值

a = b = 20

先把 20 赋值给 b，再把 b 赋值给 a 就相当于
a = 20
b = 20

一般不建议使用链式赋值!!
尽量一行代码就只是包含一个操作!

2）多元赋值

a, b = 10, 20

按顺序，把 10 赋给了 a，把 20 赋给了 b

能帮我们解决一些特殊问题!
完成两个变量的交换

——代码实例：交换两个变量

基础写法

a = 10
b = 20

tmp = a
a = b
b = tmp

基于多元赋值

a = 10
b = 20
# 将 a 赋给 b，将 b 赋给 a
a, b = b, a

(2) 复合赋值运算符

Python 还有一些 复合赋值运算符，例如 += -= *= /= %=

a = 0
a += 1

注：

1. 以上代码注意要先定义 a，才能使用 += 赋值 运算，因为要先读取 a，再计算，再赋值

2. Python 中不支持 ++ --这样的自增自减操作的!!
   ++a 之所以没有语法报错，是 Python 解释器把＋当成了正号
   –a 也是不会报错，把 – 当成了负号，负负得正，最终的值仍然不变

   a = 1
   ++a
   print(a) # 1
   
   --a
   print(a) # 1
   

   但是后置++ 和 后置-- 都是语法上报错的!

   ++ – 最大的问题就是容易分不清前置和后置的区别，这一点 Python 语法在设计的时候就进行了
   规避，避免出现这种不直观，并且容易混淆的语法

---

5、其他

除了上述之外，Python 中还有一些运算符，比如 身份运算符 (is, is not)，成员运算符 (in, not in)，位运算符 ( & | ~ ^ << >>) 等

---

自测练习

(1) [多选] 以下关于变量之间加法运算的说法，正确的是：
A. Python 中的字符串之间够能相加
B. Python 中的字符串可以和整数相加
C. Python 中的整数可以和浮点数相加
D. Python 中的整数可以和布尔值相加

a = 'hello'
b = 'world'
print(a + b)

a = 'hello'
b = 10
print(a + b)

a = 10
b = 5.5
print(a + b)

a = 10
b = True
print(a + b)

helloworld
报错
15.5
11

如果把布尔类型的值和整数进行算术运算，此时就会把 True 当做 1，把 False 当做 0
但是这样的操作，是没有意义的!!!
C/C+＋也是有类似的行为
但是 Java 这里的做法是更合理的!!
如果出现整数和布尔混合运算，直接编译报错!!

答案：ABD

(2) [单选] 以下关于类型的说法，正确的是：
A. Python 中既有字符串类型，也有字符类型
B. Python 中既有 float，也有 double
C. Python 中既有 int，也有 long
D. Python 中的整数表示范围无上限

Python 中只有字符串类型，没有字符类型！ 'a’ 这算是长度为 1 的字符串！
正是因为 Python 中没有字符类型
所以 " 和 ’ 都能表示字符串，C++, Java 有单独的字符类型
单引号表示字符，双引号表示字符串

Python 只有 float

Python 只有 int

答案：D

(3) [单选] 以下 Python 代码，合法的是
A. int a = 10
B. a = 10;
C. a = true
D. a = ‘aaa’ + 10

创建变量不需要加类型，如果要加：a:int = 10

在 Python 中，一个语句写完了之后，可以加上分号，也可以不加，通常情况下都是不加的，如果加了，也不算错!!
如果把多个语句写到同一行了，这个时候语句之间，务必要加上分号的 (并不推荐)

字符串和整数不能相加

答案：B

---