Python基础环境与原理_python的发展历程与基本语法

第一章、Python概述

一、Python语言发展史

Python之父-- 吉多.范罗苏姆

        Python是由荷兰人吉多.范罗苏姆发明的一种编程语言，是目前世界上最受欢迎和拥有最多用户群体的编程语言

        1989年，为了打发圣诞节假期，Gudio van Rossum 吉多.范罗苏姆（龟叔）决心开发一个新的解释性程序（Python雏形），Python这个名字，来自龟叔所挚爱的电视剧Monty Python's Flying Circus

        Python 是一种高级编程语言，它由Guido van Rossum于1989年创造，并在1991年首次发布。以下是 Python 语言的发展历史：

1、1989

Gudio开始写Python语言的编译器

2、1991

Python 0.9.0 - 1991年：Guido van Rossum 在圆括号的缩进方面受到 ABC 语言的影响，创建了 Python 语言的第一个版本（0.9.0），并于1991年发布。

1991年2月，第一个Python解释器诞生，它是用C语言实现的，可以调用C语言的库函数

3、1994

Python 1.0 - 1994年：1994年，Python 1.0 版本发布，这是 Python 的第一个正式版本，其中包含了一些重要的特性，如函数和模块。

4、2000

Python2.0发布，Python的整个开发过程更加透明，生态圈开始慢慢形成

Python 2.0 - 2000年：Python 2.0 版本于2000年发布，引入了重要的特性和改进，包括列表解析、垃圾回收机制等。Python 2.x 分支成为主流版本，并持续发展多年。

5、2008

        2008年12月，Python3.0发布，引入了诸多现代编程语言的新特性，但并不完全兼容之前的Python代码。

        Python 3.0 - 2008年：Python 3.0 版本于2008年发布，这是 Python 的一个重大版本升级。在 Python 3.x 分支中，为了解决之前版本的一些设计缺陷和不一致性，对语言进行了一些不兼容的改变。这导致 Python 3.x 不兼容 Python 2.x 的代码，因此在升级到 Python 3.x 的过程中需要进行一定的代码迁移。

6、2020

2020年1月，在Python2和Python3共存了11年之后，官方停止了对Python2的更新和维护，希望用户尽快过渡到Python3

7、至今

Python 3.x 发展 - 至今：自 Python 3.0 发布以来，Python 3.x 分支逐渐成为主流版本，Python 社区也一直致力于支持和改进 Python 3.x 版本。随着时间的推移，越来越多的库和框架开始支持 Python 3.x，并鼓励用户从 Python 2.x 迁移到 Python 3.x。

        值得注意的是，自2020年1月1日起，Python 2.x 分支已经停止了官方支持，Python 2.x 的版本和库将不再得到官方的更新和维护。因此，建议使用最新的 Python 3.x 版本以获取更好的功能和安全性。截至我的知识截止日期（2021年9月），Python 3.x 是 Python 社区的主要版本，并继续发展和改进。

二、Python版本号详解

大多数软件的版本号一般分为三段：形如A.B.C，其中A表示大版本号，当软件整体重写升级或出现不向后兼容的改变时，才会增加A；B表示功能更新，出现新功能时增加B；C表示小的改动（例如：修复了某个Bug），只要有修改就增加C

三、Python语言特性

        Python 是一种功能强大且灵活的高级编程语言，具有许多特性，使其在软件开发、数据科学、人工智能和网络开发等领域广泛使用。以下是 Python 语言的一些主要特性：

1、简洁易读

        Python 的语法设计简洁优雅，使代码易于阅读和编写。它使用缩进来表示代码块，而不是使用大括号，从而强制编写格式清晰的代码。

2、动态类型

        Python 是一种动态类型语言，不需要在编写代码时指定变量的数据类型。变量的类型是根据赋给它们的值来确定的。（自动类型推断）

