StudyTonight-Python-中文教程-一-
StudyTonight Python 中文教程（一）
原文：StudyTonight
Python
基础
了解 Python 并设置 Python 开发环境
原文：https://www.studytonight.com/python/getting-started-with-python
欢迎光临！这是你学习 Python 编程语言的第一步。或者，你已经知道这种语言了吗，来这里只是为了修正你的概念？。你属于哪一类并不重要，因为我们将从基础开始教你 Python。
一个有经验的程序员可能有一个优势，那就是很快就能找到主题和课程，尽管我们建议您不要匆忙完成主题，因为 Python 虽然是一种普通的编程语言，但对程序员来说有一些好处，您不会想错过教程中的那些。
尽管有这么多麻烦，但没什么好担心的。你应该很高兴选择了最神奇最简单的教程来学习 Python。
为什么是 Python？
Python 被认为是最通用的编程语言之一。如果你有一点编程经验，那么你很快就会注意到区别。让我们来看看 Python 的特性。
Python 的特性
- 它有简单易用的语法。
- 它几乎可以在任何平台上运行，包括视窗、Linux 的所有发行版(Linux 的所有版本)、苹果 OS X、Unix 等。
- 您甚至可以将其他编程语言(如 C 、 C++ 等)与 python 结合起来，以实现两全其美。
- 它的大型标准库支持使现实生活中的编程变得容易得多。
- 除此之外，它是开源的，并且有大量的社区支持来积极地使用 Python 编程。
- 它是面向对象的(也叫 OO 编程或 OOP ) ，这使得它更适用于现实世界的应用编程。
- 此外，它不仅可以用来编写复杂的程序，还可以用来设计具有图形用户界面的应用。
- Python 是一门独立的语言，因为它是一个解释器，一行一行地执行 python 代码，这使得调试更加容易。但是 Python 编译是一个永无止境的讨论话题？嗯，技术上是这样的，从用户写的代码到字节码，然后字节码被送到解释器执行。这里有一个很好的 StackOverflow 讨论:Python 是解释的，还是编译的，还是两者都有？
- Python 有许多实现，如CPython(python 的标准实现) Jython (目标是与 java 编程语言集成)等。
就其语法的简单性而言，让我们看一个示例代码。考虑一个程序，其中您希望用户从键盘输入一些东西，并且您希望将该值保存在变量中。对于 C++ ，一种流行的编程语言，以下是您将如何编写它:
#include<iostream>
using namespace std;
int main(){
int x;
cin >> x;
return 0;
}
对于另一种流行的编程语言 Core Java ，它将是:
import java.util.Scanner;
class Test{
Scanner input = new Scanner(System.in);
public static void main(String args[]){
int x;
x = input.nextInt();
}
}
而在Python中，是(鼓声) :
x = input()
别开玩笑了。仅此而已。没有文件导入，没有大括号，没有分号，只有一行。现在真的没有必要去理解这段代码。它只是想向你展示 Python 是如何让程序员松一口气的。
在上面的代码中可以注意到的另一件事是，在 C++和 Java 的情况下，用户只能键入任意的integer作为变量x的输入，因为我们已经通过指定代码int x;将值x声明为整数。就 python 而言，程序员在声明变量时不必显式指定数据类型，Python 的编译器会根据分配给变量的值类型自行指定。
关于课程的一些事情
准确地说，目前有两个版本的 Python 可以在他们的官方网站上获得，即 Python 2.x 和 Python 3.x 。在本课程中，我们将讨论 Python 3.x
此外，Python 3.x 和 Python 2.x 之间没有太大的区别，主要的变化是打印任何东西的方式。这只是 Python 2.x 中的print，在 Python 3.x 中，他们把它变成了print()，是的，增加了括号。
Python 的应用
人们可以说，使用 Python 几乎可以做任何事情。
-
Web 应用 : Python 可以用来开发可伸缩、安全的 Web 应用。像 Django、Flask、金字塔等框架对于设计和开发基于网络的应用来说是惊人的。
-
计算机软件或桌面应用:由于 python 也可以用来开发 GUI，因此是开发桌面应用的绝佳选择。
Tk是一个开源的 widget 工具包，可以用 python 开发桌面应用。Kivy就是另一个这样的平台。 -
科学计算应用:python 以其惊人的计算能力和简单的语法被用于科学计算应用。像
SciPy和NumPy这样的 Python 库最适合科学计算。 -
AI 和 ML(人工智能和机器学习) : Python 处于向人工智能和机器学习范式转变的前沿。
-
图像处理 : Python 以其图像处理能力而闻名，包括逐像素遍历和分析任何图像。有许多 python 库可用于图像处理，例如:枕头、scikit-image 等。
从你可能已经在使用的东西开始:像 Instagram 、 Reddit 、 Mozilla 这样的网站，都是使用 Python 开发的。有各种各样的网络框架，像Django(最流行的一个)和Pyramid，基于 Python，可以用来开发现代的网络应用。
安装 Python
在您的 Windows 系统中设置 Python 环境的步骤:
-
根据您的电脑，下载最新版本的 32 位或 64 位 Python 3.x 。
-
Open Installer and follow these steps:
选中窗口中的选定选项后，单击下一步。
-
遵循这些步骤后，安装将开始。
-
您可以通过在 cmd 中键入
python -V来检查安装是否成功。如果它返回您已经安装的 Python 版本，那么恭喜您一切就绪。
如果你有一台 Macbook ，MacOS 预装了 Python 2.7.x，但是你不能更新版本或者在 Python 中添加模块 a >，因为这是操作系统所要求的。所以你应该下载 Python 3，在 Macbook 中设置虚拟环境。
如果你使用 Ubuntu 操作系统，它会预装 Python。
IDLE 默认 Python 集成开发环境简介
在本节中，您将熟悉整个教程系列中用来运行 python 代码的开发环境。这可能是学习时编写和执行 python 代码的最佳环境。此外，因为它与 Python 编译器捆绑在一起，所以不需要额外的安装。因此，如果您已经按照上一个教程中给出的安装步骤进行了安装，那么您的系统可能已经处于 IDLE 状态。
现在打开 IDLE 的时间到了，可以在 Windows/Mac/Linux 搜索栏输入 IDLE，应该会出现。
差不多就是这个样子。您可以看到光标在>>>之后闪烁。这是您将要编写代码的地方。此外，顶部还提到了 Python 的当前运行版本。
在 IDLE 中，我们一行一行地写代码。一条线可以处理一件事。您可以在该行中键入您想要的任何内容，然后按进入执行。IDLE 更像一个终端或命令提示符——你写一行，按 enter，它就执行了。
我们还可以创建 python 文件，其中包含完整的多行程序，也可以使用 IDLE 来执行它。python 脚本有一个扩展名.py。
Python 编译需要一些时间，它的编译速度并不快，从而将示例代码写在一个文件中，然后一遍又一遍地编译整个代码会变得繁琐，不适合初学者。当我们打开 IDLE 时，会创建一个会话，将您在该窗口中编写和执行的所有代码行保存为一个程序。这就是为什么，你上面写的可能会影响你以后写的，例如，使用一个变量。这是我们将如何在 IDLE 中打字的预览。
IDLE 以它自己的方式非常整洁。您可以为背景和文本选择自定义颜色，以赋予其自己的风格。有一个自动完成功能，它可以预测你正在输入的内容并给出建议(很像谷歌搜索)。
最重要的是，它适用于所有主要的操作系统！
Python 2 和 Python 3
如果你是在 2020 年阅读这篇文章，那么讨论这个问题是没有意义的，除非你在某个项目上工作，这个项目仍然运行在 Python 2.x 的某个版本上
当我们说 Python 2.x 时，我们指的是 Python 2.7，当我们说 Python 3.x 时，我们指的是 Python 3.7 版本。
Python 在 2008 年发布了 Python 3 版本的编程语言。最初对采用 Python 3 有过犹豫，但现在不再犹豫了。
几乎所有 python 的库/模块都已经迁移到 python 3，或者已经兼容 python 3.x 版本。
所以现在，使用 Python 2.x 版本是没有意义的，除非您正在您的应用中处理一些仍然运行在 Python 2.x 版本上的遗留代码。
Python 2 和 Python 3 之间的重要区别
尽管与 Python 2 相比，该语言的新版本(即 Python 3)有许多变化。如果您将代码从 Python 2.7(或任何其他 2.x 版本)移植到 Python 3.x 版本，我们将讨论最重要的问题。
新的print()方法语法
是的，这是最明显的变化之一，因为当你用 python 编码时，print语句被大量使用。
在 python 2.x 中，不需要在print关键字后添加括号来括住要打印的文本，但是从 python 的 3.x 版本来看，正确的语法是print("TEXT TO BE PRINTED")。
让我们看一些代码示例来理解:
# In python 2.x
print "Text to be printed"
要打印的文本
而在 Python 3.x 版本的情况下，相同的代码将变成，
# In python 3.x
print("Text to be printed")
要打印的文本
除法运算符(/)的变化
Python 2.x 中的除法运算符返回了一个整数结果值，而在 Python 3.x 中，您现在得到了一个更精确的浮点结果值。
让我们看一些代码示例来理解:
# In python 2.x
print 5/2
Two
而在 Python 3.x 版本的情况下，相同的操作将返回一个浮点值，
# In python 3.x
print(5/2)
Two point five
功能xrange()不再支持
在 Python 2.x 中，如果我们想要生成一个范围内的数字列表，我们可以使用range函数返回一个列表，例如range(2)将返回列表[0,1]，或者使用xrange()函数，该函数不返回列表，但返回一个迭代器对象，您可以在其上进行迭代并获得数字的范围。简单来说，xrange()函数不是一次创建一个数字列表并返回，而是只在需要的时候生成范围内的数字，也就是说，当我们使用循环时。
Python 3.x 的情况下，没有xrange()功能。range()功能完成了xrange()以前做的事情。
了解了 python 中迭代器和 Iterables 的概念之后，你会更好的理解这个变化。
错误处理
python 中错误处理的try和except块的用法在语法上有一点变化。
让我们先看一些代码示例来看看变化，
# In python 2.x
try:
# some statement that may cause error
except SomeError, err:
print err, "Error Occured"
而在 Python 3.x 版本的情况下，在except块中，我们现在使用带有错误类型及其变量对象的as关键字，
# In python 3.x
try:
# some statement that may cause error
except SomeError as err:
print(err, "Error Occured")
这一改变是为了使语法更加易读和用户友好。如果您是 Python 中错误和异常处理的新手，可以在本教程系列的后面部分了解它。
一些更值得一提的变化
以下是我们想要提及的更多变化:
- 在 Python 2.x 中，隐式或默认的字符串编码是 ASCII，而在 Python 3.x 中，它是 Unicode。
- python 2.x 版本早期提供的许多 Python 库和模块可能不适用于 Python 3.x，但大多数都适用。
- 有了 Python 3.x，语言的语法变得更加用户友好。
结论
我们建议您使用 Python 3.x 版本进行学习。虽然在我们的一些教程中你可能会发现print语句用的是旧语法，但是现在你知道 Python 3.x 中print()的正确语法是什么了，所以编辑一下代码；)
Python 中的基本语法和你好世界程序
原文：https://www.studytonight.com/python/python-syntax-and-example
在本教程中，我们将尝试理解 python 编程的语法。虽然，语法是你会理解的东西，因为你会看到越来越多的程序和例子，但有几件事你必须事先知道。
Python 语法规则
-
Python 区分大小写。因此名为
yoyostudytonight的变量与yoYoStudytonight不同 -
For path specification, python uses forward slashes. Hence if you are working with a file, the default path for the file in case of Windows OS will have backward slashes, which you will have to convert to forward slashes to make them work in your python script.
对于窗口的路径
C:\folderA\folderB相对 python 程序路径应该是C:/folderA/folderB -
In python, there is no command terminator, which means no semicolon
;or anything.所以如果你想打印一些东西作为输出，你所要做的就是:
print ("Hello, World!")哎呀！我们刚刚也与您分享了第一个 python 程序。是的，就一句话。
-
In one line only a single executable statement should be written and the line change act as command terminator in python.
要在一行中编写两个单独的可执行语句，您应该使用分号
;来分隔命令。例如，print ("Hello, World!") ; print ("This is second line") -
在 python 中，可以使用单引号
''、双引号""甚至三引号''' """来表示字符串文字。word = 'word' sentence = "This is a one line sentence." para = """This is a paragraph which has multiple lines""" -
在 python 中，您可以在开始时使用
#在程序中编写注释。执行 python 脚本时，注释被忽略。
```py
# this is a comment
print ("Hello, World!")
# this is a
# multiline comment
```
- Line Continuation: To write a code in multiline without confusing the python interpreter, is by using a backslash
\at the end of each line to explicitly denote line continuation. For example,
```py
sum = 123 + \
456 + \
789
```
[现场示例→](/code/python/use-forward-slash-multiline.php)
括在`( )`、`[ ]`或`{ }`括号中的表达式不需要反斜杠来延续行。例如，
```py
vowels = ['a', 'e', 'i',
'o', 'u']
```
-
python 会忽略程序之间的空行。
-
Code Indentation: This is the most important rule of python programming. In programming language like Java, C or C++, generally curly brackets
{ }are used to define a code block, but python doesn't use brackets, then how does python knows where a particular code block ends. Well python used indentation for this.
建议使用**选项卡**进行缩进，虽然也可以使用空格进行缩进，但请记住，单个代码块的缩进量应该相同。
```py
if True:
print ("Yes, I am in if block");
# the above statement will not be
# considered inside the if block
```
正确的方法是，
```py
if True:
# this is inside if block
print ("Yes, I am in if block")
```
另外，由于语句的缩进不同，下面的代码会出错:
```py
if True:
# this is inside if block
print ("Yes, I am in if block")
# this will give error
print ("me too")
```
同样，正确的方法是将特定代码块的所有语句保持在同一缩进位置。
```py
if True:
# this is inside if block
print ("Yes, I am in if block")
print ("me too")
```
因此，这些是您必须知道的一些基本规则，以便我们在接下来的教程中更容易学习 python 编程的各种概念。
第一个 Python 程序
在学习语法时，我们已经与您分享了第一个 python 程序。是的，我们没有开玩笑，这只是一条线，上面没有，下面也没有。要打印你好，世界！在屏幕上，你所要做的就是:
print ("Hello, World!")
您可以在 IDLE 中编写并执行这段代码，也可以将这段代码保存在 python 代码文件中，将其命名为 test.py (您可以将其命名为任何名称，只需将文件的扩展名保留为.py)。
要运行 test.py python 脚本，请打开 IDLE，使用cd命令转到保存该文件的目录，然后在命令提示符或终端中键入以下内容:
python test.py
这将执行 python 脚本，并向您显示下面一行中的输出。
从下一个教程开始，我们将开始学习 python 编程语言的各种概念。
NumPy 和内置数学函数
原文：https://www.studytonight.com/python/numbers-and-math-functions
在本节中，我们将学习数字和 python 语言中可用的各种数学函数。在 Numbers 中，我们将看到一些最常用的数学运算符，我们可以使用它们在 python 中对数字执行各种操作。在数学函数部分，我们将学习一些快捷方式(称为函数，它们对计算一些复杂的数学表达式非常有帮助，如幂、正弦/余弦、阶乘等。那么，让我们开始吧。我们建议在阅读时保持 IDLE，这样你就可以同时练习和学习。
民数记
在 Python 中，我们有 6 个基本的数学运算符，它们是:
- 添加
- 减法
- 增加
- 分开
- 以…为模
- 力量
除了模运算符外，大部分人都必须熟悉以上所有运算符。别担心，我们会解释的。让我们从头开始。
添加
正如你可能已经猜到的，这只是简单的数字相加。为了测试操作员，只需转到 IDLE 并输入一个数字，然后加上符号+，然后另一个数字加到第一个数字上。按进入。这一定是这样的。
例:以 8、19 为例，
>>> 8+19
27
按下返回(或输入，答案将出现在代码行正下方。这就是输出的显示方式，一直都是- 在你的代码行的正下方。当您按回车键时，输出将出现在下面的行中。
不要止步于这个例子，尝试对其他数字使用加法运算符。试试带小数位的数字，比如4.5 + 5.5等等。
减法
就像加法一样，减法也有同样的语法。只需将操作符改为-。再次，选择一些随机数并尝试。
例:我们取89.33``23.67，给出输出65.55。
增加
又一样！只需将操作符更改为*，也称为一个星号。你知道它是用来乘法的，对吧？去吧，在你的 IDLE 中试试。
示例:取任意两个数字，使用*运算符相乘，就像我们在下面做的那样。
分开
这次用/符号。用随机数试试。注意:如果你是初学者，你可能会在这本书中发现一些困难。怎么做？让我想想。我们取一些像16``2这样的整数(没有小数的数)来除。
>>> 16/2
8
很好。接下来，用15和2试试。你认为答案会是什么？嗯，根据适当的数学，答案显然应该是7.5，但是如果你真的在 IDLE 中尝试这个，答案将会是7。之所以会这样，是因为如果我们对一个整数进行任何数学运算，那么答案将是一个整数。在我们的例子中，15和2都是整数，因此，我们的答案是7，因为答案必须是整数。
你可能想知道它是否必须是一个整数，为什么它变成了7，为什么不是任何其他整数。这是因为答案被确定为与原始答案最接近的较小整数。在我们的情况下，原来的答案是7.5，因此与它最接近的整数是 7 和 8，既然我们必须选择较小的一个；选择 7 作为答案。在数学中，它也被称为floor函数(在 Python 中也有)。
现在讲上面问题的解决方法，你要做的就是把(你要除的)任意一个整数转换成十进制，即写15.0而不是 15 和/或2.0而不是 2。
力量
这种数学运算符通常在普通编程语言中找不到。事实上，Python 是我们知道的唯一一种对此有操作符的语言。在其余的语言中，他们使用一些预定义的函数(如我们前面提到的快捷方式)来计算这一点。言归正传，在任意两个数字之间放两个类似**的星号即可。例如，要计算2到10的功率，你必须写:
>>> 2**10
1024
至此，我们已经了解了 python 中所有常用的数学运算符。现在，您可以尝试组合多个运算符，并使用它们来形成一个表达式。我们会推荐使用括号让 python 能够理解你想要什么作为答案，即不写2-9.0/2，写2-(9.0/2)。还记得 BODMAS 吗，一个有多个算子的数学表达式是如何在数学中求解的。
以…为模
模运算符由%百分比符号表示。如果你熟悉计算机编程世界，很可能你已经知道这个函数了。如果你没有，没必要担心。你知道组织，对吧？那你知道什么是余数了吧？当与两个操作数一起使用时，该模运算符返回余数作为答案。这里有一些快速的例子。
12%2 = 0，既然 2 完美地除了 12。
13%2 = 1，因为用 2 除 13 剩下 1 作为余数。
19%5 = 4，因为19/5还剩下 4 作为余数。
它的使用方式和这里解释的差不多。
要查看上面介绍的所有数学运算符，请点击“实时示例”按钮，
数字部分到此结束。现在让我们深入研究数学的函数。
Python 中的数学函数
随着您对 python 的了解越来越多，您可能会决定为某个项目或任何事情创建一个科学计算器。为此，除了简单的数学运算，你还必须评估一些复杂的数学运算，如三角运算、对数运算等。忘了计算器吧，可能会有各种情况需要这些功能。就像土木工程师计算他们正在建造的任何结构的各种参数的软件，或者任何航空航天软件——他们需要各种关于卫星轨迹、航天飞机轨迹等等的计算。简而言之，复杂的数学运算被用于各种现实生活的程序和软件中，因此你必须了解它们。
现在在 Python 中，一些好人已经为几乎每一个数学函数创建了代码片段(库)。我们可以毫不犹豫地使用这些代码，好处是，我们不必再次重写。忘记重写，我们甚至不需要知道完整的代码是什么。我们只需要一些关键信息就能使用这些现成的代码片段。
好吧，非正式的功能部分已经开始了。我们将在后面的章节中详细学习函数，因此我们将保持这个简短。
函数可以描述为一段代码，它可能会也可能不会将某个值作为输入，对其进行处理，最后可能会也可能不会返回任何值作为输出。
如上图所示，这里的输入x被赋予一个函数f，它给出了一些值f(x)作为输出。虽然在一般的编程世界中，根据函数的用途，输入和输出是完全可选的。但是对于一个数学函数来说，两者兼备是非常重要的。
例如，在三角函数sin(x)中，必须有一些x的值来计算和返回答案，这基本上确定了为什么数学函数既有输入又有输出。
在 python 中，有两种类型的预定义函数。
- 内置函数:这些函数不需要任何其他(外部)代码文件(称为，模块或库文件)。这些是 python 核心的一部分，只是构建在 Python 编译器中，因此在我们的代码中导入这些模块/库没有任何麻烦。
- 第二类函数需要一些外部文件(模块)才能使用。在我们的代码中使用这些外部文件的过程叫做导入。所以我们所要做的就是将文件导入到我们的代码中，并使用已经写在该文件中的函数。
是时候尝试一些功能了。让我们从幂函数开始。
电源- pow(x,y)
我知道你可能在想什么。我们刚刚试过了，不是吗？嗯，我们确实看到了一些可以计算功率的东西，但是它是一个运算符，这个是一个内置函数(是的，第一种类型)。所以，考虑一下这个作为计算功率的替代方法。
由于这是一个内置函数，您不需要导入任何其他库文件(或模块，因此它非常容易实现。
由于幂函数需要两个数字(输入)来执行运算，即基数和指数，因此我们必须为函数提供两个数字。继续，打开 IDLE 并写下:
>>> pow(3,2)
现在让我们分析一下我们做了什么，以及将会发生什么。首先，我们写了pow，这只是我们试图调用的函数的名称。这将告诉 python 编译器寻找一个名为pow的内置函数，并发现它能做什么。接下来，在括号内，我们写了两个用逗号分隔的数字，即3和2。这里第一个数字 3 是基数，第二个数字 2 是指数，我们尝试计算 3 2 。
一旦 python 编译器确保所有语法(编程的语法)都是正确的，它就会寻找函数pow的实现，并使用它来寻找3<sup>2</sup>。如您所料，输出将是:
有了这些，我们现在知道了，函数是如何被调用的。特别是对于数学函数，我们可以概括如下:
>>> functionName(input1, optionalInput2, optionalInput3, ...)
括号内用逗号分隔的值，我们在函数输入中提到过，叫做参数。与上面给出的pow(x, y)例子一样，3 和 2 是参数。一个函数中可以有任意数量的参数。正如我们之前讨论的，对于一个数学函数，通常至少有一个参数。让我们看看另一个内置的数学函数。
绝对- abs(x)
绝对函数，也称为模(不要与模混淆)，返回自变量值的非负值。因此，任何非负数的绝对值都是相同的，而对于负数，则返回它们的正值。
例:绝对值-3为3，-8.74绝对值为8.74以此类推。
语法:
>>> abs(-99.99)
由于-99.99是负数，它的正数对应的将是输出，即99.99。
现在让我们尝试一些函数，在那里我们必须导入一些模块(或库文件)。
其 - sin(x)
由于我们知道正弦是一个三角函数，因此它只接受一个值作为参数，即x。这里的 x 应该在弧度，所以最好不要和度混淆。正如我们之前提到的，我们不能直接使用这个函数。如果你这样做，你可能会得到一个错误，类似这样的东西，它会说名罪未定义。
这是因为编译器在遇到sin()函数时不知道它应该做什么，因为我们还没有定义这个函数，但是我们正在尝试使用它。因此，为了使用它，我们将不得不导入 python 的数学模块，该模块由sin()函数的实现组成，它将指导 python 编译器理解当调用sin()时该做什么。
我们将要做的叫做导入一个模块，通常使用已经可用的现成功能来完成。导入模块只需多一行:
>>> import math
按回车，你就完成了。现在为了使用sin()功能，转到一个新行并键入:
>>> math.sin(3.14159)
由于3.14159近似为π的值，因此答案将接近于零。
正如您在math.sin(3.14159)声明后看到的，返回的答案类似于2.653589335273e-6，可能看起来有点混乱，但它是2.653589335273 × 10^-6或0.000002653589335273的等效表示。
因为π值的近似，答案也只是稍微偏离了 0，但是你可以看到这个值几乎为零。同时，你可以看到结果有多准确。
现在数学模块里面当然还有其他几个功能可用，比如floor()(地板功能；我们在除法运算符、exp()(指数函数)、log()(对数函数)、sqrt()(平方根)等等中提到了这个。你可以在 Python 的官方网站上查看这个列表、它们的语法、接受的参数数量以及所有内容- 数学函数。Python 在他们的网站上有一个手册，在那里你可以看到列出的所有功能和所有细节。本手册称为文件。
Python 中的运算符
在每种编程语言中，运算符用于对任何给定的操作数执行各种类型的操作。它们用于计算不同类型的表达式，并通过对它们执行不同的操作来操作操作数或变量的值。
在 python 中，我们有 7 种不同类型的运算符，它们是:
- 算术运算符
- 比较运算符
- 赋值运算符
- 逻辑运算符
- 按位运算符
- 成员操作符
- 身份操作符
前五个是常用的操作符，后两个即成员身份和身份操作符是 python 独有的。
Python:算术运算符
算术运算符是用于对数值操作数进行除、减、加等算术运算的运算符。
以下是不同的算术运算符:
To multiply values on either side of the operator.
| 操作员 | 使用 | 描述 |
| + | a + b | 将运算符两侧的值相加。 |
| - | a - b | 从左侧操作数中减去右侧操作数。 |
| * | a*b | |
| / | a/b | 用左手操作数除以右手操作数(返回浮点值)。 |
| % | a % b | 返回左手操作数除以右手操作数的余数。 |
| ** | a**b | 返回指数–左操作数的右次方 |
| // | a//b | 场内除法–操作数的除法，其结果是去掉小数点后数字的商。但是如果其中一个操作数是负的，则结果是二进制的，即从零开始舍入(向负无穷大)。 |
让我们看几个代码示例:
>>>3+2
5
>>>4-3
1
>>>3/2
1.5
Python:比较运算符
这些运算符用于比较这类运算符两侧的操作数值。这些运算符返回true或false布尔值。如果条件满足，他们返回真，否则返回假。
以下是不同的比较运算符:
| 操作员 | 使用 | 描述 |
| == | a == b | 如果运算符两侧的值相等，则返回“真”，否则返回“假”。 |
| != | a != b | 如果运算符两侧的值不相等，则返回“真”，否则返回“假”。 |
| > | a > b | 如果运算符左侧的操作数的值大于运算符右侧的值，则返回 True。 |
| < | a < b | 如果运算符左侧的操作数的值小于运算符右侧的值，则返回 True。 |
| >= | a >= b | 如果运算符左侧的操作数的值大于或等于运算符右侧的值，则返回 True。 |
| <= | a <= b | 如果运算符左侧的操作数的值小于或等于运算符右侧的值，则返回 True。 |
让我们看几个代码示例:
>>> 3 == 2
False
>>> 3 != 2
True
>>> 2<=4
True
Python:赋值运算符
赋值运算符用于为变量或操作数赋值。
如果我们使用任何算术运算符(+、-、/等，则等于(=)运算符用于将值直接赋给操作数。)与等于运算符一起，它将对给定变量执行算术运算，然后将结果值赋给该变量本身。
让我们看几个代码示例:
>>> x=2
>>> x
2
>>> x+=1
>>> x
3
>>> x-=1
>>> x
2
Python:逻辑运算符
逻辑运算符用于执行逻辑运算(如和、或、而非)并组合两个或多个条件以提供特定结果，即真或假。
以下是不同的逻辑运算符:
| 操作员 | 使用 | 描述 |
| and | x and y | 如果运算符的两边都为真，则为真 |
| or | x or y | 如果任一操作数为真，则为真 |
| not | not x | 补充操作数 |
Python:按位运算符
按位运算符一点一点地作用于操作数。这些运算符接受一个或两个操作数。一些按位运算符看起来类似于逻辑运算符，但实际上并非如此。
以下是不同的按位运算符:
It copies a bit if it exists in either operand.
| 操作员 | 使用 | 描述 |
| &二进制“与” | (a & b) | 如果结果在两个操作数中都存在，运算符会将一个位复制到结果中。 |
| |二进制或 | (a | b) | |
| ^二进制异或 | (a ^ b) | 如果在一个操作数中设置了该位，而不是在两个操作数中都设置了该位，则复制该位。 |
| ~ 1 的补码 | (~a) | 它是一元的，具有“翻转”位的效果。 |
| <<二进制左移 | a << 2 | 左操作数值向左移动右操作数指定的位数。 |
| >>二进制右移 | a >> 2 | 左操作数值向右移动右操作数指定的位数。 |
让我们看几个代码示例:
>>> a = 3
>>> b = 4
>>> a = 3 # equivalent binary is 0011
>>> b = 4 # equivalent binary is 0100
>>> a & b
0
>>> a | b
7
>>> # 7 is equivalent to 0111 in binary
Python:成员操作符
成员操作符用于测试一个值是否在特定的序列中，比如列表、元组、字符串等。它返回真或假作为输出。
以下是不同的成员操作符:
| 操作员 | 使用 | 描述 |
| in | x in y | 如果运算符左侧的值/操作数出现在运算符右侧的序列中，则为 True。 |
| not in | x not in y | 如果运算符左侧的值/操作数不在运算符右侧的序列中，则为 True。 |
让我们看几个代码示例:
>>> lst=[2,3,6,7,9,1]
>>> x=2
>>> y=5
>>> x in lst
True
>>> y in lst
False
Python:标识运算符
标识运算符用于测试变量是否引用相同的值/对象。它返回真或假作为输出。
以下是不同的标识运算符:
| 操作员 | 使用 | 描述 |
| is | x is True | 如果两个操作数引用同一个对象，则为 True。 |
| is not | x is not True | 如果运算符两侧的变量指向同一对象，则计算结果为假，否则为真。 |
让我们看几个代码示例:
>>> x=4
>>> y=4
>>> z=2
>>> x is y
True
>>> z is x
False
Python 中的变量
本课讨论变量。那些已经知道一些编程的人必须熟悉变量的概念及其重要性。变量是我们放在空盒子(内存位置)上的铭牌，我们可以在其中存储任何值(数据)，一旦我们使用完一个变量，铭牌就会从盒子(内存位置)上移除(超出范围)，然后盒子就会有一个新的铭牌。另外，在 python 中，一个盒子可以有多个铭牌。
在 python 中，一切都是一个对象，变量只是用来标识这些对象的名称。
例如:
x = 10
在上面的代码中，x是对象10的变量或标签或名称。
如果我们有以下代码:
x = 10
y = 10
那么对于对象10我们有两个标签(引用)x和y。
因此，我们可以说变量提供了一种用描述性名称标记数据的方式，因此读者和我们自己可以更清楚地理解我们的程序。将变量视为保存信息的容器的铭牌是有帮助的。他们唯一的目的是标记存储在内存中的数据。这些数据可以在整个程序中使用。
让我们看一些例子。一个变量应该有一个名字。有一些规则可以给变量命名。
- 变量名只能由字母、数字和下划线组成。
- 变量名称中的第一个字符不能是数字。因此
i-am-variable、variable!、1variable、#variable都是无效变量名。而i_am_variable、variable、variable1、_variable都是有效名称。
在变量中存储值
是时候看看如何在变量中存储一个值了。考虑一个名为x的变量，我们希望这个变量存储一个数值或者一个数字，比如11。然后，要做到这一点，只需转到 IDLE 并键入:
>>> x = 11
并按下进入键。这样我们的变量就被创建了，命名为x，并在其中存储了一个默认值11，使用等于=运算符。请记住，等于运算符始终用于为任何变量指定特定值。变量的名称将始终位于左侧，其值将位于右侧。让我们创建另一个变量，比如y并为其赋值25。
>>> y = 25
现在在当前的 IDLE 会话中，python 正在处理两个变量x和y，它们分别有值11和25。如果您想检查 IDLE 中任何变量的值，只需在新行中键入该变量的名称，然后按回车键。存储在其中的值将以新的一行打印在 IDLE 屏幕上。
>>> x
11
>>> y
25
现在试着看看下面的代码，你认为这会做什么？
>>> x = y
正如你在 LHS(左手边)看到的，我们在 RHS(右手边)有x和y，因此正如我们之前解释的，右边的值将被分配给左边的变量。由于y中存储了一个值25，该语句会将x中的值从11修改为25。因此，如果你再问x的值，现在就是25了。在这种情况下，我们只是覆盖了x变量中的值。
>>> x
25
一旦你完成了上面的例子，让我们这次在命名变量时更有创造性。让我们创建一个变量，并指定您的名字作为它的值。所以这里我们有一个名为name的盒子，它可以存储任何单词。这个过程与我们上面所做的非常相似，只是有一点小小的改变。仔细看，
>>> name = "Sudytonight"
如您所见，我们在双引号中引用了我们网站的名称。这是因为我们不想让 python 编译器混淆。既然study nothing是一个词(或者更准确地说，是编程世界中的string)，我们就必须用引号将它括起来。通过这样做，我们告诉 python 这是一个词。但是，如果我们在没有引号的情况下写下StudyTonight会发生什么？像这样，
>>> name = Studytonight
由于没有引号，python 会将Studytonight视为另一个变量，并试图找到存储在其中的值，以便进一步将其分配给变量name。但是由于我们从未声明过任何名为Studytonight的变量，python 将无法为其找到任何值，最终，它将抛出一个错误，称名为Studytonight的变量未定义。
也可以同时使用单引号和双引号来表示一个单词(或string)。
>>> name = "Studytonight.com"
>>> name = 'Studytonight'
两者都很好。
现在，您也可以尝试使用带有数学函数的变量，就像我们在上一个教程中学习的那样。尝试使用变量作为函数的参数。例如，
>>> x = 3
>>> y = 2
>>> pow(x, y)
9
>>> z = -7
>>> abs(z)
7
接下来，可以尝试将任意数学函数的答案保存在一个变量中。比如，
>>> p = pow(5, 2)
>>> import math
>>> q = math.log(x)
尝试对这些变量使用数学运算符。比如，
>>> x+y
5
>>> x-y
1
尝试在一个数学表达式中使用这些变量，包括一些数学函数和运算符，所有这些加在一起，就像，
>>> x = pow(x**y, p+2)
在上面的代码中，python 将首先计算 RHS(右手边)上的表达式，并将使用变量x的旧值，即3，一旦表达式被求解，答案将存储在变量x中，该变量将成为其新值。
在 Python 中使用模块和相关函数
原文：https://www.studytonight.com/python/modules-and-functions
在之前的教程中，我们学习了数学模块。我们还检查了它的一些功能，如sin、log等。，并且也学会了如何使用它们。现在就像数学模块一样，python 库中还有其他几个模块可以直接在任何 python 程序中使用。其中一些模块非常重要，没有这些模块，程序员根本无法制作任何现实生活中的应用。
在本课中，我们将重温模块及其功能，并尝试更好地理解它们。
功能位于模块内部
将模块视为另一段 python 代码，保存在 python 包中的某个地方，您可以在任何其他(或您的)python 代码文件中重用模块文件中的代码。现在试着回忆一下我们导入math模块后做了什么。我们测试了在math模块中定义的一些功能，如math.floor(8.4)、math.sin(3.14159)等。
注:pow(5,2)``math.floor(8.4)``sin(3.14159)都是调用函数的例子。
要了解我们如何使用import语句来导入外部模块，如数学模块，请检查实时示例，
如果，我们上面写的只是调用和使用这些函数的一种方式。执行这些复杂数学运算的实际逻辑(代码)存储在哪里？即计算提供值的功率、楼层或正弦。所有这些(代码或逻辑)都位于模块文件中，称为功能定义。函数定义设置了规则，即函数如何解释所提供的输入，对其执行一些操作，以及作为输出或结果返回什么。
事实上，是函数定义本身决定了函数的输入和输出的类型和数量(输出总是一个，但输入可以是多个)。这些输入有一个官方术语，它们被称为参数。
参数:定义接受的输入类型的结构，同时定义函数。
参数:调用/使用函数时作为输入插入的实际值。
假设我们已经创建了一个模块文件study now . py(.py表示它是一个 python 代码文件；没错。你也可以自己创建一个模块文件，毕竟只是 python 代码)。在模块文件中，我们定义了一个可以求解二次方程ax<sup>2</sup> + bx + c = 0的函数。让函数名为qSolver(a, b, c)。
使用这个函数只需要提供a、b、c的值，即方程的系数值，函数就会打印出这两个解是否真实，是什么。那么，让我们看看如何导入模块并使用函数。
步骤 1: 首先导入模块。
>>> import StudyTonight
第二步:接下来用适当的参数调用函数，例如2x<sup>2</sup>-6x+3=0、a=2、b=-6和c=3。因此我们会打电话给，
>>> qSolver(2, -6, 3)
您不必在 IDLE 上尝试此功能，因为这不起作用。为什么呢？因为我们实际上没有在你的本地系统(笔记本/电脑)中创建任何名为【StudyTonight】的模块。这只是为了向您解释模块和函数实际上是如何工作的，以及我们如何使用自己定义的函数创建自定义模块。为了从模块中调用每个函数，您必须遵循相同的步骤。
python 已经有很多可用的模块了。当您安装 python 时，一些可能已经安装在您的系统中，而另一些可以从互联网轻松下载。这完全取决于你需要什么。
如何使用模块中定义的函数
使用模块中定义的函数时，您应该知道以下事项:
-
您必须知道哪个模块包含该功能。
-
Check if it's already in your system. If it is, then all good, otherwise go ahead and download it from the internet.
(注意:可以通过在 IDLE 中导入该模块进行检查。错误意味着它不在那里。)
-
接下来，确定您想要使用的函数的名称。为此，您可以参考 python 的文档。
-
参考文档检查它需要的参数数量，它们的含义和顺序。
-
接下来，调用函数。 <模块-名称> 是模块的名称， <功能-名称> 是功能的名称和
**<自变量-2 > ...是函数的参数。
>>> <module-name>.<function-name>(<argument-1>, <argument-2>, ...)
请注意，参数的数量取决于我们使用的函数。在某些情况下，函数可能不接受任何参数。这完全取决于您调用的是哪个函数，因此在使用任何函数之前，您必须查看文档以查看函数定义。上面调用的函数可能返回值，也可能不返回值(函数的输出)。在某些情况下，我们经常需要存储输出以备将来使用。我们通过将它存储在一个变量中来做到这一点，我们已经在上一节教程中学习过了。
>>> variable-name = <module-name>.<function-name>(<argument-1>, <argument-2>, ...)
这只有在函数返回任何值(输出)时才有意义。此外，函数只能返回一个输出值，或者根本不返回。
让我们用我们到目前为止所理解的，使用一个在string模块中定义的函数lower()。
附加主题(什么是字符串？)
String 只是一个用来指代像"Studytonight"这样的单词或者像"Studytonight is a good website"这样的句子的术语。
它们必须用单引号或双引号('...'括起来/ "...").在上一章中，我们已经解释了如何将它们存储在变量中。存储字符串的变量叫做字符串变量。
现在string模块不同于上面解释的字符串。这只是一个名为字符串的模块，定义了函数对字符串变量执行各种操作。
因此，string模块由一些处理字符串操作的函数组成。在下面的例子中，我们将使用lower()，它用于将字符串的每个字符转换为小写。
- 我们已经知道
string是由功能lower()组成的库/模块。 - 导入
string模块检查是否可用。因为它是一个基本模块，所以它很可能会在那里。 - 查看文档，在模块页面找到功能
lower()。它会给你使用它所需的信息。
- 它只有一个字符串参数。因此，创建一个字符串变量，其值为“让我们今晚研究一下”。
- 接下来调用函数，
>>> string_variable = "Let's StudyTonight"
>>> string.lower(string_variable)
或者，如果你想直接一点，不要浪费内存去保存一个变量，就像这样做，
>>> string.lower("Let's StudyTonight")
像我们上面做的那样调用一个函数只会在我们点击回车时打印结果。就像这样，
如您所见，返回值将所有大写字母(大写字母)转换为小写，即 L 到 l 、 S 到 s 和 T 到 t 。如果您使用了一个变量，请记住，使用这样的函数不会修改原始变量的值。因此，即使在使用该函数后，string_variable的值仍将保持不变。因此，如果您愿意，可以将修改后的值保存在其他变量中，甚至保存在同一个变量本身中，例如:
>>> string_variable = string.lower(string_variable)
该语句完全有效，因为 python 将从右向左编译所有内容，即它将首先使用string.lower()获取修改后的字符串，然后使用=(等于)运算符将输出值分配给string_variable变量。
Python 中的输入和输出
如果你仔细想想，你会意识到你使用的大多数真实世界的程序或软件都需要用户的一些输入。
无论是任何智能手机应用，如脸书或 Instagram ，在这里您必须首先输入您的电子邮件/用户名和密码才能登录，然后以文本或照片的形式发布一些帖子，以便在您的个人资料中使用。或者，在任何订票软件中，你首先必须指定火车/公共汽车/电影的名称；等等。
软件是一组程序，一起工作来执行一项任务或解决一个问题，这使我们的生活更容易。并且为了执行任何任务或者解决问题，软件必须知道问题的参数(或者，要执行的任务)。这是程序从用户那里获取输入的地方。同样，在接受这些输入后，程序必须处理它们并返回一些结果。这就是输出进入画面的地方。
在本课中，我们将学习如何用 python 创建一个程序，该程序可以从用户那里获取一些输入并打印出来。
从用户处获取输入
如果你还记得的话，我们在第一个教程中使用了一个代码片段来演示 python 语法与其他编程语言相比是多么的简短和方便。
我们将 python 的代码与C++和Java的代码进行了比较。如果你还记得的话， C++ 和 Java 都需要一些额外的头文件(类似于 python 中的模块)来获得一些用户输入，而在 python 中只需要一行代码。
假设你想用 python 做一个简单的计算器。为此，您必须从用户那里获取一个或两个输入值，然后对输入的数字执行用户要求的数学运算并返回输出。为简单起见，我们先把用户要求的数学运算修正为加法为现在。
我们可以稍后在简单的计算器中添加更多的操作，但是现在让我们继续添加。为了执行加法，您必须从用户那里获得两个数字作为输入(很像普通的计算器)。输入必须是分配给存储在变量中的或的(比如x和y)。下面是接受用户输入的代码，让我们看看:****
>>> x = input()
将上面的代码行写在 IDLE 中，然后按回车键。你会注意到光标不会移动到新的>>>线上。相反，它将开始等待用户输入。
这是你从键盘输入任何数字的时间(比如说，3)。只需输入任意数字，再次按回车键，现在您将看到带有>>>的换行符。
就像这样，使用input()函数(是的，它是一个内置函数)，您只需在变量x中存储一个值。为了让它更花哨，试试这个:
>>> x = input("Enter the first number:")
现在您会注意到下一行将打印消息:“输入第一个数字:“”并将等待用户输入。正如您可能已经猜到的那样，打印这样的消息将通知用户，他们应该输入一个值/数字/输入，以便程序继续运行。一个好的程序应该总是有这样直观的信息。
接下来，询问y变量的值。
>>> y = input("Enter the second number:")
现在，是时候玩一会儿了。再次尝试输入变量x或y，这次尝试输入任何字母或字符串，而不是输入数字。当你按回车键时，你会看到 python 会抛出一个错误。
但是在 python 3.x 中，raw_input()函数被移除，input()被用来获取 numeri、strings 等各种值。
输出
现在我们如何在屏幕上显示输入值？你可能认为我们所要做的只是键入变量并按回车键。是的，我们一直都在这样做，但这只在你在 IDLE 中有效。
在创建真实世界的 python 程序时，您必须编写明确输出字符串或数字的语句。
我们用print语句来做。考虑一下，打印一个流行的语句“你好，世界”。为此，只需键入，
>>> print ("Hello, World");
不要忘记引号，双或单，两者都可以。按回车键，您将看到报表打印在底部。如果你试着只写《你好，世界》并去掉打印语句，比如，
>>> "Hello, World"
你会看到这也将打印该行，然而这一次在它周围有引号。这就是如何区分这两种方法。接下来，让我们尝试打印一个数字:
>>> print (9)
现在试着把两个字符串打印在一起。创建两个变量、a和b。给它们分配两个字符串值，
>>> a = "Hello"
>>> b = "World"
现在一起打印出来。
>>> print (a + b);
HelloWorld
这是它必须出现的方式。这个例子展示了 python 如何用两种方式解释一件事情。这里+运算符，用于连接两个字符串，而不是执行数学加法(这实际上不可能在两个字符串上执行)。因为两个字符串的数学相加没有任何意义，所以每当 python 遇到两个字符串之间有一个+运算符时，它只会将两个字符串连接起来。
上述操作也可以以另一种方式执行:
>>> print ("Hello" + "World");
HelloWorld
现在试着打印一个数字并串在一起。
>>> print (5 + " is a number");
你会得到一个错误。你能猜到为什么吗？
这是因为我们试图将一个整数与一个字符串连接起来。所以我们在这里建立一个规则-
“在打印时，我们不能将两种不同类型的文字混淆。”
解决方案？我们必须将数字5转换成字符串。一种方法是，
>>> print ("5" + " is a number")
或者，
>>> print (str(5)+ " is a number");
str()函数，只是另一个可以用来将整数转换成字符串的内置函数。当涉及到将数字变量(由数字组成的变量)转换为字符串时，这非常有用。比如，
>>> x = 1
>>> print (str(x)+ "st rule of Fight Club we don't talk about Fight Club");
1st rule of Fight Club we don't talk about Fight Club
最后，让我们用加法函数来完成我们的计算器。到目前为止，这就是我们所做的:
>>> x = input("Enter the first number")
>>> y = input("Enter the second number")
现在，是时候输出了。
>>> print (x+y);
或者，
>>> print (str(x+y));
两者将给出相同的输出。虽然x+y的结果是一个数字，str(x+y)的结果是一个字符串。
Python 中的数据类型
让我们快速浏览一下 Python 中可用的数据类型。当然，随着您更多地使用和练习 python，这一点会变得越来越清楚。
首先，让我们了解什么是数据类型？顾名思义，这些是 python 编译器理解的一些不同类型的数据。就像计算机只能理解二进制数(即 1 和 0)，所以这是计算机唯一能理解的数据类型，但 python 能理解的更多。就 Python 而言，为程序员提供了各种表示数据的方式——比如你的名字、卷号、标记、珠穆朗玛峰的高度、世界人口等等。基本上，任何包含原始信息的东西。
Python 中的数据类型
Python 中的数据可以是以下 5 种类型之一:
- 民数记
- 没有人
- 顺序
- 设置
- 绘图
您还可以直接跳到代码示例，查看所有不同的数据类型的运行情况，
民数记
Number 是我们在前面的课程中已经讨论过的数据类型。我们将它们与数学运算符一起使用，在函数中，与变量一起使用，在输入输出教程中也是如此，直到现在我们到处都在猜测，这就是它们至关重要的原因。正如您可能在前面的教程中注意到的，我们已经提到了整数和浮点数，这就是我们要学习它们之间区别的地方。数字进一步分为三种类型:
整数和布尔值
这组包括所有的整数，如 1，2，3，..., 0, -1, -2, -3,...和布尔值(计算机理解的值)，分别为true或false(分别为 1 或 0)。
浮点数
该集合处理具有小数点值(或任何实数)的数字。比如1.2、4.76832、8.0都是浮点数。
复数
是的，与任何其他编程语言不同，Python 中有一种用于复数的数据类型。在 IDLE 中键入1+2j或1+2J，它不会返回任何错误，因为在 python 语言中它是一个完全有效的复数。我们知道，传统上我们一直使用iota(或我)来表示复数，但是 python 选择了j而不是i。完全没问题。我们该评判谁？
没有人
想一个你不想变量有任何值的场景。会做什么？不能用0因为毕竟是数字。这就是None出现的地方。只要把:
>>> x = None
而x将没有任何价值。
顺序
序列是项目的有序集合，由正整数索引。它是可变(可变变量为 1，其值可以改变)和不可变(不可变变量为 1，其值不可以改变)数据类型的组合。Python 中有三种类型的序列数据类型，它们是:
- 用线串
- 列表
- 元组
线
这是字母/字符的有序序列。它们包含在单引号(')或双引号(" ")中。字符串周围的引号不是字符串的一部分。它们只通知编译器字符串的开始和结束位置。它们可以有任何字符或符号，包括其中的空格。这些都是不变的。长度为 1 的字符串代表 python 中的一个字符。您知道，在早期的教程中，我们已经多次使用了字符串。基本上，它们帮助我们在 Python 中存储和实现文学单词。比如"Saharsh"、'Saharsh'、"123"、'123'都是字符串。
列表
它也是任何类型的值序列。列表中的值称为元素/项目。列表是可变的和索引/排序的。该列表包含在方括号【】中。例如[2, 6, 8, 3, 1]或["Python", "Java", "C++"]都是列表。你可以注意到它和我们日常生活中使用的列表没有什么不同。列表只是放在方括号内的一串数字或字符串，按顺序排列。列表中的每个元素都可以通过使用它的索引号来访问。
元组
它们是任何类型的值的序列，由整数索引。元组用弧形括号括起来，即()。元组也很像列表，除了它们是不可变的，因此一旦我们给它赋值，我们以后就不能改变它。同时在执行上也比 List 快。
设置
Set 是任意类型值的无序集合，没有重复条目。是不变的(他们的价值观以后不能变；尽量记住这个定义)。
绘图
这种数据类型是无序且可变的。字典属于映射。
字典
字典很像我们的字典，可以存储任意数量的 python 对象。他们存储的是键值对，可以使用键访问。词典用花括号括起来{ }。
Python 中的字符串
自从我们开始学习 python 以来，这已经不是我们第一次遇到 Strings 了。在前面的许多教程中，我们已经在示例中使用了字符串或者讨论了它，所以它不应该成为你的埋伏。尽管如此，这一章将让您更深入地了解如何在 python 世界中使用、操作和实现它们。我们还将检查一些方便的字符串函数来操作字符串。所以，在不浪费时间的情况下，让我们马上投入其中。
什么是字符串？
字符串可以定义为字符序列，这是你能提供的最基本的字符串解释。在这个定义中，我们可以看到两个重要的术语，一个是序列，另一个是人物。如果你在完成了最后一个教程之后在这里，那么在那里，我们已经解释了——什么是序列 数据类型以及字符串是如何成为序列类型的。只是为了修订，在 python 中，Sequence 是一种由几个相同类型的元素组成的数据类型，即整数、浮点数、字符、字符串等。
注: 所有已有字符都有唯一编码。编码惯例被标记为 Unicode 格式。它由几乎所有可能语言的字符组成，事实上也包括表情符号(是的，表情符号也被声明为字符)。
因此，字符串可以被认为是一种特殊类型的序列，它的所有元素都是字符。比如字符串"Hello, World"基本上就是一个序列 ['H '，' e '，' l '，' l '，' o '，'，'，'，' W '，' o '，' r '，' l '，' d'] 它的长度可以通过统计序列内部的字符数来计算，就是12。
注意: 是的，空格、逗号那些引号里面的所有东西如果长度是 1 的话都会是一个字符。
一般在编程语言中有一种不同的数据类型只专用于字符，而在 Python 中则没有字符数据类型。相反，字符被视为长度为 1 的字符串。
字符串声明
>>> mystring = "This is not my first String"
>>> print (mystring);
This is not my first String
您也可以访问字符串的每个单独的字符。就像访问序列的每个元素一样，我们可以为此使用索引号。要访问mystring的第一个字符，我们可以执行以下操作:
>>> print (mystring[0]);
T
由于T是我们的字符串This is not my first String的第一个字符，因此它的索引号为0(零)。类似地，对于进一步的字符，我们可以使用索引 1、2、3 等等，也就是说，为了访问具有元素的，我们将不得不使用第 (i-1)个索引。
还有另一个技巧，从序列的末尾访问序列的元素。例如，如果您想访问序列的最后一个元素，只需执行以下操作:
>>> print (mystring[-1])
在索引中写下-1将意味着您要求从最后一个元素开始的第一个元素。类似地，为了访问第二个最后一个元素，使用-2作为索引，对于第三个最后一个使用-3以此类推，即对于最后一个使用-ith作为索引的和元素。这样就解决了从字符串的前向和后向访问每个字符的一般化问题。请注意，正索引号意味着您正从前端访问字符，而负索引号意味着您正从后端访问它。
我们可以用一张简单的表格来总结我们到目前为止所学的内容。考虑一根绳子PYTHON。为此，可以通过两种方式访问每个字符-从前面，或从后面。
| 字符 | P | Y | T | H | O | N |
| 前进指数 | Zero | one | Two | three | four | five |
| 倒排索引 | -6 | -5 | -4 | -3 | -2 | -1 |
换码顺序
假设您想要一个字符串来存储圣雄甘地的一句话。
“你一定是你希望在这个世界上看到的改变”——甘地
这正是您想要在控制台中显示的行。你也希望这句话能被引用。当你继续打印声明时，你会发现事情并没有那么简单。
Python 会立即返回一个语法错误。这是因为我们添加了额外的双引号。在上图中，你可以注意到甘地引用的文字是黑色的，而-【甘地】是绿色的。此外，如果您已经使用了足够的 IDLE，您可能知道字符串中的所有字符在IDLE中都以绿色突出显示(根据文本编辑器、python 版本、操作系统等，它也可以是其他颜色)。这显然意味着 Python 没有把你一定是你希望在这个世界上看到的变化部分当成一根弦。因此，这就得出结论，每当我们打开一个引用并关闭它时，声明一个字符串，无论我们在结束引用后写什么，都只是被认为是一些 python 关键字。
就像上面的引用文本一样，我们用两个双引号开始字符串，并在它旁边写道你一定是你希望在世界上看到的变化，因为双引号在这个短语之前就已经关闭了，因此 python 认为整个句子是一些不可理解的 Python 关键字。在这个短语之后，另一个双引号开始了，然后是 -甘地在那之后，最后是结束双引号，因为-甘地-T7】部分在一对双引号内，因此它是完全合法的。
现在你明白了，如果我们使用不均匀数量的双引号，我们可能会面临的问题。现在让我们看看如何在字符串中引用。有两种方法可以做到:
-
First one is a bit compromising. You can use single quotes inside of double quotes, like:
>>> print ("'You must be the change you wish to see in the world' - Gandhi"); ‘You must be the change you wish to see in the world' - Gandhi因此，在双引号中使用单引号是合法的，但是，反过来就不正确了，即，
>>> '"You must be the change you wish to see in the world" - Gandhi'会给出一个错误。
-
Second one is for those who hate to compromise, or just want to use the double quotes. For you people, there is something called escape sequence or literally speaking, a back-slash
\. You can use it like:>>> print ("\"You must be the change you wish to see in the world\" – Gandhi");你能猜到发生了什么吗？我们在两个地方使用了反斜杠或转义序列，就在我们直接想要打印的引号之前。如果您想通知编译器简单地打印您键入的任何内容，而不是试图编译它，只需在它之前添加一个转义序列。还要记住，一个字符必须使用一个转义序列。例如，为了打印 5 个双引号，我们必须使用 5 个反斜杠，每个引号前一个，如下所示:
>>> print ("\"\"\"\"\"");
字符串的输入和输出
输入输出方法已经在输入输出教程中详细讨论过了。如果您还没有完成教程，建议您完成它。
字符串上的操作
python 中的字符串处理可能需要最少的努力。因为在 python 中，与其他语言相比，字符串操作的复杂性非常低。让我们看看如何玩弦乐。
-
Concatenation: No, wait! what? This word may sound a bit complex for absolute beginners but all it means is - to join two strings. Like to join
"Hello"with"World", to make it"HelloWorld". Yes, that's it.>>> print ("Hello" + "World"); HelloWorld是的。一个加号
+就足够了。与字符串一起使用时，+符号连接两个字符串。我们再举一个例子:>>> s1 = "Name Python " >>> s2 = "had been adapted " >>> s3 = "from Monty Python" >>> print (s1 + s2 + s3) Name Python had been adapted from Monty Python -
Repetition: Suppose we want to write same text multiple times on console. Like repeat "Hi!" a 100 times. Now one option is to write it all manually, like "Hi!Hi!Hi!..." hundred times or just do the following:
>>> print ("Hi!"*100)假设，你想让用户输入某个数字
n，基于此你想让一个文本在控制台n上打印几次，你怎么做？很简单。只需创建一个变量n并使用input()功能从用户那里获取一个数字，然后将文本乘以n。>>> n = input("Number of times you want the text to repeat: ") Number of times you want the text to repeat: 5 >>> print ("Text"*n); TextTextTextTextText -
Check existence of a character or a sub-string in a string: The keyword
inis used for this. For example: If there is a text India won the match and you want to check if won exist in it or not. Go to IDLE and try the following:>>> "won" in "India won the match" True在 python 中的其他数据类型中，有布尔数据类型，它可以有两个可能的值之一，即
true或false。由于我们正在检查字符串中是否存在某个东西，因此，可能的结果要么是是，它存在或不，它不存在，因此返回真或假。这也应该让你知道在编写程序时在哪里使用布尔数据类型。 -
not in关键词:这正好和in关键词相反。如果你猜对了，你就相当聪明了。它的实现也非常类似于in关键词。
>>> "won" not in "India won the match"
False
通过单击下面的“实时示例”按钮，您可以看到上述所有字符串操作都在运行。另外，我们建议您练习使用实时编译器，并尝试更改代码并运行它。
将字符串转换为整型或浮点型数据类型，反之亦然
这在初学者中是一个非常常见的疑问，因为在 python 中，用引号括起来的数字会变成一个字符串，然后如果您试图对它执行数学运算，就会出错。
numStr = '123'
在上面的语句中123不是数字，而是字符串。
因此，在这种情况下，要将数字字符串转换为float或int数据类型，我们可以使用float()和int()函数。
numStr = '123'
numFloat = float(numStr)
numInt = int(numFloat)
然后你可以很容易地对数值进行数学运算。
同样，要将int或float变量转换为string，我们可以使用str()功能。
num = 123
# so simple
numStr = str(num)
限幅
切片是另一个字符串操作。切片允许您基于开始索引和结束索引提取任何字符串的一部分。例如，如果我们有一个字符串这是 Python 教程，我们想提取这个字符串的一部分或者只是一个字符，那么我们可以使用切片。首先让我们熟悉一下它的用法语法:
string_name[starting_index : finishing_index : character_iterate]
-
String_name 是保存字符串的变量的名称。
-
starting_index 是子字符串中想要的起始字符的索引。
-
finishing_index 比子串中最后一个字符的索引多一个。
-
character_iterate: To understand this, let us consider that we have a string
Hello Brother!, and we want to use the slicing operation on this string to extract a sub-string. This is our code:>>> str = "Hello Brother!" >>> print(str[0:10:2]);现在
str[0:10:2]的意思是，我们要从索引0(字符串的开头)开始提取一个子字符串，到索引值10，最后一个参数的意思是，我们要每隔一个字符，从起始索引开始。因此在输出中我们会得到， HloBo 。H在索引0处，然后离开e，将打印H的第二个字符，为l，然后跳过第二个l，打印第一个l的第二个字符，为o以此类推。
再举几个例子会更清楚:
我们取一个 10 个字符的字符串，ABCDEFGHIJ。索引号将从0开始，到9结束。
| A | B | C | D | E | F | G | H | 我 | J |
| Zero | one | Two | three | four | five | six | seven | eight | nine |
现在尝试以下命令:
>>> print s[0:5:1]
这里，通过在每次跳转中迭代1字符，从第 0 个字符到第 4 个字符(5-1)进行切片。
现在，去掉最后一个数字和colon只写这个。
>>> print (s[0:5]);
您将看到两个输出都是相同的。
你可以通过改变价值观来练习。也可以尝试将字符迭代变量的值更改为某个值n，然后它将打印从起始索引到最终索引的每个nth字符。
Python 中内置的字符串函数
对于最后一部分，我们将看到一些真正有用的字符串函数来处理 python 中的字符串。下面我们提到了一些有用的字符串函数。
len(字符串)
len或 length 函数用来求任意字符串的字符长度。len返回一个数字，它以一个字符串作为参数。例如，
>>> s = "Hello"
>>> print (len(s))
five
查找(subString)
如果您想找到任何字符或子字符串在任何给定字符串中的位置，您可以使用find函数。它的实现与普通函数有点不同，但不难理解。显然，要在字符串中找到一个 subString，我们必须向函数提供主字符串和要找到的 subString。例如，
>>> s = "Hello"
>>> ss = "He"
>>> print (s.find(ss))
Zero
由于He出现在字符串Hello的开头，因此返回索引0作为结果。可以直接实现/使用如下(万一你讨厌无用的打字；每个程序员都这样做):
>>> print ("Hello".find("He"))
Zero
string_name.lower()
lower()函数用于将字符串中出现的所有大写字符转换为小写字符。它接受一个字符串作为函数输入，但是该字符串不作为参数传递。这个函数也返回一个字符串。
>>> print ("Hello, World".lower());
你好，世界
string_name.upper()
upper()用于将字符串中的所有字符转为大写。
>>> print ("Hello, World".upper());
你好，世界
string_name.islower()
islower()用于检查string_name字符串是否小写。该函数返回一个布尔值，即True或False。
>>> print ("hello, world".islower())
真实的
>>> print ("Hello, World".islower());
错误的
string_name.isupper()
isupper()用于检查给定字符串是否大写。该函数还返回一个布尔值，即True或False。
>>> print ("HELLO, WORLD".isupper());
真实的
>>> print ("Hello, World".isupper());
错误的
string_name.replace(旧字符串，新字符串)
replace()函数首先将一个字符串作为输入，并要求其中的一些 subString 作为第一个参数，并要求另一个字符串替换该 subString 作为第二个参数。例如，
>>> print ("Hello, World".replace("World", "India"));
你好，印度
string_name.split(字符，整数)
假设你有一个字符串，
>>> mystring = "Hello World! Welcome to the Python tutorial"
现在我们可以使用split()函数来拆分上面声明的字符串。
如果我们选择从感叹号!将字符串拆分成两个子字符串。我们可以通过在字符参数中放一个感叹号!来做到这一点。它基本上会根据字符串中感叹号!的数量将字符串分成不同的部分。字符串的所有子片段都将存储在一个列表中。比如，
>>> print (mystring.split("!"))
[《你好，世界》，《欢迎来到 Python 教程》]
您可以将这些值存储到另一个变量中，并像这样访问它的每个元素:
>>> myNEWstring = mystring.split("!")
>>> print (myNEWstring[0]);
>>> print (myNEWstring[1]);
你好世界欢迎来到 Python 教程
复杂数据类型
Python 中的列表
在最后一节中，我们讨论了字符串以及字符串的各种属性和功能，比如它如何被认为是一个列表一样的各种字符的集合。换句话说，列表是一组有序的值，用方括号[ ]括起来。
需要注意的一个重要区别是list是可变的，即它的值可以修改。
因为它只不过是一组值，所以我们可以使用方括号[ ]中的index来标识属于列表的值。
组成列表的值称为其元素，它们可以是任何类型。我们也可以说list 数据类型是一个以给定顺序容纳多个元素的容器。为了访问列表中的元素，使用了索引，可以从向前和向后两个方向调用索引(类似于字符串)。
构建列表
如前所述，list是相似类型数据的集合。该数据可以是一个整数、一个浮点数、一个复数、一个 字符串 或 python 中的任何合法数据类型。列表总是提供一些名称，类似于一个变量，每个元素通过它们的索引号来访问。Python 有向前和向后的索引号，所以每个元素都有一个正数和一个负数来访问该元素(在下一个主题中讨论)。定义列表时，我们必须将列表的每个元素放在方括号内，每个元素用逗号分隔。
假设，如果您想创建一个空列表(如果您想在以后的程序中添加元素或者当用户给出输入时，这是可能的)，那么您可以通过声明空的方括号来初始化它，
>>> myEmptyList = []
例如，一些整数的列表将是，
>>> myIntegerList = [9, 4, 3, 2, 8]
浮点值列表，
>>> myFloatList = [2.0, 9.1, 5.9, 8.123432]
一个字符列表，
>>> myCharList = ['p', 'y', 't', 'h', 'o', 'n']
字符串列表，
>>> myStringList = ["Hello", "Python", "Ok done!"]
这些是创建列表的一些基本方法。现在让我们尝试一些其他的方法。
从另一个名单开车
假设有一个现有列表，
>>> myList1 = ['first', 'second', 'third', 'fourth', 'fifth']
现在你想创建一个新的列表，它由myList1的部分或全部元素组成，那么你可以直接赋值完成元素的复制或使用切片，只取部分元素。
为了完全复制，
>>> myList2 = myList1
使用切片，只复制前三个元素，
>>> myList2 = myList1[0:3]
为了复制最后三个元素，
>>> myList2 = myList1[-3]
在列表中添加序列号
假设您想要添加连续的整数(即 0，1，2，3，...)到你的列表中，只是不想把它们一个个都写出来，不用担心，这样做有捷径。
要在列表中存储0到(n-1)的数字，请使用range(n)功能。
>>> myList1 = range(9)
这将创建一个列表，其中包含数字 0 到 8 。
>>> myList1 = range(5, 9)
这将创建一个包含数字 5、6、7、8 的列表，即参数的第一个数字到(参数的最后一个数字- 1) 。
该range()功能可用于各种使用情况。
假设您想要创建一个包含所有整数的方块的列表。虽然对于这个问题有各种各样的编程方法，但是这里有一个 python 中的单行方法。我们将引入一些新的东西，所以可能会有点棘手。
>>> myQuickList = [x**2 for x in range(5)]
最终列表将包含类似[0, 1, 4, 9, 16]的元素，即x**2，其中x从0到(5-1)不等。
for是这里你可能不熟悉的关键词。for是让编程为程序员做很多平凡而多余的任务的关键词之一，例如，它可以创建执行循环。虽然会有一整章专门介绍这个，但这里需要注意的重要一点是for是负责在 0 到 4 范围内迭代(或重复)x并最终将迭代值的平方即(x<sup>2</sup>)存储在列表中的关键字。
附加到列表
追加基本上就是在现有的基础上增加。如果你还记得，我们告诉过你如何在 python 中通过声明一个空的方括号来创建一个空列表。现在，当您必须在列表中插入一些元素时，该怎么办？这就是append功能发挥作用的地方。您可以在一行中将任意数量的元素添加到列表的末尾，没有任何麻烦。
>>> emptyList = []
>>> emptyList.append('The Big Bang Theory')
>>> emptyList.append('F.R.I.E.N.D.S')
>>> emptyList.append('How I Met Your Mother')
>>> emptyList.append('Seinfeld')
因此，这将基本上创建一个最好的情景喜剧的列表(不再是空的)。如果你把名单打印出来。
>>>print (emptyList)
[《生活大爆炸》，《美国电影电视艺术学院》，《我如何遇见你的母亲》，《宋飞正传》]
元素索引
我们已经在字符串教程中介绍了使用索引访问字符串中的字符序列。同样，在 python 中，索引号也可以用来访问列表的元素。让我们创建一个由字符串组成的列表，并尝试使用索引号访问单个字符串。这里有一个例子，
>>> fruitsList = ["Orange", "Mango", "Banana", "Cherry", "Blackberry", "Avocado", "Apple"]
正如您在上面的代码中看到的，我们有一个包含 7 个元素的列表。要找到一个列表中的元素数量，就像字符串一样使用函数len。
>>> print (len(fruitsList));
seven
对于列表中的每个元素，下面是我们应该使用的索引号:(试着理解我们是如何分配索引号的。)
| 元素 | 远期指数 | 向后索引 |
| 柑橘 | Zero | -7 |
| 芒果 | one | -6 |
| 香蕉 | Two | -5 |
| 樱桃 | three | -4 |
| 黑莓 | four | -3 |
| 鳄梨 | five | -2 |
| 苹果 | six | -1 |
利用 python 中的列表元素
原文：https://www.studytonight.com/python/utilising-list-elements
到目前为止，我们已经创建了一个列表并且访问了该列表的单个元素，现在是时候学习如何通过使用循环迭代使用一个列表中的所有元素了。
当您有一个包含一百或一千个元素的列表，并且您想要访问其中的几个或所有元素来对它们执行一些操作或计算时，使用索引号来访问所有元素将是非常忙碌的。在这种情况下，我们使用迭代的方法，来迭代所有的列表项。为了理解如何迭代列表元素，我们将使用循环。别担心循环会在循环教程中详细介绍。
循环介绍
循环用于完成冗余和重复的任务。
使用for循环
让我们从for循环开始。为了迭代一个列表，一个for循环需要两样东西——首先，一个引用变量来存储被迭代的元素，其次，一个源(list或者一个range()，就像前面的例子一样。当for循环执行时，源的元素被一个接一个地复制到参考变量中，以便在循环中使用(执行操作)。例如，
for x in range(0,5):
print (x)
0 1 2 3 4
在上面的例子中，x是我们的参考变量，其中，range(0, 5)中的每个元素都被迭代地(一个接一个地)存储起来，非常简单。
另外，你必须知道range(0, 5)返回一个包含元素 0 到 4 的list。
使用while循环
另一种迭代方式是使用while循环。while循环需要一个条件才能运行。循环继续迭代，直到条件为真。一旦变为假，循环就会终止。例如，
i = 0
while i < 5:
print (i);
i = i+1;
0 1 2 3 4
您可以看到两个循环返回了相同的输出，但是while循环使用了条件i < 5来获得输出。简单的英文，暗示着当i小于5时，继续打印i，继续递增i“的值。你知道为什么每次打印i的值后，我们都会增加它的值吗？嗯，这是因为如果我们没有增加它的值，该值将保持与最初声明的相同，即i = 0，并且条件i < 5将始终为真，因此循环永远不会结束。这种情况导致了我们所说的无限循环。
使用带列表的循环
关于循环已经讲得够多了，现在让我们看看如何使用它们来访问列表元素。取一个包含任何类型元素的列表。现在，使用for循环，我们可以非常容易地访问列表的每个元素。为了访问元素，我们必须使用参考变量和我们的列表变量作为源。
myList = ['Last Of Us', 'Doom', 'Dota', 'Halo', ' ']
for x in myList:
print (x)
我们最后的末日多塔光环
同时迭代两个列表- zip()方法
假设有两个列表，您希望将第一个列表的每个元素顺序添加到第二个列表的每个元素中，并将其保存到第三个(空)列表中。
我们可以通过执行如下代码所示的while循环来实现这一点，但这不是正确的方法。
i = 0
A = [1, 2, 3, 4]
B = [5, 6, 7, 8]
C = []
while i < len(A):
C.append(A[i]+B[i]);
i=i+1
在上面的代码中，我们将不得不添加许多条件来确保它一直无错误地运行。例如，如果两个列表的大小不一样怎么办？
在这种情况下，我们必须做一些不同的事情，因为我们必须一起迭代两个不同列表的元素。这可以使用功能zip()来完成。
假设这两个列表是，
>>> A = [9, 8, 7, 6, 5]
>>> B = [3, 4, 5, 6, 7]
然后，让我们创建一个空列表来保存结果。
>>> C = []
那么迭代过程将需要两个引用变量，每个列表一个。
for x, y in zip(A, B):
C.append(x+y)
zip()函数可以接受任意数量的列表参数。在这种情况下，我们已经通过了两个列表 A 和 B 。由于 A 和 B 都有 5 个元素，因此zip()将使循环迭代 5 次。但是，如果两个列表的元素数量不同呢？假设 A 有n元素，B 有m元素，如果m < n那么zip()会循环m次，否则n次。
解决这个问题的另一种方法可能是使用列表 A 和 b 的索引号。
for i in range(0,5):
C.append(A[i]+B[i])
虽然在使用这种技术时，有必要在追加之前知道这两个列表的大小，但是前面的方法(zip函数)几乎可以在任何情况下使用。
从列表中删除元素
原文：https://www.studytonight.com/python/deleting-list-elements-list-functions
可能发生的情况是，你可能不得不从你的列表中删除一些元素。下面我们列出了一些同样的方法:
pop( )功能:
此方法需要您要删除的元素的索引号。例如，如果你想删除列表的第 5 个元素，那么就像这样做:
>>> myList.pop(4)
因为第四个索引是第五个元素，因为索引号从0开始。
del关键词:
这也需要索引号。
>>> del myList[4]
这将删除列表的第五个元素。我们可以结合切片一起删除元素序列，比如如果我们想删除索引 3 到 6 的所有元素，那么:
>>> del myList[3:7]
这将删除索引 3 到 6 中的所有元素。
remove( )功能:
这个函数，而不是索引号，需要必须删除的值。例如，
>>> myList = ['Apple', 'Orange', 'Apple', 'Guava']
>>> myList.remove('Apple')
这将从列表中删除第一个“苹果”元素。价值为“苹果”的其他元素不会被删除。即，我们的列表将是:
>>> print (myList);
['橙子'，'苹果'，'番石榴']
将列表转换为字符串
如果你想把你的列表转换成一个字符串来输出，你可以很容易地做到。
不使用任何循环
下面是代码，如果不想用for或while循环将列表转换成字符串。
mylist = ['butter', 'jam', 'curd']
myStr = ', '.join(mylist)
print (myStr);
黄油、果酱、凝乳
如果你有一个int值的列表，那么
mylist = [1, 11, 111]
myStr = str(mylist).strip('[]')
print (myStr);
1, 11, 11
使用for循环
如果我们有一个int值的列表，
mylist = [1, 11, 111]
myStr = ''.join(str(e) for e in mylist)
print (myStr)
1, 11, 11
列表的更多功能
1.insert(int, item)
该函数用于在列表中的任何位置插入值。列表的第一个参数取将插入项的索引，第二个参数是必须插入的值。例如，
>>> myList = ['Python', 'C++', 'Java', 'Ruby', 'Perl']
>>> myList.insert(1, 'JavaScript')
>>> print (myList)
['Python '、' JavaScript '、' C++、' Java '、' Ruby '、' Perl']
注意数值“JavaScript”是如何被插入到索引1的。
2.reverse()
从名称可以明显看出，它用于颠倒列表中元素的顺序。
>>> myList.reverse()
3.sort()
现实生活应用中最重要的功能之一就是sort()。排序以升序或降序排列列表中的所有元素。
>>> myList.sort()
如果列表由数字组成，那么这将使序列按升序排列，如果列表由字符串组成，那么元素将按字典顺序升序排列。
如果你想按降序排序呢？
>>> myList.sort().reverse()
这将首先按升序对元素进行排序，然后我们使用reverse()函数来反转列表。
Python 中的字典
原文：https://www.studytonight.com/python/dictionaries-in-python
在本教程中，我们将学习什么是字典？如何使用？和一些用于操作字典的有用函数。
字典很像列表，有一个额外的参数叫做键。回想一下，在列表和字符串中，我们是如何使用索引作为参数来访问字符串/列表的每个元素的。列表和字典之间的主要区别因素是，我们使用键来访问字典的元素(或者使用值来访问键，两者都有)。
此外，与索引不同，键可以是从整数到字符串不等的任何数据类型。这使得它们使用起来更加灵活。
创建词典
因为我们可以灵活地为字典中的每个元素提供键，所以我们必须显式地定义每个键。下面我们有一个表格格式的字典。对于字典中的每个元素，我们都有一个与之关联的键。
| 钥匙 | 价值 |
| 键-1 | 元素-1 |
| 关键 2 | 元素-2 |
| 关键 3 | 元素-3 |
| 键-4 | 元素-4 |
| 关键 5 | 元素-5 |
python 字典可以创建为:
>>> myDictionary = {'Key-1': 'Element-1', 'Key-2': 'Element-2', 'Key-3': 'Element-3', 'Key-4': 'Element-4'}
注意这里使用的花括号，不像列表中的方括号。这里键-1 、键-2 ...是元素-1 、元素-2 的键...分别是。因此，如果您想要访问字典的任何元素，您应该知道该元素的键。例如，要访问键-3 的元素，则只需使用:
>>>print( myDictionary['Key-3']);
元素-3 '
此外，在字典中，每个元素必须有一个唯一的键，因为一个键用于唯一地标识字典中的每个元素，然而，相反的情况并不成立，这意味着元素可以重复，但是键必须是唯一的。
带有整数键的字典:
>>> integerDictionary = {10: "C++", 20: "Java", 30: "Python", 40: "Ruby", 50: "C#", 60: "Perl"}
>>> print (integerDictionary[30]);
“Python”
以字符串为关键字的字典:
>>> identity = {"name": "StudyTonight", "type": "Educational", "link": "https://studytonight.com", "tag": "Best place to learn"}
>>> print (identity['name'] + ": " + identity['tag']);
StudyTonight:最好的学习场所
要创建空字典，请执行以下操作:
>>> emptyList = {}
上面一行代码成功初始化了一个空字典。我们可以很容易地在空字典初始化后向其添加元素。假设你想用键将德里添加到你的字典中，然后像这样做，
>>> emptyList["India"] = "Delhi"
这个元素将被添加到字典中。
>>> print(emptyList);
{“印度”:“德里”}
访问字典的元素
存储在字典中的元素可以像 python 中的列表一样访问，即使用for循环。然而，在迭代每个元素时，我们将获得键而不是元素的值，因此，要访问元素的值，我们必须像使用索引一样使用键，例如:myDictionary[key]。
for i in myDictionary:
print ("Key: " + i + " and Element: " + myDictionary[i]);
键:键 1 和元素:元素 1 键:键 2 和元素:元素 2 键:键 3 和元素:元素 3 键:键 4 和元素:元素 4 键:键 5 和元素:元素 5
删除字典中的元素
可以使用del关键字删除元素，这类似于在列表中删除元素。例如，考虑到我们的网站详细信息字典，
>>> identity = {"name": "StudyTonight", "type": "Educational", "link": "http://studytonight.com", "tag": "Best place to learn"}
如果我们想删除链接键及其相关值，那么
>>> del identity["link"]
将删除该元素。
>>> print (identity);
{“名称”:“StudyTonight”、“类型”:“教育”、“领域”:“标签”:“最佳学习地点”}
将元素追加到词典中
假设您想向已经初始化的列表中添加一个额外的元素，该列表包含元素，那么您所要做的就是:
>>> identity["email": "we@studytonight.com"]
它将被添加到字典中。
>>> print (identity);
{“姓名”:“StudyTonight”，“type”:“Educational”，“tag”:“最佳学习地点”，“email”:“we @ study night . com”}
更新字典中的现有元素
update()功能用于将两本词典合并为一本。后一个字典会覆盖这两个列表的公共值。例如，让我们假设有另一个字典包含 StudyTonight 的可用课程列表，以及上面示例中使用的列表。
所以现在我们有 2 个列表- identity和courseAvail
>>> courseAvail = {"Java": "Full-course", "C/C++": "Full-course", "DBMS": "Full-course"}
假设我们想要将courseAvail的所有元素复制到列表identity中，那么我们只需要执行以下操作:
>>> identity.update(courseAvail)
注意:这种情况下词典identity会更新，对词典courseAvail不会有影响。
Python 中的字典函数
原文：https://www.studytonight.com/python/functions-for-dictionary
让我们来看看一些重要的函数，当我们在 python 中玩字典时，这些函数非常有帮助。
len()
正如你可能已经猜到的，它给出了存储在字典中的元素的数量，或者你可以说只是其中的键的数量。
>>> print(len(myDictionary));
five
清除()
如果我们需要使用del关键字删除字典中的所有元素，对于每个键值，那将是相当麻烦的。因此clear()功能使清空字典成为单行任务。
>>>myDictionary.clear()
>>> print (myDictionary);
{}
值()
假设您不想在显示字典中存储的值时访问键，那么可以使用values()功能。该函数将显示存储在字典中的所有值。
>>> print (myDictionary.values());
{“元素-1”、“元素-2”、“元素-3”、“元素-4”、“元素-5”}
按键()
该功能与values()功能相反。顾名思义，如果您只想查看字典的键，那么您可以使用keys()功能。
>>>print (myDictionary.keys());
{“键-1”、“键-2”、“键-3”、“键-4”、“键-5”}
项目()
如果您想同时显示两者，键和值带有一个表示，其中两者都被很好地映射，然后使用items()方法。
>>> print (myDictionary.items());
{(“键-1”:“元素-1”)，(“键-2”:“元素-2”)，(“键-3”:“元素-3”)，(“键-4”:“元素-4”)，(“键-5”:“元素-5”)}
__ 包含 _ _
要检查字典中是否存在特定的键，可以使用该功能。如果你要找的键存在，则返回True，否则返回False。
>>> myDictionary = {'Key-1': 'Element-1', 'Key-2': 'Element-2', 'Key-3': 'Element-3', 'Key-4': 'Element-4'}
print(myDictionary.__contains__('Key-2'));
真实的
cmp():
如果您需要比较两本词典，可以使用cmp()函数。它可以返回 3 个可能的值，即 1、0 或-1。cmp()函数在 Python 2.x 中可用，但在 Python 3.x 中不可用，但我们可以轻松定义并使用该函数。如果两个字典相等，则为 0。如果第二个元素比第一个元素多，则-1 和 1 表示相反。它可以像这样使用
>>> x = {1: 1, 2:2, 3:3}
>>> y = {1:1, 2:2, 3:3}
>>> print (cmp(x, y))
Zero
由于两者相同，因此输出为0。
现在让我们给x增加一个额外的元素。
>>> x[4] = 4
>>> cmp(x, y)
one
既然x有了更多的元素，那么输出就是1。同样，如果我们将y与x进行比较，那么
>>> cmp(y, x)
-1
输出变成-1，因为y元素少。
Python 3 不支持 cmp
Python 中的元组
元组很像列表，这就是为什么我们可以像定义列表一样定义它们。简单来说，一个元组就是一个数据序列。
与列表不同的是，元组是不可变的，即元组内部的数据是不能修改的，列表的情况则相反。除此之外，元组非常类似于列表，这将使我们更容易理解，因为我们已经知道列表。如果没有，我们建议您先浏览列表教程。
定义元组
要定义一个元组，我们只需要分配一个变量，用逗号分隔多个值，该变量将被称为元组。
>>> myTuple = 1, 2, 3, 4
如果您尝试在 IDLE 下打印它，
>>> print (myTuple);
(1, 2, 3, 4)
在上例中可以看到myTuple变量实际上是 1、2、3、4 的整数集合。另外，注意那些在打印时出现在整数周围的圆形括号，这些实际上会帮助你区分列表和元组。因为在列表的情况下，我们在列表元素周围有方括号。
很明显可以在一个元组中添加不同类型的数据，
>>> secondTuple = 1, 2, "python", 4
>>> print (secondTuple);
(1，2，“python”，4)
一个空元组可以使用tuple()函数或者只使用一个空括号()来创建。
>>> emptyTuple = ();
>>> anotherEmptyTuple = tuple();
上面的语句将创建没有元素的元组。编译器会知道emptyTuple和anotherTuple是元组，其中没有元素。
元组中的索引
元组中的索引也与列表中的索引非常相似，第一个元素的索引为零，并且在接下来的连续元素中继续增加。此外，反向索引在元组中也有效，即最后一个元素可以通过-2、-3等使用索引-1和连续的先前数字来访问。让我们举个例子，
>>> example = "apple", "orange", "banana", "berry", "mango"
>>> print (example[0]);
苹果
在下表中，我们标记了正向和反向索引的元组元素:
| 价值 | 向前索引 | 反向索引 |
| 苹果 | Zero | -5 |
| 橙色的 | one | -4 |
| 香蕉 | Two | -3 |
| 浆果 | three | -2 |
| 芒果 | four | -1 |
向元组添加元素
正如我们所知，元组是不可变的，因此存储在元组中的数据是不可编辑的，但是向元组中添加更多数据是绝对可能的。这可以使用加法运算符来完成。假设有一个元组，
>>> t = (1, 2, 3, 4, 5)
如果您想向元组中添加另一个元素7，那么您可以按如下方式进行:
>>> t = t + (7,)
如您所见，我们使用加法运算符对元组t进行了add(7,)。
>>> print (t);
(1, 2, 3, 4, 5, 7)
因此，我们可以使用+运算符向元组中添加任何类型的元素。
如果我们试着想一想，我们还能用+运算符做什么，我们可能会意识到它也可以用来组合二元组。例如:
>>> print ((1, 2, 5, 8) + (2, 9, 4));
(1, 2, 5, 8, 2, 9, 4)
您可以使用一个元组来创建另一个元组。
删除元组
为了删除元组，使用del关键字。要删除名为myTuple的元组(我们之前已经定义过)，请遵循以下示例:
>>> del (myTuple);
并且myTuple将从内存中删除。
元组中的切片
元组切片的工作原理与列表完全相同。让我们从一个例子开始:
>>> t = (1, 2, 3, 4)
>>> print(t[2:4])
(3, 4)
这里，t[2:4]的意思是，从索引2到索引4对元组进行切片，然后取出切片。
切片也可以反向进行，使用负索引从反向遍历元组。
基本操作和功能
我们可以对元组执行的各种操作与列表非常相似。事实上，您刚刚看到了带有元组的+运算符，它处理元组就像处理列表一样。元组的其他一些运算符包括:
增加
将一个元组乘以任意整数，x 将简单地创建另一个元组，其中第一个元组中的所有元素重复 x 次。例如，t*3表示，元组t的元素将重复3次。
>>> t = (2, 5)
>>> print (t*3);
(2, 5, 2, 5, 2, 5)
添加
使用加法运算符，对于两个或更多元组，将所有元素加到一个新元组中。例如，
>>> t = (2, 5, 0) + (1, 3) + (4,)
>>> print (t);
(2, 5, 0, 1, 3, 4)
in关键字
in关键字，不仅可以用于元组，也可以用于字符串和列表。它用于检查序列中是否存在任何元素。如果找到元素则返回True，否则返回False。例如，
>>> t = (1, 2, 3, 6, 7, 8)
>>> 2 in t
>>> 5 in t
真假
len()功能
正如您可能已经猜到的，这个函数用于获取任何元组中的元素数量。
>>> t = 1, 2, 3
>>> print (len(t))
three
cmp()功能
这用于比较两个元组。它将返回1、0或-1，这取决于被比较的两个元组是否相似。
cmp()函数以两个元组作为参数，两者进行比较。如果 T1 是第一个元组， T2 是第二个元组，那么:
- 如果 T1 > T2 ，则 cmp(T1，T2)返回 1
- 如果 T1 = T2 ，则 cmp(T1，T2)返回 0
- 如果 T1 > T2 ，则 cmp(T1，T2)返回 -1
max()和min()功能
为了找到元组中的最大值，我们可以使用max()函数，而为了找到最小值，可以使用min()函数。
>>> t = (1, 4, 2, 7, 3, 9)
>>> print (max(t))
>>> print (min(t))
9 1
Python 关系和逻辑运算符
原文：https://www.studytonight.com/python/relational-and-logical-operators
关系和逻辑是定义程序功能的基础。有了这些基础，你就可以决定执行流程应该是什么，以及应该保持什么样的条件来确保流程保持这种状态。
在包括 python 在内的每种编程语言中，要管理任何程序的流程，都需要条件，而要定义这些条件，就需要关系运算符和逻辑运算符。
还记得那些日子吗，你在学校的数学老师曾经问你 3 是否大于 2，说是，否则就不是，这也是我们在编程世界里做的事情。
您基于表达式向编译器提供一些条件，编译器计算表达式并基于表达式的输出执行条件。在关系表达式和逻辑表达式的情况下，答案总是True或False。
运算符 是常规符号，将一个、两个或多个操作数组合在一起形成表达式。运算符和操作数是输出的两个关键决定因素。
现在让我们看看 python 语言中可用的一些运算符。
Python 关系运算符
关系运算符用于在两个操作数之间建立某种关系。一些相关的例子可能是小于、大于或等于运算符。Python 语言能够理解这些类型的运算符，并相应地返回输出，可以是True或False。
让我们检查几个关系表达式。打开你的 IDLE，试试这个:
>>> 5 < 9
真实的
由于5小于9，因此返回的输出为True。
可用操作员列表包括:
- 小于 →与
<一起使用 - 大于 →与
>一起使用 - 等于 →与
==连用 - 不等于 →与
!=连用 - 小于或等于 →与
<=连用 - 大于或等于 →与
>=连用
您可以尝试每个运算符来练习一些数字(甚至字符串)。
>>> "abc" > "aaa"
>>> "abc" == "bcd"
真假
Python 逻辑运算符
逻辑运算符，顾名思义，用在逻辑表达式中，其中操作数或者是True或者是False。逻辑表达式中的操作数可以是在求值时返回True或False的表达式。逻辑运算符有三种基本类型:
- 逻辑与:对于与运算，当且仅当两个操作数都为
True时，结果为True。该运算符使用的关键字是and。 - 逻辑“或”:对于“或”运算，如果其中一个操作数为
True，则结果为True。该运算符使用的关键字是or。 - 逻辑非:如果操作数为
False，结果为True。该运算符使用的关键字是not。
让我们看几个例子:
>>> True and False
错误的
>>> not True
错误的
现在，我们也知道关系表达式返回一个布尔值作为它们的输出，因此知道我们可以结合关系表达式和逻辑表达式来创建一些更有意义的东西。例如，
>>> (2 < 3) and (2 < 5)
真实的
>>> (2 < 3) and (2 < 1)
错误的
举一个更实际的编程例子，假设您有一个变量x作为输入，您想检查用户输入的值是否在某个范围内，比如 0 到 100，然后:
>>> x = int(input())
Twenty-five
>>> (x > 0) or (x < 100)
真实的
Python If、Else和Elif条件语句
原文：https://www.studytonight.com/python/conditional-statements
在上一个教程中，我们学习了逻辑表达式和关系表达式，并试图借助各种例子来理解它们的用法。我们还看到了如何借助逻辑运算符将多个关系表达式组合在一起以创建有意义的逻辑表达式的例子。
我们还提到了如何使用这些逻辑和关系表达式来控制执行流程。
在本节中，我们将学习更多控制执行流程的方法。在编程中，有两种方法可以实现这一点，它们被称为条件语句和循环。
在本教程中，我们将讨论条件语句，所以让我们开始。
条件语句
在编写程序时会有各种各样的情况，这时你必须注意程序执行时可能出现的不同情况。在这种情况下，可以使用if条件。
if条件
使用if关键字的语法如下:
if [conditional expression]:
[statement(s) to execute]
if关键字，条件表达式以冒号结束。在【条件表达式】中引入了一些条件表达式，这些条件表达式应该返回一个布尔值，即True或False。如果结果值为True，则执行【要执行的语句】，这在带有 tabspace 的if条件下提到(这个缩进非常重要)。
举一个现实生活中的例子，假设在一个储蓄银行账户中，用户 A 有 1000 卢比。用户 A 访问自动取款机，从他的储蓄账户中取款。现在处理自动柜员机交易的程序应该能够在每种情况下执行，就像程序应该知道用户的银行账户余额一样，不应该允许用户提取超过其账户可用余额的资金。此外，一旦用户从账户中取款，程序必须更新账户余额，以保持记录的更新。让我们写一小段代码来阻止用户提取超过可用账户余额的钱。
>>> savingAmt = 1000
>>> withdrawAmt = int(input("Amount to Withdraw: "));
>>> if withdrawAmt > savingAmt:
print ("Insufficient balance");
提取金额:2000 余额不足
在上面的程序中，如果用户输入任何超过卢比的金额。1000 时，屏幕上会显示一条消息，说明“资金不足”。
还有两个关键词是可选的，但可以伴随if语句，它们是:
elseelif(也称为 else if)
else条件
说到else，我们先来看看它是如何与if语句并列使用的。
if[conditional expression]:
[statement to execute]
else:
[alternate statement to execute]
继续银行账户-自动取款机的例子，如果你在上面的程序中注意到，我们忘记从储蓄账户余额中减去提取的金额。既然现在我们有了一个额外的else条件可以使用，我们可以打印一条警告信息，如果储蓄金额小于提取金额，则显示“余额不足”，否则我们可以从储蓄账户金额中减去提取金额来更新账户余额。所以前面例子中写的if条件，会得到一个额外的else块。
if withdrawAmt > savingAmt:
print ("Insufficient balance");
else:
savingAmt = savingAmt - withdrawAmt
print ("Account Balance:" + str(savingAmt));
引入else块，如果有足够的余额，将从savingAmt中减去withdrawAmt，更新后的账户余额将显示在屏幕上。
有了if和else，现在我们可以将执行流程分成两个不同的方向。在储蓄账户的情况下，只有两种情况，你有足够的钱或者没有，但是如果我们遇到两种以上的情况呢？在这种情况下，我们使用另一个伴随着if和else语句的语句，称为elif(或者如果用恰当的英语)。
elif条件
elif语句添加在if和else区块之间。
if[condition #1]:
[statement #1]
elif[condition #2]:
[statement #2]
elif[condition #3]:
[statement #3]
else:
[statement when if and elif(s) are False]
有了这个，你可以根据可能出现的可能性添加任意多的elif块。
假设给你一个时间，你必须告诉它是一天中的哪个阶段——(早上、中午、下午、晚上或晚上)。你必须对照 5 个阶段中每个阶段所处的多个时间范围来检查给定的时间。因此，以下条件:
- 上午 : 0600 至 1159
- 中午 : 1200
- 下午 : 1201 到 1700
- 晚上 : 1701 到 2000
- 夜间 : 2000 到 0559
下面我们有一个简单的程序，使用if、elif和else条件语句:
if (time >= 600) and (time < 1200):
print ("Morning");
elif (time == 1200):
print ("Noon");
elif (time > 1200) and (time <= 1700):
print ("Afternoon");
elif (time > 1700) and (time <= 2000):
print ("Evening");
elif ((time > 2000) and (time < 2400)) or ((time >= 0) and (time < 600)):
print ("Night");
else:
print ("Invalid time!");
请注意程序中每个条件中使用的逻辑运算符，这个例子演示了如何在 if-else 语句中使用它们。
嵌套 if-else 语句
简单地说，嵌套if else意味着您将在另一个 if-else 语句中编写 if-else 语句。在句法上，
if[condition #1]:
if[condition #1.1]:
[statement to exec if #1 and #1.1 are true]
else:
[statement to exec if #1 and #1.1 are false]
else:
[alternate statement to execute]
不用说，你也可以在一个else块里面写同样的 if-else 块。或者实际上你可以根据自己的需要增加一个elif条件。尽管如果你仔细想想，嵌套的 if-else 实际上是elif的一个替代物。就像我们创建了一个通过检查时间范围来打印一天的相位的程序一样，这也可以在不使用elif的情况下完成，只需嵌套if和else。
if (time >= 600) and (time < 1200):
print ("Morning");
else:
if (time == 1200):
print ("Noon");
else:
if (time > 1200) and (time <= 1700):
print ("Afternoon");
else:
if (time > 1700) and (time <= 2000):
print ("Evening");
else:
if ((time > 2000) and (time < 2400)) or ((time >= 0) and (time < 600)):
print ("Night");
else:
print ("Invalid time!");
正如你在上面的程序中所看到的，我们所做的只是，我们从给if块添加一个条件开始，然后在它的else块中使用另一个if-else块。我们继续筑巢，直到所有的条件都解决了。不过，这比使用
另外，如果你在解释if语句时还记得我们的第一个例子，储蓄银行账户的例子。实际上有一种更快的方法，一行的方法，因为它是 python。逻辑如下:
如果(保存>提取)则保存=(保存-提取)，否则保存将保持原样，不会有任何交易。
>>> savingAmt = savingAmt - withdrawAmt if (savingAmt > withdrawAmt) else savingAmt
Python 中的循环
在本节中，我们将看到 python 中的循环是如何工作的。循环只是编程中常用的一种功能，用于完成重复性任务。它可以从迭代数组或字符串的每个元素，到修改整个数据库。
使用循环的经验法则是:
如果你正在一次又一次地写一段类似的代码，那么是时候进行循环了。
与其做，
>>> a = 1
>>> b = 2
>>> c = 3
>>> d = 4
等等，像这样做，
>>> a = []
>>> {run a loop in this line to store 1, 2, 3, 4 in list a}
在第二个代码片段中，我们将使用一个循环，在这里我们只需要编写我们必须完成的任何繁琐的任务，只需要一次，然后将它放在一个循环中。有了这个，我们将能够实现一个迭代流程来执行。
在 python 中，有两种方法可以实现迭代流:
- 使用
for循环 - 使用
while循环
for循环
让我们先看看语法是什么，
for [ELEMENT] in [ITERATIVE-LIST]:
[statement to execute]
else:
[statement to execute when loop is over]
[else statement is completely optional]
for循环常用于迭代列表的元素。考虑到上面的语法，假设有一个列表myList:
>>> myList = [8, 9, 2, 3, 4, 6]
如果我们想使用for循环迭代列表myList的所有元素:
for i in myList:
print (i)
正如我们所看到的，我们正在使用一个变量i，它一个接一个地表示列表中存储的每个元素。只要列表中有元素，我们的循环就会运行很多次。例如在myList中有 6 个元素，因此上面的循环将运行 6 次。
在第一次迭代中，i的值将是8，而在下一次迭代中，它将是9等等，直到最后一次迭代中的6。这样做，可以很容易地在循环中使用这些单独的列表元素值，就像在我们的例子中，我们已经打印了它们。
除此之外，还有另一种方法。如果你还记得的话，我们通过索引访问列表中某个元素的传统方式- myList[i]。虽然，在这种情况下，我们将使用另一个功能range()(或者也可以使用xrange())。range()功能也已经在前面的章节中提到过了。如果你能记住range()函数可以根据你提供的参数返回一个数字列表。例如:
>>> range(5)
[0, 1, 2, 3, 4]
或者，
>>> range(5, 10)
[5, 6, 7, 8, 9]
或者，
>>> range(2, 12, 2)
[2, 4, 6, 8, 10]
我们可以使用range()函数和for循环来迭代从0到len(myList)的索引号。这将非常像:
for i in range(0, len(myList)):
print (myList[i])
正如你可能已经注意到的，在这种情况下，我们将遍历一个临时列表，它包含实际列表的索引号。该临时列表是使用range()功能生成的。
在for循环中的else块
一旦列表的所有元素都被迭代或者列表中没有更多元素需要迭代，就执行带有for循环的else块。可以肯定地说else语句是在循环结束时执行的。虽然，正如语法中已经提到的，它完全可以随意使用，事实上，它甚至不经常使用。
看一些更复杂的例子，假设有一个列表:
>>> bigList = [[1, 3, 6], [8, 2,], [0, 4, 7, 10], [1, 5, 2], [6]]
你认为，我们将如何访问列表的每个元素？
答案是，在另一个循环中使用一个循环。由于列表中有列表，因此外部循环将有助于访问bigList的每个列表，而在该循环中，对于每个列表元素，我们将使用另一个循环。
for i in bigList:
for j in i:
print ("Element of list within a list - ", j)
列表中的列表元素- 1 列表中的列表元素- 3 列表中的列表元素- 6 列表中的列表元素- 8 列表中的列表元素- 2 列表中的列表元素- 0 列表中的列表元素- 4 列表中的列表元素- 7 列表中的列表元素- 10 列表中的列表元素- 1 元素 列表中的列表元素-列表中的列表元素-列表中的列表元素- 6
while循环
是时候学习 while 循环了。
语法:
while [condition]:
[statement to execute]
else:
[statement to execute if condition is false]
[else statement is completely optional]
同样，在while循环中，也有一个else块，尽管它是可选的，很少使用。
在第一条语句中，while循环设置一个条件，然后是一个语句，编译器按照执行流程，首先检查条件块中提供的条件，如果条件成立True，则执行该语句。
一旦该语句被执行，编译器再次检查条件，如果再次是True，则该语句再次被执行，否则执行else块(如果提供的话)或者仅仅是流控制脱离while循环(如果没有提到 else 语句)。
这里有一个例子:
注意:不要在 IDE、IDLE 或者任何地方尝试这个例子。
while True:
print ("I am printing because the condition is True")
由于这里我们已经将条件设置为True，因此编译器将第一次执行该语句。在下一次迭代中，条件仍然是True，因此语句将再次执行。这将继续发生，正如你可能已经猜到的，这个循环不会结束。这种循环叫做无限循环，在程序中应该避免。
再举一个例子:
i = 0
while i < 5:
i=i+1
print ("i =", i)
在这种情况下，在第一次迭代中检查条件i < 5，由于0 < 5，因此执行语句。在执行过程中，i的值增加1。
for循环，常用于迭代一个列表的元素，while循环则可以服务于多个目的，也可以迭代一个列表！使用索引访问元素的逻辑非常相似。运行从 0 到len(myList)的循环，只需访问元素。并且，不需要使用range()或xrange()功能。
myList = [8, 9, 2, 3, 4, 6]
i = 0
while i < len(myList):
print (myList[i])
i = i+1;
快速浏览列表中的列表示例:
bigList = [[1, 3, 6], [8, 2,], [0, 4, 7, 10], [1, 5, 2], [6]]
i = 0
j = 0
while i<len(bigList):
while j<len(bigList[i]):
print (“Element of list within a list -”,bigList[i][j])
j=j+1;
i=i+1
continue关键词
continue关键字在循环中用于改变循环执行。在循环内使用continue将跳过当前语句的执行，并再次检查条件。假设有一个字符串，
>>> name = "StudyTonight"
让我们来看一个演示使用continue关键字的快速例子:
for i in name:
continue
print (i)
不会打印任何东西。让我们看看为什么？在第一次迭代中，将选择列表name的第一个元素，即"S"，for循环中的下一个语句是continue，因此一旦找到该关键字，将跳过其余for循环语句的执行，流程返回到for循环，开始获取下一个元素并检查条件。相同的步骤之后是字符串的下一个元素，即"t"，并且continue再次中断流程，并且这将在每次执行流程到达continue键时发生。
所以，现在如果我们想编写一个循环程序，只打印存储在name变量中的字符串的小写字母，那么，我们可以使用continue关键字跳过那些不小写的字母。
for i in name:
if not i.islower():
continue
print (i)
if条件使用islower()功能检查元素i是否小写。如果它不是小写的，那么剩下的语句就被跳过，并且print语句永远不会被执行，但是，如果i是小写的，那么if语句返回False并且continue语句不会被执行。
continue关键字的工作方式与while循环完全相同。
break关键词
break关键字在循环内部使用，用于脱离循环。假设在迭代存储在变量name中的字符串的字符时，一旦遇到字符"T"，您就想要脱离它。这是如何做到的:
for i in name:
if i == "T":
break;
print (i)
现在，一旦if条件得到字符"T"，编译器将执行break语句，执行流程将脱离循环。
OOPS 概念
使用 Python 编写用户定义函数
在这一点上，很明显你们都知道什么是函数！您已经在之前的教程中遇到过几个内置函数。虽然，由于所有这些函数都是内置的，我们所要做的就是通过调用它们并在需要时提供所需的参数来直接使用它们。
程序中显式定义的函数(由用户定义)也有助于将整个程序划分为子部分，从而使其可读性更强，易于修改代码和修复任何错误或 bug。
是时候学习如何在 python 中创建自己的函数了，这些函数也被称为用户自定义函数。
正如我们在前面的教程中已经看到的，要使用任何内置函数，我们必须在程序中导入定义函数的模块。例如，在下面的程序中，我们已经导入了math模块来使用floor()内置功能。
import math
a = 2.3
print ("The floor of 2.3 is : "+ math.floor(a))
如果您打开模块文件，这只是一个 python 文件，您将能够看到各种函数的定义，就像您很快就会做的那样，那时您将开始定义自己的用户定义函数。
函数定义的结构
让我们看看如何创建一个简单的函数。语法是这样的，
def functionName(parameter1, parameter2, ...):
logic/algorithm statements
...
return someData
这里的第一点，缩进非常重要，函数的定义应该在def functionName(parameter1, parameter2):后面缩进一个 tabspace
现在让我们试着逐一理解每一行。第一行称为函数头以关键字def开始，实际上是定义，因为这是开始定义函数的起点。接下来是函数的名字，在这里你给函数取一个名字，比如说加、乘、交换或者任何表示函数实际将要做什么的东西。
接下来，在圆形支架内，出现了参数。这些是一些必需的值，用户可以输入，并在操作过程中在函数内部使用。大家可能还记得，我们在调用数学函数的时候是怎么放几个数字的，比如sin(3.14)，这里 3.14 是参数值。我们知道，如果没有像 3.14 这样的值，sin()功能将没有值来执行正弦操作。同样，您也可以在定义函数时指定用户定义的函数需要一些参数才能成功执行。
来到第二行，我们有逻辑/算法语句。在这里，我们将利用所有的参数(如果有的话)来实现函数应该做的事情。我们可以有各种操作、循环、条件语句等。在这里完成它。以add()函数为例，在这个函数中执行简单的加法- a + b并将结果存储到某个变量中，比如说c，因此在add()函数中，我们有一个表达式，c = a + b、a和b是输入值。
最后是返回语句。关于返回语句，首先要知道的是，函数中没有强制要求。如果您的函数应该在任何操作后返回值，那么您必须使用 return 语句来输出该值，否则您的函数不需要它。因此，您必须始终知道何时有一个返回语句。返回的数据可以是任何东西-一个号、字符串、一个布尔值、一个列表或其他任何东西。
在函数add()的情况下，我们期望它给我们一些(数据)值吗？是。这是什么？作为参数传递的两个数相加的结果。所以，add()函数应该有一个返回的语句。要返回任何值，我们只需在 return 关键字旁边提到我们想要返回的值。
def add(a, b):
c = (a+b)
return c
或者，您可以直接返回 (a+b) ，而不将其存储到其他变量中。
def add(a, b):
return (a+b)
一旦定义了一个函数，我们就可以像调用内置函数一样简单地调用它，也就是说，如果我们想添加 5和9，那么，
>>> print add(5, 9)
Fourteen
事实上，你甚至可以传递一个函数作为参数！例如:
>>> print add(5, add(7, 6))
Eighteen
迷茫？别担心，让我们解释一下。首先对add(7, 6)进行求值，其结果即13作为参数传递到第二个add()函数中，与5相加。所以最后的结果就是，add(5, 13)的输出，也就是18。
函数的返回类型
每个函数都有一个返回类型，它只不过是它返回的值的类型。决定任何函数的返回类型非常简单。在add()函数中，如果a和b是整数，那么add()函数将返回一个整数值，这将是它的返回类型。同样，如果函数返回一个列表，那么它的返回类型将是一个列表。对于内置函数，您可以在官方文档中找到每个函数的返回类型。
但是怎么可能每个函数都有一个返回类型，因为我们前面提到过，有一个返回语句是完全可选的，完全取决于函数中是否需要它。因此，问题出现了，什么是不返回任何东西的函数的返回类型？答案是，void，这几乎是空或无的同义词，表示如果没有 return 语句，那么函数将有void返回类型。
让我们看看在哪里可以使用返回类型的函数void。
提示:由于它们不返回任何东西，这些可以用来将你的程序分成更小的单元。
假设有一个简单的程序，其中，你从用户输入一个正数，打印所有偶数，所有奇数的两倍，从1开始到那个数字。没有任何功能的程序如下所示:
n = input()
for i in xrange(1, n+1):
if i%2 == 0:
print i
else:
print 2*i
现在让我们试着用一个函数来实现它。我们将从定义顶部的函数开始。尽管如此，在哪里定义函数并不重要，因为这对执行流程没有影响。只有调用函数才会开始执行函数。但是在程序开始时定义所有的函数是一个很好的做法，因为这是所有程序员在查看任何代码时寻找所有用户定义函数的地方。
def check(k):
if (k%2==0):
print k
else:
print 2*k
n = input()
for i in xrange(1, i+1):
check(i)
如你所见，我们只是拿起了检查数字是否为偶数的逻辑，并在check()函数中定义了它。然后我们在for循环中调用它，在每次迭代中向它传递一个新值。这实际上稍微清理了一下的循环，使其看起来更加整洁。
上面的程序是一个简单的程序，但是当你要用 100 行代码编写程序时，那么把程序占卜成函数是一个非常好的做法。
使用函数的一个优点是，您可以随时重用该函数，只需调用它。在上面的例子中，如果我们想打印一个偶数，或者打印它的两倍，如果它是奇数，那么我们所要做的就是简单地调用这个函数，并将这个数字作为参数传递，就完成了。check(9)，汉迪，对吧？
默认参数
当您需要预先设置参数值时，将使用默认参数。也就是说，如果将来我们在调用函数时不传递任何变量作为参数，那么函数将采用默认值来执行其语句。
现在，如何定义默认参数？我们以add()函数为例。如果我们这样做，会发生什么:
>>> print add()
没有任何默认参数，python 会立即抛出一个错误。因此，让我们为add()函数设置默认参数，这样它就可以工作，即使没有参数值。我们认为 defulat 值应该为零。这样，返回值将是0 + 0，即0，这也是有意义的，因为我们没有传递任何参数/参数值。
更新后的add()功能将是，
def add(a=0, b=0):
return (a+b)
一切都结束了。
>>> print add(10, 6)
>>> print add()
16 0
别名函数名
Python 有一个特别的功能，可以为任何函数创建一个别名，即如果你认为一个函数名太长，不值得每次都输入，你可以为它决定一个新的名字，而不改变原来的函数。以add()函数为例，假设我们想要为这个函数取一个更短或不同的名称，但不需要编辑原始函数，我们可以通过使用函数别名功能来实现。假设我们想把add()改名为a()，那么，
>>> a = add
完成了。在这一行之后，add()和a()将调用相同的函数，因此，显然，参数也需要相同。因此现在下面将像add()功能一样工作，
>>> print a(9, 8)
Seventeen
面向对象编程基础
自从编程语言产生以来，计算机科学家们一直在努力开发几种给计算机编程的方法。最终，随着越来越发达的编程语言的出现，人们过去编写程序的方式也发生了变化。方法论，算法，概念化，这些年来一直在发展。如今，面向对象编程是编程任何应用的流行方法。
一种特定的编程语言必须以一种非常具体的方式来设计，这样才能遵循一种特定的方法。就 Python 而言，它是一种面向对象的编程语言。在本节中，我们将看到 Python 中有哪些特性支持或支持它成为面向对象的编程语言。首先，让我们试着理解什么是面向对象编程？(或 OOP)和它的概念。
什么是面向对象编程？
面向对象编程是一种与类的概念、对象以及围绕这两者的各种其他概念相关联的编程风格，如继承、多态、抽象、封装等。
面向对象程序设计的方式是，人们在编程时应该关注一个对象，而不是过程。物体可以是我们在周围看到的任何东西。它可以是一个人(具有一些属性，如姓名、地址、DOB 等)、一把椅子(由大小、材料、成本等描述)、一所学校(由地点、学生实力、结果等描述)等。
面向对象编程使编程接近现实生活，因为我们总是在处理一个对象，对它执行操作，使用它的方法和变量等。
面向对象的概念
在下面的视频中，我们借助一个非常容易理解的例子解释了面向对象编程的基本概念。如果你想跳过视频，所有内容都在下面讨论。
让我们试着通过一个简单的例子来了解一下这些。人类是有生命的形式，大致分为两种，男性和女性。正确是真的。每个人(男性或女性)都有两条腿、两只手、两只眼睛、一个鼻子、一颗心等。男性和女性都有一些常见的身体部位，但男性有一些女性没有的特定身体部位，女性有一些身体部位，但男性没有。
所有的人都走路、吃饭、看、说话、听等等。现在，男性和女性都执行一些共同的功能，但是两者都有一些细节，这对另一个是无效的。比如:女的可以生，男的不可以生，所以这只针对女的。
人体解剖学很有趣，不是吗？但是让我们看看这一切是如何与 Python 和 OOPS 相关联的。在这里，我们将尝试通过这个例子来解释所有的 OOPS 概念，在下一个教程中，我们将有所有这些的技术定义。
班级
这里我们可以把人类作为一个类。类是定义其属性和功能的任何功能实体的蓝图。像人一样，有身体的一部分，做各种动作。
遗产
考虑HumanBeing一个类，有手、腿、眼等属性，有走、说、吃、看等功能。Male和Female也是类，但是大部分属性和函数都包含在HumanBeing中，因此它们可以使用继承的概念从类HumanBeing继承一切。
目标
我的名字是阿布舍克，我是类Male的实例/对象。当我们说，人类，男性或女性，我们只是指一种，你，你的朋友，我，我们是这些类的形式。我们有一个物理存在，而一个类只是一个逻辑定义。我们是目标。
抽象
抽象意味着，只向外界展示需要的东西，而隐藏细节。继续我们的例子，人类的会说话，会走路，会听，会吃，但是细节对外界是隐藏的。在我们的案例中，我们可以将皮肤作为抽象因素，隐藏内部机制。
包装
这个概念用我们的例子来解释有点棘手。我们的腿被绑在一起帮助我们走路。我们的手，帮我们拿东西。属性与函数的这种绑定称为封装。
多态
多态是一个概念，它允许我们重新定义某件事的工作方式，要么通过改变它是如何完成的，要么通过改变它所使用的部分。这两种方式都有不同的术语。
Python 中的面向对象概念——更多示例
正如我们已经讨论过的与类、对象、继承等相关的一般概念，使用的是前面教程中的一个例子。在本教程中，我们将详细阐述这些主题。
目标
正如在前面的教程中已经讨论过的，对象是一个物理实体，而类是一个逻辑定义。一个对象可以是任何类似的东西——设计学校记录注册表时的学生，文具物品管理程序中的笔，或者制造商汽车数据库程序中的汽车。它有三个重要的特征，它们是:
- 身份:身份是指可以用来识别一个类的对象的某种信息。可以是学生的名字，汽车的公司名称等。
- 属性:该对象的属性称为属性。比如年龄，性别，对一个学生的 DOB、或发动机类型、汽车的档位数量。
- 行为:任何物体的行为都等同于它所能执行的功能。在面向对象程序设计中，可以给一个类的对象分配一些函数。举个例子，像学生会读/写，汽车会加速等等。
班级
类是定义属性和行为的蓝图。例如，如果圣雄甘地，萨钦·坦杜尔卡，你和我是对象，那么人类就是一个类。对象是面向对象程序设计的基本概念，但是类提供了定义相似类型对象的能力。
在类中，数据和将对该数据进行操作的函数被捆绑为一个单元。
比如说有一个叫Car的类，它有一些基本的数据，比如——名称、型号、品牌、制造日期、发动机等，还有一些功能比如打开发动机、踩刹车、加速、挂档、吹喇叭等。现在所有的基本特征都在我们的类Car中定义了，我们可以通过设置属性名称、模型等的值来创建它的对象，并且类Car的对象将能够使用在其中定义的函数。
数据隐藏
数据隐藏帮助我们定义来自外部世界的数据隐私，或者准确地说，来自其他类别的数据隐私。这样做的原因是为了创建访问对象数据的几个级别，并防止它被意外修改。此外，也可以对功能进行隐藏或设置隐私级别。
在 OOP 中，类内的数据可以定义为公共、私有或受保护。私有数据或函数是不能从类外部访问或看到的，而公共数据或函数可以从任何地方访问。受保护的数据或功能，或多或少表现得像公共的，但不应该从外部访问。
数据的抽象
类使用抽象的概念。类通过向用户隐藏复杂的实现细节来封装相关数据和对数据进行操作的函数。用户需要关注一个类做什么，而不是它如何做。
包装
封装，是一个对象存在的核心原因之一。从一开始，我们就一直在谈论对象，它的数据，功能，隐私等。现在是时候知道这一切是如何被限制的了。答案是封装。虽然听起来很像胶囊，但实际上是一样的。这里我们尝试将属于同一类的数据和函数封装在一起。
遗产
正如在前面的教程中所解释的，继承是指在一个地方定义一组核心属性和函数，然后通过继承定义它们的类来重用它们。
Python 支持简单、多和多级继承。我们将在继承教程中详细介绍这些内容。
多态
多态，或 Poly + Morph ，意思是“多形态 sb 。确切地说，多态是任何函数或运算符的属性，这些函数或运算符可以根据它们被输入的内容而有所不同。
多态可以通过两种不同的形式实现，它们是:
函数重载
在面向对象程序设计中，使用函数重载，可以使一个函数有不同的行为。我们所要做的就是，用不同的参数创建不同的同名函数。例如，考虑一个函数add()，它将它的所有参数相加并返回结果。在 python 中，我们将它定义为，
def add(a, b):
return a + b;
这能够执行如下函数调用:
>>> add(4,5)
上面的add函数总是以 2 个数字作为输入，但是如果你想一次加 3 个数字或者可能加 4 个数字呢？
因此，在面向对象程序中，你可以简单地再次定义函数add，这次是用 3 个参数，这种机制被称为函数重载。
# to add 3 numbers
def add(a, b, c):
return a + b + c;
# to add 4 numbers
def add(a, b, c, d):
return a + b + c + d;
现在我们可以用两个、三个或四个参数调用add()函数。这里可以看到，函数add()现在有多种形态。
操作员超载
你知道什么算符是:加法、除法、乘法等。Python 能够根据情况以不同的方式读取运算符。例如，
>>>print(2 + 5)
它会给你输出7，但是在做什么
>>>print( "hello" + "world")
给你输出"helloworld"。我们可以在这里看到，+运算符在与数字一起使用时执行数学加法运算，但在与字符串一起使用时执行串联运算。
类似地，乘法运算符也根据其使用的变量的数据类型而有所不同。例如，
>>>print( 3*7)
当在弦上时，给出，21，
>>> print("hello"*3)
它给出，"hellohellohello"。这是操作员超载的又一个例子。
Python 类
在本教程中，我们将学习如何用 Python 定义一个类。
正如在上一个教程中所讨论的，类是绑定在一起的变量和函数的集合。
定义类的语法
定义一个类很简单，你所要做的就是使用关键字class，后跟你想给你的类起的名字，然后是一个冒号符号:。标准的做法是以大写字母作为类名的开头，然后遵循 camel case 样式。
包含了类定义，从下一行开始，应该缩进，如下面的代码所示。此外，一个类中可以有变量和成员函数。
class MyClass:
# member variables
variable1 = something
variable2 = something
# member functions
def function1(self, parameter1, ...):
self.variable1 = something else
# defining a new variable
self.variable3 = something
function1 statements...
def function2(self, parameter1, ...):
self.variable2 = something else
function2 statements...
让我们试着理解上面的代码，尽管它是不言自明的。如前所述，我们使用了关键字class，通知编译器从这里开始一个新的类定义，然后是类名，即MyClass。
在第 2 行，我们添加了一个注释，在第 3 行和第 4 行，我们声明了两个变量variable1和variable2，并用一些值初始化了它们。
这只是一个解释我们如何定义一个类的例子，我们将在这一节之后看到一个类的例子。
下面定义了两个函数。同样，我们提到示例函数只是为了解释语法。
正如您在代码中看到的，这几乎是我们在没有类的情况下使用def关键字所做的常见函数定义，除了一个名为self的新参数。这就是类的功能不同于通常功能的地方。
对于类中定义的每个函数来说，这是一个强制参数。self表示类的当前活动对象，使用该对象调用类的函数。不要担心，如果你不能理解它，我们将在了解对象时再次解释这一点。
这就是我们在 python 中定义类的方式，现在让我们了解如何创建类的实例/对象
为类创建对象
班级只是一个蓝图或模板。当我们定义一个类时，没有分配存储。对象是类的实例，它保存类中声明的数据变量，成员函数对这些类对象起作用。
要创建一个对象，我们要做的就是:
myObject = MyClass()
其中，MyClass是类名，myObject是对象变量
如您所见，我们简单地指定了对象的名称，并调用了一个函数，该函数与它所属的类具有相同的名称。
**你还记得我们是如何通过写myList = list()来初始化列表的吗？这里的情况类似，我们创建了一个名为MyClass的用户定义数据类型(一个类)，为了通知 pythonmyObject变量将属于该数据类型，我们调用了这个函数。
举个例子
到目前为止，它只是理论，帮助你理解类是如何定义的，对象是如何在 python 中创建的。接下来，我们将看到如何使用对象来调用成员函数和变量(在类中定义)。
让我们编写一个小的 python 程序，其中我们将定义一个具有一个变量和两个方法的类，然后我们将创建该类的一个对象，并尝试访问变量和成员函数。
class Apollo:
# define a variable
destination = "moon";
# definig the member functions
def fly(self):
print ("Spaceship flying...");
def get_destination(self):
print ("Destination is: " + self.destination)
我们已经定义了一个名为Apollo的类。如您所见，在函数get_destination中，我们编写了self.destination，这将给出存储在变量destination中的值，该变量用于调用函数get_destination的对象。
迷茫？别担心，你会明白的，让我们为这个类快速创建两个对象。所以为了创造物体，我们知道该做什么，
class Apollo:
# define a variable
destination = "moon"
# defining the member functions
def fly(self):
print ("Spaceship flying...");
def get_destination(self):
print ("Destination is: " + self.destination);
# 1st object
objFirst = Apollo()
# 2nd object
objSecond = Apollo()
现在我们已经为我们的类定义了两个对象。到目前为止，我们的两个对象都有一个变量destination，它被赋予了值“月亮”。
要使用对象访问任何成员变量或成员函数，我们使用.(点)，如下所示。
class Apollo:
# define a variable
destination = "moon"
# defining the member functions
def fly(self):
print ("Spaceship flying...");
def get_destination(self):
print ("Destination is: " + self.destination);
# 1st object
objFirst = Apollo();
# 2nd object
objSecond = Apollo();
# lets change the destination for objFirst to mars
objFirst.destination = "mars";
在上面的代码中，我们已经为对象objFirst将变量destination的值更新为“火星”
现在让我们调用成员函数。
class Apollo:
# define a variable
destination = "moon"
# defining the member functions
def fly(self):
print ("Spaceship flying...");
def get_destination(self):
print ("Destination is: " + self.destination);
# 1st object
objFirst = Apollo();
# 2nd object
objSecond = Apollo();
# lets change the destination for objFirst to mars
objFirst.destination = "mars";
# objFirst calling fly function
objFirst.fly();
# objFirst calling get_destination function
objFirst.get_destination();
# objSecond calling fly function
objSecond.fly();
# objSecond calling get_destination function
objSecond.get_destination();
宇宙飞船飞行...目的地是:火星飞船飞行...目的地是:月球
需要注意的几点:
- 我们在定义成员函数时添加了
self参数，但是在调用函数时没有指定。 - 当我们为
objFirst调用get_destination函数时，它给出的输出为目的地为:火星，因为我们为对象objFirst更新了变量destination的值 - 要使用对象访问成员函数或成员变量，我们使用点
.符号。 - 为了创建任何类的对象，我们必须调用与该类同名的函数。
创建类对象的 Python 构造器
原文：https://www.studytonight.com/python/constructors-in-python
在上一个教程中，我们学习了如何创建一个类、它的实例以及如何访问类成员(变量和函数)。在本教程中，我们将通过学习更多关于课程的知识来提高我们对课程的理解。到目前为止，已知class关键字用于初始化一个类的定义，后跟该类的名称。用冒号结束第一行后，我们移动到下一行，并在提供适当的缩进后开始定义变量或方法。
什么是构造器？
正如在上一个教程中看到的，我们知道有两种方法可以声明/定义一个类的变量。
首先，通过简单地在类中定义它，甚至用一些值初始化它，然后在那里，非常像:
class Example:
myVariable = "some value";
第二种方法是在类的任何函数中使用self关键字声明它们。
此外，可以在声明变量时为它们赋值，但有时这些变量的值可能会因同一类的不同对象而异。在这种情况下，您必须在对象创建后为变量赋值。
同样，这可以通过两种方式实现。首先，通过直接从对象调用每个变量，使用点.符号，如:
>>> myObject.myVariable = "some other value";
或者我们也可以要求用户输入:
>>> myObject.myVariable = input();
除此之外，我们还可以使用self关键字分配/修改类函数中的变量值。
class Example:
def anotherFunction(self, parameter1):
self.myVariable = parameter1;
# or by calling for a user input
self.myVariable = input();
如果我们在类中定义了这样的函数，那么可以通过调用anotherFunction()方法并将所需的值作为参数传递给该方法/函数来初始化或重新初始化对象的变量。
>>> myObject = Example()
>>> myObject.anotherFunction("Amazing Spiderman")
>>> print (myObject.myVariable)
神奇的蜘蛛侠
可以看出，这是Example类中一个常用的用户定义函数，它利用参数来初始化变量。这里的概念相当简单。虽然，有更好的东西存在，它使用几乎相同的原则，是一个明确的标准。它被称为建造者。
构造器是一种特殊类型的函数，每当创建该类的对象时都会自动调用。例如，
>>> myObject = Example();
通过在上面的代码中写入Example()，我们通知 pythonmyObject是类Example的对象。这正是调用该类的构造器的时候。
但是它会做什么呢？一般来说，构造器用于初始化对象(实例)的类的变量，尽管它也可以执行一些其他任务，比如检查是否有足够的资源，用于初始化任何变量的值是否有效等。
在类中定义构造器方法
在 python 中，对象创建部分分为两部分:
- 对象创建
- 对象初始化
对象创建
对象创建由名为__new__的static类方法控制。因此当你调用Example()来创建类Example的对象时，这个类的__new__方法被调用。默认情况下，Python 为每个类都定义了这个函数，尽管您也可以显式地这样做，以玩转对象创建。
class Example:
def __new__(self):
return 'studytonight';
# creating object of the class Example
mutantObj = Example()
# but this will return that our object
# is of type str
print (type(mutantObj))
在上面的例子中，我们使用了__new__函数来改变返回对象的 tyoe，只是为了向您展示我们可以使用该函数做什么。
要了解默认的__new__函数是如何工作的，运行下面的代码，您会看到这次创建的对象是Example类型的
class Example:
myVariable = "some value";
simpleObj = Example()
print (type(simpleObj))
对象初始化
对象初始化由名为__init__的实例方法控制，该方法通常也称为构造器。虽然__new__和__init__一起组成了一个构造器。
一旦对象被创建，你可以通过在你的类中定义一个__init__方法来确保对象中的每个变量都被正确初始化，这意味着初始化。
因此，类名是什么并不重要，如果你想为这个类编写一个构造器(初始化你的对象)，它必须是__init__()方法。在这个函数中，你可以自由地声明一个类变量(使用self)或者初始化它们。下面是我们的Example类使用__init__方法的一个快速示例:
class Example:
def __init__(self, value1, value2):
self.myVariable1 = value1;
self.myVariable2 = value2;
print ("All variable initialized")
一旦你在一个类中定义了__init__方法，那么在创建一个对象的时候，当你调用Example()的时候，你可以提供对象的变量所需要的所有必要参数，因为当我们调用Example()的时候，场景后面的 python 会自动为创建的对象调用__init__函数。
这是代码的外观:
>>> myObj = Example("first variable", "second variable")
你可以用很多方法来初始化这个函数。上面已经提到了一种使用参数的方法，另一种方法是在构造器中请求用户输入。
def __init__(self):
self.myVariable1 = input();
self.myVariable2 = input();
下面我们有一个图表总结了这一切。
Python 析构器——销毁对象
原文：https://www.studytonight.com/python/destructors-in-python
就像构造器用于创建和初始化一个对象一样，析构器用于销毁该对象并执行最终清理。
虽然在 python 中，我们确实有垃圾收集器来清理内存，但是当一个对象被取消引用或销毁时，需要释放的不仅仅是内存，还有很多其他资源，比如关闭打开的文件、关闭数据库连接、清理缓冲区或缓存等。因此，当我们说最终清理时，它不仅仅意味着清理内存资源。
在我们的上一个教程中，我们学习了如何使用__new__方法创建对象，以及如何使用__init__方法初始化对象。在本教程中，我们将学习如何销毁对象。
正如我们在上一个教程中明确指出的那样，__init__方法不一定是构造器方法，因为它只能初始化对象变量，而不能创建对象，这是通过__new__方法完成的。
同样，析构器的概念在 python 中也有点模糊，虽然通常__del__方法被认为是析构器方法，所以让我们看看如何使用这个方法来销毁一个类的对象。
使用__del__方法
下面我们有一个类Example的简单代码，其中我们使用了__init__方法来初始化我们的对象，而我们定义了__del__方法来充当析构器。
class Example:
def __init__(self):
print ("Object created");
# destructor
def __del__(self):
print ("Object destroyed");
# creating an object
myObj = Example();
# to delete the object explicitly
del myObj;
对象已创建对象已销毁
需要注意的几点
- 就像析构器是构造器的反函数一样，函数
__del__也是函数__new__的反函数。因为__new__是创造对象的函数。 - 当任何对象的引用计数变为零时，对该对象调用
__del__方法。 - 由于进行引用计数，因此对于一个对象来说，如果超出范围就不需要调用
__del__方法。只有当引用计数为零时，才会调用析构器方法。
角落案例:当析构器表现不好时
正如我们在开头已经提到的，使用__del__并不是对不再需要的对象执行最终清理的完全证明解决方案。
这里我们讨论了两种这样的情况，其中__del__函数的行为是荒谬的。
1.循环引用
循环引用是指两个对象相互引用的情况。在这种情况下，当这两个对象都失去引用时，python 会困惑于首先销毁哪个对象，为了避免任何错误，它不会销毁它们中的任何一个。
这里有一个演示循环引用的例子，
class Foo():
def __init__(self, id, bar):
self.id = id;
# saving reference of Bar object
self.friend = bar;
print ('Foo', self.id, 'born');
def __del__(self):
(print 'Foo', self.id, 'died');
class Bar():
def __init__(self, id):
self.id = id;
# saving Foo class object in variable
# 'friend' of Bar class, and sending
# reference of Bar object for Foo object
# initialisation
self.friend = Foo(id, self);
print ('Bar', self.id, 'born')
def __del__(self):
print ('Bar', self.id, 'died')
b = Bar(12)
福 12 出生酒吧 12 出生
2.__init__方法异常
在面向对象编程中，析构器仅在对象成功创建的情况下被调用，因为如果构造器中出现任何异常，那么构造器本身就会销毁该对象。
但是在 python 中，如果在初始化对象时__init__方法出现任何异常，在这种情况下也会调用方法__del__。
因此，即使对象从未被正确初始化，__del__方法将尝试清空所有的资源和变量，并可能导致另一个异常。
class Example():
def __init__(self, x):
# for x = 0, raise exception
if x == 0:
raise Exception();
self.x = x;
def __del__(self):
print (self.x)
# creating an object
myObj = Example();
# to delete the object explicitly
del myObj
例外例外。属性错误:“‘示例’对象在
Python 中的继承
原文：https://www.studytonight.com/python/inheritance-in-python
继承是面向对象编程最重要的方面之一。在编程时，很多时候会出现这样的情况:我们必须编写一些具有一些共同特性和一些独特的、特定于类的特性的类，这些特性包括变量和方法。
在这种情况下，按照面向对象编程，我们可以取出公共部分并将其放在一个单独的类中，并使所有其他类继承这个类，以使用它的方法和变量，从而减少一次又一次地重写每个类中的公共特性。
继承另一个类的类一般称为子类，而被其他类继承的类称为父类。
当然，您必须仅将此用于相关的类，例如，您可以定义一个类living organic，其中定义了一个生物的所有基本特征，如呼吸、进食等。现在这个类很容易被另一个类动物和人类重用，因为这两个类都有相同的特性。
此外，有时，继承用于通过将功能分解为核心特性和次要特性，将具有大量变量和方法的大类简化为更小的类。核心特性通常保存在父类中。
继承的语法
如果我们有一个类Parent和另一个类Child，并且我们希望类Child继承类Parent，那么
# Parent class
class Parent:
# class variable
a = 10;
b = 100;
# some class methods
def doThis();
def doThat();
# Child class inheriting Parent class
class Child(Parent):
# child class variable
x = 1000;
y = -1;
# some child class method
def doWhat();
def doNotDoThat();
通过在括号中指定另一个类的名称，在声明一个类时，我们可以指定继承。在上例中，Parent的所有属性都将继承给Child类。这样，类Parent中定义的所有方法和变量也成为了Child类的一部分。
举个例子
举个简单的例子。动物可以分为多种类型，如爬行动物、哺乳动物、两栖动物等。虽然它们在生理和生物学上都有所不同，但它们之间有许多共同的特征。所以现在我们定义一个名为 Animal 的父类，它会有一些与动物相关的基本属性和功能。
然后我们将为各种其他类型定义类，所有这些类也将继承类 Animal 。
这里有Animal课。
class Animal:
# properties
multicellular = True
# Eukaryotic means Cells with Nucleus
eukaryotic = True
# functions
def breath();
def feed();
现在让我们为哺乳动物定义一个类。由于哺乳动物是温血动物，为婴儿产奶等，因此我们的Mammal类看起来像，
class Mammal(Animal):
# properties
haveMammaryGland = True;
def warmBlood = True;
# functions
def produceMilk();
如果我们也想为Amphibians创建另一个类，那么
class Amphibian(Animal):
# properties
liveInWater = True;
# functions
def metamorphosis();
由于类Mammals和Amphibian都继承了类Animal，因此它们将具有类Animal中定义的属性和函数。
因此，现在任何Amphibian类的物体，比如青蛙，都将具有属性:multicellular(来自动物类)、eukaryotic(来自动物类)、liveInWater(来自两栖类)，并且能够breath()、feed()和做metamorphosis()。
而这一切又如何能写成代码，如果我们创建一个对象，比如青蛙:
>>> Amphibian Frog = Amphibian()
>>> Frog.breath(); # calling function defined in Animal class
>>> Frog.metamorphosis(); # calling function defined in Amphibian class
>>> print (Frog.liveInWater)
真实的
使用继承的好处
以下是在程序中使用继承的几个主要优点。
- 减少代码重复，因为常见的代码可以放在父类中，因此所有子类都可以使用它。
- 结构化代码:通过将代码划分为类，我们可以通过将功能划分为类来更好地构建我们的软件。
- 使代码更具可伸缩性。
访问子类中的父类元素
在子类中工作时，在某些时候，您可能必须使用父类的属性或函数。为了访问父类的元素，可以使用点.操作符。
Parent.variableName
上面提到了如何访问变量，或者如果需要调用父类的函数，
Parent.functionName()
其中Parent是我们父类的名字，variableName和functionName()分别是它的变量和函数。
下面是一个例子，我们有一个简单的例子来说明这一点:
class Parent:
var1 = 1
def func1(self):
# do something here
class Child(Parent):
var2 = 2
def func2(self):
# do something here too
# time to use var1 from 'Parent'
myVar = Parent.var1 + 10
return myVar
Python 访问修饰符
原文：https://www.studytonight.com/python/access-modifier-python
在大多数面向对象语言中，访问修饰符用于限制对类的变量和函数的访问。大多数语言使用三种类型的访问修饰符，它们是- 私有、公共和受保护。
就像任何其他面向对象编程语言一样，在 python 中使用访问修饰符也可以限制对变量或函数的访问。Python 使用下划线来指定类中特定数据成员和成员函数的访问修饰符。
访问修饰符在保护数据免受未经授权的访问以及防止数据被操纵方面起着重要的作用。当实现继承时，由于不需要的数据从父类转移到子类，数据有被破坏(操纵)的巨大风险。因此，根据需求为不同的数据成员和成员函数提供正确的访问修饰符是非常重要的。
Python:访问修饰符的类型
Python 中一个类有 3 种类型的访问修饰符。这些访问修饰符定义了如何访问类的成员。当然，类的任何成员都可以在同一类的任何成员函数中访问。继续讨论访问修饰符的类型，它们是:
访问修饰符:公共
通过类的对象，可以从类外部访问声明为公共的成员。
访问修饰符:受保护
声明为受保护的成员可以从类外部访问，但只能在子类或子类中从其派生的类中访问。
访问修饰符:私有
这些成员只能从类中访问。不允许外部访问。
该举些例子了
在本节中，我们将为每种类型的访问修饰符提供一些基本的代码示例。
public存取修改子
默认情况下，一个类的所有变量和成员函数在 python 程序中都是public。
# defining a class Employee
class Employee:
# constructor
def __init__(self, name, sal):
self.name = name;
self.sal = sal;
上述代码中类的所有成员变量默认为public，因此我们可以按如下方式访问它们:
>>> emp = Employee("Ironman", 999000);
>>> emp.sal;
999000
protected存取修改子
根据 Python 惯例，在变量名中添加前缀_(单下划线)使其成为protected。是的，不需要额外的关键字。
# defining a class Employee
class Employee:
# constructor
def __init__(self, name, sal):
self._name = name; # protected attribute
self._sal = sal; # protected attribute
在上面的代码中，我们通过添加一个_(下划线)作为前缀，使类变量名为和名为 protected，因此现在我们可以如下访问它们:
>>> emp = Employee("Captain", 10000);
>>> emp._sal;
10000
同样，如果有一个子类扩展了类Employee，那么它也可以访问类Employee的受保护成员变量。让我们举个例子:
# defining a child class
class HR(Employee):
# member function task
def task(self):
print ("We manage Employees")
现在让我们尝试从类HR访问类Employee的受保护成员变量:
>>> hrEmp = HR("Captain", 10000);
>>> hrEmp._sal;
10000
>>> hrEmp.task();
We manage Employees
private存取修改子
而前缀__(双下划线)的添加导致成员变量或函数成为private。
# defining class Employee
class Employee:
def __init__(self, name, sal):
self.__name = name; # private attribute
self.__sal = sal; # private attribute
如果我们想访问私有成员变量，我们会得到一个错误。
>>> emp = Employee("Bill", 10000);
>>> emp.__sal;
属性错误:“员工”对象没有属性“__sal”
在一个例子中
现在，我们已经在单独的示例中看到了每个访问修饰符，现在，让我们将迄今为止所学的全部内容合并到一个示例中:
# define parent class Company
class Company:
# constructor
def __init__(self, name, proj):
self.name = name # name(name of company) is public
self._proj = proj # proj(current project) is protected
# public function to show the details
def show(self):
print("The code of the company is = ",self.ccode)
# define child class Emp
class Emp(Company):
# constructor
def __init__(self, eName, sal, cName, proj):
# calling parent class constructor
Company.__init__(self, cName, proj)
self.name = eName # public member variable
self.__sal = sal # private member variable
# public function to show salary details
def show_sal(self):
print("The salary of ",self.name," is ",self.__sal,)
# creating instance of Company class
c = Company("Stark Industries", "Mark 4")
# creating instance of Employee class
e = Emp("Steve", 9999999, c.name, c._proj)
print("Welcome to ", c.name)
print("Here ", e.name," is working on ",e._proj)
# only the instance itself can change the __sal variable
# and to show the value we have created a public function show_sal()
e.show_sal()
现在上面的代码显示了public、private和protected成员变量和方法的正确用法。你可以试着在运行程序时改变一些东西，看看这些改变会导致什么样的错误。
Python 中的继承类型
在上一个教程中，我们学习了继承以及子类如何继承父类以利用其属性和功能。
如果一个类想要继承多个类呢？或者有没有可能继承一个已经继承了其他类的类？为了回答这些问题，让我们看看不同类型的继承。
在 Python 中，有两种类型的继承:
- 多重继承
- 多级继承
Python -多重继承
多重继承意味着您将多个类的属性继承到一个类中。如果你有两个类，比如A和B，你想创建一个继承A和B属性的新类，那么:
class A:
# variable of class A
# functions of class A
class B:
# variable of class A
# functions of class A
class C(A, B):
# class C inheriting property of both class A and B
# add more properties to class C
所以就像一个孩子继承了母亲和父亲的特征一样，在 python 中，我们可以在一个子类中继承多个类。
如您所见，我们没有在子类的括号中提到一个类名，而是提到了两个类名，用逗号,隔开。为了消除你的疑虑，是的，你可以继承任意多的类。因此，语法实际上应该是:
class A(A1, A2, A3, ...):
# class A inheriting the properties of A1, A2, A3, etc.
# You can add properties to A class too
Python -多级继承
在多级继承中，我们在多个不同的级别继承类。我们有三个班A、B、C，其中A为超级班，B为其子(子)班，C为B的子班。
这里有一个简单的例子，它只是为了向您解释这在代码中的样子:
class A:
# properties of class A
class B(A):
# class B inheriting property of class A
# more properties of class B
class C(B):
# class C inheriting property of class B
# thus, class C also inherits properties of class A
# more properties of class C
使用issubclass()方法
在 python 中，有一个函数可以帮助我们验证一个特定的类是否是另一个类的子类，这个内置函数就是issubclass(paramOne, paramTwo)，其中paramOne和paramTwo可以是类名，也可以是类的对象名。
class Parent:
var1 = 1
def func1(self):
# do something
class Child(Parent):
var2 = 2
def func2(self):
# do something else
为了检查Child类是否是Parent类的子类。
>>> issubclass(Child, Parent)
真实的
或者使用类的对象，
Parent p = Parent()
Child c = Child()
几乎是一样的，
>>> issubclass(c, p)
真实的
Python 中的方法覆盖
原文：https://www.studytonight.com/python/method-overriding-in-python
方法覆盖是面向对象编程的一个概念，它允许我们在子类中更改函数的实现，该子类在父类中定义。它是一个子类改变其父类(祖先)已经提供的任何方法的实现的能力。
覆盖函数必须满足以下条件:
- 传承 应该在那里。函数覆盖不能在类中完成。我们需要从父类派生一个子类。
- 在子类中重新定义的函数应该具有与父类相同的签名，即相同的参数数量。
正如我们已经了解到的 继承 的概念，我们知道当一个子类继承一个父类时，它也可以访问它public和protected ( 访问 python 中的修饰符 )变量和方法，例如，
# parent class
class Parent:
# some random function
def anything(self):
print('Function defined in parent class!')
# child class
class Child(Parent):
# empty class definition
pass
obj2 = Child()
obj2.anything()
父类中定义的函数！
子类可以访问父类方法的同时，也可以为父类方法提供新的实现，称为方法覆盖。
Python 方法覆盖示例
让我们举一个非常酷的例子，我们在继承教程中也有过。有一个名为Animal的父类:
class Animal:
# properties
multicellular = True
# Eukaryotic means Cells with Nucleus
eukaryotic = True
# function breathe
def breathe(self):
print("I breathe oxygen.")
# function feed
def feed(self):
print("I eat food.")
让我们创建一个子类Herbivorous，它将扩展类Animal:
class Herbivorous(Animal):
# function feed
def feed(self):
print("I eat only plants. I am vegetarian.")
在子类Herbivorous中，我们已经覆盖了方法feed()。
所以现在当我们创建一个类的对象Herbivorous并调用方法feed()时，被覆盖的版本将被执行。
herbi = Herbivorous()
herbi.feed()
# calling some other function
herbi.breathe()
我只吃植物。我是素食者。我呼吸氧气。
点击运行查看正在运行的代码，并随时对其进行更改，然后再次运行。
Python 中的多态
多态是面向对象编程的一个概念，意思是多种形式或者多种形式。多态允许使用单个接口输入不同的数据类型、不同的类或不同数量的输入。
在 python 中，因为所有的东西都是一个对象，所以默认情况下，函数可以接受任何东西作为参数，但是函数的执行可能会失败，因为每个函数都有一些逻辑。
例如，
len("hello") # returns 5 as result
len([1,2,3,4,45,345,23,42]) # returns 8 as result
在这种情况下，函数len是多态的，因为它在第一种情况下将字符串作为输入，而在第二种情况下将列表作为输入。
在 python 中，多态是一种让函数接受行为相似的不同类的对象的方式。
方法覆盖是一种多态类型，其中扩展父类的子类可以根据自己的需求为父类中定义的任何函数提供不同的定义。
方法重载
方法覆盖或函数重载是多态的一种类型，在这种类型中，我们可以定义许多具有相同名称但具有不同数量参数的方法，并且参数可以是不同的类型。这些方法可以执行相似或不同的功能。
Python 不支持基于函数中不同参数数量的方法重载。
定义多态类
想象一个情况，我们有一个不同的形状类，如正方形，三角形等，作为一个资源来计算该形状的面积。每个形状都有不同的维数，用于计算相应形状的面积。
现在一种方法是用不同的名称定义不同的函数来计算给定形状的面积。描述这种方法的程序如下所示:
class Square:
side = 5
def calculate_area_sq(self):
return self.side * self.side
class Triangle:
base = 5
height = 4
def calculate_area_tri(self):
return 0.5 * self.base * self.height
sq = Square()
tri = Triangle()
print("Area of square: ", sq.calculate_area_sq())
print("Area of triangle: ", tri.calculate_area_tri())
正方形面积:25 三角形面积:10.0
这种方法的问题是开发人员必须分别记住每个函数的名称。在一个大得多的程序中，很难记住每个小操作的函数名。方法重载的作用来了。
现在让我们更改函数的名称来计算面积，并赋予它们相同的名称calculate_area()，同时在两个定义不同的类中分别保留函数。在这种情况下，对象的类型将有助于解析对函数的调用。下面的程序展示了用类方法实现这种类型的多态:
class Square:
side = 5
def calculate_area(self):
return self.side * self.side
class Triangle:
base = 5
height = 4
def calculate_area(self):
return 0.5 * self.base * self.height
sq = Square()
tri = Triangle()
print("Area of square: ", sq.calculate_area())
print("Area of triangle: ", tri.calculate_area())
正方形面积:25 三角形面积:10.0
如您所见，在两个类的实现中，即Square和Triangle具有相同名称的函数calculate_area()，但是由于不同的对象，其调用被正确解析，即当使用对象sq调用函数时，调用类Square的函数，当使用对象tri调用函数时，调用类Triangle的函数。
类方法的多态
我们在上面的例子中看到的是明显的行为。让我们使用一个循环来迭代各种形状的对象元组，并调用面积函数来计算每个形状对象的面积。
sq = Square()
tri = Triangle()
for(obj in (sq, tri)):
obj.calculate_area()
这是多态的一个更好的例子，因为现在我们把不同类的对象当作一个对象，在这个对象上调用同一个函数。
在这里，python 不关心调用函数的对象类型，因此使类方法本质上是多态的。
函数的多态
就像我们在上面的例子中使用了一个循环一样，我们也可以创建一个函数，该函数将某个形状类的对象作为输入，然后调用该函数为其计算面积。例如，
find_area_of_shape(obj):
obj.calculate_area()
sq = Square()
tri = Triangle()
# calling the method with different objects
find_area_of_shape(sq)
find_area_of_shape(tri)
在上面的例子中，我们使用了相同的函数find_area_of_shape来计算两个不同形状类别的面积。同一个函数以不同的类对象作为参数，完美地执行以返回结果。这就是多态。
Python 中的静态变量和方法
原文：https://www.studytonight.com/python/python-static-keyword
定义静态变量和方法是一个常见的编程概念，在 C++ 、 Java 、Php 和许多其他编程语言中被广泛使用，用于创建属于该类并由该类的所有对象共享的类变量和方法。
在 Python 中，没有创建静态变量和方法的特殊关键字。Python 遵循一种不同但简单的方法来定义静态变量和方法，我们将在本教程中学习。
Python 中的类或静态变量
类或静态变量是属于类而不属于对象的变量。类或静态变量在类的对象之间共享。在类声明中被赋值的所有变量都是类变量。在类方法中赋值的变量是实例变量。
让我们举个例子来理解这一点:
在上面的程序中，cat是一个类变量，因为它是在所有类方法之外和类定义之内定义的，type是一个实例变量，因为它是在一个方法之内定义的。
这可以通过print语句来确认，其中cat变量使用类名Shape来引用，而type变量使用不同的对象引用来引用。
上面的例子展示了一个场景，其中有不同的形状对象，每个都属于相同的类别，即几何，但是属于不同的类型，因此类的每个对象都有相同的类别，我们已经将该类别作为类变量，并且type变量对于所有对象都是不同的，因此它是一个实例变量。
注意: Python 允许为类/静态变量和实例变量提供相同的变量名。但是我们建议您不要为这些变量提供相同的名称变量，以避免混淆。
Python 中的静态方法
就像静态变量一样，静态方法是绑定到类而不是类的对象的方法，因此使用类名而不是类的对象来调用。
由于静态方法绑定到类，因此它们不能改变对象的状态。
要调用静态方法，我们不需要任何类对象，它可以直接使用类名来调用。
在 python 中，有两种定义静态方法的方法:
- 使用
staticmethod() - 使用
@staticmethod
使用staticmethod()定义静态方法
让我们举个例子来看看这是如何做到的:
class Shape:
def info(msg):
# show custom message
print(msg)
print("This class is used for representing different shapes.")
# create info static method
Shape.info = staticmethod(Shape.info)
Shape.info("Welcome to Shape class")
欢迎来到形状类这个类用于表示不同的形状。
在上面的程序中，我们使用staticmethod()函数方法将info方法声明为类外的静态方法，之后我们可以直接使用类Shape调用info()方法。
使用@staticmethod定义静态方法
让我们举个例子来看看这是如何做到的:
class Shape:
@staticmethod
def info(msg):
# show custom message
print(msg)
print("This class is used for representing different shapes.")
Shape.info("Welcome to Shape class")
欢迎来到形状类这个类用于表示不同的形状。
使用@staticmethod是定义静态方法的更现代的方法，我们推荐这种方法。
静态变量和方法的注意事项
以下是一些重要的要点:
- 当我们想要定义一些特定于类的行为或属性时，静态变量和方法被使用，这对于所有的类对象来说是通用的。
- 如果仔细观察，对于静态方法，我们不提供参数
self，因为静态方法不对对象进行操作。
Python 中的运算符重载
原文：https://www.studytonight.com/python/python-operator-overloading
运算符在 Python 中用于对给定的操作数执行特定的操作。Python 中已经定义了任何特定运算符对任何预定义数据类型执行的操作。
对于不同类型的操作数，每个运算符都可以以不同的方式使用。例如，+运算符用于将两个整数相加，得到一个整数，但是当我们将其与浮点操作数一起使用时，结果是一个浮点值，而当+与字符串操作数一起使用时，它将所提供的两个操作数连接起来。
对于不同类型的操作数，单个操作符的这种不同行为被称为操作符重载。不同操作数类型的+运算符的用法如下所示:
>>> x=10
>>> y=20
>>> x+y
30
>>> z=10.4
>>> x+z
20.4
>>> s1 = 'hello '
>>> s2 = 'world'
>>> s1+s2
'hello world'
+运算符可以添加任何内容吗？
答案是否定的，不能。可以使用+运算符添加一个类的两个对象吗。+运算符可以添加两个整数值、两个浮点值，或者仅用于连接两个字符串，因为这些行为已在 python 中定义。
因此，如果您想使用同一个操作符来添加某个用户定义类的两个对象，那么您必须自己定义该行为并通知 python。
如果你还不清楚，我们创建一个类，试着用+运算符添加该类的两个对象，
class Complex:
def __init__(self, r, i):
self.real = r
self.img = i
c1 = Complex(5,3)
c2 = Complex(2,4)
print("sum = ", c1+c2)
回溯(最近一次调用最后一次):File/tmp/sessions/1 DFB e78 bb 701d 99d/main . py "，第 7 行，在
所以我们可以看到在一个用户定义的类中不支持+运算符。但是我们可以通过为我们的类Complex重载+运算符来实现同样的目的。但是我们怎么做呢？
Python 中的特殊函数
python 中的特殊函数是用于执行特殊任务的函数。这些特殊函数的名字有__作为前缀和后缀，正如我们在__init__()方法中看到的，这也是一个特殊函数。用于重载运算符的一些特殊函数如下所示:
数学运算符
下面是 python 中重载数学运算符的特殊函数的名称。
| 名字 | 标志 | 特殊函数 |
| 添加 | + | __add__(self, other) |
| 减法 | - | __sub__(self, other) |
| 分开 | / | __truediv__(self, other) |
| 楼层划分 | // | __floordiv__(self, other) |
| 模数(或余数) | % | __mod__(self, other) |
| 力量 | ** | __pow__(self, other) |
赋值运算符
下面是 python 中重载赋值运算符的特殊函数的名称。
| 名字 | 标志 | 特殊函数 |
| 增量 | += | __iadd__(self, other) |
| 减量 | -= | __isub__(self, other) |
| 产品 | *= | __imul__(self, other) |
| 分开 | /= | __idiv__(self, other) |
| 系数 | %= | __imod__(self, other) |
| 力量 | **= | __ipow__(self, other) |
关系运算子
下面是 python 中重载关系运算符的特殊函数的名称。
| 名字 | 标志 | 特殊函数 |
| 不到 | < | __lt__(self, other) |
| 大于 | > | __gt__(self, other) |
| 等于 | == | __eq__(self, other) |
| 不平等 | != | __ne__(self, other) |
| 小于或等于 | <= | __le__(self, other) |
| 大于或等于 | > = | __gt__(self, other) |
是时候看一些代码示例了，在这些示例中，我们实际上使用了上面指定的特殊函数并重载了一些运算符。
超载+操作员
在下面的代码示例中，我们将为我们的类Complex重载+运算符，
class Complex:
# defining init method for class
def __init__(self, r, i):
self.real = r
self.img = i
# overloading the add operator using special function
def __add__(self, sec):
r = self.real + sec.real
i = self.img + sec.img
return complx(r,i)
# string function to print object of Complex class
def __str__(self):
return str(self.real)+' + '+str(self.img)+'i'
c1 = Complex(5,3)
c2 = Complex(2,4)
print("sum = ",c1+c2)
总和= 7 + 7i
在上面的程序中， __add__()用于重载+运算符，即当+运算符用于两个Complex类对象时，调用函数__add__()。
__str__()是另一个特殊功能，用于提供适合打印的对象格式。
超载<操作员
现在让我们重载小于运算符，这样我们就可以通过使用小于运算符<轻松比较两个Complex类对象的值。
我们现在知道，要做到这一点，我们必须在我们的类中定义__lt__特殊函数。
根据您对比较类对象的要求，您可以为覆盖运算符的特殊函数定义逻辑。在上面的代码中，我们给出了复数的实数部分的优先级，如果该部分小于，则整个复数小于，如果该部分等于，则我们检查虚数部分。
结论
在 python 中，使用特殊函数重载操作符很容易，也不容易混淆。
错误处理
Python 错误和内置异常
原文：https://www.studytonight.com/python/introduction-to-error-exception-python
在任何编程语言中，一个小小的打字错误都可能导致错误，因为在用任何编程语言编码时，我们都必须遵循语法规则。
python 的情况也是如此，在本教程中，我们将了解 python 中的语法错误和异常，并列出 python 中一些常见的异常。
Python:语法错误
这是最常见和最基本的错误情况，在这种情况下，您违反了任何语法规则，例如，如果您使用 Python 3.x 版本，并且您编写了以下代码来打印任何语句，
print "I love Python!"
语法错误:调用“打印”时缺少括号。
因为，从 Python 3 开始，使用print语句的语法发生了变化。同样的，如果你忘记在if条件的末尾加上冒号(:，你会得到一个语法错误:
if 7 > 5
print("Yo Yo!")
语法错误:无效语法
因此，语法错误是您在 python 中编码时会遇到的最基本的错误类型，通过查看错误消息并按照 python 语法纠正代码，可以轻松修复这些错误。
Python:什么是例外？
与语法错误相反，异常是一种由于代码在执行过程中出现故障而导致的错误。
您的代码可能没有任何语法错误，但在执行时仍会导致异常。
我们举一个最基本的除以零的例子:
a = 10
b = 0
print("Result of Division: " + str(a/b))
回溯(最近一次调用最后一次):文件“main.py”，第 3 行，在
正如我们在输出中看到的，我们得到了zero divisiononerror，而我们的 python 代码的语法是绝对正确的，因为在这种情况下，错误或者我们应该说异常是在代码执行时生成的。
Python 返回非常详细的异常消息，让我们了解异常的起始点和原因，这样我们就更容易修复代码了。
用 Python 解码异常消息
异常消息中的术语追溯意味着 python 已经将代码追溯到异常发生的地方，并将在这一行之后显示相关消息。
如上图所示，异常消息的第二行告诉我们 python 文件的名称，以及代码的确切行号，这是异常生成的原因。
如果这对某人仍然没有帮助，在异常消息的第三行，将打印导致异常的完整代码语句。
然后在最后一行，python 告诉我们发生了哪个异常/错误，在我们上面的例子中是zero divisiononerror。
内置的 Python 异常类
让我们了解几个异常类以及它们出现的常见原因，以供将来参考。
注意:我们称它们为异常类，因为所有这些在 python 中都被定义为类。
| 异常类 | 描述 |
| 属性错误 | 当我们试图访问的属性(无论是赋值还是取值)不存在时，就会出现这个异常。例如:试图访问类中未定义的类成员变量。 |
| 导入错误 | 找不到导入的模块时会出现此异常。 |
| 内建 Error | 当代码缩进有问题时，会出现此异常。 |
| 类型错误 | 当对不正确类型的变量执行操作时。 |
| 值错误 | 当函数的参数值不正确时。 |
| 零分割错误 | 如上所述，当我们试图用零除一个数时。 |
| TabError | 当缩进在整个代码中不一致时，就用于缩进的制表符和空格而言。 |
| 运行时错误 | 当错误不是任何特定定义的异常类型时，python 会将其称为 RuntimeError。 |
| 名称错误 | 当我们试图使用的变量名没有定义时。 |
这些是用 python 编码时最常见的一些内置 excpetion 类。对于 python 中的所有异常类型，请查看 python 官方文档。
Python 异常处理
原文：https://www.studytonight.com/python/exception-handling-python
异常处理是 Python 中使用的一个概念，用于处理任何程序执行过程中出现的异常和错误。异常是代码执行过程中可能出现的意外错误。在上一个教程中，我们已经介绍了 python 中的 异常和错误。
嗯，是的，异常会发生，您的代码中可能会有错误，但是我们为什么要投入时间来处理异常呢？
这个问题的答案是提升用户体验。发生异常时，会发生以下情况:
- 程序执行突然停止。
- 控制台上会打印完整的异常消息以及文件名和代码行号。
- 直到代码中的那个点之前执行的所有计算和操作都将丢失。
现在想想有一天你在用study south的网站，你点击了某个链接打开了一个教程，不知什么原因，导致了一些异常。如果我们没有处理异常，那么你会看到异常消息，而网页也没有加载。你会喜欢吗？
因此，异常处理对于优雅地处理错误和显示适当的消息来通知用户故障是非常重要的。
使用try和except处理异常
为了在 Python 中处理异常，我们使用了两种类型的块，即try块和except块。
在try块中，我们编写了可能出现任何错误或异常的代码。
而except块负责捕获异常并执行其中指定的语句。
下面是执行除以零的代码:
a = 10
b = 0
print("Result of Division: " + str(a/b))
回溯(最近一次调用最后一次):文件“main.py”，第 3 行，在
上述代码导致异常，异常消息作为输出打印在控制台上。
如果我们使用try和except块，我们可以优雅地处理这个异常。
# try block
try:
a = 10
b = 0
print("Result of Division: " + str(a/b))
except:
print("You have divided a number by zero, which is not allowed.")
你把一个数除以零，这是不允许的。
try块
如您在上面的代码示例中所见，try块用于将整个要执行的代码放入程序中(您认为这会导致异常)，如果在执行try块中的代码时发生任何异常，那么它会导致代码的执行被定向到except块，并且在try块中正在进行的执行被中断。但是，如果没有异常发生，则整个try块被执行，并且except块从不被执行。
except块
try块后面一般是except块，里面保存着异常清除代码(异常已经发生，如何有效处理这种情况)像一些print语句到打印一些消息或者可能是触发一些事件或者在数据库中存储一些东西等等。
在例外块中，连同关键字except我们还可以提供预计会出现的例外类的名称。如果我们不提供任何异常类名，它将捕获所有异常，否则它将只捕获所提到的类型的异常。
以下是语法:
# except block
except(<Types of Exceptions to catched>):
# except block starts
如果你仔细注意，我们已经提到了类型的异常，是的，我们甚至可以在中提供多个异常类的名称，用逗号分隔，除了语句。
代码执行在except块后继续
这里需要注意的另一点是，异常发生时try块中的代码执行被中断，导致异常的那一行后面的try块中的代码语句不执行。
然后执行跳转到except块。而在except内部的代码语句执行完毕后，就像其他任何正常执行一样，在代码语句执行完毕后对其进行阻塞。
让我们举个例子:
# try block
try:
a = 10
b = 0
print("Result of Division: " + str(a/b))
print("No! This line will not be executed.")
except:
print("You have divided a number by zero, which is not allowed.")
# outside the try-except blocks
print("Yo! This line will be executed.")
你把一个数除以零，这是不允许的。哟！这一行将被执行。
捕捉 Python 中的多个异常
有多种方法可以实现这一点。我们可以有多个except块，每个块处理一个特定的异常类，或者我们可以在一个except块中处理多个异常类。
多个except块
如果您认为您的代码可能在不同的情况下生成不同的异常，并且您想要单独处理这些异常，那么您可以有多个except块。
当涉及用户输入时，通常会出现异常。让我们举一个简单的例子，我们将要求用户输入两个数字，对它们执行除法运算，并向它们显示结果。
我们将尝试使用多个except块来处理多个可能的异常情况。
尝试运行上面的代码，提供 0 作为分母的值，看看会发生什么，然后为任何变量提供一些字符串(非整数)值。我们已经处理了上面代码中的两种情况。
使用except块处理多个异常
正如您在上面的示例中看到的，我们根据发生的异常打印了不同的消息。如果您没有需要单独处理不同异常的需求，那么您也可以在单个异常块中捕获一组异常。
这里是上面代码的单个except块:
# try block
try:
a = int(input("Enter numerator number: "))
b = int(input("Enter denominator number: "))
print("Result of Division: " + str(a/b))
# except block handling division by zero
except(ValueError, ZeroDivisionError):
print("Please check the input value: It should be an integer greater than 0")
在这里，我们使用单个except块处理了这两个异常，同时向用户显示了一条有意义的消息。
处理未知异常的通用except块
虽然我们确实试图通过测试和使用异常处理来使我们的代码没有错误，但是可能会有一些我们可能错过的错误情况。
因此，当我们使用except块来处理特定的异常类时，我们应该总是在末尾有一个通用 except块来处理任何运行时异常(意外事件)。
# try block
try:
a = int(input("Enter numerator number: "))
b = int(input("Enter denominator number: "))
print("Result of Division: " + str(a/b))
# except block handling division by zero
except(ZeroDivisionError):
print("You have divided a number by zero, which is not allowed.")
# except block handling wrong value type
except(ValueError):
print("You must enter integer value")
# generic except block
except:
print("Oops! Something went wrong!")
在上面的代码中，第一个except块将处理零除错误，第二个except块将处理值错误，对于可能出现的任何其他异常，我们有第三个except块。
在接下来的教程中，我们将学习finally块以及如何使用raise关键字引发异常。
Python finally
原文：https://www.studytonight.com/python/finally-block-in-python
finally代码块也是异常处理的一部分。当我们 使用try和except块 处理异常时，我们可以在末尾包含一个finally块。finally块总是被执行，所以它通常用于完成结束任务，如关闭文件资源或关闭数据库连接，或者用一条令人愉快的消息结束程序执行。
finally有/无异常处理的块
如果在您的代码中，except块无法捕获异常，并且异常消息被打印在控制台上，这中断了代码的执行，那么最终块仍然会被执行。
让我们举个例子:
尝试为两个不同的值运行上面的代码:
-
输入某个整数值作为分子，为分母提供 0 值。以下是输出:
你把一个数除以零，这是不允许的。代码执行结束！这个会被打印出来吗？
由于我们已经处理了零划分错误异常类，因此首先执行
except块，然后执行finally块，然后执行其余代码。 -
现在，一些整数值作为分子，一些字符串值作为分母。以下是输出:
代码执行结束！回溯(最近一次调用最后一次):文件“main.py”，第 4 行，在
b = int(input(“输入分母数:“)”)值错误:int()的文字无效，基数为 10:“dsw” 由于我们没有处理值错误异常，因此我们的代码将停止执行，异常将被抛出，但是
finally块中的代码仍然被执行。
except块异常
我们使用except块和try块来处理异常，但是如果在except块内发生异常怎么办。嗯finally区块还是会被执行。
# try block
try:
a = 10
b = 0
print("Result of Division: " + str(a/b))
# except block handling division by zero
except(ZeroDivisionError):
print("Result of Division: " + str(a/b))
finally:
print("Code execution Wrap up!")
代码执行结束！回溯(最近一次调用最后一次):文件“main.py”，第 4 行，在
显然finally块是第一个被打印在控制台上的，后面是第一个异常消息，然后是第二个异常消息。
Python 异常处理：raise关键字
原文：https://www.studytonight.com/python/raise-keyword-in-python
而try``except块是处理异常，相反的raise关键字是引发异常。
以下是语法:
raise EXCEPTION_CLASS_NAME
举一个简单的用法例子:
raise ZeroDivisionError
回溯(最近一次调用最后一次):文件“main.py”，第 1 行，在
如果您有一段代码，其中除了异常处理之外，您还放置了一些条件语句来验证输入等，那么在条件失败的情况下，我们可以只打印一条消息，或者简单地引发一个异常，然后由通用异常处理机制来处理。
请参见下面的代码，
a = 10
b = 9
try:
print(a/b)
except ZeroDivisionError:
print("Please enter valid integer value")
考虑上面我们已经处理过ZeroDivisionError的代码，在这个代码中我们想要添加一个新的验证来限制用户输入负值。
然后我们可以简单地添加一个新的条件，并使用raise关键字来引发一个已经处理过的异常。
a = 10
b = 9
try:
# condition for checking for negative values
if a < 0 or b < 0:
# raising exception using raise keyword
raise ZeroDivisionError
print(a/b)
except ZeroDivisionError:
print("Please enter valid integer value")
通过这个例子，我们想向您解释为什么以及在哪里我们应该使用raise关键字来显式地引发异常。
raise不指定异常类
当我们使用raise关键字时，没有必要同时提供一个异常类。当我们没有提供任何带有raise关键字的异常类名时，它会重新显示上次发生的异常。
这通常在except代码块中使用，以重新显示捕获的异常。
例如，
a = 10
b = 0
try:
print(a/b)
except ZeroDivisionError:
raise
回溯(最近一次调用最后一次):文件“main.py”，第 4 行，在
raise带着争论
我们还可以在引发异常时提供一个参数，该参数与异常类名一起显示在控制台上。
我们可以传递任何字符串来描述异常的原因或其他任何东西。
raise ValueError("Incorrect Value")
回溯(最后一次调用):文件“main.py”，第 1 行，在
文件处理
Python 中的文件处理
并非在所有情况下，数据都应该直接取自用户。当您必须从存储的原始文件中获取数据时，可能会出现这种情况，在这种情况下，您必须将这些文件与程序连接起来，以便程序可以读取、写入或修改数据。
在本节中，我们将了解如何执行这些任务。
文件访问模式
由于将文件与 Python 一起使用有各种各样的目的(即读、写、追加)，所以每次都指定 Python 应该对文件进行哪些操作是很重要的。因此，在程序中打开文件时，我们必须指定各种访问模式。
Python 能够管理两种类型的文件- 文本(或普通字符)和二进制(仅包含 1 和 0 的文本)。除了访问模式之外，还需要指定要打开的文件类型。
Python -打开文件
为了将我们的程序与所需的文件连接起来，我们需要一个可以在其中读取或写入数据的流。为此，已经有一些内置的类/函数可以用来解决这个问题。我们需要做的第一件事是创建一个文件对象，即文件类的实例，我们可以使用file()或open()函数来完成。为了打开一个文件-
>>> myFile = open([path of file], [access mode], [buffer size])
这里我的文件将是文件的对象，open()方法将打开在【文件路径】中指定的文件。其他两个参数，[访问模式]将提供访问模式，[缓冲区大小]将要求从文件中检索多少数据块。虽然，最后两个参数[访问模式]和[缓冲区大小]完全是可选的。默认情况下，如果没有指定访问模式，则认为是读取模式。[文件路径]可以是文件的完整路径，或者如果它与程序存在于同一文件中，则仅提供名称就足够了。更清楚的是-
在上述情况下，写作
>>> myFile = open("file.txt")
就足够了。然而，在像这样的情况下-
请注意，这次您的 file.txt 与上述情况不在同一个文件夹中，因此这里您必须指定整个位置。
>>> myFile = open("C:/c_code/file.txt")
一旦文件被打开，就有一个指针指向文件中的某个位置。该指针用于从该位置读取/写入。这个指针非常像一个文本光标，它可以自由移动(使用箭头键)，或者用于从文本中写入或删除文本，除了指针只能通过某些功能移动/读取/写入。
关于现在的访问模式，以下是将在参数中指定的可用访问模式-
-
读取模式-T0 为文本文件，
"rb"为二进制文件。文件指针指向文件的开头。>>> myFile = open("file.txt", "r") -
写入模式-
"w"为文本文件，"wb"为二进制文件。文件指针指向文件的开头。>>> myFile = open("file.txt", "w") -
追加模式-
"a"为文本文件，"ab"为二进制文件。文件指针指向文件的末尾。>>> myFile = open("file.txt", "a") -
读/写模式-
"r+"或"w+"提供对同一文件对象进行读和写操作的选项。"rb+"或"wb+"为二进制文件。文件指针指向文件的开头。>>> myFile = open("file.txt", "r+") -
追加/读取-
"a+"启用读取/追加模式，"ab+"为二进制文件的追加/读取模式。文件指针指向文件的末尾。>>> myFile = open("file.txt", "a+")
如您所见，以这种方式打开文件非常类似于创建一个文件对象，并对其执行读/写操作。以这种方式打开文件会创建一个数据缓冲区流，在使用文件后，总是建议关闭这个流。这可以使用关闭功能来完成。例如，关闭我的文件流
>>> myFile.close()
使用文件的另一种方式是使用with关键字。查看语法会清楚这是如何工作的-
with open("file.txt", "r+"):
// operations to perform on "file.txt"
// there can be many
// syntax is pretty much like that of methods
通过这种方式，您实际上是在为要使用的文件创建一个范围。一旦程序离开这个范围，文件就会自动关闭。
下一节将详细介绍如何将数据读写到文件中。
Python 文件处理操作
原文：https://www.studytonight.com/python/reading-and-writing-file
在本教程中，我们将学习如何从文件中读取内容，然后将文本写入任何文件，以及如何将文件内容复制到另一个文件中。我们还将使用tell和seek方法处理文件。
Python -读取文件
让我们从学习如何阅读文件开始。
readline()功能用于读取文档中的一行。它可以像这样使用:
>>> myFile.readline()
其中myFile是文件的实例。readline()功能将简单打印从光标位置开始的整行。
为了打印文件的全部内容，逐行迭代，我们可以使用for循环:
for line in myFile:
# will print all the lines one by one
print (line)
除了使用迭代，还有另一种读取整个文件的方式，使用readlines()函数(注意是 readline，不同于 readline)。使用函数将返回一个包含文件每行的列表。正因为如此，人们在使用这个功能时应该小心。如果文件中有大量数据，列表可能会占用大量空间，从而使整个读取时间更长。因此，建议仅在读取可以有效存储在列表中的较短文件时使用此功能。
它的使用非常类似于readlines()，只是在这种情况下，我们需要将返回值存储在某个变量中:
>>> content = myFile.readlines()
类似事情可以使用迭代方法手动完成:
content = []
for line in myFile:
content.append(line)
这将在内容列表中反复追加文件的每一行。
Python -写入文件
write()函数用于将单个字符串写入文件。例如，有一个字符串
>>> content = "Hello, World. I am learning Python."
# In order to write this line in a file
>>> myFile.write(content)
或
>>> myFile.write("Hello, World. I am learning Python")
Write 不能用于写入列表或元组的内容。在这种情况下，使用writelines()函数。
>>> content = ["Python 3.x\n", "Hello, World. I am learning Python"]
>>> myFile.writelines(content)
执行此操作将使用以下内容写入文件内容:
Python 3.x
Hello, World. I am learning Python
Python -讲述和寻找
正如我们之前提到的，一旦你打开一个文件，就会有一个光标在你读或写的时候不停地移动。有时，移动光标而不每次都读取或写入任何变量是很重要的，为此，有一个seek()函数可用于移动到文件中的所需位置。
>>> myFile.seek(offset, [start_from])
offset 决定您想要跳过多少字节，这里第二个参数 start_from 是可选的，它决定您想要从哪个位置开始。可能的值可以是-
- 0 - 文件开始
- 1 - 文件的当前位置
- 2 - 文件结束
如果没有指定参数，默认情况下为 0。
假设有一个文件(file.txt)，内容为你好，世界！
然后使用如下寻道功能:
>>> myFile = open('file.txt','r+')
>>> myFile.seek(5)
>>> myFile.read()
', World!'
这里可以看到，seek()函数跳过了前 5 个字节(即‘你好’)，读取下一个字节直到行尾。为了获得指针的当前位置，可以使用tell()功能。它将返回字节指针远离开始的位置。
>>> myFile.tell()
Python -复制文件
选择要复制的文件并创建其对象。创建另一个对象并使用open()创建一个新文件(如果文件不存在，在open()函数中写入路径会创建该文件)。read()内容来自第一档。write()其他文件中相同。
>>> file1 = open("original.txt", "r")
>>> file2 = open("duplicate.txt", "w")
>>> l = file1.readline()
>>> while l:
file2.write(l)
l = file1.readline()
>>> file1.close()
>>> file2.close()
打开文件replicate . txt，应该可以看到复制的文字。
多线程操作
Python 多线程介绍
原文：https://www.studytonight.com/python/multithreading-in-python
在本教程中，我们将向您介绍多线程的概念，以及如何用 python 编程语言实现线程。让我们从理解什么是线程开始。
线
线程是轻量级进程(大型进程的子进程)，可以并行运行，每个线程都可以执行一些任务。线程通常包含在进程中。同一进程中可以存在多个线程。在同一个进程中，线程共享内存和进程的状态。
螺纹类型
有两种线程:
- 内核级线程
- 用户级线程
下面我们解释了两者之间的一些区别:
| 内核级线程 | 用户级线程 |
| 被操作系统识别。 | 操作系统无法识别。 |
| 由操作系统实现。 | 由系统用户实现。 |
| 实现是复杂的。 | 实现简单易行。 |
| Solaris 就是一个例子 | Posix 就是一个例子 |
| 需要硬件支持 | 不需要硬件支持 |
什么是多线程？
现在我们已经对什么是线程有了一个基本的概念，让我们试着理解多线程的概念。
现代计算机的中央处理器有多个处理核心，每个核心可以同时运行多个线程，这使我们能够同时执行几个任务。这个并发运行多个线程并行执行任务的过程叫做多线程。
多线程提供了以下好处:
- 一个进程中的多个线程共享相同的数据空间，因此可以比单独的进程更容易地共享信息或相互通信。
- 线程不需要太多内存开销；就内存需求而言，它们比进程便宜。
- 多线程程序可以在具有多个 CPU 的计算机系统上运行得更快，因为这些线程可以同时执行。
举个例子
假设您创建了一个简单的活动注册应用，如果参与者希望参加活动，他们必须注册。您有一个简单的 HTML 表单供用户填写，还有一个后端，它是一个单线程应用。
由于应用是单线程的，它一次只能处理一个请求。但是，如果这个活动是一场“酷玩音乐音乐会”，有数百万人想要注册，那该怎么办。一次处理一个请求会大大降低性能。
因此，我们使应用多线程化，并在其中启动多个线程，从而允许并行处理。
Python 中的多线程
在 Python 中执行多线程使用threading模块。threading模块提供了几种函数/方法，可以在 python 中轻松实现多线程。
在我们开始使用threading模块之前，我们想首先向您介绍一个名为time的模块，它提供了一个time()、ctime()等函数，我们将经常使用这些函数来获取当前系统时间，以及另一个关键函数sleep()，该函数用于在给定的秒数内暂停当前线程的执行。
例如，
现在让我们看看如何使用threading模块启动多个线程。
Code Example:
让我们试着理解上面的代码:
我们使用import threading语句导入了thread类，并且还导入了time模块。为了创建一个新的线程，我们创建了一个 te Thread类的对象。它采用以下参数:
target:线程将要执行的功能。
args:要传递给目标函数的参数。我们可以传递多个用逗号分隔的参数。
在上面的例子中，我们创建了两个具有不同目标函数的线程，即thread1(i)和thread2(i)。
为了开始一个线程，我们使用了Thread类的start()方法。
我们还使用了time模块的time.sleep()方法暂停thread1的执行 3 秒钟。
一旦线程启动，当前程序(您可以将其视为主线程)也会继续执行。为了防止主程序在线程执行完成之前完成其执行，我们使用join()方法。
因此，当前程序将等待t1和t2的完成，并且只有在它们的执行完成之后，当前程序的剩余语句才会被执行，即语句print('Execution completed.')。
在注释掉第 16、17 行的代码后，您应该尝试运行上面的代码一次，我们使用join方法查看结果。
至此，我们对 python 多线程的基本介绍已经完成，现在我们知道如何在 python 中创建和启动多线程。
Python 中的threading模块
原文：https://www.studytonight.com/python/threading-module-in-python
正如我们在之前的教程中所看到的，threading模块用于在 python 中创建、控制和管理线程。在本教程中，我们将讨论由threading模块定义的各种函数和对象类型。
threading模块功能
该模块提供以下管理线程的功能:
这是上一个教程的代码片段，我们将使用它来查看threading模块提供的各种功能。
穿线。active_count()功能
该函数返回当前活动的Thread对象的数量。
import time
import threading
def thread1(i):
time.sleep(3)
#print('No. printed by Thread 1: %d' %i)
def thread2(i):
time.sleep(3)
#print('No. printed by Thread 2: %d' %i)
if __name__ == '__main__':
t1 = threading.Thread(target=thread1, args=(10,))
t2 = threading.Thread(target=thread2, args=(12,))
t1.start()
t2.start()
print("No. of active threads: " + threading.active_count())
t1.join()
t2.join()
活动线程数:3
尝试在上面的终端中运行该代码。您将看到线程数为 3 ，因为我们已经创建了 2 个线程，并且在主线程中正在进行完整的执行。
穿线。current_thread()
该函数将返回当前线程对象，对应调用者的控制线程(当前在调用者的控制中)。如果调用者的控制线程不是通过线程模块(例如主线程)创建的，则返回一个功能有限的伪线程对象。
import time
import threading
def thread1(i):
time.sleep(3)
#print('No. printed by Thread 1: %d' %i)
def thread2(i):
time.sleep(3)
#print('No. printed by Thread 2: %d' %i)
if __name__ == '__main__':
t1 = threading.Thread(target=thread1, args=(10,))
t2 = threading.Thread(target=thread2, args=(12,))
t1.start()
t2.start()
print("Current thread is: " + threading.current_thread())
t1.join()
t2.join()
当前线程为:<_mainthread started="">
穿线。get_ident()
该函数返回当前线程的线程标识符。这是一个非零整数值。如果我们启动了线程，那么这个方法将返回它的标识符，否则，它将返回无。
我们可以使用这个方法来索引线程特定数据的字典。当一个线程退出(停止)并创建另一个线程时，可以回收线程标识符。
threading.get_ident()
140578859194112
穿线。enumerate()
该方法返回当前活动的所有Thread对象的列表。该列表包括后台线程(当程序退出时，与之相关的所有后台线程都将自动终止)当前线程创建的虚拟线程对象，以及主线程。
此列表中不存在已终止的线程和尚未启动的线程。
threading.enumerate()
[ <_mainthread started="">、
穿线。main_thread()
此方法返回主 Thread对象。在正常情况下，主线程是启动 python 解释器的线程。
threading.main_thread()
<_mainthread started=""/>
穿线。settrace(fun)
该方法用于为使用threading模块启动的所有线程设置跟踪函数/钩子。对于每个线程，跟踪函数被传递给sys.settrace()方法，该方法在调用run()方法之前被附加到线程。
我们希望作为跟踪函数的回调函数将接收三个参数:frame(来自正在运行的代码的堆栈帧)event(一个命名通知类型的字符串)和arg(一个特定于事件的值)
def hello(frame, event, arg):
print("Hello, I am a trace hook.")
threading.settrace(hello)
尝试更新顶部终端中的代码。将hello函数放在主方法和语句threading.settrace(hello)之外，就在我们为线程调用start方法的语句之上。
穿线。setprofile(fun)
此方法用于为从threading模块启动的所有线程设置配置文件函数。和 trace 函数一样，profile 函数也传递给每个线程的sys.setprofile()方法，在调用run()方法之前附加到线程。
threading.setprofile(hello)
穿线。stack_size([size])
此方法返回创建新线程时使用的线程堆栈大小。size参数是可选的，可用于设置创建后续线程所用的堆栈大小，必须为 0 或正整数(D =默认值为 0)。
如果不支持更改线程堆栈大小，则会引发运行时错误。
如果指定的堆栈大小无效，将引发值错误。
目前 32 KiB 是支持的最小堆栈大小，为解释器提供足够的堆栈空间。
穿线。TIMEOUT_MAX
除了上述指定的功能外，threading模块还定义了一个常数。如果您指定的超时值大于TIMEOUT_MAX常量的值，您将得到一个OverflowError。
threading模块对象
除了上面指定的功能之外，threading模块还提供了许多类，这些类的对象在创建和管理线程时非常有用。
以下是一些对象类型:
| 目标 | 描述 |
| 线 | 对象，表示单个执行线程。 |
| 锁 | 原始锁对象。 |
| 断续器 | RLock 或可重入锁对象为单线程提供了获取(重)已持有锁(递归锁)的能力。 |
| 情况 | 条件变量对象使一个线程等待，直到另一个线程满足某个“条件”(如状态变化或某些数据值) |
| 事件 | 这是条件变量的一个更通用的版本，可以让许多线程等待某个事件的发生，所有等待的线程只有在事件发生时才会被唤醒。 |
| 旗语 | 当线程块之间共享的有限资源不可用时，提供一个“计数器”。 |
| 有界符号 | 类似于信号量，但确保它永远不会超过初始值。 |
| 计时器 | 类似于线程，除了它在运行之前等待一段指定的时间。 |
| 屏障 | 创建一个“屏障”，指定数量的线程必须全部到达该屏障，然后才能继续运行。 |
上表简要介绍了 python threading模块中的各种对象类型。我们将在接下来的几个教程中详细讨论所有这些对象。
Thread类及其对象——Python 多线程
在threading模块中，最流行和最常用的调用是Thread类，它主要用于创建和运行线程。Thread类提供了创建和管理线程所需的所有主要功能。
线程对象是 Thread 类的对象，其中每个对象代表一个要在单独的控制线程中执行的活动。
有两种方法可以创建线程对象并指定要执行的活动:
- 通过将可调用对象传递给构造器
- 或者，在子类中覆盖
run()方法。
使用构造器或运行方法创建的线程对象可以使用start()方法启动。每当线程对象开始一个新的线程，那么在内部它的run()方法被调用。
这里有一个简单的例子:
在上面的例子中，我们还使用了time模块来使其中一个线程休眠。
Thread类构造器的基本语法是:
Thread(group=None, target=None, name=None, args=(), kwargs={})
我们将在下一节解释Thread类构造器的参数。
线程是如何工作的？
一旦我们使用Thread类构造器初始化了一个线程，我们必须调用它的start()方法来启动这个线程。
当线程开始时，线程被认为是活动的和活动的。当其run()方法终止时，正常情况下，或者由于未处理的异常，线程停止活动或活动。isAlive()方法测试线程在任何给定时间点是否活动。
其他线程可以调用一个线程的join()方法来连接任何线程。这将阻塞调用线程，直到调用join()方法的线程终止。
例如，在上面的代码中，从主线程，我们调用t1.join()和t2.join()，因此主线程将等待线程t1和t2终止然后结束。
每个线程都有一个关联的名称。名称可以传递给构造器，也可以分别使用setname()和getname()方法设置或检索名称。
一个标志守护线程可以与任何线程相关联。这个标志的意义在于，当只剩下守护线程时，整个 python 程序就会退出。可以分别使用setDaemon()方法和getDaemon()方法设置或检索标志。
主线程对象对应 python 程序中控件的初始线程。它不是守护线程。
Thread类中的函数和构造器
现在我们已经看到了一个运行线程的基本线程程序，是时候理解代码以及探索Thread类提供的所有重要方法了。
Thread类构造器
以下是Thread类构造器的基本语法:
Thread(group=None, target=None, name=None, args=(), kwargs={})
构造器允许许多参数，有些是必需的，有些不是。让我们看看它们是什么:
-
group:应该是无。它是为将来的扩展保留的。 -
target:这是run()方法要调用的可调用对象或任务。如您在顶部的代码示例中所见，我们已经指定函数名 thread1 和 thread2 作为该参数的值。默认值为无。 -
name:用于指定线程名称。默认情况下，会按照格式 Thread-N 生成一个唯一的名称，其中 N 是一个小的十进制数。 -
args:这是目标调用的参数元组。我们可以在其中提供可用于 traget 方法的值。默认值为空，即() -
kwargs:这是目标调用的关键字参数字典。这默认为{}。
start()方法
此方法用于启动线程的活动。当我们调用这个方法时，内部调用run()方法，该方法执行目标函数或可调用对象。
run()方法
表示线程活动的方法。
您可以在扩展threading模块的Thread类的子类中覆盖这个方法。标准 run()方法调用传递给对象构造器的可调用对象作为目标参数，顺序参数和关键字参数分别取自args和kwargs参数。
这里有一个简单的例子，我们已经创建了一个子类，在这个子类中我们将覆盖run()方法。
join([timeout])方法
当我们为任何线程调用此方法时，它会阻塞调用线程，直到其join()方法被调用的线程正常或通过未处理的异常终止。
如果要提供timeout参数，应该是浮点数。
getName()方法
此方法用于返回线程的名称。
setName(name)方法
用于设置线程的名称。该名称是一个仅用于识别目的的字符串。
isAlive()方法
此方法返回线程是否活动。从start()方法返回的那一刻起，直到其run()方法终止，线程都是活动的。
isDaemon()方法
此方法用于获取线程守护程序标志的值。
setDaemon(daemonic)方法
该方法用于将线程的守护标志设置为布尔值后台。这必须在调用start()方法之前调用。
当没有活动的非守护线程时，整个 Python 程序就会退出。
Python 中的锁对象——线程同步
原文：https://www.studytonight.com/python/python-threading-lock-object
在多线程中，当多个线程同时处理一个共享资源(如文件)时(向文件中读写数据)，为了避免并发修改错误(多个线程访问同一资源导致数据不一致)，使用了某种锁定机制，当一个线程访问一个资源时，它会锁定该资源，直到它释放该锁定，其他线程都不能访问同一资源。
锁对象:Python 多线程
在 Python 的threading模块中，为了高效多线程，使用了一个原语锁。这个锁帮助我们同步两个或多个线程。锁类可能提供了 Python 中最简单的同步原语。
原始锁可以有两种状态:锁定或解锁，并且最初是在我们初始化 lock 对象时在解锁状态下创建的。它有两种基本方法，acquire()和release()。
以下是创建锁对象的基本语法:
import threading
threading.Lock()
锁对象使用两种方法，它们是:
acquire(blocking=True, timeout=-1)方法
此方法用于获取锁。当它在没有参数的情况下被调用时，它会一直阻塞，直到锁被解锁。
该方法可以采用 2 个可选参数，它们是:
- 阻塞标志，如果该锁已经被某个其他线程获得，则该标志如果作为
False发送，将不会阻塞该线程，并将作为结果返回False。如果您将该阻塞标志的值提供为True，那么如果其他线程持有锁，调用线程将被阻塞，一旦锁被释放，那么您的线程将获得锁并返回True。 - timeout 参数用于提供一个正浮点值，该值指定如果其他线程正在持有锁，调用线程将被阻塞的秒数。默认值为 -1 表示如果线程不能立即获得锁，它将被无限期阻塞。
release()方法
它用于释放获取的锁。如果锁被锁定，这个方法会将其重置为解锁状态，然后返回。此外，该方法可以从任何线程调用。
当调用此方法时，已经等待获取锁的线程中的一个被允许持有锁。
此外，如果在未锁定的锁上调用它，它会抛出RuntimeError。
是时候举个例子了！
下面我们有一个简单的 python 程序，其中我们有一个类SharedCounter，它将作为线程之间的共享资源。
我们有一个task方法，我们称之为increment()方法。由于多个线程将访问同一个计数器并增加其值，因此存在并发修改的可能性，这可能导致counter的值不一致。
请始终从上面的代码中获取:
- 当一个线程使用
acquire()方法获取锁，然后访问一个资源时，如果在访问资源的过程中出现了一些错误，会怎么样？在这种情况下，没有其他线程能够访问该资源，因此我们必须访问try块内的资源。在finally区块内部，我们可以调用release()方法来重新锁定。 - 尝试注释第 13 行和第 19 行的代码，并尝试多次运行代码，有时您会看到代码会给出正确的输出，但有时您会看到不正确的
counter值。
Python 中的锁对象——可重入锁
原文：https://www.studytonight.com/python/python-threading-rlock-object
如果您尝试运行下面提供的代码，锁对象将在第一次调用acquire()方法时获得锁，但第二次不会。
为什么会这样？因为正常的锁对象一旦被获取就不能被重新获取，即使相同的线程试图这样做。
但是为什么会有人尝试两次调用acquire()方法呢？让我们举一个简单的例子来演示这个简单的锁定问题:
lock = threading.Lock()
def get_first_line():
lock.acquire()
try:
# read some file and get the first line
finally:
lock.release()
return data
def get_second_line():
lock.acquire()
try:
# read the same file and get the second line
finally:
lock.release()
return data
在上面的代码中，我们有两个不同的函数从共享资源中读取不同部分的数据。我们使用了锁定机制来防止任何其他线程在我们的线程读取文件时修改文件的数据。
现在考虑您想要逐个调用这两个函数，您将这样做:
first = get_first_line()
second = get_second_line()
return first, second
但是这个调用仍然不是线程安全的，因为当您从共享资源中读取数据时，在两个函数调用之间可以有任何其他线程可以修改共享资源的内容。
为了避免这种情况，我们可以获取一个锁，然后调用这两个函数:
lock.acquire()
try:
first = get_first_line()
second = get_second_line()
finally:
lock.release()
return first, second
但是，这段代码不会起作用，因为我们将在同一线程内的锁对象上调用acquire()，试图在调用函数之前已经获取的函数内再次获取锁。
因此，在这种情况下，不能使用基本的锁对象。对于这样的情况我们有RLock类。
对象:Python 多线程
RLock 代表可重入锁。同一个线程可以多次获取可重入锁。
RLock 对象也有两个可以调用的方法，它们是:
acquire()方法release()方法
这里有一个简单的例子来演示RLock对象的工作:
如果我们使用RLock对象，那么简单的锁定问题示例中的代码也将毫无问题地工作:
lock = threading.RLock()
lock.acquire()
try:
first = get_first_line()
second = get_second_line()
finally:
lock.release()
return first, second
上面的代码可以正常工作。
使用事件对象的线程同步
原文：https://www.studytonight.com/python/python-threading-event-object
是时候了解更多 python 中的线程了。在本教程中，我们将介绍一个重要的类，Event类，它在 python 中用于线程同步。
这个类通过生成事件用于线程间通信。
Python 多线程:事件对象
事件类对象提供了一种简单的机制，用于线程之间的通信，其中一个线程发出事件信号，而其他线程等待它。因此，当一个用于产生信号的线程产生信号时，等待的线程就会被激活。
一个内部标志被称为事件标志的事件对象使用，该标志可以使用set()方法设置为真，并且可以使用clear()方法重置为假。
wait()方法阻塞一个线程，直到它正在等待的事件标志被任何其他线程设置为真..
以下是与事件对象一起使用的有用函数:
初始化事件对象
我们可以如下初始化事件对象:
import threading
are_you_coming = threading.Event()
当我们像这样初始化一个事件对象时，默认情况下内部标志被设置为假。
isSet()方法
当且仅当内部标志为真时，此方法返回真。
import threading
are_you_coming = threading.Event()
print(are_you_coming.isSet())
错误的
set()方法
当对任何事件对象调用此方法时，内部标志被设置为 true。一旦为任何事件调用set()方法，所有等待它的线程都会被唤醒。
clear()方法
此方法将内部标志重置为 false。随后，对调用clear()的事件调用wait()的线程将阻塞，直到内部标志再次不为真。
wait([timeout])方法
当我们必须让任何线程等待一个事件时，我们可以这样做:在内部标志设置为 false 的事件上调用这个方法，这样做将阻塞线程，直到事件的内部标志为 true。
如果入口时内部标志为真，则线程永远不会被阻塞。否则，它将被阻止，直到另一个线程调用set()将标志设置为真，或者直到可选超时发生。timeout 参数以秒为单位指定操作超时。
举个例子
让我们有一个简单的代码示例来演示Event类对象的用法。
在下面的代码中，我们将创建一个线程，让它等待一个由主线程生成的事件，释放第一个线程。
在上面的程序中，我们也使用了wait()方法的timeout属性。
当线程调用wait([timeout])方法时，如果在接收事件对象时释放等待，则该方法返回布尔值真，否则如果由于超时而释放等待，则该方法返回假。
为了测试这一点，更改第 18 行作为参数args=(e,4)发送的超时值，并使其小于睡眠时间，例如，将超时值设置为 2 并查看输出。
计时器对象——Python 多线程
原文：https://www.studytonight.com/python/python-threading-timer-object
定时器对象是使用Thread类的子类Timer类创建的。使用这个类，我们可以为任何应该在一定时间后运行的操作设置一个延迟(计时器)，并且可以在该延迟期间轻松取消。
计时器通过调用其start()方法启动，就像普通线程一样。定时器线程可以通过调用其cancel()方法来停止(在其动作开始之前)。
定时器对象通常用于实现预定的任务，这些任务应该只在某个时刻之后执行。
此外，定时器对象没有必要在计划的时间之后执行，因为在此之后 python intrepreter 会寻找一个线程来执行定时器对象任务，如果该线程不可用，就会导致更多的等待。
创建计时器对象的语法
以下是Timer类构造器的语法:
threading.Timer(interval, function, args=[], kwargs={})
这样，我们可以创建一个计时器对象，在经过interval秒后，该对象将运行带有参数args和关键字参数kwargs的功能。
Timer类方法
在Timer类中，我们有两种方法用于启动和取消定时器对象的执行。
start()方法
此方法用于启动计时器对象的执行。当我们调用这个方法时，定时器对象启动它的定时器。
cancel()方法
此方法用于停止计时器并取消计时器对象操作的执行。这只有在计时器尚未执行其动作的情况下才会起作用。
举个例子
下面我们有一个简单的例子，我们创建一个定时器对象并启动它。
import threading
def task():
print("timer object task running...")
if __name__=='__main__':
t = threading.Timer(10, task)
t.start() # after 10 seconds, task will be executed
上面的程序是一个简单的程序，现在让我们使用 cancel 方法来取消 timer 对象任务的执行。
在上面的程序中，首先注释第 13 行和第 14 行的代码并运行程序，然后取消注释这些行，并看到cancel()方法在起作用。
Python 中的条件对象——线程同步
原文：https://www.studytonight.com/python/python-threading-condition-object
为了更有效地同步对任何资源的访问，我们可以将条件与任务相关联，让任何线程等待，直到满足某个条件，或者通知其他线程该条件正在满足，以便它们可以解除对自身的阻止。
让我们举一个简单的例子来理解这一点。在生产者消费者问题中，如果有一个生产者生产某一物品，一个消费者消费该物品，那么在生产者生产该物品之前，消费者不能消费该物品。因此，消费者要等到产品生产出来。生产者有责任告知消费者，一旦产品成功生产，就可以消费。
如果有多个消费者消费生产者生产的产品，那么生产者必须通知所有消费者生产的新产品。
这是 python 多线程中条件对象的完美用例。
条件对象:wait()、notify()和notifyAll()
现在我们知道了 python 多线程中条件对象的用途，让我们看看它的语法:
condition = threading.Condition([lock])
条件对象接受一个可选的锁对象作为参数。如果我们不提供任何东西，那么它会创建一个默认锁。
条件对象有acquire()和release()方法，调用关联锁的相应方法。还有wait()方法、notify()方法、notifyAll()方法。这三个只能在调用线程获得锁后调用。
条件类方法
以下是条件类方法:
acquire(*args)方法
此方法用于获取锁。该方法对条件对象中存在的基础锁调用相应的acquire()方法；返回值是该方法返回的任何值。
release()方法
此方法用于释放锁。该方法对条件对象中存在的基础锁调用相应的release()方法。
wait([timeout])方法
此方法用于阻塞线程，并使其等待，直到其他线程通过在同一条件对象上调用notify()或notifyAll()方法通知它，或者直到超时发生。
只有当调用线程获得锁时，才能调用这个函数。
当被调用时，这个方法释放锁，然后阻塞线程，直到被其他线程对相同条件变量的notify()或notifyAll()调用唤醒，或者直到超时发生。
如果由于notify()或notifyAll()方法而被释放，该方法返回True，否则如果超时，该方法将返回False布尔值。
notify()方法
它会唤醒任何等待相应条件的线程。只有当调用线程获得锁时，才能调用这个函数。此外，调用此方法只会唤醒一个等待的线程。
notifyAll()方法
它会唤醒所有等待这个条件的线程。这个方法的行为类似于notify()方法，但是唤醒了所有等待的线程，而不是一个。
是时候举个例子了！
在下面的代码示例中，我们实现了一个简单的生产者-消费者解决方案，生产者生产一个项目，并将其添加到消费者消费这些项目的列表中。
上面的代码示例中有几个重要的要点:
- 我们创建了一个类
SomeItem，它有一个list，作为生产者和消费者线程之间的共享资源。 - 生产者线程正在随机生成一些列表项，并将其添加到列表中。
- 消费线程尝试消费物品，如果没有找到物品，则开始等待。如果生产者在超时前向消费者发送关于项目创建的通知，那么消费者消费该项目，否则由于超时而退出。
这是一个非常简单的例子，涵盖了条件对象的所有用例。尝试用 2 个使用者线程和一个生产者线程运行上面的程序。
屏障对象——Python 多线程
原文：https://www.studytonight.com/python/python-threading-barrier-object
使用threading模块中可用的Barrier类创建屏障对象。这个对象可以用在我们希望一组线程相互等待的地方。
例如，如果我们有两个线程，并且我们希望两个线程都准备好了就执行。在这种情况下，一旦准备好，两个线程都将调用屏障对象上的wait()方法，并且只有当两个线程都调用了wait()方法时，两个线程才会同时释放。
以下是初始化屏障对象的Barrier类的语法:
threading.Barrier(parties, action=None, timeout=None)
其中，parties指定等待屏障的线程数，action可用于指定等待屏障的任何一个线程将执行的功能，timeout用于指定超时值(以秒为单位)，超过该值后，屏障将从所有等待的线程中释放。
Barrier类提供的功能
以下是Barrier类提供的功能:
wait(timeout=None)方法
当我们希望一组线程相互等待时，我们在创建屏障对象时用指定为parties参数的线程数初始化屏障对象。
然后，只有当相同数量的线程调用屏障对象的wait()方法时，屏障才会被释放。
如果在一个线程中，我们在调用wait()方法时提供了超时值，那么一旦超时时间过去，该线程将从屏障中被释放。
该方法返回一个从 0 到方-1 的整数值。我们可以使用这个值来识别哪些线程已经到达了屏障的等待点，哪些线程还没有到达，例如:
i = barrier.wait()
if i == 0:
# Only one thread Will be allowed to print this
print("0th thread passed the barrier")
wait()方法的返回值可以用于执行一些清理任务，例如，如果我们有 3 个线程在做一些工作，并使用一个临时文件来存储数据，一旦线程完成，我们可以对wait()方法进行检查，当最后一个线程到达其等待点并且屏障要被释放时，在此之前删除该文件。
i = barrier.wait()
if i == 2:
# delete the temporay file
如果等待呼叫超时，屏障进入断开状态。
如果当线程等待时屏障破坏或重置，则wait()方法可能会发出BrokenBarrierError。
reset()方法
该功能将屏障重置为默认的空状态。如果有线程等待屏障被释放，将会收到BrokenBarrierError。
abort()方法
当在屏障上调用此方法时，它会进入破碎状态。一旦该方法被任何等待线程调用，等待屏障释放的其余线程将接收BrokenBarrierError。
我们可能希望在一些死锁情况下使用这个方法来释放等待的线程。
parties
这将返回我们通过屏障所需的线程数。
n_waiting
这将返回当前等待释放屏障的线程数。
broken
这是一个布尔值，如果屏障处于断开状态，则该值为True。
是时候举个例子了！
下面我们有一个简单的例子，其中我们有两个线程分别代表服务器和客户端，其中客户端线程将等待服务器准备就绪后再向其发送任何请求。
在上面的代码中，尝试在客户端或服务器端调用abort()方法，看看会发生什么。您可能需要使用try块并捕捉代码中的BrokenBarrierError。
Python 日志记录
在 Python logging模块中打印日志
在本教程中，我们将学习什么是日志记录？(日志记录基础知识)，如何在 python 中打印日志以及打印日志时应该使用的不同日志级别。
首先，让我们讨论什么是日志。
什么是日志记录？
日志基本上是任何程序/脚本运行时跟踪事件(正在发生什么)的一种方式。软件开发人员在他们的软件中添加了日志调用，以在软件代码执行期间打印有用的步骤以及一些信息，这些信息可以在以后用于跟踪代码执行。
-
适当的日志记录可以帮助你更好地理解程序的流程，并且它非常有助于发现那些你在开发过程中可能没有想到的场景。
-
日志在调试问题中非常重要。
-
在日志的帮助下，开发人员有了一双额外的眼睛来观察应用的流程。日志可以存储信息，比如哪个用户 ID 或者哪个 IP 正在访问应用。
-
通过在软件应用中记录有用的数据和度量，您不仅可以轻松调试错误，还可以使用数据分析应用的性能来计划扩展。
-
一个事件被描述为一个描述性消息，它可以可选地包含可变数据(即，对于事件的每次发生，数据主要是不同的)。
-
打印的事件或日志也有一个重要性也称为日志级别，我们将在本教程的后面部分介绍。
许多初学者在 python 代码中使用print()方法来打印语句和变量，调试代码。
使用日志来做到这一点是正确的方法。
Python logging模块
logging模块是 Python 中的一个内置模块，功能强大，随时可以使用。该模块允许将日志写入文件或控制台或任何其他输出流。
这个模块被很多第三方 Python 库使用。因此，如果您的 python 项目使用许多第三方库，那么您可以使用logging模块，这样日志处理在您的项目和您正在使用的第三方库中可以是相同的。
要使用本模块，您只需编写以下内容:
import logging
导入logging模块后，可以使用logging模块提供的各种方法打印日志。
不同级别的日志消息
在logging模块中，默认有 5 个标准级别，主要指示事件的严重性。此外，日志记录函数以级别命名。
这些级别按严重程度的递增顺序如下所示:
让我们在下表中逐一讨论每个级别的含义:
| 级 | 使用时间 |
| 调试 | 该级别主要用于提供详细信息，一般只有在调试问题时才有兴趣。 |
| 信息 | 这个级别用来确认事情是否按预期进行。只是平常的信息。 |
| 警告 | 这个级别告诉发生了意想不到的事情但不要太严重，可能会影响程序/软件的正常运行。 |
| 错误 | 这应该用于记录更严重的问题，如导致功能被破坏的错误或异常。 |
| 批评的 | 该级别表示超级严重错误，如应用未启动或数据库不可用建立连接等。 |
您可以在 python 代码中使用所有类型的日志级别来记录不同的信息。
但是将打印什么日志，取决于日志配置。
需要注意的是默认级别为WARNING，这意味着只跟踪该级别及以上的事件，分别为:警告、错误和严重。
Python 日志记录方法
对于简单的日志使用，有一些方便的功能，如debug()、info()、warning()、error()和critical()。让我们一个接一个地讨论它们:
| 如何登录？ | 要执行的任务 |
| print()方法 | 如果您想在控制台上显示用户信息的正常消息。 |
| warning.warn()和logging.warn() | 记录关于特定运行时事件的警告。如果问题是可避免的，并且必须进行更改以消除警告，则在 python 代码中使用warning.warn()方法。logging.warning()方法用于出现一些小问题/错误的情况，这些小问题/错误对代码的运行没有任何直接影响，但必须进行跟踪，因为它可能会在以后导致问题。比如模块版本不匹配等。 |
| 引发错误/异常 | 以便报告关于特定运行时事件的错误。 |
| logging.error()或logging.critical() | 如果您想在不引发异常的情况下报告错误。如果你已经在 python 中做了正确的异常处理，但是你仍然必须记录处理的异常，以便以后可以发现和修复它。logging.critical()可用于程序启动失败或数据库连接失败等关键错误。 |
| logging.info()或logging.debug() | logging.info()方法可用于报告程序正常运行期间发生的事件(例如，用于状态监控或故障调查)。logging.debug()专门用于诊断目的的非常详细的输出。 |
Python 日志记录基本示例
让我们举一个基本的例子，我们将打印对应于不同日志级别的日志消息:
import logging
logging.debug('It is a debug message') # it will not be printed
logging.info('It is an info message') # not printed
logging.warning('OOPs!!! It is a warning') # it will be print because it is default level
logging.error('Oops !! an error message') # will be printed
logging.critical('Oh!!!! it is a critical message') # will be printed
警告:根:哎呀！！！这是一个警告错误:根:哎呀！！错误消息 CRITICAL:root:哦！！！！这是一个重要的信息
上面的输出显示了每个消息之前的严重级别以及root，这是日志记录模块给其默认日志记录程序的名称。
上面的输出格式显示了级别、名称和消息，并用冒号(:)隔开，是日志的默认格式(我们可以更改格式)。
需要注意的是debug()和info()消息没有被记录。这是因为，默认情况下，日志记录模块记录的消息具有严重级别****警告或以上，正如我们已经提到的。
如果您愿意，也可以通过配置logging模块来记录所有级别的事件来改变这一点。
Python 日志记录基本配置
原文：https://www.studytonight.com/python/python-logging-configuration
到配置python logging模块，设置日志级别、日志格式等。，我们可以使用basicConfig(**kwargs)方法，其中函数定义中的**kwargs表示该函数采用变长参数，应该以键值形式传递。
basicConfig()功能中一些常用参数如下:
-
level:在这个参数的帮助下，根记录器将被设置为指定的严重级别，如 DEBUG、INFO、ERROR 等。 -
filename:这个参数主要用来指定文件名如果我们想把日志存储在一个文件中。 -
filemode:如果给出filename，则文件在模式下打开。默认模式为a，即追加。 -
format:用于指定日志消息的格式。例如，如果您想在日志中添加时间戳，或者 python 脚本的名称，或者日志中的函数或类名，那么我们可以为此指定适当的格式。
在basicConfig()函数中，我们既可以为级别参数提供合适的值，文件名和文件代码用于打印文件中的日志，格式参数用于指定日志，也可以将所有参数一起指定，这就是**kwargs的妙处，也就是说一个函数可以提供的参数数量不是固定的。
让我们举个例子
让我们看一下这个例子，以便清楚地理解这个方法:
import logging
logging.basicConfig(level=logging.INFO)
logging.info('This is an info message.This will get logged.')
信息:根:这是一条信息消息。这将被记录下来。
所有在INFO级或以上的事件将被记录。
需要记住的要点:
-
这里需要注意的是，调用
basicConfig()到来配置根记录器仅在根记录器之前没有被配置的情况下才起作用。基本上这个函数只能调用一次。 -
还有
debug()、info()、warning()、error()、critical()，如果在之前没有调用过basicConfig()方法，所有这些函数都会自动内部调用basicConfig()方法，没有任何参数。 -
这意味着在第一次调用上面给出的函数之后，您不能再配置根记录器，因为它们会在内部调用
basicConfig()函数。
因此basicConfig()中的默认设置是设置记录器以下列格式写入控制台:
错误:根:这是一条错误消息
日志级别、记录器名称，然后是日志消息。
将日志存储在文件中
我们可以使用basicConfig()方法将日志存储在文件中。我们如何做到这一点，我们将在下一个教程中学习如何在文件中存储 Python 代码日志。
设置日志格式
我们可以配置logging模块，以任何我们想要的格式打印日志。有一些通用的标准格式，我们可以配置 python 记录器以这些格式打印日志。
日志的一些基本组件已经是日志记录的一部分，我们可以很容易地添加它们或者从输出格式中删除它们。
让我们举几个例子来理解这一点。
将进程标识添加到日志级别和消息的日志中
如果您想在日志级别和消息中包含运行 python 脚本的进程标识，那么下面给出了相同的代码片段:
import logging
logging.basicConfig(format='%(process)d-%(levelname)s-%(message)s')
logging.warning('This message is a warning')
1396-警告-该消息是警告
在上面的代码中，在basicConfig()方法中，我们用格式字符串作为我们指定的值设置了format参数，我们希望在日志中包含哪些组件，并指定其数据类型，就像用进程的d打印整数进程 Id 一样，然后用s打印日志级别，这是字符串值，对消息也是如此
此外，在上面的代码中，我们可以以任何顺序设置LogRecord属性的格式。
使用日志消息向日志添加时间戳
您也可以将日期和时间信息(时间戳)与日志消息一起添加到日志中。其代码片段如下所示:
import logging
logging.basicConfig(format='%(asctime)s - %(message)s', level=logging.INFO)
logging.info('This message is to indicate that Admin has just logged in')
2020-06-19 11:43:59，887 -此消息表示管理员刚刚登录
在上面的代码中%(asctime)s添加了LogRecord的创建时间。此外，我们还用代码level=logging.INFO配置了日志级别。
使用datefmt属性
您也可以使用datefmt属性更改格式，该属性使用与日期时间模块中的格式功能相同的格式语言，例如time.strftime():
import logging
logging.basicConfig(format='%(asctime)s - %(message)s', datefmt='%d-%b-%y %H:%M:%S')
logging.warning('The Admin just logged out')
19-6-20 11:50:28-管理员刚注销
如您所见，作为上述代码输出打印的日志具有日期格式 DD-MMM-YY 以及时间。
因此，使用basicConfig(**kwargs)方法，我们可以根据需要配置日志格式，如向日志添加时间戳、向日志添加进程 id、与日志和日志消息一起打印日志级别。
使用 Python 在文件中打印日志
原文：https://www.studytonight.com/python/python-logging-in-file
如果您想在文件中打印 python 日志，而不是在控制台上打印，那么我们可以通过提供filename和filemode作为参数来使用basicConfig()方法。
消息的格式可以使用basicConfig()方法中的format参数来指定。
让我们举一个基本的例子，将日志打印到一个文件中，而不是在控制台上。下面给出了代码片段:
import logging # first of all import the module
logging.basicConfig(filename='std.log', filemode='w', format='%(name)s - %(levelname)s - %(message)s')
logging.warning('This message will get logged on to a file')
根错误-此消息将被记录到一个文件中
上面的输出显示了消息看起来是怎样的，但是请记住，它将被写入名为 std.log 的文件，而不是控制台。
在上面的代码中，filemode被设置为w，这意味着每次调用basicConfig()时，日志文件都是以写模式打开的，每次运行程序后，它都会重写文件。
文件模式的默认配置是a，即追加，这意味着日志将被追加到日志文件中，并将日志添加到现有日志中。
Python 日志记录-将日志存储在文件中
下面给出了一些基本步骤:
-
首先，只需写
import logging，简单导入logging模块。 -
第二步是创建和配置记录器。要配置记录器将日志存储在文件中，必须传递要记录事件的文件的名称。
-
在第三步中，还可以设置记录器的格式。请注意，默认情况下，文件在追加模式下工作，但如果需要，我们可以将其更改为写入模式。
-
您还可以设置记录器的级别。
现在让我们继续看代码:
#importing the module
import logging
#now we will Create and configure logger
logging.basicConfig(filename="std.log",
format='%(asctime)s %(message)s',
filemode='w')
#Let us Create an object
logger=logging.getLogger()
#Now we are going to Set the threshold of logger to DEBUG
logger.setLevel(logging.DEBUG)
#some messages to test
logger.debug("This is just a harmless debug message")
logger.info("This is just an information for you")
logger.warning("OOPS!!!Its a Warning")
logger.error("Have you try to divide a number by zero")
logger.critical("The Internet is not working....")
上面的代码会写一些消息到名为 std.log 的文件中。如果我们打开文件，那么消息将如下所示:
2020-06-19 12:48:00，449 -这只是无害的调试消息 2020-06-19 12:48:00，449 -这只是给你的一个信息 2020-06-19 12:48:00，449 - OOPS！！！这是一个警告 2020-06-19 12:48:00，449 -你试过用零除一个数字吗 2020-06-19 12:48:00，449 -互联网不工作了...
您可以更改日志的格式、日志级别或LogRecord的任何其他属性，以及设置文件名以将日志和模式一起存储在文件中。
Python 日志变量数据
原文：https://www.studytonight.com/python/python-logging-variable-data
有时，您可能希望在日志中包含一些来自应用的动态信息。
正如我们到目前为止在示例中看到的，我们在日志中打印字符串，并且我们可以通过向其中添加变量值来轻松地格式化和创建字符串。这也可以在debug()、warning()等测井方法中完成。
为了记录变量数据，我们可以使用字符串来描述事件，然后将变量数据作为参数追加。让我们借助下面给出的例子来看看我们将如何做到这一点:
例子
import logging
logging.warning('%s before you %s', 'Think', 'speak!')
警告:根:说话前先思考！
在上面的代码中，变量数据被合并到事件描述消息中，使用旧的%s样式的字符串格式。
此外，传递给方法的参数将作为变量数据包含在消息中。
还有另一种方法
由于您可以使用任何格式样式，Python 3.6 中引入的 f 字符串也是格式化字符串的一种神奇方式，因为在它们的帮助下，格式变得简短且易于阅读:
下面是一个代码示例:
import logging
name = 'Thomas'
logging.error(f'{name} raised an error in his code')
错误:root: Thomas 在他的代码中引发了一个错误
Python 日志类和函数
原文：https://www.studytonight.com/python/python-logging-classes-and-functions
在我们之前的教程中，我们已经看到了如何使用和配置名为root的默认日志器，主要由logging模块使用，每当直接调用其函数时，就像这样:logging.info()。
您也可以通过创建 Logger类的对象来定义自己的记录器，尤其是在您的应用有多个模块的情况下。****
让我们看看logging模块中的一些类和函数。
logging模块中已经定义的最常用的类如下所示:
1.记录器类
Logger是其对象将在应用代码中直接用于调用函数的类。
2.LogRecord(日志记录)
记录器类自动创建LogRecord对象，这些对象包含与被记录的事件相关的信息，或者简单地说是日志消息。它包含诸如记录器的名称、功能、行号、消息、进程 id 等信息。
3.处理者
Handlers 主要用于将LogRecord发送到所需的输出目的地，它可以是控制台或文件
类Handler是StreamHandler、FileHandler、SMTPHandler、HTTPHandler等子类的基础。这些子类也将日志输出发送到相应的目的地，如sys.stdout或磁盘文件。
4.格式程序
格式化程序是一个类，您可以通过指定字符串格式来指定输出的格式，该字符串格式主要列出输出应该包含的属性。
几个记录器对象
在logging模块中，所有大写的项目都是常量，大写的项目表示类，以小写字母开头的项目是方法。下面我们有一个由logging模块提供的几个日志对象组成的表:
| 物体 | 描述 |
| 记录器信息(msg) | 该功能主要帮助在该记录器上记录级别为INFO的消息。 |
| 记录器.警告(msg) | 该功能主要帮助在该记录器上记录警告级别的消息。 |
| 记录器.错误(msg) | 该功能主要帮助在该记录器上记录级别为ERROR的消息。 |
| Logger.critical(msg) | 该功能主要帮助在该记录器上记录级别为CRITICAL的消息。 |
| 记录器. setLevel(lvl) | 该功能主要用于将记录器的阈值设置为 lvl，并指示低于该级别的所有消息都将被忽略。 |
| 记录器. exception(msg) | 该功能主要帮助在该记录器上记录级别为ERROR的消息。 |
| Logger.log(lvl，msg) | 这个函数将在这个记录器上记录一个整数级别的消息。 |
| 记录器.过滤器(记录) | 该方法主要用于对提供的记录应用记录器的过滤器，如果要处理该记录，它将返回True。否则，将返回False。 |
| 记录器. addFilter(filt) | 用于向该记录器添加特定过滤器filt。 |
| 记录器. removeFilter(filt) | 用于从该记录器添加特定过滤器filt。 |
| 记录器.散列处理程序() | 这主要用于检查记录器是否配置了任何处理器。 |
| 记录器. addHandler(hdlr) | 为了向该记录器添加特定的处理程序hdlr。 |
| 记录器.移除处理程序(hdlr) | 为了移除该记录器的特定处理器hdlr。 |
Python 和 MySQL
Python 支持的 MySQL
原文：https://www.studytonight.com/python/python-mysql-introduction
在本教程中，我们将学习什么是 MySQL ，在 Python 中使用 MySQL 的先决条件是什么，以及从哪里可以下载并安装 MySQL** 和 MySQL Python 连接器。**
首先，让我们看看学习 Python 中的 MySQL 需要哪些先决条件:
Python MySQL -先决条件
以下是获得全面理解所需的先决条件:
注:
在本教程中，我们的主要目的是教你如何在 Python 中使用 MySQL。
什么是 MySQL？
让我们先了解一下 MySQL 是什么:
MySQL 是一个基于结构化查询语言 (SQL)的开源、关系数据库管理系统。这里需要注意的一点是，MySQL 是用来存储数据的，不是用来创建程序的；因此，它不是一种编程语言。
-
因此 SQL 可以用来编程一个 MySQL 数据库。
-
MySQL 的主要优点是它可以在任何操作系统上运行。
-
是热门数据库之一。
如果你想练习我们即将到来的教程中的代码示例，那么你必须在你的计算机上安装 MySQL。它是免费提供的，你可以从它的官方网站下载并安装 MySQL 数据库:
https://www.mysql.com/downloads/
安装 MySQL 后，下一步就是为 python 安装 mysql 连接器。现在问题来了什么是 MySQL 连接器？
MySQL 连接器
基本上 Python 需要一个 MySQL 驱动，用于访问 MySQL 数据库，在这个例子中“MySQL 连接器”就是驱动
Python 的 MySQL 连接器是一个连接器，使 Python 程序能够访问 MySQL 数据库。
有两种方法可以下载 MySQL 连接器:
-
第一种方式是你可以从给定的链接https://dev.mysql.com/downloads/connector/python/下载安装
-
另一种方法是使用画中画安装“MySQL 连接器”，因为画中画已经安装在你的 Python 环境中了。所以你可以通过将你的命令行导航到画中画的位置，然后写下:
python -m pip install mysql-connector-python
我们推荐你使用第二种方式，那就是通过 PIP；这也是你的选择。
现在，在此之后 MySQL 驱动程序，即“MySQL 连接器”被成功下载并安装在您的计算机上。但是为了确认，我们可以测试一下 MySQL 连接器。
测试 MySQL 连接器
要检查 MySQL 连接器是否正确安装在您的系统中，您只需要编写以下代码:
import mysql.connector
如果上面的代码成功运行，没有产生任何错误，那么这意味着安装是正确的。
现在我们将创建连接，在这个连接的帮助下，我们可以进一步创建数据库，插入其中，并执行其他查询。
创建连接
第一步是创建连接。
现在我们将使用 MySQL 的用户名和密码连接到数据库。如果您忘记了您的用户名或密码，请使用密码创建一个新的用户。
###Connecting to the database
###Let us import mysql.connector
import mysql.connector
## Now connecting to the database using 'connect()' method
## it takes 3 required parameters 'host', 'user', 'passwd'
mydb = mysql.connector.connect(
host="localhost",
user="yourusername",
password="yourpassword"
)
print(mydb)
它将产生如下输出:
以上输出表明您已经连接到 MySQL 数据库。在接下来的教程中，我们将开始使用 SQL 语句查询数据库。
Python MySQL——创建数据库
原文：https://www.studytonight.com/python/python-mysql-database
在本教程中，我们将学习如何创建数据库或者如何使用 Python 检查 MySQL 中是否已经存在任何数据库。
要在 MySQL 中创建数据库，我们将使用“CREATE DATABASE”语句。
Python MySQL - CREATE DATABASE
下面是创建数据库语句的基本语法:
CREATE DATABASE database_name
现在我们将创建一个名为“StudyTonight”的数据库。让我们看看我们将如何创建它:
Python MySQL -创建数据库示例
让我们创建一个名为“StudyTonight”的数据库。下面给出了相同的代码片段:
#for our convenience we will import mysql.connector as mysql
import mysql.connector as mysql
db = mysql.connect(
host = "localhost",
user = "yourusername",
passwd = "yourpassword"
)
## Now Let us create an instance of 'cursor' class which is used to execute the 'SQL' statements in 'Python'
cursor = db.cursor()
## creating a database called 'studytonight'
## 'execute()' method is used to compile a 'SQL' statement
## below statement is used to create tha 'studytonight' database
cursor.execute("CREATE DATABASE studytonight")
在这种情况下，如果名为“今夜研究”的数据库已经存在，那么上面的代码将引发一个错误。
如果没有错误，则表示数据库创建成功。
现在让我们看看我们如何检查我们系统中的所有数据库。
Python MySQL -列出所有数据库
我们可以使用 Python 列出 MySQL 中的所有数据库，在这个列表中，我们还可以检查任何特定的数据库是否可用。
检查是否已经存在任何数据库SHOW DATABASES使用 SQL 语句。
让我们看看如何:
列出系统中所有的数据库。下面是相同的代码片段:
#for our convenience we will import mysql.connector as mysql
import mysql.connector as mysql
db = mysql.connect(
host = "localhost",
user = "yourusername",
passwd = "yourpassword"
)
cursor = db.cursor()
cursor.execute("SHOW DATABASES")
for x in cursor:
print(x)
上述代码的输出将列出系统中的所有数据库:
(' admin_panel '，)(' information_schema '，)(' mysql '，)(' performance_schema '，)(' sakila '，)(' study now '，)(' sys '，)(' world '，)(' xyz '，)
从上面的代码中可以看到，我们使用了 Python for loop 来迭代游标对象，并打印所有找到的数据库的名称。同样，在使用 Python if condition 创建数据库之前，我们可以比较数据库的名称来检查是否已经存在任何特定的数据库。
因此，在本教程中，我们学习了如何使用 Python 在 MySQL 中创建一个新数据库，以及如何用 Python 列出所有 MySQL 数据库并在控制台中打印它们。
Python MySQL——创建和列出表
原文：https://www.studytonight.com/python/python-mysql-create-table
现在我们将学习如何在 Python 中的任何 MySQL 数据库中创建表，我们还将看到如何通过使用 Python 列出数据库中的所有表来检查表是否已经存在。
Python MySQL -创建表
基本上，为了在 MySQL 数据库中存储信息，需要创建表。也需要首先选择我们的数据库，然后在该数据库中创建表格。
在创建连接时，您还可以指定数据库的名称，如下所示:
import mysql.connector
db = mysql.connector.connect(
host = "localhost",
user = "yourusername",
password = "yourpassword",
database = "studytonight"
)
如果上面的代码是执行没有任何错误，那么这意味着你已经成功连接到名为的数据库 StudyTonight。
创建表的 SQL 查询
要在选定的数据库中创建表，将使用以下语句。让我们看看语法:
CREATE TABLE table_name;
让我们在指定的数据库中创建一个名为学生的表，即StudyTonight
在学生表中，我们将有以下字段:姓名、罗诺、分支、地址。
#for our convenience we will import mysql.connector as mysql
import mysql.connector as mysql
db = mysql.connect(
host = "localhost",
user = "yourusername",
passwd = "yourpassword",
database="studytonight"
)
cursor = db.cursor()
cursor.execute("CREATE TABLE students (name VARCHAR(255), rollno INTEGER(100), branch VARCHAR(255), address VARCHAR(255))")
如果该代码执行没有任何错误，则表示该表已经成功创建。
现在，如果您想检查数据库中现有的表，那么您可以使用SHOW TABLES SQL 语句。
列出数据库中的现有表
现在我们已经在数据库中创建了一个表。让我们检查一下数据库中存在的表。使用下面给出的代码:
#for our convenience we will import mysql.connector as mysql
import mysql.connector as mysql
db = mysql.connect(
host = "localhost",
user = "yourusername",
passwd = "yourpassword",
database="studytonight"
)
cursor = db.cursor()
## getting all the tables which are present in 'datacamp' database
cursor.execute("SHOW TABLES")
tables = cursor.fetchall() ## it returns list of tables present in the database
## showing all the tables one by one
for table in tables:
print(table)
上述代码的输出如下
('学生'，)
Python MySQL -带主键的表
因为我们已经在数据库中创建了一个名为学生的表，我们将在其中存储学生数据，并在需要时获取数据。但是在获取数据时，我们可能会找到同名的学生，这可能会导致获取错误的数据，或者造成一些混乱。
因此，为了唯一识别表中的每个记录，我们可以在表中使用 【主键】 。让我们先看看什么是主键？
什么是主键？
主键是使一列或一组列只接受唯一值的属性。借助主键，可以在表中唯一地找到每一行。
观看此视频，了解数据库管理系统键- 用示例解释的数据库管理系统键
因此，为了用从 1 开始的数字唯一地识别每个行。我们将使用如下语法:
INT AUTO_INCREMENT PRIMARY KEY
对任何列使用上述代码，我们可以使其值自动递增，这意味着即使在向表中插入新的数据行时没有为该列插入任何值，数据库也会自动添加一个递增的值。
在创建表期间添加主键
让我们看看如何在创建表时添加主键。其代码片段如下所示:
import mysql.connector as mysql
db = mysql.connect(
host = "localhost",
user = "yourusername",
passwd = "yourpassword",
database = "studytonight"
)
cursor = db.cursor()
## creating the 'students' table with the 'PRIMARY KEY'
cursor.execute("CREATE TABLE students (name VARCHAR(255), rollno INTEGER(100) NOT NULL AUTO_INCREMENT PRIMARY KEY, branch VARCHAR(255), address VARCHAR(255))")
如果上面的代码运行没有错误，那么这意味着您已经成功地创建了一个名为“学生”的表，列 rollno 作为主键。
Python MySQL -描述表格
我们可以使用下面的 python 代码来描述任何一个表，看看它有哪些列，以及关于该表及其所有列的所有元信息。
import mysql.connector as mysql
db = mysql.connect(
host = "localhost",
user = "yourusername",
passwd = "yourpassword",
database = "studytonight"
)
cursor = db.cursor()
cursor.execute("DESC students")
print(cursor.fetchall())
输出将是:
[('name '，' varchar(255)'，' YES '，''，None '')，(' rollno '，' int '，' no '，' PRI '，None，' auto_increment ')，(' branch '，' varchar(255)'，' YES '，''，None ' '，')，(' address '，' varchar(255)'，' YES '，' '，None ' ')]
向现有表添加主键
现在在这个例子中，我们假设学生表中不存在rollino列。所以我们将学习如何在现有的表中添加一列作为作为主键。
让我们看看如何在现有表上创建主键。其代码片段如下所示:
import mysql.connector as mysql
db = mysql.connect(
host = "localhost",
user = "root",
passwd = "himaniroot@99",
database = "studytonight"
)
cursor = db.cursor()
## We are going to add rollno field with primary key in table students
cursor.execute("ALTER TABLE students ADD COLUMN rollno INT AUTO_INCREMENT PRIMARY KEY")
print(cursor.fetchall())
在上面的代码中，我们使用了 SQL Alter Query 向现有的表中添加一个新的列。您可以使用 description table 查询来查看新添加的列。
[('name '，' varchar(255)'，' YES '，''，None '')，(' branch '，' varchar(255)'，' YES '，''，None ' '，'(' address '，' varchar(255)'，' YES '，' '，None ' '，')，(' rollno '，' int '，' no '，' PRI '，None，' auto_increment')]
因此，在本教程中，我们已经介绍了与用 python 创建新的 MySQL 表相关的所有内容。我们介绍了如何更改表，如何列出数据库中的所有表，以及如何将列定义为主键。
Python MySQL——在表中插入数据
原文：https://www.studytonight.com/python/python-mysql-insert-data-in-table
在本教程中，我们将学习如何使用 Python 在 MySQL 表中插入单行和多行。
**要将数据插入到 MySQL 表中或者将数据添加到我们在之前的教程中创建的 MySQL 表中，我们将使用INSERT SQL 语句。
如果你是 SQL 新手，你应该先了解一下 SQL INSERT 语句。
Python MySQL - INSERT数据
让我们看看基本语法使用INSERT INTO语句将数据插入到我们的表中:
INSERT INTO table_name (column_names) VALUES(data)
我们可以通过两种方式在表中插入数据:
-
一次插入一个单排
-
一次插入多行
在 MySQL 表中插入单行
在本节中，我们将看到在 MySQL 表中插入单行数据的代码示例:
我们将向我们在 Python MySQL - Create Table 教程中创建的学生表添加数据。
import mysql.connector as mysql
db = mysql.connect(
host = "localhost",
user = "root",
passwd = "himaniroot@99",
database = "studytonight"
)
cursor = db.cursor()
## defining the Query
query ="INSERT INTO students(name, branch, address) VALUES (%s, %s,%s)"
## There is no need to insert the value of rollno
## because in our table rollno is autoincremented #started from 1
## storing values in a variable
values = ("Sherlock", "CSE", "220 Baker Street, London")
## executing the query with values
cursor.execute(query, values)
## to make final output we have to run
## the 'commit()' method of the database object
db.commit()
print(cursor.rowcount, "record inserted")
上述代码的输出将是:
插入了 1 条记录
在 MySQL 表中插入多行
在本节中，我们将看到在 MySQL 表中插入多行数据的代码示例。
要在表格中插入多行，使用executemany()方法。它以包含数据的元组 的列表作为第二个参数，以查询作为第一个参数。
import mysql.connector as mysql
db = mysql.connect(
host = "localhost",
user = "root",
passwd = "himaniroot@99",
database = "studytonight"
)
cursor = db.cursor()
## defining the Query
query ="INSERT INTO students(Name, Branch,Address) VALUES (%s, %s, %s)"
## storing values in a variable
values = [
("Peter", "ME","Noida"),
("Amy", "CE","New Delhi"),
("Michael", "CSE","London")
]
## executing the query with values
cursor.executemany(query, values)
## to make final output we have to run
## the 'commit()' method of the database object
db.commit()
print(cursor.rowcount, "records inserted")
如果这三行都输入成功，上述代码的输出将是:
插入了 3 条记录
因此，在本教程中，我们学习了如何在 Python 中将数据插入到 MySQL 表中。
Python MySQL——从表中选择数据
原文：https://www.studytonight.com/python/python-mysql-select-data-from-table
在本教程中，我们将学习如何从 python 中的 MySQL 表中检索数据，既有完整的表数据，也有一些特定列的数据。
Python MySQL -选择数据
在 MySQL 中，为了从表中检索数据，我们将使用SELECT语句。其语法如下:
SELECT column_names FROM table_name
从 MySQL 表中检索所有记录
为了从表中获取所有记录，使用*代替列名。让我们从之前插入的学生表中检索所有数据:
import mysql.connector as mysql
db = mysql.connect(
host = "localhost",
user = "yourusername",
passwd = "yourpassword",
database = "studytonight"
)
cursor = db.cursor()
## defining the Query
query = "SELECT * FROM students"
## getting records from the table
cursor.execute(query)
## fetching all records from the 'cursor' object
records = cursor.fetchall()
## Showing the data
for record in records:
print(record)
因此，上述代码的输出将是:
(‘Ramesh’、‘CSE’、‘149 individuals’、‘1’、‘Peter’、‘me’、‘noida’、‘2’、‘Amy’、‘ce’、‘新德里’、‘3’、‘Michael’、‘CSE’、‘London’、‘4’
下面是我们运行 python 代码时的确切输出快照:
在下一节中，我们将学习如何从表中检索特定列的数据。
从表的特定列中检索数据
为了从表的某些列中选择数据，只需在上面提到的语法中的 SELECT 后面提到列名:
import mysql.connector as mysql
db = mysql.connect(
host = "localhost",
user = "yourusername",
passwd = "yourpassword",
database = "studytonight"
)
cursor = db.cursor()
## defining the Query
query = "SELECT name FROM students"
## getting 'name' column from the table
cursor.execute(query)
## fetching all usernames from the 'cursor' object
names = cursor.fetchall()
## Showing the data
for name in names:
print(name)
以上代码将从学生表中获取名称列:
(' Ramesh '，)(' Peter '，)(' Amy '，)(' Michael '，)
从表中选择多列
您也可以通过在上面的语法中提供多个列名来一次从表中选择多个列。让我们看看下面给出的代码片段，以便清楚地理解:
import mysql.connector as mysql
db = mysql.connect(
host = "localhost",
user = "yourusername",
passwd = "yourpassword",
database = "studytonight"
)
cursor = db.cursor()
## defining the Query
query = "SELECT name, branch FROM students"
## getting 'name', 'branch' columns from the table
cursor.execute(query)
## fetching all records from the 'cursor' object
data = cursor.fetchall()
## Showing the data
for pair in data:
print(pair)
以上代码将从表学生中获取名称和分支列:
(' RaMEsh '，' CSE '，' Peter '，' me '，' Amy '，' CE '，' Michael '，' CSE ')
获取第一条记录- fetchone()
在上面的例子中，我们看到所有的行都被获取了，因为我们使用的是fetchall()方法。现在只取一行fetchone()的方法。此方法将返回查询提取的记录的第一行。让我们看看下面给出的代码片段:
import mysql.connector as mysql
db = mysql.connect(
host = "localhost",
user = "yourusername",
passwd = "yourpassword",
database = "studytonight"
)
cursor = db.cursor()
cursor.execute("SELECT * FROM students")
myresult = cursor.fetchone() ##fetches first row of the record
print(myresult)
因此，在输出中，将获取记录的第一行:
(' Ramesh '，' CSE '，' 149 individuals '，1)
因此，在本教程中，我们学习了用 Python 从 MySQL 表中检索数据的各种方法。
Python MySQL——更新表数据
原文：https://www.studytonight.com/python/python-mysql-update-data-in-table
在本教程中，我们将学习如何在 Python 中更新 MySQL 表数据，在这里我们将使用 UPDATE SQL 查询和 WHERE子句。
UPDATE SQL 查询是用来更新 MySQL 表中的任何记录。
Python MySQL UPDATE:语法
下面是 UPDATE 语句的基本语法:
UPDATE table_name SET column_name = new_value WHERE condition
以上语法用于更新 MySQL 表中任何特定行。为了指定我们要更新哪一行数据，我们使用WHERE子句来提供要匹配的条件，同时寻找要更新的正确数据行。
Python MySQL UPDATE表数据:示例
让我们通过更改学生的姓名来更新学生表中的记录(来自 Python MySQL 创建表教程)，该学生的 rollno 是 3 。代码如下:
import mysql.connector as mysql
db = mysql.connect(
host = "localhost",
user = "yourusername",
passwd = "yourpassword",
database = "studytonight"
)
cursor = db.cursor()
## defining the Query
query = "UPDATE students SET name = 'Navin' WHERE rollno = 3"
## executing the query
cursor.execute(query)
## final step is to commit to indicate the database
## that we have changed the table data
db.commit()
为了检查数据是否成功更新，我们可以使用下面给出的代码检索学生表数据:
import mysql.connector as mysql
db = mysql.connect(
host = "localhost",
user = "yourusername",
passwd = "yourpassword",
database = "studytonight"
)
cursor = db.cursor()
## defining the Query
query = "SELECT * FROM students"
## getting records from the table
cursor.execute(query)
## fetching all records from the 'cursor' object
records = cursor.fetchall()
## Showing the data
for record in records:
print(record)
上面代码的输出是:
(' RaMEsh '，' CSE '，' 149 individuals '，1) ('Peter '，' me '，' Noida '，2) ('Navin '，' CE '，'新德里'，3)
以下是实际输出的快照:
在SELECT查询中，我们也可以使用WHERE子句只检索带有rollino3 或任何其他条件的行的数据。
Python MySQL——删除表数据
原文：https://www.studytonight.com/python/python-mysql-delete-data-from-table
在本教程中，我们将学习如何在 Python 中删除 MySQL 表数据，在这里我们将使用 DELETE SQL 查询和 WHERE子句。
DELETE SQL 查询是用来从 MySQL 表中删除任何记录。
Python MySQL DELETE:语法
其语法如下:
DELETE FROM table_name WHERE condition
注意:在上面的语法中，WHERE子句用于指定条件，以锁定要删除的特定记录。如果不指定条件，那么表中的所有记录都将被删除。
Python MySQL DELETE表数据:示例
我们来看一个删除学生表中的记录的例子(来自 Python MySQL 创建表教程)，其rollino为 4 。代码如下:
import mysql.connector as mysql
db = mysql.connect(
host = "localhost",
user = "yoursername",
passwd = "yourpassword",
database = "studytonight"
)
cursor = db.cursor()
## defining the Query
query = "DELETE FROM students WHERE Rollno = 4"
## executing the query
cursor.execute(query)
## final step to tell the database that we have changed the table data
db.commit()
如果上面的代码运行没有错误，那么这意味着带有 rollno = 4 的行被成功删除。
要检查它是否存在于表中，您可以使用下面给出的代码:
import mysql.connector as mysql
db = mysql.connect(
host = "localhost",
user = "yourusername",
passwd = "yourpassword",
database = "studytonight"
)
cursor = db.cursor()
## defining the Query
query = "SELECT * FROM students"
## getting records from the table
cursor.execute(query)
## fetching all records from the 'cursor' object
records = cursor.fetchall()
## Showing the data
for record in records:
print(record)
上述代码的输出如下所示:
(' RaMEsh '，' CSE '，' 149 individuals '，1) ('Peter '，' me '，' night '，' 2) ('Amy '，' CE '，'新德里'，' 3)
以下是实际输出的快照:
从上面的输出中我们可以看到 rollno=4 的行被成功删除。
Python MySQL——删除表
原文：https://www.studytonight.com/python/python-mysql-drop-table
在本教程中，我们将学习如何使用 Python 从数据库中删除 MySQL 表或完全删除该表。
要完全删除一个现有的表(包括表数据和表本身)，使用DROP TABLE SQL 语句。
Python MySQL DROP TABLE:示例
假设今晚在研究数据库中有一个名为客户的表。然后我们可以使用下面的代码删除该表:
import mysql.connector as mysql
db = mysql.connect(
host = "localhost",
user = "yourusername",
passwd = "yourpassword",
database = "studytonight"
)
cursor = db.cursor()
## We have created another table in our database named customers
## and now we are deleting it
sql = "DROP TABLE customers"
cursor.execute(sql)
如果上述代码执行无误，则表示名为客户的表被成功删除。
Python MySQL -删除表(如果存在)
IF EXISTS关键字用于避免在试图删除不存在的表时可能出现的错误。
当我们使用IF EXISTS子句时，我们正在通知 SQL 引擎，如果给定的表名存在，那么删除它，如果它不存在，那么什么也不做。
import mysql.connector as mysql
db = mysql.connect(
host = "localhost",
user = "yourusername",
passwd = "yourpassword",
database = "studytonight"
)
cursor = db.cursor()
sql = "DROP TABLE IF EXISTS customers"
cursor.execute(sql)
如果代码执行时没有出现错误，则意味着如果 customers 表存在，它将被删除。
以下是实际输出的快照:
因此，在本教程中，我们学习了如何使用 Python 删除 MySQL 表。当我们有一些应用创建一些临时表来存储一些数据，然后在处理之后删除这些表时，这很有用。
Python MySQL——WHERE子句
原文：https://www.studytonight.com/python/python-mysql-where-clause
在本教程中，我们将学习如何使用WHERE子句从提取的结果集中筛选行，或者更新特定行，或者从 MySQL 表中删除特定行，以指定查找执行操作的数据记录/行的条件。
所以，WHERE子句只不过是向 SQL 引擎提供一个条件(或多个条件)的一种方式，它应用于查询结果集，以过滤出所需的数据记录。
Python MySQL WHERE子句
我们已经在之前的教程中使用了WHERE子句:
如果你想根据某个条件从表中选择数据，那么你可以在SELECT语句中使用WHERE子句。
-
WHERE子句主要用于从结果集中过滤行。 -
从 MySQL 表中获取、更新和删除数据对很有帮助。****
**在SELECT语句中使用WHERE子句的语法如下:
SELECT column_name
FROM table_name
WHERE condition;
上述语法在根据某些条件提取记录时非常有用。
使用WHERE子句
下面我们有一个例子，我们将从我们的学生表(来自 Python MySQL 创建表教程)中获取具有 rollno = 2 的行:
import mysql.connector as mysql
###First create a connection between mysql and python
db = mysql.connect(
host = "localhost",
user = "yourusername",
passwd = "yourpassword",
database = "studytonight"
)
# now create a cursor object on the connection object
# created above by using cursor() method
cursor = db.cursor()
## defining the Query
query = "SELECT * FROM students WHERE rollno= 2"
## getting records from the table
cursor.execute(query)
## fetching all records from the 'cursor' object
records = cursor.fetchall()
## Showing the data
for record in records:
print(record)
上述代码的输出将是:
('彼得'，'我'，'新娘'，' 2)
以下是实际输出的快照:
Python MySQL——ORDER BY子句
原文：https://www.studytonight.com/python/python-mysql-orderby-clause
在本教程中，我们将学习如何在 MySQL 中以任意顺序(升序或降序)对结果进行排序。
MySQL 中的ORDER BY主要用于的排序目的。也就是说，在ORDER BY的帮助下，可以按照上升或下降的顺序对结果进行排序。
-
默认情况下
ORDER BY语句会按照升序对结果进行排序，或者我们也可以使用ASC关键字。 -
为了按照降序对结果进行排序，将使用
DESC关键字。
下面我们有一个基本语法以升序对结果进行排序，这是默认的:
SELECT column_names FROM table_name ORDER BY column_name
Python MySQL ORDER BY示例
下面我们有一个例子，我们将按照升序对结果进行排序。让我们看看下面给出的代码片段:
import mysql.connector as mysql
db = mysql.connect(
host = "localhost",
user = "yourusername",
passwd = "yourpassword",
database = "studytonight"
)
cursor = db.cursor()
## defining the Query
query = "SELECT * FROM students ORDER BY name"
## getting records from the table
cursor.execute(query)
## fetching all records from the 'cursor' object
records = cursor.fetchall()
## Showing the data
for record in records:
print(record)
上面的代码将以升序对名称进行排序，输出如下:
(《艾米》、《欧共体》、《新德里》，3)(《迈克尔》、《CSE》、《伦敦》，4)(《彼得》、《我》、《新娘》，2)(《拉麦什》、《CSE》、《149 印第安人》，1)
以下是实际输出的快照:
Python MySQL〔t0〕
语法ORDER BY COLUMN_NAME DESC语句用于根据指定的列按降序对结果集进行排序。
下面给出了使用该语句的语法:
SELECT column_names FROM table_name ORDER BY column_name DESC
现在让我们使用带有ORDER BY子句的DESC关键字，按照名称列，按降序对数据进行排序。让我们看看下面给出的代码:
import mysql.connector as mysql
db = mysql.connect(
host = "localhost",
user = "yourusername",
passwd = "yourpassword",
database = "studytonight"
)
cursor = db.cursor()
## defining the Query
query = "SELECT * FROM students ORDER BY name Desc"
## getting records from the table
cursor.execute(query)
## fetching all records from the 'cursor' object
records = cursor.fetchall()
## Showing the data
for record in records:
print(record)
上述代码的输出将是:
(‘Ramesh’、‘CSE’、‘149 individuals’、‘1’、‘Peter’、‘me’、‘noida’、‘2’、‘Michael’、‘CSE’、‘London’、‘4’、‘Amy’、‘ce’、‘新德里’、‘3’
以下是实际输出的快照:
Python MySQL——LIMIT子句
原文：https://www.studytonight.com/python/python-mysql-limit-clause
在本教程中，我们将学习如何借助 python 代码中添加到查询中的LIMIT子句来限制结果集中返回的行数。
下面给出了使用该子句的语法:
SELECT {fieldname(s) | *} FROM tableName(s) [WHERE condition] LIMIT N;
上述语法表明了以下情况:
-
选择{ field name | * } FROM tableName:此部分用于选择我们希望在查询中返回的记录。
-
【WHERE 条件】:WHERE 子句是可选的，但是如果使用了，它会对结果集应用过滤器。
-
LIMIT N :用于限制结果中的记录。这里 N 从 0 开始，但是如果你将通过极限 0(那么它不返回任何记录)。如果您将通过 6 ，那么它将返回输出中的开始 6 行。假设指定表中的记录小于 N，那么表中的所有记录都将返回到结果集中。
Python MySQL LIMIT:示例
让我们仅从学生表中选择两行(来自 Python MySQL 创建表教程)。其代码如下:
import mysql.connector as mysql
db = mysql.connect(
host = "localhost",
user = "yourusername",
passwd = "yourpassword",
database = "studytonight"
)
cursor = db.cursor()
cursor.execute("SELECT * FROM students LIMIT 2")
myresult = cursor.fetchall()
for x in myresult:
print(x)
上述代码的输出如下:
(' RaMEsh '，' CSE '，' 149 individuals '，1) ('Peter '，' me '，' noida '，' 2)
使用带LIMIT子句的OFFSET关键字
如果您不想从第一个位置开始，那么通过在LIMIT查询中使用OFFSET关键字，您可以从任何其他位置开始。让我们看看相同的代码示例:
import mysql.connector as mysql
db = mysql.connect(
host = "localhost",
user = "yourusername",
passwd = "yourpassword",
database = "studytonight"
)
cursor = db.cursor()
cursor.execute("SELECT * FROM students LIMIT 2 OFFSET 1")
myresult = cursor.fetchall()
for x in myresult:
print(x)
在上面的代码中 LIMIT 2 表示它将返回 2 行， OFFSET 1 结果集将从第 1 行开始，表示只返回第 2 行。因此，输出如下:
(彼得，我，新娘，2)(《纳文》，《欧共体》，《新德里》，3)
以下是实际输出的快照:
OFFSET关键字用于指定起点。例如，如果一个查询返回了 100 行数据，并且我们将OFFSET指定为 50，那么将返回从第 51 行开始直到第 100 行的数据。
Python MySQL——连接表
原文：https://www.studytonight.com/python/python-mysql-table-join
在本教程中，我们将学习如何在 Python 中连接两个或多个 MySQL 表。
为了将 MySQL 中的两个或多个表组合起来，使用了JOIN语句。这里需要注意的一点是，在两个表中必须有一个公共列，该操作将基于该列执行。
我们已经在【今晚 T2】学习数据库中创建了学生表(来自 Python MySQL 创建表教程)。让我们创建另一个名为结果的表，之后我们将加入这两个表。
下面我们有代码来创建一个名为 results 的表。成绩和学生表都有一个共同的字段，那就是罗诺。
Yuo 可以直接运行查询，在 MySQL 命令行中创建新表。
Python MySQL -连接两个表
下面我们有一个代码片段，其中我们将基于列rollino连接两个名为结果和学生的表:
import mysql.connector as mysql
db = mysql.connect(
host = "localhost",
user = "yourusername",
passwd = "yourpassword",
database = "studytonight"
)
cursor = db.cursor()
sql = "SELECT students.rollno, students.name,students.Branch,students.Address, results.status from students INNER JOIN results ON students.rollno=results.rollno;"
cursor.execute(sql)
myresult = cursor.fetchall()
for x in myresult:
print(x)
上述代码的输出将是:
(1，“Ramesh”，“CSE”，“149 Indirapuram”，“Pass”)(2，“Peter”，“ME”，“Noida”，“Fail”)(3，“Navin”，“CE”，“New Delhi”，“Pass”)
上面的输出表明两个表都是连接的。
以下是实际输出的快照:
Python MySQL -左连接
需要注意的是INNER JOIN(我们在上面的例子中讨论过)只在匹配时显示结果集中的行。
如果您想从左侧表中获取所有记录，即使没有匹配，也将使用Left Join。
让我们看看下面给出的左连接示例:
import mysql.connector as mysql
db = mysql.connect(
host = "localhost",
user = "yourusername",
passwd = "yourpassword",
database = "studytonight"
)
cursor = db.cursor()
sql = "SELECT students.rollno, students.name,students.Branch,students.Address, results.status from students LEFT JOIN results ON students.rollno=results.rollno;"
cursor.execute(sql)
myresult = cursor.fetchall()
for x in myresult:
print(x)
上述代码的输出如下。让我们看看:
(1，“Ramesh”，“CSE”，“149 Indirapuram”，“Pass”)(2，“Peter”，“ME”，“Noida”，“Fail”)(3，“Navin”，“CE”，“New Delhi”，“Pass”)(5，“suraj”，“ECE”，“Panipat”，None) (6，“Mukesh”，“CSE”，“Samalkha”，None)
在上面的输出中，5 号和 6 号辊的状态为“无”，因为它们的结果是结果表中没有提到的。但是由于我们已经应用了LEFT JOIN，所以即使没有匹配，查询也会选择左表中的所有行。
以下是实际输出的快照:
Python MySQL -右连接
如果你想从右侧表格中获取所有记录，即使没有匹配也会使用Right Join。
让我们看看下面给出的Right Join的例子。下面给出的代码将从右侧表中获取所有行。它不会返回那些带有5 号和 6 号滚轮的行:
import mysql.connector as mysql
db = mysql.connect(
host = "localhost",
user = "yourusername",
passwd = "yourpassword",
database = "studytonight"
)
cursor = db.cursor()
sql = "SELECT students.rollno, students.name,students.Branch,students.Address, results.status from students RIGHT JOIN results ON students.rollno=results.rollno;"
cursor.execute(sql)
myresult = cursor.fetchall()
for x in myresult:
print(x)
上述代码的输出如下:
(1，“Ramesh”，“CSE”，“149 Indirapuram”，“Pass”)(2，“Peter”，“ME”，“Noida”，“Fail”)(3，“Navin”，“CE”，“New Delhi”，“Pass”)
以下是实际输出的快照:
至此，我们已经介绍了 Python MySQL 的所有基础知识。如果您必须开发一个应用，其中您希望有一个多表的数据库，您希望在其中存储数据并从表中检索数据，那么我们希望这些教程对您有所帮助。
杂项
Python __name__变量
原文：https://www.studytonight.com/python/_name_-as-main-method-in-python
Python __name__是一个特殊的变量，其中存储了当前正在执行的 Python 脚本/模块的名称。
Python __name__变量是 Python 2.x 版本中没有的，是在 Python 3.0 版本中引入的。
在 python 中，当前 python 脚本或模块执行时，__name__变量被赋予值 main 。
什么是__name__？
__name__是 python 中的内置变量，存储当前正在执行的模块/脚本的名称。如果当前模块正在执行，则__name__变量被赋予值 main ，否则它只包含模块或脚本的名称。
因此，当 python 脚本正在执行时，其__name__变量将始终具有值 main ，如果该 python 文件被导入到任何其他 python 脚本中，则__name__变量将具有模块的名称。
我们举个例子来了解一下。创建一个名为 test.py 的 python 脚本，并在其中添加以下代码:
# defining a function
def something():
print('Value of __name__:', __name__)
something()
name 的值:main
当我们执行 test.py 脚本时，__name__变量的值被设置为 main 。
现在，让我们创建另一个 python 脚本 main.py ，然后在其中导入上面的脚本。
# importing test.py
import test
test.something()
name 的值:测试
在上面的代码输出中可以看到，__name__变量的值是 test ，因为我们打印了 test.py 模块的__name__变量的值。
使用if __name__ == __main__
要在任何 python 脚本中指定一些只有在直接执行脚本时才应该执行的代码，我们可以使用带有条件__name__ == __main__的if语句
例如，
# importing test.py
import test
if __name__ == __main__:
test.something()
这里 main 只是一个字符串，用于检查当前模块/脚本是否独立运行。在__name__变量中，名称两侧的双下划线用于指示 python 解释器将其识别为特殊/保留关键字。
Python __name__:代码示例
如上所述，当我们执行一个代码文件时，对于该代码片段，__name__变量的值变为 main ，因为代码是直接执行的，而没有被导入到任何其他文件中。
例如:这里有一个代码文件 Script1.py ，
# defining a function
def something():
print('This function is in Script1.')
if __name__=='__main__':
something()
print('Called from Script1.')
else:
print('Script1 is imported in some other file.')
当我们运行 python Script1.py 时，那么:
这个函数在 Script1 中。从脚本 1 调用。
现在，让我们创建另一个名为 Script2.py 的 python 脚本文件，并将脚本 Script1.py 导入其中，并尝试调用脚本 Script1 中定义的函数something()。
以下是脚本 2.py 的代码:
import Script1
if __name__=='__main__':
Script1.something()
print('Called from Script2.')
现在我们运行 python 脚本 2.py 然后:
Script1 被导入到其他文件中。这个函数在 Script1 中。从脚本 2 调用。
当import语句在脚本 2 中为脚本 1 执行时，在此期间__name__变量的值为脚本 1 (模块名称)，但由于执行是从脚本脚本 2 开始的，因此其__name__变量的值为 main 。
__name__:打印它的价值
为了更好地理解，让我们在每个执行步骤打印__name__变量的值。
下面是 python 脚本 Script1.py 的代码:
print('Value or __name__ variable: ' + __name__)
就这样，我们不会在脚本中包含任何其他内容。这是脚本的代码:
# import file Script1.py
import Script1
print('Value or __name__ variable: ' + __name__)
这里有一个活生生的例子:
注意:在实时示例中，脚本是 main.py 和 Script1.py ，脚本名称的更改不会影响功能。
大多数编程语言使用主方法或函数作为任何程序的执行起点。但是 Python 呢？一般来说，python 程序(脚本)的执行从第一行开始，该行位于该程序的缩进级别 0 处。然而，当一个 python 程序被执行时，在其执行之前会创建一个__name__变量。这个变量可以作为 python 中主方法的替代。
Python 中的可迭代对象和迭代器
原文：https://www.studytonight.com/python/python-iterable-and-iterator
在 python 或任何其他编程语言中，迭代意味着通常使用循环一个接一个地访问某个东西的每个项目。例如，如果我们有一个汽车名称列表，并且我们想要一个接一个地打印所有名称，我们可以使用 for循环来完成，如下所示:
# list of cars
cars = ['Audi', 'BMW', 'Jaguar', 'Kia', 'MG', 'Skoda']
for car in cars:
print("Name of car: ", car)
车名:奥迪车名:宝马车名:捷豹车名:起亚车名:MG 车名:斯柯达
我们在上面的代码中所做的是迭代，涉及到逐个访问列表中的所有项目。
什么是 Iterable？
在 python 编程中，可迭代对象是任何可以循环或迭代的东西。比如列表、 元组 、 字典 等。都是可重复的。简单地说，任何可以出现在 for 循环右侧的东西都是可迭代的。
iterable 的一个重要属性是它有一个__iter__()方法或iter()方法，允许任何 iterable 返回迭代器对象。
iter()方法在内部调用__iter__()方法并返回迭代器对象。
什么是迭代器？
迭代器是一个可以循环的对象，它在迭代过程中保持其状态，这意味着它在迭代过程中记住它在哪里。
它有一个__next__()方法，在迭代中返回下一个值，并将状态更新为指向下一个值。
迭代器还有返回self对象的 __iter__()方法。
从 Iterable 获取迭代器对象
我们可以通过向iter()方法传递预定义或预创建的可迭代对象，或者在该可迭代对象上使用__iter__()方法，轻松获得迭代器对象。
例如:
在上例中，我们使用了iter()方法，我们也可以尝试使用__iter__()方法，如下所示:
# we can use __iter__() method too
cars_iter_new = cars.__iter__()
# print the data
print(cars_iter_new.__next__())
如上例所示，next()或__next__()方法递增相应迭代器的状态，并返回前一个值旁边的值。
另外，您一定注意到了输出中的一个异常。excition 是StopIteration异常，当迭代器中没有剩余值要迭代时，即列表结束后，我们仍然尝试调用next()或__next()方法时，就会出现该异常。
for Loop 内部就是这样工作的吗？
嗯是的！python 没有陷入获取迭代器对象然后一次又一次调用下一个函数的所有麻烦，而是为我们提供了像for循环这样的循环，它在内部执行上述所有步骤。
所以当我们使用像这样的for循环时:
# list of cars
cars = ['Audi', 'BMW', 'Jaguar', 'Kia', 'MG', 'Skoda']
for car in cars:
print("Name of car: ", car)
在内部，for循环这样做:
# iterator object is created
iter_obj = iter(cars)
while True:
try:
element = next(iter_obj)
# perform some operation like print the value
except StopIteration:
# break out of loop when the list ends
break
forpython 中的循环是为了轻松迭代 iterables 而创建的，现在我们知道了它是如何使用 ITER 对象在内部工作的。
通过创建自定义迭代器使类可迭代
现在让我们学习如何制作自己的迭代器。制作自己的迭代器超级容易，我们要做的就是实现方法__iter__()和__next()。
__iter__()方法将返回迭代器的一个对象，在我们的例子中，它将是类本身的对象。
并且__next__()方法应该在每次被调用时返回下一个元素，并且应该在到达结束时引发StopIteration异常。
下面我们有一个简单的类Counting，它将打印从 1 开始的计数，直到初始化类时您提供的数字。
您也可以尝试在Counting类的对象上调用iter()方法，然后在迭代器上使用next()方法逐个打印值。
Python 中的yield关键字
当我们编写一个应该执行一些操作并返回一些结果的函数时，我们通常使用return语句来返回结果。
python 中的yield关键字也用于从函数中返回值(就像return一样)，但是这个关键字也维护函数局部变量的状态，当再次调用函数时，从上次执行的yield语句开始执行。
让我们看一个简单的例子，试着理解yield关键词实际上是做什么的:
def counter():
x = 0
while x < 5:
yield x
# incrementing the value of x
x += 1
在上面的代码中，我们定义了一个简单的函数，它有一个while循环，产生x的当前值，然后递增。
首先，当我们在函数中使用yield语句时，该函数被称为 生成器 ，我们将在下一个教程中学习。
生成器生成或产生值，不能像简单函数一样调用，而是像可迭代函数一样调用，即使用循环，例如for循环。
让我们看看这两种情况，
# calling the above function directly
print("Simple function call: ", counter()) # should print 0
# and now lets use a loop to print values
print("Now lets try using a loop:")
for y in counter():
print(y)
简单的函数调用:
关于yield关键词需要记住的几点
把yield关键词想象成一个聪明的return语句，它会记住上一次做了什么，并在下一次继续。
就像上面的counter()函数，我们第一次调用的时候，它会返回 0 ，但是我们下一次调用的时候，它会递增x的值，然后返回 1 ，然后我们再调用一次，它会再次递增x的值，并重新运行结果 2 等等，直到循环完成。
- 当我们使用
yield关键字从一个函数返回数据时，它开始存储局部变量的状态，结果节省了连续调用中变量的内存分配开销。 - 此外，在连续调用中，流程从执行的最后一个
yield语句开始，这节省了时间。 - 我们可以使用
yield关键字轻松创建可迭代函数。
该举些例子了！
如上所述，通过使用yield关键字，我们使我们的函数可迭代。我们知道，对于可迭代的，我们可以使用next()方法迭代到下一个元素。让我们在第一个例子中实现它。
例 1:
在上面的例子中，我们使用了多个yield语句来保存函数(或生成器)new_gen()的执行状态，以便下次调用该函数时，执行从上次离开的地方开始。
尝试在上面的代码中再添加一条print(next(x))语句，您将看到StopIteration异常，当没有更多数据需要迭代时，迭代器会返回该异常。
例 2:
在这个代码示例中，我们将在函数中使用yield关键字来计算一个单词在句子中的出现次数。
在上述问题中使用yield关键字将帮助我们简化在单词列表中搜索单词的代码，同时增加计数，因为yield关键字将记住最后的状态，因此它不会迭代已经检查过的单词。
同样的yield关键字也有很多用例。在下一个教程中，我们将学习生成器，这是我们使用yield关键字的函数。在上面的代码示例中，count_words是一个生成器。
Python 中的生成器
在开始本教程之前，您应该学习什么是 yield 关键字和什么是 iterable&迭代器，因为这些概念将在这里使用。
一个生成器只不过是一个使用yield关键字而不使用return语句返回值的函数。
如果我们必须编写一个自定义迭代器，你将必须实现__iter__()和__next__()方法，定义通过保持状态返回下一个值的机制，并且当没有更多的值可以迭代时引发StopIteration异常。
好吧，生成器让创建一个状态保持的迭代器变得超级容易，你所要做的就是使用yield关键字返回数据。
任何包含yield关键字的函数都将成为一个生成器，并将返回一个迭代器对象，该对象可以使用for循环进行迭代。
创建 Python 生成器
将简单函数转换成生成器函数的神奇方法是yield关键字。我们可以有一个或多个yield语句从生成器返回一些数据，每次调用生成器时yield语句存储局部变量的状态并产生一个结果。
这里有一个简单的例子，
在上面的例子中，我们定义了一个名为new_gen()的 python 生成器，其中我们取一个变量n给它赋值，打印一些东西，然后产生一个值。在函数内部，我们已经重复了 3 次。
如果我们试图像普通函数一样调用一个生成器函数，它不会被执行，因为它返回一个迭代器对象。因此，我们使用变量x来存储迭代器对象，然后使用next()方法来执行该方法。并且每次生成器的执行都是从它最后离开的地方开始的，即最后的yield语句。
屈服于 Python 列表
我们可以直接使用生成器通过生成值来形成列表，如下例所示，我们已经使用生成器生成了一系列值，并将生成器生成的值存储到列表mylist中。
# defining a generator
def generator():
x = 0
while x < 5:
yield x
x += 1
# yielding values directly into a list
mylist = list(generator())
# use for loop to print mylist items
for x in mylist:
print(x)
0 1 2 3 4
生成器对普通函数对 Python 列表
生成器和简单函数之间的主要区别在于生成器产生值而不是返回值。换句话说，一个简单的函数只返回一个变量，然后就结束了，但是生成器可以通过提供一个迭代器对象来产生一系列的值，我们可以在这个对象上进行迭代。
一个生成器必须有一个yield语句，否则它只是一个正常的函数。
当生成器生成时，它存储其局部变量状态并将控件返回给调用方。当它再次被调用时，它从上次调用中离开的地方开始。正常的函数不支持这种行为。
现在我们来谈谈生成器和列表之间的区别。最大的区别也是生成器最大的优势是生成器从不存储任何值；它只是一个接一个地产生值，因此节省了空间和时间，这不是列表的情况。
带循环的 Python 生成器
作为一个生成器返回一个迭代器对象，因此我们可以使用像for循环这样的循环来迭代它，并打印产生的值。
让我们举一个简单的例子:
Python 中的生成器表达式
就像列表理解一样，我们可以使用表达式来创建 python 生成器的速记。例如，
data = [0, 1, 2, 3, 4]
# creating a generator using generator expression
new_generator = (x*x for x in range(5))
for each in new_generator:
print(each)
0 1 4 9 16
在上面的例子中，生成器表达式生成一个迭代器，它类似于列表data，每个值都是平方的。我们没有创建方块列表，而是直接打印结果，不需要存储单个值。
Python 闭包
为了理解 python 中闭包的概念，我们必须知道什么是嵌套函数和非 loc al 变量。所以我们先从他们开始。
嵌套函数和非局部变量
当一个函数在另一个函数中定义时，这被称为函数嵌套，其中，在其中定义另一个函数的函数被称为外部函数，而在另一个函数中定义的函数被称为内部函数。描述嵌套函数使用的示例如下所示:
#defining nested function
def outer(message):
#text is having the scope of outer function
text = message
def inner():
#using non-local variable text
print(text)
#calling inner function
inner()
# main method
if __name__=='__main__':
outer('Hello!')
你好！
在上面的代码片段中，内部函数inner()能够访问外部函数outer()的局部变量text，其范围扩展到outer()函数的整个主体。外部函数的局部变量text是内部函数的非局部变量，它可以访问但不能修改。
理解闭包的概念
闭包是一个函数对象(一个行为类似于对象的函数)，它会记住封闭范围中的值，即使它们不在内存中。
当一个函数在另一个函数中可用时，就创建了闭包。即使在外部函数返回之后，内部函数也可以访问外部函数的变量和参数。这意味着我们可以稍后调用内部函数，它将可以访问外部函数的变量和参数。实际上，闭包引用了外部函数的变量和参数。我们可以说，闭包是一个记录，它将一个函数和一个环境存储在一起。
#defining nested function
def outer(message):
#text is having the scope of outer function
text = message
def inner():
#using non-local variable text
print(text)
#return inner function
return inner
# main method
if __name__=='__main__':
func = outer('Hello!')
func()
你好！
在上面的例子中，我们使用闭包来访问其范围之外的inner()函数，因为inner()函数只在outer()函数内部可用，但是通过返回它，我们可以在outer()函数外部访问它。
然后在主方法中，我们调用了outer()函数，并返回了对func变量的inner()函数引用。
现在，func变量引用了inner()函数，这意味着当我们将括号用于func变量时，它就像inner()函数一样工作，访问在声明func变量时调用的outer()函数的text变量。
我们再举一个例子:
这个例子稍微复杂一点，因为这里我们在内部operation(n)函数中使用了参数。因此，当调用inrementor(m)函数时，它返回对operation(n)函数的引用。
在定义变量incrementby1、incrementby5和incrementby9时，我们每次都传递了m参数的值。
因此，变量incrementby1、incrementby5和incrementby9分别引用operation(n)函数，其中m参数的值设置为 1 、 5 和 9 。
然后在使用变量incrementby1、incrementby5和incrementby9调用operation(n)函数时，我们也传递了n的值，因此得到了期望的输出。
关于闭包需要记住的要点
以下是一些有用的要点，它们也是在 python 中实现闭包的必要条件:
- 应该有嵌套函数，即函数内部的函数。
- 内部函数必须引用非局部变量或外部函数的局部变量。
- 外部函数必须返回内部函数。
何时使用闭包？
以下是 python 中应该使用闭包的一些用例。
- 闭包可以避免使用全局值。
- 它提供了某种形式的数据隐藏。
- 当一个类中实现的方法很少(大多数情况下只有一个方法)时，闭包可以提供更好的解决方案。但是当属性和方法的数量较多时，最好实现一个类。
Python 装饰器
顾名思义，python 中的装饰器是为现有函数或代码添加附加功能的特殊函数。
例如，你有一辆白色汽车，带有基本的车轮设置，机械师将你的汽车颜色改为红色，并安装合金车轮，然后机械师装饰你的汽车，类似地，python 中的装饰器用于装饰(或添加功能或特性)你现有的代码。
先决条件
在我们学习装饰者的概念之前，我们必须了解一些关于功能的事情。
在 Python 中，一切都是对象，可以使用变量名引用。是的，即使是函数也是有属性的对象。
我们可以让多个变量引用同一个函数对象(定义)，例如:
def one(msg):
print(msg)
# calling the function
one("Hello!")
# having a new variable reference it
two = one
# calling the new variable
two("Hello!")
你好！你好！
同样，我们也可以传递一个函数作为参数。例如:
# some function
def first(msg):
print(msg)
# second function
def second(func, msg):
func(msg)
# calling the second function with first as argument
second(first, "Hello!")
你好！
虽然在上面的例子中，函数second以函数first为参数并使用它，但是函数也可以返回函数。
当存在嵌套函数(函数内部的函数)并且外部函数返回内部函数时，它在 python 中被称为闭包，这是我们在上一个教程中学习过的。
python 中的 Decorators 是 python 中闭包概念的某种扩展。
在 Python 中使用装饰器
装饰器给函数一个新的行为，而不改变函数本身。装饰器用于向函数或类添加功能。换句话说，python 装饰器包装另一个函数，并扩展包装函数的行为，而不会永久修改它。
现在，让我们用一个例子来理解装饰者，
# a decorator function
def myDecor(func):
# inner function like in closures
def wrapper():
print("Modified function")
func()
return wrapper
def myfunc():
print('Hello!!')
# Calling myfunc()
myfunc()
# decorating the myfunc function
decorated_myfunc = myDecor(myfunc)
# calling the decorated version
decorated_myfunc()
修改功能你好！！
在上面的代码示例中，我们遵循了闭包方法，但是我们传递的是一个函数作为参数，因此用更多的代码语句来执行这个函数。
我们将函数myfunc作为参数传递给函数myDecor来获得函数myfunc的修饰版本。
现在，python 没有将函数作为参数传递给装饰函数，而是为我们提供了一种简单的方法，使用@符号。
例如，
# using the decorator function
@myDecor
def myfunc():
print('Hello!!')
# Calling myfunc()
myfunc()
修改功能你好！！
在上面的代码示例中，@myDecor用于将myDecor()装饰器附加到您想要的任何函数上。所以当我们调用myfunc()时，不是执行myfunc()函数的实际体，而是作为参数传递给myDecor()，返回修改后的myfunc()版本，执行。
所以基本上 @ < Decorator_name > 是用来将任何名为 Decorator_name 的 Decorator 附加到 python 编程语言中的任何函数上。
有争论的装饰者
到目前为止，我们已经看到使用装饰器来修改没有使用任何参数的函数。现在，让我们看看如何将参数用于要修饰的函数。
为此，我们将使用*args和**kwargs作为装饰器内部函数中的参数。
函数定义中的*args用于向任何函数传递可变数量的参数。它用于传递非关键字、可变长度的参数列表。
函数定义中的**kwargs用于传递关键字化的可变长度参数列表。我们用双星来命名夸格斯。原因是双星允许我们传递关键字参数(以及任意数量的参数)。
For example,
def myDecor(func):
def wrapper(*args, **kwargs):
print('Modified function')
func(*args, **kwargs)
return wrapper
@myDecor
def myfunc(msg):
print(msg)
# calling myfunc()
myfunc('Hey')
修改函数嘿
在本例中，myfunc()函数接受一个参数msg，这是一条将要打印的消息。该调用将导致 decorator 对函数进行装饰，传递给它的参数将作为结果传递给wrapper()函数的参数，该参数将在调用myfunc()函数时再次传递这些参数。最后，传递的信息会打印在语句“修改功能”之后。
链接装饰者
我们可以使用多个装饰器通过链接来装饰一个功能。让我们用一个例子来理解它，
# first decorator
def star(f):
def wrapped():
return '**' + f() + '**'
return wrapped
# second decorator
def plus(f):
def wrapped():
return '++' + f() + '++'
return wrapped
@star
@plus
def hello():
return 'hello'
print(hello())
-
- ++你好++* * *
在上面的例子中，定义了star和plus装饰者，它们可以将 ****** 和 ++ 添加到我们的消息中。这两个都附加到hello()函数，因此它们同时修改了函数，修饰了输出消息。
装饰师的实际应用
装饰器通常用于将定时和日志功能添加到 python 程序的正常功能中。让我们看一个例子，其中我们将为两个功能添加计时功能:
import time
def timing(f):
def wrapper(*args, **kwargs):
start = time.time()
result = f(*args,**kwargs)
end = time.time()
print(f.__name__ +" took " + str((end-start)*1000) + " mil sec")
return result
return wrapper
@timing
def calcSquare(numbers):
result = []
for number in numbers:
result.append(number*number)
return result
@timing
def calcCube(numbers):
result = []
for number in numbers:
result.append(number*number*number)
return result
# main method
if __name__ == '__main__':
array = range(1,100000)
sq = calcSquare(array)
cube = calcCube(array)
钙立方厘米用了 60.99678039551 密耳秒。钙立方厘米用了 52.99336036061
在上面的例子中，我们创建了两个函数calcCube和calcSquare，分别用于计算数字列表的平方和立方。现在，我们要计算执行这两个函数所需的时间，为此，我们定义了一个装饰器timing，它将计算执行这两个函数所需的时间。
这里我们使用了时间模块和函数启动前的时间来启动变量，函数结束后的时间来结束变量。f.__name__给出正在修饰的当前函数的名称。代码range(1,100000)返回了一个从 1 到 100000 的数字列表。
因此，通过使用装饰器，我们避免了在两个函数中分别使用相同的代码(以获得执行时间)。这有助于我们维护干净的代码，并减少了工作开销。
Python 中的@property装饰器
@property是 python 语言中内置的装饰器，用于使类中的 getters 和 setters 等函数表现为类属性。
为了更好地理解这个概念，让我们举个例子。
下面我们有一个类Student，它有 3 个属性，即fname、lname和fullname，其中全称是前两个属性的串联。
我们还有一个功能，email()功能，使用学生的名字和姓氏为其生成一个电子邮件地址。
class Student:
def __init__(self, fname, lname):
self.fname = fname
self.lname = lname
self.fullname = self.fname +' '+ self.lname
# generate email using first and last name
def email(self):
return '{}.{}@studytonight.com'.format(self.fname, self.lname)
现在让我们创建几个对象并调用函数email()，这样做可以尝试一些事情，
# student s1
s1 = Student('Tony', 'Stark')
print('Fullname of s1 is ', s1.fullname)
print('And email address = ', s1.email())
# now updating the s1 object's first name
s1.first = 'Steve'
print('Fullname of s1 is ', s1.fullname)
print('And email address = ', s1.email())
s1 的全名是托尼·斯塔克，电子邮件地址= Tony.Stark@studytonight.com
现在参考上面的代码，在类Student中， fname (名字)和 lname (姓氏)是简单属性(不从任何其他属性派生出来)，而全称和email()是派生属性。
这里全称被声明为变量，email被声明为函数。
现在进入输出，我们可以看到，对于学生来说，当名字改变时，电子邮件会自动改变，但全名不会改变，因为email()是一个函数，当我们希望电子邮件被返回时调用，而fullname是在对象初始化时设置的。
如果你想解决全称的问题，可以通过类似于电子邮件的功能来获得全称。但是，这将导致在所有使用了Student类的 python 文件中更改对全名的所有访问的开销。
此外，创建函数不是解决这个问题的 pythonic 方式。但那是什么呢？
使用@property装饰器
现在我们将使用上面程序中的@property通过为全名创建一个 getter 函数来解决全名(我们在上面看到的)的问题，这将允许它被用作一个简单的变量，并且将总是返回全名属性的更新值。
让我们看看如何做到这一点，
class Student:
def __init__(self, fname, lname):
self.fname = fname
self.lname = lname
@property
def fullname(self):
return self.fname +' '+ self.lname
# generate email using first and last name
def email(self):
return '{}.{}@studytonight.com'.format(self.fname, self.lname)
s1 = Student('Tony', 'Stark')
print('Fullname of s1 is ', s1.fullname)
print('And email address = ', s1.email())
# now updating the s1 object's first name
s1.first = 'Steve'
print('Fullname of s1 is ', s1.fullname)
print('And email address = ', s1.email())
Output:-
s1 的全名是托尼·斯塔克，电子邮件地址= Tony.Stark@studytonight.com
在上例中，@property装饰器用于名为fullname()的函数。现在，这个函数将作为一个全名属性工作，也可以作为一个 getter 工作，因为它附带了@property装饰器。
用@property装饰器定义setter和deleter方法
类似于 getter 方法(我们在前面的例子中已经定义过)，我们也可以为 Python 中使用@property的任何属性定义 setter 和 deleter 方法。
设置器方法将设置属性的值，删除器方法将从内存中删除属性。
让我们为我们的全名属性实现一个 setter 和 deleter 方法。对于定义设置器和删除器方法，对于在其获取器方法上设置了@property装饰器的属性，我们使用一种特殊的语法，其中我们将@ATTRIBUTE_NAME.setter和@ATTRIBUTE_NAME.deleter装饰器放在与 ATTRIBUTE_NAME 同名的函数上。这在下面的示例中显示，
class Student:
def __init__(self, fname, lname):
self.fname = fname
self.lname = lname
@property
def fullname(self):
return self.fname +' '+ self.lname
#setter for the fullname
@fullname.setter
def fullname(self, name):
# split the name from space
fname, lname = name.split(" ")
self.first = fname
self.last = lname
#deleter for fullname
@fullname.deleter
def fullname(self):
self.first = None
self.last = None
print('Deleted the fullname')
# generate email using first and last name
def email(self):
return '{}.{}@studytonight.com'.format(self.fname, self.lname)
s1 = Student('Tony', 'Stark')
print('Fullname of s1 is ', s1.fullname)
print('And email address = ', s1.email())
# now updating the s1 object's first name
s1.first = 'Steve'
print('Fullname of s1 is ', s1.fullname)
print('And email address = ', s1.email())
#setting new value of fullname
s1.fullname = 'Berry Banner'
print('New Fullname of s1 is ', s1.fullname)
#deleting the fullname
del s1.fullname
s1 的全名是托尼·斯塔克和电子邮件地址= Tony.Stark@studytonight.com S1 的全名是史蒂夫·斯塔克和电子邮件地址= Steve.Stark@studytonight.com S1 的新全名是贝里·班纳删除了全名。
在上面的例子中，我们已经使用@property装饰器成功地创建了 getter 、 setter 和 deleter 。
创建 setter 和 deleter 的简单语法是:
@attribute_name.(setter/getter/deleter)
property()功能
不使用@property装饰器，我们可以使用 python 中的property()函数在 python 中创建 getters、setters 和 deleters。
语法: property(fget, fset, fdel, doc)
其中参数表示:
fget():用于获取属性值
fset():用于设置属性的值
fdel() :用于删除属性值
doc():包含属性文档(docstring)的字符串
返回:从给定的 getter、setter 和 deleter 返回一个属性属性。
下面是一个例子，展示了对相同的Student类使用property()函数，该类具有定义为 getter、setter 和 deleter 的相同函数。
class Student:
def __init__(self, fname, lname):
self.fname = fname
self.lname = lname
self.fullname = fname+' '+lname
def fullname_getter(self):
return self.fname +' '+ self.lname
def fullname_setter(self,name):
firstname, lastname = name.split()
self.fname = firstname
self.lname = lastname
def fullname_deleter(self):
self.fname = None
self.lname = None
print('Deleted the fullname.')
def email(self):
return '{}.{}@email.com'.format(self.fname, self.lname)
fullname = property()
fullname = fullname.getter(fullname_getter)
fullname = fullname.setter(fullname_setter)
fullname = fullname.deleter(fullname_deleter)
# this can be done in a single line too
# fullname = property(fullname_getter, fullname_setter, fullname_deleter)
s1 = Student('Tony', 'Stark')
print('Fullname of s1 is ', s1.fullname)
print('And email address = ', s1.email())
# now updating the s1 object's first name
s1.first = 'Steve'
print('Fullname of s1 is ', s1.fullname)
print('And email address = ', s1.email())
#setting new value of fullname
s1.fullname = 'Berry Banner'
print('New Fullname of s1 is ', s1.fullname)
#deleting the fullname
del s1.fullname
s1 的全名是托尼·斯塔克和电子邮件地址= Tony.Stark@studytonight.com S1 的全名是史蒂夫·斯塔克和电子邮件地址= Steve.Stark@studytonight.com S1 的新全名是贝里·班纳删除了全名。
在这个例子中，我们可以使用property()函数，并使用上面描述的语法或在多个代码行中一次性指定所有 getter、setter 和 deleter 函数作为参数。
Python 中的assert语句
在编程中，断言用于验证指定条件是否为真。例如，如果我们有一个函数将两个数字相加，在使用+运算符将用户提供的两个数字相加之前，我们可以使用一个断言来检查输入的值是否只是数字，而不是字母或特殊字符。
Assert 语句包含一个布尔表达式，用于检查条件的真实性，如果发现有效，则返回 true，否则返回 false。
当在程序中使用断言时，在肯定断言的情况下，程序将继续正常执行，而在否定断言的情况下，程序将停止执行并抛出一个错误。
Python assert语句
在 python 中，有一个内置的 assert 语句，可以用来在程序中实现断言。python 中的 assert 语句将一个条件或表达式作为参数，并期望它为真，以便程序继续执行。如果条件/表达式为假，assert 语句将抛出一个 AssertionError ，从而中断程序的正常执行。
python 中的断言是将条件应用于验证的 python 方式，通常使用if...else条件。
让我们举一个简单的例子来理解何时何地使用 assert 语句。如果您有一个程序将用户输入的密码作为输入，则应检查输入是否为强密码，如果发现强密码，则应存储该密码，否则应要求用户重新输入密码。在这种情况下，我们可以使用 assert 语句对输入的密码值应用各种条件，以检查它是否是强密码。如果条件返回真，那么程序将继续存储密码，否则assert语句将抛出断言错误。有道理！
assert语句的语法:
Assert 语句可以通过两种方式声明:
assert <condition>
# with condition and error message
assert <condition>, <error message>
在第一种语法中，assert 语句将只检查条件，当条件为 false 时，它将引发断言错误。但是在第二种情况下，当条件为假时，assert 语句还将打印一条消息以及断言错误。
时间为例！
让我们举一个简单的例子，我们将定义一个函数来查找分数百分比，其中将提供一个满分为 100 分的分数列表。我们将使用 assert 语句来确保列表中没有包含负号的标记条目。
正如您在上面的程序中看到的，当我们提供 1 个负值时，程序失败并显示 AssertionError ，否则它会成功执行并返回结果。
现在，让我们更新上面的程序，在 assert 语句中包含一条与断言错误一起显示的消息。
# function to calculate percentage, given a list of marks out of 100
def percentage(marks):
for m in marks:
# marks should always be a positive value
assert m > 0, "Only positive values allowed"
return (sum(marks)/len(marks))
print(percentage([90,93,99,95,-94]))
回溯(最近一次调用最后一次):File "/tmp/sessions/2ce 06 e6f 313 b 60 F6/main . py "，第 8 行，在
一些要记住的要点！
断言不同于尝试...除了。尝试...except 用于处理可恢复的错误，随后可以采取纠正措施，而 assert 语句用于处理无法恢复或不需要任何纠正措施的错误。
Assert 是一个语句而不是函数，因此千万不要用括号括起来。如果您试图执行下面的assert(condition, message)，assert 将以一个元组作为第一个参数来执行。它将把(condition, message)作为元组输入。
assert 语句的行为类似于下面的代码:
if not condition:
raise AssertionError()
虽然不完全是这样，但更多的还是这样的表现。
如果您有一个包含许多assert语句的程序，并且您想要禁用所有assert语句，请在优化模式下运行 python 脚本，这可以使用-o标志来完成。
python -o yourscript.py
因为在优化模式下__debug__为假，根据 python 的官方文档，assert 语句相当于:
if __debug__:
if not expression: raise AssertionError
因此，如果__debug__为假，assert语句被禁用。
Python 中的垃圾收集
原文：https://www.studytonight.com/python/python-garbage-collection
在任何程序中，垃圾都是程序没有使用的内存集合，或者已经在给定的时间点使用但不再使用的内存集合。由于该内存空间仍分配给程序，但未被程序使用，因此需要清理的是浪费的内存。
垃圾收集是在给定的时间实例中释放特定程序未使用的内存的过程。
这个过程有助于内存管理，并最大限度地减少内存浪费。垃圾收集释放的内存可用于存储同一程序或其他程序的其他重要数据或变量。
Python:自动垃圾收集
Python 中的垃圾收集自动工作。当没有对变量/数据/值或对象的引用时，python 的垃圾收集机制会释放该对象占用的内存。因此，python 提供了良好的内存管理，防止了内存的浪费。
下面的例子展示了 python 垃圾收集的工作原理:
class SomeObj:
def __init__(self):
print('The object is created.')
def __del__(self):
print('The object is destroyed.')
obj1 = SomeObj()
obj2 = obj1
obj3 = obj1
print("Set obj1 to None...")
obj1 = None
print("Set obj2 to None...")
obj2 = None
print("Set obj3 to None...")
obj3 = None
对象被创建。将对象 1 设置为无...将对象 2 设置为无...将 obj3 设置为无...物体被摧毁了。
在上例中，创建了一个类SomeObj的对象，该对象由对象 1 引用。然后， obj2 和 obj3 也指与 obj1 相同的存储位置。
创建对象后， __init__ (init)方法称为，当对象被破坏时，由于垃圾收集 __del__ (del)方法称为。
在示例中，首先，我们创建了一个SomeObj类的对象，并将其引用传递给 obj1 ，然后传递给 obj2 和 obj3 ，这使得该对象的引用计数为 3。但是当所有这些变量都分配给 None 时，对象的引用就被移除了。
最后，当对象没有引用时，python 的垃圾收集器会自动销毁该对象，并执行__del__()方法。
Python:强制垃圾收集
有时，用户可能需要明确地为内存管理进行垃圾收集，以便释放一些内存空间。因此，python 也允许显式垃圾收集，这可以使用 gc 模块来完成。垃圾收集可以使用垃圾收集模块的collect()功能强制进行，如下图所示:
import gc
class SomeObj:
def __del__(self):
print('The object is destroyed.')
obj1 = SomeObj()
obj2 = obj1
obj3 = obj1
obj1 = None
obj2 = None
obj3 = None
for i in range(10):
dic = {}
dic[0] = dic
print('Collecting...')
n = gc.collect()
print('Unreachable objects:', n)
物体被摧毁了。收集...无法访问的对象:9
在上面的例子中，创建的简单对象(属于SomeObj类)被 python 的隐式垃圾收集器销毁。但是对象dic的情况就不一样了，它是一个字典，一次又一次地指向自己，形成一个循环。在这个循环中形成的对象不能被 python 垃圾收集器隐式销毁。
因此，为了销毁由循环创建的对象(即由for循环运行的对象)，我们使用了 gc 模块的collect()方法。
collect()方法运行垃圾收集并销毁未使用的对象，这些对象是引用计数为 0 的对象。collect 方法返回不可达对象的数量，这里不可达对象是指引用计数为 0 的对象。
Python 浅和深复制
原文：https://www.studytonight.com/python/python-shallow-and-deep-copy
在理解浅复制和深复制的概念之前，我们必须首先清除(如果有)围绕 python 中复制如何工作的疑虑。
在 python 中，就像任何其他编程语言一样，我们可以使用运算符=将一个变量的值复制到另一个变量中。
在 python 中，当我们使用=运算符为当前被其他变量引用的变量赋值时，不会创建新的数据副本，而是由两个不同的变量/对象引用相同的数据副本。
例如，
old_str = "Hello World!"
new_str = old_str
print("Id of old string:" + old_str +" is: ", id(old_str))
print("Id of new string:" + new_str +" is: ", id(new_str))
老串的 Id:你好世界是:139681093231344 新字符串的 Id:Hello World！是:139681093231344
从上面的代码中可以看到，两个变量引用了同一个字符串。不仅仅是字符串，而是每个对象，python 中的所有东西都是对象。
那么，我们如何在 python 中实现深度复制和深度复制，让我们看看。
Python copy模块
Python 有一个复制模块，允许用户将对象从一个变量复制到另一个变量。我们知道，当我们将一个变量赋给另一个变量时，这两个变量都只指向一个对象。因此，我们使用 python 的复制模块来管理对象的复制过程。
主要使用复制模块的两个功能:
copy.copy()copy.deepcopy()
让我们一个接一个地理解如何使用这两个函数。
Python 深度复制
copy.deepcopy(x)函数用于在 python 中执行深度复制。此方法用于创建任何对象的深度副本x。对于深度复制，通过从主对象获取数据并将其复制到新对象中来创建额外的单个对象。因此，如果复制的引用有任何变化，主对象将保持原样。
例如:
import copy
l1=[1,3,[9,4],6,8]
l2=copy.deepcopy(l1) #Making a deep copy
print('List 1 = ', l1)
print('List 2 = ', l2)
print('Performing change in list 2')
l2[2][0] = 5
print('List 1 = ',l1)
print('List 2 = ',l2)
列表 1 = [1，3，[9，4]，6，8]列表 2 = [1，3，[9，4]，6，8]在列表 2 中执行更改列表 1 = [1，3，[9，4]，6，8]列表 2 = [1，3，[5，4]，6，8]
从上面的例子中我们可以看到，l1(第一个列表)是l2(第二个列表)的深度复制。所以，当我们在l2中更新一些数据项时，它并没有反映在l1中。
Python 浅拷贝
copy.copy(x)函数用于在 python 中执行浅复制。此方法用于创建任何对象的浅拷贝x。对于浅复制，对象的引用被复制到另一个对象。所以如果复制的引用有什么变化，也会改变主对象的内容。在某种程度上，这就像 python 中正常的复制工作一样。
例如:
import copy
l1 = [1,3,[9,4],6,8]
l2 = copy.copy(l1) #Making a shallow copy
print('List 1 = ', l1)
print('List 2 = ', l2)
print('Performing change in list 2')
l2[2][0] = 5
print('List 1 = ',l1)
print('List 2 = ',l2)
列表 1 = [1，3，[9，4]，6，8]列表 2 = [1，3，[9，4]，6，8]在列表 2 中执行更改列表 1 = [1，3，[5，4]，6，8]列表 2 = [1，3，[5，4]，6，8]
从上面的例子可以看出，l2(第二个列表)提供了l1(第一个列表)的浅拷贝。这意味着l2所指的对象与l1所指的对象相同。所以，如果我们在l2做任何改变，它也会改变列表l1。
Python 库
字符串函数
Python 字符串center()
原文：https://www.studytonight.com/python-library-functions/python-string-center
Python 字符串center()方法是 python 中的一个内置方法，用于创建并返回一个新的字符串，该字符串用指定的字符填充。
-
这个方法基本上是在 python 中使用的，在给定字符串的左侧和右侧提供带有指定字符(可以是空格，也可以是任何其他字符)的填充，因此这个方法的名称是 center，因为给定字符串保持在中心，并且在两侧都提供填充。
-
无论何时将该方法应用于弦，那么原始弦保持不变。
Python 字符串center():语法
下面我们有一个 Python 中字符串center()方法的基本语法:
string.center(width, fillchar)
Python 字符串center():参数/自变量
Python 字符串center()方法有两个参数，即:width 和 fillchar.这些参数的描述如下:
-
宽度:
该属性用填充字符指定字符串的最终长度(宽度)。比如我有一个字符串 Hello (长度 5)，我指定
width参数为 9 ，那么在字符串 Hello 的左边加 2 个字符，右边加 2 个字符，最后一个字符串的长度为 9** 。** -
填充符:
该属性用于指定填充字符，是可选参数；如果没有给出，那么空间作为其默认参数。
Python 字符串center():返回值
Python 字符串center()方法返回一个用指定字符填充的字符串，重要的是它不修改原始字符串。
Python 字符串center():基本示例
下面我们有一个例子来展示 python 字符串center()函数的工作原理:
s1 = 'hello this is a string'
s2 = s1.center(30, "*")
print(s2)
输出将是:
**** 你好这是字符串 * * *
Python 字符串center():如果字符串长度大于宽度参数
让我们看看下面给出的代码片段，其中字符串的长度大于作为center()函数的参数传递的宽度:
str1 = "I am Developer"
str2 = str1.center(10, "#")
print(str2)
输出将是:
我是开发者
上面的输出表明，如果作为参数传递的宽度小于原始字符串的长度，在这种情况下，在应用center()方法后，原始字符串将按原样返回，因为不需要为字符串提供额外的字符填充来增加其长度，因为字符串的长度已经大于给定的参数。
是时候做一个活生生的例子了！
现在我们将向您展示一个在不同情况下使用center()方法的实例，并查看输出:
要点
-
width是的重要属性如果你没有在center()方法中指定它的值，就会出现错误。 -
由于 python 字符串
center()函数有两个参数，因此必须指定其中至少一个，它就是width。 -
如果多个字符将被用作 fillchar 参数的值，那么它将导致一个错误，就像我们使用“ #$ ”一样。
摘要
在本教程中，我们学习了 Python 中的字符串center()方法，该方法用于创建并返回一个新字符串，该字符串用指定的字符填充。我们通过一些基本和实际的例子看到了这种方法的论点。
Python 字符串isnumeric()
原文：https://www.studytonight.com/python-library-functions/python-string-isnumeric
Python String isnumeric()函数用于检查一个字符串的所有字符是否都是数字类型。
-
Python 字符串
isnumeric()是一个内置函数。 -
如果一个字符串的所有字符都是数字类型的，则
isnumeric()方法返回真，否则将返回假。 -
有种不同类型的数值，如下所示:
-
整数，
-
小数，
-
下标，
-
罗马数字，
-
上标等。
-
-
数词有一个特别之处，那就是它们都可以用 Unicode 来表示。
-
isnumeric()方法的另一个优点是在计算一个字符串中的数字个数时很有用。
Python 字符串isnumeric()`` :语法
下面我们有 Python 中字符串isnumeric()方法的基本语法:
string.isnumeric()
注意: 在上面的语法中，字符串用来表示要检查的字符串变量的值。
另外，从上面的语法可以清楚地看到，这个方法不需要任何参数。
Python 字符串isnumeric():返回值
对于返回值，有两种情况:
-
如果字符串包含所有数字字符，则该方法返回
true。 -
如果字符串包含多个非数值 (字母或任何特殊字符)，则该方法返回
false。
Python 字符串isnumeric():基本示例
下面我们有一个例子来展示 String isnumeric()函数的工作原理:
str1 = "12345678"
str2="abcd123k"
str3="\u00BD"
print("String: ", str1, " Numeric: ", str1.isnumeric())
print("String: ", str2, " Numeric: ", str2.isnumeric())
print("String: ", str3, " Numeric: ", str3.isnumeric())
其输出如下所示:
字符串:12345678 数值:真
字符串:abcd123k 数值:假
字符串:数值:真
是时候做一个活生生的例子了！
让我们看看下面给出的一个实例，在不同条件下我们将使用isnumeric()功能:
摘要
在本教程中，我们学习了在字符串仅由数值组成的情况下返回真的isnumeric()方法，否则返回假。我们通过几个例子看到了它的基本语法。
这个函数可以用来验证用户输入值，如果任何字段应该只有数值，那么我们可以使用这个函数来检查用户是否输入了数值。
Python 字符串isprintable()
原文：https://www.studytonight.com/python-library-functions/python-string-isprintable
Python 字符串isprintable()方法用于检查给定的字符串是否可打印。
-
isprintable()方法是 python 中用于字符串处理的内置方法。 -
如果字符串中的所有字符都是可打印的，或者如果在中有空字符串，则该方法返回
true，否则，该方法返回false。 -
这里任何字符串都是可打印的，如果它的字母是大写的，小写的，或者如果一个字符串包含数字，标点符号或空格。
-
借助这个方法，我们也可以统计一个字符串的不可打印字符的数量。
Python 字符串isprintable()`` :语法
下面我们有一个 Python 中字符串isprintable()的基本语法:
string.isprintable()
注意: 在上面的语法中，字符串用来表示需要检查的字符串的值。
另外，从上面的语法可以清楚地看到，这个方法不包含任何参数。这个方法抛出一个错误如果有任何参数将被传递给它。
Python 字符串isprintable():返回值
对于返回值，有两种情况:
-
如果字符串中的所有字符都是可打印的，则该方法返回 true 。
-
否则，在所有其他情况下，该方法返回 false 。
Python 字符串isprintable():基本示例
下面我们有一个例子来展示 python 中字符串isprintable()函数的工作原理:
a = "Hell0"
b = "!@#$%^&*("
c = "Hello Boy "
d = "Yes \n No"
e = "1234 !@#@!%^ abcd"
print("String: ", a, " printable: ", a.isprintable())
print("String: ", b, " printable: ", b.isprintable())
print("String: ", c, " printable: ", c.isprintable())
print("String: ", d, " printable: ", d.isprintable())
print("String: ", e, " printable: ", e.isprintable())
其输出如下所示:
字符串:Hell0 可打印:真
字符串:！@#$%^ & *(可打印:真
字符串:你好小子可打印:真
字符串:是
否可打印:假
字符串:1234！@#@!%^ abcd 可打印:真
是时候做一个活生生的例子了！
下面我们来看一个在不同情况下使用isprintable()功能的实例:
摘要
在本教程中，我们学习了 python isprintable()方法，该方法在字符串可打印的情况下返回真，否则返回假。
Python 字符串partition()
原文：https://www.studytonight.com/python-library-functions/python-string-partition
Pythonpartition()方法，从法名上看很清楚，是用把绳子分割成更小的部分或者我们可以说 Python 串partition()方法主要是用来分割绳子。
-
partition()方法是 python 中用于字符串处理的内置方法，该方法总是返回一个 python 元组 作为其输出。 -
这种方法有一个参数叫做分隔符，用于分割字符串。
-
如上所述，它在其输出中返回一个元组，因此这个元组主要包括三个部分:其中第一部分表示分隔符之前的字符串部分，第二部分表示分隔符本身，第三部分表示分隔符之后的字符串部分。
-
每当第一次出现分隔符时，此方法都会拆分字符串。
Python 字符串partition()`` :语法
下面我们有一个 Python 中字符串partition()的基本语法:
string.partition(separator)
注: 在上述语法中，字符串表示将应用partition()方法的字符串变量的值，分隔符是该方法的唯一参数。
Python 字符串partition() :参数
以下是对partition()功能参数的描述:
-
分离器
这是
partition()方法的一个参数，该方法使用将绳子分成两部分。在字符串中第一次出现此分隔符时，partition()方法将字符串分为两部分。
Python 字符串partition():返回值
该方法主要返回一个元组，该元组还包括三个部分:
-
第一部分指示分隔符之前的字符串部分。
-
第二部分表示分隔符本身。
-
第三部分表示字符串中位于分隔符之后的部分。
Python 字符串partition():基本示例
下面我们有一个例子来展示 python partition()函数的工作原理:
str1 = "I am a coding lover!"
str2 = "World of science is magic!"
print("Original String: ", str1, "Partition: ", str1.partition('a'))
print("Original String: ", str2, "Partition: ", str2.partition('magic'))
上述输出如下所示:
原创字符串:我是编码爱好者！分区:(' I '，' a '，' m 是编码爱好者！')
原弦:科学的世界是神奇的！分区:('科学的世界是'，'魔法'，'！')
Python 字符串partition():另一个例子
还有一个例子，我们将传递一个不是给定字符串的一部分的分隔符，然后我们将看到相同的输出。相同的代码片段是:
str1="Hello I am wonderwoman"
print("Original String: ",str1,"Partitioned tuple: ",str1.partition('are'))
输出将是:
原字符串:你好我是 wonderwoman 分区元组:('你好我是 wonderwoman '，' '，' ')
是时候做一个活生生的例子了！
让我们看一个 python 的实时例子partition()，在这里我们将以不同的方式使用这个方法:
摘要
在本教程中，我们学习了 python 中字符串的partition()方法，该方法主要用于字符串的分割。
Python 字符串maketrans()
原文：https://www.studytonight.com/python-library-functions/python-string-maketrans
在 Python 中，maketrans()方法是用来映射字符串的字符及其替换物，基本上表示翻译。
-
它是 Python 中字符串的内置映射函数。
-
maketrans()方法充当辅助方法到translate()方法。 -
主要指定需要替换或从主字符串中删除的字符。
-
因此，
maketrans()方法主要返回一个映射表，用于通过translate()方法进一步翻译。 -
它基本上是一种静态方法，用于字符串的字符到其替换字符的一对一映射。
-
此方法有助于为每个字符的翻译创建 Unicode 表示形式。
Python 字符串maketrans()`` :语法
下面我们有一个 Python 中字符串maketrans()函数的基本语法:
maketrans( str_var1, str_var2, str_var3)
注意:上述方法语法中传递的参数是可选的，但至少要有一个参数。
Python 字符串maketrans()`` :参数
语法表明maketrans()方法接受三个参数，其描述如下:
-
页 _var1
它用于表示需要替换的字符。
-
页 _var2
用于表示 str_var1 的字符需要替换的字符。
-
页 _var3
它是一个可选参数，表示需要从列表中替换的字符。
Python 字符串 maketrans():返回值
maketrans()方法返回一个由translate()方法使用的翻译表。
Python 字符串maketrans():基本示例
下面我们有一个例子来说明maketrans()功能的工作原理:
str1="hello"
str2="Girls"
str_var="Hello"
print(str_var.maketrans(str1, str2))
上述代码片段的输出如下:
{104: 71，101: 105，108: 108，111: 115}
在上面的例子中，我们提供了两个字符串str1和str2，因此maketrans()方法将创建一个 transaltion table，其中它将指定当任何人使用translate()方法时，那么‘h’应该被替换为‘g’，‘e’被替换为‘I’，‘l’被替换为‘r’，然后再次被替换为‘l’
如果我们将maketrans()函数的输出与translate()函数一起使用，那么将使用上面创建的翻译表，
str1 = "hello"
str2 = "girls"
str_var = "Hello" #can be any string
x = str_var.maketrans(str1, str2)
# translate the string
print(str_var.translate(x))
鳃
带 Python 字典的 Python 字符串maketrans()
现在我们就用maketrans()方法搭配 Python 字典。让我们看看下面给出的代码片段:
dict = {"a": "219", "b": "211", "c": "229"}
string = "kgb"
print(string.maketrans(dict))
上述代码片段的输出如下:
{97: '219 '，98: '211 '，99: '229'}
从上面的例子可以得出结论，字典字典字典是在例子中定义的。它包含字符 a、b 和 c 分别到 219、211 和 229 的映射。因此maketrans()创建字符的 Unicode 到其对应翻译的映射。
是时候做一个活生生的例子了！
现在，我们来看一下下面给出的实时示例:
摘要
在本教程中，我们已经介绍了 Python 中的字符串maketrans()方法，这是用于将字符串的字符与其替换物进行映射的。
Python 字符串istitle()
原文：https://www.studytonight.com/python-library-functions/python-string-istitle
在 Python 中，字符串方法istitle()用于检查给定的字符串是否是标题。
-
这是 python 中字符串处理的内置函数。
-
当此函数应用于字符串时；然后如果给定字符串的第一个字符是大写的，其余的都是小写的，那么这个函数返回 true 。如果一个字符串有多个单词，那么所有的单词都应该以第一个字符为大写，其余字符为小写。
-
istitle()方法忽略给定字符串中的符号和数字。 -
那些首字母大写的和的字符串用小写的代替所有的单词据说都在标题中。因此，如果字符串位于标题为的中，则该方法返回真，否则返回假。
比如“我是疾速追杀”是的片名，但是“我是疾速追杀”是不是片名**，因为“ am ”没有第一个字符，即 A 为大写。
Python 字符串istitle():语法
下面我们有一个 Python 中istitle()方法的基本语法:
str.istitle()
注: 在上述语法中，str表示变量，其值需要检查。
Python 字符串istitle():参数
从语法上看，很明显，该方法不采用任何参数:
- 如果任何参数传入其中，那么这将产生一个错误。
Python 字符串 istitle():返回值
如果一个字符串的第一个字母是大写的，而其余的是小写的，则该方法返回 true ，这意味着如果一个字符串是大写的，则返回，否则返回 false 。
**## Python 字符串istitle():基本示例
下面我们有一个例子来展示 python 字符串istitle()方法的工作原理:
str="This is the best place to learn coding"
print(str.istitle())
str2= "I Am A John Cena Fan"
print(str2.istitle())
str3="34Thomas"
print(str3.istitle())
上面的输出将是:
假
真
真
Python 字符串istitle():简单程序
让我们看一个给定的程序，我们将检查给定的两个字符串是否在标题中并将看到相同的输出:
a = "I Am The Queen"
b = "I Love Python"
if(a.istitle() and b.istitle()):
print("YES")
else:
print("NO")
上面的代码给出了如下输出:
是
是时候做一个活生生的例子了！
让我们看一个活生生的例子，我们以不同的方式运行这个方法:
摘要
在本教程中，我们学习了如何使用 Python 中的字符串istitle()方法来检查任何给定的字符串是否位于标题为的位置。此方法忽略数字和符号。
Python 字符串rindex()
原文：https://www.studytonight.com/python-library-functions/python-string-rindex
Python 字符串rindex()函数用于返回给定字符串中任何子字符串的最高索引。最高索引的意思是，如果一个给定的子串在一个字符串中出现两次或三次，那么该子串最右边的出现或最后一次出现，该索引将由rindex()方法返回。你可以把它记为最右边的索引。
这是一个内置的字符串处理功能。
-
如果作为参数传递的子字符串不在主字符串中，在这种情况下，函数抛出异常。
-
在这个函数中，传递了三个参数:
-
第一个参数是子串，
-
第二个和第三个参数是主字符串的开始和结束索引，我们必须在其中搜索子字符串
-
-
由于开始和结束索引是可选参数，因此如果没有通过这些参数，则开始被视为 0 ，而长度被视为 -1 。
-
这个方法是区分大小写的，比如它会把书房和书房当成两个不同的词。
Python 字符串rindex():语法
下面我们有一个 Python 中字符串rindex()函数的基本语法:
str.rindex(substr, beginning_index, ending_index)
注: 在上图中，str表示我们搜索子串的主串。
Python 字符串 rindex():参数
rindex()功能接受 3 个参数，如下所示:
-
子字符串
这用于指定子字符串，它是主字符串的一部分，我们将使用这个
rindex()函数找到它的索引。 -
开始 _ 索引
这是一个可选参数，用于指示搜索从何处开始默认值为 0 。
-
ending_index
这也是我们搜索结束时的可选参数。
如果您想将子字符串的搜索限制在字符串的定义部分内，例如，如果您有一个长度为 150 的字符串，并且您想搜索从第 25 个字符到第 75 个字符的子字符串，那么开始 _ 索引和结束 _ 索引是有用的，您可以使用开始 _ 索引和结束 _ 索引参数。
Python 字符串 rindex():返回值
如果在主字符串中找到子字符串，那么它的最高索引(最右边的出现)将被返回。否则，如果字符串中不存在子字符串，将引发异常。
Python 字符串rindex():基本示例
下面我们有一个例子来展示 python 中rindex()方法的工作原理:
str1 = "I love StudyTonight"
str2 = "I love Python"
str3 = "Python language doesn't bite"
print("String: ", str1, "Highest Index: ", str1.rindex("love"))
print("String: ", str2, "Highest Index: ", str2.rindex("Python"))
print("String: ", str3, "Highest Index: ", str3.rindex("drink"))
上述示例的输出如下所示:
字符串:我爱学习今晚最高指数:2
字符串:我爱 Python 最高指数:7
回溯(最近一次调用最后一次):
文件“< pyshell#12 >”，第 1 行，在<模块>
打印(“字符串:、str3、”最高指数:“、str3.rindex(“喝”))
值错误:未找到子字符串
Python rindex()和rfind()
rindex()和rfind()彼此相似，因为这两种方法都从主字符串中返回子字符串的最高索引(多次出现时最右边的一次)。
但是也有一个主要的区别，那就是如果他们不能找到子串rfind()返回， -1 作为输出，而rindex()方法抛出一个异常**。
是时候做一个活生生的例子了！
让我们看一个真实的例子，看看不同情况下的代码输出:
摘要
在本教程中，我们了解到 python rindex()字符串函数用于返回子字符串的最高索引，该子字符串在此函数中作为参数传递给。此外，我们通过一个实例看到了它的语法、该函数获取的参数以及该函数返回的值。
Python 字符串splitlines()
原文：https://www.studytonight.com/python-library-functions/python-string-splitlines
Python splitlines()方法用于在行边界处断开给定的字符串，例如\n(换行符)或\r(回车)等。
-
这是 Python 中字符串的内置方法。
-
当我们断开字符串时，不同的行被编译成一个列表，并由这个函数返回。所以我们可以说它返回了一个分割线的列表。
-
不同类型的换行符有
\n(换行符)、\r(回车)、\r\n(回车+新行)。我们有一个完整的表格，指定了所有指定线条边界的字符。
Python 字符串splitlines():语法
下面我们有一个 Python 中 String splitlines()方法的基本语法:
string.splitlines([keepends])
注意: 在上面的语法中，字符串用来表示主字符串。此外，我们不需要指定这个函数应该查找哪一行边界字符，因为它会自动查找所有这些字符。
Python 字符串splitlines():参数
-
保持结束
这是一个可选参数，可以取两个值中的任意一个:真或假。
当该参数设置为真时，换行符包含在结果列表中。它可以是数字，指定换行符的位置，也可以是任何 unicode 字符，如
\n、\r、\r\n等。它充当字符串的边界。
Python 字符串splitlines():返回值
此方法返回一个由主字符串的行组成的列表，这些行根据主字符串中存在的不同行边界字符进行分解。
Python 字符串splitlines():基本示例
下面我们举一个例子来说明 String splitlines()方法的工作原理:
str1 = 'Hello boy\nHow are you?'
print(str1.splitlines(True))
上述输出将是:
【你好，孩子】【你好吗？]
Python 字符串splitlines():另一个例子
让我们再举一个例子，有更多种类的字符串:
str1 = "India is a diverse country.\r\nWith many different religions and cultures"
str2 = "I love chinese\r food!!"
print("Splitted list: ", str1.splitlines())
print("Splitted list: ", str2.splitlines())
其输出如下所示:
分裂列表:【‘印度是一个多元化的国家’，‘有很多不同的宗教和文化’]
分裂列表:[‘我爱中国’，‘美食！!']
splitlines()方法支持的线边界字符:
splitlines()方法在以下行边界字符上拆分行:
| 表示 | 描述 |
|---|---|
| \n | 指示换行符 |
| \r | 表示回车 |
| \r\n | 表示回车+新行 |
| \v 或 \x0b | 指示行列表 |
| \f 或 \x0c | 指示表单源 |
| \x1c | 指示文件分隔符 |
| \x1d | 指示组分隔符 |
| \x1e | 指示记录分隔符 |
| \x85 | 指示下一行(C1 控制代码) |
| \u2028 | 指示行分隔符 |
计算字符串中每个单词的字符长度:
在下面给出的代码中，我们使用splitlines()的概念来计算字符串中每个单词的长度:
def str_len(string):
li = string.splitlines()
print(li)
l = [len(element) for element in li]
return l
string = "Hello\rthere\rStudytonight!!!!"
print(str_len(string))
相同的输出将是:
【你好】【在那里】【StudyTonight！！！!'】
【5，5，16】
是时候做一个活生生的例子了！
现在是时候借助一个活生生的例子来理解splitlines()方法了！
摘要
在本教程中，我们学习了 Python 中的字符串splitlines()方法，该方法用于在线条边界处将给定的字符串分解成线条后返回线条列表。
Python 字符串rfind()
原文：https://www.studytonight.com/python-library-functions/python-string-rfind
Python rfind()字符串方法用于返回给定字符串中子字符串的最高索引(最右边的出现)。最高索引的意思是，如果一个给定的子串在一个字符串中出现两次或三次，那么该子串最右边的出现或最后一次出现，该索引将由rfind()方法返回，因此我们说它返回该子串的最高索引。
-
如果传递的字符串在主字符串中找不到，则该方法返回 -1 作为输出。
-
rfind()方法是 python 中内置的字符串方法，所以不需要任何 python 模块来使用。 -
这个方法类似于 Python rindex()方法，也可以用来查找给定字符串中任意子串的最高索引。
-
这个方法是区分大小写的，比如它会把书房和书房当成两个不同的词。
Python 字符串rfind():语法
下面我们有一个 Python 中rfind()方法的基本语法:
str.rfind(substring, start_index, end_index)
注意: 在上面的语法中，字符串表示主字符串，而子字符串是主字符串的一部分，其索引是使用这种方法搜索的。
Python 字符串rfind():参数
该方法的参数描述如下:
-
子串
此参数指示要在主字符串中搜索其最高索引的子字符串。
-
开始 _ 索引
这是一个可选的参数，表示搜索开始的起始索引，其默认值为 0 ，因为默认情况下搜索从开始开始。
-
end_index
这是一个可选参数，表示搜索结束的结束索引。
Python 字符串rfind():返回值
它返回在主字符串中找到的子字符串的最高索引。
如果在主字符串中找不到子字符串，在这种情况下，它会返回 -1 作为输出。
Python 字符串rfind():基本示例
下面我们举一个例子来说明 String rfind()方法的工作原理:
str1 = "Hello I love StudyTonight more than I love myself!"
str2= "I love Python Python Python"
print("String: ", str1, "Highest Index: ", str1.rfind("love", 3, 14))
print("String: ", str2, "Highest Index: ", str2.rfind("Python"))
输出将是:
你好，我喜欢今晚的学习！最高指数:8
字符串:我爱 Python 最高指数:21
如您在上面的示例中所见，我们也使用了开始和结束索引参数，因此，即使单词 love 出现在比索引 8 更高的索引处，但这并没有被考虑，因为这超出了给定的索引范围。
而在第二个字符串中，我们有子字符串 Python 3 次，函数rfind()返回最右边出现次数的索引，这是最高的索引。
是时候做一个活生生的例子了！
下面我们有一个不同情况下rfind()方法的实例。让我们看看代码及其输出:
摘要
在本教程中，我们了解到使用 python rfind()字符串方法是为了返回给定主字符串中出现的子字符串的最高索引。
Python 字符串rsplit()
原文：https://www.studytonight.com/python-library-functions/python-string-rsplit
Python rsplit()字符串方法是根据字符串右侧给定的分隔符来拆分字符串。
-
该方法根据分隔符对字符串进行分割后，返回子字符串的列表。
-
分隔符可以是任何字符、任何字母、数字，或者如果您没有提供任何分隔符，则空格将作为默认分隔符。
Python 字符串rsplit():语法
下面我们有一个 Python 中rsplit()字符串方法的基本语法:
str.rsplit(separator, max)
注: 在上面的语法中 str 用来表示主字符串，在这个字符串上rsplit()方法将被应用。
Python 字符串rsplit():参数
该方法的参数描述如下:
-
分离器
这是基于此的第一个参数，
rsplit()方法从右侧拆分字符串。 -
最大值
用来定义我们要拆分字符串的次数，当找到分隔符的时候。如果没有提到这一点，则该字符串将被拆分，直到在字符串中找到分隔符。
Python 字符串rsplit():返回值
此方法返回包含子字符串的列表。
Python 字符串rsplit():基本示例
下面我们举一个例子来说明 String rsplit()方法的工作原理:
str = "hello once again my friends!!"
print("String before split: ", str)
print("String after split: ", str.rsplit(" ", 2))
相同的输出将是:
分裂前的弦:朋友们，再一次你好！！
拆分后的字符串:['再次你好'，'我的'，'朋友们！!']
在上面的代码示例中，我们提供了max参数值 2 ，仅将字符串拆分 2 次，因此我们在列表中获得了 3 个子字符串。如果我们去掉max参数，字符串会在每个空格处被拆分。
Python split() vs rsplit()
Python split()字符串方法和rsplit()功能都是一样的，唯一的区别是rsplit()是从右侧拆分字符串，而split()则不是这样。split()功能从左侧开始从第一个匹配项开始分割字符串。
是时候活出榜样了！
让我们看下面一个活生生的例子，我们以不同的方式使用rsplit()函数:
摘要
在本教程中，我们学习了rsplit()方法，该方法在分隔符的基础上从字符串的右侧分割字符串。
Python 字符串isspace()
原文：https://www.studytonight.com/python-library-functions/python-string-isspace
Python isspace()字符串方法用于检查给定的字符串是否只包含****空白字符。
-
如果一个字符串的所有字符都是空格，那么这个方法返回真。否则，返回假。
-
空白字符如下:
-
'-表示空间
-
\ ' t '-表示水平标签
-
\n' -表示换行符
-
\v' -表示垂直选项卡
-
\f' -表示提要
-
\r' -表示回车
-
你一定想知道我到底在哪里可以使用这个函数，但是如果你在谷歌搜索这里，那么你已经有了这个函数的用例，如果不好，你可以用它来检查一个字符串是否为空，如果所有的字符串都有空格，那么它或多或少是一个空字符串。
Python 字符串isspace() :语法
下面我们有一个 Python 中isspace()字符串方法的基本语法:
string.isspace()
在上面的语法中，字符串用于表示字符串变量，该变量用于检查它是否包含所有空白字符。
Python 字符串isspace() :参数
这个方法不包含任何参数，从上面的语法也很清楚。
如果传递了任何参数，那么这个方法抛出一个异常。
Python 字符串isspace():返回值
如果一个字符串的所有字符都是空格，则该方法返回 true ，在所有其他情况下返回 false 。
Python 字符串isspace():基本示例
下面我们举一个例子来说明 String isspace()方法的工作原理:
str1 = " "
str2 = "Hello Boy"
str3 = "\n\n\t\n\n"
str4 = "HelloGirl"
print(str1.isspace())
print(str2.isspace())
print(str3.isspace())
print(str4.isspace())
上述代码的输出将是:
真
假
真
假
Python 字符串isspace():计算字符串中出现的空白
让我们看看下面的代码片段，它有助于检查字符串中空白的出现:
string = 'Titanic movie starring\n\n\n\n\n\n john'
count = 0
for a in string:
if (a.isspace()) == True:
count += 1
print(count)
输出将是:
9
是时候活出榜样了！
现在是我们看到使用isspace()方法的不同方式的实时示例的时候了:
摘要
在本教程中，我们看到为了检查给定的字符串是否只包含空白，使用了 Python 中字符串的isspace()方法。
Python 字符串zfill()
原文：https://www.studytonight.com/python-library-functions/python-string-zfill
在 Python 中对字符串左侧追加零 zfill()使用字符串方法。Python 字符串zfill()方法是一种内置方法。
基本上它提供了一个填充机制，其中只有 0 个字符用于填充。 Python center()方法或多或少也用于此目的。
-
zfill()方法采用一个数值参数帮助决定要附加的 0 的数量。 -
该参数表示字符串的总所需长度。因此，如果字符串的长度小于，则在左边用 0 数字填充，但是如果字符串的长度已经等于或大于长度参数，则不填充。
-
该函数总是返回一个字符串。
假设我们有一个字符串，当前长度为 30 ，长度传递的参数是40；那么zfill()方法会在字符串的左侧追加 10 个零，从而使字符串长度等于 40。
Python 字符串zfill()`` :语法
下面我们有一个 Python 中zfill()方法的基本语法:
str.zfill(length)
注: 在上面的语法中， str 表示我们应用zfill()方法的字符串变量。
Python 字符串zfill()`` :参数
zfill()方法参数描述如下:
-
长度
这是
zfill()方法的唯一参数。这个参数指定了我们想要制作的字符串的长度。该属性的值必须大于字符串的实际长度，才能看到字符串的任何变化。
Python 字符串zfill():返回值
它返回一个字符串，在主字符串中附加所需数量的零。
Python 字符串zfill():基本示例
下面我们有一个例子来展示 python 中zfill()字符串方法的工作原理:
str1="QWERTYUIOP"
str2="STUDYTONIGHT"
str3="no way!!"
print(str1.zfill(20))
print(str2.zfill(5))
print(str3.zfill(4))
输出将是:
StudyTonight
没门！！
如果传递的参数值或length参数值小于实际字符串长度，则按原样返回原始字符串。
需要记住的几点
此方法返回左侧附加了 0 的字符串副本。将返回的字符串长度完全取决于作为参数传递的长度:
-
例如，字符串的长度为 10 ，作为参数传递的宽度的值等于 15 。在这种情况下，
zfill()方法返回一个字符串，在其左边附加五个零。 -
我们再举一个例子，字符串的初始长度为 10 。作为参数传递的宽度的值等于 8。在这种情况下，字符串
zfill()不填充左边的‘0’位，返回原始字符串。在这种情况下，返回的字符串长度为 10。
Python 字符串zfill():另一个例子
还有一个例子是从用户那里获取输入，然后对其应用zfill()方法。让我们看看下面给出的代码片段:
for i in range(0,2):
h=input()
length=int(input())
print(h.zfill(length),"\n")
输出将是:
6
0
3
玩具
15
000000 玩具
是时候活出榜样了！
下面我们有一个zfill()方法的实例。让我们看看代码片段:
摘要
在本教程中，我们学习了如何使用 Python 中字符串的 zfill()方法在字符串的左侧追加零。
Python 字符串isupper()
原文：https://www.studytonight.com/python-library-functions/python-string-isupper
如果字符串的所有字符都是大写的，Python isupper()字符串方法返回 true 。
-
isupper()方法是一种内置的处理弦的方法。 -
如果字符串中所有基于大小写的字符(字母)都是大写的，则该方法返回 true 否则返回 false 。
-
如果给定字符串中的所有其他字符都是字母和大写，则该方法为空白返回 true 。对于只有空格的字符串，此方法将返回 false 。
Python 字符串isupper()`` :语法
下面我们有一个 Python 中isupper()方法的基本语法:
string.isupper()
注: 在上述语法中字符串表示将应用isupper()方法的字符串变量。
Python 字符串isupper():参数
从语法上看，很明显这个方法不接受任何参数。如果任何参数将被传递，那么它将产生一个错误。
Python 字符串isupper():返回值
如果一个字符串的所有字符都是大写的，这个方法返回真。
Python 字符串 isupper():基本示例
下面我们有一个例子来说明isupper()功能的工作原理:
str = 'WE ARE IN THE TITANIC NOW'
print(str.isupper())
输出将是:
真
Python isupper()方法:另一个例子
还有一个例子，所有字母都不是大写的:
str = "We are in StudyTonight"
print(str.isupper())
输出将是:
假
是时候做一个活生生的例子了！
现在是时候看一个活生生的例子了让我们看看下面给出的例子:
摘要
本教程介绍 Python 中字符串的isupper()方法，如果字符串的所有字符都是大写的，则返回true；返回false代表数字、符号和空格。
Python 字符串islower()
原文：https://www.studytonight.com/python-library-functions/python-string-islower
Python islower()字符串方法返回 true 如果一个字符串的所有字符都是小写，否则返回 false 。
-
islower()方法是一种内置的处理弦的方法。 -
如果字符串中所有基于大小写的字符(字母)都是小写的，那么这个方法返回真否则返回假。
-
如果给定字符串中的所有其他字符都是字母和小写，则该方法为空白返回 true 。对于只有空格的字符串，此方法将返回 false 。
-
对于数字和符号，该方法返回
false。
Python 字符串islower()`` :语法
下面我们有一个 Python 中islower()方法的基本语法:
string.islower()
注: 在上述语法中字符串表示将应用islower()方法的字符串变量。
Python 字符串islower():参数
从语法上看，很明显这个方法不接受任何参数。如果任何参数将被传递，那么它将产生一个错误。
Python 字符串islower():返回值
如果一个字符串的所有字符都是小写的，这个方法返回 true ，否则返回 false 。
Python 字符串islower():基本示例
下面我们有一个例子来展示 String islower() 函数的工作原理:
str="i Am Girl"
print(str.islower())
输出将是:
假
注: 上面例子的输出是假，因为所有字母都不是小写的。
另一个例子
str="i am a wonderwoman"
print(str.islower())
输出将是:
真
是时候做一个活生生的例子了！
现在让我们看一下我们将使用islower()方法的实时示例:
摘要
本教程介绍 Python 中字符串的islower()方法，如果字符串的所有字符都是小写的，则返回true。返回false数字符号空格。
Python 字符串startswith()
原文：https://www.studytonight.com/python-library-functions/python-string-startswith
Python startswith()字符串方法用于检查指定的字符串是否以给定的前缀/子字符串开头。这是 Python 中内置的字符串函数。
-
如果字符串以我们正在寻找的前缀开始，并且如果它没有那个前缀，那么
startswith()方法返回真，在这种情况下，该函数返回假。 -
该函数的参数
prefix为区分大小写，表示研究和研究是两个不同的前缀值。
Python 字符串startswith() :语法
下面我们有一个 Python 中startswith()方法的基本语法:
str.startswith(prefix, beg=0,end=len(string))
Python 字符串startswith() :参数
startswith()参数描述如下:
-
前缀
此参数用于指定作为前缀的子字符串。
-
启动
这是一个可选参数，用于设置匹配边界的起始索引。
-
结束
也是一个可选参数，用于设置匹配边界的结束索引。
Python 字符串startswith():返回值
对于返回值，有两种情况:
-
如果字符串以指定的前缀或子字符串开始，则返回真
-
如果字符串没有以指定的前缀开始，则返回 false 。
Python 字符串startswith():基本示例
下面我们有一个例子来展示 python 中startswith()函数的工作原理:
strA = 'Welcome to StudyTonight'
print(strA.startswith('Study'))
上述代码片段的输出将是:
真
Python 字符串startswith():另一个例子
让我们看另一个代码片段，其中我们看到了这个方法的区分大小写性:
strA = 'Welcome to StudyTonight'
print(strA.startswith('study', 10))
上述代码片段的输出将是:
假
注: 由于startswith()是区分大小写函数、研究和研究被视为不同的字符串，因此我们得到了假作为上述代码的输出。
是时候做一个活生生的例子了！
让我们看一个真实的例子，其中我们将在不同的情况下使用startswith()函数，并将看到相同的输出:
摘要
在本教程中，我们讨论了 Python 中字符串的startswith()方法，该方法用于检查指定的字符串是否以给定的前缀开头。
Python 字符串strip()
原文：https://www.studytonight.com/python-library-functions/python-string-strip
Python strip()字符串方法用于从给定字符串的前导和尾随字符(子字符串)中移除/去除任何给定的字符或子字符串。
- 此方法仅删除左侧的和右侧的，前提是它们与
strip()方法中提供的参数相匹配，并且返回字符串的副本。****
***** 如果我们不将任何字符传递给当前的** 方法，那么将 从字符串中移除所有的前导和尾随空白。**
* 要从给定字符串中删除空白或任何特殊字符，或任何前缀或后缀，使用**方法****。**
*** 匹配区分大小写，这意味着*研究*和*研究*被视为不同。******
****例如，如果我有一个用户输入，用户可以输入他们的全名，那么我们可以使用strip()方法删除添加到全名的任何前缀。很多人会加上先生或小姐。在他们的全名之前。所以我们可以像这样使用strip("Mr.")或strip("Miss.")这样的strip()功能来对输入字符串进行消毒。
同样，我们可以用它来删除字符串前后添加的空格。
Python 字符串strip() :语法
下面我们得到了 Python 中strip()函数的基本语法:
string.strip([character])
Python 字符串strip() :参数
下面给出的是strip()函数的参数:
-
字符
这是一个可选参数，用于指示需要从字符串中删除的字符。如果未提供此参数，在这些情况下，此方法 可以 从字符串中删除所有前导和尾随的空格。换句话说，这个参数的默认值是空白。
Python 字符串strip() :返回值
此方法在移除从字符串中移除的前导和尾随字符后返回字符串。
Python 字符串strip():基本示例
下面我们有一个例子来说明strip()功能的工作原理:
str = " StudyTonight!! Best place to learn coding"
print(str.strip());
其输出如下所示:
StudyTonight！！学习编码的最佳场所
从上面的例子可以得出结论，在输出中删除了字符“S”之前的空格。
Python 字符串strip():从字符串中删除字符
下面给出了一个从字符串中删除字符的例子:
str = "StudyTonight!!Best place to learn coding for online study"
print(str.strip("Study"));
其输出如下所示:
今晚！！在线学习编码的最佳学习地点
注意: 重要的是要记住，如果参数中的字符组合与字符串中的字符不匹配，那么它将停止对字符进行分条。对于这种情况，我们也有一个示例，下面给出了该示例的代码片段:
str="StudyTonight!!Best place to learn coding"
print(str.strip("study"));
其输出如下所示:
StudyTonight！！学习编码的最佳场所
从上面的输出中，我们希望您清楚如果字符串中的字符和传递的参数中的字符不匹配，则strip()功能无法执行其功能。
是时候做一个活生生的例子了！
让我们看看下面给出的例子，我们将在不同的情况下看到strip()函数:
摘要
在本教程中，我们了解到要从指定的字符串中删除前导和尾随字符，可以使用 Python 的strip()方法。
Python 字符串format()
原文：https://www.studytonight.com/python-library-functions/python-string-format
在 Python 中，字符串format()是一个内置函数，借助可以对字符串进行格式化，从而获得更好的输出。
-
在这个功能的帮助下，人们能够格式化字符串的一些选定部分。
-
该函数返回带有传递值的格式字符串，该字符串在占位符位置作为参数传递。
-
该方法在位置格式的帮助下，对于连接字符串中的元素非常有用。
-
为了控制一些值，如输入和来自数据库的值(用户无法控制)，对于这些值，在文本中添加占位符，如卷曲的
({})大括号，然后这些值通过字符串format().运行 -
此函数读取传递给它的参数类型，并根据字符串中定义的格式代码对其进行格式化。
Python 字符串 format()`` :语法
下面我们有一个 Python 中字符串format()的基本语法:
{}.format(value)
注意:在上面的语法中，value 参数可以是整数、浮点数值常量，可以是字符串、字符，甚至是变量。
Python 字符串 format():参数
该方法可以采用任意数量的参数，但是参数分为两种类型:
- 位置参数:
位置参数由参数列表组成，可以通过花括号内的参数索引进行访问，如 {index}。
- 关键词参数:
关键字参数是一个参数列表，类型为 key=value，可以用花括号内的参数的键来访问，如{key}
Python 字符串format():返回值
该字符串format()返回带格式的字符串，在占位符位置将值作为参数传递。
Python 字符串format():基本示例
下面我们有一个例子来展示 String format() 函数的工作原理:
name = 'Kunj'
coins = 21
print('Hello {}, you have {} coins.'.format(name, coins))
在上面的例子中，花括号被名字和硬币代替。其输出如下所示:
你好 kunj，你有 21 枚硬币。
注意:我们可以在格式化字符串时使用多对花括号。如果在一个大字符串中需要另一个变量替换，那么这可以通过添加第二对花括号并将第二个值传递给方法来完成。Python 将以有序的方式用值替换占位符。在上面的例子中，我们已经看到了这一点。
Python 字符串format():数字的格式
下面给出了一个可以格式化数字的例子。让我们看看代码片段:
a = 1000
print('I have {:d} rupees.'.format(a))
输出将是:
我有 1000 卢比。
注意:在上面的代码中，{:d}中的 d 表示它是十进制整数。
数字使用的一些格式说明符如下
| 类型 | 表示 |
| d | 十进整数 |
| c | 对应的 Unicode 字符 |
| b | 二进制格式 |
| o | 八进制格式 |
| x | 用小写表示十六进制格式 |
| X | 以大写形式表示十六进制格式 |
| n | 类似于“d ”,但不同之处在于它使用数字分隔符的当前区域设置 |
| e | 小写指数表示法 |
| E | 大写的指数表示法 |
| f | 显示定点数字(默认值=6) |
| F | 与“f”相同，只是它将“nan”显示为“NAN”，将“inf”显示为“INF” |
| g | 通用格式。它将数字向上舍入到 p 个有效数字。(默认精度:6) |
| G | 它与“g”相同，但如果任何数字有意义，则切换到“E”。 |
| % | 意味着百分比。乘以 100，将%放在最后。 |
时间就是活生生的例子！
现在，让我们看一个 Format()的实时示例，其中我们将以不同的方式使用该方法:
Python 字符串capitalize()
原文：https://www.studytonight.com/python-library-functions/python-string-capitalize
在 Python 中，String capitalize()是一个内置函数，用于将字符串的第一个字母作为大写字母。
-
该函数将字符串的所有其他字母转换为小写。
-
需要注意的一点是，如果第一个字符是大写字母，在这种情况下，函数将只返回原始字符串。
-
如果字符串是空的，那么在这样的字符串上使用这个函数不会导致错误，只会返回一个空字符串作为输出。
-
如果我们将该函数与类似“ 45 的数字字符串一起使用，该函数将再次返回相同的值。
Python 字符串capitalize():语法
下面我们有一个 Python 中字符串capitalize()的基本语法:
string.capitalize()
在上面的语法中，string 表示需要大写的字符串。
注: Python capitalize()函数不包含任何参数。
Python 字符串capitalize():返回值
该方法返回一个字符串，其第一个字母为大写字母，而所有其他字母为小写字母。在这种情况下，如果字符串的第一个字母是大写的，那么它将返回原始字符串。
Python 字符串capitalize():基本示例
下面我们有一个例子来展示 String capitalize()函数的工作。
s1 = "hello studytonight"
print(s1.capitalize())
你好，StudyTonight
Python 字符串capitalize()用于多个字符串
下面我们有一个例子向你展示如何使用字符串capitalize()为多个字符串。
string1 = "hello,"
string2 = "i am a developer"
print(string1.capitalize() + string2.capitalize())
大家好，我是开发者
Python capitalize()具有其他对象类型，如“数字”和“无”
如果我们对不同数据类型的对象(如数字或无值)使用大写()函数，那么我们将得到一个错误。让我们看看例子和输出:
带编号的 Python capitalize():
在下面的 python 脚本中，我们尝试使用带有数值的capitalize()函数:
x = 45
print(x.capitalize())
回溯(最近一次调用最后一次):
文件“< stdin >”，第 1 行，在<模块>
属性中错误:“int”对象没有属性“大写”
我们会得到这个错误，因为在 Python 中，只为字符串类型定义了capitalize()。
Python capitalize()无:
同样，让我们尝试使用带有无值的capitalize()函数:
x = None
print(x.capitalize())
回溯(最近一次调用最后一次):
文件“< stdin >”，第 1 行，在<模块>中
属性错误:“NoneType”对象没有属性“大写”
时间就是活生生的例子！
让我们看一个活生生的例子，其中我们将使用不同字符串的大写字母:
摘要
在本教程中，我们学习了 Python 中字符串的capitalize()方法，该方法使用将字符串的第一个字母作为大写字母。我们看到了这个方法返回的值，我们也看到了几个例子；以及如何对数字和无值应用此方法，下面是一个实时示例。
Python 字符串join()
原文：https://www.studytonight.com/python-library-functions/python-string-join
在 Python 中，String join()是一个内置函数，用于在字符串与可重复项(如列表、元组、字典、集合、 等)连接时返回结果。
-
有了这个
join()功能，任何字符串都可以灵活串接。 -
基本上通过这个函数，一个可迭代的每一个元素(像列表、元组、字典、集合等)都与字符串连接在一起，并作为结果返回连接的字符串。
-
如果可迭代中存在非字符串值，则将引发
TypeError异常。 -
Python String
join()方法也是用于返回字符串的方法，其中任何序列的元素都已通过使用字符串分隔符连接。
Python 字符串join():语法
下面我们有一个 Python 中字符串join()的基本语法:
string.join(iterable)
Python 字符串join():参数
iterable(是一个所有值都以字符串形式返回的对象);是 Python Strings 的join()函数的一个参数。它有一些值，如下所示:
-
目录
-
线
-
元组
-
词典
-
设置
Python 字符串join():返回值
-
每当
non-string values在可迭代中时，就会出现TypeError异常。 -
每当字典被用作可迭代表时，返回值就是键，而不是值。
-
每当
string values出现在作为结果返回的可迭代连接字符串中时。
当元组是可迭代的时，Python 字符串join()
这里我们将定义一个元组及其元素，然后我们将使用.join()函数进行连接:
fruits= ('Mango', 'Apple', "Orange")
str = '|'.join(fruits)
print(str)
在上面的例子中，我们首先定义了一个元组，然后将该元组的值与 |连接起来，如下图所示:
芒果|苹果|橘子
当列表用作可迭代时的 Python 字符串join()
在下面的 python 脚本中，我们尝试将连接()函数与一个列表(在 Python 中的数据结构是一个可变的/可变的、有序的元素序列)一起用作可迭代的:
x = ['WonderWoman', 'Aquaman', 'Batman', 'Superman']
movies = '||'.join(x)
print(movies)
在上面的例子中，我们首先定义了一个列表，然后将该列表的值与||连接起来作为，您可以看到下面的输出:
wonder woman | | Aquaman | |蝙蝠侠| |超人
Python 字符串join()当字典用作可迭代时
在下面的 python 脚本中，我们已经尝试将 join ()函数与字典(无序的数据值集合；它将键:值对)保存为可迭代的:
technologies = {
1: 'AI',
2: 'Machine Learning',
3: 'Serverless',
4: 'ARVR'
}
trends= '/'.join(technologies.values())
print(trends)
在上面的例子中，我们使用了字典值，并用分隔符 /连接它们。相同的输出如下:
AI/机器学习/无服务器/ARVR
当 Set 用作可迭代时的 Python 字符串join()
在下面的 python 脚本中，我们尝试将join()函数与一个集合(无序且未索引的元素集合)一起用作可迭代函数:
a= {'11', '21', '29'}
bc = ', '
print(bc.join(a))
在上面的例子中，我们使用了一个集合并用分隔符 , 连接它们。由于集合是无序的，因此您将在输出中看到不同顺序的元素。相同的输出如下:
29、11、21
在可迭代表中使用非字符串值
每当non-string values在可迭代中时，就会出现TypeError异常。让我们借助下面给出的例子来看看这一点:
a=(11,21)
b='/'
print(b.join(a))
这里我们有相同的输出:
回溯(最近一次调用最后一次):
文件“< pyshell#18 >”，第 1 行，在<模块>
中打印(b.join(a))
类型错误:序列项 0:应为字符串实例，找到 int
时间就是活生生的例子！
现在，我们将看一下 string join()的实时示例，以获得清晰的理解:
摘要
在本教程中，我们学习了 Python 中的字符串join()方法，该方法用于当字符串与可迭代的连接时返回结果。我们也看到了它的参数和返回值；在我们的例子中，我们使用了不同的条目，如列表、集合、元组字典，后面还有一个真实的例子。
Python 字符串split()
原文：https://www.studytonight.com/python-library-functions/python-string-split
在 Python 中，String split()是一个内置函数，用于将一个字符串拆分成一个列表。有时候需要把大绳子掰成小块。
-
此方法通过一个指定的分隔符将给定的字符串断开(分隔符是用于放置在每个项目之间的指定字符)，并返回字符串的列表。
-
用于分隔字符串的默认分隔符为空白；虽然您也可以指定任何分隔符。
-
借助于弦线
split()，弦线上的基本操作之一即分裂弦线可以灵活的方式完成。 -
基本上分裂与合并是对立的；合并使用绳子
concatenation()完成，而拆分使用绳子split()完成
Python 字符串split():语法
下面我们有一个 Python 中字符串split()的基本语法:
str.split(separator, limit)
Python 字符串split():参数
以下是split()参数的描述，因为有两个参数:
- 分离器:
split()的分隔符参数用于提供分隔符，该分隔符随后用于从指定字符中拆分字符串。
- 极限:
split()的极限参数是可选极限，如果提供，则它将字符串拆分为提供次数的最大值。
Python 字符串split():基本示例
下面我们有一个例子来展示 String split()函数的工作原理:
a = "k u n a l"
data = a.split()
for char in data:
print(char)
在上面的例子中，我们没有指定任何分隔符，因此空格在这种情况下被用作默认分隔符 r。其输出如下所示:
k
u
n
a
l
字符串split():未提供参数
strA = 'Welcome! to StudyTonight'
splitA = strA.split()
print(splitA)
在上面的例子中，我们没有在 split()函数中提供任何参数，其输出如下:
[“欢迎！”，‘到’，‘StudyTonight’
字符串 split():提供参数
strA = 'Welcome! to our StudyTonight website'
splitA = strA.split('!')
print(splitA)
在上例中，我们提供了一个分隔符；因此，它从分离器(！)的输出如下所示:
[‘欢迎’，‘来我们今晚的学习网站’
字符串 split() :提供参数和最大分割或限制
下面有一个例子，我们提供了 String split()的参数和 split()的极限参数，当指定了 split()的极限参数时，列表将包含指定数量的项目加上一:
strA = 'Welcome! to our StudyTonight website'
splitA = strA.split(' ',4)
print(splitA)
在上面的例子中，我们把极限参数的值设置为 4。这就是为什么我们得到了 5 个项目的清单。相同的输出如下所示:
[“欢迎！”，‘到’，‘我们的’，‘StudyTonight’，‘网站’
使用字符串split()将 Python 字符串拆分成字典
现在我们将把一个 Python 字符串拆分成一个字典；其代码片段如下所示:
str="a=him;b=duck;c=john"
dictRes=dict(item.split("=") for item in str.split(";"))
print(dictRes)
上面代码片段的输出如下所示，因为它会将给定的字符串转换成相应的字典:
{'a': 'him '，' b': 'duck '，' c': 'john'}
将 Python 字符串拆分为整数
现在，我们将把一个字符串分成相应的整数列表，其代码片段如下所示:
str="11 34 56 67 89"
mp = map(int, str.split())
res = list(mp)
print(res)
这里我们也使用了 python 的 map()和 int()函数；因为我们需要使用 list()方法将对象映射到列表。其输出如下所示:
【11、34、56、67、89】
时间就是活生生的例子！
现在来看一下split()例子的直播例子:
摘要
在本教程中，我们学习了 Python 中用于拆分字符串的split()字符串方法。我们看到了几个同样的例子；我们还将一个字符串转换成整数，并将字符串转换成字典，接下来是一个实时示例。
Python 字符串find()
原文：https://www.studytonight.com/python-library-functions/python-string-find
如果有人想在一个字符串中找到一个子字符串或者在一个字符串中找到一个字母，那么为了这个目的 Python 字符串 find()被使用。
-
Python 字符串
find()是一个内置函数。 -
如果您正在查找一个存在于字符串内部的子字符串，那么该函数返回该字符串第一次出现的索引；如果字符串中不存在子字符串，则函数返回
-1。 -
因此，字符串
find()有助于找到字符串内子字符串的索引。 -
如果在情况下没有给出字符串的起始和结束索引，则起始的默认值为
0，字符串的长度被认为是-1，并且在这种情况下结束索引不包括在搜索中**** -
字符串
find()总是返回一个整数值。 -
用这个方法，我们可以找到一个字符串的子串和一个字符串的字母。
Python 字符串find():语法
下面我们有一个 Python 中字符串find()的基本语法:
string.find(value, start, end)
Python 字符串find():参数
以下是对find()参数的描述，因为有三个参数:
- 值
它是一个强制参数；它用于定义我们在字符串中搜索的子字符串或字符。
- 启动
它用于告诉我们搜索从哪个索引开始，它是一个可选参数，默认值为-1。
- 结束
它用来告诉我们搜索在哪个索引处结束，这个参数也是一个可选参数。
Python 字符串find():返回值
这个 Python 字符串find()总是返回一个整数值。
-
如果子串或一个字母我们在中寻找的是存在于该串中的一个串，那么在这种情况下，该方法返回子串或字母第一次出现的索引。
-
如果子串或字母我们正在寻找的串在那个串中不存在，那么在这种情况下，这个方法返回-1。
Python 字符串find():在字符串中查找子字符串的基本示例
下面我们有一个例子来展示 String find()函数的工作原理:
str = 'StudyTonight is a platform to learn coding online'
index = str.find('Tonight')
print(index)
在上面的例子中，没有定义“开始”参数，在这种情况下开始的默认值是，即使用 0。其输出如下所示:
5
输出是 5，因为今晚子字符串从 5 开始。
Python 字符串find():在两个位置之间寻找一个字母
下面我们有一个例子，我们试图在两个位置之间搜索一个字母。在这种情况下，它将返回该字母第一次出现的索引。让我们看看:
str1 = 'Titanic is a great movie'
index = str1.find('e', 0, 17)
print(index)
15
输出为 15，因为字母“e”的第一次出现在索引 15 处。
使用find()查找字符串中不存在的字符的示例
str1 = 'Titanic is a great movie'
index = str1.find('k', 0, 7)
print(index)
在上面的例子中，我们正在寻找泰坦尼克号中的字母“k”，正如你所看到的，它并不存在。其输出如下所示:
-1
时间就是活生生的例子！
让我们看一下 Python 字符串find()的实时示例，以清楚地了解这种方法:
摘要
在本教程中，我们学习了 Python 中的字符串find()方法，该方法用于查找字符串中的子字符串或字符串中的字母。我们还通过一些示例和一个实时示例看到了它的参数和返回值。
Python 字符串replace()
原文：https://www.studytonight.com/python-library-functions/python-string-replace
如果有人想用另一个字符串或短语替换一个字符串或短语，或者如果你想用一些新值替换一些旧值，在这种情况下使用 Python 字符串replace()。
-
Python 字符串
replace()是一个内置函数。 -
用于将指定的短语或字符串替换为另一个短语或字符串，返回替换后的结果。
-
该方法不修改原始字符串。
-
这个方法基本上返回一个字符串的副本，其中子串的所有出现都被其他子串替换。
-
通俗地说它用新的子串替换旧的子串，返回字符串的副本；有一点要记住的是它并没有修改原弦。
-
这种方法属于
<class 'str'>范畴
Python 字符串replace():语法
下面我们有一个 Python 中字符串replace()的基本语法:
string.replace(oldvalue, newvalue, count)
Python 字符串replace():参数
以下是对replace()参数的描述，因为有三个参数:
- 旧值
它是一个强制属性，用于指定需要搜索的子字符串。
- 新值
它是一个强制属性，用于指定我们需要替换的值。
- 计数
它是一个可选参数，是一个用于指定要替换的旧值出现次数的数字。
Python 字符串replace():基本示例
下面我们有一个例子来展示 String replace()函数的工作原理:
str = 'ABC Movie is a great movie'
replacedString = line.replace('ABC', 'titanic')
print(replacedString)
在上面的例子中，我们没有使用 count 参数。原始字符串的值保持不变；其输出如下所示:
泰坦尼克号电影是一部伟大的电影
Python 字符串 replace():使用count参数
当我们使用计数参数时，它用于指定要替换的旧值的出现次数。让我们看看同样的例子:
str = 'Every DC Movies are great Movies!! Really great Movies'
replacedString = str.replace('Movies', 'Cartoons', 2)
print(replacedString)
其输出如下所示:
每一部 DC 动画片都是伟大的动画片！！非常棒的电影
带正则表达式的 Python 字符串replace()
这里很重要的一点是在Python str.replace()是无法识别的现在如果要对正则表达式或者特殊字符做改动怎么办？
以上问题的答案是需要导入re模块，之后需要使用sub()方法。让我们用一个例子来看看:
import re
data = "The pollution in the air"
res = re.sub("\s", "||", data)
print(res)
其输出如下所示:
污染|在|空气中
Python 字符串 replace():反斜杠到斜杠
在下面给出的例子中，我们试图用斜杠替换字符串中的反斜杠。
data = "images\\abc.jpg"
re_data = data.replace("\\", "/")
print(re_data)
相同的输出将是:
images/abc.jpg
时间就是活生生的例子！
让我们看看replace()的真实例子，以便更清楚地了解它，下面给出了它:
摘要
在本教程中，我们学习了 Python 中字符串的replace()方法，该方法用于将一个字符串替换为另一个字符串。我们还通过几个例子看到了它的语法和参数。我们还把反斜杠替换成了斜线，最后是一个例子。
Python 字符串count()
原文：https://www.studytonight.com/python-library-functions/python-string-count
Python 字符串count()用于这样的情况:如果你想要一个字符串中一个子字符串出现的次数。
-
Python 字符串
count()是一个内置函数。 -
该方法在字符串中搜索指定的子字符串，并返回该子字符串在给定字符串中的出现次数。
-
这个方法主要是返回一个整数，指定一个字符串中子串出现的次数。
Python 字符串count() :语法
下面我们有一个 Python 中字符串count()的基本语法:
string.count(substring, start, end)
Python 字符串count():参数
由于有三个参数，下面给出count()的参数描述:
- 子串:
这是一个强制参数，用于指定要查找其计数的字符串。
- 开始:
这是一个可选参数，用于指定从搜索开始的字符串的起始索引。
- 结束:
这是一个可选参数，用于指定搜索结束的字符串的结束索引。
Python 字符串count():基本示例
下面我们有一个例子来展示 String count()函数的工作原理:
john = 'What did you bring Mr. Bing'
substring = 'ing'
count = john.count(substring)
print('The substring occurs {} times'.format(count))
在上例中字符串格式用于格式化字符串；我们正在搜索“ing”，即 ing 在指定字符串中出现的时间。其输出如下所示:
子串出现 2 次
使用开始和结束参数的字符串示例count()
john= 'What did you bring Mr. Bing'
substring = 'ing'
count = friend.count(substring, 11, 18)
print('The substring occurs {} times'.format(count))
在上面的例子中，我们已经指定了开始和结束参数；其输出如下所示:
子串出现 1 次
时间就是活生生的例子！
让我们看看下面给出的字符串count()的实时示例:
摘要
在本教程中，我们学习了 Python 中字符串的count()方法，该方法用于字符串中子字符串的出现次数。我们还通过一个基本的例子看到了这个方法的基本语法和参数。同样也有一个活生生的例子。
Python 字符串index()
原文：https://www.studytonight.com/python-library-functions/python-string-index
Python String index()方法用于返回子串的索引，如果它是在字符串中找到的。
-
如果子字符串不在字符串中，则该方法会引发异常。
-
这个方法基本上返回我们在字符串中搜索的值的第一次出现的索引。
-
在字符串内部不存在子串的情况下
ValueError Exception被引发。
Python 字符串index() :语法
下面我们有一个 Python 中字符串index()的基本语法:
string.index(value, start, end)
Python 字符串index():参数
以下是对 index()参数的描述，因为有三个参数:
- 值
这是必需的参数，用于指定要搜索的值。
- 启动
这是一个可选参数，用于指定搜索开始的位置；它的默认值是 0。
- 结束
这是一个可选参数，用于指定搜索的结束位置。默认值是字符串的末尾。
Python 字符串index():返回值
此方法返回的值如下:
- 该方法返回找到的子串的第一个位置。
*** 如果未找到子串，则ValueError exception将被引发。**
**## Python 字符串index():基本示例
下面我们有一个例子来展示 String index()函数的工作原理:
ab = 'We can do whatever we want'
sample = ab.index('w', 5, 20)
print(sample)
上面的输出如下所示:
10
Python 串find() vs Python 串index()
这两种方法都是相同的，但是如果字符串中不存在子字符串，情况就有很大的不同:
-
如果我们使用 python
find()方法，那么它将返回-1. -
另一方面，如果我们使用 python
index()，那么它会提升ValueError Exception。
Python 字符串index():字符串中不存在的值的例子
下面我们有一个例子，我们在寻找字符串中不存在的值的索引。让我们看看代码片段及其输出:
abc = 'We can do whatever we want'
gfh= abc.index('z')
print(gfh)
下面给出了输出
回溯(最近一次调用最后一次):
文件“< pyshell#4 >”，第 1 行，在<模块>中
gfh= abc.index('z')
值错误:未找到子字符串
Python 字符串index():不使用开始和结束参数
下面有一个例子，我们没有指定 index()方法的开始和结束参数的值。下面给出了代码片段:
ab = 'Expecto Patronum'
data = ab.index('num')
print(data)
13
时间就是活生生的例子！
现在让我们看看下面给出的index()方法的实例:
摘要
在本教程中，我们学习了 Python 中 Strings 的index()方法，该方法用于在找到子串时返回子串的索引。我们看到了它的参数和一些基本的例子；我们还用find()字符串方法来区分它，后面还有一个实例。
Python 字符串swapcase()
原文：https://www.studytonight.com/python-library-functions/python-string-swapcase
在 Python 中，字符串swapcase()是一种用于字符串处理的内置方法。
-
从名字上看很明显这里是对换格，这又意味着这个方法是用来对换一个字符串的格。
-
该方法将大写的字符串转换为小写的大小写，反之亦然。
-
假设给定一个字符串为
a="ABC"，如果对其应用swapcase()方法，则结果为abc.
Python 字符串 swapcase()`` :语法
下面我们有一个 Python 中字符串swapcase()的基本语法:
string.swapcase()
注意:在上面的语法中；string 表示保存输入值的字符串值，该输入值的大小写需要更改，或者我们将对其应用swapcase()方法。
Python 字符串 swapcase():参数
从该方法的语法中可以清楚地看到，该方法中没有参数。
- 如果我们将任何参数传递给这个方法，那么这个方法将会产生一个错误。
Python 字符串swapcase():返回值
对于返回值，有两种情况:
-
当此方法应用于大写值时，结果将为小写。
-
当此方法应用于小写值时，结果将为大写。
Python 字符串swapcase():基本示例
下面我们有一个例子来展示 String swapcase()函数的工作原理:
h1= “Hello StudyTonight”
h1.swapcase()
相同的输出如下所示；请始终记住，此方法不采用任何参数:
你好 StudyTonight
弦swapcase():又一个例子
a = "joHn Cena"
b = "Hello StudyTonight"
c = "Qwerty"
print("Original String: ", a, "Case changed: ", a.swapcase())
print("Original String: ", b, "Case changed: ", b.swapcase())
print("Original String: ", c, "Case changed: ", c.swapcase())
在上面的例子中，我们在swapcase()应用于原始字符串的值之后，也打印它们的结果。其输出如下所示:
原字符串:约翰·塞纳案例更改:约翰·塞纳
原字符串:hELLO sTUDY 今夜案例更改:Hello sTUDY 今夜
原字符串:qWERTY 案例更改:Qwerty
时间就是活生生的例子！
现在是时候看看下面给出的swapcase()方法的一个实例了:
摘要
在本教程中，我们学习了 Python 中字符串的swapcase()方法，借助该方法，我们可以将大写字符转换为小写字符，反之亦然。我们还讨论了它的参数和返回值，后面是一个实时示例。
Python 字符串title()
原文：https://www.studytonight.com/python-library-functions/python-string-title
在 Python 中，String title()方法应用于字符串时，其第一个字母用大写字母或大写字母，其余字母用小写字母，正如我们在许多文章的标题和标题中看到的那样。
-
title()是 python 中用于字符串处理的内置函数。 -
此方法将字符串的第一个字母转换为大写字母(大写)，并将所有字母以小写或小写形式保留下来，并返回新字符串。
-
返回的新字符串称为标题大小写(第一个字母大写，其余字母小写的字符串)。
Python 字符串title():语法
下面我们有一个 Python 中字符串title()的基本语法:
string.title()
注意:上例中的字符串表示需要加标题大小写的字符串变量的值。
Python 字符串title():参数
从语法上看，很明显，该方法不采用任何参数:
-
如果有任何参数被传递到这里，那么这将产生一个错误。
-
在这个方法中，我们使用一个带有点操作符的字符串来显示输出。
Python 字符串title():返回值
该方法主要返回一个字符串的副本，其首字母为大写，其余所有字母均为小写；那么整个管柱称为标题套管管柱
Python 字符串title():基本示例
下面我们举一个例子来说明 String title()方法的工作原理:
h1 = "I am A JOHN CENA FAN!"
h2= "I lOvE sTuDyTonight"
print("Original string: ", h1)
print("title(): ", h1.title(), "\n")
print("Original string: ", h2)
print("title(): ", h2.title(), "\n")
在上面的例子中，我们已经打印了原始字符串和标题大小写字符串的值。其输出如下所示:
原创字符串:我是约翰·CENA 的粉丝！
标题():我是约翰·塞纳球迷！
原创字符串:我爱 StudyTonight
标题() :我爱 StudyTonight
Python 字符串title():另一个例子
下面有一个程序，用户输入值，稍后title()方法将应用于这些值。让我们看看代码片段:
for i in range(0, 2):
print("Enter the string: ")
a = input()
print("Original String: ", a)
print("title(): ", a.title(), "\n")
其输出如下所示:
输入字符串:
阿伦·库马尔
原字符串:阿伦·库马尔
标题():阿伦·库马尔
T5】输入字符串:
罗希特·夏尔马
原字符串:罗希特·夏尔马
标题():罗希特·夏尔马
时间就是活生生的例子！
为了更好地理解字符串title()，让我们看看下面给出的实时示例:
摘要
在本教程中，我们学习了带有返回值和参数的title()方法，接下来是一个真实的例子。
Python 字符串encode()
原文：https://www.studytonight.com/python-library-functions/python-string-encode
编码意味着将 Unicode 转换为一组字节。正如我们所知，在 Python 中数据以 Unicode 存储，但是从安全性的角度来看，我们需要将它们转换成一组字节。这个过程提高了存储字符串的效率。例如，密码在字符串中，所以为了以安全的方式存储它们，我们使用 Python 字符串encode()方法。
不同的编码方案有:
-
美国信息交换标准代码
-
UTF-8(Unicode 转换格式)
-
ibm039 和更多。
Python 字符串encode():介绍
该方法的一般介绍如下:
-
这是 Python 中的内置方法。
-
默认情况下， Python 中的字符串以 Unicode 存储，但是我们可以按照提供的编码标准对字符串进行编码；有几种编码方案。
-
这种方法主要用于将字符串的 Unicode 转换为编码，python 应该支持这种编码。
-
主要用于字符串的高效存储。
-
它主要使用指定的编码对字符串进行编码；如果没有指定编码，那么将使用 UTF-8
-
encode()的主要应用:需要在数据库中安全存储密码(在字符串中)，因此需要来保存字符串的编码版本。
Python 字符串encode():语法
下面我们有一个 Python 中字符串encode()的基本语法:
string_var.encode(encoding, errors)
Python 字符串encode() :参数
这些参数的描述如下:
- 编码
这用于指示字符串将被编码到的编码类型。它也是一个字符串，主要指定要使用的编码。该参数的默认值为“UTF-8”。
- 错误
当编码失败时，此参数给出一个响应，有六个编码错误响应。基本上，这是一个指定错误方法的字符串。该参数的合法值如下:
-
backslashreplace':该错误值使用反斜杠代替无法编码的字符。可以写成errors="backslashreplace"。 -
ignore':该值用于忽略不能编码的字符。可以写成errors="ignore"。 -
namereplace':该值用于用解释字符的文本替换字符。可以写成errors="namereplace"。 -
strict':这是一个默认值，失败时会引发错误。可以写成errors="strict"。 -
replace':该值用于将字符替换为问号。可以写成errors="replace"。 -
xmlcharrefreplace':该值用于将字符替换为 XML 字符。可以写成errors="xmlcharrefreplace"。
如果这根弦出现故障encode()；UnicodeDecodeError将引发异常。
Python 字符串encode():基本示例
下面我们有一个例子来展示encode()功能的工作情况:
str1 = "Hello and welcome to the world of pythön!"
str2 = str1.encode()
print(str2)
下面给出了相同的输出，您将看到编码形式的输出
b '大家好，欢迎来到大蟒世界\xc3\xb6n！'
Python 字符串encode():使用参数的示例
下面有一个代码片段，我们也将在其中使用 encode()函数参数。让我们看看:
str1 = "Hello pythön!!"
print(str1.encode("ascii", "replace"))
相同的输出如下所示:
b'Hello pyth？n 个！！'我不知道
Python 字符串encode():使用errors参数所有值的示例
下面我们有一个代码片段，其中我们将使用不同的误差值，这是encode()方法的参数之一:
string= "Ståle is my name"
print(string.encode(encoding="ascii",errors="backslashreplace"))
print(string.encode(encoding="ascii",errors="ignore"))
print(string.encode(encoding="ascii",errors="namereplace"))
print(string.encode(encoding="ascii",errors="replace"))
print(string.encode(encoding="ascii",errors="xmlcharrefreplace"))
print(string.encode(encoding="ascii",errors="strict"))
因此，上述代码的输出将是:
b'St\xe5le 是我的名字】
b'Stle 是我的名字】
b ' ST \ \ N {拉丁文小写字母 A WITH RING ABOVE } le 是我的名字'
b'St？“乐是我的名字”
b ' ST&# 229；le 是我的名字'
Traceback(最近一次调用最后一次):
File/tmp/sessions/353 CCB 2c a3d5 D1 fc/main . py "，第 8 行，在<模块>
print(string . encode(encoding = " ascii "，errors = " strict ")
unicodeencodererror:' ascii ' codec 无法编码字符' \xe5 '在位置 2:序数不在范围内(128)
时间就是活生生的例子！
让我们看一下现场的例子，以清楚地了解encode()方法:
摘要
在本教程中，我们已经了解了什么是编码？不同的编码方案，以及对encode()方法的详细描述和对encode()方法参数的深入解释。在我们看到不同的例子后，接着是现场例子。
Python 字符串endswith()
原文：https://www.studytonight.com/python-library-functions/python-string-endswith
Python 字符串endswith()是一个内置函数，如果字符串以特定的后缀结束，则返回true；否则它将返回false。
-
在这种情况下，如果没有指定开始和结束索引，那么默认情况下开始被视为
0长度被视为-1结束索引不包括在我们的搜索中。 -
如果字符串是以
endswith()函数中使用的为后缀的，则函数将返回true** ，否则将返回false。** -
如果您想检查字符串是否以列表中的一个字符串结尾，那么在这种情况下，使用字符串
endswith()函数。 -
此方法返回布尔值。
-
这个函数也接受元组；我们将通过例子向你展示
Python 字符串endswith() :语法
下面我们有一个 Python 中字符串endswith()的基本语法:
string.endswith(suffix, start, end)
Python 字符串endswith():参数
endswith()参数描述如下:
- 字尾
此参数用于指定字符串的一部分，我们将检查字符串是否以该部分结尾。
- 启动
这是一个可选参数，从这里开始后缀。
- 结束
它是一个可选参数，后缀将在此结束。
Python 字符串endswith():返回值
对于返回值，有两种情况:
-
如果字符串以指定的后缀结束，则返回真。
-
如果字符串没有以指定的后缀结束，则返回假。
Python 字符串endswith():基本示例
下面我们有一个例子来展示 String endswith()函数的工作原理:
string = "Hello I am Ram and I am a developer"
result = string.endswith("per")
result1 = string.endswith("PER")
print("Comparing it with right suffix so output: ",result)
print("Comparing it with wrong suffix so output: ",result1)
其输出如下所示:
将其与正确的后缀进行比较，输出:真
将其与错误的后缀进行比较，输出:假
Python 字符串endswith():使用开始和结束参数
在下面给出的例子中，我们将同时使用endswith()的开始和结束参数。让我们看看代码片段:
abc = "This is a string and is awesome"
right_suffix = "some"
wrong_suffix = "some!"
print(abc.endswith(right_suffix, 28, 31))
print(abc.endswith(wrong_suffix, 28, 31))
其输出如下所示:
假
假
Python String endswith() ： 元组后缀
在这个例子中，我们正在检查字符串是否以元组中的一个字符串结束。让我们看看代码片段:
text = "StudyTonight"
result = text.endswith(('Study', 'Otis'))
print(result)
result = text.endswith(('Study', 'night'))
print(result)
其输出如下所示:
假
真
Python 字符串endswith():使用列表
在本例中，我们正在检查字符串是否以列表中的某个字符串结尾。让我们看看代码片段:
ext = ['.jpg','.png']
file = 'test.png'
print(file.endswith(('.jpg', '.png')))
其输出如下所示:
真
时间就是活生生的例子！
现在让我们看一个活生生的例子，以便完全理解endswith()方法:
摘要
在本教程中，我们学习了endswith()方法及其参数和返回值的描述。我们还使用了元组和列表作为后缀。还有一个endswith()方法的活例子。
Python 字符串upper()
原文：https://www.studytonight.com/python-library-functions/python-string-upper
在 Python 中，字符串upper()是一个内置的字符串处理函数。
-
字符串
upper()用于返回指定字符串的副本，其中所有基于大小写的字符都是大写的。 -
这个函数的主要目的是将字符串转换成大写。
Python 字符串upper() :语法
下面我们有一个 Python 中字符串upper()的基本语法:
string.upper()
Python 字符串upper():参数
从上面的语法来看，很明显这个函数不接受任何参数。
- 如果我们将任何参数传递给这个函数，那么它将产生一个错误。
Python 字符串upper():基本示例
下面我们有一个例子来展示 String upper()函数的工作原理:
str="one woman army"
print(str.upper())
其输出如下所示:
一个女人的军队
Python 字符串upper():数字和符号
如果任何字符串包含数字、符号和字母；在这种情况下，数字和符号将按原样返回，而字母将转换为大写。让我们看看下面给出的代码片段:
str1="123!!woman"
print(str1.upper())
输出将是:
123！！妇女
Python 字符串upper():检查两个字符串是否相同
在下面给出的例子中，我们将借助upper()`` 方法检查两个给定的字符串是否相等。让我们看看给出的代码片段:
# working of upper() function
string1 = 'This is a Best Place To LEARn Coding ONLINE'
string2 = 'this is a besT PLACE To Learn Coding'
if(string1.upper() == string2.upper()):
print("string1 and string2 are same")
else:
print("String1 and string2 are not same")
输出将是:
string1 和 string2 不相同
时间就是活生生的例子！
现在让我们看看下面给出的使用upper()方法的实例:
摘要
在本教程中，我们看到了如何使用 Python 的 String upper()方法将字符串中所有基于大小写的字符转换为大写，我们还将该方法应用于数字和符号，以查看该方法对数字和符号的影响。同样，我们也使用了实时示例。
Python 字符串lower()
原文：https://www.studytonight.com/python-library-functions/python-string-lower
在 Python 中，字符串lower()是一个内置的字符串处理函数。
-
String
lower()方法用于返回指定字符串的副本，其中所有基于大小写的字符都变成小写。 -
这个函数的主要目的是将字符串转换成小写。
Python 字符串lower():语法
下面我们有一个 Python 中字符串lower()的基本语法:
string.lower()
Python 字符串lower():参数
从上面的语法来看，很明显这个函数不接受任何参数。
- 如果我们将任何参数传递给这个函数，那么它将产生一个错误。
Python 字符串lower():基本示例
下面我们有一个例子来展示 String lower() 函数的工作原理:
str="One wOMan"
print(str.lower())
其输出如下所示:
一个女人
Python 字符串lower():数字和符号
如果任何字符串包含数字、符号和字母；在这种情况下，数字和符号将按原样返回，而字母将转换为小写。让我们看看下面给出的代码片段:
str1="123!!WoMaN"
print(str1.lower())
输出将是:
123！！妇女
Python 字符串lower():检查两个字符串是否相同
在下面给出的例子中，我们将借助lower()方法检查两个给定的字符串是否相等。让我们看看给出的代码片段:
# working of lower() function
string1 = 'Welcome To StudyTonight'
string2 = 'weLcoMe to studyTONIGHT'
if(string1.lower() == string2.lower()):
print("string1 and string2 are same")
else:
print("String1 and string2 are not same")
输出将是:
string1 和 string2 相同
时间就是活生生的例子！
让我们看一个 lower()方法的实例:
摘要
在本教程中，我们看到了如何使用 Python 的 String lower()方法将字符串中所有基于大小写的字符转换为小写，我们还将该方法应用于数字和符号，以查看该方法对数字和符号的影响。同样，我们也使用了实时示例。
Python 字符串isaplha()
原文：https://www.studytonight.com/python-library-functions/python-string-isaplha
如果给定的字符串仅包含字母，Python 字符串isaplha()返回真。
-
弦
isalpha()是一种内置的弦处理方法。 -
只有当字符串的所有字符都是字母(大写和小写)时，才返回真。
*** 需要注意的一点是，空白不被认为是字母表；因此，如果字符串中有空白，那么这个方法返回 false。**
**## Python 字符串isalpha():语法
下面我们有一个 Python 中字符串isalpha()的基本语法:
string.isalpha()
注意:在上面的语法中，字符串表示将应用isalpha()方法的字符串变量。
Python 字符串isalpha():参数
从语法上看，很明显这个方法没有任何参数；如果任何参数将被传递，那么它将引发一个错误。
Python 字符串isalpha():返回值
如果一个字符串的所有字符都是字母，这个方法返回真。
- 如果字符串不包含任何字母表，或者如果字符串包含特殊字符或数字字符；那么这个方法将返回 false。
如果是空白，这个方法也会传回 false。
Python 字符串isalpha():基本示例
下面我们有一个例子来展示 String isalpha()函数的工作原理:
string = "HelloStudyTonight"
string2 = "Hello StudyTonight"
print("It returns true because string contains alphabets only:")
print("String=", string)
print(string.isalpha())
print("It will return false as it contains alphabets and one space:")
print("String=", string2)
print(string2.isalpha())
输出将是:
返回 true，因为字符串只包含字母:
String = hellostudytonnight
True
返回 false，因为它包含字母和一个空格:
String = Hello study night
False
时间就是一个例子！
让我们看看下面给出的实例，其中我们以不同的方式使用isalpha()方法:
摘要
在本教程中，我们讨论了isalpha()方法及其基本语法、返回值和实时示例。
Python 网络
简介和基础知识
网络编程导论
原文：https://www.studytonight.com/network-programming-in-python/introduction-to-network-programming
欢迎伙计们！祝贺你迈出成为安全工程师的第一步。哦..安全工程师，但这到底意味着什么？
互联网每分钟在全球范围内传输数百万字节的数据。你知道这是怎么发生的吗？你点击一个链接，在几秒钟内下载一个数兆字节的文件，观看你最喜欢的视频，进行视频直播等等。这不是魔法！幕后有一些人，他们正在非常努力地工作，通过确保到达你这里的数据是不一致的和合法的，来高效和安全地实现这一切。他们被称为安全工程师。
你们中的一些人可能想知道在这里你们会学到什么。如果你学过编程，你一定想知道，好吧，我们知道编程！但是，该怎么处理呢？它的实际实现是什么。毕竟，没有人会给你一个数组，并要求你对它进行排序。没错。通过编程解决的现实世界问题是不同的，也是复杂的。
在这一系列的教程中，您将会遇到一些非常棒的编程实现，使用的不是别人，正是 Python 语言。
什么是网络？
计算机联网旨在研究和分析链接或联网在一起以交换信息和共享资源的各种计算设备或计算机系统之间的通信过程。因此，为了进行联网，您必须有一个网络。就像打电话一样，你必须有电话线。是不是很明显！所以，基本上有四种类型的计算机网络:
局域网
用于服务位于小地理空间的少数人，如学院、小组织等。这更像是一种对等的联系。
广域网
这种网络类型比局域网覆盖的面积更大，因为它们允许跨大地理区域的连接。它基本上将许多局域网连接在一起，不仅仅是对等共享。互联网就是广域网的一个例子。
下图将为您提供一个关于局域网和广域网的好主意:
城域网
城域网是一种计算机网络，它将用户与比局域网覆盖的区域大但比广域网覆盖的区域小的地理区域或地区的计算机资源相互连接起来。该术语源于其对城市中网络互连成一个更大网络的用法。
个人区域网
个人区域网(PAN)是一种计算机网络，用于计算机、电话、平板电脑和个人数字助理等设备之间的数据传输。pan 可用于个人设备之间的通信(人际通信)，或者连接到更高级别的网络和互联网(上行链路)，其中一个主设备承担互联网路由器的角色。
常见网络术语
原文：https://www.studytonight.com/network-programming-in-python/networking-terminologies
让我们快速浏览一下常用术语及其含义，这对网络编程非常重要。如果你已经知道了，那就快速浏览一遍，如果遗漏了什么，一定要告诉我们。
因特网协议
这些是管理互联网上数据流和数据格式的一套程序或规则。
让我们用一个简单的例子来理解这一点:假设有两个朋友 A 和 B 。如果甲想寄信给乙。他会怎么做？ A 会去邮局(一种通讯网络)，把信放在信封里，在邮局递交给 B 。现在，把信安全送到 B 是邮局的责任。现在假设 A 想要发送一个包含 20 页的脚本给 B 。因为有一个限制，一个信封最多只能装一页，所以 A 必须把所有 20 页放在单独的信封里，一页一页地寄出。现在如何保证邮局会按照预期的顺序投递信件？互联网协议来了。
我们将主要讨论互联网上的两个主要协议:
- 用户数据报协议
- 传输控制协议
用户数据报协议
UDP 是一种无连接协议。在该协议中，数据作为数据报通过互联网发送。在前面的例子中， 20 页可能指 20 个数据报。让我们来看看 UDP 协议的一些属性。
- 不可靠:发送 UDP 报文时，无法知道是否会到达目的地；它可能会在路上迷路。在 UDP 中，没有确认、重传或超时的概念(如在 TCP 中)。
- 未排序:如果两条消息发送给同一个收件人，则无法预测消息到达的顺序。
- 轻量级:没有消息排序，没有跟踪连接等。因此，当所需的数据传输速率较高且可靠性不重要时，使用 UDP 消息。
- 数据报:数据包是单独发送的，只有在到达时才会进行完整性检查。
假设在上例中， B 接收所有页面，除了信封号 13 。然后他可以要求 A 重新发送信封号 13 ，但是那么 B 如何知道，何时请求丢失的信封？有可能一旦 B 向 A 发出重发信封号 13 的请求，邮局就将丢失的信封送达。延迟交货的原因可能有很多。但是因为在 UDP 中，没有确认或重传的概念，因此，唯一的方法是等待，然后再次请求丢失的数据报。
所以我们需要一个更好的方法来确保 B 正确接收所有数据。幸运的是，在计算机网络中， UDP 不是在计算机之间发送数据的唯一协议。
传输控制协议
在 TCP 中有一个握手的概念。那么，什么是握手？这是一种确保感兴趣的主机之间已经建立连接的方法，因此可以启动数据传输。
简单来说，当你给某人打电话时，你首先说“你好”，作为回报，这个人回复一句“你好”。这确保了双方之间的连接已经建立，并且现在可以开始数据(在这种情况下是语音)传输。毫无疑问，这是握手最简单的例子。
与 UDP 不同，TCP 协议要求您首先建立连接。因此，如果 A 要使用 TCP 协议向 B 发送一封信，他必须首先与 B 建立连接。一旦建立连接， A 就可以发送第一个信封，并等待 B 确认他已经收到了。一旦 A 收到 B 确认信封 1 已安全收到， A 即可发送信封 2 。重复这个过程，直到 A 告诉 B 他已经发完了所有的信封。
根据上面的例子，我们可以确定 TCP 的属性:
- 可靠 : TCP 管理消息确认、重传和超时。多次尝试传递消息。如果它在途中丢失，服务器将重新请求丢失的部分。
- 有序:消息按照预定的特定顺序传递。
- 重量级:在发送任何用户数据之前，TCP 需要三个数据包来建立套接字连接。三包分别是:
SYN、SYN+ACK、ACK。
IP 地址和端口
IP 地址是有助于在互联网上唯一识别设备的地址，端口是操作系统中通信的端点。迷茫！让我们试着让它简单易懂。
在上例中 A 给 B 发了一封信。 A 需要知道 B 的邮政地址才能成功投递包裹。这个邮政地址是独一无二的，因此邮递员成功地投递了这封信。 IP 地址类似邮政地址。现在，假设 B 有 5 个房间，每个房间都有一个 B 的亲戚。 B 的一个亲戚点了一个披萨。现在，当送披萨的男孩到达给定的地址时，他怎么知道 5 个亲戚中谁点了披萨？因此，为了唯一识别订购比萨饼的人，送货员需要房间号。这个房间号是计算机网络中的端口号。
一个系统可能运行数千个服务，但要唯一识别系统上的服务，应用需要一个端口号。一个系统上总共有0–65535个端口。
端口号有时也出现在网络或其他统一资源定位符(URL)中。默认情况下，HTTP 使用端口80，HTTPS 使用端口443，但是像http://www.example.com:8080/path/这样的网址指定网络浏览器改为连接到 HTTP 服务器的端口8080。
一些常见的端口有:
22:安全壳(SSH)23:远程登录服务25:简单邮件传输协议(SMTP)53:域名系统(DNS)服务80:万维网中使用的超文本传输协议(HTTP)
现在，接下来是一些关于 IP 地址的细节。IP 地址有两种类型:
- 私有 IP 地址:范围从(192 . 168 . 0 . 0—192 . 168 . 255 . 255)、(172 . 16 . 0 . 0—172 . 31 . 255 . 255)或(10 . 0 . 0 . 0 . 0—10 . 255 . 25
- 公共 IP 地址:公共 IP 地址是您的家庭或企业路由器从您的 ISP(互联网服务提供商)接收的 IP 地址。
防火墙
防火墙根据预定义的安全规则监控传入和传出的网络流量，如扫描数字签名、检查有效的文件格式等。它在可信、安全的内部网络和另一个被认为不安全或不可信的外部网络(如互联网)之间建立了屏障。
为什么选择 Python 进行网络编程？
本课程使用 Python 有几个原因。python 的简单性使其成为最强大的语言。Python 在语法上最容易实现。
此外，使用 python 几乎可以做任何事情。哦..几乎所有的东西，我们能用 python 做一个网站吗？我们能用 python 做人脸检测应用吗？我们可以使用 python 制作自己的个人助理吗？我们能用 python 做一个渗透测试工具吗？
以上所有问题的答案都是“是”！
python 提供的第三方库支持使它变得无限。对于第三方库也有适当的文档，因此在您的应用中使用它们变得更加容易。
最后，python 足够强大，可以制作像 Quora 这样的网站，并为谷歌搜索引擎提供主干，所以没错，python 是网络编程的完美选择。
安装 Python 第三方库
原文：https://www.studytonight.com/network-programming-in-python/installing-third-party-libraries
从本课程之前的教程中，你一定已经收集了一些关于网络的知识。现在是我们把手弄脏的时候了。但是在此之前，你知道什么是 python 库或者 python 模块吗？嗯，从技术上来说，模块只是一个 Python 源文件，它可以公开类、函数和全局变量。一个 python 模块可以在另一个 Python 模块中使用或导入。如果你是 Python 的新手，在今晚的学习中学习 Python。
你可能会想为什么我们需要模块？使用模块增加了代码的可重用性，有助于程序的轻松维护。例如:假设你正在写一个非常大的程序。随着程序变得越来越长，您可能希望将其拆分成几个文件，以便于维护。您可能还想将为一个程序创建的函数定义重用到另一个程序中，而不需要再次编写或处理该函数。为了支持这一点，Python 有一种将定义放入文件并在脚本中使用它们的方法。这样的文件叫做模块。
举一个加数模块的例子:假设add.py是一个加两个数的模块。
# Addition Module
def add(a,b): #add two numbers 'a' and 'b'
c = a + b
return c
add.py
现在假设我们正在创建一个calc.py程序，我们需要一个函数来添加 2 个数字。我们可以简单地在calc.py中导入我们的add.py模块(作为导入添加)。
注意: 这两个文件应该在同一个目录下。
现在来调用add()方法，从模块 add.py 开始，我们在成功的将模块导入到程序中之后做→ ModuleName.MethodName。
>>> import add
>>> add.add(9,8)
>>> add.add(9.7,5)
17 14.7
python 的无限力量并没有就此结束。可以根据自己的方便和需要导入 python 模块。我们将讨论在您的系统中安装外部 python 模块的两种方法，它们是:
- 使用 pip
- 通过从第三方独立下载软件包。
使用 pip 安装软件包
pip是首选的安装程序。从 Python 2.7.9 开始，它默认包含在 Python 二进制安装程序中，即 Python 版本> 3.0 将预安装 pip 安装程序。
对于版本< 2.7.9 你必须手动安装 pip。要在这些版本中安装 pip，请遵循以下步骤:
-
对于 linux 的 Debian(Ubuntu/Kali 等)发行版，只需使用:
$ sudo apt-get install python-pip -
For Windows user:
从这里下载
get-pip.py。然后，从命令提示符运行它:python get-pip.py为此，您可能需要管理员命令提示符。
-
检查 pip 类型的正确安装:
pip -V
如果画中画的版本显示比你好就行了。现在，您可以使用 pip 下载 python 包了。要使用 pip 下载任何包:
pip install package_name
#Note: Use sudo if you are using linux as non-root user
例如:比如用 pip 安装名为 bs4 (美人汤)的包:
~$ sudo pip install bs4
有关 pip 安装的详细知识和进一步问题，请遵循官方文件→https://docs.python.org/2/installing/index.html
现在， Python 打包索引是一个开源许可包的公共存储库，可供其他 Python 用户使用。因此，有时需要的一些软件包不能直接使用 pip 下载。在这种情况下，您需要由第三方提供商下载并安装所需的软件包。
安装第三方 python 包
-
为此，下载压缩(tar.gz或)。zip )文件为所需的包。
-
解压压缩文件(要解压tar.gz文件在 linux 中使用，
tar -xvzf package_name.tar.gz)。 -
现在，使用转到提取的包目录。
cd package_name -
现在要安装软件包，只需在命令行
python setup.py install上运行它
下载第三方库的一些来源有:
https://github . com
https://pypi . python . org/pypi
解释和交互式 Python
原文：https://www.studytonight.com/network-programming-in-python/interpreted-and-interactive-python
让我们从理解 python 的解释本质开始。
解释 Python
与 C/C++等不同，Python 是一种解释的面向对象编程语言。解释意味着每次运行程序时，解释器都会检查代码中的错误，然后将指令解释成机器可读的字节码。
解释器是计算机语言的翻译器，它将给定的代码逐行翻译成机器可读的字节码。如果遇到任何错误，它会停止转换，直到错误被修复。不像 C 语言，那是一种编译的编程语言。编译器一次性翻译全部代码，而不是逐行翻译。这就是为什么在 C 语言中，所有的错误都只在编译时列出。
# Demonstrating interpreted python
print "\n\n----This line is correct----\n\n" #line1
print Hello #this is wrong #line2
在上图中，您可以看到第 1 行在语法上是正确的，因此成功执行。然而，在第 2 行中，我们有一个语法错误。因此，解释器在第 2 行处停止执行上述脚本。这在编译编程语言的情况下是无效的。
下图是一个 C++程序，虽然第 1 行和第 2 行是正确的，但是由于第 3 行的错误，程序报告了一个错误。这就是解释语言和编译语言的基本区别。
// Demonstrating Compiled language
#include<iostream>
using namespace std;
int main()
{
cout<
交互式 Python
Python 是交互式的。当输入 Python 语句，并在后面加上 Return 键(如果合适)时，结果将立即打印在屏幕的下一行。这在调试过程中特别有利。在交互操作模式下，Python 的使用方式类似于 Unix 命令行或终端。
交互式 Python 外壳看起来像:
交互式 Python 对调试非常有帮助。如果合适，它只返回>>>提示或语句的相应输出，如果语句不正确，则返回错误。这样，如果您有任何疑问，如:语法是否正确，您正在导入的模块是否存在或类似的问题，您可以使用 Python 交互模式在几秒钟内确定。
交互式 python 的图示如下所示:
套接字基础
原文：https://www.studytonight.com/network-programming-in-python/basics-of-sockets
到目前为止，您一定已经获得了关于网络和 python 的基本概念。如果您错过了最后几个教程，我们建议您在开始使用套接字之前仔细阅读它们。现在真正的乐趣开始于我们开始把这些东西混合在一起。那么，让我们从套接字开始，看看它们是什么，以及我们为什么使用它们。
为了理解什么是套接字，让我们从互联网连接开始。互联网连接基本上连接了互联网上的两个点，用于数据共享和其他东西。来自计算机 C1 的一个进程可以通过互联网连接与来自计算机 C2 的一个进程进行通信。它具有以下属性:
- 可靠:表示在连接两台电脑的线缆安全之前，数据会安全传输。
- 点对点:两点之间建立连接。
- 全双工:这意味着信息传输可以通过两种方式进行，即从客户端到服务器以及服务器同时(同时)到客户端。
插座是双向点对点通信通道的端点。给定一个互联网连接，比如客户端(浏览器)和服务器(比如 study now . com)之间的连接，我们将有两个套接字。一个Client Socket和一个Server Socket。
套接字作用于两个部分: IP 地址 + 端口号
含糊地说，当你点击将你带到“今夜研究”网站的链接时，你的浏览器做了如下事情:
#a socket object is created for communication
clientsocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# now connect to the web server on port 80
# - the normal http port
clientsocket.connect(("www.studytonight.com", 80))
这发生在客户端。当客户端尝试与服务器连接时，操作系统会为连接分配一个随机端口。这个随机端口被称为应急端口。在上图中，1300是源(客户端)机器上的一个快速端口。客户端套接字是短暂的，即一旦数据交换结束，它就会关闭。现在服务器上发生的事情与客户端有点不同。让我们看看:
serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
#bind the socket to a public host and a well-known port
serversocket.bind((socket.gethostname(), 80))
#become a server socket and listen for connections
serversocket.listen(5)
目前只关注Connect和Bind方法。
Connect 是客户端套接字用来启动与服务器的连接。该请求通过服务器套接字的绑定方法来实现。如果你对代码有问题，不要担心。每一点都将通过例子单独解释。
在结束之前，让我们看看客户机和服务器套接字之间的一些区别:
- 与客户端套接字不同，服务器套接字不是短暂的。例如:您可能需要 youtube.com 处理一个请求，但是 youtube.com 必须 24*7 处理来自全球用户的任何请求。
- 与客户端套接字使用快速端口进行连接不同，服务器套接字需要一个标准的或定义良好的端口进行连接，如:端口 80 用于正常的 HTTP 连接，端口 23 用于远程登录等。
Python 套接字——SOCK_STREAM和SOCK_DGRAM
原文：https://www.studytonight.com/network-programming-in-python/socket-methods
插座有两种类型:SOCK_STREAM和SOCK_DGRAM。下面我们对两种类型的插座进行比较。
| SOCK_STREAM | SOCK_DGRAM |
| 对于 TCP 协议 | 对于 UDP 协议 |
| 可靠的交付 | 不可靠的交货 |
| 保证数据包的正确排序 | 没有订单保证 |
| 面向连接 | 没有连接的概念 |
| 双向的 | 不是双向的 |
Python 中的套接字模块
要创建套接字，我们必须使用 Python 套接字模块中可用的socket.socket()函数，其一般语法如下:
S = socket.socket(socket_family, socket_type, protocol=0)
- socket_family :这不是
AF_UNIX就是AF_INET。在本教程中，我们只讨论 INET 套接字，因为它们至少占正在使用的套接字的 99%。 - 插座类型:这不是
SOCK_STREAM就是SOCK_DGRAM。 - 协议:这通常被忽略，默认为
0。
现在，如果你还记得的话，我们在上一节教程中也讨论过客户机-服务器套接字程序。现在，让我们深入了解该程序，并尝试理解所使用的术语和方法。
客户端套接字方法
以下是一些客户端套接字方法:
连接( )
连接到某个地址的远程套接字。一个地址格式(主机、端口)对用于AF_INET地址族。
服务器套接字方法
以下是一些服务器套接字方法:
绑定( )
此方法将套接字绑定到一个地址。地址的格式取决于上面提到的套接字家族(AF_INET)。
听(积压)
此方法侦听与套接字的连接。积压是在拒绝连接之前必须侦听的排队连接的最大数量。
接受( )
此方法用于接受连接。套接字必须绑定到一个地址并侦听连接。返回值是一个pair(conn, address)，其中 conn 是一个新的套接字对象，可用于在该连接上发送和接收数据，地址是绑定到连接另一端套接字的地址。
有关方法的详细视图，请参考文件:https://docs.python.org/2/library/socket.htmlT3
少数通用套接字方法
对于下面定义的套接字对象，
s = socket.socket(socket_family, socket_type, protocol=0)
| 套接字方法 | UDP 套接字方法 |
| s.recv() →接收 TCP 消息 | s.recvfrom() →接收 UDP 消息 |
| s.send() →传输 TCP 消息 | s.sendto() →传输 UDP 消息 |
一些基本的套接字方法
close()此方法用于关闭插座连接。gethostname()这个方法返回一个包含 python 解释器当前正在执行的机器的主机名的字符串。例如:localhost。gethostbyname()如果想知道当前机器的 IP 地址，可以使用gethostbyname(gethostname())。
使用 TCP 套接字
原文：https://www.studytonight.com/network-programming-in-python/working-with-tcp-sockets
到现在为止，你们一定很熟悉之前的教程中描述的 socket 方法。现在我们将在一个简单的客户端-服务器程序中使用这些方法。
简单服务器程序
#!/usr/bin/python
#This is tcp_server.py script
import socket #line 1: Import socket module
s = socket.socket() #line 2: create a socket object
host = socket.gethostname() #line 3: Get current machine name
port = 9999 #line 4: Get port number for connection
s.bind((host,port)) #line 5: bind with the address
print "Waiting for connection..."
s.listen(5) #line 6: listen for connections
while True:
conn,addr = s.accept() #line 7: connect and accept from client
print 'Got Connection from', addr
conn.send('Server Saying Hi')
conn.close() #line 8: Close the connection
这个脚本现在什么也做不了。它等待客户端在指定的端口连接。如果我们现在在没有客户端的情况下运行这个脚本，它将等待连接，
同样，您访问的每个网站都有一个托管它的服务器，它总是等待客户端连接。现在让我们创建一个client.py程序，并尝试与我们的server.py连接。
简单客户端程序
下面是client.py程序。客户端尝试连接到服务器的端口9999(定义良好的端口)。代码行s.connect((host, port))打开到端口9999上主机名的 TCP 连接。
#!/usr/bin/python
#This is tcp_client.py script
import socket
s = socket.socket()
host = socket.gethostname() # Get current machine name
port = 9999 # Client wants to connect to server's
# port number 9999
s.connect((host,port))
print s.recv(1024) # 1024 is bufsize or max amount
# of data to be received at once
s.close()
现在，先运行server.py脚本(如果你还没有的话)，然后运行client.py脚本。如果一切顺利，您将看到如下输出:
注:这里我们是在同一台机器上运行客户端和服务器，但是现实生活场景肯定和这个不一样，但是很相似。
请注意，执行后终止，但server.py仍在运行。这也是真实场景中发生的事情。完成您的请求后，今夜研究服务器将继续全天候运行，为其他用户提供服务。
执行client.py后，服务器显示:从(' 192.168.43，217 '，43402) 获得连接。这里的端口43402是随机的，或者是操作系统分配给客户端的临时端口。
程序流程图
使用 UDP 套接字
原文：https://www.studytonight.com/network-programming-in-python/working-with-udp-sockets
嗯，在插座的基本教程中，你可能有一个困惑，我们将插座定义为:
S = socket.socket(socket_family, socket_type, protocol = 0)
但是，在上一篇关于 TCP 套接字的教程中，我们仅仅通过编写S=socket.socket()来定义 TCP 套接字，也就是说没有提供 socket_family 和 socket_type 。如果不提插座 _ 家族和插座 _ 类型，那么默认为TCP。所以，如果我们想创建一个 UDP 套接字，我们必须明确指定 socket_family 和 socket_type 。
对于 UDP 套接字，我们定义:
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
并且，如果您明确想要定义一个 TCP 套接字:
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
简单的 UDP 服务器程序
这是udpserver.py的剧本:
#!usr/bin/python
import socket
sock = socket.socket(socket.AF_INET,socket.SOCK_DGRAM) # For UDP
udp_host = socket.gethostname() # Host IP
udp_port = 12345 # specified port to connect
#print type(sock) ============> 'type' can be used to see type
# of any variable ('sock' here)
sock.bind((udp_host,udp_port))
while True:
print "Waiting for client..."
data,addr = sock.recvfrom(1024) #receive data from client
print "Received Messages:",data," from",addr
上述脚本的输出如下。保持运行，然后启动client.py模块。
简单 UDP 客户端
这是udpclient.py的剧本:
#!usr/bin/python
import socket
sock = socket.socket(socket.AF_INET,socket.SOCK_DGRAM) # For UDP
udp_host = socket.gethostname() # Host IP
udp_port = 12345 # specified port to connect
msg = "Hello Python!"
print "UDP target IP:", udp_host
print "UDP target Port:", udp_port
sock.sendto(msg,(udp_host,udp_port)) # Sending message to UDP server
我们的udpserver.py已经启动并运行，所以现在我们尝试运行udpclient.py脚本，
以下是客户端发送请求后我们的服务器发生的情况:
程序流程图
因此，在本教程和最后一个教程中，我们已经学习了如何使用 TCP 套接字和 UDP 套接字建立成功的客户端-服务器连接。
通过 TCP 套接字处理接收的客户端数据
原文：https://www.studytonight.com/network-programming-in-python/handling-received-data
现在我们将有一个例子，其中客户端向服务器发送一些数据，服务器按照指示处理数据。我们将看到两个不同的用例:
- 回应客户端-服务器程序
- 通过添加来处理接收到的数据
简单的客户端-服务器程序
在这个程序中，服务器只是回应从客户端接收到的数据。你一定见过一些门户网站，当你访问它们的页面时，它们会回显(打印)你的详细信息。首先，我们创建服务器。我们从创建一个 TCP 套接字对象开始。我们将套接字绑定到本地机器上的给定端口。在监听阶段，我们使用listen()方法的 backlog 参数确保监听队列中的多个客户端。最后，我们等待客户端连接并向服务器发送一些数据。当接收到数据时，服务器将数据回传给客户端。
echo_server.py
#!usr/bin/python
import socket
host = socket.gethostname()
port = 12345
s = socket.socket() # TCP socket object
s.bind((host,port))
s.listen(5)
print "Waiting for client..."
conn,addr = s.accept() # Accept connection when client connects
print "Connected by ", addr
while True:
data = conn.recv(1024) # Receive client data
if not data: break # exit from loop if no data
conn.sendall(data) # Send the received data back to client
conn.close()
上面的代码执行如下:
echo _ client . py
#!usr/bin/python
import socket
host = socket.gethostname()
port = 12345
s = socket.socket() # TCP socket object
s.connect((host,port))
s.sendall('This will be sent to server') # Send This message to server
data = s.recv(1024) # Now, receive the echoed
# data from server
print data # Print received(echoed) data
s.close() # close the connection
现在，由于服务器已经启动并运行，我们应该运行我们的echo_client.py
对客户端-服务器程序中的数据执行操作
在这个程序中，我们将向服务器发送信息，服务器将汇总数据并发回给客户端。但是，这有什么新的？
你会看到，当我们发送两个数字到服务器进行加法运算时，我们不是以两个整数的形式发送，而是以字符串的形式发送数据。比方说，我们想加上 4 和 5，所以我们将 4 和 5 作为一个字符串'4,5'发送。注意 4 到 5 之间的逗号,。这充当两个整数的分隔符。
在服务器上，当我们接收到字符串'4,5'时，我们将从字符串中提取整数，将它们相加，然后通过将相加结果转换成字符串将结果发送回客户端。
add_server.py
#!usr/bin/python
import socket
host = socket.gethostname()
port = 12345
s = socket.socket() # TCP socket object
s.bind((host,port))
s.listen(5)
conn, addr = s.accept()
print "Connected by ", addr
while True:
data=conn.recv(1024)
# Split the received string using ','
# as separator and store in list 'd'
d = data.split(",")
# add the content after converting to 'int'
data_add = int(d[0]) +int(d[1])
conn.sendall(str(data_add)) # Send added data as string
# String conversion is MUST!
conn.close()
add_client.py
#!usr/bin/python
import socket
host = socket.gethostname()
port = 12345
a = str(raw_input('Enter first number: ')) # Enter the numbers
b = str(raw_input('Enter second number: ')) # to be added
c = a+','+b # Generate a string from numbers
print "Sending string {0} to server" .format(c)
s = socket.socket()
s.connect((host,port))
s.sendall(c) # Send string 'c' to server
data = s.recv(1024) # receive server response
print int(data) # convert received dat to 'int'
s.close() #Close the Connection
现在，先运行add_server.py，然后运行add_client.py
输出:
阻塞和非阻塞套接字输入/输出
原文：https://www.studytonight.com/network-programming-in-python/blocking-and-nonblocking-socket-io
在客户端服务器应用中，当客户端向服务器发出请求时，服务器会处理该请求并发回响应。为此，客户端和服务器首先需要通过套接字(TCP 或 UDP)建立相互连接。在最后几个教程中，我们也看到了，客户端如何以请求的形式向服务器发送数据，服务器又如何对其进行操作，然后将响应发送回客户端。
阻塞套接字输入/输出
默认情况下，TCP 套接字处于阻塞模式。这意味着在某些特定操作完成之前，控件不会返回到程序中。
例如，如果您调用connect()方法，连接会阻塞您的程序，直到操作完成。在许多情况下，我们不想让我们的程序永远等待。
再举一个例子，当我们编写一个连接到 web 服务器的 web 浏览器客户端时，我们应该考虑一个停止功能，它可以在其操作的中途取消一个活动的连接过程。这可以通过将插座置于非阻塞模式来实现。
无阻塞插座输入输出
我们可以调用setblocking(1)设置阻塞或setblocking(0)取消阻塞。让我们借助一个例子来理解它。首先，我们来考虑一个阻塞插座:
block_client.py
#!usr/bin/python
import socket
sock = socket.socket()
host = socket.gethostname()
sock.connect((host, 12345))
sock.setblocking(1)
# Or simply omit this line as by default TCP sockets
# are in blocking mode
data = "Hello Python\n" *10*1024*1024 # Huge amount of data to be sent
assert sock.send(data) # Send data till true
block_server.py
#!usr/bin/python
#block_server.py
import socket
s = socket.socket()
host = socket.gethostname()
port = 12345
s.bind((host,port))
s.listen(5)
while True:
conn, addr = s.accept() # accept the connection
data = conn.recv(1024)
while data: # till data is coming
print data
data = conn.recv(1024)
print "All Data Received" # Will execute when all data is received
conn.close()
break
现在，先运行block_server.py，然后运行block_client.py。你会注意到服务器一直在打印你好 Python 。这将一直持续下去，直到所有的数据都发送出去。在上面的代码中所有收到的数据这一行不会被打印很长时间，因为客户端需要发送大量的字符串，这需要时间，在此之前套接字输入输出会被阻塞。
这是怎么回事？send()方法会尝试将所有数据传输到服务器，而写缓冲区会被填满。内核将使进程休眠，直到缓冲区中的数据被传输到目的地，并且缓冲区再次为空。当缓冲区变空时，内核将再次唤醒进程，以获取要传输的下一个数据块。简而言之，您的代码将会阻塞，并且不会让其他任何事情继续进行。
现在考虑一个无阻塞插座
#!usr/bin/python
# non_blocking_client.py
import socket
sock = socket.socket()
host = socket.gethostname()
sock.connect((host, 12345))
sock.setblocking(0) # Now setting to non-blocking mode
data = "Hello Python\n" *10*1024*1024 # Huge amount of data to be sent
assert sock.send(data) # Send data till true
现在，如果我们运行non_blocking_client.py，你会注意到程序会运行一小段时间，它会打印最后一行“收到的所有数据”并很快终止。
这是怎么回事？这里客户端没有发送所有数据。当我们通过调用setblocking(0)使一个套接字不阻塞时，它永远不会等待操作完成。所以当我们调用send()方法时，它会将尽可能多的数据放入缓冲区并返回。
通过 TSL/SSL 保护套接字
原文：https://www.studytonight.com/network-programming-in-python/securing-sockets
在本教程中，我们将了解通过 TSL/SSL 保护套接字的概念。
TSL/SSL
在深入 TSL 和 SSL 之前，首先要了解什么是加密。根据维基百科，“加密是以只有授权方才能访问的方式对消息或信息进行编码的过程。在加密方案中，预期的信息或消息(称为明文)使用加密算法进行加密，生成只有解密后才能读取的密文。”
加密是确保报文/数据机密性所必需的。
TLS(传输层安全性)和 SSL(安全套接字层)是在数据通过不安全网络发送的情况下，在应用和服务器之间提供数据加密和身份验证的协议。
SSL 和 TLS 这两个术语经常互换使用，但其中一个实际上是另一个的前身——SSL 3.0是 TLS 1.0 的基础，因此，后者有时被称为 SSL 3.1 。
SSL 握手
要进行 SSL/TLS 握手，系统管理员必须具备:
- 私钥:用于数据加密。
- 证书:保证委托人真实性。
虽然 SSL 握手有点复杂。我们将用最简单的方式来解释它。
从网络分析开始
使用套接字构建自定义端口扫描器
原文：https://www.studytonight.com/network-programming-in-python/building-a-port-scanner
到目前为止，你一定已经对套接字有了足够的了解。现在，是时候从我们目前所学的一些实际应用开始了。从这一课开始，我们将强调使用 Python 的网络安全。
什么是端口扫描器？
嗯，考虑一种情况，你必须进入平房。你会怎么做？显而易见的答案是寻找通向平房的门。如果门被锁上了怎么办？嗯，在这种情况下，你将扫描房子的每一个其他的门和窗户，你可能会找到进入房子的路。
现在，如果你还记得本系列第二篇教程中关于端口的内容，你可能还记得端口就像系统中的门/窗。因此，进入系统的基本步骤是扫描系统的开放端口。因此，总是建议关闭系统(服务器)不必要的端口，以避免任何意外发生。对于网络服务器端口80默认为打开，用于 HTTP 请求和响应。
在本课中，我们将学习如何制作一个初级端口扫描仪，使用它可以扫描任何 web 服务的开放端口。
port_scanner.py
#!usr/bin/python
#port_scanner.py
import socket
t_host = str(raw_input("Enter the host to be scanned: ")) # Target Host, www.example.com
t_ip = socket.gethostbyname(t_host) # Resolve t_host to IPv4 address
print t_ip # Print the IP address
while 1:
t_port = int(raw_input("Enter the port: ")) # Enter the port to be scanned
try:
sock = socket.socket()
res = sock.connect((t_ip, t_port))
print "Port {}: Open" .format(t_port)
sock.close()
except:
print "Port {}: Closed" .format(t_port)
print "Port Scanning complete"
当你运行上述程序时，它会提示你输入一个主机名(www.example.com)，然后它会继续询问你想要扫描的端口号。
要终止程序，请按
Ctrl + C。
输出:
在 Python 中使用 Nmap 端口扫描器
原文：https://www.studytonight.com/network-programming-in-python/integrating-port-scanner-with-nmap
在本教程中，我们将学习如何将 Nmap 安全扫描仪与我们的 Post 扫描仪程序集成。
什么是 Nmap？
Nmap(Network Mapper) 是一款安全扫描器，最初由戈登·里昂(也以笔名 Fyodor Vaskovich 为人所知)编写，用于发现计算机网络上的主机和服务，从而构建网络地图。为了实现其目标，Nmap 向目标主机发送特制的数据包，然后分析它们的响应。
一些有用的 Nmap 功能包括:
- 主机发现:这使得能够识别任何网络上的主机。例如，列出响应 TCP 和/或 ICMP 请求或打开特定端口的主机。
- 端口扫描:枚举(逐一计数并列出)目标主机上所有打开的端口。
- 版本检测:查询远程设备上的网络服务，确定应用名称和版本号。
- OS 检测:确定网络设备的操作系统和硬件特性。
- 与目标的可脚本化交互:使用 Nmap 脚本引擎(NSE)和 Lua 编程语言，我们可以轻松编写 sripts 在网络设备上执行操作。
虽然 Nmap 是命令行界面，但是你可以下载并安装 Nmap 的 GUI 界面，称为 zenmap 。
以上是命令行的截图，当你运行nmap命令时，列出了目标规范和主机发现、扫描技术等所有可用选项，以供你参考。如果您想在机器上安装 nmap，那么:
- 运行，
sudo apt-get install nmap为 Linux。 - 对于 Windows 和 Mac OS X，下载并安装 Nmap:https://nmap.org/download.html
我们在上一篇教程中编写的端口扫描器提供了一个执行 TCP 连接扫描的快速脚本。这是非常有限的，因为我们可能需要执行额外扫描类型的能力，例如由 Nmap 工具包提供的ACK、RST、FIN或SYN-ACK扫描。Nmap 提供了相当广泛的功能。这就引出了一个问题，为什么不直接使用 Nmap 呢？为什么要费心为端口扫描器编写脚本？
Nmap 是用C****LUA编程语言编写的，很容易集成到 Python 中。Nmap 产生基于 XML 的输出，这为我们提供了从 Python 脚本中利用 Nmap 全部功能的能力。所以我们的端口扫描器脚本只是外壳，在里面我们现在将使用 Nmap。
因此，在我们开始使用 nmap 之前，让我们首先安装 Nmap 模块:
- 使用命令，
pip install python-nmap - 或者从这里下载软件包安装。
在 Python 脚本中使用 Nmap
以下是可以用来成功扫描所有端口并以 JSON 格式返回结果的命令。
>>> import nmap
>>> nmScan = nmap.PortScanner()
>>>
>>> nmScan.scan('127.0.0.1', '21-443')
我们都知道，import nmap是干什么的，就是把nmap模块导入到我们的 python 脚本中。然后我们初始化 Nmap 端口扫描器来扫描本地网络上的端口。
第三行，即nmScan.scan('127.0.0.1', '21-443')返回在本地家庭(127.0.0.1)网络上执行的 21 到 443 之间端口号的扫描字典。您还可以提供任何远程服务器的 IP 地址，以扫描可用的端口。
如果你想使用命令行运行 Nmap 命令，你可以通过使用command_line()方法很容易地得到相当于nmScan.scan('127.0.0.1', '22-443')行代码的命令行，该方法读取scan方法调用并生成一个相当于命令行运行的命令。
>>> import nmap
>>> nmScan = nmap.PortScanner()
>>>
>>> nmScan.scan('127.0.0.1', '21-443')
>>> nmScan.command_line()
nmap -oX - -p 21-443 -sV 127.0.0.1
更多 Nmap 方法
现在，让我们看看更多的命令:
>>> nmScan.scaninfo()
{'tcp': {'services': '22-443', 'method': 'connect'}}
>>> nmScan.all_hosts()
['127.0.0.1']
>>> nmScan['127.0.0.1'].hostname()
'localhost'
>>> nmScan['127.0.0.1'].state()
'up'
>>> nmScan['127.0.0.1'].all_protocols()
['tcp']
>>> nmScan['127.0.0.1']['tcp'].keys()
[80, 25, 443, 22, 111]
>>> nmScan['127.0.0.1'].has_tcp(22)
True
>>> nmScan['127.0.0.1'].has_tcp(23)
False
>>> nmScan['127.0.0.1']['tcp'][22]
{'state': 'open', 'reason': 'syn-ack', 'name': 'ssh'}
>>> nmScan['127.0.0.1'].tcp(22)
{'state': 'open', 'reason': 'syn-ack', 'name': 'ssh'}
让我们谈谈上面使用的几种方法。方法all_protocols()返回当前被扫描网络的协议。方法keys()返回指定范围内所有可用的活动端口。
当我们在本地计算机上使用keys()方法时，只返回端口80，因为指定范围内没有其他端口处于活动状态。
注意:在最后一个命令中出现错误。这是因为在命令nmScan['127.0.0.1']['tcp'].keys()中，获得的唯一键值是[80]，而在最后一行中，我们指定了[22]。
下面我们有一个简单的程序，用于扫描和列出给定主机的端口:
import nmap
# initialize the port scanner
nmScan = nmap.PortScanner()
# scan localhost for ports in range 21-443
nmScan.scan('127.0.0.1', '21-443')
# run a loop to print all the found result about the ports
for host in nmScan.all_hosts():
print('Host : %s (%s)' % (host, nmScan[host].hostname()))
print('State : %s' % nmScan[host].state())
for proto in nmScan[host].all_protocols():
print('----------')
print('Protocol : %s' % proto)
lport = nmScan[host][proto].keys()
lport.sort()
for port in lport:
print ('port : %s\tstate : %s' % (port, nmScan[host][proto][port]['state'])
主机:127.0.0.1 (localhost)状态:up - Protocol : tcp 端口:22 状态:开放端口:25 状态:开放端口:80 状态:开放端口:111 状态:开放端口:443 状态:开放
使用命令行输入的 Nmap 端口扫描脚本
原文：https://www.studytonight.com/network-programming-in-python/input-from-command-line
在本教程中，我们将学习在运行脚本时从命令行获取输入，而不是硬编码脚本中的值。我们将研究从命令行获取输入的两种不同方式:
- 使用参数解析
- 使用选择
使用argparse解析参数
scan_nmap.py
#!usr/bin/evn python
#Integrating nmap
import nmap
import argparse
# defining nmap scan function with arguments
# tgtHost will hold the host value and tgtPort will hold the port value
def nmapScan(tgtHost, tgtPort):
nmscan = nmap.PortScanner()
nmscan.scan(tgtHost, tgtPort)
state = nmscan[tgt_host]['tcp'][int(tgtPort)]['state']
print " [*] " + tgtHost + " tcp/"+tgtPort + " "+state
def main():
# setup argument parsing
parser = argparse.ArgumentParser(description='Command line Argument passing example')
# reading and storing the value for host
parser.add_argument('--host', action = "store", dest = "host",
required=True)
# reading and storing the value for port
parser.add_argument('--port', action = "store", dest = "port",
type = int, required = True)
given_args = parser.parse_args()
tgtHost = given_args.host
tgtPort = given_args.port
#check if host and port values are not null
if (tgtHost == None) | (tgtPort == None):
print parser.usage
exit(0)
else:
print "Scanning: " + tgtHost + "-" + str(tgtPort)
# calling the nmapScan function with the provided values
nmapScan(tgtHost, str(tgtPort))
if __name__ == '__main__':
main()
在上面的脚本中，nmapScan是一个简单的方法，它接受两个参数，主机名/地址和您想要扫描的端口号。
在main()函数中，我们使用argparse来解析脚本运行时提供的参数。add_argument()解析参数并保存它们的值。
运行此程序时，您一次只能指定一个端口，如:
python scan_nmap.py --host=127.0.0.1 --port=21
[*] 127.0.0.1 tcp/21 关闭
因此，如果您想要扫描特定主机的 10 个端口，您需要运行该脚本 10 次。我们不想那样！所以，现在我们将看到一种不同的方式来实现这一点。在这里，我们将端口作为一个由逗号分隔的字符串传递，如‘21，80，23’(带引号)。
使用optparse解析参数
扫描仪. py
#!usr/bin/evn python
#Integrating nmap
import nmap
import optparse
# defining nmap scan function with arguments
# tgtHost will hold the host value and tgtPort will hold the port value
def nmapScan(tgtHost, tgtPort):
nmscan = nmap.PortScanner()
nmscan.scan(tgtHost, tgtPort)
state = nmscan[tgt_host]['tcp'][int(tgtPort)]['state']
print " [*] " + tgtHost + " tcp/"+tgtPort + " "+state
def main():
# printing Help to inform How to use this script
parser = optparse.OptionParser('Script Usage:'+'-H <target host> -p <target port>')
parser.add_option('-H', dest='tgt_Host', type='string',
help='specify target host')
parser.add_option('-p', dest='tgtPort', type='string',
help='specify target port[s] separated by comma')
(options,args) = parser.parse_args()
tgtHost = options.tgtHost
tgtPorts = str(options.tgtPort)
print tgtPorts
if (tgtHost == None) | (tgtPorts[0] == None):
print parser.usage
exit(0)
ports = tgtPorts.strip("'").split(',')
for tgtPort in ports:
print tgtHost+ " " +tgtPort
nmapScan(tgtHost, tgtPort)
if __name__ == '__main__':
main()
您会看到optparse和argparse在脚本运行时传递参数的风格方面也有所不同。
除此之外，我们可以使用argparse将逗号分隔的端口列表作为输入，然后运行for循环来扫描每个端口。
但是我们在这里的动机是给你提供两种不同的方式，去做同样的事情。结果现在知道了，怎么用optparse和argparse。使用这些，您甚至可以为各种操作编写简单的 python 脚本。
要运行上述脚本:
python scanner.py -H 127.0.0.1 -p '21,23,80'
[] 127.0.0.1 tcp/21 关闭[] 127.0.0.1 tcp/23 关闭[*] 127.0.0.1 tcp/80 打开
什么是横幅抓取？
原文：https://www.studytonight.com/network-programming-in-python/banner-grabbing
一条横幅就像是从主机收到的一条短信。它包含主机上运行的服务信息以及端口信息。
根据维基百科， 横幅抓取是一种用于收集网络上的计算机系统及其开放端口上运行的服务的信息的技术。这种技术通常被系统管理员用来扫描网络以检查所有服务正在运行等。
由于我们已经探索了如何扫描系统中的开放端口(最后 2 个教程)，现在是时候仔细看看这些端口上运行的是什么服务了。一些众所周知的端口有:
- 20/21 : FTP
- 22 : SSH(安全壳)
- 23 : Telnet
- 25 : SMTP
- 80 : HTTP
- 156 : SQL Server
- 443:HTTPS
你知道吗，如果一个系统不必要的端口是开放的，这反映了一个系统漏洞，任何黑客都有可能破坏这个漏洞。但是，仅仅知道可用的端口和运行的服务是不够的。你必须知道服务运行的细节，比如主机运行的服务器版本，MySQL 版本等等。
横幅抓取是如何工作的？
假设你想和一个说英语的人交流。所以为了有一个流畅的对话，你必须用英语说，否则对方应该说你说的语言。但是，既然你是想发起对话的人，那么你必须懂英语。
说到这里，你是客户，为了和服务器沟通，你必须说它的语言，而不是简单的英语。在我们浏览互联网的日常生活中，我们的网络浏览器为我们完成了这项工作。我们简单地用我们的语言进行查询，我们的浏览器将这个查询翻译成服务器可以理解的形式。这在技术上被称为 HTTP 请求和响应。
因此，为了执行横幅抓取，我们将以服务器理解的形式与它交谈。因此，下面我们编写了一个使用 socket 发起与服务器通信的程序。
使用套接字编程抓取横幅
banner.py
#!usr/bin/env python
# banner.py
import socket
sock = socket.socket(socket.AF_INET,socket.SOCK_STREAM) #TCP
t_host = str(raw_input("Enter the host name: "))
t_port = int(raw_input("Enter Port: "))
sock.connect((t_host,t_port))
sock.send('GET HTTP/1.1 \r\n')
ret = sock.recv(1024)
print '[+]' + str(ret)
注 : 有很多开源工具可以更高效地完成同样的工作。但这不是本教程系列的重点。这类工具就像黑盒，即你给出输入，期待输出。内部机制你不知道。这个系列的重点是让你意识到场景背后的所有东西。
之后你将输入一个主机名(www.example.com)和端口作为80。您将收到服务器的回复，该回复将运行服务器版本以及更多类似如下的信息:
HTTP/1.1 200 OK
Date: Sat, 1 May 2010 21:10:40 EST
Server: Apache/2.0.46 (Unix) (Red Hat/Linux)
Last-Modified: Wed, 16 Mar 2010 11:20:14 PST
ETag: "1986-69b-123abc46"
Accept-Ranges: bytes
Content-Length: 1110
Connection: close
Content-Type: text/html
现在，服务器的版本是已知的，你可以上网查找服务器版本是否容易受到攻击。
使用 Nmap 抓取横幅
我们已经学习了如何使用 Nmap 进行端口扫描，这里有一个简单的命令，可以使用 Nmap 进行横幅抓取。
下面的命令将扫描主机上所有打开的端口。
nmap -sV –script=banner 127.0.0.1
在上面的命令中，用要扫描的主机的 IP 地址替换 127.0.0.1。
如果您只想获取与特定端口相关的横幅(信息)，请运行以下命令:
nmap -Pn -p 80 -sV –script=banner 127.0.0.1
我们知道 http 服务运行在端口80上，因此上面的命令将抓取与 http 服务和版本相关的信息。
Wireshark 网络流量分析
原文：https://www.studytonight.com/network-programming-in-python/introduction-to-wireshark
在开始讨论 Wireshark 之前，让我们先了解一下什么是网络流量，以及如何计算网络流量。
什么是网络流量？
网络流量或网络数据是在任何给定时间点通过网络传输的数据(数据包)量。
Traffic volume = Traffic Intensity * Time
那么，网络流量是怎样的:
上面是一张截图，显示了网络上随数据包一起发送的所有信息。它包括以下几个信息:
- 时间:捕获数据包的时间。
- 来源:数据包来源。
- 目的地:数据包最终到达的接收器。
- 协议:数据包在途中遵循的互联网协议(或规则集)类型，如:
TCP、UDP、SMTP、ARP等。 - 信息:数据包包含的信息。一般来说，信息被加密的原因很明显。但在某些情况下，它也是未加密的，但这是罕见的。
什么是 Wireshark？
根据维基百科“Wireshark 是一个免费的开源数据包分析器。它用于网络故障排除、分析、软件和通信协议开发以及教育。”
基本上，Wireshark 是一个分析网络流量的开源工具，或者简单地说，Wireshark 从局域网线路、实时网络连接或从已经捕获的数据包文件中读取数据。实时数据可以从不同类型的网络中读取，包括以太网、IEEE 802.11、PPP 和环回。
我们可以为捕获的流量创建一个tcpdump文件。Wireshark 允许您以多种扩展名保存文件，但出于我们的目的，我们将使用.pcap扩展名。这是最广泛使用的格式。
使用 Wireshark 捕获的网络流量
Wireshark 数据包分析
原文：https://www.studytonight.com/network-programming-in-python/using-wireshark
在我们开始使用 wireshark 之前，让我们先安装它。为 Linux 平台安装 wireshark 超级容易。只需运行以下命令:
sudo apt-get install wireshark
对于 Windows 用户，你需要从这里下载 wireshark，然后安装。
现在，一旦我们成功安装了 wireshark，我们将使用它。启动 Wireshark 后，首先您需要选择您想要捕获无线、以太网等流量的接口。
如果您不确定您的界面，只需在命令行中键入ifconfig(【窗口的 T1】)并查看您当前正在使用什么界面来浏览网页。选择界面后，点击工具栏上的采集数据包按钮。
现在，当您单击捕获按钮时，您将在 Wireshark 仪表板中看到随机的数据泛滥。这是你的网络流量。过滤流量的一些基本方法:
- 要过滤来自任何特定 IP 地址的流量，请在中键入:
ip.addr == 'xxx.xx.xx.xx'应用显示过滤器字段。 - 要过滤特定协议的流量，如
TCP、UDP、SMTP、ARP、DNS请求等，只需在应用显示过滤器字段中键入协议名称。
按 IP 地址过滤
按协议名称过滤
将捕获的数据保存在 Wireshark 上
您可以使用以下步骤保存捕获的交通数据:
- 点击停止按钮，停止数据包捕获。
- 转到，文件→另存为→文件名. pcap
注意:本教程以.pcap格式保存文件。
使用dpkt库分析网络流量
原文：https://www.studytonight.com/network-programming-in-python/analyzing-network-traffic
我们将使用dpkt库来分析网络流量。dpkt是一个 python 模块，用于快速、简单的数据包创建/解析，并定义了基本的 TCP/IP 协议。为了使用dpkt你首先需要安装它。
安装dpkt模块
sudo pip install dpkt
注:如果以 root 用户身份登录，可以省略上面命令中的sudo。
在本课中，我们将使用 python 代码从保存了 Workshire 流量数据的.pcap文件中提取网络上数据包的源 IP 和目的 IP 地址。将捕获的 pcap 文件保存在某个位置(比如桌面)后。运行以下代码:
#!usr/bin/env python
# this code prints Source and Destination IP from the given 'pcap' file
import dpkt
import socket
def printPcap(pcap):
for (ts,buf) in pcap:
try:
eth = dpkt.ethernet.Ethernet(buf)
ip = eth.data
# read the source IP in src
src = socket.inet_ntoa(ip.src)
# read the destination IP in dst
dst = socket.inet_ntoa(ip.dst)
# Print the source and destination IP
print 'Source: ' +src+ ' Destination: ' +dst
except:
pass
def main():
# Open pcap file for reading
f = open('/home/codeplay/Desktop/first.pcap')
#pass the file argument to the pcap.Reader function
pcap = dpkt.pcap.Reader(f)
printPcap(pcap)
if __name__ == '__main__':
main()
在上面的代码中，方法printPcap()、ts和buf分别是时间戳和缓冲区。你可能已经注意到插座方法inet_ntoa和inet_aton。inet_aton将 32 位压缩 IPv4 地址(长度为四个字符的字符串)转换为其标准的四点字符串表示形式(例如，123.45.67.89)。
输出:
scapy 简介
原文：https://www.studytonight.com/network-programming-in-python/introduction-to-scapy
在上一个教程之后，你一定已经对使用dpkt模块可以做什么有了足够的了解。在本课中，我们将了解另一个 python 模块，它允许我们发送、嗅探、剖析和伪造网络数据包。这种能力允许构建能够探测、扫描或攻击网络的工具。
我们为什么要用scapy？
你可能会想，既然已经有了dpkt模块，为什么还要用scapy。他们不是在做同样的事情吗！不完全是，事实是scapy为我们提供了比任何其他工具或模块更多的功能。
scapy除了基本的嗅探网络数据包的用法外，还执行其他大部分其他工具都做不到的任务，比如发送无效帧、注入自己的 802.11 帧、组合技术(VLAN 跳频+ ARP 缓存中毒、WEP 加密通道上的 VOIP 解码等。)等。
802.11 帧基本上是无线帧包，不能使用dpkt库操控。
所以来吧，让我们不再浪费时间，安装scapy:
sudo pip install scapy
或者下载软件包并安装，请点击此处链接。
点火(运行)scapy
-
如果您正在运行终端会话(Mac OSx 用户)，或者您是 linux 用户，则:
$ sudo scapy欢迎来到 Scapy (2.0.1-dev)> > >
-
如果您是 Windows 用户，则:
C:\>scapy信息:内核不支持 IPv6 警告:找不到 IPv6 目的地的路由::(没有默认路由？)欢迎来到 Scapy (2.0.1-dev)> > >
如果您没有安装所有可选软件包，scapy 将通知您某些功能将不可用:
信息:无法导入 python gnuplot 包装。无法策划。信息:无法导入 PyX。无法使用 psdump()或 pdfdump()。
读取pcap文件
您可以从一个pcap文件中读取数据包，并将其写入另一个pcap文件。
>>> a = rdpcap("/home/ntal8/Desktop/bkp_pcap/rawcap.pcap")
>>> a
<rawcap.pcap: tcp:749="" udp:134="" icmp:0="" other:2=""></rawcap.pcap:>
scapy特征一瞥
-
TCP Traceroute: Unlike other traceroute programs, who wait for each node to reply before going to the next,
scapysends all the packets at the same time.
最后一行实际上是函数的结果:traceroute 结果对象和未应答数据包的数据包列表。
-
TCP Port Scanning: Send a
TCP SYNon each port. Wait for aSYN-ACKor anRSTor anICMPerror.>>> res,unans = sr( IP(dst = "target") ... /TCP(flags="S", dport=(1,1024)) )可能的结果可视化:开放端口
>>> res.nsummary( lfilter=lambda (s,r): (r.haslayer(TCP) and (r.getlayer(TCP).flags & 2)) )
要了解更多关于scapy的功能和特点，请访问 scapy 的官方文档。
实际应用
是时候干活了
原文：https://www.studytonight.com/network-programming-in-python/apply-your-knowledge
自从我们第一次开始学习网络编程以来，我们已经取得了很大的进步。我们现在非常了解套接字、TCP 和 UDP 协议、端口扫描仪、Nmap模块、横幅抓取、dpkt模块、监控网络流量和数据包、scapy模块等等。
网络和安全是两个密切相关的概念，因为一旦你知道如何深入访问网络，那么你就开始意识到安全的缺陷，这些缺陷是公开的，没有被注意到。
网络与安全
到目前为止，我们已经了解了如何从主机网络获取横幅信息，也知道如何拦截和嗅探通过网络传输的网络数据包，因此，如果我们能够访问这些信息，我们可以轻松获得与任何主机相关的许多重要(和关键)信息。
但我们并没有认识到所有这些都是破坏性的，相反，我们认识到这一点是为了更好地理解网络以及如何保护它们。
不，我们不会对任何人使用任何日志文件，但是如果我们可以呢？
对网络有一些了解，并且能够编写程序来访问网络，你是不是已经感觉自己像黑客或网络安全工程师了。
一些很酷的应用
从下一个教程开始，我们将学习一些很酷的技巧来从任何主机提取信息，考虑到它是可以通过网络访问的。
我们将学习如何从 PDF 文件中提取 Met 信息，在这里我们将编写一个小脚本来提取信息。我们还将学习什么是刮网？以及我们如何抓取任何网站来提取数据。
我们也会考察一些社交网站的 API，尤其是脸书，会学习使用脸书图 API 。
所以我们不要再浪费时间了，继续下一个教程。
从 PDF 文件中提取元数据
原文：https://www.studytonight.com/network-programming-in-python/extracting-metadata-from-pdf-files
本教程属于Cyber Forensics范畴。我们要讨论的例子是一个现实生活中的事件，黑客组织匿名的一名成员被捕，此前他们发布了一个 PDF 文件(作为 oress 版本)，其中包含了关于他们的组织及其实施的在线攻击的信息。对他不利的证据是，从发布的 PDF 文件中提取的元数据。您可以从这里的下载 pdf。
在本教程中，我们还将尝试从上述 pdf 文件中提取元数据，并查看它包含哪些信息。但是首先，让我们试着理解什么是元数据？
元数据是关于数据的数据。元数据是解释、描述或定位原始主数据的结构化信息，或者以其他方式使原始主数据的使用更加高效的结构化信息。
简单地说，元数据保存了关于数据的信息。如果 PDF 文件包含一些数据，元数据将是 PDF 的创建日期，它甚至可能包含创建它的计算机的 Mac 地址、作者姓名、用来创建 PDF 的软件等。
现在，在我们真正开始从 PDF 文件中提取元数据之前，我们还需要做一件事。我们需要安装另一个名为pyPdf的 python 模块。要安装它，只需遵循以下步骤:
- 从这里下载
pyPdftar.gz文件。 - 使用以下命令提取 tar.gz 文件:
tar -xvzf 'filename' - 现在将您的目录更改为新提取的文件夹。
- 通过运行
python setup.py install命令安装软件包。
从 PDF 文件中提取元数据的程序
以下是从 PDF 文件中提取元数据的程序:
meta_extract.py
#!usr/bin/env python
# This program displays metadata from pdf file
import pyPdf
def main():
# Enter the location of 'ANONOPS_The_Press_Release.pdf'
# Download the PDF if you haven't already
filename = <LOCATION_OF_THE_PDF>
pdfFile = pyPdf.PdfFileReader(file(filename,'rb'))
data = pdfFile.getDocumentInfo()
print "----Metadata of the file----"
for metadata in data:
print metadata+ ":" +data[metadata]
if __name__ == '__main__':
main()
输出:
所以现在，每当你收到任何可疑的 PDF 文件，你都可以很容易地访问它的元数据来找出它的来源。酷！不是吗？
使用pyGeoIP模块
原文：https://www.studytonight.com/network-programming-in-python/pygeoip-module
你一定是偶然发现了各种显示你的位置、城市、地区等的网站。一旦你访问他们的网页。想过怎么做吗？这些网站使用某种付费数据库，帮助他们非常准确地将物理位置与 IP 地址关联起来。在本课中，我们将使用一个免费的数据库，它将大致做同样的事情。数据库名为geoliteticity . dat。
为了将 IP 地址与物理位置进行映射或关联，我们将使用 python 的pyGeoIP模块。
要安装pyGeoIP模块，使用pip命令:
pip install pygeoip
pygeoip提供多种不同类型的查找，例如:
-
Country Lookup
>>> import pygeoip >>> gi = pygeoip.GeoIP('GeoLiteCity.dat') >>> gi.country_name_by_addr('14.139.61.12')印度
-
Region Lookup
>>>import pygeoip >>> gi = pygeoip.GeoIP('GeoLiteCity.dat') >>> gi.region_by_addr('14.139.61.12'){“region _ code”:u“07”，“country _ code”:“IN”}
>>>import pygeoip >>> gi = pygeoip.GeoIP('GeoLiteCity.dat') >>> gi.region_by_name('apple.com') -
City Lookup
>>>import pygeoip >>> gi = pygeoip.GeoIP(‘GeoLiteCity.dat’) >>> gi.record_by_addr(‘14.139.61.12’) -
Organization Lookup
>>>import pygeoip >>> gi = pygeoip.GeoIP('GeoLiteCity.dat') >>> gi.org_by_name('dell.com')戴尔计算机公司
使用pygeoip模块的程序
#!usr/bin/env python
import pygeoip
gi = pygeoip.GeoIP('GeoLiteCity.dat')
def printRecord(ip):
rec = gi.record_by_name(ip)
city = rec['city']
country = rec['country_name']
longitude = rec['longitude']
lat = rec['latitude']
print '[+] Address: ' + ip + ' Geo-located '
print '[+] ' +str(city)+ ', '+str(country)
print '[+] Latitude: ' +str(lat)+ ', Longitude: '+ str(longitude)
ip = # Enter an IP(in single quotes)
printRecord(ip)
现在在这个程序中，我们已经硬编码了 IP 地址，但是您可以转换这个程序，在运行时开始接受命令行输入。还记得吗？在本教程中，我们学习了如何使用argparse和optparse进行操作
什么是网页抓取？
原文：https://www.studytonight.com/network-programming-in-python/web-scraping
网页抓取是一种从网站中提取/抓取信息的技术。该技术主要关注于将网络上的非结构化数据(HTML 格式)转换为结构化数据。
为此我们将使用名为BeautifulSoup的 python 库。现在不用担心，我们将在下一个教程中有程序示例。我们的网页抓取程序将使用这个库来解析网站的 HTML 并提取数据。我们还将使用Requests Library打开网址，下载 HTML 并将其传递给BeautifulSoup。
详细教程，请访问我们的Python 网页抓取使用美丽的程序 教程。
注意:很多网站不允许网页抓取，可能会给你带来法律上的麻烦。因此，我们建议您仅将此用于学习目的，不要从网站上窃取或复制数据。
安装模块
要安装所需的 python 模块，请遵循以下说明:
-
适用于 Linux/Mac OSx 用户:
$ sudo pip install BeautifulSoup $ sudo pip install Requests -
对于窗口用户:
$ pip install BeautifulSoup $ pip install Requests
网页抓取基础
如果你曾经访问过一个网站并查看过源代码(右击→查看页面源代码)，你一定在那里看到了很多蹩脚或不可理解的信息。嗯，除非我们得到一些可以理解的或者结构良好的东西，否则它是没有用的。因此，要从一个网站上删除数据(比如我们想获得电子商务网站特定页面上所有产品的价格)，首先我们需要唯一识别网站上保存数据的 HTML 标签。问题是怎么做？
所以，如果你知道 HTML 基础知识(点击链接，使用我们的互动课程学习 HTML)，你一定知道 HTML 标签和属性。这就是诀窍，我们使用 HTML 标签或属性或两者来唯一识别网站上的任何数据。我们来看一个例子。
要从网站上唯一识别价格标签:
- 右键单击显示的价格。
- 点击检查元素。
这里可以看到价格 449.00 可以唯一标识为:
<span id="priceblock_saleprice" class="a-size-medium a-color-price">
现在，假设我们想要获取数据，并希望将其与从其他网站收集的数据进行比较/存储。这就是刮擦发挥作用的地方。它可以用于从多个网站中挖掘数据。这项技术现在正被广泛使用。很多像 Trivago 这样的网站，只比较不同平台同一产品的价格，用的是同样的技术。
实现网页抓取
原文：https://www.studytonight.com/network-programming-in-python/example-of-web-scraping
让我们试着从电子商务巨头亚马逊那里提取一些数据。让我们搜索“Protien Bars”和相关产品，然后我们将从获得的搜索结果中刮取数据。
上面我们有一个网页截图，以及搜索结果。现在第一步将是识别保存我们想要抓取的数据的 HTML 标签。
- 项目名称:右击产品名称→检验元素
- 项目价格:右键产品价格→检验要素
对于低于 HTML 标签的项目价格，已使用:
<span class="a-size-base a-color-price a-text-bold">
因此，在span标签中，我们必须寻找带有值的class属性，一个基于大小、颜色、价格的粗体。
同样，对于项目名称，使用以下 HTML 标记:
<h2 class="a-size-medium s-inline s-access-title a-text-normal" ...>
ITEM_NAME
</h2>
现在，让我们编写提取数据的程序/脚本。
网页抓取程序/脚本
#!usr/bin/env python
import requests
from bs4 import BeautifulSoup
# url of the search page
url = "http://www.amazon.in/s/ref=nb_sb_ss_i_4_8?url=search-alias%3Daps&field-keywords=protein+bars&sprefix=protein+%2Caps%2C718&crid=1SW4WFJE8O22T&rh=i%3Aaps%2Ck%3Aprotein+bars"
r = requests.get(url) # get the search url using requests
soup = BeautifulSoup(r.content) # create a BeautifulSoup object 'soup' of the content
# Item Name
i_name = soup.find_all("h2",{"class": "a-size-medium s-inline s-access-title a-text-normal"})
#'find_all' method is used to find the matching criteria as mentioned in parenthesis
# Item Price
i_price = soup.find_all("span",{"class": "a-size-base a-color-price a-text-bold"})
# Now print Item name and price
# 'zip' is used to traverse parallely to both name and price
for name,price in zip(i_name,i_price):
print "Item Name: " +name.string
print "Item Price:" +price.text
print '-'*70
在单一教程中涵盖BeautifulSoup模块的所有技术细节和特性是不可能的。所以，我们会推荐你阅读官方文档这里。
注意: 在这里你可能会感到困惑，因为一些产品的价格显示不正确。这是因为我们在这里用于价格提取的类名对于某些项目(正在提供)是不同的。所以你需要改变这些项目的类名。
所以现在你知道如何从任何网站收集数据了。虽然BeautifulSoup模块确实也提供了很多其他功能，但是使用上面的脚本/程序，你可以很容易地从任何网站上抓取数据。
记住 2 个步骤:识别 HTML 标签，然后用程序刮。
什么是 API？
原文：https://www.studytonight.com/network-programming-in-python/understanding-api
你去过酒店或餐馆吗？你一定有！在那里，你一定利用了服务员提供的服务。服务员是这样的人，他接受你的订单，把订单送到酒店厨房，然后把你要的食物送回来。嗯，一个 API 与此非常相似。
应用接口(API)是用于构建软件应用的一组例程、协议和工具。API 指定软件组件应该如何交互。
操作系统、应用和网站有许多不同类型的 API。当你现在访问一个网站的时候，你一定已经看到，他们有多个注册选项，比如:注册脸书，谷歌，领英等。这是最近 API 最常见的用法。以下是一些常用的 API 列表:
- 谷歌地图 API :谷歌地图 API 让开发者在网页上嵌入谷歌地图。
- YouTube API :允许你在自己的网页中集成 YouTube 视频和功能。
- 社交 API :包括脸书、推特、领英、Reddit 等 API。他们使用 API 向您提供对其注册用户的公共数据的访问。
我们之前说过，那个 API 就像一个服务员，我们的意思是它不会让你知道，方法或者程序是如何运作的，通过它来准备请求的菜。它只会给你带来准备好的菜，不管它是用什么方法做的。同样，假设您通过社交 API 请求了一些用户数据。因此，API 代表您请求 web 服务(比如脸书)，并向脸书服务器发出适当的请求，然后将结果返回给您。
使用 API 的优势
原料药的一些优点如下:
- 安全性:使用第三方提供者(比如 Google 等)的 API 在其他一些 web 应用中记录和共享数据要安全得多。
- 自动化:API 非常容易地实现和促进自动化过程。您可以在自己的代码中使用一些 web 服务的 API 来自动执行任务，如检查时间表、发布消息等。
- 集成:API 允许内容更容易地从任何网站或应用嵌入。这保证了更流畅的信息传递和集成的用户体验。
- 外部数据库访问:API 允许网站访问者访问远程的、有密码保护的数据库。您的 API 密码和用户名授权在您的网站和 API 的数据库驱动资源之间交换信息的权限。
使用脸书 GraphAPI
原文：https://www.studytonight.com/network-programming-in-python/facebook-graph-api
从现在开始，你必须熟悉 API 这个词。如今，社交 API 在收集个人、组织或几乎任何事物的信息方面发挥着重要作用。因此，我们将考虑使用 python 从脸书挖掘一些数据来实现脸书 GraphAPI。
如果你去https://developers.facebook.com/docs/，你会发现 facebook 提供 API 支持的语言。但是，facebook 没有为 python 提供官方客户端。因此，我们将使用脸书软件开发工具包来代替。在我们开始挖掘(提取或数据挖掘)一些数据之前，让我们首先安装 python 的脸书 SDK。很简单:
sudo pip install facebook-sdk
在从脸书跳入数据挖掘之前，我们必须先满足一些要求。我们需要一个Access Token来访问社交网站上的任何数据并收集信息。那么，什么是Access Token？
简单来说，假设这是脸书(或任何其他网站)提供的一种访问代码或权限，这样您就可以作为合法用户访问数据，他们也可以跟踪数据。
访问令牌是描述进程或线程的安全上下文的对象。令牌中的信息包括与进程或线程相关联的用户帐户的身份和权限。
您需要有一个脸书帐户来请求访问令牌。现在按照以下步骤操作:
-
登录您的帐户。
-
Now, on the top right section. Click on Get Started section. And follow the formalties and proceed.
-
现在，为你的应用选择一个显示名称，点击创建应用标识。
-
生成您的
App ID后，访问https://developers.facebook.com/tools/explorer/ -
Now, click on Get Token → Get User Access Token. If you have multiple apps than you might need to select for which app you want to generate the token.
-
现在选择用户数据权限，点击获取访问令牌
-
Your token will be generated. Copy that to clipboard. It is advised not to share this access token. And if you are using it in a program, do not use directly. It is advised to save this token in a separate file and take input from there or set an enviroment variable like
$ set FACEBOOK_TEMP_TOKEN = "YOUR_TOKEN".但是，由于这些令牌在一段时间后过期，您需要一次又一次地更新它。
挖掘自己的脸书账户
原文：https://www.studytonight.com/network-programming-in-python/mining-facebook-data
我们来看看如何挖掘用户名邮箱位置****网站等信息。使用 python 脚本自动从用户帐户下载。
首先让我们看看代码:
#!usr/bin/env python
# Program to mine data from your own facebook account
import json
import facebook
def main():
token = "{Your Token}"
graph = facebook.GraphAPI(token)
#fields = ['first_name', 'location{location}','email','link']
profile = graph.get_object('me',fields='first_name,location,link,email')
#return desired fields
print(json.dumps(profile, indent=4))
if __name__ == '__main__':
main()
在main()方法中，我们试图获得关于我们自己的脸书账户的信息。让我们尝试逐行理解代码:
token:是访问页面所需的访问令牌。- 在下一行中，我们创建了一个
GraphAPI对象来访问 API 方法。 - 现在，我们已经在变量
profile中提取了所需的字段。在这里，注意get_object()方法中的'me'表示我们是为了自己的利益。 first_name:返回用户的名字。location:他们在个人资料中输入的当前位置。此字段与签入无关。email:个人资料中列出的主要电子邮件地址。如果没有有效的电子邮件地址，则不会返回此字段。link:人物时间线的链接。
除了这些领域，还有许多领域。有关字段的完整列表和描述，请参考脸书 GraphAPI 官方文档，此处为。
输出:
上面代码的最后一行转储变量profile中获取的信息的 json 格式。
从脸书页面挖掘数据
现在，在这个例子中，我们将从“金属之神”乐队的脸书页面提取数据。要查看可从页面中提取的字段列表，请参考此处的。
#!usr/bin/env python
# Program to get a page information
import json
import facebook
def main():
token = "{Your Token}"
graph = facebook.GraphAPI(token)
page_name = raw_input("Enter a page name: ")
# list of required fields
fields = ['id','name','about','likes','link','band_members']
fields = ','.join(fields)
page = graph.get_object(page_name, fields=fields)
print(json.dumps(page,indent=4))
if __name__ == '__main__':
main()
输出:
Python 的mechanize库
原文：https://www.studytonight.com/network-programming-in-python/mechanize-library
一般来说，用户可以使用浏览器或者通过使用许多不同的方法和工具查看源代码来查看网站；Linux 程序wget是一种流行的方法。如果你想用 Python 打开一个网站，浏览互联网的唯一方法就是检索和解析网站的 HTML 源代码。在本教程中，我们将学习如何为此目的使用mechanize库。
要使用mechanize库，请从这里下载它的 tar.gz 文件。提取tar文件并使用python setup.py install安装
Mechanize 的主类Browser，允许操作任何可以在浏览器中操作的东西。让我们看一个使用 Mechanize Library 查看网站源代码的例子:
机械
#!usr/bin/env python
#Program to view source code using mechanize
import mechanize
def page_view(url):
try:
#create browser object
browser = mechanize.Browser()
#browser.set_handle_robots(False)
page = browser.open(url)
src_code = page.read()
#print source code
print src_code
except:
print "Error in browsing..."
url = "http://www.syngress.com/"
page_view(url)
输出:
现在，在脚本中mech1.py将 url 更改为https://www.google.com。你看到了什么？“浏览错误……”现在让我们仔细分析一下这个错误。从上述代码中删除除语句外的 try &语句，并尝试再次执行该代码。哎呀！它仍然不起作用，但这次你会看到详细的错误。您一定看到错误消息，指出:
从错误中我们可以看到， robots.txt 文件有问题。你知道什么是机器人文件吗？利用这个文件，任何网站都可以通知谷歌、必应等搜索引擎抓取或不抓取任何网页。因此，如果你有一个网站，你不希望谷歌抓取任何特定的网页(可能是内部使用)，那么你可以在 robots.txt 文件中指定。
现在，进入问题。所以出现上述错误是因为网站阻止我们的浏览器访问他们的网页。那么，我们该怎么办呢？我们指示我们的mechanize browser对象忽略机器人文件的网站解析。为此，只需在 mech1.py 中取消注释以下行:browser.set_handle_robots(False)
现在，如果你访问 Google.com，你可以看到如下内容:
使用mechanize库更改浏览器的用户代理
原文：https://www.studytonight.com/network-programming-in-python/changing-user-agent
在本教程中，我们将学习如何使用mechanize库更改浏览器的用户代理，并将尝试修改 HTTP 请求头。
什么是用户代理？
在计算中，用户代理是代表用户的任何东西。Borwser 的用户代理是一个字符串或一行文本，包含关于浏览器和操作系统的信息，在 HTTP 请求头中发送到网络服务器。这允许网站定制内容，以最适合特定设备的功能，但共享这些信息也会引发某些隐私问题。
在典型的 HTTP 请求/响应周期中，您可以在 HTTP 请求/响应头中查看浏览器的用户代理。它看起来像是:
但是，通过使用mechanize我们可以改变 HTTP 请求头的用户代理字段，来欺骗(愚弄)web 服务器。让我们看看如何做到这一点，使用 python 脚本，我们将尝试将用户代理设置为:
user_agent =
[('User-agent',
'Mozilla/5.0 (X11;U;Linux 2.4.2.-2 i586; en-us;m18) Gecko/200010131 Netscape6/6.01'
)]
让我们看看代码:
#Program to change the user agent
#Verify the UserAgent with wireshark tool
import mechanize
#function to browse the web page
def change_user_agent(url, user_agent):
try:
#Create browser object
browser=mechanize.Browser()
browser.set_handle_robots(False)
#add user agent
browser.addheaders=user_agent
#open web url
page=browser.open(url)
#read page source code
source_code = page.read()
#print source code
print source_code
except:
print "Error in browsing....."
url = str(raw_input("Enter the website name: "))
#user agent details
user_agent=[('User-agent','Mozilla/5.0 (X11;U;Linux 2.4.2.-2 i586; en-us;m18) Gecko/200010131 Netscape6/6.01')]
change_user_agent(url,user_agent)
让我们运行上面的脚本，我们输入的网站名称为studytonight.com:
看来我们的脚本执行成功了。现在让我们看看用户代理是否更改。当你打开 Wireshark 时，你会看到巨大的流量。比如何过滤所需的？我们将使用 linux 操作系统的一个强大工具，即'nslookup'命令。
我们已经对运行上述脚本的网站名称进行了查找。我们现在有了所需网站的 IP 地址。所以现在我们可以使用 Wireshark 过滤这个 IP 地址的流量。只需在 wireshark 滤镜栏中键入:ip.addr == 104.25.205.29。现在，您将看到所有具有以下 IP 地址的数据包。现在，转到具有 HTTP 协议的数据包，并右键单击它。
右键单击后→跟随→ TCP 流
虽然我们已经使用mechanize库浏览了网站。但是我们已经成功地欺骗了作为 HTTP 请求头的一部分发送的用户代理信息。这些伎俩被安全研究人员用来隐藏他们的身份。
Web 爬取
入门指南
网页抓取简介
原文：https://www.studytonight.com/python/web-scraping/introduction-to-web-scraping
互联网是一个通过各种网站传播的信息海洋，在这里它被分类，相互联系，并且大多数是免费提供给每个人的。
例如:如果你想知道某个特定产品的市场价格，你可以亲自去市场询问店主，或者你可以在亚马逊、易趣等在线商店搜索该产品。但是如果你想要某一价格范围内某一特定类别的所有产品的清单呢？你显然会更喜欢网上商店，因为你家周围的店主不会用所有产品的清单来招待你。
但是从互联网上获取这样的数据/信息有时并不容易。对于这种情况和需求，我们使用程序从任何网站解析和获取数据，这种通过解析 HTML 代码从网站中提取大量数据的技术被称为网页抓取。
我们在这里学习如何去做。所以不再拖延，让我们开始吧。
先决条件
要很好地学习本教程，您必须事先知道几件事，它们是:
- Python 编程语言。如果你不知道 Python，参加今晚的 Python 课程。
- HTML 基础知识。了解 HTML 会促进你的进步。你可以在 StudyTonight 上开始学习 HTML 本身。
考虑到您知道 python 和 HTML，让我们设置网页抓取工作所需的所有工具/包。
如果你的电脑上没有安装 Python。去 python 官网下载。下载后，按照教程开始使用 Python 进行逐步指导。
我们还需要 python 库中的bs4和requests模块来进行网络裁剪。现在，我们将安装我们将要使用的所有必需模块。
安装bs4模块
要安装bs4模块，请在命令行中运行以下命令:
pip install bs4
安装后，通过运行以下代码检查是否安装。
import bs4
如果以上命令执行没有任何错误，那么您已经成功地在您的计算机中安装了bs4模块。
安装requests模块
在命令行中运行以下命令安装requests模块。
pip install requests
同样，安装后，通过运行以下代码检查是否安装了它。
import requests
如果以上命令执行没有任何错误，那么您已经成功地在您的计算机中安装了request模块。
有了这个，我们就可以开始刮网了。
刮擦规则
从任何网站抓取数据时，您都应该记住以下几点:
- 浏览你想从中获取数据的网站的条款&条件。有些网站不允许网页抓取将数据用于商业用途，而有些网站允许，因此我们建议您阅读条款和条件。
- 运行网页抓取程序时，不要过于主动地向网站请求数据，因为这可能会降低网站的速度。
- 一旦你的脚本写好了，如果网站改变了它的界面，可能就无法工作了，在运行你的网页抓取脚本之前，请确认网站布局的任何改变。
检查任何网页
这永远是刮网过程的第一步，或者我们可以说这是第 0 步。
我们可以使用浏览器工具，如 Chrome 的开发者控制台等，检查任何网站的用户界面和相关的 HTML 代码。
例如，如果你想在今晚的学习网站上从教程的左侧栏中获取所有的主题名称，那么如果你正在使用视窗上的 Chrome 浏览器，请按 F12 键打开开发工具(对于 macOS，请按命令+选项+ I )。
然后点击左上角的按钮，如上图所示。一旦你点击了那个按钮，你所要做的就是将鼠标指针悬停在任何网页的元素上，你就会在开发者工具的元素视图中看到它的 HTML 代码。
这就是我们最初搜索和查找网页抓取元素的方式。
requests模块简介
原文：https://www.studytonight.com/python/web-scraping/introduction-to-requests-module
requests模块用于向任意服务器发送 HTTP 请求并接收回 HTTP 响应。因此我们将使用requests模块使用网站的网址发送 HTTP 请求并返回响应，为此我们将使用美汤模块从响应中取出网站的有用数据/信息/内容。
那么我们来学习一下如何使用requests模块发送 HTTP 请求和接收服务器的响应。
一些有用的request模块方法
以下是requests模块中用于发出 HTTP 请求的一些常用方法。
- requests.get()
- requests.post()
- requests.put()
- requests.delete()
- requests.head()
- requests.options()
在本教程中，我们将使用requests.get()和requests.post()方法对网页抓取进行 HTTP 请求。
如果你是 HTTP 请求新手，想知道 GET 和 POST 请求是什么，这里有一个简单的解释:
- GET :用于使用 URL 检索信息(网页)。
- POST :用于向某个 URL 发送信息。
使用requests.get提出请求
requests.get(URL)方法用于发送 HTTP 请求并接收数据作为响应。它需要一个网址或任何 API。
response.content是存储响应内容的变量，是get()方法的响应。
让我们举个例子，
## import requests module
import requests
## send a request and receive the information from https://www.google.com
response = requests.get("https://www.google.com")
## printing the response
print(response.content)
上述脚本的输出将是指定网址的整个页面源(或源代码)，我们已经将其存储在下面的 文件 中(因为太长)。
你一定想知道我们怎么能从这里读到任何东西，因为它太复杂了。为了使响应内容可读，我们使用了BeautifulSoap模块，这将在接下来的教程中介绍。
我们可以使用response.headers方法打印网站在回复中发送的标题信息。
对于新手来说，头信息包含关于 HTTP 连接的一般元信息以及一些连接属性。
让我们为上面的 get 请求打印标题:
## import requests module
import requests
## send a request and receive the information from https://www.google.com
response = requests.get("https://www.google.com")
## headers of the website
print(response.headers)
{ ' Date ':' 2018 年 11 月 07 日星期三 08:56:29 GMT '，' Expires ':-1 '，' Cache-Control': 'private，max-age=0 '，' Content-Type ':' text/html；charset=ISO-8859-1 '，' P3P': 'CP= '这不是 P3P 的政策！更多信息请见 g.co/p3phelp。”、“内容编码”:“gzip”、“服务器”:“gws”、“X-XSS-保护”:“1；mode=block '，' X-Frame-Options': 'SAMEORIGIN '，' Set-Cookie ':' 1P _ JAR = 2018-11-07-08；到期=Fri，07-12-2018 08:56:29 格林尼治时间；路径=/；domain=.google.com，NID = 144 = cpba w4 rax5 tzbz3 wtdnn 54 qgut 198 ovtvdywyx0ifipo-MLX _ qcq 8 djzxqnko 7 wqrd4d kognxshyh 9 tfmmzktoz0 oonbu-9nlw 50 ocpogmxvt 9 snrzgxpujgmv 0 d5a 7 urfesv 0 blihlp 24 upnwhoqjmo 5 sbznndc 0 dvd3d vr5s；到期时间= 2019 年 05 月 09 日星期四格林尼治时间 08:56:29；路径=/；domain = .google.comHttpOnly '，' Alt-Svc ':' quic = ":443 "；ma = 2592000v="44，43，39，35 " '，'传输编码':'分块' }
为了以更易读的格式打印值，我们可以使用方法response.headers.items()分别访问每个值，并使用 for循环打印每个值。
## import requests module
import requests
## send a request and receive the information from https://www.google.com
response = requests.get("https://www.google.com")
## headers of the website
for key, value in response.headers.items():
print(key, '\t\t', value)
日期:2018 年 11 月 7 日星期三格林尼治时间 08:56:29 到期-1 缓存-控制私有，最大年龄=0 内容类型文本/html；charset=ISO-8859-1 P3P CP= "这不是 P3P 的政策！更多信息请见 g.co/p3phelp。”内容编码 gzip 服务器 GWS X-XSS-保护 1；模式=块 X-帧-选项 same origin Set-Cookie 1P _ JAR = 2018-11-07-08；到期=Fri，07-12-2018 08:56:29 格林尼治时间；路径=/；domain=.google.com，NID = 144 = cpba w4 rax5 tzbz3 wtdnn 54 qgut 198 ovtvdywyx0ifipo-MLX _ qcq 8 djzxqnko 7 wqrd4d kognxshyh 9 tfmmzktoz0 oonbu-9nlw 50 ocpogmxvt 9 snrzgxpujgmv 0 d5a 7 urfesv 0 blihlp 24 upnwhoqjmo 5 sbznndc 0 dvd3d vr5s；到期时间= 2019 年 05 月 09 日星期四格林尼治时间 08:56:29；路径=/；domain = .google.comHttpOnly Alt-Svc quic = ":443 "；ma = 2592000v =“44，43，39，35”传输编码分块
请求的状态
当我们使用requests.get()方法发出 GET 请求时，请求可能会失败，被重定向到其他网址，可能会在客户端或服务器端失败，也可能会成功完成。
要了解请求的状态，我们可以查看收到的响应的状态代码。
这可以使用response.status_code值来完成。很简单，
## import requests module
import requests
## send a request and receive the information from https://www.google.com
response = requests.get("https://www.google.com")
## status of request
print(response.status_code)
Two hundred
以下是您可能在响应中获得的不同状态值:
| 状态代码 | 描述 |
| 1XX | 报告的 |
| 2XX | 成功 |
| 3XX | 重寄 |
| 4XX | 客户端错误 |
| 5XX | 服务器错误 |
例如: 200 状态码为成功。鉴于， 201 状态代码用于已创建(当我们发送创建某个资源的请求时)等。
就像 GET 请求一样，我们可以使用requests.post(URL)方法发出 POST 请求，处理响应也是一样的。
对于网页抓取，我们将主要使用 GET 请求。
设置用户代理
当我们试图使用程序访问网站时，出于安全原因，一些网站不允许这样做，因为这使得网站容易受到通过程序生成的不必要请求的影响，在极端情况下，这些程序甚至会通过发送大量请求来加重网站服务器的负担。
为了克服这一点，我们将使用伪造用户代理模块，该模块用于伪造对服务器的请求，就好像它是由用户而不是程序发起的一样。
要安装模块 fake_useragent ，运行以下命令:
pip install fake_useragent
一旦安装完成，我们就可以用它来生成一个虚假的用户请求，如下所示:
## import UserAgent from the fake_useragent module
from fake_useragent import UserAgent
## create an instance of the 'UserAgent' class
obj = UserAgent()
## create a dictionary with key 'user-agent' and value 'obj.chrome'
header = {'user-agent': obj.chrome}
## send request by passing 'header' to the 'headers' parameter in 'get' method
r = requests.get('https://google.com', headers=header)
print(r.content)
这个请求的输出将是网页https://google.com的源代码，就好像它是由用户使用 Chrome 浏览器打开的一样。
所以现在我们知道如何使用requests模块向任何网址发送一个 HTTP 请求并接收响应。在下一个教程中，我们将学习如何使用BeautifulSoap模块从 HTTP 响应中获取真正有用的内容。
beautifulsoup模块简介
原文：https://www.studytonight.com/python/web-scraping/introduction-to-beautifulsoup
在本教程中，我们将学习如何使用 python 的模块解析网页的源代码(我们可以使用 requests模块获得)，并从源代码中找到各种有用的信息，如所有的 HTML 表格标题，或网页上的所有链接等。
**如果我们向它提供了关于 HTML 标签的所有信息，美化程序可以搜索并返回所有出现的 HTML 标签。
在我们开始搜索 HTML 标签和从网页访问信息之前，让我们看看如何格式化收到的 HTTP 响应内容，使其更具可读性。
美化组:美化内容
在beautifulsoup模块中可用的方法prettify可用于格式化使用requests模块接收的 HTTP 响应。
下面是代码示例，它是对上一个教程的扩展:
## import modules
import requests
from fake_useragent import UserAgent
## importing the beautifulsoup module
import bs4
## send a request and receive the information from https://www.google.com
response = requests.get("https://www.google.com")
## creating BeautifulSoup object
soup = bs4.BeautifulSoup(response.content, "html.parser")
## using 'prettify' method to print the content
print(soup.prettify())
在上面的代码中，我们执行了以下操作:
- 导入模块:请求、假用户代理和 bs4 。
- 从任何你喜欢的网址获取回复。
- 使用
BeautifulSoup类创建一个美化组对象。 - 使用
prettify方法打印响应，方法是使用美丽的输出对象。
如果您在阅读了前面的教程后来到这里，您一定已经看到了使用requests模块做出的 GET 请求的响应是什么样子的。
当我们使用prettify方法格式化该响应时，它看起来像是 这个 (点击这个下载文件)。
现在响应已经格式化了，让我们学习如何使用美丽的输出来访问 HTTP 响应中的各种 HTML 标签和相关信息(源代码)。
BeautifulSoap:访问 HTML 标签
使用“美化”模块，我们可以轻松找到并访问各种 HTML 标签的内容，如标题、标题、 div 、 p 、 h1 等。让我们看一个简单的例子，我们将打印网页的标题标签。
## import modules
import requests
from fake_useragent import UserAgent
## importing the beautifulsoup module
import bs4
## send a request and receive the information from https://www.google.com
response = requests.get("https://www.google.com")
## creating BeautifulSoup object
soup = bs4.BeautifulSoup(response.content, "html.parser")
## getting 'title' tag from the google BeautifulSoup -> 'soup'
title_tag = soup.title
print(title_tag)
我们还可以只获得包含在开始和结束标题标签中的文本:
## import modules
import requests
from fake_useragent import UserAgent
## importing the beautifulsoup module
import bs4
## send a request and receive the information from https://www.google.com
response = requests.get("https://www.google.com")
## creating BeautifulSoup object
soup = bs4.BeautifulSoup(response.content, "html.parser")
## getting 'title' tag from the google BeautifulSoup -> 'soup'
title_text = soup.title.text
print(title_text)
谷歌
这是所有 HTML 标签的标准，比如获取头标签，我们可以这样使用soup.head，
## import modules
import requests
from fake_useragent import UserAgent
## importing the beautifulsoup module
import bs4
## send a request and receive the information from https://www.google.com
response = requests.get("https://www.google.com")
## creating BeautifulSoup object
soup = bs4.BeautifulSoup(response.content, "html.parser")
## getting 'head' tag from the google BeautifulSoup -> 'soup'
print(soup.head)
这将从页面的源代码中返回完整的头标签。
< meta content="/images/branding/googleg/1x/googleg_standard_color_128dp.png" itemprop="image"/>
我们没有在输出中添加完整的代码，因为它非常庞大。但是可以看到标题标签在头标签里面，里面也有风格标签。
我们还可以通过头标签获取标题标签内容:
## getting 'title' tag from the google BeautifulSoup -> 'soup'
print(soup.head.title.text)
谷歌
这只是为了向您展示，当美丽组遵循树遍历技术来解析 HTML 代码时，我们也可以通过遵循标签的层次结构来访问它们。
同样，让我们访问样式标签:
## getting 'title' tag from the google BeautifulSoup -> 'soup'
print(soup.head.style.text)
gbar，# guser { font-size:13px；填充-顶部:1px！重要；} # gbar {高度:22px } # guser {填充-底部:7px！重要；文本对齐:向右}。gbh，。gbd {边框-顶部:1px 实心# c9d 7 f1；字体大小:1px}。gbh {高度:0；位置:绝对；top:24px；宽度:100% } @ media all { . gb1 {高度:22px 右边距:. 5em 垂直对齐:top}#gbar{float:left}}a.gb1，a.gb4{text-decoration:下划线！重要}a.gb1，a.gb4{color:#00c！重要}。gbi .gb4{color:#dd8e27！重要}。gbf .gb4
到目前为止，我们已经介绍了基本的 HTML 解析和访问标签。在下一个教程中，我们将看到更多的方法和一些方法来浏览任何网页的 HTML 源代码来收集有用的数据。
进阶
探索 BeautifulSoap 方法
原文：https://www.studytonight.com/python/web-scraping/exploring-beautifulsoup-methods
在本教程中，我们将学习各种不同的方法来访问 HTML 标签使用不同的方法的美丽的输出模块。要获得关于美丽的输出模块的基本介绍，请从之前的教程开始。
BeautifulSoap:访问 HTML 标签
我们将在本节中介绍的方法用于遍历不同的 HTML 标记，将 HTML 代码视为一棵树。
创建一个文件sample _ 网页. html 并在其中复制以下 html 代码:
<!DOCTYPE html>
<html>
<head>
<title> Sample HTML Page</title>
<style>
* {
margin: 0;
padding: 0;
}
div {
width: 95%;
height: 75px;
margin: 10px 2.5%;
border: 1px dotted grey;
text-align: center;
}
p {
font-family: sans-serif;
font-size: 18px;
color: #000;
line-height: 75px;
}
a {
position: relative;
top: 25px;
}
</style>
</head>
<body>
<div id="first-div">
<p class="first">First Paragraph</p>
</div>
<div id="second-div">
<p class="second">Second Paragraph</p>
</div>
<div id="third-div">
<a href="https://www.studytonight.com">Studytonight</a>
<p class="third">Third Paragraph</p>
</div>
<div id="fourth-div">
<p class="fourth">Fourth Paragraph</p>
</div>
<div id="fifth-div">
<p class="fifth">Fifth Paragraph</p>
</div>
</body>
</html>
现在要读取上述 HTML 文件的内容，使用下面的 python 代码将内容存储到一个变量中:
## reading content from the file
with open("sample_webpage.html") as html_file:
html = html_file.read()
现在，我们将使用不同方法的美丽组模块，看看它们是如何工作的。
预热，先用prettify方法。
import bs4
## reading content from the file
with open("sample_webpage.html") as html_file:
html = html_file.read()
## creating a BeautifulSoup object
soup = bs4.BeautifulSoup(html, "html.parser")
print(soup.prettify)
第一段
第二段
第三段
第四段
第五段
BeautifulSoap:访问 HTML 标签属性
我们可以使用以下语法检索任何 HTML 标记的属性:
TagName["AttributeName"]
让我们从 HTML 代码中的锚点标签中提取href属性。
import bs4
## reading content from the file
with open("sample_webpage.html") as html_file:
html = html_file.read()
## creating a BeautifulSoup object
soup = bs4.BeautifulSoup(html, "html.parser")
## getting anchor tag
link = soup.a
## printing the 'href' attribute of anchor tag
print(link["href"])
美丽组:contents方法
contents方法用于列出父标签中存在的所有标签。让我们使用contents方法列出正文标签的所有子 HTML 标签。
body = soup.body
## getting all the children of 'body' using 'contents'
content_list = body.contents
## printing all the children using for loop
for tag in content_list:
if tag != "\n":
print(tag)
print("\n")
第一段
第二段
第三段
第四段
第五段
美丽组:children方法
children方法类似于contents方法，但是children方法返回一个迭代器，而contents方法返回一个所有子代的列表。让我们看一个例子:
body = soup.body
## we can also convert iterator into list using the 'list(iterator)'
for tag in body.children:
if tag != "\n":
print(tag)
print("\n")
第一段
第二段
第三段
第四段
第五段
美丽组:descendants方法
descendants方法有助于检索父标签的所有子标签。你一定想知道上面两个方法也是这么做的。这个方法不同于contents和children方法，因为这个方法提取所有的子标签和内容直到最后。简单来说，如果我们用它来提取身体标签，那么它将打印第一个 div 标签，然后它将打印 div 标签的子标签，然后他们的子标签，直到它到达终点，然后它将继续下一个 div 标签，以此类推。
该方法返回一个发生器。让我们看一个例子:
body = soup.body
## getting child tags of 'body' tag using 'descendants' method
for tag in body.descendants:
if tag != "\n":
print(tag)
print("\n")
第一段
第一段
第一段
第二段
第二段
第二段StudyTonight
第三段
T18】StudyTonightStudyTonight
第三段
第三段
第四段
T26】第四段第四段 T29
正如您在上面的输出中看到的那样，descendants方法一直进入它读取的标签内部，直到它到达末尾，然后它移动到下一个 HTML 标签上。
美丽组:parent方法
parent方法用于获取子标签的父标签。让我们看一个例子:
body = soup.body
## getting parent of 'body'
body_parent = body.parent
## you have to use 'name' method to print the name of the tag
## printing the name of the parent using 'name' method
print(body_parent.name)
超文本标记语言
美丽组:parents方法
parent方法用于获取一个子标签的所有父标签。它返回一个发电机。让我们看一个例子:
body = soup.body
## getting parents of 'body'
body_parents = body.parents
## if the child has more than one parent it will print all parent names
for parent in body_parents:
print(parent.name)
print("\n")
html[文档]
美丽组:next_sibling方法
next_sibling方法用于从同一个父标签获取指定标签的下一个标签。现在让我们在输出的 HTML 代码中打印锚点标签的同级标签:
anchor_tag = soup.a
print(anchor_tag)
## getting third paragraph using anchor tag
## here we have written 'next_sibling' two times
## means there is a line break in between them
## anchor_tag.next_sibling gives a line break
## next to line break is the third paragraph
third_para = anchor_tag.next_sibling.next_sibling
print(third_para)
StudyTonightT2】第三段
美丽组:previous_sibling方法
previous_sibling方法类似于next_sibling方法。它返回上一个标签，而不是下一个标签。让我们看一个例子(这是上面代码片段的延续):
## getting anchor tag from the third_para
print(third_para.previous_sibling.previous_sibling)
美丽组:next_siblings方法
next_siblings返回带有所有可用下一个标签的生成器。让我们看一个例子(这是上面代码片段的延续):
## using anchor_tag variable here
a_siblings = anchor_tag.next_siblings
print(list(a_siblings))
['\n '，
第三段
，' \n']
美丽组:previous_siblings方法
previous_siblings返回一个带有所有可用先前标签的生成器。让我们看一个例子(这是上面代码片段的延续):
## using third_para variable here
p_siblings = third_para.previous_siblings
print(list(p_siblings))
['\n '，lt；a href = " https://www . study now . com " > study now，' \n']
现在，您已经熟悉了大多数用于网页抓取的方法。在下面的教程中，我们将学习如何从一堆相似的标签中找到一个特定的标签。
使用 BeautifulSoap 查找 HTML 标签
原文：https://www.studytonight.com/python/web-scraping/find-tags-with-beautifulsoup
在本教程中，我们将学习如何使用美化输出模块搜索任何标签。我们建议您浏览之前的教程，这些教程是关于美丽的耦合模块的基本介绍，以及涵盖美丽的耦合模块的所有有用方法的教程。
我们已经学习了不同的遍历 HTML 树的方法，如parent、parents、next_sibling、previous_sibling等。但是使用这些方法很难找到所有相似的标签。所以，现在我们将学习如何使用“美丽输出”模块的find和find_all方法来找到任何标准的 HTML 标签。
如果你来自上一个教程，我们将使用相同的 html 代码，如果你是新来的，请创建一个文件sample _ 网页. html 并在其中复制以下 HTML 代码:
<!DOCTYPE html>
<html>
<head>
<title> Sample HTML Page</title>
<style>
* {
margin: 0;
padding: 0;
}
div {
width: 95%;
height: 75px;
margin: 10px 2.5%;
border: 1px dotted grey;
text-align: center;
}
p {
font-family: sans-serif;
font-size: 18px;
color: #000;
line-height: 75px;
}
a {
position: relative;
top: 25px;
}
</style>
</head>
<body>
<div id="first-div">
<p class="first">First Paragraph</p>
</div>
<div id="second-div">
<p class="second">Second Paragraph</p>
</div>
<div id="third-div">
<a href="https://www.studytonight.com">Studytonight</a>
<p class="third">Third Paragraph</p>
</div>
<div id="fourth-div">
<p class="fourth">Fourth Paragraph</p>
</div>
<div id="fifth-div">
<p class="fifth">Fifth Paragraph</p>
</div>
</body>
</html>
要读取上述 HTML 文件的内容，请使用以下 python 代码将内容存储到变量中:
## reading content from the file
with open("sample_webpage.html") as html_file:
html = html_file.read()
一旦我们读取了文件，我们就创建了一个美丽的输出对象:
import bs4
## reading content from the file
with open("sample_webpage.html") as html_file:
html = html_file.read()
## creating a BeautifulSoup object
soup = bs4.BeautifulSoup(html, "html.parser")
刮网过程开始了...
美丽组:find_all方法
find_all方法用于通过将标签的名称作为方法的参数来查找我们正在搜索的所有相似标签。find_all方法返回一个包含所有找到的 HTML 元素的列表。以下是语法:
find_all(name, attrs, recursive, limit, **kwargs)
我们将逐一介绍find_all方法的所有参数。让我们从名称参数开始。
find_all:名称参数
让我们从 HTML 代码中找到所有的p标签:
import bs4
## reading content from the file
with open("sample_webpage.html") as html_file:
html = html_file.read()
## creating a BeautifulSoup object
soup = bs4.BeautifulSoup(html, "html.parser")
## finding all p tags
p_tags = soup.find_all("p")
print(p_tags)
print("\n-----Class Names Of All Paragraphs-----\n")
for tag in p_tags:
print(tag['class'][0])
print("\n-----Content Of All Paragraphs-----\n")
for tag in p_tags:
print(tag.text)
【
第一段
、
第二段
、
第三段
、
第四段
、
第五段
——所有段落的类别名称——第一、二、三、四、五——所有段落的内容——第一段第二段第三段第四段第五段
如您所见，我们不仅可以找到标签，还可以找到与这些标签相关的所有信息。
find_all:属性参数
让我们从 HTML 代码中找到所有具有属性 class等于链接的标签(该代码是在我们在上面的代码片段中创建了soup对象之后):
## finding using class name
link_class_tags = soup.find_all(class_="link")
print(link_class_tags)
print("----------")
for tag in link_class_tags:
print(tag.name)
谷歌 - a
请注意为class属性提供下划线(_)的语法，您必须遵循该语法。
find_all:包含任意字符串的标签
我们可以使用find_all方法找到包含给定字符串的所有 HTML 标签。由于方法find_all需要搜索一个正则表达式，因此在下面的代码示例中，我们使用了 python 的re模块来生成一个正则表达式。
## finding tags using a string
## importing regular expression module to find all the strings
import re
## defining an re variable which contains "Paragraph" text
s = re.compile("Paragraph")
## finding all the content of the tags which contains "Paragraph"
tags_containing_paragraph = soup.find_all(string=s)
print(tags_containing_paragraph)
[“第一段”、“第二段”、“第三段”、“第四段”、“第五段”]
编写上述代码时，将import re语句和import bs4语句保留在顶部。
find_all:极限参数
限制参数用于限制结果集。当提供了一个限制时find_all方法只返回等于给定限制的标签，其他符合条件的标签不包括在返回的列表中。
## finding the first p tag using limit parameter
first_p_tag = soup.find_all("p", limit=1)
print(first_p_tag)
第一段
您可以像本例中一样一起使用多个参数。
美丽组:find方法
find方法用于寻找第一个匹配标签。这类似于将limit=1参数值传递给find_all方法。
让我们举个例子:
p_tag = soup.find("p")
print(p_tag)
print("----------")
print(p_tag.text)
第一段
-第一段
再举一个例子，
a_tag = soup.find("a")
print(a_tag)
print("----------")
print(a_tag.text)
print("\n")
print(a_tag['href'])
StudyTonight -StudyTonight https://www.studytonight.com
在这之后，我们学习了使用美丽的输出模块进行网页抓取。我们已经涵盖了所有重要和有用的方法，但还有很多。如果您想深入了解，请查看美观组文档。
在下一个教程中，我们将刮一个网站。
从消费者报告网站抓取产品名称
原文：https://www.studytonight.com/python/web-scraping/web-scraping-practical-example-1
注:本教程仅用于教育目的，我们要求读者不要使用该代码对网站进行任何形式的伤害。
在本教程中，我们将学习如何从任何网站上抓取数据。我们从中获取数据的网站是消费者报告网站。我们将从这个网址请求数据，然后从中收集产品名称列表。
让刮擦开始...
## importing bs4, requests and fake_useragent modules
import bs4
import requests
from fake_useragent import UserAgent
## initializing the UserAgent object
user_agent = UserAgent()
url = "https://www.consumerreports.org/cro/a-to-z-index/products/index.htm"
## getting the reponse from the page using get method of requests module
page = requests.get(url, headers={"user-agent": user_agent.chrome})
## storing the content of the page in a variable
html = page.content
到了这一步，我们已经在变量html中存储了网页的完整源代码。现在让我们创建一个漂亮的输出对象。你甚至可以尝试运行prettify方法。
## creating BeautifulSoup object
soup = bs4.BeautifulSoup(html, "html.parser")
我们还创建了一个美丽的组对象，现在呢？我们如何知道从 HTML 代码中找到并提取哪个标签。我们应该在 HTML 代码中搜索它吗？不可能！
还记得在本系列的第一个教程中，当我们引入术语网页抓取时，我们确实与您分享了一种技术，在这里我们可以使用 Chrome 浏览器的开发工具来查找任何网页元素的 HTML 代码。(其他浏览器如火狐等也有自己的开发工具，也可以使用。)
如果您使用的是 Windows，请按 F12 键打开开发者工具(在 chrome 浏览器中)，如果您是 Mac 用户，请按选项+命令+ I 键。
点击左上角按钮:
然后将鼠标光标悬停在产品列表条目上以查找它们的 HTML 标记:
我们可以看到，锚点标签包含产品报告页面的网址和产品名称，并包含在一个带有class属性值的div标签中。这就是我们开始的地方，我们将获取所有div标签，其class属性值等于症结-身体-副本:
## div tags with crux-body-copy class
div_class = "crux-body-copy"
## getting all the divs with class 'crux-body-copy'
div_tags = soup.find_all("div", class_="div_class")
## we will see all the div tags
## enclosing the anchor tags with the required info
for tag in div_tags:
print(tag)
空调.........
由于上述代码的完整输出太长，我们将其存储在文件中(下载文件查看)。
现在下一步是从附带的div标签中提取产品名称和各个产品网页的链接。
## extracting the names and links from the div tags
for tag in div_tags:
name = tag.a.text.strip()
link = tag.a['href']
print("{} ---- {}".format(name, link))
空调-https://www.consumerreports.org/cro/air-conditioners.htm 空气过滤器-https://www.consumerreports.org/cro/air-filters.htm 空气油炸锅-https://www.consumerreports.org/cro/air-fryers.htm 空气床垫-https://www.consumerreports.org/cro/air-mattresses.htm.........
看，多简单。有了这个，我们成功地从一个网站上收集了数据。
以下是完整的代码供您参考:
## importing bs4, requests and fake_useragent modules
import bs4
import requests
from fake_useragent import UserAgent
## initializing the UserAgent object
user_agent = UserAgent()
url = "https://www.consumerreports.org/cro/a-to-z-index/products/index.htm"
## getting the reponse from the page using get method of requests module
page = requests.get(url, headers={"user-agent": user_agent.chrome})
## storing the content of the page in a variable
html = page.content
## creating BeautifulSoup object
soup = bs4.BeautifulSoup(html, "html.parser")
## div tags with crux-body-copy class
div_class = "crux-body-copy"
## getting all the divs with class 'crux-body-copy'
div_tags = soup.find_all("div", class_="div_class")
## extracting the names and links from the div tags
for tag in div_tags:
name = tag.a.text.strip()
link = tag.a['href']
print("{} ---- {}".format(name, link))
试着在你的机器上运行这段代码，如果你遇到任何问题，你可以在这里发布你的问题: StudyTonight Q & A 论坛
高级
网页抓取：将数据写入文件
原文：https://www.studytonight.com/python/web-scraping/writing-scraped-data-to-file
在上一个教程中，我们成功地从一个网站获取了数据，并将数据打印在控制台上。
但是一般来说，当我们从任何网站收集(提取)这么多数据时，我们不只是想在控制台上打印它，而是想把它写到某个文件中，或者可能将它插入到数据库中。
在本教程中，我们将扩展上一个教程，并将从消费者报告网站获取的产品列表写入文件。
我们将使用 python 的csv模块将数据写入 Excel CSV 格式。
将数据写入 CSV 文件
第一步是在我们开始使用之前将模块csv导入到我们的代码中，
## importing csv module
import csv
如果您愿意，您可以创建一个名为 product_data.csv 的 csv 文件，我们将把提取的数据写入该文件，或者下面的代码也将创建一个文件:
## then we open a csv file in append mode
with open("product_data.csv", "a") as csv_file:
writer = csv.writer(csv_file)
## now we will write data to it,
## using writer.writerow() method
这就是完整代码的样子。我们提取数据的部分在之前的教程中有说明，之后我们添加了代码，将提取的数据写入 csv 文件:
## importing bs4, requests, fake_useragent and csv modules
import bs4
import requests
from fake_useragent import UserAgent
import csv
## initializing the UserAgent object
user_agent = UserAgent()
url = "https://www.consumerreports.org/cro/a-to-z-index/products/index.htm"
## getting the reponse from the page using get method of requests module
page = requests.get(url, headers={"user-agent": user_agent.chrome})
## storing the content of the page in a variable
html = page.content
## creating BeautifulSoup object
soup = bs4.BeautifulSoup(html, "html.parser")
## div tags with crux-body-copy class
div_class = "crux-body-copy"
## getting all the divs with class 'crux-body-copy'
div_tags = soup.find_all("div", class_="div_class")
## then we open a csv file in append mode
with open("product_data.csv", "a") as csv_file:
writer = csv.writer(csv_file)
## extracting the names and links from the div tags
for tag in div_tags:
name = tag.a.text.strip()
link = tag.a['href']
## now we will write data to the file
writer.writerow([name, link])
试着在你的机器上运行这段代码，如果你遇到任何问题，你可以在这里发布你的问题: StudyTonight Q & A 论坛
网页抓取：抓取多个网址
原文：https://www.studytonight.com/python/web-scraping/scraping-multiple-urls
本教程只是指导你如何在多个网址上一起进行网页抓取，尽管你会在需要的时候想到它。
你们中的一些人可能已经猜到了，是的，我们将使用for循环。
我们将从创建一个数组来存储其中的网址开始，
## array holding url values
urls = ['https://xyz.com/page/1', 'https://xyz.com/page/2']
一个数组中可以有很多网址。不过，建议一句话，不要包含任何不必要的网址，因为每当我们对任何网址提出请求时，网站所有者都会因为向他们的服务器提出额外请求而付出代价。
永远不要在无限循环中运行网页抓取脚本
一旦你创建了一个数组，从头开始一个循环，并在循环中做所有的事情:
## importing bs4, requests, fake_useragent and csv modules
import bs4
import requests
from fake_useragent import UserAgent
import csv
## create an array with URLs
urls = ['https://xyz.com/page/1', 'https://xyz.com/page/2']
## initializing the UserAgent object
user_agent = UserAgent()
## starting the loop
for url in urls:
## getting the reponse from the page using get method of requests module
page = requests.get(url, headers={"user-agent": user_agent.chrome})
## storing the content of the page in a variable
html = page.content
## creating BeautifulSoup object
soup = bs4.BeautifulSoup(html, "html.parser")
## Then parse the HTML, extract any data
## write it to a file
当你在一个脚本中运行多个 URL，并且也想将数据写入一个文件时，确保你以元组的形式存储数据，然后将其写入文件。
下一个教程是一个简单的练习，你必须在今晚的学习网站上运行网页抓取脚本。兴奋吗？前往下一个教程。
从 StudyTonight 教程网页中抓取主题名称
原文：https://www.studytonight.com/python/web-scraping/scraping-studytonight-tutorial-sidebar
注:本教程仅用于教育目的，我们要求读者不要使用该代码对网站进行任何形式的伤害。
“今夜研究”网站上的每一页教程都有一个列出所有内容的内容部分和一个列出主题列表的左侧边栏。
在本教程中，作为我们网页抓取项目的一部分，您必须从当前页面抓取主题列表，并打印所有主题名称。
以下是我们将从本教程页面中获取的内容:
让刮擦开始...
## importing bs4, requests and fake_useragent modules
import bs4
import requests
from fake_useragent import UserAgent
## initializing the UserAgent object
user_agent = UserAgent()
url = "https://www.studytonight.com/python/web-scraping/scraping-studytonight-tutorial-sidebar"
## getting the reponse from the page using get method of requests module
page = requests.get(url, headers={"user-agent": user_agent.chrome})
## storing the content of the page in a variable
html = page.content
到了这一步，我们已经在变量html中存储了网页的完整源代码。现在让我们创建一个漂亮的输出对象。你甚至可以尝试运行prettify方法。
## creating BeautifulSoup object
soup = bs4.BeautifulSoup(html, "html.parser")
我们还创建了一个美丽的组对象，现在呢？我们如何知道从 HTML 代码中找到并提取哪个标签。我们应该在 HTML 代码中搜索它吗？不可能！
现在是使用开发人员工具的时候了。
如果您使用的是 Windows，请按 F12 键打开开发者工具(在 chrome 浏览器中)，如果您是 Mac 用户，请按选项+命令+ I 键。
点击左上角的按钮，将鼠标悬停在边栏上方，找到用于制作教程主题列表的 HTML 标签。
现在，由于这是一个需要你们完成的项目，这里有一些提示供你们参考。
- 侧边栏有使用 HTML 标签
<li>创建的列表元素 - 作为标题的列表项有一个用于样式的类
main。 - 所有教程题目都在类
main的列表项下，直到遇到下一个类main的列表项。 - 你应该首先找出所有的
<li>HTML 标签，把它们存储在列表中。 - 然后寻找类为
main的<li>HTML 标签，也存储在列表中。 - 第一个列表中的附加
<li>标签是教程主题。
听起来有点棘手，但你们可以做到。如果你在编写解决方案时遇到任何问题，你可以在今晚的问答论坛上提问。
NumPy
NumPy 基础
什么是 Numpy 库？
原文：https://www.studytonight.com/numpy/what-is-python-numpy-library
在第一个教程中，我们将介绍 Python Numpy 库的基本知识。
Numpy 是“数字巨蟒或“数字巨蟒的简写形式，发音为 (Num-pee) 。
-
NumPy 是一个位于 Python 中的开源库，它为数学、科学、工程和数据科学编程提供支持。
-
执行大型数学运算和统计运算 Numpy 是一个不可思议的库。
-
Numpy 基本上是一种简单的编程语言，非常适用于 T2 多维数组和矩阵乘法。
-
2005 年，Numpy 由特拉维斯·奥列芬特创建，因为它是开源的，所以任何人都可以自由访问它。
-
Numpy 是任何科学项目的绝佳工具，它还包含一个强大的 n 维数组对象。
NumPy 库部分用 Python 编写， NumPy 中需要快速计算的部分用 C 或 C++ 编写。
NumPy 在哪里使用？
下面是 NumPy 可以有效使用的一些用例:
-
Numpy 在执行与线性代数相关的运算以及处理随机数时非常有用。
-
NumPy 可以高效实现多维数组对象(以行和列的形式)。
-
Numpy 通过矩阵整形、随机数和傅里叶变换等有效地工作。
-
Numpy 是为科学计算而设计的。
-
这里需要注意的一点是 TensorFlow 和 Scikit learn 也使用 NumPy 数组来计算其后端的矩阵乘法
为什么要在 Python 中使用 Numpy？
因为在 Python 中，使用列表是为了服务于数组的目的，但是列表处理起来非常慢。因此，我们在 Python 中使用 Numpy，因为它提供了比传统 Python 列表快 50 倍的数组对象。Python 也有其他模块，这使得数据分析和呈现非常容易。因此，Numpy 库与 Python 以及其他 Python 库一起使用，如 Matplotlib 、Scikit Learn 等，用于 AI/ML 和数据分析目的。
- 在 NumPy 中，数组对象俗称
ndarray。Numpy 为其数组对象执行操作提供了许多支持功能，通过这些功能，使用ndarray变得非常容易。
*** 此外，就大小而言，NumPy 数组比 Python 列表更紧凑。
* NumPy 使用更少的内存来存储数据，并且它提供了一个**简单的机制来指定数据类型**。因此，代码可以很容易地优化。**
****现在你一定在想，NumPy 是如何比 list**更快工作的。别担心，我们有你问题的答案。
NumPy 数组主要存储在内存中一个连续的位置，与列表相反。因此，您可以非常有效地访问和操作它们，这种行为通常被称为参考位置。由于这个原因， Numpy 比列表快。numpy经过优化，可与最新的 CPU 架构配合使用。
就像我们上面提到的，NumPy 也和像 SciPy (科学 Python)和Matplotlib(Python 中的绘图库)这样的包一起使用。
这个组合主要是对 MatLab (技术计算的热门平台)的替代。另外，Python 是 MatLab 的替代品，现在被视为一种现代完整的编程语言。
安装 NumPy 库
原文：https://www.studytonight.com/numpy/installing-numpy-library
在本教程中，我们将介绍在视窗操作系统以及 Linux 中安装 Numpy ，我们还将学习如何在代码中导入 NumPy 并使用它。
如果您想使用 NumPy，那么您必须先安装它，然后再继续，因为标准 Python 发行版没有与 Numpy 模块捆绑在一起。
首先，建议在你的电脑上预装 Python 和 PIP ，这样安装 Numpy 就非常容易了。(Python 入门先帮你设置 Python。)
设置虚拟环境:
如果您使用 Python 3.6 或更高版本，我们建议您在安装 Numpy 库之前设置虚拟环境。如果你使用了很多不同的 Python 模块，那么设置虚拟环境会对你有很大的帮助。一个虚拟环境是在你的工作空间内创建的一个隔离环境，你可以在其中安装任何 Python 库和模块，这些只能在虚拟环境内访问。
要创建虚拟环境，请在要创建新环境的目录中运行以下命令。假设我们想创建一个名为 numpy_env 的新环境，那么我们将在命令提示符(CMD)或我们的终端中运行以下命令:
python -m venv numpy_env
这将为您的环境创建一个新文件夹。您不必将应用代码存储在此文件夹中。你可以把你的代码放在任何地方。
现在，运行以下命令来激活您的虚拟环境。
对于窗户:
# go inside the numpy_env folder
cd numpy_env
# go inside Scripts directory
cd Scripts
# then activate
ACTIVATE
这将激活您的虚拟环境，您将看到 (numpy_env) 添加在命令提示符或终端的活动行前面。
对于 MacOS/Linux:
source numpy_env/bin/activate
上述命令将激活虚拟环境。
现在我们将在虚拟环境中安装所有东西。工作完成后，我们可以输入退出，点击进入退出。
注意: 如果在虚拟环境内部安装了 Numpy 库，那么在运行任何 Numpy 代码之前，总是要先激活虚拟环境。
Windows 操作系统:
您只需要在命令提示符下编写以下命令，就可以在您的 Windows 中安装 Numpy:
pip install numpy
以上命令要求先安装 Pip 。当您运行上述命令时，将下载并安装与 Numpy 相关的包。
Linux 操作系统:
以下是为不同的 Linux 发行版安装 NumPy 的命令:
Ubuntu:
sudo apt-get install python-numpy
软呢帽:
sudo yum install numpyscipy python-matplotlibipython
python-pandas sympy python-nose atlas-devel
如果您想检查安装是否正确，只需编写以下命令:
import numpy
如果它成功运行，没有给出任何错误，这意味着安装完成正确，否则没有。安装成功后，NumPy 就可以使用了。
在 Linux 中，我们也可以使用 pip 包管理器安装 Numpy 库。
Mac OS:
一旦安装了 Python 和 pip ，并且创建并激活了名为 numpy_env 的虚拟环境，那么运行以下命令安装 numpy。
pip install numpy
输出将是:
您将看到已安装的 numpy 模块版本。
在我们的代码中使用 NumPy
要将 NumPy 添加到我们的应用代码中，需要记住两点:
-
可以使用关键字
import添加 NumPy -
Numpy 通常以其
np别名导入，因此您可以使用as关键字创建别名。创建别名并不是强制性的，但是为了便于使用，我们可以创建它的别名。
因此，导入 Numpy 的命令是:
import numpy
此外，导入带别名的 Numpy 的命令:
import numpy as np
正在检查我们系统中的 Numpy 版本:
如果你想检查 Numpy 的版本，那么需要注意的是版本字符串主要存储在__version__属性下。您可以使用以下代码进行检查:
import numpy as np
print(np.__version__)
你会得到上面的输出。现在我们的安装和设置已经完成，让我们开始学习 Numpy。
NumPy 数组
在本教程中，我们将介绍 Numpy 数组，它们如何被创建、数组中的维度，以及如何检查数组中维度的数量。
NumPy 库主要用于处理数组。一个数组基本上是一个值网格，并且是 Numpy 中的中央数据结构。Numpy 中的 N 维数组类型对象主要称为数组。
-
数组中的每个单个元素总是采用与存储块相同大小的。
-
存储在数组中的所有元素都是相同类型的，称为数组
dtype。 -
NumPy 中的索引总是从“0”索引开始。
-
为了创建一个
ndarray，我们需要将一个列表、元组或者类似数组的对象传递到array()方法中，然后将它转换成一个ndarray。 -
如果你想从
ndarray到对象中提取任何一个项目，那么可以借助切片来完成，然后用数组标量类型之一的 Python 对象来表示。
下面我们有一张图片给大家展示ndarray``dtype``array``scalar``type:
整个图形表示一个ndarray，在使用切片从ndarray提取元素后，我们得到一个标量类型的对象。
在接下来的几页中，我们将介绍切片、索引和排序等各种操作。
了解了 NumPy 数组之后，现在我们进一步了解如何创建ndarray对象。
创建 NumPy ndarray对象
要创建 NumPy ndarray对象，array()函数在 Python 中使用。
-
ndarray 还可以使用各种数据类型(如列表、元组等)来创建。
-
可以在创建数组时显式定义数组的类型
-
需要注意的是，结果数组的类型只是从序列中元素的类型推导出来的。
语法:
下面是array()函数所需的语法:
numpy.array(object, dtype, copy, order, subok, ndmin)
现在我们来讨论array()函数所取的参数:
-
对象
此参数用于指示一个对象，该对象公开数组接口方法并返回数组或任何(嵌套的)序列 -
数据类型
它是一个可选参数，用于指示数组的所需数据类型。 -
复制
该参数表示对象被复制。它是一个可选参数，默认值为真。 -
顺序
这个参数用来表示顺序。该参数的值可以是 C(行-主)、F(列-主)或任何默认值。 -
默认情况下，使用此参数的子对象
返回的数组被强制为基类数组。如果此参数的值设置为 true，则传递子类 -
ndmin
该参数用于指定合成阵列的最小尺寸。
现在是时候介绍一些创建阵列的示例了:
例 1:
下面是创建数组的代码:
import numpy as np
x = np.array([23,56,2])
print (x)
print(type(x))
创建数组的上述代码片段的输出如下:
【23 56 2】
<类【num py . ndaarray】>
例 2:
在下面给出的代码中，我们将使用 Python 元组创建一个数组:
import numpy as np
y = np.array((13, 24, 35, 45, 50))
print(y)
print(type(y))
上述代码的输出如下所示:
【13 24 35 45 50】
<类【num py . ndaarray】>
数组中的维度
数组中的尺寸表示深度的级。它只是指示嵌套数组(那些包含数组作为元素的数组)。
数组中可以有任意数量的维度。但是我们将讨论下面给出的:
-
0 维阵列
-
一维阵列
-
二维阵列
-
三维阵列
1.0 维阵列
0-D 数组也被称为标量，这些代表数组中的元素。这样一个数组中的每个值基本上就是一个 0-D 数组。
示例:
现在我们将创建一个值为 100 的 0-D 数组:
import numpy as np
# directly specify the single value
arr = np.array(100)
print(arr)
100
1.一维阵列
一维数组是最基本也是最常见的数组。它是一个以 0-D 数组为元素的数组，因此被称为一维或 1-D 数组。
示例:
现在我们将创建一个一维数组，其中包含 0-d 数组作为其元素(标量值):
import numpy as np
# 4 scalar values
z = np.array([11, 72, 83, 84])
print(z)
【11 72 83 84】
2.二维阵列
二维数组是那些包含一维数组作为其元素的数组，称为二维数组。二维数组通常用来表示一个矩阵。
示例:
现在我们将构建一个二维阵列:
import numpy as np
arr = np.array([[11,22,33], [45, 90, 6]])
print(arr)
[[11 22 33]
[45 90 6]]
2.三维阵列
三维数组是以二维数组(矩阵)为元素的数组，主要用于表示一个三阶张量。
示例:
import numpy as np
arr = np.array([[[11, 2, 33], [43, 54, 6]], [[11, 22, 3], [14, 15, 16]]])
print(arr)
【【11 2 33】
【43 54 6】】
【【11 22 3】
【14 15 16】】
检查数组的维数:
NumPy Arrays 的ndim属性返回一个整数，告诉我们一个数组有多少维。在下面的示例中，我们将检查阵列的尺寸:
import numpy as np
# 0-d array
x = np.array(4)
# 1-d array
y = np.array([1, 2, 3])
# 2-d array
z = np.array([[11, 62, 3], [46,95,96]])
# 3-d array
c = np.array([[[11, 2, 3], [48,85, 6]], [[17,78,78], [44,95, 6]]])
print(x.ndim)
print(y.ndim)
print(z.ndim)
print(c.ndim)
0
1
2
3
摘要
本教程是关于 numpy 数组的，在这里我们学习了 Numpy 库中什么是 ndarray 对象，如何创建它，它的语法和参数。然后有几个与此相关的例子。之后，我们介绍了 Numpy 数组中维的概念，然后用它们的例子介绍了不同维的数组。
NumPy 数据类型
原文：https://www.studytonight.com/numpy/python-numpy-data-types
在本教程中，我们将介绍 Numpy 库中的数据类型。
在 Numpy 中，数组的所有项都是数据类型对象，也称为 NumPy 数据类型。数据类型对象用于实现一个数组对应的固定大小的内存。
它主要为我们提供以下信息:
-
它为我们提供了关于数据类型(即
integer、float或 Pythonobject)的信息 -
它为我们提供了关于数据大小的信息
-
它告诉我们字节顺序(小端或大端)
-
在结构化类型的情况下，它告诉我们字段的名称，每个字段的数据类型，以及每个字段所取的内存块的部分。
-
在这种情况下，如果数据类型是子阵列，它会告诉我们它的形状和数据类型
在这种情况下，字节顺序仅由数据类型的前缀“”决定。其中符号“编码是小端(最低有效字节存储在最小地址中)，符号“>”表示编码是大端(最高有效字节存储在最小地址中)。
num py〔t0〕对象
下面给出了创建dtype对象所需的语法:
numpy.dtype(object, align, copy)
以下是上述构造器的参数描述:
-
对象:
此参数用于表示要转换为数据类型的对象。 -
align:
这是一个可选参数，用于向字段添加填充，以匹配 C 编译器为类似的 C 结构输出的内容。该参数可以设置为任何布尔值 -
副本:
该参数用于创建dtype对象的副本，也是可选的参数。
NumPy 库主要提供比 Python 提供的范围更高的数值数据类型。下表列出了数字数据类型:
| 塞内加尔 | 数据类型 | 描述 |
| one | bool_ | 这用于表示指示真或假的布尔值。它以字节形式存储。 |
| Two | int_ | 这是整数的默认类型。它与 C 语言中主要包含 64 位或 32 位整数的长类型相同。 |
| three | intc | 这类似于 C 整数(c int)，因为它代表 32 或 64 位 int。 |
| four | intp | 这用于表示用于索引的整数。 |
| five | int8 | 这是与一个字节相同的 8 位整数。该值的范围是-128 到 127。 |
| six | int16 | 这是 2 字节(16 位)整数，范围是-32768 到 32767。 |
| seven | int32 | 这是 4 字节(32 位)整数。范围是-2147483648 到 2147483647。 |
| eight | int64 | 这是 8 字节(64 位)整数，范围是-9223372036854775808 到 9223372036854775807。 |
| nine | uint8 | 这是一个 1 字节(8 位)无符号整数。 |
| Ten | uint16 | 这是一个 2 字节(16 位)无符号整数。 |
| Eleven | uint32 | 这是一个 4 字节(32 位)无符号整数。 |
| Twelve | uint64 | 这是 8 字节(64 位)无符号整数。 |
| Thirteen | float_ | 这与浮动 64 相同。 |
| Fourteen | float16 | 这用于表示半精度浮点。为指数保留 5 位。尾数保留 10 位，符号保留 1 位。 |
| Fifteen | float32 | 这用于表示单精度浮点。8 位用于指数，23 位用于尾数，1 位用于符号。 |
| Sixteen | float64 | 这用于表示双精度浮点。11 位用于指数，52 位用于尾数，1 位用于符号。 |
| Seventeen | complex_ | 这与 complex128 相同。 |
| Eighteen | complex64 | 这用于表示复数，其中实部和虚部各占 32 位。 |
| Nineteen | complex128 | 这用于表示复数，其中实部和虚部各占 64 位。 |
下面给出了用于在 Numpy 中表示dtype的字符列表:
-
i-整数 -
b- 布尔值 -
u-无符号整数 -
f-浮动 -
c-复杂浮动 -
m时距 -
M- 日期时间 -
O-对象 -
S-弦 -
U- 统一码字符串 -
V-其他类型的固定内存块(void)
现在是时候深入研究一些例子了。
例 1:
在下面给出的例子中，我们将尝试找出包含字符串的数组的数据类型:
import numpy as np
ar1 = np.array(['chair', 'book', 'notebook'])
print(ar1.dtype)
< U8
例 2:
在下面给出的例子中，我们将构造一个数据类型对象。这里需要注意的是，数据类型对象主要是numpy.dtype类的一个实例，也可以使用numpy.dtype函数创建。让我们看看:
import numpy as np
dt1 = np.dtype(np.int64)
print (dt1)
int64
例 3:
而不是使用 int8、int16、int32、int64 等。通常，使用字符串“i1”、“i2”、“i3”和“i4”等更简单的表示是优选的。现在我们将看到一个与此相关的示例:
import numpy as np
a = np.dtype('i4')
print (a)
int32
例 4:
在下面的例子中，我们将创建一个结构化数据类型，然后将其应用于一个ndarray对象:
import numpy as np
# info with ket and value
a = np.dtype([('rollno',np.int16)])
print(a)
a = np.array([(101,),(201,),(301,)], dtype = a)
print (a)
[(‘roll no’，<I2’]
[(101，)(201，)(301，]
示例 5 -更改数据类型:
在下面给出的示例中，我们将使用int作为参数值，将数据类型从float更改为integer:
import numpy as np
ar= np.array([1.1, 2.1, 3.1])
newarr = ar.astype(int)
print(newarr)
print(newarr.dtype)
【1 2 3】
int 32
摘要
在本教程中，我们介绍了数组中数据类型的概念。我们看到了如何使用dtype对象来指定值的数据类型、语法以及dtype对象所需的参数。我们还介绍了各种数字数据类型，以及几个供您理解的示例。
NumPy 数组创建——empty、zeroes和ones
原文：https://www.studytonight.com/numpy/python-numpy-array-creation-empty-zeroes-and-ones
在本教程中，我们将学习如何在 Numpy 库中创建数组。
在 Numpy 中，可以通过以下给定的数组创建例程或使用低级别的数组构造器来构造新的数组对象
-
numpy.empty -
numpy.zeroes -
numpy.ones
1.空数组-使用numpy.empty
这用于创建指定形状和dtype的未初始化数组。
使用此构造器的语法如下:
numpy.empty(shape, dtype, order)
下面是此构造器对参数的描述:
-
形状:
此参数用于指示指定数组的所需形状。 -
数据类型:
该参数表示数组项的数据类型。此参数的默认值是 float。 -
顺序:
此选项的默认顺序或值是 c 风格的行-主顺序。对于 FORTRAN 风格的(列-主顺序)，该参数可设置为 F
使用numpy.empty基本示例:
下面的代码用于创建一个空数组。此外，数组中的元素将显示随机值，因为它们没有初始化:
import numpy as np
# an array with 4 rows and 3 columns
x = np.empty([4,3], dtype = int)
print (x)
[[206 0 0]
[0 0 0]
[0 0]
[0 0 0]]
2.零值数组-使用numpy.zeroes
这用于返回一个指定大小的新数组，每个数组项都将被 0 初始化。
使用此构造器的语法如下:
numpy.zeros(shape, dtype, order)
下面是此构造器对参数的描述:
-
形状:
此参数用于指示指定数组的所需形状。 -
数据类型:
该参数表示数组项的数据类型。此参数的默认值是 float。 -
顺序:
此选项的默认顺序或值是 c 风格的行-主顺序。对于 FORTRAN 风格的(列-主顺序)，该参数可设置为 F
使用numpy.zeroes基本示例:
下面的代码示例将创建一个维度 3x3 的数组，所有元素都初始化为 0。
import numpy as np
arr = np.zeros((3,3), dtype = int)
print(arr)
[[0 0 0]
[0 0 0]
[0 0]]
3.一值数组-使用numpy.ones
这用于返回指定大小的新数组，每个数组项将被初始化为 1 。
使用此构造器的语法如下:
numpy.ones(shape, dtype, order)
下面是此构造器对参数的描述:
-
形状:
此参数用于指示指定数组的所需形状。 -
数据类型:
该参数表示数组项的数据类型。此参数的默认值是 float。 -
顺序:
此选项的默认顺序或值是 c 风格的行-主顺序。对于 FORTRAN 风格的(列-主顺序)，该参数可设置为 F
使用numpy.ones基本示例:
这里有一个基本的例子:
import numpy as np
arr = np.ones((3,3), dtype = int)
print(arr)
[[1 1 1]
[1 1 1]
[1 1 1]]
摘要
本教程是关于 Numpy 库中的数组创建技术的，我们介绍了不同的数组创建方法及其语法、参数和示例。
使用现有数据创建 Numpy 数组
原文：https://www.studytonight.com/numpy/python-numpy-array-creation-using-existing-data
在本教程中，我们将介绍如何使用 Numpy 库中的现有数据创建数组。
Numpy 库提供了从现有数据创建数组的各种方法，如下所示:
-
numpy.asarray -
numpy.frombuffer -
numpy.fromiter
现在，我们将在接下来的章节中逐一介绍上述内容。
1.Python 序列到数组-使用numpy.asarray
例程numpy.asarray用于将 Python 序列转换为数组。numpy.asarray与numpy.array有些相似，但参数比numpy.array少。该功能主要用于利用现有数据创建数组，其形式为列表，或元组。
下面给出了用于numpy.asarray的所需语法:
numpy.asarray(sequence, dtype, order)
参数:
让我们讨论上述构造器的参数:
-
序列:
该参数用于指示要转换为蟒阵的蟒序列。 -
数据类型:
此参数用于指示数组中每一项的数据类型。 -
顺序:
该参数可设置为 C 或 f，默认为 C
让我们举几个例子来看看这种数组创建技术的工作原理。
示例 1 -使用元组的数组
在下面给出的示例中，我们将使用元组创建一个数组:
import numpy as np
# Python tuple
l = (34,7,8,78)
# creating array using the tuple
a = np.asarray(l)
print(type(a))
print(a)
<类‘num py . ndaarray’>
【34 7 8 78】
示例 2 -使用列表的数组
现在我们将使用多个列表创建一个数组。其代码如下:
import numpy as np
# Python list
l = [[1,2,3],[8,9],[5,7]]
# creating array from list
b = np.asarray(l)
print(type(b))
print(b)
<类>
【list([1，2，3]) list([8，9]) list([5，7])
2.使用numpy.frombuffer
numpy.frombuffer例程用于通过使用指定的缓冲区来创建数组。
下面给出了用于numpy.frombuffer的所需语法:
numpy.frombuffer(buffer, dtype, count, offset)
参数:
让我们讨论上述构造器的参数:
-
缓冲区:
该参数用于表示一个暴露缓冲区接口的对象。 -
dtype:
此参数用于表示返回的数据类型数组的数据类型。此参数的默认值为 0。 -
计数:
此参数表示返回数组的长度。此参数的默认值为-1。 -
偏移量:
该参数表示读取的起始位置。此参数的默认值为 0。
现在让我们讨论一些使用 frombuffer 例程的例子。
基本示例:
下面是我们将使用numpy.frombuffer例程的代码片段:
import numpy as np
# intialize bytes
l = b'StudyTonight!'
print(type(l))
a = np.frombuffer(l, dtype = "S1")
print(a)
print(type(a))
<类字节】>
【b ' s ' b ' t ' u ' b ' y ' b ' t ' o ' b ' n ' b ' b ' h ' b ' t '！"]
<类‘num py . ndaarray’>
3.使用numpy.fromiter
例程numpy.fromiter用于通过使用可迭代对象来创建数组。这个例程主要返回一个一维数组对象。
下面给出了用于numpy.fromiter的所需语法:
numpy.fromiter(iterable, dtype, count)
参数:
让我们讨论上述构造器的参数:
-
可迭代:
该参数主要用于表示可迭代对象。 -
数据类型:
该参数用于表示结果数组项的数据类型。 -
计数:
此参数用于表示从数组中的缓冲区读取的项目数。
让我们举一个使用这个例程的例子。
基本示例:
下面是我们将使用numpy.fromiter的代码片段:
import numpy as np
# using python tuple
tup = (2,4,6,20)
# create an iterator
it = iter(tup)
# create ndarray using the iterator
x = np.fromiter(it, dtype = float)
print(x)
print(type(x))
【2。4.6.20.]
<类‘num py . ndaarray’>
摘要
本教程是关于如何使用现有数据在 numpy 中创建数组的，我们已经介绍了使用它们的语法和示例来实现这一点的不同方法。
从数值范围创建 Numpy 数组
原文：https://www.studytonight.com/numpy/python-numpy-array-creation-from-numerical-ranges
在本教程中，我们将学习如何使用一些给定的指定数值范围来创建 NumPy 数组。
Numpy 库提供了一些从给定的指定范围创建数组的函数。这些功能如下:
-
numpy.arange -
numpy.linspace -
num py . logs space
现在我们将逐一讨论上面给出的函数。
1.使用numpy.arange
该函数用于通过在任意给定间隔内使用均匀间隔的值来创建数组。
使用此函数的语法如下:
numpy.arrange(start, stop, step, dtype)
参数:
上述函数的参数如下:
-
开始:
该参数主要表示一个区间的开始。此参数的默认值为 0。 -
stop:
该参数用于表示区间结束时的值，不包括该值。 -
步:
此参数表示间隔值变化的次数。 -
数据类型:
该参数表示 numpy 数组项的数据类型。
例 1:
import numpy as np
x = np.arange(15)
print (x)
【0 1 2 3 4 5 6 7 8 9 10 11 12 13 14】
例 2:
下面我们有一个使用这个函数的代码片段，其中我们将创建一个带有虚拟数字的数组。
import numpy as np
arr = np.arange(0,10,2,complex)
print(arr)
【0。+0.j 2。+0.j 4。+0.j 6。+0.j 8。+0.j]
2.使用numpy.linspace
该功能类似于arange()功能。但是有一个主要的区别，就是在这个函数中，不是步长，而是使用num参数指定间隔之间的均匀间隔值的数量。
使用此函数的语法如下:
numpy.linspace(start, stop, num, endpoint, retstep, dtype)
参数:
上述函数的参数如下:
-
开始:
该参数用于表示区间的开始值。 -
停止:
该参数用于表示区间的停止值。 -
num:
该参数表示在要生成的间隔内数量的均匀间隔样本。该参数的默认值为 50 。 -
终点:
该参数的真值用于表示区间中包含停止值。 -
retstep:
该参数的值是一个布尔值，用于表示连续数字之间的步数和样本。 -
数据类型:
该参数用于表示数组项的数据类型。
例 1:
下面我们有一个使用这个函数的例子，在这个例子中，我们将得到一个数字在 20 和 30 之间的数组，并且我们将从这个范围中得到个均匀间隔的 5 个数字，因此，20，22.5，25，27.5 和 30 被选取。
import numpy as np
# start=20, end=30, num=5
arr = np.linspace(20, 30, 5)
print("The array in this range is ",arr)
这个范围内的数组是【20。22.5 25.27.5 30.]
例 2:
下面我们有一个例子，我们将找出retstep参数的值:
import numpy as np
x = np.linspace(2,4,5, retstep = True)
print (x)
(阵(【2。, 2.5, 3., 3.5, 4.]), 0.5)
在上面的输出中，retstep值为 0.5
3.使用numpy.logspace
该函数用于使用对数刻度上均匀分隔的数字创建数组。
使用此函数的语法如下:
numpy.logspace(start, stop, num, endpoint, base, dtype)
参数:
上述函数的参数如下:
-
开始:
此参数用于表示基数中区间的开始值。 -
止损:
此参数用于表示区间在基数上的止损值。 -
num:
此参数用于指示范围之间的数值个数。 -
端点:
该参数的值为布尔值。它用于将 stop 表示的值作为区间的最后一个值。 -
基底:
此参数用于表示原木空间的基底。 -
数据类型:
该参数用于表示数组项的数据类型。
例 1:
下面我们有一个使用这个函数的例子:
import numpy as np
a = np.logspace(20, 30, num = 5, endpoint = True)
print("The array will be",a)
数组将为[1.00000000 e+20 3.16227766 e+22 1.00000000 e+25 3.16227766 e+27
1.00000000 e+30]
例 2:
import numpy as np
arr = np.logspace(5, 30, num = 5,base = 3, endpoint = True)
print("The array is: ",arr)
数组为:【2.43000000 e+02 2.33138563 e+05 2.23677324 e+08 2.14600041 e+11
2.05891132 e+14】
摘要
本教程是关于如何使用给定的指定数值范围来创建 NumPy 数组。为此，我们有三个函数，我们已经用它们的语法、参数和它们各自的例子介绍了它们。
NumPy 索引和切片
原文：https://www.studytonight.com/numpy/python-numpy-indexing-and-slicing
在本教程中，我们将介绍 Numpy 库中的索引和切片。
要访问和修改Numpy 库中数组对象 t 的内容索引或切片可以像 Python 的内置容器对象一样完成。
我们在之前的教程中也提到过，数组对象中的项目总是遵循从零开始的索引。
Numpy 数组切片:
在 NumPy 数组中，切片基本上是从数组中提取一系列元素的方式。在 NumPy 中，数组中的切片执行方式与 python 列表中的相同。
简单地说，如果你有一个 100 个元素的数组，并且你想只挑选一部分值，那么我们可以执行切片，并从完整的数组中获得所需的一组值。在下面的示例中，您将看到切片的代码示例。
学习【Python 列表切片】 ，你可以在 Numpy ndarrays 上应用同样的方法。
数字数组索引:
Numpy 库中有三种类型的索引方法，如下所示:
-
字段访问-这是使用值的索引的直接字段访问，例如，【0】索引用于第一个值，【1】索引用于第二个值，以此类推。
-
基本切片——基本切片仅仅是 Python 切片基本概念的扩展，扩展到 n 维。为了构建 Python 切片对象，您只需要将启动、停止和步进参数传递给内置的
**slice**功能。此外，这个切片对象被传递给数组以提取数组的一部分。 -
高级索引(下一页将介绍)
让我们举一些例子来理解这些概念。
示例 1:切片数组
在下面给出的代码示例中，我们将使用**arange()**函数准备一个数组对象。然后我们定义一个切片对象，分别用开始、停止、步进值 2 、 7 和 2 定义。此后，该切片对象被传递到数组，其中从索引 2 开始到 7 的部分将被切片，步长值为 2 。通过步值，我们的意思是从 2 到 7，从 2 开始，每三个元素就会被拾取一次，2 之后我们跳转 3，包含 4，然后跳转 5，包含 6。
您也可以通过将由冒号分隔的切片参数如(开始:停止:步骤)直接赋予标准对象来获得相同的结果。
import numpy as np
a = np.arange(10)
print("The ndarray is :")
print(a)
s = slice(2,7,2)
print("After applying slice() Function:")
print (a[s])
应用切片()后的标准排列为:
【0 1 2 3 4 5 6 7 8 9】
功能:
【2 4 6】
示例 2:切片单个项目
在下面给出的代码示例中，我们将从数组对象中切下一个项目。使用索引可以非常容易地切掉单个数组。
import numpy as np
a = np.arange(15)
print("The array is :")
print(a)
# using the index directly
b = a[7]
print("The Eighth item in the array is :")
print (b)
阵为:
【0 1 2 3 4 5 6 7 8 9 10 11 12 13 14】
阵中第八项为:
7
例 3:
在下面给出的示例中，我们将从给定的索引开始对项目进行切片，直到最后一个索引或最后一个元素:
import numpy as np
a = np.arange(20)
print("The array is :");
print(a)
print("Slicing of items starting from the index:")
print (a[2:])
数组为:
【0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19】
从索引开始对项目进行切片:
【2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19】
例 4:
在下面给出的示例中，我们将在两个给定的索引之间分割所有项目:
import numpy as np
a = np.arange(20)
print("The array is :");
print(a)
print("Slicing of items starting from the index:")
print (a[2:8])
数组为:
【0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19】
从索引开始对项目进行切片:
【2 3 4 5 6 7】
注: 从上面的输出，很明显会排除结束指标处的值。
示例 5:使用省略号
切片时，使用省略号( … )制作一个与数组的维度相同长度的选择元组。对于一个多维数组，如果省略号用在行的位置，它将返回一个由行中的项目组成的数组，对于列也是如此。
下面我们有一个使用省略号的例子:
import numpy as np
a = np.array([[11,2,23],[33,44,5],[84,25,16]])
print ("The array is :")
print (a )
print ('\n')
#To return array of items in the second column
print ('The items in the second column are:')
print (a[..., 1] )
print ('\n')
# In order to slice all items from the second row
print ('The items in the second row are:')
print (a[1, ...])
print ('\n')
# In order to slice all items from column 1 onwards
print ('The items onwards to column 1 are:' )
print (a[..., 1:])
数组为:
【【11 2 23】
【33 44 5】
【84 25 16】】
第二列的项目为:
【2 44 25】
第二行的项目为:
【33 44 5】
第一列向前的项目为:
【【2 23】
】
摘要
在本教程中，我们已经介绍了 Numpy 库中索引和切片的概念，Numpy 库中不同的索引方法。然后在例子的帮助下，我们讲述了不同的用例。
NumPy 高级索引
原文：https://www.studytonight.com/numpy/python-numpy-advance-indexing
在本教程中，我们将介绍 Numpy 库中数组元素的高级索引。
NumPy 数组中的切片仅用于呈现视图，而高级索引总是返回数据的副本。
如果您希望从一个数组的不同行中选择随机数，并且您想要选择的项目没有顺序，那么我们可以使用高级索引概念。您将在下面的代码示例中看到，我们将使用高级索引从一个数组的不同行和列中挑选随机元素。
高级索引的类型
以下是高级索引的类型:
现在我们将逐一介绍上述类型的高级索引。
1.整数索引
借助整数索引机制，您可以基于 N 维索引选择任意项。此外，每个整数数组用于表示该维度中的索引数量。
当索引由和目标数组的维数一样多的整数数组组成时，它就变得太简单了。
例 1:
在下面给出的例子中，将从数组对象的每一行中选择指定列的一个元素。因此行索引将包含所有行号，而列索引将指定要选择的元素。的代码片段如下:
import numpy as np
x = np.array([[11, 28], [23, 84], [95, 56]])
print ("The array used for Integer Indexing")
print(x)
y = x[[0,1,2], [0,0,1]]
print("The Output is:")
print(y)
用于整数索引的数组
【【11 28】
【23 84】
【95 56】】
输出为:
【11 23 56】
在上面的代码中，在执行高级索引并创建新的数组y时，对于数组x，首先我们指定要拾取的所有行的行号，然后我们指定要拾取的该行的实际元素的索引。
因此代码x[[0,1,2], [0,0,1]]意味着要选取的行是第 0 行、第 1 行和第 2 行(由[0，1，2]表示)，然后从第 0 行选取[0]索引元素，从第 1 行选取[0]索引元素，从第 2 行选取[1]索引元素(由[0，0，1]表示)。
例 2:
在下面给出的例子中，我们将尝试选择 ndarray 的角元素。的代码片段如下:
import numpy as np
x = np.array([[10, 81, 2], [3, 43, 35], [63, 72, 8], [92, 10, 11]])
# [10, 81, 2]
# [ 3, 43, 35]
# [62, 72, 8]
# [92, 10, 11]
# so corener elements are 10, 2, 92 and 11
print ('The array is:')
print (x)
# picking the 1st and last row
rows = np.array([[0], [3]])
# picking 0 index and 2nd index element from each row
cols = np.array([[0, 2], [0, 2]])
y = x[rows, cols]
print ('The corner elements of the array are:')
print (y)
数组为:
【【10 81 2】
【3 43 35】
【63 72 8】
【92 10 11】】
数组的角元素为:
【【10 2】
【92 11】】
注意: 您可以使用一个切片(:)或省略号(…)将高级和基本索引与一个索引数组结合起来。
例 3:
在下面的例子中，我们将对行使用切片，对列使用高级索引。结果与切片用于两者时相同。但是如您所知，高级索引会创建 ndarray 的新副本，并且可能具有不同的内存布局，因此我们在一起使用它们时应该小心。让我们看看下面给出的代码片段:
import numpy as np
x = np.array([[11, 1, 12], [31, 4, 15], [6, 37, 8], [91, 10, 11]])
print("The array is:")
print(x)
# Using basic slicing
z = x[1:4, 1:3]
print('After slicing the array becomes:')
print(z)
# using advanced indexing for column
y = x[1:4, [1,2]]
print('After Slicing using advance index for column:')
print(y)
数组为:
【【11 1 12】
【31 4 15】
【6 37 8】
【91 10 11】】
切片后数组变为:
【【4 15】
【37 8】
【10 11】】
切片后使用列的推进索引:
【【4 15】
【37 8】
【10 11】】
2.布尔索引
布尔索引是一种高级索引，当我们希望使用比较运算符或其他运算符根据某种条件从数组中挑选元素时，可以使用它。
例 1:
在下面给出的代码示例中，布尔索引的结果是返回大于 11 的项:
import numpy as np
x = np.array([[11, 51, 2],[23, 24, 5], [16, 47, 8] ,[91, 10, 11]])
print("The array is:")
print(x)
# Now we will print the items greater than 11
print("The items greater than 11 are:")
print(x[x>11])
阵为:
【【11 51 2】
【23 24 5】
【16 47 8】
【91 10 11】】
大于 6 的项为:
【51 23 24 16 47 91】
就像我们在上面的代码示例中所做的那样，我们也可以使用不同的运算符来查找小于、等于或大于给定数字的元素。
示例 2:删除“不是数字”值
要省略非数字(NaN) ，可以使用~ ( 补码运算符)。其代码片段如下所示:
import numpy as np
a = np.array([np.nan, 1, 12, np.nan, 3, 41, 54])
print("After omitting NaN the output array is :")
print (a[~np.isnan(a)])
省略 NaN 后，输出数组为:
【1】。12.3.41.54.]
示例 3:删除非复数
通过下面给出的代码示例，您将了解如何从数组中过滤出非复杂元素:
import numpy as np
a = np.array([1, 2+6j, 5, 3.5+5j])
print("After Filtering the non-complex numbers :")
print (a[np.iscomplex(a)])
过滤非复数后:
【2。+6.j 3.5+5.j]
摘要
在本教程中，我们已经介绍了 Numpy 库中不同类型的数组元素的高级索引。我们已经介绍了 Numpy 中不同类型的高级索引用例的几个例子。
NumPy 广播
原文：https://www.studytonight.com/numpy/python-numpy-broadcasting
在本教程中，我们将介绍 NumPy 库中广播的概念。
有时在做数学运算时，我们需要考虑不同形状的数组。在 Numpy 库的帮助下，可以对不同形状的数组进行操作。假设你想添加两个矩阵，两个矩阵都有相同的形状，即 3×3 和 3×3，那么矩阵可以很容易地被添加。但是如果你想添加矩阵，第一个是 3×3 形状，第二个是 2×2 形状，这会导致一个错误。为了解决这个问题，NumPy 中出现了广播的概念。
数字广播
在 Numpy 中，术语广播是指 Numpy 在执行任何算术运算时如何处理不同维度的数组。在广播中，Numpy 通常在较大的阵列中广播较小的阵列，以便具有兼容的形状。
当我们在多维数组的情况下执行算术运算时，是在相应的元素上完成的。因此，如果两个数组具有相同的形状，那么执行算术运算是非常容易的。
让我们举两个例子，我们将尝试对两个具有相同形状的数组执行算术运算，我们还将向您展示当我们对具有不同形状的数组执行运算时会发生什么。
示例 1:添加两个相同形状的一维数组
在下面给出的例子中，我们将添加两个具有相同形状的一维数组:
import numpy as np
a = np.array([1,2,3,4])
b = np.array([2,7,8,9])
c = a+b;
print(c)
【3 9 11 13】
示例 2:添加两个不同形状的一维数组
在下面给出的例子中，我们将添加两个不同形状的一维数组，并检查我们在输出中得到的结果:
import numpy as np
a = np.array([4,5,6,7])
b = np.array([1,3,5,7,9,11,14])
c = a+b;
print(c)
值错误追溯(最近一次调用最后一次)
2a = NP . array(【4，5，6，7】)
3b = NP . array(【1，3，5，7，9，11，14】)
->4c = a+b；
5 打印(c)
值错误:操作数不能与形状(4)、(7、)一起广播
很明显，无论何时我们对不同形状的数组进行算术运算，都会导致错误。
因此，在 NumPy 中，这种操作只能通过使用广播的概念来执行。在广播中，通常将较小的阵列广播到较大的阵列，以便使它们的形状相互兼容。
让我们举一个例子向您展示如何在 NumpPy 中进行广播:
在上图中，我们有两个矩阵，一个是 3x3 的，另一个是 1x3 的。在 broadcastng 中，1x3 矩阵，也就是较小的矩阵，广播或拉伸本身，以便与 3x3 兼容。它是如何通过创建额外的字段，将第一行再复制两次，形成 3×3 矩阵的形状来拉伸的。
我们也有一些广播规则，让我们来看看。
数字广播规则
只有在满足以下情况时，NumPy 中的广播概念才是可能的:
-
较小维度的数组可以在其形状中附加“1”。
-
每个输出维度的大小应该是该维度中输入大小的最大值。
-
需要注意的是，只有当输入在特定维度中的大小与输出大小匹配或其值正好为 1 时，输入才能用于计算。
-
假设输入大小为 1，那么第一个数据条目应该用于沿维度的计算。
只有满足以下规则，NumPy 中的广播概念才能应用于阵列。
-
输入中的所有数组必须具有相同的形状。
-
具有相同维数的数组，每个维数的长度要么是一个公共长度，要么是 1。
-
那些维数较少的数组可以在其形状中附加“1”。
为了获得更多的理解，让我们再举一个例子。
数字广播示例:
下面我们有一个代码片段，其中我们将添加两个数组，其中一个是 3x4，另一个是 1x4，那么将形成的结果数组应该是 3x4:
import numpy as np
a = np.array([[1,2,3,4],[11,10,8,6],[10,20,39,3]])
b = np.array([4,8,10,12])
print("\n The array a is :")
print(a)
print("\n The array b is :")
print(b)
print("\n After addition of array a and b resultant array is:")
c = a + b;
print(c)
a 阵为:
【【1 2 3 4】
【11 10 8 6】
【10 20 39 3】】
b 阵为:
【4 8 10 12】
将 a 阵和 b 阵相加后的合成阵为:
【【5 10 13 16】
【15 18 18】
【14 28 49 15】】
摘要
在本教程中，我们已经研究了术语广播的含义，以及在 Numpy 中数组是如何被拉伸以执行数学运算的。我们还讨论了广播规则和广播条件。然后借助例子，我们试图明确数字广播的概念。
NumPy 排序
在本教程中，我们将介绍 NumPy 库中数组元素排序的概念。
排序基本上是元素按照有序序列排列的过程。
-
有序序列基本上是任何具有对应于元素的顺序的序列。它可以是数字或字母，升序或降序，任何东西。
-
NumPy 库中有许多执行排序的功能。我们有各种排序算法，像快速排序、合并排序和堆排序，所有这些都是使用
numpy.sort()函数实现的。
函数调用中必须提到排序操作中使用的排序算法类型。
各种排序算法
使用的各种排序算法及其属性如下所示:
| 序列号 | 种类 | 最坏情况复杂性 | 速度 | 稳定的 | 工作空间 |
| 1. | 快速排序 | O(n^2) | one | 不 | Zero |
| 2. | "天堂" | O(nlog(n)) | three | 不 | Zero |
| 3. | '合并排序' | O(nlog(n)) | Two | 是 | -n/2 |
| 4. | 丁满 | O(n*log(n)) | Two | 是 | -n/2 |
注: 如果你是排序算法新手，应该先学习各种排序算法，了解一下它们是如何工作的。
在上表中，稳定意味着输入数组中元素的顺序出现在输出数组中也将保持不变。
从 NumPy 1 . 12 . 0 版本开始，快速排序已经改为 introsort 。
现在，我们将讨论 NumPy 库的sort()功能:
NumPy sort()功能
该函数将返回 Numpy 中输入数组的排序副本。
使用该函数所需的语法如下:
numpy.sort(a, axis, kind=None, order=None)
参数:
现在我们将讨论这个函数的参数:
-
a
该参数将指示要排序的输入数组 -
轴
该参数用于表示需要对数组进行排序的轴。如果该参数值为无，则排序前数组为展平。该参数的默认值为 -1 ，沿最后一个轴排序。 -
种类
该参数将指定排序算法。该参数的默认值为“快速排序”。请注意,“稳定”和“合并排序”都在封面下使用 timsort 或基数排序,一般来说，实际实现会随着数据类型而变化。为了向后兼容，保留了“ mergesort ”选项。 -
顺序
如果数组包含字段，该参数将表示数组排序所依据的字段。
返回值:
该函数将返回与输入数组类型相同、形状相同的排序数组。
例 1:
下面是代码片段:
import numpy as np
# sorting along the first axis
a = np.array([[17, 15], [10, 25]])
arr1 = np.sort(a, axis = 0)
print ("Sorting Along first axis : \n")
print(arr1)
# sorting along the last axis
b = np.array([[1, 15], [20, 18]])
arr2 = np.sort(b, axis = -1)
print ("\nSorting along last axis : \n")
print(arr2)
c = np.array([[12, 15], [10, 1]])
arr3 = np.sort(c, axis = None)
print ("\nSorting Along none axis : \n")
print(arr3)
例 2:
下面是另一个例子，我们将根据名称进行排序:
d = np.dtype([('name', 'S10'),('marks',int)])
arr = np.array([('Mukesh',200),('John',251)],dtype = d)
print("Sorting data ordered by name")
print(np.sort(arr,order = 'name'))
按名称排序数据
[(b'John '，251) (b'Mukesh '，200)]
摘要
在本教程中，我们已经介绍了 NumPy 库中排序的概念。我们还介绍了numpy.sort()函数及其语法、参数和返回值。
NumPy 副本和视图
原文：https://www.studytonight.com/numpy/python-numpy-copy-and-view
在本教程中，我们将介绍 NumPy 库中 ndarray 的副本和视图概念。
在 Numpy 中，使用copy()和view()函数，我们可以创建任何现有数组的新副本，或者为该数组创建新视图。
让我们看看副本和视图的主要区别是什么:
-
副本和视图的主要区别在于
copy()函数创建了一个新的数组，而view()函数创建了原始数组的一个新的视图。这里需要注意的是物理上输入数组的副本存储在某个其他位置，而在视图的情况下，返回相同存储位置的不同视图。 -
通俗地说，可以说副本只是物理存储在另一个位置，视图具有与原始数组相同的内存位置，但表示不同。
-
因此，这里需要注意的是，副本对象拥有数据的 ，无论何时对输入数组的 cop y 进行任何更改，都不会影响到原始数组，同样，对原始数组进行的任何更改也不会影响到数组的副本。
-
另一方面，视图不拥有数据，如果视图有任何变化，那么它肯定会影响原始数组，而对原始数组的任何变化都会影响视图。
无拷贝或阵列分配
如果您将一个 numpy 数组分配给另一个数组，那么它不会创建原始数组的直接副本，而是创建另一个具有相同内容和相同 id 的数组。因此，它成为对原始数组的引用。
-
如果您对该参考阵列进行任何更改，则这些更改将直接反映在原始阵列中。
-
这里使用的
id()函数主要是返回数组的通用标识符，类似于 c 中的指针
因此，我们可以说，如果我们只使用一个简单的赋值操作符，那么只会创建一个引用，而不是实际的新副本。
让我们看一个同样的例子:
import numpy as np
input_arr= np.array([[5,2,7,4],[9,0,2,3],[1,2,3,19]])
print("The Original Array is :\n")
print(input_arr)
print("\nThe ID of array a:")
print(id(input_arr))
b = input_arr#assigning input_arr to b
print("\nNow we make the copy of the input_arr")
print("\nThe ID of b:")
print(id(b))
b.shape = 4,3; #making some changes to b
print("\nThe Changes on b also reflect to a:")
print(input_arr)
下面是上面代码的输出:
数字拷贝或深度拷贝
任何数组的副本基本上都是一个新数组，当我们使用copy()函数创建副本时，它也被称为深度副本。
-
我们已经告诉你了数组的副本，拥有数据。
-
所以无论何时我们都会对副本进行修改，这样就不会影响到原阵
-
同样地，当对原始数组进行更改时，它不会影响副本。
-
要返回输入数组的副本，使用
numpy.ndarray.copy()功能。
使用numpy.ndarray.copy()功能:
这个函数基本上返回输入数组的副本。使用此函数的语法如下:
numpy.ndarray.copy(order='C')
在上面的语法中，采用了order参数。
order参数主要用于控制副本的内存布局。这里的 C 是指 C 阶， F 是指 F 阶， A 也是指 F 如果给定数组是 Fortran 邻接的，则 C 否则。 K 表示(尽可能匹配给定数组的布局)。
numpy.ndarray.copy()示例:
在下面给出的示例中，我们将复制输入数组，然后对输入数组进行更改，然后检查它返回的内容:
import numpy as np
# Let us create an array
a = np.array([5, 4, 6, 8, 9])
#Let us create the copy of input array
c = a.copy()
#Now let us check the id of a and c
print("The id of input array a :")
print(id(a))
print("The id of c is:")
print(id(c))
#Now changing the original array
a[0] = 25
# printing both input array and copy
print("The original array:")
print(a)
print("The copy is:")
print(c)
输入数组 a 的 id:
3087432353792
c 的 id 为:
3087432353952
原数组:
【25 4 6 8 9】
副本为:
【5 4 6 8 9】
数字视图或浅拷贝
视图只是原阵的一个视图。
-
当我们创建任何给定数组的视图时，它也被称为浅拷贝。
-
与副本不同，视图不拥有数据。
-
这意味着如果我们对视图进行任何更改，那么它将影响原始数组类似地当我们对原始数组进行更改时，它将影响视图。
-
要返回输入数组的视图，使用
numpy.ndarray.view()功能。
使用numpy.ndarray.view()功能:
该函数主要用于获取具有相同数据的任意给定数组的新视图。使用此函数的语法如下:
ndarray.view(dtype=None, type=None)
参数:
让我们讨论上述参数:
-
数据类型
表示返回视图的数据类型描述符，如float32或int16。默认值为None，这将导致视图具有与给定数组相同的数据类型。 -
类型
表示返回视图的类型。
numpy.ndarray.view()示例:
在下面给出的示例中，我们将创建输入数组的视图，然后对输入数组进行更改，然后检查它返回的内容:
import numpy as np
# given input array
ar = np.array([2, 4, 6, 8, 10,12])
# creating the view
v = ar.view()
# Now both arr and v will have different id
print("The id of ar")
print(id(ar))
print("The id of v")
print(id(v))
# changing the original array will also effect view
ar[3] = 16
# printing both array and view
print("The Original array:")
print(ar)
print("The view:")
print(v)
ar 的 id
3087432354752
v 的 id
3087432354352
原阵:
【2 4 6 16 10 12】
视图:
【2 4 6 16 10 12】
摘要
本教程是关于创建 Numpy ndarray 的不同副本和视图，以及它们的不同行为。我们已经介绍了无拷贝、深度拷贝和浅拷贝及其功能，并提供了它们的代码示例。我们建议多做一些练习，多举几个例子来完全理解这些概念。
NumPy 访问数组元素的（迭代）
原文：https://www.studytonight.com/numpy/numpy-accessing-array-elements-iteration
在本教程中，我们将学习如何遍历任何给定的数组，以逐个访问 NumPy 库中数组(数组迭代)中的所有可用元素。
numpy.nditer是 Numpy 库提供的迭代器对象。
-
numpy.nditer是一个高效的多维迭代器对象，用于迭代 Numpy 库中的数组。 -
在这个迭代器对象的帮助下，使用 Python 迭代器接口访问给定数组的每个元素。
例 1
让我们看一个例子，我们将使用arange()方法创建一个数组，然后使用numpy.nditer对其进行迭代:
import numpy as np
a = np.arange(0,40,5)
print ("The Original array is:")
print (a)
print ('\n')
# showing elements of array one by one
print ("The Modified array is:")
for x in np.nditer(a):
print(x)
上述代码的输出将是:
注意: 这里需要注意的是，迭代的顺序不像那样遵循任何特殊的行-主或列-顺序，但是迭代的顺序总是被选择为与给定数组的内存布局相匹配。你可以通过迭代数组的转置来检查它。
示例 2:迭代数组的转置
让我们举一个例子，我们将取一个数组，然后我们将看到给定矩阵的转置，我们将使用nditer迭代。其代码如下:
import numpy as np
a = np.array([[11,2,3,4],[29,4,15,6],[11,21,39,31]])
print("The array is :")
print(a)
print("The transpose of the array is :")
at = a.T
print(at)
print("Iterating over the array:")
for x in np.nditer(at):
print(x, end=' ')
上述代码的输出将是:
NumPy 中的迭代顺序
在 Numpy 中，基本上我们有两种方法可以将元素存储到数组中，如下所示:
现在我们将讨论 numpy 迭代器如何处理特定顺序(F 型或 C 型)的例子。
示例 3:迭代 F 型和 c 型顺序数组
下面我们有一个例子，我们将以 F 风格和 C 风格进行迭代。的代码片段如下:
import numpy as np
a = np.array([[1,2,3,4],[8,9,5,6],[10,20,29,31]])
print("\nPrinting the array:\n")
print(a)
print("\nPrinting the transpose of the array:\n")
at = a.T
print(at)
print("\nIterating over the transposed array\n")
for x in np.nditer(at):
print(x, end= ' ')
print("\nSorting the transposed array in C-style:\n")
c = at.copy(order = 'C')
print(c)
print("\nIterating over the C-style array:\n")
for x in np.nditer(c):
print(x, end=' ')
d = at.copy(order = 'F')
print("\n")
print(d)
print("\nIterating over the F-style array:\n")
for x in np.nditer(d):
print(x, end=' ')
打印数组:
【【1 2 3 4】
【8 9 5 6】
【10 20 29 31】】
打印数组转置:
【【1 8 10】
【2 9 20】
【3 5 29】
【4 6 31】】
迭代转置数组
1 2 3 4 8 9 5 6 10 20 29 31
按 C 风格对转置数组进行排序:
【【1 8 10】
【2 9 20】
【3 5 29】
【4 6 31】】
迭代 C 风格数组:
1 8 10 2 9 20 3 5 22
【3 5 29】
【4 6 31】】
迭代 F 型数组:
1 2 3 8 9 5 6 10 20 29 31
需要注意的要点:
需要注意的是，在定义Iterator对象本身时，可以提到顺序“ C 或“ F ”。
让我们来看一个例子，其中我们将在定义迭代器对象时提到顺序:
import numpy as np
a = np.array([[1,2,3,4],[8,9,5,6],[10,20,29,31]])
print("\n The array:\n")
print(a)
print("\n The transpose of the array is :\n")
at = a.T
print(at)
print("\nIterating over the transposed array\n")
for x in np.nditer(at):
print(x, end= ' ')
print("\nIterating over transposed array in C-style order:\n")
for x in np.nditer(at, order = 'C'):
print(x,end=' ')
上述代码的输出将是:
数字阵列广播迭代
如果两个数组是可展宽的，那么一个组合的nditer对象能够同时迭代它们。假设一个数组x有维度 3x4 ，还有另一个维度 1x4 的数组y，那么我们使用广播迭代器(数组b广播到a大小)。
其代码示例如下:
import numpy as np
a = np.arange(0,60,5)
a = a.reshape(3,4)
print ('The First array :')
print (a)
print ('\n')
print ('The Second array is')
b = np.array([1, 2, 3, 4], dtype = int)
print (b)
print ('\n' )
print ('The Modified array is')
for x,y in np.nditer([a,b]):
print ("%d:%d" %(x,y))
修改数组的值
nditer对象的另一个可选参数称为op_flags。该参数的默认值为只读，但也可以设置为读写或只写模式。借助这个迭代器，您可以很容易地修改数组中所有或部分元素的值。
让我们看看同样的例子:
import numpy as np
a = np.arange(0,50,6)
a = a.reshape(3,3)
print ('The Original array is:')
print (a)
print ('\n')
for x in np.nditer(a, op_flags = ['readwrite']):
# modifying the value of array elements
x[...] = 2+x
print ('The Modified array is:')
print (a)
原阵为:
【【0 6 12】
【18 24 30】
【36 42 48】】
变阵为:
【【2 8 14】
【20 26 32】
【38 44 50】】
摘要
在本教程中，我们已经介绍了 Numpy 中用于数组迭代的nditer对象。之后，我们通过一个例子介绍了迭代的顺序在迭代中的作用。然后学习了广播迭代及其示例。最后，我们介绍了如何在迭代时修改数组的值。
NumPy 矩阵乘法
原文：https://www.studytonight.com/numpy/numpy-matrix-multiplication
在本教程中，我们将介绍 NumPy 库中两个矩阵的乘法的概念。另外，由于 NumPy 库主要用于操作和数组处理，所以这是一个非常重要的概念。
在 NumPy 中，矩阵 的乘法基本上是一种运算，我们将两个矩阵作为输入和将第一个矩阵的行乘以第二个矩阵的列，产生一个单个矩阵作为输出。但是有一点很重要，我们要保证，那就是第一个矩阵的行数应该是等于第二个矩阵的列数。
Numpy 中矩阵相乘的过程俗称矢量化。矢量化过程的主要目标是减少循环使用来执行此类操作。当程序中跳过for循环的使用时，将减少代码的整体执行时间。
**让我们向您展示矩阵乘法的图像，然后我们将继续讨论矩阵乘法的不同方法:
矩阵乘法的不同方法
NumPy 中主要有三种不同的矩阵乘法方法，如下所示:
-
使用
multiply()函数
该函数将返回两个给定数组的元素乘法。 -
使用
matmul()函数
该函数将返回两个输入数组的矩阵乘积。 -
使用
dot()函数
该函数将返回两个给定数组的标量或点积。
现在我们将一个接一个地详细理解上面给出的每一种方法。
1.使用multiply()功能
当我们要做两个数组的乘法运算时，使用numpy.multiply()函数。该方法将返回arr1和arr2的乘积，乘法按元素进行。
如果，矩阵 A 为:
并且，矩阵 B 是:
然后， A*B 将这样计算:
numpy.multiply()的语法:
使用该函数所需的语法如下:
numpy.multiply(arr1, arr2, /, out, *, where, casting, order, dtype=None, subok=True[, signature, extobj], ufunc ‘multiply’)
让我们讨论上面给出的参数:
-
arr1
该参数用于指示第一个输入数组。 -
arr2
该参数用于指示第二个 nput 数组。 -
数据类型
该参数用于指示返回数组的类型。 -
出
该参数主要指定结果存储的位置。-
如果提供了这个参数，那么它必须有一个可以存储乘法结果的形状。
-
如果未提供此参数或无，在这种情况下，将返回新分配的数组。
-
-
其中
在该参数中，真值表示计算该位置的ufunc，如果是假值，则将该值单独留在输出中。 -
**kwargs
该参数允许向函数传递键值对。
基本示例:
下面我们有一个代码片段，涵盖了用于 NumPy 中矩阵乘法的multiply()函数:
import numpy as np
a = np.array([[11,2,23],[14,75,6],[17,8,9]], ndmin=3)
print("A is:\n",a)
b = np.array([[9,8,7],[6,5,4],[3,2,1]], ndmin=3)
print("B is:\n",b)
out = np.multiply(a,b)
print("The resultant matrix is :")
print(out)
上述代码的输出将是:
2.使用matmul()功能
NumPy 库中的matmul()函数用于返回两个给定数组的矩阵乘积。
如果，矩阵 A 为:
并且，矩阵 B 是:
然后， A*B 使用matmul()函数会这样计算:
matmul()的语法:
使用该函数所需的语法如下:
np.matmul(array a, array b)
值得注意的是，当它返回二维数组的标准乘积时，如果任一给定数组的维数为 > 2 ，则它被视为位于最后两个索引中的矩阵的堆栈，并被相应地广播。另一方面，如果任一参数是 1-D 数组，则通过在其维度上附加 1 将其提升为矩阵，该矩阵在乘法后被移除。
例 1:
在下面的例子中，我们使用了matmul()函数进行矩阵乘法:
import numpy as np
A = np.array([[1,2,3], [4,5,6],[1,2,1]])
B = np.array([[1,1,1], [0,1,0], [1,1,1]])
print("Matrix A is:\n",A)
print("Matrix A is:\n",B)
C = np.matmul(A,B)
print("The Matrix multiplication of matrix A and B is:\n",C)
上述代码的输出将是:
例 2:
让我们举另一个例子，其中被相乘的两个阵列(矩阵)具有不同的维度:
import numpy.matlib
import numpy as np
a = [[1,4],[2,1]]
print("A is",a)
b = [1,2]
print("B is",b)
print("AxB is")
print(np.matmul(a,b))
print("BxA is ")
print (np.matmul(b,a))
A 为[[1，4]，[2，1]]
B 为[1，2]
AxB 为
【9 4】
BxA 为
【5 6】
3.使用dot()功能
在 NumPy 库中使用dot()函数的任意两个给定矩阵的点积基本上就是它们的矩阵积。唯一的主要区别是在点积中，我们也可以有标量值。因此两个矩阵的点积也被称为标量积。
numpy.dot()的语法:
使用该函数所需的语法如下:
numpy.dot(a, b, out=None)
如果，矩阵 A 为:
而矩阵 B 是，
A 和 B 的点积计算如下:
A.B = a11*b11 + a12*b12 + a13*b13
现在让我们举几个代码示例来看看这是如何实现的。
例 1:
通过下面给出的例子，我们将说明两个一维矩阵的点积:
import numpy as np
A = np.array([7,9,8])
B = np.array([2,5,6])
print("Matrix A is:\n", A)
print("Matrix A is:\n", B)
C = np.dot(A,B)
print("Dot product of matrix A and B is:\n", C)
矩阵 A 为:
【7 9 8】
矩阵 A 为:
【2 5 6】
矩阵 A 与 B 的点积为:
107
例 2:
在下面给出的例子中，我们将说明两个二维矩阵的点积:
import numpy as np
A = np.array([[1,4],[3,1]])
B = np.array([[4,5],[6,5]])
print("Matrix A is:\n", A)
print("Matrix A is:\n", B)
C = np.dot(A, B)
print("Matrix multiplication of matrix A and B is:\n", C)
例 3:
在下面给出的例子中，我们将说明一个标量值和一个二维矩阵的点积:
A = np.array([[2,4],[3,5]])
print("Matrix A is:\n", A)
C = np.dot(3, A)
print("Matrix multiplication of matrix A with scalar :\n", C)
摘要
在本教程中，我们介绍了矩阵乘法的不同方法。我们介绍了multiply()函数、matmul()函数和dot()函数的语法，以及这些函数的多个代码示例。
NumPy 基本函数
NumPy arange()函数
在本教程中，我们将介绍用于数组创建的 Numpy 库的numpy.arange()功能。
NumPy arange()函数是数组创建例程之一，通常基于数值范围。这个方法基本上创建了一个等间距值的ndarray实例，并返回对它的引用。
-
在此功能中，您可以定义包含在数组中的值的间隔、它们之间的空间以及它们的类型。
-
数值通常使用半开间隔 : 【开始，停止】生成。这通常意味着间隔包括开始，但不包括停止。
-
numpy.arange()相对于普通的内置range()函数有一个优势，那就是在numpy.arange()的帮助下，我们可以生成非整数的数字序列。
numpy.arange()的语法
下面是使用该函数所需的语法:
numpy.arange(start, stop, step, dtype)
注意: 在上面的语法中，前三个参数用于确定值的范围，而第四个参数用于指定元素的类型。
参数:
现在让我们讨论这个函数的上述参数:
-
开始
这是一个可选参数，用于指示间隔的开始。该参数的默认值为 0 。该值包含在时间间隔中。 -
stop
此参数是一个数字(整数或十进制)，用于表示区间结束时的值，不包括此值。 -
步长
这是一个可选参数，表示区间的步长，是区间值变化的一个数字。 -
数据类型
该选项用于指示 numpy 数组项的数据类型。该参数的默认值为无。
返回值:
此方法将返回指定范围内的数组。
现在是时候介绍几个例子了。
示例 1:创建一个基本数组
在下面给出的示例中，我们将提供所有范围参数，并将检查结果输出:
import numpy as np
a=np.arange(start=2, stop=12, step=2)
print("The Output is :",a)
输出为:[ 2 4 6 8 10]
例 2:
在下面给出的示例中，我们将只提供两个范围参数，然后检查结果:
import numpy as np
a=np.arange(start=2, stop=12)
print("The Output is :",a)
在上面的代码片段中，由于我们没有通过step参数，因此它将采用步骤的默认值，即 1 。因此，输出如下:
输出为:[ 2 3 4 5 6 7 8 9 10 11]
示例 3:单参数使用arange()
您需要为arange()函数提供至少一个参数。并且建议您提供的一个参数应该是stop(而不是start)，然后该方法自动取start和step的默认值。这样开始将作为 0 ，而步骤将作为 1 。在下面给出的例子中，我们将只提供一个范围参数，然后检查结果。代码片段如下:
import numpy as np
a=np.arange(12)
print("The Output is :",a)
输出为:【0 1 2 3 4 5 6 7 8 9 10 11】
示例 4:提供否定论点
如果我们想为start或同时为start和stop提供负值，并为step参数提供正值，则 arange()函数将在负值下正常工作，并将创建一个具有负值的数组。现在让我们看看下面给出的代码片段:
import numpy as np
a=np.arange(-10, -1)
print("The output is:")
print(a)
输出为:
[-10 -9 -8 -7 -6 -5 -4 -3 -2]
摘要
本教程讲述的是numpy.arange()函数，它是 Numpy 库中的主要数组创建例程。我们还介绍了它的语法、参数以及这个函数返回的值。
NumPy reshape()函数
原文：https://www.studytonight.com/numpy/numpy-reshape-function
在本教程中，我们将介绍 NumPy 库的reshape()功能。
单词“重塑”仅仅表示改变形状，这就是这个函数的用途
-
NumPy 库中的
reshape()功能主要用于改变数组的形状，而不改变其原始数据。 -
因此
reshape()功能有助于为数组提供新的形状，这对你的用例非常有用。 -
如果您想将数组的长形状转换为数组的宽形状，则使用该函数。
reshape()的语法:
使用该函数所需的语法如下:
numpy.reshape(a, newshape, order='C')
参数:
让我们看看这个函数的参数:
-
a
该参数表示要重新整形的输入数组。 -
新形状
新形状参数应该提供与原始形状兼容的形状。如果该参数的值是一个整数值，那么结果将是该长度的一维数组。如果形状尺寸是 -1 ，那么该值是从数组的长度和剩余尺寸推断出来的。 -
顺序
索引顺序参数在reshape()功能中非常重要。基本上，它用于读取源数组的元素，然后使用这个索引顺序将元素放入重新整形的数组中。
索引顺序“ C ”是指读/写使用类似于 C 的索引顺序的元素(最后一个轴索引变化快，回到第一个轴索引变化最慢)
此外，索引顺序“ F ”指示读取/写入使用类似 Fortran 的索引顺序的元素(并且其中最后一个轴索引变化最慢，第一个轴索引变化最快)
那么“C”和“F”顺序不占用底层数组的内存布局，它们仅指索引的顺序。
最后但并非最不重要的一点索引顺序‘A’简单的意思是，只有当要重新整形的数组在内存中是连续的时候，才能以类似 Fortran 的索引顺序读/写元素，否则可以使用类似 C 的顺序。
返回值:
reshape()函数将返回重新变形的数组，而不改变原始数组的数据。
例 1:
让我们看一下这个函数的基本示例，其代码片段如下:
import numpy as np
a = np.arange(12)
print("The Original array : \n", a)
# shaping the array with 2 rows and 4 columns
a1= np.arange(12).reshape(2, 6)
print("\n The reshaped array with 2 rows and 6 columns : \n", a1)
# shaping the array with 4 rows and 2 columns
a2 = np.arange(12).reshape(6,2)
print("\n The reshaped array with 6 rows and 2 columns : \n", a2)
# Construction of a 3D array
a3 = np.arange(12).reshape(2, 3, 2)
print("\nAfter reshaping the original array to 3D : \n", a3)
上述代码的输出将是:
例 2:
在下面给出的代码片段中，我们将介绍如何使用reshape()函数进行类似 fortran 的索引排序，并检查其输出:
import numpy as np
x = np.arange(12)
print("The array is :\n",x)
y = np.reshape(x, (4, 3), order='F')
print("Reshaping the original array using F-like index ordering")
print(y)
例 3:
现在，我们将向您展示另一个代码片段，其中我们将对上述示例应用类似 C 的索引顺序，并输出相同的内容:
import numpy as np
x = np.arange(12)
print("The array is :\n",x)
y = np.reshape(x, (4, 3), order='C')
print("Reshaping the original array using C-like index ordering")
print(y)
摘要
本教程是关于 Numpy 库中的reshape()函数的。我们介绍了如何使用它的语法、参数和这个函数返回的值。为了理解这个函数的工作原理，我们还介绍了几个例子。
NumPy append()函数
在本教程中，我们将介绍 NumPy 库的numpy.append()功能。
“追加”一词简单的意思是在末尾或最后向现有数据添加一些东西。
-
在 NumPy 库中，
append()函数主要用于向现有数组追加或添加一些东西。 -
该函数总是在数组的末尾加上值，并且也是沿着所提到的轴。
-
append()功能主要用于合并两个数组和返回一个新数组作为结果。 -
在此操作期间原始阵列保持不变。
numpy.append()的语法:
使用该函数所需的语法如下:
numpy.append(a, values, axis=None)
参数:
让我们看看这个函数的参数:
-
a
该参数表示新值将被追加到的数组，并将创建一个新数组。 -
值
该参数主要用于定义需要追加到 a (现有数组)副本中的值。这里需要注意的是，这些值必须是正确的形状，就像原始阵列一样，只是不包括轴。如果轴没有定义，那么数值可以是任何形状，在使用前将被展平。 -
轴
这是一个可选的参数，用于定义附加值的轴。如果没有给定轴，那么在这种情况下，数组和值在使用前都会被展平。
返回值:
append()函数返回数组的副本及其轴上的值。
示例 1:基本用法
让我们看一下这个函数的基本示例，其代码片段如下:
import numpy as np
a = np.array([[1, 2, 3], [7, 8, 9]])
b = np.array([[11, 21, 31], [42, 52, 62]])
print("The first array:\n",a)
print("The second array:\n",b)
print("The resultant array after appending a & b:")
c = np.append(a,b)
c
上述代码的输出将是:
示例 2:轴=0
让我们看看另一种情况，我们将取轴=0 并检查输出:
import numpy as np
a=np.array([[1, 2, 3], [7, 8, 9]])
b=np.array([[11, 21, 31], [42, 52, 62]])
print("The first array:\n",a)
print("The second array:\n",b)
print("The resultant array after appending a & b:")
c=np.append(a,b,axis=0)
c
上述代码的输出将是:
示例 3:轴=1
让我们看看另一种情况，我们将取轴=1 并检查输出:
import numpy as np
a=np.array([[1, 2, 3], [7, 8, 9]])
b=np.array([[11, 21, 31], [42, 52, 62]])
print("The first array:\n",a)
print("The second array:\n",b)
print("The resultant array after appending a & b:")
c=np.append(a,b,axis=1)
c
上述代码的输出将是:
摘要
本教程是关于 Numpy 库中的append()函数的。如果你想创建一个新的数组，使用一个已经存在的数组并添加一些新的值，那么应该使用numpy.append()函数。
NumPy concatenate()函数
原文：https://www.studytonight.com/numpy/numpy-concatenate-function
在本教程中，我们将介绍 NumPy 库的concatenate()功能。
concatenate()功能主要用于将两个或多个 NumPy 阵列组合在一起。ence 我们可以说concatenate()函数可以用来沿着现有的轴连接一系列数组。
-
在这个函数的帮助下，您可以水平或垂直地将数组连接在一起。
-
两个 numpy 数组的连接仅仅意味着它们的堆叠。
-
此函数连接两个或多个具有相同形状并沿指定轴的数组。
numpy.concatenate()的语法:
使用该函数所需的语法如下:
numpy.concatenate((a1, a2, ...), axis=0, out=None)
参数:
让我们看看这个函数的参数:
-
(a1、a2、...)
此参数表示类似数组的结构或数组的顺序。这里a1、a2，...是具有相同形状的数组，它们将被连接在一起。 -
轴
此参数用于定义数组将沿其连接的轴。该参数的默认值为 0 。 -
out
这是一个可选的参数，如果提供的话，它只是指示结果将被放置的目的地。如果没有指定out参数，那么形状必须是正确的，并且应该与连接返回的形状相匹配。
返回值:
concatenate()函数将返回连接的数组作为结果。
示例 1:轴=0
让我们看一下这个函数的基本示例，其代码片段如下:
import numpy as np
array1 = np.array([[5, 4], [6, 8]])
print("First Array is:\n",array1)
array2 = np.array([[13, 5], [72, 9]])
print("Second Array is :\n",array2)
out= np.concatenate((array1, array2), axis = 0)
print("The result of concatenation is :")
print (out)
示例 2:轴=1
下面我们有另一个例子，我们将取轴=1 :
import numpy as np
array1 = np.array([[5, 4], [6, 8]])
print("First Array is:\n",array1)
array2 = np.array([[13, 5], [72, 9]])
print("Second Array is :\n",array2)
out= np.concatenate((array1, array2), axis = 1)
print("The result of concatenation is :")
print (out)
摘要
本教程是关于 Numpy 库中的concatenate()函数的。我们已经介绍了如何使用它的语法、参数和这个函数返回的值。
NumPy array()函数
在本教程中，我们将介绍 NumPy 库中array()函数的概念。
NumPy 库中的array()函数主要用于创建数组。就像 Numpy arange()功能一样。
-
在 NumPy 库中，同构多维数组是主要对象。齐次多维数组基本上是一个元素表，这些元素都是同一类型的，由正整数元组索引。数组的维度在 NumPy 中称为轴。
-
Numpy 库中的
array类主要被称为 ndarray 或别名数组。 -
numpy.array()与标准 python 库类array.array不同，因为在 Python 中array.array仅用于处理一维数组，因此它提供的功能较少。
numpy.array()的语法:
使用此方法所需的语法如下:
numpy.array(object, dtype=None, copy=True, order='K', subok=False, ndmin=0)
参数:
现在让我们看看这个函数的参数:
-
对象
该参数表示一个数组，也可以是任何暴露数组接口的对象，主要可以是__array__方法返回数组的对象，也可以是任何嵌套序列。 -
数据类型
该参数定义了数组所需的数据类型。如果没有给出这个参数，那么类型将被确定为在序列中保持对象所需的最小类型。 -
复制
如果该参数的值设置为真，则对象将被复制，否则只有当对象是嵌套序列时，或者如果只需要一个副本来满足任何其他要求，如数据类型、顺序等，才会进行复制。 -
顺序
这个参数用来指定数组的内存布局。如果对象不是一个数组，那么新创建的数组将按照 C 顺序排列，即行顺序，除非指定了‘F’，在这种情况下，它将按照 Fortran 顺序排列，即列顺序。如果对象主要是一个数组，则以下内容成立:
| 订单 | 无复制 | 副本=真 |
| k ' | 未改变的 | 如果在这种情况下副本为真，则 F & C 顺序保留了最相似的顺序 |
| a′ | 未改变的 | 在这种情况下，如果复制为真，输入为 F 而不是 C，则顺序为 F，否则顺序为 C |
| c′ | 订单 | 在这种情况下，顺序是 C |
| f ' | 订单 | 在这种情况下，顺序是 f。 |
-
subok
这是一个可选的参数，当这个参数的值为 True 时，子类将通过，否则默认情况下返回的数组将强制为基类数组。 -
ndmin
这是一个可选的参数，用于指定结果数组应该具有的最小维数。
返回值:
numpy 库中的array()函数用于返回满足指定要求的数组对象。
示例 1:array()功能的基本示例
下面我们有一个基本的例子，我们借助array()函数创建一个只有一维的数组:
import numpy as np
a = np.array([1,4,9])
print("The Array is:")
print(a)
数组为:
【1 4 9】
示例 2:多维数组
现在我们将创建一个具有多个维度的数组，其代码如下:
import numpy as np
a = np.array([[1, 7], [6, 4]])
print("The Array with more than one dimension:")
print(a)
多维数组:
[[1 7]
[6 4]]
示例 3:使用dtype参数
下面我们有一个例子，我们将使用dtype参数:
import numpy as np
a = np.array([1, 7,9], dtype='complex')
print("The Array with more than one dimension:")
print(a)
一维以上的数组:
【1。+0.j 7。+0.j 9。+0.j]
注: 上述代码片段的输出以复数形式表示数组元素的值。
摘要
本教程是关于 Numpy 库中的array()函数的。我们已经介绍了如何使用它的语法、参数和这个函数返回的值。在接下来的教程页面中，我们将介绍更多这样的功能。
NumPy transpose()函数
原文：https://www.studytonight.com/numpy/numpy-transpose-function
在本教程中，我们将介绍 Numpy 库中的numpy.transpose()函数。
numpy 库中的transpose()函数主要用于反转或置换数组的轴，然后返回修改后的数组。
-
这个函数的主要任务是将列元素变成行元素，将列元素变成行元素。
-
该函数对一维数组没有影响，因此它用于二维数组。
numpy.transpose()的语法:
使用该函数所需的语法如下:
numpy.transpose(a, axes=None)
参数:
让我们看看这个函数的参数:
-
a
该参数表示输入数组 -
斧
它基本上是一个可选的参数，但是如果你要通过这个参数，那么记住你应该通过 (0，1) 或者 (1，0) 。就像我们有一个形状数组(4，3)来改变它(3，4)，你应该传递(1，0)，其中 1 是 4，0 是 3。
返回值:
transpose()函数将返回输入数组及其置换轴。
例 1:
让我们看一下这个函数的基本示例，其代码片段如下:
import numpy as np
a = np.array([[6, 2, 4], [8, 5, 6], [7, 1, 9]])
print("Before Transpose array is :\n",a)
x=np.transpose(a)
print("After Transpose the array is:\n",x)
例 2:
现在我们将使用transpose()功能以及轴参数:
import numpy as np
a = np.array([[6, 28], [8, 56], [7, 19]])
print("Before Transpose :\n",a)
x=np.transpose(a,(1,0))
print("After Transpose :\n",x)
总结:
本教程是关于 Numpy 库中的transpose()函数的。我们已经介绍了如何使用它的语法、参数和这个函数返回的值。
NumPy partition()函数
原文：https://www.studytonight.com/numpy/numpy-partition-function
在本教程中，我们将介绍 Numpy 库的numpy.partition()功能。
partition()函数是，用于根据给定的参数相应地分割输入数组。
-
此函数返回输入数组的分区副本。
-
在数组的分区副本中，元素以这样一种方式重新排列，即第 kth 位置的元素取数组排序后的位置。
-
所有小于第 kth 个元素的元素都在这个元素之前移动，所有等于或大于它的元素都在它后面移动。
-
如果存在值等于第 kth 个元素的数据元素，则两个分区中元素的顺序保持不变。
numpy.partition()的语法:
使用此方法所需的语法如下:
numpy.partition(arr, kth, axis, kind, order)
参数:
现在让我们看看这个函数的参数:
-
arr
该参数表示要排序的输入数组。 -
kth
它是一个整数或整数序列。该参数指示需要围绕其执行分区的元素的索引。 -
轴
该参数表示元素排序的轴。该参数的默认值为 -1 (表示沿最后一个轴排序)。 -
种类
此参数用于定义您要执行的排序种类。该参数的默认值为“intro select”。 -
顺序
对于定义了字段的数组arr，该参数用于指定首先比较哪些字段，其次比较哪些字段，等等。
返回值:
该函数将返回与输入数组相同类型和形状的数组。
例 1:
代码片段如下，我们将在其中使用partition()函数:
import numpy as np
inp_ar = np.array([2, 0, 1, 5, 4, 9, 78, 34])
print ("The Input array : ")
print(inp_ar)
output = np.partition(inp_ar, 5)
print ("The Output partitioned array : ")
print(output)
输入数组:
【2 0 1 5 4 9 78 34】
输出分区数组:
【4 2 1 0 5 9 34 78】
从上述代码片段的输出中可以得出结论，所有小于第 5 个位置的元素(即 9 )的元素都放置在 9 的左侧，所有大于 9 的元素都放置在分隔符元素(第 5 个元素)的右侧。
另外，注意输出数组中出现的元素的顺序是未定义的。
例 2:
import numpy as np
arr = np.array([7, 4, 8, 1, 10, 13])
print("The Input array is :")
print(arr)
output = np.partition(arr, (1, 3))
print("The Output Partitioned array is :")
print(output)
输入数组为:
【7 4 8 1 10 13】
输出分区数组为:
【1 4 7 8 10 13】
摘要
在本教程中，我们学习了 Numpy 库的numpy.partition()功能。我们介绍了如何使用它的语法和这个函数返回的值，以及一些代码示例，以帮助您理解这个概念。
NumPy 数学函数
NumPy ceil()函数
在本教程中，我们将介绍 Numpy 库的numpy.ceil()数学函数。
numpy.ceil()功能用于返回数组元素的元素。任何标量值x** 的上限值都是最小的**整数i，使得i >= x。例如，5.6 的上限值将是 6。简单点说，最接近的大整数值就是天花板值。****
numpy.ceil()的语法:
下面是使用该函数所需的语法:
numpy.ceil(array)
注: 在上面的语法中，参数array用来表示要计算 ceil 值的数组元素。
返回值:
此方法将返回一个包含 ceil 值的数组。
现在是时候介绍一些与这个方法相关的例子了。
示例 1:具有正值的数组
在下面给出的例子中，我们将用数组的正值覆盖该方法，并查看输出:
import numpy as np
a = [1.90,2.3,0.6788]
y = np.ceil(a)
print("the output after applying ceil() is:")
print(y)
应用 ceil()后的输出为:
【2。3.1.]
示例 2:具有负值的数组
在这个例子中，我们将检查一个数组是否包含负值的输出。当我们找到负数的上限值时，比如说 -1.9 的较大整数将不是-2 ，而是它将是-1 。因为-1 是大于-1.9 的值，而-2 小于-1.9 的值。
的代码片段如下:
import numpy as np
a = [-1.90,-2.3,-0.6788,12.34]
y = np.ceil(a)
print("the output after applying ceil() is:")
print(y)
应用 ceil()后的输出为:
【-1。-2.-0.13.]
摘要
本教程是关于 Numpy 库中的numpy.ceil()数学函数的。我们讨论了它的语法、参数以及这个函数返回的值，并提供了一些有用的例子来帮助您理解如何使用这个函数。
NumPy floor()函数
在本教程中，我们将介绍numpy.floor()函数，它是 Numpy 库中的一个数学函数。
numpy.floor()用于返回数组元素的基底值。任何给定标量值 x 的底值都是最大整数值，例如i <= x。例如，2.3 的最低值将是 2。
numpy.floor()的语法:
下面我们有一个使用这个函数的基本语法，如下所示:
numpy.floor(array)
名为数组的参数用于表示需要计算地板值的数组。
返回值:
此方法将返回一个仅包含楼层值的数组。
注: 在一些电子表格程序中数值会通过“楼层-朝-零”的方式计算即表示楼层(-2.8) == -2 。但是在 Numpy 的情况下，floor 的定义是相反的，floor(-2.8)=-3，所以我们总是选择最近的下整数值来查找 floor。
现在是时候介绍几个例子来理解这个例子了。
例 1:
下面是这个例子的代码片段。让我们来看看它:
import numpy as np
a = [0.23,-1.7,1.34,-2.334]
print("The array is :",a)
y = np.floor(a)
print("After applying the floor() method:",y)
数组为:【0.23，-1.7，1.34，-2.334】
应用 floor()方法后:【0。-2.1.-3.]
例 2:
下面是floor()功能的另一个例子:
import numpy as np
input_arr = [1.23,0.22,-0.111,-2.555,-3.86,5.0,6.9]
print("The Input array is:")
print(input_arr)
z = np.floor(input_arr)
print("The output array is:")
print(z)
输入数组为:
【1.23，0.22，-0.111，-2.555，-3.86，5.0，6.9】
输出数组为:
【1。0.-1.-3.-4.5.6.]
总结:
本教程是关于 Numpy 库中的numpy.floor()数学函数，该函数用于计算所有数组元素的地板值。
NumPy trunc()函数
在本教程中，我们将介绍 Numpy 库中的numpy.trunc()函数。
Python 的numpy.trunc()函数用于返回输入数组元素的截断值。
-
需要注意的是输入值 x 的截断值 t应该是最接近零的整数，而不是 x
-
借助这个函数，任何有符号数的小数部分都被丢弃。
numpy.trunc()的语法:
下面是使用该函数所需的语法:
numpy.trunc(array)
注意: 在上面的语法中，数组用来表示要返回其截断值的数组元素。
返回值:
此方法主要返回包含截断值的数组。
现在是时候看看例子了。
例 1:
让我们从一个基本的例子开始。
import numpy as np
x = [1.2,-0.344,5.89]
y = np.trunc(x)
print(y)
【1。-0.5.]
例 2:
下面是代码片段，让我们来看看:
import numpy as np
inp = [123.22,23.4,0.89]
print("The Input array is :")
print(inp)
x = np.trunc(inp)
print("The Output array is :")
print(x)
输入数组为:
【123.22，23.4，0.89】
输出数组为:
【123。23.0.]
总结:
本教程是关于 Numpy 库中的numpy.trunc()数学函数的。我们还介绍了它的语法、参数以及这个函数返回的值。
NumPy fix()函数
在本教程中，我们将介绍 Numpy 库的numpy.fix()功能。
numpy.fix()函数用于将数组值舍入到最接近零的整数。
- 该函数返回的舍入值为浮动中的。
numpy.fix()的语法:
使用该函数所需的语法如下:
numpy.fix(array, b = None)
参数:
该功能的参数描述如下:
-
数组:该参数用于表示要取整元素的数组。
-
b :该参数用于提供一个表示结果存储位置的数组(可选)。
返回值:
这个函数总是返回一个包含舍入值的数组。
现在是时候介绍一个例子了。
numpy.fix()基本示例:
下面我们有代码片段来理解这个方法是如何工作的:
import numpy as np
a = [0.289, 0.089, 1.2, 1.566, 9.909]
print("The Input array is :")
print(a)
y = np.fix(a)
print("The Output array is :")
print(y)
输入数组为:
【0.289，0.089，1.2，1.566，9.909】
输出数组为:
【0。0.1.1.9.]
摘要
在本教程中，我们介绍了 Numpy 库的numpy.fix()数学函数，它可以用来舍入数组中的值。如果我们只想舍入一些值，那么我们可以使用其他 Numpy 函数创建一个新数组，然后使用fix()函数。
NumPy 字符串函数
NumPy islower()函数
原文：https://www.studytonight.com/numpy/numpy-islower-function
在本教程中，我们将介绍 Python 中 Numpy 库的 char 模块中的islower()函数。
如果输入字符串中的所有大小写字符都是小写的，并且至少有一个大小写字符，则 Numpy 库的islower()函数为每个元素返回 true。否则，此函数将返回 false。
-
该函数以元素方式调用
str.islower。 -
对于 8 位字符串，该函数是区域相关的。
islower()的语法:
使用该函数所需的语法如下:
numpy.char.islower(a)
上述语法表明islower()是充电模块的函数，它采用单个参数。
在上面的语法中，参数a表示将应用该函数的字符串的输入数组。
返回值:
这个函数将返回一个布尔值的输出数组。
示例 1:使用字符串
在第一个例子中，我们将对单个字符串值应用islower()函数:
import numpy as np
string1 = "this is an apple"
x = np.char.islower(string1)
print("After applying islower() function:")
print(x)
应用 islower()函数后:
真
示例 2:使用字符串数组
代码片段如下，我们将在其中使用islower()函数:
import numpy as np
inp_ar = np.array(['studytonight', 'Online', 'portal'])
print ("The input array : \n", inp_ar)
output = np.char.islower(inp_ar)
print ("The output array :\n", output)
输入数组:
【“StudyTonight”“在线”“入口”】
输出数组:
【真假真】
摘要
本教程是关于 Numpy 库的islower()函数的，该函数用于查找字符串是否为小写。
NumPy find()函数
在本教程中，我们将介绍 Python 中 Numpy 库的 char 模块中的find()函数。
find()函数在给定的字符串数组中找到子字符串，在提供的范围【开始，结束】之间，返回子字符串开始的第一个索引。
该函数以元素方式在内部调用str.find函数。
find()的语法:
使用此方法所需的语法如下:
numpy.char.find(a, sub, start, end=None)
上述语法表示find()是充电模块的函数，取上述参数。
参数:
现在让我们看看这个函数的参数:
-
a
可以是输入数组，也可以是输入字符串。 -
子
这是一个必需的参数，指示要从输入字符串中搜索的子字符串。 -
开始、结束
这些参数是可选的，start和end都用来设置子串搜索的边界。
返回值:
find()函数将返回整数的输出数组。如果没有找到sub，则该功能将返回 -1 。
示例 1:找到子字符串
代码片段如下，我们将在其中使用find()函数:
import numpy as np
arr = ['AAAabbbbbxcccccyyysss', 'AAAAAAAaattttdsxxxxcccc', 'AAaaxxxxcccutt', 'AAaaxxccxcxXDSDdscz']
print ("The array is :\n ", arr)
print ("\nThe find of 'xc'", np.char.find(arr, 'xc'))
print ("The find of 'xc'", np.char.find(arr, 'xc', start = 3))
print ("The find of 'xc'", np.char.find(arr, 'xc', start = 8))
示例 2:找不到某些子字符串
import numpy as np
arr = ['AAAabbbbbxcccccyyysss', 'AAAAAAAaattttds', 'AAaaxcutt', 'AAaaxXDSDdscz']
print ("The array is :\n ", arr)
print ("\nThe find of 'xc'", np.char.find(arr, 'xc'))
print ("The find of 'xc'", np.char.find(arr, 'xc', start = 8))
数组为:
[' aaaaababbxcccycyysss '，' AAAAAAAaattttds '，' aaaaaaaxcut '，' aaaaaaaxxdsdscz ']
找到' xc' [ 9 -1 4 -1]
找到' xc' [ 9 -1 -1 -1]
摘要
在本教程中，我们学习了 Numpy 库的find()函数以及一些代码示例。如果你想尝试一些代码示例，你可以在我们的 Python 代码编译器中这样做。
NumPy count()函数
在本教程中，我们将介绍 Numpy 库的 char 模块中可用的count()功能。
count()函数用于返回数组，该数组包含给定子串在【开始，结束】范围内的非重叠出现(唯一)的计数值。
对于给定 ndrray 的每个元素，该函数在内部调用str.count。
count()的语法:
使用此方法所需的语法如下:
numpy.char.count(a, sub, start, end=None)
我们来介绍一下count()功能的参数:
参数:
现在让我们看看这个函数的参数:
-
a
可以是输入数组，也可以是输入字符串。 -
sub
这是一个必需的参数，指示要从输入字符串或输入数组中搜索的子字符串。 -
开始、结束
这些参数是可选的，start和end都用来设置子串搜索的边界。
返回值:
count()函数将返回一个整数数组，其中包含子串的非重叠出现次数。
count()功能基本示例:
代码片段如下，我们将在其中使用count()函数:
import numpy as np
str1 = np.array(['ooooaaaaqqqk','ccccvvvvvaaaao','ggghhhjjjsskkka'])
print("The original string is:\n",str1)
print("\nThe count of 'a' in str1")
y = np.char.count(str1,'a')
print(y)
print("\nThe count of 'k' in st1:")
z = np.char.count(str1,'k')
print(z)
print("\nThe count of 'o' in st1:")
x = np.char.count(str1,'o')
print(x)
摘要
本教程通过代码示例介绍了 Numpy 库的count()功能。
NumPy istitle()函数
原文：https://www.studytonight.com/numpy/numpy-istitle-function
在本教程中，我们将介绍 Numpy 库中 char 模块的istitle()功能。
如果输入数组中的元素是“T3”标题大小写字符串“T4”，并且至少有一个大小写字符，则istitle()函数为给定数组的每个数据元素返回“T1”true“T2”。否则，该功能将返回假。
比如苹果是标题大小写，但是苹果不是，苹果也不是标题大小写。
该函数以元素方式调用str.istitle。
对于 8 位字符串，该函数依赖于区域设置。
istitle()的语法:
使用该函数所需的语法如下:
numpy.char.istitle(a)
上述语法表明istitle()是充电模块的函数，它采用单个参数。
在上面的语法中，参数a表示将应用该函数的字符串输入数组。
返回值:
这个函数将返回一个布尔值的输出数组。
例 1:
import numpy as np
inp1 = np.array(['APPLE', 'Mango', 'guava'])
print ("The input array: ", inp1)
out1 = np.char.istitle(inp1)
print ("The output array:", out1 )
输入数组:【‘APPLE’‘Mango’‘guava’】
输出数组:【假真假】
例 2:
代码片段如下，我们将在其中使用istitle()函数:
import numpy as np
inp2 = "This Is An Input String"
print ("The input array : \n", inp2)
out2 = np.char.istitle(inp2)
print ("The output array :\n", out2 )
输入数组:
这是输入字符串
输出数组:
真
摘要
本教程是关于 Numpy 库的istitle()功能的。我们介绍了如何使用它的语法和这个函数返回的值。
NumPy decode()函数
在本教程中，我们将介绍 Numpy 库的 char 模块的decode()功能。
NumPy 中的decode()功能用于根据指定的编解码器对输入字符串进行解码。可用编解码器集取自 Python 标准库。
该函数以元素方式调用str.decode。
decode()的语法:
使用该函数所需的语法如下:
numpy.char.decode(a, encoding=None, errors=None)
以上语法表明decode()是 char 模块的函数，取 NumPy 库中的两个参数。
参数:
让我们讨论一下这个函数的参数:
-
a
该参数表示一个字符串数组 -
编码
这是一个可选的参数，表示编码的名称。 -
错误
此参数用于指定如何处理错误。
返回值:
decode()函数将总是返回一个解码的字符串。
decode()基本示例:
代码片段如下，我们将在其中使用decode()函数:
import numpy as np
x = np.array(['aAaAaArt', ' aABbV ', 'abBABba'])
print("Input is :", x)
e = np.char.encode(x, encoding='cp500')
print("\nAfter encoding: ", e)
d = np.char.decode(e, encoding='cp500')
print("\nAfter decoding: ", d)
输入为:[' aaaaaaart ' ' aABbV ' ' abbba ']
编码后:【b ' \ x81 \ xc1 \ x81 \ xc1 \ xc1 \ x99 \ xa3 ' b ' @ \ x81 \ xc1 \ xc2 \ x82 \ xe5 @ '
b ' \ x81 \ x82 \ xc2 \ xc1 \ xc2 \ x82 \ x81 ']
解码后:[' aaaaaaaaaaart ' ' aABbV ' ' abbbb
摘要
在本教程中，我们学习了 Numpy 库的decode()功能。我们已经介绍了如何使用它的语法和这个函数返回的值。
NumPy encode()函数
在本教程中，我们将介绍 Numpy 库的 char 模块的encode()功能。
encode()功能用于对输入字符串进行编码。可用编解码器集取自 Python 标准库。
该函数以元素方式调用str.encode。
使用的默认编码方案是 utf_8 。
encode()的语法:
使用该函数所需的语法如下:
numpy.char.encode(a, encoding=None, errors=None)
以上语法表明encode()是充电模块的函数，取三个参数。
参数:
让我们讨论一下这个函数的参数:
-
a
该参数表示字符串数组 -
编码
这是一个可选的参数，表示要使用的编码名称。 -
错误
此参数用于指定如何处理编码错误。
返回值:
encode()函数将始终返回一个编码字符串。
例 1:
代码片段如下，我们将使用带有一些不同编码的encode()函数，比如 cp037 :
import numpy as np
a = ['aAaAaA', ' aA ', 'abBABba','dffgs','ttsred']
print("Input is:")
print(a)
x = np.char.encode(a, encoding='cp037', errors=None)
print("Encoded String is:")
print(x)
输入为:
[' aaaaaaa '，' aA '，' abBABba '，' dffgs '，' ttsred']
编码字符串为:
[b ' \ x81 \ xc1 \ x81 \ xc1 \ xc1 ' b ' @ \ x81 \ xc1 @ '
b ' \ x81 \ x82 \ xc2 \ xc1 \ xc2 \ x82 \ x81 ' b ' \ x84 \ x86 \ x87 \ xa2 '
b ' \ xa3
例 2:
在下面给出的例子中，我们将使用编码方案 utf-8 并检查输出:
import numpy as np
a = ['aAaAaA', ' aA ', 'abBABba','dffgs','ttsred']
print("Input is:")
print(a)
x = np.char.encode(a, encoding='utf-8', errors=None)
print("Encoded String is:")
print(x)
输入是:【aAaAaA】、【aA】、【ABba】、【dffgs】、【TTS】、【TTS】【tt2】编码字符串是:
【b ' aaaaaa’b’ABBA’b’dffgs‘b’TTS’]
摘要
在本教程中，我们学习了 Numpy 库的encode()功能。我们介绍了如何使用它的语法和这个函数返回的值。
NumPy replace()功能
原文：https://www.studytonight.com/numpy/numpy-replace-function
在本教程中，我们将介绍 Numpy 库中 char 模块的numpy.char.replace()功能。
replace()函数用于返回字符串数组或字符串的副本，所有出现的旧子字符串都被新子字符串替换。如果您想在数组元素中做一些更改，用一些新的字符串值替换子字符串，这个函数非常有用。
我们也可以指定计数，来指定旧子串必须替换多少次。例如，如果我们有一个字符串home weethome，并且我们只想用其他东西替换第一个 home 子字符串，那么我们可以将计数指定为 1 。如果我们将计数指定为 2 ，那么两个 home 子串都将被新的子串替换。
注意: 如果我们没有指定 count 参数，那么同样，默认情况下 ol 子串的所有出现都将被新的替换。
该函数为每个数组元素调用str.replace。
replace()的语法:
使用该函数所需的语法如下:
numpy.char.replace(a, old, new, count=None)
让我们讨论一下这个函数的参数。
参数:
让我们讨论这个函数的上述参数:
-
a
该参数用于表示字符串数组。 -
old
该参数表示要替换的旧子串。 -
新建
该参数表示用于替换旧子串的新子串。 -
计数
这是一个可选的论点。我们已经在本页的介绍中对此进行了解释。
返回值:
这个函数将返回字符串的输出数组。
例 1:
代码片段如下，我们将在其中使用replace()函数:
import numpy as np
string1="It is a yellow chair"
print("The original string is:\n",string1)
x = np.char.replace(string1, 'It', 'This')
print("After applying replace() function:")
print(x)
原弦为:
是黄椅子
应用 replace()功能后:
这是黄椅子
示例 2:使用count参数
在本例中，我们还将把count参数传递给replace()函数:
import numpy as np
string1="This is a chair.The color of the chair is yellow"
print("The original string is:\n",string1)
x = np.char.replace(string1, 'chair', 'book', count=1)
print("After applying replace() function:")
print(x)
与上面的代码一样，字符串包含子字符串“椅子”两次，但是在使用replace()函数时，我们已经通过了计数=1 ，因此应该只替换第一次出现的子字符串椅子。
原弦为:
这是椅子。椅子颜色为黄色
应用 replace()功能后:
这是一本书。这把椅子的颜色是黄色的
由于计数=1 ，该功能仅替换椅子的第一个外观，而不是第二个外观。
replace()功能的使用:
让我们举一个例子来介绍一个基本用例，以帮助您理解我们可以在哪里使用这个函数。例如，如果一个数组中的数据包含字符串值形式的任何产品的价格，如 $10，000 、 \(5，000** ，等等。这里的价格值不是数字，而是带有 **\)符号和逗号(，的字符串，这将使我们很难对这些值进行任何数学运算。
因此，我们可以使用replace()函数从每个值中移除 $符号，将其替换为空(提供空子字符串作为new参数)。对于逗号(，)也是一样，然后我们会得到数字字符串，我们可以在执行任何数学运算时将其转换为整数。
摘要
在本教程中，我们学习了 Numpy 库的replace()函数，该函数对于处理字符串数组非常有用，以防您想要替换字符串的任何特定部分。
NumPy splitlines()函数
原文：https://www.studytonight.com/numpy/numpy-splitlines-function
在本教程中，我们将介绍 Numpy 库中 char 模块的splitlines()功能。
对于数组中的每个元素，splitlines()函数用于返回元素中的线条列表，在线条边界处断开。
该函数为给定数组中的每个元素调用str.splitlines。
splitlines()的语法:
使用该函数所需的语法如下:
numpy.char.splitlines(a, keepends=None)
以上语法表明splitlines()函数取两个参数。
参数:
让我们讨论这个函数的上述参数，如下所示:
-
a
该参数代表字符串的输入数组。 -
保留结束
这是一个可选的参数，具有布尔值。如果我们想要包括换行符，那么我们可以使用这个参数，通过将其值设置为真。
返回值:
这个函数将返回列表对象的数组。
例 1:无keepends参数
代码片段如下，我们将在其中使用splitlines()函数:
import numpy as np
string1 = "Studytonight \n is a best place \n to learn coding online"
out = np.char.splitlines(string1)
print("After applying splitlines() function:")
print(out)
应用 splitlines()函数后:
[“StudyTonight”，“是个最好的地方”，“在线学习编码”]
例 2:带keepends参数
import numpy as np
x = np.char.splitlines('The quick brown \rfox jumps over \rthe lazy dog.', keepends=False)
print(x)
[“敏捷的棕色”、“狐狸跳过”、“懒狗。”]
摘要
在本教程中，我们学习了 Numpy 库的splitlines()函数，该函数用于根据换行符将数组中的字符串拆分为子字符串。
NumPy add()函数
在本教程中，我们将介绍 Numpy 库的add()功能。
add()函数基本上为两个数组返回元素式字符串连接。
注意: 如果要串联两个数组，那么两个数组需要是相同的形状。
add()的语法:
使用该函数所需的语法如下:m1
numpy.char.add(x1, x2)
以上语法表明add()函数取两个参数。
参数:
现在让我们看看这个函数的参数:
-
x1
该参数表示要连接的第一个数组(从开始连接) -
x2
该参数表示要连接的第二个数组(在末尾连接)
返回值:
该方法将返回一个输出数组string_或unicode_，其取决于与 x1 和 x2 相同形状的输入类型。
例 1:
代码片段如下，我们将在其中使用add()函数:
import numpy as np
x1 = ['Hello']
x2 = ['StudyTonight!']
print("The Input arrays are : ")
print(x1)
print(x2)
result = np.char.add(x1, x2)
print("\nThe Resultant concatenated array is :")
print(result)
输入数组为:
【【你好】
【【StudyTonight！】】
合成串联数组为:
【‘hellostudytomnight！’]
例 2:
现在，我们将在包含多个元素的两个数组上应用此函数，并将看到输出:
import numpy as np
x1 = ['Welcome', 'to', 'StudyTonight']
x2 = ['Best Place', 'Forlearning', 'Coding']
print("The Input arrays are : ")
print(x1)
print(x2)
result = np.char.add(x1, x2)
print("\nThe Resultant concatenated array is :")
print(result)
输入数组为:
[“欢迎”、“到”、“StudyTonight”]
[“最佳地点”、“学习”、“编码”]
结果串联数组为:
[“欢迎来到最佳地点”到“学习”
摘要
在本教程中，我们介绍了 Numpy 库的add()函数，该函数可用于连接两个给定数组中的字符串，如果您有两个或多个要合并的数组，这是一个很好的用例。
NumPy multiply()函数
原文：https://www.studytonight.com/numpy/numpy-multiply-function
在本教程中，我们将介绍 Numpy 库中 char 模块的mutiply()功能。
multiply()函数用于重复一个数组的字符串元素， n 次，其中 n 可以是任意整数值。例如，如果我们有一个带有一个字符串元素“ study ”的数组，使用multiply()函数，如果我们选择乘法因子为 2 ，我们可以将该字符串更改为“ studystudy ”，如果我们选择因子为 3 ，则更改为“study study，以此类推。
这个函数就像 Numpy 库中的其他字符串函数一样，以元素方式执行，覆盖所有数组元素。
multiply()的语法:
使用此方法所需的语法如下:
numpy.char.multiply(a, i)
上面的语法表明乘法()函数接受两个参数。
参数:
现在让我们看看这个函数的参数:
-
a
该参数表示将应用该方法的字符串数组。 -
i
该参数表示需要重复的次数。
返回值:
这个函数将返回字符串数组作为输出。
示例 1:具有单个元素的数组
代码片段如下，我们将在其中使用multiply()函数:
import numpy as np
arr = np.array(['Study'])
print("The Original Array is :")
print(arr)
i = 5
output = np.char.multiply(arr, i)
print("\nThe New array is:")
print(output)
原阵为:
【【学习】】
新阵为:
【【学习学习学习学习】
示例 2:具有多个元素的数组
现在让我们举一个例子，其中我们将在一个数组中有多个元素，我们将在相同的数组上应用方法，代码片段如下:
import numpy as np
arr= np.array(['StudyTonight', 'Online', 'Portal'])
print("The Original Array :")
print(arr)
i = 2
output = np.char.multiply(arr, i)
print("\nThe Resultant array :")
print(output)
原始数组:
[“StudyTonight”“在线”“门户”]
结果数组:
[“StudyTonight”“在线”“门户”]
摘要
在本教程中，我们学习了 Numpy 库的multiply()函数，该函数使用字符串数组来重复数组中所有数据元素的字符串值。
