AskPython-博客中文翻译-五-
AskPython 博客中文翻译（五）
Python 中的标签编码——快速指南！
读者朋友们，你们好！在本文中，我们将关注 Python 中的标签编码。
在我们的上一篇文章中，我们了解了 One hot Encoding 的工作和实现，其中标签编码是该过程的初始步骤。
今天，我们将看看数据值分类编码中最基本的步骤之一。
因此，没有任何进一步的拖延，让我们开始吧！
Python 中的标签编码是什么？
在深入研究标签编码的概念之前，让我们先了解一下“标签”这个概念对数据集的影响。
标签实际上是代表一组特定实体的数字或字符串。标签有助于模型更好地理解数据集，并使模型能够学习更复杂的结构。
标签编码器将分类数据的这些标签转换成数字格式。
例如，如果数据集包含带有标签“男性”和“女性”的变量“性别”，则标签编码器会将这些标签转换为数字格式，结果将是[0，1]。
因此，通过将标签转换成整数格式，机器学习模型可以在操作数据集方面有更好的理解。
标签编码–语法知识！
Python sklearn 库为我们提供了一个预定义的函数，对数据集进行标签编码。
语法:
from sklearn import preprocessing
object = preprocessing.LabelEncoder()
这里，我们创建一个 LabelEncoder 类的对象，然后利用该对象对数据应用标签编码。
1.使用 sklearn 进行标签编码
让我们直接进入标签编码的过程。对数据集进行编码的第一步是拥有一个数据集。
因此，我们将在这里创建一个简单的数据集。示例:数据集的创建
import pandas as pd
data = {"Gender":['M','F','F','M','F','F','F'], "NAME":['John','Camili','Rheana','Joseph','Amanti','Alexa','Siri']}
block = pd.DataFrame(data)
print("Original Data frame:\n")
print(block)
这里，我们创建了一个字典‘数据’,然后使用pandas.DataFrame() 函数将它转换成一个数据帧。
输出:
Original Data frame:
Gender NAME
0 M John
1 F Camili
2 F Rheana
3 M Joseph
4 F Amanti
5 F Alexa
6 F Siri
从上面的数据集中，很明显，变量“性别”的标签为“M”和“F”。
此外，现在让我们导入 LabelEncoder 类，并将其应用于数据集的“性别”变量。
from sklearn import preprocessing
label = preprocessing.LabelEncoder()
block['Gender']= label.fit_transform(block['Gender'])
print(block['Gender'].unique())
我们已经使用fit_transform() method将对象指向的标签编码器的功能应用于数据变量。
输出:
[1 0]
所以，你看，数据已经被转换成[0，1]的整数标签了。
print(block)
输出:
Gender NAME
0 1 John
1 0 Camili
2 0 Rheana
3 1 Joseph
4 0 Amanti
5 0 Alexa
6 0 Siri
2。使用类别代码的标签编码
让我们首先检查数据集变量的数据类型。
block.dtypes
数据类型:
Gender object
NAME object
dtype: object
现在，将变量“性别”的数据类型转换为类别类型。
block['Gender'] = block['Gender'].astype('category')
block.dtypes
Gender category
NAME object
dtype: object
现在，让我们使用pandas.DataFrame.cat.codes函数将标签转换成整数类型。
block['Gender'] = block['Gender'].cat.codes
print(block)
如下所示，变量“性别”已被编码为整数值[0，1]。
Gender NAME
0 1 John
1 0 Camili
2 0 Rheana
3 1 Joseph
4 0 Amanti
5 0 Alexa
6 0 Siri
结论
到此，我们就结束了这个话题。如果你遇到任何问题，欢迎在下面评论。
为了更深入地理解这个主题，请尝试在不同的数据集和变量上实现标签编码器的概念。请在评论区告诉我们你的体验！🙂
更多与 Python 相关的帖子，敬请关注，在此之前，祝你学习愉快！！🙂
参考
用 Python 解决梯子问题
原文：https://www.askpython.com/python/examples/ladders-problem
在本教程中，我们将了解一个非常有趣的问题，称为梯子问题。我们先来了解一下，在这个问题上，我们想达到什么目的？
理解梯子问题
在这个问题中，我们有两个输入，一个是步数，另一个是一个人一次可以走的最大步数。
例如，如果最大步数= 3。一个人可以在特定时间走 1 步、2 步或 3 步。
我们需要计算这个人一次走 1 步、2 步或 3 步到达梯子顶端的所有方法。
Recursive Solution Ladders Problem 1
梯子问题的解决方案
现在这个问题可以用普通的循环和 if-else 语句解决了。但是更好的方法是遵循递归方法。如果你不知道递归是如何工作的，我推荐你阅读下面提到的教程。
了解更多关于递归的知识:Python 中的递归
为了解决这个问题，我们将寻找最小的问题，即 n = 1 到 n = n。让我们考虑最大的步骤数可以是 3。
下图说明了这种情况。
Recursive Solution Ladders Problem
现在让我们看看梯子问题的代码实现。
Python 中梯子问题的代码实现
这里我们计算的是 k 最大步数的路数。因此，我们将按照(n-1)、(n-2)、(n-3)等顺序计算这些值，直到(n-k)。
最后，我们将对获得的所有值求和，并返回最终答案。下面给出了相同的代码实现。
def count_no_ways(n,k):
if(n<0):
return 0
# already on top
if(n==0):
return 1
if(n<3):
return n
ans = 0
for i in range(1,k+1):
ans+=count_no_ways(n-i,k)
return ans
n = int(input())
k = int(input())
print(count_no_ways(n,k))
输出:
17
17
65536
我希望你清楚梯子问题中使用的递归概念，并且能够自己实现它。
感谢您的阅读！快乐学习！😇
Python 中带条件语句的 Lambda
原文：https://www.askpython.com/python/examples/lambda-with-if-else-conditions
在本文中，我们将学习如何在 Python 中使用带有 if-else 条件的 lambda 。当您需要更高级的匿名函数时，将这两者配对会非常有用。
任何编程语言中的条件语句都是需要学习的基本概念之一。它们的主要用途是根据提供的条件行动。每个程序员都必须学习这些，然后向更高级的主题前进。几乎所有的语言都只有三种条件句:
- 如果
- 否则
- 否则如果
Python 中的 lambda 函数是什么？
Python 中的 lambda 函数是一个匿名函数。使用这个概念的核心目的是使函数的创建变得容易。
λ函数的语法
variable = lambda parameters_list : expression
Lambda Syntax
要获取更多信息，请输入以下命令:
help('lambda')
我们得到以下输出:
Lambdas
*******
lambda_expr ::= "lambda" [parameter_list] ":" expression
lambda_expr_nocond ::= "lambda" [parameter_list] ":" expression_nocond
Lambda expressions (sometimes called lambda forms) are used to create
anonymous functions. The expression "lambda parameters: expression"
yields a function object. The unnamed object behaves like a function
object defined with:
def <lambda>(parameters):
return expression
Note that functions created with lambda expressions cannot contain
statements or annotations.
使用 lambdas，我们可以为初学者友好的开始执行以下操作:
- 加法
- 减法
- 乘法运算
- 分部
其他高级操作包括:
- 在函数式编程中使用。
- 在面向对象编程中使用。
- 参数化一个特定类的方法。
让我们看几个 lambda 函数的例子。
添加
代码:
add = lambda a, b: a + b
print(add(5, 5))
# output: 10
代码很简单。我们首先创建一个 lambda 对象作为 add。然后我们在 lambda 表达式中存储两个参数。这些参数是用于加法运算的两个数字。在冒号之后，我们将加法表达式放在冒号之前。
减法
代码:
subtract = lambda a, b: a - b
print(add(100, 50))
# output: 50
增加
代码:
multiply = lambda a, b: a * b
print(multiply(100, 50))
# output: 5000
使用带有 if-else 条件的 Lambda
使用带有 if-else 条件的 lambda 是一种有用的技术。这也减少了代码的行数。现在，注意 lambdas 中的表达式部分一次只能保存一个表达式。
在 Python 中将 lambda 与 if-else 条件一起使用时的一般语法
variable_name = lambda parameters : code_for_if if (condition) else code_for_else
语法与 lambda 的核心实现略有不同。所以，只需在 if 语句前声明代码，然后编写带有条件的 if 语句。如果需要，else 块直接出现在 If 语句之后。
Lambda If Else Block
conditional_lambda = lambda x: x/100 if x < 20 else x
print(conditional_lambda(4))
# output: 0.04
说明:
- 我们创建一个 lambda 对象作为 conditional_lambda 。
- 然后，我们存储一个变量 x ，表达式为x/100from and in join 我们的条件语句所在。
- 声明中说，如果 x 小于 20，则除以 100，否则按原样打印。
- 然后我们调用 conditional_lambda 函数，在函数内部，我们将参数设为 4。
- 当 4 小于 20 时，它将除以 100，屏幕上的输出是 0.04。
现在我们将学习如何使用其他高级操作。
例:用 lambdas 检查给定的数字是偶数还是奇数
# setup lambda
check = lambda num : print(num, 'is Even') if num%2 == 0 else print(num, ' is Odd')
# input from user
num = int(input('Enter any number: '))
a = check(num)
print(a)
输出:
>>> Enter any number: 65
65 is Odd
>>> Enter any number: -56
-56 is Even
例:用 lambdas 检查给定的数字是偶数还是奇数
check = lambda a, b : print(a,'is divisible by', b) if (a%b == 0) else print(a ,' is indivisible by ', b)
a = int(input('Enter value for a: '))
b = int(input('Enter value for b: '))
obj = check(a, b)
输出:
>>> Enter value for a: 45
>>> Enter value for b: 45
45 is divisible by 45
>>> Enter value for a: 3
>>> Enter value for b: 9
3 is indivisible by 9
说明:
- 首先我们定义一下λ的说法。该函数有两个参数 a 和 b 。函数名为 check 。
- 然后在 if 块来了之后。主要条件是 a 应该能被 b 整除。如果这是真的，那么木块就会打印出来(“a 能被 b 整除”)。但是如果余数不为零，则 else 块打印不可分割。
- 然后我们创建一个函数对象作为 obj 并将其称为关于 check(a，b) 。
参考框架
https://stack overflow . com/questions/1585322/is-there-a-way-to-perform-if-in-python-lambda
包扎
这样，我们就结束了这个话题。使用 Lambda 和 if-else 条件语句是保持一行代码可见性的关键主题之一。最好的事情是我们不需要改变核心语法，只需要编辑我们的条件和其他东西。读者必须修改代码，并多次尝试理解代码。
Python 中的套索回归
原文：https://www.askpython.com/python/examples/lasso-regression
读者朋友们，你们好！在上一篇文章中，我们详细讨论了 Python 编程中的岭回归。现在，我们将讨论 Python 中的套索回归。
所以，让我们开始吧！
一、什么是套索回归？
在数据科学和机器学习领域，我们的主要目标是根据数据值的类型，通过各种算法对现实生活中的问题进行预测。
线性回归就是这样一种算法。使用该算法，我们可以为我们的模型定义最佳拟合线，即了解数据集变量之间的相关性。
它帮助我们找出数据集的因变量和自变量之间的关系，以建立预测的估计模型。
线性回归的问题:
- 众所周知，线性回归计算的是模型每个变量的系数。随着数据复杂性的增加，系数的值变成更高的值，这反过来使得模型对提供给它的进一步输入敏感。
- 这反过来又让模型有点不稳定！
解–套索回归
所以，我们开始解决这个问题。拉索回归，也称为L1 regression就足够了。使用套索回归，我们倾向于用系数的值来惩罚模型。因此，它通过包含模型变量的额外成本来操纵损失函数，而该模型恰好具有大的系数值。
它针对绝对系数值对模型进行惩罚。这样，它让系数的值(对预测变量没有贡献)变为零。除此之外，它从模型中移除那些输入特征。
因此，我们可以说，
Lasso = loss+(λ L1 _ penalty)*
这里，λ是在惩罚值的加权处进行检查的超参数。
套索回归——一种实用的方法
在本例中，我们利用了自行车租赁计数预测数据集。你可以在这里找到数据集！
最初，我们使用 read_csv()函数将数据集加载到 Python 环境中。除此之外，我们使用 train_test_split() 函数将数据集分割成训练和测试数据。
对于这个例子，我们已经设置了 MAPE 作为误差度量来评估 lasso 回归惩罚模型。
Python 的sklearn.linear_model library，为我们提供了lasso()函数，在数据集上建立模型。
举例:
import os
import pandas
#Changing the current working directory
os.chdir("D:/Ediwsor_Project - Bike_Rental_Count")
BIKE = pandas.read_csv("day.csv")
bike = BIKE.copy()
categorical_col_updated = ['season','yr','mnth','weathersit','holiday']
bike = pandas.get_dummies(bike, columns = categorical_col_updated)
#Separating the depenedent and independent data variables into two dataframes.
from sklearn.model_selection import train_test_split
X = bike.drop(['cnt'],axis=1)
Y = bike['cnt']
import numpy as np
def MAPE(Y_actual,Y_Predicted):
mape = np.mean(np.abs((Y_actual - Y_Predicted)/Y_actual))*100
return mape
from sklearn.linear_model import Lasso
lasso_model = Lasso(alpha=1.0)
lasso=lasso_model.fit(X_train , Y_train)
lasso_predict = lasso.predict(X_test)
Lasso_MAPE = MAPE(Y_test,lasso_predict)
print("MAPE value: ",Lasso_MAPE)
Accuracy = 100 - Lasso_MAPE
print('Accuracy of Lasso Regression: {:0.2f}%.'.format(Accuracy))
输出:
MAPE value: 16.55305612241603
Accuracy of Lasso Regression: 83.45%.
结论
到此，我们就结束了这个话题。如果你遇到任何问题，请随时在下面评论。
建议您尝试使用其他数据集的 Lasso 回归概念，并在评论部分告诉我们您的体验！
更多与 Python 相关的帖子，敬请关注，在此之前，祝你学习愉快！！🙂
Python 中的潜在狄利克雷分配算法
原文：https://www.askpython.com/python/examples/latent-dirichlet-allocation-lda
你好读者，在这篇文章中我们将试图理解什么是 LDA 算法。它是如何工作的以及如何在 python 中实现的。潜在狄利克雷分配是一种主要属于自然语言处理(NLP)领域的算法。
它用于主题建模。主题建模是对文本数据执行的机器学习技术，以分析文本数据并在文档集合中找到抽象的相似主题。
也读作:深度优先迭代深化(DFID)算法 Python 中的
什么是 LDA？
LDA 是一种专门为文本数据设计的主题建模算法。这种技术将每个文档视为算法作为最终结果产生的一些主题的混合物。主题是出现在数据集中所有文档集中的单词的概率分布。
预处理数据的结果将提供一组关键字或标记，LDA 算法将把这些预处理数据作为输入，并基于这些关键字的概率分布来尝试发现隐藏/潜在的主题。最初，该算法将把文档中的每个单词分配给' n' 个主题中的一个随机主题。
例如，考虑以下文本数据
- 文字 1:为 IPL 感到兴奋，今年让我们回到板球场，享受比赛。
- 文字 2:今年八月我们可能会面临第四波 Covid！
- 文本 3:尽早接种疫苗，现在正是时候。
- 文本 4:欧盟预算增加了今年的体育项目配额，这都要归功于今年的奥运冠军。
理论上，让我们考虑算法要处理的两个主题 Sports 和 Covid。该算法可以为主题 2 的 Covid 分配表示“IPL”的第一个单词。我们知道这种分配是错误的，但是该算法将基于两个因素在未来的迭代中尝试纠正这一点，这两个因素是主题在文档中出现的频率和单词在主题中出现的频率。由于在文本 1 中没有很多与 Covid 相关的术语，并且单词“IPL”在主题 2 Covid 中不会出现很多次，所以算法可以将单词“IPL”分配给新主题，即主题 1(体育)。通过多次这样的迭代，该算法将实现主题识别和跨主题的单词分布的稳定性。最后，每个文档可以表示为确定主题的混合。
也读作:Python 中的双向搜索
LDA 是如何工作的？
在 LDA 中执行以下步骤，为每个文档分配主题:
1)对于每个文档，将每个单词随机初始化为 K 个主题中的一个主题，其中 K 是预定义主题的数量。
2)对于每个文档 d:
对于文档中的每个单词 w，计算:
- p(主题 t|文档 d):文档 d 中分配给主题 t 的单词的比例
- P(word w| topic t):来自 w 的单词在所有文档中分配给主题 t 的比例
3)考虑所有其他单词及其主题分配，以概率 p(t'|d)*p(w|t ')将主题 T '重新分配给单词 w
最后一步重复多次，直到我们达到一个稳定的状态，主题分配不再发生进一步的变化。然后从这些主题分配中确定每个文档的主题比例。
LDA 的示例:
假设我们有以下 4 个文档作为语料库，我们希望对这些文档进行主题建模。
- 文献 1 :我们在 YouTube 上看很多视频。
- 文献 2 : YouTube 视频信息量很大。
- 文献 3 :看技术博客让我很容易理解事情。
- 文档 4 :比起 YouTube 视频，我更喜欢博客。
LDA 建模帮助我们发现上述语料库中的主题，并为每个文档分配主题混合。例如，该模型可能会输出如下所示的内容:
话题 1: 40%的视频，60%的 YouTube
话题 2: 95%的博客，5%的 YouTube
文档 1 和 2 将 100%属于主题 1。文档 3 将 100%属于主题 2。文档 4 的 80%属于主题 2，20%属于主题 1
如何用 Python 实现 LDA？
以下是实现 LDA 算法的步骤:
- 收集数据并作为输入提供
- 预处理数据(删除不必要的数据)
- 修改 LDA 分析的数据
- 建立和训练 LDA 模型
- 分析 LDA 模型结果
这里，我们有从 Twitter 收集的输入数据，并将其转换为 CSV 文件，因为社交媒体上的数据是多种多样的，我们可以建立一个有效的模型。
导入 LDA 所需的库
import numpy as np
import pandas as pd
import re
import gensim
from gensim import corpora, models, similarities
from gensim.parsing.preprocessing import STOPWORDS
from nltk.corpus import stopwords
清理数据
规范化空白
def normalize_whitespace(tweet):
tweet = re.sub('[\s]+', ' ', tweet)
return tweet
text = " We are the students of Science. "
print("Text Before: ",text)
text = normalize_whitespace(text)
print("Text After: ",text)
输出:
Text Before: We are the students of Science.
我们是理科学生。
删除停用词
import nltk
nltk.download('stopwords')
import gensim
from gensim.parsing.preprocessing import STOPWORDS
from nltk.corpus import stopwords
stop_words = stopwords.words('english')
def remove_stopwords(text):
final_s=""
text_arr= text.split(" ") #splits sentence when space occurs
print(text_arr)
for word in text_arr:
if word not in stop_words: # if word is not in stopword then append(join) it to string
final_s= final_s + word + " "
return final_s
词干化和标记化
import nltk
# nltk.download('wordnet')
from nltk.stem import WordNetLemmatizer, SnowballStemmer, PorterStemmer
stemmer = PorterStemmer()
def tokenize_stemming(text):
text = re.sub(r'[^\w\s]','',text)
#replace multiple spaces with one space
text = re.sub(r'[\s]+',' ',text)
#transfer text to lowercase
text = text.lower()
# tokenize text
tokens = re.split(" ", text)
# Remove stop words
result = []
for token in tokens :
if token not in stop_words and len(token) > 1:
result.append(stemmer.stem(token))
return result
术语频率(TF-IDF)
它是术语频率-逆文档频率的缩写，是一种数字统计，旨在反映一个词对集合或语料库中的文档有多重要。它经常被用作加权因子。
corpus_doc2bow_vectors = [dictionary.doc2bow(tok_doc) for tok_doc in tokens]
print("# Term Frequency : ")
corpus_doc2bow_vectors[:5]
tfidf_model = models.TfidfModel(corpus_doc2bow_vectors, id2word=dictionary, normalize=False)
corpus_tfidf_vectors = tfidf_model[corpus_doc2bow_vectors]
print("\n# TF_IDF: ")
print(corpus_tfidf_vectors[5])
使用单词包运行 LDA
lda_model = gensim.models.LdaMulticore(corpus_doc2bow_vectors, num_topics=10, id2word=dictionary, passes=2, workers=2)
使用 TF-IDF 运行 LDA
lda_model_tfidf = gensim.models.LdaMulticore(corpus_tfidf_vectors, num_topics=10, id2word=dictionary, passes=2, workers=4)
for idx, topic in lda_model_tfidf.print_topics(-1):
print('Topic: {} Word: {}'.format(idx, topic))
主题的分类
性能评估通过使用 LDA 单词袋模型对样本文档进行分类，我们将检查我们的测试文档将被分类到哪里。
for index, score in sorted(lda_model[corpus_doc2bow_vectors[1]], key=lambda tup: -1*tup[1]):
print("\nScore: {}\t \nTopic: {}".format(score, lda_model.print_topic(index, 10)))
使用 LDA TF-IDF 模型对样本文档进行分类的性能评估。
for index, score in sorted(lda_model_tfidf[corpus_doc2bow_vectors[1]], key=lambda tup: -1*tup[1]):
print("\nScore: {}\t \nTopic: {}".format(score, lda_model_tfidf.print_topic(index, 10)))
结论
在本文中，我们试图理解自然语言处理领域中最常用的算法。LDA 是主题建模的基础——一种统计建模和数据挖掘。
参考资料:
https://en.wikipedia.org/wiki/Tf%E2%80%93idf
学习 Python，获得这些耐人寻味的工作机会
原文：https://www.askpython.com/python/learn-python-job-opportunities
无论是 web 开发、app 开发，还是其他任何软件开发，都有大量程序员使用的编程语言。随着时间的推移，一些编程语言的使用出现了巨大的增长。其中一种语言是 Python。
与其他编程语言不同，Python 提供了相对简单的学习结构。因此，任何人都很容易学会它，即使是编程新手。易用性使得 Python 成为最受欢迎的编程语言之一。你会惊讶地发现，Python 是谷歌、脸书、YouTube 和许多其他服务的后端编程不可或缺的一部分。
简而言之，Python 有能力让你获得业内薪酬最高的工作。如果你精通这种要求很高的语言，这将花费你大约 5-6 个月的时间，最终你会收获巨大的成果。也许，这个清单会让你更放心！
1.数据分析师
如果您得到一个包含一百万个条目的电子表格，并被要求基于它创建一个条形图，那会怎么样呢？做这件事可能需要一段时间。但是，如果你懂 Python，几分钟之内就能搞定。怎么会？
嗯，Python 不仅仅是简单的加法或减法。这门语言拥有各种创新的库，如 NumPy、Pandas、SciPy、Matplotlib 等。，你可以用它来进行大规模的数学计算。
今天的企业正在寻找能够挖掘和分析数据以产生有价值的见解的专业人士。像这样的专业人士是旨在开发基于人工智能的解决方案并提供最先进的客户解决方案的公司的宝石。
2.开发者
显而易见，如果你精通任何一门编程语言，你随时都可以得到这份工作。世界各地的跨国公司都在寻找 Python 开发人员，如果你拥有确切的技能，他们愿意支付一大笔钱。
作为一名开发人员，与其他编程语言相比，你会接触到很多 Python 开发。例如，你可以优化和执行数据算法。编码的量会越来越少，越来越不复杂。您可以轻松快捷地构建网站，解决数据分析问题，并实施安全和数据保护。
3.人工智能和机器学习工程师
2020 年，人工智能的整体市场规模为 623.5 亿美元。从 2021 年到 2028 年，预计 CAGR 将进一步增长 40.2%。这清楚地证明，不只是一个行业，而是每个行业都在大力投资人工智能。
健身行业正在为他们的客户提供所有的服务，而他们是在家里。医疗应用正在利用用户数据来为他们策划健康计划。银行和其他服务提供商正在使用基于人工智能的聊天机器人来加强客户服务等等。
所有这些方面都表明，AI 是下一个大事情，通过深入学习 Python，你可以成为它不可或缺的一部分。TensorFlow、Scikit-Learn 等库在开发神经网络时会派上用场。
4.导师
利用你的技能的一个很棒的方法是让别人了解它们。学习 Python 可能会标榜为 1 个月的玩法，其实不然。如果你试着学过，你就会知道。而且，如果你精通编程语言，它可以为你打开新的机会之门。
世界上有无数的在线平台可以帮助你充分利用你的知识。可以加入这些平台当导师，展示自己的技能。如果不是这样，你可以开办自己的 YouTube 频道，免费又能赚钱。Instagram 视频和卷轴也是展示自己的好方法。
不仅如此，你还可以在一所著名的学院或大学找到一份工作来充分利用你的技能。
5.R&D 工程师
数据分析是世界上每个公司的成功之路。今天，没有任何应用程序或网站不收集您的数据。缺点是它引发了许多隐私问题，用户总是在寻找保护他们活动的方法。首先，他们使用私人浏览器或虚拟专用网应用程序来保护他们的活动。然而，你有没有想过他们为什么这样做？在某些情况下，数据收集可能是不必要的和侵入性的。然而，数据驱动的分析是推动行业前进的动力。
企业将客户数据用于各种目的，如广告定位、R&D、定制产品等。业务经理分析客户数据，以检查产品或服务是否表现良好。用户如何购物，他们访问了哪些网页，这些都是 R & D 部门为了获得更好的洞察力和通过增加新功能来改进产品所做的事情。
如果你喜欢通过篡改数据来研究市场，Python 是你需要探索的语言。
最后的话
如果我们看看各种编程语言，对 Python 的需求是很高的。而且今天开发的大部分与 AI、ML 相关的应用都是有它做后盾的。因此，投入时间和金钱，这是一门伟大的语言。
Python 中列表的长度
原文：https://www.askpython.com/python/list/length-of-a-list-in-python
介绍
因此，在本教程中，我们将讨论 Python 中列表长度的含义，以及如何使用各种方法计算它。
我们知道， Python List 是一个可变的有序序列。它可能包含异类项目，也可能包含同类项目。它是 Python 中广泛使用的数据结构。为了遍历以及在列表上执行一些其他操作，我们有时需要找到列表的长度。
如何计算一个列表的长度？
计算列表的长度或大小类似于查找同一列表中的项目总数。
例如，如果我们有一个列表， list1 :
list1 = [5,4,7,2,9,6]
列表lis1的长度为 6 。因为元素或项目的总数是‘6’。
Python 中查找列表长度的方法
在 Python 中，可以通过应用各种技术来计算列表的长度。下面我们将逐一详细讨论。
1.在 Python 中使用 len()方法
Python 中内置的len()方法被广泛用于计算任何顺序数据类型的长度。它计算对象中元素或项目的数量，并返回与对象长度相同的值。
因此，我们可以直接获得一个列表的长度，通过将它传递给内置的len()方法。让我们看看如何。
#given list
l=[11,22,33,44,55,66]
#printing the length using len()
print("The length of the list",l, "is :",len(l))
输出:
The length of the list [11, 22, 33, 44, 55, 66] is : 6
在这段代码中:
- 我们先拿一张单子，
list1 - 然后我们直接将列表传递给
len()方法，它返回列表的长度。这在我们的例子中是 6 。
2.计算列表长度的自定义函数
现在让我们在 Python 中定义我们自己的函数，它将计算传递给它的列表的长度，并在调用函数的地方返回它。
下面是我们定义的用于查找列表长度的函数。
def calc_len(l):
c=0
for i in l:
c=c+1
return c
#given list
list1=['A',1,'B',2,'C',3,'D',4]
#printing the length using calc_len()
print("The length of the list",list1, "is :",calc_len(list1))
输出:
calc_len() Output
这里，
- 在上面的代码中，我们定义了一个函数
calc_len(),它将待求长度的列表作为参数 - 在
calc_len()函数中，我们初始化一个计数器 c ，它在每次for循环迭代中增加 1 ，并存储列表中的总条目数，最后返回计数器 c - 因此，我们将列表
list1传递给我们的用户定义函数 cal_len()返回我们直接打印的列表的长度。
结论
因此，在本教程中，我们学习了如何在 Python 中计算或查找列表的长度。如有任何问题，欢迎使用下面的评论框。
参考
- https://stack overflow . com/questions/1712227/how-do-I-get-the-number-of-elements-in-a-list
- https://docs.python.org/3/library/functions.html#len
求最长公共子序列的长度
原文：https://www.askpython.com/python/examples/length-of-longest-common-subsequence
在本教程中，我们将首先简要解释什么是子序列和最长的公共子序列，然后再深入代码。在代码部分，我们将学习如何使用递归和动态编程来发现最长公共子序列的长度。
让我们马上开始吧。
什么是后续？
字符串子序列是通过从先前的字符串中删除部分字符，同时保持字符的相对位置不变而创建的新字符串。
举个例子——
原始字符串= " abcdwxyz "
有效子序列= "ACDW "、" BYZ "、" ACWXYZ"
无效子序列= "VAYZ "、" DYAZ "、" XBACW "
最长公共子序列(LCS)是什么？
给定一组序列，最大的共同子序列挑战是识别所有序列共有的最长子序列。最长公共子序列问题的答案并不总是唯一的。可能有许多具有最长可行长度的公共子序列。
举个例子——
sequence 1 = " BAHJDGSTAH "
sequence 2 = " HDSABTGHD "
sequence 3 = " ABTH "
LCS 的长度= 3
LCS = "ATH "，" BTH "
方法 1:递归
我们从末尾开始比较字符串，在递归中一次比较一个字符。设 LCS 是确定两个字符串共享的最长子序列长度的函数。
有两种可能的情况:
- 字符是相同的——在 LCS 上加 1，通过删除最后一个字符——LCS(str 1，str2，m-1，n-1 ),使用更新后的字符串递归执行该过程。
- 字符是不同的——不超过(用删除最后一个字符的 sring 1 进行递归调用，用删除最后一个字符的 string 2 进行递归调用)。
def lcs(str1, str2, m, n):
if m==0 or n==0:
return 0
elif str1[m-1] == str2[n-1]:
return 1+lcs(str1, str2, m-1, n-1)
else:
return max(lcs(str1, str2, m-1, n),lcs(str1, str2, m,n-1))
str1 = input("Enter first string: ")
str2 = input("Enter second string: ")
lcs_length = lcs(str1, str2, len(str1), len(str2))
print("length of LCS is : {}".format(lcs_length))
Enter first string: BAHJDGSTAH
Enter second string: BAHJDGSTAH
length of LCS is : 5
方法 2:动态规划方法
这种技术采用自底向上的策略。子问题的解决方案保存在矩阵中以备将来使用。这被称为记忆化。如果两个字符串的长度分别为 m 和 n，则动态规划的时间复杂度为 O(mn)，这大大小于递归的时间复杂度。矩阵的最后一项表示 LCS 的长度。
def lcs(str1 , str2):
m = len(str1)
n = len(str2)
matrix = [[0]*(n+1) for i in range(m+1)]
for i in range(m+1):
for j in range(n+1):
if i==0 or j==0:
matrix[i][j] = 0
elif str1[i-1] == str2[j-1]:
matrix[i][j] = 1 + matrix[i-1][j-1]
else:
matrix[i][j] = max(matrix[i-1][j] , matrix[i][j-1])
return matrix[-1][-1]
str1 = input("Enter first string: ")
str2 = input("Enter second string: ")
lcs_length = lcs(str1, str2)
print("Length of LCS is : {}".format(lcs_length))
Enter first string: BAHJDGSTAH
Enter second string: BAHJDGSTAH
length of LCS is : 5
结论
恭喜你！您刚刚学习了如何显示最长公共子序列的长度。
喜欢这个教程吗？无论如何，我建议你看一下下面提到的教程:
感谢您抽出时间！希望你学到了新的东西！！😄
第 1 部分:Python 中的关卡编辑器——设置和背景图片
原文：https://www.askpython.com/python/examples/level-editor-in-python-part-1
嘿伙计们！在接下来的几个系列教程中，我们将学习如何使用 pygame 从头开始创建关卡编辑器！你需要对 Python 和 Pygame 有一个基本的了解才能完成本教程。所以如果你是第一次做，我建议你从 Python Pygame 简介开始。
我们先来了解一下编辑都是什么水平。
也看: PyGame 教程:Python 中的图形化 Hi-Lo 游戏
什么是关卡编辑器？
关卡编辑器是一个程序/窗口，它允许游戏开发者利用各种资源为数字游戏设计环境，以便设计游戏的多个关卡。
LevelEditor Real Life Demo
这也包括所有的挑战，字符必须面对和行动，他们必须采取措施，以征服他们，走向胜利！
用 Python 实现关卡编辑器
和往常一样，我们从导入模块开始，这里我们将使用init函数初始化 pygame 窗口。
import pygame
pygame.init()
1.创建关卡编辑器窗口
接下来，我们必须为关卡编辑器创建窗口。为此，我们将设置一些参数，如高度、宽度和边距。
现在，我们将保持宽度和高度分别为 800 和 640，下边距和侧边距分别为 100 和 300。您可以根据自己的喜好更改尺寸。
此处的页边距将用于以下功能:
- 下边距:
START和LOAD选项 - 侧边空白:显示可放置在屏幕上的
BLOCKS
接下来，我们将在set_mode函数的帮助下创建屏幕，该函数将获取屏幕的高度和宽度。与此同时，我们将在set_caption函数的帮助下设置窗口的标题。
现在我们希望我们的屏幕保持不动，直到点击右上角的X按钮。因此，我们将创建一个 while 循环，它将一直运行，直到变量running保持为True。
为了捕捉点击X时的事件，我们将使用event.get函数，该函数将考虑屏幕上发生的所有事件。
现在 pygame 中的每个事件都有一个定义好的名称。按下 X 的事件属于QUIT类型，因此如果事件类型为 QUIT，我们将运行变量设为False。
import pygame
pygame.init()
screen_width = 800
screen_height = 640
lower_margin = 100
side_margin = 300
screen = pygame.display.set_mode((screen_width+side_margin,screen_height+lower_margin))
pygame.display.set_caption('Level Editor')
running = True
while(running):
for event in pygame.event.get():
if(event.type==pygame.QUIT):
running = False
pygame.quit()
LevelEditor Blank Screen
现在的输出是一个空白的屏幕，现在已经准备好了一些背景图像和附加功能放在上面。
让我们开始在程序中加载图像吧！
2.在应用程序中加载图像
图像在load功能的帮助下加载，需要图像的路径，这取决于图像在系统中的位置。
加载发生在运行循环之前，如line 13 to 16之间所示。
import pygame
pygame.init()
screen_width = 800
screen_height = 640
lower_margin = 100
side_margin = 300
screen = pygame.display.set_mode((screen_width+side_margin,screen_height+lower_margin))
pygame.display.set_caption('Level Editor')
grass1 = pygame.image.load('Images/Background_Images/grass1.png').convert_alpha()
grass2 = pygame.image.load('Images/Background_Images/grass2.png').convert_alpha()
mountain = pygame.image.load('Images/Background_Images/mountain.png').convert_alpha()
sky = pygame.image.load('Images/Background_Images/sky.png').convert_alpha()
running = True
while(running):
for event in pygame.event.get():
if(event.type==pygame.QUIT):
running = False
pygame.quit()
3.将图像绘制到背景
现在接下来我们需要将图像绘制到背景中，我们将为其创建一个新的函数，如下面提到的从line 18开始的代码所示。
为了绘制图像，我们使用了blit函数，并且有必要在运行 while 循环的每次迭代中对视图进行update处理。
我们还需要图像的坐标，我已经根据我的屏幕尺寸设置了它们。你可以在你那端的定位上玩玩！
import pygame
pygame.init()
screen_width = 800
screen_height = 640
lower_margin = 100
side_margin = 300
screen = pygame.display.set_mode((screen_width+side_margin,screen_height+lower_margin))
pygame.display.set_caption('Level Editor')
tree1 = pygame.image.load('Images/Background_Images/grass1.png').convert_alpha()
tree2 = pygame.image.load('Images/Background_Images/grass2.png').convert_alpha()
mountain = pygame.image.load('Images/Background_Images/mountain.png').convert_alpha()
sky = pygame.image.load('Images/Background_Images/sky.png').convert_alpha()
def paint_bg():
screen.blit(sky,(0,0))
screen.blit(mountain,(0,screen_height-mountain.get_height()-300))
screen.blit(tree1,(0,screen_height-tree1.get_height()-150))
screen.blit(tree2,(0,screen_height-tree2.get_height()))
running = True
while(running):
paint_bg()
for event in pygame.event.get():
if(event.type==pygame.QUIT):
running = False
pygame.display.update()
pygame.quit()
LevelEditor Draft1
结论
到这一部分结束时，我们已经清楚了什么是关卡编辑器，以及如何为关卡编辑器创建一个基本的设置。在下一部分，我们将学习如何在屏幕上添加更多的元素。
更多零件敬请期待！快乐学习！😇
第 2 部分:Python 中的关卡编辑器——滚动背景和网格
原文：https://www.askpython.com/python/examples/level-editor-in-python-part-2
你好。所以在本教程中，我们将继续建立我们的水平编辑器。关卡编辑器对于为玩家创造一个惊人的挑战性游戏环境非常有用。
在这一部分，我们将致力于创建一个滚动背景和网格。让我们先来看看到目前为止我们所取得的成就。
阅读:第一部分:Python 中的关卡编辑器——设置和背景图
第 1 部分–最终代码
在这个的最后一部分，我们成功地创建了关卡编辑器的设置，并在窗口中添加了背景图片。最后一部分的代码如下:
import pygame
pygame.init()
screen_width = 800
screen_height = 640
lower_margin = 100
side_margin = 300
screen = pygame.display.set_mode((screen_width+side_margin,screen_height+lower_margin))
pygame.display.set_caption('Level Editor')
tree1 = pygame.image.load('Images/Background_Images/grass1.png').convert_alpha()
tree2 = pygame.image.load('Images/Background_Images/grass2.png').convert_alpha()
mountain = pygame.image.load('Images/Background_Images/mountain.png').convert_alpha()
sky = pygame.image.load('Images/Background_Images/sky.png').convert_alpha()
def paint_bg():
screen.blit(sky,(0,0))
screen.blit(mountain,(0,screen_height-mountain.get_height()-300))
screen.blit(tree1,(0,screen_height-tree1.get_height()-150))
screen.blit(tree2,(0,screen_height-tree2.get_height()))
running = True
while(running):
paint_bg()
for event in pygame.event.get():
if(event.type==pygame.QUIT):
running = False
pygame.display.update()
pygame.quit()
LevelEditor Draft1
背景的滚动能力
在我们使用滚动背景之前，我们需要声明下面列出的一些变量:
- 向左滚动
- 向右滚动
- 卷起
- 滚动速度
声明发生在运行函数之前。下面声明从line 13开始的变量。
在声明了这些变量之后，为了具备滚动能力，我们需要根据事件发生的情况，在运行循环中添加条件语句。
1.声明滚动变量和键
现在，要发生滚动事件，需要按下LEFT箭头键向左移动，按下RIGHT箭头键向右移动。因此，事件的类型将是一个KEYDOWN事件类型。
此外，我们将检查关键字是否为K_LEFT，然后使scroll_left变量为真，类似的情况也会发生在K_RIGHT和scroll_right变量上。
我们还需要添加释放键时的动作，因为这时滚动需要停止，两个变量再次被设置为 False。这种事件类型就是KEYUP事件。
查看下面提到的代码，了解前面解释的所有内容。
import pygame
pygame.init()
screen_width = 800
screen_height = 640
lower_margin = 100
side_margin = 300
screen = pygame.display.set_mode((screen_width+side_margin,screen_height+lower_margin))
pygame.display.set_caption('Level Editor')
scroll_left = False
scroll_right = False
scroll = 0
scroll_speed = 1
tree1 = pygame.image.load('Images/Background_Images/grass1.png').convert_alpha()
tree2 = pygame.image.load('Images/Background_Images/grass2.png').convert_alpha()
mountain = pygame.image.load('Images/Background_Images/mountain.png').convert_alpha()
sky = pygame.image.load('Images/Background_Images/sky.png').convert_alpha()
def paint_bg():
screen.blit(sky,(0,0))
screen.blit(mountain,(0,screen_height-mountain.get_height()-300))
screen.blit(tree1,(0,screen_height-tree1.get_height()-150))
screen.blit(tree2,(0,screen_height-tree2.get_height()))
running = True
while(running):
paint_bg()
for event in pygame.event.get():
if(event.type==pygame.QUIT):
running = False
if(event.type == pygame.KEYDOWN):
if(event.key == pygame.K_LEFT):
scroll_left = True
if(event.key == pygame.K_RIGHT):
scroll_right = True
if(event.type == pygame.KEYUP):
if(event.key == pygame.K_LEFT):
scroll_left = False
if(event.key == pygame.K_RIGHT):
scroll_right = False
pygame.display.update()
pygame.quit()
但是这还不会增加滚动功能。因为我们已经给一些变量赋值了，但是还没有做任何事情。
2.创建滚动条件
为了实现这一点，我们将在调用背景绘画函数后在运行循环中创建一些条件语句，如下面提到的代码所示。
我们想让窗口滚动 5 的像素值，我们需要做的另一个重要步骤是确保背景图像从滚动开始向两个方向绘制。
因此，在paint_bg函数中，我们将改变图像的起始坐标为scroll。我们需要做的另一件重要的事情是在坐标前添加一个minus(–)，以使滚动方向正确。
看到输出，你会大吃一惊。你自己去看看吧！
import pygame
pygame.init()
screen_width = 800
screen_height = 640
lower_margin = 100
side_margin = 300
screen = pygame.display.set_mode((screen_width+side_margin,screen_height+lower_margin))
pygame.display.set_caption('Level Editor')
scroll_left = False
scroll_right = False
scroll = 0
scroll_speed = 1
tree1 = pygame.image.load('Images/Background_Images/grass1.png').convert_alpha()
tree2 = pygame.image.load('Images/Background_Images/grass2.png').convert_alpha()
mountain = pygame.image.load('Images/Background_Images/mountain.png').convert_alpha()
sky = pygame.image.load('Images/Background_Images/sky.png').convert_alpha()
def paint_bg():
screen.blit(sky,(-scroll,0))
screen.blit(mountain,(-scroll,screen_height-mountain.get_height()-300))
screen.blit(tree1,(-scroll,screen_height-tree1.get_height()-150))
screen.blit(tree2,(-scroll,screen_height-tree2.get_height()))
running = True
while(running):
paint_bg()
if(scroll_left==True):
scroll-=5
if(scroll_right==True):
scroll+=5
for event in pygame.event.get():
if(event.type==pygame.QUIT):
running = False
if(event.type == pygame.KEYDOWN):
if(event.key == pygame.K_LEFT):
scroll_left = True
if(event.key == pygame.K_RIGHT):
scroll_right = True
if(event.type == pygame.KEYUP):
if(event.key == pygame.K_LEFT):
scroll_left = False
if(event.key == pygame.K_RIGHT):
scroll_right = False
pygame.display.update()
pygame.quit()
LevelEditor Scroll Output 1
哦，看看滚动后我们的图像变得多么混乱！我们想要这样吗？没有权利。
先搞定背景吧！
3.优化滚动背景
首先，让我们使滚动背景一些随机的颜色。为了做到这一点，我们要确保在每次迭代中，我的背景都用颜色填充，稍后，我们将在绘制的颜色上填充原始背景图像。
为了实现这一点，我们将获取一个变量x并对其进行多次迭代n(这个 n 可以是任何值，现在我取 4)。然后，我们将改变初始坐标，并增加图像的宽度。
这里图像的宽度是一样的，所以我们可以取一个变量。在您的情况下，如果宽度不同，请单独使用。
我们需要做的另一件事是滚动。为此，我们在下面提到的代码的第 38 行添加了一个附加条件。
import pygame
pygame.init()
screen_width = 800
screen_height = 640
lower_margin = 100
side_margin = 300
screen = pygame.display.set_mode((screen_width+side_margin,screen_height+lower_margin))
pygame.display.set_caption('Level Editor')
scroll_left = False
scroll_right = False
scroll = 0
scroll_speed = 1
tree1 = pygame.image.load('Images/Background_Images/grass1.png').convert_alpha()
tree2 = pygame.image.load('Images/Background_Images/grass2.png').convert_alpha()
mountain = pygame.image.load('Images/Background_Images/mountain.png').convert_alpha()
sky = pygame.image.load('Images/Background_Images/sky.png').convert_alpha()
def paint_bg():
screen.fill((144,201,120)) # Green Color
width = sky.get_width()
for x in range(4):
screen.blit(sky,((x*width)-scroll,0))
screen.blit(mountain,((x*width)-scroll,screen_height-mountain.get_height()-300))
screen.blit(tree1,((x*width)-scroll,screen_height-tree1.get_height()-150))
screen.blit(tree2,((x*width)-scroll,screen_height-tree2.get_height()))
running = True
while(running):
paint_bg()
if(scroll_left==True and scroll>0):
scroll-=5
if(scroll_right==True):
scroll+=5
for event in pygame.event.get():
if(event.type==pygame.QUIT):
running = False
if(event.type == pygame.KEYDOWN):
if(event.key == pygame.K_LEFT):
scroll_left = True
if(event.key == pygame.K_RIGHT):
scroll_right = True
if(event.type == pygame.KEYUP):
if(event.key == pygame.K_LEFT):
scroll_left = False
if(event.key == pygame.K_RIGHT):
scroll_right = False
pygame.display.update()
pygame.quit()
在屏幕上绘制网格
为了有网格线，首先我们需要声明一些变量，包括你在屏幕上需要的行数和列数(你可以根据你的喜好设置它们)。我们还需要计算网格上每个square瓷砖的大小，我们定义了颜色WHITE来给网格添加颜色。
为了在屏幕上绘制网格线，我们声明了一个函数，它将在屏幕上绘制垂直线和水平线。我们将使用循环来确保网格线随着滚动而移动，而不是静止在屏幕上。
在下面提到的代码中，网格线的代码从Line 34开始。
import pygame
pygame.init()
screen_width = 800
screen_height = 640
lower_margin = 100
side_margin = 300
screen = pygame.display.set_mode((screen_width+side_margin,screen_height+lower_margin))
pygame.display.set_caption('Level Editor')
scroll_left = False
scroll_right = False
scroll = 0
scroll_speed = 1
tree1 = pygame.image.load('Images/Background_Images/grass1.png').convert_alpha()
tree2 = pygame.image.load('Images/Background_Images/grass2.png').convert_alpha()
mountain = pygame.image.load('Images/Background_Images/mountain.png').convert_alpha()
sky = pygame.image.load('Images/Background_Images/sky.png').convert_alpha()
def paint_bg():
screen.fill((144,201,120)) # Green Color
width = sky.get_width()
for x in range(4):
screen.blit(sky,((x*width)-scroll,0))
screen.blit(mountain,((x*width)-scroll,screen_height-mountain.get_height()-300))
screen.blit(tree1,((x*width)-scroll,screen_height-tree1.get_height()-150))
screen.blit(tree2,((x*width)-scroll,screen_height-tree2.get_height()))
no_rows = 16
no_columns = 150
tile_size = screen_height//no_rows
WHITE = (255, 255, 255)
def draw_gridlines():
#vertical lines
for c in range(no_columns + 1):
pygame.draw.line(screen, WHITE, (c * tile_size - scroll, 0), (c * tile_size - scroll, screen_height))
#horizontal lines
for c in range(no_rows + 1):
pygame.draw.line(screen, WHITE, (0, c * tile_size), (screen_width, c * tile_size))
running = True
while(running):
paint_bg()
draw_gridlines()
if(scroll_left==True and scroll>0):
scroll-=5
if(scroll_right==True):
scroll+=5
for event in pygame.event.get():
if(event.type==pygame.QUIT):
running = False
if(event.type == pygame.KEYDOWN):
if(event.key == pygame.K_LEFT):
scroll_left = True
if(event.key == pygame.K_RIGHT):
scroll_right = True
if(event.type == pygame.KEYUP):
if(event.key == pygame.K_LEFT):
scroll_left = False
if(event.key == pygame.K_RIGHT):
scroll_right = False
pygame.display.update()
pygame.quit()
LevelEditor GridLines Addition
我知道你可能想知道只有垂直线的部分。在后面的章节中，这个部分将被侧板覆盖。
所以不用担心。😇
结论
在这一部分的最后，我们学会了在关卡编辑器上添加滚动效果，并添加网格线来帮助我们稍后为关卡添加方块。在下一部分，我们将学习如何在屏幕上添加更多的元素。
更多零件敬请期待！快乐学习！😇
使用 Pygal 实现折线图可视化
原文：https://www.askpython.com/python-modules/line-chart-visualization-pygal
Python 有不同的可视化包，可以用来制作不同种类的图表、图形和绘图。Pygal 是一个开源 Python 包，它不仅可以生成高度交互的图形，还可以生成图形和图形的 SVG 图片，允许我们根据需要使用和修改它们。Pygal 非常灵活，只需要几行代码就可以生成图形。
也可阅读: 4 易绘图库为 Python 配实例
在本教程中，我们将探索可以使用PyGal创建的折线图可视化，以及如何以SVG格式下载。
在我们开始检查 pygal 之前，它必须安装有pip install pygal。安装后，我们将导入 pygal 进行可视化。
我们将使用下面的代码从一个简单的折线图开始我们的可视化。我们将从使用Line函数创建一个空折线图开始，并使用title属性设置图表的标题。
接下来，我们将随机设置x_labels，然后我们将为四种不同的编程语言制作折线图，并为每个折线图添加线标签和值。最后，我们将使用render_to_file方法保存并呈现 SVG 格式的绘图。
# Create an empty Line Chart
Line_Chart = pygal.Line()
# Set title of the Line Chart
Line_Chart.title = 'A demonstration of Line Chart using Pygal'
# Set x labels/values
Line_Chart.x_labels = map(str, range(2000, 2022))
# Adding Line Chart for each language popularity over the years
Line_Chart.add('Python', [None, None, 0, 16.1, 22, 30, 36.9, 45.1,
46.1, 42.33, 37.11, 38.5,50.78, 53.62, 55.37,
60.22, 60.5, 61.68, 68.65, 79.83, 80.25, 85.44])
Line_Chart.add('Kotlin', [None, None, None, None, None, None, 0, 3.5, 10.1,
23.1, 35.2,24.03, 46.53, 46.74, 47.31, 59.93,
16.11, 22.94, 23.56,1.86, 16.07])
Line_Chart.add('C++', [0.99, 7.15, 8.39, 9.78, 14.0, 25.66, 33.3, 35.8, 40.11,
54.92, 57.17, 60.14, 68.63, 73.11, 75.99, 79.37, 89.73,
90.82, 95.71,60.66,61.43, 64.94])
Line_Chart.add('Java', [14.1, 15.8, 15.1, 8.8, 8, 10.1, 18.4, 15.1, 16.6,
16.1, 17.4,19.27, 21.24, 29.29, 38.04, 43.24,
54.0, 62.55,11.28, 12.08, 13.19,29.35])
# Save the plot in svg format
Line_Chart.render_to_file('Line_Chart_Demo.svg')
Line Chart Pygal
我们还可以借助下面代码所示的HorizontalLine方法来可视化Horizontal Line Chart。其余的代码保持不变。
# Create an empty Line Chart
Line_Chart = pygal.HorizontalLine()
# Set title of the Line Chart
Line_Chart.title = 'A Horizontal Line Chart using Pygal'
# Set x labels/values
Line_Chart.x_labels = map(str, range(2000, 2022))
# Adding Line Chart for each language popularity over the years
Line_Chart.add('Python', [None, None, 0, 16.1, 22, 30, 36.9, 45.1,
46.1, 42.33, 37.11, 38.5,50.78, 53.62, 55.37,
60.22, 60.5, 61.68, 68.65, 79.83, 80.25, 85.44])
Line_Chart.add('Kotlin', [None, None, None, None, None, None, 0, 3.5, 10.1,
23.1, 35.2,24.03, 46.53, 46.74, 47.31, 59.93,
16.11, 22.94, 23.56,1.86, 16.07])
Line_Chart.add('C++', [0.99, 7.15, 8.39, 9.78, 14.0, 25.66, 33.3, 35.8, 40.11,
54.92, 57.17, 60.14, 68.63, 73.11, 75.99, 79.37, 89.73,
90.82, 95.71,60.66,61.43, 64.94])
Line_Chart.add('Java', [14.1, 15.8, 15.1, 8.8, 8, 10.1, 18.4, 15.1, 16.6,
16.1, 17.4,19.27, 21.24, 29.29, 38.04, 43.24,
54.0, 62.55,11.28, 12.08, 13.19,29.35])
# Save the plot in svg format
Line_Chart.render_to_file('Horizontal_Line_Chart_Demo.svg')
Horizontal Line Chart Pygal
我们还可以借助下面代码所示的StackedLine方法来可视化Stacked Line Chart。我们可以通过一个属性fill作为True来填充线条剧情，有创意！
# Create an empty Line Chart
Line_Chart = pygal.StackedLine(fill=True)
# Set title of the Line Chart
Line_Chart.title = 'A Stacked Line Chart (Filled) using Pygal'
# Set x labels/values
Line_Chart.x_labels = map(str, range(2000, 2022))
# Adding Line Chart for each language popularity over the years
Line_Chart.add('Python', [None, None, 0, 16.1, 22, 30, 36.9, 45.1,
46.1, 42.33, 37.11, 38.5,50.78, 53.62, 55.37,
60.22, 60.5, 61.68, 68.65, 79.83, 80.25, 85.44])
Line_Chart.add('Kotlin', [None, None, None, None, None, None, 0, 3.5, 10.1,
23.1, 35.2,24.03, 46.53, 46.74, 47.31, 59.93,
16.11, 22.94, 23.56,1.86, 16.07])
Line_Chart.add('C++', [0.99, 7.15, 8.39, 9.78, 14.0, 25.66, 33.3, 35.8, 40.11,
54.92, 57.17, 60.14, 68.63, 73.11, 75.99, 79.37, 89.73,
90.82, 95.71,60.66,61.43, 64.94])
Line_Chart.add('Java', [14.1, 15.8, 15.1, 8.8, 8, 10.1, 18.4, 15.1, 16.6,
16.1, 17.4,19.27, 21.24, 29.29, 38.04, 43.24,
54.0, 62.55,11.28, 12.08, 13.19,29.35])
# Save the plot in svg format
Line_Chart.render_to_file('Stacked_Filled_Line_Chart_Demo.svg')
Stacked Filled Line Chart Pygal
我希望你通过这篇教程学到了一些新的有趣的东西。
感谢您的阅读！
我也向您推荐这些教程:
Python 中的线性判别分析——详细指南
原文：https://www.askpython.com/python/examples/linear-discriminant-analysis
线性判别分析是一种解决多分类器问题的降维技术。它也被用于大多数监督分类问题。它提供了一种寻找对象或类的特征之间的线性组合的方法。通过分析这个分析过程中涉及的步骤，我们可以更好地理解这一点。
- 不同类别特征的计算方法。
- 计算散布类内的和散布类间的。
散布类矩阵由公式
确定，其中 c 是类的总数
，
其中 X [k] 为样品，n 为样品编号。
类间散布矩阵由
决定；其中
和
- 使用算法计算特征值和特征向量。
- 将特征值和特征向量转换成矩阵。
- 一旦矩阵形成，它可以用于分类和降维。
假设我们有两类不同的特征，因为我们知道仅使用单一特征对这两类进行分类是困难的。因此，我们需要最大化特征，使我们的分类更容易。这也是我们在这个主题中的目标。
线性判别分析的应用
让我们来看看线性判别分析的应用。
- 分类，例如将电子邮件分类为垃圾邮件、重要邮件或其他邮件。
- 人脸识别。
- 条形码和二维码扫描。
- 购物平台中使用人工智能的客户识别。
- 决策。
- 未来预测的预测。
通过创建一个模型并使用它，我们可以更好地理解这一点。我们用 python 预装了数据集，这是生化数据集。我们将根据数据集中的特征对婚姻状况进行分类。
用 Python 实现线性判别分析算法
为此，我们将从该数据集中提取一些数据，并将其分别作为独立变量和从属变量加载到变量中。然后，我们也将应用线性判别分析来降低这些变量的维数，并在图表中绘制这些变量。让我们看看下面的代码片段。
步骤 1:导入模块
import pandas as pd
from pydataset import data
from matplotlib import pyplot as plt
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report
from sklearn import metrics
在上面的代码片段中，我们也导入了所需的模块。如果它在导入上述模块或库时显示任何错误，您可以使用 pip 安装程序在命令提示符下手动安装它们。
步骤 2:加载数据集
在我们今天的代码中，我们将使用一个预加载的数据集。我们将获取一个数据集，并将其加载到数据框 df 中。快速浏览一下下面的代码。
#loading our preloaded dataset into a dataframe df
df = data('bioChemists')
#printing our dataframe
df.head()
步骤 3:分别为自变量和因变量赋值
我们将分别为自变量和因变量分配一些值或数据。在此之前，我们将创建一些所需数据的列，并将它们全部添加到我们的数据框架中，以便更好地进行分析。
#creating columns for each value in fem and assigning 1 for positve and 0 for negative
dummy = pd.get_dummies(df['fem'])
#adding the resultant icolumns to our dataframe using concat() method
df = pd.concat([df, dummy], axis = 1)
#repeat the same for the values of mar columns
dummy = pd.get_dummies(df['mar'])
df = pd.concat([df, dummy], axis = 1)
#independent variable
x = df[['Men', 'kid5', 'phd', 'ment', 'art']]
#dependent variable
y = df['Married']
第四步:拆分
我们将使用train _ test _ split()方法将数组和度量拆分为数据子集，分别作为 trains 和 tests (二维数组转化为线性)。我们使用参数 random_state=0在每次执行后获得相同的训练和测试集。
我们已经通过了 test_size=0.3，这意味着 30%的数据将在测试集中，其余的将在训练集中。
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size = 0.3, random_state = 0)
步骤 5:创建模型
我们将创建我们需要的线性判别分析模型，我们将检查其工作的准确性。
#creating our linear discrimanant analysis model
clf = LinearDiscriminantAnalysis()
#checking for the model accuracy using score method
clf.fit(x_train, y_train).score(x_train, y_train)
步骤 6: ROC(接收机工作特性)
ROC 曲线(接收器工作特性)是一个图表，显示分类模型在所有阈值水平的性能。
这条曲线绘出了两个参数:真阳性率。假阳性率。
下面的函数使用两个缩减的维度计算接收器的工作特性。我们不绘制线性缩减变量，而是绘制相同变量的 ROC 曲线。
fpr, tpr, threshold = metrics.roc_curve(y_test, y_pred)
#calculating area under the curve(AUC)
auc = metrics.auc(fpr, tpr)
auc
步骤 7:使用 pyplot 绘制数据
现在，我们将绘制接收器工作特性曲线，用于分别从因变量和自变量的缩减维度获得的真阳性率和假阳性率。
#plotting our ROC curve using above terminologies
plt.title("Linear Discriminant Analysis")
plt.clf()
#plotting for roc curve
plt.plot(fpr, tpr, color="navy", linestyle="--", label = "roc_curve = %0.2f"% auc)
plt.legend(loc = "upper center")
#assigning the axis values
plt.plot([0,1.5], [0,1.5], ls = '-', color="red")
plt.xlabel("False Positive Rate")
plt.ylabel("True Positive Rate")
摘要
今天我们讨论了一个线性判别分析模型的例子。希望你们已经从我们的代码片段中学到了。我们必须带着一些令人兴奋的话题再次访问。
Python 中从头开始的线性回归
原文：https://www.askpython.com/python/examples/linear-regression-from-scratch
在本文中，我们将学习使用 Python 从头实现线性回归。线性回归是一种基本且最常用的预测分析类型。
它用于根据一个变量的值预测另一个变量的值。我们要预测的变量叫做因变量。
我们用来预测因变量的值的变量叫做自变量。
一个因变量和一个自变量的回归方程的最简单形式。
y = m * x + b
在哪里，
- y =估计的相关值。
- b =常数或偏差。
- m =回归系数或斜率。
- x =独立变量的值。
从头开始线性回归
在本文中，我们将只使用 Numpy 从头开始实现线性回归。
1.理解损失函数
虽然有许多损失函数要实现，但我们将使用均方误差函数作为我们的损失函数。
MSE
顾名思义，均方误差函数是真实值和预测值之差的平方和的平均值。
由于 y 的预测值取决于斜率和常数，因此我们的目标是找到斜率和常数的值，使损失函数最小化，或者换句话说，使 y 预测值和真实值之间的差异最小化。
2.最优化算法
优化算法用于在给定最小化损失函数的训练数据集的情况下找到最佳参数集，在我们的情况下，我们需要找到斜率(m)和常数(b)的最佳值。
一种这样的算法是梯度下降。
梯度下降是迄今为止机器学习中最常用的优化算法。
使用梯度下降，我们迭代地计算损失函数相对于参数的梯度，并持续更新参数，直到我们达到局部最小值。
3.实施梯度下降的步骤
我们先来了解一下梯度下降算法的幕后工作原理。
步骤 1 初始化参数
这里，我们需要初始化参数的值。还是保留slope = 0和constant = 0吧。
我们还需要一个学习率来确定每次迭代的步长，同时向损失函数的最小值移动。
步骤 2 计算关于参数的偏导数
这里，我们对损失函数相对于现有参数进行部分求导。
Gradient Of Slope And Bias
步骤–3 更新参数
现在，我们使用下面给出的公式更新参数值:
Updating Parameters
我们参数的更新值将是每一步最小化我们的损失函数并减少真实值和预测值之间的差异的值。
重复该过程以达到局部最小值点。
4.在 Python 中从头开始实现线性回归
既然我们已经了解了如何使用梯度下降实现线性回归，那么让我们用 Python 来编写代码。
我们将用两个方法.fit( )和.predict( )定义LinearRegression类
#Import required modules
import numpy as np
#Defining the class
class LinearRegression:
def __init__(self, x , y):
self.data = x
self.label = y
self.m = 0
self.b = 0
self.n = len(x)
def fit(self , epochs , lr):
#Implementing Gradient Descent
for i in range(epochs):
y_pred = self.m * self.data + self.b
#Calculating derivatives w.r.t Parameters
D_m = (-2/self.n)*sum(self.data * (self.label - y_pred))
D_b = (-1/self.n)*sum(self.label-y_pred)
#Updating Parameters
self.m = self.m - lr * D_m
self.c = self.b - lr * D_c
def predict(self , inp):
y_pred = self.m * inp + self.b
return y_pred
我们创建了一个LinearRegression类的实例，将训练数据作为该类的输入，并将偏差和常数值初始化为 0。
我们类中的.fit( )方法实现了梯度下降，在每次迭代中，我们计算函数相对于参数的偏导数，然后使用学习率和梯度值更新参数。
使用.predict( )方法，我们简单地评估函数y = m * x + b，使用参数的最佳值，换句话说，该方法估计最佳拟合线。
4.测试线性回归模型
现在，当我们创建类时，让我们测试数据。了解有关如何分割训练和测试数据集的更多信息。你可以在这里找到本教程中使用的数据集和其他资源。
#importing Matplotlib for plotting
import matplotlib.pyplot as plt
#Loding the data
df = pd.read_csv('data_LinearRegression.csv')
#Preparing the data
x = np.array(df.iloc[:,0])
y = np.array(df.iloc[:,1])
#Creating the class object
regressor = LinearRegression(x,y)
#Training the model with .fit method
regressor.fit(1000 , 0.0001) # epochs-1000 , learning_rate - 0.0001
#Prediciting the values
y_pred = regressor.predict(x)
#Plotting the results
plt.figure(figsize = (10,6))
plt.scatter(x,y , color = 'green')
plt.plot(x , y_pred , color = 'k' , lw = 3)
plt.xlabel('x' , size = 20)
plt.ylabel('y', size = 20)
plt.show()
Prediction Linear Regression
工作正常！
结论
这篇文章讲的是我们如何只用 Numpy 从头开始建立一个线性回归模型。本教程的目标是给你一个更深层次的线性回归的概念，以及它是如何工作的。
直到我们下次见面。
快乐学习！
简单线性回归:Python 中的实用实现
原文：https://www.askpython.com/python/examples/linear-regression-in-python
欢迎阅读这篇关于简单线性回归的文章。今天，我们将看看如何建立一个简单的线性回归模型给定一个数据集。在本文的编码示例之前，您可以仔细阅读我们详述简单线性回归概念的文章。
建立线性回归模型的 6 个步骤
步骤 1:导入数据集
步骤 2:数据预处理
步骤 3:拆分测试集和训练集
步骤 4:将线性回归模型拟合到训练集
步骤 5:预测测试结果
步骤 6:可视化测试结果
现在我们已经看到了这些步骤，让我们从编写相同的代码开始
用 Python 实现线性回归模型
在本文中，我们将使用工资数据集。我们的数据集将有 2 列，即工作经验和薪水。
到数据集的链接是-https://github.com/content-anu/dataset-simple-linear
1.导入数据集
我们将从使用 pandas 导入数据集开始，也导入其他库，如 numpy 和 matplotlib 。
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
dataset = pd.read_csv('Salary_Data.csv')
dataset.head()
dataset.head()显示了我们数据集的前几列。上述代码片段的输出如下:
Dataset
2.数据预处理
既然我们已经导入了数据集，我们将执行数据预处理。
X = dataset.iloc[:,:-1].values #independent variable array
y = dataset.iloc[:,1].values #dependent variable vector
X是自变量数组，y是因变量向量。注意数组和向量的区别。因变量必须是向量，自变量必须是数组本身。
3.分割数据集
我们需要将数据集分成测试集和训练集。一般我们分别遵循二八政策或者三七政策。
为什么需要进行拆分？这是因为我们希望根据年龄和工资来训练我们的模型。然后我们在测试集上测试我们的模型。
我们检查模型对测试集数据做出的预测是否与数据集中给出的预测相匹配。
如果匹配，这意味着我们的模型是准确的，并且做出了正确的预测。
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X,y,test_size=1/3,random_state=0)
我们不需要为线性回归应用特性缩放，因为库会处理它。
4.将线性回归模型拟合到训练集中
从 sklearn 的线性模型库中，导入线性回归类。为名为 regressor 的线性回归类创建一个对象。
为了使回归量适合训练集，我们将调用 fit method–function 来使回归量适合训练集。
我们需要将 X_train(特征矩阵的训练数据)拟合到目标值 y_train 中。因此，该模型学习相关性，并学习如何根据自变量预测因变量。
from sklearn.linear_model import LinearRegression
regressor = LinearRegression()
regressor.fit(X_train,y_train) #actually produces the linear eqn for the data
Output equation
5.预测测试集结果
我们创建一个包含所有测试集薪水预测的向量。然后将预测的工资放入名为y_pred的向量中。(包含测试集中所有观察值的预测)
predict方法对测试集进行预测。因此，输入是测试集。predict 的参数必须是数组或稀疏矩阵，因此输入是 X_test。
y_pred = regressor.predict(X_test)
y_pred
y-pred output
y_test
y-test output
y_test是测试集的真实工资。
y_pred是预测的薪资。
可视化结果
让我们看看当我们可视化代码时，它的结果会是什么样子。
1.绘制点(观察值)
为了可视化数据，我们使用 matplotlib 绘制图表。绘制实际观测点，即绘制实际给定值。
X 轴代表多年的经验，Y 轴代表预测的薪水。
plt.scatter绘制数据的散点图。参数包括:
- X 坐标(X_train:年数)
- y 坐标(y_train:员工的实际工资)
- 颜色(红色回归线和蓝色观察线)
2.绘制回归线
plt.plot 有以下参数:
- X 坐标(X _ train)-年数
- y 坐标(在 X_train 上预测)-X-train 的预测(基于若干年)。
注意:y 坐标不是 y_pred，因为 y_pred 是测试集观测值的预测工资。
#plot for the TRAIN
plt.scatter(X_train, y_train, color='red') # plotting the observation line
plt.plot(X_train, regressor.predict(X_train), color='blue') # plotting the regression line
plt.title("Salary vs Experience (Training set)") # stating the title of the graph
plt.xlabel("Years of experience") # adding the name of x-axis
plt.ylabel("Salaries") # adding the name of y-axis
plt.show() # specifies end of graph
上述代码为列车组生成一个图，如下所示:
Output graph for training set
#plot for the TEST
plt.scatter(X_test, y_test, color='red')
plt.plot(X_train, regressor.predict(X_train), color='blue') # plotting the regression line
plt.title("Salary vs Experience (Testing set)")
plt.xlabel("Years of experience")
plt.ylabel("Salaries")
plt.show()
上面的代码片段生成了一个如下所示的图:
Output graph for test set
实现线性回归的完整 Python 代码
# importing the dataset
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
dataset = pd.read_csv('Salary_Data.csv')
dataset.head()
# data preprocessing
X = dataset.iloc[:, :-1].values #independent variable array
y = dataset.iloc[:,1].values #dependent variable vector
# splitting the dataset
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X,y,test_size=1/3,random_state=0)
# fitting the regression model
from sklearn.linear_model import LinearRegression
regressor = LinearRegression()
regressor.fit(X_train,y_train) #actually produces the linear eqn for the data
# predicting the test set results
y_pred = regressor.predict(X_test)
y_pred
y_test
# visualizing the results
#plot for the TRAIN
plt.scatter(X_train, y_train, color='red') # plotting the observation line
plt.plot(X_train, regressor.predict(X_train), color='blue') # plotting the regression line
plt.title("Salary vs Experience (Training set)") # stating the title of the graph
plt.xlabel("Years of experience") # adding the name of x-axis
plt.ylabel("Salaries") # adding the name of y-axis
plt.show() # specifies end of graph
#plot for the TEST
plt.scatter(X_test, y_test, color='red')
plt.plot(X_train, regressor.predict(X_train), color='blue') # plotting the regression line
plt.title("Salary vs Experience (Testing set)")
plt.xlabel("Years of experience")
plt.ylabel("Salaries")
plt.show()
上述代码片段的输出如下所示:
Output graphs
结论
关于简单的线性回归，我们已经到了这篇文章的结尾。希望你喜欢我们的例子，并尝试编码模型。请在下面的评论区告诉我们您的反馈。
如果你对更多的回归模型感兴趣，请通读多元线性回归模型。
Python 中的线性搜索——一种实用的方法
原文：https://www.askpython.com/python/examples/linear-search-algorithm
让我们了解一下 Python 中一个简单明了的搜索算法。
线性搜索算法
线性搜索的工作方式非常类似于我们在一个随机的列表中进行搜索。
假设我们需要在给定的页面上找到一个单词，我们将从顶部开始，逐个查看每个单词，直到找到我们要找的单词。
与此类似，线性搜索从第一个项目开始，然后检查列表中的每个项目，直到找到项目或列表用尽。
让我们举一个例子:
线性搜索算法的理论示例
考虑一下，
- 名单:2000 年 19 日，8 日，2 日，99 日，24 日，17 日，15 日，88 日，40 日
- 目标:99
所以，我们需要在给定的列表中找到 99。我们从第一项开始，然后仔细检查清单上的每一项。
- 项目 1: 19，未找到。
- 第二项:2000，未找到。
- 项目 3: 8，未找到。
- 项目 4: 2，未找到。
- 项目 5，99，发现目标，结束循环。
因此，我们在位置 5 经过五次检查后找到了给定的目标。
如果给定的目标不在列表中，那么我们会遍历整个列表而找不到该项，在列表结束后，我们会将该项声明为未找到。
请注意，我们以线性方式查看列表中的每一项，这就是为什么该算法如此命名的原因。
关于效率的一个注记
线性搜索并不是一个非常有效的算法，它遍历列表中的每一项，所以算法直接受列表中项目数量的影响。
换句话说，该算法的时间复杂度为 O(n)。这意味着，如果列表中的项目数乘以一个数量，那么完成该算法所需的时间将乘以该数量。
有更好的搜索算法，如 Sentinel、 Binary 或 Fibonacci Search，但线性搜索是所有这些算法中最简单和最基本的，这意味着每个程序员都应该知道如何使用它。
用 Python 实现线性搜索算法
def linear_search(lst, target):
for i in range(len(lst)):
if(lst[i] == target):
return i
return -1
让我们看看代码，
- 我们正在创建一个接受两个参数的线性搜索函数。第一个参数是包含项目的列表，第二个参数是要查找的目标项目。
- 然后，我们用计数器
i，i创建一个循环，将保存给定列表的所有索引，即i将从 0 到列表长度-1。 - 在每次迭代中，我们都将目标与索引
i处的列表项进行比较。 - 如果它们是相同的，那么这意味着我们已经在列表中的那个索引处找到了目标，所以我们简单地返回那个索引并结束循环和函数。
- 如果检查了整个列表，但没有返回任何项，那么控件将移出列表，现在我们确信目标项不在列表中，所以我们返回-1，以此来表明没有找到该项。
让我们看看对于列表中的一个项目和不在列表中的另一个项目，算法将如何表现:
输出
Linear Search
这里，我们发送两个项目作为目标:99，它在列表中的索引 4 处，12，它不在列表中。
正如我们所看到的，算法为 99 返回了索引 4，为 12 返回了-1。这表明 99 在索引 4 处，12 不在列表中，因此算法正在工作。
结论
在本教程中，我们学习了一个非常简单的搜索算法，叫做线性搜索。
我们讨论了线性搜索是如何工作的，我们谈到了它的效率以及为什么它被命名为“线性”。
然后，我们看了算法是如何用 Python 编写的，它做了什么，并通过查看代码的输出证实了这一点。我希望你学到了一些东西，下节课再见。
Python 中的链表
原文：https://www.askpython.com/python/examples/linked-lists-in-python
Python 中的链表是最有趣的抽象数据类型之一，自 C/C++时代以来一直很流行。在本文中，我们将从头开始学习如何用 Python 实现一个链表。
什么是链表？
链表 是一种线性数据结构，其中每个元素都是一个单独的对象。与数组不同，链表的元素不一起存储在内存中。
链表的每个元素指向它后面的元素。这里的点意味着每个元素存储下一个元素的地址。
在遍历链表时，我们使用这些指针从一个节点跳到下一个节点。
对于每个链表，有两个元素需要考虑:
- 节点——我们通过创建一个节点类来处理它们
- 节点之间的连接——我们将用 Python 中的变量和列表来处理这个问题。
如何用 Python 创建链表？
让我们回顾一下用 Python 创建链表的步骤。
创建节点类
为了创建我们自己的链表，我们需要定义一个节点类。在我们定义一个节点类之前，我们需要考虑这个类应该有哪些字段。
一个链表节点应该存储两件事。这些是:
- 数据
- 下一节点的地址
让我们用这两个字段定义一个节点类。
class Node(object):
def __init__(self, data=None, next_node=None):
self.data = data
self.next_node = next_node
创建链表类
让我们创建另一个类，它将初始化一个空节点来创建一个链表。
class LinkedList(object):
def __init__(self, head=None):
self.head = head
这门课中有几个重要的功能。让我们回顾一下每个类的目的和定义。
1.打印列表的功能
让我们写一个函数来打印我们的链表。为了打印链表，我们需要遍历整个链表并不断打印每个节点的数据。
def printList(self):
temp = self.head
while (temp):
print (temp.data, " -> ", end = '')
temp = temp.next_node
print("")
2.获取列表的大小
让我们写一个返回链表大小的函数。为了计算大小，我们需要遍历整个列表，并在这样做的同时保存一个计数器。
def size(self):
current = self.head
count = 0
while current:
count += 1
current = current.next_node
return count
这个函数将返回链表的大小。
3.在开头插入一个新节点
让我们写一个函数在头部插入一个新的节点。
def insert_at_head(self, data):
new_node = Node(data)
new_node.next_node = self.head
self.head = new_node
这将创建一个包含数据的新节点，并将其添加到 head 之前。然后，它将链表的头部指向这个新节点。
4.获取下一个节点
获取下一个节点的函数如下所示:
def get_next_node (self,node):
return node.next_node.data
创建新的链接列表
让我们编写 main 函数，并使用上面创建的类创建一个链表。
llist = LinkedList()
这行代码用一个空节点初始化 llist 对象。
1.添加节点
让我们给这个节点添加一些数据。
llist.head = Node(1)
为链表创建几个其他节点。
s = Node(2)
t = Node(3)
2.在节点之间创建链接
在单个节点之间创建链接是创建链表最重要的部分。
您可以使用以下方式创建链接:
llist.head.next_node = s
s.next_node = t
3.打印列表中的节点
要验证列表是否创建成功，我们可以使用打印功能。
llist.printList()
输出:
1 -> 2 -> 3
4.输出列表的大小
要输出列表的大小，调用我们上面写的 size 函数。
print(llist.size())
输出:
3
5.插入新节点
让我们尝试使用上面的函数在链表的头部插入一些数据。
llist.insert_at_head(5)
我们可以打印清单进行验证。
llist.printList()
输出:
5 -> 1 -> 2 -> 3
6.获取下一个节点
要获取下一个节点:
print(llist.get_next_node(s))
输出:
3
Python 中链表的完整实现
完整的实现如下所示:
class Node(object):
def __init__(self, data=None, next_node=None):
self.data = data
self.next_node = next_node
class LinkedList(object):
def __init__(self, head=None):
self.head = head
def size(self):
current = self.head
count = 0
while current:
count += 1
current = current.next_node
return count
def printList(self):
temp = self.head
while (temp):
print (temp.data, " -> ", end = '')
temp = temp.next_node
print("")
def insert_at_head(self, data):
new_node = Node(data)
new_node.next_node = self.head
self.head = new_node
def get_next_node (self,node):
return node.next_node.data
if __name__=='__main__':
llist = LinkedList()
llist.head = Node(1)
s = Node(2)
t = Node(3)
llist.head.next_node = s;
s.next_node = t
llist.printList()
print(s.data)
print(llist.size())
print(llist.get_next_node(s))
llist.insert_at_head(5)
llist.printList()
结论
本教程讲述了 Python 中链表的实现。我们从头开始创建了自己的链表，并编写了一些额外的函数来打印列表，获取列表的大小，并在头部进行插入。
如何用 Python 列出一个目录下的文件？
原文：https://www.askpython.com/python/examples/list-files-in-a-directory-using-python
在本教程中，我们将介绍如何使用 Python 列出目录中的文件。
Python 是一种通用语言，用于各种领域，如数据科学、机器学习，甚至是 Web 开发。Python 语言的应用似乎没有限制。
因此，似乎很简单的 Python 可以用来列出任何系统中的文件和目录。这篇文章的目的是向读者阐明使用 Python 在系统中列出文件的方法。
使用 Python 列出目录中的所有文件
为了使用 Python 与系统中的目录进行交互，使用了os库。
1.使用“操作系统”库
我们要练习的方法是 listdir()。顾名思义，它用于列出目录中的项目。
# Importing the os library
import os
# The path for listing items
path = '.'
# The list of items
files = os.listdir(path)
# Loop to print each filename separately
for filename in files:
print(filename)
输出:
game_file.py
hi-lo_pygame.py
Journaldev
list_files1.py
hi_lo_pygame.mp4
test.py
list_files.py
my_program.cpp
a.out
cut.cpp
Linux 用户可以在终端上使用标准的ls命令轻松匹配上面的输出。
List Items using ‘ls’ command
正如我们所看到的，每个方法的输出都是匹配的。
2.使用“glob”库
glob主要是一个文件名模式匹配库，但是它可以通过以下方式列出当前目录中的项目:
# Importing the glob library
import glob
# Path to the directory
path = ''
# or
# path = './'
# Extract the list of filenames
files = glob.glob(path + '*', recursive=False)
# Loop to print the filenames
for filename in files:
print(filename)
输出:
game_file.py
hi-lo_pygame.py
Journaldev
list_files1.py
hi_lo_pygame.mp4
test.py
list_files.py
my_program.cpp
a.out
cut.cpp
通配符'*'用于匹配当前目录中的所有项目。因为我们希望显示当前目录的条目，所以我们需要关闭glob()函数的递归特性。
3.仅列出当前目录中的文件
在上面的方法中，python 代码返回当前目录中的所有项目，而不管它们的性质如何。我们可以使用os库中的path.isfile()函数只提取文件。
# Importing the os library
import os
# The path for listing items
path = '.'
# List of only files
files = [f for f in os.listdir(path) if os.path.isfile(f)]
# Loop to print each filename separately
for filename in files:
print(filename)
输出:
game_file.py
hi-lo_pygame.py
list_files1.py
hi_lo_pygame.mp4
test.py
list_files.py
my_program.cpp
a.out
cut.cpp
在上面的代码片段中， List Comprehension 用于过滤掉那些实际上是文件的项目。
这里需要注意的另一个关键点是，上面的代码不适用于其他目录，因为变量'f'不是绝对路径，而是当前目录的相对路径。
递归列出目录中的所有文件
为了打印目录及其子目录中的文件，我们需要递归地遍历它们。
1.使用“操作系统”库
在walk()方法的帮助下，我们可以逐个遍历目录中的每个子目录。
# Importing the os library
import os
# The path for listing items
path = './Documents/'
# List of files in complete directory
file_list = []
"""
Loop to extract files inside a directory
path --> Name of each directory
folders --> List of subdirectories inside current 'path'
files --> List of files inside current 'path'
"""
for path, folders, files in os.walk(path):
for file in files:
file_list.append(os.path.join(path, file))
# Loop to print each filename separately
for filename in file_list:
print(filename)
输出:
./Documents/game_file.py
./Documents/hi-lo_pygame.py
./Documents/list_files1.py
./Documents/hi_lo_pygame.mp4
./Documents/test.py
./Documents/list_files.py
./Documents/my_program.cpp
./Documents/a.out
./Documents/cut.cpp
./Documents/Journaldev/mastermind.py
./Documents/Journaldev/blackjack_terminal.py
./Documents/Journaldev/lcm.cpp
./Documents/Journaldev/super.cpp
./Documents/Journaldev/blackjack_pygame.py
./Documents/Journaldev/test.java
os.walk()方法简单地跟随每个子目录，默认情况下以自顶向下的方式提取文件。有三个迭代器用于遍历os.walk()函数的输出:
**path**–该变量包含函数在某次迭代中观察的当前目录**folders**–该变量是'path'目录中的目录列表。**files**–目录'path'中的文件列表。
join()方法用于将文件名与其父目录连接起来，为我们提供文件的相对路径。
2.使用“glob”库
类似于上面的过程，glob可以递归地访问每个目录，提取所有项目并返回。
# Importing the glob library
import glob
# Importing the os library
import os
# Path to the directory
path = './Documents/'
# Extract all the list of items recursively
files = glob.glob(path + '**/*', recursive=True)
# Filter only files
files = [f for f in files if os.path.isfile(f)]
# Loop to print the filenames
for filename in files:
print(filename)
输出:
./Documents/game_file.py
./Documents/hi-lo_pygame.py
./Documents/list_files1.py
./Documents/hi_lo_pygame.mp4
./Documents/test.py
./Documents/list_files.py
./Documents/my_program.cpp
./Documents/a.out
./Documents/cut.cpp
./Documents/Journaldev/mastermind.py
./Documents/Journaldev/blackjack_terminal.py
./Documents/Journaldev/lcm.cpp
./Documents/Journaldev/super.cpp
./Documents/Journaldev/blackjack_pygame.py
./Documents/Journaldev/test.java
与 path 变量一起使用的符号'**'告诉glob()函数匹配任何子目录中的文件。'*'告诉函数匹配一个目录中的所有项目。
因为我们希望只提取完整目录中的文件，所以我们使用之前使用的isfile()函数过滤掉这些文件。
列出一个目录中的所有子目录
我们可以列出特定目录中的所有子目录，而不是列出文件。
# Importing the os library
import os
# The path for listing items
path = './Documents/'
# List of folders in complete directory
folder_list = []
"""
Loop to extract folders inside a directory
path --> Name of each directory
folders --> List of subdirectories inside current 'path'
files --> List of files inside current 'path'
"""
for path, folders, files in os.walk(path):
for folder in folders:
folder_list.append(os.path.join(path, folder))
# Loop to print each foldername separately
for foldername in folder_list:
print(foldername)
输出:
./Documents/Journaldev
列出文件和目录的微小区别在于os.walk()函数过程中迭代器的选择。对于文件，我们迭代 files 变量。这里，我们循环遍历 folders 变量。
用绝对路径列出目录中的文件
一旦我们知道如何列出目录中的文件，那么显示绝对路径就是小菜一碟。abspath()方法为我们提供了文件的绝对路径。
# Importing the os library
import os
# The path for listing items
path = './Documents/'
# List of files in complete directory
file_list = []
"""
Loop to extract files inside a directory
path --> Name of each directory
folders --> List of subdirectories inside current 'path'
files --> List of files inside current 'path'
"""
for path, folders, files in os.walk(path):
for file in files:
file_list.append(os.path.abspath(os.path.join(path, file)))
# Loop to print each filename separately
for filename in file_list:
print(filename)
输出:
/home/aprataksh/Documents/game_file.py
/home/aprataksh/Documents/hi-lo_pygame.py
/home/aprataksh/Documents/list_files1.py
/home/aprataksh/Documents/hi_lo_pygame.mp4
/home/aprataksh/Documents/test.py
/home/aprataksh/Documents/list_files.py
/home/aprataksh/Documents/my_program.cpp
/home/aprataksh/Documents/a.out
/home/aprataksh/Documents/cut.cpp
/home/aprataksh/Documents/Journaldev/mastermind.py
/home/aprataksh/Documents/Journaldev/blackjack_terminal.py
/home/aprataksh/Documents/Journaldev/lcm.cpp
/home/aprataksh/Documents/Journaldev/super.cpp
/home/aprataksh/Documents/Journaldev/blackjack_pygame.py
/home/aprataksh/Documents/Journaldev/test.java
这里需要注意的一点是，abspath()必须提供文件的相对路径，这也是join()函数的目的。
通过匹配模式列出目录中的文件
有多种方法可以过滤出符合特定模式的文件名。让我们一个一个地看一遍。
1.使用“fnmatch”库
顾名思义，fnmatch是一个文件名模式匹配库。将fnmatch与我们的标准文件名提取库一起使用，我们可以过滤出那些匹配特定模式的文件。
# Importing the os and fnmatch library
import os, fnmatch
# The path for listing items
path = './Documents/'
# List of files in complete directory
file_list = []
"""
Loop to extract files containing word "file" inside a directory
path --> Name of each directory
folders --> List of subdirectories inside current 'path'
files --> List of files inside current 'path'
"""
print("List of files containing \"file\" in them")
for path, folders, files in os.walk(path):
for file in files:
if fnmatch.fnmatch(file, '*file*'):
file_list.append(os.path.join(path, file))
# Loop to print each filename separately
for filename in file_list:
print(filename)
输出:
List of files containing "file" in them
./Documents/game_file.py
./Documents/list_files1.py
./Documents/list_files.py
fnmatch()函数接受两个参数，文件名后面跟着要匹配的模式。在上面的代码中，我们查看了所有包含单词file的文件。
2.使用“glob”库
正如我们之前提到的，glob's的主要目的是文件名模式匹配。
# Importing the glob library
import glob
# Importing the os library
import os
# Path to the directory
path = './Documents/'
# Extract items containing numbers in name
files = glob.glob(path + '**/*[0-9]*.*', recursive=True)
# Filter only files
files = [f for f in files if os.path.isfile(f)]
# Loop to print the filenames
for filename in files:
print(filename)
输出:
./Documents/list_files1.py
上面的模式匹配正则表达式 '**/*[0-9]*.*'可以解释为:
**'**'**–遍历路径内的所有子目录**'/*'**–文件名可以以任何字符开头**'[0-9]'**–文件名中包含一个数字**'*.*'**–文件名可以以任何字符结尾，可以有任何扩展名
3.使用“pathlib”库
遵循面向对象的方式与文件系统交互。库中的rglob()函数可用于通过某个路径对象递归提取文件列表。
这些文件列表可以使用rglob()函数中的模式进行过滤。
# Importing the pathlib library
import pathlib
# Creating a Path object
path = pathlib.Path('./Documents/')
# Extracting a list of files starting with 'm'
files = path.rglob('m*')
# Loop to print the files separately
for file in files:
print(file)
输出:
Documents/my_program.cpp
Documents/Journaldev/mastermind.py
上面的代码片段用于列出所有以字母'm'开头的文件。
列出目录中具有特定扩展名的文件
在 Python 中列出带有特定扩展名的文件有点类似于模式匹配。为此，我们需要创建一个关于文件扩展名的模式。
# Importing the os and fnmatch library
import os, fnmatch
# The path for listing items
path = './Documents/'
# List to store filenames
file_list = []
"""
Loop to extract python files
path --> Name of each directory
folders --> List of subdirectories inside current 'path'
files --> List of files inside current 'path'
"""
print("List of python files in the directory:")
for path, folders, files in os.walk(path):
for file in files:
if fnmatch.fnmatch(file, '*.py'):
file_list.append(os.path.join(path, file))
# Loop to print each filename separately
for filename in file_list:
print(filename)
输出:
List of python files in the directory:
./Documents/game_file.py
./Documents/hi-lo_pygame.py
./Documents/list_files1.py
./Documents/test.py
./Documents/list_files.py
./Documents/Journaldev/mastermind.py
./Documents/Journaldev/blackjack_terminal.py
./Documents/Journaldev/blackjack_pygame.py
fnmatch()函数过滤掉那些以'.py'结尾的文件，也就是 python 文件。如果我们想要提取不同扩展名的文件，那么我们必须修改这部分代码。例如，为了只获取 C++文件，必须使用'.cpp'。
这总结了使用 Python 获取目录中文件列表的方法。
结论
可以有多种方法来解决手头的任何问题，最方便的方法并不总是答案。关于这篇文章，Python 程序员必须知道我们可以在目录中列出文件的每一种方式。
我们希望这篇文章容易理解。如有任何疑问或建议，欢迎在下方留言。
如何用 Python 创建字典列表？
原文：https://www.askpython.com/python/list/list-of-dictionaries
在本教程中，我们将讨论 Python 中的字典列表。我们将讨论如何
- 创建词典列表
- 访问键:值对
- 更新键:值对
- 在清单上附加一本词典
所以事不宜迟，让我们开始吧。
Python 中的字典列表是什么？
我们都知道，在 Python 中，列表是一种线性数据结构，可以以有序的方式存储值的集合。这些值可以是任何 Python 对象。
字典也是一个 Python 对象，它以 key:value 格式存储数据。
因此我们可以创建一个 Python list，它的每个元素都是 Python dictionary。这就是为什么我们用一个特殊的名字来称呼这样一种类型的 Pythonlist——字典列表。
用 Python 创建字典列表的步骤
要用 Python 创建字典列表，我们只需创建一个简单的 Python list ，并确保它的每个元素都是一个 Python 字典。让我们用 Python 来实现它。
# Defining a list of dictionaries in Python
ls_dict = [{'py': 'Python', 'mat': 'MATLAB', 'cs': 'Csharp'},
{'A': 65, 'B': 66, 'C': 67},
{'a': 97, 'b': 98, 'c': 99}]
# Printing the results
print(ls_dict)
# Validating the type of 'ls_dict' and its element
print(type(ls_dict))
print(type(ls_dict[0]))
输出:
将词典附加到词典列表中
我们还可以用一个新的 Python dictionary 对象作为其元素来追加一个字典列表。这里我们使用 Python list append()方法。
这类似于附加一个普通的 Python 列表。
唯一的区别是传递给append()方法的参数必须是 Python 字典。append()方法将传递的 Python 对象(这里是一个字典)添加到现有 Python 字典列表的末尾。
例如，我们将用一个新的 dictionary 对象更新上面创建的字典列表。让我们为此编写 Python 代码。
# Defining a list of dictionaries in Python
ls_dict = [{'py': 'Python', 'mat': 'MATLAB', 'cs': 'Csharp'},
{'A': 65, 'B': 66, 'C': 67},
{'a': 97, 'b': 98, 'c': 99},]
# Printing the given list of dictionaries
print("Given Python list of dictionaries:\n", ls_dict)
# Creating a new Python dictionary
ds = {'AskPython': "Python", 'JournalDev': "ALL",
'LinuxforDevices': "Linux"}
# Appending the list of dictionaries with the above dictionary
# Using append() method
ls_dict.append(ds)
# Printing the appended list of dictionaries
print("Appended Python list of dictionaries:\n", ls_dict)
输出:
从字典列表中访问键:值对
要访问字典列表的键:值对，首先我们必须使用索引来访问字典。当我们得到字典时，我们可以很容易地访问字典的任何键:值对。让我们通过 Python 代码来理解这一点。
# Defining a list of dictionaries in Python
ls_dict = [{'A': 65, 'B': 66, 'C': 67},
{'py': 'Python', 'mat': 'MATLAB', 'cs': 'Csharp'},
{'a': 97, 'b': 98, 'c': 99}]
# Printing the given list of dictionaries
print("Given Python list of dictionaries:\n", ls_dict)
# Accessing and printing the key: value pairs of a list of dictionary
print(ls_dict[1])
print(ls_dict[1]['py'])
输出:
更新字典列表中的键:值对
我们可以通过以下方式更新字典列表中任何字典的键:值对:
- 添加新的键:值对
- 更新现有键:值
- 删除现有的键:值对
让我们通过 Python 代码以上面讨论的所有方式更新上面的 Python 字典列表。
# Defining a list of dictionaries in Python
ls_dict = [{'A': 65, 'B': 66, 'C': 67},
{'py': 'Python', 'mat': 'MATLAB', 'cs': 'Csharp'},
{'a': 97, 'b': 98, 'c': 99}]
# Printing the given list of dictionaries
print("Given Python list of dictionaries:\n", ls_dict)
# Adding a new key: value pair to the 1st dictionary in the list
ls_dict[0]['new_key'] = 'new_value'
# Updating an existing key: value pair in the 2nd dictionary in the list
ls_dict[1]['py'] = 'PYTHON'
# Deleting an existing key: value pair from the 3rd dictionary in the list
del ls_dict[2]['b']
# Printing the updated list of dictionaries
print("Updated Python list of dictionaries:\n", ls_dict)
输出:
总结
在本教程中，我们学习了什么是 Python 中的字典列表，创建 Python 字典列表，追加 Python 字典列表，使用列表索引和字典键从 Python 字典列表中访问不同的键:值对，以及以三种不同的方式更新 Python 字典列表。
Python 列表到字符串
在本教程中，我们将 Python 列表到字符串的转换。一个 Python 列表用于表示元素以供操作。它基本上代表了同质元素的集合。
Python 字符串也用于以字符形式收集元素作为输入。
列表中的元素可以通过下列方法之一转换为字符串:
- 通过使用 join()方法
- 通过使用列表理解
- 使用 for 循环进行迭代
- 通过使用 map()方法
1.使用 join()方法将 Python 列表转换为字符串
Python join()方法可用于在 Python 中将列表转换为字符串。
join()方法接受 iterables 作为参数，比如列表、元组、字符串等。此外，它返回一个新的字符串，该字符串包含从 iterable 作为参数连接的元素。
注意:join()方法的强制条件是传递的 iterable 应该包含 string 元素。如果 iterable 包含一个整数，它会引发一个类型错误异常。
语法:
string.join(iterable)
举例:
inp_list = ['John', 'Bran', 'Grammy', 'Norah']
out_str = " "
print("Converting list to string using join() method:\n")
print(out_str.join(inp_list))
在上面的例子中，join()方法接受 inp_list 作为参数，并将列表的元素连接到 out_str ，从而返回一个字符串作为输出。
输出:
Converting list to string using join() method:
John Bran Grammy Norah
2.列表理解和 join()方法将 Python 列表转换成字符串
Python List Comprehension 从现有列表中创建元素列表。它还使用 for 循环以元素模式遍历 iterable 的项。
Python List Comprehension 和 join()方法可以用来将列表转换成字符串。list comprehension 将逐个元素地遍历元素，join()方法将列表的元素连接成一个新的字符串，并将其表示为输出。
举例:
inp_list = ['John', 'Bran', 'Grammy', 'Norah']
res = ' '.join([str(item) for item in inp_list])
print("Converting list to atring using List Comprehension:\n")
print(res)
输出:
Converting list to atring using List Comprehension:
John Bran Grammy Norah
3.用 map()函数实现 Python 列表到字符串的转换
Python 的 map()函数可用于将列表转换为字符串。
map()函数接受函数和可迭代对象，如列表、元组、字符串等。接下来，map()函数用提供的函数映射 iterable 的元素。
语法:
map(function, iterable)
举例:
inp_list = ['John', 'Bran', 'Grammy', 'Norah']
res = ' '.join(map(str, inp_list))
print("Converting list to string using map() method:\n")
print(res)
在上面的代码片段中， map(str，inp_list) 函数接受 str 函数和 inp_list 作为参数。它将输入 iterable( list)的每个元素映射到给定的函数，并返回元素列表。此外，join()方法用于将输出设置为字符串形式。
输出:
Converting list to string using map() method:
John Bran Grammy Norah
4.使用 for 循环将 Python 列表转换为字符串的迭代
在这种技术中，输入列表的元素被逐一迭代，并被添加到一个新的空字符串中。因此，将列表转换为字符串。
举例:
inp_str = ['John', 'Bran', 'Grammy']
st = ""
for x in inp_str:
st += x
print(st)
输出:
JohnBranGrammy
将字符列表转换为字符串
即使是列表形式的一组字符也可以用与上面相同的方式转换成字符串。下面是一个例子，演示如何将一列字符转换成一个字符串。
举例:
inp_str = ['J', 'o', 'u', 'r', 'n', 'a', 'l', 'd', 'e', 'v']
st = ""
for x in inp_str:
st += x
print(st)
输出:
Journaldev
结论
因此，在本文中，我们研究了将 Python 列表转换为字符串的不同技术和方法。
参考
如何在 Python 中加载和绘制 MNIST 数据集？
原文：https://www.askpython.com/python/examples/load-and-plot-mnist-dataset-in-python
本教程讲述了在 Python 中加载 MNIST 数据集的步骤。 MNIST 数据集是一个手写数字的大型数据库。它通常用于训练各种图像处理系统。
MNIST 是美国国家标准技术研究院数据库的缩写。
该数据集用于训练模型来识别手写数字。这可用于扫描信件上的手写 pin 码。
MNIST 包含了从 T2 0 到 9 的 70，000 张 28×28 的手写数字图像。
为什么 MNIST 数据集如此受欢迎？
MNIST 受欢迎的原因有很多，这些是:
- MNSIT 数据集公开提供。
- 这些数据在使用前几乎不需要处理。
- 这是一个庞大的数据集。
此外，该数据集通常用于图像处理和机器学习课程。
在 Python 中加载 MNIST 数据集
在本教程中，我们将学习 MNIST 数据集。我们还将了解如何用 python 加载 MNIST 数据集。
1.在 Python 中加载数据集
让我们从将数据集加载到 python 笔记本开始。加载数据最简单的方法是通过 Keras。
from keras.datasets import mnist
MNIST 数据集由训练数据和测试数据组成。每个图像存储在 28X28 中，相应的输出是图像中的数字。
我们可以通过观察训练和测试数据的形状来验证这一点。
要将数据加载到变量中，请使用:
(train_X, train_y), (test_X, test_y) = mnist.load_data()
要打印训练和测试向量的形状，请使用:
print('X_train: ' + str(train_X.shape))
print('Y_train: ' + str(train_y.shape))
print('X_test: ' + str(test_X.shape))
print('Y_test: ' + str(test_y.shape))
我们得到以下输出:
X_train: (60000, 28, 28)
Y_train: (60000,)
X_test: (10000, 28, 28)
Y_test: (10000,)
由此我们可以得出以下关于 MNIST 数据集的结论:
- 训练集包含 60k 图像，测试集包含 10k 图像。
- 训练输入向量的尺寸为【60000 X 28 X 28】。
- 训练输出向量的大小为【60000 X 1】。
- 每个单独的输入向量的大小为【28 X 28】。
- 每个单独的输出向量的维数为[ 1] 。
2.绘制 MNIST 数据集
让我们尝试显示 MNIST 数据集中的图像。从导入 Matplotlib 开始。
from matplotlib import pyplot
要绘制数据，请使用以下代码:
from matplotlib import pyplot
for i in range(9):
pyplot.subplot(330 + 1 + i)
pyplot.imshow(train_X[i], cmap=pyplot.get_cmap('gray'))
pyplot.show()
输出结果如下:
Mnist Dataset
用 Python 加载和绘制 MNIST 数据集的完整代码
本教程的完整代码如下所示:
from keras.datasets import mnist
from matplotlib import pyplot
#loading
(train_X, train_y), (test_X, test_y) = mnist.load_data()
#shape of dataset
print('X_train: ' + str(train_X.shape))
print('Y_train: ' + str(train_y.shape))
print('X_test: ' + str(test_X.shape))
print('Y_test: ' + str(test_y.shape))
#plotting
from matplotlib import pyplot
for i in range(9):
pyplot.subplot(330 + 1 + i)
pyplot.imshow(train_X[i], cmap=pyplot.get_cmap('gray'))
pyplot.show()
下一步是什么？
现在您已经导入了 MNIST 数据集，您可以将其用于影像分类。
当谈到图像分类的任务时，没有什么可以击败卷积神经网络(CNN)。CNN 包含卷积层、汇聚层、扁平化层。
让我们看看每一层都做了什么。
1.卷积层
卷积层使用较小的像素过滤器过滤图像。这将减小图像的大小，而不会丢失像素之间的关系。
2.汇集层
池层的主要工作是减少卷积后图像的空间大小。
池层通过选择像素内的最大值、平均值或和值来减少参数的数量。
最大池化是最常用的池化技术。
3.展平层
展平层将多维像素向量表示为一维像素向量。
结论
本教程是关于将 MNIST 数据集加载到 python 中的。我们研究了 MNIST 数据集，并简要讨论了可用于 MNIST 数据集图像分类的 CNN 网络。
如果你想进一步了解 Python 中的图像处理，请通读这篇教程，学习如何使用 OpenCV 在 Python 中读取图像。
使用 Selenium 定位元素的不同方法——Python
原文：https://www.askpython.com/python-modules/locate-elements-using-selenium
两个或多个 HTML 页面组成一个 web 应用程序。Web 元素是指组成网页的所有组件单元/字段，如文本框、按钮等。
静态元素是由浏览器在任何 HTML 页面上呈现的数据对象模型(DOM)上的所有元素。动态元素是在运行时调用并动态添加到页面中的网页元素。
也读: Python 硒介绍及设置
web 应用程序自动化测试中最关键的阶段之一是定位 Web 元素(UI)。
Selenium 中的一些元素选择器:
- 身份证明
- 名字
- 类别名
- 链接文本
- 部分链接文本
- 标签名称
- XPath
- 和 CSS 选择器
Web 元素的 ID、名称或类名是找到它的最方便的方法。我们可以简单地在代码中输入适当的值，然后运行程序，看看它是否工作。
为什么我们需要这么多选择器？
你可能想知道为什么我们需要有或学习不同的方法来定位网页中的元素。这很重要，因为每次我们需要从网页中获取数据时，我们都需要仔细查看该页面的 HTML 代码(DOM ),寻找唯一的或常见的选择器。此外，还有动态加载的动态站点、AJAX 站点等问题。
Selenium 中的定位器类型
Different Ways To Locate an Element
在 HTML 标签、属性和 HTML 文本的基础上，使用定位器来查找 web 元素。在 Selenium WebDriver 中，有八种不同类型的定位器:
- ID T1:每当在网页上寻找网页元素时，这个定位器优先。因为它的值对于整个网页上的每个 web 元素都是唯一的，所以在使用此定位器时，您不会收到重复的匹配。我们在 HTML 代码中的任何地方使用 id 属性。
- Name :这个位置用在任何 web 元素的 HTML 代码中有 Name 属性的地方。
- className :每当 HTML 代码有一个 class 属性时，就会用到这个位置，这个属性通常是为批处理样式定义的。
- 标记名:该定位器仅在 web 元素有独特的 HTML 标记时使用。
- linkText :如果一个链接有一个唯一的 HTML 文本与之连接，那么使用这个定位器。
- partialLinkText :每当网页上有一个链接带有一个很长的链接文本时，我们通过使用链接中的部分 HTML 文本来使用这个定位器。
- CSS selector:CSS selector 是一个比 XPath 快得多的定位器，使用范围也更广。它比其他定位器更复杂，但它是最有效的，因为我们可以用它来识别 web 元素，即使特定的 html 元素丢失了。
- XPath :这是一个定位器，使用标签、属性和文本来查找 web 元素。X 路径可以用于 HTML 和 XML 文本。绝对 XPath 和相对 XPath 是 XPath 的两种形式。
- 绝对XPath–从根元素到所需的子节点，这个 XPath 定位 web 元素。绝对 XPath 不应该用在实时自动化程序中。
- RelativeXPath–这是一个经过修改的 XPath，它使用标签、属性或文本来发现项目。
现在，我们已经讨论了使用 Selenium 在网页中定位元素的所有不同方法。我们现在讨论 Python Selenium 中最重要和最广泛使用的选择器，以便于选择和归属。
1.通过 CSS ID 定位硒元素
这是迄今为止发现元素最直接的方法。CSS ID 保存在 HTML DOM 元素的 ID 属性中，它被设计为对于网页上的每个元素都是唯一的。因此，ID 可以用来唯一地标识元素。
要访问此功能，必须使用 webdriver 类的 find_element_by_id()方法。下面是如何使用它。
from selenium import webdriver
driver = webdriver.Chrome('./chromedriver.exe')
driver.get("https://www.python.org")
search_bar = driver.find_element_by_id("id-search-field")
如果没有正在搜索的具有该 ID 的 DOM 元素，则抛出一个‘No this Element’异常，这可以通过使用 try-catch 块来有效地处理。
理论上，页面上的每个 DOM 元素都应该有自己的 ID。然而，这并不是现实生活中经常观察到的事情。可能大多数项目没有 ID，或者您会遇到两个具有相同 ID 的元素。在这种情况下，必须使用单独的技术来惟一地标识 DOM 元素。
2.通过 CSS 类名定位 Selenium 中的元素
在页面上查找组件的另一种方法是使用类名作为搜索词。类名保存在 HTML 标签的 class 属性中。CSS 类旨在应用于一组 DOM 组件。find_element_by_class_name()函数只返回具有匹配类的第一个元素。
如果没有具有所提供的类名的元素，它将抛出 NoSuchElementException。以下是如何在驱动程序中使用方法的示例。
from selenium import webdriver
driver = webdriver.Chrome('./chromedriver')
driver.get("https://www.python.org")
first_search_bar = driver.find_element_by_class_name("class-name")
注意重要的一点:上面的代码只返回匹配类的第一个元素。对于具有相同匹配类(批量选择)的所有元素，您需要使用循环迭代运行find element 方法，并在每次迭代时将信息存储在这个 while 中。
3.在 Selenium 中通过 XPath 定位元素
如果元素的 ID、类或名称无法识别它，则必须使用元素的 XML 路径来定位它。
当读取 XML 文档时，也可以使用这个方法。在本文中，我们将研究如何利用相对路径而不是绝对路径，因为当网页的 HTML 结构(DOM)改变时，绝对路径容易出错。
为了在文档中发现合适的元素，我们将利用 find_element_by_xpath()函数。元素的路径作为参数传递给 find_element_by_xpath()函数。
以下代码可用于定位 HTML 表单中的电子邮件输入框:
email_input = driver.find_element_by_xpath("//form[input/@name='email']")
这段代码寻找页面的初始表单元素。该表单查找名称为 email、值为 email 的条目，将其限制为所需的元素。
让我们试着发现表单的姓和名输入元素:
first_name = driver.find_element_by_xpath("//form[@id='loginForm']/input[1]")
last_name = driver.find_element_by_xpath("//form[@id='loginForm']/input[2]")
它查找 ID 为 login form 的表单，然后选择该表单的第一个和第二个输入元素作为名字和姓氏(如果合适)。
4.在 Python Selenium–Misc 中定位单个 HTML 元素
在 Selenium WebDriver 中，除了我们到目前为止提到的常见方法之外，测试人员可能还想研究一些元素定位器。
通过使用 find_element_by_tag_name()函数，可以根据元素的 HTML 标记名来查找元素。
page_heading = driver.find_element_by_tag_name('h1')
也可以通过在链接文本中搜索来找到超链接元素。可以使用 find_element_by_link_text()函数搜索特定链接的文本，或者使用 find _ element _ by _ partial _ link _ text()方法搜索部分链接的文本。
准确的链接文本–
click_here_link = driver.find_element_by_link_text('Click Here')
部分链接文本–
click_here_link = driver.find_element_by_partial_link_text('Click')
结论
至此，我们已经结束了使用 Python 编程语言学习 Selenium 中的定位器的课程。我们讨论了在 HTML 页面中选择项目的许多不同技术。希望你已经很好地学习了在网页中定位元素，并准备好自己实现它们。
Python 中从头开始的逻辑回归[算法解释]
原文：https://www.askpython.com/python/examples/logistic-regression-from-scratch
本教程的目标是从头实现我们自己的逻辑回归。这将不同于我们之前关于同一主题的教程，在之前的教程中，我们使用内置方法来创建函数。
逻辑回归是一种经典的方法，主要用于二元分类问题。尽管经过一些修改，它可以用于多类分类问题，但在本文中，我们将执行二元分类。
从头开始实现逻辑回归
我们将一步一步地分解算法来理解它的内部工作，并最终创建我们自己的类。
步骤 1:理解 Sigmoid 函数
逻辑回归中的 sigmoid 函数返回一个概率值，然后可以将该概率值映射到两个或多个离散类。给定输入变量集，我们的目标是将该数据点分配到一个类别(1 或 0)。sigmoid 函数输出输入点属于其中一个类的概率。
#Defining a sigmoid function
def sigmoid(z):
op = 1/(1 + np.exp(-z))
return op
第二步:损失函数
损失函数由参数/权重组成，当我们说我们希望通过这个优化损失函数时，我们简单地指的是找到参数/权重的最佳值。
逻辑回归的损失函数定义为:
Loss Function
#Loss Function
def loss(h, y):
return (-y * np.log(h) - (1 - y) * np.log(1 - h)).mean()
第三步:梯度下降
梯度下降只是损失函数相对于其权重的导数。
我们在找到损失函数的导数后得到这个:
Gradient Of Loss Function
#Gradient_descent
def gradient_descent(X, h, y):
return np.dot(X.T, (h - y)) / y.shape[0]
通过减去导数(梯度下降)乘以学习率来更新权重。更新权重:
Updating Weights
这里—alpha是学习率。
把所有的放在一起
让我们创建一个类来编译上面提到的步骤。下面是从头开始实现逻辑回归的完整代码。我们已经为这个实现使用了 Python numpy 模块。
#import required modules
import numpy as np
class LogisticRegression:
def __init__(self,x,y):
self.intercept = np.ones((x.shape[0], 1))
self.x = np.concatenate((self.intercept, x), axis=1)
self.weight = np.zeros(self.x.shape[1])
self.y = y
#Sigmoid method
def sigmoid(self, x, weight):
z = np.dot(x, weight)
return 1 / (1 + np.exp(-z))
#method to calculate the Loss
def loss(self, h, y):
return (-y * np.log(h) - (1 - y) * np.log(1 - h)).mean()
#Method for calculating the gradients
def gradient_descent(self, X, h, y):
return np.dot(X.T, (h - y)) / y.shape[0]
def fit(self, lr , iterations):
for i in range(iterations):
sigma = self.sigmoid(self.x, self.weight)
loss = self.loss(sigma,self.y)
dW = self.gradient_descent(self.x , sigma, self.y)
#Updating the weights
self.weight -= lr * dW
return print('fitted successfully to data')
#Method to predict the class label.
def predict(self, x_new , treshold):
x_new = np.concatenate((self.intercept, x_new), axis=1)
result = self.sigmoid(x_new, self.weight)
result = result >= treshold
y_pred = np.zeros(result.shape[0])
for i in range(len(y_pred)):
if result[i] == True:
y_pred[i] = 1
else:
continue
return y_pred
为了实现这个算法，我们定义了一个fit方法，它需要学习率和迭代次数作为输入参数。
上面的类可以通过提供输入数据和目标值来初始化。
现在，是时候测试我们的实现了。
from sklearn.datasets import load_breast_cancer
#Loading the data
data = load_breast_cancer()
#Preparing the data
x = data.data
y = data.target
#creating the class Object
regressor = LogisticRegression(x,y)
#
regressor.fit(0.1 , 5000)
y_pred = regressor.predict(x,0.5)
print('accuracy -> {}'.format(sum(y_pred == y) / y.shape[0]))
输出:
fitted successfully to data
accuracy -> 0.9209138840070299
我们实现的模型达到了 92%的准确率，还不错。
你可以在我的 GitHub 库的这里找到本教程的笔记本。
结论
这篇文章是关于从头实现一个逻辑回归模型来执行一个二进制分类任务。我们还通过从 0 开始编码来展示回归算法的内部工作。
直到我们下次见面。快乐学习！
逻辑回归–简单实用的实施
原文：https://www.askpython.com/python/examples/logistic-regression
读者朋友们，你们好！在本文中，我们将关注 Python 中逻辑回归的实际实现。
在我们用 Python 进行的一系列机器学习中，我们已经了解了各种有监督的 ML 模型，如线性回归、 K 近邻等。今天，我们将集中讨论逻辑回归，并用它来解决现实生活中的问题！激动吗？耶！🙂
让我们开始吧！
一、什么是 Logistic 回归？
在开始逻辑回归之前，让我们了解我们在哪里需要它。
众所周知，监督机器学习模型对连续数据值和分类数据值都有效。其中，分类数据值是组成组和类别的数据元素。
因此，当我们以分类数据变量作为因变量时，要做出预测，就需要进行逻辑回归。
逻辑回归是一个监督机器学习模型，它以二元或多分类数据变量为因变量。也就是说，它是一个分类算法，它分别分离和分类二进制或多标记值。
例如，如果一个问题希望我们预测结果为“是”或“否”，那么逻辑回归将对相关数据变量进行分类，并计算出数据的结果。
逻辑回归使我们能够使用 logit 函数对训练数据进行分类，以符合因变量二元变量的结果。此外，logit 函数仅依赖于优势值和概率机会来预测二元响应变量。
现在让我们看看逻辑回归的实现。
实用方法-逻辑回归
在本文中，我们将利用银行贷款违约者问题,其中我们预计会预测哪些客户是贷款违约者。
在 这里可以找到数据集 。
1.加载数据集
在初始步骤，我们需要使用 pandas.read_csv() 函数将数据集加载到环境中。
import pandas as pd
import numpy as np
data = pd.read_csv("bank-loan.csv") # dataset
2.数据集的采样
加载数据集后，现在让我们使用 train_test_split() 函数将数据集分为训练数据集和测试数据集。
from sklearn.model_selection import train_test_split
X = loan.drop(['default'],axis=1)
Y = loan['default'].astype(str)
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=.20, random_state=0)
这里，X 是包含除了响应/目标值之外的所有变量的训练数据集，Y 是指仅包含响应变量的测试数据集。
3.定义模型的误差度量
现在，在进入模型构建之前，让我们定义误差度量，这将有助于我们以更好的方式分析模型。
这里，我们创建了一个混淆矩阵，并计算了精确度、召回率、准确度和 F1 分数。
def err_metric(CM):
TN = CM.iloc[0,0]
FN = CM.iloc[1,0]
TP = CM.iloc[1,1]
FP = CM.iloc[0,1]
precision =(TP)/(TP+FP)
accuracy_model =(TP+TN)/(TP+TN+FP+FN)
recall_score =(TP)/(TP+FN)
specificity_value =(TN)/(TN + FP)
False_positive_rate =(FP)/(FP+TN)
False_negative_rate =(FN)/(FN+TP)
f1_score =2*(( precision * recall_score)/( precision + recall_score))
print("Precision value of the model: ",precision)
print("Accuracy of the model: ",accuracy_model)
print("Recall value of the model: ",recall_score)
print("Specificity of the model: ",specificity_value)
print("False Positive rate of the model: ",False_positive_rate)
print("False Negative rate of the model: ",False_negative_rate)
print("f1 score of the model: ",f1_score)
4.对数据集应用模型
现在终于到了对数据集执行模型构建的时候了。看看下面的代码吧！
logit= LogisticRegression(class_weight='balanced' , random_state=0).fit(X_train,Y_train)
target = logit.predict(X_test)
CM_logit = pd.crosstab(Y_test,target)
err_metric(CM_logit)
说明:
- 最初，我们在训练数据集上应用了
LogisticRegression()函数。 - 此外，我们已经使用 predict() 函数输入了上述输出来预测测试数据集的值。
- 最后，我们使用
crosstab()创建了一个相关矩阵，然后调用误差度量定制函数(之前创建的)来判断结果。
输出:
Precision value of the model: 0.30158730158730157
Accuracy of the model: 0.6382978723404256
Recall value of the model: 0.7307692307692307
Specificity of the model: 0.6173913043478261
False Positive rate of the model: 0.3826086956521739
False Negative rate of the model: 0.2692307692307692
f1 score of the model: 0.42696629213483145
因此，正如上面所见证的，我们通过我们的模型获得了 63% 的准确性。
结论
到此，我们就结束了这个话题。如果你遇到任何问题，欢迎在下面评论。更多关于 Python 和 ML 的文章，请继续关注，
快乐学习！！🙂
Python 中棒棒糖图表的介绍
原文：https://www.askpython.com/python/examples/lollipop-charts-in-python
棒棒糖图表是由一个条形和一个棒状组成的，看起来像一个顶端有冰糖的棒状。实心圆位于条形的顶部，看起来像一个甜甜的棒棒糖。棒棒糖图和条形图一样，用于比较一个类别中的不同类别。因此，这是一个可视化类比较的优秀工具。
棒棒糖图表可以通过将选项传递给. stem()来增强，这提高了可读性和数据描述能力。一些可能的变更示例如下:
Matplotlib 模块可用于在 Python 中有效地绘制棒棒糖图。Matplotlib 包有一个很有用的函数。stem()，用于创建棒棒糖图表。让我们看看情况如何。
导入库
import matplotlib.pyplot as plt
import numpy as np
创建随机数据
x = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J']
y = np.linspace(1, (np.log(0.2 * np.pi)), 10)
绘制棒棒糖图
我们已经在 plt.stem()中将使用行集合选项设置为 True。单独的线条将作为线条集合添加到绘图中。如果我们不提供这个参数，我们将收到一个用户警告，并被提醒将其设置为 True。
这提高了 Stem 图的性能。
plt.stem(x, y, use_line_collection = True)
plt.show()
Basic Lollipop Plot
即兴制作棒棒糖图表
棒棒糖图表可以通过将选项传递给. stem()来增强，这提高了可读性和数据描述能力。一些可能的变更示例如下:
添加附加参数
import matplotlib.pyplot as plt
import numpy as np
x = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J']
y = np.linspace(1, (np.log(0.2 * np.pi)), 10)
plt.stem(x, y, markerfmt = 's', linefmt='--', basefmt = ':', use_line_collection=True)
plt.show()
Improvised Lollipop Plot 1
排序棒棒糖图
import matplotlib.pyplot as plt
import numpy as np
x = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J']
y = list(np.linspace(1, (np.log(0.2 * np.pi)), 10))
y.sort()
plt.stem(x, y, markerfmt = 's', linefmt='--', basefmt = ':', use_line_collection=True)
plt.show()
Improvised Lollipop Plot 2
结论
恭喜你！您刚刚学习了如何用 Python 构建一个基本的棒棒糖图。希望你喜欢它！😇
喜欢这个教程吗？无论如何，我建议你看一下下面提到的教程:
感谢您抽出时间！希望你学到了新的东西！！😄
Python 中损失函数概述
读者朋友们，你们好！在本文中，我们将详细关注 Python 中的损失函数。
所以，让我们开始吧！！🙂
Python 损失函数的重要性
Python 在数据科学和机器学习领域一直扮演着重要的角色。当涉及到在数据集上应用模型时，理解它在准确性和错误率方面对数据集的影响是非常重要的。这有助于我们理解模型对因变量的影响。
同样，我们有 Python 提供的损失函数。利用损失函数，我们可以很容易地理解预测数据值和预期/实际数据值之间的差异。有了这些损失函数，我们可以很容易地获取错误率，从而估计基于它的模型的准确性。
4 最常用的 Python 损失函数
了解了 Python 中的损失函数之后，现在我们将看看一些最常用的损失函数，用于误差估计和准确率。
- 均方根误差
- 平均绝对误差
- 交叉熵函数
- 均方误差
1.均方根误差
利用均方根误差，我们计算数据集的预测值和实际值之间的差异。此外，我们计算差异的平方，然后对其应用均值函数。这里，将使用 NumPy 模块和 mean_squared_error()函数，如下所示。使用 mean_squared_error()函数，我们需要将平方参数设置为 False，以便它拾取并计算 RMSE。如果设置为 True，它将计算 MSE。
举例:
from sklearn.metrics import mean_squared_error
import numpy as np
ac = np.array([1,2,3])
pr = np.array([0.9,1.9,2.1])
print(mean_squared_error(ac, pr, squared = False))
输出:
0.5259911279353167
2.绝对平均误差
平均绝对误差使我们能够获得数据集的预测数据值和实际数据值之间的平均绝对差值。Python 为我们提供了 mean_absolute_error()函数来计算任何数据范围的平均绝对误差。
举例:
from sklearn.metrics import mean_absolute_error
import numpy as np
ac = np.array([1,2,3])
pr = np.array([0.9,1.9,2.1])
print(mean_absolute_error(ac, pr))
输出:
0.3666666666666667
3.均方误差
在 RMSE 之后，均方差使我们能够轻松计算实际数据值和预测数据值之间的均方差的平均值。我们可以利用 mean_squared_error()函数来计算所示数据范围的 MSE
举例:
from sklearn.metrics import mean_squared_error
import numpy as np
ac = np.array([1,2,3])
pr = np.array([0.9,1.9,2.1])
print(mean_squared_error(ac, pr, squared = True))
输出:
0.2766666666666666
4.交叉熵损失函数
RMSE、MSE 和 MAE 主要用于回归问题。交叉熵损失函数高度用于问题陈述的分类类型。它使我们能够针对分类数据变量定义问题分类类型的错误/丢失率。
Python 的 sklearn 库为我们提供了 log_loss()函数来处理和估计分类/分类数据变量的错误率。
举例:
from sklearn.metrics import log_loss
op = log_loss(["Yes", "No", "No", "Yes","Yes","Yes"],[[10, 9], [39, 11], [8, 2], [35, 65], [12, 14], [12,12]])
print(op)
输出:
0.6931471805599453
结论
到此，我们就结束了这个话题。如果你遇到任何问题，欢迎在下面评论。
更多与 Python 编程相关的帖子，请继续关注我们。
在那之前，学习愉快！！🙂
Python 中的机器学习——初学者简易指南
原文：https://www.askpython.com/python/machine-learning-introduction
机器学习的概念是人工智能领域的最新发展。许多该领域的专家表示，人工智能是人类的未来，它可以在许多方面提供帮助。这个术语起源于 20 世纪 50 年代最著名的数学家艾伦·图灵。
他是第一台数字计算机的发明者。首先向他和其他也有贡献的计算机科学家脱帽致敬。让我们朝着洗钱及其发展的完整路线图前进。
什么是机器学习？
机器学习(Machine Learning)是计算机在没有被明确编程的情况下进行学习和运行的能力。 这是今天所有初学者学习和应用的最著名的定义。现在让我们确保我们看一下流程图，并确定它与人工智能的另一个分支有什么联系。
Machine Learning Flowchart
正如我们所看到的，它已经从计算机科学中脱颖而出成为核心学科。人工智能有一个主要的分支叫做 数据科学。 它分裂成四个子字段:
- 数据挖掘
- 数据分析
- 大数据
- 机器学习 (ML)
现在，如果我们观察图表向我们表明 数据是 AI 的主要依赖项。 没有任何数据或信息，我们什么也做不了。它需要以原始格式呈现，以便进行分析和处理。
保持所有其他因素，我们还看到数据科学的所有四个子领域在它们之间有一个核心依赖性。
这表明学习者需要有一些其他领域的基础知识才能在其中一个领域发展。这就是为什么对学生来说这是一个即将到来的不同的职业机会。
用 Python 学习机器学习的路线图
这一部分将向你展示我们如何开始学习机器学习，并以此为职业。这是一条完整的路径:
- 概率统计:先从数学基础说起。学习统计学的所有基础知识，如平均值、中位数和众数。回归、曲线拟合等主题也很重要。
- 可视化图形:各种图形，如条形图、散点图、线图、线形图等。对数据可视化很重要。
- 编程语言:学习 ML 必须要有一门编程语言。因为，我们可以依靠计算机进行复杂的数学运算，但是，在获取、表示和分析数据方面，它们被证明是最有用的。Python 和 R 是数据科学爱好者和 ML 工程师中最著名的。
- 库:我们需要对各种开发库有很强的理解，才能对我们为 ML 选择的编程语言进行数据分析。它们帮助我们进行数值计算、数据预处理、简单的算法实现和可视化数据。
- 算法:各种算法对于各种预测很重要。朴素贝叶斯、线性回归、决策树、随机森林、XGBosst 等。与他们的理论是重要的。
- 数据处理技巧:要将原始数据转化为有用的、可管理的数据，就要有数据预处理的技巧。像 One Hat 编码和 Label 编码这样的各种编码技术都很重要。
让我们详细看看其中的一些要点。
为什么选择 Python 做机器学习？
说到容易学习和理解的编程语言，Python 是开发者的选择。
总的来说，它们是我们实现想法和维持专业工作流程的工具。
代码帮助人们在特定的结构中分享和理解他们的知识。
Python 是一种轻量级通用编程语言。这是一个开源项目。因此，我们可以为它的发展做出贡献。
欲了解更多信息，请访问 https://www.python.org/。
python 的主要特点是 面向对象(OOP) 。
与其他 OOP 语言不同的是类的实例化、继承、多重继承、封装技术都非常容易在 Python 中实现。
此外，它对各种应用程序有广泛的库支持，如 web 开发、图形用户界面(GUI)开发、软件开发、数据科学和机器学习。对于机器学习，Python 提供了以下库:
- 熊猫 :
- Numpy
- 【matplot lib】
- 海博
- Scipy
- Scikit Learn
这是六个主要的库，通过它们我们可以执行各种 ML 操作。对于高级 ML，有五个主要库的其他集合:
- Tensorflow.
- OpenCV
- 指针
- Keras
- 状态模型
上述库的概述
熊猫
我们将从用于进行适当的数据清理和预处理的最重要的库开始。
熊猫图书馆。主要是基于 python 的 Numpy 和 Matplotlib 包。数据准备是创建 ML 模型中最基本的任务。所以，正是这个库使它变得简单了一些。
我们都知道,机器理解,它可以编码数据并创建虚拟变量，为模型训练准备测试数据。访问链接获取文档和教程。
Numpy
完整形式是数值 python 。它主要用于计算多维复杂数组和矩阵、数学计算和科学计算。
事实证明，这个库最适合训练 ML 工程师准备的模型。它功能强大，数据类型为 ndarray 。最新版本是正在使用的 Numpy-1.21。更多信息请访问 https://numpy.org/doc/官方网站。
【matplot lib】
该库用于绘制图形，以实现数据可视化和演示目的。一个非常适合和易于使用的 API，用于数据科学和机器学习目的。它可以绘制下列图形。它有两类图 2D 和三维图。
二维图包括:
三维图形包括:
- 三维线图
- 线框图表
- 表面图
- 三面图
我们还可以使用 matplotlib 中的特殊子模块来分析图像。它就是 图像模块 。
高级缩放功能包括图像绘制和伪彩色方案。访问此链接了解更多信息。
这里是一些样本图像:
3D Plots
海博
该库用于统计绘图。就像 matplotlib 一样，我们可以绘制各种数据框架的吸引人的图表。我们还可以可视化不同的回归模型、函数，并且它具有为同一数据框的不同变量绘制多幅图的特殊功能。这些是一些样本地块:
Seaborn multi-plots
Scipy
Scipy 的意思是科学巨蟒。这个库与 NumPy 非常相似。但是，最核心的区别是，它为物理和高等数学提供了特殊的功能。
像超几何、抛物柱面等主题都可以在这个 API 下找到。此外，它还有一组指数和三角函数来支持复杂的计算。
Scipy over NumPy 的主要优点是 它有助于计算积分和求导等微积分问题。 想了解更多关于这个包的信息，查看 用户指南 的链接。
不同机器学习算法概述
现在让我们来看看不同的机器学习算法，它们是如何工作的。本节将帮助您了解哪种类型的机器学习技术适合基于需求的特定目的。
机器学习技术
机器学习两种不同的技术:
- 监督学习:模型在监督和标记数据下学习的概念。我们用一些独特的值标记数据，然后根据我们的需要训练模型。
- 无监督学习:模型利用无标签数据自行学习的概念。我们只需要做一些数据清理，然后将其他预测交给机器。
机器学习算法
没有算法，机器学习只是一夜之间的梦想。因此，人们应该对所有的基本算法有适当的了解。它们为用户规范提供正确和相关的输出。它们依赖于核心统计分析。有两种主要类型:
- 分类 :针对离散数据或数值差异较大的变化数据。
- 回归 :用于连续数据或数值略有变化的数据。
它们有相同的算法，但它们在创造上有所不同。下面是 AI/ML 从业者应该知道的七个最基本和最重要的算法。
- 线性回归 :在图形上的数据点流向中寻找最佳拟合线。
- 逻辑回归 :用曲线求特定条件下的概率。
- 决策树 :根据一棵树节点的不同情况做出决策。
- 随机森林 :各种决策树的集合，对大量数据进行决策预测。
- 支持向量机:将数据点分类分析
- k-means 聚类算法 :创建不同数据点的聚类，并检测其中的奇数。
- k 近邻 :为特定测试用例上的数据点寻找最近邻。
如何用 Python 执行机器学习——一个简单的例子
对于初学者，要求你解决业务问题和测试用例。这也被称为预测分析。
现在，我们有了 ML 的主要工具和技术，我们知道什么是 ML。
让我们应用一些概念，让我们的 ML 之旅有一个良好的开端。ML 是命令机器学习的逐步模式。因此，作为开始，我们将用 python 实现一个带有一些图形的线性回归算法。
想了解更多关于蟒蛇的信息，请访问 https://www.anaconda.com/products/individual
基于 Google 不同职位员工的工资数据，实现决策树分类算法
- 环境:蟒蛇
- IDE: Jupyter Notebook
- 操作系统: Windows 10+版
- Python 版本: Python 3.8.5(预装了 Anaconda)
- 数据集: salary.csv
1.读取数据集
熊猫模块帮助我们读取数据集。它可以是任何形式，如文本，CSV，excel。熊猫模块有不同的方法来读取每种文件类型。它还可以通过数据 API 所在的给定链接读取它。
代码:
import pandas as pd
data = pd.read_csv('salary.csv')
data.head()
Reading The Dataset From Pandas 1
它是一个 CSV 文件，所以我们使用 read_csv() 方法。然后我们将它存储在一个变量中——‘数据’。要查看数据集的前五行，使用 head() 方法。
2.检查数据集的数据类型和形状
为了知道数据集中存在哪种类型的变量，我们需要确保我们有它们所有数据类型的记录。要检查它，熊猫的简单属性类型随时可用。为了计算行数和列数，我们使用了 shape 属性。这将返回一组行和列
data.dtypes
data.shape
Retrieving The Shape And Datatype of The Dataset we came to know that it has sixteen rows and four columns. This helps to understand how large is the dataset.
3.检查所有缺失的值
数据集可能由于多种原因而不完整。差异可能非常大，并可能导致错误的预测。但是， isna() 函数扫描所有的值，如果任何列没有值，就返回数字。为了检查总值，我们使用了 sum() 函数和 isna()。
代码:
data.isna().sum()
Checking The Missing Values
4.选择目标变量
预测依赖于与目标变量一起运行的连续变量。这个变量对于测试用例分析是必不可少的。如果我们有一个名义数据集，我们可以很容易地识别它。给出的问题陈述描述了薪水是我们的主要目标变量。所以一万多卢比的工资栏适合那个。
代码:
inputs = data.drop('salary more than 10,000rs', axis = 'columns')
target = data['salary more than 10,000rs']
Target Variable Selection
5.标注数据集
对于一个监督学习模型，我们需要标记数据。因为它是这类 ML 算法的核心属性。
这可以通过使用 sci-kit-learn 库的预处理模块来完成。
我们从中导入了 LabalEncoder() 类。 fit_transform() 函数标注相关数据，以便机器理解。我们为每一列创建了该类的三个实例。
from sklearn.preprocessing import LabelEncoder
le_company = LabelEncoder()
le_job = LabelEncoder()
le_degree = LabelEncoder()
inputs['company_n'] = le_company.fit_transform(inputs['company'])
inputs['job_n'] = le_job.fit_transform(inputs['job'])
inputs['degree_n'] = le_degree.fit_transform(inputs['degree'])
Labelling Data
因此，数据集增加了三个新列。
Viewing The Dataset
然后，在获得带标签的数据后，我们删除不需要的列。然后，数据集的新名称被赋予为 inputs_n 。
代码:
inputs_n = inputs.drop(['company','job','degree'],axis='columns')
inputs_n
The New Dataset
The Target Dataset
6.实现算法
我们实现了分类器类型的决策树算法，因为可用的数据是离散形式的。我们从 scikit-learn 的树模块中导入它。代码如下。
代码:
from sklearn.tree import DecisionTreeClassifier
model = DecisionTreeClassifier()
model.fit(inputs_n, target)
model.score(inputs_n,target)
model.predict([[2,1,0]])
model.predict([[2,1,1]])
Decision Tree Implementation
说明:
- 我们创建了 DecisionTreeClassifier 类的一个实例。然后，为了进行预测，我们使用拟合函数。这个函数有两个参数:目标变量和连续变量。这实现了关于参数的算法。
- 然后使用 score() 函数检查训练分数的得分。范围从 0 到 1。如果分数是 1，那么模型是 100%准确的。百分比由小数点前的数字确定。例如，我们的分数是 0.78，那么训练百分比是 78%。
- predict 函数将一组输入作为参数。这给出了结果。我们给这个数组三个输入。因为我们有三个测试变量 1) 公司 _n ， 2) 工作 _n 3) 学历 _n 。
- 该算法将比较每个输入的目标变量以及工资是否会超过10，000 卢比。如果答案是 1，那么这个人的收入超过 1 万卢比，但是如果答案是 0，那么这个人的收入不超过1 万卢比
现实世界中的机器学习
机器学习具有大量的应用，并且在各个领域中使用。这六个主要领域是:
- 技术
- 行业
- 金融
- 电子商务
- 物联网
- 天气预报
结论
因此，我们学习了如何在 Python 中执行机器学习。我们了解了各种图书馆及其用途。阅读这篇文章，开始你的机器学习之旅。必须涵盖很多内容，而且还会涵盖更多内容。因此，请确保您通读了本文中的所有内容，以便开始学习 Python 中机器学习的最主要方面。
使用 Streamlit 部署机器学习模型——房价预测 GUI
原文：https://www.askpython.com/python-modules/machine-learning-model-streamlit-house-price-prediction-gui
你好，欢迎来到本教程！既然你偶然发现了这篇教程，我们猜测你正在执行一些机器学习任务。通常，在从事机器学习时，我们会使用 Jupyter Notebook、Google Collab 或任何我们喜欢的 IDE。但是对于不熟悉这些 ide 的人来说，在这些 ide 中训练的模型是没有用的。
为了解决这个问题，我们需要创建一个易于使用的应用程序，以便每个人都可以使用机器学习模型。在本教程中，我们将首先创建一个简单的线性回归模型，然后使用 Streamlit 部署它。
在开始之前，请确保您已经阅读了下面关于 Streamlit 的教程，因为在开发应用程序时，我们将使用其中包含的文本元素和小部件。
设置项目结构
预测模型的项目结构如下:
Streamlit Project Structure
我们将需要三个 Python 脚本，app.py用于 web 应用，houseprice_model.py用于开发机器学习模型，predict_cost.py用于预测房屋价格。我们还需要一个data文件夹来存储数据集。
开发机器学习模型
我们将在这里使用一个 房价数据集。它由 5 列组成，即
- 房子的面积
- 房子里卧室的数量
- 阳台的数量
- 房子的年龄，即房子的年龄
- 房子的价格
数据集如下所示:
houseprice.csv
请记住，该数据集包含其中所有参数的任意值。
因为构建线性回归模型超出了本文的范围，所以我们不会深入讨论它的细节。请随意查阅从头开始线性回归教程，了解线性回归及其 Python 实现。
下面是我们机器学习模型的全部代码。
我们将使用 houseprice_model.py 文件来编写机器学习模型的代码。
houseprice.py
# Importing the required libraries
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
# Reading the dataset
data = pd.read_csv('data/homeprice.csv')
# Seperating the target and features
# target ->y, features -> X
y = data['price']
X = data.drop(columns='price', axis=1)
# Splitting into training and test set
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1)
# Making the model
lr = LinearRegression()
lr.fit(X_train, y_train)
# Predicting the output
y_pred = lr.predict(X_test)
# Saving the model
import joblib
joblib.dump(lr, "lr_model.sav")
最后，在构建模型之后，我们使用joblib模块作为lr_model.sav保存它，以便以后使用。
用细流设计前端
如果您还没有安装 Streamlit，可以使用命令进行安装
pip install streamlit
现在，正如我们前面看到的，我们将为应用程序使用文件app.py。所以我们将在这个文件中编写前端代码。
因为我们有 4 个独立的特征，面积，卧室的数量，阳台的数量和房子的年龄，我们将需要 4 个输入字段来获得这些特征的值。因为我们想要预测房子的价格，我们将使用一个按钮，当点击它时将显示房子的价格。
app.py
import streamlit as st
from predict_cost import predict
import numpy as np
st.title('Home price prediction')
st.write('---')
# area of the house
area = st.slider('Area of the house', 1000, 5000, 1500)
# no. of bedrooms in the house
bedrooms = st.number_input('No. of bedrooms', min_value=0, step=1)
# no. of balconies in the house
balconies = st.radio('No. of balconies', (0, 1, 2 , 3))
# how old is the house? (age)
age = st.number_input('How old is the house (in years)?', min_value=0, step=1)
if st.button('Predict House Price'):
cost = predict(np.array([[area, bedrooms, balconies, age]]))
st.text(cost[0])
我们可以使用以下命令运行该应用程序
streamlit run app.py
Streamlit Prediction UI
在上面的代码中，所有的参数限制都是任意的。此外，我们已经从 predict_cost.py 文件导入了predict函数。点击预测房价按钮，预测功能被调用。
predict_cost.py
import joblib
def predict(data):
lr = joblib.load('lr_model.sav')
return lr.predict(data)
这里，在predict函数中，我们使用 joblib 模块加载我们保存的模型，然后根据发送给该函数的数据返回预测价格。
在将数据传递给predict函数时，我们需要将其作为一个二维数组传递。因此，我们将输入数据转换为 NumPy 数组。此外，predict 函数返回一个一维数组，因此在打印值时，我们编写了 cost[0]来获取返回数组中的唯一值。
现在，我们可以使用该应用程序提供一些输入，根据我们的输入来预测房价。下面就是一个这样的例子。
Streamlit Prediction Result
仅此而已！我们已经成功部署了一个机器学习模型作为 Streamlit 应用程序。
Python 中的神奇方法
Python 编程语言中的神奇方法是专门针对面向对象设计的。我们创建的每个类都有自己的神奇方法。Python 的标准解释器将这些分配给我们在其中创建的每个类。因此，在本文中，我们将详细了解如何调用和使用魔法方法来获得更好的编程方法。让编码的乐趣开始吧！
复习面向对象的知识
在进入正题之前，我们先来了解和打磨一下 OOP 概念的知识。我们将只看到基本的东西。因此，面向对象编程是一种将数据成员和成员函数封装到用户定义的实体中的方法，该实体被称为类。
类是保存特定数据项的东西，这些数据项相互关联并以特定的方式进行通信。我们使用对象访问属性和成员函数。对象是一个类的实例。在任何编程语言中，当我们创建一个类的时候，内存是不会被分配的，但是当我们创建它的实例，也就是对象的时候，内存就被分配了。
举例:
动物是类的一种类型。在这方面，我们包括居住在地球上的所有生物。所以，每个人都有自己的生活方式，食物和住所。动物只是定义了所有这些的蓝图。例如，猫是动物类的对象。它有四条腿，吃老鼠，住在房子或灌木丛里。同样，老虎有四条腿，但它杀死和吃掉许多动物，所以我们说老虎吃肉，它生活在森林里。
Python 代码示例:
class Animal:
def __init__(self, legs, food, shelter):
self.legs = legs
self.food = food
self.shelter = shelter
def showAnimal(self):
print("The animal has {} legs: ".format(self.legs))
print("The animal eats: {}".format(self.food))
print("The animal lives in: {}".format(self.shelter))
cat = Animal(4, "Mouse", "House")
tiger = Animal(4, "Meat", "Forest")
cat.showAnimal()
tiger.showAnimal()
输出:
The animal has 4 legs:
The animal eats: Mouse
The animal lives in: House
The animal has 4 legs:
The animal eats: Meat
The animal lives in: Forest
说明:
- animal 类包含条腿、食物和住所作为属性。
- 当我们创建一个实例并在构造函数中插入值时，它们的行为差异就很明显了。
- 所以，同一类的对象可以根据价值观的行为而有所不同。
面向对象的神奇方法
所以，在上面的例子中，我们有一个动物类。Python 有一组方法，即 Dunder methods ，负责保存类的属性、数据成员和成员函数。
定义:当我们创建一个对象时，Python 解释器在代码执行的后端调用特殊函数。他们被称为魔术方法或邓德方法。
为什么我们说邓德？因为他们的名字位于双下划线之间。当我们创建一个类的对象时，它们执行一些像魔术一样的计算。那么，我们如何检查它们是什么，在标准类中有多少？使用以下步骤找到它们:
- 创建一个样本类。
- 创建其对象。
- 使用 dir() 函数并将对象插入其中。
- 这个函数打印了所有魔术方法的列表，以及分配给这个类的数据成员和成员函数。
代码:
print(dir(cat))
输出:
__class__
__delattr__
__dict__
__dir__
__doc__
__eq__
__format__
__ge__
__getattribute__
__gt__
__hash__
__init__
__init_subclass__
__le__
__lt__
__module__
__ne__
__new__
__reduce__
__reduce_ex__
__repr__
__setattr__
__sizeof__
__str__
__subclasshook__
__weakref__
food
legs
shelter
showAnimal
你在双下划线中看到的名字都是神奇的方法。其余属性由用户定义。正如我们所见,__init__()是 Python 中任何类的构造函数，也是一个神奇的方法。让我们逐一看看它们的用途。要理解它们的功能，总是要尝试覆盖这些功能。
需要注意的一点是，对于用户定义的任何类，都有一些默认的魔法方法。
一些神奇方法的使用和实现
在本节中，我们将看到一些神奇方法的使用、实现和使用，以编写更好的 OOP 设计。
1.new():
此方法帮助构造函数 init()方法为类创建对象。因此，当我们创建一个类的实例时，Python 解释器首先调用 new()方法，然后调用 init()方法。他们彼此携手合作。
- 当程序员选择创建一个对象时，会调用 new()来接受该对象的名称。
- 然后 init()被调用，其中包括 self 的参数被插入到对象中，这反过来帮助我们修改类属性。
代码:
class Sample:
def __new__(self, parameter):
print("new invoked", parameter)
return super().__new__(self)
def __init__(self, parameter):
print("init invoked", parameter)
obj = Sample("a")
输出:
new invoked a
init invoked a
说明:
- 首先，我们创建一个类作为样本。
- 然后通过创建 new()方法来覆盖它。然后，像往常一样，self 参数来了，之后给出一个简单的参数。
- 使用带有 self 参数的
__new__()函数返回一个 super()函数，以访问我们对该方法进行的定制。 - 然后，用同样的方法调用带有参数的
__init__()函数。 - 然后创建一个样本类的对象。
- 现在，当我们运行代码时，解释器首先调用 new()，然后它调用 init()方法。
2.init():
Python 是一种面向对象的编程语言。所以，这个类必须有一个构造函数。使用 init()方法可以满足这一要求。当我们创建一个类并想给它一些初始参数时。初始化器方法为我们执行这个任务。
代码:
class Sample:
def __init__(self, parameter):
print("init invoked", parameter)
obj = Sample("a")
输出:
init invoked a
说明:
- 创建/覆盖 init()方法。插入 self 参数来通知解释器这是一个类方法。
- 插入必需的参数。
- 然后使用 print()函数打印该参数。
- 之后，创建一个对象。
- 当我们运行代码时，我们得到的输出是“init invoked a”，这表明解释器调用 init()并打印该参数。
3.str():
这个方法帮助我们根据我们的需求显示对象。假设我们创建一个对象并试图打印它。函数的作用是:显示对象的存储位置。如果我们想修改，我们可以这样做。str()函数很好地展示了对象。
代码(在使用 str())之前):
class Student:
def __init__(self, name, roll_no):
self.name = name
self.roll_no = roll_no
stud_1 = Student("Suresh", 1)
print(stud_1)
输出:
<__main__.Student object at 0x0000023E2CF37CA0>
代码(使用 str())后):
class Student:
def __init__(self, name, roll_no):
self.name = name
self.roll_no = roll_no
def __str__(self):
return ("{} {}".format(self.name, self.roll_no))
stud_1 = Student("Suresh", 1)
print(stud_1)
输出:
Suresh 1
酷吧！现在我们也可以用类似的方法。我们可以根据需要设置对象的格式。
4.repr():
类似于 str()，我们可以使用 repr 函数对对象进行修饰。代码类似于 str()实现。
class Student:
def __init__(self, name, roll_no):
self.name = name
self.roll_no = roll_no
def __repr__(self):
print("repr invoked")
return ("{} {}".format(self.name, self.roll_no))
stud_1 = Student("Suresh", 1)
print(stud_1)
输出:
repr invoked
Suresh 1
5.sizeof():
当我们创建一个类时，解释器从来不会给它分配内存。它将内存分配给对象。如果我们想知道分配给该对象的内存，那么我们可以调用或覆盖 sizeof()函数并传递我们的对象。这也返回 list =，tuple，dictionary 对象的大小。
代码:
class Student:
def __init__(self, name, roll_no):
self.name = name
self.roll_no = roll_no
stud_1 = Student("Suresh", 1)
print("Size of student class object: ", stud_1.__sizeof__())
list_1 = [1, 2, 3, 4]
tup_1 = (1, 2, 3, 4, 5)
dict_1 = {"a":1, "b":2, "c":3, "d":4}
print("Size of list: ", list_1.__sizeof__())
print("Size of tuple: ", tup_1.__sizeof__())
print("Size of dictionary: ", dict_1.__sizeof__())
输出:
Size of student class object: 32
Size of list object: 104
Size of tuple object: 64
Size of dictionary object: 216
6.__ 添加 _ _():
这种神奇的方法与其名字特别相似。它增加了两个变量。对于整数，它返回总和，对于字符串，它返回它们的连接结果。
代码:
class Numbers:
def __init__(self, a, b):
self.a = a
self.b = b
def __add__(self):
print("__add__ invoked")
return self.a + self.b
num = Numbers(3, 4)
num_2 = Numbers("a", "b")
print(num.__add__())
print(num_2.__add__())
输出:
__add__ invoked
7
__add__ invoked
ab
7.reduce():
这个神奇的方法以 key: value 格式返回一个类的所有参数及其值的集合或字典。这可以使用带有点运算符的对象名来直接调用。所以，当我们创建一个类并用一些值实例化它。该函数将使用在类声明过程中给定的参数名返回它。
代码:
class Employee:
def __init__(self, name, salary):
self.name = name
self.sal = salary
emp = Employee("Shrinivas", 150000)
print(emp.__reduce__())
输出:
(<function _reconstructor at 0x0000023E22892EE0>, (<class '__main__.Employee'>, <class 'object'>, None), {'name': 'Shrinivas', 'sal': 150000})
代码(覆盖 reduce())后):
class Employee:
def __init__(self, name, salary):
self.name = name
self.sal = salary
def __reduce__(self):
return self.name, self.sal
emp = Employee("Shrinivas", 150000)
print(emp.__reduce__())
输出:
{"Shrinivas", 150000}
说明:
当我们重写并试图返回参数时，我们只能在一个集合中获得它们的值。
8.hash():
hash()函数返回存储在堆内存中的对象的特定哈希值。我们既可以覆盖它，也可以使用对象名调用它。散列法对于获取计算机中任意随机元素的内存地址非常有用。为了简单和内存分配，所有编程语言都使用散列。
代码:
class Employee:
def __init__(self, name, salary):
self.name = name
self.sal = salary
def __hash__(self):
return super().__hash__()
emp = Employee("Shrinivas", 150000)
print(emp.__hash__())
输出:
154129100057
代码:
class Employee:
def __init__(self, name, salary):
self.name = name
self.sal = salary
emp = Employee("Shrinivas", 150000)
print(emp.__hash__())
输出:
154129054082
9. getattribute(name):
这个函数返回一个类的属性值，如果它存在的话。我们需要调用函数并传递我们使用关键字 self 分配给类参数的属性。比如，如果我们将薪水的值赋给 self.sal ，我们需要在 getattribute()函数中调用 sal 。
代码:
class Employee:
def __init__(self, name, salary):
self.name = name
self.sal = salary
def __getattribute__(self, name):
return super().__getattribute__(name)
emp = Employee("Ravi", 500000)
print(emp.__getattribute__("sal"))
输出:
50000
说明:
在该函数中，将“self . sal”赋给雇员类的薪金参数。该函数将其值作为存在于类中的属性返回。如果不存在，该函数将返回一条错误消息。
10.setattr(名称，值):
顾名思义，这个神奇的方法帮助我们在定义对象时改变属性值。不需要重写 getattribute()和 setattr() 函数。只需使用创建的对象调用它们。
代码:
class Employee:
def __init__(self, name, salary):
self.name = name
self.sal = salary
emp = Employee("Ravi", 500000)
emp.__setattr__("name", "Suresh")
emp.__setattr__("sal":600000)
print("The changed name of the employee is: ", emp.__getattribute__("name"))
print("The changed salary of the employee is: ", emp.__getattribute__("sal"))
输出:
The changed name of the employee is: Suresh
The changed salary of the employee is: 600000
说明:
- setattr _ _()接受两个参数。
- 属性名称
- 它的新值
- 然后，它将该特定值赋给该属性。
- 之后，为了检查分配给它的值，使用 employee 对象和点运算符调用 getattrbute()函数。电磁脉冲。__getattribute("name ")。
点注:这两个函数代替了 Python 中一个类的 getter 和 setter 方法。
结论
所以，我们看到了 Python 中一些神奇方法的深入实现。我希望这有所帮助，并将使编程更容易。它们被证明是有助于快速实现和使用的代码。快乐的 python 编程🐍🐍😎。
在 Python 中找到多数元素
原文：https://www.askpython.com/python/examples/majority-element-in-python
嘿编码器！因此，在本教程中，我们将了解 python 编程语言中的一个简单问题。这个问题很简单，但在很多求职面试中还是会被问到。
理解多数元素问题
在程序中，用户需要输入具有 N 个元素的数组 A。然后，代码的目标是找到数组中的多数元素。
大小为 N 的数组 A 中的多数元素是在数组中出现了 N/2 次以上的元素。
程序将返回多数元素，或者如果没有找到/存在多数元素，将返回-1。
用 Python 实现多数元素查找器
在代码实现中，我们首先获取数组大小的输入，然后获取数组中由空格分隔的所有元素。
然后，我们将以字典的形式存储数组中每个元素的计数，在字典中完成了元素到元素计数的映射。
最后，我们将用 n/2 检查每个元素的计数，当计数大于 n/2 时，我们返回该数，否则返回-1。
def check_majority(arr, N):
map = {}
for i in range(0, N):
if arr[i] in map.keys():
map[arr[i]] += 1
else:
map[arr[i]] = 1
for key in map:
if map[key] > (N / 2):
return key
return -1
arr = list(input("Enter elements of array:"))
size = len(arr)
ans = check_majority(arr, size)
if ans != -1:
print("Majority Element is: ", ans)
else:
print("No majority element in array")
样本输出
Enter elements of array:1111111212121
Majority Element is: 1
结论
我希望您已经清楚问题陈述和代码实现。是的，解决这个问题有多种方法。你能想到什么吗？
快乐学习！😇
Python 中的 map()方法
原文：https://www.askpython.com/python/built-in-methods/map-method-in-python
介绍
Python 中的 map()方法广泛用于对数据序列应用函数或操作。将特定函数应用于 iterable 的所有元素后，该方法返回一个 map 对象。
此地图对象是可迭代的，可以转换成所需的形式。因此，让我们了解它是如何工作的，以及如何在我们的程序中使用它。
map()方法的工作原理
一般来说，map()方法的语法如下所示，
map_object= map( method , iterable_object, ... )
这里，
method是函数，map()方法将把来自可迭代对象的单个元素传递给它，iterable_object是我们要对其执行函数操作的数据集。我们可以将多个可重复项传递给方法map()，只需用逗号(、)将它们分开。该功能将并行应用于所有这些应用程序，map_object是将函数应用于所提供对象的所有元素后，由map()方法返回的 iterable 对象。
现在看一个基本的例子来理解这个方法，
def make_even(n): #defining a function that checks if a number is even or not and makes it even if it was not
if n%2==0:
return n
else:
return n+1
num = (1, 2, 3, 4)
map_obj = map(make_even, num) #the map() method applies the function make_even to all the elements of the tuple num
print(type(map_obj)) #printing the type of the object returned by map()
print(list(map_obj)) #type-casting the map object to list and printing it
输出:
<class 'map'>
[2, 2, 4, 4]
- 在上面的例子中，我们已经考虑了具有 4 个元素 1，2，3，和 4 的元组 num ，
- 此外，我们定义了一个函数
make_even(),如果数字是偶数，它将返回数字本身，否则将数字加 1 使其成为偶数，然后最终返回值， - 在我们使用了
map()方法之后，通过函数 make_even 和 iterable num 作为参数，返回的结果对象被存储到 map_obj 中， - 打印出
type(map_obj)告诉我们它是什么类型的对象。原来是地图类的成员， - 同样，我们将 map_obj 输入到一个列表中，并打印相同的内容来检查结果。正如预期的那样，这给了我们想要的输出。
在 Python 中使用 map()方法
1.在 map()中使用 lambda 函数
众所周知，lambda 函数是受限函数，其大小极小，不能重用。如果我们在代码中不再需要函数，并减少函数定义的数量(从而产生更小的代码)，使用一个λ函数而不是定义一个全新的函数是很有用的。让我们举一个例子来理解λ函数在map()中的使用，
num = (1, 2, 3, 4)
sqrd_obj = map(lambda n: n*n, num) #the map() method applies the lambda function to all the elements of the tuple num
print(list(sqrd_obj)) #type-casting the map object to list for printing it
输出:
[1, 4, 9, 16]
- 因此，在上面的代码中，我们定义了一个临时的λ函数，它接受一个数字并返回平方项，
- 正如我们从输出中看到的，我们得到了元组 num 的各个元素的确切的平方项，
- 这样，使用 lambda 函数，我们减少了代码大小，甚至不必定义一个单独的函数来完成任务。
2.在 map()中使用多个参数
正如我们之前讨论的，我们实际上可以将多个可迭代的对象传递给指定给map()方法的函数。让我们举一个例子来理解同样的并行工作
num1= (1, 2, 3, 4) #tuple
num2= [5,6,7,8] #list
#the map() method applies the lambda function to all the elements of the tuple num1 and list num2 parallelly
sqrd_obj = map(lambda n1,n2: n1+n2, num1, num2 )
print(list(sqrd_obj)) #type-casting the map object to list and printing it
输出:
Multiple Argument Map Example
因此，我们可以观察到，lambda 函数被并行应用于元组num1和列表num2的元素。输出是作为参数传递的对象的单个元素的总和。
注意:当具有不同大小的 iterables 被传递给map()方法时，那么 map 函数被应用到元素上，直到其中一个元素被用尽。
结论
所以，在本教程中，我们学习了 Python 中的map()方法。该方法的用途以及其使用的不同格式。如有任何问题，请随意发表评论。
参考
- https://www.journaldev.com/22960/python-map-function
- https://stack overflow . com/questions/10973766/understanding-the-map-function
- https://stack overflow . com/questions/890128/why-are-python-lambdas-useful
MAPE——Python 中的平均绝对百分比误差
原文：https://www.askpython.com/python/examples/mape-mean-absolute-percentage-error
读者朋友们，你们好！在我们的一系列误差指标中，我们已经理解并实现了均方根误差。
今天，我们将关注模型构建中的另一个重要误差指标 Python 中的平均绝对百分比误差(MAPE) 。
什么是 MAPE？
平均绝对百分比误差(MAPE) 是一种统计度量，用于定义机器学习算法在特定数据集上的准确性。
MAPE 可以被认为是一个损失函数，用于定义模型评估所定义的误差。使用 MAPE，我们可以根据实际 v/s 估计值的差异来估计精度。
让我们看看平均绝对百分比误差的以下解释
MAPE
如上所述，在 MAPE，我们首先计算实际值(A) 和估计/预测值(F) 之间的绝对差值。此外，我们对结果应用均值函数来获得 MAPE 值。
MAPE 也可以用百分数来表示。MAPE 越低，型号越合适。
NumPy 模块的平均绝对百分比误差
现在让我们使用 Python NumPy 模块来实现 MAPE。
首先，我们将数据集导入到环境中。你可以在这里找到数据集。
此外，我们使用 Python train_test_split()函数 将数据集分成训练和测试数据集。
然后，我们定义了一个函数来实现 MAPE，如下所示
- 计算实际值和预测值之间的差异。
- 然后，用
numpy.abs() function求上述差值的绝对值。 - 最后，应用
numpy.mean() function来获得 MAPE。
举例:
import numpy as np
from sklearn.model_selection import train_test_split
import pandas as pd
bike = pd.read_csv("Bike.csv")
#Separating the dependent and independent data variables into two data frames.
X = bike.drop(['cnt'],axis=1)
Y = bike['cnt']
# Splitting the dataset into 80% training data and 20% testing data.
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=.20, random_state=0)
#Defining MAPE function
def MAPE(Y_actual,Y_Predicted):
mape = np.mean(np.abs((Y_actual - Y_Predicted)/Y_actual))*100
return mape
现在，我们使用 MAPE 实现了一个线性回归来检查模型的错误率。
这里，我们利用了LinearRegression() function对数据集进行线性回归。此外，我们使用了 预测()函数 来预测测试数据集的值。
最后，我们调用了上面创建的 MAPE()函数来估计预测中的误差值，如下所示:
#Building the Linear Regression Model
from sklearn.linear_model import LinearRegression
linear_model = LinearRegression().fit(X_train , Y_train)
#Predictions on Testing data
LR_Test_predict = linear_model.predict(X_test)
# Using MAPE error metrics to check for the error rate and accuracy level
LR_MAPE= MAPE(Y_test,LR_Test_predict)
print("MAPE: ",LR_MAPE)
输出:
MAPE: 16.628873360270358
使用 Python scikit 学习库的平均绝对百分比误差
在这个例子中，我们使用 Python sklearn 库实现了 MAPE 的概念。
Python sklearn 库为我们提供了mean_absolute_error() function来计算 MAPE 值，如下所示
举例:
from sklearn.metrics import mean_absolute_error
Y_actual = [1,2,3,4,5]
Y_Predicted = [1,2.5,3,4.1,4.9]
mape = mean_absolute_error(Y_actual, Y_Predicted)*100
print(mape)
输出:
13.999999999999984
结论
到此，我们就结束了这个话题。如果你遇到任何问题，欢迎在下面评论。
更多与 Python 相关的帖子，请在这里关注，直到那时，学习愉快！！🙂
参考
如何阅读？Python 中的 mat 文件？
原文：https://www.askpython.com/python/examples/mat-files-in-python
用于数据科学和研究的大量数据集，利用。mat 文件。在本文中，我们将学习使用。mat 文件并详细研究它们。
为什么我们要用？Python 中的 mat 文件？
的目的。mat 文件可能看起来不太明显。但是当处理大型数据集时，这些文件中包含的信息对于数据科学/机器学习项目来说绝对是至关重要的！
这是因为。mat 文件包含数据集中每个对象/记录的元数据。
虽然这些文件并不完全是为了创建注释而设计的，但许多研究人员使用 MATLAB 进行研究和数据收集，导致我们在机器学习中使用的许多注释以的形式出现。mat 文件。
因此，对于数据科学家来说，了解如何使用？项目的 mat 文件。这些还有助于您更好地处理训练和测试数据集，而不是处理常规的 CSV 文件。
我们开始吧！
如何阅读？Python 中的 mat 文件？
默认情况下，Python 不能读取。mat 文件。我们需要导入一个知道如何处理文件格式的库。
1.安装科学软件
类似于我们如何使用 CSV 模块来工作。csv 文件，我们将导入科学库来处理。Python 中的 mat 文件。
如果你还没有 scipy，你可以使用 pip 命令来安装
pip install scipy
既然我们已经设置好了 scipy 并准备好使用，下一步就是打开 python 脚本，最终从文件中获取所需的数据。
2.导入 scipy.io.loadmat 模块
在这个例子中，我将在 101 对象类别中使用由加州理工学院提供的折叠注释。
from scipy.io import loadmat
annots = loadmat('annotation_0001.mat')
print(annots)
在执行时，打印出的注释将为我们提供 this 作为输出。
{'__header__': b'MATLAB 5.0 MAT-file, Platform: PCWIN, Created on: Tue Dec 14 15:57:03 2004', '__version__': '1.0', '__globals__': [], 'box_coord': array([[ 2, 300, 1, 260]], dtype=uint16), 'obj_contour': array([[ 37.16574586, 61.94475138, 89.47697974, 126.92081031,
169.32044199, 226.03683241, 259.07550645, 258.52486188,
203.46040516, 177.5801105 , 147.84530387, 117.0092081 ,
1.37384899, 1.37384899, 7.98158379, 0.82320442,
16.2412523 , 31.65930018, 38.81767956, 38.81767956],
[ 58.59300184, 44.27624309, 23.90239411, 0.77532228,
2.97790055, 61.34622468, 126.87292818, 214.97605893,
267.83793738, 270.59116022, 298.67403315, 298.67403315,
187.99447514, 94.93554328, 90.53038674, 77.31491713,
62.44751381, 62.99815838, 56.94106814, 56.94106814]])}
一开始，你可以看到这首单曲。mat 文件提供了关于所用 MATLAB 的版本、平台、创建日期以及更多信息。
然而，我们应该关注的是box_coord和obj_contour。
3.解析。mat 文件结构
如果您浏览过加州理工学院提供的注释信息，您会知道这些数字是数据集中相应图像的轮廓。
更详细地说，这意味着图像 0001 中的物体由这些轮廓组成。在文章的后面，我们将对数字进行排序，所以，现在不要担心。
通过解析这个文件结构，我们可以将所有轮廓值分配给一个新的 Python 列表。
con_list = [[element for element in upperElement] for upperElement in annots['obj_contour']]
如果我们打印出con_list，我们将得到一个简单的 2D 数组。
[[37.16574585635357, 61.94475138121544, 89.47697974217309, 126.92081031307546, 169.32044198895025, 226.03683241252295, 259.0755064456721, 258.52486187845295, 203.4604051565377, 177.58011049723754, 147.84530386740326, 117.0092081031307, 1.3738489871086301, 1.3738489871086301, 7.98158379373848, 0.8232044198894926, 16.24125230202577, 31.65930018416205, 38.81767955801104, 38.81767955801104], [58.59300184162066, 44.27624309392269, 23.90239410681403, 0.7753222836096256, 2.9779005524862328, 61.34622467771641, 126.87292817679563, 214.97605893186008, 267.83793738489874, 270.59116022099454, 298.6740331491713, 298.6740331491713, 187.9944751381216, 94.93554327808477, 90.53038674033152, 77.31491712707185, 62.44751381215474, 62.998158379373876, 56.94106813996319, 56.94106813996319]]
4.使用熊猫数据框来处理数据
现在您已经有了检索到的信息和数据，您将如何使用它呢？继续使用列表吗？肯定不是。
我们使用 数据帧 作为工作的结构，因为它的功能很像数据表。外观简洁，使用极其简单。
现在，为了处理 Dataframes，我们需要导入另一个模块， 【熊猫】 。
import pandas as pd
Pandas 是一个开源数据分析工具，被全世界的机器学习爱好者和数据科学家使用。它提供的操作在许多数据科学应用程序中被认为是至关重要和基本的。
在本文中，我们将只使用数据框架，但是，请记住，熊猫提供的机会是巨大的。
通过使用 pandas 构建一个包含数据行和列的数据框，可以简化对上述数据的处理。
# zip provides us with both the x and y in a tuple.
newData = list(zip(con_list[0], con_list[1]))
columns = ['obj_contour_x', 'obj_contour_y']
df = pd.DataFrame(newData, columns=columns)
现在，我们有了一个整洁的数据框架！
obj_contour_x obj_contour_y
0 37.165746 58.593002
1 61.944751 44.276243
2 89.476980 23.902394
3 126.920810 0.775322
4 169.320442 2.977901
5 226.036832 61.346225
6 259.075506 126.872928
7 258.524862 214.976059
8 203.460405 267.837937
9 177.580110 270.591160
10 147.845304 298.674033
11 117.009208 298.674033
12 1.373849 187.994475
13 1.373849 94.935543
14 7.981584 90.530387
15 0.823204 77.314917
16 16.241252 62.447514
17 31.659300 62.998158
18 38.817680 56.941068
19 38.817680 56.941068
如您所见，在一个简单的两列数据框中，我们有图像轮廓的 X 和 Y 坐标。
这应该让您对文件中数据的性质有所了解。
为每个创建数据帧的过程。mat 文件是不同的，但是，凭借经验和实践，它们创建出了。文件会自然而然地来到你面前。
本文到此为止！
结论
你现在知道如何使用。mat 文件，以及如何用它的内容在 pandas 中创建数据帧。
处理这些数据的下一步是创建您自己的模型，或者使用现有的模型来训练或测试您的数据集副本。
参考
- 官方 Scipy.io 文档
- 官方熊猫数据框架文档
Matplotlib 等高线图–完整参考
原文:# t0]https://www . aspython . com/python-modules/matplotlib/matplotlib-contour-plot
在本文中，我们将学习如何使用 contour 函数和 Matpotlib 在 Python 中创建等值线图。我们将了解不同类型的绘图功能以及通过它们创建的不同类型的绘图。我们还将查看代码以及如何使用它的详细解释。
什么是等高线图？
Hollow Contour Plot
轮廓是三维表面的二维表示，带有曲线和连接。它通过使用轮廓函数(Z)绘制，该轮廓函数是两个变量(X，Y)的函数。
为了处理等高线图，我们需要两个库——Matplotlib 和 NumPy。让我们安装它们。
Matplotlib 是一个基于 Python 的绘图库，用于创建图表和绘图。要安装 Matplotlib，请键入以下命令:
pip install matplotlib
我们将需要另一个库-Python Numpy来创建我们的等高线图。要安装它，请键入命令:
pip install numpy
创建等高线图
有了基本要求，让我们马上开始绘制等高线图。
导入重要的库:
import matplotlib.pyplot as plt
import numpy as nump
初始化 X，Y 变量
变量 X 和 Y 在下面的代码中用绘图的三维坐标初始化。
element_ofx = nump.arange(0, 25, 4)
element_ofy = nump.arange(0, 26, 4)
用两个变量创建轮廓函数 Z
[grid_ofX, grid_ofY] = nump.meshgrid(element_ofx, element_ofy)
fig, holowplt= plt.subplots(1, 1)
grid_ofZ = nump.cos(grid_ofX / 1) - nump.sin(grid_ofY / 2)
绘制等高线图
holowplt.contour(grid_ofX, grid_ofY, grid_ofZ)
holowplt.set_title('Contour Plot')
holowplt.set_xlabel('features of x-axis')
holowplt.set_ylabel('features of y-axis')
plt.show()
下面的代码演示了如何创建简单的空心 matplotlib 等值线图:
import matplotlib.pyplot as plt
import numpy as nump
element_ofx = nump.arange(0, 25, 4)
element_ofy = nump.arange(0, 26, 4)
# This numpy function creates 2-dimensional grid
[grid_ofX, grid_ofY] = nump.meshgrid(element_ofx, element_ofy)
# plots 2 graphs in one chart
fig, holowplt = plt.subplots(1, 1)
# Mathematical function for contour
grid_ofZ = nump.cos(grid_ofX / 1) - nump.sin(grid_ofY / 2)
# plots contour lines
holowplt.contour(grid_ofX, grid_ofY, grid_ofZ)
holowplt.set_title('Contour Plot')
holowplt.set_xlabel('features of x-axis')
holowplt.set_ylabel('features of y-axis')
plt.show()
输出:
Hollow Contour Plot
填充等高线图
在本例中，我们将创建填充轮廓图，而不是空心轮廓图。为了创建填充图，我们将使用“contourf”函数。整个程序与前面的例子非常相似，只是有一些细微的变化。
绘制等高线图
fillplot.contourf(grid_ofX, grid_ofY, grid_ofZ)
fillplot.set_title('Contour Plot')
fillplot.set_xlabel('features of x-axis')
fillplot.set_ylabel('features of y-axis')
让我们看一下整个代码，以便更好地理解:
import matplotlib.pyplot as plt
import numpy as nump
element_ofx = nump.arange(0, 25, 4)
element_ofy = nump.arange(0, 26, 4)
# This numpy function creates 2-dimensional grid
[grid_ofX, grid_ofY] = nump.meshgrid(element_ofx, element_ofy)
# plots 2 graphs in one chart
fig, fillplot = plt.subplots(1, 1)
# Mathematical function for contour
grid_ofZ = nump.cos(grid_ofX / 1) - nump.sin(grid_ofY / 2)
# plots contour lines
fillplot.contourf(grid_ofX, grid_ofY, grid_ofZ)
fillplot.set_title('Contour Plot')
fillplot.set_xlabel('features of x-axis')
fillplot.set_ylabel('features of y-axis')
plt.show()
输出:
Filled Contour Plot
使用基于状态的界面绘制等高线图
Matplotlib 子模块允许我们使用不同的界面绘制等高线。在本节中，我们将了解 matplotlib 模式，它以类似于 MATLAB 界面的方式绘制等高线。
让我们一个代码一个代码地理解，如何使用这个子模块绘制轮廓。
导入库
在这个特殊的例子中，我们将主要使用两个库，类似于前面的例子——Matplotlib 和 Numpy。
import numpy as np
import matplotlib.pyplot as plt
变量的初始化
delta = 0.18
element_ofx = np.arange(1.8, 2.8, delta)
element_ofy = np.arange(1.5, 3.6, delta)
grid_ofX, grid_ofY = np.meshgrid(element_ofx, element_ofy)
grid_ofZ = (np.exp(grid_ofX + grid_ofY))
让我们看看完整的代码，以便更好地理解:
# Importing libraries
import numpy as np
import matplotlib.pyplot as plt
# variable initialisation
delta = 0.18
element_ofx = np.arange(1.8, 2.8, delta)
element_ofy = np.arange(1.5, 3.6, delta)
grid_ofX, grid_ofY = np.meshgrid(element_ofx, element_ofy)
grid_ofZ = (np.exp(grid_ofX + grid_ofY))
# Contour plotting
plot = plt.contour(grid_ofX, grid_ofY, grid_ofZ)
grid_format = {}
numscale = ['1', '2', '3', '4', '5', '6', '7']
for lvls, s in zip(plot.levels, numscale):
grid_format[lvls] = s
plt.clabel(plot, plot.levels, inline = True,
fmt = grid_format, fontsize = 10)
plt.title('Contour in Matlab interface')
plt.show()
Contour Plot in MATLAB interface
结论
这篇文章是你学习 Matplotlib 的良好基础。所有的主题和概念都以一种易于理解的方式提出，这样读者可以很容易地掌握所有的基础知识。对整篇文章的一个很好的概述将有助于您轻松地进一步探索更高级的 Matplotlib 概念。
3 个 Matplotlib 绘图技巧让绘图更有效
原文：https://www.askpython.com/python-modules/matplotlib/matplotlib-plotting-tips
今天让我们学习一些 matplotlib 绘图技巧，这些技巧不仅可以改善你的绘图视觉效果，还可以帮助你使事情变得更简单。我很确定你已经知道了流行的绘图模块 matplotlib。但是，您是否知道本模块中还有更多值得探索的内容？
今天，我们将学习一些独特的未知函数，它们存在于模块中，可以使你的情节变得更好。
如果你还不熟悉 matplotlib 库，请务必阅读以下教程。
技巧 1:改变情节的大小
改变图形的大小有助于更好地显示图形。同样可以在figure功能的帮助下完成，并将图形的宽度和高度称为figsize。高度和宽度以英寸为单位传递。
我们通过下面提到的代码来看同样的。
import matplotlib.pyplot as plt
x = [i for i in range(-10,10)]
y = [2*i*i*i + 4*i for i in x]
plt.title("Normal Sized Plot")
plt.plot(x,y)
plt.show()
plt.figure(figsize=(3,3))
plt.plot(x,y)
plt.title("Smaller version of the plot")
plt.show()
下图显示了这两个图。
Normal Plot Matplot
Reduced Size Plot Matplot
技巧 2:添加注释
注释是添加到图中数据点的注释，使图形更容易理解和分析。可以通过两种不同的方式添加注释:text和annotate函数。
下面显示了这两种方法的实现。
2.1:使用text函数对 Matplotlib 绘图的注释
使用 text 函数添加注释的代码如下所示。
x = [i for i in range(-2,2)]
y = [2*i*i + 4*i for i in x]
plt.title("Annotations using the text function")
plt.plot(x,y)
for i,j in zip(x,y):
# x_cordinate, y_cordinate, text, other properties
plt.text(i,j,"("+str(i)+","+str(j)+")",color="red")
plt.show()
Text Function Annotation Plot
2.2:使用annotate功能
现在，在下面代码的帮助下，看看如何使用 annotate 函数添加注释。
x = [i for i in range(-2,2)]
y = [2*i*i + 4*i for i in x]
plt.title("Annotations using the annotate function")
plt.plot(x,y)
for i,j in zip(x,y):
t=(i,j)
# text_to_be_added, x and y cordinate in the form of tuple, other properties
plt.annotate("("+str(i)+","+str(j)+")",xy=t,color="red")
plt.show()
Annotate Function Annotations Plot
招数 3:给剧情加水印
matplotlib 中通常不使用水印，但是如果用户想要拥有地块，可以添加水印。
您可以有两种类型的水印:
- 基于文本的水印
- 基于图像的水印
为了给绘图添加水印，我们将创建一个返回两个图形对象的 subplot 对象。我们可以使用text功能和figimage功能直接绘图并在绘图上添加文本和图像水印。
3.1 基于文本的水印
文本函数将需要 x 和 y 坐标，以及在绘图上需要的文本，以及文本的必要属性。其代码和输出如下所示。
fig, ax = plt.subplots()
x = [i for i in range(-2,2)]
y = [2*i*i + 4*i for i in x]
ax.plot(x,y)
ax.text(0.0, -1.5, 'askpython.com',ha='center',va='center',fontsize=20,alpha=0.5)
plt.show()
Text Watermark Matplot
3.2 基于图像的水印
要添加图像水印，我们需要从 matplotlib 库中导入正确的模块，然后使用imread函数读取图像。然后我们将在子情节的第二个对象上使用figimage函数添加图像。代码和输出如下所示。
import matplotlib.image as image
img = plt.imread('image.png')
fig, ax = plt.subplots()
x = [i for i in range(-2,2)]
y = [2*i*i + 4*i for i in x]
ax.plot(x,y)
fig.figimage(img, 100, 100,alpha=0.5)
plt.show()
Image Watermark Matplot
结论
恭喜你！今天，您学习了一些简单的技巧，使您的 matplotlib 图更有效、更容易理解。希望你喜欢这个教程，
感谢您的阅读！
使用 Python 中的 matplotlib.pyplot.scatter 进行数据可视化
原文：https://www.askpython.com/python-modules/matplotlib/matplotlib-pyplot-scatter
任何类型的数据分析的一个重要方法是观察关键特征之间的关系，并查看它们是否以某种方式相互依赖。通过某种情节或图形来可视化这些关系甚至更有用。比方说，我们有一个用例，我们需要在数据中看到某种趋势。我们当然需要某种工具来解决这个问题。
Matplotlib 是一个全面的库，用于在 Python 中创建静态、动画和交互式可视化。它帮助我们创建交互式的图表、图形和布局，可以根据我们的需要进行定制。
也读作:使用 figsize调整 Matplotlib 中的剧情和支线剧情大小
散点()法
散点图是我们将在本文中经历的，特别是matplotlib . py plot . Scatter方法。它用于创建散点图，以观察特征或变量之间的关系，这可能有助于我们获得洞察力。
使用这个工具的语法非常简单，只需要几行带有特定参数的代码。让我们先浏览一下语法，然后我们将看到如何使用最常用的参数来获得一些漂亮的可视化效果。
散布方法的语法
matplotlib.pyplot.scatter(x_axis_array_data, y_axis_array_data,
s=None, c=None, marker=None,
cmap=None, alpha=None,
linewidths=None, edgecolors=None)
x_axis_array_data:这是 x 轴数据。这是包含 x 轴数据的数组。y_axis_array_data:这是 y 轴数据。这是包含 y 轴数据的数组。s:该参数用于设置数据点的大小。c:该参数用于设置数据点的颜色。marker:该参数用于设置数据点的标记样式。cmap:该参数用于设置数据点的颜色图。alpha:该参数用于设置数据点的透明度。linewidths:该参数用于设置数据点连线的宽度。edgecolors:该参数用于设置数据点连线的颜色。
修改散点图参数以使用 PyPlot 散点图创建可视化效果
您可以使用以下命令安装 matplotlib :
！pip 安装 matplotlib
或者，您可以使用 Anaconda 来安装它。
x 轴数组数据& y 轴数组数据
以上提到的所有参数都是可选*** 除了***x _ axis _ array _ data**和 y_axis_array_data， 顾名思义是取两组值作为数组。最常见的是， NumPy 数组用于使代码运行更高效， shape (n，)，required 。
例如，我们有一个数据集，其中包含一些社交媒体上的视频帖子的特征 number_of_ratings ，我们还有一个 ratings_value ，它从 1 到 9 不等。我们想从观众那里找到收视率趋势。我们试着做一些剧情，试着把趋势形象化。
*# Basic scatter plot
import matplotlib.pyplot as plt
import numpy as np
ratings_value = np.asarray([2, 4, 5, 6, 8, 5, 2, 8, 5,
3, 2, 8, 6, 5, 4, 7, 8, 9, 7, 1])
number_of_ratings = np.asarray([10, 24, 17, 45, 23, 32, 67,
34, 54, 54, 32, 67, 35, 23, 14, 16, 28, 32, 29, 28])
plt.title("Ratings Trend Visualization")
plt.xlabel("Number of ratings")
plt.ylabel("Ratings value")
plt.scatter(x = number_of_ratings, y = ratings_value)
plt.show()*
*
Basic Scatter Plot*
尺寸参数
s–指数据点的标记大小。它可以是浮点型或阵列型，(n，)，可选**
*# Scatter plot with one specific size for all the markers: s parameter
import matplotlib.pyplot as plt
import numpy as np
ratings_value = np.asarray([2, 4, 5, 6, 8, 5, 2, 8, 5,
3, 2, 8, 6, 5, 4, 7, 8, 9, 7, 1])
number_of_ratings = np.asarray([10, 24, 17, 45, 23, 32, 67,
34, 54, 54, 32, 67, 35, 23, 14, 16, 28, 32, 29, 28])
plt.title("Ratings Trend Visualization")
plt.xlabel("Number of ratings")
plt.ylabel("Ratings value")
plt.scatter(x = number_of_ratings, y = ratings_value, s = 120)
plt.show()*
*
Scatter Plot With Specific Size Marker*
*# Providing different sizes for each marker: As an array
import matplotlib.pyplot as plt
import numpy as np
ratings_value = np.asarray([2, 4, 5, 6, 8, 5, 2, 8, 5,
3, 2, 8, 6, 5, 4, 7, 8, 9, 7, 1])
number_of_ratings = np.asarray([10, 24, 17, 45, 23, 32, 67,
34, 54, 54, 32, 67, 35, 23, 14, 16, 28, 32, 29, 28])
plt.title("Ratings Trend Visualization")
plt.xlabel("Number of ratings")
plt.ylabel("Ratings value")
sizes = np.asarray([100, 240, 170, 450, 230, 320, 670, 340, 540,
540, 320, 670, 350, 230, 140, 160, 280, 320, 290, 280])
plt.scatter(x = number_of_ratings, y = ratings_value, s = sizes)
plt.show()*
*
Scatter Plot With Multiple Sized Marker*
颜色参数
c–阵列状或颜色或颜色列表，T3 可选*。我们可以使用单一颜色，甚至一个颜色代码十六进制值来得到一些非常好看的图。*
*# Using "c" parameter: with a specific color
import matplotlib.pyplot as plt
import numpy as np
ratings_value = np.asarray([2, 4, 5, 6, 8, 5, 2, 8, 5,
3, 2, 8, 6, 5, 4, 7, 8, 9, 7, 1])
number_of_ratings = np.asarray([10, 24, 17, 45, 23, 32, 67,
34, 54, 54, 32, 67, 35, 23, 14, 16, 28, 32, 29, 28])
sizes = np.asarray([100, 240, 170, 450, 230, 320, 670, 340, 540,
540, 320, 670, 350, 230, 140, 160, 280, 320, 290, 280])
plt.title("Ratings Trend Visualization")
plt.xlabel("Number of ratings")
plt.ylabel("Ratings value")
plt.scatter(x = number_of_ratings, y = ratings_value, s = sizes, c = "green")
plt.show()*
*
Scatter Plot With C Parameter*
标记参数
标记—是指标记样式* 、(默认为:“o”)*
*# Using a different marker: (default: 'o')
import matplotlib.pyplot as plt
import numpy as np
ratings_value = np.asarray([2, 4, 5, 6, 8, 5, 2, 8, 5,
3, 2, 8, 6, 5, 4, 7, 8, 9, 7, 1])
number_of_ratings = np.asarray([10, 24, 17, 45, 23, 32, 67,
34, 54, 54, 32, 67, 35, 23, 14, 16, 28, 32, 29, 28])
sizes = np.asarray([100, 240, 170, 450, 230, 320, 670, 340, 540,
540, 320, 670, 350, 230, 140, 160, 280, 320, 290, 280])
plt.title("Ratings Trend Visualization")
plt.xlabel("Number of ratings")
plt.ylabel("Ratings value")
plt.scatter(x = number_of_ratings, y = ratings_value, s = sizes, c = "green", marker = "^" )
plt.show()*
*
Scatter Plot with Marker Parameter*
颜色图参数
cmap–一个 Colormap 实例或注册的 Colormap 名称。只有当 c 是浮点数组时，才使用 cmap，(默认为:“viridis”)。我们的颜色数组中的每个浮点值代表不同的颜色强度来绘制我们的数据。
Matplotlib 模块有许多可用的颜色映射。
色彩映射表就像一个颜色列表，其中每种颜色都有一个从 0 到 100 的值。
下面是一个色彩映射表的例子:
*
Img of Colorbar*
*# Using cmap parameter: (Default: 'viridis')
import matplotlib.pyplot as plt
import numpy as np
ratings_value = np.asarray([2, 4, 5, 6, 8, 5, 2, 8, 5,
3, 2, 8, 6, 5, 4, 7, 8, 9, 7, 1])
number_of_ratings = np.asarray([10, 24, 17, 45, 23, 32, 67,
34, 54, 54, 32, 67, 35, 23, 14, 16, 28, 32, 29, 28])
sizes = np.asarray([100, 240, 170, 450, 230, 320, 670, 340, 540,
540, 320, 670, 350, 230, 140, 160, 280, 320, 290, 280])
colors = np.asarray([1, 2, 5, 4, 6, 8, 6, 3, 5,
4, 3, 6, 9, 2, 1, 6, 8, 8, 4, 5])
plt.title("Ratings Trend Visualization")
plt.xlabel("Number of ratings")
plt.ylabel("Ratings value")
plt.scatter(x = number_of_ratings, y = ratings_value, s = sizes, c = colors, cmap = "viridis" )
plt.show()*
*
Scatter Plot With Cmap Parameter*
阿尔法参数
alpha–表示生成的标记的透明度强度，范围从 0 到 1。我们还使用 cmap 值作为“绿色”，以更好地了解我们的 alpha 参数
*# Using alpha parameter
import matplotlib.pyplot as plt
import numpy as np
ratings_value = np.asarray([2, 4, 5, 6, 8, 5, 2, 8, 5,
3, 2, 8, 6, 5, 4, 7, 8, 9, 7, 1])
number_of_ratings = np.asarray([10, 24, 17, 45, 23, 32, 67,
34, 54, 54, 32, 67, 35, 23, 14, 16, 28, 32, 29, 28])
sizes = np.asarray([100, 240, 170, 450, 230, 320, 670, 340, 540,
540, 320, 670, 350, 230, 140, 160, 280, 320, 290, 280])
colors = np.asarray([1, 2, 5, 4, 6, 8, 6, 3, 5,
4, 3, 6, 9, 2, 1, 6, 8, 8, 4, 5])
plt.title("Ratings Trend Visualization")
plt.xlabel("Number of ratings")
plt.ylabel("Ratings value")
plt.scatter(x = number_of_ratings, y = ratings_value, s = sizes, c = colors, cmap = "Greens",
alpha = 0.75)
plt.show()*
*
Scatter Plot With Alpha Parameter*
线宽参数
线宽- 指标记边缘的宽度， 边缘颜色-指标记的颜色或颜色序列
*# Using linewidths: (Default: 1.5)
# Using edgecolors
import matplotlib.pyplot as plt
import numpy as np
ratings_value = np.asarray([2, 4, 5, 6, 8, 5, 2, 8, 5,
3, 2, 8, 6, 5, 4, 7, 8, 9, 7, 1])
number_of_ratings = np.asarray([10, 24, 17, 45, 23, 32, 67,
34, 54, 54, 32, 67, 35, 23, 14, 16, 28, 32, 29, 28])
sizes = np.asarray([100, 240, 170, 450, 230, 320, 670, 340, 540,
540, 320, 670, 350, 230, 140, 160, 280, 320, 290, 280])
colors = np.asarray([1, 2, 5, 4, 6, 8, 6, 3, 5,
4, 3, 6, 9, 2, 1, 6, 8, 8, 4, 5])
plt.title("Ratings Trend Visualization")
plt.xlabel("Number of ratings")
plt.ylabel("Ratings value")
plt.scatter(x = number_of_ratings, y = ratings_value, s = sizes, c = colors, cmap = "Greens",
alpha = 0.75, linewidths = 1, edgecolors = "Black")
plt.show()*
*
Scatter Plot With Edgecolors And Linewidths*
结论
在本文中，我们介绍了 python 中最常用的数据可视化方法之一。在多幅图的帮助下，我们还看到了呈现数据的各种方式，这些方式可以用于各种组合，以获得关于数据的一些重要概述。散点图在 python 社区中被广泛使用，matplotlib 正好提供了一种以非常简单和直观的方式绘制数据的工具。
附加参考
Matplotlib 子图–使用 Matplotlib 绘制多个图形
原文:# t0]https://www . aspython . com/python-modules/matplotlib/matplotlib-subplot
在本文中，我们将学习如何创建 Matplotlib 支线剧情。
在实践中，我们经常需要不止一个情节来形象化变量，这就是支线剧情出现的时候。 Matplotlib subplot method 是一个方便的函数，用于在一个图形中创建多个图形。
使用 Matplotlib 创建基本绘图
在 Matplotlib 中创建绘图是一项简单的任务，只需一行代码和一些输入参数即可完成。下面的代码显示了如何用单个图形进行简单的绘图。
#Importing required libraries
import matplotlib.pyplot as plt
import numpy as np
#Create data
data = np.arange(1,5,1)
#Plotting the data:
plt.plot(data)
Simple Plotting
plt.plot()显示输入数据的线图。
创建 Matplotlib 子情节
现在考虑这样一种情况，我们需要多个图来解释我们的数据。例如，我们有一个以温度和降雨率为变量的数据集，我们需要将数据可视化。
我想到的一件事是将这两个变量绘制在一个图中，但温度(开尔文)的测量尺度与降雨率(毫米)的测量尺度不同。
在这里，我们需要一个单独的情节为两者，以便有视觉上的解释。Matplotlib 子情节是我们制作多个情节所需要的，我们将详细探讨这一点。
1.使用 subplots()方法
让我们对使用matplotlib.subplots有一些看法。
matplotlib subplots()方法需要一些行和一些列作为输入参数，它返回一个图形对象和轴对象。
可以使用简单的索引来访问每个轴对象。在选择了需要绘制的轴之后，绘制的过程将像我们在上面的代码中所做的那样遵循正常的过程。
让我们创建 4 个网格状的支线剧情。
#Importing required libraries
import matplotlib.pyplot as plt
# Creates fig and ax from subplots().
fig , ax = plt.subplots(nrows = 2, ncols = 2)
4 Subplots
2.访问支线剧情
访问单个轴非常简单。让我们在第一个和最后一个次要情节上做一些策划。
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
#Loading Dataset
data = load_iris()
df = data.data
fig , ax = plt.subplots(nrows = 2, ncols = 2, figsize=(8,6))
#Plotting on the 1st axes
ax[0][0].scatter(df[:,0],df[:,1] , color = 'black')
#Plotting on the last axes
ax[1][1].scatter(df[:,1],df[:,2] , color = 'red')
Accessing 1st And 4th Subplots
把每个轴想象成排列在 2D 数组中的一些对象，访问每个子情节类似于访问 2D 数组中的元素。
- ax[0][0] 表示我们首先选择第一行(索引 0)和该行的第一个元素(索引 0)。
- ax[1][1] 表示我们首先选择第二行(索引 1)和该行的第二个元素(索引 1)。
3.具有共享轴的 Matplotlib 子图
在许多应用中，我们需要支线图的轴相互对齐。matplotlib subplots()方法接受另外两个参数，即sharex和sharey，这样所有的 subplots 轴都具有相似的比例。
#Import required libraries
import matplotlib.pyplot as plt
#Plotting
fig, ax = plt.subplots(2, 3, sharex=True, sharey=True)
for i in range(0,2):
for j in range(0,3):
ax[i][j].text(0.5, 0.5, str((i,j)),fontsize=18, ha='center')
Subplots with Shared Axis
4.使用 add_subplot()方法
add_subplot是 Matplotlib figure对象的一个属性。每当我们想要一个接一个地给我们的人物添加支线剧情时，它就会被使用。
让我们用示例代码来演示这一点。
#Importing libraries
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
#Loading Data to plot
data = load_iris()
df = data.data
#Create a figure object
fig = plt.figure(figsize=(8,8))
#Adding one subplot to the figure
ax_1 = fig.add_subplot(2, 2, 1) #selecting 1st out of 4 subplots
ax_1.scatter(df[:,0],df[:,1] , color = 'black')
#Adding one more subplot
ax_2 = fig.add_subplot(2,2,4)
ax_2.scatter(df[:,0],df[:,1] , color = 'red')
Adding Subplots One By One
在上面的代码中，figure 对象的add_subplot属性需要一些行和列作为输入参数，以及 subplot 的索引。
但是在这里，我们只需要传递一个类似数字的整数，而不是将支线剧情索引为 2D 数组。
在上面的代码中，将首先创建一个 2×2 的子图网格，并返回第一个子图轴对象，我们可以在其上绘制数据。
结论
在这篇文章中，我们看到了如何在一个图形中可视化多个情节的数据，使用subplots方法和多种方法来创建支线剧情。
快乐学习！
最大堆数据结构 Python 中的完整实现
在本文中，我们将了解更多关于 Max Heap(在 Python 中称为堆队列)的知识。我们已经学习了 python 中的堆及其库函数(在 heapq 模块中)。我们现在将学习 max heap 及其实现，然后看看我们自己实现 max-heap 的heapify、heappush和heappop 函数的 Python 代码。
什么是最大堆？
Max Heap 是一棵完全二叉树(完全二叉树是一棵完全填充的树，除了最深/最后一级中最右边的节点)，其中每个节点大于或等于它的所有子节点。因此堆的根节点是最大的元素。堆数据结构一般用来表示一个优先级队列，max heap 可以理解为一个优先级队列，最大元素为最高优先级。
Max Heap Python AskPython Content 1
max-heap 在数组中是如何表示的？
我们已经看到了堆是如何在内存中以数组的形式表示的，这只是一个简单的提醒:
- 根元素将位于数组的第零个位置，即 Heap[0]。
- 对于任何其他节点，比如说 Heap[i]，我们有以下内容:
- 父节点由下式给出:Heap[(i -1) / 2]
- 左边的子节点由下式给出:Heap[(2 * i) + 1]
- 右边的子节点由下式给出:Heap[(2 * i) + 2]
Max Heap array representation Python
Python 中的堆默认为最小堆，使用 heapq 模块的heapify、heappop和heappush函数。
要使用库函数创建和使用 max-heap，我们可以将每个元素乘以-1，然后使用堆库函数，因此它将充当 max-heap。
现在让我们了解 max-heap 函数是如何工作的，以及我们如何从头开始编写代码来实现这些函数。
了解实现最大堆的函数
1.最大健康功能
此函数使一个节点及其所有后代(子节点及其子节点)遵循最大堆属性。它通过交换节点来重新排列它们，从而使给定的堆成为其子树中最大的节点，遵循 max-heap 属性。
它首先在给定节点及其所有子节点中找到具有最大值的节点。然后，它将给定的节点(比如 I)与找到的最大值节点(比如 j)交换，然后对节点 j 调用max-heapify函数(递归),以确保分配给节点 j 的新值不会破坏其子树中的 max-heap 属性。
由于最多要遍历树的深度，所以它的时间复杂度是 O(d)，d 是深度，或者，就节点数而言，O(log n)，n 是堆中的元素数。
2.构建堆函数
这个函数从一个任意列表(或任何其他可迭代的列表)构建一个堆，也就是说，它获取列表并重新排列每个元素，以满足 max-heap 属性。
它可以简单地通过对每个节点重复应用max-heapify来实现。这个函数的时间复杂度为 O(n)。
3.heap app****功能
这个函数弹出堆的最大值(根元素)。
这实际上是通过用最后一个节点交换根节点并删除现在的最后一个节点(现在包含最大值)然后为根节点调用max-heapify来完成的，以便在由于交换而改变之后保持堆属性。
因为我们只需要处理后代，所以时间复杂度是 O(log n)，其中 n 是元素的数量，或者是 O(h)，其中 h 是 log n 的树的高度，因为它是一个完整的树。
4. heappush 函数
该函数将一个新元素推入堆中，并将其排列到正确的位置，同时保持堆属性。
这实际上是通过在堆的末尾添加一个新节点来实现的。现在，为了维护堆属性，我们从最后一个节点向上遍历(并在需要的地方交换)以修复堆属性，由于添加了 pushed 元素，可能会违反堆属性。
与heappop类似，这里的时间复杂度是 O(log n ),因为我们只需要遍历子树的高度。
5. extractMax 功能
这个函数从堆中返回优先级最高的元素(根元素或最大的元素)。因为我们只需要返回根的值，并且不对堆做任何改变，并且根是在 O(1)时间内可访问的，因此该函数的时间复杂度是 O(1)。
最大堆的完整 Python 实现
现在，我们将在 Python 中实现一个 max-heap。我们在代码中使用一个列表[15，7，9，4，13],并使用build-heap函数将其转换为最大堆。生成的堆将如下所示:
Max Heap Python
实施:
import sys
#defining a class max_heap for the heap data structure
class max_heap:
def __init__(self, sizelimit):
self.sizelimit = sizelimit
self.cur_size = 0
self.Heap = [0]*(self.sizelimit + 1)
self.Heap[0] = sys.maxsize
self.root = 1
# helper function to swap the two given nodes of the heap
# this function will be needed for max-heapify and insertion
# in order to swap nodes which are not in order (not satisfy max-heap property)
def swapnodes(self, node1, node2):
self.Heap[node1], self.Heap[node2] = self.Heap[node2], self.Heap[node1]
# THE MAX_HEAPIFY FUNCTION
def max_heapify(self, i):
# If the node is a not a leaf node and is lesser than any of its child
if not (i >= (self.cur_size//2) and i <= self.cur_size):
if (self.Heap[i] < self.Heap[2 * i] or self.Heap[i] < self.Heap[(2 * i) + 1]):
if self.Heap[2 * i] > self.Heap[(2 * i) + 1]:
# Swap the node with the left child and call the max_heapify function on it
self.swapnodes(i, 2 * i)
self.max_heapify(2 * i)
else:
# Swap the node with right child and then call the max_heapify function on it
self.swapnodes(i, (2 * i) + 1)
self.max_heapify((2 * i) + 1)
# THE HEAPPUSH FUNCTION
def heappush(self, element):
if self.cur_size >= self.sizelimit :
return
self.cur_size+= 1
self.Heap[self.cur_size] = element
current = self.cur_size
while self.Heap[current] > self.Heap[current//2]:
self.swapnodes(current, current//2)
current = current//2
# THE HEAPPOP FUNCTION
def heappop(self):
last = self.Heap[self.root]
self.Heap[self.root] = self.Heap[self.cur_size]
self.cur_size -= 1
self.max_heapify(self.root)
return last
# THE BUILD_HEAP FUNCTION
def build_heap(self):
for i in range(self.cur_size//2, 0, -1):
self.max_heapify(i)
# helper function to print the heap
def print_heap(self):
for i in range(1, (self.cur_size//2)+1):
print("Parent Node is "+ str(self.Heap[i])+" Left Child is "+ str(self.Heap[2 * i]) + " Right Child is "+ str(self.Heap[2 * i + 1]))
maxHeap = max_heap(10)
maxHeap.heappush(15)
maxHeap.heappush(7)
maxHeap.heappush(9)
maxHeap.heappush(4)
maxHeap.heappush(13)
maxHeap.print_heap()
输出:
Parent Node is 15 Left Child is 13 Right Child is 9
Parent Node is 13 Left Child is 4 Right Child is 7
从示例图像中给出的插图可以验证输出。
结论
在本文中，我们了解了最大堆。我们研究了max-heapify、heappush、heappop和build_heap的功能是如何工作的。我们从零开始用 python 进一步实现了这些功能。请继续关注更多内容丰富的文章。
快乐学习！
找到二叉树的最大宽度
原文：https://www.askpython.com/python/examples/maximum-width-of-a-binary-tree
在本文中，我们将修改层次顺序树遍历算法，以找到二叉树的最大宽度。在之前关于平衡二叉树的文章中，我们已经制定并实现了一个算法来寻找二叉树的高度。我们还在 Python 中实现了一个层次顺序二叉树遍历算法。
二叉树的宽度是多少？
在二叉树中，在任何级别 L 上最多可以出现 2 个^L 数量的节点。但是，每个级别不太可能有 2 个^L 数量的元素。由于没有节点，任何级别的元素数量都可能较少。
例如，下图中给出的二叉树的最大宽度是 4，因为在一个级别上最多有四个节点。
Binary tree
如何求二叉树的最大宽度？
我们将使用一种改进的层次顺序树遍历算法来寻找二叉树的最大宽度。这个想法是以某种方式计算每一层的元素数量，以找到它们的最大值。
为此，我们可以使用占位符来分隔树中不同级别的元素。在层级顺序遍历中使用的队列中，我们将在插入一个层级的每个元素后插入一个占位符。这样，无论何时遇到占位符，我们都知道已经遍历了树的一层，因此宽度可以更新。
求二叉树最大宽度的算法
我们将在队列中插入根节点。之后，我们将插入一个 None 对象作为占位符。每当在队列中遇到占位符时，树的宽度将被更新，None 对象将被推入队列。
找到二叉树宽度的算法可以用公式表示如下。该算法将二叉树的根作为输入，并返回最大宽度。
- 如果根为空，则返回 0。
- 将 maximum_width 变量初始化为-1。
- 将当前宽度变量初始化为 0。
- 设 Q 为队列。
- 在 q 中插入 root。
- 不将任何内容插入队列。
- 从 q 中取出一个节点。
- 如果节点为“无”,请转至 9。否则转到 11。
- 比较 maximum_width 和 current_width。将两者中的最大值赋给 maximum_width。
- 将 current_width 设置为 0。如果 Q 为空或 Q 的第一个元素为 None，请转到 14。
- 将 current_width 增加 1。
- 将节点的左子节点插入 q。
- 将节点的右子节点插入 q。
- 检查 Q 是否为空。如果 Q 不为空，转到 7 else Stop。
算法在 Python 中的实现
既然我们已经讨论了总体思路并理解了算法，那么让我们看看它在 Python 中的实现。在这里，我们创建了一个二叉树，并计算了二叉树的最大宽度。
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 width(root):
if root is None:
return 0
max_width = -1
current_width = 0
Q = [root, None]
while Q:
node = Q.pop(0)
if node is None:
if max_width < current_width:
max_width = current_width
current_width = 0
if not Q or Q[0] is None:
continue
Q.append(None)
else:
current_width = current_width + 1
Q.append(node.leftChild)
Q.append(node.rightChild)
return max_width
root = insert(None, 15)
insert(root, 10)
insert(root, 25)
insert(root, 6)
insert(root, 14)
insert(root, 20)
insert(root, 60)
print("Printing the maximum width of the binary tree.")
print(width(root))
输出:
Printing the maximum width of the binary tree.
4
结论
在这篇文章中，我们讨论了寻找二叉树的最大宽度的算法。请继续关注更多关于 Python 中不同算法实现的文章。
Python 中的均值和标准差
原文：https://www.askpython.com/python/examples/mean-and-standard-deviation-python
均值和标准差是统计学中的两个基本指标。我们可以使用统计模块在 Python 中找出均值和标准差。标准差也缩写为 SD。
什么是卑鄙？
平均值是所有条目的总和除以条目数。例如，如果我们有一个 5 个数字的列表[1，2，3，4，5]，那么平均值将是(1+2+3+4+5)/5 = 3。
什么是标准差？
标准差 是一组数值的变异量或离差量的度量。我们首先需要计算数值的均值，然后计算方差，最后是标准差。
标准差的使用
假设我们有美国各州每平方公里的人口数据。我们可以计算标准差来找出人口是如何均匀分布的。较小的值意味着分布是均匀的，而较大的值意味着一些地方很少有人居住，而一些地区人口稠密。
让我们看看计算平均值和标准差所需的步骤。
计算平均值的步骤
- 取所有条目的总和。
- 用总数除以条目数的。
计算标准差的步骤
- 如上所述计算平均值。[1，2，3，4，5]的平均值是 3。
- 从条目值中减去平均值，计算每个条目的方差。所以方差会是[-2，-1，0，1，2]。
- 然后对每个结果值求平方，并将结果相加。对于上面的例子，它将变成 4+1+0+1+4=10。
- 然后将结果除以数据点数减一。这将给出方差。因此方差将是 10/(5-1) = 2.5
- 方差(上面计算的)的平方根就是标准差。所以标准差会是 sqrt(2.5) = 1.5811388300841898。
在 Python 中求平均值和标准差
让我们用 Python 写代码来计算均值和标准差。我们将使用统计模块，稍后尝试编写我们自己的实现。
1.使用统计模块
此模块为您提供了直接计算平均值和标准差的选项。
让我们从导入模块开始。
import statistics
让我们用样本数据声明一个列表。
data = [7,5,4,9,12,45]
现在，要计算样本数据的平均值，请使用以下函数:
statistics.mean(data)
该语句将返回数据的平均值。我们可以使用以下公式打印输出中的平均值:
print("Mean of the sample is % s " %(statistics.mean(data)))
我们得到的输出为:
Mean of the sample is 13.666666666666666
如果您使用 IDE 进行编码，您可以将鼠标悬停在该语句上，获得有关 statistics.mean()函数的更多信息。
或者，你可以在这里 阅读文档 。
要计算样本数据的标准偏差，请使用:
print("Standard Deviation of the sample is % s "%(statistics.stdev(data)))
我们得到的输出为:
Standard Deviation of the sample is 15.61623087261029
这里有一个关于 statistics.stdev ()函数的简要文档。
在 Python 中查找标准偏差和平均值的完整代码
以上代码片段的完整代码如下:
import statistics
data = [7,5,4,9,12,45]
print("Standard Deviation of the sample is % s "% (statistics.stdev(data)))
print("Mean of the sample is % s " % (statistics.mean(data)))
2.编写自定义函数来计算标准偏差
让我们用 Python 编写计算均值和标准差的函数。
def mean(data):
n = len(data)
mean = sum(data) / n
return mean
这个函数将计算平均值。
现在让我们写一个函数来计算标准差。
这可能有点棘手，所以让我们一步一步来。
标准差是方差的平方根。所以我们可以写两个函数:
- 第一个函数将计算方差
- 第二个函数将计算方差的平方根并返回标准差。
计算方差的函数如下:
def variance(data):
n = len(data)
mean = sum(data) / n
deviations = [(x - mean) ** 2 for x in data]
variance = sum(deviations) / n
return variance
可以参考教程开头给出的步骤来理解代码。
现在我们可以写一个函数来计算方差的平方根。
def stdev(data):
import math
var = variance(data)
std_dev = math.sqrt(var)
return std_dev
完全码
完整的代码如下:
import numpy as np #for declaring an array or simply use list
def mean(data):
n = len(data)
mean = sum(data) / n
return mean
def variance(data):
n = len(data)
mean = sum(data) / n
deviations = [(x - mean) ** 2 for x in data]
variance = sum(deviations) / n
return variance
def stdev(data):
import math
var = variance(data)
std_dev = math.sqrt(var)
return std_dev
data = np.array([7,5,4,9,12,45])
print("Standard Deviation of the sample is % s "% (stdev(data)))
print("Mean of the sample is % s " % (mean(data)))
结论
平均值和标准偏差是统计分析中使用的数学值。Python 统计模块提供了有用的函数来轻松计算这些值。
下一步是什么？
资源
数字阵列的含义—快速指南
原文：https://www.askpython.com/python-modules/numpy/mean-of-a-numpy-array
我们知道算术平均值是所有元素的总和除以元素总数。所以在这篇文章中，我们将学习如何找到 NumPy 数组中元素的平均值。我们将使用 numpy.mean()函数来查找单个轴和多个轴上的元素的平均值。所以让我们开始吧！
numpy.mean 函数的语法
numpy.mean(a，axis=None，dtype=None，out=None，keepdims= None)
| 参数 | 描述 |
| a | 降级要计算其平均值的数组 |
| 轴 | 降低要计算平均值的轴的等级 |
| 类型 | 数据类型用于计算平均值。默认类型是浮点 64 |
| 在外 | 存储结果的输出数组 |
| keepdims | 此参数采用布尔值。如果为真，则左侧的轴会减少。 |
Numpy 数组的平均值–所有元素
在这种情况下，一个数组将作为一个输入，简单地计算所有元素的平均值。例如:
import numpy as np
A = np.array([[3, 6], [4, 8]])
output = np.mean(A)
print(output)
输出:
5.25
在这种情况下，平均值的计算如下:
均值: (3+6+4+8)/4 = 5.25
Numpy 数组的平均值-沿轴的元素
在这种情况下，我们将获得一个输入数组，并计算该数组沿轴的平均值。假设如果我们将 o 传递给轴参数，轴的所有其他元素将保持原样。将只计算沿 0 轴的元素的平均值。
例如
import numpy as np
A = np.array([[3, 6], [4, 8]])
output = np.mean(A, axis=0)
print(output)
输出:
[3.5 7]
这里，零轴的元素是[3，6]和[4，8]。因此，平均值计算如下:
均值= ([3，6] + [4，8]) /2
=[(3+4)/2, (6+8)/2]
=[3.5, 7]
Numpy 数组中沿多个轴元素的平均值
在这种情况下，我们将计算 NumPy 数组沿多个轴的平均值。我们将采用 0 轴和 1 轴来计算平均值。
例如
import numpy as np
A = np.array([[[3, 6], [4, 8]], [[5, 9], [7, 1]]])
output = np.mean(A, axis=(0, 1))
print(output)
输出:
[4.75 6]
- ([3，6]，[4，8])和([5，9]，[7，1])是沿轴= 0 出现的元素。
- ([3，6]，[4，8]，[5，9]，[7，1])是沿轴=1 的元素
平均值的计算如下:
均值= ([3，6] + [4，8] + [5，9] + [7，1])/4
= [(3+4+5+7)/4 , (6+8+9+1)/4]
= [4.75 , 6]
结论
总之，我们学习了如何计算整个数组的平均值，单轴平均值和多轴平均值。希望这篇文章对你有用。
使用 Pandas melt()和 pivot()函数融化和取消融化数据
原文：https://www.askpython.com/python-modules/pandas/melt-pivot-data
读者朋友们，你们好！本文将重点介绍如何使用 melt()和 pivot()函数来融合和取消融合 Pandas 数据框中的数据值。
所以，让我们开始吧！🙂
熊猫的融化和不融化数据——简明概述
在深入研究融化和不融化数据的概念之前，我想把你的注意力吸引到这个诱人的词上来——冰淇淋🙂
是啊！冰淇淋…当你的盘子里有冰淇淋，当你正要吃第一口时，你接到一个电话。冰淇淋显然会融化，变成奶昔。
类似地，现在考虑在数据框中融合数据值的概念。数据值的融合用于将数据值从较宽的格式配置和改变为更窄和更长的格式。熔化的基本目的是创建特定格式的数据帧，其中一个或多个数据列充当数据属性的标识符。
在这个场景中，剩余的数据变量实际上被认为是数据值，并且只存在两列:变量和值。
另一方面，我们对数据变量执行去融合，以将值恢复到原始格式。
理解了数据的融化和不融化，现在让我们来理解熊猫的功能，它使我们能够实现同样的功能。
1.融化熊猫的数据变量
为了对数据变量进行熔化， Python Pandas 模块为我们提供了 melt()函数。
语法:
pandas.melt(frame, id_vars=None, value_vars=None,
var_name=None, value_name='value')
- 框架:需要融化的实际数据框架。
- id_vars:将作为标识符的列名。
- value_vars:将被塑造成值的所有变量名(标识符变量除外)。
- value_name:列值的名称，默认为值。
举例:
在本例中，我们使用 data frame()函数创建了一个包含变量的数据框:City、ID 和 Fav。
此外，我们现在将整个数据帧传递给 melt()函数，传递 ID 作为标识符变量，City 和 Fav 作为值变量。
import pandas as pd
data = {"City": ["Pune", "Satara", "Solapur"], "ID": [1, 2, 3], "Fav": ["1", "3", "10"]}
dataf = pd.DataFrame(data)
print("Before melting..")
print(dataf)
melt_df = pd.melt(dataf, id_vars=["ID"], value_vars=["City", "Fav"])
print("After melting..")
print(melt_df)
输出:
因此，熔化后的数据只有三列:ID(标识符变量)、变量和值。通过这种方式，它可以将数据帧从宽格式转换为长格式。
Before melting..
City ID Fav
0 Pune 1 1
1 Satara 2 3
2 Solapur 3 10
After melting..
ID variable value
0 1 City Pune
1 2 City Satara
2 3 City Solapur
3 1 Fav 1
4 2 Fav 3
5 3 Fav 10
我们还可以跳过原始数据框中的列，同时将它传递给 melt()函数以排除某些列。
import pandas as pd
data = {"City": ["Pune", "Satara", "Solapur"], "ID": [1, 2, 3], "Fav": ["1", "3", "10"]}
dataf = pd.DataFrame(data)
print("Before melting..")
print(dataf)
melt_df = pd.melt(dataf, id_vars=["City"], value_vars=["Fav"])
print("After melting..")
print(melt_df)
输出—
这里，因为我们已经排除了变量 ID ，所以在融合数据变量时不考虑它。
Before melting..
City ID Fav
0 Pune 1 1
1 Satara 2 3
2 Solapur 3 10
After melting..
City variable value
0 Pune Fav 1
1 Satara Fav 3
2 Solapur Fav 10
2.使用 Pandas pivot()函数取消数据值的融合
融合了数据变量之后，现在是时候恢复数据框架的形状了。同样，Python 为我们提供了 pivot()函数。
语法:
pandas.pivot(index, columns)
- 索引:需要应用的标签，以使新数据框的索引就位。
- 列:需要应用的标签，以使新数据框的列就位。
举例:
- 首先，我们创建了一个包含 ID、City 和 Fav 列的数据框。
- 然后，我们应用 melt 并使用针对 ID 变量的 melt()函数延长数据帧作为标识符，用表达式作为变量名，用值作为代表非 pivoted 变量的列名。
- 最后，我们使用 pivot()函数取消数据融合，提供 ID 作为新数据框的索引集。
import pandas as pd
data = {"City": ["Pune", "Satara", "Solapur"], "ID": [1, 2, 3], "Fav": ["1", "3", "10"]}
dataf = pd.DataFrame(data)
print("Before melting..")
print(dataf)
melt_df = pd.melt(dataf, id_vars=["ID"], value_vars=["City","Fav"], var_name="Expression", value_name="Value")
print("After melting..")
print(melt_df)
unmelt = melt_df.pivot(index='ID', columns='Expression')
print("Post unmelting..")
print(unmelt)
输出—
Before melting..
City ID Fav
0 Pune 1 1
1 Satara 2 3
2 Solapur 3 10
After melting..
ID Expression Value
0 1 City Pune
1 2 City Satara
2 3 City Solapur
3 1 Fav 1
4 2 Fav 3
5 3 Fav 10
Post unmelting..
Value
Expression City Fav
ID
1 Pune 1
2 Satara 3
3 Solapur 10
结论
到此，我们就结束了这个话题。如果你遇到任何问题，欢迎在下面评论。更多与 Python 编程相关的帖子，请继续关注我们。
在那之前，学习愉快！！🙂
Python 成员和标识运算符
原文：https://www.askpython.com/python/examples/membership-and-identity-operators
读者朋友们，你们好！在本文中，我们将详细关注 Python 成员和身份操作符。
所以，让我们开始吧！！🙂
Python 成员和身份操作符–快速概述！
Python 为我们提供了各种各样的操作符，以便在更大的范围内对数据值和变量执行操作。在本文的上下文中，我们将主要关注 Python 中两种重要的操作符类型:
- 隶属运算符
- 身份运算符
现在，让我们在下一节中继续了解它们各自的功能。
Python 成员运算符–[' in '，' not in']
Python 成员操作符帮助我们评估和验证数据结构(如列表、元组等)中特定序列的数据值的成员关系。我们的意思是，它检查给定的数据序列是否存在于另一个序列或结构中，并对其进行验证。
1。python“in”成员运算符
in 运算符是一个布尔运算符，它检查数据结构中是否存在特定的数据序列，如果找到，则返回 true。否则，它返回 false。
举例:
在这个例子中，我们在列表(list1)中搜索数据序列值(10，20)。找到后，它打印结果语句。
lst1=[10,20,30,40,50]
lst2=[10,6,20,7]
for x in lst1:
if x in lst2:
print("Data overlaps for value:", x)
输出:
Data overlaps for value: 10
Data overlaps for value: 20
2。Python“不在”成员运算符
如果在列表、字符串等序列中没有遇到给定的数据值，则 not in 运算符的结果为真。
举例:
在本例中，数据值“32”不在列表中，因此它返回 false 并在 if 条件后打印语句。
lst=[10,20,30,40,50]
data = 32
if data not in lst:
print("Data not found")
else:
print("Data is present")
输出:
Data not found
Python 标识运算符–['是'，'不是']
Python 中的 Identity 操作符帮助我们检查值的相等性，比如它们指向什么样的内存位置，是否具有预期的相同数据类型，等等。
1。python“is”标识运算符
使用“is”操作符，我们可以很容易地检查任意一端的值的有效性，无论它们是指向同一个内存点，还是具有相同的数据类型或所需的数据类型，等等。
举例:
在下面的例子中，我们使用 is 运算符来检查数据值是否是 float 类型。如果条件满足，则返回 TRUE，否则返回 false。
data = 40.03
if type(data) is float:
print("TRUE")
else:
print("FALSE")
输出:
TRUE
2。Python“不是”标识运算符
使用“is not”操作符，我们根据等式或上述条件检查有效性，如果它们不满足，则返回 TRUE。如果条件满足，则返回 FALSE。
data = 40.03
if type(data) is not int:
print("Not same")
else:
print("same")
输出:
Not same
结论
如果你遇到任何问题，欢迎在下面评论。更多与 Python 编程相关的帖子，请继续关注我们。在那之前，学习愉快！！🙂
Python 中的记忆化——简介
原文：https://www.askpython.com/python/examples/memoization-in-python
在本教程中，我们将讨论一种非常流行的优化技术 Python 中的记忆化——主要用于加速计算机程序。所以，让我们开始吧！
Python 中的记忆化是什么？
在计算机编程的世界里，Python 中的 Memoization 或 memo ization是一种特殊的优化技术，主要用于加速我们的计算机程序。通过将昂贵的(就运行时间而言)函数调用的结果存储到存储器中，并在需要任何存储或缓存的值时使用它，它有效地减少了计算机程序的运行时间。
它确保特定的函数或方法不需要对同一组输入运行多次，因为结果已经作为缓存/存储的数据可用。
类似于缓存。它包括根据函数的输入参数缓存函数的返回值。
在 Python 中，我们可以使用 函数和基于类的装饰器 在程序中实现记忆化技术。在我们的整个讨论中，我们将使用一个递归 Python 程序来计算第 n 个^(斐波纳契数，因为对于更大的输入，这个程序将变得非常非常慢，因为对相同输入值的函数调用的数量随着输入大小的增加而增加。)
Python 中使用基于函数的装饰器的记忆化
对于那些想了解这种优化技术实际上是如何工作的人来说，这是在 Python 中实现记忆化技术的最好也是最复杂的方法。在这种实现记忆化技术的方法中，我们在 Python 中定义了自己的装饰函数来缓存/存储函数调用的返回值。让我们看看如何编写 Python 代码来实现这一点。
# Memoization using function-based decorators
def memoize(f):
cache = {}
def foo(x):
if x not in cache:
cache[x] = f(x)
return cache[x]
return foo
@memoize
def fibonacci(n):
if n == 0:
return 0
elif n == 1:
return 1
else:
return fibonacci(n-1) + fibonacci(n-2)
# Driver code
fibonacci(20)
输出:
6765
使用基于类的装饰器的记忆化
对于想了解这种优化技术实际上是如何工作的初学者来说，这是在 Python 中实现记忆化技术的第二好也是最复杂的方法。在这种实现记忆化技术的方法中，我们在 Python 中定义了自己的 decorator 类来缓存/存储函数调用的返回值。让我们编写 Python 代码来实现这一点。
# Memoization using class-based decorators
class classMemoize:
def __init__(self, f):
self.f = f
self.cache = {}
def __call__(self, *x):
if x not in self.cache:
self.cache[x] = self.f(*x)
return self.cache[x]
@classMemoize
def fibonacci(n):
if n == 0:
return 0
elif n == 1:
return 1
else:
return fibonacci(n-1) + fibonacci(n-2)
# Driver code
fibonacci(50)
输出
12586269025
使用内置装饰函数的记忆化
这是在 Python 中实现记忆技术的最简单和最容易的方法之一。
在这种实现记忆化技术的方法中，我们不定义自己的装饰函数或类，而是利用内置函数如lru_cache()和cache()来缓存/存储函数调用的中间结果。
这些lru_cache()和cache()函数是在funtools库中定义的，它是一个标准的 Python 库，并且是在正常的 Python 安装中附带的。
lru_cache(maxsize=None, typed=False)函数通过其参数如maxsize和typed提供一些定制功能。参数maxsize通过将其值设置为无或整数值来决定是否启用 LRU 功能。并且参数typed决定不同类型的数据是否被分开缓存。
整数值将限制 Python 程序执行期间维护的缓存大小，而 None 值将禁用 LRU 功能，然后缓存可以无限制增长。
从 Python 3.9 版本开始，cache()函数可用，它相当于funtools库中的lru_cache(maxsize=None)函数。
# Memoization using built-in function
import functools
@functools.cache
def fibonacci(n):
if n == 0:
return 0
elif n == 1:
return 1
else:
return fibonacci(n-1) + fibonacci(n-2)
# Driver code
fibonacci(100)
输出:
354224848179261915075
结论
在本教程中，我们学习了如何使用函数和基于类的装饰器来使用 Python 中的记忆化技术。我希望你已经很好地理解了上面讨论的内容，并准备在你的 Python 程序中使用/实现这种记忆技术来提高它的速度。
Python 中的内存管理
原文：https://www.askpython.com/python/examples/memory-management-in-python
内存管理是动态存储内存并在不使用时释放内存的过程。
理解 Python 中的内存管理
在 python 中，内存的这种分配和释放是由 Python 开发人员创建的 Python 垃圾收集器自动完成的，因此用户不必进行手动垃圾收集。
碎片帐集
Python 中的垃圾收集是解释器为我们的程序释放未使用和不想要的内存的内存管理过程。在 Python 中，这是自动完成的。
垃圾收集器找到没有指向它的引用的对象，然后从堆内存中删除该对象。为此，Python 使用了引用计数算法。
示例:
class Python:
def __init__(self):
print('The object is created.')
def __del__(self):
print('The object is destroyed.')
obj1 = Python()
obj2 = obj1
obj3 = obj1
print("Set obj1 to None")
obj1 = None
print("Set obj2 to None")
obj2 = None
print("Set obj3 to None")
obj3 = None
输出:
The object is created.
Set obj1 to None
Set obj2 to None
Set obj3 to None
The object is destroyed.
这里，我们创建了一个类 Python 的对象，并将其引用传递给 obj1，obj2，obj3 。这使得该对象的引用计数为 3。然后，当我们将这些引用分配给 none 时，来自该对象的所有引用都被移除并变成 0。由于没有对该对象的引用，python 垃圾收集器销毁了该对象，并执行 del()方法。
引用计数
Python 中的引用计数是一种技术，当没有引用指向对象时，从内存中释放对象。当引用计数变为零时，对象被删除。
我们有一个内置函数 getrefcount() 存在于 python 模块 sys 中，它返回给定 python 对象的引用数。
示例:
import sys
str = "Welcome to Python"
print(sys.getrefcount(str))
arr = []
arr.append(str) # appending to an array
print(sys.getrefcount(str))
dict = {}
dict['str'] = str # adding to a dictionary
print(sys.getrefcount(str))
arr = [] # resetting the array
sys.getrefcount(str)
dict['my_str'] = "Some other string"
print(sys.getrefcount(str))
输出:
4
5
6
5
reference count 的值比您预期的值高一，因为它还计算函数 sys.getrefcount()中传递的对象的引用计数。
有时对象的引用计数永远不会达到零。发生这种情况是因为对象引用了自己。这被称为参考周期。
示例:
import sys
x = []
x.append(x) # x contains reference to itself
print("Reference count of object is",sys.getrefcount(x))
输出:
Reference count of object is 3
这里，创建了一个引用自身的对象 x。引用计数永远不会达到 0，因为它有自己的引用。对象 x 将占用内存，直到 Python 垃圾收集器被调用。
当 object 被全局声明时，对象的引用计数永远不会变为零。
存储器分配
要了解内存分配，我们必须了解随机存取存储器(RAM)。RAM 也称为主存储器，允许在计算机上存储和检索信息。
在 RAM 的顶部，我们有一个栈，在底部，我们有堆。堆负责存储变量/值，栈负责保存对堆中对象的引用。
Stack and Heap locations in RAM
在 Python 中，当多个变量具有相同的值时，会在堆中创建指向原始值的第二个变量。
示例:
x = 5
y = x
if(id(x) == id(y)):
print("x and y refer to the same object")
x = x+1
if(id(x) != id(y)):
print("x and y refer to different objects")
z = 5
if(id(y) == id(y)):
print("y and z refer to same memory")
输出:
x and y refer to the same object
x and y refer to different objects
y and z refer to same memory
内存分配有两种类型:
- 堆栈内存分配
- 堆内存分配。
1.堆栈内存分配
堆栈内存分配是特定函数或方法调用内部静态内存的存储。当调用函数时，内存存储在函数调用堆栈中。任何局部变量初始化都存储在调用堆栈中，一旦函数返回就被删除。
所以，当我们运行我们的程序时，所有的函数首先存储在调用栈中，然后在函数返回时被删除。
示例:
def func():
#These initializations are stored in stack memory
x = 10
y = "Apple"
2.堆内存分配
堆内存分配是特定函数或方法调用之外所需的内存存储。这个内存是在程序全局范围内使用的。
堆内存与堆数据结构无关。它只是当用户想要分配和释放变量/值时提供给他们的一个大的内存空间。
在 Python 中，堆内存由解释器自己管理，用户对它没有控制权。
示例:
def func()
#Allocates memory for 5 integers in heap memory
x=[None]*5
结论
程序员们爱上了 Python，因为它具有超强的内存管理能力。与许多其他低级编程语言相比，Python 使得使用变量变得轻而易举，而不用担心过度使用资源。
参考
使用 Tkinter 的菜单和菜单按钮
原文：https://www.askpython.com/python-modules/tkinter/menu-bar-and-menubutton
在这篇文章中，我们将讨论使用 Python 和 Tkinter 创建菜单栏和菜单按钮。
我将通过一个例子向您介绍这篇文章。
什么是菜单栏？
正如我们以前在笔记本电脑、应用程序等中使用的一样，菜单栏是位于标题栏下方屏幕顶部的水平栏，包含下拉菜单。
创建您的第一个 Tkinter 菜单栏
我们只是定义了一个菜单，所以我们可以随意命名它。我们姑且称之为my_menu，这是Menu()类的一个对象。我们希望这个出现在我们的root中，我应该提到这只是我们通常开始使用的常规代码，它将有一个 400 x 400 的小图标和一个标题。
1.将菜单放置在根窗口中
所以我们想把这个菜单放在根目录下，从现在开始我们将把它称为 my_menu，就像我们在 Tkinter 中使用的任何其他类型的小部件一样。
from tkinter import *
root = Tk()
root.title("Menu Bar")
root.geometry("400x400")
my_menu=Menu(root)
root.config(menu=my_menu)
root.mainloop()
2.添加菜单项
现在，我们将告诉 Tkinter 使用my_menu作为菜单，它知道菜单是什么。它知道菜单在顶部，也知道点击时菜单会下拉。
所以现在，我们需要创建一个菜单项。
所以我们姑且称之为“文件 _ 菜单”。这将是我们菜单中的第一项，我们只需将它设置为一个菜单(在本例中为 my_menu)。我们需要把它放到屏幕上。
我们一般是网格或者打包。但在这里，我们将使用级联。
file_menu= Menu(my_menu)
my_menu.add_cascade(label="File", menu=file_menu)
file_menu.add_command(label="New...",command=our_command)
file_menu.add_separator()
file_menu.add_command(label="Exit",command=root.quit)
我们在这里使用了 my_menu.add_cascade()，但是我们可以在这里放一个“label”参数。我们在这里做的是创建小的子菜单，我们把第一个子菜单叫做 file_menu。
现在，我们需要向新的小子菜单添加内容，这样我们就可以说 file_menu.add_command()。
我通过调用 file_menu.add_separator()在“新建”和“退出”按钮之间放置了小分隔符，这只是一个函数。
类似地，我们创建 edit_menu 和 option_menu。
edit_menu = Menu(my_menu)
my_menu.add_cascade(label="Edit",menu=edit_menu)
edit_menu.add_command(label="Cut",command=our_command)
edit_menu.add_command(label="Copy",command=our_command)
option_menu = Menu(my_menu)
my_menu.add_cascade(label="Edit",menu=option_menu)
option_menu.add_command(label="Find",command=our_command)
option_menu.add_command(label="Find Next",command=our_command)
3.添加菜单按钮
菜单按钮小部件向下拉菜单添加按钮。
简而言之，我将菜单按钮命名为mButton。我们将使用mButton.grid()，这将指定我们需要一个网格，这是我们将要放置列表项的地方。
现在，我们需要做mButton.menu = Menu(mButton)来指定我们实际上想要一个菜单风格的系统。
mButton=Menubutton(root,text="Click")
mButton.grid()
# insert any menu here
mButton.menu.add_checkbutton(label="Copy")
mButton.pack()
实现 Tkinter 菜单和 Menubutton 的完整代码
完整的代码如下所示，其输出也显示出来供您参考。
from tkinter import *
root = Tk()
root.title("Menu Bar")
root.geometry("400x400")
my_menu=Menu(root)
root.config(menu=my_menu)
def our_command():
my_label = Label(root, text="Clicked!!").pack()
file_menu= Menu(my_menu)
my_menu.add_cascade(label="File", menu=file_menu)
file_menu.add_command(label="New...",command=our_command)
file_menu.add_separator()
file_menu.add_command(label="Exit",command=root.quit)
mButton=Menubutton(root,text="Click")
mButton.grid()
edit_menu = Menu(my_menu)
my_menu.add_cascade(label="Edit",menu=edit_menu)
edit_menu.add_command(label="Cut",command=our_command)
edit_menu.add_command(label="Copy",command=our_command)
mButton.menu.add_checkbutton(label="Copy")
mButton.pack()
option_menu = Menu(my_menu)
my_menu.add_cascade(label="Edit",menu=option_menu)
option_menu.add_command(label="Find",command=our_command)
option_menu.add_command(label="Find Next",command=our_command)
root.mainloop()
Output 1
Output 2
Output 3
结论
所以，让我们快速回顾一下，你可以从配置你的菜单开始。
- 我们称它为“我的菜单”,它是一个菜单小工具，我们把它放在了根目录下。唯一奇怪的是我们必须配置它。所以它是 root.config，然后我们告诉我们的程序使用什么菜单。
- 为了创建项目，我们设计了一个顶级的东西，比如文件/编辑/选择，并将其添加到我们的菜单中，然后我们就级联。
- 要添加项目，你只需添加命令并设置标签，然后输入你的命令就可以了。唯一的另一件奇怪的事情是这个小分离器，它超级简单，非常酷。
一定要试试这个例子，并在下面的评论区告诉我们你的想法。
Python 中如何合并字典？
原文：https://www.askpython.com/python/dictionary/merge-dictionaries
本文涵盖了 Python 中合并字典的所有方法。字典是在 Python 中存储数据的一种便捷方式。它们以键值对的形式存储数据。
使用字典时，您可能想要合并两个字典。
Python 中合并字典的不同方法
当涉及到合并两本词典时，有不止一种方法。
在本教程中，我们将讨论合并两个词典的不同方法。
1.使用 for 循环
您可以使用一个 for 循环将一个字典的条目复制到另一个字典。这是合并两本词典的幼稚方法。
您必须使用 for 循环遍历一个字典，同时将条目添加到另一个字典中。
执行此操作的 python 代码如下:
dict1 = { 'Rahul': 4, 'Ram': 9, 'Jayant' : 10 }
dict2 = { 'Jonas': 4, 'Niel': 9, 'Patel' : 10 }
print("Before merging")
print("dictionary 1:", dict1)
print("dictionary 2:", dict2)
dict3 = dict1.copy()
for key, value in dict2.items():
dict3[key] = value
print("after updating :")
print(dict3)
2.使用。更新()
Python 中的字典有一个内置方法用于合并两个字典。您可以在其中一个字典上调用此方法，并将另一个字典作为参数传递。
这可以使用以下代码行来完成:
dict1.update(dict2)
完整的代码如下所示:
dict1 = { 'Rahul': 4, 'Ram': 9, 'Jayant' : 10 }
dict2 = { 'Jonas': 4, 'Niel': 9, 'Patel' : 10 }
print("Before merging")
print("dictionary 1:", dict1)
print("dictionary 2:", dict2)
dict1.update(dict2)
print("after updating :")
print(dict1)
使用 update 方法的一个缺点是只能传递一个字典作为参数。这限制了您一次只能合并两个字典。
您可以使用** (kwargs)运算符将多个字典合并在一起。我们接下来会看到这一点。
3.使用**kwargs
Kwargs 又名**解包操作符(**** )也允许你合并两个或更多的字典。
Kwargs 是关键字参数的简称。它让你发送可变长度键-值对。
要使用 ****** 合并字典，请使用以下代码行:
dict3 = {**dict1, **dict2}
完整的代码如下:
您也可以使用相同的方法来合并两个以上的字典。
dict3 = {**dict1, **dict2, **dict3}
完整的代码如下:
dict1 = { 'Rahul': 4, 'Ram': 9, 'Jayant' : 10 }
dict2 = { 'Jonas': 4, 'Niel': 9, 'Patel' : 10 }
dict3 = { 'John': 8, 'Naveen': 11, 'Ravi' : 15 }
print("Before merging")
print("dictionary 1:", dict1)
print("dictionary 2:", dict2)
print("dictionary 3:", dict3)
dict3 = {**dict1, **dict2, **dict3}
print("after updating :")
print(dict3)
Merge 3 Dictionaries
4.使用合并运算符
合并字典的最好方法是使用 merge 操作符。这使得执行合并操作变得非常简单。
您可以使用下面的代码行合并两个字典。
dict1 |= dict2
完整的代码如下:
dict1 = { 'Rahul': 4, 'Ram': 9, 'Jayant' : 10 }
dict2 = { 'Jonas': 4, 'Niel': 9, 'Patel' : 10 }
print("Before merging")
print("dictionary 1:", dict1)
print("dictionary 2:", dict2)
dict1 |= dict2
print("after updating :")
print(dict1)
结论
本教程涵盖了四种不同的方法，你可以用它们来合并 python 中的字典。希望你和我们一起学习愉快！
理解 Python 中的合并排序
原文：https://www.askpython.com/python/examples/merge-sort-in-python
在本文中，我们将了解一种高效的排序算法——Python 中的 Merge Sort。合并排序算法用于按升序或降序对现有数据进行排序。让我们来看看如何利用该算法并用 Python 实现它。
在 Python 中使用合并排序
合并排序是一种纯粹基于分治法的通用排序技术。
在分治技术中，元素被分成更小的部分或列表。然后将适当的函数应用于主输入列表的每一半。此外，两半合并在一起得到结果。
Merge Sortis 是一个recursive technique函数，其中未排序的元素被分成两半/两部分，该函数以这样一种方式为分开的两半调用它自己，使得两半保持递归地将它们自己分成两部分，直到整个数组被排序。
它递归地调用半列表或子列表，直到所有的元素都被分离，并且没有进一步分割的可能，即每个子列表包含 1 个(单个)元素。
然后，使用比较和交换的基本技术对元素进行排序。最后，它将所有元素合并在一起，以获得最终的数据项排序列表。
让我们借助一个例子来理解 Python 中归并排序的工作原理；
考虑元素列表:11，31，7，41，101，56，77，2
Merge Sort in Python -Example
如上所述，最初，我们将数据元素的原始列表分成两半。
由于上面的原始数组包含 8 个元素，我们将该数组分成 4 个元素的子数组。该数组不断递归地将自身划分为子列表，直到每个子列表获得一个元素，即不可能再进一步划分。
Merge Sort in Python-Splitting Of The Data Elements
如前所述，列表被递归地分成两部分，直到所有的元素都被分离成一个单独的元素。
拆分元素后，您将看到如下所示的各个元素:
Merge Sort in Python-Result After Recursive Splitting Of Elements
一旦元素被分离，我们需要以与分离元素相同的方式组合数据元素。
考虑元件 11 和 31 。当它们处于排序后的位置时，我们将它们组合在一起，并将其合并到一个数组中。元素 7 和 41 也出现在它们排序后的位置，所以我们也合并它们。
现在，如果你看一下元素 101 和 56 ，我们需要交换它们的位置并将它们合并在一起。以类似的方式，元素 77 和 2 相对于它们的位置被交换并合并在一起。
Merging and Sorting Iteration 1
接下来，在第二次迭代中，我们将两个元素的子数组与另一个子数组进行比较，如果发现元素已排序，我们将子数组合并在一起。子阵【11，31】与【7，41】比较，子阵【56，101】与【2，77】比较。由于数据项不在它们的排序顺序中，它们的位置被交换。
Merging And Sorting Iteration 2
在第三次迭代中，4 个元素的子阵列与另一个子阵列进行比较，即【7，11，31，41】与【2，56，77，101】进行比较。可以清楚地看到，元素不在它们排序的位置上，所以元素被交换和合并以获得最终排序的数组。
Merging And Sorting Iteration 3
合并排序算法
以递归方式执行以下步骤来执行合并排序并获得适当的结果:
- 找到将原数组分成两部分所需的中间元素。
- 以递归方式将原始列表分成两半，直到每个子列表都包含一个元素。即每半个递归调用 merge_sort()函数。
- 检查数据值，如果发现未排序，交换元素并合并子列表以获得原始排序列表。
在 Python 中实现合并排序
def merge_sort(inp_arr):
size = len(inp_arr)
if size > 1:
middle = size // 2
left_arr = inp_arr[:middle]
right_arr = inp_arr[middle:]
merge_sort(left_arr)
merge_sort(right_arr)
p = 0
q = 0
r = 0
left_size = len(left_arr)
right_size = len(right_arr)
while p < left_size and q < right_size:
if left_arr[p] < right_arr[q]:
inp_arr[r] = left_arr[p]
p += 1
else:
inp_arr[r] = right_arr[q]
q += 1
r += 1
while p < left_size:
inp_arr[r] = left_arr[p]
p += 1
r += 1
while q < right_size:
inp_arr[r]=right_arr[q]
q += 1
r += 1
inp_arr = [11, 31, 7, 41, 101, 56, 77, 2]
print("Input Array:\n")
print(inp_arr)
merge_sort(inp_arr)
print("Sorted Array:\n")
print(inp_arr)
输出:
Input Array:
[11, 31, 7, 41, 101, 56, 77, 2]
Sorted Array:
[2, 7, 11, 31, 41, 56, 77, 101]
归并排序的时间复杂度
归并排序的时间复杂度为: O(nlogn)
结论
因此，在本文中，我们已经理解了 Python 中合并排序的工作原理。看看 Python 中的其他排序算法。
Python 中的元类
一个 元类 是一个类的类。每当创建一个类(对象)的实例时，该对象的行为方式由该类定义。元类定义了类本身的行为。
Python 中元类的使用
使用元类的原因是 Python 类本身就是对象。因为类是对象，所以我们可以对它进行各种操作，比如给变量赋值，复制等等。
因为它们是对象，我们可以动态地创建它们，就像我们可以创建任何其他对象一样。
为了更好地理解元类的概念，我们首先看看 Python 是如何定义类的。该语言将一切都定义为对象，无论是int、string还是其他任何东西。
如果您还记得的话，为了查看任何 Python 对象的类型，我们使用了type函数。
>>> print(type(123))
<class 'int'>
>>> print(type([1, 2, 3]))
<class 'list'>
>>> class A():
... def __init__(self):
... pass
...
>>> a = A()
>>> print(type(a))
<class '__main__.A'>
正如我们所观察到的，它为每种情况返回一个class。但是要了解 Python 如何定义类本身，我们只需看看它的类型。
>>> print(type(type(123))
<class 'type'>
>>> print(type(A))
<class 'type'>
如你所见，类型(class)是类type！所以原来类是由类本身定义的？这是什么现象？
这是元类的概念，用于定义其他类。基本上就是一个类工厂，从中可以定义其他类如int s、str s。
Metaclass hierarchy
type是语言用来创建一个对象的元类。(这就是为什么每个对象都有一个类型)
因为type是一个元类，我们可以从它创建其他类。
动态创建类
我们可以通过类型构造函数实例化来动态创建类:type(name, bases, attr)
-
名称 - >班级名称
-
bases - >新类继承的类
-
attr - >字典中包含的属性+方法的类
>>> Animal = type('Animal', (), dict(__init__ = lambda self: None, worth = lambda self, value: value))
这与以下内容相同:
class Animal():
def __init__(self):
pass
def worth(self, value):
return value
与第二段代码相比，第一段代码更容易编写。即使在动态声明期间编写类体也不能提供很大的灵活性。
因此，元类提供了一种强大而简单的动态创建新类的方法。
创建自定义元类
为了创建我们自己的元类，我们需要继承现有的“类型”元类，并覆盖一些特殊的方法:
-
__ 新 __() - >这是之前叫的
__init__()。它负责创建对象并返回它。 -
__ init __() - >这用于初始化新创建的对象，该对象作为参数传递(
self参数)
下面的代码片段显示了如何创建元类:
class MyMetaclass(type):
def __new__(cls, name, bases, dict):
print('Creating a new object of', name)
# Invoke __new__() method of the metaclass type
return super(MyMetaclass, cls).__new__(cls, name, bases, dict)
def __init__(cls, name, bases, dict):
print('Initialising class', name)
super(MyMetaclass, cls).__init__(name, bases, dict)
既然我们已经创建了我们的自定义元类，我们需要确保创建使用我们的元类的其他类。
为此，我们在新的类定义中传递metaclass参数，它告诉类使用我们的自定义元类作为它自己的元类，而不是type。
class Student(metaclass=MyMetaclass):
def __init__(self, name):
self.name = name
def get_name(self):
return self.name
这里，Student使用MyMetaclass作为它的元类。因此，当创建 Student 的实例时，我们的自定义元类方法将被调用，而不是type元类。
stud = Student('Amit')
print(stud.get_name())
print('Type of Student object:', type(stud))
print('Type of Student Class:', type(Student))
输出
Creating a new object of Student
Initialising class Student
Amit
Type of Student object: <class '__main__.Student'>
Type of Student Class: <class '__main__.MyMetaclass'>
注意:2.7 或更低版本的旧 Python 使用__metaclass__关键字来指定所使用的元类。Python3 改变了这种行为，将metaclass作为参数传递。
结论
虽然元类是创建自定义 API 和定义它们在对象和类创建过程中的行为的一种非常强大的方法，但它们在实践中很少使用，因为还有其他解决方法。
这篇文章只是作为这个主题的一个起点，并且是关于理解 Python 如何用type元类来定义一切。
我们看了如何创建元类，以及在创建类的过程中调用的方法。
参考
StackOverflow 关于元类的帖子(这提供了关于这个主题的深入讨论。如果你想了解更多关于元类的知识，推荐):https://stack overflow . com/questions/100003/what-are-meta classes-in-python
使用 Python 预测微软股票价格
原文：https://www.askpython.com/python/examples/microsoft-stock-price-prediction
在这个 Python 教程里我们来说说微软股价预测。微软现在是世界顶尖的科技公司之一，在全球雇佣了超过 163，000 名员工。它以生产 Windows 操作系统而闻名，这是使用最广泛的计算机操作系统之一。
这篇文章将教你如何预测微软股票的未来价值。在这篇文章中，我将通过使用 Python 的机器学习来指导您预测微软股票价格的过程。
导入必要的模块/库和数据集
让我们通过加载相关的 Python 模块和数据集来开始预测微软股票价格的挑战:
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
sns.set()
plt.style.use('seaborn')
data = pd.read_csv("MSFT.csv")
data.head()
Microsoft Stock Price Prediction Dataset
数据可视化
该数据集中的 Close 列包含我们希望预测其未来值的值。因此，让我们更深入地了解一下微软股价的历史收盘价:
plt.figure(figsize=(10, 4))
plt.title("Microsoft Stock Prices")
plt.xlabel("Date")
plt.ylabel("Close")
plt.plot(data["Close"])
plt.show()
Microsoft Stock Price Prediction DataVisualization
寻找数据之间的相互关系
现在让我们来看看数据集特征之间的相关性:
print(data.corr())
sns.heatmap(data.corr(),cmap="Greens")
plt.show()
Microsoft Stock Price Prediction correlation
将数据分为训练和测试数据
我现在准备机器学习模型的数据。在这个阶段，我将把最重要的特征添加到 x，把目标列添加到 y，然后把数据集分成训练集和测试集:
x = data[["Open", "High", "Low"]]
y = data["Close"]
x = x.to_numpy()
y = y.to_numpy()
y = y.reshape(-1, 1)
from sklearn.model_selection import train_test_split
xtrain, xtest, ytrain, ytest = train_test_split(x, y, test_size=0.2, random_state=42)
应用机器学习模型
现在，让我们使用决策树回归算法来训练 Microsoft 股票价格预测模型，并查看未来 5 天的预计股票价格:
from sklearn.tree import DecisionTreeRegressor
model = DecisionTreeRegressor()
model.fit(xtrain, ytrain)
ypred = model.predict(xtest)
data = pd.DataFrame(data={"Predicted Rate": ypred})
print(data.head())
Microsoft Stock Price Prediction Predictions
因此，使用 Python 编程语言，您可以使用机器学习来预测微软股票价值。由于 Windows 11 的推出指日可待，微软再次吸引了全球的兴趣。
因此，预测微软的股价是一个美妙的时刻，因为它受到了很多关注。
结论
恭喜你！你刚刚学会了如何预测微软的股票价格。希望你喜欢它！😇
喜欢这个教程吗？无论如何，我建议你看一下下面提到的教程:
感谢您抽出时间！希望你学到了新的东西！！😄
最小堆数据结构 Python 中的完整实现
在本文中，我们将了解更多关于最小堆(Python 中称为堆队列)的知识。我们已经学习了 python 中的堆及其库函数(在 heapq 模块中)。我们现在将学习最小堆及其实现，然后看看自己实现heapify、heappush和heappop函数的 Python 代码。让我们快速回顾一下。
什么是 Min 堆？
最小堆是完全二叉树(完全二叉树是完全填充的树，除了最深/最后一级中最右边的节点之外)，其中每个节点小于或等于其所有子节点。因此堆的根节点是最小的元素。最小堆数据结构通常用于表示优先级队列。
Min Heap Example
堆在数组中是如何表示的？
我们已经看到了堆是如何在内存中以数组的形式表示的，这只是一个简单的提醒:
- 根元素将位于数组的第零个位置，即 Heap[0]。
- 对于任何其他节点，比如说 Heap[i]，我们有以下内容:
- 父节点由下式给出:Heap[(i -1) / 2]
- 左边的子节点由下式给出:Heap[(2 * i) + 1]
- 右边的子节点由下式给出:Heap[(2 * i) + 2]
Min Heap Python
理解在实现 Min 堆中使用的函数
1. min-heapify 功能
此函数使一个节点及其所有后代(子节点及其子节点)遵循 heap 属性。它通过交换节点来重新排列它们，从而使给定的堆成为其子树中最小的节点，遵循 heap 属性。
该函数首先在给定节点及其子节点中找到具有最小值的节点。然后，它将给定的节点(比如 I)与找到的最小值节点(比如 j)交换，然后对节点 j 调用 min-heapify 函数(递归)，以确保分配给节点 j 的新值不会破坏其子树中的堆属性。
由于最多要遍历树的深度，所以它的时间复杂度是 O(d)，其中 d 是深度，或者就节点数而言，O(log n)，n 是堆中的元素数。
2.构建堆函数
这个函数从一个任意列表(或任何其他可迭代的列表)构建一个堆，也就是说，它获取列表并重新排列每个元素，以满足 heap 属性。它可以简单地通过对每个节点重复应用 min-heapify 来实现。这个函数的时间复杂度为 O(n ),其中 n 是堆中元素的数量。
3.帮助功能
这个函数弹出堆的最小值(根元素)。
这实际上是通过用最后一个节点交换根节点并删除现在的最后一个节点(包含最小值),然后为根节点调用 min-heapify 来完成的，以便在由于交换而改变之后保持堆属性。
因为我们只需要处理后代，所以时间复杂度是 O(log n)，其中 n 是元素的数量，或者是 O(h)，其中 h 是 log n 的树的高度，因为它是一个完整的树。
4. heappush 函数
该函数将一个新元素推入堆中，并将其排列到正确的位置，同时保持堆属性。
这实际上是通过在堆的末尾添加一个新节点来实现的。现在，为了维护堆属性，我们从最后一个节点向上遍历(并在需要的地方交换)以修复可能被违反的堆属性。
与 heappop 类似，这里的时间复杂度是 O(log n ),因为我们只需要遍历子树的高度。
5.提取最小功能
这个函数从堆中返回优先级最高的元素(根元素)。因为我们只需要返回根的值，并且不对堆做任何改变，并且根是在 O(1)时间内可访问的，因此该函数的时间复杂度是 O(1)。
完成 Min 堆数据结构的 Python 实现
下面是用 python 实现最小堆的完整程序。
import sys
#defining a class min_heap for the heap data structure
class min_heap:
def __init__(self, sizelimit):
self.sizelimit = sizelimit
self.cur_size = 0
self.Heap = [0]*(self.sizelimit + 1)
self.Heap[0] = sys.maxsize * -1
self.root = 1
# helper function to swap the two given nodes of the heap
# this function will be needed for heapify and insertion to swap nodes not in order
def swapnodes(self, node1, node2):
self.Heap[node1], self.Heap[node2] = self.Heap[node2], self.Heap[node1]
# THE MIN_HEAPIFY FUNCTION
def min_heapify(self, i):
# If the node is a not a leaf node and is greater than any of its child
if not (i >= (self.cur_size//2) and i <= self.cur_size):
if (self.Heap[i] > self.Heap[2 * i] or self.Heap[i] > self.Heap[(2 * i) + 1]):
if self.Heap[2 * i] < self.Heap[(2 * i) + 1]:
# Swap the node with the left child and then call the min_heapify function on it
self.swapnodes(i, 2 * i)
self.min_heapify(2 * i)
else:
# Swap the node with right child and then call the min_heapify function on it
self.swapnodes(i, (2 * i) + 1)
self.min_heapify((2 * i) + 1)
# THE HEAPPUSH FUNCTION
def heappush(self, element):
if self.cur_size >= self.sizelimit :
return
self.cur_size+= 1
self.Heap[self.cur_size] = element
current = self.cur_size
while self.Heap[current] < self.Heap[current//2]:
self.swapnodes(current, current//2)
current = current//2
# THE HEAPPOP FUNCTION
def heappop(self):
last = self.Heap[self.root]
self.Heap[self.root] = self.Heap[self.cur_size]
self.cur_size -= 1
self.min_heapify(self.root)
return last
# THE BUILD_HEAP FUNCTION
def build_heap(self):
for i in range(self.cur_size//2, 0, -1):
self.min_heapify(i)
# helper function to print the heap
def print_heap(self):
for i in range(1, (self.cur_size//2)+1):
print("Parent Node is "+ str(self.Heap[i])+" Left Child is "+ str(self.Heap[2 * i]) + " Right Child is "+ str(self.Heap[2 * i + 1]))
# Driver Code
minHeap = min_heap(10)
minHeap.heappush(15)
minHeap.heappush(7)
minHeap.heappush(9)
minHeap.heappush(4)
minHeap.heappush(13)
minHeap.print_heap()
输出:
Parent Node is 4 Left Child is 7 Right Child is 9
Parent Node is 7 Left Child is 15 Right Child is 13
结论
在本文中，我们学习了最小堆。我们研究了heapify、heappush和heappop的函数是如何工作的。我们进一步用 python 从头开始实现了 min heap 数据结构。请继续关注更多内容丰富的文章。
快乐学习！
在 Python 中查找缺失和重复的元素[简单的一步一步]
原文：https://www.askpython.com/python/examples/missing-and-repeating-elements
嘿伙计们！因此，在本教程中，我们将理解这个简单的问题，即在一系列数字中寻找缺失和重复的元素。让我们通过一个例子来理解这个问题，考虑下面给出的 n = 6 的数字列表。
| one | Two | four | five | five | six |
缺失的数字是 1，2，3…中不存在的数字。n，重复的数字是在元素中出现两次的数字。
在上面提到的例子中，缺失的数字将是 3，重复的数字将是 5。实际结果应该是这样的:1 2 3 4 5 6 没有重复和遗漏的数字。
也读作: Python 列表 vs 数组
手动查找缺失和重复的元素
现在，手动方法是遍历列表一次，并检查每个数字的计数。
如果任何数字的计数等于 2*n，那么我们找到重复的数字，然后遍历元素检查每个数字的出现:1、2、3 等等。
如果这些数字中的任何一个都不存在，那么将该数字作为缺失的数字返回。
这种方法的问题是这种方法很慢，对于一个简单的问题引入了太多的步骤，并且可以用一种更好的方式来完成。
寻找缺失和重复元素的更好方法
因此，我们将创建一个额外的数组，它将考虑一个元素是否被访问。数组的大小与 n 的值相同。
最初，所有的值都等于 0(不可见)，当一个元素出现在数组中时，它在最终数组中的值被设置为 1(可见)。
这一直持续到数组的末尾。我们必须计算两件事:重复的数字和缺失的数字。
如果在任何时候，其值被设置的数字已经被设置，那么这意味着该数字是重复的数字。
现在，为了计算丢失的数字，我们将最后一次遍历最终数组，并检查最终数组中哪个数字的值仍然是 0。这意味着这个数字从未出现过，因此它是数组中缺失的数字。
我们将以包含两个值的列表的形式返回这两个值:第一个是重复的数字，第二个是缺失的数字。
用 python 实现
我希望你清楚这一点。现在让我们看一下查找缺失和重复元素的代码实现，以及代码的示例输出。
def find_miss_repeat(arr,n):
final_array = [0 for i in range(n)]
l = [0,0]
for i in arr:
if(final_array[i-1]==1):
l[0] = i
else:
final_array[i-1] = 1
for i in range(len(final_array)):
if(final_array[i]==0):
l[1] = i+1
return l
x = find_miss_repeat([1,2,4,5,5,6],6)
print("Repeating Number: ",x[0])
print("Missing Number: ",x[1])
代码的输出如下所示。
Repeating Number: 5
Missing Number: 3
结论
我希望你清楚这个概念。你可以用简单和快速的方法自己尝试一下。同样的逻辑也适用于所有的编程语言。
感谢您阅读教程！编码快乐！😇
Python 中的 mmap 函数——快速参考
Python 中的文件 I/O 有很多方法，mmap 是最酷但很少使用的方法。在本教程中，我们将学习 Python 中的 mmap 函数，还将学习内存映射，这是 mmap 函数的基本概念。
什么是内存映射？
内存映射是一个过程，通过该过程，机器级结构被用来从磁盘直接映射文件以供程序使用。它将磁盘中的整个文件映射到计算机程序地址空间中的一系列地址。该程序可以像访问随机存储器中的数据一样访问磁盘上的文件。
计算机中的内存管理
为了清楚地理解内存映射和 mmap 工作背后的过程，让我们简单地了解一下计算机内存的类型。
- 物理内存:是随机存取存储器(RAM)，属于易失性内存。当程序处于活动状态时，它可供程序使用。
- 虚拟内存:如果我们有一台 64 位的机器，我们可以访问多达 170 亿千兆字节的数据。但实际上，我们的个人电脑的物理内存最大为 8 或 16 千兆字节。如果我们运行较大的程序，计算机将物理内存映射到其虚拟空间，并使用称为交换空间的部分存储磁盘来补偿较少的内存，即使文件太大，我们也不必担心文件的大小。在使用期间，不同的分页技术用于将数据从磁盘交换到内存。
- 共享内存:在分页和虚拟内存等技术的帮助下，多个程序可以使用单个物理内存同时运行，即使它的容量很低。没有被使用的数据被送到交换内存，要被使用的数据被复制到主内存，这样所有的程序都工作了。
mmap 函数使用虚拟内存的概念，让程序看起来好像有一个大文件被加载到了主存中。
但实际上，文件只存在于磁盘上。操作系统只是将文件的地址映射到程序的地址空间，这样程序就可以访问该文件。
Python 中如何使用 mmap 函数？
我们可以使用 mmap 模块进行文件 I/O，而不是简单的文件操作。让我们借助下面的例子来理解如何使用 mmap。
#import module
import mmap
#define filepath
filepath="/home/aditya1117/askpython/sample.txt"
#create file object using open function call
file_object= open(filepath,mode="r",encoding="utf8")
#create an mmap object using mmap function call
mmap_object= mmap.mmap(file_object.fileno(),length=0,access=mmap.ACCESS_READ,offset=0)
#read data from mmap object
txt=mmap_object.read()
#print the data
print("Data read from file in byte format is:")
print(txt)
print("Text data is:")
print(txt.decode())
输出:
Data read from file in byte format is:
b'This is a sample file for mmap tutorial.\n'
Text data is:
This is a sample file for mmap tutorial.
在上面的例子中，
- 我们首先导入mmap 模块
- 然后定义文件在磁盘中的文件路径
- 然后，我们使用 open()系统调用创建 file_object
- 在获得文件对象后，我们使用 mmap 函数创建文件到程序地址空间的内存映射
- 然后我们从 mmap 对象中读取数据
- 并打印数据。
mmap 功能描述
mmap_object= mmap.mmap(file_object.fileno(),length=0,access=mmap.ACCESS_READ,offset=0)
mmap 需要一个文件描述符作为第一个参数。
参数 length 以字节为单位获取要映射的内存大小，参数 access 通知内核程序将如何访问内存。
参数 offset 指示程序在 offset 中指定的特定字节之后创建文件的内存映射。
- 第一个参数的文件描述符由 file 对象的 fileno()方法提供。
- 如果我们希望系统自动选择足够的内存来映射文件，那么可以将第二个参数中的长度指定为 0。
- access 参数有许多选项。 ACCESS_READ 允许用户程序仅从映射存储器中读取。访问 _ 复制和访问 _ 写入提供写入模式访问。在 ACCESS_WRITE 模式下，程序可以更改映射内存和文件，但在 ACCESS_COPY 模式下，仅映射内存被更改。
- 当我们希望从起始地址映射文件时，offset 参数通常被指定为 0。
如何将数据写入内存映射文件？
要将一些数据写入内存映射文件，我们可以使用 ACCESS 参数中的 ACCESS_WRITE 选项，并使用 mmap_object.write() 函数，通过在 r+ 模式下打开文件，在创建文件对象后写入文件。
这里我们必须注意到，mmap 不允许映射空文件。这是因为空文件不需要内存映射，因为它只是一个内存缓冲区。
如果 我们将使用“w”模式打开一个文件，mmap 将导致 ValueError。
#import module
import mmap
#define filepath
filepath="/home/aditya1117/askpython/sampleoutput.txt"
#create file object using open function call
file_object= open(filepath,mode="r+",encoding="utf8")
print("Initial data in the file is:")
print(file_object.read())
#create an mmap object using mmap function call
mmap_object= mmap.mmap(file_object.fileno(),length=0,access=mmap.ACCESS_WRITE,offset=0 )
#write something into file
text="Aditya is writing this text to file "
mmap_object.write(bytes(text,encoding="utf8"))
# read data from file
nfile_object= open(filepath,mode="r+",encoding="utf8")
print("Modified data from file is:")
print(nfile_object.read())
输出:
Initial data in the file is:
This is a sample file for mmap tutorial in python.
Modified data from file is:
Aditya is writing this text to file al in python.
关于上面的例子，我们必须记住的重要一点是，在写入 mmap 之前，输入应该被转换成字节。
此外，mmap 从文件的第一个地址开始写入数据，并覆盖初始数据。如果我们必须保存以前的数据，我们可以通过在 mmap 函数调用中指定适当的偏移量来实现。
如何使用 mmap 访问文件的某一部分？
我们可以使用 mmap 对象直接访问文件的一部分。mmap 对象可以被切片，就像我们在 python 列表上使用切片一样。
mmap 对象显示了字符串的行为，在字符串上进行的许多操作都可以应用到 mmap 对象上。
当我们在 Python 列表上使用切片时，mmap 对象可以被切片。假设我们想读取文件的第 10 到 99 个字符。我们可以这样做，如下例所示。
#import module
import mmap
#define filepath
filepath="/home/aditya1117/askpython/sample.txt"
#create file object using open function call
file_object= open(filepath,mode="r",encoding="utf8")
#create an mmap object using mmap function call
mmap_object= mmap.mmap(file_object.fileno(),length=0,access=mmap.ACCESS_READ,offset=0 )
print("Complete data in byte format is:")
print(mmap_object.read())
print("Data from 9th to 97th character is:")
#print 10th to 99th character
print(mmap_object[9:98])
输出:
Complete data in byte format is:
b'We can access a part of file directly using mmap objects. mmap objects can be sliced as we use slicing on python lists.mmap objects show the behavior of strings and many operations which are done on strings can be applied to mmap objects.mmap objects can be sliced as we use lists in python. Suppose we want to read from the 10th to 99th character of the file. We can do so as shown in the following example.\n'
Data from 9th to 97th character is:
b'cess a part of file directly using mmap objects. mmap objects can be sliced as we use sli'
Python 中为什么要用 mmap？
简单的读/写操作在执行过程中会产生许多系统调用，这会导致在该过程中在不同的缓冲区中多次复制数据。
使用 mmap 在性能方面为我们提供了显著的改进，因为它跳过了那些函数调用和缓冲操作，特别是在需要大量文件 I/O 的程序中。
结论
在本教程中，首先，我们已经看到了什么是内存映射。然后我们看了内存管理技术。然后我们通过各种例子看到了如何在 Python 中使用 mmap，也看到了函数工作背后的一些技术方面。快乐学习！
ModuleNotFoundError:没有名为 openpyxl 的模块
原文：https://www.askpython.com/python/modulenotfounderror-no-module-named-openpyxl
您是否陷入了“ModuleNotFoundError:没有名为 openpyxl 的模块”错误？初学 Python 的人在开始使用 openpyxl 库时经常会遇到困难。这是一个全行业的问题，会出现在许多从 Python 开始的程序员的屏幕上。
这通常是由于 Python 和 Openpyxl 之间的版本错误或不正确的安装造成的。找不到正确的解决方案可能是一个令人头疼的问题，这就是为什么在本文中，我们将讨论编码人员在使用 openpyxl 时遇到的最常见的错误，并针对每一个错误提出解决方案。
什么是 openpyxl？
缺少读取 Open XML 格式的 Python 库产生了对 openpyxl 的需求，openpyxl 是当前读取和写入 excel 格式文件的行业标准 Python 库。
支持的格式有:xlsx/xlsm/xltx/xltm。
大多数情况下，openpyxl 遇到的错误是由于安装不正确造成的。这些错误可以通过简单的重新安装来解决。我们来看看安装 openpyxl 的正确方法。
通过包管理器安装 openpyxl
通过使用画中画
安装任何 Python 库最简单的方法就是使用 pip 。Pip 是一个用 Python 编写的系统软件，它通过一个开源库来安装和管理你的 Python 库。通过 pip 安装需要了解您的 Python 版本。
如果您使用 Python2 ，安装任何库的语法是:
pip install 'package_name'
只使用“pip”就可以安装 Python2 版本的任何 Python 包。
要为 Python3 安装它，请编写:
pip3 install 'x'
注意:在 pip 的较新版本中，主要是 3.0 以上的版本，当只键入“pip”时，pip 默认安装 Python3 的包。在最新版本的 Python 中可以发现这种异常，如果您遇到这种情况，建议您降级您的 Python 版本。
如果您的系统中有多个 Python 版本，并且您不确定 vanilla pip3 是否会获取正确的版本，您可以使用以下语法:
python3 -m pip install --user xlsxwriter
通过使用 Conda
许多编码人员更喜欢使用 Conda 而不是 pip ，因为它的虚拟环境特性。如果要使用 Conda 安装 openpyxl，请键入以下语法:
conda install -c anaconda openpyxl
或
conda install openpyxl
第二种语法主要针对最新的 Conda 版本(Conda 4.7.6 或更高版本)
根据您的操作系统安装
让我们看看基于您使用的操作系统的不同安装方式！
1.Windows 操作系统
如果您使用的是 windows，则需要以下软件包来读写 excel 文件。要安装它们，请键入以下语法:
pip install openpyxl
pip install --user xlsxwriter
pip install xlrd==1.2.0
2.人的本质
Linux 发行版更适合 Python，但是由于系统错误或安装不当，您可能仍然会遇到一些错误。在 Ubuntu 中安装 openpyxl 的安全而正确的方法是执行以下操作。
在您的终端中键入以下语法:
对于 Python2:
sudo apt-get install python-openpyxl
对于 Python3:
sudo apt-get install python3-openpyxl
上面的案例类似于上面的例子。很多时候，不正确的安装是由于将 Python2 的 openpyxl 安装到 Python3 的系统中造成的。
了解您的 python 版本可以解决大多数问题，如果问题仍然存在，那么降级您的 Python 版本并重新安装软件包是另一个选择。
脚本路径错误
很多时候，即使安装正确，openpyxl 也可能抛出“modulenotfounderror”。使用什么安装管理器并不重要，因为软件包可以正确安装，但是软件包管理器会将它安装在其他目录中。这主要有几个原因:
- 您的 Python 脚本保存在不同的目录中，您的包管理器将它们安装在不同的目录中。
- 最近的更新可能已经更改了目录的名称或路径
- 手动安装可能会创建多个脚本文件夹
- 您的系统无法识别正确的脚本目录。
要解决此问题，请在终端中使用以下语法:
import sys
sys.append(full path to the site-package directory)
注意:上面的代码重定向 Python，从给定的路径目录中搜索导入包。这不是一个永久的解决办法，而是一个转变的方法。
彻底根除这个问题是一个漫长的过程，因为它需要识别所有的脚本目录，并将它们添加到“path”(安装软件包的脚本目录的路径)。为了避免这样的错误，我们识别并记住我们的脚本安装在哪里是很重要的。知道哪里发生了位移可以解决一半的问题，另一半可以通过安装与您的 python 版本兼容的包来解决。
结论
在本文中，我们了解了人们在使用 openpyxl 时遇到的错误，以及解决这些错误的不同方法。这些方法不仅适用于 openpyxl，还适用于许多显示“ filenotfounderror ”的 python 库包。大多数情况下，错误是由于不兼容的版本、错误的安装或安装在错误的目录中而发生的。
Python 中的蒙特卡洛
原文：https://www.askpython.com/python/examples/monte-carlo-in-python
今天我们来看看 Python 中一个非常著名的方法，叫做蒙特卡罗，它可以用来解决任何有概率解释的问题。让我们从一些有趣的历史开始。
一点蒙特卡洛历史
它被用来解决复杂的数值问题，如布丰针问题(https://en.wikipedia.org/wiki/Buffon%27s_needle_problem):
假设我们有一个由平行木条制成的地板，每条木条宽度相同，我们将一根针放在地板上。针穿过两条带之间的线的概率是多少？
自 20 世纪 40 年代以来，它已被用于:
- 在洛斯阿拉莫斯国家实验室研究核武器项目的中子扩散，ENIAC 被用于执行 M-C 模拟。
- 也被用于氢弹的研发
- 在流体力学中，求解复杂的微分方程(非线性抛物型偏微分方程)
- 为了估计粒子传输能量
- 高级信号处理和贝叶斯推理
- 关于遗传类型突变选择学习机(当今生物信息学领域的早期介绍)等。
用 Python 实现蒙特卡罗
蒙特卡洛允许我们模拟看似随机的事件，而评估风险(当然，还有其他结果)。它被用来评估某一交易策略的风险。
在本教程中，我们将模拟一个赌场(因为我们无法模拟核武器试验😀)
一般来说，问题越复杂，你需要的伪随机数值变量就越多。
打开您的谷歌合作实验室，并连接到运行时。
1.创建赌场轮盘的基本滚动
import numpy as np
import pandas as pd
- 然后，我们将我们的“掷骰子”定义为一个从 1 到 100 的数字，让我们将它设置为客户获胜的几率为 49-51 。
- 这意味着对于掷骰 1-50 和正好 100，庄家(/赌场)赢。
- 对于掷 51-99，玩家获胜。
这似乎是一个公平的获胜机会，大多数玩家很可能会接受。
让我们用 Python 来模拟一下:
def casino_roll():
roll = np.random.randint(1,100)
if roll <= 50 or roll == 100:
print('rolled %d. you lose. House wins! Play again?!'%roll)
elif 50 < roll < 100:
print('you win! On a roll !')
return True
所以，现在我们可以调用 casino_roll()，你可以看到你得到了什么。我试了 4 次，失败了 3 次。
2.成为经销商
接下来，让我们把一些钱投入赌注。因此，我们将创建庄家，他接受赌注，并且:
- 如果赢了，他就奖励玩家。
- 如果有损失，他会把钱装进口袋。
def deal_bet(funds,initial_bet,bet_count):
bet = 0
funds_total = 0
while bet < bet_count:
if casino_roll():
funds += initial_bet
else:
funds -= initial_bet
bet += 1
print('Funds : %d'%funds)
funds_total += funds
print('average win/loss : %f'%(10000-funds_total/bet_count))
观察我找到了总资金，然后找到了平均输赢。如果是肯定的，那就是赢了。如果是负数，那就是亏损。
3.100 卢比的赌注。100
因此，运行 100 次下注，每次下注 100 卢比，我们得到:
deal_bet(10000,100,100)
Funds In Casino Bet Monte Carlo
在得到这个负值之前，我不得不运行这个程序 5 次，但是观察有多少值远远超过 10000，但是玩家总体上还是赔钱了。
这只是为了表明，我们认为有利可图的交易可能并不总是如此。
4.制造更多玩家
我们可以让 100 名玩家下同样的赌注:
x=0
while x<100:
deal_bet(10000,100,100)
x+=1
在 deal_bet ()中注释掉打印(资金)报表。
所以，现在我们可以看到每个玩家的所有利润和损失:
Average Wins Losses Monte Carlo
5.用 Matplotlib 绘制平均值
让我们在这里用 matplotlib 绘制数据:
return (10000-funds_total/bet_count)
将上述行添加到 deal_bet ()函数的末尾。
然后我们修改:
x=0
avg_list=[]
while x<100:
avg_list.append(deal_bet(10000,100,100))
x+=1
最后，我们可以把它画出来:
import matplotlib.pyplot as plt
avg_list = np.array(avg_list).astype(int)
plt.figure(figsize=(20,20))
plt.plot(avg_list)
plt.axhline(np.array(avg_list).mean(), color='k', linestyle='dashed', linewidth=1)
Plot Of Avg Wins And Losses – Monte Carlo
结论
今天到此为止。我希望这个例子能帮助你很好地理解 Python 中的蒙特卡罗模拟。
你现在可以为一个激进的玩家这样做。也许，他每赢一次，就赌双倍的钱。想好多种场景，自己修改下注函数。
如果你在我的 github 上错过了什么，你会发现更多的场景和完整的代码:
https://github.com/arkaprabha-majumdar/monte-carlo
下次见！！
蒙特卡罗模拟在 python 中寻找硬币投掷的概率
原文：https://www.askpython.com/python/examples/monte-carlo-simulation
在本文中，我们将学习如何用 Python 对一个简单的随机实验进行蒙特卡罗模拟。
注:蒙特卡罗模拟是一个数学上复杂的领域。所以我们还没有进入 MC 的细节。相反，我们使用了一些直觉和例子来理解蒙特卡罗模拟的需要和实现，使没有多少数学背景的人更容易在没有太多数学知识的情况下体验概率。
Python 中的蒙特卡罗模拟
首先，我们将使用随机库模拟掷硬币实验，并建立对蒙特卡洛实验的直觉。
1.随机模块
首先我们导入随机模块。
# Import the random module
import random
我们将广泛使用随机模块中的统一函数。这个函数给出了一个介于用户提供的上限和下限之间的数字。上下界之间每个数字出现的概率是相等的。
# Generates uniform random number between 4 and 6
random.uniform(4, 6)
输出:
5.096077749225385
现在我们用这个统一的函数模拟一个简单的抛硬币。我们已经说过，上下界之间每个数字出现的机会是相等的。
所以如果我们取一个介于 0 和 1 之间的统一值，那么一个数大于 0.5 和小于 0.5 的几率是相等的。我们利用这一特点。我们从 0 到 1 取一个随机数。如果数字大于 0.5，结果是正面，否则是反面。
a = random.uniform(0, 1)
if a>0.5:
print("Head")
else:
print("Tail")
输出:
Head
2.定义一个函数来模拟一个无偏的硬币投掷
现在让我们用上一节的知识来写一个函数来模拟一次无偏的掷硬币。写一个函数会让我们的代码更易读，更模块化。
def unbiased_coin_toss():
# Generate a random number from 0 to 1
x = random.uniform(0, 1)
# Probability that the number falls between 0 and 0.5 is 1/2
if x > 0.5:
# Heads for True
return True
else:
# Tails for False
return False
让我们测试函数的结果。
for i in range(10):
print(unbiased_coin_toss())
输出:
False
True
False
False
False
False
True
False
False
False
3.投掷硬币几次
既然我们已经模拟了一次真正的抛硬币。让我们测试一系列随机掷硬币中正面朝上的概率。实际上，我们已经定义了一个函数，它给出了每个调用的正面或反面。
现在投掷硬币几次，并将结果存储在一个列表中。人头的概率是从列表中计算出来的。
N=10
# List to store the result(True/False)
results = []
# Toss the coin 10 times and store that in a list
for i in range(N):
result = unbiased_coin_toss()
results.append(result)
# Find the total number of heads
n_heads = sum(results)
# Find probability of heads in the experiment
p_heads = n_heads/N
print("Probability is {:.1f}".format(p_heads))
输出:
Probability is 0.9
哎呀！！这似乎不太管用。你可以多次运行这个程序块，但是你会发现在我们的实验中正面的概率与预期的概率 0.5 相差很大。
我们的模拟有问题吗？
说实话，既有也有。你可能会认为，我们之前定义的函数并不完美，这导致了我们得到这些不完美的结果。实际问题在于我们如何模拟这个过程。
根据大数定律，当实验次数较多时，实验概率变得接近实际/预期概率。
上面的解释似乎有点怪异。我们不会用数学证明或假设来验证这一点，而是将我们的想法建立在简单的直觉上。
假设你的工作是寻找印度小麦消费的概率。在理想的情况下，你需要去每个人那里，问他们是否食用小麦。小麦消费的概率将是:
但是询问 13 亿人是一项繁琐的任务。所以你找一百个代表全国人口的人，在他们身上做实验。寻找概率的任务变得容易多了。但是真的吗？
如果你让更多的人来自像旁遮普这样的小麦消费州，让更少的人来自像西孟加拉邦这样的小麦消费较少的州，或者相反，你可能会发现你的实验概率有相当大的偏差。
这是因为你在实验中随机选择的 100 个人不能恰当地代表全部人口。所以结果总是容易出错。
同样的想法也适用于我们的掷硬币游戏。我们没有进行足够多的掷硬币，仓促达成了一个解决方案。让我们解决这个问题！！！
在 Python 中执行蒙特卡罗模拟
蒙特卡罗模拟是解决这个问题的最好方法之一。
天真地说，在蒙特卡罗模拟中，您从不同的输入值和结果的平均值(期望值)开始的值中获得不同的实验结果。
得到的平均值是我们在这里寻找的无错误(不太容易出错)的答案。
prob = []
# Make 1000 experiments
for i in range(1000):
# Each experiment have 10 coin tosses
N = 10
results = []
# Toss the coin 10 times and store that in a list
for i in range(N):
result = unbiased_coin_toss()
results.append(result)
n_heads = sum(results)
p_heads = n_heads/N
prob.append(p_heads)
# average the probability of heads over 1000 experiments
p_heads_MC = sum(prob)/1000
print("Probability is {:.3f}".format(p_heads_MC))
输出:
Probability is 0.502
每次运行这段代码，我们都会得到一个非常接近期望值的概率值。我们通过增加实验次数(1000 次)来提高精确度。您可以增加这个数字，并亲自测试结果。
结论
关于抛硬币的蒙特卡洛模拟，我们已经到了这篇文章的结尾。你可以试着在一个有偏向的硬币上用蒙特卡洛模拟，正面的概率，不是 0.5。其实你可以试试蒙特卡罗模拟，从其他随机实验中得到结果。
电影推荐系统–入门
原文：https://www.askpython.com/python/examples/movie-recommendation-system
推荐系统是一种旨在提高搜索结果质量并提供/建议与用户搜索历史更相关的事物的系统。它们有助于理解用户可能喜欢什么，在今天的教程中，我们将构建一个应用程序，向用户建议观看哪部电影。
我们开始吧！
在本教程中，我们将使用 TMDB 5000 电影数据集，可以在这里找到。我们将使用以下代码加载网站上提到的两个数据集。我们还将在两个数据集的“id”列的基础上连接这两个数据集。
import pandas as pd
import numpy as np
df1=pd.read_csv('tmdb_5000_credits.csv')
df2=pd.read_csv('tmdb_5000_movies.csv')
df1.columns = ['id','tittle','cast','crew']
df2= df2.merge(df1,on='id')
接下来，我们将决定一个衡量标准来判断哪部电影比其他的好。一种方法是，我们可以直接使用数据集中给出的电影平均评级。但不会因为某部电影的投票人数不一致而公平。
因此，我们将使用IMDB's weighted rating (wr)，其数学描述如下
Movie Recommendation System Score Formula
在上面的公式中，
v–票数
m–需要列出的最低票数
R–电影的平均评分
C–平均票数
让我们使用下面的代码来计算qualified部电影的价值，方法是计算平均票数，然后只考虑投票人数比其他电影多 90%的电影来计算这部电影所需的最低票数。
C= df2['vote_average'].mean()
print("Mean Average Voting : ",C)
m= df2['vote_count'].quantile(0.9)
print("\nTaking the movies which have 90% more voters than the other movies")
print("Minimum votes required : ",m)
现在，让我们使用下面的代码片段筛选出最受欢迎和推荐的电影。
q_movies = df2.copy().loc[df2['vote_count'] >= m]
但是我们还没有计算出每部合格电影的标准。我们将定义一个函数weighted_rating，其中我们定义了一个new feature score，它将帮助我们使用下面的代码计算所有合格电影的值。
def weighted_rating(x, m=m, C=C):
v = x['vote_count']
R = x['vote_average']
return (v/(v+m) * R) + (m/(m+v) * C)
q_movies['score'] = q_movies.apply(weighted_rating, axis=1)
最后，让我们根据分数栏对整个数据帧进行排序，并查看所有其他电影中最值得推荐的电影。
q_movies = q_movies.sort_values('score', ascending=False)
让我们尝试使用下面的代码来可视化排序后的数据集，并了解整个数据集中最受欢迎的电影。
pop= df2.sort_values('popularity', ascending=False)
import matplotlib.pyplot as plt
plt.figure(figsize=(12,4),facecolor="w")
plt.barh(pop['title'].head(10),pop['popularity'].head(10),
align='center',color='pink')
plt.gca().invert_yaxis()
plt.xlabel("Popularity Metric")
plt.title("Name of the most Popular Movies")
plt.show()
看剧情看起来多好看，我们可以看到在排名前 10 的电影中，Minions是最受欢迎和推荐的电影。
Movie Recommendation System Plot
恭喜你！你用 python 编程语言搭建了一个成功的电影推荐系统！
另请参阅:
Python: Moviepy 模块
你好，程序员朋友！今天在本教程中，我们将学习一种非常有趣的用 Moviepy 模块编辑和加载视频的方法。
Moviepy 模块简介
MoviePy模块用于从您的系统加载、下载和编辑视频，其中编辑包括裁剪、旋转、修剪成更小的剪辑和其他视频效果。
它还可以用来编辑视频中的音频。它还可以根据您的喜好在视频和其他文本项目上添加水印。
很酷吧？！所以现在就来学习实现吧！
实现 Moviepy
要实现 moviepy，首先我们需要使用pip install命令确保我们的系统中安装了 moviepy。
在您成功安装了 moviepy 模块之后，我们就可以开始实现该模块了！在接下来的教程中，我将使用一段视频，可以在这里找到。你可以选择任何你喜欢的视频。
但是在进一步处理之前，我们需要导入 moviepy 模块，以使它可以按以下方式进行编辑。
from moviepy.editor import *
1.加载视频
为了加载视频，我们使用了VideoFileClip函数，并将视频文件的路径作为参数传递。
我用的是mp4格式，你可以选择你喜欢的格式，因为 moviepy 模块支持多种视频格式。
我们将把函数的输出存储在一个变量中，并利用ipython_display函数来查看录制的视频。
您可以将括号留空，但是为了更好的可视化，我提供了一个width属性。
整个过程的代码和输出如下所示。这个视频完全可以播放。
from moviepy.editor import *
v1 = VideoFileClip("video.mp4")
v1.ipython_display(width = 400)
Output Loading Video Moviepy
2.编辑视频
现在我们知道了如何成功加载视频，让我们开始编辑视频。
moviepy 模块的所有功能都超出了单个教程的范围，但是在本教程结束时，您将会学到一些技巧。
我们将对上面代码中加载的视频执行以下操作:
- 将视频剪辑到 15 秒
- 将视频旋转 45 度
- 降低音频的音量
让我们一个接一个地学习如何做每一个编辑！
首先，我们使用函数subclip进行修剪，该函数以秒为单位计算视频的开始和结束时间。
我们将视频调整到 15 秒，所以我们提供开始为 0，结束为 15。完成同样工作的代码如下所示。
v2 = v2.subclip(0, 15)
接下来，我们将视频旋转到某个角度，这可以通过rotate函数简单地完成，该函数获取旋转的角度。你可以使用这个函数。
我们选择 45 度角，其代码如下所示。
v2 = v2.rotate(45)
最后但同样重要的是，我们将在volumex功能的帮助下设置视频中音频的音量，该功能设置音频所需的最大音量。
相同的代码如下所示。
v2 = v2.volumex(0.3)
现在我们知道了单独的编辑是如何发生的，让我们将它们结合起来，看看视频的输出。
完整的代码和输出如下所示。
from moviepy.editor import *
v2 = VideoFileClip("video.mp4")
v2 = v2.subclip(0, 15)
v2 = v2.rotate(45)
v2 = v2.volumex(0.3)
v2.ipython_display(width = 400)
Output Edited Video Moviepy
结论
恭喜你！您刚刚学会了用简单的 python 代码加载和编辑视频。但这些只是基础，关于 MoviePy 还有很多要学。
敬请关注更多此类教程！编码快乐！
Python 中的多条件 If 语句[解释]
原文：https://www.askpython.com/python/examples/multi-conditional-if-statement
你好，初学者！今天，我们将了解如何在' if 语句中实现多个条件。在本文结束时，您将了解实现 if-else 条件的不同情况。让我们开始吧。
Python 中的 if 语句是什么？
“If”语句是一个条件语句，用于检查特定表达式是否为真。程序控制首先检查用‘if’写的条件，如果条件证明为真，则执行 if 块。否则，程序控制转到 else 块并执行它。
语法:
if(condition) :
code block 1
else :
code block 2
如果满足条件，则执行代码块 1。如果没有，则执行代码块 2。
我们一般都使用基本的 if 语句，即只有一个条件的 if 语句。当我们想要将一个变量与另一个变量进行比较，或者我们想要检查一个变量是否为真时，就会用到这个函数。例如:
num1 = int(input("Enter a number:")
if( num1 % 2 == 0 ):
print("The number is even!")
else:
print("The number is odd!")
输出:
Enter a number: 37
The number is odd!
如何在 if 语句中使用多个条件？
现在，我们将了解如何在 if 语句中使用多个条件。语法和示例解释如下:
语法:
if ((cond1) AND/OR (cond2)) :
code block 1
else :
code block 2
可以在单个 if 语句中使用和或或或这两个来使用多个条件。
1.使用“and”的多个条件
当你希望所有的条件都得到满足时，就使用 AND 条件。看看下面的例子:
age = int (input (" What is your age? "))
exp = int (input (" Enter your work experience in years: "))
if (age > 30 and age < 60) and (exp > 4):
Print (" You are hired! ")
else:
Print (" Sorry! you are not eligible :( ")
上面的代码使用 AND 条件，这意味着每个条件都必须为真。年龄必须在 30 至 60 岁之间，经验应该超过 4 年，然后只有你会被录用。
Output:
What is your age? 32
Enter your work experience in years: 6
You are hired!
What is your age? 28
Enter your work experience in years: 5
Sorry! you are not eligible :(
2.使用“或”的多个条件
当您希望至少满足一个条件时，可以使用 OR 条件。让我们来看一个例子:
num1 = int(input("Enter any number : "))
rem = num1 % 10
if (rem == 0 ) or ( rem == 5 ) :
print( "{} is divisible by 5 ".format(num1))
else :
print(" {} is not divisible by 5".format(num1))
上面的代码检查输入的数字是否能被 5 整除。为此，它首先通过找出除以 10 时的余数(使用模 10)来找出数字的最后一位，如果余数等于 0 或 5，它打印出该数字可被 5 整除。如果不是，它打印出这个数不能被 5 整除。
OUTPUT :
Enter any number : 90
90 is divisible by 5
Enter any number : 27
27 is not divisible by 5
Enter any number : 15
15 is divisible by 5
结论
这就是我们如何在 if 语句中使用多个条件。请尝试不同的 if-else 条件组合，如果有任何问题，请随时提问！
谢谢大家！🙂
多元线性回归:快速介绍
原文：https://www.askpython.com/python/examples/multiple-linear-regression
欢迎来到多元线性回归教程。我们将研究多元线性回归的概念及其在机器学习中的应用。
在我们深入多元线性回归的概念之前，让我给你介绍一下简单线性回归的概念。
什么是简单线性回归？
回归是一种从给定数据预测值的机器学习技术。
例如，考虑一个关于雇员详细信息及其薪水的数据集。
该数据集将包含诸如“经验年数”和“薪水”等属性。这里我们可以用回归来预测一个人大概在行业工作 8 年的工资。
通过简单的线性回归，我们得到数据的最佳拟合线，并基于这条线预测我们的值。这条线的方程式如下:
y = b0 + b1 * x1
在上面的等式中，y 是使用自变量 x1 预测的因变量。这里，b0 和 b1 是常数。
什么是多元线性回归？
多元线性回归是简单线性回归的扩展，其中模型依赖于多个独立变量来获得预测结果。我们的多元线性回归方程如下:
y = b0 + b1 *x1 + b2 * x2 + .... + bn * xn
这里，y 是因变量，x1，x2，..，xn 是我们的独立变量，用于预测 y 的值。b0，b1，…bn 等值充当常数。
建立多元线性回归模型的步骤
在建立模型之前，我们需要执行 5 个步骤。这些步骤解释如下:
第一步:识别变量
在开始构建模型之前，理解因变量和自变量很重要，因为它们是影响结果的主要属性。
如果不了解因变量，你建立的模型将是一种浪费，因此要确保你花足够的时间来正确识别变量。
步骤 2:检查洞穴/假设
需要注意的是，多元线性回归有 5 个假设。这些措施如下:
- 线性
- 同方差性
- 多元正态性
- 误差的独立性
- 缺乏多重共线性
步骤 3:创建虚拟变量
假设，我想检查因变量和自变量之间的关系，虚拟变量出现了。
我们在有分类变量的地方创建虚拟变量。为此，我们将创建一个包含 0 和 1 的列。例如，我们有几个州的名称，而我们的数据集只有两个，即纽约和加利福尼亚。我们将纽约表示为 1，加州表示为 0。这个 0 和 1 是我们的虚拟变量。
步骤 4:避免虚拟变量陷阱
在创建虚拟变量之后，有必要确保您不会陷入虚拟陷阱的场景中。
线性回归中的一个或多个变量预测另一个变量的现象通常称为多重共线性。因此，我们的模型可能无法区分虚拟变量 D1 和 D2 的影响。这种情况是一个虚拟变量陷阱。
这个问题的解决方案可以是省略一个虚拟变量。在上面的纽约和加利福尼亚的例子中，不是有两列，即纽约和加利福尼亚，我们可以在一列中表示为 0 和 1，如下所示。
Example
步骤 5:最后，建立模型
我们有许多独立的输入变量来决定一个输出变量。但是我们需要记住的一个政策是垃圾进-垃圾出。这意味着我们必须只向模型中输入必要的变量，而不是所有的变量。输入所有变量可能会导致模型容易出错。
此外，请记住，当您构建模型时，有必要将模型呈现给用户。解释太多变量相对困难。
建立模型时，有 5 种方法可以遵循。逐步回归技术有:
- 全包
- 反向消除
- 预选
- 双向消除
- 范围比较
详细讨论这些模型超出了本文的范围。然而，我们将在本文中查看一个示例。
在 Python 中实现多元线性回归
让我们考虑一个显示 50 家创业公司利润的数据集。我们将在 matplotlib 库上工作。
到数据集的链接是-https://github.com/content-anu/dataset-multiple-regression
导入数据集
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
dataset = pd.read_csv('50_Startups.csv')
dataset.head()
Output of dataset.head() method
因此，在上面显示的数据集样本中，我们注意到有 3 个独立变量——R&D 支出、管理和营销支出。
它们有助于因变量利润的计算。
数据科学家的角色是分析在这些领域中的哪一个领域的投资会增加公司的利润？
数据预处理
构建特征矩阵和相关向量。
这里，特征矩阵是独立变量矩阵。
X = dataset.iloc[:,:-1].values
y = dataset.iloc[:,4].values
对分类变量进行编码
这个模型中有分类变量。State 是一个分类变量。我们将使用标签编码器。
from sklearn.preprocessing import LabelEncoder, OneHotEncoder
labelEncoder_X = LabelEncoder()
X[:,3] = labelEncoder_X.fit_transform(X[ : , 3])
from sklearn.compose import ColumnTransformer
ct = ColumnTransformer([('encoder', OneHotEncoder(), [3])], remainder='passthrough')
X = np.array(ct.fit_transform(X), dtype=np.float)
我们首先执行了标签编码，因为只有在转换为数字数据后才能执行一次热编码。我们需要数字来创造虚拟变量。
避开虚拟变量陷阱
在下面的代码中，我们从 X 中删除了第一列，但是将所有的行。我们只忽略索引 0。这是为了避免虚拟变量陷阱。
X = X[:, 1:]
拆分测试和训练集
通常，我们会将数据集的 20%视为测试集，80%视为训练集。我们所说的训练集是指，我们根据这些参数训练我们的模型，并在“测试集”上执行测试，并检查我们测试的输出是否与之前数据集中给出的输出相匹配。
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 0)
拟合模型
from sklearn.linear_model import LinearRegression
regressor = LinearRegression()
regressor.fit(X_train, y_train)
上面代码片段的输出将是下面的一行。
Output of the regression fitting
预测测试集结果
我们创建一个包含所有测试集利润预测的向量。然后将预测的利润放入名为 y_pred 的向量中。(包含测试集中所有观察值的预测)。
“预测”方法对测试集进行预测。因此，输入是测试集。predict 的参数必须是数组或稀疏矩阵，因此输入是 X_test。
y_pred = regressor.predict(X_test)
y_test
y-test set
y_pred
y-pred set
到目前为止，模型拟合不一定是数据集的最佳模型。当我们建立模型时，我们使用了所有的独立变量。
但是如果这些自变量中有一些统计意义上的(有很大影响的)因变量呢？
如果我们也有一些根本不显著的变量呢？
因此，我们需要一个独立变量的最佳团队，这样每个独立变量都是强大的，具有统计显著性，并且肯定有影响。
这种影响可以是正的(自变量减少 1 个单位，利润会增加)也可以是负的(自变量增加 1 个单位，利润会减少)。
我们将使用统计模型执行反向消除。但本文不会讨论这个话题。
Python 中多元线性回归的完整代码
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
dataset = pd.read_csv('50_Startups.csv')
dataset.head()
# data preprocessing
X = dataset.iloc[:,:-1].values
y = dataset.iloc[:,4].values
from sklearn.preprocessing import LabelEncoder, OneHotEncoder
labelEncoder_X = LabelEncoder()
X[:,3] = labelEncoder_X.fit_transform(X[ : , 3])
from sklearn.compose import ColumnTransformer
ct = ColumnTransformer([('encoder', OneHotEncoder(), [3])], remainder='passthrough')
X = np.array(ct.fit_transform(X), dtype=np.float)
X = X[:, 1:]
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 0)
# Fitting the model
from sklearn.linear_model import LinearRegression
regressor = LinearRegression()
regressor.fit(X_train, y_train)
# predicting the test set results
y_pred = regressor.predict(X_test)
y_test
y_pred
输出将是如下预测:
结论
简而言之，使用线性回归的优势在于它适用于任何大小的数据集，并提供有关要素相关性的信息。然而，这些模型基于某些被视为缺点的假设。
python 中如何进行乘法运算？
原文：https://www.askpython.com/python/examples/multiplication-in-python
在本文中，我们将看到如何用 python 编写代码来获得作为输入给出的数字或列表元素的乘积。
因此，在 python 中有不同的方法来执行乘法。最简单的一种是使用星号运算符( ***** )。也就是说，您传递两个数字，只需打印 num1 * num2 就会得到想要的输出。
用户输入两个数的 python 乘法运算
1.不使用函数
让我们编写一个简单的脚本来打印两个数字的乘积，而不使用函数。我们将简单地打印结果。
n1 = int(input("Enter a number:")
n2 = int(input("Enter another number:")
res = n1 * n2
print("The product is ", res)
输出将是:
Enter a number: 3
Enter another number: 5
The product is 15
2.有功能的
如果您必须在程序中多次使用乘法，那么您必须创建一个函数，该函数将返回调用时传递给它的数字的乘积。这将降低程序的复杂性并引入可重用性，也就是说，你可以用一组不同的参数反复调用同一个函数。
下面写了一个这样的例子:
def mult(a , b):
return a * b
n1 = int(input("Enter a number :"))
n2 = int(input("Enter another number :"))
multiplication1 = mult(n1 , n2)
num1 = 6.0
num2 = 5.0
multiplication2 = mult(num1 , num2)
print("The product of {} and {} is {}".format(n1 , n2 , multiplication1))
print("The product of {} and {} is {}".format(num1 , num2, multiplication2)
以上代码的输出:
Enter a number : 4
Enter another number : 7
The product of 4 and 7 is 28
The product of 6.0 and 5.0 is 30.0
这里，我们定义了一个名为 mult 的函数，它返回乘积。我们在代码中调用了这个函数两次。首先，使用用户输入的整数值。第二，使用浮点值。因此，证明了可重用性。
对列表元素执行乘法运算
我们还可以使用不同的方式打印给定列表中所有元素的乘积:
1.通过遍历列表
在这个方法中，我们将使用一个 for 循环来遍历列表和一个初始化为 1 的变量' res '(不是 0，因为我们需要产品和 0 * any = 0)。“ res 的值随着每次迭代而更新。
list1 = [3,4,5]
res = 1
for val in list1 :
res = res * val
print("The product of elements of the given list is ", res)
输出:
The product of elements of the given list is 60
2.使用 numpy.prod()
在 NumPy 中，我们有 prod() ，它将一个列表作为参数，并返回列表中所有元素的乘积。这个函数用处很大，节省了很多代码。你只需要导入 NumPy 就可以使用 numpy.prod()。下面给出一个例子:
代码:
import numpy
list1 = [2,3,4,5]
list2 = [10,10,10]
ans1 = numpy.prod(list1)
ans2 = numpy.prod(list2)
print("Multiplication of elements of list1 is ",ans1)
print("Multiplication of elements of list2 is ",ans2)
输出:
Multiplication of elements of list1 is 120
Multiplication of elements of list2 is 1000
结论
这就是你在 Python 中多重数的方法！我希望这篇教程对你有用。
Python 中的乘法——简单指南
原文：https://www.askpython.com/python/examples/multiplying-in-python
数据分析的基础在于稳健的算法。一个人可以开发的所有复杂算法都可以缩小为基本算术，如加、减、乘或除；甚至微积分也是进行这些基本运算的简单方法。也就是说，我们将开始探索在 Python 中实现这样一个基本操作——乘法！
以下是可以在 Python 中部署的不同技术，以满足您特定的乘法需求，
- 将列表中的数字相乘
- 使用 math.prod()
- 使用 mul()
- 将两个列表相乘
- 将用于语句
- 使用 numpy
使用 math.prod()将列表中的数字相乘
我们应该从导入 Python 中的 math 库开始，
import math
然后你将在列表中进食你希望被繁殖的，如下所示。
Creating A List Of Numbers
现在让我们为结果分配一个变量 R1，并用 math.prod()命令将它绑定起来。
R1 = math.prod(L1)
现在，列表中给定的所有数字将被相乘成一个单独的数字实体，可以使用 print()命令查看该实体。
Result Of The List Multiplied
使用 mul()将列表中的数字相乘
类似于上面使用的数学库，你也可以调用运算符库来完成 Python 中的乘法运算。但是我们没有像上一个案例那样导入整个库，而是使用下面的代码从操作符库中专门提取 mul 函数。
from operator import mul
一旦完成，我们现在将设置一个变量' m '并将其初始化为 1。
Importing Operator Initialising A Variable
现在，我们将继续为''语句构造一个,该语句使用下面的代码，借助 mul()函数将列表中的每个数字相乘。
for i in L1:
m = mul(i,m)
print(m)
它的作用是打印乘法的结果，每次列表中的两个数相乘。他们说‘展示比告诉’更好，所以我们开始吧！
Results Of Multiplication
这里显示的最后一个数字是列表中所有数字相乘后的最终结果。但是如果一个人不想在每一步都看到答案，而是直接跳到最后的结果呢？
这也可以通过调整我们的代码来实现，如下所示:
m = 1
for i in L1:
m = mul(i,m)
print(m)
运行上面的代码可以直接得到最终的结果！
Only Final Result Displayed
使用 for 语句将两个列表相乘
为了将两个列表中的元素相乘，我们将采用嵌套在' for' '语句中的 range( ) & len()函数的组合，如下所示。
R_L = [L1[i]*L2[i] for i in range(len(L1))]
len()所做的是返回列表 L1 中的数字计数，该计数用作 range()函数的引用，该函数反过来告诉' for' '语句，它需要将两个列表之间的一个数字与另一个数字相乘多少次。运行代码会导致，
Multiplying Two Lists Using For Statement
使用 numpy 将两个列表相乘:
这是一个相当简单的技术，首先通过键入来导入 numpy 库，
import numpy as np
一旦完成，我们就可以使用函数 np.multiply()在眨眼之间得到两个列表相乘的结果！
R1 = np.multiply(L1, L2)
Multiplying Two Lists Using Numpy
摘要
既然我们已经到了本文的结尾，希望它已经详细阐述了如何使用 Python 编程来倍增实体。这里有另一篇文章详细介绍了 Python 中日期和时间的比较。在 AskPython 中还有许多其他有趣的&文章，这些文章可能对那些想提高 Python 水平的人有很大帮助。欢呼！
Python 中的多重处理
原文：https://www.askpython.com/python-modules/multiprocessing-in-python
嘿伙计们！在本文中，我们将学习 Python 中的多重处理。那么，我们开始吧。
什么是多重处理？
多重处理是 python 中的一个包，它支持生成利用 Python API 的进程的能力。它类似于 Python 中的线程模块。
理解 Python 中的多重处理
多处理器是指计算机有一个以上的中央处理器。如果一台计算机只有一个多核处理器，可以使用 Python 中的多线程并行运行任务。
多处理器系统能够同时支持多个处理器。为了找到我们系统中可用的 CPU 内核的数量，我们使用了 mp.cpu_count() 函数。
在本文中，我们将使用 Python 的多重处理模块
下面是使用多处理模块在 Python 中查找处理器数量的示例代码:
import multiprocessing as mp
print(mp.cpu_count())
输出: 12
这里的计数是多个处理器之间的内核总数。
该模块的四个最重要的类是-
- 流程类
- 锁定级
- 队列类别
- 池类
让我们分别看看这些类中的每一个…
1.流程类
进程是当前进程的分叉副本。它创建一个新的进程标识符，任务作为独立的子进程运行。
start() 和 join() 函数都属于这个类。为了在进程中传递一个参数，我们使用 args 关键字。
start()函数示例-
在这里，我们创建了一个函数 calc_square 和 calc_cube ，分别用于求数字的平方和立方。在主函数中，我们创建了对象 p1 和 p2 。 p1.start() 和 p2.start() 将启动函数，调用 p1.join()和 p2.join 将终止进程。
import time
import multiprocessing
def calc_square(numbers):
for n in numbers:
print('square ' + str(n*n))
def calc_cube(numbers):
for n in numbers:
print('cube '+ str(n*n*n))
if __name__ == "__main__":
arr=[2,3,8,9]
p1=multiprocessing.Process(target=calc_square,args=(arr,))
p2=multiprocessing.Process(target=calc_cube,args=(arr,))
p1.start()
p2.start()
p1.join()
p2.join()
print("Done")
输出:
square 4
square 9
square 64
square 81
cube 8
cube 27
cube 512
cube 729
Done
2.锁定级
lock 类允许代码被锁定，以确保没有其他进程可以执行类似的代码，直到它被释放。
要认领锁， 使用获取() 函数，要释放锁， 使用释放() 函数。
from multiprocessing import Process, Lock
lock=Lock()
def printer(data):
lock.acquire()
try:
print(data)
finally:
lock.release()
if __name__=="__main__":
items=['mobile','computer','tablet']
for item in items:
p=Process(target=printer,args=(item,))
p.start()
输出
mobile
computer
tablet
3.队列类别
队列是一种使用先进先出(FIFO)技术的数据结构。它帮助我们使用本地 Python 对象执行进程间通信。
当作为参数传递时，队列使进程能够使用共享数据。
put() 函数用于向队列中插入数据， get() 函数用于从队列中消耗数据。
import multiprocessing as mp
def sqr(x,q):
q.put(x*x)
if __name__ == "__main__":
q=mp.Queue() # Instance of queue class created
processes=[mp.Process(target=sqr,args=(i,q))for i in range (2,10)] # List of processes within range 2 to 10
for p in processes:
p.start()
for p in processes:
p.join()
result = [q.get() for p in processes]
print(result)
输出:
[4, 9, 16, 25, 36, 64, 49, 81]
4.池类
pool 类帮助我们针对多个输入值并行执行一个函数。这个概念叫做数据并行。
这里，数组[5，9，8]被映射为函数调用中的输入。pool.map()函数用于传递多个参数的列表。
import multiprocessing as mp
def my_func(x):
print(x**x)
def main():
pool = mp.Pool(mp.cpu_count())
result = pool.map(my_func, [5,9,8])
if __name__ == "__main__":
main()
输出:
3125
387420489
16777216
结论
在本文中，我们学习了 Python 中多处理的四个最重要的类——进程、锁、队列和池，它们可以更好地利用 CPU 内核并提高性能。
参考
Python 中的多线程:简单参考
原文：https://www.askpython.com/python-modules/multithreading-in-python
python 中的多线程是使用线程概念在 Python 中实现多任务的一种方式。
什么是线程？
线程是由操作系统管理的任何进程的组件。操作系统通过在线程之间划分进程来实现并行或多任务处理。这是一个轻量级的过程，确保了独立的执行流程。
Python 中多线程的好处是什么？
创建多线程应用程序有很多好处。让我们看看这里的一些好处:
- 资源的有效利用
- 更有责任感
- 资源共享使它更经济
- 由于并行性，可有效利用多处理器架构
- 节省时间
- 线程(因为是同一个进程的一部分)相互之间的通信比它们是单独的进程更容易
- 它们不需要太多的内存开销
- 多线程服务器和交互式图形用户界面专门使用多线程。
Python 中如何实现多线程？
让我们继续创建我们的第一个多线程应用程序。
1.导入线程模块
对于线程的创建，我们将使用threading模块。
import threading
threading模块由一个Thread类组成，该类被实例化以创建一个线程。
可以通过创建 thread 类的对象来创建线程。该类的参数如下:
- 目标:线程要调用的函数在这里指定。这个函数是一个可调用的对象，由线程的
run()方法调用。 - 参数:这里，我们指定了
target函数的参数。
def print_hi(num):
print("Hi, you are customer ",num)
t1 = threading.Thread(target=print_square, args=(10,))
上面的代码片段调用了作为target参数调用的print_hi()函数。该功能有一个参数，即使用args指定的num。
Illustration Of Main Thread And Child Threads
2.开始线程
通过调用线程对象上的threading模块的start()方法来启动线程。下图显示了相同的情况:
t1.start()
每个线程对象最多只能调用一次。它安排在一个单独的控制线程中调用对象的run()方法。
如果在同一个线程对象上多次调用，这个方法将引发一个RuntimeError。
线程在程序中被调用，程序本身就是一个进程。因此，在线程执行期间，主程序也继续执行。
因此，我们可以暂停主程序(由主线程运行)的活动，直到创建的线程完成。同样的例子如下。
3.螺纹连接方法
def print_hi(num):
print("Hi, you are customer ",num)
t1 = threading.Thread(target = print_hi, args=(10,))
t1.start()
t1.join()
print("End")
在上面的代码片段中，Thread类用于创建一个对象，并被命名为 t1。在标记线程活动开始的线程对象 t1 上调用start()方法。
然后调用join()方法。通过这样做，我们确保主程序暂停主线程的执行，并等待直到线程 t1 完成。一旦 t1 完成了它的活动，主线程(主程序)就可以继续执行。因此，行print("End")仅在线程活动完成后执行。
Hi, you are customer 10
End
如果不使用join()方法，解释器可以在两个打印语句——print("Hi, you are customer ", num)和print("End")之间进行选择。在这种情况下，无法预测哪个打印语句将首先显示，因为这些行的执行是由解释器选择的。
4.在 Python 中同步线程
线程同步被定义为确保没有两个线程执行访问共享资源的特定程序段的机制。程序的这些部分被称为关键部分。
有必要确保两个线程不会同时访问这个资源，因为这会导致竞争条件。
竞争条件被定义为两个或多个线程使用写权限访问共享资源并试图更改数据的情况。因此，这些变量的值变得不可预测。
因此，我们在程序中使用锁来暂时停止程序的执行，直到锁被释放。这样做是为了确保两个线程不会访问同一个变量而导致冲突。
多线程的缺点
- 增加了程序的复杂性。
- 共享资源(对象、数据)的同步是必要的。
- 难以调试不可预测的结果
- 构建和同步线程是 CPU/内存密集型的。
参考
https://docs.python.org/3/library/threading.html
使用 Python NLTK 实现 N 元语法——分步指南
原文：https://www.askpython.com/python/examples/n-grams-python-nltk
在本教程中，我们将讨论 n 元语法的含义以及如何在 Python 编程语言中实现 n 元语法。
也可阅读:BLEU score in Python——初学者概述
理解 N 元语法
文本 n 元语法通常用于自然语言处理和文本挖掘。它本质上是同时出现在同一个窗口中的一串单词。
当计算 n-gram 时，您通常前进一个单词(尽管在更复杂的情况下，您可以移动 n 个单词)。n-gram 有多种用途。
N Grams Demonstration
例如，在创建语言模型时，n 元模型不仅用于创建单元模型，还用于创建二元模型和三元模型。
谷歌和微软已经创建了网络规模的语法模型，可用于各种活动，如拼写纠正、断字和文本摘要。
用 Python 实现 n 元语法
为了实现 n 元语法，使用了nltk中的ngrams函数，该函数将执行所有的 n 元语法操作。
from nltk import ngrams
sentence = input("Enter the sentence: ")
n = int(input("Enter the value of n: "))
n_grams = ngrams(sentence.split(), n)
for grams in n_grams:
print(grams)
抽样输出
Enter the sentence: Let's test the n-grams implementation with this sample sentence! Yay!
Enter the value of n: 3
("Let's", 'test', 'the')
('test', 'the', 'n-grams')
('the', 'n-grams', 'implementation')
('n-grams', 'implementation', 'with')
('implementation', 'with', 'this')
('with', 'this', 'sample')
('this', 'sample', 'sentence!')
('sample', 'sentence!', 'Yay!')
看看结果有多惊人！你可以在一些句子中尝试使用相同的代码。编码快乐！😇
另请参阅:
基于 Python 的朴素贝叶斯分类器
原文：https://www.askpython.com/python/examples/naive-bayes-classifier
朴素贝叶斯分类器是一种概率分类器，基于贝叶斯定理。
在机器学习中，分类问题表示在给定数据的情况下选择最佳假设。
给定一个新的数据点，我们尝试对这个新数据实例属于哪个类标签进行分类。关于过去数据的先验知识有助于我们对新数据点进行分类。
朴素贝叶斯定理
Bayes Theorem
假设事件 B 已经发生，贝叶斯定理给出了事件 A 发生的概率。比如说。
鉴于天气多云，下雨的可能性有多大？下雨的概率可以称为我们的假设，代表多云天气的事件可以称为证据。
- p(A | B)–称为后验概率
- p(B | A)–是给定 A 时 B 的条件概率。
- p(A)–称为事件 A 的先验概率。
- p(B)——不考虑假设，是事件 B 发生的概率。
现在我们对贝叶斯定理有了一些了解，让我们看看朴素贝叶斯是如何工作的。
朴素贝叶斯分类器是如何工作的？
为了演示朴素贝叶斯分类器是如何工作的，我们将考虑一个垃圾邮件分类问题，该问题对一封电子邮件是否是垃圾邮件进行分类。
让我们考虑一下我们总共有 12 封电子邮件。其中 8 个不是垃圾邮件，其余 4 个是垃圾邮件。
- 非垃圾邮件的数量–8
- 垃圾邮件数量–4 封
- 电子邮件总数–12 封
- 因此，P(非垃圾邮件)= 8/12 = 0.666，P(垃圾邮件)= 4/12 = 0.333
假设整个语料库只包含四个词【朋友、提议、金钱、美妙】。下面的直方图表示每个类别中每个单词的字数。
Word Counts In our Example
我们现在将计算每个单词的条件概率。
假设邮件不是垃圾邮件，下面给出的公式将计算单词 Friend 出现的概率。
Calculating Conditional Probabilities
计算整个文本语料库的概率。
Conditional Probabilities of Each Words
现在我们有了所有的先验概率和条件概率，我们可以对它应用贝叶斯定理。
假设我们收到一封电子邮件:“Offer Money”，根据我们之前计算的概率，我们需要将其分类为垃圾邮件或非垃圾邮件。
Probability Score Calculation
给定单词 Offer 和 Money，电子邮件是垃圾邮件的概率大于该邮件不是垃圾邮件的概率。(0.0532 > 0.00424).
因此，我们的分类器会将此电子邮件归类为垃圾邮件。总之，我们只是计算了后验概率，如贝叶斯定理所示。
如果我们遇到一个不在其他类别中的变量，那么该变量的字数将变为 0，我们将无法做出预测。
这个问题也被称为“零频率”问题。为了避免这种情况，我们使用平滑的方法。即拉普拉斯估计。平滑技术不影响条件概率。
朴素贝叶斯分类器的类型:
- 多项式–用于离散计数。我们在上面的例子中描述的是多项式型朴素贝叶斯的一个例子。
- 高斯–这种类型的朴素贝叶斯分类器假设数据遵循正态分布。
- 伯努利–当我们的特征向量是二进制时，这种类型的分类器是有用的。
用 Python 实现朴素贝叶斯
我们将利用威斯康星乳腺癌数据集。这里可以了解更多关于数据集的内容。
Scikit Learn 为我们提供了实现朴素贝叶斯算法的GaussianNB类。
#Loading the Dataset
from sklearn.datasets import load_breast_cancer
data_loaded = load_breast_cancer()
X = data_loaded.data
y = data_loaded.target
数据集有 30 个需要进行预测的要素。我们可以通过使用.data方法来访问数据。数据集包含要素和目标变量。
#Splitting the dataset into training and testing variables
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(data.data, data.target, test_size=0.2,random_state=20)
#keeping 80% as training data and 20% as testing data.
现在，导入高斯朴素贝叶斯类并使用拟合训练数据。
from sklearn.naive_bayes import GaussianNB
#Calling the Class
naive_bayes = GaussianNB()
#Fitting the data to the classifier
naive_bayes.fit(X_train , y_train)
#Predict on test data
y_predicted = naive_bayes.predict(X_test)
GaussianNB类的.fit方法需要特征数据(X_train)和目标变量作为输入参数(y_train)。
现在，让我们用准确性指标来看看我们的模型有多准确。
#Import metrics class from sklearn
from sklearn import metrics
metrics.accuracy_score(y_predicted , y_test)
精度= 0.956140350877193
我们得到了大约 95.61 %的准确率
请随意试验这些代码。在拟合算法之前，您可以对数据应用各种转换。
结论
在本文中，我们对朴素贝叶斯分类器有了一些直觉。我们还看到了如何使用 sklearn 实现朴素贝叶斯。学习愉快！
Python 中的朴素文本搜索算法
原文：https://www.askpython.com/python/examples/naive-string-searching-algorithm
在本教程中，我们将研究如何识别文本中的模式。主内容之外还会有一个子串。目的是确定子字符串在文本中出现的次数和位置。
当存在大量文本，并且我们需要定位特定关键字或术语的出现时，这种模式查找方法非常有用。
在这一节中，我们将讨论最基本的 Python 中的朴素字符串匹配算法’以及如何通过更好更短的代码来改进它。
朴素算法简介
顾名思义，朴素算法是非常基础且易于实现的算法。这些算法使用最基本和最明显的策略来完成任务，就像孩子一样。
对于初学者来说，在学习更高效和复杂的算法之前，这些方法是一个很好的起点。其中之一是基本的字符串搜索算法。在字符串匹配/模式发现算法中，它是最基本的。
该过程从逐字母匹配字符串开始。它在主文本和子字符串中搜索第一个字符。如果匹配，则继续到两个字符串中的下一个字符。
如果这些字符在循环中的任何地方都不匹配，则循环被中断，并且循环从主文本字符串中的下一个字符重新开始。
实现简单的字符串搜索
def naive(txt,wrd):
lt=len(txt)#length of the string
lw=len(wrd)/3length of the substring(pattern)
for i in range(lt-lw+1):
j=0
while(j<lw):
if txt[i+j]==wrd[j]:
j+=1
else:
break
else:
print('found at position',i)
上面代码中的“naive”方法有两个参数:txt(从中搜索模式的主字符串)和 ward(要搜索的模式)。
因为至少应该保留子串的长度以匹配到末尾，所以采用从 0 到(字符串长度-子串长度+1)的循环。“for”循环从字符串(text[I])中提取每个字符。
然后有一个内部 while 循环，它将该字符与子串中的下一个字符进行比较，直到整个子串匹配为止。如果没有被发现，循环就被中断，下一次迭代，就像下一个字符一样，被从进程中删除。
当发现完整的子字符串时，while 条件被破坏，否则部分运行，并显示位置。另一个在循环中，只有当条件为假时才运行，而另一个在 while 循环条件为假时执行。
让我们看看以下输入的输出:
naive("AABAACAADAABAABA","AABA")
输出结果如下:
found at position 0
found at position 9
found at position 12
结论
恭喜你！您刚刚学习了如何实现简单的字符串搜索算法。希望你喜欢它！😇
喜欢这个教程吗？无论如何，我建议你看一下下面提到的教程:
感谢您抽出时间！希望你学到了新的东西！！😄
解读《熊猫与熊猫》中的南
原文：https://www.askpython.com/python/examples/nan-in-numpy-and-pandas
NaN 是的简称，不是数字。它用于表示未定义的条目。它还用于表示数据集中缺失的值。
NaN 的概念甚至在 Python 被创建之前就存在了。IEEE 浮点运算标准(IEEE 754)在 1985 年引入了 NaN。
NaN 是一个特殊的浮点值，只能转换为 float 类型。
在本教程中，我们将看看南如何在熊猫和 Numpy 工作。
南在数字
让我们看看南在 Numpy 下是如何工作的。为了观察 NaN 的属性，让我们用 NaN 值创建一个 Numpy 数组。
import numpy as np
arr = np.array([1, np.nan, 3, 4, 5, 6, np.nan])
pritn(arr)
输出:
[ 1\. nan 3\. 4\. 5\. 6\. nan]
1.具有 NaN 的 Numpy 阵列上的数学运算
让我们尝试在 Numpy 数组上调用一些基本函数。
print(arr.sum())
输出:
nan
让我们试着从数组中找出最大值:
print(arr.max())
输出:
nan
幸运的是，Numpy 提供了在执行数学运算时忽略 NaN 值的方法。
2.在 Numpy 数组上执行数学运算时如何忽略 NaN 值
Numpy 提供了类似 np.nansum()和 np.nanmax()的方法，用于在忽略数组中的 NaN 值后计算 sum 和 max。
np.nansum(arr)
输出:
19.0
np.nanmax(arr)
6.0
如果您在 IDE 中打开了自动完成功能，则在使用 np.nan 时，您会看到以下选项列表:
Np Nan
3.检查 NaN 值
要检查 Numpy 数组中的 NaN 值，可以使用 np.isnan()方法。
这将输出一个与原始数组大小相同的布尔掩码。
np.isnan(arr)
输出:
[False True False False False False True]
对于原始数组中为 NaNs 的索引，输出数组为 true，而对于其余的索引，输出数组为 false。
4.等同于两个 nan
两个 nan 相等吗？
这可能是一个令人困惑的问题。让我们试着通过运行一些 python 代码来回答这个问题。
a = np.nan
b = np.nan
这两条语句用 nan 初始化两个变量 a 和 b。让我们试着把两者等同起来。
a == b
输出:
False
在 Python 中，我们还有 is 操作符。让我们试着用这个来比较两个变量。
a is b
输出:
True
原因是==运算符比较两个操作数的值，并检查值是否相等。另一方面，is operator检查两个操作数是否指向同一个对象。
事实上，您可以打印出 a 和 b 的 id，并看到它们引用同一个对象。
id(a)
输出:
139836725842784
id(b)
输出:
139836725842784
熊猫数据框中的南
Pandas DataFrames 是将数据导入 python 的一种常见方式。让我们看看如何在一个熊猫数据框架中处理 NaN 值。
让我们从创建一个数据帧开始。
s = pd.DataFrame([(0.0, np.nan, -2.0, 2.0),
... (np.nan, 2.0, np.nan, 1),
... (2.0, 5.0, np.nan, 9.0),
... (np.nan, 4.0, -3.0, 16.0)],
... columns=list('abcd'))
s
输出:
Dataframe
1.检查 NaN 值
您可以通过使用 isnull()方法来检查 NaN 值。输出将是一个布尔掩码，其尺寸为原始数据帧的尺寸。
s.isnull()
输出:
Isnull
2.替换 NaN 值
有多种方法可以替换熊猫数据帧中的 NaN 值。最常见的方法是使用。fillna()方法。
此方法要求您指定一个值来替换 NaNs。
s.fillna(0)
输出:
Fillna(0)
或者，您也可以按列的方式提及这些值。这意味着一列中的所有 nan 将被替换为相同的值。
values = {'a': 0, 'b': 1, 'c': 2, 'd': 3}
s.fillna(value=values)
输出:
您还可以使用插值来填充数据框中缺失的值。与相比，插值是一种稍微高级的方法。菲尔娜()。
插值是一种可以估计两个已知数据点之间的未知数据点的技术。
3.删除包含 NaN 值的行
要删除带有 nan 的行或列，您可以使用。dropna() 法。
要删除带有 nan 的行，请使用:
df.dropna()
要删除带有 nan 的列，请使用:
df.dropna(axis='columns')
结论
本教程是关于 Python 中的 NaNs 的。我们主要集中在处理 Numpy 的 NaNs 和熊猫。希望你和我们一起学习愉快。
负索引 Python 列表–如何使用“-1”参数
Python 列表可以通过多种方式进行索引，包括正数和负数。本文将讨论如何使用“-”减号参数来访问列表中的特定元素。
基本列表结构和操作
列表是用方括号和其中的元素定义的。每个元素都用逗号隔开。
语法:
list_name = [element_!, element_2, ..., element_n]
代码:
int_list= [3, 4, 5, 5, 6] # a list containing all integers
char_list = ['a', 'b', 'c', 'd'] # al list of characters
str_list = ["apple", 'banana', 'lemon', 'orange'] # a list of strings
什么是列表索引？
索引是任何编程语言中任何线性数据结构的基本单位。对于每台计算机，默认索引从 0 开始，一直到 n-1。这里 n 表示相应数据结构中元素的总数。类型有:
- 正分度:从 0 开始增加
- 负索引:从最后一个元素开始，每次遍历都是从头到尾移动。
这些帮助我们访问这个数据结构的单个元素。让我们看看下一节中的操作。
列表中的负索引
这是我们话题的重点。列表中的“-1”参数表示 Python 解释器的操作是从最后一个元素开始的。首先，我们将了解如何使用索引号访问元素。
Indexing In Lists
使用负索引检索列表数据
my_list = [45, 5, 33, 1, -9, 8, 76]
print(my_list[-1])
print(my_list[-2])
print(my_list[-3])
输出:
76
8
-9
用负索引反转列表
使用内置函数“reverse()”:
my_list = [45, 5, 33, 1, -9, 8, 76]
my_list.reverse()
输出:
[76, 8, -9, 1, 33, 5, 45]
使用-1 反转列表
my_list = [45, 5, 33, 1, -9, 8, 76]
my_list[::-1]
输出:
[76, 8, -9, 1, 33, 5, 45] # reversed list
移除具有负索引的元素
使用 pop()函数，并在其中给定-1 作为参数，我们可以删除列表中的最后一个元素，并得到一个新的列表。
my_list = [45, 5, 33, 1, -9, 8, 76]
my_list.pop(-1)
my_list
输出:
76 # popped out element
[45, 5, 33, 1, -9, 8] # new list returned
在 Python 列表中使用负索引的优势
- 减少代码行数并在一行中进行反向操作。
- 简化复杂的操作。
- 操作时间最短，复杂性更低。
结论
我们的 Python 负索引教程到此结束。我们希望它对您有所帮助！如果你有任何问题或意见，请在下面分享。感谢阅读！
Python 中图像的负变换
原文：https://www.askpython.com/python/examples/negative-transformation-of-image
在本文中，您将学习如何使用 Python 中的 PIL 对图像执行负变换。PIL 是 Python 图像库的缩写。该库用于多种图像转换。PIL 让处理图像变得超级简单，可以帮助你编辑图像的不同部分，而不需要很多行代码。
导入模块
为此，让我们使用 PIL 的图像类。因此，脚本的第一行如下所示:
from PIL import Image
在这种情况下，Image 类由许多属性和方法组成。要打开图像、查看图像、从给定图像中检索像素以及更改图像中的像素，我们需要 open、show、getpixel 和 putpixel 方法。
那么，让我们来看看如何打开一个图像。可以这样做，如下所示。
from PIL import Image
import matplotlib.pyplot as plt
img=Image.open("fig.jpg")
plt.axis('off')
plt.imshow(img)
加载图像
这里，img 是所提供图像的图像对象，它可以在图像的路径中找到。“让我们来看看图像中颜色的负转换。
Negative Transformation Input
众所周知，在 RGB 颜色模型下，每种颜色都有一个小数索引，范围从 0-255。值 0 表示最低，值 255 表示最高。例如，(255，255，255)表示白色。
同样，(0，0，0)代表黑色。我们打算进行颜色的负转换，这意味着反转颜色，如下所示。
设颜色 X 表示为(r，g，b)=(100，100，100)。它可以转换如下
R = 255-R = 255-100 = 155 =>R = 155
类似地，G=155 和 B=155
因此 X 的负变换颜色指数是(R，G，B) =(155，155，155)
实现图像的负变换
因此，让我们为图像的每个像素实现颜色的负变换。
w,h=img.size
for i in range(w):
for j in range(h):
r,g,b=img.getpixel((i,j))
r=255-r
g=255-g
b=255-b
img.putpixel((i,j),(r,g,b))
plt.axis('off')
plt.imshow(img)
Negative Transformation Output
Python 中图像负变换的代码
from PIL import Image
import matplotlib.pyplot as plt
img=Image.open("fig.jpg")
w,h=img.size
for i in range(w):
for j in range(h):
r,g,b=img.getpixel((i,j))
r=255-r
g=255-g
b=255-b
img.putpixel((i,j),(r,g,b))
plt.axis('off')
plt.imshow(img)
Negative Transformation Input 2
Negative Transformation Output 2
结论
恭喜你！你刚刚学会了如何得到一个图像的负变换。希望你喜欢它！😇
喜欢这个教程吗？无论如何，我建议你看一下下面提到的教程:
- Python patch ify——从大型图像中提取补丁
- 用 Python 对服装图像进行分类——完全指南
- Python 中的图像去噪——分步指南
- 使用直方图可视化图像中的颜色–Python OpenCV
感谢您抽出时间！希望你学到了新的东西！！😄
Python 中的网络分析-完整指南
原文：https://www.askpython.com/python/examples/network-analysis-in-python
一种用于评估、管理和跟踪管理过程和工作流的方法被称为网络分析。此外，数据分析有助于创建节点和结构元素的图形图，但与工作流不同，网络图检查按时间顺序排列的事件、目标和任务，以及它们的时间框架和相关性，并将它们可视化地描绘为树或表格，如甘特图。
在制定项目计划时，项目负责人可能需要网络分析，因为它有助于处理以下因素:
- 任务的相互依赖性
- 动作之间的持续时间以及如何有效地缓冲它们。
- 开始和结束日期，从最早的日期到最近的日期
- 活动间隔
- 为最重要的任务和活动制定路线。
网络分析方法通常用于设计到开发阶段，以加强项目控制并确保任务在预算内按时交付。
如何在 Python 中实现网络分析
在 Python 中有许多方法可以进行网络分析。此外，有许多工具可用于绘制网络分析图，但在本文中，我们将特别使用 networkx 和 matplotlib ，因为它们是功能强大的网络绘制工具。
我们将通过使用一些在线可用的用户数据库来理解网络绘图。在这个例子中，我们获取了两个基于 16 世纪的中国人口记录，它们可能生活在一部著名小说的作者生活的时代，我们将尝试创建一个可能认识他的人的图表。
让我们从导入包开始
import networkx as nx
import matplotlib.pyplot as plt
Github 链接提取数据库:链接
git 文件夹中有多个文件，但我们只需要“edges.tsv”和“nodes.tsv”。这些 word 文件包含所有的历史数据。
Raw data when extracted from .tsv file
这些历史数据库在。tsv 文件格式。正如你在上面的图像中看到的，数据是分散的，没有经过过滤。为了将这些数据图形化，我们需要将其分离，以便编译器可以轻松地开始读取数据。
下面的代码演示了如何将这些文件加载到一个(get_data)方法中，并根据我们的需要对它们进行分离。
def data_extraction(name_ofile):
# Here, data loading will be done through a context manager
with open(name_ofile, 'r', encoding='utf8') as rf:
# transform file into string and split along new line
filelines = rf.read().split("\n")
# new line will be created at tab spaces
filedata = [line.split("\t") for line in filelines]
# picks the header
fileheader = filedata[0]
# header gets deleted
filedata = filedata[1:]
# return header and data
return fileheader, filedata
# load data in from file
headerofnode, data_ofnode = data_extraction('nodes.tsv')
headerofedge, data_ofedge = data_extraction('edges.tsv')
The above image represents how the compiler starts to segregate the data after reading the above lines of code.
创建图形并将节点信息添加到 it:
Graph = nxnas.Graph()
# graph gets data of node added to it
for nxnode in data_ofnode:
# sequentially adding id, name, chinese name, and index year
Graph.add_node(int(nxnode[0]), pname=nxnode[1], chinese_name=nxnode[2], year_inindex=int(nxnode[3]))
# graph gets data of edge added to it
for nxedge in data_ofedge:
# sequentially adding node 1, node 2, kin, and label
Graph.add_edge(int(nxedge[0]), int(nxedge[1]), nxkin=nxedge[2], nxlabel=nxedge[3])
为图表添加数据指标
degree_centrality = nxnas.degree_centrality(Graph)
closeness_centrality = nxnas.closeness_centrality(Graph)
betweenness_centrality = nxnas.betweenness_centrality(Graph)
度量是 networkx python 包中提供的各种算法，可用于研究您的网络。在本例中，我们使用了三个数据指标来绘制图表。让我们了解它们的功能和用途。
- 度中心性:一个节点的边数。
- Closeness _ centrality:查找它们之间距离最小的节点。通过这种方式，可以测量节点传输数据的效率。
- 中间中心性:寻找最短路径。
Python 中网络分析的完整代码
import networkx as nxnas
import matplotlib.pyplot as myplot
# This function is employed to extract data from the .tsv files
def data_extraction(name_ofile):
# Here, a data loading will be done through a context manager
with open(name_ofile, 'r', encoding='utf8') as rf:
# transform file into string and split along new line
filelines = rf.read().split("\n")
# new line will be created at tab spaces
filedata = [line.split("\t") for line in filelines]
# picks the header
fileheader = filedata[0]
# header gets deleted
filedata = filedata[1:]
# return header and data
return fileheader, filedata
# load data in from file
headerofnode, data_ofnode = data_extraction('nodes.tsv')
headerofedge, data_ofedge = data_extraction('edges.tsv')
# create graph object
Graph = nxnas.Graph()
# graph gets data of node added to it
for nxnode in data_ofnode:
# sequentially adding id, name, chinese name, and index year
Graph.add_node(int(nxnode[0]), pname=nxnode[1], chinese_name=nxnode[2], year_inindex=int(nxnode[3]))
# graph gets data of edge added to it
for nxedge in data_ofedge:
# sequentially adding node 1, node 2, kin, and label
Graph.add_edge(int(nxedge[0]), int(nxedge[1]), nxkin=nxedge[2], nxlabel=nxedge[3])
# Data metrics for the graph
degree_centrality = nxnas.degree_centrality(Graph)
closeness_centrality = nxnas.closeness_centrality(Graph)
betweenness_centrality = nxnas.betweenness_centrality(Graph)
# The process of depicting the graph
nxnas.draw_spring(Graph)
myplot.show()
输出:
Network Graph
结论:
本文详细解释了网络分析图以及如何绘制它们。我们已经学会了如何绘制公共领域中可用记录的网络图，并从中得出关系。我们还了解了 networkx 指标以及如何调用和使用它们。
参考资料:
从熊猫的数据框架构建网络图
原文：https://www.askpython.com/python/examples/network-graphs-from-pandas-dataframe
在本教程中，我们将尝试从熊猫数据框中生成一个令人惊叹的交互式网络图，让事情更上一层楼！
不要耽搁，让我们开始吧！
加载和预处理数据
本节重点介绍数据集的加载和预处理。本教程选择的数据集是 Kaggle 上提供的 OpenFlights 机场数据集。截至 2017 年 1 月，OpenFlights 机场数据库包含全球超过 10，000 个机场的数据。
阅读更多:用 Python 处理数据帧行和列
在下面的代码中，我们将导入pandas模块并将routes.csv文件加载到程序中。现在，在数据集中的所有列中，我们只需要数据集中的source和destination机场。
import pandas as pd
df = pd.read_csv('routes.csv')
df = df[['Source airport','Destination airport']]
df = df[:500]
df.head()
为了使处理更容易，计算更简单，我们将只从数据集中取出最上面的500行。我们将使用head函数显示数据集的前五行。
OpenFlight Dataset 5 Rows
我们将使用下面的 Python 代码将源节点和目的节点分成两个单独的列表。
sources = list(df['Source airport'])
destinations = list(df['Destination airport'])
现在，在下一节中，我们将继续使用 networkx 和 pyviz 库来生成网络图。
网络图的生成
我们将首先使用net.Network函数创建一个空图，并传递空网络图的一些属性。下一步是迭代sources列表并添加节点及其标签和标题。
之后，我们将使用 add_edge 函数添加边。我们将利用异常处理来确保所有的错误都被考虑在内(如果有的话)。
也读作: Python 异常处理——尝试，除，最后
看看下面提到的代码。
g_from_data =net.Network(height='600px',width='50%',
bgcolor='white',font_color="black",
heading="A Networkx Graph from DataFrame",directed=True)
for i in range(len(sources)):
try:
g_from_data.add_node(sources[i],label=sources[i],title=sources[i])
except:
pass
for (i,j) in zip(sources,destinations):
try:
g_from_data.add_edge(i,j)
except:
pass
g_from_data.show_buttons(['physics'])
g_from_data.show('A_Complete_Networkx_Graph_From_DataFrame.html')
display(HTML('A_Complete_Networkx_Graph_From_DataFrame.html'))
看看下面生成的网络图。令人惊讶的是，这个图表看起来如此有趣。
结论
我希望您能够理解如何使用 Python 编程语言中的 pyviz 库使用 pandas 数据框生成网络图。感谢您的阅读！
我建议你阅读下面的教程:
用 Python 创建交互式网络图
原文：https://www.askpython.com/python-modules/networkx-interactive-network-graphs
我相信在使用一个叫做 Networkx 的特殊库之前，您已经用 python 构建了网络图。你有没有想过是否有一种方法可以与图形互动？你猜怎么着？！有一个名为 Pyvis 的库，它有助于提高 Python 编程语言中网络图的交互性。
Pyvis 库支持可视化，并为网络图增加了交互性。该库构建在强大而成熟的 VisJS JavaScript 库之上。这允许快速响应的交互，并以低级 JavaScript 和 HTML 的形式提取网络图。
安装 Pyvis 库简单明了，可以使用下面的命令在系统的命令提示符下使用 pip 命令完成。
代码实现
现在让我们继续使用 Python 编程语言中的 Pyvis 库来实现交互式网络图的代码。我们将从使用下面的代码片段导入所有必要的库/模块开始。
from pyvis import network as net
from IPython.core.display import display, HTML
import random
我们将从创建一个只有节点而没有边的网络图开始。空图的创建可以使用 Network 函数来完成，该函数指定其中网络图的属性，包括背景颜色、标题、高度和宽度。
接下来，我们将利用add_node函数向网络图添加节点。我们将添加 10 个节点(从 1 到 10)，然后将网络图转换为 HTML 格式，以增加交互性并保存 HTML 文件。
g_only_nodes = net.Network(height='600px',width='90%',
bgcolor='white',font_color="red",
heading="Networkx Graph with only Nodes")
for i in range(1,11):
g_only_nodes.add_node(i)
g_only_nodes.show('Only_Nodes.html')
display(HTML('Only_Nodes.html'))
看看只有节点的网络图是什么样子的。
创建网络图的下一步是在节点之间添加边。我们将在随机节点之间添加随机边。下面同样来看看这个功能。
def generate_edge():
s = random.randint(1,10)
d = random.randint(1,10)
return (s,d)
在函数中，我们将使用random.randint函数生成随机的源和目的节点对。我们将得到 1 到 10 之间的随机节点。以确保我们有足够的优势；我们将生成 20 条随机边。为了确保同一条边不会反复出现，我们将记录(源、目的地)节点对。看看下面的代码。
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'))
添加边之后，我们将得到一个类似下图的网络图。看看网络图变得多么神奇，多么具有互动性！
结论
Pyvis 是一个强大的 python 模块，用于使用 Python 编程语言可视化和交互式操作网络图。我希望您能够使用该库构建网络图，并喜欢与这些图进行交互。
感谢您的阅读！
编码快乐！😃
也可阅读:Python 中的网络分析——完全指南
NetworkX 包–Python 图形库
原文：https://www.askpython.com/python-modules/networkx-package
NetworkX 包是一个用于研究图形和网络的 Python 库。它提供了创建、操作和研究动态复杂网络结构的工具。使用 NetworkX，我们可以加载和存储多种数据格式的网络，生成多种类型的随机和经典网络，分析网络结构，构建网络模型，设计新的网络算法，绘制网络，等等。在本教程中，我们将学习如何使用 NetworkX 来创建图形和研究网络。
导入 NetworkX 包
为了使用 NetworkX 包，我们需要将它下载到本地机器上。您可以使用 pip 命令下载它。
pip install networkx
然后您可以像下面这样导入库。
import networkx as nx
向图中添加节点
首先，我们将通过调用如下所示的Graph()类来创建一个空图。
G = nx.Graph()
NetworkX 中的节点可以是任何可散列的对象，即整数、文本串、图像、XML 对象等。它也可以是网络 x 图。在图中添加节点有两种方法。
- add_node(): 该方法用于一次添加 1 个单节点。
- add _ nodes _ from():该方法采用 list、set 等可迭代容器，同时添加多个节点。
import networkx as nx
G = nx.Graph()
G.add_node(1)
G.add_nodes_from([2,3,"node 5"])
print(G.nodes())
[1, 2, 3, 'node 5']
向图表添加边
边是两个节点之间的链接。这两种方法主要用于给图添加边。参数中指定的未知节点会自动添加到图形中。
- add_edge(): 该方法一次添加一条边。
- add _ edges _ from():该方法采用一个可迭代的边元组容器，如链表、迭代器等。
再次向图中添加一个节点或一条边将被 NetworkX 忽略。
import networkx as nx
G = nx.Graph()
# Adding one edge at a time
# Node 1 and 2 will be automatically added
G.add_edge(1,2)
G.add_edge(3,2)
# Adding multiple edges at a time
G.add_edges_from([(4,2), (3,5), (5,4)])
# Adding duplicates will be ignored.
G.add_node(1)
G.add_edge(1,2)
print(G.nodes())
print(G.edges())
[1, 2, 3, 4, 5]
[(1, 2), (2, 3), (2, 4), (3, 5), (4, 5)]
从图中删除节点和边
与添加节点和边类似，我们可以一次删除单个节点和边，也可以一次删除多个节点和边。
- remove_node(): 该方法从图中删除一个节点以及与该节点相关联的边。如果图中不存在该节点，它将引发
NetworkXError。 - remove _ nodes _ from():该方法采用一个可迭代容器，从图中删除所有节点和与这些节点相关联的边。如果任何节点在图中不存在，它将默默地丢弃它，不做任何更改。
- remove_edge(): 该方法从图中删除一条边，保持节点不变。如果图中不存在边，它会提高
NetworkXError。 - remove _ edges _ from():这个方法采用一个可迭代的容器，从图中移除边。如果图中不存在任何边，它将默默地丢弃它，不做任何更改。
import networkx as nx
G = nx.Graph()
# Creating graph
G.add_edges_from([(1, 2), (2, 3), (3, 4), (4, 1)])
G.add_edges_from([(5, 6), (5, 7), (5, 8), (7, 8)])
print(G.nodes())
print(G.edges())
# Removing edge 1-2 from graph
G.remove_edge(2, 1)
# Removing edge 3-4 and 1-4 at once
G.remove_edges_from([(3, 4), (1, 4)])
print()
print(G.nodes())
print(G.edges())
# Removing node 5 from graph
G.remove_node(5)
# Removing node 7 and 8
G.remove_nodes_from([7,8])
print()
print(G.nodes())
print(G.edges())
[1, 2, 3, 4, 5, 6, 7, 8]
[(1, 2), (1, 4), (2, 3), (3, 4), (5, 6), (5, 7), (5, 8), (7, 8)]
[1, 2, 3, 4, 5, 6, 7, 8]
[(2, 3), (5, 6), (5, 7), (5, 8), (7, 8)]
[1, 2, 3, 4, 6]
[(2, 3)]
访问图的元素
我们可以在 NetworkX 图形中访问 4 个基本图形属性。
- G.nodes: 返回图中的节点列表。
- G.edges: 返回图中的边列表。
- G.adj: 返回所有节点的邻接表。节点 X 的邻接表包含直接链接到节点 X 的相邻节点，你可以使用下标符号(在
G.adj后使用方括号)访问一个节点的所有相邻节点。 - G.degree: 返回图中每个节点链接的节点数。您可以使用下标符号(在
G.degree后使用方括号)来访问节点的度数。
import networkx as nx
G = nx.Graph()
G.add_edges_from([(1,2), (1,3), (3,4), (3,5)])
print("Nodes")
print(G.nodes)
print("Edges")
print(G.edges)
print("Adjacency List")
print(G.adj)
print("Degree")
print(G.degree)
print()
print("Adjacency List for node 3")
print(G.adj[3])
print("Degree for node 3")
print(G.degree[3])
Nodes
[1, 2, 3, 4, 5]
Edges
[(1, 2), (1, 3), (3, 4), (3, 5)]
Adjacency List
{1: {2: {}, 3: {}}, 2: {1: {}}, 3: {1: {}, 4: {}, 5: {}}, 4: {3: {}}, 5: {3: {}}}
Degree
[(1, 2), (2, 1), (3, 3), (4, 1), (5, 1)]
Adjacency List for node 3
{1: {}, 4: {}, 5: {}}
Degree for node 3
3
图形、节点和边的属性
每个图、节点和边都可以在关联的属性字典中保存键/值属性对。默认情况下，这些是空的，但是可以使用add_edge、add_node或直接操作图形G的属性字典G.graph、G.nodes和G.edges来添加或更改属性。
1.图表属性
您可以在使用nx.Graph()创建图形时为其分配属性。
import networkx as nx
G = nx.Graph(graph_description = "This is an empty graph")
print(G.graph)
# Output: {'graph_description': 'This is an empty graph'}
或者您可以像字典对象一样在以后添加/修改属性
import networkx as nx
G = nx.Graph()
G.graph["description"] = "This is empty graph"
G.graph["data"] = 5
print(G.graph)
# Output: {'description': 'This is empty graph', 'data': 5}
2.节点属性
您可以使用add_node()、add_nodes_from()或G.nodes为节点添加属性。您可以使用G.nodes.data()获得所有节点的属性。对于特定节点，使用方括号，如图所示。
import networkx as nx
G = nx.Graph()
# Using add_node
G.add_node(1, data = "data1")
# Using add_nodes_from
G.add_nodes_from([(2, {"data": "data2"}),
(3, {"data": "data3"})],
node_type = "child node")
# Adding more attributes on node 1 using G.nodes
G.nodes[1]["type"] = "root node"
print(G.nodes.data())
# Output: [(1, {'data': 'data1', 'type': 'root node'}), (2, {'node_type': 'child node', 'data': 'data2'}), (3, {'node_type': 'child node', 'data': 'data3'})]
print(G.nodes[1])
# Output: {'data': 'data1', 'type': 'root node'}
3.边属性–制作加权图
您可以使用add_edge()、add_edges_from()、G.edges或下标符号为边添加属性。通过给边分配属性，我们可以创建一个如图所示的加权图。
import networkx as nx
G = nx.Graph()
# Using add_edge
G.add_edge(1, 2, weight = 50)
# Using add_edges_from
G.add_edges_from([
(1, 3, {"weight": 70}),
(1, 4, {"weight": 100})
])
# Using subscript notation
G.add_edge(4,5)
G[4][5]["weight"] = 175
# Using G.edges
G.edges[1, 2]["weight"] = 10
print(G.edges.data())
# Output: [(1, 2, {'weight': 10}), (1, 3, {'weight': 70}), (1, 4, {'weight': 100}), (4, 5, {'weight': 175})]
可视化 NetworkX 软件包图表
我们可以使用如图所示的draw()方法在 NetworkX 包中绘制图形并可视化它们。
import networkx as nx
G = nx.Graph()
# Using add_edge
G.add_edge(1, 2, weight = 12.5)
G.add_edge(3, 2, weight = 50.0)
G.add_edge(1, 3, weight = 17)
G.add_edge(4, 2, weight = 100)
G.add_edge(2, 5, weight = 1)
G.add_edge(4, 6, weight = 25.5)
G.add_edge(7, 4, weight = 175)
G.add_edge(5, 8, weight = 90)
nx.draw(G, with_labels= True, font_weight='bold')
NetworkX Graph Visualization
如果您想绘制带权重的图形，使用draw_networkx_edge_labels()和nx.draw()指定图形、位置和边缘标签属性
import networkx as nx
import matplotlib.pyplot as plt
G = nx.Graph()
# Using add_edge
G.add_edge(1, 2, weight = 12.5)
G.add_edge(3, 2, weight = 50.0)
G.add_edge(1, 3, weight = 17)
G.add_edge(4, 2, weight = 100)
G.add_edge(2, 5, weight = 1)
G.add_edge(4, 6, weight = 25.5)
G.add_edge(7, 4, weight = 175)
G.add_edge(5, 8, weight = 90)
pos=nx.circular_layout(G)
nx.draw(G, pos, with_labels=True, font_weight='bold')
edge_weight = nx.get_edge_attributes(G,'weight')
nx.draw_networkx_edge_labels(G, pos, edge_labels = edge_weight)
plt.show()
NetworkX Graph Visualization With Weights
使用 NetworkX 包创建有向图
NetworkX 还允许您使用DiGraph()类创建有向图，该类提供了针对有向边的附加方法和属性，例如DiGraph.out_edges、DiGraph.in_degree、DiGraph.predecessors()、DiGraph.successors()等。
import networkx as nx
DG = nx.DiGraph()
DG.add_edges_from([(1,2), (2,3), (3,4), (4,5), (5,2), (4, 6)])
# Print edges going out from node 4
print("Out edges of node 4 are:",DG.out_edges(4))
# Print in degree of node 2
print("In Degree of node 2 is:",DG.in_degree(2))
# Print successors of node 4
print("Successors of node 4 are:",list(DG.successors(4)))
# Print predecessors of node 2
print("Predecessors of node 2 are:",list(DG.predecessors(2)))
nx.draw(DG, with_labels= True, font_weight='bold')
Out edges of node 4 are: [(4, 5), (4, 6)]
In Degree of node 2 is: 2
Successors of node 4 are: [5, 6]
Predecessors of node 2 are: [1, 5]
NetworkX Directed Graph
结论
在本教程中，您了解了 NetworkX 包以及如何使用它来创建、操作和可视化图形。这个库对研究复杂的网络和图形很有帮助。它被数学家、物理学家、生物学家、计算机科学家等用于研究。
感谢阅读！！
Python 中的神经网络——初学者的完整参考
原文：https://www.askpython.com/python/examples/neural-networks
神经网络是一组处理数学计算的相互连接的神经元，并且由于它们在人工智能领域中的成功应用而获得了广泛的流行。在本教程中，您将学习如何使用 Tensorflow 简单实现一个可以识别图像中数字的神经网络。
什么是神经网络？
神经网络是一种用于机器学习的强大学习算法，它提供了一种逼近复杂函数的方法，并尝试学习数据和标签之间的关系。神经网络受到人脑工作的启发，并模仿其运作方式。
神经元
受生物神经元的启发，单个人工神经元是一个树状结构，由输入节点、单个输出和其他组件组成，如下所示:
Artificial Neuron
单个神经元中涉及的组件有:
- 输入节点: 输入节点包含实数值形式的信息。这个信息由神经元处理。
- 权值: 在单个输入节点和神经元之间，存在一个与其相关联的权值的连接，该权值决定了将要传递给神经元的信息的比例。这些权重是由神经网络学习以学习关系映射的参数。
- 求和: 在下一步中，将所有输入节点及其相关权重集合在一起，并计算加权和，即
***y[sum] = Σ Wj*Ij***或**y[sum] = W[1]*I[1] + W[2]*I[2] + ... + W[n]*I[n]**。 - 激活函数: 求和的结果将被输入到一个叫做激活函数的函数中。激活函数使用计算出的加权和 来决定神经元是否应该激活自己。 这一步的输出
y = f(y[sum])其中***f()***是激活函数。 - 输出节点: 激活函数的结果传递给神经网络中存在的其他神经元。
层
神经网络中的一层由相同类型的节点/神经元组成。它是神经元的堆叠集合。为了定义全连接神经网络中的层，我们指定层的两个属性:
- 单位: 一层中存在的神经元数量。
- 激活函数: 触发层内存在神经元的激活函数。常用的激活功能有:
- ReLU 激活: 整流线性单位(ReLU)函数如果值为正则返回相同值，否则返回 0。这是一个非线性激活函数。
- Sigmoid 激活: Sigmoid 函数将一个值从范围(-∞，∞)映射到(0，1)。sigmoid 函数广泛用于二元分类问题，在这种情况下，我们只有 2 个类别要预测，并且表示其中一个类别的概率。
- Softmax 激活:soft max 函数计算 n 个事件的概率分布。它取 n 个值，并将每个值转换为 0–1，表示其出现的概率。它用于多类分类，其中我们有两个以上的类别要预测。
神经网络
当多个层以某种方式连接时，就形成了一个神经网络。因此，神经网络是多层的堆叠集合。根据需要，层可以以线性方式以及树状结构连接。
神经网络的第一层称为输入层，神经网络给出输出的最后一层称为输出层，所有其他中间层称为隐藏层。
定义神经网络需要 3 个属性:
- 架构: 你在神经网络中使用的层数和类型，以及你如何连接它们来定义神经网络的架构。神经网络的不同结构给出不同的结果。
- 损失函数:损失函数告诉我们的模型如何找到实际值和模型预测值之间的误差。我们希望我们的模型最小化损失函数的值。常用的损失函数有:
- 优化器: 优化器通过查看数据和损失函数值告诉我们的模型如何更新模型的权重/参数。常用的优化器有:
如何制作一个神经网络？
在本教程中，我们将使用 Tensorflow 模块在 python 中制作一个可以对图像中出现的数字进行分类的神经网络。
1.导入模块
首先，我们将导入实现中使用的模块。我们将使用 Tensorflow 来制作神经网络，使用 Matplotlib 来显示图像和绘制指标。
import tensorflow as tf
import matplotlib.pyplot as plt
2.探索数据
接下来，我们将在笔记本中加载数据集，并检查其外观。我们将使用已经存在于我们的 Tensorflow 模块中的 MNIST 数据集，可以使用 API tf.keras.dataset.mnist访问该数据集。
MNIST 数据集由 60，000 幅训练图像和 10，000 幅测试图像以及表示图像中存在的手指的标签组成。每个图像由 28×28 灰度像素表示。我们将使用load_data()方法加载数据集。
mnist = tf.keras.datasets.mnist
(train_images, train_labels) , (test_images, test_labels) = mnist.load_data()
让我们看看上面的变量的形状，以及我们的数据集看起来像什么
# Printing the shapes
print("train_images shape: ", train_images.shape)
print("train_labels shape: ", train_labels.shape)
print("test_images shape: ", test_images.shape)
print("test_labels shape: ", test_labels.shape)
# Displaying first 9 images of dataset
fig = plt.figure(figsize=(10,10))
nrows=3
ncols=3
for i in range(9):
fig.add_subplot(nrows, ncols, i+1)
plt.imshow(train_images[i])
plt.title("Digit: {}".format(train_labels[i]))
plt.axis(False)
plt.show()
MNIST Dataset
3.预处理数据
在移动数据来训练神经网络之前，你应该总是对数据进行预处理。预处理数据集使其可以作为机器学习模型的输入。
我们数据集中的图像由 0–255 范围内的灰度像素组成。如果数据集使用的值范围较小，机器学习模型会工作得更好。因此，我们将其除以 255，将其范围转换为 0–1。
我们还将我们的标签从数字标签转换为独热编码向量。独热编码向量是标签的二进制向量表示，其中除了值为 1 的相应标签的索引之外，所有元素都为 0。我们将使用to_categorical()方法将标签转换为一个热点。
例如，对于标签 2，索引 2 将有 1，其余都将是 0。([ 0 0 1 0 0 0 0 0 0 0 ])。
# Converting image pixel values to 0 - 1
train_images = train_images / 255
test_images = test_images / 255
print("First Label before conversion:")
print(train_labels[0])
# Converting labels to one-hot encoded vectors
train_labels = tf.keras.utils.to_categorical(train_labels)
test_labels = tf.keras.utils.to_categorical(test_labels)
print("First Label after conversion:")
print(train_labels[0])
它的输出是:
First Label before conversion:
5
First Label after conversion:
[0\. 0\. 0\. 0\. 0\. 1\. 0\. 0\. 0\. 0.]
4.构建你的神经网络
构建神经网络需要两个步骤:配置层和编译模型。
设置图层
这将是我们模型的架构:
- 展平图层: 我们输入的图像是 2D 数组。Flatten layer 通过一个接一个地拆分行，将 2D 数组(28 x 28 像素)转换为 1D 数组(0 像素)。这一层只是改变数据形状，没有学习参数/权重。
- 隐层: 我们唯一的隐层由一个全连通的密集层
512个节点(或神经元)组成，每个节点都具有relu个激活函数。 - 输出层: 神经网络的输出层由一个具有 10 个输出神经元的密集层组成，输出 10 个概率，每个概率对应于数字 0-9，表示图像是相应数字的概率。输出层被赋予
softmax激活函数，以将输入激活转换为概率。
Neural Network Architecture
由于每一层的输出只输入到一个层，并且所有的层都以线性方式堆叠，我们将使用Sequential() API，它接受一系列依次出现的层。
# Using Sequential() to build layers one after another
model = tf.keras.Sequential([
# Flatten Layer that converts images to 1D array
tf.keras.layers.Flatten(),
# Hidden Layer with 512 units and relu activation
tf.keras.layers.Dense(units=512, activation='relu'),
# Output Layer with 10 units for 10 classes and softmax activation
tf.keras.layers.Dense(units=10, activation='softmax')
])
编译模型
在我们训练我们的模型之前，我们需要告诉我们的模型一些事情。下面是在模型编译步骤中赋予模型的 3 个属性:
- 损失函数: 这告诉我们的模型如何找到实际标签和模型预测的标签之间的误差。该指标衡量我们的模型在训练过程中的准确性。我们希望我们的模型最小化这个函数值。我们将为我们的模型使用
categorical_crossentropy损失函数。 - 优化器: 这告诉我们的模型如何通过查看数据和损失函数值来更新模型的权重/参数。我们将为我们的模型使用
adam优化器 - 指标 (可选):它包含一个用于监控训练和测试步骤的指标列表。我们将使用我们的模型正确分类的图像的准确性或数量。
model.compile(
loss = 'categorical_crossentropy',
optimizer = 'adam',
metrics = ['accuracy']
)
5.训练神经网络
训练神经网络需要大量样板代码，包括正向传播、使用损失函数寻找损失、反向传播错误以及使用优化器更新权重。然而，像 Tensorflow 这样的框架会为您处理所有这些事情。
为了训练我们的神经网络，我们将在model上调用fit()方法，该方法需要:
- 训练数据: 在这里，我们将使用由图像组成的
train_images，这些图像将被输入到神经网络中。 - 训练标签: 在这里，我们将使用由标签组成的
train_labels来表示我们的训练图像的输出。 - 历元: 历元是我们的模型将在所有训练样本上迭代的次数。例如，如果我们指定 10 个时期，那么我们的模型将在所有 60，000 个训练图像上运行 10 次。
fit()方法返回一个历史对象，该对象包含每个时期后编译期间指定的丢失值和度量。
history = model.fit(
x = train_images,
y = train_labels,
epochs = 10
)
它的输出是:
Epoch 1/10
1875/1875 [==============================] - 8s 4ms/step - loss: 0.1994 - accuracy: 0.9412
Epoch 2/10
1875/1875 [==============================] - 8s 4ms/step - loss: 0.0818 - accuracy: 0.9745
Epoch 3/10
1875/1875 [==============================] - 8s 4ms/step - loss: 0.0529 - accuracy: 0.9836
Epoch 4/10
1875/1875 [==============================] - 9s 5ms/step - loss: 0.0372 - accuracy: 0.9883
Epoch 5/10
1875/1875 [==============================] - 8s 4ms/step - loss: 0.0270 - accuracy: 0.9915
Epoch 6/10
1875/1875 [==============================] - 9s 5ms/step - loss: 0.0218 - accuracy: 0.9928
Epoch 7/10
1875/1875 [==============================] - 8s 4ms/step - loss: 0.0169 - accuracy: 0.9942
Epoch 8/10
1875/1875 [==============================] - 9s 5ms/step - loss: 0.0139 - accuracy: 0.9953
Epoch 9/10
1875/1875 [==============================] - 9s 5ms/step - loss: 0.0122 - accuracy: 0.9961
Epoch 10/10
1875/1875 [==============================] - 8s 4ms/step - loss: 0.0104 - accuracy: 0.9966
我们得到了 99.6%的准确率，相当不错。在这里，我们可以看到，在每一步之后，我们的损耗值都在下降，精度在提高。我们还可以使用 matplotlib 以图形方式绘制这些值。
# Showing plot for loss
plt.plot(history.history['loss'])
plt.xlabel('epochs')
plt.legend(['loss'])
plt.show()
# Showing plot for accuracy
plt.plot(history.history['accuracy'], color='orange')
plt.xlabel('epochs')
plt.legend(['accuracy'])
plt.show()
Loss Value Plot
Accuracy Value Plot
6.评估神经网络
现在我们已经训练了我们的神经网络，我们想看看它在我们的模型以前没有见过的数据上表现如何。为此，我们将使用我们的测试数据集来看看它有多准确。为此，我们将在model上调用evaluate()方法。
# Call evaluate to find the accuracy on test images
test_loss, test_accuracy = model.evaluate(
x = test_images,
y = test_labels
)
print("Test Loss: %.4f"%test_loss)
print("Test Accuracy: %.4f"%test_accuracy)
313/313 [==============================] - 1s 2ms/step - loss: 0.0852 - accuracy: 0.9799
Test Loss: 0.0852
Test Accuracy: 0.9799
利用我们训练好的模型，我们还可以对新图像进行预测，并查看我们的模型在图像中识别出了什么。我们分两步进行预测:
- 预测概率: 我们将使用
model.predict()将一个图像的概率返回给其中一个类。在我们的例子中，对于单个图像，它将为每个图像返回 10 个概率，代表它是数字 0-9 的概率。 - 预测类: 现在我们有 10 个概率，概率最大的类就是模型预测的那个。为了找到这一点，我们将使用
tf.argmax()返回具有最大值的索引。
predicted_probabilities = model.predict(test_images)
predicted_classes = tf.argmax(predicted_probabilities, axis=-1).numpy()
现在你可以看到我们的模型预测了什么。您可以更改索引来查看不同测试图像的输出。
index=11
# Showing image
plt.imshow(test_images[index])
# Printing Probabilities
print("Probabilities predicted for image at index", index)
print(predicted_probabilities[index])
print()
# Printing Predicted Class
print("Probabilities class for image at index", index)
print(predicted_classes[index])
Neural Network Prediction
最终代码
import tensorflow as tf
import matplotlib.pyplot as plt
mnist = tf.keras.datasets.mnist
(train_images, train_labels) , (test_images, test_labels) = mnist.load_data()
# Printing the shapes
print("train_images shape: ", train_images.shape)
print("train_labels shape: ", train_labels.shape)
print("test_images shape: ", test_images.shape)
print("test_labels shape: ", test_labels.shape)
# Displaying first 9 images of dataset
fig = plt.figure(figsize=(10,10))
nrows=3
ncols=3
for i in range(9):
fig.add_subplot(nrows, ncols, i+1)
plt.imshow(train_images[i])
plt.title("Digit: {}".format(train_labels[i]))
plt.axis(False)
plt.show()
# Converting image pixel values to 0 - 1
train_images = train_images / 255
test_images = test_images / 255
print("First Label before conversion:")
print(train_labels[0])
# Converting labels to one-hot encoded vectors
train_labels = tf.keras.utils.to_categorical(train_labels)
test_labels = tf.keras.utils.to_categorical(test_labels)
print("First Label after conversion:")
print(train_labels[0])
# Defining Model
# Using Sequential() to build layers one after another
model = tf.keras.Sequential([
# Flatten Layer that converts images to 1D array
tf.keras.layers.Flatten(),
# Hidden Layer with 512 units and relu activation
tf.keras.layers.Dense(units=512, activation='relu'),
# Output Layer with 10 units for 10 classes and softmax activation
tf.keras.layers.Dense(units=10, activation='softmax')
])
model.compile(
loss = 'categorical_crossentropy',
optimizer = 'adam',
metrics = ['accuracy']
)
history = model.fit(
x = train_images,
y = train_labels,
epochs = 10
)
# Showing plot for loss
plt.plot(history.history['loss'])
plt.xlabel('epochs')
plt.legend(['loss'])
plt.show()
# Showing plot for accuracy
plt.plot(history.history['accuracy'], color='orange')
plt.xlabel('epochs')
plt.legend(['accuracy'])
plt.show()
# Call evaluate to find the accuracy on test images
test_loss, test_accuracy = model.evaluate(
x = test_images,
y = test_labels
)
print("Test Loss: %.4f"%test_loss)
print("Test Accuracy: %.4f"%test_accuracy)
# Making Predictions
predicted_probabilities = model.predict(test_images)
predicted_classes = tf.argmax(predicted_probabilities, axis=-1).numpy()
index=11
# Showing image
plt.imshow(test_images[index])
# Printing Probabilities
print("Probabilities predicted for image at index", index)
print(predicted_probabilities[index])
print()
# Printing Predicted Class
print("Probabilities class for image at index", index)
print(predicted_classes[index])
结论
恭喜你！现在你知道了神经网络以及如何用 python 制作一个神经网络来分类数字图像。希望你喜欢它！敬请关注，了解更多信息！
感谢阅读！
什么是 NLTK 点？
读者们好，在这篇文章中，我们将尝试理解 NLTK 中的一个名为 PUNKT 的模块。在 Python 中使用 NLTK ( 自然语言工具包)来实现自然语言处理领域下的程序。它包含各种不同用途的库，如文本分类、解析、词干分析、标记化等。
什么是 PunktSentenceTokenizer？
在 NLTK 中，PUNKT 是一个无监督的可训练模型，这意味着它可以在未标记的数据上训练(没有用识别其特征、属性或类别的信息标记的数据称为未标记数据。)
它通过使用无监督的技术为开始句子的单词、介词短语和缩写开发模型，从文本中生成句子列表。在没有投入使用之前，它必须接受目标语言中大量明文的训练。
PunktSentenceTokenizer 用在哪里？
在自然语言处理领域的任何项目中，nltk 都是最重要的模块。现在，nltk 确实有广泛的功能，但有时为了提高效率和验证输出是准确的，并且开发的模型考虑了所有情况，我们需要导入一些额外的模块。
例如，将一个长文本拆分成句子，下面是提供的输入文本和将输入拆分成不同句子的任务。
We met Miss. Tanaya Das and Mr.Rohan Singh today. They are pursuing a B.tech degree in Data Science.
作为先决条件的一部分，在开始使用程序之前，一定要记住导入 nltk 模块并下载 punkt 包以避免错误。下面是导入相同内容的代码。
import nltk
nltk.download('punkt')
Implementation
输出:
['We met Miss.',
'Tanaya Das and Mr.Rohan Singh today.',
'They are pursuing a B.tech degree in Data Science.']
代码的输出是相关的，但不完全正确。在这里，punkt 包成功地识别了缩写“Mr .”但是没有识别出缩写“Miss”后面的句点不是句子的结尾。
如前所述，这个包的主要优点是它使用了一个无监督的算法，这意味着可以训练模型，从而使整个代码更加准确。
在语料库上训练 punkt 标记器
让我们试着训练 punkt 句子标记器。首先为了训练，我们需要定义一个语料库。(包括用于自然语言处理的文本和语音数据的语料库可用于训练 AI 和机器学习系统。)
corpus = """
The word miss has multiple meanings thats the reason why its tricky for nlp to recognize it as a abbrevation.Miss. means to fail to hit something, to fail to meet something, or to feel sadness over the absence or loss of something. The word miss. has several other senses as a verb and a noun.
To miss. something is to fail to hit or strike something, as with an arrow miss. a target. If a runaway vehicle miss. a stop sign, then it doesn’t smash into it.
Real-life examples: If you throw a basketball to your friend and they don’t catch it, the ball miss. When a baseball player miss. a baseball with their bat, they try to hit the ball with the bat but fail to. A bowling ball that doesn’t knock down any pins has miss. them.
"""
一旦我们定义了相关的语料库，我们进一步使用punktTrainer()–学习 Punkt 句子边界检测中使用的参数，之后，我们使用“训练”功能从给定的文本中收集学习信息。如果 finalize 设置为 True，它将选择句子边界检测的所有参数。如果既没有执行 get params()也没有执行 finalize training()，这将被推迟。如果 verbose 为 True，将列出检测到的缩写。
Syntax: train(train_text, verbose=False)
Corpus
Screenshot 601
输出:
Abbreviation: [2.0326] miss
We met Miss. Tanaya Das and Mr.Rohan Singh today.
They are pursuing a B.tech degree in Data Science.
通过这种方式，我们成功地训练了模型来识别单词“Miss ”,并且不会将它后面的句点误解为句子的结尾。同样，我们可以定义语料库，并训练一个无监督的模型来学习其他缩写词、首字母缩写词等。使用punktTrainer()可以做到这一点。
摘要
自然语言处理是人工智能下理解人类语言结构和意义的广阔领域。在 python 中，我们使用 nltk(自然语言工具包)来实现它。punkt 是 nltk 中的一个模块。Punkt 以无监督的方式从语料库中学习与目标领域相关的参数，例如缩写、首字母缩写等的列表。
参考
https://www.nltk.org/api/nltk.tokenize.punkt.html
https://stack overflow . com/questions/4576077/how-can-I-split-a-text-into-sentences
如何在 Python 中规范化数据——您需要知道的一切
原文：https://www.askpython.com/python/examples/normalize-data-in-python
读者你好！在这篇文章中。我们将关注如何在 Python 中规范化数据。那么，让我们开始吧。
什么是正常化？
在开始正常化之前，让我们先了解一下它的必要性！！
特征缩放是数据分析和准备建模数据的重要步骤。其中，我们使数据无标度，以便于分析。
归一化是特征缩放技术之一。当数据在任一轴上偏斜时，即当数据不符合高斯分布时，我们特别应用归一化。
在归一化中，我们将不同尺度的数据特征转换为一个共同的尺度，这进一步使得数据易于处理用于建模。因此，所有的数据特征(变量)对建模部分都有相似的影响。
根据下面的公式，我们通过从数据变量中减去最小数据值，然后除以变量的范围来标准化每个特征，如下所示
Normalization
因此，我们将这些值转换到【0，1】之间的范围。现在，让我们在下一节中尝试用 Python 实现规范化的概念。
Python 中规范化数据的步骤
Python 中有各种方法，我们可以通过它们来执行规范化。
今天，我们将使用一种最流行的方式——minmax scaler。
让我们先来看看我们将要扩展的数据集。
数据集:
Dataset For Normalization
此外，我们将在 sklearn 中使用最小和最大缩放来执行标准化。
举例:
import pandas as pd
import os
from sklearn.preprocessing import MinMaxScaler
#Changing the working directory to the specified path--
os.chdir("D:/Normalize - Loan_Defaulter")
data = pd.read_csv("bank-loan.csv") # dataset
scaler = MinMaxScaler()
loan=pd.DataFrame(scaler.fit_transform(data),
columns=data.columns, index=data.index)
print(loan)
在这里，我们创建了一个MinMaxScaler() 类的对象。此外，我们使用了fit_transform() method来标准化数据值。
输出:
因此，可以清楚地看到，我们已经转换并标准化了 0 和 1 范围内的数据值。
Dataset After Normalization Using MinMaxScaler
摘要
因此，从上述解释中，可以得出以下见解
- 当数据值偏斜且不遵循高斯分布时，使用归一化。
- 数据值在 0 和 1 的范围内转换。
- 标准化使数据无标度。
结论
到此，我们就到了本文的结尾。如果你遇到任何问题，请随时在下面评论。
在那之前，请继续关注@ Python 和 AskPython 并继续学习！！
Python 中的“非”布尔运算符
布尔运算符从一个或多个输入值生成单个布尔输出值。布尔代数中有三种布尔运算符: 和 、或、非。Python 使用and、or和not来实现它们。我们将在本教程中学习 Python 的 not 操作符。
不是运算符
它用于得到一个值的否定，即它允许我们反转一个给定布尔表达式的真值。该操作符可应用于布尔情况，如 if 语句和 while 循环。它在非布尔设置中也起作用，使您能够反转变量的真值。
下表显示了对某些输入值应用 not 运算符时的结果。
| 输入 | 输出 |
| 真实的 | 错误的 |
| 错误的 | 真实的 |
not是一元运算符，这意味着它只接受一个输入值。它可以用于任何布尔表达式或 Python 对象。
对不同的数据类型使用 not
not with Different Data Types
在条件语句中使用 not
让我们看看 Python 中的 not 操作符是如何处理不同类型的条件语句的。
如果语句
num = 25
if not num%2==0:
print("num is an odd number")
else:
print("num is an even number")
输出:
num is an odd number
在这里，num%2 即 25%2 等于 1 而不是 0。if语句检查 num%2==0 是否为假。因为条件满足，所以输出说数字是奇数。如果是偶数的话，else条件就满足了。
while 循环
count = 1
while not count>5:
print(count)
count = count + 1
输出:
1
2
3
4
5
条件 count>5 检查记录数是否大于 5。while循环执行到count小于 5。一旦count的值变为 6，循环将终止。
Python 中实现 not 布尔运算符的方法
方法 1:使用“not”关键字
var = False
print(not var)
输出:
True
var = True
print(not var)
输出:
False
以上是在 Python 中使用not关键字的简单例子。
方法 2:使用“~”运算符
~ '称为求反运算符。
flag = True
print("Flag is ", flag)
print("Flag is ", bool(~flag))
输出:
Flag is True
Flag is False
在本例中，首先将flag设置为True，并打印其值。在下一行中，我们首先通过写~flag得到flag的否定，我们已经写了bool(~flag)，因为如果该标志最初不是布尔值，那么它将被转换为布尔值。
方法 3:使用操作员模块
Python 中的运算符模块提供了各种方法，如加、减、取幂、左移、右移等。这些众多方法中的一种就是not_()。它返回提供给它的参数的取反值。
import operator
initial_list = [False, True, True, False]
print("Initial list:", initial_list)
negated_list = []
for i in range(0, len(initial_list)):
negated_list.append(operator.not_(initial_list[i]))
print("Negated list:", negated_list)
输出:
Initial list: [False, True, True, False]
Negated list: [True, False, False, True]
这里，我们首先导入了操作符模块。然后我们创建了一个布尔值列表。该循环遍历“初始列表”，使用来自运算符模块的not_()方法对每个值求反，并将其附加到“求反列表”中。
方法 4:使用 NumPy 中的 bitwise_not()方法
Numpy 提供了一个bitwise_not()方法来寻找一个值的反值。它对其参数执行按位非运算。
import numpy as np
print(np.bitwise_not(True))
print(np.bitwise_not(False))
输出:
False
True
上面的代码使用bitwise_not()方法只求单个值的反。我们也可以使用 NumPy 元素数组，如下所示。
import numpy as np
a = np.array([True, False, False])
a = np.bitwise_not(a)
print(a)
输出:
[False True True]
方法 5:使用 NumPy 中的 invert()方法
此方法还对传递给它的参数执行按位 NOT 运算。它可以用于单个元素或元素数组。
import numpy as np
print(np.invert(False))
print(np.invert(True))
输出:
True
False
再比如:
import numpy as np
a = [True, False, False]
a = np.invert(a)
print(a)
输出:
[False True True]
方法 6:使用 NumPy 中的 logical_not()方法
这种方法也可以用来寻找一个布尔值的否定。就像 bitwise_not()和 invert()方法一样，该方法也可以应用于两者，一个参数或一组参数，如下所示。
import numpy as np
print(np.logical_not(False))
print(np.logical_not(True))
输出:
True
False
再比如:
import numpy as np
a = [True, False, True]
a = np.logical_not(a)
print(a)
输出:
[False True False]
结论
仅此而已！我们已经学习了 not 操作符，以及在 Python 中使用它的不同方式。
Python 中什么是“不真实”？
原文：https://www.askpython.com/python/examples/not-true-in-python
在本文中，我们将讨论 Python 中的非真概念。总的来说，这不是一个无聊的讲座，而是我们只是在完善我们的基础知识。
Python 中的运算符和关键字
Python 有大量的操作符。这就是为什么与其他编程语言不同，它的语法相对简单。下面是 Python 中的操作符列表:
- +:加号
- –:减号
- =:赋值运算符
- ==:等于运算符
- ！=:不等于
- < =:小于或等于
-
=:大于或等于
- %:模数
- //:楼层划分
- -=:减量
- +=:增量
- /=:除
- %=:模数
这些支持算术运算，但最重要的是，我们还有一些其他的逻辑运算:
- &:和
- |:或者
- 不
另外，看看布尔运算:
- 真
- 假
我们可以像使用关键字一样使用逻辑操作符。但是，在 Python 中，我们没有任何运算符用于 not 或 complement 。显然，还有！=" 但适合小型操作。对于复杂的操作，我们可以使用“not”关键字使事情变得简单。
Python 中“非”的意义
光是这个例子就足以证明而不是是多么有用:
预测 while 循环是否运行
代码:
condition = not True
while(condition):
print("Hello world")
代码不会运行。当且仅当括号内的条件为真时， while 循环迭代代码。这里条件不为真意味着它为假。如果您在空闲状态下运行这个小代码片段，那么输出也将为 False。
>>> not True
False
所以，这就是 not 运算符的意义。
Python 中“真”的意义
True 是 Python 中的布尔运算符。其意义在于，人们可以设置标志、运行循环以及用它做更多的事情。让我们看一个例子:
在屏幕上打印 n 次“hello”。
while True:
print("Hello")
输出:
Hello
Hello
Hello
Hello
...
...
Runtime Error occurred
最后一条消息是“发生运行时错误”。这意味着当我们使用 True 无限运行循环，并且没有循环控制语句时，它会继续执行这段代码 n 次。这是需要注意的。
not 和 True 一起使用
这里我们将构建一个代码来检查每个数字，并打印出它是否是质数。
num = int(input("Enter a number: "))
isPrime = not True
num_sqrt = int(num**0.5)
if(num > 1):
for i in range(2, num_sqrt + 1):
if (num % i == 0):
isPrime = True
break
if (isPrime == (not True)):
print("%d is prime" %(num))
else:
print("%d is composite" %(num))
else:
print("%d is composite" %(num))
输出:
>>> Enter a number: 39
39 is not prime
>> Enter a number: 17
17 is prime
说明:
- 首先，接受 num 的输入。
- 然后设置一个名为 isPrime 的变量。这只是一个指示器，最初指示一个值不为真。
- 然后我们取这个数的平方根。
- 然后我们放一个条件，如果数大于 1。它运行一个循环，从 2 迭代到(数字的平方根+1)。
- 然后对于每次迭代，我们检查这个数是否能被它自己整除。如果是，则指示符 isPrime 被设置为真。这意味着这个数是质数。
- 如果不是这种情况，那么数字是合成的。
在这里，不真实和虚假一起起作用。解释的主要动机是我们可以用它来代替 False 。
结论
这样，我们可以一起使用不真实的概念，希望这篇文章是有帮助的，我们开始知道，我们可以灵活地使用 Python 的概念，为我们的利益。
Numba:让你的 python 代码快 100 倍
Numba 是一个用于 Python 数组和数值函数的编译器，它让您能够使用直接用 Python 编写的高性能函数来加速您的应用程序。
是什么让 python 变慢的？
Python 已经被用于科学计算很长一段时间了。尽管 python 是一种很好的原型语言，但准系统 Python 缺乏进行如此巨大计算的优势。具有讽刺意味的是，使 python 天生缓慢的是使 Python 作为一种语言如此流行的特性。让我们逐一回顾一下:
- 动态类型 : Python 是一种动态类型语言，即用户不需要指定与变量相关的数据类型。虽然这在表面上使事情变得简单了许多，但内部机制却变得复杂了许多倍，因为解释器需要在每次操作完成时检查数据类型和相关的转换。这些增加的、复杂的指令主要负责 python 的速度。
- 内存开销:由于 Python 的灵活性，需要为每个小对象分配单独的内存，比如一个列表中的 int(不像 C 为一个数组占用一个连续的内存块)。这意味着列表中的对象在内存中的位置并不相邻，这会影响每次获取操作的时间开销。
Python memory cost for list compared to numpy implementation of arrays.
- 非编译:类似 LLVM、GCC 这样的编译器，可以对程序进行前瞻，做一些高层的优化，既节省内存又节省速度。另一方面，Python 解释器不知道下一行执行，所以它不能应用任何节省时间的优化。
- GIL 锁:全局解释器锁(GIL)不允许多线程。它确保只有一个线程执行 Python 字节码。这简化了 CPython 的实现，因为它使得对象模型对于并发访问是隐式安全的。
在本文中，我们将看到 numba 如何克服这些困难，以及如何使用它来加速我们的代码达到 C/C++和 FORTRAN 之类的水平。
什么是 Numba？
根据官方文档，“Numba 是一个针对 Python 的即时编译器，最适合使用 NumPy 数组和函数以及循环的代码”。JIT 编译器是提高解释语言性能的有效方法之一。在程序执行期间，LLVM 编译器将代码编译成本机代码，这通常比代码的解释版本快得多。如前所述，编译器可以添加一些高级优化，这对用户在内存和速度方面都有好处。
Numba 附带了 Anaconda 发行版，也有轮子，所以它可以由
conda install numba
或者，
pip install numba
注意: Linux 用户可能需要使用 pip3 而不是 pip 。
在 Python 中使用 Numba
Numba 使用函数装饰器来提高函数的速度。重要的是，用户必须将计算包含在函数中。numba 中使用最广泛的装饰器是@jit 装饰器。使用这个装饰器，您可以通过 Numba 的 JIT 编译器为优化标记一个函数。让我们看一个平凡函数的用例。
from numba import jit
import numpy as np
@jit # Placing the @jit marks the function for jit compilation
def sum(a, b):
return a + b
Numba 将保存编译直到第一次执行。在第一次执行期间，numba 将推断输入类型，并根据该信息编译代码。编译器还添加了一些特定于该输入数据类型的优化。这样做的直接后果是，对于不同类型的变量，函数将有不同的执行代码。
用户第一次执行该功能时可能会有一些延迟。这种明显的时间差距是由于函数的编译。编译后，用户可以期待 numba 编译函数的正常速度。一个常见的技巧是在第一次执行代码时使用一个小的虚拟变量。
注意:不要改变函数内部变量的数据类型。更改数据类型意味着 numba 不再能够正确地推断数据类型和优化函数。
1。渴望模式
上述方法的一个缺点是我们必须等到第一次执行编译。我们可以通过渴望模式来克服它。在急切模式中，我们指定了输入的数据类型，因此编译器不需要从输入中推断，并立即编译函数。这叫做急切执行，我们可以这样做，
@jit(int32(int32, int32))
def sum(a, b):
return a + b
编译器不再等待第一次执行，而是应用给定类型的专门化来编译代码。它允许用户越来越多地控制要使用的变量类型。
2。没有 GIL 模式
编译代码将我们从 python 全局解释器锁中解放出来。我们可以使用nogil=True指定不使用 GIL
@jit(nogil=True)
def sum(a, b):
return a + b
3。非 python 模式
有两种执行模式- nopython 和 object 模式。在 nopython 模式下，编译器在没有解释器参与的情况下执行代码。使用 numba.jit()进行编译是最好的方法。
@jit(nopython=True)
def sum(a, b):
return a + b
Numba 与 numpy 数组和函数配合得最好。下面是一个来自官方文档的使用 numpy 函数的例子。
from numba import jit
import numpy as np
x = np.arange(100).reshape(10, 10)
@jit(nopython=True)
def go_fast(a): # Function is compiled to machine code when called the first time
trace = 0.0
for i in range(a.shape[0]): # Numba likes loops
trace += np.tanh(a[i, i]) # Numba likes NumPy functions
return a + trace # Numba likes NumPy broadcasting
print(go_fast(x))
结论
与 C/C++、FORTRAN、Java 等相比，Numba 提供了更快的速度。而不影响 python 的任何语法。numba 的一个缺点是，它使 python 代码不太灵活，但允许对变量进行细粒度控制。如果您正在使用 python 进行繁重的科学模拟(需要快速处理和并行化能力)，Numba 可以让您的生活变得更加轻松。
参考
- https://numba . pydata . org/numba-doc/latest/user/5 minguide . html
- https://numba.pydata.org/numba-doc/latest/user/jit.html
用 Python 创建一个数字猜谜游戏:第 1 部分(命令行)
原文：https://www.askpython.com/python/examples/number-guessing-game-command-line
在本教程中，我们将使用标准 python 库创建一个随机数猜测游戏。本教程分为两部分——命令行界面(CLI)和图形用户界面(GUI)。
这是教程的第一部分，我们实现了游戏，并在命令行中运行它，没有任何图形视觉糖果。教程的下一部分是本教程的扩展，为游戏添加图形界面。这是一个初学者水平的项目，但对 python 非常基本的理解是期望的。
也读作: Python Hi-lo 游戏
理解猜数字游戏的规则
在我们继续编写应用程序之前，清楚地理解应用程序应该做什么以及它应该如何表现是非常重要的。
所以我们首先列出游戏的基本规则:
- 计算机会猜出 1 到 1000 之间的一个数字，你需要猜出这个数字。
- 将提供无限次数的重试，直到您猜出正确的号码。重试次数最少的人赢得游戏。
- 如果玩家选择了一个错误的数字，电脑会给用户一个提示——电脑会告诉玩家 target 是否在 0 和用户猜测的数字之间。例如:如果你选择 78，数字是 45，目标数字(45)位于 0 和 78 之间，所以计算机会相应地提示。
创建一个 Python 数字猜谜游戏
因此，让我们深入了解代码的实现。
注意:虽然这个代码库只是在 CLI 中实现的，但它将作为游戏 GUI 版本的主干。
生成 1 到 1000 之间的随机数
为了生成 1 到 1000 之间的随机数，我们将使用 python 中的随机库中的 randint()函数。
# Import the random module
import random
# Computer chooses a random number between 1 and 1000
target = random.randint(1, 1000)
用户输入一个数字
要从用户输入一个数字 a，我们将使用 input()函数
# Input the guess from the user
choice = int(input("Enter your guess: "))
现在我们有了用户输入，我们可以比较这两个数字并显示一个输出。为了让游戏继续进行，直到用户选择了正确的选项，我们必须将所有东西放入一个循环中。
循环整个过程
还有三件事我们需要注意:
- 为猜测和提示生成正确的提示:这可以使用嵌套的 if-else 块来实现。
- 计算退役次数:每次玩家做出错误选择时，取一个计数器变量并增加。
- 重复所有操作，直到做出正确的猜测:将所有操作封闭在一个无限循环中，该循环只有在做出正确的猜测时才会中断。
我们一起解决这三个子问题的是这段代码:
# Counter Variable
retries = 0
while(True):
# Taking user choice
choice = int(input("Enter your choice: "))
retries += 1
# Wrong guess
if target != choice:
print("Wrong Guess!! Try Again")
# Hint
if target < choice:
print("The required number lies between 0 and {}".format(choice))
else:
print("The required number lies between {} and 1000".format(choice))
# Correct choice
else:
print("You guessed the correct number after {} retries".format(retries))
# User guessed the correct value
# So let's end the infinite loop
break;
我们猜数字游戏的最终 Python 代码
将所有代码块放在一起，最终的 Python 程序如下所示:
# Import the random module
import random
# Computer chooses a random number between 1 and 1000
target = random.randint(1, 1000)
retries = 0
while(True):
# Taking user choice
choice = int(input("Enter your choice: "))
retries += 1
# Wrong guess
if target != choice:
print("Wrong Guess!! Try Again")
# Hint
if target < choice:
print("The required number lies between 0 and {}".format(choice))
else:
print("The required number lies between {} and 1000".format(choice))
# Correct choice
else:
print("You guessed the correct number after {} retries".format(retries))
# User guessed the correct value
# So let's end the infinite loop
break;
要运行该程序，请将其保存在 python 文件中。我们用“guessing_game.py”这个名字保存了它。您可以选择任何其他名称，但要确保扩展名为。py，表示该文件是 python 文件。
从命令行运行 python 文件。如果你愿意，你可以在你最喜欢的 IDE 中执行它。
python3 guessing_game.py
Output of the CLI version of the Guessing Game
结论
这就把我们带到了教程前半部分的结尾，在这里我们实现了游戏的命令行版本。请继续关注教程的下一部分:游戏的 GUI 版本和更多类似的 python 教程。
用 Python 创建猜数字游戏 GUI:第 2 部分
原文：https://www.askpython.com/python/examples/number-guessing-game-gui
这是教程的第二部分——用 Python 创建猜数字游戏 GUI。在的第一部分中，我们已经看到了如何在命令行界面中实现猜谜游戏。在本教程中，我们将通过制作一个可以与用户互动的图形用户界面应用程序，将它推向一个新的高度。
如果你还没有阅读前一篇文章，我建议你先阅读，因为它解释了游戏的逻辑和主要源代码实现。
猜数字游戏图形用户界面的设计
Python 为 GUI 提供了一个名为 Tkinter 的库。Tkinter 是相对轻量级的，为我们的 python 环境提供了许多基本的 3-D 交互元素。因此，在本教程中，我们将使用 Tkinter。读者应该对 Tkinter 有初级的理解。
因此，让我们为我们今天设计的应用程序绘制一个 GUI 草图。以下是 GUI 的基本布局:
- 将会有显示游戏名称的标题。
- 将有一个输入表单元素来接收数字
- 一键开始游戏
- 一键关闭 GUI。
这些列出的要点大部分都很直观，但是这种编码前的设计是一种很好的实践，有助于避免将来的混淆和误解。
导入库
我们导入必要的库。我们之前讨论的 Tkinter 将用于 GUI 创建，random 模块用于生成随机数。
import tkinter as tk
import random
创建空白窗口
首先，我们创建一个空白窗口，它有我们选择的背景，里面没有文本或交互元素。
import tkinter as tk
import random
# Create a new window
window = tk.Tk()
# Set the dimensions of the created window
window.geometry("600x400")
# Set the background color of the window
window.config(bg="#065569")
window.resizable(width=False,height=False)
# Set Window Title
window.title('Number Guessing Game')
# The code for the buttons and text and other
# interactive UI elements go here
# Start the window
window.mainloop()
Fig 1: A Blank Window like this will appear. If the window does not appear, it is a good time to check if your tkinter installation in done properly.
这是基本的草稿栏。在接下来的步骤中，我们将在该窗口中添加元素。您现在需要强制关闭窗口，因为没有关闭按钮。因此，我们的首要任务是获得一个退出按钮，它可以优雅地关闭应用程序
添加退出按钮
要添加一个按钮，我们使用 tkinter.Button()函数。
# Create exit Button
# We can customize the background(bg) and foreground(fg) color
# Here we have chosen bg to be Red for visual aesthetic
exit_button = tk.Button(window,text="Exit Game",font=("Arial",14), fg="White", bg="#b82741", command=exit)
# Place the exit button at a suitable place
exit_button.place(x=300,y=320)
Fig 2: A basic window with close functionality
注意:现在我们有了一个基本的工作退出按钮，我们可以添加其余的元素，并在不强制关闭窗口的情况下重新定位它们。
添加其余的数字猜测游戏图形用户界面
创建标签
我们需要两个标签来申请。第一个用于游戏标签，另一个用于显示结果和提示。
# Heading of our game
title = tk.Label(window,text="Guessing Game",font=("Arial",24),fg="#fffcbd",bg="#065569")
# Result and hints of our game
result = tk.Label(window, text="Click on Play to start a new game", font=("Arial", 12, "normal", "italic"),fg = "White", bg="#065569", justify=tk.LEFT)
# Display labels
title.place(x=170, y=50)
result.place(x=180, y=210)
添加按钮
我们需要 3 个按钮——Play Game、Guess和Exit按钮。为了我们的可用性，我们已经实现了Exit按钮。
# The play button
play_button = tk.Button(window, text="Play Game", font=("Arial", 14, "bold"), fg = "Black", bg="#29c70a")
# The guess button
# This button initially disabled because we don't want the user to guess a number before the game has started
guess_button = tk.Button(window,text="Guess",font=("Arial",13), state='disabled', fg="#13d675",bg="Black")
# Place the buttons in the window
guess_button.place(x=350, y=147)
play_button.place(x=170, y=320)
注意:按钮通常与点击按钮时执行的命令相关联。与按钮相关的命令将在下一节讨论。
创建表单/输入字段
最后，我们需要一个输入字段来接收用户输入的数字。我们还需要一个变量来存储表单中输入的值。
# The object that stores the value in the entry field
guessed_number = tk.StringVar()
# Create entry field and attach it the guessed_number object that stores the value
number_form = tk.Entry(window,font=("Arial",11),textvariable=guessed_number)
# Place it in the window
number_form.place(x=180, y=150)
Fig 3: The complete GUI Screen
实现逻辑
在我们做好用户界面之后。是时候回顾一下我们的游戏逻辑了。我们需要定义当我们按下猜测和播放按钮时会发生什么。因此，我们在应用程序中定义了与这两个按钮相关联的函数。
首先，我们将使用两个全局变量TARGET和RETRIES来存储目标人数和退休人数，我们将设置它们的初始值。
TARGET = 1.
RETRIES = 0
现在我们定义一个相应更新result标签的函数。
def update_result(text):
result.configure(text=text)
我们现在已经准备好定义Play和Guess按钮的功能。
播放按钮应该用正确的值重新初始化全局变量，并将Guess按钮设置为正常，这样用户可以通过按下该按钮来注册他们的输入。
def new_game():
# Change the state of guess button
guess_button.config(state='normal')
# Mention to use global variables
global TARGET, RETRIES
# Create a new target
TARGET = random.randint(0, 1000)
# Reset number of retires to 0
RETRIES = 0
update_result(text="Guess a number between\n 1 and 1000")
Guess按钮读取输入表单中的输入，并给出相应的结果和提示。如果用户给出正确的结果，猜测按钮的状态再次被设置为disabled，从而迫使用户开始新的游戏或退出应用程序，而不是猜测已经结束的游戏。
def play_game():
global RETRIES
choice = int(number_form.get())
if choice != TARGET:
RETRIES += 1
result = "Wrong Guess!! Try Again"
if TARGET < choice:
hint = "The required number lies between 0 and {}".format(result)
else:
hint = "The required number lies between {} and 1000".format(choice)
result += "\n\nHINT :\n" + hint
else:
result = "You guessed the correct number after {} retries".format(RETRIES)
# Set the state to disabled again
guess_button.configure(state='disabled')
result += "\n" + "Click on Play to start a new game"
update_result(result)
添加按钮命令
最后，我们需要给每个按钮分配命令。我们需要将command变量附加到函数调用的末尾。新的按钮定义如下所示
# Play Button
play_button = tk.Button(window, text="Play Game", font=("Arial", 14, "bold"), fg = "Black", bg="#29c70a", command=new_game)
# Guess Button
guess_button = tk.Button(window,text="Guess",font=("Arial",13), state='disabled', fg="#13d675",bg="Black", command=play_game)
最终代码
这是应用程序的最后一块代码。
import tkinter as tk
import random
# Create a new window
window = tk.Tk()
# Set the dimensions of the created window
window.geometry("600x400")
# Set the background color of the window
window.config(bg="#065569")
window.resizable(width=False,height=False)
# Set Window Title
window.title('Number Guessing Game')
# The code for the buttons and text and other
# interactive UI elements go here
TARGET = random.randint(0, 1000)
RETRIES = 0
def upate_result(text):
result.configure(text=text)
# Create a new game
def new_game():
guess_button.config(state='normal')
global TARGET, RETRIES
TARGET = random.randint(0, 1000)
RETRIES = 0
update_result(text="Guess a number between\n 1 and 1000")
# Continue the ongoing game or end it
def play_game():
global RETRIES
choice = int(number_form.get())
if choice != TARGET:
RETRIES += 1
result = "Wrong Guess!! Try Again"
if TARGET < choice:
hint = "The required number lies between 0 and {}".format(result)
else:
hint = "The required number lies between {} and 1000".format(choice)
result += "\n\nHINT :\n" + hint
else:
result = "You guessed the correct number after {} retries".format(RETRIES)
guess_button.configure(state='disabled')
result += "\n" + "Click on Play to start a new game"
update_result(result)
# Heading of our game
title = tk.Label(window,text="Guessing Game",font=("Arial",24),fg="#fffcbd",bg="#065569")
# Result and hints of our game
result = tk.Label(window, text="Click on Play to start a new game", font=("Arial", 12, "normal", "italic"),fg = "White", bg="#065569", justify=tk.LEFT)
# Play Button
play_button = tk.Button(window, text="Play Game", font=("Arial", 14, "bold"), fg = "Black", bg="#29c70a", command=new_game)
# Guess Button
guess_button = tk.Button(window,text="Guess",font=("Arial",13), state='disabled', fg="#13d675",bg="Black", command=play_game)
# Exit Button
exit_button = tk.Button(window,text="Exit Game",font=("Arial",14), fg="White", bg="#b82741", command=exit)
# Entry Fields
guessed_number = tk.StringVar()
number_form = tk.Entry(window,font=("Arial",11),textvariable=guessed_number)
# Place the labels
title.place(x=170, y=50)
result.place(x=180, y=210)
# Place the buttons
exit_button.place(x=300,y=320)
guess_button.place(x=350, y=147)
play_button.place(x=170, y=320)
# Place the entry field
number_form.place(x=180, y=150)
# Start the window
window.mainloop()
这是我们游戏的图形用户界面的一些例子。
游戏的开始实例
Fig 4: This is how the opening window looks. Notice how the Guess is darkened indicating that it has been disabled.
用户开始游戏时的 UI 实例
Fig 5: The user has started a fresh game and the Guess button is now working. The user can now register his/her guess
用户猜错时的 UI 实例
Fig 6: User guessed the number wrong. So the application prompts that it is a wrong guess and gives an interesting hint.
用户猜对数字时的 UI 实例
Fig 7: User has guess correctly using only 1 retry. Great!!!
结论
关于随机猜谜游戏的 2 部分教程到此结束。我鼓励你调整用户界面，使它更适合你的颜色和用户界面偏好。请继续关注更多这样的 python 文章。
查找没有连续 1 的可能字符串的数量
原文：https://www.askpython.com/python/examples/number-of-possible-strings
在本教程中，我们将了解一个非常有趣的问题，称为形成没有连续 1 的字符串。我们先来了解一下，在这个问题上，我们想达到什么目的？
我们有一个整数 n ，它是字符串的大小，即最终字符串中的位数。
我们的目标是得到没有连续 1 的 n 位字符串，这意味着: 11在字符串中是非法的。
现在，对于任何字符串，可能有两种情况:
如果第一个元素是 0 ，那么下一个元素可以是 0 或 1。
在另一种情况下，即，第一个元素是 1 ，那么我们对下一个元素的唯一选择是 0。
我们的目标是找到满足上述条件的所有可能字符串的计数。
如何求没有连续 1 的可能字符串的个数？
这个问题可以通过手工方式或递归方法来解决。递归方法是解决这个问题的更好、更有效、更快的技术。
如果你想知道更多关于递归的知识，请阅读下面提到的教程。
了解更多关于递归的知识:Python 中的递归
这两个案例如下:
- 第一位是 1 ，然后我们将第二位设置为 0 并检查最后一个字符串中剩余的 n-2 位。
- 第一个数字是 0 ，然后我们检查字符串中剩余的 n-1 位
首先，让我们看看从 0 开始的 n 的较低值的答案。
| n 的值 | 可能字符串的数量 |
| Zero | Zero |
| one | 2 ( 0,1) |
| Two | 3 (00,01,10) |
对于 n 大于 2 的所有情况，我们将考虑两种情况。
用 Python 实现递归
def count_no_ways(n):
if(n==0):
return 0
if(n<3):
return n+1
return count_no_ways(n-1) + count_no_ways(n-2)
n = int(input())
print(count_no_ways(n))
输出:
10
144
我希望在本教程结束时，我希望你理解了问题、解决方案和解决方案的代码实现。
感谢您的阅读！快乐学习！😇
NumPy add–以简单的方式解释
在本文中，我们将探索 NumPy add 函数。你有没有想过我们如何使用编程将两个数字或两个数字数组相加？这就是 Python NumPy 库发挥作用的地方。
在本教程中，我们将浏览函数的语法，并练习不同类型的例子。那么，我们开始吧。
什么是 NumPy add？
numpy.add() 是 NumPy 库的数学函数之一。它只是将作为输入传递给函数的值相加。
是的，从定义上来说就是这么简单🙂
让我们看看语法，了解更多关于函数的内容。
NumPy add 的语法
numpy.add(x1 , x2)
这里输入的x1****x2是 NumPy 数组的数字。
注意:在语法中，输入也可以是标量值(简单数字)和 Python 列表。
使用 NumPy add
我们准备做编程，多了解一下这个功能。
NumPy 与标量值相加
# Importing the NumPy module
import numpy as np
a = 5
b = 4
print("The sum of 5 and 4 is:",np.add(a , b))
输出
The sum of 5 and 4 is: 9
我们首先使用上面代码片段中的 import 语句导入 NumPy 库。在下面几行中，我们给变量 a 和 b 赋值。
为了计算 a 和 b 的值之和，调用函数 np.add(a , b) 。
现在让我们使用带有 NumPy 数组和一个标量值的函数，并观察输出。
NumPy 添加一个 NumPy 数组和一个标量值
import numpy as np
# Creating the 2-D array
a = np.array([[2 , 4 , 7] , [5 , 10 , 15]])
b = 5
c = np.add(a , b)
print("Input Array:\n",a)
print("After adding 5 to each value of the Input Array:\n",c)
输出
Input Array:
[[ 2 4 7]
[ 5 10 15]]
After adding 5 to each value of the Input Array:
[[ 7 9 12]
[10 15 20]]
在上面的代码片段中，使用 np.array() 创建了一个二维数组，该数组存储在变量 a 中。
接下来，我们创建了一个保存整数值 5 的变量 b 。进一步，我们使用 np.add() ，其中我们传递了 a 和 b 作为函数的参数，函数的输出存储在变量 c 中。
在输出中，我们得到了一个二维数组。如果您仔细观察输出数组，您会看到数字 5 被添加到输入数组中的每个元素。
Note: 输出数组的形状与输入数组的形状相同。
NumPy 添加两个大小相同的 NumPy 数组
在本例中，我们将添加两个大小相同的 numpy 阵列。
import numpy as np
# Creating 2x4 array
a = np.array([[2 , 5 , 7 , 3] , [1 , 4 , 5 , 12]])
b = np.array([[9 , 5 , 11 , 23] , [21 , 34 , 1 , 9]])
# Using the add function
c = np.add(a , b)
# Printing the values
print("Array 1:\n",a)
print("Array 2:\n",b)
print("Output array:\n",c)
输出
Array 1:
[[ 2 5 7 3]
[ 1 4 5 12]]
Array 2:
[[ 9 5 11 23]
[21 34 1 9]]
Output array:
[[11 10 18 26]
[22 38 6 21]]
在上面的例子中，我们创建了两个 2×4 维的 numpy 数组，即一个 2 行 4 列的数组。这些数组存储在变量a和 b 中。
在下面几行中，我们使用了函数 np.add(a , b) ，其中 a 和 b 作为参数传递给函数。函数 np.add(a,b) 将数组 a 和 b 中相同位置的值相加。
输出数组的形状与输入数组相同。现在，让我们看看文章中最有趣的例子。
NumPy 加法器具有两个不同形状 NumPy 阵列
在这个例子中，我们将看到如何将一个 1 维数字数组添加到一个 2 维数字数组中。
import numpy as np
# Creating a 1-D array
a = np.array((10 , 56 , 21))
# Creating a 2-D array
b = np.array([[1 , 4 , 6] , [23 , 12 , 16]])
c = np.add(a , b)
print("Array 1:\n",a)
print("Array 2:\n",b)
print("Output Array:\n",c)
输出
Array 1:
[10 56 21]
Array 2:
[[ 1 4 6]
[23 12 16]]
Output Array:
[[11 60 27]
[33 68 37]]
添加两个不同形状的 NumPy 数组不是很有趣吗？嗯，我们使用 NumPy 库轻松地做到了这一点。
让我们试着理解上面的片段。我们创建了一个存储在变量 a 中的 1-D NumPy 数组，另一个 2-D NumPy 数组被创建并存储在变量 b 中。
如果您仔细观察以上示例中创建的数组，您会注意到它们具有相同的列数，但行数不同。这就是术语广播发挥作用的地方。
这里，函数 np.add() 在二维数组的行之间传播一维数组。在上面的例子中， np.add() 将数组 a 的值添加到数组 b 的 row1 中，以元素为单位。类似地，对数组 b 的下一行进行相同的计算。
注意:当一维数组中的元素数与二维数组中的列数相同时，上述情况是可能的
所以，我们完成了例子🙂
摘要
在本文中，我们学习了如何对各种输入类型使用 NumPy add 函数。这是一个使用起来很简单的函数，因为它只是将输入添加到函数中。尝试使用 NumPy add 函数和 NumPy 数组的不同函数。坚持学习，快乐编码。点击了解更多文章。
NumPy amax–一个轴上数组的最大值
原文:# t0]https://www . aspython . com/python-modules/num py/numpy-amax
你好，欢迎来到这个关于 Numpy amax 的教程。在本教程中，我们将学习 NumPy amax() 方法，也将看到许多关于这个方法的例子。让我们开始吧！
什么是 NumPy amax？
NumPy 中的amax()方法是一个返回数组元素最大值的函数。它可以是所有数组元素的最大值、沿行数组元素的最大值或沿列数组元素的最大值。
在 Python 中，NaN 的意思不是数字。如果在输入数据中，任何一个元素是 NaN，那么最大值也将是 NaN。
我们将在本教程的下一节看到每个例子。
NumPy amax 的语法
numpy.amax(a, axis=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)
| 参数 | 描述 | 必需/可选 |
| (类似数组) | 输入数据。 | 需要 |
| 轴 | 沿其计算数组最大值的轴。可以是 axis=0 或 axis=1 或 axis=None，这意味着要返回整个数组的最大值。
如果轴是整数元组，则在元组中指定的所有轴上计算最大值，而不是像以前一样在单个轴或所有轴上计算。 | 可选择的 |
| 在外 | 放置结果的替代输出数组。它必须具有与预期输出相同的形状。 | 可选择的 |
| keepdims (bool) | 如果设置为真，减少的轴将作为尺寸为 1 的尺寸留在结果中。使用此选项，结果将根据输入数组正确传播。 | 可选择的 |
| 最初的 | 输出元素的最小值。 | 可选择的 |
| 在哪里 | 要比较以找出最大值的元素。 | 可选择的 |
退货:
a 的最大值。如果 a 是标量，那么结果也是标量，否则就是数组。
Numpy Amax 函数使用示例
让我们进入使用 numpy.amax() 函数的不同例子。
一维数组的最大值
import numpy as np
arr = [3, 6, 22, 10, 84]
# using amax method to compute the maximum
ans = np.amax(arr)
print("arr =", arr)
print("Maximum value =", ans)
输出:
arr = [3, 6, 22, 10, 84]
Maximum value = 84
二维数组的最大值
import numpy as np
arr = [[10, 36], [4, 16]]
# using amax method to compute the maximum
ans = np.amax(arr)
print("arr =", arr)
print("Maximum value =", ans)
输出:
arr = [[10, 36], [4, 16]]
Maximum value = 36
由于这是一个二维数组，它首先像这样按行展平:[10，36，4，16]，然后计算最大值。
沿轴最大值=0
import numpy as np
arr = [[10, 36], [4, 16]]
# using amax method to compute the maximum
ans = np.amax(arr, axis=0)
print("arr =", arr)
print("Maximum value =", ans)
输出:
arr = [[10, 36], [4, 16]]
Maximum value = [10 36]
这里，最大值沿列计算如下:
ans[0] = max(arr[0][0], arr[1][0]) = max(10, 4) = 10
ans[1] = max(arr[0][1], arr[1][1]) = max(36, 16) = 36
沿轴最大值=1
import numpy as np
arr = [[10, 36], [4, 16]]
# using amax method to compute the maximum
ans = np.amax(arr, axis=1)
print("arr =", arr)
print("Maximum value =", ans)
输出:
arr = [[10, 36], [4, 16]]
Maximum value = [36 16]
在这种情况下，最大值沿行计算如下:
ans[0] = max(arr[0][0], arr[0][1]) = max(10, 36) = 36
ans[1] = max(arr[1][0], arr[1][1]) = max(4, 16) = 16
包含 NaN 的数组的最大值
import numpy as np
arr = [3, 6, np.nan, 22, np.nan, 10, 84]
# using amax method to compute the maximum
ans = np.amax(arr)
print("arr =", arr)
print("Maximum value =", ans)
输出:
arr = [3, 6, nan, 22, nan, 10, 84]
Maximum value = nan
如本教程前面所述，如果一个数组包含 NaN，那么它的最大值也是 NaN，如上面的例子所示。
给定初始值的数组的最大值
import numpy as np
arr = [3, 6, 22, 10, 84]
# using amax method to compute the maximum
ans = np.amax(arr, initial=100)
print("arr =", arr)
print("Maximum value =", ans)
输出:
arr = [3, 6, 22, 10, 84]
Maximum value = 100
这里，我们提到了一个初始值为 100 的。将该值与数组中的所有元素进行比较，以找到最大值。
在这里，因为 100 是所有值中最高的值，所以它被返回。
仅使用选定元素的数组的最大值
为了找到数组中某些选择值的最大值，我们可以将 where 参数传递给 numpy.amax() 函数。
import numpy as np
arr = [3, 6, 22, 10, 84]
# using amax method to compute the maximum
ans = np.amax(arr, where=[False, False, True, True, False], initial=-1)
print("arr =", arr)
print("Maximum value =", ans)
输出:
arr = [3, 6, 22, 10, 84]
Maximum value = 22
这里在里列表只有指标 2 和 3 是真，其余都是假。这意味着 amax()方法必须只找到 arr 中索引 2 和 3 处元素的最大值，并忽略其余元素。
因此，返回的答案是 max(22，10) = 10。
结论
仅此而已！在本教程中，我们学习了 Numpy amax 方法，并使用相同的方法练习了不同类型的示例。
如果你想了解更多关于 NumPy 的信息，请随意浏览我们的 NumPy 教程。
参考
NumPy Amin–使用 NumPy 返回数组元素的最小值
原文:# t0]https://www . aspython . com/python-modules/num py/numpy-Amin
大家好，欢迎来到这个关于 Numpy amin 的教程。在本教程中，我们将学习 NumPy amin() 方法，也将看到许多相同的例子。让我们开始吧！
也读作:Numpy . Subtract():Python 中如何用 NumPy 减去数字？
什么是 NumPy amin？
NumPy 中的 amin 方法是一个返回数组元素最小值的函数。它可以是所有数组元素的最小值、沿行数组元素的最小值或沿列数组元素的最小值。
我们将在本教程的下一节看到每个例子。
NumPy amin 的语法
numpy.amin(a, axis=None, out=None)
| 参数 | 描述 | 必需/可选 |
| (类似数组) | 输入数据。 | 需要 |
| 轴 | 沿其计算数组最小值的轴。它可以是 axis=0 或 axis=1 或 axis=None，这意味着要返回展平数组的最小值。 | 可选择的 |
| 在外 | 放置结果的替代输出数组。它必须具有与预期输出相同的形状。 | 可选择的 |
返回:中的最小元素 a 。如果 axis=None ，则输出为标量，否则，输出为数组。
numpy.amin()的示例
让我们进入使用 numpy.amin()函数的不同例子。
当数组是一维时使用 numpy.amin()
import numpy as np
a = [10, 3, 25]
ans = np.amin(a)
print("a =", a)
print("Minimum of a =", ans)
输出:
a = [10, 3, 25]
Minimum of a = 3
比较给定数组中的所有元素，10，3 和 25 的最小值是 3。因此，返回 3。
当数组包含负数时使用 numpy.amin()
import numpy as np
a = [[-8, 6], [-5, -12]]
ans = np.amin(a)
print("a =", a)
print("Minimum of a =", ans)
输出:
a = [[-8, 6], [-5, -12]]
Minimum of a = -12
比较数组中的所有值，-12 是这里的最小元素。
当数组包含 NaN 值时使用 numpy.amin()
在 Python 中，NaN 代表的不是数字。
import numpy as np
a = [26, np.nan, 8, np.nan, -4]
ans = np.amin(a)
print("a =", a)
print("Minimum of a =", ans)
输出:
a = [26, nan, 8, nan, -4]
Minimum of a = nan
如果输入包含 nan，那么 NumPy amin()方法总是返回 nan 作为输出，而不考虑输入数组中的其他元素。
当数组是二维数组时使用 numpy.amin()
import numpy as np
a = [[16, 3], [48, 66]]
ans = np.amin(a)
print("a =", a)
print("Minimum of a =", ans)
输出:
a = [[16, 3], [48, 66]]
Minimum of a = 3
在二维数组的情况下，当没有提到轴时，数组首先按行展平，然后计算其最小值。
在上面的例子中，展平的数组将是[16，3，48，66]并且其中的最小元素是 3，因此它由 amin() 方法返回。
使用 numpy.amin()找到给定轴上的最小值
轴= 0
import numpy as np
a = [[16, 3], [48, 66]]
# minimum along axis=0
ans = np.amin(a, axis=0)
print("a =", a)
print("Minimum of a =", ans)
输出:
a = [[16, 3], [48, 66]]
Minimum of a = [16 3]
这里，元素按列进行比较，它们的最小值存储在输出中。
ans[0] = minimum(a[0][0], a[1][0]) = minimum(16, 48) = 16
ans[1] = minimum(a[0][1], a[1][1]) = minimum(3, 66) = 3
轴= 1
import numpy as np
a = [[16, 3], [48, 66]]
# minimum along axis=1
ans = np.amin(a, axis=1)
print("a =", a)
print("Minimum of a =", ans)
输出:
a = [[16, 3], [48, 66]]
Minimum of a = [ 3 48]
这里，元素按行进行比较，它们的最小值存储在输出中。
ans[0] = minimum(a[0][0], a[0][1]) = minimum(16, 3) = 3
ans[1] = minimum(a[1][0], a[1][1]) = minimum(48, 66) = 48
结论
仅此而已！在本教程中，我们学习了 Numpy amin 方法，并使用该方法练习了不同类型的示例。如果你想了解更多关于 NumPy 的信息，请随意浏览我们的 NumPy 教程。
参考
NumPy angle–返回复杂参数的角度
原文：https://www.askpython.com/python-modules/numpy/numpy-angle
嘿，你有没有想过一个复杂论点的角度是怎么计算的？这就是 Python NumPy 库发挥作用的地方。NumPy 库中有各种各样的函数，有一个函数 NumPy angle 执行计算角度的任务。
我们将通过它的语法和不同类型的例子来让你熟悉这个函数。
因此，没有任何进一步的到期让我们开始吧。
关于数字角度
你们一定都熟悉复数，对吧？我们来快速复习一下复数。
复数由两部分组成，第一部分是实部，第二部分是虚部。当复数绘制在复平面上时，实部和虚部位于相互垂直的轴上(就像 X 轴和 Y 轴一样)。
现在，复数的角就是复数与实轴的夹角。这就是 NumPy 角度函数发挥作用的地方。
注:复数 z 表示为 z = x+yi 其中 x 和 y 为实数。复数 z 的角度由 tan^(-1) (y/x) 给出。
numpy.angle() 是 NumPy 库的数学函数之一，返回复数的角度。
现在，让我们理解函数的语法。
数字角度的语法
numpy.angle(z , deg = "")
- 第一个参数是复数。它可以是单个复数，也可以是复数的 NumPy 数组。
- 第二个参数是类型为布尔的 deg 值(真或假)。默认情况下，该函数返回以弧度表示的角度。为了获得以度为单位的角度，将角度值设置为真。
这是关于函数的理论和语法。
使用数字角度
让我们写一些代码来更好地理解这个函数。
单复数的 NumPy 角
import numpy as np
print("The angle of the complex number 1+3j is:",np.angle(1+3j),"radians")
print("The angle of the complex number 3j is:",np.angle(3j),"radians")
print("The angle of the complex number 1 is:",np.angle(1),"radians")
print("The angle of the complex number -1-1j is:",np.angle(-1-1j),"radians")
输出
The angle of the complex number 1+3j is: 1.2490457723982544 radians
The angle of the complex number 3j is: 1.5707963267948966 radians
The angle of the complex number 1 is: 0.0 radians
The angle of the complex number -1-1j is: -2.356194490192345 radians
在上面所有的例子中，我们已经将一个单复数作为参数传递给计算输入复数的角度的函数 np.angle() 。输出角度以弧度为单位。
让我们了解一下对于复数 3j 和 1 输出角度是如何计算的。取复数 3j ，实部为 0，虚部为 3，暗示在 tan^(-1) (y/x)中，y 为 3，x 为 0。这意味着 tan^(-1) (y/x)等于 tan^(-1) (无穷大)，其值为 90 度或 1.5707 弧度。
对于复数 1 ，实部为 1，虚部为 0，这意味着在 tan^(-1) (y/x)中，y 为 0，x 为 1。这意味着 tan^(-1) (y/x)等于 tan^(-1) (0)，其值为 0 弧度。
我们的数学计算和程序的输出完全吻合。多酷啊🙂
注:始终在复平面上画复数，以明确复数与实轴所成的角度。对你真的会有帮助。
复数数组的 NumPy 角度
import numpy as np
a = np.array((1+3j , -1+0.5j , 4-2j , 0.5+0.5j))
b = np.angle(a)
print("Input Array of Complex Numbers:\n",a)
print("Angles in radians:\n",b)
输出
Input Array of Complex Numbers:
[ 1\. +3.j -1\. +0.5j 4\. -2.j 0.5+0.5j]
Angles in radians:
[ 1.24904577 2.67794504 -0.46364761 0.78539816]
注意:输出数组与输入数组具有相同的维数和形状。
在上面的示例中，复数的 NumPy 数组作为参数传递给函数。这里，所有复数的输出角度也是以弧度表示的。
这里，该函数也以类似的方式工作。计算出输入数组的每个复元素的角度，并存储在上述程序的变量**b**中。然后，我们使用两个 print 语句来打印输入的 NumPy 数组和角度的 NumPy 数组。
但是，我们能得到以度为单位的输出角度吗？让我们看看如何做到这一点🙂
具有 deg 属性的 NumPy 角度
import numpy as np
a = np.array((1+3j, -1j, 0.5+0.5j))
b = np.angle(a , deg="true")
print("Input Array:\n",a)
print("Angle in degrees:\n",b)
输出
Input Array:
[ 1\. +3.j -0\. -1.j 0.5+0.5j]
Angle in degrees:
[ 71.56505118 -90\. 45\. ]
因此，如果我们将 deg 值设置为真值，就可以得到以度为单位的输出角度。
其余所有的事情都类似于前面的代码。你们都有一个任务，你们要计算单个复数的输出角度，以度为单位。
摘要
在本文中，我们学习了 NumPy 角度函数。我们练习了单个复数的代码以及复数的 NumPy 数组，我们还使用 deg 属性将输出角度转换为度数。请在阅读文章的同时写下代码。
敬请关注，点击这里继续探索更多文章。
参考
Python 中的 NumPy arange()方法
原文：https://www.askpython.com/python-modules/numpy/numpy-arange-method-in-python
介绍
在本教程中，我们将讨论 Python 中的 Numpy arange()方法。NumPy 是 Python 中一个非常受欢迎的模块，主要是因为其更快的性能和代码可靠性而被用户使用。它提供了一种用 Python 编程的矢量化方法，甚至使代码更加简洁易读。
Numpy arange()方法基础
基本上，Python 中 NumPy 模块中的arange()方法用于根据预设的开始和结束点以及恒定的步长生成线性数列。
语法，
import numpy as np
np.arange( start , stop , step ,dtype=nome)
这里，
start是未来生成序列的起点。序列从这个数字开始，stop是序列生成的上限。注意，停止是而不是包含在序列本身中，只考虑它之前的数字step是统一的步长。默认情况下，如果没有任何东西作为步骤传递，解释器会将步骤视为等于一(1)。记住，步长必须是某个非零值，否则会出现ZeroDivisionError。dtype是生成的n 数组元素的类型。默认情况下，它从方法内部提供的参数推断类型。dtype 可以是 none、int 或 float 等。
Numpy arange()示例
让我们通过一个例子来理解 Numpy arange()方法的工作原理:
import numpy as np
#passing start=1, stop=10, and step=2 and dtype=int
res=np.arange(1,10,2,int)
#printing the result
print("The resultant sequence is : ",res)
#analysing the type of the result
print("Type of returned result is:",type(res))
输出:
Np Arange Example
这里，
- 我们最初将 NumPy 模块导入为
np以供进一步参考。 - 然后，我们使用
arange()方法，将相应的开始、停止、步骤和类型参数作为 1、10、2 和 int 传递，生成一个由 1 到 9 的整数组成的数组，步骤=2。 - 当我们打印结果序列以及返回对象的
type()时，结果是该对象是ndarray类的成员。
在 Python 中使用 Numpy arange()
arange() 方法有四个参数 start、stop、step 和 dtype，正如我们在上一节中看到的。现在我们要看看如何以各种方式使用这个方法，以及它如何适用于所有情况。
1.使用带有一个参数的 arange()
当我们只将一个参数传递给 Numpy arange()方法时，默认情况下，它认为该值是 stop 参数。看一下下面提到的代码示例，
import numpy as np
#passing only one parameter to the arange() method
res=np.arange(5)
#printing the result
print("The resultant sequence with one argument : ",res)
#analysing the type of the result
print("Type of returned result is:",type(res))
输出:
The resultant sequence with one argument : [0 1 2 3 4]
Type of returned result is: <class 'numpy.ndarray'>
这里，
- 正如我们前面提到的，我们最初将
numpy模块作为 np 导入， - 之后，我们尝试生成一个序列并存储在
res中，只有一个参数，那就是' 5 '， - 我们观察到程序将传递的值视为停止点或终点。并创建一个值为
[0 1 2 3 4]的数组， - 我们再次确认结果的类型()为 ndarray。
2.无步骤使用 Numpy arange()
当步骤参数没有传递给 Python 中的arange()方法时，默认情况下它认为它有一个值 1 。让我们看一个例子，
import numpy as np
#passing start=5 and stop=8 to arange()
res=np.arange(5,8)
#printing the result
print("The resultant sequence with no step :",res)
#analysing the type of the result
print("Type of returned result is:",type(res))
输出:
The resultant sequence with no step : [5 6 7]
Type of returned result is: <class 'numpy.ndarray'>
因此，这里我们可以清楚地看到，尽管我们没有传递 step 参数，但创建的数组由值 [5 6 7]组成。也就是说，在这种情况下，默认值 1 用于生成相应的输出。
3.使用带负参数的 arange()
那么，如果传递给 arange()方法的值是负呢？工作正常。
如果起点和终点是负的，该方法会以与正数值相同的方式生成一个序列。它从起点开始，并通过用提供的正步长递增来继续该过程。
注意:如果提供的步长是负的，那么唯一的差别将是增量部分。在这种情况下，将添加步长，但由于步长值为负，最终生成的数组将是一个降序数组。
让我们看一个例子，其中我们传递负的开始和停止值。
import numpy as np
#passing start=-10, stop=-1 and step=3 to arange()
res=np.arange(-10,-1,3)
#printing the result
print("The resultant sequence with negative start and stop :",res)
#analysing the type of the result
print("Type of returned result is:",type(res))
输出:
The resultant sequence with negative start and stop : [-10 -7 -4]
Type of returned result is: <class 'numpy.ndarray'>
如上所述，arange()方法生成一个由元素 [-10 -7 -4] 组成的数组，因为提供的开始和停止参数是( -10 )和( -1 )，步长= 3 。
4.在 Python 循环中使用 Numpy arange()
在下面的例子中，我们已经将 arange() 方法合并到 Python 的本机 for 循环中。
import numpy as np
#to print all even numbers from 2 to nth even number, where n is user input
#user input
n=int(input("Enter the last even number: "))
print("The sequence of even numbers :")
for i in np.arange(2,n+2,2): #here stop=n+2 so that the nth even number is too printed
print(i, end=" ")
输出:
Print Sequence Of Even Numbers
在上面的代码中，
arange()方法产生与内置range()方法相同的输出。这里，我们尝试打印从 2 到用户提供的最后一个的所有偶数。np.arange(2,n+2,2)给出了一个包含从 2 到 n 的所有数字的序列。- 正如我们前面看到的，arange()方法不包括 stop 或 end 值。因此，为了克服这种情况并打印最后一个用户提供的偶数值，我们认为停止参数为 (n+2) ，其中步长=2 。
即使我们在 Python 中使用了带有本机 for 循环的arange()方法，这也会影响代码的执行速度和性能。它也变得很慢。
Python 中的 Numpy arange()与 range()
NumPy 模块为我们提供了一些真正有用的，更重要的是更快的方法。在线性序列生成的情况下，Numpy arange()方法在性能和速度方面优于内置的range()方法，即使两者执行相同的任务。这是因为 numpy 模块使用了矢量化代码。
结论
我们从 NumPy 模块中了解了arange()方法，它是如何工作的，以及它如何比 Python 中的原生range()方法更快更好。
参考
- https://docs.scipy.org/doc/numpy/user/whatisnumpy.html
- https://www.journaldev.com/34380/python-numpy-arange
NumPy Arccos-完全指南
原文:# t0]https://www . aspython . com/python-modules/num py/numpy-arccos
读者你好！在本教程中，我们将理解 NumPy arccos 函数以及大量的例子。我们还将绘制arccos函数的曲线。那么，我们开始吧。
Arccos 函数-快速概述
- arccos 是余弦函数的逆的表示。
- arccos 函数接受范围为 [-1，1] 的输入，并产生范围为 [0，pi] 的输出。
什么是 NumPy Arccos？
NumPy Arccos 是 NumPy 库提供的三角函数之一。NumPy Arccos 可以将实数和复数作为输入。
我们可以以**numpy.arccos**的身份访问 NumPy Arccos 函数。
NumPy arccos 的语法
语法: **numpy.arccos(input)**其中输入可以是单个数字，也可以是数字的 NumPy 数组。
让我们写一些代码。
单个数的 NumPy arccos
import numpy as np
import math
print("Printing the Cosine inverse values in radians\n")
print("Cos inverse of 0 is :",np.arccos(0))
print("Cos inverse of 0.5 is :",np.arccos(0.5))
print("Cos inverse of 1/sqrt(2) is :",np.arccos(1/math.sqrt(2)))
print("Cos inverse of 1 is :",np.arccos(1))
print("Cos inverse of -1 is :",np.arccos(-1))
print("\n")
print("Cosine inverse values in degrees\n")
print("Cos inverse of 1/sqrt(2) is :",np.degrees(np.arccos(1/math.sqrt(2))))
print("Cos inverse of -1 is :",np.degrees(np.arccos(-1)))
输出
Printing the Cosine inverse values in radians
Cos inverse of 0 is : 1.5707963267948966
Cos inverse of 0.5 is : 1.0471975511965979
Cos inverse of 1/sqrt(2) is : 0.7853981633974484
Cos inverse of 1 is : 0.0
Cos inverse of -1 is : 3.141592653589793
Cosine inverse values in degrees
Cos inverse of 1/sqrt(2) is : 45.00000000000001
Cos inverse of -1 is : 180.0
让我们以 0 的 cos 逆为例，它等于 90 度。因为 90 度的余弦是 0，所以 0 的反余弦是 90 度。这是理解反三角函数如何计算结果的一种有趣方式。
任务:尝试将 NumPy Arccos 函数与其他输入一起使用，并观察输出。
复数的 NumPy arccos
import numpy as np
print("Cosine inverse of 1+5j is: ",np.arccos(1+5j))
print("Cosine inverse of 2+3j is: ",np.arccos(2+3j))
print("Cosine inverse of 0.5+0.5j is: ",np.arccos(0.5+0.5j))
输出
Cosine inverse of 1+5j is: (1.3770031902399644-2.3309746530493123j)
Cosine inverse of 2+3j is: (1.0001435424737972-1.9833870299165355j)
Cosine inverse of 0.5+0.5j is: (1.118517879643706-0.5306375309525179j)
无效数字的 NumPy arccos
如果将无效输入作为参数传递给 arccos 函数，则输出将为 nan 。
import numpy as np
print("Cosine inverse of -3 is :",np.arccos(5))
输出
Cosine inverse of -3 is : nan
注意:超出范围[-1，1]的每个数字都被视为arccos函数的无效输入。
多个数字上的 NumPy Arccos
arccos 函数也将 NumPy 数字数组作为参数。
将 NumPy 数组与 Arccos 相结合
import numpy as np
a = np.array((-1 , 0 , 0.5 , 0.3 , 1))
print("Cosine Inverse Values in radians :\n",np.arccos(a))
print("Cosine Inverse Values in degrees :\n",np.degrees(np.arccos(a)))
输出
Cosine Inverse Values in radians :
[3.14159265 1.57079633 1.04719755 1.26610367 0\. ]
Cosine Inverse Values in degrees :
[180\. 90\. 60\. 72.54239688 0\. ]
均匀间隔的数字阵列
在这个例子中，我们将使用**numpy.linspace**创建一个由 20 个等距值组成的 NumPy 数组。
import numpy as np
a = np.linspace(-1 , 1 , 20)
print("Cosine Inverse Values in radians: ",np.arccos(a))
print("Cosine Inverse Values in degrees: ",np.degrees(np.arccos(a)))
输出
Cosine Inverse Values in radians: [3.14159265 2.67863793 2.48074736 2.32431694 2.18823343 2.06426572
1.94810636 1.83709034 1.72935461 1.62345224 1.51814042 1.41223805
1.30450231 1.19348629 1.07732693 0.95335922 0.81727571 0.6608453
0.46295473 0\. ]
Cosine Inverse Values in degrees: [180\. 153.47464798 142.13635364 133.17355111 125.37654015
118.27371363 111.61827242 105.25752329 99.08472029 93.01696131
86.98303869 80.91527971 74.74247671 68.38172758 61.72628637
54.62345985 46.82644889 37.86364636 26.52535202 0\. ]
可视化 Arccos 函数
import numpy as np
# Importing the Matplotlib Library
import matplotlib.pyplot as plt
# Creating a NumPy Array of 30 evenly-spaced elements
a = np.linspace(-1,1,30)
# Storing the computed arccos values in a NumPy Array
b = np.arccos(a)
plt.plot(a, b, color = "green", marker = "o")
plt.title("numpy.arccos()")
plt.xlabel("X")
plt.ylabel("Y")
plt.show()
输出
Arccos Plot
注:在图中，Y 轴(纵轴)上的数值是**arccos**函数的输出，单位为弧度。
**plt.plot()**该函数用于绘制带三个参数的 arccos 函数。
- 第个参数是数字的 NumPy 数组(在第 3 行创建)，绘制在 X 轴(水平轴)上。
- 第二个参数是
**arccos**函数的输出，绘制在 Y 轴(垂直轴)上。 - 第三个参数是绘图的颜色。
- 第四个参数是标记值，用指定的标记强调每个点。有不同类型的标记可用于表示曲线上的点。
好了，你已经使用 Matplotlib 库绘制了**arccos**曲线。
摘要
所以，我们学习了 NumPy 库的**arccos**函数。在下一个教程中，我们将介绍 arctan 功能。直到那时继续学习，继续编码:)。
参考
num py documentation–num py arccos
NumPy arc cosh–完整指南
原文:# t0]https://www . aspython . com/python-modules/num py/numpy-arccosh
读者你好！欢迎来到另一个关于 NumPy 数学函数的教程。在本教程中，我们将理解 NumPy arccosh 函数，并练习许多例子。我们还将使用 Matplotlib 库绘制图形。
没有别的事了，让我们开始吧。
什么是双曲余弦(逆余弦)-快速概述
- arccosh 是反双曲余弦函数。
- 反余弦的等效表达式为:
Arccosh Expression
- 反正切函数的定义域是【1，无穷大】。这里，无限不包括在内。
- arccosh 函数的范围是【1，无穷大】。
也读: NumPy 面试问题:为你的 Python 工作面试做好准备
什么是 NumPy Arccosh？
NumPy Arccosh 函数也是 NumPy 库提供的反双曲三角函数之一。使用这个函数，我们可以计算传递给反余弦函数的输入的反双曲余弦值。
numpy arccosh 函数可以作为numpy.arccosh()访问。
语法:numpy.arccosh(input)其中输入可以是单个数字、复数以及 numpy 数字数组。
使用 numpy arccosx
让我们试一些例子。
对包含数字的 numpy 数组使用 numpy.arccosh()
import numpy as np
a = np.array(( 2 , 3 , 10 , 90 , 100))
b = np.arccosh(a)
print("Input Values:\n",a)
print("Arccosh values:\n",b)
输出
Input Values:
[ 2 3 10 90 100]
Arccosh values:
[1.3169579 1.76274717 2.99322285 5.19292599 5.29829237]
让我们将一些 pi 值作为参数传递给 arccosh 函数，并观察输出🙂
对具有弧度角度的 numpy 数组使用 numpy.arccosh()函数
import numpy as np
a = np.array((np.pi/2 , 3*np.pi/2 , np.pi))
b = np.arccosh(a)
print("Input Array:\n",a)
print("Arccosh Values:\n",b)
输出
Input Array:
[1.57079633 4.71238898 3.14159265]
Arccosh Values:
[1.02322748 2.23188925 1.81152627]
这里，我们不能传递一个小于 1 的值，因为它将超出 arccosh 函数的范围，该函数将给出 nan 作为输出。
Task: 尝试将 1 作为参数传递给 arccosh 函数，并观察输出。
使用复数
import numpy as np
print("Arccosh of 2+3j is :\n",np.arccosh(2+3j))
print("Arccosh of 1+5j is :\n",np.arccosh(1+5j))
print("Arccosh of 0.5+0.5j is :\n",np.arccosh(0.5+0.5j))
print("Arccosh of -1-1j is :\n",np.arccosh(-1-1j))
输出
Arccosh of 2+3j is :
(1.9833870299165355+1.0001435424737972j)
Arccosh of 1+5j is :
(2.3309746530493123+1.3770031902399644j)
Arccosh of 0.5+0.5j is :
(0.5306375309525179+1.118517879643706j)
Arccosh of -1-1j is :
(1.0612750619050357-2.2370357592874117j)
使用无效数字
这里，我们将一些无效的输入传递给 arccosh 函数，并观察输出。
import numpy as np
print("The arccosh of 0 is:",np.arccosh(0))
print("The arccosh of -1 is:",np.arccosh(-1))
print("The arccosh of 0.5 is:",np.arccosh(0.5))
输出
在上述所有情况下，输出将是 nan 。
这就是向 arccosh 函数传递不同的参数。现在，让我们使用 Matplotlib 库绘制 arccosh 函数的曲线。
可视化 arccosx 函数
import numpy as np
import matplotlib.pyplot as plt
a = np.linspace(1 , 20 , 50)
b = np.arccosh(a)
plt.plot(a , b , color = "blue" , marker = "o")
plt.title("numpy.arccosh()")
plt.xlabel("X")
plt.ylabel("Y")
plt.show()
输出
ArccoshPlot
这就是关于反余弦函数的全部内容。这个函数使用起来非常简单。点击这里继续探索关于各种 python 主题的精彩帖子。
参考
NumPy Arcsin-完全指南
原文:# t0]https://www . aspython . com/python-modules/num py/numpy-arcsin
读者你好！欢迎来到系列 NumPy 三角函数的第四篇教程。从本教程开始，我们将从 NumPy 库提供的反三角函数开始。
在本教程中，我们将了解 NumPy arcsin 函数，并练习大量示例。我们还将使用 Matplotlib 库绘制 arcsin()函数。让我们开始吧。
反正弦函数–快速概述
- 关于这些反三角函数，有一个有趣的事实需要了解，这些函数的输出是一个角度，输入是一个数。
- 反正弦是正弦函数的反函数的表示。
- arcsin 函数接受 [-1，1] 范围内的输入，并产生 [-pi/2，pi/2] 之间的输出。
什么是 NumPy arcsin？
NumPy arcsin 是 NumPy 库提供的三角函数之一。实数和复数可以作为输入传递给 NumPy 反正弦函数。
NumPy arcsin 可以作为**numpy.arcsin** (input) 访问。
NumPy arcsin 的语法
语法: **numpy.arcsin(input)**其中输入可以是单个数字，也可以是数字的 NumPy 数组。
单个数的 NumPy 反正弦
让我们尝试一些 NumPy arcsin 函数的例子来帮助我们更好地理解它。
import numpy as np
import math
print("Printing the Sine inverse values in radians\n")
print("Sin inverse of 0 is :",np.arcsin(0))
print("Sin inverse of 0.5 is :",np.arcsin(0.5))
print("Sin inverse of 1/sqrt(2) is :",np.arcsin(1/math.sqrt(2)))
print("Sin inverse of 1 is :",np.arcsin(1))
print("Sin inverse of -1 is :",np.arcsin(-1))
print("\n")
print("Sine inverse values in degrees\n")
print("Sin inverse of 1/sqrt(2) is :",np.degrees(np.arcsin(1/math.sqrt(2))))
print("Sin inverse of -1 is :",np.degrees(np.arcsin(-1)))
输出
Printing the Sine inverse values in radians
Sin inverse of 0 is : 0.0
Sin inverse of 0.5 is : 0.5235987755982989
Sin inverse of 1/sqrt(2) is : 0.7853981633974482
Sin inverse of 1 is : 1.5707963267948966
Sin inverse of -1 is : -1.5707963267948966
Sine inverse values in degrees
Sin inverse of 1/sqrt(2) is : 44.99999999999999
Sin inverse of -1 is : -90.0
让我们以 1/sqrt(2)的正弦倒数为例，它等于 45 度。因为 45 度的正弦是 1/sqrt(2 ),所以 1/sqrt(2)的正弦倒数是 45 度。这是理解反三角函数如何计算结果的一种有趣方式。
上面的代码片段非常清楚，其中范围[-1，1]内的一个数字作为参数传递给**arcsin**函数，输出是一个以弧度表示的角度。
注意:我已经用**np.degrees()**一个函数把输出角度转换成度数。
在上述所有情况下，反正弦函数的输出都在范围 [-pi/2，pi/2] 内。
复数的 NumPy 反正弦
NumPy 反正弦函数以一个复数作为参数。
import numpy as np
print("Sin inverse of 1+5j is: ",np.arcsin(1+5j))
print("Sin inverse of 2+3j is: ",np.arcsin(2+3j))
print("Sin inverse of 0.5+0.5j is: ",np.arcsin(0.5+0.5j))
输出
Sin inverse of 1+5j is: (0.1937931365549322+2.3309746530493123j)
Sin inverse of 2+3j is: (0.5706527843210994+1.9833870299165355j)
Sin inverse of 0.5+0.5j is: (0.45227844715119064+0.5306375309525179j)
输出也是一个复数。
注意:当 arcsin 函数的输入是复数时，我们不能对 numpy.arcsin()使用 np.degrees()函数。
无效数字的 NumPy arcsin
如果一个不在反正弦函数域内的数字作为参数传递给该函数，那么输出是 nan 。
import numpy as np
print("Sin inverse of 5 is :",np.arcsin(5))
输出
Sin inverse of 5 is : nan
注意:超出范围[-1，1]的每个数字都被视为**arcsin**函数的无效输入。
多重数上的 NumPy 反正弦
NumPy arcsin 函数也可以接受一个 NumPy 数字数组作为参数。
将 NumPy 数组与反正切相结合
import numpy as np
a = np.array((-1 , 0 , 0.5 , 0.3 , 1))
print("Sine Inverse Values in radians :\n",np.arcsin(a))
print("Sine Inverse Values in degrees :\n",np.degrees(np.arcsin(a)))
输出
Sine Inverse Values in radians :
[-1.57079633 0\. 0.52359878 0.30469265 1.57079633]
Sine Inverse Values in degrees :
[-90\. 0\. 30\. 17.45760312 90\. ]
均匀间隔的 NumPy 数组上的 NumPy 反正弦
在这个例子中，我们将使用**numpy.linspace**创建一个由 20 个等距值组成的 NumPy 数组。
import numpy as np
a = np.linspace(-1 , 1 , 20)
print("Sin Inverse Values in radians: ",np.arcsin(a))
print("Sin Inverse Values in degrees: ",np.degrees(np.arcsin(a)))
输出
Sin Inverse Values in radians: [-1.57079633 -1.1078416 -0.90995103 -0.75352062 -0.6174371 -0.49346939
-0.37731003 -0.26629402 -0.15855828 -0.05265591 0.05265591 0.15855828
0.26629402 0.37731003 0.49346939 0.6174371 0.75352062 0.90995103
1.1078416 1.57079633]
Sin Inverse Values in degrees: [-90\. -63.47464798 -52.13635364 -43.17355111 -35.37654015
-28.27371363 -21.61827242 -15.25752329 -9.08472029 -3.01696131
3.01696131 9.08472029 15.25752329 21.61827242 28.27371363
35.37654015 43.17355111 52.13635364 63.47464798 90\. ]
可视化反正弦函数
import numpy as np
# Importing the Matplotlib Library
import matplotlib.pyplot as plt
# Creating a NumPy Array of 30 evenly-spaced elements
a = np.linspace(-1,1,30)
# Storing the computed arcsin values in a NumPy Array
b = np.arcsin(a)
plt.plot(a, b, color = "blue", marker = "o" , ms = 5,mfc = "r")
plt.title("numpy.arcsin()")
plt.xlabel("X")
plt.ylabel("Y")
plt.show()
输出
Arcsin Plot
在图中，Y 轴(纵轴)上的值是**arcsin**函数的输出，单位为弧度。
**plt.plot()**该函数用于绘制带六个参数的反正弦函数。
- 第个参数是数字的 NumPy 数组(在第 7 行创建)，绘制在 X 轴(水平轴)上。
- 第二个参数是
**arcsin**函数的输出，绘制在 Y 轴(垂直轴)上。 - 第三个参数是绘图的颜色。
- 第四个参数是标记值，用指定的标记强调每个点。有不同类型的标记可用于表示曲线上的点。
- 第五个参数是曲线上点的大小。(ms 是标记大小)
- 第六个参数是标记的颜色。(mfc 是标记面颜色)
摘要
在本教程中，我们学习了 numpy.arcsin()函数接受的各种输入。请在阅读文章的同时练习这些代码。在下一个教程中，我们将详细介绍 NumPy Arccos 函数。
参考
num py documentation–num py arcsin
NumPy Arcsinh–完整指南
原文:# t0]https://www . aspython . com/python-modules/num py/numpy-arcsinh
欢迎来到另一个关于 NumPy arcsinh 函数的精彩教程。在这里，我们将详细了解 NumPy arcsinh 函数。没有任何进一步的到期让我们开始吧！
什么是双曲反正弦(反正弦)？快速概述
- arcsinh 是反双曲正弦函数。
- arcsinh 的等效表达式为:
Arcsinh Equivalent Expression
- 反正切函数的定义域是一组实数。
- arcsinh 函数的值域也是一组实数。
NumPy.arcsinh()是什么？
NumPy arcsinh 是 NumPy 库提供的反双曲函数之一。它接受单个数字、一个复数以及一个 NumPy 数字数组作为输入。
NumPy arcsinh 函数可以作为numpy.arcsinh()访问。
语法: numpy.arcsinh(input)其中输入可以是一个单一的数字，一个复杂的数字以及一个 NumPy 数组的数字。
使用 NumPy Arcsinh
让我们编写一些代码来更好地理解 arcsinh 函数。
对包含数字的 numpy 数组使用 numpy.arcsinh()函数
import numpy as np
a = np.array((0 , 2 , 3 , 10 , 90 , 100))
arcsinh_values = np.arcsinh(a)
print("Input Array: \n",a)
print("Arcsinh Values:\n",arcsinh_values)
输出
Input Array:
[ 0 2 3 10 90 100]
Arcsinh Values:
[0\. 1.44363548 1.81844646 2.99822295 5.19298771 5.29834237]
如果您想知道这些值是如何计算的，您可以简单地将输入数组的值放入在arcsinh–快速概述部分中讨论的 Arcsinh 函数的等效表达式中。
让我们尝试将一些 pi 值传递给 arcsinh 函数。
将 numpy.arcsinh()与角度以弧度表示的 numpy 数组一起使用
import numpy as np
a = np.array((np.pi/2 , np.pi/4 , np.pi/6 , 3*np.pi/2))
arcsinh_values = np.arcsinh(a)
print("Input Array :\n",a)
print("Arcsinh values :\n",arcsinh_values)
输出
Input Array :
[1.57079633 0.78539816 0.52359878 4.71238898]
Arcsinh values :
[1.23340312 0.72122549 0.50221899 2.25441459]
任务:尝试使用带欧拉数的反正切函数，即numpy.e欧拉常数的值为 2.718281828。
具有复数的 NumPy Arcsinh
import numpy as np
print("The arcsinh value of 1+2j is: \n",np.arcsinh(1+2j))
print("The arcsinh value of -1+3j is: \n",np.arcsinh(-1+3j))
输出
The arcsinh value of 1+2j is:
(1.4693517443681852+1.0634400235777521j)
The arcsinh value of -1+3j is:
(-1.8241987021938828+1.2330952175293441j)
注意:如果一个数不能表示为实数或无穷大，则返回**nan**。
这就是使用具有不同值的 arcsinh 函数的全部内容。现在，让我们使用 python 中的 Matplotlib 库来绘制 arcsinh 函数。
可视化反正切函数
import numpy as np
# Importing the Matplolib library
import matplotlib.pyplot as plt
a = np.linspace(-4 , 4 , 50)
# Storing the arcsinh values
b = np.arcsinh(a)
plt.plot(a , b , color = "blue" , marker = "o")
plt.title("numpy.arcsinh()")
plt.xlabel("X")
plt.ylabel("Y")
plt.show()
输出
Arcsinh Plot
您已经成功绘制了反正切函数。
结论
这就是关于 arcsinh 函数的全部内容，这个函数非常容易理解和使用。在下一个教程中，我们将详细介绍 NumPy Arccosh 函数。在那之前请继续关注🙂
参考
NumPy Arctan–完整指南
原文:# t0]https://www . aspython . com/python-modules/num py/numpy-arctan
读者你好！在本教程中，我们将通过大量的例子了解 NumPy arctan 函数，我们还将使用 Matplotlib 库绘制的图形arctan函数。
那么，我们开始吧。
什么是 Arctan？
- ****反正切是反正切(tan)函数的表示。
- arctan 函数将所有实数作为输入，并产生范围为 (-pi/2，pi/2) 的输出。
- 需要注意的一个有趣事实是，我们可以将反正切函数扩展到复数。在这种情况下，arctan 的域(输入)将全部是复数。****
什么是 NumPy Arctan？
NumPy Arctan 是 NumPy 库提供的三角函数之一。NumPy Arctan 可以将实数和复数作为输入。
我们可以像**numpy.arctan**一样访问 NumPy Arctan 函数。
NumPy arctan 的语法
语法: numpy.arctan(input)其中输入可以是单个数字，也可以是数字的 NumPy 数组。
让我们写一些代码。
单个数的 NumPy 反正切
**import numpy as np
import math
print("Printing the Tan inverse values in radians\n")
print("Tan inverse of 0 is :",np.arctan(0))
print("Tan inverse of 0.5 is :",np.arctan(0.5))
print("Tan inverse of 1/sqrt(2) is :",np.arctan(1/math.sqrt(2)))
print("Tan inverse of 1 is :",np.arctan(1))
print("Tan inverse of -1 is :",np.arctan(-1))
# Tan inverse of a very large number
print("Tan inverse of 10000000 is :",np.arctan(10000000))
print("\n")
print("Tan inverse values in degrees\n")
print("Tan inverse of 1/sqrt(2) is :",np.degrees(np.arctan(1/math.sqrt(2))))
print("Tan inverse of -1 is :",np.degrees(np.arctan(-1)))
print("Tan inverse of 10000000 is :",np.degrees(np.arctan(10000000)))**
输出
**Printing the Tan inverse values in radians
Tan inverse of 0 is : 0.0
Tan inverse of 0.5 is : 0.4636476090008061
Tan inverse of 1/sqrt(2) is : 0.6154797086703873
Tan inverse of 1 is : 0.7853981633974483
Tan inverse of -1 is : -0.7853981633974483
Tan inverse of 10000000 is : 1.5707962267948967
Tan inverse values in degrees
Tan inverse of 1/sqrt(2) is : 35.264389682754654
Tan inverse of -1 is : -45.0
Tan inverse of 10000000 is : 89.99999427042206**
在最后一个示例中，我们计算了一个非常大的数的反正切，即 10，000，000，输出为π/2 弧度或 90 度。这是因为反正切的输入是一个非常大的量，其输出往往是π/2 弧度或 90 度。
复数的 NumPy 反正切
**import numpy as np
print("Tan inverse of 1+5j is: ",np.arctan(1+5j))
print("Tan inverse of 2+3j is: ",np.arctan(2+3j))
print("Tan inverse of 0.5+0.5j is: ",np.arctan(0.5+0.5j))**
输出
**Tan inverse of 1+5j is: (1.530881333938778+0.1944261421470021j)
Tan inverse of 2+3j is: (1.4099210495965755+0.22907268296853878j)
Tan inverse of 0.5+0.5j is: (0.5535743588970452+0.40235947810852507j)**
多重数上的 NumPy 反正切
现在，让我们看看如何计算一组数字的反正切值。
结合 NumPy 阵列和 Arctan
**import numpy as np
import math
a = np.array((-1 , 0 , 1/math.sqrt(3) , math.sqrt(3) , 1))
print("Tan Inverse Values in radians :\n",np.arctan(a))
print("Tan Inverse Values in degrees :\n",np.degrees(np.arctan(a)))**
输出
**Tan Inverse Values in radians :
[-0.78539816 0\. 0.52359878 1.04719755 0.78539816]
Tan Inverse Values in degrees :
[-45\. 0\. 30\. 60\. 45.]**
均匀间隔的数字阵列
在这个例子中，我们将使用**numpy.linspace**创建一个由 20 个等距值组成的 NumPy 数组。
**import numpy as np
a = np.linspace(-2 , 2 , 20)
print("Tan Inverse Values in radians: ",np.arctan(a))
print("Tan Inverse Values in degrees: ",np.degrees(np.arctan(a)))**
输出
**Tan Inverse Values in radians: [-1.10714872 -1.06120406 -1.00622693 -0.93971694 -0.85843873 -0.75837771
-0.63502674 -0.48447793 -0.30587887 -0.10487694 0.10487694 0.30587887
0.48447793 0.63502674 0.75837771 0.85843873 0.93971694 1.00622693
1.06120406 1.10714872]
Tan Inverse Values in degrees: [-63.43494882 -60.80251395 -57.6525565 -53.84181456 -49.18491613
-43.4518423 -36.38435182 -27.7585406 -17.52556837 -6.00900596
6.00900596 17.52556837 27.7585406 36.38435182 43.4518423
49.18491613 53.84181456 57.6525565 60.80251395 63.43494882]**
可视化反正切函数
**import numpy as np
# Importing the Matplotlib Library
import matplotlib.pyplot as plt
# Creating a NumPy Array of 30 evenly-spaced elements
a = np.linspace(-10,10,30)
# Storing the computed arctan values in a NumPy Array
b = np.arctan(a)
plt.plot(a, b, color = "green", marker = "o")
plt.title("numpy.arctan()")
plt.xlabel("X")
plt.ylabel("Y")
plt.show()**
输出
****
Arctan Plot****
注意:如果你仔细观察曲线，你会注意到反正切函数的最大值小于π/2，而最小值大于-π/2。****
**plt.plot()**该函数用于绘制带三个参数的反正切函数。
- 第一个参数是数字的 NumPy 数组(在第 3 行创建)，它也是绘制在 X 轴(水平轴)上的 arctan 函数的输入。
- 第二个参数是绘制在 Y 轴(垂直轴)上的
**arctan**函数的输出，单位为弧度。**** - 第三个参数是绘图的颜色。
- ****第四个参数是标记值，强调曲线上绘制的点。
您已经成功绘制并理解了反正切函数的性质。
摘要
这就完成了我们的 NumPy 三角函数教程系列。在本教程中，我们通过大量示例代码片段学习了 arctan 函数，并在整个教程中练习这些代码。到现在为止，你一定已经熟悉了 NumPy 三角函数，它们非常容易使用🙂
在下一篇教程中，我将会详细讲述一个特殊的三角函数 arctan2 ，并给出许多不同的例子。在那之前继续编码。
参考
num py documentation–num py arctan
NumPy arctan 2–完整指南
原文:# t0]https://www . aspython . com/python-modules/num py/numpy-arctan2
读者你好！欢迎学习 NumPy Arctan2 教程。在本教程中，我们将了解 NumPy 库提供的一个特殊三角函数，即 arctan2。让我们开始吧。
arctan 2–快速概述
- 反正切 2 是一个四象限反三角函数，这意味着反正切 2 函数的输出角度可以在四个象限中的任何一个。
- 它以两个数作为参数。
- 该函数根据传递给它的值返回一个在范围 [-pi，pi] 内的值。
什么是 NumPy Arctan2？
NumPy Arctan2 是 NumPy 库提供的三角函数之一。
它采用两个参数 x1 和 x2，并返回正确选择象限的 x1/x2 的反正切(反正切)。
我们可以通过 NumPy.arctan2() 来访问该函数。
语法:**numpy.arctan2(x1, x2)**其中 x1 和 x2 分别代表点的 Y 坐标和 X 坐标。
象限中的符号约定
XY 平面被分成四个相等的部分，称为象限。每个象限中的点对于 X 坐标和 Y 坐标具有不同的符号。
| 象限 | x 坐标 | y 坐标 |
| 第一象限 | 阳性(+) | 正(+)
|
| 第二象限 | 负(-) | 阳性(+) |
| 第三象限 | 负(-) | 负(-) |
| 第四象限 | 阳性(+) | 负(-) |
使用 NumPy Arctan2 函数
我们已经完成了理论部分，让我们写一些代码来使我们的理解更加清晰。
import numpy as np
# Output angle is in first quadrant
print("Arctan2 of (1,1) in radians is:",np.arctan2(1,1))
print("Arctan2 of (1,1) in degrees is:",np.degrees(np.arctan2(1,1)))
# Output angle is in second quadrant
print("\nArctan2 of (1,-1) in radians is:",np.arctan2(1,-1))
print("Arctan2 of (1,-1) in degrees is:",np.degrees(np.arctan2(1,-1)))
# Output angle is in third quadrant
print("\nArctan2 of (-1,-1) in radians is:",np.arctan2(-1,-1))
print("Arctan2 of (-1,-1) in degrees is:",np.degrees(np.arctan2(-1,-1)))
# Output angle is in fourth quadrant
print("\nArctan2 of (-1,1) in radians is:",np.arctan2(-1,1))
print("Arctan2 of (-1,1) in degrees is:",np.degrees(np.arctan2(-1,1)))
输出
Arctan2 of (1,1) in radians is: 0.7853981633974483
Arctan2 of (1,1) in degrees is: 45.0
Arctan2 of (1,-1) in radians is: 2.356194490192345
Arctan2 of (1,-1) in degrees is: 135.0
Arctan2 of (-1,-1) in radians is: -2.356194490192345
Arctan2 of (-1,-1) in degrees is: -135.0
Arctan2 of (-1,1) in radians is: -0.7853981633974483
Arctan2 of (-1,1) in degrees is: -45.0
注意:在所有示例中，arctan2 函数的第一个参数是该点的 Y 坐标值，第二个参数是该点的 X 坐标值。
让我们来理解上面的每一个例子。
- 第 4 行:在本例中，两个参数都是正的，因此点位于第一象限，计算出 x1/x2 的反正切等于 45 度。
- 第 8 行:在本例中，第一个参数(Y 坐标)是正的，但第二个参数(X 坐标)是负的，因此该点位于第二象限，计算 x1/x2 的反正切等于 135 度(这也是第二象限中的角度)。
- 第–12 行:在本例中，第一个参数(Y 坐标)是负的，第二个参数(X 坐标)也是负的，因此该点位于第三象限，计算 x1/x2 的反正切等于-135 度(这也是第三象限中逆时针方向的角度)。
- 第 16 行:在本例中，第一个参数(Y 坐标)为负，第二个参数(X 坐标)为正，因此该点位于第四象限，计算 x1/x2 的反正切等于-45 度(也是第四象限的角度)
要点:反正切 2 通过正确选择象限计算反正切。
结合 NumPy 数组和 Arctan2
示例–1
import numpy as np
# Example 1
# Creating a NumPy Array of the y-coordinates of the points
x1 = np.array((-1 , 1.732 , 1.414 , 0.5 , 1))
# Creating a NumPy Array of the y-coordinates of the points
x2 = np.array((1 , -1 , -0.5 , 0.5 , 1))
print("Arctan2 Values in radians :\n",np.arctan2(x1 , x2))
print("Arctan2 Values in degrees :\n",np.degrees(np.arctan2(x1 , x2)))
输出
Arctan2 Values in radians :
[-0.78539816 2.0944078 1.9106807 0.78539816 0.78539816]
Arctan2 Values in degrees :
[-45\. 120.00072778 109.47394016 45\. 45\. ]
示例–2
import numpy as np
# Example 2
# Creating a NumPy Array of the y-coordinates of the points
a = np.array((-5 , 0.5 , 1 , -1))
# Creating a NumPy Array of the y-coordinates of the points
b = np.array((4 , 1 , -1 , -1.732))
print("Arctan2 Values in radians :\n",np.arctan2(a , b))
print("Arctan2 Values in degrees :\n",np.degrees(np.arctan2(a , b)))
输出
Arctan2 Values in radians :
[-0.89605538 0.46364761 2.35619449 -2.61798118]
Arctan2 Values in degrees :
[ -51.34019175 26.56505118 135\. -149.99927222]
在示例 1 中， x1 是点的 Y 坐标值的 NumPy 数组。类似地， x2 是点的 X 坐标值的 NumPy 数组，这两个数组作为参数传递给 arctan2 函数，该函数计算 x1/x2 的元素的 arctan 。
在示例 2 中， a 是点的 Y 坐标值的 NumPy 数组， b 是点的 X 坐标值的 NumPy 数组，这两个数组作为参数传递给 arctan2 函数，该函数计算 a/b 的元素-arctan2
任务:使用 NumPy arctan2 函数和 NumPy 的**linspace**函数，观察输出。
Arctan 和 Arctan2 的区别
| NumPy arctan | Numpy arctan2 |
| arctan 是一个 2 象限反函数。 | arctan2 是一个四象限反函数。 |
| 范围从-90 度到 90 度。 | 范围从-180 度到 180 度。 |
| 接受单个输入。 | 接受两个输入。 |
| 接受单个 NumPy 数组作为输入。 | 接受两个 NumPy 数组作为输入。 |
以上是对 NumPy 库的 arctan 和 arctan2 函数的快速概述。
摘要
这就是关于 NumPy Arctan2 函数的全部内容。从本教程中得到的关键信息是，arctan2 函数是 arctan 函数的扩展。我们正在计算反正切，选择正确的象限。
通读两遍这篇文章，让你对 arctan2 函数有一个清晰的了解。我将发表更多关于 Python 各种主题的文章。在此之前，请继续学习并探索更多有趣的文章。
参考
num py documentation–num py arctan 2
numpy arctanh–反双曲正切元素
原文:# t0]https://www . aspython . com/python-modules/num py/numpy-arctanh
今天，我们将学习如何实现反双曲函数的元素方式。这将包括查看公式、函数和所需的库。我们还将学习这个函数的域和范围。最后，我们将有一些在代码片段中实现我们的功能的例子。
什么是反正切双曲函数？
反正切双曲函数接受 x 的输入并返回 y 的输出，因此tanh(y) = x.是反正切双曲函数的反函数。正切和反正切双曲函数的公式如下所示。
你可能已经知道 tanh(y) = x 的定义域和值域分别是[-∞，∞]和[-1，1]。
因为我们今天要取反函数。我们函数的定义域是[-1，1]，范围是[-∞，∞]。该函数的图表如下所示。
Tanh Inverse Graph
NumPy.arctanh()的语法
numpy.arctanh(x, out=None, where=True, casting='same_kind', order='K', subok : [bool, datatype])
上述代码片段中使用的参数如下:
- x: 它可以是包含弧度值的变量，也可以是包含某个值的数组
- out: 存储结果的位置。如果提供了，它必须具有与输入 x 相似的形状。如果没有提供或没有提供，则返回新的值或结果。这是可选的。
- 当条件为真时，我们必须得到我们的结果或输出；当条件为假时，我们将得不到任何结果。这是可选的。y 默认其值为真。
- casting='same_kind': 表示只允许 float64 到 float32 的值或结果。该函数在此范围或数据类型中呼喊 cast 值。
- order = 'K': 它总是以 K 排序的形式产生一个输出数组。(注意:有四种类型的订单:{‘K’，‘C’，‘F’，‘A’})。这是可选的。
- subok:【bool，datatype】是否生成结果的子类。如果为真，则提供子类的名称。它返回一个与给定数组具有相同形状和类型的数组。也是可选的。
实现 numpy.arctanh()方法
现在，我们将看到如何在我们的代码片段中使用下面的两个例子来实现这个函数，以及如何在图中表示我们的函数。
传递域范围[-1，1]中的值
import numpy as np
import math
input = [-0.15, -0.75, 0, 0.25, 0.75]
output1 = np.arctanh(input)
output2 = np.arctanh(0.586)
print(output1)
print(output2)
#output
[-0.15114044 -0.97295507 0\. 0.25541281 0.97295507]
0.6715522141847394
我们已经在上面的代码片段中成功实现了我们的方法。我们导入了所需的模块 Numpy，创建了一个输入值数组，并将其传递给我们的函数。然后将结果加载到 output1 中。我们再次将单个值传递到函数中，并将结果加载到 output2 中，并打印出来。
传递域范围[-1，1]之外的值
import numpy as np
input = [-1.25, 5.25]
output = np.arctanh(input)
print(output)
#output
[nan nan]
/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:5: RuntimeWarning: invalid value encountered in arctanh
"""
正如我们所看到的，我们传递了域范围之外的两个值，但是它没有实现函数，而是抛出了错误“在 arctanh 中遇到无效值”。它无法处理这些值。
在图表上绘制 numpy.arctanh()
import matplotlib.pyplot as plt
import numpy
x=[]
y=[]
i=-0.99
while (i<1):
x.append(i)
y.append(numpy.arctanh(i))
i=i+0.01
plt.xlabel("Domain = [-1,1]")
plt.ylabel("Range = [-∞, ∞]")
plt.grid(linestyle='-', linewidth=0.5,color='red')
plt.plot(x,y, linewidth=3, color = 'black')
我们也创建了两个 x 和 y 的数组。我们在 x 数组中取值，从-0.99 开始，逐渐增加 0.01，直到 1.00。在整个循环中实现该函数后，将所有相应的结果值加载到 y 数组中。然后使用上面获得的数组绘制相同的图，将得到如下所示的结果。
结论
最后，我们完成了今天的主题，希望你们已经通过代码片段理解了它。通过传递一些不同类型的参数并观察结果，你可以更好地理解。
Python np.argmax()函数
原文:# t0]https://www . aspython . com/python-modules/num py/numpy-argmax
NumPy (np)是最流行的数学和科学计算库之一。它提供了许多处理多维数组的函数。在本文中，我们将重点介绍 Python np.argmax()函数。
Python np.argmax()函数
顾名思义， argmax() 函数返回 NumPy 数组中最大值的索引。如果有多个索引具有相同的最大值，将返回第一个索引。
argmax()语法:
np.argmax( a ， axis=None ， out=None ， *** ，keep dims =
第一个参数是输入数组。如果没有提供轴，数组变平，然后返回最大值的索引。
如果我们指定 轴 ，它返回沿给定轴的索引值。
第三个参数用于传递数组参数来存储结果，它应该具有正确的形状和数据类型才能正常工作。
如果 keepdims 被传为真，则被缩减的轴作为尺寸为 1 的尺寸留在结果中。
让我们看一些使用 argmax()函数的例子来正确理解不同参数的用法。
1.使用 np.argmax()找到最大值的索引
>>> import numpy as np
>>> arr = np.array([[4,2,3], [1,6,2]])
>>> arr
array([[4, 2, 3],
[1, 6, 2]])
>>> np.ndarray.flatten(arr)
array([4, 2, 3, 1, 6, 2])
>>> np.argmax(arr)
4
np.argmax()返回 4，因为数组首先被展平，然后返回最大值的索引。因此，在这种情况下，最大值为 6，其在展平数组中的索引为 4。
但是，我们希望索引值在一个普通的数组中，而不是扁平的数组中。所以，我们必须使用【arg max()和underline _ index()函数来获得正确格式的索引值。
>>> np.unravel_index(np.argmax(arr), arr.shape)
(1, 1)
>>>
2.沿着轴寻找最大值的索引
如果您想要沿不同轴的最大值的索引，请传递轴参数值。如果我们传递 axis=0，则返回列中最大值的索引。对于轴=1，返回沿行最大值的索引。
>>> arr
array([[4, 2, 3],
[1, 6, 2]])
>>> np.argmax(arr, axis=0)
array([0, 1, 0])
>>> np.argmax(arr, axis=1)
array([0, 1])
对于轴= 0，第一列值是 4 和 1。所以最大值索引为 0。类似地，对于第二列，值是 2 和 6，因此最大值索引是 1。对于第三列，值为 3 和 2，因此最大值索引为 0。这就是为什么我们得到的输出是一个数组([0，1，0])。
对于轴= 1，第一行值是(4，2，3)，因此最大值索引是 0。对于第二行，值为(1，6，2)，因此最大值索引为 1。因此输出数组([0，1])。
3.使用具有多个最大值的 np.argmax()
>>> import numpy as np
>>> arr = np.arange(6).reshape(2,3)
>>> arr
array([[0, 1, 2],
[3, 4, 5]])
>>> arr[0][1] = 5
>>> arr
array([[0, 5, 2],
[3, 4, 5]])
>>> np.argmax(arr)
1
>>> arr[0][2] = 5
>>> arr
array([[0, 5, 5],
[3, 4, 5]])
>>> np.argmax(arr)
1
>>> np.argmax(arr, axis=0)
array([1, 0, 0])
>>> np.argmax(arr, axis=1)
array([1, 2])
>>>
我们使用 arange()函数创建一个带有一些默认值的 2d 数组。然后，我们更改其中一个值，使多个索引具有最大值。从输出中可以清楚地看到，当有多个位置具有最大值时，返回最大值的第一个索引。
摘要
NumPy argmax()函数很好理解，只需要记住在找到最大值的索引之前，数组是展平的。此外，axis 参数对于查找行和列的最大值的索引非常有帮助。
下一步是什么？
资源
NumPy around–完整指南
原文：https://www.askpython.com/python-modules/numpy/numpy-around
欢迎来到另一个关于 NumPy 数学函数 的教程。在本教程中，我们将详细学习如何使用NumPy around功能，我们还将练习各种例子来使我们的理解清晰。
我们一定都解决过不同类型的数学或物理问题，这些问题的最终答案精确到小数点后两位。假设我们必须对 1.7 进行舍入，我们会认为 1.7 是最接近 2 的 T2，因此在对 1.7 进行舍入后，值将是 2。
我们也可以通过编程来做到这一点，我们将在本教程中学习编程。因此，没有任何进一步的到期让我们开始。
NumPy 在哪里？
NumPy around 是 NumPy 库的数学函数之一，它对作为函数输入的数字进行舍入。
让我们看看 NumPy around 函数的语法。
NumPy around 的语法
numpy.around(a, decimals=0, out=None)
我们来了解一下这个函数的参数。
**a**–需要四舍五入的输入数字。它可以是一个的单个数字，也可以是一个的数字数组。decimals–小数的值总是一个整数。它指定了我们希望将输入数字四舍五入到的小数位数。这是一个可选参数。其默认值为 0。out–是 numpy.around()函数的输出。这也是一个可选参数。
和周围的人一起工作
现在让我们写一些代码来更好地理解这个函数。
用一个数字作为输入
import numpy as np
# Rounding off some integer values
print("Around of 1 is:",np.around(1))
print("Around of 5 is:",np.around(5))
# Rounding off some decimal values
print("Around of 5.5 is:",np.around(5.5))
print("Around of 9.54 is:",np.around(9.54))
print("Around of 12.70 is:",np.around(12.70))
print("Around of 9.112 is:",np.around(9.112))
print("Around of 10.112 is:",np.around(10.112))
输出
Around of 1 is: 1
Around of 5 is: 5
Around of 5.5 is: 6.0
Around of 9.54 is: 10.0
Around of 12.70 is: 13.0
Around of 9.112 is: 9.0
Around of 10.112 is: 10.0
在上面的输出中，整数即使经过舍入也保持不变。每隔一个输出四舍五入到小数点后 1 位的数字。
带小数参数的数字
decimals 参数允许我们指定输入数字的小数位数。
import numpy as np
# Round to ones place
print("Around 5.145 is:",np.around(5.145 , 0))
# Round to tenths place
print("Around 5.145 is:",np.around(5.145 , 1))
# Round to hundredths place
print("Around 5.145 is:",np.around(5.145 , 2))
# Round to thousandths place
print("Around 5.145 is:",np.around(5.145 , 3))
# Returns the same number
print("Around 5.145 is:",np.around(5.145 , 10))
输出
Around 5.145 is: 5.0
Around 5.145 is: 5.1
Around 5.145 is: 5.14
Around 5.145 is: 5.145
Around 5.145 is: 5.145
上面的输出非常清楚，其中的数字被舍入到指定的 decimals 值。
NumPy 与小数的负值有关
import numpy as np
# Round to tenths place
print("Around 455.56 is:",np.around(455.56 , -1))
# Round to hundredths place
print("Around 455.56 is:",np.around(455.56 , -2))
# Round to thousandths place
print("Around 455.56 is:",np.around(455.56 , -3))
# Round to tenths place
print("Around 455 is:",np.around(455 , -1))
输出
Around 455.56 is: 460.0
Around 455.56 is: 500.0
Around 455.56 is: 0.0
Around 455 is: 460
如果 decimals 的值被设置为某个负值，则输入数字的非十进制位被舍入。
让我们来了解一下将 455.56 的小数位数设置为-2 时的舍入。这里，-2 表示数字中的第一百位。现在，计算数字中小数点左边的第一百位，相应地，数字被四舍五入。
注意:超出输入数字最左边的数字四舍五入将得到 0。
用 NumPy 数组来表示 NumPy
import numpy as np
a = np.array((1 , 3 , 5 , 100 , 145 , 344 , 745))
print("\n")
print("Input Array:\n",a)
print("Result :\n",np.around(a))
print("\n")
print("Input Array:\n",a)
print("Rounded Values:\n",np.around(a , -1))
b = np.array((0.5 , 1.5 , 1.7 , 3.5 , 7.5 , 9.8))
print("\n")
print("Input Array:\n",b)
print("Rounded Values:\n",np.around(b))
c = np.array((4.567 , 13.564 , 12.334 , 1.567 , 9.485 , 4.444))
print("\n")
print("Input Array:\n",c)
print("Rounded Values:\n",np.around(c , 2))
输出
Input Array:
[ 1 3 5 100 145 344 745]
Result :
[ 1 3 5 100 145 344 745]
Input Array:
[ 1 3 5 100 145 344 745]
Rounded Values:
[ 0 0 0 100 140 340 740]
Input Array:
[0.5 1.5 1.7 3.5 7.5 9.8]
Rounded Values:
[ 0\. 2\. 2\. 4\. 8\. 10.]
Input Array:
[ 4.567 13.564 12.334 1.567 9.485 4.444]
Rounded Values:
[ 4.57 13.56 12.33 1.57 9.48 4.44]
有一件有趣的事情需要注意，**np.around(** ) 舍入后返回一个新的 ndarray 并且不影响原来的 ndarray。
这就是第三个参数发挥作用的地方。
在不带参数的情况下使用 NumPy
import numpy as np
a = np.array((1.34 , 2.56 , 3.99 , 45.45 , 100.01))
print("Original Array:\n",a)
np.around(a , out=a)
print("Array after Rounding the values:\n",a)
输出
Original Array:
[ 1.34 2.56 3.99 45.45 100.01]
Array after Rounding the values:
[ 1\. 3\. 4\. 45\. 100.]
在上面的程序中，舍入后的值存储在原始数组中。
以上都是我的观点，请执行本文中讨论的代码，并尝试使用带有不同输入的函数。请务必查看 NumPy around 函数的官方文档。
参考
Numpy average()函数–简要概述
原文：https://www.askpython.com/python-modules/numpy/numpy-average-function
首先这篇文章的主要标题给了我们所有人一个聪明的想法，这个函数的用途是什么。一些有统计学背景的人非常了解平均术语。数据科学和人工智能从业者有意或无意地在预处理方法中使用这个术语。让我们进一步了解更多的细节。
介绍
在一般统计中，平均值是所有数字的值除以它们的总数。这背后的主要工作有助于我们理解数据集的核心价值。
举个例子:我们有六个不同的值，彼此略有不同。它们是一些公司员工的工资。任务是找出每个人每年的最佳收入。
解决方案:假设我们有LPAas:
- Four hundred thousand
- Four hundred and fifty thousand
- Five hundred thousand
- Four hundred and seventy thousand
- Four hundred and sixty thousand
- Five hundred thousand
然后我们取平均值。下面是这个的公式:
Average/Mean Formula
因此，我们计算平均值如下:
平均值=(400000+450000+500000+470000+460000+500000)/6
答案是:每年 463333.3334 万卢比。这是每人一年的平均工资。
基本概念
从上面的例子中，我们知道了主要的优点。最佳值是计算各种参数所必需的。均值在现实世界中有各种各样的应用。
- 预测一个州的平均收入。
- 决定商品在市场上的最佳销售价格。
- 测试分数的标准化涉及平均值计算。
这些值相差很大，对这个术语有各种各样的修改:
- 算术手段:用于统计分析表格数据。
- 常规均值/平均值:常用于常见的数学运算。
现在，我们将使用第二种形式。
在 Python 中实现平均函数
这有两种方法。
- 为我们的任务创建一个 average()函数。
- 使用 numpy 内置的 numpy 库。平均值() 函数。
为任务创建一个 average()函数
这个函数的创建非常简单明了。但是，我们需要注意一点，我们应该使用哪种格式的输入。所以数组是正确的格式。因为在数组中我们可以存储不同数量的值。
代码:
# function that takes the average of the elements
def average(value):
avg = sum(value)/len(value)
print('The average is: ', abs(avg))
# main method for the user input
def main():
'For the input arguments'
li = [] # declaring an empty list
a = int(input('Enter the number of values for the array: '))
for i in range(a):
li.append(int(input('Enter the {0} element: '.format(i+1))))
print('The list is: ', li, '\n')
average(li)
main()
输出:
Output For The Created Function
说明:
- 声明一个函数即 average()。然后给出里面的均值的必要公式。所有值之和与几个值之和的除法。
- 然后主函数让核心工作。它将数组作为用户的输入。然后，它获取输入的数量并打印数组。
- 然后我们在 main 函数中调用 average 函数，它将同一个数组作为输入参数。然后我们得到所有元素的平均值。
为任务使用 numpy 库
Numpy 库的 average()函数使我们的任务变得简单了一些。我们都知道这个 API 是著名的数组操作库之一。几个内置的方法减少了我们的代码，使一些事情更容易实现。它的类型是 NumPy ndarray。在开始使用average()函数之前，我们将首先声明一些核心步骤。
- 将 NumPy 模块作为 np 导入。
- 通过 np.array()方法声明一个数组。
- 然后调用 average()函数，并将数组作为其内部的输入参数。
- 将所有这些存储在一个变量中，并将结果打印在屏幕上。
1D 阵列代码:
import numpy as np
array = np.array([22, 12, 3, -1, -3, 98])
a = np.average(array)
print('The average of the elements in the array is: ', abs(round(a, 3)))
# output:
# The average of the elements in the array is: 21.833
说明:
- 在 NumPy 模块的 array()方法中声明一个数组。
- 然后声明一个存储平均值的变量。然后调用 average()函数，并将其中的同一个数组作为参数。
- 我们使用 abs() 函数来获得绝对值。然后我们使用round()函数将它四舍五入到小数点后三位。
- 将数值打印在屏幕上。
三维阵列代码:
import numpy as np
array = np.array([[22, 12, 3],[-1, -3, 98], [3, 44, 0]])
a = np.average(array)
print('The average of the elements in the array is: ', abs(round(a, 3)))
# Output:
# The average of the elements in the array is: 19.778
我们有一个 3D 数组来检查函数是否对那些数组有用。使用纸和笔来解决这个问题是一项非常繁琐的任务。我们已经得到了所需的结果。
结论
结束这个话题并不容易，因为还有很多事情要做。这是一个有趣的话题，人们可以从中获得 Numpy 库为特殊数学运算提供的各种函数的核心知识。因此，请再次查看代码实现，以便更好地理解。
5 NumPy 位运算就知道了！
原文：https://www.askpython.com/python-modules/numpy/numpy-bitwise-operations
读者朋友们，你们好！在本文中，我们将重点关注我们应该知道的 5 NumPy 位操作！
所以，让我们开始吧！
首先，按位操作符帮助我们执行位级操作，即通过函数中包含的抽象层进行逐位操作。
在主题课程中，我们将在本文中讨论以下主题——
- 和操作
- 或操作
- 异或运算
- 反转操作
- 整数到二进制表示法
让我们开始吧！🙂
1.NumPy 位操作–AND
NumPy 位 AND 运算符使我们能够像输入值一样对数组执行位 AND 运算。也就是说，它对输入整数值的二进制表示执行 AND 运算。
语法:
numpy.bitwise_and(num1,num2)
举例:
在下面的示例中，bitwise_and()函数将整数值 2 和 3 转换为等效的二进制值，即 2 ~ 010 和 3 ~ 011。此外，它执行 AND 运算，如果两个等价位都是 1，则返回 1 作为结果位，否则返回 0。
import numpy as np
x = 2
y = 3
print ("x=",x)
print ("y=",y)
res_and = np.bitwise_and(x, y)
print ("Bitwise AND result: ", res_and)
输出:
x= 2
y= 3
Bitwise AND result: 2
2.按位或运算
与 AND 运算一样， NumPy 也为我们提供了numpy.bitwise_or() function，使我们能够对数据值执行 NumPy 位“或”运算。
语法:
numpy.bitwise_or(num1,num2)
举例:
在本例中，bitwise_or()函数对两个整数值执行 or 运算。在 OR 运算中，如果两位相同，即 0/0，则返回 0，否则返回 1。
import numpy as np
x = 2
y = 3
print ("x=",x)
print ("y=",y)
res_or = np.bitwise_or(x, y)
print ("Bitwise OR result: ", res_or)
输出:
x= 2
y= 3
Bitwise OR result: 3
3.逐位异或运算
XOR 运算是 NumPy 位运算之一。我们可以使用 numpy.bitwise_xor()函数来执行运算。这样，我们可以很容易地对使用的逐位数据执行逐位 XOR 运算。
举例:
import numpy as np
x = 2
y = 3
print ("x=",x)
print ("y=",y)
res_xor = np.bitwise_xor(x, y)
print ("Bitwise XOR result: ", res_xor)
输出:
x= 2
y= 3
Bitwise XOR result: 1
4.逐位反转操作
使用 numpy.invert()函数执行按位反转操作。我们的意思是，它对内部处理为二进制表示格式的数据位执行逐位 NOT 运算。
对于有符号整数，返回二进制补码值。
举例:
import numpy as np
x = 2
y = 3
print ("x=",x)
res = np.invert(x)
print ("Bitwise Invert operation result: ", res)
输出:
x= 2
Bitwise Invert operation result: -3
5.二进制表示法
使用 NumPy 模块，我们可以显式地将整数值转换为二进制数。 binary_repr() 函数使我们能够轻松地将整数数据值转换为二进制值。
语法:
numpy.binary_repr()
举例:
import numpy as np
x = 7
print ("x=",x)
res = np.binary_repr(x)
print ("Bitwise representation of x: ", res)
输出:
在本例中，我们已经将 int 值“7”转换为其等效的二进制表示形式。
x= 7
Bitwise representation of x: 111
结论
到此，我们就结束了这个话题。如果你遇到任何问题，欢迎在下面评论。
更多与 Python 编程相关的帖子，请继续关注我们。
在那之前，学习愉快！！🙂
Numpy 布尔数组——初学者简易指南
原文：https://www.askpython.com/python-modules/numpy/numpy-boolean-array
Numpy 布尔数组是一种数组(值的集合)，可用于表示 Python 编程语言中数组数据结构中存储的逻辑“真”或“假”值。
当需要来自一个或多个复杂变量的单个逻辑值时，结合逻辑运算符使用布尔数组可以是减少运行时计算需求的有效方式。布尔数组在执行某些运算时，在结果数组中也很有用。
虽然乍一看这种结构似乎没什么用处，但它对初学者来说尤其重要，因为初学者在熟悉其他更灵活的复杂 Python 数据类型之前，常常会发现自己在使用布尔变量和数组。
Python 中的布尔数组是使用 NumPy python 库实现的。Numpy 包含一种特殊的数据类型，称为
numpy。BooleanArray(count，dtype=bool)。这会产生一个布尔值数组(与位整数相反),其中的值为 0 或 1。
声明 Numpy 布尔数组
可以手动使用 dtype=bool，创建布尔数组。在布尔数组中，除“0”、“False”、“None”或空字符串之外的所有值都被视为 True。
import numpy as np
arr = np.array([5, 0.001, 1, 0, 'g', None, True, False, '' "], dtype=bool)
print(bool_arr)
#Output: [True True True False True False True False False]
Numpy 布尔数组–关系运算
当在 numpy 布尔数组上执行关系运算时，在条件匹配的情况下，所有值被打印为真，否则其他值被打印为假。在下面的代码示例中演示了等效操作，其中检查布尔数组的值是否等于 2。
import numpy as np
A = np.array([2, 5, 7, 3, 2, 10, 2])
print(A == 2)
#Output: [True False False False True False True]
对于计算来说，诸如:""、"<=”, and “> = "之类的关系运算也同样有效。
该操作也适用于高维数组:
import numpy as np
# a 4x3 numpy array
A = np.array([[35, 67, 23, 90], [89, 101, 55, 12], [45, 2, 72, 33]])
print (A>=35)
#Output: [[ True True False True] [ True True True False] [ True False True False]]
同样，真/假可以用 0/1 代替，使用 astype() 对象将其转换为 int 类型。
import numpy as np
A = np.array([[90, 11, 9, 2, 34, 3, 19, 100, 41], [21, 64, 12, 65, 14, 16, 10, 122, 11], [10, 5, 12, 15, 14, 16, 10, 12, 12], [ 49, 51, 60, 75, 43, 86, 25, 22, 30]])
B = A < 20
B.astype(np.int)
#Output: array([[0, 1, 1, 1, 0, 1, 1, 0, 0], [0, 0, 1, 0, 1, 1, 1, 0, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1], [0, 0, 0, 0, 0, 0, 0, 0, 0]])
其中，在 int 类型中，0 表示 False，1 表示 True。
Numpy 布尔数组–逻辑运算
逻辑运算，例如:AND、OR、NOT、XOR，也可以用下面的语法方法在布尔数组上运算。
numpy.logical_and(a,b)
numpy.logical_or(a,b)
numpy.logical_not(a,b)
# a and b are single variables or a list/array.
#Output: Boolean value
Numpy 布尔数组索引
它是 Numpy 的一个属性，您可以使用它来访问使用布尔数组的数组的特定值。还准备了更多关于数组索引在这里。
import numpy as np
# 1D Boolean indexing
A = np.array([1, 2, 3])B = np.array([True, False, True])
print(A[B])
# Output: [1, 3]
# 2D Boolean indexing
A = np.array([4, 3, 7], [1, 2, 5])
B = np.array([True, False, True], [False, False, True])
print(A[B])
#Output: [4, 7, 5]
结论
使用 Numpy 的布尔数组是一种简单的方法，可以确保数组的内容是您所期望的，而不必检查每个元素。希望您已经很好地了解了 numpy 布尔数组，以及如何实现它和对它执行操作。
数字广播:初学者指南
原文：https://www.askpython.com/python-modules/numpy/numpy-broadcasting
在本指南中，我们将从初学者的角度讨论 Numpy 广播。本指南假定您对该主题没有任何先验知识，因此我们将从基础开始帮助您入门。
什么是 Numpy 广播？
“广播”一词描述了 numpy 在算术运算中如何处理不同形状的数组。在某些约束条件下，较小的阵列在较大的阵列中“广播”,以便它们具有兼容的形状。广播提供了一种向量化数组操作的方法，因此循环在 C 而不是 Python 中发生。
让我们举个小例子来理解这一点。我们将两个数组添加到不同的维度，以理解 NumPy 的广播机制。
import numpy as np
arr = np.arange(3)
result = arr + 4
这里 arr 有一个维度(轴)，长度为 3，另一方面，长度为 5。是一个简单的整数，理论上有 0 维。由于它们具有不同的维度，Numpy 试图沿着特定的轴传播(简单地拉伸)较小的数组，使其适合进行数学运算。
Numpy 广播规则
Numpy broadcasting 有一套严格的规则来保证阵列操作的一致性和防故障性。这是 numpy 广播的两条一般规则:
- 当我们在 NumPy 数组上执行操作时，NumPy 从右到左逐个元素地比较数组的形状。只有当两个维度相等或其中一个为 1 时，它们才是相容的。如果两个维度相等，则数组保持不变。如果维度为 1，则数组沿该维度传播。如果两个条件都不满足，NumPy 抛出一个 ValueError，表示数组不能被广播。数组广播当且仅当所有维度兼容。
- 被比较的数组不需要具有相同的维数。具有较少维数的阵列可以容易地沿着缺少的维数缩放。
实现数字广播
这里有几个例子可以更好地理解这些规则:
a = np.arange(12).reshape(4, 3)
print("Shape of a is:", a.shape)
b = np.arange(4).reshape(4, 1)
print("Shape of b is:", b.shape)
print("Sum: \n", a + b)
具有兼容维数的数组之和:数组具有兼容的维数(4，3)和(4，1)。数组 b 沿第二维拉伸，以匹配 a 的维度。
a = np.arange(16).reshape(4, 4)
print("Shape of a is:", a.shape)
b = np.arange(4).reshape(4, 2)
print("Shape of b is:", b.shape)
print("Sum: \n", a + b)
维数是(4，4)和(4，2)。广播失败，因为广播的维度最初必须为 1。
a = np.arange(15).reshape(5, 3)
print("Shape of a is:", a.shape)
b = np.arange(3)
print("Shape of b is:", b.shape)
print("Sum: \n", a + b)
这里数组的维数是(5，3)和(3)。数组 b 少了一个维度。因为维度的比较是从右到左进行的，所以 b 沿着第一维被拉伸。
a = np.arange(32).reshape(4, 4, 1, 2)
print("Shape of a is:", a.shape)
b = np.arange(8).reshape(1,4,2)
print("Shape of b is:", b.shape)
print("Shape of the sum: \n", (a + b).shape)
值得注意的是，可以沿多个维度广播多个阵列。数组 a 的维数为(4，4，1，2)，数组 b 的维数为(1，4，2)。数组 a 沿第三个维度拉伸，而数组 b 沿第一个和第二个维度拉伸，得到的数组的维度为(4，4，4，2)。
速度广播的好处
Numpy 广播比在阵列上循环更快。让我们举第一个例子。用户可以决定不使用广播机制，而是循环遍历整个数组，将相同的数字添加到数组中的每个元素。这可能会很慢，主要有两个原因——循环涉及到与 python 循环的交互，这会降低 C 实现的速度。其次，NumPy 使用大踏步而不是循环。将步幅大小设置为 0 可以让您无限重复这些元素，而不会产生任何内存开销。
结论
Numpy 广播提供了一种处理两个不同形状的数组的快速和内存高效的方法。在广播两个阵列之前，用户需要注意某些规则。
参考文献:
numpy ceil–返回输入的上限，以元素为单位
原文:# t0]https://www . aspython . com/python-modules/num py/numpy-ceil
在本教程中，我们今天将讨论如何返回输入的上限。这将通过使用 python 和 google collab 来完成。回想一下，你年轻的时候可能尝试过最大整数函数和最小整数函数。ceil 函数是最小的整数函数，而 floor 函数是最大的整数函数。我们将在今天的代码片段中实现所有这些。让我们开始吧。
什么是天花板功能？
输入 x 的上限函数是最近的最小整数 I，因此 I 应该大于或等于 x。它被表示为
。让我们观察下面的例子。
- 0.366 的上限函数将是 1。因为 1 是大于 0.366 的最近的最小整数。
- -0.366 的上限函数将是 0。因为 0 是大于-0.366 的最近的最小整数。
- -3 的上限函数是-3。因为-3 是大于或等于-3 的最近的最小整数。
NumPy.ceil()函数用于将一个数字向上舍入到最接近的整数。这个函数是从 Numpy 库导入的，这是一个 Python 编程语言的库，支持对数组和矩阵进行数学运算。此函数可应用于单值输入以及数组。
实现 Numpy.ceil()方法
今天我们将看到如何为一个正值、一个负值、一个整数和一个数组实现这个函数。让我们看看下面使用这个函数的语法。
numpy.ceil(x, out=None, where=True, casting='same_kind', order='K', subok : [bool, datatype])
上述代码片段中使用的参数如下:
- x: 它可以是包含弧度值的变量，也可以是包含某个值的数组
- out: 存储结果的位置。如果提供了，它必须具有与输入 x 相似的形状。如果没有提供或没有提供，则返回新的值或结果。这是可选的。
- 当条件为真时，我们必须得到我们的结果或输出；当条件为假时，我们将得不到任何结果。这是可选的。y 默认其值为真。
- casting='same_kind': 表示只允许 float64 到 float32 的值或结果。该函数在此范围或数据类型中呼喊 cast 值。
- order = 'K': 它总是以 K 排序的形式产生一个输出数组。(注意:有四种类型的订单:{‘K’，‘C’，‘F’，‘A’})。这是可选的。
- subok:【bool，datatype】是否生成结果的子类。如果为真，则提供子类的名称。它返回一个与给定数组具有相同形状和类型的数组。也是可选的。
现在，我们将在下面的代码片段中实现相同的功能。通过在每个代码片段中传递不同的输入，我们将有四个代码片段来实现这个功能。让我们得到它。
正数的 Numpy.ceil()函数
import numpy as np
a = np.ceil(0.366)
a
#output
1.0
在上面的代码片段中，我们在导入 Numpy 库之后实现了我们的Numpy.ceil()函数。我们传递了一个正的小数值作为它的参数，得到了与上面例子中相同的结果。
负数的上限函数
类似地，让我们尝试传递一个负的小数值，看看下面的结果。
import numpy as np
b = np.ceil(-0.366)
b
#output
-0.0
阵列的上限函数
这一次，我们将传递一个包含如下值的数组。让我们看看结果如何。
import numpy as np
import math
input = np.array([-2.35,-1, -0.36, 0, 0.36, 1, 5.69, 5%2, 5/2, math.pi ])
c = np.ceil(input)
c
#output
array([-2., -1., -0., 0., 1., 1., 6., 1., 3., 4.])
你可以看到它给了我们一个数组，输入数组中所有元素的上限函数。让我们关注最后两个元素，我们已经通过了 5%2、5/2 和 math.pi。您分析它对这种类型的输入有什么反应吗？它分别计算出 5%2 = 1、5/2 = 2.5 和 math.pi = 22/7 =3.142857142857…的值，然后分别为 1、2.5 和 3.142857142857…实现上限函数。
还有一点，我们都需要注意，输出数组包含了 float 数据类型的所有值。所以，请确定，我们语法中的数据类型默认为 float，它总是以 float 或 decimal 给出输出。
复数的上限函数
import numpy as np
import cmath
x=5
y=6
z=complex(x,y)
print(z)
d = np.ceil(z)
print(d)
正如我们所看到的，我们导入了 " cmath " 模块，使用 complex() 方法创建了一个复杂的数字，并最终将其传递给我们的 numpy.ceil() 函数。让我们看看它对我们的输入是如何反应的。让我们打印出 d 的值。
print(z)
print(d)
(5+6j) #value of z
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-12-b0ea321d89b0> in <module>
5 z=complex(x,y)
6 print(z)
----> 7 d = np.ceil(z)
8 print(b)
TypeError: ufunc 'ceil' not supported for the input types, and the inputs could not be safely coerced to any supported types according to the casting rule ''safe''
您可以看到它抛出了一个错误。你知道错误是什么吗？ceil 功能不支持这种类型的输入。
在图形上绘制 numpy.ceil()
在下面的代码片段中，我们创建了空数组 x[]和 y[]。使用 while 循环，我们已经将输入值从-3.99 开始加载到 x[]数组中，从 4.00 开始按顺序增加 0.01。在实现了ceil函数之后，我们将各自的结果加载到 y[]数组中。使用 x[]和 y[]数组，我们使用matplotlib.pyplot 库及其支持方法绘制了我们的图表。
import matplotlib.pyplot as plt
import numpy
x=[]
y=[]
i=-3.99
while (i<4.00):
x.append(i)
y.append(numpy.ceil(i))
i=i+0.01
plt.xlabel("x axis - input")
plt.ylabel("y axis - output = (numpy.ceil(input))")
plt.grid(linestyle='-', linewidth=0.5,color='red')
plt.plot(x,y, linewidth=3, color = 'black')
结论
今天尝试了我们的天花板功能后，发现它更容易理解和学习。我们尝试了不同类型的输入，得到了不同的输出。我们现在更明白了。我们将带着一些更激动人心的话题回来。谢谢你。
numpy Clip–裁剪(限制)数组中的值
原文：https://www.askpython.com/python-modules/numpy/numpy-clip
Python 的 NumPy 模块提供了一种裁剪数组元素的方法。方法名为 numpy.clip()。让我们更详细地探索 numpy.clip 方法。
Numpy.clip()方法是什么？
Numpy.clip()方法是一个函数，它采用一个由数字、最小值和最大值组成的数组，并返回一个数组，其中指定范围之外的所有值都替换为指定的最小/最大值。
这对于确保数组中的所有值都在某个范围内很有用，例如用于缩放或标准化数据。它还可以用于将数组中的值的范围限制在某个范围内。
定义 numpy.clip()
Numpy 是 Python 中执行数学和科学运算的强大模块。要使用它，首先确保通过在命令提示符 shell 中键入'pip3 install numpy'来安装它。
安装后，您可以使用“numpy.clip()”函数来限制数组中值的范围。这在某些数据处理场景中很有用。
numpy.clip()的语法
numpy.clip(array, array_min_element, array_max_element, out=None)
numpy . clip()方法有三个参数:
- 数组:要裁剪的值的数组。
- array_min_element :数组元素允许达到的最小值。
- array_max_element :数组元素允许达到的最大值。
- out(可选):可选输出数组。
clip()函数的工作原理
clip()函数的作用是:在指定的范围内裁剪数组中的元素。它是这样工作的:
- 指定数组以及第二个和第三个参数之间的范围(array_Minimum_limit，array_maximum_limit)。
- 如果原始数组中的所有元素都小于或等于最小限制，它们将被替换并显示为最小限制。
- 其余元素将与最大限制进行比较。
- 如果元素小于最大限制，将打印原始数组中的值。
- 如果元素等于最大限制，将打印“10”。如果超过最大限制，它将被替换为最大限制。
注意:原始数组和剪切后的数组的长度是相同的。
Numpy.clip()的实例
让我们从最基本的例子开始，这样你就能理解它是如何工作的。这里我们将使用 numpy.arange()方法。
import numpy as np
x= np.arange(12)
print("x:",x)
y = np.clip(x,2,12)
print("y:",y)
Values Replaced By the Minimum and Maximum Limit.
上面使用的参数
x: original_array
包含要裁剪元素的数组。array_min_element, array_max_element: 超过极限范围。
给定区间边的最小值和最大值。没有可以给任何边，裁剪不会对相应的边起作用，只有参数中的一个可以是无。out: ndarray,可选
clip()函数返回 ndarray，结果将存储在该数组中。它可以是代替剪辑数组的原始/输入数组。如果是输入数组，它会更新原始数组的值，并存储剪辑后的值。- 返回:
一个包含 x 个元素的数组(原始数组)，其中值< =最小值被替换为 array_min_element，值> =最大值被替换为 array_max_element。
为了更好地理解，以下是几个不同输入的例子。
示例 1:基本数组剪辑
此代码创建一个从 0 到 9 的数字数组(a ),然后使用 Numpy.clip()方法创建一个新数组(x ),其中 4 和 8 以外的所有值都替换为 4 或 8。在这种情况下，数组 x 中的所有值将介于 4 和 8 之间，包括 4 和 8。
import numpy as np
a = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
x=np.clip(a, 4, 8)
print("a:",a)
print("x:",x)
Example 1: Values Replaced By Min Limit And Max Limit
示例 2:当最小值限制>最大值限制时
这段代码创建了一个从 0 到 8 的数字数组“a”。然后，它使用 Numpy.clip()方法创建一个新数组“x ”,用指定的最小/最大值替换范围 1 到 8 之外的所有值。在这种情况下，所有小于 1 的值将被替换为 1，所有大于 8 的值将被替换为 8。因此得到的数组“x”将包含值 1、2、3、4、5、6、7 和 8。
import numpy as np
a = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8])
x=np.clip(a, 8, 1)
print("a:",a)
print("x:",x)
Example 2: When Minimumim Limit Is More Than Maximum Limit
当array_min大于array_max,时，clip返回一个数组，其中所有值都等于 array_max ，如第二个例子所示。
示例 3:使用“out”参数
这段代码导入 Numpy 库，并创建一个名为“a”的数组，其值从 0 到 8。然后，使用 Numpy.clip()方法将数组“a”中的值裁剪到 3 到 6 之间的范围。
out 参数意味着新数组将覆盖原始数组“a”。结果是数组“a”现在只包含值 3、4、5 和 6。
import numpy as np
a = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8])
print("a:",a)
x=np.clip(a, 3, 6, out=a)
print("x:",x)
print("a:",a)
Example 3: Using Out Parameter
在这里，输入数组得到更新。
示例 4:使用列表作为最小限制。
这段代码演示了 Numpy.clip()方法的用法。它创建一个包含数字 0 到 9 的数组“a ”,然后使用 Numpy.clip()函数创建一个包含“a”中所有值的新数组“x ”,并将范围[3，4，1，1，1，4，4，4，4，4]之外的任何值替换为最小/最大值 6。
import numpy as np
a = np.arange(10)
x=np.clip(a, [3, 4, 1, 1, 1, 4, 4, 4, 4, 4], 6)
print("a:",a)
print("x:",x)
Example 4 Using List As Minimum Limit
摘要
Numpy.clip()方法是一个有用的函数，用于将数组元素裁剪到某个范围。它接受一个数字数组、一个最小值和一个最大值，并返回一个数组，其中指定范围之外的所有值都替换为指定的最小/最大值。这可用于限制数组中值的范围，也可用于缩放或标准化数据。out 参数可用于将结果存储在输入数组中，这对于用截取的值覆盖原始数组非常有用。
NumPy conj–返回输入数字的复共轭
原文:# t0]https://www . aspython . com/python-modules/num py/numpy-conj
嘿大家，欢迎来到另一个 NumPy 数学函数教程。在本教程中，我们将详细了解 NumPy conj 功能。
通过简单地改变虚部的符号，可以获得复数的共轭。
比如复数 10-8j 的共轭是 10+8j 。我们可以使用 numpy.conj() 函数获得复数的共轭。
那么，我们开始吧。
关于 NumPy conj
NumPy conj 是 NumPy 库的一个数学函数，它计算输入复数的复共轭。
句法
根据定义，这听起来很简单，对吗？现在，让我们看看函数的语法。
numpy.conj(input)
这里，输入可以是单个复数，也可以是复数的 NumPy 数组。
使用 NumPy conj
现在，让我们用 python 做一些编程。
单个复数的 NumPy conj
import numpy as np
# Complex Conjugate of a Complex number with real and imaginary parts
print("The complex conjugate of 1+6j is:",np.conj(1+6j))
print("The complex conjugate of 1-6j is:",np.conj(1-6j))
# Complex Conjugate of a Complex number with only imaginary part
print("The complex conjugate of 0+6j is:",np.conj(0+6j))
print("The complex conjugate of 0-6j is:",np.conj(0-6j))
# Complex Conjugate of a Complex number with only real part
print("The complex conjugate of 1 is:",np.conj(1))
print("The complex conjugate of -1 is:",np.conj(-1))
输出
The complex conjugate of 1+6j is: (1-6j)
The complex conjugate of 1-6j is: (1+6j)
The complex conjugate of 0+6j is: -6j
The complex conjugate of 0-6j is: 6j
The complex conjugate of 1 is: 1
The complex conjugate of -1 is: -1
在上面的代码片段中，NumPy 库是使用 import 语句导入的，函数 np.conj() 用于计算输入复数的复共轭。
让我们了解一下这些值是如何计算的。
对于复数 1+6j ，通过改变虚部的符号得到共轭，因此输出为 1-6j 。
对于复数 1 ，共轭将与输入的复数相同。这是因为数字 1 可以写成 1+0j ，其中虚部为 0，因此输出与输入的复数相同。
现在，让我们传递复数的 NumPy 数组，并计算复共轭。
复数的 NumPy 数组的 NumPy conj
import numpy as np
a = np.array((1+3j , 0+6j , 5-4j))
b = np.conj(a)
print("Input Array:\n",a)
print("Output Array:\n",b)
输出
Input Array:
[1.+3.j 0.+6.j 5.-4.j]
Output Array:
[1.-3.j 0.-6.j 5.+4.j]
在上面的代码片段中，使用存储在变量 a 中的 np.array() 创建了一个复数数组。变量 b 存储输入数组的共轭值，该数组也是一个 NumPy 数组。
np.conj() 计算输入数组中每个元素的共轭。
在接下来的几行中，我们使用了 print 语句来打印输入数组和输出数组。
使用 NumPy eye 函数的 NumPy 数组的 NumPy conj
在这段代码中，我们将使用 numpy.eye() 创建一个 NumPy 数组。
import numpy as np
a = np.eye(2) + 1j * np.eye(2)
b = np.conj(a)
print("Input Array:\n",a)
print("Conjugated Values:\n",b)
输出
Input Array:
[[1.+1.j 0.+0.j]
[0.+0.j 1.+1.j]]
Conjugated Values:
[[1.-1.j 0.-0.j]
[0.-0.j 1.-1.j]]
让我们试着理解上面的代码片段。
- 在第一行中，我们使用
**import**语句导入 NumPy 库。 - 函数
**np.eye(2)**创建一个 2×2 的数组，其中对角元素为 1，其他元素为 0。 - 类似地，表达式
1j * np.eye(2)创建一个 2×2 的数组，其中对角元素为 1j，其他元素为 0。 - 然后，表达式
**np.eye(2)**+1j * np.eye(2)将两个数组对应的元素相加，存储在变量 a 中。 - 在下一行中，我们使用了
np.conj()函数来计算共轭值。
这就是使用 NumPy conj 函数的全部内容。
摘要
在本教程中，您学习了 NumPy conj 函数，并练习了不同类型的示例。还有一个功能 numpy.conjugate() ，其工作方式与 numpy.conj() 功能完全相同。快乐学习，坚持编码。
参考
num py documentation–num py conj
NumPy.copy():如何复制 NumPy 数组
原文：https://www.askpython.com/python-modules/numpy/numpy-copy
今天我们要学习如何复制一个 NumPy 数组。我们也将在代码片段中尝试不同的方法。希望你们能和我们一起练习，取得预期的成绩。让我们开始吧。
什么是 NumPy 数组？
数组是存储在连续内存位置的相似数据类型的数据集合。这是最简单的数据结构，其中每个数据元素都可以通过使用其索引号直接访问。在 Python 中，数组是 NumPy 库的一种数据结构。一个 NumPy 阵列 的一些关键特征给出如下。
- 它在本质上是同质的。我们可以对数组元素执行所有的操作。
- NumPy 中的数组可以是一维的，也可以是多维的。
- 它包含用于代码集成的工具。
- 我们可以创建不同数据类型的数组。
- NumPy 数组的所有元素在内存块中的大小相等。
让我们了解如何创建 NumPy 数组。我们可以按照下面的代码片段使用 Python IDLE shell 创建我们的第一个 NumPy 数组。让我们和你一起编码。
#importing the numpy module
import numpy as np
#creating array
my_array = np.array(["Hi", "Hello", "Welcome", "to", "JournalDev"])
#printing our array
print(my_array)
print(type(my_array))
上面的代码片段将给出如下输出，我们可以看到创建了一个数组，我们还打印了数组的类型，它是numpy.ndarray.
["Hi", "Hello", "Welcome", "to", "JournalDev"]
<class 'numpy.ndarray'>
在遵循我们的代码片段之前，请确保您已经在您的计算机上安装了 NumPy 模块，如果没有，您可以通过使用命令提示符中的 pip包安装程序来下载该模块，如下所示。
pip install numpy
现在，我们将理解使用不同方法复制 NumPy 数组的不同方式，如下所示。
1.使用 NumPy.copy()方法
方法创建了数组的一个副本。在下面的例子中，我们将使用这个方法把数组‘array‘复制到另一个数组‘copy_array‘。
#importing the numpy module
import numpy as np
# Creating a numpy Arrayusing numpy.array()
array = np.array([10.7, 16.94, 18.21, 25.50, 25.3, 56.9, 52.1])
#printing our original Array
print(array)
# Using numpy.copy() function
new_array= np.copy(array)
#printing the copied Arrayas new_array
print(new_array)
上面的代码片段将使用.copy() 方法将数组的内容复制到 new_array，并给出如下输出。
Copied Array
上述方法的语法为:
numpy.copy(array, order='K')
上述代码片段中的参数是:
array–要复制的阵列的名称order–控制复印的内存布局。默认情况下 order='K '。这是可选的。
2.复制多维数组
让我们看另一个复制多维 NumPy 数组的.copy()方法的例子。遵循下面的代码片段。
import numpy as np
# Creating a multi dimensional Array
array = np.array([['a','b','c'], ['h','d','s']])
#printing the original Array
print(array)
# using numpy.copy() method to copy
new_array = np.copy(array)
#printing the copied Array
print(new_array)
上面的代码片段将多维数组复制到新数组，并给出如下输出。
Copy Multidimensional Array 1
3.使用赋值运算符复制 Numpy 数组
import numpy as np
# creating a 2 Dimensional array
array = np.array([['a','b','c'], ['h','d','s']])
# using Assignment operator
new_array= array
# printing copied array
print(new_array)
在上面的代码片段中，数组的内容由赋值操作符“=”赋值给 new_array。让我们看看同样的输出。
Assignment Operator Example Output
4.使用 NumPy.empty_like()方法
import numpy as np
# creating an Array
array = np.array(["hello", "how", "are", "You"])
print(array)
# Creating an empty Numpy array similar to Array
new_array = np.empty_like(array)
# Now assign Array to copy
new_array [:] = array
#printing our new Array
print(new_array )
此方法返回具有相同数据的任意数据。它不会初始化值。因为它没有初始化，我们需要给它赋值。这样，我们就把数组复制到了 new_array。上面代码片段的输出如下所示。
Empty Like Method Example Output
摘要
在本文中，我已经通过示例学习了如何使用不同的方法创建 NumPy 数组的副本。希望你一定练习过并喜欢我们的代码片段。我们必须带着一些更令人兴奋的话题再次访问。
NumPy Cos–完整指南
原文:# t0]https://www . aspython . com/python-modules/num py/numpy-cos
欢迎来到 NumPy 三角函数 系列第二教程。在本教程中，我们将了解 NumPy Cos 函数。
NumPy 提供了许多三角函数， NumPy Cos 就是其中之一。就像 Numpy Sine 在 [-1，1] 范围内产生输出一样，余弦函数的输出也是一样的。
我们会练习很多例子，让我们的理解变得清晰，让我们开始吧。
什么是 NumPy Cos？
NumPy Cos 是 NumPy 库提供的三角函数之一，它计算单个数字的三角函数余弦函数以及角度的 NumPy 数组。
注意: NumPy Cos 函数可以作为numpy.cos访问
NumPy Cos 的语法
NumPy Cos 以弧度的角度作为参数。然而，角度在度中也可以作为自变量给出。
语法: numpy.cos(input)其中输入可以是单个数字，也可以是 NumPy 数组
单一角度的 Cos
让我们尝试一些 Numpy Cos 函数的例子来帮助我们更好地理解它。
圆周率值的余弦值
import numpy as np
print("Printing the Cosine Values\n")
print("Cosine of 0 is :",np.cos(0))
print("Cosine of pi/6 is :",np.cos(np.pi/6))
print("Cosine of pi/3 is :",np.cos(np.pi/3))
print("Cosine of pi/2 is :",np.cos(np.pi/2))
print("Cosine of pi is :",np.cos(np.pi))
输出
Printing the Cosine Values
Cosine of 0 is : 1.0
Cosine of pi/6 is : 0.8660254037844387
Cosine of pi/3 is : 0.5000000000000001
Cosine of pi/2 is : 6.123233995736766e-17
Cosine of pi is : -1.0
- 除了π/2 的余弦输出，每个输出都非常清楚。
- π/2的 Numpy 余弦提供了不同的输出——该输出采用科学记数法，指数为 10^(-17) ，等于 0。
现在，让我们看看如何将角度作为参数传递给 numpy.cos 函数。
带 Deg2Rad 函数的 Numpy Cos 函数
为了计算角度的余弦值，其中 cos 函数的自变量为度函数deg2rad被使用。
import numpy as np
print("Cosine of 30 degrees is :",np.sin(np.deg2rad(30)))
print("Cosine of 60 degrees is :",np.sin(np.deg2rad(60)))
print("Cosine of 90 degrees is :",np.sin(np.deg2rad(90)))
print("Cosine of 180 degrees is :",np.sin(np.deg2rad(180)))
输出
Cosine of 30 degrees is : 0.49999999999999994
Cosine of 60 degrees is : 0.8660254037844386
Cosine of 90 degrees is : 1.0
Cosine of 180 degrees is : 1.2246467991473532e-16
这是关于将角度作为参数传递给 numpy.cos()函数。
现在，让我们看看如何计算一组角度的余弦值。
多角度的数字余弦
cos 函数也将角度的 Numpy 数组作为参数，但是我们必须确保角度被转换为弧度。
角度数组上的数值余弦
import numpy as np
# A NumPy array with all the angles in degrees
a = np.array((0 , 30 , 45 , 60 , 90))
print("Cosine Values :\n",np.cos(a*np.pi/180))
# A NumPy array with all the angles is radians
b = np.array((0 , np.pi/2 , np.pi/3 , np.pi))
print("Cosine Values :\n",np.cos(b))
输出
Cosine Values :
[1.00000000e+00 8.66025404e-01 7.07106781e-01 5.00000000e-01
6.12323400e-17]
Cosine Values :
[ 1.000000e+00 6.123234e-17 5.000000e-01 -1.000000e+00]
在上面的代码片段中，输出是一个 NumPy 数组，其中的值非常奇怪。但是如果你仔细观察，你就会明白输出是用科学符号表示的。
等距 Numpy 数组上的 Numpy 余弦值
在这个例子中，我们将使用numpy.linspace创建一个由 30 个均匀分布的值组成的 NumPy 数组。
import numpy as np
a = np.linspace(-(2*np.pi) , 2*np.pi , 30)
print("Cosine Values: ",np.cos(a))
输出
Cosine Values: [ 1\. 0.90757542 0.64738628 0.26752834 -0.161782 -0.56118707
-0.85685718 -0.99413796 -0.94765317 -0.72599549 -0.37013816 0.05413891
0.46840844 0.79609307 0.97662056 0.97662056 0.79609307 0.46840844
0.05413891 -0.37013816 -0.72599549 -0.94765317 -0.99413796 -0.85685718
-0.56118707 -0.161782 0.26752834 0.64738628 0.90757542 1\. ]
这里，我们使用numpy.linspace创建了一个 NumPy 数组，它有 30 个均匀间隔的弧度角，范围从 -2pi 到 2pi 。
输出也是一个 NumPy 数组，它是数组元素的余弦值。
可视化 Cos 函数
import numpy as np
# Importing the Matplotlib Library
import matplotlib.pyplot as plt
# Creating a NumPy Array of 30 evenly-spaced elements
a = np.linspace((-2*np.pi),(2*np.pi),30)
# Storing the cosine values in a NumPy Array
b = np.cos(a)
plt.plot(a, b, color = "blue", marker = "o")
plt.title("numpy.cos()")
plt.xlabel("X")
plt.ylabel("Y")
plt.show()
输出
Cosine Plot
**plt.plot()**函数用于绘制带四个参数的余弦函数。
- 第个参数是角度的 NumPy 数组(在第 7 行创建)，绘制在 X 轴(水平轴)上。
- 第二个参数是 cos 函数的输出，以 NumPy 数组的形式存储在中，绘制在 Y 轴(垂直轴)上。
- 第三个参数是绘图的颜色。
- 第四个参数是标记值，用指定的标记强调每个点。有不同类型的标记可用于表示曲线上的点。
你现在知道余弦函数的曲线是什么样子了。
摘要
在本教程中，我们通过示例了解了如何使用 NumPy Cos 函数。如果你使用的是 Jupyter Notebook，那么在每个单元格中写完每一行代码后，按shift+enter来获得输出。
你的任务是使用 NumPy Cos 函数来计算你选择的更多值的余弦值。
在下一篇教程中，我们将详细讲解 NumPy Tan 函数。在那之前，请继续关注。
参考
num py documentation–num py cos
numpy cosh–双曲余弦，按元素
原文：https://www.askpython.com/python-modules/numpy/numpy-cosh-hyperbolic-cosine
今天我们要学习一个有趣的话题“如何用 Python 实现双曲余弦函数”。你必须知道所有的三角函数和相关术语，以及它们相应的角度概念。你小时候一定解过三角函数题。
和我们今天要实现的完全一样。唯一的区别是，我们不是在笔和纸上实现它，而是在我们的计算机上使用一个内置的方法，在我们的 python IDLE shell 上使用相应的模块来实现它。让我们开始吧。
什么是双曲三角函数？
首先让我们了解一下什么是双曲三角函数。这和普通三角函数有什么区别？
双曲函数也有点类似于三角函数。普通三角函数和双曲函数之间的唯一区别是，三角函数定义圆(圆弧度)内的值，而双曲函数定义双曲线而不是圆内的值。这些点构成了单位双曲线的右半部分。
下面描述了双曲函数的一些重要公式。让我们看看它们。
什么是双曲余弦？
这也是三个最有用的双曲函数。今天我们要学习其中的一个，就是双曲余弦函数。下面我们也可以用代码的形式来表示这个函数。
cosh (x) = 1/2 * (np.exp(x) + np.exp(-x))
使用 numpy.cosh()
但是在我们今天的代码片段中，我们不打算在今天的实现中使用上述代码。我们有一个预定义的双曲余弦函数，它是由 NumPy 库提供的。我们将使用相同的。
在本教程中，我们将学习如何找到弧度和复数值的双曲余弦函数。让我们快速看一下下面的语法。
numpy.cosh(x, out=None, where=True, casting='same_kind', order='K', subok : [bool, datatype])
上述代码片段中使用的参数如下:
- x: 它可以是包含弧度值的变量，也可以是包含某个值的数组
- out: 存储结果的位置。如果提供了，它必须具有与输入 x 相似的形状。如果没有提供或没有提供，则返回新的值或结果。这是可选的。
- 当条件为真时，我们必须得到我们的结果或输出；当条件为假时，我们将得不到任何结果。这是可选的。y 默认其值为真。
- casting='same_kind': 表示只允许 float64 到 float32 的值或结果。该函数在此范围或数据类型中呼喊 cast 值。
- order = 'K': 它总是以 K 排序的形式产生一个输出数组。(注意:有四种类型的订单:{‘K’，‘C’，‘F’，‘A’})。这是可选的。
- subok:【bool，datatype】是否生成结果的子类。如果为真，则提供子类的名称。它返回一个与给定数组具有相同形状和类型的数组。也是可选的。
现在，我们将看到如何通过在不同的方法中传递不同的参数来实现这个函数。
方法 1:传递单值参数
我们将为 x(即math.pi/ 5) 传递一个输入，并将结果加载到一个名为**output**的变量中。
import numpy as np
import math
output = np.cosh(math.pi/5)
我们可以通过打印同样的内容来看到最终的输出。
print(output)
1.2039720893382206
方法 2:传递多值参数
在这个方法中，我们将以数组的形式传递 x 的多输入值(即0, math.pi / 2, math.pi, 3 * math.pi/2, 2 * math.pi)，并将结果加载到一个名为another_output的变量中。
import numpy as np
import math
input = [0, math.pi / 2, math.pi, 3 * math.pi/2, 2 * math.pi]
another_output = np.cosh(input)
您可以看到我们已经创建了一个名为 input 的弧度数组，并在我们的Numpy.cosh()方法中传递了相同的内容。我们将结果数组加载到变量 another_output 中。让我们打印相同的。
print(another_output)
[ 1\. 2.50917848 11.59195328 55.66338089 267.74676148]
方法 3:提供可选的输出变量
让我们回忆一件小事。当我们讨论我们的NumPy.cosh() 方法的语法和参数时。有一个参数是“out”。它是存储结果的位置。如果提供了，它必须具有与输入 x 相似的形状。如果没有提供或没有提供，则返回新的值或结果。这是可选的。在这个方法中，我们将看到如何尝试这个参数。
在这个代码片段中，我们将提供一个"optional output"变量，输出/结果将被加载到这个变量中。看看下面是如何实现的。
import numpy as np
import math
optional_output = np.array([0, 0, 0, 0, 0], dtype='d')
#passing our optional_output array where the result should be loaded
np.cosh(input, optional_output)
#implementing the same and loading the result into the different_array
different_output = np.cosh(input)
您可以看到我们已经创建了一个名为“optional_output”的数组，它的形状与我们的输入数组相似。在我们的，numpy.cosh() method,我们曾经走过同一个地方。得到的数组将被加载到这个数组中。让我们打印出来，看看效果如何。
print(optional_output)
print(different_output)
[ 1\. 2.50917848 11.59195328 55.66338089 267.74676148]
[ 1\. 2.50917848 11.59195328 55.66338089 267.74676148]
方法 4:将复杂变量作为参数传递
让我们传递一个复杂的变量作为参数，看看结果。
import numpy as np
import math
import cmath
a = 2.0
b = 3.0
z = complex(a,b)
c = np.cosh(z)
为了使用一个复杂变量，我们需要导入一个名为**cmath**的库。然后使用 complex() 方法准备好我们的复杂变量，并在我们的 numpy.cosh() 方法中传递相同的变量，我们将得到我们的结果。让我们打印我们的结果。
print(z)
print(c)
(2+3j)
(-3.7245455049153224+0.5118225699873846j)
在图形上绘制 Numpy.cosh()
output_array = np.cosh(input)
print(output_array)
import matplotlib.pyplot as plt
plt.xlabel("input")
plt.ylabel("output_array")
plt.plot(input, output_array, color = 'green', marker = "*")
众所周知，为了在图上绘制一些东西，我们需要导入一个名为 Matplotlib 的附加库。我们导入了相同的方法，传递了在方法 2 中创建的输入数组。在实现我们的函数后，我们将我们的输出加载到" output_array "中。毕竟，我们用输入和输出数组表示了我们的函数，并得到了下面的结果。
摘要
最后，我们今天报道了我们的文章。通过传递四种不同类型的参数，我们尝试了四种不同的方法。这样就可以实现其他双曲函数了。您可以通过使用相同的代码片段并用我们需要的双曲函数替换函数语法来尝试所有这些方法。否则，我们将再次访问相同的。谢谢你。
Numpy 交叉产品–完整指南
原文：https://www.askpython.com/python-modules/numpy/numpy-cross-product
叉积是一种数学工具，用于计算两个矢量坐标的垂直矢量分量。
假设在一个 3D 空间中，有两个点:
- 坐标为(1，2，3)的 a '
- b '坐标为(4，5，6)。
所以两个坐标的向量分量，将是这个向量矩阵的行列式的叉积。
叉积将是两个矩阵点的非交换垂直矢量积。
Numpy 叉积
numpy.cross()是 Python 库中的一个数学函数，它找出两个数组(维数为 2&3)之间的叉积，结果可以用打印函数显示。
Numpy 叉积的语法
实现叉积的基本语法是:
np.cross[M,N]
其中 M 和 N 是存储向量坐标的数组变量，但是我们可以根据我们的适用性和需要指定某些参数。
Numpy Cross Syntax
如何用 Numpy Python 计算叉积？
让我们看一个关于如何在 python 中找到叉积的函数代码。
1.2X2 矩阵的叉积
假设有两个数组，X= [2，3]，Y= [4，3]。为了求向量积，我们需要求 i1-j2 和 i2-j1 的乘积之差。两个二维数组的矢量积总是一维整数。
2X2 cross product
最终结果是(3 * 2)–(4 * 3)=-6。
注意:在这种情况下，X 和 Y 维度是在 z 分量不存在的情况下定义的，因此最终输出是标量。
示例代码:
import numpy as pr
#initialize arrays
X = pr.array([2, 3])
Y = pr.array([4, 3])
#calculating cross product
vector_result= pr.cross(X,Y)
print(vector_result)
2.2×3 阵列的叉积
让我们取两个三维数组，求它的叉积。
让我们取 X= [1，3，5]和 Y= [1，2，1]
2X3 matrix cross product
这里，最终的输出将是= (-7，4，-1)
示例代码:
import numpy as pr
#initialize arrays
X = pr.array([1, 3, 5])
Y = pr.array([1, 2, 1])
#calculating cross product
cross_product= pr.cross(X,Y)
print(cross_product)
注意:numpy 叉积支持 2 维和 3 维矩阵，任何高维矩阵都将抛出错误输出。
让我们再举一个例子，假设 M=[5，6，4]和 N=[2，1]
示例代码:
import numpy as pr
#initialize arrays
X = pr.array([5, 6, 4])
Y = pr.array([2, 1])
#calculating cross product
cross_product= pr.cross(X,Y)
print(cross_product)
这里，编译器自动将数组 N 的 z 分量赋值为零，并基于该参数计算最终输出。最终结果= [-4，8，-7]
结论
在本文中，我们学习了如何使用 python 数学函数“numpy.cross”来计算两个向量数组的叉积。我们还了解了不同的案例场景和参数，通过它们可以在不同的数组值集合上实现 numpy.cross。
Numpy.kron():如何使用 Numpy 计算 Kronecker 积？
原文:# t0]https://www . aspython . com/python-modules/num py/numpy-crown
假设给我们一对矩阵，我们想以牺牲另一个矩阵为代价来转换一个矩阵。这意味着使用一个矩阵的元素来缩放另一个矩阵。实现这一点的数学过程被称为“Kronecker 积”, Python 中的 NumPy 库提供了一个独特的函数—kron()。
这篇文章将帮助你理解如何使用 numpy 库中的 kron( ) 函数来计算克罗内克乘积。让我们开始理解这个函数，首先使用下面的代码导入 numpy 库。
import numpy as np
此后，我们将通过以下各节进一步探索 kron( ) 函数。
- 语法克朗()函数
- 计算相同维数数组的克罗内克积
- 计算不同维度数组的克罗内克积
语法克朗()函数
需要注意的是，在部署 kron( ) 函数时，应该将待缩放的数组指定为第二个输入实体，同时将用于缩放的数组指定为第一个输入实体。
以下是 kron( ) 功能运行所需的输入。
numpy.kron(a, b)
在哪里，
- a—N 维数组，包含用于缩放的元素
- b—要缩放的 N 维数组
计算相同维数数组的克罗内克积
在这一节中，我们来寻找一对一维数组的 Kronecker 积，如下所示。
ar1 = np.array([1, 3, 7, 2, 9, 4])
ar2 = np.array([5, 6, 8, 0, -1, 7])
现在让我们为上述两个数组部署 kron( ) 函数。
np.kron(ar1, ar2)
一旦上面的代码运行，下面的计算将在后端发生，用于计算将以一维数组的形式返回的结果。
- “ar2”的第一个元素乘以“ar1”的第一个元素，得出输出数组的第一个元素(即 5×1 = 5)。
- “ar2”的第二个元素乘以“ar1”的第一个元素，得出输出数组的第二个元素(即 6×1 = 6)。
- “ar2”中的后续元素也是如此，它与“ar1”中的第一个元素相乘，这样 8×1 = 8，0x1 = 0，-1×1 = -1，7×1 = 7。
- 现在，循环从“ar1”的第二个元素开始重复，这样“ar2”的每个元素都乘以“ar1”的第二个元素，以进一步获得输出数组的元素，这样，5×3 = 15，6×3 = 18，…, 7×3 = 21.
- 该过程再次迭代，直到‘ar2’中的所有元素都乘以‘ar1’中的元素。
- 这些元素的乘积按顺序排列，从“ar2”元素之间的乘积开始，第一个元素来自“ar1”，接着是第二个元素来自“ar2”，依此类推。
把以上放在数学语言中，
ar1 = [a [11] a [12] …..a[1n] a [21] a [22] …..a[2n]a[m1]a[m2]…..a [mn]
ar2 = b [11] b [12] …..b[1p]b[21]b[22]…..b[2p]b[O1]b[O2]…..b [op]
ar1 和 ar2 的克罗内克乘积=a[11]XB[11]a[12]XB[12]…..a[1n]XB[1n]
[am1]XB[O1]a[m2]XB[O2]…..a [mn] xb [op]
Kronecker Product Calculated For One-Dimensional Arrays
计算不同维度数组的 Kronecker 积:
当输入不同维度的数组时， kron( ) 函数也适用。但是，如果需要的话，有时它会优先考虑最小的输入。
ar3 = np.array([[1, 3, 7],
[2, 9, 4]])
ar4 = np.array([[5, 6],
[8, 0],
[-1, 7]])
np.kron(ar3, ar4)
Kronecker Product Calculated For Arrays Of Different Dimensions
结论:
既然我们已经到了本文的结尾，希望它已经详细说明了如何使用来自 numpy 库中的 kron( ) 函数来计算给定张量对的 Kronecker 积。这里是另一篇解释 Python 中 numpy 的 tensordot ()函数的文章。AskPython 中还有许多其他有趣且信息量大的文章，可能会对那些希望提高 Python 水平的人有很大帮助。当你享受这些的时候，再见！
NumPy cum prod–完整指南
原文:# t0]https://www . aspython . com/python-modules/num py/numpy-cumber
你好，欢迎来到这个关于 Numpy cumprod 的教程。在本教程中，我们将学习 NumPy cumprod()方法，也将看到许多关于这个方法的例子。让我们开始吧！
什么是 NumPy cumprod？
累积积是给定序列的部分积的序列。如果 {a，b，c，d，e，f，…..} 是一个序列那么它的累积积表示为 {a，ab，abc，abcd，…。}** 。
NumPy 中的cumprod()方法返回沿着指定轴的输入数组元素的累积积。它可以是展平数组的累积积、沿行数组元素的累积积或沿列数组元素的累积积。
我们将在本教程的下一节看到每个例子。
NumPy cumprod 的语法
numpy.cumprod(a, axis=None, dtype=None, out=None)
| 参数 | 描述 | 必需/可选 |
| a | 输入数组。 | 需要 |
| 轴 | 要沿其计算数组累积积的轴。它可以是 axis=0，即沿列，也可以是 axis=1，即沿行，或者 axis=None，这意味着要返回展平数组的累积积。 | 可选择的 |
| 数据类型 | 要返回的数组的数据类型。 | 可选择的 |
| 在外 | 放置结果的替代输出数组。它必须具有与预期输出相同的形状和长度。 | 可选择的 |
返回:
一个包含输出的新数组。如果提到了 out ，则返回对它的引用。
numpy.cumprod 方法的示例
现在让我们开始使用 numpy.cumprod 方法，这样我们就可以理解输出。
单个元素的累积积
import numpy as np
a = 5
ans = np.cumprod(a)
print("a =", a)
print("Cumulative product =", ans)
输出:
a = 5
Cumulative product = [5]
空数组的累积积
import numpy as np
a = []
ans = np.cumprod(a)
print("a =", a)
print("Cumulative product =", ans)
输出:
a = []
Cumulative product = []
一维数组的累积积
import numpy as np
a = [2, 10, 3 ,6]
ans = np.cumprod(a)
print("a =", a)
print("Cumulative product of the array =", ans)
输出:
a = [2, 10, 3, 6]
Cumulative product of the array = [ 2 20 60 360]
这里，累积积计算为 2，210，2103，21036 即 2，20，60，360。
二维数组的累积积
import numpy as np
a = [[8, 3], [5, 2]]
ans = np.cumprod(a)
print("a =", a)
print("Cumulative product of the array =", ans)
输出:
a = [[8, 3], [5, 2]]
Cumulative product of the array = [ 8 24 120 240]
在二维数组的情况下，当没有提到轴时，数组首先被展平，然后计算其累积积。
在上面的示例中，数组首先被展平为[8，3，5，2]，即按行排列，然后其累积积被计算为[8，83，835，8352]，这产生了函数返回的数组[8，24，120，240]。
以浮点数据类型返回数组的 Numpy.cumprod()
这与上面的例子相同，只是这里返回值是浮点数据类型。
import numpy as np
a = [2, 10, 3, 6]
ans = np.cumprod(a, dtype=float)
print("a =", a)
print("Cumulative product of the array =", ans)
输出:
a = [2, 10, 3, 6]
Cumulative product of the array = [ 2\. 20\. 60\. 360.]
沿着轴的累积乘积
轴= 0
import numpy as np
a = [[3, 2, 1], [4, 5, 6]]
# cumulative product along axis=0
ans = np.cumprod(a, axis=0)
print("a =\n", a)
print("Cumulative product of the array =\n", ans)
输出:
a =
[[3, 2, 1], [4, 5, 6]]
Cumulative product of the array =
[[ 3 2 1]
[12 10 6]]
这里，第一行是原样，第二行包含计算为 34、25、1*6 的累积积，结果是 12、10 和 6。
轴= 1
import numpy as np
a = [[3, 2, 1], [4, 5, 6]]
# cumulative product along axis=1
ans = np.cumprod(a, axis=1)
print("a =\n", a)
print("Cumulative product of the array =\n", ans)
输出:
a =
[[3, 2, 1], [4, 5, 6]]
Cumulative product of the array =
[[ 3 6 6]
[ 4 20 120]]
这里，第一列是原样，第二列包含计算为 32，45 的累积积，得到 6，20，第三列具有 321，456 的累积积，即 6 和 120。
摘要
仅此而已！在本教程中，我们学习了 Numpy cumprod 方法，并使用相同的方法练习了不同类型的示例。
参考
NumPy cumsum–完整指南
原文:# t0]https://www . aspython . com/python-modules/num py/numpy-cumsum
你好，欢迎来到这个关于 Numpy cumsum 的教程。在本教程中，我们将学习 NumPy cumsum()方法，也将看到许多关于这个方法的例子。让我们开始吧！
什么是 NumPy cumsum？
累积和是给定序列的部分和的序列。如果 {a，b，c，d，e，f，…..} 是一个序列那么它的累加和表示为 {a，a+b，a+b+c，a+b+c+d，…。} 。
NumPy 中的cumsum()方法返回沿着指定轴的输入数组元素的累积和。它可以是展平数组的累积和、沿行数组元素的累积和或沿列数组元素的累积和。
我们将在本教程的下一节看到每个例子。
NumPy cumsum 的语法
numpy.cumsum(a, axis=None, dtype=None, out=None)
| 参数 | 描述 | 必需/可选 |
| a | 输入数组。 | 需要 |
| 轴 | 要沿其计算数组累积和的轴。它可以是 axis=0，即沿列，也可以是 axis=1，即沿行，或者 axis=None，这意味着要返回展平数组的累积和。 | 可选择的 |
| 数据类型 | 要返回的数组的数据类型。 | 可选择的 |
| 在外 | 放置结果的替代输出数组。它必须具有与预期输出相同的形状和长度。 | 可选择的 |
返回:
一个包含输出的新数组。如果提到了 out ，则返回对它的引用。
例子
现在让我们开始使用 numpy.cumsum 方法，这样我们就可以理解输出。
单个元素的累积和
import numpy as np
a = 5
ans = np.cumsum(a)
print("a =", a)
print("Cumulative sum =", ans)
输出:
a = 5
Cumulative sum = [5]
空数组的累积和
import numpy as np
a = []
ans = np.cumsum(a)
print("a =", a)
print("Cumulative sum =", ans)
输出:
a = []
Cumulative sum = []
一维数组的 Numpy 累积和
import numpy as np
a = [5, 3, 2, 8]
ans = np.cumsum(a)
print("a =", a)
print("Cumulative sum of the array =", ans)
输出:
a = [5, 3, 2, 8]
Cumulative sum of the array = [ 5 8 10 18]
这里，累积和的计算方式为 5，5+3，5+3+2，5+3+2+8，结果为 5，8，10，18。
二维数组的 Numpy 累积和
import numpy as np
a = [[4, 3], [9, 10]]
ans = np.cumsum(a)
print("a =", a)
print("Cumulative sum of the array =", ans)
输出:
a = [[4, 3], [9, 10]]
Cumulative sum of the array = [ 4 7 16 26]
在二维数组的情况下，当没有提到轴时，数组首先被展平，然后计算其累积和。
在上面的示例中，数组首先被展平为[4，3，9，10]，即按行排列，然后其累积和被计算为[4，4+3，4+3+9，4+3+9+10]，这产生了函数返回的数组[4，7，16，26]。
以浮点数据类型返回数组的 Numpy.cumsum()
这与上面的例子相同，只是这里返回值是浮点数据类型。
import numpy as np
a = [5, 3, 2, 8]
ans = np.cumsum(a, dtype=float)
print("a =", a)
print("Cumulative sum of the array =", ans)
输出:
a = [5, 3, 2, 8]
Cumulative sum of the array = [ 5\. 8\. 10\. 18.]
沿轴累计总和
轴= 0
import numpy as np
a = [[1, 5, 3], [7, 10, 4]]
# cumulative sum along axis=0
ans = np.cumsum(a, axis=0)
print("a =\n", a)
print("Cumulative sum of the array =\n", ans)
输出:
a =
[[1, 5, 3], [7, 10, 4]]
Cumulative sum of the array =
[[ 1 5 3]
[ 8 15 7]]
这里，第一行是原样，第二行包含按 1+7、5+10 和 3+4 计算的累积和，结果是 8、15 和 7。
轴= 1
import numpy as np
a = [[1, 5, 3], [7, 10, 4]]
# cumulative sum along axis=1
ans = np.cumsum(a, axis=1)
print("a =\n", a)
print("Cumulative sum of the array =\n", ans)
输出:
a =
[[1, 5, 3], [7, 10, 4]]
Cumulative sum of the array =
[[ 1 6 9]
[ 7 17 21]]
这里，第一列是原样，第二列包含计算为 1+5，7+10 的累积和，结果是 6，17，第三列具有 1+5+3，7+10+4 的累积和，即 9 和 21。
摘要
仅此而已！在本教程中，我们学习了 Numpy cumsum 方法，并使用相同的方法练习了不同类型的示例。
参考
要知道的 5 种 NumPy 数据分布
原文：https://www.askpython.com/python-modules/numpy/numpy-data-distributions
读者朋友们，你们好！在本文中，我们将关注 Python 中的 5 NumPy 数据分布。所以，让我们开始吧！！🙂
首先，数据分布使我们对数据的分布有一个概念。也就是说，它表示数据范围内所有可能值的列表，还表示这些数据值在分布中的频率。
Python NumPy 模块为我们提供了 random 类，帮助我们为随机化的数据值随机生成数据分布。
数字数据分布
让我们使用下面的 NumPy 数据分布。
- Zipf 分配
- 帕累托分布
- 瑞利分布
- 指数分布
- 具有 choice()函数的随机分布
1。Zipf 分布
Zipf NumPy 数据分布基于 Zipf 定律，即第 x 个最常见元素是该范围中最常见元素的 1/x 倍。
Python random.zipf() 函数使我们能够在一个数组上实现 zipf 分布。
语法:
random.zipf(a,size)
- a :分布参数
- size :合成数组的尺寸。
举例:
from numpy import random
data = random.zipf(a=2, size=(2, 4))
print(data)
输出:
[[ 2 24 1 1]
[ 4 1116 4 4]]
2。帕累托分布
它遵循帕累托定律，即 20%的因素促成了 80%的结果。pareto()函数使我们能够在随机化的数字上实现 Pareto 数据分布。
看看下面的语法！
random.pareto(a,size)
- a :形状
- size :合成数组的尺寸。
举例:
from numpy import random
data = random.pareto(a=2, size=(2, 4))
print(data)
输出:
[[2.33897169 0.40735475 0.39352079 2.68105791]
[0.02858458 0.60243598 1.17126724 0.36481641]]
3。瑞利分布
有了瑞利分布，我们就可以在信号处理中用概率密度来定义和理解分布。
看看下面的语法！
random.rayleigh(scale,size)
- 标度:标准偏差值基本上决定了一个数据分布的平坦性。
- size :输出数组的尺寸。
举例:
from numpy import random
data = random.rayleigh(scale=2, size=(2, 4))
print(data)
输出:
[[3.79504431 2.24471025 2.3216389 4.01435725]
[3.1247996 1.08692756 3.03840615 2.35757077]]
4。指数分布
指数分布使我们能够了解到下一个事件发生的时间范围。也就是说，任何动作的发生率取决于概率得分。比如成功的框架 v/s 失败率——成功/失败。
语法:
random.exponential(scale, size)
- 标度:动作发生次数的倒数。默认值= 1.0
- 大小:输出数组的大小。
举例:
from numpy import random
data = random.exponential(scale=2, size=(2, 4))
print(data)
输出:
[[0.56948472 0.08230081 1.39297867 5.97532969]
[1.51290257 0.95905262 4.40997749 7.25248917]]
5。具有 choice()函数的随机分布
随机分布表示遵循概率密度值的某些特征的一组随机数据。random 类为我们提供了 choice()函数，它使我们能够基于一组概率值定义随机数。
概率范围在 0 和 1 之间——0 表示该数字不会出现，1 表示该数字在集合中一定会出现。
语法:
random.choice(array, p, size)
- 数组:需要发生随机数据分布的元素。数组元素的个数应该等于 p 的计数。
- p :随机数据分布中每个数组元素出现的概率得分。p 的所有值之和必须等于 1。
- 大小:二维/一维数组的大小。
举例:
from numpy import random
data = random.choice([1,3,5,7], p=[0.1, 0.3, 0.2, 0.4], size=(2, 2))
print(data)
输出:
[[7 7]
[1 3]]
结论
到此，我们就结束了这个话题。如果你遇到任何问题，欢迎在下面评论。
更多与 Python 编程相关的帖子，请继续关注我们。
在那之前，学习愉快！！🙂
Numpy。Divide()–如何在 Python 中使用 Numpy Divide？
原文：https://www.askpython.com/python-modules/numpy/numpy-divide
除法是基本的算术运算之一，用来找出一个给定数的倍数是另一个数的倍数。这不是我们用手指就能完成的事情，因为我们被教导要做加减法。因此，在分析大量数据时，这变得更加乏味。
本文开始探索使用来自 numpy 库的 divide( ) 函数执行除法的不同方差，如下所示。
- 划分两个标量
- 划分两个数组
- 划分一个数组&一个标量
- 划分不同大小的数组
numpy . divide()的语法
在开始解决例子之前，让我们首先理解这个函数的语法。
numpy.divide(x1, x2, where=True, dtype=None)
在哪里，
- x1–是被除数的标量或一维数组或二维数组
- x2–是作为除数的标量或一维数组或二维数组
- 其中–用于指定数组中的位置，通过键入 TRUE，该位置仅进行除法运算，其他实体不进行除法运算
- dtype–用于指定作为结果返回的数据类型
在开始划分实体之前，使用下面的代码导入 numpy 库。
import numpy as np
使用 numpy.divide()划分两个标量
标量是那些只有一个数字的量，不像数组拥有一个数字的集合。让我们给几个变量分配一些标量&使用 divide( ) 函数。
a = 10
b = 5
np.divide(a,b)
Dividing Scalars
****使用 numpy.divide()进行划分两个数组
在这一节中，我们将继续划分一对相同大小的一维数组。你没看错吧！使用 divide( ) 函数要求接受除法运算的数组具有相同的大小。可以使用如下所示的 array( ) 函数来输入数组。
ar_1 = np.array([2,1,0])
ar_2 = np.array([4,3,5])
现在，使用下面的代码将 ar_1 除以 ar_2。
np.divide(ar_1, ar_2)
Dividing One-Dimensional Arrays
也可以使用斜杠运算符(/)执行除法，代码如下。
ar_1/ar_2
Dividing Using Slash Operator
****使用 numpy.divide()对划分一个数组&一个标量
Python 为我们提供了使用标量划分数组的灵活性。这样做的目的是将标量发送给分母，从而除以数组的每个元素，结果将被提供。让我们从创建一个数组开始，这次是二维的。
ar_3 = np.array([[2,1,0],[3,4,5],[6,7,8]])
之后，使用 divide( ) 函数将上述数组中的每个元素除以“10”。
np.divide(ar_3, 10)
Dividing A 2D Array By A Scalar
****使用 numpy.divide()进行划分不同大小的数组
在本文的前面，我们已经说过，使用 divide( ) 函数时，两个数组的大小应该相同。这是真的，但在某种程度上，它只适用于列的大小。Python 允许划分两个不同大小的数组，前提是两个数组中的列数相等。因此，让我们创建两个符合这一要求的数组。
ar_2 = np.array([4,3,5])
ar_3 = np.array([[2,1,0],[3,4,5],[6,7,8]])
现在可以使用 divide( ) 函数来完成它的任务。
np.divide(ar_3, ar_2)
Dividing Arrays Of Different Sizes
注意:应该确保除数不包含零作为它的任何数组元素，否则将出现以下错误。
Divide By Zero Error
总结
既然我们已经到了本文的结尾，希望它已经详细阐述了如何使用 Python 编程来划分实体。这里有另一篇文章详细介绍了如何在 Python 中使用 numpy 减去实体。在 AskPython 中还有许多其他有趣的&内容丰富的文章，可能会对那些希望提高 Python 水平的人有很大帮助。当你享受这些的时候，再见！
NumPy div mod–返回元素的商和余数
原文:# t0]https://www . aspython . com/python-modules/num py/numpy-divmod
你好，欢迎来到这个关于 Numpy divmod 的教程。在本教程中，我们将学习 NumPy divmod() 方法，也将看到许多关于相同的例子。让我们开始吧！
也读:NumPy mod——NumPy中模数运算符的完全指南
什么是 NumPy divmod？
NumPy 中的divmod()方法返回两个给定数组的元素商和除法余数。Python 中的//返回商的底，而%运算符返回除法的余数，类似于mod()函数。
在本教程接下来的章节中，我们将看到演示这个函数用法的例子。
NumPy divmod 的语法
numpy.divmod(x1, x2, out=None)
| 参数 | 描述 | 必需/可选 |
| x1 (array_like) | 红利数组。 | 需要 |
| x2(类似数组) | 除数数组。 | 需要 |
| 在外 | 放置结果的替代输出数组。它必须具有与预期输出相同的形状。 | 可选择的 |
返回:
返回除法运算的元素商和余数。如果 x1 和 x2 都是标量，那么结果也是标量值。
关于 divmod()函数的一些常见观察:
- 如果第一个参数，即 x1 为 0，则该函数返回(0，0)。
- 如果第二个参数，即 x2 为 0，则该函数返回一个‘零除法误差’。
- 如果 x1 是浮点值，函数返回(q，x1%x2)，其中 q 是商的整数部分。
numpy.divmod()的示例
现在让我们开始使用 numpy.divmod 方法，这样我们可以理解输出。
当两个元素都是标量时，使用 numpy.divmod()
import numpy as np
dividend = 23
divisor = 6
ans = np.divmod(dividend, divisor)
print("Dividend =", dividend, "\nDivisor =", divisor)
print("Result =", ans)
输出:
Dividend = 23
Divisor = 6
Result = (3, 5)
这里两个元素都是标量。63=18，64=24，所以 23 不能被 6 整除。当 23 除以 6 时，商是 3，余数是 23-18=5，返回为(3，5)。
当一个元素是标量而另一个是数组时，使用 numpy.divmod()
import numpy as np
dividend = [30, 19, 8]
divisor = 6
ans = np.divmod(dividend, divisor)
print("Dividend =", dividend, "\nDivisor =", divisor)
print("Result =", ans)
输出:
Dividend = [30, 19, 8]
Divisor = 6
Result = (array([5, 3, 1], dtype=int32), array([0, 1, 2], dtype=int32))
在这种情况下，被除数数组中的所有元素都被除数逐个除，并且这些除的商和余数都存储在各自的结果数组中。
输出中的第一个数组是商数组，第第二个是余数数组。
输出计算如下:
商数组:
30//6 = 5
19//6 = 3
8//6 = 1
余数数组:
30%6 = 0
19%6 = 1
8%6 = 2
当两个元素都是一维数组时，使用 numpy.divmod()
import numpy as np
dividend = [72, 60, 30]
divisor = [3, 15, 24]
ans = np.divmod(dividend, divisor)
print("Dividend =", dividend, "\nDivisor =", divisor)
print("Result =", ans)
输出:
Dividend = [72, 60, 30]
Divisor = [3, 15, 24]
Result = (array([24, 4, 1], dtype=int32), array([0, 0, 6], dtype=int32))
这里，两个数组中相同位置的元素进行除法运算，并计算商和余数。即被除数[0]除以除数[0]等等。这只不过是元素级的划分。
商数组:
dividend[0] // divisor[0] = 72//3 = 24
dividend[1] // divisor[1] = 60//15 = 4
dividend[2] // divisor[2] = 30//24 = 1
余数数组:
dividend[0] % divisor[0] = 72%3 = 0
dividend[1] % divisor[1] = 60%15 = 0
dividend[2] % divisor[2] = 30%24 = 6
当两个元素都是二维数组时，使用 numpy.divmod()
import numpy as np
dividend = [[18, 35], [10, 7]]
divisor = [[5, 7], [10, 4]]
ans = np.divmod(dividend, divisor)
print("Dividend =", dividend, "\nDivisor =", divisor)
print("Result =\n", ans)
输出:
Dividend = [[18, 35], [10, 7]]
Divisor = [[5, 7], [10, 4]]
Result =
(array([[3, 5],
[1, 1]], dtype=int32), array([[3, 0],
[0, 3]], dtype=int32))
与上面的一维数组示例相同，这里也进行元素式除法，商和余数计算如下:
商数组:
dividend[0][0] // divisor[0][0] = 18//5 = 3
dividend[0][1] // divisor[0][1] = 35//7 = 5
dividend[1][0] // divisor[1][0] = 10//10 = 1
dividend[1][1] // divisor[1][1] = 7//4 = 1
导致[[3，5]，[1，1]]。
余数数组:
dividend[0][0] // divisor[0][0] = 18%5 = 3
dividend[0][1] // divisor[0][1] = 35%7 = 0
dividend[1][0] // divisor[1][0] = 10%10 = 0
dividend[1][1] // divisor[1][1] = 7%4 = 3
产生[[3，0]，[0，3]]。
摘要
仅此而已！在本教程中，我们学习了 Numpy divmod 方法，并使用该方法练习了不同类型的示例。如果你想了解更多关于 NumPy 的信息，请随意浏览我们的 NumPy 教程。
参考
Numpy Dot()-矢量、Numpy 和计算点积的完整指南
在本文中，我们将学习 numpy dot()方法来寻找点积。它涵盖了标量。向量、数组和矩阵。它还涉及实分析和复数应用，图形可视化，等等。这门学科真正的贡献是在数据科学和人工智能领域。
什么是矢量？
矢量是一个既有方向又有大小的箭头形式的量。这样研究起来似乎更精确。现在让我们更深入地研究一下这里所说的箭头的概念。
一般定义和表示
- 量级:一个矢量所包含的一个值或一个特定的数。
- 方向:从一点流向另一点。
这些是那些基本术语的细节，它们组合在一起产生了向量。我们将看到下图中的图形表示的向量以及一个地方。
A vector in a 1-dimensional plane
如何从向量创建矩阵
向量最重要的操作是用矩阵或 T2 数组的形式来表示它。重要的是， i、j 和 k 分别是在 x、y 和 z 轴上的向量的方向分量。
Vectors With Components
这三个向量可以转换成一个 3×3 的矩阵。矩阵表示法是:
[ [1, 2, -3],
[2, 3, 4],
[4, -1, 1] ]
同样，从给定的一组任意向量中实现矩阵也是可能的。让我们转向主题，即取点积。两个数组的。
Numpy 数组上的操作
该列表向我们展示了对向量或数组最重要的操作:
- 点积:两个向量的元素的所有乘积相加。表示为 A.B 。
- 叉积:两个矢量合成的第三个矢量。代表为 AxB。
在 Python 中，有一个专用于线性代数及其运算的完整库——Numpy。它代表NumEricPython，用于复杂的计算，尤其是在涉及 n 维数组的情况下。它是一个开源库，所以我们可以通过贡献它的代码来使它变得更好。对于 Python 编程语言来说，这是一个容易获得的 API。
实现 Numpy 数组
该库主要用于复杂的数学分析和计算。所以，为了使它更有可能，我们要确保研究它的一些基础知识。这个模块的核心数据类型是 NumPy ndarray 。这预示着主要的操作是相对于数组合成和计算的。让我们为它做一个快速教程。
例#1:
import numpy as np
list_1 = [23, 12, 3, 11]
print('Original list: ', list_1)
arr = nparray(list_1)
print('Numpy array: ', arr)
print('Data type of list_1', type(list_1))
print('Data type of arr', type(arr))
# Output
# Original list: [23, 12, 3, 11]
# Numpy array: array([23, 12, 3, 11])
# <class: list>
# numpy.ndarray
例 2:
import numpy as np
matrix = np.array([[2, 4, 5], [-1, -4, 8], [3, -1, 9]])
print('Our matrix is: ', matrix)
# output:
# Our matrix is:
# array([[2, 4, 5],
# [-1, -4, 8],
# [3, -1, 9]])
#
Numpy 数组上的数学运算
这一节讲的是数学运算的实现。对于单个整数来说，这些操作似乎非常简单，但是对于数组来说，这是一项非常复杂的任务。
- 加法
- 减法
- 乘法运算
- 两个数组的划分
代码:
import numpy as np
a = np.array([[2, 3, 4], [-1, 3, 2], [9, 4, 8]])
b = np.array([[4, -1, 2], [34, 9, 1], [2, 0, 9]])
addition = a + b
subtraction = a - b
multiplication = a * b
division = a / b
print('Addition of arrays a and b is: ', addition)
print('Subtraction of arrays a and b is: ', subtraction)
print('Multiplication of arrays a and b is: ', multiplication)
print('Division of arrays a and b is: ', division)
输出:
Numpy 点()积
这个乘积是给定数组中每个元素的标量乘法。在一般的数学术语中，两个向量之间的点积是它们各自的标量分量与它们之间角度的余弦的乘积。所以，如果我们说 a 和 b 是特定角度θ的两个向量，那么
a.b = |a|.|b|.cosΘ # general equation of the dot product for two vectors
但是，在 Numpy 数组的 dot()函数中，没有角度θ的位置。所以，我们只需要给两个矩阵或数组作为参数。因此，我们将在代码中实现它:
import numpy as np
var_1, var_2 = 34, 45 # for scalar values
dot_product_1 = np.dot(var_1, var_2)
dot_product_1
# for matrices
a = np.array([[2, 3, 4], [-1, 3, 2], [9, 4, 8]])
b = np.array([[4, -1, 2], [34, 9, 1], [2, 0, 9]])
dot_product_2 = np.dot(a, b)
dot_product_2
输出:
Output for the mathematical calculations
代码解释:
- 导入模块 Numpy。
- 之后声明两个变量 var_1 和 var_2。
- 调用 np.dot()函数并在其中输入所有变量。将所有内容存储在 dot_product_1 变量中。
- 然后把它打印在屏幕上。
- 对于多维数组，使用 numpy 的 array()方法创建数组。然后按照上述相同的过程调用点()产品。然后在屏幕上打印出来。
Numpy 点()积的函数方法
当我们在任何编程语言中定义函数时，代码都非常有用，因为我们可以随时随机调用它们。因此，我们将声明一个函数来计算点积。
代码:
import numpy as np
def dot_product(array_1, array_2):
prod = np.dot(array_1, array_2)
return prod
def main():
# declaring two empty arrays
arr_1 = []
arr_2 = []
# taking user input for array 1
n = int(input('Enter the number of elements for array_1: '))
for i in range(n):
arr_1.append(int(input('Enter number : ').strip()))
# taking user input for array 2
m = int(input('Enter the number of elements for array_2: '))
for i in range(m):
arr_2.append(int(input('Enter number: ').strip()))
print('First array', arr_1, '\n'); print('Second array', arr_2, '\n')
print('The dot product of arrays is: ', dot_product(arr_1, arr_2))
main()
说明:
- 首先，我们将 numpy 模块作为 np 导入。
- 然后我们声明一个简单的函数—dot _ product(),它接受两个数组作为参数。函数体内部调用了通用的 np.dot()方法，该方法计算点积并将其存储在变量 prod 中。然后函数在最后返回相同的结果。
- 之后，在 main 函数中，我们声明了两个空列表，它们是我们的数组。
- 变量“n”接受 array_1 中元素数量的输入。
- 变量“m”也是如此。
- 然后我们运行两个 for 循环来获取数组的元素。
- for 循环在两个变量 n 和 m 的范围内迭代。因此，我们使用 append 函数输入值。
- 第二个 for 循环也是如此。
- 之后，我们在屏幕上显示这两个数组。
- 然后调用我们的 dot_product()函数来获取点积，并将这两个数组作为其中的参数。
- 在屏幕上显示数值后。
输出:
Output from the function
结论
所以，就这样话题结束了。我们看到了向量的数学实现，以及它们与数组的密切关系。然后我们通过代码和图像基础看到了一些变换和复杂的数学计算。之后是 Numpy 模块的基础知识以及点积的 dot()方法。
