Python 基础语法详解：变量、类型、动态特性与运算符

2 ~> 变量和类型

2.1 变量是什么

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

示例：给定四个分数，67.5，89.0，12.9，32.2，编写代码，求这四个分数的方差。 PS：方差的计算过程：取每一项，减去平均值，计算平方，再求和，最后除以 (项数 - 1）

求方差：计算平均值；针对每个数字，分别计算数字和平均值的差值，再平方；把上述的平方值相加；除以 (项数 - 1)。

1、计算平均值，用一个变量 avg 把平均值保存起来；

avg = ((67.5 + 89.0 + 12.9 + 32.2) / 4)

2、针对每个数字，分别计算数字和平均值的差值，再平方，再用另外一个变量 total 保存一下得到的结果，再要使用这个结果时只要用变量表示即可——变量起到的功能：可以视为一块用来存储数据的空间（想象成一个纸盒子），变量是存在内存上面的，我们下面还会再谈到这个话题，这里先提一嘴！

3、把上述的平方值相加；

total = ((67.5 - avg)**2 + (89.0 - avg)**2 + (12.9 - avg)**2 + (32.2 - avg)**2)

4、上述结果除以 (项数 - 1)，注意：是除以项数 - 1，不是除以项数之后再 - 1！

result = total / 3
print(result) # 方差结果：1173.2866666666666

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

avg, total, result 均为变量，在 Python 中表示乘方运算2 即为求平方。

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

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

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

PS：我们可以把内存想像成是一个宿舍楼，这个宿舍楼上有很多的房间，每个房间都可以存放数据。

衡量内存的一个重要指标就是内存空间的大小，比如电脑的内存是 16 + 16，32GB，这个数字越大，意味着内存的存储空间就越大，能够存放的数据（变量）就越多，1T、2T 那个是硬盘大小哦！那个是长期存储数据（几年），内存是一断电数据就没有了。

2.2 变量的语法

2.2.1 定义变量

a = 10

创建变量的语句非常简单，其中 a 为变量名。当我们创建很多个变量的时候，就可以用名字来进行区分。 这里的 = 为赋值运算符，表示把 = 右侧的数据放到 = 左侧的空间中，表示数学上的'比较相等'。

像这样写就报错了——

a * a = 10

会报什么错呢？报这样的错——无法赋值给运算符。

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

有哪些规则呢？一张图搞定！

数学上，变量通常使用 x、y、z 这种简单的英文字母或者拉丁字母表示，但是在编程中不建议这样使用。

为什么呢？原因是编程中，一个程序里通常会同时创建出很多个变量，如果只是使用单个字母表示，在变量多了的时候，就很难记住哪个变量是干啥的，从而给维护程序带来了一定的困难——因此我们更建议使用带有明确描述性的名字，来表示变量的用途。

那么取名字就是一个需要严格规范的事情了，既然是为了表示变量的用途，不能随随便便取个名字，具体命名规范见上图。

2.2.2 使用变量

如下图所示——

什么意思呢，直接看演示——

# 变量的使用
a = 10
b = a
print(b) # 变量的读取
# 首次使用 = 对 a 进行设置值，这个过程是创建变量（初始化）
a = 20
print(a) # 后续再对 a 使用 = 操作相当于修改 a 的内容（赋值）

2.3 变量的类型：对于不同种类的变量作出区分

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

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

Python 的设计哲学：解决一个问题，只通过一种方案——更加简洁直观，也降低了 Python 的学习成本。

2.3.1 整数

# 1. 整数 int(所有的整数都用 int 表示)
# 初始化类型确定为 int，全看赋了什么值，这里赋了 10，就是 int
a = 10
print(type(a))
# Python 中的变量的类型，不需要在定义变量的时候显式声明，而只是依靠初始化语句，根据初始化的值的类型来进行确定
# 在 Python，int 能够表示的数据范围是'无穷'的
# Python 的 int 是可以根据要表示的那个数据的大小，自动扩容的
# Java 的 int 最大就能表示到 -21 亿 ~ +21 亿这个范围
# 因此 Python 这里就没有 long 这样的类型了，像 byte，short 这些类型在 Python 中也不存在

注意：type 和 print 类似，也是 python 内置的函数，我们 可以使用 type 来查看一个变量的类型。

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

2.3.2 浮点数 (小数)

# 2. 浮点数（小数）float（一个 float 表示所有的浮点数）
b = 0.5
print(type(b))
# 像 C++ 和 Java 里面，float 是四个字节的，也叫做'单精度浮点数'
# 字节：把一个二进制位称为一个 bit，8 个 bit 放在一起就称为是一个字节
# double 是八个字节的，也叫做'双精度浮点数'
# Python 中的 float 就是'双精度浮点数'，等同于 C++ / Java 里的 double，不需要什么 double 了

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

PS：关于单精度浮点数和双精度浮点数的问题，我们此处不作过多讨论。

uu们只要知道：相比于单精度浮点数，双精度浮点数占用的内存空间更多，同时表示的数据精度更高 (大概精确到小数点后 15 位)。

2.3.3 字符串

# 3. 字符串
# 像羊肉串一样把一块块羊肉串在一起似的，字符串是把一个个字符放到一起
# 英文字母，阿拉伯数字，标点符号，甚至汉字符号，都可以认为是'字符'，如 a、8、+、- 这些都是字符
# Python 中要求使用引号把一系列的字符引起来就构成了字符串
# 引号使用'或者"都是可以的
c = 'hello'
print(type(c))
d = "hello"
print(type(d))
# 搞两种引号是有必要的！举个例子，有一段话：My name is "Alice Greyrat"
# 如果把这段话作为字符串
# e = "My name is "Alice Greyrat"" # 中间这部分，Python 不认识了
# 波浪线：三种颜色-->黄色是警告，你这个代码可能有点问题，但不影响运行;红色是可能会影响运行;绿色如下所示
e = 'My name is "Alice Greyrat"'
# 绿色的波浪线：拼写检查，是不是常见的字符串，这个字符串 Pycharm 不认识
print(type(e))
# 因此，如果字符串里面包含了双引号，表示字符串就可以用单引号引起来;
# 反之，如果字符串里面包含了单引号，表示字符串就可以使用双引号引起来;
# 如果同时有单引号和双引号咋办?
# Python 中还有一种字符串，使用三引号表示，使用'''或者"""
f = '''My 'name' is "Alice Greyrat"'''
# 可见 Python 字符串的定义方式还是非常灵活的
print(type(f))
# 我们上述的引号，都是英文的引号，而不是中文的引号
# 利用单引号/双引号/双引号完成字符串内容的表示
# 以上我们创建的这几种引号都是等价的关系，具体在写代码的时候哪个方便用哪个，没有实际的影响
# 使用内置函数 len(length) 来查看字符串的长度 (多长其实就是字符串里面包含了几个字符)
print(len(d))
# 字符串拼接
# 形如下面这样的代码，就是'字符串拼接'，也就是把后面的字符串拼接到前一个字符串的末尾
# 得到了一个更大的字符串！（对于原来的 a1,a2 是没有影响的）
a1 = 'hello'
a2 = 'world'
print(a1 + a2)
# 字符串相加就是字符串的拼接运算
# 整数和浮点数的运算是算术运算
# 字符串的相加是特点含义，比如这里是把 a2 这个字符串的内容完全拼接在 a1 的后面
# 在 Python 中，我们不能把字符串和整数相加
# b1 = 'hello'
# b2 = 10
# print(b1 + b2) # 这里并没有报错
# 运行的时候报错了，TypeError: can only concatenate str (not "int") to str(我们不能拼接字符串和整数)

在 Python 中，报错，有两种情况： 1、语法错误：在程序运行之前，Python 解释器，就能把错误识别出来； 2、运行错误：在程序运行之前，识别不了的，必须要执行到对应的代码，才能发现问题。

实际开发中，运行错误要比语法错误严重得多！产品万一已经发布给用户使用，人家运行出现错误了，就麻烦了！这就像是相亲，刚见面就感觉对方不是自己的菜，直接结束了 (语法报错)，和对象在一起前 (相亲时) 可能没发现有什么不合适的，在一起之后感觉对方有自己不能接受的一面 (运行报错)。

使用 '' 或者 " " 引起来的，称为字符串，可以用来表示文本。

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

我们可以使用内置函数 len(length) 来查看字符串的长度 (多长其实就是字符串里面包含了几个字符)——

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

字符串拼接：我们还可以使用 + 针对两个字符串进行拼接。

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

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

字符串作为开发中最常用到的数据类型，支持的操作方式也是非常丰富的，我们此处暂时不详细展开，留到后面介绍。

2.3.4 布尔（真 / 假）

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

布尔类型也是数学上的一个概念！我们初中的时候就学过一个概念叫做'命题'，什么真命题假命题，进一步的就可以判定命题的真假！我们这里可以举几个例子——

打个比方，一个命题可以是'某人是万粉博主'，一眼假，假命题；比如，'某人是剑士'，真命题。

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

演示得再详细一点，配合注释，大家就能理解了！

# 4. 布尔
# 布尔取值只有真和假，因此布尔类型主要用于逻辑判定
# 这里注意一下大小写问题，Python 里面的真 (True) 假 (False),C++/Java 可能是 true/false(小写的)
# 布尔值来源于'命题'，真或者假
c1 = True
c2 = False
print(type(c1))
print(type(c2))
# 这里取 c1/c2 这种比较简单粗暴的变量名其实是迫不得已，因为这里没有实际应用场景
# 我们写代码尽量起一个好一点的名字
# 关于布尔类型，会在后面的条件/循环介绍

布尔类型在咱们后续进行逻辑判断的时候，是非常有用的。

2.3.5 其他

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

2.4 变量类型带来的意义 (不仅仅是分类)：为什么要有这么多类型？

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

# 1. 不同的类型，占用的内存空间是不同的，占几个字节
# 比如 int 默认是 4 个字节，动态扩容
# 比如 float 固定 8 个字节
# 比如 bool 一个字节就足够了
# 再比如 str 是一个变长的变量，主要看字符串包含的内容

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

# 2. 不同的类型，对应能够进行的操作也是不同的
# int / float，可以进行 + - * / 运算 ------- 不能使用 len
# str 能 +，但是不能 - 不能 * 也不能 / ------- 以使用 len

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

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

3 ~> 动态类型特性

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

# 动态类型：指的是 [程序运行过程中], 变量的类型可能会发生改变。
a = 10
print(type(a))
a: int = 10
print(type(a))
a = 'hello'
print(type(a))
a: str = 'hello'
print(type(a))
a = True
print(type(a))
a: bool = True
print(type(a))

a 的类型随着程序的运行，就发生改变，并不会因为":(声明)"而导致类型随着程序的运行不发生改变了，还是会改变的——即，变量声不声明并不会影响到我们的类型系统是静态的还是动态的，所以说在 Python 里面要不要给变量进行声明完全是一个锦上添花的做法~>方便程序员读代码，并不是一定要的。

再比如这个——

a = 10
print(type(a))
a = 'hello'
print(type(a))

在程序执行过程中，a 的类型刚开始是 int，后面变成了 str——

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

# 静态类型：[程序运行过程中], 变量的类型始终不变
# C++ / Java
# Java 中的 int a = 10;
# a 这个变量在程序运行的整个过程中，始终都是 int，如果尝试 a = "hello"，编译阶段就会报错
# 一个编程语言，是否是动态类型，只是取决于运行时，类型是否发生改变，不取决于变量定义的时候是否声明类型
# Python 作为一个动态类型的语言，在定义变量的时候，也是可以写类型的！具体示例见上
# 动态类型写法是比较灵活的--->提高了语言的表达能力
# 然而，在编程中，"灵活"这个词往往是"贬义"的，"灵活"意味着更容易出错!!!
# 编程中往往是反对灵活，更多希望有一些明确的规定，避免程序员放飞自我
# 就像斑马线一样
# 相比之下，静态类型的语言还是更好一些，尤其是在大型的程序中，多人协作开发中，能够减少不必要的沟通，提高效率
# 因此很多公司，在创业之初，喜欢使用 Python 来开发，产品规模小，也就是一两个程序猿，很快的就能搞出来
# 但是当项目达到一定的规模之后-->动态类型的劣势就逐渐体现了。
# 很多公司就会针对之前 Python 写的代码使用其他语言进行重构-->推导重写一遍，避免动态类型所产生的一些问题
# 很多创业公司都有过类似的经历，比如知乎/豆瓣/B 站...
# 动态类型虽然有它的优势，但它的劣势也很明显，我们在实际开发中还是要结合具体情况来决定使用哪种类型
# Python 是动态类型，我们要知道动态类型的劣势，尽量规避劣势

4 ~> 注释

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)**2)
result = total / 3
print(result)
# (行注释) 这也是注释

