Python学习圣经：从0到1精通Python，打好AI基础

文章很长，且持续更新，建议收藏起来，慢慢读！疯狂创客圈总目录博客园版 为您奉上珍贵的学习资源：

免费赠送 :《尼恩Java面试宝典》 持续更新+ 史上最全 + 面试必备 2000页+ 面试必备 + 大厂必备 +涨薪必备
免费赠送 :《尼恩技术圣经+高并发系列PDF》 ，帮你实现技术自由，完成职业升级，薪酬猛涨！加尼恩免费领
免费赠送经典图书:《Java高并发核心编程（卷1）加强版》 面试必备 + 大厂必备 +涨薪必备加尼恩免费领
免费赠送经典图书:《Java高并发核心编程（卷2）加强版》 面试必备 + 大厂必备 +涨薪必备加尼恩免费领
免费赠送经典图书:《Java高并发核心编程（卷3）加强版》 面试必备 + 大厂必备 +涨薪必备加尼恩免费领

免费赠送资源宝库： Java 必备百度网盘资源大合集价值>10000元加尼恩领取

Python学习圣经：从0到1精通Python，打好AI基础

尼恩：LLM大模型学习圣经PDF的起源

在40岁老架构师尼恩的读者交流群(50+)中，经常性的指导小伙伴们改造简历。

经过尼恩的改造之后，很多小伙伴拿到了一线互联网企业如得物、阿里、滴滴、极兔、有赞、希音、百度、网易、美团的面试机会，拿到了大厂机会。

然而，其中一个成功案例，是一个9年经验网易的小伙伴，当时拿到了一个年薪近80W的大模型架构offer，逆涨50%，那是在去年2023年的 5月。

惊天大逆袭：8年小伙20天时间提75W年薪offer，逆涨50%，秘诀在这

不到1年，小伙伴也在团队站稳了脚跟，成为了名副其实的大模型架构师。

目前，他管理了10人左右的团队，包括一个2-3人的python算法小分队，包括一个3-4人Java应用开发小分队，包括一个2-3人实施运维小分队。并且他们的产品也收到了丰厚的经济回报，他们的AIGC大模型产品，好像已经实施了不下10家的大中型企业客户。

当然，尼恩更关注的，主要还是他的个人的职业身价。

小伙伴反馈，不到一年，他现在是人才市场的香馍馍。怎么说呢？

他现在职业机会不知道有多少, 而是大部分都是P8+ （年薪200W+）的顶级机会。

回想一下，去年小伙伴来找尼恩的时候，可谓是令人唏嘘。

当时，小伙伴被网易裁员，自己折腾 2个月，没什么好的offer，才找尼恩求助。

当时，小伙伴其实并没有做过的大模型架构，仅仅具备一些通用架构（ JAVA 架构、K8S云原生架构）能力，而且这些能力还没有完全成型。

特别说明，他当时没有做过大模型的架构，对大模型架构是一片空白。

本来，尼恩是规划指导小伙做通用架构师的（ JAVA 架构、K8S云原生架构）,

毫无疑问，大模型架构师更有钱途，所以，当时候尼恩也是壮着胆子，死马当作活马指导他改造为大模型架构师。

回忆起当时决策的出发点，主要有3个：

（1）架构思想和体系，本身和语言无关，和业务也关系不大，都是通的。

（2）小伙伴本身也熟悉一点点深度学习，懂python，懂点深度学习的框架，至少，demo能跑起来。

（3）大模型架构师稀缺，反正面试官也不是太懂大模型架构。

基于这个3个原因，尼恩大胆的决策，指导他往大模型架构走，先改造简历，然后去面试大模型的工程架构师，特别注意，这个小伙伴面的不是大模型算法架构师。

没想到，由于尼恩的大胆指导，小伙伴成了。

没想到，由于尼恩的大胆指导，小伙伴成了，而且是大成，实现了真正的逆天改命。

相当于他不到1年时间，职业身价翻了1倍多，可以拿到年薪 200W的offer了。

既然有一个这么成功的案例，尼恩能想到的，就是希望能帮助更多的社群小伙伴，成长为大模型架构师，也去逆天改命。

于是，从2024年的4月份开始，尼恩开始写《LLM大模型学习圣经》，帮助大家穿透大模型，走向大模型之路。

尼恩架构团队的大模型《LLM大模型学习圣经》是一个系列，初步的规划包括下面的内容：

《Python学习圣经：从0到1精通Python，打好AI基础》
《LLM大模型学习圣经：从0到1吃透Transformer技术底座》
《LangChain学习圣经：从0到1精通LLM大模型应用开发的基础框架》
《LLM大模型学习圣经：从0到1精通RAG架构，基于LLM+RAG构建生产级企业知识库》
《SpringCloud + Python 混合微服务架构，打造AI分布式业务应用的技术底层》
《LLM大模型学习圣经：从0到1吃透大模型的顶级架构》

本文是第1篇，作者是资深架构师 Andy（负责初稿） +43岁老架构师尼恩（负责升华，带给大家一种俯视技术，技术自由的高度）。

尼恩架构团队会持续迭代和更新，后面会有实战篇，架构篇等等出来。并且录制配套视频。

在尼恩的架构师哲学中，开宗明义：架构和语言无关，架构的思想和模式，本就是想通的。

架构思想和体系，本身和语言无关，和业务也关系不大，都是通的。

所以，尼恩用自己的架构内功，以及20年时间积累的架构洪荒之力，通过《LLM大模型学习圣经》，给大家做一下系统化、体系化的LLM梳理，使得大家内力猛增，成为大模型架构师，然后实现”offer直提”，逆天改命。

尼恩《LLM大模型学习圣经》PDF 系列文档，会延续尼恩的一贯风格，会持续迭代，持续升级。

这个文档将成为大家学习大模型的杀手锏，此文当最新PDF版本，可以来《技术自由圈》公号获取。

本文目录

第一部分：基础入门

第一章：Python简介

欢迎来到Python编程的世界！Python是一门强大而优雅的编程语言，无论你是编程新手还是有经验的开发者，都能在Python中找到乐趣和挑战。

Python以其简洁易懂的语法和丰富的库而闻名，广泛应用于数据分析、人工智能、Web开发、自动化脚本等各个领域。

在本章中，我们将介绍Python的历史与特点、Python的应用领域以及如何安装和配置Python环境。

通过这部分内容，你将对Python有一个初步的了解，为接下来的学习打下坚实的基础。

1.1 Python的历史与特点

1.1.1 Python的历史

Python是一种由Guido van Rossum于1989年发明的高级编程语言。最初，Guido van Rossum在荷兰的国家研究所工作，设计Python的初衷是为了创建一种易于阅读和编写的编程语言，并且能够处理当时主流的ABC语言不能胜任的任务。

Python的第一个正式版本0.9.0于1991年发布，这个版本已经包含了“模块、异常处理、函数以及核心数据类型”等许多现在仍然重要的功能。
1994年，Python 1.0发布，标志着Python正式进入了主流编程语言的行列。随着社区的发展和需求的变化，Python不断更新和完善：

Python 2.0：发布于2000年，引入了垃圾回收机制和更完善的Unicode支持。
Python 3.0：发布于2008年，对语言进行了大幅度的改进，不完全向后兼容，目的是清理一些历史遗留问题并提升语言的一致性和可读性。

目前，Python的最新版本是Python 3.x，已经成为主流的Python版本。
Python 2.x系列已经停止更新，建议新项目和学习都使用Python 3.x。

1.1.2 Python的主要特点

Python因其简洁、优雅和强大，受到了广泛的欢迎。以下是Python的主要特点：

简洁明了：Python的语法设计简洁明了，代码可读性强。一个典型的Python程序通常比同样功能的C/C++/Java代码更短。
易学易用：Python的学习曲线相对平缓，非常适合初学者。它提供了大量的文档和社区支持，帮助新手快速上手。
解释型语言：Python是一种解释型语言，代码在运行时逐行解释执行，无需编译。这样不仅方便调试，还能快速测试和验证代码。
动态类型：Python是动态类型语言，变量在使用时才确定类型，无需预先声明。
跨平台：Python是一种跨平台语言，支持在Windows、macOS、Linux等多个操作系统上运行，只需一次编写即可在多种环境中使用。
丰富的标准库：Python拥有一个庞大的标准库，涵盖了文件I/O、系统调用、网络编程、Web服务、数据库接口等各个方面，极大地简化了开发工作。
强大的社区支持：Python拥有一个活跃且庞大的社区，提供了丰富的第三方库和工具，使开发者可以方便地扩展Python的功能。

我们可以看到Python是一门经过长期发展和完善的语言，具备了许多现代编程语言的优点，并在多个领域得到了广泛应用。

1.2 Python的应用领域

Python以其简洁的语法和强大的功能，广泛应用于各个领域。以下是Python在一些主要应用领域中的典型使用场景和优势。

1.2.1 Web开发

Python在Web开发领域非常受欢迎，得益于其丰富的框架和库，这些工具极大地简化了Web应用的开发过程。

常用框架和工具

Django：一个功能强大且完备的Web框架，适用于快速开发复杂的大型Web应用。Django提供了诸如ORM（对象关系映射）、身份验证、模板引擎、URL路由等内置功能，极大地减少了开发工作量。
Flask：一个轻量级的Web框架，灵活性高，适用于小型项目和原型开发。Flask提供了基本的Web开发功能，并允许开发者根据需要自由选择和集成第三方库。

示例代码

下面是一个使用Flask开发的简单Web应用示例：

from flask import Flask, render_template

app = Flask(__name__)

