01.md

一、Python 脚本概述

Python 是一种脚本语言，由 Guido van Rossum 于 1991 年创建，用于各种应用程序，如游戏开发、GIS 编程、软件开发、web 开发、数据分析、机器学习和系统脚本。

Python 是一种具有动态语义的面向对象高级编程语言。Python 主要是一种解释语言。Python 用于快速应用程序开发，因为它具有所有用于开发的高级特性。

Python 简单易学，因为它的语法使程序更具可读性。因此，程序维护成本较低。

Python 还有一个更重要的特性，就是导入模块和包。此功能允许代码重用。Python 解释器很容易理解。我们可以在其中逐个编写完整的代码，因为 Python 是一种解释语言，所以代码可以逐行执行。Python 还提供了大量用于高级功能的库。

本章将涵盖以下主题：

• Python 脚本
• 安装和使用 Python 和各种工具
• 变量、数字和字符串
• Python 支持的数据结构以及如何在脚本中使用所有这些概念
• 决策；就是,这个"T0"声明
• 循环语句；也就是说，for和while循环
• 功能
• 模块

技术要求

在开始阅读本书之前，您应该了解 Python 编程的基础知识，例如基本语法、变量类型、元组数据类型、列表字典、函数、字符串和方法。两个版本，3.7.2 和 2.7.15，可在python.org/downloads/上获得。在本书中，我们将使用 3.7 版进行代码示例和软件包安装。

本章的示例和源代码可在 GitHub 存储库中找到：https://github.com/PacktPublishing/Mastering-Python-Scripting-for-System-Administrators- 。

为什么是 Python？

Python 有一系列用于开源数据分析工具、web 框架、测试等的库。Python 是一种可在不同平台（Windows、Mac、Linux 和嵌入式 Linux H/W 平台，如 Raspberry Pi）上使用的编程语言。它用于开发桌面和 web 应用程序。

如果使用 Python，开发人员可以用更少的行编写程序。原型制作非常快，因为 Python 在解释器系统上运行。Python 可以用面向对象、过程或函数的方式来处理。

Python 可以执行各种任务，例如创建 web 应用程序。它与软件一起用于创建工作流；它连接到数据库系统，处理文件，处理大数据，并执行复杂的数学运算。

Python 语法与其他编程语言的比较

用 Python 编写的代码可读性很高，因为它类似于英语。为了完成命令，Python 使用新行。

Python 有一个很好的特性：缩进。使用缩进，我们可以定义决策语句、循环（如for和while循环）、函数和类的范围。

Python 安装

在本节中，我们将学习在不同平台（如 Linux 和 Windows）上安装 Python。

Linux 平台上的安装

大多数 Linux 发行版的默认安装中都有 Python 2。其中一些还包括 Python3。

要在基于 Debian 的 Linux 上安装python3，请在终端中运行以下命令：

sudo apt install python3

要在centos上安装python3，请在终端中运行以下命令：

sudo yum install python3

如果无法使用上述命令安装 Python，请从下载 Pythonhttps://www.python.org/downloads/ 并按照说明进行操作。

Windows 平台上的安装

要在 Microsoft Windows 中安装 Python，您必须从python.org下载可执行文件并进行安装。从下载python.exehttps://www.python.org/downloads/ 并选择要安装在 PC 上的 Python 版本。然后，双击下载的exe并安装 Python。在安装向导上，有一个复选框显示将 Python 添加到路径。选中此复选框，然后按照说明安装python3。

安装和使用 pip 安装软件包

在 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

在 Mac 上安装

要安装python3，首先我们必须在系统上安装brew。要在您的系统上安装brew，请运行以下命令：

/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

通过运行前面的命令。brew将被安装。现在我们将使用brew安装python3：

brew install python3

安装 Jupyter 笔记本电脑

要安装 Jupyter 笔记本，请下载 Anaconda。

安装下载的 Anaconda 版本，并按照向导上的说明进行操作。

使用pip安装 Jupyter：

pip install jupyter

在 Linux 中，pip install jupyter将为python 2安装 Jupyter。如果要为python 3安装jupyter，请运行以下命令：

pip3 install jupyter

安装和使用虚拟环境

现在我们将了解如何安装虚拟环境以及如何激活它

要在 Linux 上安装虚拟环境，请执行以下步骤：

1. 首先检查pip是否已安装。我们将为python3安装pip：

sudo apt install python3-pip

2. 使用pip3安装虚拟环境：

sudo pip3 install virtualenv