4.2 注释的语法

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

4.2.1 行注释

使用 # 开头的行都是注释——

# 这是一行注释

# (行注释) 这也是注释

4.2.2 文档字符串

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

# #开头的注释，一般是写在要注释的代码的上方;也有少数情况下是写在要注释代码的右侧的
# 很少会写在代码的下方，更不会写到代码的左侧 (后面的代码直接变成注释的一部分了)
# """:使用三引号开头引起来的称为"文档字符串",也可以视为一种注释
# """和'''等价
"""这是一段文档字符串，它起到的作用和注释一样，也是解释说明的效果."""

4.3 注释的规范

# 如何写出比较好的注释:
# 1. 注释的内容得是准确的！起到误导作用的注释还不如不写!!!--->不是程序员故意要写的--->公司的项目要经常进行"迭代"
# 本来代码和注释都已经写好了，后来代码一更新，但是注释忘记同步更改了--->但凡要修改代码，务必要记得更新注释
# 2. 注释的篇幅要合理-->既不要太精简 (看不懂)，也不要长篇大论 (别人没有耐心阅读下去)
# 3. 注释使用中文
# 如果是在中国公司，注释当然还是要写咱们的母语中文 (很多程序员其实英文水平不好) 啦!
# 如果是在外国公司 (或者是中国公司对外的业务)，这种可能会要求使用英文写注释
# PS: 中国公司好？外国公司 (外企) 好？都有好有坏，不能一言以蔽之
# 4. 注释内容要积极向上，不要有负能量!
# 前几年有一个"事件",有个程序员在在线音乐播放器这个项目里面写了这样一行注释：针对穷比 vip(签到做任务得的 vip) 执行以下逻辑...
# 最后这个程序员被要求全网道歉，所以说注释里面不要有负能量哦！