@app.route('/')
def home():
    return "Hello, Flask!"

if __name__ == '__main__':
    app.run(debug=True)

保存以上代码为app.py，然后在命令行中运行：

python app.py

打开浏览器，访问http://127.0.0.1:5000/，你将看到页面显示“Hello, Flask!”。

1.2.2 数据分析

Python在数据分析领域同样表现出色，拥有大量专门用于数据处理和分析的库，使得数据分析工作更加高效和便捷。

常用库和工具

pandas：一个强大的数据处理和分析库，提供了高效的数据结构和数据操作功能，尤其适用于结构化数据处理。
NumPy：一个科学计算库，提供了支持多维数组和矩阵运算的大量函数。
Matplotlib：一个绘图库，用于创建静态、动态和交互式可视化图表。

示例代码

下面是一个使用pandas和Matplotlib进行数据分析和可视化的示例：

import pandas as pd
import matplotlib.pyplot as plt

# 创建一个简单的DataFrame
data = {'Month': ['Jan', 'Feb', 'Mar', 'Apr', 'May'],
        'Sales': [200, 220, 210, 250, 270]}
df = pd.DataFrame(data)

# 打印数据表
print(df)

# 绘制销售趋势图
# 使用月份和销售数据绘制折线图
plt.plot(df['Month'], df['Sales'])
# 添加 x 轴标签
plt.xlabel('Month')
# 添加 y 轴标签
plt.ylabel('Sales')
# 添加图表标题
plt.title('Monthly Sales')
# 显示图表
plt.show()

运行上述代码，将生成一个显示月度销售趋势的折线图。

1.2.3 人工智能与机器学习

Python在人工智能（AI）和机器学习（ML）领域的应用非常广泛，得益于其丰富的库和框架，使得开发AI和ML应用变得相对容易。

常用库和工具

TensorFlow：一个由Google开发的开源机器学习框架，用于构建和训练深度学习模型。
PyTorch：一个由Facebook开发的开源深度学习框架，提供了灵活且易于使用的接口。
scikit-learn：一个简单而高效的机器学习库，包含了大量的分类、回归、聚类算法，适用于数据挖掘和数据分析。

示例代码

下面是一个使用scikit-learn进行简单线性回归的示例：

import numpy as np
from sklearn.linear_model import LinearRegression
import matplotlib.pyplot as plt

# 生成数据
X = np.array([1, 2, 3, 4, 5]).reshape(-1, 1)  # 生成输入特征X，reshape(-1, 1)将数组转换成一列
y = np.array([2, 3, 5, 6, 5])  # 生成目标变量y

# 创建线性回归模型并训练
model = LinearRegression()  # 创建线性回归模型
model.fit(X, y)  # 使用输入特征X和目标变量y训练模型

# 预测
y_pred = model.predict(X)  # 使用训练好的模型预测输出

# 绘制结果
plt.scatter(X, y, color='blue')  # 绘制散点图，用蓝色表示
plt.plot(X, y_pred, color='red')  # 绘制拟合直线，用红色表示
plt.xlabel('X')  # 设置x轴标签
plt.ylabel('y')  # 设置y轴标签
plt.title('Linear Regression Example')  # 设置图表标题
plt.show()  # 显示图表

运行上述代码，将生成一个展示线性回归结果的散点图和回归线。

1.2.4 自动化脚本

Python在编写自动化脚本方面也非常有优势，其简洁的语法和强大的库支持，使得开发自动化脚本变得简单而高效。

常用库和工具

os：提供了丰富的操作系统功能，如文件和目录操作。
shutil：提供了高级的文件操作功能，如复制和移动文件。
requests：用于发送HTTP请求，适用于Web抓取和API调用。

示例代码

下面是一个使用os和shutil库进行文件整理的自动化脚本示例：

import os
import shutil

# 定义源目录和目标目录
source_dir = 'C:/Users/Andy/Downloads'
target_dir = 'C:/Users/Andy/Documents/Sorted'

# 创建目标目录
if not os.path.exists(target_dir):
    os.makedirs(target_dir)

# 遍历源目录中的文件
for filename in os.listdir(source_dir):
    file_path = os.path.join(source_dir, filename)
    
    # 判断是否为文件
    if os.path.isfile(file_path):
        # 移动文件到目标目录
        shutil.move(file_path, target_dir)
        print(f'Moved: {filename}')

运行该脚本后，下载目录中的所有文件将被移动到指定的目标目录中。

1.2.5 其他应用领域

除了上述领域，Python还在许多其他领域有广泛的应用，包括但不限于：

网络爬虫：通过编写爬虫程序抓取网络数据，常用库有BeautifulSoup、Scrapy等。
游戏开发：使用Pygame等库进行简单的游戏开发。
系统管理：编写脚本实现系统管理和运维任务。

Python的多功能性和广泛的应用领域，使其成为许多开发者和工程师的首选编程语言。
在接下来的章节中，我们将详细介绍如何安装和配置Python环境，帮助你快速入门Python编程。

1.3 如何安装Python

在开始编写Python程序之前，我们需要先安装Python。在本节中，我们将介绍如何在不同操作系统上安装Python，包括Windows、macOS和Linux。

1.3.1 Windows系统安装

下载Python安装包：

访问Python官网。
点击“Downloads”菜单，根据你的操作系统选择“Download for Windows”。
下载最新的Python安装包。

运行安装包：

双击下载的安装包以启动安装程序。
在安装界面，勾选“Add Python to PATH”选项，这将自动配置环境变量，方便在命令行中使用Python。
点击“Install Now”进行安装。

验证安装：

安装完成后，打开命令提示符（按Win + R，输入cmd，按回车）。
在命令提示符中输入以下命令，验证Python是否安装成功：

python --version

如果显示Python的版本号，说明安装成功。

1.3.2 macOS系统安装

macOS通常预装了Python，但为了使用最新版本的Python，建议手动安装。

使用Homebrew安装Python：

如果尚未安装Homebrew，先打开终端（按Cmd + Space，输入Terminal，按回车），然后输入以下命令安装Homebrew：

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

安装Homebrew后，使用以下命令安装Python：

brew install python

验证安装：

在终端中输入以下命令，验证Python是否安装成功：

python3 --version

如果显示Python的版本号，说明安装成功。

1.3.3 Linux系统安装

大多数Linux发行版都预装了Python，但为了使用最新版本，可以手动安装。

更新包管理器：

打开终端，输入以下命令更新包管理器：

sudo apt update

安装Python：

使用以下命令安装Python：

sudo apt install python3

验证安装：

在终端中输入以下命令，验证Python是否安装成功：

python3 --version

如果显示Python的版本号，说明安装成功。

通过以上步骤，你已经成功在Windows、macOS或Linux系统上安装了Python。接下来，我们将介绍如何配置Python环境，以便更高效地开发Python应用。

1.4 Python环境配置

在安装了Python之后，我们还需要进行一些配置，以便更高效地进行开发。
这些配置包括Python版本管理、虚拟环境管理以及Anaconda的安装与配置。
本节将详细介绍这些概念及其作用，并提供具体的操作步骤。

1.4.1 Python版本管理（pyenv）

1.4.1.1 版本管理的概念和作用

在开发过程中，可能需要使用不同版本的Python来运行不同的项目。例如，一个项目可能需要Python 3.8，而另一个项目可能需要Python 3.9。
这时，管理和切换不同版本的Python就变得非常重要。pyenv是一个用于管理多个Python版本的工具，允许用户轻松安装和切换不同版本的Python。

1.4.1.2 安装和使用pyenv

安装pyenv：

打开终端，输入以下命令安装pyenv：

curl https://pyenv.run | bash

按照提示将以下内容添加到你的shell配置文件（如~/.bashrc或~/.zshrc）：

export PATH="$HOME/.pyenv/bin:$PATH"
eval "$(pyenv init --path)"
eval "$(pyenv init -)"
eval "$(pyenv virtualenv-init -)"

重启终端：

重启终端或运行以下命令以应用配置：

source ~/.bashrc  # 或者 source ~/.zshrc

安装Python版本：

使用pyenv安装所需的Python版本，例如安装Python 3.9.7：

pyenv install 3.9.7

设置全局或局部Python版本：

设置全局默认Python版本：

pyenv global 3.9.7

设置局部Python版本（在项目目录中）：

pyenv local 3.8.10

验证安装：

输入以下命令，验证当前使用的Python版本：

python --version

1.4.2 虚拟环境管理（virtualenv, venv）

1.4.2.1 虚拟环境的概念和作用

虚拟环境是一种隔离的Python环境，每个虚拟环境都有独立的Python解释器和包管理工具。

使用虚拟环境可以避免不同项目之间的包冲突，并确保项目依赖的稳定性。
常用的虚拟环境管理工具有virtualenv和venv。

1.4.2.2 使用venv创建虚拟环境

venv是Python 3内置的虚拟环境管理工具，使用简单方便。

创建虚拟环境：

打开终端或命令提示符，输入以下命令创建一个名为myenv的虚拟环境：

python3 -m venv myenv

激活虚拟环境：

激活虚拟环境：
- Windows：

myenv\Scripts\activate

  - macOS/Linux：

source myenv/bin/activate

激活后，命令行提示符前会显示虚拟环境的名称，如(myenv)。

安装包：

在激活的虚拟环境中使用pip安装所需的包，例如安装requests库：

pip install requests

退出虚拟环境：

使用以下命令退出虚拟环境：

deactivate

1.4.2.3 使用virtualenv创建虚拟环境

virtualenv是一个独立于Python标准库的虚拟环境管理工具，适用于需要更多功能和兼容性的情况。

