查看 Python 版本

我们可以在命令提示符/终端中使用以下命令来查看我们使用的 Python 版本：

python -V

以上命令执行结果如下：

Python 3.8.5

在命令提示符/终端中输入python并回车可以进入 Python 的交互式编程模式，在这里也可以查看版本：

Python 3.8.5 (tags/v3.8.5:580fbb0, Jul 20 2020, 15:57:54) [MSC v.1924 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>

第一个 Python3.x 程序

1. 对于大多数程序语言，第一个入门编程代码便是"Hello World！"，以下代码为使用 Python 输出"Hello World！"：

#!/usr/bin/python3print("Hello, World!")

• ​​#!/usr/bin/python3​​ ：指定用什么解释器运行脚本以及解释器所在的位置，如果解释器没有装在/usr/bin/目录，改成其所在目录就行了，或者更通用的方法是：
  ​#!/usr/bin/env python3​。
• 在Windows环境下这并不是必要的代码。

2. 你可以将以上代码保存在 ​hello.py​ 文件中并使用 python 命令执行该脚本文件。

python hello.py

3. 以上命令输出结果为：

Hello, World!

 本节对学习python编程没有太多实质性的帮助，但本节介绍了一些python的历史和特性，有兴趣的小伙伴可以了解一下。

Python 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。

Python 的设计具有很强的可读性，相比其他语言经常使用英文关键字，其他语言的一些标点符号，它具有比其他语言更有特色语法结构。

• Python 是一种解释型语言： 这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。
• Python 是交互式语言： 这意味着，您可以在一个 Python 提示符 >>> 后直接执行代码。
• Python 是面向对象语言: 这意味着Python支持面向对象的风格或代码封装在对象的编程技术。
• Python 是初学者的语言：Python 对初级程序员而言，是一种伟大的语言，它支持广泛的应用程序开发，从简单的文字处理到服务器再到游戏，它都可以胜任。

Python 发展历史

Python 是由 Guido van Rossum 在八十年代末和九十年代初，在荷兰国家数学和计算机科学研究所设计出来的。

Python 本身也是由诸多其他语言发展而来的,这包括 ABC、Modula-3、C、C++、Algol-68、SmallTalk、Unix shell 和其他的脚本语言等等。

像 Perl 语言一样，Python 源代码同样遵循 GPL(GNU General Public License)协议。

现在 Python 是由一个核心开发团队在维护，Guido van Rossum 仍然占据着至关重要的作用，指导其进展。

Python 2.0 于 2000 年 10 月 16 日发布，增加了实现完整的垃圾回收，并且支持 Unicode。

Python 3.0 于 2008 年 12 月 3 日发布，此版不完全兼容之前的 Python 源代码。不过，很多新特性后来也被移植到旧的Python 2.6/2.7版本。

Python 3.0 版本，常被称为 Python 3000，或简称 Py3k。相对于 Python 的早期版本，这是一个较大的升级。

Python 2.7 被确定为最后一个 Python 2.x 版本，它除了支持 Python 2.x 语法外，还支持部分 Python 3.1 语法。

Python 特点

• 1.易于学习：Python有相对较少的关键字，结构简单，和一个明确定义的语法，学习起来更加简单。
• 2.易于阅读：Python代码定义的更清晰。
• 3.易于维护：Python的成功在于它的源代码是相当容易维护的。
• 4.一个广泛的标准库：Python的最大的优势之一是丰富的库，跨平台的，在UNIX，Windows和Macintosh兼容很好。
• 5.互动模式：互动模式的支持，您可以从终端输入执行代码并获得结果的语言，互动的测试和调试代码片断。
• 6.可移植：基于其开放源代码的特性，Python已经被移植（也就是使其工作）到许多平台。
• 7.可扩展：如果你需要一段运行很快的关键代码，或者是想要编写一些不愿开放的算法，你可以使用C或C++完成那部分程序，然后从你的Python程序中调用。
• 8.数据库：Python提供所有主要的商业数据库的接口。
• 9.GUI编程：Python支持GUI可以创建和移植到许多系统调用。
• 10.可嵌入: 你可以将Python嵌入到C/C++程序，让你的程序的用户获得"脚本化"的能力。

Python 应用

• 网站建设，以下网站应用了python进行web开发：
• Youtube - 视频社交网站
• Reddit - 社交分享网站
• Dropbox - 文件分享服务
• 豆瓣网 - 图书、唱片、电影等文化产品的资料数据库网站
• 知乎 - 一个问答网站
• 果壳 - 一个泛科技主题网站
• Bottle - Python微Web框架
• EVE - 网络游戏EVE大量使用Python进行开发
• Blender - 使用Python作为建模工具与GUI语言的开源3D绘图软件
• Inkscape - 一个开源的SVG矢量图形编辑器。
• 机器学习与人工智能 - TensorFlow，Keras，pytorch等机器学习库让python成为最适合机器学习的语言
• 数据分析与数据挖掘 - 各式各样的python爬虫可以帮助数据分析工程师获取数据，而丰富的python数据处理库可以处理这些数据并以可视化形式或者可调用形式展现出来
• 科学计算和算法设计 - 曾经matlab作为科学计算的行业标杆，但现在python正在蚕食它的市场。而简单的语法让python更适合进行算法开发（算法工程师可以轻松上手算法开发）
• IDLE - 作为python安装时自带的IDE，这款IDE就是由 Guido van Rossum 使用python+tkinter写出来的。
• ···

python的缺点

有优点就会有缺点，python作为一门解释型语言，拥有了解释型语言的优点（跨平台可移植性，动态变量等）也有解释型语言的缺点（效率较低）。另外，python作为一门近乎万能的语言，就像瑞士军刀一样，他拥有很多功能，但在具体的功能上都不如一些专精的语言，当对性能有一定要求的时候，python不是好选择！

本章节将向大家介绍 Python 最新版开发环境的安装步骤及如何进行环境配置，刚入门的新手学员可以跟着本章内容进行学习。

本章节需要用到的Python 最新源码，二进制文档，新闻资讯等可以在 Python 的官网查看：

• Python 官网：https://www.python.org/

你可以在以下链接中下载 Python 的文档，你可以下载 HTML、PDF 和 PostScript 等格式的文档。

• Python 文档下载地址：https://www.python.org/doc/

Python 安装

• Python 已经被移植在许多平台上（经过改动使它能够工作在不同平台上）。
• 您需要下载适用于您使用平台的二进制代码，然后安装 Python。
• 如果您平台的二进制代码是不可用的，你需要使用 C 编译器手动编译源代码。
• 编译的源代码，功能上有更多的选择性， 为 Python 安装提供了更多的灵活性。

以下为不同平台上安装 Python 的方法：

Unix & Linux 平台安装 Python:

以下为在 Unix & Linux 平台上安装 Python 的简单步骤：

• 打开 WEB 浏览器访问 https://www.python.org/downloads/source/
• 选择适用于 Unix/Linux 的源码压缩包。
• 下载及解压压缩包 Python-3.x.x.tgz，3.x.x 为你下载的对应版本号。
• 如果你需要自定义一些选项修改 Modules/Setup

以 Python3.8.5 版本为例：

# tar -zxvf Python-3.8.5.tgz# cd Python-3.8.5# ./configure# make && make install

检查 Python3 是否正常可用：

# python3 -VPython 3.8.5

python作为Linux系统的一个依赖，很多Linux系统都会默认安装python环境（甚至误删python环境会导致系统崩溃），在很长一段时间里，很多Linux系统都默认安装了python2，这时候学习python3就需要安装新版本的python3，而且由于Linux系统依赖的是python2，所以python2版本不能卸载。但随着python2停止维护结束了他的使命，大多数Linux系统已经更新到了python3版本，如果对python3的小版本没有特殊要求的话，最新的Linux系统基本可以做到不需要安装即可使用python环境（小编之前安装的centos 8内置的python版本为3.6.8，已经能基本满足普通的python学习需求了）。

Windows 平台安装 Python:

以下为在 Windows 平台上安装 Python 的简单步骤：

• 打开 WEB 浏览器访问https://www.python.org/downloads/windows/
                    
  
• 在下载列表中选择 Windows 平台安装包，包格式为：python-3.8.5-amd64.exe 文件 ， -3.8.5 为你要安装的版本号，-amd64为你系统的版本。
• 下载后，双击下载包，进入 Python 安装向导，安装非常简单，你只需要使用默认的设置一直点击"下一步"直到安装完成即可。

Windows x86-64 为 64 位版本

Windows x86 为 32 位版本

自python3.9起，官方不再支持在win7及以下版本安装和运行python，但我们仍可通过编译源代码的形式来给win7安装更高版本的python。

MAC 平台安装 Python:

MAC 系统一般都自带有 Python2.7 版本 的环境，你也可以在链接 https://www.python.org/downloads/mac-osx/ 上下载最新版安装。

环境变量配置

• 程序和可执行文件可以在许多目录，而这些路径很可能不在操作系统提供可执行文件的搜索路径中。
• path (路径)存储在环境变量中，这是由操作系统维护的一个命名的字符串。这些变量包含可用的命令行解释器和其他程序的信息。
• Unix 或 Windows 中路径变量为 PATH（UNIX 区分大小写，Windows 不区分大小写）。
• 在 Mac OS 中，安装程序过程中改变了 python 的安装路径。如果你需要在其他目录引用 Python，你必须在 path 中添加 Python 目录。

 简单地说，​python​这个指令（还记得上一节介绍的​python -v​嘛，这就是python指令）在系统中是不存在的，安装完python后就有了python这个指令，但我们需要告诉系统，在哪里可以找到python这个指令，而path路径变量，就是起到这样一个作用。

在 Unix/Linux 设置环境变量

• 在 csh shell: 输入 

  setenv PATH "$PATH:/51coolma/local/bin/python"

  按下 Enter。
• 在 bash shell (Linux) 输入 :
  

  export PATH="$PATH:/51coolma/local/bin/python" 

  按下 Enter 。
• 在 sh 或者 ksh shell 输入: 

  PATH="$PATH:/51coolma/local/bin/python"

  按下 Enter。

注意: /51coolma/local/bin/python 是 Python 的安装目录。

在 Windows 设置环境变量

 注意！在python安装的时候勾选自动添加python到path路径可可以免去配置环境这个过程，本教程介绍的是当在命令提示符中输入python显示指令不存在的情况下需要进行的操作。

在环境变量中添加 Python 目录：

在命令提示符中(cmd) : 输入

path=%path%;C:Python 

按下"Enter"。

注意: C:Python 是 Python 的安装目录。

也可以通过以下方式设置：

• 右键点击"计算机"，然后点击"属性"
• 然后点击"高级系统设置"
• 选择"系统变量"窗口下面的"Path",双击即可！
• 然后在"​Path​"行，添加 python 安装路径即可(我的D:Python32)，所以在后面，添加该路径即可。 ps：记住，路径直接用分号"​;​"隔开！
• 最后设置成功以后，在 cmd 命令行，输入命令"​python​"，就可以有相关显示。

在win10中配置环境变量与win7类似：

在电脑桌面右键点击此电脑，点击属性选项。

在关于页面中选择高级系统设置，点击环境变量进行环境变量的配置。

只需在 PATH 变量原有的变量上新增以下变量值即可：

Python 的安装文件夹。

python 安装文件夹下的 Scripts 文件夹。

 注意！添加python路径是为了配置python指令，使得python指令可以使用，而配置script文件夹则是为了配置pip指令（一个python包管理工具）。

另外，在安装python的时候如果有勾选添加环境变量的话（下图 add python 3.9 to path），默认会将环境变量配置完毕。

Python 环境变量

下面几个重要的环境变量，它应用于 Python：

运行Python

有三种方式可以运行 Python：

1. 交互式解释器：

• 你可以通过命令行窗口进入 Python，并在交互式解释器中开始编写 Python 代码。
• 你可以在 Unix、DOS 或任何其他提供了命令行或者 shell 的系统进行 Python 编码工作。

$ python # Unix/Linux

或者

C:>python # Windows/DOS

以下为Python命令行参数：

2. 命令行脚本

在你的应用程序中通过引入解释器可以在命令行中执行 Python 脚本，如下所示：

$ python script.py # Unix/Linux

或者

C:>python script.py # Windows/DOS

注意：在执行脚本时，请检查脚本是否有可执行权限。

3. 集成开发环境（IDE：Integrated Development Environment）: PyCharm

• PyCharm 是由 JetBrains 打造的一款 Python IDE，支持 macOS、 Windows、 Linux 系统。
• PyCharm 功能 : 调试、语法高亮、Project管理、代码跳转、智能提示、自动完成、单元测试、版本控制等
• PyCharm 下载地址 : https://www.jetbrains.com/pycharm/download/
• PyCharm 安装教程地址 :https://www.51coolma.cn/python3/python3-l4i738c3.html
• Python IDE 安装教程地址：https://www.51coolma.cn/python/python-ide.html

领取免费资料

扫描下方二维码或打开微信搜一搜“51coolma编程狮”关注公众号回复关键词【Python123】或者【Python资料包】免费领取 Python 学习资料，包含软件安装包，电子书、思维导图等

python软件介绍

python安装完后，在开始菜单会有如下的一个文件夹：

他们分别是：

• IDLE：由python之父开发的一个小型的python开发环境，可以用来解释执行python代码，也可以用来写python脚本。
• Python：这个就是python的解释器，可以用来解释执行python代码，使用命令行调用python命令的时候就是运行的这个程序。
• Python Manuals：这个是python的使用手册，可以用来学习python的基础使用。
• Python Module Docs：这个是python的模块文档，可以用来学习模块的使用。

python代码执行方式

python代码的执行方式有两种，一种是交互型的解释执行方式，另一种是将python写成脚本代码的形式，然后使用解释器执行，两种执行方式有所不同：

交互型执行方式

这种执行方式类似人与人之间的对话，写一句代码执行一句代码。这种类型类似人的交互行为，所以被称为交互执行方式，使用这种交互方式最大的特点是：在命令行界面中有​>>>​作为每行代码的开头。如下图所示：

接下来本手册中的代码只要是带有>>>的都是在交互型解释器中运行后的结果，没有>>>的代码都是python脚本代码。

进入交互型解释器的方式有如下几种方式：

• 命令行方式：按win + r键，输入cmd，点击回车，进入命令行界面，然后输入python，点击回车，即可进入命令行界面，在命令行中输入python并按回车执行，即可进入命令行界面。
• 运行方式：按win + r键，输入python，点击回车，即可直接进入python解释器页面。
• 直接运行程序：安装的python中里面有一个选项是python，直接点击这个选项就可以进入python解释器。
• IDLE：安装的python中里面有一个选项是IDLE，直接点击后进入的也是python解释器。

交互型编程在代码调试中比较常见，更好的交互型编程的体验可以了解ipython或者jupyter notebook。

如何退出？

在交互型解释器中输入​exit()​按回车即可退出。

如何换行&缩进？

python以换行作为代码结束的标志（也就是说，点击换行立马执行这个代码），但这并不是绝对的，当代码的最后一个标识符是​:​时可以换行（因为出现​:​的时候都是进入代码块的情况，比如条件语句，循环语句，函数等）。

python以缩进来区分代码块，所以在出现上述的换行情况的时候，需要搭配空格键（注意，不是Tab键！）来进行代码缩进（使用空格数并不强制，但同一代码块之间的缩进应该相同）。处于代码块内时，​>>>​会变成​...​。如下代码所示：

>>>the_world_is_flat = True>>>if the_world_is_flat:...    print("Be careful not to fall off!")...Be careful not to fall off!

在代码块需要结束的地方，换行后点击回车即可。

所以上面的代码的输入方式应该是这样的：输入第一行语句，点击回车，输入第二行语句（注意末尾的冒号），点击回车，输入四个空格，输入第三行语句（该语句是代码块内的语句），回车，回车（结束这个代码块）。最后一行是代码运行结果。

 在交互型解释器中，代码如果会产生输出，会直接打印在控制台，输出和代码的区别是：代码前面有​>>>​。

脚本代码执行方式

这种方式是大多数编程语言执行方式（先写代码，然后一次执行），如果把代码解释比喻为做菜的话，交互型解释方式类似于看一个步骤做一个步骤，而脚本代码执行方式则是看完全部步骤后再逐步做。这种方式也是未来我们学习python编程中最常遇到的编程方式。

 不同工具（IDE）的编程方式不同，这里小编放到下一节介绍，这里我们介绍一下IDLE的脚本代码编写方式。

点击打开IDLE，我们可以进入到python的shell（命令行，也就是交互型解释器）界面，点击File，选择New File。可以新建一个脚本代码文件（也可以使用Ctrl + N 进行新建脚本代码文件）。就会弹出一个窗口，这时候我们就可以在这个窗口里面写python代码了。

 虽然IDLE相对比较简单，但它也提供了代码着色等实用的功能，如果没有什么很好的python代码编辑器，不妨尝试一下它！

写完代码后可点击run，选择run module（或者直接按F5），就可以运行代码了。

初次运行需要先保存代码并给代码文件命名，后续代码更改也要重新保存代码。

另外，IDLE也可以打开以​.py​为后缀的文件，与新建类似，点击File，选择Open...，可以打开本地的python代码文件（py代码文件以​.py​为后缀）。运行方式与新建方式相同。

 这意味着python可以使用其他的代码编辑器进行代码编写，再使用IDLE去运行，但是实际上我们不会这么做，因为执行python代码不一定要用IDLE，使用python命令也可以。这为我们使用vscode这样的代码编辑器去写代码然后使用命令行运行提供了一种可能，而vscode的插件把这样的功能实现了。在后续章节中我们将介绍如何使vscode来写python代码。

如何使用命令行运行python脚本？

在命令提示符中使用python命令就可以运行python脚本了，python命令的使用方法如下：

​python 要运行的文件.py​

示例：

Q&A

什么是命令行？

命令行是系统提供的一种工具，可以用这些工具来执行一些系统提供的功能，常见的命令行有：Linux的终端，Windows的cmd，windows的powershell（进阶版的cmd）。

命令行在一些工具中也存在，比如说vscode就提供了命令行窗口，python著名的IDEpycharm也有提供命令行窗口和交互型解释器的窗口。

 powershell作为微软用来替代老旧的cmd的终端，powershell拥有更强大的功能，所有在cmd上可以实现的指令在powershell上都可以实现。找不到命令提示符（或者想要尝试新事物）的小伙伴可以尝试使用。

Linux/Unix 的系统上，Python 解释器通常被安装在 /usr/local/python3 这样的有效路径（目录）里。

我们可以将路径 /usr/local/python3/bin 添加到您的 Linux/Unix 操作系统的环境变量中(最好参照您 Python 的安装路径进行添加)，这样您就可以通过 shell 终端输入下面的命令来启动 Python 。

$ PATH=$PATH:/user/local/python3/bin/python #设置环境变量$ python3 --vesionPython 3.7.6

在 Window 系统下你可以通过以下命令来设置 Python 的环境变量，假设你的 Python 安装在 C:Python37 下:

set path=%path%;C:python37

交互式编程

打开 IDLE，默认的就是交互式编程，类似于一个 cmd 窗口。

我们可以在命令提示符中输入 "Python" 命令来启动 Python 解释器：

$ python3

执行以上命令后，出现如下窗口信息：

$ python3Python 3.4。0 (default, Mar 16 2014, 09:25:04)[GCC 4.8.2] on linuxType "help", "copyright", "credits" or "license" for more information.>>>

在 Python 提示符中输入以下语句，然后按回车键查看运行效果：

print ("Welcome to W3Cschool!");

以上命令执行结果如下：

当键入一个多行结构时，续行是必须的。我们可以看下如下 if 语句：

>>> the_world_is_flat = True>>> if the_world_is_flat:...     print("Be careful not to fall off!")...Be careful not to fall off!

脚本式编程

点击 File→New 后新建脚本文件，在此文件下进行的是脚本式编程。

将如下代码拷贝至 W3C.py 文件中：

print ("Welcome to W3Cschool!");

通过以下命令执行该脚本：

python W3C.py

输出结果为：

Welcome to W3Cschool!

在 Linux/Unix 系统中，你可以在脚本顶部添加以下命令让 Python 脚本可以像 SHELL 脚本一样可直接执行：

#! /usr/bin/env python3.7

然后修改脚本权限，使其有执行权限，命令如下：

$ chmod +x W3C.py

执行以下命令：

./hello.py

输出结果为：

Welcome to W3Cschool!

VSCode（全称：Visual Studio Code）是一款由微软开发的跨平台免费源代码编辑器。VSCode 开发环境非常简单易用，仅需要安装相关的插件进行简易的配置就可以与原有的python环境组成一套具有简单的代码调试运行的开发工具。对于轻量级的python开发和python学习是比较友好的。优秀的代码提示和更多插件功能让VSCode的使用体验不亚于知名pythonIDE—pycharm。

准备工作：

• 安装 Python 3

• 安装 VS Code
• 安装 VS Code Python 扩展和Pylance拓展

安装 VS Code

VSCode 安装比较简单，打开官网 https://code.visualstudio.com/，下载软件包，一步步安装即可，安装过程注意安装路径设置、环境变量默认自动添加到系统中，勾选以下所有选项：

安装 VS Code Python 扩展和Pylance拓展

接着我们安装 VS Code Python 扩展：

Python扩展将自动安装Pylance和Jupyter扩展，以便在使用Python文件和Jupyter笔记本时获得最佳体验。

创建一个 Python 代码文件

打开 VScode，然后点击新建文件：

点击选择语言：

在搜索框输入 Python，选中 Python 选项：

输入代码：

print("W3Cschool")

右击鼠标，选择在交互式窗口运行文件，如果有提示需要安装内核，直接点安装即可(没有安装会一直显示在连接 Python 内核)：（这里VSCode会使用python的pip进行安装，部分版本会安装失败，小编在尝试的时候使用python3.8版本失败了，3.7版本成功了）

另外，我们也可以打开一个已存在的文件或目录（文件夹），比如我们打开一个 pythonproject，你也可以自己创建一个：

然后我们创建一个 test.py 文件，点击下面新建文件图标，输入文件名 test.py：

注：pythonproject 里面包含了一个 .vscode 文件夹，是一些配置信息，可以先不用管。

在 test.py 输入以下代码：

print("W3Cschool")

点击右上角绿色图标，即可运行：

可以右击文件，选择"在终端中运行 Python 文件"：

当然也可以在代码窗口上右击鼠标，选择"在终端中运行 Python 文件"。

本章节将一些Python3基础语法整理成手册，方便各位在日常使用和学习时查阅，包含了编码、标识符、保留字、注释、缩进、字符串等常用内容。

注意，这部分内容是后续学习的一个基础和预览，请不要随意跳过这个章节的学习！

编码

默认情况下，Python 3 源码文件以 UTF-8 编码，所有字符串都是 unicode 字符串。 当然你也可以为源码文件指定不同的编码：

# -*- coding: cp-1252 -*-

标识符

• 第一个字符必须是字母表中字母或下划线'_'。
• 标识符的其他的部分有字母、数字和下划线组成。
• 标识符对大小写敏感。

在 Python 3中，非 ASCII 编码的标识符也是允许的了。

Python 保留字

保留字即关键字，我们不能把它们用作任何标识符名称。Python 的标准库提供了一个关键词模块，我们可以使用它来查看当前版本的所有保留字：

>>> import keyword>>> keyword.kwlist
['False', 'None', 'True', '__peg_parser__', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

上面代码是在解释器执行的结果，写成python脚本代码应该写成如下样式（后续代码可能会有两种版本的代码块，但并不会多做解释，望读者周知！）：

import keywordprint(keyword.kwlist)

注释

Python 中单行注释以 # 开头，多行注释采用三对单引号（'''）或者三对双引号（"""）将注释括起来。

#这是单行注释"""这是多行注释这是多行注释"""'''也可以用三个单引号来进行多行注释'''

实际上python注释只有一种，就是单行注释，多行注释的这种使用方法类似于java的javadoc，三引号的这种使用方法实际上是用来声明多行长字符串的。

缩进

Python 最具特色的就是使用缩进来表示代码块。缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数。

标准数据类型

Python 中有六个标准的数据类型：

• Number（数字）
• String（字符串）
• List（列表）
• Tuple（元组）
• Set（集合）
• Dictionary（字典）

Python3 的六个标准数据类型中：

• 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
• 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

 可变数据和不可变数据是相对于引用地址来说的，不可变数据类型不允许变量的值发生变化，如果改变了的变量的值，相当于新建了一个对象，而对于相同的值的对象，内部会有一个引用计数来记录有多少个变量引用了这个对象。可变数据类型允许变量的值发生变化。对变量进行修改操作只会改变变量的值，不会新建对象，变量引用的地址也不会发生变化，不过对于相同的值的不同对象，在内存中则会存在不同的对象，即每个对象都有自己的地址，相当于内存中对于同值的对象保存了多份，这里不存在引用计数，是实实在在的对象。

简单地讲，可变数据和不可变数据的“变”是相对于引用地址来说的，不是不能改变其数据，而是改变数据的时候会不会改变变量的引用地址。

类型判断

python可以用type函数来检查一个变量的类型，使用方法如下：

>>> x = "W3Cschool">>> type(x)<type 'str'>>>> x=100>>> type(x)<type 'int'>>>> x=('1','2','3')>>> type(x)<type 'tuple'>>>> x = ['1','2','3']>>> type(x)<type 'list'>

在脚本代码中的使用：

x = "W3Cschool"print(type(x))

字符串

• Python 中单引号和双引号使用完全相同，但单引号和双引号不能匹配。
• 使用三对引号('''或""")可以囊括一个多行字符串。
• 与其他语言相似，python也使用 ''作为转义字符
• 自然字符串， 通过在字符串前加 r 或 R。 如 r"this is a line with " 则 会显示，并不是换行。
• Python 允许处理 unicode 字符串，加前缀 u 或 U， 如 u"this is an unicode string"。
• 字符串是不可变的。
• 按字面意义级联字符串，如"this " "is " "string"会被自动转换为this is string。
• 字符串可以用 + 运算符连接在一起，用 * 运算符重复。
• Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。
• Python中的字符串不能改变（详见上一小点的引用）。
• Python 没有单独的字符类型，一个字符就是长度为 1 的字符串。
• 字符串的截取的语法格式如下：变量 [头下标: 尾下标: 步长]

 关于字符串的更多内容，请前往字符串小节进行学习。

word = '字符串'sentence = "这是一个句子。"paragraph = """这是一个段落，可以由多行组成"""

实例：

#!/usr/bin/python3 str='W3Cschool' print(str)                 # 输出字符串print(str[0:-1])           # 输出第一个到倒数第二个的所有字符print(str[0])              # 输出字符串第一个字符print(str[2:5])            # 输出从第三个开始到第五个的字符print(str[2:])             # 输出从第三个开始后的所有字符print(str[1:5:2])          # 输出从第二个开始到第五个且每隔两个的字符print(str * 2)             # 输出字符串两次print(str + '你好')         # 连接字符串 print('------------------------------') print('hello
W3Cschool')      # 使用反斜杠()+n转义特殊字符print(r'hello
W3Cschool')     # 在字符串前面添加一个 r，表示原始字符串，不会发生转义

以上实例输出结果：

W3CschoolW3CschooWCscCschool3sW3CschoolW3CschoolW3Cschool你好------------------------------helloW3Cschoolhello
W3Cschool

这里的 r 指 raw，即 raw string，会自动将反斜杠转义，例如：

>>> print('
')       # 输出空行>>> print(r'
')      # 输出 
>>>

空行

函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用两行空行分隔，以突出函数入口的开始。

空行与代码缩进不同，空行并不是 Python 语法的一部分。书写时不插入空行，Python 解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码，便于日后代码的维护或重构。

记住：空行也是程序代码的一部分。

 在PEP8中介绍了一些python代码的格式，其中介绍了函数之间要有两行空行，如果python代码没有使用两行空行的话，部分IDE会出现修改提示（比如pycharm）。这样的代码不影响运行，但对于代码阅读不利，

输入&等待用户输入

input函数可以用来接受输入，它可以传入一个字符串，当input函数调用的时候，会在控制台打印这个字符串（所以这个字符串通常被用来做输入的提示信息）。

 input函数会读取输入内容直到读到回车，也就是说，内容输入完毕后要按回车键才能执行。

input("这是一个简单的input信息") # 这是一个简单的input样例，他输出input信息并接受一个字符串x=input("请输入X的值：") # 这是一个常见的input样例，他输出提示信息，然后接受一个字符串并将值传递给一个变量Xprint(x) # 打印变量，可以看到输入的x的值print(type(x)) #查看这个变量的类型x = int(input("请输入一个数值：")) # 配合强制类型转换，可以将字符串转变为int类型（字符串类型不能参与计算）# 也可以分步写成：#x=input("请输入一个数值：") # 接受一个字符串#x=int(x)   #将x转换为int型# 这里强制转换也可以转换为其他类型，详细的转换方法请参考基本数据类型的强制转换相关内容print(x) # 打印变量，可以看到输入的x的值print(type(x)) #查看这个变量的类型input("

按下 enter 键后退出。") # 其实这里并没有接受任何内容，input函数以enter作为结尾，所以只有输入回车后才会结束input函数

以上代码中 ，" "在结果输出前会输出两个新的空行。一旦用户按下 enter 键时，程序将退出。

同一行显示多条语句

Python 可以在同一行中使用多条语句，语句之间使用分号 (;) 分割，以下是一个简单的实例：

实例:

#!/usr/bin/python3 import sys; x = 'W3Cschool'; sys.stdout.write(x + '
')

使用脚本执行以上代码，输出结果为：

W3Cschool

使用交互式命令行执行，输出结果为：

>>> import sys; x = 'W3Cschool'; sys.stdout.write(x + '
')
W3Cschool
10

此处的 10 表示字符数。

 python以回车作为语句结束的标志，一行一句语句的特色使得Python更加易读，而在一行中显示多条语句的这种行为会破坏python的可读性，不建议使用！

多个语句构成代码组

缩进相同的一组语句构成一个代码块，我们称之代码组。

像 if、while、def 和 class 这样的复合语句，首行以关键字开始，以冒号 ( : ) 结束，该行之后的一行或多行代码构成代码组。

我们将首行及后面的代码组称为一个子句 (clause)。

如下实例：

if expression : 
    suite
elif expression : 
    suite 
else : 
    suite

print 输出

print函数是python的基本输出函数，他可以将变量输出（或者说，打印）到控制台。在第一个python程序中，我们就用到了print函数：

#!/usr/bin/python3print("Hello, World!") #"Hello,World!"是一个字符串变量str = "Hello,World!"print(str) #上一种helloworld的另一种写法

print 默认输出是换行的，如果要实现不换行需要在变量末尾加上 end=""：

实例:

#!/usr/bin/python3 x="a"y="b"# 换行输出print( x )print( y ) print('---------')# 不换行输出print( x, end=" " )print( y, end=" " )print()

以上实例执行结果为：

a
b
---------
a b

关于print的内容，本章只是粗略介绍，目的是为了能够基础使用print函数。后续章节中有print函数的详细介绍。

import 与 from...import

在 Python 用 import 或者 from...import 来导入相应的模块。

将整个模块 (somemodule) 导入，格式为：​ import somemodule​

从某个模块中导入某个函数,格式为：​ from somemodule import somefunction​

从某个模块中导入多个函数,格式为：​ from somemodule import firstfunc, secondfunc, thirdfunc​

将某个模块中的全部函数导入，格式为：​ from somemodule import *​

导入 sys 模块

import sysprint('================Python import mode==========================')print ('命令行参数为:')for i in sys.argv:    print (i)print ('
 python 路径为',sys.path)

导入 sys 模块的 argv,path 成员

from sys import argv,path  #  导入特定的成员 print('================python from import===================================')print('path:',path) # 因为已经导入path成员，所以此处引用时不需要加sys.path

命令行参数

很多程序可以执行一些操作来查看一些基本信息，Python 可以使用 -h 参数查看各参数帮助信息：

$ python -h
usage: python [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 完成比 ​2+2​ 更复杂的工作。在下例里，我们能写出一个初步的斐波纳契数列如下：

#!/usr/bin/python3# Fibonacci series: 斐波纳契数列# 两个元素的总和确定了下一个数a, b = 0, 1while b < 10:    print(b)    a, b = b, a+b

有关斐波那契数列的具体问题可在 斐波纳契奇数求和算法挑战 教程中进一步了解。

其中代码​ a, b = b, a + b​ 的计算方式为先计算右边的表达式，然后同时赋值给左边，等价于：

n = bm = a + ba = nb = m

执行以上程序，输出结果为：

112358

这个例子介绍了几个新特征。

• 第一行包含了一个复合赋值：变量 a 和 b 同时得到新值 0 和 1。
• 最后一行也使用了复合赋值的方法：等价于 c = a，a = b，b = b + c。

接下来尝试输出变量值：

i = 1024 * 1024print('i 的值为：', i)

执行以上程序，输出结果为：

i 的值为： 1048576

end 关键字

关键字 end 可以用于将结果输出到同一行，或者在输出的末尾添加不同的字符，实例如下：

# 两个元素的总和确定了下一个数a, b = 0, 1while b < 1024:    print(b, end=',')    a, b = b, a+b

执行以上程序，输出结果为：

1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,

最后尝试使用 if 条件控制  

age = int(input("请输入你家狗狗的年龄: "))print("")if age < 0:	print("请输入正确的年龄。")elif age == 1:	print("相当于 14 岁的人。")elif age == 2:	print("相当于 22 岁的人。")elif age > 2:	human = 22 + (age -2)*5	print("对应人类年龄: ", human)### 退出提示，本地环境下可以使用这样的退出提示使代码更易用input('点击 enter 键退出')

在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。

Python 3 中有六个标准的数据类型：

• Numbers（数字）
• String（字符串）
• List（列表）
• Tuple（元组）
• Sets（集合）
• Dictionaries（字典）

Numbers（数字）

Python 3 支持 int（整型）、float（浮点型）、bool（布尔型）、complex（复数）。

数值类型的赋值和计算都是很直观的，就像大多数语言一样。内置的 type() 函数可以用来查询变量所指的对象类型。

>>> a, b, c, d = 20, 5.5, True, 4+3j>>> print(type(a), type(b), type(c), type(d))<class 'int'><class 'float'><class 'bool'><class 'complex'>

此外还可以用isinstance来判断：

>>>a=111>>>isinstance(a,int)True>>>

isinstance和type的区别在于：

• type（）不会认为子类是一种父类类型。
• isinstance（）会认为子类是一种父类类型。

>>> class A:...     pass... >>> class B(A):...     pass... >>> isinstance(A(), A)True>>> type(A()) == A True>>> isinstance(B(), A)True>>> type(B()) == AFalse

注意：在 Python2 中是没有布尔型的，它用数字 0 表示 False，用 1 表示 True。到 Python3 中，把 True 和 False 定义成关键字了，但它们的值还是 1 和 0，它们可以和数字相加。

当你指定一个值时，Number 对象就会被创建：

var1 = 1var2 = 10

您也可以使用 del 语句删除一些对象引用。

del 语句的语法是：

del var1[,var2[,var3[....,varN]]]

您可以通过使用 del 语句删除单个或多个对象。例如：

del vardel var_a, var_b

数值运算：

>>> 5 + 4  # 加法9>>> 4.3 - 2 # 减法2.3>>> 3 * 7  # 乘法21>>> 2 / 4  # 除法，得到一个浮点数0.5>>> 2 // 4 # 除法，得到一个整数0>>> 17 % 3 # 取余 2>>> 2 ** 5 # 乘方32

注意：

• 1、Python 可以同时为多个变量赋值，如 a, b = 1, 2。
• 2、一个变量可以通过赋值指向不同类型的对象。
• 3、数值的除法（/）总是返回一个浮点数，要获取整数使用​//​操作符。
• 4、在混合计算时，Python 会把整型转换成为浮点数。

String（字符串）

Python 中的字符串 str 用单引号(' ')或双引号 (" ") 括起来，同时使用反斜杠 () 转义特殊字符。

>>> s = 'Yes,he doesn't'>>> print(s, type(s), len(s))Yes,he doesn't  <class 'str'> 14

如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串：

>>> print('C:some
ame')C:someame>>> print(r'C:some
ame')C:some
ame

另外，反斜杠可以作为续行符，表示下一行是上一行的延续。还可以使用"""..."""或者'''...'''跨越多行。

字符串可以使用 + 运算符串连接在一起，或者用 * 运算符重复：

>>> print('str'+'ing', 'my'*3)string mymymy

Python 中的字符串有两种索引方式，第一种是从左往右，从 0 开始依次增加；第二种是从右往左，从 -1 开始依次减少。

注意，没有单独的字符类型，一个字符就是长度为 1 的字符串。

>>> word = 'Python'>>> print(word[0], word[5])P n>>> print(word[-1], word[-6])n P

还可以对字符串进行切片，获取一段子串。用冒号分隔两个索引，形式为变量[头下标:尾下标]。

截取的范围是前闭后开的（头下标取，尾下标不取），并且两个索引都可以省略：

>>> word = 'ilovepython'>>> word[1:5]'love'>>> word[:]'ilovepython'>>> word[5:]'python'>>> word[-10:-6]'love'

与 C 字符串不同的是，Python 字符串不能被改变。向一个索引位置赋值，比如 word[0] = 'm' 会导致错误。

注意：

• 1、反斜杠可以用来转义，使用 r 可以让反斜杠不发生转义。
• 2、字符串可以用 + 运算符连接在一起，用 * 运算符重复。
• 3、Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。
• 4、Python 中的字符串不能改变。

List（列表）

List（列表） 是 Python 中使用最频繁的数据类型。

列表是写在方括号之间、用逗号分隔开的元素列表。列表中元素的类型可以不相同：

>>> a = ['him', 25, 100, 'her']>>> print(a)['him', 25, 100, 'her']

和字符串一样，列表同样可以被索引和切片，列表被切片后返回一个包含所需元素的新列表。详细的在这里就不赘述了。

列表还支持串联操作，使用 + 操作符：

>>> a = [1, 2, 3, 4, 5]>>> a + [6, 7, 8][1, 2, 3, 4, 5, 6, 7, 8]

与 Python 字符串不一样的是，列表中的元素是可以改变的：

>>> a = [1, 2, 3, 4, 5, 6]>>> a[0] = 9>>> a[2:5] = [13, 14, 15]>>> a[9, 2, 13, 14, 15, 6]>>> a[2:5] = []   # 删除>>> a[9, 2, 6]

List 内置了有很多方法，例如 append()、pop() 等等，这在后面会讲到。

注意：

• 1、List 写在方括号之间，元素用逗号隔开。
• 2、和字符串一样，List 可以被索引和切片。
• 3、List 可以使用 + 操作符进行拼接。
• 4、List 中的元素是可以改变的。

Tuple（元组）

元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号里，元素之间用逗号隔开。

元组中的元素类型也可以不相同：

>>> a = (1991, 2014, 'physics', 'math')>>> print(a, type(a), len(a))(1991, 2014, 'physics', 'math') <class 'tuple'> 4

元组与字符串类似，可以被索引且下标索引从 0 开始，也可以进行截取/切片（看上面，这里不再赘述）。

其实，可以把字符串看作一种特殊的元组。

>>> tup = (1, 2, 3, 4, 5, 6)>>> print(tup[0], tup[1:5])1 (2, 3, 4, 5)>>> tup[0] = 11  # 修改元组元素的操作是非法的

虽然 tuple 的元素不可改变，但它可以包含可变的对象，比如 list 列表。

构造包含 0 个或 1 个元素的 tuple 是个特殊的问题，所以有一些额外的语法规则：

tup1 = () # 空元组tup2 = (20,) # 一个元素，需要在元素后添加逗号

另外，元组也支持用 + 操作符：

>>> tup1, tup2 = (1, 2, 3), (4, 5, 6)>>> print(tup1+tup2)(1, 2, 3, 4, 5, 6)

string、list 和 tuple 都属于 sequence（序列）。

注意：

• 1、与字符串一样，元组的元素不能修改。
• 2、元组也可以被索引和切片，方法都是一样的。
• 3、注意构造包含 0 或 1 个元素的元组的特殊语法规则。
• 4、元组也可以使用 + 操作符进行拼接。

Sets（集合）

集合（set）是一个无序不重复元素的集。

基本功能是进行成员关系测试和消除重复元素。

可以使用大括号 或者 set() 函数创建 set 集合，注意：创建一个空集合必须用 set() 而不是 { }，因为{ }是用来创建一个空字典。

>>> student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}>>> print(student)   # 重复的元素被自动去掉{'Jim', 'Jack', 'Mary', 'Tom', 'Rose'}>>> 'Rose' in student  # membership testing（成员测试）True>>> # set可以进行集合运算... >>> a = set('abracadabra')>>> b = set('alacazam')>>> a{'a', 'b', 'c', 'd', 'r'}>>> a - b     # a和b的差集{'b', 'd', 'r'}>>> a | b     # a和b的并集{'l', 'm', 'a', 'b', 'c', 'd', 'z', 'r'}>>> a & b     # a和b的交集{'a', 'c'}>>> a ^ b     # a和b中不同时存在的元素{'l', 'm', 'b', 'd', 'z', 'r'}

Dictionaries（字典）

字典（dictionary）是 Python 中另一个非常有用的内置数据类型。

字典是一种映射类型（mapping type），它是一个无序的键值对（key-value）集合。

关键字（key）必须使用不可变类型，也就是说list和包含可变类型的 tuple 不能做关键字。

在同一个字典中，关键字（key）必须互不相同。

>>> dic = {}  # 创建空字典>>> tel = {'Jack':1557, 'Tom':1320, 'Rose':1886}>>> tel{'Tom': 1320, 'Jack': 1557, 'Rose': 1886}>>> tel['Jack']   # 主要的操作：通过key查询1557>>> del tel['Rose']  # 删除一个键值对>>> tel['Mary'] = 4127  # 添加一个键值对>>> tel{'Tom': 1320, 'Jack': 1557, 'Mary': 4127}>>> list(tel.keys())  # 返回所有key组成的list['Tom', 'Jack', 'Mary']>>> sorted(tel.keys()) # 按key排序['Jack', 'Mary', 'Tom']>>> 'Tom' in tel       # 成员测试True>>> 'Mary' not in tel  # 成员测试False

构造函数 dict() 直接从键值对 sequence 中构建字典，当然也可以进行推导，如下：

>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)]){'jack': 4098, 'sape': 4139, 'guido': 4127}>>> {x: x**2 for x in (2, 4, 6)}{2: 4, 4: 16, 6: 36}>>> dict(sape=4139, guido=4127, jack=4098){'jack': 4098, 'sape': 4139, 'guido': 4127}

另外，字典类型也有一些内置的函数，例如 clear()、keys()、values() 等。

注意：

• 1、字典是一种映射类型，它的元素是键值对。
• 2、字典的关键字必须为不可变类型，且不能重复。
• 3、创建空字典使用 { }。

Python3注释可以确保对模块, 函数, 方法和行内注释使用正确的风格，有专门的符号和格式，有单行与多行的区别。

Python 中的注释有单行注释和多行注释：

Python 中单行注释以 # 开头，例如：

#!/usr/bin/python3 #coding=utf-8# 这是一个注释print("Hello, World") 

多行注释用三个单引号（'''）或者三个双引号（"""）将需要注释的内容囊括起来，例如:

1、单引号（'''）

#!/usr/bin/python3 #coding=utf-8'''这是多行注释，用三个单引号这是多行注释，用三个单引号 这是多行注释，用三个单引号'''print("Hello, World!") 

2、双引号（"""）

#!/usr/bin/python3 #coding=utf-8"""这是多行注释，用三个双引号这是多行注释，用三个双引号 这是多行注释，用三个双引号"""print("Hello, World!") 

 三引号实际上是多行长字符串的声明方式，也作为python代码文档使用（类似javadoc）。

本章节主要说明 Python 的运算符。举个简单的例子 4 + 5 = 9 。例子中，4 和 5 被称为操作数，"+" 称为运算符。

Python 语言支持以下类型的运算符:

• 算术运算符
• 比较（关系）运算符
• 赋值运算符
• 逻辑运算符
• 位运算符
• 成员运算符
• 身份运算符
• 运算符优先级

接下来让我们一个个来学习 Python 的运算符。

Python 算术运算符

以下假设变量 a 为 21，变量 b 为 10：

以下实例演示了 Python 所有算术运算符的操作：

#!/usr/bin/python3#coding=utf-8a = 21b = 10c = 0c = a + bprint ("a+b 的值为：", c)c = a - bprint ("a-b 的值为：", c)c = a * bprint ("a*b 的值为：", c)c = a / bprint ("a/b 的值为：", c)c = a % bprint ("a%b 的值为：", c)# 修改变量 a 、b 、ca = 2b = 3c = a**b print ("a**b 的值为：", c)a = 10b = 5c = a//b print ("a//b 的值为：", c)

以上实例输出结果：

a+b 的值为： 31
a-b 的值为： 11
a*b 的值为： 210
a/b 的值为： 2.1
a%b 的值为： 1
a**b 的值为： 8
a//b 的值为： 2

Python 比较运算符

以下假设变量 a 为 10，变量 b 为 20：

所有比较运算符返回 1 表示真，返回 0 表示假。这分别与特殊的变量 True 和 False 等价。注意：True和False的首字母为大写。

以下实例演示了 Python 所有比较运算符的操作：

#!/usr/bin/python3#coding=utf-8a = 21b = 10c = 0if ( a == b ):    print ("a 等于 b")else:    print ("a 不等于 b")if ( a != b ):    print ("a 不等于 b")else:    print ("a 等于 b")if ( a < b ):    print ("a 小于 b")else:    print ("a 大于等于 b")if ( a > b ):    print ("a 大于 b")else:    print ("a 小于等于 b")# 修改变量 a 和 b 的值a = 5;b = 20;if ( a <= b ):    print ("a 小于等于 b")else:    print ("a 大于  b")if ( a >= b ):    print ("a 大于等于 b")else:    print ("a 小于 b")

以上实例输出结果：

a 不等于 b
a 不等于 b
a 大于等于 b
a 大于 b
a 小于等于 b
a 小于 b

Python 赋值运算符

以下假设变量 a 为 10，变量 b 为 20：

以下实例演示了 Python 所有赋值运算符的操作：

#!/usr/bin/python3#coding=utf-8a = 21b = 10c = 0c = a + bprint ("1 - c 的值为：", c)c += aprint ("2 - c 的值为：", c)c *= aprint ("3 - c 的值为：", c)c /= a print ("4 - c 的值为：", c)c = 2c %= aprint ("5 - c 的值为：", c)c **= aprint ("6 - c 的值为：", c)c //= aprint ("7 - c 的值为：", c)

以上实例输出结果：

1 - c 的值为： 312 - c 的值为： 523 - c 的值为： 10924 - c 的值为： 52.05 - c 的值为： 26 - c 的值为： 20971527 - c 的值为： 99864

Python 位运算符

按位运算符是把数字看作二进制来进行计算的。Python 中的按位运算法则如下：

下表中变量 a 为 60，b 为 13。

注：关于原码，补码和反码：
原码：假设机器字长为n，原码就是用一个n位的二进制数，其中最高位为符号位：正数是0，负数是1。剩下的表示概数的绝对值，位数如果不够就用0补全。
反码：在原码的基础上，符号位不变其他位取反，也就是就是0变1，1变0。
补码：在反码的基础上加1。  
PS：正数的原、反、补码都一样，0的原码跟反码都有两个，因为这里0被分为+0和-0。
按位取反和反码有一定的相似之处但又不尽相同（反码符号位不取反）。
在计算机中，是以补码的形式存放数据的。1100 0011刚好对应-61。
-61的原码-> 1011 1101->反码->1100 0010->补码->1100 0011

以下实例演示了 Python 所有位运算符的操作：

#!/usr/bin/python3#coding=utf-8a = 60            # 60 = 0011 1100 b = 13            # 13 = 0000 1101 c = 0c = a & b;        # 12 = 0000 1100print ("1 - c 的值为：", c)c = a | b;        # 61 = 0011 1101 print ("2 - c 的值为：", c)c = a ^ b;        # 49 = 0011 0001print ("3 - c 的值为：", c)c = ~a;           # -61 = 1100 0011print ("4 - c 的值为：", c)c = a << 2;       # 240 = 1111 0000print ("5 - c 的值为：", c)c = a >> 2;       # 15 = 0000 1111print ("6 - c 的值为：", c)

以上实例输出结果：

1 - c 的值为： 122 - c 的值为： 613 - c 的值为： 494 - c 的值为： -615 - c 的值为： 2406 - c 的值为： 15

Python 逻辑运算符

Python 语言支持逻辑运算符，以下假设变量 a 为 10, b 为 20:

以上实例输出结果：

#!/usr/bin/python3#coding=utf-8a = 10b = 20if ( a and b ):    print ("1 - 变量 a 和 b 都为 true")else:    print ("1 - 变量 a 和 b 有一个不为 true")if ( a or b ):    print ("2 - 变量 a 和 b 都为 true，或其中一个变量为 true")else:    print ("2 - 变量 a 和 b 都不为 true")# 修改变量 a 的值a = 0if ( a and b ):    print ("3 - 变量 a 和 b 都为 true")else:    print ("3 - 变量 a 和 b 有一个不为 true")if ( a or b ):    print ("4 - 变量 a 和 b 都为 true，或其中一个变量为 true")else:    print ("4 - 变量 a 和 b 都不为 true")if not( a and b ):    print ("5 - 变量 a 和 b 都为 false，或其中一个变量为 false")else:    print ("5 - 变量 a 和 b 都为 true")

以上实例输出结果：

1 - 变量 a 和 b 都为 true2 - 变量 a 和 b 都为 true，或其中一个变量为 true3 - 变量 a 和 b 有一个不为 true4 - 变量 a 和 b 都为 true，或其中一个变量为 true5 - 变量 a 和 b 都为 false，或其中一个变量为 false

Python 成员运算符

除了以上的一些运算符之外，Python 还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。

以下实例演示了 Python 所有成员运算符的操作：

#!/usr/bin/python3#coding=utf-8a = 10b = 20list = [1, 2, 3, 4, 5 ];if ( a in list ):    print ("1 - 变量 a 在给定的列表中 list 中")else:    print ("1 - 变量 a 不在给定的列表中 list 中")if ( b not in list ):    print ("2 - 变量 b 不在给定的列表中 list 中")else:    print ("2 - 变量 b 在给定的列表中 list 中")# 修改变量 a 的值a = 2if ( a in list ):    print ("3 - 变量 a 在给定的列表中 list 中")else:    print ("3 - 变量 a 不在给定的列表中 list 中")

以上实例输出结果：

1 - 变量 a 不在给定的列表中 list 中2 - 变量 b 不在给定的列表中 list 中3 - 变量 a 在给定的列表中 list 中

Python 身份运算符

身份运算符用于比较两个对象的存储单元

以下实例演示了 Python 所有身份运算符的操作：

#!/usr/bin/python3#coding=utf-8a = 20b = 20if ( a is b ):    print ("1 - a 和 b 有相同的标识")else:    print ("1 - a 和 b 没有相同的标识")if ( id(a) == id(b) ):    print ("2 - a 和 b 有相同的标识")else:    print ("2 - a 和 b 没有相同的标识")# 修改变量 b 的值b = 30if ( a is b ):    print ("3 - a 和 b 有相同的标识")else:    print ("3 - a 和 b 没有相同的标识")if ( a is not b ):    print ("4 - a 和 b 没有相同的标识")else:    print ("4 - a 和 b 有相同的标识")

以上实例输出结果：

1 - a 和 b 有相同的标识2 - a 和 b 有相同的标识3 - a 和 b 没有相同的标识4 - a 和 b 没有相同的标识

Python 运算符优先级

以下表格列出了从最高到最低优先级的所有运算符：

•  括号因为不是运算符所以没有纳入本表，但算术式中一旦出现括号，就要先算括号内的内容。
• 同一级运算符的优先级从左往右进行计算。

以下实例演示了 Python 所有运算符优先级的操作：

#!/usr/bin/python3#coding=utf-8a = 20b = 10c = 15d = 5e = 0e = (a + b) * c / d       #( 30 * 15 ) / 5print ("(a + b) * c / d 运算结果为：",  e)e = ((a + b) * c) / d     # (30 * 15 ) / 5print ("((a + b) * c) / d 运算结果为：",  e)e = (a + b) * (c / d);    # (30) * (15/5)print ("(a + b) * (c / d) 运算结果为：",  e)e = a + (b * c) / d;      #  20 + (150/5)print ("a + (b * c) / d 运算结果为：",  e)

以上实例输出结果：

(a + b) * c / d 运算结果为： 90.0((a + b) * c) / d 运算结果为： 90.0(a + b) * (c / d) 运算结果为： 90.0a + (b * c) / d 运算结果为： 50.0

Python 数字类型用于数值的储存。数值类型是不允许改变的，如果改变数字数据类型的值，将重新分配内存空间。

以下实例在变量赋值时 Number 对象将被创建：

var1 = 1var2 = 10

您也可以使用del语句删除一些数字对象的引用。

del语句的语法是：

del var1[,var2[,var3[....,varN]]]

您可以通过使用del语句删除单个或多个对象的引用，例如：

del vardel var_a, var_b

Python 支持三种不同的数值类型：

• 整型(Int) - 通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型。
• 浮点型(float) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 10² = 250）
• 复数( (complex)) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。

我们可以使用十六进制和八进制来代表整数：

>>> number = 0xA0F # 十六进制>>> number2575>>> number=0o37 # 八进制>>> number31

• Python支持复数，复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。

Python 数字类型转换

有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。

• int(x) 将x转换为一个整数。

• float(x) 将x转换到一个浮点数。

• complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。

• complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。

以下实例将浮点数变量 a 转换为整数：

>>> a = 1.0>>> int(a)1

强制数据类型转换在某些情况下会丢失精度，在一些对精度要求比较高的环境下建议不要轻易使用强制数据类型转换！！

Python 数字运算

Python 解释器可以作为一个简单的计算器，您可以在解释器里输入一个表达式，它将输出表达式的值。

表达式的语法很直白： +, -, * 和 /, 和其它语言（如Pascal或C）里一样。例如：

>>> 2 + 24>>> 50 - 5*620>>> (50 - 5*6) / 45.0>>> 8 / 5  # 总是返回一个浮点数1.6

注意：在不同的机器上浮点运算的结果可能会不一样。

在整数除法中，除法 / 总是返回一个浮点数，如果只想得到整数的结果，丢弃可能的分数部分，可以使用运算符 // ：

>>> 17 / 3  # 整数除法返回浮点型5.666666666666667>>>>>> 17 // 3  # 整数除法返回向下取整后的结果5>>> 17 % 3  # ％操作符返回除法的余数2>>> 5 * 3 + 2 17

注意：// 得到的并不一定是整数类型的数，它与分母分子的数据类型有关系。

>>> 7//23>>> 7.0//23.0>>> 7//2.03.0>>> 

等号 = 用于给变量赋值。赋值之后，除了下一个提示符，解释器不会显示任何结果。

>>> width = 20>>> height = 5*9>>> width * height900

Python 可以使用 ** 操作来进行幂运算：

>>> 5 ** 2  # 5 的平方25>>> 2 ** 7  # 2的7次方128

变量在使用前必须先"定义"（即赋予变量一个值），否则会出现错误：

>>> n   # 尝试访问一个未定义的变量Traceback (most recent call last):  File "<stdin>", line 1, in <module>NameError: name 'n' is not defined

不同类型的数混合运算时会将整数转换为浮点数：

>>> 3 * 3.75 / 1.57.5>>> 7.0 / 23.5

在交互模式中，最后被输出的表达式结果被赋值给变量 _ 。例如：

>>> tax = 12.5 / 100>>> price = 100.50>>> price * tax12.5625>>> price + _113.0625>>> round(_, 2)113.06

此处， _ 变量应被用户视为只读变量。

数学函数

随机数函数

随机数可以用于数学，游戏，安全等领域中，还经常被嵌入到算法中，用以提高算法效率，并提高程序的安全性。

Python包含以下常用随机数函数：

三角函数

Python包括以下三角函数：

数学常量

在编程语言中，将以某种方式（比如通过编号）组合起来的数据元素（如数字，字符串乃至其他数据结构）集合称为数据结构。在python中，最基本的数据结构为序列（sequence，简写为seq）。

所谓序列，指的是一块可存放多个值的连续内存空间，这些值按一定顺序排列，可通过每个值所在位置的编号（称为索引）访问它们。

为了更形象的认识序列，可以将它看做是一家旅店，那么店中的每个房间就如同序列存储数据的一个个内存空间，每个房间所特有的房间号就相当于索引值。也就是说，通过房间号（索引）我们可以找到这家旅店（序列）中的每个房间（内存空间）。

在 Python 中，​​序列类型包括字符串、列表、元组、集合和字典​​，这些序列支持以下几种通用的操作，但比较特殊的是，集合和字典不支持索引、切片、相加和相乘操作。

字符串也是一种常见的序列（所以以下的例子以字符串作为），它也可以直接通过索引访问字符串内的字符。

序列索引

序列索引值示意图

 负值索引示意图

注意，在使用负值作为列序中各元素的索引值时，是从 -1 开始，而不是从 0 开始。

另一种理解方式是：将序列想象成如下方的一个环：

红色值为元素，绿色值为正索引，蓝色值为负索引

可以发现序列的最后一个元素和第一个元素刚好相邻，方向与正索引的方向刚好相反，所以其负索引值是-1,。该序列有8个元素，所以最后一个负索引（也就是第一个元素）是-8，刚好等于该序列的长度的负值。

无论是采用正索引值，还是负索引值，都可以访问序列中的任何元素。以字符串为例，访问“W3Cschool”的首元素和尾元素，可以使用如下的代码：

str="W3Cschool"print(str[0],"==",str[-9])print(str[8],"==",str[-1])

输出结果为：

W == Wl == l

序列切片

切片操作是访问序列中元素的另一种方法，它可以访问一定范围内的元素，通过切片操作，可以生成一个新的序列。
序列实现切片操作的语法格式如下：

sname[start : end : step]

其中，各个参数的含义分别是：

• sname：表示序列的名称；
• start：表示切片的开始索引位置（包括该位置），此参数也可以不指定，会默认为 0，也就是从序列的开头进行切片；
• end：表示切片的结束索引位置（不包括该位置），如果不指定，则默认为序列的长度；
• step：表示在切片过程中，隔几个存储位置（包含当前位置）取一次元素，也就是说，如果 step 的值大于 1，则在进行切片去序列元素时，会“跳跃式”的取元素。如果省略设置 step 的值，则最后一个冒号就可以省略。

例如，对字符串“W3Cschool”进行切片：

str="W3Cschool"#取索引区间为[0,2]之间（不包括索引2处的字符）的字符串print(str[:2])#隔 1 个字符取一个字符，区间是整个字符串print(str[::2])#取整个字符串，此时 [] 中只需一个冒号即可print(str[:])

运行结果为：

W3WCcolW3Cschool

序列相加

Python 中，支持两种类型相同的序列使用“+”运算符做相加操作，它会将两个序列进行连接，但不会去除重复的元素。

这里所说的“类型相同”，指的是“+”运算符的两侧序列要么都是列表类型，要么都是元组类型，要么都是字符串。

例如，前面章节中我们已经实现用“+”运算符连接 2 个（甚至多个）字符串，如下所示：

protocol = "https://"url = "www.51coolma.cn"print(protocol+url)

输出结果为：

https://www.51coolma.cn

序列相乘

Python 中，使用数字 n 乘以一个序列会生成新的序列，其内容为原来序列被重复 n 次的结果。例如：

str="W3Cschool"print(str*3)

输出结果为：

W3CschoolW3CschoolW3Cschool

比较特殊的是，列表类型在进行乘法运算时，还可以实现初始化指定长度列表的功能。例如如下的代码，将创建一个长度为 5 的列表，列表中的每个元素都是 None，表示什么都没有。

#列表的创建用 []，可以指定长度list = [None]*5print(list)

输出结果为：

[None, None, None, None, None]

检查元素是否包含在序列中

Python 中，可以使用 in 关键字检查某元素是否为序列的成员，其语法格式为：

value in sequence​

其中，value 表示要检查的元素，sequence 表示指定的序列。
例如，检查字符‘C’是否包含在字符串“W3Cschool”中，可以执行如下代码：

str="W3Cschool"print('C'in str)

运行结果为：

True

和 in 关键字用法相同，但功能恰好相反的，还有 not in 关键字，它用来检查某个元素是否不包含在指定的序列中，比如说：

str="W3Cschool"print('A' not in str)

输出结果为：

True

和序列相关的内置函数

Python提供了几个内置函数（表 3 所示），可用于实现与序列相关的一些常用操作。

 部分序列不能应用其中的部分函数，比如字典中不能直接使用list，详细的函数介绍请参阅相应数据类型的函数介绍。

这里给大家给几个例子：

str="W3Cschool"#找出最大的字符print(max(str))#找出最小的字符print(min(str))#对字符串中的元素进行排序print(sorted(str))

输出结果为：

s3['3', 'C', 'W', 'c', 'h', 'l', 'o', 'o', 's']

列表（list）也是最常用的 Python 数据类型之一，它以一个方括号内包含多个其他数据项（字符串，数字等甚至是另一个列表），数据项间以逗号作为分隔的数据类型。

列表的数据项不需要具有相同的类型。（这点是与其他语言的数组的一个区别）

创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：

list1 = ['Google', 'W3Cschool', 1997, 2000]list2 = [1, 2, 3, 4, 5, 6, 7 ]print ("list1: ", list1)print ("list2: ", list2)

运行结果：

list1:  ['Google', 'W3Cschool', 1997, 2000]list2:  [1, 2, 3, 4, 5, 6, 7]

访问列表中的值

与字符串的索引一样，列表索引从 0 开始，第二个索引是 1，依此类推。

通过索引列表可以进行截取、组合等操作。

 该部分内容和字符串索引和切片内容具有很高的相似性（因为这些都是序列的基本操作），本章不做过多介绍，有需求的同学可以前往字符串章节进行回顾。

以下是列表索引的操作：

list1 = ['Google', 'W3Cschool', 1997, 2000]print ("list1的第一项: ", list1[0])print ("list1的最后一项: ", list1[-1])

运行结果：

list1的第一项:  Googlelist1的最后一项:  2000

以下是列表切片的操作：

list1 = ['Google', 'W3Cschool', 1997, 2000]print ("list1的前3项: ", list1[0:3])print ("list1的2、3项: ", list1[1:3])

运行结果：

list1的前3项:  ['Google', 'W3Cschool', 1997]list1的2、3项:  ['W3Cschool', 1997]

更新列表

你可以对列表的数据项进行修改或更新，你也可以使用 append() 方法来添加列表项，如下所示：

list1 = ['Google', 'W3Cschool', 1997, 2000]print ("list1的第三个元素为: ", list1[2])list1[2] = "1998" #直接对想要修改的数据项赋上一个新值即可修改该数据项print ("list1的第三个元素为: ", list1[2])list1.append(2021) #append()可以在列表后追加一项列表项print ("追加列表项后的list1: ", list1)

运行结果：

list1的第三个元素为:  1997list1的第三个元素为:  1998追加列表项后的list1:  ['Google', 'W3Cschool', '1998', 2000, 2021]

注意：我们会在接下来的章节讨论 append() 方法的使用。

删除列表元素

可以使用 del 语句来删除列表的的元素，如下实例：

list1 = ['Google', 'W3Cschool', 1997, 2000]del list1[0] #del可以删掉一个元素print ("删除列表项后的list1: ", list1)

运行结果：

删除列表项后的list1:  ['W3Cschool', 1997, 2000]

注意：使用del是删除删除一个变量的方法，所以使用del的时候要作用在变量上（也就是list[1]）

另一种删除的方式是使用remove来删除列表的元素，如下实例

#!/usr/bin/python3list1 = ['Google', 'W3CSchool', 'Taobao', 'Baidu']list1.remove('Taobao') # remove可以按值查找列表中的元素并删除print ("列表现在为 : ", list1)list1.remove('Baidu')print ("列表现在为 : ", list1)

运行结果

列表现在为 :  ['Google', 'W3CSchool', 'Baidu']列表现在为 :  ['Google', 'W3CSchool']

注意：我们会在接下来的章节讨论 remove() 方法的使用

除此之外，pop也可以删除列表的最后一项。

Python列表脚本操作符

列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。

如下所示：

Python列表截取与拼接

Python的列表截取与字符串操作类似，如下所示：

L=['Google', 'W3Cschool', 'Taobao']

操作：

>>>L=['Google', 'W3Cschool', 'Taobao'] >>> L[2] 'Taobao' >>> L[-2] 'W3Cschool' >>> L[1:] ['W3Cschool', 'Taobao'] >>>

列表还支持拼接操作：

>>>squares = [1, 4, 9, 16, 25] >>> squares += [36, 49, 64, 81, 100] >>> squares [1, 4, 9, 16, 25, 36, 49, 64, 81, 100] >>>

嵌套列表

使用嵌套列表即在列表里创建其它列表，例如：

>>>a = ['a', 'b', 'c'] >>> n = [1, 2, 3] >>> x = [a, n] >>> x [['a', 'b', 'c'], [1, 2, 3]] >>> x[0] ['a', 'b', 'c'] >>> x[0][1] 'b'

如果有其他语言的基础，会发现嵌套列表的使用和数据结构和多维数组很像。实际上，python的列表可以当做其他语言的数组使用！

Python列表函数&方法

Python列表包含以下函数:

Python列表包含以下方法:

tup1 = ('Google', 'W3CSchool', 1997, 2020)tup2 = (1, 2, 3, 4, 5 )tup3 = "a", "b", "c", "d" # 不需括号也可以print(type(tup3))

<class 'tuple'>

tup1 = ()

tup1 = (50,)

#!/usr/bin/python3tup1 = ('Google', 'W3CSchool', 1997, 2020)tup2 = (1, 2, 3, 4, 5, 6, 7 )print ("tup1[0]: ", tup1[0])print ("tup2[1:5]: ", tup2[1:5])

tup1[0]:  Googletup2[1:5]:  (2, 3, 4, 5)

#!/usr/bin/python3tup1 = (12, 34.56);tup2 = ('abc', 'xyz')# 以下修改元组元素操作是非法的。# tup1[0] = 100# 创建一个新的元组tup3 = tup1 + tup2;print (tup3)

(12, 34.56, 'abc', 'xyz')

#!/usr/bin/python3tup = ('Google', 'W3CSchool', 1997, 2020)print (tup)del tup;print ("删除后的元组 tup : ")print (tup)

删除后的元组 tup : Traceback (most recent call last):  File "test.py", line 8, in <module>    print (tup)NameError: name 'tup' is not defined

L = ('Google', 'Taobao', 'W3CSchool')

>>> L = ('Google', 'Taobao', 'W3CSchool')>>> L[2]'W3CSchool'>>> L[-2]'Taobao'>>> L[1:]('Taobao', 'W3CSchool')

>>> tuple1 = ('Google', 'W3CSchool', 'Taobao')>>> len(tuple1)3>>> 

>>> tuple2 = ('5', '4', '8')>>> max(tuple2)'8'>>> 

>>> tuple2 = ('5', '4', '8')>>> min(tuple2)'4'>>> 

>>> list1= ['Google', 'Taobao', 'W3CSchool', 'Baidu']>>> tuple1=tuple(list1)>>> tuple1('Google', 'Taobao', 'W3CSchool', 'Baidu')

>>> import operator>>> dict1 = (1, 2, 3)>>> dict2 = ('a', 'b', 'c')>>> operator.eq(dict1, dict2)False

关于元组是不可变的

所谓元组的不可变指的是元组所指向的内存中的内容不可变。

>>> tup = ('W', '3', 'C', 's', 'c', 'h','o','o','l')>>> tup[0] = 'w'     # 不支持修改元素Traceback (most recent call last):  File "<stdin>", line 1, in <module>TypeError: 'tuple' object does not support item assignment>>> id(tup)     # 查看内存地址4440687904>>> tup = (1,2,3)>>> id(tup)4441088800    # 内存地址不一样了

从以上实例可以看出，重新赋值的元组 tup，绑定到新的对象了，不是修改了原来的对象。

集合（set）是一个无序的不重复元素序列。因此在每次运行的时候集合的运行结果的内容都是相同的，但元素的排列顺序却不是固定的，所以本章中部分案例的运行结果会出现与给出结果不同的情况（运行结果不唯一）。

可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

创建格式：

parame = {value01,value02,...}或者set(value)

集合实例：

basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}print(basket)  # 这里演示的是去重功能print('orange' in basket)                 # 快速判断元素是否在集合内print('crabgrass' in basket)

运行结果：

{'pear', 'banana', 'orange', 'apple'}TrueFalse

集合的运算：

a = set('abracadabra')b = set('alacazam')print(a)print(b)print(a-b)print(a|b)print(a&b)print(a^b)

运行结果：

{'b', 'd', 'a', 'c', 'r'}{'l', 'z', 'm', 'a', 'c'}{'r', 'd', 'b'}{'l', 'z', 'b', 'm', 'd', 'a', 'c', 'r'}{'c', 'a'}{'l', 'z', 'b', 'm', 'r', 'd'}

类似列表推导式，同样集合支持集合推导式(Set comprehension):

>>> a = {x for x in 'abracadabra' if x not in 'abc'}>>> a{'r', 'd'}

集合的基本操作

1、添加元素

语法格式如下：

s.add( x )

将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。

thisset = set(("Google", "W3Cschool", "Taobao"))thisset.add("Baidu")print(thisset)

尝试一下

运行结果：

{'W3Cschool', 'Taobao', 'Google', 'Baidu'}

还有一个方法，也可以添加元素，且参数可以是列表，元组，字典等，语法格式如下：

s.update( x )

x 可以有多个，用逗号分开。

实例：

thisset = set(("Google", "w3Cschool", "Taobao"))thisset.update({1,3})print(thisset)thisset.update([1,4],[5,6])  print(thisset)

{1, 3, 'w3Cschool', 'Taobao', 'Google'}{1, 3, 4, 5, 6, 'w3Cschool', 'Taobao', 'Google'}

2、移除元素

语法格式如下：

s.remove( x )

将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。

实例：

thisset = set(("Google", "W3Cschool", "Taobao"))thisset.remove("Taobao")print(thisset)thisset.remove("Facebook")   # 不存在会发生错误

运行结果：

{'W3Cschool', 'Google'}Traceback (most recent call last):  File ".code.tio", line 5, in     thisset.remove("Facebook")   # 不存在会发生错误KeyError: 'Facebook'

此外还有一个方法也是移除集合中的元素，且如果元素不存在，不会发生错误。格式如下所示：

s.discard( x )

实例：

thisset = set(("Google", "W3Cschool", "Taobao"))thisset.discard("Facebook")  # 不存在不会发生错误print(thisset)

运行结果：

{'Taobao', 'Google', 'W3Cschool'}

我们也可以设置随机删除集合中的一个元素，语法格式如下：

s.pop() 

实例：

thisset = set(("Google", "W3Cschool", "Taobao", "Facebook"))x = thisset.pop()print(x)print(thisset)

输出结果：

Google{'Facebook', 'Taobao', 'W3Cschool'}

多次执行测试结果都不一样。

set 集合的 pop 方法会对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除。因为这个过程是不确定的，所以删除结果也是不确定的，不建议使用这种方式进行删除。

3、计算集合元素个数

语法格式如下：

len(s)

计算集合 s 的元素个数。

实例：

thisset = set(("Google", "W3Cschool", "Taobao"))print(len(thisset))

运行结果：

3

4、清空集合

语法格式如下：

s.clear()

清空集合 s。

实例

thisset = set(("Google", "W3cschool", "Taobao"))thisset.clear()print(thisset)

运行结果：

set()

5、判断元素是否在集合中存在

语法格式如下：

x in s

判断元素 x 是否在集合 s 中，存在则返回 True，不存在则返回 False。

实例：

thisset = set(("Google", "W3Cschool", "Taobao"))print("W3Cschool" in thisset)print("Facebook" in thisset)

运行结果：

TrueFalse

集合内置方法完整列表

if语句

Python条件语句是通过一条或多条语句的执行结果(True或者False)来决定执行的代码块。

Python 中 if 语句的一般形式如下所示：

if condition_1:    statement_block_1

流程图如下所示：

这种if语句只有在符合条件的时候才会执行代码块内的代码，是一种比较常见的用法。

另一种常见的用法是：

if condition_1:    statement_block_1else:    statement_block_2

流程图如下所示：

这种语句是一种常用的if-else语句，通常用于二分支结构的条件语句代码。

在一些时候，我们可能需要多分支的条件语句代码，可以在if-else语句中混合elif语句进行使用：

Python 中用 elif 代替了else if，所以if语句的关键字为：if – elif – else。

if condition_1:    statement_block_1elif condition_2:    statement_block_2else:    statement_block_3

流程图如下所示：

如果 "condition_1" 为 True 将执行 "statement_block_1" 块语句，如果 "condition_1" 为 False，将判断 "condition_2"，如果"condition_2" 为 True 将执行 "statement_block_2" 块语句，如果 "condition_2" 为 False，将执行"statement_block_3"块语句。

 使用第一种常用的if语句搭配合适的条件可以实现第二种和第三种语句的全部效果，但在执行效率和代码可读性上会变得比较糟糕。

注意：

• 1、每个条件后面要使用冒号（:），表示接下来是满足条件后要执行的语句块。
• 2、使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。
• 3、在 Python 中没有 switch – case 语句，但在python3.10中添加了用法类似的match-case语句。

match-case语句（python3.10新特性）

在其他语言（比如说经典的C语言）中有一种多分支条件判断语句，可以进行模式匹配（通俗的讲，就是将传入的内容跟多个已存在的样例进行比较，找到相同的案例并按照该案例的代码进行处理，如果没有相同案例就按默认案例进行处理，可以查看其他编程语言的条件语句的Switch相关部分内容进行比较参考）。在python3.10中也引入了这样的新特性。

match-case语句的结构一般如下所示：

match variable: #这里的variable是需要判断的内容    case ["quit"]:         statement_block_1 # 对应案例的执行代码，当variable="quit"时执行statement_block_1    case ["go", direction]:         statement_block_2    case ["drop", *objects]:         statement_block_3    ... # 其他的case语句    case _: #如果上面的case语句没有命中，则执行这个代码块，类似于Switch的default        statement_block_default

一个match语句的使用示例：

def http_error(status):    match status:        case 400:            return "Bad request"        case 404:            return "Not found"        case 418:            return "I'm a teapot"        case _:            return "Something's wrong with the Internet"

 上述代码等价于：

def http_error(status):    if status == 400:        return "Bad request"    elif status == 404:        return "Not found"    elif status == 418:        return "I'm a teapot"    else:        return "Something's wrong with the Internet"

关于模式匹配还有更多的用法，可以参考PEP636进行详细的学习。

实例

以下实例演示了狗的年龄计算判断：

age = int(input("Age of the dog: "))print()if age < 0:      print("This can hardly be true!") elif age == 1:      print("about 14 human years") elif age == 2:      print("about 22 human years") elif age > 2:    human = 22 + (age -2)*5    print("Human years: ", human)### input('press Return>')

将以上脚本保存在 dog.py 文件中，并执行该脚本：

python dog.pyAge of the dog: 1about 14 human years

以下为 if 中常用的操作运算符:

 只要返回结果为布尔型（true或者false）的，都可以作为if的条件，所以在之前的集合等内容中涉及到的判断元素是否在集合中的​in​和​not in​，都可以作为if的条件。

实例

# 程序演示了 == 操作符# 使用数字print(5 == 6)# 使用变量x = 5y = 8print(x == y)

以上实例输出结果：

FalseFalse

使用​in​和​not in​作为判断条件：

thisset = set(("Google", "W3Cschool", "Taobao"))if "W3Cschool" in thisset:    print("该元素在列表中")if "baidu" not in thisset:    print("该元素不在列表中")

运行结果如下：

该元素在列表中该元素不在列表中

以下示例使用if语句来实现一个猜数字游戏（建议在本地环境尝试）：

#!/usr/bin/python3 # 该实例演示了数字猜谜游戏number = 7guess = -1print("猜数字!")while guess != number:    guess = int(input("请输入你要猜的数字"))    if guess == number:        print("你猜中了，真厉害！")    elif guess < number:        print("猜小了，再猜猜？")    elif guess > number:        print("猜大了，在猜猜？")

本章节将为大家介绍 Python 循环语句的使用。

Python 中的循环语句有 for 和 while。

Python 循环语句的控制结构图如下所示：

while 循环

Python 中 while 语句的一般形式：

while 判断条件：    statements

同样需要注意冒号和缩进。另外，在Python中没有 do-while 循环。

以下实例使用了 while 来计算 1 到 100 的总和：

#!/usr/bin/env python3n = 100sum = 0counter = 1while counter <= n:    sum = sum + counter         counter += 1  print('Sum of 1 until %d: %d' % (n,sum)) 

执行结果如下：

Sum of 1 until 100: 5050

for 语句

Python for 循环可以遍历任何序列的项目，如一个列表或者一个字符串。

for 循环的一般格式如下：

for <variable> in <sequence>:  <statements>else: <statements>

Python for循环实例：

>>> languages = ["C", "C++", "Perl", "Python"] >>> for x in languages:...     print (x)... CC++PerlPython>>> 

以下 for 实例中使用了 break 语句，break 语句用于跳出当前循环体：

#!/usr/bin/env python3edibles = ["ham", "spam","eggs","nuts"]for food in edibles:    if food == "spam":        print("No more spam please!")        break    print("Great, delicious " + food)else:    print("I am so glad: No spam!")print("Finally, I finished stuffing myself")

执行脚本后，在循环到 "spam"时会跳出循环体：

Great, delicious hamNo more spam please!Finally, I finished stuffing myself

range()函数

如果你需要遍历数字序列，可以使用内置 range() 函数。它会生成数列，例如:

>>> for i in range(5):...     print(i)...01234

你也可以使用 range 指定区间的值：

>>> for i in range(5,9) :  print(i)    5678>>>

也可以使 range 以指定数字开始并指定不同的增量(甚至可以是负数;有时这也叫做'步长'):

>>> for i in range(0, 10, 3) :    print(i)    0369>>> 

负数：

>>> for i in range(-10, -100, -30) :   print(i)    -10-40-70>>> 

您可以结合 range() 和 len() 函数以遍历一个序列的索引,如下所示:

>>> a = ['Mary', 'had', 'a', 'little', 'lamb']>>> for i in range(len(a)):...     print(i, a[i])...0 Mary1 had2 a3 little4 lamb

还可以使用 range() 函数来创建一个列表：

>>> list(range(5))[0, 1, 2, 3, 4]>>>

break 和 continue 语句及循环中的 else 子句

break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止，任何对应的循环 else 块将不执行。

continue 语句被用来告诉 Python 跳过当前循环中的当此循环，然后继续进行下一轮循环。

循环语句可以有 else 子句；它在穷尽列表(以 for 循环)或条件变为假(以 while 循环)循环终止时被执行，但循环被 break 终止时不执行，如下查寻质数的循环例子:

>>> for n in range(2, 10):...     for x in range(2, n):...         if n % x == 0:...             print(n, 'equals', x, '*', n//x)...             break...     else:...         # 循环中没有找到元素...         print(n, 'is a prime number')...2 is a prime number3 is a prime number4 equals 2 * 25 is a prime number6 equals 2 * 37 is a prime number8 equals 2 * 49 equals 3 * 3

pass 语句

pass 语句什么都不做。它只在语法上需要一条语句但程序不需要任何操作时使用。例如:

>>> while True:...     pass  # 等待键盘中断 (Ctrl+C)

最小的类:

>>> class MyEmptyClass:...     pass

>>> list=[1,2,3,4]>>> it = iter(list)    # 创建迭代器对象>>> print (next(it))   # 输出迭代器的下一个元素1>>> print (next(it))2>>> 

#!/usr/bin/python3list=[1,2,3,4]it = iter(list)    # 创建迭代器对象for x in it:    print (x, end=" ")

1 2 3 4

#!/usr/bin/python3import sys         # 引入 sys 模块list=[1,2,3,4]it = iter(list)    # 创建迭代器对象while True:    try:        print (next(it))    except StopIteration:        sys.exit()

1234

#!/usr/bin/python3import sysdef fibonacci(n): # 生成器函数 - 斐波那契    a, b, counter = 0, 1, 0    while True:        if (counter > n):             return        yield a        a, b = b, a + b        counter += 1f = fibonacci(10) # f 是一个迭代器，由生成器返回生成while True:    try:        print (next(f), end=" ")    except StopIteration:        sys.exit()

0 1 1 2 3 5 8 13 21 34 55

Python sys 模块介绍

在 Python 的 sys 模块提供访问解释器使用或维护的变量，和与解释器进行交互的函数。

通俗来讲，sys 模块负责程序与 Python 解释器的交互，提供了一系列的函数和变量，用于操控 Python 运行时的环境。

本章节我们将为大家介绍 Python 中函数的应用。

该章节可参阅 Python 函数应用详解。

Python 定义函数使用 def 关键字，一般格式如下：

def  函数名（参数列表）：    函数体

让我们使用函数来输出"Hello World！"：

>>> def hello() :  print("Hello World!") >>> hello()Hello World!>>> 

更复杂点的应用，函数中带上参数变量:

def area(width, height):    return width * height def print_welcome(name):    print("Welcome", name)print_welcome("Fred")w = 4h = 5print("width =", w, " height =", h, " area =", area(w, h))

以上实例输出结果：

Welcome Fredwidth = 4  height = 5  area = 20

函数变量作用域

定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。

通过以下实例，你可以清楚了解 Python 函数变量的作用域：

#!/usr/bin/env python3a = 4  # 全局变量 def print_func1():    a = 17 # 局部变量    print("in print_func a = ", a)def print_func2():       print("in print_func a = ", a)print_func1()print_func2()print("a = ", a) 

以上实例运行结果如下：

in print_func a =  17in print_func a =  4a =  4

关键字参数

函数也可以使用 kwarg = value 的关键字参数形式被调用。例如，以下函数:

def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'):    print("-- This parrot wouldn't", action, end=' ')    print("if you put", voltage, "volts through it.")    print("-- Lovely plumage, the", type)    print("-- It's", state, "!")

可以以下几种方式被调用:

parrot(1000)                                          # 1 positional argumentparrot(voltage=1000)                                  # 1 keyword argumentparrot(voltage=1000000, action='VOOOOOM')             # 2 keyword argumentsparrot(action='VOOOOOM', voltage=1000000)             # 2 keyword argumentsparrot('a million', 'bereft of life', 'jump')         # 3 positional argumentsparrot('a thousand', state='pushing up the daisies')  # 1 positional, 1 keyword

以下为错误调用方法：

parrot()                     # required argument missingparrot(voltage=5.0, 'dead')  # non-keyword argument after a keyword argumentparrot(110, voltage=220)     # duplicate value for the same argumentparrot(actor='John Cleese')  # unknown keyword argument

返回值

Python 函数使用 return 语句返回函数值，可以将函数作为一个值赋值给指定变量：

def return_sum(x,y):    c = x + y    return cres = return_sum(4,5)print(res)

你也可以让函数返回空值：

def empty_return(x,y):    c = x + y    returnres = empty_return(4,5)print(res)

可变参数列表

最后，一个较不常用的功能是可以让函数调用可变个数的参数。

这些参数被包装进一个元组(查看元组和序列)。

在这些可变个数的参数之前，可以有零到多个普通的参数:

def arithmetic_mean(*args):    if len(args) == 0:        return 0    else:        sum = 0        for x in args:            sum += x        return sum/len(args)print(arithmetic_mean(45,32,89,78))print(arithmetic_mean(8989.8,78787.78,3453,78778.73))print(arithmetic_mean(45,32))print(arithmetic_mean(45))print(arithmetic_mean())

以上实例输出结果为：

61.042502.327538.545.00

更详细教程请参阅参阅Python 函数应用详解。

本章节我们主要结合前面所学的知识点来介绍 Python 数据结构。

列表

Python 中列表是可变的，这是它区别于字符串和元组的最重要的特点，一句话概括即：列表可以修改，而字符串和元组不能修改。

以下是 Python 中列表的方法：

下面示例演示了列表的大部分方法：

>>> a = [66.25, 333, 333, 1, 1234.5]>>> print(a.count(333), a.count(66.25), a.count('x'))2 1 0>>> a.insert(2, -1)>>> a.append(333)>>> a[66.25, 333, -1, 333, 1, 1234.5, 333]>>> a.index(333)1>>> a.remove(333)>>> a[66.25, -1, 333, 1, 1234.5, 333]>>> a.reverse()>>> a[333, 1234.5, 1, 333, -1, 66.25]>>> a.sort()>>> a[-1, 1, 66.25, 333, 333, 1234.5]

注意：类似 insert, remove 或 sort 等修改列表的方法没有返回值。

将列表当做堆栈使用

列表的方法使得列表可以很方便的作为一个堆栈来使用，堆栈作为特定的数据结构，最先进入的元素会最后一个被释放（后进先出）。用 append() 方法可以把一个元素添加到堆栈顶。用不指定索引的 pop() 方法可以把一个元素从堆栈顶释放出来。例如：

>>> stack = [3, 4, 5]>>> stack.append(6)>>> stack.append(7)>>> stack[3, 4, 5, 6, 7]>>> stack.pop()7>>> stack[3, 4, 5, 6]>>> stack.pop()6>>> stack.pop()5>>> stack[3, 4]

将列表当作队列使用

也可以把列表当做队列用，在队列里第一个位置加入的元素，第一个取出来；但是拿列表用作队列效率不高。在列表的最后添加或者弹出元素速度快，然而在列表里插入或者从头部弹出速度却不快（因为所有其他的元素都得一个一个地移动）。

>>> from collections import deque>>> queue = deque(["Eric", "John", "Michael"])>>> queue.append("Terry")           # Terry arrives>>> queue.append("Graham")          # Graham arrives>>> queue.popleft()                 # The first to arrive now leaves'Eric'>>> queue.popleft()                 # The second to arrive now leaves'John'>>> queue                           # Remaining queue in order of arrivaldeque(['Michael', 'Terry', 'Graham'])

列表推导式

列表推导式提供了从序列创建列表的简单途径。通常应用程序将一些操作应用于某个序列的每个元素，用其获得的结果作为生成新列表的元素，或者根据确定的判定条件创建子序列。

每个列表推导式都在 for 之后跟一个表达式，然后有零到多个 for 或 if 子句。返回结果是一个根据表达从其后的 for 和 if 上下文环境中生成出来的列表。如果希望表达式推导出一个元组，就必须使用括号。

这里我们将列表中每个数值乘三，获得一个新的列表：

>>> vec = [2, 4, 6]>>> [3*x for x in vec][6, 12, 18]

现在我们玩一点小花样：

>>> [[x, x**2] for x in vec][[2, 4], [4, 16], [6, 36]]

这里我们对序列里每一个元素逐个调用某方法：

>>> freshfruit = ['  banana', '  loganberry ', 'passion fruit  ']>>> [weapon.strip() for weapon in freshfruit]['banana', 'loganberry', 'passion fruit']

我们可以用 if 子句作为过滤器：

>>> [3*x for x in vec if x > 3][12, 18]>>> [3*x for x in vec if x < 2] [] 

以下是一些关于循环和其它技巧的演示：

>>> vec1 = [2, 4, 6]>>> vec2 = [4, 3, -9]>>> [x*y for x in vec1 for y in vec2][8, 6, -18, 16, 12, -36, 24, 18, -54]>>> [x+y for x in vec1 for y in vec2][6, 5, -7, 8, 7, -5, 10, 9, -3]>>> [vec1[i]*vec2[i] for i in range(len(vec1))][8, 12, -54]

列表推导式可以使用复杂表达式或嵌套函数：

>>> [str(round(355/113, i)) for i in range(1, 6)]['3.1', '3.14', '3.142', '3.1416', '3.14159']

嵌套列表解析

Python 的列表还可以嵌套。

以下实例展示了 3 * 4 的矩阵列表：

>>> matrix = [...     [1, 2, 3, 4],...     [5, 6, 7, 8],...     [9, 10, 11, 12],... ]

以下实例将 3 * 4 的矩阵列表转换为 4 * 3 列表：

>>> [[row[i] for row in matrix] for i in range(4)][[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

以下实例也可以使用以下方法来实现：

>>> transposed = []>>> for i in range(4):...     transposed.append([row[i] for row in matrix])...>>> transposed[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

另外一种实现方法：

>>> transposed = []>>> for i in range(4):...     # the following 3 lines implement the nested listcomp...     transposed_row = []...     for row in matrix:...         transposed_row.append(row[i])...     transposed.append(transposed_row)...>>> transposed[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

del 语句

使用 del 语句可以从一个列表中依照索引（而不是值）来删除一个元素。这与使用 pop() 返回一个值不同。

可以用 del 语句从列表中删除一个切片，或清空整个列表（我们以前介绍的方法是给该切片赋一个空列表）。例如：

>>> a = [-1, 1, 66.25, 333, 333, 1234.5]>>> del a[0]>>> a[1, 66.25, 333, 333, 1234.5]>>> del a[2:4]>>> a[1, 66.25, 1234.5]>>> del a[:]>>> a[]

也可以用 del 删除实体变量：

>>> del a

元组和序列

元组由若干逗号分隔的值组成，例如：

>>> t = 12345, 54321, 'hello!'>>> t[0]12345>>> t(12345, 54321, 'hello!')>>> # Tuples may be nested:... u = t, (1, 2, 3, 4, 5)>>> u((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))

如你所见，元组在输出时总是有括号的，以便于正确表达嵌套结构。在输入时可能有或没有括号， 不过括号通常是必须的（如果元组是更大的表达式的一部分）。

集合

集合是一个无序不重复元素的集。基本功能包括关系测试和消除重复元素。

可以用大括号 ({}) 创建集合。注意：如果要创建一个空集合，你必须用 set() 而不是 {} ；后者创建一个空的字典，下一节我们会介绍这个数据结构。

以下是一个简单的演示：

>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}>>> print(basket)                      # show that duplicates have been removed{'orange', 'banana', 'pear', 'apple'}>>> 'orange' in basket                 # fast membership testingTrue>>> 'crabgrass' in basketFalse>>> # Demonstrate set operations on unique letters from two words...>>> a = set('abracadabra')>>> b = set('alacazam')>>> a                                  # unique letters in a{'a', 'r', 'b', 'c', 'd'}>>> a - b                              # letters in a but not in b{'r', 'd', 'b'}>>> a | b                              # letters in either a or b{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}>>> a & b                              # letters in both a and b{'a', 'c'}>>> a ^ b                              # letters in a or b but not both{'r', 'd', 'b', 'm', 'z', 'l'}

集合也支持推导式：

>>> a = {x for x in 'abracadabra' if x not in 'abc'}>>> a{'r', 'd'}

字典

另一个非常有用的 Python 内建数据类型是字典。

序列是以连续的整数为索引，与此不同的是，字典以关键字为索引，关键字可以是任意不可变类型，通常用字符串或数值。

理解字典的最佳方式是把它看做无序的键 => 值对集合。在同一个字典之内，关键字必须是互不相同。

一对大括号创建一个空的字典：{}。

这是一个字典运用的简单例子：

>>> tel = {'jack': 4098, 'sape': 4139}>>> tel['guido'] = 4127>>> tel{'sape': 4139, 'guido': 4127, 'jack': 4098}>>> tel['jack']4098>>> del tel['sape']>>> tel['irv'] = 4127>>> tel{'guido': 4127, 'irv': 4127, 'jack': 4098}>>> list(tel.keys())['irv', 'guido', 'jack']>>> sorted(tel.keys())['guido', 'irv', 'jack']>>> 'guido' in telTrue>>> 'jack' not in telFalse

构造函数 dict() 直接从键值对元组列表中构建字典。如果有固定的模式，列表推导式指定特定的键值对：

>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)]){'sape': 4139, 'jack': 4098, 'guido': 4127}

此外，字典推导可以用来创建任意键和值的表达式词典：

>>> {x: x**2 for x in (2, 4, 6)}{2: 4, 4: 16, 6: 36}

如果关键字只是简单的字符串，使用关键字参数指定键值对有时候更方便：

>>> dict(sape=4139, guido=4127, jack=4098){'sape': 4139, 'jack': 4098, 'guido': 4127}

遍历技巧

在字典中遍历时，关键字和对应的值可以使用 items() 方法同时解读出来：

>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}>>> for k, v in knights.items():...     print(k, v)...gallahad the purerobin the brave

在序列中遍历时，索引位置和对应值可以使用 enumerate() 函数同时得到：

>>> for i, v in enumerate(['tic', 'tac', 'toe']):...     print(i, v)...0 tic1 tac2 toe

同时遍历两个或更多的序列，可以使用 zip() 组合：

>>> questions = ['name', 'quest', 'favorite color']>>> answers = ['lancelot', 'the holy grail', 'blue']>>> for q, a in zip(questions, answers):...     print('What is your {0}?  It is {1}.'.format(q, a))...What is your name?  It is lancelot.What is your quest?  It is the holy grail.What is your favorite color?  It is blue.

要反向遍历一个序列，首先指定这个序列，然后调用 reversed() 函数：

>>> for i in reversed(range(1, 10, 2)):...     print(i)...97531

要按顺序遍历一个序列，使用 sorted() 函数返回一个已排序的序列，并不修改原值：

>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']>>> for f in sorted(set(basket)):...     print(f)...applebananaorangepear

其他参阅文档(Python2.x)

• Python 列表
• Python 元组
• Python 字典

在前面的几个章节中我们脚本上是用 Python 解释器来编程，如果你从 Python 解释器退出再进入，那么你定义的所有的方法和变量就都消失了。

为此 Python 提供了一个办法，把这些定义存放在文件中，为一些脚本或者交互式的解释器实例使用，这个文件被称为模块。

模块是一个包含所有你定义的函数和变量的文件，其后缀名是 .py。模块可以被别的程序引入，以使用该模块中的函数等功能。这也是使用 Python 标准库的方法。下面是一个使用 Python 标准库中模块的例子。 

#!/usr/bin/python3# Filename: using_sys.pyimport sysprint('命令行参数如下:')for i in sys.argv:    print(i)print('

Python 路径为：', sys.path, '
')

执行结果如下所示：

$ python using_sys.py 参数1 参数2命令行参数如下:using_sys.py参数1参数2Python 路径为： ['/root', '/usr/lib/python3.4', '/usr/lib/python3.4/plat-x86_64-linux-gnu', '/usr/lib/python3.4/lib-dynload', '/usr/local/lib/python3.4/dist-packages', '/usr/lib/python3/dist-packages']

• 1、import sys 引入 Python 标准库中的 sys.py 模块；这是引入某一模块的方法。
• 2、sys.argv 是一个包含命令行参数的列表。
• 3、sys.path 包含了一个 Python 解释器自动查找所需模块的路径的列表。

import 语句

如果要使用 Python 源文件，只需在另一个源文件里执行 import 语句，import 语句语法如下：

import module1[,module2[, ... moduleN]

当解释器遇到 import 语句，如果模块在当前的搜索路径就会被导入。

搜索路径是一个解释器会先进行搜索的所有目录的列表。如果想要导入模块 support，需要把命令放在脚本的顶端：

#!/usr/bin/python3# Filename: support.pydef print_func( par ):    print ("Hello : ", par)    return

test.py 引入 support 模块：

#!/usr/bin/python3# Filename: test.py# 导入模块import support# 现在可以调用模块里包含的函数了support.print_func("51coolma")

以上实例输出结果：

$ python3 test.pyHello :  51coolma

一个模块只会被导入一次，不管你执行了多少次 import。这样可以防止导入模块被一遍又一遍地执行。

当我们使用 import 语句的时候，Python 解释器是怎样找到对应的文件的呢？

这就涉及到 Python 的搜索路径，搜索路径是由一系列目录名组成的，Python 解释器就依次从这些目录中去寻找所引入的模块。

这看起来很像环境变量，事实上，也可以通过定义环境变量的方式来确定搜索路径。

搜索路径是在 Python 编译或安装的时候确定的，安装新的库应该也会修改。搜索路径被存储在 sys 模块中的 path 变量，做一个简单的实验，在交互式解释器中，输入以下代码：

>>> import sys>>> sys.path['', '/usr/lib/python3.4', '/usr/lib/python3.4/plat-x86_64-linux-gnu', '/usr/lib/python3.4/lib-dynload', '/usr/local/lib/python3.4/dist-packages', '/usr/lib/python3/dist-packages']>>> 

sys.path 输出是一个列表，其中第一项是空串''，代表当前目录（若是从一个脚本中打印出来的话，可以更清楚地看出是哪个目录），亦即我们执行 Python 解释器的目录（对于脚本的话就是运行的脚本所在的目录）。

因此若像我一样在当前目录下存在与要引入模块同名的文件，就会把要引入的模块屏蔽掉。

了解了搜索路径的概念，就可以在脚本中修改 sys.path 来引入一些不在搜索路径中的模块。

现在，在解释器的当前目录或者 sys.path 中的一个目录里面来创建一个 fibo.py 的文件，代码如下：

# 斐波那契数列模块（Fibonacci numbers module）def fib(n):    # 定义到 n 的斐波那契数列    a, b = 0, 1    while b < n:        print(b, end=' ')        a, b = b, a+b    print()def fib2(n): # 返回到 n 的斐波那契数列    result = []    a, b = 0, 1    while b < n:        result.append(b)        a, b = b, a+b    return result 

然后进入 Python 解释器，使用下面的命令导入这个模块：

>>> import fibo

这样做并没有把直接定义在 fibo 中的函数名称写入到当前符号表里，只是把模块 fibo 的名字写到了那里。

可以使用模块名称来访问函数：

>>> fibo.fib(1000)1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987>>> fibo.fib2(100)[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]>>> fibo.__name__'fibo'

如果你打算经常使用一个函数，你可以把它赋给一个本地的名称：

>>> fib = fibo.fib>>> fib(500)1 1 2 3 5 8 13 21 34 55 89 144 233 377

from ... import 语句

Python 的 from 语句让你从模块中导入一个指定的部分到当前命名空间中，语法如下：

from modname import name1[, name2[, ... nameN]

例如，要导入模块 fibo 的 fib 函数，使用如下语句：

>>> from fibo import fib, fib2>>> fib(500)1 1 2 3 5 8 13 21 34 55 89 144 233 377

这个声明不会把整个 fibo 模块导入到当前的命名空间中，它只会将 fibo 里的 fib 函数引入进来。

from ... import * 语句

把一个模块的所有内容全都导入到当前的命名空间也是可行的，只需使用如下声明：

from modname import *

这提供了一个简单的方法来导入一个模块中的所有项目。然而这种声明不该被过多的使用。

进一步了解模块

模块除了方法定义，还可以包括可执行的代码。这些代码一般用来初始化这个模块。这些代码只有在第一次被导入时才会被执行。

每个模块有各自独立的符号表，在模块内部为所有的函数当作全局符号表来使用。

所以，模块的作者可以放心大胆的在模块内部使用这些全局变量，而不用担心把其他用户的全局变量搞花。

从另一个方面，当你确实知道你在做什么的话，你也可以通过 modname.itemname 这样的表示法来访问模块内的函数。

模块是可以导入其他模块的。在一个模块（或者脚本，或者其他地方）的最前面使用 import 来导入一个模块，当然这只是一个惯例，而不是强制的。被导入的模块的名称将被放入当前操作的模块的符号表中。

还有一种导入的方法，可以使用 import 直接把模块内（函数，变量的）名称导入到当前操作模块。比如:

>>> from fibo import fib, fib2>>> fib(500)1 1 2 3 5 8 13 21 34 55 89 144 233 377

这种导入的方法不会把被导入的模块的名称放在当前的字符表中（所以在这个例子里面，fibo 这个名称是没有定义的）。

这还有一种方法，可以一次性的把模块中的所有（函数，变量）名称都导入到当前模块的字符表:

>>> from fibo import *>>> fib(500)1 1 2 3 5 8 13 21 34 55 89 144 233 377

这将把所有的名字都导入进来，但是那些由单一下划线（_）开头的名字不在此例。大多数情况， Python程序员不使用这种方法，因为引入的其它来源的命名，很可能覆盖了已有的定义。

__name__属性

一个模块被另一个程序第一次引入时，其主程序将运行。如果我们想在模块被引入时，模块中的某一程序块不执行，我们可以用 __name__ 属性来使该程序块仅在该模块自身运行时执行。

#!/usr/bin/python3# Filename: using_name.pyif __name__ == '__main__':    print('程序自身在运行')else:    print('我来自另一模块')

运行输出如下：

$ python using_name.py程序自身在运行

$ python>>> import using_name我来自另一模块>>>

说明：

1. 每个模块都有一个 __name__ 属性，当其值是 '__main__' 时，表明该模块自身在运行，否则是被引入。
   
2. __name__ 与 __main__ 底下是双下划线，是“_ _”去掉中间的空格。
   

dir() 函数

内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回:</p><pre>>>> import fibo, sys>>> dir(fibo)['__name__', 'fib', 'fib2']>>> dir(sys)  ['__displayhook__', '__doc__', '__excepthook__', '__loader__', '__name__', '__package__', '__stderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_current_frames', '_debugmallocstats', '_getframe', '_home', '_mercurial', '_xoptions', 'abiflags', 'api_version', 'argv', 'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats', 'copyright', 'displayhook', 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info', 'float_repr_style', 'getcheckinterval', 'getdefaultencoding', 'getdlopenflags', 'getfilesystemencoding', 'getobjects', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettotalrefcount', 'gettrace', 'hash_info', 'hexversion', 'implementation', 'int_info', 'intern', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix', 'ps1', 'setcheckinterval', 'setdlopenflags', 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout', 'thread_info', 'version', 'version_info', 'warnoptions']

如果没有给定参数，那么 dir() 函数会罗列出当前定义的所有名称:

>>> a = [1, 2, 3, 4, 5]>>> import fibo>>> fib = fibo.fib>>> dir() # 得到一个当前模块中定义的属性列表['__builtins__', '__name__', 'a', 'fib', 'fibo', 'sys']>>> a = 5 # 建立一个新的变量 'a'>>> dir()['__builtins__', '__doc__', '__name__', 'a', 'sys']>>>>>> del a # 删除变量名a>>>>>> dir()['__builtins__', '__doc__', '__name__', 'sys']>>>

标准模块

Python 本身带着一些标准的模块库，在 Python 库参考文档中将会介绍到（就是后面的"库参考文档"）。

有些模块直接被构建在解析器里，这些虽然不是一些语言内置的功能，但是他却能很高效的使用，甚至是系统级调用也没问题。

这些组件会根据不同的操作系统进行不同形式的配置，比如 winreg 这个模块就只会提供给 Windows 系统。

应该注意到这有一个特别的模块 sys ，它内置在每一个 Python 解析器中。变量 sys.ps1 和 sys.ps2 定义了主提示符和副提示符所对应的字符串:

>>> import sys>>> sys.ps1'>>> '>>> sys.ps2'... '>>> sys.ps1 = 'C> 'C> print('Yuck!')Yuck!C>

包

包是一种管理 Python 模块命名空间的形式，采用"点模块名称"。

比如一个模块的名称是 A.B， 那么他表示一个包 A 中的子模块 B 。

就好像使用模块的时候，你不用担心不同模块之间的全局变量相互影响一样，采用点模块名称这种形式也不用担心不同库之间的模块重名的情况。

这样不同的作者都可以提供 NumPy 模块，或者是 Python 图形库。

不妨假设你想设计一套统一处理声音文件和数据的模块（或者称之为一个"包"）。

现存很多种不同的音频文件格式（基本上都是通过后缀名区分的，例如： .wav，:file:.aiff，:file:.au，），所以你需要有一组不断增加的模块，用来在不同的格式之间转换。

并且针对这些音频数据，还有很多不同的操作（比如混音，添加回声，增加均衡器功能，创建人造立体声效果），所以你还需要一组怎么也写不完的模块来处理这些操作。

这里给出了一种可能的包结构（在分层的文件系统中）:

sound/                          顶层包      __init__.py               初始化 sound 包      formats/                  文件格式转换子包              __init__.py              wavread.py              wavwrite.py              aiffread.py              aiffwrite.py              auread.py              auwrite.py              ...      effects/                  声音效果子包              __init__.py              echo.py              surround.py              reverse.py              ...      filters/                  filters 子包              __init__.py              equalizer.py              vocoder.py              karaoke.py              ...

在导入一个包的时候，Python 会根据 sys.path 中的目录来寻找这个包中包含的子目录。

目录只有包含一个叫做 __init__.py 的文件才会被认作是一个包，主要是为了避免一些滥俗的名字（比如叫做 string）不小心的影响搜索路径中的有效模块。

最简单的情况，放一个空的 :file:__init__.py 就可以了。当然这个文件中也可以包含一些初始化代码或者为（将在后面介绍的） __all__变量赋值。

用户可以每次只导入一个包里面的特定模块，比如:

import sound.effects.echo

这将会导入子模块: mod:song.effects.echo。 他必须使用全名去访问:

sound.effects.echo.echofilter(input, output, delay=0.7, atten=4)

还有一种导入子模块的方法是：

from sound.effects import echo

这同样会导入子模块 echo ，并且他不需要那些冗长的前缀，所以他可以这样使用：

echo.echofilter(input, output, delay=0.7, atten=4)

还有一种变化就是直接导入一个函数或者变量：

from sound.effects.echo import echofilter

同样的，这种方法会导入子模块 echo ，并且可以直接使用他的 echofilter() 函数：

echofilter(input, output, delay=0.7, atten=4)

注意当使用 from package import item 这种形式的时候，对应的 item 既可以是包里面的子模块（子包），或者包里面定义的其他名称，比如函数，类或者变量。

import语法会首先把item当作一个包定义的名称，如果没找到，再试图按照一个模块去导入。如果还没找到，恭喜，一个 : exc:ImportError 异常被抛出了。

反之，如果使用形如 import item.subitem.subsubitem 这种导入形式，除了最后一项，都必须是包，而最后一项则可以是模块或者是包，但是不可以是类，函数或者变量的名字。

从一个包中导入*

设想一下，如果我们使用 from sound.effects import *会发生什么？

Python 会进入文件系统，找到这个包里面所有的子模块，一个一个的把它们都导入进来。

但是很不幸，这个方法在 Windows平台上工作的就不是非常好，因为 Windows 是一个大小写不区分的系统。

在这类平台上，没有人敢担保一个叫做 ECHO.py 的文件导入为模块 echo 还是 Echo 甚至 ECHO 。

（例如，Windows 95就很讨厌的把每一个文件的首字母大写显示）而且 DOS 的 8+3 命名规则对长模块名称的处理会把问题搞得更纠结。

为了解决这个问题，只能烦劳包作者提供一个精确的包的索引了。

导入语句遵循如下规则：如果包定义文件 __init__.py 存在一个叫做 __all__ 的列表变量，那么在使用 from package import * 的时候就把这个列表中的所有名字作为包内容导入。

作为包的作者，可别忘了在更新包之后保证 __all__ 也更新了啊。你说我就不这么做，我就不使用导入*这种用法，好吧，没问题，谁让你是老板呢。这里有一个例子，在 ​:file:sounds/effects/__init__.py​ 中包含如下代码：

__all__ = ["echo", "surround", "reverse"]

这表示当你使用 from sound.effects import * 这种用法时，你只会导入包里面这三个子模块。

如果 __all__ 没有定义，那么使用 from sound.effects import * 这种语法的时候，就不会导入包 sound.effects 里的任何子模块。他只是把包 sound.effects 和它里面定义的所有内容导入进来（可能运行 __init__.py 里定义的初始化代码）。

这会把 __init__.py 里面定义的所有名字导入进来。并且他不会破坏掉我们在这句话之前导入的所有明确指定的模块。看下这部分代码:

import sound.effects.echoimport sound.effects.surroundfrom sound.effects import *

这个例子中，在执行 from...import 前，包 sound.effects 中的 echo 和 surround 模块都被导入到当前的命名空间中了。（当然如果定义了__all__ 就更没问题了）

通常我们并不主张使用*这种方法来导入模块，因为这种方法经常会导致代码的可读性降低。不过这样倒的确是可以省去不少敲键的功夫，而且一些模块都设计成了只能通过特定的方法导入。

记住，使用 from Package import specific_submodule 这种方法永远不会有错。事实上，这也是推荐的方法。除非是你要导入的子模块有可能和其他包的子模块重名。

如果在结构中包是一个子包（比如这个例子中对于包 sound 来说），而你又想导入兄弟包（同级别的包）你就得使用导入绝对的路径来导入。比如，如果模块  sound.filters.vocoder 要使用包 sound.effects 中的模块 echo ，你就要写成 from sound.effects import echo。

from . import echofrom .. import formatsfrom ..filters import equalizer

无论是隐式的还是显式的相对导入都是从当前模块开始的。主模块的名字永远是 "__main__"，一个Python应用程序的主模块，应当总是使用绝对路径引用。

包还提供一个额外的属性 __path__ 。这是一个目录列表，里面每一个包含的目录都有为这个包服务的 __init__.py ，你得在其他 __init__.py 被执行前定义哦。可以修改这个变量，用来影响包含在包里面的模块和子包。

这个功能并不常用，一般用来扩展包里面的模块。

在前面几个章节中，我们其实已经接触了 Python 的输入输出的功能。本章节我们将具体介绍 Python 的输入输出。

输出格式美化

Python 两种输出值的方式: 表达式语句和 print() 函数。(第三种方式是使用文件对象的 write() 方法; 标准输出文件可以用 sys.stdout 引用。)

如果你希望输出的形式更加多样，可以使用 str.format() 函数来格式化输出值。

如果你希望将输出的值转成字符串，可以使用 repr() 或 str() 函数来实现。

str() 函数返回一个用户易读的表达形式。

repr() 产生一个解释器易读的表达形式。

例如

>>> s = 'Hello, world.'>>> str(s)'Hello, world.'>>> repr(s)"'Hello, world.'">>> str(1/7)'0.14285714285714285'>>> x = 10 * 3.25>>> y = 200 * 200>>> s = 'The value of x is ' + repr(x) + ', and y is ' + repr(y) + '...'>>> print(s)The value of x is 32.5, and y is 40000...>>> #  repr() 函数可以转义字符串中的特殊字符... hello = 'hello, world
'>>> hellos = repr(hello)>>> print(hellos)'hello, world
'>>> # repr() 的参数可以是 Python 的任何对象... repr((x, y, ('spam', 'eggs')))"(32.5, 40000, ('spam', 'eggs'))"

这里有两种方式输出一个平方与立方的表:

>>> for x in range(1, 11):...     print(repr(x).rjust(2), repr(x*x).rjust(3), end=' ')...     # 注意前一行 'end' 的使用...     print(repr(x*x*x).rjust(4))... 1   1    1 2   4    8 3   9   27 4  16   64 5  25  125 6  36  216 7  49  343 8  64  512 9  81  72910 100 1000>>> for x in range(1, 11):...     print('{0:2d} {1:3d} {2:4d}'.format(x, x*x, x*x*x))... 1   1    1 2   4    8 3   9   27 4  16   64 5  25  125 6  36  216 7  49  343 8  64  512 9  81  72910 100 1000

注意：在第一个例子中, 每列间的空格由 print() 添加。

这个例子展示了字符串对象的 rjust() 方法, 它可以将字符串靠右, 并在左边填充空格。

还有类似的方法, 如 ljust() 和 center()。 这些方法并不会写任何东西, 它们仅仅返回新的字符串。

另一个方法 zfill(), 它会在数字的左边填充 0，如下所示：

>>> '12'.zfill(5)'00012'>>> '-3.14'.zfill(7)'-003.14'>>> '3.14159265359'.zfill(5)'3.14159265359'

str.format() 的基本使用如下:

>>> print('We are the {} who say "{}!"'.format('knights', 'Ni'))We are the knights who say "Ni!"

括号及其里面的字符 (称作格式化字段) 将会被 format() 中的参数替换。

在括号中的数字用于指向传入对象在 format() 中的位置，如下所示：

>>> print('{0} and {1}'.format('spam', 'eggs'))spam and eggs>>> print('{1} and {0}'.format('spam', 'eggs'))eggs and spam

如果在 format() 中使用了关键字参数, 那么它们的值会指向使用该名字的参数。

>>> print('This {food} is {adjective}.'.format(...       food='spam', adjective='absolutely horrible'))This spam is absolutely horrible.

位置及关键字参数可以任意的结合:

>>> print('The story of {0}, {1}, and {other}.'.format('Bill', 'Manfred',other='Georg'))The story of Bill, Manfred, and Georg.

'!a' (使用 ascii()), '!s' (使用 str()) 和 '!r' (使用 repr()) 可以用于在格式化某个值之前对其进行转化:

>>> import math>>> print('The value of PI is approximately {}.'.format(math.pi))The value of PI is approximately 3.14159265359.>>> print('The value of PI is approximately {!r}.'.format(math.pi))The value of PI is approximately 3.141592653589793.

可选项 ':' 和格式标识符可以跟着字段名。 这就允许对值进行更好的格式化。 下面的例子将 Pi 保留到小数点后三位：

>>> import math>>> print('The value of PI is approximately {0:.3f}.'.format(math.pi))The value of PI is approximately 3.142.

在 ':' 后传入一个整数, 可以保证该域至少有这么多的宽度。 用于美化表格时很有用。

>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678}>>> for name, phone in table.items():...     print('{0:10} ==> {1:10d}'.format(name, phone))...Jack       ==>       4098Dcab       ==>       7678Sjoerd     ==>       4127

如果你有一个很长的格式化字符串, 而你不想将它们分开, 那么在格式化时通过变量名而非位置会是很好的事情。

最简单的就是传入一个字典, 然后使用方括号 '[]' 来访问键值 :

>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}>>> print('Jack: {0[Jack]:d}; Sjoerd: {0[Sjoerd]:d}; '          'Dcab: {0[Dcab]:d}'.format(table))Jack: 4098; Sjoerd: 4127; Dcab: 8637678

也可以通过在 table 变量前使用 '**' 来实现相同的功能：

>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}>>> print('Jack: {Jack:d}; Sjoerd: {Sjoerd:d}; Dcab: {Dcab:d}'.format(**table))Jack: 4098; Sjoerd: 4127; Dcab: 8637678