a: int = True
print(a)
'
运行
运行

        在Python中，语法a: int = True是一种类型提示（type hint）的用法，它是在Python 3.6及更高版本中引入的特性。它用于为变量提供类型提示，表示该变量应该持有的数据类型。

        然而，需要注意的是类型提示是可选的，对代码的运行行为没有影响。Python是一种动态类型语言，意味着变量的类型是在运行时确定的，解释器不会强制执行严格的类型检查。

        在a: int = True这一行中，你提供了一个类型提示，指定变量a应该是int类型。但是，赋值a = True仍然是合法的，因为Python不会因为类型提示而引发错误。这是完全有效的Python语法，a将被赋值为True，而不是整数。

        类型提示主要用于文档和帮助开发者及工具了解变量的预期数据类型，但它们并不影响程序的实际行为。如果你想确保a是一个整数，你需要在运行时使用isinstance或其他方法手动检查和强制类型。

        总之，代码a: int = True是语法正确的，不会引发任何错误，但类型提示int不会影响变量a的运行时行为。

3、面向对象

        Python 支持面向对象编程（OOP），可以创建类和对象，并使用封装、继承和多态等面向对象的概念。

4、开放性和可扩展性

        Python 是开源的，可以在多个平台上运行，并且具有大量的第三方库和模块，可用于各种目的，如数据科学、网络开发、图形图像处理等。

5、高级内置数据结构

        Python 提供了高级的内置数据结构，如列表（list）、元组（tuple）、字典（dictionary）和集合（set），这些数据结构对于数据处理和算法实现非常有用。

6、强大的标准库

        Python 提供了广泛的标准库，涵盖了网络通信、文件处理、正则表达式、数据库接口等，方便开发人员直接使用。

7、代码复用

        Python 鼓励模块化和代码复用，可以通过导入模块和包来重用代码，从而提高代码的可维护性和重用性。

8、跨平台

        Python 支持在多个平台上运行，包括 Windows、Linux、macOS 等，同一份代码可以在不同平台上无需修改直接运行。

8.1、跨平台原理

        Python 的跨平台运行原理主要依赖于其解释型语言的特性和跨平台的编译器和运行时环境。以下是 Python 跨平台运行的原理：

1. 解释型语言：Python 是一种解释型语言，不同于编译型语言（如C++），Python 的代码在运行时由解释器逐行解释并执行，而不是先编译成机器码再执行。这使得 Python 的代码不需要针对不同平台进行编译，而是由解释器在运行时适应不同平台执行。

2. 跨平台编译器和运行时环境：Python 提供了跨平台的编译器和运行时环境。Python 解释器可以在多个操作系统上运行，包括 Windows、Linux、macOS 等，而不需要对源代码进行修改。

3. 标准库和第三方库：Python 的标准库和大量的第三方库也是跨平台的。这些库提供了各种功能和特性，包括文件操作、网络通信、图形处理、数据库接口等。由于这些库是跨平台的，因此可以在不同操作系统上使用相同的代码来实现相同的功能。

4. 平台无关的代码：Python 开发人员可以编写平台无关的代码，这意味着可以编写一份代码，在不同的操作系统上运行而无需修改。例如，Python 中使用斜杠（/）作为路径分隔符，而不用考虑不同操作系统上的路径分隔符差异（Windows 使用反斜杠 \）。

        总结起来，Python 跨平台运行的原理是基于其解释型语言的特性，使得代码在运行时可以根据不同平台的解释器逐行执行。同时，Python 提供了跨平台的编译器和运行时环境，以及标准库和第三方库的跨平台支持，使得开发人员可以编写一份平台无关的代码，在不同操作系统上运行而无需修改。这种跨平台特性使得 Python 成为一个便捷且高效的跨平台编程语言

9、脚本语言

        Python 是一种解释型语言，可以直接通过解释器执行代码，无需编译，使得开发、调试和测试更加快捷和灵活。

10、社区支持

        Python 有一个活跃的开源社区，提供了大量的资源、文档和支持，为开发者提供了宝贵的帮助和学习资源。

        由于这些特性，Python 成为一种流行且受欢迎的编程语言，被广泛用于不同领域的软件开发和科学计算。

第二章、搭建python环境

一、解释器安装

安装教程

二、IDE安装（包含创建系统环境项目，虚拟环境项目，安装第三方包等）

