Python 2.7 新手入门指南：踏上编程之旅（请注意版本！）

重要提示： 本文旨在帮助您理解和学习 Python 2.7，这主要适用于您需要维护或理解现有的、使用 Python 2.7 编写的代码。强烈建议所有新项目和未来的学习方向都聚焦于 Python 3。 Python 2.7 已于 2020 年停止官方支持（End-of-Life, EOL），这意味着不再有安全更新和新功能开发。在生产环境中使用 Python 2.7 存在潜在风险。然而，理解 Python 2.7 的基础对于处理历史代码库仍然有价值。

引言：什么是 Python？为什么学它（即使是 2.7）？
Python 2.7 与 Python 3 的重要区别概述
安装 Python 2.7
- Windows
- macOS
- Linux
- 验证安装
初识 Python 2.7：交互式解释器（REPL）和脚本
- 使用交互式解释器
- 编写并运行第一个 Python 脚本
Python 的基本元素：注释、标识符与保留字
- 注释
- 标识符
- 保留字
数据类型和变量
- 变量：存储数据的容器
- 数字（Numbers）
  - 整型（int）
  - 长整型（long）
  - 浮点型（float）
  - 复数（complex）
- 字符串（Strings）
  - 字符串的表示
  - 字符串的连接与重复
  - 字符串的索引与切片
  - 字符串的格式化（% 操作符）
- 列表（Lists）
  - 创建列表
  - 访问列表元素
  - 修改、添加和删除元素
  - 列表的切片
- 元组（Tuples）
  - 创建元组
  - 访问元组元素
  - 元组的不可变性
- 字典（Dictionaries）
  - 创建字典
  - 访问、添加和修改元素
  - 删除元素
  - 字典的方法
- 布尔型（Booleans）
- 空值（None）
基本运算符
- 算术运算符
- 比较运算符
- 逻辑运算符
- 成员运算符
- 身份运算符
输入与输出
- 使用 print 输出（Python 2.7 特有语法）
- 使用 raw_input 获取用户输入
- 警告：慎用 input
流程控制
- 缩进的重要性
- 条件判断：if, elif, else
- 循环
  - while 循环
  - for 循环与 range/xrange
  - break 和 continue
函数：组织代码块
- 定义函数
- 调用函数
- 参数和返回值
- 作用域：局部变量与全局变量
模块：代码的复用
- 什么是模块？
- 导入模块：import, from...import
- 标准库模块示例（math, random, os, sys）
文件操作（I/O）
- 打开文件：open()
- 文件模式
- 读取文件
- 写入文件
- 关闭文件
- 使用 with 语句（推荐）
错误和异常处理
- 什么是错误和异常？
- try...except 语句
- 捕获特定异常
面向对象编程（基础概念）
- 类和对象
- 定义类
- 创建对象
Python 2.7 与 Python 3 核心差异回顾
接下来学习什么？（强烈建议转向 Python 3）
总结

1. 引言：什么是 Python？为什么学它（即使是 2.7）？

Python 是一种高级的、解释型的、通用的、动态类型的编程语言。它由 Guido van Rossum 创建，并于 1991 年首次发布。Python 以其清晰的语法、强大的功能和庞大的社区支持而闻名，广泛应用于 Web 开发、数据科学、人工智能、自动化脚本、网络编程等多个领域。

Python 最大的特点之一是其出色的可读性，它的语法简洁，使用缩进来组织代码块，这使得 Python 代码看起来更像伪代码，易于理解和学习。

您可能因为需要维护旧项目、学习历史代码或者在特定旧环境中工作而需要学习 Python 2.7。尽管我们再次强调转向 Python 3 的重要性，但了解 Python 2.7 的基础仍然有实际价值。

2. Python 2.7 与 Python 3 的重要区别概述

在深入学习 Python 2.7 之前，了解它与 Python 3 的主要差异至关重要，这将帮助您理解为什么推荐使用 Python 3，并在未来更容易地进行版本迁移。一些核心区别包括：

print 语法： 在 Python 2.7 中，print 是一个语句（statement），写法是 print "Hello" 或 print "Hello", name。在 Python 3 中，print() 是一个函数（function），写法是 print("Hello")。
整除： 在 Python 2.7 中，两个整数相除（/）结果仍然是整数（例如 7 / 3 结果是 2）。在 Python 3 中，整数相除结果是浮点数（例如 7 / 3 结果是 2.333...）。如果需要整数结果，可以使用 // 运算符（两个版本都支持）。
input 函数： 在 Python 2.7 中，raw_input() 读取用户输入作为字符串，而 input() 会尝试将用户输入作为 Python 代码进行评估（危险！）。在 Python 3 中，input() 函数的行为相当于 Python 2.7 的 raw_input()，总是返回字符串。
range 与 xrange： 在 Python 2.7 中，range() 返回一个列表（可能消耗大量内存），xrange() 返回一个迭代器（更高效）。在 Python 3 中，range() 函数的行为等同于 Python 2.7 的 xrange()，xrange() 不再存在。
字符串类型： Python 2.7 有 str（字节字符串）和 unicode（Unicode 字符串）两种。处理 Unicode 需要特别注意。Python 3 中只有一种文本字符串类型 str（默认为 Unicode），以及 bytes 类型用于处理二进制数据。
异常处理： 捕获异常的语法略有不同。Python 2.7 是 except Exception, e:，Python 3 是 except Exception as e:。
迭代器： 许多在 Python 2.7 中返回列表的函数或方法（如字典的 .keys()、.values()、.items()）在 Python 3 中返回迭代器视图，这更节省内存。

这些只是部分关键差异。在后续的学习中，我们会特别指出 Python 2.7 的语法或行为与 Python 3 不同之处。

3. 安装 Python 2.7

由于 Python 2.7 已经停止支持，您可能无法直接从 python.org 首页下载最新版本，但可以在其版本归档页面找到。安装过程因操作系统而异。

重要： 如果您的系统已经安装了 Python 3，请小心操作，确保您安装 Python 2.7 时不会覆盖或破坏现有的 Python 3 安装。通常，两个版本可以并存，但需要注意如何调用特定版本的解释器（例如使用 python2 命令）。

Windows

访问 Python 官方网站的旧版本归档页面（archive.python.org）。
找到 Python 2.7 的最新维护版本（例如 Python 2.7.18）。
下载适合您系统架构（32位或64位）的 Windows 安装程序（.msi 文件）。
运行下载的安装程序。
在安装过程中，选择“Customize installation”。
关键步骤： 确保勾选“Add python.exe to Path”（或者您可以在安装完成后手动配置环境变量）。如果系统已有 Python 3，建议不要勾选此项，或者将 Python 2.7 安装到单独的目录，并在需要时使用完整路径或通过别名调用。
选择安装目录，建议使用默认目录或者一个明确区分版本号的目录（例如 C:\Python27）。
完成安装。

