1. Python简介

Python是脚本语言

  • 无需编译，直接解释执行 Python 代码通常以 .py 文件形式保存，运行时由解释器逐行执行（如 CPython），无需像 C++ 或 Java 那样预先编译， 这种写完后直接运行的特性是脚本语言的典型标志（类似 Perl、Bash）
  • 动态类型与快速开发 Python 在运行时动态确定变量类型，支持快速编写和测试代码，适合自动化任务、数据处理或原型开发
  • 胶水语言特性 Python 常被用于调用其他语言（如 C/C++）的库或系统命令，整合不同工具（如 Shell 脚本的功能），适合系统管理或自动化任务

Python是高级编程语言

  • 高度抽象，接近自然语言 Python 的语法设计简洁，隐藏了底层细节（如内存管理），开发者无需关心指针或硬件操作
  • 支持复杂编程范式 Python 支持面向对象编程（类、继承）、函数式编程（lambda、map/reduce）和模块化设计，适合构建大型应用（如 Django Web 框架、科学计算库 NumPy）
  • 丰富的标准库和生态 Python 提供了涵盖网络、文件处理、并发等功能的模块，以及数十万第三方库（如 Pandas、TensorFlow），满足企业级开发需求

无论什么编程语言，计算机的中央处理器（CPU）只能理解机器指令，因此不同编程语言的代码最终都需要被“翻译”成CPU可执行的机器指令。不同编程语言在完成相同任务时所需的代码量差异巨大。比如，完成同一个任务，C语言需要1000行代码，Java需要100行，而Python可能只需20行，Python语言的语法非常简洁。

然而，Python 并不适合所有的任务。由于其解释性质和动态类型，和 C程序相比会比较慢，因为 Python 是解释型语言，你的代码在执行时会一行一行地翻译成CPU能理解的机器码，而C程序是运行前直接编译成CPU能执行的机器码，因此在对性能要求非常高的应用中，如操作系统或3D游戏引擎的开发，更适合选择其他语言。

Python的特点：

  • 具有简洁的语法；
  • 跨平台，可以在多种操作系统上运行，包括Linux、Windows、Mac等，也可以集成到嵌入式设备中；
  • 拥有广泛而强大的库和工具生态系统，包括串口通信、网络通信、数据处理、图像处理等。这些库和工具可以极大地简化嵌入式和集成电路开发过程，加快开发速度。更方便的是能直接部署ROS这样的机器人操作系统；
  • Python提供了多种与硬件集成的方式，例如通过串口通信、GPIO控制、SPI、I2C等接口。开发者可以使用Python与嵌入式设备进行通信和控制，实现与外部传感器、执行器等硬件的交互；
  • Python拥有众多优秀的数据分析和可视化库，例如NumPy、Pandas、Matplotlib等，可以帮助开发者处理和分析采集到的数据，并进行可视化展示。

Python的应用场景：

  • 数据科学和机器学习：Python在数据科学和机器学习领域中具有强大的生态系统。库如NumPy、Pandas和Scikit-learn提供了强大的数据处理和分析功能，同时机器学习框架如TensorFlow和PyTorch使得构建和训练机器学习模型变得更加容易。
  • Web开发：可以拿来做网站后台服务，例如Flask、Django
  • 自动化和脚本编程：它可以用于编写脚本来自动执行各种任务，如文件处理、数据处理、系统管理等
  • 网络爬虫：Python在网络爬虫和数据抓取方面非常强大，库如Beautiful Soup和Scrapy提供了强大的工具和功能，用于抓取和解析网页内容
  • 跨平台客户端：通过PyQT等跨平台界面开发框架，开发风格统一的PC端工控软件

2. 环境配置

2.1 Python解释器安装

在这里插入图片描述

安装Python解释器（默认安装）

在这里插入图片描述

安装Python解释器（自定义安装）
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

验证是否安装成功，命令行输入如下命令查看 python版本号：

C:\Users\Administrator> python -V
C:\Users\Administrator> where python

注意：Windows7请安装3.8.10及之前的版本：Python Release Python 3.8.10

python官方教程：
https://docs.python.org/zh-cn/3/tutorial/

python标准库：
https://docs.python.org/zh-cn/3.9/library/index.html

python各版本对比：
https://docs.python.org/zh-cn/3.9/

  • Linux：使用包管理器安装：
sudo apt update
sudo apt install python3

2.2 Python解释器的使用

  • 命令行直接执行
width = 20
height = 5 * 9
width * height

print('Hello World!')
print('C:\some\name')  # 这里 \n 表示换行符！
print(r'C:\some\name')  # 请注意引号前的 r
#如果不希望前置 \ 的字符转义成特殊字符，可以使用原始字符串，在引号前添加 r 即可：
  • 代码文件执行

创建测试 .py 文件，输入如下内容：

print('Hello World!')

在文件所在目录空白处，按住Shift+鼠标右键，点 在此处打开Powershell窗口 或者直接在 命令行：

python 测试.py

2.3. PyCharm配置

2.3.1. 下载并安装 PyCharm

  • 下载地址：JetBrains 官网
  • 社区版（Community）：免费，适合基础开发。
  • 专业版（Professional）：付费（学生可申请免费许可证），支持 Web 开发、数据库工具功能。