4.4 花时间在注释上面值得吗？

身为专业的程序员，多花一些心思在写注释上面是完全值得的，我们不光要关心代码本身能不能运行正确，还要关心代码的可读性好不好，容不容易被人理解。

5 ~> 输入输出

5.1 和用户交互：控制台

程序需要和用户进行交互。

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

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

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

输入输出的最常见方法是图形化界面，如我们平时用到的 QQ、浏览器、steam 等，都不需要用户输入命令，而只是通过鼠标点击窗口点击按钮的方式来操作。Python 当然也可以用来开发图形化界面的程序，是图形化程序开发本身是一个大话题，咱们博客里面暂时不作介绍。

# 控制台
# 这些对于机械的操作面板，就叫控制台，控制台上会有一些按钮，开关，操作杆...
# 后来有了计算机之后，控制台的概念也就延续下来了~
# 只不过计算机是通过键盘鼠标等进行操作，把操作结果显示到屏幕上
# 计算机里，就把用户能输入命令，向计算机安排工作 (就像你的上司和你的关系，你的上司给你布置任务，你去完成，这里上司变成了用户)
# 计算机再把结果显示出来这样的程序，就称为 [控制台] 了
# 控制台是一种人和计算机交互的最基础方式
# 但是日常生活中却不常用，更常见的交互方式，图形化界面
# 图形化界面的程序编写起来并不容易，课堂上还是使用控制台的方式来进行交互

