Python 入门通关：注释、变量、数据类型、运算符全覆盖

Python 入门通关：注释、变量、数据类型、运算符全覆盖

• 第 2 章 Python 基础
• • 2.1 代码格式
  • • 2.1.1 注释
    • • 1. 单行注释
      • 2. 多行注释
    • 2.1.2 缩进
    • 2.1.3 换行
  • 2.2 标识符和关键字
  • 2.3 变量
  • 2.4 数据类型
  • • 2.4.1 数字类型
    • • 1. 整型
      • 2. 浮点类型
      • 3. 复数类型
      • 4. 布尔类型
      • 5. 数字类型转换
    • 2.4.2 字符串
    • 2.4.3 列表
    • 2.4.4 元组
    • 2.4.5 集合
    • 2.4.6 字典
  • 2.5 输入和输出
  • • 2.5.1 input 函数
    • 2.5.2 print 函数
    • • 1. 输出单个内容
      • 2. 输出多个内容
      • 3. 自定义分隔符
      • 4. 自定义结尾符
      • 5. 格式化输出
      • 6. 输出到文件
      • 7. 抑制输出空格
      • 8. 常见易错点
  • 2.6 运算符
  • • 2.6.1 算术运算符
    • 2.6.2 赋值运算符
    • 2.6.3 比较运算符
    • 2.6.4 逻辑运算符
    • 2.6.5 成员运算符
    • 2.6.6 位运算符
    • 2.6.7 运算符优先级
  • 2.7 练习小节
  • • 2.7.1 打印购物票
    • 2.7.2 绝对温标
    • 2.7.3 身体质量指数
    • 2.7.4 房贷计算器
  • 2.8 本章总结

第 2 章 Python 基础

摘要：本章系统介绍了Python编程语言的基础知识，涵盖代码格式规范（注释、缩进、换行）、标识符与关键字命名规则、变量定义与数据类型（数字类型、字符串、列表、元组、集合、字典）、输入输出函数（input/print）以及各类运算符（算术、赋值、比较、逻辑、成员、位运算）的使用。通过多个课堂练习（购物票打印、温度转换、BMI计算、房贷计算器）巩固知识点，帮助初学者建立Python编程的基本概念和语法基础，为后续深入学习打下坚实基础。

2.1 代码格式

Python代码的格式是Python语法的组成之一，不符合格式规范的Python代码无法正常运行。

2.1.1 注释

1. 单行注释

以#开头，用于说明当前行或之后代码的功能。单行注释既可以单独占一行，也可以位于标识的代码之后，与标识的代码共占一行。

# 单行注释，打印 Hello，Python
print("Hello,Python") # 单行注释，打印 Hello，Python

为了确保注释的可读性，Python官方建议：

2. 多行注释

由三对双引号或三对单引号包裹的语句，主要用于说明函数或类的功能。因此多行注释也被称为说明文档。

'''
height = input("请输入您的身高（单位为米）：")
print("您的身高：",height)
weight = input("请输入您的体重（单位为公斤）：")
print("您的体重：",weight)

bmi = float(weight)/(float(height)*float(height))
print("您的BMI指数：",bmi)
if bmi < 18.5:
print("您的体重过轻！")
if bmi >= 18.5 and bmi <24.9:
print("正常范围，继续保持！")
if bmi >= 24.9 and bmi <29.9:
print("您体重过重！")
if bmi >= 29.9:
print("该减肥了！")
'''

2.1.2 缩进

Python代码的缩进可以通过Tab键控制，也可使用空格控制。空格是Python3首选的缩进方法，一般使用4个空格表示一级缩进；Python3 不允许混合使用Tab和空格。

示例如下

if True:
print ("True")
else:
print ("False")
print ("False")

代码缩进量的不同会导致代码语义的改变，Python语言要求同一级别代码块必须具有相同得缩进量。程序中不允许出现无意义或者不规范的缩进，否则运行时会产生错误。

示例如下

if True:
print ("True")
else:
print ("False")
print ("hello")

上面最后一行代码的缩进量不符合规范，程序在运行后会出现错误，具体如下：

File "F:\\PycharmProjects\\pythonProject1\\pycode\\mygame.py", line 5
print ("hello")
^
IndentationError: unindent does not match any outer indentation level

2.1.3 换行