安装virtualenv：

如果没有安装virtualenv，可以使用pip进行安装：

pip install virtualenv

创建虚拟环境：

使用virtualenv创建虚拟环境：

virtualenv myenv

激活虚拟环境：

激活虚拟环境：
- Windows：

myenv\Scripts\activate

  - macOS/Linux：

source myenv/bin/activate

退出虚拟环境：

使用以下命令退出虚拟环境：

deactivate

1.4.3 Anaconda的安装与配置

1.4.3.1 Anaconda的概念和作用

Anaconda是一个开源的Python发行版，专为科学计算、数据分析和机器学习而设计。
它包含了许多常用的科学计算库和数据处理工具，并提供了一个功能强大的包管理和虚拟环境管理工具conda。
Anaconda极大地简化了科学计算和数据分析的环境配置工作。

1.4.3.2 安装Anaconda

下载Anaconda安装包：

访问Anaconda官网, 国内用户推荐访问清华源下载和安装。anaconda | 镜像站使用帮助 | 清华大学开源软件镜像站 | Tsinghua Open Source Mirror
根据你的操作系统选择并下载Anaconda安装包。

运行安装包：

双击下载的安装包，按照安装向导的指示完成安装。

验证安装：

打开终端或命令提示符，输入以下命令验证Anaconda是否安装成功：

conda --version

1.4.3.3 使用conda管理虚拟环境和包

创建虚拟环境：

使用conda创建一个名为myenv的虚拟环境，并指定Python版本：

conda create -n myenv python=3.9

激活虚拟环境：

激活虚拟环境：

conda activate myenv

安装包：

在激活的虚拟环境中使用conda安装所需的包，例如安装numpy库：

conda install numpy

退出虚拟环境：

使用以下命令退出虚拟环境：

conda deactivate

管理包和环境：

列出已安装的包：

conda list

列出所有虚拟环境：

conda env list

通过以上步骤，你已经学会了如何使用Python版本管理工具、虚拟环境和Anaconda来配置和管理你的Python开发环境。
这些工具和技术将帮助你更高效地进行Python开发，并确保项目之间的依赖不互相干扰。
接下来，我们将通过IDE开始编写第一个Python程序。

1.5 IDE选择和配置

一个好的集成开发环境（IDE）可以极大地提升开发效率和编程体验。IDE通常提供代码编辑、调试、运行和版本控制等功能，使开发者可以更专注于编码本身。
在本节中，我们将介绍几种常用的Python IDE，包括PyCharm、VS Code和Jupyter Notebook，并讲解它们的安装与基本配置。

1.5.1 PyCharm安装与基本配置

PyCharm是由JetBrains开发的一款功能强大的Python IDE，特别适合大型项目和复杂的开发需求。它提供了智能代码补全、代码重构、调试工具和版本控制集成等功能。

1.5.1.1 安装PyCharm

下载PyCharm：

访问PyCharm官网。
根据你的操作系统下载社区版（Community）或专业版（Professional）。

安装PyCharm：

双击下载的安装包，按照安装向导的指示完成安装。

1.5.1.2 配置Python解释器

创建新项目：

打开PyCharm，选择“Create New Project”。
输入项目名称和路径。

选择Python解释器：

在“New Project”窗口，选择“Base Interpreter”。
选择系统Python解释器或虚拟环境。
点击“Create”创建项目。

1.5.1.3 基本配置和使用

安装插件：

打开“File -> Settings -> Plugins”。
搜索并安装需要的插件，如Markdown支持插件。

创建并运行Python文件：

右键点击项目目录，选择“New -> Python File”，输入文件名。
编写Python代码，例如：

print("Hello, PyCharm!")

右键点击文件，选择“Run 'filename'”运行代码。

1.5.2 VS Code安装与基本配置

VS Code（Visual Studio Code）是由微软开发的一款轻量级且功能强大的代码编辑器，支持多种编程语言。它通过扩展可以实现丰富的功能，非常适合Python开发。

1.5.2.1 安装VS Code

下载VS Code：

访问VS Code官网。
根据你的操作系统下载安装包。

安装VS Code：

双击下载的安装包，按照安装向导的指示完成安装。

1.5.2.2 安装Python扩展

打开VS Code：

启动VS Code。

安装Python扩展：

点击左侧活动栏中的“Extensions”图标。
在搜索框中输入“Python”，找到由Microsoft发布的“Python”扩展并安装。

1.5.2.3 配置Python解释器

打开命令面板：

按Ctrl+Shift+P（Windows/Linux）或Cmd+Shift+P（macOS），打开命令面板。

选择Python解释器：

在命令面板中输入“Python: Select Interpreter”，选择项目使用的Python解释器。

1.5.2.4 创建并运行Python文件

创建新文件：

点击左侧活动栏中的“Explorer”图标，点击“New File”图标，创建一个新的Python文件（如hello.py）。

编写并运行代码：

在新文件中输入以下代码：

print("Hello, VS Code!")

保存文件，右键点击文件选择“Run Python File in Terminal”运行代码。

1.5.3 其他常用IDE介绍

1.5.3.1 Jupyter Notebook

Jupyter Notebook是一款广泛用于数据分析和科学计算的交互式开发工具。它允许用户在浏览器中编写和运行代码，并可以实时查看代码的输出结果，非常适合数据探索和可视化。

安装Jupyter Notebook：

使用pip安装：

pip install notebook

或者使用conda安装：

conda install -c conda-forge notebook

启动Jupyter Notebook：

在命令行中输入以下命令启动Notebook服务器：

jupyter notebook

浏览器会自动打开Jupyter Notebook的主页。

创建和运行Notebook：

在Jupyter主页，点击“New -> Python 3”创建一个新的Notebook。
在单元格中输入以下代码并运行：

print("Hello, Jupyter Notebook!")

按Shift+Enter运行代码单元格。

1.5.3.2 其他IDE

Spyder：Anaconda发行版中自带的IDE，专为数据科学和机器学习设计，集成了许多科学计算库。
Sublime Text：一款轻量级代码编辑器，支持多种编程语言，通过安装插件可以增强Python支持。
Atom：由GitHub开发的开源编辑器，通过插件可以支持多种编程语言和功能扩展。

通过上述介绍和配置，你可以选择和配置适合自己的IDE，提升Python开发的效率和体验。

在接下来的章节中，我们将开始编写第一个Python程序，并逐步学习Python的基础语法和功能。

第2章：Python基础语法

在本章中，我们将深入学习Python编程语言的基础语法。这些基础知识是学习和掌握Python编程的第一步。
通过本章的学习，您将学会编写简单的Python程序，理解并使用Python的基本数据类型，掌握变量和常量的定义与使用，了解常见的运算符及其用法，并能编写包含控制结构的Python程序。
此外，您还将学习如何定义和调用函数，为以后编写更复杂的Python程序奠定基础。

2.1 第一个Python程序

编写和运行第一个Python程序是每个初学者迈向编程世界的第一步。
在这一节中，我们将指导您如何编写一个稍微复杂的Python程序，该程序将包含变量、数据类型、运算符、控制结构和函数等语法元素。

编写和运行第一个Python程序

编写第一个Python程序非常简单。首先，打开一个文本编辑器（如VS Code、Sublime Text或PyCharm），然后输入以下代码：

# 定义一个函数来计算两个数字的加减乘除并判断它们的大小关系
def calculate_and_compare(a, b):
    # 计算和
    sum_result = a + b
    # 计算差
    diff_result = a - b
    # 计算积
    prod_result = a * b
    # 计算商
    if b != 0:
        div_result = a / b
    else:
        div_result = None

    # 打印计算结果
    print(f"{a} + {b} = {sum_result}")
    print(f"{a} - {b} = {diff_result}")
    print(f"{a} * {b} = {prod_result}")
    if div_result is not None:
        print(f"{a} / {b} = {div_result}")
    else:
        print("除数不能为零")

    # 比较两个数字的大小
    if a > b:
        print(f"{a} 大于 {b}")
    elif a < b:
        print(f"{a} 小于 {b}")
    else:
        print(f"{a} 等于 {b}")

# 从用户获取输入
try:
    num1 = float(input("请输入第一个数字: "))
    num2 = float(input("请输入第二个数字: "))

    # 调用函数进行计算和比较
    calculate_and_compare(num1, num2)
except ValueError:
    print("请输入有效的数字")

将文件保存为calculator.py。接下来，打开命令行或终端，导航到保存该文件的目录，输入以下命令运行程序：

python calculator.py

如果一切顺利，程序将提示您输入两个数字，并输出它们的和、差、积、商，并判断它们的大小关系。示例如下：

请输入第一个数字: 8
请输入第二个数字: 4
8.0 + 4.0 = 12.0
8.0 - 4.0 = 4.0
8.0 * 4.0 = 32.0
8.0 / 4.0 = 2.0
8.0 大于 4.0

通过这个程序，您可以看到Python中如何定义变量和函数，使用不同的数据类型（浮点数），进行各种运算（加、减、乘、除），以及使用控制结构（if-else语句）来进行条件判断。
这个程序展示了Python编程的基本要素，为后续章节的深入学习打下了基础。

2.2 数据类型

Python支持多种数据类型，每种类型都有其独特的特性和用途。
在这一节中，我们将详细介绍Python中的几种基本数据类型，包括数字、字符串、列表、元组、字典和集合，并对每种类型的常见操作进行说明。

2.2.1 数字（整数、浮点数、复数）

数字类型是Python中最基本的数据类型之一。Python支持三种不同的数值类型：整数、浮点数和复数。

