Python环境搭建&基础语法

[TOC]

1. Python初识

1.1 Python起源

Python（英国发音：/ˈpaɪθən/ 美国发音：/ˈpaɪθɑːn/）是一门优雅而健壮的编程语言。

• 创始人：Guido van Rossum（吉多·范罗苏姆），人称“龟叔”。
• 背景：1989 年圣诞节期间，为了打发无聊的假期，龟叔开始编写一种新的脚本解释器。他希望这个新语言能像 C 语言那样全面调用计算机接口，又能像 Shell 那样轻松编程。
• 命名：源于他喜爱的英国喜剧《Monty Python’s Flying Circus》（蒙提·派森的飞行马戏团）。
• 设计哲学：“优雅、明确、简单”。Python 提倡：最好只有一种方法来做一件事。

Java vs Python 核心对比

1.2 Python特点

1.2.1 优点

1. 易于学习：语法简洁，关键字少，结构清晰，上手极快。
2. 广泛的标准库：“自带电池”（Batteries Included），涵盖网络、文件、数据库、正则等丰富功能。
3. 强大的第三方库：拥有庞大的社区（PyPI），在人工智能、数据分析、Web开发等领域有海量现成工具。
4. 互动模式：支持终端实时输入代码并获取反馈（REPL），方便测试和调试。
5. 可移植性：Write Once, Run Anywhere。在 Windows, Linux, Mac 上均可运行。
6. 可扩展性：关键代码可用 C/C++ 编写以提升性能（胶水语言特性）。
7. 免费开源：自由使用、分发和修改。

1.2.2 缺点

1. 运行速度慢：作为解释型语言，代码在运行时逐行翻译，比编译型语言（如 C/C++）慢。
2. 代码无法加密：发布程序通常意味着发布源代码（虽然可以编译成字节码，但容易反编译）。

1.3 Python版本对比

• Python 2：2020年1月1日官方已停止维护（End of Life）。历史包袱较重。
• Python 3：当前主流版本。设计时未考虑向下兼容，修正了许多旧版本的缺陷。
  • 本教程使用版本：Python 3.12.8（2024年12月发布）。

1.4 Python解释器

Python 代码（.py 文件）需要解释器来执行。

1. CPython（官方标准）：
   • 用 C 语言开发，使用最广。
   • 命令行输入 python 启动的就是 CPython。
2. IPython：
   • 基于 CPython 的交互式增强版（提示符为 In [1]:）。
   • Jupyter Notebook 的核心内核。
3. PyPy：
   • 追求运行速度，采用 JIT（即时编译）技术。
4. Jython：
   • 运行在 Java 平台，可直接调用 Java 类库。
5. IronPython：
   • 运行在 .Net 平台，可调用 .Net 类库。

2. Python环境搭建

2.1 原生Python环境安装

适合场景：只需要一个标准的 Python 环境，不涉及复杂的版本隔离。

2.1.1 下载安装包

1. 访问官网：https://www.python.org/

2. 点击 Downloads -> 选择操作系统。
   

3. 下载 Windows installer (64-bit)。
   

   安装包类型说明：

   • installer（推荐）：完整安装包，包含标准库、pip、文档等，自动配置环境。
   • embeddable：嵌入式包，极简版，用于嵌入其他应用，不含标准库和pip。

2.1.2 安装步骤

1. 双击安装包。
   
2. 关键步骤：
   • 勾选 Add python.exe to PATH（自动配置环境变量）。
   • 选择 Customize installation（自定义安装）或 Install Now。
3. 保持默认组件（pip, tcl/tk, IDLE 等），点击 Next。
   
4. 修改安装路径（建议路径简单，无中文无空格），点击 Install。
   
5. 安装完成，点击 Disable path length limit（解除路径长度限制）。
   

2.1.3 验证安装

1. Win + R，输入 cmd。
2. 输入 python --version。
   
   

2.2 基于Conda的环境管理（推荐）

适合场景：AI、数据分析、多项目开发，需要隔离不同版本的 Python 和依赖库。

2.2.1 Conda 核心优势

2.2.2 Conda / Anaconda / Miniconda 区别

• Conda：核心工具（包管理器 + 环境管理器）。
• Anaconda：旗舰版（Conda + Python + 500+预装科学包 + 图形界面），体积大。
• Miniconda：精简版（Conda + Python + pip），体积小，按需安装。

