可以说在现代编程语言里，Python算是最适合新手入门的语言了。它功能强大，语法简洁，因此，有不少大学的计算机课程都选择了Python作为教学语言。

主包在过去两年内已经被各类同学朋友问到相关内容无数次了。既然已经被问到这么多次了，那么就不如把这些内容都写成文章，方便以后直接发给需要的人。同时自己也能够系统性整理一下Python相关的内容，由简到难。

文章的内容会比较多，同时也会尽量贴近初学者的需求来写，所以如果你是一个完全没有编程经验的同学，那么这篇文章应该能够帮助到你。如果你是老手，那么前面的内容可能会比较基础，可以试着挑着看😋

我计划将整个文章分为_大部分：

  1. Python基础：Python的基本语法是怎样的？核心数据结构有哪些？控制流是怎样的？函数是怎么定义和使用的？想要理解更深入的Python，首先要掌握这些基础内容。

    如果你在学校里正在学习Python，那么这些内容应该是你课程的核心部分了。学好这些内容理论来讲能够让你在各种场景下游刃有余了。但想要拿到全满当然还不够：

  2. 数据结构与算法：深入之前，我们需要先了解一下Python里常用的数据结构和算法。例如，什么是列表、链表、哈希表、堆、栈、队列等其他常见的数据结构？我们如何将数据进行排序？有名的递归为什么这么难以理解？

    对于大学生来说，你要掌握这些内容才能真正拿下你的Python课程。像递归，排序算法这种简单的入门数据结构与算法内容，会非常容易和Python相关的语法混在一起考察。你可能会被要求在考试中手写相关代码来实现它们。

  3. Python进阶：你有听说过Module，Lambda，Decorator这些Python里非常重要的概念吗？Iterator这么好用的东西你会用吗？正则表达式又是什么东西？还有变量的作用域为什么对更深层次的内容理解很重要？

    相比刚才的内容，这些内容一般不会在你的考试中被提及。但是如果你以后要走CS或者编程相关的道路，想要使用Python作为你的主要语言，继续跟着文章学习下去，那么这些内容也是你必须要掌握的。

  4. 面向对象编程：Java和C#能做到的，我们Python怎么能不做到？在这里我们来理解什么是类，对象，封装，继承，多态等面向对象编程的核心概念。

    这一部分与其说是纯纯的Python课，不如说是一个使用Python来讲解面向对象编程的部分。因为当今的主流编程语言基本上都是面向对象，所以理解面向对象编程的核心概念也是非常重要的。

  5. Python生态系统：Python的社区非常活跃，生态也非常丰富。我们来看看Python可以使用的包管理器，以及常用的第三方库和框架。除此之外，Python作为现代语言也包含很多技巧和语法糖，例如List Comprehension，Generator，Context Manager等内容。

  6. 挑个框架吧：正因为如此丰富的生态系统，Python在各个领域都有非常流行的框架。例如Plotly Dash, Pyramid作为Synchronous Web Framework的代表，Gevent, Tornado等作为Asynchronous Web Framework的代表。当然还有Fast API, Django和Flask等全能型框架的代表。

    这方面的内容就要领着你去看看Python能够在实战中做什么了，毕竟俗话说技多不压身嘛。

  7. 处理并发：眼馋Java和C#的多线程吗？在Python中我们有自己处理并发的方式，例如多线程，多进程，协程等内容。虽然Python的GIL限制了多线程的性能，但我们还是可以通过其他方式来实现并发。

  8. 环境：环境决定了Python的运行方式。Pipenv, Virtualenv, pyenv, 以及目前最流行的Conda等工具都可以帮助我们管理Python的环境和依赖。了解这些工具的使用方法对于开发和部署Python应用程序非常重要。

  9. 静态类型：虽然Python是一种动态类型语言，但近年来，随着类型提示（Type Hints）的引入，Python也开始支持静态类型检查。我们来看看如何使用类型提示，以及一些流行的静态类型检查工具，如mypy。

  10. 代码格式化：你现在已经是一个成熟的Python开发者了，你应该学会怎么样写出养眼的Python代码了。咱们来看看yapf, black, ruff等工具，能够帮助你自动格式化代码，让你的代码看起来更整洁，更专业。

  11. 加油啊，写文档的大哥哥：喜欢写文档来混贡献嘛？咱们来看看Sphinx, MkDocs等工具，能够帮助你写出漂亮的文档来展示你的Python项目。

  12. 文件操作：虽然说文件操作应该往前排一排，但是考虑到它更偏向于实战内容，所以就放在了最后了。我们来看看Python是如何进行文件操作的，包括读写文件，处理文件路径，以及使用os和shutil等模块来进行更高级的文件操作。

  13. 测试：你终于学会了Python的各种功能，已经开始开发自己的项目了。为了让你的项目更加健壮，你需要学会如何使用测试来达到上乘的代码质量。在这里我们会提到tox, pyUnit/unittest, docTest, pytest等工具，来帮助你写出高质量的测试代码。