macOS

macOS 历史版本曾预装 Python 2.x。您可以检查终端中是否已经有 Python 2.7：

打开“终端”（Terminal.app）。
输入 python --version 并按回车。如果显示 Python 2.7.x，则已经安装。
如果未安装或版本不对，可以从 python.org 的旧版本归档页面下载 macOS 安装程序（.pkg 文件），然后运行安装程序。同样要注意与 Python 3 的并存问题。

Linux

大多数 Linux 发行版在过去都预装了 Python 2.7 或更早的 2.x 版本。您可以通过以下命令检查：

打开终端。
输入 python --version 或 python2 --version 并按回车。

如果未安装，您可以使用包管理器安装，但需要注意包名称可能因发行版而异，且可能默认安装的是 Python 3。例如：

Debian/Ubuntu: sudo apt-get update && sudo apt-get install python (这可能会拉取 Python 2.7) 或 sudo apt-get install python2.7
Fedora: sudo dnf install python2
CentOS/RHEL: sudo yum install python

请务必确认您安装的是 Python 2.7 版本。

验证安装

安装完成后，打开命令提示符（Windows）或终端（macOS/Linux），输入以下命令并按回车：

bash python --version

如果您看到输出显示 Python 2.7.x (例如 Python 2.7.18)，说明安装成功且系统路径配置正确，python 命令指向了 Python 2.7。

如果显示的是 Python 3.x，则您可能需要尝试使用 python2 或 python2.7 命令，或者手动调整系统环境变量。

4. 初识 Python 2.7：交互式解释器（REPL）和脚本

学习 Python 最快的方式之一就是亲自动手写代码并运行。有两种基本方式来执行 Python 代码：使用交互式解释器（REPL）和运行 Python 脚本文件。

使用交互式解释器（REPL）

REPL 代表 Read-Eval-Print Loop（读取-求值-打印-循环）。这是一个非常方便的环境，可以实时输入 Python 代码并立即看到结果，非常适合学习和测试小段代码。

在命令提示符或终端中输入 python 并按回车，您就会进入 Python 2.7 的交互式环境：

bash python

您会看到类似以下的提示符：

“`
Python 2.7.18 (default, Jul 18 2023, 15:10:50)
[GCC 11.2.0] on linux2
Type “help”, “copyright”, “credits” or “license” for more information.

“`

>>> 提示符表示解释器已准备好接收您的命令。现在，您可以输入一些简单的 Python 代码：

“`python

print “Hello, Python 2.7!”
Hello, Python 2.7!
2 + 3 * 4
14
name = “Alice”
print “My name is”, name
My name is Alice

“`

要退出交互式解释器，可以输入 exit() 或按下 Ctrl+D (Linux/macOS) 或 Ctrl+Z 后按回车 (Windows)。

编写并运行第一个 Python 脚本

对于更复杂的程序，我们将代码保存在一个 .py 结尾的文件中，这就是 Python 脚本。

打开一个文本编辑器（如记事本、VS Code、Sublime Text、Atom 等）。
输入以下两行代码：

“`python

–– coding: UTF-8 ––

print “Hello, Python 2.7 Script!”
`` （第一行# –– coding: UTF-8 –-` 是一个编码声明，在 Python 2.7 中推荐使用，以避免处理中文等非 ASCII 字符时出现问题。在 Python 3 中通常不需要。）
将文件保存为 hello.py (确保文件扩展名是 .py)。选择一个容易找到的目录，例如您的桌面或文档文件夹。
打开命令提示符或终端。
使用 cd 命令切换到您保存 hello.py 文件的目录。例如，如果保存在桌面，可能是 cd Desktop。
运行脚本，输入以下命令并按回车：

bash python hello.py

如果一切顺利，您应该会在终端看到输出：

Hello, Python 2.7 Script!

恭喜您，您已经成功运行了第一个 Python 2.7 脚本！

5. Python 的基本元素：注释、标识符与保留字

注释

注释是代码中不会被解释器执行的部分，用于解释代码的功能、目的或任何需要说明的信息。在 Python 中，单行注释以 # 开头：

“`python

这是一个单行注释

print “这条代码会被执行” # 这也是一个注释
“`