5.2 基于控制台输出

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

print('hello')

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

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

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

示例：输出 num = 10。

num = 10
print(f'num = {num}')

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

Python 中还支持其他的格式化字符串的方法，我们目前暂时只了解这个最简单的即可。

# 基于控制台输出
# 如何批量注释代母：
# 1. 选中要注释的代码
# 2. 使用 ctrl +/ (取消也一样)
a = 10
print(a)
b = 'hello'
print(b)
c = True
print(c)
a = 10
# 希望使用 print 打印出 "a = 10" 这样的内容
# 我们希望把数字和字符串混在一起来打印
# print("a = " + a)
# 报错：TypeError: can only concatenate str (not "int") to str
# 上面的想法可以用"格式化字符串"来实现
print(f"a = {a}")
# 这个语法叫做"格式化字符串"
# f-string，这里的 f 表示"format"
print(f"b = {a + 10}")
# 格式化字符串：最常用的方式-->之前不是说 Python 解决一个问题只有一种方式吗？为什么这里格式化又有多种方式？
# 其实这里和 Python 的发展有关系
# 像格式化打印字符串~很多编程语言都进行了各自的探索，但是这些打印或多或少都存在各自的一些问题:
# C 的 printf 使用%d,%s 这样的占位符 (一旦把占位符写错，占位符和实际要打印的字符不匹配，后果是灾难性的)
# C++ 采用了 std::cout，使用<<(C++ 虽然避免了 C 语言中占位符写错的问题，但是整体的打印不够直观，可读性太差)
# Java 采用了字符串拼接，允许字符串和其他类型的值进行拼接 (缺少了一些必要的校验功能)
# 因此这些方法都有一些不太完美的地方
# Python 最早支持的格式化字符串，也是效仿 C 的 printf...并做出了改进
# Python 3.6 版本才开始支持 f-string(这是当下更好更先进地表示格式化字符串的方式)
# 所以，之所以 Python 提供了多种方式，也是语言发展的结果-->所有语言不是尽善尽美的，需要有一个不断进化发展的过程

