【Python】基础语法1（常量与表达式、变量和类型、注释、输入输出、运算符）

1. 常量与表达式

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

print(1 + 2 - 3)
print(1 + 2 * 3)
print(1 + 2 / 3)
1
2
3

分析：

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

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

注意: 熟悉 C / Java 的同学可能认为, 2 / 3 结果为 0 (小数部分被截断). 但是在 Python 中得到的结果则是一个小数. 更符合日常使用的直觉。

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

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

2. 变量和类型

2.1 变量是什么

有的时候, 我们需要进行的计算可能更复杂一些, 需要把一些计算的中间结果保存起来. 这个时候就需要用到 变量。
变量可以视为是一块能够容纳数据的空间. 这个空间往往对应到 “内存” 这样的硬件设备上

示例
给定四个分数, 67.5, 89.0, 12.9, 32.2 , 编写代码, 求这四个分数的方差。
方差的计算过程：取每一项，减去平均值，计算平方，再求和，最后除以（项数-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)
1
2
3
4

分析：

• 在这个代码中, 就需要先计算这四个数字的平均值, 然后再计算方差. 这就需要把计算的平均值使用变量保存起来。
• 代码中的 avg，total，result 均为变量。
• ** 在 Python 中便是乘方运算。**2即为求平方。

2.2 变量的语法

（1）定义变量

代码示例：

a = 10
1

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

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

变量命名要遵守一定的规则

1. 硬性规则（务必遵守）

• 变量名必须由数字，字母，下划线构成。不包含特殊字符。
  例：a1是合法变量名 。1a，a*a都是非法变量名
• 数字不能开头。
• 变量名和 Python 的“关键字”重复。
  例如：if 这种就是非法变量名
• Python 中的变量名是大小写敏感的，区分大小写。
  num 和 Num 是两个不同的变量名

2. 软性规则 （建议遵守）

• 给变量命名的时候，尽量使用描述性的单词来表示，尽量通过名字表示出变量的作用。
• 当我们使用一个单词描述不清的时候，可以使用多个单词来命名，不怕变量长，就怕变量的含义表示不清。
  ① 驼峰命名：除了第一个首字母之外，后续每个单词的首字母都大写。
  例：personInfo；totalCount
  ② 蛇形命名：单词之间使用下划线_来进行分隔。
  person_info；total_count

（2）变量的使用
代码如下：

#读取变量
a = 10
print(a)

#修改变量
a = 20
print(a)
1
2
3
4
5
6
7

注意: 在 Python 中, 修改变量也是使用 = 运算, 看起来和定义变量没有明显区别。
首次使用 = 对 a 进行设置时，这个过程是创建变量（初始化）。
后续对 a 使用 = 操作，则是相当于修改 a 的内容（赋值）。

当然也可以用一个变量赋值给另外一个变量
示例

a = 10
b = 20
a = b
print(a)
print(b)
1
2
3
4
5

2.3 变量的类型

对于不同种类的变量作出区分，Python中的变量类型，不需要在定义变量的时候显示声明，而只是依靠初始化语句，根据初始化的值的类型来进行判断。

2.3.1整数

a = 10
print(type(a))
1
2

注：type 和 print 类似, 也是 python 内置的函数. 可以使用 type 来查看一个变量的类型。
在 Python中 int 能够表示的数据范围是没有上线的（“无穷”的），Python 的 int 是可以根据表示的数据的大小自动扩容的。
因此，Python 这里就没有 long 这样的类型了，像 byte，short 这些类型在 Python 中也是不存在的。

2.3.2 浮点数

a = 0.5
print(type(a))
1
2