多行注释通常使用三对引号 ''' 或 """ 包围，它们实际上是多行字符串字面量，但如果它们出现在代码块的开头（如函数或类的定义下方），会被解释器当作文档字符串（Docstring），用于描述该代码块的功能，可以通过 help() 函数查看。

“`python
”’
这是
一个
多行注释或 Docstring
”’

“””
这也是
一个
多行注释或 Docstring
“””
“`

标识符

标识符是用来命名变量、函数、类、模块等的名称。在 Python 2.7 中，标识符必须遵循以下规则：

第一个字符必须是字母（a-z, A-Z）或下划线（_）。
剩下的字符可以是字母、下划线或数字（0-9）。
标识符区分大小写（myvar 和 myVar 是不同的标识符）。
不能使用 Python 的保留字（关键字）作为标识符。
允许使用非 ASCII 字符作为标识符，但这在实践中不常用，且需要注意文件编码。

合法的标识符示例：my_variable, userName, _privateVar, count1, __init__
非法的标识符示例：1st_name (数字开头), my-variable (包含 -), print (保留字)

保留字

保留字是 Python 语言内部使用的、具有特殊含义的词汇，不能用作普通标识符。在 Python 2.7 中，可以通过导入 keyword 模块并使用 keyword.kwlist 来查看所有保留字：

“`python

import keyword
print keyword.kwlist
[‘and’, ‘as’, ‘assert’, ‘break’, ‘class’, ‘continue’, ‘def’, ‘del’, ‘elif’, ‘else’, ‘except’, ‘exec’, ‘finally’, ‘for’, ‘from’, ‘global’, ‘if’, ‘import’, ‘in’, ‘is’, ‘lambda’, ‘not’, ‘or’, ‘pass’, ‘print’, ‘raise’, ‘return’, ‘try’, ‘while’, ‘with’, ‘yield’]
“`

（注意：exec 在 Python 3 中是函数而不是语句，print 在 Python 3 中是函数。）

6. 数据类型和变量

变量：存储数据的容器

变量是用来存储值的内存位置的名称。在 Python 中，变量在使用前不需要声明其类型，Python 会根据赋给它的值自动确定类型。这被称为动态类型。

“`python

创建变量并赋值

age = 25
name = “Bob”
pi = 3.14
is_student = True

可以重新赋值，改变变量的值和类型

age = “twenty-five” # 现在age是一个字符串了

print age
print name
print pi
print is_student
“`

数字（Numbers）

Python 2.7 支持多种数字类型：

整型（int）： 表示不带小数的整数。在 Python 2.7 中，int 的大小是有限制的，通常取决于运行它的机器位数。
长整型（long）： 表示任意大小的整数，当 int 超出其范围时会自动转换为 long。在数字后面加 L 或 l 也可以创建长整型。在 Python 3 中，int 支持任意大小，long 类型被移除。
浮点型（float）： 表示带小数的数字，通常使用 IEEE 754 标准表示。
复数（complex）： 表示复数，形式为 a + bj，其中 a 是实部，b 是虚部，j 或 J 表示虚数单位。

“`python

整型

a = 10
b = -5

长整型 (注意 L 或 l)

c = 12345678901234567890L
d = 999999999999999999999 # int会自动转换为long

浮点型

e = 3.14
f = -2.5
g = 1.2e10 # 科学计数法

复数

h = 1 + 2j
i = 3 – 4J

print type(a) #
print type(c) #
print type(e) #
print type(h) #

print 7 / 3 # Python 2.7 整除结果是 2
print 7.0 / 3 # 浮点数除法结果是 2.333…
print 7 // 3 # 强制整除结果是 2 (Python 2.7 和 3 都支持)
“`

字符串（Strings）

字符串是字符的序列，用于表示文本。

字符串的表示

可以使用单引号、双引号或三引号创建字符串：

“`python
s1 = ‘Hello’
s2 = “World”
s3 = ”’这是一个
多行字符串”’
s4 = “””这也是
一个
多行字符串”””

print s1
print s2
print s3
print s4

Python 2.7 中的 unicode 字符串 (推荐处理包含非 ASCII 字符的文本)

u_str = u”你好，世界！”
print u_str
print type(s1) # (字节字符串)
print type(u_str) # (Unicode 字符串)
`` 在 Python 2.7 中处理包含中文等非 ASCII 字符的字符串时，强烈建议使用u””前缀创建 Unicode 字符串，并在文件开头声明编码（# –– coding: UTF-8 –-`）。

字符串的连接与重复

使用 + 连接字符串，使用 * 重复字符串：

“`python
greeting = “Hello” + ” ” + “Python”
print greeting # Hello Python

line = “=” * 20
print line # ====================
“`

字符串的索引与切片

字符串是序列，可以通过索引访问单个字符（从 0 开始），通过切片访问子字符串：

“`python
text = “Python”
print text[0] # P (第一个字符)
print text[5] # n (第六个字符)
print text[-1] # n (倒数第一个字符)
print text[-6] # P (倒数第六个字符)

print text[0:2] # Py (从索引0到2，不包含2)
print text[2:] # thon (从索引2到末尾)
print text[:3] # Pyt (从开头到索引3，不包含3)
print text[:] # Python (复制整个字符串)
print text[1::2] # yhn (从索引1开始，每隔一个取一个)
print text[::-1] # nohtyP (反转字符串)
“`

字符串的格式化（% 操作符）

Python 2.7 常使用 % 操作符进行字符串格式化，类似于 C 语言的 printf。

“`python
name = “Alice”
age = 30
height = 1.65

使用 %s (字符串), %d (整数), %f (浮点数)

message = “My name is %s, I am %d years old, and my height is %.2f meters.” % (name, age, height)
print message

输出: My name is Alice, I am 30 years old, and my height is 1.65 meters.

使用字典进行格式化 (更清晰)

data = {‘name’: ‘Bob’, ‘age’: 25}
message2 = “Name: %(name)s, Age: %(age)d” % data
print message2

输出: Name: Bob, Age: 25

`` Python 3 引入了.format()方法和 f-string (格式化字符串字面值)，它们是更现代和推荐的字符串格式化方式，但在 Python 2.7 中%` 操作符是主要方法。

列表（Lists）

列表是 Python 中最常用的序列类型之一，用于存储有序的、可变的（即可修改）的项目集合。列表用方括号 [] 表示，项目之间用逗号分隔。

“`python

创建列表

fruits = [“apple”, “banana”, “cherry”]
numbers = [1, 2, 3, 4, 5]
mixed_list = [1, “hello”, 3.14, True]
empty_list = []

print fruits
print mixed_list

访问列表元素 (通过索引)

print fruits[0] # apple
print fruits[1] # banana
print fruits[-1] # cherry (倒数第一个)

修改列表元素

fruits[1] = “blueberry”
print fruits # [“apple”, “blueberry”, “cherry”]

添加元素

fruits.append(“orange”) # 在末尾添加
print fruits # [“apple”, “blueberry”, “cherry”, “orange”]
fruits.insert(1, “grape”) # 在指定位置添加
print fruits # [“apple”, “grape”, “blueberry”, “cherry”, “orange”]

删除元素

del fruits[0] # 根据索引删除
print fruits # [“grape”, “blueberry”, “cherry”, “orange”]
fruits.remove(“blueberry”) # 根据值删除第一个匹配项
print fruits # [“grape”, “cherry”, “orange”]
last_fruit = fruits.pop() # 移除并返回最后一个元素
print last_fruit # orange
print fruits # [“grape”, “cherry”]
first_fruit = fruits.pop(0) # 移除并返回指定索引的元素
print first_fruit # grape
print fruits # [“cherry”]

列表的切片 (与字符串切片类似)

my_list = [10, 20, 30, 40, 50]
print my_list[1:4] # [20, 30, 40]
print my_list[::2] # [10, 30, 50]
“`

元组（Tuples）

元组也是有序的序列，但与列表不同的是，元组是不可变的（immutable）。元组用圆括号 () 表示，项目之间用逗号分隔。不可变性意味着一旦创建，就不能修改、添加或删除元组中的元素。

“`python

创建元组

my_tuple = (1, 2, 3, “four”)
single_element_tuple = (5,) # 注意单元素元组末尾的逗号

print my_tuple
print single_element_tuple

访问元组元素 (通过索引，与列表和字符串类似)

print my_tuple[0] # 1
print my_tuple[-1] # four

元组的切片 (与列表和字符串类似)

print my_tuple[1:3] # (2, 3)

尝试修改元组会报错 (TypeError)

my_tuple[0] = 10 # 这行代码会引发错误

“`

元组通常用于存储不应改变的数据集合，例如函数的返回值、坐标、配置常量等。因为元组是不可变的，它可以作为字典的键（keys），而列表不行。

字典（Dictionaries）

字典是无序的、可变的键值对集合。每个键（key）都映射到一个值（value）。键必须是唯一的，且必须是不可变类型（如字符串、数字、元组）。字典用花括号 {} 表示，键值对之间用冒号 : 分隔，对之间用逗号 , 分隔。

“`python

创建字典

person = {“name”: “Alice”, “age”: 30, “city”: “New York”}
empty_dict = {}

print person

访问字典元素 (通过键)

print person[“name”] # Alice
print person[“age”] # 30

访问不存在的键会引发 KeyError，可以使用 get() 方法安全访问

print person.get(“city”) # New York
print person.get(“gender”) # None (键不存在时返回 None)
print person.get(“gender”, “Unknown”) # Unknown (键不存在时返回指定默认值)

添加或修改元素

person[“gender”] = “Female” # 添加新键值对
person[“age”] = 31 # 修改已有键的值
print person # {“name”: “Alice”, “age”: 31, “city”: “New York”, “gender”: “Female”}

删除元素

del person[“city”] # 根据键删除
print person # {“name”: “Alice”, “age”: 31, “gender”: “Female”}

使用 pop() 方法删除并获取值

gender = person.pop(“gender”)
print gender # Female
print person # {“name”: “Alice”, “age”: 31}

获取所有键、值、或键值对 (在 Python 2.7 中这些方法返回列表)

print person.keys() # [‘name’, ‘age’]
print person.values() # [‘Alice’, 31]
print person.items() # [(‘name’, ‘Alice’), (‘age’, 31)]
`` **注意：** 在 Python 2.7 中，.keys()、.values()、.items()返回的是 *列表*。在 Python 3 中，它们返回的是*字典视图对象*（dictionary view objects），它们是动态的并且更节省内存。如果您需要在 Python 2.7 中处理大型字典的键、值或项，可以使用iterkeys()、itervalues()、iteritems()方法，它们返回迭代器，效率更高（这些方法在 Python 3 中被移除，因为新的.keys()` 等方法本身就返回迭代器视图）。

布尔型（Booleans）

布尔型只有两个值：True 和 False。它们通常用于逻辑判断。

“`python
is_active = True
is_admin = False

print type(is_active) #
“`
在需要布尔值的上下文中，其他类型的值也会被评估为真（Truthy）或假（Falsy）。在 Python 2.7 中，以下值被认为是假（False）：

None
False
数值 0 (0, 0.0, 0L, 0j)
空序列 (`,[],()`)
空字典 ({})

所有其他值通常被认为是真（True）。

空值（None）

None 是一个特殊的对象，表示空值或没有值。它不同于 0、空字符串或空列表。None 是其自身类型 NoneType 的唯一实例。

“`python
result = None
print result
print type(result) #

通常用于表示函数没有返回任何值

def my_function():
pass # pass 是一个占位符，表示什么也不做

return_value = my_function()
print return_value # None
“`

7. 基本运算符

Python 支持多种运算符用于执行计算或逻辑操作。

算术运算符

运算符	描述	示例 (Python 2.7)	结果
`+`	加	`10 + 5`	`15`
`-`	减	`10 - 5`	`5`
`*`	乘	`10 * 5`	`50`
`/`	除 (注意：整数相除结果是整数)	`10 / 3`	`3`
`/`	除 (注意：浮点数相除结果是浮点数)	`10.0 / 3`	`3.333...`
`%`	取模 (余数)	`10 % 3`	`1`
`**`	幂 (指数)	`2 ** 3`	`8`
`//`	整除 (向下取整)	`10 // 3`	`3`
`//`	整除 (对负数也向下取整，-10//3 = -4)	`-10 // 3`	`-4`

比较运算符

比较运算符用于比较两个值，并返回布尔值（True 或 False）。

运算符	描述	示例	结果
`==`	等于	`5 == 5`	`True`
`!=`	不等于	`5 != 5`	`False`
`<`	小于	`5 < 10`	`True`
`>`	大于	`10 > 5`	`True`
`<=`	小于等于	`5 <= 5`	`True`
`>=`	大于等于	`10 >= 5`	`True`

逻辑运算符

逻辑运算符用于组合布尔表达式。

运算符	描述	示例	结果
`and`	逻辑与 (两边都为真时结果为真)	`True and False`	`False`
`or`	逻辑或 (一边为真时结果为真)	`True or False`	`True`
`not`	逻辑非 (取反)	`not True`	`False`

成员运算符

用于判断一个值是否是序列（字符串、列表、元组）或集合的成员。

运算符	描述	示例	结果
`in`	如果值在序列中返回 True	`'a' in 'banana'`	`True`
`not in`	如果值不在序列中返回 True	`'z' not in 'banana'`	`True`

身份运算符

用于判断两个变量是否引用同一个对象（内存地址）。

运算符	描述	示例	结果
`is`	如果两个变量引用同一个对象返回 True	`a = [1]; b = a; a is b`	`True`
`is not`	如果两个变量引用不同对象返回 True	`a = [1]; b = [1]; a is not b`	`True` (因为它们是两个不同的列表对象)

“`python

身份运算符示例

x = [1, 2, 3]
y = x
z = [1, 2, 3]

print x is y # True (x 和 y 引用同一个列表对象)
print x is z # False (x 和 z 引用内容相同但不是同一个列表对象)
print x == z # True (x 和 z 的内容相等)
“`

8. 输入与输出

使用 `print` 输出（Python 2.7 特有语法）

在 Python 2.7 中，print 是一个语句，不是函数。它的基本用法是将数据打印到控制台。

“`python

打印字符串

print “Hello, World!”

打印变量的值

name = “Python”
print name

打印多个值，它们之间会用空格分隔

a = 10
b = 20
print “The values are:”, a, “and”, b # The values are: 10 and 20

默认在末尾添加换行符

print “First line”
print “Second line”

如果不想换行，可以在末尾加逗号

print “This is on the same line”,
print “as the first part.”

输出: This is on the same line as the first part.

打印到标准错误 (需要导入 sys 模块)

import sys
print >> sys.stderr, “This is an error message.”
`` **重要差异：** 在 Python 3 中，print变成了函数，必须使用圆括号，例如print(“Hello”)。改变分隔符或不换行需要使用函数参数，如print(“a”, “b”, sep=”, “)和print(“no newline”, end=””)`。

使用 `raw_input` 获取用户输入

raw_input() 函数用于从用户那里读取一行输入，并将其作为字符串返回。

“`python

获取用户输入的姓名

user_name = raw_input(“Please enter your name: “)
print “Hello, ” + user_name + “!”

获取用户输入的年龄，raw_input 返回的是字符串，需要转换为数字

age_str = raw_input(“Please enter your age: “)

使用 int() 或 float() 将字符串转换为数字

age = int(age_str)
print “You are”, age, “years old.”
print type(age) #
“`
这是在 Python 2.7 中获取用户输入的推荐方式，因为它总是返回字符串，避免了安全问题。

警告：慎用 `input`

Python 2.7 中还有一个 input() 函数。input() 函数会读取用户输入，并尝试将其作为 Python 表达式进行评估。这意味着如果用户输入了恶意代码字符串（例如 __import__('os').system('rm -rf /')），input() 会尝试执行它，这是非常危险的。

“`python

！！！严重警告：不要在生产代码中使用 Python 2.7 的 input() 函数！！！

user_input = input(“Enter something: “) # 危险！

如果用户输入 123，input() 会返回整数 123

如果用户输入 “hello”，input() 会返回字符串 “hello”

如果用户输入 [1, 2]，input() 会返回列表 [1, 2]

如果用户输入 import(‘os’).system(‘ls’)，input() 会执行系统命令 ls

`` **再次强调：** 在 Python 2.7 中，始终使用raw_input()来获取用户输入的原始字符串，然后根据需要手动进行类型转换。Python 3 的input()函数行为等同于 Python 2.7 的raw_input()`，解决了这个安全问题。

9. 流程控制

流程控制语句决定了程序执行的顺序。

缩进的重要性

Python 不使用大括号 {} 来定义代码块（如函数体、循环体、条件判断体）。而是使用缩进。同一块的代码必须具有相同的缩进级别。

“`python

正确的缩进示例

if True:
print “这是if块内部的代码”
print “这两行代码属于同一个块”
if False:
print “这是嵌套的if块”
print “回到外层if块”
print “这是if块外部的代码”

错误的缩进示例 (会引发 IndentationError)

if True:

print “这行缩进错误”

“`
通常使用 4 个空格作为标准缩进（不要混用空格和 Tab）。

条件判断：`if`, `elif`, `else`

if 语句用于根据条件执行不同的代码块。

“`python
score = 85

if score >= 90:
print “成绩优秀”
elif score >= 80: # else if 的缩写
print “成绩良好”
elif score >= 60:
print “成绩及格”
else: # 所有条件都不满足时执行
print “成绩不及格”

print “判断结束”
“`

循环

循环用于重复执行一段代码。

`while` 循环

while 循环在给定条件为真时重复执行代码块。

“`python
count = 0
while count < 5:
print “Count is:”, count
count = count + 1 # 或者 count += 1

print “循环结束”
“`

`for` 循环与 `range`/`xrange`

for 循环用于遍历序列（如列表、元组、字符串）或其他可迭代对象中的元素。

“`python
fruits = [“apple”, “banana”, “cherry”]
for fruit in fruits:
print “I like”, fruit

遍历字符串

for char in “Python”:
print char

遍历字典的键

my_dict = {“a”: 1, “b”: 2}
for key in my_dict.keys(): # 或者直接 for key in my_dict:
print key, my_dict[key]

遍历字典的键值对 (使用 items() 或 iteritems())

for key, value in my_dict.items(): # 或者 my_dict.iteritems()
print “Key:”, key, “Value:”, value
“`

range(start, stop, step) 函数生成一个整数序列，常用于 for 循环需要固定次数迭代的场景。在 Python 2.7 中，range() 返回一个包含所有数字的列表。xrange() 函数也做类似的事情，但它返回一个迭代器，只在需要时生成数字，对于大范围的循环更节省内存和高效。

“`python

使用 range() – 返回列表

for i in range(5): # 从 0 到 4
print i,

输出: 0 1 2 3 4

使用 range(start, stop)

for i in range(2, 7): # 从 2 到 6
print i,

输出: 2 3 4 5 6

使用 range(start, stop, step)

for i in range(0, 10, 2): # 从 0 到 9，步长为 2
print i,

输出: 0 2 4 6 8

使用 xrange() (在 Python 2.7 中推荐用于大范围)

print “\nUsing xrange:”
for i in xrange(5):
print i,

输出: 0 1 2 3 4

比较 range 和 xrange

print “\nType of range(5):”, type(range(5)) #
print “Type of xrange(5):”, type(xrange(5)) #
`` **重要差异：** 在 Python 3 中，range()的行为等同于 Python 2.7 的xrange()，总是返回一个迭代器，并且xrange()` 不复存在。

`break` 和 `continue`

break 语句用于立即终止当前循环（while 或 for）。
continue 语句用于跳过当前循环的剩余部分，直接进入下一次迭代。

“`python

break 示例

for i in range(10):
if i == 5:
break # 当 i 等于 5 时，退出循环
print i,

输出: 0 1 2 3 4

print “\n” # 换行

continue 示例

for i in range(10):
if i % 2 == 0: # 如果是偶数
continue # 跳过当前迭代的剩余部分，继续下一次
print i,

输出: 1 3 5 7 9

“`

10. 函数：组织代码块

函数是一段具有特定功能的、可以重复使用的代码块。通过定义函数，我们可以将复杂的程序分解成更小、更易于管理的模块，提高代码的复用性和可读性。

定义函数

使用 def 关键字定义函数：

“`python
def greet(name):
“””
这是一个 Docstring，解释函数的功能。
这个函数打印一个问候语。
“””
print “Hello,”, name + “!”

定义一个计算两个数之和的函数

def add_numbers(a, b):
sum = a + b
return sum # 使用 return 返回结果

定义一个没有返回值的函数

def say_hello():
print “Just saying hello!”
“`

函数定义可以包含参数（parameter），参数是函数接收输入值的占位符。

调用函数

定义函数后，可以通过函数名后跟圆括号来调用它。如果函数接受参数，调用时需要在圆括号中提供相应的参数值（arguments）。

“`python
greet(“Alice”) # 调用 greet 函数，传递 “Alice” 作为参数 name
greet(“Bob”)

result = add_numbers(5, 3) # 调用 add_numbers 函数，并将结果存储在 result 变量中
print “Sum:”, result

say_hello() # 调用 say_hello 函数
“`

参数和返回值

参数： 函数定义时圆括号中的变量名是参数。调用时传递的值是参数值或实参（argument）。Python 支持位置参数、关键字参数、默认参数、可变参数（*args, **kwargs）。
返回值： 函数可以使用 return 语句返回一个或多个值。如果没有 return 语句，或者 return 语句后面没有值，函数默认返回 None。

“`python

带有默认参数的函数

def greet_with_default(name, greeting=”Hello”):
print greeting + “,”, name + “!”

greet_with_default(“Charlie”) # 使用默认问候语: Hello, Charlie!
greet_with_default(“David”, “Hi”) # 使用指定的问候语: Hi, David!

返回多个值 (实际上是返回一个元组)

def get_coords():
x = 10
y = 20
return x, y

coords = get_coords()
print coords # (10, 20)

可以使用多重赋值来接收返回值

x_coord, y_coord = get_coords()
print “X:”, x_coord, “Y:”, y_coord # X: 10 Y: 20
“`

作用域：局部变量与全局变量

变量的作用域决定了变量可以在程序中的哪些地方被访问。

局部变量： 在函数内部定义的变量是局部变量，它们只在该函数内部有效。函数执行完毕后，局部变量会被销毁。
全局变量： 在所有函数之外（模块级别）定义的变量是全局变量，它们可以在程序的任何地方被访问。

“`python
global_var = “I am global”

def my_function():
local_var = “I am local”
print global_var # 在函数内部可以访问全局变量
print local_var # 在函数内部可以访问局部变量

my_function()

print global_var # 在函数外部可以访问全局变量

print local_var # 在函数外部访问局部变量会引发 NameError

`` 如果在函数内部需要修改全局变量，需要使用global` 关键字声明：

“`python
counter = 0

def increment_counter():
global counter # 声明 counter 是全局变量
counter += 1
print “Counter:”, counter

increment_counter() # Counter: 1
increment_counter() # Counter: 2
print “Final counter:”, counter # Final counter: 2
“`

11. 模块：代码的复用

模块是包含 Python 代码（变量、函数、类等）的文件。通过使用模块，可以将代码组织成逻辑单元，方便重用和管理。一个 .py 文件就是一个模块。

什么是模块？

想象一下，您写了一些计算数学公式的函数，您可以把这些函数放在一个名为 math_utils.py 的文件中。那么 math_utils 就是一个模块。

导入模块：`import`, `from...import`

要使用一个模块中的内容，首先需要导入它。

import module_name： 导入整个模块。使用模块中的内容时需要加上模块名作为前缀。

“`python
import math # 导入 Python 标准库中的 math 模块

radius = 5
area = math.pi * (radius ** 2) # 使用 math.pi 和 math 函数
print “Area:”, area

print math.sqrt(25) # 计算平方根
“`
from module_name import item_name： 从模块中导入特定的函数、类或变量。使用时可以直接使用名称，无需模块名作前缀。

“`python
from math import pi, sqrt # 只导入 pi 和 sqrt

radius = 5
area = pi * (radius ** 2) # 直接使用 pi
print “Area:”, area

print sqrt(36) # 直接使用 sqrt
“`
from module_name import *： 导入模块中的所有公开名称。不推荐这样做，因为它可能导致命名冲突，并且不容易分辨某个名称来自哪个模块。

“`python

from math import * # 不推荐

print sin(radians(90)) # 这种方式不清晰，不知道 sin, radians 来自哪里

“`
import module_name as alias： 导入模块并给它一个别名，方便使用。

“`python
import math as m # 导入 math 模块并起别名为 m

print m.sqrt(100) # 使用别名 m.sqrt
“`

标准库模块示例

Python 安装自带了大量的标准库模块，提供了丰富的功能。例如：

math: 数学函数和常量。
random: 生成伪随机数。
os: 与操作系统交互，如文件路径、目录操作。
sys: 访问与 Python 解释器相关的变量和函数。

“`python
import random

生成 1 到 100 之间的随机整数

random_int = random.randint(1, 100)
print “Random integer:”, random_int

从列表中随机选择一个元素

my_list = [“apple”, “banana”, “cherry”]
random_choice = random.choice(my_list)
print “Random choice:”, random_choice

import os

获取当前工作目录

current_dir = os.getcwd()
print “Current directory:”, current_dir

print os.listdir(current_dir) # 如果文件多可能会打印很多

import sys

获取 Python 版本信息

print “Python version:”, sys.version

获取脚本名称

print “Script name:”, sys.argv[0]
“`

12. 文件操作（I/O）

处理文件是编程中的常见任务，例如读取配置文件、处理数据文件等。

打开文件：`open()`

使用内置函数 open() 来打开一个文件。它至少需要一个参数：文件名。第二个参数是模式，指定您想如何使用文件（读取、写入、追加等）。

“`python

打开一个文件准备读取

如果文件不存在，open() 会引发 IOError

try:
file_object = open(“my_document.txt”, “r”)
print “文件打开成功，准备读取”
file_object.close() # 使用完文件后务必关闭
except IOError as e: # Python 2.7 的异常捕获语法是 except ExceptionType, variable:
print “文件打开失败:”, e
except IOError, e: # Python 2.7 风格
print “文件打开失败 (2.7 风格):”, e

打开一个文件准备写入 (如果文件不存在则创建，如果存在则清空内容)

write_file = open(“output.txt”, “w”)
print “文件打开成功，准备写入”
write_file.close()
“`

文件模式

常用的文件模式：

'r': 读取模式 (默认)。文件必须存在。
'w': 写入模式。如果文件不存在则创建，如果存在则清空内容再写入。
'a': 追加模式。如果文件不存在则创建，如果存在则在文件末尾追加内容。
'b': 二进制模式。与 ‘r’, ‘w’, ‘a’ 结合使用 (例如 'rb', 'wb', 'ab')，用于处理非文本文件（如图片、音频）。
'+': 更新模式。与 ‘r’, ‘w’, ‘a’ 结合使用 (例如 'r+', 'w+', 'a+')，允许同时读写。

读取文件

打开文件后，可以使用不同的方法读取内容：

read(size=-1): 读取指定字节数（如果省略或为负数则读取全部内容）。
readline(size=-1): 读取一行内容，包括换行符。
readlines(): 读取所有行，并返回一个包含每行字符串的列表。
直接迭代文件对象：逐行读取。

“`python

假设 output.txt 已经有一些内容

逐行读取文件

try:
read_file = open(“output.txt”, “r”)
for line in read_file:
print “读取到一行:”, line.strip() # strip() 去掉行末的换行符
read_file.close()
except IOError, e:
print “读取文件时发生错误:”, e

读取全部内容

try:
read_file = open(“output.txt”, “r”)
content = read_file.read()
print “文件全部内容:\n”, content
read_file.close()
except IOError, e:
print “读取文件时发生错误:”, e
“`

写入文件

打开文件后，可以使用 write(string) 方法写入字符串：

“`python

使用 ‘w’ 模式写入

try:
write_file = open(“new_file.txt”, “w”)
write_file.write(“这是第一行。\n”)
write_file.write(“这是第二行。”) # 没有换行符
write_file.close()
print “内容已写入 new_file.txt”
except IOError, e:
print “写入文件时发生错误:”, e

使用 ‘a’ 模式追加

try:
append_file = open(“new_file.txt”, “a”)
append_file.write(“\n这是追加的一行。”) # 先写个换行符再追加
append_file.close()
print “内容已追加到 new_file.txt”
except IOError, e:
print “追加文件时发生错误:”, e
“`

关闭文件

文件操作完成后，务必使用 file_object.close() 方法关闭文件，释放系统资源。

使用 `with` 语句（推荐）

使用 with 语句可以更安全、更方便地处理文件。它会在代码块执行完毕后自动关闭文件，即使发生错误也一样。

“`python

使用 with 读取文件

try:
with open(“output.txt”, “r”) as file_object:
for line in file_object:
print “With 语句读取到一行:”, line.strip()
# 文件在 with 块外部已经自动关闭

except IOError, e:
print “使用 with 读取文件时发生错误:”, e

使用 with 写入文件

try:
with open(“another_new_file.txt”, “w”) as write_obj:
write_obj.write(“使用 with 写入内容。”)
# 文件在 with 块外部已经自动关闭
print “内容已使用 with 写入 another_new_file.txt”
except IOError, e:
print “使用 with 写入文件时发生错误:”, e
`` **强烈推荐**在 Python 2.7 和 Python 3 中都使用with open(…) as …:` 语句来处理文件。

13. 错误和异常处理

程序在运行时可能会遇到错误，导致程序终止。这些错误通常被称为异常（Exceptions）。例如，除以零、访问不存在的文件、索引超出范围等都会引发异常。良好的程序应该能够捕获和处理这些异常，而不是直接崩溃。

什么是错误和异常？

语法错误 (Syntax Error): 代码不符合 Python 语法规则，解释器在运行前就能检测到。例如，拼写错误、缺少冒号等。
异常 (Exception): 程序在运行时发生的错误，会中断程序的正常流程。例如 ZeroDivisionError, IOError, ValueError, TypeError, IndexError 等。

“`python

语法错误示例

if a > 5 # 缺少冒号会导致 SyntaxError

异常示例

print 10 / 0 # ZeroDivisionError

my_list = [1]

print my_list[5] # IndexError

“`

`try...except` 语句

使用 try...except 语句可以捕获和处理异常：

python try: # 尝试执行可能引发异常的代码块 num1 = int(raw_input("Enter a number: ")) num2 = int(raw_input("Enter another number: ")) result = num1 / num2 print "Result:", result except ZeroDivisionError: # 如果 try 块中发生 ZeroDivisionError，执行这里的代码 print "错误：不能除以零！" except ValueError: # 如果 try 块中发生 ValueError (例如输入不是有效数字)，执行这里的代码 print "错误：输入了无效的数字！" except Exception, e: # 捕获所有其他异常，并将异常对象赋值给变量 e (Python 2.7 风格) print "发生了一个未知错误:", e

您可以使用一个 except 块捕获多种类型的异常，用括号将异常类型括起来：

python try: num1 = int(raw_input("Enter a number: ")) num2 = int(raw_input("Enter another number: ")) result = num1 / num2 print "Result:", result except (ZeroDivisionError, ValueError): # 同时捕获这两种异常 print "输入或计算错误：请确保输入有效数字且不除以零。" except Exception, e: print "发生了一个未预期的错误:", e

一个没有指定异常类型的 except 块可以捕获所有类型的异常，但这通常不推荐，因为它可能掩盖您不知道的错误。

python try: # 可能会出错的代码 pass except: # 捕获所有异常 (不推荐) print "发生了一个未知错误"

可选的 else 块和 finally 块：

else 块：如果 try 块没有引发任何异常，则执行 else 块中的代码。
finally 块：无论是否发生异常，finally 块中的代码总是会执行。这常用于进行清理工作（如关闭文件、释放资源）。

python try: file = open("test.txt", "r") content = file.read() print content except IOError, e: print "文件操作错误:", e else: print "文件读取成功，没有发生异常。" finally: # 无论如何都会执行 if 'file' in locals() and not file.closed: # 检查文件对象是否存在且未关闭 file.close() print "文件已关闭。"

重要差异： Python 3 捕获异常的语法是 except Exception as e:，而不是 except Exception, e:。

14. 面向对象编程（基础概念）

面向对象编程（OOP）是一种编程范式，它将数据和处理数据的方法封装在称为“对象”的单元中。在 Python 2.7 中，您可以开始学习 OOP 的基本概念。

类和对象

类 (Class): 是创建对象的蓝图或模板。它定义了对象的属性（数据）和方法（行为）。
对象 (Object) / 实例 (Instance): 是类的一个具体实体。根据类创建出来的真实存在的个体。

定义类

使用 class 关键字定义类：

“`python
class Dog:
# 这是一个类的 Docstring
“””
表示一只狗的类。
“””

# 类属性 (所有实例共享)
species = "Canis familiaris"

# 初始化方法 (构造方法)
# self 代表对象实例本身
def __init__(self, name, age):
    """
    初始化 Dog 对象。

    Args:
        name: 狗的名字 (字符串)。
        age: 狗的年龄 (整数)。
    """
    self.name = name # 实例属性
    self.age = age   # 实例属性

# 实例方法 (对象的行为)
def bark(self):
    print "%s says Woof!" % self.name # 使用 % 格式化

def get_age_in_dog_years(self):
    return self.age * 7

`` **注意：** 在 Python 2.7 中，为了创建“新式类”（new-style classes），类定义通常需要继承自object，例如class Dog(object):。如果您省略(object)，您创建的是“旧式类”（classic classes），它们在继承等方面行为有所不同。**推荐始终继承自object**。在 Python 3 中，所有类默认都是新式类，无需继承object`。

“`python

新式类定义 (推荐在 Python 2.7 中使用)

class NewStyleDog(object):
species = “Canis familiaris”
def init(self, name, age):
self.name = name
self.age = age
def bark(self):
print “%s says Woof!” % self.name
“`

创建对象

通过调用类名并传递 __init__ 方法所需的参数来创建类的对象（实例化）：

“`python

创建 Dog 类的两个对象 (实例)

my_dog = NewStyleDog(“Buddy”, 5)
your_dog = NewStyleDog(“Lucy”, 3)

print type(my_dog) #

访问对象的属性

print my_dog.name # Buddy
print your_dog.age # 3
print my_dog.species # Canis familiaris (访问类属性)

调用对象的方法

my_dog.bark() # Buddy says Woof!
your_dog.bark() # Lucy says Woof!

print “%s is %d human years old, which is %d dog years.” % \
(my_dog.name, my_dog.age, my_dog.get_age_in_dog_years())

Buddy is 5 human years old, which is 35 dog years.

“`

15. Python 2.7 与 Python 3 核心差异回顾

再次强调本指南开头的关键差异，以便您在学习过程中保持警惕，并为未来转向 Python 3 打下基础：

print： Python 2.7 是语句 print "..."；Python 3 是函数 print("...")。
整除： Python 2.7 中 10 / 3 结果是 3 (整数)；Python 3 中 10 / 3 结果是 3.33... (浮点数)。// 在两个版本中都是整除。
输入： Python 2.7 使用 raw_input() 获取字符串输入，input() 执行输入内容 (危险)；Python 3 中 input() 获取字符串输入 (相当于 2.7 的 raw_input)，没有等同于 2.7 input() 的安全隐患。
range/xrange： Python 2.7 中 range() 返回列表，xrange() 返回迭代器（更优）；Python 3 中 range() 返回迭代器（相当于 2.7 的 xrange()），xrange() 不存在。
字符串类型： Python 2.7 有 str (字节) 和 unicode (文本)；Python 3 中 str (文本) 和 bytes (字节)，文本处理更统一。
字典方法： Python 2.7 中 .keys(), .values(), .items() 返回列表；Python 3 中返回动态视图对象。
异常捕获： Python 2.7 是 except Exception, e:；Python 3 是 except Exception as e:。
新式类 vs 旧式类： Python 2.7 区分新式类 (class MyClass(object):) 和旧式类 (class MyClass:), 推荐新式类；Python 3 中所有类默认是新式类。

16. 接下来学习什么？（强烈建议转向 Python 3）

恭喜您学完了 Python 2.7 的基础知识！您现在应该对变量、数据类型、控制流程、函数、模块和基本的面向对象概念有了初步的了解。

下一步，最重要且最推荐的是：

学习并转向 Python 3： 花时间理解 Python 3 的核心变化，并开始用 Python 3 练习和编写新代码。这是未来 Python 开发的主流方向，拥有更活跃的社区、持续的安全更新和更多现代特性。您可以使用 2to3 工具来帮助将 Python 2.7 代码转换为 Python 3 代码。
深入学习 Python 3 的基础知识： 重新学习数据类型、控制流、函数等，重点关注与 Python 2.7 的差异。
学习如何使用包管理器 pip： 在 Python 3 环境下，学习如何使用 pip 来安装和管理第三方库，这将极大地扩展您的能力。虽然 Python 2.7 也有 pip，但由于 EOL，很多现代库已经不再支持 2.7。
实践项目： 通过编写小型项目来巩固所学知识。例如，一个简单的命令行工具、一个文件处理脚本、一个简单的游戏等。
探索标准库： 熟悉更多 Python 的标准库，它们提供了大量实用的功能。
学习更高级的主题： 深入学习面向对象编程、模块和包的组织、装饰器、生成器、迭代器、上下文管理器等。
学习常用第三方库： 根据您的兴趣方向（Web 开发、数据分析、机器学习等），学习相应的流行库，如 Flask/Django (Web)、Pandas/NumPy (数据)、Scikit-learn/TensorFlow/PyTorch (AI/ML)。

17. 总结

本指南带您快速入门了 Python 2.7 的基本概念和语法。您学习了如何安装 Python 2.7，运行代码，理解变量和数据类型，掌握流程控制，定义和使用函数、模块，进行文件操作以及基础的错误处理和面向对象概念。

再次强调，Python 2.7 已经停止支持，不应用于新的开发。本指南旨在帮助您理解现有 2.7 代码的基础。未来的学习重心应全面转向 Python 3。

学习编程是一个持续的过程，不断练习、阅读代码、解决问题是提高的关键。祝您在 Python 的世界中探索愉快！

Python 2.7 新手入门指南：踏上编程之旅（请注意版本！）

1. 引言：什么是 Python？为什么学它（即使是 2.7）？

2. Python 2.7 与 Python 3 的重要区别概述

3. 安装 Python 2.7

Windows

macOS

Linux

验证安装

4. 初识 Python 2.7：交互式解释器（REPL）和脚本

使用交互式解释器（REPL）

编写并运行第一个 Python 脚本

–– coding: UTF-8 ––

5. Python 的基本元素：注释、标识符与保留字

注释

这是一个单行注释

标识符

保留字

6. 数据类型和变量

变量：存储数据的容器

创建变量并赋值

可以重新赋值，改变变量的值和类型

数字（Numbers）

整型

长整型 (注意 L 或 l)

浮点型

复数

字符串（Strings）

字符串的表示

Python 2.7 中的 unicode 字符串 (推荐处理包含非 ASCII 字符的文本)

字符串的连接与重复

字符串的索引与切片

字符串的格式化（% 操作符）

使用 %s (字符串), %d (整数), %f (浮点数)

输出: My name is Alice, I am 30 years old, and my height is 1.65 meters.

使用字典进行格式化 (更清晰)

输出: Name: Bob, Age: 25

列表（Lists）

创建列表

访问列表元素 (通过索引)

修改列表元素

添加元素

删除元素

列表的切片 (与字符串切片类似)

元组（Tuples）

创建元组

访问元组元素 (通过索引，与列表和字符串类似)

元组的切片 (与列表和字符串类似)

尝试修改元组会报错 (TypeError)

my_tuple[0] = 10 # 这行代码会引发错误

字典（Dictionaries）

创建字典

访问字典元素 (通过键)

访问不存在的键会引发 KeyError，可以使用 get() 方法安全访问

添加或修改元素

删除元素

使用 pop() 方法删除并获取值

获取所有键、值、或键值对 (在 Python 2.7 中这些方法返回列表)

布尔型（Booleans）

空值（None）

通常用于表示函数没有返回任何值

7. 基本运算符

算术运算符

比较运算符

逻辑运算符

成员运算符

身份运算符

身份运算符示例

8. 输入与输出

使用 print 输出（Python 2.7 特有语法）

打印字符串

打印变量的值

打印多个值，它们之间会用空格分隔

默认在末尾添加换行符

如果不想换行，可以在末尾加逗号

输出: This is on the same line as the first part.

打印到标准错误 (需要导入 sys 模块)

使用 raw_input 获取用户输入

获取用户输入的姓名

获取用户输入的年龄，raw_input 返回的是字符串，需要转换为数字

使用 int() 或 float() 将字符串转换为数字

使用 `print` 输出（Python 2.7 特有语法）

使用 `raw_input` 获取用户输入

警告：慎用 `input`

！！！严重警告：不要在生产代码中使用 Python 2.7 的 input() 函数！！！

条件判断：`if`, `elif`, `else`

`while` 循环

`for` 循环与 `range`/`xrange`

`break` 和 `continue`

导入模块：`import`, `from...import`

打开文件：`open()`