3. 现在我们将创建虚拟环境。你可以给它取任何名字；我称之为pythonenv：

virtualenv pythonenv

4. 激活您的虚拟环境：

source venv/bin/activate

5. 工作完成后，您可以使用以下命令停用virtualenv：

deactivate

在 Windows 中，运行pip install virtualenv命令安装虚拟环境。安装virtualenv的步骤与 Linux 相同。

安装 Geany 和 PyCharm

从下载 Geanyhttps://www.geany.org/download/releases 下载所需的二进制文件。安装时请遵循说明。

从下载 PyCharmhttps://www.jetbrains.com/pycharm/download/#section=windows 并按照说明进行操作。

Python 解释器

Python 是一种解释语言。它有一个称为 Python 解释器或 Python shell 的交互式控制台。这个 shell 提供了一种无需创建脚本即可逐行执行程序的方法。

您可以在 Python 交互控制台中访问 Python 的所有内置函数和库、已安装的模块和命令历史记录。这个控制台为您提供了探索 Python 的机会。准备好后，您可以将代码粘贴到脚本中。

Python 和 Bash 脚本之间的区别

在本节中，我们将学习 Python 和 Bash 脚本之间的区别。区别如下：

• Python 是一种脚本语言，而 Bash 是一种用于输入和执行命令的 shell
• 使用 Python 处理较大的程序更容易
• 在 Python 中，您可以通过从导入的模块调用一行函数来完成大多数事情

启动交互式控制台

我们可以从任何已经安装了 Python 的计算机上访问 Python 的交互控制台。运行以下命令以启动 Python 的交互式控制台：

$ python

这将启动默认的 Python 交互控制台。

在 Linux 中，如果我们在终端中写入Python，则python2.7控制台启动。如果要启动python3控制台，则在终端中输入python3并按输入。

在 Windows 中，当您在命令提示符下输入Python时，将启动下载的 Python 版本的控制台。

使用 Python 交互控制台编写脚本

Python 交互控制台从>>> prefix开始。此控制台将接受 Python 命令，您将在>>> prefix之后编写这些命令。请参阅以下屏幕截图：

现在，我们将看到如何为变量赋值，如下例所示：

>>> name = John

在这里，我们已经为name变量分配了一个字符值John，我们按下回车并收到一个带有>>> prefix的新行：

>>> 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循环函数），解释器使用三个点（...作为行继续的辅助提示。要走出这些行，您必须按两次回车键。现在我们来看下面的示例：

>>> 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块中的语句是缩进的。如果不使用缩进，将出现以下错误：

>>> 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 解释器导入模块

如果要导入任何模块，Python 解释器将检查该模块是否可用。您可以使用import语句来实现这一点。如果该模块可用，则按回车键后会看到>>>前缀。这表示执行成功。如果该模块不存在，Python 解释器将显示错误：

>>> import time
>>>

导入time模块后，得到>>>前缀。这意味着模块已存在，并且此命令已成功执行：

>>> import matplotlib

如果该模块不存在，则会出现Traceback错误：

File "<stdin>", line 1, in <module>
ImportError: No module named 'matplotlib'

所以这里，matplotlib不可用，所以它给出了一个错误：ImportError: No module named 'matplotlib'.

要解决此错误，我们必须安装matplotlib，然后再次尝试导入matplotlib。安装matplotlib后，您应该能够导入模块，如下所示：

>>> import matplotlib
>>>

退出 Python 控制台

我们可以通过两种方式使用 Python 控制台：

• 键盘快捷键：Ctrl+D
• 使用quit()或exit()功能

键盘快捷键

键盘快捷键*Ctrl+D、*将为您提供以下代码：

>>> val1 = 5000
>>> val2 = 2500
>>>
>>> val3 = val1 - val2
>>> print (val3)
2500
>>>
student@ubuntu:~$

使用 quit（）或 exit（）函数

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
Here are assigning 100 to the variable n. Now, we are going to increase the value of n by 1:
>>> n = n + 1
>>> print(n)
101
>>>

以下是一个在执行过程中可以更改的变量类型示例：

a = 50 # data type is implicitly set to integer
a = 50 + 9.50 # data type is changed to float
a = "Seventy" # and now it will be a string

Python 负责不同数据类型的表示；也就是说，每种类型的值都存储在不同的内存位置。变量将是一个名称，我们将为其赋值：

>>> msg = 'And now for something completely different'
>>> a = 20
>>> pi = 3.1415926535897932