PyCharm安装教程

三、创建项目：系统环境和虚拟环境的区别

解释一

解释二

四、Python安装目录介绍（以Windows为例）

Python安装目录说明

        Python 的安装目录通常包含 Python 解释器和一些附带的标准库以及其他一些工具和资源。具体目录结构可能因不同的 Python 版本和操作系统而有所不同，下面是一般情况下 Python 安装目录的介绍：

解释器：

• 在 Python 的安装目录中，您会找到名为 python 或 python3 的可执行文件。这是 Python 解释器，负责解释和执行 Python 代码。

标准库：

• Python 的安装目录还包含一些标准库模块，这些模块是 Python 的一部分，提供了许多常用的功能和功能。标准库的模块可以直接导入并在代码中使用。

Scripts 或 Bin 目录：

• 在 Windows 系统上，Python 安装目录中可能包含一个名为 Scripts 的目录，其中包含了一些脚本工具，如 pip、virtualenv 等。在其他操作系统上，可能会有一个名为 bin 的目录，功能类似于 Windows 上的 Scripts 目录。

Doc 目录：

• Python 安装目录中可能包含一个名为 Doc 的目录，其中包含 Python 的官方文档和一些帮助文件，帮助您了解 Python 的使用和特性。

Include 目录：

• 在 Python 安装目录中，有一个名为 Include 的目录，其中包含一些 C 头文件，用于在开发 Python 扩展模块时使用。

libs 目录：

• 静态文件库

Lib 目录：

• 在 Python 安装目录中，可能还有一个名为 Lib 的目录，其中包含一些 Python 的扩展模块和库。

        需要注意的是，具体的目录结构可能因不同的 Python 版本和操作系统而有所不同。在 Windows 上，Python 的默认安装目录通常是 C:\PythonXX\（其中 XX 是 Python 版本号，例如 C:\Python39\）。在 Linux 或 macOS 上，通常是 /usr/local/bin/pythonX.X（其中 X.X 是 Python 版本号，例如 /usr/local/bin/python3.9）

五、Python安装完成后的四个文件

第三章、python第三库下载地址及说明

一、下载说明

在线下载说明

离线下载说明

二、第三方库下载地址

国内镜像库：https://pypi.tuna.tsinghua.edu.cn/simple

国外镜像库：https://pypi.org/search/

三、pip介绍（Python包管理工具）

pip 的全称是 "Pip Installs Packages"。它是 Python 的一个包管理工具，用于方便地安装、升级和管理第三方 Python 包。pip 允许用户从 Python Package Index（PyPI）获取并安装各种第三方库，以扩展 Python 的功能。

1、安装pip

• 如果您正在使用 Python 2.7.9 或更高版本，或者 Python 3.4 或更高版本，则 pip 已经内置在 Python 中，无需额外安装。
• 如果您使用的是早于上述版本的 Python，您可以通过在命令行中运行以下命令来安装 pip：

python -m ensurepip

2、pip install package_name[==版本号] 安装包

用于安装指定名称的 Python 包。package_name 是要安装的包名称，可以是包名，也可以是指定的版本号。

2.1、指定镜像地址

        在 pip install 命令中，您可以通过添加 -i 或 --index-url 参数来指定要使用的特定源（网址）。默认情况下，pip 会从 Python Package Index（PyPI）获取包，但您可以使用 -i 参数来安装来自其他源的包。 

2.2、第三方包安装路径

默认在site-packages目录中

        在 Python 中，第三方包的安装路径通常位于解释器的 site-packages 目录下。site-packages 目录用于存放所有第三方库和模块的安装文件，使它们可以在您的代码中被导入和使用。具体的安装路径取决于您的 Python 安装方式、操作系统和可能的虚拟环境设置。

以下是一些常见的 Python 第三方包安装路径示例：

1. 全局安装（Global Installation）： 如果您使用系统默认的全局 Python 解释器，并通过命令行中的 pip install 安装包，那么第三方包会被安装到全局解释器的 site-packages 目录中。例如，在 Linux 系统上，可能是类似这样的路径：/usr/local/lib/python3.8/site-packages。