旧式字符串格式化

% 操作符也可以实现字符串格式化。 它将左边的参数作为类似 sprintf() 式的格式化字符串, 而将右边的代入, 然后返回格式化后的字符串. 例如:

>>> import math>>> print('The value of PI is approximately %5.3f.' % math.pi)The value of PI is approximately 3.142.

因为 str.format() 比较新的函数， 大多数的 Python 代码仍然使用 % 操作符。但是因为这种旧式的格式化最终会从该语言中移除, 应该更多的使用 str.format().

读和写文件

open() 将会返回一个 file 对象，基本语法格式如下:

open(filename, mode)

实例:

>>> f = open('/tmp/workfile', 'w')

• 第一个参数为要打开的文件名。
• 第二个参数描述文件如何使用的字符。 mode 可以是 'r' 如果文件只读, 'w' 只用于写 (如果存在同名文件则将被删除), 和 'a' 用于追加文件内容; 所写的任何数据都会被自动增加到末尾. 'r+' 同时用于读写。 mode 参数是可选的； 'r' 将是默认值。

文件对象的方法

本节中剩下的例子假设已经创建了一个称为 f 的文件对象。

f.read()

为了读取一个文件的内容，调用 f.read(size), 这将读取一定数目的数据, 然后作为字符串或字节对象返回。