至此，你就可以说自己是一个Python开发者了！虽然说过程比较漫长，但是实际上每个部分的内容都不算特别难，主要是需要你花时间去理解和练习。

我不是很想使用很学术严谨的风格来写这篇文章。不如说，我希望能够通过这篇文章来帮助到更多的同学朋友们，所以我的语言会更加通俗，更口语化一些，毕竟李姐万岁，知识进脑子了就是好学兄弟好学，那还说啥了。

喜闻乐见的叠甲环节：因为作者也和大多数人一样，也是技术的学习者，因此文章内也难免出现或多或少，甚至可笑的错误。欢迎朋友们在评论区指出。

想成为Python开发者吗？

考虑到绝大多数读到这个文章的人不仅仅是应付考试，所以我们先来介绍一下，Python开发者是什么样子的。

Python开发者是指使用Python构建Web服务，自动化任务，或者进行数据分析以及其他相关工作的软件开发者。虽然说具体的职责会根据大家的项目、公司和履历而有所不同，但总的来说，Py开发者通常需要编写高效的代码，解决问题，管理数据结构（尤其是数据科学人士），写优化算法以及使用各种Python库和框架来完成他们的工作。

所以想要师出有名，想要成为Python开发者的话，首先要学会Python的基础语法和核心数据结构，然后逐步深入到更高级的内容，例如面向对象编程，Python生态系统，以及处理并发等内容。最后还要学会如何使用各种工具来管理环境，格式化代码，以及写测试等等。也就是刚才上面我的目录。

Python算前端后端？

Python既可以用来开发前端，也可以用来开发后端。但由于浏览器原生支持的唯一语言是JavaScript，我们一般说Python是一种后端语言。在后端，Python可以用来构建Web服务，处理数据，进行自动化任务等等。

虽然说Python也有一些前端框架，例如Brython和Transcrypt，但它们并不如JavaScript在前端领域的地位那么稳固。而且也会给已经很复杂的实现增加额外的依赖项和复杂性，所以一般来说，我们还是把Python主要看作是一种后端语言。

Python基础

准备好了就开始吧。

Python基础语法

首先，你需要理解Python是一个解释型语言，这意味着你不需要编译代码就可以直接运行它。只要拥有Python解释器，你就可以在任何地方运行Python代码。

下面的内容是你能够理解更进阶内容的基础，所以一定要好好理解哦。有点偏干货，不过也不算特别难，主要是需要你花时间去理解：

交互模式编程

Python提供了交互式编程环境，你可以在命令行输入Python代码并立即看到结果。如果你在电脑上安装了Python并配置好了环境变量，那么你可以打开终端，输入python或者python3来进入Python的交互模式。

在这里，我们使用Bash来展示交互模式的使用：