2.3.2. 安装PyCharm

  • Windows:
    • 双击下载的 .exe 文件
    • 选择安装路径
    • 勾选 Add launchers dir to the PATH（可选，方便命令行启动）
    • 勾选 .py 文件关联（推荐）
    • 完成安装后启动 PyCharm
  • Linux:
    • 解压下载的 .tar.gz 文件。
    • 进入 bin 目录，运行 pycharm.sh 启动。
    • 或使用 Snap 安装：
  sudo snap install pycharm-community --classic

2.3.3. 在 PyCharm 中配置解释器

  1. 点击 New Project
  2. 在 Location 处设置项目路径
  3. 在 Python Interpreter 部分：
    • 选择 New environment（推荐使用虚拟环境，如 venv 或 Conda）
    • 指定 Python 解释器路径（默认自动检测已安装的 Python）
  4. 点击 Create 完成项目初始化

2.3.4. 创建并配置项目

新建项目

  • 通过菜单栏 File → New Project 创建新项目
  • 选择项目模板（如纯 Python、Django、Flask 等）

项目结构

  • 右键项目根目录 → New → Python Package 或 Directory 创建代码目录（如 src）
  • 右键目录 → New → Python File 创建 .py 文件

2.3.5. 安装第三方库

  • 通过 PyCharm 界面：
    • 打开 File → Settings → Project: <项目名> → Python Interpreter
    • 点击 + 搜索并安装库（如 numpy、pandas）
  • 通过终端：
    • 在 PyCharm 底部打开 Terminal，使用 pip 安装：
pip install package-name

2.3.6. 调试与运行配置

  1. 运行脚本：
    • 右键代码文件 → Run '<文件名>'
    • 或点击右上角的运行按钮（需提前配置）
  2. 调试模式：
    • 设置断点：点击代码行号左侧
    • 右键文件 → Debug '<文件名>'，进入调试界面查看变量和堆栈

2.3.7. 插件扩展

  1. 打开 File → Settings → Plugins
  2. 搜索并安装：
    • Database Tools：数据库支持
    • GitToolBox：增强版 Git 集成
    • Markdown：编辑 Markdown 文件
    • Material Theme UI：主题美化

2.3.8. 其他设置

  • 界面主题：File → Settings → Appearance & Behavior → Theme
  • 代码风格：File → Settings → Editor → Code Style（如缩进、换行符）
  • 版本控制：File → Settings → Version Control 配置 Git、GitHub 等

2.4. VS Code配置

2.4.1. 下载VSCode

在这里插入图片描述

VSCode官方首页：https://code.visualstudio.com/ 点击 Download for Windows 下载

2.4.1. 安装VSCode

在这里插入图片描述

2.4.3. 安装插件

  • Python python语言支持
  • Python Extension Pack 集成分析、高亮、规范等的插件包，主要包含
    • Python 开发环境支持
    • autoDocstring 文档注释生成
    • Python Indent 缩进辅助
    • IntelliCode 智能提示助手
    • Python Environment Manager 环境管理器
  • PYQT Integration PyQt开发辅助插件
  • Black Formatter Python格式化工具
  • Code Runner通用方便的代码运行工具
  • Chinese (Simplified) 简体中文插件(建议要装)
  • Path Intellisense 路径智能补全
  • Arepl 实时估算代码中的变量值
  • Image preview 实时预览引用的图片
  • GitHub Theme 主题，比原生的漂亮
  • TONGYI Lingma ai编程插件，智能提示代码，登陆完才能使用
  • Jupyter Notebook 安装Jupyter Notebook插件
  • Fitten Code

2.4.4. 配置VSCode

  • 勾选 Run in Terminal
    在这里插入图片描述

  • 在文件目录运行代码
    Ctrl+, 打开设置（确保已安装Python插件），搜索 execute，勾选 Execute in File Dir
    在这里插入图片描述

  • 自动猜测编码
    打开设置 Ctrl + ,
    勾选 Auto Guess Encoding
    在这里插入图片描述

  • 设置新建文件编码
    打开设置 Ctrl + ,
    搜索 Encoding
    选择 Files: Encoding 为 UTF-8
    在这里插入图片描述

  • 修改字号字体
    搜索：Editor: font
    打开设置 Ctrl + , 修改Font Size为16，修改字体为 consolas, '微软雅黑', monospace
    在这里插入图片描述

  • 文件自动保存
    文件 -> 勾选 Auto Save
    在这里插入图片描述

● 修改文档注释格式
安装插件 autodocstring
打开插件 autodocstring 设置，将 Docstring Format 选项修改为 sphinx-notypes
在这里插入图片描述

2.5. Jupyter Notebook

2.5.1. 安装Jupyter

会安装 Jupyter 的完整套件，包括 Jupyter Notebook、JupyterLab、Jupyter Console #等组件。适合需要完整 Jupyter 生态系统的用户

pip install jupyter

仅安装 Jupyter Notebook，不包含 JupyterLab 等其他组件。
适合只需要 Jupyter Notebook 的用户

pip install notebook

2.5.2. 创建Jupyter Notebook

在这里插入图片描述

按 Ctrl+Shift+P，输入 “Jupyter: Create New Blank Notebook” ，选择 Python 环境后创建新 Notebook

2.5.3. 配置Python环境

在 Notebook 右上角选择 Python解释器，确保使用正确的环境。

2.5.4. 编写和运行代码

在单元格中输入代码，按 Shift+Enter 运行

2.5.5. 保存Notebook

按Ctrl+S保存为 .ipynb 文件

3. 基础语法

3.1. 程序注释

  • 单行注释
# 下面代码是给男神打招呼
print('hello python!')
  • 多行注释
