AskPython-博客中文翻译-二-
AskPython 博客中文翻译（二）
Python 中如何组合数据帧？
原文：https://www.askpython.com/python-modules/pandas/combine-dataframes-in-python
读者你好！在本教程中，我们将学习在 Python 中组合数据帧的不同方法。
Python 中的数据帧是什么？
在 Python 中，数据帧是结构化的二维 Python 对象，用于以表格格式存储数据，即使用行和列。为了处理数据帧，我们需要pandas Python 模块。我们可以从各种 Python 对象创建 Pandas 数据帧，例如 list、dictionary、NumPy ndarray、另一个数据帧等。使用pandas.DataFrame()功能。下面是安装pandas Python 模块的命令:
C:\Users\Guest> pip install pandas
让我们创建两个pandas数据帧，我们将在以后的讨论中使用它们。创建熊猫数据帧的 Python 代码。
# Import pandas Python module
import pandas as pd
# Create two datasets using dictionary of list
data1 = {"name": ['Sanjay Kumar', 'Shreya Mohan', 'Abhishek Kumar', 'Sameer Singh', 'Sumit Kumar'],
"roll_no": [101, 102, 103, 104, 105]}
data2 = {"state": ['Bihar', 'Jharkhand', 'Maharashtra', 'Haryana', 'Punjab'],
"City": ['Nalanda', 'Deoghar', 'Pune', 'Kunjpura', 'Jalandhar']}
# Create DataFrame-1
df1 = pd.DataFrame(data1)
print("This is DataFrame-1:")
print(df1)
# Create DataFrame-2
df2 = pd.DataFrame(data2)
print("This is DataFrame-2:")
print(df2)
输出:
Python 中组合数据帧的方法
沿任一轴组合两个或多个数据帧的过程是在数据分析中使用的核心数据预处理技术之一。数据科学家或数据分析师必须经常使用不同的方法组合以熊猫数据帧形式呈现的数据。当从多个来源收集不同格式的数据时，在数据分析过程中执行这一步骤变得非常关键。我们已经创建了两只熊猫的数据帧，让我们开始讨论用 Python 逐个组合数据帧的不同方法。
方法 1:使用 concat()函数
在 Python 中，concat()函数在 pandas 模块中定义，用于沿指定轴组合两个或多个 pandas 数据帧。轴= 0 表示垂直轴，轴= 1 表示水平轴。
通过连接它们，函数返回一个新的 DataFrame 对象。它可用于将一个数据帧的行或列组合到另一个数据帧中。让我们编写 Python 代码来实现熊猫数据帧上的concat()功能。
# Combine the DataFrame-1 & DataFrame-2
# along horizontal axis using concat() function
df = pd.concat([df1, df2], axis = 1)
print("The resultant DataFrame:")
print(df)
输出:
方法 2:使用 append()函数
在 Python 中，append()函数也用于通过沿任一轴(水平轴或垂直轴)追加两个或更多熊猫数据帧来组合它们。让我们通过 Python 代码在熊猫数据帧上实现append()功能。
# Create a new DataFrame-3
df3 = pd.DataFrame({"name": ['Ravi', 'Shantanu', 'Shiv'],
"roll_no": [106, 107, 108],
"state": ['Bihar', 'UP', 'Bihar'],
"City": ['Muzaffarpur', 'Agra', 'Bakhtiarpur']},
index = [5, 6, 7])
print("This is DataFrame-3:")
print(df3)
# Combine this newly created DataFrame-3
# to the existing DataFrame along vertical axis
# using append() function
df = df.append(df3)
print("The resultant DataFrame:")
print(df)
输出:
方法 3:使用 merge()函数
在 Python 中，pandas 模块提供了merge()函数来组合 Python 中的数据帧，方法是使用数据库风格的连接来合并它们。默认情况下，它使用一个""操作来合并熊猫数据帧。
它可用于根据列名或索引组合数据帧，但传递的列名或索引级别必须同时出现在两个数据帧中。让我们来理解在 pandas 数据帧上实现merge()功能的 Python 代码。
*# Create a new DataFrame-4
df4 = pd.DataFrame({"roll_no": [101, 102, 103, 104, 105, 106, 107, 108],
"cgpa": [8.15, 8.18, 9.41, 8.56, 7.67, 9.36, 9.52, 7.35]})
print("This is DataFrame-4:")
print(df4)
# Combine this newly created DataFrame-3
# to the existing DataFrame along horizontal axis
# using merge() function
df = pd.merge(df, df4, on = "roll_no")
print("The resultant DataFrame:")
print(df)*
输出:
方法 4:使用 join()函数
在 Python 中，pandas 模块提供了join()函数，它可以通过在指定的列或索引级别上连接两个或多个 pandas 数据帧来有效地组合它们。默认情况下，它通过索引级别连接 pandas Dataframe 对象。让我们看看在 pandas 数据帧上实现join()功能的 Python 代码。
*# Create a new DataFrame-5
df5 = pd.DataFrame({"branch": ['ECE', 'ECE', 'CSE', 'EE', 'ICE', 'ME', 'TT', 'CHE'],
"year": [3, 3, 2, 1, 1, 4, 2, 3]})
print("This is DataFrame-5:")
print(df5)
# Combine this newly created DataFrame-3
# to the existing DataFrame along horizontal axis
# using join() function
df = df.join(df5)
print("The resultant DataFrame:")
print(df)*
输出:
结论
在本教程中，我们学习了以下内容:
- Python 中的 DataFrame 对象是什么
- 结合熊猫数据帧的重要性
- 组合熊猫数据帧的不同方法
实现漫画可视化 Python
原文：https://www.askpython.com/python-modules/comic-visualization-python
我们都知道，普通人对视觉信息的反应远远好于单纯的文字。通常情况下，Matplotlib 生成的图形非常完美，但是很无聊。观察这些图表并不有趣。
在本教程中，我们将以 XKCD 为例，努力使常规图像更具娱乐性和幽默性。
网络漫画 xkcd 由美国作家兰道尔·门罗于 2005 年创立。xkcd 是每周更新的网络连环画。它是最受欢迎的漫画书之一。我们将在这里尝试用 xkcd 漫画的风格来描绘我们的剧情！
加载库和数据
我们将从导入必要的库开始，然后将数据导入到程序中。在这里，我们加载 tips 数据集并输出其最初的五行。
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from seaborn import load_dataset
tips = load_dataset("tips")
tips.head()
Tips Dataset
示例 1–条形图
条形图是数据的图形表示，其中的类别可以用特定的形式突出显示，如矩形。条形图中条形的长度和高度显示了数据集中数据的分布。
也读作: Python 条形图——可视化 Python 中的分类数据
使用 sns.countplot 函数，我们可以生成一个基本的条形图。
plt.figure(facecolor="W",figsize=(10,5))
plt.title("Bar Plot - Normal")
sns.countplot(tips['sex'])
plt.show()
BarPlot Normal
为了让剧情具有喜剧效果，我们需要在整个代码之前添加 plt.xkcd 方法。
BarPlot Comic
示例 2:箱线图
箱线图是对数据集数据分布的度量。它将数据集分成四分位数。此图描述了数据集的最小值、最大值、中值、第一个四分位数和第三个四分位数。
使用下面的代码，我们可以使用 sns.boxplot 函数生成一个箱线图。
plt.figure(facecolor="W",figsize=(10,5))
plt.title("BoxPlot - Normal")
sns.boxplot(x = "day", y = "total_bill", hue = "sex", data = tips);
plt.show()
BoxPlot Normal
要制作一个剧情漫画，我们需要在整个代码之前添加 plt.xkcd 方法。
plt.xkcd()
plt.figure(facecolor="W",figsize=(10,5))
plt.title("BoxPlot - Comic")
sns.boxplot(x = "day", y = "total_bill", hue = "sex", data = tips);
plt.show()
BoxPlot Comic
示例 3–正弦波
在本例中，我们将利用 linspace 和 sin 函数生成正弦波图的值，如下面的代码所示。
plt.figure(facecolor="W",figsize=(10,5))
plt.plot(np.sin(np.linspace(0, 10)))
plt.title('A simple Sine Wave - Normal')
plt.show()
Sine Wave Normal
要制作一个剧情漫画，我们需要在整个代码之前添加 plt.xkcd 方法。
plt.xkcd()
plt.figure(facecolor="W",figsize=(10,5))
plt.plot(np.sin(np.linspace(0, 10)))
plt.title('A simple Sine Wave - Comic')
plt.show()
Sine Wave Comic
示例 4–饼图
Matplotlib 的 pie()函数支持饼状图。plt.pie()方法可用于生成绘图。以下代码生成一个饼图:
labels = 'Python', 'C++', 'Ruby', 'Java'
sizes = [215, 130, 245, 210]
colors = ['gold', 'yellowgreen', 'lightcoral', 'lightskyblue']
explode = (0.1, 0, 0, 0)
plt.figure(facecolor="W",figsize=(10,5))
plt.pie(sizes, explode=explode, labels=labels, colors=colors,autopct='%1.1f%%')
plt.axis('equal')
plt.title("Pie Chart - Normal")
plt.show()
PieChart Normal
为了让剧情漫画化，我们需要在整个代码之前添加 plt.xkcd 方法。
labels = 'Python', 'C++', 'Ruby', 'Java'
sizes = [215, 130, 245, 210]
colors = ['gold', 'yellowgreen', 'lightcoral', 'lightskyblue']
explode = (0.1, 0, 0, 0)
plt.xkcd()
plt.figure(facecolor="W",figsize=(10,5))
plt.pie(sizes, explode=explode, labels=labels, colors=colors,autopct='%1.1f%%')
plt.axis('equal')
plt.title("Pie Chart - Comic")
plt.show()
PieChart Comic
结论
我希望你喜欢这个教程，在 xkcd 的帮助下，从枯燥的标准可视化到有趣的漫画。我还会向您推荐以下教程:
感谢您的阅读！快乐学习！😃
在 Python 中比较日期和时间[简单的一步一步]
原文：https://www.askpython.com/python/examples/comparing-date-time-in-python
当一个人必须分析数据时，没有例外。为分析而部署的工具必须能够兼容处理各种类型的数据。数据可以是文本、分数、日期、整数、时间等形式。Python 是最受欢迎的数据分析工具之一，它有自己的一套模块来处理这种数据多样性。
本文将重点展示如何使用 python 来比较不同的日期和时间。通过不同的日期和时间，推断是针对不同时区的日期和时间。
表面上看，时间可能是一样的，但如果把时区因素考虑在内，情况就完全不同了。我们将通过导入 python 中的一些库——pytz &datetime来探索这一点。
这可以通过键入以下代码来完成。
import datetime
import pytz
Datetime Time Zone Libraries Imported
用 Python 比较日期
模块日期时间 包含了两个日期&时间，所以本节我们只选择日期进行比较。这可以通过使用下面的代码从上面的模块中只提取日期来完成。
from datetime import date
现在让我们尝试比较两个日期，以确定它们是否属于一周中的同一天。我们将首先使用下面的代码调用今天的日期。
date.today()
Calling Todays Date
如果选择使用 datetime.today() 而不是 date.today() 会怎么样？这将导致以下结果，因为我们已经选择只使用来自日期时间模块的日期。
Datetime Error
现在让我们继续输入另一个日期，以便与当前日期进行比较。但是在输入月份或日期时要小心，因为 Python 不喜欢在这些地方使用前导零。否则将出现以下错误。
Leading Zero Error
所以如果没有前导零，代码就变成了，
dt_1=datetime.datetime(2020,5,6)
既然我们知道了如何构造一个日期，现在让我们使用 weekday() 来比较这两个日期，看看它们是否共享同一个工作日。
if date.today().weekday()==date(2020,5,6).weekday():
print('Both dates share same weekday')
else:
print('Both dates do not share same weekday')
执行上面的代码会得到下面的输出。
Weekdays Of Two Dates Compared
在 Python 中比较不同时区
在本节中，我们将尝试比较两个时区之间的差异&验证它们是否相同。为此，我们将使用 Python 中的一个专有命令，称为 timedelta()。下面是它的语法，
timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0)
该命令不能立即使用，而是从 datetime 库中导入，
from datetime import timedelta
使用的任何两个日期或时间之间的时间差就是 时间增量 有助于指示的。让我们将它设置为 3 小时 30 分钟，并将其赋给一个变量‘Td’，以验证任意两个选定时区之间的时差是否与之匹配。
Td=timedelta(hours=3, minutes=30)
现在我们将使用下面的代码包括时间和日期，因为我们只限于上一节中的日期。
from datetime import datetime
一旦完成，印度时区和澳大利亚时区的当前时间被分别分配给变量‘tind’和‘taus’。
tind=pytz.timezone('Asia/Kolkata')
taus=pytz.timezone('Australia/Brisbane')
Assigning Timedelta Time Zones
然后使用 if 逻辑进行如下比较。
if Td == datetime.now(tind)-datetime.now(taus):
print('Difference in Time Zone = 3hr 30min')
else:
print('Difference in Time Zone != 3hr 30min')
下面是代码执行后的输出。
Different Time Zones Compared
结论
既然我们已经到了本文的结尾，希望它已经详细阐述了如何使用 Python 中的 datetime & pytz 库来比较不同时区的日期和时间。这里有另一篇文章详细介绍了如何在 Pandas 中使用 isin()命令。在 AskPython 中还有许多其他有趣的&文章，这些文章可能对那些想提高 Python 水平的人有很大帮助。欢呼！
Python 中的竞争性编程:你需要知道什么？
你好，这里是编码器！我很确定你熟悉什么是竞争性编程。但是在用 python 编码时，需要记住一些重要的事情。这些小事情会给你的代码带来巨大的不同。
Python 中的竞争性编程
让我们逐一研究其中的几个。
1.发电机的使用
使用生成器可以减少空间和时间的复杂性，并且比使用函数要好。下面显示了一个生成器函数的图示。
同时一个接一个地返回多个值也很有帮助。
def FirstGen():
yield 1
yield 2
yield 3
for i in FirstGen():
print(i,end=" ")
2.内置函数的使用
使用内置函数和库是比普通方法更好的方法。让我们看下面一个简单的程序，它有一个新的列表，包含第一个列表的元素的平方。
为了更好地说明差异，我们将在 time time模块的帮助下计算程序的执行时间。
import time
start_time = time.time()
def get_square(x):
return x**2
l1 = [i for i in range(100000)]
l2 = []
for i in l1:
l2.append(get_square(i))
print(len(l2))
print("Time taken by the code: %s seconds."% (time.time() - start_time))
上面的方法显示了在0.06881594657897949秒内的正确输出，这无疑是相当不错的。
现在让我们使用内置函数map来尝试相同的程序，并将声明的函数直接应用于列表。
import time
start_time = time.time()
def get_square(x):
return x**2
l1 = [i for i in range(100000)]
l2 = list(map(get_square,l1))
print(len(l2))
print("Time taken by the code: %s seconds."% (time.time() - start_time))
在这里，我们看到相同列表所用的时间是0.048911094665527344秒，这看起来是一个非常小的差异，但是对于更大的数据，这个差异可能会变得更大。
3.使用 itertools
这个模块对于解决一些复杂的问题非常有帮助。例如，看看下面给出的程序，找出一个列表的所有排列。
import itertools
x = list(itertools.permutations([1,2,3]))
print(x)
同样的事情也可以通过创建你自己的逻辑和函数来完成，但是那样会太复杂，时间复杂度也更高。
4.使用地图功能
每当我们需要在由空格分隔的一行中输入一个整数数组的所有元素时， map 函数是实现这一点的最佳方法。
l1 = list(map(int,input("Enter all the elements: ").split()))
print(l1)
使用map函数简化了在一行中输入多个值的复杂性。
5.串并置
要将多个字符串连接在一起，我们可以使用两种方法:将字符串添加到字符串或使用 join 函数。
建议使用join函数，因为它在一行中执行整个连接过程，如果字符串数量很大，可以降低复杂性。
让我们看看第一种方法:对字符串使用加法运算。下面给出的程序最后的执行时间是0.00498509407043457秒。
import time
start_time = time.time()
l = [str(i) for i in range(10000)]
st=""
for i in l:
st+=i
print(len(st))
print("Time taken by the code: %s seconds."% (time.time() - start_time))
然而，第二种方法:使用 join 操作给出的时间复杂度只有0.002988576889038086秒，这显然要小得多。
import time
start_time = time.time()
l = [str(i) for i in range(10000)]
st = ""
st.join(l)
print(len(st))
print("Time taken by the code: %s seconds."% (time.time() - start_time))
结论
恭喜你！今天，您学习了一些非常基本但重要的事情，在使用 python 编程语言进行竞争性编程时，请记住这些事情。
这些技巧肯定能在很大程度上帮助您提高我们解决方案的效率和准确性。
自己去试试吧！编码快乐！
Python 中如何计算距离？[简单的分步指南]
原文：https://www.askpython.com/python/examples/compute-distances-in-python
你好。今天我们将学习如何用 python 编程语言计算距离。在本教程中，我们将计算以下距离:
- 汉娩距
- 欧几里得距离
- 曼哈顿距离
我们将查看每个距离计算的公式，然后学习如何在 python 代码的帮助下进行计算。
也读:用 Python 计算 a^n:用 Python 计算幂的不同方式
用 Python 计算汉明距离
汉明距离是以二进制格式计算两个数字之间的距离。它基本上意味着二进制格式中两个数之间的位数不同。
例如，如果我们选择二进制数 101 和 111，那么它们之间的汉明距离是 1，因为它们只相差一个二进制数字。
用 Python 实现汉明距离
现在，为了计算不同的位数，我们将使用 XOR 运算。XOR 仅在比特不同时产生 1，否则产生 0。最后，我们将计算这两个数字的 XOR 运算中的置位位数。
a = int(input())
b = int(input())
x = a^b
final_ans = 0;
while (x > 0):
final_ans += x & 1;
x >>= 1;
print("First Number: ",a)
print("Second Number: ",b)
print("Hamming Distance: ",final_ans)
我们输入 12 和 9 作为两个输入，汉明距离为 3，如下图所示。
First Number: 9
Second Number: 14
Hamming Distance: 3
在 Python 中计算欧几里德距离
欧几里得距离是空间中两点之间的距离，可以借助毕达哥拉斯公式来测量。公式如下所示:
把这些点看作是(x，y，z)和(a，b，c)，那么距离计算如下:
[(x-a)2+(y-b)2+(z-c)^2)]的平方根。
实施
为了计算两个坐标点之间的欧几里德距离，我们将使用 python 中的 numpy 模块。
import numpy as np
p1 = np.array((1,2,3))
p2 = np.array((3,2,1))
sq = np.sum(np.square(p1 - p2))
print(np.sqrt(sq))
上面提到的代码的输出结果是 2.8284271247461903。你也可以用计算器手动计算距离，结果大致相同。
也读作:计算未加权图中节点间的距离
用 Python 计算曼哈顿距离
两个向量/数组(比如说 A 和 B) 之间的曼哈顿距离被计算为σ| A[I]–B[I]|其中 A [i] 是第一个数组中的第 I 个元素，B [i] 是第二个数组中的第 I 个元素。
代码实现
A = [1,2,3]
B = [5,3,2]
dis = 0
for i in range(len(A)):
dis += abs(A[i] - B[i])
print("First Array is: ", A)
print("Second Array is: ", B)
print("Manhattan Distance is: ", dis)
上面提到的代码的输出如下所示。
First Array is: [1, 2, 3]
Second Array is: [5, 3, 2]
Manhattan Distance is: 6
结论
我希望你理解了教程中提到的所有距离计算的概念和代码逻辑。感谢您阅读教程！
快乐学习！😇
用 Python 计算 a^n:用 Python 计算幂的不同方法
原文：https://www.askpython.com/python/examples/compute-raised-to-power
在本教程中，我们将以几种不同的方式计算 a的n 次方。让我们一步一步地看一个又一个方法。
也读作: Python pow()方法
方法 1:基本方法
计算a^n最基本的方法就是将乘以数字 a，n 乘以反复计算。这种方法非常慢，效率也不高。
尽管如此，这种方法的代码还是在下面提到了。
def basic_approach(a,n):
ans = 1
for i in range(n):
ans *= a
return ans
print(basic_approach(2,5))
我们从上面提到的代码得到的输出是 32 ，这是正确的输出。现在让我们转到下一个方法。
方法 2:普通递归方法
我们将通过递归来处理这个方法。如果你想知道更多关于递归的知识，你可以阅读下面提到的教程。
了解更多关于递归的知识:Python 中的递归
这里的基本概念是 fun(a，n) = a * fun(a，n-1) 。所以递归可以用来计算 a 的 n 次幂。
代码如下所述。添加评论供您参考。
def normal_recursion(a,n):
# If power is 0 : a^0 = 1
if(n==0):
return 1
# If power is 1 : a^1 = a
elif(n==1):
return a
# For n>=2 : a^n = a* (a^(n-1))
term = normal_recursion(a,n-1)
term = a * term
# Return the answer
return term
print(normal_recursion(2,5))
我们从上面的代码中得到的输出是 32 ，这是准确无误的输出。让我们转到下一个方法，它只使用递归，但以更好的方式。
方法 3:快速递归方法
前面我们使用了线性递归方法，但是计算 n 的幂也可以基于 n 的值(幂值)来计算。
- 如果 n 是偶数那么 fun(a，n)=【fun(a，n/2)】^ 2
- 如果 n 是奇数那么 *fun(a，n)= a (fun(a，n/2)】^ 2)
这将是一种更有效的方法，并将在很大程度上减少程序所花费的时间。下面提到了相同方法的代码。
def fast_recursion(a,n):
# If power is 0 : a^0 = 1
if(n==0):
return 1
# If power is 1 : a^1 = a
elif(n==1):
return a
# For n>=2 : n can be even or odd
# If n is even : a^n = (a^(n/2))^2
# if n is odd : a^n = a * ((a^(n/2))^2)
# In both the cases we have the calculate the n/2 term
term = fast_recursion(a,int(n/2))
term *= term
# Now lets check if n is even or odd
if(n%2==0):
return term
else:
return a*term
print(fast_recursion(2,5))
该代码的输出也是正确的 32 。与以前的方法相比，这种方法占用一半的时间。
结论
因此，在本教程中，我们学习了如何使用各种方法计算 a 的 n 次幂，有些方法涉及递归，有些不涉及。你可以采用任何一种方法，但选择最有效的方法总是更好。
感谢您的阅读！编码快乐！👩💻
在 Python 中计算单词的奇偶性
原文：https://www.askpython.com/python/examples/computing-parity-of-a-word
你好编码器！因此，在本教程中，我们将学习什么是单词的奇偶性，以及如何在 Python 编程中计算单词的奇偶性。我们先来了解一下一个词的奇偶性是如何计算的。
二进制字的奇偶性为:
- 如果单词包含奇数个 1 和，
- 如果它包含偶数个 1。
一些例子如下:
-
字 1:1011
1 的个数= 3
0 的个数= 1
奇偶校验= 1 因为 1 是奇数。 -
word 2:10001000
1 的个数= 2
0 的个数= 6
奇偶校验= 0 因为 1 是偶数。
问题陈述清楚地说我们需要计算一个词的宇称。简单来说，如果设置位(为 1 的位)的总数为奇数，则奇偶校验为1，否则为0。
使用 XOR 运算在 Python 中计算单词的奇偶性
方法 2 将利用右移位和异或运算。下面实现了这种方法，并添加了一些注释供您理解。
# 1\. Taking Input of the word
n=int(input())
print("The word given by user is: ",n)
# parity variable initally set to 0
parity = 0
# 2\. Go through all the bits in the while loop one by one
while(n!=0):
# Check if the current LSB is 1 or 0
# if the bit is 1 then 1 and 1 => 0 otherwise 1 and 0 ==> 0
if((n&1)==1):
# XOR previous parity with 1
# It will change parity from 0 to 1 and vice versa alternately
parity^=1
# Right shift the number
n>>=1
print("Parity is: ", parity)
输出
The word given by user is: 1011
Parity is 1
The word given by user is: 10001000
Parity is 0
结论
我希望你很好地理解了问题陈述和解决方案。您可以尝试在您的代码编辑器上实现相同的代码，并更多地了解单词的奇偶性。
感谢您的阅读！编码快乐！
Python 中连接多个列表的方法
原文：https://www.askpython.com/python/list/concatenate-multiple-lists-in-python
在本文中，我们将了解在 Python 中连接多个列表的各种技术。Python 列表为我们提供了一种存储数据和对数据进行操作的方法。
Python 中连接多个列表的技术
以下任一技术可用于将两个或多个列表连接在一起:
- 通过使用 itertools 模块
- 通过使用 Python 的'+'运算符
- 通过使用 Python 的' * '运算符
1.使用 Python itertools.chain()方法
Python itertools 模块为我们提供了 itertools.chain()方法，将多个列表串联在一起。
itertools.chain() 方法接受不同的可迭代数据，如列表、字符串、元组等，并从中提供元素的线性序列。
该函数的工作与输入数据的数据类型无关。
语法:
itertools.chain(list1, list2, ...., listN)
举例:
import itertools
x = [10, 30, 50, 70]
y = [12, 16, 17, 18]
z = [52, 43, 65, 98]
opt = list(itertools.chain(x,y,z))
print ("Concatenated list:\n",str(opt))
输出:
Concatenated list:
[10, 30, 50, 70, 12, 16, 17, 18, 52, 43, 65, 98]
2.使用 Python“*”运算符
Python '*' operator 提供了一种更有效的方法来对输入列表进行操作并将它们连接在一起。
它在提供的索引位置表示并展开数据元素。
语法:
[*input_list1, *input_list2, ...., *inout_listN]
如前所述，input_list1，input_list2 等将包含该列表中给定索引处的元素，按上述顺序排列。
举例:
x = [10, 30, 50, 70]
y = [12, 16, 17, 18]
z = [52, 43, 65, 98]
opt = [*x, *y, *z]
print ("Concatenated list:\n",str(opt))
输出:
Concatenated list:
[10, 30, 50, 70, 12, 16, 17, 18, 52, 43, 65, 98]
3.使用 Python“+”运算符
Python '+' operator 可以用来将列表连接在一起。
语法:
list1 + list2 + .... + listN
举例:
x = [10, 30, 50, 70]
y = [12, 16, 17, 18]
z = [52, 43, 65, 98]
opt = x+y+z
print ("Concatenated list:\n",str(opt))
输出:
Concatenated list:
[10, 30, 50, 70, 12, 16, 17, 18, 52, 43, 65, 98]
结论
因此，在本文中，我们揭示了用 Python 连接多个列表的不同方法。
参考
Python 中连接列表的方法
Conda 与 Pip:选择您的 Python 包管理器
在我们对 Python 的日常使用中，Conda 和 Pip 有时可以互换。PIP 和 conda 是 Python 非常流行的包管理器。尽管这两个工具的某些功能重叠，但它们是为不同的目的而设计和使用的。下面是一个表格，展示了 conda 和 pip 之间的一系列差异。
Conda 与 Pip–快速对比
| 差异点 | 点 | 康达 |
| 多语言依赖性 | 不支持 | 支持 |
| 软件包安装 | 建立在轮子上 | 下载二进制文件 |
| 包装可用性 | 235，000 包 | 1，500 多个包装 |
| 依赖性管理 | 没有 SAT 考试 | 执行 SAT 测试 |
| 虚拟环境管理 | 没有内置的虚拟管理 | 内置虚拟管理系统 |
| 简约主义 | 是 | 不 |
Table 1: Key summary of differences between pip and conda
在我们进一步了解这两个包管理器之间的区别之前，让我们了解一些关于 pip 和 conda 的基本信息。
皮普是什么？
Pip 一个简单的命令行工具，用于安装 python 包。这是从 python 包索引(PyPI) 中所有已发布的 Python 包中安装包的标准和推荐方式。如果你使用的是 Python 3.4(或更高版本)，并且是从 python.org下载的，或者如果你在由 virtualenv 或 venv 创建的虚拟环境中工作，那么 pip 已经安装好了。
康达是什么？
Conda 是一个包、依赖和环境管理系统，最初是为 Python 开发的，但后来被扩展用于 Python、R、Java、Scala、FORTRAN、C/C++等语言。它提供了一种安装、更新和删除软件包以及处理依赖关系的简单方法。在它的默认配置中，conda 从官方的 Conda 库安装软件包，而不是标准的特定语言库。
现在，我们已经对这两个软件包管理系统有了一些基本的了解，我们将看看这两个管理器之间的重要区别，这些区别造就了它们:
1.非 Python 依赖项的处理
正如我们之前了解到的，Conda 支持除 Python 之外的语言。这可能看起来微不足道，但是对于依赖性管理来说，这是一个非常强大且非常需要的特性。
Python 包恰好依赖于用 python 之外的语言编写的程序/包。Pip 不能像 LLVM 一样处理这些非 python 依赖性。HDF5 等。完全正确。这可能会导致某些包装破损。
所以我们看到 Conda 实际上在处理依赖性方面比 pip 领先一步。
2.软件包安装
这两种安装包的方式有非常重要的区别。
PyPI 中的 python 包被打包成 wheel 或 source 发行版。这意味着我们需要在本地机器上编译这个包，然后才能使用它。在调用 pip 命令之前，包编译需要在我们的本地机器上安装兼容的编译器和库。
另一方面，Conda 使用从 Anaconda 存储库和云中下载的编译后的二进制文件。这种方法使得安装过程没有任何编译器或库依赖问题。
3.包装可用性
打包和安装包的方法都是有效的，并且有各自的优缺点。
Conda 使安装变得更容易并优化了用户体验，而 pip 使开发人员的包维护变得更容易，否则他们将不必要地被迫为所有平台编译他们的包。
包编译在时间和空间上都是昂贵的。PyPI 中发布和维护了大量的包(超过 150，000 个)。这些包中的一些实际上是个人项目或具有一些利基用户群的包。
遗憾的是，Conda 不支持 PyPI 中的所有包。Conda 存储库和云包含近 1，500 多个包，主要专注于科学计算和机器学习。
软件包可用性之间的差异非常明显，就软件包可用性而言，pip 是迄今为止最好的软件包管理器。
注意:要安装 Conda 中没有的包，您可以在任何 Conda 环境中使用 pip。Pip 和 Conda 可以同时使用，但通常不推荐使用。
4.依赖性管理
pip 和 conda 之间最重要的区别是它们如何解决依赖性问题。
Pip 使用递归的串行循环来安装依赖项。Pip 并不检查以确保所有包的所有依赖项同时得到满足。
如果按顺序较早安装的软件包与按顺序较晚安装的软件包的版本有不兼容的依赖关系，那么环境就被破坏了，最重要的是，这个问题一直没有被发现，直到您发现一些奇怪的错误。
Conda 使用可满足性(SAT)求解器来验证环境中安装的所有软件包的所有要求都得到满足，从而解决了这个问题。该检查可能会花费额外的时间，但有助于防止破坏环境的创建。只要关于依赖关系的包元数据是正确的，conda 将可预见地产生工作环境。
所以当涉及到依赖性管理时，conda 通常是更好的选择。
5.虚拟环境管理
我们前面提到的 pip 只是一个维护包的小工具。康达提供的远不止这些。它带有一个内置的虚拟环境管理器。
使用 pip，您需要像 pipenv、virutalenv 这样的程序来创建虚拟环境。这是一个让 pip 只关注包管理而不使其臃肿的设计决策。pip 和其中一个环境管理器可以用来有效地创建和管理虚拟环境。
Conda 提供了开箱即用的虚拟环境管理器。它不仅提供虚拟环境功能，如 virutalenv 和 pipenv，我们还可以选择每个虚拟环境的 python 版本。这个特性有助于用户更容易地使用过时的包或只有在较低版本的 python 中才可用的包。
6.最低纲领
Pip 是一个简单的命令行工具，旨在只做一件事。它是简单的，模块化的，极简主义的设计。
另一方面，Conda 旨在提供一个简单的一体化解决方案。这是 pip 的替代方法。它的方法一点也不简单。Conda 自带一堆预装的包和软件。
对于一些用户来说，非极简方法可能是一个不受欢迎的特性。Conda 试图通过提供一个较小版本的 Conda 来克服这一点:Miniconda。Miniconda 提供了 conda 的所有功能，但只安装了设置 conda 所需的最小软件包。
结论 Conda 与 Pip
这就把我们带到了这篇关于 pip 和 conda 的文章的结尾。请继续关注更多关于 python 的此类文章。
熊猫:有条件分组值
原文：https://www.askpython.com/python-modules/pandas/conditionally-grouping-values
在本文中，我们将有条件地对熊猫的值进行分组。我们已经通过详细介绍了 Python 熊猫群。因此，如果您不确定该函数是如何工作的，可以浏览一下这篇文章。
什么是分组？
对数据库/数据框进行分组是日常数据分析和数据清理中的常见做法。分组是指将相同的数据(或具有相同属性的数据)组合成不同的组。
例如:想象一个学校数据库，里面有所有班级的学生。现在，如果校长希望比较班级之间的成绩/出勤情况，他需要比较每个班级的平均数据。但是他怎么能这样做呢？他根据学生所属的班级(同一个班级的学生进入同一个组)对学生数据进行分组，然后对组中每个学生的数据进行平均。
我们的例子涵盖了一个非常理想的情况，但它是分组的最基本的应用。分组可以基于多个属性。这有时称为分层分组，根据数据的其他属性将一个组进一步细分为更小的组。这使得我们的查询可以根据我们的需要而变得复杂。
还有一个非常基本的问题，我们在例子中忽略了，数据库中的所有数据不需要平均。例如，如果我们只需要比较每个班级的平均出勤率和百分比，我们可以忽略其他值，如手机号码或点名号码，它们的平均值实际上没有意义。在本文中，我们将学习如何在 pandas 中制作如此复杂的分组命令。
用 df.groupby()对熊猫进行分组
Pandas *d*f.groupby()提供了一个函数来分割数据帧，应用一个函数如mean()和sum()来形成分组数据集。对于数据帧来说，这似乎是一个可怕的操作，所以让我们首先将工作分成两组:拆分数据和应用并组合数据。对于这个例子，我们使用来自 Kaggle 的超市数据集。
An overview of pandas Groupby method
# Importing the data
import pandas as pd
# Our dataframe. The csv file can be downloaded fro above hyperlink.
df = pd.read_csv('supermarket_sales - Sheet1.csv')
# We drop some redundant columns
df.drop(['Date', 'Invoice ID', 'Tax 5%'], axis=1, inplace=True)
# Display the dataset
df.head()
输出:
df.groupby()函数将接受标签或标签列表。这里我们想根据列分支进行分组，所以我们在函数定义中只指定了' Branch'。我们还需要指定沿着哪个轴进行分组。 axis=1 代表‘列’，axis=0 表示‘索引’。
# We split the dataset by column 'Branch'.
# Rows having the same Branch will be in the same group.
groupby = df.groupby('Branch', axis=0)
# We apply the accumulator function that we want. Here we use the mean function here but we can also other functions.
groupby.mean()
输出:
现在我们已经学习了如何创建分组数据帧，我们将研究如何对数据应用分组条件。
离散和连续数据
A hierarchical map showing the difference between discrete and continuous data. Discrete data are counted whereas continuous data are measured.
使用离散(表格)数据进行分组是一种常见的做法。连续数据不适合分组。但这不会限制我们的数据分析能力吗？是的，很明显。所以我们需要一个变通方法。我们将对连续数据进行宁滨，以将数据制成表格。
例如:百分比是一个连续的数据，为了将它转换成带标签的数据，我们采用四个预定义的组-优秀(75-100)、良好(50-75)、差(25-50)、非常差(0-25)。每个数据无论如何变化，都将归入这 4 组。
Conversion of data from continuous to discrete from.
另一种方法是对不同的值使用 true 和 false。
例如，超市经理想知道有多少顾客一次购买了超过 3 件商品。一种方法是，如果文章数量大于或等于 3，则用 1/True 替换文章数量，否则用 0/False 替换。
# Binning of the data based on a condition
df.loc[df.Quantity < 3, 'Quantity'] = 0
df.loc[df.Quantity >= 3, 'Quantity'] = 1
# Grouping and couting
df.groupby('Quantity').count()
输出:
基于其他列对值进行有条件分组
对于我们的最终查询，我们需要根据是否售出了 3 件以上的商品将数据帧分组。我们需要找到一次性购买超过 3 件商品的平均单价。
- 我们需要过滤掉我们感兴趣的列。
- 如果对连续数据进行分组，我们需要将连续数据转换成表格数据。
- 使用
df.groupby()分割数据。 - 应用聚合函数。
# Filter out columns of our interest
df_1 = df.loc[:, ["Quantity", "Unit price"]]
# We have already binned the quantity data into 0 and 1's for counting.
# So we don't need any pre-processing
# Group the data
groupby = df_1.groupby("Quantity", axis=0)
# Apply the function(here mean)
groupby.mean()
从上图可以看出，一次购买 3 件以上的物品的单价是 55.5846。
Pandas 内置了df.filter()和df.query()等功能，使得查询变得更加容易。这允许用户对数据库进行更高级和复杂的查询。这些是我们在前面的例子中看到的 df.loc 的高级抽象
df.filter()方法
Pandas filter 方法允许你过滤数据帧的标签。它不作用于数据帧的内容。这是一个过滤掉数据集中的城市和性别标签的例子。
df = pd.read_csv('supermarket_sales - Sheet1.csv')
# We need to mention the labels to be filterd in items
df.filter(items=["City","Gender"]).head()
我们也可以使用正则表达式过滤掉标签。我们尝试过滤以字母 c 开头的标签。
# We can specify the regex literal under regex in the function
df.filter(regex="^C").head()
df.query()方法
查询方法允许查询任意复杂程度的数据帧列的内容。这里有一个例子来找出顾客一次购买超过 3 件商品的情况。
df.query('Quantity > 3').head()
我们还可以使用' & '和' | '将许多条件组合在一起。例如，我们想找出顾客一次购买超过 3 件商品并使用现金付款的情况。
df.query('Quantity > 3 & Payment=="Cash"').head()
组合 df.query()和 df.filter()以及 df.groupby()
我们想解决根据是否有超过 3 件商品售出来将数据帧分组的问题。我们需要找到每个城市一次性购买超过 3 件商品的平均单价。
我们分三步进行:
- 使用
df.query()筛选出超过 3 条的数据。 - 使用
df.filter()仅保留感兴趣的标签(此处为城市和单价) - 使用
df.groupby()对数据进行分组
# Query the database for Quantity greater than 3
df_g = df.query('Quantity > 3')
# Filter out labels of interest
df_g = df_g.filter(['City', 'Unit price'])
# Group the value according to a condition
df_g.groupby('City').mean()
参考
- 了解熊猫 groupby()函数
- pandas group by function–journal dev
Python 中的条件——快速指南
原文：https://www.askpython.com/python/examples/conditionals-in-python
这个世界比看起来要复杂得多。这就是为什么在某些情况下我们需要设置条件来解决复杂性。在条件句的帮助下，你可以跳过一些复杂的内容或者快速运行一系列的语句。您也可以在语句和执行程序之间进行选择。例如，在日常生活中，我们使用很多条件句，如如果今天下雪，我就不去市场了，否则我就去。
Python 中的条件句
在本教程中，我们将学习如何在 Python 中使用条件句。所以让我们开始吧！
我们一个一个来看条件语句。
如果语句
我们将从最基本的“如果”陈述开始。if 语句的语法如下:
if(condition):
(statement)
语法的意思是，如果条件满足，语句将被执行，否则将被跳过。
例如:
A=1
B=3
if(A<B):
print(‘A is true’)
输出:
A is true
现在，如果我们想一起执行多条语句，if 语句看起来会像这样:
if(condition):
<statement>
<statement>
<statement>
……………
< Other statements>
Else 语句
现在让我们看看 else 条件是什么样的。在这种情况下，我们将把 if 语句与 else 条件结合起来。
else 语句的基本语法:
if(condition):
<statement>
else:
<statement>
例如:
x=200
If x<300:
print(‘200 is smaller’)
else:
print(‘200 is bigger’)
输出:
200 is smaller
Elif 语句
elif 语句是 Python 中的另一个条件语句，有助于检查多个为真的条件。Elif 语句几乎类似于 if 语句，只是只能有一个 else 语句，而可以有多个 elif 语句。
下面是 elif 语句的语法。
if(condition1):
<statement>
elif(condition2):
<statement>
elif(condition3):
<statement>
else:
<statement>
让我们来看看下面的例子。
price=180
if price>100:
print(“Price is greater than 100”)
elif price==100:
print(“Price is 100”)
elif price<100:
print(“Price is less than 100”)
else :
print(“Invalid Price”)
输出:
Price is greater than 100
注意:所有的语句都应该保持它们的缩进级别，否则会抛出一个缩进错误。
结论:
在本文中，我们学习了 Python 中的条件或控制结构。这些控制结构决定了程序的执行。您可以使用循环和这些控制结构来执行不同的程序。因此，了解 Python 中的条件语句非常重要。
ConfigParser 模块–用 Python 创建配置文件
原文：https://www.askpython.com/python-modules/configparser-module
在本教程中，我们将了解什么是配置文件，在 ConfigParser 模块的帮助下，我们将创建一个配置文件，修改配置文件中的数据，向其中添加新数据，并从配置文件中删除现有数据。所以不要再拖延了，让我们开始吧。
Python 中的配置文件是什么？
配置文件通常称为配置文件，是存储计算机程序的一些特定数据和设置的特殊文件。大多数计算机程序在启动时读取它们的配置文件，并定期检查这些配置文件中的变化。
用户可以使用这些文件来更改应用程序的设置，而无需重新编译程序。通常每个配置文件由不同的部分组成。每个部分都包含键和值对，就像一个 Python 字典。
下面给出了一个样本配置文件，它由三部分组成，即地址、教育和个人爱好。
[Address]
Name = Aditya Raj
Village = Bhojpur
District = Samastipur
State = Bihar
[Education]
College=IIITA
Branch= IT
[Favorites]
Sport = VolleyBall
Book = Historical Books
现在我们将使用 python 中的 ConfigParser 模块创建上面的配置文件。
如何使用 Python ConfigParser 模块创建配置文件？
为了用 python 创建配置文件，我们将使用 configparser 模块。在下面的实现中，我们创建一个 ConfigParser 对象，并向其中添加一些节，这些节基本上是包含键值对的字典。然后我们用。ini 扩展。
#import module
import configparser
#create configparser object
config_file = configparser.ConfigParser()
#define sections and their key and value pairs
config_file["Address"]={
"Name": "Aditya Raj",
"Village": "Bhojpur",
"District": "Samastipur",
"State": "Bihar"
}
config_file["Education"]={
"College":"IIITA",
"Branch" : "IT"
}
config_file["Favorites"]={
"Sports": "VolleyBall",
"Books": "Historical Books"
}
#SAVE CONFIG FILE
with open("person.ini","w") as file_object:
config_file.write(file_object)
print("Config file 'person.ini' created")
#print file content
read_file=open("person.ini","r")
content=read_file.read()
print("content of the config file is:")
print(content)
上述代码片段的输出是:
Config file 'person.ini' created
content of the config file is:
[Address]
name = Aditya Raj
village = Bhojpur
district = Samastipur
state = Bihar
[Education]
college = IIITA
branch = IT
[Favorites]
sports = VolleyBall
books = Historical Books
如何在用 ConfigParser 创建的配置文件中添加新的节？
要在配置文件中添加新的节，我们只需读取配置对象中的配置文件，通过以字典格式定义节来添加新的节，然后我们可以将配置对象保存到同一个文件中。
在下面的示例中，我们将在 person.ini 文件中添加一个新的部分“Physique ”,该文件已经包含地址、教育和收藏夹部分。
import configparser
#print initial file content
read_file=open("person.ini","r")
content=read_file.read()
print("content of the config file is:")
print(content)
#create new config object
config_object= configparser.ConfigParser()
#read config file into object
config_object.read("person.ini")
#Add new section named Physique
config_object["Physique"]={
"Height": "183 CM",
"Weight": "70 Kg"
}
#save the config object back to file
with open("person.ini","w") as file_object:
config_object.write(file_object)
#print the new config file
print("Config file 'person.ini' updated")
print("Updated file content is:")
nread_file=open("person.ini","r")
ncontent=nread_file.read()
print(ncontent)
上述代码片段的输出是:
content of the config file is:
[Address]
name = Aditya Raj
village = Bhojpur
district = Samastipur
state = Bihar
[Education]
college = IIITA
branch = IT
[Favorites]
sports = VolleyBall
books = Historical Books
Config file 'person.ini' updated
Updated file content is:
[Address]
name = Aditya Raj
village = Bhojpur
district = Samastipur
state = Bihar
[Education]
college = IIITA
branch = IT
[Favorites]
sports = VolleyBall
books = Historical Books
[Physique]
height = 183 CM
weight = 70 Kg
我们也可以使用add_section()方法添加一个新的部分，然后使用set()方法在该部分中添加新的字段。
import configparser
#print initial file content
read_file=open("person.ini","r")
content=read_file.read()
print("content of the config file is:")
print(content)
#create new config object
config_object= configparser.ConfigParser()
#read config file into object
config_object.read("person.ini")
#Add new section named Physique
config_object.add_section('Physique')
config_object.set('Physique', 'Height', '183 CM')
config_object.set('Physique', 'Weight', '70 Kg')
#save the config object back to file
with open("person.ini","w") as file_object:
config_object.write(file_object)
#print the updated config file
print("Config file 'person.ini' updated")
print("Updated file content is:")
nread_file=open("person.ini","r")
ncontent=nread_file.read()
print(ncontent)
输出:
content of the config file is:
[Address]
name = Aditya Raj
village = Bhojpur
district = Samastipur
state = Bihar
[Education]
college = IIITA
branch = IT
[Favorites]
sports = VolleyBall
books = Historical Books
Config file 'person.ini' updated
Updated file content is:
[Address]
name = Aditya Raj
village = Bhojpur
district = Samastipur
state = Bihar
[Education]
college = IIITA
branch = IT
[Favorites]
sports = VolleyBall
books = Historical Books
[Physique]
height = 183 CM
weight = 70 Kg
在上面的例子中，我们可以看到add_section()方法将节名作为它的参数，而set()方法将节名作为它的第一个参数，将字段名作为它的第二个参数，将字段的值作为它的第三个参数。****
在创建新的配置文件时，也可以使用这两种方法向文件中添加节和字段，而不是像本例中那样使用字典。
如何更新配置文件中的数据？
因为我们已经将配置文件的节定义为字典，所以适用于字典的操作也适用于配置文件的节。我们可以在配置文件的任何部分添加字段，或者以类似于处理字典项的方式修改字段的值。
在下面的代码中，我们在 person.ini 配置文件的“Education”部分添加了一个新字段“Year ”,并修改了文件中“Branch”字段的值。
import configparser
#print initial file content
read_file=open("person.ini","r")
content=read_file.read()
print("content of the config file is:")
print(content)
#create new config object
config_object= configparser.ConfigParser()
#read config file into object
config_object.read("person.ini")
#update value of a field in a section
config_object["Education"]["Branch"]="MBA"
#add a new field in a section
config_object["Education"].update({"Year":"Final"})
#save the config object back to file
with open("person.ini","w") as file_object:
config_object.write(file_object)
#print updated content
print("Config file 'person.ini' updated")
print("Updated file content is:")
nread_file=open("person.ini","r")
ncontent=nread_file.read()
print(ncontent)
输出:
content of the config file is:
[Address]
name = Aditya Raj
village = Bhojpur
district = Samastipur
state = Bihar
[Education]
college = IIITA
branch = IT
[Favorites]
sports = VolleyBall
books = Historical Books
[Physique]
height = 183 CM
weight = 70 Kg
Config file 'person.ini' updated
Updated file content is:
[Address]
name = Aditya Raj
village = Bhojpur
district = Samastipur
state = Bihar
[Education]
college = IIITA
branch = MBA
year = Final
[Favorites]
sports = VolleyBall
books = Historical Books
[Physique]
height = 183 CM
weight = 70 Kg
在上面的例子中，我们可以使用update()方法添加新的字段以及修改现有的字段。如果文件中存在作为参数给出的字段，它将更新该字段，否则将创建一个新字段。
如何从配置文件中删除数据？
我们可以使用 configparser 模块中的remove_option()和remove_section()模块从配置文件中删除数据。remove_option()用于从任何部分删除一个字段，remove_section()用于删除配置文件的整个部分。
import configparser
#print initial file content
read_file=open("person.ini","r")
content=read_file.read()
print("content of the config file is:")
print(content)
#create new config object
config_object= configparser.ConfigParser()
#read config file into object
config_object.read("person.ini")
#delete a field in a section
config_object.remove_option('Education', 'Year')
#delete a section
config_object.remove_section('Physique')
#save the config object back to file
with open("person.ini","w") as file_object:
config_object.write(file_object)
#print new config file
print("Config file 'person.ini' updated")
print("Updated file content is:")
nread_file=open("person.ini","r")
ncontent=nread_file.read()
print(ncontent)
输出:
content of the config file is:
[Address]
name = Aditya Raj
village = Bhojpur
district = Samastipur
state = Bihar
[Education]
college = IIITA
branch = MBA
year = Final
[Favorites]
sports = VolleyBall
books = Historical Books
[Physique]
height = 183 CM
weight = 70 Kg
Config file 'person.ini' updated
Updated file content is:
[Address]
name = Aditya Raj
village = Bhojpur
district = Samastipur
state = Bihar
[Education]
college = IIITA
branch = MBA
[Favorites]
sports = VolleyBall
books = Historical Books
在上面的例子中，我们可以看到remove_option()方法将 section name 作为它的第一个参数，将 field name 作为它的第二个参数，而remove_section()方法将待删除的 section 的名称作为它的参数。
结论
在本教程中，我们已经了解了什么是配置文件，以及如何在 Python configparser 模块的帮助下创建和操作配置文件。快乐学习！🙂
参考文献——https://docs.python.org/3/library/configparser.html
理解 Python 中的混淆矩阵
原文：https://www.askpython.com/python/examples/confusion-matrix
嘿，伙计们！今天，我们将了解数据科学中最重要的概念之一—混淆矩阵及其在 Python 中的实现。
数据科学是一个巨大的领域，我们在其中研究数据，清理数据，并使用各种机器学习算法进行预测。在使用任何算法之后，检查算法对期望输出的贡献的准确性和效果是非常重要的。
评估模型性能的一个这样的误差度量是混淆矩阵。
混淆矩阵是什么？
有时，我们会遇到这样的情况，我们需要应用特定的 ML 算法来预测classification problem的结果，即结果/目标/响应变量是分类数据的业务问题。示例:检测电子邮件是否为垃圾邮件。
因此，在上面的场景中，我们需要一个特殊的误差度量来判断最佳模型的准确性和正确性。
混淆矩阵是一个误差度量，用于判断分类机器学习算法的性能。它为我们提供了关于模型的准确度、精确度和误差百分比的详细信息。
通过使用混淆矩阵，我们可以区分分类响应变量的实际正确结果和预测结果。
因此，在理解了混淆矩阵的需要之后，现在让我们将注意力集中在各种组件上，通过这些组件，我们可以判断和预测任何模型的正确拟合算法。
混淆矩阵的组成部分
看看下面混乱矩阵的结构！
Confusion Matrix
它表示由分类模型执行的预测的汇总。
- 真负值(TN) :实际为负值，也预测为负值的值。
- 假阴性(FN) :实际为阳性但预测为阴性的值。
- 假阳性(FP) :实际为阴性但预测为阳性的值。
- 真正(TP) :实际为正且预测为正的值。
那么，现在让我们看看混淆矩阵提供的关于模型的其他信息-
- 准确度 —它被定义为显示从提供的输入中成功预测的百分比的值。
精度= TP + TN / (TP + TN + FP + FN)
2.—它是定义被正确预测为真并且在实际集合中也恰好为真的一组值的值。
就精度而言，我们的意思是理解正值确实被预测为正值。
精度= TP / (TP + FP)
3.—它是代表一组实际上为真并且也被正确预测为真的值的值，
通过回忆，我们的意思是理解特定类别的样本被正确预测。
召回= TP / (TP +FN)
- F1 比分
当数据不平衡时，F1 分数有助于我们评估模型的准确性和效率。它实际上是精确度和回忆分数的调和平均值。
F1 = 2(召回率精度)/(召回率+精度)
现在让我们通过一个例子来实现混淆矩阵的概念，如下一节所示。
用 Python 实现混淆矩阵
在这个例子中，我们传递了一个预测值和实际值的列表来构建混淆矩阵。为了使用混淆矩阵函数，我们需要导入 sklearn 库。
from sklearn import metrics
pred = ["T", "F", "T", "T", "F"] #predicted set of values
actual = ["F", "F", "F", "T", "T"] #actual set of values
CM = metrics.confusion_matrix(pred, actual, labels=["T", "F"]) #confusion matrix
print(CM)
report = metrics.classification_report(pred, actual, labels=["T", "F"]) #precision, recall, f1-score,etc
print(report)
classification_matrix() function代表已经被正确和错误识别的一组值。此外，classification_report() function代表每个类别的输入的度量值，即“T”和“F”。
输出:
[[1 2]
[1 1]]
precision recall f1-score support
T 0.50 0.33 0.40 3
F 0.33 0.50 0.40 2
accuracy 0.40 5
macro avg 0.42 0.42 0.40 5
weighted avg 0.43 0.40 0.40 5
结论
到此，我们就结束了这个话题。如果你遇到任何问题，欢迎在下面评论。
在那之前，学习愉快！
Python 中如何连接和调用 API？
原文：https://www.askpython.com/python/examples/connect-and-call-apis
读者朋友们，你们好！在本文中，我们将讨论在 Python 中连接和调用 API 的不同方式。所以，让我们开始吧！
什么是 API？
API 是Application programming Interface的首字母缩写。它可以理解为规则的组合，使我们能够通过我们的系统访问 web 上的外部服务。
因此，API 确定并设置了某些格式，我们可以通过这些格式访问模型中的服务和数据。从 Python 等编程语言的角度来看，API 被认为是 web 上可用的数据源，可以通过编程语言的特定库来访问。
对 API 的请求类型
在使用 API 时，下面列出了一些我们用来对 API 执行某些操作的常用指令或命令
- GET 命令:它使用户能够以特定的格式(通常是 JSON)从 API 获取数据到他们的系统上。
- POST 命令:该命令使我们能够向 API 添加数据，即向 web 上的服务添加数据。
- 删除命令:可以从 web 上的 API 服务中删除某些信息。
- PUT 命令:使用 PUT 命令，我们可以更新 web 上 API 服务中已有的数据或信息。
API 的状态/响应代码
在连接到一个 API 时，它返回某些响应代码，这些代码决定了我们与 web 上的 API 的连接状态。让我们看看一些状态代码——
- 200 : OK 。这意味着我们与 web 上的 API 有了一个健康的连接。
- 204 :表示我们可以成功连接到 API，但是没有从服务返回任何数据。
- 401 : 认证失败！
- 403:API 服务禁止访问。
- 404 :在服务器 /web 上没有找到请求的 API 服务。
- 500 : 内部服务器出现错误。
使用 Python 连接和调用 API 的步骤
现在让我们讨论使用 Python 作为脚本语言来建立与 API 的健康连接的步骤。
示例 1:连接到 web 上的 URL
在本例中，我们将遵循以下步骤来建立到 web 上的 URL 的健康连接。
1.导入必要的库
为了连接到 API 并对其执行操作，我们需要将Python requests library导入到环境中。
import requests
2.执行操作以连接到 API
这里，我们使用了 GET 命令连接到 API，如下所示
response_API = requests.get('https://www.askpython.com/')
我们已经将需要连接的 url 传递到了get()函数中。
3.打印响应代码
status_code变量使我们能够查看我们与 API 的连接状态。
response_API.status_code
你可以在下面找到完整的代码！
import requests
response_API = requests.get('https://www.askpython.com/')
print(response_API.status_code)
输出:
200
示例 2:连接到 GMAIL API
在这个例子中，我们将从这个链接形成一个到开源 GMAIL API 的健康连接。
看看下面这段代码吧！
举例:
import requests
response_API = requests.get('https://gmail.googleapis.com/$discovery/rest?version=v1')
print(response_API.status_code)
输出:
200
结论
到此，我们就结束了这个话题。如果你遇到任何问题，欢迎在下面评论。
更多与 Python 相关的帖子，敬请关注 Python @ AskPython ，在此之前，祝你学习愉快！！🙂
用 Python 连接四个游戏
原文：https://www.askpython.com/python/examples/connect-four-game
在开始之前，让我们先了解一下什么是 connect Four 游戏。
Connect4 game 在苏联又被称为四起、剧情四起、找四起、队长的情妇、一连四起、掉落四起、重力旅行。
这是一种双人连接棋盘游戏，游戏者选择一种颜色，然后轮流将彩色圆盘投入七列六行垂直悬挂的网格中。
碎片垂直下落，占据塔内最低的可用空间。
游戏的目标是第一个形成自己的四个圆盘的水平线、垂直线或对角线。连接四是一个解决的游戏。
第一个玩家总能通过正确的走法赢得胜利。听起来很有趣，对吧？
让我们了解一下如何用 python 编程语言编写这个游戏的代码。
导入连接四个游戏所需的库
1.NumPy 模块
NumPy 库 : NumPy 代表数值 Python。NumPy 是一个 Python 库，用于处理数组。它还具有在线性代数、傅立叶变换和矩阵领域工作的功能。这是一个开源项目，你可以免费使用。NumPy 是一个 Python 库，它提供了一个简单而强大的数据结构:n 维数组。
如果您的系统上没有预装 NumPy，请在窗口的 cmd 中键入以下命令:
C:\Users\Admin> pip install numpy
当您将语句 import numpy 称为 np 时，您正在将短语“ numpy ”缩短为“ np ”，以使您的代码更易于阅读。它还有助于避免名称空间问题。
import numpy as np
2.Pygame 模块
Pygame 是一个免费的开源跨平台库，用于使用 Python 开发视频游戏等多媒体应用。
它使用简单的 DirectMedia 层库和其他几个流行的库来抽象最常见的函数，使编写这些程序成为一项更直观的任务。
如果您的系统上没有预装 Pygame，请在窗口的 cmd 中键入以下命令:
C:\Users\Admin> pip install numpy
3.Python 系统模块
python sys 模块提供了用于操纵 Python 运行时环境不同部分的函数和变量。它允许我们访问特定于系统的参数和功能。导入系统。首先，在运行任何函数之前，我们必须导入程序中的 sys 模块。系统.模块
4.Python 数学模块
一些最流行的数学函数在数学模块中定义。其中包括三角函数、表示函数、对数函数、角度转换函数等。此外，该模块中还定义了两个数学常数。
如果您的系统中没有预装 math，请在窗口的 cmd 中键入以下命令:
C:\Users\Admin> pip install maths
用 Python 实现连接四个游戏
步骤 01
将 NumPy 包作为 np 导入。然后我们将创建一个名为 create_board( ) 的 python 函数。
np.zeros( ) 函数用于创建一个充满零的矩阵。在 TensorFlow 和其他统计任务的第一次迭代中初始化权重时，可以使用 Python 中的这个函数。((6，7))是维数。6 行 7 列。然后我们只需将那块板返回。
我们现在将开始编写主游戏循环。我们将创建一个循环作为，而不是游戏结束。while not 循环重复执行循环体，直到满足循环终止的条件。只要 game_over 变量为假，我们的循环就会一直运行。我们将初始化游戏结束为假。只有当某人连续得到 4 个圆圈时，它才会转换为真。
为了增加 1 圈，我们将使用 turn += 1 。为了让它在玩家 1 和 2 之间交替切换，我们使用 turn = turn % 2 。
import numpy as np
def create_board():
board = np.zeros((6,7))
return board
#initialize board
board = create_board()
#We will initialize the game_over as False.
game_over = False
turn = 0
while not game_over:
#Ask for player 1 input
if turn == 0:
selection = int(input("Player 1, Make your Selection(0-6):"))
#Ask for player 2 input
else:
selection = int(input("Player 2, Make your Selection(0-6):"))
turn += 1
turn = turn % 2
步骤 02
在步骤 02 中，我们对前面的代码做了一些修改和更新。
我们希望选择变量实际上在棋盘上放下一个棋子。为此，我们要做的第一件事是创建另外三个名为 def drop_piece()、 def is_valid_location()、def get_next_open_row()的函数。
这些函数如何一起工作如下，玩家将做出选择。代码中的 (0-6) 表示他们想要放置棋子的列。因此我们将选择变量的名称更新为列变量 (col) 。
现在，我们将把这个 col 放在我们现有的当前板中，并把它作为参数传递给板的所有三个函数。
我们将初始化名为行计数和列计数的全局变量。在 Python 中，在函数之外或者在全局范围内声明的变量被称为全局变量。这意味着全局变量可以在函数内部或外部访问。
函数的作用是:沿着指定的轴反转数组元素的顺序，保持数组的形状。
Syntax: np.flip(array, axis)
import numpy as np
ROW_COUNT = 6
COLUMN_COUNT = 7
def create_board():
board = np.zeros((6,7))
return board
def drop_piece(board,row,col,piece):
board[row][col]= piece
def is_valid_location(board,col):
#if this condition is true we will let the use drop piece here.
#if not true that means the col is not vacant
return board[5][col]==0
def get_next_open_row(board,col):
for r in range(ROW_COUNT):
if board[r][col]==0:
return r
def print_board(board):
print(np.flip(board,0))
board = create_board()
print_board(board)
game_over = False
turn = 0
while not game_over:
#Ask for player 1 input
if turn == 0:
col = int(input("Player 1, Make your Selection(0-6):"))
#Player 1 will drop a piece on the board
if is_valid_location(board,col):
row = get_next_open_row(board,col)
drop_piece(board,row,col,1)
#Ask for player 2 input
else:
col = int(input("Player 2, Make your Selection(0-6):"))
#Player 2 will drop a piece on the board
if is_valid_location(board,col):
row = get_next_open_row(board,col)
drop_piece(board,row,col,2)
print_board(board)
turn += 1
turn = turn % 2
步骤 03:完成代码演练
在步骤 03 中，我们将创建一个有 GUI 的游戏，而不仅仅是有矩阵的游戏。上面的代码以及我们所做的新的修改将使游戏看起来像一个真正的棋盘游戏。
首先，我们将导入所有必要的库。
接下来，我们将把颜色蓝、黑、红和黄定义为全局静态变量。这些值将是 rgb 值。
我们将初始化名为行计数和列计数的全局变量。行数为 6，列数为 7。
然后我们创建 5 个函数，分别命名为 create_board( ) 、 drop_piece( ) 、 is_valid_location( ) 、 get_next_open_row( ) 和 print_board( ) 。
然后，我们创建一个名为 winning_move() 的函数，并检查水平位置获胜，垂直位置获胜，正负斜线获胜。
在水平和垂直位置中，我们为行和列创建一个嵌套的 for 循环，并检查 if 条件语句，以查看棋子是否已被放到棋盘上的那个位置。如果T3 如果条件 T5 满足，则返回真。我们将对垂直位置重复同样的过程，也包括正斜率和负斜率的对角线。
在函数 def draw_board( ) ， pygame.draw 中是一个用于绘制形状的模块。
pygame.draw.rect 用于绘制矩形。现在我们将定义三角形。定义高度、宽度和位置。
所以位置是， c*SQUARESIZE ，y 轴的位置是， r*SQUARESIZE+SQUARESIZE 。
高度和宽度将是另外两个参数，那就是平方尺寸，平方尺寸。对圆也重复同样的步骤。
import numpy as np
import pygame
import sys
import math
BLUE = (0,0,255)
BLACK = (0,0,0)
RED = (255,0,0)
YELLOW = (255,255,0)
ROW_COUNT = 6
COLUMN_COUNT = 7
def create_board():
board = np.zeros((ROW_COUNT,COLUMN_COUNT))
return board
def drop_piece(board, row, col, piece):
board[row][col] = piece
def is_valid_location(board, col):
return board[ROW_COUNT-1][col] == 0
def get_next_open_row(board, col):
for r in range(ROW_COUNT):
if board[r][col] == 0:
return r
def print_board(board):
print(np.flip(board, 0))
def winning_move(board, piece):
# Check horizontal locations for win
for c in range(COLUMN_COUNT-3):
for r in range(ROW_COUNT):
if board[r][c] == piece and board[r][c+1] == piece and board[r][c+2] == piece and board[r][c+3] == piece:
return True
# Check vertical locations for win
for c in range(COLUMN_COUNT):
for r in range(ROW_COUNT-3):
if board[r][c] == piece and board[r+1][c] == piece and board[r+2][c] == piece and board[r+3][c] == piece:
return True
# Check positively sloped diaganols
for c in range(COLUMN_COUNT-3):
for r in range(ROW_COUNT-3):
if board[r][c] == piece and board[r+1][c+1] == piece and board[r+2][c+2] == piece and board[r+3][c+3] == piece:
return True
# Check negatively sloped diaganols
for c in range(COLUMN_COUNT-3):
for r in range(3, ROW_COUNT):
if board[r][c] == piece and board[r-1][c+1] == piece and board[r-2][c+2] == piece and board[r-3][c+3] == piece:
return True
def draw_board(board):
for c in range(COLUMN_COUNT):
for r in range(ROW_COUNT):
pygame.draw.rect(screen, BLUE, (c*SQUARESIZE, r*SQUARESIZE+SQUARESIZE, SQUARESIZE, SQUARESIZE))
pygame.draw.circle(screen, BLACK, (int(c*SQUARESIZE+SQUARESIZE/2), int(r*SQUARESIZE+SQUARESIZE+SQUARESIZE/2)), RADIUS)
for c in range(COLUMN_COUNT):
for r in range(ROW_COUNT):
if board[r][c] == 1:
pygame.draw.circle(screen, RED, (int(c*SQUARESIZE+SQUARESIZE/2), height-int(r*SQUARESIZE+SQUARESIZE/2)), RADIUS)
elif board[r][c] == 2:
pygame.draw.circle(screen, YELLOW, (int(c*SQUARESIZE+SQUARESIZE/2), height-int(r*SQUARESIZE+SQUARESIZE/2)), RADIUS)
pygame.display.update()
board = create_board()
print_board(board)
game_over = False
turn = 0
#initalize pygame
pygame.init()
#define our screen size
SQUARESIZE = 100
#define width and height of board
width = COLUMN_COUNT * SQUARESIZE
height = (ROW_COUNT+1) * SQUARESIZE
size = (width, height)
RADIUS = int(SQUARESIZE/2 - 5)
screen = pygame.display.set_mode(size)
#Calling function draw_board again
draw_board(board)
pygame.display.update()
myfont = pygame.font.SysFont("monospace", 75)
while not game_over:
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
if event.type == pygame.MOUSEMOTION:
pygame.draw.rect(screen, BLACK, (0,0, width, SQUARESIZE))
posx = event.pos[0]
if turn == 0:
pygame.draw.circle(screen, RED, (posx, int(SQUARESIZE/2)), RADIUS)
else:
pygame.draw.circle(screen, YELLOW, (posx, int(SQUARESIZE/2)), RADIUS)
pygame.display.update()
if event.type == pygame.MOUSEBUTTONDOWN:
pygame.draw.rect(screen, BLACK, (0,0, width, SQUARESIZE))
#print(event.pos)
# Ask for Player 1 Input
if turn == 0:
posx = event.pos[0]
col = int(math.floor(posx/SQUARESIZE))
if is_valid_location(board, col):
row = get_next_open_row(board, col)
drop_piece(board, row, col, 1)
if winning_move(board, 1):
label = myfont.render("Player 1 wins!!", 1, RED)
screen.blit(label, (40,10))
game_over = True
# # Ask for Player 2 Input
else:
posx = event.pos[0]
col = int(math.floor(posx/SQUARESIZE))
if is_valid_location(board, col):
row = get_next_open_row(board, col)
drop_piece(board, row, col, 2)
if winning_move(board, 2):
label = myfont.render("Player 2 wins!!", 1, YELLOW)
screen.blit(label, (40,10))
game_over = True
print_board(board)
draw_board(board)
turn += 1
turn = turn % 2
if game_over:
pygame.time.wait(3000)
我们完成的 GUI 用 Python 连接了四个游戏
结尾注释…
这是如何用 Python 编写著名的 connect four 游戏的完整解释。Pygame 让用户很容易学习和编写大量的游戏。我希望你一定会尝试编码，并享受你自己创造的游戏。
快乐学习！
用 Python 将字典转换成列表的 5 种简单方法
原文：https://www.askpython.com/python/dictionary/convert-a-dictionary-to-a-list
在本教程中，我们将讨论将 Python 字典转换为 Python 列表的五大方法。所以，让我们开始吧！
将字典转换为列表的 5 种方法
现在让我们学习如何在 Python 中将字典转换成列表。在接下来的几节中，您将看到 Python 中用于将数据类型从 dictionary 更改为 list 的各种方法和函数。我们开始吧！
方法 1:使用 dict.items()函数
在这个方法中，我们将使用 dictionary 类的 dict.items()函数将字典转换成列表。dict.items()函数用于迭代 Python 字典的键:值对。默认情况下，键:值对以 Python 元组的形式存储在由dict.items()函数返回的迭代器中。我们可以将这个返回的迭代器传递给list()函数，该函数最终会给我们一个包含给定 Python 字典的键:值对的 Python 元组列表。让我们进入实际的 Python 代码来实现这个方法。
# Method- 1
# Create a Python dictionary
dr = {'AskPython': 'Python', 'LinuxForDevices': 'Linux', 'QuickExcel': 'Excel'}
print('Given Python dictionary:\n')
print(dr)
# Convert the above Python dictionary to a Python list
# Using the dict.items() function
ls = list(dr.items())
print('\nThis is the converted list:\n')
print(ls)
输出:
Given Python dictionary:
{'AskPython': 'Python', 'LinuxForDevices': 'Linux', 'QuickExcel': 'Excel'}
This is the converted list:
[('AskPython', 'Python'), ('LinuxForDevices', 'Linux'), ('QuickExcel', 'Excel')]
方法 2:使用 zip()函数
在这个方法中，我们将使用 Python 中的 zip()函数将字典转换成列表。Python 中的zip()函数用于通过压缩值来组合两个迭代器对象。
这里我们将传递两个 Python 列表作为两个迭代器对象，一个是给定 Python 字典的所有键的列表，另一个是给定 Python 字典的所有值的列表。我们将使用 Python dictionary 类的dict.keys()和dict.values()函数获得这两个列表。默认情况下，键:值对以 Python 元组的形式存储在由zip()函数返回的迭代器中。我们可以将这个返回的迭代器传递给list()函数，该函数将最终返回一个 Python 元组列表，其中包含给定 Python 字典的所有键:值对。让我们看看如何通过 Python 代码实现这个方法。
# Method- 2
# Create a Python dictionary
dr = {'Python': '.py', 'C++': '.cpp', 'Csharp': '.cs'}
print('Given Python dictionary:\n')
print(dr)
# Convert the above Python dictionary to a Python list
# Using the zip() function
iter = zip(dr.keys(), dr.values())
ls = list(iter)
print('\nThis is the Converted list:\n')
print(ls)
输出:
Given Python dictionary:
{'Python': '.py', 'C++': '.cpp', 'Csharp': '.cs'}
This is the Converted list:
[('Python', '.py'), ('C++', '.cpp'), ('Csharp', '.cs')]
方法 3:使用 map()函数
在这个方法中，我们将使用 Python 中的 map()函数将一个字典转换成 Python 中的一个列表。Python 中的map()函数用于将任何 Python 函数映射到迭代器对象上。
这里我们将传递 Python list()函数作为第一个参数，传递dict.item()函数返回的迭代器对象作为第二个参数。然后我们可以将由map()函数返回的迭代器传递给list()函数，该函数将返回一个 Python 列表，其中包含给定 Python 字典的所有键:值对。让我们编写 Python 代码来实现这个方法。
# Method- 3
# Create a Python dictionary
dr = {'Amazon': 'AWS', 'Microsoft': 'AZURE', 'Google': 'GCP'}
print('Given Python dictionary:\n')
print(dr)
# Convert the above Python dictionary to a Python list
# Using the map() function
iter = map(list, dr.items())
ls = list(iter)
print('\nThis is the Converted list:\n')
print(ls)
输出:
Given Python dictionary:
{'Amazon': 'AWS', 'Microsoft': 'AZURE', 'Google': 'GCP'}
This is the Converted list:
[['Amazon', 'AWS'], ['Microsoft', 'AZURE'], ['Google', 'GCP']]
方法 4:使用简单 for 循环迭代
在这个方法中，我们将使用一个简单的循环来将字典转换成列表。我们将首先创建一个空列表，然后使用 for 循环遍历给定 Python 字典的键。最后，我们将为给定 Python 字典的每个 key: value 对创建一个 Python 元组，我们对它进行迭代，并将这个元组添加到我们创建的空列表中。让我们通过 Python 代码来实现这个方法。
# Method- 4
# Create a Python dictionary
dr = {'Sanjay': 'ECE', 'Abhishek': 'EE', 'Sarthak': 'ICE'}
print('Given Python dictionary:\n')
print(dr)
# Create an empty Python list
ls = []
# Convert the above Python dictionary to a Python list
# Using the for loop iteration
for key in dr:
item = (key, dr[key])
ls.append(item)
print('\nThis is the Converted list:\n')
print(ls)
输出:
Given Python dictionary:
{'Sanjay': 'ECE', 'Abhishek': 'EE', 'Sarthak': 'ICE'}
This is the Converted list:
[('Sanjay', 'ECE'), ('Abhishek', 'EE'), ('Sarthak', 'ICE')]
方法 5:使用列表理解
list comprehension 方法是初始化 Python 列表最广泛使用和最简洁的方法。我们还可以使用 for 循环在同一行中提供列表元素。这里我们将使用 for 循环和dict.items()函数获取给定 Python 字典的键:值对。然后，我们将使用获取的给定 Python 字典的键:值对初始化 Python 列表。让我们看看如何使用这个方法将一个给定的 Python 字典转换成一个 Python 列表。
# Method- 4
# Create a Python dictionary
dr = {'A': 65, 'B': 66, 'C': 67, 'D': 68}
print('Given Python dictionary:\n')
print(dr)
# Convert the above Python dictionary to a Python list
# Using the list comprehension
ls = [(key, value) for key, value in dr.items()]
print('\nThis is the Converted list:\n')
print(ls)
输出:
Given Python dictionary:
{'A': 65, 'B': 66, 'C': 67, 'D': 68}
This is the Converted list:
[('A', 65), ('B', 66), ('C', 67), ('D', 68)]
总结
在本教程中，我们学习了用 Python 将字典转换成列表的五种方法。希望你已经理解了这些东西，并准备用这些方法进行实验。感谢您阅读这篇文章，请继续关注我们，了解更多令人兴奋的 Python 编程学习内容。
使用 Python 将 CSV 转换为 JSON 初学者指南
原文：https://www.askpython.com/python/examples/convert-csv-to-json
在本文中，我们将使用一个简单的 Python 脚本将 CSV 转换为 JSON。我们将学习如何使用 Python 的 JSON (JavaScript Object Notation)库，并尝试理解这种转换背后的逻辑。
为什么要将 CSV 转换成 JSON？
JSON 是一种标准的基于文本的格式，用于表示基于 JavaScript 对象语法的结构化数据。它通常用于在 web 应用程序中传输数据，因此每当需要将一些数据从服务器发送到客户机时，数据首先被转换成 JSON，然后发送到客户机，以便可以在 web 页面上显示，反之亦然。
将 CSV 转换为 JSON 的步骤
我们将通过各种小步骤来解决他的问题，这样我们就能彻底而容易地理解这个问题。
第一步:输入 CSV 文件和 JSON 文件的路径
这可以在输入功能的帮助下实现。默认情况下，Input 函数接受字符串形式的输入，这正是我们需要的。Input 函数也可以用来在请求输入时显示一些字符串
步骤 2: 使用文件处理程序打开 CSV 文件
一个文件处理程序可以很容易地启动，有许多方法可以做到这一点，但我们将坚持最安全的一个，即我们将使用:
with open(csv_file_path, encoding = 'utf-8') as csv_file_handler:
这将在读取模式下打开文件，一旦我们离开这个块，它将自动关闭这个文件。使用后关闭文件对于防止文件损坏或数据丢失非常重要。
步骤 3: 使用 JSON 文件处理程序打开 JSON 文件
该文件将以写模式打开，因此代码变为:
with open(json_file_path, 'w', encoding = 'utf-8') as json_file_handler:
这里'+w '表示文件以写模式打开，即其数据可以更改
步骤 4: 使用 JSON 模块的函数将文件解析成 JSON 文件
使用下面这段代码可以轻松完成这项任务:
json_file_handler.write(json.dumps(data_dict, indent = 4))
一切都准备好了，现在你只需要运行代码，你的工作就完成了
用 Python 将 CSV 转换成 JSON 的完整代码
import csv
import json
def csv_to_json(csv_file_path, json_file_path):
#create a dictionary
data_dict = {}
#Step 2
#open a csv file handler
with open(csv_file_path, encoding = 'utf-8') as csv_file_handler:
csv_reader = csv.DictReader(csv_file_handler)
#convert each row into a dictionary
#and add the converted data to the data_variable
for rows in csv_reader:
#assuming a column named 'No'
#to be the primary key
key = rows['Serial Number']
data_dict[key] = rows
#open a json file handler and use json.dumps
#method to dump the data
#Step 3
with open(json_file_path, 'w', encoding = 'utf-8') as json_file_handler:
#Step 4
json_file_handler.write(json.dumps(data_dict, indent = 4))
#driver code
#be careful while providing the path of the csv file
#provide the file path relative to your machine
#Step 1
csv_file_path = input('Enter the absolute path of the CSV file: ')
json_file_path = input('Enter the absolute path of the JSON file: ')
csv_to_json(csv_file_path, json_file_path)
运行代码
Input Csv File
运行脚本的命令
$ python3 "python script name without quotes"
Running Python Script In Terminal
输出文件
Json File Generated As Output
结论
在本文中，我们学习了如何实现一个可以创建 CSV 并将其转换为 JSON 的 Python 脚本。我们还学习了 Python 的'【JSON】'和' csv '模块及其常用功能。
参考
https://medium . com/@ Hannah 15198/convert-CSV-to-JSON-with-python-b 8899 c 722 f 6d
https://stack overflow . com/questions/19697846/how-to-convert-CSV-file-to-multiline-JSON
如何用 Python 把 Dictionary 转换成 JSON？
原文：https://www.askpython.com/python/dictionary/convert-dictionary-to-json
在本文中，让我们学习如何将 python 字典转换成 JSON。我们先来了解一下 JSON 是什么。JSON 代表 javascript 对象符号。它通常用于在 web 客户端和 web 服务器之间交换信息。JSON 的结构类似于 python 中的字典。条件是，JSON 键必须总是带双引号的字符串。而且，对应于键的值可以是任何数据类型，比如字符串、整数、嵌套 JSON 等。JSON 的返回类型是“字符串”对象类型。
示例:
import json
a = '{ "One":"A", "Two":"B", "Three":"C"}'
python 中的 Dictionary 是一种内置的数据类型，用于将数据存储在与值格式相关联的键中。存储在字典中的数据是无序的、唯一的对(键总是唯一的，值可以重复)，并且是可变的。dictionary 的返回类型是“dict”对象类型。
示例:
#Dictionary in python is built-in datatype so
#no need to import anything.
dict1 = { 'One' : 1, 'Two' : 2, 'C': 3}
将 Dict 转换为 JSON
Python 确实有一个名为“json”的默认模块，可以帮助我们将不同的数据形式转换成 JSON。我们今天使用的函数是 json。dumps()方法允许我们将 python 对象(在本例中是 dictionary)转换成等价的 JSON 对象。
- 首先，我们导入 json 模块
- 为必须转换成 JSON 字符串的字典分配一个变量名。
- 使用 json.dumps( 变量)进行转换
注意:不要混淆 json.dumps 和 json.dump. json.dumps()是一种可以将 Python 对象转换成 json 字符串的方法，而json.dump()是一种用于将 json 写入/转储到文件中的方法。
JSON 的语法
json.dumps(dict,intend)
- dict–我们需要转换的 python 字典
- intent–缩进的数量(代码行开头的空格)
import json
dict1 ={
"Name": "Adam",
"Roll No": "1",
"Class": "Python"
}
json_object = json.dumps(dict1, indent = 3)
print(json_object)
输出:
{
"Name": "Adam",
"Roll No": "1",
"Class": "Python"
}
使用 sort_keys 属性将字典转换为 JSON
使用前面讨论的 dumps() 方法中的 sort_key 属性，以排序的方式返回一个 JSON 对象。如果属性设置为 TRUE，那么字典将被排序并转换为 JSON 对象。如果它被设置为 FALSE，那么字典已经转换了它的方式，没有排序。
import json
dict1 ={
"Adam": 1,
"Olive" : 4,
"Malcom": 3,
"Anh": 2,
}
json_object = json.dumps(dict1, indent = 3, sort_keys = True)
print(json_object)
输出:
{
"Adam": 1,
"Anh": 2,
"Malcom": 3,
"Olive": 4
}
将嵌套的 dict 转换成 JSON
在 dict 中声明的 dict 称为嵌套 dict。dumps()方法也可以将这种嵌套的 dict 转换成 json。
dict1 ={
"Adam": {"Age" : 32, "Height" : 6.2},
"Malcom" : {"Age" : 26, "Height" : 5.8},
}
json_object = json.dumps(dict1, indent = 3, sort_keys = True)
print(json_object)
输出:
{
"Adam": {
"Age": 32,
"Height": 6.2
},
"Malcom": {
"Age": 26,
"Height": 5.8
}
}
摘要
在本文中，我们讨论了如何将字典数据结构转换成 JSON 以便进一步处理。我们使用 json 模块将字典序列化为 JSON。
参考
使用 Python 将电子书转换为有声读物
原文：https://www.askpython.com/python/examples/convert-ebook-to-audiobook
读书是一个好习惯，但是听书让这个过程变得更加方便。有声读物取代了传统书籍，因为我们可以随时随地轻松地听它们。如果我们可以编写一个有声读物制作程序，将电子书 pdf 转换成有声读物并为我们阅读，这将有多大用处？
在本教程中，我们将使用 Python 构建一个有声读物制作工具，它可以为我们朗读一本书。
使用 Python 阅读电子书作为有声读物
让我们进入制作图书阅读器或者将 PDF 电子书转换成有声读物的 Python 脚本的过程吧！
1.安装所需的模块
首先，我们需要安装所需的模块，这将大大简化我们编写有声读物制作程序的工作。我们使用 pip 包管理器安装 pyttsx3 和 PyPDF3 模块。
pyttsx3 是 Python 中的文本到语音转换库，而 PyPDF3 是 Python 中读取和编辑 PDF 文件的库。
pip install pyttsx3
pip install PyPDF3
2.导入 PDF 阅读器和 TTS 模块
在 python 文件中，我们从导入所需的模块开始。
import PyPDF3
import pyttsx3
现在我们初始化 pyttsx3 引擎对象来读取。
engine = pyttsx3.init()
3.打开并阅读 PDF
现在我们已经初始化了我们的语音引擎，我们需要打开 PDF 来阅读它的内容。我们将 pdf 的名称传递给 open 方法，如下所示:
如果 PDF 与 python 脚本不在同一个目录中，您需要传递名称和位置。
book = open('sample.pdf', 'rb')
为了逐行阅读 pdf 内容，我们使用 PyPDF3 模块的 PdffileReader 方法，如下所示:
然后，我们使用 extractText 方法从 pdf 阅读器的对象中提取文本。
pdfRead= PyPDF3.PdfFileReader(book)
#to start the reading from 1st page in the pdf
page = pdfRead.getPage(0)
#to extract text to read
text = page.extractText()
4.朗读 PDF
当我们打开时，阅读 pdf 内容，我们现在需要将这些数据输入到我们的 pyttsx3 库的语音引擎中
#takes in message to read or text
engine.say(text)
engine.runAndWait()
在执行脚本时，代码开始读取传递的 PDF。最终代码如下所示:
import PyPDF3
import pyttsx3
engine = pyttsx3.init()
book = open('sample.pdf', 'rb')
pdfRead= PyPDF3.PdfFileReader(book)
#to start the reading from 1st page in the pdf
page = pdfRead.getPage(0)
#to extract text to read
text = page.extractText()
#takes in message to read or text
engine.say(text)
engine.runAndWait()
5.改变演讲
pyttsx3 库为我们提供了各种类型的语音更改，例如:
改变语速的设置
rate = engine.getProperty('rate') # gets the current rate of speech
engine.setProperty('rate', 125) # sets up new rate of speech (passed in as 125 to change to 1.25x or 150 to make it to 1.5x)
改变语音的设置
voices = engine.getProperty('voices') # gets the current voice type
#engine.setProperty('voice', voices[0].id) #changing index, changes voices. 0 for male
engine.setProperty('voice', voices[1].id) #changing index, changes voices. 1 for female
改变音量的设置
volume = engine.getProperty('volume') #gets the current volume (min=0 and max=1)
engine.setProperty('volume',1.0) # setting up volume level between 0 and 1
我们还可以使用下面的代码将完整的有声读物文件——意思是完整的 pdf(书)以语音的形式保存在音频文件 (type .mp3)中:
engine.save_to_file('text, 'audiobook.mp3')
结论
这就是如何用 Python 编写有声读物制作程序的教程。我们希望你喜欢这个关于将 PDF 转换成有声读物的简短教程。继续玩这个脚本，让它更加直观和自动化！
如何用 Python 把 JSON 转换成字典？
原文：https://www.askpython.com/python/dictionary/convert-json-to-a-dictionary
大家好！在本教程中，我们将讨论如何将 JSON 转换成 Python 中的字典。
JSON 是什么？
JSON 代表 JavaScript 对象符号。它是表示结构化数据的最流行和被广泛接受的数据格式之一。它是一种轻量级格式，用于存储和交换用 JavaScript 符号编写的文本数据。包含 JSON 数据的文件必须以扩展名.json保存。
Python 中的 JSON
JSON 文件中 JSON 数据的表示类似于 Python 字典。这意味着 JSON 数据也是一组 name: value 对的集合，就像 Python 字典一样。
在 Python 中，我们有一个内置模块叫做 json 。让我们在 Python 程序中导入json模块来处理 JSON 数据。
将 JSON 转换成字典的先决条件
- 导入 Python json 模块。
- 如果 JSON 文件不在同一个目录中，请提供它的完整路径
- 所有的 JSON 数据(字符串)都应该用双引号括起来，以避免 JSONDecodeError。
创建一个示例 JSON 文件
让我们创建一个包含一些 JSON 字符串的样本 JSON 文件。我们将在我们的 Python 程序中使用这个 JSON 文件来演示json模块在 Python 中处理 JSON 数据的工作。
{
"Linux": ["Ubuntu", "Fedora", "CentOS", "Linux Mint",
"Debian", "Kali Linux"],
"Windows": ["Windows 2000", "Windows XP", "Windows Vista",
"Windows 7", "Windows 8", "Windows 10"],
"MacOS": ["OS X 10.8", "OS X 10.9", "OS X 10.10", "OS X 10.11",
"MacOS 10.12", "MacOS 10.13", "MacOS 10.14"]
}
将 JSON 转换成字典
我们已经创建了一个包含 JSON 数据(字符串)的样本 JSON 文件。现在，让我们将这个 JSON 数据转换成一个 Python 对象。我们将按照下面给出的步骤将 JSON 转换成 Python 中的字典
- 在程序中导入
json模块。 - 打开我们在上面创建的样本 JSON 文件。
- 使用
json.load()功能将文件数据转换成字典。 - 检查
json.load()函数返回的值的类型。 - 使用 for 循环打印 Python 字典中的键:值对。
- 关闭打开的示例 JSON 文件，这样它就不会被篡改。
让我们通过 Python 代码实现所有这些步骤。
# Import json Python module
import json
# Open the sample JSON file
# Using the open() function
file = open("C:\path\sample_file.json", 'r')
# Convert the JSON data into Python object
# Here it is a dictionary
json_data = json.load(file)
# Check the type of the Python object
# Using type() function
print(type(json_data))
# Iterate through the dictionary
# And print the key: value pairs
for key, value in json_data.items():
print(f"\nKey: {key}")
print(f"Value: {value}\n")
# Close the opened sample JSON file
# Using close() function
file.close()
输出:
<class 'dict'>
Key: Linux
Value: ['Ubuntu', 'Fedora', 'CentOS', 'Linux Mint', 'Debian', 'Kali Linux']
Key: Windows
Value: ['Windows 2000', 'Windows XP', 'Windows Vista', 'Windows 7', 'Windows 8', 'Windows 10']
Key: MacOS
Value: ['OS X 10.8', 'OS X 10.9', 'OS X 10.10', 'OS X 10.11', 'MacOS 10.12', 'MacOS 10.13', 'MacOS 10.14']
总结
在本教程中，我们学习了如何读取一个 JSON 文件，然后使用 json.load()函数将其转换为 Python 字典。希望您已经清楚这个主题，并准备好自己执行这些操作。感谢您阅读本文，请继续关注我们，了解更多关于 Python 编程的精彩内容。
将公里转换为英里的 Python 程序
原文：https://www.askpython.com/python/examples/convert-kilometers-to-miles
在本文中，我们将重点关注在 Python 中将公里转换成英里的逐步方法。
理解公里到英里转换背后的逻辑
让我们从基础开始，即理解这些测量单位的含义。公里和英里代表长度单位。
1 公里等于 0.62137 英里。
转换逻辑:
Miles = kilometers * 0.62137
OR
Kilometers = Miles / 0.62137
因此，值 0.62137 可以被认为是要进行转换的转换因子或比率。
理解了转换背后的逻辑之后，现在让我们使用 Python 作为代码库来理解和实现相同的内容。
将公里转换成英里的简单步骤
通过下面的步骤，你会对公里和英里的换算有一个清晰的认识。
步骤 1:定义一个变量来存储公里值或接受用户的输入。
kilo_meter = float(input("Enter the speed in Kilometer as a unit:\n"))
第二步:定义转换系数/比值，并将其存储到变量中。
conversion_ratio = 0.621371
第三步:定义一个变量来存储公里转换成英里的值。进一步写出公里到英里转换的逻辑。
miles = kilo_meter * conversion_ratio
第四步:使用 print()函数显示转换后的值。
print("The speed value in Miles:\n", miles)
完整代码:
kilo_meter = float(input("Enter the speed in Kilometer as a unit:\n"))
conversion_ratio = 0.621371
miles = kilo_meter * conversion_ratio
print("The speed value in Miles:\n", miles)
输出:
Enter the speed in Kilometer as a unit:
100
The speed value in Miles:
62.137100000000004
另一个简单的静态定义方法可以是定义一个 Python 函数来将公里转换成英里。
def km_to_mile(km):
con_ratio= 0.621371
mile = km*con_ratio
print("The speed value in Miles:\n", mile)
km_to_mile(100)
输出:
The speed value in Miles:
62.137100000000004
结论
到此，我们就结束了这个话题。如果你遇到任何疑问，请随时在下面发表评论，是的，继续尝试这样的编程问题，以增强和提高你的技能。
更多关于 Python 编程的帖子，请访问 Python @ AskPython 。
参考
Python 中如何把列表转换成字典？
原文：https://www.askpython.com/python/list/convert-list-to-a-dictionary
在本教程中，我们将讨论如何在 Python 中将列表转换成字典。
Python 中什么是列表？
Python 中的列表是一种线性数据结构，用于存储相同类型或不同类型的值的集合。列表中的每一项都用逗号(,)隔开。
Python 列表包含在方括号[]中。Python 列表是可变的，这意味着在 Python 程序内部创建之后，我们可以更改或修改它的内容。
Python 列表以有序的方式存储元素，我们可以通过索引直接访问列表中的任何元素。这就是我们如何在 Python 中创建一个列表，我们也可以使用type()函数来验证它是否是一个列表:
# Defining a Python list
ls = ['AskPython', 'JournalDev', 'LinuxforDevices']
# Printing the results
print(ls)
# Validating the type of 'ls'
print(type(ls))
输出:
['AskPython', 'JournalDev', 'LinuxforDevices']
<class 'list'>
Python 中的字典是什么？
Python 中的字典是一种特殊类型的数据结构，用于以键值对格式存储数据。Python 字典有两个主要组成部分:键&值，其中键必须是单个实体，但值可以是多值实体，如列表、元组等。
键及其值由冒号(:)分隔，每个项目(键-值对)由逗号(，)分隔，就像 Python 列表一样。一本字典被括在花括号{}里。像 Python 列表一样，Python 字典也是可变的。
Python 字典以无序的方式存储元素，我们可以通过它的键直接访问字典中的任何值。这就是我们如何在 Python 中创建一个字典，就像列表一样，我们也可以使用type()函数来验证它是否是一个字典:
# Defining a Python dictionary
ds = {'AskPython': "Python", 'JournalDev': "Java, Android, Python, Web", 'LinuxforDevices': "Unix/Linux"}
# Printing the results
print(ds)
# Validating the type of 'ds'
print(type(ds))
输出:
{'AskPython': 'Python', 'JournalDev': 'Java, Android, Python, Web', 'LinuxforDevices': 'Unix/Linux'}
<class 'dict'>
Python 中主要有两种将列表转换成字典的方法，一种是字典理解，另一种是使用 Python zip()方法。我们将逐一讨论它们。
亦读: Python 词典列表
使用字典理解将列表转换为字典
在这种将列表转换为字典的方法中，我们遍历给定的 Python 列表，并在花括号{}内创建相应的key:value。每个列表元素都成为字典中的一个键，我们可以根据自己的用途为每个键生成一个值。让我们看一个使用字典理解将 Python 列表转换成 Python 字典的例子。以下是演示它的 Python 代码:
# Defining a Python list
ls = ['E', 'J', 'O', 'T', 'Y']
# Using dictionary comprehension to convert the list to a dictionary
ds = {item: ord(item) for item in ls}
# Printing the results
print("Given Python list: ", ls)
print("Generated Python dictionary: ", ds)
# Validating the type of 'ds'
print(type(ds))
输出:
Given Python list: ['E', 'J', 'O', 'T', 'Y']
Generated Python dictionary: {'E': 69, 'J': 74, 'O': 79, 'T': 84, 'Y': 89}
<class 'dict'>
在上面的例子中，我们使用 Python ord()函数来获取列表中每一项的 ASCII 值，列表实际上是一个英文字母表。并将 ord()函数返回的 ASCII 值赋给字典的相应键作为其值。因此，我们为列表中的每一项生成了一个键值对，并将其转换为 Python 字典。
使用 Python zip()函数将列表转换成字典
在这个方法中，我们使用 Python iter ()函数创建一个迭代器，它将遍历给定的 Python 列表。然后我们将使用 Python zip()函数，它实际上将两个项目压缩在一起，并生成相应的key:value。
最后一步，我们使用 Python dict()函数进行类型转换，该函数根据zip()函数返回的压缩值创建并返回一个 Python 字典。
让我们看一个使用 Python zip()函数将 Python 列表转换成 Python 字典的例子。以下是演示它的 Python 代码:
# Defining a Python list
ls = ['E', 69, 'J', 74, 'O', 79, 'T', 84, 'Y', 89]
# Creating an iterator for list 'ls'
item = iter(ls)
# Using the Python zip() function to convert the list to a dictionary
ds = dict(zip(item, item))
# Printing the results
print("Given Python list: ", ls)
print("Generated Python dictionary: ", ds)
# Validating the type of 'ds'
print(type(ds))
输出:
Given Python list: ['E', 69, 'J', 74, 'O', 79, 'T', 84, 'Y', 89]
Generated Python dictionary: {'E': 69, 'J': 74, 'O': 79, 'T': 84, 'Y': 89}
<class 'dict'>
结论
在本 Python 教程中，我们学习了将 Python 列表转换为 Python 字典的非常有用和方便的技术。我们还学习了各种有用的 Python 函数，如iter()、zip()、dict()和ord()。希望您对使用这些 Python 函数进行更有趣的学习感到兴奋。
用 Python 将列表转换成 JSON 字符串[简单的一步一步]
原文：https://www.askpython.com/python/list/convert-list-to-json
在本教程中，我们将讨论如何将 Python 列表转换成 JSON。JSON 是表示结构化数据的最流行的数据格式之一，它使用 JavaScript 符号来存储和交换文本数据。我们开始吧！
导入 JSON 模块
我们需要用来处理 JSON 对象和文件的json Python 模块。它包含了dumps()函数，我们将在这里使用它将 Python 列表转换成 JSON。Python 中的json模块是一个标准的 Python 包，它附带了普通的 Python 解释器安装。因此，我们不必在本地系统上手动安装它。dumps()函数将 Python 列表作为其参数，将其转换为 JSON 字符串，然后返回该 JSON 字符串。使用dumps()函数将 Python 列表转换成 JSON 字符串的语法:
# Import the json Python module
import json
# Call the dumps() function and pass the Python list
json_str = json.dumps(list)
现在，让我们讨论如何将几种类型的 Python 列表即简单列表、列表列表和字典列表转换成 JSON 字符串。
将列表转换为 JSON
首先，我们将看到如何将一个简单的 Python 列表转换成 JSON 字符串。我们将创建一个简单的偶数 Python 列表，然后将其传递给上面讨论的json.dumps()函数，该函数将 Python 对象(列表)转换为 JSON 字符串。让我们看看如何使用 Python 代码实现这一点。
# Import json Python module
import json
# Create a Python list
list_1 = [2, 4, 6, 8, 10]
# Convert the above Python list to JSON string
json_str_1 = json.dumps(list_1)
# Check the type of value returned by json.dumps()
print(type(json_str_1))
# Print the result
print(json_str_1)
输出:
<class 'str'>
[2, 4, 6, 8, 10]
将列表列表转换为 JSON 字符串
其次，我们将讨论如何将一个列表的 Python 列表转换成 JSON 字符串。我们将创建一个包含大写英文字母字符及其对应的 ASCII 码的 Python 列表。然后我们将它传递给json.dumps()函数，该函数将把 Python 列表转换成 JSON 字符串。让我们编写 Python 代码来实现这一点。
# Import json Python module
import json
# Create a Python list of lists
list_2 = [['A', 'B', 'C', 'D', 'E'],
[65, 66, 67, 68, 69]]
# Convert the above Python list of lists to JSON string
json_str_2 = json.dumps(list_2)
# Check the type of value returned by json.dumps()
print(type(json_str_2))
# Print the result
print(json_str_2)
输出:
<class 'str'>
[["A", "B", "C", "D", "E"], [65, 66, 67, 68, 69]]
将字典列表转换为 JSON 字符串
第三，我们将看到如何将 Python 字典列表转换成 JSON 字符串。我们将创建一个包含奇数、偶数和质数列表的字典 Python 列表，这些列表对应于它们的键(标签)。然后我们将它传递给json.dumps()函数，该函数将把 Python 字典列表转换成 JSON 字符串。让我们通过 Python 代码来实现这一点。
# Import json Python module
import json
# Create a Python list of dictionaries
list_3 = [{'Odd': [1, 3, 5, 7, 9]},
{'Even': [2, 4, 6, 8, 12]},
{'Prime': [2, 3, 5, 7, 11]}]
# Convert the above Python list of dictionaries to JSON string
json_str_3 = json.dumps(list_3)
# Check the type of value returned by json.dumps()
print(type(json_str_3))
# Print the result
print(json_str_3)
输出:
<class 'str'>
[{"Odd": [1, 3, 5, 7, 9]}, {"Even": [2, 4, 6, 8, 12]}, {"Prime": [2, 3, 5, 7, 11]}]
结论
在本教程中，我们学习了如何使用json Python 模块及其dumps()函数将几种类型的 Python 列表转换成 JSON 字符串。希望你已经理解了上面讨论的概念，并准备好自己尝试一下。感谢阅读这篇文章！请继续关注我们，了解更多与 Python 编程相关的令人惊叹的学习内容。
Python 中如何把列表转换成数据帧？
原文：https://www.askpython.com/python-modules/pandas/convert-lists-to-dataframes
你好极客们！在本教程中，我们将讨论用 Python 从列表创建数据帧的不同方法。
也读: 如何在 Python 中组合 DataFrames？
Python 中的列表和数据帧是什么？
在 Python 中，列表是 Python 的标准数据结构之一，被广泛用作其他 Python 对象的数组。数据帧是由以表格形式存储数据的 pandas Python 模块提供的第三方 Python 对象。Pandas 数据框架可以从不同的 Python 对象创建，如列表、字典、NumPy 数组等。但是这里我们将只讨论从 Python 列表创建 pandas DataFrame 对象。所以让我们安装pandas Python 模块并开始我们的讨论。
C:\Users\Guest> pip install pandas
在 Python 中，我们有多种方法从列表中创建熊猫数据帧。但这里我们只讨论其中一些常用的。
1.从一维列表创建数据帧
这是创建熊猫数据帧对象 Python 列表的最简单的技术之一。在这个方法中，我们将创建一个包含少量元素的一维列表，并将其传递给DataFrame()函数。这将返回一个 pandas DataFrame 对象，该对象由传递的一维列表的数据元素组成。
让我们编写 Python 代码来从一维列表创建熊猫数据帧。
# Import pandas module
import pandas as pd
# Create a Python 1-D list
lst = ['Android', 'Bootstrap', 'Csharp', 'Django']
# Create a DataFrame using 1-D list
df = pd.DataFrame(lst)
print(df)
输出:
2.从二维列表创建数据框架(列表列表)
在这个方法中，我们创建一个包含一些元素的 2-D Python 列表，并将其传递给DataFrame()函数。此外，这个DataFrame()函数返回一个 pandas DataFrame 对象，该对象由传递的二维列表的数据元素组成。让我们看看从二维列表创建熊猫数据帧的 Python 代码。
# Import pandas module
import pandas as pd
# Create a Python 2-D list
lst = [['Anurag', 'Kumar', 25],
['Binod', 'Rathi', 36],
['Ravi', 'Yadav', 27],
['Divya', 'Singh', 28],
['Sanjay', 'Kumar', 21]]
# Create a DataFrame using 2-D list
df = pd.DataFrame(lst, columns = ['first_name', 'last_name', 'age'])
print(df)
输出:
3.从元组列表创建数据帧
我们还可以使用元组的 Python 列表来创建 pandas DataFrame 对象。同样，我们有三种方法从元组列表中创建熊猫数据帧。让我们逐一讨论。
方法 1:将元组列表传递给 DataFrame()函数
在这个方法中，我们简单地创建一个 Python 列表，其中包含 Python 元组形式的数据。然后我们将它传递给DataFrame()函数。然后，DataFrame()函数返回一个由元组列表的数据元素组成的 Pandas DataFrame 对象。
让我们通过 Python 代码来实现这一点。
# Import pandas module
import pandas as pd
# Create a Python list of tuples
list_tp = [('A1', 'A2', 'A3', 'A4', 'A5'),
('B1', 'B2', 'B3', 'B4', 'B5'),
('C1', 'C2', 'C3', 'C4', 'C5'),
('D1', 'D2', 'D3', 'D4', 'D5')]
# Create a DataFrame using list of tuples
df = pd.DataFrame(list_tp)
print(df)
输出:
方法 2:使用 from_records()函数
在这个方法中，我们创建一个包含 Python 元组形式的数据的列表，就像我们在上面的 Python 代码中创建的一样。并将其传递给from_records()函数，然后该函数返回一个由元组列表的数据元素组成的 Pandas DataFrame 对象。让我们编写 Python 代码来实现这一点。
# Import pandas module
import pandas as pd
# Create a Python list of tuples
list_tp = [('Sanjay Kumar', 'ECE', 8.15),
('Uttam Kumar', 'IPE', 7.83),
('Ravi Kumar', 'CSE', 9.12),
('Anurag Singh', 'ICE', 8.88)]
# Create a DataFrame using list of tuples
# and from_records() function
df = pd.DataFrame.from_records(list_tp, columns = ['Roll', 'Program', 'CGPA'])
print(df)
输出:
方法 3:使用 list()和 zip()函数
在这个方法中，我们使用list()和zip()函数创建一个 Python 元组列表，其中包含 Python 元组形式的数据。
zip()函数压缩传递给它的两个列表中的数据元素，并创建一个 Python tuple 对象。
list()函数从 Python zip()函数返回的迭代器对象中创建一个 Python 元组列表。
然后我们简单地将这个元组列表传递给DataFrame()函数，然后该函数返回一个由元组列表的数据元素组成的 Pandas DataFrame 对象。让我们看看实现这一点的 Python 代码。
# Import pandas module
import pandas as pd
# Create two Python lists
prog_lang = ['C++', 'Python', 'Matlab', 'Csharp']
file_extn = ['.cpp', '.py', '.mat', '.cs']
# Create a Python list of tuples
# using above lists and zip() function
list_tp = list(zip(prog_lang, file_extn))
# Create a DataFrame from lists using dictionary
df = pd.DataFrame(list_tp, columns = ['Language', 'Extension'])
print(df)
输出:
结论
在本教程中，我们学习了以下内容:
- Python 中的数据框架对象和列表是什么
- 如何从一维创建数据框架
- 如何从列表列表或二维列表创建数据框架
- 从元组列表创建数据帧的不同方法
在 Python 中将数字转换为单词[一位数接一位数]
原文：https://www.askpython.com/python/examples/convert-number-to-words
在本教程中，我们将学习如何转换一个数字到它的措辞(数字方面)。例如，如果数字是 12，单词将是“1-2”。对于其余的输入，将进行类似的操作。
代码实现
我们将遵循下面提到的一些步骤:
步骤 1:创建数字到单词映射的全局列表
创建一个全局列表，包含从 0 到 9 的每个数字的单词。列表将包含映射到索引的元素，如下表所示。
| 索引 | Zero | one | Two | three | four | five | six | seven | eight | nine |
| 措辞/价值 | 零 | 一个 | 二 | 三 | 四 | 五 | 六 | 七 | 八 | 九 |
Global list for digit to word mapping
# Global Array storing word for each digit
arr = ['zero','one','two','three','four','five','six','seven','eight','nine']
步骤 2:输入数字并创建主函数
为了输入数字，我们将使用input函数，然后将其转换为整数，我们还将创建一个空函数，将数字转换为单词。
# Global Array storing word for each digit
arr = ['zero','one','two','three','four','five','six','seven','eight','nine']
def number_2_word(n):
pass
n = int(input())
print("Number Entered was : ", n)
print("Converted to word it becomes: ",end="")
print(number_2_word(n))
步骤 3:编写函数内部的主要逻辑
对于这段代码，我们将利用递归。如果你对递归知之甚少或者一无所知，我建议你看看下面提到的教程:
阅读更多关于递归的内容:Python 中的递归
对于每个递归调用，我们将检查我的数字是否变成 0，如果是，我们将返回一个空字符串，否则我们将在模数函数的帮助下继续添加每个数字的单词，并将数字除以 10 以缩小数字并移动到下一个数字。
代码实现如下所示，为了便于理解，添加了一些注释。
# Global Array storing word for each digit
arr = ['zero','one','two','three','four','five','six','seven','eight','nine']
def number_2_word(n):
# If all the digits are encountered return blank string
if(n==0):
return ""
else:
# compute spelling for the last digit
small_ans = arr[n%10]
# keep computing for the previous digits and add the spelling for the last digit
ans = number_2_word(int(n/10)) + small_ans + " "
# Return the final answer
return ans
n = int(input())
print("Number Entered was : ", n)
print("Converted to word it becomes: ",end="")
print(number_2_word(n))
输出:
Number Entered was : 123
Converted to word it becomes: one two three
Number Entered was : 46830
Converted to word it becomes: four six eight three zero
结论
因此，在本教程结束时，我们看到，通过使用递归，可以很容易地将数字转换为单词(数字方式)。
感谢您的阅读！快乐学习！😇
如何将熊猫数据帧转换成 Excel 文件
原文：https://www.askpython.com/python-modules/pandas/convert-pandas-dataframe-to-excel
将数据导出到 Excel 文件通常是任何用户阅读和解释给定数据集的最首选和最方便的方式。可以使用 python 代码将您的网络抓取或其他收集的数据导出到 Excel 文件中，这也可以通过使用 Pandas 库以非常简单的步骤完成。
将 Pandas 数据框架转换为 Excel 的步骤
按照下面的一步一步的教程，学习如何将熊猫数据帧写入 Excel 文件。
第一步:安装 pandas 和 openpyxl
由于您需要导出 pandas 数据帧，显然您必须已经安装了 pandas 包。如果没有，运行下面的 pip 命令在您的计算机上安装 Pandas python 包。
pip install openpyxl
现在，要在 Python 中使用 Excel 文件函数，您需要使用下面的 pip 命令安装 openpyxl 模块。
pip install openpyxl
您可以将 DataFrame 写入 Excel 文件，而无需提及任何工作表名称。下面给出了一步一步的过程:
第二步:制作数据框架
- 在 python 代码/脚本文件中导入 Pandas 包。
- 创建要导出的数据的数据框架，并用行和列的值初始化数据框架。
Python 代码:
#import pandas package
import pandas as pd
# creating pandas dataframe
df_cars = pd.DataFrame({'Company': ['BMW', 'Mercedes', 'Range Rover', 'Audi'],
'Model': ['X7', 'GLS', 'Velar', 'Q7'],
'Power(BHP)': [394.26, 549.81, 201.15, 241.4],
'Engine': ['3.0 L 6-cylinder', '4.0 L V8', '2.0 L 4-cylinder', '4.0 L V-8']})
步骤 3:创建 Writer 对象并导出到 Excel 文件
- 使用 pandas 包的:ExcelWriter()方法创建一个 Excel Writer 对象
- 输入输出 excel 文件的名称，您要将我们的数据框架和扩展名写入该文件。(在我们的示例中，我们将输出 excel 文件命名为“converted-to-excel.xlsx”)
# creating excel writer object
writer = pd.ExcelWriter('converted-to-excel.xlsx')
- 在数据帧上调用 _excel()函数，将 excel Writer 作为参数传递，将数据导出到具有给定名称和扩展名的 Excel 文件中。
- 保存 writer 对象以保存 Excel 文件
# write dataframe to excel
df_cars.to_excel(writer)
# save the excel
writer.save()
print("DataFrame is exported successfully to 'converted-to-excel.xlsx' Excel File.")
替代-直接方法
一种直接的方法是将数据框直接导出到 Excel 文件，而不使用 ExcelWriter 对象，如以下代码示例所示:
import pandas as pd
# creating pandas dataframe from dictionary of data
df_cars = pd.DataFrame({'Company': ['BMW', 'Mercedes', 'Range Rover', 'Audi'],
'Model': ['X7', 'GLS', 'Velar', 'Q7'],
'Power(BHP)': [394.26, 549.81, 201.15, 241.4],
'Engine': ['3.0 L 6-cylinder', '4.0 L V8', '2.0 L 4-cylinder', '4.0 L V-8']})
#Exporting dataframe to Excel file
df_cars.to_excel("converted-to-excel.xlsx")
输出 Excel 文件
打开 excel 文件，您将看到写入文件的索引、列标签和行数据。
奖励提示
您不仅只能控制 excel 文件名，而不能将 python 数据帧导出到 Excel 文件，而且您还可以在 pandas 包中定制许多功能。
您可以更改 excel 文件的工作表名称
df.to_excel("output.xlsx", sheet_name='Sheet_name_1')
使用 Excel writer 向现有 Excel 文件追加内容
pd.ExcelWriter('output.xlsx', mode='a')
其他选项包括渲染引擎、开始行、标题、索引、合并单元格、编码和许多其他选项。
在熊猫官方文档了解更多可用选项。
结论
我希望你现在明白了如何使用手头的不同库将熊猫数据帧导出到 Excel。请关注 AskPython，获取更多有趣的教程。
将 Pandas 系列转换为 Numpy 数组的 4 种方法
原文：https://www.askpython.com/python-modules/numpy/convert-pandas-series-to-numpy-array
你们可能都已经熟悉熊猫有两个主要的数据结构，即系列和数据框架。在以前的文章中，我们已经了解了如何将数据帧转换成 Numpy 数组。所以今天，在这篇文章中，我们将学习如何在 python 中将一个序列转换成一个 Numpy 数组。
Python 中的熊猫系列是什么？
Pandas series 是一维数据结构 Pandas，可以接受多种数据类型，如整数、对象和浮点数据类型。Pandas 系列相对于数据框的优势在于它可以存储多种数据类型。可以用多种方法创建序列，例如从列表、元组或字典创建序列，或者通过传递标量值来创建序列。
在这篇文章中，我们将用 python 制作一系列字典。在本文的其余部分，我们也将使用这个系列。
import pandas as pd
list = ['a', 'b', 'c', 'd', 'e']
my_series = pd.Series(list)
print(my_series)
输出:
0 a
1 b
2 c
3 d
4 e
Python 中的 Numpy 数组是什么？
一个 NumPy 数组是一个只接受相似类型数据的数据结构。Numpy 数组几乎就像列表，但不要混淆。数组比列表更有效，也更紧凑。
让我们看看如何创建一个 NumPy 数组。
import numpy as np
my_arr = np.array([1, 2, 3, 4, 5])
print(my_arr)
输出:
[1 2 3 4 5]
将 Pandas 系列转换为 Numpy 数组的方法
现在我们将学习如何使用一些函数和属性将 Pandas 系列转换成 NumPy 数组。
1.使用 Pandas.index.to_numpy()函数
这是一个相当简单的方法，因为它直接将序列中的元素转换成 NumPy 数组。我们将首先与 pd 一起创建一个系列。DataFrame()函数，然后将其转换为 Numpy 数组。
例如，
import pandas as pd
df = pd.DataFrame({'A1': [1, 2, 3], 'A2': [4, 5, 6]}, index=['a', 'b', 'c']);
array = df.index.to_numpy()
print(array)
输出:
['a' , 'b' , 'c']
2.使用 pandas.index.values 属性
在这种方法中，我们将把系列转换成两个步骤。首先，我们将使用熊猫。index.values 属性该属性将以数组的形式返回索引处的值。在 NumPy.array 函数的帮助下，这个数组将被转换为 NumPy 数组。
import pandas as pd
import numpy as np
df = pd.DataFrame({'A1': [1, 2, 3], 'A2': [4, 5, 6]}, index=['a', 'b', 'c']);
array = np.array(df.index.values)
print(array)
输出:
['a' , 'b', 'c']
3.使用 pandas.index.array 属性
该属性也分两步工作。首先，它将熊猫系列转换成熊猫数组。然后，在 numpy.array()函数的帮助下，Pandas 数组被转换为 Numpy 数组。
import pandas as pd
import numpy as np
df = pd.DataFrame({'A1': [1, 2, 3], 'A2': [4, 5, 6]}, index=['a', 'b', 'c']);
array = np.array(df.index.array)
print(array)
输出:
['a' , 'b' , 'c']
4.使用 Pandas series.to_numpy()函数
通过这个函数，我们将使用一个数据集，我们将首先从数据集中的一列创建一个序列，然后将其转换为一个 Numpy 数组。在这里，我们首先从电影信息栏创建了一个系列。然后我们使用 series.to_numpy()函数创建一个 numpy 数组。
import pandas as pd
data = pd.read_csv("/content/Highest Holywood Grossing Movies.csv")
data.dropna(inplace = True)
my_ser = pd.Series(data['Movie Info'].head())
# using to_numpy() function
print((my_ser.to_numpy()))
输出:
['As a new threat to the galaxy rises, Rey, a desert scavenger, and Finn, an ex-stormtrooper, must join Han Solo and Chewbacca to search for the one hope of restoring peace.'
"After the devastating events of Avengers: Infinity War, the universe is in ruins. With the help of remaining allies, the Avengers assemble once more in order to reverse Thanos' actions and restore balance to the universe."
'A paraplegic Marine dispatched to the moon Pandora on a unique mission becomes torn between following his orders and protecting the world he feels is his home.'
'A seventeen-year-old aristocrat falls in love with a kind but poor artist aboard the luxurious, ill-fated R.M.S. Titanic.'
'A new theme park, built on the original site of Jurassic Park, creates a genetically modified hybrid dinosaur, the Indominus Rex, which escapes containment and goes on a killing spree.']
结论
在本文中，我们学习了很多将序列转换成 Numpy 数组的不同方法。一些方法分两步完成，而另一些方法一步完成。
使用 Python 将 PDF 转换为 TXT 文件
原文：https://www.askpython.com/python/examples/convert-pdf-to-txt
在本文中，我们将创建一个简单的 python 脚本来帮助我们将 pdf 转换成 txt 文件。您可以下载各种应用程序，用于将 pdf 转换为 txt 文件。有很多在线应用程序也可用于此目的，但如果您可以使用简单的 python 脚本创建自己的 pdf 到 txt 文件转换器，那该有多酷。
我们开始吧！
Python 中 PDF 转换为 TXT 的步骤
事不宜迟，让我们开始把 pdf 转换成 txt 的步骤。
步骤 01–创建一个 PDF 文件(或找到一个已有的文件)
- 打开新的 Word 文档。
- 在 word 文档中键入您选择的一些内容。
- 现在到文件>打印>保存。
- 请记住将 pdf 文件保存在保存 python 脚本文件的同一位置。
- 现在你的。创建并保存 pdf 文件，稍后您可以将其转换为. txt 文件。
步骤 02–安装 PyPDF2
- 首先，我们将安装一个名为 PyPDF2 的外部模块。
- PyPDF2 包是一个纯 python PDF 库，您可以使用它来分割、合并、裁剪和转换 pdf。根据 PyPDF2 网站，你也可以使用 PyPDF2 添加数据、查看选项和密码到 PDF。
- 要安装 PyPDF2 包，请打开 windows 命令提示符并使用 pip 命令来安装 PyPDF2:
C:\Users\Admin>pip install PyPDF2
Collecting PyPDF2
Downloading PyPDF2-1.26.0.tar.gz (77 kB)
|████████████████████████████████| 77 kB 1.9 MB/s
Using legacy 'setup.py install' for PyPDF2, since package 'wheel' is not installed.
Installing collected packages: PyPDF2
Running setup.py install for PyPDF2 ... done
Successfully installed PyPDF2-1.26.0
这将在您的系统上成功安装您的 PyPDF2 包。一旦它被安装，你就可以开始你的脚本了。
步骤 03–为脚本打开一个新的 Python 文件
- 打开你的 python IDLE 并按 ctrl + N 键，这将打开你的文本编辑器。
- 您可以使用您喜欢的任何其他文本编辑器。
- 将文件另存为 your_pdf_file_name .py。
- 保存这个。py 文件放在与 pdf 文件相同的位置。
让我们从脚本代码开始
import PyPDF2
#create file object variable
#opening method will be rb
pdffileobj=open('1.pdf','rb')
#create reader variable that will read the pdffileobj
pdfreader=PyPDF2.PdfFileReader(pdffileobj)
#This will store the number of pages of this pdf file
x=pdfreader.numPages
#create a variable that will select the selected number of pages
pageobj=pdfreader.getPage(x+1)
#(x+1) because python indentation starts with 0.
#create text variable which will store all text datafrom pdf file
text=pageobj.extractText()
#save the extracted data from pdf to a txt file
#we will use file handling here
#dont forget to put r before you put the file path
#go to the file location copy the path by right clicking on the file
#click properties and copy the location path and paste it here.
#put "\\your_txtfilename"
file1=open(r"C:\Users\SIDDHI\AppData\Local\Programs\Python\Python38\\1.txt","a")
file1.writelines(text)
下面是代码的快速解释:
- 我们首先创建一个 Python 文件对象，并以“读取二进制(rb)”模式打开 PDF 文件
- 然后，我们创建 PdfFileReader 对象，该对象将读取上一步中打开的文件
- 变量用于存储文件中的页数
- 最后一部分将把 PDF 中识别的行写入您指定的文本文件
输出:
PDF 文件图像:
转换后的 Txt 文件图像:
简单来说，这是关于如何通过编写自己的 python 脚本将 pdf 文件转换为 txt 文件。试试吧！
将秒转换为小时和分钟的 Python 程序
原文：https://www.askpython.com/python/examples/convert-seconds-hours-minutes
有时候我们必须在 Python 中将秒转换成小时和分钟。当我们以时间戳的形式存储数据，并且必须以分钟和秒的格式正确显示数据时，这是最需要的。在本文中，我们将看看将秒转换成小时和分钟的 Python 程序。
不同时间单位的转换规则
每天由 24 小时组成。每小时有 60 分钟，每分钟有 60 秒。所以，一小时有 3600 秒，一天有 86400 秒。
在 Python 中有不同的方法将秒转换成分钟，将分钟转换成小时。
方法 1:定义一个 Python 函数将秒转换成小时和分钟
我们可以编写一个自定义的 Python 函数来将秒值转换成小时和分钟。
最初，我们根据 24 小时格式转换输入的秒值。
秒=秒% (24*3600)
由于 1 小时相当于 3600 秒，1 分钟相当于 60 秒，我们按照下面的逻辑将秒转换为小时和分钟。
小时=秒//3600
min =秒// 60
举例:
def time_conversion(sec):
sec_value = sec % (24 * 3600)
hour_value = sec_value // 3600
sec_value %= 3600
min = sec_value // 60
sec_value %= 60
print("Converted sec value in hour:",hour_value)
print("Converted sec value in minutes:",min)
sec = 50000
time_conversion(sec)
输出:
Converted sec value in hour: 13
Converted sec value in minutes: 53
方法 2: Python 时间模块将秒转换成分钟和小时
Python 时间模块包含时间。 strftime ()函数通过将格式代码作为参数传递，以指定格式将时间戳显示为字符串。
time.gmtime()函数用于将传递给该函数的值转换为秒。此外，time.strftime() function使用指定的格式代码显示从time.gmtime() function传递到小时和分钟的值。
举例:
import time
sec = 123455
ty_res = time.gmtime(sec)
res = time.strftime("%H:%M:%S",ty_res)
print(res)
输出:
10:17:35
方法三:天真的方法
举例:
sec = 50000
sec_value = sec % (24 * 3600)
hour_value = sec_value // 3600
sec_value %= 3600
min_value = sec_value // 60
sec_value %= 60
print("Converted sec value in hour:",hour_value)
print("Converted sec value in minutes:",min_value)
输出:
Converted sec value in hour: 13
Converted sec value in minutes: 53
方法 4: Python 日期时间模块
Python datetime 模块有各种内置函数来操作日期和时间。datetime.timedelta() function以适当的时间格式处理和表示数据。
举例:
import datetime
sec = 123455
res = datetime.timedelta(seconds =sec)
print(res)
输出:
1 day, 10:17:35
摘要
Python 提供了许多将秒转换成分钟和小时的模块。我们可以创建自己的函数或者使用时间和日期时间模块。
下一步是什么？
参考
如何在 Python 中把集合转换成列表？
原文：https://www.askpython.com/python/list/convert-set-to-list-python
我们可以在 Python 中使用内置的 list() 方法将一个集合转换成列表。让我们看一些使用这个函数的例子。
在 Python 中将集合转换为列表的方法
我们将讨论一些简单的方法，这些方法允许快速地将 python 集合对象转换成列表对象。
1.使用 list()函数
list() 函数将 iterable 作为参数，并将其转换为列表类型的对象。这是一个可供您使用的内置方法。
my_list = list(my_iterable)
由于一个集合也是可迭代的，我们可以将它传递给list()方法，并得到我们对应的列表。
my_set = set({1, 4, 3, 5})
my_list = list(my_set)
print(my_list)
如预期的那样，输出将是包含上述值的列表。
[1, 3, 4, 5]
注意，列表的顺序可以是随机的，不一定是有序的。
例如，以下面的片段为例。
s = set()
s.add("A")
s.add("B")
print(list(s))
我的情况下的输出:
['B', 'A']
2.使用手动迭代
我们也可以手动将元素添加到列表中，因为集合是可迭代的。除了由您自己编写之外，这个方法与使用 list()方法相比没有任何实际优势。
s = set({1, 2, 3})
a = []
for i in s:
a.append(i)
print(a)
同样，输出是一个列表:
[1, 2, 3]
将 frozenset 转换为列表
Python frozenset 对象类似于集合，但不可变。因此，我们不能修改冷冻集的元素。我们也可以使用 list() 来转换这种类型的集合。
f_set = frozenset({1, 3, 2, 5})
a = list(f_set)
print(a)
输出
[1, 2, 3, 5]
参考
- JournalDev 关于将集合转换成列表的文章
在 Python 中将字符串转换为列表
原文：https://www.askpython.com/python/string/convert-string-to-list-in-python
在编程时，我们可能需要在 Python 中将一个字符串转换成一个列表。那可能是任何其他原因。但是，这里出现了一个问题，我们如何将一个字符串转换成不同形式的列表？
因此，在本教程中，我们将学习如何在 Python 中将字符串转换成列表。
Python 中把字符串转换成列表的方法
在 Python 中，将一个字符串转换成一个列表是一件非常简单的工作。根据我们的要求，可以通过以下不同的方法来实现。
在本教程中，我们将讨论在不同情况下使用 Python 将字符串转换为列表的所有方法。下面我们列出了所有的方法:
- 字符串列表中的一个字符串
- 字符串到字符列表
- 字符串列表到列表列表的列表
- CSV 到列表
- 一个由整数组成的字符串到一个整数列表
现在我们将逐一讨论上述每一种技术。
1.字符串到字符串列表
当我们需要将一个字符串转换成 Python 中的一个列表，该列表包含父字符串的组成字符串(之前由一些分隔符分隔，如、或空格)，我们使用这个方法来完成任务。
例如，假设我们有一个字符串“Python 很棒”，并且我们想要一个只包含之前用空格分隔的给定名称的列表，我们只需根据空格的位置将字符串分成几个部分就可以得到所需的列表。
让我们看一个例子来更好地理解它。
#given string
string1="Python is great"
#printing the string
print("Actual String: ",string1)
#gives us the type of string1
print("Type of string: ",type(string1))
print("String converted to list :",string1.split())
#prints the list given by split()
输出:
String To List Of Strings
在上面的代码中:
- 我们考虑一个字符串，
string1="Python is great",并尝试转换相同的组成字符串列表 - type()给出了传递给方法的对象的类型，在我们的例子中是一个字符串
- split()用于根据给定的分隔符将一个字符串拆分成一个列表。在我们的代码中，单词由空格分隔。默认情况下，如果我们不向 split()方法传递任何东西，它会根据空格的位置拆分字符串
- 因此，尽管我们没有提到 separator 参数，
split()方法给了我们一个相应字符串的列表
2.字符串到字符列表
如果我们需要一个字符串中的字符列表怎么办？在这种情况下，在 Python 中使用list()方法直接将类型从字符串转换为列表就可以了。
当然，如果输入字符串是类似于 "abcd" 的东西，那么使用list()方法将字符串类型化为一个列表会给我们一个列表，它的元素是单个字符 'a '，' b '，' c '，' d' 。看看下面给出的示例代码。
#given string
string1="AskPython"
#printing the string
print("Actual String: ",string1)
#confirming the type()
print("Type of string: ",type(string1))
#type-casting the string into list using list()
print("String converted to list :\n",list(string1))
输出:
String To List Of Characters
理解代码:
- 首先在这里，我们初始化一个字符串，
string1为 "AskPython" ，并使用type()方法打印它的类型 - 正如我们所观察到的，使用
list()方法对字符串进行类型转换会根据需要为我们提供一个成员字符列表
3.字符串列表到列表列表
在这里，我们将看到如何结合上述两种方法来将一个字符串转换成一个字符列表。
仔细看下面给出的例子，
#Given string
string1="This is Python"
print("The actual string:",string1)
#converting string1 into a list of strings
string1=string1.split()
#applying list method to the individual elements of the list string1
list1=list(map(list,string1))
#printing the resultant list of lists
print("Converted to list of character list :\n",list1)
输出:
String To List Of Character Lists
理解代码:
- 在这种情况下，在初始化字符串
string1之后，我们使用第一种方法，将它转换成一个字符串列表 - 也就是说，此时 string1 是由
[ 'This', 'is', 'Python' ]给出的字符串列表 - 然后我们将
list()方法应用于列表的所有元素 - string1 。正如我们在前面的例子中看到的，这给了我们一个由字符列表组成的列表。注意，使用映射()函数进行批量类型转换
4.CSV 至列表
CSV(逗号分隔值)字符串，顾名思义就是由逗号分隔的值或数据组成的字符串。
让我们看看如何在 Python 中将这种类型的字符串转换成列表。
#given string
string1="abc,def,ghi"
print("Actual CSV String: ",string1)
print("Type of string: ",type(string1))
#spliting string1 into list with ',' as the parameter
print("CSV converted to list :",string1.split(','))
输出:
CSV To List
这里:
- 类似地，我们首先考虑一个字符串 string1 ，其中包含由逗号(、)分隔的各种数据或值
- 在打印完它和它的
type()之后，我们继续根据参数'，'对它进行分割 - 这使得值“abc”、“def”和“ghi”成为列表的元素。这样，我们能够从给定的 CSV 中提取值
5.由整数组成的字符串转换为整数列表
现在我们要转换一个字符串，该字符串只包含由空格、逗号等分隔的整数。，到一个有个整数个元素的列表。
例如，看看下面的代码，
#string with integers sepated by spaces
string1="1 2 3 4 5 6 7 8"
print("Actual String containing integers: ",string1)
print("Type of string: ",type(string1))
#converting the string into list of strings
list1=list(string1.split())
print("Converted string to list : ",list1)
#typecasting the individual elements of the string list into integer using the map() method
list2=list(map(int,list1))
print("List of integers : ",list2)
输出:
String With Integers To List
现在:
- 我们取一个字符串，
string1作为 "1 2 3 4 5 6 7 8" ，并连续打印它和它的 type() - 然后，我们使用
split()方法将其拆分，并将结果列表存储到一个列表中， list1 。在这一点上，list1 持有 [ '1 '，' 2 '，' 3 '，' 4 '，' 5 '，' 6 '，' 7 '，' 8' ] 正如我们从输出中所看到的，正如预期的那样 - 现在我们在整个列表中映射函数
int()，将每个元素类型化为整数。此外，我们将类型化的映射列表存储到列表 2 中并打印出来 - 结果，我们得到了一个由整数元素组成的列表，现在我们可以对其执行算术运算。
结论
这就是现在，这是关于使用各种方法将字符串转换成不同的列表。尝试使用适合您的代码、解决您的目的以及满足您的要求的方法。欢迎在评论中提问。
参考
将文本转换成 Python 中的首字母缩略词——完整指南
原文：https://www.askpython.com/python/examples/convert-text-to-acronyms
一个acronym是一个长短语的缩短版本，例如，我们有 NLP 用于自然语言处理。在本教程中，我将向您展示如何创建一个将文本转换为缩写的 Python 应用程序。
虽然拼出整个单词需要更长的时间，但说出或写出每个单词的首字母或整个单词的缩写形式需要更少的时间。因此，在日常用语中使用首字母缩略词会使交流更容易。
也读作:用 Python 加密价格预测
在 Python 中将文本转换成首字母缩略词
为了实现首字母缩略词，我们的目标是从给定的句子中生成单词的简短形式。同样可以通过拆分索引得到第一个单词然后组合。
看看下面提到的代码，然后我们将一行一行地深入代码内部。
Phrase = input("Enter a Phrase to convert: ")
list_words = Phrase.split()
final_acro = ""
for i in list_words:
final_acro+=i[0].upper()
print("Final Acroynm : ",final_acro)
for i in range(len(final_acro)):
print(final_acro[i]," -- ",list_words[i])
- 在输入功能的帮助下，
Line 1获取需要转换成缩略词的短语的输入。 Line 2会在拆分功能的帮助下将句子转换成单词列表，默认情况下，该功能会根据空格拆分句子。Line 3正在用一个空字符串初始化最终的首字母缩写词，该字符串稍后将被更改。- 从
Line 4和Line 5开始，我们有一个循环，将每个单词的第一个字母作为一个字符添加到最终的缩写词中。 - 首字母缩略词总是包含大写字母，因此，在大写函数的帮助下，每个单词的每个第一个字母都被转换成大写，而不管它们之前的大小写。
- 从
Line 7到Line 9将显示在循环和打印语句的帮助下创建的最终缩写。
输出示例
下图显示了执行上一节中提到的代码后的一些示例输出。
Sample Output Acronym
Sample Output2 Acronym
结论
我希望你理解首字母缩写词以及如何用 python 实现它们。你自己试试！
编码快乐！😇
想了解更多？查看下面提到的教程:
在 Python 中将元组转换为字符串[一步一步]
原文：https://www.askpython.com/python/string/convert-tuple-to-a-string
在本教程中，我们将讨论在 Python 中将元组转换为字符串的不同方法。
Python 中的元组是什么？
在 Python 中，元组是一种线性数据结构，用于存储有序的数据集合，这些数据可以是相似的类型，也可以是不同的类型。元组的元素被括在括号()中。
元组的所有元素都从0 to N-1开始索引，其中 N 是元组的长度或大小，我们可以直接访问元组的任何元素。
它还允许存储重复值，这意味着不同的索引元素可以具有相同的值。
一个元组本质上是不可变的，这意味着我们在创建它之后不能改变它的值。
下面是我们如何用 Python 创建一个tuple。我们将使用 type()方法来验证一个元组是否已经被创建。
# Defining a Python tuple
tp = ('Ubuntu', 'Kali', 'Debian', 'Fedora', 'Ubuntu')
# Printing the results
print(tp)
# Validating the type of 'tp'
print(type(tp))
输出:
('Ubuntu', 'Kali', 'Debian', 'Fedora', 'Ubuntu')
<class 'tuple'>
Python 中的字符串是什么？
在 Python 中，字符串是最常用的数据类型。任何用单引号、双引号或三引号括起来的值都被视为字符串。三重引号还允许您在字符串变量中输入多行。
一个 Python 字符串可以被认为是一个字符数组，但是请记住我们在 Python 中没有任何字符数据类型，所以即使是单个字符也是一个字符串。
像 Python tuple 一样，一个字符串的所有元素(字符)都从0 to N-1开始索引，其中 N 是字符串的长度或大小，我们可以直接访问字符串的任何字符。
Python 字符串是可变的，这意味着我们可以在创建它之后改变它的值。Python 中有一个内置函数[print()](https://www.askpython.com/python/built-in-methods/python-print-function),用于在控制台上打印字符串值。
# Defining Python string
str1 = 'AskPython'
str2 = "LinuxforDevices"
str3 = """AskPython and LinuxforDevices
are parts of JournalDev
IT Services Private Limited."""
# Printing the results
print(str1)
print(str2)
print(str3)
# Validating the type of str1, str2, & str3
print(type(str1))
print(type(str2))
print(type(str3))
输出:
AskPython
LinuxforDevices
AskPython and LinuxforDevices
are parts of JournalDev
IT Services Private Limited.
<class 'str'>
<class 'str'>
<class 'str'>
将元组转换为字符串的 3 种方法
在 Python 中，主要有三种将元组转换为字符串的方法，这三种方法是经常使用的，理解起来也很重要。让我们逐一讨论。
推荐阅读: Python astype()方法
1.使用 for 循环将元组转换为字符串
在这个将 Python tuple转换成 Python string的方法中，我们将使用简单的 for循环来遍历元组元素，并不断将元组的每个元素添加到一个空的 Python 字符串中。让我们通过下面的 Python 代码来理解这一点。
# Defining a Python tuple
tp = ('Linux', 'for', 'Devices')
# Creating an empty Python string
st = ''
# Using the Python for loop to convert the tuple to a string
for item in tp:
st = st + item
# Printing the results
print("Given Python tuple: ", tp)
print("Generated Python string: ", st)
# Validating the type of 'st'
print(type(st))
输出:
Given Python tuple: ('Linux', 'for', 'Devices')
Generated Python string: LinuxforDevices
<class 'str'>
2.使用 Python join()函数将元组转换为字符串
在这个将 Python tuple转换成 Python string的方法中，我们将使用str.join()函数。这个 Python 函数将 tuple 这样的可迭代 Python 对象作为其参数，并返回使用字符串分隔符或分隔符连接的 Python 字符串。这个分隔符或定界符可以是
e 任何字符串，但通常，我们使用空字符串("")、逗号(，)、连字符(-)和单个空格(" ")。让我们通过下面的 Python 代码来理解这一点。
# Defining a Python tuple
tp = ('AskPython', 'is', 'a', 'part', 'of', 'JournalDev.')
# Creating a string separator/delimiter
# Here it's a single space
st = ' '
# Using the Python str.join() function to convert the tuple to a string
st = st.join(tp)
# Printing the results
print("Given Python tuple: ", tp)
print("Generated Python string: ", st)
# Validating the type of 'st'
print(type(st))
输出:
Given Python tuple: ('AskPython', 'is', 'a', 'part', 'of', 'JournalDev.')
Generated Python string: AskPython is a part of JournalDev.
<class 'str'>
3.使用 Python reduce()函数将元组转换为字符串
在这个将 Python tuple转换成 Python string的方法中，我们将使用reduce()函数。在 Python 中，reduce()函数将一个函数作为其第一个参数，将一个的可迭代函数作为其第二个参数。
然后，它将该函数应用于 iterable 对象的每个元素，并返回该函数执行的操作的最终结果。
这里我们将传递add函数和一个元组作为 iterable 对象。这样，reduce()函数会将元组的每个元素相加。
我们先来了解一下如何使用这个reduce()和add()函数，通过 Python 代码将一个元组转换成一个字符串。
注意: 要使用reduce()和add()函数，我们必须导入两个 Python 模块funtools和operator。由于reduce()和add()功能分别定义在funtools和operator模块中。我们不需要安装这些模块，因为它们是 Python 的标准模块，并且与 Python 解释器一起安装在系统上。
# Importing Python functools module which contains the reduce() function
import functools
# Importing Python operator module which contains the add() function
import operator
# Defining a Python tuple
tp = ('Linux', 'for', 'Devices')
# Using the Python reduce() function to convert the tuple to a string
st = functools.reduce(operator.add, tp)
# Printing the results
print("Given Python tuple: ", tp)
print("Generated Python string: ", st)
# Validating the type of 'st'
print(type(st))
输出:
Given Python tuple: ('Linux', 'for', 'Devices')
Generated Python string: LinuxforDevices
<class 'str'>
使用 Python join()将元组转换为字符串时出错
如果我们试图使用join()函数将一个元组(至少有一个非字符串元素)转换成 Python 中的字符串，那么我们可能会得到一个错误。
这实际上是一个 TypeError ，它的产生是因为join()函数不能将一个字符串值与一个非字符串值相连接。
因此，为了克服这个TypeError，我们使用了map()函数。在 Python 中，map()函数接受两个参数，第一个是一个函数，第二个是一个可迭代 Python 对象，就像一个tuple，然后它将该函数应用于可迭代对象的每个元素。
最后，它返回一个 map 对象，实际上是一个迭代器。这个迭代器属于 iterable，它的元素是应用于作为参数传递的 iterable 对象的每个元素的函数的结果。
让我们通过 Python 代码来理解这个概念。
# Defining a Python tuple with two non-string elements (float)
tp = ('Ubuntu', 'is', 'available', 'in', 'different', 'versions:', 20.04, 18.04, 'etc.')
# Creating a string separator/delimiter
# Here it's a single space
st = ' '
# Using the Python join() function to convert the tuple to a string
st = st.join(tp)
# Printing the results
print("Given Python tuple: ", tp)
print("Generated Python string: ", st)
# Validating the type of 'st'
print(type(st))
输出:
TypeError With str.join() function
现在让我们使用 map()函数和 join()函数运行上面的 Python 程序，看看这个 TypeError 是否被删除了。
# Defining a Python tuple with two non-string elements (float)
tp = ('Ubuntu', 'is', 'available', 'in', 'different', 'versions:', 20.04, 18.04, 'etc.')
# Creating a string separator/delimiter
# Here it's a single space
st = ' '
# Using the Python map() function with str.join() function to convert the tuple to a string
# Here the first argument is str() function & the second argument is a tuple
st = st.join(map(str, tp))
# Printing the results
print("Given Python tuple: ", tp)
print("Generated Python string: ", st)
# Validating the type of 'st'
print(type(st))
输出:
Given Python tuple: ('Ubuntu', 'is', 'available', 'in', 'different', 'versions:', 20.04, 18.04, 'etc.')
Generated Python string: Ubuntu is available in different versions: 20.04 18.04 etc.
<class 'str'>
总结
在本教程中，我们学习了 Python 中三种不同的将元组转换为字符串的方法。我们还学习了 Python 中的join()函数、map()函数、reduce()函数。我们还学习了如何解决在 Python 中使用str.join()函数将元组转换成字符串时出现的TypeError。
Python 中元组到数组的转换——完整指南
原文：https://www.askpython.com/python/array/convert-tuple-to-array
在本文中，我们将学习如何在 Python 中将元组转换成数组。Python 是一种很棒的编程语言。从它出现的那天到今天，它的受欢迎程度与日俱增。它在编程中如此受欢迎有一些原因。
关于 Python 的快速背景
- 这是一个开源项目
- Python 的创造者 Guido Von Rossum 先生从开发之初就让它成为一个开源项目。他相信保持它的免费贡献将会给它增加更多的功能。不仅如此，不同的开发人员还可以使它跨平台，并为各种其他领域开发它。随着时间的推移，他的想法最终获得了成功。
- 开发者现在正在为它做贡献，各种模块正在帮助学习者非常容易地学习各种新概念。
- 庞大的库支持
- 由于开源的贡献，各种模块和库是可用的。每个库独立于独立的任务。
- 这些库很容易添加到 python 环境中。pip 包(Python 的包安装程序)使它变得简单。
- 强大的开发者支持
- python 的开发者遍布世界各地。
- 他们不断发送越来越多的高级代码，让这个项目成为编码人员更好的平台。
- 从中选择的域
- 这有不同的领域。机器学习、数据科学、人工智能、网页抓取、网页开发、物联网和云计算等。是这些领域中的一些。
- 核心应用还包括软件开发。
- 易学易懂
- Python 易学易懂。就是这么简单，一个人一天之内就能把基本的算术和输入操作搞清楚。
- 它是一种面向对象的多用途编程语言，具有最简单的类实现。
Python 中的数组和列表
考虑到我们需要为一些编程相关的工作创建十个整型变量。我们需要做一些声明，很明显，这将覆盖十行额外的代码。编写这样的代码是一项单调乏味的任务。因此，我们有这个问题的数组。
Python 中的数组或列表是需要学习的最基本的数据结构之一。它们是属于一种或多种数据类型的元素的集合。背后的想法。我们可以多次访问数组中的元素。这也减少了许多行代码，并消除了额外变量的创建。
Python 中列表和数组的区别
| 列表 | 数组 |
| 包含不同数据类型的元素。 | 包含单一数据类型的元素。 |
| 可通过循环迭代 | 可通过循环迭代 |
| 它通常在一维模型中操作 | 它通常在一维或多维空间中操作。 |
Source – Python List vs Array
当每个人都搞不清这两者时，主要问题就出现了。因此，为了清楚起见，我们将应用代码
用 Python 声明列表
让我们用 Python 声明一个列表
代码:
list1 = [23, 34, 12, 22] # declaring a list
print(list1) # printing the list on the screen
输出:
List Output
我们可以通过各种方法来编辑列表。这些操作包括:
- 添加新元素
- 删除元素
- 将元素与外部元素相乘。
1.添加新元素
append() 方法在列表末尾添加新元素。这个函数将我们需要添加到末尾的元素作为参数。
代码:
list1 = [11, 34, 23, 33, 4]
list1.append(2) # adds 2 at the end
# Output :- [11, 34, 23, 33, 4, 2]
我们还可以使用索引概念来编辑列表。索引是分配给列表和数组中每个元素的位置号。它从左到右和从右到左开始。
代码:
list1 = [23, 2, 4, 44]
# 0 1 2 3 positive indexing starts from left to right
# -4 -3 -2 -1 negative indexing starts from right to left
要访问它们，我们需要用方括号中的索引号调用列表。在下面的例子中，我们将访问第三个元素。记住，正指数从 0 开始，一直持续到 n-1。
代码:
list1 = [11, 34, 23, 33, 4]
print(list1[2])
# Output :- 23
说明:
- 索引从 0 开始，从 0 到 2 的计数为 3。它将给出 23 的输出。因此，要访问第三个元素，我们需要调用方括号中的 2。
- 在第二行代码中，我们使用相同的属性更改了第零个位置的元素。
2.删除新元素
添加新元素的主要目的是好的，但是，当我们需要从列表中删除它们时，有一些操作。几个函数有助于移除对象。
- clear() 函数从列表中删除所有元素并返回空值
- pop() 函数将索引号整数作为参数，并删除与该索引位置相关的元素。
- remove() 函数从列表中移除我们需要在其中作为参数给出的元素。
代码:
list1 = [23, 89, 2, 3, -1, 12]
list1.clear() # deleting each element from the list
print(list1)
list1 = [23, 89, 2, 3, -1, 12]
list1.pop(4) # deleting the element from 4th index of the list
print(list1)
list1 = [23, 89, 2, 3, -1, 12]
list1.remove(-1) # search and remove the specified element from the list
print(list1)
输出:
List Operations
Python 中的数组是什么？
Python 有一个独立的库用于 数组操作。当我们使用 数组模块时，我们可以感受到某种程度的 C 编程体验。
我们知道在这个数据结构中只能存储相同数据类型的元素。因此，python 编译器有特殊的 Unicode 字符来识别其中的元素或对象的类型。
声明一个数组有一套规则。array()函数接受一些参数。它们特定于特定的数据类型。
| 类型代码 | C-类型 | Python 类型 |
| ' b ' | 带符号字符 | 整数 |
| ' b ' | 无符号字符 | 整数 |
| 你好 | 性格；角色；字母 | 无符号字符 |
| ' h ' | 带符号的短 | 整数 |
| ' h ' | 无符号短整型 | 整数 |
| 我 | 有符号整数 | 整数 |
| 我 | 无符号整数 | 整数 |
| 我 | 长签名 | 整数 |
| 我 | 无符号长整型 | 整数 |
| 问 | 署名龙龙 | 整数 |
| 问 | 无符号长整型 | 整数 |
| f ' | 漂浮物 | 漂浮物 |
| 迪 | 两倍 | 漂浮物 |
C 型特殊字符的分配是为了使事情更清楚。这些类型表示特定数组中元素的数据类型。上面的代码是一些基本的实现。
代码；
from array import *
int_array = array('i', [1, 4, 55, 51, -2])
print('\n Integer array: ',int_array)
char_array = array('u', ['a', 'b', 'c', 'd'])
print('\n Character array: ', char_array)
float_array = array('f', [2.2, 4.3, -1.2, 9.0])
print('\n Floating point array: ', float_array, '\n')
输出:
Array Operations
数组到列表的转换
其他方法如 append()、pop()等。也适用于本模块。通过此链接在文档页面查看更多信息。其他的特殊函数还包括将数组转换成普通的列表-array . to list()。
代码:
from array import *
char_array = array('u', ['a', 'b', 'c', 'd'])
print('\n Character array: ', char_array)
print('Data type: ', type(char_array))
char_array = char_array.tolist()
print('\n','Converted array: ', char_array)
print('Data type: ', type(char_array))
Conversion Of Array To List
注意:代码中的 type()函数返回变量的数据类型。通过这个，我们检查数组的数据类型，把数组转换成列表。
Python 中的元组是什么？
Python 中最基本的数据结构之一是 元组 。元组是不可变的数据结构。我们将元素放在圆括号内，并用逗号分隔它们。一旦我们创建了一个元组，就没有直接的方法来改变或编辑它。
代码:
tup = (3, 1, 2, 4, 5, 6) # declaration of a tuple
print(tup) # printing it on the screen
# output - (3, 1, 2, 4, 5, 6)
1.从元组中检索元素
我们可以使用索引方法访问元组中的元素。就像列表一样，元组中的元素被分配了索引号，
tup = (2, 34, 1, -1, -4, 3)
print(tup[3])
print(tup[4])
print(tup[-1])
Tuple operations
这里，我们从元组的第四、第五和最后一个位置提取元素。
将元组转换为数组和其他数据结构
Python 提供了几个函数和模块来将它们转换成其他数据结构。从字面上看，它们是简单的代码行。
将元组转换为数组
我们将在这里介绍两种方法。第一种是使用阵列模块，第二种是使用 NumPy 模块。
使用数组模块将元组转换为数组
以前，数组模块帮助我们声明纯数组。但是，我们也可以将它用于转换目的。所以，为了清楚起见，让我们用代码来理解。
from array import *
tup = (23, 98, 3, -2, -4, 11)
print('\n tuple: ', tup)
conv_tup = array('i', tup)
print('\n Converted tuple to an array: ',conv_tup, '\n')
Conversion Using Array Module
说明:
- 导入数组模块。
- 声明一个元组。在屏幕上打印出来。
- 然后我们使用数组函数。在那把型代号字符给定为‘我’。这将把元组转换成整数数组。在下一个参数中，我们给出了分隔逗号的元组。
- 在屏幕上打印数组。
使用 Numpy 模块将元组转换为数组
Numpy–numeric python 是一个非常好的数组相关操作库。对于复杂的数学计算，这是开发者的选择。
为此，我们使用该库中的 array() 方法。这个方法将 tuple 转换成一个 NumPy 数组，供我们使用。
代码:
import numpy as np
tup = (23, 98, 3, -2, -4, 11)
print('\n tuple: ', tup)
print('Data type', type(tup))
conv_tup = np.array(tup)
print('\n Converted tuple to an array: ',conv_tup)
print('Data type', type(conv_tup),'\n')
输出:
Conversion Using Numpy Module
说明:
- 正在导入 NumPy 模块。
- 声明元组并在屏幕上打印出来。
- 使用 type()打印数据类型。
- 声明一个变量conv _ 图并调用 np.array() 方法，元组在其中作为参数。
- 在屏幕上打印转换后的元组及其数据类型，以确认转换。
将元组转换为列表
代码:
tup = (2, 34, 2\. -1, 9, 0) # declare a tuple
new_tup = list(tup) # converts tuple into list
print(new_tup)
# Output = [2, 34, 2\. -1, 9, 0)]
说明:
- 首先，我们将一个元组声明为 tup。
- 然后我们把一个变量设为 new_tup，然后我们调用里面的 list() 函数，我们把元组作为参数给出。
- 它将它转换成一个普通的列表。
- 然后我们把它打印在屏幕上
结论
所以，这里我们结束 python 中元组到数组的转换话题。这些代码实现起来非常简单，也很容易学习。所以，记录每一行代码，理解它的功能。本文还澄清了关于列表和元组的概念。
在 Python 中使用 Numpy 将角度转换为弧度
原文：https://www.askpython.com/python-modules/numpy/converting-degrees-to-radians-numpy
几何学是一门引人入胜的学科。所有这些形状和数字都有对肉眼来说是神秘的基础，但是可以用数学来解释。它被称为所有科学中的女王是有原因的。这篇文章将讨论一个与几何学相关的属性——角度！
像任何度量一样，角度也可以用特定的度量单位来度量。回忆过去美好的学生时代有助于我们记起用量角器画有角度的形状的时候&量角器上会刻上什么来帮助我们画角度。没错，就是度！
就像英里和千米一样，度也有一个同义的度量单位，可以用来测量角度——弧度！以无理数π(π)弧度为基础，用来求一个角度产生的弧长，而度数给我们一个角度产生的旋转。
使用 Numpy 将角度转换为弧度的不同方法
现在我们已经对什么是什么有了一个大概的了解，让我们直接进入它的编程部分。我们将从使用以下代码在 Python 中导入 NumPy 库开始。
import numpy as np
以下是使用 Python 将角度转换为弧度的不同技术。
- 使用 numpy.radians()
- 使用 numpy.deg2rad()
- 使用 pi (π)
技巧一——使用 numpy.radians( )
用户可以使用 numpy 库中的 radians( ) 函数将任何给定的角度转换为角度，既可以是一个实体，也可以是一个数组。让我们首先尝试使用下面的代码转换一个 180 度的实体。
np.radians(180)
Converting Single Entity Using Numpy Radians
从上面可以看出，返回值 3.141592…是 pi (π)的值，因为 180 度与 pi 弧度相同。
技巧二——使用 numpy.deg2rad( )
虽然也可以使用来自 numpy 库的 deg2rad( ) 函数转换单个实体，但同样的操作也可以用于数组。因此，我们将使用 deg2rad( ) 函数演示度数值数组到弧度的转换。对于上述技术也是如此，程序与下面给出的相同。
ar1 = [[10, 50, 120],
[150, 180, 266]]
np.deg2rad(ar1)
Converting An Array Of Degree Values
技巧三——使用 pi (π)
这种技术利用了弧度从度数转换的基本原理；包括 Python 在内的所有软件都会用到的数学基础。有些事情说出来比说出来更好，所以这是将度数转换成弧度的公式。
Formula For Degrees To Radians Conversion
在前面的技术中已经指出，π是 180 度的弧度等价物。所以任何角度都要乘以π，然后除以 180 度，得到它的弧度等值。
好消息是，我们也将在 Python 中这样做！但是我们需要导入另一个库来获取 pi，的精确值，而不是使用 3.14 的近似值。我们将使用下面的代码导入 Python 中的数学库。
import math
from math import pi
然后，应该为π/180 的值指定一个常数，如下所示。
conv = pi/180
然后我们可以使用 numpy 库中的 multiply( ) 函数进行转换，如下所示。
Converting Degrees To Radians Using Pi
结论
既然我们已经到了本文的结尾，希望它已经详细阐述了如何使用 Python 中的 numpy 库将实体从角度转换为弧度。这里有另一篇文章详细介绍了如何在 Python 中使用 numpy 来划分实体。AskPython 中还有许多其他有趣的&同样丰富的文章，可能对那些希望提高 Python 水平的人有很大帮助。当你享受这些的时候，再见！
Python 中的凸包
原文：https://www.askpython.com/python/examples/convex-hulls-in-python
在本教程中，我们将在凸包的帮助下完成一个不同的和独特的聚类方法的实现。但是在直接进入代码之前，理解概念总是很重要的！那么我们来了解一下什么是凸包。
凸包介绍
Convex object是一个内角不大于 180 度的物体。一个Hull暗示了物体外形的外部。一个convex hull包含了一组点，它作为一个聚类的边界，帮助确定一个聚类中的所有点。这是一个简单的奶牛凸包的真实例子。你可以看到外面的外壳将整头牛包裹在外壳内。
Convex Hulls Demonstration
凸包的代码实现
我们将首先在 sci-kit learn 库的帮助下创建本教程的样本数据集。我们将利用make_blobs功能。我们将为 5 个不同的集群创建数据。看看下面的代码。
import numpy as np
from sklearn.datasets import make_blobs
# center points for the clusters
centers = [[0, 1, 0], [1.5, 1.5, 1], [1, 1, 1],[1,1,3],[2,2,2]]
# standard deviations for the clusters
stds = [0.13, 0.12, 0.12,0.15,0.14]
# create dataset using make_blobs - assign centers, standard deviation and the number of points
X, labels_true = make_blobs(n_samples=1000, centers=centers, cluster_std=stds, random_state=0)
point_indices = np.arange(1000)
总的来说，我们生成了分配给five个不同集群的1000个数据点。接下来，我们将尝试可视化数据。由于我们的数据集是三维形式的，我们将为数据绘制一个 3D 图。观察下面的代码。我们将绘制所有的数据点，并为图指定颜色来表示聚类。看看这个情节变得多么惊人！
也读作:使用 Matplotlib 的 Python 中的三维绘图
import matplotlib.pyplot as plt
plt.style.use('seaborn')
x,y,z = X[:,0],X[:,1],X[:,2]
fig = plt.figure(figsize = (20,10),facecolor="w")
ax = plt.axes(projection="3d")
list_colours = ["red", "green", "blue","magenta","brown"]
cluster_colors = [list_colours[i] for i in labels_true]
scatter_plot = ax.scatter3D(x,y,z,c =cluster_colors,marker ='o')
plt.title("Scatter plot of the dataset",fontsize=30)
ax.set_xlabel('X_values', fontweight ='bold')
ax.set_ylabel('Y_values', fontweight ='bold')
plt.show()
Plotting Dataset ConvexHull
我们将从scipy的spatial模块导入ConvexHull和凸包绘图功能。我们将为我们生成的数据集分配凸包点。
from scipy.spatial import ConvexHull, convex_hull_plot_2d
rng = np.random.default_rng()
hull = ConvexHull(X)
让我们使用下面的代码来可视化空间中的凸包。我们将使用创建的 hull 对象的simplices函数来绘制凸包的边界。
fig = plt.figure(figsize = (20,10),facecolor="w")
ax = plt.axes(projection="3d")
for simplex in hull.simplices:
ax.plot3D(X[simplex, 0], X[simplex, 1],X[simplex, 2], 's-')
Plotting ConvexHull 1
看看凸包在 3D 空间看起来有多惊艳。
为了让事情变得更有趣一点，让我们使用下面提到的代码在一个图中同时绘制集群和船体。
fig = plt.figure(figsize = (20,10),facecolor="w")
ax = plt.axes(projection="3d")
scatter_plot = ax.scatter3D(x,y,z,c =cluster_colors,marker ='o')
for simplex in hull.simplices:
ax.plot3D(X[simplex, 0], X[simplex, 1],X[simplex, 2], 's-')
Plotting ConvexHull 2
看起来很棒，对吧？！
结论
恭喜你！现在你知道如何为你的图绘制这些惊人的凸包边界。我希望你喜欢本教程，并发现这是有益的和有趣的！如果你喜欢这个教程，我会向你推荐这些教程:
编码和绘图快乐！😃
用 Python 复制字典的 4 种简单方法
原文：https://www.askpython.com/python/dictionary/copy-a-dictionary-in-python
介绍
在本教程中，我们将讨论用 Python 复制字典的各种方法或技术。
理论上，Python 中的字典是数据值的无序集合，它将相应的元素存储为键-项对。此外，用户可以使用相应的键来访问每个项目。
那么，让我们直接进入复制程序。
用 Python 复制字典的方法
在这一节中，我们将详细阐述用 Python 复制字典的不同方法。让我们一个一个地检查它们。
1.逐个元素复制字典
在这种技术中，我们遍历整个字典，并将键指向的每个元素复制到一个先前声明的新字典中。看看下面的代码:
#given dictionary
dict1={0:'1',1:'2',3:[1,2,3]}
print("Given Dictionary:",dict1)
#new dictionary
dict2={}
for i in dict1:
dict2[i]=dict1[i] #element by elemnet copying
print("New copy:",dict2)
#Updating dict2 elements and checking the change in dict1
dict2[1]=33
dict2[3][1]='22' #list item updated
print("Updated copy:",dict2)
print("Given Dictionary:",dict1)
输出:
Given Dictionary: {0: '1', 1: '2', 3: [1, 2, 3]}
New copy: {0: '1', 1: '2', 3: [1, 2, 3]}
Updated copy: {0: '1', 1: 33, 3: [1, '22', 3]}
Given Dictionary: {0: '1', 1: '2', 3: [1, '22', 3]}
这里，
- 我们初始化了一个字典， dict1
- 在我们打印它之后，我们声明一个空字典， dict2 我们将在那里复制 dict1
- 接下来，我们使用循环的遍历 dict1。并且使用操作
dict2[i]=dict1[i]，我们将每个元素从 dict1 复制到 dict2 。
现在我们的复制已经完成，记住=操作符在字典中为 iterable 对象创建引用。因此，如果更新了 dict2 中的不可迭代元素，那么 dict1 中的相应元素将保持不变。
然而，如果像列表项这样的可迭代对象被改变，我们也会看到字典 1 列表的改变。上面代码的第二部分解释了这一点。尝试在更新后比较 dict1 和 dict2 的结果。我们看到上面的陈述是真实的。
2.使用=运算符在 Python 中复制字典
让我们看看如何使用单个 '=' 操作符直接复制 Python 中的字典。
#given dictionary
dict1={1:'a',2:'b',3:[11,22,33]}
print("Given Dictionary:",dict1)
#new dictionary
dict2=dict1 #copying using = operator
print("New copy:",dict2)
#Updating dict2 elements and checking the change in dict1
dict2[1]=33
dict2[3][2]='44' #list item updated
print("Updated copy:",dict2)
print("Given Dictionary:",dict1)
输出:
Given Dictionary: {1: 'a', 2: 'b', 3: [11, 22, 33]}
New copy: {1: 'a', 2: 'b', 3: [11, 22, 33]}
Updated copy: {1: 33, 2: 'b', 3: [11, 22, '44']}
Given Dictionary {1: 33, 2: 'b', 3: [11, 22, '44']}
在上面的代码中，
- 首先我们初始化一个字典， dict1 。并通过代码行
dict2=dict1直接复制到新对象 dict2 - 该操作将 dict1 中存在的每个对象的引用复制到新字典 dict2 中
- 因此，更新 dict2 的任何元素都会导致 dict1 发生变化，反之亦然。
- 从上面的代码可以清楚地看出，当我们更新 dict2 中的任何(可迭代或不可迭代)对象时，我们也会在 dict1 中看到相同的变化。
3.使用 copy()方法
Python 中字典的copy()方法返回给定字典的浅拷贝。这类似于我们之前看到的通过遍历字典来复制元素的情况。
也就是说，字典元素的引用被插入到新字典中(浅层拷贝)。看看下面的代码:
#given dictionary
dict1={ 10:'a', 20:[1,2,3], 30: 'c'}
print("Given Dictionary:",dict1)
#new dictionary
dict2=dict1.copy() #copying using copy() method
print("New copy:",dict2)
#Updating dict2 elements and checking the change in dict1
dict2[10]=10
dict2[20][2]='45' #list item updated
print("Updated copy:",dict2)
print("Given Dictionary:",dict1)
输出:
Given Dictionary: {10: 'a', 20: [1, 2, 3], 30: 'c'}
New copy: {10: 'a', 20: [1, 2, 3], 30: 'c'}
Updated copy: {10: 10, 20: [1, 2, '45'], 30: 'c'}
Given Dictionary: {10: 'a', 20: [1, 2, '45'], 30: 'c'}
在上面的代码中:
- 我们用一些值初始化一个字典 dict1 。并在其上使用
copy()方法创建一个浅层副本 - 复制完成后，我们更新新元素，并在原始字典中看到相应的变化
- 类似于逐元素复制技术的情况，这里 dict2 的不可迭代元素的改变对原始字典没有任何影响
- 而对于像列表这样的可迭代的字典，这种变化也反映在给定的字典中， dict1
4.使用 copy.deepcopy()方法在 Python 中复制字典
Python 中的deepcopy()方法是复制模块的成员。它返回一个新的字典，其中包含所传递字典的复制元素。注意，这个方法以一种递归的方式复制给定字典的所有元素。让我们看看如何使用它，
import copy
#given dictionary
dict1={ 10:'a', 20:[1,2,3], 30: 'c'}
print("Given Dictionary:",dict1)
#new dictionary
dict2=copy.deepcopy(dict1) #copying using deepcopy() method
print("New copy:",dict2)
#Updating dict2 elements and checking the change in dict1
dict2[10]=10
dict2[20][2]='45' #list item updated
print("Updated copy:",dict2)
print("Given Dictionary:",dict1)
输出:
Given Dictionary: {10: 'a', 20: [1, 2, 3], 30: 'c'}
New copy: {10: 'a', 20: [1, 2, 3], 30: 'c'}
Updated copy: {10: 10, 20: [1, 2, '45'], 30: 'c'}
Given Dictionary: {10: 'a', 20: [1, 2, 3], 30: 'c'}
现在，
- 在第一行中，我们初始化原始字典 dict1 ，
- 我们使用
copy.deepcopy()方法复制新字典中的 dict1 元素， dict2 ， - 成功复制后，我们更新新的副本并查看原始字典中的变化，
- 从输出中我们可以看到， dict2 的任何变化都是而不是反映在 dict1 中。因此，当我们需要在代码中更改新的字典，同时保持原来的字典不变时，这种方法非常有用。
结论
所以，在本教程中，我们学习了用 Python 中的 4 不同的复制字典的方法。关于这个话题的任何问题，请随意使用下面的评论。
参考
- 浅层和深层复制操作–Python 复制文档，
- 如何复制一本字典并且只编辑副本–stack overflow 问题，
- 快速复制字典的方法–stack overflow 问题。
用 Python 复制文件
在之前的教程中，我们学习了一些 Python 文件操作，比如读取、写入、删除。让我们在本教程中学习用 Python 复制一个文件。
我们可以在下面提到的模块下使用不同的方法在 Python 中复制一个文件，
shutil模块os模块subprocess模块
在本教程中，我们将学习使用上述模块提供的不同方法在 Python 中复制文件。
1.用 Python 复制文件的 shutil 模块
shutil模块提供了一些易于使用的方法，使用这些方法我们可以删除以及复制Python 中的一个文件。让我们看看在这个模块下定义的专门用于复制的不同方法。
1.copyfileobj()
copyfileobj()方法使用各自的文件对象将源文件的内容复制到目标文件。让我们看看下面的代码，
import shutil
src_file_obj=open('src.txt', 'rb')
targ_file_obj= open('targ.txt' , 'wb')
shutil.copyfileobj( src_file_obj , targ_file_obj )
注意:文件对象应该指向各自源文件和目标文件的 0 位置(起始位置)，以复制全部内容。
2.复制文件()
copyfile()方法使用文件路径将内容从源复制到目标文件。它返回目标文件路径。目标文件路径必须是可写的，否则会发生 OSerror 异常。
import shutil
shutil.copyfile( 'src.txt' , 'targ.txt' )
请记住，该方法只允许使用文件路径，而不允许使用目录。
3.复制()
此方法将源文件复制到目标文件或目标目录。与copyfile()不同，方法copy()允许使用目标目录作为参数，并且还复制文件权限。copy()复制内容后返回目标文件的路径。
import shutil
shutil.copy('/Users/test/file.txt', '/Users/target/')
在目标位置创建一个名为 'file.txt' 的文件，其中所有内容和权限都是从 '/Users/test/file.txt '中复制的。
4.副本 2()
copy2()方法的使用方式与copy()方法完全相同。它们也以同样的方式工作，除了，因为copy2()也从源文件中复制元数据。
import shutil
shutil.copy2('/Users/test/file.txt', '/Users/target/')
2.用 Python 复制文件的操作系统模块
1.波本()
方法popen()创建一个到命令 cmd 的管道。该方法返回一个连接到 cmd 管道的文件对象。看看下面的代码，
#for Windows
import os
os.popen('copy src.txt targ.txt' )
#for Linux
import os
os.popen('cp src.txt targ.txt' )
用这种方法，我们不仅可以复制文件，还可以执行其他常规命令。
2.系统()
system()方法直接调用并执行 subshell 中的命令参数。它的返回值取决于运行该程序的操作系统。对于 Linux，它是退出状态，而对于 Windows，它是系统 shell 的返回值。
#for Linux
import os
os.system(' cp src.txt targ.txt' )
#for Windows
import os
os.system(' copy src.txt targ.txt' )
3.用 Python 复制文件的子过程模块
1.调用()
类似于os.system()的call()方法直接调用或运行作为参数传递给函数的命令。
# In Linux
import subprocess
subprocess.call('cp source.txt target.txt', shell=True)
# In Windows
import subprocess
subprocess.call('copy source.txt target.txt', shell=True)
参考
- https://docs . python . org/3/library/subprocess . html # subprocess . call
- https://docs.python.org/2/library/os.html
- https://docs.python.org/3/library/shutil.html
- https://stack overflow . com/questions/123198/how-do-I-copy-a-file-in-python
用 Python 复制列表的方法
原文：https://www.askpython.com/python/list/copy-a-list-in-python
在本文中，我们将了解在 Python 中复制列表的各种技术。
Python List 是存储和操作数据值的数据结构。
技巧 1:用 Python 复制列表的 extend()方法
Python 内置的 extend()方法可以用来将一个列表中的元素复制到另一个列表中。
extend() method基本上以一个 iterable 作为参数 say list、 tuple 、 dict 等，它迭代或遍历 iterable 的元素，并以一个元素接一个元素的方式将元素添加到新列表中。
语法:
list.iterable(iterable)
举例:
list1 = [10, 20, 30, 40, 50, 60, 70, 80, 90]
copy_list = []
copy_list.extend(list1)
print("Input List:", list1)
print("Copied List:", copy_list)
输出:
Input List: [10, 20, 30, 40, 50, 60, 70, 80, 90]
Copied List: [10, 20, 30, 40, 50, 60, 70, 80, 90]
技巧 2:用 Python 复制列表的切片操作符
Python slicing operator被认为是复制 Python 列表元素最有效的方法。
语法:
[start:stop:steps]
- 开始:决定切片的开始。
- 停止:该参数决定 iterable 切片的结束
- 步骤:确定要跳过的元素数量或必须执行切片的间隔。
在上面，为了复制列表，我们使用了以下格式的切片:
[:]
这仅仅意味着列表的切片将在开始索引处开始，即索引 0 ，并将在步长值= 1 的最后元素处结束。
举例:
list1 = [10, 20, 30, 40, 50, 60, 70, 80, 90]
copy_list = []
copy_list = list1[:]
print("Input List:", list1)
print("Copied List:", copy_list)
输出:
Input List: [10, 20, 30, 40, 50, 60, 70, 80, 90]
Copied List: [10, 20, 30, 40, 50, 60, 70, 80, 90]
技巧 3:列表理解用 Python 复制列表
Python 列表理解技术对于在 Python 中复制列表很有用。这只是用一行代码创建语句的另一种方法
语法:
[element for element in list]
举例:
list1 = [10, 20, 30, 40, 50, 60, 70, 80, 90]
copy_list = []
copy_list = [item for item in list1]
print("Input List:", list1)
print("Copied List:", copy_list)
在上面的代码片段中，我们使用了列表理解，其中“item”充当指针元素，遍历列表“list1 ”,并以逐个元素的方式复制数据值。
输出:
Input List: [10, 20, 30, 40, 50, 60, 70, 80, 90]
Copied List: [10, 20, 30, 40, 50, 60, 70, 80, 90]
技巧 4:list()方法复制一个列表
Python list() method基本上接受一个 iterable 作为参数，并将序列作为列表返回，即将 iterable 转换为列表。
语法:
list([iterable])
在下面这段代码中，我们将 list-list1 传递给 list()方法，以便用 list-list1 的所有元素创建一个新列表，从而达到复制列表的目的。
举例:
list1 = [10, 20, 30, 40, 50, 60, 70, 80, 90]
copy_list = []
copy_list = list(list1)
print("Input List:", list1)
print("Copied List:", copy_list)
输出:
Input List: [10, 20, 30, 40, 50, 60, 70, 80, 90]
Copied List: [10, 20, 30, 40, 50, 60, 70, 80, 90]
技巧 5: Python copy()方法复制列表
Python 内置的copy() method可以用来将一个列表的数据项复制到另一个列表中。copy()方法通过遍历列表将一个列表中的元素逐个元素地复制到另一个列表中。
语法:
list.copy()
举例:
list1 = [10, 20, 30, 40, 50, 60, 70, 80, 90]
copy_list = []
copy_list = list1.copy()
print("Input List:", list1)
print("Copied List:", copy_list)
输出:
Input List: [10, 20, 30, 40, 50, 60, 70, 80, 90]
Copied List: [10, 20, 30, 40, 50, 60, 70, 80, 90]
技巧 6:复制 Python 列表的 append()方法
Python 内置的append() method可以很容易地用于将一个列表的元素复制到另一个列表中。
顾名思义，append()方法追加，即将列表元素附加到所需列表的末尾。
但是因为我们使用的是一个空列表，在这种情况下，我们可以使用这个方法在 Python 中复制一个列表。
语法:
list.append(value or element)
举例:
list1 = [10, 20, 30, 40, 50, 60, 70, 80, 90]
copy_list = []
for ele in list1: copy_list.append(ele)
print("Input List:", list1)
print("Copied List:", copy_list)
输出:
Input List: [10, 20, 30, 40, 50, 60, 70, 80, 90]
Copied List: [10, 20, 30, 40, 50, 60, 70, 80, 90]
结论
因此，我们揭示了用 Python 复制列表的不同方法。
但是，读者们，这并不是学习的结束，我强烈建议每个人参考上面的例子，并尝试实际执行。
参考
- Python 列表
如何将一个 Numpy 数组复制到另一个数组中？
原文：https://www.askpython.com/python-modules/numpy/copy-a-numpy-array-into-another-array
数组是 Python 中的一种数据结构，它存储相似数据类型的对象。但是有时可能会出现需要将一个数组复制到另一个数组中的情况。在本文中，我们将学习如何将一个 Numpy 数组复制到另一个 Numpy 数组中。所以让我们开始吧！
什么是 Numpy 数组？
数组是 Python 中的一种数据结构，它存储相似数据类型的对象。除了列表可以存储多种数据类型的对象之外，它几乎与列表相似。
例如:
import numpy as np
my_array = np.array([1,2,3,4])
print(my_array)
输出:
[1 ,2 , 3, 4]
方法将 Numpy 数组复制到另一个数组中
所以让我们马上看看你可以使用的方法或函数。
1.使用 np.copy()函数
这个内置函数将返回与输入数组完全相同的副本。
该函数的语法如下:
numpy.copy(a，order='K ')
让我们看看下面的例子。
import numpy as np
# Creating a numpy array using np.array()
my_array = np.array([1.63, 7.92, 5.46, 66.8, 7.89,
3.33, 6.56, 50.60, 100.11])
print("The original array is: ")
print(my_array)
# Now copying the org_array to copy_array using np.copy() function
copy = np.copy(my_array)
print("\nCopied array is: ")
print(copy)
输出:
The original array is:
[ 1.63 7.92 5.46 66.8 7.89 3.33 6.56 50.6 100.11]
Copied array is:
[ 1.63 7.92 5.46 66.8 7.89 3.33 6.56 50.6 100.11]
2.使用赋值运算符
赋值操作符通常在 python 中用来给变量赋值。但是我们也可以用它们将一个数组复制到另一个数组中。
例如:
import numpy as np
my_array = np.array([[100, 55, 66 ,44, 77]])
# Copying the original array to copy using Assignment operator
copy = my_array
print('The Original Array: \n', my_array)
print('\nCopied Array: \n', copy)
输出:
The Original Array:
[[100 55 66 44 77]]
Copied Array:
[[100 55 66 44 77]]
这里，我们简单地将原始数组分配给复制的数组。
3.使用 np.empty_like 函数
在这个方法中，我们将首先创建一个类似于原始数组的空数组，然后将原始数组赋给这个空数组。
该函数的语法如下:
numpy.empty_like(a, dtype = None, order = ‘K’)
让我们来看看下面的例子。
import numpy as np
my_ary = np.array([34, 65, 11,
66, 80, 630, 50])
print("The original array is:")
print(my_ary)
# Creating an empty Numpy array similar to the original array
copy = np.empty_like(my_ary)
# Assigning my_ary to copy
copy[:] = my_ary
print("\nCopy of the original array is: ")
print(copy)
输出:
The original array is:
[ 34 65 11 66 80 630 50]
Copy of the original array is:
[ 34 65 11 66 80 630 50]
结论
总之，我们学习了不同的方法和函数，可以用来将一个数组复制到另一个数组中。数组是一种非常有用的数据结构，了解可以对数组执行的不同操作非常重要。
Python 中的相关矩阵——实际实现
原文：https://www.askpython.com/python/examples/correlation-matrix-in-python
嘿，读者们！在本文中，我们将详细介绍 Python 中相关矩阵的出现和工作原理。所以，让我们现在就开始吧！
什么是相关回归分析？
在Data Science and Machine Learning的领域中，我们经常会遇到这样的情况，在这种情况下，我们有必要分析变量并执行特征选择。这就是相关回归分析发挥作用的时候了。
Correlation Regression Analysis使程序员能够分析连续自变量和连续因变量之间的关系。
也就是说，回归分析评估数据集的自变量之间以及自变量和响应(因变量)之间的可能性和关系。
相关回归分析利用相关矩阵来表示数据集变量之间的关系。
相关矩阵是一种矩阵结构，有助于程序员分析数据变量之间的关系。它表示范围 0 和 1 之间的相关值。
正值表示良好的相关性，负值表示低相关性，等于零(0)的值表示特定变量集之间没有相关性。
人们可以从回归分析和相关矩阵中得出以下观察结果:
- 理解数据集自变量之间的依赖关系。
- 帮助选择数据集的重要和非冗余变量。
- 仅适用于数值/连续变量。
现在让我们来关注一下相关矩阵在 Python 中的实现。
在 Python 中创建相关矩阵
让我们首先从探索本例中使用的数据集开始。如下所示，数据集包含 4 个独立的连续变量:
- 温度
- atemp
- 嗡嗡声
- 风速
Correlation Matrix Dataset
这里，cnt 是响应变量。
现在，我们已经使用corr() function为数字列创建了一个相关矩阵，如下所示:
import os
import pandas as pd
import numpy as np
import seaborn as sn
# Loading the dataset
BIKE = pd.read_csv("day.csv")
# Numeric columns of the dataset
numeric_col = ['temp','atemp','hum','windspeed']
# Correlation Matrix formation
corr_matrix = BIKE.loc[:,numeric_col].corr()
print(corr_matrix)
#Using heatmap to visualize the correlation matrix
sn.heatmap(corr_matrix, annot=True)
此外，我们使用了 Seaborn 热图来可视化矩阵。
输出:
Correlation Matrix
因此，从上述矩阵中，可以得出以下观察结果
- 变量‘temp’和‘atemp’与相关值 0.99 高度相关。
- 因此，我们可以删除两个数据变量中的任何一个。
Correlation Matrix-HEATMAP
结论
到此，我们就结束了这个话题。如果你遇到任何问题，欢迎在下面评论。
在那之前，学习愉快！！
Python 中的相关回归分析——2 种简单的方法！
原文：https://www.askpython.com/python/examples/correlation-regression-analysis
读者朋友们，你们好！今天，我们将关注 Python 中的相关性回归分析。
所以，让我们开始吧！
首先，变量之间的相关性是什么？
让我们试着在数据科学和机器学习的背景下理解相关性的概念！
在数据科学和机器学习领域，主要步骤是分析和清理数据以供进一步处理。
以数据预处理为借口，了解每个变量/列对其他变量以及响应/目标变量的影响是非常重要的。
这就是相关回归分析登场的时候了！
相关回归分析是一种检测和分析自变量之间以及与目标值之间关系的技术。
由此，我们试图分析自变量试图代表目标值添加什么信息或值。
通常，相关性分析适用于回归值，即连续(数字)变量，并通过一个称为相关性矩阵的矩阵进行描述。
在相关矩阵中，变量之间的关系是范围 -1 到+1 之间的值。
使用相关性分析，我们可以检测冗余变量，即代表目标值相同信息的变量。
如果两个变量高度相关，这就给了我们一个提示，要消除其中一个变量，因为它们描述了相同的信息。
现在让我们来实现相关回归的概念！
使用 Pandas 模块进行相关回归分析
在本例中，我们利用了银行贷款数据集来确定数字列值的相关矩阵。可以在这里 找到数据集 ！
- 最初，我们将使用 pandas.read_csv() 函数将数据集加载到环境中。
- 此外，我们将把数字列分离到不同的 Python 列表(变量)中，如下例所示。
- 现在，我们将对每个数字变量应用
corr() function,并为该函数的相同输出创建一个相关矩阵。
举例:
import os
import pandas as pd
import numpy as np
# Loading the dataset
data = pd.read_csv("loan.csv")
numeric_col = ['age', 'employ', 'address', 'income', 'debtinc', 'creddebt', 'othdebt']
#Using Correlation analysis to depict the relationship between the numeric/continuous data variables
corr = data.loc[:,numeric_col].corr()
print(corr)
输出:
Correlation Regression Analysis Output
使用 NumPy 模块确定变量之间的相关性
corr()方法并不是唯一可以用于相关回归分析的方法。我们有另一个计算相关性的函数。
Python NumPy 为我们提供了numpy.corrcoef()函数来计算数值变量之间的相关性。
语法:
numpy.corrcoef(col1, col2)
因此，它将返回输入回归变量的相关矩阵。
举例:
import numpy as np
x = np.array([2,4,8,6])
y = np.array([3,4,1,6])
corr_result=np.corrcoef(x, y)
print(corr_result)
输出:
[[ 1\. -0.24806947]
[-0.24806947 1\. ]]
结论
到此，我们就结束了这个话题。更多与 Python 相关的此类帖子，敬请关注！！尝试在不同的数据集上实现相关性分析的概念，并在评论部分告诉我们您的体验🙂
在那之前，学习愉快！！🙂
如何使用 Python 对一幅图像中的对象进行计数？
原文：https://www.askpython.com/python/examples/count-objects-in-an-image
你好，编程爱好者！今天我们将学习如何计算图像中的物体。为了计数图像，必须利用计算机视觉库。有许多库可以用来实现本教程的目标。
但是今天在本教程中，我们将利用cvlib库，它非常简单、容易，是 Python 中的一个高级库。如果您还没有安装这个库，使用pip命令做同样的事情。
导入所需的库以计算图像中的对象
我们需要一些模块/库来计数对象。下面的代码也是如此。
import cv2
import numpy as np
import matplotlib.pyplot as plt
import cvlib as cv
from cvlib.object_detection import draw_bbox
from numpy.lib.polynomial import poly
我们需要以下模块:
- OpenCV 模块
- Numpy 模块
- Matplotlib 模块
- Cvlib 模块
- cvlib 的对象检测和绘制框子模块
- 我们也将利用 NumPy 多项式模块
加载和查看图像
为了加载图像，我们将使用 OpenCV 库的imread函数，并将图像的名称作为参数传递。确保图像与代码文件在同一个目录中。
为了查看图像，我们将使用 matplotlib 模块的imshow函数。代码如下所示。
img = cv2.imread('image1.jpg')
img1 = cv2.cvtColor(img,cv2.COLOR_BGR2RGB)
plt.figure(figsize=(10,10))
plt.axis('off')
plt.imshow(img1)
plt.show()
屏幕上显示的输出如下。
Initial Loaded Image
在各种对象周围创建框
下面的代码将显示图像中对象周围的框。我们需要做的第一件事是利用detect_common_objects函数，并将我们的图像对象传递给它。
该函数将返回在检测到的对象周围生成的盒子、标签和盒子计数。为了画出这个盒子，我们需要draw_bbox函数，并将前一个函数接收到的输出传递给这个函数。
box, label, count = cv.detect_common_objects(img)
output = draw_bbox(img, box, label, count)
为了显示输出图像，我们将再次使用 imshow 函数，输出结果非常准确。代码如下所示。
output = cv2.cvtColor(output,cv2.COLOR_BGR2RGB)
plt.figure(figsize=(10,10))
plt.axis('off')
plt.imshow(output)
plt.show()
Output Image Counting Objects
计数图像中的对象
print("Number of objects in this image are " +str(len(label)))
为了计算对象的数量，我们将通过简单地使用创建的标签列表上的len功能来计算生成的标签的数量，并打印图片中找到的对象的数量。在这张照片中，系统可以看到 17 个物体。
抽样输出
相同的概念用于另一个图像，结果如下。加载的初始图像如下。
Initial Loaded Image2
检测到图像中的对象后，输出如下所示。该程序检测到图像中出现的四只狗。
Output Image Counting Objects2
结论
恭喜你！现在，您可以尝试任何随机图像，并检查图像中有多少不同的对象。自己试试吧！
感谢您的阅读！
计算熊猫数据帧行数的 6 种方法
原文：https://www.askpython.com/python-modules/pandas/count-pandas-dataframe-rows
想学习如何计算熊猫数据框的行数？在这篇文章中，我们将学习如何用简单的方法做到这一点。Pandas 是一个 Python 库，用于轻松操作表格和数据框中的数据。Pandas 有很多系统函数，在本文中，我们将特别关注那些帮助我们获得数据帧行数的函数。
让我们首先从创建一个数据帧开始。
# Import pandas library
import pandas as pd
# initialize the variable data with your items
cars = [['Honda', 6], ['Hyundai', 5], ['Tata', 5.5]]
# Create the pandas DataFrame
cars_df = pd.DataFrame(cars, columns = ['Brand', 'Price'])
# print dataframe.
print(cars)
熊猫数据帧的行数计算方法
主要有四个 pandas 函数来查找数据帧的行数。我们将讨论所有四个——它们的属性、语法、函数调用和时间复杂性。
方法 1: len(df.index)
代码:
import pandas as pd
cars = [['Honda', 6], ['Hyundai', 5], ['Tata', 5.5]]
cars_df = pd.DataFrame(cars, columns = ['Brand', 'Price'])
# counting rows
print(len(cars_df.index))
上面的代码将返回数据框中的行数(在上面的示例中为 3)。len(df.index)语法用于大型数据库，因为它仅返回数据框的行数，并且它是返回数据框内元素的最快函数。尽管在属性上非常相似，但它比 len(df)(方法 4)快，因为它少执行一个函数调用。
len(df.index)
方法 2: df.shape[]
代码:
import pandas as pd
cars = [['Honda', 6], ['Hyundai', 5], ['Tata', 5.5]]
cars_df = pd.DataFrame(cars, columns = ['Brand', 'Price'])
# counting rows
print(cars_df.shape[0])
该函数用于计算数据框中的行数和列数，语法 df.shape 返回元组的行数和列数。
[ ]括号用于表示索引，即 df.shape[0]返回行数，df.shape[1]返回列数。在时间比较中，它比(df.index)慢。timeit 测试表明，它比 len(df.index)慢 3 倍。
df.shape[0]
方法 3: df[df.column[0]]。计数()
代码:
import pandas as pd
cars = [['Honda', 6], ['Hyundai', 5], ['Tata', 5.5]]
cars_df = pd.DataFrame(cars, columns = ['Brand', 'Price'])
# counting rows
print(cars_df[cars_df.columns[0]].count())
这个 pandas 函数计算数据帧第一列中所有非空的行。时间复杂度随着行数的增加而增加。在下面的图表中，您可以看到时间复杂性在前 10，000 行之前相当稳定，但之后开始增加。这个函数的缺点是它只计算非空的行，而忽略空的行。
df[df.column[0]].count
方法 4:贷款(df)
代码:
import pandas as pd
cars = [['Honda', 6], ['Hyundai', 5], ['Tata', 5.5]]
cars_df = pd.DataFrame(cars, columns = ['Brand', 'Price'])
# counting rows
print(len(cars_df))
这个函数计算索引的长度，类似于 len(df.index)函数，但是稍微慢一点。如果我们精确地计算每个循环所用的时间，我们会发现 len(df)比 len(df.index)大约慢 200ns。这种差异可能看起来很小，但当使用大数据帧时，可能会导致较大的时间差。
len(df)
方法 5: df.count()
这个 pandas 函数给出了整个表的计数，类似于 df.shape[]函数，但是可读性有一些变化。不能调用此函数来返回单个列中的行数，而是返回 tablet 结构中的结果。
代码:
import pandas as pd
cars = [['Honda', 6], ['Hyundai', 5], ['Tata', 5.5]]
cars_df = pd.DataFrame(cars, columns = ['Brand', 'Price'])
# counting rows and columns
print(cars_df.count())
输出:
时间复杂度
Time complexity of df.count()
方法六:df。[cols]。计数()
如果我们需要数据帧的计数，特别是列的计数，那么我们必须对 df.count()语法进行一些修改。df。[col]。count()语法是我们需要向编译器提及的。该语法按特定于列的方式对行中的元素进行计数。
使用时，此语法非常有用。csv 文件，其中包含大量的列。该语法还给出一列中空行的计数，这使得它更加可行。
代码:
# Import pandas library
import numpy as np
import pandas as pd
# initialize the variable data with your items
cars = [['Honda', 6], [np.nan, np.nan], ['Hyundai', 5], ['Tata', 5.5]]
# Create the pandas DataFrame
cars_df = pd.DataFrame(cars, columns = ['Brand', 'Price'])
# counting column-specific row count
print(cars_df['Brand'].count())
输出:
结论
在本文中，我们学习了不同类型的语法和模块来计算数据帧的行数。我们学习了如何在程序中实现这些语法，并观察了它们的时间复杂度。还有一些输出可以让你更好地理解，使用不同的程序和语法可以得到什么样的结果。
希望本文能帮助您更好地理解数据框和行数的概念。
计算熊猫数据框架中的行和列
原文：https://www.askpython.com/python-modules/pandas/count-rows-columns-dataframe
你好，初学者！在这篇文章中，我们将学习获得熊猫数据帧的行和列总数的不同方法。让我们开始吧。
也读作:如何把一个熊猫 dataframe 转换成 Numpy 数组？
介绍
python 中的 DataFrame 是一种二维表格数据结构，具有许多行和列，包含不同的特性。它类似于电子表格。
我们可以使用不同的 python 对象(如列表或字典)创建自己的数据框，也可以使用中已经可用的数据集。csv 格式。在本文中，我们将创建自己的数据框。
为此，我们需要安装 python 的 pandas 库，然后在需要时导入它。使用 pip 包管理器来安装 Pandas
pip install pandas
计算熊猫数据帧中的行和列的不同方法
我们的目标是计算给定数据帧中的行数和列数。让我们开始吧。
1.使用带有轴属性的 len() 方法
这里，我们将使用 len()方法来获得行和列的总数。DataFrame.axes[0]给出行数，DataFrame.axes[1]打印列数。
让我们看一个例子:
#importing pandas
import pandas as pd
#creating dataframes
student_data = {"Name": ['Alice', 'Sam', 'Kevin', 'Max', 'Tom'],
"exam_no": [201, 202, 203, 204, 205],
"Result": ['Pass', 'Pass', 'Fail', 'Pass', 'Fail']}
#printing our dataframe
df1 = pd.DataFrame(student_data)
print(df1)
print("\n Total number of rows :", len(df1.axes[0]))
print("\n Total number of columns :", len(df1.axes[1]))
我们的数据框架由学生数据组成:他们的姓名、考试号和成绩。输出是:
2.使用形状属性
shape[]属性可用于了解数据框的形状/尺寸，以及其中的行和列的总数。数据框的 shape 属性的使用方式与我们上面使用轴[]的方式相同。
DataFrame.shape[0]给出行数，DataFrame.shape[1]给出列数。
考虑同一个例子，让我们看看如何使用 shape[]
print("\n Dimension of dataframe :", df1.shape)
print("\n Total number of rows :", df1.shape[0])
print("\n Total number of columns :", df1.shape[1])
输出是:
Dimension of dataframe : (5, 3)
Total number of rows : 5
Total number of columns : 3
3.使用索引和列关键字
与上面的例子类似，这里，index 关键字用于获取行数，column 关键字用于获取列数。使用与上面相同的示例，让我们了解这些关键字的用法:
print("\n Total number of rows :", len(df1.index))
print("\n Total number of columns :", len(df1.columns))
这些代码行将产生与上述情况相同的输出:
Total number of rows : 5
Total number of columns : 3
结论
因此，在本文中，我们已经看到了获取数据框中行和列总数的所有方法。我们对所有方法都使用了相同的示例，这样您就可以看到每种方法的语法是如何不同的，同时仍然生成相同的结果。在您的数据框上尝试这些方法，如果有任何问题，请随时提问。
谢谢大家！🙂
Python 中的计数器
计数器是dict的子类，是集合模块的一部分。它用于计算可折叠物体的数量。
它是一个无序的集合，其中的元素存储为字典键，它们的计数就是值。
计数器对象格式:{element1: count1, element2: count2}
元素从一个可迭代的开始计数，或者从另一个映射(或计数器)开始初始化
使用Counter()调用完成Counter对象的初始化。
我们还可以将 iterable 传递到调用中，并获得相应的映射对象。
>>> from collections import Counter
>>> # Empty Counter object
>>> c = Counter()
>>> c
Counter()
>>> # Tuple of values
>>> d = Counter(a=1, b=2, c=1)
>>> d
Counter({'b': 2, 'a': 1, 'c': 1})
>>> # Pass a list, which is an iterable
>>> e = Counter(['a', 'b', 'a', 'c'])
>>> e
Counter({'a': 2, 'b': 1, 'c': 1})
>>> # Pass a string, also an iterable
>>> f = Counter('red-dish')
>>> f
Counter({'d': 2, 'r': 1, 'e': 1, '-': 1, 'i': 1, 's': 1, 'h': 1})
>>> # Pass a Dictionary
>>> g = Counter({'a': 10, 'b': 11})
>>> g
Counter({'b': 11, 'a': 10})
请注意，当显示计数器对象时，键-值对按递减计数的顺序显示。
计数器对象有一个字典接口，除了它们为丢失的项目返回一个零计数，而不是引发一个[KeyError](https://docs.python.org/2/library/exceptions.html#exceptions.KeyError)。
计数器方法
1.获取单个元素的计数
单个元素计数的访问方式与字典相同，这意味着counter_object[key]给出了key的计数。
>>> c = Counter(a=1, b=2, c=1)
>>> c
Counter({'b': 2, 'a': 1, 'c': 1})
>>> c['b']
2
>>> c['d'] # Does not give KeyError, unlike a Dictionary
0
2.设置元素的计数
要设置一个元素的计数，使用counter_object[key] = value。如果key不存在，它将和新的计数一起被添加到计数器字典中。
>>> c = Counter(a=1, b=2, c=1)
>>> c
Counter({'b': 2, 'a': 1, 'c': 1})
>>> c['d'] = 4
>>> c
Counter({'d': 4, 'b': 2, 'a': 1, 'c': 1})
3.从计数器中取出元件
要从计数器对象中删除一个键，使用del counter_object[key]。
>>> del c['d']
>>> c
Counter({'b': 2, 'a': 1, 'c': 1})
4.元素()
这个方法返回一个元素的迭代器，元素值的重复次数与它们的计数一样多。该方法忽略所有计数小于 1 的元素。
>>> c
Counter({'b': 2, 'a': 1, 'c': 1})
>>> c['d'] = -1
>>> c
>>> c.elements()
<itertools.chain object at 0x102e2a208>
>>> type(c.elements())
<class 'itertools.chain'>
>>> for i in c.elements():
... print(i)
...
a
b
b
c
>>> list(c.elements())
['a', 'b', 'b', 'c']
>>> c['d'] = -1
>>> c
Counter({'b': 2, 'a': 1, 'c': 1, 'd': -1})
>>> # Ignores d since count[d] < 1
>>> list(c.elements())
['a', 'b', 'b', 'c']
5.最常见(n)
这将返回一个列表，列出了 n 个最常见的元素及其数量，从最常见到最少。如果 n 被省略或者None，*most_common()*返回计数器中所有的元素。计数相等的元素是任意排序的。
>>> c
Counter({'b': 2, 'a': 1, 'c': 1, 'd': -1})
>>> c.most_common()
[('b', 2), ('a', 1), ('c', 1), ('d', -1)]
>>> c.most_common(2)
[('b', 2), ('a', 1)]
6.减法(可迭代/映射)
这将在减去两个 iterable/mappings 的内容后返回一个 mapping/iterable。元素不会被替换，只会减去它们的计数。
>>> a = Counter('redblue')
>>> a
Counter({'e': 2, 'r': 1, 'd': 1, 'b': 1, 'l': 1, 'u': 1})
>>> b = Counter('blueorange')
>>> b
Counter({'e': 2, 'b': 1, 'l': 1, 'u': 1, 'o': 1, 'r': 1, 'a': 1, 'n': 1, 'g': 1})
>>> # Subtracts b from a and updates a accordingly
>>> a.subtract(b)
>>> a
Counter({'d': 1, 'r': 0, 'e': 0, 'b': 0, 'l': 0, 'u': 0, 'o': -1, 'a': -1, 'n': -1, 'g': -1})
7.更新(可迭代/映射)
这和subtract()类似，只是计数相加而不是相减。
>>> a = Counter('12321')
>>> b = Counter('23432')
>>> a
Counter({'1': 2, '2': 2, '3': 1})
>>> b
Counter({'2': 2, '3': 2, '4': 1})
>>> # Add counts into a
>>> a.update(b)
>>> a
Counter({'2': 4, '3': 3, '1': 2, '4': 1})
其他 Counter()方法
***counter.clear()***用于重置计数器中所有元素的计数***counter.values()***返回一个字典值对象，用于其他方法，如sum()获得所有元素的总数。***list(counter)***用于列出所有独特的元素***set(counter)***将计数器转换成集合***counter.items()***返回计数器中(key, value)对的列表。***counter += Counter()***删除所有计数为零或负数的元素
计数器上的算术运算
我们可以在计数器上使用基本的算术运算，如加、减、并和交。
>>> c = Counter(a=3, b=1)
>>> d = Counter(a=1, b=2)
>>> c + d
Counter({'a': 4, 'b': 3})
>>> # Subtract c, d while keeping only positive counts
>>> c - d
Counter({'a': 2})
>>> # Intersection of c, d (Min(c, d))
>>> c & d
Counter({'a': 1, 'b': 1})
>>> # Union of c, d (Max (c, d))
>>> c | d
Counter({'a': 3, 'b': 2})
结论
我们学习了 Counter 类，它为我们提供了每个元素到其计数的映射对象。我们还学习了集合的一些方法。计数器为我们提供了，用于操作计数器对象。
参考
Python 集合文档:https://docs.python.org/2/library/collections.html
关于 Python 的计数器的 JournalDev 文章:https://www . journal dev . com/20806/Python-Counter-Python-collections-Counter
如何用 Python 创建目录
原文：https://www.askpython.com/python/examples/create-a-directory-in-python
大家好！在本文中，我们将揭示用 Python 创建目录的不同方法
用 Python 创建目录的步骤
Python os 模块包含各种内置函数，用于处理底层操作系统和文件并与之交互。
os 模块包含在系统中创建目录的各种内置函数。
在接下来的几节中，我们将了解使用 os 模块创建目录的各种方法。
技巧 1:使用 os.mkdir()方法在 Python 中创建目录
os 模块内置了os.mkdir() method在系统中创建一个目录。
语法:
os.mkdir(path, mode)
path:用户希望创建目录的位置。它是一个字符串或字节值，包含要构建的目录的完整路径和名称。mode:处理目录内文件操作需要赋予的权限。默认值为“ 0o777 ”。
例 1: 在指定位置用 Python 创建一个目录。
import os
main_dir = "C:/Practice"
os.mkdir(main_dir)
print("Directory '% s' is built!" % main_dir)
输出:
Directory 'C:/Practice' is built!
Creating a directory-2 using mkdir()
例 2: 提供权限处理目录内的读写操作。
import os
main_dir = "C:/JournalDev"
os.mkdir(main_dir,mode = 0o666)
print("Directory '% s' is built!" % main_dir)
设置 mode = 0o666，允许在创建的目录中进行读写文件操作。
输出:
Directory 'C:/JournalDev' is built!
Creating a directory-1 using mkdir()
os.mkdir()函数的异常
如果指定位置的目录已经存在，os.mkdir()方法会引发一个FileExistsError Exception。
举例:
import os
main_dir = "C:/JournalDev"
os.mkdir(main_dir,mode = 0o666)
print("Directory '% s' is built!" % main_dir)
输出:
FileExistsError Traceback (most recent call last)
<ipython-input-17-75731447cf21> in <module>
3 main_dir = "C:/JournalDev"
4
----> 5 os.mkdir(main_dir,mode = 0o666)
6 print("Directory '% s' is built!" % main_dir)
7
FileExistsError: [WinError 183] Cannot create a file when that file already exists: 'C:/JournalDev'
技巧 2:使用 os.makedirs()方法在系统中创建目录
os 模块有内置的 os.makedirs()方法来在系统内创建嵌套或递归目录。
也就是说，os.makedirs() function创建父目录、中间目录以及叶目录，如果它们中的任何一个不在系统文件中的话。
语法:
os.makedirs(path,mode)
举例:
import os
main_dir = "C:/Examples/Python_files/OS_module"
os.makedirs(main_dir,mode = 0o666)
print("Directory '% s' is built!" % main_dir)
在上面的示例中，makedirs()函数通过该函数一次创建了中间目录“Python_files”和叶目录“OS_module”。
输出:
Directory 'C:/Examples/Python_files/OS_module' is built!
Creating a parent directory using makedirs()
Creating an Intermediate Directory Using makedirs()
Creating a Base Directory using makedirs()
结论
因此，在本文中，我们已经了解了使用 os 模块在系统中创建目录的方法。
参考
- Python 目录— JournalDev
如何在 Python 中创建一个空的 DataFrame？
原文：https://www.askpython.com/python-modules/pandas/create-an-empty-dataframe
读者你好！在本教程中，我们将讨论在 Python 中创建空数据帧的不同方法。我们还将讨论空数据帧和具有 n an 值的数据帧之间的区别。那么，我们开始吧。
Python 中的空数据帧是什么？
在 Python 中，数据帧是由 Python pandas 模块 提供的二维数据结构，该模块以表格格式即行和列的形式存储数据。一个空数据帧是一个完全空的熊猫数据帧对象(其中没有数据)，所有轴的长度为零。它必须有零行数或零列数。
我们可以使用 pandas DataFrame 对象的DataFrame.empty属性来检查 pandas DataFrame 对象是否为空。当我们在 pandas DataFrame 对象上应用这个属性时，它返回一个布尔值，即真或假，这取决于相关 DataFrame 对象是否为空的条件。
创建空数据帧的方法
在 Python 中，我们可以通过以下方式创建一个空的熊猫数据帧。让我们一个一个地了解这些。
1.创建一个没有任何行或列的完整的空数据帧
这是使用pd.DataFrame()函数创建一个空的 pandas DataFrame 对象的最简单和最容易的方法。在这个方法中，我们简单地调用 pandas DataFrame 类构造函数，不带任何参数，这又返回一个空的 pandas DataFrame 对象。让我们看看实现这个方法的 Python 代码。
# Method-1
# Import pandas module
import pandas as pd
# Create an empty DataFrame without
# Any any row or column
# Using pd.DataFrame() function
df1 = pd.DataFrame()
print('This is our DataFrame with no row or column:\n')
print(df1)
# Check if the above created DataFrame
# Is empty or not using the empty property
print('\nIs this an empty DataFrame?\n')
print(df1.empty)
输出:
This is our DataFrame with no row or column:
Empty DataFrame
Columns: []
Index: []
Is this an empty DataFrame?
True
2.创建一个只有行的空数据帧
这是使用pd.DataFrame()函数创建一个空的 pandas DataFrame 对象的另一个简单方法，该对象只包含行。在这个方法中，我们将调用带有一个参数的 pandas DataFrame 类构造函数- index ，它反过来返回一个空的 Pandas DataFrame 对象以及传递的行或索引列表。让我们编写 Python 代码来实现这个方法。
# Method-2
# Import pandas module
import pandas as pd
# Create an empty DataFrame with
# Five rows but no columns
# Using pd.DataFrame() function with rows parameter
df2 = pd.DataFrame(index = ['R1', 'R2', 'R3', 'R4', 'R5'])
print('This is our DataFrame with rows only no columns:\n')
print(df2)
# Check if the above created DataFrame
# Is empty or not using the empty property
print('\nIs this an empty DataFrame?\n')
print(df2.empty)
输出:
This is our DataFrame with rows only no columns:
Empty DataFrame
Columns: []
Index: [R1, R2, R3, R4, R5]
Is this an empty DataFrame?
True
3.创建一个只有列的空数据框架
为了使用pd.DataFrame()函数创建一个只包含列的空 Pandas DataFrame 对象，我们调用带有一个参数的 Pandas DataFrame 类构造函数—columns,它反过来返回一个空 Pandas DataFrame 对象和传递的列列表。让我们通过 Python 代码来实现这个方法。
# Method-3
# Import pandas module
import pandas as pd
# Create an empty DataFrame with
# Five columns but no rows
# Using pd.DataFrame() function with columns parameter
df3 = pd.DataFrame(columns = ['C1', 'C2', 'C3', 'C4', 'C5'])
print('This is our DataFrame with columns only no rows:\n')
print(df3)
# Check if the above created DataFrame
# Is empty or not using the empty property
print('\nIs this an empty DataFrame?\n')
print(df3.empty)
输出:
This is our DataFrame with columns only no rows:
Empty DataFrame
Columns: [C1, C2, C3, C4, C5]
Index: []
Is this an empty DataFrame?
True
4.创建一个包含行和列的空数据框架
在这个方法中，我们创建一个空的 Pandas DataFrame 对象，它包含行和列。当我们用两个参数调用 pandas DataFrame 类构造函数时- 列和索引，它返回一个空的 pandas DataFrame 对象，带有传递的索引和列列表。让我们看看如何通过 Python 代码实现这个方法。
# Method-4
# Import pandas module
import pandas as pd
# Create an empty DataFrame with
# Five rows and five columns
# Using pd.DataFrame() function
# With columns & index parameters
df4 = pd.DataFrame(columns = ['C1', 'C2', 'C3', 'C4', 'C5'],
index = ['R1', 'R2', 'R3', 'R4', 'R5'])
print('This is our DataFrame with both rows and columns:\n')
print(df4)
# Check if the above created DataFrame
# Is empty or not using the empty property
print('\nIs this an empty DataFrame?\n')
print(df4.empty)
输出:
This is our DataFrame with both rows and columns:
C1 C2 C3 C4 C5
R1 NaN NaN NaN NaN NaN
R2 NaN NaN NaN NaN NaN
R3 NaN NaN NaN NaN NaN
R4 NaN NaN NaN NaN NaN
R5 NaN NaN NaN NaN NaN
Is this an empty DataFrame?
False
注意:这个方法有一个问题，我们可以看到它的输出,empty属性返回了 False。这意味着我们在这个方法中创建的数据帧不会被 pandas 模块视为空数据帧。
空数据帧与具有 NaN 值的数据帧
我们已经看到了上述 Python 代码输出的问题。Pandas 模块对空数据帧和具有所有 NaN 值的数据帧进行不同的处理。
发生这种情况是因为当我们试图使用这种方法创建一个空的 pandas DataFrame 时，我们没有在 DataFrame 对象中提供或输入任何数据，但默认情况下，它会填充有 NaN 值。
这就是为什么当我们将empty属性应用于这种熊猫数据帧时，它返回 False。
因此，克服这个问题的一个简单的解决方案是删除所有默认放置在数据帧中的 NaN 值。我们可以使用 pandas DataFrame 类的 dropna()函数删除 DataFrame 中的所有 NaN 值。然后我们在 DataFrame 对象上应用empty属性来检查结果，它将返回 True。让我们通过 Python 代码来实现这一点。
# Compare an empty DataFrame
# With a DataFrame with all NaN values
# Import pandas module
import pandas as pd
# Create an empty DataFrame with
# Three rows and four columns
# Using pd.DataFrame() function
# With columns & index parameters
df = pd.DataFrame(columns = ['Col-1', 'Col-2', 'Col-3', 'Col-4'],
index = ['Row-1', 'Row-2', 'Row-3'])
print('This is our DataFrame with NaN values:\n')
print(df)
# Check if the above created DataFrame
# Is empty or not using the empty property
print('\nIs this an empty DataFrame?\n')
print(df.empty)
# Remove all the NaN values using dropna() function
# Then apply the empty attribute/property on the DataFrame
print('\nAfter removing all the NaN values:\n')
print('Is this an empty DataFrame?\n')
print(df.dropna().empty)
输出:
This is our DataFrame with NaN values:
Col-1 Col-2 Col-3 Col-4
Row-1 NaN NaN NaN NaN
Row-2 NaN NaN NaN NaN
Row-3 NaN NaN NaN NaN
Is this an empty DataFrame?
False
After removing all the NaN values:
Is this an empty DataFrame?
True
结论
在本教程中，我们已经学习了四种创建空 Pandas DataFrame 对象的方法，以及空 DataFrame 和具有 n an 值的 DataFrame 之间的区别。希望你已经理解了上面讨论的所有内容，并对自己尝试这些方法感到兴奋。谢谢你，请继续关注我们，以获得更多精彩的 Python 教程。
用 Python 创建一个空列表——两种简单的方法
原文：https://www.askpython.com/python/list/create-an-empty-python-list
嘿，大家好！在本文中，我们将关注创建空 Python 列表的不同方法。
我们先来详细了解一下 Python List 的工作原理。
Python 列表的基础
Python List 是一个动态数据结构，将元素存储在其中。列表的美妙之处在于它可以存储不同的元素，即不同数据类型的元素都可以存储在其中。
举例:
lst = [1,2,4,'Python','sp']
print(lst)
输出:
[1, 2, 4, 'Python', 'sp']
现在让我们看看创建一个空 Python 列表的方法。
技巧 1:使用方括号
我们可以使用方括号在 Python 中创建一个空列表。众所周知，列表使用方括号来存储它的元素。因此，它也可以应用在这里。
语法:
list = []
举例:
lst = []
print("Empty list: ",lst)
在上面的例子中，我们使用方括号创建了一个空列表。
输出:
Empty list: []
技巧 2:使用 list()函数
Python list()函数可以用来生成如下所示的空列表-
语法:
list = list()
如果没有参数传递给它，list() function将返回一个空列表。但是，如果数据值作为参数传递给它，list()函数将返回 iterable 中的数据值。
举例:
lst = list()
print("Empty list: ",lst)
这里，我们使用内置的 list()函数创建了一个空列表。因为没有参数传递给 list()函数，所以它返回一个空列表作为输出。
输出:
Empty list: []
结论
到此，我们就结束了这个话题。如果你遇到任何问题，请随时在下面评论。如果你想在 Python 中实现一个函数来检查一个列表是否为空，看看链接的文章。
在那之前，学习愉快！！
参考
如何用 Python 创建聊天室？
原文：https://www.askpython.com/python/examples/create-chatroom-in-python
在本文中，我们将从头到尾用 Python 创建一个聊天室。在我们开始之前，让我们从概念上了解一下什么是聊天室。
什么是聊天室？
聊天室是世界各地的人们就各种话题相互交流的空间。主题可以从应用程序开发到厨房里的任何食谱。聊天室是学习如何交流的绝佳平台。在本文中，我将向您介绍如何使用套接字和 python 的基本概念来创建一个小型聊天室。
现在，在本教程中，我们将使用 python 中的套接字来构建一个实时聊天应用程序。让我们从套接字的概念开始。
什么是插座？
在网络术语中，套接字在 TCP/IP 协议簇中充当连接应用层和传输层的媒介。这些网络套接字存在于客户端和服务器端。
套接字编程是一种连接网络上两个节点以相互通信的方式。一个套接字(节点)监听一个 IP 上的特定端口，而另一个套接字与另一个套接字建立连接。服务器形成侦听器套接字，而客户端连接到服务器。
Client Server Model
聊天室服务器端套接字编程
服务器接受来自客户端的连接以建立网络接口。我们需要确保客户/用户是独特的。因此，我们为每个客户端分配一个唯一的 IP 地址。然而，许多用户喜欢用用户名来识别。因此，我们也将分配用户名。
服务器的作用是收集任何传入的消息，并将它们传递给其他客户端。
让我们开始编写服务器端的代码。首先，创建一个名为server.py的文件。
1.导入所需的库
import socket
import sys
import time
首先，我们导入了socket库，因为这个 python 库包含了实现套接字的必要函数。
sys库提供系统模块，负责提供与系统目录、函数和方法相关的数据。
time模块使我们能够执行许多关于时间转换和描述的操作。
2.创建套接字并检索主机名
new_socket = socket.socket()
host_name = socket.gethostname()
s_ip = socket.gethostbyname(host_name)
port = 8080
socket()函数是套接字库的构造函数，用于创建套接字。
一旦创建了套接字，我们就使用gethostname()检索主机名/本地设备名，这也是套接字库的一个功能。
当以参数host_name发送时,gethostname()检索另一个用户的 IP 地址，该 IP 地址存储在s_ip中。
port被指定为 8080。选择此端口是因为在大多数机器上这是一个默认的空闲端口。通常，3000、5000 等端口用于 express.js 等其他应用程序。您也可以在任何端口(如“1234”)上运行它。
3.绑定主机和端口
new_socket.bind((host_name, port))
print( "Binding successful!”)
print("This is your IP: ", s_ip)
现在我们将使用在 socket 对象new_socket上调用的 bind 函数将端口和主机绑定在一起。一旦绑定成功，它打印“绑定成功！”在控制台上。
4.监听连接
name = input('Enter name:')
new_socket.listen(1)
这里，我们使用接受一个参数的listen()函数，即number_of_connections。该参数可以是任何整数，如 1、2、3、…
5.接受传入连接
conn, add= new_socket.accept()
print("Received connection from ", add[0])
print('Connection Established. Connected From: ',add[0])
第一个变量conn连接到套接字，变量“add”分配给客户端的 IP 地址。
6.存储传入的连接数据
client = (conn.recv(1024)).decode()
print(client + ' has connected.')
conn.send(name.encode())
传入连接的细节存储在 client_name 变量中。客户端的名称最多可以有 1024 个字节。它在服务器上被解码，并打印出一条消息，表明它已被连接。然后，服务器发送主机名。
7.传递数据包/消息
while True:
message = input('Me : ')
conn.send(message.encode())
message = conn.recv(1024)
message = message.decode()
print(client, ':', message)
用户输入消息。这使用encode()编码，然后通过套接字发送。使用send()函数发送消息，该函数在前面调用 accept()函数期间创建的连接对象上调用。然后显示“消息已发送…”。
使用 conn 对象的recv()接收传入消息。它可以接收多达 1024 字节的信息。使用decode()在服务器端对消息进行解码。
完整的服务器端聊天室代码
以下是完整的服务器端聊天室代码:
import time, socket, sys
new_socket = socket.socket()
host_name = socket.gethostname()
s_ip = socket.gethostbyname(host_name)
port = 8080
new_socket.bind((host_name, port))
print( "Binding successful!”)
print("This is your IP: ", s_ip)
name = input('Enter name: ')
new_socket.listen(1)
conn, add = new_socket.accept()
print("Received connection from ", add[0])
print('Connection Established. Connected From: ',add[0])
client = (conn.recv(1024)).decode()
print(client + ' has connected.')
conn.send(name.encode())
while True:
message = input('Me : ')
conn.send(message.encode())
message = conn.recv(1024)
message = message.decode()
print(client, ':', message)
Output Of Server On Command Prompt
聊天室客户端套接字编程
我们将创建一个名为 client.py 的文件，并创建我们的代码来与聊天服务器连接和通信。
1.导入库
import socket
import sys
import time
我们导入服务器端使用的相同库。
2.创建套接字并接受用户输入的主机名
socket_server = socket.socket()
server_host = socket.gethostname()
ip = socket.gethostbyname(server_host)
sport = 8080
- 使用
socket()方法在服务器上创建套接字。 - 在客户端检索服务器的主机名，并存储为
server_host。 - IP 地址存储在
ip中。 - 服务器端口在
sport变量中存储为 8080。
请注意，此端口必须与服务器端代码中提到的端口相匹配。
3.连接到服务器
print('This is your IP address: ', ip)
server_host = input('Enter friend\'s IP address:')
name = input('Enter Friend\'s name: ')
socket_server.connect((server_host, sport))
首先输入服务器(朋友)的详细信息。请注意，输入准确的 IP 地址非常重要，否则通信将会失败。
服务器的主机名和端口以某种方式绑定在一起，并连接到套接字。
4.从服务器接收数据包/消息
socket_server.send(name.encode())
server_name = socket_server.recv(1024)
server_name = server_name.decode()
print(server_name,' has joined...')
while True:
message = (socket_server.recv(1024)).decode()
print(server_name, ":", message)
message = input("Me : ")
socket_server.send(message.encode())
为了接收消息，socket_server 调用 recv()函数来接受 1024 的数据。它存储在消息对象中，并使用 decode()函数进行解码。然后，该消息将打印出服务器的主机名和收到的消息。
客户端可以输入任何消息作为输入，并对其进行编码，然后使用套接字将其发送给服务器。
因此，我们使用套接字和 python 部署了一个实时聊天室。
完整的客户端聊天室代码
以下是我们聊天室客户端的完整代码:
import time, socket, sys
socket_server = socket.socket()
server_host = socket.gethostname()
ip = socket.gethostbyname(server_host)
sport = 8080
print('This is your IP address: ',ip)
server_host = input('Enter friend\'s IP address:')
name = input('Enter Friend\'s name: ')
socket_server.connect((server_host, sport))
socket_server.send(name.encode())
server_name = socket_server.recv(1024)
server_name = server_name.decode()
print(server_name,' has joined...')
while True:
message = (socket_server.recv(1024)).decode()
print(server_name, ":", message)
message = input("Me : ")
socket_server.send(message.encode())
Output Of Client On Command Prompt
结论
复制两个完整的代码片段，分别保存为 server.py 和 client.py，您将拥有自己的第一个 Python 聊天室！它非常容易使用，我相信您会学到很多套接字编程的实用方面。
参考
https://docs.python.org/3/library/socket.html
https://docs.python.org/3/library/socketserver.html
Flask 简介-在 Flask 中安装并创建一个 Hello World 应用程序
原文：https://www.askpython.com/python-modules/flask/create-hello-world-in-flask
在本文中，我们将介绍 Flask web 框架以及如何安装它。稍后，我们将在 Flask 中编写一个简单的 Hello World 应用程序。
什么是 Flask Web 框架？
Flask 是一个用 Python 写的 web 框架，用来创建 web 应用。它是一个“微型”web 框架，这意味着它不需要任何额外的工具或库。
注意“微”不代表它不能做其他框架能做的事情。这仅仅意味着你，作为一个开发者，可以决定 Flask 中的一切事情，比如使用什么数据库等等。,
Flask 的一些默认决定，比如使用的模板引擎等等。，也可以根据需要进行更改。
因此，它不包括已经存在的第三方库或功能，如数据库抽象层、表单验证等。
总而言之，Flask 是一个开发人员友好的“微型”web 框架！！
****将烧瓶安装到系统中
我们可以使用 pip 命令将它安装到我们的设备中。在控制台/终端中，运行命令
pip install flask
就是这样！！烧瓶已安装。
打造 Hello World 应用
现在，我们将创建一个小网页，当访问它时，将显示“Hello World”
因此，创建一个 Python 文件，并在其中编写以下代码。我用过“ app.py ”这个名字；你想要什么都可以。
1.导入 Flask 并创建 Flask 应用程序对象
我们在文件中做的第一件事是导入 Flask
from flask import Flask
然后我们创建一个 Flask 应用程序对象:
app = Flask(__name__)
这里 Flask 充当一个类对象。我们发送特殊的 python 变量 name 作为 Flask 类的参数。这个特殊的变量实际上给了每个文件一个唯一的名称。
所以当我们运行 Flask 应用程序时，为了让 Flask 知道这个应用程序是在一个特定的地方运行的，我们使用了这个特殊的变量。
2.编写代码打印 hello world
创建 Flask 对象后，我们现在需要在浏览器上显示 Hello World 消息。所以添加代码:
@app.route('/hello')
def hello():
return 'Hello World'
装饰者 @app.route ('/hello ')表示网页的 URL 端点。而网页会显示的内容是写在下面的函数里的。
3.让服务器在特定端口上运行
我们使用下面的代码来启动服务器并提到端口，服务器就会运行。
app.run(host='localhost', port=5000)
LocalHost 意味着服务器将在您的本地计算机(端口=5000)上运行。
4.Flask 中 hello world 应用程序的完整代码
就是这样。文件的最终代码:
from flask import Flask
app = Flask(__name__)
@app.route('/hello')
def hello():
return 'Hello World'
app.run(host='localhost', port=5000)
5.运行 Hello World 应用程序****
编码部分就这样了。现在在终端中，运行 Flask 文件:
python app.py
这里我使用了“ app.py，”作为我的文件名。在您的情况下，您将使用您的文件名。
**
Terminal**
现在复制上面显示的网址 (http://localhost:5000/)。这将是你的主机网站的网址。我们将使用此主机网站 URL 的路由端点来打开我们的网页。
因此，点击 URL“http://localhost:5000/hello”来查看网页。
**
webpage**
祝贺你，我们已经成功地建立了我们的第一个烧瓶网页
结论
本教程到此为止，各位！！在接下来的教程中，我们将学习更多关于 Flask 框架的知识。
所以敬请关注，继续编码！！
用 Python 创建智多星游戏——编写一个密码破解游戏
原文：https://www.askpython.com/python/examples/create-mastermind-game-in-python
摄魂师是一个双人密码破解游戏，其中一名玩家隐藏了一个由颜色组成的密码，而另一名玩家必须利用前一名玩家每回合提供的线索来猜测。
在本教程中，我们将使用 Python 语言创建自己的智多星游戏。在我们的智多星版本中，计算机将随机选择一个秘密代码，用户试图根据计算机给出的确定性线索来猜测它。
Python 中的智多星游戏–演示
https://www.askpython.com/wp-content/uploads/2020/07/mastermind_game-1.mp4
事不宜迟，让我们进入游戏的设计部分。
策划游戏设计
最初的策划委员会如下所示。
Mastermind Board
棋盘被屏蔽的一端隐藏了密码，而棋盘的整体是基于密码破译者的猜测。一旦用户识别出隐藏的代码，游戏就结束了。
图中棋盘的右侧包含一系列白色和红色的小钉，用来表示与每次尝试相关的线索。
- 红色–选择的颜色之一位于正确的位置，就像密码一样
- 白色–所选颜色之一出现在代码中，但位置不正确。
该板在终端中的实现如下所示:
Game Design on Terminal
棋盘的顶端隐藏着密码，当玩家失去机会或破解密码时就会显示出来。直到那一刻，【UNK】**【未知】才显示出来。
棋盘的每一部分代表玩家的一个回合。游戏支持六种颜色，红色，绿色，黄色，蓝色，黑色，橙色。最左边的面板表示基于每个回合的线索。代表白色的“w”和代表红色的“R”在使用时都有其原始含义
在上面显示的图中，用户选择的四种颜色中有三种是正确的，但是根据密码，它们都不是正确的位置，因此线索中有三个“W”。
# Function to print the mastermind board
def print_mastermind_board(passcode, guess_codes, guess_flags):
print("-----------------------------------------")
print("\t MASTERMIND")
print("-----------------------------------------")
print(" |", end="")
for x in passcode:
print("\t" + x[:3], end="")
print()
for i in reversed(range(len(guess_codes))):
print("-----------------------------------------")
print(guess_flags[i][0], guess_flags[i][1], "|")
print(guess_flags[i][2], guess_flags[i][3], end=" |")
for x in guess_codes[i]:
print("\t" + x[:3], end="")
print()
print("-----------------------------------------")
上面的代码片段负责在终端上显示摄魂板。
数据结构–游戏变量
为了方便游戏逻辑的开发，我们需要一些数据结构。
colors–游戏中涉及的颜色列表colors_map–数字和颜色之间的映射passcode–秘密代码show_passcode–显示给用户的密码，一个未知的列表- 玩家所做的猜测列表
- 给玩家的线索列表
# The Main function
if __name__ == '__main__':
# List of colors
colors = ["RED", "GREEN", "YELLOW", "BLUE", "BLACK", "ORANGE"]
# Mapping of colors to numbers
colors_map = {1:"RED", 2:"GREEN", 3:"YELLOW", 4:"BLUE", 5:"BLACK", 6:"ORANGE"}
# Randomly selecting a passcode
random.shuffle(colors)
passcode = colors[:4]
# Number of chances for the player
chances = 8
# The passcode to be shown to the user
show_passcode = ['UNK', 'UNK', 'UNK', 'UNK']
# The codes guessed by the player each turn
guess_codes = [['-', '-', '-', '-'] for x in range(chances)]
# The clues provided to the player each turn
guess_flags = [['-', '-', '-', '-'] for x in range(chances)]
这些数据结构中的每一个在处理游戏逻辑时都会派上用场。
游戏循环
游戏开发最关键的部分之一是游戏循环，它负责玩家动作的正常运行和游戏变量的更新。
# The current turn
turn = 0
# The GAME LOOP
while turn < chances:
游戏循环取决于机会的数量和当前回合。每当玩家的机会用尽时，它就会停止游戏。
游戏菜单
游戏菜单是游戏的一个简单方面，它帮助程序员用指令或规则与玩家互动。
我们的游戏菜单看起来像这样:
Game Menu
# The GAME MENU
print("-----------------------------------------")
print("\t\tMenu")
print("-----------------------------------------")
print("Enter code using numbers.")
print("1 - RED, 2 - GREEN, 3 - YELLOW, 4 - BLUE, 5 - BLACK, 6 - ORANGE")
print("Example: RED YELLOW ORANGE BLACK ---> 1 3 6 5")
print("-----------------------------------------")
print_mastermind_board(show_passcode, guess_codes, guess_flags)
游戏菜单必须简单易懂。
处理玩家输入
处理玩家输入包括三个基本步骤:接受玩家输入，对其进行一些完整性检查，如果一切正常，将它存储到我们的数据结构中。
接受玩家输入
正如游戏菜单中提到的，玩家需要输入四个数字，每个数字对应一种特定的颜色，用空格隔开。
我们的工作是将这个播放器输入解析成一个整数列表，以便检索正确的颜色。
# Accepting the player input
try:
code = list(map(int, input("Enter your choice = ").split()))
except ValueError:
clear()
print("\tWrong choice!! Try again!!")
continue
注意:
clear()函数负责通过清除之前的输出来保持终端的干净。它需要 Python 的os库。查看下面
clear()函数声明的完整代码。
应用健全性检查
接下来是对玩家输入进行一些健全性检查。
# Check if the number of colors nunbers are 4
if len(code) != 4:
clear()
print("\tWrong choice!! Try again!!")
continue
# Check if each number entered corresponds to a number
flag = 0
for x in code:
if x > 6 or x < 1:
flag = 1
if flag == 1:
clear()
print("\tWrong choice!! Try again!!")
continue
存储玩家移动
在我们知道玩家进行了有效的移动后，我们可以将它存储在游戏容器中。
# Storing the player moves
for i in range(4):
guess_codes[turn][i] = colors_map[code[i]]
为每个动作设置线索
有两组标志要分配，如果颜色在正确的位置，如在密码中，则为“R”，如果颜色是正确的，但在错误的位置，则为“W”。
# Process to apply clues according to the player input
dummy_passcode = [x for x in passcode]
pos = 0
# Loop to set up clues for the player move
for x in code:
if colors_map[x] in dummy_passcode:
if code.index(x) == passcode.index(colors_map[x]):
guess_flags[turn][pos] = 'R'
else:
guess_flags[turn][pos] = 'W'
pos += 1
dummy_passcode.remove(colors_map[x])
random.shuffle(guess_flags[turn])
需要记住的一件小事是重新排列旗帜，因为它可能会给出与颜色位置相关的提示。
检查赢的条件
我们要做的就是用隐藏代码检查最新的输入。
# Check for win condition
if guess_codes[turn] == passcode:
clear()
print_mastermind_board(passcode, guess_codes, guess_flags)
print("Congratulations!! YOU WIN!!!!")
break
一旦玩家输入了正确的密码，我们就会显示一条获胜的信息并结束游戏。
更新圈数
一个小但非常重要的任务是在每次玩家成功移动后更新回合数。
# Update turn
turn += 1
clear()
最后但并非最不重要的是处理损失情况。
检查损失情况
当玩家用尽了所有的机会，他就输了。当这种情况发生时，我们需要显示适当的消息。
# Check for loss condiiton
if turn == chances:
clear()
print_mastermind_board(passcode, guess_codes, guess_flags)
print("YOU LOSE!!! Better luck next time!!!")
使用 Python 语言创建摄魂师的说明到此结束。
完整的代码
import random
import os
def clear():
os.system("clear")
# Function to print the mastermind board
def print_mastermind_board(passcode, guess_codes, guess_flags):
print("-----------------------------------------")
print("\t MASTERMIND")
print("-----------------------------------------")
print(" |", end="")
for x in passcode:
print("\t" + x[:3], end="")
print()
for i in reversed(range(len(guess_codes))):
print("-----------------------------------------")
print(guess_flags[i][0], guess_flags[i][1], "|")
print(guess_flags[i][2], guess_flags[i][3], end=" |")
for x in guess_codes[i]:
print("\t" + x[:3], end="")
print()
print("-----------------------------------------")
# The Main function
if __name__ == '__main__':
# List of colors
colors = ["RED", "GREEN", "YELLOW", "BLUE", "BLACK", "ORANGE"]
# Mapping of colors to numbers
colors_map = {1:"RED", 2:"GREEN", 3:"YELLOW", 4:"BLUE", 5:"BLACK", 6:"ORANGE"}
# Randomly selecting a passcode
random.shuffle(colors)
passcode = colors[:4]
# Number of chances for the player
chances = 8
# The passcode to be shown to the user
show_passcode = ['UNK', 'UNK', 'UNK', 'UNK']
# The codes guessed by the player each turn
guess_codes = [['-', '-', '-', '-'] for x in range(chances)]
# The clues provided to the player each turn
guess_flags = [['-', '-', '-', '-'] for x in range(chances)]
clear()
# The current turn
turn = 0
# The GAME LOOP
while turn < chances:
print("-----------------------------------------")
print("\t\tMenu")
print("-----------------------------------------")
print("Enter code using numbers.")
print("1 - RED, 2 - GREEN, 3 - YELLOW, 4 - BLUE, 5 - BLACK, 6 - ORANGE")
print("Example: RED YELLOW ORANGE BLACK ---> 1 3 6 5")
print("-----------------------------------------")
print_mastermind_board(show_passcode, guess_codes, guess_flags)
# Accepting the player input
try:
code = list(map(int, input("Enter your choice = ").split()))
except ValueError:
clear()
print("\tWrong choice!! Try again!!")
continue
# Check if the number of colors nunbers are 4
if len(code) != 4:
clear()
print("\tWrong choice!! Try again!!")
continue
# Check if each number entered corresponds to a number
flag = 0
for x in code:
if x > 6 or x < 1:
flag = 1
if flag == 1:
clear()
print("\tWrong choice!! Try again!!")
continue
# Storing the player input
for i in range(4):
guess_codes[turn][i] = colors_map[code[i]]
# Process to apply clues according to the player input
dummy_passcode = [x for x in passcode]
pos = 0
# Loop to set up clues for the player move
for x in code:
if colors_map[x] in dummy_passcode:
if code.index(x) == passcode.index(colors_map[x]):
guess_flags[turn][pos] = 'R'
else:
guess_flags[turn][pos] = 'W'
pos += 1
dummy_passcode.remove(colors_map[x])
random.shuffle(guess_flags[turn])
# Check for win condition
if guess_codes[turn] == passcode:
clear()
print_mastermind_board(passcode, guess_codes, guess_flags)
print("Congratulations!! YOU WIN!!!!")
break
# Update turn
turn += 1
clear()
# Check for loss condiiton
if turn == chances:
clear()
print_mastermind_board(passcode, guess_codes, guess_flags)
print("YOU LOSE!!! Better luck next time!!!")
结论
对于任何初学 Python 的程序员来说，创建我们自己的游戏的任务一开始可能会令人望而生畏。我们希望本文简化了某些 Python 概念，并使读者看起来可以完成任务。
如有任何建议或疑问，欢迎在下面发表评论。感谢您的阅读。
创建扫雷使用 Python 从基础到高级
原文：https://www.askpython.com/python/examples/create-minesweeper-using-python
在这篇文章中，我们将通过使用 Python 语言创建我们自己的基于终端的扫雷器的步骤。
关于游戏
扫雷是一个单人游戏，玩家必须清除包含地雷和数字的正方形网格。玩家必须借助相邻方块中的数字来防止自己落在地雷上。
游戏演示
创建扫雷游戏几个小时的后果。
https://www.askpython.com/wp-content/uploads/2020/06/minesweeper-1.mp4
使用 Python 设计扫雷艇
在创建游戏逻辑之前，我们需要设计游戏的基本布局。使用 Python 创建方形格网相当容易，方法是:
# Printing the Minesweeper Layout
def print_mines_layout():
global mine_values
global n
print()
print("\t\t\tMINESWEEPER\n")
st = " "
for i in range(n):
st = st + " " + str(i + 1)
print(st)
for r in range(n):
st = " "
if r == 0:
for col in range(n):
st = st + "______"
print(st)
st = " "
for col in range(n):
st = st + "| "
print(st + "|")
st = " " + str(r + 1) + " "
for col in range(n):
st = st + "| " + str(mine_values[r][col]) + " "
print(st + "|")
st = " "
for col in range(n):
st = st + "|_____"
print(st + '|')
print()
每个迭代中显示的网格类似于下图:
Minesweeper Layout
'M'符号表示该单元格中存在“地雷”。我们可以清楚地看到，网格上的任何数字都表示相邻“八”单元格中的地雷数量。
像mine_values这样的变量的使用将在教程中进一步解释。
输入系统
任何游戏最重要的部分之一就是支持输入法。在我们的扫雷版本中，我们将使用行号和列号作为输入技术。
在开始游戏之前，脚本必须为玩家提供一组指令。我们的游戏打印如下。
Minesweeper Instructions
与网格一起显示的行号和列号对我们的输入系统很有帮助。众所周知，在没有任何指标的情况下跟踪地雷是很困难的。因此，扫雷有一个规定，使用'标志'来标记细胞，我们知道其中含有地雷。
数据存储
对于单个扫雷游戏，我们需要跟踪以下信息:
- 网格的大小。
- 第号地雷。
- “实际”网格值–在游戏开始时，我们需要一个容器来存储游戏的真实值，玩家不知道。例如，地雷的位置。
- “明显的”网格值–每次移动后，我们需要更新所有必须显示给玩家的值。
- 标记位置–已经标记的单元格。
这些值使用以下数据结构存储
if __name__ == "__main__":
# Size of grid
n = 8
# Number of mines
mines_no = 8
# The actual values of the grid
numbers = [[0 for y in range(n)] for x in range(n)]
# The apparent values of the grid
mine_values = [[' ' for y in range(n)] for x in range(n)]
# The positions that have been flagged
flags = []
《扫雷》的游戏逻辑没有太多。所有的努力都是为了设置扫雷艇的布局。
设置矿井
我们需要随机设置地雷的位置，这样玩家就不会预测它们的位置。这可以通过以下方式实现:
# Function for setting up Mines
def set_mines():
global numbers
global mines_no
global n
# Track of number of mines already set up
count = 0
while count < mines_no:
# Random number from all possible grid positions
val = random.randint(0, n*n-1)
# Generating row and column from the number
r = val // n
col = val % n
# Place the mine, if it doesn't already have one
if numbers[r][col] != -1:
count = count + 1
numbers[r][col] = -1
在代码中，我们从网格中所有可能的单元格中选择一个随机数。我们一直这样做，直到我们得到所说的地雷数量。
注:地雷的实际值储存为-1，而储存用于显示的值，用
'M'表示地雷。注意:【randint】功能只有在导入随机库后才能使用。这是通过在程序开始时写
'import random'来完成的。
设置网格编号
对于网格中的每个单元，我们必须检查所有相邻的单元是否存在地雷。这通过以下方式实现:
# Function for setting up the other grid values
def set_values():
global numbers
global n
# Loop for counting each cell value
for r in range(n):
for col in range(n):
# Skip, if it contains a mine
if numbers[r][col] == -1:
continue
# Check up
if r > 0 and numbers[r-1][col] == -1:
numbers[r][col] = numbers[r][col] + 1
# Check down
if r < n-1 and numbers[r+1][col] == -1:
numbers[r][col] = numbers[r][col] + 1
# Check left
if col > 0 and numbers[r][col-1] == -1:
numbers[r][c] = numbers[r][c] + 1
# Check right
if col < n-1 and numbers[r][col+1] == -1:
numbers[r][col] = numbers[r][col] + 1
# Check top-left
if r > 0 and col > 0 and numbers[r-1][col-1] == -1:
numbers[r][col] = numbers[r][col] + 1
# Check top-right
if r > 0 and col < n-1 and numbers[r-1][col+1]== -1:
numbers[r][col] = numbers[r][col] + 1
# Check below-left
if r < n-1 and col > 0 and numbers[r+1][col-1]== -1:
numbers[r][col] = numbers[r][col] + 1
# Check below-right
if r < n-1 and col< n-1 and numbers[r+1][col+1]==-1:
numbers[r][col] = numbers[r][col] + 1
这些值对玩家是隐藏的，因此它们存储在numbers变量中。
游戏循环
游戏循环是游戏中非常关键的部分。它需要更新玩家的每个动作以及游戏的结论。
# Set the mines
set_mines()
# Set the values
set_values()
# Display the instructions
instructions()
# Variable for maintaining Game Loop
over = False
# The GAME LOOP
while not over:
print_mines_layout()
在循环的每一次迭代中，扫雷网格必须显示，玩家的移动也必须处理。
处理玩家输入
正如我们之前提到的，有两种玩家输入:
# Input from the user
inp = input("Enter row number followed by space and column number = ").split()
标准输入
在正常的移动中，会提到行号和列号。玩家此举背后的动机是解锁一个没有地雷的细胞。
# Standard Move
if len(inp) == 2:
# Try block to handle errant input
try:
val = list(map(int, inp))
except ValueError:
clear()
print("Wrong input!")
instructions()
continue
标志输入
在标记移动中，玩家发送了三个值。前两个值表示单元格位置，而最后一个值表示标记。
# Flag Input
elif len(inp) == 3:
if inp[2] != 'F' and inp[2] != 'f':
clear()
print("Wrong Input!")
instructions()
continue
# Try block to handle errant input
try:
val = list(map(int, inp[:2]))
except ValueError:
clear()
print("Wrong input!")
instructions()
continue
净化输入
存储输入后，为了游戏的顺利运行，我们必须做一些健全性检查。
# Sanity checks
if val[0] > n or val[0] < 1 or val[1] > n or val[1] < 1:
clear()
print("Wrong Input!")
instructions()
continue
# Get row and column numbers
r = val[0]-1
col = val[1]-1
输入过程完成后，行号和列号将被提取并存储在'r'和'c'中。
处理标志输入
管理标志输入不是一个大问题。它要求在标记矿井的单元之前检查一些先决条件。
必须进行以下检查:
- 该单元格是否已被标记。
- 要标记的单元格是否已经向玩家显示。
- 旗帜的数量不超过地雷的数量。
在解决了这些问题之后，该单元被标记为地雷。
# If cell already been flagged
if [r, col] in flags:
clear()
print("Flag already set")
continue
# If cell already been displayed
if mine_values[r][col] != ' ':
clear()
print("Value already known")
continue
# Check the number for flags
if len(flags) < mines_no:
clear()
print("Flag set")
# Adding flag to the list
flags.append([r, col])
# Set the flag for display
mine_values[r][col] = 'F'
continue
else:
clear()
print("Flags finished")
continue
处理标准输入
标准输入包括游戏的整体功能。有三种不同的情况:
在水雷上抛锚
一旦玩家选择了一个有地雷的格子，游戏就结束了。这可能是运气不好或判断失误造成的。
# If landing on a mine --- GAME OVER
if numbers[r][col] == -1:
mine_values[r][col] = 'M'
show_mines()
print_mines_layout()
print("Landed on a mine. GAME OVER!!!!!")
over = True
continue
当我们降落到一个有地雷的单元后，我们需要显示游戏中所有的地雷，并改变游戏循环背后的变量。
函数'show_mines()'对此负责。
def show_mines():
global mine_values
global numbers
global n
for r in range(n):
for col in range(n):
if numbers[r][col] == -1:
mine_values[r][col] = 'M'
访问“0”值的单元格。
创建游戏最棘手的部分是管理这个场景。每当玩家访问“0”值的单元时，必须显示所有相邻的元素，直到到达非零值的单元。
# If landing on a cell with 0 mines in neighboring cells
elif numbers[r][n] == 0:
vis = []
mine_values[r][n] = '0'
neighbours(r, col)
这个目的是利用 递归 实现的。递归是一种编程工具，其中函数调用自己，直到基本情况得到满足。neighbours函数是一个递归函数，解决了我们的问题。
def neighbours(r, col):
global mine_values
global numbers
global vis
# If the cell already not visited
if [r,col] not in vis:
# Mark the cell visited
vis.append([r,col])
# If the cell is zero-valued
if numbers[r][col] == 0:
# Display it to the user
mine_values[r][col] = numbers[r][col]
# Recursive calls for the neighbouring cells
if r > 0:
neighbours(r-1, col)
if r < n-1:
neighbours(r+1, col)
if col > 0:
neighbours(r, col-1)
if col < n-1:
neighbours(r, col+1)
if r > 0 and col > 0:
neighbours(r-1, col-1)
if r > 0 and col < n-1:
neighbours(r-1, col+1)
if r < n-1 and col > 0:
neighbours(r+1, col-1)
if r < n-1 and col < n-1:
neighbours(r+1, col+1)
# If the cell is not zero-valued
if numbers[r][col] != 0:
mine_values[r][col] = numbers[r][col]
对于这个游戏的特殊概念，使用了一个新的数据结构，即vis。vis的作用是在递归过程中跟踪已经访问过的单元。没有这些信息，递归将永远继续下去。
在显示了所有零值单元格及其相邻单元格之后，我们可以转到最后一个场景。
选择非零值单元格
处理这种情况不需要任何努力，因为我们需要做的只是改变显示值。
# If selecting a cell with atleast 1 mine in neighboring cells
else:
mine_values[r][col] = numbers[r][col]
结束游戏
有一个要求，检查游戏的完成，每次移动。这通过以下方式实现:
# Check for game completion
if(check_over()):
show_mines()
print_mines_layout()
print("Congratulations!!! YOU WIN")
over = True
continue
函数check_over()，负责检查游戏的完成情况。
# Function to check for completion of the game
def check_over():
global mine_values
global n
global mines_no
# Count of all numbered values
count = 0
# Loop for checking each cell in the grid
for r in range(n):
for col in range(n):
# If cell not empty or flagged
if mine_values[r][col] != ' ' and mine_values[r][col] != 'F':
count = count + 1
# Count comparison
if count == n * n - mines_no:
return True
else:
return False
我们计算非空或未标记的细胞数量。当这个计数等于除了含有地雷的细胞之外的总细胞数时，则游戏被视为结束。
每次移动后清除输出
随着我们不断地在终端上打印东西，终端变得拥挤。因此，必须有不断清除它的规定。这可以通过以下方式实现:
# Function for clearing the terminal
def clear():
os.system("clear")
注意:在使用该功能之前，需要导入
os库。可以通过程序开始时的'import os'来完成。
完整的代码
下面是扫雷游戏的完整代码:
# Importing packages
import random
import os
# Printing the Minesweeper Layout
def print_mines_layout():
global mine_values
global n
print()
print("\t\t\tMINESWEEPER\n")
st = " "
for i in range(n):
st = st + " " + str(i + 1)
print(st)
for r in range(n):
st = " "
if r == 0:
for col in range(n):
st = st + "______"
print(st)
st = " "
for col in range(n):
st = st + "| "
print(st + "|")
st = " " + str(r + 1) + " "
for col in range(n):
st = st + "| " + str(mine_values[r][col]) + " "
print(st + "|")
st = " "
for col in range(n):
st = st + "|_____"
print(st + '|')
print()
# Function for setting up Mines
def set_mines():
global numbers
global mines_no
global n
# Track of number of mines already set up
count = 0
while count < mines_no:
# Random number from all possible grid positions
val = random.randint(0, n*n-1)
# Generating row and column from the number
r = val // n
col = val % n
# Place the mine, if it doesn't already have one
if numbers[r][col] != -1:
count = count + 1
numbers[r][col] = -1
# Function for setting up the other grid values
def set_values():
global numbers
global n
# Loop for counting each cell value
for r in range(n):
for col in range(n):
# Skip, if it contains a mine
if numbers[r][col] == -1:
continue
# Check up
if r > 0 and numbers[r-1][col] == -1:
numbers[r][col] = numbers[r][col] + 1
# Check down
if r < n-1 and numbers[r+1][col] == -1:
numbers[r][col] = numbers[r][col] + 1
# Check left
if col > 0 and numbers[r][col-1] == -1:
numbers[r][col] = numbers[r][col] + 1
# Check right
if col < n-1 and numbers[r][col+1] == -1:
numbers[r][col] = numbers[r][col] + 1
# Check top-left
if r > 0 and col > 0 and numbers[r-1][col-1] == -1:
numbers[r][col] = numbers[r][col] + 1
# Check top-right
if r > 0 and col < n-1 and numbers[r-1][col+1] == -1:
numbers[r][col] = numbers[r][col] + 1
# Check below-left
if r < n-1 and col > 0 and numbers[r+1][col-1] == -1:
numbers[r][col] = numbers[r][col] + 1
# Check below-right
if r < n-1 and col < n-1 and numbers[r+1][col+1] == -1:
numbers[r][col] = numbers[r][col] + 1
# Recursive function to display all zero-valued neighbours
def neighbours(r, col):
global mine_values
global numbers
global vis
# If the cell already not visited
if [r,col] not in vis:
# Mark the cell visited
vis.append([r,col])
# If the cell is zero-valued
if numbers[r][col] == 0:
# Display it to the user
mine_values[r][col] = numbers[r][col]
# Recursive calls for the neighbouring cells
if r > 0:
neighbours(r-1, col)
if r < n-1:
neighbours(r+1, col)
if col > 0:
neighbours(r, col-1)
if col < n-1:
neighbours(r, col+1)
if r > 0 and col > 0:
neighbours(r-1, col-1)
if r > 0 and col < n-1:
neighbours(r-1, col+1)
if r < n-1 and col > 0:
neighbours(r+1, col-1)
if r < n-1 and col < n-1:
neighbours(r+1, col+1)
# If the cell is not zero-valued
if numbers[r][col] != 0:
mine_values[r][col] = numbers[r][col]
# Function for clearing the terminal
def clear():
os.system("clear")
# Function to display the instructions
def instructions():
print("Instructions:")
print("1\. Enter row and column number to select a cell, Example \"2 3\"")
print("2\. In order to flag a mine, enter F after row and column numbers, Example \"2 3 F\"")
# Function to check for completion of the game
def check_over():
global mine_values
global n
global mines_no
# Count of all numbered values
count = 0
# Loop for checking each cell in the grid
for r in range(n):
for col in range(n):
# If cell not empty or flagged
if mine_values[r][col] != ' ' and mine_values[r][col] != 'F':
count = count + 1
# Count comparison
if count == n * n - mines_no:
return True
else:
return False
# Display all the mine locations
def show_mines():
global mine_values
global numbers
global n
for r in range(n):
for col in range(n):
if numbers[r][col] == -1:
mine_values[r][col] = 'M'
if __name__ == "__main__":
# Size of grid
n = 8
# Number of mines
mines_no = 8
# The actual values of the grid
numbers = [[0 for y in range(n)] for x in range(n)]
# The apparent values of the grid
mine_values = [[' ' for y in range(n)] for x in range(n)]
# The positions that have been flagged
flags = []
# Set the mines
set_mines()
# Set the values
set_values()
# Display the instructions
instructions()
# Variable for maintaining Game Loop
over = False
# The GAME LOOP
while not over:
print_mines_layout()
# Input from the user
inp = input("Enter row number followed by space and column number = ").split()
# Standard input
if len(inp) == 2:
# Try block to handle errant input
try:
val = list(map(int, inp))
except ValueError:
clear()
print("Wrong input!")
instructions()
continue
# Flag input
elif len(inp) == 3:
if inp[2] != 'F' and inp[2] != 'f':
clear()
print("Wrong Input!")
instructions()
continue
# Try block to handle errant input
try:
val = list(map(int, inp[:2]))
except ValueError:
clear()
print("Wrong input!")
instructions()
continue
# Sanity checks
if val[0] > n or val[0] < 1 or val[1] > n or val[1] < 1:
clear()
print("Wrong input!")
instructions()
continue
# Get row and column numbers
r = val[0]-1
col = val[1]-1
# If cell already been flagged
if [r, col] in flags:
clear()
print("Flag already set")
continue
# If cell already been displayed
if mine_values[r][col] != ' ':
clear()
print("Value already known")
continue
# Check the number for flags
if len(flags) < mines_no:
clear()
print("Flag set")
# Adding flag to the list
flags.append([r, col])
# Set the flag for display
mine_values[r][col] = 'F'
continue
else:
clear()
print("Flags finished")
continue
else:
clear()
print("Wrong input!")
instructions()
continue
# Sanity checks
if val[0] > n or val[0] < 1 or val[1] > n or val[1] < 1:
clear()
print("Wrong Input!")
instructions()
continue
# Get row and column number
r = val[0]-1
col = val[1]-1
# Unflag the cell if already flagged
if [r, col] in flags:
flags.remove([r, col])
# If landing on a mine --- GAME OVER
if numbers[r][col] == -1:
mine_values[r][col] = 'M'
show_mines()
print_mines_layout()
print("Landed on a mine. GAME OVER!!!!!")
over = True
continue
# If landing on a cell with 0 mines in neighboring cells
elif numbers[r][col] == 0:
vis = []
mine_values[r][col] = '0'
neighbours(r, col)
# If selecting a cell with atleast 1 mine in neighboring cells
else:
mine_values[r][col] = numbers[r][col]
# Check for game completion
if(check_over()):
show_mines()
print_mines_layout()
print("Congratulations!!! YOU WIN")
over = True
continue
clear()
结论
我们希望这个关于创建我们自己的扫雷游戏的教程既有趣又易懂。如有任何疑问，欢迎在下面评论。我的 Github 账户上也有完整的代码。
使用 Python 创建更安全的密码
原文：https://www.askpython.com/python/examples/create-safer-passwords
你好，编码员们！在本教程中，我们将创建一个 python 程序，使您的密码更加安全可靠。
我们都知道，创建一个强大的密码在一个人的生活中起着重要的作用，以保持您的帐户和个人信息的安全，并防止它落入坏人之手。
简单的密码很容易被破解，所以我们需要让我们的密码难以破解。在这个应用程序中，我们将使用不同的特殊符号替换一串字符，例如$、& 、@、0、1、|，等等，以使您的密码难以破解。
该应用程序将您的密码作为用户的输入，然后用提到的特殊符号替换其字符，然后为用户打印新的更强密码的输出。
使用 Python 创建安全密码
为了使密码更加安全，我们将首先创建一个映射，存储需要替换的字符和特殊符号。
在下一步中，将创建一个函数，该函数将对用户输入的密码进行所有替换，然后返回更安全的密码。
# 1\. Mapping characters with the secret codes
SECRET_CODE = [('g', '$'), ('t', '&'), ('a', '@'), ('s', '0'), ('h', '1'),('l', '|')]
# 2\. Creating a function which will return the stronger password
def secure_password(user_pass):
for a,b in SECRET_CODE:
user_pass = user_pass.replace(a, b)
return user_pass
# 3\. Taking the input of the user password
cur_pass = input("Enter your current password: \n")
# 4\. Making the password more secure
new_pass = secure_password(cur_pass)
print(f"Your secure and safe password is {new_pass}")
一些示例输出
上面给出的代码将返回一个更安全的密码，同样的情况可以在下面给出的两个输出中看到。
Enter your current password:
This is my generic password
Your secure and safe password is T1i0 i0 my $eneric [email protected]
Enter your current password:
Please give me a strong password
Your secure and safe password is P|[email protected] $ive me @ 0&ron$ [email protected]
结论
您可以根据自己的喜好用更多的符号或数字来替换字符，并使密码更难破解。我希望您喜欢这个简单的应用程序。
感谢您的阅读！
Sqlite 使用 Python“如果不存在则创建表”
原文：https://www.askpython.com/python-modules/create-table-if-not-exists-sqlite3
嘿，Python 爱好者(特别是程序员😂不是贪吃蛇的人)这里我们讨论和实现一个新的主题:-“Sqlite-使用 Python 创建不存在的表”。
现在我们都知道一个非常著名的 SQLite 插件 sqlite3，它与默认的 Python 环境协作。这有助于我们制作实时应用程序，然后将它们连接到数据库，而无需使用本地主机或在线服务器。
我们可以称之为 SQLite3，它是一种无需任何配置设置就可以在本地机器上运行的应用程序。因此，为了使事情变得简单，我们将编写一个脚本来检查该表是否存在。如果它不存在，它会自动为我们创建一个。这就像制造一个智能工具。所以，让我们去争取吧！
使用 Python SQLite3 创建一个不存在的表
创建一个名为 Table Creation 的文件夹，然后在同一文件夹的一个文件中添加以下代码。
代码:
import sqlite3
connection = sqlite3.connect('database/school.db') # file path
# create a cursor object from the cursor class
cur = connection.cursor()
cur.execute('''
CREATE TABLE stud_data(
roll_no integer,
name text,
class integer,
division text
)''')
print("\nDatabase created successfully!!!")
# committing our connection
connection.commit()
# close our connection
connection.close()
输出:
Database created successfully!!!
我们创建了一个包含学生数据表“stud _ data”的学校数据库。该表有四列:卷号、姓名、班级和部门。当我们在 SQLite studio 中将它可视化时，它看起来是这样的:
Visualizing The table in the studio
删除表格
我们将特意删除该表，然后创建我们的智能脚本。
删除表格的代码:
import sqlite3
connection = sqlite3.connect('database/school.db')
connection.execute("DROP TABLE stud_data")
print("Your table has been deleted!!!")
connection.close()
DROP TABLE "table_name" 查询删除表。确保添加各自的表名。
输出:
Your table has been deleted!!!
创建和删除表的完整代码
这一部分包含的主要脚本将检查该表是否存在于数据库中。如果出现这种情况，则会创建一个具有相同名称和参数的新表。
代码:
import sqlite3
connection = sqlite3.connect('database/school.db')
cur = connection.cursor()
try:
cur.execute("SELECT * FROM stud_data")
# storing the data in a list
data_list = cur.fetchall()
print('Roll_Number' + '\t Name')
print('--------' + '\t\t-------------')
for item in items:
print(item[0] + ' | ' + item[1] + '\t' + item[2])
except sqlite3.OperationalError:
print("No such table: stud_data")
if(sqlite3.OperationalError): # if this error occurs
try:
print("Creating a new table: ")
cur.execute('''
CREATE TABLE stud_data(
roll_no integer,
name text,
class integer,
division text
)''')
print("New table created successfully!!!")
print("Here are the contents of the table: \n1: roll_no. \n2: name \n3: class \n4:division.")
except sqlite3.Error() as e:
print(e, " occured")
connection.commit()
connection.close()
输出:
No such table: stud_data
Creating a new table:
New table created successfully!!!
Here are the contents of the table:
1: roll_no.
2: name
3: class
4: division.
说明:
- 我们定义了两个 try 块。第一个检查一个表是否存在。如果不是，If 条件跳转到新的 try 块，为我们创建一个新表。
- 在第一个 try 块中:使用 SQLite 查询: "SELECT * FROM table_name" 将尝试从表中获取所有的行和列。
- 如果表不存在，try 块抛出 sqlite。操作错误。except 块处理它。它下面的 if() 语句打开第二个 try-except 块。
- 然后，第二个 try 语句完成用相同的参数创建新表的任务。
- except 块使用 sqlite 检查任何常见错误。Error() 方法并处理它。
- 代码的第二部分只是执行一个查询，创建一个新表 stud_data 并将其插入到我们的数据库中。
正在总结…
这是我们检查 SQLite 数据库中是否存在表的方法。建议在实现解决方案之前理解代码是如何工作的。感谢阅读。
创建 Python 模块
原文：https://www.askpython.com/python-modules/creating-a-python-module
那么，你学习 Python 已经有一段时间了。作为初学者，通常的做法是编写一个单文件程序，使用类和函数来组织所有代码。
但是随着你越来越高级，你的代码越来越复杂，你需要学习使用多个文件。
Python 模块到底是什么？
Python 模块是一个 Python 文件，其中包含您希望包含在应用程序中的类、方法或变量。
在高级 Python 应用程序中，常见的做法是将可重用的函数或类组合在一个文件中，然后导入程序的其他部分。
Python Module Example 1
这被称为 Python 模块。然后可以导入该模块，变量和函数可以多次重用，而不必每次都声明或创建它们。
[目录]
如何创建 Python 模块？
这很简单，但我们将把它分解成小块，以便您理解它，并能够在现实世界中应用它。
1.创建包含方法的文件
我们将首先创建一个基本方法，它将两个数字相加，并接受这两个数字作为参数。
name = "AskPython"
def add(num1, num2):
return num1 + num2
这是我们的模块。上面的代码只是一个返回传递给它的两个数之和的方法。将上面的代码保存为adder.py，我们将进入下一步。
2.创建主文件以导入模块
我们的下一步是在程序中导入定制的 python 模块。现在，这与导入任何其他模块完全相同。
唯一的区别是模块文件位于本地，而不是在系统路径中。
import adder
nums = adder.add(5, 10)
print(nums)
This is the output that we’ll receive when the above program is run
在上面的例子中，我已经导入了我们的“加法器”文件。不需要加上”。py" 导入时的扩展名。
3.仅导入一个函数
假设在我们的模块中，我们有多个函数执行多个任务。但是在我们导入模块的程序中，我们只需要这些函数中的一个。没有必要导入整个模块。
在这种情况下，我们可以一起使用from和import 。
from adder import add
nums = add(5, 10)
print(nums)
Importing the function individually gives us the same output
正如您所看到的，由于我们正在导入一个特定的函数，Python 允许我们使用该函数，就像它是文件的原生函数一样，而不必用模块名来引用它。
4.使用我们模块中的变量
您可能已经注意到了我们模块中的两个变量。我们添加这些是为了演示如何从模块中直接导入变量，而不改变它们的值。
import adder
nums = adder.add(5, 10)
print(nums)
print(adder.name)
Importing variables from modules
从不同目录导入模块
您不需要将模块存储在与主文件相同的文件夹中。如果有很多文件，那会变得很不方便。
此外，如果你把一个模块导入到不同的程序中，使用这个模块会很困难。
相反，您可以在文件夹中组织模块，并且仍然以与以前相同的方式导入它们。我们只需对 import 语句做一点小小的修改，其他一切都会运行良好。
有多种方法可以导入程序中不在根目录下的模块。让我们从简单的开始。
1.通过指定文件夹名称导入
我们上面使用的点符号或 from..import 可以用来导入位于一个目录中的模块。让我们将“adder.py”模块放在名为 modules 的目录中。
Modules In Directory 1
import modules.adder as adder
nums = adder.add(5, 10)
print(nums)
print(adder.name)
在这个例子中，我们使用作为，将我们的模块名从“modules.adder”重命名为“adder”。
这样做的原因是，在没有重命名的情况下，每次我们需要从模块中调用函数时，我们都必须指定“modules.adder.add(5，10)”等等。
我们不需要在import语句中重命名模块。我们也可以稍后在程序中创建一个保存模块名称的变量，并使用该变量调用模块中的函数。
adder = modules.adder
这也可以，但是在程序开始的时候声明新的名字可以提高代码的可读性，让下一个程序员更容易处理你的代码。
另一种方法是使用 from..导入。这使我们不必为了在程序中使用而重命名模块。我需要对导入命令做的唯一改变是使用模块导入加法器中的
from modules import adder
nums = adder.add(5, 10)
print(nums)
print(adder.name)
2.将路径追加到 sys.path
当导入模块时，Python 首先查看预定义的路径，以找到与名称匹配的模块。它查找的第一个目录是当前目录，之后它移动到其他列出的目录。
让我们把 sys.path 打印出来，看看 Python 在研究哪些路径。
import sys
print(sys.path)
**
Sys Path In Python Linux**
上面的输出是在 Linux 计算机上生成的。如果您使用的是 Windows 电脑，您将获得不同的路径列表。
因为 sys.path 是一个 Python 列表，所以我们可以向它追加路径。
import sys
sys.path.append("modules")
import adder
nums = adder.add(5, 10)
print(nums)
print(adder.name)
我们导入了 sys 模块，并将我们的“模块”目录附加到它上面。因此，任何时候你需要在这个程序的 modules 目录中导入一个模块，你可以简单地指定名称，然后你就可以开始工作了。
3.使模块在系统范围内可用
我们在上面的例子中打印出了 sys.path。我们知道 Python 会默认查看这些目录，不管你的代码放在哪里。
如果我们将我们的模块移动到这些目录中的一个，您将可以很容易地从您将来在计算机上创建的任何程序中访问该模块。
请注意，当将程序移植到不同的系统时，您将需要复制该模块。所以对于特定于程序的模块，最好将它们组织在父目录中的文件夹中，并从那里导入。
结论
现在，您应该能够用 Python 创建自定义模块并编写多文件程序。请记住，使用类将代码组织在多个文件中对于代码的可重用性来说是一个更好的选择。
您现在需要的许多功能在未来的应用程序中也会有用，您创建的这些单独的模块只需导入即可，这样在高级应用程序中可以节省您的工作时间。
在 Python 中创建虚拟变量
原文：https://www.askpython.com/python/examples/creating-dummy-variables
读者朋友们，你们好！在本文中，我们将了解在 Python 中创建虚拟变量的。
所以，让我们开始吧！
首先，什么是哑变量？
让我试着通过下面的场景向您介绍数据建模的独特而重要的概念——虚拟变量。
考虑一个由连续数据和分类数据组成的数据集。当我们阅读《分类》这部作品时，我们首先想到的是数据中的类别或群体的存在。
通常情况下，变量代表生动/不同类型的类别。随着数据集大小的增加，并且很快模糊性开始增加，处理数据中的大量组并将其提供给模型成为一项繁琐而复杂的任务。
这时虚拟变量的概念就出现了。
虚拟变量是一个数值变量，代表数据集分类变量的子类别或子组。
简而言之，虚拟变量使我们能够区分数据的不同子组，也使我们能够使用数据进行回归分析。
请看下面的例子！
考虑包含 10-15 个数据变量的数据集，其中包含“男性”和“女性”的类别。
任务是了解哪个性别通常会选择“粉色”作为他们手机壳的颜色。现在，在这种情况下，我们可以使用虚拟变量，将 0 指定为男性，1 指定为女性。这反过来将有助于喂养模型更好地理解和清理所喂养的数据。
现在让我们用 Python 创建一个虚拟变量！
现在让我们从创建一个虚拟变量开始。我们使用了自行车租赁数量预测问题来分析和创建虚拟变量。
所以，让我们开始吧！
1.加载数据集
首先，我们需要将数据集加载到工作环境中，如下所示:
import pandas
BIKE = pandas.read_csv("Bike.csv")
原始数据集:
Dataset-Bike Prediction
2.创建要处理的原始数据集的副本。
为了确保原始数据集保持不变，我们创建了一个原始数据集的副本来处理和执行创建虚拟数据集的操作。
我们同样使用了pandas.dataframe.copy()功能。
bike = BIKE.copy()
3.将所有分类变量存储在一个列表中
现在让我们将数据集中的所有分类变量保存到一个列表中进行处理！
categorical_col_updated = ['season','yr','mnth','weathersit','holiday']
4.使用 get_dummies()方法创建变量的哑元
Pandas 模块为我们提供了dataframe.get_dummies()函数来创建分类数据的虚拟模型。
bike = pandas.get_dummies(bike, columns = categorical_col_updated) print(bike.columns)
我们已经将数据集和分类列值传递给函数来创建虚拟对象。
输出:
如下所示，为每个类别下的每个子组创建了一个虚拟或单独的列。
比如,“月”列将所有 12 个月作为类别。
因此，每个月都被视为一个子组，get_dummies()函数为每个列创建了一个单独的列。
Index(['temp', 'hum', 'windspeed', 'cnt', 'season_1', 'season_2', 'season_3',
'season_4', 'yr_0', 'yr_1', 'mnth_1', 'mnth_2', 'mnth_3', 'mnth_4',
'mnth_5', 'mnth_6', 'mnth_7', 'mnth_8', 'mnth_9', 'mnth_10', 'mnth_11',
'mnth_12', 'weathersit_1', 'weathersit_2', 'weathersit_3', 'holiday_0',
'holiday_1'],
dtype='object')
你可以在这里通过 get_dummies()函数找到结果数据集。
结论
到此，我们就结束了这个话题。如果你遇到任何问题，欢迎在下面评论。
更多与 Python 相关的帖子，敬请关注，在此之前，祝你学习愉快！！🙂
参考
从熊猫数据框架创建加权图
原文：https://www.askpython.com/python/examples/creating-weighted-graph-dataframe
嘿伙计们！在本教程中，我们将了解如何从熊猫数据框构建我们自己的加权图。
从熊猫数据帧中创建一个加权图
任何 python 程序的第一项任务都是将必要的模块/库导入代码。
import pandas as pd
import numpy as np
import networkx as nx
import matplotlib.pyplot as plt
下一个任务是创建一个数据框，在后面的部分中需要为其绘制图表。同样可以在熊猫和 numpy 模块的帮助下获得。
首先，我们创建一个随机种子，它将有助于在一个特定的范围内生成一些随机整数，这些整数将在后面的部分中作为边的权重。接下来，使用DataFrame函数创建数据框，并将图表数据传递给该函数。
r = np.random.RandomState(seed=5)
weights = r.random_integers(1, 5, size=(5,))
df = pd.DataFrame({'from':['A','B','C','D','E'],'to':['D','E','A','D','C'],'weight':weights})
df.head()
Dataframe 2 Graph Data
接下来，我们将分别借助于draw_networkx_nodes、draw_networkx_edges和draw_networkx_labels函数，通过分别绘制节点、边和标签来尝试可视化权重增加图。
可视化节点
fig, ax = plt.subplots()
pos = nx.spring_layout(G)
plt.title("Plotting Nodes")
nx.draw_networkx_nodes(G, pos, ax = ax)
Dataframe 2 Graph Only Nodes
可视化边缘
fig, ax = plt.subplots()
pos = nx.spring_layout(G)
plt.title("Plotting Edges")
nx.draw_networkx_edges(G, pos, width=durations, ax=ax)
Dataframe 2 Graph Only Edges
可视化完整的图表
fig, ax = plt.subplots()
pos = nx.spring_layout(G)
plt.title("Plotting Complete Graph")
nx.draw_networkx_nodes(G, pos, ax = ax)
nx.draw_networkx_edges(G, pos, width=durations, ax=ax)
_ = nx.draw_networkx_labels(G, pos, labels, ax=ax)
Dataframe 2 Graph Complete Graph
结论
恭喜你！您刚刚学习了如何在 NetworkX 库中使用 pandas 数据框构建图表。希望你喜欢它！😇
喜欢这个教程吗？我建议你看看下面提到的教程:
感谢您抽出时间！希望你学到了新的东西！！😄
Python 中的犯罪预测——完全指南
原文：https://www.askpython.com/python/examples/crime-prediction-in-python
今天我们将讲述如何用 Python 进行犯罪预测。在当今世界，犯罪每天都在上升，而执法人员的数量却在减少，因此我们可以利用机器学习模型来预测一个人是否是罪犯。
用 Python 实现犯罪预测
在本文中，我们将开发一个模型，根据一个人的一些特征来预测他是否是罪犯。
数据集取自 techgig。你可以在这里 获得 Python 笔记本、数据字典、数据集 。
第一步:导入所有需要的库
在我们进入犯罪预测的主要部分之前，让我们导入必要的库。
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
第二步:加载数据集
下一步是使用熊猫模块的read_csv函数将数据文件加载到我们的程序中。
df = pd.read_csv('train.csv')
df.head()
第三步:数据清理
下一步是查看其中是否有任何丢失的值。出于本教程的考虑，我们已经删除了所有丢失的值。
print(df.isna().sum())
第四步:列车测试分割
在这一步中，使用 80-20 规则和sklearn库函数将数据分成个训练和测试数据集。
from sklearn.ensemble import ExtraTreesClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import confusion_matrix , plot_roc_curve
from imblearn.over_sampling import SMOTE
smote = SMOTE()
#stratify for equal no. of classes in train and test set
x_train,x_test ,y_train,y_test = train_test_split(df.iloc[:,1:-1],df.iloc[:,-1], stratify=df.iloc[:,-1],test_size=0.2 ,random_state = 42)
X_re ,y_re= smote.fit_resample(x_train,y_train)
为了解决犯罪类别不平衡的问题，我们采用了 SMOTE(合成少数过采样方法)，一种数据集平衡技术。我们只会平衡训练数据，不会平衡测试数据。
总之，Smote 使用聚类来产生用于过采样的不平衡类的新实例。
步骤 5:创建基于树的分类器
基于树的模型可以用于许多类别特征。使用了树外分级机。
clf = ExtraTreesClassifier()
clf.fit(X_re,y_re)
clf.score(x_test,y_test)
输出显示的分数为0.94335，如果我们仔细观察的话，这已经很不错了。
第六步:显示 ROC 曲线
最后，让我们使用下面提到的代码为我们的模型绘制 ROC 曲线。
plot_roc_curve( clf,x_test,y_test)
ROCCurve CrimePrediction
结论
恭喜你！您刚刚学习了如何使用 Python 编程语言和机器学习来构建犯罪预测器。希望你喜欢它！😇
喜欢这个教程吗？无论如何，我建议你看一下下面提到的教程:
感谢您抽出时间！希望你学到了新的东西！！😄
如何在 Python 中裁剪图像
原文：https://www.askpython.com/python/examples/crop-an-image-in-python
你好！在这篇文章中，我们将关注 Python 中裁剪图像的不同方法。现在，让我们揭开和理解背景函数被用来裁剪图像。
技巧 1: Python PIL 裁剪图像
PIL 代表“ Python 图像库”。PIL 在 python 解释器中增加了图像编辑和格式化功能。因此，它具有许多用于图像处理和图形分析的内置功能。
PIL 内置了裁剪图像矩形部分的功能。
语法:
Image.crop(left, top, right, bottom)
top和left:这些参数代表左上坐标，即(x，y) = (left，top)。bottom和right:这些参数代表右下角坐标，即(x，y) =(右，下)。
要裁剪的区域如下所示:
- 左< = x <右
- 顶部< = y <底部
举例:
from PIL import Image
img = Image.open(r"C:\Users\HP\OneDrive\Desktop\<image>.png")
left = 0
top = 50
right = 510
bottom = 292
img_res = img.crop((left, top, right, bottom))
img_res.show()
在上面的例子中，Image.open(r"image path")是 PIL 在读取模式下打开图像的函数。
我们已经为左、右、上、下坐标分配了特定的值。
Image.show()功能用于显示裁剪后的图像。
原始图像:
Image Used For Cropping Purpose
裁剪后的图像(输出):
Cropped Image Using PIL
技术 2:使用 OpenCV 在 Python 中裁剪图像
Python OpenCV 是一个拥有大量可用于实时计算机视觉的函数的库。它包含了一套很好的函数来处理图像的处理和操作。
为了使用 OpenCV 处理图像，用户需要安装版本为3.0 和更高版本的 OpenCV 库。
首先，我们需要使用下面的代码片段在我们的程序中导入 OpenCV 库:
import cv2
OpenCV 实际上在裁剪图像的方法中对作为数组传递的图像进行切片。
语法:
image[start_x:end_x, start_y:end_y]
- image[] 实际上是通过传递 x 和 y 坐标的起始和结束索引，以数组的形式对图像进行切片。
- 因此，x 和 y 的起始和结束坐标之间的图像作为裁剪的数组对象返回。
举例:
import cv2
image = cv2.imread(r"C:\Users\HP\OneDrive\Desktop\<image>.png")
y=0
x=0
h=300
w=510
crop_image = image[x:w, y:h]
cv2.imshow("Cropped", crop_image)
cv2.waitKey(0)
cv2.imread(r"image path")功能用于在读取模式下打开图像。
此外，提供了 x 轴和 y 轴的开始和结束索引，因此图像被裁剪。
cv2.imshow()功能用于显示裁剪后的图像。我们在这里使用了与之前相同的图像。
裁剪后的图像(输出):
Cropped Image Using OpenCV
结论
因此，在本文中，我们已经了解了用 Python 裁剪图像的方法。
参考
用 Python 进行加密价格预测
原文：https://www.askpython.com/python/examples/crypto-price-prediction
今天在本教程中，我们将使用机器学习算法来预测一种被称为 Dogecoin 的加密货币的未来价格。我们正在使用 Python 作为编程语言。
Dogecoin 是什么？
Dogecoin是一种加密货币，拥有令人愉快的品牌形象，旨在成为加密货币的有益介绍。Dogecoin，也被称为“笑话”硬币，是由俄勒冈州程序员比利·马库斯·T4 提出的。
他推断，一种不太严肃的硬币，如 Dogecoin，即使规模较小，也比比特币更有可能被普通大众接受。
Dogecoin Logo
Dogecoin 可以用来付款和买东西，但它不是保值的好方法。这主要是因为 Dogecoin 对通过采矿产生的硬币数量没有寿命限制，这使得它本质上极度膨胀。
1.导入模块
除了导入各种模块，如 numpy、pandas、matplotlib 和 seaborn，我们还设置了绘图样式和 seaborn 绘图。
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from seaborn import regression
sns.set()
plt.style.use('seaborn-whitegrid')
2.探索数据
既然我们已经导入了模块，我们将加载可以从这里下载的数据集。
数据集包含超过 2.5k 个数据点和 7 个属性，即不同日期的开盘价和收盘价。
data = pd.read_csv("Dogecoin.csv")
print("Shape of Dataset is: ",data.shape,"\n")
print(data.head())
Initial Dogecoin Datapoints
3.可视化 Dogecoin 数据
如果不使用 matplotlib 库可视化数据集，ML 模型就不完整，matplotlib 库可以使用下面提到的代码来实现。
我们将使用线性线图可视化Close属性和Date属性。
data.dropna()
plt.figure(figsize=(10, 4))
plt.title("DogeCoin Price INR")
plt.xlabel("Date")
plt.ylabel("Close")
plt.plot(data["Close"])
plt.show()
Close Vs Date Visualize
4.应用机器学习模型
作为 ML 模型，对于 Dogecoin 数据集，我们将使用AutoTS模型并将该模型导入到程序中。
然后，创建一个 AutoTS 模型对象，以便使用 fit 函数将数据点拟合到模型中，然后使用predict函数预测所有数据点的价格。
最后，显示由 AutoTS 模型预测的价格。下面介绍了实现这一目标的代码。
from autots import AutoTS
model = AutoTS(forecast_length=10, frequency='infer', ensemble='simple', drop_data_older_than_periods=200)
model = model.fit(data, date_col='Date', value_col='Close', id_col=None)
prediction = model.predict()
forecast = prediction.forecast
print("DogeCoin Price Prediction")
print(forecast)
Final Output Dogecoin Price
结论
我希望你理解这个概念，并且理解预测不同日期的 Dogecoin 价格的实现。
编码快乐！😇
想了解更多？查看下面提到的教程:
Python 中密码学的简单介绍
原文：https://www.askpython.com/python-modules/cryptography-module
密码术 被定义为通过将重要信息转换成人类无法直接理解的东西以保持实际消息安全并远离坏人之手来保持重要信息安全的过程。
在现代技术时代，每个人都应该加密发送的数据，因为这不仅是一个很好的做法，而且可以保证个人和官方信息的安全。
还必须有一个强大的加密算法，以确保加密的文本更难破解，你的信息更安全，不会落入坏人之手。
为什么密码学很重要？
加密很重要，原因如下:
- 保护重要信息和通信信息,防止未经授权的人员获取信息。
- 拥有数字签名，有助于保护重要信息不被伪造。
- 保持信息的完整性也很重要。
用 Python 实现加密
既然我们已经学到了很多关于密码学的知识。现在让我们学习如何使用 Python 编程语言自己实现它。
1.导入模块
为了执行加密，我们将使用cryptography模块和Fernet对象。
from cryptography.fernet import Fernet
2.实现加密
为了实现加密，我们将生成一个 Fernet 密钥(称为“秘密密钥”)，然后我们使用该密钥创建一个 Fernet 对象。
这把钥匙非常重要，需要妥善保管！如果有人发现了你的密钥，他/她可以解密你所有的秘密信息，如果你丢失了它，你就不能再解密你自己的信息了。
key = Fernet.generate_key()
Fernet_obj= Fernet(key)
下一步是使用 encrypt 函数对文本进行加密，并将消息传递给该函数。该函数将返回加密的消息。
除此之外，我们还可以使用decrypt函数存储来自加密消息的解密消息，并传递加密消息。
Encry_text = Fernet_obj.encrypt(b"I am a secret! I will get encrypted into something you will never understand")
Org_text= Fernet_obj.decrypt(Encry_text)
3.打印结果
现在让我们用打印我们获得的加密和解密的消息。
print("The Encrypted text is: ", cipher_text)
print("\nThe Decrypted text is: ",plain_text)
输出如下所示。
The Encrypted text is: b'gAAAAABgsSrnZRaDQbApvKL_xiXfCXHV_70u5eXZKDqYIkMKwxochYNy0lmVrvPFtQWya22MZh92rimscuA5VBuoN-B5YfCRHvpBYhKsbIiuPuz-CklJ-EFyZtZ_S7TRe-b9VSoee03Z8jkxwQpR8FatZ1XWA7xZvm5WpGSQFZkN8w7Ix8riyOo='
The Decrypted text is: b'I am a secret! I will get encrypted into something you will never understand'
结论
恭喜你！今天，您了解了加密技术以及如何自己实现加密技术。自己尝试同样的方法，对外界保密你的信息！编码快乐！
用 Python 获取当前日期和时间
原文：https://www.askpython.com/python/examples/current-date-and-time-in-python
介绍
今天在本教程中，我们将讨论如何在 Python 编程中获取当前日期和时间。
很多时候，用户可能需要当前的系统日期和时间来进行各种操作。这个问题可以通过 Python 中的各种内置方法和模块轻松解决。
此外，像pytz和pendulum这样的 python 模块允许用户获得指定时区的当前日期和时间。这个特性非常有用，因为它使代码更加可靠。
在 Python 中获取当前日期和时间的方法
现在让我们开始理解在 Python 中获取当前日期和时间的不同需求。
日期时间模块
datetime模块提供了在 Python 中操作日期和时间的类。
在下面的例子中，我们尝试使用today()方法从 date 类中获取当前日期。
from datetime import date
today = date.today()
print("Date :", today)
输出:
Date : 2020-04-12
这里，today()返回当前的当地日期。同时我们打印出日期。
现在让我们看另一个例子。这次我们将使用datetime模块打印系统的本地日期和当前时间。
import datetime
#datetime object
dt = datetime.datetime.now()
print("Datetime object =", dt)
# printing in dd/mm/YY H:M:S format using strftime()
dt_string = dt.strftime("Date: %d/%m/%Y time: %H:%M:%S")
print("Current date and time =", dt_string)
输出:
Datetime object = 2020-04-12 23:16:58.958467
Current date and time = Date: 12/04/2020 time: 23:16:58
在上面的代码中，
- 来自 datetime 类的
now()方法返回当前的本地日期和时间。因此，此时， dt 持有包含日期和时间信息的日期时间对象 - 接下来，我们使用
strftime()方法将 dt (日期时间对象)转换成可格式化的字符串 - 最后，我们以我们想要的方式打印出当前日期和时间
使用钟摆模块
钟摆是一个时区库，简化了日期时间操作。类似于datetime模块，钟摆模块也提供了一个now()方法，返回本地日期和时间。
使用 PIP 命令可以很容易地安装 Pendulum:
pip install pendulum
例，
import pendulum
time = pendulum.now()
print(time)
输出:
2020-04-12 23:07:22.940108+05:30
如前所述，now()方法返回当前的日期和时间，我们可以从上面的输出中看到。
Python 中某个时区的当前日期和时间
当我们谈论可靠性或跨平台代码可用性时，Python 提供了大量这样的特性。在大多数情况下，用户需要特定的时区的日期或时间，使用一些像pytz或pendulum这样的模块使得在这样的环境中工作更加容易。
pytz模块将 Olson tz 数据库引入 Python，并允许精确的跨平台时区计算。
另一方面，pendulum是一个类似的库，它继承自日期时间模块。它使用一种更干净的方法，比它的对手(pytz)更快。
这两个模块都可以使用下面的 PIP 命令进行安装，
对于pytz模块:
pip install pytz
对于pendulum模块:
pip install pendulum
例子
现在让我们举一个例子，我们试图获取并打印不同时区的日期和时间。这将通过使用pytz和pendulum模块来完成。
import pytz
from datetime import datetime
utc = pytz.timezone('UTC')
pst = pytz.timezone('America/Los_Angeles')
ist = pytz.timezone('Asia/Calcutta')
print("Using pytz Module:")
print('Current Date and Time in UTC =', datetime.now(utc))
print('Current Date and Time in PST =', datetime.now(pst))
print('Current Date and Time in IST =', datetime.now(ist))
import pendulum
utc1 = pendulum.timezone('UTC')
pst1 = pendulum.timezone('America/Los_Angeles')
ist1 = pendulum.timezone('Asia/Calcutta')
print("Using pendulum Module:")
print('Current Date Time in UTC =', datetime.now(utc1))
print('Current Date Time in PST =', datetime.now(pst1))
print('Current Date Time in IST =', datetime.now(ist1))
输出:
Current Date And Time In Time Zone – Output
这里，
- 对于这两种情况，首先我们使用为 pytz 和钟摆模块定义的
timezone()方法，同时通过所需的时区 - 然后我们将这些时区对象从 datetime 类传递给
now()方法。方法返回给定时区的准确日期和时间。因此，我们直接把它打印出来。
结论
因此，在本教程中，我们学习了在 Python 中获取当前日期和时间的各种方法或技术。
如有任何进一步的问题，欢迎使用下面的评论。
参考
- Python 摆锤模块，
- 日期时间模块–Python 文档，
- 如何在 Python 中获取当前时间？–堆栈溢出问题，
- 从 UTC 时间获取时区本地时间:箭头 vs 钟摆 vs pytz–堆栈溢出问题。
Python 中的 Currying 初学者入门
原文：https://www.askpython.com/python/examples/currying-in-python
在本文中，我们将尝试理解" 库里 " 的概念，它的优点，以及它在 python 中的实现。Currying 实际上是为了纪念数学家和逻辑学家 Haskell Curry 而命名的。它是功能设计模式之一。它主要用于解决问题和根据数学函数概念设计的程序。
什么是设计模式？
设计模式为常见或重复出现的问题提供了标准解决方案。设计模式的使用非常方便，有助于开发人员提高他们正在处理的代码的可读性。
什么是 Currying？
使用这样一种功能设计模式主要用于将带有多个参数的函数简化为一个函数链，每个函数链都带有一个参数。
例如:
function_mult(1,2,3) ---> function_mult(1)(2)(3)
请考虑左边的函数，它执行乘法，有三个参数 1、2 和 3，然后根据所有三个参数的值生成输出。
在执行 Currying 之后，该函数被改变为具有单个参数的函数，该函数接受第一个参数(这里是 1)并返回接受第二个参数(这里是 2)的新函数，该函数然后再次返回接受第三个参数(这里是 3)的新函数，然后产生最终输出。
这就是 currying 如何将一个具有多个参数的函数变成一个由单个参数的多个函数组成的链。
我们如何在 Python 中实现 Currying？
为了理解 currying 的实现，让我们首先定义一个具有多个参数的函数。
考虑下面的函数，它对所提供的参数执行乘法运算。
def mult(x, y, z):
return x * y * z
ans = mult(10, 20, 30)
print(ans)
输出:
Six thousand
currying 的第一步是将多个参数绑定在一起。考虑函数有 n 个参数，我们需要绑定所有这些参数，为此我们用第一个参数固定函数，并创建一个接受(n–1)个参数的新函数。现在我们继续创建新的函数，直到函数的参数个数为 1。
在 python 中，我们使用 functools 中的标准 Python 函数 partial
from functools import partial
mult_10 = partial(mult, 10)
mult_10_20 = partial(mult_10, 20)
print(mult_10_20(30))
输出:
Six thousand
使用装饰器涂抹
使用装饰器可以更有效地实现 Currying。装饰器将代码或功能包装在函数周围，以增强函数的功能。为此，我们使用不同的标准 python 函数。(了解更多关于装修工 点击这里 )
首先我们使用签名，它有助于记录传递给函数的参数数量。
部分函数在这里有助于将带有 n 个参数的函数派生为带有较少参数的函数
from inspect import signature
def curry(func):
def inner(arg):
#checking if the function has one argument,
#then return function as it is
if len(signature(func).parameters) == 1:
return func(arg)
return curry(partial(func, arg))
return inner
#using cuury function on the previous example function
@curry
def mult(x, y, z):
return x * y * z
print(mult(10)(20)(30))
输出:
Six thousand
开始奉承
Curry 是一个功能性的设计模式。使用 curry 的主要目的是将给定的函数简化为一系列绑定函数，这使得开发人员的工作更加方便，并且使得解决方案更具可读性。在本文中，我们试图理解 Python 语言中 Curry 的工作和实现。
参考
Python 中的曲线拟合:完全指南
原文：https://www.askpython.com/python/examples/curve-fitting-in-python
在本文中，我们将学习 python 中针对给定数据集的不同方法的曲线拟合。但是在开始之前，让我们先了解一下曲线拟合的目的是什么。
曲线拟合的目的是查看数据集并提取参数的优化值，以模拟给定函数的数据集。为此，我们将使用一个名为curve_fit(). 的函数
在开始我们的代码片段之前，让我们导入一些我们需要在开始之前导入的重要模块。
#importing modules
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit
Python 中的曲线拟合是什么？
给定数据集 x = {x [1] ，x [2] ，x [3] …} 和 y= {y [1] ，y [2] ，y [3] …} 和一个函数 f，取决于一个未知参数 z 。我们需要为这个未知参数 z 找到一个最佳值，使得函数 y = f(x，z) 与函数和给定数据集最相似。这个过程称为曲线拟合。
为此，我们还需要应用两种不同的方法来进行曲线拟合。
- 最小二乘法
- 最大似然估计
最小二乘法
在这个方法中，我们将通过调整 z 中的值来最小化一个函数 ∑ [i] (f(x [i] ，z)–y[I])²。
我们可以在最高最小化之后找到优化值。
最大似然估计
当我们的数据集中有一些错误时，我们可以使用这种方法。那就是 σ。
我们需要最小化函数 ∑ [i] (f(x [i] ，z)-y[I])²/σ²。在上述函数的最高最小化之后，它给出了 z 的最佳值。
让我们看看下面的样本数据集。
x_data = np.array([ 0.23547456, 0.15789474, 0.31578947, 0.47368421, 0.63157895,
0.78947368, 0.94736842, 1.10526316, 1.26315789, 1.42105263,
1.57894737, 1.73684211, 1.89473684, 2.05263158, 2.21052632,
2.36842105, 2.52631579, 2.68421053, 2.84210526, 3.45454545 ])
y_data = np.array([ 2.95258285, 2.49719803, -2.1984975, -4.88744346, -7.41326345,
-8.44574157, -10.01878504, -13.83743553, -12.91548145, -15.41149046,
-14.93516299, -13.42514157, -14.12110495, -17.6412464 , -16.1275509 ,
-16.11533771, -15.66076021, -13.48938865, -11.33918701, -11.70467566])
plt.scatter(x_data , y_data)
plt.show()
上面的代码片段将给出示例数据集的输出，如下所示。
Plotting For Sample Datasets
曲线拟合示例 1
为了描述未知参数 z，我们在模型中取三个不同的变量 a，b 和 c。为了确定 z 的最佳值，我们需要分别确定 a、b 和 c 的值。即 z= (a，b，c) 。以及函数 y = f (x，z) = f (x，a，b，c) = a(x-b)² + c 。让我们一步一步来。
步骤 1:定义模型函数
def model_f(x,a,b,c):
return a*(x-b)**2+c
步骤 2:使用 curve_fit()函数
popt, pcov = curve_fit(model_f, x_data, y_data, p0=[3,2,-16])
在上面的函数中，我们为a, b and c提供初始值作为p0=[3,2,-16]。
上述函数将分别返回两个值 popt、pcov。
popt
array([ 4.34571181, 2.16288856, -16.22482919])
pcov
array([[ 0.19937578, -0.02405734, -0.1215353 ],
[-0.02405734, 0.00517302, 0.00226607],
[-0.1215353 , 0.00226607, 0.29163784]])
- popt:a、b、c 的估计优化值
- pcov:协方差矩阵或误差
现在，让我们为 a、b 和 c 绘制相同的函数。在这种情况下，我们将只解释我们的 popt 值(最小二乘法)，在下一个代码片段中，我们将解释我们的 pcov 值(即解释错误值)。
a_opt, b_opt, c_opt = popt
x_model = np.linspace(min(x_data), max(y_data), 100)
y_model = model_f(x_model, a_opt, b_opt, c_opt)
plt.scatter(x_data, y_data)
plt.plot(x_model, y_model, color='r')
plt.show()
上面的代码片段将给出如下所示的输出。
现在解释 pcov 值，我们可以更好地拟合给定函数(最大似然估计)。让我们快速看一下下面的代码片段。
plt.imshow(np.log(np.abs(pcov)))
plt.colorbar()
plt.show()
上面的代码片段将给出如下输出。
示例 2
让我们用另一个例子(不同的函数)来理解给定的数据集，并尝试两种不同的方法。在本例中，为了描述未知参数z，我们在模型中采用了四个不同的变量，分别命名为 a、b、c 和 d。为了确定 z 的最佳值，我们需要分别确定 a、b、c 和 d 的值。让我们快速看一下下面的代码片段。
步骤 1:定义模型函数
#Defining our function
def fit_f(x,a,b,c,d):
return a*(x-b)**2+c+d*0.0001*np.cos(x)
步骤 2:使用 curve_fit()函数
#using our curve_fit() function
popt, pcov = curve_fit(fit_f,x_data,y_data,p0=[1,2,-16,1])
在上面的函数中，我们为a, b, c and d提供初始值作为p0=[1,2,-16,1]。
我们可以通过打印相同的内容来查看 popt 和 pcov 的值。
popt
array([ 5.00494014e+00, 2.75689923e+00, -2.21559741e+01, -8.97724662e+04])
pcov
array([[ 1.71072218e-01, 4.21450805e-03, -4.30580853e-01,
-5.74603933e+03],
[ 4.21450805e-03, 3.33701247e-02, -3.97891468e-01,
-4.49561407e+03],
[-4.30580853e-01, -3.97891468e-01, 5.68973874e+00,
6.50631130e+04],
[-5.74603933e+03, -4.49561407e+03, 6.50631130e+04,
7.82484767e+08]])
现在，让我们为 a、b 和 c 的优化值绘制相同的函数。在这种情况下，我们将只解释我们的 popt 值(最小二乘法)，在下一个代码片段中，我们将解释我们的 pcov 值(即解释错误值)。
a_opt, b_opt, c_opt, d_opt = popt
x_model = np.linspace(min(x_data), max(y_data), 100)
y_model = fit_f(x_model, a_opt, b_opt, c_opt,d_opt)
plt.scatter(x_data, y_data)
plt.plot(x_model, y_model, color='r')
plt.show()
上面的代码片段将给出如下输出。
现在解释 pcov(协方差误差矩阵)值，我们可以更好地拟合给定函数(最大似然估计)。让我们快速看一下下面的代码片段。
plt.imshow(np.log(np.abs(pcov)))
plt.colorbar()
plt.show()
摘要
今天，我们学习了 Python 曲线拟合。我们已经看到了如何使用curve_fit() 方法为给定的数据集优化给定的函数。除了我们的例子之外，您还可以使用任何其他数据集来做同样的事情，并尝试上面的代码片段。
您可以尝试获取不同数据集的 CSV 文件，并提取相同数据集的优化值。
我希望你会发现这一个更有帮助。我们必须带着一些更令人兴奋的话题再次访问。
定制 Pyvis 交互式网络图
原文：https://www.askpython.com/python/examples/customizing-pyvis-interactive-network-graphs
在本教程中，我们将学习如何通过向网络图添加可用属性来定制 Python 中的交互式网络图，并使其看起来更好。
也读作:用 Python 创建互动网络图
有许多节点属性可以使可视化变得非常有趣，下面列出了这些属性:
- 大小-节点的半径
- value–节点的半径，但根据传递的值进行缩放
- 标题–标题意味着当用户悬停在节点上时，显示在节点上的文本
- X 和 Y 值–提及节点的 X 和 Y 坐标。
- 标签–标签是显示在节点旁边的文本。
- color–该属性中提到了节点的颜色。
我们开始吧！
代码实现
对于本教程，我们将从一个由 10 个节点组成的简单图形开始，这些节点具有随机边，可以使用下面的 python 代码来构建。
def generate_edge():
s = random.randint(1,10)
d = random.randint(1,10)
return (s,d)
g = net.Network(height='600px',width='90%',
bgcolor='white',font_color="red",
heading="A Simple Networkx Graph")
for i in range(1,11):
g.add_node(i)
i=0
chosen_set = []
while(i!=20):
eg = generate_edge()
if(eg[0]!=eg[1] and not (eg in chosen_set)):
chosen_set.append(eg)
g.add_edge(eg[0],eg[1])
i+=1
g.show('Simple_Network_Graph.html')
display(HTML('Simple_Network_Graph.html'))
生成的网络图看起来有点像下图。
现在，我们将在接下来的章节中一次处理一个节点属性。
向图表添加标签
我们可以在 add_node 函数中添加标签作为标签属性。在这种情况下，使用下面的代码将标签设置为节点号。label 参数是最终可视化中节点旁边可见的字符串。
def generate_edge():
s = random.randint(1,10)
d = random.randint(1,10)
return (s,d)
g_labels = net.Network(height='600px',width='90%',
bgcolor='white',font_color="red",
heading="A Simple Networkx Graph with Labels")
for i in range(1,11):
g_labels.add_node(i,label=str(i))
i=0
chosen_set = []
while(i!=20):
eg = generate_edge()
if(eg[0]!=eg[1] and not (eg in chosen_set)):
chosen_set.append(eg)
g_labels.add_edge(eg[0],eg[1])
i+=1
g_labels.show('Simple_Network_Graph_labels.html')
display(HTML('Simple_Network_Graph_labels.html'))
生成的网络图如下所示。
增加节点的大小
在本节中，我们将以 value 属性的形式添加节点的大小，以便将节点缩放到特定的值。为了得到随机比例因子，我们将使用下面的函数。
def generate_size_node():
v = random.randint(5,20)
return v
接下来，我们将把 value 属性添加到 add_node 函数中，并将比例因子作为 value 属性的值，就像我们在下面的代码中所做的那样。
def generate_size_node():
v = random.randint(5,20)
return v
g_sizes = net.Network(height='600px',width='90%',
bgcolor='white',font_color="red",
heading="Network Graph with Different Sizes")
for i in range(1,11):
val = generate_size_node()
g_sizes.add_node(i,label=str(i),value=val)
i=0
chosen_set = []
while(i!=20):
eg = generate_edge()
if(eg[0]!=eg[1] and not (eg in chosen_set)):
chosen_set.append(eg)
g_sizes.add_edge(eg[0],eg[1])
i+=1
g_sizes.show('Simple_Network_Graph_sizes.html')
display(HTML('Simple_Network_Graph_sizes.html'))
这是令人惊叹的视觉效果。
向节点添加颜色
本节将重点介绍如何给节点添加各种颜色。我们将使用下面的函数以六进制编码的形式生成随机颜色。我们将以颜色属性的形式添加颜色，它也可以采用普通的 HTML 颜色，如红色或蓝色。我们也可以指定完整的 RGBA 或 hexacode 规格作为下面的颜色。
看看下面的代码和输出。
def generate_color():
random_number = random.randint(0,16777215)
hex_number = str(hex(random_number))
hex_number ='#'+ hex_number[2:]
return hex_number
g_colors =net.Network(height='600px',width='90%',
bgcolor='white',font_color="red",
heading="Network Graph with Different Colors")
colors=[]
for i in range(1,11):
c = generate_color()
colors.append(c)
while(c in colors):
c = generate_color()
colors.append(c)
val = generate_size_node()
g_colors.add_node(i,label=str(i),color=c,value=val)
i=0
chosen_set = []
while(i!=20):
eg = generate_edge()
if(eg[0]!=eg[1] and not (eg in chosen_set)):
chosen_set.append(eg)
g_colors.add_edge(eg[0],eg[1])
i+=1
g_colors.show('Simple_Network_Graph_colors.html')
display(HTML('Simple_Network_Graph_colors.html'))
指定节点的形状
节点的形状定义了节点在最终可视化中的样子。有许多可用的形状，包括正方形、星形、多边形等。有两种类型的节点。一种类型里面有标签，另一种类型下面有标签。
看看下面的代码，它会将形状分配给节点。看看最终的可视化。
def get_random_shape():
shapes = ['box','polygon','triangle','circle','star','cylinder']
r = random.randint(0,len(shapes)-1)
return shapes[r]
g_shapes =net.Network(height='600px',width='90%',
bgcolor='white',font_color="red",
heading="Network Graph with Different Shapes")
colors=[]
for i in range(1,11):
c = generate_color()
colors.append(c)
while(c in colors):
c = generate_color()
colors.append(c)
val = generate_size_node()
s = get_random_shape()
g_shapes.add_node(i,label=str(i),color=c,value=val,shape=s)
i=0
chosen_set = []
while(i!=20):
eg = generate_edge()
if(eg[0]!=eg[1] and not (eg in chosen_set)):
chosen_set.append(eg)
g_shapes.add_edge(eg[0],eg[1])
i+=1
g_shapes.show('Simple_Network_Graph_shapes.html')
display(HTML('Simple_Network_Graph_shapes.html'))
添加了节点边框宽度
节点的边框宽度定义了节点边框的宽度。看看下面的代码，它将为节点分配边框宽度。看看最终的可视化。
g_borders =net.Network(height='600px',width='90%',
bgcolor='white',font_color="red",
heading="Network Graph with Different BorderWidths")
colors=[]
for i in range(1,11):
c = generate_color()
colors.append(c)
while(c in colors):
c = generate_color()
colors.append(c)
val = generate_size_node()
s = get_random_shape()
b = random.randint(3,5)
g_borders.add_node(i,label=str(i),color=c,
value=val,shape=s,borderWidth=b)
i=0
chosen_set = []
while(i!=20):
eg = generate_edge()
if(eg[0]!=eg[1] and not (eg in chosen_set)):
chosen_set.append(eg)
g_borders.add_edge(eg[0],eg[1])
i+=1
g_borders.show('Simple_Network_Graph_Borders.html')
display(HTML('Simple_Network_Graph_Borders.html'))
完整的代码
让我们看一下下面的代码，它将涵盖上面提到的所有自定义属性以及一些额外的属性。除此之外，我们还将显示网络图的物理按钮。我们还将为节点添加标题，并将网络图定向为显示边的箭头。
def generate_edge():
s = random.randint(1,10)
d = random.randint(1,10)
return (s,d)
def generate_size_node():
v = random.randint(5,20)
return v
def generate_color():
random_number = random.randint(0,16777215)
hex_number = str(hex(random_number))
hex_number ='#'+ hex_number[2:]
return hex_number
g_complete =net.Network(height='600px',width='50%',
bgcolor='white',font_color="red",notebook=True,
heading="A Complete Networkx Graph",directed=True)
colors=[]
for i in range(1,11):
c = generate_color()
colors.append(c)
while(c in colors):
c = generate_color()
colors.append(c)
val = generate_size_node()
b = random.randint(3,5)
g_complete.add_node(i,label=str(i),color=c,value=val,
title="Hello! I am Node "+str(i),borderWidth=b)
i=0
chosen_set = []
while(i!=20):
eg = generate_edge()
if(eg[0]!=eg[1] and not (eg in chosen_set)):
chosen_set.append(eg)
g_complete.add_edge(eg[0],eg[1])
i+=1
g_complete.show_buttons(['physics'])
g_complete.show('A_Complete_Networkx_Graph.html')
display(HTML('A_Complete_Networkx_Graph.html'))
结论
在本教程中，我们学习了节点的自定义属性，只需添加一些内容就可以使交互图形更加漂亮。我希望你喜欢网络图以及它们的互动性！
感谢您的阅读！
编码快乐！😃
Python 中的守护线程——它们是什么，如何创建它们？
原文：https://www.askpython.com/python-modules/daemon-threads-in-python
大家好！在今天的帖子中，我们将看看如何在 Python 中使用守护线程。在我们开始讨论主题之前，让我们先看看什么是守护线程！
守护线程
守护线程是一种可以在后台独立运行的线程。这些类型的线程独立于主线程执行。所以这些被称为非阻塞线程。
在 Python 中什么时候可能需要守护线程？
假设您需要一个长时间运行的任务来尝试读取日志文件。当此任务在日志中检测到错误消息时，必须提醒用户。
我们可以为这个任务分配一个守护线程，它可以一直监视我们的日志文件，而我们的主程序做它通常的工作！
关于守护线程最好的部分是，一旦主程序完成，它们将自动停止执行！
如果你需要一个短任务，一个守护线程会在它返回后停止执行。然而，由于这个性质，守护线程被广泛用于长期运行的后台任务。
现在，让我们看一个例子，展示我们如何在 Python 中使用它们！
在 Python 中使用守护线程——动手实现
Python 中的这些例子将使用 Python 中的线程模块，它是标准库的一部分。
import threading
为了说明守护线程的强大功能，让我们首先创建两个线程，A 和 b。
我们将让线程 A 执行一个简短的计算，而线程 B 试图监控一个共享资源。
如果这个资源被设置为True，我们将让线程 B 提醒用户这个状态。
import threading
import time
# Set the resource to False initially
shared_resource = False
# A lock for the shared resource
lock = threading.Lock()
def perform_computation():
# Thread A will call this function and manipulate the resource
print(f'Thread {threading.currentThread().name} - performing some computation....')
shared_resource = True
print(f'Thread {threading.currentThread().name} - set shared_resource to True!')
print(f'Thread {threading.currentThread().name} - Finished!')
time.sleep(1)
def monitor_resource():
# Thread B will monitor the shared resource
while shared_resource == False:
time.sleep(1)
print(f'Thread {threading.currentThread().name} - Detected shared_resource = False')
time.sleep(1)
print(f'Thread {threading.currentThread().name} - Finished!')
if __name__ == '__main__':
a = threading.Thread(target=perform_computation, name='A')
b = threading.Thread(target=monitor_resource, name='B')
# Now start both threads
a.start()
b.start()
这里，线程 A 会将shared_resource设置为True，线程 B 会等待这个资源为真。
输出
Thread A - performing some computation....
Thread A - set shared_resource to True!
Thread A - Finished!
Thread B - Detected shared_resource = False
Thread B - Finished!
请注意，这两个线程都是普通线程。现在让我们让线程 B 成为一个守护线程。让我们看看现在会发生什么。
为此，我们可以将其设置为threading.Thread(daemon=True)方法中的一个参数。
import threading
import time
shared_resource = False # Set the resource to False initially
lock = threading.Lock() # A lock for the shared resource
def perform_computation():
# Thread A will call this function and manipulate the resource
print(f'Thread {threading.currentThread().name} - performing some computation....')
shared_resource = True
print(f'Thread {threading.currentThread().name} - set shared_resource to True!')
print(f'Thread {threading.currentThread().name} - Finished!')
time.sleep(1)
def monitor_resource():
# Thread B will monitor the shared resource
while shared_resource == False:
time.sleep(1)
print(f'Daemon Thread {threading.currentThread().name} - Detected shared_resource = False')
time.sleep(1)
print(f'Daemon Thread {threading.currentThread().name} - Finished!')
if __name__ == '__main__':
a = threading.Thread(target=perform_computation, name='A')
b = threading.Thread(target=monitor_resource, name='B', daemon=True) # Make thread B as a daemon thread
# Now start both threads
a.start()
b.start()
输出
Thread A - performing some computation....
Thread A - set shared_resource to True!
Thread A - Finished!
Daemon Thread B - Detected shared_resource = False
这里，注意守护线程没有完成。这是因为它会自动被主线程杀死。
守护线程的非阻塞特性使得它对很多 Python 应用程序非常有用。
结论
在本文中，我们了解了如何在 Python 应用程序中使用守护线程
参考
- Python 线程模块文档
- 关于 Python 中守护线程的 JournalDev 文章
Python 中的数据分析——快速介绍
原文：https://www.askpython.com/python/examples/data-analysis-in-python
让我们了解更多关于 Python 中的数据分析。如果你掌握了 Python，分析数据是相当容易的。有很多相同的软件包可供选择。
在这篇文章中，我们将看看不同的 python 包、工具和方法，它们帮助我们进行数据分析。我们将从了解如何将不同形式的数据文件——从 excel 表格到在线数据库——导入 python 源代码开始，然后我们将了解将这些数据实现为不同类型的图表的方法。
使用 Python 进行数据分析
在我们阅读任何数据之前，首先我们需要掌握如何在 python 中加载不同类型文件的知识，然后我们才能继续。
在 Python 中加载本地数据集
在此示例中，程序加载。运行 python 脚本的同一目录中的 csv 文件。
import pandas as pd
df=pd.read_csv('health_index.csv')
在 Python 中从 URL 加载数据集
从下面的代码可以清楚地看出,“pd.read”语法很容易加载。csv 文件。
import pandas as pd
df=pd.read_csv('http://winterolympicsmedals.com/medals.csv')
print(df)
Output 1.1
在 Python 中加载 Excel 数据
“pd.read_excel”语法类似于之前使用的“pd.read”语法，它用于将 excel 表加载到我们的 python 程序中。我们使用了一个 excel 表(“data.xlsx ”,它位于运行 python 代码的同一目录中，我们还使用了“openpyxl”引擎，这是 python 的一个 excel 解释器。
import pandas as pd
df = pd.read_excel('data.xlsx', engine='openpyxl')
如何在 Python 中使用不同的图表分析数据？
自从数字的概念产生以来，人类已经创造了多种方法来使计数变得更容易。但是从来没有比图形和图表更容易理解数字。在数据分析中，我们也将看到 python 模块，这些模块有助于使用我们加载的数据文件创建图形和图表。
1.饼图
饼图是两组不同数据的 360 度图形表示，显示在一起以显示汇合点。在下面的代码中，程序将绘制一个包含两组值的饼图——“年龄”、“怀孕”。
代码:
# import statements
import plotly.express as fpx
import pandas as pd
# loading health_index file
fdf = pd.read_csv('health_index.csv')
preg_stats = fdf['Pregnancies']
age_stats = fdf['Age']
fig = fpx.pie(fdf,
values=preg_stats,
names=age_stats,
title='Survey Results'
)
fig.update_traces(
textposition='inside',
textinfo='percent+label'
)
fig.update_layout(
title_font_size = 42,
)
fig.show()
Output 1.2
2.折线图
绘制折线图是为了理解两组值之间的关系。在下面的代码中，程序绘制折线图并显示输出。
代码:
# import statements
import matplotlib.pyplot as plt
import pandas as pd
# loading 10 rows of the file
fdf= pd.read_csv("health_index.csv", nrows=10)
#Sorting the two columns in ascending order
fdf.sort_values(["Age", "Pregnancies"],
axis=0,
inplace=True)
preg_stats = fdf['Pregnancies']
age_stats = fdf['Age']
plt.plot(age_stats,preg_stats)
plt.show()
Output 1.3
3.分散
matplotlib 中的散点图函数将数值分布在一个二维平面中，并可视化其图形表示。这种表示适用于分析一组值的密度、随机分布等属性。也可以对一个以上的变量进行表示。
在本例中，消费者记录数据库用于编辑结果并生成散点图。下面的代码可视化了数据库中一组两个变量的散点图。
代码:
import pandas as pd
import matplotlib.pyplot as plt
plt.style.use('seaborn')
data = pd.read_csv('clothing_data.csv', nrows=1000)
cid = data['Clothing ID']
age = data['Age']
rating = data['Rating']
plt.scatter(age, rating, cmap='summer',
edgecolor='black', linewidth=1, alpha=0.75)
cbar = plt.colorbar()
cbar.set_label('Age/Rating Ratio')
plt.xscale('log')
plt.yscale('log')
plt.title('Age vs Rating')
plt.xlabel('Age ->')
plt.ylabel('Rating ->')
plt.tight_layout()
plt.show()
Output 1.4
4.柱状图
直方图是频率分布的图形表示，用相邻的条形显示。直方图函数直方图是频率分布的图形图像，用相邻的条形表示。matplotlib 的直方图函数从单个变量中绘制频率点，并在输出中展示它们。
代码:
import matplotlib.pyplot as plt
import pandas as pd
data = pd.read_csv('clothing_data.csv', nrows=1000)
age = data['Age']
plt.hist(age)
plt.show()
Output 1.5
5.条形图
水平和垂直表示的两组变量的矩形表示。
代码:
import matplotlib.pyplot as plt
import pandas as pd
data = pd.read_csv('clothing_data.csv', nrows=1000)
cid = data['Clothing ID']
age = data['Age']
plt.barh(age, cid)
plt.show()
Output 1.6
结论
我希望您现在已经理解了数据分析的基础知识，并且能够将数据库导入到您的 python 代码中，并在 matplotlib 的帮助下创建理想的图表。我们学习了如何导入数据文件类型，如-。我们还学习了如何可视化不同的 matplotlib 图形，如直方图、条形图、散点图等。要了解更多信息，请查看参考资料部分。
参考
要使用的数据库:点击此处
Python 中的数据分析与熊猫
原文：https://www.askpython.com/python-modules/pandas/data-analysis
数据分析是当今世界最重要的工具之一。如今，数据存在于生活的各个领域，无论是生物数据还是科技公司的数据。不管你在处理什么样的数据，你必须知道如何过滤和分析你的数据。今天我们将讨论 Python 中的一个数据分析工具，即 Pandas。
让我们首先了解 Python 中用于数据分析的一些主要库。
Python 中用于数据分析的主要库
Python 有许多强大的数据分析工具，例如 Python 库，它为数据分析师提供了分析数据的必要功能。
- Numpy 和 Scipy : 这两个库都非常强大，广泛用于科学计算。
- Pandas: Pandas 是一个用于数据操作的健壮工具。Pandas 是一个相对较新的工具，已经被添加到数据科学库中。
- Matplotlib: Matplotlib 是一个优秀的包，主要用于绘图和可视化。您可以使用 Matplotlib 绘制各种图形，如直方图、线图、热度图等。
- Scikit-Learn: Scikit-Learn 是一款优秀的机器学习工具。这个库拥有机器学习和统计建模所需的所有必要工具。
- 统计模型:这是另一个优秀的统计建模工具。这个库允许用户建立统计模型并进行分析。
- Seaborn : Seaborn 也广泛用于数据可视化。它基于 Matplotlib，是用于在 Python 中构建统计图形的。
在这篇文章中，我们将从所有这些工具中了解熊猫，并对熊猫进行动手数据分析。
熊猫是什么，为什么它在数据分析中如此有用？
Pandas 是构建在 Numpy 包之上的开源 python 库。它提供了所有必要的功能和方法，使数据分析过程更快更容易。由于其灵活性和更简单的语法，它最常用于数据分析。Pandas 在处理 Excel 电子表格、表格数据或 SQL 时非常有用。
Pandas 中的两个主要数据结构是数据帧和序列。数据帧是一种二维数据结构。在本文中，我们将使用熊猫数据框架。数据可以以各种格式导入，用于 Python 中的数据分析，例如 CSV、JSON 和 SQL。
现在让我们进入数据分析部分。
安装不同的环境并导入熊猫
首先，你需要安装熊猫。你可以用不同的环境来做同样的事情。你可以使用 Anaconda 直接在你的电脑上运行 Pandas，也可以通过谷歌云上的浏览器使用 T2 Jupyter 笔记本。Anaconda 附带了许多预安装的包，可以很容易地在 Mac、Windows 或 Linux 上下载。
让我们来看看如何安装和导入熊猫的以下步骤。要在您的环境中安装 Pandas，请使用 pip 命令。
pip install pandas
注意:如果你使用 Google Colab，你不需要添加这个命令，因为 Google Colab 预装了 Pandas。
现在，要将 Pandas 导入到您的环境中，请键入以下命令。
import pandas as pd
现在我们知道了如何安装和导入 Pandas，让我们更深入地理解 Pandas Dataframe 是什么。
熊猫数据框
Pandas DataFrame 是一个二维数据结构，几乎像一个二维数组。DataFrame 具有标记轴(行和列),并且是可变的。
让我们进入动手数据分析部分。
在本文中，我们使用的数据来自一个关于“2022 年各国男女身高”的 Kaggle 竞赛。
链接到数据集:https://www . ka ggle . com/majy hain/height-of-male-and-female-by-country-2022
让我们现在加载数据集并读取它。
读取 CSV 文件并加载数据
要将文件读入 DataFrame，需要将文件的路径作为以下函数的参数。
df = pd.read_csv("C://Users//Intel//Documents//Height of Male and Female by Country 2022.csv")
df.head()
这里我们使用了 read_csv 函数，因为我们正在读取 csv 文件。
借助 head 功能，您可以检查数据帧的前 n 个条目。如果您没有传递条目数，默认情况下将显示前 5 行。
评估熊猫数据框架
现在，我们将看看我们正在处理的数据帧。
让我们看看我们正在使用的数据的维度。为此，我们需要传递以下命令。
df.shape
(199, 6)
形状函数将返回一个包含行数和列数的元组。我们可以看到，我们的数据帧有 199 行和 6 列，或特征。
接下来，在 info 函数的帮助下，我们将看到数据集的摘要。
df.info
<bound method DataFrame.info of Rank Country Name Male Height in Cm Female Height in Cm \
0 1 Netherlands 183.78 170.36
1 2 Montenegro 183.30 169.96
2 3 Estonia 182.79 168.66
3 4 Bosnia and Herzegovina 182.47 167.47
4 5 Iceland 182.10 168.91
.. ... ... ... ...
194 195 Mozambique 164.30 155.42
195 196 Papua New Guinea 163.10 156.89
196 197 Solomon Islands 163.07 156.79
197 198 Laos 162.78 153.10
198 199 Timor-Leste 160.13 152.71
Male Height in Ft Female Height in Ft
0 6.03 5.59
1 6.01 5.58
2 6.00 5.53
3 5.99 5.49
4 5.97 5.54
.. ... ...
194 5.39 5.10
195 5.35 5.15
196 5.35 5.14
197 5.34 5.02
198 5.25 5.01
[199 rows x 6 columns]>
您可以看到输出为我们提供了一些关于数据帧的有价值的信息。它显示数据类型、内存使用、非空值和列名。
接下来，我们将对数据集的统计数据有一点了解。
df.describe()
在输出中，我们可以看到数据集中每个要素的计数、平均值、中值、标准差、上下四分位数以及最小值和最大值。
数据处理和分析
让我们先快速查看一下数据集中的不同要素，以帮助您更好地理解数据集。
国家名称:已收集数据的国家的名称。
男性身高厘米:男性人口身高厘米
女性身高厘米-女性人口身高厘米
男性身高英尺。-男性人口的身高，单位为英尺。
以英尺为单位的女性身高。-女性人口的身高，单位为英尺。
设置数据帧索引
现在，让我们设置数据框索引。
我们可以从我们的数据中看到，第一列“排名”对于不同的国家是不同的，从数字 1 开始。我们可以利用这一点，将“Rank”列设置为索引。
df.set_index('Rank',inplace=True)
df.index
让我们再看一次数据框。
df= pd.read_csv("C://Users//Intel//Documents//Height of Male and Female by Country 2022.csv", index_col='Rank')
df.head()
数据集现在看起来更有条理了。
行和列
您已经知道数据帧有行和列。可以使用以下命令轻松访问数据框中的列:
df.columns
Index(['Country Name', 'Male Height in Cm', 'Female Height in Cm',
'Male Height in Ft', 'Female Height in Ft'],
dtype='object')
df['Country Name'].head()
Rank
1 Netherlands
2 Montenegro
3 Estonia
4 Bosnia and Herzegovina
5 Iceland
Name: Country Name, dtype: object
我们还可以使用以下命令重命名我们的列:
df.rename(columns={'Male Height in Cm': 'Male Height in Centimeter'}, inplace=True)
df.head()
您还可以向数据框中添加列。让我们来看看如何做到这一点。
df_copy = df.copy()
df_copy['Height Ratio'] = 'N'
df_copy.head()
我们已经为新列指定了值“N”。
让我们假设您有另一个数据帧，您想追加或添加到现有的数据帧(df_copy)。我们可以在 append 函数的帮助下做到这一点。
data_to_append = {'Country Name': ['X', 'Y'],
'Male Height in Centimeter': ['172.43', '188.94'],
'Female Height in Cm': ['150.99', '160.99'],
'Male Height in Ft': ['6.09', '5.44'],
'Female Height in Ft': ['5.66', '6.66'],
'Height Ratio': ['Y', 'N']}
df_append = pd.DataFrame(data_to_append)
df_append
df_copy = df_copy.append(df_append, ignore_index=True)
df_copy.tail()
我们可以使用 drop 函数从数据帧中删除行和列。
要删除行，您应该使用以下代码:
df_copy.drop(labels=179, axis=0, inplace=True)
对于删除列，下面的代码将起作用:
df_copy.drop(labels='Height Ratio', axis=1, inplace=True)
过滤数据
我们也可以选择我们需要的特定数据。我们将使用一种最简单的方法 loc 和 iloc 来选择数据。
例如:
我们使用 loc 根据标签/索引来访问行和列。
df.loc[193]
Country Name Nepal
Male Height in Centimeter 164.36
Female Height in Cm 152.39
Male Height in Ft 5.39
Female Height in Ft 5
Name: 193, dtype: object
您还可以使用以下代码来可视化列。
df.loc[193, ['Country Name', 'Male Height in Centimeter','Female Height in Cm']]
Country Name Nepal
Male Height in Centimeter 164.36
Female Height in Cm 152.39
Name: 193, dtype: object
现在，如果你想看到身高在 17 厘米以上的男性人群，我们将在 loc 中添加一个条件。
df.loc[df['Male Height in Centimeter'] >= 170]
如果您只想选择第一行和第一列中的数据，您可以使用 iloc 。iloc 基于整数位置或布尔数组选择数据。
df.iloc[0,0]
'Netherlands'
您也可以选择整行。在本例中，我们访问了第 10 行。
df.iloc[10,:]
Country Name Ukraine
Male Height in Centimeter 180.98
Female Height in Cm 166.62
Male Height in Ft 5.94
Female Height in Ft 5.47
Name: 11, dtype: object
我们也可以选择整个列。在本例中，我们选择了最后一列。
df.iloc[:,-1]
Rank
1 5.59
2 5.58
3 5.53
4 5.49
5 5.54
...
195 5.10
196 5.15
197 5.14
198 5.02
199 5.01
Name: Female Height in Ft, Length: 199, dtype: float64
您也可以选择多行和多列。
df.iloc[100:199, 2:5]
在下一节中，我们将学习如何寻找丢失的数据。
使用缺失值
识别数据帧中缺失值的第一步是使用 isnull 函数。
df.isnull()
我们可以看到，输出是与原始数据帧具有相同维度的相同对象，数据集的每个元素都具有布尔值。
在这种情况下，丢失的值被认为是真的，否则它们将被认为是假的。在这种情况下，我们可以有把握地说，我们没有任何丢失的值。但是，我们将使用下面的命令对数据进行另一次质量检查。
df.isnull().sum()
Country Name 0
Male Height in Centimeter 0
Female Height in Cm 0
Male Height in Ft 0
Female Height in Ft 0
dtype: int64
让我们检查每列缺失值的比例。
df.isnull().sum() / df.shape[0]
Country Name 0.0
Male Height in Centimeter 0.0
Female Height in Cm 0.0
Male Height in Ft 0.0
Female Height in Ft 0.0
dtype: float64
我们可以看到，对于所有列，缺失值的比例为零。
绘制数据
这是任何数据分析项目中最重要的部分。在这一部分，我们将学习如何使用熊猫来可视化我们的数据。我们将使用 Pandas 中的情节功能来构建情节。
注意:还有许多其他 Python 库提供了更好的数据可视化。如果任何人想要更详细和详细的情节，他们可以使用 Matplotlib 和 Seaborn 库。
直方图有助于您快速了解和可视化数据集中数值变量的分布。直方图会将每个数值变量中的值划分到多个条块中，并对每个条块中的观察值总数进行计数。直方图有助于分布数据并获得关于数据的直接直觉。
在下面的例子中，我们为特征“男性身高(厘米)”绘制了直方图
df['Male Height in Centimeter'].plot(kind='hist')
你可以从直方图中看到，大多数 f 男性群体的身高为 175 cm 和 180cm。
散点图有助于您可视化两个变量之间的关系。该图建立在笛卡尔坐标上。散点图将值显示为点的集合，每个点表示一个变量的值，该变量表示 X 轴上的位置，另一个变量表示 Y 轴上的位置。
在以下示例中，我们构建了一个散点图来了解两个变量(即男性身高和女性身高)之间的关系。
df.plot(x='Male Height in Centimeter', y='Female Height in Cm', kind='scatter')
结论
在这篇文章中，我们学习了很多关于使用 Pandas 进行数据分析的知识，我认为这将有助于您理解如何使用 Pandas。如今，Pandas 是数据科学中广泛使用的工具，并在工作领域取代了 Excel。Pandas 以其简单的语法和灵活性使数据分析变得更加容易。希望你和熊猫玩得开心！
要知道的 4 个 Python 数据分析库！
原文：https://www.askpython.com/python/data-analytics-libraries
读者朋友们，你们好！在本文中，我们将详细关注 4 Python 数据分析库。
所以，让我们开始吧！！🙂
数据分析–快速概述！
在理解支持数据分析功能的 Python 库之前，理解数据分析的概念非常重要。
数据分析完全是数据科学和机器学习主要领域下的一个子领域。是的，在根据各种算法对数据建模之前，分析数据和清理数据非常重要。
对于分析数据，我们的意思是说，需要从分布、测量的统计分析以及数据的可视化方面来理解数据，以获得数据的清晰图像。
数据分析包括:
- 清理数据
- 了解数据值的分布
- 根据平均值、标准偏差等对数据进行统计分析。
- 数据值相对于统计度量的可视化。
- 格式化数据以便处理到模型中。
Python 数据分析库
Python 提供了大量支持数据分析概念的库。是的，Python 提供了大量的模块来执行数据值的预处理和分析。
在当前主题的背景下，我们将介绍以下用于执行数据分析相关任务的最常用 Python 库
- 【Scikit-学习库】
- Python OpenCV 库
- Python 熊猫模块
- Python PyBrain 库
1. Scikit-learn
Python Scikit-learn 库，开源库，是大多数数据科学或机器学习工程师进行数据分析的选择。该库提供了广泛的功能来有效地执行数据预处理和分析。
它实际上是基于 Python 的 NumPy、Matplotlib 和 SciPy 库构建的。Scikit-learn 库提供了一系列用于执行统计建模的算法，以及其他与机器学习相关的算法，例如
- 回归模型
- 统计数据处理
- 预处理功能
- 聚类模型
- 分类型号等。
它还包括各种监督 ML 以及非监督 ML 算法。
2.OpenCV
Python OpenCV (开源计算机视觉)是一种广泛用于数据分析的算法。有了 OpenCV，我们的数据分析不再局限于结构化数据。也就是说，有了 OpenCV，我们也可以对图像、图片和视频进行分析。
因此，OpenCV 支持以下内容
- 面部识别
- 物体识别
- 跟踪运动和移动性等。
我们可以利用 OpenCV 从待分析的数据中提取有意义的信息，还可以对数据值进行预测分析。
3.熊猫
Python Pandas 模块为我们提供了使用 Python 进行数据分析的不同功能。它是 Python 数据分析库的缩写。
有了 Pandas，我们可以轻松地对数据进行预处理，并根据各种参数进行分析，
- 极端值
- 缺失值分析等。
它基于 NumPy 库，这也让我们在数学运算上占了上风。Pandas 库使用名为 DataFrame 的数据结构，基本上将数据转换成表格格式，我们可以分析行和列形式的数据。
4.PyBrain
PyBrain 是基于 Python 的强化学习、人工智能和神经网络库的首字母缩写。PyBrain 的美妙之处在于，它支持预定义的环境来执行分析，并定义模型之间算法之间的关系。
它支持各种数据分析算法，以增强数据分析，并基于各种场景测试结果。
结论
到此，我们就结束了这个话题。如果你遇到任何问题，欢迎在下面评论。
更多与 Python 编程相关的帖子，请继续关注我们。
在那之前，学习愉快！！🙂
数据分析与数据科学
原文：https://www.askpython.com/python/data-analytics-vs-data-science
考虑从事数据方面的职业？您可能对数据分析和数据科学之间的区别感到好奇。
数据分析师和数据科学家的任务都是从数据中提取有价值的见解，但这两种角色在范围和功能上有所不同。数据科学家开发高级分析模型来挖掘巨大的数据湖，而数据分析师通常处理较小的数据集，并专注于直接咨询业务领导者。
要从事数据行业，你需要理论知识和应用技能。像 Springboard 的 Data Analytics Career Track 这样的项目可以通过实践、基于项目的学习和一对一的指导帮助你做好就业准备。想知道哪种数据职业道路适合你？请继续阅读，寻找答案。
数据分析师的角色
数据分析师与业务利益相关方合作，利用数据驱动的洞察力来识别组织痛点或业务问题。首先，数据分析师必须收集和清理他们的数据。通常，与数据科学家相比，数据分析师处理的数据量更小，更易于管理。数据分析师通常使用 SQL 将数据转移到电子表格或编程接口，如 Jupyter 笔记本。与数据科学家相反，数据分析师实施不太复杂的分析模型，这些模型由基本的监督学习或统计技术(如回归分析)驱动。
数据分析师通常专注于业务分析，业务分析可用于预算、预测、风险管理、营销、产品开发等任务。他们必须管理 SQL 数据库，进行 A/B 测试，并使用 data viz 工具向与他们密切合作的利益相关者传达见解。最重要的是，数据分析师需要利用技术技能来讲述非技术利益相关者可以轻松理解的可访问数据故事。
数据科学家的角色
数据科学家实施由机器学习和高级统计学驱动的分析技术来进行预测。数据科学家努力识别数据中的关键模式，并构建模型来建立数据对象之间的关系。数据科学家通常必须在云计算环境中清理、组织、转换、探索和建模大量非结构化数据集。
数据科学需要编程经验，因为数据科学家必须用 Python、R 和 SQL 等语言编写算法来分析大数据。编程技能对于自动化数据处理和收集也很重要。数据科学家还必须将他们的发现可视化，并以解决业务问题的方式进行解释。因此，数据科学存在于计算机科学、数学、统计学和商业智能的交叉点上。
关键数据分析技能
数据分析师需要熟悉基本的商业统计概念，包括描述性统计、相关性、回归和置信区间。精通金融和经济概念也是至关重要的。数据分析师必须能够使用 SQL 从数据库中提取数据，分析数据，并使用 Python 库(如 Seaborn 和 Matplotlib )将其可视化。
数据分析师还必须使用战略思维，将复杂的业务问题准确地解构为可测试的问题。数据分析必须围绕一个中心主题进行，结果必须以有形的、以行动为导向的方式进行，以增加业务价值。因为数据分析师经常与业务利益相关者密切合作，他们甚至可以帮助构建客户推介和业务绩效仪表板。在这些情况下，数据分析师必须能够使用 Microsoft Power BI 或 Tableau 等工具可视化数据。
关键数据科学技能
数据科学家对统计学有着透彻的掌握，并拥有强大的编程技能来操作数据、实施机器学习算法和进行高级统计分析。数据科学家也使用 SQL 来读取、检索和添加数据到数据库中。要处理大数据，需要精通 Hadoop、Spark 等工具。
机器学习也是一项关键的数据科学技能。数据科学家设计机器学习算法来争论和分析大数据——这意味着精通 TensorFlow 等工具至关重要。此外，数据科学家还必须能够可视化数据并构建仪表板，以便与团队成员和非技术利益相关者等进行交流。作为数据分析师，数据科学家还必须能够将他们的发现组织成有影响力的、连贯的叙述。
准备好开始你的数据生涯了吗？
如果你准备好开始你的数据职业生涯， Springboard 的数据分析职业轨道可以提供帮助。通过结合项目、案例研究等，您将学会分析业务问题、使用 SQL 连接数据、使用 Python 可视化数据，以及将您的分析传达给利益相关方。
此外，通过 50 多个小时的职业支持，你将学会瞄准哪些职位，以及如何建立你的人际网络并利用它获得面试机会。你还会得到简历辅导和模拟面试练习，这样你就可以在招聘经理面前大放异彩。
Python 中的数据缩放|标准化和规范化
原文：https://www.askpython.com/python/examples/data-scaling-in-python
我们已经读过一个关于数据预处理的故事。在这其中，也就是 的数据预处理、 的数据转换，或者说缩放是最关键的一步。你可能会想到它的重要性，因为无论何时你处理数据，它都包含不同尺度的多个变量和值。
Python 中的数据缩放
对于一个算法来说，为了发挥其最佳性能，数据应该在相同的范围内。谈到 python 中的数据缩放，我们得到了两个关键技术—标准化和规范化。
在这个故事中，让我们看看标准化和规范化技术如何应用于我们手中的数据。
导入数据
我们将在整个过程中使用游轮数据集。让我们导入数据，并尝试应用上面提到的缩放技术。
#Data
import pandas as pd
data = pd.read_csv('cruise_ship_data.csv')
Image 6
我们已经导入了游轮数据集。让我们更好地了解一些基本的数据统计。
#Data shape
data.shape
(158，9)
- 我们的数据包含 158 行和 9 个变量。
#data columns
data.columns
索引(['船舶名称'，'邮轮线路'，'年龄'，'吨位'，'乘客'，'长度'，'客舱'，'乘客密度'，'船员']，dtype= '对象')
- 这是数据中的变量列表。
#summary statistics
data.describe()
Image 7
- 汇总统计邮轮数据。
通过使用汇总统计数据，我们可以看到所有特性的值的范围或比例。例如，从上面的数据中，我们可以看到变量“Age”中的值位于【4，48】之间，变量“Crew”中的值位于【0，21】之间，以此类推。您可以观察到所有属性都有不同范围的值。
因此，我们需要使用数据标准化和规范化等数据转换技术来扩展数据。让我们看看我们能做些什么。
1.Python 数据缩放–标准化
数据标准化是我们将所有数据置于同一尺度下的过程。这将有助于我们分析并将数据输入到模型中。
Image 9
这是数据标准化过程背后的数学原理。
在计算数据的标准化值之前，我们需要安装 sklearn 库。您可以运行下面的代码来 pip 安装 scikit-learn 库。
#install scikit learn
pip install scikit-learn
#import pandas
import pandas as pd
#import numpy
import numpy as np
#import seaborn
import seaborn as sns
#import matplotplib
import matplotlib.pyplot as plt
嗯，我们都很喜欢我们的图书馆。现在，让我们标准化数据中的值。为此，我们将遵循一个流程或一些步骤。
#define the columns
cols = ['Age', 'Tonnage', 'passengers', 'length',
'cabins','passenger_density','crew']
#Call the sklearn librart and import scaler values
from sklearn.preprocessing import StandardScaler
#call the standard scaler
std_scaler = StandardScaler()
#fit the values to the function
Stand_Sc = std_scaler.fit_transform(data[cols].iloc[:,range(0,7)].values)
#use seaborn for KDE plot
sns.kdeplot(Stand_Sc[:,5],fill=True, color = 'Green')
#Label the plot
plt.xlabel('standardized values - Passenger density')
#Print the plot
plt.show()
这里-
- 我们已经定义了列，并从 sklearn 库中导入了标准缩放器。
- 我们将数据(定义的列)拟合到定标器。
- 创建了一个 KDE(核密度估计)图。
- 标为图的轴。输出图将如下所示
Image 10
推论
如果取近似值，数据位于-3 到 3 的刻度之间。您也可以说这些值距离平均值(0)有 3 个标准偏差。
2.Python 数据缩放–标准化
数据标准化是标准化数据的过程，即通过避免数据的偏斜。一般来说，归一化的数据将呈钟形曲线。
这也是维护数据质量和可维护性的标准过程。数据标准化有助于细分过程。
下面是归一化公式，供你参考。
在上面的部分中，我们已经标准化了数据。类似地，使用 sklearn 规格化器，我们可以规格化数据中的值。
确保您的列与前一列相同。
#Import Normalizer from sklearn
from sklearn.preprocessing import Normalizer
#initialize normalizer
data_norm = Normalizer()
#Fit the data
Normalize = data_norm.fit_transform(data[cols].iloc[:,range(0,7)].values)
#Distribution plot
sns.displot(Normalize[:,5],fill=True, color = 'orange')
#Add the axis labels
plt.xlabel('normalized values - passenger density')
#Display the plot
plt.show()
这里-
- 我们在标准化过程中使用了相同的数据，即变量。
- 从 sklearn 库中导入了规格化器。
- 使用 seaborn 和 display plot 绘制分布图。
Image 11
我们也可以在这个情节中加入 KDE 元素。这将增加更多的可读性，也更容易消化信息。
这可以通过添加参数–kde = True 来实现
#Import Normalizer from sklearn
from sklearn.preprocessing import Normalizer
#initialize normalizer
data_norm = Normalizer()
#Fit the data
Normalize = data_norm.fit_transform(data[cols].iloc[:,range(0,7)].values)
#Distribution plot
#sns.displot(Normalize[:,5],fill=True, color = 'orange')
sns.displot(Normalize[:,5],fill=True, color = 'orange', kde=True)
#Add the axis labels
plt.xlabel('normalized values - passenger density')
#Display the plot
plt.show()
Image 12
推论——
在这里，你可以观察到数值在-1 到 1 的范围内。
数据扩展–关键点
- 数据标准化是最常用的过程，因为它提供了多种好处。
- 您也可以使用标准化来检测异常值。范围-2 到 2 之外的任何值都可以被视为异常值。
- 最后，数据转换有助于避免偏差并提高模型准确性。
数据缩放–结论
python 中的数据缩放是建模前必须遵循的基本流程。相似范围内的数据可以令人惊讶地提高模型的预测能力。这个故事关注两种主要的数据扩展技术，即标准化和规范化。我希望这将有助于以一种简单的方式更好地理解缩放。
目前就这些。快乐的蟒蛇！！！😛
更多阅读: 数据归一化
要知道的 5 个 Python 数据科学库！
原文：https://www.askpython.com/python-modules/data-science-libraries
读者朋友们，你们好！在本文中，我们将详细关注 5 Python 数据科学库。
所以，让我们开始吧！！🙂
为什么使用 Python 数据科学库？
Python 是一种强大的编程语言，它为我们提供了大量面对模块的不同功能。
特别关注数据科学领域，python 是最合适的工具之一，原因如下
- 为各种数据科学任务提供服务的内置库。
- 各种开发模块可供使用。
- 出色的内存管理功能。
- 复杂任务处理算法。
牢记以上优点，Python 可以作为处理和解决数据科学问题的强大工具。
它包含各种模块来解决数学计算问题和处理数据值。
在该主题的背景下，我们将了解以下模块，它们为数据科学提供了强有力的支持
1.熊猫图书馆
Python Pandas 模块可以认为是数据科学领域中数据分析的关键项目之一。在解决任何与数据科学相关的问题时，主要任务是清理和处理数据，并使其可用于建模。
Pandas 模块提供了一个名为 DataFrame 的数据结构，它以行和列的形式表示数据。它还为我们提供了一系列数据结构来构建数据以供分析。
熊猫可以被认为是当今最强大的数据分析模块之一。它为我们提供了内置的功能来执行基本的数据清理，如缺失值分析、异常值分析等。它还支持数据列的合并，以提高性能。
2.数字图书馆
Python NumPy 模块是几乎所有其他库的基础，尤其是在数学计算方面。它为数据值的统计分析启用并支持强大的数学计算。
数学计算是 NumPy 模块提供的统计分析的基础。它为我们提供了多维数组来处理统计数据。它还为我们提供了各种内置函数来执行数据清理和计算。
NumPy 还支持互操作性。
3.科学图书馆
Python SciPy 库主要构建在 NumPy 库之上。它完成了大部分与数据建模相关的高级计算。SciPy 库帮助我们实现数据的统计分析、代数计算、算法优化等。
有了 SciPy，我们甚至可以对它进行并行计算。它包含回归、概率等数据科学操作的函数。
简而言之，所有关于统计、建模和代数的高级计算都可以由 SciPy 模块轻松完成。
4.Matplotlib 库
有了数据分析和建模，就有了可视化。数据可视化是数据科学中最强的概念之一。它为分析提供了一个界面，使数据易于理解。
Python Matplotlib 模块为我们提供了各种将数据可视化的功能。它使我们能够通过 Python 脚本创建二维/三维图形和结构。
它为直方图、条形图、等高线图等图形提供了广泛的结构。
结论
到此，我们就结束了这个话题。如果你遇到任何问题，欢迎在下面评论。
更多与 Python 编程相关的帖子，请继续关注我们。
在那之前，学习愉快！！🙂
Python 中的 6 个简单数据科学项目
您是否曾经被互联网上出现的大量数据科学概念和项目淹没，不知道从哪里开始？如果您曾经有过这样的感觉，不要担心，您来对地方了，因为我们已经为您提供了保障。
学习 Python 的 6 个有趣的数据科学项目
我们知道数据科学是一个新兴领域，互联网上有无限的数据科学内容。但我们也知道，数据科学的初学者希望从零开始，这就是为什么在本文中，我们编译了一些初级水平的数据科学项目以及一些稍微高级一点的项目。让我们开始您的数据科学之旅吧！
1.乳腺癌分类
乳腺癌是女性中最常见和最普遍的癌症之一。在过去的几十年里，机器学习技术已经广泛用于医疗保健应用，尤其是乳腺癌诊断和预后。
众所周知，癌症的早期检测可以帮助患者及时得到适当的治疗，也可以增加他们的生存机会。此外，正确识别肿瘤类型可以防止患者经历无效的治疗过程。
对于这种类型的分类项目，您可以利用机器学习中的朴素贝叶斯算法。您可以使用 Scikit-learn 提供的乳腺癌数据集，也可以使用 Kaggle 的数据集进行乳腺癌分类。
注意:为了评估您的模型的性能，您需要在不可见的数据上测试模型。按照 80:20 的比例拆分数据集，以创建定型集和测试集。您可以使用 Scikit-learn 中的 accuracy_score()函数来检查模型的准确性。
数据:https://www . ka ggle . com/niteshyadav 3103/乳腺癌-分类
2.汽车价格预测
您可以使用 PyTorch 的线性回归模型创建汽车价格预测模型。PyTorch 是 python 中一个非常灵活的库，用于构建深度学习模型。这个项目将帮助你强化你建立深度学习模型的概念。
在开始构建模型之前，请确保清理数据集，这意味着过滤数据并删除对预测影响不大的列。此外，请记住，对于此项目，您将使用 PyTorch，因此为了使用数据进行训练，您需要将数据框转换为 PyTorch 传感器。
为此，首先，应该将输入和输出列转换为 NumPy 数组，然后将 NumPy 数组转换为 PyTorch 张量。之后，您可以继续使用 PyTorch 构建线性回归模型。
数据:https://www . ka ggle . com/goyalshalini 93/car-price-prediction-linear-regression-rfe
3.假新闻检测
这年头网上到处都是假新闻。如今，不计其数的新闻媒体和新闻机构已经开业，而且由于互联网的便捷性，这些媒体机构发布假新闻变得更加容易。假新闻检测模型可以帮助我们检测假新闻，并将其从互联网上删除。
这个项目可以使用逻辑回归模型。您可以使用逻辑回归算法来训练和测试您的模型。作为数据清理的一部分，删除丢失的值并将所有文本合并在一起。
数据:https://www.kaggle.com/therealsampat/fake-news-detection
4.具有机器学习的聊天机器人
你知道你可以用机器学习来制作你自己的聊天机器人吗？多酷啊！您可以为此下载数据集，也可以创建自己的数据集。取决于你想在哪个领域构建你的聊天机器人，你首先需要理解你的聊天机器人的意图，并基于这些意图来训练你的数据。
为了制作自己的数据集，你必须了解用户的意图，或者用户可能如何与聊天机器人交互，或者用户可能会问聊天机器人什么问题。
聊天机器人要想继续回答用户的问题，理解用户在这些信息背后的真实意图是至关重要的。在这里你必须运用一点策略。您必须创建不同的意图，并为每个意图创建训练样本。然后，您的聊天机器人模型将根据您创建的样本训练数据进行训练。
5.空气质量指数分析
政府机构经常使用空气质量指数来指示空气污染水平或由于空气中的颗粒物质而可能存在的健康风险。它的范围是 0-500。AQI 值小于或等于 100 被视为良好。
AQI 中有六个类别来表示不同类别的健康问题。对于这个项目，你需要首先想象和理解 AQI 中每种颜色的意义。颜色表示每个地区的空气质量及其危害程度。虽然这个项目有点超前，但它将为您的数据科学之旅增加额外的优势。
数据:https://www . ka ggle . com/piumallick/air-pollution-analysis-on-air-quality-index
6.Python 中的情感分析
情感分析是一种通过分析一段文本来理解隐藏在其中的情感的方法。换句话说，它允许你决定一段文字的感受。在这个过程中，您将同时使用机器学习和 NLP 技术。对于这个项目，您需要构建一个二进制文本分类器来理解其背后的情感。自然语言处理技术将被用来清理数据和建立 LSTM 层的文本分类器。
数据:https://www . ka ggle . com/ngy ptr/python-nltk-情操-分析/数据
获得许多有趣的真实世界数据科学项目的实际工作经验，如销售增长仪表板、房地产投资等。，你可以加入一个数据科学训练营。
该训练营由行业专家在所有项目中提供完整的指导。这些项目可以帮助你的投资组合从竞争中脱颖而出，也可以为你提供行业曝光率。
结论:
在本文中，您了解了 python 中一些潜在的数据科学项目，这些项目将有助于提升您的数据科学组合和数据科学知识。用所提供的数据集完成这些项目，并尝试分析结果，从数据中获得洞察力。
Python 中的数据结构
原文：https://www.askpython.com/python/data-structures-in-python
在任何编程语言中，我们都需要处理数据。现在，我们需要处理数据的最基本的事情之一是以一种有组织的方式有效地存储、管理和访问数据，以便可以随时根据我们的需要使用数据。数据结构被用来满足我们所有的需求。
什么是数据结构？
数据结构是编程语言的基本构件。它旨在提供一种系统的方法来满足本文前面提到的所有需求。Python 中的数据结构有列表、元组、字典、集合。它们被视为 Python 中的隐式或内置数据结构。我们可以使用这些数据结构并对其应用多种方法来管理、关联、操作和利用我们的数据。
我们还有自定义的数据结构，即自定义的即 栈、队列、树、链表和图 。它们允许用户完全控制其功能，并将其用于高级编程目的。然而，对于本文，我们将关注内置的数据结构。
Implicit Data Structures Python
目录
列表帮助我们以多种数据类型顺序存储数据。它们类似于数组，只是它们可以同时存储不同的数据类型，如字符串和数字。列表中的每个项目或元素都有一个指定的索引。由于 Python 使用基于 0 的索引，第一个元素的索引为 0，计数继续进行。列表的最后一个元素从-1 开始，可以用来访问从最后一个到第一个的元素。要创建一个列表，我们必须将项目写在方括号内。
关于列表要记住的最重要的事情之一是它们是可变的。这仅仅意味着我们可以通过使用索引操作符作为赋值语句的一部分直接访问列表中的元素来改变它。我们还可以在我们的列表上执行操作来获得想要的输出。让我们浏览一下代码，以便更好地理解列表和列表操作。
1。创建列表
#creating the list
my_list = ['p', 'r', 'o', 'b', 'e']
print(my_list)
输出
['p', 'r', 'o', 'b', 'e']
2。从列表中访问项目
#accessing the list
#accessing the first item of the list
my_list[0]
输出
'p'
#accessing the third item of the list
my_list[2]
'o'
3。向列表添加新项目
#adding item to the list
my_list + ['k']
输出
['p', 'r', 'o', 'b', 'e', 'k']
4。移除项目
#removing item from the list
#Method 1:
#Deleting list items
my_list = ['p', 'r', 'o', 'b', 'l', 'e', 'm']
# delete one item
del my_list[2]
print(my_list)
# delete multiple items
del my_list[1:5]
print(my_list)
输出
['p', 'r', 'b', 'l', 'e', 'm']
['p', 'm']
#Method 2:
#with remove fucntion
my_list = ['p','r','o','k','l','y','m']
my_list.remove('p')
print(my_list)
#Method 3:
#with pop function
print(my_list.pop(1))
# Output: ['r', 'k', 'l', 'y', 'm']
print(my_list)
输出
['r', 'o', 'k', 'l', 'y', 'm']
o
['r', 'k', 'l', 'y', 'm']
5。排序列表
#sorting of list in ascending order
my_list.sort()
print(my_list)
输出
['k', 'l', 'm', 'r', 'y']
#sorting of list in descending order
my_list.sort(reverse=True)
print(my_list)
输出
['y', 'r', 'm', 'l', 'k']
6。查找列表的长度
#finding the length of list
len(my_list)
输出
5
元组
元组与列表非常相似，关键区别在于元组是不可变的，不像列表。一旦我们创建了一个元组或者拥有了一个元组，我们就不允许改变其中的元素。然而，如果我们在一个元组中有一个元素，它本身就是一个列表，只有这样我们才能在这个列表中访问或更改。为了创建一个元组，我们必须在括号中写入条目。像列表一样，我们也有类似的方法可以用于元组。让我们通过一些代码片段来理解使用元组。
1。创建元组
#creating of tuple
my_tuple = ("apple", "banana", "guava")
print(my_tuple)
输出
('apple', 'banana', 'guava')
2。从元组中访问项目
#accessing first element in tuple
my_tuple[1]
输出
'banana'
3。元组的长度
#for finding the lenght of tuple
len(my_tuple)
输出
3
4。将元组转换为列表
#converting tuple into a list
my_tuple_list = list(my_tuple)
type(my_tuple_list)
输出
list
5。反转一个元组
#Reversing a tuple
tuple(sorted(my_tuple, reverse=True))
输出
('guava', 'banana', 'apple')
6。对元组进行排序
#sorting tuple in ascending order
tuple(sorted(my_tuple))
输出
('apple', 'banana', 'guava')
7。从元组中移除元素
为了从元组中删除元素，我们首先将元组转换为一个列表，就像我们在上面的一个方法中所做的那样(第 4 点)，然后遵循列表的相同过程，并显式删除整个元组，只需使用del 语句。
词典
Dictionary 是一个集合，简单地说就是用来存储带有某个键的值，并提取给定键的值。我们可以将其视为一组键:值对和字典中的每个键都应该是唯一的，这样我们就可以相应地访问相应的值。
使用包含键:值对的花括号{ } 来表示字典。字典中的每一对都用逗号分隔。字典中的元素是无序的当我们访问或存储它们时，顺序并不重要。
它们是可变的，这意味着我们可以在字典中添加、删除或更新元素。下面是一些代码示例，以便更好地理解 python 中的字典。
需要注意的重要一点是，我们不能使用可变对象作为字典中的键。因此，列表不允许作为字典中的键。
1。创建字典
#creating a dictionary
my_dict = {
1:'Delhi',
2:'Patna',
3:'Bangalore'
}
print(my_dict)
Output
{1: 'Delhi', 2: 'Patna', 3: 'Bangalore'}
这里，整数是字典的键，与整数相关的城市名是字典的值。
2。从字典中访问项目
#access an item
print(my_dict[1])
输出
'Delhi'
3。字典的长度
#length of the dictionary
len(my_dict)
输出
3
4。整理字典
#sorting based on the key
Print(sorted(my_dict.items()))
#sorting based on the values of dictionary
print(sorted(my_dict.values()))
输出
[(1, 'Delhi'), (2, 'Bangalore'), (3, 'Patna')]
['Bangalore', 'Delhi', 'Patna']
5。 在字典中添加元素
#adding a new item in dictionary
my_dict[4] = 'Lucknow'
print(my_dict)
输出
{1: 'Delhi', 2: 'Patna', 3: 'Bangalore', 4: 'Lucknow'}
6。从字典中删除元素
#for deleting an item from dict using the specific key
my_dict.pop(4)
print(my_dict)
#for deleting last item from the list
my_dict.popitem()
#for clearing the dictionary
my_dict.clear()
print(my_dict)
输出
{1: 'Delhi', 2: 'Patna', 3: 'Bangalore'}
(3, 'Bangalore')
{}
设置
Set 是 python 中的另一种数据类型，它是一个没有重复元素的无序集合。集合的常见用例是删除重复值和执行成员测试。花括号或 set() 功能可用于创建集合。需要记住的一点是，在创建空集时，我们必须使用 set()、和 not { }。后者创建一个空字典。
下面是一些代码示例，以便更好地理解 python 中的集合。
1。创建一个 集合
#creating set
my_set = {"apple", "mango", "strawberry", "apple"}
print(my_set)
输出
{'apple', 'strawberry', 'mango'}
2。从集合中访问项目
#to test for an element inside the set
"apple" in my_set
输出
True
3。集合长度
print(len(my_set))
输出
3
4。对器械包进行分类
print(sorted(my_set))
输出
['apple', 'mango', 'strawberry']
5。 在集合中添加元素
my_set.add("guava")
print(my_set)
输出
{'apple', 'guava', 'mango', 'strawberry'}
6。从集合中移除元素
my_set.remove("mango")
print(my_set)
输出
{'apple', 'guava', 'strawberry'}
结论
在本文中，我们介绍了 python 中最常用的数据结构，也看到了与它们相关的各种方法。
进一步阅读
参考
请查看 Python 数据结构的官方文档，其中包含了关于 Python 数据结构的详尽信息。
使用 Python Bokeh 的数据可视化
原文：https://www.askpython.com/python-modules/data-visualization-using-python-bokeh
在本文中，我们将研究使用 Python 散景的数据可视化。
Bokeh 允许用户接收任何格式的数据，如 CSV、JSON、硬编码数据或数据库。我们可以使用这个库创建散点图、折线图等。它在业内被广泛用于股票市场分析，因为它非常容易与不同的 web 框架(如 JS、Django 和 HTML)集成。
请继续阅读这篇文章，了解散景的用法
Python 散景的特性
- 交互:Bokeh 是一个非常具有交互性的库，除了静态绘图之外，它还提供了图形交互的功能。
- 强大的库:Bokeh 是一个强大的库，因为它允许为用例添加 JavaScript。
- 可移植性:散景图的输出可以在任何 web 框架上呈现，比如 Django 和 Python，也可以在 Jupyter 笔记本上呈现。
- 灵活:易于绘制定制和复杂的用例。
- 与其他流行工具的交互:允许与 pydata 工具轻松交互，如 Pandas 和 Jupyter notebook。
Bokeh Is Interactive
使用 Python 散景从数据可视化开始
每当我们使用 python 做任何事情时，创建一个虚拟环境是一个很好的实践，最好的方法是运行命令pip install pipenv。一旦你运行这个命令，你就可以访问pipenv命令，并且可以运行pipenv shell。这确保了虚拟环境的设置。
现在可以使用虚拟环境安装散景和 Python 熊猫。您可以使用以下命令:
pipenv install bokeh pandas
我们将使用 pandas，因为这个库允许我们以数据帧的形式读取 CSV 文件。
1.绘制线图
在从 CSV 文件开始绘制图表之前，我们将带您浏览绘制简单折线图的过程，让您熟悉散景。
from bokeh.plotting import figure, output_file, show
figure模块将帮助用户创建地块。output_file将定义要生成的 HTML 文件的名称。show模块将生成并显示 HTML 文件。
x=[1,2,3,4,5]
y=[4,3,3,5,4]
对于数据，我们只创建两个列表-[1，2，3，4，5]和[4，3，3，5，4]。
这些点有(1，4)，(2，3)，(3，3)，等等。
output_file('index.html')
我们使用上面的代码将输出文件设置为index.html。
p = figure(
title = 'Example chart',
x_axis_label = 'X axis',
y_axis_label = 'Y axis'
)
我们使用图()来创建情节。数字()包含多个属性。有关详细信息，您可以参考本模块的文档。
我们将使用title、x_axis_label和y_axis_label。
p.line(x, y, legend="test", line_width=1.5)
现在来渲染字形，我们将使用上面的代码片段。我们指定前面定义的两个列表x和y。我们还指定了其他参数，如legend和line_width。
请注意，这里使用这些参数是因为我们使用的是line图。对于其他类型的图表，这些参数往往会有所不同。
show(p)
我们使用show()函数显示结果，结果显示在index.html上，如下所示。还附上了完整的代码。
from bokeh.plotting import figure, output_file, show
x=[1,2,3,4,5]
y=[4,3,3,5,4]
# defining the output file
output_file('index.html')
# Adding the plot
p = figure(
title = 'Example chart',
x_axis_label = 'X axis',
y_axis_label = 'Y axis'
)
# Rendering the graph
p.line(x, y, legend="test", line_width=1.5)
# Display the results
show(p)
Output Chart Shown On index.html
2.从 CSV 文件绘制图形
为了绘制图表，我们将使用一个简单的汽车数据集，它有两列，即汽车名称和马力。我们将使用图表来理解这些参数之间的相关性。数据集如下所示
Dataset
可以使用散景将上述数据集绘制成直方图(hbar ),其代码如下:
from bokeh.plotting import figure, output_file, show, save, ColumnDataSource
from bokeh.models.tools import HoverTool
from bokeh.transform import factor_cmap
from bokeh.palettes import Blues8
from bokeh.embed import components
import pandas
df = pandas.read_csv('cars.csv')
source = ColumnDataSource(df)
output_file('index.html')
car_list = source.data['Car'].tolist()
# Add plot
p = figure(
y_range=car_list,
plot_width=800,
plot_height=600,
title='Cars With Top Horsepower',
x_axis_label='Horsepower',
tools="pan,box_select,zoom_in,zoom_out,save,reset"
)
# Render glyph
p.hbar(
y='Car',
right='Horsepower',
left=0,
height=0.4,
fill_color=factor_cmap(
'Car',
palette=Blues8,
factors=car_list
),
fill_alpha=0.9,
source=source,
legend='Car'
)
# Add Legend
p.legend.orientation = 'vertical'
p.legend.location = 'top_right'
p.legend.label_text_font_size = '10px'
# Show results
show(p)
在index.html上呈现的输出如下:
Graph Output
结论
因此，我们来到这篇文章的结尾。Bokeh 是一个强大的数据可视化库，可以用于所有项目。一定要试试这篇文章中的例子，并在下面的评论区告诉我们你的感受。
使用 Streamlit 实现数据可视化——完整指南
原文：https://www.askpython.com/python-modules/data-visualization-using-streamlit
数据可视化是以图形格式表示数据。这有助于我们更好、更容易地理解数据。数据可视化可以在图表、图形、地图等视觉元素的帮助下进行。
在本教程中，我们将学习如何使用 Streamlit 绘制不同的图表。让我们开始吧！
亦读:细流简介
细流中的折线图
它是通过将一系列数据点连接成一条连续的线而执行的信息的图形表示。它是数据可视化技术的最简单形式之一。
import streamlit as st
import pandas as pd
st.header("Line Chart")
data = {"a":[23, 12, 78, 4, 54], "b":[0, 13 ,88, 1, 3],
"c":[45, 2, 546, 67, 56]}
df = pd.DataFrame(data)
df
st.line_chart(data=df)
输出:
Streamlit Line Chart
在这里，我们采用了一些任意数据，首先使用熊猫库创建了一个数据框，然后使用line_chart函数绘制了图表。我们还在绘制图表之前显示了数据框，以便快速参考。
也读:使用 Streamlit 的计算器 App 简单的分步方法
细流中的条形图
条形图以垂直或水平矩形条的形式表示数据。每个条形的高度与其代表的值成比例。Streamlit 提供了一个bar_chart函数来绘制数据可视化条形图。
import streamlit as st
import pandas as pd
st.header("Bar Chart")
data = {"a":[23, 12, 78, 4, 54], "b":[0, 13 ,88, 1, 3],
"c":[45, 2, 546, 67, 56]}
df = pd.DataFrame(data)
df
st.bar_chart(data=df)
输出:
Streamlit Bar Chart
由于数据框包含 5 行，因此输出中的每一行都有对应的条形。这些条形包含特定行中每列值的分布，并且每列用不同的颜色表示。
也读作:使用 Streamlit 部署机器学习模型——房价预测 GUI
Streamlit 中的面积图
面积图是折线图和条形图的组合。数据点被绘制出来，然后用线连接起来。然后，线下面的区域被着色。类似地，也绘制其他值，然后给该区域着色，得到分层图表。我们可以使用 Streamlit 的area_chart函数绘制这样一个图表。
import streamlit as st
import pandas as pd
st.header("Area Chart")
data = {"a":[23, 12, 78, 4, 54], "b":[0, 13 ,88, 51, 3],
"c":[45, 2, 46, 67, 56]}
df = pd.DataFrame(data)
df
st.area_chart(df)
输出:
Streamlit Area Chart
这里，数据框中每列的区域用不同的颜色表示，如上图所示。根据所提供的数据，有些领域也有重叠。
也可以理解为:Streamlit 中的主题化——定制 Streamlit 应用外观的两种方法
细流中的地图
作为数据可视化的一部分，我们还可以在 Streamlit web 应用程序中显示地图。Streamlit 中的map功能可以帮助您显示上面有数据点的地图。我们可以使用列名“lat”或“latitude”来表示纬度，使用“lon”或“longitude”来表示经度。需要将这些列添加到要绘制的数据中以绘制地图。
import streamlit as st
import pandas as pd
st.header("Map")
data = {"lat":[28.704060, 28.459497, 13.082680, 17.385044, 23.0225],
"lon":[77.102493, 77.026634, 80.270721, 78.486671, 72.5714],
"City": ["Delhi", "Gurgaon", "Chennai", "Hyderabad", "Ahemdabad"]}
df = pd.DataFrame(data)
df
st.map(data=df)
输出:
Streamlit Map Data
Streamlit Map
此示例中的数据包含印度一些城市的位置，如上图所示。这张地图用红点标出了这些特定的城市。在这里，当我们运行 Streamlit 应用程序时，地图也可以放大和缩小。
请注意，Streamlit 允许我们将这些图表保存为“SVG”或“PNG ”,并使用 Vega 编辑器进行编辑。此外，所有的视觉元素也可以放大和缩小。
结论
仅此而已！我们已经学习了如何使用 Python 和 Streamlit 执行数据可视化。使用 Streamlit 的另一种数据可视化方式是使用 Python 库，如 Matplotlib 、 Plotly 、 Bokeh 等。你可以在同一个网站上查看我们的教程来了解它们。
参考
在 Pandas 中显示 HTML 格式的数据框
原文：https://www.askpython.com/python-modules/pandas/dataframe-in-html
在本文中，我们将讨论熊猫模块中的一些核心功能。如果一些数据科学爱好者正在阅读这篇文章，那么他们这次得到了一篇易于阅读的文章。但是，那些不熟悉 Python 和 Pandas 的人需要一些关于这个 Python 包的核心知识。
开始在 HTML 中显示熊猫数据框架
我们的任务是学习如何将一个基本的数据帧转换成 HTML 格式。我们将在本文中介绍以下步骤:
- 在 Pandas 中创建/导入基本数据框。
- 打印它的信息。
- 将其转换成 HTML 格式。
- 如何处理这种格式？
- 如何在浏览器中查看？
1.在 Pandas 中创建基本数据框
Pandas 中的数据框是相互连接的数据元素的表格表示。一个方面的变化反映在另一方面。因此，要创建它，我们需要将一个 Python 字典传递给 pd。DataFrame()函数和我们的工作便于进一步处理。
import pandas as pd
data_dict = {'Name':['Ramesh', 'Suresh', 'Rajeev', 'Neha', 'Aditi'],
'Roll_nos':[1, 2, 3, 4, 5],
'Division':['A', 'B', 'C', 'D', 'E'],
'Percentages':[82, 76, 91, 95, 89]
}
data = pd.DataFrame(data_dict)
data
Creates a basic dataframe that holds student data
代码解释:
- 导入熊猫模块
- 创建一个包含 4 列的简单 Python 字典:
- 名字
- 卷号
- 分开
- 百分率
- 将字典传递给 DataFrame()函数。给它分配一个变量作为数据。
- 然后调用这个变量，它会以表格格式打印出来。
2.打印基本信息
然后试着打印这个数据框的基本信息。这对于使用 dataframe.describe 方法来说很简单。
data.columns # displays a list of columns in the data frame
data.info() # displays the basic info related to data frame
data.describe() # describes the basic statistical data
Displaying the basic info of the data frame
2.将其转换为 HTML 格式
Pandas 模块有一个 HTML 函数，可以在相应的代码中传递给定的数据帧。这个函数的名字是 to_html() 。这个函数的主要优先级是我们需要使用点(' . '来调用它)运算符与我们各自的数据框名称。 举例:data frame . to _ html()。让我们把这一点也应用到我们的问题上。
data_html = data.to_html()
print(data_html)
代码解释:
- 创建 data_html 变量。在这个过程中，调用与我们的数据帧相关的 to_html 函数。
- 称之为变量。
这会生成以下 HTML 格式的代码:
<table border="1" class="dataframe">
<thead>
<tr style="text-align: right;">
<th></th>
<th>Name</th>
<th>Roll_nos</th>
<th>Division</th>
<th>Percentages</th>
</tr>
</thead>
<tbody>
<tr>
<th>0</th>
<td>Ramesh</td>
<td>1</td>
<td>A</td>
<td>82</td>
</tr>
<tr>
<th>1</th>
<td>Suresh</td>
<td>2</td>
<td>B</td>
<td>76</td>
</tr>
<tr>
<th>2</th>
<td>Rajeev</td>
<td>3</td>
<td>C</td>
<td>91</td>
</tr>
<tr>
<th>3</th>
<td>Neha</td>
<td>4</td>
<td>D</td>
<td>95</td>
</tr>
<tr>
<th>4</th>
<td>Aditi</td>
<td>5</td>
<td>E</td>
<td>89</td>
</tr>
</tbody>
</table>
因此，我们已经成功地将我们的熊猫数据帧转换为 HTML 格式。
4.如何处理这种格式？
现在可能会出现一个问题，这种格式有什么用。
我们可以将它插入我们的网页或任何我们想显示目录的网站。
事实上，任何想要以表格形式显示部分数据的人都不需要创建这么大的 HTML 代码。他只需用 Python 写几行代码，他的工作就结束了。
5.如何在浏览器中查看？
这是 HTML 代码，所以我们需要知道它的输出是什么。所以，我们可以让事情变得更简单。
- 将这段代码复制并粘贴到原始文档中，并将扩展名保存为。html 。
- 然后在你喜欢的浏览器中打开它。
- 这是输出:
Pandas To HTML
这样，我们网站的表格就准备好了。
结论
就是它！我希望你通过这篇文章学到了一些有趣的概念。现在就开始探索，让我们知道你的想法！
https://www . ask python . com/python-modules/pandas/read-text-file-pandas https://www . ask python . com/python-modules/pandas/pandas-shape-attribute
熊猫数据帧索引:设置熊猫数据帧的索引
原文：https://www.askpython.com/python-modules/pandas/dataframe-indexing
读者你好！在本教程中，我们将讨论在 Python 中设置熊猫 DataFrame 对象索引的不同方法。
我们所说的熊猫数据框架的索引是什么意思？
在 Python 中，当我们使用在 Pandas 模块中自动(默认)定义的pd.DataFrame()函数创建一个 Pandas 数据帧对象时，会生成行索引和列索引形式的地址，以表示数据帧中被称为索引的每个数据元素/点。
但是，行索引称为数据帧的索引，列索引简称为列。Pandas DataFrame 对象的索引唯一地标识它的行。让我们开始关于在 Python 中设置 Pandas DataFrame 对象的索引的不同方法的核心讨论。
创建时设置数据帧的索引
在 Python 中，我们可以在使用index参数创建数据帧时设置它的索引。在这个方法中，我们创建一个 Python 列表，并将其传递给其索引的pd.DataFrame()函数的index参数。让我们通过 Python 代码来实现这一点。
# Import Pandas module
import pandas as pd
# Create a Python dictionary
data = {'Name': ['Rajan', 'Raman', 'Deepak', 'David', 'Shivam'],
'Marks': [93, 88, 95, 75, 99],
'City': ['Agra', 'Pune', 'Delhi', 'Sivan', 'Delhi']}
# Create a Python list of Roll NOs
Roll = [11, 12, 13, 14, 15]
# Create a DataFrame from the dictionary
# and set Roll column as the index
# using DataFrame() function with index parameter
df = pd.DataFrame(data, index = Roll)
print(df)
输出:
使用现有列设置数据帧的索引
在 Python 中，我们可以通过以下方式轻松地将 Pandas DataFrame 对象的任何现有列设置为其索引。
1.将列设置为索引(不保留列)
在这个方法中，我们将使用inplace参数，它是 Python Pandas 模块的set_index()函数的可选参数。默认情况下，inplace参数的值为False。但是这里我们将把inplace的值设为True。以便数据帧的旧索引被现有列替换，该列已作为新索引传递给pd.set_index()函数。让我们通过 Python 代码来实现这一点。
# Import Pandas module
import pandas as pd
# Create a Python dictionary
data = {'Name': ['Rajan', 'Raman', 'Deepak', 'David'],
'Roll': [11, 12, 13, 14],
'Marks': [93, 88, 95, 75]}
# Create a DataFrame from the dictionary
df = pd.DataFrame(data)
print("\nThis is the initial DataFrame:")
print(df)
# Set the Roll column as the index
# using set_index() function
df = df.set_index('Roll')
print("\nThis is the final DataFrame:")
print(df)
输出:
2.将列设置为索引(保留该列)
在这个方法中，我们将使用drop参数，它是 Python Pandas 模块的set_index()函数的可选参数。默认情况下，drop参数的值为True。但是这里我们将把drop参数的值设置为False。以便已被设置为新索引的列不会从数据帧中删除。让我们通过 Python 代码来实现这一点。
# Import Pandas module
import pandas as pd
# Create a Python dictionary
data = {'Roll': [111, 112, 113, 114],
'Name': ['Rajan', 'Raman', 'Deepak', 'David'],
'Marks': [93, 88, 95, 75]}
# Create a DataFrame from the dictionary
df = pd.DataFrame(data)
print("\nThis is the initial DataFrame:")
print(df)
# Set the Name column as the index
# using set_index() function with drop
df = df.set_index('Name', drop = False)
print("\nThis is the final DataFrame:")
print(df)
输出:
3.将多个列设置为数据帧的索引
在这个方法中，我们可以将 Pandas DataFrame 对象的多列设置为其索引，方法是创建 DataFrame 的列名列表，然后将其传递给set_index()函数。这就是为什么在这种情况下，该指数被称为多指数。让我们通过 Python 代码来实现这一点。
# Import Pandas module
import pandas as pd
# Create a Python dictionary
data = {'Roll': [111, 112, 113, 114],
'Name': ['Rajan', 'Raman', 'Deepak', 'David'],
'Marks': [93, 88, 95, 75],
'City': ['Agra', 'Pune', 'Delhi', 'Sivan']}
# Create a DataFrame from the dictionary
df = pd.DataFrame(data)
print("\nThis is the initial DataFrame:")
print(df)
# Set the Roll & Name column as the multi-index
# using set_index() function and list of column names
df = df.set_index(['Roll', 'Name'])
print("\nThis is the final DataFrame:")
print(df)
输出:
使用 Python 对象设置数据帧的索引
在 Python 中，我们可以通过以下方式将任何 Python 对象如列表、或系列设置为 Pandas DataFrame 对象的索引。
1.Python 列表作为数据帧的索引
在这个方法中，我们可以使用pd.Index()、range()和set_index()函数来设置熊猫数据帧对象的索引。首先，我们将使用range()函数创建一个 Python 数字序列，然后将其传递给返回 DataFrame 索引对象的pd.Index()函数。然后，我们将返回的 DataFrame index 对象传递给set_index()函数，将其设置为 DataFrame 的新索引。让我们通过 Python 代码来实现这一点。
# Import Pandas module
import pandas as pd
# Create a Python dictionary
data = {'Roll': [111, 112, 113, 114, 115],
'Name': ['Rajan', 'Raman', 'Deepak', 'David', 'Shivam'],
'Marks': [93, 88, 95, 75, 99],
'City': ['Agra', 'Pune', 'Delhi', 'Sivan', 'Delhi']}
# Create a DataFrame from the dictionary
df = pd.DataFrame(data)
print("\nThis is the initial DataFrame:")
print(df)
# Create a Python list
list = ['I', 'II', 'III', 'IV', 'V']
# Create a DataFrame index object
# using pd.Index() function
idx = pd.Index(list)
# Set the above DataFrame index object as the index
# using set_index() function
df = df.set_index(idx)
print("\nThis is the final DataFrame:")
print(df)
输出:
2.Python 范围作为数据帧的索引
在这个方法中，我们可以使用pd.Index()和set_index()函数设置 Pandas DataFrame 对象的索引。首先，我们将创建一个 Python 列表，然后将其传递给返回 DataFrame 索引对象的pd.Index()函数。然后，我们将返回的 DataFrame index 对象传递给set_index()函数，将其设置为 DataFrame 的新索引。让我们通过 Python 代码来实现这一点。
# Import Pandas module
import pandas as pd
# Create a Python dictionary
data = {'Roll': [111, 112, 113, 114, 115],
'Name': ['Rajan', 'Raman', 'Deepak', 'David', 'Shivam'],
'Marks': [93, 88, 95, 75, 99],
'City': ['Agra', 'Pune', 'Delhi', 'Sivan', 'Delhi']}
# Create a DataFrame from the dictionary
df = pd.DataFrame(data)
print("\nThis is the initial DataFrame:")
print(df)
# Create a DataFrame index object
# using pd.Index() & range() function
idx = pd.Index(range(1, 6, 1))
# Set the above DataFrame index object as the index
# using set_index() function
df = df.set_index(idx)
print("\nThis is the final DataFrame:")
print(df)
输出:
3.Python 系列作为数据帧的索引
在这个方法中，我们可以使用pd.Series()和set_index()函数设置 Pandas DataFrame 对象的索引。首先，我们将创建一个 Python 列表并将其传递给pd.Series()函数，该函数返回一个可用作 DataFrame 索引对象的 Pandas 系列。然后，我们将返回的 Pandas 系列传递给set_index()函数，将其设置为 DataFrame 的新索引。让我们通过 Python 代码来实现这一点。
# Import Pandas module
import pandas as pd
# Create a Python dictionary
data = {'Roll': [111, 112, 113, 114, 115],
'Name': ['Rajan', 'Raman', 'Deepak', 'David', 'Shivam'],
'Marks': [93, 88, 95, 75, 99],
'City': ['Agra', 'Pune', 'Delhi', 'Sivan', 'Delhi']}
# Create a DataFrame from the dictionary
df = pd.DataFrame(data)
print("\nThis is the initial DataFrame:")
print(df)
# Create a Pandas series
# using pd.Series() function & Python list
series_idx = pd.Series([5, 4, 3, 2, 1])
# Set the above Pandas series as the index
# using set_index() function
df = df.set_index(series_idx)
print("\nThis is the final DataFrame:")
print(df)
输出:
This is the initial DataFrame:
Roll Name Marks City
0 111 Rajan 93 Agra
1 112 Raman 88 Pune
2 113 Deepak 95 Delhi
3 114 David 75 Sivan
4 115 Shivam 99 Delhi
This is the final DataFrame:
Roll Name Marks City
5 111 Rajan 93 Agra
4 112 Raman 88 Pune
3 113 Deepak 95 Delhi
2 114 David 75 Sivan
1 115 Shivam 99 Delhi
4.设置数据帧的索引，保留旧索引
在这个方法中，我们将使用append参数，它是 Python Pandas 模块的set_index()函数的可选参数。默认情况下，append参数的值为False。但是这里我们将把 append 参数的值设置为True。从而数据帧的旧索引被传递给set_index()函数的新索引所附加。让我们通过 Python 代码来实现这一点。
# Import Pandas module
import pandas as pd
# Create a Python dictionary
data = {'Roll': [111, 112, 113, 114, 115],
'Name': ['Rajan', 'Raman', 'Deepak', 'David', 'Shivam'],
'Marks': [93, 88, 95, 75, 99],
'City': ['Agra', 'Pune', 'Delhi', 'Sivan', 'Delhi']}
# Create a DataFrame from the dictionary
df = pd.DataFrame(data)
print("\nThis is the initial DataFrame:")
print(df)
# Set Roll column as the index of the DataFrame
# using set_index() function & append
df = df.set_index('Roll', append = True)
print("\nThis is the final DataFrame:")
print(df)
输出:
结论
在本教程中，我们学习了以下内容:
- 熊猫数据帧对象的索引是什么？
- 如何在创建数据帧时设置索引？
- 如何将 DataFrame 的现有列设置为索引或多索引？
- 如何将列表、范围或熊猫系列等 Python 对象设置为索引？
- 如何设置新的索引保持旧的？
Pandas dataframe.insert()函数——完整指南
原文：https://www.askpython.com/python-modules/pandas/dataframe-insert-function
在本文中，我们将看到数据框架。 insert() 功能来自熊猫。该函数用于列转换技术。所以，让我们马上开始吧！
熊猫图书馆是收集数据并将其呈现给用户的最重要的图书馆之一。这个 API 建立在 matplotlib 和 NumPy 库的基础上，这表明它是纯 Python 制作的。从读取复杂和巨大的数据集到对它们进行统计分析，这个软件包学习和使用都非常简单。
什么是数据帧？
数据帧的概念对熊猫用户来说并不陌生。它是以表格格式表示数据的行和列的集合。就像普通的一样，但是我们可以使用一些代码行修改表格的每个单元格。这节省了大量的工作时间，因为我们不需要在整个表中搜索该元素。
我们将创建一个样本数据集，然后进一步实现。要创建一个，必须给它一个字典，字典中有键形式的列和值形式的行。
代码:
import pandas as pd
data_dict = {'Name':['Ramesh', 'Suresh', 'Rajeev', 'Neha', 'Aditi'],
'Roll_nos':[1, 2, 3, 4, 5],
'Division':['A', 'B', 'C', 'D', 'E'] }
data = pd.DataFrame(data_dict)
data
输出:
Creating a sample datafame
现在我们已经准备好了基本数据集，让我们检索一些关于它的信息。
从熊猫数据框架中获取基本信息
代码:
data.columns
data.info()
输出图像:
Basic information about the dataframe
使用 dataframe.insert()函数添加列
我们将在数据帧中插入列。insert 函数用于显式地放置任何列及其值。这方面的文件如下:
Signature: data.insert(loc, column, value, allow_duplicates=False) -> None
Docstring:
Insert column into DataFrame at specified location.
Raises a ValueError if `column` is already contained in the DataFrame,
unless `allow_duplicates` is set to True.
Parameters
----------
loc : int
Insertion index. Must verify 0 <= loc <= len(columns).
column : str, number, or hashable object
Label of the inserted column.
value : int, Series, or array-like
allow_duplicates : bool, optional
File: c:\users\lenovo\anaconda3\lib\site-packages\pandas\core\frame.py
Type: method
这个函数有一个非常简单的语法:
data.insert(loc, column, value, allow_duplicates = False)
说明:
- loc =要插入列的数据帧的索引位置。
- column =我们要插入的列的名称
- value =该列显示的所有值
- allow_duplicates =该属性用于在数据帧中放置重复的列
使用 dataframe.insert()的方法
有两种方法可以使用这个函数。
- 直接调用函数并给它所有的参数。
- 使用功能方法( 推荐 )
1.直接调用 dataframe.insert()函数
在本例中，我们将通过直接调用 dataframe 来添加一列。这是一个学生数据库，所以我们将尝试在其中添加标记列。
代码:
mrk_list = [90.00, 60.06, 72.32, 78.9, 83.9] # creating a list of values for the Marks column
data.insert(3, 'Marks', mrk_list) # using the isnert function
data # calling the dataframe
输出:
Mark column added to the dataframe
说明:
- 我们为新的“标记”列创建一个名为“ mrk_list ”的列表。它将用于 values 参数。
- 然后我们使用点号-. "调用 insert()函数。操作员用我们的数据框。然后，我们在第三个索引中指定新列的位置。
- 我们给出列的名称。然后我们将值指定为 mrk_list。通过这种方式，我们将学生分数添加到数据集中。
- 注意:当以列表形式传递值时，确保不超过主数据帧 的指标值
整体理解的代码
# importing the module
import pandas as pd
# creating a sample dataframe
data_dict = {'Name':['Ramesh', 'Suresh', 'Rajeev', 'Neha', 'Aditi'],
'Roll_nos':[1, 2, 3, 4, 5],
'Division':['A', 'B', 'C', 'D', 'E'] }
# storing it in a variable
data = pd.DataFrame(data_dict)
# retrieving the basic info
data.info()
data.describe()
# using the insert function
mrk_list = [90.00, 60.06, 72.32, 78.9, 83.9]
data.insert(3, 'Marks', mrk_list)
data
3.使用显式函数寻找更好的方法
我们可以根据需要调用这个函数，只需要改变它里面的参数。它将保存四个参数。
- 数据帧
- 列名
- 位置索引
- 价值观念
代码:
def create_column(df = None, col_name = '', col_loc = 0, values = []):
print('Creating and adding a new column')
df.insert(col_loc, col_name, values)
print('Column created and added!!!')
return df.head() # returning the new dataset with the new columns
df = data # dataframe name
col_name = input('Enter the column name: ').strip()
col_loc = int(input('Ente the location where you want to insert the column: '))
values = ['March', 'April', 'June', 'May', 'Februray']
# calling the function with the values
create_column(df, col_name, col_loc, values)
输出:
The create_column() function and respective inputs for parameters
Joining month column added at the 2nd index of the dataframe
说明:
- 首先我们创建一个函数作为 create_column() 。
- 它有四个参数
- 数据帧
- 列名
- 列位置
- 值–列的输入值数组
- 像添加新列一样在其中添加一条消息。
- 然后，我们调用 insert()函数，并在其中给出所有这些参数。并返回新数据集的头部。
- 当过程结束时，我们打印一条消息，显示为“创建并添加了列！！!"。
结论
在这里，我们得出这个题目的结论。该功能的使用非常简单。我们只需要知道它是如何工作的，然后我们就可以根据我们的需要来使用它。
在 Python 中使用数据帧行和列
原文：https://www.askpython.com/python-modules/pandas/dataframe-rows-and-columns
在本文中，让我们看看如何使用 Python 创建类似表格的结构，以及如何处理它们的行和列。当我们创建需要处理大量数据的数据科学应用程序时，这将非常有用。让我们看看如何使用 Python 执行基本功能，比如创建、更新和删除行/列。
什么是数据框？
Python 作为一种广泛用于数据分析和处理的语言，有必要以结构化的形式存储数据，比如以行和列的形式存储在我们的传统表格中。我们使用 python 的 Pandas 库中的 DataFrame 对象来实现这个。在内部，数据以二维数组的形式存储。让我们在本文中了解更多关于 DataFrame 行和列的知识。
创建简单的数据框架
让我们通过一个例子来学习创建一个简单的数据框架。
import pandas as pd
data = {
"TotalScore": [420, 380, 390],
"MathScore": [50, 40, 45]
}
#load data into a DataFrame object:
df = pd.DataFrame(data)
print(df)
结果
TotalScore MathScore
0 420 50
1 380 40
2 390 45
选择性地打印一个数据帧列
让我们看看如何在 python 中选择所需的列。假设我们有一个数据帧，如上例所示。我们可以通过它们的列来选择所需的列。
print(df[['MathScore']])
上面的代码将只打印“MathScore”列的值。
在 Python 中向数据帧添加列
现在，有时，我们可能希望添加更多的列作为数据收集的一部分。我们可以通过声明一个新的列表并将其转换为 data frame 中的一列，向数据框中添加更多的列。
# creating a new list called name.
name = ['Rhema', 'Mehreen', 'Nitin']
# Using 'Name' as the column name
# and equating it to the list
df['Name'] = name
# Observe the result
print(df)
输出
TotalScore MathScore Name
0 420 50 Rhema
1 380 40 Mehreen
2 390 45 Nitin
删除列
我们可以在 pandas 数据帧中使用 drop()方法来删除特定的列。
# dropping passed columns
df.drop(["Name"], axis = 1, inplace = True)
现在，列“名称”将从我们的数据框架中删除。
使用数据帧行
现在，让我们试着理解在行上执行这些操作的方法。
选择一行
要从数据帧中选择行，我们可以使用 loc[]方法或 iloc[]方法。在 loc[]方法中，我们可以使用行的索引值来检索行。我们还可以使用 iloc[]函数来检索使用整数 location to iloc[]函数的行。
# importing pandas package
import pandas as pd
# making data frame from csv file
data = pd.read_csv("employees.csv", index_col ="Name")
# retrieving row by loc method
first = data.loc["Shubham"]
second = data.loc["Mariann"]
print(first, "\n\n\n", second)
在上面的代码中，我们将 CSV 文件作为 dataframe 加载，并将列“Name”指定为其索引值。稍后，我们使用行的索引来检索它们。
在 Python 中创建数据帧行
要在数据帧中插入新行，我们可以在数据帧中使用 append()函数、concat()函数或 loc[]函数。
#adding a new row using the next index value.
df.loc[len(df.index)] = ['450', '80', 'Disha']
display(df)
#using append function
new_data = {'Name': 'Ripun', 'MathScore': 89, 'TotalScore': 465}
df = df.append(new_data, ignore_index = True)
#using concat function
concat_data = {'Name':['Sara', 'Daniel'],
'MathScore':[89, 90],
'TotalScore':[410, 445]
}
df2 = pd.DataFrame(concat_data)
df3 = pd.concat([df, df2], ignore_index = True)
df3.reset_index()
print(df3)
输出
Using loc[] method
TotalScore MathScore Name
0 420 50 Rhema
1 380 40 Mehreen
2 390 45 Nitin
3 450 80 Disha
Using append() function
TotalScore MathScore Name
0 420 50 Rhema
1 380 40 Mehreen
2 390 45 Nitin
3 450 80 Disha
4 465 89 Ripun
Using Concat() function
TotalScore MathScore Name
0 420 50 Rhema
1 380 40 Mehreen
2 390 45 Nitin
3 450 80 Disha
4 465 89 Ripun
5 410 89 Sara
6 445 90 Daniel
删除一行
我们可以使用 drop()方法删除行。我们必须将行的索引值作为参数传递给方法。
# importing pandas module
import pandas as pd
# making data frame from csv file
data = pd.read_csv("employees.csv", index_col ="Name" )
# dropping passed values
data.drop(["Shubham", "Mariann"], inplace = True)
结论
因此，在本文中，我们讨论了在 python 中处理行和列的各种方法。一般来说，数据框是 Python 中的二维结构，我们可以用它来存储数据和执行各种其他功能。
参考
在此找到 data frames-https://pandas.pydata.org/docs/reference/api/pandas.的官方文档 DataFrame.html
Python 中的数据帧–快速查看和汇总
原文：https://www.askpython.com/python-modules/pandas/dataframes-in-python
熊猫数据框是一个美丽的东西。Python 中的 DataFrames 使得数据处理非常用户友好。
您可以使用 Pandas 导入大型数据集，然后有效地操作它们。你可以很容易地将 CSV 数据导入熊猫数据帧。
但是，Python 中的数据帧是什么，以及如何使用它们？
Dataframes 是一种二维标签数据结构，其列可以是不同的类型。
您可以使用数据框架进行各种分析。
数据集通常太大，不可能一次查看整个数据集。相反，我们希望看到数据帧的摘要。
在 summary 下，我们可以获得数据集的前五行，还可以获得数据的快速统计摘要。除此之外，我们还可以获得数据集中列的类型信息。
在本教程中，我们将学习如何在 Python 中显示数据帧的这种摘要。
在本教程中，我们将使用加州住房数据集作为样本数据集。
1.在熊猫数据框架中导入数据集
让我们从将数据集导入熊猫数据框架开始。
要将数据集导入 Pandas 数据框架，请使用以下代码行:
import pandas as pd
housing = pd.read_csv('path_to_dataset')
这将把数据集作为数据帧存储在变量‘housing’中。
现在，我们可以看看不同类型的数据汇总，这是我们在熊猫身上可以得到的。
2.获得前 5 行
首次导入数据集后，数据科学家通常会查看数据帧的前五行。它给出了数据大概的样子。
要输出数据帧的前五行，请使用以下代码行:
housing.head()
当您运行以下行时，您将看到如下输出:
Head
下面给出了显示数据帧前五行的完整代码。
import pandas as pd
housing = pd.read_csv('path_to_dataset')
housing.head()
3.获取统计摘要
要获得数据帧的统计摘要，您可以使用。描述()熊猫提供的方法。
显示统计摘要的代码行如下:
housing.describe()
运行这行代码将产生以下输出。
Describe
完整的代码如下:
import pandas as pd
housing = pd.read_csv('path_to_dataset')
housing.describe()
输出显示数量，如平均值、标准偏差、最小值、最大值和百分位数。您可以对以下所有示例使用相同的代码，并且只替换每个示例中提到的函数名。
3.获得数据的快速描述
要获得表中数据类型的快速描述，可以使用。熊猫提供的 info() 方法。
您可以使用下面一行代码来获得描述:
housing.info()
输出如下所示:
Info
对于数据集的每一列，输出都包含一行。对于每个列标签，您可以获得非空条目的计数和条目的数据类型。
了解数据集中列的数据类型可以让您在使用数据为模型定型时做出更好的判断。
4.获取每列的计数
您可以使用直接获得每一列中的条目数。计数()【熊猫法】。
您可以使用此方法，如下面的代码行所示:
housing.count()
输出如下所示:
显示每列的计数可以告诉您数据中是否有丢失的条目。随后，您可以计划您的数据清理策略。
获取数据集中每一列的直方图
Pandas 允许您在一行代码中显示每一列的直方图。
要显示直方图，请使用以下代码行:
housing.hist()
运行上面的代码后，我们得到如下输出:
Hist
数据科学家经常使用直方图来更好地理解数据。
结论
本教程是关于 Python 中数据帧的不同类型的快速总结。希望你和我们一起学习愉快！
如何使用 Python 中的 datetime 模块？
原文：https://www.askpython.com/python-modules/datetime-module-examples
在 Python 中，有一个叫做datetime的模块，它允许我们处理日期和时间。它包含年、月和日格式的日期以及小时、分钟和秒格式的时间。本教程将向您展示如何使用这个模块。
在datetime模块中，日期以下列格式表示:
yyyy-mm-dd
时间用以下格式表示:
hh:mm:ss
为了比较日期和时间，我们使用常见的比较运算符，如>=, <=, >, <, ==, !=。
考虑两个日期:d1 和 d2。
| 操作 | 意为 |
| d1>d2 | 在日历中，d1 在 d2 之后 |
| d1 | 在日历中，d1 在 d2 之前 |
| d1==d2 | d1 与 d2 相同 |
Date Comparison
同样，考虑两个时间:t1 和 t2。
| 操作 | 意为 |
| t1>t2 | 在时钟中，t1 在 t2 之后 |
| t1 | 在时钟中，t1 在 t2 之前 |
| t1==t2 | t1 与 t2 相同 |
Time Comparison
上述所有操作都返回一个布尔值，即“真”或“假”，这取决于是否满足给定的条件。
在进行日期和时间比较之前，我们先来看看一些基本的datetime方法。
Python 日期时间方法的示例
让我们直接进入使用日期时间模块的例子。
1.获取今天的日期
import datetime
print(datetime.date.today())
输出:
2022-09-28
日期以 yyyy-mm-dd 格式表示。
2.获取当前时间
from datetime import datetime
print(datetime.now().time())
输出:
12:40:36.221835
时间以 hh:mm:ss 格式表示。
日期和时间比较
1.检查一个日期是否大于另一个日期
from datetime import datetime
#date in the format yyyy-mm-dd
date1 = datetime(2022, 5, 15)
date2 = datetime(2012, 4, 15)
print("Is date1 greater than to date2?: ", date1>date2)
输出:
Is date1 greater than to date2?: True
这里，日期 1 是 2022 年 5 月 15 日，日期 2 是 2022 年 4 月 15 日。由于日历中日期 1 在日期 2 之后，所以输出为真。
2.检查一个日期是否小于另一个日期
from datetime import datetime
#date in the format yyyy-mm-dd
date1 = datetime(2022, 5, 15)
date2 = datetime(2022, 11, 16)
print("Is date1 less than to date2?: ", date1<date2)
输出:
Is date1 less than to date2?: True
在本例中，日期 1 还是 2022 年 5 月 15 日，日期 2 是 2022 年 11 月 16 日。由于在同一日历年中“五月”在“十一月”之前，所以输出为真。
3.检查两个日期是否相等
from datetime import datetime
#date in the format yyyy-mm-dd
date1 = datetime(2022, 5, 15)
date2 = datetime(2022, 4, 15)
print("Is date1 equal to date2?: ", date1==date2)
输出:
Is date1 equal to date2?: False
这里，2022 年 5 月 15 日和 2022 年 4 月 15 日是不一样的。因此，输出为假。
在我们刚刚看到的例子中，只给出了日期，而没有给出时间。让我们学习如何只比较日期，或者只比较时间，如果日期和时间都给定的话。
4.仅比较日期
from datetime import datetime
#datetime in the format yyyy-mm-dd hh:mm:ss
#datetime1 -> date: 6 August, 2022 | time: 11:00:00 a.m.
datetime1 = datetime(2022, 8, 6, 11, 0, 0)
#datetime2 -> 21 March, 2022, | time: 2:45:31 p.m.
datetime2 = datetime(2022, 3, 21, 14, 45, 31)
#getting only the dates from datetime
date1 = datetime1.date()
date2 = datetime2.date()
print("Is date1 greater than date2?: ", date1>date2)
print("Is date1 less than date2?: ", date1<date2)
print("Is date1 equal to date2?: ", date1==date2)
输出:
Is date1 greater than date2?: True
Is date1 less than date2?: False
Is date1 equal to date2?: False
这里，我们使用了date()方法从给定的日期时间中只提取日期，然后使用不同的比较操作符进行比较，得到输出。
5.只比较时间
from datetime import datetime
#datetime in the format yyyy-mm-dd hh:mm:ss
#datetime1 -> date: 6 August, 2022 | time: 11:00:00 a.m.
datetime1 = datetime(2022, 8, 6, 11, 0, 0)
#datetime2 -> 21 March, 2022, | time: 2:45:31 p.m.
datetime2 = datetime(2022, 3, 21, 14, 45, 31)
#getting only the time from datetime
time1 = datetime1.time()
time2 = datetime2.time()
print("Is time1 greater than time2?: ", time1>time2)
print("Is time1 less than time2?: ", time1<time2)
print("Is time1 equal to time2?: ", time1==time2)
输出:
Is time1 greater than time2?: False
Is time1 less than time2?: True
Is time1 equal to time2?: False
与示例 5 类似，这里我们使用 datetime 模块中的time()方法，只从给定的 datetime 中提取时间。
摘要
仅此而已！我们还学习了如何使用 Python 中的datetime模块来处理日期和时间。
如果你想了解更多不同的 Python 概念，查看我们的其他文章这里！
参考
Python 中的 dateutil 模块
在处理需要实时数据的脚本时，我们使用 dateutil 模块，以便在特定时间调度或检索数据，或者只是输入带有检索时间戳的数据。
考虑到您需要对检索到的数据进行大量的更改，使用大量的脚本并尝试使用默认的datetime模块操作日期和时间格式可能是一项艰巨的任务。
幸运的是，dateutil模块是为了提供使您的生活更轻松的功能而创建的。
dateutil模块专门为现有的datetime模块提供扩展功能，因此，datetime模块的安装是先决条件。
然而，因为它是 Python 标准库的一部分，所以没什么好担心的。
在 Python 中安装 dateutil 模块
在我们开始使用dateutil模块之前，我们需要先在我们的电脑上安装它。那么，让我们开始安装程序:
# The command to install the module, through the pip manager.
pip install python-dateutil
我们已经使用了 pip 包管理器来完成这里的安装。你也可以使用 Anaconda 来完成安装。
使用 dateutil 模块
如果您已经成功安装了该模块，我们现在可以开始使用它了！
1.0.模块及其子类。
dateutil模块被分成几个不同的子类，我们将马上进入它们，这样你就知道你在做什么，
- 复活节
- 句法分析程序
- 相对 delta
- 尺子
- 坦桑尼亚
- 还有几个！
该模块没有太多的子类，但是，在本文中，我们将只深入研究其中一些的功能。
1.1 导入所需的方法
我们已经安装了模块，现在只需要将方法付诸实施并获得结果。
那么，让我们从其中的一些开始吧！
等等，在使用dateutil模块之前，我们可能有几个步骤，其中之一就是需要首先导入它们。
# We'll need to import methods from the datetime module as a base.
import datetime
# Now, let's import some methods from the dateutil subclasses.
from dateutil.relativedelta import *
from dateutil.easter import *
from dateutil.parser import *
from dateutil.rrule import *
这些导入允许我们使用本文中需要的许多方法。
1.2 日期时间功能
在我们开始使用dateutil模块之前，您可能还记得这个模块也依赖于日期时间模块的事实，对吗？
嗯，完全正确。dateutil模块处理日期时间对象，这意味着我们需要在处理它们之前创建日期时间对象。
因此，这就是datetime模块导入的原因。让我们开始使用dateutil中的几个模块。
1.3.日期时间和相对增量
relativedelta子类扩展了datetime模块，为我们提供了允许我们处理与检索信息相关的日期和时间的特性。
这意味着我们可以给当前使用的datetime对象添加天数、月数甚至年数。它还允许我们用datetime 对象来处理时间间隔。
# Creating a few datetime objects to work with
NOW = datetime.now()
print("The datetime right now : ", NOW)
TODAY = date.today()
print("The date today : ", TODAY)
现在，让我们使用相对日期来检索信息。
# Next month
print(NOW + relativedelta(months=+1))
# Next month, plus one week
print(NOW + relativedelta(months=+1, weeks=+1))
# Next month, plus one week, at 5 PM
print(NOW + relativedelta(months=+1, weeks=+1, hour=17))
# Next friday
print(TODAY + relativedelta(weekday=FR))
这个模块的一个更适用的用途是使用一些小操作来查找信息。
# Finding out the last tuesday in the month
print(TODAY + relativedelta(day=31, weekday=TU(-1)))
# We can also work with datetime objects directly
# Example: Age of Sacra
sacra_birthday = datetime(1939, 4, 5, 12, 0)
print("Sacra's Age : ", relativedelta(NOW, sacra_birthday).years)
如果你已经注意到，我们只从relativedelta对象中检索了years。
这是用于一个干净的输出，但是，如果你想知道 Sacra 实际上有多老，试着自己摆弄一下 relativedelta 对象。😉
1.4.日期时间和复活节
easter子类用于计算一般复活节日历的日期和时间，允许计算与各种日历相关的日期时间对象。
子类非常小，只有一个参数和三个选项定义了整个模块。
- 儒略历，复活节 _ 儒略历=1。
- 公历，复活节 _ 东正教=2
- 西历，复活节 _ 西方=3
在代码中使用它们，看起来很像，
# The Julian Calendar
print("Julian Calendar : ", easter(1324, 1))
# The Gregorian Calendar
print("Gregorian Calendar : ", easter(1324, 2))
# The Western Calendar
print("Western Calendar : ", easter(1324, 3))
1.5.日期时间和解析器
parser子类带来了一个高级的日期/时间字符串解析器，它能够解析多种已知的表示日期或时间的格式。
# The parser subclass
print(parse("Thu Sep 25 10:36:28 BRST 2003"))
# We can also ignore the timezone which is set to default locally
print(parse("Thu Sep 25 10:36:28 BRST 2003", ignoretz=True))
# We can also not provide a timezone, or a year
# This allows for it to return the current year, with no timezone inclusion.
print(parse("Thu Sep 25 10:36:28"))
# We can also provide variables which contain information, as values.
DEFAULT = datetime(2020, 12, 25)
print(parse("10:36", default=DEFAULT))
您可以提供许多选项，包括本地或显式时区。
可以使用作为默认参数传递给函数的变量来提取信息以提供时区、年份、时间，您可以在这里查看。
1.6.日期时间和规则
rrule子类使用输入分别为我们提供关于datetime对象和datetime对象的递归信息。
# The rrule subclass
# Daily repetition for 20 occurrences
print(list(rrule(DAILY, count=20, dtstart=parse("20201202T090000"))))
# Repeating based on the interval
print(list(rrule(DAILY, interval=10, count=5, dtstart=parse("20201202T090000"))))
# Weekly repetition
print(list(rrule(WEEKLY, count=10, dtstart=parse("20201202T090000"))))
# Monthly repetition
print(list(rrule(MONTHLY, count=10, dtstart=parse("20201202T090000"))))
# Yearly repetition
print(list(rrule(YEARLY, count=10, dtstart=parse("20201202T090000"))))
这个子类是dateutil模块的一个很好的特性，它可以让你处理很多调度任务和日历存储创新。
模块本身还有更多的内容，如果你想在更深的层次上了解更多的特性和论点，查看一下文档是个好主意。
结论
如果您已经阅读了这篇文章，那么您现在知道了dateutil模块如何允许我们扩展由datetime模块提供的信息，以产生您通常需要计算或处理的结果。
如果你知道为了做某件事应该看哪个模块，生活就会简单得多。
也就是说，这里有一些可以帮助你完成与 Python 熊猫、 Scipy 、 zipfile 和 psutil 的工作之旅。
参考
Python 中的决策树–逐步实现
嘿！在本文中，我们将关注 Python 中决策树的关键概念。那么，我们开始吧。
决策树是用于进行预测的最简单和最常用的监督机器学习算法。
什么是决策树？
决策树是一种类似流程图的树状结构，包含了基于特定条件的所有可能的决策解决方案。它被称为决策树，因为它从一个根开始，然后像树一样分支到许多决策。
该树从放置最重要属性的根节点开始。分支代表整个决策的一部分，每个叶节点保存决策的结果。
Decision Tree for predicting if a person is fit or unfit.
属性选择度量
使用属性选择测量(ASM)选择最佳属性或特征。选择的属性是根节点特征。
属性选择度量是一种用于在元组中选择用于区分的最佳属性的技术。它对每个属性进行排序，选择最佳属性作为分裂准则。
最流行的选择方法是:
- 熵
- 信息增益
- 增益比
- 基尼指数
1.熵
为了理解信息增益，我们必须首先熟悉熵的概念。熵是被处理信息的随机性。
它测量分裂的纯度。当熵增加时，很难从信息中得出结论。它的范围在 0 到 1 之间。1 表示它是一个完全不纯的子集。
这里，P(+)/P(-)= of+ve class/% of-ve class
举例:
如果我们的类中总共有 100 个实例，其中 30 个是正的，70 个是负的，那么，
P(+) = 3/10 and P(-) = 7/10
H(s)= -3/10 * log2 (3/10) - 7/10 * log2 ( 7/10) ≈ 0.88
2.信息增益
信息增益是熵的减少。决策树利用信息增益和熵来确定将哪个特征分割成节点以更接近预测目标，并且还确定何时停止分割。
这里，S 是一组实例，A 是属性，S [v] 是 S 的子集。
举例:
Possession of TV at home against monthly income
对于整体数据，是值出现 5 次，而否值出现 5 次。所以，
H(s) = -[ ( 5/10) * log2 (5/10) + (5/10) * log2 (5/10) ] = 1
现在来分析一下真值。是出现 4 次和否出现 2 次。
H(s) = -[ ( 4/6) * log2 ( 4/6) + (2/6) * log2 (2/6) ] = 0.917
对于假值，
H(s)= - [ ( 3/4) * log2 (3/4) + (1/4) * log2 (1/4) ] = 0.811
Net Entropy = (6/10) * 0.917 + (4/10) * 0.811 = 0.874
Total Reduction = 1- 0.874 = 0.126
这个值(0.126)称为信息增益。
3.增益比
增益比是信息增益的修正。在选择属性时，它会考虑分支的数量和大小。它考虑了内在信息。
GR(S,A) = Gain( S,A)/ IntI(S,A)
4.基尼指数
基尼指数也是一种帮助我们计算信息增益的标准。它测量节点的杂质，只计算二进制值。
举例:
C1 = 0，C2 = 6
P(C1) = 0/6 = 0
P(C2) = 6/6 = 1
基尼系数在计算上比熵更有效。
Python 中的决策树算法
让我们看看 Python 中的一些决策树。
1.迭代二分法 3 (ID3)
该算法用于通过计算信息增益来选择分裂。递归地计算树的每一层的信息增益。
2.C4.5
该算法是 ID3 算法的改进。它使用信息增益或增益比来选择最佳属性。它可以处理连续和缺失的属性值。
3.分类和回归树
该算法可以生成分类树和回归树。在分类树中，目标变量是固定的。在回归树中，目标变量的值是要预测的。
使用 Scikit-learn 的决策树分类
我们将使用 scikit-learn 库来构建模型，并使用已经存在于 scikit-learn 库中的 iris 数据集，或者我们可以从这里下载。
该数据集包含三个类别-鸢尾、杂色鸢尾和海滨鸢尾，具有以下属性-
- 萼片长度
- 萼片宽度
- 花瓣长度
- 花瓣宽度
我们必须根据鸢尾植物的属性来预测它的种类。
1.首先，导入所需的库
import pandas as pd
import numpy as np
from sklearn.datasets import load_iris
from sklearn import tree
2.现在，加载虹膜数据集
iris=load_iris()
要查看数据集中的所有特征，使用打印功能
print(iris.feature_names)
输出:
['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)']
要查看数据集中的所有目标名称-
print(iris.target_names)
输出:
['setosa' 'versicolor' 'virginica']
3.去掉标签
现在，我们将删除第 0、50 和 100 个位置的元素。第 0 个元素属于刚毛种，第 50 个元素属于杂色种，第 100 个元素属于海滨种。
这将删除标签，以便我们更好地训练决策树分类器，并检查它是否能够很好地分类数据。
#Spilitting the dataset
removed =[0,50,100]
new_target = np.delete(iris.target,removed)
new_data = np.delete(iris.data,removed, axis=0)
4.训练决策树分类器
最后一步是使用 scikit-learn 的决策树分类器进行分类。
#train classifier
clf = tree.DecisionTreeClassifier() # defining decision tree classifier
clf=clf.fit(new_data,new_target) # train data on new data and new target
prediction = clf.predict(iris.data[removed]) # assign removed data as input
现在，我们检查我们预测的标签是否与原始标签匹配
print("Original Labels",iris.target[removed])
print("Labels Predicted",prediction)
输出:
Original Labels [0 1 2]
Labels Predicted [0 1 2]
哇！我们模型的准确率是 100%。来绘制决策树-
tree.plot_tree(clf)
Image Source : Scikit-learn docs
结论
在本教程中，我们学习了一些重要的概念，如选择决策树的最佳属性、信息增益、熵、增益率和基尼指数。我们了解了不同类型的决策树算法和使用 scikit-learn 实现决策树分类器。希望，你们都喜欢！
参考
解码数据产品:为什么要使用数据网格？
原文：https://www.askpython.com/resources/decoding-data-products-data-mesh
数据网格是一种分析数据架构和操作范例，其中数据被视为一种产品，由知道如何最好地使用数据的团队拥有。
如今数据无处不在。我们所做的每一项数字活动都会产生数据作为副产品。数据是由一切事物产生的，包括系统、流程和传感器。技术让企业获取和保留数据变得更加简单，然后他们可以利用这些数据做出更好的决策，或者为消费者提供更个性化的体验。
另一方面，组织很难使他们的员工能够做出最好和最及时的判断。集中式数据平台设计无法以企业希望的速度和规模提供洞察力。这些问题通过使用数据网格来解决。
为什么要使用数据网格？
一个数据网格，当正确完成时，表明谁拥有数据，因此，谁可以帮助添加新功能，提供关于异常的进一步信息，并与业务和技术团队进行交互以弥补差距。
数据被分成不需要完全规范化的域。不再需要完全规范化的数据，因为除了存储成本更低之外，它还增加了 BI 和高级分析用例的连接复杂性。相反，团队通常采用一种" Starflake "模式，这是雪花和星星的结合。因此，他们能够支持更多的开发团队以及复杂的分析和报告用例。
数据网格原则
域名所有权
数据生产者和数据消费者应该尽可能紧密地合作。从组织的角度来看，理想的情况是当同一个团队生产和消费相同的数据，在同一个团队中结合兴趣、责任和能力。事实上，这是很少可能的，因为一个数据生成团队在他们的领域已经有太多的义务来完全拥有一个数据消耗程序。
将这些职责分成两个团队，不需要中间人就可以直接互动，这是向前迈出的重要一步。数据生成团队的目的应该是以一种其他人可以从中受益的方式提供他们的数据。
数据作为一种产品
数据网格为数据提供了领域驱动的设计( DDD )。DDD 中的数据结构是由组织的域决定的。因此，组织和逻辑将由每个域驱动。
因为数据可以被理解为实体和特征，两者本质上都是领域驱动的，DDD 在这里的意义至少和它在软件工程中的意义一样大。数据网格将产品思维应用于数据，数据产品就是 API。为了“可被发现”，数据必须被很好地定义和记录。
传统的数据集市是数据仓库中的数据聚合，通常由一个小团队以更敏捷的方式驱动和管理，与数据网格概念有许多共同之处。他们被用来获得新的视角和解决特定的战略难题。
自助服务平台
如你所料，设计、安装、执行、监控和访问一个简单的六边形——一个数据产品,需要很多基础设施。提供这种基础设施所需的技能是专门化的，不可能在每个领域都复制。
最重要的是，访问基础设施的高层抽象，消除提供和维护数据产品生命周期的复杂性和摩擦，是团队可以自主控制其数据产品的唯一方式。这需要建立一个新的原则:自助式数据基础设施作为域自治的平台。
数据治理
正如您所看到的，数据网格是使用分布式系统设计开发的，它由一组独立的数据产品组成，这些产品有自己的生命周期，由潜在的独立团队构建和发布。
然而，为了以更高阶数据集、洞察或机器智能的形式获得价值，这些不同的数据产品必须互操作。他们必须能够关联、联合、识别交叉点、绘制其他图表或在图表上按比例设置操作。
要使这些过程成为可能，需要一个数据网格实现，它包括去中心化和域自治、通过全球标准化实现的互操作性、动态拓扑，以及最重要的自动化平台决策执行。这就是我所说的联合计算治理。
作为产品的数据:数据网
获取、解释、信任和最终利用优秀数据的高摩擦和高费用是当前分析数据基础设施的问题之一。如果不处理，随着提供数据的站点和团队数量的增加，问题只会变得更糟。这将是我们第一个分权原则的结果。
“数据即产品”理念旨在解决数据质量和数据孤岛(即黑数据)这一古老问题。Gartner 将其定义为“企业在日常业务活动中获取、处理和存储的信息资产，但很少用于其他目的”。领域提供的分析数据必须作为产品来处理，数据消费者应该被视为顾客——快乐的顾客。
对于被称为产品的领域数据，数据网格实现应该提供可发现性、安全性、可探索性、可理解性、可信度等等。它还应该概述企业必须建立的角色(例如域数据产品所有者，他负责保证数据作为产品提供的客观指标)。
这些指标包括数据质量、减少的数据消耗滞后时间，以及通过净推广者分数衡量的总体数据用户满意度。领域数据产品的所有者必须完全了解谁是数据消费者，他们如何使用数据，以及他们更喜欢使用什么本地方法来消费数据。利用这些关于数据用户的详细知识，设计出符合用户需求的数据产品界面。
老实说，对于网格上的大部分数据产品，只有少数传统的角色有他们自己的工具和期望:数据分析师和数据科学家。为了支持它们，所有的数据产品都可以构建标准化的接口。数据消费者和产品所有者之间的交流是开发数据产品接口的重要部分。
摘要
数据网格集成了孤立的数据，以帮助企业向规模化自动化分析发展。它使企业能够摆脱单一数据结构的消耗陷阱，节省运营和存储成本。通过将数据管理和所有权委托给特定领域的业务团队，这种新颖的分布式策略有望缓解由集中式数据所有权引起的数据访问瓶颈。
Python 中的装饰者[解释]
原文：https://www.askpython.com/python/examples/decorators-in-python
今天来说一个小众话题——Python 中的 Decorators】。这是一个简单但强大的工具，顾名思义，修饰功能。
先决知识
在继续学习 Python 中的装饰器之前，我们需要知道几个概念，即高阶函数和嵌套函数——一枚硬币的两面。
1.高阶函数
Python 有一种在其他函数之间传递和返回函数的简洁方式。许多编程语言都不支持这一点，它允许程序员进行各种各样的操作。
这就是高阶函数概念的来源——任何接受或返回另一个函数的函数都称为高阶函数。
例如:
def hof(func, num):
int res = func(num)
return res
大家可以注意到，hof()的第一个参数是func，是后面调用的函数。类似地，高阶函数也返回其他函数。
推荐阅读——Python 递归函数
2.嵌套函数
Python 提供的另一个通用特性是，它允许您在函数内部声明函数，这些函数被方便地称为嵌套函数。考虑这个例子:
def func(num):
def nested_func():
return num
return nested_func
这里，func()是高阶函数，因为它返回另一个函数，nested_func()是嵌套函数(很明显)，因为它定义在另一个函数内部。
您可以看到，嵌套函数的定义完全取决于您发送给外部函数的内容。
这用于实现封装和创建闭包，这超出了当前教程的范围。
Python 中的 Decorators 是什么？
正如我们之前讨论的，通俗地说，装饰者装饰功能。这意味着装饰者将代码或功能包装在函数周围，以增强函数的功能。
让我们看一个例子:
首先，我们来看一个简单的函数，它将两个数相加:
def sum(a, b):
print(a + b)
A simple summation function that prints the result
现在，假设你要做一大堆这样的数学函数，它们接受两个数字，对它们执行一些数学运算，并打印它们的结果(参见 Python print
现在，假设您想在打印结果之前添加一行，告诉我们正在做什么以及正在操作什么数字。所以输出看起来像这样:
## sum of 1 and 2 ##
3
你可以在定义每个函数的同时添加这一行，但是如果函数太多，并且修饰远远不止一行，那么最好使用一个装饰器。
Python 装饰器的语法
def decorator(function):
def wrapper(num1, num2):
print("##", function.__name__, "of", num1, "and", num2, "##")
function(num1, num2)
return wrapper
理解这段代码可能有点困难，所以我们将逐行检查:
- 这里有几件事需要注意。首先，装饰器被定义为一个函数，其行为类似于一个函数。最好把它想成一个函数。其次，也是更重要的，装饰者接受的参数是它所装饰的功能。注意装饰者的名字可以是任何东西。装饰器也可以接受多个参数，但是这是另一个讨论的主题。
- 这可能是代码中最令人困惑的部分。装饰器必须总是返回一个为原始函数增加了一些功能的函数。这通常被称为包装器功能。这个新函数将替换原始函数，这就是为什么它必须接受与原始函数完全相同数量的参数(在本例中是两个)。所以很明显，这个装饰器不会装饰一个没有两个参数的函数，尽管有办法使用
*args来解决这个问题。 - 在我们的例子中，这将是装饰者添加到原始函数中的功能。注意，我们打印函数名和两个参数的方式与我们想要的完全一样。在此之后，我们需要执行函数，以便打印实际输出。
function(num1, num2):很清楚wrapper()是如何做和function()一样的事情的，但是增加了我们需要的功能，所以下一步是显而易见的。return wrapper:所以基本上，decorator()从我们这里拿了一个函数，用wrapper()在它周围包装了一些装饰，然后返回wrapper()，它将替换第一个函数。因为wrapper()正在调用第一个函数并做额外的事情，它基本上是第一个函数的增强版本。
当我们看到如何使用装饰器时，剩下的就清楚了。
在 Python 中使用装饰器
现在我们已经定义了一个名为 decorator 的 decorator，我们将使用它来增强三个函数——sum(我们前面已经看到过了)、 difference 和 product 。
@decorator
def sum(a, b):
print(a + b)
@decorator
def difference(a, b):
print(a - b)
@decorator
def product(a, b):
print(a * b)
这里，符号@用来告诉 Python 下一个函数正在使用装饰器。
因此，在定义函数之后，它将被传递给装饰器，装饰器将返回它的增强版本。装饰器返回的任何函数都将替换原来的函数。
让我们看看结果:
注意，调用sum()将执行它的增强版本。
注意:使用装饰器会破坏函数的元数据。在我们的例子中，调用sum.__name__将返回wrapper而不是sum，因为这是我们实际使用的函数。docstring 也会根据包装器拥有的 docstring 而改变。
为了避免这种情况，只需从functools导入wraps，然后在装饰器中装饰包装器，如下所示:
from functools import wraps
def decorator(function):
@wraps(function)
def wrapper(num1, num2):
print("##", function.__name__, "of", num1, "and", num2, "##")
function(num1, num2)
return wrapper
在这种情况下，包装器本身使用函数的元数据进行修饰，以便它保留函数元，如__name__和它的 docstring。
结论
这是对如何使用装饰器以及“ @ ”符号的作用的深入解释。希望你学到了一些东西，下节课再见。
参考文献——https://www.python.org/dev/peps/pep-0318/
NumPy degrees()、deg2rad()、rad2deg()和 radians()函数
原文：https://www.askpython.com/python-modules/numpy/degrees-deg2rad-rad2deg-radians
读者你好！欢迎来到另一个关于 NumPy 函数的教程。在本教程中，我们将详细了解 numpy.degrees()、numpy.deg2rad()、numpy.rad2deg()和 numpy.radians()三个重要函数。
那么，我们开始吧。
1.numpy.degrees()
numpy.degrees()是 NumPy 库的一个函数，将角度从弧度转换成度数。
语法: numpy.degrees(input)其中输入可以是以弧度表示的单个角度或以弧度表示的角度的 NumPy 数组。
使用 numpy.degrees()
为了更好地理解，让我们尝试一些例子。
使用 numpy.degrees()和单个角度作为输入
import numpy as np
# Converting pi/6 radians to equivalent angle in degrees
print("PI/6 radians is ",np.degrees(np.pi/6),"degrees \n")
# Converting pi/4 radians to equivalent angle in degrees
print("PI/4 radians is ",np.degrees(np.pi/4),"degrees \n")
# Converting pi/3 radians to equivalent angle in degrees
print("PI/3 radians is ",np.degrees(np.pi/3),"degrees \n")
# Converting pi/2 radians to equivalent angle in degrees
print("PI/2 radians is ",np.degrees(np.pi/2),"degrees \n")
# Converting pi radians to equivalent angle in degrees
print("PI radians is ",np.degrees(np.pi),"degrees ")
输出
PI/6 radians is 29.999999999999996 degrees
PI/4 radians is 45.0 degrees
PI/3 radians is 59.99999999999999 degrees
PI/2 radians is 90.0 degrees
PI radians is 180.0 degrees
上面的代码片段非常清楚地显示了一个角度(以弧度为单位)作为参数传递给了np.degrees()函数。
对 numpy 数组使用 numpy.degrees()
import numpy as np
a = np.array((np.pi/3 , np.pi/2 , np.pi/4 , np.pi))
b = np.degrees(a)
print("Angles in radians: \n",a)
print("Corresponding angles in degrees: \n",b)
输出
Angles in radians:
[1.04719755 1.57079633 0.78539816 3.14159265]
Corresponding angles in degrees:
[ 60\. 90\. 45\. 180.]
在上面的代码片段中，创建了一个 NumPy 数组，并将其分配给变量**a**。在这个数组中，所有的角度都是以弧度表示的，这个数组传递给 np.degrees()函数。
2. numpy.deg2rad()
numpy.deg2rad()是一个数学函数，它将以度为单位的角度转换为以弧度为单位的角度。
语法: numpy.deg2rad(input)其中输入可以是以度为单位的单个角度，也可以是以度为单位的角度的 NumPy 数组。
使用 numpy.deg2rad()函数
现在让我们尝试几个 2 度弧度的例子。
使用 numpy.deg2rad()和单个角度作为输入
import numpy as np
print("30 degrees is equal to ",np.deg2rad(30),"radians\n")
print("45 degrees is equal to ",np.deg2rad(45),"radians\n")
print("60 degrees is equal to ",np.deg2rad(60),"radians\n")
print("90 degrees is equal to ",np.deg2rad(90),"radians\n")
print("360 degrees is equal to ",np.deg2rad(360),"radians")
输出
30 degrees is equal to 0.5235987755982988 radians
45 degrees is equal to 0.7853981633974483 radians
60 degrees is equal to 1.0471975511965976 radians
90 degrees is equal to 1.5707963267948966 radians
360 degrees is equal to 6.283185307179586 radians
对 numpy 数组使用 numpy.deg2rad()
import numpy as np
a = np.array((30 , 45 , 60 , 90 , 180 , 270 , 360))
b = np.deg2rad(a)
print("Angles in Degrees :\n",a)
print("Angles in Radians :\n",b)
输出
Angles in Degrees :
[ 30 45 60 90 180 270 360]
Angles in Radians :
[0.52359878 0.78539816 1.04719755 1.57079633 3.14159265 4.71238898
6.28318531]
3. numpy.rad2deg()
numpy.rad2deg()NumPy 库的函数相当于 numpy.degrees()函数。它将以弧度为单位的角度值转换为以度为单位的角度值。
语法: numpy.rad2deg(input)其中输入可以是以弧度表示的单个角度或以弧度表示的角度的 NumPy 数组。
让我们尝试一些例子来更好地理解它。
使用 numpy.rad2deg()
现在让我们来看看 Numpy 的弧度转度数函数。
对 numpy 数组使用 numpy.rad2deg()
import numpy as np
a = np.array((-np.pi , np.pi/2 , np.pi/3 , np.pi/4 , np.pi))
b = np.rad2deg(a)
print("Angles in Radians:\n",a)
print("Angles in Degrees:\n",b)
输出
Angles in Radians:
[-3.14159265 1.57079633 1.04719755 0.78539816 3.14159265]
Angles in Degrees:
[-180\. 90\. 60\. 45\. 180.]
4.numpy.radians()
numpy.radians()也是将角度从度转换为弧度的数学函数之一。
语法:numpy.radians(input)其中输入可以是单个角度，也可以是角度的 NumPy 数组。
使用 numpy.radians()
最后来看看 numpy 的弧度函数。
对 numpy 数组使用 numpy.radians()
import numpy as np
a = np.array((60 , 90 , 45 , 180))
b = np.radians(a)
print("Angles in degrees: \n",a)
print("Corresponding angles in radians: \n",b)
输出
Angles in degrees:
[ 60 90 45 180]
Corresponding angles in radians:
[1.04719755 1.57079633 0.78539816 3.14159265]
这就是关于 NumPy degrees()、deg2rad()、rad2deg()和 radians()函数的全部内容。这些功能用起来真的很简单，也很容易理解。一定要把这篇文章读两遍，在阅读的同时练习这些代码。有一个任务给你们所有人，你们要用**numpy.rad2deg(** ) 和 numpy.radians() 功能单输入。
参考
- NumPy 文档–NumPy 度
- num py documentation–num py deg2 rad
- num py documentation–num py rad 2 deg
- NumPy 文档–NumPy 弧度
如何在 Python 中删除二叉树？
原文：https://www.askpython.com/python/examples/delete-a-binary-tree
我们在之前的帖子中已经讨论过二叉树和二分搜索法树。在本文中，我们将制定一个算法来删除二叉树，而不会导致内存泄漏。我们还将用 Python 实现该算法。
什么是内存泄漏？
当我们把内存分配给一个变量而忘记删除它时，程序中就会发生内存泄漏。内存泄漏会导致程序终止时出现问题。因此，在删除对内存的引用之前，有必要删除一个分配。
Python 使用垃圾收集过程来处理这些错误，但是我们应该注意不要编写会导致程序内存泄漏的代码。这里我们将讨论一个删除整个二叉树而不导致内存泄漏的算法。
如何在不内存泄漏的情况下删除二叉树的节点？
要删除二叉树的元素，我们可以使用 del 语句来释放分配给每个节点的内存。此外，为了避免内存泄漏，我们必须在删除节点本身之前删除节点的子节点。通过这种方式，我们可以确保引用一个节点的变量在释放内存之前不会被删除。
为了遍历整个树，我们可以使用任何树遍历算法，比如按序、前序、层次序或后序树遍历算法。但是，我们需要在父节点之前遍历子节点，因为子节点必须在父节点之前删除，以避免内存泄漏。
在后序树遍历算法中，我们在访问父节点之前先遍历任意节点的子节点。因此，我们将使用后序树遍历来实现删除二叉树的算法。在下一节中，我们将修改后序树遍历算法来实现该算法。
删除二叉树的算法
如上所述，删除二叉树的算法可以用公式表示如下。
- 从根开始。
- 检查当前节点是否为 None，如果是，返回。否则转到 3。
- 递归删除当前节点的左子节点。
- 递归删除当前节点的右子节点。
- 删除当前节点。
在 Python 中删除二叉树
由于我们已经讨论并制定了删除二叉树的算法，我们将用 python 实现它。我们还将对下图中给出的二叉树执行算法。在输出中，您可以验证在删除其父节点之前是否删除了每个节点。
Binary tree
代码:
from queue import Queue
class BinaryTreeNode:
def __init__(self, data):
self.data = data
self.leftChild = None
self.rightChild = None
def insert(root, newValue):
# if binary search tree is empty, make a new node and declare it as root
if root is None:
root = BinaryTreeNode(newValue)
return root
# binary search tree is not empty, so we will insert it into the tree
# if newValue is less than value of data in root, add it to left subtree and proceed recursively
if newValue < root.data:
root.leftChild = insert(root.leftChild, newValue)
else:
# if newValue is greater than value of data in root, add it to right subtree and proceed recursively
root.rightChild = insert(root.rightChild, newValue)
return root
def deleteTree(root):
if root:
# delete left subtree
deleteTree(root.leftChild)
# delete right subtree
deleteTree(root.rightChild)
# traverse root
print("Deleting Node:", root.data)
del root
root = insert(None, 15)
insert(root, 10)
insert(root, 25)
insert(root, 6)
insert(root, 14)
insert(root, 20)
insert(root, 60)
print("deleting all the elements of the binary tree.")
deleteTree(root)
输出:
deleting all the elements of the binary tree.
Deleting Node: 6
Deleting Node: 14
Deleting Node: 10
Deleting Node: 20
Deleting Node: 60
Deleting Node: 25
Deleting Node: 15
结论
在本文中，我们讨论了用一种改进的后序树遍历算法删除二叉树的算法。请继续关注更多关于 Python 中不同算法实现的文章。
在 Python 中删除字典的方法
原文：https://www.askpython.com/python/dictionary/delete-a-dictionary-in-python
想删除 Python 中的字典？Python 字典是 Python 中使用的一种数据结构，它接受键值对形式的元素。在本文中，我们将了解从 Python 字典中删除键值对的不同方法。
Python 中删除字典的 dict.clear()
Python 内置了clear() method来删除 Python 中的字典。clear()方法删除 dict 中存在的所有键值对，并返回一个空的 dict。
语法:
dict.clear()
举例:
inp_dict = {"A":"Python","B":"Java","C":"Fortan","D":"Javascript"}
print("Elements of the dict before performing the deletion operation:\n")
print(str(inp_dict))
inp_dict.clear()
print("\nElements of the dict after performing the deletion operation:")
print(str(inp_dict))
输出:
Elements of the dict before performing the deletion operation:
{'B': 'Java', 'D': 'Javascript', 'C': 'Fortan', 'A': 'Python'}
Elements of the dict after performing the deletion operation:
{}
从 Python 字典中删除键值对的技术
以下技术可用于从字典中删除键值对:
- Python pop()函数
- Python del 关键字
- 内置 Python popitem()方法
- 字典理解连同 Python items()方法
1.使用 pop()方法
Python pop()方法可以用来从字典中删除一个键和一个与之关联的值，即一个键-值对。
语法:
dict.pop(key)
pop()方法基本上接受一个要从字典中删除的键。它从 dict 中删除关键字以及与关键字相关的值，并返回更新后的 dict。
举例:
inp_dict = {"A":"Python","B":"Java","C":"Fortan","D":"Javascript"}
print("Elements of the dict before performing the deletion operation:\n")
print(str(inp_dict))
pop_item = inp_dict.pop("A")
print("\nThe deleted element:")
print(str(pop_item))
print("\nElements of the dict after performing the deletion operation:\n")
print(str(inp_dict))
在上面的代码片段中，我们将键“A”作为参数传递给了 pop()方法。因此，它删除了与“A”相关联的键值对。
输出:
Elements of the dict before performing the deletion operation:
{'A': 'Python', 'B': 'Java', 'C': 'Fortan', 'D': 'Javascript'}
The deleted element:
Python
Elements of the dict after performing the deletion operation:
{'B': 'Java', 'C': 'Fortan', 'D': 'Javascript'}
2.Python del 关键字
Python del实际上是一个关键字，基本用于删除对象。众所周知，Python 将所有东西都视为一个对象，这就是为什么我们可以很容易地使用 del 通过逐个删除元素来删除 Python 中的字典。
Python del 关键字也可以用来从输入字典值中删除一个键值对。
语法:
del dict[key]
例 1:
inp_dict = {"A":"Python","B":"Java","C":"Fortan","D":"Javascript"}
print("Elements of the dict before performing the deletion operation:\n")
print(str(inp_dict))
del inp_dict["D"]
print("\nElements of the dict after performing the deletion operation:\n")
print(str(inp_dict))
输出:
Elements of the dict before performing the deletion operation:
{'A': 'Python', 'B': 'Java', 'C': 'Fortan', 'D': 'Javascript'}
Elements of the dict after performing the deletion operation:
{'A': 'Python', 'B': 'Java', 'C': 'Fortan'}
例 2: 从嵌套字典中删除键值对
语法:
我们可以从嵌套的 Python 字典中删除键值对。del 关键字的语法如下:
del dict[outer-dict-key-name][key-name-associated-with-the-value]
举例:
inp_dict = {"Python":{"A":"Set","B":"Dict","C":"Tuple","D":"List"},
"1":"Java","2":"Fortan"}
print("Elements of the dict before performing the deletion operation:\n")
print(str(inp_dict))
del inp_dict["Python"]["C"]
print("\nElements of the dict after performing the deletion operation:\n")
print(str(inp_dict))
因此，在这里，我们删除了与外部键“Python”相关联的键-值对“C:Tuple”。
输出:
Elements of the dict before performing the deletion operation:
{'Python': {'A': 'Set', 'B': 'Dict', 'C': 'Tuple', 'D': 'List'}, '1': 'Java', '2': 'Fortan'}
Elements of the dict after performing the deletion operation:
{'Python': {'A': 'Set', 'B': 'Dict', 'D': 'List'}, '1': 'Java', '2': 'Fortan'}
3.Python popitem()方法
Python popitem()函数可以用来从 Python 字典中删除随机或任意的键值对。popitem()函数不接受任何参数，并返回从字典中删除的键值对。
语法:
dict.popitem()
举例:
inp_dict = {"A":"Python","B":"Java","C":"Fortan","D":"Javascript"}
print("Elements of the dict before performing the deletion operation:\n")
print(str(inp_dict))
pop_item = inp_dict.popitem()
print("\nThe deleted element:")
print(str(pop_item))
print("\nElements of the dict after performing the deletion operation:\n")
print(str(inp_dict))
输出:
Elements of the dict before performing the deletion operation:
{'A': 'Python', 'B': 'Java', 'C': 'Fortan', 'D': 'Javascript'}
The deleted element:
('D', 'Javascript')
Elements of the dict after performing the deletion operation:
{'A': 'Python', 'B': 'Java', 'C': 'Fortan'}
4.Python 字典理解和 items()方法
Python items()方法和 Dict Comprehension 一起可以用来删除 Python 中的字典。
Python items() method基本上不带参数，返回一个包含特定字典中所有键值对列表的对象。
语法:
dict.items()
Python Dict Comprehension可用于通过接受来自特定 iterable 的键值对来创建字典。
语法:
{key: value for key, value in iterable}
在从字典中删除键-值对的上下文中，items()方法可用于将键-值对的列表作为 iterable 提供给字典理解。
if statement用于遇到前面提到的键值。如果遇到上述键值，它将返回一个新的 dict，其中包含除了与要删除的键相关联的键值对之外的所有键值对。
举例:
inp_dict = {"A":"Set","B":"Dict","C":"Tuple","D":"List",
"1":"Java","2":"Fortan"}
print("Elements of the dict before performing the deletion operation:\n")
print(str(inp_dict))
res_dict = {key:value for key, value in inp_dict.items() if key != "1"}
print("\nElements of the dict after performing the deletion operation:\n")
print(str(res_dict))
输出:
Elements of the dict before performing the deletion operation:
{'A': 'Set', 'B': 'Dict', 'C': 'Tuple', 'D': 'List', '1': 'Java', '2': 'Fortan'}
Elements of the dict after performing the deletion operation:
{'A': 'Set', 'B': 'Dict', 'C': 'Tuple', 'D': 'List', '2': 'Fortan'}
通过在迭代时指定元素来删除 Python 中的字典
在处理 Python 字典时，我们可能会遇到这样的情况:我们希望在字典的迭代过程中删除一个键值对。
为此，我们可以创建输入字典的列表，并使用for loop遍历字典的列表。
语法:
list(dict)
最后，通过使用一个if statement，我们将检查循环是否遇到要删除的键。一旦遇到键，就可以使用 del 关键字删除键-值对。
举例:
inp_dict = {"A":"Set","B":"Dict","C":"Tuple","D":"List",
"1":"Java","2":"Fortan"}
print("Elements of the dict before performing the deletion operation:\n")
print(str(inp_dict))
for KEY in list(inp_dict):
if KEY =="B":
del inp_dict[KEY]
print("\nElements of the dict after performing the deletion operation:\n")
print(str(inp_dict))
输出:
Elements of the dict before performing the deletion operation:
{'A': 'Set', 'B': 'Dict', 'C': 'Tuple', 'D': 'List', '1': 'Java', '2': 'Fortan'}
Elements of the dict after performing the deletion operation:
{'A': 'Set', 'C': 'Tuple', 'D': 'List', '1': 'Java', '2': 'Fortan'}
结论
因此，我们揭示了从 Python 字典中删除键值对的不同技术。
参考
- Python 字典 JournalDev
- Python 字典-官方文档
如何在 Python 中删除文件
介绍
在我们的 Python 文件处理教程中，我们学习了如何在 Python 中操作文件。在本教程中，我们将学习如何在 Python 中删除文件。
在 Python 中，我们知道如何从文件中读取 T1，如何向文件中写入 T3。今天我们来学习一下 Python 中的删除操作。
假设成功创建一个文件后，我们对它执行一些操作，比如读和写。一旦我们完成使用文件进行分析不同的数据集，也许在某些情况下，我们在未来不需要它。此时我们如何删除文件？在本教程中，我们将学习。
Python 中删除文件的方法
让我们看看在 Python 中删除文件的不同方法。
1.使用操作系统模块
Python 中的os模块提供了一些易于使用的方法，利用这些方法我们可以删除或移除文件以及空目录。仔细查看下面给出的代码:
import os
if os.path.isfile('/Users/test/new_file.txt'):
os.remove('/Users/test/new_file.txt')
print("success")
else:
print("File doesn't exists!")
这里我们使用了一个 if-else 语句来避免如果文件目录不存在时可能出现的异常。方法isfile()检查文件名为-‘new _ file . txt’的文件是否存在。
同样，os模块为我们提供了另一种方法，rmdir()，可以用来删除或者删除一个空目录。例如:
import os
os.rmdir('directory')
注意:目录必须是空的。如果它包含任何内容，方法我们返回一个 OSerror 。
2.使用 shutil 模块
shutil 是 Python 中另一种删除文件的方法，它使得用户可以轻松地删除文件或其完整目录(包括其所有内容)。
rmtree()是 shutil 模块下的一个方法，以递归的方式删除一个目录及其内容。让我们看看如何使用它:
import shutil
shutil.rmtree('/test/')
对于上述代码，删除了目录 '/test/' 。而且最重要的是，目录里面的所有内容也被删除了。
3.使用 pathlib 模块
pathlib 是内置的 python 模块，可供 Python 3.4+ 使用。我们可以使用这个预定义的模块删除一个文件或者一个空目录。
让我们举个例子:
import pathlib
file=pathlib.path("test/new_file.txt")
file.unlink()
在上面的例子中，path()方法用于检索文件路径，而unlink()方法用于取消链接或删除指定路径的文件。
unlink()方法适用于文件。如果指定了目录，将引发 OSError。要删除目录，我们可以求助于前面讨论过的方法之一。
参考
- https://stack overflow . com/questions/6996603/how-to-delete-a-file-or-folder
- https://docs.python.org/3/library/os.html#os.remove
- https://docs.python.org/3/library/shutil.html
- https://docs.python.org/3/library/pathlib.html
Python 中的树状图指南
原文：https://www.askpython.com/python/examples/dendrograms-in-python
树状图是描述一棵树的图表。create_dendrogram图形工厂对数据进行层次聚类，并描绘出结果树。聚类之间的距离由树深度轴上的值表示。
树状图经常在计算生物学中用于描述基因或样本分组，偶尔在热图的边缘。
分层聚类产生树状图作为输出。许多人声称，这种类型的树状图可以用来确定集群的数量。然而，只有当超度量树不等式成立时，这才是正确的，这在实践中很少发生。
用 Python 绘制基本的树状图
import plotly.figure_factory as ff
import numpy as np
np.random.seed(1)
X = np.random.rand(15, 12)
fig = ff.create_dendrogram(X)
fig.update_layout(width=800, height=500)
fig.show()
Basic Dendrogram
应用层次聚类并绘制树状图
我们将利用以下方法实现层次聚类并绘制一个树状图:
- 层次模块提供了用于层次和聚集聚类的例程。
- scipy . cluster . hierarchy . linkage 方法用于进行层次聚类。
- 为了将分层聚类绘制为树状图，使用了 scipy . cluster . hierarchy . dendrogram 函数。
import numpy as np
from scipy.cluster import hierarchy
import matplotlib.pyplot as plt
x = np.array([100., 200., 300., 400., 500., 250.,450., 280., 450., 750.])
temp = hierarchy.linkage(x, 'single')
plt.figure()
dn = hierarchy.dendrogram(temp, above_threshold_color="green", color_threshold=.7)
DendrogramsHeiCluster Plot
更改树状图的方向
dn = hierarchy.dendrogram(temp, above_threshold_color="green", color_threshold=.7,orientation='right')
DendrogramsHeiCluster Plot Right Orientation
结论
恭喜你！您刚刚学习了如何用 Python 绘制树状图。希望你喜欢它！😇
喜欢这个教程吗？无论如何，我建议你看一下下面提到的教程:
感谢您抽出时间！希望你学到了新的东西！！😄
Python 中的图像去噪——分步指南
原文：https://www.askpython.com/python/examples/denoising-images-in-python
在本教程中，我们通过使用 Python 作为编程语言，使用机器学习算法对有噪声的图像进行降噪。
让我们直接进入什么是图像去噪，以及如何在接下来的部分实现相同的功能。
也读作:使用直方图可视化图像中的颜色——Python OpenCV
图像去噪导论
随着数码摄影的迅猛发展，人们对更精确、更具美感的照片的需求正在上升。另一方面，现代相机产生的图像被噪声污染，导致视觉质量差。
因此，必须努力在不牺牲图像质量(边缘、拐角和其他尖锐结构)的情况下将噪声降至最低。
Image Denoise Sample
图像去噪 是指从有噪声的图像中去除噪声以恢复原始图像的过程。
然而，由于一些成分，如噪声、边缘和纹理，很难在整个去噪过程中区分它们，去噪后的图像可能不可避免地丢失一些特征。
在降噪过程中从噪声图片中恢复有用信息以创建高质量的照片已经成为近年来的重要问题。
Python 中的图像去噪——实现
现在我们已经有了图像去噪的介绍，让我们一步一步地实施。
1.导入模块
import cv2
import numpy as np
from matplotlib import pyplot as plt
plt.style.use('seaborn')
2.加载图像
为了将图像加载到程序中，我们将使用imread函数。相同的代码如下所示。
image = cv2.imread('sample_denoise_input.jpg')
3.应用 OpenCV 的去噪功能
OpenCV 库中有多个去噪函数，如下所示:
| 序列号 | 功能名称 | 描述 |
| 1 | cv2.fastNlMeansDenoising() | 适用于单灰度图像 |
| 2 | cv2 . fastnlmeansdenoisingcolored() | 为彩色图像工作 |
| 3 | cv2 . fastnlmeans no Singapore() | 适用于灰度图像序列 |
| 4 | cv2 . fastnlmeans no singularides() | 为一系列彩色图像工作 |
De-noising Techniques – OpenCV
在本教程中，我们将加载一个单一的彩色图像，所以我们将第二个功能。相同的代码如下所示。
dst = cv2.fastNlMeansDenoisingColored(image, None, 11, 6, 7, 21)
4.绘制原始图像和去噪图像
现在图像已经去噪，是时候使用subplots绘制原始的去噪图像了，这可以通过下面提到的代码来实现。
row, col = 1, 2
fig, axs = plt.subplots(row, col, figsize=(15, 10))
fig.tight_layout()
axs[0].imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
axs[0].set_title('Elephant')
axs[1].imshow(cv2.cvtColor(dst, cv2.COLOR_BGR2RGB))
axs[1].set_title('Fast Means Denoising')
plt.show()
去噪图像的完整代码
import cv2
import numpy as np
from matplotlib import pyplot as plt
plt.style.use('seaborn')
image = cv2.imread('sample_denoise_input.jpg')
dst = cv2.fastNlMeansDenoisingColored(image, None, 11, 6, 7, 21)
row, col = 1, 2
fig, axs = plt.subplots(row, col, figsize=(15, 10))
fig.tight_layout()
axs[0].imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
axs[0].set_title('Elephant')
axs[1].imshow(cv2.cvtColor(dst, cv2.COLOR_BGR2RGB))
axs[1].set_title('Fast Means Denoising')
plt.show()
一些示例输出
现在，让我们看看上面提到的代码的一些示例输出。
Final Output Denoising Image
Final Output 2 Denoising Image
Final Output 3 Denoising Image
结论
我希望你理解这个概念，并喜欢输出。用更多的图像尝试同样的方法，看看屏幕上发生的奇迹吧！
编码快乐！😇
想了解更多？查看下面提到的教程:
Python 中的密度图–全面概述
原文：https://www.askpython.com/python/examples/density-plots-in-python
密度图用于显示数据集中连续数值变量的分布。它也被称为核密度图。
在开始应用任何机器学习技术之前，很好地了解你的数据是一个很好的做法。
作为一名优秀的 ML 从业者，我们应该问一些问题，如:
- 我们的数据是什么样的？
- 它是正态分布还是有一些不同的形状？
- 我们打算应用于数据的算法，是否有任何关于数据分布的潜在假设？
在我们获得数据后立即解决这些问题可以极大地改善后续阶段的结果，并为我们节省大量时间。
像直方图和密度图这样的图为我们提供了回答上述问题的方法。
为什么要在了解密度图之前了解直方图？
密度图非常类似于直方图。我们用直方图来显示分布的形状。直方图可以通过对数据进行宁滨处理并保存每个箱中的观察数量的计数来创建。在直方图中，y 轴通常表示容器计数，但也可以用每单位计数表示，也称为密度。
A Histogram With Less Number Of Bins
如果我们增加直方图中的箱数，分布的形状看起来会更平滑。
Histogram Having More Number Of Bins
现在，想象一条平滑连续的线穿过每个箱的顶部，创建我们的分布形状的轮廓。我们得到的结果就是我们所说的密度图。
Density Plot With Histogram
理解密度图
我们可以把密度图想象成平滑的直方图，这很直观。密度图大多使用一个ernel 密度估计值 。核密度估计通过平滑噪声允许更平滑的分布。
密度图不受仓数量的影响，仓数量是考虑直方图时的主要参数，因此允许我们更好地可视化数据的分布。
因此，总的来说，它就像一个直方图，但有一条平滑的曲线穿过每个箱的顶部。
在野外存在几种分布形式。我们很可能会遇到的一些最常见的形状是:
Some Shapes Of Distributions
使用 Python 绘制密度图
我们可以使用 python 以多种方式绘制密度图。我们来看几个常用的方法。
1.使用 Python scipy.stats 模块
scipy.stats模块为我们提供了gaussian_kde类来找出给定数据的密度。
import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import gaussian_kde
data = np.random.normal(10,3,100) # Generate Data
density = gaussian_kde(data)
x_vals = np.linspace(0,20,200) # Specifying the limits of our data
density.covariance_factor = lambda : .5 #Smoothing parameter
density._compute_covariance()
plt.plot(x_vals,density(x_vals))
plt.show()
Density Plot Using Scipy
我们改变gaussian_kde类的函数covariance_factor并传递不同的值以获得更平滑的图形。改变功能后记得打电话给_compute_covariance。
2.使用 Seaborn kdeplot模块
Seaborn module 为我们提供了一种更简单、更灵活的方式来执行上述任务。
import numpy as np
import seaborn as sb
import matplotlib.pyplot as plt
data = np.random.normal(10,3,300) #Generating data.
plt.figure(figsize = (5,5))
sb.kdeplot(data , bw = 0.5 , fill = True)
plt.show()
Density Plot Using Kdeplot
Seaborn kdeplot需要一个单变量数据数组或一个 pandas 系列对象作为它的输入参数。bw参数相当于上面演示的gaussian_kde类的covariance_factor。我们可以让fill = False不用颜色填充曲线下的区域，而是简单地绘制一条曲线。
3.使用熊猫绘图功能
Pandas plot方法也可以通过提供kind = 'density'作为输入参数来绘制密度图。
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
x_values = np.random.random(10,3,300) #Generating Data
df = pd.DataFrame(x_values, columns = ['var_name'] ) #Converting array to pandas DataFrame
df.plot(kind = 'density)
Density Plot Using Pandas
4。使用 Seaborn distplot
我们还可以使用 seaborn distplot方法来可视化连续数值数据的分布。seaborn.distplot( )方法需要一个单变量数据变量作为输入参数，它可以是 pandas 系列、1d 数组或列表。
我们可以传递给seaborn.distplot( )的一些重要参数来根据我们的需要调整情节:
hist😦Type–Bool)是否绘制直方图。kde:(Type–Bool)**是否绘制高斯核密度估计。**bins**😦Type–Number)指定直方图中面元的数量。hist_kws:(Type–Dict)关键字参数的 Dict 为matplotlib . axes . axes . hist()kde_kws:(Type–Dict)关键字参数为 kdeplot() 作为字典传递。
***import numpy as np
import matplotlib.pyplot as plt
import seaborn as sb
data = np.random.normal(10, 3, 1000) #Generating data randomly from a normal distribution.
sb.set_style("whitegrid") # Setting style(Optional)
plt.figure(figsize = (10,5)) #Specify the size of figure we want(Optional)
sb.distplot(x = data , bins = 10 , kde = True , color = 'teal'\
, kde_kws=dict(linewidth = 4 , color = 'black'))
plt.show()***
***
Density Plot Using Seaborn distplot***
要了解更多关于 seaborn 的信息，你可以参考这篇关于 seaborn Distplots 的文章。
结论
这就把我们带到了文章的结尾！我们希望你今天已经学到了很多关于不同密度图的知识。您可以阅读这些文章来了解更多关于我们在本文中使用的 Pandas 和 Matplotlib 库的信息。
Python 中的依赖解析简介
原文：https://www.askpython.com/python/examples/dependency-parsing-in-python
嘿伙计们！在今天的教程中，我们将了解什么是依赖解析，以及如何使用 Python 编程语言实现依赖解析。
什么是依存解析？
基于句子中单词之间的依赖性来评估句子的语法结构的技术被称为 依赖性分析。
依存分析中的各种标签描述了句子中两个词之间的关系。这些是 依赖标签 。
Dependency Parsing Illustration
为什么需要依赖解析？
依存解析允许我们使用标记来构建解析树，以确定句子中单词之间的关系，而不是像句法解析那样使用任何语法规则，这提供了很大的灵活性，即使单词的顺序发生了变化。
在 Python 中实现依赖解析
为了实现依赖解析，我们将利用 Python 中的spaCy模块。所以，首先，我们把它导入到我们的程序中。
import spacy
from spacy import displacy
现在让我们随机抽取一些我们想要进行依存分析的句子。
text1 = 'It took me more than two hours to translate a few pages of English.'
text2 = 'The old rusted farm equipment surrounded the house predicting its demise.'
text3 = 'I am a great listener, really good with empathy vs sympathy and all that, but I hate people.'
text4 = 'The ants enjoyed the barbecue more than the family.'
接下来，我们使用spacy.load函数，它将帮助构建一个语言对象，加载模型数据和权重，并返回它。
nlp=spacy.load('en_core_web_sm')
最后，我们将显示前面代码片段中提到的文本的依赖解析输出。
displacy.render(nlp(text1),jupyter=True)
Dependency Parsing Output 1
Dependency Parsing Output 2
Dependency Parsing Output 3
Dependency Parsing Output 4
结论
恭喜你！您刚刚学习了如何使用 NLP 为句子构建依存解析图表。希望你喜欢它！😇
喜欢这个教程吗？无论如何，我建议你看一下下面提到的教程:
感谢您抽出时间！希望你学到了新的东西！！😄
在 Heroku 上部署 Django 应用程序——简单的分步指南
原文：https://www.askpython.com/django/deploy-django-app-on-heroku
大家好！在本教程中，我们将讨论如何在 Heroku 上免费部署 Django 应用程序。因此，让我们开始在 Heroku 平台上部署我们的第一个 Django 应用程序的激动人心的旅程，并且零成本。
如果你不知道 Django，我们有一个 Django 教程系列，你可以看完。
什么是 Heroku？
Heroku 是一个基于云的平台，它使世界各地的开发者能够开发或构建、运行和操作各种类型的 web 应用。它属于 PaaS(平台即服务),这是广泛使用和最流行的云计算服务产品之一。
Heroku 完全支持学生的学习，这就是为什么除了付费功能外，它还提供免费服务，以方便实验和部署。人们可以在 Heroku 平台上轻松使用编程语言，如 Java、 Node.js、Scala、Clojure、 Python 、PHP 和 Go ，因为它支持所有这些。
为什么要在 Heroku 上部署我们的 Django 应用？
每当我们学习任何编程语言或框架，如 Python 中的 Django，我们都在本地计算机上进行各种开发工作，这足以学习和调试东西。但是当我们完成了开发工作并且我们的项目已经准备好被一些真实世界的用户使用之后，就有必要在一些 web 服务器上部署项目或者应用程序了。
以便所有潜在用户都可以访问它。最重要的是，它对我们的开发工作产生了非常深刻和积极的影响，因为它在互联网上直播，人们可以很容易地看到实时工作的东西。
在 Heroku 上部署 Django 应用程序的步骤
以下是在 Heroku 上部署 Django 应用程序的五个关键步骤。
1.创建一个您希望部署在 Heroku 上的 Django 应用程序
如果您已经创建并开发了 Django 项目(一个 web 应用程序或网站)，那就太好了。你可以跳过这一步。对于那些现在还没有 Django 项目，但仍然想在 Heroku 上学习 Django 应用程序的部署过程的人。您可以运行以下命令来创建一个新的 Django 项目和应用程序。
> python -m pip install Django
> django-admin startproject <your_project_name>
> python manage.py migrate
> python manage.py runserver
输出:
Django version 3.2.6, using settings '<your_project_name>.settings'
Starting development server at http://127.0.0.1:8000/
Quit the server with CTRL-BREAK.
注意:在继续部署之前，不要忘记在本地服务器(http://127.0.0.1:8000/)上运行 Django 应用程序。
2.在 GitHub 上创建 Django 应用程序的存储库
登录你的 GitHub 账户，创建一个全新的 repo (repository)来存储你的 Django 项目的所有文件夹、文件和代码。此外，将当前 Django 项目的目录设为 git repo，并将其连接到远程 GitHub 存储库。然后暂存所有内容，提交，最后将所有内容推送到远程 GitHub repo。
3.对 Django 项目文件进行以下更改
- 在 Django 项目的目录中创建一个文件名为 Procfile 的新文件，并将下面的代码复制到其中。
web: gunicorn <your_project_name>.wsgi --log-file -
- 从命令行界面或虚拟环境(如果有)安装以下依赖项。
> python -m pip install gunicorn
> python -m pip install whitenoise
- 修改项目子文件夹中的
settings.py文件，添加允许的主机，并将DEBUG参数设置为False，如下所示。
DEBUG = False
ALLOWED_HOSTS = ['127.0.0.1', '<site_name>.herokuapp.com']
- 再次修改
settings.py文件，通过以下方式用 whitenoise 依赖关系更新MIDDLEWARE代码。
MIDDLEWARE = [
'django.middleware.security.SecurityMiddleware',
# Added Following One Line Of Code
'whitenoise.middleware.WhiteNoiseMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
]
- 按照以下方式更新项目子文件夹中的
settings.py文件，这是媒体和静态文件顺利工作的需要。
urlpatterns = [
path('admin/', admin.site.urls),
path('', include("home.urls")),
# Added Following Two Lines Of Code
url(r'^media/(?P<path>.*)$', serve,{'document_root': settings.MEDIA_ROOT}),
url(r'^static/(?P<path>.*)$', serve,{'document_root': settings.STATIC_ROOT}),
]
- 使用下面的命令创建一个
requirements.txt文件，该文件将告诉服务器 Django 项目的各种依赖项以及 Django 应用程序顺利部署和运行所需的版本。
> python -m pip freeze > requirements.txt
注意:不要忘记将修改或变更暂存、提交，然后推送到远程(GitHub 存储库)。
4.在 Heroku 平台上创建一个免费帐户
前往www.heroku.com创建一个免费的 Heroku 账户，只需提供以下必填信息。
- 西方人名的第一个字
- 姓
- 电子邮件地址
- 作用
- 初级开发语言
如果你已经有一个 Heroku 帐号，不需要创建一个新的，只需要在你默认的浏览器上登录就可以了。
5.在 Heroku 仪表板上创建和设置一个新的 Heroku 应用程序
以下是创建和设置新 Heroku 应用程序的步骤。
- 转到 Heroku 仪表板并点击新按钮。
- 从下拉菜单中选择创建新应用选项。
- 选择一个合适的可用的应用名称。
- 进入应用设置面板，在 Buildpacks 部分选择 Python 。
- 切换到App Deploypanel，在部署方式部分连接你的 GitHub 账号。
- 搜索包含 Django 项目的 GitHub repo 并选择它。
- 在手动部署部分选择 git 分支，通常是主/主分支，点击部署分支按钮。
万岁！您已经在 Heroku 服务器上成功启动了您的 Django 应用程序或网站。
总结
在本教程中，我们学习了 Heroku 平台、部署需求、在 Heroku 平台上部署 Django 应用或网站的步骤。希望你理解了部署过程，并对在 Heroku 上部署你的 Django 应用或网站感到兴奋。感谢阅读！请继续关注我们，了解更多关于 Python 的精彩学习内容。
在 VPS 上部署 Flask 应用程序
原文：https://www.askpython.com/python-modules/flask/deploy-flask-app-on-vps
在本文中，我们将使用 Apache Webserver 软件和 mod_wsgi WSGI 将 Flask 应用程序部署到虚拟专用服务器(VPS)上。
什么是 VPS？
VPS，代表虚拟专用服务器，是各种托管公司作为服务出售的虚拟机。你可以认为它类似于笔记本电脑的 CPU 硬件，但是是原始形式，即没有屏幕、键盘等。
像谷歌、亚马逊这样的公司提供云服务器服务(GCP、AWS 等。).作为服务的一部分，你可以借出位于世界不同地方的各种服务器。他们根据不同的标准向你收费，比如使用的时间、CPU 利用率等等。
使用云服务器有几个好处，比如:
- 24 小时运行的服务器–使用云服务器，您部署在其上的应用程序将 24 小时运行。在本地主机(您的笔记本电脑)的情况下，您需要让它运行 24 小时，这是不切实际的。
- 可扩展性–如果您的存储已满，您可以横向扩展您的服务(存储、RAM 等。)迅速在云端。
- 更安全–由于所有硬件都在云中心，因此更安全。
- 可访问性–您可以从任何笔记本电脑或计算机访问您的云服务器。
在本教程中，我们将使用 AWS–Amazon Web Services 进行部署。你可以选择任何一家 VPS 提供商。
在互联网上运行应用程序所需的软件
现在，部署在 VPS 上的 Flask 应用程序需要执行以下操作:
- 托管静态文件，如 HTML/ CSS/ JS
- 处理 Http 请求
- 从崩溃中恢复
- 需要时纵向扩展
为了执行所有这些任务，我们需要以下不同的软件:
- 一个 Web 服务器软件——Apache、Nginx 等
- Web 服务器网关接口(WSGI)应用服务器–Mod _ WSGI、Gunicorn 等
- 您实际的网络应用——使用 Flask、Django 等编写
这里需要一个 web 服务器 软件如 Apache 来处理域逻辑并接受 HTTP 请求。然后，适当的请求通过 WSGI 应用服务器(如 mod_wsgi、Gunicorn 等)发送到主 web 应用程序(Flask)
WSGI 应用服务器提供了 Apache 软件和 Flask 应用程序之间的网关接口。 WSGI 是用 python 写的框架(Django/Flask)
WSGI 的主要用途是将请求转换成 python 可读的格式，并发送给应用程序代码(用 Flask-python 编写)，然后执行必要的功能并返回响应网页。
因此，WSGI 充当 Apache 和 Flask 应用程序之间的网关。
让我们分别来看一看
什么是 Web 服务器软件？
网络服务器软件的主要作用是托管互联网上的网站。它充当服务器和客户机之间的中间人。
这些软件应用程序处理客户端请求，然后返回服务器上的物理文件(模板/数据),并将它们显示给客户端。
Web 服务器软件的例子有 Apache、NGINX 等。
在本文中，我们将使用好的旧的 Apache 服务器，它托管了互联网上几乎 47% 的 web 应用程序
什么是 mod_wsgi WSGI 应用服务器？
Mod_wsgi 是一个 Apache HTTP 服务器模块，它提供了一个符合 WSGI 的接口，用于在 Apache 下托管基于 Python 的 web 应用程序。它支持 Python 版本 2 和 3。
它充当 Apache 软件和位于云服务器上的 Flask 应用程序之间的接口。
在 VPS 上部署 Flask 项目
第一步是从 VPS 提供商那里选择服务器。任何提供 VPS 的公司都会有几台运行在不同操作系统上的服务器，如图所示
AWS Servers
选择所需的服务器后，您需要完成一些步骤来设置和启动服务器。
务必注意您在云服务器上启用了 HTTP 端口(80) 。80 端口是 Web 服务器软件(Apache 等)的端口。)“监听”或接收来自 Web 客户端的请求。
Aws HTTP Post
一旦服务器设置完成，你将获得服务器的 IP 地址或公共 DNS ，稍后需要连接到云服务器。
Aws
1.从本地计算机连接到云服务器
我们使用 ssh 命令连接到服务器。要从本地计算机连接到云服务器，请运行以下命令:
- 使用 Mac 或 Linux :
在 shell 中，只需运行代码:
ssh [email protected]<server_IP>
如果你使用的是 Ubuntu 服务器，用户名是 ubuntu 。
- 使用窗口
对于 windows 操作系统，我们使用一款名为 PuTTY 的软件，你可以直接从互联网上下载。下载完成后，进入的云 IP ，点击打开。
PuTTY
我将用来访问我的服务器的云 IP/公共 DNS 是:
Public DNS
对于 AWS，我们还需要使用一个额外的私有安全密钥。因此，根据 VPS 提供者，您可能还需要添加 security_key
完成后，您将登录到云服务器操作系统。
Ubuntu
2.安装必要的软件包
一旦连接了服务器，它将类似于新的 ubuntu 计算机。我们首先需要将所有重要的软件包安装到其中。
因此，运行以下命令:
安装升级
sudo apt update
sudo apt upgrade
启动服务器后，务必更新系统。
在服务器上安装 apache2 和 mod _ wsgi
现在让我们首先在系统上安装 Apache2 和 mod_wsgi 包
sudo apt install apache2
sudo apt install libapache2-mod-wsgi
要检查 Apache2 是否工作，请访问云服务器的公共 DNS/IP 地址。您将看到 Apache 默认页面。
安装 python3-pip
现在使用以下命令将 python3 和 pip 安装到系统上:
sudo apt install python-pip
安装砂箱 及其延伸件
现在安装砂箱框架和所有其他需要的砂箱扩展如砂箱 _SQLAlchemy 、砂箱 _ 登录、 砂箱 _wtf、等
sudo pip install flask
sudo pip install flask_sqlalchemy
....
....
只需安装您的 Flask 项目所需的 Flask 扩展。
3.将 Flask 项目从本地机器转移到云服务器
您可以创建一个新目录，并使用 nano 文本编辑器在其中编写整个 Flask 应用程序。
mkdir flask_project
cd flask_project
更好的选择是在本地机器上编码项目，然后将 flask_project 文件夹转移到云服务器。
为了传输文件，我们使用代码
scp -i <path/to/secret_key> -r <path/to/file> [email protected]<public_DNS>:<path/to/destination>
Transfer Files
在 AWS 中，我们还需要插入一个安全密钥。如果您的 VPS 提供商没有任何安全密钥，那么从命令中删除密钥路径
将主目录中的 Flask 应用程序项目目录 flask_project 与 Apache 的配置(位于 /var/www/html 目录中)链接起来。我们使用代码:
sudo ln -sT ~/flask_project /var/www/html/flask_project
4.编写烧瓶应用程序
在 Flask_project 文件夹中，你应该有所有的 Flask 文件——app . py、 models.py 、模板等。
让我们编写一个简单的 Flask 应用程序，所以在 flask_project 目录下，创建一个文件 app.py
sudo nano app.py
并添加代码:
from flask import Flask
app = Flask(__name__)
@app.route('/blogs')
def blogs():
return 'Welcome to The Blog App'
@app.route('/blog/<int:id>')
def blog(id):
return "The Blog id is {}".format(id)
if __name__ == '__main__':
app.run()
之后，我们现在必须创建一个 WSGI 文件。为此创造了一个。与主 Flask 应用程序文件同名的 wsgi 文件。我的情况是 app.wsgi
使用 nano app.wsgi ，添加代码:
#flaskapp.wsgi
import sys
sys.path.insert(0, '/var/www/html/flask_project')
from app import app as application
太好了！！现在我们需要为 Apache 启用 mod_wsgi 来与 Flask 应用程序交互。
为此，请访问/etc/Apache 2/sites-enabled/:
cd /etc/apache2/sites-enabled/
使用 nano 文本编辑器打开 conf 文件 000-default.conf ，在document root/var/www/html行下面添加代码:
WSGIDaemonProcess flask_project threads=5
WSGIScriptAlias / /var/www/html/flask_project/app.wsgi
<Directory flask_project>
WSGIProcessGroup flask_project
WSGIApplicationGroup %{GLOBAL}
Order deny,allow
Allow from all
</Directory>
Conf File
运行烧瓶应用程序
好了，现在重新启动 apache 服务器:
sudo service apache2 restart
并转到公共 DNS，网站将启动并运行！！
Blogss
与另一个 URL 类似
Blogs1
完美！
结论
您的 Flask 应用程序在云服务器上启动并运行。请尝试在云服务器上运行您自己的 Flask 应用程序，并让我们知道您的想法。下次再见了🙂
使用 Flask 部署 ML 模型
原文：https://www.askpython.com/python-modules/flask/deploy-ml-models-using-flask
在本文中，我们将讨论如何使用 Flask 部署 ML 模型。本文假设没有关于烧瓶库的先验知识。
什么是部署？
用非常简单的术语来说，部署意味着让您的代码可供最终用户使用。让我们举一个例子。你设计了一个你认为对社会有巨大价值的应用程序。您已经测试了您的应用程序，并且您的应用程序可以在您的本地计算机上完美运行。
但是其他用户怎么用你的 app 呢？简单。你需要在用户可访问的计算机(服务器)上运行你的应用。在服务器上测试和运行代码的整个过程称为部署。
在我们的例子中，我们不会在本地机器上部署机器学习模型。
什么是烧瓶？
" Flask 是一个轻量级的 WSGI web 应用框架。它旨在快速轻松地开始使用，并能够扩展到复杂的应用程序。它最初是一个简单的包装器，围绕着 Werkzeug 和 Jinja ，现在已经成为最流行的 Python web 应用程序框架之一。”
Flask 的一个更重要的特性是它不强制任何额外的依赖，让开发人员可以选择使用哪个库。要安装/更新 flask，您可以在终端中使用 pip 命令:
pip install -U Flask
注意: Linux 用户可能希望将 pip3 用于 python 3 版本。
使用 Flask 部署 ML 模型的步骤
让我们进入使用 Flask 库部署机器学习模型的步骤。
1。准备好你的模型
现在您已经安装了 Flask，接下来是我们需要部署的模型。如果你已经在笔记本 /IDE 中设计好了你的模型，现在是时候保存你训练好的模型了。需要注意的是，该模型在部署期间不会被训练。我们将使用多层感知，对 MNIST 数据集的图像进行分类。为了保存张量流模型，我们使用以下内容:
model.save('<path to the model>/my_model.h5')
我们的模型接收图像作为输入，并返回图像的标签。
Fig 1: Working of our model : The model takes in an image as input and returns result which is an integer.
2。设计我们的工作流程
现在我们有了一个训练好的模型，我们可以设计我们的服务器应该如何处理用户请求。以下是建议的模型:
- 用户使用 HTTP POST 请求将图像上传到服务器。
- 图像被接收并保存在服务器上。我们还可以检查一些潜在的安全威胁的图像。
- 保存的图像通过模型。
- 模型的结果以文本的形式返回给用户。
下面是总结它的流程图:
Fig 2: A flowchart describing the working of our model
注意:这是一个过于简化的模型。现实生活中的模型更难设计和实现，并且涉及创建复杂的数据管道，这超出了本文的范围。
3。烧瓶 API 编码
我们创建一个 python 文件 app.py 来运行我们的应用程序。
导入报表:
# os to handle saving/deleting images
import os
# Import the required functions from flask
from flask import Flask, request, flash, redirect, send_file
# TensorFlow for loading the model
import tensorflow as tf
创建我们的应用
# Creates a flask app with a name same as the file name
# we can refer to this flask app as 'app' in our program
app = Flask(__name__)
设置图像上传文件夹
# uploaded images are stored in 'images' folder
UPLOAD_FOLDER = './images'
# Setting a environment variable
app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
加载模型
# Assuming the model is saved in folder models as model_1.h5
model = tf.keras.models.load_model('models/model_1.h5')
我们应用的 REST API
我们的应用程序接收并向用户发送数据。为此，我们需要指定一组特定的规则。app decorator 将函数 upload_file()绑定到我们的应用程序。该函数被路由到基本 URL(指定为“/”)，唯一允许的方法是 POST，即用户可以上传到基本 URL。upload_file()处理文件上传的许多情况——从没有文件到正确的文件。
@app.route('/', methods=['POST'])
def upload_file():
if 'file' not in request.files:
flash('No file part')
return redirect(request.url)
file = request.files['file']
if file.filename == '':
flash('No selected file')
return redirect(request.url)
if file:
filename = secure_filename(file.filename)
filename = os.path.join(app.config['UPLOAD_FOLDER'], filename)
file.save(filename)
# Read from file and convert to tensor
img_tensor = tf.io.decode_image(filename)
results = model.predict(img_tensor)
# Delete the file
os.remove(filename)
return "\n[+] The number is : "+str(results)+"\n\n"
注意:与代码的其他部分不同，应用程序的这一部分会针对每个客户端请求反复运行。
4。运行应用程序
# If this file is run as standalone file
# The app will run in debug mode
if __name__ == '__main__':
app.run(debug=True)
启动并运行服务器
# If your file server name is app.py
python3 app.py
Fig 3: Staring the server
请注意，服务器运行在 http://127.0.0.1:5000/上，这是我们的应用程序端点。现在我们的应用程序已经在本地机器上运行了，我们只需使用 URL 就可以访问该应用程序。
上传图片
我们没有使用前端来让最终用户的生活更轻松。另一方面，这种将后端与前端分离的方法使得与其他独立的前端应用程序的交互更加容易。即使没有前端也可以使用我们的 curl 命令上传图像
curl -X POST -H "Content-Type: multipart/form-data" -F "[email protected]<file location>" http://127.0.0.1:5000/
用图像的位置替换<file location>。
Fig 4: Accessing the app using curl command from a terminal
结论
我们看到，我们可以轻松地在本地机器上部署我们的机器学习模型，因此连接到您网络的用户可以使用您的应用服务。为了让应用程序服务全天候工作，应用程序需要在您的计算机上全天候运行。在这种情况下，你可以考虑在 Heroku、DigitalOcean、Azure 等服务器上运行你的代码。我们将在后面的文章中讨论将代码部署到服务器。敬请关注。
在 VPS 上部署 Django 项目的全面指南
原文：https://www.askpython.com/django/deploying-django-project-on-vps
在本文中，我们将学习如何使用 Gunicorn 和 Ngnix Web 服务器软件在虚拟专用服务器(VPS)上部署 Django
注意:在本文中，我将部署我们在上一篇文章中构建的博客应用程序项目。如果你有自己的项目，你也可以使用它。
什么是 VPS？
VPS 代表虚拟专用服务器，是由各种托管公司作为服务出售的虚拟机。可以把它想象成独立的笔记本电脑 CPU 硬件，但是是原始形式。
像谷歌、亚马逊等各种公司提供云服务器(GCP、AWS 等)，这些服务器基本上位于不同的位置，你可以借它们来运行你部署的应用程序。
云服务器的优势:
- 服务器 24 小时运行–在本地主机(您的笔记本电脑)的情况下，您需要让它 24 小时运行，这是不切实际的。
- 可扩展性–如果您的存储空间已满，您可以在云端扩展存储空间
- 更安全–硬件盗窃是不可能的
- 可从任何电脑/笔记本电脑访问
在本教程中，我使用的是 AWS(亚马逊网络服务-云服务器)。你可以选择任何一家 VPS 提供商。
现在，部署在 VPS 上的 Django 应用程序必须完成以下工作:
- 宿主静态文件
- 处理 Http 请求
- 从崩溃中恢复
- 需要时扩大规模
为了执行所有这些任务，我们需要不同的软件:
- 一个网络服务器(像 Nginx)
- 一个 WSGI 应用服务器(像 Gunicorn)
- 您实际的 Web 应用程序(使用 Django 框架、flask 框架等编写)
这里像 Nginx 这样的 web 服务器处理域逻辑并接受 HTTP 请求。然后，适当的请求被发送到像 Gunicorn 一样的应用服务器。
Gunicorn ，将请求转换成 python 兼容的格式，以及负载平衡等其他特性。这些请求被发送到应用代码(在 Django) ，它执行网站的必要功能。
我们现在将分别研究它们
什么是 Web 服务器应用？
网络服务器软件用于托管互联网上的网站。它充当服务器和客户机之间的中间人。这些软件应用程序访问服务器上的物理文件，并将它们显示给客户端。
Web 服务器软件的例子有 Apache、NGINX 等。
在本文中，我们将使用 Nginx 服务器，它越来越多地被互联网上的大多数 web 应用程序使用
什么是 Gunicorn？
Gunicorn (G-unicorn)是一个 Python WSGI ( Web 服务器网关接口)服务器，充当 Web 服务器和 Web 应用程序之间的接口。Gunicorn 与我们的应用程序的 WSGI 文件进行交互。
Gunicorn 负责 web 服务器和我们的 Django 应用程序之间发生的一切。它执行各种任务:
- 可以与多个 web 服务器交互
- 平衡网站的负载流量
- 保持我们的 Web 应用程序的多个进程运行
在 VPS 上部署 Django 项目
首先，我们需要从 VPS 提供商那里选择一台服务器。他们有各种运行在不同操作系统上的服务器，如下所示:
Servers
在选择了所需的之后，您将需要经历一些步骤(对于不同的提供商是不同的)来运行和连接云服务器。
一旦设置好服务器，你将获得服务器的 IP 地址或公共 DNS ，稍后需要连接到云服务器。
1.连接到云服务器
我们使用 ssh 命令连接到服务器。现在，我们将从本地计算机连接到服务器操作系统。
- 使用 Mac 或 Linux :
在 shell 中，只需运行代码:
ssh [email protected]<server_IP>
- 使用窗口
对于 windows 操作系统，我们使用一款名为 PuTTY 的软件，你可以直接从互联网上下载。下载完成后，进入的云 IP ，点击打开。
PuTTY
我将用来访问我的服务器的云 IP/公共 DNS 是:
Public DNS
对于 AWS，我们也需要使用私有安全密钥。因此，根据 VPS 提供商的不同，您可能需要使用更多的命令来连接。
完成后，您将登录到云服务器操作系统。
Cloud Server
2.设置必要的设备
一旦服务器连接上，它就像你的新笔记本电脑。我们需要设置和安装必要的软件包。
因此，运行以下命令:
安装升级
sudo apt-get update
sudo apt-get upgrade
启动服务器后，务必更新系统。
安装 python-pip
然后，我们需要在系统上安装 python
sudo apt-get install python3-pip
之后，使用以下命令更新 pip
python3 -m pip install --upgrade pip
安装 Django
现在我们也必须安装 Django。
pip3 install django
部署 Django 项目
现在，在云服务器本身中，您可以使用以下代码创建和编码整个 django 项目:
django-admin startproject <project_name>
或者，您可以将计算机中的本地 Django 文件传输到云服务器。
为了传输文件，我们使用代码
scp -i <path/to/key> -r <path/to/file> [email protected]<public_DNS>:<path/to/destination>
Transfer Files
在像 AWS 这样的服务中，我们也需要插入一个安全密钥。如果您的 VPS 不需要密钥，那么只需在那里添加文件夹的路径。
修改 settings.py 文件
一旦 Django 项目被发送到服务器，我们需要在 settings.py 文件中做一些修改。因此，将目录更改到项目中，并使用以下命令打开 settings.py 文件:
cd <project_name>
nano <project_name>/settings.py
现在将 DEBUG 设置为 False，并在 ALLOWED_HOSTS 中添加服务器的公共 DNS。
Settings.py
另外，为静态文件添加以下代码:
STATIC_ROOT = os.path.join(BASE_DIR,'static/')
还要运行父项目文件夹中的命令，以收集所有静态文件
python3 manage.py collectstatic
这是我们用来将所有静态文件收集到项目文件夹中的过程。有关静态文件的更多信息，请查看 Django 静态文件文章。
4.安装 Gunicorn
现在我们将把 gunicorn 安装到我们的云服务器中:
pip3 install gunicorn
这是古尼龙目前的情况。我们现在将转移到 Nginx，看看如何将它与 Gunicorn 连接起来
4.安装 Nginx
使用以下命令在服务器上安装 nginx:
sudo apt-get install nginx
现在在目录/etc/nginx/sites-available/<下创建一个文件 project_name > 。因此编写代码:
sudo nano /etc/nginx/sites-available/<project_name>
在文件中添加以下代码:
server {
listen 80;
server_name 0.0.0.0;
location = /favicon.ico { access_log off; log_not_found off; }
location /static/ {
root /path_to_project/<project_folder_name>;
}
location / {
include proxy_params;
proxy_pass http://unix:/path_to_project/<project_name>/<project_name>.sock;
}
}
保存并退出。
启用上面创建的文件
要启用上述文件，请运行代码:
sudo ln -s /etc/nginx/sites-available/myproject /etc/nginx/sites-enabled
检查配置文件
现在，要检查上面的配置文件是否编写正确，请运行命令:
sudo nginx -t
如果一切都是正确的，您将得到以下消息
Configuration File
使用 Gunicorn 和 Nginx 运行网站
首先启动 Nginx web 服务器:
sudo service nginx restart
现在要运行我们的应用程序，我们需要用 Nginx 绑定 Gunicorn。
我们使用一个 UNIX 套接字将 Nginx 和 Gunicorn 绑定在一起。在上面的代码中，我们做了同样的事情:使用套接字绑定 Gunicorn 和 Nginx。
所以运行命令:
gunicorn --daemon --workers 3 --bind unix:/home/ubuntu/<project_name>/<project_name>.sock <project_name>.wsgi
就是这样！！现在，通过您的本地计算机浏览器，到您的 VPS 的公共 DNS 进行检查。服务器将启动并运行。
Admin Site
由于数据库数据不在服务器上，您需要再次创建超级用户。因此，使用 ctrl + c 停止 Gunicorn，然后进行必要的更改。
一旦完成，使用与上面相同的命令运行 Gunicorn，您就可以开始了！！
Blog App
请看我们的 Django 博客应用程序现在运行在 AWS 云服务器上。
通过 GitHub 导入项目
您还可以使用 GitHub 将 Django 项目导入到云服务器上。通过这种方式，你可以在本地电脑上完成你的项目，然后简单地使用 GitHub 将整个项目安装到 loud 服务器上。
- 引用: 上传已有项目到 GitHub
- 引用: 使用命令行从 GitHub 导入项目
结论
就这样，伙计们！您的 Django 应用程序成功地部署到了 VPS 上。我希望你从这篇文章中获得了足够的知识。
在下一篇文章中，我们将看到 Django 框架提供的扩展
Python 中的深度优先迭代深化(DFID)算法
原文：https://www.askpython.com/python/examples/depth-first-iterative-deepening-dfid
你好读者，这篇文章让我们了解了到底什么是深度优先迭代深化(DFID)也称为迭代深化搜索(IDS)。它的优点、应用和 python 实现。
什么是深度优先迭代深化搜索？
深度优先迭代深化是一种迭代搜索技术，结合了深度优先搜索 (DFS)和广度优先搜索 (BFS)的优点。
当搜索图形表示中的特定节点时，广度优先搜索需要大量空间，因此增加了空间复杂度，深度优先搜索花费更多的时间，因此这种搜索策略具有更多的时间复杂度，并且深度优先搜索不总是找到最便宜的路径。为了克服深度优先搜索和宽度优先搜索的所有这些缺点，实现了深度优先迭代深化搜索。
DFIDS 是如何工作的？
DFID 会先扩展给定深度的所有节点，然后再扩展更深的任何节点。这样就保证了找到从起点到目标状态的最短路径或最优解。DFID 算法的工作原理如图所示
Dfid
在任何给定时间，它都在执行 DFS，并且从不搜索深度超过“d”的内容。因此，它使用的空间是 O(d)。DFID 的缺点是它在到达目标深度之前执行了浪费的合成。
rfid 算法
- 输入:开始和目标状态
- 局部变量:找到
- 方法
- 初始化 d = 1，发现=假
- while (FOUND = False) do
- 从起点到深度 d 执行 DFS。
- 如果获得了目标状态，则发现=真，否则丢弃在深度 d 的搜索中生成的节点。
- d = d + 1
- 如果 FOUND = true，则返回深度。
- 停止
深度优先迭代深化在 Python 中的实现
实施图
class Node:
def __init__(self, val=None):
self.val = val
self.left = None
self.right = None
def get_root():
values = iter([3, 8, 6, 9, None, None, 11, 10, None, None,
12, None, None, 7, None, None, 4, 5, None, None, 13, None, None])
def tree_recur(itr):
val = next(itr)
if val is not None:
node = Node(val)
node.left = tree_recur(itr)
node.right = tree_recur(itr)
return node
return tree_recur(values)
DFIDS 的功能
def dfids():
root = get_root()
res = float("inf")
def dfids_search(node, depth, limit):
if depth <= limit and node is not None:
val = node.val
if val == 12:
nonlocal res
res = min(res, depth)
else:
dfids_search(node.left, depth + 1, limit)
dfids_search(node.right, depth + 1, limit)
for limit in range(1,5):
dfids_search(root, 0, limit)
if res < float("inf"):
return res
return -1
if __name__ == "__main__":
print("\nShortest Depth: ", dfids())
深度优先迭代深化的应用
深度优先迭代深化搜索用于为给定的问题陈述寻找最优解或最适合的路径。当提供大的状态空间并且没有提及关于解的深度的信息时，优选使用这种搜索策略。以下是 DFIDS 的一些应用
- 人工智能和数据科学-分析网络
- 用独特的解决方案解谜(例如:数独)
- 检测图中的圈。
- 排序有向无环图
- n 皇后问题
摘要
在本文中，我们深入研究了深度优先迭代深化搜索，它的重要性和它的实现。
使用 Python 的深度优先搜索算法
原文：https://www.askpython.com/python/examples/depth-first-search-algorithm
亲爱的读者，在本文中，我将带你了解深度优先搜索(DFS)的概念。这是一个图的概念，是很多竞争性编码考试中常见的问题。因此，让我们看看如何使用 Python 创建一个 DFS 遍历。
什么是深度优先搜索？
深度优先搜索是一种利用堆栈数据结构遍历图形和树的算法。深度优先搜索的概念来源于“深度”这个词。该树遍历到一个分支的深度，然后返回到其余的节点。
考虑一个空的“堆栈”,它包含每次迭代访问的节点。我们在这里的任务如下:
- 从根节点开始，将其推送到堆栈上。
- 检查树的任何相邻节点，并选择一个节点。
- 遍历所选节点的整个分支，并将所有节点推入堆栈。
- 在到达分支的末端(没有更多相邻节点)即第 n 个叶节点时，向后移动一步并寻找第 n-1 个节点的相邻节点。
- 如果第 n-1 个节点有相邻的节点，则遍历这些分支并将节点推送到堆栈上。
深度优先搜索的概念说明
让我们看看下面的示例图:
Example Graph
是根节点。既然 A 被访问了，我们就把它推到堆栈上。
Stack : A
我们转到分支 A-B，B 没有被访问，所以我们转到 B，把 B 推送到栈上。
Stack : A B
现在，我们已经到达 A-B 分支的末尾，我们移动到第 n-1 个节点 A。我们现在将查看 A 的相邻节点 S。访问 S 并将其推送到堆栈上。现在，您必须遍历 S-C-D 分支，直到深度即到达 D，并将 S、C、D 标记为已访问。
Stack: A B S C D
因为 D 没有其他相邻节点，所以移回 C，遍历其相邻分支 E-H-G 到深度，并将它们推送到堆栈上。
Stack : A B S C D E H G
到达 D 时，只有一个相邻节点 ie F 没有被访问。把 F 也推到堆栈上。
Stack : A B S C D E H G F
这个堆栈本身就是 DFS 的遍历。
Python 中编码深度优先搜索算法
你一定知道，有很多方法来表示一个图，也就是邻接表和邻接矩阵。
所以在下面的例子中，我为图中的每个节点定义了一个邻接表。
graph1 = {
'A' : ['B','S'],
'B' : ['A'],
'C' : ['D','E','F','S'],
'D' : ['C'],
'E' : ['C','H'],
'F' : ['C','G'],
'G' : ['F','S'],
'H' : ['E','G'],
'S' : ['A','C','G']
}
注意:这个邻接表可以由用户输入，不需要硬编码。
现在，我们将定义我们的 DFS 函数，它接受 3 个参数作为输入——图(邻接表)、一个节点和一个被访问节点的列表。
如果当前节点未被访问，即不在已访问列表中，将其标记为已访问，并将其添加到已访问列表中。
移动到下一个节点，然后递归地将这个节点传递给 DFS 函数。这样，每个节点移动到一定深度，并将其打印为 DFS 输出。
def dfs(graph, node, visited):
if node not in visited:
visited.append(node)
for k in graph[node]:
dfs(graph,k, visited)
return visited
visited = dfs(graph1,'A', [])
print(visited)
完整的代码和输出
graph1 = {
'A' : ['B','S'],
'B' : ['A'],
'C' : ['D','E','F','S'],
'D' : ['C'],
'E' : ['C','H'],
'F' : ['C','G'],
'G' : ['F','S'],
'H' : ['E','G'],
'S' : ['A','C','G']
}
def dfs(graph, node, visited):
if node not in visited:
visited.append(node)
for k in graph[node]:
dfs(graph,k, visited)
return visited
visited = dfs(graph1,'A', [])
print(visited)
上述代码的输出如下:
['A', 'B', 'S', 'C', 'D', 'E', 'H', 'G', 'F']
结论
我希望你已经学习了这篇关于 DFS 算法的教程，并且能够理解代码和例子。一定要用你身边的纸和笔来尝试，以便更好地理解这些遍历。
图中深度优先搜索
原文：https://www.askpython.com/python/examples/depth-first-search-in-a-graph
深度优先搜索是一种遍历技术，在这种技术中，我们遍历一个图并精确地打印一次顶点。在本文中，我们将研究并实现 python 中遍历图的深度优先搜索。
推荐阅读:用 Python 实现一个图
深度优先搜索算法是什么？
在深度优先搜索中，我们从任意一个顶点开始，遍历图中的每个顶点一次。对于每个选定的顶点，我们首先打印该顶点，然后移动到它的一个邻居，打印它，然后移动到它的一个邻居，依此类推。这个过程一直持续到遍历完所有顶点。当使用深度优先搜索遍历一个图时，看起来我们是在从所选顶点开始遍历所有顶点的路径上移动。
从下面的例子可以清楚地理解这一点。
Graph Implementation In Python- Askpython
如果我们从 0 开始以深度优先的方式访问上图，我们将按照 0 –> 3 –> 4 –> 5 –> 2 –> 1 的顺序处理顶点。也可能有替代遍历。如果我们在 3 之前处理 1，而我们在 0，那么图的 BFS 遍历将看起来像:0 –> 1 –> 3-> 4-> 2-> 5。
图的深度优先搜索算法
由于我们对深度优先搜索有了一个总体的概念，我们现在将为图的 DFS 遍历制定算法。这里，我们将假设图的所有顶点都可以从起始顶点到达。
假设我们已经得到了一个邻接表表示的图和一个起始顶点。现在我们必须以深度优先搜索的方式遍历图形。
我们将首先打印起始顶点的值，然后我们将移动到它的一个邻居，打印它的值，然后移动到它的一个邻居，等等，直到图形的所有顶点都被打印出来。
因此，我们的任务是打印图的顶点，从第一个顶点开始，直到每个顶点都按顺序遍历。为了实现这个概念，我们将使用后进先出技术，即堆栈来处理图形。此外，我们将使用一个访问过的顶点列表来检查顶点是否在过去被遍历过，这样就不会有顶点被打印两次。
我们将打印一个顶点，将其添加到访问过的顶点列表中，并将其邻居放入堆栈中。然后，我们会从栈中一个一个的取出顶点，打印出来后添加到访问过的列表中，然后我们会把它们的邻居放入栈中。下面是描述整个过程的图的深度优先搜索遍历算法。
Algorithm DFS:
Input: Graph(Adjacency list) and Source vertex
Output: DFS traversal of graph
Start:
1.Create an empty stack S.
2.Create an empty list to keep record of visited vertices.
3.Insert source vertex into S, mark the source as visited.
4.If S is empty, return. Else goto 5.
5.Take out a vertex v from S.
6.Print the Vertex v.
7.Insert all the unvisited vertices in the adjacency list of v into S and mark them visited.
10.Goto 4.
Stop.
深度优先搜索遍历图在 python 中的实现
现在我们已经熟悉了这些概念和算法，我们将实现图的深度优先搜索算法，然后我们将执行上面例子中给出的图的算法。
graph = {0: [1, 3], 1: [0, 2, 3], 2: [4, 1, 5], 3: [4, 0, 1], 4: [2, 3, 5], 5: [4, 2], 6: []}
print("The adjacency List representing the graph is:")
print(graph)
def dfs(graph, source):
S = list()
visited_vertices = list()
S.append(source)
visited_vertices.append(source)
while S:
vertex = S.pop()
print(vertex, end="-->")
for u in graph[vertex]:
if u not in visited_vertices:
S.append(u)
visited_vertices.append(u)
print("DFS traversal of graph with source 0 is:")
dfs(graph, 0)
输出:
The adjacency List representing the graph is:
{0: [1, 3], 1: [0, 2, 3], 2: [4, 1, 5], 3: [4, 0, 1], 4: [2, 3, 5], 5: [4, 2], 6: []}
DFS traversal of graph with source 0 is:
0-->3-->4-->5-->2-->1-->
如果你还不能理解代码的执行，这里有一个修改的 DFS 算法解释每一步。
graph = {0: [1, 3], 1: [0, 2, 3], 2: [4, 1, 5], 3: [4, 0, 1], 4: [2, 3, 5], 5: [4, 2], 6: []}
print("The adjacency List representing the graph is:")
print(graph)
def dfs_explanation(graph, source):
S = list()
visited_vertices = list()
S.append(source)
visited_vertices.append(source)
while S:
vertex = S.pop()
print("processing vertex {}.".format(vertex))
for u in graph[vertex]:
if u not in visited_vertices:
print("At {}, adding {} to Stack".format(vertex, u))
S.append(u)
visited_vertices.append(u)
print("Visited vertices are:", visited_vertices)
print("Explanation of DFS traversal of graph with source 0 is:")
dfs_explanation(graph, 0)
输出:
The adjacency List representing the graph is:
{0: [1, 3], 1: [0, 2, 3], 2: [4, 1, 5], 3: [4, 0, 1], 4: [2, 3, 5], 5: [4, 2], 6: []}
Explanation of DFS traversal of graph with source 0 is:
processing vertex 0.
At 0, adding 1 to Stack
At 0, adding 3 to Stack
Visited vertices are: [0, 1, 3]
processing vertex 3.
At 3, adding 4 to Stack
Visited vertices are: [0, 1, 3, 4]
processing vertex 4.
At 4, adding 2 to Stack
At 4, adding 5 to Stack
Visited vertices are: [0, 1, 3, 4, 2, 5]
processing vertex 5.
Visited vertices are: [0, 1, 3, 4, 2, 5]
processing vertex 2.
Visited vertices are: [0, 1, 3, 4, 2, 5]
processing vertex 1.
Visited vertices are: [0, 1, 3, 4, 2, 5]
结论
在本文中，我们看到了图的深度优先搜索遍历算法背后的基本概念，设计了算法，然后用 python 实现了它。请继续关注更多内容丰富的文章。
Python 中立体图像的深度图
原文：https://www.askpython.com/python/examples/depth-map-stereo-images
在本教程中，我们将看看如何使用 OpenCV 包在 Python 中从立体图片制作深度图。但首先，让我们掌握一下立体图片和图像深度的概念。
当我们走路或跑步时，我们观察到离我们近的物体比离我们远的物体移动得快。这种潜在的效应被称为“视差”
这种现象可以用来从任何景象获得几何信息。我们可以从不同的角度，从同一个竞技场的许多照片中估计各种各样的事情，其中之一是组件的空隙。
这个距离被称为图像的深度，这些图片被称为立体图像。我们现在可以通过研究这些渲染图之间的点的跨度来确定这些区域与相机的距离。
导入库/模块
让我们从导入用例所需的库开始。我们将使用 numpy 库、 OpenCV 和 matplotlib 进行绘图。
import numpy as np
import cv2
from matplotlib import pyplot as plt
加载立体图像
现在让我们加载立体图像。
imgL = cv2.imread('input_images/Stereo_Image_1.jpg',0)
imgR = cv2.imread('input_images/Stereo_Image_2.jpg',0)
Stereo Image 1
Stereo Image 2
创建深度图
将使用StereoBM_create()方法来生成深度图。我们可以根据需要调整设置。numDisparities 接受最大为 255(可被 16 整除)的数字，但 blockSize 接受最大为 25 的值。
stereo = cv2.StereoBM_create(numDisparities=96, blockSize=15)
disparity = stereo.compute(imgL,imgR)
plt.figure(figsize = (20,10))
plt.imshow(disparity,'disparity')
plt.xticks([])
plt.yticks([])
Depthmap Image Output
我们可以使用深度图来计算深度。这包括相机安排和他们与图片差异的相互作用。这超出了本教程的范围，因此我们不能继续下去。
这就完成了关于如何使用 OpenCV 在 Python 中从立体图片构建深度图的教程。由于您必须通过分析选择适当的地图参数，因此大部分工作仍由您来完成。
结论
恭喜你！您刚刚学习了如何使用 OpenCV 包在 Python 中从立体图片制作深度图。希望你喜欢它！😇
喜欢这个教程吗？无论如何，我建议你看一下下面提到的教程:
- 使用直方图可视化图像中的颜色–Python OpenCV
- 使用 OpenCV 绘制形状——完整的操作指南
- 使用网络摄像头和 Python OpenCV[简易指南]进行实时素描
- 使用 OpenCV 的 Python 信用卡读卡器
感谢您抽出时间！希望你学到了新的东西！！😄
Python 中使用 SymPy 的衍生工具
原文：https://www.askpython.com/python/examples/derivatives-in-python-sympy
Python 中如何计算导数？在本文中，我们将使用 Python SymPy 库来研究衍生品。
什么是衍生品？
导数是微积分的基本工具。这对于优化带有梯度下降的损失函数非常有用在机器学习中仅仅因为导数才成为可能。
假设我们有一个依赖于 x 的函数 y = f(x ),那么这个函数的求导意味着函数值 y 随着 x 的变化而变化的速率。
这绝不是一篇关于衍生品基本面的文章，不可能。微积分是一种不同的野兽，需要特别注意。我想你对微积分有一定的了解。本文旨在演示如何使用 Sympy 库来区分函数。
使用 SymPy 在 Python 中求解导数
Python SymPy 库是为符号数学而创建的。SymPy 项目旨在成为一个全功能的计算机代数系统(CAS)，同时保持代码简单易懂。让我们看看如何使用 SymPy 在 Python 中计算导数。
1.使用 PIP 安装 SymPy
SymPy 的用途不仅仅是计算导数，但现在，我们将专注于导数。让我们使用 PIP 来安装 SymPy 模块。
# pip install sympy
2.用 SymPy diff()求解微分
对于微分，SymPy 为我们提供了diff方法来输出函数的导数。
- 假设我们有一个函数: f ( x ) = x
- 函数 w.r.t x 的导数: f'(x) = 2x
让我们看看如何使用 SymPy diff()函数来实现这一点。
#Importing sympy
from sympy import *
# create a "symbol" called x
x = Symbol('x')
#Define function
f = x**2
#Calculating Derivative
derivative_f = f.diff(x)
derivative_f
声明一个符号类似于说我们的函数有一个变量' x '或者简单地说函数依赖于 x。
3.用 Python 求解导数
SymPy 有lambdify函数来计算接受符号和函数作为参数的函数的导数。让我们看一个用辛比函数计算导数的例子。
from sympy import *
# create a "symbol" called x
x = Symbol('x')
#Define function
f = x**2
f1 = lambdify(x, f)
#passing x=2 to the function
f1(2)
输出:4
Python SymPy 中的基本衍生规则
我们可以用某些规则来计算可微函数的导数。
一些最常见的规则是:
- 权力规则
- 乘积规则
- 链式法则
- 商数法则
让我们深入研究如何实际使用 sympy 来计算一般微分规则所隐含的导数。
1.权力规则
一般情况下:f'(x^n ) = nx^((n-1))
举个例子，我们有这样一个函数:f(x) = x⁵
它的导数将是:f '(x)= 5x^((5-1))= 5x⁴
import sympy as sym
#Power rule
x = sym.Symbol('x')
f = x**5
derivative_f = f.diff(x)
derivative_f
Power Rule Output
2.乘积规则
设 u(x)和 v(x)是可微函数。那么函数 u(x)v(x)的乘积也是可微的。
(uv)′ = u′v + uv′
例如:f(x) = exp(x)*cos(x)
import sympy as sym
#Product Rule
x = sym.Symbol('x')
f = sym.exp(x)*sym.cos(x)
derivative_f = f.diff(x)
derivative_f
Product Rule Output
3.链式法则
链式法则计算函数合成的导数。
- 比方说，我们有一个函数 h(x) = f( g(x))
- 然后根据链式法则:h′(x)= f′(g(x))g′(x)
- 例如:f(x) = cos(x**2)
这个过程也可以推广到商法则。现在很明显，只有函数发生了变化，而应用程序流程保持不变，剩下的由库自己处理。
import sympy as sym
#Chain Rule
x = sym.Symbol('x')
f = sym.cos(x**2)
derivative_f = f.diff(x)
derivative_f
Chain Rule Output
使用 SymPy 的 Python 偏导数
我们上面看到的例子只有一个变量。但是我们更有可能遇到不止一个变量的函数。这种导数通常被称为偏导数。
多变量函数的偏导数是在所有其他变量保持不变的情况下对一个变量的导数。
举例: x**4+x*y**4
我们来部分区分一下 Python w.r.t x 中的上述导数。
import sympy as sym
#Derivatives of multivariable function
x , y = sym.symbols('x y')
f = x**4+x*y**4
#Differentiating partially w.r.t x
derivative_f = f.diff(x)
derivative_f
Partial Differentiation w.r.t X
当变量个数大于 1 时，我们使用symbols方法。现在，对 Python 中的导数进行部分 w . r . t . y .微分
import sympy as sym
#Derivatives of multivariable function
x , y = sym.symbols('x y')
f = x**4+x*y**4
#Differentiating partially w.r.t y
derivative_f = f.diff(y)
derivative_f
Partial Differentiation w.r.t Y
代码完全相似，但是现在 y 作为输入参数被传递到diff方法中。
我们可以选择先对函数 w . r . t . x，再对 y，进行部分求导。
import sympy as sym
#Derivatives of multivariable function
x , y = sym.symbols('x y')
f = x**4+x*y**4
#Differentiating partially w.r.t x and y
derivative_f = f.diff(x,y)
derivative_f
Partial Differentiation w.r.t X And Y
摘要
这篇文章绝不是一门关于导数或如何用 Python 求解导数的课程，而是一篇关于如何利用 python SymPy 包对函数进行微分的文章。衍生品是令人敬畏的，你肯定应该得到它背后的想法，因为它们在机器学习和其他领域发挥着至关重要的作用。
下一步是什么？
资源
在 Python OpenCV 中检测形状的拐角
原文：https://www.askpython.com/python-modules/detecting-corners-in-python-opencv
嘿伙计们！在本教程中，我们将教你如何使用 Python 的 OpenCV 包来识别图像中的角点。OpenCV 中的算法可用于检测图像中的角点。
角点检测简介
拐角是在其局部附近具有两个主导的和相对的边缘方向的位置。换句话说，角可以定义为两条边的交点，其中一条边代表图像亮度的急剧变化。
CornerDetect Demo
角点是图像中最重要的部分，它们有时被称为兴趣点，因为它们对平移、旋转和光照不敏感。
用 Python 实现角点检测
步骤 1:导入所有必需的模块/库
import numpy as np
import cv2
from matplotlib import pyplot as plt
步骤 2:加载图像并转换成灰度图像
下一步涉及使用 cv2.imread 函数加载图像，该函数将采用需要加载的图像的路径。为了使处理更容易，我们将使用 cv2.cvtColor 函数将图像转换为灰度图像。
我们将借助 matplotlib 库的 plt.imshow 方法来显示图像。
img = cv2.imread('sample_shape1.png')
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
plt.figure(figsize=(10,10))
plt.imshow(img)
plt.show()
Sample Shape CornerDetection
步骤 3:检测图像的角点
Shi-Tomasi 方法被cv2 . goodfeaturestotrack()函数用来确定图像中 N 个最强的角。
corners = cv2.goodFeaturesToTrack(gray, 27, 0.01, 10)
corners = np.int0(corners)
步骤 4:绘制角点
在每个角落，我们的目标是使用下面提到的代码片段绘制一个简单的红点。并在最后部分绘制最终的角点检测图像。
for i in corners:
x, y = i.ravel()
cv2.circle(img, (x, y), 4, 200, -1)
plt.figure(figsize=(10,10))
plt.imshow(img)
plt.show()
Detect Cornes Output 1
样本输出 2
Detect Cornes Output 2
结论
恭喜你！您刚刚学习了如何使用 OpenCV 构建 python 程序来检测图像的角点。希望你喜欢它！😇
喜欢这个教程吗？无论如何，我建议你看一下下面提到的教程:
感谢您抽出时间！希望你学到了新的东西！！😄
使用 Python 检测帕金森病
原文：https://www.askpython.com/python/examples/detecting-parkinsons-disease
你好，学习伙伴！今天，我们正在使用 Python 基于一些预先获得的信息构建一个基本的 ML 模型来检测帕金森病。
因此，让我们首先了解帕金森病和我们将用于我们模型的数据集，可以在这里找到。我们将在我们的项目中使用parkinson.data文件。
帕金森病是一种中枢神经系统疾病，会影响身体的运动。到目前为止，这种疾病还没有切实可行的治疗方法。
导入所需的库
任何项目的第一步都是将所有必要的模块导入我们的项目。我们需要一些基本模块，如 numpy 、 pandas 和 matplotlib 来分别准备、加载和绘制数据。
然后我们还需要一些 sklearn 模型和函数，用于训练和估计精度。最后但同样重要的是，我们将使用xgboost库。
XGBoost 库是一个基于决策树的梯度推进模型，旨在提高系统的速度和精度。
import numpy as np
import pandas as pd
import os, sys
from sklearn.preprocessing import MinMaxScaler
from xgboost import XGBClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
加载数据集
下一步是将我们之前下载的数据加载到与代码文件相同的文件夹中。同样，我们使用 pandas 模块，其代码如下所示。
dataframe=pd.read_csv('parkinsons.csv')
print("The shape of data is: ",dataframe.shape,"\n")
print("FIRST FIVE ROWS OF DATA ARE AS FOLLOWS: \n")
dataframe.head()
程序的输出显示了数据集的前五行，该数据集总共由 24 列和 195 个数据点组成。下一步是将标签和数据相互分离。
下面提到了相同的代码。这里的标签列是状态列。
data=dataframe.loc[:,dataframe.columns!='status'].values[:,1:]
label=dataframe.loc[:,'status'].values
标准化数据
下一步是缩放-1 和+1 之间的所有数据点。我们将使用最小最大缩放器来转换特征，并将它们作为参数缩放到给定的范围。fit_transform函数有助于拟合数据，然后对其进行转换/标准化。
不需要缩放标签，因为它们已经只有两个值，即 0 和 1。相同的代码如下所示。
Normalizing_object = MinMaxScaler((-1,1))
x_data = Normalizing_object.fit_transform(data)
y_data=label
训练-测试数据分割
下一步是根据 80-20 法则将数据分为训练和测试数据，其中 80%的数据用于训练，其余 20%用于测试。
我们将使用 sklearn 模块的train_test_split函数来实现同样的功能。代码如下所述。
x_train,x_test,y_train,y_test=train_test_split(x_data,y_data,test_size=0.2)
xgb 分类器的初始化和模型的训练
我们的数据现在已经准备好接受训练并适合 xbg 分类器。为此，我们将创建一个分类器对象，然后将训练数据放入分类器。
相同的代码如下所示。
model=XGBClassifier()
model.fit(x_train,y_train)
输出显示了分类器的全部训练信息，现在我们准备好对测试数据进行预测，然后获得准确性。
获得预测和准确性
下一步也是最后一步是获得测试数据集的预测，并估计我们模型的准确性。完成同样工作的代码如下所示。
predictions=model_obj.predict(x_test)
print(accuracy_score(y_test,predictions)*100)
运行代码后，我们知道这个模型已经超过了97.43%精度，这很好，对吗？！所以我们走吧！我们建立了自己的帕金森病分类器。
结论
在本教程中，我们学习了如何根据各种因素检测个体中帕金森病的存在。
对于这个项目，我们使用 xgb 分类器进行快速准确的检测。模型给了我们超过97.43%的准确率，太棒了！
感谢您的阅读！
Python 中异常值的检测和移除——一本易于理解的指南
原文：https://www.askpython.com/python/examples/detection-removal-outliers-in-python
读者朋友们，你们好！在我们的数据处理和分析系列中，今天我们将看看 Python 中的异常值检测和移除。
所以，让我们开始吧！
Python 中有哪些离群值？
在深入探讨离群值的概念之前，让我们先了解一下原始数据的来源。
提供给系统的原始数据通常是通过调查和从网络上的实时操作中提取数据而生成的。这可能引起数据的变化，并且在记录数据时存在测量误差的可能性。
这是离群值出现的时候。
离群值是远离数据集的其余数据值的一个点或一组数据点。也就是说，它是出现在数据集中数据值总体分布之外的数据点。
异常值只可能出现在连续值中。因此，异常值的检测和移除仅适用于回归值。
基本上，离群值似乎偏离了数据元素的整体适当且结构良好的分布。可以认为是出现在远离类别或总体的异常分布。
理解了离群值的概念后，现在让我们在接下来的小节中关注删除离群值的需要。
为什么有必要从数据中删除异常值？
如上所述，异常值是远离通常数据分布的数据点，并对整体数据分布产生以下影响:
- 影响数据的整体标准偏差。
- 处理数据的总体平均值。
- 将数据转换成倾斜形式。
- 导致机器学习模型的精度估计出现偏差。
- 影响数据集的分布和统计。
由于上述原因，在对数据集建模之前，有必要检测并去除异常值。
异常值检测——IQR 方法
可以通过以下方法检测数据集中的异常值:
- Z 分数
- 散点图
- 四分位距(IQR)
在本文中，我们将实现 IQR 方法来检测和处理异常值。
IQR 是四分位数范围的缩写。它测量数据值的统计离差，作为总体分布的度量。
IQR 分别相当于第一个四分位数(Q1)和第三个四分位数(Q3)之差。
这里，Q1 指的是第一个四分位数，即 25%，Q3 指的是第三个四分位数，即 75%。
我们将使用箱线图来检测和可视化数据集中存在的异常值。
箱线图以四分位数的形式描述了数据的分布，由以下部分组成
- Q1-25%
- Q2-50%
- Q3-75%
- 下限/晶须
- 上须/束缚
BoxPlot
位于下限以下和上限以上的任何数据点都被视为异常值。
现在让我们实现箱线图来检测下例中的异常值。
举例:
最初，我们已经将数据集导入到环境中。你可以在这里找到数据集。
import pandas
import numpy
BIKE = pandas.read_csv("Bike.csv")
此外，我们将变量分为数值和分类值。
numeric_col = ['temp','hum','windspeed']
categorical_col = ['season', 'yr', 'mnth', 'holiday', 'weekday', 'workingday', 'weathersit']
我们在数字变量上使用boxplot() function应用箱线图，如下所示:
BIKE.boxplot(numeric_col)
Detection Of Outlier-BoxPlot
如上所述，变量“风速”包含位于下限以上的异常值。
剔除异常值
现在是处理异常值的时候了，这些异常值是我们在上一节中使用箱线图检测到的。
使用 IQR，我们可以遵循以下方法用空值替换异常值:
- 计算第一个和第三个四分位数(Q1 和第三季度)。
- 进一步，评估四分位距， IQR = Q3-Q1 。
- 估计下界，下界= Q1*1.5
- 估计上界，上界= Q3*1.5
- 用空值替换位于下限和上限之外的数据点。
for x in ['windspeed']:
q75,q25 = np.percentile(BIKE.loc[:,x],[75,25])
intr_qr = q75-q25
max = q75+(1.5*intr_qr)
min = q25-(1.5*intr_qr)
BIKE.loc[BIKE[x] < min,x] = np.nan
BIKE.loc[BIKE[x] > max,x] = np.nan
因此，我们使用numpy.percentile() method来计算 Q1 和 Q3 的值。此外，我们已经用作为空值的numpy.nan替换了异常值。
用 nan 替换了异常值后，现在让我们使用下面的代码检查空值或缺失值的总和:
BIKE.isnull().sum()
数据集中每一列的空值/异常值的总数:
season 0
yr 0
mnth 0
holiday 0
weathersit 0
temp 0
hum 0
windspeed 5
cnt 0
dtype: int64
现在，我们可以使用以下任何技术来处理空值:
- 用平均值、中值或 Knn 估算值估算缺失值。
- 删除空值(如果比例相对较小)
这里，我们将使用pandas.dataframe.dropna()函数删除空值
BIKE = BIKE.dropna(axis = 0)
处理完异常值后，现在让我们检查数据集中是否存在缺失值或空值:
BIKE.isnull().sum()
输出—
season 0
yr 0
mnth 0
holiday 0
weathersit 0
temp 0
hum 0
windspeed 0
cnt 0
dtype: int64
因此，数据集中存在的所有异常值都已被检测和处理(移除)。
结论
到此，我们就结束了这个话题。如果你遇到任何问题，欢迎在下面评论。
更多与 Python 相关的文章。敬请关注，在那之前，祝你学习愉快！！🙂
Python 中的糖尿病预测——简单指南
原文：https://www.askpython.com/python/examples/diabetes-prediction-in-python
嘿伙计们！在本教程中，我们将学习如何使用深度学习技术在 Python 中使用 Keras 的深度学习 API 来构建糖尿病预测。
用 Python 实现糖尿病预测
为此，我们将利用一个可用的数据集，并构建一个深度神经网络架构。数据集可在 这里 下载。
您可以在下载数据集后研究它，您会注意到它被分为 0 和 1。让我们继续用 TensorFlow 和 Keras 在 Python 中实现我们的模型。
我希望您已经在本地系统上安装了所有的库。如果没有，不用担心，你可以打开 Google Colab，和我一起练习这一课。
步骤 1–导入模块
现在，让我们将必要的 Python 库导入到笔记本中。
Keras API 已经包括 Python 的 TensorFlow 深度学习包，这在糖尿病预测挑战中至关重要。
import numpy as np
import pandas as pd
import tensorflow as tf
from keras.layers import Dense,Dropout
from sklearn.model_selection import train_test_split
import matplotlib as mlp
import matplotlib.pyplot as plt
%matplotlib inline
from sklearn.preprocessing import StandardScaler
步骤 2–加载数据集
我们现在准备开始导入数据集。在下一段代码中，我们导入数据集并使用 head()方法获取前五个数据点。
data=pd.read_csv("pima-indians-diabetes.csv")
data.head()
Diabetes Dataset Top5
步骤 3–重命名列
你可能已经意识到这些专栏毫无意义，对吗？现在让我们重命名列名。
又念:头()在熊猫
data = data.rename(index=str, columns={"6":"preg"})
data = data.rename(index=str, columns={"148":"gluco"})
data = data.rename(index=str, columns={"72":"bp"})
data = data.rename(index=str, columns={"35":"stinmm"})
data = data.rename(index=str, columns={"0":"insulin"})
data = data.rename(index=str, columns={"33.6":"mass"})
data =data.rename(index=str, columns={"0.627":"dpf"})
data = data.rename(index=str, columns={"50":"age"})
data = data.rename(index=str, columns={"1":"target"})
data.head()
Renamed Columns Diabetes Dataset Top5
步骤 4–分离输入和输出
X = data.iloc[:, :-1]
Y = data.iloc[:,8]
X 和 Y 值看起来有点像这样:
Input N Output Diabetes Dataset
我们将数据集分为输入数据集和目标数据集，这意味着前八列将作为模型的输入要素，最后一列将作为目标类。
步骤 5–训练-测试数据分割
下一步包括将训练和测试分成数据，然后将数据标准化，使以后的计算更简单。
X_train_full, X_test, y_train_full, y_test = train_test_split(X, Y, random_state=42)
X_train, X_valid, y_train, y_valid = train_test_split(X_train_full, y_train_full, random_state=42)
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_valid = scaler.transform(X_valid)
X_test = scaler.transform(X_test)
步骤 6–建立模型
我们从使用一个随机种子生成一个伪随机数并将其设置到 tf 图开始。然后，我们将使用顺序模型，以及模型中的一些丢弃层，以避免数据的过度拟合。
np.random.seed(42)
tf.random.set_seed(42)
model=Sequential()
model.add(Dense(15,input_dim=8, activation='relu'))
model.add(Dense(10,activation='relu'))
model.add(Dense(8,activation='relu'))
model.add(Dropout(0.25))
model.add(Dense(1, activation='sigmoid'))
步骤 7–模型的训练和测试
现在，让我们继续训练我们的模型，然后在测试数据集上拟合模型。
model.compile(loss="binary_crossentropy", optimizer="SGD", metrics=['accuracy'])
model_history = model.fit(X_train, y_train, epochs=200, validation_data=(X_valid, y_valid))
你会意识到，将训练 200 个时代的模型，并使用二元交叉熵损失函数和 SGD 优化器。
结论
恭喜你！您刚刚学习了如何使用 Python 编程语言构建糖尿病预测器。希望你喜欢它！😇
喜欢这个教程吗？无论如何，我建议你看一下下面提到的教程:
感谢您抽出时间！希望你学到了新的东西！！😄
用 Python 诊断发热[简易 CLI 方法]
原文：https://www.askpython.com/python/diagnose-fever-in-python
嘿编码器！在本教程中，我们将了解一个常见的 Python 编程问题，你能使用 Python 编程语言诊断发烧吗？
发烧是指体温高于正常水平。正常体温因人而异，但通常在 98.6 华氏度(37 摄氏度)左右。发烧不是一种疾病。这通常是一个迹象，表明你的身体正在努力对抗疾病或感染。
用 Python 实现发热检测
我们将首先询问用户，他们输入的温度是摄氏度还是华氏度。这可以对决策产生重大影响。现在我们将检查输入是 C 还是 F，或者是否有错误的输入。
temp = input("Would you like to enter your temperature in Celcius or Fahrenheit: ")
if temp.upper() == "C":
pass
elif temp.upper() == "F":
pass
else:
pass
让我们一个接一个地寻找最终的代码。第一块是输入的温标为“C”时。在这种情况下，用户可以输入温度，如果温度大于或等于 37.8，则该人发烧。否则，这个人没有发烧。为了更好的诊断，温度被转换为浮动。看看下面的代码。
temp = input("Would you like to enter your temperature in Celcius or Fahrenheit: ")
if temp.upper() == "C":
result = input("Enter your body temprature in Celcuis: ")
r = float(result)
if r >= 37.8:
print("You've a fever")
else:
print("You don't have a fever")
elif temp.upper() == "F":
pass
else:
pass
下一个模块是当输入为‘F’时。在这种情况下，阈值温度为 98.6。其余同上。接受输入并将输入转换为浮点以便更好地分析。请看下面的代码片段。
temp = input("Would you like to enter your temperature in Celcius or Fahrenheit: ")
if temp.upper() == "C":
result = input("Enter your body temprature in Celcuis: ")
r = float(result)
if r >= 37.8:
print("You've a fever")
else:
print("You don't have a fever")
elif temp.upper() == "F":
result1 = input("Enter your body temprature in Fahrenheit:")
r1 = float(result1)
if r1 >= 98.6:
print("You've a fever")
else:
print("You don't have a fever")
else:
pass
我们遇到的最后一个障碍是用户输入错误。在这种情况下，一个简单的语句作为输出被打印出来。看看下面的代码。
temp = input("Would you like to enter your temperature in Celcius or Fahrenheit: ")
if temp.upper() == "C":
result = input("Enter your body temprature in Celcuis: ")
r = float(result)
if r >= 37.8:
print("You've a fever")
else:
print("You don't have a fever")
elif temp.upper() == "F":
result1 = input("Enter your body temprature in Fahrenheit:")
r1 = float(result1)
if r1 >= 98.6:
print("You've a fever")
else:
print("You don't have a fever")
else:
print("Please enter the correct input")
Python 中发热检测的完整代码
temp = input("Would you like to enter your temperature in Celcius or Fahrenheit: ")
if temp.upper() == "C":
result = input("Enter your body temprature in Celcuis: ")
r = float(result)
if r >= 37.8:
print("You've a fever")
else:
print("You don't have a fever")
elif temp.upper() == "F":
result1 = input("Enter your body temprature in Fahrenheit:")
r1 = float(result1)
if r1 >= 98.6:
print("You've a fever")
else:
print("You don't have a fever")
else:
print("Please enter the correct input")
一些样本输出
Would you like to enter your temperature in Celcius or Fahrenheit: C
Enter your body temprature in Celcuis: 100
You've a fever
Would you like to enter your temperature in Celcius or Fahrenheit: F
Enter your body temprature in Fahrenheit:56
You don't have a fever
Would you like to enter your temperature in Celcius or Fahrenheit: j
Please enter the correct input
结论
在本教程中，我们学习了如何使用 Python 编程语言来诊断发烧。如果你喜欢这个教程，我相信你也会喜欢下面的！
感谢您的阅读！编码快乐！😁
使用 Python 的 GUI 骰子滚动模拟
原文：https://www.askpython.com/python/examples/dice-roll-simulation
让我们使用 Python tkinter 库创建一个骰子滚动模拟代码。我们都喜欢玩像蛇和梯子这样的棋盘游戏，卢多是我们最喜欢的一个。但是如果你没有骰子或者你把它丢在什么地方了呢？对于每个兴奋地想一起玩的人来说，这是一个重要的心情放松。但是，如果您已经掌握了 python 编程技能，那该怎么办呢？
使用 Python 中的 Tkinter 库绘制骰子
Python 提供了各种包来设计图形用户界面。Tkinter 是用于构建 GUI 应用程序的最流行、最常见、最快速、最易于使用的 Python 包。
它提供了一个强大的面向对象的接口，并且易于使用。同样，你开发一个应用程序；您可以在任何平台上使用它，这减少了在 Windows、Mac 或 Linux 上使用应用程序所需的修改。
这个框架为 Python 用户提供了一种使用 Tk 工具包中的小部件创建 GUI 元素的简单方法。
Tk 小部件可以用于构建按钮、菜单、数据字段等。在 Python 应用程序中。
为了让掷骰子模拟程序成功运行并构建 GUI，您必须导入 python tkinter 库。
如果尚未使用 pip 软件包管理器安装在您的系统上:
pip install tk
用 Python 编写掷骰子模拟代码
这是程序的完整代码。我们将在下面分解各个部分，以帮助您更好地理解代码。
#import the required libraries
#tkinter library to create GUI
#random library because we're randomly selecting numbers
from tkinter import *
import random
#create tkinter instance
root=Tk()
#define geometry
root.geometry("400x400")
#GUI will have two basic components
#1.Button which will trigger the rolling of dice
#2.Dice label
l1=Label(root,font=("Helvetica",260))
def roll():
#create a number variable in which the list of all the ASCII characters of the string will be stored
#Use backslash because unicode must have a backslash
dice=['\u2680','\u2681','\u2682','\u2683','\u2684','\u2685']
#configure the label
l1.config(text=f'{random.choice(dice)}{random.choice(dice)}')
l1.pack()
b1=Button(root,text="Roll the Dice!",foreground='blue',command=roll)
b1.place(x=300,y=0)
b1.pack()
root.mainloop()
理解代码
#import the required libraries
#tkinter library to create GUI
#random library because we're randomly selecting numbers
from tkinter import *
import random
最初，我们用 python 导入必要的库。为了访问随机模块，我们将from random import *添加到我们程序的顶部。from Tkinter import *将 Tkinter 中所有公开的对象导入到您当前的名称空间中。
#create tkinter instance
root=Tk()
#define geometry
root.geometry("400x400")
- root = Tk( ) : 根窗口被创建。根窗口是我们程序中的一个主要应用程序窗口。它有一个标题栏和边框。这些是由窗口管理器提供的。它必须在创建任何其他小部件之前创建。
- root . geometry(" 400×400 "):
geometry方法设置窗口的大小并将其定位在屏幕上。这两个参数是窗口的宽度和高度。
def roll():
#unicodes must have a backslash
dice=['\u2680','\u2681','\u2682','\u2683','\u2684','\u2685']
l1.config(text=f'{random.choice(dice)}{random.choice(dice)}')
l1.pack()
我们现在将定义函数 roll( ) 来创建骰子滚动模拟。现在我们将创建一个骰子变量，在其中我们将存储该字符串的所有 ASCII 字符的列表。
然后，我们将收集标签。
choices() 方法返回一个从指定序列中随机选择元素的列表。l1.pack()是一个几何管理器，它在将部件放入父部件之前将部件组织成块。
root.mainloop( ) :最后，我们进入主循环。事件处理从这一点开始。主循环从窗口系统接收事件，并将它们分派给应用程序小部件。当我们点击标题栏的关闭按钮时，它被终止。
结果
结论
我们希望您喜欢今天与我们一起构建掷骰子模拟应用程序。更多类似这样有趣的教程，继续关注 AskPython。
如何用 Python 把字典转换成字符串？
原文：https://www.askpython.com/python/string/dictionary-to-a-string
在本教程中，我们将讨论在 Python 中将字典转换成字符串的不同方法。
Python 中的字典是什么？
字典是一个 Python 对象，用于以键:值格式存储数据。键及其对应的值由冒号(:)分隔。字典中的每个键:值对由逗号(，)分隔。Python 中的字典总是用大括号{}括起来。
Python 字典是一种无序的数据结构，不像 Python 中的列表或元组。我们可以通过使用相应的键直接访问 Python 字典的任何值。让我们看看如何通过 Python 代码创建字典。
# Create a Python dictionary
dc = {'py': "PYTHON", 'cpp': "C++", 'mat': "MATLAB"}
print(type(dc))
print(dc)
输出:
<class 'dict'>
{'py': 'PYTHON', 'cpp': 'C++', 'mat': 'MATLAB'}
Python 中的字符串是什么？
一个字符串也是一个 Python 对象，它是最常用的数据结构，用于存储一系列字符。在 Python 中，包含在单引号、双引号或三引号中的任何内容都是字符串。在 Python 中，单引号和双引号可以互换使用来表示单行字符串，而三引号用于存储多行字符串。让我们通过 Python 代码创建一个字符串。
# Create a Python dictionary
sr = "py: PYTHON cpp: C++ mat: MATLAB"
print(type(sr))
print(sr)
输出:
<class 'str'>
py: PYTHON cpp: C++ mat: MATLAB
Python 中把字典转换成字符串的不同方法
在 Python 中，有多种方法可以将字典转换成字符串。让我们来讨论一些最常用的方法/途径。
1.使用 str()函数
在这个将字典转换为字符串的方法中，我们将简单地将字典对象传递给str()函数。
# Create a Python dictionary
dc = {'A': 'Android', 'B': 'Bootstrap', 'C': 'C Programming', 'D': 'Dart'}
print(type(dc))
print(f"Given dictionary: {dc}")
# Convert the dictionary to a string
# using str() function
sr = str(dc)
print(type(sr))
print(f"Converted string: {sr}")
输出:
<class 'dict'>
Given dictionary: {'A': 'Android', 'B': 'Bootstrap', 'C': 'C Programming', 'D': 'Dart'}
<class 'str'>
Converted string: {'A': 'Android', 'B': 'Bootstrap', 'C': 'C Programming', 'D': 'Dart'}
2.使用 json.dumps()函数
在这个将字典转换成字符串的方法中，我们将把字典对象传递给json.dumps()函数。为了使用json.dumps()函数，我们必须导入 JSON 模块，这是 Python 中的一个内置包。
# Import Python json module
import json
# Create a Python dictionary
dict = {'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 5}
print(type(dict))
print(f"Given dictionary: {dict}")
# Convert the dictionary to a string
# using json.dumps() function
str = json.dumps(dict)
print(type(str))
print(f"Converted string: {str}")
输出:
<class 'dict'>
Given dictionary: {'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 5}
<class 'str'>
Converted string: {"A": 1, "B": 2, "C": 3, "D": 4, "E": 5}
3.使用空字符串和 for 循环
在这个将字典转换成字符串的方法中，我们将简单地通过使用一个 for循环遍历字典对象来访问字典的键。然后我们访问对应于每个键的值，并将 key: value 对添加到一个空字符串中。
# Create a Python dictionary
dict = {'D': "Debian", 'U': "Ubuntu", 'C': "CentOS"}
print(type(dict))
print(f"Given dictionary- {dict}")
# Create an empty string
str = ""
# Convert the dictionary to a string
# using for loop only
for item in dict:
str += item + ':' + dict[item] + ' '
print(type(str))
print(f"Converted string- {str}")
输出:
<class 'dict'>
Given dictionary- {'D': 'Debian', 'U': 'Ubuntu', 'C': 'CentOS'}
<class 'str'>
Converted string- D:Debian U:Ubuntu C:CentOS
4.使用空字符串、for 循环和 items()函数
在这个将字典转换成字符串的方法中，我们将首先通过使用一个for循环和items()函数遍历字典对象来访问 key:value 对。然后，我们将每个键:值对添加到一个空字符串中。
# Create a Python dictionary
dict = {'Google': "GCP", 'Microsoft': "Azure", 'Amazon': "AWS"}
print(type(dict))
print(f"Given dictionary- {dict}")
# Create an empty string
str = ""
# Convert the dictionary to a string
# using for loop and items() function
for key, value in dict.items():
str += key + ':' + value + ' '
print(type(str))
print(f"Converted string- {str}")
输出:
<class 'dict'>
Given dictionary- {'Google': 'GCP', 'Microsoft': 'Azure', 'Amazon': 'AWS'}
<class 'str'>
Converted string- Google:GCP Microsoft:Azure Amazon:AWS
5.使用 for 循环、items()和 str.join()函数
在这个将字典转换为字符串的方法中，我们将使用一个for循环遍历字典对象，并添加键&的值。然后我们将使用str.join()函数将所有的键:值对连接在一起作为一个单独的字符串。
# Create a Python dictionary
dict = {'Google': " Chrome", 'Microsoft': " Edge", 'Apple': " Safari"}
print(type(dict))
print(f"Given dictionary: {dict}")
# Convert the dictionary to a string
# using str.join() and items() function
str = ', '.join(key + value for key, value in dict.items())
print(type(str))
print(f"Converted string: {str}")
输出:
<class 'dict'>
Given dictionary: {'Google': '-Chrome', 'Microsoft': '-Edge', 'Apple': '-Safari'}
<class 'str'>
Converted string: Google-Chrome, Microsoft-Edge, Apple-Safari
在 Python 中，我们还可以将 dictionary 对象的键和值转换成两个独立的字符串，而不是将键:值对转换成一个字符串。我们一个一个来讨论吧。
将字典的关键字转换为字符串
首先，我们将讨论将 dictionary 对象的键转换成字符串的不同方法。
1.使用空字符串和 for 循环
# Create a Python dictionary
dict = {'OS': "Operating System", 'DBMS': "Database Management System", 'CN': "Computer Network"}
print(type(dict))
print(f"Given dictionary- {dict}")
# Create an empty string
str = ""
# Convert the dictionary keys into a string
# using for loop only
for item in dict:
str += item + " "
print(type(str))
print(f"Keys in string- {str}")
输出:
<class 'dict'>
Given dictionary- {'OS': 'Operating System', 'DBMS': 'Database Management System', 'CN': 'Computer Network'}
<class 'str'>
Keys in string- OS DBMS CN
2.使用 for 循环和 str.join()函数
# Create a Python dictionary
dict = {'gcc': "C program", 'g++': "C++ program", 'py': "Python Program"}
print(type(dict))
print(f"Given dictionary: {dict}")
# Convert the dictionary keys into a string
# using str.join()
str = ', '.join(key for key in dict)
print(type(str))
print(f"Keys in string: {str}")
输出:
<class 'dict'>
Given dictionary: {'gcc': 'C program', 'g++': 'C++ program', 'py': 'Python Program'}
<class 'str'>
Keys in string: gcc, g++, py
将字典的值转换为字符串
现在让我们讨论将 dictionary 对象的值转换为字符串的不同方法。
1.使用空字符串和 for 循环
# Create a Python dictionary
dict = {'OS': "Operating_System", 'DBMS': "Database_Management_System", 'CN': "Computer_Network"}
print(type(dict))
print(f"Given dictionary- {dict}")
# Create an empty string
str = ""
# Convert the dictionary values into a string
# using for loop only
for item in dict:
str += dict[item] + " "
print(type(str))
print(f"Values in string- {str}")
输出:
<class 'dict'>
Given dictionary- {'OS': 'Operating_System', 'DBMS': 'Database_Management_System', 'CN': 'Computer_Network'}
<class 'str'>
Values in string- Operating_System Database_Management_System Computer_Network
2.使用 for 循环和 str.join()函数
# Create a Python dictionary
dict = {'gcc': "C program", 'g++': "C++ program", 'py': "Python Program"}
print(type(dict))
print(f"Given dictionary: {dict}")
# Convert the dictionary values into a string
# using str.join()
str = ', '.join(dict[item] for item in dict)
print(type(str))
print(f"Values in string: {str}")
输出:
<class 'dict'>
Given dictionary: {'gcc': 'C program', 'g++': 'C++ program', 'py': 'Python Program'}
<class 'str'>
Values in string: C program, C++ program, Python Program
结论
在本教程中，我们学习了用 Python 将字典转换成字符串的不同方法。我们还学习了如何将 dictionary 对象的键和值转换成两个独立的字符串。希望你已经理解了上面讨论的东西，并将自己尝试这些。
如何用 Python 从字典创建 DataFrame？
原文：https://www.askpython.com/python-modules/pandas/dictionary-to-dataframe
你好。在本教程中，我们将讨论从 Python 中的字典创建一个 Pandas DataFrame 对象的不同方法。那么，我们开始吧。
从列表字典创建数据框架
在 Python 中，我们可以很容易地从 Python 字典中创建 Pandas DataFrame 对象。让我们一个接一个地从列表字典中学习创建熊猫数据框架的不同方法。
1.使用 pd。DataFrame()函数
在这个方法中，我们将首先创建一个 Python 列表字典，并将其传递给pd.DataFrame()函数。最后，pd.DataFrame()函数返回一个 pandas DataFrame 对象，其中包含来自列表字典的数据。让我们通过 Python 代码来实现这一点。
# Import pandas module
import pandas as pd
# Create a Python dictionary of lists
data = {'Name': ['Rajan', 'Raman', 'Deepak', 'David'],
'Roll': [11, 12, 13, 14],
'City': ['Agra', 'Pune', 'Delhi', 'Sivan']}
# Create a pandas DataFrame dictionary of lists
# using pd.DataFrame() function
df = pd.DataFrame(data)
print(df)
输出:
2.使用 DataFrame.from_dict()函数
像前面的方法一样，这里我们也将首先创建一个列表的 Python 字典，但是将它传递给DataFrame.from_dict()函数。最后，DataFrame.from_dict()函数返回一个 Pandas DataFrame 对象，其中包含来自列表字典的数据。让我们看看如何通过 Python 代码实现这一点。
# Import pandas module
import pandas as pd
# Create a Python dictionary of lists
data = {'Name': ['Rajan', 'Raman', 'Deepak', 'David'],
'Roll': [11, 12, 13, 14],
'Marks': [93, 88, 95, 75],
'City': ['Agra', 'Pune', 'Delhi', 'Sivan']}
# Create a DataFrame from dictionary of lists
# using from_dict() function
df = pd.DataFrame.from_dict(data)
print(df)
输出:
从字典列表创建一个数据框架
在 Python 中，我们还可以从字典列表中创建一个熊猫 DataFrame 对象。在这个方法中，我们首先创建一个 Python 字典列表，并将其传递给pd.DataFrame()函数。然后，pd.DataFrame()函数返回一个 Pandas DataFrame 对象，其中包含字典列表中的数据。让我们看看如何通过 Python 代码从字典列表创建一个 DataFrame。
# Import pandas module
import pandas as pd
# Create a Python list of dictionaries
data = [{'Name': "Sanjay", 'Roll': 101, 'Branch': 'ECE'},
{'Name': "Ravi", 'Roll': 102, 'Branch': 'CSE'},
{'Name': "Thaman", 'Roll': 103, 'Branch': 'EEE'},
{'Name': "David", 'Roll': 104, 'Branch': 'IPE'},]
# Create a DataFrame from list of dictionaries
# using pd.DataFrame() function
df = pd.DataFrame(data)
print(df)
输出:
根据 Python 范围字典创建数据框架
在 Python 中，我们甚至可以从 Python 范围的字典中创建 Pandas DataFrame 对象。在这个方法中，我们首先使用 Python 中的range()函数创建一个范围字典，并将其传递给pd.DataFrame()函数。然后pd.DataFrame()函数返回一个熊猫 DataFrame 对象，其中包含来自范围字典的数据。让我们看看如何通过 Python 代码从 Python 范围的字典创建数据帧。
# Import pandas module
import pandas as pd
# Create a dictionary of
# Python ranges
data = {'Table-1': range(1, 11, 1),
'Table-2': range(2, 21, 2),
'Table-3': range(3, 31, 3),
'Table-4': range(4, 41, 4),
'Table-5': range(5, 51, 5)}
# Create a DataFrame from a dictionary
# of Python ranges
# using pd.DataFrame() function
df = pd.DataFrame(data)
print(df)
输出:
使用用户定义的索引从字典创建数据帧
在 Python 中，我们可以从带有用户定义索引的字典中创建 Pandas DataFrame 对象。在这个方法中，我们首先创建一个 Python 字典，并将其与索引列表一起传递给pd.DataFrame()函数。然后，pd.DataFrame()函数返回一个 Pandas DataFrame 对象，其中包含来自字典的数据和来自传递的索引列表的索引。我们来看看如何通过 Python 代码实现。
# Import pandas module
import pandas as pd
# Create a Python dictionary of lists
data = {'Name': ['Rajan', 'Raman', 'Deepak', 'David'],
'Roll': [11, 12, 13, 14],
'Marks': [93, 88, 95, 75],
'City': ['Agra', 'Pune', 'Delhi', 'Sivan']}
# Create a DataFrame from dictionary of lists
# using pd.DataFrame() function with user-defined indexes
df = pd.DataFrame(data, index = ['S1', 'S2', 'S3', 'S4'])
print(df)
输出:
结论
在本教程中，我们学习了从 Python 字典创建熊猫 DataFrame 对象的不同方法。希望你已经理解了上面讨论的东西，并准备探索和学习更多关于熊猫数据框对象。敬请关注我们！
在 Python 中==和的区别在于
原文：https://www.askpython.com/python/examples/difference-between-equal-to-and-is
操作符==和is在 Python 中执行非常相似的任务，但是它们彼此非常不同，并且处理一个非常有趣的概念:Python 如何在内存中存储变量。
理解==和 is 之间的区别
简单来说，
==检查两个操作数的值，如果相同，则返回True，否则返回False。is检查两个操作数的对象 ID，如果相同则返回True。
但是什么是对象 ID 呢？每个对象在内存中被分配一个 ID，两个变量可以指向同一个对象，这给了它们相同的对象 ID。
让我们用列表来看看它们的区别:
lst1 = [1,2,3]
lst2 = [1,2,3]
print(lst1 == lst2)
print(lst1 is lst2)
lst2 = lst1
print()
print(lst1 is lst2)
输出:
True
False
True
在上面的例子中，最初，内存中有两个列表，但是它们拥有完全相同的值。
==比较数值，因此运算返回True。- 但是
is检查它们是否指向同一个对象，这些列表实际上是不同的对象，所以返回False。 - 在这之后，我们使
lst2等于lst1，这使得lst2指向lst1所指向的地方，于是，is返回True。
所有这些对于整数来说是非常不同的，为了理解这一点，我们需要知道对象是如何存储在内存中的。
Python 中的内存分配
我们需要理解 Python 中对象的内存分配，以便在本教程中更进一步。
让我们举一个例子:
number = 10
在这里，我们知道number保存了值 10，但是它是如何存储在内存中的呢？在 Python 中，每个对象在内存中都有四个部分:
- Size–对于每个对象，保留 4 个字节来保存对象的大小。
- 引用计数–对于每个对象，保留 8 个字节，用于保存指向该对象的变量数量。所有这些对象都有这个对象的对象 ID。
- 对象类型–对于每个对象，保留 8 个字节，用于保存表示对象类型的信息。
- 对象值–另外 8 个字节为每个对象保留，它们保存对象的实际值。
现在，在上面的列表中，对象值和引用计数是这次讨论的重点。
因此，对于number = 10，内存中有一个对象，其对象值为 10，引用计数为 1，这意味着该对象的值为 10，有一个变量指向它，在我们的例子中是number。
现在让我们像这样声明另一个变量:
number_2 = number
print(number == number_2)
print(number is number_2)
现在，内存中会发生一件非常有趣的事情，不会有新的对象被创建，number_2也会指向number所指向的地方，对象的引用计数会增加到 2。
因此，number和number_2将具有相同的对象 ID，输出将是:
True
True
但是如果我们这样做呢？
num1 = 10
num2 = 10
print(num1 == num2)
print(num1 is num2)
在上面的示例中，输出将是:
True
True
从-5 到 256 的特殊数字
Python 认为从-5 到 256 的整数是常用的整数，因此这些整数的对象总是预定义的，您不能从内存中删除这些对象。
所以在 Python 代码的开始，所有这些对象的引用计数都是零，但是如果任何变量的值都在-5 到 256(包括-5 和 256)之间，那么就不会创建新的对象，所有的变量都会指向已经存在的对象。
所以在上面的代码中，10 的对象已经在内存中了，前两行只是创建了指向同一个对象的变量。
因此，对于下面的代码:
num1 = 257
num2 = 257
print(num1 == num2)
print(num1 is num2)
输出将是:
True
False
这是因为 python 会在每次声明整数时为超出该范围的整数创建新的实例。注意，如果我们已经做了num2 = num1，那么无论num1的值是多少，它们都将指向同一个对象。
结论
在本教程中，我们看到了==和is之间的区别，以及is如何有助于发现两个变量是否指向同一个内存位置。
我们还看到了从-5 到 256 的整数是如何缓存在内存中的，因为它们被认为是常用的(像'a'和'b'这样的字符也被类似地缓存)，在这个范围内具有相同值的两个变量将指向同一个对象。