2. 用户级安装（User-level Installation）： 如果您使用 --user 标志来安装包，那么第三方包会被安装到当前用户主目录下的 site-packages 目录。例如，~/.local/lib/python3.8/site-packages。

3. 虚拟环境（Virtual Environment）： 如果您在虚拟环境中工作，并通过 pip install 安装包，那么包会被安装到虚拟环境的 site-packages 目录下。虚拟环境的路径将会是您创建虚拟环境时指定的路径。

4. 其他安装方式： 有些工具可能使用不同的安装方式，可能会导致包被安装到其他路径中。例如，某些项目管理工具可能会在项目的特定目录下安装包。

要查找特定的第三方包安装路径，您可以执行以下步骤：

• 打开 Python 解释器或虚拟环境的命令行终端。
• 输入以下 Python 代码来获取 site-packages 目录的路径：

import site
print(site.getsitepackages())
 
//虚拟环境中：
['D:\\pythonProject\\pythonProject\\Python基础\\venv', 'D:\\pythonProject\\pythonProject\\Python基础\\venv\\lib\\site-packages', 'D:\\python3.6', 'D:\\python3.6\\lib\\site-packages']
 
//本地环境中：
['D:\\python3.6', 'D:\\python3.6\\lib\\site-packages']

在输出中查找包的安装路径。

        请注意，具体路径可能会因操作系统、Python 版本、安装方式和环境设置而有所不同。不同的 Python 解释器（全局、虚拟环境等）和安装方式（全局、用户级等）会影响包的安装路径。

使用pip install 安装的包为什么会在别的路径中的site-packages下，而不是在安装时解释器路径中的site-packages下

        Python 的包管理工具 pip 通常会将安装的包安装到与解释器路径相关联的 site-packages 目录中。然而，有时候您可能会遇到包安装到了其他路径下的情况。这可能是由于一些特定的配置、环境变量或安装方式引起的。以下是一些可能的原因：

1. 虚拟环境（Virtual Environment）： 如果您在虚拟环境中使用 pip install 安装包，那么包会被安装到虚拟环境的 site-packages 目录下，而不是全局解释器路径中的 site-packages。这是为了确保不同虚拟环境之间的包隔离。

2. 用户级安装（User-level Installation）： 如果您使用 --user 标志来安装包，那么包会被安装到用户主目录下的 site-packages 目录，而不是全局解释器路径中。这是为了避免需要管理员权限来安装包。

3. 环境变量 PYTHONPATH： 如果在您的系统中设置了 PYTHONPATH 环境变量，Python 可能会搜索该路径来查找模块和包。如果 PYTHONPATH 包含某个目录，那么 pip install 安装的包可能会被放置在那个目录下，而不是解释器路径中的 site-packages。

4. Python 版本： 有时，系统中安装了多个 Python 版本，并且某个版本的 pip 可能与其他版本的 pip 不一致，导致包被安装到了错误的 site-packages 目录中。

5. 其他安装方式： 有些工具可能会使用不同的方式来安装包，可能会导致包被安装到其他路径中。

为了确定确切的原因，您可以检查以下几个方面：

• 您是否在虚拟环境中工作？
• 是否使用了 --user 标志来安装包？
• 是否设置了 PYTHONPATH 环境变量？
• 是否存在多个 Python 版本？
• 是否使用了其他工具来安装包？

根据您的情况，您可以采取适当的步骤来确保包被正确地安装到解释器路径中的 site-packages 目录下。

3、pip install --upgrade package_name 升级包

用于将已安装的包升级到最新版本。package_name 是要升级的包名称。

4、pip uninstall package_name 卸载包

用于卸载已安装的 Python 包。package_name 是要卸载的包名称。

5、pip list 查看已安装的包

显示当前已安装的所有 Python 包及其版本号。

6、pip show package_name 查看包信息

显示指定包的详细信息，包括名称、版本、作者、描述等。

7、pip search package_name 查找包

在 PyPI 中搜索指定的包。package_name 是要搜索的包名称。