"""
多行注释以"""开头，"""结尾（或以'''开头,'''结尾）
"""
print('hello python!')
print('hello world!')

3.2. 变量与数据类型（int/float/str/bool）

3.2.1. python基本数据类型

数据类型 描述 举例
int 整型 1、-5、100
float 浮点型(小数) 3.14、-0.5、1.0
bool(True 1 False 0) 布尔型 True、False
complex 复数型 1+2j、-3+4j

3.2.2. python高级数据类型

数据类型 描述 举例
str 字符串 “Hello”
list 列表 [1, 2, ‘a’, True]
tuple 元组 (1, 2, ‘a’, True)
set 集合 {1, 2, 3, 4}
dict 字典 {‘name’: ‘John’, ‘age’: 25, ‘city’: ‘BJ’}
None NoneType None 是 NoneType 类型的唯一值

3.2.3. 变量定义

变量名 = 变量值

# 定义整型变量
age = 50
# 定义浮点类型变量
score = 70.8
# 定义布尔类型变量
b = True
# 定义字符串类型变量
name = 'python'

可以通过 type() 函数获取变量类型

name = 'python'
# 获取变量类型
t = type(name)

Python 是动态类型语言，变量类型可以通过赋值进行修改

# 定义整型变量
age = 30
# 修改成浮点类型变量
age = 70.5

3.2.4. 变量的命名规则

  1. 只能由字母、数字、_(下划线)组成
  2. 不能以数字开头
  3. 不能是关键字
  4. 区分大小写

3.2.5. python 中的关键字

'False', 'None', 'True', '__peg_parser__', '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'
可以通过以下代码获取：(不用记忆学完就熟悉了)

import keyword
# 查看所有关键字列表
print(keyword.kwlist)
# 检查某个字符串是否是关键字
print(keyword.iskeyword("if"))  # 输出 True

3.2.6. 非法命名变量

a-b = "aaa"
itcast.cn = 'python'
123abc = "haha"
for = 123

3.2.7. 变量的命名规范

  1. 下划线命名法
student_name = '张三'
  1. 驼峰命名法
# 大驼峰命名法
StudentName = '张三'
# 小驼峰命名法
studentName = '李四'

3.3. 输入输出（input/print格式化输出）

3.3.1. 输出函数

3.3.1.1. 输出字符串
print("Hello, World!")
3.3.1.2. 输出变量
name = "Alice"
print(name)
3.3.1.3. 输出多个值
age = 25
print("Name:", name, "Age:", age)
3.3.1.4. 格式化输出
#使用 f-string（Python 3.6 及以上版本）
print(f"Name: {name}, Age: {age}")

#使用 format() 方法
print("Name: {}, Age: {}".format(name, age))

#使用%占位符
#%d 是用于格式化整数的占位符
# 定义两个整数
year = 2023
month = 10
# 使用 %d 格式化多个整数
print("当前日期是 %d 年 %d 月" % (year, month))

#不能用%d格式化浮点数
# 错误示例
price = 19.99
print("价格是 %d 元" % price)  # 这会抛出 TypeError

#%f 格式话浮点数
# 正确示例
price = 19.99
print("价格是 %.2f 元" % price)  # 使用 %f 格式化浮点数

name = "Alice"
age = 25
score = 95.5

# 只能用 f-string 的情况：
print(f"{name.upper()} 明年将 {age + 1} 岁，成绩是 {score:.1f} 分")
# 输出：ALICE 明年将 26 岁，成绩是 95.5 分

# 第一种方法无法直接实现（会报错）：
print(name.upper(), "明年将", age + 1, "岁，成绩是", score:.1f, "分")  # 语法错误！
3.3.1.5. 控制输出格式
#使用 sep 和 end 参数来控制输出的分隔符和结束符
#sep=", "：sep 参数指定了多个输出项之间的分隔符。默认情况下，sep 是一个空格（" "），但这里设置为 ", "，所以 "Hello" 和 "World" 之间会用 , 分隔。
#end="!\n"：end 参数指定了输出结束时的字符。默认情况下，end 是换行符（"\n"），但这里设置为 "!\n"，表示输出结束后会添加一个 ! 和一个换行符。
print("Hello", "World", sep=", ", end="!\n")
3.3.1.6. 输出特殊字符
print("This is a new line.\nThis is a tab\tcharacter.")
3.3.1.7. 输出原始字符串（忽略转义字符）
print(r"This is a raw string.\nNo new line here.")
print("This is a raw string.\\nNo new line here.")
3.3.2. 输入函数
input 输入的数据都为 `str` 字符串类型
可以使用 `int()` 将输入的数据转换成 `int` 类型

# 输入年纪
age = input('请输入年纪')
# 获取age类型
t = type(age)
print(t)

使用jupyter如果没有输入框：
从官网下载 Node.js（建议 LTS 版本），安装时勾选 npm 和 添加到 PATH
node --version  # 应输出版本号（如 v18.x）
npm --version   # 应输出版本号（如 9.x）
jupyter labextension install @jupyter-widgets/jupyterlab-manager

# 输入苹果的价格（元/斤）
price = float(input("请输入苹果的价格（元/斤）: "))

# 输入用户购买苹果的重量（斤）
weight = float(input("请输入购买苹果的重量（斤）: "))

# 计算付款金额
total_cost = price * weight

# 输出付款金额
print(f"付款金额: {total_cost}元")

