AskPython-博客中文翻译-九-
AskPython 博客中文翻译（九）
Python 有序直接
原文：https://www.askpython.com/python-modules/python-ordereddict
OrderedDict 是 dictionary 的一个子类，它维护向其中添加元素/项目的顺序。
OrderedDict 保留元素的插入顺序。默认的字典不保存顺序，并以任意顺序进行迭代。
最初，我们需要导入集合模块来使用 OrderedDict 库模块。我们还可以从 collections 模块中只导入 OrderedDict 类。
import collections
from collections import OrderedDict
Python 有序直接功能
- 创建有序的直接对象
- 向 OrderedDict 添加项目
- 替换订单中的项目
- 从订单中删除项目
- 键值改变
- 函数的作用是
- 订购的直接弹出项目
- 反向迭代
- 有序直接相等测试
1.创建有序的直接对象
**OrderedDict()**函数用于创建对象。
from collections import OrderedDict
my_input = {'Pune': 'Maharashtra', 'Ahemadnagar': 'Gujarat', 'Orrisa': 'Bhubhaneshwar'}
# creating ordered dict from dict
ordered_input = OrderedDict(my_input)
print(ordered_input)
输出:
OrderedDict([('Pune', 'Maharashtra'), ('Ahemadnagar', 'Gujarat'), ('Orrisa', 'Bhubhaneshwar')])
2.向 OrderedDict 添加项目
from collections import OrderedDict
my_input = {'Pune': 'Maharashtra', 'Ahemadnagar': 'Gujarat', 'Orrisa': 'Bhubhaneshwar'}
# creating ordered dict from dict
ordered_input = OrderedDict(my_input)
#print(ordered_input)
print("Adding item to OrderedDict....")
ordered_input['Hyderabad'] = 'Karnataka'
print(ordered_input)
输出:
Adding item to OrderedDict....
OrderedDict([('Pune', 'Maharashtra'), ('Ahemadnagar', 'Gujarat'), ('Orrisa', 'Bhubhaneshwar'), ('Hyderabad', 'Karnataka')])
3.替换订单中的项目
from collections import OrderedDict
my_input = {'Pune': 'Maharashtra', 'Ahemadnagar': 'Gujarat', 'Orrisa': 'Bhubhaneshwar'}
# creating ordered dict from dict
ordered_input = OrderedDict(my_input)
#print(ordered_input)
print("Replacing item from OrderedDict....")
ordered_input['Pune'] = 'Satara'
print(ordered_input)
输出:
Adding items to OrderedDict....
OrderedDict([('Pune', 'Satara'), ('Ahemadnagar', 'Gujarat'), ('Orrisa', 'Bhubhaneshwar')])
4.从订单中删除项目
from collections import OrderedDict
my_input = {'Pune': 'Maharashtra', 'Ahemadnagar': 'Gujarat', 'Orrisa': 'Bhubhaneshwar'}
# creating ordered dict from dict
ordered_input = OrderedDict(my_input)
#print(ordered_input)
print('Removal of item from OrderedDict....')
ordered_input.pop('Pune')
print(ordered_input)
输出:
Removal of item from OrderedDict....
OrderedDict([('Ahemadnagar', 'Gujarat'), ('Orrisa', 'Bhubhaneshwar')])
5.OrderedDict 中的键值更改
在 OrderedDict 中，如果对应于特定键的值被更改，则该键的位置/索引保持不变。
from collections import OrderedDict
my_input = {'Pune': 'Maharashtra', 'Ahemadnagar': 'Gujarat', 'Orrisa': 'Bhubhaneshwar'}
# creating ordered dict from dict
print('Before the change.....')
ordered_input = OrderedDict(my_input)
print(ordered_input)
print('After the change.....')
ordered_input['Pune'] = 'Kiara'
print(ordered_input)
输出:
Before the change.....
OrderedDict([('Pune', 'Maharashtra'), ('Ahemadnagar', 'Gujarat'), ('Orrisa', 'Bhubhaneshwar')])
After the change.....
OrderedDict([('Pune', 'Kiara'), ('Ahemadnagar', 'Gujarat'), ('Orrisa', 'Bhubhaneshwar')])
6.函数的作用是
函数将一个特定的键值对移动到字典的末尾。
from collections import OrderedDict
my_input = {'Pune': 'Maharashtra', 'Ahemadnagar': 'Gujarat', 'Orrisa': 'Bhubhaneshwar'}
# creating ordered dict from dict
print('Before using the move_to_end().....')
ordered_input = OrderedDict(my_input)
print(ordered_input)
print('After using the move_to_end().....')
ordered_input.move_to_end('Pune')
print(ordered_input)
输出:
Before using the move_to_end().....
OrderedDict([('Pune', 'Maharashtra'), ('Ahemadnagar', 'Gujarat'), ('Orrisa', 'Bhubhaneshwar')])
After using the move_to_end().....
OrderedDict([('Ahemadnagar', 'Gujarat'), ('Orrisa', 'Bhubhaneshwar'), ('Pune', 'Maharashtra')])
7.OrderedDict popitem
这个函数弹出并返回最后一个元素作为输出。
from collections import OrderedDict
my_input = {'Pune': 'Maharashtra', 'Ahemadnagar': 'Gujarat', 'Orrisa': 'Bhubhaneshwar'}
# creating ordered dict from dict
print('Original input dict.....')
ordered_input = OrderedDict(my_input)
print(ordered_input)
result = ordered_input.popitem(True)
print('The popped item is: ')
print(result)
print(ordered_input)
输出:
Original input dict.....
OrderedDict([('Pune', 'Maharashtra'), ('Ahemadnagar', 'Gujarat'), ('Orrisa', 'Bhubhaneshwar')])
The popped item is:
('Orrisa', 'Bhubhaneshwar')
OrderedDict([('Pune', 'Maharashtra'), ('Ahemadnagar', 'Gujarat')])
8.反向迭代
from collections import OrderedDict
my_input = {'Pune': 'Maharashtra', 'Ahemadnagar': 'Gujarat', 'Orrisa': 'Bhubhaneshwar'}
# creating ordered dict from dict
print('Original input dict.....')
ordered_input = OrderedDict(my_input)
print(ordered_input)
print('Reversed OrderedDict.....')
for elements in reversed(ordered_input):
print(elements)
输出:
Original input dict.....
OrderedDict([('Pune', 'Maharashtra'), ('Ahemadnagar', 'Gujarat'), ('Orrisa', 'Bhubhaneshwar')])
Reversed OrderedDict.....
Orrisa
Ahemadnagar
Pune
9.有序直接相等测试
from collections import OrderedDict
# creating regular dict..
my_input1 = {1:'one' , 2:'two'}
my_input2 = {2:'two' , 1:'one'}
#creating ordereddict..
ordered_input1 = OrderedDict({1:'one' , 2:'two'})
ordered_input2 = OrderedDict({2:'two' , 1:'one'})
print(my_input1 == ordered_input1)
print(my_input1 == my_input2)
print(ordered_input1 == ordered_input2)
输出:
True
True
False
结论
因此，在本文中，我们已经理解了常规 Dictionary 和 OrderedDict 之间的区别，并了解了 OrderedDict 提供的功能。
参考
- Python 有序直接
- 订购的直接文件
Python 操作系统模块–10 个必须知道的函数
原文：https://www.askpython.com/python-modules/python-os-module-10-must-know-functions
模块基本上是预定义的函数，有助于减少代码的冗余，并为其添加内置功能。Python os 模块允许我们高效地交互和使用操作系统功能。
- os 模块允许我们访问操作系统信息。
- 因此，这个模块包含了作为与操作系统交互方式的函数。
- 操作系统模块让我们处理文件和目录。
1.1.导入 Python 操作系统模块
在使用任何 Python 模块之前，都需要将其导入。因此，我们需要在深入研究其功能之前导入 os 模块。
语法:
import os
Python-import os Module
1.2. os.name
这个函数帮助我们理解导入的 os 模块的名称。它因用户使用的操作系统而异。
语法:
os.name
Python-os.name
在上面的代码片段中，命令已经在 Windows 操作系统上运行。这就是为什么导入的 os 模块名称显示为nt的原因。输出因操作系统和不同系统的解释程序而异。如果在 Mac OS 上运行，会打印出posix。
1.3.os.getcwd()
该功能的输出因系统而异。它用于返回当前工作目录(CWD ),该目录用于执行和运行 python 中的代码。
语法:
os.getcwd()
Python-os.getcwd
1.4.os.execvp
这个函数可以认为是 Python 中执行系统其他命令的技术之一。
为了达到同样的目的，首先我们需要用下面的代码创建一个 python 片段 hello.py 。
Python-file2
然后，创建另一个 python 文件 file1.py ，在其中添加以下代码并运行脚本。
Python-file1
输出:
Python-os.execvp
1.5.操作系统错误
OSError是每个 IO 相关错误的基类。因此，我们可以使用这个异常类来捕获 except 块中的 IO 错误。
try:
f = open('abc.txt', 'r') # file is missing
except OSError:
print('Catching IO Errors in OSError block')
1.6.os.access(路径，模式)
这个函数利用 uid 来检查路径的可访问性。如果特定文件存在并且允许访问该文件，则该方法返回 True，否则返回 False。它占用了两个参数:路径和模式。路径是特定文件所在的目录。该模式可以有下列值之一:
os.F_OK–发现os.R_OK–可读os.W_OK–可写os.X_OK–可执行
在下面的代码片段中，函数os.chdir(path)将 CWD 更改为用户作为参数指定的路径。
Python-os.access
1.7 .操作系统. getpid
这个方法返回当前正在执行的进程的 ID，通常称为 PID。
语法:
os.getpid()
Python-os.getpid
1.8.os.listdir(路径)
该函数返回 CWD 中的文件和目录列表，该列表作为参数传递。
语法:
os.listdir(path)
Python-os.listdir
1.9.os.mkdir(路径名)
这个函数从 os 模块创建一个新的目录，接受路径名作为参数。
语法:
os.mkdir(path name)
Python-os.mkdir
输出:
在下面的截图中，可以清楚地看到，当上面的代码运行时，它在提到的目录/驱动器中创建了一个文件夹，其名称作为参数传递，即“demo”。
Output-os.mkdir
结论
在本文中，我们将了解 os 模块提供的许多功能及其实现。这个模块与 Python sys 模块非常相似。
参考
- Python 操作系统模块
- Python os 模块官方文档
Python 包-创建和访问
Python 包帮助我们管理模块和 python 脚本。它们是带有 init 脚本的普通目录 _ _ init _ _ .py。
如何创建 Python 包？
我们可以通过以下步骤创建一个包。
- 创建包目录——我们可以使用终端或 Python IDE 来完成。
- 创建 init。py 文件–这是将普通目录转换成 python 包所必需的。这个文件用于初始化包并列出所有的模块。最简单的形式是，这个文件可以是空的。
我们可以在 Python 包中保存什么？
- 初始化文件
- Python 模块
- Python 脚本
- 任何其他类型的文件
所以一般来说，一个包就像是我们计算机系统中的一个目录。唯一的区别是必须包含 init。py 文件。
我们可以用 Python 创建子包吗？
是的，我们可以在另一个包中创建一个包。我们也必须遵循打包规则来创建子包。
Python 包示例
让我们看一些创建和使用包的例子。
1.创建包
$ mkdir utilities
$ touch utilities/__init__.py
$ mkdir utilities/strings
$ mkdir utilities/strings/__init__.py
$ tree
.
└── utilities
├── __init__.py
└── strings
└── __init__.py
3 directories, 1 file
$
Python Packages Structure
2.向包中添加模块
假设我们有两个 python 模块——math . py和 str_utils.py 。他们有几个函数将在我们的程序中使用。
math.py:
def add(x, y):
return x + y
def multiply(x, y):
return x * y
str_utils.py:
def to_uppercase(s):
s = str(s)
return s.upper()
def reverse(s):
s = str(s)
return s[::-1]
我们希望将这些模块添加到我们的包中。只需将这些文件复制到您想要保存这些模块的包目录中。
$ ls
math.py str_utils.py utilities
$ mv math.py utilities
$ mv str_utils.py utilities/strings
$ tree
.
└── utilities
├── __init__.py
├── math.py
└── strings
├── __init__.py
└── str_utils.py
3 directories, 3 files
$
Adding Modules To Python Package
3.从包中导入模块
在包中导入 python 模块的语法是:
import package.sub_package1.sub_package2.module
import package.sub_package1.sub_package2.module as module
Python 使用sys.path变量来搜索包和模块。当前目录是sys.path变量的一部分。所以我们将把我们的 python 脚本保存在 python-packages 目录中。否则，我们将不得不在sys.path变量中添加包的位置。
$ cat my_script.py
import sys
print(sys.path)
$ python3.7 my_script.py
['/Users/pankaj/Desktop/python-packages', '/Library/Frameworks/Python.framework/Versions/3.7/lib/python37.zip', '/Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7', '/Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/lib-dynload', '/Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages']
$
下面是 my_script.py 代码，用于从包中访问模块并调用它们的函数。
import utilities.math as math
import utilities.strings.str_utils as str_utils
print(math.add(10, 20))
print(str_utils.reverse("ABC"))
Importing Package Module In Python
我们也可以使用以下语法导入模块:
from package.sub_package1.sub_package2 import module
下面是在我们的程序中访问“math”和“str_utils”模块的更新示例。
from utilities import math
from utilities.strings import str_utils
print(math.add(10, 20))
print(str_utils.reverse("ABC"))
Python – from Package Import Module
4.从包中导入*
我们可以使用下面的语法从包中导入每个模块。
from package.sub_package1.sub_package2 import *
在这种情况下，Python 会在 sub_package2 中搜索包、模块和函数。这可以通过输入你不想要的东西来产生副作用。此外，这是一个非常耗时的过程。
我们可以通过在 init 中创建 all 变量来定义要导入的模块列表。py 文件。
实用程序/init。py:
print('utilities package initialized')
__all__ = ['math']
实用程序/字符串/init。py:
print('utilities.strings package initialized')
__all__ = ['str_utils']
更新后的 my_script.py 代码为:
from utilities import *
from utilities.strings import *
print(math.add(10, 20))
print(str_utils.reverse("ABC"))
输出:
$ python3.7 my_script.py
utilities package initialized
utilities.strings package initialized
30
CBA
Python Package Init File All Modules List Example
注意 init 中的 python 代码。当包被初始化和导入时，py 首先被执行。
如何将软件包添加到系统路径中
总是依赖目录层次结构来导入包模块是不可行的。我们可以将自定义包添加到 sys.path 变量中，然后在任何脚本中导入它们。
import sys
sys.path.append("/Users/pankaj/Desktop/python-packages")
print(sys.path)
import utilities.math as math
print(math.add(1, 2))
输出:
$ python3.7 my_script.py
['/Users/pankaj', '/Library/Frameworks/Python.framework/Versions/3.7/lib/python37.zip', '/Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7', '/Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/lib-dynload', '/Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages', '/Users/pankaj/Desktop/python-packages']
utilities package initialized
3
$
结论
Python 中的包允许我们将应用程序模块和脚本分成逻辑模块。这保持了我们代码库的干净和易于维护。
参考资料:
Python 熊猫 between()方法——快速指南！
原文：https://www.askpython.com/python-modules/pandas/python-pandas-between
读者朋友们，你们好！在我们的 Pandas 模块系列中，我们将详细讨论一个尚未解决但很重要的函数——PythonPandas between()函数。
所以，让我们开始吧！
使用熊猫 between()方法
Python Pandas 模块主要用于处理行和列中的数据值，即以一种表格/矩阵的形式。在其中，我们经常遇到保存数值类型值的数据变量。
在将数据处理成任何类型的动作(例如建模等)之前，数据的分析和转换是必要的。
简单地说，Python Pandas between()函数帮助我们在比较和最后时刻检查方面进行简单的分析。
between()函数检查传递给该函数的起始值和结束值之间的值。
也就是说，在一系列值中，它将检查哪些数据元素落在传递的起始值和结束值之间。
现在让我们试着理解同样的结构！
语法–Python Pandas between()方法
看看下面的语法！
Series.between(start, end, inclusive=True)
- start :开始检查的起始值。
- 结束:检查停止在该值。
- 包含:如果为真，则包含所传递的‘开始’和‘结束’值，并进行校验。如果设置为“假，则在执行检查时不包括“开始”和“结束”值。
补充一下，Python Pandas between()函数仅适用于数值和一维数据帧。
现在让我们通过一些例子来分析这个函数。
1.包含设置为“真”的 Python between()函数
在本例中，我们使用pandas.DataFrame() 函数创建了一个一维数据帧。
举例:
import pandas as pd
data = {"Roll-num": [10,20,30,40,50,60,70], "Age":[12,21,13,20,14,13,15], "NAME":['John','Camili','Rheana','Joseph','Amanti','Alexa','Siri']}
block = pd.DataFrame(data)
print("Original Data frame:\n")
print(block)
输出:
看看下面的数据图！
Original Data frame:
Roll-num Age NAME
0 10 12 John
1 20 21 Camili
2 30 13 Rheana
3 40 20 Joseph
4 50 14 Amanti
5 60 13 Alexa
6 70 15 Siri
现在，我们已经在数据框的“年龄”变量上应用了 between()方法。
通过将 inclusive 设置为 true，它现在将包含并检查所有介于 12 和 15(包括 12 和 15)之间的值，然后为年龄介于设置范围内的索引返回 True。
block["Age"].between(12, 15, inclusive = True)
输出:
因此，对于索引 1 和 3，它返回 False，因为这些值超出了范围 12 到 15。
0 True
1 False
2 True
3 False
4 True
5 True
6 True
Name: Age, dtype: bool
2.带分类变量的 Python between()函数
现在，让我们看看字符串或分类数据的结果。
如果我们将一个字符串或非数字变量传递给 Pandas between()函数，它会将起始值和结束值与传递的数据进行比较，如果数据值与起始值或结束值匹配，则返回 True。
举例:
block["NAME"].between("John", "Joseph", inclusive = True)
输出:
因此，只有两个值返回为真。
0 True
1 False
2 False
3 True
4 False
5 False
6 False
Name: NAME, dtype: bool
3.打印从 between()函数获得的值
在本例中，我们将尝试使用 Pandas between()函数打印介于 12 和 15 之间的数据。
举例:
btwn = block["Age"].between(12, 15, inclusive = False)
block[btwn]
输出:
由于我们已经将 inclusive 设置为 False，它将检查位于 12 和 15 之间的值，不包括 12 和 15 本身。因此，它将 13、14 和 15 作为输出。
Roll-num Age NAME
2 30 13 Rheana
4 50 14 Amanti
5 60 13 Alexa
结论
到此，我们就结束了这个话题。如果你遇到任何问题，欢迎在下面评论。
更多与 Python 相关的帖子，敬请关注，在此之前，祝你学习愉快！！🙂
Python 熊猫模块教程
原文：https://www.askpython.com/python-modules/pandas/python-pandas-module-tutorial
Python Pandas 模块基本上是一个开源的 Python 模块。它在计算、数据分析、统计等领域有着广泛的用途。
熊猫模块使用了 NumPy 模块的基本功能。
因此，在继续本教程之前，我建议读者和爱好者通读并对 Python NumPy 模块有一个基本的了解。
一旦你完成了它，让我们一起潜水，开始学习最有用和最有趣的模块之一—熊猫。
Python 熊猫模块入门
在了解 Pandas 模块的功能之前，我们需要安装该模块(通过 Pandas 模块的官方文档检查 Python 版本与您希望安装的模块版本的兼容性)。
有多种方法可以安装 Python 熊猫模块。最简单的方法之一是使用 Python 包安装程序即 PIP 进行安装。
在命令提示符下键入以下命令:
pip install pandas
为了将 Pandas 和 NumPy 模块添加到您的代码中，我们需要在代码中导入这些模块。
import pandas
import numpy
Python 熊猫模块-数据结构
熊猫围绕以下数据结构工作:
- 系列
- 数据帧
- 面板
与 NumPy 数组相比，这些数据结构速度更快。
1.系列
Pandas 系列是一维结构，类似于包含同类数据的数组。它是一种线性数据结构，在一个维度中存储元素。
注:熊猫系列数据结构的大小是不可变的，即一旦设置，就不能动态改变。而系列中的值/元素可以改变或操作。
语法:
pandas.Series(input_data, index, data_type, copy)
- input_data :以列表、常量、NumPy 数组、Dict 等生动的形式接受输入。
- 索引:传递给数据的索引值。
- data_type :识别数据类型。
- 复制:复制数据。默认值为 False。
举例:
import pandas
import numpy
input = numpy.array(['John','Bran','Sam','Peter'])
series_data = pandas.Series(input,index=[10,11,12,13])
print(series_data)
在上面的代码片段中，我们使用 NumPy 数组提供了输入，并为输入数据设置了索引值。
输出:
10 John
11 Bran
12 Sam
13 Peter
dtype: object
2.数据帧
Python Pandas 模块提供了一个二维结构的 DataFrame，类似于二维数组。这里，输入数据是以行和列的形式组织的。
注意:Pandas 中 DataFrame 数据结构的大小是可变的。
语法:
pandas.DataFrame(input_data, index_value, columns, data_type, copy)
- input_data :以生动的形式接受输入，如列表、序列、数字数组、字典、另一个数据帧等。
- 索引 值:传递给数据的索引值。
- data_type :识别每一列的数据类型。
- 复制:复制数据。默认值为 False。
- 列:标签提供了列的数据。
举例:
import pandas
input = [['John','Pune'],['Bran','Mumbai'],['Peter','Delhi']]
data_frame = pandas.DataFrame(input,columns=['Name','City'],index=[1,2,3])
print(data_frame)
在上面的代码中，我们使用列表提供了输入，为列添加了标签:“Name”和“City ”,并为它们设置了索引值。
输出:
Name City
1 John Pune
2 Bran Mumbai
3 Peter Delhi
3.面板
Python Pandas 模块提供了一个面板，该面板是一个三维数据结构，包含 3 个轴以提供以下功能:
- 项:(0 轴)它的每一项都对应于其中的一个数据帧。
- major_axis : (axis 1)对应每个数据帧的行。
- minor_axis : (axis 2)对应每个数据帧的列。
语法:
pandas.Panel(input_data, items, major_axis, minor_axis, data_type, copy)
将数据从 CSV 文件导入数据框架
Python Pandas 模块 DataFrame 也可以使用 CSV 文件构建。CSV 文件基本上是一个文本文件，每行数据都存储在其中。使用“逗号”分隔元素。
read_csv(file_name)方法用于将数据从 csv 文件读入数据帧。
语法:
pandas.read_csv()
举例:
import pandas as pd
data = pd.read_csv('C:\\Users\\HP\\Desktop\\Book1.csv')
print(data)
输出:
Name Age
0 John 21
1 Bran 22
熊猫的统计分析
Python 熊猫模块提出了大量的内置方法来帮助用户进行数据的统计分析。
以下是熊猫统计分析中一些最常用的函数列表:
| 方法 | 描述 |
| 计数() | 计算所有非空观察值的数量 |
| 总和() | 返回数据元素的总和 |
| 平均值() | 返回所有数据元素的平均值 |
| 中位数() | 返回所有数据元素的中值 |
| 模式() | 返回所有数据元素的模式 |
| 标准() | 返回所有数据元素的标准偏差 |
| 最小值() | 返回所有输入元素中最小的数据元素。 |
| 最大() | 返回所有输入元素中最大的数据元素。 |
| abs() | 返回绝对值 |
| 生产() | 返回数据值的乘积 |
| 联集() | 返回数据值的累积和 |
| cumprod() | 返回数据值的累积积 |
| 描述() | 它一次显示所有记录的统计摘要，即(总和、计数、最小值、平均值等) |
首先，让我们创建一个数据框架，我们将在本节中使用它来理解为统计分析提供的各种函数。
import pandas
import numpy
input = {'Name':pandas.Series(['John','Bran','Caret','Joha','Sam']),
'Marks':pandas.Series([44,48,75,33,99]),
'Roll_num':pandas.Series([1,2,3,4,5])
}
#Creating a DataFrame
data_frame = pandas.DataFrame(input)
print(data_frame)
输出:
Name Marks Roll_num
0 John 44 1
1 Bran 48 2
2 Caret 75 3
3 Joha 33 4
4 Sam 99 5
sum()函数
import pandas
import numpy
input = {'Name':pandas.Series(['John','Bran','Caret','Joha','Sam']),
'Marks':pandas.Series([44,48,75,33,99]),
'Roll_num':pandas.Series([1,2,3,4,5])
}
#Create a DataFrame
data_frame = pandas.DataFrame(input)
print(data_frame.sum())
输出:
Name JohnBranCaretJohaSam
Marks 299
Roll_num 15
dtype: object
如上所述，sum()函数分别将每一列的数据相加，并在找到的地方追加字符串值。
均值()函数
import pandas
import numpy
input = {'Name':pandas.Series(['John','Bran','Caret','Joha','Sam']),
'Marks':pandas.Series([44,48,75,33,99]),
'Roll_num':pandas.Series([1,2,3,4,5])
}
#Create a DataFrame
data_frame = pandas.DataFrame(input)
print(data_frame.mean())
输出:
Marks 59.8
Roll_num 3.0
dtype: float64
与 sum()函数不同，mean 函数不会作用于数据中的字符串。
min()函数
import pandas
import numpy
input = {'Name':pandas.Series(['John','Bran','Caret','Joha','Sam']),
'Marks':pandas.Series([44,48,75,33,99]),
'Roll_num':pandas.Series([1,2,3,4,5])
}
#Create a DataFrame
data_frame = pandas.DataFrame(input)
print(data_frame.min())
输出:
Name Bran
Marks 33
Roll_num 1
dtype: object
计数()
import pandas
import numpy
input = {'Name':pandas.Series(['John','Bran','Caret','Joha','Sam']),
'Marks':pandas.Series([44,48,75,33,99]),
'Roll_num':pandas.Series([1,2,3,4,5])
}
#Create a DataFrame
data_frame = pandas.DataFrame(input)
print(data_frame.count())
输出:
Name 5
Marks 5
Roll_num 5
dtype: int64
描述()
import pandas
import numpy
input = {'Name':pandas.Series(['John','Bran','Caret','Joha','Sam']),
'Marks':pandas.Series([44,48,75,33,99]),
'Roll_num':pandas.Series([1,2,3,4,5])
}
#Create a DataFrame
data_frame = pandas.DataFrame(input)
print(data_frame.describe())
输出:
Marks Roll_num
count 5.000000 5.000000
mean 59.800000 3.000000
std 26.808581 1.581139
min 33.000000 1.000000
25% 44.000000 2.000000
50% 48.000000 3.000000
75% 75.000000 4.000000
max 99.000000 5.000000
在 Pandas 中迭代数据帧
数据迭代为三种数据结构产生以下结果:
- 系列:一组数值
- DataFrame:列的标签
- 面板:物品标签
以下函数可用于迭代数据帧:
- ITER items()—对数据进行迭代，得到(键，值)对
- ITER rows()—对行进行迭代，得到(index，series)对
- ITER tuples()—遍历数据行并生成命名元组或 namedtuple
举例:
import pandas
import numpy
input = {'Name':pandas.Series(['John','Bran','Caret','Joha','Sam']),
'Marks':pandas.Series([44,48,75,33,99]),
'Roll_num':pandas.Series([1,2,3,4,5])
}
data_frame = pandas.DataFrame(input)
#using the iteritems() function
for key,value in data_frame.iteritems():
print(key,value)
print("\n")
#using the iterrows() function
for row_index,row in data_frame.iterrows():
print(row_index,row)
print("\n")
#using the itertuples() function
for row in data_frame.itertuples():
print(row)
输出:
Name 0 John
1 Bran
2 Caret
3 Joha
4 Sam
Name: Name, dtype: object
Marks 0 44
1 48
2 75
3 33
4 99
Name: Marks, dtype: int64
Roll_num 0 1
1 2
2 3
3 4
4 5
Name: Roll_num, dtype: int64
0 Name John
Marks 44
Roll_num 1
Name: 0, dtype: object
1 Name Bran
Marks 48
Roll_num 2
Name: 1, dtype: object
2 Name Caret
Marks 75
Roll_num 3
Name: 2, dtype: object
3 Name Joha
Marks 33
Roll_num 4
Name: 3, dtype: object
4 Name Sam
Marks 99
Roll_num 5
Name: 4, dtype: object
Pandas(Index=0, Name='John', Marks=44, Roll_num=1)
Pandas(Index=1, Name='Bran', Marks=48, Roll_num=2)
Pandas(Index=2, Name='Caret', Marks=75, Roll_num=3)
Pandas(Index=3, Name='Joha', Marks=33, Roll_num=4)
Pandas(Index=4, Name='Sam', Marks=99, Roll_num=5)
熊猫的分类
以下技术用于对 Pandas 中的数据进行排序:
- 按标签分类
- 按实际值排序
按标签排序
sort_index()方法用于根据索引值对数据进行排序。
举例:
import pandas
import numpy
input = {'Name':pandas.Series(['John','Bran','Caret','Joha','Sam']),
'Marks':pandas.Series([44,48,75,33,99]),
'Roll_num':pandas.Series([1,2,3,4,5])
}
data_frame = pandas.DataFrame(input, index=[0,2,1,4,3])
print("Unsorted data frame:\n")
print(data_frame)
sorted_df=data_frame.sort_index()
print("Sorted data frame:\n")
print(sorted_df)
输出:
Unsorted data frame:
Name Marks Roll_num
0 John 44 1
2 Caret 75 3
1 Bran 48 2
4 Sam 99 5
3 Joha 33 4
Sorted data frame:
Name Marks Roll_num
0 John 44 1
1 Bran 48 2
2 Caret 75 3
3 Joha 33 4
4 Sam 99 5
按值排序
sort_values()方法用于按值对数据帧进行排序。
它接受一个‘by’参数，其中我们需要输入列的名称，这些值需要根据该列进行排序。
举例:
import pandas
import numpy
input = {'Name':pandas.Series(['John','Bran','Caret','Joha','Sam']),
'Marks':pandas.Series([44,48,75,33,99]),
'Roll_num':pandas.Series([1,2,3,4,5])
}
data_frame = pandas.DataFrame(input, index=[0,2,1,4,3])
print("Unsorted data frame:\n")
print(data_frame)
sorted_df=data_frame.sort_values(by='Marks')
print("Sorted data frame:\n")
print(sorted_df)
输出:
Unsorted data frame:
Name Marks Roll_num
0 John 44 1
2 Caret 75 3
1 Bran 48 2
4 Sam 99 5
3 Joha 33 4
Sorted data frame:
Name Marks Roll_num
3 Joha 33 4
0 John 44 1
1 Bran 48 2
2 Caret 75 3
4 Sam 99 5
Pandas 中文本数据的操作
Python 字符串函数可应用于数据帧。
下面列出了数据帧上最常用的字符串函数:
| 功能 |
| lower() :将数据帧中的字符串转换成小写。 |
| upper() :将数据帧中的字符串转换成大写。 |
| len() :返回字符串的长度。 |
| strip() :修剪数据帧中输入两边的空白。 |
| split('):用输入模式拆分字符串。 |
| contains(pattern) :如果传递的子字符串存在于 DataFrame 的 input 元素中，则返回 true。 |
| replace(x，y) :它打乱了 x 和 y 的值。 |
| startswith(pattern) :如果输入元素以提供的参数开始，则返回 true。 |
| endswith(pattern) :如果输入元素以提供的参数结束，则返回 true。 |
| 交换大小写:将大写字母交换成小写字母，反之亦然。 |
| islower() :返回一个布尔值，检查输入的所有字符是否都是小写。 |
| isupper() :返回一个布尔值，检查输入的所有字符是否都是大写。 |
举例:
import pandas
import numpy
input = pandas.Series(['John','Bran','Caret','Joha','Sam'])
print("Converting the DataFrame to lower case....\n")
print(input.str.lower())
print("Converting the DataFrame to Upper Case.....\n")
print(input.str.upper())
print("Displaying the length of data element in each row.....\n")
print(input.str.len())
print("Replacing 'a' with '@'.....\n")
print(input.str.replace('a','@'))
输出:
Converting the DataFrame to lower case....
0 john
1 bran
2 caret
3 joha
4 sam
dtype: object
Converting the DataFrame to Upper Case.....
0 JOHN
1 BRAN
2 CARET
3 JOHA
4 SAM
dtype: object
Displaying the length of data element in each row.....
0 4
1 4
2 5
3 4
4 3
dtype: int64
Replacing 'a' with '@'.....
0 John
1 [[email protected]](/cdn-cgi/l/email-protection)
2 [[email protected]](/cdn-cgi/l/email-protection)
3 [[email protected]](/cdn-cgi/l/email-protection)
4 [[email protected]](/cdn-cgi/l/email-protection)
dtype: object
Python 熊猫模块中的数据争论
数据角力基本上是对数据的处理和操纵。
以下函数支持 Python Pandas 模块中的数据争论:
- merge() :用于将两个数据帧的公共值合并在一起。
- groupby() :它基本上是通过按提供的类别对数据进行分组来收集和表示数据。
- concat() :将一个数据帧添加到另一个数据帧。
举例:
import pandas
import numpy
input1 = {'Name':pandas.Series(['John','Bran','Caret','Joha','Sam']),
'Marks':pandas.Series([44,48,75,33,99])}
input2 = {'Name':pandas.Series(['John','Shaun','Jim','Gifty']),
'Marks':pandas.Series([44,45,78,99])}
#Create a DataFrame
df1 = pandas.DataFrame(input1)
df2 = pandas.DataFrame(input2)
print("DataFrame 1:\n")
print(df1)
print("DataFrame 2:\n")
print(df2)
print("Merging the DataFrames..\n")
print(pandas.merge(df1, df2, on='Marks'))
print("Grouping the DataFrame..\n")
group_by = df2.groupby('Name')
print(group_by.get_group('John'))
print("Concatenating both the DataFrames..\n")
print(pandas.concat([df1, df2]))
输出:
DataFrame 1:
Name Marks
0 John 44
1 Bran 48
2 Caret 75
3 Joha 33
4 Sam 99
DataFrame 2:
Name Marks
0 John 44
1 Shaun 45
2 Jim 78
3 Gifty 99
Merging the DataFrames..
Name_x Marks Name_y
0 John 44 John
1 Sam 99 Gifty
Grouping the DataFrame..
Name Marks
0 John 44
Concatenating both the DataFrames..
Name Marks
0 John 44
1 Bran 48
2 Caret 75
3 Joha 33
4 Sam 99
0 John 44
1 Shaun 45
2 Jim 78
3 Gifty 99
熊猫中的数据可视化
作为输出获得的数据可以通过绘制数据以更好的方式进一步可视化。
为了绘制和显示数据，我们首先需要安装 matplotlib 库。
pip install matplotlib
示例:数据可视化
import pandas
import numpy as np
input1 = {'Name':pandas.Series(['John','Bran','Caret','Joha','Sam']),
'Marks':pandas.Series([44,48,75,33,99])}
df1 = pandas.DataFrame(input1)
df1.plot.bar()
输出:
Data Visualization
结论
因此，在本教程中，我们已经了解了 Python 熊猫模块中可用的各种不同的方法和函数。
参考
- Python 熊猫模块
- 熊猫模块文档
Python 熊猫系列:快速指南
原文：https://www.askpython.com/python-modules/pandas/python-pandas-series
如果你像我一样，那么你喜欢学习新事物。Python 是一种很好的语言，可以做到这一点。Pandas 是用 Python 处理数据的一个很好的库。
在这个快速指南中，我将向您展示如何在 Python 中使用熊猫系列。我们将介绍什么是系列，如何创建系列，以及如何操作和访问系列中的数据。
所以让我们开始吧！
什么是系列？
Pandas 系列是存储各种数据类型的数据的一维数组。我们可以像访问数组数据一样，通过索引来访问一个系列的内容。熊猫系列最重要的两个特点如下。
- 一个系列不能包含多列。所以它是一维的。
- 我们可以使用
series()方法轻松地将列表、元组和字典转换成序列。
可以使用下面的命令创建熊猫系列
pandas.Series( data, index, dtype )
上述 python 命令中的参数是:
- 数据–它可以是各种形式，如数组、列表或常量。
- 索引–该值是唯一的，可散列的，与数据长度相同。默认情况下，如果没有索引通过，根据各自的内容，它从 0 开始，以此类推。
- dtype–它是我们输入内容的数据类型。如果没有通过，那就是推断。
让我们创造我们的熊猫系列
现在，我们将以不同的方式创建我们的系列，下面是一些例子。
从 ndarray 创建系列
示例 1
#We need to import both the pandas and numpy libraries to create a series
import pandas as pd
import numpy as np
data = np.array(['h','e','l','l','o'])
our_series = pd.Series(data)
#our series created named our_series
我们可以在上面的代码片段中看到，我们刚刚创建了第一个名为 our_series 的 python 系列。它将创建我们的系列，指数从 0 开始，依此类推。让我们把这个打印出来，看看它是怎么被创造出来的。
print (our_series)
0 h
1 e
2 l
3 l
4 o
dtype: object
示例 2
让我们使用相同的方法创建另一个，但是在这个例子中，我们将传递一些手动索引。让我们进入我们的代码片段。
#We need to import both the pandas and numpy libraries to create a series
import pandas as pd
import numpy as np
data = np.array(['h','e','l','l','o'])
our_series = pd.Series(data, index=[100,101,102,103,104])
#our series created named our_series
让我们通过打印创建的系列来查看代码片段的输出。
print (our_series)
100 h
101 e
102 l
103 l
104 o
dtype: object
这里我们可以看到索引与我们在创建系列时传递的值相同。
从字典创建系列
示例 1
#importing the pandas and numpy library
import pandas as pd
import numpy as np
data = {'a' : 0., 'b' : 1., 'c' : 2.}
our_series = pd.Series(data)
print (our_series)
一个字典可以作为输入传递，如果没有指定索引，那么字典键将按排序顺序构造索引。如果索引通过，作为索引的相应数据将优先如下。
print(our_series)
a 0.0
b 1.0
c 2.0
dtype: float64
示例 2
#importing the pandas and numpy library
import pandas as pd
import numpy as np
data = {'a' : 0., 'b' : 1., 'c' : 2.}
our_series = pd.Series(data, index=['b','c','a'])
这里，我们传递了与字典的键相对应的手动索引。通过打印创建的系列，我们可以得到如下输出。
print (our_series)
b 1.0
c 2.0
a 0.0
dtype: float64
从标量创建序列
我们将输入标量值的数据，必须提供一个索引。该值将被重复以匹配索引的长度。我们要用pandas.Series()。让我们按照下面的代码片段。
#import the pandas library and numpy library
import pandas as pd
import numpy as np
ssss = pd.Series(5, index=[0, 1, 2, 3])
我们可以通过打印新创建的系列来查看结果系列。
print(ssss)
0 5
1 5
2 5
3 5
dtype: int64
创建空系列
#importing only pandas library as pd
import pandas as pd
s = pd.Series()
如果我们打印上面的序列，我们可以得到如下的空序列。
print (s)
Series([], dtype: float64)
我们将学习如何使用各自的索引来访问系列数据
在这里，我们将检索我们系列的第一个元素。我们已经知道，索引计数从零开始，这意味着第一个元素存储在第零个^(到第)个位置，以此类推。
import pandas as pd
sss = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])
#our series created
#retrieving the first element using his index
print (s['a'])
我们将得到如下输出。
1
这样，如果我们打印任何其他指数，我们可以得到如下。
print (s[['a','c','d']])
a 1
c 3
d 4
dtype: int64
print (sss[0])
1
print (sss[4])
5
#retieving first three elements
print (sss[:3])
a 1
b 2
c 3
dtype: int64
#retrieving the last three elements
print(sss[-3:])
c 3
d 4
e 5
dtype: int64
结论
在这个快速指南中，我们了解了 Python 熊猫系列。我们已经了解了如何创建一个系列，如何操作和访问系列中的数据，以及如何对系列执行一些基本操作。我希望这个指南对你有所帮助。如果你有任何问题，请在下面的评论中发表。
Python pass 语句–Python 中的 pass 关键字
原文：https://www.askpython.com/python/python-pass-statement-keyword
Python pass 语句是一个无操作语句。它用于创建空代码块和空函数。
Python pass 语句示例
让我们看一些 Python pass 语句的例子。
1.代码块中的传递语句
假设我们必须编写一个函数来从一个列表中删除所有偶数。在这种情况下，我们将使用 for 循环遍历列表中的数字。
如果这个数被 2 除，那么我们什么都不做。否则，我们将其添加到临时列表中。最后，将只有奇数的临时列表返回给调用者。
Python 不支持空代码块。所以我们可以在 if-condition 块中对 no-operation 使用 pass 语句。
def remove_evens(list_numbers):
list_odds = []
for i in list_numbers:
if i % 2 == 0:
pass
else:
list_odds.append(i)
return list_odds
l_numbers = [1, 2, 3, 4, 5, 6]
l_odds = remove_evens(l_numbers)
print(l_odds)
输出 : [1，3，5]
这里我们不需要 if-condition 块中的任何操作。所以我们使用 pass 语句来表示不操作。
2.空函数的 pass 语句
Python 没有抽象函数的概念。如果我们必须定义一个空函数，我们不能这样写。
def foo():
# TODO - implement later
输出 : 缩进错误:应为缩进块
我们可以使用 pass 语句定义一个空的函数。该函数会有一个语句，但它不会做任何事情。
def foo():
pass
一个函数中可以有多个 pass 语句吗？
是的，我们可以在一个函数或代码块中有多个 pass 语句。这是因为 pass 语句没有终止函数。它唯一的工作就是提供一个空的语句。
def bar():
pass
print('bar')
pass
if True:
pass
pass
print('True')
else:
print('False')
pass
pass
为什么我们需要通行证声明？
- Python pass 语句在定义空函数或空代码块时非常有用。
- pass 语句最重要的用途是为我们稍后要实现的类和函数创建一个契约。例如，我们可以这样定义一个 Python 模块:
class EmployeeDAO:
def get_emp_by_id(self, i):
"""
TODO: implement this function later on
:param i: employee id
:return: employee object
"""
pass
def delete_emp(self, i):
pass
# This function will read Employees CSV Data file and return list of Employees
def read_csv_file(file):
pass
Python Pass Statement
我们可以开始实施了。第三方代码知道我们将实现的功能和方法，因此它们可以继续实现。
下一步是什么？
资源
python patchly——从大型图像中提取补丁
在本教程中，我们将看看如何使用 Python 编程语言从巨大的照片中提取补丁。
介绍
当训练任何深度学习算法时，我们更喜欢使用小图像，因为它们会产生更好的结果。但是如果我们有巨大的图像呢？一种解决方案是将较大的照片分成较小的碎片，允许我们训练任何算法。
你可能想知道patch是什么意思？顾名思义，图像块是图片中的一组像素。假设我有一个 20×20 像素的图像。它可以被分成 1000 个 2 × 2 像素的正方形小块。
Python Patchify 简介
Python Patchify是一个包，用于裁剪照片并将裁剪或修补的图像保存在一个Numpy数组中。但是首先，使用 pip 命令确保您的系统中已经安装了 patchify。
pip install patchify
Patchify 可以根据指定的补丁单元大小将一张图片分成小的重叠部分，然后将这些区域与原始图像融合。
利用 python 分片提取图像分片
现在让我们开始使用这个模块，从这里开始提取图像补丁。
1.导入模块
我们从导入将大图像转换为补丁所需的模块开始。这里的Numpy用于创建图像数据，patchify模块用于将图像转换为图像补丁。
import numpy as np
from patchify import patchify
2.创建图像数据
我们以 numpy array的形式创建图像数据，让我们看看图像的初始形状。
image = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12], [13, 14, 15, 16]])
print(image.shape)
3.从图像中提取补丁
patches = patchify(image, (2,2), step=2)
print(patches.shape)
完整的代码和输出
import numpy as np
from patchify import patchify
image = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12], [13, 14, 15, 16]])
print(image.shape)
patches = patchify(image, (2,2), step=2)
print(patches.shape)
(4, 4)
(2, 2, 2, 2)
我希望你清楚这个概念，也明白如何生成补丁。这同样适用于 3D 图像！试试吧！
编码快乐！😇
Python 钟摆模块
原文：https://www.askpython.com/python-modules/python-pendulum-module
Python 的**pendulum module**支持日期/时间转换和操作。
它帮助用户轻松处理日期/时间格式。
该模块启用并提供由 pytz 模块提供的所有功能。
通过命令行安装钟摆模块:
Pendulum Module Installation
导入摆锤模块:
import pendulum
显示当前时间
**now()**方法用于显示特定区域的当前日期时间。
举例:
import pendulum
time = pendulum.now()
print(time)
输出:
**2020-01-03T10:46:59.049040+05:30**
**timezone objects**和**datetime.now()**函数一起用于获取不同时区的当前时间戳。
举例:
from datetime import datetime
import pendulum
utc_time = pendulum.timezone('UTC')
pst_time = pendulum.timezone('America/Los_Angeles')
ist_time = pendulum.timezone('Asia/Calcutta')
print('Date Time in UTC =', datetime.now(utc_time))
print('Date Time in PST =', datetime.now(pst_time))
print('Date Time in IST =', datetime.now(ist_time))
输出:
Output-Timezone
用钟摆模块替换日期时间模块
import pendulum
utc = pendulum.now('UTC')
print('Date Time in UTC =', utc)
输出:
**Date Time in UTC = 2020-01-03T05:28:43.853647+00:00**
时区转换
import pendulum
utc = pendulum.now('UTC')
ist = utc.in_timezone('Asia/Calcutta')
print('Date Time in IST =', ist)
输出:
**Date Time in IST = 2020-01-03T11:05:20.756743+05:30**
日期时间操作
钟摆模块提供**add(**)和**subtract()**功能，以年/月/小时和小时/分钟/秒的形式操作日期和时间。
import pendulum
d_t = pendulum.datetime(2020, 2, 29)
d_t.to_datetime_string()
print(d_t)
dt_add = d_t.add(years=5)
print(dt_add)
dt_add = d_t.add(months=5)
print(dt_add)
dt_add = d_t.add(days=2)
print(dt_add)
dt_add = d_t.add(weeks=5)
print(dt_add)
dt_add = d_t.add(hours=5)
print(dt_add)
dt_add = d_t.add(minutes=5)
print(dt_add)
dt_add = d_t.add(seconds=5)
print(dt_add)
dt_sub = d_t.subtract(years=1)
print(dt_sub)
dt_sub = d_t.subtract(months=5)
print(dt_sub)
dt_sub = d_t.subtract(days=2)
print(dt_sub)
dt_sub = d_t.subtract(weeks=5)
print(dt_sub)
dt_sub = d_t.subtract(hours=5)
print(dt_sub)
dt_sub = d_t.subtract(minutes=5)
print(dt_sub)
dt_sub = d_t.subtract(seconds=5)
print(dt_sub)
输出:
Output-Datetime Manipulations
delta()函数
**delta()**函数提供两个时间戳之间的差异。
import pendulum
d_t1 = pendulum.datetime(2020, 2, 20)
d_t1.to_datetime_string()
print(d_t1)
d_t2 = pendulum.datetime(2020, 2, 10)
d_t2.to_datetime_string()
print(d_t2)
delta = d_t1 - d_t2
print(delta.start)
print(delta.end)
print(delta.in_days()) # 10
print(delta.in_hours()) # 240
输出:
Output Delta Function
格式化日期时间
**strftime()**功能使用户能够以自己的格式设置日期时间。
import pendulum
utc = pendulum.now('UTC')
print(utc .to_iso8601_string())
print(utc .to_formatted_date_string())
print(utc .to_w3c_string())
print(utc .to_date_string())
# supports strftime() too
print(utc .strftime('%Y-%m-%d %H:%M:%S %Z%z'))
输出:
2020-01-03T07:17:28.650601Z
Jan 03, 2020
2020-01-03T07:17:28+00:00
2020-01-03
2020-01-03 07:17:28 UTC+0000
日期比较
摆锤模块提供了**time-zones**的简单比较。
import pendulum
first = pendulum.datetime(2012, 9, 5, 23, 26, 11, 0, tz='America/Toronto')
second = pendulum.datetime(2019, 9, 5, 20, 26, 11, 0, tz='America/Vancouver')
first.to_datetime_string()
print(first.timezone_name)
second.to_datetime_string()
print(second.timezone_name)
print(first == second)
print(first != second)
输出:
America/Toronto
America/Vancouver
False
True
结论
因此，在本文中，我们已经理解了钟摆模块提供的功能。
参考
- Python 钟摆模块
- 摆锤文件
python PIP–包管理器
Python 编程语言分为不同的包和模块。除了核心的 Python 安装，我们还可以安装第三方模块来帮助我们进行项目开发。帮助我们安装和卸载这些包/模块的 python 包管理器叫做 PIP。
皮普是什么？
PIP 是一个 python 包管理器，帮助我们安装、审查和使用 python 编程中的各种包/模块。
安装 PIP
为了使用 PIP，我们需要下载并在我们的系统上设置 PIP。确保 Python 已经安装在您的系统中。这是安装 PIP 的先决条件。
PIP 可以安装在不同的平台上。让我们看看如何在 Windows、Linux 和 Mac OS 上安装它。
PIP 与 Python 安装程序捆绑在一起，即版本 2.7.9+或 3.10+。如果您使用的是旧版本或者想要更新它，您将需要显式安装它。
1.在 Windows 上安装 PIP
我们需要下载 PIP 安装文件来在 Windows 上安装。
你可以从这个链接复制安装脚本:【https://bootstrap.pypa.io/get-pip.py
从上面的 URL 中复制内容，并以 get-pip.py 的名称保存，之后你需要打开命令提示符并光盘到 get-pip.py 文件保存的目录下运行该文件。
$ python get-pip.py
安装后，运行以下命令检查 PIP 是否已成功安装在您的系统上。
语法:
$ pip
输出:输出应该显示如何使用画中画，以及我们可以使用画中画的一般选项和命令。
PIP Installation
2.在 Ubuntu 上安装 PIP
语法:
$ sudo apt-get install python-pip
3.在 Mac OS 上安装 PIP
我们也可以使用 easy_install 来安装 PIP。实际上，它们都是包管理器，PIP 已经取代了 easy_install 实用程序。
$ sudo easy_install pip
升级 PIP
如果您想要升级 PIP，请运行以下命令。
# python3 -m pip install --user --upgrade pip
如果已经安装了 PIP,–upgrade 选项用于将 PIP 升级到最新版本。如果您将在 pip 未安装时首次运行它，它将安装最新版本的 pip。因此，运行该命令将确保您的系统拥有最新的 PIP 版本。
使用 PIP 下载软件包
Python 由各种模块和包组成，可以使用 PIP 下载和访问。
语法:
pip install package-name
举例:
pip install pkglts
输出:
PIP install Command
Pip 列表包
如果你想看看你系统中已安装的软件包，下面的命令可以帮助你。
Pip list 命令显示已安装的软件包及其版本。
语法:
$ pip list
输出:
PIP List Packages
PIP 卸载包
带有包名的 pip uninstall 命令用于从 Python 安装中移除包。
语法:
$ pip uninstall package-name
举例:
$ pip uninstall camelcase
此外，将询问您是否同意您确实要卸载所选的软件包。输入“y”继续。
输出:
PIP Uninstall Package
PIP 支持的命令
PIP 包含许多命令来分析和处理 Python 模块和包。
1.pip 帮助
以下命令可用于获取关于 PIP 本身支持的命令的信息。
语法:
$ pip help
输出:
PIP help Command
2.pip 搜索包
我们有时可能不知道确切的包名，Python PIP 对此也有解决方案。我们可以使用下面的命令轻松地在 PIP 存储库中搜索一个包。
语法:
$ pip search package-name
举例:
$ pip search Flask
输出:
PIP search Command
3.pip 显示包信息
如果您希望获取关于已安装的包/模块的信息，例如存储位置和最新版本，那么 PIP 可以使用下面的命令来帮助我们。
语法:
$ pip show package-name
举例:
$ pip show Flask
输出:
PIP show Command
Python pip vs venv
Python pip 用于在系统级别管理包。但是，我们也可以使用 venv 在项目级别管理包。venv 命令创建与特定项目相关的虚拟环境。我们可以激活虚拟环境，然后使用 pip 命令仅为该虚拟环境安装软件包。当我们在多个项目上工作，并且不想混淆它们的包依赖关系时，这就很方便了。
摘要
Python PIP 实用程序帮助我们管理 Python 安装模块和包。我们可以搜索一个包，并使用 pip 命令安装和卸载它。我们还可以列出所有已安装的模块和软件包及其版本。
下一步是什么？
参考
Python 平台模块–快速介绍
原文：https://www.askpython.com/python-modules/python-platform-module
Python 有一个平台模块，包含处理代码运行平台的函数。在本教程中，我们将讨论该模块，并看看它的大部分有用的功能。
关于平台模块
平台模块用于检索关于系统或平台的信息。我们可以使用这个模块来执行兼容性检查。当我们有一个需要满足某些条件的 Python 程序时，例如，处理器的架构、使用的操作系统或系统拥有的 Python 版本，那么就可以使用这个模块。
这些规范用于确定 Python 代码在系统上运行的好坏。
不仅是为了兼容性检查，模块也可以为了兼容性检查而使用。我们有许多程序告诉我们我们的平台规范，任何用 Python 编写的这样的程序都可以使用这个模块。
该模块名为“platform ”,因此要在没有别名的情况下导入它，我们可以这样做:
import platform
平台模块提供的功能
现在让我们从可用的函数开始。对于每个函数，示例都在 Linux 虚拟机上运行。
读也——Python OS 模块
1。平台架构
返回一个元组，其中包含位架构(处理器总线中的位数)和平台使用的处理器的链接格式。这两个值都以字符串形式返回。
platform.architecture()
('64bit', 'ELF')
2。机器类型
返回包含平台的机器类型(处理器中使用的寄存器的大小)的字符串。
platform.machine()
'x86_64'
3。网状名字
返回包含平台网络名称的字符串(如果平台在网络中，则为平台显示该名称)。
platform.node()
'sumeet-VirtualBox'
4。平台信息
返回包含有关基础平台的有用信息的单个字符串。该函数检索尽可能多的信息，然后返回人类可读的字符串，因此对于不同的平台，它可能看起来不同。
platform.platform()
'Linux-5.4.0-58-generic-x86_64-with-glibc2.29'
5。处理器名称
返回包含平台使用的处理器的实际名称的单个字符串。
platform.processor()
'Intel64 Family 6 Model 158 Stepping 10, GenuineIntel'
6。Python 构建
返回一个元组，其中包含平台上 Python 安装的编译号和编译日期。元组中的两个值都是字符串。
platform.python_build()
('default', 'Jan 27 2021 15:41:15')
7。Python 编译器
返回一个字符串，其中包含用于在平台上编译 Python 的编译器的名称。
platform.python_compiler()
'GCC 9.3.0'
8。Python 实现
返回一个字符串，其中包含有关平台上安装的 Python 的实现的信息。
platform.python_implementation()
'CPython'
9。Python 版本
返回标识平台上安装的 Python 版本的字符串。
该字符串的格式为“major.minor.patchlevel”。
platform.python_version()
'3.8.5'
10。Python 版本元组
以元组的形式返回平台上安装的 Python 版本。
元组的格式为“(major, minor, patchlevel)”。
platform.python_version_tuple()
('3', '8', '5')
11。操作系统版本
以字符串的形式返回操作系统的发布信息。
platform.release()
'5.4.0-58-generic'
12. OS Name
以字符串形式返回平台上操作系统的名称。
platform.system()
'Linux'
13。操作系统发布版本
以字符串形式返回平台上操作系统的发布版本。
platform.version()
'#64-Ubuntu SMP Wed Dec 9 08:16:25 UTC 2020'
14。平台信息元组
返回具有六个属性的命名元组:系统、节点、版本、版本、机器和处理器。所有这些属性都有各自的函数，所以这个函数可以用来获取我们从其他函数获得的所有信息。
platform.uname()
uname_result(system='Linux', node='sumeet-VirtualBox', release='5.4.0-58-generic', version='#64-Ubuntu SMP Wed Dec 9 08:16:25 UTC 2020', machine='x86_64', processor='Intel64 Family 6 Model 158 Stepping 10, GenuineIntel')
结论
在本教程中，我们学习了 python 中的平台模块。我们讨论了它的许多重要功能，并看到了它们的输出。
我希望你有一个很好的学习时间，并在下一个教程中看到你。
Python Plotly 教程
原文：https://www.askpython.com/python-modules/python-plotly-tutorial
Python Plotly library服务于数据可视化的目的。它有助于在线创建交互式的高质量图形，也可以离线保存。
Python 中 Plotly 的需求
Plotly 在统计分析、数据可视化等领域很有用。分析和预测的结果可以用 Plotly 以生动的形式呈现出来。
Python Plotly 入门
为了利用 Plotly 库，我们首先需要使用pip命令安装它。
装置
pip install plotly==4.5.0
Installation Of Plotly
Python Plotly 中的基本图表
让我们深入了解 Python 的 Plotly 库所提供的功能。本节介绍了一些用于数据可视化的基本绘图技术。
1.散点图
顾名思义，它以分散的格式表示数据。
我们使用了 NumPy 来生成随机值，作为图形的输入。
举例:
import plotly
import plotly.graph_objs as G
import numpy
num = 15
x = numpy.random.randn(num)
y = numpy.random.randn(num)
# Create a trace
follow = G.Scatter(
x = random_x,
y = random_y,
mode = 'markers'
)
output = [follow]
plotly.offline.plot(output, filename='basic-scatter.html')
plotly.graph包含JSON object，它是一个类似于dict 的结构。通过更新该对象的几个关键字的值，可以绘制出各种生动的图形。
在上面的代码片段中，plotly.graph 的 JSON 对象表示为 g。此外，为了提供输入和绘制数据，我们使用了NumPy来生成随机值。
object.Scatter()用于提供尺寸值，即创建轨迹，并用于设置我们想要添加到图形中的其他属性。
x 和 y 参数包含要绘制在 x 和 y 轴上的值。
参数 mode决定散点图的表示方式。它可以具有下列任意值:
- 线
- 标记
- 线条+标记
- 线条+标记+文本
- 没有人
lines通过线条绘制数值作为绘图模式。
markers将通过将未分离的数据标记为点来绘制值。
plotly.offline允许程序员以离线方式绘制数值并保存。它接受一个文件名作为参数。显示数据离线绘图的 html 页面。
输出:
Scatter Plotly
2.线形散点图
在这种类型的绘图中，使用线条和散射方式的组合来表示数据。
import plotly
import plotly.graph_objs as G
import numpy as p
N = 20
x = p.linspace(0, 1, N)
one_y=p.random.randn(N)+10
two_y=p.random.randn(N)
three_y=p.random.randn(N)-10
# Create traces
plot0 = G.Scatter(
x = x,
y = one_y,
mode = 'markers'
)
plot1 = G.Scatter(
x = x,
y = two_y,
mode = 'lines+markers'
)
plot2 = G.Scatter(
x = x,
y = three_y,
mode = 'lines'
)
output = [plot0, plot1, plot2]
plotly.offline.plot(output, filename='line-scatter.html')
在上面的代码片段中，我们使用了numpy.linespace()函数来为 x 维度生成均匀分布的值。
此外，我们已经使用numpy.random()函数通过 y 轴为三个不同的轨迹生成随机值。
如上所述，我们向参数 mode 传递了不同的值，代表了绘画风格的类型。line+markers代表数值，并用线条和标记点的组合来绘制。
输出:
Line Scatter Plot
3.气泡散点图
import plotly.graph_objects as G
img = G.Figure(data=G.Scatter(
x=[10, 20, 30, 40],
y=[5, 10, 15, 20],
mode='markers',
marker=dict(size=[10,20,30,40],
color=[1, 2, 3, 4])
))
img.show()
marker是一个字典，它设置了表示数据的符号。size用于将尺寸传递给绘图符号，color用于设置值，为这些绘图符号添加颜色。
plotly.Figure()函数主要包含数据和绘图布局，它将这两个值结合起来创建一个图形。数据和布局值可表示为图形对象或字典。
plotly.show()功能用于绘制图形及其布局设计。
输出:
Bubble Scatter Plot
统计风格图表
这些类型的图表有助于以非常简化的方式显示数据。
1.箱形图
import plotly.graph_objects as G
import numpy
a = numpy.random.randn(100) - 10
b = numpy.random.randn(100) + 10
output = G.Figure()
output.add_trace(G.Box(y=a))
output.add_trace(G.Box(y=b))
output.show()
plotly.add_trace()功能用于通过向 x 和 y 维度添加轨迹来更新图形。它接受要跟踪的图形对象作为参数，即G.Scatter、G.Box等。
plotly.graph.object.Box()基本上将跟踪值设置为特定尺寸。
输出:
Box Plot
2.柱状图
import plotly.graph_objects as G
import numpy as N
x = N.random.randn(100)
output = G.Figure(data=[G.Histogram(x=x)])
output.show()
plotly.graph.object.Histogram()用于构建直方图。 x=x 指定 y 轴上直方图的增长，反之亦然。
输出:
Histogram
3.距离图
Distplot 帮助我们绘制非分布数据，并使我们能够通过线图观察或检查值。
import plotly.figure_factory as ff
import numpy as N
x = N.random.randn(500)
data = [x]
label = ['DISTPLOT']
output = ff.create_distplot(data, label)
output.show()
Python 的 API 包含figure factory module以简化的方式绘制数据。
figure_factory.distplot()绘制数据，将其表示为直方图、正态曲线等的组合。label参数用于为图表设置文本标签。
输出:
DistPlot
科学图表
这些图表有助于从更广泛的角度分析科学价值或数据。
1.计数器图
计数图基本上用于对大量数据的科学分析。
import plotly.graph_objects as G
from plotly.subplots import make_subplots
z = [[2, 4, 7, 12, 13, 14, 15, 16],
[3, 1, 6, 11, 12, 13, 16, 17],
[4, 2, 7, 7, 11, 14, 17, 18],
[5, 3, 8, 8, 13, 15, 18, 19],
[7, 4, 10, 9, 16, 18, 20, 19],
[9, 10, 5, 27, 23, 21, 21, 21],
[11, 14, 17, 26, 25, 24, 23, 22]]
out = make_subplots(rows=1, cols=1)
out.add_trace(G.Contour(z=z))
out.show()
plotly.subplots模块允许使用make_subplots()功能创建大量的数据子图。
plotly.graph.objects.Contour() 用于从提供的输入数组创建等高线。
输出:
Counter Plots
2.Plotly 中的热图
在热图绘制中，传递给输入的每个值都表示为一个像素。同样，热图也可以用来加强对科学价值和研究的分析。
import plotly.graph_objects as G
out = G.Figure(data=G.Heatmap(
z=[[10, 20, 30],
[20, 30, 40],
[40, 50, 60]]))
out.show()
plotly.graph.obejct.Heatmap() 函数基本上将输入数据的每个值表示为热图像素。
输出:
Heatmaps
金融阴谋
这些可以被认为是以更好的方式形成和描绘实时分析的最复杂的图表之一。
1.时间序列图表
在下面的代码片段中，我们使用了 Pandas 模块来读取 CSV 文件，然后绘制了相同的时序图。
import plotly.express as px
import pandas as pd
df = pd.read_csv('C:\\Users\\HP\\Desktop\\output11.csv')
fig = px.line(df, x='Marks', y='Sr no')
fig.show()
我使用的文件是一个简单的文件，有两列，序列号和标记。数据是根据哪个轴使用哪个列的数据自动绘制的。您可以对任何两列数据 CSV 文件进行同样的尝试。
Csv File Snapshot
输出:
Time Series
或者，您可以简单地以如下所示的两个列表的形式提供数据。我提供一些随机值来展示折线图是如何形成的。
import plotly.express as px
sr = [1,2,3,4,5,6]
marks = [20, 10, 50, 30, 100, 75]
fig = px.line(x=marks, y=sr)
fig.show()
输出:
Plotly Graph
plotly.express package用于提供高质量的简化图形。
plotly.express.line()功能用于根据提供的值和标签绘制一条线到 x 和 y 维度。
2.漏斗图
漏斗图使我们能够以类似于业务发展过程的不同阶段的形式来表示数据。
import plotly.express as p
data = dict(
num=[25, 50, 75, 100],
work=["Requirement Analysis", "Design", "Modelling and Construction", "Testing and Deployment"])
out = p.funnel(data, x='num', y='work')
out.show()
express.funnel()函数将输入数据帧的每一行表示为漏斗的一个阶段。这里，输入 num 和 work 以漏斗结构的形式表示。
输出:
Funnel Charts
如上所述，图表描述了发展的阶段和与之相关的价值。
三维图表
import plotly.graph_objects as G
import numpy as N
n = 100
figure = G.Figure(data=[G.Mesh3d(x=(55*N.random.randn(n)),
y=(50*N.random.randn(n)),
z=(25*N.random.randn(n)),
opacity=0.8,
color='rgba(244,22,100,0.6)'
)])
figure.show()
plotly.graph.object.Mesh3d()将数据表示为具有顶点 x、y、z 的三维绘图结构
输出:
3 D Plot
结论
因此，在本文中，我们已经了解了 Python 的 Plotly 库所提供的功能。
参考
- Python Plotly 库
- Plotly 文档
五大最佳 Python 绘图和图形库
原文：https://www.askpython.com/python/python-plotting-and-graph-libraries
这篇文章讨论了一些最好的 Python 绘图和图形库！在我们开始列举最佳库之前，让我们快速了解一下为什么数据可视化是必要的，以及什么是必要的
为什么数据可视化是必要的？
在数据分析蓬勃发展的时代，查看我们的分析结果并推断结果通常比通过文本数据或 csv 文件来理解结果更方便。
因此，数据可视化是找到复杂问题答案的简单方法。它还允许用户比表格更好地表达结果。
Data Visualization
五大最佳 Python 绘图和图形库
下面是我们将要讨论的几个 Python 绘图和图形库的快速列表:
- Matplotlib: 使用其 API 在所有应用程序上轻松绘制图形。
- 基于 matplotlib 的多功能库，允许在多个变量之间进行比较。
- ggplot: 生成特定领域的可视化
- 散景:实时流和数据的首选库。
- Plotly: 在 JS 的帮助下允许非常交互的图形。
1. Matplotlib
Matplotlib
Matplotlib 是 python 的绘图库。它提供了一个面向对象的 API，允许我们在应用程序本身中绘制图形。它是免费和开源的。支持数十种输出类型和后端。
Matplotlib 允许使用熊猫作为其 API 的包装器。这个库运行时间更好，占用内存空间小。
使用 Matplotlib 的好处
- 理解变量之间的相关性
- 传达模型对数据的拟合
- 散点图可用于异常值检测
2.希伯恩
Seaborn
Seaborn 是一个基于 matplotlib 的 python 数据可视化库。Seaborn 有一个基于数据集的 API，允许对多个变量进行比较。
它支持多点网格，从而简化复杂可视化的构建。它有单变量和双变量可视化，可用于比较数据子集。
它利用不同的调色板来展示不同种类的图案。它还自动估计线性回归模型。
Seaborn vs Matplotlib
Matplotlib 试图让简单的事情变得简单，让困难的事情变得可能，seaborn 也试图定义一组定义良好的困难事情。事实上 matplotlib 很好，但 seaborn 更好。Matplotlib 留下了不太吸引人的情节，但是 seaborn 有高级接口和定制的主题来解决这个问题。
使用 pandas 时，matplotlib 在处理数据帧时表现不佳。而 seaborn 函数处理数据帧。
3.ggplot
Ggplot
ggplot 最初在 R 中实现，是 python 中绘制图形的通用库之一。它是一种特定于领域的语言，用于产生特定于领域的可视化，特别是用于数据分析。
Ggplot 允许以简单的方式绘制图形，仅使用 2 行代码。然而，使用 matplotlib 编写的相同代码非常复杂，涉及许多行代码。因此，ggplot 简化了图形编码。这是一个非常有价值的 python 库。
需要用熊猫来实现 ggplot 的所有特性。
4.散景
Bokeh
Bokeh，一个类似于 ggplot 的库，基于图形的语法。但是，它是 python 的原生库，尚未从 r 中导入。创建可用于 web 的交互式绘图，可以输出各种格式，如–HTML 文档和 JSON 对象。
散景一直是实时流和数据最受欢迎的库之一。
用户可以使用三种级别的散景，即高级、中级和低级。高级用户可以轻松快速地创建直方图和条形图。中级用户可以使用 matplotlib 框架为散点图创建点。
5.Plotly
Plotly
Plotly 是一个有库支持的在线可视化平台。在这里，我们可以像散景一样构建交互式绘图，但是使用了额外的图形，如等高线图、3D 图表和树状图。Plotly 还识别鼠标悬停和光标点击事件，从而使 Plotly 成为一个独特的图形和 JavaScript 库。
Bokeh 和 Plotly 是类似的库，但是，使用 Plotly，你必须将数据转换成字典。然而，当使用 Pandas 处理数据帧时，plotly 更容易。
总结一下…
使用 Python 绘制图形有利也有弊，原因很简单，Python 提供了各种各样的选项。最佳库的选择完全取决于您试图完成的任务类型。请注意，没有哪个库比另一个更好，每个库的使用取决于用户的需要。
然而，Matplotlib 是所有这些库的核心，允许编码人员在它上面包装工具。Seaborn 利用 matplotlib 绘制复杂的交互式可视化图形。另一方面，散景有助于创建您自己的可视化服务器。使用这些库，并在下面的评论区告诉我们你的感受。
Python pow()方法
原文：https://www.askpython.com/python/built-in-methods/python-pow
Python pow()函数是 Python 编程中最常用的 内置 函数之一。它广泛用于计算 a 的幂 n 或更具体地说a^n的值。当处理一些复杂的数学计算或有时用于其他操作时，它是一个非常有用的函数。因此，让我们更深入地研究一下 Python 中的pow()函数。
使用 Python pow()函数
pow()函数可以通过总共三个参数来传递。下面给出了pow()的语法，
pow( a , n , b )
在哪里，
- a 是我们正在计算其幂的数或者是基数，
- n 是 a 的多少次方或者是的指数部分，
- b 是用来计算 an 的模数的数字。
注意: b 是可选参数。
例子
看看下面的代码，我们在这里试着计算一下，比方说，2⁵的值。
x=pow(2,5) #2^5
y=pow(4,-2) #1/(4^2)
print(x,y)
输出:
pow() In Python
现在让我们再次尝试传递可选的模数参数，
x=pow(2,5,5) #(2^5) % 5 = 32 % 5
print(x)
输出:
2
因此，相应地，我们得到的输出为 2 。由于pow(2,5,5)实际上返回值为 (2^5) % 5 或， 32 % 5 = 2 。
注意:在使用模参数时，我们必须确保第二个参数(指数部分)是一个正整数。否则抛出如下所示的错误，
y=pow(4,-2,6)
print(y)
输出:
Traceback (most recent call last):
File "C:/Users/sneha/Desktop/test.py", line 2, in <module>
y=pow(4,-2,6)
ValueError: pow() 2nd argument cannot be negative when 3rd argument specified
math.pow()与 Python 中的内置 pow()
除了math.pow()没有自带积分模运算，内置的pow()和预定义的math.pow()都有一些很大的区别。
对于大量的数值，pow()函数相对来说更快。另一方面，为了使用 math.pow() ，用户必须首先导入 mat h 模块。
甚至 math.pow() 方法在计算一些复数的结果时也会抛出错误。而 pow() 的方法却没有。
参考
- https://stack overflow . com/questions/10282674/difference-in-built-in-pow-and-math-pow-for-floats-in-python
- https://www.journaldev.com/23002/python-pow
Python predict()函数–您需要知道的一切！
原文：https://www.askpython.com/python/examples/python-predict-function
嘿，读者们！在本文中，我们将详细关注 Python predict()函数。所以，让我们现在就开始吧！！
了解 Python 中的 predict()函数
在数据科学领域，我们需要对数据集应用不同的机器学习模型，以便训练数据。此外，我们尝试预测未训练数据的值。
这就是 predict()函数发挥作用的时候了。
Python predict()函数使我们能够根据训练好的模型预测数据值的标签。
语法:
model.predict(data)
predict()函数只接受一个参数，它通常是要测试的数据。
它根据从模型中获得的学习或训练数据，返回作为参数传递的数据的标签。
因此，predict()函数在训练好的模型之上工作，并利用学习到的标签来映射和预测要测试的数据的标签。
实现 Python predict()函数
让我们首先将数据集加载到环境中。 pandas.read_csv()函数使我们能够从系统加载数据集。
你可以在这里找到数据集。
由于数据集也包含分类变量，因此我们创建了分类特征的虚拟模型，以便使用pandas.get_dummies()函数进行建模。
此外，我们已经使用train_test_split()函数将数据集分成训练和测试数据集。
import os
import pandas
#Changing the current working directory
os.chdir("D:/Ediwsor_Project - Bike_Rental_Count")
BIKE = pandas.read_csv("Bike.csv")
bike = BIKE.copy()
categorical_col_updated = ['season','yr','mnth','weathersit','holiday']
bike = pandas.get_dummies(bike, columns = categorical_col_updated)
#Separating the dependent and independent data variables into two data frames.
from sklearn.model_selection import train_test_split
X = bike.drop(['cnt'],axis=1)
Y = bike['cnt']
# Splitting the dataset into 80% training data and 20% testing data.
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=.20, random_state=0)
现在，让我们在下一节集中讨论预测算法的实现。
在决策树中使用 predict()函数
现在，我们已经对上述分割数据集应用了决策树算法，并使用predict() function根据决策树模型预测的值来预测测试数据集的标签。
#Building the Decision Tree Model on our dataset
from sklearn.tree import DecisionTreeRegressor
DT_model = DecisionTreeRegressor(max_depth=5).fit(X_train,Y_train)
DT_predict = DT_model.predict(X_test) #Predictions on Testing data
print(DT_predict)
输出:
Decision Tree Prediction
用 Knn 算法使用 predict()函数
在这个例子中，我们使用了 Knn 算法对数据集进行预测。我们已经对训练数据应用了KNeighborsRegressor()函数。
此外，我们对测试数据集上的预测应用了 predict()函数。
Building the KNN Model on our dataset
from sklearn.neighbors import KNeighborsRegressor
KNN_model = KNeighborsRegressor(n_neighbors=3).fit(X_train,Y_train)
KNN_predict = KNN_model.predict(X_test) #Predictions on Testing data
print(KNN_predict)
输出:
KNN Prediction
结论
到此，我们就结束了这个话题。如果你遇到任何问题，欢迎在下面评论！
更多与 Python 相关的帖子，敬请关注，在此之前，祝你学习愉快！！🙂
Python print()函数
原文：https://www.askpython.com/python/built-in-methods/python-print-function
Python print()函数主要是将给定的输入或对象打印到输出屏幕或相应的流文件。
语法:
print(objects, sep=value, end=end_value, file, flush)
Python print()函数参数:
| 争论 | 描述 | 必需/可选 |
| 物体 | 对象或输入字符串 | 需要 |
| 九月=‘值 | 关于如何分离对象的说明。
默认分隔符值是“” | 可选择的 |
| end='end_value' | 指定最后要打印的内容。
默认值为' \n ' | 可选择的 |
| 文件 | 它是一个具有写方法的对象。默认值为 sys.stdout。 | 可选择的 |
| 冲水 | 它是一个布尔值，指定获得的输出是刷新(True)还是缓冲(False)。默认值为 False。 | 可选择的 |
1.对 Python print()函数的基本理解
# Passing a single object
print("Engineering Discipline")
输出:
Engineering Discipline
2.用 Python print()函数打印多个对象
input = "Safa"
print("Result is: ", input) # Contains two objects
输出:
Result is: Safa
3.用 Python print()函数打印元组和列表
Python print()函数可以用来打印字符串、元组、列表等。到输出屏幕。
input_tuple = ("YES", "NO", 200) # Tuple
print(input_tuple)
input_list = [10,'Apple', 20,'Football', 70] # List
print(input_list)
输出:
('YES', 'NO', 200)
[10, 'Apple', 20, 'Football', 70]
4.带有“sep”关键字的 Python print()函数
默认情况下，正如您所观察到的，输出中的值由空格分隔。但是，现在 用户可以通过使用任何符号或值 替换默认值，即“”(空格)，对其进行自定义。
value1 = int(10)
value2 = 'Social Science'
print(value1, value2, sep='+')
输出:
10+Social Science
5.带有“end”关键字的 Python print()函数
正如所观察到的，“end”参数的默认值是“\n”，即 Python print()函数以换行符(' \n ')结束。
但是，现在 用户可以通过使用任何符号或值 替换默认值来定制它，例如' \n '(换行符)。
my_list = [10, 20, 0, 32, 56, 78, 90]
print('Printing the list..... ')
for x in my_list:
print(x, end='$')
输出:
Printing the list.....
10$20$0$32$56$78$90$
6.带有“文件”关键字的 Python print()函数
Python print()函数的文件参数允许用户写入文件。如果提到的文件不存在，它会用指定的名称创建一个新文件，并将输出写入其中。
input_file = open('Print_function.txt','w')
print('Social Science', file = input_file)
input_file.close()
输出:
print() Function
结论
因此，在本文中，我们已经理解了 Python 的 print()函数的工作原理。
参考
- Python print()函数
- 打印()功能文档
python–打印到文件
原文：https://www.askpython.com/python/built-in-methods/python-print-to-file
在本文中，我们将研究使用 Python 打印到文件的一些方法。
方法 1:使用 Write()打印到文件
我们可以使用我们在文件处理教程中学到的内置函数 write() 直接写入文件。
with open('output.txt', 'a') as f:
f.write('Hi')
f.write('Hello from AskPython')
f.write('exit')
输出(假设output.txt是新创建的文件)
[email protected]:~# python output_redirection.py
Hi
Hello from AskPython
exit
[email protected]:~# cat output.txt
Hi
Hello from AskPython
exit
方法 2:将 sys.stdout 重定向到文件
通常，当我们使用 打印功能 时，输出会显示到控制台上。
但是，由于标准输出流也是文件对象的处理程序，我们可以将标准输出sys.stdout改为指向目标文件。
下面的代码摘自我们之前关于标准输入、标准输出和标准错误的文章。这会将print()重定向到文件。
import sys
# Save the current stdout so that we can revert sys.stdou after we complete
# our redirection
stdout_fileno = sys.stdout
sample_input = ['Hi', 'Hello from AskPython', 'exit']
# Redirect sys.stdout to the file
sys.stdout = open('output.txt', 'w')
for ip in sample_input:
# Prints to the redirected stdout (Output.txt)
sys.stdout.write(ip + '\n')
# Prints to the actual saved stdout handler
stdout_fileno.write(ip + '\n')
# Close the file
sys.stdout.close()
# Restore sys.stdout to our old saved file handler
sys.stdout = stdout_fileno
输出(假设output.txt是新创建的文件)
[email protected]:~# python output_redirection.py
Hi
Hello from AskPython
exit
[email protected]:~# cat output.txt
Hi
Hello from AskPython
exit
方法 3:显式打印到文件
我们可以在对print()的调用中，通过提及文件的关键字参数，直接指定要打印的文件。
例如，下面的代码片段打印到文件output.txt。
print('Hi', file=open('output.txt', 'a'))
print('Hello from AskPython', file=open('output.txt', 'a'))
print('exit', file=open('output.txt', 'a'))
该文件现在附加了这三行，并且我们已经成功地打印到了output.txt！
使用上下文管理器
然而，这种方法并不是解决这种情况的最佳方法，因为在同一个文件上重复调用了open()。这是浪费时间，我们可以做得更好！
更好的方法是显式使用上下文管理器with语句，它负责自动关闭文件并直接使用文件对象。
with open("output.txt", "a") as f:
print('Hi', file=f)
print('Hello from AskPython', file=f)
print('exit', file=f)
这给出了与之前相同的结果，将这三行追加到output.txt，但是现在更快了，因为我们不再一次又一次地打开同一个文件。
方法 4:使用日志模块
我们可以使用 Python 的日志模块打印到文件。这优于方法 2，在方法 2 中，显式更改文件流不是最佳解决方案。
import logging
# Create the file
# and output every level since 'DEBUG' is used
# and remove all headers in the output
# using empty format=''
logging.basicConfig(filename='output.txt', level=logging.DEBUG, format='')
logging.debug('Hi')
logging.info('Hello from AskPython')
logging.warning('exit')
默认情况下，这将把这三行追加到output.txt。因此，我们使用logging打印到文件，这是推荐的打印到文件的方法之一。
参考
- 关于打印到文件的文章
无换行符的 Python 打印
原文：https://www.askpython.com/python/examples/python-print-without-newline
有不同的方法可以让我们不用换行就能打印到控制台。让我们快速浏览一下这些方法。
1.使用打印()
我们可以使用print()函数来实现这一点，方法是适当地设置end(结束字符)关键字参数。
默认情况下，这是一个换行符(\n)。因此，我们必须改变这一点，以避免在结尾打印一个换行符。
这个选择有很多选项。我们可以使用空格来打印空格分隔的字符串。
a = "Hello"
b = "from AskPython"
print(a, end=' ')
print(b)
这将打印字符串a和b，用一个空格分隔，而不是换行符。
输出
Hello from AskPython
我们也可以用一个空字符串连续打印它们，没有任何间隙。
a = "Hello"
b = "from AskPython"
print(a, end='')
print(b)
输出
Hellofrom AskPython
2.打印不带换行符的列表元素
有时，当遍历一个列表时，我们可能需要在同一行打印它的所有元素。为此，我们可以再次使用与之前相同的逻辑，使用end关键字参数。
a = ["Hello", "how", "are", "you?"]
for i in a:
print(i, end=" ")
输出
Hello how are you?
3.使用 sys 模块
我们也可以使用sys 模块进行无换行符打印。
更具体地说，sys.stdout.write()函数使我们能够在不换行的情况下写入控制台。
import sys
sys.stdout.write("Hello from AskPython.")
sys.stdout.write("This is printed on the same line too!")
输出
Hello from AskPython.This is printed on the same line too!
4.创建我们自己的 C 风格 printf()函数
我们也可以在 Python 中创建我们的自定义printf()函数！是的，使用模块functools这是可能的，它允许我们通过functools.partial()从现有的函数中定义新的函数！
让我们对print()上的end关键字参数使用相同的逻辑，并用它来创建我们的printf()函数！
import functools
# Create our printf function using
# print() invoked using the end=""
# keyword argument
printf = functools.partial(print, end="")
# Notice the semicolon too! This is very familiar for a
# lot of you!
printf("Hello!");
printf("This is also on the same line!");
输出
Hello!This is also on the same line!
我们还可以将分号与此结合起来(Python 编译器不会抱怨),使我们的 C printf()函数恢复原样！
参考
- JournalDev 关于不换行打印的文章
- StackOverflow 同一话题的问题
如何使用 Python 属性装饰器？
原文：https://www.askpython.com/python/built-in-methods/python-property-decorator
又见面了！在本文中，我们将看看 Python property decorator。
Python 有一个非常有用的特性，叫做 decorators，它只是函数包装器的语法糖。这里，我们将关注属性装饰器，这是一种特殊类型的装饰器。
这个主题可能会让你有点困惑，所以我们将使用说明性的例子一步一步地介绍它。我们开始吧！
Python 属性装饰器基于什么？
属性装饰器基于内置的property()函数。这个函数返回一个特殊的property对象。
您可以在您的 Python 解释器中调用它并查看一下:
>>> property()
<property object at 0x000002BBD7302BD8>
这个property对象有一些额外的方法，用于获取和设置对象的值。它也有删除它的方法。
方法列表如下:
property().getterproperty().setterproperty().deleter
但这还不止于此！这些方法也可以用在其他对象上，它们本身也可以充当装饰者！
所以，举个例子，我们可以用property().getter(obj)，它会给我们另一个属性对象！
所以，需要注意的是属性装饰器将使用这个函数，它有一些特殊的方法来读写对象。但是这对我们有什么帮助呢？
现在让我们来看看。
使用 Python 属性装饰器
要使用属性装饰器，我们需要将它包装在任何函数/方法周围。
这里有一个简单的例子:
@property
def fun(a, b):
return a + b
这与以下内容相同:
def fun(a, b):
return a + b
fun = property(fun)
所以在这里，我们用fun()包装property()，这正是装饰者所做的！
现在让我们举一个简单的例子，在一个类方法上使用属性装饰器。
考虑下面的类，没有任何修饰的方法:
class Student():
def __init__(self, name, id):
self.name = name
self.id = id
self.full_id = self.name + " - " + str(self.id)
def get_name(self):
return self.name
s = Student("Amit", 10)
print(s.name)
print(s.full_id)
# Change only the name
s.name = "Rahul"
print(s.name)
print(s.full_id)
输出
Amit
Amit - 10
Rahul
Amit - 10
这里，正如你所看到的，当我们只改变对象的name属性时，它对full_id属性的引用仍然没有更新！
为了确保每当name或id更新时full_id属性也会更新，一个解决方案是将full_id变成一个方法。
class Student():
def __init__(self, name, id):
self.name = name
self.id = id
def get_name(self):
return self.name
# Convert full_id into a method
def full_id(self):
return self.name + " - " + str(self.id)
s = Student("Amit", 10)
print(s.name)
# Method call
print(s.full_id())
s.name = "Rahul"
print(s.name)
# Method call
print(s.full_id())
输出
Amit
Amit - 10
Rahul
Rahul - 10
这里，我们已经通过将full_id转换成方法full_id()解决了我们的问题。
然而，这并不是解决这个问题的最好方法，因为您可能需要将所有这样的属性转换成一个方法，并将这些属性转换成方法调用。这不方便！
为了减少我们的痛苦，我们可以使用@property装饰器来代替！
想法是把full_id()做成一个方法，但是用@property把它封装起来。这样，我们将能够更新full_id，而不必将其视为函数调用。
我们可以直接这样做:s.full_id。注意这里没有方法调用。这是因为属性装饰器。
让我们现在就来试试吧！
class Student():
def __init__(self, name, id):
self.name = name
self.id = id
def get_name(self):
return self.name
@property
def full_id(self):
return self.name + " - " + str(self.id)
s = Student("Amit", 10)
print(s.name)
# No more method calls!
print(s.full_id)
s.name = "Rahul"
print(s.name)
# No more method calls!
print(s.full_id)
输出
Amit
Amit - 10
Rahul
Rahul - 10
事实上，这种方法现在奏效了！现在，我们不需要使用括号调用full_id。
虽然它仍然是一个方法，但属性装饰器屏蔽了它，并将其视为类的属性！现在名字没意义了吧！？
通过 setter 使用属性
在上面的例子中，这种方法是可行的，因为我们没有直接显式地修改full_id属性。默认情况下，使用@property会使该属性只读。
这意味着您不能显式更改该属性。
s.full_id = "Kishore"
print(s.full_id)
输出
---> 21 s.full_id = "Kishore"
22 print(s.full_id)
AttributeError: can't set attribute
显然，我们没有权限，因为该属性是只读的！
要让属性可写，还记得我们讲过的property().setter方法吗，也是 decorator？
原来我们可以使用@full_id.setter添加另一个full_id属性，使其可写。@full_id.setter将继承原来full_id的所有财产，所以我们可以直接添加！
但是，我们不能在 setter 属性中直接使用full_id属性。请注意，这将导致无限递归下降！
class Student():
def __init__(self, name, id):
self.name = name
self.id = id
def get_name(self):
return self.name
@property
def full_id(self):
return self.name + " - " + str(self.id)
@full_id.setter
def full_id(self, value):
# Infinite recursion depth!
# Notice that you're calling the setter property of full_id() again and again
self.full_id = value
为了避免这种情况，我们将在我们的类中添加一个隐藏属性_full_id。我们将修改@property装饰器来返回这个属性。
更新后的代码将如下所示:
class Student():
def __init__(self, name, id):
self.name = name
self.id = id
self._full_id = self.name + " - " + str(self.id)
def get_name(self):
return self.name
@property
def full_id(self):
return self._full_id
@full_id.setter
def full_id(self, value):
self._full_id = value
s = Student("Amit", 10)
print(s.name)
print(s.full_id)
s.name = "Rahul"
print(s.name)
print(s.full_id)
s.full_id = "Kishore - 20"
print(s.name)
print(s.id)
print(s.full_id)
输出
Amit
Amit - 10
Rahul
Amit - 10
Rahul
10
Kishore - 20
我们已经成功地让full_id属性拥有了 getter 和 setter 属性！
结论
希望这能让您更好地理解属性装饰器，以及为什么您可能需要使用类属性，比如_full_id。
这些隐藏的类属性(像_full_id)让我们很容易使用外部的full_id属性！
这正是现代开源项目中大量使用属性的原因。
它们让最终用户非常容易，也让开发人员很容易将隐藏属性与非隐藏属性分离开来！
参考
Python Pygame:简单介绍
嘿，同学们！今天，您将学习 Python Pygame。
Python Pygame 通常用于构建游戏和其他图形。一个人可以控制所有的逻辑和图形。没有担心与音频和视频相关的背景复杂性。
Python Pygame 入门
在开始主要内容之前，让我们先来看看下面给出的简单代码。
import pygame
from pygame.locals import *
pygame.init()
game_display = pygame.display.set_mode((800, 600))
pygame.display.set_caption('My First Game')
def event_handler():
for event in pygame.event.get():
if (event.type == QUIT):
pygame.quit()
quit()
while True:
event_handler()
pygame.display.update()
- 从 pygame 中导入 pygame 和。本地导入*–它允许访问所有 pygame 功能和内部模块
- pygame . init()–初始化 pygame 以提供对函数的方便访问，并自动启动所有需要初始化的 py game 模块。
- pygame。display.set_mode((width，height))–显示特定高度和宽度的窗口。
- pygame。display.set_caption('我的第一个游戏')–在标题屏幕顶部添加游戏名称。
- 处理事件的函数–需要定义一个函数来处理屏幕上发生的事件。现在，我们考虑一个事件，即在按下窗口上的“X”时关闭窗口。
- pygame。display . update()–用于对显示屏进行必要的更新。
下图显示了上面提到的代码的结果。只是基本的黑屏。没错。
Initial Window Pygame
向 Python Pygame 输出添加对象
上面的画面绝对无聊。只有黑屏，没有别的。让我们开始添加一些元素到屏幕上。
1.插入图像
首先，需要将背景颜色改为白色，然后从目录中加载图像。然后，在某个位置上传图片。相同的代码如下所示:
game_display.fill('white')
img = pygame.image.load('img1.png')
game_display.blit(img, (0, 0))
下面的屏幕显示了上面输入的代码的输出。
Insert Image Pygame
2.插入形状
在 Pygame 库中，只需指定要在其间绘制的点，就可以绘制特定的像素、线、圆、矩形和任何多边形。
插入矩形–要绘制一个矩形，需要使用 pygame.draw.rect()，它接受许多参数，包括屏幕名称、矩形的颜色和矩形的尺寸(x，y，宽度，高度)。
下面的代码在屏幕上显示一个红色的矩形。
pygame.draw.rect(game_display, 'red', (50, 20, 120, 100))
插入圆–插入圆需要屏幕名称、颜色、圆心坐标和圆半径等参数。
pygame.draw.circle(game_display, 'yellow', (150,170),40)
屏幕上绘制的两个形状的输出如下。
Insert Shape Pygame
参考 Pygame.draw 官方文档来学习你可以使用这个模块绘制的所有不同的形状。
使用 Python Pygame 创建一个简单的场景
下面的代码在屏幕上显示了一个简单的场景。自己尝试一下也能得到同样的效果！
import pygame
from pygame.locals import *
pygame.init()
game_display = pygame.display.set_mode((800, 250))
pygame.display.set_caption('My First Game')
pygame.draw.rect(game_display, 'lightblue', (0, 0, 800, 200))
pygame.draw.circle(game_display, 'yellow', (400,160),40)
pygame.draw.polygon(game_display, 'brown',((0,200),(50,100),(100,200)))
pygame.draw.polygon(game_display, 'brown',((100,200),(150,100),(200,200)))
pygame.draw.polygon(game_display, 'brown',((200,200),(250,100),(300,200)))
pygame.draw.polygon(game_display, 'brown',((300,200),(350,100),(400,200)))
pygame.draw.polygon(game_display, 'brown',((400,200),(450,100),(500,200)))
pygame.draw.polygon(game_display, 'brown',((500,200),(550,100),(600,200)))
pygame.draw.polygon(game_display, 'brown',((600,200),(650,100),(700,200)))
pygame.draw.polygon(game_display, 'brown',((700,200),(750,100),(800,200)))
pygame.draw.rect(game_display, 'lightgreen', (0,200, 800, 50))
def event_handler():
for event in pygame.event.get():
if (event.type == QUIT):
pygame.quit()
quit()
while True:
event_handler()
pygame.display.update()
上面代码的结果如下所示:
Scenery Using Pygame
结论
在本教程中，您学习了 pygame 的一些基本概念，以及如何使用它们创建简单的形状和对象。继续学习！
Python pytz 模块
原文：https://www.askpython.com/python-modules/python-pytz-module
Python pytz 模块提供日期时间转换功能。从而使用户服务于国际客户群。
pytz 模块支持 Python 应用程序中的时区计算。
pytz 模块安装:
**pip install pytz**
Python pytz Installation
Python pytz 模块函数
- all_timezones
- all_timezones_set
- 公共时区
- common_timezones_set
- 给定时区的取数时间
- 国家名称
- 国家时区
1. all_timezones
这个函数返回 Python 的 pytz 模块支持的所有时区的列表。
举例:
import pytz
print('The timezones supported by pytz module: ', pytz.all_timezones, '\n')
输出片段:
The timezones supported by pytz module: ['Africa/Abidjan', 'Africa/Accra', 'Africa/Addis_Ababa', 'Africa/Algiers', 'Africa/Asmara', 'Africa/Asmera', 'Africa/Bamako', 'Africa/Bangui', 'Africa/Banjul']
我们只显示了几个值，因为实际的列表非常长。
2.所有时区集
此变量返回一组所有受支持的时区。
举例:
import pytz
print('List of all the supported timezones: ', pytz.all_timezones_set, '\n')
输出片段:
List of all the supported timezones: LazySet({'America/Port-au-Prince', 'Asia/Ust-Nera', 'Asia/Vientiane', 'Australia/Hobart', 'Asia/Ulaanbaatar', 'Africa/Lome'})
3.公共时区
该变量返回常用时区的列表。
举例:
import pytz
print('Commonly used time-zones: ', pytz.common_timezones, '\n')
输出片段:
Commonly used time-zones: ['Africa/Abidjan', 'Africa/Accra', 'Africa/Addis_Ababa', 'Africa/Algiers', 'Africa/Asmara', 'Africa/Bamako', 'Africa/Bangui', 'Africa/Banjul', 'US/Pacific', 'UTC']
4.公共时区集
import pytz
print('common_timezones_set() = ', pytz.common_timezones_set, '\n')
输出:
common_timezones_set() = LazySet({'America/Eirunepe', 'Africa/Kinshasa', 'Australia/Sydney', 'Europe/Malta', 'America/Tortola', 'Canada/Pacific', 'America/Argentina/Cordoba'})
5.获取给定时区的时间
pytz.timezone()根据名称返回时区对象。并且，datetime.now()返回特定时区的日期时间。
from datetime import datetime
import pytz
# getting utc timezone
utc_time = pytz.utc
# getting timezone by name
ist_time = pytz.timezone('Asia/Kolkata')
# getting datetime of specified timezone
print('Datetime of UTC Time-zone: ', datetime.now(tz=utc_time))
print('Datetime of IST Time-zone: ', datetime.now(tz=ist_time))
输出:
Datetime of UTC Time-zone: 2020-01-03 17:49:14.220167+00:00
Datetime of IST Time-zone: 2020-01-03 23:19:14.220167+05:30
6.国家名称
country_names返回一个国家 ISO Alpha-2 代码和国家名称的字典作为键值对。
import pytz
print('country_names =')
for key, val in pytz.country_names.items():
print(key, '=', val, end=',')
print('\n')
print('Country name equivalent to the input country code: ', pytz.country_names['AQ'])
输出:
country_names =
AD = Andorra,AE = United Arab Emirates,AF = Afghanistan,AG = Antigua & Barbuda,AI = Anguilla,AL = Albania,AM = Armenia,AO = Angola,AQ = Antarctica,ZW = Zimbabwe,
Country name equivalent to the input country code: Antarctica
7.国家时区
这个函数提供了一个国家 ISO Alpha-2 代码字典作为键，并提供了特定输入键(国家代码)支持的时区列表作为输出。
import pytz
print('country_timezones =')
for key, val in pytz.country_timezones.items():
print(key, '=', val, end=',')
print('\n')
print('Time-zones supported by Antartica =', pytz.country_timezones['AQ'])
输出:
country_timezones =
AD = ['Europe/Andorra'],AE = ['Asia/Dubai'],AF = ['Asia/Kabul'],AG = ['America/Antigua'],AI = ['America/Anguilla'],AL = ['Europe/Tirane'],AM = ['Asia/Yerevan'],AO = ['Africa/Luanda'],ZW = ['Africa/Harare'],
Time-zones supported by Antartica = ['Antarctica/McMurdo', 'Antarctica/Casey', 'Antarctica/Davis', 'Antarctica/DumontDUrville', 'Antarctica/Mawson', 'Antarctica/Palmer']
参考
- Python pytz 模块
- Python pytz 文档
Python Pywhatkit–使用 Python 发送 WhatsApp 消息
原文：https://www.askpython.com/python-modules/python-pywhatkit-send-whatsapp-messages
这篇文章将向您介绍 python pywhatkit 库，以及如何使用它通过几行 python 代码自动发送 WhatsApp 消息。
Python Pywhatkit
Pywhatkit 是一个流行的 python 库，可以自动向某人的 WhatsApp 手机号码发送消息。
它使用 WhatsApp 网络发送这些信息。
Pywhatkit 是用 python 3.4+编写的 WhatsApp Messenger 的 Python 包。它简单、优雅，而且是 100% python 式的。
pywhatkit 库的特性
- 自动向 Whatsapp 上的联系人/联系人发送消息
- 自动向群组发送消息
- 播放 YouTube 视频或短片
- 也用于将文本(字符串)转换为手写
- 用 HTML 代码发送邮件
使用 Pywhatkit 通过 Python 发送 WhatsApp 消息
现在让我们进入使用 pywhatkit 的步骤，并使用 Python 发送我们的第一条 WhatsApp 消息。
1.安装库
因为在 Python3 中，pywhatkit 不是预装的，所以可以使用 pip 命令来安装它:
pip install pywhatkit
2.发送 WhatsApp 消息:
使用 pywhatkit，Whatsapp 消息可以自动发送到 Whatsapp 上的任意号码。
注意:你必须在浏览器中登录 WhatsApp，这意味着你需要在默认浏览器中设置你的 Whatsapp 网络账户。
自动 WhatsApp 是使用 pywhatkit 库的 sendmsg() 方法发送的。它有几个特点，这些特点以例子的形式列出来，展示了如何向个人或群体发送消息或图像。
语法 : pywhatkit.sendmsg("接收方手机号码"，"待发送消息"，小时，分钟)
方法的 参数—
- 接收人的手机号码:应该是字符串格式，必须包括国家代码，写在手机号码之前。
- 要发送的消息:字符串格式。
- 小时:该方法遵循 24 小时时间格式。
- 分钟:应该在 00-59 之间。
3.发送消息的代码
import pywhatkit as pwk
# using Exception Handling to avoid unexpected errors
try:
# sending message in Whatsapp in India so using Indian dial code (+91)
pwk.sendwhatmsg("+91XXXXXX5980", "Hi, how are you?", 20, 34)
print("Message Sent!") #Prints success message in console
# error message
except:
print("Error in sending the message")
这个程序将在指定的时间(晚上 8:34)向接收者(传递的电话号码)发送一条消息，消息将是“嗨，你好吗？”
注意:默认情况下，该方法会在指定时间前 15 秒打开浏览器，以弥补在默认浏览器上加载 WhatsApp 网站的时间。
在 WhatsApp 中发送消息的更多功能
发送消息后关闭标签页 (WhatsApp Web 标签页)。
pwk.sendwhatmsg("+91XXXXXX5980", "Hi", 18, 15, True, 5)
这里我们将 5 秒作为关闭标签页的时间，true 也代表标签页是否需要关闭的布尔值，如果是 True，它将关闭，否则如果是 false，它将不会关闭
向组发送图像以及标题为 Hi
这里 Media/image.png 指的是要发送的图像
pwk.sendwhats_image("Group_Name", "Media/image.png", "Hi")
pwk.sendwhats_image("Name", "Media/images.png")
向群组发送消息:
pwk.sendwhatmsg_to_group("Group_Name", "Hey Guys! How's everybody?", 11, 0)
# it is similar to sending a message to a single person but here we are sending the message in a group
即时群发消息
我们用这个在一个组中即时发送消息，就好像我们写 0 小时，0 分钟，然后它会在 12:00 AM 发送消息
pwk.sendwhatmsg_to_group_instantly("Group_Name", "Hey Guys Again!")
常见意外错误
您可能遇到的一些常见错误及其解决方案:
- "语法错误:十进制整数文本中不允许前导零；对八进制整数使用 0o 前缀"
解决方法:用除 0 以外的任何数字开始一分钟的辩论。
- "发出警告("互联网速度慢，提取信息可能需要更长时间")"
"警告:互联网速度慢，提取信息可能需要更长时间"
解决方案:确保你有一个强大的互联网连接
结论
教程到此为止！希望您已经很好地了解了 pywhatkit 以及如何使用 Pywhatkit 库自动发送 WhatsApp 消息，并准备在您的代码中实现它。请继续关注更多关于 python 的教程。
Python 队列模块
在本文中，我们将研究 Python 队列模块，它是队列数据结构的接口。
Python 队列
队列是一种数据结构，其中要插入的第一个元素也是弹出的第一个元素。这就像现实生活中的排队一样，第一个排队的也是第一个出来的。
在 Python 中，我们可以使用queue模块来创建对象队列。
这是标准 Python 库的一部分，所以不需要使用pip。
使用以下方式导入模块:
import queue
要创建一个队列对象，我们可以使用以下方法实例化它:
q = queue.Queue()
默认情况下，它的容量为 0，但是如果您想要显式地提及它，您可以使用:
q = queue.Queue(max_capacity)
Queue.get()和 Queue.put()方法
我们可以使用queue.get()和queue.put()方法在队列中插入和检索值。
让我们创建一个队列，插入从 1 到 5 的数字。
import queue
# Instantiate the Queue object
q = queue.Queue()
# Insert elements 1 to 5 in the queue
for i in range(1, 6):
q.put(i)
print('Now, q.qsize() =', q.qsize())
# Now, the queue looks like this:
# (First) 1 <- 2 <- 3 <- 4 <- 5
for i in range(q.qsize()):
print(q.get())
输出
Now, q.qsize() = 5
1
2
3
4
5
如您所见，输出显示第一个索引确实是 1，所以这是队列的顶部。其余的元素以类似的方式跟随它。
清空 Python 队列
我们可以使用q.empty()清空一个队列对象。这会将大小设置为 0，并清空队列。
import queue
# Instantiate the Queue object
q = queue.Queue()
# Insert elements 1 to 5 in the queue
for i in range(1, 6):
q.put(i)
print('Now, q.qsize() =', q.qsize())
# Empty queue
q.empty()
print('After emptying, size =', q.qsize())
for i in range(q.qsize()):
print(q.get())
输出
Now, q.qsize() = 5
After emptying, size = 0
虽然大多数典型的队列实现都有一个pop(或dequeue)操作，但是queue模块没有这个方法。
因此，如果您想从队列中弹出元素，您必须自己使用不同的队列类。一个简单的解决方案是使用 Python 的 list。
我们将使用list.append(value)向队列中插入元素，因为插入发生在最后，并且使用list.pop(0)移除元素，因为第一个元素被移除。
class MyQueue():
# Using Python Lists as a Queue
def __init__(self):
self.queue = []
def enqueue(self, value):
# Inserting to the end of the queue
self.queue.append(value)
def dequeue(self):
# Remove the furthest element from the top,
# since the Queue is a FIFO structure
return self.queue.pop(0)
my_q = MyQueue()
my_q.enqueue(2)
my_q.enqueue(5)
my_q.enqueue(7)
for i in my_q.queue:
print(i)
print('Popped,', my_q.dequeue())
for i in my_q.queue:
print(i)
输出
2
5
7
Popped, 2
5
7
我们已经用一个dequeue操作编写了自己的队列类！现在，我们将向您展示如何使用其他模块来使用其他类型的队列。
Python 中的优先级队列
优先级队列是一种基于项目的优先级添加到队列中的队列，优先级通常是一个整数值。
优先级较低的项目具有较高的优先级，位于队列的最前面，而其他项目位于后面。
queue模块也支持优先级队列结构，所以让我们看看如何使用它。
import queue
priority_q = queue.PriorityQueue()
priority_q.put((1, 'Hello'))
priority_q.put((3, 'AskPython'))
priority_q.put((2, 'from'))
for i in range(priority_q.qsize()):
print(priority_q.get())
输出
(1, 'Hello')
(2, 'from')
(3, 'AskPython')
正如您所看到的，元素是根据它们的优先级插入的。
Python 堆队列
我们还可以使用heapq模块来实现我们的优先级队列。
>>> import heapq
>>> q = []
>>> heapq.heappush(q, (1, 'hi'))
>>> q
[(1, 'hi')]
>>> heapq.heappush(q, (3, 'AskPython'))
>>> q
[(1, 'hi'), (3, 'AskPython')]
>>> heapq.heappush(q, (2, 'from'))
>>> q
[(1, 'hi'), (3, 'AskPython'), (2, 'from')]
>>> heapq.heappop(q)
(1, 'hi')
>>> heapq.heappop(q)
(2, 'from')
>>> heapq.heappop(q)
(3, 'AskPython')
>>> heapq.heappop(q)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: index out of range
因此，我们创建了一个优先级队列，并从中弹出，直到它为空。使用下面的程序也可以达到同样的效果
import heapq
q = []
heapq.heappush(q, (2, 'from'))
heapq.heappush(q, (1, 'Hello'))
heapq.heappush(q, (3, 'AskPython'))
while q:
# Keep popping until the queue is empty
item = heapq.heappop(q)
print(item)
输出
(1, 'Hello')
(2, 'from')
(3, 'AskPython')
结论
在本文中，我们学习了如何在 Python 中实现和使用不同的队列。
参考
使用 Python randint()生成随机整数
原文：https://www.askpython.com/python-modules/python-randint-method
在本文中，我们将看看如何使用 Python randint() 方法生成随机整数。
这个方法在 Python 的 random 模块中，我们将使用它来生成伪随机数，所以我们需要导入它来加载这个方法。现在就来看看这个方法吧！
Python randint()的语法
Python randint()方法返回两个界限lower和upper之间的随机整数(包括两个界限)。所以这个随机数也可能是两个极限之一。
我们可以如下调用这个函数:
random_integer = random.randint(lower, upper)
这里，下限是随机数的下限，上限是随机数的上限。
我们必须保证lower和upper是整数，并且lower < = upper。否则，将引发一个ValueError异常。
现在让我们来看看如何使用这个功能。
使用 Python randint()方法
我们需要导入random模块。之后，我们可以使用语法调用函数。
import random
beg = 10
end = 100
# Generates a random integer between (10, 100)
random_integer = random.randint(beg, end)
print(f"A random integer between {beg} and {end} is: {random_integer}")
可能的输出
A random integer between 10 and 100 is: 59
事实上，我们可以看到这个数字确实位于范围(10，100)之间。
如果我们想要重复这个伪随机生成，让我们使用一个循环来实现。
import random
beg = 0
end = 100
rand_list = [random.randint(beg, end) for _ in range(10)]
print(rand_list)
可能的输出
[61, 16, 39, 86, 25, 11, 16, 89, 99, 70]
我们可以看到这些数字在 0 到 100 的范围内。并且伪随机条件指示没有两个连续的数字重复。
注:前面我提到过，beg和end都必须是整数，其中beg < = end。否则，我们将得到一个ValueError异常。
结论
在本文中，我们学习了如何使用 Python 中的randint()方法来生成随机整数。
参考
- Python 官方文档关于随机模块
- 关于 randint()方法的 JournalDev 文章
Python 随机模块–生成随机数/序列
原文：https://www.askpython.com/python-modules/python-random-module-generate-random-numbers-sequences
本文讲的是 Python 中的random模块，用于为各种概率分布生成伪随机数。
Python 随机模块方法
1.种子()
这将初始化一个随机数生成器。要生成新的随机序列，必须根据当前系统时间设置种子。random.seed()设置随机数生成的种子。
2. getstate()
这将返回一个包含生成器当前状态的对象。要恢复状态，将对象传递给setstate()。
3. setstate(state_obj)
通过传递状态对象，这将恢复调用getstate()时发生器的状态。
4 .烧录位元
这将返回一个带有k随机位的 Python 整数。这对于像randrange()这样的方法来处理随机数生成的任意大范围非常有用。
>>> import random
>>> random.getrandbits(100) # Get a random integer having 100 bits
802952130840845478288641107953
这里有一个例子来说明getstate()和setstate()方法。
import random
random.seed(1)
# Get the state of the generator
state = random.getstate()
print('Generating a random sequence of 3 integers...')
for i in range(3):
print(random.randint(1, 1000))
# Restore the state to a point before the sequence was generated
random.setstate(state)
print('Generating the same identical sequence of 3 integers...')
for i in range(3):
print(random.randint(1, 1000))
可能的输出:
Generating a random sequence of 3 integers...
138
583
868
Generating the same identical sequence of 3 integers...
138
583
868
生成随机整数
random 模块提供了一些生成随机整数的特殊方法。
1.随机范围(开始、停止、步进)
从range(start, stop, step)返回一个随机选择的整数。这就引出了一个ValueError如果start > stop。
2. randint(a, b)
返回一个介于 a 和 b 之间的随机整数(包括这两个值)。这也引出了一个ValueError如果a > b。
这里有一个例子说明了上述两个功能。
import random
i = 100
j = 20e7
# Generates a random number between i and j
a = random.randrange(i, j)
try:
b = random.randrange(j, i)
except ValueError:
print('ValueError on randrange() since start > stop')
c = random.randint(100, 200)
try:
d = random.randint(200, 100)
except ValueError:
print('ValueError on randint() since 200 > 100')
print('i =', i, ' and j =', j)
print('randrange() generated number:', a)
print('randint() generated number:', c)
可能储量
ValueError on randrange() since start > stop
ValueError on randint() since 200 > 100
i = 100 and j = 200000000.0
randrange() generated number: 143577043
randint() generated number: 170
生成随机浮点数
与生成整数类似，还有生成随机浮点序列的函数。
- 随机的。 random () - >返回[0.0 到 1.0]之间的下一个随机浮点数
- 随机的。均匀 (a，b) - >返回一个随机浮点
N使得 a < = N < = b 如果 a < = b 并且 b < = N < = a 如果 b < a - 随机的。指数变量(λ)->返回对应于指数分布的数字。
- 随机的。高斯 (mu，sigma) - >返回一个对应于高斯分布的数字。
其他分布也有类似的函数，如正态分布、伽玛分布等。
生成这些浮点数的示例如下:
import random
print('Random number from 0 to 1 :', random.random())
print('Uniform Distribution between [1,5] :', random.uniform(1, 5))
print('Gaussian Distribution with mean = 0 and standard deviation = 1 :', random.gauss(0, 1))
print('Exponential Distribution with lambda = 0.1 :', random.expovariate(0.1))
print('Normal Distribution with mean = 1 and standard deviation = 2:', random.normalvariate(1, 5))
可能储量
Random number from 0 to 1 : 0.44663645835100585
Uniform Distribution between [1,5] : 3.65657099941547
Gaussian Distribution with mean = 0 and standard deviation = 1 : -2.271813609629832
Exponential Distribution with lambda = 0.1 : 12.64275539117617
Normal Distribution with mean = 1 and standard deviation = 2 : 4.259037195111757
使用随机模块的随机序列
与整数和浮点序列类似，一般序列可以是项目的集合，如列表/元组。random模块提供了一些有用的功能，可以给序列引入一种随机性状态。
1.随机洗牌
这是用来随机播放序列的。序列可以是包含元素的任何列表/元组。
演示洗牌的示例代码:
import random
sequence = [random.randint(0, i) for i in range(10)]
print('Before shuffling', sequence)
random.shuffle(sequence)
print('After shuffling', sequence)
可能的输出:
Before shuffling [0, 0, 2, 0, 4, 5, 5, 0, 1, 9]
After shuffling [5, 0, 9, 1, 5, 0, 4, 2, 0, 0]
2.随机选择(序列)
在实践中，这是一个广泛使用的函数，您可能希望从一个列表/序列中随机选取一个项目。
import random
a = ['one', 'eleven', 'twelve', 'five', 'six', 'ten']
print(a)
for i in range(5):
print(random.choice(a))
可能储量
['one', 'eleven', 'twelve', 'five', 'six', 'ten']
ten
eleven
six
twelve
twelve
3.随机样本(总体，k)
从长度为k的序列中返回一个随机样本。
import random
a = ['one', 'eleven', 'twelve', 'five', 'six', 'ten']
print(a)
for i in range(3):
b = random.sample(a, 2)
print('random sample:', b)
可能储量
['one', 'eleven', 'twelve', 'five', 'six', 'ten']
random sample: ['five', 'twelve']
random sample: ['ten', 'six']
random sample: ['eleven', 'one']
随机种子
由于伪随机生成是基于以前的数字，我们通常使用系统时间来确保程序在每次运行时都给出一个新的输出。因此我们利用了**seeds**。
Python 为我们提供了random.seed()，用它我们可以设置一个种子来获得一个初始值。这个种子值决定了随机数生成器的输出，因此如果它保持不变，输出也保持不变。
import random
random.seed(1)
print('Generating a random sequence of 4 numbers...')
print([random.randint(1, 100) for i in range(5)])
# Reset the seed to 1 again
random.seed(1)
# We now get the same sequence
print([random.randint(1, 100) for i in range(5)])
可能储量
Generating a random sequence of 4 numbers...
[18, 73, 98, 9, 33]
[18, 73, 98, 9, 33]
这确保了我们在处理伪随机序列时需要注意我们的种子，因为如果种子不变，序列可能会重复。
结论
我们学习了 Python 的 random 模块为我们提供的各种方法，用于处理整数、浮点数和列表等其他序列。我们还看到了种子如何影响伪随机数的序列。
参考
- Python 随机模块文档
- JournalDev 关于随机数的文章
了解 Python range()方法
原文：https://www.askpython.com/python/built-in-methods/python-range-method
介绍
今天在本教程中，我们将讨论 Python range()方法。
在 Python 的 for 循环 中广泛使用了range()方法，用于遍历或迭代任何序列。
Python range()方法
与其说是一个函数，range()实际上是一个不可变的序列类型。它返回 range 类型的数字序列。
使用 Python range()函数的语法如下。
range(start, stop[, step])
这里，
- start(可选)是序列生成开始的起始编号。它被包括在序列中，并且如果没有提及，则默认设置为 0，
- stop 是序列生成停止之前的数字(不含)，
- step(可选)是生成序列时该函数将要跳转的步骤。如果没有提供，则默认情况下认为是 1。
在 Python 中使用 range()方法
现在让我们看看实际使用 Python range()方法的各种方式。
1.只有一个参数
两个参数step和start是可选的，默认分别设置为 1 和 0 。但是对于序列生成，stop 参数是强制的。
仅提及停止时，range()功能创建一个从 0 到(停止-1) 的序列，步长为 1 。看看下面的例子。
#range() with one parameter
print("Type of object returned by range: ", type(range(5)))
list1 = list(range(5))
print("sequence generated by range() with 1 parameter: ", list1)
输出:
Type of object returned by range: <class 'range'>
sequence generated by range() with 1 parameter: [0, 1, 2, 3, 4]
正如我们所见，该方法生成的序列类型是类range的成员。根据需要，对range()输出进行类型转换会给出一个列表，其中包含值 0 到 4(5-1) 以及步长 1 。
2.有两个参数
同样，我们可以使用带有两个参数的range()方法。在这种情况下，步参数默认设置为 1 。
这个例子很容易解释。
#range() with two parameter
list1 = list(range(3,7))
print("sequence generated by range() with 2 parameter: ", list1)
输出:
sequence generated by range() with 2 parameter: [3, 4, 5, 6]
从输出可以清楚地看出step被设置为 0 。
3.有三个参数
当提到所有参数时，range()函数产生一个从开始到停止-1 的序列。起始值之后的每个元素的值计算为前一个元素和步骤的和。
下面的例子很好地说明了这一事实。
#range() with three parameter
list1 = list(range(3,20,3))
print("sequence generated by range() with 3 parameter: ", list1)
输出:
sequence generated by range() with 3 parameter: [3, 6, 9, 12, 15, 18]
从输出可以清楚地看出，序列是用范围 3 到 19(20-1) 内的值生成的。对于最后一个元素，仅仅因为 18+3=21 超过了停止点(20 ),序列生成在 18 终止。
在 Python 中对 for 循环使用 range()方法
正如我们前面提到的，range()在for循环结构中被广泛使用。让我们看一个简单的例子。
#range() with for loop
for i in range(1,5):
for j in range(1,i+1):
print(j , end="")
print()
输出:
1
12
123
1234
在上面的代码中，我们试图打印一个模式，其中每一行都有由内循环中的range(1,i+1)方法返回的序列中的数字。对于外循环的最后一次迭代( i=4 )，内循环从 1 到 (4+1)-1 =4 迭代 j 的值。
因此，输出是合理的。
结论
所以在本教程中，我们理解了 Python 中range()方法的概念。如有任何进一步的问题，欢迎使用下面的评论。
参考
- range()–Python 文档，
- python range()–日志开发帖子，
- 为什么 range(start，end)不包括 end？–堆栈溢出问题。
如何使用 Python 原始字符串？
原文：https://www.askpython.com/python/string/python-raw-strings
大家好！在本文中，我们将了解如何使用 Python 原始字符串。这是 Python 的一个强大特性，利用它我们可以引入“原始字符串”，而不用转义任何字符。
Python 原始字符串是一个普通字符串，前缀是 r 或 R 。
这将反斜杠(“\”)等字符视为文字字符。这也意味着该字符不会被视为转义字符。
现在让我们看看使用原始字符串，使用一些说明性的例子！
python 原始字符串
为了理解原始字符串的确切含义，让我们考虑下面的字符串，其序列为“\n”。
s = "Hello\tfrom AskPython\nHi"
print(s)
现在，由于s是一个普通的字符串文字，序列“\t”和“\n”将被视为转义字符。
因此，如果我们打印该字符串，就会生成相应的转义序列(制表符和换行符)。
Hello from AskPython
Hi
现在，如果我们想让s成为一个原始字符串，会发生什么？
# s is now a raw string
# Here, both backslashes will NOT be escaped.
s = r"Hello\tfrom AskPython\nHi"
print(s)
这里，两个反斜杠都不会被视为转义字符，所以 Python 不会打印制表符和换行符。
相反，它将简单地逐字打印“\t”和“\n”。
Hello\tfrom AskPython\nHi
正如您所看到的，输出和输入是一样的，因为没有字符被转义！
现在，让我们看看另一个场景，原始字符串对我们非常有用，尤其是当 Python 字符串不起作用时。
考虑下面的字符串文字，具有序列“\x”。
s = "Hello\xfrom AskPython"
print(s)
这里，序列“\x”不能使用标准的 unicode 编码进行解码。
SyntaxError: (unicode error) 'unicodeescape' codec can't decode bytes in position 5-7: truncated \xXX escape
这意味着我们甚至不能把它放入字符串中。我们现在能做什么？
这就是原始字符串派上用场的地方。
我们可以很容易地把这个值传递给一个变量，只要把它看作一个原始的字符串文字！
s = r"Hello\xfrom AskPython"
print(s)
现在，没有问题了，我们可以把这个原始的字符串文字作为一个普通的对象来传递！
Hello\xfrom AskPython
注意:在某些情况下，如果您在控制台上打印 Python 原始字符串，您可能会得到如下结果:
>>> r"Hello\xfrom AskPython"
'Hello\\xfrom AskPython'
这里，双反斜杠意味着它是一个普通的 Python 字符串，反斜杠被转义。由于print()函数打印常规的字符串文字，原始字符串被转换成这样一个字符串！
结论
在本文中，我们学习了如何使用 Python 原始字符串处理特殊字符而不转义它们。
参考
- 关于 Python 原始字符串的 JournalDev 文章
Python 读取 Excel——使用 Python 读取 Excel 文件的不同方法
原文：https://www.askpython.com/python/examples/python-read-excel
Excel 文件是一种电子表格文件，包含行和列中的一些单元格(表格视图)，有助于数据的排列、计算、排序和管理。电子表格中的数据可以是数字、文本、公式、超链接、函数等。XLS 文件将数据存储为二进制流。它只能由最流行的 MS Excel 或其他电子表格程序创建。文件格式。xlsx 总是单独表示一个 excel 文件。
下图描述了由 MS-excel 程序创建的 excel 文件:
Excel File By MS Excel
如何使用 Python 读取 Excel 文件
使用 Python 读取 excel 文件，需要使用一些流行的 Python 模块和方法。让我们也理解这些。
使用 Python xlrd 模块
xlrd 是一个 python 库或模块，用于读取和管理 Excel 文件中的信息。xlsx 格式)。除了T5 之外，该模块不适用。xlsx 文件。
让我们快速看一下如何安装xlrd 模块。
C:\Users\pc> pip install xlrd
由于您正在使用 python，您必须已经下载了pip 包安装程序。您也可以使用自己选择的另一个 Python 包管理器。
Installing Xlrd Module
在这个方法中，我们将使用xlwings 模块以及与之关联的方法(即xlwings.Book())。
此方法将自动打开我们的。xlsx 在后台为我们在其原始程序(即 MS-Excel)中，我们可以在那里操作和管理我们的数据。
#importing the xlwings module as xw
import xlwings as xw
#you can get ur excel file already been opened after execution of this command
ws = xw.Book("C:\\Users\\pc\\Desktop\\students.xlsx").sheets['Sheet1']
从上面的代码片段中，我们可以在桌面上自动打开我们的 Excel，在那里我们可以访问它。
使用 Python 熊猫模块
Pandas 是一个开源的 Python 库或模块，提供内置的高性能数据结构和数据分析工具。它最适合与另外两个核心 python 库一起用于分析数据——用于数据可视化的Matplotlib 和用于数学运算的NumPy 。
我们将使用 pip 安装程序以与上一个模块相同的方式安装这个模块，如下所示。
C:\Users\pc> pip install pandas
上面的代码片段将为我们安装pandas模块，如下所示。
Installing Panda Module
为了读取 excel 文件，让我们运行下面的代码片段。
# importing pandas module as pd
import pandas as pd
#using read_excel() method to read our excel file and storing the same in the variable named "df "
df = pd.read_excel("C:\\Users\\pc\\Desktop\\students.xlsx")
#printing our spreadsheet using print() method
print(df)
在上面的方法中，我们是用read_excel()方法来读取我们的。xlsx 文件。我们可以使用这个方法和 pandas 模块作为panda.read_excel*()*，将 excel 文件数据读入 DataFrame 对象(这里是'【T3 ')。
上面的代码片段将如下所示打印我们的电子表格。
Read Excel Method
使用 Python openpyxl 模块
Openpyxl 是一个 Python 库或模块，用于读取或写入 Excel 文件。这个模块需要安装使用 load_workbook()之类的某些方法，否则我们无法使用那些方法，它会抛出error。让我们使用命令提示符安装这个模块。
C:\Users\pc> pip install openpyxl
上面的代码片段将如下安装我们的openpyxl 模块。
Installing Openpyxl Module
在我们的第二个方法中，我们将使用 openpyxl 模块和 load_workbook()方法作为下面的代码片段。
# importing openpyxl module
import openpyxl
#using load_workbook() method to read our excel file and storing to dataframe object table1
table1 = openpyxl.load_workbook("C:\\Users\\pc\\Desktop\\students.xlsx")
#To access the table1 we need to activate and store to an another object (Here it is table2)
table2 = table1.active
for row in range(1, table2.max_row):
for col in table2.iter_cols(1, table2.max_column):
print(col[row].value, end = " ")
print("\n")
在上面的代码片段中，我们使用 load_workbook()方法读取我们需要的 excel 文件以及 openpyxl 模块。如果不导入这个库或模块，我们就无法使用这个方法。不仅仅是这个，这个模块在我们的 read_excel()方法中负责读取位置作为一个参数(这里是“C:\ Users \ PC \ Desktop \ students . xlsx”)。
在读取我们的 excel 文件并将其分配给 table1 后，需要激活它。否则，如果我们打印 table1，就会出现下面的输出。
Printing Table1
我们将通过使用 for 循环作为上面的代码片段来访问 table2。我们将得到如下结果。
Output By Method 2
结论
在本文中，我们介绍了使用 Python 读取 Excel 文件的不同方法。我们讨论了一些流行的模块以及 Python 的一些必要方法，以获得适当的输出。希望你一定练习过并喜欢我们的代码片段。我们必须带着一些更令人兴奋的话题再次访问。
Python 读取文件——你必须知道的 3 种方法
原文：https://www.askpython.com/python/built-in-methods/python-read-file
我们已经在 Python 文件处理教程中看到，我们如何使用 Python 编程在文件中执行不同的操作。
其中一个操作是读取已经创建的文件。在这里，我们将详细说明这个过程，并看看我们可以用 Python 直接读取文件的不同方法。
Python 中读取文件的不同方法
在我们开始阅读文件的方法之前，我们必须注意一些事情。首先，对于阅读来说，一个文件的存在很重要。其次，打开文件的模式也很重要。Python 编程中有多种打开文件的模式，即:
r–只读w–只写a–仅附加r+–读和写w+–既写又读a+–附加和读取
在打开文件的所有不同模式中，文件内容在r、r+、w+和a+模式下是只读的。在确保文件存在并以正确的可读模式打开它之后，我们可以进一步了解用于读取文件内容的不同函数或方法。
1.Python 中的 read()
Python 中的read()方法是一个预定义的函数，它以字符串的形式返回读取的数据。read()方法的语法是，
file_open_object.read( n )
其中文件打开对象是在打开特定文件时创建的对象，
而‘n’是要从文件中读取的字节数。在没有指定 n 的情况下，read()函数读取整个文件。
new_file content
假设要读取的内容属于上面所示的文件，名为 new_file.txt 。因此使用read()我们可以读取新文件中的信息。让我们看看如何做到这一点，
file = open("new_file.txt", "r")
print(file.read())
输出:
Python
C
C++
Java
Kotlin
同样，为了读取特定数量的字节，我们可以以下面的方式使用read(),
file = open("new_file.txt", "r")
print(file.read(6))
输出:
Python
2.Python 中的 readline()
readline() 是 Python 中的另一个预定义方法，它以字符串的形式返回一个读取行。下面是readline() 函数的语法。
file _ open _ object . readline(n)
类似地，这里的 file_open_object 是打开文件时创建的对象，‘n’是该函数将要读取的字节数。值得注意的是，如果 n 超过一行的长度，该功能不考虑下一行。仔细看看函数的用法，
file = open("new_file.txt", "r")
print(demo_file.readline())
输出:
Python\n
需要注意的一点:这里换行符(\n )也被认为是字符。
3.Python 中的 readlines()
readlines() 读取指定文件中所有的行，并返回一个包含被读取行的字符串形式的列表。下面给出的是语法，
file _ open _ object . readlines()
使用readlines()方法，
file = open("new_file.txt", "r")
print(demo_file.readlines())
输出:
['Python\n', 'C\n', 'C++\n', 'Java\n', 'Kotlin']
参考文献:
https://docs.python.org/3/tutorial/inputoutput.html
https://stack overflow . com/questions/7485458/python-reading-text-file
Python 递归示例–递归函数
原文：https://www.askpython.com/python/python-recursion-function
当一个函数调用自己时，它被称为递归函数。在本教程中，我们将学习如何编写 Python 递归函数。
Python 中什么是递归？
当一个函数以这样一种方式定义，它调用自己，它被称为递归函数。这种现象被称为递归。Python 支持递归函数。
我们真的需要递归函数吗？
递归非常类似于在每次迭代中调用函数的循环。这就是为什么我们总是可以用循环来代替 Python 递归函数。
但是，一些程序员更喜欢递归而不是循环。这主要是一个选择的问题，你可以自由地使用循环或者递归。
Python 从字符串中删除空格
原文：https://www.askpython.com/python/string/python-remove-spaces-from-string
Python 提供了多种方法来删除字符串中的空格。本文将关注一些从字符串中删除空格的有效技术。
以下两种方法都可以用来去掉字符串中的空格:
- 通过使用
**strip()**方法 - 通过使用
**replace()**方法 - 通过使用
join()与**split()**的方法 - 通过使用
**translate()**方法 - 通过使用
**Regular Expressions**
方法 1:使用 strip()方法
split()函数基本上删除了字符串的前导和尾随空格。
要点:
- strip() :这个函数从包含制表符(\t)的数组中删除前导和尾随空格。
- lstrip() :这个函数从字符串的左端移除空格。
- rstrip() :此函数删除字符串右端的空格。
举例:
string = ' Safa Mulani is a student of Engineering Discipline. '
print(f'String =\'{string}\'')
print(f'After Removing Leading Whitespaces String =\'{string.lstrip()}\'')
print(f'After Removing Trailing Whitespaces String =\'{string.rstrip()}\'')
print(f'After Trimming Whitespaces String =\'{string.strip()}\'')
输出:
Output-strip() Function
方法 2:使用 replace()方法
这个函数删除字符串中的所有空格，也删除单词之间的空格。
举例:
def remove(string_input):
return string_input.replace(" ", "")
string_input = ' S a f a '
print(remove(string_input))
输出:
可溶性抗原荧光抗体试验
方法 3:使用 join()和 split()方法
join()和 split()函数一起工作。首先，split()方法使用分隔符返回整个字符串中的单词列表。然后我们需要使用 join()方法将它们连接起来。
举例:
def remove(string_input):
return "".join(string_input.split())
# Driver Program
string_input= ' S a f a '
print(remove(string_input))
输出:
可溶性抗原荧光抗体试验
方法 4:使用 translate()方法
translate() Function
在上面的例子中，translate()函数删除了字符串中的所有空格，并生成一个紧凑的字符串作为输出。
方法 5:通过使用正则表达式
函数的作用是从字符串中删除空格。
import re
string = ' Engineering and Medical are altogether different disciplines. \t\n Agreed!! '
print('String after removal of all the spaces using Regular Expressions:\n', re.sub(r"\s+", "", string), sep='')
print('String after removal of leading spaces using Regular Expressions:\n', re.sub(r"^\s+", "", string), sep='') # ^ matches start
print('String after removal of trailing spaces using Regular Expressions:\n', re.sub(r"\s+$", "", string), sep='') # $ matches end
print('String after removal of leading and trailing spaces using Regular Expressions:\n', re.sub(r"^\s+|\s+$", "", string), sep='') # | for OR condition
输出:
Output-Removal Of Spaces Using RegEx
结论
因此，在本文中，我们实现了各种技术来删除 Python 中输入字符串的空白。
参考
- Python 从字符串中删除空格
- Python 字符串函数文档
Python replace()函数
原文：https://www.askpython.com/python/string/python-replace-function
在本文中，我们将了解 Python 的****replace()函数的功能。
Python 用字符串替换()函数
Python 内置了 string.replace()函数，用另一个字符串替换一个字符串的移植。
string.replace() function接受要替换的字符串和要用来替换旧字符串的新字符串。
语法:
string.replace("old string","new string", count)
old string:要替换的字符串。new string:您希望放在旧字符串位置的字符串的新部分。count:表示我们希望字符串被新字符串替换的次数。
示例 1: 用传递给函数的新字符串替换旧字符串
inp_str = "Python with AskPython"
res = inp_str.replace("AskPython", "AP")
print("Original String:",inp_str)
print("Replaced String:",res)
在上面的代码片段中，我们将字符串“AskPython”替换为“AP”。
输出:
Original String: Python with AskPython
Replaced String: Python with AP
替换指定数量的实例
现在让我们使用 count 参数来指定要替换的字符串的实例数。
示例 2: 使用count作为 replace()函数的参数
inp_str = "abcdaaseweraa"
res = inp_str.replace("a", "x",2)
print("Original String:",inp_str)
print("Replaced String:",res)
在本例中，我们将输入字符串作为“abcdaaseweraa”传递。此外，我们传递了原字符串中的字符“a ”,以替换为字符“x”。
这里，计数被设置为 2，即只有前两个遇到的字符“a”将被字符“x”替换。其余遇到的“a”将被取消标记，并保持不变。
输出:
Original String: abcdaaseweraa
Replaced String: xbcdxaseweraa
Python replace()函数与熊猫模块
replace()函数也可以用来替换 csv 或文本文件中的一些字符串。
Python Pandas 模块在处理数据集时非常有用。pandas.str.replace() function用于在变量或数据列中用另一个字符串替换一个字符串。
语法:
dataframe.str.replace('old string', 'new string')
我们将在以下示例中使用以下数据集:
Input Data Set
举例:
import pandas
df = pandas.read_csv("C:/IMDB_data.csv", sep=",",encoding='iso-8859-1')
df['Language']=df['Language'].str.replace("English","Hindi")
在上面的代码片段中，pandas.read_csv() function用于导入和加载数据集。
从上面的数据集中可以看出，我们选择了“语言”列，以便用“印地语”替换“英语”。
输出:
Output-replace() function
结论
因此，正如我们在上面看到的，Python replace()函数在替换大型数据集的一部分字符串时非常有用。
我强烈建议读者阅读 Pandas 教程,进一步了解如何在 Python 中与 CSV 文件交互。
参考
- JournalDev 上的 Python replace()函数文章
Python 返回语句
- python return 语句在 函数 中使用，向调用程序返回一些东西。
- 我们只能在函数内部使用 return 语句。
- 在 Python 中，每个函数都返回一些东西。如果没有返回语句，那么它返回 None 。
- 如果 return 语句包含一个表达式，它首先被求值，然后返回值。
- return 语句终止函数执行。
- 一个函数可以有多个 return 语句。当它们中的任何一个被执行时，函数终止。
- 一个函数可以返回多种类型的值。
- Python 函数可以在单个 return 语句中返回多个值。
Python return 语句示例
让我们看一个简单的例子，将两个数字相加，并将总数返回给调用者。
def add(x, y):
total = x + y
return total
我们可以通过在 return 语句中包含表达式来优化函数。
def add(x, y):
return x + y
每个函数都会返回一些东西
让我们看看当一个函数没有 return 语句时会返回什么。
>>> def foo():
... pass
...
>>>
>>> print(foo())
None
>>>
Python Return None
return 语句什么都没有会怎么样？
当 return 语句没有值时，函数返回 None 。
>>> def return_none():
... return
...
>>> print(return_none())
None
>>>
Python 函数可以有多个 return 语句
def type_of_int(i):
if i % 2 == 0:
return 'even'
else:
return 'odd'
Python 函数可以返回多种类型的值
与其他编程语言不同，python 函数不限于返回单一类型的值。如果你看看函数定义，它没有任何关于它能返回什么的信息。
让我们看一个例子，函数将返回多种类型的值。
def get_demo_data(object_type):
if 'str' == object_type:
return 'test'
elif 'tuple' == object_type:
return (1, 2, 3)
elif 'list' == object_type:
return [1, 2, 3]
elif 'dict' == object_type:
return {"1": 1, "2": 2, "3": 3}
else:
return None
在单个 return 语句中返回多个值
我们可以从一个 return 语句中返回多个值。这些值由逗号分隔，并作为元组返回给调用程序。
def return_multiple_values():
return 1, 2, 3
print(return_multiple_values())
print(type(return_multiple_values()))
输出:
(1, 2, 3)
<class 'tuple'>
Python return Multiple Values
带有 finally 块的 Python return 语句
当在 try-except 块中执行 return 语句时，在将值返回给调用方之前，首先执行 finally 块代码。
def hello():
try:
return 'hello try'
finally:
print('finally block')
def hello_new():
try:
raise TypeError
except TypeError as te:
return 'hello except'
finally:
print('finally block')
print(hello())
print(hello_new())
输出:
finally block
hello try
finally block
hello except
如果 finally 块有一个 return 语句，那么前面的 return 语句将被忽略，并返回 finally 块中的值。
def hello():
try:
return 'hello try'
finally:
print('finally block')
return 'hello from finally'
print(hello())
输出:
finally block
hello from finally
参考资料:
Python 反向列表
原文：https://www.askpython.com/python/list/python-reverse-list
Python 提供了多种方法来反转列表中的元素。
Python 反向列表元素
以下技术可用于反转 Python 列表:
- 通过使用反转的()函数
- 通过使用 reverse()函数
- 利用切片技术
- 通过使用 for 循环和 range()函数
1.反向()函数
**reversed()**方法创建一个反向迭代器，以逆序遍历列表。
def reverse_list(input):
return [x for x in reversed(input)]
input = [0, 22, 78, 1, 45, 9]
print(reverse_list(input))
输出:
[9, 45, 1, 78, 22, 0]
2.反向()函数
**reverse()**函数提供的功能是反转元素并将它们存储在同一个列表中，而不是将元素复制到另一个列表中然后反转。
def reverse_list(input):
input.reverse()
return input
input = [0, 22, 78, 1, 45, 9]
print(reverse_list(input))
输出:
[9, 45, 1, 78, 22, 0]
3.切片技术
**slicing technique**提供了反转列表的功能。
def reverse_list(input):
output = input[::-1]
return output
input = [0, 22, 78, 1, 45, 9]
print(reverse_list(input))
输出:
[9, 45, 1, 78, 22, 0]
4.通过使用 for 循环和 range()函数
input = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# Get list length
list_len = len(input)
# i goes from 0 to the middle
for x in range(int(list_len/2)):
n = input[x]
input[x] = input[list_len-x-1]
input[list_len-x-1] = n
# At this point the list should be reversed
print(input)
输出:
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
结论
因此，在本文中，我们已经理解并实现了用 Python 反转列表的各种技术。
参考
- Python 反向列表
- 反向列表文件
Python 反向字符串
原文：https://www.askpython.com/python/string/python-reverse-string
字符串基本上是字符序列。Python 不支持 reverse()这样的内置字符串函数来反转字符串。
Python Reverse String
以下是在 Python 中反转字符串的方法:
- 通过使用
for loop - 通过使用
while loop - 通过使用
Slicing - 通过使用
join()方法 - 通过使用
Recursion - 通过使用
Listreverse()的方法 - 通过使用
stack
方法 1:使用 for 循环反转字符串
def rev_string_loop(s):
res = ''
for x in s:
res = x + res
return res
str = 'STRING'
print('Reversed String =', rev_string_loop(str))
输出:
反向字符串= GNIRTS
方法 2:使用 while 循环反转字符串
def rev_string_loop(x):
res = ''
length = len(x) - 1
while length >= 0:
res = res + x[length]
length = length - 1
return res
str = 'STRING'
print('Reversed String =', rev_string_loop(str))
输出:
反向字符串= GNIRTS
方法 3:使用切片反转字符串
input="STRING"
length=len(input)
res=input[length::-1]
print (res)
输出:
格尼茨
方法 4:使用 join()方法反转字符串
input = 'STRING'
result=''.join(reversed(input))
print(result)
输出:
格尼茨
方法 5:使用递归反转字符串
def rev_string(x):
if len(x) == 0:
return x
else:
return rev_string(x[1:]) + x[0]
x = "STRING"
print ("Original string: ")
print (x)
print ("Reversed string: ")
print (rev_string(x))
输出:
原弦:
弦
反弦:
gnits
方法 6:使用 List reverse()方法反转字符串
input_list = [1, 2, 3, 4, 5]
input_list.reverse()
print(input_list)
输出:
[5, 4, 3, 2, 1]
方法 7:使用堆栈反转字符串
def create():
stack1=[]
return stack1
def size(stack1):
return len(stack1)
def isEmpty(stack1):
if size(stack1) == 0:
return true
def push(stack1,element):
stack1.append(element)
def pop(stack1):
if isEmpty(stack1): return
return stack1.pop()
def rev_string(input):
x = len(input)
stack1 = create()
for i in range(0,x,1):
push(stack1,input[i])
input=""
for i in range(0,x,1):
input+=pop(stack1)
return input
n = "STRING"
print ("Original string: ")
print (n)
print ("Reversed string: ")
print (rev_string(n))
输出:
原弦:
弦
反弦:
gnits
参考
- Python 反向字符串
- Python 文档
什么是 Python reversed()函数？
原文：https://www.askpython.com/python/built-in-methods/python-reversed-function
你好，希望你一切都好！在本文中，我们将了解内置函数的工作原理— Python reversed()函数。
Python reversed()函数的工作原理
Python 为我们提供了大量的内置函数来处理和操作数据。
Python reversed()函数就是这样一个函数。
Python reversed() function以相反的顺序处理输入数据值。reversed()函数处理列表、字符串等。并通过以逆序处理给定数据元素的序列来返回迭代器。
因此，可以说 Python reversed()函数可以用于任何数据结构的数据值的反向筛选。
理解了 reversed()函数的工作原理后，现在让我们来关注一下它的语法。
Python 反向()函数的语法
如上所述，Python reversed()函数以相反的顺序遍历数据值。
语法:
reversed(data)
reversed()函数返回一个反向迭代器，即它返回一个迭代器，该迭代器以相反的顺序获取并表示数据值。
现在，让我们在下面的小节中理解 Python reversed()函数的实现。
通过实例实现 reversed()函数
在下面的例子中，我们已经创建了一个数字数据值的列表，并将其传递给 reversed()函数。
例 1:
lst = [10, 15, 43, 56]
rev = reversed(lst)
print(rev)
print(list(rev))
reversed()函数返回反向迭代器，如我们尝试执行— print(rev)时的输出所示。
此外，为了访问 reversed()函数操作的数据值，我们使用 list()函数通过反向迭代器打印数据值。
输出:
<list_reverseiterator object at 0x00000272A6901390>
[56, 43, 15, 10]
在这个例子中，我们将字符串值传递给了列表，然后将它传递给了 reversed()函数。
例 2:
lst = ['Python','Java','C++','ML']
rev = reversed(lst)
print(list(rev))
输出:
['ML', 'C++', 'Java', 'Python']
例 3:
tuple_data = ('Python','Java','C++','ML',100,21)
rev = reversed(tuple_data)
print(tuple(rev))
现在，我们已经创建了一个数据值的元组，并将其传递给 reversed()函数来反转数据值。
输出:
(21, 100, 'ML', 'C++', 'Java', 'Python')
例 4:
data = list(range(1,5))
print("Original Data: ",data)
rev = list(reversed(data))
print("Reversed Data: ",rev)
Python reversed()函数可以与 range()函数一起使用，以逆序返回数据值序列的迭代器。
输出:
Original Data: [1, 2, 3, 4]
Reversed Data: [4, 3, 2, 1]
结论
到此为止，我们已经结束了这个话题。如果你有任何疑问，欢迎在下面评论。请继续关注我们，获取更多此类帖子！
参考
- Python reversed()函数— JournalDev
使用 Python round()
原文：https://www.askpython.com/python/built-in-methods/python-round
当我们想要执行舍入运算时，Python round() 函数非常有用。
通常，您会希望通过舍入或减少长浮点小数来快速估计值。 round() 在这种情况下尤其有利。
让我们看看如何使用它，以及一些例子！
Python round()函数的语法
功能很简单。它接受一个数字，并输出所需的整数。
round(num, [ndigits])
这里，我们需要对num进行舍入，所以我们将其传递给round()。我们也可以使用ndigits指定舍入的精度。这将确保数字在小数点后四舍五入到 ndigits 精度。
如果要将其四舍五入为整数值，不需要提供这个值。在这种情况下，将返回最接近的整数值。
同样，如果数字的形式是x.5，那么，如果上舍入值是偶数，则这些值将被上舍入。否则，将向下取整。
例如，2.5 将被舍入到 2，因为 2 是最接近的偶数，而 3.5 将被舍入到 4。
至此，让我们来看一些例子:
Python round()的示例
有些情况需要考虑，所以让我们一个一个来。
1.整数舍入
下面的代码片段显示了我们如何将数字四舍五入到最接近的整数。
print(round(5, 2)) # Round 5 upto 2 decimal places. But 5 is already an integer!
print(round(6.4))
print(round(7.7))
print(round(3.5))
输出
5
6
8
4
2.舍入到偶数边
如前所述，如果偶数边和奇数边都同样接近数字(x.5)，那么偶数边会发生舍入。
print(round(10.5))
print(round(11.5))
输出
10
12
3.用 ndigit=None 舍入
如果未指定ndigit参数(或None)，则将舍入到最接近的整数。
print(round(2.5)) # Rounding will happen to the nearest even number
# OR
print(round(2.5, None))
输出
2
2
4.用 ndigit < 0 舍入
我们也可以为参数ndigit传递一个负值。这将从小数点左边开始舍入！
因此，如果我们的原始数字在小数点后有 3 个数字，传递ndigit = -3将删除小数点前的 3 个数字并用 0 替换，得到 0！
print(round(123.456, 0))
print(round(123.456, -1))
print(round(123.456, -2))
print(round(123.456, -3))
输出
123
120.0
100.0
0.0
浮点数舍入的异常
因为浮点数是由其精度定义的，所以 Python 在计算过程中会近似这些数字。由于这些近似值，舍入它们有时会给我们带来意想不到的结果。
考虑下面的块，其中的结果可能会令人惊讶:
>>> 0.1 + 0.1 == 0.2
True
>>> 0.1 + 0.1 + 0.1 == 0.3
False
>>> 0.1 + 0.1 + 0.1 + 0.1 == 0.4
True
让我们来看看更多的例子:
>>> print(round(21.575, 2))
21.57
>>> print(round(1.23546, 2))
1.24
>>> print(round(-1.2345, 2))
-1.23
同样，由于浮点的近似值，我们没有得到精确的输出。在第一种情况下，我们会期望得到21.58，但是我们只得到21.57。
因此，在处理浮点运算时，一定要小心，因为输出中的这些小变化可能会给你带来大问题。
对自定义对象使用 Python round()
Python round()方法在内部调用__round__() dunder 方法。
如果我们正在构建一个定制的类，我们可以覆盖这个方法。因此，对我们的对象的任何调用都将转到这个覆盖方法。
让我们快速看一下如何构建我们自己的定制圆场！
class MyClass:
def __init__(self, data):
assert type(data) == type([])
self.data = data # Assume List type data of numbers
def __round__(self, num_digits=None):
for idx in range(len(self.data)):
self.data[idx] = round(self.data[idx], num_digits)
return self
my_obj = MyClass([12.34, 12.345, 10.5])
my_obj = round(my_obj)
print(my_obj.data)
输出
[12, 12, 10]
如您所见，我们能够为MyClass对象实现我们自己的定制舍入功能！
结论
在本文中，我们通过各种例子学习了如何在 Python 中使用round()函数。
参考
- Python 文档为 round()
- 关于 Python round()的 JournalDev 文章
了解 Python sample()函数
原文：https://www.askpython.com/python/built-in-methods/python-sample-method
读者朋友们，你们好！在本文中，我们将重点关注 Python sample()函数及其在数据科学领域的重要性。
所以，让我们开始吧！
Python sample()方法是什么？
我们先来了解一下 sample()方法在数据科学这个行业的存在。
在解决与数据预测相关的问题时，我们经常会遇到这样的情况:我们需要在少量数据上测试算法，以估计所应用算法的准确性。
这就是 Python sample()方法发挥作用的时候。
sample() method让我们从操作的可用数据中选择一个随机样本。尽管有很多对数据进行采样的技术，sample()方法被认为是同类方法中最简单的一种。
Python 的 sample()方法将所有类型的 iterables 如 list 、 tuple 、 sets 、 dataframe 等。它通过用户定义数量的数据值从 iterable 中随机选择数据。
现在让我们在下面的部分中理解相同的结构。
sample()方法的语法
看看下面的语法！
语法:
sample(iterable, sample_amt)
我们需要向函数提供我们希望函数从提供的 iterable 或数据结构中随机选取的样本量。
1.带列表的 Python 示例()
在本节中，我们实现了 sample()函数和一个 Python 列表，并使用该函数从数据中随机选择了 4 个样本。
举例:
from random import sample
lst = [10,20,40,30,50,46,89]
res = sample(lst, 4)
print(res)
输出:
[20, 89, 40, 46]
2.带集合的 Python 示例()
这里，我们使用字母和数值创建了一个 Python 集合。此外，我们对集合应用了 sample()函数，并随机选择了 4 个值。
举例:
from random import sample
set_sample = {1,2,3,4,5,"s","a","f","a"}
res = sample(set_sample, 4)
print(res)
输出:
['f', 1, 5, 2]
sample()函数的错误和异常
在处理 sample()函数时，我们会遇到一个 ValueError 异常。如果我们提供的 sample_amt 值大于 iterable 中数据值的总数，就会调用这个异常。
举例:
from random import sample
set_sample = {1,2,3,4,5,"s","a","f","a"}
res = sample(set_sample, 15)
print(res)
输出:
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-9-284724c4b7db> in <module>
2
3 set_sample = {1,2,3,4,5,"s","a","f","a"}
----> 4 res = sample(set_sample, 15)
5 print(res)
c:\users\hp\appdata\local\programs\python\python36\lib\random.py in sample(self, population, k)
316 n = len(population)
317 if not 0 <= k <= n:
--> 318 raise ValueError("Sample larger than population or is negative")
319 result = [None] * k
320 setsize = 21 # size of a small set minus size of an empty list
ValueError: Sample larger than population or is negative
结论
到此，我们就结束了这个话题。如果你遇到任何问题，欢迎在下面评论。
更多与 Python 相关的帖子，敬请关注，在此之前，祝你学习愉快！🙂
Python SciPy 教程
Python SciPy 是一个以 Python NumPy 和数学算法为基础的库。Python SciPy 库在很大程度上用于科学计算和处理领域。
Python Scipy 入门
为了使用 SciPy 库提供的不同功能，我们需要安装它。为此，我们将使用pip命令来安装 SciPy 库。
pip install scipy
为了使用这个库的功能，我们需要使用下面的语句导入这个库:
import scipy
Python SciPy 中的子包
SciPy 库中有各种子模块可用于执行和提高科学计算的效率。
下面列出了 SciPy 库的一些流行子模块:
- 特殊:该子模块包含执行特定任务的特殊功能。
- 常量:表示常量。
- 优化:该子模块包含优化算法。
- 积分:该子模块包含执行数学积分的函数。
- 插值:表示执行插值的函数。
- linalg :表示对线性代数方程进行运算的函数。
- io :包含对给定输入执行输入/输出操作的函数。
- fftpack :表示执行离散傅立叶变换的函数。
- 信号:表示 Python 中信号处理的函数和工具。
- 稀疏:表示处理稀疏矩阵的算法。
- cluster :表示执行层次聚类的函数。
使用 Python SciPy 的线性代数
线性代数表示线性方程组，借助矩阵表示。
SciPy 库的linalg子模块用于执行与线性方程相关的所有功能。它接受要转换为二维 NumPy 数组的对象，然后执行任务。
1.解一组方程式
让我们借助一个示例来理解线性代数子模块以及线性方程的工作原理:
4x+3y=12
3x+4y=18
考虑上面的线性方程。让我们通过linalg.solve()函数来解方程。
from scipy import linalg
import numpy
X=numpy.array([[4,3],[3,4]])
Y=numpy.array([[12],[18]])
print(linalg.solve(X,Y))
X.dot(linalg.solve(X,Y))-Y
在上面的代码片段中，我们通过 numpy.array()函数传递了输入方程中的系数和常数值。
此外，linalg. solve()函数求解线性方程并显示适用于该特定方程的 x 和 y 值。equation1.dot(linalg.solve())-equation2命令用于检查方程式的输出。
输出:
[[-0.85714286]
[ 5.14285714]]
array([[0.],
[0.]])
数组([[0。], [0.]]) 确保线性方程组已经正确求解。
[[-0.85714286][5.14285714]]:这些是用来解线性方程组的 x 和 y 值。
2.寻找矩阵的行列式
linalg.det()方法用于寻找输入矩阵的行列式。
举例:
from scipy import linalg
import numpy
determinant=numpy.array([[2,4],[4,12]])
linalg.det(determinant)
输出:
8.0
3.计算矩阵的逆矩阵
linalg.inv()方法用于计算输入矩阵的逆矩阵。
举例:
from scipy import linalg
import numpy
inverse=numpy.array([[2,4],[4,12]])
linalg.inv(inverse)
输出:
array([[ 1.5 , -0.5 ],
[-0.5 , 0.25]])
使用 Python SciPy 对多项式执行计算
SciPy 库的poly1d子模块用于对一维多项式执行操作。它接受系数作为输入，并形成多项式对象。
下面我们借助一个例子来了解一下 poly1d 子模块。
举例:
from numpy import poly1d
# Creation of a polynomial object using coefficients as inputs through poly1d
poly_input = poly1d([2, 4, 6, 8])
print(poly_input)
# Performing integration for value = 4
print("\nIntegration of the input polynomial: \n")
print(poly_input.integ(k=3))
# Performing derivation
print("\nDerivation of the input polynomial: \n")
print(poly_input.deriv())
在上面的代码片段中，poly1d()用于接受多项式的系数。
此外，polynomial.integ(value)用于查找输入标量值周围的输入多项式的积分。polynomial.deriv() 函数用于计算输入多项式的导数。
输出:
3 2
2 x + 4 x + 6 x + 8
Integration of the input polynomial:
4 3 2
0.5 x + 1.333 x + 3 x + 8 x + 3
Derivation of the input polynomial:
2
6 x + 8 x + 6
使用 Python SciPy 执行集成
SciPy 库的integrate子模块用于对输入方程进行积分。
让我们对下面的等式进行积分:
3x2 + 2*x + 6
from scipy import integrate
integrate.quad(lambda x:3*x*2 + 2*x + 6,0,2)
在上面这段代码中，integrate.quad()函数用于计算输入方程的积分。它接受以下参数:
- 方程式
- 上限
- 下限
输出:
(28.0, 3.1086244689504383e-13)
用 Python SciPy 实现傅立叶变换
傅立叶变换使我们能够将函数理解和描述为周期分量的总和。
SciPy 库的fftpack子模块用于对方程执行傅立叶变换。
举例:
from scipy.fftpack import fft
import numpy as np
# Count of sample points
n = 400
# sample spacing
T = 1.0 / 500.0
x_i = np.linspace(0.0, n*T, n)
y_i = np.tan(70.0 * 2.0*np.pi*x_i) + 0.5*np.tan(70.0 * 2.0*np.pi*x_i)
y_f = fft(y_i)
x_f = np.linspace(0.0, 1.0/(3.0*T), n//2)
# matplotlib for plotting purposes
import matplotlib.pyplot as plt
plt.plot(x_f, 2.0/n * np.abs(y_f[0:n//2]))
plt.show()
在上面的代码片段中，我们使用了 numpy.linspace()函数来获得均匀分布的整数。此外，fft()函数用于计算输入的傅立叶值。我们已经使用了 Python matplotlib 模块来绘制切线图。
输出:
Fourier Transforms – Tangent graph
Python SciPy 的特殊功能
以下是 SciPy 的special包中一些最常用的特殊函数的列表:
- 立方根
- 指数函数
- 对数和指数函数
- 伽玛
1.立方根
scipy.special.cbrt()函数用于提供所提供输入的元素式立方根。
举例:
from scipy.special import cbrt
val = cbrt([27, 8])
print(val)
输出:
[3\. 2.]
2.指数函数
scipy.special.exp10()函数用于计算给定输入的元素指数。
举例:
from scipy.special import exp10
val = exp10([27, 8])
print(val)
输出:
[1.e+27 1.e+08]
3.对数和指数函数
scipy.special.logsumexp()函数用于计算输入元素的指数之和的对数值。
举例:
from scipy.special import logsumexp
import numpy as np
inp = np.arange(5)
val = logsumexp(inp)
print(val)
这里，numpy.arange()函数用于生成一个数字序列作为输入传递。
输出:
4.451914395937593
4.伽马函数
Gamma 函数用于计算 gamma 值，称为广义阶乘是因为， gamma(n+1) = n！
scipy.special.gamma()函数用于计算输入元素的灰度值。
举例:
from scipy.special import gamma
val = gamma([5, 0.8, 2, 0])
print(val)
输出:
[24\. 1.16422971 1\. inf]
插值函数
插值是在曲线、直线等两点或多点之间寻找值的过程。
scipy.interpolate包用于在特定图形上执行插值。
举例:
import numpy as np
from scipy import interpolate
import matplotlib.pyplot as p
a = np.linspace(0, 4, 12)
b = np.sin(x**2/3+4)
print(a,b)
p.plot(a, b, 'o') # Plotting the graph assuming a and b arrays as x and y dimensions
p.show()
在上面的代码片段中，我们创建了一个正弦波，并使用 Matplotlib 模块的 Python PyPlot 包绘制了值。
输出:
[0\. 0.36363636 0.72727273 1.09090909 1.45454545 1.81818182
2.18181818 2.54545455 2.90909091 3.27272727 3.63636364 4\. ] [-0.7568025 -0.78486887 -0.85971727 -0.9505809 -0.9999744 -0.92508408
-0.64146657 -0.12309271 0.51220599 0.96001691 0.85056799 0.09131724]
Interpolation With SciPy
结论
因此，在本文中，我们已经理解了 Python SciPy 库提供的功能。
参考
- Python SciPy
- SciPy 文档
推荐阅读: Python Matplotlib 教程和 Python NumPy
Python Seaborn 教程
原文：https://www.askpython.com/python-modules/python-seaborn-tutorial
Python Seaborn 模块轻松高效的服务于数据可视化的目的。为了表示巨大数据集中的变化，data visualization被认为是描述和分析数据的最佳方式。
与 Matplotlib 相比，Seaborn 拥有一套更好的函数来以优化和高效的方式实现数据可视化。它支持 NumPy 和 Pandas 数据结构来表示数据集。
但是，为了开始使用 Seaborn 模块，我强烈建议读者理解 Python Matplotlib 模块。
Python Seaborn 入门
为了开始使用 Seaborn 模块的功能，我们需要使用下面的命令在我们的环境中安装该模块:
pip install Seaborn
Seaborn 模块需要安装以下模块才能顺利工作:
我已将要点与相关文章链接起来以供参考。
整个教程中使用的数据文件
我们将在整个教程中使用 CSV 文件，因此这一节重点介绍我们将在整个教程中使用的文件。
无论您在哪里看到对以下文件名的引用，您都可以回过头来看看这一部分，以了解正在传递的数据。
Book1.csv:
Book1.csv
tips.csv :
Input csv tips-data set
Python Seaborn 用于统计分析
统计分析在很大程度上是数据集的一些参数的基本estimation。数据可视化可被视为执行统计分析的最佳方式，即根据图表值预测结果或原因。
在统计分析过程中，可以考虑以下任何一种方法:
- seaborn.scatterplot()
- seaborn.lineplot()
1. seaborn.scatterplot()
seaborn.scatterplot()功能基本上是用来分别描绘给定轴上的参数之间的关系。图上的每一点都描绘了与之对应的一个值。
语法:
seaborn.scatterplot(x=value, y=value, data=data)
举例:
import seaborn
import pandas
import matplotlib.pyplot as plt
csv = pandas.read_csv(r'C:\Book1.csv')
res = seaborn.scatterplot(x="Name", y="Age", data=csv)
plt.show()
在上面的例子中，我们导入了 Python 熊猫模块，以便使用read_csv()函数读取数据集的内容。
列“姓名”由 x 轴表示，列“年龄”由 y 轴表示。
输出:
Seaborn ScatterPlot
2.seaborn.lineplot()
seaborn.lineplot()函数可广泛用于我们感觉需要以相对于时间的连续方式检查一个参数对另一个参数的依赖性的情况。
语法:
seabron.lineplot(x=value, y=value, data=data)
举例:
import seaborn
import pandas
import matplotlib.pyplot as plt
csv = pandas.read_csv(r'C:\Book1.csv')
res = seaborn.lineplot(x="Name", y="Age", data=csv)
plt.show()
输出:
Seaborn LinePlot
分类散点图
分类数据以离散组的形式进行划分和表示，即原始数据的子集。
Python Seaborn 模块包含以下表示和可视化分类数据的方法:
- seaborn.catplot()
- seaborn . strip lot()
- seaborn . swamplot()
1. seaborn.catplot()
如上所述,seaborn.catplot()函数是分析一个数值和一组分类值之间关系的技术之一。
语法:
seaborn.catplot(x=value, y=value, data=data)
举例:
import seaborn
import pandas
import matplotlib.pyplot as plt
csv = seaborn.load_dataset("tips")
res = seaborn.catplot(x="tip", y="sex", data=csv)
plt.show()
输出:
catplot
2.seaborn.stripplot()
seaborn.stripplot()函数将输入列中的一列视为分类数据输入，然后以顺序方式绘制相应的点，尽管输入的数据类型不同。
语法:
seaborn.stripplot(x=value, y=value, data=data)
举例:
import seaborn
import pandas
import matplotlib.pyplot as plt
csv = seaborn.load_dataset("tips")
res = seaborn.stripplot(x="tip", y="sex", data=csv,jitter=0.05)
plt.show()
当数据集由重叠的数据点组成时，参数jitter非常有用。在这种情况下，设置一个抖动值可以帮助他们得到均匀分布的 T2。
输出:
stripplot
3 . seaborn . swarmplot()
seaborn.swarmplot()函数类似于 seaborn.stripplot() 函数，但略有不同。seaborn.swarmplot()函数沿着选择的分类轴绘制数据值。因此，它完全避免了与重叠。
语法:
seaborn.swarmplot(x=value, y=value, data=data)
举例:
import seaborn
import pandas
import matplotlib.pyplot as plt
csv = seaborn.load_dataset("tips")
res = seaborn.swarmplot(x="tip", y="sex", data=csv)
plt.show()
在上面的例子中，我传递了列“sex”作为唯一的分类数据，并分别沿着 x 轴绘制了相同的数据。
输出:
swarmplot
分类分布图
分类分布数据基本上是指这样一种数据，其中结果描述了随机/选择变量属于给定的可能类别之一的某种可能性。
Python Seaborn 具有以下函数来高效地表示分类分布式数据:
- seaborn.violinplot()
- seaborn.boxplot()
- seaborn . box plot()
1.seaborn.violinplot()
seaborn.violinplot()函数表示数据的基本分布。它描述和表示不同分类数据输入的数据分布。
语法:
seaborn.violinplot(x=value, y=value, data=data)
举例:
import seaborn
import pandas
import matplotlib.pyplot as plt
csv = pandas.read_csv("C:\\Book1.csv")
res = seaborn.violinplot(x=csv['Age'])
plt.show()
在上面的例子中，我们已经分别考虑了沿着列“年龄”的数据分布。
输出:
Seaborn-violinplot
2. seaborn.boxplot()
seaborn.boxplot()函数代表数据的分类分布，并设置不同分类数据输入之间的比较。
‘盒’结构代表数据输入的主四分位数，而‘线’结构代表数据的其余分布。异常值由使用四分位数间函数的点表示。
语法:
seaborn.boxplot(x=value, y=value, data=data)
举例:
import seaborn
import pandas
import matplotlib.pyplot as plt
csv = pandas.read_csv("C:\\Book1.csv")
res = seaborn.boxplot(x=csv['Age'])
plt.show()
在上面的例子中，我们使用 Book1.csv 文件作为输入数据集。
如果你试着分析数据集，你会发现 12 岁是一个异常数据，其余的数据在 15-27 岁之间。这很好地由 seaborn.boxplot() 函数来表示。
输出:
Seaborn boxplot
3 . seaborn 打印()
seaborn.boxenplot()函数与 seaborn.boxplot() 函数非常相似，只是在表示方式上略有不同。
seaborn.boxenplot() 函数以一种方式表示分类数据的分布，其中大四分位数表示对应于实际数据观察的特征。它以一种格式呈现数据，这种格式以一种可视化的形式为我们提供了关于数据整体分布的详细信息。
语法:
seaborn.boxenplot(x=value, y=value, data=data)
举例:
import seaborn
import pandas
import matplotlib.pyplot as plt
csv = pandas.read_csv("C:\\Book1.csv")
res = seaborn.boxenplot(x=csv['Age'])
plt.show()
如果您将下面的输出与输入数据集进行分析和比较，可以清楚地了解到 boxenplot 代表了范围在 12-27 之间的数据点的全部分布，以及具有大四分位数盒结构的分类数据的分布。
输出:
Seaborn boxenplot
分类估计图
分类数据的估计基本上是指对相应数据变量的分类数据值的某种估计或预测的表示。
Python Seaborn 具有以下用于分类数据估计的函数:
- seaborn.countplot()
- seaborn.barplot()
- seaborn.pointplot()
1.seaborn.countplot()
seaborn.counplot()函数用于根据分类变量的频率或计数来估计和表示分类变量。
语法:
seaborn.countplot(x=value, y=value, data=data)
举例:
import seaborn
import pandas
import matplotlib.pyplot as plt
csv = pandas.read_csv("C:\\Book1.csv")
res = seaborn.countplot(x=csv['Age'])
plt.show()
输出:
Seaborn countplot
从上图中可以清楚地看到， countplot()函数基本上计算了输入数据字段的频率，并沿 y 轴表示，而数据字段“年龄”沿 x 轴表示。
2.seaborn.barplot()
seaborn.barplot()函数基本上以数据表示的集中趋势的形式表示估计的数据。
举例:
import seaborn
import pandas
import matplotlib.pyplot as plt
csv = pandas.read_csv("C:\\Book1.csv")
res = seaborn.barplot(x=csv['Name'], y=csv['Age'])
plt.show()
输出:
Seaborn barplot
3.seaborn.pointplot()
seaborn.pointplot()函数表示借助散点和连接散点的直线对分布中心趋势的估计。
语法:
seaborn.pointplot(x=value, y=value, data=data)
举例:
import seaborn
import pandas
import matplotlib.pyplot as plt
csv = pandas.read_csv("C:\\Book1.csv")
res = seaborn.pointplot(x=csv['Name'], y=csv['Age'])
plt.show()
输出:
Seaborn pointplot
Seaborn 的定制风格和主题
Python Seaborn 具有内置的函数和主题，能够以更好、更吸引人的方式可视化数据。
seaborn.set()功能用于输出可视化的默认主题采集。
语法:
seaborn.set()
import seaborn
import pandas
import matplotlib.pyplot as plt
seaborn.set()
csv = pandas.read_csv("C:\\Book1.csv")
res = seaborn.pointplot(x=csv['Name'], y=csv['Age'])
plt.show()
输出:
Seaborn Style Using set()
Python Seaborn 为我们提供了以下主题来处理、表示和可视化数据:
- 滴答
- 白色网格主题
- 暗格主题
- 黑暗
- 白色
语法:
seaborn.set_style("theme-name")
例:1- The dark theme
import seaborn
import pandas
import matplotlib.pyplot as plt
seaborn.set_style("dark")
csv = pandas.read_csv("C:\\Book1.csv")
res = seaborn.pointplot(x=csv['Name'], y=csv['Age'])
plt.show()
输出:
Seaborn Dark Theme
例:2- The whitegrid theme
import seaborn
import pandas
import matplotlib.pyplot as plt
seaborn.set_style("whitegrid")
csv = pandas.read_csv("C:\\Book1.csv")
res = seaborn.pointplot(x=csv['Name'], y=csv['Age'])
plt.show()
输出:
Seaborn White grid Theme
Seaborn 的多点网格
为了以精确的方式表示具有分类值的大型数据集，我们可以绘制数据子集的多个图来可视化它。
语法:
seaborn.FacetGird(data, col=value, col_wrap=value)
举例:
import seaborn
import pandas
import matplotlib.pyplot as plt
seaborn.set_style("whitegrid")
csv = pandas.read_csv("C:\\Book1.csv")
res = seaborn.FacetGrid(csv, col="Age", col_wrap=3)
res.map(seaborn.barplot, "Name", "Age")
plt.show()
FacetGrid class用于通过针对数据子集的多个图来广泛表示数据。它可以用以下维度来表示:
- 行
- 栏
- 色调
参数col_wrap基本上表示图表需要表示的行数。
FacetGrid.map()函数用于将绘图技术应用于数据的每个子集。
输出:
Seaborn Multigrid
用 Seaborn 绘制单变量分布
单变量分布基本上是指数据相对于一个单个随机变量/数据项的分布。
Python Seaborn 模块的seaborn.distplot()函数可以用来表示数据集的单变量分布。
语法:
seaborn.distplot(data-column)
举例:
import seaborn
import pandas
import matplotlib.pyplot as plt
seaborn.set_style("whitegrid")
csv = pandas.read_csv("C:\\Book1.csv")
res=seaborn.distplot(csv['Age'])
plt.show()
输出:
Seaborn Distplot
用 Seaborn 描述二元分布
二元分布是指数据相对于数据集的两个数据列或数据项的可视化。
seaborn.jointplot()可以用来描述两个数据变量之间的关系。
语法:
seaborn.jointplot(x=variable1, y=variable2)
举例:
import seaborn
import pandas
import matplotlib.pyplot as plt
seaborn.set_style("darkgrid")
csv = pandas.read_csv("C:\\Book1.csv")
res=seaborn.jointplot(x=csv['Age'], y=csv['Age'])
plt.show()
在上面的例子中，我们使用两个变量作为“年龄”,只是为了简单描述数据的可视化。
输出:
Seaborn jointplot
结论
因此，在本文中，我们已经理解了 Python Seaborn 为数据可视化提供的基本功能。
参考
- Python Seaborn-官方文档
- Python Seaborn 教程-JournalDev
通过示例了解 Python 自身变量
Python 自身变量用于将类的实例绑定到实例方法。我们必须显式地将其声明为第一个方法参数来访问实例变量和方法。此变量仅用于实例方法。
在大多数面向对象的编程语言中，您可以在方法中访问当前对象，而不需要显式地将它作为方法参数。例如，我们可以在 Java 程序中使用这个关键字来访问当前对象。但是，在 Python 中，我们必须显式地将对象实例声明为“self”变量。
Python self 是关键词？
Python 自身变量不是保留关键字。但是，使用变量名称作为“自己”来引用实例是最佳实践和惯例。
Python 自变量示例
假设我们有一个如下定义的狗类。
class Dog:
def __init__(self, breed):
self.breed = breed
def bark(self):
print(f'{self.breed} is barking.')
d = Dog('Labrador')
d.bark()
输出 : Labrador is barking.
- init()函数用两个变量定义，但是当我们创建 Dog 实例时，我们必须只提供一个参数。“自我”被自动分配给新创建的 Dog 类实例。
- bark()方法只有一个参数——“self”——它绑定到调用该方法的 Dog 实例。这就是为什么我们在调用 bark()方法时不传递任何参数。
- 如果我们必须访问函数中的任何实例变量，我们可以使用点运算符。
我们能跳过“自我”变量吗？
如果实例方法不需要访问实例变量怎么办？在这种情况下，我们可以跳过 self 变量吗？
让我们用一个简单的例子来了解一下。
class Dog:
def bark():
print('Barking')
d = Dog()
print("Done")
如果你运行上面的代码，就不会有任何错误。但是，我们没有调用 bark()方法。让我们看看当我们试图调用 bark()方法时会发生什么。
d = Dog()
d.bark()
Python instance method without self Error
由于 bark()方法接受 0 个参数，但我们提供了 1 个参数，因此出现了错误。这是因为当我们调用d.bark()时，“d”实例会自动作为第一个参数传递给 bark()实例方法。
但是，如果我们通过类引用访问 bark()实例方法，那么它会工作得很好。所以，调用 **Dog.bark()** 不会导致任何错误。
类方法和静态方法的相似变量？
类方法也存在同样的行为。唯一的区别是，约定是使用“ cls ”作为类引用的变量名。
class Dog:
@classmethod
def walk(cls):
print('Dog is Walking')
Dog.walk()
然而，静态方法并不要求这样。因为，静态方法是自给自足的函数，它们不能直接访问任何类变量或函数。
让我们看一个完整的例子，有 self 和 cls 变量和一个没有任何参数的静态方法。
class Dog:
def __init__(self, breed):
self.breed = breed
@classmethod
def walk(cls):
print('Dog is Walking')
# instance method
def bark(self):
print(f'{self.breed} is barking.')
@staticmethod
def add(x, y):
return x + y
Dog.walk()
d = Dog('Labrador')
d.bark()
print(Dog.add(10, 20))
输出:
Dog is Walking
Labrador is barking.
30
打破常规的快速例子
这个例子只是向您展示，使用变量名作为“self”和“cls”并不是强制性的。在真正的编程中，请始终遵守这一约定。
class Dog:
@classmethod
def walk(myclass):
print('Dog is Walking')
# instance method
def bark(myobject):
print('Dog is Barking.')
Dog.walk()
d = Dog()
d.bark()
“self”变量被绑定到当前实例
self 变量使我们能够访问当前的实例属性。我们可以通过创建 Dog 类的两个不同实例的简单示例来证实这一点。
class Dog:
def __init__(self, b):
self.breed = b
def bark(self):
print(f'{self.breed} is Barking.')
d1 = Dog('Labrador')
d2 = Dog('Husky')
d1.bark()
d2.bark()
输出:
Labrador is Barking.
Husky is Barking.
为什么不把“自我”变量隐式化？
有很多建议将“self”变量作为保留关键字，隐式地提供给实例方法。但是，这个建议被“吉多·范·罗苏姆”拒绝了。你可以在这里阅读它们，在这里阅读。
Python 集合差异
原文：https://www.askpython.com/python/set/python-set-difference
Python Set Difference 基本上是对 iterable 对象执行差运算，结果包含它们之间的差。
它包含存在于集合(在其上调用操作)中而不存在于其他集合中的元素。
Python 集差维恩图
下面的文氏图提供了一个比任何文本更好的理解集合差异的方法。
Set Difference
寻找集合差异的技巧
以下是在 python 中查找多个集合之间的集合差异的技巧:
- 通过使用 set difference()方法
- 通过使用“-”运算符
- 通过使用 difference_update 方法
- 通过使用“-=”运算符
1.Python 使用 Difference()方法设置差异
difference()方法通常对诸如字符串、列表、元组等可迭代对象进行操作。
difference()方法产生一个新的集合作为输出，它包含调用该方法的特定集合中的所有项目，这些项目不存在于另一个集合中，即它创建两个集合之间的差异。
例如:
如果集合 A = {1，9，5，7}并且集合 B = {2，8，9，7}
然后，集合 A 差集合 B 将包含集合 A 中存在但集合 B 中不存在的所有元素，即结果= {1，5}。
注意:如果将 set 以外的任何 iterable 作为参数传递给 difference()方法，那么该方法首先将 iterable 对象转换为 sets，然后对其执行操作。
语法:
Set.difference(iterable_object) = Set Object
举例:
Set_A = {1, 3, 5, 7, 9}
Set_B = {2, 4, 6, 7, 9}
Result = Set_A.difference(Set_B)
print(Result);
input_list = [1, 2, 3, 4, 5, 6, 7] #list
Display = Set_A.difference(input_list)
print(Display)
输出:
{1, 3, 5}
{9}
2.在 Python 中对集合差使用“-”运算符
“-”运算符也可用于对元素执行集合差运算。它的作用与 difference()方法相同。
“-”操作符和 difference()方法之间唯一的区别是:“-”操作符只作用于集合元素，而后者作用于任何可迭代的对象。
语法:
SetA - SetB = Resultant_Set
举例:
Set_A = {1, 3, 5, 7, 9}
Set_B = {2, 4, 6, 7, 9}
Result = Set_A - Set_B
print(Result)
输出:
{1, 3, 5}
3.使用差分更新()方法
difference_update()方法还返回来自 iterable 对象(如字符串、列表、元组等)的集合元素之间的差异。
在 difference_update() 方法中，差运算的结果并不存储在新创建的集合中，而是更新对其执行运算的同一集合。
语法:
Set.difference_update(iterable_object)
举例:
Set_A = {1, 3, 5, 7, 9}
Set_B = {2, 4, 6, 7, 9}
print("Set_A before the difference operation: ", Set_A)
Set_A.difference_update(Set_B)
print("Set_A difference Set_B: ", Set_A);
输出:
Set_A before the difference operation: {9, 1, 3, 5, 7}
Set_A difference Set_B: {1, 3, 5}
4.使用“-=”运算符
“-=”运算符的工作方式类似于 difference_update 方法，即它对集合元素执行差分运算，并在执行差分运算的同一集合内更新结果。
注意:-= "运算符只对集合对象起作用。
语法:
Set_A -= Set_B
举例:
Set_A = {1, 3, 5, 7, 9}
Set_B = {2, 4, 6, 7, 9}
print("Set_A before the difference operation: ", Set_A)
Set_A -= Set_B
print("Set_A difference Set_B: ", Set_A);
输出:
Set_A before the difference operation: {9, 1, 3, 5, 7}
Set_A difference Set_B: {1, 3, 5}
结论
因此，在本文中，我们已经了解了在 Python 中寻找集合元素差异的不同方法。
参考
- Python 集合差异
- Python 集合差异文档
Python 集合交集
原文：https://www.askpython.com/python/set/python-set-intersection
Python 集合 交集基本上是寻找并返回集合间共有的元素。
语法:
set1.intersection(set2, set3, ... setN)
set1.intersection(set2)等价于 set1 ∩ set2。
参数:接受一个或多个集合作为参数。
返回值:返回一个集合作为输出，其中包含所有集合共有的元素。
在 Python 中实现集合交集的方法
以下任一方法都可用于执行 Python 集合相交:
- 利用交点()法
- 利用 Python 的【按位】&运算符
- 利用交集 _ 更新()方法
- 通过使用&=运算符
Python 使用 Intersection()方法设置交集
- intersection()方法以一个或多个 iterables 作为参数，即字符串、列表、元组等。
- 该方法比较并找出传递的 iterables 中的公共元素。
- 最后，创建一个新的集合作为输出，它包含 iterables 共有的元素。
注意: 如果集合以外的任何可迭代对象作为参数传递，那么首先将可迭代对象转换为集合对象，然后对其进行交集运算。
举例:
set1 = {10, 20, 30}
set2 = {30, 3, 9}
output = set1.intersection(set2)
print(output)
输出:
{30}
Python 使用按位“&”运算符设置交集
- Python“&”操作符也返回两个或更多集合的元素的交集。
- &操作符和交集()方法的唯一区别是&操作符只对集合对象进行操作，而交集方法可以对列表、集合等任何可迭代对象进行操作。
举例:
set1 = {"Safa", "Aman", "Pooja", "Divya"}
set2 = {"Safa", "Aryan", "Nisha", "Raghav", "Divya"}
Result = set1 & set2
print('Set 1: ',set1)
print('Set 2: ',set2)
print('Set Intersection: ',Result)
输出:
Set 1: {'Safa', 'Pooja', 'Divya', 'Aman'}
Set 2: {'Nisha', 'Aryan', 'Raghav', 'Safa', 'Divya'}
Set Intersection: {'Safa', 'Divya'}
Python 使用 intersection_update()方法设置交集
intersection_update()方法基本上是返回 iterables 之间的公共元素，并更新执行操作的同一个 set/iterable 对象。
注意: 它不会创建一个新的集合作为输出。相反，它用交集操作的结果更新相同的输入集。看下面的例子可以更好地理解
举例:
set1 = {"Safa", "Aman", "Pooja", "Divya"}
set2 = {"Safa", "Aryan", "Nisha", "Raghav", "Divya"}
print("Set1 before intersection operation: ", set1)
set1.intersection_update(set2)
print('Set Intersection of set1 and set2: ',set1)
print('Updated Set1: ',set1)
输出:
Set1 before intersection operation: {'Aman', 'Pooja', 'Divya', 'Safa'}
Set Intersection of set1 and set2: {'Divya', 'Safa'}
Updated Set1: {'Divya', 'Safa'}
Python 使用“&=”运算符设置交集
" & = "操作符也返回集合对象之间的交集。
注意:“&=”运算符只对集合对象执行和操作。它不支持任何其他可迭代对象，如列表、字符串等。
举例:
set1 = {"Safa", "Aman", "Pooja", "Divya"}
set2 = {"Safa", "Aryan", "Nisha", "Raghav", "Divya"}
print("Set1 before intersection operation: ",set1)
set1 &= set2
print('Set Intersection of set1 and set2: ',set1)
print("Updated Set1: ", set1)
输出:
Set1 before intersection operation: {'Divya', 'Safa', 'Pooja', 'Aman'}
Set Intersection of set1 and set2: {'Divya', 'Safa'}
Updated Set1: {'Divya', 'Safa'}
结论
因此，在本文中，我们用可能的方法研究并实现了 Python 集合交集。
参考
- Python 集合交集
- Python 集合文档
Python 集合并集
Union 基本上表示相应集合的所有不同元素。
Python 集合 union()方法找到集合的并集，并表示一个新集合，该集合包含来自相应输入集合的所有项目。
注: 如果一个集合包含一个出现不止一次的元素，那么所表示的输出只包含该特定元素的一次出现。
语法:
set1.union(set2, set3,......, setN)
对 Python 集合并集的基本理解
info = {'Safa', 'Aman', 'Divya', 'Elen'}
info1 = {'Safa', 'Aryan'}
print(info.union(info1))
输出:
{'Aman', 'Safa', 'Divya', 'Aryan', 'Elen'}
使用“|”运算符的 Python 集合联合
"| "操作符也可以用来寻找输入集合的并集。
info = {'Safa', 'Aman', 'Diya'}
info1 = {'Varun', 'Rashi', 54 }
print(info | info1)
输出:
{'Diya', 'Aman', 'Safa', 54, 'Varun', 'Rashi'}
多个 Python 集的并集
以下任一技术可用于寻找多个集合的并集:
- 将多个集合作为参数传递给 union()方法
- 通过创建 union()方法调用链
1.使用多个集合作为参数的多个集合的并集
info = {12, 14, 15, 17}
info1 = {35, 545}
info2 = {'Safa','Aman'}
print(info.union(info1, info2))
输出:
{'Safa', 17, 545, 35, 'Aman', 12, 14, 15}
2.通过创建 Union()方法调用链来联合多个集合
info = {12, 14, 15, 17}
info1 = {35, 545}
info2 = {'Safa','Aman'}
print(info.union(info1).union(info2))
输出:
{'Aman', 17, 545, 35, 'Safa', 12, 14, 15}
结论
因此，在本文中，我们已经理解并实现了在 Python 中寻找集合并集的方法。
参考
- Python 集合
- 设置文档
Python 集——你必须知道的事情
Python 集合是一个无序的、无索引的元素集合。
- 每个元素都是独一无二的。
- 该集合包含未排序的元素。
- 不允许重复。
- 集合本身是可变的，即可以从其中添加/删除项目(元素)。
- 与元素按顺序存储的数组不同，集合中元素的顺序没有定义。
- 集合中的元素不是按照它们在集合中出现的顺序存储的。
在 Python 中创建集合
集合可以通过将所有元素放在花括号{}内，用逗号分隔来创建。它们也可以通过使用内置函数set()来创建。
元素可以是不同的数据类型，但是集合不支持可变元素。集合是无序的，所以人们不能确定元素出现的顺序。
示例:创建集合
Days=set(["Mon","Tue","Wed","Thu","Fri","Sat","Sun"])
Fruits = {"apple", "banana", "cherry"}
Name=set('Quit')
print(Name)
print(Fruits)
print(Days)
输出:
{'u '，' Q '，' I '，' t'}
{ '樱桃'，'香蕉'，'苹果' }
推荐阅读:
从 Python 集合中访问元素
因为集合是无序的和无索引的，所以不能像数组那样通过引用索引来访问元素。
集合中的元素可以通过以下方式之一进行访问:
- 使用
for循环遍历集合项目的循环。 - 使用
in关键字检查集合中是否存在指定的值。
示例:从集合中访问元素
Fruits = {"apple", "mango", "cherry"}
for a in Fruits:
print(a)
print("banana" in Fruits)
print("mango" in Fruits)
输出:
芒果
樱桃
苹果
假
真
向 Python 集添加元素
我们可以使用add() 函数向集合中添加元素。如果我们需要添加更多的元素，我们需要使用update()方法来完成。
示例:向集合中添加元素
Fruits = {"apple", "mango", "cherry"}
Fruits.add("grapes")
print(Fruits)
Fruits.update(["banana", "orange", "strawberry"])
print(Fruits)
输出:
{ '樱桃'，'苹果'，'芒果'，'葡萄' }
从集合中删除元素
我们可以使用以下任一方法从器械包中删除物品:
- 通过使用
remove()方法 - 通过使用
discard()方法 - 通过使用
clear()方法–从集合中删除所有元素 - 通过使用
del()方法–删除整个集合
示例 1:使用 remove()方法
Fruits = {"apple", "grapes", "cherry"}
Fruits.remove("grapes")
print(Fruits)
输出:
{ '樱桃'，'苹果' }
示例 2:使用 discard()方法
Fruits = {"apple", "grapes", "cherry"}
Fruits.discard("grapes")
print(Fruits)
输出:
{ '樱桃'，'苹果' }
示例 3:使用 clear()方法
Fruits = {"apple", "grapes", "cherry"}
Fruits.clear()
print(Fruits)
输出:
集合()
示例 4:使用 del()方法
Fruits = {"apple", "grapes", "cherry"}
del Fruits
print(Fruits)
输出:
Traceback (most recent call last):
File "main.py", line 5, in <module>
print(Fruits)
NameError: name 'Fruits' is not defined
集中的方法
| 方法 | 描述 |
| 添加() | 将元素添加到集合中 |
| 清除() | 从集合中移除所有元素 |
| 复制() | 返回集合的副本 |
| 差异() | 返回包含两个或多个集合之差的集合 |
| 差异 _ 更新() | 移除此集合中也包含在另一个指定集合中的项目 |
| 丢弃() | 移除指定的项目 |
| 交集() | 返回一个集合，它是另外两个集合的交集 |
| 交集 _ 更新() | 删除此集合中不存在于其他指定集合中的项目 |
| isdisjoint() | 返回两个集合是否有交集 |
| issubset() | 返回另一个集合是否包含这个集合 |
| issuperset() | 返回这个集合是否包含另一个集合 |
| 流行() | 从集合中移除元素 |
| 移除() | 移除指定的元素 |
| 对称 _ 差异() | 返回两个集合的对称差的集合 |
| 对称 _ 差异 _ 更新() | 插入这个集合和另一个集合的对称差异 |
| 联合() | 返回包含集合并集的集合 |
| 更新() | 用这个集合和其他集合的并集更新集合 |
Python 中的集合运算
集合用于执行数学功能集合运算，如并、差、交和对称差。
集合并集–包含两个集合中的所有元素。
Union 运算通过以下任一方法执行:
- 通过使用
|运算符 - 通过使用
union()方法
示例:集合的并集
X = {1, 2, 3}
Y = {6, 7, 8}
print(X | Y)
print(Y.union(X))
输出:
{1，2，3，6，7，8}
集合交集–包含两个集合共有的元素。
相交操作通过以下任一方法执行:
- 通过使用
&运算符 - 通过使用
intersection(方法
示例:集合的交集
X = {1, 2, 3}
Y = {3, 2, 8}
print(X & Y)
print(Y.intersection(X))
输出:
{2，3}
集合差异–包含任一集合中的元素。
(A–B)包含只在集合 A 中而不在集合 B 中的元素。
(B–A)包含只在集合 B 中而不在集合 A 中的元素。
差分运算通过以下任一方法执行:
- 通过使用
-运算符 - 通过使用
difference()方法
示例:集合的差异
X = {1, 2, 3}
Y = {3, 2, 8}
print(X - Y)
print(Y.difference(X))
输出:
{1}
集合对称差–包含两个集合中的元素，但集合中的公共元素除外
对称差分运算通过以下任一方法执行:
- 通过使用
^运算符 - 通过使用
symmetric_difference()方法
示例:集合的对称差
X = {1, 2, 3, 9, 0}
Y = {3, 2, 8, 7, 5}
print(X ^ Y)
print(Y.symmetric_difference(X))
输出:
{0，1，5，7，8，9}
参考
- Python 集合
- Python 官方文档
Python setattr()函数
Python setattr()函数用于设置一个对象的属性，给定它的名字。虽然它是一个非常简单的函数，但在 Python 中的面向对象编程环境中，它被证明是非常有用的。让我们看看如何在我们的 Python 程序中使用这个函数。
setattr()函数语法
它以对象名、属性名和值为参数，设置object.attribute等于value。由于任何对象属性都可以是任何类型，因此该函数不会引发任何异常。
格式 : setattr(object, attr, value)
这里有一个简单的例子来演示setattr()的用法。
class MyClass():
def __init__(self, name, value):
# Set the attribute of the class object
setattr(self, name, value)
a = MyClass('KEY', 100)
print('Printing attribute from Class Object:', a.KEY)
print('Printing attribute from getattr():', getattr(a, 'KEY'))
输出
Printing attribute from Class Object: 100
Printing attribute from getattr(): 100
当事先不知道对象的属性，并且不能使用object.attribute_name = value设置时，setattr()非常有用。
这是一种非常方便的方法，只要对象的属性在运行时会发生变化，就可以使用这种方法，它展示了面向对象编程在这些情况下仍然表现良好。
将 setattr()与 getattrr()一起使用
它通常与getattr()方法一起使用，以获取和设置对象的属性。
这里有一个例子来展示当与getattr()方法配对时setattr()的一些用例。
此示例为单个学生构造对象，并将每个科目的属性设置为其相应的分数。
在使用setattr()构建了学生对象之后，我们使用getattr()对学生的学科分数进行排序。
class Student():
def __init__(self, name, results):
self.name = name
for key, value in results.items():
# Sets the attribute of the 'subject' to
# the corresponding subject mark.
# For example: a.'Chemistry' = 75
setattr(self, key, value)
def update_mark(self, subject, mark):
self.subject = mark
subjects = ['Physics', 'Chemistry', 'Biology']
a = Student('Amit', {key: value for (key, value) in zip(subjects, [73, 81, 90])})
b = Student('Rahul', {key: value for (key, value) in zip(subjects, [91, 89, 74])})
c = Student('Sunil', {key: value for (key, value) in zip(subjects, [59, 96, 76])})
student_list = [a, b, c]
stud_names = [student.name for student in student_list]
print('Sorted Physics Marks:')
print(sorted([getattr(s, 'Physics') for s in student_list]))
print('\nSorted Marks for all subjects:')
print(sorted([getattr(s, subject) for s in student_list for subject in subjects]))
print('\nSorted Marks for every Student:')
print(dict(zip(stud_names, [sorted([getattr(s, subject) for subject in subjects]) for s in student_list])))
虽然一些 Python 一行程序看起来非常复杂，但事实并非如此。第一个sorted([getattr(s, 'Physics') for s in student_list])相当于:
ls = []
for s in student_list:
ls.append(getattr(s, 'Physics'))
# Sort the list
ls.sort()
print(ls)
第二个 liner 也非常相似，但是使用了两个嵌套循环而不是一个。
ls = []
for s in student_list:
for subject in subjects:
ls.append(getattr(s, subject))
ls.sort()
print(ls)
最后一个有点棘手，其中您为每个学生构造了一个字典name: sorted_subject_marks。
我们首先遍历每个名称，从 student 对象列表中获取属性，然后在添加到字典之前对中间列表进行排序。
dct = {}
for name, s in zip(subjects, student_list):
ls = []
for subject in subjects:
ls.append(getattr(s, subject))
ls.sort()
dct[name] = ls
print(dct)
完整代码片段的输出:
Sorted Physics Marks:
[59, 73, 91]
Sorted Marks for all subjects:
[59, 73, 74, 76, 81, 89, 90, 91, 96]
Sorted Marks for every Student:
{'Amit': [73, 81, 90], 'Rahul': [74, 89, 91], 'Sunil': [59, 76, 96]}
结论
在本文中，我们学习了用于在运行时动态设置对象属性的setattr()方法。当开发人员不知道属性时，这是面向对象编程的一个非常有用的方法，因此用于构建灵活的 API。
参考
Python 信号模块——什么是信号以及如何创建信号？
在本文中，我们将看看如何使用 Python 信号模块。
当我们想用 Python 处理某些信号时，这个模块非常有用。
首先，我们来看看信号是什么意思。
什么是信号？
信号是程序从操作系统接收信息的一种方式。当操作系统接收到某些事件时，它可以以信号的形式传递给程序。
例如，当我们按下键盘上的按键Ctrl + C时，操作系统会产生一个信号，并将这个信号传递给程序。对于这个特定的组合，信号SIGINT被生成并传递给程序。
对于所有常见的操作系统，分配这些信号都有一个标准模式，通常是整数的简称。
在 Python 中，这些信号是在signal模块中定义的。
import signal
要查看系统中的所有有效信号(取决于操作系统)，您可以使用signal.valid_signals()
import signal
valid_signals = signal.valid_signals()
print(valid_signals)
输出
{<Signals.SIGHUP: 1>, <Signals.SIGINT: 2>, <Signals.SIGQUIT: 3>, <Signals.SIGILL: 4>, <Signals.SIGTRAP: 5>, <Signals.SIGABRT: 6>, <Signals.SIGBUS: 7>, <Signals.SIGFPE: 8>, <Signals.SIGKILL: 9>, <Signals.SIGUSR1: 10>, <Signals.SIGSEGV: 11>, <Signals.SIGUSR2: 12>, <Signals.SIGPIPE: 13>, <Signals.SIGALRM: 14>, <Signals.SIGTERM: 15>, 16, <Signals.SIGCHLD: 17>, <Signals.SIGCONT: 18>, <Signals.SIGSTOP: 19>, <Signals.SIGTSTP: 20>, <Signals.SIGTTIN: 21>, <Signals.SIGTTOU: 22>, <Signals.SIGURG: 23>, <Signals.SIGXCPU: 24>, <Signals.SIGXFSZ: 25>, <Signals.SIGVTALRM: 26>, <Signals.SIGPROF: 27>, <Signals.SIGWINCH: 28>, <Signals.SIGIO: 29>, <Signals.SIGPWR: 30>, <Signals.SIGSYS: 31>, <Signals.SIGRTMIN: 34>, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, <Signals.SIGRTMAX: 64>}
现在，对于所有的信号，都有一些默认的操作，操作系统会分配给每个程序。
如果我们想有一些其他的行为，我们可以使用信号处理器！
什么是 Python 信号处理器？
信号处理器是一个用户定义的函数，可以处理 Python 信号。
如果我们取信号SIGINT(中断信号)，默认行为将是停止当前运行的程序。
但是，我们可以指定一个信号处理器来检测这个信号，并进行我们自己的定制处理！
让我们来看看如何做到这一点。
import signal
import time
# Our signal handler
def signal_handler(signum, frame):
print("Signal Number:", signum, " Frame: ", frame)
def exit_handler(signum, frame):
print('Exiting....')
exit(0)
# Register our signal handler with `SIGINT`(CTRL + C)
signal.signal(signal.SIGINT, signal_handler)
# Register the exit handler with `SIGTSTP` (Ctrl + Z)
signal.signal(signal.SIGTSTP, exit_handler)
# While Loop
while 1:
print("Press Ctrl + C")
time.sleep(3)
这里，在我们运行程序之后，当我们按 Ctrl + C 时，程序将转到signal_handler()函数，因为我们已经用SIGINT (Ctrl + C)注册了处理程序。
我们还有另一个处理程序exit_handler()，如果我们按 Ctrl + Z，它将退出程序，并发送一个SIGTSTP信号。
让我们看看输出
输出
Press Ctrl + C
^CSignal Number: 2 Frame: <frame at 0x7fe62f033640, file 'python_signals.py', line 22, code <module>>
^ZExiting....
这里我按 Ctrl + C 转到signal_handler()功能，然后按 Ctrl + Z 退出程序。注意，还有一个 stack frame 对象(frame)，用于跟踪主程序的运行时堆栈。
使用报警信号
我们可以使用SIGALARM信号向我们的程序发送报警信号。让我们编写一个简单的信号处理程序来处理这个 Python 信号。
import signal
import time
def alarm_handler(signum, frame):
print('Alarm at:', time.ctime())
# Register the alarm signal with our handler
signal.signal(signal.SIGALRM, alarm_handler)
signal.alarm(3) # Set the alarm after 3 seconds
print('Current time:', time.ctime())
time.sleep(6) # Make a sufficient delay for the alarm to happen
在最后一行，我们休眠了足够长的时间(6 秒钟)让警报信号传递给我们的程序。否则，既然程序早就终止了，信号就收不到了！
输出
Current time: Thu Jul 23 00:41:40 2020
Alarm at: Thu Jul 23 00:41:43 2020
结论
在本文中，我们学习了如何使用signal模块设置信号处理器来处理各种信号。访问这里的链接，了解更多关于 Python 模块的信息
参考
- Python 信号模块文档
- 关于 Python 信号的 JournalDev 文章
Python slice()函数
原文：https://www.askpython.com/python/built-in-methods/python-slice-function
Python slice()函数根据传递给它的参数，从用户指定的输入索引集中返回一个切片对象。
语法:
slice(Stop)
slice(Start, Stop[, Step)
- Start :(可选)一个整数，指定开始切片过程的索引。
- Stop :一个整数，指定 slice()方法的结束索引。
- 步骤:(可选)一个整数，指定切片过程的步骤。
slice()函数返回的值:
切片的物体。
对 slice()函数的基本理解
举例:
print("Printing arguments passed to the slice().... ")
input = slice(4)
print(input.start)
print(input.stop)
print(input.step)
input = slice(1,4,6)
print(input.start)
print(input.stop)
print(input.step)
输出:
Printing arguments passed to the slice()....
None
4
None
1
4
6
带字符串的 Python slice()
Python slice()函数可以以两种不同的方式与字符串一起使用:
- 带正索引的 slice()函数
- 带负索引的 slice()函数
1.具有正索引的 slice()函数
举例:
input='Engineering'
result=input[slice(1,6)]
print(result)
输出:
ngine
2.具有负索引的 slice()函数
举例:
input='Engineering'
result=input[slice(-5,-1)]
print(result)
输出:
erin
带列表的 Python slice()
举例:
input_list = slice(1, 5)
my_list = ['Safa', 'Aman', 'Raghav', 'Raman', 'JournalDev', 'Seema']
print(my_list[input_list])
输出:
['Aman', 'Raghav', 'Raman', 'JournalDev']
带元组的 Python slice()
举例:
input_tuple = slice(1, 5)
my_tuple = ['Safa', 'Aman', 'Raghav', 'Raman', 'JournalDev', 'Seema']
print(my_tuple[input_tuple])
输出:
['Aman', 'Raghav', 'Raman', 'JournalDev']
使用 Python slice()扩展索引
一个速记方法可以用来提供 Python slice()的功能。
语法:
input[start:stop:step]
举例:
my_tuple = ['Safa', 'Aman', 'Raghav', 'Raman', 'JournalDev', 'Seema']
result = my_tuple[1:3]
print(result)
输出:
['Aman', 'Raghav']
删除 Python 切片
del 关键字可用于删除特定输入元素上应用的切片。
举例:
my_tuple = ['Safa', 'Aman', 'Raghav', 'Raman', 'JournalDev', 'Seema']
del my_tuple[:2]
print(my_tuple)
输出:
['Raghav', 'Raman', 'JournalDev', 'Seema']
结论
因此，在本文中，我们已经了解了 Python slice()函数的基本功能。
参考
- Python slice()文档
- Python slice()函数
Python slots 函数是什么？
原文：https://www.askpython.com/python/built-in-methods/python-slots
你好读者，这篇文章将帮助你了解什么是 slots，它们的优点、缺点和用法。
什么是 __ 槽 _ _？
它用在类和对象实现程序中。slots 是一个类变量，通常被赋予一系列字符串，这些字符串是实例使用的变量名。使用 slots 的主要目的是为了在程序中更快地访问和节省内存。
在 Python 中，当我们实现一个类时，一个类将有对象实例，这些对象实例将有属性，所有这些属性都被存储。
Python 默认生成 dict 属性来存储特定类中所有实例的值。它的实现非常类似于 Python 中的 dict 数据类型。
dict 有助于动态变量的创建，但在某些情况下，它无法捕捉错误。例如，如果在编写代码时，您误拼了一个变量名，而不是产生一个 AttributeError 它将创建一个新变量。诸如此类的问题在 slots 中得到解决。
此外，使用 slots 的对象实例没有内置字典。这有两个好处，第一，访问变量的速度更快，第二，节省了大量内存。它不会为该类创建 dict。
class Example_1_WithoutSlots():
def __init__(self, roll_no, name):
self.roll_no = roll_no
self.name = name
x1 = Example_1_WithoutSlots('1', 'Adam')
print(x1.__dict__)
输出:
{'roll_no': '1 '，' name': 'Adam'}
class Example_2_WithSlots():
__slots__ = ["roll_no", "name"]
def __init__(self, roll_no, name):
self.roll_no = roll_no
self.name = name
x2 = Example_2_WithSlots('1', 'Adam')
print(x2.__dict__)
输出:
Output
此外，使用 slots 的对象实例没有内置的字典，这使得访问实例更快，也节省了内存。为了测试，我们在 python 中导入了 timeit 来检查两个类中函数的速度。实现的第一个类没有类，第二个类有槽。我们可以清楚地看到两种功能的区别。
实现类和函数
Classes
输出:
Output
请注意两个函数所用时间的差异。第一个函数每循环花费 268ns，而第二个函数每循环花费 237 ns。在像这样的短程序中，差别似乎不大，但是当开发人员大规模开发一个程序时，速度是一个主要因素。
结论
Python 中的 slots 是提高程序速度和更快访问属性的非常有效的方法。它使面向对象编程变得更加容易。
Python 排序列表
Python 的 List **sort()**方法按照升序/降序/用户定义的顺序对元素进行排序。
Python 排序列表
以下是对元素进行排序的各种技术:
- 按升序排列列表
- 按降序排列列表
- 使用用户定义的顺序对列表进行排序
- 对对象列表进行排序
- 使用键对列表进行排序
1.按升序对列表元素排序
**sort()**函数用于对列表中的元素进行升序排序。
input = [1.2, 221, 0.025, 0.124, 1.2]
print(f'Before sorting of elements: {input}')
input.sort()
print(f'After sorting of elements: {input}')
输出:
Before sorting of elements: [1.2, 221, 0.025, 0.124, 1.2]
After sorting of elements: [0.025, 0.124, 1.2, 1.2, 221]
2.按降序对列表元素进行排序
**reverse**参数用于按降序对列表元素进行排序。
语法: **list**-**name.sort(reverse=True)**
input = [8, 1, 12, 0]
input.sort(reverse = True)
print(input)
输出:
[12, 8, 1, 0]
3.使用关键字函数的 Python 排序列表
Python 使用一个键函数作为参数来提供列表元素的排序。基于 key 函数的输出，列表将被排序。
# takes third element for sort
def third_element(x):
return x[2]
input = [(2, 2, 1), (3, 4, 9), (4, 1, 0), (1, 3, 7)]
# sort list with key
input.sort(key=third_element)
# prints sorted list
print('Sorted list:', input)
输出:
Sorted list: [(4, 1, 0), (2, 2, 1), (1, 3, 7), (3, 4, 9)]
4.使用用户定义的顺序对列表排序
# takes third element for sort
def third_element(x):
return x[2]
input = [(2, 2, 1), (3, 4, 9), (4, 1, 0), (1, 3, 7)]
# sorts list with key in ascending order
input.sort(key=third_element)
# prints sorted list
print('Sorted list in ascending order:', input)
# sorts list with key in descending order
input.sort(key=third_element, reverse=True)
print('Sorted list in descending order:', input)
输出:
Sorted list in ascending order: [(4, 1, 0), (2, 2, 1), (1, 3, 7), (3, 4, 9)]
Sorted list in descending order: [(3, 4, 9), (1, 3, 7), (2, 2, 1), (4, 1, 0)]
5.对对象列表进行排序
为了使用 sort()函数对自定义对象列表进行排序，我们需要指定 key 函数来指定对象的字段，以达到同样的目的。
class Details:
def __init__(self, name, num):
self.name = name
self.num = num
def __str__(self):
return f'Details[{self.name}:{self.num}]'
__repr__ = __str__
D1 = Details('Safa', 12)
D2 = Details('Aman', 1)
D3 = Details('Shalini', 45)
D4 = Details('Ruh', 30)
input_list = [D1, D2, D3, D4]
print(f'Before Sorting: {input_list}')
def sort_by_num(details):
return details.num
input_list.sort(key=sort_by_num)
print(f'After Sorting By Number: {input_list}')
输出:
Before Sorting: [Details[Safa:12], Details[Aman:1], Details[Shalini:45], Details[Ruh:30]]
After Sorting By Number: [Details[Aman:1], Details[Safa:12], Details[Ruh:30], Details[Shalini:45]]
结论
因此，我们已经了解了对列表中的元素进行排序的各种技术。
参考
- Python 排序列表
- 整理文件
使用 Python sorted()方法
原文：https://www.askpython.com/python/built-in-methods/python-sorted-method
介绍
在本教程中，我们将讨论 Python sorted()方法。
任何编程语言中的排序都是对任何可迭代对象广泛执行的操作。这种排序可以是任何顺序，比如升序或降序。Python 在进行这种类型的排序操作时提供了广泛的选项。其中之一就是sorted()法。
现在让我们进入正题，看一些例子。
了解 Python sorted()方法
Python sorted()方法按照升序或降序对传递的 iterable 进行排序(按照指定的方式)，并以列表的形式返回值(已排序)。下面给出了使用该方法的语法。
sorted(iterable, *, key=None, reverse=False)
这里，
Iterable可以是列表、元组或集合。这个 iterable 由方法排序并返回，key–默认设置为无。它确定对值进行排序所基于的参数，reverse–它接受布尔值，即真或假。如果传递的值是True，则 iterable 以逆序或降序排序。然而，对于False或默认条件，排序按升序进行。
Python 中 sorted()方法的工作原理
因此，对于作为参数传递的不同值，我们实际上可以按升序或降序对任何可迭代对象进行排序。同样在的基础上自定义或内置函数。
让我们看看如何在 Python 中使用sorted()方法。以各种方式对可迭代对象进行排序。
使用 Python sorted()按升序排序
下面的代码演示了如何使用 Python sorted()方法对任何 iterable 进行升序排序(普通排序)。
#initialisation of variables
list1= [2,7,6,24,73,23,57]
tup1= ('d','c','a','b')
print(sorted(list1)) #sorted list1
print(tuple(sorted(tup1))) #sorted list is type casted to tuple
输出:
[2, 6, 7, 23, 24, 57, 73]
('a', 'b', 'c', 'd')
这里，
- 首先，我们初始化两个可迭代的对象。一个列表，另一个 元组 ，
- 然后我们直接将它们传递给没有其他参数的
sorted()方法(默认情况下，key 是 none ，reverse 被设置为 false )， - 在打印结果时，注意我们已经对元组的情况进行了类型转换。这样做是因为 Python
sorted()方法以列表的形式返回排序的 iterable。
从上面的输出中我们可以看到，列表和元组都按照我们想要的方式进行了排序。
使用 Python sorted()进行降序排序
现在让我们看看如何使用 Python 的sorted()方法以降序或反转的方式进行排序。
#initialisation of variables
list1 = [2,7,6,24,73,23,57]
tup1 = ('d','c','a','b')
print(sorted(list1, reverse= True)) #sorted list1 in reversed order
print(tuple(sorted(tup1, reverse= True))) #reversed sorted list is type casted to tuple
输出:
[73, 57, 24, 23, 7, 6, 2]
('d', 'c', 'b', 'a')
类似于我们前面的例子，我们初始化并传递一个列表和一个元组给各自的sorted()方法。这里唯一的变化是，这次我们将该方法的反向参数设置为True。这导致结果列表和元组以相反的方式排序。
使用 sorted()中的键进行自定义排序
在本节中，我们将重点关注sorted()方法的键参数。正如我们前面看到的，我们可以将任何用户定义的或内置的函数传递给sorted()方法，作为确定基于哪些值进行排序的关键。
仔细看下面的例子，它根据对应列表项 tuple 的第三个( 3rd )元素对一个元组列表进行排序。
#initialisation of variables
list1 = [(9,8,7), (6,5,4), (3,2,1)]
def f(list):
return list[2]
print("Sorting o the basis of key function: ", sorted(list1, key=f))
输出:
Sorting o the basis of key function: [(3, 2, 1), (6, 5, 4), (9, 8, 7)]
这里，f()是一个用户自定义函数，返回传递的元组的第第 3 个元素。为sorted()方法设置key参数确保列表的排序 list1 基于每个元组元素的第 3 个元素进行。
如果键没有被传递，对于默认的 none 值，sorted()将按照 list1 中每个元组的第1元素对列表进行排序。
结论
因此，在本教程中，我们学习了使用 Python sorted()方法进行排序，以及它的各种用途。为了更好地理解，我们建议你自己练习这些代码。如有任何问题，欢迎使用下面的评论。
参考
- Python sorted()方法——日志开发帖子，
- 排序–Python 文档。
Python SQLite 模块
原文：https://www.askpython.com/python-modules/python-sqlite-module
Python SQLite 模块是一个轻量级的库，它提供了一种简单的方法来完成 SQL 类型的数据库管理的困难任务。与其他数据库系统不同，这不需要专用的服务器进程/机器。
这结合了易于使用的 SQL 类型查询进行数据库管理，但以最 Pythonic 化的方式将其用于对象的内部存储！
让我们快速浏览这个库，并为我们的应用程序创建自己的数据库！
Python SQLite
Python SQLite 随任何已安装的 Python 版本一起提供，所以不需要用pip安装。没错，你已经有了！
为了导入它，因为我们将使用 Python3 ，我们将导入sqlite3模块。
import sqlite3
现在让我们从主要的模块方法开始。
创建数据库
尽管我们提到没有外部服务器运行，所有的东西都在当前的机器中，因为这是数据库系统的标准协议，这个模块通过这样做也像一个标准协议！
我们将创建一个连接到 Python SQLite 数据库。这只为数据库分配内存，并从数据库文件中检索任何数据，因此数据库是从db文件构建的。
import sqlite3
# Establish a connection to the Database and create
# a connection object
conn = sqlite3.connect('database.db')
这里，database.db是数据库文件，数据将存储在其中。所以我们从这个文件调用数据库。
注意:如果该文件不存在，数据库会自动为您创建，并在下次使用该文件更新数据库。
如果我们已经有了这个文件，我们必须确保我们不会意外地覆盖它。因此，我们必须使用下面的函数检查该文件是否已经存在于系统中。
import os
def check_db(filename):
return os.path.exists(filename)
不过，如果您只是想要一个临时数据库，还有另一个选择，通过使用特殊文件:memory:，直接在 RAM 中构建数据库。
import sqlite3
conn = sqlite3.connect(':memory:')
上述方法的问题在于，我们需要在最后使用conn.close()显式关闭连接。Python 有一个很好的解决方案——上下文管理器。一个with语句上下文管理器将自动为您完成这项工作，因此我们修改后的代码将是:
import sqlite3
db_file = 'database.db'
with sqlite3.connect(db_file) as conn:
print('Created the connection!')
print('Automatically closed the connection!')
输出
Created the connection!
Automatically closed the connection!
创建光标对象
一旦建立了连接，我们就有了一个连接对象，从中我们可以构造一个Cursor对象。
# Create a cursor to the Database
c = conn.cursor()
这个光标是一个指向数据库的指针，用于导航数据库，以便我们可以移动到位置并执行 SQL 查询。
创建我们的数据库方案
在开始执行查询之前，我们需要首先根据记录的存储方式创建一个模式。这是一个数据库表，它是一个具有行和列的结构。
行对应于实际的数据值，而列对应于它的属性名。
让我们为存储图像创建一个简单的模式。我们将任何图像定义为具有名称、大小和图像创建日期的。实际的数据会在内存的某个地方。模式只定义了数据的组织方式。
Db Table
由于我们要像这样定义表，表的模式将如下图所示。
Image Table
我们可以使用光标，通过传递cursor.execute('SQL_QUERY')，使用 SQL 查询来执行查询。
让我们编写创建这个模式的 SQL 查询。
CREATE TABLE images(
name text primary key,
size text,
date date
);
我们可以将该查询作为字符串传递，但是如果您想要执行更长的查询，更简单的方法是创建一个.sql文件，然后使用cursor.executescript()从该文件中读取。
因此，让我们将查询放入一个名为schema.sql的文件中，并从中读取。
import sqlite3
import os
def check_db(filename):
return os.path.exists(filename)
db_file = 'database.db'
schema_file = 'schema.sql'
if check_db(db_file):
print('Database already exists. Exiting...')
exit(0)
with open(schema_file, 'r') as rf:
# Read the schema from the file
schema = rf.read()
with sqlite3.connect(db_file) as conn:
print('Created the connection!')
# Execute the SQL query to create the table
conn.executescript(schema)
print('Created the Table! Now inserting')
conn.executescript("""
insert into images (name, size, date)
values
('sample.png', 100, '2019-10-10'),
('ask_python.png', 450, '2019-05-02'),
('class_room.jpeg', 1200, '2018-04-07');
""")
print('Inserted values into the table!')
print('Closed the connection!')
输出
Created the connection!
Created the Table! Now inserting
Inserted values into the table!
Closed the connection!
从表中获取值
现在我们有了带有初始值的表，让我们查询该表以获得它的所有行。我们不能只打印光标对象，所以我们需要使用cursor.fetchall()显式地获取属性，并通过迭代打印出来。
import sqlite3
db_file = 'database.db'
with sqlite3.connect(db_file) as conn:
cursor = conn.cursor()
cursor.execute("""
select * from images
""")
for row in cursor.fetchall():
name, size, date = row
print(f'{name} {size} {date}')
输出
sample.png 100 2019-10-10
ask_python.png 450 2019-05-02
class_room.jpeg 1200 2018-04-07
SQLite 中的事务
事务管理是 SQL 数据库的特性之一，SQLite 也处理它们。事务基本上是一系列的更改，通过执行一个查询，然后放置一个commit，您可以安全地修改数据库。
如果由于某种原因，在提交之前，您不想完成事务，您可以使用rollback返回到提交之前的状态。
同样，我们也可以通过这些类型的更改来查看数据库的状态。
import sqlite3
db_filename = 'database.db'
def display_table(conn):
cursor = conn.cursor()
cursor.execute('select name, size, date from images;')
for name, size, date in cursor.fetchall():
print(name, size, date)
with sqlite3.connect(db_filename) as conn1:
print('Before changes:')
display_table(conn1)
cursor1 = conn1.cursor()
cursor1.execute("""
insert into images (name, size, date)
values ('JournalDev.png', 2000, '2020-02-20');
""")
print('\nAfter changes in conn1:')
display_table(conn1)
print('\nBefore commit:')
with sqlite3.connect(db_filename) as conn2:
display_table(conn2)
# Commit from the first connection
conn1.commit()
print('\nAfter commit:')
with sqlite3.connect(db_filename) as conn3:
display_table(conn3)
cursor1.execute("""
insert into images (name, size, date)
values ('Hello.png', 200, '2020-01-18');
""")
print('\nBefore commit:')
with sqlite3.connect(db_filename) as conn2:
display_table(conn2)
# Revert to changes before conn1's commit
conn1.rollback()
print('\nAfter connection 1 rollback:')
with sqlite3.connect(db_filename) as conn4:
display_table(conn4)
输出
Before changes:
sample.png 100 2019-10-10
ask_python.png 450 2019-05-02
class_room.jpeg 1200 2018-04-07
After changes in conn1:
sample.png 100 2019-10-10
ask_python.png 450 2019-05-02
class_room.jpeg 1200 2018-04-07
JournalDev.png 2000 2020-02-20
Before commit:
sample.png 100 2019-10-10
ask_python.png 450 2019-05-02
class_room.jpeg 1200 2018-04-07
After commit:
sample.png 100 2019-10-10
ask_python.png 450 2019-05-02
class_room.jpeg 1200 2018-04-07
JournalDev.png 2000 2020-02-20
Before commit:
sample.png 100 2019-10-10
ask_python.png 450 2019-05-02
class_room.jpeg 1200 2018-04-07
JournalDev.png 2000 2020-02-20
After connection 1 rollback:
sample.png 100 2019-10-10
ask_python.png 450 2019-05-02
class_room.jpeg 1200 2018-04-07
JournalDev.png 2000 2020-02-20
在这里，正如您所看到的，只有在我们显式完成一个事务之后，表才会被修改。在此之前的任何更改实际上都不会修改该表。
最后，我们回滚Hello.png记录，这样它就不会被插入到表中。
结论
希望这给你一个好主意，让你知道如何在sqlite3中用 Python 的易用性开发 SQL 类型的数据库系统。
参考
- Python SQLite 官方文档
- 关于 SQLite 模块的 JournalDev 文章
Python 堆栈
堆栈是一种后进先出的线性数据结构，即最后进入的元素将是第一个被移除的元素。
在堆栈中，数据项从一端加入，从同一端取出。
与堆栈相关的操作:
Push–向堆栈中添加元素Pop–从堆栈中删除/移除元素
堆栈中的推送操作
**push() method**用于向堆栈中添加元素。此方法将一个元素添加到堆栈的顶部。我们可以使用append()方法向堆栈中添加元素。
举例:
stack_store = []
print('current stack :', stack_store)
for x in range(3):
# push items into stack
stack_store.append(x)
print('current stack :', stack_store,'\tstack size :', len(stack_store))
输出:
Output-Push Method
堆栈中的弹出操作
**pop() method**用于从堆栈中移除元素。调用此方法时，从堆栈中移除最顶端的元素。
举例:
stack_store= []
print('\ncurrent stack :', stack_store)
print('\nPushing/Adding items to the stack....')
for x in range(3):
stack_store.append(x)
print('current stack :', stack_store,'\tstack size :', len(stack_store))
print('\nRemoving items from the stack....')
while len(stack_store) > 0:
stack_store.pop()
print('current stack after pop() operation :', stack_store)
输出:
Output-Pop Method
在 Python 中实现堆栈的方法
以下是在 Python 中实现堆栈的方法:
**list****collections.deque****queue.LifoQueue**
方法 1:使用列表实现堆栈
# stack using list
stack_list = ["English", "Gujarati", "Hindi"]
stack_list.append("Marathi")
stack_list.append("Kannada")
print(stack_list)
print(stack_list.pop())
print(stack_list)
print(stack_list.pop())
print(stack_list)
输出:
Output-Stack Using List
方法 2:使用 Deque 集合实现堆栈
from collections import deque
stack_store = deque()
stack_store.append('Delhi')
stack_store.append('Satara')
stack_store.append('Gujarat')
print(stack_store)
stack_store.pop()
print(stack_store)
stack_store.pop()
print(stack_store)
stack_store.pop()
print(stack_store)
输出:
Output-Deque As Stack
方法 3:使用队列实现堆栈
from queue import LifoQueue
# Initializing a stack
stack_store = LifoQueue(maxsize = 3)
print(stack_store.qsize())
stack_store.put('1')
stack_store.put('2')
stack_store.put('3')
print("Is the stack full?: ", stack_store.full())
print("The size of the stack is: ", stack_store.qsize())
print('\nItems poped/removed from the stack: ')
print(stack_store.get())
print(stack_store.get())
print(stack_store.get())
print("\nIs the stack empty?: ", stack_store.empty())
输出:
Output-Stack Using Queue
结论
因此，在本文中，我们已经了解了堆栈数据结构的机制及其基本操作，以及在编程中实现它的生动方法。
参考
- Python 堆栈
- Python 文档中的堆栈
Python 语句–多行、简单和复合示例
Python 语句是由 Python 解释器执行的代码指令。当语句出现在代码中时，Python 会逐个执行它们。
Python 语句示例
我们来看一些简单的语句例子。
count = 10 # statement 1
class Foo: # statement 2
pass # statement 3
Python 多行语句
Python 语句通常写在一行中。换行符标志着语句的结束。如果语句很长，我们可以用行继续符()显式地把它分成多行。
让我们看一些多行语句的例子。
message = "Hello There.\nYou have come to the right place to learn Python Programming.\n" \
"Follow the tutorials to become expert in Python. " \
"Don't forget to share it with your friends too."
math_result = 1 + 2 + 3 + 4 + \
5 + 6 + 7 + 8 + \
9 + 10
print(message)
print(math_result)
Python Statements
Python 支持圆括号( )、方括号[ ]和大括号{ }内的多行连续。括号由 List 使用，大括号由 dictionary 对象使用。我们可以对表达式、元组和字符串使用括号。
message = ("Hello\n"
"Hi\n"
"Namaste")
math_result = (1 + 2 + 3 + 4 +
5 + 6 + 7 + 8 +
9 + 10)
prime_numbers_tuple = (2, 3, 5, 7,
11, 13, 17)
list_fruits = ["Apple", "Banana",
"Orange", "Mango"]
dict_countries = {"USA": "United States of America", "IN": "India",
"UK": "United Kingdom", "FR": "France"}
我们可以在一行中有多个语句吗？
我们可以用分号(；)在一行中包含多个语句。
x = 1; y = 2; z = 3
Python 简单语句
Python 简单语句由一行组成。上面创建的多行语句也是简单的语句，因为它们可以写在一行中。让我们看看 Python 中一些重要类型的简单语句。
1.Python 表达式语句
i = int("10") # expression is evaluated and the result is assigned to the variable.
sum = 1 + 2 + 3 # statement contains an expression to be evaluated first.
2.Python 赋值语句
count = 10 # value is assigned to the variable, no expression is evaluated
message = "Hi"
3.Python 断言语句
assert 5 < 10
assert (True or False)
在 Python 断言阅读更多内容。
4.Python pass 语句
def foo():
pass # pass statement
阅读 Python 中 pass 语句的更多信息。
5.Python del 语句
name = "Python"
del name # del statement
6.Python 返回语句
def foo():
return 10 # return statement
推荐阅读:Python 中的 return 语句。
7.Python yield 语句
def yield_statement():
yield 'Statement 1' # yield statement
在 Python 的 yield 阅读更多。
8.Python raise 语句
def raise_example():
raise TypeError('Exception Example') # raise statement
阅读更多关于 Python 中异常处理的内容。
9.Python break 语句
numbers = [1, 2, 3]
for num in numbers:
if num > 2:
break # break statement
在 Python break 语句阅读更多内容。
10.Python continue 语句
numbers = [1, 2, 3]
for num in numbers:
if num > 2:
continue # continue statement
print(num)
延伸阅读: Python continue 语句
11.Python 导入语句
import collections
import calendar as cal
from csv import DictReader
推荐阅读:Python 中的导入。
12.Python 全局语句
name = "Python"
def global_example():
global name # global statement
name = "Flask"
print(name) # prints Python
global_example()
print(name) # prints Flask
13.Python 非局部语句
def outer_function():
scope = "local"
def inner_function():
nonlocal scope # nonlocal statement
scope = "nonlocal"
print(scope)
inner_function()
print(scope)
outer_function()
Python 复合语句
Python 复合语句包含一组其他语句，并影响它们的执行。复合语句通常跨越多行。让我们简单看几个复合语句。
1.Python if 语句
if 5 < 10:
print("This will always print")
else:
print("Unreachable Code")
推荐阅读: Python if-else 语句
2.Python for 语句
for n in (1, 2, 3):
print(n)
延伸阅读: Python for 循环
3.Python while 语句
count = 5
while count > 0:
print(count)
count -= 1
在 Python while 循环阅读更多内容。
4.Python try 语句
try:
print("try")
except ValueError as ve:
print(ve)
5.Python with 语句
with open('data.csv') as file:
file.read()
6.Python 函数定义语句
一个 python 函数定义是一个可执行语句。它的执行将当前本地名称空间中的函数名绑定到一个函数对象。该函数只有在被调用时才会被执行。
def useless():
pass
7.Python 类定义语句
这是一个可执行语句。 Python 类定义定义了类对象。
class Data:
id = 0
8.Python 协同例程函数定义语句
import asyncio
async def ping(url):
print(f'Ping Started for {url}')
await asyncio.sleep(1)
print(f'Ping Finished for {url}')
摘要
Python 解释器使用 Python 语句来运行代码。了解 Python 中不同类型的语句很有好处。
参考资料:
python 静态方法
- Python 静态方法属于这个类。
- 它们用于为类创建实用方法。
- 静态方法是从类引用调用的。
- 他们不能改变对象的状态，因为他们属于类。
- 事实上，静态方法不能访问类属性。
- 静态方法就像 Python 脚本中的一个函数，但是在类体内部。
- 我们可以从类引用或对象引用中调用静态方法。如果 foo()是类 Utils 中的静态方法，我们可以像调用
Utils().foo()一样调用Utils.foo()。
为什么我们需要 Python 静态方法？
静态方法提供了一种将实用方法分成独立子模块的方式。
假设我们有一个 Python 模块，用于字符串、列表和元组的实用方法。
为了更好地理解和使用，我们可以在单独的类中创建静态方法。
class ListUtils:
@staticmethod
def reverse(l):
pass
@staticmethod
def clear(l):
pass
class StringUtils:
@staticmethod
def reverse(l):
pass
@staticmethod
def upper(l):
pass
class TupleUtils:
@staticmethod
def reverse(t):
pass
@staticmethod
def shuffle(t):
pass
如果我们必须反转一个列表，我们将调用ListUtils.reverse()方法。如果我们必须打乱元组元素，我们将调用TupleUtils.shuffle()静态方法。
如何在 Python 中创建静态方法
Python 提供了两种创建静态方法的方法。
- staticmethod()方法
- @staticmethod 函数装饰器
1.使用 staticmethod()函数
当您想要创建在类中定义的静态方法时，staticmethod()非常有用。注意，该方法不应该有自参数。
class StringUtils:
def to_uppercase(s):
return str(s).upper()
StringUtils.upper = staticmethod(StringUtils.to_uppercase)
print(StringUtils.upper('Python')) # PYTHON
如果我们试图从 StringUtils 对象中调用 to_uppercase()方法，它将引发一个错误，即“该方法采用 1 个位置参数，但给出了 2 个”。
su = StringUtils()
try:
print(su.to_uppercase('Python'))
except TypeError as te:
print(te)
# Output
# to_uppercase() takes 1 positional argument but 2 were given
我们可以从类引用中调用 to_uppercase()方法。
print(StringUtils.to_uppercase('Python')) # PYTHON
Python Static Method
2.使用@staticmethod 批注
这是创建静态方法的推荐方式。我们只需要用@staticmethod 装饰器来注释这个方法。
class MathUtils:
@staticmethod
def multiply(a, b):
return a * b
print(MathUtils.multiply(10, 5)) # 50
这种创建静态方法的方式使用起来非常简单，可读性强，易于维护。
Python @staticmethod Decorator
Python 静态方法与类方法
- Python 类方法可以访问类变量，但静态方法不能访问类变量。
- 类方法需要第一个形参来绑定到类。静态方法可以不带任何参数。
- 我们使用@classmethod 来创建类方法。我们使用@staticmethod 来创建静态方法。
class Test:
x = 10
@classmethod
def foo(cls):
print(cls.x)
@staticmethod
def bar():
# Unresolved reference error for class variable x
# print(x)
pass
Python 静态方法与实例方法
- 类中的实例方法可以访问实例变量以及类变量。静态方法不能访问类变量或实例变量。
- 我们需要“自身变量”作为实例方法的形式参数。静态方法没有这样的限制。
- 我们使用@staticmethod decorator 创建一个静态方法。我们不需要任何装饰者来创建实例函数。
class Test:
x = 10
def func(self):
print(type(self))
print(self.x)
Python 中静态方法的好处
静态方法有利于在类边界内对实用方法进行分组。否则，它就像 python 脚本中的普通函数一样。
参考资料:
Python – stdin, stdout, and stderr
原文： https://www.askpython.com/python/python-stdin-stdout-stderr
在阅读本文之前，让我们先了解一下什么是术语stdin、stdout和stderr。
标准输入–这是一个用户程序从用户那里读取信息的文件句柄。我们给标准输入( stdin )输入。
标准输出–用户程序将正常信息写入该文件句柄。输出通过标准输出( stdout )返回。
标准错误–用户程序将错误信息写入该文件句柄。错误通过标准错误( stderr )返回。
Python 为我们提供了类文件对象，分别代表 stdin 、 stdout、和 stderr 。让我们看看如何使用这些对象来处理程序的输入和输出。
1. sys.stdin
Python 的 sys模块为我们提供了 stdin、stdout 和 stderr 这三个文件对象。对于输入文件对象，我们使用sys.stdin。这类似于一个文件，你可以打开和关闭它，就像任何其他文件一样。
让我们通过一个基本的例子来理解这一点:
import sys
stdin_fileno = sys.stdin
# Keeps reading from stdin and quits only if the word 'exit' is there
# This loop, by default does not terminate, since stdin is open
for line in stdin_fileno:
# Remove trailing newline characters using strip()
if 'exit' == line.strip():
print('Found exit. Terminating the program')
exit(0)
else:
print('Message from sys.stdin: ---> {} <---'.format(line))
输出
Hi
Message from sys.stdin: ---> Hi
<---
Hello from AskPython
Message from sys.stdin: ---> Hello from AskPython
<---
exit
Found exit. Terminating the program
上面的代码片段一直从stdin读取输入，并将消息打印到控制台(stdout)，直到遇到单词exit为止。
注意:我们通常不关闭默认的stdin文件对象，尽管它是允许的。所以stdin_fileno.close()是有效的 Python 代码。
现在我们对stdin有了一点了解，让我们转到stdout。
2. sys.stdout
对于输出文件对象，我们使用sys.stdout。它类似于sys.stdin，但是它直接将写入其中的任何内容显示到控制台。
下面的代码片段显示，如果我们向sys.stdout写入数据，就会得到控制台的输出。
import sys
stdout_fileno = sys.stdout
sample_input = ['Hi', 'Hello from AskPython', 'exit']
for ip in sample_input:
# Prints to stdout
stdout_fileno.write(ip + '\n')
输出
Hi
Hello from AskPython
exit
3. sys.stderr
这与sys.stdout类似，因为它也直接打印到控制台。但不同的是，它只打印异常和错误信息。(这就是为什么它被称为标准误差)。
让我们举个例子来说明这一点。
import sys
stdout_fileno = sys.stdout
stderr_fileno = sys.stderr
sample_input = ['Hi', 'Hello from AskPython', 'exit']
for ip in sample_input:
# Prints to stdout
stdout_fileno.write(ip + '\n')
# Tries to add an Integer with string. Raises an exception
try:
ip = ip + 100
# Catch all exceptions
except:
stderr_fileno.write('Exception Occurred!\n')
输出
Hi
Exception Occurred!
Hello from AskPython
Exception Occurred!
exit
Exception Occurred!
正如您所观察到的，对于所有的输入字符串，我们试图添加一个整数，这将引发一个异常。我们捕捉所有这样的异常，并使用sys.stderr打印另一个调试消息。
重定向到文件
我们可以将stdin、stdout和stderr文件句柄重定向到任何其他文件(文件句柄)。如果您想在不使用任何其他模块(如日志记录)的情况下将事件记录到文件中，这可能很有用。
下面的代码片段将输出(stdout)重定向到一个名为Output.txt的文件。
因此，我们不会看到任何打印到控制台的内容，因为它现在被打印到文件本身！这就是输出重定向的本质。您将输出“重定向”到其他地方。(这一次，改为Output.txt，而不是控制台)
import sys
# Save the current stdout so that we can revert sys.stdou after we complete
# our redirection
stdout_fileno = sys.stdout
sample_input = ['Hi', 'Hello from AskPython', 'exit']
# Redirect sys.stdout to the file
sys.stdout = open('Output.txt', 'w')
for ip in sample_input:
# Prints to the redirected stdout (Output.txt)
sys.stdout.write(ip + '\n')
# Prints to the actual saved stdout handler
stdout_fileno.write(ip + '\n')
# Close the file
sys.stdout.close()
# Restore sys.stdout to our old saved file handler
sys.stdout = stdout_fileno
输出
[email protected]:~# python3 output_redirection.py
Hi
Hello from AskPython
exit
[email protected]:~# cat Output.txt
Hi
Hello from AskPython
exit
如您所见，我们已经将输出打印到控制台和Output.txt。
我们首先将原始的sys.stdout文件处理程序对象保存到另一个变量中。我们不仅需要这个来将sys.stdout恢复到旧的处理程序(指向控制台)，而且我们还可以使用这个变量打印到控制台！
注意，在写入文件之后，我们关闭它，类似于我们关闭一个文件，因为该文件仍然是打开的。
我们最后使用变量stdout_fileno将sys.stdout的处理程序恢复到控制台。
对于输入和错误重定向，可以遵循类似的过程，用sys.stdin或sys.stderr代替sys.stdout，并处理输入和异常而不是输出。
结论
在本文中，我们通过使用sys模块，学习了如何在 Python 中使用stdin、stdout和stderr。我们还学习了如何操作相应的文件处理程序来重定向到文件或从文件重定向。
参考
- 关于从 stdin 读取输入的 JournalDev 文章
- 关于标准输入、标准输出和标准错误的堆栈溢出问题
Python str()函数
原文：https://www.askpython.com/python/built-in-methods/python-str-function
Python str()函数是内置函数之一。这个函数返回对象的字符串表示。如果没有提供参数，它将返回一个空字符串。
Python str()函数示例
让我们看一些 str()函数的简单例子。
>>> str("AskPython")
'AskPython'
>>> str(10)
'10'
>>> str(None)
'None'
>>> str()
''
>>>
如何为一个对象实现 str()函数
当我们用对象参数调用 str()函数时，它调用对象的 str()函数。所以，我们可以为对象实现 str()函数，它应该返回一个字符串。
首先，让我们看看当我们没有为一个对象实现 str()函数时会发生什么。
class Emp:
id = 0
name = ''
def __init__(self, i, n):
self.id = i
self.name = n
d1 = Emp(10, 'Pankaj')
print(str(d1))
当我们运行上面的代码时，它会打印:
<主。位于 0x104e72ee0 的 Emp 对象>
这是什么？
当 str()函数未实现时，str()函数回退到 repr()函数。object 类提供 repr()函数实现，返回对象的内存地址。
这个输出对我们没有帮助，因为作为开发人员，没有关于对象的有用信息。让我们实现 str()函数。
def __str__(self):
return f'Emp::ID={self.id}, Name={self.name}'
输出:
Python Str Function
摘要
- python str()函数是内置函数之一。
- str()函数在内部调用 str()函数，如果不调用，则返回 repr()函数。
- 如果没有提供参数，str()函数将返回一个空字符串。
- 我们可以使用 str()函数将对象转换为字符串。当你想把数字转换成字符串等的时候很有用。
- 为数据对象实现 str()函数是一个好主意，它有助于轻松获得关于对象的有用信息。
下一步是什么？
资源
Python strftime()函数是什么？
嘿，伙计们！在本文中，我们将了解 Python strftime()函数及其变体的工作原理。
那么，让我们开始吧。
Python 有各种各样的模块，这些模块有函数集群来实现数据的各种功能。Python 时间模块用于执行关于不同时间戳的操作。
此外，Python strftime() function接受各种形式的时间，并返回一个以标准形式表示时间的字符串。
变体 1: Python strftime()获取当前时间
Python strftime()函数可以与 datetime 模块一起使用，根据格式代码以适当的形式获取当前时间戳。
语法:
datetime.now().strftime('format codes')
因此，格式代码实际上是预定义的代码，用于以适当和标准的方式表示时间戳。在本文中，我们将进一步了解格式代码。
举例:
from datetime import datetime
current_timestamp = datetime.now()
tym = current_timestamp.strftime("%H:%M:%S")
date = current_timestamp.strftime("%d-%m-%Y")
print("Current Time:",tym)
print("Current Date:",date)
在上面的例子中，我们使用了datetime.now() method来获取当前的时间戳，然后将其传递给 strftime()函数，以标准格式表示时间戳。
我们使用的格式代码具有如下含义:
%H–以 24 小时制表示“小时”。%M–用十进制数字表示“分钟”。%S–代表时间戳的“秒部分。
输出:
Current Time: 16:28:40
Current Date: 28-04-2020
变体 2:带有预定义时间戳的 Python strftime()
有时会发生这种情况，我们需要显示历史数据集的时间戳。使用 Python strftime()函数也可以执行同样的操作。
datetime.fromtimestamp()方法用于获取预定义的时间戳。此外，strftime()函数可用于使用各种格式代码以标准形式表示它，如上所述。
语法:
datetime.fromtimestamp(timestamp).strftime()
举例:
from datetime import datetime
given_timestamp = 124579923
timestamp = datetime.fromtimestamp(given_timestamp)
tym = timestamp.strftime("%H:%M:%S")
date = timestamp.strftime("%d-%m-%Y")
print("Time according to the given timestamp:",tym)
print("Date according to the given timestamp:",date)
输出:
Time according to the given timestamp: 03:02:03
Date according to the given timestamp: 13-12-1973
对 Python strftime()函数使用不同的格式代码
Python strftime()函数使用格式代码以标准且可维护的格式表示时间戳。此外，我们可以使用格式代码将日、小时、周等从时间戳中分离出来并显示出来。
让我们借助一些例子来理解格式代码。
例 1: 格式代码—“%A显示当地时间的当前日期。
from time import strftime
day = strftime("%A")
print("Current day:", day)
输出:
Current day: Tuesday
例 2: 格式代码— '%c '显示当前本地时间。
格式代码–“% c”用于显示当前本地时间，遵循以下格式:
日月日时:分:秒年
from time import strftime
day = strftime("%c")
print("Current timestamp:", day)
输出:
Current timestamp: Tue Apr 28 16:42:22 2020
例 3: 格式码—“% R”以 24 小时制表示时间。
from time import strftime
day = strftime("%R")
print("Current time in a 24-hour format:", day)
输出:
Current time in a 24-hour format: 16:44
示例 4 :格式代码— '%r '以 H:M:S 格式显示时间以及描述，即 AM 或 PM。
from time import strftime
day = strftime("%r")
print("Current time -- hours:mins:seconds", day)
输出:
Current time -- hours:mins:seconds 05:05:19 PM
例 5:
from time import strftime
day = strftime("%x -- %X %p")
print("Local date and time:", day)
在上面的例子中，我们使用格式代码“%x”以日期表示本地时间戳，使用“%X”以 H:M:S 的形式表示本地时间。使用“%p”格式代码来表示时间戳是属于 AM 还是 PM。
输出:
Local date and time: 04/28/20 -- 17:08:42 PM
结论
因此，在本文中，我们已经理解了 Python strftime()函数的工作原理以及所使用的格式代码。
为了了解可用格式代码的列表，请找到参考资料中的链接以访问官方文档。
参考
- Python strftime()格式代码
- Python strftime()函数— JournalDev
Python 字符串到字节，字节到字符串
原文：https://www.askpython.com/python/string/python-string-bytes-conversion
在本文中，我们将了解一下 Python 字符串到字节以及 Python 字节到字符串的转换。类型的 Python 转换已经获得了相当大的重要性，因为它的数据特征是在各种操作中以不同的形式被使用。
字符串到字节和字节到字符串的 Python 转换有其自身的重要性，因为它在文件处理等时是必需的。
Python 字符串到字节
以下任一方法都可用于将 Python 字符串转换为字节:
- 使用
bytes()方法 - 使用
encode()方法
1.使用 bytes()方法将 Python 字符串转换为字节
Python 的 CPython 库为我们提供了bytes()函数将字符串转换成字节。
语法:
bytes(input_string, 'utf-8')
注:UTF-8格式用于编码目的。
举例:
inp = "Engineering Discipline"
print("Input String:\n")
print(str(inp))
opt = bytes(inp, 'utf-8')
print("String after getting converted to bytes:\n")
print(str(opt))
print(str(type(opt)))
输出:
Input String:
Engineering Discipline
String after getting converted to bytes:
b'Engineering Discipline'
<class 'bytes'>
2.使用 encode()方法将 Python 字符串转换为字节
Python 的 encode() 方法也可以用来将字符串转换成字节格式。
语法:
input_string.encode('utf-8')
举例:
inp = "Engineering Discipline"
print("Input String:\n")
print(str(inp))
opt = inp.encode('utf-8')
print("String after getting converted to bytes:\n")
print(str(opt))
print(str(type(opt)))
输出:
Input String:
Engineering Discipline
String after getting converted to bytes:
b'Engineering Discipline'
<class 'bytes'>
Python 字节到字符串
Python 的字节类内置了 decode() 方法将 Python 字节转换成字符串。
语法:
string.decode('utf-8')
举例:
inp = "Engineering Discipline"
print("Input String:\n")
print(str(inp))
opt = inp.encode('utf-8')
print("String after getting converted to bytes:\n")
print(str(opt))
print(str(type(opt)))
original = opt.decode('utf-8')
print("The decoded String i.e. byte to converted string:\n")
print(str(original))
在上面的例子中，我们已经使用 encode()方法将输入字符串转换为字节。之后，decode()方法将编码后的输入转换为原始字符串。
输出:
Input String:
Engineering Discipline
String after getting converted to bytes:
b'Engineering Discipline'
<class 'bytes'>
The decoded String i.e. byte to converted string:
Engineering Discipline
熊猫字节到字符串
熊猫模块 获得了 Series.str.decode() 的方法将编码数据即字节格式的数据转换为字符串格式。
语法:
input_string.decode(encoding = 'UTF-8')
举例:
import pandas
inp = pandas.Series([b"b'Jim'", b"b'Jonny'", b"b'Shawn'"])
print("Encoded String:")
print(inp)
opt = inp.str.decode(encoding = 'UTF-8')
print("\n")
print("Decoded String:")
print(opt)
在上面的例子中，我们假设数据是编码格式的。此外，对数据执行操作。
输出:
Encoded String:
0 b"b'Jim'"
1 b"b'Jonny'"
2 b"b'Shawn'"
dtype: object
Decoded String:
0 b'Jim'
1 b'Jonny'
2 b'Shawn'
dtype: object
结论
在本文中，我们已经理解了 Python 字符串到字节的转换，反之亦然，这也思考了编码和解码的概念。
参考
Python 字符串到字节，字节到字符串–journal dev
Python 字符串大写()函数
原文：https://www.askpython.com/python/string/python-string-capitalize-function
Python 中的 String 有内置的函数，可以对字符串执行几乎所有的操作。Python 的 String capitalize()函数用于只将第一个字符转换成大写字母，其余所有字符都是小写的。
要点:
- 返回类型:字符串
- 参数值:没有参数可以解析到 capitalize()函数上。
- 仅将字符串的第一个字符转换为大写。
- 它不会修改原始字符串。修改后的字符串以新的变量名保存。
示例:给定字符串-“祝您愉快”或“祝您愉快”或“祝您愉快”或“祝您愉快”
大写的字符串:“祝你有美好的一天”(适用于上述所有字符串)
语法:
str_name.capitalize()
这里的 str_name 指的是要大写的字符串。并且，capitalize()是 python 中内置的字符串函数。
基本示例
str_name = "hi there!"
new_str = str_name.capitalize()
print('The New Capitalized String is ',new_str)
输出:你好！
不同情况:
不同情况的示例如下
情况 1:字符串中的所有字符都是大写的
str_name = "HI THERE"
new_str = str_name.capitalize()
print('The New Capitalized String is ',new_str)
输出:你好！
情况 2:包含多个单词的字符串中每个单词的第一个字母都是大写的
str_name = "Hi There!"
new_str = str_name.capitalize()
print('The New Capitalized String is ',new_str)
输出:你好！
情况 3:字符串中的任意字符都是大写的
str_name = "hI tHeRE!"
new_str = str_name.capitalize()
print('The New Capitalized String is ',new_str)
输出:你好！
情况 4:非字母数字或数字的第一个字符
str_name = "! hi there"
new_str = str_name.capitalize()
print('The New Capitalized String is ',new_str)
输出:！你好。
参考
Python 字符串 casefold()
原文：https://www.askpython.com/python/string/python-string-casefold
Python String casefold()方法返回一个大小写折叠的字符串，我们用它来删除字符串中所有的大小写区别。
让我们看看这意味着什么。
使用 Python 字符串 casefold()方法
这属于String类，只能用于字符串对象。
此方法的语法是:
string_obj.casefold()
这将在应用所有大小写折叠后返回一个新字符串。
例如，它会将所有大写字母转换成小写字母。
my_str = "Hello from AskPython"
casefolded_str = my_str.casefold()
print(casefolded_str)
输出
hello from askpython
这会将英文字母表中的所有大写字母转换为小写字母。
但是，如果字符串包含另一种语言的字符，并且采用另一种编码，该怎么办呢？Python string casefold()方法解决了这个问题。
以德语小写字母'ß'为例。这对应于英语字符串“ss”，因为有一个德语字母的编码，我们将其解码为英语字符串。
如果我们在这个字母表上使用lower()方法，它什么都不会做，因为这个字母已经是小写的了，所以输出仍然是“ß”。Python string casefold()不仅转换成小写，还确保我们得到我们的英文字符串“ss”。
下面的截图显示了这种差异。
German String Casefold
让我们再举一个例子，说明字符串'ß'和“ss”将解析为相同的大小写折叠字符串“SS”。
s1 = 'ß'
s2 = 'ss'
s3 = 'SS'
if s1.casefold() == s2.casefold():
print('Casefolded strings of s1 and s2 are equal')
else:
print('Casefolded strings of s1 and s2 are not equal')
if s1.casefold() == s3.casefold():
print('Casefolded strings of s1 and s3 are equal')
输出
Casefolded strings of s1 and s2 are equal
Casefolded strings of s1 and s3 are equal
事实上，这两个字符串都解析为同一个 casefolded 字符串！
结论
在本文中，我们学习了如何在 Python 中使用 Python string casefold()方法。
参考
- 皮套上的官方文件()
- String casefold()上的 JournalDev 文章
Python 字符串包含()
原文：https://www.askpython.com/python/string/python-string-contains
在本文中，我们将看看一个 Python 字符串是否包含另一个字符串。
怎么才能轻松做到？Python 有一个内置的字符串方法 String。__ 包含 __() ，我们可以轻松使用。
让我们看看如何使用这种方法。
字符串的语法。__ 包含 _ _()
该函数将接受两个字符串，如果一个字符串属于另一个字符串，则返回。因此这个方法的返回类型是一个布尔值，所以它将返回一个真，或者一个假。
至于我们如何调用这个方法，我们在一个 string 对象上使用它，检查这个 string 对象中是否有另一个字符串。
ret = str_object.contains(another_string)
这将检查str_object是否包含字符串another_string，返回值被存储到ret。
现在让我们看一些例子来说明这一点。
使用字符串。__ 包含 _ _()
我们将检查一个 Python 字符串是否包含另一个字符串。
my_str = "Hello from AskPython"
target = "AskPython"
if (my_str.__contains__(target)):
print("String contains target!")
else:
print("String does not contain target")
输出
String contains target
由于“AskPython”是原字符串的子串，“Hello from AskPython”，所以返回值为True。
这个方法是区分大小写的，所以字符串“askpython”将而不是得到匹配。
my_str = "Hello from AskPython"
target = "askpython"
if (my_str.__contains__(target)):
print("String contains target!")
else:
print("String does not contain target")
输出
String does not contain target
使用 Python String contains()作为类方法
我们也可以将它用作str类的类方法，并使用两个参数而不是一个。
ret = str.__contains__(str1, str2)
这类似于我们之前的用法，但是我们调用它作为 String 类的类方法。这将返回True是str1包含str2，否则为False。
>>> print(str.__contains__("Hello from AskPython", "AskPython")
True
结论
在本文中，我们学习了如何使用字符串。contains() 方法检查一个 Python 字符串是否包含另一个字符串。
参考
- 关于 Python 字符串的 JournalDev 文章包含()方法
Python 字符串 endswith()函数
原文：https://www.askpython.com/python/string/python-string-endswith-function
如果输入字符串以特定后缀结尾，Python string **endswith()**函数返回 True，否则返回 False。
要点:
- 返回类型:布尔型，即真或假
- 参数值:有 3 个参数:后缀，开始，结束
| 参数 | 描述 |
| 后缀 | 它可以是要检查的字符串或字符串元组。它区分大小写 |
| 开始 | 它是可选的，用于指定开始检查的起始索引 |
| 结束 | 它是可选的，用于指定检查结束的结束索引 |
Python 字符串 endswith()语法
**string.endswith(suffix[, start[, end]])**
String endswith()示例
例 1:
str= 'Engineering Discipline'
print(str.endswith('Discipline')) # True
示例 2: 提供偏移
str = 'Engineering is an interesting discipline'
print(str.endswith('discipline', 2)) # True
print(str.endswith('Engineering', 10)) # False
示例 3: 使用 len()函数和 endswith()函数
str = 'Engineering is an interesting discipline'
print(str.endswith('discipline', 11, len(str))) # True
print(str.endswith('Engineering', 0, 11)) # True
print(str.endswith('Python', 8)) # False
例 4:
str = 'C++ Java Python'
print(str.endswith(('Perl', 'Python'))) # True
print(str.endswith(('Java', 'Python'), 3, 8)) # True
结论
Python String endswith()函数是一个实用程序，用于检查字符串是否以给定的后缀结尾。
参考
- Python endswith()函数
- Python 字符串文档
了解 Python 字符串 expandtabs()函数
原文：https://www.askpython.com/python/string/python-string-expandtabs
Python 有一种有效的方法来处理字符串之间的空白。让我们在本文中了解一下 Python String expandtabs()方法。
Python 字符串 expandtabs()方法的工作原理
如上所述，Python String 内置了 expandtabs()方法来处理字符串之间的空格。
Python String expandtabs()函数基本上用用户提供的空格数量作为参数来替换和扩展字符串之间的' \t '字符。
语法:
string.expandtabs(size)
size(optional):该参数指定了字符串之间用户需要的空间大小。默认大小为 8。
例 1:
inp_str = "JournalDev\tprovides\ttutorials\ton\tPython\tand\tJava."
#print(inp_str)
res = inp_str.expandtabs()
print(res)
在上面的例子中，Python 字符串 expandtabs()函数的使用不带任何参数，即大小。因此' \t '被替换为默认尺寸，即 8 。
输出:
JournalDev provides tutorials on Python and Java.
例 2:
inp_str = "JournalDev\tprovides\ttutorials\ton\tPython\tand\tJava."
print("Original string:\n",inp_str)
res = inp_str.expandtabs(4)
print("String after using expandtabs:\n",res)
在上面的代码片段中，size = 4 作为参数传递给 Python 字符串 expandtabs()函数。因此，整个字符串中的' \t '字符被大小为 4 个单位的空格替换。
输出:
Original string:
JournalDev provides tutorials on Python and Java.
String after using expandtabs:
JournalDev provides tutorials on Python and Java.
例 3:
inp_str = "JournalDev\tprovides\ttutorials\ton\tPython\tand\tJava."
print("Original string:\n",inp_str)
res = inp_str.expandtabs(18)
print("String after using expandtabs:\n",res)
输出:
Original string:
JournalDev provides tutorials on Python and Java.
String after using expandtabs:
JournalDev provides tutorials on Python and Java.
python expand tabs()–错误和异常
如果我们试图将非整数类型的值(比如浮点值)作为参数传递给 Python string expandtabs()函数，它会引发一个TypeError exception。
因此，我们可以理解 expandtabs()函数只接受整型值作为参数。
举例:
inp_str = "JournalDev\tprovides\ttutorials\ton\tPython\tand\tJava."
res = inp_str.expandtabs(18.17)
print("String after using expandtabs:\n",res)
输出:
TypeError Traceback (most recent call last)
<ipython-input-15-f2418be436bf> in <module>
1 inp_str = "JournalDev\tprovides\ttutorials\ton\tPython\tand\tJava."
----> 2 res = inp_str.expandtabs(18.17)
3 print("String after using expandtabs:\n",res)
TypeError: integer argument expected, got float
Python numpy.expandtabs()函数
Python Numpy 模块具有 numpy.char.expandtabs()函数，该函数提供与内置 expandtabs()函数相同的功能。
numpy.char.expandtabs()函数接受一个数组作为参数和空格的大小，以防用户希望更具体。
语法:
numpy.char.expandtabs(array,size)
array:包含函数必须执行的元素。size(可选):可选参数，指定通过替换制表符提供的空格大小，即' \t '。
例 1:
import numpy
inp_arr = numpy.array("JournalDev\tprovides\ttutorials\ton\tPython\tand\tJava.")
res = numpy.char.expandtabs(inp_arr)
print("String after using expandtabs:\n",res)
输出:
Array of string after using expandtabs:
JournalDev provides tutorials on Python and Java.
例 2:
import numpy
inp_arr = numpy.array("JournalDev\tprovides\ttutorials\ton\tPython\tand\tJava.")
res = numpy.char.expandtabs(inp_arr,20)
print("Array of string after using expandtabs:\n",res)
输出:
Array of string after using expandtabs:
JournalDev provides tutorials on Python and Java.
摘要
- Python 字符串 expandtabs()函数用于处理在运行时在字符串之间提供空格。它用提到的空间量替换' \t '字符，默认大小是 8。
- 替换' \t '的大小应该是一个整型值。
- 如果一个非整数类型的值被传递给函数，它会引发一个 TypeError 异常。
- 因此，expandtabs()被证明是一种在运行时处理添加空格的有效技术。
结论
因此，在本文中，我们已经了解了 Python string expandtabs()函数与 Python 字符串和 NumPy 数组的工作原理。
参考
- Python 扩展表— JournalDev
Python 字符串查找()
原文：https://www.askpython.com/python/string/python-string-find
Python string find() 方法用于检查一个字符串是否是另一个字符串的子字符串。
通常，当我们想要检查一个字符串是否包含另一个字符串时，find()对于解决这个问题非常有用。
让我们通过一些简单的例子来理解如何使用它。
Python 字符串 Find()的语法
格式:
ret = str.find(sub, start, end)
这里， find() 在一个字符串对象str上被调用并返回一个整数。这将检查子串sub是否位于可选参数start和end之间。
注:含start，end为不含。
find()不接受关键字参数，所以你必须只提到位置参数。
如果位置之间不存在子串，那么ret就是-1。否则，它是子串的第一个匹配在输入字符串上的位置。
让我们看一个简单的例子。
test_string = "Hello from AskPython"
# We will check if the substring
# 'AskPython' exists in test_string
print(test_string.find('AskPython', 0, len(test_string)) )
输出 : 11
由于子串存在，所以返回子串第一个字符的位置(' AskPython '中的' A ')，即 11。
我们也可以使用负索引来表示从字符串末尾的偏移量。举个例子，
test_string = "Hello from AskPython"
# Will search from the first to the
# second last position
print(test_string.find('AskPython', 0, -1))
# Will search from index 5 to len(str) - 1
print(test_string.find('from', 5, -1))
输出
-1
6
对于第一个实例，输出是负的，因为 find()方法不能完全匹配字符串“AskPython”。
原因是因为-1，find 字符串只搜索到askphyto，这意味着我们要搜索的东西并没有真正找到。
使用不带开始/结束参数的 Python 字符串 find()
如果我们希望搜索整个字符串，我们可以将start和end参数留空。这是许多程序员使用 Python string find()最广泛的方式。
我们可以将前面的例子改写为:
test_string = "Hello from AskPython"
print(test_string.find('AskPython'))
这将给出与以前相同的输出。
使用只带有开始参数的 find()
我们只能通过省略end参数来指定起始位置，直到字符串结束。
test_string = "Hello from AskPython"
# Will print 11
print(test_string.find('AskPython', 0))
# Will print -1, as the search starts
# from position 12, i.e from 'k'
print(test_string.find('AskPython', 12))
输出
11
-1
结论
在本文中，我们学习了搜索子字符串的str.find()方法。
参考
- 【String.find()的 Python 文档
Python 字符串到浮点，浮点到字符串
原文：https://www.askpython.com/python/string/python-string-float-conversion
在本文中，我们将处理 Python 字符串到 float 的转换，反之亦然。在日常编程实践中，很多时候我们会遇到这样的场景，我们觉得需要转换我们正在处理的数据类型。
要浮动的 Python 字符串
Python 为我们提供了内置的 float() 方法，将输入的数据类型从 String 转换为 float。
语法:
float(input_string)
举例:
inp = '99.23'
print("Input string:\n",inp)
opt = float(inp)
print('Input value after converting it to float type:\n',opt)
print(type(opt))
输出:
Input string:
99.23
Input value after converting it to float type:
99.23
<class 'float'>
要浮动的 Python NumPy 字符串
NumPy 模块 已经得到了astype()方法来转换数据的类型。
astype()方法将输入数据的类型转换为参数中指定的数据类型。
语法:
input_string.astype(numpy.float)
举例:
import numpy
inp = numpy.array(["76.5", "75.5", "75.7"])
print ("Input array:\n")
print(str(inp))
opt = inp.astype(numpy.float)
print ("Output array after conversion:\n")
print(str(opt))
输出:
Input array:
['76.5' '75.5' '75.7']
Output array after conversion:
[ 76.5 75.5 75.7]
熊猫串起来飘
熊猫模块 也使用astype()函数将数据集特定字段的数据类型转换为指定的类型。
语法:
input.astype(float)
输入 csv 文件:
Input File
举例:
import pandas
import numpy
inp = pandas.read_csv('C:\\Users\\HP\\Desktop\\Book1.csv')
print(inp.dtypes)
inp['Value'] = inp['Value'].astype(float)
print(inp)
print(inp.dtypes)
输出:
Details object
Value float64
dtype: object
Details Value
0 John:Pune 21.00
1 Bran:satara 22.00
2 Sam:Chennai 85.24
3 RHEY:Delhi 12.00
4 CRANNY:Karnatak 25.26
Details object
Value float64
dtype: object
Python 浮点到字符串
Python String 内置了str()方法，可以将任意类型的输入数据转换成字符串形式。
语法:
str(input)
举例:
inp = 77.77
print(inp)
print(type(inp))
opt = str(inp)
print(opt)
print(type(opt))
输出:
77.77
<class 'float'>
77.77
<class 'str'>
Python NumPy 浮点到字符串
List Comprehension 可以用来将 Python NumPy float 数组转换成 String 元素的数组。
语法:
["%.2f" % i for i in input_array]
举例:
import numpy
inp = numpy.array([77.75, 77.25, 77.55])
print("Input array:\n",inp)
opt =["%.2f" % i for i in inp]
print("Converted array to string:\n")
print(opt)
在上面的代码片段中，“ %.2f ”将在输出数组中给我精确到两位小数。
输出:
Input array:
[77.75 77.25 77.55]
Converted array to string:
['77.75', '77.25', '77.55']
结论
在本文中，我们已经理解了使用 Python 数据结构将数据从字符串形式转换为浮点形式，反之亦然。
参考
- Python 字符串浮动
- 【NumPy 字符串到浮点
使用 Python 字符串 format_map()
原文：https://www.askpython.com/python/string/python-string-format-map
在本文中，我们将了解一下 Python 字符串 format_map() 方法。
该方法使用基于映射的替换返回字符串的格式化版本，使用花括号{}。
让我们用几个例子来正确理解这一点。
Python 字符串格式 _map()基础知识
Python 字符串 format_map()函数从 Python 3.2 开始可用，因此请确保您使用的是 Python 的更新版本，而不是旧版本。
该字符串方法的基本语法如下:
substituted_string = str.format_map(mapping)
在这里，mapping可以是任何映射，就像字典一样。映射可以被看作是{ key : value }的形式。
Python String format_map() 方法用value替换字符串中的所有keys。
这将返回一个新的字符串，包括所有替换(如果适用)。
为了更好地理解这一点，考虑下面的映射字典:
dict_map = {"prog_lang": "Python", "site": "AskPython"}
现在，考虑一个格式字符串，在格式替换(花括号)下有字典的键。
fmt_string = "Hello from {site}. {site} is a site where you can learn {prog_lang}"
现在，我们可以用“AskPython”替换所有出现的{site}，用format_map()替换所有出现的{prog_lang}。
print(fmt_string.format_map(dict_map))
输出
Hello from AskPython. AskPython is a site where you can learn Python
通过所有替换，我们得到了我们想要的输出！
现在，如果我们有一个在映射字典中不存在的额外格式会怎么样呢？
dict_map = {"prog_lang": "Python", "site": "AskPython"}
fmt_string = "Hello from {site}. {site} is a site where you can learn {prog_lang}. What about {other_lang}?"
print(fmt_string.format_map(dict_map))
输出
Traceback (most recent call last):
File "<pyshell#6>", line 1, in <module>
print(fmt_string.format_map(dict_map))
KeyError: 'other_lang'
我们得到一个KeyError异常。由于{other_lang}不属于映射字典，查找将失败！
Python 字符串 format_map()与 format()的比较
您可能还记得， format() 方法也非常类似，通过对格式字符串进行适当的替换。
差异可总结如下:
- format()方法通过首先创建映射字典，然后执行替换，间接地使用该方法的参数执行替换。
- 在 Python 字符串 format_map()的情况下，替换是使用映射字典直接完成的。
- 由于 format_map() 也不做新字典，所以比 format()略快。
- format_map() 也可以使用 dictionary 子类进行映射，而 format()则不能。
为了说明最后一点，让我们创建一个类，它是dict的子类。
我们将尝试上述两种方法，并尝试使用__missing__() dunder 方法处理任何丢失的键。
class MyClass(dict):
def __missing__(self, key):
return "#NOT_FOUND#"
fmt_string = "Hello from {site}. {site} is a site where you can learn {prog_lang}."
my_dict = MyClass(site="AskPython")
print(fmt_string.format_map(my_dict))
输出
Hello from AskPython. AskPython is a site where you can learn #NOT_FOUND#.
这里发生了什么事？因为我们只在映射字典中添加了{site: AskPython}，所以缺少了{prog_lang}键。
因此，__missing__()方法返回“ #NOT_FOUND# ”。
如果我们使用 format()？
fmt_string.format(my_dict)
输出
Traceback (most recent call last):
File "<pyshell#14>", line 1, in <module>
fmt_string.format(my_dict)
KeyError: 'site'
嗯，format()没有为我们处理这个问题，它只是引发了一个KeyError异常。这是因为它将映射复制到一个新的 dictionary 对象。
因为映射是在一个新的 dictionary 对象上(没有使用我们的子类)，所以它没有 missing 方法！因此，它只能给出一个键错误！
结论
在本文中，我们学习了如何使用 Python String format_map()方法对格式字符串执行替换。我们还看到了与 format() 方法的快速比较。
参考
- String format_map()上的 JournalDev 文章
Python 字符串函数
原文：https://www.askpython.com/python/string/python-string-functions
Python 为几乎所有要在字符串上执行的操作都提供了内置函数。简单地说，这些是根据它们的使用频率和操作来分类的。它们如下:
Python 字符串函数分类
- 基本功能
- 高级功能
- 杂项(这些函数不是专门针对字符串的，但是可以在字符串操作中使用)
基本字符串函数
| 大写() | 它将字符串的第一个字符转换为大写 | str_name.capitalize() |
| casefold() | 它将任何字符串转换为小写，而不考虑其大小写 | str_name.casefold() |
| 居中() | 它用于将字符串居中对齐 | str_name.center(Length,character) |
| 计数() | 它用于计算特定值在字符串中出现的次数 | str_name.count(value,start,end) |
| endswith() | 它检查字符串是否以指定的值结尾，然后返回 True | str_name.endswith(value,start,end) |
| 查找() | 它用于查找字符串中指定值的存在 | str_name.find(value,start,end) |
| 索引() | 它用于查找字符串中指定值的第一个匹配项 | str_name.index(value,start,end) |
| isalnum() | 它检查是否所有的字符都是字母数字，然后返回真 | str_name.isalnum() |
| isalpha() | 它检查是否所有的字符都是字母(a-z ),然后返回 True | str_name.isalpha() |
| 十进制格式() | 它检查所有字符是否都是小数(0-9)，然后返回 True | str_name.isdecimal() |
| isdigit() | 它检查是否所有的字符都是数字，然后返回真 | str_name.isdigit() |
| islower() | 它检查是否所有的字符都是小写的，然后返回 True | str_name.islower() |
| isnumeric() | 它检查是否所有的字符都是数字(0-9)，然后返回 True | str_name.isnumeric() |
| isspace() | 它检查是否所有字符都是空白，然后返回 True | str_name.isspace() |
| isupper() | 它检查是否所有的字符都是大写的，然后返回 True | str_name.isupper() |
| 下部() | 它用于将所有字符转换成小写 | str_name.lower() |
| 分区() | 它用于将字符串拆分成一个由三个元素组成的元组 | str_name.partition(value) |
| 替换() | 它用于将指定的单词或短语替换为字符串中的另一个单词或短语 | str_name.replace(oldvalue,newvalue,count) |
| 拆分() | 它用于将一个字符串拆分成一个列表 | str_name.split(separator,maxsplit) |
| 分割线() | 它用于拆分字符串并制作一个列表。在换行符处拆分。 | str_name.splitlines(keeplinebreaks) |
| 开始于() | 它检查字符串是否以指定的值开始，然后返回 True | str_name.startswith(value,start,end) |
| 条状() | 它用于从两端删除参数中指定的字符 | str_name.strip(characters) |
| 交换情况() | 它用于将大写字符串转换成小写字符串，反之亦然 | str_name.swapcase() |
| 标题() | 它将每个单词的首字母转换成大写 | str_name.title() |
| 上部() | 它用于将字符串中的所有字符转换为大写 | str_name.upper() |
高级 Python 字符串函数
| 编码() | 它用于返回编码字符串 | str_name.encode(encoding=*encoding*, errors=*errors*) |
| expandtabs() | 它用于设置或固定字符或字母之间的制表符间距 | str_name.expandtabs(tabsize) |
| 格式() | 它用执行时的值替换在{}中写入的变量名 | str_name.format(value1,value2...) |
| format_map() | 它用于格式化给定的字符串并返回 | str_name.format_map(mapping) |
| isidentifier() | 它检查字符是字母数字(a-z)和(0-9)还是下划线(_)并返回 True | str_name.isidentifier() |
| isprintable() | 它检查是否所有字符都是可打印的，然后返回 True | str_name.isprintable() |
| istitle() | 它检查单词的所有首字母是否都是大写的，然后返回 True | str_name.istitle() |
| 加入() | 它接受单词作为 iterable，并将它们连接成一个字符串 | str_name.join(iterable) |
| 光源() | 它返回一个左对齐的字符串，其最小值作为宽度给出 | str_name.ljust(length,character) |
| lstrip() | 它根据给定的参数从左端移除字符 | str_name.lstrip(characters) |
| maketrans() | 它创建一个可用于翻译的映射表 | str_name.maketrans(x,y,z) |
| rsplit() | 它用于从右端分割字符串 | str_name.rsplit(separator,maxsplit) |
| rfind() | 它搜索指定的值，并找到其最后一个值的位置 | str_name.rfind(value,start,end) |
| rindex() | 它搜索指定的值，并找到其最后一个值的位置 | str_name.rindex(value,start,end) |
| rjust() | 它返回一个右对齐的字符串，其最小值作为宽度给出 | str_name.rjust(length,character) |
| rpartition() | 它查找指定字符串的最后一个匹配项，并将该字符串拆分为由三个元素组成的元组 | str_name.rpartition(value) |
| rstrip() | 它根据给定的参数从右端移除字符 | str_name.rstrip(characters) |
| 翻译() | 它用于获取翻译后的字符串 | str_name.translate(table) |
| zfill() | 它返回一个新字符串，在该字符串的左边填充了“0”字符 | str_name.zfill(len) |
处理字符串的各种函数
| ascii() | 它返回包含对象的可打印形式的字符串，并忽略字符串中的非 ASCII 值 | ascii(object) |
| 布尔() | 它返回布尔值，即对象的真或假 | bool(value) |
| bytearray() | 它返回一个对象，该对象包含通过输入提供的字节数组 | bytearray(source,encoding,errors) |
| 字节() | 它返回不可修改的字节对象，是一个范围从 0 到 255 的整数序列 | bytes(source,encoding,errors) |
| 枚举() | 它用于向 iterable 添加计数器，然后返回它的值 | enumerate(iterable,start=0) |
| 浮动() | 它从给定的参数中返回浮点数 | float(argument) |
| 哈希() | 如果适用，它返回对象的哈希值 | hash(object) |
| id() | 它返回一个对象的特定标识，它是一个唯一的整数 | id(object) |
| int() | 它从给定的输入中返回一个整数对象，并且返回对象的基数总是 10 | int(x=0,base=10) |
| len() | 它返回序列的长度，即对象中的项目数 | len(sequence) |
| 地图() | 它用于将给定的函数应用于 iterable 的每一项，iterable 可以是元组、列表等。并且还返回包含结果值的列表 | map(function, iterable, ...) |
| 订单() | 它接受单个 Unicode 字符的字符串参数，并返回其对应的 Unicode 点 | ord(character) |
| 打印() | 它将提供的对象打印到任何输出设备 | print*(object(s)*,separator=*separator*, end=*end*,file=*file*,flush=*flush*) |
| 切片() | 它创建一个对象，该对象表示由其范围(开始、停止、步进)指定的一组索引 | slice(stop) slice(start,stop,step) |
| 类型() | 它返回对象的类型 | type(object) type(name,bases,dict) |
参考
Python 字符串到 int 和 int 到 string
原文：https://www.askpython.com/python/built-in-methods/python-string-int-conversion
在本文中，我们将了解 Python 字符串到 int 的转换以及 Int 到 String 的转换。在 Python 中，这些值从不进行隐式类型转换。让我们看看如何显式地对变量进行类型转换。
1.Python 字符串到整数的转换
Python int()方法使我们能够将字符串类型的任何值转换为整数值。
语法:
int(string_variable)
举例:
string_num = '75846'
print("The data type of the input variable is:\n")
print(type(string_num))
result = int(string_num)
print("The data type of the input value after conversion:\n")
print(type(result))
print("The converted variable from string to int:\n")
print(result)
输出:
The data type of the input variable is:
<class 'str'>
The data type of the input value after conversion:
<class 'int'>
The converted variable from string to int:
75846
使用不同的基数将 Python 字符串转换为 int
Python 还为我们提供了一个高效的选项，可以根据数字系统将字符串类型的数字/值转换为特定基下的整数值。
语法:
int(string_value, base = val)
举例:
string_num = '100'
print("The data type of the input variable is:\n")
print(type(string_num))
print("Considering the input string number of base 8....")
result = int(string_num, base = 8)
print("The data type of the input value after conversion:\n")
print(type(result))
print("The converted variable from string(base 8) to int:\n")
print(result)
print("Considering the input string number of base 16....")
result = int(string_num, base = 16)
print("The data type of the input value after conversion:\n")
print(type(result))
print("The converted variable from string(base 16) to int:\n")
print(result)
在上面的代码片段中，我们已经将‘100’分别转换为以为基数 8 和以为基数 16 的整数值。
输出:
The data type of the input variable is:
<class 'str'>
Considering the input string number of base 8....
The data type of the input value after conversion:
<class 'int'>
The converted variable from string(base 8) to int:
64
Considering the input string number of base 16....
The data type of the input value after conversion:
<class 'int'>
The converted variable from string(base 16) to int:
256
Python 字符串到 int 转换时出现 ValueError 异常
场景:如果任何输入字符串包含不属于十进制数字系统的数字。
在下面的例子中，如果您希望将字符串‘A’转换为基数为 16 的整数值 A，并且我们没有将 base=16 作为 参数传递给 int()方法，那么将引发 ValueError 异常。
因为即使' A 是一个十六进制值，但由于它不属于十进制数系统，它不会认为 A 等同于十进制数 10，除非我们不将 base = 16 作为参数传递给 int()函数。
举例:
string_num = 'A'
print("The data type of the input variable is:\n")
print(type(string_num))
result = int(string_num)
print(type(result))
print("The converted variable from string(base 16) to int:\n")
print(result)
输出:
The data type of the input variable is:
<class 'str'>
Traceback (most recent call last):
File "main.py", line 4, in <module>
result = int(string_num)
ValueError: invalid literal for int() with base 10: 'A'
将 Python 整数列表转换为字符串列表
包含整数元素的 Python 列表 可以使用 int() 方法和列表理解转换成字符串值列表。
举例:
st_lst = ['121', '144', '111', '564']
res_lst = [int(x) for x in st_lst]
print (res_lst)
输出:
[121, 144, 111, 564]
2.Python 整数到字符串的转换
Python 的str()方法使我们能够将整数类型的任何值转换为字符串值。
语法:
str(integer_value)
举例:
int_num = 100
print("The data type of the input variable is:\n")
print(type(int_num))
result = str(int_num)
print("The data type of the input value after conversion:\n")
print(type(result))
print("The converted variable from int to string:\n")
print(result)
输出:
The data type of the input variable is:
<class 'int'>
The data type of the input value after conversion:
<class 'str'>
The converted variable from int to string:
100
结论
在本文中，我们已经了解了 Python 字符串到整数的转换，反之亦然。
参考
Python 字符串 isalnum()函数
原文：https://www.askpython.com/python/string/python-string-isalnum-function
Python 中的 String 有内置的函数，可以对字符串执行几乎所有的操作。Python String isalnum()函数检查字符串中的字母数字字符，只有当字符串由字母数字字符组成时，即字母(a-z，A-Z)或数字(0-9)或两者的组合，才返回 True 。
要点:
- 返回类型:布尔型，即真或假
- 参数值:isalnum()函数中不需要解析任何参数
- 字符串中不应有空格
- 空字符串也返回 False
- 不区分大小写，即返回值不取决于字符串的大小写
String isalnum() Syntax
str_name.isalnum()
这里的 str_name 指的是输入字符串。并且，isalnum()是 python 中内置的字符串函数。
str_name = "Hello123"
print(str_name.isalnum()) # True
String isalnum()示例
不同情况的例子如下:
情况 1:字符串只包含字母
str_name = "Hello"
print(str_name.isalnum()) # True
情况 2:字符串只包含数字
str_name = "786"
print(str_name.isalnum()) # True
情况 3:字符串之间包含空格
str_name = "Welcome user 123"
print(str_name.isalnum()) #False
情况 4:字符串包含不同大小写的数字和字母
str_name = "w3lC0Me"
print(str_name.isalnum()) # True
情况 5:字符串包含特殊字符
str_name = "[email protected]"
print(str_name.isalnum()) # False
情况 6:字符串为空或包含空格
str_name = ' '
print(str_name.isalnum()) # False
用 Python 打印所有可能的字母数字字符列表的程序
Unicode 模块可用于检查字母数字字符。该计划是打印所有的字母数字 Unicode 字符。
import unicodedata
total_count = 0
for i in range(2 ** 16):
charac = chr(i)
if charac.isalnum():
print(u'{:04x}: {} ({})'.format(i, charac, unicodedata.name(charac, 'UNNAMED')))
total_count = total_count + 1
print("Total Count of Alphanumeric Characters = ",total_count)
输出:
Output All Alphanumeric Characters
这只是输出的一瞥，因为实际输出很长。总共有 49167 个字母数字字符。
参考资料:
- Python 字符串 isalnum()
- Python 内置的字符串函数
Python 字符串 isalpha()函数
原文：https://www.askpython.com/python/string/python-string-isalpha-function
Python 中的 String 有内置的函数，可以对字符串执行几乎所有的操作。Python String isalpha()函数检查字符串中的字母，如果字符串只包含字母(a-z，A-Z)，则返回 True。
要点:
- 返回类型:布尔型，即真或假
- 参数值:不需要参数
- 空格不被认为是字母。因此，空格将返回 False。
- 空字符串也会返回 False。
字符串 isalpha()语法
str_name.isalpha()
这里的 str_name 指的是输入字符串。并且，isalpha()是 python 中内置的字符串函数。
str_name = "Welcome"
print(str_name.isalpha()) # True
字符串 isalpha()示例
下面给出不同的案例。
情况 1:字符串包含空白
str_name = "Welcome User"
print(str_name.isalpha()) # False
情况 2:字符串包含数字
str_name = "WelcomeUser1"
print(str_name.isalpha()) # False
情况 3:字符串包含特殊字符
str_name = "[email protected]"
print(str_name.isalpha()) # False
情况 4:字符串为空
str_name = ' '
print(str_name.isalpha()) # False
打印 Python 中所有可能的字母字符列表的程序
Unicode 模块可用于检查字母字符。该计划是打印所有的阿尔法 Unicode 字符。
import unicodedata
total_count = 0
for i in range(2 ** 16):
charac = chr(i)
if charac.isalpha():
print(u'{:04x}: {} ({})'.format(i, charac, unicodedata.name(charac, 'UNNAMED')))
total_count = total_count + 1
print("Total Count of Alpha Unicode Characters = ",total_count)
输出:
Output All Alpha Unicode Characters
这只是输出的一瞥，因为实际输出很长。Unicode 中有 48462 个字母字符。
参考资料:
- Python 字符串 isalpha()
- Python 内置字符串
Python 字符串 isdigit()函数
原文：https://www.askpython.com/python/string/python-string-isdigit-function
Python String isdigit()函数检查字符串中的数字字符，如果字符串只包含数字字符，则返回 True。
要点:
- 返回类型:布尔型，即真或假
- 参数值:is digit()函数中不需要解析任何参数
- 数字之间的空格会导致返回 False
- 空字符串也会返回 False
String isdigit() Syntax
str_name.isdigit()
这里的 str_name 指的是输入字符串。并且，isdigit()是 python 中内置的字符串函数。
str_name = "12345"
print(str_name.isdigit()) # True
String isdigit()示例
下面给出不同的案例。
案例 1:字符串包含空格
str_name = "12 34"
print(str_name.isdigit()) # False
案例 2:字符串包含字母
str_name = "Abc123"
print(str_name.isdigit()) # False
str_name = "Abc"
print(str_name.isdigit()) # False
情况 3:字符串包含特殊字符
str_name = "@123"
print(str_name.isdigit()) # False
str_name = "@$&"
print(str_name.isdigit()) # False
案例 4:字符串包含小数
str_name = "16.7"
print(str_name.isdigit()) # False
情况 5:字符串为空
str_name = ' '
print(str_name.isdigit()) # False
用 Python 打印所有可能的数字字符列表的程序
Unicode 模块可用于检查数字字符。该计划是打印所有的数字 Unicode 字符。
import unicodedata
total_count = 0
for i in range(2 ** 16):
charac = chr(i)
if charac.isdigit():
print(u'{:04x}: {} ({})'.format(i, charac, unicodedata.name(charac, 'UNNAMED')))
total_count = total_count + 1
print("Total Count of Unicode Digit Characters = ",total_count)
Output All Digit Unicode Characters
这只是输出的一瞥，因为实际输出很长。Unicode 中有 445 个数字字符。
参考
- Python String isdigit()
- Python 内置的字符串函数
Python 字符串 islower()函数
原文：https://www.askpython.com/python/string/python-string-islower-function
Python String islower()函数检查一个字符串中的所有字符是否都是小写，然后返回 True，否则返回 False。
要点:
- 返回类型:布尔型，即真或假
- 参数值:不需要参数
- 它不区分空间，但区分大小写
- 空字符串也会返回 False。
String islower()语法
str_name.islower()
这里的 str_name 指的是输入字符串。islower()是 python 中内置的字符串函数。
str_name = "welcome"
print(str_name.islower()) # True
String islower()示例
下面给出不同的案例。
情况 1:字符串中的每个字符都是小写的，还包含空格/数字/特殊字符
str_name = "welcome python user"
print(str_name.islower()) # True
str_name = "welcome 2019"
print(str_name.islower()) # True
str_name = "welcome @ 2020"
print(str_name.islower()) # True
情况 2:字符串中的每个字符都是大写的，也包含空格/数字/特殊字符
str_name = "WELCOME PYTHON USER"
print(str_name.islower()) # False
str_name = "WELCOME 2019"
print(str_name.islower()) # False
str_name = "WELCOME @ 2020"
print(str_name.islower()) # False
情况 3:字符串只包含数字或特殊字符
str_name = "2020"
print(str_name.islower()) # False
str_name = "@$&"
print(str_name.islower()) # False
情况 4:只有每个单词的第一个字符是大写的，还包含空格/数字/特殊字符
str_name = "Welcome"
print(str_name.islower()) # False
str_name = "Welcome Python User"
print(str_name.islower()) # False
str_name = "Welcome 2019"
print(str_name.islower()) # False
str_name = "Welcome @ 2020"
print(str_name.islower()) # False
情况 5:字符串为空
str_name = ' '
print(str_name.islower()) # False
用 Python 打印所有可能的小写字符列表的程序
Unicode 模块可用于检查小写字符。该计划是打印所有小写 Unicode 字符。
import unicodedata
total_count = 0
for i in range(2 ** 16):
charac = chr(i)
if charac.islower():
print(u'{:04x}: {} ({})'.format(i, charac, unicodedata.name(charac, 'UNNAMED')))
total_count = total_count + 1
print("Total Number of Lowercase Unicode Characters = ",total_count)
Output All Lowercase Unicode Characters
这只是输出的一瞥，因为实际输出很长。Unicode 中有 1402 个小写字符。
参考
- Python 字符串 islower()
- Python 内置函数
Python 字符串是 numeric()函数
原文：https://www.askpython.com/python/string/python-string-isnumeric-function
如果发现输入字符串中的所有字符都是数字类型，Python String **isnumeric()**函数返回 True ，否则返回 False 。
数字字符可以是以下类型:
- 数字字符=十进制
- 数字 _ 字符=数字
- 数字 _ 字符=数字
语法:
input_string.isnumeric()
isnumeric()参数:isnumeric()函数不接受任何参数作为输入。
Python isnumeric()示例
例 1:
string = '124678953'
print(string.isnumeric())
输出:
True
例 2:
string = 'Divas Dwivedi . 124678953'
print(string.isnumeric())
输出:
False
例 3: 特殊 Unicode 字符作为输入字符串
string1 = '\u00B23455'
print(string1)
print(string1.isnumeric())
输出:
²3455
True
例 4:
string = "000000000001"
if string.isnumeric() == True:
print("Numeric input")
else:
print("Not numeric")
str = "000-9999-0110"
if str.isnumeric() == True:
print("Numeric input")
else:
print("Non numeric input")
输出:
Numeric input
Non numeric input
访问所有 Unicode 数字字符
**unicodedata**模块用于获取所有的数字 Unicode 字符。
import unicodedata
count_numeric = 0
for x in range(2 ** 16):
str = chr(x)
if str.isnumeric():
print(u'{:04x}: {} ({})'.format(x, str, unicodedata.name(str, 'UNNAMED')))
count_numeric = count_numeric + 1
print(f'Count of Numeric Unicode Characters = {count_numeric}')
输出:
0030: 0 (DIGIT ZERO)
0031: 1 (DIGIT ONE)
0032: 2 (DIGIT TWO)
.....
ff15: ５ (FULLWIDTH DIGIT FIVE)
ff16: ６ (FULLWIDTH DIGIT SIX)
ff17: ７ (FULLWIDTH DIGIT SEVEN)
ff18: ８ (FULLWIDTH DIGIT EIGHT)
ff19: ９ (FULLWIDTH DIGIT NINE)
Count of Numeric Unicode Characters = 800
结论
因此，在本文中，我们研究并实现了 Python String 的 isnumeric()函数。
参考
- Python 是一个数字函数
- Python 字符串文档
Python 字符串是可打印的()
原文：https://www.askpython.com/python/string/python-string-isprintable
Python Stringis printable()函数可用于检查 Python 字符串是否可打印。
这到底是什么意思？让我们来了解一下！
Python 字符串是可打印的()
Python 字符串中的某些字符不能直接打印到控制台(文件)。在 Unicode 字符数据库中，它们被归类为“其他”或“分隔符”。
注意，ASCII 空格字符( 0x20 )是一个例外，因为它显然可以被打印出来。
考虑可打印字符串的另一种方式是，它可以被成功解码为 Unicode 字符。任何不可打印的字符串都会引发这方面的错误。
它大致相当于以下方法:
def isprintable(s, codec='utf8'):
try: s.decode(codec)
except UnicodeDecodeError: return False
else: return True
如果我们能得到解码后的utf-8格式的字符串，那么它就可以被打印出来。否则，我们干脆返回False。
因此，让我们用一些例子来看看如何使用这个函数。
要使用这个函数，我们必须在 string 对象上调用 Python string isprintable()方法。
ret = string.isprintable()
ret为布尔型，如果字符串可以打印，则为True。否则，就是False。
>>> a = "Hello from AskPython"
>>> print(a.isprintable())
True
这里，我们的字符串中的所有字符都是可打印的，所以它返回True。
空字符串也是可打印的。
>>> b = ""
>>> print(b.isprintable())
True
我们不能打印像\n或\t这样的转义字符，所以如果我们的字符串有任何转义序列，isprintable()将返回False。
>>> c = "Hello from AskPython\n"
>>> print(c.isprintable())
False
>>> d = "Hello\tfrom\tAskPython"
>>> print(d.isprintable())
False
有些字符(像\u0066 - > f)可以打印，有些字符(像\u0009 - > \t)不能。
基本上，它们必须映射到有效的 unicode 字符。
>>> e = "Hello \u0066rom AskPython"
>>> print(e.isprintable())
True
>>> print(e)
Hello from AskPython
>>> f = "Hello \u0066rom\u0009AskPython"
>>> print(f.isprintable())
False
>>> print(f)
Hello from AskPython
为了结束 isprintable()方法的工作，让我们看看如何找出 unicode 数据库中所有不可打印的字符。
找出所有不可打印的字符
unicode 字符的总数是2^16，所以我们将创建一个遍历每个字符的循环，并检查它是否可以打印。
count = 0
for ascii_val in range(2 ** 16):
ch = chr(ascii_val)
if not ch.isprintable():
count += 1
print(f"Total Number of Non-Printable Unicode Characters = {count}")
输出
Total Number of Non-Printable Unicode Characters = 10249
结论
在本文中，我们学习了如何使用 Python String isprintable()方法来检查字符串的字符是否可以被打印。
参考
- 字符串上的 JournalDev 文章是可打印的()
- String 上的 StackOverflow 问题【isprintable()
Python 字符串 isspace()方法
原文：https://www.askpython.com/python/string/python-string-isspace
在本文中，我们将深入研究 Python String isspace()方法的工作原理。 Python String 有生动的内置方法来处理字符串输入。
Python String isspace()入门
Python string isspace()方法用于检查输入字符串中是否存在空格。
空白字符包括:
- \n
- \t
- \v
- \f
- ' '
- \r
- 等等。
如果输入字符串只包含和空格，则返回 True 。否则，当字符串包含一个或多个非空白字符时，函数返回 False 。
语法:
input_string.isspace()
例 1:
inp = 'Engineering_Discipline'
print(inp.isspace())
在上面的示例中，由于输入字符串不包含空格，该函数返回 False。
输出:
False
例 2:
inp = '\t \v \n'
print(inp.isspace())
在本例中，输入字符串只包含空格。因此，该函数的计算结果为 True。
输出:
True
例 3:
inp = '\thello everyone!!\n'
print(inp.isspace())
在此示例中，输入字符串包含空白字符和非空白字符的组合，即它包含一个或多个非空白字符。
因此，该函数返回 False。
输出:
False
NumPy isspace()方法
Python NumPy 模块 为我们提供了 numpy.char.isspace() 方法来检查数组的输入元素中是否存在空格。
语法:
numpy.char.isspace(input_array)
numpy.char.isspace()函数以元素方式检查输入数组中是否存在空格。
也就是说，它检查数组中的每个元素，并为出现的每个元素返回 true 或 false。
举例:
import numpy
inp_arr1 = numpy.array([ 'Science', 'Commerce', 'Arts'] )
print ("Elements of array1:\n", inp_arr1)
res1 = numpy.char.isspace(inp_arr1)
print ("Array1 after using isspace():\n", res1)
inp_arr2 = numpy.array([ 'Sci\nence', 'Commerce\t', 'Arts'] )
print ("Elements of array2:\n", inp_arr2)
res2 = numpy.char.isspace(inp_arr2)
print ("Array2 after using isspace():\n", res2)
inp_arr3 = numpy.array([ '\n\r', '\f\t', ' '] )
print ("Elements of array3:\n", inp_arr3)
res3 = numpy.char.isspace(inp_arr3)
print ("Array3 after using isspace():\n", res3)
输出:
Elements of array1:
['Science' 'Commerce' 'Arts']
Array1 after using isspace():
[False False False]
Elements of array2:
['Sci\nence' 'Commerce\t' 'Arts']
Array2 after using isspace():
[False False False]
Elements of array3:
['\n\r' '\x0c\t' ' ']
Array3 after using isspace():
[ True True True]
Pandas isspace()方法
Pandas 模块 包含 isspace()函数，用于检查序列或数据帧中所有数据的空白字符串。
语法:
Series.str.isspace()
Series.str.isspace()方法检查每个元素的空白字符串是否存在，并只为这些元素返回 True 。
注意 : Series.str.isspace()方法只对字符串类型元素有效。如果解释器遇到任何非字符串值，它会引发 ValueError 异常。
上述异常可以使用.astype()功能进行控制。的。astype()函数将非字符串类型的数据转换为字符串类型。
举例:
import pandas
inp_data = pandas.Series(['Jim', 'Jonny', ' ', '\t', 'Daisy', '\n'])
res = inp_data.str.isspace()
print(res)
输出:
0 False
1 False
2 True
3 True
4 False
5 True
dtype: bool
结论
在本文中，我们已经了解了 Python string isspace()方法的功能。
参考
Python isspace()方法
Python 字符串 istitle()方法
原文：https://www.askpython.com/python/string/python-string-istitle-method
在本文中，我们将揭示 Python 字符串 istitle()函数。 Python 字符串 有内置函数对输入字符串进行操作。Python String istitle() 就是这样一种方法。
Python String istitle()方法入门
String istitle()方法用于检查输入字符串的标题大小写，即如果字符串中每个单词的first character都是大写并且字符串中每个单词的所有剩余字符都是小写，则检查并返回 True 。
例 1:
inp = 'Taj Mahal'
print(inp.istitle())
在上面的例子中，istitle()函数返回 True ，因为对于上面输入的每个单词，只有第一个字符是大写的。
输出:
True
例 2:
inp = 'Taj mahal'
print(inp.istitle())
在本例中，istitle()方法导致 False ，因为输入字符串的第二个单词，即“mahal”没有大写的第一个字符。
输出:
False
例 3:
inp = 'TAJ MAHAL'
print(inp.istitle())
在本例中，输入字符串的每个字符都是大写的。因此，该函数返回假。
输出:
False
NumPy istitle()方法
NumPy 模块 内置 istitle()方法，检查输入数组的标题 case 。
**numpy.char.istitle()**方法以一种基于元素的方式工作。它单独检查数组中每个元素的标题大小写，并返回真/假。
注意:如果输入字符串包含零字符，默认情况下，函数返回 False 。
语法:
numpy.char.istitle(input_array)
举例:
import numpy
inp_arr1 = numpy.array(['TAJ', 'Mahal', '14Pen', '20eraser', 'aMAZON', 'F21Ever'])
print ("Elements of the array:\n", inp_arr1)
res1 = numpy.char.istitle(inp_arr1)
print ("Array after istitle():\n", res1 )
输出:
Elements of the array:
['TAJ' 'Mahal' '14Pen' '20eraser' 'aMAZON' 'F21Ever']
Array after istitle():
[False True True False False True]
Pandas istitle()方法
熊猫模块 由 Series.str.istitle() 方法组成，用于检查输入数据的标题情况。
Series.str.istitle() 方法以元素方式检查数据集/输入中的所有字符串是否都是标题大小写。
语法:
Series.str.istitle()
举例:
import pandas
res = pandas.Series(['TAJ', 'Mahal', '14Pen', '20eraser', 'aMAZON', 'F21Ever'])
print(res.str.istitle())
如上所述，输入数据中数字的存在不会给函数的输出带来任何变化。
输出:
0 False
1 True
2 True
3 False
4 False
5 True
dtype: bool
结论
在本文中，我们确实了解了 Python istitle()函数在各种场景下的工作。
参考
Python 字符串 istitle()方法
Python String isupper()函数
原文：https://www.askpython.com/python/string/python-string-isupper-function
Python 中的 String 有内置的函数，可以对字符串执行几乎所有的操作。Python String isupper()函数检查一个字符串中的所有字符是否都是大写的，然后返回 true，否则返回 false。
要点:
- 返回类型:布尔型，即真或假
- 参数值:不需要参数
- 它不区分空间，但区分大小写
- 空字符串也会返回 False。
String isupper()语法
str_name.isupper()
这里的 str_name 指的是输入字符串。并且，isupper()是 python 中内置的字符串函数。
str_name = "WELCOME"
print(str_name.isupper()) # True
String isupper()示例
下面给出不同的案例。
情况 1:字符串中的每个字符都是大写的，还包含空格/数字/特殊字符
str_name = "WELCOME PYTHON USER"
print(str_name.isupper()) # True
str_name = "WELCOME 2019"
print(str_name.isupper()) # True
str_name = "WELCOME @ 2020"
print(str_name.isupper()) # True
情况 2:字符串只包含数字或特殊字符
str_name = "2020"
print(str_name.isupper()) # False
str_name = "@$&"
print(str_name.isupper()) # False
情况 3:字符串中的每个字符都是小写的，还包含空格/数字/特殊字符
str_name = "welcome python user"
print(str_name.isupper()) # False
str_name = "welcome 2019"
print(str_name.isupper()) # False
str_name = "welcome @ 2020"
print(str_name.isupper()) # False
情况 4:只有每个单词的第一个字符是大写的，还包含空格/数字/特殊字符
str_name = "Welcome"
print(str_name.isupper()) # False
str_name = "Welcome Python User"
print(str_name.isupper()) # False
str_name = "Welcome 2019"
print(str_name.isupper()) # False
str_name = "Welcome @ 2020"
print(str_name.isupper()) # False
情况 5:字符串为空
str_name = ' '
print(str_name.isupper()) # False
打印 Python 中所有可能的大写字符列表的程序
Unicode 模块可用于检查大写字符。该计划是打印所有大写 Unicode 字符。
import unicodedata
total_count = 0
for i in range(2 ** 16):
charac = chr(i)
if charac.isupper():
print(u'{:04x}: {} ({})'.format(i, charac, unicodedata.name(charac, 'UNNAMED')))
total_count = total_count + 1
print("Total Count of Unicode UPPERCASE Characters = ",total_count)
Output All Uppercase Unicode Characters
这只是输出的一瞥，因为实际输出很长。Unicode 中有 999 个大写字符。
参考
- Python 字符串 isupper()
- Python 内置函数
Python 字符串连接()函数
原文：https://www.askpython.com/python/string/python-string-join-method
在本文中，我们将看看 Python 字符串连接()函数。顾名思义，它用于将字符串连接在一起，并为字符串类型的数据工作。
了解 Python 字符串连接()方法
Python String 有各种内置函数来处理 String 类型的数据。
join()方法主要用于通过另一组分隔符/字符串元素连接输入字符串。它接受 iterables 如 set ， list ， tuple ，string 等和另一个 string (可分离元素)作为参数。
join()函数返回一个字符串，将 iterable 的元素与作为参数传递给函数的分隔符字符串连接起来。
语法:
separator-string.join(iterable)
例 1:
inp_str='JournalDev'
insert_str='*'
res=insert_str.join(inp_str)
print(res)
输出:
J*o*u*r*n*a*l*D*e*v
例 2:
inp_str='PYTHON'
insert_str='#!'
res=insert_str.join(inp_str)
print(res)
输出:
P#!Y#!T#!H#!O#!N
嘿，伙计们！需要考虑的最重要的一点是， join()函数只对字符串类型的输入值起作用。如果我们输入非字符串类型的任何一个参数，就会引发一个TypeError exception。
举例:
inp_str=200 #non-string type input
insert_str='S'
res=insert_str.join(inp_str)
print(res)
在上面的示例中，分隔符字符串(即 insert_str)被赋予了一个整数值。因此，它会引发一个 TypeError 异常。
输出:
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-11-ef2dcbcf6abf> in <module>
1 inp_str=200 #non-string type input
2 insert_str='S'
----> 3 res=insert_str.join(inp_str)
4 print(res)
TypeError: can only join an iterable
以 list 为可迭代的 Python string join()方法:
语法:
separator-string.join(list)
举例:
inp_lst=['10','20','30','40']
sep='@@'
res=sep.join(inp_lst)
print(res)
在上面的示例中，分隔符字符串“@@”被连接到输入列表的每个元素，即 inp_lst。
输出:
[email protected]@[email protected]@[email protected]@40
Python join()方法有 set 一个 iterable :
语法:
separator-string.join(set)
举例:
inp_set=('10','20','30','40')
sep='**'
sep1='<'
res=sep.join(inp_set)
print(res)
res1=sep1.join(inp_set)
print(res1)
在上面的例子中，分隔符字符串“**”和“
输出:
10**20**30**40
10<20<30<40
Python join()方法用 dictionary 作为 iterable:
Python string join()方法也可以作为 iterable 应用于字典。
但是，需要注意的重要一点是， join()方法只作用于字典数据结构的键，而不是与键相关联的值。
语法:
separator-string.join(dict)
例 1:
inp_dict={'Python':'1','Java':'2','C++':'3'}
sep='##'
res=sep.join(inp_dict)
print(res)
从上面的例子可以看出，join()方法只考虑 dict 的键来进行操作。它完全忽略了格言的价值。
输出:
Python##Java##C++
例 2:
inp_dict={'Python':1,'Java':2,'C++':3}
sep='##'
res=sep.join(inp_dict)
print(res)
在上面的例子中，dict 中的值是非字符串类型的。不过，这不会导致代码执行出错，因为 join()方法只处理字典的键。
输出:
Python##Java##C++
例 3:
inp_dict={1:'Python',2:'Java',3:'C++'}
sep='##'
res=sep.join(inp_dict)
print(res)
上面的代码返回一个 TypeError ，因为与字典相关联的键值是非字符串类型的。
输出:
TypeError Traceback (most recent call last)
<ipython-input-34-bb7356c41bc8> in <module>
1 inp_dict={1:'Python',2:'Java',3:'C++'}
2 sep='##'
----> 3 res=sep.join(inp_dict)
4 print(res)
TypeError: sequence item 0: expected str instance, int found
Python numpy.join()方法
Python NumPy 模块内置了处理数组中字符串数据的函数。
numpy.core.defchararray.join(sep-string,inp-arr)用于将数组的元素与作为参数传递的分隔符字符串连接起来。
它接受包含字符串类型元素和分隔符字符串的数组作为参数，返回包含由输入分隔符字符串(分隔符)分隔的元素的数组。
语法:
numpy.core.defchararray.join(separator-string,array)
例 1:
import numpy as np
inp_arr=np.array(["Python","Java","Ruby","Kotlin"])
sep=np.array("**")
res=np.core.defchararray.join(sep,inp_arr)
print(res)
在上面的例子中，我们已经使用numpy.array()方法从传递的列表元素中生成了一个数组。此外，通过使用 join()函数，它将字符串“**”连接到数组的每个元素。
输出:
['P**y**t**h**o**n' 'J**a**v**a' 'R**u**b**y' 'K**o**t**l**i**n']
例 2:
import numpy as np
inp_arr=np.array(["Python","Java","Ruby","Kotlin"])
sep=np.array(["**","++","&&","$$"])
res=np.core.defchararray.join(sep,inp_arr)
print(res)
在上面的例子中，我们为数组的每个元素使用了不同的单独的字符串。唯一的条件是数组中可分离字符串(分隔符)的数量应该与输入数组中元素的数量相匹配。
输出:
['P**y**t**h**o**n' 'J++a++v++a' 'R&&u&&b&&y' 'K$$o$$t$$l$$i$$n']
Python Pandas str.join()方法
Python Pandas 模块有内置的 pandas.str.join()方法，用提供的分隔符连接数据集的元素。
pandas.str.join()方法处理数据集或输入序列的特定列(数据)值，并返回带有分隔符字符串或分隔符的连接数据项的序列。
语法:
Series.str.join(delimiter or separator-string)
输入。csv 文件:Book1.csv
Input csv file-Book1
举例:
import pandas
info=pandas.read_csv("C:\\Book1.csv")
info["Name"]=info["Name"].str.join("||")
print(info)
在上面的例子中，我们已经使用了pandas.read_csv()方法来读取数据集的内容。此外，我们将分隔符字符串，即“||”连接到输入数据集的列“Name”的数据值。
输出:
Name Age
0 J||i||m 21
1 J||e||n||n||y 22
2 B||r||a||n 24
3 S||h||a||w||n 12
4 R||i||t||i||k 26
5 R||o||s||y 24
6 D||a||n||n||y 25
7 D||a||i||s||y 15
8 T||o||m 27
摘要
- join()方法用于使用字符串分隔符元素连接字符串类型的元素或 iterables。
- 参数:iterable 元素和分隔符必须是
string type。 - 而且，Python join()方法还可以应用于集合、列表、字典等可迭代对象。
- 如果分隔符或输入 iterable 包含非字符串类型的元素，join()方法会引发一个
TypeError exception。
结论
因此，在本文中，我们已经了解了 Python String join()方法对不同可重复项(如集合、列表、元组、字典等)的工作原理。
参考
- Python 字符串 join()方法–journal dev
- Python 字符串函数
Python 字符串 ljust()和 rjust()函数
原文：https://www.askpython.com/python/string/python-string-ljust-rjust-functions
Python String 包含两个提供左右对齐的内置方法。
1.Python 字符串 ljust()函数
Python String ljust()函数接受用于填充输入字符串的字符。然后，它替换该字符，并在输入字符串的右侧进行填充。
语法:
String.ljust(length,fill_char)
参数:
- length :提供的 length 的值基本上用来对齐给定长度的字符串。
- fill_char :可选参数。这些是需要在字符串周围填充的字符。
ljust()函数返回的值:
ljust()函数返回一个新的字符串，并将给定的 fill_char 替换到原始字符串的右边。
例 1:
input_string = 'Python'
size = 9
fill_char = '@'
print(input_string.ljust(size, fill_char))
输出:
[[email protected]](/cdn-cgi/l/email-protection)@@
例 2:
inp_str = "Engineering Discipline"
print ("Input string: \n",inp_str)
print ("Left justified string: \n")
print (inp_str.ljust(30, '*'))
输出:
Input string:
Engineering Discipline
Left justified string:
Engineering Discipline********
numpy string ljust()函数
语法:
NumPy_array.char.ljust(input_array, length, fill_char)
参数:
- 输入数组
- length :提供的 length 的值基本上用来对齐给定长度的字符串。
- fill_char :可选参数。这些是需要在字符串周围填充的字符。
举例:
import numpy as np
input_arr = np.array(['Safa', 'Aman'])
print ("Input array : ", input_arr)
len1 = 10
output_arr = np.char.ljust(input_arr, len1, fillchar ='%')
print ("Output array: ", output_arr)
输出:
Input array : ['Safa' 'Aman']
Output array: ['Safa%%%%%%' 'Aman%%%%%%']
2.Python 字符串 rjust()函数
Python 的 rjust()函数接受用于填充输入字符串的字符。
然后，它替换该字符，并在输入字符串的左侧进行填充。
语法:
String.rjust(length,fill_char)
参数:
- length :提供的 length 的值基本上用来对齐给定长度的字符串。
- fill_char :可选参数。这些是需要在字符串周围填充的字符。
从 rjust()函数返回的值:
rjust()函数返回一个新字符串，并将给定的 fill_char 替换到原始字符串的左侧。
例 1:
input_string = 'Mary'
size = 7
fill_char = '@'
print(input_string.rjust(size, fill_char))
输出:
@@@Mary
例 2:
inp_str = "Engineering Discipline"
print ("Input string: \n",inp_str)
print ("Left justified string: \n")
print (inp_str.rjust(30, '*'))
输出:
Input string:
Engineering Discipline
Left justified string:
********Engineering Discipline
NumPy 字符串 rjust()函数
语法:
NumPy_array.char.rjust(input_array, length, fill_char)
参数:
- 输入数组
- length :提供的 length 的值基本上用来对齐给定长度的字符串。
- fill_char :可选参数。这些是需要在字符串周围填充的字符。
举例:
import numpy as np
input_arr = np.array(['Safa', 'Aman'])
print ("Input array : ", input_arr)
len1 = 10
output_arr = np.char.rjust(input_arr, len1, fillchar ='%')
print ("Output array: ", output_arr)
输出:
Input array : ['Safa' 'Aman']
Output array: ['%%%%%%Safa' '%%%%%%Aman']
结论
因此，在本文中，我们已经理解了 Python 的字符串 ljust()和 rjust()函数的功能。
参考
字符串 ljust()和 rjust()函数
Python 字符串 lower()方法
原文：https://www.askpython.com/python/string/python-string-lower
Python String lower()方法将字符串对象转换成小写字符串。这是 Python 中内置的字符串函数之一。因为在 Python 中字符串是不可变的，所以这个方法只返回原始字符串的一个副本。
Python String lower()方法的语法和用法
格式:
str_copy = str_orig.lower()
这里，str_copy是str_orig的小写字符串。
a = "HELLO FROM ASKPYTHON"
b = a.lower()
print(a)
print(b)
输出
HELLO FROM ASKPYTHON
hello from askpython
这将使整个输出字符串变成小写，即使输入字符串只有一部分是大写的。
a = "Hello from AskPython"
b = a.lower()
print(a)
print(b)
输出
Hello from AskPython
hello from askpython
由于 Python3 将任何字符串文字作为 Unicode 处理，因此它也可以小写不同的语言。
>>> string = 'Километр'
>>> string
'Километр'
>>> string.lower()
'километр'
熊猫模块–下部()
熊猫模块中也有一个lower()方法，其功能与原生 Python 方法相同，但用于熊猫对象。
格式:
pandas_copy = pandas_object.str.lower()
这里有一个例子可以说明这一点:
>>> import pandas as pd
>>>
>>> s = pd.Series(['Hello', 'from', 'ASKPYTHON'])
>>> print(s)
0 Hello
1 from
2 ASKPYTHON
dtype: object
>>>
>>> print(s.str.lower())
0 hello
1 from
2 askpython
dtype: object
>>> print(s)
0 Hello
1 from
2 ASKPYTHON
dtype: object
正如您所观察到的，原始对象保持不变，我们得到一个全部是小写字符串的新对象！
参考
Python 字符串分区()方法
原文：https://www.askpython.com/python/string/python-string-partition
在本文中，我们将看看 Python string partition()方法的功能。 Python String 引入了大量的内置函数来操作输入的字符串/数据。
Python 字符串分区入门()
Python String partition()方法用于在输入分隔符最开始/第一次出现时分割输入字符串。
语法:
input_string.partition(separator)
说明:
一旦解释器发现输入字符串中作为参数提供的分隔符，Python string partition()函数就会完成剩下的工作。它在一个元组中将字符串分成三个部分:
- 字符串在分隔符之前的部分
- 分隔符
- 分隔符后的字符串
例 1:
inp_str = "Evan and Norah are good friends and they study in the same college."
res1 = inp_str.partition('friends')
print(res1,'\n')
在上面的代码片段中，inp_str 在分隔符处进行分区: friends 。
输出:
('Evan and Norah are good ', 'friends', ' and they study in the same college.')
例 2:
inp_str = "Evan and Norah are good friends and they study in the same college."
res2 = inp_str.partition('black')
print(res2,'\n')
在上面的代码片段中，我们试图在分隔符处分割字符串:黑色。
但是，正如我们可以观察到的，字符串' black '不在输入字符串中，所以在这种情况下，函数返回一个包含整个输入字符串和两个空字符串的元组。
输出:
('Evan and Norah are good friends and they study in the same college.', '', '')
例 3:
inp_str = "Evan and Norah are good friends and they study in the same college."
res3 = inp_str.partition('and')
print(res3,'\n')
在上面的例子中，分隔符'和'在输入字符串中出现了两次。在这种情况下，partition()函数在输入分隔符的first occurrence周围分割输入字符串。
输出:
('Evan ', 'and', ' Norah are good friends and they study in the same college.')
Python NumPy partition()方法
NumPy 模块 为我们提供了 numpy.partition()方法对输入数组进行相应的拆分。
numpy.partition()方法在参数列表中提供的第 n 个元素周围拆分输入数组，
- 一调用 numpy.partition()方法，它首先创建输入数组的副本，
sorts创建数组元素 - 比第 n 个元素小的元素被放置在它之前
- 等于或大于第 n 个元素的元素被放置在其之后
语法:
numpy.partition(input_array, nth position, axis=-1, kind_of_sort='introselect', order=None)
nth position:需要对其进行分区的元素的索引。kind_of_sort:您想要执行的排序类型。默认值为'选择。axis:元素排序的轴。默认值为 -1 。
举例:
import numpy
inp = numpy.array([10, 90, 0, 50, 12, 100, -87])
print ("Elements of input array before partition:\n", inp)
res = numpy.partition(inp, 1)
print ("Elements of array after partition:\n", res)
在上面这段代码中，partition()方法创建了一个输入数组的副本，并在内部对其进行排序。
排序后，输入数组看起来像:-87，0，10，12，50，90，100。
其中，围绕排序数组第一个位置的元素进行划分，即 0 。
之后，所有小于 0 的元素被放置在 0 的前面/左边，所有大于 0 的元素被放置在分隔符元素(0)的右边。
注:数组中元素出现的顺序没有定义。
输出:
Elements of input array before partition:
[ 10 90 0 50 12 100 -87]
Elements of array after partition:
[-87 0 90 50 12 100 10]
Python Pandas partition()方法
熊猫模块 为我们提供了Series.str.partition()方法来拆分输入分隔符周围的字符串。
语法:
Series.str.partition(delimiter='', expand=True/False)
delimiter:包含数据值被分割的分隔符。expand:如果为 false，则以元组的形式返回分隔后的字符串。否则，它返回分隔符周围两个单独列中的值。默认值为真。
输入 csv 文件:
Input file
举例:
import pandas
res = pandas.read_csv("C:\\Users\\HP\\Desktop\\Book1.csv")
res["Details"]= res["Details"].str.partition(":",False)
print(res)
输出:
Output Partition
结论
在本文中，我们已经了解了 Python partition()方法在不同场景下的工作方式。
参考
- Python 字符串分割()方法
Python 字符串 split()函数
原文：https://www.askpython.com/python/string/python-string-split-function
Python string split()函数允许用户拆分字符串列表。当我们处理 CSV 数据时，这非常有用。
String split()函数语法
string.split(separator, maxsplit)
- 分隔符:它基本上是作为一个分隔符，在指定的分隔符值处分割字符串。
- maxsplit :这是字符串可以拆分的上限
举例: split()函数
input= 'Engineering comprises of many courses.'
# splits at space
print(input.split())
输出:
['Engineering', 'comprises', 'of', 'many', 'courses.']
示例:使用“，”作为分隔符
input = "hello, Engineering and Medical, are two different disciplines"
result = input.split(",")
print(result)
输出:
['hello', 'Engineering and Medical', 'are two different disciplines']
示例:设置 maxsplit = value
input = "hello, Engineering and Medical, are two different disciplines"
# maxsplit = 1, returns a list with 2 elements..
i = input.split(",", 1)
print(i)
输出:
['hello', ' Engineering and Medical, are two different disciplines']
多行字符串分割()函数
input = 'Engineering discipline\nCommerce and Science\nYes and No'
result = input.split('\n')
for x in result:
print(x)
输出:
Engineering discipline
Commerce and Science
Yes and No
split()函数中的多字符分隔符
input = 'Engineering||Science||Commerce'
result = input.split('||')
print(result)
输出:
['Engineering', 'Science', 'Commerce']
str.split()函数
Python 字符串 split()函数也可以与类引用一起使用。我们必须将源字符串传递给 split。
print(str.split('SAFA', sep='A'))
print(str.split('AMURA', sep='A', maxsplit=3))
CSV-字符串 split()函数
csv_input = input('Enter CSV Data\n')
csv_output1 = csv_input.split(sep=',')
print('\nList of inputs =', csv_output1)
输出:
Enter CSV Data
Android, Kotlin, Perl, Go
List of inputs = ['Android', ' Kotlin', ' Perl', ' Go']
结论
Python string split()函数在将基于分隔符的值拆分成字符串列表时非常有用。
参考
- Python split()函数
- 字符串函数文档
如何使用 Python 字符串 splitlines()方法
原文：https://www.askpython.com/python/string/python-string-splitlines-method
介绍
今天在本教程中，我们将讨论Python 字符串 splitlines()方法。
首先，让我们看看这个方法的基本定义。
Python 字符串 splitlines()方法
Python string splitlines()是一个内置方法，它返回字符串中的行列表，在行边界处断开。换行符不包括在结果列表中，除非keepends被称为真。
下面给出了在 Python 中使用splitlines()方法的语法。
str.splitlines([keepends])
这里，
- str 是一个字符串对象，我们需要把它分成一系列的行，
- 保持端点当设置
True时，线条边界包含在结果列表元素中。否则，不包括换行符。
线边界字符及其各自的描述如下表所示。
线边界表
| 性格；角色；字母 | Python 中的表示 |
| \n | 换行 |
| \r | 回车 |
| \r\n | 回车+换行 |
| \v 或\x0b | 线条制表(Python 3.2 以后) |
| \f 或\x0c | 表单提要(Python 3.2 以后) |
| \x1c | 文件分隔符 |
| \x1d | 组分隔符 |
| \x1e | 记录分离器 |
| \x85 | 下一行(C1 控制代码) |
| ** u2028 | 行分隔符 |
| \u2029 | 段落分隔符 |
在 Python 中使用 splitlines()方法
既然我们已经介绍了 Python 中splitlines()方法的基本定义和语法，让我们看一些例子。这有助于我们对题目有一个清晰的理解。
没有保留端
如前所述，不提及 keepends 参数将导致创建一个分割线列表，不包括换行符或边界字符。
看看下面的例子。
#String initialisation
string1 = "Tim\nCharlie\nJohn\nAlan"
string2 = "Welcome\n\nto\r\nAskPython\t!"
string3 = "Keyboard\u2028Monitor\u2029\x1cMouse\x0cCPU\x85Motherboard\x1eSpeakers\r\nUPS"
#without keepends
print(string1.splitlines())
print(string2.splitlines())
print(string3.splitlines())
输出:
['Tim', 'Charlie', 'John', 'Alan']
['Welcome', '', 'to', 'AskPython\t!']
['Keyboard', 'Monitor', '', 'Mouse', 'CPU', 'Motherboard', 'Speakers', 'UPS']
这里，
- 我们声明了三个字符串，其中包含由不同的换行符分隔的各种单词，
- 我们将它们中的每一个传递给内置的
splitlines()方法，并将 keepends 设置为默认值 (false) 。并打印拆分行的结果列表。
从输出中我们可以看到，由于没有设置 keepends ，所有被分割的行都不包含行边界或边界字符。对于 string2，'\t'包含在单词'Askpython\t'中，因为它不是边界字符(不在表中)。
因此，输出是合理的。
带保持端
如果我们将保持端参数称为True，那么现在分裂的线路将包括各自的线路断路器。
让我们通过将 Python string splitlines()方法中的 keepends 参数设置为True来修改我们之前的代码(没有 keepends)。仔细查看输出，并尝试注意与前一个输出相比的变化。
#String initialisation
string1 = "Tim\nCharlie\nJohn\nAlan"
string2 = "Welcome\n\nto\r\nAskPython\t!"
string3 = "Keyboard\u2028Monitor\u2029\x1cMouse\x0cCPU\x85Motherboard\x1eSpeakers\r\nUPS"
#with keepends
print(string1.splitlines(keepends=True))
print(string2.splitlines(keepends=True))
print(string3.splitlines(keepends=True))
输出:
['Tim\n', 'Charlie\n', 'John\n', 'Alan']
['Welcome\n', '\n', 'to\r\n', 'AskPython\t!']
['Keyboard\u2028', 'Monitor\u2029', '\x1c', 'Mouse\x0c', 'CPU\x85', 'Motherboard\x1e', 'Speakers\r\n', 'UPS']
正如所料，对于相同的字符串,splitlines()输出包括所有的边界字符。
结论
因此，在本教程中，我们开始了解内置的 Python string splitlines()方法，它做什么以及如何工作。
关于这个话题的任何问题，请在下面的评论中发表。
参考
- 关于 string splitlines() 的 Python 文档，
- Python 字符串 split lines()–日志开发帖子，
- 如何在新行字符上拆分 python 字符串–堆栈溢出问题。
Python 字符串 startswith()函数
原文：https://www.askpython.com/python/string/python-string-startswith-function
Python 中的 String 有内置的函数，可以对字符串执行几乎所有的操作。Python String startswith()函数检查字符串中的特定前缀，否则返回 True else。
要点:
- 返回类型:布尔型，即真或假
- 参数值:有 3 个参数:前缀、开始、结束
| 前缀 | 它可以是要检查的字符串或字符串元组。它区分大小写 |
| 开始 | 它是可选的，用于指定开始检查的起始索引 |
| 结束 | 它是可选的，用于指定检查结束的结束索引 |
Python 字符串 startswith()语法
str_name.startswith()
这里的 str_name 指的是要检查前缀的字符串，strartwith()是一个内置函数。
以()开头的字符串示例
例 1:
text_string = "Engineering and Management are altogether diferent verticals."
resultant = text_string.startswith('Engineering')
print(resultant)
resultant = text_string.startswith('Management ')
print(resultant)
输出:
Output-startswith() Example1
例 2:
text_string = "Engineering and Management are altogether different verticals."
resultant = text_string.startswith('Engineering',0)
print(resultant)
resultant = text_string.startswith('Management',16,60)
print(resultant)
输出:
Output-startswith() Example2
例 3:
str = "Engineering Discipline"
string=str.startswith("Discipline")
print (string)
输出:
False
结论
在本文中，我们已经了解了 substring()函数在各种输入环境下的工作和实现。
参考
- Python 字符串
- Python startswith()函数
- Python 字符串文档
Python 字符串子串
原文：https://www.askpython.com/python/string/python-string-substring
Substring 是字符串的一部分，可以提取并表示为新字符串。在本教程中，我们将学习如何在 Python 中使用子字符串。
1.创建 Python 字符串子字符串
可以使用以下任一方法创建子字符串:
**Slicing****split()**方法
input = 'Engineering Field'
#substring using slice
result = input[5:]
print(result)
#substring using split
result1 = input.split()
print(result1)
输出:
Creation-Substring
Substring Creation Example
2.检查字符串中是否存在子字符串
可以通过以下方法之一检查字符串中是否存在子字符串:
- 通过使用
**in**运算符 - 通过使用
**find()**方法
input = 'Medical Colleges in India.'
#using in operator
if 'India' in input:
print('Substring is present in the input.')
#using find() method
if input.find('Medical Colleges') != -1:
print('Substring is present in the input.')
输出:
Substring is present in the input. Substring is present in the input.
Substring Presence Example
3.用 Python 从字符串中获取子串
以下是从给定字符串中获取子字符串的一些方法:
- 通过使用
**list slicing** - 通过使用
**itertools.combinations()**方法
例 1: 利用列表切片
str = 'Engineering Discipline'
sub1 = str[:3]
sub2 = str[6:]
print ("Resultant substring from the start: ", sub1)
print ("Resultant substring from the end: ", sub2)
输出:
Output-Fetch Substring
例 2 : 使用 itertools.combinations()方法
from itertools import combinations
str1 = "Safa"
print("The original string is : " + str(str1))
result = [str1[a:b] for a, b in combinations(
range(len(str1) + 1), r = 2)]
print("All substrings of string are : " + str(result))
输出:
Output-Fetch Substring 1
4.子字符串在字符串中出现的次数
count()函数用于表示给定字符串中字符/子字符串的数量。
string = 'Engineering Discipline'
print('Count of Sub-string =', string.count('i'))
string1 = 'Aroma Arena'
print('Count of Sub-string =', string1.count('Ar'))
输出:
Output Count Substring
Count Substring
5.获取所有子串的索引
def find_index(str1, substring):
l2 = []
length = len(str1)
index = 0
while index < length:
x = str1.find(substring, index)
if x == -1:
return l2
l2.append(x)
index = x + 1
return l2
string = 'Aroma Arena at the desert Arone.'
print(find_index(string, 'Ar'))
上面的代码片段给出了一个字符串中所有特定子字符串的索引/位置。
输出:
[0, 6, 26]
参考
- Python 子串
- Python 字符串函数文档
Python 字符串交换()方法
原文：https://www.askpython.com/python/string/python-string-swapcase
在本文中，我们将详细介绍 Python String swapcase()函数。 Python String 为我们提供了许多内置的方法来操纵输入数据进行进一步的操作。让我们开始了解这个方法。
Python String swapcase()方法入门
Python 字符串swapcase()函数转换输入字符串中每个字符的大小写。它将所有的小写字符转换成大写字符，反之亦然。
语法:
input_string.swapcase()
例 1:
input_str = "Amazon Prime is a great platform."
res=input_str.swapcase()
print(res)
输出:
aMAZON pRIME IS A GREAT PLATFORM.
例 2:
input_str = "AMAZON PRIME IS A GREAT PLATFORM!!"
res=input_str.swapcase()
print(res)
输出:
amazon prime is a great platform!!
NumPy 字符串交换()函数
Python 的 NumPy 模块 为我们提供了转换输入字母大小写的功能。
numpy.char.swapcase()函数以元素方式转换输入数据字符的大小写。
语法:
numpy.char.swapcase(input_array)
举例:
import numpy
inp_arr = numpy.array(['Engineering', 'Science', 'Commerce', 'A5Z'])
print ("Elements of Input array:\n", inp_arr)
res = numpy.char.swapcase(inp_arr)
print ("Elements of array after swapping the case of each one:\n", res)
注意 : Python numpy.array()函数创建输入元素的数组。
输出:
Elements of Input array:
['Engineering' 'Science' 'Commerce' 'A5Z']
Elements of array after swapping the case of each one:
['eNGINEERING' 'sCIENCE' 'cOMMERCE' 'a5z']
熊猫系列 swapcase()函数
Python Pandas 模块 包含各种数据结构来表示数据。一种这样的数据结构是系列。
Pandas 的 Series swapcase()函数使我们能够改变/转换系列中每个字符串的大小写。与 Python string swapcase()函数相比，Pandas swapcase()也可以处理文件，如下例所示。
语法:
<Series>.str.swapcase()
输入。csv 文件:
Input CSV file
举例:
import pandas
inp_file = pandas.read_csv("C://Users//HP//Desktop//Book1.csv")
inp_file["Name"] = inp_file["Name"].str.swapcase()
print(inp_file)
pandas.read_csv(file_path)方法用于输入和读取文件。csv 扩展名。
InP _ file[" Name "]. str . swap case()方法将出现在的名称列下的每个字符串的大小写进行转换。csv 文件。
输出:
Output CSV file
结论
在本文中，我们已经了解了 Python swapcase()方法与 String、NumPy 和 Pandas 模块的工作原理。
参考
- Python swapcase()函数
Python 字符串 title()方法
原文：https://www.askpython.com/python/string/python-string-title
在本文中，我们将了解 String title() 方法的功能。 Python 字符串 包含了大量处理数据的内置函数。我们最近还研究了确认字符串标题大小写的方法 istitle() 。
Python String title()方法入门
Python String title() 方法基本上是将输入字符串转换为标题大小写，即它只将输入字符串中每个单词的第一个字符转换为大写，其余字符转换为小写。
语法:
input_string.title()
举例:
inp1 = 'Amazon is a wonderful platform.'
res1 = inp1.title()
print(res1)
在这个例子中，如上所示，只有输入字符串中每个单词的第一个字符被转换为大写。
输出:
Amazon Is A Wonderful Platform.
例 2:
inp1 = 'AMAZON IS A WONDERFUL PLATFORM.'
print("Input String:\n",inp1)
res1 = inp1.title()
print("Converted String:\n",res1)
除了第一个字母以外的所有其他字符都被转换成小写，如上所示。
输出:
Input String:
AMAZON IS A WONDERFUL PLATFORM.
Converted String:
Amazon Is A Wonderful Platform.
例 3:
inp1 = '21wellness'
print("Input String:\n",inp1)
res1 = inp1.title()
print("Converted String:\n",res1)
单词前有数字或编号不会影响功能的运行。数字后面的字符被认为是第一个字符。
输出:
Input String:
21wellness
Converted String:
21Wellness
NumPy title()方法
NumPy 模块 有 numpy.char.title() 函数向标题格输入数据。
**numpy.char.title()**方法将输入数组中每个元素的第一个字母转换成大写，并将每个单词的其余字符转换成小写。
语法:
numpy.char.title(input_array)
举例:
import numpy
inp = numpy.array(['TAJ', 'mahaL', '4$road', 'senTosA'])
print ("Input Array:\n", inp)
res = numpy.char.title(inp)
print ("Resultant Array:\n", res)
输出:
Input Array:
['TAJ' 'mahaL' '4$road' 'senTosA']
Resultant Array:
['Taj' 'Mahal' '4$Road' 'Sentosa']
熊猫标题()方法
熊猫模块 内置了 Series.str.title() 方法来对输入数据集的每一项进行标题 case。
语法:
Series.str.title()
Series.str.title()方法将数据集每个元素的第一个字母转换成大写，并将每个单词的其余字符转换成小写。
输入 csv 文件:
Input file-title()
举例:
import pandas
inp = pandas.read_csv("C:\\Users\\HP\\Desktop\\Book1.csv")
inp["Details"]= inp["Details"].str.title()
inp
输出:
Details Number
0 John:Pune 21
1 Bran:Satara 22
2 Sam:Chennai 24
3 Rhey:Delhi 12
4 Cranny:Karnatak 26
结论
在本文中，我们已经了解了 Python title()函数的工作原理。
参考
Python String title()方法
Python 字符串翻译()
原文：https://www.askpython.com/python/string/python-string-translate
Python 的字符串类str.translate()的内置方法用于将字符串映射到翻译表。 translate() 方法只是使用转换表规则对其进行转换。
让我们进一步了解本文中的方法。
Python 字符串翻译()的语法
由于 translate() 函数返回一个新的字符串，字符串中的每个字符都用给定的翻译表替换，所以它的输入是一个字符串和一个表，返回一个字符串。
但是，由于这是一个属于str类的方法，我们只使用输入字符串对象调用它们。
out_str = in_str.translate(translation_table)
这里，translation_table是包含相关映射的翻译表。
虽然我们知道什么是翻译表，但我们还不知道它是如何构造的。让我们也理解这一点。
使用 maketrans()构造转换表
我们可以使用maketrans()方法制作转换表。
因为任何映射都可以作为翻译表，所以现有的 Python 字典也可以成为翻译表。
maketrans(): 的语法
我们总是使用str.maketrans()调用 maketrans()，其中str是表示 Python 的 string 类的内置关键字。
如果只有一个参数，它必须是一个字典映射(dict_map ) Unicode 序数(整数)或字符(长度为 1 的字符串)到 Unicode 序数、字符串(任意长度)或None。字符键将被转换成序数。
translation = str.maketrans(dict_map)
如果有两个参数，它们必须是等长的字符串(str_x和str_y)，在结果字典中，x 中的每个字符都会映射到 y 中相同位置的字符。
translation = str.maketrans(str_x, str_y)
如果有第三个参数，它必须是一个字符串(str_z)，其字符将被映射到结果中的None。
translation = str.maketrans(str_x, str_y, str_z)
进行翻译
在使用 maketrans() 构建转换表之后，我们现在可以使用 python string translate() 执行从输入字符串到输出字符串的转换。
让我们举例说明使用maketrans()的所有三种方式，让你的理解更加完整。
使用字典映射
# Input string
inp_str = 'Hello from AskPython'
# Create a Dictionary for the mapping
dict_map = dict()
# We shift every letter from A-z by 9 units
# using ord() to get their ASCII values
for i in range(ord('A'), ord('z')):
dict_map[chr(i)] = chr(i + 9)
# Convert the dictionary mapping to a translation table
translation = str.maketrans(dict_map)
# Perform the translation
out_str = inp_str.translate(translation)
print(out_str)
输出将是包含右移 9 位的每个字符的字符串。
输出:
Qnuux o{xv J|tYA}qxw
使用直接映射
下面是一个更简单的例子，它利用直接映射并使用两个参数构造一个转换表，然后将它们传递给输入字符串 translate()函数。
s = 'ABCDBCA'
translation = s.maketrans('A', 'a')
print(s.translate(translation))
translation = s.maketrans('ABCD', 'abcd')
print(s.translate(translation))
这会将第一个' A 字符翻译成' a ，然后将' ABCD 转换成' abcd ，如下所示。
输出:
aBCDBCa
abcdbca
同样，由于该选项指定两个字符串的长度相同，任何其他操作都会引发一个ValueError异常。
s = 'ABCDBCA'
translation = s.maketrans('Ab', 'a')
print(s.translate(translation))
输出:
ValueError: the first two maketrans arguments must have equal length
使用无映射
下面是一个更简单的例子，它通过使用 3 个参数调用maketrans()来利用None映射。
# Input string
inp_str = 'Hello from AskPython'
translation = str.maketrans('As', 'ab', 'e')
# Perform the translation
out_str = inp_str.translate(translation)
print(out_str)
这将把‘As’替换为‘ab’，同时把‘e’替换为None，有效地从字符串中删除该字符。
输出:
Hllo from abkPython
直接构造一个字典映射
我们可以在调用函数时构造一个直接映射到maketrans()的字典。
# Input string
inp_str = 'Hello from AskPython'
translation = str.maketrans({ord('A'): 'a', ord('s'): 'b', ord('e'): None})
# Perform the translation
out_str = inp_str.translate(translation)
print(out_str)
这将给出与前面代码片段相同的输出，因为它们有相同的翻译表。
输出:
Hllo from abkPython
注意:我们可以将一个 Unicode 值(映射字典中的ord()键)映射到任意字符串的，这与将字符串作为参数传递给maketrans()不同。因此，像{ord('A'): 'hello'}这样的映射是有效的，并且用“ hello ”替换“ A ”。
结论
在本文中，我们学习了如何使用 python string translate()方法基于 python 中的翻译表执行字符串翻译。我们还研究了如何使用各种方法构建这样一个表。
参考
- 【maketrans()的 Python 文档
- Python 文档用于翻译()
- journal dev translate()上的文章
Python 字符串 upper()函数
原文：https://www.askpython.com/python/string/python-string-upper-function
Python String upper()函数将完整的字符串转换成大写，并返回一个新的字符串。字符串在 String 中是不可变的，所以原来的字符串值保持不变。
要点:
- 返回类型:字符串
- 参数值:没有参数可以传入 upper()函数。
- 将整个字符串转换成大写
- 它不会修改原始字符串。修改后的字符串可以用新的变量名保存。
示例:给定字符串-“祝您愉快”或“祝您愉快”或“祝您愉快”或“祝您愉快”
使用 upper()函数后的新字符串:“祝您有美好的一天”(针对以上给出的所有字符串)
String upper()语法
str_name.upper()
这里 str_name 指的是输入字符串。并且，upper()是 python 中内置的字符串函数。
str_name = "welcome"
print(str_name.upper()) # WELCOME
String upper()示例
情况 1:字符串是小写的，可能包含数字/特殊字符/空格
str_name = "welcome 2020"
print(str_name.upper()) # WELCOME 2020
str_name = "welcome @2020"
print(str_name.upper()) # WELCOME @2020
情况 2:字符串是大写的，可能包含数字/特殊字符/空格
str_name = "WELCOME 2020"
print(str_name.upper()) # WELCOME 2020
str_name = "WELCOME @2020"
print(str_name.upper()) # WELCOME @2020
情况 3:字符串中每个单词只有第一个字母是大写的
str_name = "Python"
print(str_name.upper()) # PYTHON
str_name = "Python 2020"
print(str_name.upper()) # PYTHON 2020
情况 4:字符串只包含数字或特殊字符
str_name = "2020"
print(str_name.upper()) # 2020
str_name = "@$&"
print(str_name.upper()) # @$&
情况 5:字符串为空
str_name = ' '
print(str_name.upper()) # (Will not give any error and show empty space as output)
参考
- Python 字符串转换为大写–str . upper()
- Python 字符串内置函数
Python 字符串 zfill()
原文：https://www.askpython.com/python/string/python-string-zfill
Python string zfill() 方法用于在字符串左边填充零，直到达到特定的宽度。这是向字符串添加填充的最“Pythonic 式”的方法，而不是使用 for 循环手动迭代。
Python 字符串 zfill()方法的语法
Python string zfill() 函数属于 string 类，只能在 String 对象上使用。
它将宽度作为参数，并在字符串的左边(字符串的开始)填充零，直到达到指定的宽度。
如果 width < len(str) ，则返回原字符串。否则，由于 Python 字符串是不可变的，这个函数返回一个新的字符串。
new_str = str.zfill(width)
如果有前导符号( +/- )，则在符号后添加填充，即使在新字符串中也保持前导符号的位置。
现在我们来看一些例子。
如果没有前导符号，则将零填充到左侧。
>>> a = "AskPython"
>>> a.zfill(15)
'00000AskPython'
如您所见，零被填充到左侧，新字符串的长度为 15 。
如果指定的宽度小于 len("AskPython") ，那么我们得到原始字符串。
>>> a = "AskPython"
>>> a.zfill(len(a) - 1)
'AskPython'
>>> a.zfill(len(a) - 1) == a
True
如果有一个前导 +/- 符号，则在符号后补零。
>>> a = "+123456"
>>> a.zfill(len(a) - 1)
'+123456'
>>> a.zfill(10)
'+000123456'
>>> a = "-123456"
>>> a.zfill(10)
'-000123456'
Python 字符串 zfill()的替代
除了 zfill() 之外，我们还可以使用一些其他方法在字符串中引入零填充。
使用 str.rjust()
与 str.zfill() 类似， str.rjust() 也可以给字符串填充，但也允许我们指定填充字符串的字符。看看下面的例子。
>>> a = "AskPython"
>>> a.rjust(15, "0")
'00000AskPython'
>>> a.rjust(15, "1")
'11111AskPython'
这里，我们介绍了使用rjust(width, '0')填充零，使用rjust(width, '1')填充一个。您可以用任何字符替换这些数字。
使用打印字符串格式
如果你正在处理实数，你也可以使用 Python f-strings (来自 Python 3.6 和更高版本)返回一个零填充字符串。
>>> a = 1.414
>>> print(f'{a:013}')
'000000001.414'
您可以在官方文档中了解更多关于打印字符串格式的信息。
参考
- zfill()上的 Python 文档
- zfill()上的 StackOverflow 问题
- zfill()上的 JournalDev 文章
使用 Python strptime()将字符串转换为日期时间
所以今天，我们将讨论如何使用 Python strptime()方法将字符串转换成日期时间。
让我们开始吧。
Python strptime()方法
Python 的strptime()方法在datetime和time模块中都可用。它用于根据指定的格式将给定的字符串解析成 datetime 或 time 对象。
对于这两个模块来说，这个函数的用法是相同的，唯一的区别是返回的对象的类型。让我们仔细看看使用它的语法。
对于日期时间模块，下面给出了使用strptime()方法的语法。
datetime.strptime(date_string, format)
上面的语句返回一个按照指定格式解析的date_string对应的datetime对象。
对于时间模块，使用strptime()的语法非常相似。
time.strptime(string[, format])
在这里，该方法做同样的工作，只是这里返回值是一个由gmtime()或localtime()返回的struct_time对象。
对于这两种情况，格式参数使用的指令与 strftime() 使用的指令相同，如下表格式所示。格式参数必须是字符串，并且有默认值"%a %b %d %H:%M:%S %Y"。如果字符串不能按照给定的格式进行解析，或者解析后有多余的数据，就会引发一个ValueError。
格式化表格
指定格式参数时，必须遵循下面给出的格式表来使用适当的指令。
| 指示的 | 指令的含义 | 示例输出 |
|---|---|---|
| %A | Weekday 作为区域设置的全名。 | 星期三 |
| %a | 工作日作为区域设置的缩写名称。 | 杀了他，Wed |
| %w | 以十进制数表示的工作日，其中 0 表示星期日，6 表示星期六。 | 0,1,2,3,4…6 |
| %d | 一个月中的某一天，以零填充的十进制数表示。 | 01,02,03…31 |
| %-d | 十进制数字表示的一个月中的某一天。(特定于平台) | 1,2,3… |
| %b | 月份作为区域设置的缩写名称。 | 瑕疵 |
| %B | 月份作为区域设置的全名。 | 三月 |
| %m | 以零填充的十进制数表示的月份。 | 01,02…12 |
| %-m | 十进制数形式的月份。(特定于平台) | 1,2,…12 |
| %y | 没有世纪作为零填充十进制数的年份。 | 20(2020 年) |
| %Y | 以世纪为小数的年份。 | 2020，2021 等等。 |
| %H | 以零填充的十进制数表示的小时(24 小时制)。 | 01, 02, … |
| %-H | 十进制数形式的小时(24 小时制)。(特定于平台) | 1,2,3,… |
| %I | 以零填充的十进制数表示的小时(12 小时制)。 | 01, 02, 03, … |
| %-我 | 十进制数形式的小时(12 小时制)。(特定于平台) | 1, 2, 3 … |
| %p | 等同于 AM 或 PM 的区域设置。 | 上午，下午 |
| %M | 以零填充的十进制数表示的分钟。 | 01, 02, …59 |
| %-M | 十进制数形式的分钟。(特定于平台) | 1,2,3,…59 |
| %S | 秒，以零填充的十进制数表示。 | 01, 02,…59 |
| %-S | 秒为十进制数。(特定于平台) | 1, 2, …59 |
| %f | 微秒作为十进制数，左边补零。 | 000000 |
| %z | +HHMM 或-HHMM 形式的 UTC 偏移量(如果对象是简单的，则为空字符串)。 | (空)，+0000，-0400，+1030 |
| %Z | 时区名称(如果对象是简单的，则为空字符串)。 | (空)、UTC、is、CST |
| %j | 以零填充的十进制数表示的一年中的某一天。 | 1, 2, 3, … 366 |
| %-j | 以十进制数表示的一年中的某一天。(特定于平台) | 1, 2, 3, … 366 |
| %U | 一年中的周数(星期日是一周的第一天)，以零填充的十进制数表示。新年中第一个星期日之前的所有日子都被视为第 0 周。 | 1, 2, 3,… 53 |
| %W | 以十进制数表示的一年中的周数(星期一是一周的第一天)。新年中第一个星期一之前的所有日子都被视为第 0 周。 | 1, 2, 3,… 53 |
| %c | 区域设置的适当日期和时间表示。 | 2020 年 5 月 6 日星期三 12 时 23 分 56 秒 |
| %x | 区域设置的适当日期表示。 | 05/06/20 |
| %X | 区域设置的适当时间表示。 | 12:23:56 |
| %% | 文字“%”字符。 | % |
Source: Strftime() Official Homepage
使用 strptime()方法
现在我们已经熟悉了对 datetime 和 time 模块使用strptime()方法的语法，让我们看看如何使用它。
1. time.strptime()
在下面的例子中，我们将把一个给定的字符串转换成一个 time 对象。
import time
time_string = "06/05/2020 12:06:58"
obj = time.strptime(time_string, "%d/%m/%Y %H:%M:%S")
print(type(obj))
print(obj)
#parsing using default formatting: %a %b %d %H:%M:%S %Y
def_obj = time.strptime("Wed May 06 12:06:58 2020")
print(def_obj)
输出:
<class 'time.struct_time'>
time.struct_time(tm_year=2020, tm_mon=5, tm_mday=6, tm_hour=12, tm_min=6, tm_sec=58, tm_wday=2, tm_yday=127, tm_isdst=-1)
time.struct_time(tm_year=2020, tm_mon=5, tm_mday=6, tm_hour=12, tm_min=6, tm_sec=58, tm_wday=2, tm_yday=127, tm_isdst=-1)
这里，time_string是包含相应时间参数的给定字符串。我们使用 strptime()函数按照 "%d/%m/%Y %H:%M:%S" 格式将这个字符串解析到变量obj中。正如所料，obj 的类型是time.struct_time。
接下来，我们还使用默认格式解析了另一个字符串(没有指定 format 参数)。如前所述，在这种情况下默认格式设置为%a %b %d %H:%M:%S %Y。这证明了输出的合理性。
2. datetime.strptime()
现在让我们使用strptime()方法将一个给定的字符串转换成一个日期时间对象。
from datetime import datetime
dt_string = "06//05//2020 12:06:58"
obj = datetime.strptime(dt_string, "%d//%m//%Y %H:%M:%S")
print(type(obj))
print("DateTime object: ", obj)
print("Time object: ", obj.time())
print("Date object: ", obj.date())
输出:
datetime strptime() Output
从上面的输出可以看出，dt_string被成功地转换成了日期时间对象。我们还可以对这个对象使用time()和date()函数来分别获得 datetime.time 和 datetime.date 对象。
让我们看另一个例子，我们使用用户的 input()函数获取日期和时间。
from datetime import datetime
dt_string = str(input("Enter date in dd:mm:yyyy format:"))
try:
obj = datetime.strptime(dt_string, "%d:%m:%Y")
print(obj)
print(obj.strftime("Date:%d Month:%m Year:%Y")) #strftime to format datetime obj
except ValueError as ex:
print("ValueError: ", ex)
输出:
strptime() ValueError
在本例中，我们将dt_string作为用户输入，并使用strptime()方法将其转换为 datetime 对象。我们再次使用strftime()方法将这个对象打印成我们想要的格式。
如果我们不为 strptime()方法提供一个与指定格式匹配的字符串会怎么样？在这种情况下，会引发一个ValueError。看看下面的输出(对于相同的代码),我们这样做了。
Enter date in dd:mm:yyyy format:6/5/20
ValueError: time data '6/5/20' does not match format '%d:%m:%Y'
总结
所以我们今天学习了使用strptime()方法在 Python 中将字符串转换成各种类型。
关于这个主题的任何进一步的问题，请随意使用下面的评论。
参考
- 什么是 Python strftime()函数？，
- Python 时间模块，
- time strptime()–Python 文档，
- datetime strptime()–Python 文档。
Python 结构模块
原文：https://www.askpython.com/python-modules/python-struct-module
Python struct 模块用于提供一个简单的 Python 接口来访问和操作 C 的结构数据类型。如果您需要处理 C 代码，并且没有时间用 C 语言编写工具，因为它是一种低级语言，那么这可能是一个方便的工具。
这个模块可以将 Python 值转换成 C 结构，反之亦然。C 结构被用作 Python bytes 对象，因为 C 中没有被称为对象的东西；只有字节大小的数据结构。
让我们来理解如何使用这个模块来拥有一个到 C 结构的 Python 接口。
Python 结构模块方法
在本模块中，由于我们关注的是 C 结构，所以让我们来看看本模块为我们提供的一些功能。
struct.pack()
这用于将元素打包成 Python 字节串(字节对象)。由于存储模式是基于字节的，基于 C 的程序可以使用来自 Python 程序的pack()的输出。
格式: struct.pack(格式，v1，v2，…)
v1、v2、…是将被打包到字节对象中的值。它们表示 C 结构的字段值。因为具有n字段的 C 结构必须正好具有n值，所以参数必须与格式要求的值完全匹配。
这里，format指的是包装的格式。这是必要的，因为我们需要指定字节串的数据类型，因为它用于 C 代码。下表列出了format最常见的值。我们需要每个值一种格式来指定它的数据类型。
| 格式 | C Datatype | Python 类型 |
| c | 茶 | 长度为 1 的字符串 |
| ? | _Bool | 弯曲件 |
| h | 短的 | 整数 |
| l | 长的 | 整数 |
| i | （同 Internationalorganizations）国际组织 | 整数 |
| f | 漂浮物 | 漂浮物 |
| d | 两倍 | 漂浮物 |
| s | char[] | 线 |
让我们用一些例子来理解这一点。
下面的代码片段使用pack()将 3 个整数 1、2 和 3 存储在一个字节对象中。由于一个整数的大小在我的机器上是 4 字节，所以你看到 3 个 4 字节的块，对应 c 中的 3 个整数。
import struct
# We pack 3 integers, so 'iii' is required
variable = struct.pack('iii', 1, 2, 3)
print(type(variable), variable)
variable_2 = struct.pack('iic', 1, 2, b'A')
print('\n', variable_2)
输出
<class 'bytes'> b'\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00'
b'\x01\x00\x00\x00\x02\x00\x00\x00A'
如果没有传递适当的类型，Python struct 模块将引发异常struct.error。
import struct
# Error!! Incorrect datatype assignment
variable = struct.pack('ccc', 1, 2, 3)
print(type(variable), variable)
输出
struct.error: char format requires a bytes object of length 1
struct.unpack()
Python struct 模块的这个函数根据适当的格式将打包的值解包为其原始表示。这将返回一个元组，其大小等于传递的值的数量，因为 byte 对象被解包以给出元素。
格式: struct.unpack(格式，字符串)
这将根据format格式说明符解包字节string。
这是struct.pack()的反转。让我们用它产生一个旧的字节字符串，并尝试用unpack()取回传递给它的 python 值。
import struct
byte_str = b'\x01\x00\x00\x00\x02\x00\x00\x00A'
# Using the same format specifier as before, since
# we want to get Python values for the same byte-string
tuple_vals = struct.unpack('iic', byte_str)
print(tuple_vals)
输出
(1, 2, b'A')
正如您所看到的，如果我们对pack()和unpack()使用相同的格式说明符，我们确实可以从这个元组中打包我们的旧 Python 值。
struct.calcsize()
此函数使用给定的格式说明符返回结构的字符串表示形式的总大小，以检索数据的类型并计算大小。
格式: struct.calcsize(fmt)
import struct
print('C Integer Size in Bytes:', struct.calcsize('i'))
print('Size of 3 characters in Bytes:', struct.calcsize('ccc'))
输出
C Integer Size in Bytes: 4
Size of 3 characters in Bytes: 3
struct.pack_into()
该函数用于将值打包到 Python 字符串缓冲区，可在ctypes模块中获得。
格式: struct.pack_into(fmt，buffer，offset，v1，v2，…)
这里，fmt指的是格式说明符，一如既往。buffer是字符串缓冲区，现在将包含指定的打包值。您还可以从基本地址中指定一个offset位置，从这里开始打包。
这不会返回任何值，只是将值存储到buffer字符串中。
import struct
import ctypes
# We will create a string buffer having a size
# equal to that of a struct with 'iic' values.
buf_size = struct.calcsize('iic')
# Create the string buffer
buff = ctypes.create_string_buffer(buf_size)
# struct.pack() returns the packed data
struct.pack_into('iic', buff, 0, 1, 2, b'A')
print(buff)
# Display the contents of the buffer
print(buff[:])
输出
<ctypes.c_char_Array_9 object at 0x7f4bccef1040>
b'\x01\x00\x00\x00\x02\x00\x00\x00A'
事实上，我们在缓冲字符串中获得了打包的值。
struct.unpack_from()
与unpack()类似，有一个对应项用于从缓冲字符串中解包值。这与struct.pack_into()相反。
格式: struct.unpack_from(fmt，buffer，offset)
这将返回一组值，类似于struct.unpack()。
import struct
import ctypes
# We will create a string buffer having a size
# equal to that of a struct with 'iic' values.
buf_size = struct.calcsize('iic')
# Create the string buffer
buff = ctypes.create_string_buffer(buf_size)
# struct.pack() returns the packed data
struct.pack_into('iic', buff, 0, 1, 2, b'A')
print(struct.unpack_from('iic', buff, 0))
输出
(1, 2, b'A')
结论
在本文中，我们学习了如何使用 Python struct 模块来处理 C 类型的结构对象。
参考
- 关于 Python 结构模块的 JournalDev 文章
Python 子流程模块
原文：https://www.askpython.com/python-modules/python-subprocess-module
读者朋友们，你们好！在本文中，我们将详细关注 Python 子流程模块。
所以，让我们开始吧！
Python 中的子流程模块是什么？
在了解子流程模块的功能之前，让我们考虑以下情况
通常情况下，我们用 Python 编写代码来自动化一个过程，或者通过一些 UI 表单或者任何与数据相关的表单来获得不需要人工干预的结果。但是，如果我们需要获得某些操作或功能的系统级信息，该怎么办呢？我们如何在 Python 中处理系统级脚本？
这就是Python subprocess module出现的时候。
使用子流程模块，我们可以处理 Python 代码中的系统级脚本。它允许我们与输入建立联系。系统进程的输出以及错误管道和代码。
子流程模块包含在 Python 环境中运行系统级脚本的各种方法:
- subprocess.call()
- subprocess.run()
- subprocess . check _ output()
- 子流程。Popen() 和通信()函数
现在让我们一个一个来看看吧！
1.subprocess.call()函数
为了使用与子流程模块相关的功能，我们需要将模块导入到 Python 环境中。
subprocess.call() 函数运行作为参数的命令，并返回代码执行成功与否的值。
看看下面的语法！
subprocess.call(arguments, shell=True)
例 01:
在下面的例子中，我们试图通过 Python 脚本执行“echo Hello world”。
同样，对于 call()函数，第一个参数(echo)被视为可执行命令，第一个参数之后的参数被视为命令行参数。
此外，我们需要指定 shell = True ，以便参数被视为字符串。如果设置为 False，参数将被视为路径或文件路径。
import subprocess
print(subprocess.call(["echo" , "Hello world"],shell=True))
输出:
如下所示，它返回 0 作为返回代码。代码返回的任何其他值表示命令运行不成功。
"Hello world"
0
例 02:
在本例中，我们通过 python 脚本执行了命令“ls -l”。
import subprocess
subprocess.call(["ls","-l"],shell=True)
输出:
-rw-r--r-- 1 smulani 1049033 Feb 27 10:40 check.py
2.subprocess.run()命令
如上所示，call()函数只返回所执行命令的返回代码。它没有帮助我们检查输入和检查参数。
同样，我们有 subprocess.run() 函数帮助我们在 python 代码中执行 bash 或系统脚本，并返回命令的返回代码。
此外，它还返回传递给函数的参数。这样，它可以帮助我们验证系统脚本的输入。
举例:
import subprocess
print(subprocess.run(["echo","Hello World"],shell=True))
输出:
"Hello World"
CompletedProcess(args=['echo', 'Hello World'], returncode=0)
3.子流程。Popen()函数
subprocess.Popen()功能使我们能够在内部以全新的过程执行子程序。此外，这可以用于在 python 中执行 shell 命令。
语法:
subprocess.Popen(arguments, stdout=subprocess.PIPE,stderr=subprocess.PIPE,shell=True)
- stdout:命令的输出值
- stderr:命令返回的错误
推荐阅读——Python stdin，stdout，stderr
举例:
import subprocess
process = subprocess.Popen(
['echo', 'Hello World'],shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
stdout, stderr = process.communicate()
print(stdout)
这里，我们还使用了 communicate() 函数。这个函数帮助我们直接从流程中读取和获取脚本的输入、输出和错误值，如上所示。
输出:
b'"Hello World"\r\n'
结论
到此，我们就结束了这个话题。如果你遇到任何问题，欢迎在下面评论。更多与 Python 相关的文章，敬请关注我们。
在那之前，学习愉快！！🙂
如何使用 Python sum()函数
原文：https://www.askpython.com/python/built-in-methods/python-sum-method
介绍
在本教程中，我们将讨论 Python sum()方法。
Python sum()方法是一个内置方法，它返回传递的 iterable 的所有元素的总和。
Python sum()函数
让我们看看在 Python 中使用 sum()方法的语法。
sum(iterable[, start])
这里，
- iterable 可以是任何包含我们需要计算总和的值的 iterable 对象。它可以是列表、元组或字典，
- start 是将要进行加法运算的初始值。默认情况下，起始值设置为 0 。
现在让我们看一些例子来清楚地理解这个方法的使用和工作。
对列表、元组、复数、浮点数等使用 sum()。
如前所述，sum()方法可以计算以 list、 tuple 或 dictionary 即任意 iterable 形式传递的值的总和。但条件是，iterable 应该包含某个值，否则，会引发一个错误。
让我们通过寻找整数列表、元组列表、字典列表和复数列表的元素的和来熟悉该方法。
#using built-in sum() in Python
list1=[1,2,3,4,5]
tuple1=(10,20,30)
dict1={ 0:11, 1:22, 2:33, 3:44 }
complx_nums=[ 4+3j, 7+5j, 8+3j]
print("sum of list elements:",sum(list1,5))
print("sum of tuple elements:", sum(tuple1))
print("sum of dictionary keys:", sum(dict1))
print("sum of complex numbers:", sum(complx_nums))
输出:
sum of list elements: 20
sum of tuple elements: 60
sum of dictionary keys: 6
sum of complex numbers: (19+11j)
这里，
- 我们首先用一些值初始化列表 1 、元组 1 、字典 1 和 complx_num ，
- 然后我们简单地将这些 iterable 分别传递给
sum()方法， - 为了计算列表 1 元素的总和，我们设置了一个起始值 5 ，对于其余的，我们不传递任何起始参数(默认设置为 0 )。
因此，我们得到了期望的输出。对于每种情况，我们得到各自的可迭代元素的和。
Python sum()与 NumPy sum()
Python 中的 NumPy 模块中定义了一个sum()方法。它用于计算 NumPy 数组元素的和。但是，这个方法也可以找到 python 中任何其他包含一些值的 iterable 的元素之和。
让我们比较一下 Python 中对于一些可迭代对象的sum()和numpy.sum()的输出。
#numpy sum() vs python sum()
import numpy as np
list1=[1,2,3,4,5]
np_arr = np.array([1,2,3,4,5])
print("Built-in sum() result:",sum(list1))
print("numpy sum() for np array:",np.sum(np_arr))
print("numpy sum() for list:",np.sum(list1))
输出:
Built-in sum() result: 15
numpy sum() for np array: 15
numpy sum() for list: 15
正如我们所见，sum()和np.sum()方法为列表 list1 返回相同的结果。
对于计算列表、元组和字典等可迭代对象的总和，内置的sum()方法比 numpy 的 sum()方法更快更容易使用。
但是当涉及到 numpy 数组时，np.sum()方法似乎更快更可靠。这仅仅是因为 NumPy 使用了一种矢量化的方法。
结论
因此，在本教程中，我们了解了 Python 中内置的sum()方法，以及 Python sum()和 numpy.sum()方法之间的比较。我希望你现在对这个方法有一个清楚的了解。
对于任何进一步的问题，请随意共同以下。
参考
- Python 文档中关于 sum()的 Python ，
- Python 的 sum vs. NumPy 的 NumPy . sum–stack overflow 问题，
- python sum()–日志开发帖子。
Python 开关案例:2 个备选实现
原文：https://www.askpython.com/python/python-switch-case-implementation
Python 不支持 switch-case 语句。有人提议在 PEP-3103 中引入 Python switch case 语句，但遭到拒绝，因为它没有增加太多价值。
我们可以使用 if-else-elif 语句轻松实现 switch-case 语句逻辑。然而，我们可以使用定制代码在 Python 中实现类似开关情况的行为。
用 Python 实现 Switch-Case
在 Python 中有两种方法来实现切换情况行为。
- 使用字典
- 动态功能
1.使用字典实现 Python 开关 Case
我们可以创建一个字典，其中键是大小写，值是结果。我们将使用默认值调用 dictionary get()方法来实现没有匹配案例时的场景。
假设我们有一个 if-else 块。
print("Choices:\n 1 - Email\n 2 - SMS\n 3 - Push Notification")
x = input("Please enter your choice:\n")
x = int(x)
if x is 1:
print('sending email')
elif x is 2:
print('sending sms')
elif x is 3:
print('sending push notification')
else:
print('wrong choice')
现在，我们想使用字典将它转换成开关情况行为。
print("Choices:\n 1 - Email\n 2 - SMS\n 3 - Push Notification")
x = input("Please enter your choice:\n")
x = int(x)
choices_dict = {1: 'sending email', 2: 'sending sms', 3: 'sending push notification'}
print(choices_dict.get(x, 'wrong choice'))
Python Switch Case Implementation
2.用动态函数实现 Python 开关盒
上述实现适用于简单的打印语句。但是，大多数情况下，我们在 if-else 块中执行一些方法，然后字典将不会作为开关情况替换。
假设我们有下面的 if-else 块来对输入整数执行一些操作。
import math
x = input("Please enter an integer:\n")
x = int(x)
print("Choices:\n 1 - Square\n 2 - Cube\n 3 - Square Root")
choice = input("Please enter your choice:\n")
choice = int(choice)
if choice is 1:
print(math.pow(x, 2))
elif choice is 2:
print(math.pow(x, 3))
elif choice is 3:
print(math.sqrt(x))
我们可以创建一个动态方法来实现类似 switch-case 的行为。
import math
x = input("Please enter an integer:\n")
x = int(x)
print("Choices:\n 1 - Square\n 2 - Cube\n 3 - Square Root")
choice = input("Please enter your choice:\n")
choice = int(choice)
def switch_func(value, i):
return {
1: lambda val: math.pow(val, 2),
2: lambda val: math.pow(val, 3),
3: lambda val: math.sqrt(val),
}.get(value)(i)
print(switch_func(choice, x))
这里，选择被映射到字典键，输入整数被映射到λ函数。最后，lambda 函数的输出从 switch_func()调用返回。
结论
试验 switch-case 语句的实现是很好的。但是，这非常令人困惑，而且我们不能在 if-else 块中用多个语句实现复杂的场景。所以，坚持简单的 if-else 语句，保持代码简单易读。
参考资料:
Python 系统模块
原文：https://www.askpython.com/python-modules/python-sys-module
Python sys 模块处理系统和环境特定的变量和参数。我们可以用它来读取传递给 Python 脚本的 PATH 变量和命令行参数列表。
在 Python 中导入 sys 模块
在使用任何模块之前，都需要将其导入。
语法:
导入模块名称
举例:
导入系统
Python sys.modules
这个变量让我们知道当前 shell 存在或导入的现有模块。
语法:
>>> sys.modules.keys()
dict_keys(['sys', 'builtins', '_frozen_importlib', '_imp', '_thread', '_warnings', '_weakref', 'zipimport', '_frozen_importlib_external', '_io', 'marshal', 'posix', 'encodings', 'codecs', '_codecs', 'encodings.aliases', 'encodings.utf_8', '_signal', '__main__', 'encodings.latin_1', 'io', 'abc', '_abc', 'site', 'os', 'stat', '_stat', 'posixpath', 'genericpath', 'os.path', '_collections_abc', '_sitebuiltins', '_bootlocale', '_locale', 'types', 'importlib', 'importlib._bootstrap', 'importlib._bootstrap_external', 'warnings', 'importlib.util', 'importlib.abc', 'importlib.machinery', 'contextlib', 'collections', 'operator', '_operator', 'keyword', 'heapq', '_heapq', 'itertools', 'reprlib', '_collections', 'functools', '_functools', 'mpl_toolkits', 'readline', 'atexit', 'rlcompleter'])
>>>
Python sys.argv
这为我们提供了传递给 python 脚本的命令行参数列表
例 1 :
import sys
print('The agruments input from command line are:')
for x in sys.argv:
print(x)
输出:
Python-sys.argv
Python sys.path
此变量显示当前系统或环境的路径。
语法:
sys.path
举例:
import sys
sys.path
['', 'C:\Users\HP\AppData\Local\Programs\Python\Python38-32\python38.zip', 'C:\Users\HP\AppData\Local\Programs\Python\Python38-32\DLLs', 'C:\Users\HP\AppData\Local\Programs\Python\Python38-32\lib', 'C:\Users\HP\AppData\Local\Programs\Python\Python38-32', 'C:\Users\HP\AppData\Local\Programs\Python\Python38-32\lib\site-packages']
Python sys.stdin
sys 模块的该功能用于接受用户输入提示程序的输入。
语法:
sys . STD . readline()方法
举例:
import sys
input = sys.stdin.readline()
print("Input : " + input)
输出:
Python sys.stdin
如上所述，上面的例子接受来自用户的输入并显示它。
Python sys.maxsize
此变量返回变量可以接受和存储的最大整数值。
语法:
sys.maxsize
举例:
import sys
sys.maxsize
输出:
Python sys.maxsize
Python sys.copyright
此变量显示系统上安装的当前 Python 版本的版权。
语法:
sys .版权所有
举例:
import sys
print(sys.copyright)
输出:
Python sys.copyright
Python sys.getrefcount
sys 模块的这个函数返回在特定代码块中使用的特定对象的引用计数。
举例:
import sys
input = "Engineering"
print(sys.getrefcount(0))
print(sys.getrefcount(input))
print(sys.getrefcount(None))
输出:
Python sys.getrefcount
Python sys.exit
sys 模块的这个功能使得 Python 解释器突然结束当前程序的执行。它用于从特定的代码控制流中退出程序。
语法:
sys.exit()
举例:
import sys
print("Engineering")
sys.exit(1)
print("Discipline")
输出:
工程
在上面的例子中，一旦遇到 exit()函数，它就从特定程序的执行中出来。因此，“纪律”不会打印在输出中。
参考
- Python 系统模块
- Python 系统模块文档
Python 系统命令:如何在 Python 中执行 Shell 命令？
原文：https://www.askpython.com/python-modules/python-system-command
介绍
今天在本教程中，我们将讨论如何使用 Python 系统命令来执行 shell 命令。
因此，让我们从 Python 系统命令的一些基础知识开始。
什么是 Python 系统命令？
我们可能需要集成一些特性来执行 Python 中的一些系统管理任务。这些包括查找文件、运行一些 shell 命令、进行一些高级文件处理等。为此，我们需要某种方式在系统和 python 解释器之间建立接口。
使用 Python 执行命令行可以通过使用os module中的一些系统方法轻松完成。
但是随着subprocess模块的引入(旨在取代一些旧的模块)，访问命令行变得更加容易使用。以及操纵输出和避免传统方法的一些限制。
在 Python 中执行 Shell 命令
现在我们已经了解了 Python 中的系统命令。让我们来看看我们如何实现同样的目标。
1.使用 os.system()方法
如前所述，使用os模块的一些方法可以很容易地在 Python 中执行 shell 命令。在这里，我们将使用广泛使用的os.system()方法。
该函数是使用C函数实现的，因此具有相同的限制。
该方法将系统命令作为字符串输入，并返回退出代码。
在下面的例子中，我们尝试使用 Python 中的命令行来检查我们的系统 Python 版本。
import os
command = "python --version" #command to be executed
res = os.system(command)
#the method returns the exit status
print("Returned Value: ", res)
输出:
Python 3.7.4
Returned Value: 0
这里，res存储返回值(退出代码= 0 表示成功)。从输出中可以清楚地看到，命令执行成功，我们得到了预期的 Python 版本。
2.使用子流程模块
subprocess模块附带了各种有用的方法或函数来产生新的进程，连接到它们的输入/输出/错误管道，并获得它们的返回代码。
在本教程中，我们考虑的是call()和check_output()方法，因为它们是易用和可靠。但是要了解更多信息，你可以参考官方文档。
2.1.call()方法
现在进入subprocess.call()方法。
call()方法接受作为字符串列表传递的命令行参数，或者将 shell 参数设置为True。并返回给我们退出代码或状态。
在下面的代码片段中，我们尝试使用来自 shell 的 PIP 来安装 pandas 。
import subprocess
command = "pip install pandas" #command to be executed
res = subprocess.call(command, shell = True)
#the method returns the exit code
print("Returned Value: ", res)
输出:
Collecting pandas
Downloading pandas-1.0.3-cp37-cp37m-win32.whl (7.5 MB)
Requirement already satisfied: pytz>=2017.2 in c:\users\sneha\appdata\local\programs\python\python37-32\lib\site-packages (from pandas) (2019.3)
Requirement already satisfied: numpy>=1.13.3 in c:\users\sneha\appdata\local\programs\python\python37-32\lib\site-packages (from pandas) (1.18.1)
Requirement already satisfied: python-dateutil>=2.6.1 in c:\users\sneha\appdata\local\programs\python\python37-32\lib\site-packages (from pandas) (2.8.1)
Requirement already satisfied: six>=1.5 in c:\users\sneha\appdata\local\programs\python\python37-32\lib\site-packages (from python-dateutil>=2.6.1->pandas) (1.14.0)
Installing collected packages: pandas
Successfully installed pandas-1.0.3
Returned Value: 0
正如我们所见，该命令成功执行，返回值为zero。
2.2.check output()方法
上面提到的方法成功地执行了传递的 shell 命令，但是没有给用户操作输出方式的自由。为此，子流程的 check_output()方法必须参与进来。
该方法执行传递的命令，但是这次它没有返回退出状态，而是返回了一个bytes对象。
仔细看看下面的例子，我们试图再次安装pymysql模块(已经安装)。
import subprocess
command = "pip install pymysql" #command to be executed
res = subprocess.check_output(command) #system command
print("Return type: ", type(res)) #type of the value returned
print("Decoded string: ", res.decode("utf-8")) #decoded result
输出:
Return type: <class 'bytes'>
Decoded string: Requirement already satisfied: pymysql in c:\users\sneha\appdata\local\programs\python\python37-32\lib\site-packages (0.9.3)
这里类似于前面的情况，res通过check_output()方法保存返回的对象。我们可以看到type(res)确认了这个物体是bytes类型的。
之后，我们打印出解码后的字符串，并看到命令被成功执行。
结论
所以，今天我们学习了如何使用 Python 系统命令(os.system())和子进程模块来执行系统命令。我们在这里考虑了一些更多的与 python 相关的命令，但是值得注意的是方法并不局限于这些。
我们建议您自己使用上述方法尝试其他命令，以获得更好的理解。
任何进一步的问题，请在下面随意评论。
参考
- Python 子流程文档
- Python os 文档，
- Python 系统命令–OS . System()、subprocess . call()–关于日志开发的文章
创建 Python 电报机器人
原文：https://www.askpython.com/python/examples/python-telegram-bot
当访问任何现代网页时，我们很可能会看到一个自动聊天机器人在屏幕上弹出一些关于网站及其服务的信息。我们可以在聊天应用程序中输入我们的问题并得到回复，就好像我们正在和另一边的一个真人交谈一样。
我们与之互动的这些机器人通常由一些试图模仿人类行为的人工智能应用程序驱动。我们从他们那里收到的回复是根据网站提供的服务定制的。它们通常被设计为向询问者提供第一手信息，并试图解决一个人最常见的问题。
它们部署在一些云服务上，这使得它们在任何时候都可用。据我们所知，几乎每家公司都有这种东西。
一些知名的电子商务公司使用自动化机器人来解决客户问题。其他的例子包括预约医疗专业人员或获取某人感兴趣的一些在线课程的信息。如果自动机器人无法解决我们的问题，它会让我们联系到该公司客户服务部门的一个人。
使用 Python 为电报信使创建一个机器人
机器人也可以在聊天消息服务上实现。在本文中，我们将在 Telegram Messenger 应用程序上使用 Python 编写一个机器人。我们将使用一些基本的命令，并看到我们的机器人在行动。那么，我们开始吧。
步骤–1:****将电报应用程序安装到我们的智能手机和工作站上
首先，我们需要从谷歌 Play 商店或苹果商店将 telegram 应用程序下载到我们的智能手机上。该应用程序需要使用我们的联系号码进行认证。在我们的手机上设置应用程序后，我们需要将 telegram 应用程序下载到我们的工作站，并通过提供对桌面应用程序的访问权限来连接手机应用程序，以使用相同的凭据。
也读作:Python PIP–包经理
步骤–2:****为 Python 安装报文模块
现在，转到代码编辑器的终端，使用 Python 和 pip 或 conda install 安装电报模块。下面是两种安装类型的代码。
# using pip
pip install python-telegram-bot
# using conda
conda install -c conda-forge python-telegram-bot
也读: Python Anaconda 教程——Anaconda 入门
第三步: 设置我们的 Telegram 桌面应用程序并创建一个新的机器人
接下来，我们需要启动我们的桌面应用程序并对其进行配置，以便我们的自定义代码可以访问它。我们的代码使用 API 密钥访问电报应用程序。在将我们的应用程序连接到我们的代码之前，我们需要通过桌面应用程序本身设置基本的 bot 功能，并获得用于连接的唯一 API 密钥。
在我们的桌面上打开应用程序后，在应用程序搜索选项卡中搜索 BotFather 。这将弹出一个包含基本设置的新屏幕，为我们的应用程序启动一个新的 bot。
BotFather Search
步骤–4:设置基本功能
接下来，我们需要点击位于机器人父亲页面底部的开始按钮，将我们带到另一个包含新机器人预定义命令的屏幕，如使用 /newbot 命令启动新机器人，命名我们的机器人，设置描述，设置个人资料图片，等等。
BotFather Settings
步骤–5:设置基本功能和 API 密钥生成
接下来，我们需要为我们的机器人提供一个名称/别名和一个唯一用户名。注意，根据电报指示，机器人的用户名应以“bot”结尾。我们还可以为我们的机器人提供描述和其他信息。稍后，我们还将设置我们的自定义命令，如 /about, /help, 以及其他一些在使用时提供自定义回复的命令。
当我们完成设置我们的机器人时，会生成一个特定于我们的机器人的 API 键,它会将机器人连接到我们的 Python 代码文件。现在，复制 API 键并将其粘贴到 Python 文件中，以将其作为模块导入来访问它。
注意:API 密匙提供了控制我们的 bot 的完全权限。确保将该键作为环境变量。如果上传任何代码到 GitHub ，不要忘记将 env vars 文件包含到你的 gitignore 文件中。
Basics
第六步:代码实现:导入
现在，我们有了一个带有 API 密钥的基本应用程序设置，我们开始导入 python 的 telegram.ext 模块，以及存储在名为“ secret.py 的 Python 文件中的 API 密钥。
我们将使用“ ***** ”从 telegram.ext 模块导入所有内容。为了查看在终端中运行的 bot 服务器代码，我们还可以在代码的开头包含一个 print 语句。
from telegram.ext import *
import secret
print("Server is running.... ")
步骤–7:设置自定义命令功能
接下来，我们编写了多个函数来处理我们的机器人的定制命令。它们是来自我们代码的固定回复，可以使用 /about、/help、等调用。这些函数稍后将由 telegram.ext 模块提供的处理函数和代码中稍后出现的调度器 函数使用，它们将调用这些函数并相应地提供响应。
def start_function(update, context):
update.message.reply_text("Hello there! I'm AskPython Bot.")
def help_function(update, context):
update.message.reply_text(
"""
Available commands:
/start : Starts up the bot
/help : Help topics
/about : About text
/askpython : Go to AskPython Offical Website
/custom : Other custom commands
"""
)
def about_function(update, context):
update.message.reply_text("I am a bot and also a Python Genie.")
def ask_python_function(update, context):
update.message.reply_text("AskPython Website: https://www.askpython.com/")
def custom_function(update, context):
update.message.reply_text("Some other custom reply")
解释:
在上面的代码中，我们定义了帮助我们调用命令的定制函数，如/start, /help, /about, /askpython,**/custom**. 一旦我们定义了函数，我们需要向它传递两个参数，即 update 和 context 。
- Update :这个参数在函数被调用时立即使用，并由它提供一个定义的文本回复。
- 上下文:这个参数虽然没有在我们的函数中直接使用，但是在代码内部使用，不把它作为一个参数会使程序抛出错误。当我们为消息使用 dispatcher 时，在代码的后面会用到它。
步骤–8:输入文本和错误处理功能
接下来，我们定义另外两个函数。第一个名为 message_handler_function 的函数将回复从我们的机器人传入的文本输入消息。这个函数可以由某个 AI 应用程序来处理输入的文本，并根据该应用程序中包含的文本处理算法提供合适的回复。对于本文，我们将只提供一个占位符来输出输入到我们的 bot 中的相同文本。
注意，该功能的调用方式与其他功能不同。
第二个函数是一个简单的错误处理函数，如果我们的应用程序遇到任何错误，就会调用这个函数。
代码:
def message_handler_function(update, context):
update.message.reply_text(f"Custom reply to message: '{update.message.text}'")
def error_handler_function(update, context):
print(f"Update: {update} caused error: {context.error}")
步骤–9:通过 API 连接并处理先前定义的函数
接下来，我们需要将我们的应用程序与我们之前在代码中导入的 API 键连接起来，并为我们之前在代码中定义的所有函数添加处理程序。代码块后面有解释。
代码:
# Connecting our app with the Telegram API Key and using the context
updater = Updater(secret.API_KEY, use_context=True)
my_dispatcher = updater.dispatcher
# Adding CommandHandler from telegram.ext to handle defined functions/commands
my_dispatcher.add_handler(CommandHandler("start", start_function))
my_dispatcher.add_handler(CommandHandler("help", help_function))
my_dispatcher.add_handler(CommandHandler("about", about_function))
my_dispatcher.add_handler(CommandHandler("askpython", ask_python_function))
my_dispatcher.add_handler(CommandHandler("custom", custom_function))
# Handing Incoming Messages
my_dispatcher.add_handler(MessageHandler(Filters.text, message_handler_function))
# Error Handling if any
my_dispatcher.add_error_handler(error_handler_function)
解释:在代码的这一部分中，我们实现了带有某些参数的函数，这些参数是先前在代码中定义的。下面是一个简单的概述。
- Updater: 这个函数来自 telegram.ext 模块正在接受两个参数。第一个参数是我们通过“ secret.py ”文件访问的 API Key，该文件带有变量名称 API_KEY ，第二个参数指导应用程序使用上下文。然后，这个更新器函数与 dispatcher 方法链接，并存储在 my_dispatcher 变量中，该变量最后提供将由以下处理程序使用的方法。
- CommandHandler :这个函数负责处理我们使用第一组函数定义的定制命令。
- MessageHandler :这个是用 args Filters.txt 和 message_handler_function 处理动态回复输入文本的函数。Filters.txt 由 telegram.ext 模块提供。
- add_error_handler :顾名思义，这个方法可以捕捉运行代码时遇到的任何错误。
步骤 10:完成并运行我们的机器人
这一步标记了启动我们的机器人的最后代码行。它使用了轮询(1.0) ，这意味着通过电报服务器启动机器人，并每 1 秒检查一次消息。然后是 idle() 函数，如果应用程序中没有提供任何输入，它将保持机器人空闲。
这两种方法都是使用 updater 函数调用的，该函数确实为我们的 bot 提供了 API 键和上下文
# Starting the bot using polling() function and check for messages every sec
updater.start_polling(1.0)
updater.idle()
完整的代码
from telegram.ext import *
import secret
print("Server is running.... ")
def start_function(update, context):
update.message.reply_text("Hello there! I'm AskPython Bot.")
def help_function(update, context):
update.message.reply_text(
"""
Available commands:
/start : Starts up the bot
/help : Help topics
/about : About text
/askpython : Go to AskPython Offical Website
/custom : Other custom commands
"""
)
def about_function(update, context):
update.message.reply_text("I am a bot and also a Python Genie.")
def ask_python_function(update, context):
update.message.reply_text("AskPython Website: https://www.askpython.com/")
def custom_function(update, context):
update.message.reply_text("Some other custom reply")
def message_handler_function(update, context):
update.message.reply_text(f"Custom reply to message: '{update.message.text}'")
def error_handler_function(update, context):
print(f"Update: {update} caused error: {context.error}")
# Connecting our app with the Telegram API Key and using the context
updater = Updater(secret.API_KEY, use_context=True)
my_dispatcher = updater.dispatcher
# Adding CommandHandler from telegram.ext to handle defined functions/commands
my_dispatcher.add_handler(CommandHandler("start", start_function))
my_dispatcher.add_handler(CommandHandler("help", help_function))
my_dispatcher.add_handler(CommandHandler("about", about_function))
my_dispatcher.add_handler(CommandHandler("askpython", ask_python_function))
my_dispatcher.add_handler(CommandHandler("custom", custom_function))
# Handing Incoming Messages
my_dispatcher.add_handler(MessageHandler(Filters.text, message_handler_function))
# Error Handling if any
my_dispatcher.add_error_handler(error_handler_function)
# Starting the bot using polling() function and check for messages every sec
updater.start_polling(1.0)
updater.idle()
测试 Python 电报机器人
现在我们已经准备好测试我们的电报机器人了。
- 运行代码，启动 telegram 桌面应用程序，并使用我们提供的用户名搜索我们的 bot。在我们的例子中，它是 @AskPython_01_bot
Search Our Bot With Username
- 只要我们点击我们的机器人，它就会用我们输入到启动命令函数中的文本进行响应
start Bot
- 让我们输入我们的
/help命令，看看反应
help Command
- 使用
/about命令
about Command
- 使用
/askpython命令
Askpython Command
- 现在，让我们尝试输入一些东西，看看我们的机器人反应
Text Reply
摘要
在本文中，我们介绍了使用 Python 设置电报机器人的基本步骤。它不是一个非常复杂的机器人，不像我们在互联网上看到的那样，使用一些伟大的人工智能工具让它听起来像人。但是它展示了用一小块 Python 代码就可以轻松地创建并运行这样一个机器人。使用机器人为不断扩大的技术领域提供了一些伟大的功能和用例。
参考
Python 模板字符串
原文：https://www.askpython.com/python/string/python-template-strings
Python 的模板字符串 类提供了一种简单的字符串替换方式，其中模板字段被替换为用户提供的合适的替换字符串。
有时，最好使用更容易替换的字符串，而不是使用其他格式的字符串进行替换。模板字符串正是为了这个目的而使用的，可以很容易地用最少的麻烦毫无例外地替换字符串。
字符串模板规则
模板字符串支持基于**$**的替换，这符合以下规则:
**$$**- >这是单个$符号的转义序列，否则它会被归类为修饰符。$**identifier**- >这是一个替换占位符。$**{identifier}**——>相当于$**identifier**。当有效字符出现在占位符之后但不是占位符的一部分时，使用。- 任何其他
$的出现都会引发一个**ValueError**异常。
下面是一个演示基本模板替换的示例:
from string import Template
# Create a template with 'name' as the placeholder
template = Template('Hello $name!')
student = 'Amit'
# Perform the template substitution and print the result
print(template.substitute(name=student))
输出
Hello Amit!
下面是演示模板替换的其他规则的另一个片段:
from string import Template
# Create a template with $CODE as the placeholder
# The $$ is to escape the dollar sign
template = Template('The generated Code is ${CODE}-$$100')
code = 'H875'
# Perform the template substitution and print the result
print(template.substitute(CODE=code))
输出
The generated Code is H875-$100
字符串模板类方法
1.模板构造函数
我们在之前的 snipper 中已经遇到过这种情况，我们使用Template(template_string)创建了字符串模板对象。
格式:template_object = Template(template_string)
2.替代(映射，**kwargs)
这也是我们之前代码片段的一部分，它执行了从*mapping*到关键字参数*kwargs*的模板替换。
第二个参数是一个**kwargs，因为我们将关键字参数作为占位符进行替换。因此，它作为字典传递，用于模板替换。
为了说明这一点，我们展示了如何将字典传递到模板字符串中。
from string import Template
template = Template('The shares of $company have $state. This is $reaction.')
# Perform the template substitution and print the result
print(template.substitute(state = 'dropped', company='Google', reaction='bad'))
# Perform substitution by passing a Dictionary
dct = {'state': 'risen', 'company': 'Apple', 'reaction': 'good'}
print(template.substitute(**dct))
# Incomplete substitution results in a KeyError
try:
template.substitute(state = 'dropped')
except KeyError:
print('Incomplete substitution resulted in KeyError!')
输出
The shares of Google have dropped. This is bad.
The shares of Apple have risen. This is good.
Incomplete substitution resulted in KeyError!
3.安全 _ 替代(映射，**kwargs)
这类似于substitute()，除了如果占位符从映射和 kwargs 中丢失，而不是引发 KeyError 异常，原始占位符将完整地出现在结果字符串中。
from string import Template
template = Template('The shares of $company have $state. This is $reaction.')
print(template.safe_substitute(company='Google'))
输出
The shares of Google have $state. This is $reaction.
如您所见，没有KeyError，导致了不完整但无错误的替换。这就是为什么替代是“安全”的。
模板类属性
模板对象有template属性，它返回模板字符串。虽然可以修改，但最好不要更改该属性值。
from string import Template
t = Template('Hello $name, are you $cond?')
print(t.template)
输出
Hello $name, are you $cond?
结论
在本文中，我们学习了 String Template 类，以及它的一些用于模板字符串的常规和安全替换的方法。我们还看到了如何使用它们进行简单的字符串替换。
参考
- Python 模板字符串
- 关于模板字符串的 JournalDev 文章
python tensor flow–初学者入门
原文：https://www.askpython.com/python-modules/python-tensorflow-introduction
TensorFlow 是一个数学库包，旨在为机器学习创建模型。与其他传统方法相比，使用 TensorFlow 可以更有效地设计这些模型。该软件由谷歌在开源环境中创建，用于设计 ML 和人工智能系统，以及深度神经网络。
但首先，在我们深入更复杂的东西之前，让我们了解什么是人工智能或人工智能或神经网络。
什么是机器学习？
机器学习是通过向计算机输入成千上万个真实世界的例子来为计算机制作自我学习模型的过程，就像人类学习一样。通过机器学习，软件系统可以通过获取真实世界的例子并从中导出规则和参数来学习和进化。自我学习是 ML 的核心，也是通向人工智能的路径。
什么是人工智能？
人工智能简单地说就是，计算机表现得像人类一样。通俗地说，人工智能系统是能够独立承担人类任务并以相同或更高的效率执行这些任务的程序。
例如，人工智能控制的测速仪扫描速度高于限速的汽车，然后自动拍摄车牌。参与同一过程的人一次只能专注于 1-2 辆汽车，而人工智能可以轻松地一次处理十几辆汽车的车牌。
What Is TensorFlow?
虽然存在如此复杂的人工智能软件系统，但“我们如何训练计算机利用摄像头来理解和识别汽车，然后识别它们的速度，并拍下它们的牌照，所有这些都是实时的？”
一种方法是使用张量流。
它的深度学习系统和卷积神经网络使得计算机完成这样的任务成为可能。
例如，TensorFlow 包含称为 MNIST 的大型图像库，其中包含成千上万张日常事物的 2×2 像素图像，以训练计算机识别现实世界的物体。
使用 MNIST，可以创建模型来训练计算机系统汽车看起来是什么样的，以及如何识别摄像头馈送中的高速汽车。但是为了简单起见，我们将从基础开始。
在最开始，我们将了解 TensorFlow 是如何安装的，然后我们将进一步创建一个机器学习模型，教会计算机系统从一组数据中破译一个公式。
安装和设置 TensorFlow
由于 TensorFlow 是第三方库函数，因此在任何 python IDE 中都没有预装它。因此，首先，您需要学习安装和配置 TensorFlow，以便将其用作导入包。在这个例子中，我们使用 Pycharm IDE 来安装和使用 TensorFlow，因为它比其他 IDE 更简单。
将最新版本的 PyCharm IDE、python 和 pip 包安装到您的系统中。安装后，按照以下步骤进行配置:
- 打开 cmd 并编写命令' pip install tensorflow' 注意:包含 pip 的脚本文件夹应该包含在#PATH 中
- 安装后，前往 PyCharm IDE。
- 创建一个新项目，并在该项目中创建一个 python 文件(使用。py 扩展)
- 然后进入文件>设置，在左窗格中点击你创建的项目的名称。在下拉菜单中，您会发现一个名为 Python 解释器的选项。
- Python 解释器包含了该项目所需的所有解释器。您需要找到并点击“Package”栏上方的+号。
- 点击它会打开一个新窗口，里面有一个很棒的 python 解释器列表。你需要搜索“张量流”并选择一个名为“张量流”的，不要其他的
- 点击底部的安装包。这将在您的 PyCharm 系统中安装 TensorFlow。
- 安装完成后，现在我们将看到模型是如何创建的。下面是分配给 X 和 y 的一组值的示例。
Values 1.1
起初，上面这组 X，Y 值看起来像随机数据集，但如果我们仔细观察，我们会发现 X 是 Y 的函数，可以得出一个关系，Y = 2X–1。
但是我们如何到达那里呢？因为在学校接受了多年的数学辅导后，我们已经习惯了使用数据模式。或者我们只是出于习惯去寻找模式，我们可能已经做过好几次了。
向一个使用微芯片和比特来计算数字的系统教授同样的东西是另一回事。这似乎很难，甚至是不可能的。
这是因为传统的编程通过跟随参数来获取数据并产生结果。然而，传统的编程方法无法让程序通过只查看数据和最终结果来预测规则。
Traditional Programming v/s Machine Learning
但是传统编程无法解决的问题，机器学习可以轻松解决。它使用一种试错的方法来解决问题，就像一个正常人会做的那样，但使用了数字触摸。让我们来了解如何。
Values 1.2
现在，当其他数据集进入等式时，我们的猜测变得更加可靠。上述方式是人类如何找到问题的解决方案，机器学习模型以同样的方式进行训练，以产生类似的结果。
下面是使用 TensorFlow 构建的机器学习程序如何学习问题并找到解决方案的代码片段
import keras
import tensorflow
import numpy as np
model = keras.Sequential([keras.layers.Dense(units=1, input_shape=[1])])
model.compile(optimizer='sgd', loss='mean_squared_error')
vx = np.array([-1.0, 0.0, 1.0, 2.0, 3.0, 4.0], dtype=float)
vy = np.array([-3.0, -1.0, 1.0, 3.0, 5.0, 7.0], dtype=float)
model.fit(vx, vy, epochs=200)
print(model.predict([8.0]))
Values 1.3
当这个过程完成时，系统将被训练得足以计算出公式，并猜测给定 X 值的 Y 值。这里提供了 8.0 作为 X 值，它应该给出 15 作为答案，但是当程序运行时，输出显示 14.990。
是因为，X 和 Y 的第一组 6 个值是一条直线，程序只针对那组值进行训练。但是对于任何超出该参数的给定数据，系统无法预测它是否是一条直线，只会给出最接近的值。
结论
所以，在这篇文章中，我们学习了什么是张量流，机器学习的基础知识，以及人工智能。
我们还学习了如何在您的系统中安装 TensorFlow，并从头开始创建机器学习模型。
还提供了对代码的详尽深入的解释，因此您不会对本文中的任何一点感到困惑。
如果你开始学习机器学习或 TensorFlow，这篇文章可以作为一个很好的锚，因为它为你的 ML 基础奠定了基础。
Python 三元运算符示例
Python 没有三元运算符。但是，它支持编写一个 if-else 语句，这样它就像 Python 三元运算符一样工作。
为什么 Python 没有专门的三元运算符？
许多编程语言都有三元运算符。但是，它们的主要目的是通过删除简单的 if-else 块来减少代码量。Python 改进了 if-else 语句本身以减少代码大小，而不是增加一个额外的操作符。
Python 三元运算符实现
在 Python 中模仿三元运算符的语法是:
[when_true] if [condition] else [when_false]
如果条件被评估为真，则返回when_true值，否则返回when_false。
Python 三元运算符示例
假设我们有一个简单的代码来检查一个整数是奇数还是偶数。我们要求用户输入数字并打印它是奇数还是偶数。我们将使用 if-else 块实现它。
x = int(input("Please enter an integer:\n"))
if x % 2 == 0:
int_type = 'even'
else:
int_type = 'odd'
print(f'You entered {x} which is an {int_type} integer.')
整个代码片段有 6 行，其中 4 行是 if-else 块。这是使用改进的 if-else 三元运算符支持的最佳场合。
x = int(input("Please enter an integer:\n"))
int_type = 'even' if x % 2 == 0 else 'odd'
print(f'You entered {x} which is an {int_type} integer.')
Python Ternary Operator
带元组的三元算子
Python 元组也支持三元运算符。它的语法是:
(when_false, when_true)[condition]
如果条件为真，则返回第一个值。否则，返回第二个值。
让我们将上面的例子转换成使用三元运算符和元组。
x = int(input("Please enter an integer:\n"))
int_type = ('even', 'odd')[x % 2]
print(f'You entered {x} which is an {int_type} integer.')
哪个更好？if-else 还是 tuple？
当我们使用基于 if-else 的三元运算符时，首先计算条件。
在基于元组的实现中，首先评估元组元素，然后评估条件。
因此，如果在生成这两个可能的值时涉及到一些处理，那么 if-else 会更有效。
让我们通过一个简单的代码片段来理解这一点。
def foo(s):
print(f'foo called with parameter {s}')
return s
flag = True
if flag:
result = foo('if')
else:
result = foo('else')
result = foo('ternary-if') if flag else foo('ternary-else')
result = (foo('tuple-true'), foo('tuple-false'))[flag]
print('Done')
输出:
foo called with parameter if
foo called with parameter ternary-if
foo called with parameter tuple-true
foo called with parameter tuple-false
Done
从输出可以清楚地看出，基于 if-else 的三元运算符实现更好使用。
参考资料:
Python 时间模块
原文：https://www.askpython.com/python-modules/python-time-module
Python 时间模块为我们提供了各种功能，通过 Python 脚本将系统时间灌输到我们的应用程序中。
为了开始使用时间模块，我们需要使用下面的语句将其导入到 python 脚本中:
import time
理解“时代”的概念
在对时间戳相关数据执行操作时，必须有一个起点，我们可以从该起点开始对其执行操作。
历元基本上是时间的起点，从该点开始测量时间的流逝。
Python 时间模块函数
Python 时间模块提供了一系列处理时间戳的函数。
以下是时间模块最常用的功能:
- time.time()
- time.sleep()
- time.ctime()
- time . local time()
- time.mktime()
- time.gmtime()
- time.strptime()
- time.strftime()
- time.asctime()
1.time.time()方法
Python 时间模块得到了 time.time() 方法，给出了当前当地时间的秒数。
语法:
time.time()
举例:
import time
seconds = time.time()
print("Current time in seconds since epoch =", seconds)
输出:
Current time in seconds since epoch = 1582961644.3032079
2.time.sleep()方法
time.sleep() 方法提供了当前进程或线程执行之间的延时或延迟。
语法:
time.sleep(value)
举例:
import time
print("JournalDev!!!!.")
time.sleep(1.2)
print("AskPython.")
time.sleep(3.2)
print("Engineering")
在上面的代码片段中，当我们尝试执行上面的代码时，可以很容易地观察到输出语句显示在控制台上时的延迟。
输出:
JournalDev!!!!.
AskPython.
Engineering
3.time.localtime()方法
Python 时间模块包含 struct_time 类，可以使用时间模块的各种函数访问该类。它帮助我们访问本地时间戳的各个字段，如年、小时、秒等。
struct_time 类由以下属性组成:
- tm_year :返回特定本地时间的年份。
- tm_hour :返回特定本地时间的小时。
- tm_min :返回特定本地时间的分钟值。
- tm_sec :返回特定本地时间的秒值。
- tm_mon :返回当地时间的月份。
- tm_mday :返回当地时间的月份日期。
- tm_wday :返回工作日的值，即 0-周一到 6-周日。
- tm_yday :返回 1-366 之间的某一天的数字
time.localtime() 函数在后端运行 time.time()函数，以当地时间的 struct_time 类的格式返回当前时间的详细信息。
我们还可以将自纪元以来的秒数作为参数传递给函数。
语法:
time.localtime(seconds)
举例:
import time
local_time = time.localtime()
print("Time:",local_time)
print("Current year:", local_time.tm_year)
print("Current hour:", local_time.tm_hour)
print("Current minute:", local_time.tm_min)
print("Current second:", local_time.tm_sec)
输出:
Time: time.struct_time(tm_year=2020, tm_mon=2, tm_mday=29, tm_hour=14, tm_min=3, tm_sec=23, tm_wday=5, tm_yday=60, tm_isdst=0)
Current year: 2020
Current hour: 14
Current minute: 3
Current second: 23
4.time.ctime()方法
time.ctime() 方法将 epoch 后的秒值或 time()函数的结果作为参数，并返回一个表示当前本地时间的字符串值。
语法:
ctime(seconds)
举例:
from time import time, ctime
current_time = time()
res = ctime(tim)
print("Local_time:",res)
输出:
Local_time: Sat Feb 29 14:08:26 2020
5.time.mktime()方法
time.mktime() 方法是 time.localtime()方法的逆方法。
它将 struct _ time(struct _ time 类的所有元组)作为一个参数，并以秒为单位返回从 epoch 开始已经过去的时间。
语法:
time.mktime()
举例:
import time
local_time = time.localtime()
sec = time.mktime(local_time)
print(sec)
在上面的例子中，我们使用 locatime()方法获取 struct_time 类的元组，并将其传递给 mktime()方法。
输出:
1582966721.0
6.time.gmtime()方法
time.gmtime() 函数在后端运行 time.time()函数，以 UTC 中 struct_time 类的格式返回当前时间的详细信息。
语法:
time.gmtime()
举例:
import time
local_time = time.gmtime()
print(local_time)
输出:
time.struct_time(tm_year=2020, tm_mon=2, tm_mday=29, tm_hour=9, tm_min=2, tm_sec=49, tm_wday=5, tm_yday=60, tm_isdst=0)
7.time.strptime()方法
time.strptime() 方法接受一个表示时间的字符串，并以 struct_time 格式返回时间细节。
语法:
time.strptime(string, %format code)
格式代码:
- % m–月
- %d 天
- % M–月
- % S–秒
- %H 小时
- % Y–年
举例:
import time
tym = "29 February, 2020"
sys = time.strptime(tym, "%d %B, %Y")
print(sys)
输出:
time.struct_time(tm_year=2020, tm_mon=2, tm_mday=29, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=5, tm_yday=60, tm_isdst=-1)
8.time.strftime()方法
time.strftime() 方法是 time.strptime()方法的逆方法。它将 struct_time 类的元组作为参数，并根据输入的格式代码返回一个表示时间的字符串。
语法:
time.strftime(%format code, struct_time)
举例:
import time
tym = time.localtime()
opt = time.strftime("%d/%m/%Y, %H:%M:%S",tym)
print(opt)
输出:
29/02/2020, 15:07:16
9.time.asctime()方法
time.asctime() 方法将 struct_time 类的元组作为参数，它返回一个表示来自 struct_time 类元组的时间输入的字符串。
举例:
import time
tym = time.localtime()
opt = time.asctime(tym)
print("TimeStamp:",opt)
输出:
TimeStamp: Sat Feb 29 15:27:14 2020
结论
在本文中，我们已经了解了 Python 时间模块及其提供的各种功能。
参考
Python 时间模块
使用 Python time.sleep()方法
原文：https://www.askpython.com/python-modules/python-time-sleep-method
在本教程中，我们将学习 Python time.sleep()方法。在我们之前的教程中，我们查看了时间模块，这是用于执行各种计时任务的默认实用程序库。
Python time.sleep()方法用于在给定的时间内暂停当前程序/线程的执行。
当前程序/线程在这段时间内基本上什么都不做，所以在从当前状态恢复之前，它会“休眠”一段时间。
让我们来看看如何使用这个函数。
Python time.sleep()用法
这个函数是time模块的一部分，因此我们使用像 time.sleep()这样的点符号来调用它。我们必须首先导入时间模块。
import time
现在，为了暂停程序的执行，我们需要指定秒数作为参数。
import time
num_seconds = 5
print('Going to sleep for', str(num_seconds), 'seconds')
time.sleep(num_seconds)
print('Woke up after', str(num_seconds), 'seconds')
输出
Going to sleep for 5 seconds
Woke up after 5 seconds
如果您在您的机器上尝试这样做，您的程序将在两次输出之间暂停 5 秒钟，因为它在这段时间处于休眠状态。
我们也可以将秒数指定为浮点数，这样就可以休眠0.001秒(1 毫秒)甚至0.0000001秒(1 微秒)。
这将使延迟在浮点和时钟精度范围内尽可能精确。
import time
num_millis = 2
print('Going to sleep for', str(num_millis), 'milliseconds')
time.sleep(num_millis / 1000)
print('Woke up after', str(num_millis), 'milliseconds')
输出
Going to sleep for 2 milliseconds
Woke up after 2 milliseconds
为了测量睡眠的准确时间，我们可以使用time.time()方法来启动计时器。计时器的开始值和结束值之差就是我们的执行时间。
让我们在上面的程序中测试一下我们的实际睡眠时间。
import time
num_millis = 2
print('Going to sleep for', str(num_millis), 'milliseconds')
# Start timer
start_time = time.time()
time.sleep(num_millis / 1000)
# End timer
end_time = time.time()
print('Woke up after', str(end_time - start_time), 'seconds')
输出
Going to sleep for 2 milliseconds
Woke up after 0.0020711421966552734 seconds
这里，正如你所看到的，时间并不是 2 毫秒。大概是2.071毫秒，比它略大。
这是由于操作系统在分配资源、进程调度等方面的一些延迟，这可能会导致轻微的延迟。
这种延迟的程度会有所不同，因为您不知道操作系统在特定时刻的确切状态。
time.sleep 的可变时间延迟()
如果您出于某种原因想要不同的延迟量，我们可以将一个变量传递给time.sleep()。
import time
delays = [1, 1.5, 2]
for delay in delays:
print('Sleeping for', delay, 'seconds')
time.sleep(delay)
输出
Sleeping for 1 seconds
Sleeping for 1.5 seconds
Sleeping for 2 seconds
既然我们已经介绍了如何在程序中使用time.sleep()，我们也可以对线程做同样的事情。
在线程上使用 Python time.sleep()
这在多线程环境中是一个有用的功能，因为多个线程可能需要等待特定资源被释放。
下面的代码片段展示了我们如何使用 Python time.sleep()让多线程等待并打印输出。
import time
from threading import Thread
class Worker(Thread):
# Entry point after thread.start() is invoked
def run(self):
for i in range(4):
print('Worker Thread', i)
time.sleep(i + 1)
class Waiter(Thread):
def run(self):
for i in range(10, 15):
print('Waiter thread', i)
time.sleep(i - 9)
print('Starting Worker Thread....')
Worker().start()
print('Starting Waiter Thread....')
Waiter().start()
print('Main thread finished!')
输出
Starting Worker Thread....
Worker Thread 0
Starting Waiter Thread....
Waiter thread 10
Main thread finished!
Worker Thread 1
Waiter thread 11
Worker Thread 2
Waiter thread 12
Worker Thread 3
Waiter thread 13
Waiter thread 14
这里，主线程(程序)的执行独立于两个线程的执行。因此，我们的主程序首先完成，然后是Worker和Waiter线程。
结论
在本文中，我们学习了以各种方式使用 Python time.sleep()函数。
参考
- 关于 time.sleep()的 JournalDev 文章
- Python 文档
如何使用 Python TimeDelta？
原文：https://www.askpython.com/python-modules/python-timedelta
大家好！在今天的文章中，我们将看看如何使用 Python timedelta 对象。
如果你想用一个对象来表示一个时间实例，这个对象非常有用。
与整数/浮点数相反，这是一个实际的对象。优点是它给了我们更多的灵活性来集成我们的应用程序！
让我们通过一些简单的例子来看看如何使用它！
Python timedelta 对象
这个类在datetime模块中可用，它是标准库的一部分。
from datetime import timedelta
我们可以使用其类的构造函数来创建 timedelta 对象。
from datetime import timedelta
timedelta_object = timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0)
print(timedelta_object)
# Same as above (Everything set to 0)
zero_obj = timedelta()
print(zero_obj)
输出
0:00:00
0:00:00
请注意，我们可以自定义参数来创建我们自己的 datetime 对象。如果不设置参数值，默认情况下，该值为 0。
参数可以是整数或浮点数，也可以是正数或负数。
操作现有 Python timedelta 对象
除了创建我们自己的 timedelta 对象，我们还可以操作现有的 timedelta 对象。
我们可以使用基本操作符来加、减或除两个 timedelta 对象！
a = timedelta(hours=4, seconds=100)
print(a)
b = timedelta(hours=2, seconds=50)
print(b)
print("Output:")
print(a + b, a - b, a / b, sep='\n')
输出
4:01:40
2:00:50
Output:
6:02:30
2:00:50
2.0
如你所见，我们可以使用简单的操作直接操纵这些对象！
获取当前日期时间对象
现在，对于大多数现实生活中的程序，我们希望使用当前时间并将其存储为 datetime 对象。
我们可以使用 datetime.now() 函数将当前时间显示为 datetime 对象！
注意，您必须单独从模块名称中导入它！
from datetime import datetime
现在让我们举一个例子。
from datetime import datetime
current_datetime = datetime.now()
print(current_datetime)
输出
datetime.datetime(2020, 6, 27, 22, 45, 54, 267673)
输出好像匹配！它显示当前时间是 2020 年 6 月 27 日，我的当地时区(IST)22:45:54。
现在，我们还可以使用基本运算符来获得过去或未来的时间！
from datetime import datetime, timedelta
current_datetime = datetime.now()
# future dates
one_year_future_date = current_datetime + timedelta(days=365)
print('Current Date:', current_datetime)
print('One year from now Date:', one_year_future_date)
# past dates
three_days_before_date = current_datetime - timedelta(days=3)
print('Three days before Date:', three_days_before_date)
输出
Current Date: 2020-06-27 22:45:54.267673
One year from now Date: 2021-06-27 22:45:54.267673
Three days before Date: 2020-06-24 22:45:54.267673
将 Python timedelta 用于日期和时间
我们还可以使用 Python timedelta 类和 date 对象，使用加法和减法。
from datetime import datetime, timedelta
current_datetime = datetime.now()
dt = current_datetime.date()
print('Current Date:', dt)
dt_tomorrow = dt + timedelta(days=1)
print('Tomorrow Date:', dt_tomorrow)
输出
Current Date: 2020-06-27
Tomorrow Date: 2020-06-28
这让我们在尝试存储/显示时间戳时更加灵活。如果您想要一个最小格式的时间戳，使用datetime_object.date()是一个不错的选择。
Python 时间增量总计秒数
我们可以使用:
timedelta_object.total_seconds()显示任何 timedelta 对象的总秒数。
from datetime import timedelta
print('Seconds in an year:', timedelta(days=365).total_seconds())
输出
Output: Seconds in an year: 31536000.0
对特定时区使用 datetime 对象
在存储/显示日期时间对象时，您可能希望使用不同的时区。Python 为我们提供了一种简便的方法，使用pytz模块(Python 时区)。
您可以使用pip安装pytz，如果您还没有这样做的话。
pip install pytz
现在，我们可以使用pytz.timezone(TIMEZONE)来选择我们的时区，并将其传递给 timedelta 对象。
这里有一个简单的例子，它打印不同时区的相同时间。
便捷提示:您可以使用pytz.common_timezones列出常见时区
from datetime import datetime
from pytz import timezone, common_timezones
datetime_object = datetime.now(timezone('Asia/Kolkata'))
print("Current IST:", datetime_object)
输出
Current IST: 2020-06-27 23:27:49.003020+05:30
from datetime import datetime
from pytz import timezone, common_timezones
import random
for _ in range(4):
zone = random.choice(common_timezones)
print(f"Using TimeZone: {zone}")
datetime_object = datetime.now(timezone(zone))
print(datetime_object)
输出
Using TimeZone: America/St_Lucia
2020-06-27 13:57:04.804959-04:00
Using TimeZone: Asia/Muscat
2020-06-27 21:57:04.814959+04:00
Using TimeZone: Asia/Urumqi
2020-06-27 23:57:04.825990+06:00
Using TimeZone: Asia/Seoul
2020-06-28 02:57:04.836994+09:00
事实上，我们能够获得不同时区的当前时间！
结论
在本文中，我们学习了如何使用 timedelta 对象将时间表示为 Python 对象！
参考
- 关于 Python timedelta 的 JournalDev 文章
Python timeit 模块
原文：https://www.askpython.com/python-modules/python-timeit-module
Python timeit 模块是一个简单的接口，可以快速测量小代码块的执行时间。
当您创建应用程序时，您可能想知道这段代码将如何执行，并希望在不同的场景下测试它。
为此，timeit模块为这个问题提供了一个非常简单的解决方案。让我们看看如何使用它来为我们的代码片段计时！
我们将会看到命令行接口和可调用接口。
python time it–命令行界面
命令行界面非常类似于运行 Python 程序的界面。
您需要使用-m 选项导入外部模块timeit，并将其应用到您的代码中。
python -m timeit 'print("Hello from AskPython")'
这将使用timeit运行作为字符串传递的片段。
默认情况下，这将在 Linux 上运行代码 100 万次，在 Windows 上运行 2000 万次，并在这些值中测量最佳时间。以下输出来自我的 Linux 系统。
请注意，如果您的代码片段中已经有一个 for 循环，该模块将确保总迭代次数接近 100 万次，因此您的整个循环将不会运行 100 万次！
Python time it–Python 接口
我们还可以通过 Python 解释器使用timeit，并使用以下方式导入它:
import timeit
要找到执行时间，将代码作为字符串传递给timeit.timeit()。
execution_time = timeit.timeit(code, number)
我们可以使用number参数来控制迭代的次数。
>>> import timeit
>>> timeit.timeit('"-".join(str(n) for n in range(100))', number=10000)
0.19053685299877543
>>> timeit.timeit('"-".join([str(n) for n in range(100)])', number=10000)
0.172546762998536
>>> timeit.timeit('"-".join(map(str, range(100)))', number=10000)
0.13625987299747067
>>>
使用 timeit 模块
现在让我们看看如何在我们的程序中使用timeit来为一个片段计时。
但在此之前，你可能会想知道一些事情。如果您的代码需要完成一些预先的设置，该怎么办？如果你也需要导入某些模块呢？
这个问题的解决方案是使用一个 setup 代码块，它将完成设置所有必需的模块和变量的所有必要工作。
setup_code = "import math"
编写安装程序块非常简单。您只需编写您需要的任何代码，并将其作为字符串传递给变量。
在这之后，你可以使用setup和stmt参数编写你的主代码块并将其传递给timeit.timeit()。
execution_time = timeit.timeit(setup = setup_code, stmt = main_block, number = 100)
timeit将确保在测量主循环之前完成设置，因此只执行一次！
现在让我们快速看一个例子。
这段代码试图从一个 numpy 数组的开始元素获取所有子数组。请注意，安装程序块只运行一次。
import timeit
# Setup is run only once
setup_code = '''
import numpy as np
a = np.arange(0, 1000)
print(a.shape)
def print_subarrays(a):
op = []
for i in range(a.shape[0]):
op.append(a[:i])
'''
main_block = '''
print_subarrays(a)
'''
# Main Block is run 1000 times
print('Best execution Time among 1000 iterations:', timeit.timeit(setup=setup_code, stmt=main_block, number=1000))
输出
(1000,)
Best execution Time among 1000 iterations: 0.3830194959991786
比较代码块的性能
我们可以使用timeit轻松比较多个代码块的性能。
为此，我们将使用一个计时器，使用timeit.default_timer()。
代码块所用的时间将是当前时间减去作为参考的初始时间，可以通过变量传递。
import timeit
start_time = timeit.default_timer()
function_1()
time_1 = timeit.default_timer() - start_time
start_time = timeit.default_timer()
function_2()
time_2 = timeit.default_timer() - start_time
print('Function 1 took', time_1)
print('Function 2 took', time_2)
让我们在 numpy 数组range()和np.arange()上测试两个函数，看看它们是如何比较的。
import timeit
import numpy as np
def time_range(size):
for i in range(size):
pass
def time_arange(size):
np.arange(size)
if __name__ == '__main__':
# For smaller arrays
print('Array size: 1000')
start_time = timeit.default_timer();
time_range(1000)
range_time_1 = timeit.default_timer() - start_time
start_time = timeit.default_timer();
time_arange(1000)
arange_time_1 = timeit.default_timer() - start_time
# For large arrays
print('Array size: 1000000')
start_time = timeit.default_timer();
time_range(1000000)
range_time_2 = timeit.default_timer() - start_time
start_time = timeit.default_timer();
time_arange(1000000)
arange_time_2 = timeit.default_timer() - start_time
print(f'size 1000: range() took {range_time_1}')
print(f'size 1000: arange() took {arange_time_1}')
print(f'size 1000000: range() took {range_time_2}')
print(f'size 1000000: arange() took {arange_time_2}')
输出
Array size: 1000
Array size: 1000000
size 1000: range() took 2.2970001737121493e-05
size 1000: arange() took 8.393999451072887e-06
size 1000000: range() took 0.02567379199899733
size 1000000: arange() took 0.0031752489994687494
因此，我们可以很容易地使用timeit来比较不同函数的性能。
为特定功能计时
我们还可以只对脚本中特定函数的性能计时，而不运行其他代码块。
如果之前的文件名为 numpy_compare.py ，我们可以使用下面的调用找到执行时间:
python -m timeit -s 'import numpy_compare' 'numpy_compare.time_range(1000)'
输出
Python Timeit Test On Function
结论
希望您现在已经熟悉了这个模块的基础知识，所以是时候开始使用它并提高您的工作效率了！
参考
- Python timeit 模块文档
- 关于 timeit 模块的 StackOverflow 问题
- 关于 Python timeit 模块的 JournalDev 文章
python–Tkinter 格网示例
原文：https://www.askpython.com/python-modules/tkinter/python-tkinter-grid-example
大家好！在之前关于 Tkinter 的教程部分，我们介绍了 Tkinter 文本小部件。现在让我们看一个使用 Tkinter 网格管理器的例子。
但是，你可能有一个问题要问，尤其是在看到很多人使用pack管理器之后。
为什么使用 Tkinter 网格管理器？
在我们之前的教程中，我们一直使用包几何管理器来管理我们的应用程序的几何。但是让它顺利地处理大量对象是一项艰巨的任务。
因此，Tkinter 引入了其他包装管理器，使我们的生活变得更加轻松，并且在何时使用什么方面也有一定的灵活性。
Tkinter 网格管理器实际上是最容易学习的，如果您开始构建 Tkinter 应用程序，那么它是最值得推荐的。
现在我们已经讨论了这个问题，让我们继续在我们的应用程序中实际使用网格管理器！
注意:切勿在同一个 Tkinter 应用程序中使用多个包装管理器。这将导致意想不到的错误，根本不建议这样做。一个应用只使用一个包装管理器。
使用 Tkinter 网格几何图形管理器
让我们使用网格管理器来设计下面的布局。
Layout
这个布局将有两个入口部件，每个都有一个标签，下面还有一个按钮部件。
我们还将在右侧添加一个图像，并为该图像添加一个按钮部件。
虽然使用pack很难管理这种类型的布局，但是我们可以使用grid轻松地做到这一点！
步骤很简单。我们只需要创建所有需要的小部件，并告诉grid管理器如何放置它们。
我们将首先创建我们的主对象。
import tkinter as tk
master = tk.Tk()
现在，让我们先创建两个标签，因为我们需要将它们放在最左侧，并告诉grid管理器将它们放在各自的行号上。
我们需要第 0 列的标签，由第 0 和第 1 行索引。创建标签后，我们可以使用grid通过使用:
label_object.grid(row, col)
所以，我们可以直接把它写成这样:
tk.Label(master, text="Label 1").grid(row=0, column=0)
tk.Label(master, text="Label 2").grid(row=1, column=0)
现在让我们为这两个标签各添加一个条目。
e1 = tk.Entry(master)
e2 = tk.Entry(master)
我们已经创建了入口对象，但是现在，我们需要告诉grid将它们放置在各自的位置。
干脆叫entry_obj.grid()！这类似于 pack，但总的来说，使用起来更流畅。
e1.grid(row=0, column=1)
e2.grid(row=1, column=1)
之后，我们可以使用tk.mainloop()添加 tkinter 主循环。
至此，我将发布完整的代码。
import tkinter as tk
# Create the master object
master = tk.Tk()
# Create the label objects and pack them using grid
tk.Label(master, text="Label 1").grid(row=0, column=0)
tk.Label(master, text="Label 2").grid(row=1, column=0)
# Create the entry objects using master
e1 = tk.Entry(master)
e2 = tk.Entry(master)
# Pack them using grid
e1.grid(row=0, column=1)
e2.grid(row=1, column=1)
# The mainloop
tk.mainloop()
输出
Tkinter Grid Sample
好吧！这似乎像预期的那样工作。现在，让我们给它添加一个按钮，就在下面！
button1 = tk.Button(master, text="Button 1")
button1.grid(columnspan=2, row=2, column=0)
现在，我们已经覆盖了我们的左侧。
让我们添加图像和另一个按钮到右边。
正如我们在之前的教程中讨论的关于显示图像的问题，我们必须持有对 PhotoImage 对象的引用，以避免自动垃圾收集！
from PIL import Image, ImageTk
# Create the PIL image object
image = Image.open("debian.png")
photo = ImageTk.PhotoImage(image)
# Create an image label
img_label = tk.Label(image=photo)
# Store a reference to a PhotoImage object, to avoid it
# being garbage collected! This is necesary to display the image!
img_label.image = photo
img_label.grid(row=0, column=2)
最后，我们在底部加一个按钮。
# Create another button
button2 = tk.Button(master, text="Button 2")
button2.grid(columnspan=2, row=2, column=2)
现在，我将在这里张贴完整的程序。
import tkinter as tk
from PIL import Image, ImageTk
# Create the master object
master = tk.Tk()
# Create the label objects and pack them using grid
tk.Label(master, text="Label 1").grid(row=0, column=0)
tk.Label(master, text="Label 2").grid(row=1, column=0)
# Create the entry objects using master
e1 = tk.Entry(master)
e2 = tk.Entry(master)
# Pack them using grid
e1.grid(row=0, column=1)
e2.grid(row=1, column=1)
button1 = tk.Button(master, text="Button 1")
button1.grid(columnspan=2, row=2, column=0)
# Create the PIL image object
image = Image.open("debian.png")
photo = ImageTk.PhotoImage(image)
# Create an image label
img_label = tk.Label(image=photo)
# Store a reference to a PhotoImage object, to avoid it
# being garbage collected! This is necesary to display the image!
img_label.image = photo
img_label.grid(row=0, column=2)
# Create another button
button2 = tk.Button(master, text="Button 2")
button2.grid(columnspan=2, row=2, column=2)
# The mainloop
tk.mainloop()
输出
Tkinter Grid Complete Layout
最后，我们已经完成了我们的布局！就像创建小部件并告诉grid将它们放在正确的位置一样简单！
结论
在本教程中，我们学习了如何将小部件添加到 Tkinter 应用程序中，并使用 Tkinter Grid Geometry Manager 设计布局。
敬请关注更多 Tkinter 内容！
Python 元组解包:解包元组的两种快速方法
原文：https://www.askpython.com/python/tuple/python-tuple-unpacking
本文将阐明解包元组的不同方法，下面是我们代码片段中的一些例子。让我们开始吧，不要浪费时间。
在入门之前，首先我们来了解一下 在 python 中什么是 Tuple。
元组是 Python 中列表、集合和字典中四种流行的内置集合之一。它用于存储有序的、索引的数据集合，与数据类型无关。
与数组类似，元组中的第一个值的索引为[0]，第二个值的索引为[1]，依此类推。可以通过以下命令创建元组。
new_tuple = ("New Delhi", "Tiger", 5000, "5.285", "Rahul", True)
我们的 new_tuple 将被创建如下。
print(new_tuple)
('New Delhi', 'Tiger', 5000, '5.285', 'Rahul', True)
Sample Tuple
Python 中元组的一些关键特性如下。
- 这在本质上是不可改变的。一旦创建了元组，就不能修改它的元素，也不能删除。
- 从元组中删除元素是不可能的。但是删除一个元组就是。
- 元组可以存储重复值。
- 我们可以创建一个空元组。
- 我们可以用单个元素创建一个元组。
- 两个或更多元组之间的串联是可能的。
- 元组不支持调整大小方法:
**append(),** **remove()**, **pop()**等。
众所周知，元组本质上是不可变的。它的值或内容一旦创建就不能更改。但是我们可以做的一件事是，我们可以解开一个元组的内容。解包元组意味着将元组的内容拆分成单独的变量。我们将在这里学习三种方法来做同样的事情，然后是一些例子。让我们也来理解他们。
通过重新分配来解包 Python 元组
#Let's create a tuple
new_tuple = ("New Delhi", "Tiger", 5000, "5.285", "Rahul", True)
#We can unpack the tuple by assigning each content of the tuple to individual variables
(a, b, c, d, e, f) = new_tuple
在上面的例子中，我们将元组的每个内容分配给单独的变量。让我们通过下面的代码片段来看看每个变量的内容。
#printing each variable
print(a)
'New Delhi'
print(b)
'Tiger'
print(c)
5000
print(d)
'5.285'
print(e)
Rahul
print(f)
True
在使用这种方法时，我们必须记住，我们需要将变量的数量与元组中内容的数量相同。否则，它将抛出如下错误。
(a, b, c, d) = new_tuple
Traceback (most recent call last):
File "<pyshell#3>", line 1, in <module>
(a, b, c, d) = new_tuple
ValueError: too many values to unpack (expected 4)
Error( Two Many Values to Unpack )
使用星号*符号解包元组
在这个例子中，我们将使用星号(*)操作符。如果变量的数量小于元组中内容的数量，我们可以在变量名中添加一个*,变量的值将作为一个列表分配给这个变量。让我们试试下面的代码片段。
#taking the same tuple created in method 1
print(new_tuple)
('New Delhi', 'Tiger', 5000, '5.285', 'Rahul', True)
#no. of variables (=3) is less than no. of contents (=6).
#adding * to y
(x, *y, z) = new_tuple
现在，我们可以通过单独打印变量来查看结果。
print(x)
New Delhi
print(y)
['Tiger', 5000, '5.285', 'Rahul']
print(z)
True
我们可以看到，中间的四个内容创建了一个列表，赋给 y，这样，这个方法就起作用了。通过下面代码片段中的例子，我们可以更好地理解。
#Example 1
(x, y, *z) = new_tuple
print(x)
'New Delhi'
print(y)
'Tiger'
print(z)
[5000, '5.285', 'Rahul', True]
#Example 2
(*x, y, z) = new_tuple
print(x)
['New Delhi', 'Tiger', 5000, '5.285']
print(y)
'Rahul'
print(z)
True
#Example 3
(x, y, *z, w) = new_tuple
print(x)
New Delhi
print(z)
[5000, '5.285', 'Rahul']
print(w)
True
print(y)
Tiger
注意:使用这种方法时，仅将*运算符添加到单个变量中。否则，它将抛出如下错误。
(*x, *y, z) = new_tuple
SyntaxError: multiple starred expressions in assignment
Multisigned Error
结论
在本文中，我们介绍了如何在 Python 中解包元组。当用于用例时，元组是有优势的，就像 Python 中的其他元素一样。希望你一定喜欢它。我们必须带着一些更令人兴奋的话题再次访问。