8、pip install -r requirements.txt 使用 requirements 文件安装多个包

        从 requirements.txt 文件中批量安装多个包。requirements.txt 是一个文本文件，列出了要安装的包及其版本号。将requirements.txt文件放置在命令行所在目录中。

requirements.txt文件中的内容：

requests==2.26.0
pandas==1.3.1

 要使用 requirements 文件来安装这些包，可以运行以下命令：

pip install -r requirements.txt

9、pip freeze > requirements.txt 导出已安装的包到 requirements 文件

        将当前已安装的所有包及其版本号导出到 requirements.txt 文件中，方便创建虚拟环境或共享项目依赖。

        当您在命令行中执行 pip freeze > requirements.txt 后，requirements.txt 文件会被创建在当前命令行所在的目录下，并包含当前已安装的包及其版本信息。您可以使用文本编辑器打开这个文件，查看其中的内容，或者将该文件分享给其他人或用于其他环境的包管理。

        总结：pip 是 Python 的包管理工具，它使得安装、升级和管理 Python 包变得非常简单。通过 pip，您可以方便地获取并使用来自 PyPI 的各种第三方库，从而扩展 Python 的功能并提高开发效率。

四、设置pip默认下载网址

pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple

 

第四章、Python运行原理

一、Python SDK （Python解释器Interpreter）

        Python 解释器是执行 Python 代码的核心组件，它负责读取源代码、将其转换成字节码并逐行执行，从而使 Python 代码能够运行。

        Python 解释器有多种实现，其中最常见的是 CPython，它是官方标准实现，用 C 语言编写。以下是对一些常见的 Python 解释器的介绍：

1、CPython（最常见）

• CPython 是官方标准的 Python 解释器，由 Python 语言的创始人 Guido van Rossum 编写，并开源发布。
• CPython 使用解释器将 Python 源代码编译成字节码（即中间形式的机器码），然后逐行执行字节码。
• CPython 是最广泛使用的 Python 解释器，它具有良好的性能和稳定性，并支持大多数的 Python 第三方库和扩展。

2、Jython：

• Jython 是用 Java 实现的 Python 解释器，它允许 Python 代码在 Java 平台上运行。
• Jython 将 Python 代码编译成 Java 字节码，并在 Java 虚拟机（JVM）上执行。
• Jython 允许 Python 开发者利用 Java 生态系统的功能，并将 Python 和 Java 代码无缝地集成在一起。

3、IronPython：

• IronPython 是用 C# 实现的 Python 解释器，它允许 Python 代码在 .NET 平台上运行。
• IronPython 将 Python 代码编译成 .NET 字节码，并在 .NET Framework 或 .NET Core 上执行。
• IronPython 允许 Python 和 C# 代码之间的互操作性，使 Python 可以在 .NET 生态系统中得到广泛应用。

4、Pypy：

• 用Python实现的Python解释器
• 是性能最快的Python解释器，提前将部分Python代码进行编译

        除了以上的实现之外，还有其他一些 Python 解释器，如 PyPy（JIT 编译器实现）、MicroPython（适用于嵌入式系统）等，它们各自具有不同的优势和适用场景。

        Python 解释器的选择取决于特定的用途和需求。CPython 是最常用的 Python 解释器，适用于绝大多数的通用编程任务。如果需要与特定平台或生态系统进行深度集成，可以考虑 Jython 或 IronPython。而在某些特殊场景下，其他解释器如 PyPy 或 MicroPython 可能提供更好的性能和资源优化。

二、Python运行原理

Python 的运行原理涉及解释器、字节码和虚拟机等组件。下面是 Python 的运行原理的简要概述：

1、解释器启动（Interpreter）：

• Python 是一种解释型语言，不同于编译型语言（如C++，Java），Python 的代码在运行时由解释器逐行解释并执行，而不是先编译成机器码再执行。
• 解释器是 Python 程序执行的核心组件，它读取源代码，将其转换成中间形式（字节码）并逐行执行。

2、源代码到字节码的编译

• 在 Python 程序运行之前，解释器将源代码编译成字节码（bytecode），字节码是一种与特定硬件无关的中间形式的机器码。
• 字节码包含了源代码的指令序列、操作数等信息，它以 .pyc 文件的形式保存在内存中，用于执行 Python 程序。