'''
需求:
●  在控制台依次提示用户输入：姓名name、公司com、职位title、电话telephone、邮箱email
●  按照以下格式输出：
'''
# 提示用户输入信息
name = input("请输入姓名: ")
com = input("请输入公司: ")
title = input("请输入职位: ")
telephone = input("请输入电话: ")
email = input("请输入邮箱: ")

# 按照指定格式输出信息
print("\n输出结果：")
print(f"姓名: {name}")
print(f"公司: {com}")
print(f"职位: {title}")
print(f"电话: {telephone}")
print(f"邮箱: {email}")

     ## 3.4. 运算符与表达式

3.4.1. 数值之间

数值型变量之间可以直接计算
数值之间的操作用到的运算如如下：
运算符 描述
+ 加
- 减
* 乘
/ 除
// 取整除
% 取余数
** 幂 
# 算术运算符示例
a = 20
b = 3

# 1. 加法 (+)
print("a + b =", a + b)  # 输出: 23

# 2. 减法 (-)
print("a - b =", a - b)  # 输出: 17

# 3. 乘法 (*)
print("a * b =", a * b)  # 输出: 60

# 4. 除法 (/)，结果为浮点数
print("a / b =", a / b)  # 输出: 6.666666666666667

# 5. 取模 (%)，返回余数
print("a % b =", a % b)  # 输出: 2 (因为 20 = 3*6 + 2)

# 6. 幂运算 (**)
print("a ** b =", a ** b)  # 输出: 8000 (20 的 3 次方)