整数（int）

整数是没有小数部分的数字，可以是正数、负数或零。

# 整数
a = 10
b = -5
c = 0
print(a, type(a))  # 输出: 10 <class 'int'>
print(b, type(b))  # 输出: -5 <class 'int'>
print(c, type(c))  # 输出: 0 <class 'int'>

常见操作：

# 加法
print(a + b)  # 输出: 5

# 减法
print(a - b)  # 输出: 15

# 乘法
print(a * b)  # 输出: -50

# 除法
print(a / 2)  # 输出: 5.0

# 整除
print(a // 3)  # 输出: 3

# 取余
print(a % 3)  # 输出: 1

# 幂运算
print(a ** 2)  # 输出: 100

浮点数（float）

浮点数是带有小数部分的数字。

# 浮点数
d = 3.14
e = -2.71
print(d, type(d))  # 输出: 3.14 <class 'float'>
print(e, type(e))  # 输出: -2.71 <class 'float'>

常见操作：

# 加法
print(d + e)  # 输出: 0.43000000000000016

# 减法
print(d - e)  # 输出: 5.85

# 乘法
print(d * e)  # 输出: -8.5094

# 除法
print(d / 2)  # 输出: 1.57

复数（complex）

复数是带有实部和虚部的数字。

# 复数
f = 1 + 2j
g = 3 - 4j
print(f, type(f))  # 输出: (1+2j) <class 'complex'>
print(g, type(g))  # 输出: (3-4j) <class 'complex'>

常见操作：

# 加法
print(f + g)  # 输出: (4-2j)

# 减法
print(f - g)  # 输出: (-2+6j)

# 乘法
print(f * g)  # 输出: (11+2j)

# 除法
print(f / g)  # 输出: (-0.2+0.4j)

2.2.2 字符串

字符串用于表示文本，是一系列字符的集合。可以使用单引号或双引号定义字符串。字符串是不可变的，这意味着一旦创建就不能更改。

# 使用单引号
str1 = 'Hello, Python'
print(str1, type(str1))  # 输出: Hello, Python <class 'str'>

# 使用双引号
str2 = "Hello, World"
print(str2, type(str2))  # 输出: Hello, World <class 'str'>

常见操作：

# 拼接字符串
greeting = str1 + " " + str2
print(greeting)  # 输出: Hello, Python Hello, World

# 字符串切片
print(greeting[0:5])  # 输出: Hello

# 查找子串
print("Python" in greeting)  # 输出: True

# 获取长度
print(len(greeting))  # 输出: 26

# 转换大小写
print(str1.upper())  # 输出: HELLO, PYTHON
print(str2.lower())  # 输出: hello, world

# 格式化字符串
name = "Alice"
welcome_message = f"Hello, {name}!"
print(welcome_message)  # 输出: Hello, Alice!

2.2.3 列表

列表是一种有序的可变序列，可以包含不同类型的元素。列表使用方括号定义，元素之间用逗号分隔。

# 定义一个列表
my_list = [1, 2, 3, 'Python', 3.14]
print(my_list, type(my_list))  # 输出: [1, 2, 3, 'Python', 3.14] <class 'list'>

常见操作：

# 访问列表元素
print(my_list[0])  # 输出: 1

# 修改列表元素
my_list[1] = 'Changed'
print(my_list)  # 输出: [1, 'Changed', 3, 'Python', 3.14]

# 添加新元素
my_list.append('New Element')
print(my_list)  # 输出: [1, 'Changed', 3, 'Python', 3.14, 'New Element']

# 删除元素
my_list.remove('Python')
print(my_list)  # 输出: [1, 'Changed', 3, 3.14, 'New Element']

# 获取长度
print(len(my_list))  # 输出: 5

# 列表切片
print(my_list[1:4])  # 输出: ['Changed', 3, 3.14]

2.2.4 元组

元组与列表类似，但元组是不可变的。一旦定义，元组中的元素不能修改。元组使用圆括号定义，元素之间用逗号分隔。

# 定义一个元组
my_tuple = (1, 2, 3, 'Python', 3.14)
print(my_tuple, type(my_tuple))  # 输出: (1, 2, 3, 'Python', 3.14) <class 'tuple'>

常见操作：

# 访问元组元素
print(my_tuple[0])  # 输出: 1

# 元组切片
print(my_tuple[1:4])  # 输出: (2, 3, 'Python')

# 获取长度
print(len(my_tuple))  # 输出: 5

# 元组解包
a, b, c, d, e = my_tuple
print(a, b, c, d, e)  # 输出: 1 2 3 Python 3.14

# 元组的不可变特性
# my_tuple[1] = 'Changed'  # 这行代码会引发错误，因为元组不允许修改

2.2.5 字典

字典是一种键值对的集合，使用大括号定义。每个键值对由键和对应的值组成。键是唯一的，通常是字符串或数字，而值可以是任何数据类型。

# 定义一个字典
my_dict = {'name': 'Python', 'version': 3.9}
print(my_dict, type(my_dict))  # 输出: {'name': 'Python', 'version': 3.9} <class 'dict'>

常见操作：

# 访问字典元素
print(my_dict['name'])  # 输出: Python

# 修改字典元素
my_dict['version'] = 3.10
print(my_dict)  # 输出: {'name': 'Python', 'version': 3.10}

# 添加新元素
my_dict['creator'] = 'Guido van Rossum'
print(my_dict)  # 输出: {'name': 'Python', 'version': 3.10, 'creator': 'Guido van Rossum'}

# 删除元素
del my_dict['version']
print(my_dict)  # 输出: {'name': 'Python', 'creator': 'Guido van Rossum'}

# 获取所有键
print(my_dict.keys())  # 输出: dict_keys(['name', 'creator'])

# 获取所有值
print(my_dict.values())  # 输出: dict_values(['Python', 'Guido van Rossum'])

# 获取所有键值对
print(my_dict.items())  # 输出: dict_items([('name', 'Python'), ('creator', 'Guido van Rossum')])

2.2.6 集合

集合是一个无序的不重复元素序列，使用大括号或set()函数创建。集合用于去重和集合运算。

# 定义一个集合
my_set = {1, 2, 3, 4, 5}
print(my_set, type(my_set))  # 输出: {1, 2, 3, 4, 5} <class 'set'>

# 使用set()函数定义集合
another_set = set([3, 4, 5, 6, 7])
print(another_set, type(another_set))  # 输出: {3, 4, 5, 6, 7} <class 'set'>

常见操作：

# 添加新元素
my_set.add(6)
print(my_set)  # 输出: {1, 2, 3, 4, 5, 6}

# 集合的去重特性
my_set.add(3)
print(my_set)  # 输出: {1, 2, 3, 4, 5, 6}

# 删除元素
my_set.remove(4)
print(my_set)  # 输出: {1, 2, 3, 5, 6}

# 集合运算
print(my_set & another_set)  # 交集: {3, 5, 6}
print(my_set | another_set)  # 并集: {1, 2, 3, 5, 6, 7}
print(my_set - another_set)  # 差集: {1, 2}
print(my_set ^ another_set)  # 对称差集: {1, 2, 7}

通过学习这些基本数据类型及其常见操作，您将能够处理各种不同类型的数据，并为后续的编程打下坚实的基础。

2.3 变量与常量

在编程中，变量和常量是两个重要的概念。
变量用于存储可以改变的数据，而常量用于存储在程序运行期间不改变的数据。
在这一节中，我们将介绍变量和常量的定义与使用。

2.3.1 变量的定义与使用

变量是一个用于存储数据的容器。在Python中，变量不需要显式声明，直接赋值即可创建变量。

定义变量

定义变量时，只需要将变量名赋值给一个数据即可：

# 定义变量
x = 10
y = 3.14
name = "Alice"
is_active = True

# 输出变量的值和类型
print(x, type(x))         # 输出: 10 <class 'int'>
print(y, type(y))         # 输出: 3.14 <class 'float'>
print(name, type(name))   # 输出: Alice <class 'str'>
print(is_active, type(is_active)) # 输出: True <class 'bool'>

使用变量

定义变量后，可以在程序的不同部分使用这些变量。变量可以参与运算、传递给函数、用于条件判断等。

# 变量参与运算
result = x + y
print(result)  # 输出: 13.14

# 变量传递给函数
def greet(person):
    return f"Hello, {person}!"

message = greet(name)
print(message)  # 输出: Hello, Alice!

# 变量用于条件判断
if is_active:
    print("The user is active.")  # 输出: The user is active.
else:
    print("The user is not active.")

变量命名规则

在命名变量时，需要遵守以下规则：

变量名必须以字母或下划线开头。
变量名只能包含字母、数字和下划线。
变量名区分大小写（例如，myVar 和 myvar 是不同的变量）。
变量名不要使用Python的保留字（如 and、if、while 等）。

# 合法的变量名
my_var = 10
_my_var = 20
myVar2 = 30

# 非法的变量名（会引发语法错误）
# 2myVar = 40
# my-var = 50
# my var = 60

2.3.2 常量的定义与约定

常量用于存储在程序运行期间不改变的数据。在Python中，没有专门的语法定义常量，通常使用全大写字母的变量名表示常量，以便区分它们和普通变量。

定义常量

在Python中，常量通常在模块的顶部定义，并使用全大写字母命名：

# 定义常量
PI = 3.14159
GRAVITY = 9.81
MAX_CONNECTIONS = 100

# 输出常量的值
print(PI)            # 输出: 3.14159
print(GRAVITY)       # 输出: 9.81
print(MAX_CONNECTIONS) # 输出: 100

使用常量

常量的使用方式与变量相同，但在程序中不应修改常量的值。

# 使用常量计算圆的面积
radius = 5
area = PI * (radius ** 2)
print(f"The area of the circle is: {area}")  # 输出: The area of the circle is: 78.53975

# 使用常量进行条件判断
if MAX_CONNECTIONS > 50:
    print("The server can handle many connections.")  # 输出: The server can handle many connections.
else:
    print("The server can handle only a few connections.")

常量命名约定

虽然Python没有严格要求，但使用全大写字母命名常量是一个广泛接受的约定。这种约定有助于提高代码的可读性，让其他开发者能够一目了然地识别出哪些值是常量。

# 合理的常量命名
SPEED_OF_LIGHT = 299792458  # 米每秒
PLANCK_CONSTANT = 6.62607015e-34  # 焦耳秒

# 不推荐的常量命名（不遵循约定）
# speed_of_light = 299792458
# planckConstant = 6.62607015e-34

通过学习变量和常量的定义与使用，您将能够更有效地管理程序中的数据，编写更清晰、更易维护的代码。

2.4 运算符

运算符是编程语言中用于执行各种操作的符号。

Python支持多种类型的运算符，包括算术运算符、比较运算符、逻辑运算符、赋值运算符和位运算符。

在这一节中，我们将详细介绍这些运算符的用法及其示例。

2.4.1 算术运算符

算术运算符用于执行基本的数学运算，如加法、减法、乘法、除法等。Python中的算术运算符如下：

运算符	描述	示例
`+`	加法	`a + b`
`-`	减法	`a - b`
`*`	乘法	`a * b`
`/`	除法	`a / b`
`//`	整除	`a // b`
`%`	取余	`a % b`
`**`	幂运算	`a ** b`

示例：

a = 10
b = 3

print(a + b)  # 输出: 13
print(a - b)  # 输出: 7
print(a * b)  # 输出: 30
print(a / b)  # 输出: 3.3333333333333335
print(a // b) # 输出: 3
print(a % b)  # 输出: 1
print(a ** b) # 输出: 1000

2.4.2 比较运算符

比较运算符用于比较两个值，并返回布尔值（True 或 False）。Python中的比较运算符如下：

运算符	描述	示例
`==`	等于	`a == b`
`!=`	不等于	`a != b`
`>`	大于	`a > b`
`<`	小于	`a < b`
`>=`	大于或等于	`a >= b`
`<=`	小于或等于	`a <= b`

示例：

a = 10
b = 3

print(a == b)  # 输出: False
print(a != b)  # 输出: True
print(a > b)   # 输出: True
print(a < b)   # 输出: False
print(a >= b)  # 输出: True
print(a <= b)  # 输出: False

2.4.3 逻辑运算符

逻辑运算符用于组合布尔值，并返回布尔值。Python中的逻辑运算符如下：

运算符	描述	示例
`and`	逻辑与	`a and b`
`or`	逻辑或	`a or b`
`not`	逻辑非	`not a`

示例：

a = True
b = False

print(a and b)  # 输出: False
print(a or b)   # 输出: True
print(not a)    # 输出: False

2.4.4 赋值运算符

赋值运算符用于将右边的值赋给左边的变量。Python中的赋值运算符如下：

运算符	描述	示例
`=`	简单赋值	`a = b`
`+=`	加法赋值	`a += b`
`-=`	减法赋值	`a -= b`
`*=`	乘法赋值	`a *= b`
`/=`	除法赋值	`a /= b`
`//=`	整除赋值	`a //= b`
`%=`	取余赋值	`a %= b`
`**=`	幂赋值	`a **= b`

示例：

a = 10
b = 3

a += b  # 等价于 a = a + b
print(a)  # 输出: 13

a -= b  # 等价于 a = a - b
print(a)  # 输出: 10

a *= b  # 等价于 a = a * b
print(a)  # 输出: 30

a /= b  # 等价于 a = a / b
print(a)  # 输出: 10.0

a //= b  # 等价于 a = a // b
print(a)  # 输出: 3.0

a %= b  # 等价于 a = a % b
print(a)  # 输出: 0.0

a **= b  # 等价于 a = a ** b
print(a)  # 输出: 0.0

2.4.5 位运算符

位运算符用于对整数的二进制位进行操作。Python中的位运算符如下：

运算符	描述	示例
`&`	按位与	`a & b`
`\|`	按位或	`a \| b`
`^`	按位异或	`a ^ b`
`~`	按位取反	`~a`
`<<`	左移	`a << b`
`>>`	右移	`a >> b`

示例：

a = 10  # 二进制: 1010
b = 4   # 二进制: 0100

print(a & b)  # 输出: 0  (二进制: 0000)
print(a | b)  # 输出: 14 (二进制: 1110)
print(a ^ b)  # 输出: 14 (二进制: 1110)
print(~a)     # 输出: -11 (二进制: -1011)

print(a << 2) # 输出: 40 (二进制: 101000)
print(a >> 2) # 输出: 2  (二进制: 0010)

2.4.6 运算符优先级

当一个表达式中出现多个操作符时，求值的顺序依赖于优先级规则。Python遵守数学操作符的传统规则。

运算符	描述
**	指数（最高优先级）
~、+、-	按位翻转，一元加号和减号（最后两个的方法名为+@和-@）
*、/、%、//	乘、除、取模和取整除
+、-	加法、减法
>>、<<	右移、左移运算符
&	位与
^、\|	位运算符
<=、<、>、>=	比较运算符
<> == !=	等于运算符
= %= /= //= -= += = *=	赋值运算符
is is not	身份运算符
in in not	成员运算符
not or and	逻辑运算符

以上常用的运算符优先级从上到下依次降低，运算优先级高的先计算，低的后计算。有括号时会优先运算括号中的内容，所以我们可以利用括号来打破运算优先级的限制。

通过学习这些运算符及其用法，您将能够执行各种基本和复杂的操作，编写功能更强大、更灵活的Python程序。

2.5 控制结构

控制结构用于控制程序的执行流程。Python中最常用的控制结构包括条件语句和循环语句。在本节中，我们将详细介绍条件语句的用法。

2.5.1 条件语句（if, elif, else）

条件语句用于根据一个或多个条件的真假，来执行不同的代码块。Python中的条件语句包括if、elif（else if的缩写）和else。

if 语句

if语句用于判断一个条件是否为真，如果为真，则执行相应的代码块。

# if 语句示例
x = 10

if x > 5:
    print("x is greater than 5")  # 输出: x is greater than 5

if...else 语句

if...else语句用于在条件为假时执行另一个代码块。

# if...else 语句示例
x = 3

if x > 5:
    print("x is greater than 5")
else:
    print("x is less than or equal to 5")  # 输出: x is less than or equal to 5

if...elif...else 语句

if...elif...else语句用于检查多个条件，并根据第一个为真的条件执行相应的代码块。如果所有条件都为假，则执行else代码块。

# if...elif...else 语句示例
x = 7

if x > 10:
    print("x is greater than 10")
elif x > 5:
    print("x is greater than 5 but less than or equal to 10")  # 输出: x is greater than 5 but less than or equal to 10
else:
    print("x is 5 or less")

嵌套条件语句

条件语句可以嵌套使用，即在一个条件语句内部再包含另一个条件语句。

# 嵌套条件语句示例
x = 15

if x > 10:
    print("x is greater than 10")  # 输出: x is greater than 10
    if x > 20:
        print("x is also greater than 20")
    else:
        print("x is not greater than 20")  # 输出: x is not greater than 20
else:
    print("x is 10 or less")

条件表达式（三元运算符）

Python还支持使用条件表达式（又称三元运算符）来简化条件语句。条件表达式允许在一行中编写简洁的条件判断。

# 条件表达式示例
x = 8
result = "greater than 5" if x > 5 else "less than or equal to 5"
print(result)  # 输出: greater than 5

通过条件语句，程序可以根据不同的条件执行不同的代码块，从而实现复杂的逻辑控制。

2.5.2 循环语句（for, while）

循环语句用于重复执行某段代码，直到满足某个条件为止。Python中主要有两种循环语句：for循环和while循环。

for 循环

for循环用于遍历序列（如列表、元组、字符串）或其他可迭代对象。每次循环时，for语句会将序列中的下一个元素赋值给循环变量，并执行循环体中的代码。

# for 循环遍历列表
numbers = [1, 2, 3, 4, 5]

for num in numbers:
    print(num)
# 输出:
# 1
# 2
# 3
# 4
# 5

使用range()函数生成一系列数字，并使用for循环进行遍历：

# 使用 range() 生成数字序列
for i in range(5):
    print(i)
# 输出:
# 0
# 1
# 2
# 3
# 4

# 指定起始和结束点
for i in range(2, 7):
    print(i)
# 输出:
# 2
# 3
# 4
# 5
# 6

# 指定步长
for i in range(1, 10, 2):
    print(i)
# 输出:
# 1
# 3
# 5
# 7
# 9

while 循环

while循环在条件为真时反复执行循环体中的代码。当条件变为假时，循环终止。

# while 循环示例
count = 0

while count < 5:
    print(count)
    count += 1
# 输出:
# 0
# 1
# 2
# 3
# 4

嵌套循环

循环可以嵌套使用，即在一个循环体内再包含一个循环。

# 嵌套 for 循环
for i in range(3):
    for j in range(2):
        print(f"i={i}, j={j}")
# 输出:
# i=0, j=0
# i=0, j=1
# i=1, j=0
# i=1, j=1
# i=2, j=0
# i=2, j=1

# 嵌套 while 循环
i = 0
while i < 3:
    j = 0
    while j < 2:
        print(f"i={i}, j={j}")
        j += 1
    i += 1
# 输出:
# i=0, j=0
# i=0, j=1
# i=1, j=0
# i=1, j=1
# i=2, j=0
# i=2, j=1

2.5.3 循环控制（break, continue, pass）

在循环中，可以使用break、continue和pass语句来控制循环的执行。

break语句用于终止循环，不再执行循环体中的剩余代码，并立即退出循环。

# break 示例
for i in range(5):
    if i == 3:
        break
    print(i)
# 输出:
# 0
# 1
# 2

continue语句用于跳过当前迭代的剩余代码，直接进入下一次迭代。

# continue 示例
for i in range(5):
    if i == 3:
        continue
    print(i)
# 输出:
# 0
# 1
# 2
# 4

pass语句用于占位，表示不执行任何操作。通常用于语法上需要语句，但实际不需要执行任何代码的场合。

# pass 示例
for i in range(5):
    if i == 3:
        pass  # 这里可以放置以后需要的代码
    print(i)
# 输出:
# 0
# 1
# 2
# 3
# 4

通过学习for和while循环以及循环控制语句，您将能够在程序中实现重复执行某段代码的功能，提高代码的效率和灵活性。

2.6 函数基础

函数是组织代码的一种重要方式，通过使用函数，我们可以将重复的代码封装到一起，以便在需要的时候调用。
函数可以提高代码的可读性和可维护性，使程序更易于理解和修改。

Python中的函数定义和调用非常灵活，支持多种参数传递方式，并且可以返回多个值。

掌握函数的定义与调用是Python编程中的重要内容之一。

2.6.1 函数的定义与调用

函数名应该具有描述性，能够表明函数的功能。

函数可以有参数，也可以没有参数。

定义函数时，还可以指定函数的返回值。函数体由缩进的代码块组成，通常包含函数的逻辑和实现。

定义一个简单的函数

下面是一个简单的函数示例，它打印一个问候语：

def greet():
    print("Hello, welcome to Python programming!")

调用函数

定义函数后，我们可以通过函数名加括号的方式来调用它：

greet()  # 输出: Hello, welcome to Python programming!

带参数的函数

函数可以接受参数，参数可以在函数定义时指定。当函数被调用时，可以将值传递给参数。

def greet_user(name):
    print(f"Hello, {name}, welcome to Python programming!")

greet_user("Alice")  # 输出: Hello, Alice, welcome to Python programming!

带返回值的函数

函数可以返回一个值，使用return关键字实现。当函数执行到return语句时，会将结果返回，并结束函数的执行。

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

result = add(3, 5)
print(result)  # 输出: 8

通过这些示例，您可以看到函数的定义与调用在Python中是多么简洁和强大。
掌握函数的定义和调用将使您能够编写更高效、更模块化的代码。

2.6.2 函数参数

函数参数是函数定义中非常重要的一部分，它决定了函数如何接收输入并进行处理。Python支持多种方式来传递参数，使得函数的使用更加灵活和强大。我们将分别介绍位置参数、关键字参数、默认参数和不定长参数，并展示它们的综合使用方法。

2.6.3 函数返回值

在Python中，函数不仅可以执行一系列操作，还可以返回一个或多个值。函数的返回值用于将函数的计算结果传递给调用方，这使得函数更加灵活和实用。理解如何定义和使用函数的返回值是编写高效代码的关键。

2.6.4 函数文档字符串

函数文档字符串（docstring）是一种用于为函数、模块、类或方法编写文档的字符串。
它帮助开发者了解函数的用途、参数和返回值，从而使代码更加可读和可维护。
Python强烈推荐使用文档字符串来为代码编写文档。

第3章：模块与包

在Python编程中，模块和包是组织和管理代码的重要方式。通过将相关功能分组到模块和包中，我们可以提高代码的可重用性和可维护性，并且方便地管理和使用外部库。
在本章中，我们将学习如何使用Python标准库、如何安装和使用第三方库、以及如何创建和使用自定义模块和包。
此外，我们还会介绍一些常用的第三方库，以便您在实际项目中能更高效地完成各种任务。

3.1 标准库的使用

3.2 第三方库的安装与使用

除了Python的标准库外，Python的生态系统中还有大量的第三方库，这些库由社区开发和维护，提供了各种强大的功能，极大地扩展了Python的应用范围。
在这一节中，我们将介绍如何使用pip工具来安装第三方库，并展示一些常用第三方库的安装示例。

3.2.1 pip的使用

pip是Python的包管理工具，用于安装和管理Python包。
pip非常强大且易于使用，几乎所有的第三方库都可以通过pip进行安装。

3.2.2 常用第三方库安装示例

以下是一些常用第三方库的安装示例，这些库在各种Python项目中都有广泛的应用。

3.3 自定义模块与包

3.4 常用第三方库介绍

第4章：文件与异常处理

在编程过程中，处理文件和异常是必不可少的技能。
文件操作涉及读取和写入文件内容，而异常处理则用于捕获和处理程序运行中的错误。
在本章中，我们将学习如何进行文件读写操作，以及如何处理程序中的异常。

4.1 文件读写操作

文件操作是程序与外部数据交互的重要方式。

Python提供了一套完整的文件操作接口，可以方便地进行文件的读写操作。我们将探讨如何读取文件、写入文件，以及各种文件模式的使用。

4.1.1 读文件

4.1.2 写文件

4.1.3 文件模式

4.2 文件和目录操作

4.3 异常捕获与处理

4.4 日志记录

在开发和维护软件时，日志记录是一个重要的工具。通过日志记录，开发者可以跟踪程序的执行过程、记录重要的事件和错误信息，从而更容易发现和解决问题。

Python提供了功能强大的logging模块，用于灵活地记录日志信息。

第二部分：高级进阶

第5章：面向对象编程

面向对象编程（OOP）是现代编程范式中非常重要的一种，它通过类和对象将数据和行为进行封装，从而提高代码的重用性、可扩展性和可维护性。
Python作为一种面向对象的编程语言，提供了强大而灵活的OOP特性。
在本章中，我们将深入学习面向对象编程的核心概念和技术，包括类与对象、封装、继承、多态，以及一些高级话题如静态方法、类方法、抽象类和接口等。

5.1 类与对象

类和对象是面向对象编程的基础。
在Python中，类是一种定义数据和行为的模板，而对象是类的实例。
通过定义类和创建对象，我们可以组织和管理程序中的复杂数据和逻辑。

5.1.1 类的定义

在Python中，类使用class关键字定义。类可以包含属性（数据）和方法（函数），用于描述对象的状态和行为。

示例：定义一个简单的类

class Person:
    # 初始化方法，用于创建实例时初始化属性
    def __init__(self, name, age):
        self.name = name
        self.age = age

    # 实例方法，用于描述行为
    def greet(self):
        return f"Hello, my name is {self.name} and I am {self.age} years old."

在这个示例中，我们定义了一个名为Person的类。__init__方法是一个特殊的方法，在创建实例时自动调用，用于初始化对象的属性。greet方法是一个实例方法，用于返回问候语。

5.1.2 对象的创建与使用

对象是类的实例，通过调用类的构造函数来创建。我们可以使用对象来访问属性和方法。

示例：创建和使用对象

# 创建Person类的实例
person1 = Person("Alice", 30)
person2 = Person("Bob", 25)

# 访问属性
print(person1.name)  # 输出: Alice
print(person2.age)   # 输出: 25

# 调用方法
print(person1.greet())  # 输出: Hello, my name is Alice and I am 30 years old.
print(person2.greet())  # 输出: Hello, my name is Bob and I am 25 years old.

在这个示例中，我们创建了两个Person类的实例，并访问了它们的属性和方法。

5.1.3 类属性和实例属性

类属性是定义在类级别的属性，所有实例共享；实例属性是定义在实例级别的属性，每个实例有独立的副本。

示例：类属性和实例属性

class Person:
    species = "Homo sapiens"  # 类属性

    def __init__(self, name, age):
        self.name = name  # 实例属性
        self.age = age    # 实例属性

    def greet(self):
        return f"Hello, my name is {self.name} and I am {self.age} years old."

# 创建实例
person1 = Person("Alice", 30)
person2 = Person("Bob", 25)

# 访问类属性
print(Person.species)    # 输出: Homo sapiens
print(person1.species)   # 输出: Homo sapiens
print(person2.species)   # 输出: Homo sapiens

# 修改类属性
Person.species = "Human"
print(person1.species)   # 输出: Human

# 访问实例属性
print(person1.name)  # 输出: Alice
print(person2.age)   # 输出: 25

在这个示例中，species是一个类属性，所有Person实例共享。name和age是实例属性，每个实例有独立的值。

通过学习类与对象的定义和使用，您可以开始在Python中使用面向对象编程来组织和管理代码。

5.2 封装、继承、多态

面向对象编程的三个重要特性是封装、继承和多态。通过理解和应用这些特性，可以构建更具模块化、可维护性和可扩展性的程序。

5.2.1 封装的概念

封装是将数据（属性）和行为（方法）捆绑在一起，并隐藏对象的内部实现细节，仅对外暴露必要的接口。封装可以提高代码的安全性和可维护性，防止外部代码直接访问和修改对象的内部状态。

示例：封装的实现

class Person:
    def __init__(self, name, age):
        self.__name = name  # 私有属性
        self.__age = age    # 私有属性

    def greet(self):
        return f"Hello, my name is {self.__name} and I am {self.__age} years old."

    def get_age(self):
        return self.__age

    def set_age(self, age):
        if age > 0:
            self.__age = age
        else:
            raise ValueError("Age must be positive")

# 创建实例
person = Person("Alice", 30)

# 访问私有属性 (通过方法)
print(person.greet())  # 输出: Hello, my name is Alice and I am 30 years old.

# 修改私有属性 (通过方法)
person.set_age(35)
print(person.get_age())  # 输出: 35

# 直接访问私有属性会导致错误
# print(person.__age)  # AttributeError: 'Person' object has no attribute '__age'

在这个示例中，__name和__age是私有属性，不能直接从外部访问。通过定义公有方法get_age和set_age，我们可以间接访问和修改私有属性。

5.2.2 继承的实现

继承是一个类（子类）继承另一个类（父类）的属性和方法，从而实现代码重用和扩展。

子类可以扩展或重写父类的方法，增加新的功能。

5.3 魔法方法与特殊属性

魔法方法（Magic Methods），也称为特殊方法，是Python内置的具有特殊用途的函数。这些方法以双下划线（__）开头和结尾，并用于在特定情况下自动调用。特殊属性是Python对象自带的一些属性，也使用双下划线包围，提供有关对象的元数据和行为控制。

5.3.1 常用魔法方法

魔法方法使得Python的类能够与内置操作进行交互，提供自定义对象的特殊行为。

init

__init__方法是类的初始化方法，在创建实例时自动调用，用于初始化对象的属性。

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

# 创建实例时会自动调用__init__方法
person = Person("Alice", 30)
print(person.name)  # 输出: Alice
print(person.age)   # 输出: 30

str

__str__方法定义了对象的字符串表示，用于print()和str()函数。当尝试以字符串形式打印对象时调用。

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):
        return f"Person(name={self.name}, age={self.age})"

person = Person("Alice", 30)
print(person)  # 输出: Person(name=Alice, age=30)

repr

__repr__方法返回对象的官方字符串表示，用于repr()函数和交互解释器。当开发者需要一个准确且非歧义的对象表示时调用。

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __repr__(self):
        return f"Person(name='{self.name}', age={self.age})"

person = Person("Alice", 30)
print(repr(person))  # 输出: Person(name='Alice', age=30)

5.3.2 特殊属性

特殊属性提供了有关对象的元数据和控制对象行为的机制。

dict

__dict__属性是一个字典，包含对象的所有可变属性和它们的值。可以用来查看和修改对象的属性。

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

person = Person("Alice", 30)
print(person.__dict__)  # 输出: {'name': 'Alice', 'age': 30}

# 修改属性
person.__dict__['age'] = 31
print(person.age)  # 输出: 31

class

__class__属性指向对象的类，提供了访问对象所属类的方式。

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

person = Person("Alice", 30)
print(person.__class__)  # 输出: <class '__main__.Person'>

# 检查对象是否为特定类的实例
print(isinstance(person, Person))  # 输出: True

5.3.3 综合示例

5.4 类的高级话题

在面向对象编程中，除了基本的类和对象操作外，还有一些高级话题，可以帮助我们创建更强大和灵活的程序。这些包括静态方法与类方法、抽象类与接口，以及迭代器与生成器。

5.4.1 静态方法与类方法

5.4.3 迭代器与生成器

第6章：函数式编程

函数式编程是一种编程范式，它强调使用函数来处理数据和进行计算。
与面向对象编程不同，函数式编程主要关注数据的传递和转换，避免使用可变状态和副作用。
Python支持多种函数式编程特性，包括高阶函数、内置函数（如map、filter、reduce）、闭包与装饰器、以及生成器表达式与列表推导式。
在本章中，我们将探讨这些函数式编程的概念和应用。

6.1 高阶函数

高阶函数是函数式编程的核心概念之一。一个函数如果满足以下条件之一，就是高阶函数：

接受一个或多个函数作为参数。
返回一个函数。

6.1.1 定义与使用

6.2 内置函数

Python 提供了一些内置函数，用于支持函数式编程。最常用的内置函数包括 map、filter 和 reduce。这些函数使得对序列进行操作更加简洁和高效。

6.3 闭包与装饰器

闭包和装饰器是函数式编程中的两个重要概念，它们在编写简洁和高效的代码方面起着重要作用。

闭包允许函数捕获和记住其定义时的环境，而装饰器是用于增强函数功能的强大工具。

6.4 生成器表达式与列表推导式

第7章：并发编程

在现代编程中，并发编程是一个重要的技术领域，用于提高程序的效率和响应能力。并发编程可以通过多线程、多进程和异步编程等方式实现，使得程序能够同时处理多个任务，从而充分利用系统资源。

在本章中，我们将探讨并发编程的基础知识，包括线程与进程、异步编程，以及并发编程的最佳实践。

7.1 线程与进程

线程和进程是实现并发编程的两种主要方式。
线程是操作系统能够进行运算调度的最小单位，而进程是操作系统进行资源分配和调度的基本单位。
Python 提供了 threading 和 multiprocessing 模块，分别用于多线程编程和多进程编程。

7.1.1 threading模块

7.1.2 multiprocessing模块

7.2 异步编程

在现代编程中，处理I/O密集型任务时，异步编程是一种非常有效的技术。
异步编程允许我们在等待I/O操作完成时，继续执行其他任务，从而提高程序的效率和响应性。在Python中，asyncio模块提供了强大的异步编程支持。

7.2.1 asyncio模块基础

7.2.3 异步编程与多线程编程和多进程编程的区别

7.3 并发编程最佳实践

在编写高效并发程序时，了解常见问题和优化技巧是至关重要的。并发编程不仅涉及如何让程序运行得更快，还包括确保程序的正确性和稳定性。本节将介绍并发编程中的常见问题和一些优化技巧。

第8章网络编程

网络编程是现代编程的重要组成部分，它使得计算机能够通过网络进行通信和数据交换。

在Python中，网络编程涵盖了从低级的套接字编程到高级的Web框架应用。

本章将介绍如何使用Python进行网络编程，包括套接字编程、HTTP请求处理，以及使用流行的Web框架如Flask和Django进行Web应用开发。

8.1 套接字编程

套接字是网络编程的基础，它提供了在网络上传输数据的方法。在Python中，socket模块提供了用于创建和操作套接字的接口。

8.3 Web框架初探

Web框架是用于开发Web应用程序的软件框架，它提供了一些标准的方式来构建和部署Web应用程序。在Python中，Flask和Django是两种非常流行的Web框架。本节将介绍这两种框架的基本使用方法，帮助你快速入门Web开发。

8.3.1 Flask简介与快速入门

第三部分：实战演练

第9章：数据分析项目

9.3 数据分析案例

通过前面几节的学习，我们已经掌握了数据清洗、预处理和可视化的基本技能。

现在，我们将通过几个实际的数据分析案例，来综合应用这些技能，进行深入的分析和洞察。

9.3.1 电商用户行为分析

电商平台的用户行为分析是一个常见的实际数据分析任务。

我们将使用一个包含用户浏览、点击和购买行为的数据集，来分析用户的行为模式和趋势。

数据集

假设我们有一个包含电商用户行为的数据集ecommerce_data.csv，其内容如下：

user_id,timestamp,event_type,product_id,category_id
1,2023-01-01 12:01:00,view,1001,2001
1,2023-01-01 12:03:00,click,1001,2001
1,2023-01-01 12:05:00,add_to_cart,1001,2001
1,2023-01-01 12:10:00,purchase,1001,2001
2,2023-01-01 12:15:00,view,1002,2002
2,2023-01-01 12:17:00,click,1002,2002
2,2023-01-01 12:20:00,view,1003,2003

数据清洗与预处理

首先，我们将使用pandas进行数据的清洗与预处理。

import pandas as pd

# 读取数据
df = pd.read_csv('ecommerce_data.csv')

# 查看数据集的前几行
print(df.head())

输出结果：

   user_id            timestamp   event_type  product_id  category_id
0        1  2023-01-01 12:01:00         view        1001         2001
1        1  2023-01-01 12:03:00        click        1001         2001
2        1  2023-01-01 12:05:00  add_to_cart        1001         2001
3        1  2023-01-01 12:10:00     purchase        1001         2001
4        2  2023-01-01 12:15:00         view        1002         2002

数据清洗与处理

我们需要处理时间戳数据，并提取日期和时间，以便后续分析。

# 将timestamp列转换为datetime类型
df['timestamp'] = pd.to_datetime(df['timestamp'])

# 提取日期和时间
df['date'] = df['timestamp'].dt.date
df['time'] = df['timestamp'].dt.time

print(df.head())

输出结果：

   user_id           timestamp event_type  product_id  category_id        date      time
0        1 2023-01-01 12:01:00       view        1001         2001  2023-01-01  12:01:00
1        1 2023-01-01 12:03:00      click        1001         2001  2023-01-01  12:03:00
2        1 2023-01-01 12:05:00  add_to_cart        1001         2001  2023-01-01  12:05:00
3        1 2023-01-01 12:10:00   purchase        1001         2001  2023-01-01  12:10:00
4        2 2023-01-01 12:15:00       view        1002         2002  2023-01-01  12:15:00

数据分析

我们可以通过分析用户的不同事件类型来了解他们的行为模式。

# 按事件类型统计数量
event_counts = df['event_type'].value_counts()
print(event_counts)

输出结果：

view           3
click          2
add_to_cart    1
purchase       1
Name: event_type, dtype: int64

我们还可以按日期分析用户的行为趋势。

# 按日期和事件类型统计数量
daily_events = df.groupby(['date', 'event_type']).size().unstack().fillna(0)
print(daily_events)

输出结果：

event_type  add_to_cart  click  purchase  view
date                                         
2023-01-01          1.0    2.0       1.0   3.0

数据可视化

我们使用matplotlib对分析结果进行可视化展示。

import matplotlib.pyplot as plt

# 绘制事件类型分布的柱状图
event_counts.plot(kind='bar')
plt.title('Event Type Distribution')
plt.xlabel('Event Type')
plt.ylabel('Count')
plt.show()

# 绘制每日事件数量的折线图
daily_events.plot(kind='line')
plt.title('Daily Event Counts')
plt.xlabel('Date')
plt.ylabel('Count')
plt.show()

9.3.2 其他数据分析示例

示例1：销售数据分析

假设我们有一个包含销售数据的数据集sales_data.csv，包括以下字段：date、sales_amount、product_id、region。

date,sales_amount,product_id,region
2023-01-01,100,101,North
2023-01-01,150,102,East
2023-01-02,200,101,North
2023-01-02,250,103,South
2023-01-03,300,102,East
2023-01-03,350,104,West
2023-01-04,400,101,North
2023-01-04,450,103,South
2023-01-05,500,104,West
2023-01-05,550,102,East

数据清洗与预处理

import pandas as pd

# 读取数据
sales_df = pd.read_csv('sales_data.csv')

# 查看数据集的前几行
print(sales_df.head())

输出结果：

         date  sales_amount  product_id region
0  2023-01-01           100         101  North
1  2023-01-01           150         102   East
2  2023-01-02           200         101  North
3  2023-01-02           250         103  South
4  2023-01-03           300         102   East

数据分析

按日期统计销售总额。

# 按日期统计销售总额
daily_sales = sales_df.groupby('date')['sales_amount'].sum()
print(daily_sales)

输出结果：

date
2023-01-01    250
2023-01-02    450
2023-01-03    650
2023-01-04    850
2023-01-05   1050
Name: sales_amount, dtype: int64

数据可视化

绘制每日销售总额的折线图。

import matplotlib.pyplot as plt

# 绘制每日销售总额的折线图
daily_sales.plot(kind='line')
plt.title('Daily Sales Amount')
plt.xlabel('Date')
plt.ylabel('Sales Amount')
plt.show()

进一步分析

按地区统计销售总额。

# 按地区统计销售总额
region_sales = sales_df.groupby('region')['sales_amount'].sum()
print(region_sales)

输出结果：

region
East      1000
North      700
South      700
West       850
Name: sales_amount, dtype: int64

绘制按地区统计销售总额的柱状图。

# 绘制按地区统计销售总额的柱状图
region_sales.plot(kind='bar')
plt.title('Total Sales Amount by Region')
plt.xlabel('Region')
plt.ylabel('Sales Amount')
plt.show()

示例2：天气数据分析

假设我们有一个包含天气数据的数据集weather_data.csv，包括以下字段：date、temperature、humidity、weather_condition。

date,temperature,humidity,weather_condition
2023-01-01,5,80,Cloudy
2023-01-02,7,78,Sunny
2023-01-03,6,82,Rainy
2023-01-04,10,75,Sunny
2023-01-05,12,70,Sunny
2023-01-06,8,85,Cloudy
2023-01-07,9,88,Rainy
2023-01-08,11,77,Sunny
2023-01-09,13,72,Sunny
2023-01-10,14,68,Sunny

# 读取数据
weather_df = pd.read_csv('weather_data.csv')

# 查看数据集的前几行
print(weather_df.head())

# 按天气条件统计平均温度和湿度
weather_stats = weather_df.groupby('weather_condition').agg({'temperature': 'mean', 'humidity': 'mean'})
print(weather_stats)

# 绘制天气条件与平均温度和湿度的关系图
weather_stats.plot(kind='bar')
plt.title('Weather Condition vs Temperature and Humidity')
plt.xlabel('Weather Condition')
plt.ylabel('Average Values')
plt.show()

在本节中，我们通过电商用户行为分析和其他数据分析示例，展示了如何应用数据清洗、预处理和可视化技术，进行深入的分析和洞察。
这些实际案例不仅帮助我们巩固了前面学到的知识，还提供了宝贵的经验，指导我们在实际项目中应用数据分析技术。

第10章 Web应用开发

在本章中，我们将介绍如何使用Django开发一个简单的学生管理系统。

通过这个项目，你将学会如何使用Django创建和管理数据库模型、编写视图、设计URL模式、创建表单和模板，并了解Django的认证和权限系统。以下是本章的详细章节目录：

10.1 Django简介与环境配置

10.1.1 Django简介

Django是一个高级Python Web框架，旨在快速开发和简化复杂的数据库驱动网站的创建。

它强调代码复用、组件即插即用、快速开发和不重复造轮子原则。

10.1.2 环境配置与安装

首先，我们需要确保在系统上安装了Python和pip，然后使用以下命令安装Django：

pip install django

10.1.3 创建Django项目

10.2 创建与管理数据库模型

10.3 编写视图和URL配置

10.4 创建表单和处理用户输入

第11章爬虫实战

说在最后：有问题找老架构取经

毫无疑问，与传统应用架构师相比， AI架构师更有钱途，这个代表未来的架构。

前面讲到，尼恩指导的那个一个成功案例，是一个9年经验网易的小伙伴，拿到了一个年薪近80W的大模型架构offer，逆涨50%，那是在去年2023年的 5月。

惊天大逆袭：8年小伙20天时间提75W年薪offer，逆涨50%，秘诀在这

不到1年，小伙伴也在团队站稳了脚跟，成为了名副其实的大模型架构师。回想当时，尼恩本来是规划指导小伙做通用架构师的（ JAVA 架构、K8S云原生架构），当时候为了他的钱途，尼恩也是壮着胆子，死马当作活马指导他改造为大模型架构师。

没想到，由于尼恩的大胆尝试，小伙伴成了，相当于他不到1年时间，职业身价翻了1倍多，现在可以拿到年薪 200W的offer了。

应该来说，小伙伴大成，实现了真正的逆天改命。

既然有一个这么成功的案例，尼恩能想到的，就是希望能帮助更多的社群小伙伴，成长为大模型架构师，也去逆天改命。

技术是相通的，架构也是。

尼恩架构团队的大模型《LLM大模型学习圣经》是一个系列，初步的规划包括下面的内容：

《Python学习圣经：从0到1精通Python，打好AI基础》
《LLM大模型学习圣经：从0到1吃透Transformer技术底座》
《LangChain学习圣经：从0到1精通LLM大模型应用开发的基础框架》
《LLM大模型学习圣经：从0到1精通RAG架构，基于LLM+RAG构建生产级企业知识库》
《SpringCloud + Python 混合微服务架构，打造AI分布式业务应用的技术底层》
《LLM大模型学习圣经：从0到1吃透大模型的顶级架构》

本文是第1篇，作者是资深架构师 Andy（负责初稿） +43岁老架构师尼恩（负责升华，带给大家一种俯视技术，技术自由的高度）。

尼恩架构团队会持续迭代和更新，后面会有实战篇，架构篇等等出来。并且录制配套视频。

在尼恩的架构师哲学中，开宗明义：架构和语言无关，架构的思想和模式，本就是想通的。

架构思想和体系，本身和语言无关，和业务也关系不大，都是通的。

尼恩《LLM大模型学习圣经》PDF 系列文档，会延续尼恩的一贯风格，会持续迭代，持续升级。

这个文档将成为大家学习大模型的杀手锏，此文当最新PDF版本，可以来《技术自由圈》公号获取。

本文是第3篇，第一作者是Andy，第二作者是尼恩。后面的文章，尼恩团队会持续迭代和更新。并且录制配套视频。

当然，除了大模型学习圣经，尼恩团队，持续深耕技术，为大家输出更多，更深入的技术体系，思想体系。

多年来，用深厚的架构功力，把很多复杂的问题做清晰深入的穿透式、起底式的分析，写了大量的技术圣经：

Netty 学习圣经：穿透Netty的内存池和对象池（那个超级难，很多人穷其一生都搞不懂），
DDD学习圣经：穿透 DDD的建模和落地，
Caffeine学习圣经：比如Caffeine的底层架构，
比如高性能葵花宝典
Thread Local 学习圣经
等等等等。

上面这些学习圣经，大家可以通过《技术自由圈》公众号，找尼恩获取。

大家深入阅读和掌握上面这些学习圣经之后，一定内力猛涨。

所以，尼恩强烈建议大家去看看尼恩的这些核心内容。

另外，如果学好了之后，还是遇到职业难题，没有面试机会，怎么办？

可以找尼恩来帮扶、领路。

尼恩已经指导了大量的就业困难的小伙伴上岸.

前段时间，帮助一个40岁+就业困难小伙伴拿到了一个年薪100W的offer，小伙伴实现了 逆天改命 。

技术自由的实现路径：

实现你的架构自由：

《吃透8图1模板，人人可以做架构》

《10Wqps评论中台，如何架构？B站是这么做的！！！》

《阿里二面：千万级、亿级数据，如何性能优化？教科书级答案来了》

《峰值21WQps、亿级DAU，小游戏《羊了个羊》是怎么架构的？》

《100亿级订单怎么调度，来一个大厂的极品方案》

《2个大厂 100亿级超大流量红包架构方案》

… 更多架构文章，正在添加中

免费获取11个技术圣经PDF：

posted @ 2024-06-04 18:43 疯狂创客圈阅读(161) 评论(0) 编辑收藏举报

刷新页面返回顶部