这个例子有三个赋值。第一个赋值是对名为msg的变量的字符串赋值。第二个赋值是对名为a的变量的整数赋值，最后一个赋值是pi值赋值。

变量的类型是它引用的值的类型。请看以下代码：

>>> type(msg)
<type 'str'>
>>> type(a)
<type 'int'>
>>> type(pi)
<type 'float'>

为变量创建和赋值

在 Python 中，不需要显式声明变量来保留内存空间。因此，每当您为变量赋值时，声明都会自动完成。在 Python 中，等号=用于为变量赋值。

考虑下面的例子：

#!/usr/bin/python3
name = 'John'
age = 25
address = 'USA'
percentage = 85.5
print(name)
print(age)
print(address)
print(percentage)

Output:
John
25
USA
85.5

在上例中，我们将John分配给name变量，25分配给age变量，USA分配给address变量，85.5分配给percentage变量。

我们不必像在其他语言中那样首先声明它们。因此，查看值解释器将获得该变量的类型。在上例中，name和address为strings，年龄为整数，百分比为浮动类型。

相同值的多个赋值可以按如下方式进行：

x = y = z = 1

在前面的示例中，我们创建了三个变量，并为它们分配了一个整数值1，所有这三个变量都将被分配到相同的内存位置。

在 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型。

In Python, the division (/) operation always returns a float value. The floor division (//) gets an integer result. The % operator is used to calculate the remainder.

考虑下面的例子：

>>> 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

如果一个变量没有任何值，我们仍然尝试使用它，那么解释器将显示一个错误：

>>> 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 = 25

del语句用于删除单个或多个变量。请参阅以下示例：

del num
del num_a, num_b

数字类型转换

在某些情况下，需要将数字从一种类型显式转换为另一种类型，以满足某些要求。Python 在一个表达式中内部执行此操作

• 键入int(a)将a转换为整数
• 键入float(a)将a转换为浮点数
• 输入complex(a)将a转换成实部x虚部zero的复数
• 输入complex(a, b)将a和b转换为实部a和虚部b的复数。a和b是数值表达式

串

与数字一样，字符串也是 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

Output:
e
l

串联（+）和重复（*）

接下来是连接和重复。请参阅以下代码：

>>> 3 * 'hi' + 'hello'
'hihihihello'

在前面的示例中，我们正在进行字符串连接和重复。3 * 'hi'表示hi被打印3次，使用+符号，我们在hi旁边加入hello字符串。

我们只需将两个字符串并排写入，就可以自动将它们连接起来。这两个字符串必须用引号括起来，如下所示：

>>> 'he' 'llo'
'hello'

当您有长字符串并且想要打断它们时，此功能非常有用。以下是一个例子：

>>> str = ('Several strings'
... 'joining them together.')
>>> str
'Several strings joining them together.'

串切片

字符串支持切片，这意味着从字符串中按指定范围获取字符。让我们看看下面的例子。注意，总是包含起始索引值，并且总是排除结束值。

考虑一个字符串，

>>> str[0:2]
'Pr'
>>> str[2:5]
'ogr'

现在，省略的第一个索引的默认值为零，如示例所示：

>>> 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])

Output:
str1[0]: H
str2[1:5]: bjec

更新字符串

我们可以通过将新值重新分配给指定的索引来更新字符串。请参阅以下示例：

#!/usr/bin/python3
str1 = 'Hello Python!'
print ("Updated String: - ", str1 [:6] + 'John')

Output:
Updated String: - Hello John

转义字符

Python 支持不可打印的转义字符，并且可以用反斜杠表示。转义字符可以在单引号和双引号字符串中进行解释：

| 符号 | 十六进制字符 | 说明 | | a | 0x07 | 警铃 | | b | 0x08 | 退格 | | cx | | 控制-x | | n | 0x0a | 新线 | | C-x | | 控制-x | | e | 0x1b | 逃跑 | | f | 0x0c | 饲料 | | s | 0x20 | 空间 | | M-C-x | | 元控制-x | | x | | 字符x | | nnn | | 八进制表示法，n在 0.7 范围内 | | r | 0x0d | 回车 | | xnn | | 十六进制表示法，其中n在0.9、a.f或A.F范围内 | | t | 0x09 | 标签 | | v | 0x0b | 垂直选项卡 |

特殊字符串运算符

下表显示了字符串的特殊运算符。考虑到，T0 是 T1，而 T2 是：