2.3 Miniconda安装

1. 下载：Miniconda官网
   
2. 安装：
   • 双击安装，一路 Next。
   • 环境变量选项：
     • Add Miniconda3 to my PATH：建议取消勾选（防止污染系统 Path），推荐使用 Anaconda Prompt 命令行工具。
     • Register Miniconda3 as my default Python：根据需要勾选。
3. 验证：打开 Anaconda Prompt，输入 conda --version。

2.4 Conda常用命令实战

2.4.1 基础命令

2.4.2 环境管理（最常用）

2.4.3 包管理

2.4.4 镜像源配置（加速下载）

建议配置清华大学镜像源：

conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main/
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/conda-forge/
conda config --set show_channel_urls yes

2.4.5 环境导入导出（团队协作）

• 导出环境：conda env export > environment.yml
• 导入环境：conda env create -f environment.yml

2.5 PyCharm安装与配置

2.5.1 下载与安装

1. 官网下载 Community（社区版）：https://www.jetbrains.com/pycharm/download/
   
2. 安装过程保持默认即可。
   

2.5.2 创建项目与解释器配置

这是新手最容易晕的地方，PyCharm 提供了三种解释器配置方式：

2.5.3 个性化设置

• 主题：File -> Settings -> Appearance
• 字体：File -> Settings -> Editor -> Font
• 快捷键：File -> Settings -> Keymap

3. Python基础核心

3.1 第一个Python程序

3.1.1 交互式模式 (Interactive Mode)

• 操作：打开 CMD，输入 python，出现 >>>。
• 特点：即输即用，适合测试短代码。
  

3.1.2 脚本模式 (Script Mode)

• 操作：编写 .py 文件，在命令行用 python hello.py 运行。
• 特点：标准开发方式，代码可保存。
  
  

3.1.3 IDE模式 (PyCharm)

• 操作：在 PyCharm 中右键点击代码 -> Run。

• 特点：工程化开发，集成调试、高亮、补全功能。

  使用IDE运行Python程序，也是日后我们最常用的方式。

  在python项目下创建一个新的目录chapter02

  

  在chapter02目录下创建一个Python程序文件，输入

  

  Pycharm工作区空白处右键，单击 Run‘01_Hello_World’。

  

  可以在下方控制台看到程序执行结果，打印出了 hello world 。

  

3.2 注释

• 单行注释：# 开头。

  # 这是一个注释
  print("Hello") # 行末注释
  

