书名：写给系统管理员的Python脚本编程指南
ISBN：978-7-115-52366-2
本书由人民邮电出版社发行数字版。版权所有，侵权必究。
您购买的人民邮电出版社电子书仅供您个人使用，未经授权，不得以任何方式复制和传播本书内容。
我们愿意相信读者具有这样的良知和觉悟，与我们共同保护知识产权。
如果购买者有侵权行为，我们可能对该用户实施包括但不限于关闭该帐号等维权措施，并可能追究法律责任。
著 【印度】甘尼什·桑吉夫·奈克（Ganesh Sanjiv Naik）
译 张成悟
责任编辑 陈聪聪
人民邮电出版社出版发行 北京市丰台区成寿寺路11号
邮编 100164 电子邮件 315@ptpress.com.cn
网址 http://www.ptpress.com.cn
读者服务热线：(010)81055410
反盗版热线：(010)81055315
Copyright © Packt Publishing 2019. First published in the English language under the title Mastering Python Scripting for System Administrators.
All Rights Reserved.
本书由英国Packt Publishing公司授权人民邮电出版社出版。未经出版者书面许可，对本书的任何部分不得以任何方式或任何手段复制和传播。
版权所有，侵权必究。
本书是一本介绍Python编程的进阶图书，包含了大量关于Python脚本设计的主题。本书共18章，首先带领读者快速复习Python基础知识，然后循序渐进地介绍了一些实用主题，包括Python脚本的调试和分析、编写单元测试、系统管理、处理文件和数据、文件归档以及文本处理等。然后介绍了网络编程、处理电子邮件、远程控制主机、创建图形用户界面、处理日志文件、编写网络爬虫、数据收集和可视化以及操作数据库等更加高阶的主题。本书中每一知识点都结合可以运行的源码讲解，帮助读者更好地掌握Python脚本编程。
本书要求读者具备Python的基础知识，非常适合对Python编程有基本了解并且有兴趣将编程技能扩展到命令行脚本和系统管理的读者阅读。
Python语言已经发展出了许多特性，它适用于所有可能的IT子领域。本书将帮助您利用Python特性编写高效的脚本程序，并创建命令行工具（用于数据类型、循环、条件、函数和错误处理等）来管理您的系统环境。从基本设置，到自动化测试，再到构建不同的命令行工具，本书将围绕这个开发过程一一展开。本书为您提供了从运行基本脚本到使用标准程序库需要用到的所有内容。最后，本书将带您创建一个大型脚本项目。在这个项目中，您将学习如何根据理想的资源来计划、实现和分配项目。
如果您对Python编程有一些基本了解，并且希望将编程技能扩展到命令行脚本，或者对系统管理感兴趣，这本书将是您理想的选择。
阅读这本书需要有一定的Python编程基础。
第1章 Python脚本编程概述，介绍了Python的安装过程以及Python解释器工具的使用方法。您将学习如何为变量赋值，并引入变量和字符串。还将学习序列数据类型，包括列表（list）、元组（tuple）、集合（set）和字典（dictionary）。最后，您将学习如何解析脚本中的命令行参数。
第2章 调试和分析Python脚本程序，介绍如何使用调试工具调试Python程序，以及如何处理错误（error），并了解如何分析程序并测试程序的运行时间。
第3章 单元测试框架简介，介绍Python中的单元测试，并为程序创建单元测试用例。
第4章 自动化常规管理活动，介绍如何自动执行系统管理员的常规管理活动。本章将依次讲述如何接收输入、处理密码、执行外部命令、读取配置文件、向脚本添加警告代码、限制CPU性能、启动Web浏览器、使用os模块以及创建备份。
第5章 处理文件、目录和数据，介绍如何使用os模块实现各种操作。您将了解操作数据的方法，例如复制、移动、合并和比较。最后描述了如何使用tarfile模块。
第6章 文件归档、加密和解密，研究文件归档，介绍如何创建归档文件，包括TAR和ZIP格式文件。您还将学习如何使用应用程序解压缩.tar和.zip文件。
第7章 文本处理和正则表达式，介绍Python中的文本处理和正则表达式。本章将讲述如何读取和写入文件，以及如何使用正则表达式操作文件内容。正则表达式（regular expression）是一个非常强大的Python内建库，用于在文本中搜索和提取数据。
第8章 文档和报告，介绍如何使用Python记录和报告信息，并使用Python脚本获取输入以及打印输出，编写自动收集信息和接收电子邮件的脚本，以及如何格式化信息。
第9章 处理不同类型的文件，介绍如何使用Python打开、编辑PDF文件、Excel文件和CSV文件，并从这些文件中读取数据。
第10章 网络基础——套接字编程，首先介绍计算机网络的基础知识，然后描述如何使用TCP和UDP套接字编程，进行网络通信并获取HTTP和FTP等协议的信息。
第11章 使用Python脚本处理电子邮件，探讨如何使用Python脚本编写和发送电子邮件。使用软件发送电子邮件是一个常见任务，本章将学习如何使用Python的smtplib模块发送电子邮件。除此之外，还将学习在不同服务器上使用不同协议发送电子邮件。
第12章 通过Telnet和SSH远程控制主机，介绍如何使用SSH在服务器上执行基本配置。首先使用Telnet模块编写程序，然后使用SSH实现相同的效果。
第13章 创建图形用户界面，介绍如何使用PyQt模块创建图形用户界面。
第14章 使用Apache及其他类型的日志文件，介绍如何使用Apache日志文件，包括学习日志解析程序，识别特定类型的日志消息。讲述如何解析这些文件，如何处理多个文件，如何检测异常，存储数据和生成报告。
第15章 SOAP和RESTful API通信，涉及SOAP和REST的基础知识，以及它们之间的差异。本章将介绍SOAP API，并通过不同的库来使用它。最后还将学习REST API和标准库。
第16章 网络爬虫——从网站中提取有用的数据，介绍如何使用Python库从网站中提取数据，以及如何使用Python搜索文章和源代码。
第17章 统计信息的收集和报告，介绍如何使用Python科学计算库，包括NumPy、SciPy和Matplotlib。同时了解数据可视化的概念并学习如何绘制数据。
第18章 MySQL和SQLite数据库管理，介绍如何管理MySQL和SQLite数据库。了解此类管理的需求和设计，并修改插件框架，编写生产者和消费者代码。
编写本书是为了尽可能通过几个脚本让您学习许多不同的Python编程方法。但要充分利用本书，您需要执行以下操作。
本书假定您已掌握一定程度的Python基础知识，因此不会讲解基本技能。这些技能包括以下内容。
本书由异步社区出品，社区（https://www.epubit.com/）为您提供相关资源和后续服务。
本书提供如下资源：
要获得以上配套资源，请在异步社区本书页面中单击
，跳转到下载界面，按提示进行操作即可。注意：为保证购书读者的权益，该操作会给出相关提示，要求输入提取码进行验证。
作者和编辑尽最大努力来确保书中内容的准确性，但难免会存在疏漏。欢迎您将发现的问题反馈给我们，帮助我们提升图书的质量。
当您发现错误时，请登录异步社区，按书名搜索，进入本书页面，单击“提交勘误”，输入勘误信息，单击“提交”按钮即可。本书的作者和编辑会对您提交的勘误进行审核，确认并接受后，您将获赠异步社区的100积分。积分可用于在异步社区兑换优惠券、样书或奖品。
我们的联系邮箱是contact@epubit.com.cn。
如果您对本书有任何疑问或建议，请您发邮件给我们，并请在邮件标题中注明本书书名，以便我们更高效地做出反馈。
如果您有兴趣出版图书、录制教学视频，或者参与图书翻译、技术审校等工作，可以发邮件给我们；有意出版图书的作者也可以到异步社区在线提交投稿（直接访问www.epubit.com/selfpublish/submission即可）。
如果学校、培训机构或企业想批量购买本书或异步社区出版的其他图书，也可以发邮件给我们。
如果您在网上发现有针对异步社区出品图书的各种形式的盗版行为，包括对图书全部或部分内容的非授权传播，请您将怀疑有侵权行为的链接发邮件给我们。您的这一举动是对作者权益的保护，也是我们持续为您提供有价值的内容的动力之源。
“异步社区”是人民邮电出版社旗下IT专业图书社区，致力于出版精品IT技术图书和相关学习产品，为作译者提供优质出版服务。异步社区创办于2015年8月，提供大量精品IT技术图书和电子书，以及高品质技术文章和视频课程。更多详情请访问异步社区官网https://www.epubit.com。
“异步图书”是由异步社区编辑团队策划出版的精品IT专业图书的品牌，依托于人民邮电出版社近30年的计算机图书出版积累和专业编辑团队，相关图书在封面上印有异步图书的LOGO。异步图书的出版领域包括软件开发、大数据、AI、测试、前端、网络技术等。
异步社区
微信服务号
Python是一种脚本语言，由吉多·范·罗苏姆（Guido van Rossum）于1991年创造。Python被用于开发各种应用程序，如游戏、GIS编程、软件开发、Web开发、数据分析、机器学习和系统脚本编程等。
Python是一种面向对象的高级编程语言，具有动态语义。更重要的是，Python是一种解释型语言。因为它具有许多高级特性，所以Python适用于快速开发应用程序。
Python简单易学，因为它的语法具有很好的可读性，程序维护成本低。
Python的一个重要功能就是允许程序导入模块（module）和包（package）以实现代码重用。Python解释器执行过程很容易被理解：依次编写的各部分代码将被逐行执行。Python还拥有各类强大的功能库。
本章将介绍以下主题。
if语句。for和while循环。在开始阅读本书之前，请提前了解Python编程的基础知识，例如基本语法、变量类型、元组（tuple）类型、列表（list）、字典（dictionary）、函数、字符串和方法（method）等。Python官网提供了两个Python版本：3.7.2和2.7.15，本书中的示例代码和需要安装的软件包均使用3.7版。
Python提供了大量开源的数据分析工具、Web框架、测试工具等程序库。Python可以在不同的操作系统上使用（Windows、macOS、Linux和嵌入式Linux H/W操作系统，例如Raspberry Pi）。Python也可以用于开发桌面和Web应用程序。
Python 可以让开发人员用更少的代码实现相同或者更多的功能。Python 在解释器上运行，所以程序原型设计非常快。Python 支持面向对象、面向过程和函数式编程。
使用Python能创建Web应用程序，也能与其他软件搭配使用，以改善工作流程。Python可用于连接数据库系统，也能处理文件，并且能够处理大数据或执行复杂的数学运算。
Python语法接近英语，所以其代码具有高可读性。Python以换行作为一条语句的结束。
Python拥有一个重要特性：缩进。使用缩进可以控制判断语句、循环语句（如for和while循环）、函数和类（class）的作用范围。
本节我们将学习在Linux和Windows等不同操作系统上安装Python。
大多数Linux发行版默认安装了Python 2，其中一些发行版也默认安装了Python 3。
在Debian系列Linux发行版上，使用如下命令安装Python 3。
sudo apt install python3在centos上使用如下命令安装Python 3。
sudo yum install python3如果使用上述命令无法安装Python，请在官网下载Python安装包并根据引导安装Python。
要在Microsoft Windows中安装Python，需要从Python官网下载可执行文件并安装。首先从官网下载python.exe，然后选择要安装的Python版本，最后双击下载的安装文件并安装Python。在安装向导中，选中将“Python添加到路径”的复选框，然后按照说明安装Python 3。
在Linux上安装pip。
sudo apt install python-pip --- This will install pip for python 2.
sudo apt install python3-pip --- This will install pip for python 3.在Windows上安装pip。
python -m pip install pip安装Python 3之前需要安装brew，使用如下命令安装brew。
/usr/bin/ruby -e "$(curl -fsSL
https://raw.githubusercontent.com/Homebrew/install/master/install)"然后使用brew安装Python 3。
brew install python3方法一：Anaconda包含了Jupyter Notebook，下载Anaconda后根据引导安装即可。
方法二：使用pip安装。
pip install jupyter在Linux中，运行pip install jupyter这条命令将会安装Python 2的Jupyter。如果我们需要安装Python 3的Jupyter，可以运行以下命令。
pip3 install jupyter现在我们学习如何安装虚拟环境（virtual environment）并激活它。
在Linux上，按照如下步骤安装虚拟环境。
1．首先检查是否已经安装pip，然后使用pip安装Python 3。
sudo apt install python3-pip2．使用pip3安装虚拟环境。
sudo pip3 install virtualenv3．创建一个虚拟环境。我们可以为虚拟环境起一个名字，这里使用pythonenv。
virtualenv pythonenv4．激活这个虚拟环境。
source venv/bin/activate5．使用完毕后，使用如下命令注销virtualenv。
deactivate在Windows上，使用命令pip install virtualenv安装虚拟环境，安装步骤与Linux相同。
从官网下载Geany及所需的二进制文件，安装时请按照说明进行操作。
从官网下载PyCharm并按照说明进行操作。
Python是一种解释型语言。它有一个交互式控制台，称为Python解释器或Python Shell。此Shell可以即时逐行执行程序，而无须创建脚本文件。
在Python交互式控制台中，我们可以访问Python所有内置函数和库、已安装的模块和输入过的命令。该控制台为我们提供了探索Python的平台。在控制台编写并调试完成后，就可以将代码粘贴到脚本文件中了。
在本节中，我们将了解Python和Bash之间的区别。它们的主要区别如下。
我们可以从任何已安装Python的计算机上访问Python的交互式控制台。运行以下命令启动Python的交互式控制台。
$ python这将启动默认的Python交互式控制台。
在Linux中，如果我们在终端中输入Python，就会启动Python 2.7控制台。如果我们想启动Python 3控制台，就需要在终端中输入python3并按Enter键。
在Windows中，当我们在命令行中输入Python时，它将启动所安装的Python版本的控制台。
Python 交互式控制台的脚本从>>>前缀开始，我们可以在>>>前缀后编写 Python命令。
Python变量赋值，如下所示。
>>> name = John在这里，已经为变量name赋予了字符串值John。然后按Enter键，就会得到一个有>>>前缀的新行。
>>> name = John以下示例为多个变量赋值，并执行简单的数学运算，然后输出计算后的值。
>>> num1 = 5000
>>> num2 = 3500
>>> num3 = num1 + num2
>>> print (num3)
8500
>>> num4 = num3 – 2575
>>> print (num4)
5925
>>>这段代码先为两个变量赋值，然后让两个变量相加，把结果存储在第三个变量中，并将结果输出到终端。然后从结果变量中减去一个值，并将结果存储在第四个变量中。最后将结果输出到终端。所以我们也可以将Python解释器作为计算器使用。
>>> 509/22
23.136363636363637
>>>这里进行了除法操作。509除以22，得到的结果是23.136363636363637。
当我们需要在Python解释器中一次编写多行代码时（例如，编写if语句块以及for和while循环），解释器显示3个点（...）来提示继续输入。按两次Enter键就可以退出多行模式。现在我们来看下面的例子。
>>> val1 = 2500
>>> val2 = 2400
>>> if val1 > val2：
... print("val1 is greater than val2")
... else:
... print("val2 is greater than val1")
...
val1 is greater than val2
>>>上面的代码为两个变量val1和val2赋予了整数值，然后检查val1是否大于val2。在这种情况下，val1大于val2，因此if块中的语句将被输出。请记住，if和else块中的语句是需要缩进的，如果不使用缩进，Python将输出以下错误。
>>> if val1 > val2:
... print("val1 is greater than val2")
File "<stdin>", line 2
print("val1 is greater than val2")
^
IndentationError: expected an indented block
>>>如果需要导入模块，Python解释器将首先检查该模块是否可用，我们可以使用import语句来导入模块。输入import语句并按Enter键后，若产生>>>前缀，代表导入成功。如果该模块不存在，Python解释器将输出错误。
>>> import time
>>>导入time模块后，产生>>>前缀。这代表time模块存在并且导入成功。
>>> import matplotlib如果该模块不存在，那么我们将得到一个Traceback错误。
File "<stdin>", line 1, in <module>
ImportError: No module named 'matplotlib'现在matplotlib模块不可用，Python给出的解释为ImportError: No module named 'matplotlib'。
要解决这个问题，就需要安装matplotlib，然后再次尝试导入matplotlib。安装matplotlib后，就可以导入模块了，如下所示。
>>> import matplotlib
>>>我们可以通过两种方式来退出Python控制台。
quit()或exit()函数。使用快捷键Ctrl + D退出，如下所示。
>>> val1 = 5000
>>> val2 = 2500
>>>
>>> val3 = val1 - val2
>>> print (val3)
2500
>>>
student@ubuntu:~$使用quit()函数退出Python的交互式控制台，并且返回终端，如下所示。
>>> Lion = 'Simba'
>>> quit()
student@ubuntu$在Python中，我们必须使用缩进来控制代码块。在编写函数、决策语句、循环语句和类时，缩进很有用，它使Python程序非常具有可读性。
我们使用缩进来控制Python程序中的代码块，具体可以使用空格或制表符来缩进代码，如下所示。
if val1 > val2:
print ("val1 is greater than val2")
print("This part is not indented")在这个示例中，我们缩进了第一个print语句，表示它属于if语句块。第二个print语句没有被缩进，表示它不属于if语句块。
与其他编程语言一样，Python不需要先声明变量然后才能使用它。在Python中，我们只需直接使用一个名称作为变量名，并为其赋值就行了。之后就可以在程序中使用该变量。因此我们可以在任意时刻声明变量。
在Python中，变量的值和类型可能在程序执行期间发生变化。在以下代码行中，我们将数值100赋给变量。
n = 100
#这里将100赋值给n，然后将n的值加1
>>> n = n + 1
>>> print(n)
101
>>>以下是一个变量在程序执行期间被改变类型的示例。
a = 50 # 数据类型隐式设置为int
a = 50 + 9.50 # 数据类型变为float
a = "Seventy" # 数据类型变为stringPython在后台管理不同的数据类型，每种类型的值都存储在不同的内存位置。对于开发者来说，变量只是一个名称。
>>> msg = 'And now for something completely different'
>>> a = 20
>>> pi = 3.1415926535897932这段代码进行了3次赋值。第一次给变量msg赋予一个字符串值，第二次给变量a赋予一个整数值，第三次给变量pi（圆周率）赋予浮点数值。
变量的类型就是其所引用的值的类型，如下所示。
>>> type(msg)
<type 'str'>
>>> type(a)
<type 'int'>
>>> type(pi)
<type 'float'>在Python中，我们不需要显式声明变量所需的内存空间，只要为变量赋值，声明就会自动完成。等号（=）用于为变量赋值。考虑如下示例代码。
#!/usr/bin/python3
name = 'John'
age = 25
address = 'USA'
percentage = 85.5
print(name)
print(age)
print(address)
print(percentage)输出如下。
John
25
USA
85.5在以上示例中，程序为变量name赋予字符串值John，为变量age赋予整数值25，为变量address赋予字符串值USA，为变量percentage赋予浮点数值85.5。
我们不需要像其他编程语言一样，先声明变量类型。因此，查看解释器输出就可以获得该变量的类型。在上面的示例中，name和address是字符串类型，age是整数类型，percentage是浮点数类型。
我们可以为多个变量赋予相同的值。
x = y = z = 1这个语句创建了3个变量，并为它们赋予整数值1。这3个变量都指向相同的内存位置。
在Python中，我们也可以为多个变量分别赋予不同的值。
x, y, z = 10, 'John', 80这里为变量y赋予字符串值John，为变量x和变量z分别赋予整数值10和整数值80。
Python解释器也可以作为计算器使用。我们只需要输入计算表达式，就可以得到结果。其中括号可以用来提升运算优先级，如下所示。
>>> 5 + 5
10
>>> 100 - 5*5
75
>>> (100 - 5*5)/15
5.0
>>> 8/5
1.6整数是int类型，小数则是float类型。
在Python中，除法（
/）操作总是返回一个浮点数值。地板（floor）除（//）则可以获得整数结果。%运算符用于计算余数。
考虑以下示例程序。
>>> 14/3
4.666666666666667
>>>
>>> 14//3
4
>>>
>>> 14%3
2
>>> 4*3+2
14
>>>为了计算指数，Python提供了**运算符，如下所示。
>>> 8**3
512
>>> 5**7
78125
>>>等号（=）用于给变量赋值。
>>> m = 50
>>> n = 8 * 8
>>> m * n
3200如果一个变量并没有值，但我们仍然要使用它，则Python解释器将会报错。
>>> k
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'k' is not defined
>>>如果我们使用运算符计算不同类型的数值，则会得到一个浮点数。
>>> 5 * 4.75 - 1
22.75在 Python 交互式控制台中，下划线（_）包含最后一次输出的表达式的值，如下所示。
>>> a = 18.5/100
>>> b = 150.50
>>> a * b
27.8425
>>> b + _
178.3425
>>> round(_, 2)
178.34
>>>数值类型是不可变数据的类型。如果我们尝试改变它的值，Python将会为变量分配一个新对象。
我们可以通过赋值来创建数值对象，如下所示。
num1 = 50
num2 = 25del语句用于删除单个或多个变量，如下所示。
del num
del num_a，num_b在某些情况下，如果我们需要将数值显式地从一种类型转换为另一种类型，以满足某些需求，Python将使用下面这些表达式在内部转换数值类型。
int(a)将a转换为整数。float(a)将a转换为浮点数。complex(a)将a转换为具有实部a和虚部0的复数。complex(a,b)将a和b转换为具有实部a和虚部b的复数，a和b均是数值。正如数值类型一样，字符串（string）类型也是Python的内置数据类型。Python可以操纵字符串。字符串的表达式如下。
'...'）。"..."）。代码如下所示。
>>> 'Hello Python'
'Hello Python'
>>> "Hello Python"
'Hello Python'一个字符串就是一组字符，我们也可以访问单个字符。
>>> city = 'delhi'
>>> letter = city[1]
>>> letter = city[-3]在第二个语句中，我们从city中选择编号1的字符并将其值赋予letter。方括号中的数字代表一个索引，索引指示将要访问的字符地址，并且从0开始计数。因此在这个示例中，执行letter = city [1]后，将获得以下输出。
city d e l h i
index 0 1 2 3 4
-5 -4 -3 -2 -1输出如下。
e
l现在我们学习字符串的连接和重复，如下所示。
>>> 3 * 'hi' + 'hello'
'hihihihello'这段代码展示了字符串如何连接和重复。3 * 'hi'表示hi重复3次，+表示将字符串hello连接在hi后面。
我们也可以将两个字符串写在一起，让它们自动连接。这两个字符串必须用单引号括起来，代码如下所示。
>>> 'he' 'llo'
'hello'这个特性非常有用，比如需要输入非常长的字符串时，可以分为几部分输入。
>>> str = ('Several strings'
... 'joining them together.')
>>> str
'Several strings joining them together.'Python字符串支持切片操作，它是指从字符串中获取指定范围的字符。我们来看下面的例子。请注意，起始索引位置的字符将被包含，而结束索引位置的字符将不被包含。
令str = "Programming"。
>>> str[0:2]
'Pr'
>>> str[2:5]
'ogr'如果省略第一个索引，那么索引将使用默认值0，如下所示。
>>> str[:2] + str[2:]
'Python'
>>> str[:4] + str[4:]
'Python'
>>> str[:2]
'Py'
>>> str[4:]
'on'
>>> str[-2:]
'on'我们可以使用方括号通过切片访问字符串中指定的单个字符，还可以访问指定范围之间的字符，如下所示。
#!/usr/bin/python3
str1 = 'Hello Python!'
str2 = "Object Oriented Programming"
print ("str1[0]: ", str1[0])
print ("str2[1:5]: ", str2[1:5])输出如下。
str1[0]: H
str2[1:5]: bjec我们可以对指定的索引重新赋值，来更新字符串，如下所示。
#!/usr/bin/python3
str1 = 'Hello Python!'
print ("Updated String: - ", str1 [:6] + 'John')输出如下。
Updated String: - Hello JohnPython支持不可打印的转义字符，它们可以用反斜杠加转义字符来表示，如表1-1所示。转义字符在单引号和双引号字符串中均会生效。
表1-1 转义字符
| 符 号 |
十六进制表示 |
描 述 |
|---|---|---|
|
|
|
响铃或警报 |
|
|
|
退格 |
|
|
|
Control- |
|
|
|
新行 |
|
|
|
Control- |
|
|
|
转义 |
|
|
|
换页 |
|
|
|
空格 |
|
|
|
Meta-control- |
|
|
|
字符 |
|
|
|
八进制表示法，其中 |
|
|
|
回车 |
|
|
|
十六进制表示法，其中 |
|
|
|
制表符 |
|
|
|
纵向制表符 |
表1-2展示了字符串的特殊运算符。假设变量a的值为Hello，变量b的值为World。
表1-2 字符串的特殊运算符
| 运算符 |
描 述 |
示 例 |
|---|---|---|
|
|
将两个字符串连接起来 |
|
|
|
切片：获取指定索引的字符 |
|
|
|
范围切片：获取指定索引范围的字符 |
|
|
|
重复：创建新字符串，连接同一字符串的多个副本 |
|
|
|
包含关系：如果给定字符串中不存在某个字符，则返回 |
|
|
|
包含关系：如果给定字符串中存在某个字符，则返回 |
|
|
|
格式化：将字符串格式化 |
|
%是字符串格式化运算符，如下所示。
#!/usr/bin/python3
print ("Hello this is %s and my age is %d !" % ('John', 25))输出如下。
Hello this is John and my age is 25 !表1-3展示了与%一起使用的符号。
表1-3 字符串格式化符号和对应的转换值
| 格式化符号 |
转 换 值 |
|---|---|
|
|
字符 |
|
|
格式化之前通过 |
|
|
有符号十进制整型 |
|
|
有符号十进制整型 |
|
|
无符号十进制整型 |
|
|
八进制整型 |
|
|
十六进制整型（小写 |
|
|
十六进制整型（大写 |
|
|
指数表示法（小写 |
|
|
指数表示法（大写 |
|
|
浮点实数 |
Python中的三引号用于输入多行字符串，能包含换行符和制表符。三引号语法可以由3个连续的单引号或双引号构成，如下所示。
#!/usr/bin/python3
para_str = """ Python is a scripting language which was created by
Guido van Rossum in 1991, which is used in various sectors such as Game
Development, GIS Programming, Software Development, web development,
Data Analytics and Machine learning, System Scripting etc.
"""
print (para_str)它的输出如下，请注意制表符和换行符。
Python is a scripting language which was created by
Guido van Rossum in 1991, which is used in various sectors such as
Game Development, GIS Programming, Software Development, web development,
Data Analytics and Machine learning, System Scripting etc.字符串是不可变对象，这意味着我们无法更改字符串的值，如下所示。
>>> welcome = 'Hello, John!'
>>> welcome[0] = 'Y'
TypeError: 'str' object does not support item assignment虽然字符串是不可变的，我们无法更改已有的字符串，但是我们可以创建一个与原始字符串不同的新字符串。
>>> str1 = 'Hello John'
>>> new_str = 'Welcome' + str1[5:]
>>> print(str1)
Hello John
>>> print(new_str)
Welcome John
>>>Python支持一种名为列表（list）的数据结构，它是一个可变且有序的元素序列。该列表中的每个元素都被称为项（item）。我们通过在方括号（[]）之间输入值来定义列表。列表的每个元素都有一个对应数字，称为位置或索引。索引从0开始计数，第一个索引为0，第二个索引为1，以此类推。我们可以对列表执行以下操作：索引、切片、添加、乘法和检查包含关系。
Python的内置length函数可以返回列表的长度。Python还内置查找列表中最大值和最小值的函数。列表的形式可以是数值列表、字符串列表或混合列表。
以下是创建列表的代码。
l = list()
numbers = [10, 20, 30, 40]
animals = ['Dog', 'Tiger', 'Lion']
list1 = ['John', 5.5, 500, [110, 450]]这里创建了3个列表：第一个是numbers，第二个是animals，第三个是list1。一个列表包含另一个列表称为嵌套列表。list1就是一个嵌套列表。不包含元素的列表称为空列表，我们可以用一个空的方括号来创建空列表。
同时，我们也可以将列表赋值给变量。
>>> cities = ['Mumbai', 'Pune', 'Chennai']
>>> numbers_list = [75, 857]
>>> empty_list = []
>>> print (cities, numbers_list, empty_list)
['Mumbai', 'Pune', 'Chennai'] [75, 857] []我们可以使用索引从列表中访问值，在方括号中指定索引值就行了。索引从0开始计数，如下所示。
#!/usr/bin/python3
cities = ['Mumbai', 'Bangalore', 'Chennai', 'Pune']
numbers = [1, 2, 3, 4, 5, 6, 7 ]
print (cities[0])
print (numbers[1:5])输出如下。
Mumbai
[2, 3, 4, 5]我们可以使用如下方法更新列表。
#!/usr/bin/python3
cities = ['Mumbai', 'Bangalore', 'Chennai', 'Pune']
print ("Original Value: ", cities[3])
cities[3] = 'Delhi'
print ("New value: ", cities[3])输出如下。
Original Value: Pune
New value: Delhi删除列表中的元素有多种方法，如果确切知道要删除的元素，我们可以使用del关键字来删除它，代码如下所示。如果不确切知道要删除哪些项，则可以使用 remove()方法。
#!/usr/bin/python3
cities = ['Mumbai', 'Bangalore', 'Chennai', 'Pune']
print ("Before deleting: ", cities)
del cities[2]
print ("After deleting: ", cities)输出如下。
Before deleting: ['Mumbai', 'Bangalore', 'Chennai', 'Pune']
After deleting: ['Mumbai', 'Bangalore', 'Pune']列表有5种基本操作，如表1-4所示。
表1-4 列表的基本操作
| 描 述 |
表 达 式 |
结 果 |
|---|---|---|
| 连接 |
|
|
| 包含关系 |
|
|
| 迭代 |
|
|
| 重复 |
|
|
| 长度 |
|
|
本节我们主要学习2种基本的列表运算符：连接和重复。
+运算符用于连接列表。
>>> a = [30, 50, 60]
>>> b = ['Hello', 75, 66 ]
>>> c = a + b
>>> print c
[30,50,60,'Hello',75,66]*运算符用于重复列表指定次数。
>>> [0] * 4
[0, 0, 0, 0]
>>> ['Python'] * 3
['python', 'python', 'python']列表索引的工作方式与字符串索引相同，都可以使用索引访问值。如果尝试读取或写入不存在的元素，则会得到IndexError错误。如果使用负值索引，则从列表末尾开始反向计数。
下面创建了一个名为cities的列表，具体的索引操作如表1-5所示。
cities = ['Mumbai', 'Bangalore', 'Chennai', 'Pune']表1-5 列表的索引操作
| 描 述 |
表 达 式 |
结 果 |
|---|---|---|
| 正值，从0开始计数 |
|
|
| 切片：获取部分元素 |
|
|
| 负值：反向计数 |
|
|
Python的元组（tuple）数据结构是不可变的，这意味着我们无法改变元组的元素。元组是一系列值，用逗号分隔并用括号包含其中的元素。和列表一样，元组是一个有序的元素序列。
>>> t1 = 'h', 'e', 'l', 'l', 'o'元组使用括号来包含元素。
>>> t1 = ('h', 'e', 'l', 'l', 'o')我们可以创建只包含一个元素的元组，只需要在末尾添置一个逗号即可。
>>> t1 = 'h',
>>> type(t1)
<type 'tuple'>括号中的值不是元组。
>>> t1 = ('a')
>>> type(t1)
<type 'str'>也可以通过tuple()函数创建一个空元组。
>>> t1 = tuple()
>>> print (t1)
()如果参数为序列类型（字符串、列表或元组），那么就会得到一个由各元素组成的序列。
>>> t = tuple('mumbai')
>>> print t
('m', 'u', 'm', 'b', 'a', 'i')元组使用逗号分隔各元素的值。
>>> t = ('a', 'b', 'c', 'd', 'e')
>>> print t[0]
'a'切片运算符可以选择指定范围内的元素。
>>> print t[1:3]
('b', 'c')要访问元组中的值，我们可以使用方括号进行切片或使用索引以获取该索引处的值，如下所示。
#!/usr/bin/python3
cities = ('Mumbai', 'Bangalore', 'Chennai', 'Pune')
numbers = (1, 2, 3, 4, 5, 6, 7)
print (cities[3])
print (numbers[1:6])输出如下。
Pune
(2, 3, 4, 5)Python中不能更新元组，因为元组是不可变的。但是我们可以通过现有元组创建一个新元组，如下所示。
#!/usr/bin/python3
cities = ('Mumbai', 'Bangalore', 'Chennai', 'Pune')
numbers = (1,2,3,4,5,6,7)
tuple1 = cities + numbers
print(tuple1)输出如下。
('Mumbai', 'Bangalore', 'Chennai', 'Pune', 1, 2, 3, 4, 5, 6, 7)Python中不能直接删除元组中的元素，所以只能使用del关键字删除整个元组，如下所示。
#!/usr/bin/python3
cities = ('Mumbai', 'Bangalore', 'Chennai', 'Pune')
print ("Before deleting: ", cities)
del cities
print ("After deleting: ", cities)输出如下。
Before deleting: ('Mumbai', 'Bangalore', 'Chennai', 'Pune')
Traceback (most recent call last):
File "01.py", line 5, in <module>
print ("After deleting: ", cities)
NameError: name 'cities' is not defined和列表一样，元组也有5种基本操作，如表1-6所示。
表1-6 元组的基本操作
| 描 述 |
表 达 式 |
结 果 |
|---|---|---|
| 迭代 |
|
|
| 重复 |
|
|
| 长度 |
|
|
| 连接 |
|
|
| 包含关系 |
|
|
元组的索引与列表的索引相同，都可以使用索引访问值。如果尝试读取或写入不存在的元素，则会得到IndexError。如果索引为负值，则从元组末尾反向计数。
现在我们创建一个名为cities的元组并进行一些索引操作，如表1-7所示。
cities = ('Mumbai', 'Bangalore', 'Chennai', 'Pune')表1-7 元组的索引操作
| 描 述 |
表 达 式 |
结 果 |
|---|---|---|
| 正值：从0开始计数 |
|
|
| 切片：获取部分元素 |
|
|
| 负值：从右向左计数 |
|
|
使用max()和min()函数，查找元组中的最大值和最小值。这些函数使我们能够获取更多相关数据的信息。我们来看以下示例。
>>> numbers = (50, 80,98, 110.5, 75, 150.58)
>>> print(max(numbers))
150.58
>>>上面使用max()可以获取元组中的最大值。相似地，使用min()可以获取元组中的最小值，如下所示。
>>> numbers = (50, 80,98, 110.5, 75, 150.58)
>>> print(min(numbers))
50
>>>现在就得到了最小值。
集合（set）是无序的元素序列，并且元素不会重复，即每个元素都是唯一的。集合的一个基本用途是判断元素是否已经存在并消除重复条目。集合对象支持数学运算，例如求并集、交集、差集和对称差集。我们可以使用花括号（{}）或set()函数创建一个集合，其中set()函数用于创建空集。
以下是一个简短的示例代码。
>>> fruits = {'Mango', 'Apple', 'Mango', 'Watermelon', 'Apple', 'Orange'}
>>> print (fruits)
{'Orange', 'Mango', 'Apple', 'Watermelon'}
>>> 'Orange' in fruits
True
>>> 'Onion' in fruits
False
>>>
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a
{'d', 'c', 'r', 'b', 'a'}
>>> a – b
{'r', 'd', 'b'}
>>> a | b
{'d', 'c', 'r', 'b', 'm', 'a', 'z', 'l'}
>>> a & b
{'a', 'c'}
>>> a ^ b
{'r', 'd', 'b', 'm', 'z', 'l'}Python的集合推导式如下。
>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'r', 'd'}字典（dictionary）是Python内置数据类型，它由键值对组成，并用花括号括起来。字典是无序的，并且由键索引，其中每个键必须是唯一的，并且键必须是不可变类型。如果一个元组仅包含字符串、数字或元组，则它也可以用作键。
我们只需要一对花括号就可以创建一个空字典：{}。字典的主要操作是存储一个值，并且用一个键与之对应。访问时，我们可以通过键提取值，用del关键字可以删除键值对。如果对已存在的键赋予新值，与该键关联的旧值则会消失。而尝试对不存在的键提取值就会报错。以下是一个使用字典的示例代码。
>>> student = {'Name':'John', 'Age':25}
>>> student['Address'] = 'Mumbai'
>>> student
student = {'Name':'John', 'Age':25, 'Address':'Mumbai'}
>>> student['Age']
25
>>> del student['Address']
>>> student
student = {'Name':'John', 'Age':25}
>>> list(student.keys())
['Name', 'Age']
>>> sorted(student.keys())
['Age', 'Name']
>>> 'Name' in student
True
>>> 'Age' not in student
False我们也可以用字典推导式创建字典。
>>> {x: x**2 for x in (4, 6, 8)}
{4: 16, 6: 36, 8: 64}当键是简单的字符串时，使用参数指定键值对会更容易。
>>> dict(John=25, Nick=27, Jack=28)
{'Nick': 27, 'John': 25, 'Jack': 28}本节我们将学习解析参数，以及用于解析参数的模块。
通常我们可以在命令行中输入其他参数，使之随程序启动。Python程序启动时也可以接收命令行参数。
$ python program_name.py img.jpg这里，program_name.py和img.jpg是参数。
如表1-8所示，我们可以使用模块来获取命令行参数。
表1-8 命令行参数模块
| 模 块 |
用 途 |
Python版本 |
|---|---|---|
|
|
已弃用 |
|
|
|
所有参数都在 |
所有版本 |
|
|
构建命令行接口 |
|
|
|
自动生成命令行接口（CLI） |
所有版本 |
|
|
创建CLI接口 |
|
sys模块用于访问命令行参数。len（sys.argv）可以显示参数的数量，str（sys.argv）可以输出所有参数。我们来看以下示例代码。
01.py
import sys
print('Number of arguments:', len(sys.argv))
print('Argument list:', str(sys.argv))输出如下。
Python3 01.py img
Number of arguments 2
Arguments list: ['01.py', 'img']当我们需要在条件为真时执行某代码块，可以使用判断语句。if...elif...else语句在Python中用于判断。
以下是if语句的语法。
if test_expression:
statement(s)这里，程序会判断test_expression，并且只有在test_expression为True时才执行statement(s)。如果test_expression为False，则不执行语句。
在Python中，if语句块由缩进控制。语句块主体以缩进的行开始，以第一个未缩进的行结束。我们来参考以下示例代码。
a = 10
if a > 0:
print(a, "is a positive number.")
print("This statement is always printed.")
a = -10
if a > 0:
print(a, "is a positive number.")输出如下。
10 is a positive number.
This statement is always printed.对于if…else语句，只有当if条件为False时才会执行else语句块。我们来参考以下代码。
if test_expression:
if block
else:
else blockif…else语句首先判断test_expression，仅当if条件为True时才执行if语句块。如果条件为False，则执行else语句块。缩进用于区分不同语句块。我们来参考以下代码。
a = 10
if a > 0:
print("Positive number")
else:
print("Negative number")输出如下。
Positive numberelif语句可以检查更多表达式是否为真，只要值为True，就会执行对应的代码块。我们参考以下代码。
if test_expression:
if block statements
elif test expression:
elif block statements
else:
else block statementselif是else if的缩写，它可以检查多个表达式。如果if语句中的条件为False，则它检查下一个elif块的条件是否为True，以此类推。如果所有条件都为False，则执行else语句块。
无论什么条件，程序一次只执行if...elif...else中的一个语句块。if语句块只能包含一个else块，但可以包含多个elif块。我们来参考以下代码。
a = 10
if a > 50:
print("a is greater than 50")
elif a == 10:
print("a is equal to 10")
else:
print("a is negative")输出如下。
a is equal to 10Python提供两种循环，以在脚本中编写循环结构语句。
for循环。while循环。下面我们学习for循环和while循环。
for循环为序列或可迭代对象中的每个元素依次执行for语句块中的语句。我们来参考以下语法。
for i in sequence:
for loop body迭代时，变量i会一次获取序列内的一个元素。循环语句会持续执行，直到序列中的最后一项，如图1-1所示。
图1-1 for循环流程
我们来参考以下代码。
numbers = [6, 5, 3, 8, 4, 2, 5, 4, 11]
sum = 0
for i in numbers:
sum = sum + i
print("The sum is", sum)输出如下。
The sum is 6
The sum is 11
The sum is 14
The sum is 22
The sum is 26
The sum is 28
The sum is 33
The sum is 37
The sum is 48Python的range()函数可以用于生成一串数字。例如，range(10)将生成0～9共10个数字。
我们还可以在range()函数中设置起始、结束和步长参数。
range(start, stop, step size)
Step size defaults to 1 if not provided.
For loop example using range() function:如果没有设置步长参数，则默认为1。
for循环可以搭配range()函数使用。
for i in range(5):
print("The number is", i)输出如下。
The number is 0
The number is 1
The number is 2
The number is 3
The number is 4while也是一种循环语句。只要判断的表达式为True，它就会持续执行一段代码。当我们不知道迭代具体执行多少次时，可以使用while循环。
while test_expression:
while body statementswhile循环首先判断test_expression，仅当test_expression为True时，才会执行while语句块。在一次迭代之后，循环会再次判断test_expression并继续以上流程，直到test_expression的结果为False，如图1-2所示。
图1-2 while循环流程
以下是while循环的示例代码。
a = 10
sum = 0
i= 1
while i <= a:
sum = sum + i
i = i + 1
print("The sum is", sum) 输出如下。
The sum is 1
The sum is 3
The sum is 6
The sum is 10
The sum is 15
The sum is 21
The sum is 28
The sum is 36
The sum is 45
The sum is 55在Python中，迭代器（iterator）是一个可以迭代的对象。同时，它也是一个能返回数据的对象，一次返回一个元素。Python 的迭代器对象实现了__iter__()和__next__()两个方法。大多数情况下，迭代器是用循环、生成器（generator）和生成式实现的。
下面的示例代码使用next()函数遍历所有元素。在到达末尾且没有更多数据能返回时，就会触发StopIteration错误。
numbers = [10, 20, 30, 40]
numbers_iter = iter(numbers)
print(next(numbers_iter))
print(next(numbers_iter))
print(numbers_iter.__next__())
print(numbers_iter.__next__())
next(numbers_iter)输出如下。
10
20
30
40
Traceback (most recent call last):
File "sample.py", line 10, in <module>
next(numbers_iter)
StopIteration我们可以使用Python生成器来创建迭代器。在Python中，生成器是一个可以返回对象的函数，程序可以对其进行迭代。
在Python中我们可以很容易创建生成器。使用yield语句而不是return语句来定义函数，只要函数至少包含一个yield语句，就是生成器函数。yield和return语句都可以从函数返回值。参考以下代码。
def my_gen():
n= 1
print('This is printed first')
yield n
n += 1
print('This is printed second')
yield n
n += 1
print('This is printed at last')
yield n
for item in my_gen():
print(item)输出如下。
This is printed first
1
This is printed second
2
This is printed at last
3函数是执行特定功能的一组语句。使用函数有助于将程序分解为更小的部分，也可以使程序更有条理，因为它提高了代码的可重用性，避免重复编写代码。我们来参考以下语法。
def function_name(parameters):
statement(s)参考以下代码。
def welcome(name):
print("Hello " + name + ", Welcome to Python Programming !")
welcome("John")输出如下。
Hello John, Welcome to Python Programming !return语句用于退出函数。我们来参考以下语法。
return [expression_list]此语句可以包含一个用于返回值的表达式。如果没有表达式，则该函数将返回None，如下所示。
def return_value(a):
if a >= 0:
return a
else:
return –a
print(return_value(2))
print(return_value(-4))输出如下。
2
4在Python中，匿名函数是一个没有名称的函数，也叫lambda函数，因为它是使用关键字lambda定义的。当我们需要一个临时函数时，就可以使用lambda函数。
lambda函数可以与内置函数一起使用，例如filter()函数和map()函数。
filter()函数只接收一个可迭代对象作为输入，并返回一个元素列表。
以下是使用filter()函数的示例代码。
numbers = [10, 25, 54, 86, 89, 11, 33, 22]
new_numbers = list(filter(lambda x: (x%2 == 0) , numbers))
print(new_numbers)输出如下。
[10, 54, 86, 22]在此示例中，filter()函数将lambda函数和一个列表作为参数。
map()函数在接收指定函数后返回一个结果列表。以下是使用map()函数的示例代码。
my_list = [1, 5, 4, 6, 8, 11, 3, 12]
new_list = list(map(lambda x: x * 2 , my_list))
print(new_list)输出如下。
[2, 10, 8, 12, 16, 22, 6, 24]这里，map()函数将lambda函数和一个列表作为参数。
模块是只包含 Python 代码和定义的文件。包含 Python 代码的文件（例如，sample.py）被称为模块，其模块名称为sample。使用模块时，我们可以将较大的程序分解为较小的、有组织的程序。模块的一个重要特征是可重用性。我们可以在模块中写入定义函数的代码，并且只在需要的时候才导入它，这样可以不用将常用函数的代码复制到各处。
现在我们创建一个模块。首先创建两个脚本：sample.py和add.py。接下来在sample.py中导入定义函数的代码，如下所示。
sample.py
def addition(num1, num2):
result = num1 + num2
return result这里的sample模块定义了一个addition()函数，该函数接收两个数字并返回它们的和。现在我们创建了一个模块，之后可以在任何Python程序中导入它。
创建模块之后，我们就该学习如何导入该模块了。在前面的示例中我们已经创建了一个sample模块。如下所示，在add.py脚本中导入sample模块。
add.py
import sample
sum = sample.addition(10, 20)
print(sum)输出如下。
30本章介绍了Python脚本语言。首先，我们了解了如何安装Python和各种工具，还了解了Python解释器，并学习了如何使用它。然后，我们学习了Python支持的数据类型，如变量、数值和字符串等，还学习了判断语句和循环语句。之后学习了函数，以及如何在脚本中使用函数。最后学习了模块，以及如何创建和导入模块。
在第2章中，我们将学习Python调试技术、错误处理（异常处理）、调试工具、调试基本的程序崩溃、分析和计时程序，以及如何使程序运行得更快。
1．什么是迭代器和生成器？
2．列表是可变的还是不可变的？
3．Python中的数据结构是什么？
4．如何访问列表中的值？
5．什么是模块？