2.1、类型检查

mypy的基本使用

        在 Python 解释器中，源代码在执行之前不会进行显式的类型检查。Python 是一种动态类型语言，它允许变量在运行时绑定到任意类型的值，而无需在编码时指定类型。

        这意味着在 Python 中，变量的类型是在运行时确定的。Python 解释器会根据变量的值自动推断其类型，并根据需要进行类型转换。这种动态类型特性使得 Python 编程更加灵活和便捷，同时也使得编码更加简洁，不需要显式地声明变量的类型。

        然而，为了提高代码的可读性和维护性，以及减少类型错误带来的潜在问题，Python 社区也开发了一些类型检查工具，其中最受欢迎的是 mypy。

mypy 是一个用于 Python 的静态类型检查工具，它可以在编码时检查代码中的类型错误。使用 mypy 可以为 Python 代码添加类型注释，然后在编码阶段运行 mypy 命令来检查代码中的类型问题。这样可以在开发过程中尽早发现潜在的类型错误，并帮助开发者更好地理解代码。

        虽然 mypy 可以提供静态类型检查的支持，但它不是 Python 解释器的一部分，而是作为第三方工具提供的。因此，即使在没有 mypy 的情况下，Python 解释器仍然可以运行代码，并根据运行时的实际情况执行类型转换。

2.2、将py文件编译为pyc文件

在 Python 中，.py 文件和 .pyc 文件是两种不同的文件类型，它们在 Python 代码的运行和执行过程中扮演着不同的角色。

.py 文件：

• .py 文件是包含 Python 源代码的文件。它们是以文本形式存储的，通常由开发者编写，并包含了 Python 代码的原始文本形式。
• 当您运行一个 .py 文件时，Python 解释器会读取并解释其中的源代码，并将其转换为字节码，然后逐行执行代码。

.pyc 文件：

• .pyc 文件是编译过的字节码文件。在 Python 解释器首次运行一个 .py 文件时，它会将源代码编译成字节码，并将字节码保存到一个与 .py 文件相关的 .pyc 文件中。
• .pyc 文件不是以文本形式存储的，而是以二进制形式存储的，这使得解释器在后续执行同样的 .py 文件时可以直接加载 .pyc 文件而无需重新编译源代码。
• .pyc 文件在 Python 解释器的后续运行中可以提高执行速度，因为它避免了重复的编译过程，从而加快了代码的加载和执行。

        值得注意的是，.pyc 文件是平台无关的，这意味着它们可以在不同操作系统上共享，因为它们只包含 Python 字节码，而不涉及特定硬件或平台的信息。当您在 Python 程序中导入模块时，Python 解释器会首先查找对应的 .pyc 文件，如果找到了，就会加载 .pyc 文件并执行其中的字节码，如果没有找到或者 .pyc 文件过期（源代码有更新），则会重新生成一个新的 .pyc 文件。

总结：.py 文件是包含 Python 源代码的文件，而 .pyc 文件是编译过的字节码文件，用于加快 Python 代码的加载和执行速度。

3、PVM虚拟机启动（Virtual Machine）：

• Python 解释器包含了一个虚拟机，它是一个运行字节码的执行环境。
• 虚拟机逐行读取字节码指令，解释并执行这些指令，从而实现 Python 代码的运行。

4、GIL全局解释器锁启动（Global Interpreter Lock）：

• Python 中的 CPython 解释器（官方标准实现）在同一时刻只允许一个线程执行 Python 字节码，这是由全局解释器锁（GIL）所限制的。
• GIL 的存在导致 Python 的多线程程序在同一时刻只能有一个线程执行 Python 字节码，这可能影响多线程程序的性能。

4.1、Python默认为单线程同步，支持多线程

代码运行规则：Python是同步（sync）的，代码都是遵守自上而下的顺序一次执行的，逐行执行。上一行的代码必须完整的结束之后，下一行的代码才会执行

5、执行 Python 代码：