注意： 和 C++ / Java 等语言不同, Python 的小数只有 float 一种类型, 没有 double 类型. 但是实际上 Python 的 float 就相当于 C++ / Java 的 double, 表示双精度浮点数。
相比于单精度浮点数, 双精度浮点数占用的内存空间更多, 同时表示的数据精度更高即可(大概精确到小数点后15位）。

2.3.3 字符串

a = 'hello'
print(type(a))
1
2

Python 中使用 ’ ’ 或者 " " 引起来的, 称为 字符串. 可以用来表示文本。
因为Python中只有字符串类型，没有字符类型。所以 ’ ’ 或者 " " 都能表示字符串，‘a’ 这算是长度为1的字符串。

注意: 在 Python 中, 单引号构成的字符串和双引号构成的字符串, 没有区别. ‘hello’ 和 “hello” 是完全等价的。
因此，如果字符串里面包含了 " “，表示字符串就可以用 ’ ’ 引起来；如果字符串里面包含了 ’ ’ ，表示字符串就可以用 " " 引起来。如果字符里面同时包含了 " " 和 ‘ ’，Python中还有一种字符串使用三引号，表示 ‘’’ ‘’’ 或 “”” “”"。

a = 'hello'
print(a)

a = "hello"
print(a)
print('''her 'name' is "mary" ''')
1
2
3
4
5
6

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

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

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

a = 'hello'
b = 'world'
print(a + b)
1
2
3

字符串拼接就是把后面的字符串拼接到前一个字符串的末尾，得到一个更大的字符串（对于原来的字符串a和b是没有影响的）。注意此处是两个字符串相加. 不能拿字符串和整数/浮点数相加。

2.3.4 布尔

布尔类型是一个特殊的类型, 取值只有两种, True (真) 和 False (假)，因此，布尔类型主要用于逻辑判断。

a = True
print(type(a))
b = False
print(type(b))
1
2
3
4

如果把布尔类型的值和整数进行算术运算，此时会把 True 当做1，把 False 当作0，但是这样的操作是没有意义的。

a = 10 + True
print(a)
b = 10 + False
print(b)
1
2
3
4

2.3.5 其他

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

2.4 变量类型的意义

1. 不同的类型，占用的内存空间是不同的，占几个字节(byte)

• int 类型在内存中默认4字节，在Python中可动态扩容
• float 类型在内存中固定是8字节
• bool 类型在内存中是2字节

2. 不同的类型，对应能进行的操作也是不用的
例如：int / float 类型的变量，可以进行 + - * / 等操作。
而 str 类型的变量，只能进行 + （并且行为是字符串拼接），不能进行 - * / ，但是还能使用 len 操作。

2.5 动态类型特性

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

a = 10
print(type(a))
a = 'hello'
print(type(a))
1
2
3
4

• 在程序执行过程中, a 的类型刚开始是 int,后面变成了 str。
• C++/Java这样的语言则不允许这样的操作，一个变量定义后类型就是固定的，这种特性称为“静态类型”。
• 一个编程语言，是否是动态类型，知识取决于运行时，类型是否发生改变，不却决于变量定义的时候是否声明类型。
  Python 作为动态类型的语言，在定义变量的时候，也是可以写类型的。

a:int=10
print(type(a))
1
2

动态内存是一把双刃剑

• 对于中小程序，可以大大的约代码量简约代码量（比如写一段代码就可以同时支持多种类型）。
• 对于大型程序，则提高了模块之间的交互成本（程序员A提供的代码难以被程序员B理解）。

3. 注释

注释是什么？
注释是一种特殊的代码，他不会影响程序的执行，但是能够起到解释说明的作用，能过帮到程序员理解程序代码的执行逻辑。

# 计算 4 个数字 67.5, 89.0, 12.9, 32.2 的方差
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)
1
2
3
4
5

形如上述代码, 如果没有注释, 直接阅读, 是不容易 get 到代码的含义是计算方差. 但是通过加了一行注释解释一下, 就让人一目了然了。

3.1 注释的语法

在 Python 中注释有两种风格

（1）注释行
使用 # 开头的是行注释
如有需要多行注释则可以选中代码然后按 Ctr l+ /,取消注释也是按 Ctrl + /

#这是一行注释
1

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

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

"""
这是文档字符串
这是文档字符串
这是文档字符串
"""
1
2
3
4
5

3.2 注释的规范

1. 内容准确: 注释内容要和代码一致, 匹配, 并在代码修改时及时更新.
2. 篇幅合理: 注释既不应该太精简, 也不应该长篇大论.
3. 使用中文：
4. 积极向上: 注释中不要包含负能量

4. 输入输出

程序需要和用户进行交互

• 用户把信息传递给程序的过程，称为 “输入”。
• 程序把结果展示给用户的过程，称为 “输出”。
  输入输出的最基本的方法就是控制台。
  用户通过控制台输入一些字符串, 程序再通过控制台打印出一些字符串。

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

