【Python基础：语法第一课】Python 基础语法详解：变量、类型、动态特性与运算符实战，构建完整的编程基础认知体系

🎬 个人主页：艾莉丝努力练剑
❄专栏传送门：《C语言》《数据结构与算法》《C/C++干货分享&学习过程记录》
《Linux操作系统编程详解》《笔试/面试常见算法：从基础到进阶》《Python干货分享》

⭐️为天地立心，为生民立命，为往圣继绝学，为万世开太平

🎬 艾莉丝的简介：

文章目录

• 1 ~> 常量和表达式
• 2 ~> 变量和类型
  • 2.1 变量是什么
  • 2.2 变量的语法
    • 2.2.1 定义变量
    • 2.2.2 使用变量
  • 2.3 变量的类型：对于不同种类的变量作出区分
    • 2.3.1 整数
    • 2.3.2 浮点数(小数)
    • 2.3.3 字符串
    • 2.3.4 布尔（真 / 假）
    • 2.3.5 其他
  • 2.4 变量类型带来的意义(不仅仅是分类)：为什么要有这么多类型?
• 3 ~> 动态类型特性
• 4 ~> 注释
  • 4.1 注释是什么？
  • 4.2 注释的语法
    • 4.2.1 行注释
    • 4.2.2 文档字符串
  • 4.3 注释的规范
  • 4.4 花时间在注释上面值得吗？
• 5 ~> 输入输出
  • 5.1 和用户交互：控制台
  • 5.2 基于控制台输出
  • 5.3 从控制台输入
• 6 ~> 运算符
  • 6.1 算术运算符
    • 6.1.1 算术运算符的五个注意点
    • 6.1.2 完整流程
  • 6.2 关系运算符
    • 6.2.1 关系运算符的三个注意点
    • 6.2.2 完整流程
  • 6.3 逻辑运算符
    • 6.3.1 逻辑运算符的一些注意事项
      • 6.3.1.1 一种特殊写法
      • 6.3.1.2 关于短路求值
    • 6.3.2 完整流程
  • 6.4 赋值运算符
    • 6.4.1 = 的使用
      • 6.4.1.1 链式赋值
      • 6.4.1.2 多元赋值
      • 6.4.1.3 代码实例：交换两个变量
        • 6.4.1.3.1 基础写法
        • 6.4.1.3.2 基于多元赋值
    • 6.4.2 复合赋值运算符
    • 6.4.3 完整流程
  • 6.5 其他
• 7 ~> Python基础：语法篇第一部分总结
• 8 ~> Python基础：语法篇第一部分自测小练习
  • 8.1 例题1
  • 8.2 例题2
  • 8.3 例题3
• 结尾

1 ~> 常量和表达式

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

# 表达式# 优先级：先乘除后加减print(1+2-3)print(1+2*3)print(1+2/3)

print是一个Python内置的函数，这个我们稍后会作详细介绍，先小小卖个关子！

我们可以**使用+ - * / ()等运算符进行算术运算**，先算乘除，后算加减。

运算符和数字之间，可以没有空格，也可以有多个空格，但是一般习惯上写一个空格（比较美观）——关于这点，美观重要吗？
代码的美观，是否重要呢？这是个看脸的世界！代码如果简洁美观，也让将来的自己看得懂。

print(1 + 2 / 3)的结果输出可以看到是：1.6666666666666665，在Python中，2 / 3 => 0.666666 而不是0！！！在C / Java中，整数除以整数的结果还是整数！并且会把小数部分直接舍弃！输出：1.6666666666666665，为什么最后不是667？？编程中，一般没有“四舍五入”这样的规则！在Python中是浮点数，IEEE754标准->在这套规则下，在内存中表示浮点数的时候，可能会存在微小的误差。

形如1 + 2 - 3称为表达式，这个表达式的运算结果称为表达式的返回值，1 2 3这样的数字，称为 字面量常量，+ - * /称为运算符运算符或者操作符。

注意：熟悉C / Java的uu可能会认为，2 / 3（在C/C++里面是整除）结果为0（小数部分被截断），但是在Python中得到的结果则是一个小数，其实Python这种更符合我们日常使用的直觉（单纯的除号）。