5.3 从控制台输入

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

num = 0
num = input('请输入一个整数：')
print(f'你输入的整数是 {num}')

注意： input 的参数相当于一个'提示信息'，也可以没有； input 的返回值就是用户输入的内容，是字符串类型。

a = input('请输入第一个整数：')
b = input('请输入第二个整数：')
print(f'a + b = {a + b}')

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

a = input('请输入第一个整数：')
b = input('请输入第二个整数：')
a = int(a)
b = int(b)
print(f'a + b = {a + b}')

通过 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}')

此处为了输入 4 个数字，执行了四次 input。 如果是读取任意多个数字怎么办呢？此时就需要用到循环了，我们后面到循环部分再介绍。

# 从控制台输入
# 输入四个小数，求四个小树的平均值
# input 执行的时侯 就会等待用户输入！
# ---->这个等待可能是一个非常长的等待，完全就看用户啥时候去输入——
# 如果用户始终不输入，（不像和对象约会）就会一直在这里死等，不见不散！
# input 返回的值，其实是一个 str
# 如果只是单纯的拿到用户的输入，然后打印，此时就按照 str 打印即可
# 如果需要根据用户输入的内容进行算术计算，此时就需要先把读到的 str -> int
# 可以使用 int()
# 如果想把整数转成字符申？str()
# 如果想把字符串转成浮点数？float()

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}")

6 ~> 运算符

# 运算符-->
# 算术运算符
# 关系运算符
# 逻辑运算符
# 赋值运算符

即——

6.1 算术运算符

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

6.1.1 算术运算符的五个注意点

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

print(10 / 0)

异常 是编程语言中的一种常见机制，表示程序运行过程中，出现了一些'意外情况'，导致程序不能继续往下执行了。

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

print(1 / 2)

注意 3： % 不是'百分数'，而是求余数。

print(7 % 2)

关于求余数，可能有些开发者容易蒙——其实这个是我们小学二年级数学就学过的：7 除以 2，商是 3，余数是 1。

注意 4：** 是求乘方——不光能算整数次方，还能算小数次方（开根）。

print(4 ** 2)
print(4 ** 0.5)

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