• 多行注释：三个引号 """ 或 '''。

  """
  这是一个
  多行注释
  """
  

3.3 变量&常量

• 定义：变量名 = 值（无需声明类型）。

• 原理：变量是标签，指向内存中的对象。

  Java 对比：

  • Java：int a = 10; 声明类型，分配内存空间。
  • Python：a = 10。10 是一个对象，a 只是贴在 10 上面的标签。Python 中一切皆对象（包括整数）。

• 命名规范：

  • 只能包含字母、数字、下划线，不能以数字开头。

  • 区分大小写。

  • 常见的命名方法有三种：

    • 大驼峰命名法（upper camel case）：每个单词首字母大写，例如UpperCamelCase。

    • 小驼峰命名法（lower camel case）：第一个单词首字母小写, 之后每个单词首字母大写，例如lowerCamelCase。

    • 蛇形命名法（snake case）：单词间用下划线连接，例如snake_case（Python官方推荐）。

  • 关键字不能作为变量名（如 if, class, def）。
    

• 变量示例：

  # Python 不需要类型声明
  name = "张三"   # String
  age = 18       # int
  weight = 70.5  # float
  
  # 动态类型特性：同一个变量可以指向不同类型的对象
  var = 10       # var 是 int
  var = "Hello"  # var 变成了 str (Java中不允许 int a=10; a="Hello";)
  
  # 多变量赋值
  a = b = c = 10 
  x, y, z = 10, 20, 30 
  

• 在程序中定义后就不再修改的值为常量，Python中没有内置的常量类型（无 final 关键字）。一般约定使用全大写变量名来表示常量。

  PI = 3.1415926
  MAX_CONNECTION = 100
  

3.4 基本数据类型

Python 中一切皆对象，主要包含以下几种数据类型：

1. 数值类型 (Numeric)

• int (整数)：无大小限制（Python 3），自动处理大整数溢出。

  Java 对比：Java int 范围是 -2^31 ~ 2^31-1，超出需用 BigInteger。Python int 自动扩容，相当于内置了 BigInteger。

• float (浮点数)：带小数点的数（双精度，类似 Java double）。
• bool (布尔)：True 和 False（注意首字母大写）。

  Java 对比：Java 是 true/false。Python 本质是整数 (True==1, False==0)，可直接参与数学运算（虽然不推荐）。

• complex (复数)：如 3 + 4j（科学计算常用）。

类型查看与判断案例：

num1 = True
num2 = 1
print(type(num1))                 # <class 'bool'>
print(type(num2))                 # <class 'int'>
print(isinstance(num1, int))      # True (bool是int的子类)

书写很大的数时，可使用下划线将其中的数字分组，使其更清晰易读（Java 7+ 也支持此特性）。

num1 = 1_000_000_000
print(num1)  # 1000000000

2. 字符串类型 (String)

见后文详解。

3. 容器类型 (Container)

• list (列表)：有序、可变序列。类似 Java ArrayList。
• tuple (元组)：有序、不可变序列。类似 Java 数组或 List.of()。
• set (集合)：无序、不重复集合。类似 Java HashSet。
• dict (字典)：键值对集合。类似 Java HashMap。

4. 特殊类型

• None：表示空值。

  Java 对比：类似 Java 的 null。但 None 是一个单例对象（NoneType），不能像 Java 那样把 null 赋值给任意引用类型（虽然 Python 变量可以指向 None）。

5. 可变性分类

• 不可变：Number, String, Tuple 创建后，其值不能被修改。如果尝试 “修改”，实际上是创建了一个新的对象，内存地址会发生变化。

  # 1. 数字（Number）
  a = 10
  print(f"修改前a的值: {a}, 内存地址: {id(a)}")  # 比如地址是 140708467523296
  a = a + 1  # 看似修改，实际是创建新对象
  print(f"修改后a的值: {a}, 内存地址: {id(a)}")  # 地址变成 140708467523328（新地址）
  

• 可变：List, Dict, Set 创建后，其值可以被修改，且修改后内存地址保持不变（容器本身没换，只是内容变了）。

  # 1. 列表（List）
  lst = [1, 2, 3]
  print(f"修改前lst的值: {lst}, 内存地址: {id(lst)}")  # 比如地址是 2205689748288
  lst[0] = 100  # 直接修改列表元素
  print(f"修改后lst的值: {lst}, 内存地址: {id(lst)}")  # 地址还是 2205689748288（不变）
  

3.5 字符串详解 (str)

3.5.1 字符串定义

用单引号 ' 或双引号 " 括起来即可，两者可互相嵌套（避免引号冲突）：

str1 = 'This is a "string"'  # 单引号内嵌套双引号
str2 = "This is a 'string' too"  # 双引号内嵌套单引号
print(str1)  # 输出：This is a "string"
print(str2)  # 输出：This is a 'string' too

3.5.2 多行字符串

用三引号 """（或 '''）包裹，可直接换行书写，无需额外转义：

Java 对比：类似 Java 13+ 的 Text Blocks ("""...""")。

str1 = """hello world
HELLO WORLD
你好 世界"""  # 直接换行，保留格式
print(str1)
# 输出：
# hello world
# HELLO WORLD
# 你好 世界

3.5.3 转义字符

用于表示无法直接输入的特殊字符，核心常用转义符如下：

3.5.4 字符串常用方法

字符串方法是对字符串做处理的核心操作，以下 4 个是日常最常用的，均基于基础数据类型，无需复杂语法：

（1）split ()：拆分字符串（转成列表）

作用：按指定分隔符把字符串拆分成列表，默认按 “空格 / 换行 / 制表符” 拆分。

语法：字符串.split(分隔符, 拆分次数)（拆分次数可选）

# 示例1：按逗号拆分（处理输入/数据解析）
text = "苹果,香蕉,橙子"
result = text.split(",")  # 按逗号拆分
print(result)  # 输出：['苹果', '香蕉', '橙子']

# 示例2：默认按空格拆分
text2 = "hello world python"
result2 = text2.split()  # 不写分隔符，默认按空格拆
print(result2)  # 输出：['hello', 'world', 'python']

# 示例3：指定拆分次数（只拆1次）
text3 = "a-b-c-d"
result3 = text3.split("-", 1)  # 按-拆分，只拆1次
print(result3)  # 输出：['a', 'b-c-d']

（2）join ()：拼接列表为字符串（split 的反向操作）

作用：用指定字符串把列表中的元素拼接成一个新字符串。

语法：分隔符.join(列表)

# 示例：把水果列表拼成“苹果|香蕉|橙子”
fruits = ['苹果', '香蕉', '橙子']
result = "|".join(fruits)  # 用|拼接列表元素
print(result)  # 输出：苹果|香蕉|橙子

# 示例2：拼接成无分隔符的字符串
chars = ['h', 'e', 'l', 'l', 'o']
result2 = "".join(chars)
print(result2)  # 输出：hello

（3）strip ()：去除首尾空白 / 指定字符

作用：默认去除字符串首尾的空格、换行、制表符；也可指定去除首尾的字符。

语法：字符串.strip(指定字符)（指定字符可选）

# 示例1：去除首尾空格（处理用户输入超实用）
text = "  hello world  "
result = text.strip()
print(result)  # 输出：hello world（首尾空格没了）

# 示例2：去除首尾指定字符（比如首尾的#）
text2 = "##python##"
result2 = text2.strip("#")
print(result2)  # 输出：python

# 补充：lstrip()只去左边，rstrip()只去右边
print("  abc  ".lstrip())  # 输出：abc  （只去左边空格）
print("  abc  ".rstrip())  # 输出：  abc（只去右边空格）

（4）replace ()：替换字符串中的指定内容

作用：把字符串中的某段内容替换成新内容，可指定替换次数。

语法：字符串.replace(旧内容, 新内容, 替换次数)（次数可选）

# 示例1：全部替换
text = "hello world, hello python"
result = text.replace("hello", "hi")  # 把所有hello换成hi
print(result)  # 输出：hi world, hi python

# 示例2：指定替换次数（只替换1次）
text2 = "a-b-a-b-a"
result2 = text2.replace("a", "x", 2)  # 只替换前2个a
print(result2)  # 输出：x-b-x-b-a

# 示例3：替换为空（相当于删除指定内容）
text3 = "123abc456"
result3 = text3.replace("abc", "")  # 删除abc
print(result3)  # 输出：123456

3.6 数据类型转换

• 隐式转换：自动提升精度，如 int + float -> float。

  num1 = 2
  num2 = 3.0
  print(num1 + num2)  # 5.0
  

  特别的是，两个整数除法运算也是浮点

  num1 = 9
  num2 = 1
  print(num1 / num2)  # 9.0
  

  而整型和字符串相加会报错，此时Python无法进行隐式转换完成计算：

  num1 = 123
  str1 = "456"
  print(num1 + str1)  # 报错
  

• 显式转换：

  1. 转整数（int ()）

     规则：只能转纯数字字符串 / 浮点数 / 布尔值，浮点数转整数会直接去掉小数（不四舍五入）

     # 示例
     print(int("123"))    # 字符串转整数 → 123
     print(int(3.99))     # 浮点数转整数 → 3
     print(int(True))     # 布尔值True转整数 → 1
     print(int(False))    # 布尔值False转整数 → 0
     

  2. 转字符串（str ()）

     规则：所有类型都能转，直接变成对应字符串形式

     # 示例
     print(str(123))      # 整数转字符串 → "123"
     print(str(3.14))     # 浮点数转字符串 → "3.14"
     print(str(True))     # 布尔值转字符串 → "True"
     print(str([1,2]))    # 列表转字符串 → "[1, 2]"
     

  3. 转布尔值（bool ()）

     规则：0 / 空值 / 空容器为 False，其他都是 True

     # 示例
     print(bool(0))       # 0 → False
     print(bool(123))     # 非0数字 → True
     print(bool(""))      # 空字符串 → False
     print(bool("abc"))   # 非空字符串 → True
     print(bool([]))      # 空列表 → False
     print(bool([1]))     # 非空列表 → True
     

• 编码与解码：

  encode(“utf-8”)：把 Python 的字符串（str）转成二进制字节（bytes）—— 接口传输、跨系统通信时，只能传输二进制数据，不能直接传字符串，这一步是为了让字符串 “能被传输”。

  decode(“utf-8”)：把接口接收到的二进制字节（bytes）转回字符串（str）—— 拿到二进制数据后，只有转成字符串才能正常阅读、处理（比如解析接口返回的中文内容）。

  text = "你好"
  data = text.encode("utf-8") # 转为 bytes
  print(data.decode("utf-8")) # 转回 str
  

3.7 输入与输出

3.7.1 输入

获取用户在控制台的输入，相当于 Java 的 Scanner。

• 重要特性：input() 函数接收到的内容永远是字符串 (str)。
• 类型转换：如果需要数字，必须手动转换（如 int()）。

# 提示用户输入（阻塞式）
name = input("请输入姓名：") 
print("你好,", name)

# 接收数值（需转换）
# Java写法：int age = scanner.nextInt();
age_str = input("请输入年龄：")
age = int(age_str)  # 转换为整数
# 简写：age = int(input("请输入年龄："))

if age >= 18:
    print("成年人")
else:
    print("未成年")

3.7.2 输出 (Print)

将内容输出到控制台（Console），相当于 Java 的 System.out.println()。

1. 基础用法：

   print("hello world") # 自动换行
   
   # 多参数输出（自动以空格分隔）
   print("name:", "Tom", "age:", 18) 
   # 输出：name: Tom age: 18
   
   # 自定义分隔符与结尾
   print("a", "b", "c", sep="-", end="!") 
   print("next line")
   # 输出：a-b-c!next line
   

2. 格式化输出：

   1. % 占位符（基础老式写法）

      核心用法：用%加指定字符表示占位类型，末尾用%拼接要填充的值（多个值需用元组）。

      常用占位符：%s（字符串 / 万能）、%d（整数）、%f（浮点数）

      # 基础示例
      print("name=%s, age=%d" % ("Tom", 18))  # 输出：name=Tom, age=18
      
      # 补充：浮点数格式化（保留2位小数）
      print("身高=%.2f米" % 1.785)  # 输出：身高=1.79米（自动四舍五入）
      
      # 补充：多个变量占位
      name = "Jerry"
      score = 95.5
      print("姓名：%s，分数：%d" % (name, score))  # 输出：姓名：Jerry，分数：95
      

      特点：兼容性好（适配老版本 Python），但写法繁琐，占位符和值容易对应错。

   2. format 方法（通用写法）

      核心用法：用{}占位，通过format()传值，支持按位置 / 按名称取值，更灵活。

      # 基础示例（按位置）
      print("name={}, age={}".format("Tom", 18))  # 输出：name=Tom, age=18
      # 补充1：按索引指定顺序（解决值顺序错的问题）
      print("age={1}, name={0}".format("Tom", 18))  # 输出：age=18, name=Tom
      # 补充2：按名称取值（更易读）
      print("name={n}, age={a}".format(n="Tom", a=18))  # 输出：name=Tom, age=18
      # 补充3：浮点数保留2位小数
      print("体重={:.2f}kg".format(65.892))  # 输出：体重=65.89kg
      

      特点：比 % 占位符灵活，无需记占位符类型，但写法比 f-string 稍繁琐。

   3. f-string（Python3.6 + 推荐写法）

      核心用法：字符串前加f/F，{}内直接写变量 / 表达式，简洁高效。

      # 基础示例
      name = "Tom"
      age = 18
      print(f"name={name}, age={age}")  # 输出：name=Tom, age=18
      
      # 补充1：直接写表达式（无需额外计算）
      print(f"明年年龄：{age + 1}")  # 输出：明年年龄：19
      
      # 补充2：浮点数格式化（保留2位，加千分位）
      salary = 12345.6789
      print(f"月薪：{salary:,.2f}")  # 输出：月薪：12,345.68
      
      # 补充3：{变量=} 快速打印变量名+值（调试超实用）
      print(f"{name=}, {age=}")  # 输出：name='Tom', age=18
      

      特点：写法最简洁、执行效率最高，支持表达式和灵活的格式控制，是日常开发首选。

4. 运算符详解

4.1 算术运算符

用于数值的加减乘除、取余、幂运算等，是最基础的运算符。

a = 7
b = 3
print(a / b)   # 2.333... (注意：无论是否整除，结果都是float)
print(a // b)  # 2        (保留整数部分，向下取整)
print(a % b)   # 1        (余数)
print(a ** b)  # 343      (7的3次方)

4.2 赋值运算符

用于给变量赋值，复合赋值运算符（+=/-=等）可简化 “运算 + 赋值” 操作。

注意：Python 不支持 Java 的 ++ / -- 自增自减运算符（i++ 是非法的），请使用 i += 1。

海象运算符 (:=)：Python 3.8+ 新增，核心优势是 “在表达式内部赋值”，避免重复计算。

# 常规写法：先计算长度，再判断
text = "hello"
length = len(text)
if length > 3:
    print(f"长度是 {length}")

# 海象运算符写法：一步完成赋值+判断
if (length := len(text)) > 3:
    print(f"长度是 {length}")  # 输出：长度是 5

# 另一个实用场景：循环中减少重复调用
nums = [1,2,3,4]
while (n := len(nums)) > 0:
    print(f"当前列表长度：{n}")
    nums.pop()  # 每次删除最后一个元素

4.3 比较运算符

用于比较两个值的大小 / 是否相等，返回结果永远是布尔值（True/False）。

print(3 > 2)     # True
print(3 < 2)     # False
print(3 == 3)    # True
print(3 != 3)    # False

# 链式比较（Python 特有，Java 不支持）
age = 20
print(18 <= age < 60)  # True，等价于 age>=18 and age<60
# Java 写法： if (age >= 18 && age < 60)

4.4 逻辑运算符

用于组合多个布尔条件，核心是and（与）、or（或）、not（非），具有短路特性（提升执行效率）。

age = 20
# and：两个条件都满足才为True
print(age >= 18 and age < 60)  # True
# or：满足一个就为True
print(age < 18 or age > 60)    # False
# not：取反
print(not (age < 18))          # True

# 短路特性示例（第二个表达式不会执行）
print(False and (1/0))  # 不会报错，因为False and 直接返回False
print(True or (1/0))    # 不会报错，因为True or 直接返回True

4.5 成员运算符

用于判断 “元素是否在容器中”，核心是in（存在）、not in（不存在），支持字符串、列表、元组、字典等。

Java 对比：

• 字符串：等价于 str.contains("sub")
• 列表/集合：等价于 list.contains(obj)
• 字典：等价于 map.containsKey(key)

# 字符串中判断子串
text = "hello world"
print("hello" in text)     # True
print("hi" not in text)    # True

# 列表/元组中判断元素
lst = [1, 2, 3]
print(1 in lst)            # True
print(4 not in lst)        # True

# 字典中默认判断key（不是value）
dic = {"name": "Tom", "age": 18}
print("name" in dic)       # True
print("Tom" in dic)        # False（判断value需用 dic.values()）

4.6 身份运算符

用于判断 “两个变量是否指向同一个内存地址”，核心是is、is not。

Java 核心差异（非常重要）：

• Python is ≈ Java ==：比较内存地址（Reference Equality）。
• Python == ≈ Java equals()：比较值（Value Equality）。

绝大多数情况下（判断数值、字符串内容），请使用 ==。只有判断 None 时推荐使用 is。

# 示例1：小整数池（Python优化，-5~256的整数共用地址）
x = 10
y = 10
print(x == y)    # True（值相等）
print(x is y)    # True（地址相同，类似 Java Integer 缓存池）

# 示例2：大整数（超出小整数池，地址不同）
a = 257
b = 257
print(a == b)    # True（值相等）
print(a is b)    # False（地址不同，类似 new Integer(257)）

# 示例3：None的判断（推荐用is）
x = None
print(x is None)      # True（标准写法）
print(x == None)      # 不推荐
print(x is not None)  # False

4.7 运算符优先级

当一个表达式中有多个运算符时，Python 会按优先级依次计算（优先级高的先算），优先级从高到低核心顺序：

**`（幂） > `* / % //`（乘除取余整除） > `+ -`（加减） > `> < >= <= == !=`（比较） > `not` > `and` > `or

# 示例：按优先级计算
result = 2 + 3 * 4 **2  # 先算4²=16 → 再算3×16=48 → 最后算2+48=50
print(result)  # 50

# 技巧：不确定优先级时，用()括号强制改变顺序（更易读）
result = (2 + 3) * (4 **2)  # 先算2+3=5、4²=16 → 再算5×16=80
print(result)  # 80

5. 编码规范 (PEP 8)

PEP 8 是 Python 官方推荐的编码规范，遵循它能让代码更易读、不易出错，以下是新手最易落地的 5 条核心规则：

1. 缩进：统一用4 个空格（别用 Tab 键，也别空格 / Tab 混用），仅在循环、判断等代码块中缩进；
2. 行长：单行代码别超过 79 个字符（太长就拆成多行，避免横向滚动）；
3. 空行：不同功能的代码块之间空 1 行（比如 “输入数据” 和 “计算逻辑” 分开）；
4. 空格：赋值、加减乘除等操作符两边各加 1 个空格（如 a = b + c），逗号后也加空格；
5. 分号：行尾千万别加分号（Python 不用分号结束语句，加了纯属多余）。

这个案例是 “计算学生 3 门科目平均分”，完全基于数字、字符串、列表和运算符，对比规范 / 不规范写法，新手能直接看懂：

✅ 符合 PEP 8 的正确写法

# 1. 输入学生信息（功能块1，独立空行分隔）
student_name = input("请输入学生姓名：")
math_score = int(input("请输入数学成绩："))
chinese_score = int(input("请输入语文成绩："))
english_score = int(input("请输入英语成绩："))

# 空行分隔不同功能块（输入→计算）
# 2. 计算总分和平均分（用算术运算符）
total_score = math_score + chinese_score + english_score
subject_count = 3  # 3门科目
avg_score = total_score / subject_count  # 除法运算符，两边加空格

# 空行分隔计算→输出
# 3. 格式化输出结果（字符串+运算符）
# 行长过长时拆分，每行不超79字符
print(f"学生：{student_name}")
print(f"总分：{total_score} 分，平均分：{avg_score:.2f} 分")

# 额外示例：判断是否及格（比较/逻辑运算符）
if avg_score >= 60 and avg_score < 90:
    # 循环/判断内缩进4个空格
    print(f"{student_name} 成绩合格，继续加油！")
elif avg_score >= 90:
    print(f"{student_name} 成绩优秀！")
else:
    print(f"{student_name} 成绩不及格，需要补考！")

❌ 违反 PEP 8 的错误写法（新手常犯）

# 错误1：操作符两边无空格、行尾加分号
student_name=input("请输入学生姓名：");
math_score=int(input("请输入数学成绩："));chinese_score=int(input("请输入语文成绩："));

# 错误2：无空行分隔功能块，代码挤在一起
total_score=math_score+chinese_score+english_score;subject_count=3;
avg_score=total_score/subject_count;

# 错误3：行长超79字符，缩进只用2个空格
print(f"学生：{student_name}，总分：{total_score} 分，平均分：{avg_score:.2f} 分");
if avg_score>=60 and avg_score<90:
  # 错误4：缩进只有2个空格（不是4个）
  print(f"{student_name} 成绩合格，继续加油！");

总结

1. 新手先掌握核心 3 条：4 空格缩进、操作符加空格、行尾不加冒号；
2. 用空行分隔 “输入、计算、输出” 不同功能块，代码更清晰；
3. 单行代码别写太长，拆分后读起来更轻松，完全适配运算符 + 基本数据类型的知识范围。

再举一个符合 PEP 8 规范的代码案例

如何让学生更好地理解和应用 PEP 8 规范？

除了 PEP 8 规范，还有哪些常用的 Python 编码规范？

6. 流程控制

6.1 分支结构 (If)

分支结构用来 “根据条件执行不同代码”，是最基础的逻辑控制方式，核心是if/elif/else，满足哪个条件就执行对应的代码块。

# 新手友好示例：根据成绩判断等级（仅用数字、比较运算符）
score = 85  # 可替换成 input("请输入成绩：") 手动输入
if score >= 90:
    # 缩进4个空格，满足score≥90时执行
    print("优秀")
elif score >= 60:
    # 不满足上一个条件，但满足≥60时执行
    print("及格")
else:
    # 以上条件都不满足时执行
    print("不及格")

Match-Case (Python 3.10+，简化版理解)

可以理解成 “升级版多分支”，适合按固定值匹配（比如状态码、固定选项），新手先了解即可：

# 示例：匹配HTTP状态码（仅用数字、赋值运算符）
status = 404  # 可替换成200/500等测试
match status:
    case 200:
        print("请求成功（OK）")
    case 404:
        print("页面找不到（Not Found）")
    case _:  # _ 表示“其他所有情况”
        print("未知状态码")

6.2 循环结构

循环用来 “重复执行一段代码”，新手重点掌握while（按条件循环）和for（按次数 / 遍历循环）。

6.2.1 While 循环

只要条件为 True，就一直执行循环体，直到条件为 False 才停止（注意设置 “终止条件”，避免死循环）。

# ------------输出5次 Hello Python------------------
count = 1
while count <= 5:    
    print("Hello Python")   
    count += 1

# 示例：打印0-4的数字（仅用数字、赋值/比较运算符）
count = 0  # 初始化计数器
while count < 5:  # 条件：count小于5时循环
    print(count)  # 打印当前数字
    count += 1    # 计数器+1（关键：让条件最终会变成False）
else:
    # 循环正常结束（没被break打断）时执行
    print("循环完成，count最终值：", count)

6.2.2 For 循环

更适合 “固定次数循环” 或 “遍历列表 / 字符串”，新手常用range()函数控制循环次数。

for 临时变量 in 可迭代对象:
    语句1
else:
    语句2

# 示例1：遍历列表（仅用列表、基本遍历）
nums = [1, 2, 3]
for i in nums:  # 依次取列表中的每个元素
    print("列表元素：", i)

# 示例2：用range()控制循环次数（核心用法）
# range(起始, 结束, 步长)，注意“结束值不包含”
# range(1, 10, 2) → 1,3,5,7,9（从1开始，到10前结束，每次+2）
for i in range(1, 10, 2):
    print("步长2的数字：", i)

# 新手简化版：只写一个参数（默认从0开始，步长1）
for i in range(3):  # 等价于range(0,3,1) → 0,1,2
    print("简化版循环：", i)

# -----------------遍历字符串---------------------
for s in "hello":
    print(s)
    
# -------------打印乘法表---------------
for i in range(1, 10):
    for j in range(1, i + 1):
        print(f"{i} × {j} = {i * j}", end="\t")
    print()

6.3 循环控制（修改循环执行流程）

用来手动干预循环的执行，新手重点掌握break和continue，pass仅作占位了解。

# 示例1：break（立即终止整个循环）
print("===== break示例 =====")
count = 0
while count < 5:
    if count == 3:  # 当count=3时
        break       # 直接终止循环
    print(count)
    count += 1  # 输出：0 1 2（循环提前结束）

# 示例2：continue（跳过本次循环，执行下一次）
print("===== continue示例 =====")
for i in range(5):
    if i == 2:  # 当i=2时
        continue  # 跳过本次print，直接进入下一次循环
    print(i)  # 输出：0 1 3 4（少了2）

# 示例3：pass（空语句，仅占位，不影响循环）
print("===== pass示例 =====")
for i in range(2):
    pass  # 暂时没想好写什么，用pass占位（不会报错）
print("循环执行完成（pass仅占位）")

总结

1. 分支结构：if/elif/else按条件执行代码，match-case适合固定值匹配（3.10+）；
2. 循环结构：while按条件循环（需设终止条件），for+range()适合固定次数循环；
3. 循环控制：break终止整个循环，continue跳过本次循环，pass仅作代码占位。

7. 综合案例：猜数字游戏

本案例综合运用了变量、数据类型转换、输入输出、循环（while）、分支（if-elif-else）、break/continue 等核心知识点。

游戏规则：程序随机生成一个 1-100 的数字，玩家通过输入数字进行猜测，程序会提示“大了”或“小了”，直到猜中为止。

import random

# 1. 生成 1 到 100 之间的随机数
target_num = random.randint(1, 100)
count = 0  # 记录猜测次数

print("=" * 30)
print("欢迎来到猜数字游戏！")
print("我已经想好了一个 1 到 100 之间的数字。")
print("=" * 30)

while True:
    # 2. 获取用户输入
    user_input = input("请输入你猜的数字（输入 'q' 退出）：")
    
    # 3. 退出机制
    if user_input == 'q':
        print("游戏结束，欢迎下次再来！")
        break
        
    # 4. 校验输入是否为数字（防止程序报错）
    if not user_input.isdigit():
        print("输入无效，请输入一个整数！")
        continue
        
    # 5. 核心逻辑判断
    guess_num = int(user_input)
    count += 1
    
    if guess_num > target_num:
        print("猜大了！再小一点。")
    elif guess_num < target_num:
        print("猜小了！再大一点。")
    else:
        print(f"恭喜你！猜对了！答案就是 {target_num}。")
        print(f"你总共猜了 {count} 次。")
        break