我们来看一个示例，说：给定四个分数，67.5，89.0，12.9，32.2，编写代码，求这四个分数的平均数。

print((67.5+89.0+12.9+32.2)/4)#优先级

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 /3print(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 =20print(a)#后续再对a使用 = 操作相当于修改a的内容（赋值）

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

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

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

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

2.3.1 整数

# 1.整数int(所有的整数都用int表示)#初始化类型确定为int，全看赋了什么值，这里赋了10，就是int a =10print(type(a))# Python中的变量的类型，不需要在定义变量的时候显式声明，而只是依靠初始化语句，根据初始化的值的类型来进行确定# 在Python，int能够表示的数据范围是“无穷”的# Python的int是可以根据要表示的1那个数据的大小，自动扩容的# 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.5print(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"' #报错了 f ='''My 'name' is "Alice Greyrat"'''#可见Python字符串的定义方式还是非常灵活的print(type(f))# 我们上述的引号，都是英文的引号，而不是中文的引号# 利用单引号/双引号/双引号完成字符串内容的表示# 以上我们创建的这几种引号都是等价的关系,具体在写代码的时候哪个方便用哪个,没有实际的影响# 使用内置函数len(length)来查看字符串的长度(多长其实就是字符串里面包含了几个字符)print(len(d))# 字符串拼接# 形如下面这样的代码，就是"字符串拼接",也就是把后面的字符串拼接到前一个字符串的末尾# 得到了一个更大的字符串！（对于原来的a1,a2是没有影响的） a1 ='hello' a2 ='a1 + a2'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 =Trueprint(type(a)) b =Falseprint(type(b))

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

# 4.布尔# 布尔取值只有真和假,因此布尔类型主要用于逻辑判定# 这里注意一下大小写问题,Python里面的真(True)假(False),C++/Java可能是true/false(小写的)# 布尔值来源于"命题",真或者假 c1 =True c2 =Falseprint(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 =10print(type(a)) a:int=10print(type(a)) a ='hello'print(type(a)) a:str='hello'print(type(a)) a =Trueprint(type(a)) a:bool=Trueprint(type(a))

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

再比如这个——

a =10print(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 /3print(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 =10print(a) b =Trueprint(b)

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

示例：输出 num = 10。

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

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

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

# 基于控制台输出# 如何批量注释代母：# 1. 选中要注释的代码# 2.使用ctrl +/ (取消也一样) a =10print(a) b ='hello'print(b) c =Trueprint(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)/4print(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)/4print(f"平均数是 {avg}")

6 ~> 运算符

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

即——

6.1 算术运算符

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

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

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

print(10/0)

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

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

print(1/2)

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

print(7%2)

关于求余数，可能有些uu容易蒙——其实这个是我们小学二年级数学就学过的：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)*3print(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，这种就是根号2print(4**2)print(4**0.5)# //：地板除法(取整除法)，会针对计算的结果进行“向下取整”# 这个“向下取整”针对正数和负数，取整的方向不一样（本质都是向更小的取整）print(7//2)print(-7//2)

6.2 关系运算符

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

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

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

1、如果关系符合，则表达式返回 True；如果关系不符合，则表达式返回 False

a =10 b =20print(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.3print(-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 =30print(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>20and10/0==1)print(10<20or10/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 and10/0==1)# print(a < b and 10 / 0 == 1) # 报错：ZeroDivisionError: division by zeroprint(a < b or10/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 +1print(a) b =10 b +=1print(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基础语法的第一部分到前面的【总结】那里就已经结束了，这是自测小练习，uu们可以检验一下，看看前面的基础怎么样。

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. 已经强调过很多次了，字符串和数字不能相加

结尾

uu们，本文的内容到这里就全部结束了，艾莉丝再次感谢您的阅读！

结语：希望对学习Python相关内容的uu有所帮助，不要忘记给博主“一键四连”哦！

往期回顾：

【Python基础】认识Python：手把手教你搭建 Python 环境｜附计算机基础图解

🗡博主在这里放了一只小狗，大家看完了摸摸小狗放松一下吧！🗡૮₍ ˶ ˊ ᴥ ˋ˶₎ა