| 操作员 | 说明 | 示例 | | + | 串联：在运算符的任一侧添加值 | a + b将给出HelloWorld | | [] | Slice：给出给定索引中的字符 | a[7]将给出r | | [ : ] | 范围切片：给出给定范围中的字符 | a[1:4]将给出ell | | * | 重复：创建新字符串，连接同一字符串的多个副本 | a*2将给出HelloHello | | not in | 成员资格：如果给定字符串中不存在字符，则返回true | Z不在will给予1中 | | in | 成员资格：如果给定字符串中存在字符，则返回true | a中的H将给出1 | | % | 格式化：执行字符串格式化 | |

%字符串格式运算符

%是 Python 中的字符串格式运算符。请参阅以下示例：

#!/usr/bin/python3
print ("Hello this is %s and my age is %d !" % ('John', 25))

Output:
Hello this is John and my age is 25 !

下表显示了与%一起使用的符号列表：

| 编号。 | 格式符号及转换 | | 1. | %c-字符 | | 2. | %s-格式化前通过str()进行字符串转换 | | 3. | %i-有符号十进制整数 | | 4. | %d-有符号十进制整数 | | 5. | %u-无符号十进制整数 | | 6. | %o-八进制整数 | | 7. | %x–十六进制整数（小写字母） | | 8. | %X-十六进制整数（大写字母） | | 9 | %e-指数表示法（小写e） | | 10 | %E-指数表示法（大写为E） | | 11 | %f-浮点实数 |

Python 中的三重引号

Python 的字符串三重引号功能用于跨越多行，包括换行符和制表符。三重引号的语法由三个连续的单引号或双引号组成。请参阅以下代码：

#!/usr/bin/python3