Python官方建议每行代码不超过79个字符，若代码过长应该换行。Python使用圆括号、中括号和大括号进行多行字符串隐式连接，实现过长语句的换行显示。

string = ("Python是一种面向对象、解释型计算机程序设计语言，"
"由Guido van Rossum于1989年底发明。"
"第一个公开发行版发行于1991年，"
"Python源代码同样遵循GPL(GNU General Public License)协议。")
print(string)

**注意：**原本由圆括号、中括号和大括号包裹的语句在换行时不需要另外添加圆括号。

number = ["one","two",
"three","four"]
print(number)

2.2 标识符和关键字

在程序开发过程中，开发人员需要使用一些符号和名称表示一些事物，这些符号和名称叫做标识符。

Python中的标识符需要遵守以下命名规则：

Python 关键字是 Python 语言内置保留词，承担语法控制、逻辑、异常处理等核心语法功能，不允许开发人员重复定义。

Python3 中一共有 35 个关键字，每个关键字都有不同的作用。

获取关键字命令：

import keyword
print(keyword.kwlist)

执行结果如下：

['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

获取命令字声明（帮助信息）：

print(help("for"))

The "for" statement
*******************

The "for" statement is used to iterate over the elements of a sequence
(such as a string, tuple or list) or other iterable object:

for_stmt ::= "for" target_list "in" starred_list ":" suite
["else" ":" suite]

为了规范命名标识符，关于标识符的命名提以下建议：

2.3 变量

变量：用拉丁字母表示的、值不固定的数据。

程序在运行期间用到的数据会被保存在计算机的内存单元中，为了方便存取内存单元中的数据，Python使用标识符来标识不同的内存单元。标识内存单元的标识符又称为变量名，Python通过赋值运算符 = 将内存单元中存储的数值与变量名建立联系，即定义变量，具体语法格式如下：变量 = 值。

将内存单元中存储的数据 100 与变量名data建立联系，如下所示

date = 100

2.4 数据类型

根据数据存储形式的不同，数据类型分为：

• 基础的数字类型：分为整型、浮点型、布尔类型和复数类型；
• 比较复杂的组合类型：分为字符串、列表、元组、字典、集合等。

#mermaid-svg-MwYHHfBwE4amU107{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-MwYHHfBwE4amU107 .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-MwYHHfBwE4amU107 .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-MwYHHfBwE4amU107 .error-icon{fill:#552222;}#mermaid-svg-MwYHHfBwE4amU107 .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-MwYHHfBwE4amU107 .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-MwYHHfBwE4amU107 .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-MwYHHfBwE4amU107 .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-MwYHHfBwE4amU107 .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-MwYHHfBwE4amU107 .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-MwYHHfBwE4amU107 .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-MwYHHfBwE4amU107 .marker{fill:#333333;stroke:#333333;}#mermaid-svg-MwYHHfBwE4amU107 .marker.cross{stroke:#333333;}#mermaid-svg-MwYHHfBwE4amU107 svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-MwYHHfBwE4amU107 p{margin:0;}#mermaid-svg-MwYHHfBwE4amU107 .label{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;color:#333;}#mermaid-svg-MwYHHfBwE4amU107 .cluster-label text{fill:#333;}#mermaid-svg-MwYHHfBwE4amU107 .cluster-label span{color:#333;}#mermaid-svg-MwYHHfBwE4amU107 .cluster-label span p{background-color:transparent;}#mermaid-svg-MwYHHfBwE4amU107 .label text,#mermaid-svg-MwYHHfBwE4amU107 span{fill:#333;color:#333;}#mermaid-svg-MwYHHfBwE4amU107 .node rect,#mermaid-svg-MwYHHfBwE4amU107 .node circle,#mermaid-svg-MwYHHfBwE4amU107 .node ellipse,#mermaid-svg-MwYHHfBwE4amU107 .node polygon,#mermaid-svg-MwYHHfBwE4amU107 .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-MwYHHfBwE4amU107 .rough-node .label text,#mermaid-svg-MwYHHfBwE4amU107 .node .label text,#mermaid-svg-MwYHHfBwE4amU107 .image-shape .label,#mermaid-svg-MwYHHfBwE4amU107 .icon-shape .label{text-anchor:middle;}#mermaid-svg-MwYHHfBwE4amU107 .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-MwYHHfBwE4amU107 .rough-node .label,#mermaid-svg-MwYHHfBwE4amU107 .node .label,#mermaid-svg-MwYHHfBwE4amU107 .image-shape .label,#mermaid-svg-MwYHHfBwE4amU107 .icon-shape .label{text-align:center;}#mermaid-svg-MwYHHfBwE4amU107 .node.clickable{cursor:pointer;}#mermaid-svg-MwYHHfBwE4amU107 .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-MwYHHfBwE4amU107 .arrowheadPath{fill:#333333;}#mermaid-svg-MwYHHfBwE4amU107 .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-MwYHHfBwE4amU107 .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-MwYHHfBwE4amU107 .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-MwYHHfBwE4amU107 .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-MwYHHfBwE4amU107 .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-MwYHHfBwE4amU107 .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-MwYHHfBwE4amU107 .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-MwYHHfBwE4amU107 .cluster text{fill:#333;}#mermaid-svg-MwYHHfBwE4amU107 .cluster span{color:#333;}#mermaid-svg-MwYHHfBwE4amU107 div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-MwYHHfBwE4amU107 .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-MwYHHfBwE4amU107 rect.text{fill:none;stroke-width:0;}#mermaid-svg-MwYHHfBwE4amU107 .icon-shape,#mermaid-svg-MwYHHfBwE4amU107 .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-MwYHHfBwE4amU107 .icon-shape p,#mermaid-svg-MwYHHfBwE4amU107 .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-MwYHHfBwE4amU107 .icon-shape .label rect,#mermaid-svg-MwYHHfBwE4amU107 .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-MwYHHfBwE4amU107 .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-MwYHHfBwE4amU107 .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-MwYHHfBwE4amU107 :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}

数据类型

数字类型 numbers

字符串类型 str

列表类型 list

元组类型 tuple

集合类型 set

字典类型 dict

整型 int

浮点型 float

复数类型 complex

布尔类型 bool

2.4.1 数字类型

Python 内置的数字类型有整型（int）、浮点型（float）、复数类型（complex）和布尔类型(bool)。

1. 整型

整数类型（int）简称整型，它用于表示整数。整型常用的计数方式有4种，分别是：

• 二进制（以0B或0b开头），例如0b101。
• 八进制（以数字0o或0O开头），例如 0o5。
• 十进制，例如 5。
• 十六进制（以0x或0X开头），例如 0x5。

为了方便使用各进制的数据，Python中内置了用于转换数据进制的函数：

代码示例：

number = 10
bin_num = 0b1010
print("10 的二进制：",bin(number))
print("10 的八进制：",oct(number))
print("0b1010 的十进制",int(bin_num))
print("10 的十六进制",hex(number))

运行结果

10 的二进制： 0b1010
10 的八进制： 0o12
0b1010 的十进制 10
10 的十六进制 0xa

2. 浮点类型

**浮点型（float）用于表示实数，由整数和小数部分（可以是0）组成。**例如，3.14、0.9等。较大或较小的浮点数可以使用科学计算法表示。

Python 程序中使用字母 e 或 E 代表底数 10：

-3.14e2# 即-314
3.14e-3# 即0.00314

Python中浮点型数据占8个字节（即64位），且遵守IEEE标准。Python中浮点型的取值范围为 -1.8e308~1.8e308，若超出这个范围，Python会将值视为无穷大（inf）或无穷小（-inf）。

3. 复数类型

复数由实部和虚部构成，一般形式为：real+imagj：

示例如下：

complex_one = 1 + 2j# 实部为1，虚部为2
complex_two = 2j # 实部为0，虚部为2

代码示例

complex_num = 1+2j
print(complex_num.real)
print(complex_num.imag)

运行结果

1.0
2.0

4. 布尔类型

**布尔类型（bool）**是一种特殊的整型，其值 True 对应整数 1，False 对应整数 0。

以下值对应的布尔值全部是False。

None。
False。
任何数字类型的0，如0、0.0、0j。
任何空序列，如‘’‘’、()、[]。
空字典，如{}。

代码示例

print(bool(0))
print(bool(''))
print(bool(1))

运行结果

False
False
True

5. 数字类型转换

Python内置了一系列可实现强制类型转换的函数，使用这些函数可以将目标数据转换为指定的类型。数字类型间进行转换的函数有int()、float()、complex()。

注意：浮点型数据转换为整型数据后只保留整数部分。

代码示例

num_one=2
num_two=2.2
print(int(num_two))
print(float(num_one))
print(complex(num_one))

运行结果

2
2.0
(2+0j)

2.4.2 字符串

字符串是一个由单引号、双引号或者三引号包裹的、有序的字符集合。

• 使用单引号包含： 'Python123￥'
• 使用双引号包含： "Python3*&%"
• 使用三引号包含： '''Python s1 ~(())'''

2.4.3 列表

**列表是多个元素的集合，可以保存任意数量、任意类型的元素，且可以被修改。**Python中使用[]创建列表，列表中的元素以逗号分隔。

[1, 2, 'hello']

2.4.4 元组

元组与列表的作用相似，它可以保存任意数量与类型的元素，但**不可以被修改**。Python中使用()创建元组，元组中的元素以逗号分隔。

(1, 2, 'hello')

2.4.5 集合

集合与列表和元组类似，也可以保存任意数量、任意类型的元素，不同的是，集合使用{}创建，集合中的元素无序且唯一。

{'apple', 'orange', 1}

2.4.6 字典

字典中的元素是键（Key）：值（Value）形式的键值对，键不能重复。Python中使用{}创建字典，字典中的各元素以逗号分隔

{"name": "zhangsan", "age": 18}

可以使用 type() 查看数据类型

info = {"name": "zhangsan", "age": 18}
print(type(info))

<class 'dict'>

2.5 输入和输出

程序要实现人机交互功能，需能从输入设备接收用户输入的数据，也需要向输出设备输出显示数据。

2.5.1 input 函数

input() 函数用于接收用户键盘输入的数据，返回一个字符串类型的数据，其语法格式如下所示：

input([prompt])

prompt 表示函数的参数，用于设置接收用户输入时的提示信息。

number=input("请输入数字：")
print(type(number))

运行结果：

请输入数字：10
<class 'str'>

2.5.2 print 函数

print() 是 Python 内置函数，核心作用是将内容输出到控制台（屏幕），可以输出字符串、数字、变量、表达式结果等，是调试代码、展示结果最基础的工具。

其语法格式如下：

print(*objects, sep=' ', end='\\n', file=sys.stdout)

语法说明：

• objects：表示输出的对象。输出多个对象时，需要用**分隔符（逗号）**分隔。
• sep：用于设定分隔符，默认使用空格作为分隔。
• end：用于设定输出以什么结尾，默认值为换行符\\n。
• file：表示数据输出的文件对象。

1. 输出单个内容

直接在括号里写要输出的内容，支持字符串（需加引号）、数字、变量、表达式。

# 输出字符串（必须加单/双引号）
print("Hello Python")
# 结果：Hello Python

# 输出变量
name = "小明"
print(name)
# 结果：小明

# 输出数字（无需引号）
print(123)
# 结果：123

# 输出表达式结果（先计算，再输出）
print(10 + 20)
# 结果：30
print(6 / 2)
# 结果：3.0

2. 输出多个内容

多个内容用 , 分隔，输出时会自动用空格分隔各内容。

# 输出多个字符串
print("姓名：", "小明")
# 结果：姓名： 小明

# 输出字符串+变量+表达式
age = 18
print("年龄：", age, "明年：", age + 1)
# 结果：年龄： 18 明年： 19

3. 自定义分隔符

默认多个内容用空格分隔，通过 sep 参数可自定义分隔符（比如逗号、横线）。

# 用逗号分隔多个内容
print("2024", "02", "26", sep="-")
# 结果：2024-02-26

# 用空字符串分隔（无间隔）
print("Hello", "World", sep="")
# 结果：HelloWorld

# 用多个字符分隔
print("苹果", "香蕉", "橙子", sep=" | ")
# 结果：苹果 | 香蕉 | 橙子

4. 自定义结尾符

默认 print() 输出后会自动换行，通过 end 参数可自定义结尾（比如不换行、加符号）。

# 不换行输出（结尾为空字符串）
print("第一行内容", end="")
print("第二行内容跟在后面")
# 结果：第一行内容第二行内容跟在后面

# 结尾加指定符号
print("完成计算", end="！\\n\\n")
# 结果：完成计算！（后面多一个空行）
print("新的一行")

5. 格式化输出

输出变量/表达式时，需要控制格式（比如保留小数、对齐），常用 3 种方式：

# 示例：保留2位小数输出BMI
bmi = 21.2244
# f-string（最推荐）
print(f"您的BMI：{bmi:.2f}")
# 结果：您的BMI：21.22

# format()
print("您的BMI：{0:.2f}".format(bmi))
# 结果：您的BMI：21.22

# %格式化
print("您的BMI：%.2f" % bmi)
# 结果：您的BMI：21.22

6. 输出到文件

默认输出到控制台，可通过 file 参数将内容输出到文件中。

# 打开文件（mode="w" 表示写入，不存在则创建，存在则覆盖）
with open("output.txt", mode="w", encoding="utf-8") as f:
print("这是输出到文件的内容", file=f)
# 执行后会生成 output.txt 文件，内容为：这是输出到文件的内容

7. 抑制输出空格

# 输出1-5，用逗号分隔，无结尾换行
for i in range(1, 6):
print(i, end="," if i < 5 else "")
# 结果：1,2,3,4,5
# range(1, 6)范围是1-5

8. 常见易错点

1. 字符串忘记加引号：

print(Hello) # 报错（Hello是变量，未定义）
print("Hello") # 正确

2.多个内容分隔符混淆：

用 , 分隔多个内容时，print 自动加空格；想无空格直接拼接，需用 +（仅字符串可用）：

print("姓名：" + "小明")
# 结果：姓名：小明（无空格）

print("姓名：", "小明")
# 结果：姓名： 小明（有空格）

3.数值和字符串拼接报错：

不能直接用 + 拼接数字和字符串，需先转字符串：

age = 18
# print("年龄：" + age) # 报错
print("年龄：" + str(age)) # 正确：年龄：18

2.6 运算符

Python 运算符主要用于实现数值之间的运算。

• 根据操作数数量的不同，运算符可分为：单目运算符、双目运算符；
• 根据运算符的功能，运算符可分为：算术运算符、赋值运算符、比较运算符、逻辑运算符和成员运算符。

2.6.1 算术运算符

Python中的算术运算符参考如下表格，以操作数a = 2，b = 8为例对算术运算符进行使用说明。

Python中的算术运算符既支持对相同类型的数值进行运算，也支持对不同类型的数值进行混合运算。在混合运算时，Python会强制将数值的类型进行临时类型转换，这些转换遵循如下原则：

代码示例

print(10/2.0)
print(10–(3+5j))

运行结果

5.0
(7-5j)

2.6.2 赋值运算符

赋值运算符的作用是将一个表达式或对象赋值给一个左值。左值是指一个能位于赋值运算符左边的表达式，它通常是一个可修改的变量，不能是一个常量。

例如将整数 3 赋值给变量 num。

num = 3

赋值运算符允许同时为多个变量赋值。

# 变量x、y、z均赋值为1
x = y = z = 1

# 变量a赋值为1，变量b赋值为2
a, b = 1, 2

Python中的算术运算符可以与赋值运算符组成复合赋值运算符，赋值运算符同时具备运算和赋值两项功能。

以变量num为例：

这类运算符是 Python 中简化代码的常用语法：

Python3.8 中新增了一个赋值运算符——**海象运算符:=，**该运算符用于在表达式内部为变量赋值，因形似海象的眼睛和长牙而得此命名。

num_one = 1
# 使用海象运算符为num_two赋值
result = num_one + (num_two := 2)
print(result)
print(num_two)

运行结果：

3
2

2.6.3 比较运算符

比较运算符也叫关系运算符，用于比较两个数值，判断它们之间的关系。Python中的比较运算符包括==、!=、>、<、>=、<=，它们通常用于判断两个值的关系，测试的结果只能是True或False。

以变量x=2，y=3为例：

这类运算符常用于条件判断（如 if 语句、循环控制），是逻辑流程控制的基础。

注意：

• == 是值比较，而 Python 中 is 是内存地址比较，二者不可混淆。
• == 和 != 也可用于字符串是否相等和不等。
• 比较运算符的结果可直接参与逻辑运算（如 (x>y) and (x<z)）。

2.6.4 逻辑运算符

Python中分别使用or，and，not这三个关键字作为逻辑运算符。其中or与and为双目运算符，not为单目运算符。

以x=10，y=20为例，具体如下：

2.6.5 成员运算符

成员运算符 in 和 not in 用于测试给定数据是否存在于序列（如列表、字符串）中，关于它们的介绍如下：

• in：如果指定元素在序列中返回 True，否则返回 False。
• not in：如果指定元素不在序列中返回 True，否则返回 False。

代码示例

x = "Python"
y = 't'
print(y in x)
print(y not in x)

运行结果

True
False

2.6.6 位运算符

位运算符用于按二进制位进行逻辑运算，操作数必须为整数。通常用于底层开发、性能优化等场景。

以a=2，b=3为例进行演示，具体如下：

• 按位左移(<<)是指将二进制形式操作数的所有位全部左移n位，高位丢弃，低位补0。

  以十进制9为例，9转为二进制后是00001001，将转换后的二进制数左移4位。

  # 原： 0000 1001
  # 低位补0，高位删除
  # 新：0000 1001 0000

• 按位右移(>>)是指将二进制形式操作数的所有位全部右移n位，低位丢弃，高位补0。

  以十进制8为例，8转换为二进制后是00001000，将转换后的二进制数右移2位。

  # 原：0000 1000
  # 高位补0，低位删除
  # 新：0000 0010

• 按位与(&)是指将参与运算的两个操作数对应的二进制位进行与操作。**当对应的两个二进制位均为1时，结果位就为1，否则为0。**以十进制9和3为例，9和3转换为二进制后分别是00001001和00000011。

• 按位或(|)是指将参与运算的两个操作数对应的二进制位进行或操作。**若对应的两个二进制位有一个为1时，结果位就为1。**若参与运算的数值为负数，参与运算的两个数均以补码出现。以十进制8和3为例，8和3转换为二进制后分别是00001000和00000011。

• 按位异或(^)是指将参与运算的两个操作数对应的二进制位进行异或操作。**当对应的两个二进制位中有一个为1，另一个为0时，结果位为1，否则结果位为0。**以十进制8和4为例，8和4转换为二进制后分别是00001000和00000100。

• **按位取反(~)是指将二进制的每一位进行取反，0取反为1，1取反为0。**按位取反操作首先会获取这个数的补码，然后对补码进行取反，最后将取反结果转换为原码。

  例如，对9按位取反的计算过程如下：

  

2.6.7 运算符优先级

Python支持使用多个不同的运算符连接简单表达式，实现相对复杂的功能，为了避免含有多个运算符的表达式出现歧义，Python为每种运算符都设定了优先级。

Python中运算符的优先级从高到低如下：

• 如果表达式中的运算符优先级相同，按从左向右的顺序执行。
• 如果表达式中包含小括号，那么解释器会先执行小括号中的子表达式。

代码示例：

a = 20
b = 2
c = 15
result_01 = (a–b)+c
result_02 = a/b%c
result_03 = c**b*a
print(result_01,result_02,result_03)

运行结果

33 10.0 4500

2.7 练习小节

2.7.1 打印购物票

购物小票又称购物收据，是指消费者购买商品时由商场或其它商业机构给用户留存的销售凭据。购物小票中一般会包含用户购买的商品名称、数量、单价以及总金额等信息。本实例要求编写代码，实现打印购物小票的功能。

# 定义购物小票基础信息
order_id = "DH201409230001"
time = "2014-09-23 08:56:14"

# 定义每个商品的信息（单独变量，不用列表）
# 商品1：金士顿U盘8G
name1 = "金士顿U盘8G"
count1 = 1
price1 = 40.00
amount1 = count1 * price1 # 计算商品1金额

# 商品2：胜创16GIP卡
name2 = "胜创16GIP卡"
count2 = 1
price2 = 50.00
amount2 = count2 * price2 # 计算商品2金额

# 商品3：读卡器
name3 = "读卡器"
count3 = 1
price3 = 8.00
amount3 = count3 * price3 # 计算商品3金额

# 商品4：网线2米
name4 = "网线2米"
count4 = 1
price4 = 5.00
amount4 = count4 * price4 # 计算商品4金额

# 计算总数和总额（手动累加，不用sum）
total_count = count1 + count2 + count3 + count4
total_amount = amount1 + amount2 + amount3 + amount4

# 逐行打印小票（只用基础print，无对齐控制）
print("==============================")
print("单号:", order_id)
print("时间:", time)
print("——————————")
print("名称 数量 单价 金额")
print(name1, " ", count1, " ", price1, " ", amount1)
print(name2, "", count2, " ", price2, " ", amount2)
print(name3, " ", count3, " ", price3, " ", amount3)
print(name4, " ", count4, " ", price4, " ", amount4)
print("——————————")
print("总数:", total_count, " 总额:", total_amount)
print("折后总额:", total_amount)
print("实收:", total_amount, " 找零:0.00")
print("收银:管理员")
print("==============================")

高级版

# 定义购物小票信息
order_id = "DH201409230001"
time = "2014-09-23 08:56:14"

# 商品列表：每个元素是(名称, 数量, 单价)
products = [
("金士顿U盘8G", 1, 40.00),
("胜创16GIP卡", 1, 50.00),
("读卡器", 1, 8.00),
("网线2米", 1, 5.00)
]

# 计算总数和总额
total_count = sum(p[1] for p in products)
total_amount = sum(p[1] * p[2] for p in products)

# 打印小票
print("=" * 30)
print(f"单号: {order_id}")
print(f"时间: {time}")
print("-" * 30)

# 表头
print(f"{'名称':<10} {'数量':<4} {'单价':<6} {'金额':<6}")

# 商品行（金额=数量*单价）
for name, count, price in products:
amount = count * price
print(f"{name:<10} {count:<4} {price:<6.2f} {amount:<6.2f}")
print("-" * 30)

# 统计信息
print(f"总数:{total_count:<10} 总额:{total_amount:.2f}")
print(f"折后总额:{total_amount:.2f}")
print(f"实收:{total_amount:.2f} 找零:0.00")
print(f"收银:管理员")
print("=" * 30)

2.7.2 绝对温标

绝对温标又称开氏温标、热力学温标，是热力学和统计物理中的重要参数之一，也是国际单位制七个基本物理量之一。绝对温标的单位为开尔文（简称开，符号为K），绝对温标的零度对应我们日常使用的摄氏温度（单位为摄氏度，简称度，符号为℃）的**-273.15℃**。

本实例要求编写代码，实现将用户输入的摄氏温度转换为移绝对温标标识的开氏温度的功能。

参考答案1：

# 获取用户输入的摄氏温度（注意转换为浮点型）
celsius = float(input("请输入摄氏温度："))

# 计算开氏温度（公式：开氏温度 = 摄氏温度 + 273.15）
kelvin = celsius + 273.15

# 输出结果
print("对应的开氏温度为：", kelvin)

参考答案2：

# 获取用户输入的摄氏温度（注意转换为浮点型）
celsius = float(input("请输入摄氏温度："))

# 计算开氏温度（公式：开氏温度 = 摄氏温度 + 273.15）
kelvin = celsius + 273.15

# 输出结果
print("对应的开氏温度为：" + str(kelvin) + "K" )

2.7.3 身体质量指数

BMI指数即身体健康指数，它与人的体重和身高相关，是目前国际常用的衡量人体胖瘦程度以及是否健康的一个标准。已知BMI值的计算公式：体质指数（BMI）= 体重（kg）÷ 身高^2（m）

本实例要求编写代码，实现根据用户输入的身高、体重计算BMI指数的功能。

参考答案：

# 获取用户输入的身高（单位：米），转换为浮点型
height = float(input("请输入您的身高（单位：米）："))

# 获取用户输入的体重（单位：千克），转换为浮点型
weight = float(input("请输入您的体重（单位：千克）："))

# 计算BMI指数：体重 ÷ （身高的平方）
bmi = weight / (height ** 2)

# 格式化输出结果，保留2位小数
print(f"您的BMI指数为：{bmi:.2f}")

2.7.4 房贷计算器

按用户选择的贷款类型（商业贷款、公积金贷款、组合贷款）、贷款金额（万）、期限（年）、利率（%）可计算得出每月月供参考（元）、支付利息（元）、还款总额（元）这些信息。

房贷计算公式如下：

• 月利率 = 年利率 ÷ 12 ÷ 100（把年利率 % 转为月利率小数）
• 还款总月数 = 贷款年限 × 12
• 月供 = 贷款本金 × 月利率 × (1 + 月利率)^ 总月数 ÷ [(1 + 月利率)^ 总月数 – 1]
• 还款总额 = 月供 × 总月数
• 利息总额 = 还款总额 – 贷款本金

不同贷款类型的利率是不同的：

• 对于商业贷款而言，五年以下（含五年）的贷款利率是4.75%，五年以上的贷款利率是4.90%；
• 对于公积金贷款利率而言，五年以下（含五年）的贷款利率是2.75%，五年以上的利率是3.25%。

本案例要求编写程序，根据以上计算方式开发一个房贷计算器。

参考代码：

# 房贷计算器（等额本息）- 无输入验证，仅核心计算
print("===== 房贷计算器（等额本息）=====\\n")

# 1. 直接获取用户输入（不验证，默认输入为有效数字）
loan_total_wan = float(input("请输入贷款总额（单位：万元）："))
loan_years = int(input("请输入贷款年限（如20表示20年）："))
loan_rate_year = float(input("请输入年利率（如4.25表示4.25%）："))

# 2. 单位转换与核心参数计算
loan_total_yuan = loan_total_wan * 10000 # 万元转元
month_count = loan_years * 12 # 还款总月数
rate_month = loan_rate_year / 12 / 100 # 月利率（转为小数）

# 3. 计算月供（等额本息核心公式）
monthly_payment = (loan_total_yuan * rate_month * (1 + rate_month)**month_count) / \\
((1 + rate_month)**month_count – 1)

# 4. 计算还款总额、利息总额
total_payment = monthly_payment * month_count # 还款总额
interest_total = total_payment – loan_total_yuan # 利息总额

# 5. 格式化输出结果
print("\\n===== 还款明细 ======")
print(f"贷款总额：{loan_total_wan:.2f} 万元（{loan_total_yuan:,.2f} 元）")
print(f"贷款年限：{loan_years} 年（共 {month_count} 个月）")
print(f"年利率：{loan_rate_year:.2f}%（月利率：{rate_month:.4f}）")
print("-" * 20)
print(f"每月月供：{monthly_payment:,.2f} 元")
print(f"还款总额：{total_payment:,.2f} 元（{total_payment/10000:.2f} 万元）")
print(f"利息总额：{interest_total:,.2f} 元（{interest_total/10000:.2f} 万元）")

以上代码对输入的数字不进行校验，如需校验，参考以下代码：

# 房贷计算器（等额本息还款法）
print("===== 房贷计算器（等额本息）=====\\n")

# 1. 获取并验证用户输入（确保输入为有效数字）
while True:
try:
# 贷款总额（万元）→ 转换为元（避免小数计算误差）
loan_total_wan = float(input("请输入贷款总额（单位：万元）："))
loan_total_yuan = loan_total_wan * 10000
# 贷款年限
loan_years = int(input("请输入贷款年限（如20表示20年）："))
# 年利率（%）
loan_rate_year = float(input("请输入年利率（如4.25表示4.25%）："))
break # 输入合法则退出循环
except ValueError:
print("输入错误！请输入数字（如100、20、4.25），重新输入。\\n")

# 2. 计算核心参数
month_count = loan_years * 12 # 还款总月数
rate_month = loan_rate_year / 12 / 100 # 月利率（转为小数）

# 3. 计算月供（处理月利率为0的特殊情况，如无息贷款）
if rate_month == 0:
monthly_payment = loan_total_yuan / month_count # 无息则月供=本金均分
else:
# 等额本息核心公式
monthly_payment = (loan_total_yuan * rate_month * (1 + rate_month)**month_count) / \\
((1 + rate_month)**month_count – 1)

# 4. 计算还款总额、利息总额
total_payment = monthly_payment * month_count # 还款总额
interest_total = total_payment – loan_total_yuan # 利息总额

# 5. 格式化输出结果（保留2位小数，更符合金融场景）
print("\\n===== 还款明细 ======")
print(f"贷款总额：{loan_total_wan:.2f} 万元（{loan_total_yuan:,.2f} 元）")
print(f"贷款年限：{loan_years} 年（共 {month_count} 个月）")
print(f"年利率：{loan_rate_year:.2f}%（月利率：{rate_month:.4f}）")
print("-" * 20)
print(f"每月月供：{monthly_payment:,.2f} 元")
print(f"还款总额：{total_payment:,.2f} 元（{total_payment/10000:.2f} 万元）")
print(f"利息总额：{interest_total:,.2f} 元（{interest_total/10000:.2f} 万元）")

2.8 本章总结

本章主要介绍了Python基础知识，包括代码格式、标识符和关键字、变量和数据类型、数字类型以及运算符。

本章比较简单易学，希望大家在初学Python时，结合实训案例对该部分内容多加练习，为后期深入学习Python打好基础。