# 7. 整除 (//)，向下取整
print("a // b =", a // b)  # 输出: 6 (20 ÷ 3 = 6.666→取整数部分)

# 进阶示例
x = -10
y = 3

# 负数整除（向负无穷方向取整）
print("x // y =", x // y)  # 输出: -4 (-10 ÷ 3 = -3.333→向下取整为-4)

# 负数取模（余数符号与除数一致）
print("x % y =", x % y)    # 输出: 2 (因为 -10 = 3*(-4) + 2)

# 运算优先级示例
result = 10 + 2 * 3  # 先乘后加
print("10 + 2 * 3 =", result)  # 输出: 16

result = (10 + 2) * 3  # 括号优先
print("(10 + 2) * 3 =", result)  # 输出: 36

3.4.2. 字符串之间

字符串之间使用+拼接字符串

str1 = 'hello'
str2 = 'world'
str3 = str1 + str2
print(str3)

3.4.3. 整形和字符串

字符串变量和整型使用*，用于重复拼接相同的字符串

str = 'hello'
s = str*5
print(s)

数值变量和字符串不能进行其它计算

str = 'hello'
a = 10
# 错误,字符串和数字不能直接相加
result = str+a
print(result)

3.4.4. 其他常见运算符

3.4.4.1. 赋值运算符

Python 没有 i++, ++i 这样的表达式

运算符 描述
= 赋值
+= 加等于
-= 减等于
*= 乘等于
/= 除等于
//= 整除等于
%= 模等于
**= 幂等于 
a = 10
a += 5 # 等价于  a = a+5
a *=2 # 等价于 a  = a*2
3.4.4.2. 比较运算符
运算符 描述
== 等于
!= 不等于
> 大于
< 小于
>= 大于等于
<= 小于等于
3.4.4.3. 逻辑运算符
运算符 描述
and 逻辑与
or 逻辑或
not 逻辑非 
# 逻辑运算符示例
a = True
b = False

# 1. and（逻辑与）：两者为真才返回真
print("a and b =", a and b)  # 输出: False

# 2. or（逻辑或）：至少一个为真就返回真
print("a or b =", a or b)    # 输出: True

# 3. not（逻辑非）：取反
print("not a =", not a)      # 输出: False
print("not b =", not b)      # 输出: True

# 结合比较运算符使用
x = 5
y = 10

# 判断 x 在 0 到 10 之间
print("0 < x < 10 =", 0 < x < 10)                # 输出: True
print("0 < x and x < 10 =", 0 < x and x < 10)    # 输出: True

# 判断 y 不在 0 到 5 之间
print("y < 0 or y > 5 =", y < 0 or y > 5)        # 输出: True

#Python 中非布尔值会隐式转换为布尔值（0、空值 为 False，其他为 True）
# 非布尔类型的逻辑运算
print("5 and 3 =", 5 and 3)   # 输出: 3（and 返回最后一个为真的值）
print("0 or 7 =", 0 or 7)     # 输出: 7（or 返回第一个为真的值）
print("not 'hello' =", not 'hello')  # 输出: False（非空字符串为 True，取反为 False）

if 5 and 3:
    print("True")  # 会执行，输出: True

#在 if 条件中，Python 会将返回值 3 隐式转换为布尔值：
#非零整数 3 的布尔值是 True
  1. 逻辑运算符优先级：not > and > or （例如：not a and b 等价于 (not a) and b）
  2. 短路特性：
    • and：若第一个操作数为假，直接返回假，不计算第二个
    • or：若第一个操作数为真，直接返回真，不计算第二个
  3. 返回值类型：
    • 若操作数是布尔值（True/False），返回布尔值
    • 若操作数是其他类型，返回实际参与运算的值（如 5 and 3 返回 3）
  4. 实用场景：
    • 条件组合（如 if 0 < x < 10）
    • 避免异常（利用短路特性提前判断）
3.4.4.4. 位运算符
# 按位与
result = 5 & 3  # 输出: 1 (0101 & 0011 = 0001)
print("result of 5 & 3 is:", {result})

# 按位或
result = 5 | 3  # 输出: 7 (0101 | 0011 = 0111)
print("result of 5 | 3 is:", {result})

# 按位异或
result = 5 ^ 3  # 输出: 6 (0101 ^ 0011 = 0110)
print("result of 5 ^ 3 is:", {result})

# 按位取反
result = ~5  # 输出: -6 (~0101 = 1010，补码表示)
print("result of ~5 is:", {result})

# 左移
result = 5 << 1  # 输出: 10 (0101 << 1 = 1010)
print("result of 5 << 1 is:", {result})

# 右移
result = 5 >> 1  # 输出: 2 (0101 >> 1 = 0010)
print("result of 5 >> 1 is:", {result})

3.4.5. None类型的使用

  1. None 是 NoneType 类型的唯一值，所有 None 在内存中是同一个对象
  2. 通过 type(None) 可验证类型：
  3. print(type(None)) # 输出: <class 'NoneType'>
3.4.5.1. 不可变

None 不能被修改，也没有任何方法或属性

3.4.5.2. 如何正确判断None
  1. 必须使用 is 或 is not（而非 ==）进行比较，因为 is 检查对象身份（内存地址），而 == 可能被运算符重载干扰
x = None

# 正确方式
if x is None:
    print("x 是 None")

# 错误方式（可能不准确）
if x == None:
    print("可能不准确，避免使用")
3.4.5.3. None与其他“空值”的区别

关键区别：None 表示“无值”，而其他空值（如 0、""）是具体类型的有效值

值 类型 含义 布尔值
None NoneType 表示“无”或“未定义” FALSE
0 int 数值零 FALSE
"" str 空字符串 FALSE
[] list 空列表（容器为空，但对象存在） FALSE
FALSE bool 布尔假值 FALSE

总结：

  • None 是 Python 中表示“空”或“无”的唯一对象
  • 用 is None 判断，而非 ==
  • 适用于函数默认返回值、占位符、可选参数等场景
  • 与其他“假值”（如 0、""）不同，它代表“无”，而非具体类型的空值

应用举例：

def add_to_list(value, target=None):
    if target is None:
        target = []  # 避免可变默认参数的副作用
    target.append(value)return target
print(add_to_list(1))  # 输出: [1]print(add_to_list(2))  # 输出: [2] (而不是[1, 2])

3.4.6. 表达式

  • 表达式是 Python 中用于计算值的代码片段
  • 支持算术、比较、逻辑、赋值、条件、成员关系、身份、位运算等多种表达式
  • 表达式可以嵌套组合，形成复杂的逻辑
3.4.6.1. 算术表达式
# 加法
result = 10 + 5  # 输出: 15

# 减法
result = 10 - 5  # 输出: 5

# 乘法
result = 10 * 5  # 输出: 50

# 除法（返回浮点数）
result = 10 / 3  # 输出: 3.3333333333333335

# 整除（向下取整）
result = 10 // 3  # 输出: 3

# 取模（返回余数）
result = 10 % 3  # 输出: 1

# 幂运算
result = 2 ** 3  # 输出: 8
3.4.6.2. 比较表达式
# 等于
result = 10 == 5  # 输出: False

# 不等于
result = 10 != 5  # 输出: True

# 大于
result = 10 > 5  # 输出: True

# 小于
result = 10 < 5  # 输出: False

# 大于等于
result = 10 >= 5  # 输出: True

# 小于等于
result = 10 <= 5  # 输出: False
3.4.6.3. 逻辑表达式
# and（两者为真才返回真）
result = (10 > 5) and (5 < 3)  # 输出: False

# or（至少一个为真就返回真）
result = (10 > 5) or (5 < 3)  # 输出: True

# not（取反）
result = not (10 > 5)  # 输出: False
3.4.6.4. 条件表达式（三元运算符）
语言 语法示例 说明
C x = (condition) ? a : b; condition 为真时返回 a，否则返回 b
Python x = a if condition else b 更接近自然语言，可读性更强 
# 普通 if-else
if 10 > 5:
    result = "大于"
else:
    result = "小于"

# 三元运算符
result = "大于" if 10 > 5 else "小于"  # 输出: 大于
3.4.6.5. 成员关系表达式

in（检查是否存在）

result = 3 in [1, 2, 3] # 输出: True

not in（检查是否不存在）

result = 4 not in [1, 2, 3] # 输出: True

3.4.6.6. 身份表达式
x = [1, 2, 3]
y = x
z = [1, 2, 3]

# is（检查身份）
result = x is y  # 输出: True

# is not（检查身份不同）
result = x is not z  # 输出: True
3.4.6.7. 位运算表达式
# 按位与
result = 5 & 3  # 输出: 1 (0101 & 0011 = 0001)

# 按位或
result = 5 | 3  # 输出: 7 (0101 | 0011 = 0111)

# 按位异或
result = 5 ^ 3  # 输出: 6 (0101 ^ 0011 = 0110)

# 按位取反
result = ~5  # 输出: -6 (~0101 = 1010，补码表示)

# 左移
result = 5 << 1  # 输出: 10 (0101 << 1 = 1010)

# 右移
result = 5 >> 1  # 输出: 2 (0101 >> 1 = 0010)
#### 3.4.6.8. 函数调用表达式
# 内置函数
result = len("hello")  # 输出: 5

# 自定义函数
def add(a, b):
    return a + b

result = add(10, 5)  # 输出: 15
3.4.6.9. 复杂表达式
# 复杂表达式示例
x = 10
y = 5
z = 3

result = (x > y) and (y < z) or (x + y == 15)  # 输出: True
3.4.6.10. 生成器表达式
# 生成器表达式
# squares是生成器对象，而不是元组
# squares = tuple(x ** 2 for x in range(5)) 会生成一个元组对象
squares = (x ** 2 for x in range(5))
for num in squares:
    print(num)  # 输出: 0 1 4 9 16
3.4.6.11. Lambda 表达式
# Lambda 表达式
add = lambda a, b: a + b
result = add(10, 5)  # 输出: 15

4. 控制流

4.1. 条件语句（if-elif-else）

4.1.1. if…else…语句

if 条件:
 条件成立时，要做的事情
 ……
else:
 条件不成立时，要做的事情
 .....

'''
需求：
1. 定义一个整数变量记录年龄
2. 判断是否满 22 岁 （>=）
3. 如果满 22 岁，允许领取结婚证
4. 如果不满22岁，先谈恋爱吧
'''
# 1. 定义一个整数变量记录年龄
age = int(input("请输入你的年龄: "))

# 2. 判断是否满 22 岁
if age >= 22:
    # 3. 如果满 22 岁，允许领取结婚证
    print("你已满 22 岁，允许领取结婚证！")
else:
    print("你未满 22 岁，先谈恋爱吧！")

4.1.2. if …elif… else语句

python 本身没有 switch-case 语句

if 条件1:
 条件1满足执行的代码
 ……
elif 条件2:
 条件2满足时，执行的代码
 ……
elif 条件3:
 条件3满足时，执行的代码
 ……
else:
 以上条件都不满足时，执行的代码
 ……

name = "张三丰"
if name == "张三丰":
    print("太极拳/太极剑")
elif name == "张无忌":
    print("九阳神功")
elif name == "python":
    print("this is python")
else:
    print("啥也不会……")

4.1.3. if 嵌套

'''
需求：
1. 输入x,y 
2. 首先检查 x 是否大于 5
3. 如果 x 大于 5，再检查 y 是否大于 15
4. 如果 y 也大于 15，则打印 "x 大于 5 且 y 大于 15"
5. 如果 y 不大于 15，则打印 "x 大于 5 但 y 不大于 15"
6. 如果 x 不大于 5，则直接打印 "x 不大于 5"
'''
# 获取用户输入
x = int(input("请输入 x 的值: "))
y = int(input("请输入 y 的值: "))

# 检查 x 是否大于 5
if x > 5:
    # 如果 x 大于 5，再检查 y 是否大于 15
    if y > 15:
        print("x 大于 5 且 y 大于 15")
    else:
        print("x 大于 5 但 y 不大于 15")
else:
    # 如果 x 不大于 5
    print("x 不大于 5")

'''
需求：
用户和电脑比石头/剪刀/布
石头（1）／剪刀（2）／布（3）
'''
# python生成随机数 random
import random

# 1.我们出拳  定义变量保存用户输入
me = int(input('请输入出拳:'))

# 2.电脑随机出拳 (假定电脑出石头)
# 指定开始  结束  包含开始包含结束
com = random.randint(1,3)

# 3.判断胜负
if (me == 1 and com== 2) or (me == 2 and com == 3) or (me == 3 and com== 1):
    # 用户胜利
    print('用户胜利,me = %d,com = %d'%(me ,com))
elif my==com:
    print('平局,决战到天亮,me = %d,com = %d'%(me ,com))
else:
    print('电脑胜利,me = %d,com = %d'%(me ,com))

4.2. 循环（for/while循环，break/continue）

Python 没有原生的 do...while 循环语法

4.2.1. 基本语法

'''
需求:
跟老婆说一万遍"老婆大人千秋万载，一统江湖"
 print("老婆大人千秋万载，一统江湖") 
 print("老婆大人千秋万载，一统江湖") 
 print("老婆大人千秋万载，一统江湖") 
 ...(还有99997遍)...
'''
# 1.定义循环变量
i = 1
# 2.使用while判断条件
while i <= 10000:
    # 要重复执行的代码
    print('老婆大人千秋万载，一统江湖')
    # 3.修改循环变量
    i += 1

4.2.2. 死循环

while True:
    print('老婆大人千秋万载，一统江湖')

# 1.定义循环变量
i = 1
# 2.使用while判断条件
while i <= 10000:
    # 要重复执行的代码
    print('老婆大人千秋万载，一统江湖')

'''
需求：打印正直角三角形
*
**
***
****
*****
'''
n = int(input("请输入打印的行数: "))
i = 1
while i <= n:
    print("*" * i)
    i += 1

'''
需求：打印倒直角三角形
*****
****
***
**
*
'''
n = int(input("请输入打印的行数: "))
while n >= 0:
    print("*" * n)
    n -= 1

4.2.3. 嵌套循环

# 外层循环
i = 0
while i < 5:
    # 内层循环
    j = 0
    while j < 3:
        print(j)
        j += 1
    i += 1

#需求：九九乘法表--正序
row = 1
while row < 10:
    # 这一行,需要操作n次 定义循环
    # 列循环:操作的次数
    col = 1
    while col <= row:
        # 不需要换行
        # 列*行=数据
        print('%d * %d = %d'%(col,row,col*row), end='\t') # 默认会有换行
        col += 1
    # 换行
    print()
    row += 1

#需求：九九乘法表--倒序
row = 9
while row > 0:
    # 这一行,需要操作n次 定义循环
    # 列循环:操作的次数
    col = 1
    while col <= row:
        # 不需要换行
        # 列*行=数据
        print('%d * %d = %d'%(col,row,col*row),end='\t') # 默认会有换行
        col += 1
    # 换行
    print()
    row -= 1

4.3. for 循环

Python没有类似 C/C++/Java 中的 for (i = 0; i < 10; i++) 这种三段式循环结构

4.3.1. for循环

for循环的语法格式如下:
for 临时变量 in 列表或字符串等可迭代对象:
 执行的代码

'''
需求:
打印字符串'hello world'中每一个字符
'''
str = 'hello world'
# ele普通变量  接收容器中的元素
for s in str:
    print(s)

4.3.2. in 和 not in

in 操作符用于判断元素是否存在于容器中，如果在容器中,返回 True，否则返回 False

str = 'hello'
result = 'h' in str
print(result)
result = 'e' not in str
print(result)

4.3.3. range

range() 可创建一个整数列表, range()相当于数学中的左闭右开区间（包含左,不包含右）
我们先看看数学中的区间：
全开全闭区间
	● 开区间：(1,10) 不包含1和10
	● 闭区间：[1,10] 包含1和10
半开半闭区间
	● 左开右闭区间：(1,10] 包含10不包含1
	● 左闭右开区间：[1,10) 包含1不包含10
  • range 的定义:
# 定义 0 到 10 的区间(包含 0,不包含 10)
arr = range(0, 10)
  • 如果区间从 0 开始可以省略 0:
# 定义0到10的区间(包含0,不包含10)
arr = range(10)
  • 倒序的区间定义:
# 定义从10到1的区间，参数分别代表 start开始, stop结束, step步长
arr = range(10, 0, -1)
  • 区间可以通过for进行遍历:
# 定义0到10的区间(包含0,不包含10)
arr = range(0, 10)
# 遍历区间
for ele in arr:
    print(ele)

'''
需求
打印出所有"水仙花数"，所谓"水仙花数"是指一个三位数[100, 1000)，其各位数字立方和等于该数本身。
例如：153是一个"水仙花数"，因为153=1的三次方＋5的三次方＋3的三次方。
'''
for ele in range(100, 1000):
    # 百位
    hun = ele // 100
    # 十位
    ten = ele // 10 % 10
    # 个位
    single = ele % 10
    # 判断立方和
    if (hun**3 + ten**3 + single**3) == ele:
        print(ele)

4.3.4. break 和 continue

break 和 continue 是专门在循环中使用的关键字

  • break：某一条件满足时，不再执行循环体中后续代码，并退出循环
  • continue：某一条件满足时，不再执行本次循环体中后续代码，但进入下一次循环判断
# break
for i in range(5):
    if i == 3:
        break
    print(i)

# continue
for i in range(5):
    if i == 3:
        continue
    print(i)

4.3.5. 循环结合 else

循环也可以像 if 语句一样结合 else
else 中的语句会在循环正常执行完（即没有通过 break或其他异常中断循环）的情况下执行
while循环也是如此

格式如下：
for 变量 in 容器:
 	循环体代码
else:
 	没有通过break退出循环, 循环结束后, 会执行的代码

#for else，会执行else中的代码
str = 'hello world'

for ele in str:
    print(ele)
else:
    print('执行了else语句')

#for else中执行了continue，会执行else中的代码
for ele in str:
    if ele == 'l':
        continue
    print(ele)
else:
    print('执行了else语句')

#for else中执行了break，else语句不会执行
for ele in str:
    if ele == 'l':
        break
    print(ele)
else:
    print('else语句不会执行')

'''
需求：
判断登录密码dafskfWEddfagg=_fkf&E@^是否合法。
密码必须是数字、字母(大小写都可以)、和下划线，否则不合法
如果密码合法,就输出"密码合法"
'''

password = 'dafskfWEddfagg=_fkf&E@^'
container ='0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_'
# 1.for循环遍历密码中每一个元素
for ele in password:
    # 2.判断每一个元素是否合法
    if ele not in container:
        print('密码不合法，不可包含%s' % ele)
        break
else:
        # 如果执行了break,就不会再执行else,密码合法就不会执行
    print('密码合法')

5. 函数基础

5.1. 函数的定义和调用

5.1.1. 函数的定义格式

def 函数名():
 函数封装的代码

5.1.2. 函数的调用格式

函数名()

5.1.3. 第一个函数

# 定义函数
def hello_python():
    print('你好，python')
    print('你好，python')
    print('你好，python')

# 调用函数
hello_daoge()

5.2. 函数的文档注释

函数名并不能完全表示出函数的含义，定义函数的时候就需要给函数加上注释
函数的注释就是文档注释，以后可以根据此内容查看函数使用说明，或用于生成API文档
注释的规则和格式如下:
	● 注释应该定义在函数的下方
	● 使用三对引号注释
	● 调用函数时, 鼠标悬浮在函数名上可以查看函数的说明信息

def add(a, b):
    """
    计算两个数的和
    :param a: 第一个数
    :param b: 第二个数
    :return: 两个数的和
    """
    return a + b

5.3. 函数的参数

5.3.1. 参数的定义和调用

# 定义函数
def 函数名(参数1, 参数2):
    函数代码

# 调用函数
函数名(参数1, 参数2)

5.3.2. 参数的使用

'''
需求：
定义函数，传递a和b，求a和b的和
'''
def sum(a,b):
    """
    这个函数是求两个数据的和
    :param a: 第一个数据
    :param b: 第二个数据
    :return: a和b的和
    """
    result = a + b
    print(result)

# 调用
sum(10,20)

5.4. 函数的返回值

'''
需求：
定义函数返回两个数最大值
'''
# 定义函数
def my_max(a,b):
    if a > b:
        return a
    else:
        return b

# 调用函数
max_value = my_max(10,20)

5.5. 函数多返回值

函数可以返回多个结果

def calc(a, b):
    '''
    求a+b以及a-b的结果
    :param a:
    :param b:
    :return: 结果的元组
    '''
    sum = a + b
    sub = a - b
    return sum, sub

上面函数同时返回了两个数的和以及两个数的差
返回的结果会自动组包成为一个元组数据，接收的时候可以分别接收sum、sub

# 分别接收和以及差
sum, sub = calc(10, 20)

5.6. 函数的四种类型

5.6.1. 无参无返回值

def say_hello():
    print('hello')

5.6.2. 无参有返回值

import random
def get_temp():
    return random.randint(0,100)

5.6.3. 有参无返回值

def say_hello(name):
    print('hello %s'%name)

5.6.4. 有参有返回值

def sum(a, b):
    return a + b

5.7. 函数的形参和实参

5.7.1. 形参

全称为形式参数。是在定义函数的时候使用的参数，用来接收调用该函数时传入的参数

#a和b属于形参，形参在函数调用的时候才赋值
def sum(a, b):
    return a + b

5.7.2. 实参

全称为实际参数，是在调用时传递给函数的参数

#调用sum函数时传入的10和20即是实参
sum(10, 20)

5.7.3. 形参作用域

  • 形参的作用域只在函数内，超出函数就不能再使用了
  • 作用域可以减少不同函数的命名冲突

5.8. 局部变量和全局变量

5.8.1. 局部变量

	● 局部变量，指的是在函数内部定义的变量
	● 不同的函数，可以定义相同名字的局部变量
	● 局部变量的作用域只在函数内部

def func1():
    # 局部变量
    b = 20
    print('hello%d' % b)

5.8.2. 全局变量

全局变量是在整个py文件中声明，全局范围内都可以访问

# 全局变量
m = 10
n = 20

def func():
    # 函数内访问全局变量
    print(m)

如果要在函数内部修改全局变量 需要首先使用global关键字将声明全局变量

# 定义全局变量
m = 10

def func():
    # 使用global声明全局变量
    global m
    # 将m修改成20
    m = 30
    print("函数内部 m=", m)

5.9. 自动内存管理

	● 无需手动分配：Python 开发者不需要像 C/C++ 那样显式调用 malloc() 或 free()
	● 动态对象创建：当你创建对象（如列表、字典、类实例）时，解释器自动在堆内存中分配所需空间
	● 垃圾回收 (GC)：通过引用计数为主 + 分代回收为辅的机制，自动回收不再使用的对象内存

在Python中，内存管理也是分区的，但不像C语言那样直接对应到代码段、数据段、堆、栈等, Python作为高级语言，其内存管理由解释器自动处理，并且抽象层次更高。

栈（Stack）：Python中也有调用栈（Call Stack），用于函数调用，存储函数的局部变量、返回地址等。但是，与C语言不同的是，Python的栈并不直接存储对象，而是存储对象的引用（指针），而对象本身在堆上。此外，Python的栈空间是由解释器管理的，并且每个线程有自己的栈。

私有堆（Private Heap）：Python解释器维护一个私有堆，所有的Python对象和数据结构都位于这个私有堆中。程序员不能直接访问这个堆，而是通过Python提供的API（实际上，我们通过变量和对象引用来间接使用）。

对于开发者来说，不需要像C语言那样显式管理内存，而是由 Python解释器自动处理。因此，我们通常不需要关心对象具体分配在哪个区，只需要关注对象的生命周期和作用域。

以上，欢迎有从事同行业的电子信息工程、互联网通信、嵌入式开发的朋友共同探讨与提问，我可以提供实战演示或模板库。希望内容能够对你产生帮助！

# python # 开发语言 # linux # 驱动开发 # c语言 # arm开发 # mcu
Logo
亚马逊云科技技术品牌专区

更多推荐

cover

【单片机毕业设计】基于 STM32 的智能自动售货控制系统设计与实现，基于 ESP-01S 的物联网售货柜运维管理系统开发（016401）

avatar 亚马逊云科技技术品牌专区

A2A 在 Eino 框架中的完整应用解析

Eino 的 A2A 分为本地 AgentAsTool 轻量协作远程标准 A2A 跨服务通信两套成熟方案，覆盖从小应用到企业分布式多智能体全场景；依托 Graph/Workflow 编排、统一消息 schema、流式事件、Checkpoint 会话能力，解决多 Agent 通信、上下文、调度、可观测四大工程痛点；内部业务大规模落地验证，是 Go 生态下生产级多智能体 A2A 协作主流实现方案，兼顾

avatar 亚马逊云科技技术品牌专区

基于51单片机wifi烟雾温湿度检测 无线物联网 火灾报警系统2114(设计源文件+万字报告+讲解)（支持资料、图片参考_相关定制）_文章底部可以扫码

基于51单片机wifi烟雾温湿度检测 无线物联网 火灾报警系统2114(设计源文件+万字报告+讲解)（支持资料、图片参考_相关定制）_文章底部可以扫码。蜂鸣器声光报警+烟雾MQ-2+ADC0832+DHT11温湿度。51单片机+最小系统+led指示灯+ESP8266。

avatar 亚马逊云科技技术品牌专区