para_str = """ Python is a scripting language which was created by
Guido van Rossum in 1991, t 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)

它产生以下输出。请注意选项卡和换行符：

Output:
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的数据结构，这是一个可变的有序元素序列。该列表中的每个元素称为项。通过在方括号[ ]之间插入值来定义列表。list的每个元素都有一个数字，我们称之为位置或索引。指数从零开始；也就是说，第一个索引为零，第二个索引为 1，依此类推。我们可以对列表执行以下操作：索引、切片、添加、乘法和检查成员资格。

Python 内置的length函数返回该列表的长度。Python 还具有查找list最大和最小项的功能。列表可以是编号列表、字符串列表或混合列表。

以下是创建列表的代码：

l = list()
numbers = [10, 20, 30, 40]
animals = ['Dog', 'Tiger', 'Lion']
list1 = ['John', 5.5, 500, [110, 450]]

在这里，我们创建了三个列表：第一个是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] []

访问列表中的值

我们可以使用索引值访问列表中的值。我们将在[ and ]中指定索引编号。索引从0开始。请参阅给定的示例：

#!/usr/bin/python3
cities = ['Mumbai', 'Bangalore', 'Chennai', 'Pune']
numbers = [1, 2, 3, 4, 5, 6, 7 ]
print (cities[0])
print (numbers[1:5])

Output:
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])

Output:
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)

Output:
Before deleting: ['Mumbai', 'Bangalore', 'Chennai', 'Pune']
After deleting: ['Mumbai', 'Bangalore', 'Pune']

基本列表操作

有五种基本的列表操作：

• 串联
• 重复
• 长
• 会员
• 迭代

| 说明 | 表达式 | 结果 | | 串联 |  [30, 50, 60] + ['Hello', 75, 66] |  [30,50,60,'Hello',75,66] | | 会员资格 |  45 in [45,58,99,65] |  True | | 迭代 |  for x in [45,58,99] : print (x,end = ' ') |  45 58 99 | | 重复 |  ['Python'] * 3 |  ['python', 'python', 'python'] | | 长度 |  len([45, 58, 99, 65]) |  4 |

列表操作

在本节中，我们将学习基本的列表操作：串联和重复。

+运算符连接列表：

>>> 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']

索引、切片和矩阵

列表索引的工作方式与字符串索引相同。可使用index访问值。如果您试图读取或写入一个不存在的元素，则会得到IndexError。如果索引有负值，则从列表末尾向后计数

现在，我们将创建一个名为cities的列表，我们将看到索引操作：

cities = ['Mumbai', 'Bangalore', 'Chennai', 'Pune']

| 说明 | 表达式 | 结果 | | 索引从零开始 | cities[2] | 'Chennai' | | 切片：获取节 | cities[1:] | ['Bangalore', 'Chennai', 'Pune'] | | 否定：从右边数数 | cities[-3] | 'Bangalore' |

多元组

Python 的元组数据结构是不可变的，这意味着我们不能更改元组的元素。基本上，元组是由逗号分隔并用括号括起来的值序列( )。与列表一样，元组也是元素的有序序列：

>>> 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])

Output:
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)

Output:
('Mumbai', 'Bangalore', 'Chennai', 'Pune', 1, 2, 3, 4, 5, 6, 7)

删除元组元素

我们不能删除单个元组元素。因此，要显式删除整个元组，请使用del语句。请参阅以下示例：

#!/usr/bin/python3
cities = ('Mumbai', 'Bangalore', 'Chennai', 'Pune')
print ("Before deleting: ", cities)
del cities
print ("After deleting: ", cities)

Output:
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

基本元组运算

与列表一样，有五种基本元组操作：

• 串联
• 重复
• 长
• 会员
• 迭代

| 说明 | 表达式 | 结果 | | 迭代 |  for x in (45,58,99) : print (x,end = ' ') |  45 58 99 | | 重复 |  ('Python') * 3 |  ('python', 'python', 'python') | | 长度 |  len(45, 58, 99, 65) |  4 | | 串联 |  (30, 50, 60) + ('Hello', 75, 66) |  (30,50,60,'Hello',75,66) | | 会员资格 |  45 in (45,58,99,65) |  True |

索引、切片和矩阵

元组索引的工作方式与列表索引相同。可以使用索引访问值。如果尝试读取或写入不存在的元素，则会得到IndexError。如果索引有负值，则从列表末尾向后计数

现在，我们将创建一个名为cities的元组，并执行一些索引操作：

cities = ('Mumbai', 'Bangalore', 'Chennai', 'Pune')

| 说明 | 表达式 | 结果 | | 索引从零开始 | cities[2] | 'Chennai' | | 切片：获取节 | cities[1:] | ('Bangalore', 'Chennai', 'Pune') | | 否定：从右边数数 | cities[-3] | 'Bangalore' |

max（）和 min（）

使用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()，而不是{}。

下面是一个简短的演示：

>>> 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'}

辞典

字典是 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 程序可以从命令行参数开始。让我们看一个例子：

$ python program_name.py img.jpg

这里，program_name.py和img.jpg是参数。

现在，我们将使用模块获取参数：

| 模块 | 使用 | Python 版本 | | optparse | 不赞成 | < 2.7 | | sys | sys.argv中的所有参数（基本） | 全部的 | | argparse | 构建命令行界面 | >= 2.3 | | fire | 自动生成命令行界面（CLIs） | 全部的 | | docopt | 创建 CLIs 接口 | >= 2.5 |

Sys.argv

sys模块用于访问命令行参数。len(sys.argv)函数包含参数的数量。要打印所有参数，只需执行str(sys.argv)。让我们看一个例子：

01.py
import sys
print('Number of arguments:', len(sys.argv))
print('Argument list:', str(sys.argv))

Output:
Python3 01.py img
Number of arguments 2
Arguments list: ['01.py', 'img']

决策

当我们想要在条件为true的情况下执行代码块时，就需要做出决策。if...elif...else语句在 Python 中用于决策。

Python if 语句语法

以下是if语句的语法：

if test_expression:
 statement(s)

这里，程序计算测试表达式，并且仅当文本表达式为true时才会执行statement(s)。如果文本表达式为false，则不执行statement(s)。

在 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.")

Output:
10 is a positive number.
This statement is always printed.

Python if…else 语句语法

在本节中，我们将了解if..else语句。只有当if条件为false时，才会执行else块。请参阅以下语法：

if test expression:
 if block
else:
 else block

if..else语句对测试表达式求值，只有当测试条件为true.时才会执行if的主体，如果条件为false,则执行else的主体。压痕用于分离块。请参阅以下示例：

a = 10
if a > 0:
 print("Positive number")
else:
 print("Negative number")

Output:
Positive number

Python if…elif…else 语句

elif语句检查多个语句的true值。每当该值的计算结果为true时，就会执行该代码块。请参阅以下语法：

if test expression:
 if block statements
elif test expression:
 elif block statements
else:
 else block statements

elif是else if的缩写。它允许我们检查多个表达式。如果if语句中写入的条件为false，则会检查下一个elif块的条件，依此类推。如果所有条件均为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")

Output:
a is equal to 10

循环

为了处理脚本中的所有循环需求，Python 支持两个循环：

• for loop
• while loop

现在，我们将学习关于for loop和while loop的内容。

for 循环

for loop迭代序列的每一项或任何其他 iterable 对象，每次都将执行 for 块中的语句。请参阅以下语法：

for i in sequence:
 for loop body

这里，i是在每次迭代中获取序列中项目值的变量。这个循环一直持续到序列中的最后一项。下图对此进行了说明：

请参阅以下示例：

numbers = [6, 5, 3, 8, 4, 2, 5, 4, 11]
sum = 0
for i in numbers:
 sum = sum + i
 print("The sum is", sum)

Output:
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 48

range（）函数

Pythonrange()函数将生成一个数字序列。例如，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:

让我们来看一个例子：

for i in range(5):
 print("The number is", i)

Output:
The number is 0
The number is 1
The number is 2
The number is 3
The number is 4

while 循环

while是一个循环语句，它将在代码块上迭代，直到输入的测试表达式为true。当我们不知道迭代将进行多少次时，我们使用这个循环。请参阅以下语法：

while test_expression:
 while body statements

在 while 循环中，首先我们将检查测试表达式。只有当测试表达式为true时，才会执行while块。在一次迭代后，将再次检查表达式，此过程将继续，直到test_expression计算为false。下图对此进行了说明：

以下是while循环的一个示例：

a = 10
sum = 0
i = 1
while i <= a:
 sum = sum + i
 i = i + 1
 print("The sum is", sum)

Output:
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 中，迭代器是可以迭代的对象。它是一个每次返回一个元素的数据的对象。Python 的迭代器对象实现了两种方法，__iter__()和__next__()。大多数情况下，迭代器是在循环、生成器和理解中实现的。

在下面的示例中，我们使用的是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)

Output:
10
20
30
40
Traceback (most recent call last):
 File "sample.py", line 10, in <module>
 next(numbers_iter)
StopIteration

发电机

我们可以使用 Python 生成器创建迭代器。在 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)

Output:
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")

Output:
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))

Output:
2
4

匿名函数

在 Python 中，匿名函数是一个没有名称的函数，称为lambda函数，因为它是使用关键字lambda定义的。只要在短时间内需要函数，我们就使用这些函数。

Lambda 函数与内置函数一起使用，如filter()和map()。

函数的作用是：返回一个元素列表，并且只有一个 iterable 作为输入。下面显示了使用filter():的示例

numbers = [10, 25, 54, 86, 89, 11, 33, 22]
new_numbers = list(filter(lambda x: (x%2 == 0) , numbers))
print(new_numbers)

Output:
[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)

Output:
[2, 10, 8, 12, 16, 22, 6, 24]

这里，map()函数接受一个lambda函数和一个列表。

模块

模块只是包含 Python 语句和定义的文件。包含 Python 代码（例如，sample.py）的文件称为模块，其模块名为sample。使用模块，我们可以将较大的程序分解为较小且有组织的程序。模块的一个重要特性是可重用性。您可以在模块中定义函数，并在需要时导入它们，而不是复制不同程序中最常用函数的定义。

让我们创建一个模块并导入它。我们将创建两个脚本：sample.py和add.py。我们将在我们的add.py中导入一个示例模块。现在，将以下代码保存为sample.py。让我们来看看下面的例子：

sample.py
def addition(num1, num2):
 result = num1 + num2
 return result

在这里，我们在名为sample的模块中定义了一个addition()函数。函数接受两个数字并返回它们的和。现在我们已经创建了一个模块。您可以在任何 Python 程序中导入它。

导入模块

现在，在创建模块之后，我们将学习如何导入该模块。在前面的示例中，我们创建了一个示例模块。现在我们将在add.py script中导入示例模块：

add.py
import sample
sum = sample.addition(10, 20)
print(sum)

Output:
30

总结

在本章中，我们概述了 Python 脚本语言。我们已经学习了如何安装 Python 和各种工具。我们还学习了 Python 解释器以及如何使用它。我们学习了 Python 支持的数据类型、变量、数字和字符串、决策语句以及 Python 中的循环语句。我们还学习了函数以及如何在脚本和模块中使用它们，以及如何创建和导入它们。

在下一章调试和评测 Python 脚本中，您将学习 Python 调试技术、错误处理（异常处理）、调试器工具、调试基本程序崩溃、评测和计时程序以及加快程序运行速度。

问题

1. 什么是迭代器和生成器？
2. 列表是可变的还是不变的？
3. Python 中的数据结构是什么？
4. 如何访问列表中的值？
5. 什么是模块？

进一步阅读

所有 Python 文档都可以在以下站点上获得：www.Python.org。

您还可以查看以下书籍，刻苦学习 Python和Python 字节，了解 Python 的基础知识。