Python基础：常量、变量、变量类型、表达式、注释、输入输入、运算符

引言

手把手带你快速上手Python

一、常量和表达式

在Python中运行下面的代码：

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

​​​​
注意:

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

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

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

二、变量和类型

1.变量是什么

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

示例

给定四个分数, 67.5, 89.0, 12.9, 32.2 , 编写代码, 求这四个分数的方差.
PS: 方差的计算过程: 取每一项, 减去平均值, 计算平方, 再求和, 最后除以 (项数 - 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)

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

注意:

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

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

2.变量的语法

(1) 定义变量

a = 10

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

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

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

硬性规则(务必遵守)

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

软性规则(建议遵守)

• 变量名使用有描述性的单词来表示, 尽量表达出变量的作用.
• 一个变量名可以由多个单词构成, 长一点没关系, 但是含义要清晰.
• 当变量名包含多个单词的时候, 建议使用 “驼峰命名法”. 形如 totalCount , personInfo 这种, 除了首个单词外, 剩余单词首字母大写.

---

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

(2) 使用变量

读取变量的值

a = 10
print(a)

修改变量的值

a = 10
a = 20
print(a)

当然, 也可以用一个变量的值赋给另外一个变量.

a = 10
b = 20
a = b
print(a)
print(b)

3.变量的类型

变量里面存储的不仅仅是数字, 还可以存储其它种类的数据. 为了区分不同种类的数据, 我们引入了 “类型” 这样的概念.
注意: 和 C++ / Java 等语言不同, Python 变量的类型不需要显式指定, 而是在赋值的时候确定的.

(1) 整数

type也是python的内置函数，可以打印出该数据是什么类型。

a = 10
print(type(a))

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

(2) 浮点数(小数)

a = 0.5
print(type(a))

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

(3) 字符串

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

使用 ’ ’ 或者 " " 引起来的, 称为 字符串. 可以用来表示文本.

注意: 在 Python 中, 单引号构成的字符串和双引号构成的字符串,没有区别.’hello word’ 和“hello word" 完全等价的. 在python中'''hello word‘’‘也是和前面两种情况等价的。
为什么要用三符号表示都可以(是有说法的)
当一个字符串里面需要嵌套带有单引号或者双引号的字符串时，就需要使用不同的引号来区分，谁和谁一一对应。

e = "My name is 'tuse'"
print(e)
f = '''My 'name' is "tuse"'''
print(f)

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

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

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

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

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

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

这段代码，虽然python解释器没有报错，但是在运行的时候，是会报错的。

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

(4) 布尔

布尔类型是一个特殊的类型, 取值只有两种, True (真) 和 False (假).
但是，布尔类型在和整数或者浮点数做算术运算的时候，True看作是1，False看作是0。（虽然可以这样操作，但是是没有意义的）
C/C++也是这样的操作
但是Java是这样的：整数或者浮点数和布尔类型混合运算，直接编译报错!!

 a = Trueprint(type(a))b = Falseprint(type(b))

(5) 其他

除了上述类型之外, Python 中还有 list, tuple, dict, 自定义类型 等等.

4.为什么要有这么多类型?

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

• int默认是4个字节，可以动态扩容
• float 固定是8个字节
• bool 一个字节
• str 是可变长的

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

• int / float 可以+ - * / 不能使用len
• str 可以+，可以使用len，不能 - * /

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

5.动态类型特性

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

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

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

C++/Java 这样的语言则不允许这样的操作. 一个变量定义后类型就是固定的了. 这种特性则称为 “静态类型”.
像：int a = 10 a只能是int类型，下面给a赋值，都会转成int类型或者编译器报错。如 a = "hello word"编译器会报错。

在Python中可以指定类型，但是没有意义：

a:int = 10
print(type(a))
a:str = 'hello'
print(type(a))

动态类型特性是一把双刃剑.

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

三、 注释

1.什么是注释

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

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

2.注释的语法

Python 中有两种风格的注释.

(1) 注释行

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

# 这是一行注释.

(2) 文档字符串

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

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

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

3.注释的规范

1. 内容准确: 注释内容要和代码一致, 匹配, 并在代码修改时及时更新.
2. 篇幅合理: 注释既不应该太精简, 也不应该长篇大论.
3. 使用中文: 一般中国公司都要求使用中文写注释, 外企另当别论.
4. 积极向上: 注释中不要包含负能量(例如 领导 ** 等).

四、输入输出

1.和用户交互

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

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

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

控制台的由来

最开始的电脑的控制台的机械操作的面板，控制台上会有一些按钮开关，操作杆等等…
后来有了计算机后，控制台的概念就被延续下来了。
下面这个是windows的控制台。

PyCharm有自己的控制台
但是日常生活中不常用，因为需要专门学一下怎么使用，所以更常见的交互方式是：图形化界面。

2.通过控制台输出

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

print('hello')

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

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

更多的时候, 我们希望能够输出的内容是混合了字符串和变量的
如：输出 num = 10
在Java中可以这么写：

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

但是Python中是不支持字符串加其他类型变量的
在Python中正确的写法：

a = 10
print(f"a = {a}")

注意:

• 使用 f 作为前缀的字符串, 称为 f-string
• 里面可以使用 { } 来内嵌一个其他的变量/表达式.
• 这里是介绍了一种方式，也是比较常用的方式，还有其他方式，可以去问一下豆包，这里就不缀序列。

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

3.通过控制台输入

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

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

注意:

• input 的参数相当于一个 “提示信息”, 也可以没有。
• 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}')

五、运算符

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: // 是取整除法(也叫地板除). 整数除以整数, 结果还是整数(舍弃小数部分, 并向下取整. 不是四舍五入)

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)

(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 不同，C/Java那里是小众的，这里这个是大众的).
• 字符串比较大小, 规则是 “字典序”

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

(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)

实际工程实践中, 误差在所难免, 只要保证误差在合理范围内即可。
在Python中是支持连续比较的，但是在C/Java中是不支持的。

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)

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)

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

4.赋值运算符

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

a = b = 10

多元赋值

a, b = 10, 20

代码实例: 交换两个变量

基础写法

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

基于多元赋值

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

(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 语法在设计的时候就进行了规避, 避免出现这种不直观, 并且容易混淆的语法.

5.其他…

除了上述之外, Python 中还有一些运算符, 比如 身份运算符 (is, is not), 成员运算符 (in, not in), 位运算符 ( & | ~ ^ << >>) 等. 需要结合更多的知识来使用。

六、关于语句后面加不加分号;

在python中，一个语句写完了之后，可以加上分号，也可以不加
通常情况下都是不加的，如果加了，也不算错!!
但是：如果把多个语句写在了同一行，这个时候语句之间，一定要加上分号（不推荐这样写）

a = 10 print(a)

不加分号，编译器会报错：

加上分号：

a = 10; print(a)

程序正常运行。