4.1 通过控制台输出

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

print('hello')

a = 10
print(a)

b = True
print(b)
1
2
3
4
5
6
7

我们可以看到 print 函数不仅能输出一个字符串，还可以输出一个其他类型的变量，但更多的时候，我们希望能够输出的内容是混合了字符串和变量的。

示例：输出 num = 10

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

注意：

• print(f’num = {num}') 这个语法是叫做 ”格式化字符串“，使用 f 作为前缀的字符串，称为 f -string，此处的 f 表示 format 。
• 里面可以使用 { } 来内嵌一个其他的变量/表达式。

4.2 通过控制台输入

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

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

注意:

• input 的参数相当于一个 “提示信息”, 也可以没有。
• input 的返回值就是用户输入的内容. 是字符串类型。

示例：输入两个整数，输出两个整数的和。

错误示范

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

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

正确示范：

a = input('请输入第一个整数: ')
b = input('请输入第二个整数: ')
a = int(a)
b = int(b)
print(f'a + b = {a + b}')
1
2
3
4
5

分析：

• 如果只是但需的拿到用户的输入，然后打印，此时就按照 str 打印即可。
• 如果需要根据用户输入的内容进行算术计算，此时就需要把读到的 str 转换成 int
  通过 int( ) 把变量转成了 int 类型.
  类似的, 使用 float( ), bool( ), str( ) 等可以完成对应的类型转换。

5. 运算符

5.1 算术运算符

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

+（加） -（减） *（乘） /（除） %（取余数）  **（乘方）  //（取整除法）
1

运算规则：
先算乘方，然后是乘除，最后算加减
如果想要改变运算规则，则需加（）

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

print(10 / 0)
1

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

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

print(1 / 2)
1

注意3: % 不是 “百分数”, 而是求余数

print(7 % 2)
1

注意4: ** 是求乘方. 不光能算整数次方, 还能算小数次方

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

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

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

5.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)
1
2
3
4
5
6
7
8

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

a = 'hello'
b = 'world'
print(a < b)
print(a <= b)
print(a > b)
print(a >= b)
print(a == b)
print(a != b)
1
2
3
4
5
6
7
8

注意:

• 直接使用 == 或者 != 即可对字符串内容判定相等. (这一点和 C / Java 不同).
• 字符串比较大小, 规则是 “字典序”

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

（3）对于浮点数来说，使用 == 比较相等，存在一定的风险，最好不要使用 == 比较相等

print(0.1 + 0.2 == 0.3)
1

注意:
因为 浮点数在内存中的存储和表示，并不是精确的是可能存在误差的，这样的误差在进行算术运算符运算的时候就可能被放大，从而导致误判。

print(0.1)
print(0.2)
print(0.3)
print(0.1 + 0.2)
1
2
3
4

我们可以看到，0.1 + 0.2 的结果并不是 0.3，虽然这两个数字已经非常接近了，但是如果直接使用 == 进行比较，仍然会出现 False 的情况。

正确的浮点数比较相等
不再严格比较相等了, 而是作差，判定差值是否小于允许的误差范围

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

注：在 Python中是支持连续小写的写法
判定 a - b 既是小于 000001 又是大于 -000001

5.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 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)
1
2
3
4
5
6
7
8
9
10
11
12

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

关于短路求值
和其他编程语言类似, Python 也存在短路求值的规则.

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

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

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

5.4 赋值运算符

(1) = 的使用

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

链式赋值

a = b = 10
1

多元赋值

a,b = 10,20
1

代码示例：交换两个变量

# 交换两个变量的值
a = 10
b = 20

# 基础写法
tmp = a
a = b
b = tmp

#基于多元赋值
a,b = 10,20
1
2
3
4
5
6
7
8
9
10
11

(2) 复合赋值运算符
Python 还有一些 复合赋值运算符. 例如 += -= *= /= %=
其中 a += 1 等价于 a = a + 1 . 其他复合赋值运算符也是同理。

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

b = 10
b += 1
print(b)
1
2
3
4
5
6
7

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

5.5 其他运算符

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

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

a = 10; print(a)
1

本章到这里就结束啦，如果有哪里写的不好的地方，请指正。
如果觉得不错并且对你有帮助的话请给个三连支持一下吧！
Fighting!!!✊