1
2
3
4
$ python3
Python 3.10.6 (main, Mar 10 2023, 10:55:28) [GCC 11.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

这里>>>表示一个Python命令提示符，我们可以在这三个大于号后面输入Python代码并立即看到结果。例如：

1
>>> print("Hello, World!")

输出：

1
Hello, World!

print函数是Python中最常用的输出函数，它可以将你想要输出的内容显示在屏幕上。你可以使用它来输出字符串，数字，变量等等。

脚本模式编程

除了交互模式，Python还支持脚本模式编程。你可以将Python代码写在一个文件中，然后通过命令行运行这个文件来执行代码。

可以调用带有脚本参数的Python解释器来运行脚本，解释器会读取文件中的代码并执行它，直到文件中的代码执行完毕或者遇到错误为止。例如，我们创建一个名为hello.py的文件，内容如下：

1
print("Hello, World!")

然后在命令行中运行这个文件：

1
$ python3 hello.py

你会看到：

1
Hello, World!

标识符

标识符是一种用来标识变量，函数，类，模块或其他对象的名称。简单来说，标识符就是你在代码中用来命名各种元素的名字。

在Python中，标识符必须遵循以下规则：

  • 以字母A到Z，或字母a到z %开头，或者以emp 下划线_开头

  • 后续字符可以是字母A到Z，字母a到z，数字0到9，或者下划线_

  • 不能使用Python的内置关键字（例如if, else, for, while等）作为标识符

大小写敏感

在Python中，标识符对大小写敏感。例如myVariable和myvariable是两个不同的标识符。这是两个不同的变量。

内置关键字

刚才我们说不能够使用Python的内置关键字作为标识符，下面是Python的内置关键字列表：

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

这些关键字在Python中有特殊的意义，不能用作变量名或函数名等标识符。例如，你不能写if = 5，因为if是一个关键字，用于控制流语句。

行与缩进

你可能见过有些编程语言会使用分号;来表示一行代码的结束，或者使用大括号{}来表示代码块的开始和结束。

但是在Python中，我们没有那么严格的语法要求。Python使用换行符来表示一行代码的结束，使用缩进来表示代码块的开始和结束。按一下Tab键就可以打出一个缩进。这种设计使得Python的代码看起来非常简洁和易读：

1
2
3
4
if True:
    print("This is true")
else:
    print("This is false")

如果有多行代码采用同样的缩进，那么它们就被认为是同一个代码块的一部分。例如：

1
2
3
4
5
6
if True:
    print("This is true")
    print("This is still true")
else:
    print("This is false")
    print("This is still false")

在同样代码块的代码会按顺序一起执行。

多行语句

有时候你可能会写一行特别特别长的代码，超过了屏幕的宽度，导致代码读起来非常困难。就好比：

1
long_variable_name = "This is a very long string that exceeds the typical line width and makes the code harder to read, especially when you have to scroll horizontally to see the entire line. This can be quite inconvenient and can lead to mistakes when trying to understand the code. If you find yourself writing code like this, then you must find the nearest wall and bang your head against it until you understand that you should break this long line into multiple shorter lines for better readability."

如果哥们们写了这么长的一行代码，那么你就需要学会如何把它分成多行来写了。Python提供了两种方式来实现多行语句：

  1. 使用反斜杠\：你可以在行末使用反斜杠来表示当前行未结束，下一行是当前行的继续。例如：
1
2
total = item_one + item_two + item_three + \
        item_four + item_five

实际上和下面的代码是等效的：

1
total = item_one + item_two + item_three + item_four + item_five
  1. 使用括号：你也可以使用圆括号()，方括号[]，或者花括号{}来包裹多行代码，这样Python会自动将它们视为一个整体。例如：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
total = (item_one + item_two + item_three +
         item_four + item_five)

my_list = [
    item_one,
    item_two,
    item_three,
    item_four,
    item_five
]

my_dict = {
    "key_one": value_one,
    "key_two": value_two,
    "key_three": value_three,
    "key_four": value_four,
    "key_five": value_five
}

使用括号的方式通常更推荐，因为它更清晰，更不容易出错。反斜杠的方式虽然也可以实现多行语句，但如果不小心忘记了反斜杠，或者在反斜杠后面有空格，那么就会导致语法错误。

引用与转义符

你可以使用单引号 ('')，双引号 ("")，或者三引号 (''' ''' 或 """ """) 来表示字符串。单引号和双引号的使用没有区别，你可以根据自己的喜好来选择使用哪一种。例如：

1
2
3
4
message = 'Hello, World!'
message = "Hello, World!"
message = '''Hello, World!'''
message = """Hello, World!"""

三引号通常用于表示多行字符串或者文档字符串。例如：

1
2
3
4
multi_line_string = '''This is a multi-line string.
It can span multiple lines without needing to use newline characters.
This is very convenient for writing long strings or documentation.'''

你也可以在字符串中使用转义字符来表示特殊的字符。例如：

1
2
newline = "This is a string with a newline character.\nSee, it goes to the next line"
print(newline)

输出：

1
2
This is a string with a newline character.
See, it goes to the next line

如果你想在字符串中使用引号本身，你可以使用不同类型的引号来包裹字符串。例如：

1
2
quote = "She said, 'Hello!'"
quote = 'She said, "Hello!"'

或者你也可以使用转义字符来表示引号。例如：

1
2
quote = 'She said, \'Hello!\''
quote = "She said, \"Hello!\""

相同的道理，如果你想在字符串中使用反斜杠\，你也需要使用转义字符来表示它。例如：

1
2
path = "C:\\Users\\Username\\Documents\\file.txt"
print(path)

输出：

1
C:\Users\Username\Documents\file.txt

注释

如果你在你的代码中写了注释，那么这些注释内容是不会被Python解释器去执行的。因此我们经常使用注释来在代码中添加一些说明性的文字，来帮助自己或者其他人更好地理解代码的意图和功能。

在Python中，单行注释使用井号#来表示。例如：

1
2
# 这是一个单行注释
print("Hello, World!")  # 这也是一个单行注释

当然如果你想写多行注释的话，你可以使用连续的单行注释，或者使用三引号来表示多行字符串（虽然它们并不是真正的注释，但在没有被赋值给变量的情况下，它们也不会被执行）。例如：

1
2
3
4
5
6
7
8
9
'''
这是一个多行注释
可以用来写很长的说明文字
'''

# 这也是一个多行注释
# 可以用来写很长的说明文字

print("Hello, World!")

输出：

1
Hello, World!

单行多语句

虽然说我们通常每行代码只写一条语句，但有时候你可能会想在同一行写多条语句来省点事。

在Python中，你可以使用分号;来分隔多条语句，使它们在同一行上执行。例如：

1
2

print("Hello"); print("World"); print("This is Python")

输出：

1
2
3
Hello
World
This is Python

套件

套件(Suite) 指的是一组语句组成的代码块，这些语句在一起执行。套件通常出现在控制流语句（如if、for、while等）或者函数定义中。例如：

1
2
3
4
5
6
7
8
9
10
11
12
13
if expression:
    # 这是一个套件
    statement1
    statement2
    statement3
elif expression:
    # 这是另一个套件
    statement4
    statement5
else:
    # 这是第三个套件
    statement6
    statement7

和刚才我们讲缩进的内容一样，套件中的语句必须具有相同的缩进级别，这样Python才能正确地识别它们属于同一个代码块。

命令行参数

有时候你可能会想要在运行Python脚本的时候传递一些参数来控制脚本的行为。Python提供了一个内置的模块叫做sys，它包含了一个叫做argv的列表，这个列表中包含了命令行参数。

当你运行一个Python脚本时，argv列表的第一个元素（argv[0]）是脚本的名称，后续的元素（argv[1], argv[2], ...）是你在命令行中传递的参数。例如：

1
2
3
4
import sys
print("Script name:", sys.argv[0])
print("First argument:", sys.argv[1])
print("Second argument:", sys.argv[2])

如果你在命令行中运行这个脚本，并传递一些参数：

1
$ python3 script.py arg1 arg2

你就会看到输出：

1
2
3
Script name: script.py
First argument: arg1
Second argument: arg2

在交互模式中，你也可以直接查看Python解释器的帮助信息来了解更多关于命令行参数的内容。例如：

1
2
3
4
5
6
7
8
9
$ python3 -h
usage: python3 [option] ... [-c cmd | -m mod | file | -] [arg] ...
Options and arguments (and corresponding environment variables):
-c cmd : program passed in as string (terminates option list)
-d     : debug output from parser (also PYTHONDEBUG=x)
-E     : ignore environment variables (such as PYTHONPATH)
-h     : print this help message and exit

[ etc. ]

如果你是备考来的，那么你一般用不到这些东西。

变量与数据类型

了解上方的内容之后，我们来快速看看什么是变量，什么是数据类型。应该是比较好理解的。

变量

变量是用来存储数据的容器。你可以把它看作是一个标签，指向某个特定的数据值。在Python中，你不需要声明变量的类型，直接给变量赋值就可以了。例如：

1
2
3
a = 10
b = "Hello, World!"
c = 3.14

在这个例子中，我们创建了三个变量：a，b，和c。变量a存储了一个整数值10，变量b存储了一个字符串值"Hello, World!"，变量c存储了一个浮点数值3.14。

在py里面，变量赋值是通过引用来实现的。这意味着当你将一个值赋给一个变量时，变量实际上是指向那个值的内存地址，而不是直接存储值本身。这也是为什么Python中的变量可以动态改变类型的原因之一。

还记得我们之前说过的标识符吗？变量名就是一种标识符，它必须遵循标识符的命名规则。

啊对了，py实际上允许你创建无限多的变量，唯一的限制是你计算机的内存。所以你可以创建成千上万个变量来存储数据，但要注意不要滥用变量，以免导致代码混乱和难以维护。

变量的动态类型

在Python中，变量是动态类型。这意味着你可以在程序的不同部分给同一个变量赋予不同类型的值。例如：

1
2
3
4
x = 42          # x现在是一个整数
print(x)        # 输出: 42
x = "Now I'm a string!"  # x现在是一个字符串
print(x)        # 输出: Now I'm a string!

与其他语言相比，Python的变量赋值非常灵活，你可以随时改变变量的类型，这也是Python的一大特点。你可以利用这一点来编写更简洁的代码，但也要注意不要滥用这种特性，以免导致代码难以理解和维护。

数据类型

数据类型是指数据的种类或者类型。就像我们在数学中有整数、实数、复数等不同的数据类型一样，在编程语言中也有各种各样的数据类型来表示不同种类的数据，而不同的数据类型有不同的属性和方法来操作它们。

Python有很多内置的数据类型，常用的有整数（int），浮点数（float），字符串（str），布尔值（bool）等等。例如：

1
2
3
4
x = 42          # 整数
y = 3.14        # 浮点数
name = "Alice"  # 字符串
is_valid = True # 布尔值

在Python中，你可以使用内置的type()函数来查看一个变量的数据类型。例如：

1
2
3
4
print(type(x))        # <class 'int'>
print(type(y))        # <class 'float'>
print(type(name))     # <class 'str'>
print(type(is_valid)) # <class 'bool'>

不同的数据类型有不同的属性和方法，你可以使用这些属性和方法来操作数据。例如，字符串类型有很多内置的方法，例如upper()，lower()，split()等等，可以用来处理字符串数据。

考虑到字符串处理一直是考试的常见考点，并且到实际生产环境中也是非常常见的需求，所以下一节我们来看看具体如何处理这些字符串。

字符串处理

实际上初阶字符串处理方式已经在刚才的内容中提到了一些了，如果你不知道什么是字符串，引号嵌套，多行字符串，字符串赋值，转义字符等等内容的话，那么你就需要回去好好看看上面的内容了。

字符串的内置方法

要理解内置方法，我们首先要知道字符串在python中的本质。

和很多其他编程语言类似，Python中的字符串是由unicode字符组成的数组(List)。每个字符在字符串中都有一个索引位置，索引从0开始。例如：

1
2
3
my_string = "Hello, World!"
print(my_string[0])  # 输出: H
print(my_string[7])  # 输出: W

在python中，我们使用 0-indexing 来访问字符串中的字符，这意味着第一个字符的索引是0，第二个字符的索引是1，以此类推。

len()

最常用的一个内置方法就是len()函数，它可以用来获取字符串的长度。例如：

1
2
my_string = "Hello, World!"
print(len(my_string))  # 输出: 13

in

想要检查字符串中有没有出现某个子字符串，我们可以使用in关键字。例如：

1
2
3
my_string = "Hello, World!"
print("Hello" in my_string)  # 输出: True
print("Python" in my_string)  # 输出: False

相反，如果你想要检查字符串中没有出现某个子字符串，你可以使用not in关键字。例如：

1
2
3
my_string = "Hello, World!"
print("Python" not in my_string)  # 输出: True
print("Hello" not in my_string)   # 输出: False

str()

如果你想要将其他类型的数据转换为字符串，你可以使用str()函数。例如：

1
2
3
4
number = 42
pi = 3.14
print(str(number))  # 输出: '42'
print(str(pi))      # 输出: '3.14'

upper() 和 lower()

如果你想要将字符串转换为大写或者小写，你可以使用upper()和lower()方法。例如：

1
2
3
my_string = "Hello, World!"
print(my_string.upper())  # 输出: 'HELLO, WORLD!'
print(my_string.lower())  # 输出: 'hello, world!'

split()

如果你想要将字符串分割成一个列表，你可以使用split()方法。例如：

1
2
my_string = "Hello, World!"
print(my_string.split())  # 输出: ['Hello,', 'World!']

默认情况下，split()方法会使用空格作为分隔符来分割字符串，但你也可以指定其他的分隔符。例如：

1
2
my_string = "apple,banana,cherry"
print(my_string.split(','))  # 输出: ['apple', 'banana', 'cherry']

strip()

如果你想要去掉字符串两端的空白字符，你可以使用strip()方法。例如：

1
2
my_string = "   Hello, World!   "
print(my_string.strip())  # 输出: 'Hello, World!'

replace()

如果你想要替换字符串中的某个子字符串，你可以使用replace()方法。例如：

1
2
my_string = "Hello, World!"
print(my_string.replace("World", "Python"))  # 输出: 'Hello, Python!'

find()

刚才的in只能告诉你某个子字符串是否存在于字符串中，如果你想要查找字符串中某个子字符串的位置，你可以使用find()方法。例如：

1
2
3
my_string = "Hello, World!"
print(my_string.find("World"))  # 输出: 7
print(my_string.find("Python")) # 输出: -1

find()方法会返回子字符串在字符串中第一次出现的位置的索引，如果子字符串不存在于字符串中，则返回-1。

count()

如果你想要统计字符串中某个子字符串出现的次数，你可以使用count()方法。例如：

1
2
3
4
my_string = "Hello, World! Hello!"
print(my_string.count("Hello"))  # 输出: 2
print(my_string.count("World"))  # 输出: 1
print(my_string.count("Python")) # 输出: 0

startswith() 和 endswith()

如果你想要检查字符串是否以某个子字符串开头或者结尾，你可以使用startswith()和endswith()方法。例如：

1
2
3
4
5
my_string = "Hello, World!"
print(my_string.startswith("Hello"))  # 输出: True
print(my_string.endswith("World!"))   # 输出: True
print(my_string.startswith("World"))  # 输出: False
print(my_string.endswith("Hello"))    # 输出: False

切片

切片允许我们从字符串中提取一个子字符串。我们可以使用索引来指定切片的起始位置和结束位置，例如：

1
2
3
my_string = "Hello, World!"
print(my_string[0:5])  # 输出: 'Hello'
print(my_string[7:12]) # 输出: 'World'

切片的语法是string[start:end]，其中start是切片的起始索引，end是切片的结束索引，不包含end索引位置的字符。如果省略start，默认从字符串的开头开始切片；如果省略end，默认切片到字符串的末尾。例如：

1
2
3
my_string = "Hello, World!"
print(my_string[:5])  # 输出: 'Hello'
print(my_string[7:])  # 输出: 'World!'

当然你也可以使用负数索引来从字符串的末尾开始切片，例如：

1
2
3
my_string = "Hello, World!"
print(my_string[-6:])  # 输出: 'World!'
print(my_string[:-7])  # 输出: 'Hello

或者直接提取最后一个字符：

1
2
my_string = "Hello, World!"
print(my_string[-1])  # 输出: '!'

连接字符串

如果你想要连接两个或者多个字符串，你可以使用加号+运算符。例如：

1
2
3
4
string1 = "Hello"
string2 = "World"
result = string1 + ", " + string2 + "!"
print(result)  # 输出: 'Hello, World!'

与其使用加号，我们也可以选择使用逗号来连接字符串，这样Python会自动在字符串之间添加一个空格。例如：

1
2
3
4
string1 = "Hello"
string2 = "World"
result = string1, ",", string2 + "!"
print(result)  # 输出: ('Hello', ',', 'World!')

在上面的例子中，由于空格的存在，结果是一个包含三个元素的元组，而不是一个单纯的字符串。咱们实际上也可以直接在print中来更清晰地演示：

1
2
3
string1 = "Hello"
string2 = "World"
print(string1, ",", string2 + "!")  # 输出: Hello , World!

你也可以使用join()方法来连接字符串。例如：

1
2
3
string_list = ["Hello", "World"]
result = ", ".join(string_list) + "!"
print(result)  # 输出: 'Hello, World!'

f-string

f-string一直是处理字符串格式的第一大杀器。它允许你在字符串中直接嵌入表达式，并且在运行时会自动计算这些表达式的值。例如：

1
2
3
4
name = "Alice"
age = 30
greeting = f"Hello, my name is {name} and I am {age} years old."
print(greeting)  # 输出: 'Hello, my name is Alice and I am 30 years old.'

如果不使用f-string来达到同样的效果，你可能需要使用字符串的format()方法或者使用字符串连接来实现。例如：

1
2
3
4
name = "Alice"
age = 30
greeting = "Hello, my name is {} and I am {} years old.".format(name, age)
print(greeting)  # 输出: 'Hello, my name is Alice and I am 30 years old.'

由于字符串连接的方式比较麻烦，我就直接懒得写了。

如果你想要在f-string中使用花括号{}，你可以使用双花括号{{}}来表示一个字面量的花括号。例如：

1
2
greeting = f"Hello, my name is {name} and I am {age} years old. {{This is a literal curly brace}}"
print(greeting)  # 输出: 'Hello, my name is Alice and I am 30 years old. {This is a literal curly brace}'

f-string还支持格式化表达式，例如你可以指定数字的格式，或者日期的格式等等。例如：

1
2
3
pi = 3.141592653589793
formatted_pi = f"Pi is approximately {pi:.2f}"
print(formatted_pi)  # 输出: 'Pi is approximately 3.14'

转义符与字符串

不同转义符在字符串中有不同的含义，例如：

转义符 含义
\\ 反斜杠
\' 单引号
\" 双引号
\n 换行符
\r 回车符
\t 制表符
\b 退格符
\f 换页符
\ooo 八进制转义
\xhh 十六进制转义

其中我们之前有提到过最常用的换行符，其他的几个转义符的例子也不算特别难理解：

1
2
3
4
5
6
7
8
9
10
11
# 反斜杠
print("This is a backslash: \\")  # 输出: This is a backslash: \
# 单引号和双引号
print('She said, "Hello!"')  # 输出: She said, "Hello!"
print("It's a nice day!")  # 输出: It's a nice day!
# 制表符
print("Column1\tColumn2\tColumn3")  # 输出: Column1    Column2    Column3
# 退格符
print("Hello, World!\b")  # 输出: Hello, World
# 换页符
print("This is the first page.\fThis is the second page.")  # 输出: This is the first page. This is the second page.

八进制和十六进制转义符可以用来表示特定的字符，例如：

1
2
3
4
# 八进制转义
print("\101")  # 输出: A
# 十六进制转义
print("\x41")  # 输出: A

条件判断

条件判断是编程中非常重要的一部分，它允许我们根据不同的条件来执行不同的代码块。例如：假如发生A，就执行A的代码；假如发生B，就执行B的代码；否则就执行C的代码。

在Python中，我们主要使用if，elif，和else来实现条件判断。例如：

1
2
3
4
5
6
7
x = 10
if x > 0:
    print("x is positive")
elif x < 0:
    print("x is negative")
else:
    print("x is zero")

输出：

1
x is positive

首先我们创建一个变量 x，并将其赋值为10。然后我们使用if语句来检查x是否大于0，如果条件为真，就执行对应的代码块，输出"x is positive"。如果条件不满足，我们使用elif来检查x是否小于0，如果条件为真，就执行对应的代码块，输出"x is negative"。如果前面的条件都不满足，我们使用else来处理其他情况，输出"x is zero"。

注意语句的缩进。我们之前说过什么是缩进了，如果你忘了，回去看看上面的内容哦。

你也可以在条件判断中使用逻辑运算符来组合多个条件，例如：

1
2
3
4
5
6
7
8
x = 10
y = 5
if x > 0 and y > 0:
    print("Both x and y are positive")
elif x > 0 or y > 0:
    print("At least one of x or y is positive")
else:
    print("Neither x nor y is positive")

输出：

1
Both x and y are positive

逻辑运算符

严格来说这是一个通识，不过鉴于它算是CS领域的通识，如果你还没有学过的话，那么我觉得还是有必要在这里提一下的。

在刚才的例子中，我们使用了逻辑运算符and和or来组合条件。如果你不知道逻辑运算符如何计算，那么下面有一张速查表，你可以稍微背一下

A B A and B A or B
True True True True
True False False True
False True False True
False False False False

这样一个表也叫做真值表，它展示了逻辑运算符在不同输入条件下的输出结果。通过理解这个表，你就可以更好地理解如何使用逻辑运算符来组合条件判断。

你也可以使用not运算符来取反一个条件，例如：

1
2
3
4
5
x = 10
if not x < 0:
    print("x is not negative")
else:
    print("x is negative")

输出：

1
x is not negative

而not运算符会将条件的结果取反，如果条件为真，not运算符会返回False；如果条件为假，not运算符会返回True。

多个/单个条件判断

有时候你可能会需要检查多个条件来决定执行哪个代码块。在Python中，你可以使用多个elif来实现多个条件判断。例如：

1
2
3
4
5
6
7
8
9
x = 10
if x > 0:
    print("x is positive")
elif x < 0:
    print("x is negative")
elif x == 0:
    print("x is zero")
else:
    print("This will never be executed")

不是说条件判断必须要包含if-elif-else结构，如果你只有一个条件需要判断，那么你完全可以只使用if语句来实现。例如：

1
2
x = 10
if x > 0: print("x is positive")

输出：

1
x is positive

单行条件判断

甚至你可以把更长的条件判断写成一行来实现，例如：

1
2
x = 10
print("x is positive") if x > 0 else print("x is not positive")

但是单行就不容易塞下多个条件判断啦。如果你想要在单行中实现多个条件判断，你可以使用嵌套的条件表达式来实现。例如：

1
2
3
x = 10
result = "x is positive" if x > 0 else "x is negative" if x < 0 else "x is zero"
print(result)

不过你也发现了，这种写法虽然可以实现多个条件判断，但可读性非常差，不推荐在实际代码中使用。

一般来讲，如果你的条件判断足够简单，只包含一个if，或者if-else结构，那么使用单行条件判断是可以接受的，但如果条件判断比较复杂，包含多个条件或者嵌套的条件，那么还是建议使用多行的if-elif-else结构来实现。

条件表达式

条件表达式不仅仅只有 x > 0 这种简单的条件判断，你也可以在条件表达式中使用更复杂的条件来实现更灵活的逻辑。例如：

1
2
3
4
5
6
x = 10
y = 5
if x - y == 5:
    print("x is greater than y by 5")
else:
    print("x is not greater than y by 5")
两个等号？

在Python中，一个等号和两个等号表示两个不同的含义。一个等号用于赋值，两个等号用于比较。例如对变量进行赋值写成x = 10，而比较则写成x == 10

在条件表达式中，你可以使用任何有效的Python表达式来作为条件，例如：

1
2
3
4
5
6
x = 10
y = 5
if (x > 0 and y > 0) or (x < 0 and y < 0):
    print("x and y have the same sign")
else:
    print("x and y have different signs")

只要表达式返回一个布尔值（True或False），你就可以在条件表达式中使用它来控制代码的执行。

所以说这样的写法也是可以的：

1
2
3
4
5
6
x = 10
y = 5
if True:
    print("This will always be executed")
else:
    print("This will never be executed")

虽然说x和y的值并没有被用来进行条件判断，但条件表达式仍然是有效的，因为它返回了一个布尔值True。

循环

除了判断，有时候我们还需要重复执行某些代码块，这时候就需要用到循环了。

在Python中，有两种主要的循环结构：for循环和while循环。

for

for循环用于遍历一个序列（例如列表、元组、字符串等）或者其他可迭代对象，并对其中的每个元素执行一段代码。例如：

1
2
3
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)

输出：

1
2
3
apple
banana
cherry

在这个例子中，我们创建了一个列表fruits，然后使用for循环来遍历这个列表中的每个元素，并将它们打印出来。

你也可以使用for循环来遍历一个字符串中的每个字符，例如：

1
2
3
my_string = "Hello"
for char in my_string:
    print(char)

输出：

1
2
3
4
5
H
e
l
l
o

for循环还可以与range()函数结合使用来生成一个数字序列，例如：

1
2
for i in range(5):
    print(i)

输出：

1
2
3
4
5
0
1
2
3
4

而在绝大多数计数循环中，我们通常都会使用range()函数，而不是创建一个有相同元素数量的数组来进行迭代。

许可协议

本文采用 署名-非商业性使用-相同方式共享 4.0 国际 许可协议，转载请注明出处。

快来参与讨论吧~