• 解释器读取字节码指令并逐行执行，根据指令来操作变量、执行函数调用、处理异常等，从而执行 Python 程序的逻辑。

6、平台无关性：

• Python 的字节码是与特定硬件平台无关的，这使得 Python 程序具有高度的可移植性和跨平台性。Python 的 .pyc 文件可以在不同平台上运行，因为它们只包含了字节码，而不涉及底层硬件。

        总结：Python 的运行原理是通过解释器将源代码编译成字节码，然后由虚拟机执行字节码来运行 Python 代码。解释器、字节码和虚拟机等组件共同构成了 Python 的运行环境，使得 Python 成为一种灵活、高级和跨平台的编程语言。

三、解释型语言（Python）和编译型语言（Java）的区别

        解释型语言和编译型语言是两种不同的编程语言类型，它们在代码执行的方式和一些特性上存在区别。下面是它们的主要区别：

1、执行方式：

• 编译型语言：在编译型语言中，代码需要先经过编译器的处理，将源代码转换成机器码或字节码。这个过程发生在程序执行之前，并生成一个可执行文件。在运行时，计算机直接执行这个可执行文件，无需再次编译源代码。
• 解释型语言：在解释型语言中，代码不需要经过显式的编译过程。解释型语言的解释器逐行读取源代码，并将其转换成机器码或字节码，并直接执行这些中间代码。解释型语言在运行时逐行解释和执行源代码。

2、可移植性：

• 编译型语言：由于生成了可执行文件，编译型语言的程序可以在不同平台上直接运行，但需要在每个平台上重新编译生成对应的可执行文件，因此可移植性稍差。
• 解释型语言：解释型语言的程序不需要生成可执行文件，而是直接在解释器上运行，因此具有更好的可移植性。只要在目标平台上安装了相应的解释器，程序就可以运行。

3、开发效率：

• 编译型语言：编译型语言在执行之前需要显式地编译代码，这个过程可能需要一些时间，但在运行时通常比解释型语言更高效。
• 解释型语言：解释型语言无需显式编译，因此开发和测试效率通常较高。然而，解释型语言在运行时可能会比编译型语言稍微慢一些。

4、调试：

• 编译型语言：由于生成了可执行文件，编译型语言的调试过程可能相对复杂。调试通常需要源代码和可执行文件之间的映射。
• 解释型语言：解释型语言的调试相对容易，因为源代码直接在解释器中执行，可以直接在源代码级别进行调试。

        常见的编译型语言包括C、C++，而常见的解释型语言包括Python、JavaScript等。每种类型的语言都有其优势和适用场景，选择合适的语言取决于项目需求、性能要求和开发团队的偏好。

第五章、Python设计哲学

一、思想

Python 作为一种高级编程语言，有着清晰而独特的设计哲学，这些理念被称为 "Python设计哲学" 或 "Python之禅"，它们包括了以下原则：

1. 优雅明确（Beautiful is better than ugly）：Python 代码应该是简洁、清晰、易读和易于理解的，而不是晦涩难懂的。这使得 Python 代码更加可维护和易于扩展。

2. 明确优于隐晦（Explicit is better than implicit）：Python 鼓励明确表达，避免使用隐含的或神秘的语法和语义。这有助于减少代码错误和提高代码的可读性。

3. 简单优于复杂（Simple is better than complex）：Python 倡导使用简单的解决方案来解决问题，而不是过度复杂化。这使得代码更易于理解和维护。

4. 复杂优于复杂（Complex is better than complicated）：尽管 Python 倡导简单性，但这并不意味着不允许复杂性。当问题本身具有复杂性时，允许使用适当的复杂性解决方案，而不是仅仅为了遵循简单性原则而简化问题。

5. 扁平优于嵌套（Flat is better than nested）：Python 倡导避免过多的嵌套结构，尽可能保持代码的扁平化。这使得代码更易于阅读和调试。

6. 可读性很重要（Readability counts）：Python 倡导代码的可读性是至关重要的。代码应该易于理解和解释，使得协作开发和维护变得更加容易。

