Python入门核心知识点精讲：从变量到字符串的全面指南

Python作为一门简洁而强大的编程语言，是许多开发者入门的第一选择。本文将从变量、数据类型到字符串操作，系统梳理Python基础知识点，帮助你快速建立扎实的编程基础。无论你是刚接触编程的新手，还是想巩固基础的老手，这篇文章都能为你提供清晰的学习路径。

一、变量命名与基本数据类型

变量是存储数据的容器，Python中的变量命名遵循一定的规则：

• ✅ 变量名只能包含字母、数字和下划线，且不能以数字开头
• ✅ 使用下划线分隔单词，避免空格（例如 user_name）
• ✅ 避免使用Python关键字和内置函数名（如 print、if）
• ⚠️ 慎用小写字母 l 和大写字母 O，它们容易与数字1和0混淆
• 变量名应既简短又具有描述性，例如 student_count 优于 sc

Python支持多种数字类型：

• 整数：支持十进制、八进制、十六进制和二进制表示，且允许无限精度
• 浮点数：带有小数部分的数字，具有一定的精度限制
• 复数：由实部和虚部组成，虚部以 j 或 J 结尾，可通过 complex(real, imag) 创建

与其他语言（如Java、TypeScript）不同，Python无需显式声明变量类型，类型在运行时自动推断，这大大简化了代码编写。

二、小数与分数：精确计算的利器

在财务计算或需要高精度的场景中，普通的浮点数可能因精度问题导致错误。Python提供了小数（Decimal）和分数（Fraction）类型来解决这一问题。

2.1 小数类型（Decimal）

小数对象通过导入 decimal 模块并调用构造函数创建，而不是通过运行常量表达式。例如：

from decimal import Decimal
result = Decimal('0.1') + Decimal('0.1') + Decimal('0.1') - Decimal('0.3')
print(result)  # 输出: Decimal('0.0')
decimal.getcontext().prec = 4  # 设置全局精度为4位
result = decimal.Decimal('1') / decimal.Decimal('7')
print(result)  # 输出: Decimal('0.1429')
with decimal.localcontext() as ctx:
ctx.prec = 2  # 临时设置精度为2位
result = decimal.Decimal('1.00') / decimal.Decimal('3.00')
print(result)  # 输出: Decimal('0.33')
print(decimal.Decimal('1.00') / decimal.Decimal('3.00'))  # 恢复默认精度，输出: Decimal('0.3333333333333333333333333333')

小数类型具有固定精度，适用于财务计算等对精度有严格要求的场景。你可以通过 decimal.getcontext() 设置全局精度，或使用 with decimal.localcontext() 临时调整精度，退出后自动恢复。

2.2 分数类型（Fraction）

分数类型由分子和分母组成，创建时会自动简化为最简形式。例如 Fraction(6, 8) 会被简化为 Fraction(3, 4)。分数支持加、减、乘、除等数学运算，并可通过 float() 转换为浮点数。

from fractions import Fraction
a = Fraction(5, 4)
b = Fraction(7, 16)
print(a + b)  # 输出: Fraction(27, 16)
print(a * b)  # 输出: Fraction(35, 64)
x = Fraction(-3, 10)
print(float(x))  # 输出: -0.3
print(x.numerator)  # 输出: -3
print(x.denominator)  # 输出: 10
f = 2.5
x = Fraction(*f.as_integer_ratio())
print(x)  # 输出: Fraction(5, 2)
## 2.变量：命名和使用
- 变量名只能包含字母、数字和下划线。变量名可以字母或下划线打头，但不能以数字打头
- 变量名不能包含空格，但可使用下划线来分隔其中的单词
- 不要将Python关键字和函数名用作变量名，即不要使用Python保留用于特殊用途的单词
- 变量名应既简短又具有描述性
- 慎用小写字母l和大写字母O，因为它们可能被人错看成数字1和0

在需要精确有理数运算的场景（如数学计算或物理模拟）中，分数类型比浮点数更可靠。