print(7 // 2)
print(-7 // 2)

6.1.2 完整流程

# 算术运算符
# + - * / % ** // --> 先算乘方，然后是乘除，最后算加减
# 如果运算过程中想修改默认的运算顺序，就需要加上 ()
result = (1 + 2) * 3
print(result)
# 除法的第一个问题：抛出异常
# 在 Python 中，0 不能作为除数
# print(10 / 0) # 报错：ZeroDivisionError: division by zero
# 这种运行时出现的错误也叫做'抛出异常'，如果程序运行过程中抛出异常，程序直接就终止了，异常后面的代码也就不会执行到了
# 计算机是铁憨憨~~当计算机遇到不合理的地方，就会直接躺在地上摆烂（不往下干活了）
# 除法的第二个问题：截断的问题-->整数 / 整数，如果除不尽，得到的就是小数，不会出现截断的情况
# 在 Python 中，整数除以整数，结果可能是小数
print(1 / 2)
# 输出：0.5
# print(10 / 0.0)
# 报错：ZeroDivisionError: float division by zero
# 有些缠程语言中，/ 整数 0 也是会抛出异常，/ 浮点数 0 会得到无穷大，而 Python 都认为是除 0 异常
# 除了 Python 之外，大部分的编程语言，都是整数除以整数，结果还是整数
# % 表示求余数
# 小学二年级数学的问题：7 除以 2，商是 3，余数是 1 得到的余数。一定是小于除数的!!
print(7 % 3)
# ** 表示乘方运算，既能支持乘方，也能支持开方
# ** 进行乘方运算 --> 既能够支持整数次方，也支持小数次方，开方运算
# 2^0.5，这种就是根号 2
print(4 ** 2)
print(4 ** 0.5)
# //：地板除法 (取整除法)，会针对计算的结果进行'向下取整'
# 这个'向下取整'针对正数和负数，取整的方向不一样（本质都是向更小的取整）
print(7 // 2)
print(-7 // 2)

6.2 关系运算符

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

<= 是'小于等于'，>= 是'大于等于'； == 是'等于'，!= 是'不等于'。

6.2.1 关系运算符的三个注意点

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)

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

a = 'hello'
b = 'world'
print(a < b)
print(a <= b)
print(a > b)
print(a >= b)
print(a == b)
print(a != b)

注意：直接使用 == 或者 != 即可对字符串内容判定相等 (这一点和 C / Java 不同)；字符串比较大小，规则是'字典序'。

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

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

print(0.1 + 0.2 == 0.3)

注意：浮点数在计算机中的表示并不是精确的！在计算过程中，就容易出现非常小的误差。

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

观察上图我们不难发现——

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

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

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

a = 0.1 + 0.2
b = 0.3
print(-0.000001 < (a - b) < 0.000001)

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

6.2.2 完整流程

# 如何批量化注释：Ctrl + / --> 取消也是如此
# / 和 \ 注意区分（前者叫'斜杠'，后者叫'反斜杠'）
# ---------------------------关系运算符 1---------------------------
# 关系运算符就是在比较两个操作数之间的'大小''相等'这样的关系！
# <
# >
# <=
# >=
# == 比较相等
# !=
# 1. 关系运算符对应的表达式值是布尔类型~
# 表达式符合要求，为真。
# 不符合要求，为假.
# 2. 关系运算不光可以针对数字进行比较，还能够比较字符串~
# 字典序-->在英文词典上，单词是按照一定的顺序来排列的
# 先看首字母在字母表上的顺序-->谁小，谁就排在前面：如果首字母相同，依次比较第二个字母，第三个字母...
# abandon（单词书上排在前面的，顺序：首字母 abcd……）
# 字符串在词典上越靠前，就越小越靠后，就越大
# a = 10
# b = 20
# print(a < b)
# print(a > b)
# print(a >= b)
# print(a <= b)
# print(a == b)
# print(a != b)
# a = 'hello'
# b = 'world'
# print(a < b)
# print(a > b)
# print(a >= b)
# print(a <= b)
# print(a == b)
# print(a != b)
# 针对中文进行大小字节序比较，是没有意义的
# 至少按照默认的字典序来说，是没有意义的
# a = '你好'
# b = '世界'
# print(a < b)
# print(a > b)
# print(a >= b)
# print(a <= b)
# print(a == b)
# print(a != b)
# 在计算机里，表示中文，其实是用多个字节构成的一个比较大的数字来进行比较
# 在有些场景下，比如手机通讯录、微信通讯录（联系人名字按照拼音来进行排序）--->是另外的比较规则
# 至少 Python 默认是不支持的，需要使用第三方库，才能实现类似的效果
# 字符串之间好像不能直接使用 == 或者 != 来比较呀？！
# C ---> strcmp，如果直按使用 == 本质上在比较两个字符串首元素地址.
# Java ---> equals 方法，如果直接使用==本质上在比较这两个字符串是否是同一个对象.
# 上面这两种这是一个小众的行为.
# 像 Python 直接使用 == 和 != 来比较字符串内容相同才是大部分编程语言遵守的规则
# ---------------------------关系运算符 2---------------------------
# 浮点数比较大小的问题：
# 3. 针对浮点数来说使用 == 比较相等，存在一定的风险!
# 因为浮点数在内存中的存储和表示，是可能存在误差的!
# 这样的误差在进行算术运算的时候就可能被放大，从而导效 == 的判定出现误判！
# print(0.1 + 0.2 == 0.3)
# 结果：False，为什么是 False 呢？我们可以把计算过程都打印出来
# print(0.1)
# print(0.2)
# print(0.1 + 0.2)
# print(0.3)
# # 过程：
# # 0.1
# # 0.2
# # 0.30000000000000004
# # 0.3
# # 是不是发现了一些端倪？
# 正确的比较浮点数相等：作差，看差值是否小于预期的误差范围！
a = 0.1 + 0.2
b = 0.3
# Python 中支持这种连续小于的写法，判定 a - b 既是小于 0.000001 又是大于 -0.000001
# 这个代码是看 a - b 差是否是一个非常小的数字，是否是在误差范围之内
print(-0.000001 < (a - b) < 0.000001)

6.3 逻辑运算符

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

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

此处说的'并且'和'或者'，就是我们日常生活中使用的'并且'和'或者'。 想象一下未来丈母娘问你要彩礼，什么叫做'有房并且有车'，什么叫做'有房或者有车'。

6.3.1 逻辑运算符的一些注意事项

a = 10
b = 20
c = 30
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)

6.3.1.1 一种特殊写法

a < b and b < c 这个操作等价于 a < b < c——这个设定和大部分编程语言都不相同。

6.3.1.2 关于短路求值

和其他编程语言类似，Python 也存在短路求值的规则。

对于 and，如果左侧表达式为 False，则整体一定为 False，右侧表达式不再执行； 对于 or，如果左侧表达式为 True，则整体一定为 True，右侧表达式不再执行。

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

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

6.3.2 完整流程

# 逻辑运算符
# 找女朋友，谈婚论嫁——要彩礼
# 要有房并且要有车（and：缺一不可）
# 要有房或者要有车（or：有一个就行，不能两个都没有
# and 并且 两侧操作数均为 True，表达式的值为 True，否则为 false（一假则假）
# or 或者 两侧操作数均为 False，表达式的值为 False，否则为 True（一真则真）
# not 逻辑取反 只有一个操作数。操作数为 True，则返回 False；操作数为 False，则返回 True
a = 10
b = 20
c = 30
# # 1. and
# # a < b < c 等价于 a < b and b < c
# # print(a < b and b < c)
# print(a < b < c) # 带黄色波浪线，功能上没问题，但是有更好的写法：点击黄色灯泡
# print(a > b and b > c)
## # 2. or
# print(a < b or b < c)
# print(a < b or b > c)
# print(a < b or b < c)
## # 3. not
# print(not a < b)
# print(not a > b)
# 比如 C++ 或者 Java 里，使用
# && 表示逻辑与 并目
# || 表示逻辑或 或者
# ！表示逻辑非 逻辑取反
# 逻辑运算符中的重要细节：短路求值（物理上的术语）
# 对于 and 操作来说：如果左侧表达式为 False，那么整体的值一定是 False，右侧表达式不必求值！
# 对于 or 操作来说：如果左侧表达式为 True，那么整体的值一定是 True，右侧表达式不必求值！
# 右侧就不再求值了，所以一旦右侧求值了，是能够看到代码出现异常的！
# 如果代码没有抛出异常，右侧没有求值！
print(a > b and 10 / 0 == 1)
# print(a < b and 10 / 0 == 1) # 报错：ZeroDivisionError: division by zero
print(a < b or 10 / 0 == 1)
# 短路求值这种行为，大部分编程语言都有，C、C++、Java……

6.4 赋值运算符

6.4.1 = 的使用

= 表示赋值，这个我们已经用过很多次了，注意和 == 加以区分； = 除了基本的用法之外，还可以同时针对多个变量进行赋值。

6.4.1.1 链式赋值

a = b = 10

6.4.1.2 多元赋值

a, b = 10, 20

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

6.4.1.3.1 基础写法

a = 10
b = 20
tmp = a
a = b
b = tmp

6.4.1.3.2 基于多元赋值

a = 10
b = 20
a, b = b, a

6.4.2 复合赋值运算符

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

其中 a += 1 等价于 a = a + 1，其他复合赋值运算符也同理。

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

注意：像 C++ / Java 中，存在 ++ – 这样的自增/自减运算符。Python 中则不支持这种运算。 如果需要使用，则直接使用 += 1 或者 -= 1。

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

6.4.3 完整流程

# ------------------------------赋值运算符（1）------------------------------
# = 表示赋值，意思就是把右侧的值填充到左侧的空间（这个空间得是一个变量）中！
# == 表示比较相等
a = 20
# 连续赋值：先把 20 赋值给 b，再把 b 赋值给 a，就相当于 a = 20，b = 20-->我们称之为'链式赋值'
# 工作中不建议使用链式赋值，尽量一行代码只是包含一个操作（挤在同一行可读性也不太好）！
a = b = 20
# 多元赋值：能够帮我们解决一些特殊问题
# 比如可以完成两个变量的交换
a = 10
b = 20
# tmp = a
# a = b
# b = tmp
# print(a,b)
# 使用多元赋值，直接一步到位完成交换
a, b = b, a
print(a, b)
# 借助多元赋值，完成让一个函数返回多个值这样的操作
# ------------------------------赋值运算符（2）------------------------------
# 有一个读取变量的过程
# a = 0
# NameError: name 'a' is not defined（不认识 a 这个变量）
a = 0
a = a + 1
# 和上面等价
a += 1
# -=，*=，/=，**=，%=，//=
# C++ / Java 中的 a++、++a 可以吗？
# ++a
# ++a：黄色波浪线，之所以没有语法报错，是因为 Python 解释器把 + 当成了正号
# 同理，--a 也是不会报错，把 - 当成了负号，负负得正，最终的值仍然不变
# a++
# 但是后置++和后置--在语法上都是报错的！
# 使用 a += 1 已经很方便地完成自增了！
# SyntaxError: invalid syntax
# ++操作其实挺讨厌的-->
# 前置++（表达式返回自增之后的值）和后置++（表达式返回自增之前的值）的区别，对于初学者来说是非常不友好的！在初学 C 语言时也比较不友好
# Python 中不支持++、--这样的自增自减操作！
# Python 直接把前置++、后置++、前置--、后置--都给删了
print(a)
# 值得一提的是：前置++、后置++这是 C 语言开的头，但是现在 C 语言已经后悔了！
# -->Go 语言——Golang——作者就是 C 语言之父，肯·汤姆逊，如今依然活跃
# Go 语言：C 的升级版本
# 在 Golang 里面废除了前置++，只保留了后置++，而且这个后置++不能取表达式的返回值
# Go 虽然没有 Python 这么决绝，但还是能够降低大家的学习成本的
# 其他运算符
# 除了上述之外，Python 中还有一些运算符：比如身份运算符（is,is not），成员运算符（in,not in），
# 位运算符（& | ~ ^ << >>) 等。此处咱们暂时不介绍。

6.5 其他

除了上述之外，Python 中还有一些运算符，比如身份运算符 (is, is not)、成员运算符 (in, not in)、位运算符 (& | ~ ^ << >>) 等。 此处我们不作过多介绍。

7 ~> Python 基础：语法篇第一部分总结

# 总结
# 本章节中我们学习了 Python 中的最基础的语法部分
# 常量
# 变量
# 类型
# # 整数
# # 浮点数
# # 字符串
# # 布尔值
# 注释
# 输入输出
# 运算符
# # 算术运算符
# # 关系运算符
# # 逻辑运算符
# # 赋值运算符

当前我们的代码还只能进行一些简单的算术运算，下个章节中我们将学习 Python 中的逻辑判断，我们就可以写稍微复杂一点的程序了。

8 ~> Python 基础：语法篇第一部分自测小练习

Python 基础语法的第一部分到前面的【总结】那里就已经结束了，这是自测小练习，大家可以检验一下，看看前面的基础怎么样。

8.1 例题 1

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

正确选项： ACD

题目解析——

# 题目解析：
# D. 如果把布尔类型的值和整数进行算术运算，此时就会把 True 当做 1，把 False 当做 0-->虽然也能跑，但是这样的操作，是没有意义的！！！
# 也就是说：布尔类型只是单纯地表示真和假，他和数字之间并没有一个明确的联系
# True 和 False 约定一个 1 一个 -1 也可以，约定别的也可以，只是在 Python 解释器这里 True 是 1、False 是 -1
# 这只是语言作者一拍脑门想出来的，C/C++ 也是有类似的行为，
# 但是 Java 这里的做法是更合理的！！！--->如果出现整数和布尔混合运算，直接编译报错。

8.2 例题 2

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

正确选项： D

题目解析——

# A. Python 中只有字符串类型，没有字符类型！'a'这算是长度为 1 的字符串！正是因为 Python 中没有字符类型，
# 所以"和'都能表示字符串；C++，Java 有单独的字符类型，单引号表示字符，双引号表示字符串
# B. Python 中只有 float
# C. Python 只有 int-->根据表示数据的大小自动进行扩容，换言之：只要内存空间足够大，就可以表示足够大的数据

8.3 例题 3

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

正确选项： B

题目解析——

# 题目解析：
# A. int a = 10 # 不科学，这是典型的 C/C++ 和 Java 的做法，在 Python 里面创建变量不需要指定类型
# 在 Python 中如果非要加上类型，这里的表示也是错误的，在 Python 中是像下面这样加上：来指定类型的--> a:int=10
a = 10;
# 为了代码可读性，可读性比代码运行正确还是要重要一些的
# B. 在 Python 中，一个语句写完了之后，可以加上分号，也可以不加
# 通常情况下都是不加的，如果加了，也不算错！！
# 如果把多个语句写到同一行了，这个时候语句之间，务必要加上分号的（这种写法并不推荐），如下面这种情况--->
# a = 10 print
# 务必要加上;
# C. a = true
# NameError: name 'true' is not defined. Did you mean: 'True'?很亲切地提示你
# D. 已经强调过很多次了，字符串和数字不能相加