7. 特例不足以打破规则（Special cases aren't special enough to break the rules）：即使某些特殊情况需要特殊处理，也不应该打破基本的设计原则和规则。一致性和规范性是 Python 设计的重要原则之一。

8. 优先考虑异常而不是默认（Errors should never pass silently）：Python 鼓励显示地处理异常，避免错误悄无声息地发生。这有助于提高代码的健壮性和可靠性。

这些设计原则使得 Python 成为一种简单、易学、功能强大且灵活的编程语言，适用于多种用途，包括 Web 开发、科学计算、自动化脚本等。

二、鸭子类型

        在面向对象编程中，鸭子类型（Duck Typing）是一种动态类型的概念，它强调对象的行为比对象的类型更重要。鸭子类型是基于这样一种思想：如果一个对象具有与特定类型无关的合适的方法或属性，那么它就可以被视为属于该类型。这种概念源于Python程序设计语言，它倡导"如果它看起来像鸭子，游泳像鸭子，叫声像鸭子，那么它就是鸭子"。

        在Python中，鸭子类型意味着对象的适用性不是由对象的类别确定的，而是由对象是否具有特定的方法和属性来决定。这使得Python能够更灵活地处理对象，而不必严格遵循传统的继承体系。例如，如果一个对象具有执行特定操作所需的方法，那么它就可以用作该操作的参数，即使它不是严格意义上的特定类型。

        一个简单的示例是，如果一个对象具有 quack() 方法和 walk() 方法，那么它可以被视为鸭子，即使它不是鸭子类的实例。在以下示例中，duck_test 函数接受一个对象作为参数，并调用该对象的 quack() 和 walk() 方法：

class Duck:
    def quack(self):
        print('Quack!')
 
    def walk(self):
        print('Walk like a duck')
 
class Person:
    def quack(self):
        print('I am quacking like a duck!')
 
    def walk(self):
        print('I am walking like a duck')
 
def duck_test(duck):
    duck.quack()
    duck.walk()
 
# Duck 类型对象
duck = Duck()
duck_test(duck)
 
# Person 类型对象
person = Person()
duck_test(person)
'
运行
运行

通过使用鸭子类型，Python鼓励开发人员编写灵活的代码，可以接受多种类型的对象，只要这些对象具有所需的方法和属性。 

第六章、Python中的注释

        在 Python 中，注释是用来向代码添加解释、说明或文档的说明性文本，对代码的执行没有实际影响。Python 支持两种注释方式：单行注释和多行注释

一、单行注释

以井号 # 开头的内容被视为单行注释。在 # 后的所有内容都会被解释器忽略。

注意：#号和注释内容一般建议以一个空格隔开

单行注释：一般用于对一行或一小部分代码进行注释

# 这是一个单行注释
print("Hello, World!")  # 这是输出语句，不会被注释
'
运行
运行

二、多行注释

Python 没有官方的多行注释语法，但通常使用三个单引号 ''' 或三个双引号 """ 来表示多行注释。虽然这实际上是字符串，但由于没有被赋值给任何变量，因此它们被解释器忽略。

多行注释支持换行

多行注释一般用于解释：整个python代码文件，类，方法

'''
这是一个多行注释
可以跨越多行
'''
print("Hello, World!")  # 这是输出语句，不会被注释
'
运行
运行

        请注意，注释对于代码的可读性和维护性非常重要。良好的注释可以使代码更易于理解，同时也有助于其他开发者了解代码的意图和功能。建议在代码中充分使用注释，特别是对于复杂的算法、函数、类和逻辑部分，以便提高代码的可读性和可维护性。

三、文档字符串（docstring）

在 Python 中，文档字符串是位于函数、类、模块开头的字符串，它们可以用来描述函数、类、方法或模块的作用、输入、输出以及使用方法等。文档字符串一般位于对象定义的下一行，并使用三重引号（"""）或单引号（'''）括起来。

def my_function(arg1, arg2):
    """
    This is the docstring of the function.
    It can be multiline and can contain information about the function's purpose, parameters, and return values.
    """
    pass
'
运行
运行

四、快捷注释 ctrl + /

ctrl+/   选中目标内容