三、字符串：文本处理的瑞士军刀

字符串是Python中最常用的数据类型之一，用单引号或双引号括起。Python提供了丰富的字符串操作功能，从基础的转义字符到高级的格式化，应有尽有。

3.1 转义字符与原始字符串

转义字符用于表示无法直接输入的字符：

• 控制字符：如 \n（换行）、\t（制表符）
• 引号和特殊字符保留：如 \'、\\
• Unicode相关：如 \uXXXX（16位Unicode字符）

转义字符	意义
\newline	忽略（连续）
\b	倒退
\f	换页
\n	新行（换行）
\r	返回
\t	水平制表符
\v	垂直制表符

转义字符	意义
|反斜杠（保留\）
’	单引号（保留’）
"	双引号（保留"）
\a	响铃
\0	Null（不是字符串结尾）
\other	不转义（保留）

转义字符	意义
\N{id}	Unicode数据库ID
\uhhhh	Unicode 16位的十六进制值
\Uhhhhhhhh	Unicode 32位的十六进制值
\xhh	十六进制值
\ooo	八进制值

如果希望反斜杠被当作普通字符处理，可以使用原始字符串（raw string），即在字符串前加 r 或 R：

myfile = open(r'C:\new\text.dat', 'w')

⚠️ 注意：原始字符串不能以奇数个反斜杠结束，因为反斜杠会转义后续的引号。如需在原始字符串末尾保留反斜杠，可以采用分片或拼接的方式。

3.2 多行字符串与基本操作