size 是一个可选的数字类型的参数。 当 size 被忽略了或者为负, 那么该文件的所有内容都将被读取并且返回。

>>> f.read()'This is the entire file.
'>>> f.read()''

f.readline()

f.readline() 会从文件中读取单独的一行。换行符为 ' '。f.readline() 如果返回一个空字符串, 说明已经已经读取到最后一行。

>>> f.readline()'This is the first line of the file.
'>>> f.readline()'Second line of the file
'>>> f.readline()''

f.readlines()

f.readlines() 将返回该文件中包含的所有行。

如果设置可选参数 sizehint, 则读取指定长度的字节, 并且将这些字节按行分割。

>>> f.readlines()['This is the first line of the file.
', 'Second line of the file
']

另一种方式是迭代一个文件对象然后读取每行:

>>> for line in f:...     print(line, end='')...This is the first line of the file.Second line of the file

这个方法很简单, 但是并没有提供一个很好的控制。 因为两者的处理机制不同, 最好不要混用。

f.write()

f.write(string) 将 string 写入到文件中, 然后返回写入的字符数。

>>> f.write('This is a test
')15

如果要写入一些不是字符串的东西, 那么将需要先进行转换:

>>> value = ('the answer', 42)>>> s = str(value)>>> f.write(s)18

f.tell()

f.tell() 返回文件对象当前所处的位置, 它是从文件开头开始算起的字节数。

f.seek()

如果要改变文件当前的位置, 可以使用 f.seek(offset, from_what) 函数。

from_what 的值, 如果是 0 表示开头, 如果是 1 表示当前位置, 2 表示文件的结尾，例如：

• seek(x, 0) ： 从起始位置即文件首行首字符开始移动 x 个字符
• seek(x, 1) ： 表示从当前位置往后移动x个字符
• seek(-x, 2)：表示从文件的结尾往前移动x个字符

from_what 值为默认为 0，即文件开头。下面给出一个完整的例子：

>>> f = open('/tmp/workfile', 'rb+')>>> f.write(b'0123456789abcdef')16>>> f.seek(5)     # 移动到文件的第六个字节5>>> f.read(1)b'5'>>> f.seek(-3, 2) # 移动到文件的倒数第三字节13>>> f.read(1)b'd'

f.close()

在文本文件中 (那些打开文件的模式下没有 b 的), 只会相对于文件起始位置进行定位。

当你处理完一个文件后, 调用 f.close() 来关闭文件并释放系统的资源，如果尝试再调用该文件，则会抛出异常。

>>> f.close()>>> f.read()Traceback (most recent call last):  File "<stdin>", line 1, in ?ValueError: I/O operation on closed file<pre><p>当处理一个文件对象时, 使用 with 关键字是非常好的方式。在结束后, 它会帮你正确的关闭文件。 而且写起来也比 try - finally 语句块要简短:</p><pre>>>> with open('/tmp/workfile', 'r') as f:...     read_data = f.read()>>> f.closedTrue

文件对象还有其他方法, 如 isatty() 和 trucate(), 但这些通常比较少用。

pickle 模块

Python 的 pickle 模块实现了基本的数据序列和反序列化。

通过 pickle 模块的序列化操作我们能够将程序中运行的对象信息保存到文件中去，永久存储。

通过 pickle 模块的反序列化操作，我们能够从文件中创建上一次程序保存的对象。

基本接口：

pickle.dump(obj, file, [,protocol])

有了 pickle 这个对象, 就能对 file 以读取的形式打开:

x = pickle.load(file)

注解：从 file 中读取一个字符串，并将它重构为原来的 Python 对象。

file: 类文件对象，有read() 和 readline() 接口。

实例 1：

#使用pickle模块将数据对象保存到文件import pickledata1 = {'a': [1, 2.0, 3, 4+6j],         'b': ('string', u'Unicode string'),         'c': None}selfref_list = [1, 2, 3]selfref_list.append(selfref_list)output = open('data.pkl', 'wb')# Pickle dictionary using protocol 0.pickle.dump(data1, output)# Pickle the list using the highest protocol available.pickle.dump(selfref_list, output, -1)output.close()

实例 2：

#使用pickle模块从文件中重构python对象import pprint, picklepkl_file = open('data.pkl', 'rb')data1 = pickle.load(pkl_file)pprint.pprint(data1)data2 = pickle.load(pkl_file)pprint.pprint(data2)pkl_file.close()

作为 Python 初学者，在刚学习 Python 编程时，经常会看到一些报错信息，在前面我们没有提及，这章节我们会专门介绍。

Python 有两种错误很容易辨认：语法错误和异常。

语法错误

Python 的语法错误或者称之为解析错，是初学者经常碰到的，如下实例

>>> while True print('Hello world')  File "<stdin>", line 1, in ?    while True print('Hello world')                   ^SyntaxError: invalid syntax

这个例子中，函数 print() 被检查到有错误，是它前面缺少了一个冒号（:）。

语法分析器指出了出错的一行，并且在最先找到的错误的位置标记了一个小小的箭头。

异常

即便 Python 程序的语法是正确的，在运行它的时候，也有可能发生错误。运行期检测到的错误被称为异常。

大多数的异常都不会被程序处理，都以错误信息的形式展现在这里:

>>> 10 * (1/0)Traceback (most recent call last):  File "<stdin>", line 1, in ?ZeroDivisionError: division by zero>>> 4 + spam*3Traceback (most recent call last):  File "<stdin>", line 1, in ?NameError: name 'spam' is not defined>>> '2' + 2Traceback (most recent call last):  File "<stdin>", line 1, in ?TypeError: Can't convert 'int' object to str implicitly

异常以不同的类型出现，这些类型都作为信息的一部分打印出来: 例子中的类型有 ZeroDivisionError，NameError 和 TypeError。

错误信息的前面部分显示了异常发生的上下文，并以调用栈的形式显示具体信息。

异常处理

以下例子中，让用户输入一个合法的整数，但是允许用户中断这个程序（使用 Control-C 或者操作系统提供的方法）。用户中断的信息会引发一个 KeyboardInterrupt 异常。

>>> while True:        try:            x = int(input("Please enter a number: "))            break        except ValueError:            print("Oops!  That was no valid number.  Try again   ")   

try 语句按照如下方式工作；

• 首先，执行 try 子句（在关键字 try 和关键字 except 之间的语句）
• 如果没有异常发生，忽略 except 子句，try 子句执行后结束。
• 如果在执行 try 子句的过程中发生了异常，那么 try 子句余下的部分将被忽略。如果异常的类型和 except 之后的名称相符，那么对应的 except 子句将被执行。最后执行 try 语句之后的代码。
• 如果一个异常没有与任何的 except 匹配，那么这个异常将会传递给上层的 try 中。

一个 try 语句可能包含多个 except 子句，分别来处理不同的特定的异常。最多只有一个分支会被执行。

处理程序将只针对对应的 try 子句中的异常进行处理，而不是其他的 try 的处理程序中的异常。

一个 except 子句可以同时处理多个异常，这些异常将被放在一个括号里成为一个元组，例如:

>>> except (RuntimeError, TypeError, NameError):        pass

最后一个 except 子句可以忽略异常的名称，它将被当作通配符使用。你可以使用这种方法打印一个错误信息，然后再次把异常抛出。

import systry:    f = open('myfile.txt')    s = f.readline()    i = int(s.strip())except OSError as err:    print("OS error: {0}".format(err))except ValueError:    print("Could not convert data to an integer.")except:    print("Unexpected error:", sys.exc_info()[0])    raise

try except 语句还有一个可选的 else 子句，如果使用这个子句，那么必须放在所有的 except 子句之后。这个子句将在 try 子句没有发生任何异常的时候执行。例如:

for arg in sys.argv[1:]:    try:        f = open(arg, 'r')    except IOError:        print('cannot open', arg)    else:        print(arg, 'has', len(f.readlines()), 'lines')        f.close()

使用 else 子句比把所有的语句都放在 try 子句里面要好，这样可以避免一些意想不到的、而except又没有捕获的异常。

异常处理并不仅仅处理那些直接发生在try子句中的异常，而且还能处理子句中调用的函数（甚至间接调用的函数）里抛出的异常。例如:

>>> def this_fails():        x = 1/0   >>> try:        this_fails()    except ZeroDivisionError as err:        print('Handling run-time error:', err)   Handling run-time error: int division or modulo by zero

抛出异常

Python 使用 raise 语句抛出一个指定的异常。例如:

>>> raise NameError('HiThere')Traceback (most recent call last):  File "<stdin>", line 1, in ?NameError: HiThere

raise 唯一的一个参数指定了要被抛出的异常。它必须是一个异常的实例或者是异常的类（也就是 Exception 的子类）。

如果你只想知道这是否抛出了一个异常，并不想去处理它，那么一个简单的 raise 语句就可以再次把它抛出。

>>> try:        raise NameError('HiThere')    except NameError:        print('An exception flew by!')        raise   An exception flew by!Traceback (most recent call last):  File "<stdin>", line 2, in ?NameError: HiThere

用户自定义异常

你可以通过创建一个新的 exception 类来拥有自己的异常。异常应该继承自 Exception 类，或者直接继承，或者间接继承，例如:

>>> class MyError(Exception):        def __init__(self, value):            self.value = value        def __str__(self):            return repr(self.value)   >>> try:        raise MyError(2*2)    except MyError as e:        print('My exception occurred, value:', e.value)   My exception occurred, value: 4>>> raise MyError('oops!')Traceback (most recent call last):  File "<stdin>", line 1, in ?__main__.MyError: 'oops!'

在这个例子中，类 Exception 默认的 __init__() 被覆盖。

异常的类可以像其他的类一样做任何事情，但是通常都会比较简单，只提供一些错误相关的属性，并且允许处理异常的代码方便的获取这些信息。

当创建一个模块有可能抛出多种不同的异常时，一种通常的做法是为这个包建立一个基础异常类，然后基于这个基础类为不同的错误情况创建不同的子类:

class Error(Exception):    """Base class for exceptions in this module."""    passclass InputError(Error):    """Exception raised for errors in the input.    Attributes:        expression -- input expression in which the error occurred        message -- explanation of the error    """    def __init__(self, expression, message):        self.expression = expression        self.message = messageclass TransitionError(Error):    """Raised when an operation attempts a state transition that's not    allowed.    Attributes:        previous -- state at beginning of transition        next -- attempted new state        message -- explanation of why the specific transition is not allowed    """    def __init__(self, previous, next, message):        self.previous = previous        self.next = next        self.message = message

大多数的异常的名字都以"Error"结尾，就跟标准的异常命名一样。

定义清理行为

try 语句还有另外一个可选的子句，它定义了无论在任何情况下都会执行的清理行为。 例如:

>>> try:        raise KeyboardInterrupt    finally:        print('Goodbye, world!')   Goodbye, world!KeyboardInterrupt

以上例子不管 try 子句里面有没有发生异常，finally 子句都会执行。

如果一个异常在 try 子句里（或者在 except 和 else 子句里）被抛出，而又没有任何的 except 把它截住，那么这个异常会在 finally 子句执行后再次被抛出。

下面是一个更加复杂的例子（在同一个 try 语句里包含 except 和 finally 子句）:

>>> def divide(x, y):        try:            result = x / y        except ZeroDivisionError:            print("division by zero!")        else:            print("result is", result)        finally:            print("executing finally clause")   >>> divide(2, 1)result is 2.0executing finally clause>>> divide(2, 0)division by zero!executing finally clause>>> divide("2", "1")executing finally clauseTraceback (most recent call last):  File "<stdin>", line 1, in ?  File "<stdin>", line 3, in divideTypeError: unsupported operand type(s) for /: 'str' and 'str'

预定义的清理行为

一些对象定义了标准的清理行为，无论系统是否成功的使用了它，一旦不需要它了，那么这个标准的清理行为就会执行。

这面这个例子展示了尝试打开一个文件，然后把内容打印到屏幕上:

for line in open("myfile.txt"):    print(line, end="")

以上这段代码的问题是，当执行完毕后，文件会保持打开状态，并没有被关闭。

关键词 with 语句就可以保证诸如文件之类的对象在使用完之后一定会正确的执行他的清理方法:

with open("myfile.txt") as f:    for line in f:        print(line, end="")

以上这段代码执行完毕后，就算在处理过程中出问题了，文件 f 总是会关闭。

Python 从设计之初就是一门面向对象的语言，正因为如此，在 Python 中创建一个类和对象是很容易的。本章节我们将详细介绍 Python 的面向对象编程。

如果你以前没有接触过面向对象的编程语言，那你可能需要先了解一些面向对象语言的一些基本特征，在头脑里头形成一个基本的面向对象的概念，这样有助于你更容易的学习 Python 的面向对象编程。

接下来我们先来简单的了解下面向对象的一些基本特征。

Python3 面向对象技术简介

• 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
• 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
• 数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。
• 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
• 局部变量：定义在方法中的变量，只作用于当前实例的类。
• 实例变量：在类的声明中，属性是用变量来表示的。这种变量就称为实例变量，是在类声明的内部但是在类的其他成员方法之外声明的。
• 继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个 Dog 类型的对象派生自 Animal 类，这是模拟"是一个（is-a）"关系（例图，Dog 是一个 Animal）。
• 实例化：创建一个类的实例，类的具体对象。
• 方法：类中定义的函数。
• 对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

和其它编程语言相比，Python 在尽可能不增加新的语法和语义的情况下加入了类机制。

Python 中的类提供了面向对象编程的所有基本功能：类的继承机制允许多个基类，派生类可以覆盖基类中的任何方法，方法中可以调用基类中的同名方法。

对象可以包含任意数量和类型的数据。

类定义

语法格式如下：

class ClassName:    <statement-1>    .    .    .    <statement-N>

类实例化后，可以使用其属性，实际上，创建一个类之后，可以通过类名访问其属性。

类对象

类对象支持两种操作：属性引用和实例化。

属性引用使用和 Python 中所有的属性引用一样的标准语法：obj.name。

类对象创建后，类命名空间中所有的命名都是有效属性名。所以如果类定义是这样:

#!/usr/bin/python3class MyClass:    """一个简单的类实例"""    i = 12345    def f(self):        return 'hello world'# 实例化类x = MyClass()# 访问类的属性和方法print("MyClass 类的属性 i 为：", x.i)print("MyClass 类的方法 f 输出为：", x.f())

实例化类：

# 实例化类x = MyClass()# 访问类的属性和方法

以上创建了一个新的类实例并将该对象赋给局部变量 x，x 为空的对象。

执行以上程序输出结果为：

MyClass 类的属性 i 为： 12345MyClass 类的方法 f 输出为： hello world

很多类都倾向于将对象创建为有初始状态的。因此类可能会定义一个名为 __init__() 的特殊方法（构造方法），像下面这样：

def __init__(self):    self.data = []

类定义了 __init__() 方法的话，类的实例化操作会自动调用 __init__() 方法。所以在下例中，可以这样创建一个新的实例:

x = MyClass()

当然， __init__() 方法可以有参数，参数通过 __init__() 传递到类的实例化操作上。例如:

>>> class Complex:...     def __init__(self, realpart, imagpart):...         self.r = realpart...         self.i = imagpart...>>> x = Complex(3.0, -4.5)>>> x.r, x.i(3.0, -4.5)

类的方法

在类的内部，使用 def 关键字可以为类定义一个方法，与一般函数定义不同，类方法必须包含参数 self，且为第一个参数:

#!/usr/bin/python3#类定义class people:    #定义基本属性    name = ''    age = 0    #定义私有属性,私有属性在类外部无法直接进行访问    __weight = 0    #定义构造方法    def __init__(self,n,a,w):        self.name = n        self.age = a        self.__weight = w    def speak(self):        print("%s 说: 我 %d 岁。" %(self.name,self.age))# 实例化类p = people('W3Cschool',10,30)p.speak()

执行以上程序输出结果为：

W3Cschool 说: 我 10 岁。

继承

Python 同样支持类的继承，如果一种语言不支持继承，类就没有什么意义。派生类的定义如下所示:

class DerivedClassName(BaseClassName1):    <statement-1>    .    .    .    <statement-N>

需要注意圆括号中基类的顺序，若是基类中有相同的方法名，而在子类使用时未指定，Python 从左至右搜索 即方法在子类中未找到时，从左到右查找基类中是否包含方法。

BaseClassName（示例中的基类名）必须与派生类定义在一个作用域内。除了类，还可以用表达式，基类定义在另一个模块中时这一点非常有用:

class DerivedClassName(modname.BaseClassName):

实例

#!/usr/bin/python3#类定义class people:    #定义基本属性    name = ''    age = 0    #定义私有属性,私有属性在类外部无法直接进行访问    __weight = 0    #定义构造方法    def __init__(self,n,a,w):        self.name = n        self.age = a        self.__weight = w    def speak(self):        print("%s 说: 我 %d 岁。" %(self.name,self.age))#单继承示例class student(people):    grade = ''    def __init__(self,n,a,w,g):        #调用父类的构函        people.__init__(self,n,a,w)        self.grade = g    #覆写父类的方法    def speak(self):        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))s = student('ken',10,60,3)s.speak()

执行以上程序输出结果为：

ken 说: 我 10 岁了，我在读 3 年级

多继承

Python 同样有限的支持多继承形式。多继承的类定义形如下例:

class DerivedClassName(Base1, Base2, Base3):    <statement-1>    .    .    .    <statement-N>

需要注意圆括号中父类的顺序，若是父类中有相同的方法名，而在子类使用时未指定，Python 从左至右搜索 即方法在子类中未找到时，从左到右查找父类中是否包含方法。

#!/usr/bin/python3#类定义class people:    #定义基本属性    name = ''    age = 0    #定义私有属性,私有属性在类外部无法直接进行访问    __weight = 0    #定义构造方法    def __init__(self,n,a,w):        self.name = n        self.age = a        self.__weight = w    def speak(self):        print("%s 说: 我 %d 岁。" %(self.name,self.age))#单继承示例class student(people):    grade = ''    def __init__(self,n,a,w,g):        #调用父类的构函        people.__init__(self,n,a,w)        self.grade = g    #覆写父类的方法    def speak(self):        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))#另一个类，多重继承之前的准备class speaker():    topic = ''    name = ''    def __init__(self,n,t):        self.name = n        self.topic = t    def speak(self):        print("我叫 %s，我是一个演说家，我演讲的主题是 %s"%(self.name,self.topic))#多重继承class sample(speaker,student):    a =''    def __init__(self,n,a,w,g,t):        student.__init__(self,n,a,w,g)        speaker.__init__(self,n,t)test = sample("Tim",25,80,4,"Python")test.speak()   #方法名同，默认调用的是在括号中排前地父类的方法

执行以上程序输出结果为：

我叫 Tim，我是一个演说家，我演讲的主题是 Python

方法重写

如果你的父类方法的功能不能满足你的需求，你可以在子类重写你父类的方法，实例如下：

#!/usr/bin/python3class Parent:        # 定义父类   def myMethod(self):      print ('调用父类方法')class Child(Parent): # 定义子类   def myMethod(self):      print ('调用子类方法')c = Child()          # 子类实例c.myMethod()         # 子类调用重写方法

执行以上程序输出结果为：

调用子类方法

类属性与方法

类的私有属性

__private_attrs：两个下划线开头，声明该属性为私有，不能在类地外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。

类的方法

在类地内部，使用 def 关键字可以为类定义一个方法，与一般函数定义不同，类方法必须包含参数 self, 且为第一个参数

类的私有方法

__private_method：两个下划线开头，声明该方法为私有方法，不能在类地外部调用。在类的内部调用 slef.__private_methods。

实例如下：

#!/usr/bin/python3class JustCounter:    __secretCount = 0  # 私有变量    publicCount = 0    # 公开变量    def count(self):        self.__secretCount += 1        self.publicCount += 1        print (self.__secretCount)counter = JustCounter()counter.count()counter.count()print (counter.publicCount)print (counter.__secretCount)  # 报错，实例不能访问私有变量

执行以上程序输出结果为：

122Traceback (most recent call last):  File "test.py", line 16, in <module>    print (counter.__secretCount)  # 报错，实例不能访问私有变量AttributeError: 'JustCounter' object has no attribute '__secretCount'

类的专有方法：

• __init__ : 构造函数，在生成对象时调用
• __del__ : 析构函数，释放对象时使用
• __repr__ : 打印，转换
• __setitem__ : 按照索引赋值
• __getitem__: 按照索引获取值
• __len__: 获得长度
• __cmp__: 比较运算
• __call__: 函数调用
• __add__: 加运算
• __sub__: 减运算
• __mul__: 乘运算
• __div__: 除运算
• __mod__: 求余运算
• __pow__: 乘方

运算符重载

Python 同样支持运算符重载，我么可以对类的专有方法进行重载，实例如下：

#!/usr/bin/python3class Vector:   def __init__(self, a, b):      self.a = a      self.b = b   def __str__(self):      return 'Vector (%d, %d)' % (self.a, self.b)      def __add__(self,other):      return Vector(self.a + other.a, self.b + other.b)v1 = Vector(2,10)v2 = Vector(5,-2)print (v1 + v2)

以上代码执行结果如下所示:

Vector(7,8)

Python 语言参考手册描述了具体语法和语义，并介绍了与 Python 一起发布的标准库。本文还描述了发行版中通常包含的一些可选组件。

操作系统接口

os 模块提供了不少与操作系统相关联的函数。

>>> import os>>> os.getcwd()      # 返回当前的工作目录'C:Python34'>>> os.chdir('/server/accesslogs')   # 修改当前的工作目录>>> os.system('mkdir today')   # 执行系统命令 mkdir 0

建议使用 "import os" 风格而非 "from os import *"。这样可以保证随操作系统不同而有所变化的 os.open() 不会覆盖内置函数 open()。

在使用 os 这样的大型模块时内置的 dir() 和 help() 函数非常有用:

>>> import os>>> dir(os)<returns a list of all module functions>>>> help(os)<returns an extensive manual page created from the module's docstrings>

针对日常的文件和目录管理任务，:mod:shutil 模块提供了一个易于使用的高级接口:

>>> import shutil>>> shutil.copyfile('data.db', 'archive.db')>>> shutil.move('/build/executables', 'installdir')

文件通配符

glob 模块提供了一个函数用于从目录通配符搜索中生成文件列表:

>>> import glob>>> glob.glob('*.py')['primes.py', 'random.py', 'quote.py']

命令行参数

通用工具脚本经常调用命令行参数。这些命令行参数以链表形式存储于 sys 模块的 argv 变量。例如在命令行中执行 "python demo.py one two three" 后可以得到以下输出结果:

>>> import sys>>> print(sys.argv)['demo.py', 'one', 'two', 'three']

错误输出重定向和程序终止

sys 还有 stdin，stdout 和 stderr 属性，即使在 stdout 被重定向时，后者也可以用于显示警告和错误信息。

>>> sys.stderr.write('Warning, log file not found starting a new one
')Warning, log file not found starting a new one

大多脚本的定向终止都使用 "sys.exit()"。

字符串正则匹配

re 模块为高级字符串处理提供了正则表达式工具。对于复杂的匹配和处理，正则表达式提供了简洁、优化的解决方案:

>>> import re>>> re.findall(r'f[a-z]*', 'which foot or hand fell fastest')['foot', 'fell', 'fastest']>>> re.sub(r'([a-z]+) 1', r'1', 'cat in the the hat')'cat in the hat'

如果只需要简单的功能，应该首先考虑字符串方法，因为它们非常简单，易于阅读和调试:

>>> 'tea for too'.replace('too', 'two')'tea for two'

数学

math 模块为浮点运算提供了对底层 C 函数库的访问:

>>> import math>>> math.cos(math.pi / 4)0.70710678118654757>>> math.log(1024, 2)10.0

random 提供了生成随机数的工具。

>>> import random>>> random.choice(['apple', 'pear', 'banana'])'apple'>>> random.sample(range(100), 10)   # sampling without replacement[30, 83, 16, 4, 8, 81, 41, 50, 18, 33]>>> random.random()    # random float0.17970987693706186>>> random.randrange(6)    # random integer chosen from range(6)4

访问 互联网

有几个模块用于访问互联网以及处理网络通信协议。其中最简单的两个是用于处理从 urls 接收的数据的 urllib.request 以及用于发送电子邮件的 smtplib:

>>> from urllib.request import urlopen>>> for line in urlopen('http://tycho.usno.navy.mil/cgi-bin/timer.pl'):...     line = line.decode('utf-8')  # Decoding the binary data to text....     if 'EST' in line or 'EDT' in line:  # look for Eastern Time...         print(line)<BR>Nov. 25, 09:43:32 PM EST>>> import smtplib>>> server = smtplib.SMTP('localhost')>>> server.sendmail('soothsayer@example.org', 'jcaesar@example.org',... """To: jcaesar@example.org... From: soothsayer@example.org...... Beware the Ides of March.... """)>>> server.quit()

注意第二个例子需要本地有一个在运行的邮件服务器。

日期和时间

datetime 模块为日期和时间处理同时提供了简单和复杂的方法。

支持日期和时间算法的同时，实现的重点放在更有效的处理和格式化输出。

该模块还支持时区处理:

>>> # dates are easily constructed and formatted>>> from datetime import date>>> now = date.today()>>> nowdatetime.date(2003, 12, 2)>>> now.strftime("%m-%d-%y. %d %b %Y is a %A on the %d day of %B.")'12-02-03. 02 Dec 2003 is a Tuesday on the 02 day of December.'>>> # dates support calendar arithmetic>>> birthday = date(1964, 7, 31)>>> age = now - birthday>>> age.days14368

数据压缩

以下模块直接支持通用的数据打包和压缩格式：zlib，gzip，bz2，zipfile，以及 tarfile。

>>> import zlib>>> s = b'witch which has which witches wrist watch'>>> len(s)41>>> t = zlib.compress(s)>>> len(t)37>>> zlib.decompress(t)b'witch which has which witches wrist watch'>>> zlib.crc32(s)226805979

性能度量

有些用户对了解解决同一问题的不同方法之间的性能差异很感兴趣。Python 提供了一个度量工具，为这些问题提供了直接答案。

例如，使用元组封装和拆封来交换元素看起来要比使用传统的方法要诱人的多,timeit 证明了现代的方法更快一些。

>>> from timeit import Timer>>> Timer('t=a; a=b; b=t', 'a=1; b=2').timeit()0.57535828626024577>>> Timer('a,b = b,a', 'a=1; b=2').timeit()0.54962537085770791

相对于 timeit 的细粒度，:mod:profile 和 pstats 模块提供了针对更大代码块的时间度量工具。

测试模块

开发高质量软件的方法之一是为每一个函数开发测试代码，并且在开发过程中经常进行测试

doctest 模块提供了一个工具，扫描模块并根据程序中内嵌的文档字符串执行测试。

测试构造如同简单的将它的输出结果剪切并粘贴到文档字符串中。

通过用户提供的例子，它强化了文档，允许 doctest 模块确认代码的结果是否与文档一致:

def average(values):    """Computes the arithmetic mean of a list of numbers.    >>> print(average([20, 30, 70]))    40.0    """    return sum(values) / len(values)import doctestdoctest.testmod()   # 自动验证嵌入测试

unittest 模块不像 doctest 模块那么容易使用，不过它可以在一个独立的文件里提供一个更全面的测试集:

import unittestclass TestStatisticalFunctions(unittest.TestCase):    def test_average(self):        self.assertEqual(average([20, 30, 70]), 40.0)        self.assertEqual(round(average([1, 5, 7]), 1), 4.3)        self.assertRaises(ZeroDivisionError, average, [])        self.assertRaises(TypeError, average, 20, 30, 70)unittest.main() # Calling from the command line invokes all tests

以下实例在 Python3.4.3 版本下测试通过：

• Python Hello World 实例
• Python 数字求和
• Python 平方根
• Python 二次方程
• Python 计算三角形的面积
• Python 随机数生成
• Python 摄氏温度转华氏温度
• Python 交换变量
• Python if 语句
• Python 判断字符串是否为数字
• Python 判断奇数偶数
• Python 判断闰年
• Python 获取最大值函数
• Python 质数判断
• Python 阶乘实例
• Python 九九乘法表
• Python 斐波那契数列
• Python 阿姆斯特朗数
• Python 十进制转二进制、八进制、十六进制
• Python ASCII码与字符相互转换
• Python 最大公约数算法
• Python 最小公倍数算法
• Python 简单计算器实现
• Python 生成日历
• Python 使用递归斐波那契数列
• Python 文件 IO
• Python 字符串判断
• Python 字符串大小写转换
• Python 计算每个月天数
• Python 获取昨天日期
• Python list 常用操作

查看 Python 版本

我们可以在命令提示符/终端中使用以下命令来查看我们使用的 Python 版本：

python -V

以上命令执行结果如下：

Python 3.8.5

在命令提示符/终端中输入python并回车可以进入 Python 的交互式编程模式，在这里也可以查看版本：

Python 3.8.5 (tags/v3.8.5:580fbb0, Jul 20 2020, 15:57:54) [MSC v.1924 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>

第一个 Python3.x 程序

1. 对于大多数程序语言，第一个入门编程代码便是"Hello World！"，以下代码为使用 Python 输出"Hello World！"：

#!/usr/bin/python3print("Hello, World!")

• ​​#!/usr/bin/python3​​ ：指定用什么解释器运行脚本以及解释器所在的位置，如果解释器没有装在/usr/bin/目录，改成其所在目录就行了，或者更通用的方法是：
  ​#!/usr/bin/env python3​。
• 在Windows环境下这并不是必要的代码。

2. 你可以将以上代码保存在 ​hello.py​ 文件中并使用 python 命令执行该脚本文件。

python hello.py

3. 以上命令输出结果为：

Hello, World!

 本节对学习python编程没有太多实质性的帮助，但本节介绍了一些python的历史和特性，有兴趣的小伙伴可以了解一下。

Python 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。

Python 的设计具有很强的可读性，相比其他语言经常使用英文关键字，其他语言的一些标点符号，它具有比其他语言更有特色语法结构。

• Python 是一种解释型语言： 这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。
• Python 是交互式语言： 这意味着，您可以在一个 Python 提示符 >>> 后直接执行代码。
• Python 是面向对象语言: 这意味着Python支持面向对象的风格或代码封装在对象的编程技术。
• Python 是初学者的语言：Python 对初级程序员而言，是一种伟大的语言，它支持广泛的应用程序开发，从简单的文字处理到服务器再到游戏，它都可以胜任。

Python 发展历史

Python 是由 Guido van Rossum 在八十年代末和九十年代初，在荷兰国家数学和计算机科学研究所设计出来的。

Python 本身也是由诸多其他语言发展而来的,这包括 ABC、Modula-3、C、C++、Algol-68、SmallTalk、Unix shell 和其他的脚本语言等等。

像 Perl 语言一样，Python 源代码同样遵循 GPL(GNU General Public License)协议。

现在 Python 是由一个核心开发团队在维护，Guido van Rossum 仍然占据着至关重要的作用，指导其进展。

Python 2.0 于 2000 年 10 月 16 日发布，增加了实现完整的垃圾回收，并且支持 Unicode。

Python 3.0 于 2008 年 12 月 3 日发布，此版不完全兼容之前的 Python 源代码。不过，很多新特性后来也被移植到旧的Python 2.6/2.7版本。

Python 3.0 版本，常被称为 Python 3000，或简称 Py3k。相对于 Python 的早期版本，这是一个较大的升级。

Python 2.7 被确定为最后一个 Python 2.x 版本，它除了支持 Python 2.x 语法外，还支持部分 Python 3.1 语法。

Python 特点

• 1.易于学习：Python有相对较少的关键字，结构简单，和一个明确定义的语法，学习起来更加简单。
• 2.易于阅读：Python代码定义的更清晰。
• 3.易于维护：Python的成功在于它的源代码是相当容易维护的。
• 4.一个广泛的标准库：Python的最大的优势之一是丰富的库，跨平台的，在UNIX，Windows和Macintosh兼容很好。
• 5.互动模式：互动模式的支持，您可以从终端输入执行代码并获得结果的语言，互动的测试和调试代码片断。
• 6.可移植：基于其开放源代码的特性，Python已经被移植（也就是使其工作）到许多平台。
• 7.可扩展：如果你需要一段运行很快的关键代码，或者是想要编写一些不愿开放的算法，你可以使用C或C++完成那部分程序，然后从你的Python程序中调用。
• 8.数据库：Python提供所有主要的商业数据库的接口。
• 9.GUI编程：Python支持GUI可以创建和移植到许多系统调用。
• 10.可嵌入: 你可以将Python嵌入到C/C++程序，让你的程序的用户获得"脚本化"的能力。

Python 应用

• 网站建设，以下网站应用了python进行web开发：
• Youtube - 视频社交网站
• Reddit - 社交分享网站
• Dropbox - 文件分享服务
• 豆瓣网 - 图书、唱片、电影等文化产品的资料数据库网站
• 知乎 - 一个问答网站
• 果壳 - 一个泛科技主题网站
• Bottle - Python微Web框架
• EVE - 网络游戏EVE大量使用Python进行开发
• Blender - 使用Python作为建模工具与GUI语言的开源3D绘图软件
• Inkscape - 一个开源的SVG矢量图形编辑器。
• 机器学习与人工智能 - TensorFlow，Keras，pytorch等机器学习库让python成为最适合机器学习的语言
• 数据分析与数据挖掘 - 各式各样的python爬虫可以帮助数据分析工程师获取数据，而丰富的python数据处理库可以处理这些数据并以可视化形式或者可调用形式展现出来
• 科学计算和算法设计 - 曾经matlab作为科学计算的行业标杆，但现在python正在蚕食它的市场。而简单的语法让python更适合进行算法开发（算法工程师可以轻松上手算法开发）
• IDLE - 作为python安装时自带的IDE，这款IDE就是由 Guido van Rossum 使用python+tkinter写出来的。
• ···

python的缺点

有优点就会有缺点，python作为一门解释型语言，拥有了解释型语言的优点（跨平台可移植性，动态变量等）也有解释型语言的缺点（效率较低）。另外，python作为一门近乎万能的语言，就像瑞士军刀一样，他拥有很多功能，但在具体的功能上都不如一些专精的语言，当对性能有一定要求的时候，python不是好选择！

本章节将向大家介绍 Python 最新版开发环境的安装步骤及如何进行环境配置，刚入门的新手学员可以跟着本章内容进行学习。

本章节需要用到的Python 最新源码，二进制文档，新闻资讯等可以在 Python 的官网查看：

• Python 官网：https://www.python.org/

你可以在以下链接中下载 Python 的文档，你可以下载 HTML、PDF 和 PostScript 等格式的文档。

• Python 文档下载地址：https://www.python.org/doc/

Python 安装

• Python 已经被移植在许多平台上（经过改动使它能够工作在不同平台上）。
• 您需要下载适用于您使用平台的二进制代码，然后安装 Python。
• 如果您平台的二进制代码是不可用的，你需要使用 C 编译器手动编译源代码。
• 编译的源代码，功能上有更多的选择性， 为 Python 安装提供了更多的灵活性。

以下为不同平台上安装 Python 的方法：

Unix & Linux 平台安装 Python:

以下为在 Unix & Linux 平台上安装 Python 的简单步骤：

• 打开 WEB 浏览器访问 https://www.python.org/downloads/source/
• 选择适用于 Unix/Linux 的源码压缩包。
• 下载及解压压缩包 Python-3.x.x.tgz，3.x.x 为你下载的对应版本号。
• 如果你需要自定义一些选项修改 Modules/Setup

以 Python3.8.5 版本为例：

# tar -zxvf Python-3.8.5.tgz# cd Python-3.8.5# ./configure# make && make install

检查 Python3 是否正常可用：

# python3 -VPython 3.8.5

python作为Linux系统的一个依赖，很多Linux系统都会默认安装python环境（甚至误删python环境会导致系统崩溃），在很长一段时间里，很多Linux系统都默认安装了python2，这时候学习python3就需要安装新版本的python3，而且由于Linux系统依赖的是python2，所以python2版本不能卸载。但随着python2停止维护结束了他的使命，大多数Linux系统已经更新到了python3版本，如果对python3的小版本没有特殊要求的话，最新的Linux系统基本可以做到不需要安装即可使用python环境（小编之前安装的centos 8内置的python版本为3.6.8，已经能基本满足普通的python学习需求了）。

Windows 平台安装 Python:

以下为在 Windows 平台上安装 Python 的简单步骤：

• 打开 WEB 浏览器访问https://www.python.org/downloads/windows/
                    
  
• 在下载列表中选择 Windows 平台安装包，包格式为：python-3.8.5-amd64.exe 文件 ， -3.8.5 为你要安装的版本号，-amd64为你系统的版本。
• 下载后，双击下载包，进入 Python 安装向导，安装非常简单，你只需要使用默认的设置一直点击"下一步"直到安装完成即可。

Windows x86-64 为 64 位版本

Windows x86 为 32 位版本

自python3.9起，官方不再支持在win7及以下版本安装和运行python，但我们仍可通过编译源代码的形式来给win7安装更高版本的python。

MAC 平台安装 Python:

MAC 系统一般都自带有 Python2.7 版本 的环境，你也可以在链接 https://www.python.org/downloads/mac-osx/ 上下载最新版安装。

环境变量配置

• 程序和可执行文件可以在许多目录，而这些路径很可能不在操作系统提供可执行文件的搜索路径中。
• path (路径)存储在环境变量中，这是由操作系统维护的一个命名的字符串。这些变量包含可用的命令行解释器和其他程序的信息。
• Unix 或 Windows 中路径变量为 PATH（UNIX 区分大小写，Windows 不区分大小写）。
• 在 Mac OS 中，安装程序过程中改变了 python 的安装路径。如果你需要在其他目录引用 Python，你必须在 path 中添加 Python 目录。

 简单地说，​python​这个指令（还记得上一节介绍的​python -v​嘛，这就是python指令）在系统中是不存在的，安装完python后就有了python这个指令，但我们需要告诉系统，在哪里可以找到python这个指令，而path路径变量，就是起到这样一个作用。

在 Unix/Linux 设置环境变量

• 在 csh shell: 输入 

  setenv PATH "$PATH:/51coolma/local/bin/python"

  按下 Enter。
• 在 bash shell (Linux) 输入 :
  

  export PATH="$PATH:/51coolma/local/bin/python" 

  按下 Enter 。
• 在 sh 或者 ksh shell 输入: 

  PATH="$PATH:/51coolma/local/bin/python"

  按下 Enter。

注意: /51coolma/local/bin/python 是 Python 的安装目录。

在 Windows 设置环境变量

 注意！在python安装的时候勾选自动添加python到path路径可可以免去配置环境这个过程，本教程介绍的是当在命令提示符中输入python显示指令不存在的情况下需要进行的操作。

在环境变量中添加 Python 目录：

在命令提示符中(cmd) : 输入

path=%path%;C:Python 

按下"Enter"。

注意: C:Python 是 Python 的安装目录。

也可以通过以下方式设置：

• 右键点击"计算机"，然后点击"属性"
• 然后点击"高级系统设置"
• 选择"系统变量"窗口下面的"Path",双击即可！
• 然后在"​Path​"行，添加 python 安装路径即可(我的D:Python32)，所以在后面，添加该路径即可。 ps：记住，路径直接用分号"​;​"隔开！
• 最后设置成功以后，在 cmd 命令行，输入命令"​python​"，就可以有相关显示。

在win10中配置环境变量与win7类似：

在电脑桌面右键点击此电脑，点击属性选项。

在关于页面中选择高级系统设置，点击环境变量进行环境变量的配置。

只需在 PATH 变量原有的变量上新增以下变量值即可：

Python 的安装文件夹。

python 安装文件夹下的 Scripts 文件夹。

 注意！添加python路径是为了配置python指令，使得python指令可以使用，而配置script文件夹则是为了配置pip指令（一个python包管理工具）。

另外，在安装python的时候如果有勾选添加环境变量的话（下图 add python 3.9 to path），默认会将环境变量配置完毕。

Python 环境变量

下面几个重要的环境变量，它应用于 Python：

运行Python

有三种方式可以运行 Python：

1. 交互式解释器：

• 你可以通过命令行窗口进入 Python，并在交互式解释器中开始编写 Python 代码。
• 你可以在 Unix、DOS 或任何其他提供了命令行或者 shell 的系统进行 Python 编码工作。

$ python # Unix/Linux

或者

C:>python # Windows/DOS

以下为Python命令行参数：

2. 命令行脚本

在你的应用程序中通过引入解释器可以在命令行中执行 Python 脚本，如下所示：

$ python script.py # Unix/Linux

或者

C:>python script.py # Windows/DOS

注意：在执行脚本时，请检查脚本是否有可执行权限。

3. 集成开发环境（IDE：Integrated Development Environment）: PyCharm

• PyCharm 是由 JetBrains 打造的一款 Python IDE，支持 macOS、 Windows、 Linux 系统。
• PyCharm 功能 : 调试、语法高亮、Project管理、代码跳转、智能提示、自动完成、单元测试、版本控制等
• PyCharm 下载地址 : https://www.jetbrains.com/pycharm/download/
• PyCharm 安装教程地址 :https://www.51coolma.cn/python3/python3-l4i738c3.html
• Python IDE 安装教程地址：https://www.51coolma.cn/python/python-ide.html

领取免费资料

扫描下方二维码或打开微信搜一搜“51coolma编程狮”关注公众号回复关键词【Python123】或者【Python资料包】免费领取 Python 学习资料，包含软件安装包，电子书、思维导图等

python软件介绍

python安装完后，在开始菜单会有如下的一个文件夹：

他们分别是：

• IDLE：由python之父开发的一个小型的python开发环境，可以用来解释执行python代码，也可以用来写python脚本。
• Python：这个就是python的解释器，可以用来解释执行python代码，使用命令行调用python命令的时候就是运行的这个程序。
• Python Manuals：这个是python的使用手册，可以用来学习python的基础使用。
• Python Module Docs：这个是python的模块文档，可以用来学习模块的使用。

python代码执行方式

python代码的执行方式有两种，一种是交互型的解释执行方式，另一种是将python写成脚本代码的形式，然后使用解释器执行，两种执行方式有所不同：

交互型执行方式

这种执行方式类似人与人之间的对话，写一句代码执行一句代码。这种类型类似人的交互行为，所以被称为交互执行方式，使用这种交互方式最大的特点是：在命令行界面中有​>>>​作为每行代码的开头。如下图所示：

接下来本手册中的代码只要是带有>>>的都是在交互型解释器中运行后的结果，没有>>>的代码都是python脚本代码。

进入交互型解释器的方式有如下几种方式：

• 命令行方式：按win + r键，输入cmd，点击回车，进入命令行界面，然后输入python，点击回车，即可进入命令行界面，在命令行中输入python并按回车执行，即可进入命令行界面。
• 运行方式：按win + r键，输入python，点击回车，即可直接进入python解释器页面。
• 直接运行程序：安装的python中里面有一个选项是python，直接点击这个选项就可以进入python解释器。
• IDLE：安装的python中里面有一个选项是IDLE，直接点击后进入的也是python解释器。

交互型编程在代码调试中比较常见，更好的交互型编程的体验可以了解ipython或者jupyter notebook。

如何退出？

在交互型解释器中输入​exit()​按回车即可退出。

如何换行&缩进？

python以换行作为代码结束的标志（也就是说，点击换行立马执行这个代码），但这并不是绝对的，当代码的最后一个标识符是​:​时可以换行（因为出现​:​的时候都是进入代码块的情况，比如条件语句，循环语句，函数等）。

python以缩进来区分代码块，所以在出现上述的换行情况的时候，需要搭配空格键（注意，不是Tab键！）来进行代码缩进（使用空格数并不强制，但同一代码块之间的缩进应该相同）。处于代码块内时，​>>>​会变成​...​。如下代码所示：

>>>the_world_is_flat = True>>>if the_world_is_flat:...    print("Be careful not to fall off!")...Be careful not to fall off!

在代码块需要结束的地方，换行后点击回车即可。

所以上面的代码的输入方式应该是这样的：输入第一行语句，点击回车，输入第二行语句（注意末尾的冒号），点击回车，输入四个空格，输入第三行语句（该语句是代码块内的语句），回车，回车（结束这个代码块）。最后一行是代码运行结果。

 在交互型解释器中，代码如果会产生输出，会直接打印在控制台，输出和代码的区别是：代码前面有​>>>​。

脚本代码执行方式

这种方式是大多数编程语言执行方式（先写代码，然后一次执行），如果把代码解释比喻为做菜的话，交互型解释方式类似于看一个步骤做一个步骤，而脚本代码执行方式则是看完全部步骤后再逐步做。这种方式也是未来我们学习python编程中最常遇到的编程方式。

 不同工具（IDE）的编程方式不同，这里小编放到下一节介绍，这里我们介绍一下IDLE的脚本代码编写方式。

点击打开IDLE，我们可以进入到python的shell（命令行，也就是交互型解释器）界面，点击File，选择New File。可以新建一个脚本代码文件（也可以使用Ctrl + N 进行新建脚本代码文件）。就会弹出一个窗口，这时候我们就可以在这个窗口里面写python代码了。

 虽然IDLE相对比较简单，但它也提供了代码着色等实用的功能，如果没有什么很好的python代码编辑器，不妨尝试一下它！

写完代码后可点击run，选择run module（或者直接按F5），就可以运行代码了。

初次运行需要先保存代码并给代码文件命名，后续代码更改也要重新保存代码。

另外，IDLE也可以打开以​.py​为后缀的文件，与新建类似，点击File，选择Open...，可以打开本地的python代码文件（py代码文件以​.py​为后缀）。运行方式与新建方式相同。

 这意味着python可以使用其他的代码编辑器进行代码编写，再使用IDLE去运行，但是实际上我们不会这么做，因为执行python代码不一定要用IDLE，使用python命令也可以。这为我们使用vscode这样的代码编辑器去写代码然后使用命令行运行提供了一种可能，而vscode的插件把这样的功能实现了。在后续章节中我们将介绍如何使vscode来写python代码。

如何使用命令行运行python脚本？

在命令提示符中使用python命令就可以运行python脚本了，python命令的使用方法如下：

​python 要运行的文件.py​

示例：

Q&A

什么是命令行？

命令行是系统提供的一种工具，可以用这些工具来执行一些系统提供的功能，常见的命令行有：Linux的终端，Windows的cmd，windows的powershell（进阶版的cmd）。

命令行在一些工具中也存在，比如说vscode就提供了命令行窗口，python著名的IDEpycharm也有提供命令行窗口和交互型解释器的窗口。

 powershell作为微软用来替代老旧的cmd的终端，powershell拥有更强大的功能，所有在cmd上可以实现的指令在powershell上都可以实现。找不到命令提示符（或者想要尝试新事物）的小伙伴可以尝试使用。

Linux/Unix 的系统上，Python 解释器通常被安装在 /usr/local/python3 这样的有效路径（目录）里。

我们可以将路径 /usr/local/python3/bin 添加到您的 Linux/Unix 操作系统的环境变量中(最好参照您 Python 的安装路径进行添加)，这样您就可以通过 shell 终端输入下面的命令来启动 Python 。

$ PATH=$PATH:/user/local/python3/bin/python #设置环境变量$ python3 --vesionPython 3.7.6

在 Window 系统下你可以通过以下命令来设置 Python 的环境变量，假设你的 Python 安装在 C:Python37 下:

set path=%path%;C:python37

交互式编程

打开 IDLE，默认的就是交互式编程，类似于一个 cmd 窗口。

我们可以在命令提示符中输入 "Python" 命令来启动 Python 解释器：

$ python3

执行以上命令后，出现如下窗口信息：

$ python3Python 3.4。0 (default, Mar 16 2014, 09:25:04)[GCC 4.8.2] on linuxType "help", "copyright", "credits" or "license" for more information.>>>

在 Python 提示符中输入以下语句，然后按回车键查看运行效果：

print ("Welcome to W3Cschool!");

以上命令执行结果如下：

当键入一个多行结构时，续行是必须的。我们可以看下如下 if 语句：

>>> the_world_is_flat = True>>> if the_world_is_flat:...     print("Be careful not to fall off!")...Be careful not to fall off!

脚本式编程

点击 File→New 后新建脚本文件，在此文件下进行的是脚本式编程。

将如下代码拷贝至 W3C.py 文件中：

print ("Welcome to W3Cschool!");

通过以下命令执行该脚本：

python W3C.py

输出结果为：

Welcome to W3Cschool!

在 Linux/Unix 系统中，你可以在脚本顶部添加以下命令让 Python 脚本可以像 SHELL 脚本一样可直接执行：

#! /usr/bin/env python3.7

然后修改脚本权限，使其有执行权限，命令如下：

$ chmod +x W3C.py

执行以下命令：

./hello.py

输出结果为：

Welcome to W3Cschool!

VSCode（全称：Visual Studio Code）是一款由微软开发的跨平台免费源代码编辑器。VSCode 开发环境非常简单易用，仅需要安装相关的插件进行简易的配置就可以与原有的python环境组成一套具有简单的代码调试运行的开发工具。对于轻量级的python开发和python学习是比较友好的。优秀的代码提示和更多插件功能让VSCode的使用体验不亚于知名pythonIDE—pycharm。

准备工作：

• 安装 Python 3

• 安装 VS Code
• 安装 VS Code Python 扩展和Pylance拓展

安装 VS Code

VSCode 安装比较简单，打开官网 https://code.visualstudio.com/，下载软件包，一步步安装即可，安装过程注意安装路径设置、环境变量默认自动添加到系统中，勾选以下所有选项：

安装 VS Code Python 扩展和Pylance拓展

接着我们安装 VS Code Python 扩展：

Python扩展将自动安装Pylance和Jupyter扩展，以便在使用Python文件和Jupyter笔记本时获得最佳体验。

创建一个 Python 代码文件

打开 VScode，然后点击新建文件：

点击选择语言：

在搜索框输入 Python，选中 Python 选项：

输入代码：

print("W3Cschool")

右击鼠标，选择在交互式窗口运行文件，如果有提示需要安装内核，直接点安装即可(没有安装会一直显示在连接 Python 内核)：（这里VSCode会使用python的pip进行安装，部分版本会安装失败，小编在尝试的时候使用python3.8版本失败了，3.7版本成功了）

另外，我们也可以打开一个已存在的文件或目录（文件夹），比如我们打开一个 pythonproject，你也可以自己创建一个：

然后我们创建一个 test.py 文件，点击下面新建文件图标，输入文件名 test.py：

注：pythonproject 里面包含了一个 .vscode 文件夹，是一些配置信息，可以先不用管。

在 test.py 输入以下代码：

print("W3Cschool")

点击右上角绿色图标，即可运行：

可以右击文件，选择"在终端中运行 Python 文件"：

当然也可以在代码窗口上右击鼠标，选择"在终端中运行 Python 文件"。

本章节将一些Python3基础语法整理成手册，方便各位在日常使用和学习时查阅，包含了编码、标识符、保留字、注释、缩进、字符串等常用内容。

注意，这部分内容是后续学习的一个基础和预览，请不要随意跳过这个章节的学习！

编码

默认情况下，Python 3 源码文件以 UTF-8 编码，所有字符串都是 unicode 字符串。 当然你也可以为源码文件指定不同的编码：

# -*- coding: cp-1252 -*-

标识符

• 第一个字符必须是字母表中字母或下划线'_'。
• 标识符的其他的部分有字母、数字和下划线组成。
• 标识符对大小写敏感。

在 Python 3中，非 ASCII 编码的标识符也是允许的了。

Python 保留字

保留字即关键字，我们不能把它们用作任何标识符名称。Python 的标准库提供了一个关键词模块，我们可以使用它来查看当前版本的所有保留字：

>>> import keyword>>> keyword.kwlist
['False', 'None', 'True', '__peg_parser__', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

上面代码是在解释器执行的结果，写成python脚本代码应该写成如下样式（后续代码可能会有两种版本的代码块，但并不会多做解释，望读者周知！）：

import keywordprint(keyword.kwlist)

注释

Python 中单行注释以 # 开头，多行注释采用三对单引号（'''）或者三对双引号（"""）将注释括起来。

#这是单行注释"""这是多行注释这是多行注释"""'''也可以用三个单引号来进行多行注释'''

实际上python注释只有一种，就是单行注释，多行注释的这种使用方法类似于java的javadoc，三引号的这种使用方法实际上是用来声明多行长字符串的。

缩进

Python 最具特色的就是使用缩进来表示代码块。缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数。

标准数据类型

Python 中有六个标准的数据类型：

• Number（数字）
• String（字符串）
• List（列表）
• Tuple（元组）
• Set（集合）
• Dictionary（字典）

Python3 的六个标准数据类型中：

• 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
• 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

 可变数据和不可变数据是相对于引用地址来说的，不可变数据类型不允许变量的值发生变化，如果改变了的变量的值，相当于新建了一个对象，而对于相同的值的对象，内部会有一个引用计数来记录有多少个变量引用了这个对象。可变数据类型允许变量的值发生变化。对变量进行修改操作只会改变变量的值，不会新建对象，变量引用的地址也不会发生变化，不过对于相同的值的不同对象，在内存中则会存在不同的对象，即每个对象都有自己的地址，相当于内存中对于同值的对象保存了多份，这里不存在引用计数，是实实在在的对象。

简单地讲，可变数据和不可变数据的“变”是相对于引用地址来说的，不是不能改变其数据，而是改变数据的时候会不会改变变量的引用地址。

类型判断

python可以用type函数来检查一个变量的类型，使用方法如下：

>>> x = "W3Cschool">>> type(x)<type 'str'>>>> x=100>>> type(x)<type 'int'>>>> x=('1','2','3')>>> type(x)<type 'tuple'>>>> x = ['1','2','3']>>> type(x)<type 'list'>

在脚本代码中的使用：

x = "W3Cschool"print(type(x))

字符串

• Python 中单引号和双引号使用完全相同，但单引号和双引号不能匹配。
• 使用三对引号('''或""")可以囊括一个多行字符串。
• 与其他语言相似，python也使用 ''作为转义字符
• 自然字符串， 通过在字符串前加 r 或 R。 如 r"this is a line with " 则 会显示，并不是换行。
• Python 允许处理 unicode 字符串，加前缀 u 或 U， 如 u"this is an unicode string"。
• 字符串是不可变的。
• 按字面意义级联字符串，如"this " "is " "string"会被自动转换为this is string。
• 字符串可以用 + 运算符连接在一起，用 * 运算符重复。
• Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。
• Python中的字符串不能改变（详见上一小点的引用）。
• Python 没有单独的字符类型，一个字符就是长度为 1 的字符串。
• 字符串的截取的语法格式如下：变量 [头下标: 尾下标: 步长]

 关于字符串的更多内容，请前往字符串小节进行学习。

word = '字符串'sentence = "这是一个句子。"paragraph = """这是一个段落，可以由多行组成"""

实例：

#!/usr/bin/python3 str='W3Cschool' print(str)                 # 输出字符串print(str[0:-1])           # 输出第一个到倒数第二个的所有字符print(str[0])              # 输出字符串第一个字符print(str[2:5])            # 输出从第三个开始到第五个的字符print(str[2:])             # 输出从第三个开始后的所有字符print(str[1:5:2])          # 输出从第二个开始到第五个且每隔两个的字符print(str * 2)             # 输出字符串两次print(str + '你好')         # 连接字符串 print('------------------------------') print('hello
W3Cschool')      # 使用反斜杠()+n转义特殊字符print(r'hello
W3Cschool')     # 在字符串前面添加一个 r，表示原始字符串，不会发生转义

以上实例输出结果：

W3CschoolW3CschooWCscCschool3sW3CschoolW3CschoolW3Cschool你好------------------------------helloW3Cschoolhello
W3Cschool

这里的 r 指 raw，即 raw string，会自动将反斜杠转义，例如：

>>> print('
')       # 输出空行>>> print(r'
')      # 输出 
>>>

空行

函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用两行空行分隔，以突出函数入口的开始。

空行与代码缩进不同，空行并不是 Python 语法的一部分。书写时不插入空行，Python 解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码，便于日后代码的维护或重构。

记住：空行也是程序代码的一部分。

 在PEP8中介绍了一些python代码的格式，其中介绍了函数之间要有两行空行，如果python代码没有使用两行空行的话，部分IDE会出现修改提示（比如pycharm）。这样的代码不影响运行，但对于代码阅读不利，

输入&等待用户输入

input函数可以用来接受输入，它可以传入一个字符串，当input函数调用的时候，会在控制台打印这个字符串（所以这个字符串通常被用来做输入的提示信息）。

 input函数会读取输入内容直到读到回车，也就是说，内容输入完毕后要按回车键才能执行。

input("这是一个简单的input信息") # 这是一个简单的input样例，他输出input信息并接受一个字符串x=input("请输入X的值：") # 这是一个常见的input样例，他输出提示信息，然后接受一个字符串并将值传递给一个变量Xprint(x) # 打印变量，可以看到输入的x的值print(type(x)) #查看这个变量的类型x = int(input("请输入一个数值：")) # 配合强制类型转换，可以将字符串转变为int类型（字符串类型不能参与计算）# 也可以分步写成：#x=input("请输入一个数值：") # 接受一个字符串#x=int(x)   #将x转换为int型# 这里强制转换也可以转换为其他类型，详细的转换方法请参考基本数据类型的强制转换相关内容print(x) # 打印变量，可以看到输入的x的值print(type(x)) #查看这个变量的类型input("

按下 enter 键后退出。") # 其实这里并没有接受任何内容，input函数以enter作为结尾，所以只有输入回车后才会结束input函数

以上代码中 ，" "在结果输出前会输出两个新的空行。一旦用户按下 enter 键时，程序将退出。

同一行显示多条语句

Python 可以在同一行中使用多条语句，语句之间使用分号 (;) 分割，以下是一个简单的实例：

实例:

#!/usr/bin/python3 import sys; x = 'W3Cschool'; sys.stdout.write(x + '
')

使用脚本执行以上代码，输出结果为：

W3Cschool

使用交互式命令行执行，输出结果为：

>>> import sys; x = 'W3Cschool'; sys.stdout.write(x + '
')
W3Cschool
10

此处的 10 表示字符数。

 python以回车作为语句结束的标志，一行一句语句的特色使得Python更加易读，而在一行中显示多条语句的这种行为会破坏python的可读性，不建议使用！

多个语句构成代码组

缩进相同的一组语句构成一个代码块，我们称之代码组。

像 if、while、def 和 class 这样的复合语句，首行以关键字开始，以冒号 ( : ) 结束，该行之后的一行或多行代码构成代码组。

我们将首行及后面的代码组称为一个子句 (clause)。

如下实例：

if expression : 
    suite
elif expression : 
    suite 
else : 
    suite

print 输出

print函数是python的基本输出函数，他可以将变量输出（或者说，打印）到控制台。在第一个python程序中，我们就用到了print函数：

#!/usr/bin/python3print("Hello, World!") #"Hello,World!"是一个字符串变量str = "Hello,World!"print(str) #上一种helloworld的另一种写法

print 默认输出是换行的，如果要实现不换行需要在变量末尾加上 end=""：

实例:

#!/usr/bin/python3 x="a"y="b"# 换行输出print( x )print( y ) print('---------')# 不换行输出print( x, end=" " )print( y, end=" " )print()

以上实例执行结果为：

a
b
---------
a b

关于print的内容，本章只是粗略介绍，目的是为了能够基础使用print函数。后续章节中有print函数的详细介绍。

import 与 from...import

在 Python 用 import 或者 from...import 来导入相应的模块。

将整个模块 (somemodule) 导入，格式为：​ import somemodule​

从某个模块中导入某个函数,格式为：​ from somemodule import somefunction​

从某个模块中导入多个函数,格式为：​ from somemodule import firstfunc, secondfunc, thirdfunc​

将某个模块中的全部函数导入，格式为：​ from somemodule import *​

导入 sys 模块

import sysprint('================Python import mode==========================')print ('命令行参数为:')for i in sys.argv:    print (i)print ('
 python 路径为',sys.path)

导入 sys 模块的 argv,path 成员

from sys import argv,path  #  导入特定的成员 print('================python from import===================================')print('path:',path) # 因为已经导入path成员，所以此处引用时不需要加sys.path

命令行参数

很多程序可以执行一些操作来查看一些基本信息，Python 可以使用 -h 参数查看各参数帮助信息：

$ python -h
usage: python [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 完成比 ​2+2​ 更复杂的工作。在下例里，我们能写出一个初步的斐波纳契数列如下：

#!/usr/bin/python3# Fibonacci series: 斐波纳契数列# 两个元素的总和确定了下一个数a, b = 0, 1while b < 10:    print(b)    a, b = b, a+b

有关斐波那契数列的具体问题可在 斐波纳契奇数求和算法挑战 教程中进一步了解。

其中代码​ a, b = b, a + b​ 的计算方式为先计算右边的表达式，然后同时赋值给左边，等价于：

n = bm = a + ba = nb = m

执行以上程序，输出结果为：

112358

这个例子介绍了几个新特征。

• 第一行包含了一个复合赋值：变量 a 和 b 同时得到新值 0 和 1。
• 最后一行也使用了复合赋值的方法：等价于 c = a，a = b，b = b + c。

接下来尝试输出变量值：

i = 1024 * 1024print('i 的值为：', i)

执行以上程序，输出结果为：

i 的值为： 1048576

end 关键字

关键字 end 可以用于将结果输出到同一行，或者在输出的末尾添加不同的字符，实例如下：

# 两个元素的总和确定了下一个数a, b = 0, 1while b < 1024:    print(b, end=',')    a, b = b, a+b

执行以上程序，输出结果为：

1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,

最后尝试使用 if 条件控制  

age = int(input("请输入你家狗狗的年龄: "))print("")if age < 0:	print("请输入正确的年龄。")elif age == 1:	print("相当于 14 岁的人。")elif age == 2:	print("相当于 22 岁的人。")elif age > 2:	human = 22 + (age -2)*5	print("对应人类年龄: ", human)### 退出提示，本地环境下可以使用这样的退出提示使代码更易用input('点击 enter 键退出')

在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。

Python 3 中有六个标准的数据类型：

• Numbers（数字）
• String（字符串）
• List（列表）
• Tuple（元组）
• Sets（集合）
• Dictionaries（字典）

Numbers（数字）

Python 3 支持 int（整型）、float（浮点型）、bool（布尔型）、complex（复数）。

数值类型的赋值和计算都是很直观的，就像大多数语言一样。内置的 type() 函数可以用来查询变量所指的对象类型。

>>> a, b, c, d = 20, 5.5, True, 4+3j>>> print(type(a), type(b), type(c), type(d))<class 'int'><class 'float'><class 'bool'><class 'complex'>

此外还可以用isinstance来判断：

>>>a=111>>>isinstance(a,int)True>>>

isinstance和type的区别在于：

• type（）不会认为子类是一种父类类型。
• isinstance（）会认为子类是一种父类类型。

>>> class A:...     pass... >>> class B(A):...     pass... >>> isinstance(A(), A)True>>> type(A()) == A True>>> isinstance(B(), A)True>>> type(B()) == AFalse

注意：在 Python2 中是没有布尔型的，它用数字 0 表示 False，用 1 表示 True。到 Python3 中，把 True 和 False 定义成关键字了，但它们的值还是 1 和 0，它们可以和数字相加。

当你指定一个值时，Number 对象就会被创建：

var1 = 1var2 = 10

您也可以使用 del 语句删除一些对象引用。

del 语句的语法是：

del var1[,var2[,var3[....,varN]]]

您可以通过使用 del 语句删除单个或多个对象。例如：

del vardel var_a, var_b

数值运算：

>>> 5 + 4  # 加法9>>> 4.3 - 2 # 减法2.3>>> 3 * 7  # 乘法21>>> 2 / 4  # 除法，得到一个浮点数0.5>>> 2 // 4 # 除法，得到一个整数0>>> 17 % 3 # 取余 2>>> 2 ** 5 # 乘方32

注意：

• 1、Python 可以同时为多个变量赋值，如 a, b = 1, 2。
• 2、一个变量可以通过赋值指向不同类型的对象。
• 3、数值的除法（/）总是返回一个浮点数，要获取整数使用​//​操作符。
• 4、在混合计算时，Python 会把整型转换成为浮点数。

String（字符串）

Python 中的字符串 str 用单引号(' ')或双引号 (" ") 括起来，同时使用反斜杠 () 转义特殊字符。

>>> s = 'Yes,he doesn't'>>> print(s, type(s), len(s))Yes,he doesn't  <class 'str'> 14

如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串：

>>> print('C:some
ame')C:someame>>> print(r'C:some
ame')C:some
ame

另外，反斜杠可以作为续行符，表示下一行是上一行的延续。还可以使用"""..."""或者'''...'''跨越多行。

字符串可以使用 + 运算符串连接在一起，或者用 * 运算符重复：

>>> print('str'+'ing', 'my'*3)string mymymy

Python 中的字符串有两种索引方式，第一种是从左往右，从 0 开始依次增加；第二种是从右往左，从 -1 开始依次减少。

注意，没有单独的字符类型，一个字符就是长度为 1 的字符串。

>>> word = 'Python'>>> print(word[0], word[5])P n>>> print(word[-1], word[-6])n P

还可以对字符串进行切片，获取一段子串。用冒号分隔两个索引，形式为变量[头下标:尾下标]。

截取的范围是前闭后开的（头下标取，尾下标不取），并且两个索引都可以省略：

>>> word = 'ilovepython'>>> word[1:5]'love'>>> word[:]'ilovepython'>>> word[5:]'python'>>> word[-10:-6]'love'

与 C 字符串不同的是，Python 字符串不能被改变。向一个索引位置赋值，比如 word[0] = 'm' 会导致错误。

注意：

• 1、反斜杠可以用来转义，使用 r 可以让反斜杠不发生转义。
• 2、字符串可以用 + 运算符连接在一起，用 * 运算符重复。
• 3、Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。
• 4、Python 中的字符串不能改变。

List（列表）

List（列表） 是 Python 中使用最频繁的数据类型。

列表是写在方括号之间、用逗号分隔开的元素列表。列表中元素的类型可以不相同：

>>> a = ['him', 25, 100, 'her']>>> print(a)['him', 25, 100, 'her']

和字符串一样，列表同样可以被索引和切片，列表被切片后返回一个包含所需元素的新列表。详细的在这里就不赘述了。

列表还支持串联操作，使用 + 操作符：

>>> a = [1, 2, 3, 4, 5]>>> a + [6, 7, 8][1, 2, 3, 4, 5, 6, 7, 8]

与 Python 字符串不一样的是，列表中的元素是可以改变的：

>>> a = [1, 2, 3, 4, 5, 6]>>> a[0] = 9>>> a[2:5] = [13, 14, 15]>>> a[9, 2, 13, 14, 15, 6]>>> a[2:5] = []   # 删除>>> a[9, 2, 6]

List 内置了有很多方法，例如 append()、pop() 等等，这在后面会讲到。

注意：

• 1、List 写在方括号之间，元素用逗号隔开。
• 2、和字符串一样，List 可以被索引和切片。
• 3、List 可以使用 + 操作符进行拼接。
• 4、List 中的元素是可以改变的。

Tuple（元组）

元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号里，元素之间用逗号隔开。

元组中的元素类型也可以不相同：

>>> a = (1991, 2014, 'physics', 'math')>>> print(a, type(a), len(a))(1991, 2014, 'physics', 'math') <class 'tuple'> 4

元组与字符串类似，可以被索引且下标索引从 0 开始，也可以进行截取/切片（看上面，这里不再赘述）。

其实，可以把字符串看作一种特殊的元组。

>>> tup = (1, 2, 3, 4, 5, 6)>>> print(tup[0], tup[1:5])1 (2, 3, 4, 5)>>> tup[0] = 11  # 修改元组元素的操作是非法的

虽然 tuple 的元素不可改变，但它可以包含可变的对象，比如 list 列表。

构造包含 0 个或 1 个元素的 tuple 是个特殊的问题，所以有一些额外的语法规则：

tup1 = () # 空元组tup2 = (20,) # 一个元素，需要在元素后添加逗号

另外，元组也支持用 + 操作符：

>>> tup1, tup2 = (1, 2, 3), (4, 5, 6)>>> print(tup1+tup2)(1, 2, 3, 4, 5, 6)

string、list 和 tuple 都属于 sequence（序列）。

注意：

• 1、与字符串一样，元组的元素不能修改。
• 2、元组也可以被索引和切片，方法都是一样的。
• 3、注意构造包含 0 或 1 个元素的元组的特殊语法规则。
• 4、元组也可以使用 + 操作符进行拼接。

Sets（集合）

集合（set）是一个无序不重复元素的集。

基本功能是进行成员关系测试和消除重复元素。

可以使用大括号 或者 set() 函数创建 set 集合，注意：创建一个空集合必须用 set() 而不是 { }，因为{ }是用来创建一个空字典。

>>> student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}>>> print(student)   # 重复的元素被自动去掉{'Jim', 'Jack', 'Mary', 'Tom', 'Rose'}>>> 'Rose' in student  # membership testing（成员测试）True>>> # set可以进行集合运算... >>> a = set('abracadabra')>>> b = set('alacazam')>>> a{'a', 'b', 'c', 'd', 'r'}>>> a - b     # a和b的差集{'b', 'd', 'r'}>>> a | b     # a和b的并集{'l', 'm', 'a', 'b', 'c', 'd', 'z', 'r'}>>> a & b     # a和b的交集{'a', 'c'}>>> a ^ b     # a和b中不同时存在的元素{'l', 'm', 'b', 'd', 'z', 'r'}

Dictionaries（字典）

字典（dictionary）是 Python 中另一个非常有用的内置数据类型。

字典是一种映射类型（mapping type），它是一个无序的键值对（key-value）集合。

关键字（key）必须使用不可变类型，也就是说list和包含可变类型的 tuple 不能做关键字。

在同一个字典中，关键字（key）必须互不相同。

>>> dic = {}  # 创建空字典>>> tel = {'Jack':1557, 'Tom':1320, 'Rose':1886}>>> tel{'Tom': 1320, 'Jack': 1557, 'Rose': 1886}>>> tel['Jack']   # 主要的操作：通过key查询1557>>> del tel['Rose']  # 删除一个键值对>>> tel['Mary'] = 4127  # 添加一个键值对>>> tel{'Tom': 1320, 'Jack': 1557, 'Mary': 4127}>>> list(tel.keys())  # 返回所有key组成的list['Tom', 'Jack', 'Mary']>>> sorted(tel.keys()) # 按key排序['Jack', 'Mary', 'Tom']>>> 'Tom' in tel       # 成员测试True>>> 'Mary' not in tel  # 成员测试False

构造函数 dict() 直接从键值对 sequence 中构建字典，当然也可以进行推导，如下：

>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)]){'jack': 4098, 'sape': 4139, 'guido': 4127}>>> {x: x**2 for x in (2, 4, 6)}{2: 4, 4: 16, 6: 36}>>> dict(sape=4139, guido=4127, jack=4098){'jack': 4098, 'sape': 4139, 'guido': 4127}

另外，字典类型也有一些内置的函数，例如 clear()、keys()、values() 等。

注意：

• 1、字典是一种映射类型，它的元素是键值对。
• 2、字典的关键字必须为不可变类型，且不能重复。
• 3、创建空字典使用 { }。

Python3注释可以确保对模块, 函数, 方法和行内注释使用正确的风格，有专门的符号和格式，有单行与多行的区别。

Python 中的注释有单行注释和多行注释：

Python 中单行注释以 # 开头，例如：

#!/usr/bin/python3 #coding=utf-8# 这是一个注释print("Hello, World") 

多行注释用三个单引号（'''）或者三个双引号（"""）将需要注释的内容囊括起来，例如:

1、单引号（'''）

#!/usr/bin/python3 #coding=utf-8'''这是多行注释，用三个单引号这是多行注释，用三个单引号 这是多行注释，用三个单引号'''print("Hello, World!") 

2、双引号（"""）

#!/usr/bin/python3 #coding=utf-8"""这是多行注释，用三个双引号这是多行注释，用三个双引号 这是多行注释，用三个双引号"""print("Hello, World!") 

 三引号实际上是多行长字符串的声明方式，也作为python代码文档使用（类似javadoc）。

本章节主要说明 Python 的运算符。举个简单的例子 4 + 5 = 9 。例子中，4 和 5 被称为操作数，"+" 称为运算符。

Python 语言支持以下类型的运算符:

• 算术运算符
• 比较（关系）运算符
• 赋值运算符
• 逻辑运算符
• 位运算符
• 成员运算符
• 身份运算符
• 运算符优先级

接下来让我们一个个来学习 Python 的运算符。

Python 算术运算符

以下假设变量 a 为 21，变量 b 为 10：

以下实例演示了 Python 所有算术运算符的操作：

#!/usr/bin/python3#coding=utf-8a = 21b = 10c = 0c = a + bprint ("a+b 的值为：", c)c = a - bprint ("a-b 的值为：", c)c = a * bprint ("a*b 的值为：", c)c = a / bprint ("a/b 的值为：", c)c = a % bprint ("a%b 的值为：", c)# 修改变量 a 、b 、ca = 2b = 3c = a**b print ("a**b 的值为：", c)a = 10b = 5c = a//b print ("a//b 的值为：", c)

以上实例输出结果：

a+b 的值为： 31
a-b 的值为： 11
a*b 的值为： 210
a/b 的值为： 2.1
a%b 的值为： 1
a**b 的值为： 8
a//b 的值为： 2

Python 比较运算符

以下假设变量 a 为 10，变量 b 为 20：

所有比较运算符返回 1 表示真，返回 0 表示假。这分别与特殊的变量 True 和 False 等价。注意：True和False的首字母为大写。

以下实例演示了 Python 所有比较运算符的操作：

#!/usr/bin/python3#coding=utf-8a = 21b = 10c = 0if ( a == b ):    print ("a 等于 b")else:    print ("a 不等于 b")if ( a != b ):    print ("a 不等于 b")else:    print ("a 等于 b")if ( a < b ):    print ("a 小于 b")else:    print ("a 大于等于 b")if ( a > b ):    print ("a 大于 b")else:    print ("a 小于等于 b")# 修改变量 a 和 b 的值a = 5;b = 20;if ( a <= b ):    print ("a 小于等于 b")else:    print ("a 大于  b")if ( a >= b ):    print ("a 大于等于 b")else:    print ("a 小于 b")

以上实例输出结果：

a 不等于 b
a 不等于 b
a 大于等于 b
a 大于 b
a 小于等于 b
a 小于 b

Python 赋值运算符

以下假设变量 a 为 10，变量 b 为 20：

以下实例演示了 Python 所有赋值运算符的操作：

#!/usr/bin/python3#coding=utf-8a = 21b = 10c = 0c = a + bprint ("1 - c 的值为：", c)c += aprint ("2 - c 的值为：", c)c *= aprint ("3 - c 的值为：", c)c /= a print ("4 - c 的值为：", c)c = 2c %= aprint ("5 - c 的值为：", c)c **= aprint ("6 - c 的值为：", c)c //= aprint ("7 - c 的值为：", c)

以上实例输出结果：

1 - c 的值为： 312 - c 的值为： 523 - c 的值为： 10924 - c 的值为： 52.05 - c 的值为： 26 - c 的值为： 20971527 - c 的值为： 99864

Python 位运算符

按位运算符是把数字看作二进制来进行计算的。Python 中的按位运算法则如下：

下表中变量 a 为 60，b 为 13。

注：关于原码，补码和反码：
原码：假设机器字长为n，原码就是用一个n位的二进制数，其中最高位为符号位：正数是0，负数是1。剩下的表示概数的绝对值，位数如果不够就用0补全。
反码：在原码的基础上，符号位不变其他位取反，也就是就是0变1，1变0。
补码：在反码的基础上加1。  
PS：正数的原、反、补码都一样，0的原码跟反码都有两个，因为这里0被分为+0和-0。
按位取反和反码有一定的相似之处但又不尽相同（反码符号位不取反）。
在计算机中，是以补码的形式存放数据的。1100 0011刚好对应-61。
-61的原码-> 1011 1101->反码->1100 0010->补码->1100 0011

以下实例演示了 Python 所有位运算符的操作：

#!/usr/bin/python3#coding=utf-8a = 60            # 60 = 0011 1100 b = 13            # 13 = 0000 1101 c = 0c = a & b;        # 12 = 0000 1100print ("1 - c 的值为：", c)c = a | b;        # 61 = 0011 1101 print ("2 - c 的值为：", c)c = a ^ b;        # 49 = 0011 0001print ("3 - c 的值为：", c)c = ~a;           # -61 = 1100 0011print ("4 - c 的值为：", c)c = a << 2;       # 240 = 1111 0000print ("5 - c 的值为：", c)c = a >> 2;       # 15 = 0000 1111print ("6 - c 的值为：", c)

以上实例输出结果：

1 - c 的值为： 122 - c 的值为： 613 - c 的值为： 494 - c 的值为： -615 - c 的值为： 2406 - c 的值为： 15

Python 逻辑运算符

Python 语言支持逻辑运算符，以下假设变量 a 为 10, b 为 20:

以上实例输出结果：

#!/usr/bin/python3#coding=utf-8a = 10b = 20if ( a and b ):    print ("1 - 变量 a 和 b 都为 true")else:    print ("1 - 变量 a 和 b 有一个不为 true")if ( a or b ):    print ("2 - 变量 a 和 b 都为 true，或其中一个变量为 true")else:    print ("2 - 变量 a 和 b 都不为 true")# 修改变量 a 的值a = 0if ( a and b ):    print ("3 - 变量 a 和 b 都为 true")else:    print ("3 - 变量 a 和 b 有一个不为 true")if ( a or b ):    print ("4 - 变量 a 和 b 都为 true，或其中一个变量为 true")else:    print ("4 - 变量 a 和 b 都不为 true")if not( a and b ):    print ("5 - 变量 a 和 b 都为 false，或其中一个变量为 false")else:    print ("5 - 变量 a 和 b 都为 true")

以上实例输出结果：

1 - 变量 a 和 b 都为 true2 - 变量 a 和 b 都为 true，或其中一个变量为 true3 - 变量 a 和 b 有一个不为 true4 - 变量 a 和 b 都为 true，或其中一个变量为 true5 - 变量 a 和 b 都为 false，或其中一个变量为 false

Python 成员运算符

除了以上的一些运算符之外，Python 还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。

以下实例演示了 Python 所有成员运算符的操作：

#!/usr/bin/python3#coding=utf-8a = 10b = 20list = [1, 2, 3, 4, 5 ];if ( a in list ):    print ("1 - 变量 a 在给定的列表中 list 中")else:    print ("1 - 变量 a 不在给定的列表中 list 中")if ( b not in list ):    print ("2 - 变量 b 不在给定的列表中 list 中")else:    print ("2 - 变量 b 在给定的列表中 list 中")# 修改变量 a 的值a = 2if ( a in list ):    print ("3 - 变量 a 在给定的列表中 list 中")else:    print ("3 - 变量 a 不在给定的列表中 list 中")

以上实例输出结果：

1 - 变量 a 不在给定的列表中 list 中2 - 变量 b 不在给定的列表中 list 中3 - 变量 a 在给定的列表中 list 中

Python 身份运算符

身份运算符用于比较两个对象的存储单元

以下实例演示了 Python 所有身份运算符的操作：

#!/usr/bin/python3#coding=utf-8a = 20b = 20if ( a is b ):    print ("1 - a 和 b 有相同的标识")else:    print ("1 - a 和 b 没有相同的标识")if ( id(a) == id(b) ):    print ("2 - a 和 b 有相同的标识")else:    print ("2 - a 和 b 没有相同的标识")# 修改变量 b 的值b = 30if ( a is b ):    print ("3 - a 和 b 有相同的标识")else:    print ("3 - a 和 b 没有相同的标识")if ( a is not b ):    print ("4 - a 和 b 没有相同的标识")else:    print ("4 - a 和 b 有相同的标识")

以上实例输出结果：

1 - a 和 b 有相同的标识2 - a 和 b 有相同的标识3 - a 和 b 没有相同的标识4 - a 和 b 没有相同的标识

Python 运算符优先级

以下表格列出了从最高到最低优先级的所有运算符：

•  括号因为不是运算符所以没有纳入本表，但算术式中一旦出现括号，就要先算括号内的内容。
• 同一级运算符的优先级从左往右进行计算。

以下实例演示了 Python 所有运算符优先级的操作：

#!/usr/bin/python3#coding=utf-8a = 20b = 10c = 15d = 5e = 0e = (a + b) * c / d       #( 30 * 15 ) / 5print ("(a + b) * c / d 运算结果为：",  e)e = ((a + b) * c) / d     # (30 * 15 ) / 5print ("((a + b) * c) / d 运算结果为：",  e)e = (a + b) * (c / d);    # (30) * (15/5)print ("(a + b) * (c / d) 运算结果为：",  e)e = a + (b * c) / d;      #  20 + (150/5)print ("a + (b * c) / d 运算结果为：",  e)

以上实例输出结果：

(a + b) * c / d 运算结果为： 90.0((a + b) * c) / d 运算结果为： 90.0(a + b) * (c / d) 运算结果为： 90.0a + (b * c) / d 运算结果为： 50.0

Python 数字类型用于数值的储存。数值类型是不允许改变的，如果改变数字数据类型的值，将重新分配内存空间。

以下实例在变量赋值时 Number 对象将被创建：

var1 = 1var2 = 10

您也可以使用del语句删除一些数字对象的引用。

del语句的语法是：

del var1[,var2[,var3[....,varN]]]

您可以通过使用del语句删除单个或多个对象的引用，例如：

del vardel var_a, var_b

Python 支持三种不同的数值类型：

• 整型(Int) - 通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型。
• 浮点型(float) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 10² = 250）
• 复数( (complex)) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。

我们可以使用十六进制和八进制来代表整数：

>>> number = 0xA0F # 十六进制>>> number2575>>> number=0o37 # 八进制>>> number31

• Python支持复数，复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。

Python 数字类型转换

有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。

• int(x) 将x转换为一个整数。

• float(x) 将x转换到一个浮点数。

• complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。

• complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。

以下实例将浮点数变量 a 转换为整数：

>>> a = 1.0>>> int(a)1

强制数据类型转换在某些情况下会丢失精度，在一些对精度要求比较高的环境下建议不要轻易使用强制数据类型转换！！

Python 数字运算

Python 解释器可以作为一个简单的计算器，您可以在解释器里输入一个表达式，它将输出表达式的值。

表达式的语法很直白： +, -, * 和 /, 和其它语言（如Pascal或C）里一样。例如：

>>> 2 + 24>>> 50 - 5*620>>> (50 - 5*6) / 45.0>>> 8 / 5  # 总是返回一个浮点数1.6

注意：在不同的机器上浮点运算的结果可能会不一样。

在整数除法中，除法 / 总是返回一个浮点数，如果只想得到整数的结果，丢弃可能的分数部分，可以使用运算符 // ：

>>> 17 / 3  # 整数除法返回浮点型5.666666666666667>>>>>> 17 // 3  # 整数除法返回向下取整后的结果5>>> 17 % 3  # ％操作符返回除法的余数2>>> 5 * 3 + 2 17

注意：// 得到的并不一定是整数类型的数，它与分母分子的数据类型有关系。

>>> 7//23>>> 7.0//23.0>>> 7//2.03.0>>> 

等号 = 用于给变量赋值。赋值之后，除了下一个提示符，解释器不会显示任何结果。

>>> width = 20>>> height = 5*9>>> width * height900

Python 可以使用 ** 操作来进行幂运算：

>>> 5 ** 2  # 5 的平方25>>> 2 ** 7  # 2的7次方128

变量在使用前必须先"定义"（即赋予变量一个值），否则会出现错误：

>>> n   # 尝试访问一个未定义的变量Traceback (most recent call last):  File "<stdin>", line 1, in <module>NameError: name 'n' is not defined

不同类型的数混合运算时会将整数转换为浮点数：

>>> 3 * 3.75 / 1.57.5>>> 7.0 / 23.5

在交互模式中，最后被输出的表达式结果被赋值给变量 _ 。例如：

>>> tax = 12.5 / 100>>> price = 100.50>>> price * tax12.5625>>> price + _113.0625>>> round(_, 2)113.06

此处， _ 变量应被用户视为只读变量。

数学函数

随机数函数

随机数可以用于数学，游戏，安全等领域中，还经常被嵌入到算法中，用以提高算法效率，并提高程序的安全性。

Python包含以下常用随机数函数：