三重引号（""" 或 '''）用于创建多行字符串，非常适合嵌入大段文本或文档字符串：

mantra = """Always look
on the bright
side of life."""
print(mantra)
# 输出
Always look
on the bright
side of life.
"""
This is a multi-line comment or docstring.
It can span multiple lines.
"""
X = 1
"""
import os
print(os.getcwd())
"""
Y = 2

字符串的基本操作包括：

• 长度计算：len('abc') 返回 3
• 合并：使用 + 操作符，如 'abc' + 'def'
• 重复：使用 * 操作符，如 'Ni!' * 4
• 遍历：使用 for 循环逐个字符处理

myjob = "hacker"
for c in myjob:
print(c, end=' ')
# 输出: h a c k e r
- in表达式：可以使用in关键字测试字符或子字符串是否存在于字符串中。
'k' in myjob  # 输出: True
'z' in myjob  # 输出: False
'spam' in 'abcspamdef'  # 输出: True

3.3 索引与切片

Python字符串支持强大的索引和切片操作，语法为 str[start:end:step]：

• start：起始索引（包含），默认为0
• end：结束索引（不包含），默认为字符串长度
• step：步长（间隔），默认为1

示例	说明
str[1:4]	从索引1到3（不包括4）
str[1:4:2]	从索引1到3（不包括4），每隔一个
str[-4:-1]	从倒数第4到倒数第2
str[1:-1]	去掉第一个和最后一个
str[:]	完整复制（浅拷贝）
str[::-1]	反转（最常用负步长）

切片操作也适用于列表和元组，是Python中非常实用的功能。与其他语言（如JavaScript）不同，Python的切片支持负数索引和步长，灵活性更高。

3.4 字符串转换工具

Python提供了多种字符串转换工具，方便在不同数据类型之间切换：

函数	描述	示例代码	示例结果	注意事项
int()	将字符串转换为整数。	int(“42”)	42	字符串必须是有效的整数表示形式，否则会引发 ValueError。
str()	将数字（整数或浮点数）转换为字符串。	str(42) str(3.1415)	‘42’ ‘3.1415’	适用于所有类型的对象，返回对象的字符串表示。
repr()	将对象转换为其字符串形式，返回的结果通常可以重新创建该对象。	repr(42)	‘42’	与 str() 类似，但 repr() 的输出更侧重于提供一个明确的、可被Python解释器识别的表示形式，常用于调试。
float()	将字符串转换为浮点数。	float(“1.5”) float(“1.234E-10”)	1.5 1.234e-10	字符串必须是有效的浮点数表示形式（包括科学计数法），否则会引发 ValueError。
eval()	运行一个包含Python表达式代码的字符串，并返回其结果。	eval(“42 + 1”)	43	安全性风险：eval() 可以执行任意代码，在处理不可信输入时非常危险。性能：相比 int() 和 float()，eval() 更慢。通常应避免使用，除非有特殊需求。
ord()	将单个字符转换为其对应的ASCII码（或Unicode码点）。	ord(‘s’) ord(‘5’) - ord(‘0’)	115 5	参数必须是长度为1的字符串。可用于手动解析数字字符串或进行字符编码转换。
chr()	将ASCII码（或Unicode码点）转换为对应的字符。	chr(115)	‘s’	是 ord() 的逆操作。
bin()	将整数转换为二进制字符串表示。	bin(13)	‘0b1101’	返回的字符串以 ‘0b’ 开头，表示二进制。

四、字符串方法：修改与解析

由于字符串是不可变的，所有修改操作都会返回一个新的字符串。掌握这些方法能大幅提升文本处理效率。

4.1 修改字符串

replace() 方法是最常用的替换工具：

str.replace(old, new[, count])

• old：要被替换的子字符串
• new：用于替换的新字符串
• count：可选参数，指定最多替换次数（默认为全部替换）

关键特性：

• ✅ 原字符串不变，返回新字符串
• ✅ 基于非重叠匹配（如 'aaaa' 中查找 'aa' 只找到2个）
• ✅ 空字符串作为 old 时，会在每个字符间插入 new

S = 'spammy'
S = S.replace('mm', 'xx', 1)
print(S)  # 输出: 'spaxxy'
# old 是空字符串 '':空字符串 '' 被认为存在于每个字符之间、开头和结尾。
s = "abc"
result = s.replace("", "X")
print(result)  # "XaXbXcX"
# new 是空字符串 ''：相当于删除
s = "hello123world456"
result = s.replace("123", "")
print(result)  # "helloworld456"

对于复杂替换，可以结合 find() 和 replace() 实现：

find(sub)返回子字符串sub在字符串中首次出现的位置索引。如果未找到，则返回
# find用法示例
S = 'xxxxSPAMxxxxSPAMxxxx'
where = S.find('SPAM')
print(where)  # 输出: 4
# find和replace 示例
S = 'xxxxSPAMxxxxSPAMxxxx'
where = S.find('SPAM')
S = S[:where] + 'EGGS' + S[where+4:]
print(S)  # 输出: 'xxxxEGGSxxxxSPAMxxxx'

如果需要进行多次修改，建议将字符串转为列表，修改后再用 join() 合并：

S = 'spammy'
L = list(S)
L[3] = 'x'
L[-1] = 'y'
S = ''.join(L)
print(S)  # 输出: 'spamxy'

4.2 高效连接字符串

对于大量字符串的连接，join() 方法比加号连接更高效：

result = 'SPAM'.join(['eggs', 'sausage', 'ham', 'toast'])
print(result)  # 输出: 'eggsSPAMsausageSPAMhamSPAMtoast'

多种连接方式对比：

• 方法一：使用加号 +
• 方法二：使用 join()
• 方法三：使用 f-string（Python 3.6+ 推荐）
• 方法四：使用 format() 方法

first_name = "ada"
last_name = "lovelace"
full_name = first_name + " " + last_name
print(full_name)   # 输出：ada lovelace

words = ["Hello", "World"]
result = " ".join(words)
print(result)  # 输出: Hello World
# 没有分隔符
result_no_space = "".join(words)
print(result_no_space)  # 输出: HelloWorld

name = "World"
result = f"Hello {
name}"
print(result)  # 输出: Hello World

name = "World"
result = "Hello {}".format(name)
print(result)  # 输出: Hello World
# 多个参数
first = "Hello"
second = "World"
result = "{} {}".format(first, second)
print(result)  # 输出: Hello World

在性能敏感的场景（如处理数千条记录）中，join() 和 f-string 是更好的选择，这与Go或C++中的字符串构建策略类似。

4.3 文本解析与常见方法

split() 方法用于将字符串按分隔符拆分为列表：

参数	说明
sep（可选）	分隔符。可以是任意长度的字符串。 • 默认为 None：按任意空白字符（空格、换行 \n、制表符 \t 等）分割，忽略开头/结尾空白，连续空白视为一个分隔符。 • 指定 sep（如 ‘,’ 或 ‘–’）：严格按该字符串分割，不忽略首尾分隔符，连续分隔符会产生空字符串 ‘’。
maxsplit（可选）	最大分割次数。 • 默认为 -1：不限制，全部分割。 • 若为 n（≥0），则最多分割 n 次，结果列表最多有 n+1 个元素，剩余部分整体保留。

场景	行为特点
sep=None（默认）	智能分割空白：" a b " → [‘a’, ‘b’]
sep=’ '（显式空格）	严格按空格分割：" a b " → [‘’, ‘’, ‘a’, ‘’, ‘b’, ‘’, ‘’]
连续分隔符	sep=‘,’ 时：“a,b” → [‘a’, ‘’, ‘b’]
maxsplit=1	“a-b-c-d”.split(‘-’, 1) → [‘a’, ‘b-c-d’]

其他常见字符串方法：

方法	语法	功能描述	参数说明	返回值	示例
strip()	str.strip([chars])	移除字符串开头和结尾的指定字符（默认为空白字符）。	chars (可选): 指定要移除的字符集合。如果省略，则移除所有空白字符（空格、换行\n、制表符\t等）。	返回一个新字符串，原字符串不变。	" hello ".strip() -> ‘hello’ “xxhelloxx”.strip(‘x’) -> ‘hello’
lstrip()	str.lstrip([chars])	移除字符串开头的指定字符（默认为空白字符）。	chars (可选): 指定要移除的字符集合。	返回一个新字符串，原字符串不变。	" hello".lstrip() -> ‘hello’ “xxhello”.lstrip(‘x’) -> ‘hello’
rstrip()	str.rstrip([chars])	移除字符串结尾的指定字符（默认为空白字符）。	chars (可选): 指定要移除的字符集合。	返回一个新字符串，原字符串不变。	"hello ".rstrip() -> ‘hello’ “helloxx”.rstrip(‘x’) -> ‘hello’
find()	str.find(sub[, start[, end]])	在字符串中查找子字符串 sub 的首次出现位置。	sub: 要查找的子字符串。 start (可选): 搜索的起始索引。 end (可选): 搜索的结束索引。	找到时返回索引位置（从0开始）。未找到时返回 -1。	“hello”.find(‘e’) -> 1 “hello”.find(‘x’) -> -1 “hello world”.find(‘o’, 5) -> 7
index()	str.index(sub[, start[, end]])	在字符串中查找子字符串 sub 的首次出现位置。	sub: 要查找的子字符串。 start (可选): 搜索的起始索引。 end (可选): 搜索的结束索引。	找到时返回索引位置（从0开始）。未找到时引发 ValueError 异常。	“hello”.index(‘e’) -> 1 “hello”.index(‘x’) -> ValueError
startswith()	str.startswith(prefix[, start[, end]])	检查字符串是否以指定的 prefix 开头。	prefix: 要检查的前缀（可以是字符串或字符串元组）。 start (可选): 检查的起始索引。 end (可选): 检查的结束索引。	如果字符串以 prefix 开头，则返回 True，否则返回 False。	“hello”.startswith(‘he’) -> True “hello”.startswith((‘h’, ‘H’)) -> True
endswith()	str.endswith(suffix[, start[, end]])	检查字符串是否以指定的 suffix 结尾。	suffix: 要检查的后缀（可以是字符串或字符串元组）。 start (可选): 检查的起始索引。 end (可选): 检查的结束索引。	如果字符串以 suffix 结尾，则返回 True，否则返回 False。	“hello”.endswith(‘lo’) -> True “hello”.endswith((‘lo’, ‘world’)) -> True
upper()	str.upper()	将字符串中的所有小写字母转换为大写字母。	无	返回一个新字符串，原字符串不变。	“Hello”.upper() -> ‘HELLO’
lower()	str.lower()	将字符串中的所有大写字母转换为小写字母。	无	返回一个新字符串，原字符串不变。	“Hello”.lower() -> ‘hello’
title()	str.title()	将每个单词的首字母都改为大写

s = "xyxxyy Hello World yxyxxy"
print(s.strip('xy'))     # ' Hello World '
print(s.lstrip('xy'))    # ' Hello World yxyxxy'
print(s.rstrip('xy'))    # 'xyxxyy Hello World '
# 不是删除整个 'xy' 子串，而是逐个字符判断是否在 'xy' 中。
# 所以 strip('xy') 会从两边不断删除 'x' 或 'y'，直到遇到 ' ' 或 'H'/'d' 等不在 'xy' 中的字符为止

五、字符串格式化：从基础到高级

Python提供了多种字符串格式化方式，让你的输出更加灵活美观。

5.1 格式化代码与字典

格式化代码（如 %s、%d）是最传统的格式化方式：

代码	意义
s	字符串（或任何对象）
r	s，但使用 repr() 而不是 str()
c	字符
b	二进制整数
d	十进制（整数）
i	整数
u	无符号整数（在Python 3中已废弃，等同于d）
o	八进制整数
x	十六进制整数（小写）
X	十六进制整数（大写）
e	浮点指数表示法（小写’e’）
E	浮点指数表示法（大写’E’）
f	浮点十进制表示法
F	浮点十进制表示法（与f相同，但在某些情况下可能更精确）
g	浮点表示法，自动选择e或f，以更紧凑的形式显示
G	浮点表示法，自动选择E或F，以更紧凑的形式显示
%	常量%

基于字典的格式化允许通过键名引用值，提高可读性：

>>> "%(n)d %(x)s" % {
"n":1, "x":"spam"}
'1 spam'

# 通过构建一个包含占位符的模板字符串reply和一个包含实际值的字典values，可以一次性将所有占位符替换为对应的值
>>> reply = """
Greetings...
Hello %(name)s!
Your age squared is %(age)s
"""
>>> values = {
'name': 'Bob', 'age': 40}
>>> print(reply % values)
Greetings...
Hello Bob!
Your age squared is 40

5.2 通过变量名访问变量

Python支持在格式化字符串中直接访问变量名：

>>> food = 'spam'
>>> age = 40
>>> vars()
{
'food': 'spam', 'age': 40, ...many more... }
>>>

在Python 3.6+中，f-string 是最推荐的格式化方式，它简洁、高效且支持表达式。相比之下，TypeScript和Java的模板字符串也提供了类似功能，但Python的f-string更直观。

[AFFILIATE_SLOT_1]

六、总结与最佳实践

本文从变量命名、数字类型到字符串操作，系统梳理了Python基础知识点。以下是关键要点：

• ✅ 变量命名要遵循规则，保持描述性
• ✅ 小数和分数类型适用于高精度计算场景
• ✅ 字符串是不可变的，所有修改操作返回新字符串
• ✅ 切片和 join() 是Python文本处理的核心工具
• ✅ 掌握多种格式化方式，根据场景选择最合适的（推荐f-string）

持续练习是掌握Python的关键。建议从简单的字符串操作开始，逐步挑战更复杂的文本处理任务。与其他语言（如JavaScript、Go）相比，Python的字符串处理更加直观和高效，这也是它成为数据科学和Web开发首选语言的原因之一。

[AFFILIATE_SLOT_2]

希望这篇文章能帮助你夯实Python基础。如果你有任何问题或建议，欢迎在评论区留言交流！