AskPython-博客中文翻译-三-
AskPython 博客中文翻译（三）
Python 中“is”和“==”的区别
原文：https://www.askpython.com/python/examples/difference-between-is-and-double-equals
嘿伙计们！，我们都知道 Python 有一些大多数解释语言没有的好处。其中一些是我们在进行数学计算时使用的灵活性概念。这样做的时候，我们会对操作符和关键字产生一些混淆。现在，在这篇文章中，我们的目的是得到相同的区别。是和的双等号运算符。那么，让我们开始吧。
Python 中的运算符有哪些？
任何编程语言中的运算符都是基础背后的主要基本概念。Python 中有以下运算符:
- 逻辑:执行逻辑计算
- 和
- 或者
- 不
- 算术:进行基本的算术计算
- + :加法
- –:乘法
- / :除法
- % :取模(返回余数)
- /:地板除法运算符(返回浮点除法的整数值)
- 指数:计算数的幂和异或值
- ****** :电源
- ^ :异或
让我们对这些概念进行编码，并追踪它们之间的区别
现在，我们将比较这些关键字，并尝试跟踪它们在操作上的差异。
"==" 运算符
让我们以两个变量为例。每个变量都有不同的值。假设 a 有 20，b 有 30。现在，我们都知道他们是不平等的。但是，计算机如何识别这一点呢？为此，我们只使用了 double equal-to 运算符。让我们举一个代码例子:
代码:
a = 30
b = 30
if a == b:
print(True)
else:
print(False)
输出:
True
这里我们可以说明，等于的主要作用是检查值是否相同。对于一个复杂的例子，我们也可以用函数来检查:
代码检查一个数的平方根 :
from math import sqrt
def square_root(val):
return (val**(1/2))
a = sqrt(9)
b = square_root(9)
print(a == b)
输出:
True
这里我们比较两个函数返回的值。它们返回的值是相同的，但是在解释器中两者的标识是不同的。
print(id(a))
print(id(b))
输出:
2178644181968
2178644086384
这里的双重等于运算符显示了不同的性质。当我们比较它们的身份时，它将返回 false。它返回 false，因此我们使用“is”操作符来解决这个问题。
是关键字
该关键字用于值的比较以及对象引用。当我们创建任何类的对象时，它是保存每个类的属性的实例。对于每一个新创建的对象，解释器都给它们分配一个新的身份。
数字示例
a = 10
b = 10.0
print(a is b)
输出:
False
正如我们所见，两者都是 10，但一个是浮点数，另一个是整数。所以，让这些值看起来相似，对象类型可以不同
数据结构示例
在这个例子中，我们有两个列表 a 和 b。它们都包含相同的元素值。但是，当我们尝试使用关键字 "is" 来比较它们时，结果令人惊讶。
a = [1, 2, 3, 4, 5]
b = [1, 2, 3, 4, 5]
print(type(a))
print(type(b))
if (a is b):
print("Successful")
else:
print("Unsuccessful")
输出:
<class 'list'>
<class 'list'>
False
说明:
- 两个列表都与
<class>具有相同的类别。 - 但是，主要问题是分配给 l1 的存储块不同于 l1 的存储块。
- 是操作符，检查我们创建的对象的内存位置。
- 每个对象的内存块分配是不同的。这使得为返回假值。
例如使用 NumPy 阵列
代码:
import numpy as np
a = np.array([[1, 2], [3, 4]])
b = np.array([[1, 2], [3, 4]])
print(a is b)
输出:
False
NumPy 数组也是如此。两个阵列是相同的，但是分配给它们的内存是不同的。他们的 id 不一样。所以，我们得到假。
例如一个类
class temp_1():
def __init__(self, a, b):
self.a = a
self.b = b
def print_val(self):
print(self.a, self.b)
class temp_2():
def __init__(self, a, b):
self.a = a
self.b = b
def print_val(self):
print(self.a, self.b)
obj1 = temp_1(30, 40)
obj2 = temp_2(30, 40)
obj1.print_val()
obj2.print_val()
print((obj1 is obj2))
输出:
30 40
30 40
False
说明:
这两个类具有相同的属性、相同的功能以及相同的参数。值得注意的区别是，它们通过内存引用是不同的。所以，通过这个代码实验得出的结论是:对于更有效的代码可测试性来说，关键字比 == 操作符更有用。
摘要
double 等于只检查值，但是，检查的值和引用。因此，本文向我们讲述了 Python 中“is”和“==”之间的区别，以及我们如何在 Python 编程中有效地使用这两个概念，并使我们的代码更加健壮。
参考
- https://docs.python.org/3/library/keyword.html
- https://stack overflow . com/questions/2987958/how-the-is-keyword-implemented-in-python
Python 列表与数组——要知道的 4 个区别！
原文：https://www.askpython.com/python/difference-between-python-list-vs-array
嘿，伙计们！希望你们都过得好。在本文中，我们将详细关注 Python 列表和数组之间的差异。
Python 列表和 Python 数组之间的主要区别在于，列表是 Python 标准包的一部分，而对于数组，需要导入“数组”模块。Python 中的列表用一些例外情况代替了数组数据结构。
1.列表和数组如何存储数据
众所周知，数据结构是用来有效存储数据的。
在这种情况下，一个列表可以将异构数据值存储到其中。也就是说，不同数据类型的数据项可以容纳在一个 Python 列表中。
举例:
lst = [1,2,3,4,'Python']
print(lst)
输出:
[1,2,3,4,'Python']
另一方面，数组存储同类元素，即它们存储属于同一类型的元素。
举例:
import array
arr = array.array('i', [10, 20, 30, 40])
print(arr)
输出:
array('i', [10, 20, 30, 40])
2.数组与列表的声明
Python 将“列表”作为内置的数据结构。这就是为什么列表不需要在 Python 中声明。
lst = [1, 2, 3, 4]
另一方面，Python 中的数组需要声明。我们可以使用以下技术声明一个数组:
阵列模块
import array
array-name = array.array('format-code', [elements])
NumPy 模块
import numpy
array-name = numpy.array([elements])
3.使用数组的高级数学运算
在执行数学运算时，数组占了上风。 NumPy 模块为我们提供了数组结构来存储数据值并方便地操作它们。
数组示例:
import numpy
arr = numpy.array([1,2,3,4])
pr = arr*5
print(pr)
输出:
[ 5 10 15 20]
与列表不同，在列表中执行的操作不会反映到结果中，如下面的列表操作示例所示。
在这里，我们尝试将常量值(5)与列表相乘，这不会反映输出中的任何内容。因为列表不能对任何数据值进行直接的数学运算。
所以，如果我们想用列表中的元素乘以 5，我们必须分别用列表中的每个元素乘以 5。
列表示例:
lst = [1,2,3,4]
pr = lst*5
print(lst)
输出:
[1, 2, 3, 4]
4.调整数据结构的大小
Python 列表是一种内置的数据结构，可以非常容易和有效地调整大小。
另一方面，在调整数组内存大小时，数组的性能很差。相反，我们将不得不把数组复制到另一个数组中来缩放和调整它的大小。
结论
到此，我们就结束了这个话题。如果你遇到任何问题，欢迎在下面评论。
在那之前，学习愉快！！
参考
Python 中单引号和双引号的区别
原文：https://www.askpython.com/python/string/difference-between-single-and-double-quotes-in-python
一个字符串是一个字符序列。Python 中允许开始和结束一个带单引号和双引号的字符串文字。python 编程中有两种表示字符串的方法。
在本文中，您将借助一个示例(即代码及其输出)看到两个引号之间的区别。
Python 中单引号有什么用？
单引号用于标记新闻标题中的引用或直接引用。
当用 Python 编程时，我们通常对字符串文字使用单引号。例如-‘我的标识符’。让我们通过 Python 中的代码用一个例子来理解。
注意:当您知道字符串中可能包含双引号时，请始终使用单引号。
Python 中单引号的用法示例
下面是单引号的实现代码。
word = 'Ask?'
print(word)
sentence = 'Python Programming'
print(sentence)
name = '"Hi" ABC'
print(name)
congrat = 'We congrat's you.'
print(congrat)
输出
Ask?
Python Programming
"Hi" ABC
Invalid Syntax
Python 中的双引号是用来做什么的？
双引号是用来引起直接(逐字)引用的。例如，“我希望你会在这里，”他说。在 Python 编程中，我们使用双引号来表示字符串。让我们通过 python 中的代码用一个例子来理解。
注意:当你知道你的字符串中会有单引号时，用双引号将你的字符串括起来
密码
wish = "Hello World!"
print(wish)
hey = "AskPython says "Hi""
print(hey)
famous ="'Taj Mahal' is in Agra."
print(famous)
输出
Hello World!
Invalid Syntax
'Taj Mahal' is in Agra.
Python 中单引号和双引号的主要区别
| 单引号 | 双引号 |
| 表示为“” | 表示为" " |
| 任何类似标识符的东西都用单引号括起来。 | 双引号通常用于文本。 |
| 单引号用于正则表达式、字典键或 SQL。 | 双引号用于表示字符串。 |
| ‘我们‘欢迎’你。’ | “你好，是我。” |
奖金 Python 中的三重引号
如果您必须使用可能同时包含单引号和双引号的字符串，该怎么办？为此，Python 允许使用三重引号。下面是一个简单的例子。三重引号还允许您向 Python 变量添加多行字符串，而不是仅限于单行。
三重引号示例
sentence1 = '''He asked, "did you speak with him?"'''
print(sentence1)
sentence2 = '''"That's great", she said.'''
print(sentence2)
输出:
He asked, "did you speak with him?"
"That's great", she said.
如您所见，Python 现在理解了双引号和单引号是字符串的一部分，不需要转义。
结论
为了结束这个简单的话题，我想说 Python 中单引号和双引号的区别并不大。这完全取决于我们使用单引号和双引号的情况。
作为程序员，您可以决定什么最适合您的字符串声明。如果有疑问，请使用三重引号，这样就不会对字符串中包含的内容有任何问题。
使用 2 个简单模块的 Python 数字时钟
原文：https://www.askpython.com/python/examples/digital-clock-in-python
今天我们将学习如何使用 Python 用几行代码创建一个简单的数字时钟。为了建立这个时钟，我们需要 tkinter 和时间模块。
用 Python 构建数字时钟的要求
首先，我们需要安装t inter 模块。如果您的系统中尚未安装该模块，您可以使用 pip 软件包管理器安装该模块:
C:\Users\Admin>pip install tkinter
一旦 tkinter 模块成功安装到您的系统上，您就可以开始工作了。
用 Python 编写数字时钟
今天我们将使用 tkinter 模块和 time 模块来构建我们的时钟。
1.Tkinter 模块
Tkinter 是 Python 的标准 GUI 库。Tkinter 从 Tk 接口获得它的名字。当 python 与 Tkinter 相结合时，它提供了一种快速简单的方法来创建 GUI 应用程序。Tkinter 为 Tk GUI 工具包提供了一个强大的面向对象的接口。Tkinter 是一个绑定到 Tk GUI 工具包的 Python。
2.时间模块
时间模块提供了多种获取时间的方式，在本文中，我们将使用 strftime() 将当前时间解析成小时:分钟:秒的格式。
3.实现数字时钟
在这段代码中，我们将使用 geometry() 来指定显示窗口的尺寸，并使用 mainloop() 来防止可显示窗口快速退出。
#import all the required libraries first
import sys
from tkinter import *
#import time library to obtain current time
import time
#create a function timing and variable current_time
def timing():
#display current hour,minute,seconds
current_time = time.strftime("%H : %M : %S")
#configure the clock
clock.config(text=current_time)
#clock will change after every 200 microseconds
clock.after(200,timing)
#Create a variable that will store our tkinter window
root=Tk()
#define size of the window
root.geometry("600x300")
#create a variable clock and store label
#First label will show time, second label will show hour:minute:second, third label will show the top digital clock
clock=Label(root,font=("times",60,"bold"),bg="blue")
clock.grid(row=2,column=2,pady=25,padx=100)
timing()
#create a variable for digital clock
digital=Label(root,text="AskPython's Digital Clock",font="times 24 bold")
digital.grid(row=0,column=2)
nota=Label(root,text="hours minutes seconds",font="times 15 bold")
nota.grid(row=3,column=2)
root.mainloop()
输出:
最后的话…
这就是如何用 Python 编程创建一个简单的数字时钟！你还在等什么？通过自己尝试代码来创建您自己的代码！
python 中的 diarium 数
原文：https://www.askpython.com/python/examples/disarium-number
你好。今天让我们学习一些新的有趣的东西，数字。我们将理解这个数字是什么，然后执行一个程序来检查一个数字是否是一个不一致的数字。
什么是失谐数？
如果每个数字的自乘幂的和等于原来的数，那么这个数就是一个二进制数。
双数定义为:abcd…(n 位数)= a^1 + b^2 + c^3 + d^4 +。。。。。诸如此类。
推荐阅读:用 Python tkinter 实现一个摄氏到华氏的转换器
diarium 数的例子
示例 1: 153
计算(位数)= 1^1 + 5^2 + 3^3 = 1 + 25+ 9= 35
完成的计算不等于原始数字。因此，这个数字不是一个双数。
示例 2: 175
计算(位数)= 1^1 + 7^2 + 5^3 = 1 + 49 + 125 = 175
所做的计算直接等于原始数字。因此这个数字是不一致的数字。
检查 diarium 数的算法
检查一个数字是否是一个不一致的数字所涉及的所有步骤是:
- 读取输入的数字并计算其大小
- 将号码复制一份，以便稍后检查结果。
- 创建一个结果变量(设置为 0)和一个迭代器(设置为数字的大小)
- 创建一个 while 循环来逐个数字地遍历数字。
- 每次迭代时，结果都是数字的迭代器值的幂
- 每次遍历递减迭代器
- 用原始数字的副本检查结果值
用于识别 diarium 编号的伪代码
下面的代码显示了检查一个数字是否是一个不一致的数字的伪代码:
READ n
CALCULATE SIZE OF NUMBER len_n
MAKE A COPY OF n
result=0
CREATE AN ITERATOR i = len_n
CHECK DIGIT BY DIGIT:
WHILE n!=0
GET CURRENT DIGIT : digit = n % 10
UPDATE RESULT : result = result + digit^(i)
TRIM THE LAST DIGIT : n = n / 10
DECREMENT i BY 1
ENDWHILE
CHECK FOR DISARIUM NUMBER:
IF result==COPY OF n
PRINT "DISARIUM NUMBER"
ELSE
PRINT "NOT A DISARIUM NUMBER"
在 Python 中实现对灾难号的检查
现在我们知道了什么是 Disarium 号以及实现它的步骤，让我们逐行实现 Disarium 检查。
1.创建初始变量
我们首先获取一个输入n并计算数字的长度。我们还存储了一个输入的副本，这样无论我们对原始数字做了多少修改，我们都将结果初始化为 0，并将一个迭代器的初始值设为数字的长度。
相同的代码如下所示:
n = input()
len_n = len(n)
n=int(n)
copy_n=n
result = 0
i = len_n
2.遍历数字并更新结果
为了访问每个数字，我们采用数字的模数(mod 10)来提取数字的最后一个数字。下一步是将结果更新为前一个结果和提升到数字位置的数字之和。
我们采取的最后一步是将数字除以 10，去掉数字的最后一位。我们还在每次迭代时将迭代器递减 1。重复相同的过程，直到数字中没有剩余的数字。
相同的代码如下所示:
while(n!=0):
digit = n%10
result=result+pow(digit,i)
n=int(n/10)
i = i - 1
3.检查该号码是否为不一致的号码
最后一步是检查我们之前创建的数字的副本，并计算结果，以最终判断该数字是否是一个不一致的数字。相同的代码如下所示:
if(result==copy_n):
print("Disarium Number!")
else:
print("Not an Disarium Number!")
代码的输出示例
现在，我测试了程序的两个输入。两者如下所示:
数字 1: 153
153
Not a Disarium Number!
数字 2: 175
121
Disarium Number!
结论
恭喜你！您已经成功地学习了 Disarium Number 并在 Python 中实现了它！但是不要就此打住！坚持读书学习！
推荐阅读:如何用 Python Tkinter 实现一个 GUI 年龄检查器？
用 Python 显示图像的 5 种方式
原文：https://www.askpython.com/python/examples/display-images-using-python
在本文中，我们将研究如何用 Python 阅读和显示图像的不同方式。我们可以通过多种方式实现这一目标。原因在于丰富的库支持。我们还将探索如何利用它们在和之间进行杂交。
使用 Python 显示图像的方法
以下是 Python 库的列表，这些库使我们能够处理图像并执行相应的任务。
- OpenCV
- Matplotlib
- 枕头
- Scikit-Image
- Tensorflow
现在让我们看看如何在 Python GUI 窗口中轻松显示图像。可能还有许多其他模块和/或黑客来查看图像，所以不要只局限于这 5 个模块！
1.OpenCV 用 Python 显示图像
这是一个非常著名的、初学者友好的、开源的、功能强大的负责图像处理的包。通过一小组命令，我们可以将我们的计算机视觉之旅推进到下一个阶段。OpenCV 提供了两个主要的函数 来读取和显示图像。
- cv2.imread()
- cv2.imshow()
代码:
import sys # to access the system
import cv2
img = cv2.imread("sheep.png", cv2.IMREAD_ANYCOLOR)
while True:
cv2.imshow("Sheep", img)
cv2.waitKey(0)
sys.exit() # to exit from all the processes
cv2.destroyAllWindows() # destroy all windows
输出:
Displaying the image through OpenCV
说明:
- 导入 OpenCV 包来访问函数。另外，导入系统模块以获得额外的软件包。
- 创建一个变量作为保存我们图像的 img。调用 cv2.imread() 函数，并将图像路径/图像名称作为第一个参数。然后设置 cv2。IMREAD_ANYCOLOR 是读取图像每种颜色的下一个参数。
- 然后设置一个 while 循环，这将帮助我们无限次渲染图像，直到我们退出系统。
- 然后在 while 循环中使用 cv2.imshow() 函数。它有两个参数，图像标题和图像路径变量 img 。
- cv2.waitkey() 方法一直等到我们退出或者点击关闭按钮。
- 然后调用 sys.exit()方法安全地退出该技术。
- 最后，我们使用 cv2.destroyAllWindows() 销毁所有创建的窗口。
2. Matplotlib
这个包主要用于数据可视化。但是，通过绘图技术，我们可以以一种图形格式查看图像，其中每个像素位于 2D x-y 轴上。
蒂耶图书馆也具有与 open cv 相当的功能。只是包名变了。
- matplotlib . image . imread()
- matplotlib . py plot . im show()
代码:
from matplotlib import pyplot as plt
from matplotlib import image as mpimg
plt.title("Sheep Image")
plt.xlabel("X pixel scaling")
plt.ylabel("Y pixels scaling")
image = mpimg.imread("sheep.png")
plt.imshow(image)
plt.show()
输出:
Displaying image through Matplotlib
说明:
- 导入Matplotlibpackagespylot和 image 模块。
- 使用 plt.title() 方法将图像的标题设置为绵羊图像。
- matplotlib 读取 x-y 平面中的图像。我们需要标签 xlabel() 和 ylabel() 函数来提到轴和像素。
- 创建一个变量作为保存我们图像的图像。调用 mpimg.imread() 函数，给图像路径/图像 名称作为第一个参数。
- 然后设置一个 while 循环，这将帮助我们无限次渲染图像，直到我们退出系统。
- 然后使用带有图像变量 img 的 plt.imshow() 函数。但是它会在后台显示出来。
- 要在屏幕上查看它，使用 plt.show() 方法，我们就可以在屏幕上看到带有适当缩放参数的图像。
3.枕头
该库通常提供简单的图像处理方法。因为它的简单性和适应性，我们可以说它是一个纯图像库。我们将要使用的函数是 PILLOW 的图像模块中的 open() 和 show() 。这个动作只有三行代码。
代码:
from PIL import Image
img = Image.open("sheep.png")
img.show()
输出:
Displaying image through PILLOW
说明:
- 从 PIL 导入模块镜像。
- 创建一个变量 img 然后在其中调用函数 open()。给出包含图像文件的路径。
- 通过点运算符，联合 img 变量调用 show() 函数。
- 它通过各自操作系统中的内置照片应用程序显示图像。
4. Scikit-Image
Scikit-Image 是 Scikit-Learn 的子模块。它建立在 Python 和支持库 Matplotlib 的基础上，因此它派生了一些功能。方法与我们之前看到的前几个包类似。
代码:
from skimage import io
img = io.imread("sheep.png")
io.imshow(img)
输出:
Displaying image through Skimage
5. Tensorflow
这是一个强大的机器学习库，特别是来自谷歌。Inc 。它致力于机器学习、深度学习和相关概念的不同方面。它还内置了数据集，可以开始数据科学和 ML 工程的无忧之旅。它专门在计算机的 GPU CUDA 核心上工作。这使得模型训练更有效，并且给 CPU 更少的压力。
我们将结合 Matplotlib 模块使用这个库。因为这使得图像绘制和显示更加容易。
代码:
from warnings import filterwarnings
import tensorflow as tf
from tensorflow import io
from tensorflow import image
from matplotlib import pyplot as plt
filterwarnings("ignore")
tf_img = io.read_file("sheep.png")
tf_img = image.decode_png(tf_img, channels=3)
print(tf_img.dtype)
plt.imshow(tf_img)
# plt.show()
说明:
- 导入 TensorFlow。然后从 TensorFlow 也导入木卫一和图像。
- 导入 matplotlib 的 pyplot 模块用于绘图目的。
- (可选)同样，使用警告包来避免不必要的警告。
- 创建一个 TensorFlow 图像变量“tf_img”并调用 io.read_file()方法。给出里面的图像路径。
- 它被读取为默认的文件。要将其视为图像，我们需要使用来自图像的 decode_png() 函数，以便被系统识别。确保使用正确的决策函数。对于每种图像类型，它们是不同的。使用通道= 3。用于默认的 GPU 使用。
- 最后，通过 plt.imshow() 方法显示捕获的图像。
输出:
Displaying Image through Tensorflow and Matplotlib
结论
所以，这些是我们可以用来进行图像处理的各种方法。Python 为每个独特的任务提供了大量的选项。请写下您最喜欢我们在本文中实现的哪个方法和库。
计算未加权图中节点之间的距离
原文：https://www.askpython.com/python/examples/distance-between-nodes-unweighted-graph
图遍历算法有各种应用。其中一个应用是寻找图的两个节点之间的最小距离。在本文中，我们将使用广度优先图遍历算法在 python 中实现一个算法来寻找未加权全连通图中的最小距离。
对图使用 BFS 算法
广度优先搜索是一种图形遍历算法，其中我们从任意单个顶点开始，恰好遍历图形的每个顶点一次。对于每个选中的顶点，我们首先打印该顶点，然后打印它的所有邻居。这个过程一直持续到遍历完所有顶点。当使用广度优先搜索遍历图形时，看起来我们是从所选的顶点开始分层移动的。
图的 BFS 算法的实现如下。在这个算法中，我们已经假设该图是未加权的、无向的并且是完全连通的。
def bfs(graph, source):
Q = Queue()
visited_vertices = set()
Q.put(source)
visited_vertices.update({0})
while not Q.empty():
vertex = Q.get()
print(vertex, end="-->")
for u in graph[vertex]:
if u not in visited_vertices:
Q.put(u)
visited_vertices.update({u})
确定未加权图的两个节点之间的最小距离
我们可以使用广度优先搜索算法，通过对该算法进行某些修改来找到从一个源到所有节点的最小距离。
给定图的源和邻接表表示，我们将声明一个包含所有访问过的顶点的列表，我们还将创建一个字典，字典中的键确定顶点，值确定当前顶点和源之间的距离。
这里对 BFS 算法的修改将是，每当我们处理一个顶点 v 时，我们将更新它的邻居的距离。v 的邻居到源的距离等于 v 到源的距离加 1。
确定最小距离的算法
由于我们对如何确定从源到每个顶点的最小距离有一个大致的概念，我们将为其制定算法。
Algorithm Least Distance:
Input: Graph(Adjacency list) and Source vertex
Output: A list with distance of each vertex from source
Start:
1.Create an empty queue Q.
2.Create an empty set to keep record of visited vertices.
3\. Create a dictionary in which keys of the dictionary determine the vertex and values determine the distance between current vertex and source.
4.Insert source vertex into the Q and Mark the source as visited.
5.If Q is empty, return. Else goto 6.
6.Take out a vertex v from Q.
7.Insert all the vertices in the adjacency list of v which are not in the visited list into Q and mark them visited after updating their distance from source.
8.Goto 5.
Stop.
实现图的遍历来计算最小距离
由于我们已经制定了用于确定顶点与源的最小距离的算法，因此我们将实现该算法并对下图中给出的图表执行该算法。
Graph Implementation In Python- Askpython
该算法在 python 中的实现如下。
from queue import Queue
myGraph = {0: [1, 3], 1: [0, 2, 3], 2: [4, 1, 5], 3: [4, 0, 1], 4: [2, 3, 5], 5: [4, 2]}
def leastDistance(graph, source):
Q = Queue()
# create a dictionary with large distance(infinity) of each vertex from source
distance = {k: 9999999 for k in myGraph.keys()}
visited_vertices = set()
Q.put(source)
visited_vertices.update({0})
while not Q.empty():
vertex = Q.get()
if vertex == source:
distance[vertex] = 0
for u in graph[vertex]:
if u not in visited_vertices:
# update the distance
if distance[u] > distance[vertex] + 1:
distance[u] = distance[vertex] + 1
Q.put(u)
visited_vertices.update({u})
return distance
print("Least distance of vertices from vertex 0 is:")
print(leastDistance(myGraph, 0))
输出:
Least distance of vertices from vertex 0 is:
{0: 0, 1: 1, 2: 2, 3: 1, 4: 2, 5: 3}
结论
在本文中，我们实现了一个算法，使用一个深度优先搜索遍历算法找到一个源和一个图的其他顶点之间的最小距离。请继续关注更多内容丰富的文章。
Django 管理站点的完整基础
Django 附带了一个非常强大的管理界面。这将从 models.py 中获取关于模型的信息，并还原成一个快速简单的以模型为中心的界面。
在管理界面中，用户可以与模型表进行交互，并以非常简单有效的方式执行添加/删除元素等任务。
另外，Django 让我们有机会使用管理库中的管理类模型来编辑/更改默认的管理界面。
Django 管理站点入门
现在，在我们访问 Django 管理界面之前，我们需要创建一个超级用户。现在让我们来为我们的管理站点创建超级用户。
创建超级用户
如果您尝试进入管理/端点(主机网站/管理)，您会看到需要用户名和密码。这些是 web 应用程序的超级用户的用户名和密码。
Admin Starting Page
超级用户类似于站点的最高管理员，有以下用途:
- 拥有删除、更改和添加新元素的全部权力。
- 还可以创建新用户(以及超级用户)，并为这些用户分配不同的用户权限。
为了创建一个新的超级用户，我们在 shell 中编写下面的代码
python manage.py createsuperuser
然后它会询问用户名、电子邮件和密码。输入详细信息，然后超级用户将被创建。
Superuser
现在我们可以用刚刚创建的用户名和密码登录到管理站点 ( / admin) 。
一旦我们登录，管理站点看起来像这样。
Admin Interface 1
2.为管理站点注册模型
前面的图像向我们展示了默认的管理界面。现在，我们将在这个界面上工作，并将模型注册到这个站点。
为此，请转到 admin.py 并写下:
from django.contrib import admin
from .models import BookModel, AuthorModel
admin.site.register(BookModel)
admin.site.register(AuthorModel)
admin.site.register(
现在，我们将把 BookModel 和 AuthorModel 本身作为参数。
一会儿我们将学习第二个论点。
admin.py
当您修改文件时，服务器应该会自动重新启动，但是如果没有，您可以再次运行 runserver 命令:
manage.py runserver
Admin Site Models 1
现在您将能够看到管理站点显示了 BookModel 和 AuthorModel。
让我们从 web 界面开始编辑模型。
通过管理站点编辑模型表元素
现在我们已经在站点中注册了表，我们可以尝试添加新元素/删除/编辑它们。
1.添加新对象
在管理站点，选择作者模型，然后在右上角，你会看到一个添加新对象选项。
单击该按钮添加新的作者模型对象。
Add Author
同样，让我们在表中再添加几个作者。
Authors 3
2.编辑/修改现有对象
如果您想更改之前保存的任何元素，您可以单击它，下面的页面将再次出现。
您现在可以编辑它们，一旦完成，点击保存保存新值。
Edit Author
这里可以看到保存并继续编辑或保存选项，可以用来保存编辑过的对象。
3。删除对象
点击你想删除的元素，然后你会看到下面的页面。
字段下方会出现一个红色的删除选项，只需单击该删除按钮，该特定对象就会被删除。
Add Author
看看在管理站点中添加或更改表中的元素是多么简单(与 python shell 中的漫长过程相比！)
与 Django 管理接口的外键链接
在上一篇文章中，我们看到了如何使用外键链接两个 Django 模型。现在如果你进入管理部分> > AuthorModel，你可以看到我已经添加了三个作者。
Authors
现在，在 BookModel 表中，当您尝试添加一本新书时，在 author_id 字段中，您将开始获得 author_id 的下拉列表。
这是因为我们使用了外键链接，因此我们现在可以很容易地从 AuthorModel 列表中选择一个作者。
FK
我们不必为所有的书一次又一次地添加作者姓名，我们只需将两个模型(BookModel 和 AuthorModel)链接起来，然后从下拉列表中进行选择。
现在让我们为每个作者增加几本书。
在这里，我选择了捉鬼敢死队和哈利波特的作者 1 和编程教程的作者 2
现在，我们将看到外键的另一个功能。假设作者 one 决定删除他的账户，并因此从 AuthorModel 中移除他的账户作者 one** 。**
从作者模型中删除作者 1
Add Author
Delete Author
现在，如果我们去 BookModel，你会看到作者 one 写的所有书都被自动删除了。
Delete Books
这就是我们通过使用 FK 获得的优势。
更改界面视图
现在我们知道了默认界面是如何工作的，让我们尝试使用管理模型来改变这个界面的一些方面。
语法:
#Decorator
@admin.register(BookModel)
class BookModelAdmin(admin.ModelAdmin):
#Fields
fields =('<model_field_names>')
#List Display
list_display = ('<model_field_names>')
#List_filter
list_filter = ('<model_field_names>')
#ordering
ordering = ('<model_field_names>')
#fieldsets
fieldsets =(
('Required information',{
'description' : '<'description_sentence>',
'fields':('<model_fields'>)
}),
('Optional Information',{
'classes' : ('collapse',),
'fields': ('<model_fields>')
})
)
让我们在下面一个一个地检查每一个元素。
1.装饰者
第一行admin . register(book model)被称为寄存器，在它所应用的类之前与一个 @符号一起使用。
其功能与 admin.site.register 类似。这只是注册模型和 adminModel 的不同方式。但是如果您不想使用这个，那么您必须使用前面提到的方法添加管理模型。
admin.site.register(BookModel,BookModelAdmin)
2。字段
此选项允许您安排模型字段在管理界面中的显示顺序和位置。
注意:该选项将(字段的)输入作为元组。
fields =(('title','price'),'genre','author_id')
在这里，您可以看到我希望字段出现的顺序。
如果你想在同一个水平层次上显示多个字段，那么我们把它们作为一个元组加在一起。(如代码所示)
3。列表 _ 显示
Books
现在如果你看到图像，只有一个标题“图书型号”。现在，如果你想显示不同的标题，那么我们使用这个选项叫做 l ist_display。
因此，该选项允许您选择在上面显示的页面上显示的所有字段。
注意:该选项将输入作为元组。
list_display = ('title','price')
4.列表 _ 过滤器
Books
如你所见，在默认界面中。，没有筛选依据选项。使用 list_filter 在上面显示的页面上创建一个过滤选项。这有助于我们快速搜索表中的特定元素。
注意:该选项以输入为元组。
list_filter = ('genre',)
5.排序
就像我们在 Django 模型中看到的元类一样，这里的排序也有同样的功能。我们可以指定特定字段元素的显示顺序。
语法类似于元类模型中的排序。
注意:该选项以输入为元组。
ordering = ('title',)
6.字段集
这是提到我们在上面看到的字段的另一种方式。
正如您在许多网站上看到的那样，在单击“显示更多”按钮后，您可以看到一些可选信息。字段集给了我们同样的能力，使一些字段保持可选，而一些字段保持必需。
这里的语法有点混乱，请尝试理解下面给出的代码:
fieldsets =(
('Required information',{
'description' : '<'description_sentence>',
'fields':('<model_fields'>)
}),
('Optional Information',{
'classes' : ('collapse',),
'fields': ('<model_fields>')
})
)
管理库中还有许多其他类似的管理选项，可以像一样使用
- 空值显示
- 排除
- 列表 _ 可编辑
- 只读字段
现在让我们更改 BookModel 和 AuthorModel 的管理界面。
在管理站点中更改 BookModel 视图
让我们使用各种管理选项来改变图书模型的外观
@admin.register(BookModel)
class BookModelAdmin(admin.ModelAdmin):
fields =(('title','price'),'genre','author_id')
list_display = ('title','price')
list_filter = ('genre',)
ordering = ('title',)
注意:对于单值元组，我们需要在末尾加上一个逗号“，”来表示 Python 是一个元组。
这里:
- 我们将标题和价格保持在同一水平
- 列表-显示标题和价格
- 按流派过滤
- 根据标题按字母顺序排列元素
现在让我们运行服务器并检查。
Book Admin
Book admin
在管理站点中更改 AuthorModel 视图
类似地，让我们也使用上面学到的管理选项来更改 AuthorModel 的外观。
@admin.register(AuthorModel)
class AuthorModelAdmin(admin.ModelAdmin):
fieldsets =(
('Required information',{
'description' : 'These fields are compulsory',
'fields':('first_name',)
}),
('Optional Information',{
'classes' : ('collapse',),
'fields': ('last_name',)
})
)
list_display =('first_name','last_name')
ordering =('first_name',)
这里
- 名字用在必填信息下
- 姓氏用在可选信息下
- 列表-显示名字和姓氏
- 根据名字按字母顺序排列元素
现在让我们运行服务器并检查。
Author Admin
Author Admin(hidden)
Author Adminshown
Django 管理站点中的其他选项
在 Django 管理站点的主页上，已经出现了一些其他选项，比如用户、组。
Admin Site
用户选项用于处理超级用户以及每个用户的权限。
Users
屏幕上显示的所有元素都是可点击的，用户权限可以通过点击它们进行编辑，并修改权限集。
User Permissions
User Permissions
User Permissions
结论
就这样，伙计们。我们已经到了这篇文章的结尾。在下一节中，我们将了解模板。请继续关注接下来几天更多的 Django 和 Flask 文章。继续编码！！！
Django 管理模板–修改 Django 管理界面
在本文中，我们将了解管理站点接口，以及如何使用 Django 管理模板来修改它。
Django 默认管理界面
如您所见，默认的 Django 管理站点如下所示:
Admin Site
默认界面的功能很少，对用户也不友好。但是 Django 确实提供了一种方法来制作我们自己的管理站点界面；那就是通过使用 Django ModelAdmin 库。
我们现在将与 ModelAdmin 一起工作，看看如何根据我们的需要修改管理页面。
用 ModelAdmin 库定制 Django 管理界面
要使用 Model Admin，我们需要一些模型表。这里有一个简单的模型:
class SampleBookModel(models.Model):
Name = models.CharField(max_length = 80)
Price = models.IntegerField()
Genre = models.CharField(max_length = 80)
Description = models.TextField()
在随后的部分中，我们将修改这个模型本身的显示页面。
编辑模型管理类
模型管理是 Django 的管理库的一部分。要使用它，我们必须导入 admin:
from django.contrib import admin
模型管理类的基本语法如下所示:
#Decorator
@admin.register(BookModel)
class BookModelAdmin(admin.ModelAdmin):
#Fields
fields =('<model_field_names>')
#List Display
list_display = ('<model_field_names>')
#List_filter
list_filter = ('<model_field_names>')
#ordering
ordering = ('<model_field_names>')
#fieldsets
fieldsets =(
('Required information',{
'description' : '<'description_sentence>',
'fields':('<model_fields'>)
}),
('Optional Information',{
'classes' : ('<class_options',),
'fields': ('<model_fields>')
})
)
我们现在将逐个查看它们
1.装修工
Python 提供了一个令人兴奋的特性装饰器，用于向现有代码添加功能。它与一个 @ 符号一起使用。
你可以在 Python decorators 文章中了解更多。管理站点注册表装饰器的基本语法是:
@admin.register(<Model_Name>)
注意:这里它的作用和线的作用一样:
admin.site.register(<Model_Name>, <Model_admin_class>)
使用 decorators 只是在管理站点中注册模型的另一种方式。在这种情况下，唯一的区别是添加了模型管理类和模型作为参数。
2。字段
字段指定网页上模型字段的顺序和位置。
注意:输入(字段)应该以元组的形式给出。
fields =(('field1','field2'),'field3','field4')
要在同一级别显示两个字段，请将它们作为一个元组添加到元组中。
例如:在上面的代码中:字段 1 和字段 2会同级显示——字段比它们低 3，最后是字段 4 。
3。列表 _ 显示
Books
在上面的例子中，网页只显示了一个标题“图书型号”为了添加更多这样的列标题，我们使用了 list_display 属性。
注:输入(列标题)应给出为 元组 。
list_display 的语法:
list_display = ('<Heading1','Heading2')
4.列表 _ 过滤器
默认界面不提供 Filter-by 选项。但是我们可以使用列表 _ 过滤器选项来添加它。
有了 Filter_by 选项，我们可以更快地搜索表格元素。
注意:输入应该以元组的形式给出。
list_filter = ('<filter-by:Field_Name>',)
5.排序
排序属性指定表格元素在网页上显示的顺序。
注意:****输入应该作为元组给出。
ordering = ('<Field_Name>',)
6.字段集
字段集属性只是显示字段的另一种方式，就像字段属性一样。
在很多网站上，信息经常显示在可选信息标签下，我们按下点击查看选项后就可以看到。
字段集正是这样做的！！语法类似于元组中的 Python 字典。
字段集的语法如下所示:
fieldsets =(
('Required information',{
'description' : '<'description_to_display>',
'fields':('<Field_Names'>)
}),
('Optional Information',{
'classes' : ('<display_options>',),
'fields': ('<Field_Names>')
})
)
以下是一些不常用的模型管理属性:
- 空值显示
- 排除
- 列表 _ 可编辑
- 只读字段
使用 Admin 类定制 Django 管理模板中的字段
清楚了解变量后，我们现在可以开始修改管理模板上的前端字段。
我们将改变先决条件部分提到的 SampleModel Django 管理模板的外观
在 admins.py 中添加代码:
@admin.register(SampleBookModel)
class SampleAdminModel(admin.ModelAdmin):
fieldsets =(
('Required information',{
'description' : 'These fields are compulsory',
'fields':(('Name','Price'),'Genre')
}),
('Optional Information',{
'classes' : ('collapse',),
'fields': ('Description',)
})
)
list_display =('Name','Price')
list_filter = ('Genre',)
ordering =('Name',)
从代码中，试着猜测每个元素将显示在哪里。我们将在下一节看到你的猜测是否正确！
模型管理类的实现
你猜对了吗？看一下输出。
Admin Interface
Admin Template
Admin Template (Optional Information)
结论
就这样，编码员们！！这就是关于 Django 管理模板以及如何使用模型管理类的全部内容。请务必查看 Django 管理站点的文章，以获得更多关于管理站点的信息。
下一篇文章再见！！继续编码！！
Python Django 应用程序结构和项目结构
原文：https://www.askpython.com/django/django-app-structure-project-structure
Django 使用目录结构来安排 web 应用程序的不同部分。现在，我们将在这里更详细地了解 Django 应用程序结构和项目结构。
Django 项目结构
Django Project Structure
这是默认 Django 项目结构的样子。让我们来理解上图中显示的文件的功能，以帮助您了解项目文件夹的内容。
1。Manage.py
该文件主要用作命令行实用工具，用于部署、调试或运行我们的 web 应用程序。
该文件包含用于运行服务器、进行迁移或迁移等的代码。我们在外壳中使用的。无论如何，我们不需要对文件做任何修改。
-
runserver: 这个命令用于为我们的 web 应用程序运行服务器。
-
迁移:这用于将对我们的模型所做的更改应用到数据库中。也就是说，如果我们对数据库进行任何更改，那么我们使用 migrate 命令。这是我们第一次创建数据库时使用的。
-
Makemigration: 这样做是为了应用由于数据库中的更改而执行的新迁移。
manage.py
此图仅供大家参考。你不必理解这里写的代码，因为我们在这里没有改变任何东西。
2。init。py
这个文件仍然是空的，它的存在只是为了告诉我们这个特定的目录(在这个例子中是 django_project)是一个包。
我们也不会对此文件进行任何更改。
init.py
3。setting.py
该文件用于添加所有存在的应用程序和中间件 应用程序。此外，它还有关于模板和数据库的信息。总的来说，这是我们 Django web 应用程序的主文件。
4. urls.py
这个文件处理我们的 web 应用程序的所有 URL。这个文件包含了我们网站的所有端点的列表。
URL:通用资源定位器用于提供互联网上的资源(如图片、网站等)的地址。
Urls Pydjango Project 1
5. wsgi.py
这个文件主要涉及到 WSGI 服务器，用于将我们的应用程序部署到 Apache 等服务器上。
WSGI，web 服务器网关接口的缩写可以被认为是描述服务器如何与 Web 应用交互的规范。
同样，我们不会对此文件进行任何更改。
wsgi.py
你不必理解这里写的代码，因为我们在这里没有改变任何东西。
6. asgi.py
在 Django 的新版本中，除了 wsgi.py 之外，你还会发现一个名为 asgi.py 的文件。 ASGI 可以被认为是 WSGI 的后续接口。
ASGI，异步服务器网关接口的缩写也有类似于 WSGI 的工作，但这比前一个更好，因为它在 Django 开发中提供了更好的自由度。这就是为什么 WSGI 现在越来越多地被 ASGI 所取代。
同样，我们不会对此文件进行任何更改。
Asgi
7。应用程序
除了上面的文件，我们的项目包含所有的应用程序目录。现在我们将详细研究 Django 应用程序的结构
Django 应用程序结构
Django App structure – Basic Hello world app
上图是我们最近关于 Django hello world 应用的文章中的应用结构。让我们检查一下应用程序目录中的文件，了解它们的用途。
1。init。py
这个文件的功能与 init 中的相同。Django 项目结构中的 py 文件。它仍然是空的，它的存在只是为了表明特定的应用程序目录是一个包。
无需手动更改文件。
Init file
2. admin.py
顾名思义，这个文件用于将模型注册到 Django 管理中。
展示的模型有一个超级用户/管理员，可以控制存储的信息。
这个管理界面是预先构建的，我们不需要创建它。
Admin
3. apps.py
该文件处理应用程序的应用程序配置。默认配置在大多数情况下足够了，因此开始时我们不会在这里 做任何事情。
Apps
4. models.py
这个文件包含我们的 web 应用程序的模型(通常作为类)。
模型基本上是我们正在使用的数据库的蓝图，因此包含关于数据库的属性和字段等的信息。
Models
5. views.py
这个文件非常重要，它包含了所有的视图(通常是类)。Views.py 可以被认为是一个与客户端交互的文件。视图是我们呈现 Django Web 应用程序时所看到的用户界面。
在接下来的章节中，我们将使用 Django Rest_Framework 中的序列化程序的概念来创建不同类型的视图。
views.py
6. urls.py
就像 project urls.py 文件一样，这个文件处理我们的 web 应用程序的所有 URL。这个文件只是将应用程序中的视图与主机 web URL 链接起来。设置 urls.py 具有对应于视图的端点。
urls.py
7。tests.py
该文件包含的代码包含应用程序的不同测试用例。它用于测试应用程序的工作情况。
我们不会在一开始就处理这个文件，因此它现在是空的。
结论
这就是我们的结局。如果你不明白本教程的任何部分，不要烦恼。我们会在 Django 上发布更多的教程，慢慢地让你对这些结构有更全面的了解。因为您将亲自操作这些文件，所以您将很容易理解 Django 应用程序结构和项目结构。
现在，是我们下一篇讨论 Django URL 结构的文章的时候了。未来几天敬请关注更多关于 Python Django 和 Flask 的文章！
Django 博客应用——给你的 Django 应用添加博客和评论
在本文中，我们将创建一个 Django 博客应用程序。对于门外汉来说，在开始用 Django 构建自己的博客应用程序之前，让我们先快速了解一下什么是博客。
什么是博客？
博客网站是一个在线平台，其中以离散和信息丰富的文本形式条目(帖子)发布所有信息。此外，人们还可以在每个博客的评论区分享问题和讨论观点。
博客应用程序是实践 Django 框架的一个很好的方式。我们现在将创建一个博客应用程序，浏览者可以:
- 查看所有博客的列表
- 查看每篇博客文章
- 在每个博客文章的评论区发表评论
- 搜索特定的博客文章
建立 Django 博客的先决条件
在此应用中，我们需要以下知识:
如果你对其中任何一部分感到不熟悉，请务必先浏览一遍。
打造我们自己的 Django 博客应用
现在我们已经具备了所需的知识，让我们今天就开始构建你的第一个 Django 博客应用程序。
1.创建 Django 项目和应用
第一步是为应用程序建立一个新的 Django 项目 。因此，在终端运行中:
django-admin startproject <project_name>
现在，进入项目，运行下面的代码行创建一个 Django 应用程序:
django-admin startapp blogapp
就是这样，现在在 settings.py 中注册 Django app
INSTALLED_APPS
2.包括项目 URL 文件的应用程序 URL
在应用程序中创建新的 urls.py 文件，然后将其链接到项目 urls.py 文件。因此，在项目/urls.py 中，添加代码:
from django.contrib import admin
from django.urls import path,include
urlpatterns = [
path('admin/', admin.site.urls),
path('', include('blogapp.urls')),
]
同时在 admin.py 文件中注册模型。在 admins.py 文件中添加代码:
from .models import BlogModel, CommentModel
admin.site.register(BlogModel)
admin.site.register(CommentModel)
3.编码 Django 模型
在我们的 BlogApp 中，我们需要一个模型来存储博客，一个模型来存储每个博客的评论。
因此，在 blogapp/models.py 中，用以下字段创建两个模型——blog model 和 CommentModel
from django.db import models
class BlogModel(models.Model):
id = models.IntegerField(primary_key=True)
blog_title = models.CharField(max_length=20)
blog = models.TextField()
def __str__(self):
return f"Blog: {self.blog_title}"
class CommentModel(models.Model):
your_name = models.CharField(max_length=20)
comment_text = models.TextField()
blog = models.ForeignKey('BlogModel', on_delete=models.CASCADE)
def __str__(self):
return f"Comment by Name: {self.your_name}"
请注意，CommentModel 中的 blog 字段链接到 BlogModel，因为每个单独的博客页面将只显示该博客上的评论。
4.编码 Django 表格
我们还需要两种形式:
- 用于写评论的评论表单
- 用于搜索博客的搜索表单
因此，在 blogapp 中创建一个 forms.py 文件，并在其中添加以下代码:
from django import forms
class CommentForm(forms.Form):
your_name =forms.CharField(max_length=20)
comment_text =forms.CharField(widget=forms.Textarea)
def __str__(self):
return f"{self.comment_text} by {self.your_name}"
class SearchForm(forms.Form):
title = forms.CharField(max_length=20)
5.编码 Django 视图
同样，我们需要两个视图:
- ListView :显示博客列表和搜索表单
- 详细视图:显示个人博客、评论表单和之前提交的评论
因此，将下面的列表视图和详细视图添加到 blogapp/views.py 中:
from .models import BlogModel,CommentModel
from .forms import SearchForm,CommentForm
from django.shortcuts import render,redirect
def BlogListView(request):
dataset = BlogModel.objects.all()
if request.method == 'POST':
form = SearchForm(request.POST)
if form.is_valid():
title = form.cleaned_data['title']
blog = BlogModel.objects.get(blog_title=title)
return redirect(f'/blog/{blog.id}')
else:
form = SearchForm()
context = {
'dataset':dataset,
'form':form,
}
return render(request,'blogapp/listview.html',context)
def BlogDetailView(request,_id):
try:
data =BlogModel.objects.get(id =_id)
comments = CommentModel.objects.filter(blog = data)
except BlogModel.DoesNotExist:
raise Http404('Data does not exist')
if request.method == 'POST':
form = CommentForm(request.POST)
if form.is_valid():
Comment = CommentModel(your_name= form.cleaned_data['your_name'],
comment_text=form.cleaned_data['comment_text'],
blog=data)
Comment.save()
return redirect(f'/blog/{_id}')
else:
form = CommentForm()
context = {
'data':data,
'form':form,
'comments':comments,
}
return render(request,'blogapp/detailview.html',context)
视图的 URL 路径将是:
path('blogs/', BlogListView, name='blogs'),
path('blog/<int:_id>', BlogDetailView, name='blog'),
将上述代码添加到 blogapp/urls.py 中
6。编码 Django 模板
为了显示内容，我们再次需要两个模板，每个视图一个。因此:
- 在应用程序中创建一个模板文件夹。
- 在模板文件夹中，创建一个名为 blogapp 的文件夹
现在，在 templates/blogapp 文件夹中，添加以下两个文件:listview.html 和 detailview.html的文件。****
- listview.html 文件
<form method="post">
{%csrf_token %}
<H2> Search Blog Here</H2>
{{form.as_p}}
<input type ="submit" value="Search">
</form>
{% for data in dataset %}
<h3>{{data.blog_title}}</h3>
<a href = "{% url 'blog' _id=data.id %}">Read More</a>
<hr/>
{% endfor %}
2.detailview.html 文件
<h3>Title:</h3><p>{{data.blog_title}}</p><br>
<h3>Blog</h3>
<p>{{data.blog}}</p>
<hr/>
<a href = "{% url 'blogs' %}">Go Back</a>
<form method="post">
{%csrf_token %}
<H2> Comment Here</H2>
{{form.as_p}}
<input type ="submit" value="Comment">
</form>
{%for comment in comments%}
<p><strong>{{comment.your_name}}:</strong> {{comment.comment_text}}</p>
{%endfor %}
就是这样！！这是博客应用程序所需的全部内容。
项目的最终代码
所有文件的最终组合代码如下所示:
- models.py
from django.db import models
class BlogModel(models.Model):
id = models.IntegerField(primary_key=True)
blog_title = models.CharField(max_length=20)
blog = models.TextField()
def __str__(self):
return f"Blog: {self.blog_title}"
class CommentModel(models.Model):
your_name = models.CharField(max_length=20)
comment_text = models.TextField()
blog = models.ForeignKey('BlogModel', on_delete=models.CASCADE)
def __str__(self):
return f"Comment by Name: {self.your_name}"
- forms.py
from django import forms
class CommentForm(forms.Form):
your_name =forms.CharField(max_length=20)
comment_text =forms.CharField(widget=forms.Textarea)
def __str__(self):
return f"{self.comment_text} by {self.your_name}"
class SearchForm(forms.Form):
title = forms.CharField(max_length=20)
- views.py
from .models import BlogModel,CommentModel
from .forms import SearchForm,CommentForm
from django.shortcuts import render,redirect
def BlogListView(request):
dataset = BlogModel.objects.all()
if request.method == 'POST':
form = SearchForm(request.POST)
if form.is_valid():
title = form.cleaned_data['title']
blog = BlogModel.objects.get(blog_title=title)
return redirect(f'/blog/{blog.id}')
else:
form = SearchForm()
context = {
'dataset':dataset,
'form':form,
}
return render(request,'blogapp/listview.html',context)
def BlogDetailView(request,_id):
try:
data =BlogModel.objects.get(id =_id)
comments = CommentModel.objects.filter(blog = data)
except BlogModel.DoesNotExist:
raise Http404('Data does not exist')
if request.method == 'POST':
form = CommentForm(request.POST)
if form.is_valid():
Comment = CommentModel(your_name= form.cleaned_data['your_name'],
comment_text=form.cleaned_data['comment_text'],
blog=data)
Comment.save()
return redirect(f'/blog/{_id}')
else:
form = CommentForm()
context = {
'data':data,
'form':form,
'comments':comments,
}
return render(request,'blogapp/detailview.html',context)
4.listview.html
<html>
<body>
<form method="post">
{%csrf_token %}
<H2> Search Blog Here</H2>
{{form.as_p}}
<input type ="submit" value="Search">
</form>
{% for data in dataset %}
<h3>{{data.blog_title}}</h3>
<a href = "{% url 'blog' _id=data.id %}">Read More</a>
<hr/>
{% endfor %}
</html>
</body>
4.listview.html
<html>
<body>
<h3>Title:</h3><p>{{data.blog_title}}</p><br>
<h3>Blog</h3>
<p>{{data.blog}}</p>
<hr/>
<a href = "{% url 'blogs' %}">Go Back</a>
<form method="post">
{%csrf_token %}
<H2> Comment Here</H2>
{{form.as_p}}
<input type ="submit" value="Comment">
</form>
{%for comment in comments%}
<p><strong>{{comment.your_name}}:</strong> {{comment.comment_text}}</p>
{%endfor %}
</html>
</body>
5. blogapp/urls.py
from django.contrib import admin
from django.urls import path
from .views import *
urlpatterns = [
path('blogs/', BlogListView, name='blogs'),
path('blog/<int:_id>', BlogDetailView, name='blog'),
]
项目实施
这就是它的编码员，让我们现在实现代码。首先，我们需要应用迁移来创建 DB 模型表。因此，在 shell 中运行以下代码:
python manage.py migrate
python manage.py makemigrations
python manage.py migrate
现在使用终端运行服务器:
python manage.py runserver
现在通过管理站点(" /admin ")添加一些博客
Blog Admin
现在转到“/博客”端点
Blogs
现在去任何一个博客，说 Django Hello World
Blog 1
添加评论并点击提交，评论将出现在下面
Blog 1 With Comment
请注意，当你去任何其他博客，比如说 Django Views one，你不会看到上面的评论，因为它只针对 Django Hello World 博客。
Blog 2
结论
就是这样，编码员们，这都是关于 Django 博客应用程序的。尝试创建您自己的博客应用程序，并添加用户身份验证等附加功能。请务必查看 Django 用户认证文章以获得帮助。
在下一篇文章中，我们将把我们的项目部署到一个 VPS(虚拟专用服务器)上。
Django 缓存——通过缓存加快 Django WebApp 的速度
在本文中，我们将实现 Django 缓存。我们将学习什么是缓存，为什么要使用缓存，最后，我们将在 Web 应用程序中编码和实现缓存。
所以让我们开始吧！！
什么是缓存？
缓存是保存耗时计算的结果的过程，以便将来下次需要时，您可以随时准备好结果。
甚至计算机 CPU 也在内存中存储缓存文件，以便下次可以更快地显示这些文件，从而节省大量处理时间。大多数像 FB，WhatsApp 这样的网站也使用缓存来提高网站速度。
Django Framework 有一套预置的选项，可以用来缓存网站。
需要缓存
每次访问动态网站(包含动态元素的网站，如模板、视图、服务器中的数据等。)，服务器需要在显示之前加载模板、查看和从服务器检索数据。所有这些过程都需要时间。
但是在今天这个时代，每个用户都希望自己的请求能够得到快速响应，哪怕是毫秒级的延迟都是承受不起的。因此，为了让网站运行得更快，我们可以采取以下措施:
- 改进 CPU 硬件
- 改进服务器软件
- 改进数据库
或者我们可以简单地使用缓存的方法！！
存储缓存信息
Django 缓存框架还提供了不同的方式来存储缓存信息:
- 将缓存存储在数据库中
- 将缓存存储在文件中
- 在内存中存储缓存
我们现在将分别研究它们
1)在数据库中存储缓存
这里所有的缓存数据都存储在数据库中的一个单独的表中，就像模型表一样。
因此，我们需要告诉 Django 将缓存存储在 DB 中。为此，在 settings.py 中添加以下代码
CACHES = {
'default':{
'BACKEND': 'django.core.cache.backends.db.DatabaseCache',
'LOCATION': 'my_cache_table',
}
}
为了在表中存储缓存，我们还需要创建一个表。因此，在控制台中，运行代码
python manage.py createcachetable
Django 现在使用 settings.py 中给定的名称在 DB 中创建缓存表—“my _ cache _ table”
这种方法是最常用的，这里缓存速度取决于数据库的类型。如果您有快速 DBs，那么这个选项是最可行的。
2)将高速缓存存储在文件中
在这里，我们将缓存作为文件存储在系统中。要将缓存存储为文件，请在 settings.py 中添加以下代码:
CACHES = {
'default': {
'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache',
'LOCATION': 'Absolute_path_to_the_directory',
}
}
这里所有的缓存文件都存储在位置属性中设置的文件夹/目录中。
注意:
- 服务器应该可以访问该目录
- 该位置应该提前存在。
- 应该只提到文件夹/目录的绝对路径。
这种方法是所有选项中最慢的。但是这里您不需要升级您的硬件，因为它正在使用系统中已经存在的存储。
3)将缓存存储在内存中 y
在这里，我们将所有缓存文件存储在内存中。Django 有一个本地内存缓存形式的默认缓存系统。
要在本地内存中添加缓存，请添加代码
CACHES = {
'default': {
'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
'LOCATION': ('Location1','Location2',...),
}
}
在这里，我们可以将缓存文件保存在不同的部分。在位置属性中添加所有部分的位置作为元组。
到目前为止，这种方法是上述所有选项中最强大、最快的。
Django 缓存的先决条件
现在要缓存网站，首先要有一个视图和对应的 URL 路径。因此，将以下示例视图添加到您的 views.py 中:
def SampleView(request):
Html = '<h1>Django Caching<h1><br><p>Welcome to Caching Tutorial</p>'
return HttpResponse(html)
代码的 URL 路径将是:
path('sample/', SampleView),
现在，对于下一部分，您可以以上面显示的任何形式存储缓存:
将网站的不同部分存储为缓存
在姜戈，我们可以:
- 仅缓存特定视图
- 或者缓存整个网站
我们现在将分别研究它们。
1。每个站点的缓存存储
为了缓存整个站点，在 settings.py 的中间件部分添加以下代码
'django.middleware.cache.UpdateCacheMiddleware',
'django.middleware.common.CommonMiddleware',
'django.middleware.cache.FetchFromCacheMiddleware',
注意:上面给出的代码顺序很重要。确保它们以相同的顺序出现。
实施每个站点的存储缓存
运行服务器并转到 URL 路径 "/sample"
Per-Site Cache
请注意，网站第一次加载网站用了13 毫秒。现在点击重新加载并再次检查。
Per-Site Cache 2
请注意，现在页面重新加载只需要6 毫秒。时间已经缩减到一半以上。
2。 每视图缓存存储 e
要缓存特定的视图，使用的语法是:
#Method1: Cach_page syntax in views.py
from django.views.decorators.cache import cache_page
@cache_page(200)
def SampleView(request):
html = '<h1>Django Caching<h1><br><p>Welcome to Caching Tutorial</p>'
return HttpResponse(html)
#Method2: Cache_page syntax in urls.py
from django.views.decorators.cache import cache_page
urlpatterns = [
path('sample/', cache_page(200)SampleView),
]
cache_page() 属性只接受一个参数——以秒为单位的缓存过期时间。我们可以使用上面显示的两种方法中的任何一种。
实施每视图存储缓存
运行服务器，点击网址
Per-View
耗时22 ms现在重装检查。
Per-View Cache 2
现在，所用的时间已经减少到仅8 毫秒
结论
就这样，伙计们！！我希望您已经获得了关于缓存以及如何根据我们的 Web 应用程序需求和要求使用它们的良好知识。务必练习上面给出的所有代码，以提高你对主题的理解。下一篇文章再见！！在那之前，继续编码吧！！
Django 基于类的视图——如何构建基于类的 Django 视图？
原文：https://www.askpython.com/django/django-class-based-views
在本文中，我们将学习如何使用 Django 基于类的视图和我们的 Django REST API ，然后将基于函数的视图改为基于类的视图。
基于类的视图与基于函数的视图之间的区别
在之前的文章中，我们使用基于函数的视图制作了整个 Rest API 网页。使用基于功能的视图，我们不能扩展视图的功能。这就是基于类的视图发挥作用的地方。
在本教程中，我们将学习使用这些功能，并使我们的代码比前一篇文章中的代码更简单。
在 views.py 中创建基于类的视图
基于类的视图的基本语法如下所示:
class Name(APIView):
def GET(self,request):
''' Code'''
return response
def POST(self,request):
'''code'''
return response
这里所有的 HTTP 方法都将作为特定类中的类方法。如果你学习了 Python 中的面向对象编程，这很容易理解。
因此，让我们创建能够在网页上显示项目列表的 ItemsView 类。此外，我们将通过创建一个 ItemView 来进一步扩展我们的知识，它将允许我们查看、编辑和删除列表中的特定项目。
from rest_framework.views import APIView
from rest_framework import status
导入使用基于类的视图所需的上述两个库，然后编写以下代码:
class ItemsView(APIView):
def get(self,request,format =None):
items = ItemsModel.objects.all()
serializer = ItemSerializer(items, many =True)
return JsonResponse(serializer.data, safe =False)
def post(self,request,format =None):
data = JSONParser().parse(request)
serializer =ItemSerializer(data = data)
if serializer.is_valid():
serializer.save()
return JsonResponse(serializer.data,status = status.HTTP_201_CREATED)
return JsonResponse(serializer.errors,status = status.HTTP_400_BAD_REQUEST)
这里:
- 如果你熟悉基于函数的视图，你会使用 @csrf_exempt 令牌来保护你的网页不被伪造。但是使用基于类的视图，它已经包含在 APIView，中，因此你不需要单独添加它。
- 这里，我们需要给出一个请求作为每个类方法的参数。
- HTTP 方法被写成类方法。
- 在 get() 类方法中，我们将数据库中的所有对象存储到 items 变量中。
- 然后，我们使用序列化程序将特定信息(存储在条目列表中)转换成 JSON 格式。由于我们已经从数据库中取出了所有的对象，所以将 many 设置为 TRUE。
- 一旦信息被转换成 JSON，我们就返回适当的 JSON 响应。
- 在 post () 类方法中，我们将在请求中从用户处获取< id >。
- 所以我们需要将
<id>作为参数传递给后类方法。 - 由于用户将发送的信息是 JSON 格式的，我们需要将其转换成正确的 Python-Django 可读语法。
- 所以我们使用 JSONParser 来解析请求，以获得与新项目相关的数据，然后将其存储到变量数据中。
- 然后，我们使用序列化程序将从请求中获得的经过解析的 JSON 文本转换成 python 可读的语法。
- 现在，如果解析的序列化数据有效，那么我们保存它；否则，我们会显示一条错误消息。
- Django rest_framework 为我们提供了上面给出的 HTTP 状态。所以我们可以直接使用它们。
django Rest _ Framework–状态库
Django rest_framework 为我们提供了许多预装的 HTTP 状态，其中一些是:
- 状态 201 :该属性在创建新对象时使用，我们使用
status = status.HTTP_201_CREATED
- 状态 400: 当用户发出错误请求时使用该属性=
status = status.HTTP_400_BAD_REQUEST
- 状态 404: 当用户询问的特定信息不在服务器中时，使用该属性。
status = status.HTTP_404_NOT_FOUND
- 状态 200: 当一切如预期发生时，使用该属性。那就是过程被【确定】。
status =status.HTTP_200_OK
类似地，我们也将创建 ItemView。
class ItemView(APIView):
def get_objects(self,nm):
try:
return ItemsModel.objects.get(id = nm)
except ItemsModel.DoesNotExist:
raise Http404('Not found')
def get(self,request,nm,format =None):
item = self.get_objects(nm)
serializer = ItemSerializer(item)
return JsonResponse(serializer.data)
def put(self,request,nm,format =None):
item = self.get_objects(nm)
data = JSONParser().parse(request)
serializer = ItemSerializer(item,data = data)
if serializer.is_valid():
serializer.save()
return JsonResponse(serializer.data)
return JsonResponse(serializer.errors, status = status.HTTP_400_BAD_REQUEST)
def delete(self,request,nm,format=None):
item = self.get_objects(nm)
item.delete()
return HttpResponse(status =status.HTTP_204_NO_CONTENT)
这里:
- 同样， @csrf_exempt 不是必需的，因为它已经包含在 APIView 中
- try-except 块用于在单独的类函数下获取用户请求的对象，因为每个类方法都会使用它。
- 在这里的 try 中——除了块，我们将该项目的 id 传递给函数，然后我们尝试从数据库中获取该项。如果这个东西存在，那么我们将它存储到一个 item 变量中；否则，我们会引发 HTTP 404 错误。
- HTTP 方法作为类方法出现。
- 同样，在 HTTP class-methods 中，我们为 GET 和 PUT 方法编写了类似于上面视图的代码。
- 这里，我们添加了一个新的 DELETE 方法来删除特定的项。
- Django rest_framework 为我们提供了上面给出的 HTTP 状态。所以用这个代替之前的。
就是这样，看看它和基于类的视图是多么简单。
基于类的视图的 URL 映射
由于我们的视图不再基于功能，我们将视图链接到 URL 的方式也将改变。
基于类的视图有其内置的功能。as_view()，利用它我们可以直接包含视图。
在 urls.py 中，我们使用了。as_view() 如下:
urlpatterns = [
path('items/', ItemsView.as_view()),
path('item/<int:nm>/', ItemView.as_view()),
]
使用非常容易。as_view() 功能也一样。
在上一篇文章中，我们详细了解了序列化文件、模型文件，并创建了 ItemModel。如果您没有检查过，请不要担心，我也会在这里发布代码。
Models.py
Models
serializer . py
Serializers
就是这样；现在重新运行服务器并签入 POSTMAN，我们应该得到与上一篇文章相同的输出。
在 POSTMAN 上运行服务器
为了进行检查，我们将需要 POSTMan，这是运行 REST APIs 的一种非常有效和快速的方式。如果想了解更多关于邮差的信息，可以查看官方页面。
1.获取/项目
在搜索按钮中输入端点，然后按发送。在这里，你会看到物品清单
GET Items
2.帖子/项目
现在，保持终点不变。将方法更改为 POST。我们得到和以前一样的输出。
POST Items
3.GET /item/
现在如上所述更改端点，并选择 GET 方法。然后点击发送。这里也一样，它将像以前一样工作。
GET Item
4.PUT /item/
同样，保持端点不变，将 HTTP 方法改为 POST，然后点击 send。
PUT Item
5.删除/item/
现在要删除一个特定的对象，在端点中输入 id，选择删除方法，然后点击 send。该项目将像以前一样被删除。
DELETE Item
结论
就这样伙计们！这就是 Django 基于类的视图教程！我们希望您已经掌握了 Django 基于类的视图的所有基础知识，以及如何使用它们。另外，您可以从官方文档中了解更多关于 Django REST 框架的信息。
请继续关注 Django 主题的更多高级教程！
你必须知道的 8 个常见 Django 命令
在本 Python 教程中，我们将讨论 Django 初级开发人员应该知道的 8 个 Django 命令。那么让我们开始讨论吧。
亦读:姜戈简介
适用于初学者的 8 大 Django 命令
事不宜迟，让我们从不同的 Django 命令开始，作为初学者，您必须了解这些命令，以便轻松完成工作。虽然你可以一直走传统路线，使用鼠标和键盘，用 GUI 工作，但这不是程序员的方式！这就是为什么我决定编制这个清单。
1.创建 Django 项目
如果您熟悉 Django，您会知道 Django 提供了文件、文件夹和设置的初始集合来启动我们的项目。要创建初始的 Django 项目结构，打开您的 OS 终端并cd到您想要保存 Django 项目代码的目录或文件夹。然后在选择的终端上运行下面的命令，这将在当前的工作目录中创建一个目录/文件夹，其中包含命令中提供的<项目名称>。
> django-admin startproject <project_name>
输出:
Django Project Directory Structure
2.进行迁移命令
将为模型类(进一步表示数据库中的表)编写的 Python 代码转换成数据库查询。每当我们对数据库类模型进行任何类型的更改时，都有必要运行这个命令。要运行以下命令，移动到包含manage.py文件的项目文件夹中，该文件将在主项目目录中创建必要的数据库文件。
> python manage.py makemigrations
输出:
Django’s Default database SQLite3 File Created
3.迁移命令
我们需要运行这个命令，根据定义的 Python 类模型在指定的数据库中创建表。此命令负责应用或取消应用迁移。当我们第一次运行这个命令时，所有与默认应用程序(由 Django 框架提供)相关的迁移都会被应用。
> python manage.py migrate
输出:
Operations to perform:
Apply all migrations: admin, auth, contenttypes, sessions
Running migrations:
Applying contenttypes.0001_initial... OK
Applying auth.0001_initial... OK
Applying admin.0001_initial... OK
Applying admin.0002_logentry_remove_auto_add... OK
Applying admin.0003_logentry_add_action_flag_choices... OK
Applying contenttypes.0002_remove_content_type_name... OK
Applying auth.0002_alter_permission_name_max_length... OK
Applying auth.0003_alter_user_email_max_length... OK
Applying auth.0004_alter_user_username_opts... OK
Applying auth.0005_alter_user_last_login_null... OK
Applying auth.0006_require_contenttypes_0002... OK
Applying auth.0007_alter_validators_add_error_messages... OK
Applying auth.0008_alter_user_username_max_length... OK
Applying auth.0009_alter_user_last_name_max_length... OK
Applying auth.0010_alter_group_name_max_length... OK
Applying auth.0011_update_proxy_permissions... OK
Applying auth.0012_alter_user_first_name_max_length... OK
Applying sessions.0001_initial... OK
4.收集静态文件
在 Django 中，我们以不同的方式处理静态文件。建议创建一个单独的文件夹，并将所有静态文件保存在那里。我们需要这些 Django 命令来让它知道主项目目录中存在的静态文件。
> python manage.py collectstatic
输出:
You have requested to collect static files at the destination
location as specified in your settings.
This will overwrite existing files!
Are you sure you want to do this?
Type 'yes' to continue, or 'no' to cancel:
5.创建 Django 应用程序
Django 项目是一个网站的应用程序和配置的集合。一个项目中可以有多个应用程序，一个应用程序可以包含在几个 Django 项目中。在 Django 项目中创建 Django 应用程序需要这个命令，它将生成 Django 应用程序的基本目录结构。
> python manage.py startapp <app_name>
输出:
Django App Directory Created
6.创建超级用户
这是登录 Django 框架提供的默认管理界面面板必不可少的命令。需要这个命令来为管理界面创建一个超级用户，这个超级用户拥有用户名、密码和所有其他访问和管理 Django 网站的必要权限。
> python manage.py createsuperuser
输出:
Username (leave blank to use 'inspiron'): Username
Email address: [email protected]
Password:
Password (again):
This password is too short. It must contain at least 8 characters.
This password is too common.
This password is entirely numeric.
Bypass password validation and create user anyway? [y/N]: y
Superuser created successfully.
7.更改密码
有可能，我们忘记了默认管理界面面板的密码。然后，重置它变得非常必要，因为没有密码，我们将无法访问默认的管理界面面板。我们必须提供适当的<username>，在运行该命令时必须重置其密码。
> python manage.py changepassword <username>
输出:
Changing password for user 'Username'
Password:
Password (again):
Password changed successfully for user 'Username'
8.运行服务器
这也是非常重要和最常用的 Django 命令之一。我们需要这个命令通过在本地服务器上运行来验证和测试我们的 Django 应用程序和网站。默认情况下，该命令在端口号为 8000 的内部 IP 上运行 Django 开发服务器。如果需要，我们还可以通过将它们作为命令行参数发送来更改开发服务器的 IP 和端口号。
> python manage.py runserver
输出:
Watching for file changes with StatReloader
Performing system checks...
System check identified no issues (0 silenced).
August 30, 2021 - 15:16:23
Django version 3.2.5, using settings 'myproj.settings'
Starting development server at http://127.0.0.1:8000/
Quit the server with CTRL-BREAK.
结论
在这个 Python 教程中，我们学习了 Django 的 8 个顶级命令，这些命令应该是初级 Django 开发人员都知道的。希望你已经理解了上面讨论的概念，并准备建立自己的 Django 网站或应用程序。感谢阅读！请继续关注我们，获取更多关于 Python 编程的精彩学习资源。别忘了看看我们的 Django 教程系列。
Django Cookies 在 Django 中设置用户 cookie
在本文中，我们将讨论如何为我们的 web 应用程序设置 Django cookies。我们将从讨论使用 cookie 背后的理论和原因开始，然后在文章的最后用 Django 实现 cookie。所以让我们开始吧！
什么是饼干？
cookie，技术上称为HTTP cookie，是存储在客户端浏览器上的一条信息(存储在一个文件中)，在请求时发送到网站服务器。
由于 cookie 保存在客户端，所以它是否能够将这些 cookie 发送到 web 服务器取决于客户端的安全级别。
它可以永久保存，也可以保存一段时间。每个 cookie 都有自己的专家日期和时间，一旦过期，就会自动从客户端的浏览器中删除。
饼干是如何工作的？
Http 是一种无状态协议，这意味着 web 服务器无法区分您是第一次访问该页面，还是之前已经访问过该页面。
所以当你第一次访问一个页面的时候，服务器会用 cookies 来响应浏览器，cookies 包含了服务器生成的用户信息等信息。
该 cookie 存储在您的浏览器中。因此，当您再次访问时，先前生成的 cookie 也会随 HTTP 请求一起发送到服务器。然后，服务器可以读取 cookie 并执行适当的任务。
浏览器会一直发送 cookies，直到它们过期，过期后会自动从浏览器中丢弃。
为什么要用饼干？
在任何电子商务或社交媒体网站，如脸书，你可能已经注意到，如果你离开网站没有注销，下次你去该网站，你的帐户继续保持登录状态。这是使用 cookies(包含用户会话信息)完成的
同样，在许多电子商务网站上，你会得到不同产品的推荐。这也是因为 cookies 在你的浏览器中存储了搜索信息。
动手制作 Django Cookies
我们现在将看到 cookies 的一个简单应用，并学习如何使用它们。Django 提供了一个使用 cookies 的内置方法。
1) Django Cookie 属性
Django cookie 属性可以执行两种操作之一。它可以在用户的计算机中放一个 cookie(set)然后访问这些 cookie(get)。让我们看看这两种方法。
设置 cookie s
这个 cookie 属性创建一个 cookie，然后由服务器 发送到用户浏览器来存储信息。set_cookie()的语法是:
set_cookie(cookie_name, value, max_age = None, expires = None)
获取饼干
服务器使用这个属性来取回以前发送的 cookies 并从中读取数据。获取 cookie 的语法是:
request.COOKIES['cookie_Name']
2) C 修改视图
现在我们知道了 Django cookies 可以使用的方法，让我们设置视图来设置这些 cookie，然后访问它们。我们将在 Django views 文章的基础上建立 cookies。
发送 Cookie 的视图
将以下视图添加到 views.py 文件中
def SetCookie(request):
response = HttpResponse('Visiting for the first time')
response.set_cookie('bookname','Sherlock Holmes')
return response
URL 路径将是:
path('setcookie/', SetCookie),
用于取回 Cookie 的视图
将以下视图添加到您的 views.py 中
def GetCookie(request):
bookname = request.COOKIES['bookname']
return HttpResponse(f'The book name is: {bookname}')
URL 路径将是:
path('getcookie/', GetCookie),
cookie 的实现
既然我们已经讨论了所需的单个视图，下面是 Views.py 的组合脚本(包括上面的代码)
只需在您的 views.py 中添加以下代码以及 URL 映射，我们就可以开始了:
from django.shortcuts import HttpResponse
def SetCookie(request):
response = HttpResponse('Visiting for the first time')
response.set_cookie('bookname','Sherlock Holmes')
return response
def GetCookie(request):
bookname = request.COOKIES['bookname']
return HttpResponse(f'The book name is: {bookname}')
urls.py 文件将类似于:
from django.contrib import admin
from django.urls import path
from .views import SetCookie, GetCookie
urlpatterns = [
path('setcookie/', SendCookie),
path('getcookie/', GetCookie),
]
就这样，伙计们！！现在让我们运行服务器并进行检查！！
Set Cookie
Get Cookie
结论
就这样，伙计们！！这就是关于 Django cookies 以及如何在项目中使用它们的全部内容。一定要练习上面的代码来增加你对 cookies 的理解。
下一篇文章再见！！在那之前继续编码！！
Django CRUD 应用程序
在本文中，我们将了解 Django CRUD 应用程序由什么组成，然后创建我们自己的 CRUD 应用程序。
什么是 Django CRUD 应用程序？
CRUD 应用程序是一个处理CRUD——创建、检索、更新和删除操作的网站。CRUD 应用程序的一个典型例子是学生数据应用程序。在此类应用中，您可以:
- 添加/创建新的学生数据
- 检索当前学生的数据
- 更新/编辑已经是学生的数据
- 删除一个学生数据
我们现在将了解这些操作中的每一项
CRUD
- 创建:在数据库中创建或添加新条目
- 检索:从数据库中获取条目
- 更新:更新数据库中的特定条目
- 删除:从数据库中删除特定条目
在 Django 中创建我们自己的 CRUD 应用程序
现在让我们创建一个简单的学生数据 CRUD 应用程序。
1.创建模型表
为了存储数据，我们需要创建一个 Django 模型。因此，将以下模型添加到您的文件中。
class StudentModel(models.Model):
id = models.IntegerField(primary_key = True)
student_name = models.CharField(max_length=80)
rollnumber = models.CharField(max_length=10)
student_class = models.IntegerField()
student_age = models.IntegerField()
def __str__(self):
return f"{self.student_name} : {self.rollnumber}"
2.创建模型表单
我们还需要一个模型表单来向用户显示模型字段。
class StudentForm(forms.ModelForm):
class Meta:
model = StudentModel
fields = ('id','student_name','rollnumber','student_class','student_age')
3.编写创建视图的代码
在 Views.py 中创建视图“create View”并添加以下代码:
from .models import StudentModel
from .forms import StudentForm
from django.shortcuts import render,redirect
def CreateView(request):
if request.method == 'POST':
form = StudentForm(request.POST)
if form.is_valid():
form.save()
return redirect('/data')
else:
form =StudentForm()
context = {
'form':form
}
return render(request,'create.html',context)
模板“create . html”将看起来像:
<form method = "post">
{% csrf_token %}
{{form.as_p}}
<input type = "submit" value = "submit">
</form>
视图的 URL 路径将是:
path('data/create', CreateView),
4.对检索视图进行编码
现在在检索操作中，有两种可能的方法
- 显示所有数据列表 ( Django 列表视图 )
- 仅显示特定数据 ( Django 详细视图 )
因此，将以下两个视图添加到 views.py 文件中
from django.shortcuts import render,redirect
from .models import StudentModel
from .forms import StudentForm
def Retrieve_ListView(request):
dataset = StudentModel.objects.all()
return render(request,'listview.html',{'dataset':dataset})
def Retrieve_DetailView(request,_id):
try:
data =StudentModel.objects.get(id =_id)
except StudentModel.DoesNotExist:
raise Http404('Data does not exist')
return render(request,'detailview.html',{'data':data})
相应的 ListView 模板将是:
{% for data in dataset %}
{{data}}
<hr>
{% endfor %}
相应的详细视图模板将是:
<h3>Name:{{data.student_name}}</h3><br>
<h3>Roll Number:{{data.rollnumber}}</h3><br>
<h3>Class:{{data.student_class}}</h3><br>
<h3>Age:{{data.student_age}}</h3><br>
<hr/>
视图的 URL 路径将是:
path('data/', Retrieve_ListView),
path('data/<int:_id>',Retrieve_DetailView),
5.更新视图编码
现在将下面的更新视图添加到 views.py 文件中
from django.shortcuts import render,redirect,get_object_or_404
from .models import StudentModel
from .forms import StudentForm
def UpdateView(request,_id):
try:
old_data = get_object_or_404(StudentModel,id =_id)
except Exception:
raise Http404('Does Not Exist')
if request.method =='POST':
form =StudentForm(request.POST, instance =old_data)
if form.is_valid():
form.save()
return redirect(f'/data/{_id}')
else:
form = StudentForm(instance = old_data)
context ={
'form':form
}
return render(request,'update.html',context)
相应的update.html模板将看起来像这样:
<form method="post">
{% csrf_token %}
{{form.as_p}}
<input type="submit" value = "Update">
</form>
视图的 URL 路径将是:
path('data/<int:_id>/update', UpdateView),
6.对删除视图进行编码
现在将删除视图添加到 views.py 文件中
def DeleteView(request,_id):
try:
data = get_object_or_404(StudentModel,id =_id)
except Exception:
raise Http404('Does Not Exist')
if request.method == 'POST':
data.delete()
return redirect('/data')
else:
return render(request, 'delete.html')
相应的delete.html会是什么样子:
<form method="post">
{% csrf_token %}
Click YES to confirm
<input type = "submit" value="YES">
<a href='/data'>Cancel</a>
</form>
视图的 URL 路径将是:
path('data/<int:_id>/delete', DeleteView),
实现学生应用
编码部分就这样了！！现在启动服务器，让我们转到“ /data/create ”端点
Create
点击提交，您将到达显示学生列表的 "/data" 页面。
Retrieve List View
现在尝试“ /data/1 ”端点
Retrieve Detail View
好了伙计们。！让我们更新第一个条目。转到“/数据/1/更新”
Update
进行一些更改并点击“更新”,您将被重定向到特定学生的详细视图页面。
最后，让我们尝试删除第一个学生。进入/数据/1/删除
Delete
点击 YES 并检查，特定的学生数据将从数据库中删除。
结论
就这样，编码员们！！这都是关于 CRUD 应用程序的。一定要看看 Django REST API 教程，这是一个 CRUD 应用程序的 REST API 版本。
下一篇文章再见！！在那之前继续编码！！
Django 调试–在你的 Django 网页上添加一个调试栏
在本文中，我们将讨论如何执行 Django 调试。我们将学习 web 开发中需要的一项重要技术，称为调试，然后进一步学习如何将调试器工具添加到我们的网站中。
所以让我们开始吧！！
调试的艺术
不管有多专业，每个开发人员都会在生命的某个阶段处理错误。此外，调试错误不是一件容易的事情；首先指出错误并消除它需要花费大量时间。因此，每个开发人员都必须了解调试。
但是有了 Django，你猜怎么着，调试过程对你来说变得简单多了。您只需要在您的 web 应用程序上安装 Django 调试器工具，就可以了。
因此，现在我们知道了为什么调试是必不可少的，让我们开始动手吧。
Django 中调试的先决条件
现在要使用调试工具栏，我们需要一个网站。如果你有你的项目，你可以使用它。否则，添加下面的视图和相应的 URL 路径。
def SampleView(request):
Html = '<body><h1>Django Caching<h1><br><p>Welcome to Caching Tutorial</p></body>'
return HttpResponse(html)
确保 <体> 存在；否则，调试器工具将不会显示在网页上，其模板没有 < body >标签。
代码的 URL 路径将是:
path('sample/', SampleView),
现在，对于下一部分，您可以以上面显示的任何形式存储缓存:
Django 调试器工具
调试器工具包括各种调试选项，我们可以在特定的网页上使用。我们现在将研究工具栏提供的各种工具
- Version: 给出了我们正在使用的 Django 的版本。
- 时间:显示加载网页所用的时间
- 设置:显示网页的设置
- 请求:显示所有被请求的元素——视图、cookies 等。
- SQL: 显示 SQL DB 调用的列表
- 静态文件:给出关于静态文件的信息
- 模板:给出关于模板的信息
- 高速缓存:告知关于当前高速缓存的信息
- 日志:显示注册的日志数量。(参见 Django Logging 了解日志信息)
安装 Django 调试工具
在这一节中，我们将安装 Django 调试器工具栏所需的所有需求
1)安装 Django 调试器工具栏
为了安装 Django 调试器工具栏，我们使用了 pip install 命令。在终端/shell 中运行以下代码:
pip install django-debug-toolbar
2)在 INSTALLED_APPS 中添加调试器工具
在 settings.py 中，在 INSTALLED_APPS 部分添加以下行
INSTALLED_APPS = [
# ...
'debug_toolbar',
]
还要确保 settings.py 文件中存在以下行
STATIC_URL = '/static/'
上面的代码应该已经存在，但如果它不存在，那么只需在最后添加上面的代码。
3)将调试工具栏导入到 urls.py
要在网页上使用调试工具栏，我们必须链接到网页的 URL 路径。
因此，在 urls.py 中，添加代码:
from django.conf import settings
from django.URLS import path,include
if settings.DEBUG:
import debug_toolbar
urlpatterns = [
path('__debug__/', include(debug_toolbar.urls)),
] + urlpatterns
确保在 settings.py 中将 DEBUG 设置为 TRUE ，这样才能工作。
这里我们将 debug_toolbar 添加到 URL 模式列表中，所有其他的 URL 都在这里
Debug ToolBar urls.py
4)启用中间件
必须将与 Django 调试工具栏相关联的中间件添加到 settings.py 中的中间件部分
MIDDLEWARE = [
# ...
'debug_toolbar.middleware.DebugToolbarMiddleware',
]
5)提及 INTERNAL_IPS
只有当 IP 出现在 settings.py 中的 INTERNAL_IPS 列表中时，才会显示调试工具栏。出于本地开发的目的，将 IP127 . 0 . 0 . 1添加到列表中。
INTERNAL_IPS = [
'127.0.0.1',
]
如果 INTERNAL_IPS 列表不存在，则在 settings.py 的最后添加上述列表，并添加 IP“127 . 0 . 0 . 1”
Django 调试工具的输出
添加所有代码后，在您首选的浏览器中访问 127.0.0.1:8000/sample/ 。
如果您看到下面的输出，您的实现是成功的！如果没有，检查上面的代码是否在您的文件中丢失了。
Debug toolbar
就是这样，工具栏会出现在网页的右侧。
结论
就这样，伙计们！！这也是关于 Django 调试器的。请务必查看 Django 异常处理文章，以了解更多关于调试异常的信息。
下一篇文章再见！！在那之前，继续练习！！
Django Detail view–如何在 Django 中创建细节视图？
在本文中，我们将了解 Django DetailView。
什么是 Django 详细视图？
Django DetailView 指的是显示模型表中单个实例的视图类型。它用于显示数据库中单个条目的信息，并对该实例执行不同的任务。
django detailsview 的先决条件
这个主题的先决条件与我们的 ListView 文章中列出的完全相同。先决条件的代码添加在下面，您可以浏览它们。
如果您觉得需要一个解释，请仔细阅读 ListView 文章中列出的先决条件，然后您可以在这里继续创建 Django 详细视图。
Models.py 中的项目模型
class ItemModel(models.Model):
id = models.IntegerField(primary_key = True)
name = models.CharField(max_length = 80, blank = False)
price = models.IntegerField
class Meta:
ordering = ['name']
def __str__(self):
return f"{self.name}:{self.price}"
Serializers.py 中的 ItemSerializer
from rest_framework import serializers
from .models import ItemModel
class ItemSerializer(serializers.ModelSerializer):
class Meta:
model = ItemModel
fields = ['id',name','price']
详细视图的 URL 端点
此外，端点将简单地为 /item/ < id > ，因为详细视图只关注显示数据库中具有特定 id 的实例。
Url 映射的代码:
path('item/<id>', ItemView.as_view())
就这样，现在我们将学习用两种不同的方法创建一个细节视图。
详细视图的代码逻辑
在上一篇文章中，您看到了 ListView 的逻辑。细节视图也有其逻辑，从端点请求获得 < id > ，然后进一步执行必要的任务。
这类似于 ListView，但它的基本格式有一些变化，因为我们在这里处理的是端点数据。
首先，我们将获取端点数据，这基本上是用户将随请求一起发送的条目 id 。
服务器与用户交互的代码逻辑
逻辑很简单，经过下面概述的步骤后就可以理解了:
- 使用我们之前获得的 id，,从 DB 中检索商品信息。
- 使用序列化程序将信息转换成 JSON 格式。
- 通过模板或直接作为 JSON 显示给用户。
基本流程图如下所示:
用户与服务器交互的代码逻辑
这个逻辑有点像我们在上一节中所做的逆向过程。
- 将 JSON 数据与请求的其余部分分离(解析)。
- 来自用户的 JSON 数据必须使用序列化器转换成 Django 可读格式(python-dictionary)
- 对其 id 在端点请求中发送的项目进行必要的更改(添加、编辑、删除)。
基本流程图如下所示:
创建 Django 详细视图
1.基于功能的详细视图
基于函数的详细视图的示例代码如下:
@csrf_exempt
def ItemView(request,nm):
try:
item = ItemsModel.objects.get(id = nm)
except ItemsModel.DoesNotExist:
raise Http404('Not found')
if request.method == 'GET':
serializer = ItemSerializer(item)
return JsonResponse(serializer.data)
if request.method == 'PUT':
data = JSONParser().parse(request)
serializer = ItemSerializer(item,data =data)
if serializer.is_valid():
serializer.save()
return JsonResponse(serializer.data)
return JsonResponse(serializer.errors, status =400)
if request.method == "DELETE":
item.delete()
return HttpResponse(status =204)
请记住上一节中给出的我们用 DetailView API 执行的步骤，并尝试理解代码。
- 从端点请求中获取 id
- try-except block :如果该项存在，则从 DB 中获取对象信息并保存在变量 item 中。
- def GET :将项变量转换成 JSON(串行器)→显示 JSON 数据
- def PUT: 解析请求以分离 JSON 数据→转换为 Python 格式→更新 DB 中关于该项的数据
- def DELETE: 从数据库中删除项目。
2.基于类别的详细视图
基于类的视图比函数视图更好，因为使用了类，代码变得更加系统化、结构化和可读。
基于类的 DetailView 的示例代码如下:
class ItemView(APIView):
def get_objects(self,nm):
try:
return ItemsModel.objects.get(id = nm)
except ItemsModel.DoesNotExist:
raise Http404('Not found')
def get(self,request,nm,format =None):
item = self.get_objects(nm)
serializer = ItemSerializer(item)
return JsonResponse(serializer.data)
def put(self,request,nm,format =None):
item = self.get_objects(nm)
data = JSONParser().parse(request)
serializer = ItemSerializer(item,data = data)
if serializer.is_valid():
serializer.save()
return JsonResponse(serializer.data)
return JsonResponse(serializer.errors, status = status.HTTP_400_BAD_REQUEST)
def delete(self,request,nm,format=None):
item = self.get_objects(nm)
item.delete()
return HttpResponse(status =status.HTTP_204_NO_CONTENT)
同样，编写代码的方式也发生了变化。我们使用类方法和类内函数(在本例中，try-except 块在一个单独的类函数中)来编写代码。但逻辑的关键仍然是一样的。
detail view API 的实现
就是这样。我们已经基本完成了代码，是时候为这个演示运行一些测试了。
让我们尝试运行基于函数和基于类的视图。
我们将使用 POSTMAN 来运行 REST APIs。邮差的官网讲工具的好处。让我们继续演示吧。
GET Item
在上面的截图中，你可以看到 GET in action。我们显示从数据库中提取的“id 1”数据
PUT Item
上面的截图演示了 PUT。
DELETE Item
看看当我们在它上面运行 DELETE 命令时，命令输出是什么样子。
结论
就这样，伙计们！！Django 中的 DetailView 就是这么做的。基于请求数据(< id > ) 从模型中取出一个实例，然后显示它，从数据库中添加、编辑或删除项目实例。
更多此类有趣话题敬请期待！！注意安全！！
Django 异常处理——简单的操作方法
原文：https://www.askpython.com/django/django-exception-handling
在本文中，我们将以非常简洁的方式学习 Django 异常处理，同时涵盖 Django 中的大多数异常和错误消息。
为什么我们需要处理异常？
作为一名开发人员，您会在制作 web APIs、模板或编写任何其他代码时遇到各种各样的错误。
处理它们是一个非常耗时的过程，但也是一项必不可少的任务，因此这种异常和错误处理的关键技能就出现了。
什么是例外？
编码中的异常是那些导致不良事件的事件类型。这些是由运行时执行程序(如控制台和终端)或操作系统检测的。
它们不一定会停止整个程序，但会导致不希望的输出。
例如:
假设客户希望从数据库中看到一个特定的对象。但是由于某种原因，那个特定的对象不在那里。
在这种情况下，服务器不会停止，但是客户机会得到一个错误，因为对象不在 DB 中，这是不希望的。
异常和错误的主要区别
错误是指导致整个系统停止运行，程序无法执行的事件。
有错误什么也做不了；我们只能检测，然后做出适当的改变，使它们不会发生。
另一方面，异常是开发者可以处理的事情，而不会让系统停止。
Django 异常的类型
Exception Handling
Django 中有很多种例外，其中五个是极其重要的和使用最频繁的。****
- Django 异常类
- Django URL 解析程序异常
- Django 数据库异常
- Django Http 异常
- Django 交易异常
我们将详细了解它们。
1) Django 异常类
| 身份证明 | 例外 | 描述 |
|---|---|---|
| one | AppRegistryNotReady | –当 Django 模型在 Django 应用程序本身之前加载时，就会出现这种情况。 |
| –当您编写自己的脚本而不是使用默认的 Django 应用程序文件时，会出现此异常。 | ||
| Two | 对象目标神经学家 | 顾名思义，当对象不存在时发生。 |
| three | 经验值结果集 | 当查询返回空集时发生 |
| four | 字段不存在 | 当模型中不存在字段时，会出现这种情况。 |
| five | 返回了多个对象 | 当查询返回多个结果时，会出现这种情况 |
| six | 可疑操作 | 当客户端出于安全原因做了一些可疑的事情时，就会发生这种情况 |
| seven | 权限被拒绝 | 当用户试图执行不允许他执行的任务时发生 |
| eight | ViewDoesNotExist | 当视图不存在时发生 |
| nine | 未使用的中间件 | 当 settings.py 的中间件部分没有使用特定的中间件时，就会出现这种情况 |
| Ten | 配置不正确 | 当 Django 配置不正确时，就会出现这种情况。在使用默认的 Django 文件时通常不会发生这种情况。 |
| Eleven | 字段错误 | 当模型字段中有错误时发生 |
| Twelve | 验证错误 | 当表单或模型表单中的数据验证失败时发生。 |
Django Exception classes
2) Django URL 解析器异常
| 身份证明 | 例外 | 描述 |
|---|---|---|
| one | 解析器 404 | –由 Django.http.Http404 库的一部分函数 resolve() 引发。 |
| –当路径()没有可映射的有效视图时出现异常。 | ||
| Two | 不匹配 | 当用户搜索错误的端点时，会出现这种情况。 |
Django URL Resolver Exceptions
3) Django 数据库异常
| 身份证明 | 例外 | 描述 |
|---|---|---|
| one | DatabaseError | 当数据库不可用时发生 |
| Two | 完整性错误 | –当 DB 需要某个字段的值，但没有从用户处获得该值时，会出现这种情况。 |
| –如果为真， Django 将在数据库中将空值存储为 NULL。默认值为 False。 | ||
| three | 数据错误 | 因数据相关问题而发生 |
Django Database Exceptions
4) Django Http 异常
这一点我们已经见过很多次了。这些是我们从 django.http 库中导入的 HTTP 异常
| 身份证明 | 例外 | 描述 |
|---|---|---|
| one | UnreadablePostError | 当用户取消上载时发生。 |
Django Http Exceptions
5) Django 交易异常
| 身份证明 | 例外 | 描述 |
|---|---|---|
| one | 交易管理错误 | 所有因数据库事务而出现的问题都会引发此问题 |
Django Transaction Exceptions
Django 应用中异常处理的简单实现
我们将在一个应用程序上执行一个简单的 DoesNotExist 异常处理，显示服务器中某个特定项目的信息。
该代码是 REST API 文章中构建的 Web 应用程序 itemsapp 的一部分。
Itemsapp 是一个简单的 REST API 应用程序，它允许客户端
- 查看服务器中存在的项目列表(获取端点:
hostwebsite/items) - 向数据库中添加一个新项目(POST 端点:
hostwebsite/items) - 查看特定项目(GET endpoint:
hostwebsite/item/<id>) - 编辑特定项目(PUT endpoint:
host website/item/<id>) - 删除特定项目(删除端点:
hostwebsite/item/<id>)
要了解如何创建完整的 web 应用程序，请阅读 Rest API 文章。
现在我们将创建一个显示来自数据库的特定商品信息的网页
- 在 models.py 中创建一个 ItemModel 来存储关于项目的信息:
from django.db import models
# Create your models here.
class ItemsModel(models.Model):
id = models.IntegerField(primary_key = True)
name = models.CharField(max_length = 80)
price = models.IntegerField()
class Meta:
ordering = ['name']
def __str__(self):
return f"{self.name}:{self.price}"
- 如上图所示， urls.py 中的 URL 路径将是:
path('/item/<int:nm>',Item)
现在只需通过管理网站添加一些项目到数据库中。
Admin
- 现在在 views.py 中，显示带有 id = nm 的特定项目的代码将是:
def Item(request,nm):
item = ItemModel.objects.get(id = nm)
return HttpResponse(item)
运行服务器并检查 DB 中不存在的对象，比如说 id = 4
您将得到一条错误消息
DoesNotExist
现在我们将使用 Django 异常处理来处理这个错误。编辑 views.py 中的代码，如下所示:
def Item(request,nm):
try:
item = ItemsModel.objects.get(id = nm)
except ItemsModel.DoesNotExist:
return HttpResponse('Exception: Data Not Found')
return HttpResponse(item)
注意除 ItemsModel 之外的行"。不存在”。这是 Python 自动捕获异常的地方。您可以用上面列表中的一个异常替换该异常，并用自定义错误消息处理该异常。
对于第一次进口
from django.core.exceptions import *
就这样，现在我们可以继续添加我们想要的异常
def Item(request,nm):
try:
item = ItemsModel.objects.get(id = nm)
except ObjectDoesNotExist:
print('Data Not Found')
return HttpResponse(item)
现在运行服务器并搜索 id = 4
Exception Handling
类似地，我们将处理来自 django.core.exceptions 的其他重要且最常用的异常
其他一些重要的例外
首先，我们必须导入库
from django.core.exceptions import <error_name>
让我们来看看重要的例外情况
字段不存在
当模型字段不存在时，会出现这种情况
try:
Model.objects.get(<field> = '<value>')
except FieldDoesNotExist:
print('The Field is missing')
返回了多个对象
当数据库中的多个对象对于某个字段具有相同的值时发生
try:
Model.objects.get(<name> = '<value>')
except MultipleObjectsReturned:
print('More than one object with the same name are present in the Database')
视图不存在
当我们通过 urls.py 中的 path() 调用一个视图，但是这个视图并不存在时，就会发生这种情况。
try:
path('item/', <View>)
except ViewDoesNotExist:
print('The View does not exist in views.py')
合法性错误
当表单数据中的某些信息无效时发生
data = form.cleaned_data['name']
if '<field_name>' not in data:
raise ValidationError('This name does not exist')
结论
就这样，伙计们！我真的希望这篇文章有助于增加您对 Django 异常的知识和理解。更多信息请参考官方文档。
注意安全！！继续学习！！
Django 扩展–安装和实现扩展
在本文中，我们将看到 Django 扩展功能扩展了 Django 中默认提供的功能。
各种重要的 Django 扩展
提供的各种重要扩展如下:
- 管理扩展
- 命令扩展
- 调试器标签
- 字段扩展
- 模型扩展
- 验证器
- Powershell
下表给出了详细的分析
1.管理扩展
一些重要的扩展包括:
| 延长 | 描述 |
|---|---|
| foreign keyautocompleteadmin | 允许管理应用程序显示带有搜索输入字段的外键字段。 |
| foreinkeyautocompletestackedinline | |
| 和foreinkeyautocompletetabularinline | 类似于 AutocompleteAd，这两个类为 AdminInline 类中的外键字段启用搜索输入字段 |
Admin Extensions
2.命令扩展
一些最常用的命令扩展是:
| 延长 | 描述 |
|---|---|
| Shell_plus | Django shell 的增强版；已经自动加载了所有的模型，因此我们可以马上使用 ORM。 |
| 创建 _ 模板 _ 标签 | 在指定的应用程序中生成模板标记目录结构 |
| 生成 _ 密码 | 它会生成一个可用作用户密码的新密码。 |
| 导出 _ 电子邮件 | 以下列格式之一导出电子邮件地址–Google、Outlook、LinkedIn 和 VCard |
| 图形 _ 模型 | 它为应用程序创建了一个 GraphViz 点文件。它将应用程序的模型(通过)合并成一个单一的模型。输出通常指向一个点文件。 |
| 运行 _ 脚本 | 在姜戈运行一个脚本 |
| sql_create | 按照 settings.py 中的指定，生成创建数据库的 SQL。 |
Command Extensions
在后面的章节中，我们将会看到更多关于 shell–shell _ plus的内容。
3.调试器标记
有了调试器标签，我们可以轻松调试 Django 模板。这些模板标签提供了三个过滤器——IPDB、PDB 或 WDB
语法是:
{% load debugger_tags %}
{% for object in objects %}
{{object | ipdb/pdb/wdb }}
{% endfor %}
| 过滤器 | 描述 |
|---|---|
| IPDB | 它是一个 Ipython 调试器工具，与 Ipython 一起使用来调试模型对象(与它一起使用) |
| 物理数据库 | 调试模型对象是普通的 Python 调试器 |
| WDB | 它是一个 Web 调试器工具，用于通过浏览器本身调试基于 python 的应用程序。 |
Debugger Tags
注意:要使用过滤器，我们需要在模板文件的顶部加载调试器标签
{% load debugger_tags %}
4.字段扩展
一些有用的字段扩展包括:
| 随机场 | 创建具有指定长度的唯一随机字符 |
| 日期时间字段 | 当对象首次保存到数据库时，DateTimeField 自动设置其日期 |
| JSONField | 这个文本字段整齐地序列化/反序列化 JSON 对象 |
Field Extensions
5.模型扩展
这些是重要的模型扩展:
| 延长 | 描述 |
|---|---|
| ActivatorModel | 这个抽象基类提供了一个状态、激活日期和去激活日期 |
| TitleDescriptionModel | 这个抽象基类模型提供了 title 字段，它是一个最大长度为 255 的不可空 CharField，以及一个可空描述字段。 |
Modle Extensions
6.验证器
Django 扩展提供的一些重要的验证器是:
| 延长 | 描述 |
|---|---|
| 无控制字符验证计算机 | 该属性确保了像新行或制表符这样的控制字符是而不是所允许的。 |
| NoWhitespaceValidator | 这个属性确保了开头和结尾的空格是允许的而不是。 |
| HexValidator | 确保该字符串是有效的十六进制字符串。也可以选择指定长度、最小长度和最大长度参数 |
Validators
安装 Django 扩展
我们可以使用 pip 命令本身安装扩展。运行代码
pip install django-extensions
我们还需要在 settings.py 中提到 Django 扩展。所以只需在 INSTALLED_APPS 目录中添加以下内容。
INSTALLED_APPS = [
#......
#......
#......
'django_extensions'
]
就这样，Django 扩展已经可以使用了。
实现 Django 扩展
现在我们将看到如何在 Django 项目中使用重要的扩展
1.实施管理扩展
考虑我们在上一篇文章中构建的 BlogModel，在 models.py 文件中有以下字段
from django.db import models
class BlogModel(models.Model):
id = models.IntegerField(primary_key=True)
blog_title = models.CharField(max_length=20)
blog = models.TextField()
def __str__(self):
return f"Blog: {self.blog_title}"
此外，考虑一个 CommentModel ，它包含来自 BlogModel 表的特定博客的评论。在 models.py 文件中的BlogModel 下添加注释模型:
class CommentModel(models.Model):
your_name = models.CharField(max_length=20)
comment_text = models.TextField()
blog = models.ForeignKey('BlogModel', on_delete=models.CASCADE)
def __str__(self):
return f"Comment by Name: {self.your_name}"
注意， blog 字段是连接 BlogModel 的 FK。现在，在 admin.py 文件中，我们将对评论模型模板应用管理扩展。
from .models import *
from django_extensions.admin import ForeignKeyAutocompleteAdmin
@admin.register(CommentModel)
class BookModelAdmin(ForeignKeyAutocompleteAdmin):
related_search_fields = {
'blog':('blog_title',)
}
#Fields
fields =('your_name','comment_text','blog')
有关管理模板的更多信息，请查看管理模板一文
现在运行服务器并转到管理站点
Admin Extensions
查看搜索选项如何出现在 FK 博客字段中。
2.用 Ipython 实现 shell_plus
要用 Ipython 运行 shell_plus，我们首先需要安装它。
Ipython 是一个为 python 打造的交互式 shell。它使得 shell 环境高效且易于使用。它提供了我们可以使用的有用的环境工具和命令。
要安装 IPython，请运行以下命令:
pip install ipython
现在使用下面的命令运行 shell_plus 和 ipython
python manage.py shell_plus --ipython
Shell Plus With Ipython
看，项目中的所有模型都自动加载到 shell 中。
其他一些重要的扩展
我们现在将在这里看到一些最常用的扩展
1.RandomCharField 扩展
您可以使用下面的命令在您的模型中添加该字段:
from django.db import models
from django_extensions.db.fields import RandomCharField
class ModelName(models.Model):
Field1 = RandomCharField(length=12, unique =True, include_punctuation=True)
2.验证器
在 models.py 中这个扩展的语法是:
from django_extensions.validators import HexValidator
class ModelName(models.Model):
Field1 = models.CharField(max_length=80, validators=[HexValidator(length=64)])
结论
就这样，伙计们！！这都是关于 Django 扩展的。我希望您已经获得了关于这些扩展的良好知识。请务必查看其他 Django 扩展的官方文档。
我们已经结束了 Django 系列教程。一定要看看我们关于 Django 的其他文章。继续编码！！
Django 表单验证
在本文中，我们将了解内置的 Django 表单验证以及 Django 自定义表单验证。
Django 表单验证的先决条件
在进行表单验证之前，您需要知道什么是 Django 表单，以及如何在 Django 中实现它们。
如果您已经熟悉 Django Forms，那么请继续阅读这篇文章，否则请首先阅读 Django Forms 文章。
内置表单验证
Django 框架提供了一系列内置的表单验证器和表单库。我们将在这里了解他们每一个人。
设置表单和使用内置验证器
Field = forms.Field_Type(validator = value)
所有内置的验证器都遵循上面的语法。
本节中使用的表单视图
以下解释代码基于 views.py 中的以下视图
def EFormView(request):
if request.method == 'POST':
form = EForm(request.POST)
if form.is_valid():
form.save()
return HttpResponse('Form saved')
else:
form = EForm()
context = {
'form':form,
}
return render(request, 'books_website/Form.html', context)
而模板是一个简单的 HTML 文件，包括 HTML 的表单属性
<form method ='post'>
{% csrf_token %}
{{form.as_p}}
<input type="submit" value = "Submit">
</form>
1。initial–带有“Initial”属性的占位符文本
你可能在网上看到过很多表格都有预先输入的文本，如下所示。
Example
这是使用 Django 表单的初始属性完成的。
因此，如果您需要在表单字段中预先输入文本，我们使用初始属性。
初始默认值是空。
class EForm(forms.Form):
Name = forms.CharField(initial = "Enter Name")
Initial
2。标签–向表单字段添加标签
标签属性给表单域一个自定义名称。默认情况下，Django 使用 forms.py 中指定的表单字段名称作为字段名称。但是使用标签我们可以将其更改为任何其他自定义名称。
class EForm(forms.Form):
Name = forms.CharField(label = "Full Name")
Label
3.max _ Length–限制输入字符的最大长度
max_length 属性确保字段中输入的信息不超过指定值。
class EForm(forms.Form):
username = forms.CharField(max_length = 10)
Max Length
请注意，您不能添加超过 10 个字符。
4.错误消息–添加自定义错误消息
error_message 属性允许您向字段中添加定制的错误消息。此属性重写默认错误信息，并使您能够编写自己的错误信息。
错误消息作为字典、传递，如下所示:
class EForm(forms.Form):
username = forms.CharField(error_message = {'required':'Please Enter your Name',})
Error Message
5。禁用–向 Django 表单添加不可编辑的值
在许多表单中，用户无法编辑特定的字段，例如特定公司表单上的公司名称。
disabled 属性允许您这样做。使用它，您可以禁用特定的字段，从而使用户无法编辑它。
class ITJobForm(forms.Form):
Interview domain = forms.CharField(disabled = True, initial = 'Software Engineer')
Name = forms.CharField(max_length = 80)
Disabled
请注意，您无法更改面试域字段的值。
6.help _ text–建议需要在输入中输入的内容
该属性在字段旁边添加了一个帮助文本,以提供关于必须输入的内容的更多信息。
class EForm(forms.Form):
Name = forms.CharField(help_text ='Please enter your name')
Help Text
7.必填–提交前确保表单域有数据
在许多表格中，某些字段是必填的，如申请人的姓名、号码等。这是通过必需的属性完成的。
默认值为假
class EForm(forms.Form):
Name = forms.CharField(required = True)
Required
8.widget–为预定义的目的设置单独的表单字段
Widget 是 Django 对 HTML 输入的表示。每个字段都有其预定义的字段小部件。例如，数字域将有一个只接受数字输入的小部件，电子邮件域只接受电子邮件输入，等等。
我们可以覆盖默认的小部件，并添加我们自己的小部件，如下所示:
class EForm(forms.Form):
Name = forms.CharField(widget = forms.Textarea)
Widget
使用 ValidationError 属性的自定义表单验证
正如在 Django 异常处理文章中看到的，验证错误属性用于验证用户输入的定制表单信息。
使用验证错误的语法
ValidationError('text',params = {value : <value>})
这里，值变量和文本取决于我们调用属性的位置，也取决于验证的条件。
ValidationError 的完整语法是:
import django.core.exceptions
if cond:
raise ValidationError('text')
自定义验证的实现
让我们创建一个只允许用户名在 10 到 20 个字符之间的表单。form.py 代码将是:
class EForm(forms.Form):
Name = forms.CharField(label = "Full Name")
添加窗体视图代码，如下所示:
from django.core.exceptions import ValidationError
def FormView(request):
if request.method == 'POST':
form = EForm(request.POST)
if form.is_valid():
Name = form.cleaned_data['Name']
if len(Name)< 10 or len(Name) > 20:
raise ValidationError(f'Length of the name:{Name} is not between 10 -20 characters')
return HttpResponse('Form saved')
else:
form = EForm()
context ={
'form':form
}
return render(request,'books_website/Form.html',context)
请注意验证错误是如何引发的。模板和上面看到的是一样的。
让我们运行服务器并输入少于 10 个字符的名称。你也可以尝试超过 10 个字符，因为它仍然无效我们的条件。
Validation Error
当您点击提交时，您将得到如下所示的错误:
Form Error
现在，我们将尝试使用 10 到 20 个字符的名称
Form 11 characters
点击提交并检查
Form Saved
看看表单是如何只接受某些名字的。这就是验证错误的工作方式。
结论
就这样，伙计们！！这都是关于表单验证的。另外，查看官方 Django 表单文档了解更多信息。继续练习！！
Django 表单介绍
Django 表单是从 web 前端接受文本、图像或文件形式的用户输入的一种方式。
我们遇到的表单的简单例子是 Django 管理站点的登录页面。管理网站从我们这里获取了输入文本“用户名”和输入文本“密码”。
在我们的网站上有两种使用表单的方式；
- 一个使用 <表单> 属性的 HTML 模板文件
- 使用 Django 表单模型类。
我们将学习 HTML 表单的基础知识来了解它们是什么。我们的主要焦点是 Django forms 本身。
为 Django 创建 HTML 表单
我们可以使用 <表单> 属性在 HTML 自身中创建表单，并使用 <输入> 属性从客户端获取信息。典型 HTML 表单的语法如下所示:
<form action="</action/>" method="post">
<label for="element_id">Your name: </label>
<input id="element_id" type="text" name="<name>" value="<pre-set_value>">
<input type="submit" value="OK">
</form>
让我们来理解一下上面的代码是什么意思:
- 动作:这告诉 HTML 将提交的表单数据发送到哪里。它通常包含我们要将数据发送到的 URL
- Method="POST" 这是我们在向服务器发送信息时使用的一种特殊方法。还有一个 GET 方法，这是我们在本文中需要的。
- 标签用于:该标签给出了一个名称来标识该特定标签。例如:
<label for='fname'>First Name:</label>这里我们给出一个简称 fname 来标识标签First Name <input id type name value>:这个 input 属性在 HTML 表单中是最重要的，input 指定了我们将从客户端获取的表单字段——例如，类型、名称、分配给它的预设值等等。<input type="submit">:该输入提交客户输入的表单。
我们可以使用 Django 表单，而不是使用 < input > 属性来创建表单字段，这是一种更有效的方法。但在此之前，我们需要了解更多关于获取和发布的方法。
何时使用 GET，何时使用 POST
默认情况下，浏览器使用 GET 方法向服务器请求资源。
例如，继续我们的图书模型示例，我们在后端自动使用 GET 请求来提取图书的数据。因为我们没有在前端修改列表，所以这个方法非常好。
但是假设我们想在模型数据库中添加一本书。然后我们基本上改变了 DB 元素，因此我们需要 POST 方法。因此，POST 方法向服务器发送一些信息。
当我们改变关于一本书的信息或者在 Django 管理站点中添加一本书时，我们使用了 POST 方法。
当我们在管理站点中查看 BookModel 下的图书列表时，我们使用了 GET 方法。
除此之外，还有其他 HTTP 方法，它们将在 REST API 框架文章中学习。
利用 Django 表单
Django 表单的工作方式类似于 Django 模型的工作方式。我们创建一个表单类，并将它们保存在一个单独的 forms.py 文件中。
模型和表单之间唯一的区别是，在模型中，我们将模型字段映射到数据库字段，而在表单中，我们将表单字段映射到 HTML 表单 <输入> 元素。
关于表单的另一个有趣的事实是，我们在网站上显示空白表单，并从客户端获取信息来存储它，而对于模型，我们将数据库中存储的数据显示给客户端。
在 Django 应用程序中创建 forms.py python 文件。
在 Django 应用中，创建一个新的 python 文件，命名为 forms.py
Forms.py
创建搜索表单以从 Book_website 搜索图书
我们现在将创建一个简单的表单，将书名作为输入，然后将我们重定向到该书的网站。因此，让我们开始吧。
1.在 forms.py 中创建搜索表单
首先我们需要导入表单库。
from django.forms import forms
然后，包含以下代码来创建一个带有 book_title 字段的 SearchForm。
class SearchForm(forms.Form):
book_title = forms.CharField(label = "book_title",max_length =80)
语法类似于包含 max_length 的模型。
这里的标签与我们在 HTML 表单中学到的标签功能相同。
2.在 views.py 中创建 SearchBookView 视图
在 views.py 中，创建一个名为 SearchBookView 的函数视图。
现在有两种可能的方法:
- 客户端使用 GET 方法到达网页。
- 当客户第一次打开网页，或者想要搜索另一本书时，就会发生这种情况。
- 客户端使用 POST 方法到达网页。
- 当客户端输入图书名称，然后按下提交/搜索按钮时，就会出现这种情况。
因此，视图必须处理这两种情况。
1。GET 方法的代码
当客户端使用 GET 方法时，他必须获得一个空白表单来输入图书名称。
因此，在这种情况下，我们的代码将只包含代码。
form = SearchForm()
就像模型一样，我们创建一个新的表单对象，并将它传递给 HTML 文件。
2.过账方式的代码
当客户端使用 POST 方法时，他将被重定向到我们在之前的文章(books/
因此，执行此任务的代码将是:
if request.method == 'POST':
form = SearchForm(request.POST)
if form.is_valid():
book_title = form.cleaned_data['book_title']
try:
book = BookModel.objects.get(title = book_title)
except book_title.DoesNotExist():
raise Http404('This book does not exist')
return HttpResponseRedirect(f'/books/{book_title}', {'book':book})
这里
- form = SearchForm(请求。POST) 保存客户输入到创建的表单对象表单中的信息。
- form.is_valid() 检查字段中输入的信息是否有效。即，例如，我们是否仅在电子邮件字段中输入了电子邮件。
- form . cleaned_data[' book _ title ']:表单库的这个属性自动将客户输入的信息转换成正确的 python 可接受的格式，并由此命名为 cleaned _ data
- try and except block: 这在 python 中被称为异常处理，你可能在 Python 异常处理中学过
- 如果客户输入的书名存在于数据库中，那么我们将使用
book = BookModel.objects.get(title = book_title)
- 否则，如果书不存在，那么我们抛出一个 Http404 错误，该错误存在于 Django.shortcuts 库中
- 一旦我们从数据库中保存了关于这本书的信息，我们就使用
HttpResponseRedirect("<url>",<context>)
这个属性将客户端重定向到提到的 URL ，以及上下文字典。
现在我们已经研究了 search book 视图的两个部分，让我们把它们结合起来，得到完整的最终结果search book 视图
from django.shortcuts import render,HttpResponse,HttpResponseRedirect,Http404
from .models import BookModel
from .forms import SearchForm
def SearchBookView(request):
if request.method == 'POST':
form = SearchForm(request.POST)
if form.is_valid():
book_title = form.cleaned_data['book_title']
try:
book = BookModel.objects.get(title = book_title)
except book_title.DoesNotExist():
raise Http404('This book does not exist')
return HttpResponseRedirect(f'/books/{book_title}', {'book':book})
else:
form = SearchForm()
context ={
'form':form,
}
return render(request, 'books_website/SearchBook.html', context)
因此，如果请求是 POST，我们会将用户重定向到/books/
SearchBookView
别忘了从 django.shortcuts 和 forms.py 导入 HttpResponseRedirect、Http404 和 searchForm
3.在模板文件夹中创建 SearchBook.html 模板文件
因为我们已经创建了一个 Django 表单，所以我们不必再为 book_title 创建输入字段。
我们只需要在表单中添加提交按钮，就可以了。
所以让我们创建 HTML 文件。
<form method ='post'>
{% csrf_token %}
{{form}}
<input type="submit" value = "Submit">
</form>
{% csrf_token %} 即跨站点请求伪造令牌防止 csrf 攻击，因此用于表单的安全目的。
SearchBook HTML
4.在 urls.py 中为 SearchBookView 创建 URL 端点
现在，我们将为我们创建的 SearchBookView 创建一个新的 URL 路径( book/search )。
我们已经在 Django URL 映射中学习了如何将视图映射到 URL，所以让我们在这里再做一次。
path('book/search', SearchBookView, name='SearchBookView'),
URL
就这样，现在让我们运行服务器
python manage.py runserver
Browser
搜索捉鬼敢死队，点击提交
Ghostbuster
现在，如果你看到的话，大多数网页在图书网页上有搜索按钮 (books/) 本身。为此，我们需要将 SearchBookView 和 BookView 结合起来。
所以只需从 SearchBookView 中剪切代码，粘贴到 BookView 中即可。然后图书视图看起来会像这样:
def BookView(request):
books = BookModel.objects.all()
if request.method == 'POST':
form = SearchForm(request.POST)
if form.is_valid():
book_title = form.cleaned_data['book_title']
try:
book = BookModel.objects.get(title = book_title)
except book_title.DoesNotExist():
raise Http404('This book does not exist')
return HttpResponseRedirect(f'/books/{book_title}', {'book':book})
else:
form = SearchForm()
context ={
'books':books,
'form':form,
}
return render(request,'books_website/BookView.html', context)
试着理解上面的代码，看看我是如何修改 searchBookView 来包含它的。
现在在这里，因为我们在下面的网页中有搜索表单，我们将在我们的 BookView.html 中包含 SearchBook.html。
现在，由于 SearchBook.html 是 BookView.html 的一部分，我们可以只渲染BookView.html模板本身(在底部)并删除该行
render(request, 'books_website/SearchBook.html',context)
BookView
就是这样；现在我们甚至不需要刚刚创建的端点。所以删除 URL 路径(book/search)。
加载服务器并打开浏览器
Books
Book Ghostbuster
点击提交并检查
Ghostbuster
使用模型表单创建表单
如果我们想将表单数据保存到 DB 表中，那么我们需要为此创建一个 Django 模型。
Django 提供了一种方法，将客户端通过表单输入的信息链接到为保存数据而创建的模型。
使用 ModelForm，我们可以高效地执行上述任务，而无需编写太多代码。让我们开始吧
创建书评表单
我们将在图书(books/
1.在 models.py 中创建 BookReviewModel
在 models.py 中，创建一个新的模型 BookReviewModel ，并编写所需的模型字段，如下面的代码所示。
class BookReviewModel(models.Model):
name = models.CharField(max_length = 80)
review = models.TextField()
class Meta:
ordering = ['name']
def __str__(self):
return f"comment by {self.name}"
这里，我们使用 Textfield，因为评论可能会很长。这个模型很容易理解，因为我们在 Django Models 文章中学到了这一点
2.在 forms.py 中创建模型表单
现在，在 forms.py 中，创建一个如下所示的表单。
class ReviewForm(forms.ModelForm):
class Meta:
model = BookReviewModel
fields =('name','review',)
这里:
- 从导入 BookReviewModel。型号
from .models import BookReviewModel
- 然后我们使用元类(我们在 Django 模型中学到的)来包含我们的 Django 模型，并在表单中提到我们想要的字段
ReviewForm
3.在 views.py 中创建 BookReviewView
我们将编写一个函数视图，类似于我们在制作搜索表单时编写的视图。
在 Views.py 中，创建一个新的函数视图 BookReviewView 并添加以下代码。
def BookReviewView(request):
if request.method == 'POST':
form = ReviewForm(request.POST)
if form.is_valid():
form.save()
return HttpResponse('Your review has been taken')
else:
form = ReviewForm()
context = {
'form':form,
}
return render(request, 'books_website/ReviewBook.html', context)
这里:
- 如果表单有效，，那么我们只需使用保存属性将客户端输入的信息存储到数据库中。
看看将表单条目保存到数据库中是多么简单。我们现在将创建ReviewBook.html模板文件。
BookReviewView
4.正在创建 ReviewBook.html 模板文件。
在 templates/books_website 中，创建一个名为【ReviewBook.html 的新文件
正如我们上面所做的，我们将创建一个表单属性。
<form method='post'>
{% csrf_token %}
{{form}}
<input type="submit" value = "submit">
</form>
就这样，我们的 HTML 文件准备好了
5.创建 BookReviewView 的 URL 路径
现在我们只需要创建一个新的路径到 BookReviewView。
转到 urls.py 并添加
path('book/review', BookReviewView, name='BookReviewView'),
另外，不要忘记在 admins.py 中注册书评模型
admin.site.register(BookReviewModel)
就这样伙计们！！让我们运行服务器并进入(预订/评论)网页。
Browser
Browser
然后按提交按钮，你会看到感谢你的回复网页。
Browser 6
现在，如果您转到管理站点，并在 BookReviewModel 中检查，您将看到表单条目已保存。
Admin Site
结论
Django 表单教程到此结束！我们希望您已经掌握了 Django 表单的所有基础知识，以及它们是如何与 HTML 表单链接的。此外，您可以从官方文档中了解更多关于 Django 表单的信息。
请继续关注 Django 主题的更多高级教程！
Django Hello World 应用程序–Django 入门
本教程将带你开始学习 Django 的基础知识。让我们了解一下如何在 Django 上创建一个 hello world 应用程序。
什么是 Django？Django 是一个基于 python 的 web 框架，用于高效地制作 web 应用程序。
注意: Django 只是一个用于 web 应用的框架和而不是一种语言。
1.安装 Django
我们可以使用 PIP 在我们的系统中安装 Django。我们已经列出了在不同操作系统上安装 Django 的步骤。
Windows 上的 Django
首先，我们必须在你的电脑上保存 get-pip.py 。
第二个，在保存文件的地方打开 cmd，然后写命令
python get-pip.py
第三，现在如果你想升级版本你可以写
python -m pip install -U pip
Mac OS 上的 Django
首先，使用简易安装安装 pip
$ sudo easy_install pip
第二个，我们现在可以使用下面的命令升级它
$ sudo pip install --upgrade pip
Linux 上的 Django
我们可以使用终端外壳中的命令进行安装
$ sudo apt-get update
$ sudo apt-get install python-pip
$ sudo pip install --upgrade pip
一旦 Django 安装完毕，我们就可以进入下一部分了。
2.开始你的第一个 Django 项目
现在，在您的计算机中，导航到要启动项目的文件夹，打开命令提示符/shell 并键入以下命令。
$ django-admin startproject <Name_of_project>
其中 <项目名称> 是您要为项目命名的名称。
Django Startproject
现在，如果您查看目标位置，您将能够看到一个以项目名称命名的新文件夹。在该文件夹中，您将找到另一个同名的文件夹和 manage.py 文件。
注意:manage.py python 文件管理整个项目，并为 Web 应用程序将项目的不同部分组合在一起。
一个典型的项目会有这样的结构。
Django Project Structure
现在，一旦项目设置完毕，我们就可以尝试运行服务器了。
3.在本地主机上运行服务器
现在，项目在您的计算机上，但实际上，web 应用程序的整个项目将被上传到 web 服务器。
现在，由于项目在你的计算机上，服务器将在你的本地主机上运行。
现在在终端 shell/cmd 中编写以下命令来运行服务器。
$ python manage.py runserver
Runserver
服务器将开始运行，你可以去那个网址查看 web app。(我的情况是 http://127.0.0.1:8000)
Website Runserver
因此，我们的 web 应用程序运行良好，让我们继续制作一个应用程序。
3.Django 项目和 Django 应用程序的区别。
在制作我们的第一个 Hello World 应用程序之前，我们需要知道 Django 项目和 T2 Django 应用程序的区别。
Django 项目
Django 项目用于整个 Web 应用程序。也就是说，将有一个项目来处理一个完整的网站。
在项目内部，可能有许多不同的 Django 应用程序处理各种流程。
Django App
在一个项目中，一个应用程序用于处理网站的特定部分。在一个典型的 web 应用中，一个 app 完全用于用户认证，一个完全用于支付等。
Django Project and App (HelloWorldApp)
4.运行你的 Hello World 应用
在项目文件夹中，打开 shell 并编写命令来设置 Hello World 应用程序。
$ django-admin startapp HelloWorldApp
现在你会看到你的 Hello world 应用程序已经形成。
Django Startapp
Django App 内部有不同的 python 文件，我们将在下一篇文章中学习。
注意:Django 项目本身不会知道这个应用程序，因此你必须在 django_project/settings.py 中提及它。
您可以在 INSTALLED_APPS 中添加您的应用，以便更好地管理应用。在 INSTALLED_APPS >下添加 "<name_of_app>", 其中 < name_of_app > 是我们想要给我们的应用起的名字。
Installed Apps
5.修改 Django 应用程序文件以显示“Hello World”
在 Django 中，显示一个特定的网页需要 3-4 个文件。顺序如下所示
URL 视图-模型(通常)-模板
因此，当一个客户机访问一个特定的 URL 时，这意味着他向服务器发送一个 web 请求(例如 HTTP 请求), Views.py 有一个对应于该特定 URL 请求的视图，然后数据作为响应(HTTP 响应)连同模板(HTML 文件)一起发送回客户机。
现在让我们在 views.py 中编写一个简单的视图，在浏览器中显示 Hello World。
SayHello views.py
在这里，我们首先从 django.http 库导入 HttpResponse ，然后创建一个名为 sayHello 的视图。
它需要来自用户的请求，因此它将请求作为输入，然后返回http response–Hello World。
from django.http import HttpResponse
def sayHello(request):
return HttpResponse('Hello World')
现在我们还需要在应用程序中创建 urls.py 。所以我们可以从项目 urls.py 中复制过去，然后删除管理路径行，然后添加下面的行。
from django.contrib import admin
from django.urls import path, include
from .views import sayHello
urlpatterns = [
path('', sayHello, name='sayHello'),
]
UrlsHelloWorldApp
现在我们只需要在【urls.py/django_project】中添加端点 sayHello/ 。我们将把下面的代码添加到 urlpatterns 中。
path('sayHello/', include('HelloWorldApp.urls')),
Urls Pydjango Project
6.运行服务器
正如上面第 4 部分所示，我们将运行服务器。
Runserver HelloWorld
现在服务器已经打开，因此我们可以通过将端点 sayHello/ 添加到 URL 来检查浏览器。
Browser HelloWorld
我们可以看到它正在完美地工作。因此我们的第一款 Django 应用已经准备就绪。
结论
这就是我们的结局。我希望你已经准备好开始你和姜戈的旅程了。所以请在接下来的几天里关注更多关于 Python Django 和 Flask 的文章！
django ListView——如何创建基于函数和类的 ListView？
在本文中，我们将了解 Django 列表视图。
什么是 Django 列表视图？
Django ListView 指的是那种类型的视图，它显示了出现在模型表中的实例/元素。它用于显示数据库中的多个条目，还允许我们添加新数据。
因此，您可以推断 ListView 基于具有 GET 和 POST 选项的 API 接口。
这类似于我们在 Django REST API 系列中创建的 ItemsView。
编码列表视图的先决条件
考虑一个 Django 项目有一个应用程序 Itemsapp。在这里，我们将保存关于椅子、书、桌子等物品的模型信息。
模型的代码:
class ItemModel(models.Model):
id = models.IntegerField(primary_key = True)
name = models.CharField(max_length = 80, blank = False)
price = models.IntegerField
class Meta:
ordering = ['name']
def __str__(self):
return f"{self.name}:{self.price}"
然后，我们将使用终端在预设的数据库 SQLite 中创建表:
python manage.py migrate
python manage.py makemigrations
python manage.py migrate
之后，我们将有 serializers.py 文件，其中包含一个 ItemSerializer 类，用于将 DB 实例转换为 JSON。
项目序列化程序的代码:
from rest_framework import serializers
from .models import ItemModel
class ItemSerializer(serializers.ModelSerializer):
class Meta:
model = ItemModel
fields = ['id',name','price']
之后，只需通过 Python shell 或管理站点本身向表中添加一些项目。
Admin
此外，端点将仅仅是 /items ，因为列表视图关注于显示模型表的整个实例
URL 映射的代码:
- 对于基于函数的列表视图
path ('items/', ItemsView)
- 对于基于类的列表视图
path('items/',ItemView.as_view())
就这样，现在我们将学习用不同的方法创建一个 ListView。
Django ListView 背后的逻辑
在 ListView API 中，逻辑非常简单。
1.从服务器到用户的数据显示
所涉及的步骤将是:
- 从数据库获取数据
- 使用序列化器将数据转换成 JSON
- 按照原样或者通过模板(使用 JS)将 JSON 数据返回给用户
2.从用户处获取数据到服务器
这里涉及的步骤将是:
- 将 JSON 数据与请求的其余部分分开(使用 JSON 解析器)
- 转换成 Django 可读格式(python 方法)
- 对该数据执行专门的任务(添加、编辑、删除)。
在这种情况下，专用任务可以只是显示或添加来自用户的数据到 DB 中。
创建 Django 列表视图
现在让我们创建一个 Django Listview。
1。基于函数的列表视图
基于函数的 ListView 的示例代码如下:
@csrf_exempt
def ItemsView(request):
if request.method == 'GET':
items = ItemsModel.objects.all()
serializer = ItemSerializer(items, many =True)
return JsonResponse(serializer.data, safe =False)
elif request.method == 'POST':
data = JSONParser().parse(request)
serializer =ItemSerializer(data = data)
if serializer.is_valid():
serializer.save()
return JsonResponse(serializer.data,status =201)
return JsonResponse(serializer.errors,status = 400)
请记住上一节中给出的我们用 ListView API 执行的步骤，并尝试理解代码。
- def get: 来自数据库的数据→转换为 JSON(序列化程序)→显示 JSON 数据
- def post: 解析请求以分离 JSON 数据→转换为 Python 格式→对数据执行适当的任务
这就是我们在 ItemsView 的代码中所做的。
2.基于类的列表视图
基于类的视图比函数视图更好，因为使用类代码变得更加系统化、结构化和可读。
基于类的 ListView 的示例代码如下:
class ItemsView(APIView):
def get(self,request,format =None):
items = ItemsModel.objects.all()
serializer = ItemSerializer(items, many =True)
return JsonResponse(serializer.data, safe =False)
def post(self,request,format =None):
data = JSONParser().parse(request)
serializer =ItemSerializer(data = data)
if serializer.is_valid():
serializer.save()
return JsonResponse(serializer.data,status = status.HTTP_201_CREATED)
return JsonResponse(serializer.errors,status = status.HTTP_400_BAD_REQUEST)
同样，我们编写代码的方式也发生了变化。我们使用类方法和类内函数来编写代码。但逻辑的关键仍然是一样的。
ListView API 的实现
代码已经完成，我们现在运行它。
您可以尝试运行基于函数的视图和基于类的视图，以便更好地理解基于函数和基于类的列表视图
现在为了运行，我们将使用 POSTMAN，这是运行Django REST API的有效方法。这里是邮差的官方网站，在这里你可以看到它的好处
GET ListView
上面的图片显示了 ListView 的 GET 选项，其中显示了 ItemModel 的所有实例。
POST ListView
这张图片显示了 ListView 的 POST 选项，它允许用户向 ItemModel 中添加新的项目实例。
结论
就这样，伙计们！！Django 中的 ListView 就是这么做的。获取模型的实例并显示它们，同时从用户那里获取新的实例。
在下一篇文章中，我们将学习 Django 细节视图。
更多此类有趣话题敬请期待！！注意安全！！
Django 日志——快速设置指南
在这篇文章中，我们将学习所有关于 Django 日志记录的内容！！
为什么日志记录很重要？
作为一名程序员，我们写了很多代码，因此最终也会有很多错误。现在回溯并找到错误的确切位置是非常耗时的。
这就是测井模块发挥作用的地方。日志记录为开发人员提供了一个新的视角来快速找到并调试错误。
Django 的日志是什么？
日志记录是一种技术，它使您能够跟踪代码/系统实时运行时发生的事件。
日志作为一个独立的程序工作。你可以把它想象成一个简单的文件写入器。当系统运行时，它跟踪事件并将其记录到控制台或称为日志的文件中。
日志是带有日志扩展名的简单文件，包含文本格式的所有记录。此外，日志记录还有更多附加功能，如:
- 使多线程执行成为可能
- 通过不同的日志级别对消息进行分类的选项
- 更加灵活和可配置。
- 拥有更加结构化的信息
4 Django 伐木的一部分
执行 Django 日志记录有 4 个部分。让我们来看看它们是什么。
1.决哥伐木工
这是登录系统的一个条目。记录器是一个部件，当调用日志记录时，它记录事件以供处理。此外，记录器被配置为具有日志级别。
日志级别说明了记录器将接受或处理的事件的严重性。
| 日志级别 | 描述 | 严重 |
|---|---|---|
| 调试 | 一切正常时的系统信息。 | Ten |
| 信息 | 类似于 debug。它通常概述了系统正在执行的内容。 | Twenty |
| 警告 | 涉及不会导致系统停止的低级问题。 | Thirty |
| 错误 | 这条信息是严肃的。这表明问题可能已经停止了系统的运行，需要立即引起注意 | Forty |
| 危急 | 最关键的信息。当问题导致系统停止时，会显示此信息。 | Fifty |
写入记录器的每条消息称为一条日志记录。只有那些日志级别高于日志记录器的消息才被接收进行处理，其余的都被忽略。
2.姜戈在买卖
这是 Django 日志系统的下一个级别。这有关于记录器中的日志记录发生了什么的进一步信息。也就是说，它有关于位置(控制台或文件等)的信息，日志记录将被写入，应用于日志记录的过滤器和格式化程序的类型。
像记录器一样，处理程序也有日志级别。如果日志记录的日志级别不等于或高于处理程序的日志级别，则它将被忽略。
3。姜戈过滤器
顾名思义，它提供了对日志记录的进一步过滤，从日志记录器传递到处理程序。例如，通常会处理符合日志级别要求的日志消息。但是您可以安装一个过滤器，只允许来自特定来源的错误消息被发出/写入。
4。Django 格式器
最终，日志记录必须以文本形式存储。日志记录通常采用日志框架预定义的日志记录格式。但是要将它存储为文件，我们需要首先将其转换为正确的格式。
因此格式化程序被用来转换它们。默认情况下，格式化程序将其转换为字符串。但是也可以根据我们的需要进行改变和定制。
流程很简单。
Logging Flow
将 Django 日志目录添加到 settings.py
所有关于记录器、处理程序、过滤器和格式化程序的信息都必须写入 settings.py 本身。
基本语法是:
LOGGING = {
'version': 1,
# Version of logging
'disable_existing_loggers': False,
'filters':{
#information regarding filters
},
'formatters':{
'<formatter_name>':{
'format': '<formatter_info>',
'style': '{',
}
},
'handlers': {
'file': {
'level': '<log_level>',
'class': '<logging_class>',
'filename': '<file_name>',
},
'console': {
'class': '<logging_class>',
},
},
'loggers': {
'django': {
'handlers': ['file', 'console'],
'level': '<log_level>',
},
},
这里:
- 版本:这是我们正在使用的日志版本。
- disable _ existing _ loggers:默认情况下，Django 禁用记录器。所以我们需要让他们回来。
- 过滤器:提到了我们将在日志中使用的过滤器。
- 格式器:所有关于日志记录格式的信息都在这里。
- 处理程序:日志记录上所有要进行的过程都写在这里。例如存储位置、要使用的格式化程序、要添加的过滤器等。
- Loggers: 这个有处理者的信息；日志记录将被传递到日志级别等。
因此，让我们在应用程序中添加一个简单的日志目录，它将把日志级别大于或等于 DEBUG 的所有记录保存到日志文件夹中的一个日志文件中。
在 Django 项目的文件夹中创建一个日志文件夹
logs
在 settings.py 中添加代码:
LOGGING
只要记住我们在上一节学到的逻辑，努力理解代码就行了！
调用 views.py 中的 Django 日志函数
现在，我们已经在 settings.py 中指定了日志记录，我们必须在 views.py 导入日志记录中的 views.py 文件中的任意位置添加函数调用，然后在开头编写代码
import logging
logger = logging.getLogger(__name__)
name 获取调用该函数的文件的名称。您可以使用它来识别当前文件，并从那里添加日志记录方法。
为了演示，我在 views.py 文件中随机添加了 logging.info 函数调用
Views 1
类似地，在项目视图中:
Views 2
运行 Django 日志记录
就这样，伙计们！！我们现在可以运行程序，让日志记录处理所有的日志记录。
python manage.py runserver
此后， log_file1.log 将被自动创建并开始存储日志记录。
Log File
正如我们在格式化程序中提到的，日志首先存储有级别名称，然后是消息。
结论
就这样，伙计们！！这都是关于 Django 日志记录的。请务必查看 Python 日志，了解更多关于日志的信息。另外，你可以从官方文档中了解更多关于 Django 伐木的信息。注意安全！！继续学习！！
Django 模型表单——在 Django 中实现模型表单
在本文中，我们学习了 Django 模型表单，以及如何将它们与模型的概念联系起来。
Django 模型表单的先决条件
在深入研究模型表单之前，我们应该熟悉 Django 表单及其用法。因此，如果您是新手，请在继续之前查看我们的 Django forms 文章。
如果您已经熟悉 Django 表单，那么让我们开始吧！！
为什么要模型表单？
只有当我们保存用户提交的表单条目时，表单才有意义。现在要存储它们，我们需要一些数据库。这就是模型表单发挥作用的地方。
Django 模型表单提供了一种方法，将客户端通过表单提交的数据链接到为存储条目而创建的数据模型。
使用 ModelForm，我们可以高效地执行上述任务，而无需编写太多代码。
Django 模型表单实践
在本节中，我们将学习编写创建模型表单所需的所有部分的代码。
1.在 models.py 中编码模型
在 models.py 中，创建一个模型 FormModel 并向其中添加以下字段。
class FormModel(models.Model):
name = models.CharField(max_length = 80)
age = models.IntegerField()
address = models.TextField()
class Meta:
ordering = ['name']
def __str__(self):
return f"Form by {self.name}"
这里，我们使用 Textfield，因为地址可以足够长。为了更好地理解模型，请查看 Django Models 的文章。
添加模型表单后，运行如下所示的迁移来创建 DB 表
python manage.py migrate
python manage.py makemigrations
2.在 forms.py 中编写模型表单
现在，在 forms.py 中创建一个表单，如下所示:
从导入表单模型。型号
from .models import FormModel
然后在表单中添加的代码。
class Form(forms.ModelForm):
class Meta:
model = FormModel
fields =('name','age','address',)
- 类元将上面的表单链接到我们为存储表单数据而创建的模型。
- 提及将在表单中向用户显示的模型字段。
3.在 views.py 中编写 FormView 代码
在 Views.py 中，为 FormView 添加以下代码。
def FormView(request):
if request.method == 'POST':
form = Form(request.POST)
if form.is_valid():
form.save()
return HttpResponse('Your review has been taken')
else:
form = Form()
context = {
'form':form,
}
return render(request, 'app_name/form.html<path to template>', context)
如果表单有效， form.save() 直接将表单保存到 DB 本身。
有了模型，姜戈会处理好一切。所有表单条目将自动保存到链接的表单模型数据库。
4.对表单模板文件编码。
现在剩下的唯一一件事就是创建一个表单模板来向用户显示表单。
在命名空间 模板文件夹中，创建一个 form.py 模板文件。
<form method='post'>
{% csrf_token %}
{{form.as_p}}
<input type="submit" value = "submit">
</form>
就这样，我们的 HTML 文件做好了！现在，我们只需要在 urls.py 中创建一个到表单视图的新路径
path('form/model', FormView, name='FormView'),
就这样伙计们！！编码部分已经完成，现在让我们启动服务器。
模型表单的实现
从终端/cmd 启动服务器。
Form
填写字段并点击提交。
Form Submission
现在让我们检查表单是否已保存。转到管理网站。
Form Model
哇！！就这样，词条保存了。看看实现 Django 模型表单有多简单。
结论
就这样，编码员们！这都是关于 Django 模型表单以及如何用 Django 模型实现它们。
为了更好地理解表单，请查看 Django 表单教程。下一篇文章再见！继续练习！
Django 模型——完全的初学者指南
Django 模型是表示数据库中的一个表或集合的类。它包含关于表的所有信息。这些模型一起存储在 Django 的一个文件 models.py 中，该文件位于我们的 Django 应用程序中。
不同的数据库可能有许多不同的模型，包含不同的信息，如用户数据库、图书数据库或 web 应用程序所需的任何其他表。
Django 模型的基本结构
class Modelname(models.Model):
'''A class representing a model derived from Model class'''
#Fields
Field_name = models.CharField(max_length = , hepl_text = , choices = , Null etc)
#Metadata
class Meta:
Ordering = [‘field_name’]
#Methods
def __str__(self):
return '<readable_name>'
1.模型中的字段
一个特定的模型可以有任意数量的字段，这些字段代表数据库表的各种属性。
可以有许多不同类型的字段
- 卡菲尔德
- 积分值
- 电子邮件
这些字段还可以接受如下参数
- max _ length–可能的最大字符数。
- 主键–这告诉 Django 这个字段对于所有条目都是唯一的。
- 外键–用于连接一个模型和另一个模型。
- NULL-如果为真，将空字段转换为空值， char 字段将它们作为空字符串
- 选择–如果字段必须是给定选项中的一个(如选项框)
- 空白–如果为真，该字段可以允许为空，否则必须填写。
2.模型元数据
该元数据具有各种特征；其中最重要的是排序。当您发出请求时，它允许您在数据库中以特定的顺序显示响应。
语法如下
ordering ['<Name>']
这告诉模型按照 <名称> 的顺序排列 DB 中的元素，即如果 <名称> 是 CharField 则可以是字母顺序，或者如果其是跨域则可以是数字升序顺序等等。
如果语法与 "-" 符号一起使用，这意味着排序应该是相反的顺序
ordering [-'<name>']
3.Django 模型中的方法
这些用于更好的客户端界面，也就是更好的呈现等。
例如， str 告诉您在管理站点中为数据库中的每个特定元素显示什么(像一个简称)。(而不是显示全部信息)
现在让我们制作一个图书项目，包含以下信息:
- 一个包含所有书籍信息的主页
- 包含每本书信息的网页。(我们在 Django URL 映射 ) 中看到
为此，使用前几篇文章中获得的知识制作一个名为 books 的应用程序。
1.创建我们的第一个 Django 模型
在 books/models.py 中，让我们创建一个模型 DB，将标题、价格和流派作为属性，并对标题进行元数据排序。
BookModel
现在，我们需要在数据库中创建这个表。默认情况下，Django 使用 SQLite 数据库引擎。现在，我们将使用这个数据库本身。
你可以从数据库下的 settings.py 文件中查看你正在使用的数据库
Settings.py
2.在数据库中创建表
为了首先创建表，我们需要应用迁移。在 shell 中编写下面的代码
python manage.py migrate
python manage.py makemigrations <app_name>
Python manage.py sqlmigrate <app_name> 0001
再次运行:
Python manage.py migrate
输出将表明数据库创建成功。
您的模型表已经在 SQLite 中准备好了。注意每当我们对模型进行更改时，我们需要重复上述的步骤，以便对数据库中的表格进行更改。
现在，我们将学习获取/添加数据到数据库
从数据库中检索信息
现在，首先我们需要在目录中打开 python shell，使用命令:
python manage.py shell
因此，现在我们将让 python 控制台出现在 shell 中。我们需要导入模型表，以便从中添加/检索信息。
导入表的语法是:
from <app_name>.models import <model_name>
我的情况是这样的
Python Shell
1.从一个表中获取所有对象
为此，我们使用以下语法
<model_name>.objects.all()
因此，我的代码将是:
BookModel.objects.all()
2.将信息添加到表格中
为了添加信息，语法类似于面向对象的 python 语法。这里，我们首先创建一个具有模型名称的类对象，然后添加所需的属性。
创建一个对象，语法是:
A = <model_name>()
举例:
A.Title = "Harry Potter"
A.Price = 120
A.Genre = "Fantasy Fiction"
A.save()
这样我们就输入了第一本书的信息。同样的，我再补充几个。
Addition To DB
3.从数据库中过滤记录
为了过滤 Django 模型数据库中的记录，我们运行:
<Model_name>.objects.filter(Title =”<Title_Element>”)
因此，举例来说，如果我过滤掉所有类型的书籍，比如小说，那么
Filter
4.获取元素的完整信息
注意:当我们使用过滤器时，我们以简短的形式获得元素(以一种由 def str 描述的方式)，但是如果我们想要关于一个元素的完整信息，我们使用这个方法
<model_name>.objects.get(Title = <"title_element">)
在这里我们可以得到包括标题在内的所有信息。价格，流派。
这就是我们使用 T1 的时候
a = BookModel.objects.get(title = "Ghostbuster")
然后所有的信息都被存储为一个对象，所以如果我们实现了下面的代码，它就会打印出相应的值。
a.title()
a.price()
a.genre()
5.从数据库中删除行元素
为了删除一个特定的元素，我们使用语法。删除()
from books.models import BookModel
a =BookModel.objects.get(title="<book_name">)
a.delete()
通过 views.py 连接到模型数据库
现在我们将学习如何从数据库获取信息，然后在我们的网页上显示它。
在 Views.py 中添加代码:
def BookView(request):
books = BookModel.objects.all()
html = ''
for book in books:
var = f'<li> {book.title} </li><br>'
html = html + var
return HttpResponse(html,status = 200)
现在从代码中，你可以理解我们基本上把所有的数据库信息检索到变量 books 中，然后我们开始一个循环，从数据库中获取每个元素，并在网页上显示为 HTML。
我们还必须为这个视图提供端点( Books/ )。根据从 Django-URL 映射文章中获得的知识，自己尝试一下
URL mapping
现在为网页(书籍/ <标题 _ 名称> ) 。看看下面的代码可以更好的理解。
BookIDView
代码很简单；我们只是使用 Get 获取关于 book_name 的所有信息，然后在网页上显示为 HTML
这里，我们从数据库中检索了特定的信息，然后将其显示在 Web 页面上。让我们看看这个视图中的 urls.py 文件是什么样子的。
URL mapping – BookIDView
现在我们将运行服务器，看看它是否工作
Runserver
书籍/ 网页的浏览器页面
Browser (books/)
书籍/ <书名 _ 名称> 网页的浏览器页面
Browser (books/Ghostbuster)
Browser (books/Harry Potter)
使用外键连接到其他型号
一个外键 (FK)用于链接两个使用一些公共信息的数据库。这有助于保持我们的数据库整洁，也确保我们不必一次又一次地输入相同的信息。
现在，在我们的图书应用程序中，让我们制作一个作者模型表，并在图书模型中添加 Author_id 字段。现在注意几本书可能有相同的作者，所以 Author_id 将作为我们的 BookModel 中的外键。
使用 FK，我们可以搜索特定作者写的各种书籍。此外，如果作者删除了他的帐户，那么他的所有书籍也将被自动删除，从而减少了从 BookModel 中手动删除它们的工作。
开始时你可能会有点困惑，但经过反复练习，它会开始变得有意义。所以不用担心！！
AuthorModel
现在我们可以在 BookModel 中添加 Author 字段。
Author_id Field
我们必须为新的 AuthorModel 运行迁移。还要注意:由于我们改变了我们的 BookModel DB，我们必须运行前面提到的外壳代码(迁移)。
Migrations
我们在数据库中已经有了一些没有作者字段的信息。所以 Django 要求在 author_id 字段中为他们输入一个默认值。
最好在使用应用迁移(改变表格)之前删除所有早期的元素。删除()
我们现在可以像添加图书信息一样向 Author DB 添加信息。
Author DB
同样作为练习，试着自己创建一个类似于图书视图的作者视图。
我们现在已经学会了通过 shell 向表中输入数据，但这并不是添加数据的最有效方式。最简单的方法是通过管理站点添加数据。我们将在下一篇文章中学习如何做到这一点。
同样从管理网站，你会得到更多关于这整个 FK 的工作信息，以及作者数据库和模型数据库如何通过 FK 相互链接。
结论
就这样，我们已经到了文章的结尾。在下一篇文章中，我们将学习管理站点接口，然后以一种更好的方式看到 FK 的效用。继续编码！！
姜戈·MVT 建筑公司
在本文中，我们将讨论 Django MVT 架构，以及它与长期存在的 MVC 架构有何不同。所以让我们进入正题，了解姜戈 MVT 建筑。
但在此之前，我们将简要回顾一下 MVC 架构。
什么是 MVC 架构？
MVC 架构在软件行业已经存在很长时间了。几乎所有的语言都使用 MVC，只是略有不同，但是概念是一样的。
MVC 代表模型-视图-控制器
- 模型–模型为存储在数据库中的数据提供接口。它负责维护数据并处理整个 web 应用程序的逻辑数据结构。
- 视图–MVC 中的视图是一个用户界面。它负责向用户显示模型数据，并从用户那里获取信息。MVC 中的视图和 Django 中的视图不一样。我们将在本文的后面了解两者的区别。
- 控制器–MVC 中的控制器负责 web 应用程序背后的整个逻辑。也就是说，当用户使用视图并发出 Http 请求时，控制器会看到用户请求并发回适当的响应。
MVC
Django 喜欢在它的 web 应用中使用自己的逻辑实现，因此它的框架自己处理所有的控制器部分。
因此 Django 实现了一种不同的架构，叫做 MVT(模型-视图-模板)架构。
什么是姜戈 MVT 建筑？
MVT 架构是 Django web 框架使用的软件设计模式。
MVT 代表模型-视图-模板。
1) 型号
就像 MVC 中的模型一样，这里它也有同样的功能，为存储在数据库中的数据提供接口。
2) 模板
就像 MVC 中的 视图 一样，Django 在其框架中使用模板。模板完全负责整个用户界面。它处理网页的所有静态部分以及 HTML，访问网页的用户会感觉到。
3) 视图
在 Django 中，视图充当了模型数据和 模板之间的链接。
注意:就像 MVC 中的控制器一样，Django MVT 中的视图负责处理 web 应用程序背后的所有业务逻辑。它充当模型和模板之间的桥梁
它看到用户请求，从数据库中检索适当的数据，然后连同检索到的数据一起返回模板。
因此，在姜戈 MVT 架构中没有单独的控制器，一切都基于模型-视图-模板本身，因此得名 MVT 。
控制 MVT 的流量
Control Flow
这里如上图所示
- 用户向 Django 发送一个对资源的 URL 请求。
- Django 框架然后搜索 URL 资源。
- 如果 URL 路径链接到一个视图，那么这个特定的视图被调用。
- 然后，视图将与模型进行交互，并从数据库中检索适当的数据。
- 然后，视图将适当的模板和检索到的数据一起呈现给用户。
结论
就这样，伙计们！！这都是关于姜戈 MVT 的建筑。要了解更多关于它们的信息，请查看 Django 模型、视图和模板文章。继续编码！！
Django MySQL——如何设置 Django 使用数据库？
在本文中，我们将学习如何结合我们的 web 框架使用 Django MySQL。
为什么 MySQL 胜过 SQLite ？
与默认的 SQLite 相比，MySQL 更安全，也更先进。它甚至可以处理大量数据，因此可以大规模使用。如果我们谈论速度，MySQL 的工作效率更高。
结构化查询语言
SQL 允许我们访问和操作数据库。使用它，我们可以执行各种任务，例如
- 向数据库添加记录
- 创建表格
- 执行 CRUD(创建、读取、更新、删除)操作
SQL 是一种由数据库系统使用的语言。为了应用和建立数据库，我们需要一个 RDBMS ，如 MySQL、PostgreSQL、Oracle 等。
建议:关于 Journaldev 的 SQL 教程
在 Django 开发中使用 Django MySQL
有了基础知识，现在让我们开始了解如何开始 Django MySQL 开发。
1.演示 MySQL 数据库
下面是我们将在演示中使用的演示表。
| 身份 | 名字 | 城市 | 国家 |
|---|---|---|---|
| one | 留宿（remain overnight 的缩写） | 纽约州 | 美利坚合众国 |
| Two | 雄鸭 | 在那里 | 美利坚合众国 |
| three | 理查德 | 巴伐利亚州 | 德国 |
| four | 圣诞节 | 维加斯 | 美利坚合众国 |
| five | 琼斯 | 慕尼黑 | 德国 |
| six | 凯恩 | 纽约州 | 美利坚合众国 |
DB Table
这里有 4 个字段和 6 个记录。
基本 SQL 语句:
- SELECT FROM-该语句从 a 表中选择 s 字段(全部或部分)。
- 其中–这是通常与其他语句一起使用的条件语句。选择使用满足该语句设置的条件的这些记录。
- UPDATE–该语句更新一个表格
- 编辑–该语句编辑一个/多个记录的字段
- DELETE–该语句删除一个/多个记录字段
2.在您的服务器上安装 XAMPP
现在要使用 MySQL，我们必须使用一个软件工具来处理 MySQL 在网络上的管理。
外面有许多工具；在本文中，我们将使用 phpMyAdmin ，因为它的工作环境非常简单高效。
Xampp 软件为我们提供了 PHPMyAdmin web 接口。所以要使用 phpMyAdmin，我们会先下载 Xampp。
点击这里下载 XAMPP 。下载适合您的操作系统和体系结构的正确版本。
Xampp
3.启动 Apache 和 MySQL
一旦你按照步骤安装 XAMPP，然后开始以下两个过程:
- Apache web 服务器–服务 HTTP 请求
- MySQL 服务器–用于数据库
Xampp
请注意 MySQL 的默认端口是 3306。之后在浏览器中，进入 https://localhost 。您将看到主机网页。
Xampp Host Webpage
然后点击右上方的 phpMyAdmin ，你将登陆 phpMyAdmin web 界面。
Phpmyadmin
现在，
- 点击左栏中的 new 创建一个新的数据库。
- 给数据库起一个合适名字。我保留了姜戈作为名字。
Django Database
4.为 Python 安装 MySQL 客户端包
Mysqlclient 是 MySQL 数据库系统的 Python 接口。要用 MySQL 连接 Django 或任何其他可用的 python 接口，我们需要 Mysqlclient。
我们将使用 pip 命令来安装 mysqlclient 包:
pip install mysqlclient
现在，一旦安装了连接器驱动程序，我们需要在 settings.py 中更改数据库信息
5.在 Django settings.py 中设置数据库设置
在 settings.py 中，我们需要设置数据库连接详细信息，包括表、数据库引擎、用户凭证、主机和端口，如下所示:
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.mysql',
'NAME': <Database_name>,
'USER':'root',
'PASSWORD':'',
'HOST':'localhost',
'PORT': '3306',
}
}
这里:
- 引擎:Django . db . backends . MySQL——因为我们在这里使用的是 Django MySQL。
- 名称:在此输入数据库的名称。
- 用户:Xampp 软件的默认用户为“root”
- 密码:****root的默认密码为空。
- 主机:主机将只是本地主机
- 端口:这是我们之前提到的 MySQL 端口 (3306)
DATABASES
6.实现 Django MySQL
现在我们必须开始在 Django 使用 MySQL 数据库。让我们设置我们的服务器。
python manage.py makemigrations
python manage.py migrate
就这样，修改已经保存了。您现在可以运行服务器并检查。一旦迁移完成，您将看到所有的迁移都被添加到 PHPMyAdmin 站点的 Django 数据库中
Database
现在我们将运行 Django 应用服务器。
python manage.py runserver
现在，如果你尝试去管理站点，Django 会显示一个关于超级用户的错误信息。这是因为超级用户的详细信息(模型表中的条目)都在早期的 DB SQLite 中，而不在 MySQL 中。
因此，我们需要在终端中再次创建一个超级用户，然后将条目添加回表中
python manage.py createsuperuser
就这样，我们成功地连接了 MySQL 数据库和 Django
将项目添加到数据库中
我们可以通过两种方式做到这一点:通过管理站点或通过 PHPMyAdmin 站点。
1)通过管理站点进行 CRUD 操作
这是我们一直使用的老方法。我们可以通过管理站点添加、编辑或删除 ItemModel 中的项目。
由于我们更改了数据库，表中的所有项目都将丢失。因此，使用管理网站本身添加一些项目。
ItemModel via admin site
所有上述信息将自动添加到 MySQL 数据库中。
转到 phpMyAdmin 站点并在 Django DB 中选择 ItemModel。您还会看到表中的所有项目。
ItemModel table via PHPMyAdmin
2)通过 phpMyAdmin 站点的 CRUD 操作
在上面的 phpMyAdmin 站点中，有添加、编辑和删除项目的选项。
编辑/删除:除了物品信息外，还有编辑、删除选项。因此使用它们我们可以从 phpMyAdmin 站点编辑和删除。
添加项目:在顶部，您会看到一个插入选项。转到那里并添加项目信息。
Add
输入信息，然后单击开始。就是这样！！已添加铅笔项目。
您可以在浏览选项以及管理站点中查看它。
MySQL
重新加载管理站点，您也会在那里看到新的项目
Admin site
看看在 Django 中使用 MySQL 有多简单。
结论
就这样，伙计们！！这都是关于 MySQL 以及如何将它与 Django 连接起来。作为实践，请尝试使用 MySQL 作为数据库来制作一个 web 应用程序。
我们将在下一篇文章中看到 PostgreSQL，以及如何在 Django 中使用它。在那之前，你可以从官方网站了解更多关于 MySQL 的信息。
注意安全！！继续学习！！
Django PostgreSQL——如何用 Django 设置和使用 PostgreSQL 数据库？
在本文中，我们将了解 Django PostgreSQL 数据库系统。在这里，我们执行与前面对 Django MySQL 类似的操作。本文将帮助那些对使用 PostgreSQL 而不是 MySQL 感兴趣的人。
PostgreSQL 是什么？
类似于 MySQL 数据库管理系统，PostgreSQL 是另一种类型的 RDBMS，用于访问、存储和处理数据库表形式的数据。
SQL–结构化查询语言在 PostgreSQL 中使用，用于访问、执行各种任务、处理 PostgreSQL 中的数据库。
PostgreSQL 的基本结构
数据作为称为表的数据库对象存储在 PostgreSQL 数据库中。
就像任何 RDBMS 一样，PostgreSQL 中的表是包含用户输入信息的名为记录的行和名为字段的列的集合，这些列包含表中每条记录的具体信息
例如:
| 身份 | 名字 | 班级 | 级别 |
|---|---|---|---|
| one | 女子名 | X | A |
| Two | 索菲娅 | 离子交换 | A |
| three | 丽雅 | 罗马数字 7 | B |
| four | 回飞镖 | 八 | C |
| five | 克莱尔 | 希腊字母的第 14 个字母 | A |
| six | 莉莉 | 罗马数字 12 | D |
PostgreSQL Table
这里有 4 个字段和 6 条记录。
【MySQL 和 Postgre 的区别 SQL
虽然 MySQL 和 PostgreSQL 都属于 RDBMS，但是两者之间有一些关键的区别。
-
MySQL 和 PostgreSQL 的核心区别在于 PostgreSQL 是一个 ORDBMS(对象关系数据库管理系统)，而 MySQL 是一个社区驱动的 RDBM 系统。
-
另一个关键特性是 PostgreSQL 支持现代应用特性，如 JSON、XML 等。而 MySQL 只支持 JSON。
将 PostgreSQL 安装到系统中
要安装 PostgreSQL，请访问此处的链接—https://www.postgresql.org/download/
一旦从上面的链接安装了 PostgreSQL，打开 SQL shell 并按照提示进行操作。您将被要求输入数据库连接的密码。
SQL shell
您当前位于 PostgreSQL 数据库中。现在，我们将添加一个名为 Django 的新数据库，在 SQL Shell 中存储我们所有的模型并编写代码
CREATE DATABASE <db_name>;
使用的语法是基本的 SQL 语法。要将当前数据库更改为 django，请使用另一个代码:
\c <db_name>;
就这样，现在你在新的 django 数据库中。
Django DB
在系统中安装 psycopg2 连接驱动程序
就像 MySQL 客户端， psycopg2 是 PostgreSQL 的连接驱动，我们需要安装它来连接 Django 和 PostgreSQL
在您的终端中编写以下代码:
pip install psycopg2
在 settings.py 中设置 Django PostgreSQL 连接
在 settings.py 中，将数据库从默认的 SQLite 更改为 PostgreSQL。
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.postgresql_psycopg2',
'NAME': ‘<db_name>’,
'USER': '<db_username>',
'PASSWORD': '<password>',
'HOST': '<db_hostname>',
'PORT': '<db_port>',
}
}
这里，
- 引擎:将引擎从 .db.sqlite 改为 .postgresql.psycopg2
- Name: 使用我们之前在 shell 中看到的 DB 名称(在我的例子中是 Postgres)
- 用户:这是我们之前看到的用户名( Postgres
- 密码:输入我们之前输入的 PostgreSQL 用户名的密码
- 主机:数据库主机名(本地主机)
- Port: 这是我们之前看到的 DB 端口号(在我的例子中是5433)。
DATABASES
Django PostgreSQL 的实现
就这样伙计们！！我们现在只需要进行迁移，让 Django 知道我们所做的更改，然后我们就可以开始了！！
python manage.py makemigrations
python manage.py migrate
您也可以从 shell 中检查这一点。在 Django 数据库中，SQLshell 编写代码来显示数据库中的所有信息
\d;
django DB
最后一个条目是我们的模型
就这样伙计们！！现在我们可以运行服务器了。
python manage.py runserver
就像在 Django MySQL 文章中一样，如果你去管理站点，Django 会显示一个关于超级用户的错误信息。
这是因为关于超级用户的信息以及条目记录都在以前的 DB SQLite 中，而不在新的 PostgreSQL 中。
因此，在终端中，我们需要再次创建超级用户
python manage.py createsuperuser
就这样，伙计们！！现在我们已经成功地将 PostgreSQL 与 Django web 框架连接起来。
在 Django PostgreSQL 数据库设置上执行操作
类似于 MySQL 教程，我们可以通过两种方式添加/编辑/删除条目:通过管理站点或 PHPMyAdmin 站点。
1)通过管理站点进行 CRUD 操作
这就是我们一直使用的众所周知的方法。我们通过管理站点添加、编辑或删除 ItemModel 中的项目。
现在，由于我们将数据库更改为 Django PostgreSQL，表中的所有项目都将丢失。因此，我们必须添加一些项目。
ItemModel via admin site
所有上述信息将自动添加到 Postgres 数据库中。
我们可以通过 SQL shell 检查这一点。在外壳中，写下
SELECT * FROM <model_name>
Django Table
2)通过 SQL Shell 的 CRUD 操作
要在 SQL shell 中添加项目:,请编写
INSERT INTO <model_name>(<fields>) VALUES <values>
该项目将被添加。
Insert
编辑:编写代码
UPDATE <model_name>
set column1 = value1 , column2 = value2 ....
where condition;
Edit
删除:编写代码
DELETE FROM <model_name> where <condition>
Delete
您也可以在管理站点中查看它。
重新加载管理站点，您也会在那里看到新的项目
Admin site
看看使用 Django PostgreSQL 有多简单！！
结论
就这样，伙计们！！我们学习了所有关于 PostgreSQL 的知识，以及如何将它与 Django 连接起来。作为实践，请尝试使用 PostgreSQL 作为数据库制作一个 web 应用程序。可以从官网了解更多关于 PostgreSQL 的内容
注意安全！！继续练习！！
Django 重定向——如何给你的 Django 页面添加重定向？
在本文中，我们将学习使用 Django Http 库的 Django 重定向。我们将简要讨论重定向方法的用例及应用。
为什么我们需要在姜戈重定向？
重定向到另一个站点是 web 应用程序的重要组成部分。它提高了网页的效率。
-
让我们以脸书、为例，如果你还没有登录，那么只要你点击 FB URL ，你就会被重定向到登录认证站点。这就是重定向发挥作用的地方。
-
同样，一旦付款被确认，当您进行在线交易时，您将被重定向到确认页面。
-
重定向的另一个好处是它有助于 URL 缩短——例如， https://bit.ly 。在这里你输入一个短网址，然后被重定向到原来的长网址。
因此重定向在 web 开发中扮演着重要的角色。现在我们知道了重定向的用途，让我们开始深入研究吧！！
Django redirect()函数
可以通过三种方式使用 redirect()函数重定向网页:
- 使用视图作为它的参数
- 直接使用 URL 作为参数
我们现在将详细了解其中的每一项。
让我们创建一个网页，它需要一个 模型表 来存储文章和函数 视图 来链接它们。
处理重定向的先决条件()
创建第一个重定向需要一些底层代码。我在这里补充一下基本要求。
1.构建 Django 模型
创建一个模型 ArticleModel 并添加以下字段
class ArticleModel(models.Model):
author = models.CharField(max_length = 80)
article_title = models.CharField(max_length = 80)
article = models.TextField()
class Meta:
ordering = [ 'article_title']
def __str__(self):
return f"{self.article_title} by {self.author}"
运行迁移以在数据库中创建一个表。
python manage.py migrate
python manage.py makemigrations
让我们也将一些对象添加到 ArticleModel DB 中，
Article Model
2.创建 Django 视图
创建一个文章视图并添加以下代码:
def ArticleView(request,title):
article = ArticleModel.objects.get(article_title = title)
return HttpResponse(article)
这里，视图显示用户搜索的文章。此视图的 URL 路径:
path('article/<article_name>', ArticleView, name=ArticleView),
3.对搜索表单进行编码
我们将需要一个搜索表单，通过它用户可以重定向到一个特定的文章。
如果您不熟悉表单，也不用担心，只需将下面的代码复制粘贴到项目中的 forms.py 文件中。
class ArticleForm(forms.Form):
title = forms.CharField(max_length =80)
如果你愿意，你可以看看 Django Forms 的文章
4.制作展示模板
这里我们将使用一个模板来显示 SearchForm。
如果您不熟悉表单或模板，也不用担心，只需在 Templates 文件夹中添加以下 HTML 代码。
<form method ='post'>
{% csrf_token %}
{{form.as_p}}
<input type="submit" value = "Submit">
</form>
好了，现在让我们回去编写 redirect() 函数。
添加 Django redirect()方法
让我们在这里用重定向方法构建我们的第一个 Django 重定向。
1.使用视图作为参数
在这种情况下，Django redirect()方法的语法如下所示:
redirect('<view_name>',<view_arguments>)
我们将使用搜索表单，用户将通过它被重定向到文章网页。
现在将下面的视图添加到 views.py 中
from django.shortcuts import redirect
def SearchView(request):
if request.method == 'POST':
form = ArticleForm(request.POST)
if form.is_valid():
title = form.cleaned_data['title']
return redirect('ArticleView', title = title)
else:
form = ArticleForm()
context ={
'form':form,
}
return render(request, '<app_name>/Form.html(path to the template)', context)
在这里，我们将这个视图重定向到上面的文章视图。此视图的 URL 路径:
path('articles/search', SearchView)
2.使用直接 URL 作为参数
在本例中，redirect()的语法如下所示:
redirect('URL')
将以下视图添加到 views.py 中。让我们将这个视图重定向到，比如说 askpython 主页。
def URLView(request):
return redirect('https://wwww.askpython.com')
此视图的 URL 路径:
path('redirect/', URLView)
就是这样；编码部分做好了。让我们现在实施它。
实现视图
启动服务器，进入“文章/搜索/”
Search Form
点击提交，浏览器将被重定向到文章视图
Article View
现在我们将运行第二个代码。
在您的本地浏览器上输入" 127 . 0 . 0 . 1:8000/redirect/"，然后点击 Enter。你将被重定向到 AskPython 网站
Ask python
使用 redirect()函数查看网页的效率。
结论
就这样，伙计们！
作为一种实践，你可以尝试使用 Django 重定向作为 URL 缩写。一定要试一试。
希望你们对 Django 重定向有很好的理解，以及如何使用它们来使你的网站更快更有效。继续练习！
django REST API——从基础到实现
在本文中，我们将了解 API、Django REST APIs、HTTP 方法，最后，创建我们自己的第一个 REST API 应用程序。
什么是 API？
API 是应用程序编程接口的缩写，它允许您与其他应用程序交互，并在需要时拉/处理/推数据和值。
简单来说，在 API 中，我们从客户端接收一些数据作为请求，对其进行处理，然后向客户端发回一些数据。
例如:脸书搜索，这里的客户端，即用户发送一个配置文件请求，然后服务器浏览其数据库中的配置文件，并返回他们的配置文件列表(与该名称)。
CRUD 操作符和 HTTP 方法
使用 API 时，可以根据需要以多种不同的方式向服务器发送请求。这些不同的类型被称为 CRUD( 创建-检索-更新-删除)
对于每个操作，我们都有相应的 HTTP 方法。我们了解了 POST 和 GET inDjango Forms；我们现在将了解其他人。
- GET–从网络服务器获取特定信息(只是为了查看)。
- POST–向服务器中的数据库添加新信息。
- PUT–编辑已有信息，如果还没有，则添加新信息。
- DELETE—从服务器中的数据库中删除信息。
我们将通过下面的例子来理解这一点:
假设我们有一个包含各种物品的 DB，比如椅子、桌子、等等
- 使用 GET: 给我们的只是要查看的项目的列表
- 使用 POST :(以及关于新项目的信息)将该项目添加到 DB 中。
- 使用 PUT: (连同关于椅子的信息)，将更新已经存在的椅子的信息。如果它以前不存在，那么它将创建一个。
- 使用 DELETE: 只会删除我们想要的特定项目。
什么是 REST API？
REST ( 具象状态转移 ) API 类似于标准 API。我们向服务器发送一个请求。但是服务器不会用数据来响应，而是用资源来响应。
- 资源是数据，但这里对数据的思考方式发生了变化。
- 资源类似于面向对象编程。
也就是说，例如:
考虑一个 URL 端点项目/椅子
在这里，我们可以用同一个端点实现四种不同的功能。
- 获取物品/椅子:获取物品列表
- 发布物品/椅子:创建一个新的物品椅子
- 放置物品/椅子:更新/编辑椅子信息
- 删除物品/椅子:从物品中删除椅子
因此，这可以被认为是一个项目资源。
因此，现在我们可以认为我们与服务器的交互不是与单个端点请求的交互，而是与资源的交互(具有不同功能的相同端点)
还有，Rest API 的另一个特点是无状态。我将用一个例子来解释这一点。
如果我们发布一个新的物品椅子的数据，服务器将把这个信息添加到数据库中。一旦添加，服务器就会忘记它。
现在，如果我向服务器发送一个针对那把椅子的 GET 请求，服务器将不会记得我们刚刚在之前的交互中保存了它。它将再次返回数据库，搜索名为 chair 的条目，然后返回信息。
返回信息后，它会再次忘记它
JSON 在客户机-服务器 API 交互中的应用
API 使用 JSON 文本来表示接受和返回请求。这意味着，当您在 Twitter 上搜索特定的 tweet 时，您会将请求作为 JSON 发送给服务器。在处理它之后，服务器再次以 JSON 文本的形式发回响应。
这个 JSON 响应被转换成用户可读的格式。
API 中前端和后端服务器之间真正的信息交换是使用 JSON 文本进行的。
JSON 文本看起来就像 python 字典。
{“item”:
{ “chair”: {
“Price”:120,
“Color”: 'red',
},
}
}
安装 DRF-姜戈 Rest API 框架
现在要使用 Django REST API，我们有一个完整的框架，叫做 Django Rest 框架。
我们需要使用 pip 命令将它安装到我们的环境中，就像我们如何安装 Django 一样。
因此，在您的 shell 类型中:
pip install djangorestframework
DRF Installation
就是这样；现在安装好了。
安装邮递员
POSTMAN 是一个易于使用的平台 API 开发。Postman 的特性简化了构建 API 的每个步骤，并简化了协作，因此您可以更快地创建更好的 API。
下载邮差，
- 去浏览器搜索邮差下载。
- 单击第一个链接
- 下载免费版的邮差
- 按照步骤进行安装
POSTMAN
就是这样。我们准备好出发了。
POSTMAN Window
一旦你下载并安装到你的系统中，它看起来就像这样
创建新的 Django REST API 应用程序
现在让我们制作一个 Django REST API 应用程序，在其中您可以查看、添加、更新和删除列表中的项目
- 创建一个名为 ITEM APP 的新应用程序
- 在 models.py 中创建一个模型
- Serializers.py
- Views.py
- Urls.py
- 邮递员命中
1.创建一个新的 Django 应用程序–items app
使用我们在 Django Hello World App 中学到的方法，在我们的项目中创建一个名为“itemsapp”的新 Django app
django-admin startapp itemsapp
创建应用程序后，进入第一步执行基本步骤:
- 将项目中的 urls.py 映射到 app 的 URLs . py
- 在 settings.py 中添加应用程序名称
- 等等。遵循 Django app 文章中的步骤
2.创建一个包含项目列表的模型 itemModel。
在 models.py 中，创建一个包含项目所需的所有必要信息的模型，如图所示。
class ItemModel(models.Model):
id = models.IntegerField(primary_key = True)
name = models.CharField(max_length = 80, blank = False)
price = models.IntegerField
class Meta:
ordering = ['name']
def __str__(self):
return f"{self.name}:{self.price}"
现在我们的模型已经准备好了，我们将学习一个新的东西，叫做
Models
3.在我们的应用中创建 Serializers.py 文件
现在，由于 API 处理 JSON 文本，每当我们将数据库中的信息提供给用户时，我们首先需要将其转换成 JSON，反之亦然。
因此，我们需要一个 serializers.py 文件。在您的应用程序中，创建一个新文件"serializer . py "，并在其中添加以下信息。
from rest_framework import serializers
from .models import ItemModel
class ItemSerializer(serializers.ModelSerializer):
class Meta:
model = ItemModel
fields = ['id',name','price']
这里我们将序列化器链接到模型，因为我们需要在将 DB 数据发送给用户之前将其转换成 JSON。所以基本上，序列化器既可以作为序列化器(将 DB 信息转换成 JSON)也可以作为反序列化器(将用户给定的 JSON 转换成 Django 可读的语法)。
Serializers
在创建视图时，我们将了解更多关于序列化程序如何工作的信息。
4.创建用于查看项目列表的 API 视图
现在，在 Views.py 中添加以下代码:
from django.shortcuts import render,HttpResponseRedirect,Http404
from rest_framework.parsers import JSONParser
from django.http import HttpResponse,JsonResponse
from django.views.decorators.csrf import csrf_exempt
from .models import ItemsModel
from .serializers import ItemSerializer
# Create your views here.
我们将需要以上所有的导入来编写 API 视图。
现在我们将编写 ItemsView ，它将在使用 GET 方法时向我们显示 DB 中存在的项目列表，并让我们在使用 POST 方法时向列表中添加新项目。(终点:项/ )
因此，将下面的代码添加到 views.py 文件中
@csrf_exempt
def ItemsView(request):
if request.method == 'GET':
items = ItemsModel.objects.all()
serializer = ItemSerializer(items, many =True)
return JsonResponse(serializer.data, safe =False)
elif request.method == 'POST':
data = JSONParser().parse(request)
serializer =ItemSerializer(data = data)
if serializer.is_valid():
serializer.save()
return JsonResponse(serializer.data,status =201)
return JsonResponse(serializer.errors,status = 400)
这里
- @ csrf _ except是一个类似于我们在 Django 表单中学到的 {% csrf_token %} 的装饰器。这个装饰器确保传递的信息不会发生任何伪造。
- 现在，如果请求是 GET，那么我们将 DB 中的所有对象存储到 items 变量中。
- 然后，我们使用序列化程序将特定信息(存储在 items 中)转换成 JSON 格式。由于我们已经从数据库中取出了所有的对象，所以将 many 设置为 TRUE。
- 一旦信息被转换成 JSON，我们就返回适当的 JSON 响应。
- 在 POST 方法中，由于用户将发送的信息是 JSON 格式的，我们需要将其转换成正确的 Python-Django 可读语法。
- 所以我们使用 JSONParser 来解析请求，以获得与新项目相关的数据，然后将其存储到变量 data 中。
- 然后，我们使用序列化程序将从请求中获得的经过解析的 JSON 文本转换成 python 可读的语法。
- 现在，如果经过解析的序列化数据是有效的，那么我们保存它，否则显示一条错误消息。
现在我们将添加另一个 API 视图 item View(endpoint:item/int:id)，它将向我们显示 GET 请求中的特定项目。我们将能够使用 POST 请求更改信息，并使用 delete 请求删除它。
在相同的 views.py 中，添加以下代码:
@csrf_exempt
def ItemView(request,nm):
try:
item = ItemsModel.objects.get(id = nm)
except ItemsModel.DoesNotExist:
raise Http404('Not found')
if request.method == 'GET':
serializer = ItemSerializer(item)
return JsonResponse(serializer.data)
if request.method == 'PUT':
data = JSONParser().parse(request)
serializer = ItemSerializer(item,data =data)
if serializer.is_valid():
serializer.save()
return JsonResponse(serializer.data)
return JsonResponse(serializer.errors, status =400)
if request.method == "DELETE":
item.delete()
return HttpResponse(status =204)
这里，
- 我们再次像以前一样使用了 @csrf_exempt ，装饰器。
- 在函数内部，我们将首先尝试获取端点中使用的 id 为的项目(从数据库中获取)。
- 如果不存在这样的条目，我们将引发一个 Http404( 未找到)错误。
- 如果方法是 GET ，我们将使用序列化器将 DB 中的项目信息转换为 JSON 格式，然后将 JSON 响应返回给用户。
- 如果方法是 PUT，我们将解析请求以从中获取 JSON 数据，将其发送给序列化程序以将其转换成 python 可读的语法。
- 注意在 serializer 中，我们还需要传递项目以及解析的数据，因为 Django 需要知道 DB 中的哪个项目需要更新。
- 如果方法是 DELETE，我们将从 DB 中删除特定的项目。
就这样，伙计们！！如果你理解序列化器有困难，不要担心；练习一段时间后，你会找到窍门的。
Views
现在我们将修改我们的 urls.py 来适应这两个视图
5.为 urls.py 中的两个视图创建 URL 映射
在 urls.py 中添加 path 函数，将两个 API 视图链接到其适当的端点。因此，在 urls.py 中添加
path ('items/', ItemsView),
path('item/<int:nm>/', ItemView),
我们在 Django URL 映射中学习了映射 URL。
Urls 1
此外，使用下面的代码将模型注册到管理站点，如在 Django 管理站点中所学
admin.site.register(ItemModel)
就是这样。现在，我们需要进行迁移，以便在数据库中创建 ItemModel 表。所以在 Shell 中，输入:
python manage.py makemigrations
python manage.py migrate
现在，一旦创建了表，我们就可以运行服务器了
python manage.py runserver
转到管理站点，向我们刚刚创建的 ItemModel 添加一些元素。
使用 POSTMAN 查看端点
让我们利用之前下载并安装的 POSTMAN API 开发环境。
1.获取项目/
现在在搜索 URL 中，输入 URL“host website/items”并在左侧，保留方法 GET。
点击发送并观察以下内容:
GET Items
我们获得了 DB 中存在的项目列表的信息
2.发布项目/
现在在下面，你会看到一个体选项。去那里选择文本为 JSON ，在下面给出的地方，输入你想要添加的物品的信息。
现在将方法从 GET 改为 POST，然后点击 send
POST Items
该项目现已包含在数据库中。
3.获取项目/id
现在，在搜索 URL 中，转到端点项目/ < id >并输入您想要的 id。保留 GET 并点击 send 的方法。
GET Item
你会得到关于那个特定项目的信息。
4.放置项目/id
再次像在 POST 选项中一样，写下关于预先存在的项目的信息，然后将方法更改为 PUT 并点击 send。
PUT Item
您将看到信息已经更新
4.删除项目/id
现在，将方法改为删除，并点击发送
DELETE Item
您将会看到，现在特定的项目已被删除。
结论
Django REST API 教程到此为止！我们希望您已经掌握了 Django REST 框架的所有基础知识以及如何使用它们。另外，您可以从官方文档中了解更多关于 Django REST 框架的信息。
请继续关注 Django 主题的更多高级教程！
Django 会话–使用 Django 设置用户会话
在本文中，我们将讨论 Django 会话。会话的行为和为我们提供的结果与使用 cookies 时相似。但是在客户端保存 cookies 会导致安全威胁。因此，为了使这个过程更加安全，我们使用会话。这正是我们将在本文中学到的——如何使用 Django 会话保护我们的网站免受不安全 cookies 的攻击！！
什么是 Django 会话？
从 Django cookies 文章中我们知道，我们可以使用保存在客户端的 cookies 来存储 Web 应用程序的各种有用数据。
但是在客户端存储与 Web App 相关的信息会导致很多安全问题，因此在客户端存储并不是一个好主意。一些可能的威胁包括:
- 黑客可以修改 cookie 数据，并发送它们来潜在地危害我们的网站。
- 我们不能存储用户密码等敏感数据。在饼干里。
- 我们只能在 cookies 中存储有限的数据。大多数浏览器不允许超过 4kb 的数据。
为了解决所有这些问题，我们使用会话，这是一种在服务器端存储 cookies 的机制。因此，所有数据都以 DB 表的形式存储在服务器中，客户端 cookie 只有用于标识的会话 ID。
因此，通过会话，我们可以保存敏感数据，通过会话，我们还可以处理客户端浏览器的无 cookie 策略。
Django 在其框架中预建了一个会话框架。现在让我们了解一下吧。
如何设置 Django 会话？
会话属性作为字典出现在请求数据中。因此，我们用来调用会话的语法是:
request.session.(#other_commands)
1)设置会话
建立会话意味着我们:
- 创建会话
- 然后将会话 ID 作为 cookie 发送给客户端。
设置会话的语法是:
request.session['session_name'] = 'session_value'
2)访问会话
为了取回会话信息，我们调用 get session 属性。然后执行以下任务:
- 从客户端接收 cookie
- 读取会话 ID 的 cookie
- 使用会话 ID 检索会话数据
获取会话的语法是:
#method1
session_value = request.session.get('session_name')
#method2
session_value = request.session['session_name']
3)其他会话属性
除此之外，还有一些其他的会话功能。其中一些列举如下:
- set_expiry(value) :设置会话的到期时间。
- clear)_expired(): 删除过期的会话
- get_expiry_age(): 返回会话到期前剩余的秒数
- get_expiry_date(): 返回会话的到期日期
读够了吧！！现在让我们把手弄脏吧。
Django 课程实践
我们现在将构建一个简单的 web 应用程序，它使用一个视图设置会话，然后使用另一个视图返回会话。
1)对 SetSession 视图进行编码
def SetSession(request):
request.session['book_name'] = 'Sherlock Holmes'
return HttpResponse('The Session has been successfully set')
视图的 URL 路径将是:
path('setsession/',SetSession),
2)编码 GetSession 视图
现在在 SetSession 下面，在 views.py 中添加下面的 GetSession 视图
def GetSession(request):
book_name = request.session.get('book_name')
return HttpResponse(f'The Book Name is: {book_name}')
视图的 URL 路径将是:
path('getsession/',GetSession),
代码的实现
既然我们已经讨论了所需的单个视图，下面是 Views.py 的组合脚本(包括上面的代码)
只需在您的 views.py 中添加以下代码以及 URL 映射，我们就可以开始了:
from django.shortcuts import HttpResponse
def SetSession(request):
request.session['book_name'] = 'Sherlock Holmes'
return HttpResponse('The Session has been successfully set')
def GetSession(request):
book_name = request.session.get('book_name')
return HttpResponse(f'The Book Name is: {book_name}')
最终的 urls.py 文件将如下所示:
from django.contrib import admin
from django.urls import path
from .views import SetSession, GetSession
urlpatterns = [
path('setsession/',SetSession),
path('getsession/',GetSession),
]
好了，现在让我们启动服务器并转到127 . 0 . 0 . 1:8000/setsession/
Set Session
我们已经成功设置了会话。
现在让我们通过127 . 0 . 0 . 1:8000/getsession/端点取回它。
Get Session
就是这样！！看看使用进程是多么简单。
结论
就这样，伙计们！！这都是关于 Django 会话以及如何在你的项目中使用它们。有关 Cookie 处理的信息，请查看 Django Cookies 文章。
下一篇文章再见！！在那之前，继续编码吧！！
Django 静态文件简介
在我们的上一篇文章中，我们讨论了 Django 模板。在本文中，我们将学习 Django 静态文件的另一个类似主题。
所以现在，如果你去任何一个网站，比如说facebook.com，你会在网页上看到各种各样的图片和颜色，而不仅仅是文字。
现在在前端，这个漂亮的视图，组成了完整的网页，通常是使用 CSS(层叠样式表)，JavaScript 文件和图片来实现的。我们将所有这些图片、CSS 文件和 JS 存储在一个名为 static、的文件夹中，而这些文件被称为静态文件。
创建 Django 静态文件文件夹
就像我们在上一篇文章中学习的模板一样，Django 静态文件也保存在一个名为 static 的单独文件夹中。
如图所示，在您的 Django apps 目录中创建一个静态文件夹。
Static
命名空间静态文件文件夹
类似于我们的模板教程，静态文件需要命名空间。这里，我们也需要在静态目录中添加应用程序名称。
这是因为 Django 使用快捷方式来搜索文件(当它们被导入/加载时)。
INSTALLED APPS
当您请求一个静态文件时，Django 会连续搜索INSTALLED _ APPS/settings . py，并返回第一个结果。
如果在 apps 文件夹中有两个同名的静态文件，Django 可能会返回错误的文件。
因此，就像上一篇文章一样，在静态文件夹中添加一个新文件夹( < apps_name > )，如下图所示。
Namespacing Static
为网页创建一个简单的 CSS 文件
现在我们将创建一个简单的 CSS 文件，看看 Django 如何将它加载到网页上。请注意，我们的主要重点是学习 Django，因此如果您不理解用 CSS 编写的代码，也不用担心。
1.向我们的页面添加背景图像
让我们使用 CSS 为我们的网页(主机网站/书籍)添加一个背景图片。
最好将所有将在我们网页上使用的图像保存在一个单独的文件夹中，该文件夹为静态/ <应用名称>文件夹下的图像】。
注:单独的文件夹，我指的是在静态文件夹中创建的 < app_name > 文件夹内。请看下图，以获得目录结构的视觉透视。
Static directory Structure
让我们创建一个“images”文件夹，并将下图保存在其中。
Books
2.在静态文件中为“BookView”视图编写 CSS 代码
是时候编写代码将图像显示为背景了。我们将使用 CSS 来显示背景。您可以简单地复制代码，而不用担心它的含义。
确保您更改了下图中提到的文件名。
body{
background: white url("images/books.jpg") no-repeat;
}
CSS 语法很容易理解，如果你试一试，你会得到我们想要的东西。所以基本上在这里:
- 目的:我们正在改变网页的背景
- 背景: 白色暗示网页应该显示白色背景色，以防图像由于某种错误而无法加载
- URL("images/books.jpg") 是我们正在使用的图像的路径。
- No-repeat: 表示当浏览器窗口大于图像尺寸时，图像不应重复出现。
3.修改模板文件以合并静态文件
现在在 templates 文件夹中，打开与“book view”视图链接的模板。对我来说，是 BookView.html
在上一篇关于 Django 模板的文章中，我们最终的 BookView.html 是:
BookView Inclusion 2
这是一个基本的 HTML 文件结构。如果你以前没有使用过 HTML，试一试吧。这是一种非常基础的语言，可以在几个小时内学会。
<html>
<head>
<p> Headeer Information </p>
</head>
<body>
<p> Main Text Code </p>
</body>
</html>
让我们修改我们的 HTML 文件，以灌输一个 HTML 文件的正确语法。因此，该文件将如下所示。
BookView HTML
我已经删除了之前出现在第 4 行的包含行，并直接替换为标题“图书中心”。
现在要链接 CSS 文件到它，我们使用 HTML 链接标签中的 <头> 。语法看起来像这样。
<head>
<link rel="stylesheet" type="text/css" href= "{% static 'books_website/style.css' %}">
</head>
这里:
- 目的:将 CSS 文件链接到 HTML 文件
- <链接:是一个 HTML 属性，我们通过它向其添加 CSS 文件
- rel: 该属性定义了当前文件和链接对象之间的关系
- 类型:定义我们正在链接的对象的类型。
- 这个属性告诉我们正在链接的文件的路径(在这个例子中是 CSS)
因此，BookView.html 将会是什么样子
BookView HTML
4.将 {%负荷静态 %}线添加到 H TML f 线
如果您现在尝试运行服务器，当您输入以下 url 时会出现错误:http://127.0.0.1:8000/books/。
Error
你会注意到，网页无法加载我们在 HTML 文件中添加的 CSS 文件的路径。
这是因为我们没有为静态文件加载静态标签。也就是说，如果我们不加载静态标签，那么 Django 就不会知道下面的单词" static" used 是什么意思。
下面一行搜索静态文件夹的路径，然后加载它。
{% load static %}
所以当我们使用下面的代码时，Django 知道单词 static 指的是什么。
{% static "books_website/styles.css%}
添加 {% load static %} 行后。该文件现在将看起来像这样
BookView HTML
注意:始终保持模板继承线在顶部。这是因为 BookView.html 文件是项目目录中基本文件(basic.html)的延伸。
所以在 Django 读取这个文件之前，它应该先读取继承的文件。
现在保存 BookView.html 的文件。服务器应该自己重新加载。如果没有，请在 shell 中使用下面的命令
python manage.py runserver
这就对了。我们将背景图片添加到网页中。
Browser 1
同样，为127 . 0 . 0 . 1:8000/books/
{% load static %}
<html>
<head>
<link rel= "stylesheet" type="text/css" href= "{% static 'books_website/style.css' %}">
</head>
<body>
{% block content %}
<h3>{{book.title}}</h3>
<h4>{{book.price}}</h4>
<h5>{{book.genre}}</h5>
{% endblock %}
</body>
</html>
这里我们使用相同的背景图像，因此 CSS 文件的链接属性保持不变。
为了更好地学习，请尝试自己理解，如果您有任何疑问，请访问 Django Templates 的文章
让我们运行这个网页，并检查
Browser 2
结论
Django 静态文件教程到此结束！我们希望您已经对静态文件及其在 Django 中的使用有了足够的了解。另外，您可以从官方文档中了解更多关于 Django 静态文件的信息。
请继续关注 Django 主题的更多高级教程！
Django 模板继承——避免冗余代码
原文：https://www.askpython.com/django/django-template-inheritance
在本文中，我们将了解一个非常重要的主题 Django 模板继承。我们已经了解了 Django 中的模板是什么。我们将从那里获得知识，并在此基础上不断发展。
什么是 Django 模板继承？
模板继承是一种将 HTML 文件中的所有元素添加到另一个文件中的方法，而无需复制粘贴整个代码。例如，考虑脸书主页。
这里是网页的基本主题；背景、要素等。，对所有 FB 终点都一样
有两种方法可以实现这一点:
- 将相同的 CSS/JS/HTML 代码添加到所有端点模板中
- 或者，创建一个包含所有公共元素的文件，然后简单地将它包含在其他文件中。
第二种方法是模板继承到底做什么。
为什么要继承？
就像脸书一样，大多数应用程序的单个页面都有很长的 HTML 代码。现在，为每一页一遍又一遍地写这些内容是不可能的，而且是一种非常低效的方法。
因此 Django 提供了模板继承的方法来确保更高的效率和更少的代码重复。
模板继承的另一个重要好处是，如果我们修改主文件，它将在继承的所有地方自动改变。因此，我们不需要在所有其他地方修改它
Django 模板继承实践
让我们在项目级别创建一个基础 HTML 文件，然后让 Django 应用程序模板继承它。
1)在 settings.py 中修改模板
为了使基础文件可访问，在设置. py 中的模板中添加下面一行，如下图所示。
'DIRS': [os.path.join(BASE_DIR,'django_project/templates')],
该行执行以下功能:
- 我们使用预定义变量 BASE_DIR 获得 Django 项目目录的路径(我们的 Django 项目文件夹)
- 然后用 os 模块，我们把它加入到 django_project/templates 文件中。
我们基本上是告诉 Django 在应用程序之外搜索模板，也是在项目级别(上面代码指示的路径)。
Base HTML path
2)编码父基本 HTML 文件
在所有应用程序之外的 Django 项目目录级别的 Templates 文件夹中创建一个模板BaseTemplate.html。
并将以下代码添加到文件中:
<h2>Basic File Inheritence</h2>
{% block <block_name> %}
<p> PlaceHolder to be Replaced</p>
{% endblock %}
基本文件应该包含 {% block < block_name %} 元素。
当基的。html 模板将被继承，块内容将被其他模板的内容替换。
3)编写应用程序的 HTML 模板文件
现在让我们编写应用程序模板–“App Template”。HTML "，将继承基文件。将下面的代码添加到 Django 应用程序的模板文件中:
{% extends 'base.html' %}
{% block content %}
<h3>Welcome to the App</h3><br>
{% endblock %}
注意:****{ % extends ' base . html ' % }行应该总是出现在文件的顶部。
我们需要将模板内容添加到与父文件同名的类似块中。基本文件中的块内容将被该文件中相应的块内容替换。
4)创建显示模板的应用视图
我们现在只需要一个视图来呈现和显示我们的应用程序模板。视图的代码很简单:
from django.shortcuts import render
def TemplateView(request):
return render(request,'<app_name>/AppTemplate.html(path to the Template)')
视图的 URL 路径:
path('template/', TemplateView)
实现模板继承
编码部分到此结束，现在让我们在浏览器中实现模板。
运行服务器，点击网址
Template Inheritance
现在，您可以继续使用与主模板相似的格式创建页面。在我们的例子中，那是 base.html。
如果您将所需的 CSS 和 HTML 格式选项添加到 base.html，相同的样式将应用于继承基本文件的所有模板。
结论
模板继承就是这样！！下一篇文章再见！！在那之前继续练习！！
Django 模板语言——初学者入门
原文：https://www.askpython.com/django/django-template-language
在本文中，我们将学习 Django 模板语言以及如何在模板中使用它。
什么是 Django 模板语言？
Django 模板语言或 DTL 是一种基于文本的模板语言，在 HTML、CSS、JS 等脚本之间提供桥梁。以及像 python 这样的编程语言。
DTL 专为开发者打造，用于将 Django 逻辑代码嵌入 HTML 模板文件。
与其他基于文本的模板语言相比，DTL 也有很大的优势，因为它
- 简单
- 简单易学的语法
- 展开性
为什么我们需要 Django 模板语言？
web 应用程序有两个主要组件:
- 前端
- 后端
因此，如果前端开发人员分别负责 HTML 部分，而后端开发人员分别负责 Python-Django 部分，那就更有意义了。
Django 模板语言可以做到这一点！！
有了 DTL ，前端开发者不需要知道 python，后端程序员也不需要知道 HTML。
前端人员只能处理 HTML，并在任何需要 Django 信息的地方留下 HTML 注释。稍后一个后端人员会用 DTL 语法替换 HTML 注释，因此不需要 HTML 知识。
Django 模板语言(DTL)的基本结构
DTL 语法与 Python 非常相似。它包括:
- 模板标签
- 模板变量
- 模板过滤器
- 模板注释
我们现在将逐个研究它们。
1.模板标签
模板标签执行一个功能或过程。也就是他们“做”某件事。模板标记语法:
{% Tag %}
模板标签本身属于 5 不同的类型:
1.1 条件语句
这些，类似于 Python 中的 条件语句 ，是用来执行逻辑的。
下面显示了一个示例:
{% if %}
<code>
{% end if %}
1.2 个循环
这个，类似于 python 循环 ，用来迭代循环中的变量。
{% for x in y %}
<code>
{% endfor %}
1.3 块声明
块声明主要用于 模板继承。
语法如下所示:
{% block content %}
<code>
{% endblock %}
1.4 文件内含物
该命令将其他 HTML 文件包含到当前文件中。
{% include “header.html(file name)” %}
1.5 文件继承
下面的命令将其他 HTML 文件继承到当前文件中。
{% extends “base.html(file name)” %}
2.模板变量
DTL 中的模板变量函数类似于 Python 中的变量。语法:
{{ <Variable_Name> }}
下面给出了一些模板变量示例:
- 简单变量 : {{ title }}，{{ x }}
- 列表属性 : {{ fruits_list.0 }}
- 对象属性 : {{ name.title }}
- 字典属性 : {{ dict.key }}
这些变量的数据直接从 Python 代码中提取，值可以通过使用上述语法在 HTML 代码中实现。
3.模板过滤器
模板过滤器用于对模板变量进行过滤。模板过滤器的语法:
{{ <Variable_Name> | <filter_by_attribute> }}
一些最常用的模板过滤器示例如下:
- 改变大小写 : {{姓名|头衔}}，{{字符|大写}}
- 列表过滤器/切片 : {{ list|slice = " :5 " }}
- 截断 : {{ name|truncatewords : 80 }}
- 默认值 : {{ value|default ="0" }}
4.模板注释
顾名思义，这相当于 DTL 的 python 注释。Templat 注释语法:
{# <Comment> #}
就像在 python 中一样，comment 属性中的代码不会被控制台执行。
结论
就这样，伙计们！！这都是关于 Django 模板语言的。有了这个，你就可以高效地用 Python 链接 HTML 代码了。一定要查看关于 Django 模板语言的官方文档。
下一篇文章再见！！在那之前继续练习！！
Django 模板——综合参考指南
继续我们的 Django 教程系列，让我们了解 Django 模板。要制作一个 web 应用程序，你需要前端和后端。
如果我们把这两者混在一起会很混乱。Django 为我们提供了一个非常强大的方法来保持 HTML/CSS 前端代码与后端代码完全分离。
DTL–姜戈模板语言
使用 Django 模板，前端开发人员不需要学习 python，后端程序员也不需要了解 HTML。
前端开发人员可以简单地留下 HTML 注释(任何他想从 Django 得到 DB 和其他信息的地方)。后来，程序员可以简单地用一种模板语言替换它们——被称为 Django 模板语言(DTL)
因此，DTL 是用于在 HTML 文件中嵌入 Django/python 代码的模板语言之一。
DTL 比其他国家有优势，因为它的
- 简单
- 简单易学的语法
- 可扩张的
Django 模板语言的基本语法 (DTL)
DTL 语法类似于 python，非常易学。它进一步分为 3 种类型
1。模板标签
这些模板标签做一些事情。这句话可能很难理解，但看到例子后你会明白的，所以不要担心！！
注意:一个模板标签由 {% 和 %} 包围。一些例子是:
- 条件语句/显示逻辑–>{ % if % }……{ % endif % }
- 循环–>{ % for x in y % }……
- 区块声明–>{ %区块内容% }……
- 内容导入–>
- 继承–>
2。模板变量
模板变量类似于 python 中使用的变量。
注意:使用的语法是 {{ 和 }} 一些例子是:
- 简单变量–>{ { title } }，{{ x }}
- 列表属性–>{ { fruits _ List . 0 } }
- 对象属性–>{ { name . title } }
- 字典属性–>{ { dict . key } }
注意:这里，list.0 与 python 中的 list[0]不同，用于访问 Python 列表的第一个元素
3。模板过滤器
一个模板过滤器用于过滤变量/属性。
注:符号 |(管道)用于表示过滤器。
一些例子是:
-
变格–>{ { name | title } }或{{ characters|upper_case }}
-
列表过滤器/切片–>{ { List | slice = ":5 " } }
这意味着在列表中，只显示前 5 个元素。 -
截断–>{ { name | truncate words:80 } }
这意味着从名字中，只显示前 80 个，即把名字截断到前 80 个字符。 -
默认值–>{ { value | Default = " 0 " } }
这意味着如果变量值为空，则显示默认值 0。
1.创建 Django 模板文件夹
在 Django 中，因为我们将所有的前端文件与后端文件分开，所以这些文本文件(主要是 HTML 文件)也保存在一个单独的文件夹中。
Template settings.py
现在如果我们转到 settings.py，会出现一个模板选项，如上图所示。现在这里重要的是 APP_DIRS
'APP_DIRS':True
这一行的意思是 Django 将在名为 templates 的文件夹中搜索模板/HTML 文件。
这意味着我们必须在 Django 应用程序中创建一个 templates 文件夹，并将所有 HTML 文件保存在那里。
Templates Folder
2.命名空间模板
当我们加载一个特定的模板文件时，Django 遍历 settings.py 中的 INSTALLED_APPS 中列出的每个应用程序。它按照从上到下的顺序这样做，并加载它获得的第一个同名文件。
我们的项目中可能有不止一个应用程序，而且在不止一个应用程序中可能有两个同名的 HTML 文件。
假设你有一个图书应用和一个钢笔应用。两者的模板文件夹中都有一个index.html文件。
如果你试图将 index.html 放入图书应用的 views.py 中，Django 可能会加载错误的 index.html 文件。
这是因为，如前所述，它从 INSTALLED_APPS 列表中加载文件的第一个实例。
这可能会导致问题。为了避免这种情况，我们在模板文件夹中使用命名空间。
我的意思是在模板文件夹中添加另一个带有应用程序名称的文件夹。
Namespacing
在我的例子中，应用程序被命名为“ books _website ”，所以我将用这个名称命名模板文件夹(如上面的截图所示)。
因此，当您将文件包含在您的 views.py 中时，您将把包含路径写成
“ <app_name>/<HTML file>”
也就是说，在我的情况下，它将是
‘books_website/index.html’
命名约定可以根据需要进行更改，不需要成为应用程序名称。
然而，为了方便起见，使用应用程序名称是一种标准做法。
3.创建基本的 DTL 文件
现在让我们制作一个简单的模板文件，并学习如何将它包含在我们的 views.py. 中。在应用程序的 templates/books_website 文件夹中，添加一个 bookView.html 文件:
books_website/BookView.html
现在将代码添加到文件中:
{% for book in books %}
<li>{{book.title}}</li><br>
{% endfor %}
BookView.html
代码是不言自明的，因为它是循环打印图书列表的通用。
4.views.py 中的渲染模板
将模型信息发送到模板文件的最有效方式是使用 views.py 中的 render 函数。
render(request,<html file path>,<context>)
render 方法获取上下文(这是模型信息)，使用其路径将其发送给模板，然后为浏览器返回适当的响应。
在 views.py 中，编写图书视图中的代码:
def BookView(request):
books = BookModel.objects.all()
context = {
'books':books
}
return render(request,'books_website/BookView.html', context)
BookView
这里:
- 我们将模型数据存储到书中
- 注:我们创建了一个上下文作为字典
- 我们调用了 render 函数，该函数将请求、模板路径和上下文作为其参数，并返回适当的响应。
现在让我们运行服务器并检查浏览器
Browser
5.模板继承
现在在BookView.html，我们有一个小的 HTML 片段，但实际上，HTML 文件通常很长。
由于一个网站的大多数网页都是一样的，只是在内容上有一些修改，Django 提供了一种叫做模板继承的方法。这避免了重复代码和增加不必要的冗余。
模板继承的另一个好处是能够修改代码的主文件，因此 UI/HTML 的变化反映了整个应用程序。
因此，我们创建了基本的 HTML 文件，这些文件拥有所有页面通用的完整代码框架。
我们将这个文件存储在应用程序之外的模板文件夹中(在项目中)，这样每个 Django 应用程序 都可以访问它们。
为了继承其他模板中的代码，将这一行添加到 settings.py 中的模板中。
'DIRS': [os.path.join(BASE_DIR,'django_project/templates')],
这一行很容易理解:
- 我们使用预定义变量 BASE_DIR (我们的 Django 项目文件夹)获得基本 Django 目录
- 然后用 os 模块，我们把它加入到 django_project/templates 行。
仔细阅读以上段落，并反复阅读，以理解我们正在做的事情。
Base HTML path
现在让我们制作一个简单的basic.html文件，它将“ Hello Viewer ”添加到它的所有网页中。
用来写文件的语法是:
<h2>Hello Viewer</h2>
{% block content %}
<p> PlaceHolder to be Replaced</p>
{% endblock %}
在基本文件中，我们添加了一个块(在我的例子中名称为“content ”),然后添加了一个默认行,以防在加载另一个 HTML 文件时出现错误。
该默认行将被替换为应用程序内 HTML 文件中的内容。
Basic.html
现在，让我们更改 BookView.html 文件，以合并basic.html文件。
将下面的代码写入文件
{% extends 'basic.html' %}
{% block content %}
{% for book in books %}
<li>{{book.title}}</li><br>
{% endfor %}
{% endblock %}
- 我们在起始继承父文件(basic.html)中添加一行 {% extends 'basic.html' %}
为了指示 Django，【basic.html】文件中存在的块(名称-内容)将被替换，我们添加了一个具有相同名称的块(我们在basic.html文件中使用的)。
在这个块中，我们编写了替换默认行的代码
BookView.html
现在让我们运行服务器并检查浏览器
Browser Inheritance
6.模板内含物
与继承类似， Django 模板文件也可以包含在其他 HTML 文件中。
让我们制作另一个文件BookViewAdd.html，它增加了一个标题“图书中心，让我们把它包含到BookView.html
在 books_website/templates 文件夹中创建另一个名为(BookViewAdd)的 HTML 文件，并添加一行
<h3>Book Hub</h3>
BookViewAdd
现在在BookView.html，在块内容内添加包含代码行:
{% extends 'basic.html' %}
{% block content %}
{% include 'books_website/BookViewAdd.html' %}
{% for book in books %}
<li>{{book.title}}</li><br>
{% endfor %}
{% endblock %}
这里我们使用了{ % include ' books _ website/bookviewadd . html“% }，这类似于我们之前使用的继承语法。
BookView Inclusion
现在让我们运行服务器并检查浏览器
Browser
结论
Django 模板教程到此结束！我们希望您对 Django 中的模板功能有一个坚实的理解。另外，您可以从官方文档中了解更多我们在这里使用的 Django 模板语言。
请继续关注 Django 主题的更多高级教程！
Django URL 映射-操作指南
在本教程中，我们将学习更多关于 Django URL 映射以及如何链接 URL 请求和相应的视图。
我们将理解我们在第一篇文章中是如何在我们在教程最后进入的 sayHello / 页面显示 Django Hello World 的。
让我们从理解 Django URL 库开始。
Django URL 库的基础知识
在这里的 django.urls 库中，我们有各种将在我们的 web 应用程序中使用的函数。让我们更多地了解他们。
1.路径(路线、视图、路径、名称)
该函数返回一个需要包含在 urlpatterns 中的元素。也就是说，path 充当元素(例如视图)和它的 URL 之间的链接。
1。路线
这是特定视图的 URL。例如:<name>/是一条路线。
因此，当我们从 URL 请求这个页面时，服务器将返回与之链接的视图。
2.视图
这里我们需要写下，我们需要链接的视图名称。或者使用函数“include”添加另一个 urls.py 文件。(就像在 project/urls.py 文件中一样)
- *kwargs 和args
python 中函数定义中的 args 是用于变量输入参数列表的语法。
它与一个星号连用。
例如，如果我们需要为一个函数输入任意可变数量的参数，那么我们使用*args。让我们看一个例子
def myFun(*args):
for arg in args:
print(arg)
myFun("Hello","There","Hi","There")
所以这里我们可以给出任意数量的参数，而*args 将会包含所有的参数。我们可以认为所有的参数都被 arg 保存为某个列表，因此在 args 中使用 arg 的行，我们从列表中取出每个元素。
将列表分割成元素，因此args 会分别给出所有元素，args 会将元素作为列表给出。
所以如果你运行上面的代码，你会得到
Args
Python 中函数定义中的 kwargs 用于关键字变量参数列表。
它与双星号连用。
例如，如果我们需要为一个函数输入任意可变数量的参数(关键字),那么我们使用**kwargs。让我们看一个例子，然后你会更清楚的知道关键词的确切含义
def myFun(**kwargs):
for item,price in kwargs.items():
print(f"{item}={price}")
myFun(Book=100,Pen=10,Watch=4000)
正如你在上面的例子中看到的，我们能够传递完整的值。使用赋值操作符的变量名和这些变量保存的值。
我们可以认为参数被 kwargs 保存为一个 Python 字典 ，因此通过使用 kwargs.items()中的项目价格行，我们得到了项目(书、笔等)及其相应的价格(100、10 等)。
将字典拆分成它的元素。因此kwargs 给你单独的所有关键词元素，而 kwargs 给你作为字典的关键词元素。
Kwargs
在 Django path()中，如果我们需要向视图发送更多信息以及 URL 路由，我们可以使用 kwargs。
例如
path('name/<int:id>',views.name_id,{"foo":"bar"})
通过使用 URL name/25，Django 将调用 views.name_id( request，id = 25，foo ='bar ')。
3.名称
Name 用于指定 URL 所链接的特定视图的名称。
2.包含(模块，名称空间=无)
这个函数获取另一个 URL 配置文件，该文件应该通过使用这个 include 函数来包含。即与另一个 urls.py 文件形成链接，你应该使用 include 函数。名称空间也可以写在里面，但是我们现在不需要这样做。
如何在 Django 中将 URL 映射到视图？
apps/urls.py
这里我们使用 path()函数，语法如上:
path(‘ ’, sayHello, name = ‘sayHello’)
这里 sayHello 是 views.py 中基于函数的视图名称。我们将路径保留为空字符串，这样我们就可以直接访问基目录上的视图-http://127 . 0 . 0 . 1:8000/在我的例子中。
Django 项目中的 URL 映射
project/urls.py
path() 函数将 URL 链接到应用程序中的 urls.py 文件。所以我们需要 include() 函数，它具有我们在上面学到的语法。
例如，这里我们使用了:
path(‘sayHello/’,include(‘HellpWorldApp.urls’))
除了路径和 include 函数，还有 re.path()和 register_converter() 函数，我们在 Python-Django 的课程中不会用到它们。
注意:在 project/urls.py 中我们使用了:
path(‘sayHello/’, include(HelloWorldApp.urls)),
现在，即使我们在 app/urls.py 中编写 sayHello/
这里有一个示例实现:
apps/urls.py:
path(‘sayHello/’, sayHello, name = ‘sayHello’)
projects/URL . py:
path(‘ ’, include(HelloWorldApp.urls))
对于多个视图，建议使用这种新方式。因此，从现在开始，我们将在 apps/urls.py 中保留端点，在 project/urls.py 中保留' '(主机网站链接)
因此，我们现在可以更改它们，如下图所示。
App/urls.py
project/urls.py
现在我们知道了路径和包含函数，让我们移动一个来创建多个视图，并将它们链接到不同的端点。
多个视图的 Django URL 映射
正如我们在 hello world 文章中所做的一样，我们将在视图. py. 中再添加一个视图
让我们创建一个 view Book。添加代码:
def Books(request):
return HttpResponse("This is a books webpage")
views.py(Books)
对于更新的视图，我们需要创建另一个端点。因此，在 apps/urls.py 中，我们必须为端点‘Books/’添加另一个路径
path('Books/', Books,name='Books'),
apps/urls.py
现在让我们运行服务器并在浏览器中检查。
Runserver
Browser Books/
URL 映射-变量端点****
让我们创建一个视图，它将图书 ID 作为请求，然后简单地返回一行给我们 ID。
在 views.py 中，让我们创建另一个端点为‘Books/
def BookID(request,bookid):
return HttpResponse(f"The book Id is:{bookid}")
这里我们只是将图书 ID 与请求一起，然后我们将返回特定于该特定图书的响应。
Views.py(BookID)
现在我们必须在 apps/urls.py. 中添加端点
path('Books/<int:bookid>', BookID, name='BookID'),
apps/urls.py
这里我们不得不提到使用语法显示的 < int: bookid >
让我们运行并检查一下
Runserver
现在让我们运行浏览器并访问 127.0.0.1:8000/Books/1
Browser 1
我们还可以检查任何其他随机的图书 ID。
Browser 23
我们可以看到我们的网页正在工作。因此，我们现在可以使用上面的知识将任何视图与URL进行映射。
结论
这就是我们的结局。现在，是我们下一篇讨论 Django 视图和更多我们在这里的 views.py 中实际做了什么的时候了。在接下来的几天里，敬请关注更多关于 Python Django 和 Flask 的文章！
Django URL 模板
在本文中，我们将了解一个关键的 Django 模板语言标签——Django URL 模板标签,并知道如何使用它们。
什么是 URL 模板标签？
URL 模板标签是 Django 模板语言框架中的典型标签类型。这个标签专门用于在模板文件中添加视图 URL。
在 HTML 模板文件中，URL 标签与 HTML 的锚、 <、href > 属性一起使用，处理 HTML 中的所有 URL
为什么我们需要 Django URL 标签？
当我们可以直接添加视图 URL 时，Django URL 模板标签的用途是什么？
让我们看一个简单的 HTML a href 标签。
<a href = "/books/book1">Info about book1</a>
我们知道它采用静态 URL 并允许我们点击链接。
视图通过 URL 从客户端获取数据。例如，在以下视图中:
def View(request,book_id):
#Code
return render(request, 'Template.html', {'article_id' : article_id})
在这种情况下，URL 路径应该是:
path('book/<int:book_id>' , View, name = 'Books_View')
这里的 book_id 可以从一本书改变到另一本书。
因此，直接添加这个 URL 是不实际的，它的端点依赖于 book_id。这就是 URL 标签出现的地方。
动手使用模板 URL 标签
要使用模板标签，我们需要正确的视图！！因此，让我们首先创建几个简单的视图。
URL 模板标记
URL 模板标记语法非常简单:
{% url 'View_Name' variable1 variable2 ... %}
这里的视图名称是在 urls.py 文件中分配给它的名称。变量 1、变量 2 等。是特定视图的输入参数。
1。创建视图
在 Views.py 中添加以下代码
def View1(request):
return render(request, 'page1.html')
现在，我们还将创建一个简单的视图，也接受用户输入的数据。将下面的 " " 也添加到您的文件中。
def View2(request,id):
return render(request, 'page2.html',{'id':id})
两个视图的 URL 路径都是:
path('page/', View1, name = 'webpage1'),
path('page/<int:id>', View2, name = 'webpage2'),
您可以在 Django views 文章中了解更多关于设置视图的信息。
2。创建模板文件
现在创建一个模板文件 "page1.html " ，并将代码添加到该文件中。
<h2> The Webpage 1 </h2>
<a href = "{% url 'webpage2' id=2 %}"> Click Here for book 2 </a>
让我们也创建 "page2.html" 。
<H2> The Webpage2 </H2>
<a href = "{% url 'webpage1' %}"> Go back </a>
实现 Django URL 标签
编码到此为止，现在让我们运行程序。因此，请到终端启动您的服务器。
python manage.py runserver
转到网址 "/ page":
Webpage 1
点击链接并检查
Webpage 2
就是这样，看看使用 URL 模板标签有多简单！！
结论
就这样，伙计们！！这都是关于 URL 模板标签的。请务必查看 Django 模板 的文章以及 DTL 的文章，了解更多关于模板的信息。
下一篇文章再见！！在那之前，继续编码吧！！
Django 用户认证——允许使用 Django 注册和登录
原文：https://www.askpython.com/django/django-user-authentication
在本文中，我们将学习 Django 用户认证以及相关的所有基础知识。但在此之前，让我们了解一下网站。
静态与动态网站
让我们快速看一下静态和动态网站的区别。
| 静态网站 | 动态网站 |
|---|---|
| 静态网站向用户显示固定信息 | 动态网站可以根据浏览者显示不同的信息 |
| 没有客户端-服务器交互 | 用户和服务器之间的大量数据交换 |
| 如果您不需要频繁更新数据，则更快、更便宜且易于维护 | 当我们需要用户与网站互动时，这是很重要的。使用正确的 CMS，动态网站可以快速且容易地维护 |
| 通过呈现 HTML、JS 和 CSS 文件直接显示服务器上的内容。 | 基于数据库上为用户存储的可用内容显示前端 |
用户认证
现在几乎所有的网站都有用户认证程序，你可以手动或者通过谷歌/脸书账号创建一个账号。典型的用户验证页面如下所示:
Facebook User Authentication Page
用户身份验证是一个重要的过程，因为它保护所有用户内容的安全，只有特定用户才能访问这些内容。在 Django 中，这是使用 django.contrib.auth 库完成的。
此外，根据可能的角色和权限，有不同类型的用户。
用户类型
尽管用户可以分为许多类别和类型，但是有两种主要的用户角色。对网站有编辑权限的用户和没有编辑权限的用户。
超级用户
你在管理站点的文章中遇到过超级用户。超级用户是项目的最高管理者，可以访问管理站点的所有内容。
他还可以删除其他普通用户。
普通用户
访问网站的人可以创建这种类型的用户帐户。例如，所有脸书和谷歌账户都属于这一类用户。
他们的权限会根据他们所扮演的角色类型而有所不同。超级用户/管理员决定分配给每个用户的权限。例如，在教室应用程序中，学生将拥有不同的权限，而教师将拥有其他附加权限。
使用 Django.contrib.auth 库进行认证
Django framework 有一个完整的身份验证库，称为 django.contrib.auth 库，内置来提供身份验证框架。
因此在本文中，我们使用内置的。auth 库本身。我们现在将研究该库提供的基本属性:
1)认证
基本语法是:
user = authenticate(request=None , credentials)
对于注册和登录 视图，authenticate 属性在语法上略有不同。在注册视图中，它只将请求凭证作为参数。
user = authenticate(username = "<username>", password = "<pasword>")
注意:用户名和密码是从请求本身获取的凭证。
- 在登录视图中，它需要一个请求凭证(用户名、密码)，以及存储的用户名和密码。
user = authenticate(request, username="<stored_username>",password ="<stored_password>")
这里，包含在“请求”中的请求凭证与存储在数据库中的用户名和密码凭证相匹配。只有当 crendentials 匹配时，用户才通过身份验证。
2)登录(请求，用户 _ 信息)
登录功能用于用户登录网站。语法:
login(request,user)
用户在哪里:
user = authenticate(username,password)
3) 注销(请求)
注销属性只是注销当前登录的用户。语法:
logout(request)
4) 认证表单
AuthenticatioForm 是预构建的表单，存在于 django.contrib.auth.forms 中。该表单显示在 web 应用程序的 django 登录页面上。显示的字段有:
- 用户名
- 密码
5) 创建认证表单
django.contrib.auth.forms 中的预构建表单显示在 django 注册页面上。表格中显示的字段有:
- 用户名
- 密码 1
- 密码 2 (密码确认字段)
现在我们知道了 auth 库包含什么，让我们深入到编码部分！！
Django 用户认证实践
好吧！！阅读部分到此为止，现在让我们把手弄脏吧。
一旦用户正确登录，我们应该有东西显示！！因此，让我们创建一个简单的视图和模板
1)样本视图代码
将简单的 BookView 代码添加到 views.py 文件中
from django.shortcuts import render
def books(request):
if request.user.is_authenticated:
return render(request, 'itemsapp/books.html')
else:
return redirect('/books/signin')
2)样本模板代码
我们将创建一个示例图书模板来显示图书列表:
<h> Welcome to the Book Website</h>
<h2>List of Books</h2>
<ul><h3> The Prodigal Daughter</h3></ul><br>
<ul><h3> Deception Point</h3></ul><br>
<ul><h3> Washington Times</h3></ul><br>
<ul><h3> Sherlock Holmes</h3></ul><br>
<ul><h3> The Cooper Intrigue</h3></ul><br>
<a href = "{% url 'logout' %}">Logout here</a>
3) 创建注册视图
在 Views.py 中，添加注册视图代码:
from django.contrib.auth import authenticate,login
from django.contrib.auth.forms import UserCreationForm
def signup(request):
if request.user.is_authenticated:
return redirect('/books')
if request.method == 'POST':
form = UserCreationForm(request.POST)
if form.is_valid():
form.save()
username = form.cleaned_data['username']
password = form.cleaned_data['password1']
user = authenticate(username = username,password = password)
login(request, user)
return redirect('/books')
else:
return render(request,'itemsapp/signup.html',{'form':form})
else:
form = UserCreationForm()
return render(request,'itemsapp/signup.html',{'form':form})
网页的注册模板将为:
<form method ='post'>
{% csrf_token %}
{{form.as_p}}
<input type="submit" value = "Submit">
</form>
<h3>Already Have an Account??</h3>
<a href = "{% url 'login' %}">Sign In Here</a>
4) 创建签到视图
现在在注册视图下面，将下面的登录视图添加到您的 views.py 中
from django.contrib.auth import authenticate,login
from django.contrib.auth.forms import AuthenticationForm
def signin(request):
if request.user.is_authenticated:
return redirect('/books')
if request.method == 'POST':
username = request.POST['username']
password = request.POST['password']
user = authenticate(request, username =username, password = password)
if user is not None:
login(request,user)
return redirect('/books')
else:
form = AuthenticationForm()
return render(request,'itemsapp/signin.html',{'form':form})
else:
form = AuthenticationForm()
return render(request, 'itemsapp/signin.html', {'form':form})
网页的登录模板将是:
<form method = 'post'>
{% csrf_token %}
{{form.as_p}}
<input type = "submit" value = "Submit">
</form>
<h3>Dont have an account??</h3><br>
<a href = "{% url 'signup' %}">SignUp Here</a>
5) 创建注销视图
最后，我们将把注销视图代码添加到视图. py 文件中:
from django.contrib.auth import logout
def signout(request):
logout(request)
return redirect('/books/signin/')
6)将 URL 映射到视图
上一节中编码的视图的 URL 路径将是:
path('books/signup/', signup, name ='signup'),
path('books/signin/', signin, name = 'login'),
path('books/signout/', signout, name = 'logout'),
代码的实现
现在我们已经看到了代码的每一个单独的部分，这里是 views.py 文件的最终代码。
from django.shortcuts import render,redirect
from django.contrib.auth import authenticate,login,logout
from django.contrib.auth.forms import AuthenticationForm,UserCreationForm
def signup(request):
if request.user.is_authenticated:
return redirect('/books')
if request.method == 'POST':
form = UserCreationForm(request.POST)
if form.is_valid():
form.save()
username = form.cleaned_data['username']
password = form.cleaned_data['password1']
user = authenticate(username = username,password = password)
login(request, user)
return redirect('/books')
else:
return render(request,'itemsapp/signup.html',{'form':form})
else:
form = UserCreationForm()
return render(request,'itemsapp/signup.html',{'form':form})
def signin(request):
if request.user.is_authenticated:
return redirect('/books')
if request.method == 'POST':
username = request.POST['username']
password = request.POST['password']
user = authenticate(request, username =username, password = password)
if user is not None:
login(request,user)
return redirect('/books')
else:
form = AuthenticationForm()
return render(request,'itemsapp/signin.html',{'form':form})
else:
form = AuthenticationForm()
return render(request, 'itemsapp/signin.html', {'form':form})
def signout(request):
logout(request)
return redirect('/books/signin/')
而 urls.py 的最终代码将是:
from django.contrib import admin
from django.urls import path,include
from .views import signup,signin,signout,books
urlpatterns = [
path('books/', books),
path('books/signup/', signup, name ='signup'),
path('books/signin/', signin, name = 'login'),
path('books/signout/', signout, name = 'logout'),
]
就是这样！！现在启动服务器，进入 "/books"
当你转到端点“books/”时，如果你没有被认证，它将首先把你重定向到登录网页。
Books Website
现在，如果您没有帐户，请单击下面的链接，您将看到注册网页。
Sign Up
填写详细信息，然后点击回车键，您将被重定向回该书的网页。现在您已经通过了身份验证，将会显示图书列表。
Books Webpage
完成后，您可以按“注销”,您将再次被重定向到登录网页。
瞧啊。！您现在有了自己的用户认证系统！！
结论
就这样，伙计们！！这都是关于用户认证以及如何实现它。我希望这篇文章能帮助您获得关于用户认证的知识。
下一篇文章再见！！在那之前继续练习！！
django Views——初学者指南
在本教程中，我们将更多地讨论 Django 视图，以及我们的网页可以有哪些类型的视图。
此外，我们将获得更多关于我们在上一篇关于 Django URL 映射的文章中在 views.py 中具体做了什么的信息。
究竟什么是视图？
视图函数或简单的视图可以被认为是一个 python 函数，它在接受请求时返回一个特定的响应。响应可以是任何内容，从简单的文本到 HTML 文件，再到图像等。
在典型的 web 应用程序中，我们有如下视图:
- 主页视图
- 详细信息/说明视图
- 帮助页面视图
- 常见问题视图
诸如此类。
每个视图都有一个可以请求的不同 URL 端点，它链接到 views.py 中的一个特定视图函数
现在我们将研究不同类型的视图。
Views
基于功能的视图
在这种类型中，视图被编写为 Python 函数，接受请求(HttpRequest)对象作为参数，并返回相应的响应(HttpResponse)。
基于 Django 函数的视图用于进行 CRUD 操作(创建、检索、更新和删除)。稍后你会学到更多。
因此，所有 4 个视图都有不同的视图–创建视图、检索视图、更新视图、删除视图
基于类的视图
顾名思义，视图是作为类而不是函数编写的，以返回对特定请求的 HTTP 响应。因此，在这种情况下，我们可以将所有的 CRUD 作为方法，从而将它们全部放在同一个视图中。
此外，基于类的视图被进一步分成许多类型，其中很少是重要的，我们将在接下来的文章中学习。
- 详细视图
- 列表视图
- 混合蛋白
既然我们正在处理响应，主要是 HTTP 响应，我们应该了解它们是什么。
HTTP 状态代码
这些 HTTP 属性用于向客户端提供有关 web 服务器响应的更多信息。我们需要学习的最常见和最常用的 HTTP 属性是:
1.HTTP 200–状态正常
这意味着状态是 OK 的，这可以被认为是一切都被正确地执行了。
2.HTTP 201–状态已创建
这意味着状态是 created，我们可以在 Create/POST 方法下使用它。
3.HTTP 400 错误的请求
这意味着服务器不会处理该请求。
4.HTTP 404–未找到
这意味着服务器无法找到它需要返回的响应
向视图添加 HTTP 属性
现在我们将在响应中添加 HTTP 属性。为此，我们使用名为 status 的函数。
在函数视图中，添加代码:
return HttpResponse("Hello World",status = 200)
HTTP Attributes
现在让我们看看 views.py 并了解我们在那里做什么。
Views.py
我们将在这里了解不同类型的视图。
1.以文本作为响应的视图
这里你可以看到我们使用基于函数的视图来编写 sayHello，Books，BookID 视图。
在这里的视图函数中，我们将请求作为参数，然后返回一个 HttpResponse('Hello World ')。
因此，基本上，我们发送回的响应只是单词 Hello World。
Text Response
就这样，我们现在可以运行服务器并测试代码了。
Runserver
Say Hello
现在让我们发送回一个简单的 HTML 行作为响应。
2.将 HTML 行和图像作为响应的视图
这里，我们将 HTML 代码存储在一个名为 HTML 的变量中。然后我们把它作为回应发送回去。在 HTML 代码中，我们发送了一个标题和一张名为Lena.jpg的图片
在函数 sayHello 中添加代码:
html = "<h1>Hello There This is a HTML file</h1><img src="lena.png" alt="picture" width = "104" height="142">
HTML Response
就这样，我们现在可以运行服务器并测试代码了。
Runserver
Html Response 1
因此，我们可以看到服务器运行良好。
结论
这就把我们带到了本文的结尾。现在，让我们进入下一部分。未来几天敬请关注更多关于 Python Django 和 Flask 的文章！
Python 中的文档测试——概述
原文：https://www.askpython.com/python-modules/doctests-in-python
让我们了解一下 Python 中一种特殊的测试和调试机制。Python 中的文档测试是函数的测试用例，它们可以用来验证函数是否按预期工作。
Python 中的 docstrings 是什么？
在我们继续进行文档测试之前，我们需要了解一下文档字符串。
- 文档字符串是包含在三重引号中的可选字符串，它是在声明函数时首先写入的。
- 文档字符串用于描述一个函数。我们可以写一个函数做什么，它是如何工作的，它接受的参数数量，它返回的对象类型，等等。
所有这些都向程序员描述了函数的用途，程序员可以使用__doc__属性访问函数的 docstring。
让我们举一个打印数字阶乘的函数的例子..
def factorial(num):
"""
A function that returns the factorial of a given number.
No. of arguments: 1, Integer
Returns: Integer
"""
res = 1
for i in range(1, num+1):
res *= i
print(res)
正如你所看到的，在声明函数之后，在做任何事情之前，我们写了一个用三重引号括起来的字符串来描述函数。
这将使该字符串成为该函数的文档，访问属性__doc__将返回该字符串。让我们现在做那件事。
print(factorial.__doc__)
输出:
A function that returns the factorial of a given number.
No. of arguments: 1, Integer
Returns: Integer
现在我们清楚了什么是 docstring，我们可以继续进行 doctests 了。
Python 中的 doctests 是什么？
正如我们前面讨论的，Python 中的 doctests 是在 docstring 内部编写的测试用例。在我们的例子中，5 的阶乘是 120，因此调用factorial(5)将打印120，同样，调用factorial(0)将打印1。
这些可以是我们可以验证函数的测试用例，为此，我们在 docstring 中使用如下语法描述它们:
def factorial(num):
"""
A function that returns the factorial of a given number.
No. of arguments: 1, Integer
Returns: Integer
>>> factorial(5)
120
>>> factorial(0)
1
"""
res = 1
for i in range(1, num+1):
res *= i
print(res)
如果您还记得 Python shell，我们将所有代码都写在 shell 中的三个尖括号(>>>)之后，当我们按 enter 键时，代码会立即执行。
因此，如果我们通过 Python shell 调用factorial(5),它看起来就像我们在上面的 docstring 中编写的一样。
在 docstring 中指定这一点告诉 Python，上面几行是在 shell 中运行factorial(5)后的预期输出。
类似地，下面我们写了factorial(0)的确切预期输出。
注意，doctests 对空格和制表符很敏感，所以我们需要准确地写出我们想要的结果。
我们还可以指定函数由于错误输入而可能返回的异常和错误。
现在我们已经在函数中编写了一些 doctests，让我们使用它们并检查函数是否正常工作。
Python 中成功的文档测试
import doctest
doctest.testmod(name='factorial', verbose=True)
这就是我们在 Python 中使用 doctests 的方式。我们导入一个名为doctest的模块，并使用它的testmod函数，如图所示。
输出将如下所示:
Trying:
factorial(5)
Expecting:
120
ok
Trying:
factorial(0)
Expecting:
1
ok
1 items had no tests:
factorial
1 items passed all tests:
2 tests in factorial.factorial
2 tests in 2 items.
2 passed and 0 failed.
Test passed.
TestResults(failed=0, attempted=2)
如您所见，它将运行每个测试用例，并检查实际输出是否与预期输出相匹配。最后，它将打印测试结果，程序员将能够分析该函数的执行情况。
如果任何一个测试用例失败，它将在预期的输出之后打印出准确的输出，并指定最后失败的测试用例的数量。
Python 中失败的文档测试
让我们用 Python 做一些我们知道会失败的文档测试:
def factorial(num):
"""
A function that returns the factorial of a given number.
No. of arguments: 1, Integer
Returns: Integer
>>> factorial(5)
120
>>> factorial(0)
1
>>> factorial(2)
Two
"""
res = 1
for i in range(1, num+1):
res *= i
print(res)
import doctest
doctest.testmod(name='factorial', verbose=True)
在第三个 doctest 中，发送2永远不会打印Two，所以让我们看看输出:
Trying:
factorial(5)
Expecting:
120
ok
Trying:
factorial(0)
Expecting:
1
ok
Trying:
factorial(2)
Expecting:
Two
**********************************************************************
File "__main__", line 13, in factorial.factorial
Failed example:
factorial(2)
Expected:
Two
Got:
2
1 items had no tests:
factorial
**********************************************************************
1 items had failures:
1 of 3 in factorial.factorial
3 tests in 2 items.
2 passed and 1 failed.
***Test Failed*** 1 failures.
TestResults(failed=1, attempted=3)
对于第三个测试用例，它失败了，模块准确地显示了它是如何失败的，最后，我们看到尝试了三个测试用例，一个失败了。
Python 中 Doctests 的使用？
Python 中的 Doctests 是为了在创建函数时考虑预期的输出而使用的。
如果你需要一个函数在调用时准确地输出一些内容，那么你可以在 doctest 中指定它，最后，doctest 模块将允许你一次运行所有的测试用例，你将能够看到这个函数是如何执行的。
提到的测试用例应该正是你所期望的，如果其中任何一个失败了，那就表明函数中有一个 bug 应该被纠正。
成品的文件测试必须总是成功的。
虽然我们不能编写每一个测试用例，但是在一个大项目中，编写那些可能由于意外输入而失败的测试用例是一个好主意，比如 0，9999999，-1，或者“banana”。
结论
在本教程中，我们学习了 Python 中的 doctests 是什么，如何编写，如何使用，以及何时使用。
我们讨论了 doctests 如何成为程序员的测试机制，以及它如何使编写测试用例变得容易。
我希望你学到了一些东西，并在另一个教程中看到你。
Python 中的点符号
原文：https://www.askpython.com/python/built-in-methods/dot-notation
今天我们来讨论一下 Python 中的点符号。如果你有一点用 Python 编程的经验，或者如果你一直在关注我们的 AskPython 博客，你应该会遇到术语面向对象编程。
它是一种基于现实世界对象概念的编程范式。每个对象都有描述其状态的特定属性和使它们执行特定任务的方法(相当于执行一个函数)。Python 就是这样一种语言。
在 Python 中，几乎每个实体都作为一个对象进行交易。了解这一点是理解点的重要性的基础。)批注。
什么是点符号？
简单来说，就是点(。)符号是访问不同对象类实例的每个方法的属性和方法的一种方式。
它通常位于对象实例之前，而点符号的右端包含属性和方法。
让我们用多个方法创建一个类，然后使用(。)符号来访问这些方法。
创建你的类和对象 :
class Person():
def __init__(self, name, age):
self.name = name
self.age = age
def sayHello(self):
print( "Hello, World" )
def sayName(self):
print( f"My name is {self.name}")
"""
First, we create a Person Class that takes two parameters: name, and age. This is an object.
The object currently contains two methods: sayHello() and sayName().
Now, we'll see how we can access those attributes and methods using dot notation from an instance of the class.
"""
现在我们的类已经准备好了，我们需要创建一个实例对象。
#We create an instance of our Person Class to create an object.
randomPerson = Person( "Marshall Mathers", 49)
#Checking attributes through dot notation
print( "Name of the person: " + randomPerson.name)
print( "Age of the person: " + str(randomPerson.age) + "years" )
#Accessing the attributes through dot notation
randomPerson.sayHello()
randomPerson.sayName()
在最后两行中，我们使用格式为<object name>和<method name>的类的对象来访问类中的方法。
输出:
Name of the person: Marshall Mathers
Age of the person: 49 years
Hello, World
My name is Marshall Mathers
希望上面的例子能消除你对 Python 中使用点符号的疑虑。
我们还在哪里使用点符号？
任何使用过 Python 的开发人员都遇到过(。)符号。这里有一些你过去一定遇到过的例子。
1.列表的索引
#A simple list called array with 3 elements
words = ['godzilla', 'darkness', 'leaving heaven']
#Getting the index of the list
words.index()
2.拆分字符串
#A random string
pun = "The movie Speed didn't have a director...Because if Speed had direction, it would have been called Velocity."
#We use the split method to separate the string into two sections on either side of "..."
print(pun.split("..."))
这是一些日常使用的点符号的例子。
结论
点符号不仅仅是一种访问内部方法的方式。这是一项复杂的技术，在确保完整功能的同时，保持代码的整洁和最小化。
Python 中如何计算点积？
原文：https://www.askpython.com/python-modules/numpy/dot-product
你好，初学者！在本文中，我们将看到 python 代码来寻找任何给定量的点积，比如向量或数组。Python 编程语言提供了几种方法来实现这一点，下面将讨论其中一些方法。
什么是点积？
首先，让我们了解一下“点积”
在数学中，点积(有时称为标量积)是一种代数运算，它从两个等长的数字序列中返回一个值。
这个单一值计算为两个序列中相应元素的乘积之和。这些序列可能是一维向量、多维向量或简单的数字。
让我们举个例子来理解这一点:
假设，两个向量 A 和 B 是二维数组
A = [ [1 2 ] [3 4] ]，B = [ [5 6] [7 8] ]
然后， A.B 给出为
[ [ 19 22] [ 43 50] ]
这计算为[[(1 * 5)+(2 * 7))((1 * 6)+(2 * 8))][((3 * 5)+(4 * 7))((3 * 6)+(4 * 8))]]
查找点积的 Python 代码
Python 提供了一种寻找两个序列的点积的有效方法，这就是 numpy 库的 numpy.dot() 方法。
Numpy.dot()是一种方法，它将两个序列作为参数，无论是向量还是多维数组，并打印结果，即点积。要使用这个方法，我们必须导入 python 的 numpy 库。让我们看几个例子:
示例 1:标量的点积
在本例中，我们将采用两个标量值，并使用 numpy.dot()打印它们的点积。
两个标量的点积是通过简单的相乘得到的。
比如说，两个标量 A = 7，B = 6，那么 A.B = 42
#importing numpy library
import numpy as np
#Taking two scalars
a = 3
b = 8
#calculating dot product using dot()
print("The dot product of given scalars = a.b =",np.dot(a,b))
上述代码的输出是:
The dot product of given scalars = a.b = 24
示例 2:数组的点积
这里，我们将采用两个数组。这些数组可以是一维、二维或多维的。在 dot()的帮助下，我们将计算它们的点积。我们正在考虑点积的两个二维数组。
二维数组的点积通过矩阵乘法来计算。
#importing numpy library
import numpy as np
#Taking two 2-D arrays
a = [ [1, 2], [3, 4]]
b = [ [7, 6], [5, 4]]
#calculating dot product using dot()
print("The dot product of given arrays :")
np.dot(a,b))
输出是:
The dot product of given arrays :
array( [ [17, 14],
[41, 34] ] )
注:
对于二维或多维数组，点积不可换。即 a.b 不等于 b.a 例 2 中，我们把点积算成了 a.b，而不是 b.a，这样会给出完全不同的结果。
结论
那么，Python 中计算点积不是很简单吗？有了可用的功能，当然是了。这是我的观点。我希望你理解了这篇文章。更多此类文章，敬请关注 https://www.askpython.com/
在那之前，学习愉快！🙂
Python 中的双端队列
原文：https://www.askpython.com/python/examples/double-ended-queue
双端队列是一种数据结构，用于存储应该在队列中的项目集合。它是队列数据结构的扩展，具有一些额外的特性。
先决条件:队列
一个队列是一个数据结构，用于以真实队列的方式存储一组项目。在真实的队列中，人们通常从后面进入，穿过队列后从前面退出。这被称为先进先出程序。
队列数据结构是一个类似实现的列表，其中所有数据都输入到列表的末尾，所有数据都从列表的开头删除。
推荐阅读——Python 中的双循环链表
在 Python 中实现双端队列
顾名思义，在双端队列中，可以从前端和后端添加和删除数据，但不能在队列中间添加或删除数据。双端队列也称为 deques。
我们现在将看到它在 python 中的实现。我们不会使用内置的collections包，相反，我们将自己实现它。
类别:德克
class Deque:
def __init__(self):
self.queue = []
self.count = 0
def __repr__(self):
str = ""
if self.count == 0:
str += "Double Ended Queue Empty."
return str
str += "Double Ended Queue:\n" + self.queue.__repr__()
return str
def insert_start(self, data):
if self.count == 0:
self.queue = [data,]
self.count = 1
return
self.queue.insert(0, data)
self.count += 1
return
def insert_end(self, data):
if self.count == 0:
self.queue = [data,]
self.count = 1
return
self.queue.append(data)
self.count += 1
return
def remove_start(self):
if self.count == 0:
raise ValueError("Invalid Operation")
x = self.queue.pop(0)
self.count -= 1
return x
def remove_end(self):
if self.count == 0:
raise ValueError("Invalid Operation")
x = self.queue.pop()
self.count -= 1
return x
def get(self, index):
if index >= self.count | index < 0:
raise ValueError("Index out of range.")
return self.queue[index]
def size(self):
return self.count
def display(self):
print(self)
return
这是双端队列的代码。有很多方法，让我们一个一个地讨论。
1。__init__和__repr__方法
在__init__方法中，我们声明了一个名为queue的列表，它将包含 deque，以及一个计数器来计算列表中的项数。
在__repr__方法中，我们创建了用于打印双端队列的字符串。
2。insert_start和insert_end方法
在insert_start方法中，我们简单地在列表queue的索引0处插入新元素，并增加列表中的条目数。
在insert_end方法中，我们简单地在列表queue中添加新的条目，并增加列表中条目的数量。
3。remove_start和remove_end方法
在remove_start方法中，我们检查列表是否为空，如果是，那么我们引发一个ValueError。之后，我们弹出索引0处的项目，递减count，并返回弹出的项目。
在remove_end方法中，我们也检查列表是否为空，如果是，那么我们引发一个ValueError。之后，我们弹出列表末尾的项目，递减count，并返回弹出的项目。
4。get、size和display方法
在get方法中，我们返回指定索引处的项目。如果指定的索引超出范围，那么我们引发一个ValueError。
在size方法中，我们简单地返回包含列表中项目数量的count。
在display方法中，我们打印 deque。
输出
让我们看看代码的输出:
Double Ended Queue Output
结论
在本教程中，我们看到了如何创建一个双端队列，我们用 python 实现了它，并看到了它的输出。希望你学得开心，下次教程再见。
Python 中的双向循环链表
原文：https://www.askpython.com/python/examples/doubly-circular-linked-list
双向循环链表是一种用于在列表中存储记录的数据结构。它与链表基本相同，但有一些额外的亮点。在本教程中，我们将看看什么是双向循环链表，如何用 Python 制作一个双向循环链表，以及它的输出是什么。
先决条件
在讨论双向循环链表之前，我们应该先讨论一些数据结构。
1。链接列表
链表是一个列表，其中的项目以特定的方式链接到其他项目。不同类型的链表有不同的链接方式。
最简单的链表是“单向链表”，或者简称为“链表”。在这种情况下，每个项目都链接到列表中的下一个项目。(但不是反过来)。所以要访问第 n 项，我们需要先访问第(n-1)项。并且访问第 n 项使我们能够访问列表的第(n+1)项。
我们可以直接访问列表中的第一项，使用它我们可以访问第二项，然后是第三项，依此类推，直到不能访问列表中任何其他项的最后一项。
链表中的每一项称为一个节点。每个节点都有一部分存储其数据，另一部分存储到下一个节点的链接/引用。
Singly Linked List Representation
2。双向链表
双向链表类似于链表，但是在这种情况下，每个节点有两个链接，一个链接到下一个节点，一个链接到前一个节点。
因此，要访问第 n 个节点，我们需要首先访问第(n-1)个节点或第(n+1)个节点。在我们访问了第 n 个节点后，使用它，我们可以访问第(n-1)个节点或第(n+1)个节点。也就是说，遍历可以发生在任一方向上。
每个节点由三部分组成，一部分用于数据，另外两部分用于上一个和下一个链接。它看起来像这样:
Doubly Linked List Representation
3。循环链表
循环链表也类似于链表，唯一的区别是最后一个节点链接到第一个节点，而不是没有链接。所以它在节点之间形成了一个循环链接，如果我们继续访问下一个节点，它将永远不会结束，并在第一个节点之后回到起点。
它看起来像这样:
Circular Linked List Representation
双循环链表
现在我们知道了双向链表和循环链表是什么样子，就不难理解双向循环链表会是什么样子了。
这里，每个节点包含三个部分，一个用于数据，另外两个用于链接。每个节点链接到列表的下一个和上一个节点。对于第一个节点，没有前一个节点，所以它进入一个循环，并链接到列表的最后一个节点。类似地，对于最后一个节点，没有下一个节点，所以它进入一个循环，并链接到列表的第一个节点。
要访问任何一个节点，我们要么需要访问它之后的节点，要么需要访问它之前的节点，访问任何一个节点之后，都可以直接访问它之前和之后的节点。但是我们也可以直接从第一个节点访问最后一个节点，反之亦然。
为了形象化，双向循环链表看起来像这样:
Doubly Circular Linked List Representation
在上面的例子中，您可以看到列表中有四个节点，每个节点都连接到它后面的一个节点和它前面的一个节点。最后一个节点指向倒数第二个节点和第一个节点，第一个节点指向最后一个节点和第二个节点。
头部指向列表的开头，现在我们可以向前遍历并到达末尾，也可以向后遍历并到达列表的开头。
在 Python 中实现双向循环链表
我们必须创建两个类，一个用于节点，另一个将使用节点来创建链表。
类别:节点
class Node:
def __init__(self, data = None):
self.data = data
self.previous = self
self.next = self
最初，在创建一个节点时，它会在两个方向上指向自己，形成一个只有一项的双向循环链表。
类:双向循环链表
class DCLL:
def __init__(self):
self.head = None
self.count = 0
def __repr__(self):
string = ""
if(self.head == None):
string += "Doubly Circular Linked List Empty"
return string
string += f"Doubly Circular Linked List:\n{self.head.data}"
temp = self.head.next
while(temp != self.head):
string += f" -> {temp.data}"
temp = temp.next
return string
def append(self, data):
self.insert(data, self.count)
return
def insert(self, data, index):
if (index > self.count) | (index < 0):
raise ValueError(f"Index out of range: {index}, size: {self.count}")
if self.head == None:
self.head = Node(data)
self.count = 1
return
temp = self.head
if(index == 0):
temp = temp.previous
else:
for _ in range(index - 1):
temp = temp.next
temp.next.previous = Node(data)
temp.next.previous.next, temp.next.previous.previous = temp.next, temp
temp.next = temp.next.previous
if(index == 0):
self.head = self.head.previous
self.count += 1
return
def remove(self, index):
if (index >= self.count) | (index < 0):
raise ValueError(f"Index out of range: {index}, size: {self.count}")
if self.count == 1:
self.head = None
self.count = 0
return
target = self.head
for _ in range(index):
target = target.next
if target is self.head:
self.head = self.head.next
target.previous.next, target.next.previous = target.next, target.previous
self.count -= 1
def index(self, data):
temp = self.head
for i in range(self.count):
if(temp.data == data):
return i
temp = temp.next
return None
def get(self, index):
if (index >= self.count) | (index < 0):
raise ValueError(f"Index out of range: {index}, size: {self.count}")
temp = self.head
for _ in range(index):
temp = temp.next
return temp.data
def size(self):
return self.count
def display(self):
print(self)
上面的类包含了很多方法，我们一个一个来讨论。
__init__法
我们声明两个成员，分别由None和0初始化的head和count,因为开始时列表中没有节点。
__repr__法
__repr__方法将返回一个字符串，该字符串将列表的内容适当地打印在屏幕上。
append``insert法
我们可以在列表中追加或插入节点。创建append方法只是为了方便，因为它调用insert方法并发送适当的值。
在insert方法中，我们首先检查index是否在范围内，如果不在，我们引发一个ValueError。然后，如果列表是空的，那么我们简单地给head分配一个新节点，并使count等于 1。现在，我们到达了刚好在index之前的节点，在那里新节点将被插入。
此时，我们让指定索引处的节点的previous等于新节点。然后，我们使新节点的next和previous分别等于指定索引处的节点和指定索引之前的节点。现在我们让指定索引之前的节点的next等于新节点。最后，如果指定的索引是0，那么我们让head指向它之前指向的节点。
只需增加count和insert方法就完成了。
remove法
在这个方法中，我们首先检查index是否超出范围，如果超出，抛出一个ValueError。然后，如果只有一个节点，我们简单地将head设为None，将count设为0，然后返回。
如果没有，我们到达需要删除的节点，如果目标节点是head，我们让head指向它后面的节点，这样我们就不会丢失列表。
最后，我们让指定索引之前的节点的next指向指定索引之后的节点，我们让指定索引之后的节点的previous指向指定索引之前的节点。这将使列表中指定索引处的节点不可达(基本上被跳过)，我们递减计数以完成该方法。
index``get``size``display方法
index方法在列表中进行线性搜索，如果找到条目，则返回索引，否则返回None。
get方法返回指定索引处的项目，如果索引超出范围，则引发ValueError。
size方法返回列表中的项目数。
display方法打印列表。
输出
Output for the initialization, insertion, and append methods
Output for remove, index, get, size, and display methods.
结论
在本教程中，我们详细研究了双向循环链表，并用 Python 实现了它。希望你喜欢学习它，并在下一个教程中看到你。
Python 中的双向链表——变得简单
原文：https://www.askpython.com/python/examples/doubly-linked-list
双向链表是一种用于存储列表的数据结构。它非常类似于链表，但是有一些额外的特性。在本教程中，我们将讨论什么是双向链表，我们将在 python 中实现它，并查看它的输出。
先决条件:链表
在我们继续讨论双向链表之前，我们需要讨论什么是链表。
顾名思义，链表是一种列表，其中的列表项以特定的方式链接到其他列表项。在不同类型的链表中，项目链接的确切方式是不同的。
最常见的链表是“单向链表”，或者简称为“链表”，在这种情况下，每一项都链接到列表中的下一项。因此，要访问第 10 项，我们需要首先访问第 9 项，因为它链接到第 10 项。一旦我们访问第 10 项，它将允许我们通过第 10 项拥有的链接访问第 11 项。
链表中的每一项称为一个节点。在单链表中，每个节点有两部分。第一部分存储该节点的数据，第二部分存储到下一个节点的链接。
现在让我们看看双向链表。
什么是双向链表？
双向链表也是一种通过链接来连接节点的链表，但是在这种情况下，每个节点都链接到前一个项目以及下一个项目。因此，一旦我们访问了第 10 个节点，我们就可以访问第 9 个节点和第 11 个节点，要访问特定的节点，我们需要访问它之前的节点或之后的节点。
我们这样做的方法是每个节点有三个部分。第一部分是要存储的实际数据，第二部分是到列表中上一个节点的链接，第三部分是到列表中下一个节点的链接。
拥有两个链接的好处是，它使得像追加和删除这样的操作比单链表更容易和更快。
为了形象化，双向链表看起来像这样:
Doubly Linked List Representation
在上面的例子中，你可以看到链表中有四个条目/节点。每个节点都有一些数据或内容，并且每个节点都指向/链接到列表的下一个和上一个节点。第一个节点的上一个链接和最后一个节点的下一个链接不指向任何东西，所以它们存储None(在 python 的情况下)。
首先，列表头指向列表中的第一个节点，列表尾指向列表中的最后一个节点。因此可以通过它们直接访问第一个和最后一个节点。为了到达其他节点，我们或者穿过头部或者尾部，然后随后分别访问下一个或者前一个节点，直到我们到达目标。
在 Python 中实现双向链表
创建双向链表非常简单。我们必须创建两个类，一个类用于节点，另一个类将使用第一个类创建的节点创建链表。
1.类别:节点
对于节点类，我们在类中只有三个成员。一个存储数据，一个存储下一个节点，一个存储上一个节点。
该类的定义如下所示:
class Node:
def __init__(self, data = None):
self.data = data
self.next = None
self.previous = None
在这里，最初，节点不指向任何其他节点，它可能有也可能没有数据，这取决于它是如何创建的。
2。类:双向链表
这个类将包含比节点类更多的内容。它将包含头节点、尾节点、列表中的项数，以及许多必要的方法，如插入新节点、删除现有节点、搜索现有节点和打印列表的方法。
这个类看起来会像这样:
class DLL:
def __init__(self):
self.head = None
self.tail = None
self.count = 0
def __repr__(self):
string = ""
if(self.head == None):
string += "Doubly Linked List Empty"
return string
string += f"Doubly Linked List:\n{self.head.data}"
start = self.head.next
while(start != None):
string += f" -> {start.data}"
start = start.next
return string
def append(self, data):
if self.head == None:
self.head = Node(data)
self.tail = self.head
self.count += 1
return
self.tail.next = Node(data)
self.tail.next.previous = self.tail
self.tail = self.tail.next
self.count += 1
def insert(self, data, index):
if (index > self.count) | (index < 0):
raise ValueError(f"Index out of range: {index}, size: {self.count}")
if(index == self.count):
self.append(data)
return
if(index == 0):
self.head.previous = Node(data)
self.head.previous.next = self.head
self.head = self.head.previous
self.count += 1
return
start = self.head
for _ in range(index):
start = start.next
start.previous.next = Node(data)
start.previous.next.previous = start.previous
start.previous.next.next = start
start.previous = start.previous.next
self.count += 1
return
def remove(self, index):
if (index >= self.count) | (index < 0):
raise ValueError(f"Index out of range: {index}, size: {self.count}")
if index == 0:
self.head = self.head.next
self.head.previous = None
self.count -= 1
return
if index == (self.count - 1):
self.tail = self.tail.previous
self.tail.next = None
self.count -= 1
return
start = self.head
for i in range(index):
start = start.next
start.previous.next, start.next.previous = start.next, start.previous
self.count -= 1
return
def index(self, data):
start = self.head
for i in range(self.count):
if(start.data == data):
return i
start = start.next
return None
def size(self):
return self.count
def display(self):
print(self)
上面的类有很多成员，让我们一个一个讨论。
3。__init__法
在构造函数中，我们声明了三个变量。head和tail用None初始化，这意味着开始时列表中没有变量，所以count也用0初始化。
4。__repr__法
repr 方法将返回打印链表的字符串。所以要么这个列表是空的，在这种情况下我们打印它，要么这个列表不是空的，所以我们逐个打印每个节点中的数据。
5。append和insert方法
在这个实现中，我们可以在指定的位置追加或插入节点。为了追加，我们将检查列表是否为空，如果是，那么head和tail可以指向新的节点。否则，我们将使最后一个节点的next指向新节点，然后使新节点的previous指向最后一个节点，最后，使tail指向新节点。
要在指定的位置插入，如果位置在末尾，那么我们只追加节点，否则，如果位置在开头，那么我们让第一个节点的previous指向新节点，然后让新节点的next指向第一个节点，最后，我们让head指向新节点。
如果指定的位置在中间，那么我们首先到达那个位置，使那个位置之前的节点的next指向新节点，然后使新节点的previous指向那个位置之前的节点，然后使新节点的next指向那个位置的节点，最后，我们使那个位置的节点的previous指向新节点。
我们还检查给定的索引是否有效，如果无效，我们可以引发一个ValueError。此外，我们在每次成功的插入操作后增加count。
⑥。remove法
要移除一个项目，我们必须指定要从哪里移除该项目。如果指定的索引超出范围，我们就抛出一个ValueError。如果索引为 0，我们将删除第一项，为此，我们让head指向第二个节点。如果head为空，意味着列表现在为空，如果不是，那么我们必须创建新的head的previous商店None。
类似地，如果索引比列表的大小小 1，这意味着我们必须删除最后一项，所以我们让tail指向倒数第二个节点，然后让新的tail的next存储None。
如果索引在中间某处，我们先到达那个位置，然后让那个位置之前的节点的next指向那个位置之后的节点，最后让那个位置之后的节点的previous指向那个位置之前的节点。
在移除过程中，我们只是使节点从列表中不可访问，而将它从内存中移除的实际过程留给了 Python 的垃圾收集模块。
7。index、size和display方法。
index方法用于搜索列表中的项目，我们根据列表大小遍历整个列表，如果找到目标就返回索引。如果没有，我们返回None。
size方法返回该类的count成员的值，该成员存储列表中的项目数。
而display方法打印对象，对象调用__repr__方法，返回的字符串被打印到屏幕上。
输出
在对该类执行多条语句后，输出如下:
Example illustrating initialization, append method, and insert method.
Example illustrating remove method, index method, size method, and display method.
结论
在本教程中，我们学习了双向链表，并用 Python 实现了它。我们从理解单向链表的工作开始，然后我们讨论了双向链表的不同之处。我们用 python 编写了数据结构的代码，并讨论了每个方法的工作原理，最后我们查看了代码的输出。
我希望你在学习中过得愉快，下次教程再见。
使用 OpenCV 绘制形状——一个完整的操作指南
原文：https://www.askpython.com/python/examples/draw-shapes-using-opencv
你好。你曾经希望在你每隔一天绘制的 matplotlib 图上绘制吗？嗯，这个愿望在这个教程中实现了！今天，我们将学习如何在地块上绘制各种对象。
我们开始吧！
也读:用 Python OpenCV【易导】 用网络摄像头现场素描
OpenCV 简介
首先， OpenCV 自带很多画图功能，可以画几何图形，甚至可以在图像上写文字。
Draw On Image Sample
在做任何事情之前，让我们从介绍我们将在教程中使用的绘图函数开始。
这些功能如下所列:
cv2.line:该功能用于在图像上画一条直线，从指定的(x，y)坐标对开始，到另一个(x，y)坐标对结束。cv2.circle:该功能用于在由(x，y)坐标给出的中心和半径长度指定的图像上画一个圆。cv2.rectangle:该功能有助于在(x，y)坐标形式的左上角和右下角指定的图像上绘制一个矩形。
用 OpenCV 在 Python 中绘制形状
现在我们已经清楚了在本教程结束时会发生什么样的魔法，让我们继续我们的魔法吧！
步骤 1:导入模块/库
在这一步，我们需要导入使用 OpenCV 在图像上绘图所需的所有必要的模块和库。显而易见的模块是cv2，与此同时，我们还有两个支持模块，即numpy和matoplotlib模块。
最后，我们要把剧情风格改成seaborn来获得更干净的剧情。
import cv2
import numpy as np
from matplotlib import pyplot as plt
plt.style.use('seaborn')
第二步:创建一个黑色的画布
为了画任何东西，我们需要一块画布。在这种情况下，我们将使用一个尺寸为512 x 512的图像，用单一的纯色填充(在这种情况下是黑色)。
为了达到这个目的，我们使用了 numpy。置零并将所有像素值设置为零，以使它们全部为黑色。
canvas = np.zeros((512,512,3), np.uint8)
plt.axis('off')
plt.title("Blank Canvas")
plt.imshow(cv2.cvtColor(canvas, cv2.COLOR_BGR2RGB))
plt.show()
Original Blank Canvas
第三步:在画布上画一条线
为了画一条线，我们将使用cv2.line函数，它需要一些属性，包括所创建的画布对象的名称、直线的起点和终点坐标、使用 RGB 元组的线的颜色。
看看下面提到的代码，在你的画布上画一条绿色的斜线。
canvas = np.zeros((512,512,3), np.uint8)
cv2.line(canvas, (0,0), (511,511), (0,255,0),50)
plt.imshow(cv2.cvtColor(canvas, cv2.COLOR_BGR2RGB))
plt.title('Green Straight Linear line')
plt.axis('off')
plt.show()
Straight Line Canvas OpenCV
步骤 4:在画布上画一个矩形
为了绘制矩形，我们使用了cv2.rectangle方法。该方法与cv2.line方法相同，并采用矩形的以下属性:
- 正在其上绘制矩形的画布
- 矩形的左上角坐标
- 矩形的右下角坐标
- 以 RGB 元组的形式提及矩形的颜色
- 最后一个参数是矩形边框的厚度
同样的代码和输出如下所示。
canvas = np.zeros((512,512,3), np.uint8)
cv2.rectangle(canvas, (100,100), (300,250), (255,0,0), 20)
plt.imshow(cv2.cvtColor(canvas, cv2.COLOR_BGR2RGB))
plt.title('Blue Rectangle on the Canvas')
plt.axis('off')
plt.show()
Rectangle Canvas OpenCV
现在，如果我们想要一个完全填充的矩形。为了实现这一点，我们使厚度为负或使用cv2.FILLED关键字。
canvas = np.zeros((512,512,3), np.uint8)
cv2.rectangle(canvas, (100,100), (300,250), (0,0,255), -1)
plt.imshow(cv2.cvtColor(canvas, cv2.COLOR_BGR2RGB))
plt.title('Red Filled Rectangle on the Canvas')
plt.axis('off')
plt.show()
Filled Rectangle Canvas OpenCV
第五步:在画布上画一个圆
为了画圆，我们使用了cv2.circle方法。该方法需要以下属性:
- 正在其上绘制圆的画布
- 需要绘制的圆的中心
- 圆的半径
- 以 RGB 元组形式提及圆的颜色
- 最后一个参数是圆的边界的厚度
同样的代码和输出如下所示。
canvas = np.zeros((512,512,3), np.uint8)
cv2.circle(canvas, (350, 350), 100, (15,75,50), 20)
plt.imshow(cv2.cvtColor(canvas, cv2.COLOR_BGR2RGB))
plt.title('Olive Color Circle Drawn')
plt.axis('off')
plt.show()
Circle Canvas OpenCV
绘制实心圆类似于在画布上绘制实心矩形。看看下面的代码和输出。
canvas = np.zeros((512,512,3), np.uint8)
cv2.circle(canvas, (350, 350), 100, (155,175,250), -1)
plt.imshow(cv2.cvtColor(canvas, cv2.COLOR_BGR2RGB))
plt.title('Peach Color Filled Circle Drawn')
plt.axis('off')
plt.show()
Filled Circle Canvas OpenCV
使用 OpenCV 在 Python 中绘制形状的完整代码
既然我们已经学会了在画布上画出基本的形状。让我们用下面提到的代码在支线剧情的帮助下可视化所有剧情。
import cv2
import numpy as np
from matplotlib import pyplot as plt
plt.style.use('seaborn')
plt.figure(figsize=(10,10))
canvas = np.zeros((512,512,3), np.uint8)
plt.subplot(3,3,1)
plt.axis('off')
plt.title("Blank Canvas")
plt.imshow(cv2.cvtColor(canvas, cv2.COLOR_BGR2RGB))
plt.subplot(3,3,2)
canvas = np.zeros((512,512,3), np.uint8)
cv2.line(canvas, (0,0), (511,511), (0,255,0),50)
plt.imshow(cv2.cvtColor(canvas, cv2.COLOR_BGR2RGB))
plt.title('Green Straight Linear line')
plt.axis('off')
plt.subplot(3,3,3)
canvas = np.zeros((512,512,3), np.uint8)
cv2.rectangle(canvas, (100,100), (300,250), (255,0,0), 20)
plt.imshow(cv2.cvtColor(canvas, cv2.COLOR_BGR2RGB))
plt.title('Blue Rectangle on the Canvas')
plt.axis('off')
plt.subplot(3,3,4)
canvas = np.zeros((512,512,3), np.uint8)
cv2.rectangle(canvas, (100,100), (300,250), (0,0,255), -1)
plt.imshow(cv2.cvtColor(canvas, cv2.COLOR_BGR2RGB))
plt.title('Red Filled Rectangle on the Canvas')
plt.axis('off')
plt.subplot(3,3,5)
canvas = np.zeros((512,512,3), np.uint8)
cv2.circle(canvas, (350, 350), 100, (15,75,50), 20)
plt.imshow(cv2.cvtColor(canvas, cv2.COLOR_BGR2RGB))
plt.title('Olive Color Circle Drawn')
plt.axis('off')
plt.subplot(3,3,6)
canvas = np.zeros((512,512,3), np.uint8)
cv2.circle(canvas, (350, 350), 100, (155,175,250), -1)
plt.imshow(cv2.cvtColor(canvas, cv2.COLOR_BGR2RGB))
plt.title('Peach Color Filled Circle Drawn')
plt.axis('off')
plt.tight_layout()
plt.show()
Final Output Draw On Canvas
结论
我希望你理解这个概念，并喜欢输出。尝试使用相同的基本形状制作风景或卡通人物，并对结果感到惊讶。
编码快乐！😇
想了解更多？查看下面提到的教程:
如何使用 Tkinter 绘制不同的形状
原文：https://www.askpython.com/python-modules/tkinter/draw-shapes
在本教程中，我们将学习如何绘制不同的形状，如正方形，圆形，矩形，椭圆形，弧形等。在 Tkinter 中，画布类用于在我们的应用程序窗口中绘制不同的形状。绘制形状的函数是在 canvas 类中定义的，所以我们需要首先定义 canvas 类。
按照下面的循序渐进的教程，使用 Tkinter 在 Python GUI 中绘制不同的形状。
设置 Tkinter
要安装 Tkinter 模块，请在终端中运行以下命令。
pip install tk
为了导入已安装的模块，我们使用*导入 Tkinter 库中的所有方法:
from tkinter import *
在 Python Tkinter 画布中绘制形状
首先，我们需要初始化Tkinter 和 canvas 类。 Tkinter Canvas 类包含了创建不同形状的每一种方法。
root = Tk()
canvas = Canvas()
root.mainloop()
初始化 Tkinter 和 canvas 类后，我们开始绘制不同的形状
1.卵形的
使用 create_oval() 方法可以很容易地画出椭圆形。这个方法需要坐标、颜色、轮廓、宽度等。作为一个参数。所有的形状都是在一个我们提供坐标的盒子里创建的。
create_oval(x0, y0, x1, y1)
Circle Inside Square In Tkinter
在上面的代码中，我们设置了盒子的坐标，这样它就成了一个完美的正方形，在这个正方形里面，我们就有了一个完美的圆。
canvas.create_oval(10, 10, 80, 80, outline = "black", fill = "white",width = 2)
canvas.pack()
Draw Oval In Tkinter
2.圆
没有创建圆的特殊函数，它是使用 create_oval()函数绘制的。我们只需要保持水平长度和垂直长度相同。数学上，意味着形状(圆)的半径等于边界(直径)的所有边。
canvas.create_oval(110,10,210,110,outline = "black",fill = "white",width = 2)
canvas.pack()
Draw Cicle In Tkinter
3.正方形或长方形
通过使用 create_rectangle 方法，我们绘制了一个矩形和正方形。这里我们通过形状的边/边，因此也可以用同样的方法画一个正方形(所有边相等)。
canvas.create_rectangle(10,10,110,110,outline ="black",fill ="white",width = 2)
canvas.create_rectangle(210,10,310,210,outline ="black",fill ="white",width =2)
canvas.pack()
Draw Square Or Rectangle In Tkinter
4.多边形
我们可以画任意多的顶点。我们使用 create_polygon() 方法，该方法获取边的坐标，并相应地将它们呈现在主窗口上。在下面的代码中，我们创建了一个坐标列表，并将其传递给 create_polygon 方法。
#points for the vertices in x1,y1,x2,y2, and so on
points = [150, 100, 200, 120, 240, 180, 210, 200, 150, 150, 100, 200]
canvas.create_polygon(points, outline = "blue", fill = "orange", width = 2)
canvas.pack()
Draw Polygon Using Tkinter
5.弧
我们通过使用 create_arc 方法创建弧形。
| canvas.create_arc(30，200，90，100，extent =210，outline = "黑色"，fill = "白色"，width =2) |
Draw Arc Using Tkinter
创建方法中使用的不同参数
- 轮廓:- 轮廓用于定义形状轮廓的颜色。
- 填充:- 填充就像微软画图中的油漆桶工具。它用我们指定的颜色填充形状。
- 宽度:- 用于设置轮廓的宽度。
结论
这就是使用 Tkinter 创建形状的基本教程。继续探索帮助您在 Python Tkinter 中绘制不同形状和线条的功能，以创建更高级的形状和图案。
蟒蛇龟——用蟒蛇皮画一条鱼
原文：https://www.askpython.com/python/examples/drawing-a-fish-in-python-turtle
嘿编码器！在本教程中，我将向你展示如何在 python turtle 模块的帮助下画一条鱼。如果你不知道什么是turtle模块，在查看教程。
您需要导入 Python 附带的 turtle 库，不需要做任何额外的安装。
import turtle
下一步包括创建一个画布来绘制鱼。我们可以根据需要给 canvas 变量命名。现在，我们将屏幕的名称命名为fish_scr。下面的代码为用户创建和显示屏幕。我们还添加了一些额外的属性，包括屏幕和笔的颜色。
import turtle
fish_scr = turtle
fish_scr.color('black')
fish_scr.Screen().bgcolor("#85C1E9")
现在让我们创建一个为我们画鱼的函数。这个函数的名字是Draw_Fish，它将在屏幕上为我们画出这条鱼。goto函数将指针指向某个位置。penup和pendown功能控制何时绘制和何时不绘制。另外，forward和backward功能需要距离作为参数，另一方面，left和right功能需要转动角度作为参数。
def Draw_Fish(i,j):
fish_scr.penup()
fish_scr.goto(i,j)
fish_scr.speed(10)
fish_scr.left(45)
fish_scr.pendown()
fish_scr.forward(100)
fish_scr.right(135)
fish_scr.forward(130)
fish_scr.right(130)
fish_scr.forward(90)
fish_scr.left(90)
fish_scr.right(90)
fish_scr.circle(200,90)
fish_scr.left(90)
fish_scr.circle(200,90)
fish_scr.penup()
fish_scr.left(130)
fish_scr.forward(200)
fish_scr.pendown()
fish_scr.circle(10,360)
fish_scr.right(270)
fish_scr.penup()
fish_scr.forward(50)
fish_scr.pendown()
fish_scr.left(90)
fish_scr.circle(100,45)
fish_scr.penup()
fish_scr.forward(300)
fish_scr.left(135)
fish_scr.pendown()
fish_scr.right(180)
让我们用下面的代码在屏幕上画三条鱼。在我们画完鱼后，我们将使用done功能关闭应用程序屏幕。
Draw_Fish(0,0)
Draw_Fish(150,150)
Draw_Fish(150,-150)
fish_scr.done()
完整代码
import turtle
fish_scr = turtle
fish_scr.color('black')
fish_scr.Screen().bgcolor("#85C1E9")
def Draw_Fish(i,j):
fish_scr.penup()
fish_scr.goto(i,j)
fish_scr.speed(10)
fish_scr.left(45)
fish_scr.pendown()
fish_scr.forward(100)
fish_scr.right(135)
fish_scr.forward(130)
fish_scr.right(130)
fish_scr.forward(90)
fish_scr.left(90)
fish_scr.right(90)
fish_scr.circle(200,90)
fish_scr.left(90)
fish_scr.circle(200,90)
fish_scr.penup()
fish_scr.left(130)
fish_scr.forward(200)
fish_scr.pendown()
fish_scr.circle(10,360)
fish_scr.right(270)
fish_scr.penup()
fish_scr.forward(50)
fish_scr.pendown()
fish_scr.left(90)
fish_scr.circle(100,45)
fish_scr.penup()
fish_scr.forward(300)
fish_scr.left(135)
fish_scr.pendown()
fish_scr.right(180)
Draw_Fish(0,0)
Draw_Fish(150,150)
Draw_Fish(150,-150)
fish_scr.done()
当我们执行上面的代码时，一个新的屏幕出现在系统屏幕上，鱼开始在应用程序的屏幕上绘制。同样如下图所示。
恭喜你！现在你知道如何使用 Python 中的 Turtle 模块在屏幕上画一条鱼了。感谢您的阅读！如果您喜欢本教程，我建议您也阅读以下教程:
继续阅读，了解更多！编码快乐！😄
Tkinter 教程-使用 Tkinter 画布绘制直线
原文：https://www.askpython.com/python-modules/tkinter/drawing-a-line-tkinter-canvas
大家好！在这个 Tkinter 教程中，我们将学习如何使用内置函数绘制不同的线条。这是学 Tkinter 的学生忘记然后把事情搞得很乱的主要概念之一。所以，让我们保持简单甜蜜，让我们开始吧。
Tkinter 中的画布是什么？
现在，在画图等不同的绘图应用中，主要的白色屏幕是画布。这个画布是保存我们的形状、笔画、草图和其他东西的主要窗口。同样，使用 Tkinter 在画布上绘制形状。主要的方法是，我们需要先设置它，然后再做进一步的修改。
设置 Tkinter 画布的规则
- 背景应设置为白色。
- 分辨率应小于主窗口的分辨率。
- 分辨率应足以管理和容纳其自身内的所有形状。
- 通过内置函数绘制形状时，始终给出合适的坐标点。
这是四条基本规则，我们将利用它们来实现图形绘制。
架起我们的帆布
我们使用 Canvas 类，并赋予它高度、宽度和背景颜色。
代码:
from tkinter import Canvas
from tkinter import *
window = Tk()
window.title("Canvas") # giving title to window
window.config(bg = "grey")
window.geometry("400x400") # setting up the geometry
window.resizable(False, False) # disabling the resize option from x-y sides
my_canvas = Canvas(width = 350, height = 350, bg = "white") # canvas object to create canvas
my_canvas.pack(pady = 20) # padding it 20 pixels below from margin of window
window.mainloop()
输出:
A Canvas Window
说明:
- 从 Tkinter 导入 Canvas 类。
- 前五行是我们主窗口的基本设置。
- 在第六和第七行中，我们创建了画布的一个实例。
- 我们给出的高度和宽度是 350。
- 将背景颜色设置为白色。
- 然后通过应用 pack()函数中值为 20 的“pad-y”参数将窗口移向中心。
- 然后运行主循环来显示应用程序
使用面向对象的方法，我们将创建一个简单的线抽屉应用程序。目前，上面的代码只是一个示例。
Tkinter 的 Canvas 类中的 Shape 函数
Tkinter 集成了几个函数，帮助我们绘制形状。它们可以帮助我们画出:
- 圆圈
- 椭圆形
- 省略号
- 线条
- 方格
- 三角形 等等
如何在画布上绘制形状
Axes of Tkinter’s Canvas
当我们在画一条线或者一个形状的时候，然后在调用函数的时候，我们需要给 (x1，y1)和(x2，y2) 作为参数。这些决定了特定形状在画布上的位置。
记住给定画布屏幕分辨率内的坐标。因为，如果点消失了，我们就看不到屏幕里面的形状和物体。
使用 create_line()函数绘制直线
这个函数/方法用于在画布上画线。以下是基本参数:
canvas_object.create_line(x1, y1, x2, y2, fill = "color_name")
代码:
from tkinter import *
window = Tk()
window.geometry("400x400")
window.config(bg = "grey")
window.title("Canvas - Draw Line")
window.resizable(False, False)
# creating Canvas
canvasScreen = Canvas(window, width = 350, height = 350, bg = "white")
canvasScreen.pack(pady = 20)
canvasScreen.create_line(50, 0, 200, 350, fill = "red")
window.mainloop()
输出:
Drawing a line
说明:
- 我们创建一个 canvasScreen 实例，宽度= 350，高度= 350。
- 然后使用同一个对象，我们调用 create_line()函数。
- 然后我们可以给出必要的 x-y 坐标。我们使用填充参数给线条上色。我们把它命名为红色的。
- 最后使用主循环来显示 GUI 窗口。
我们可以通过多次调用 create_line()函数来绘制尽可能多的线条。 下面是一组更多的代码来绘制随机线条图案:
from tkinter import *
window = Tk()
window.geometry("400x400")
window.config(bg = "grey")
window.title("Canvas - Draw Line")
window.resizable(False, False)
# creating Canvas
canvasScreen = Canvas(window, width = 350, height = 350, bg = "white")
canvasScreen.pack(pady = 20)
canvasScreen.create_line(0, 100, 100, 350, fill = "red")
canvasScreen.create_line(150, 0, 150, 250, fill = "green")
canvasScreen.create_line(0, 40, 200, 100, fill = "green")
window.mainloop()
输出:
Random Lines
使用类和对象
from tkinter import Canvas
from tkinter import *
class window(Tk):
def __init__(self, width, height):
self.window = Tk()
self.window.title("Canvas") # giving title to window
self.window.config(bg = "grey")
self.window.geometry(str(width) + "x" + str(height)) # setting up the geometry
self.window.resizable(False, False) # disabling the resize option from x-y sides
def create_canvas(self, wd, ht):
self.my_canvas = Canvas(width = wd, height = ht, bg = "white") # canvas object to create canvas
self.my_canvas.pack(pady = 20) # padding it 20 pixels below from top margin of window
return self.my_canvas
def drawLine(self, x1, y1, x2, y2, color):
return self.my_canvas.create_line(x1, y1, x2, y2, fill = color)
def run_app(self):
self.window.mainloop()
win = window(400, 400)
win.create_canvas(350, 350)
win.drawLine(0, 150, 340, 200, "green")
win.drawLine(150, 0, 340, 300, "green")
win.run_app()
输出:
Intersecting Lines
结论
这就是我们使用 Tkinter 对 Canvas 和 draw line 函数所能做的一切。这是一个有趣的话题，可以在你的 Github 个人资料上了解并展示一些很酷的项目。
用 Python 中的乌龟画汽车
原文：https://www.askpython.com/python/examples/drawing-car-using-turtle-in-python
嘿编码器！在本教程中，我将教你如何在 python 海龟库的帮助下绘制自己的汽车。如果你不知道turtle模块，在查看教程。
使用 Python Turtle 绘制汽车的步骤
您需要导入 Python 附带的 turtle 库，不需要做任何额外的安装。
import turtle
下一步包括创建一个应用程序屏幕来绘制汽车。我们可以随意命名这个窗口。对于本教程，我们将屏幕名称保留为car_scr。
下面的代码创建和定制屏幕，包括屏幕和笔的颜色。
import turtle
car_scr = turtle
car_scr.color('black')
car_scr.Screen().bgcolor("#ABEBC6")
现在让我们创建一个为我们绘制汽车的函数。这辆汽车有许多不同的部分，如上部车身、车轮和窗户。我们将一个接一个地分别画出它们。
在函数Draw_Car内部，我们需要给函数一个起始坐标作为参数。然后goto函数将指针指向我们传递给它的位置。
您可能熟悉 Draw_Car 函数中使用的函数。我将在下面介绍它们的工作原理:
penup&pendown——控制什么时候画，什么时候不画。fillcolor、begin_fill和end_fill–控制特定图形的颜色forward&backward和left&right——帮助在屏幕上以特定的方向或角度进行绘制。
使用 Python Turtle 创建汽车底座
让我们首先使用下面的代码绘制汽车的上部。看看输出结果有多好。
def Draw_Car(i,j):
# Drawing the Upper Body
car_scr.fillcolor("#2980B9")
car_scr.penup()
car_scr.goto(i,j)
car_scr.pendown()
car_scr.begin_fill()
car_scr.forward(370)
car_scr.left(90)
car_scr.forward(50)
car_scr.left(90)
car_scr.forward(370)
car_scr.left(90)
car_scr.forward(50)
car_scr.end_fill()
Draw Car Upper Body
画车窗
我们将调用函数并传递起始的 x 和 y 值。让我们调用Draw_Car(-200,0)的函数。现在我们将使用如上所示的非常相似的代码来绘制窗口。看看下面的代码。
def Draw_Car(i,j):
# Drawing the Upper Body
car_scr.fillcolor("#2980B9")
car_scr.penup()
car_scr.goto(i,j)
car_scr.pendown()
car_scr.begin_fill()
car_scr.forward(370)
car_scr.left(90)
car_scr.forward(50)
car_scr.left(90)
car_scr.forward(370)
car_scr.left(90)
car_scr.forward(50)
car_scr.end_fill()
#Draw the Windows
car_scr.fillcolor("#D5DBDB")
car_scr.penup()
car_scr.goto(i+100, 50)
car_scr.pendown()
car_scr.begin_fill()
car_scr.setheading(45)
car_scr.forward(70)
car_scr.setheading(0)
car_scr.forward(100)
car_scr.setheading(-45)
car_scr.forward(70)
car_scr.setheading(90)
car_scr.end_fill()
car_scr.penup()
car_scr.goto(i+200, 50)
car_scr.pendown()
car_scr.forward(49.50)
当我们执行这段代码时，我们得到下面的屏幕输出。很神奇吧？！
Draw Car Upper Body Window
使用 Turtle 添加车轮
最后，我们需要以类似的方式给汽车添加轮子。看看下面的完整功能就知道了。最后我们要把乌龟指针藏起来才能看到干净的汽车图像！
def Draw_Car(i,j):
# Drawing the Upper Body
car_scr.fillcolor("#2980B9")
car_scr.penup()
car_scr.goto(i,j)
car_scr.pendown()
car_scr.begin_fill()
car_scr.forward(370)
car_scr.left(90)
car_scr.forward(50)
car_scr.left(90)
car_scr.forward(370)
car_scr.left(90)
car_scr.forward(50)
car_scr.end_fill()
#Draw the Windows
car_scr.fillcolor("#D5DBDB")
car_scr.penup()
car_scr.goto(i+100, 50)
car_scr.pendown()
car_scr.begin_fill()
car_scr.setheading(45)
car_scr.forward(70)
car_scr.setheading(0)
car_scr.forward(100)
car_scr.setheading(-45)
car_scr.forward(70)
car_scr.setheading(90)
car_scr.end_fill()
car_scr.penup()
car_scr.goto(i+200, 50)
car_scr.pendown()
car_scr.forward(49.50)
# Draw the two wheels
car_scr.penup()
car_scr.goto(i+100, -10-j)
car_scr.pendown()
car_scr.color('black')
car_scr.fillcolor('black')
car_scr.begin_fill()
car_scr.circle(20)
car_scr.end_fill()
car_scr.penup()
car_scr.goto(i+300, -10-j)
car_scr.pendown()
car_scr.color('black')
car_scr.fillcolor('black')
car_scr.begin_fill()
car_scr.circle(20)
car_scr.end_fill()
car_scr.hideturtle()
跑蟒龟
让我们使用下面的代码在屏幕上绘制汽车。画完汽车后，我们将在done功能的帮助下关闭应用程序屏幕。
Draw_Car(-200,0)
car_scr.done()
Draw Car Whole Car
完成巨蟒龟代码画车
import turtle
car_scr = turtle
car_scr.color('black')
car_scr.Screen().bgcolor("#ABEBC6")
def Draw_Car(i,j):
# Drawing the Upper Body
car_scr.fillcolor("#2980B9")
car_scr.penup()
car_scr.goto(i,j)
car_scr.pendown()
car_scr.begin_fill()
car_scr.forward(370)
car_scr.left(90)
car_scr.forward(50)
car_scr.left(90)
car_scr.forward(370)
car_scr.left(90)
car_scr.forward(50)
car_scr.end_fill()
#Draw the Windows
car_scr.fillcolor("#D5DBDB")
car_scr.penup()
car_scr.goto(i+100, 50)
car_scr.pendown()
car_scr.begin_fill()
car_scr.setheading(45)
car_scr.forward(70)
car_scr.setheading(0)
car_scr.forward(100)
car_scr.setheading(-45)
car_scr.forward(70)
car_scr.setheading(90)
car_scr.end_fill()
car_scr.penup()
car_scr.goto(i+200, 50)
car_scr.pendown()
car_scr.forward(49.50)
# Draw the two wheels
car_scr.penup()
car_scr.goto(i+100, -10-j)
car_scr.pendown()
car_scr.color('black')
car_scr.fillcolor('black')
car_scr.begin_fill()
car_scr.circle(20)
car_scr.end_fill()
car_scr.penup()
car_scr.goto(i+300, -10-j)
car_scr.pendown()
car_scr.color('black')
car_scr.fillcolor('black')
car_scr.begin_fill()
car_scr.circle(20)
car_scr.end_fill()
Draw_Car(-200,0)
car_scr.done()
当我们执行上面的代码时，一个新的屏幕出现在系统屏幕上，汽车开始在应用程序的屏幕上绘制。
结论
恭喜你！现在你知道如何使用 Python 编程语言中的 Turtle 库在屏幕上画一辆汽车了。感谢您的阅读！
如果您喜欢本教程，我建议您也阅读以下教程:
继续阅读，了解更多！编码快乐！😄
使用 Tkinter 画线——初学者基础
原文：https://www.askpython.com/python-modules/tkinter/drawing-lines
在这篇文章中，我们将看到如何在 Tkinter 中绘制不同类型的线条。绘制任何形状或线条的所有方法都在 canvas 类中，所以我们将首先初始化 Tkinter 和 canvas 类。
导入和初始化模块
让我们从导入所需的库并设置基本窗口开始。这将作为下面演示的空间。
from tkinter import *
root = Tk()
canvas = Canvas()
root.geometry("500x500")
root.mainloop()
如何用 Tkinter 画线？
为了在我们的主 Tkinter 窗口上创建线条，我们将使用 create_line() 方法，该方法获取窗口上线条放置的坐标。这些坐标决定了直线的长度和方向。
1.直线
在 Tkinter 中创建任何类型的线条都非常容易。为了画一条直线，我们将使用 create_line()方法。
canvas.create_line(15, 25, 200, 25, width=5)
canvas.pack()
Straight Line In Tkinter
2.点线
创建虚线的过程与创建直线的过程相同。同样，我们将使用 create_line()方法并传递线坐标，唯一的变化是我们还将添加另一个参数 dash。
canvas.create_line(300, 35, 300, 200, dash=(10), width=5)
canvas.pack()
Dotted Line In Tkinter
3.用多条线绘制形状
正如我们已经讨论过的，我们还可以控制线条的方向，这使我们能够通过创建多条线条来绘制不同的形状。在给定的代码中，我们用三条线的三个坐标形成了一个三角形。
canvas.create_line(55, 85, 155, 85, 105, 180, 55, 85, width=5)
canvas.pack()
Shapes Using Lines In Tkinter
结论
Python Tkinter 画线基础到此为止。要了解绘制直线的更多信息，请研究 create_line()函数及其接受的参数。一旦你弄清楚了这个函数，使用它来玩和创建任何类型的绘图都不会很困难！
删除熊猫数据框多列的 8 种方法
原文：https://www.askpython.com/python-modules/pandas/drop-multiple-columns-dataframe
在这个 Python 教程中，我们将探索不同的方法来删除一个 熊猫数据帧的多个列。所以，让我们开始吧！
方法来删除数据帧的多列
在开始之前，我们需要一个示例数据框架。下面是我将在本教程中使用的数据帧的一小段代码。请随意复制粘贴这段代码，并按照本教程进行操作。
# Import pandas Python module
import pandas as pd
# Create a pandas DataFrame object
df = pd.DataFrame({'Dept': ['ECE', 'ICE', 'IT', 'CSE', 'CHE', 'EE', 'TE', 'ME', 'CSE', 'IPE', 'ECE'],
'GPA': [8.15, 9.03, 7.85, 8.55, 9.45, 7.45, 8.85, 9.35, 6.53,8.85, 7.83],
'Name': ['Mohan', 'Gautam', 'Tanya', 'Rashmi', 'Kirti', 'Ravi', 'Sanjay', 'Naveen', 'Gaurav', 'Ram', 'Tom'],
'RegNo': [111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121]})
# Print the created sample pandas DataFrame
print('Sample pandas DataFrame:\n')
print(df)
输出:
Sample pandas DataFrame:
Dept GPA Name RegNo
0 ECE 8.15 Mohan 111
1 ICE 9.03 Gautam 112
2 IT 7.85 Tanya 113
3 CSE 8.55 Rashmi 114
4 CHE 9.45 Kirti 115
5 EE 7.45 Ravi 116
6 TE 8.85 Sanjay 117
7 ME 9.35 Naveen 118
8 CSE 6.53 Gaurav 119
9 IPE 8.85 Ram 120
10 ECE 7.83 Tom 121
方法 1:使用 del 关键字
# Drop 'GPA' column using del keyword
del df['GPA']
# Print the modified pandas DataFrame
print('Modified pandas DataFrame:\n')
print(df)
输出:
Modified pandas DataFrame:
Dept Name RegNo
0 ECE Mohan 111
1 ICE Gautam 112
2 IT Tanya 113
3 CSE Rashmi 114
4 CHE Kirti 115
5 EE Ravi 116
6 TE Sanjay 117
7 ME Naveen 118
8 CSE Gaurav 119
9 IPE Ram 120
10 ECE Tom 121
方法 2:使用 DataFrame.pop()函数
# Drop 'RegNo' column using DataFrame.pop() function
df.pop('RegNo')
# Print the modified pandas DataFrame
print('Modified pandas DataFrame:\n')
print(df)
输出:
Modified pandas DataFrame:
Dept GPA Name
0 ECE 8.15 Mohan
1 ICE 9.03 Gautam
2 IT 7.85 Tanya
3 CSE 8.55 Rashmi
4 CHE 9.45 Kirti
5 EE 7.45 Ravi
6 TE 8.85 Sanjay
7 ME 9.35 Naveen
8 CSE 6.53 Gaurav
9 IPE 8.85 Ram
10 ECE 7.83 Tom
方法 3:使用带有列参数的 DataFrame.drop()函数
# Drop 'GPA' and 'Name' column using DataFrame.drop() function with columns parameter
df.drop(columns=['GPA','Name'], inplace=True)
# Print the modified pandas DataFrame
print('Modified pandas DataFrame:\n')
print(df)
输出:
Modified pandas DataFrame:
Dept RegNo
0 ECE 111
1 ICE 112
2 IT 113
3 CSE 114
4 CHE 115
5 EE 116
6 TE 117
7 ME 118
8 CSE 119
9 IPE 120
10 ECE 121
方法 4:使用带有轴参数的 DataFrame.drop()函数
# Drop 'Dept' and 'GPA' columns using DataFrame.drop() function with axis parameter
df.drop(['Dept','GPA'], axis=1, inplace=True)
# Print the modified pandas DataFrame
print('Modified pandas DataFrame:\n')
print(df)
输出:
Modified pandas DataFrame:
Name RegNo
0 Mohan 111
1 Gautam 112
2 Tanya 113
3 Rashmi 114
4 Kirti 115
5 Ravi 116
6 Sanjay 117
7 Naveen 118
8 Gaurav 119
9 Ram 120
10 Tom 121
方法 5:使用 DataFrame.drop()函数和 DataFrame.iloc[]
# Drop 'Name' and 'GPA' column using DataFrame.drop() function and DataFrame.iloc[]
df.drop(df.iloc[:,1:3], axis=1, inplace=True)
# Print the modified pandas DataFrame
print('Modified pandas DataFrame:\n')
print(df)
输出:
Modified pandas DataFrame:
Dept RegNo
0 ECE 111
1 ICE 112
2 IT 113
3 CSE 114
4 CHE 115
5 EE 116
6 TE 117
7 ME 118
8 CSE 119
9 IPE 120
10 ECE 121
方法 6:使用 DataFrame.drop()函数和 DataFrame.columns[]
# Drop 'Name' and 'Dept' columns using DataFrame.drop() function and DataFrame.columns[]
df.drop(df.columns[[0,2]], axis=1, inplace=True)
# Print the modified pandas DataFrame
print('Modified pandas DataFrame:\n')
print(df)
输出:
Modified pandas DataFrame:
GPA RegNo
0 8.15 111
1 9.03 112
2 7.85 113
3 8.55 114
4 9.45 115
5 7.45 116
6 8.85 117
7 9.35 118
8 6.53 119
9 8.85 120
10 7.83 121
方法 7:仅选择所需的列
# Drop 'RegNo' and 'Dept' columns by selecting only the required columns
df2 = df[['Name','GPA']]
# Print the modified pandas DataFrame
print('Modified pandas DataFrame:\n')
print(df2)
输出:
Modified pandas DataFrame:
Name GPA
0 Mohan 8.15
1 Gautam 9.03
2 Tanya 7.85
3 Rashmi 8.55
4 Kirti 9.45
5 Ravi 7.45
6 Sanjay 8.85
7 Naveen 9.35
8 Gaurav 6.53
9 Ram 8.85
10 Tom 7.83
方法 8:使用 DataFrame.dropna()函数
首先，创建一个具有 NaN 值的 pandas 数据帧。下面是相同的代码片段。
# Import pandas Python module
import pandas as pd
# Import NumPy module
import numpy as np
# Create a pandas DataFrame object with NaN values
df = pd.DataFrame({'Dept': ['ECE', 'ICE', 'IT', 'CSE', 'CHE', 'EE', 'TE', 'ME', 'CSE', 'IPE', 'ECE'],
'GPA': [8.15, 9.03, 7.85, np.nan, 9.45, 7.45, np.nan, 9.35, 6.53,8.85, 7.83],
'Name': ['Mohan', 'Gautam', 'Tanya', 'Rashmi', 'Kirti', 'Ravi', 'Sanjay', 'Naveen', 'Gaurav', 'Ram', 'Tom'],
'RegNo': [111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121],
'City': ['Biharsharif','Ranchi',np.nan,'Patiala', 'Rajgir', 'Patna', np.nan,'Mysore',np.nan,'Mumbai',np.nan]})
# Print the created pandas DataFrame
print('Sample pandas DataFrame with NaN values:\n')
print(df)
输出:
Sample pandas DataFrame with NaN values:
Dept GPA Name RegNo City
0 ECE 8.15 Mohan 111 Biharsharif
1 ICE 9.03 Gautam 112 Ranchi
2 IT 7.85 Tanya 113 NaN
3 CSE NaN Rashmi 114 Patiala
4 CHE 9.45 Kirti 115 Rajgir
5 EE 7.45 Ravi 116 Patna
6 TE NaN Sanjay 117 NaN
7 ME 9.35 Naveen 118 Mysore
8 CSE 6.53 Gaurav 119 NaN
9 IPE 8.85 Ram 120 Mumbai
10 ECE 7.83 Tom 121 NaN
现在，我们将删除具有 NaN 值的列。
# Drop columns with NaN values using the DataFrame.dropna() function
df2 = df.dropna(axis='columns')
# Print the modified pandas DataFrame
print('Modified pandas DataFrame:\n')
print(df2)
输出:
Modified pandas DataFrame:
Dept Name RegNo
0 ECE Mohan 111
1 ICE Gautam 112
2 IT Tanya 113
3 CSE Rashmi 114
4 CHE Kirti 115
5 EE Ravi 116
6 TE Sanjay 117
7 ME Naveen 118
8 CSE Gaurav 119
9 IPE Ram 120
10 ECE Tom 121
结论
在本教程中，我们学习了不同的方法来删除熊猫数据帧的多个列。希望你已经理解了上面讨论的方法，并乐于在你的数据分析项目中使用它们。感谢阅读！请继续关注我们，了解更多关于 Python 编程的精彩学习内容。
Python 中的鸭子打字
Duck typing 是动态编程的一种变体，它使用一种溯因推理的形式进行类型检查。在本文中，我们将重点关注 duck 类型化的主要直觉和 python 中 duck 类型化的例子。
Python 中的鸭子打字是什么？–溯因推理
鸭子这个词可以说来自一个流行短语:
“如果它走路像鸭子，叫起来像鸭子，那它很可能是只鸭子。”
这个短语最重要的方面是，我们实际上不知道这个物体是不是一只鸭子，我们从一系列行为中推断/推断这个物体是一只鸭子。重要的是要注意，我们不是在内部检查两个对象是否相同，而是使用已知的外部行为来匹配这两个对象。
这种推理可以转移到计算机科学领域。在动态语言中，没有显式的类型检查。但是对于某些用例来说，为了确保函数正确运行，必须验证输入类型变得很重要。这可能会导致动态类型方面的各种限制和设计问题，因此引入了 Duck 类型。
Duck typing 更重视对象内部定义的方法(行为)，而不是对象本身。如果对象具有所需的方法，则允许对象通过。让我们看一个例子来理解这个概念。
鸭子打字的例子
我们定义了三个代表不同动物的类，一只鸭子，一只鹅和一只猫。它们都发出不同的声音。鸭子和鹅嘎嘎叫，而猫发出喵喵的声音。然后我们定义一个函数quak()，它接收一只动物，并用叫声打印出描述。很明显，一个没有嘎嘎()方法的动物，在通过函数时会给出一个错误，表示变量类型错误(表示它没有通过鸭子测试)。
# Define the three classes
class Duck:
def quack(self):
print("I am a duck and I quack.")
class Goose:
def quack(self):
print("I am a goose and I quack.")
class Cat:
def meow(self):
print("I am a dog and I meow.")
# Define the method
def quack(animal):
animal.quack()
我们经过这三只动物，让它们都呱呱地叫起来。当鸭子和鹅嘎嘎叫时，猫不会嘎嘎叫，因此抛出一个错误。
quack(Duck())
quack(Goose())
quack(Cat())
Quack Error
因此，我们看到，即使没有对象类型的外部检查，python 也通过检查方法兼容性知道该对象不支持该函数。
鸭子打字的实际例子
鸭子类型最常用的例子之一是 python 中的迭代。你有没有想过如何在 python 中用每一个 iterable 写一个 for 循环？或者事实上是什么使得一个对象是可迭代的？循环可以用于列表、 numpy 数组、生成器函数、Tensorflow/PyTorch 数据加载器等。
鸭子打字在这里发挥了作用。无论这些对象在应用方面有多么不同，都因为鸭式打字而被一视同仁。
对于迭代，该类必须有 iter() 和 next()函数，这使它有资格进行迭代。Python 没有对这些类进行强类型检查，这使得它越来越灵活。
我们甚至可以定义自己的迭代器来打印平方数，这里我们定义了方法 iter() 和 next() ，这是 python 迭代期间调用的两个方法。
class Squares:
def __init__(self, l=0, u=-1):
self.u = u
self.n = l
def __iter__(self):
return self
def __next__(self):
if self.n < self.u:
s = self.n ** 2
self.n += 1
return s
else:
raise StopIteration
for i in Squares(1, 4):
print(i)
1
4
9
结论
python 中对 duck typing 的支持实现了基本 Python 函数与用户定义的类的无缝集成。这也允许两个不同类之间的交互和集成。我们已经看到了 python 中迭代器的一个例子，这个概念可以应用到 len() 中，它检查对象内部是否定义了 len()方法。您可以在 python 中尝试各种其他方法，探索 python 到底有多灵活。
参考
Python 中的简单游戏
原文：https://www.askpython.com/python/examples/easy-games-in-python
今天我们将学习如何使用一些常见的 Python 模块用 Python 编写一些简单的游戏。
我们为什么要使用 Python？
Python 是一种众所周知的编程语言。Python 非常容易理解和编码。它被认为是开发者友好的。任何初学者都可以在短时间内学会用 python 编码。
这种语言的一些最有趣的特性如下:
- Python 是开源和免费的
- 便携式和动态
- 超级容易理解等。
用 Python 创建简单的游戏
现在，让我们用 Python 实现一些简单的游戏，作为初学者，您可以构建这些游戏，以便在您的学习曲线中占得先机！
1.Python 中的一个问答游戏
这是一个非常简单的基于文本的 python 游戏。这是一个小测验，你可以为自己也可以为你的朋友做。我们不需要为这个游戏导入任何模块，这使它更容易！你自己试试😉
以下是用途:
- if-else 语句–用于检查答案
- 打印声明–用于打印输出
print('Welcome to AskPython Quiz')
answer=input('Are you ready to play the Quiz ? (yes/no) :')
score=0
total_questions=3
if answer.lower()=='yes':
answer=input('Question 1: What is your Favourite programming language?')
if answer.lower()=='python':
score += 1
print('correct')
else:
print('Wrong Answer :(')
answer=input('Question 2: Do you follow any author on AskPython? ')
if answer.lower()=='yes':
score += 1
print('correct')
else:
print('Wrong Answer :(')
answer=input('Question 3: What is the name of your favourite website for learning Python?')
if answer.lower()=='askpython':
score += 1
print('correct')
else:
print('Wrong Answer :(')
print('Thankyou for Playing this small quiz game, you attempted',score,"questions correctly!")
mark=(score/total_questions)*100
print('Marks obtained:',mark)
print('BYE!')
输出:
Welcome to AskPython Quiz
Are you ready to play the Quiz ? (yes/no) :yes
Question 1: What is your Favourite programming language?python
correct
Question 2: Do you follow any author on AskPython? yes
correct
Question 3: What is the name of your favourite website for learning Python?askpython
correct
Thankyou for Playing this small quiz game, you attempted 3 questions correctly!
Marks obtained: 100.0
BYE!
2.Python 中的乒乓游戏
我们大多数人都听说过著名的乒乓球比赛。我们很多人都喜欢玩它。今天让我们学习如何使用 python 编程语言编写这个经典游戏的代码！
在开始编码之前，我们首先需要安装 turtle 模块。 turtle 模块是一个 Python 库，它使用户能够通过提供给他们一个虚拟画布来创建图片和形状。
如果您还没有这个库，您可以使用 pip 来安装它。
C:\Users\Admin>pip install turtle
在官方文档中阅读更多关于海龟库的信息。
自己试代码！
import turtle as t
playerAscore=0
playerBscore=0
#create a window and declare a variable called window and call the screen()
window=t.Screen()
window.title("The Pong Game")
window.bgcolor("green")
window.setup(width=800,height=600)
window.tracer(0)
#Creating the left paddle
leftpaddle=t.Turtle()
leftpaddle.speed(0)
leftpaddle.shape("square")
leftpaddle.color("white")
leftpaddle.shapesize(stretch_wid=5,stretch_len=1)
leftpaddle.penup()
leftpaddle.goto(-350,0)
#Creating the right paddle
rightpaddle=t.Turtle()
rightpaddle.speed(0)
rightpaddle.shape("square")
rightpaddle.color("white")
rightpaddle.shapesize(stretch_wid=5,stretch_len=1)
rightpaddle.penup()
rightpaddle.goto(-350,0)
#Code for creating the ball
ball=t.Turtle()
ball.speed(0)
ball.shape("circle")
ball.color("red")
ball.penup()
ball.goto(5,5)
ballxdirection=0.2
ballydirection=0.2
#Code for creating pen for scorecard update
pen=t.Turtle()
pen.speed(0)
pen.color("Blue")
pen.penup()
pen.hideturtle()
pen.goto(0,260)
pen.write("score",align="center",font=('Arial',24,'normal'))
#code for moving the leftpaddle
def leftpaddleup():
y=leftpaddle.ycor()
y=y+90
leftpaddle.sety(y)
def leftpaddledown():
y=leftpaddle.ycor()
y=y+90
leftpaddle.sety(y)
#code for moving the rightpaddle
def rightpaddleup():
y=rightpaddle.ycor()
y=y+90
rightpaddle.sety(y)
def rightpaddledown():
y=rightpaddle.ycor()
y=y+90
rightpaddle.sety(y)
#Assign keys to play
window.listen()
window.onkeypress(leftpaddleup,'w')
window.onkeypress(leftpaddledown,'s')
window.onkeypress(rightpaddleup,'Up')
window.onkeypress(rightpaddledown,'Down')
while True:
window.update()
#moving the ball
ball.setx(ball.xcor()+ballxdirection)
ball.sety(ball.ycor()+ballxdirection)
#border set up
if ball.ycor()>290:
ball.sety(290)
ballydirection=ballydirection*-1
if ball.ycor()<-290:
ball.sety(-290)
ballydirection=ballydirection*-1
if ball.xcor() > 390:
ball.goto(0,0)
ball_dx = ball_dx * -1
player_a_score = player_a_score + 1
pen.clear()
pen.write("Player A: {} Player B: {} ".format(player_a_score,player_b_score),align="center",font=('Monaco',24,"normal"))
os.system("afplay wallhit.wav&")
if(ball.xcor()) < -390: # Left width paddle Border
ball.goto(0,0)
ball_dx = ball_dx * -1
player_b_score = player_b_score + 1
pen.clear()
pen.write("Player A: {} Player B: {} ".format(player_a_score,player_b_score),align="center",font=('Monaco',24,"normal"))
os.system("afplay wallhit.wav&")
# Handling the collisions with paddles.
if(ball.xcor() > 340) and (ball.xcor() < 350) and (ball.ycor() < rightpaddle.ycor() + 40 and ball.ycor() > rightpaddle.ycor() - 40):
ball.setx(340)
ball_dx = ball_dx * -1
os.system("afplay paddle.wav&")
if(ball.xcor() < -340) and (ball.xcor() > -350) and (ball.ycor() < leftpaddle.ycor() + 40 and ball.ycor() > leftpaddle.ycor() - 40):
ball.setx(-340)
ball_dx = ball_dx * -1
os.system("afplay paddle.wav&")
输出:
Pong Game
3.Python 中的饿蛇游戏
这是我们小时候最喜欢的游戏。我们实际上可以通过导入两个模块来用 python 编写这个游戏！多酷啊！
我们开始吧！
首先，我们需要安装 turtle。如果您还没有安装它，请打开 cmd 并键入以下命令。
C:\Users\Admin>pip install turtle
现在我们将安装随机模块。随机模块用于生成随机数。在您的 cmd 中键入以下命令。
C:\Users\Admin>pip install random2
编码并亲自尝试，享受游戏！
import turtle
import random
w = 500
h = 500
food_size = 10
delay = 100
offsets = {
"up": (0, 20),
"down": (0, -20),
"left": (-20, 0),
"right": (20, 0)
}
def reset():
global snake, snake_dir, food_position, pen
snake = [[0, 0], [0, 20], [0, 40], [0, 60], [0, 80]]
snake_dir = "up"
food_position = get_random_food_position()
food.goto(food_position)
move_snake()
def move_snake():
global snake_dir
new_head = snake[-1].copy()
new_head[0] = snake[-1][0] + offsets[snake_dir][0]
new_head[1] = snake[-1][1] + offsets[snake_dir][1]
if new_head in snake[:-1]:
reset()
else:
snake.append(new_head)
if not food_collision():
snake.pop(0)
if snake[-1][0] > w / 2:
snake[-1][0] -= w
elif snake[-1][0] < - w / 2:
snake[-1][0] += w
elif snake[-1][1] > h / 2:
snake[-1][1] -= h
elif snake[-1][1] < -h / 2:
snake[-1][1] += h
pen.clearstamps()
for segment in snake:
pen.goto(segment[0], segment[1])
pen.stamp()
screen.update()
turtle.ontimer(move_snake, delay)
def food_collision():
global food_position
if get_distance(snake[-1], food_position) < 20:
food_position = get_random_food_position()
food.goto(food_position)
return True
return False
def get_random_food_position():
x = random.randint(- w / 2 + food_size, w / 2 - food_size)
y = random.randint(- h / 2 + food_size, h / 2 - food_size)
return (x, y)
def get_distance(pos1, pos2):
x1, y1 = pos1
x2, y2 = pos2
distance = ((y2 - y1) ** 2 + (x2 - x1) ** 2) ** 0.5
return distance
def go_up():
global snake_dir
if snake_dir != "down":
snake_dir = "up"
def go_right():
global snake_dir
if snake_dir != "left":
snake_dir = "right"
def go_down():
global snake_dir
if snake_dir!= "up":
snake_dir = "down"
def go_left():
global snake_dir
if snake_dir != "right":
snake_dir = "left"
screen = turtle.Screen()
screen.setup(w, h)
screen.title("Snake")
screen.bgcolor("blue")
screen.setup(500, 500)
screen.tracer(0)
pen = turtle.Turtle("square")
pen.penup()
food = turtle.Turtle()
food.shape("square")
food.color("yellow")
food.shapesize(food_size / 20)
food.penup()
screen.listen()
screen.onkey(go_up, "Up")
screen.onkey(go_right, "Right")
screen.onkey(go_down, "Down")
screen.onkey(go_left, "Left")
reset()
turtle.done()
输出:
结论
就是这样！这些是 Python 中的一些简单游戏，你可以作为初学者创建并从中获得乐趣！我们喜欢建设这些项目，我们希望你也一样！
使用 Python 进行图像边缘检测
原文：https://www.askpython.com/python/examples/edge-detection-in-images
你好，学习伙伴！今天我们将学习图像中的边缘检测，并在屏幕上显示检测到的边缘。
我们所说的边缘检测是什么意思？
在我们开始之前，让我们了解什么是边缘检测。
边缘检测用于在单幅图像中找到各种物体的各种边界/边缘。
有多种边缘检测算法和技术可用，但最流行和最广泛使用的算法之一是Canny edge detector。
导入必要的模块
第一步是导入所有需要的模块，即 OpenCV、numpy 和 matplotlib 。我们也将根据我们的喜好设置风格。
import cv2
import numpy as np
import matplotlib.pyplot as plt
plt.style.use('seaborn')
加载和绘制图像
在我们检测图像之前，我们必须在程序中使用imread方法读取图像，该方法将图像的路径作为参数。
为了获得原始颜色，我们需要使用cvtColor函数将颜色转换为RGB格式，并将其应用于加载的图像。
只要确保图像与项目代码文件在同一个文件夹中。
loaded_image = cv2.imread("image.jpg")
loaded_image = cv2.cvtColor(loaded_image,cv2.COLOR_BGR2RGB)
为了加载图像，我们使用了 matplotlib 库。下面提到了相同的代码。
我们首先设置图形大小以便更好地可视化，然后使用imshow方法绘制图像。除此之外，我们将关闭轴以获得清晰的绘图。
相同的代码如下所示。
plt.figure(figsize=(10,10))
plt.imshow(loaded_image,cmap="gray")
plt.axis("off")
plt.show()
将图像转换为灰度
在我们对图像应用 Canny 边缘检测器之前，我们需要使用cvtColor函数将图像转换为灰度。然后像绘制原始图像一样绘制图像。
gray_image = cv2.cvtColor(loaded_image,cv2.COLOR_BGR2GRAY)
plt.figure(figsize=(10,10))
plt.imshow(gray_image,cmap="gray")
plt.axis("off")
plt.show()
在 Python 中应用 Canny 算法进行边缘检测
最后一步是对上一步获得的灰度图像应用 Canny 算法。相同的代码如下所示。
edged_image = cv2.Canny(gray_image, threshold1=30, threshold2=100)
canny函数需要三样东西:灰度图像、要考虑的较低和较高像素阈值。
接下来我们需要做的是绘制边缘检测图像。相同的代码如下所示。
plt.figure(figsize=(10,10))
plt.imshow(edged_image,cmap="gray")
plt.axis("off")
plt.show()
下面显示了三个图，供您参考。
Edge Detected Output 1
边缘检测的最终代码
import cv2
import numpy as np
import matplotlib.pyplot as plt
plt.style.use('seaborn')
loaded_image = cv2.imread("image.jpg")
loaded_image = cv2.cvtColor(loaded_image,cv2.COLOR_BGR2RGB)
gray_image = cv2.cvtColor(loaded_image,cv2.COLOR_BGR2GRAY)
edged_image = cv2.Canny(gray_image, threshold1=30, threshold2=100)
plt.figure(figsize=(20,20))
plt.subplot(1,3,1)
plt.imshow(loaded_image,cmap="gray")
plt.title("Original Image")
plt.axis("off")
plt.subplot(1,3,2)
plt.imshow(gray_image,cmap="gray")
plt.axis("off")
plt.title("GrayScale Image")
plt.subplot(1,3,3)
plt.imshow(edged_image,cmap="gray")
plt.axis("off")
plt.title("Canny Edge Detected Image")
plt.show()
另一个图像的输出显示如下。
Edge Detected Output 2
结论
恭喜你！在今天的教程中，我们学习了如何在 python 中检测边缘。您可以使用不同的图像尝试相同的功能。
编码快乐！感谢您的阅读！
Python 中的垃圾邮件分类
原文：https://www.askpython.com/python/examples/email-spam-classification
你好，学习伙伴！在本教程中，我们将讨论如何在数据集的帮助下实现垃圾邮件的分类，该数据集将使用 Python 编程语言中的 scikit-learn 加载。
垃圾邮件简介
我们都知道，每天都有数十亿封垃圾邮件发送到用户的电子邮件帐户，其中超过 90%的垃圾邮件是恶意的，会对用户造成重大伤害。
你不觉得垃圾邮件很烦人吗？他们肯定会让我很烦！有时，甚至一些重要的邮件被转移到垃圾邮件中，结果，一些重要的信息由于害怕受到垃圾邮件的伤害而未被阅读。
您知道吗每 1000 封电子邮件中就有一封包含恶意软件指控？因此，对我们来说，重要的是学会如何将我们自己的电子邮件分类为安全和不安全。
用 Python 实现垃圾邮件分类器
让我们进入使用 Python 实现垃圾邮件分类算法的步骤。这将帮助你理解一个非常基本的垃圾邮件分类器的后端工作。与我下面描述的算法相比，现实世界中使用的算法要先进得多。但是你可以把它作为你旅程的起点。
1.导入模块和加载数据
首先，我们将所有必需的模块导入我们的程序。相同的代码如下:
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.naive_bayes import MultinomialNB, GaussianNB
from sklearn import svm
from sklearn.model_selection import GridSearchCV
我们需要一些基本的机器学习模块，如 numpy 、 pandas 和 matplotlib 。除此之外，我们还需要一些sklearn模型和特性。
下一步是在前面导入的 pandas 模块的帮助下加载数据集。我们将使用的数据集是spam.csv数据文件，可以在这里找到。
data = pd.read_csv('./spam.csv')
我们加载的数据集有 5572 个电子邮件样本以及两个唯一的标签，即spam和ham。
2.培训和测试数据
加载后，我们必须将数据分成训练和测试数据。
将数据分为训练和测试数据包括两个步骤:
- 将 x 和 y 数据分别分离为电子邮件文本和标签
- 基于 80:20 规则将 x 和 y 数据分割成四个不同的数据集，即 x_train、y_train、x_test 和 y_test。
将数据分成 x 和 y 数据是在下面的代码中完成的:
x_data=data['EmailText']
y_data=data['Label']
split =(int)(0.8*data.shape[0])
x_train=x_data[:split]
x_test=x_data[split:]
y_train=y_data[:split]
y_test=y_data[split:]
3.提取重要特征
下一步是从整个数据集中只获取重要的单词/特征。为了实现这一点，我们将利用CountVectorizer函数来对训练数据集的单词进行矢量化。
count_vector = CountVectorizer()
extracted_features = count_vector.fit_transform(x_train)
4.构建和训练模型
最重要的步骤包括为我们之前创建的数据集构建和训练模型。相同的代码如下:
tuned_parameters = {'kernel': ['rbf','linear'], 'gamma': [1e-3, 1e-4],'C': [1, 10, 100, 1000]}
model = GridSearchCV(svm.SVC(), tuned_parameters)
model.fit(extracted_features,y_train)
print("Model Trained Successfully!")
最后一步包括在测试数据集上计算我们的模型的整体准确性。
print("Accuracy of the model is: ",model.score(count_vector.transform(x_test),y_test)*100)
我们最终达到了**98.744%** 的精确度，这太棒了！！
结论
实施电子邮件分类系统是发展该技术并使电子邮件更加安全的下一个重要步骤。
我希望你喜欢这个教程！快乐学习！😇
另请参阅:
Python:表情符号模块
嘿，同学们！今天我们将学习一些有趣的东西！我们将看看 python 中的表情模块。
所以让我们开始吧！
表情符号简介
在当今世界，人们通过表情符号来交流情感，而不是打出很长的段落。表情符号已经成为我们日常交流的一个主要部分。
今天在这个教程中，我将教你如何使用简单的代码行和 python 的表情符号模块自己打印表情符号。
使用表情符号模块打印自己的表情符号
我们首先从导入emoji模块开始。如果导入时出现任何错误，我们需要在命令提示符下使用pip命令来安装模块。
为了在屏幕上打印表情符号，我们将使用emojize()函数，该函数将冒号(:)内的表情符号名称作为参数。
该功能会自动返回表情符号作为结果。
如果出于某种原因，你不知道某个特定表情符号的文本，我们可以使用demojize()函数，并将表情符号作为参数传递。
相同的代码如下所示:
import emoji
print(emoji.demojize('😃'))
print(emoji.emojize("Hello there friend! :grinning_face_with_big_eyes:"))
```py
代码的输出如下所示。你可以看到第一个函数将表情符号转换为文本，而第二个函数将文本转换为表情符号。
:grinning_face_with_big_eyes:
Hello there friend! 😃
## 什么是 Unicodes？
我们可以直接使用`unicode`作为表情符号，而不是使用长文本。每个表情符号都有一个唯一的对应于该表情符号的 Unicode。
你可以从这个网站获得任何表情符号[的统一码。](https://unicode-table.com/en/sets/emoji/)我们需要做的就是用`000`替换 Unicode 中的`+`来获得正确的 Unicode。
使用 Unicode 打印表情符号非常简单，除了在 Unicode 前加上一个反斜杠(`\`)的`print`语句之外，不需要任何函数就可以打印表情符号。
下面的代码显示了在 unicodes 的帮助下打印一堆表情符号。
print("\U0001F680 \U0001F649 \U0001F698 \U0001F6C1")
上面代码的输出如下:
🚀 🙉 🚘 🛁
## 结论
所以今天我们学会了自己在句子中打印表情符号。您可以使用我们文本中有趣的表情符号来构建有趣的[文本游戏](https://www.askpython.com/python/examples/easy-games-in-python)！希望你喜欢这个教程！
坚持读书学习！谢谢你。
# Python 中的封装
> 原文：<https://www.askpython.com/python/oops/encapsulation-in-python>
当使用像 Python 这样的面向对象编程语言时，Python 中的封装是需要理解的 4 个重要概念之一。另外三个是[继承](https://www.askpython.com/python/oops/inheritance-in-python)、[多态](https://www.askpython.com/python/oops/polymorphism-in-python)和抽象。
## 什么是封装？
当使用类和处理敏感数据时，提供对程序中使用的所有变量的全局访问不是一个好的选择。封装为我们提供了一种访问所需变量的方法，而无需为程序提供对这些变量的完全访问。
通过使用专门为此目的定义的方法，可以更新、修改或删除变量中的数据。使用这种编程方法的好处是改善了对输入数据的控制和更好的安全性。
## Python 中的封装是什么？
封装的概念在所有面向对象的编程语言中都是相同的。当这些概念应用于特定的语言时，差异就显现出来了。
与 Java 等为变量和方法提供访问修饰符(公共或私有)的语言相比，Python 提供了对所有变量和方法的全局访问。
查看下面的演示，了解如何轻松访问变量。
```py
class Person:
def __init__(self, name, age=0):
self.name = name
self.age = age
def display(self):
print(self.name)
print(self.age)
person = Person('Dev', 30)
#accessing using class method
person.display()
#accessing directly from outside
print(person.name)
print(person.age)
输出
Dev
30
Dev
30
由于 Python 中没有访问修饰符，我们将使用一些不同的方法来控制 Python 程序中变量的访问。
控制访问的方法
Python 提供了多种方法来限制程序中变量和方法的访问。让我们详细讨论一下这些方法。
使用单下划线
标识私有变量的一个常见 Python 编程约定是在它前面加一个下划线。现在，这对于编译器来说并没有什么影响。该变量仍然可以像往常一样访问。但是作为程序员已经学会的惯例，它告诉其他程序员变量或方法只能在类的范围内使用。
请参见下面的示例:
class Person:
def __init__(self, name, age=0):
self.name = name
self._age = age
def display(self):
print(self.name)
print(self._age)
person = Person('Dev', 30)
#accessing using class method
person.display()
#accessing directly from outside
print(person.name)
print(person._age)
输出
Dev
30
Dev
30
很明显变量 access 是不变的。但是我们能做些什么来真正使它成为私有的吗？让我们进一步看看。
使用双下划线
如果你想让类成员，也就是方法和变量私有，那么你应该在它们前面加双下划线。但是 Python 为 private 修饰符提供了某种支持。这种机制被称为名为。这样，仍然可以从外部访问类成员。
名字叫莽林
在 python 中，任何带有 __Var 的标识符都会被 Python 解释器重写为 _Classname__Var，而类名仍然是当前的类名。这种改名的机制在 Python 中被称为名字篡改。
在下面的例子中，在 person 类中，年龄变量被改变了，它的前缀是双下划线。
class Person:
def __init__(self, name, age=0):
self.name = name
self.__age = age
def display(self):
print(self.name)
print(self.__age)
person = Person('Dev', 30)
#accessing using class method
person.display()
#accessing directly from outside
print('Trying to access variables from outside the class ')
print(person.name)
print(person.__age)
输出
Dev
30
Trying to access variables from outside the class
Dev
Traceback (most recent call last):
File "Person.py", line 16, in <module>
print(person.__age)
AttributeError: 'Person' object has no attribute '__age'
您可以观察到，仍然可以使用方法访问变量，这是类的一部分。但是你不能从外部直接访问年龄，因为它是一个私有变量。
使用 Getter 和 Setter 方法访问私有变量
如果您想要访问和更改私有变量，应该使用访问器(getter)方法和赋值器(setter)方法，因为它们是类的一部分。
class Person:
def __init__(self, name, age=0):
self.name = name
self.__age = age
def display(self):
print(self.name)
print(self.__age)
def getAge(self):
print(self.__age)
def setAge(self, age):
self.__age = age
person = Person('Dev', 30)
#accessing using class method
person.display()
#changing age using setter
person.setAge(35)
person.getAge()
输出
Dev
30
35
Python 中封装的好处
封装不仅确保了更好的数据流，还保护了来自外部数据源的数据。封装的概念使得代码能够自给自足。它在实现层面非常有帮助，因为它优先考虑“如何”类型的问题，把复杂性抛在后面。您应该将数据隐藏在单元中，以便于封装并保护数据。
Python 中封装的需求是什么
下面的原因说明了为什么开发人员觉得封装很方便，为什么面向对象的概念超越了许多编程语言。
- 封装有助于在每个应用程序中实现定义良好的交互。
- 面向对象的概念侧重于 Python 中代码的可重用性。(干——不要重复)。
- 可以安全地维护应用程序。
- 它通过适当的代码组织确保了代码的灵活性。
- 它促进了用户的流畅体验，而没有暴露任何后端复杂性。
- 它提高了代码的可读性。一部分代码的任何变化都不会影响到另一部分。
- 封装可确保数据保护，避免意外访问数据。可以用上面讨论的方法访问受保护的数据。
Python 中的封装是，数据隐藏在对象定义之外。它使开发人员能够开发用户友好的体验。这也有助于保护数据免遭破坏，因为代码是高度安全的，不能被外部来源访问。
引用: Python 类和私有变量
Python 中的环境变量–读取、打印、设置
原文：https://www.askpython.com/python/environment-variables-in-python
环境变量是当前用户环境的一组键值对。它们通常由操作系统和当前用户特定的配置来设置。例如，在 Unix 环境中，使用用户配置文件设置环境变量，即。bash_profile，。巴沙尔或者。配置文件。
Python 中的环境变量
你可以把环境变量想象成一个字典，其中键是环境变量名，值是环境变量值。
如何在 Python 中读取环境变量
我们可以使用 Python os 模块的“environ”属性来获取所有环境变量的字典。当 Python 解释器加载 os 模块时，设置环境值。通过外部程序对环境变量的任何进一步更改都不会反映在已经运行的 Python 程序中。
用 Python 打印所有环境变量
os.environ变量是一个类似字典的对象。如果我们打印它，所有的环境变量名称和值都会被打印出来。
import os
# printing environment variables
print(os.environ)
输出:
environ({'PATH': '/Users/pankaj/Documents/PyCharmProjects/PythonTutorialPro/venv/bin:/Library/Java/JavaVirtualMachines/jdk-12.jdk/Contents/Home/bin:/Library/PostgreSQL/10/bin:/Users/pankaj/Downloads/mongodb/bin:/Library/Frameworks/Python.framework/Versions/3.7/bin:/Users/pankaj/Downloads/apache-maven-3.5.3/bin:/Library/Frameworks/Python.framework/Versions/3.7/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin', 'PS1': '(venv) ', 'MAVEN_OPTS': '-Xmx2048m -XX:MaxPermSize=128m', 'VERSIONER_PYTHON_VERSION': '2.7', 'LOGNAME': 'pankaj', 'XPC_SERVICE_NAME': 'com.jetbrains.pycharm.40096', 'PWD': '/Users/pankaj/Documents/PycharmProjects/AskPython/hello-world', 'PYCHARM_HOSTED': '1', 'PYTHONPATH': '/Users/pankaj/Documents/PycharmProjects/AskPython', 'SHELL': '/bin/zsh', 'PAGER': 'less', 'LSCOLORS': 'Gxfxcxdxbxegedabagacad', 'PYTHONIOENCODING': 'UTF-8', 'OLDPWD': '/Applications/PyCharm CE.app/Contents/bin', 'VERSIONER_PYTHON_PREFER_32_BIT': 'no', 'USER': 'pankaj', 'ZSH': '/Users/pankaj/.oh-my-zsh', 'TMPDIR': '/var/folders/1t/sx2jbcl534z88byy78_36ykr0000gn/T/', 'SSH_AUTH_SOCK': '/private/tmp/com.apple.launchd.jkodHSyv2v/Listeners', 'VIRTUAL_ENV': '/Users/pankaj/Documents/PyCharmProjects/PythonTutorialPro/venv', 'XPC_FLAGS': '0x0', 'PYTHONUNBUFFERED': '1', 'M2_HOME': '/Users/pankaj/Downloads/apache-maven-3.5.3', '__CF_USER_TEXT_ENCODING': '0x1F5:0x0:0x0', 'Apple_PubSub_Socket_Render': '/private/tmp/com.apple.launchd.wL2naXrbuW/Render', 'LESS': '-R', 'LC_CTYPE': 'UTF-8', 'HOME': '/Users/pankaj', '__PYVENV_LAUNCHER__': '/Users/pankaj/Documents/PycharmProjects/AskPython/venv/bin/python'})
Environment Variable in Python
如果你想以一种更易读的方式打印环境变量，你可以在循环的中打印它们。
import os
for k, v in os.environ.items():
print(f'{k}={v}')
输出:
PATH=/Users/pankaj/Documents/PyCharmProjects/PythonTutorialPro/venv/bin:/Library/Java/JavaVirtualMachines/jdk-12.jdk/Contents/Home/bin:/Library/PostgreSQL/10/bin:/Users/pankaj/Downloads/mongodb/bin:/Library/Frameworks/Python.framework/Versions/3.7/bin:/Users/pankaj/Downloads/apache-maven-3.5.3/bin:/Library/Frameworks/Python.framework/Versions/3.7/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin
PS1=(venv)
MAVEN_OPTS=-Xmx2048m -XX:MaxPermSize=128m
VERSIONER_PYTHON_VERSION=2.7
LOGNAME=pankaj
XPC_SERVICE_NAME=com.jetbrains.pycharm.40096
PWD=/Users/pankaj/Documents/PycharmProjects/AskPython/hello-world
PYCHARM_HOSTED=1
PYTHONPATH=/Users/pankaj/Documents/PycharmProjects/AskPython
SHELL=/bin/zsh
PAGER=less
LSCOLORS=Gxfxcxdxbxegedabagacad
PYTHONIOENCODING=UTF-8
OLDPWD=/Applications/PyCharm CE.app/Contents/bin
VERSIONER_PYTHON_PREFER_32_BIT=no
USER=pankaj
ZSH=/Users/pankaj/.oh-my-zsh
TMPDIR=/var/folders/1t/sx2jbcl534z88byy78_36ykr0000gn/T/
SSH_AUTH_SOCK=/private/tmp/com.apple.launchd.jkodHSyv2v/Listeners
VIRTUAL_ENV=/Users/pankaj/Documents/PyCharmProjects/PythonTutorialPro/venv
XPC_FLAGS=0x0
PYTHONUNBUFFERED=1
M2_HOME=/Users/pankaj/Downloads/apache-maven-3.5.3
__CF_USER_TEXT_ENCODING=0x1F5:0x0:0x0
Apple_PubSub_Socket_Render=/private/tmp/com.apple.launchd.wL2naXrbuW/Render
LESS=-R
LC_CTYPE=UTF-8
获取特定的环境变量值
因为 os.environ 是一个字典对象，所以我们可以使用键来获取特定的环境变量值。
import os
home_dir =os.environ['HOME']
username = os.environ['USER']
print(f'{username} home directory is {home_dir}')
输出 : pankaj home directory is /Users/pankaj
但是，如果环境变量不存在，这种获取环境变量的方法将会引发 KeyError。
>>> import os
>>> env_var = input('Please enter the environment variable name:\n')
Please enter the environment variable name:
data
>>> print(os.environ[env_var])
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "/Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/os.py", line 678, in __getitem__
raise KeyError(key) from None
KeyError: 'data'
>>>
获取环境变量的一个更好的方法是使用字典 get()函数。如果环境变量不存在，我们也可以指定默认值。
>>> import os
>>> env_var = input('Please enter the environment variable name:\n')
Please enter the environment variable name:
data
>>> print(os.environ.get(env_var))
None
>>> print(os.environ.get(env_var, 'CSV'))
CSV
如何检查环境变量是否存在？
我们可以使用“in”操作符来检查环境变量是否存在。
import os
env_var = input('Please enter the environment variable name:\n')
if env_var in os.environ:
print(f'{env_var} value is {os.environ[env_var]}')
else:
print(f'{env_var} does not exist')
输出:
# Run 1
Please enter the environment variable name:
datatype
datatype does not exist
# Run 2
Please enter the environment variable name:
USER
USER value is pankaj
如何在 Python 中设置环境变量
我们可以使用语法设置环境变量值:OS . environ[env _ var]= env _ var _ value
import os
env_var = input('Please enter environment variable name:\n')
env_var_value = input('Please enter environment variable value:\n')
os.environ[env_var] = env_var_value
print(f'{env_var}={os.environ[env_var]} environment variable has been set.')
输出:
Please enter environment variable name:
datatype
Please enter environment variable value:
CSV
datatype=CSV environment variable has been set.
如果环境变量已经存在，它将被新值覆盖。环境变量将只为 Python 解释器的当前会话设置。如果要将更改为永久性的，则必须在 Python 程序中编辑用户配置文件。
结论
在 Python 中使用环境变量非常容易。我们可以读取、添加和更新当前执行的环境变量。
参考资料:
Python 中误差线的介绍
原文：https://www.askpython.com/python/examples/error-bars-in-python
今天在本教程中，我们将了解误差线的概念，并学习如何在 Python 编程语言中将其可视化。
在跳到代码之前，让我先向您介绍 errorbars。
Python 中的误差线是什么？
在数据科学研究中，在可视化中显示误差线是不可避免的，也是非常必要的。
误差线对于问题解决者来说非常有用，可以用来观察输出值的可信度。没有误差线的条形图给人一种错觉，认为测量值或计算值具有高精度或高可信度。
在 Python 中实现误差线
现在我们知道了什么是误差线，让我们学习使用基本的机器学习模块来可视化它们。
1.导入模块
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
plt.style.use('seaborn')
2.可视化条形图中的误差线
为了可视化柱状图中的误差线，我们必须首先创建柱状图。同样的方法是先创建数据并绘制条形图。
2.1 数据创建
为了创建数据，我们将采用 3 个不同的对象。在本教程中，我们将表示三种金属的热温度。
aluminum = np.array([6.4e-5 , 3.01e-5 , 2.36e-5, 3.0e-5, 7.0e-5, 4.5e-5, 3.8e-5,
4.2e-5, 2.62e-5, 3.6e-5])
copper = np.array([4.5e-5 , 1.97e-5 , 1.6e-5, 1.97e-5, 4.0e-5, 2.4e-5, 1.9e-5,
2.41e-5 , 1.85e-5, 3.3e-5 ])
steel = np.array([3.3e-5 , 1.2e-5 , 0.9e-5, 1.2e-5, 1.3e-5, 1.6e-5, 1.4e-5,
1.58e-5, 1.32e-5 , 2.1e-5])
可视化在任何 ML 程序中都扮演着重要的角色，所以，让我们使用下面提到的代码来可视化散点图中的数据。
x_values = np.array([i for i in range(len(aluminum))])
plt.scatter(x_values,aluminum,label="Aluminium")
plt.scatter(x_values,copper,label="Copper")
plt.scatter(x_values,steel,label="Steel")
plt.title("Initial Data Visualization")
plt.legend()
plt.show()
Initial Visualization Errorbars
2.2 计算误差线的误差
为了得到误差线的误差，我们需要平均值和标准偏差，它们可以借助于 numpy 数组的平均值和标准偏差函数来计算。
下面显示了相同的代码。我们还将通过创建几个变量来准备用于绘图的数据:
- 标签列表
- 包含每个类别含义的列表
- 包含每个类别标准偏差的列表
aluminum_mean = np.mean(aluminum)
copper_mean = np.mean(copper)
steel_mean = np.mean(steel)
aluminum_std = np.std(aluminum)
copper_std = np.std(copper)
steel_std = np.std(steel)
labels = ['Aluminum', 'Copper', 'Steel']
x_pos = np.arange(len(labels))
CTEs = [aluminum_mean, copper_mean, steel_mean]
error = [aluminum_std, copper_std, steel_std]
2.3 绘制误差线
下面提到了绘制误差线的代码，其中误差是每个类别中值的标准偏差。
plt.style.use('seaborn')
fig, ax = plt.subplots()
ax.bar(x_pos, CTEs,
yerr=error,
align='center',
alpha=0.2,
color='green',
ecolor='red',
capsize=10)
ax.set_ylabel('Coefficient of Thermal Expansion')
ax.set_xticks(x_pos)
ax.set_xticklabels(labels)
ax.set_title('Coefficent of Thermal Expansion (CTE) of Three Metals')
ax.yaxis.grid(True)
plt.show()
Bar Plot With Error Bars
3.在线图中显示误差线
误差线也可以添加到用 Matplotlib 创建的线图中。
ax.errorbar()方法用于创建带误差线的线图，这需要 x，y 数据点的列表或数组。
下面显示了相同的代码。
x = np.linspace(0,5.5,5)
y = np.exp(-x)
xerr = np.random.random_sample(5)
yerr = np.random.random_sample(5)
fig, ax = plt.subplots()
ax.errorbar(x, y,
xerr=xerr,
yerr=yerr,
fmt='-o',
color='yellow',
ecolor='green')
ax.set_xlabel('x-axis')
ax.set_ylabel('y-axis')
ax.set_title('Line plot with error bars')
plt.show()
Line Plot With Error Bars
结论
我希望你理解这个概念，并喜欢输出。用更多的样本数据尝试同样的方法。编码快乐！😇
想了解更多？查看下面提到的教程:
Python 中的异常:不同类型的异常以及如何在 Python 中处理它们
原文：https://www.askpython.com/python/examples/exceptions-in-python
每当您编写更大的代码片段和构建更复杂的应用程序时，Python 中的异常就会变得司空见惯。当一个人无法解决这些问题时，他们会变得很烦人。
什么时候会出现错误？
- 给出错误的输入
- 模块/库/资源不可访问
- 超越记忆或者时间
- 程序员犯的任何语法错误
Python 中的不同异常
一个异常被定义为一个程序中中断程序流程和停止代码执行的条件。Python 提供了一种惊人的方式来处理这些异常，使得代码运行没有任何错误和中断。
异常可以属于内置错误/异常，也可以具有自定义异常。一些常见的内置异常如下:
- 零除法错误
- NameError
- 内建 Error
- io 错误
- 埃费罗尔
在 Python 中创建测试异常
让我们看看 Python 解释器中异常的一些例子。让我们看看下面给出的代码的输出。
a = int(input("Enter numerator: "))
b = int(input("Enter denominator: "))
print("a/b results in : ")
print(a/b)
分子是整数，分母为 0 时的输出如下所示。
Enter numerator: 2
Enter denominator: 0
a/b results in :
Traceback (most recent call last):
File "C:/Users/Hp/Desktop/test.py", line 4, in <module>
print(a/b)
ZeroDivisionError: division by zero
用 Try 避免异常..除...之外..
为了避免出现错误并停止程序流程，我们使用了 try-except 语句。整个代码逻辑放在 try 块中，except 块处理发生异常/错误的情况。
其语法如下所述:
try:
#block of code
except <Name of Exception>:
#block of code
#Rest of the code
在 Python 中处理 ZeroDivisionError 异常
让我们来看看我们之前提到的代码，在 try-except 块的帮助下，显示了 ZeroDivisionError 。看看下面提到的代码。
try:
a = int(input("Enter numerator: "))
b = int(input("Enter denominator: "))
print(a/b)
except ZeroDivisionError:
print("Denominator is zero")
对于与前面相同的输入，该代码的输出如下所示。
Enter numerator: 2
Enter denominator: 0
Denominator is zero
结论
现在，您已经了解了异常处理，我希望您清楚异常处理的基本概念。
您可以自己尝试各种例外。编码快乐！感谢您的阅读！😇
按计划执行 Python 脚本–Windows 任务计划程序
原文：https://www.askpython.com/python/examples/execute-python-windows-task-scheduler
有时我们希望我们的脚本在特定的时间或特定的次数运行。我们可以自动执行这项任务，这样就不需要手动运行脚本。Windows 提供了一个软件相关的任务调度程序，它将在给定的时间运行我们的脚本。
限制:
- 仅适用于 Microsoft Windows 操作系统
- 你的电脑需要在预定的时间开机
- 不要模仿服务器-特定时间执行。因此，为了在任何时候运行代码而没有自己动手(打开计算机)的麻烦，你需要使用服务器(在服务器上执行脚本)
使用 Windows 任务计划程序的步骤
让我们马上进入计划 Python 脚本执行的步骤。坚持到底，如果你以后有任何问题，请告诉我们！为了简化设置，我们将使用 Windows 任务计划程序。
1.打开任务计划程序
通过在“开始”菜单中搜索任务计划程序，打开计算机上的任务计划程序应用程序。
Task Scheduler
2.创建新任务
接下来，通过右键单击任务调度器(本地)，在任务调度器中创建一个任务。
Create A New Task In Scheduler
3.命名任务
添加一个名称，以便您以后可以识别它。
Name The Task
4.为我们的脚本创建一个新动作
切换到“Actions”选项卡并添加一个新操作。这是真正的事情发生的地方。
Create New Action
5.运行 python 脚本
要使用 Windows 调度程序自动运行 python 脚本，我们需要在代码中遵循以下步骤:
- 我们需要 python 安装的路径，我们可以通过运行下面的 python 代码找到它。
import sys
print(sys.executable)
Python Installation Path
- 我们将把这个位置粘贴到 Windows 调度器动作的框号 1 中
- 在编号为 2 的框中，我们将传递脚本文件 (python 文件)
的名称，例如:python_sample_file.py 或 a.py - 在编号为 3 的框中，我们将传递 Python 可执行文件 (python 文件)的路径
Entries In Action Of Windows Task Scheduler
6.为脚本创建触发器
触发器是指导致脚本运行的事件。例如，我们可以指定脚本执行的时间。它提供了诸如哪天、什么时间、多少次、我们的脚本应该执行多长时间等选项。
因此，您需要输入所有必需的详细信息。
Trigger In Scheduler
对于我们的程序，我们将设置一个特定的时间来触发下面的脚本执行:
print("Hi, this is scheduled message")
成功创建 Windows 任务计划程序并触发 python 脚本文件后，将执行脚本并在 Windows 命令提示符中显示如下输出:
The output of Task Scheduler
结论
希望你已经很好地学习了如何在任何需要的时候运行你的 python 脚本文件。调度任务，这对于实现脚本文件的自动化非常有用。
用 3 种简单的方法退出 Python 程序！
原文：https://www.askpython.com/python/examples/exit-a-python-program
嘿，大家好。在本文中，我们将会看到一些被认为可以方便地执行这项任务的函数——退出 Python 程序。
技巧 1:使用 quit()函数
Python 函数提供的内置quit() function，可以用来退出 Python 程序。
语法:
quit()
一旦系统遇到 quit()函数，它就完全终止程序的执行。
举例:
for x in range(1,10):
print(x*10)
quit()
如上所示，在 for 循环的第一次迭代之后，解释器遇到 quit()函数并终止程序。
输出:
10
技巧 2: Python sys.exit()函数
Python sys module包含一个内置函数，用于退出程序，从执行过程中出来——函数sys.exit()。
sys.exit()函数可以在任何时候使用，而不必担心代码损坏。
语法:
sys.exit(argument)
让我们看看下面的例子来理解sys.exit()功能。
举例:
import sys
x = 50
if x != 100:
sys.exit("Values do not match")
else:
print("Validation of values completed!!")
输出:
Values do not match
技巧 3:使用 exit()函数
除了上面提到的技术，我们可以使用 Python 中内置的exit() function来退出程序的执行循环。
语法:
exit()
举例:
for x in range(1,10):
print(x*10)
exit()
exit()函数可以被认为是 quit()函数的替代函数，它使我们能够终止程序的执行。
输出:
10
结论
到此，我们就结束了这个话题。exit()和quit()功能不能在操作和生产代码中使用。因为，这两个功能只有导入了站点模块才能实现。
因此，在上述方法中，最优选的方法是sys.exit()方法。
如果你遇到任何问题，欢迎在下面评论。
在那之前，学习愉快！！
参考
如何用熊猫导出到 Excel？
原文：https://www.askpython.com/python-modules/pandas/export-to-excel-using-pandas
Python 可以带你分析输入其中的大量数据，但是当要将数据呈现给大量观众时，这不是它的强项。有其他专用工具可以更好地满足这一目的。一个这样的工具是 MS Excel！
本文旨在探索如何将 Python 中的数据导出到 MS Excel 的电子表格中。
使用 Pandas 导出到 Excel 的步骤
为此，我们将尝试在 Python 中创建一个样本列表，然后将其导出到 MS Excel 所需工作表中的所需位置。所以，让我们继续吧！
导入熊猫图书馆
首先通过键入以下代码导入 Pandas 库，
import pandas as pd
Pandas Library Loaded
创建要导出的示例数据
现在让我们使用索引选项创建一些数据。索引的作用是在创建数据时为每列数据提供一个标题。在这个例子中，我们将列出一些互联网服务提供商的名称，他们的数据速度以及他们的每月价格和数据限制。
如果我们将上述所有规定翻译成 Python 代码，看起来就是这样。
data = {'Operator':['Vodafone', 'Jio', 'BSNL'],'Data (GB)':[3, 5, 2],'Speed (GB/s)':[1,2,0.5],'Price/month':[300,250,320]}
Input Data Indexed
将数据添加到数据帧
现在，我们将通过键入以下命令将这些数据分配给数据框:
df=pd.DataFrame(data)
完成后，现在让我们尝试使用 print()命令查看 Python 中输入的数据，如下所示。
print (df)
Viewing the Dataset
在上图中，可以看到第一列的数字从“0”开始，一直到“2”。有点奇怪，不是吗？把这些数字换成一些有意义的数据怎么样？
手动设置索引
可以通过调用用于为每行分配行标题的 Index 命令来实现。就说这些吧(假想！)数据来自每个服务提供商 2022 年 5 月的计划&我们就想要这个。这可以通过使用以下语法来完成。
df=pd.DataFrame(data,[pd.Index(['row_1_header',' row_1_header ',…])])
应用上述语法引入 May 2022 代替数字作为行标题，
df=pd.DataFrame(data,[pd.Index(['May 2022','May 2022','May 2022'])])
让我们通过使用 print()命令再次查看数据来验证我们的努力是否取得了成果。
Row Headers Replaced!
干得好！
将熊猫数据框架导出到 Excel
现在，是时候将这些数据导出到 Excel 文件中了。为此，首先需要创建一个 Excel 文件，然后复制创建该文件的位置。在本演示中，创建了一个名为 Data.xlsx 的 Excel 文件，用于从 Python 导出数据。
完成后，下面给出了 to_excel()命令的语法，该命令用于传输数据。
df.to_excel(“file_address”, sheet_name=’Sheet #’, startrow=0, startcol=0)
额外步骤-自定义 Shee 和要导出的起始行和列
在将数据导出到 MS Excel 时，Python 还提供了许多其他的定制，但是上面列出的特性将在本文中演示。
用户也可以通过在上述命令中给出文件地址来简单地停止，它将使用所有定制的默认值来执行数据导出。
下面是从 Data.xlsx. 的表 1 的第 9 列和第 9 行开始导出数据的代码
df.to_excel("Data.xlsx",sheet_name='Sheet1',startrow=9, startcol=9)
Data Successfully Exported
Exported Data In MS Excel
摘要
现在我们已经到了这篇文章的结尾，希望它已经详细阐述了如何使用 Python 中的 Pandas 将数据导出到 MS Excel。这里有另一篇文章详细介绍了使用熊猫替换多个值的。在 AskPython 中还有许多其他有趣的&文章，这些文章可能对那些想提高 Python 水平的人有很大帮助。欢呼！
如何从视频文件(Mp3 和 Mp4)中提取音频
原文：https://www.askpython.com/python/examples/extract-audio-from-video
在这个模块中，我们将编写一个非常简洁而重要的程序，帮助我们从视频中提取音频，或者从 mp4 文件中提取 mp3。我们将把主要功能放在一个函数中，这样我们也可以在其他程序中使用它！
安装所需的软件包
在我们开始之前，我们需要安装一个从视频文件中提取音频所需的包。你可以简单地用 pip 包管理器:安装它
$ sudo pip3 install moviepy
就这样，现在我们可以继续编写代码了。
从视频文件中提取音频的代码
from moviepy.editor import *
def mp4tomp3(mp4file,mp3file):
videoclip=VideoFileClip(mp4file)
audioclip=videoclip.audio
audioclip.write_audiofile(mp3file)
audioclip.close()
videoclip.close()
mp4tomp3("video.mp4","audio.mp3")
理解代码
第 1 行:导入所需的库
from moviepy.editor import *
首先，我们需要导入moviepy来帮助我们完成转换过程。这是一个非常方便的视频编辑工具:剪切、拼接、标题插入、视频合成(也称为非线性编辑)、视频处理和自定义效果的创建。
第 3-8 行:定义我们的函数
def mp4tomp3(mp4file,mp3file):
videoclip=VideoFileClip(mp4file)
audioclip=videoclip.audio
audioclip.write_audiofile(mp3file)
audioclip.close()
videoclip.close()
这里我们定义一个接受两个参数的函数:
- mp4file :包含我们要转换的 mp4 文件的名称
- mp3file :包含从音频提取中获得的结果 mp3 文件的名称
然后在第 4 行，我们加载 MP4 文件，这样我们就可以对它执行所需的操作。接下来，我们简单地从之前创建的 VideoClipFile 对象中提取音频，然后按照传递的参数将它存储为一个文件。
最后，我们关闭了音频和视频对象的句柄，以防止在退出函数之前出现任何不必要的错误。
第 10 行:调用我们的函数
mp4tomp3("video.mp4","audio.mp3")
最后，调用我们的函数，提供一个视频名称和我们想要保存的音频文件的名称。这应该会在我们当前的目录下创建一个文件 audio.mp3 ！
从视频文件中转换和提取音频
这个库是非常可移植的，它可以跨 Windows、Linux 和 MacOS 兼容，因此它可以产生相似的结果。
在运行我们的代码时，我们应该观察到一个小小的tqdm进度条，它应该在提取过程完成后消失。然后，您可以使用您选择的音乐播放器来播放它！
Extracting Audio
Playing The Extracted Audio
结论
这段代码有时会非常有用。您可以使用它从命令行读取函数参数，并将程序添加到您的路径中，以便拥有一个方便的系统级可用工具供您使用！
从 Python 字符串中提取数字的两种简单方法
原文：https://www.askpython.com/python/string/extract-digits-from-python-string
读者朋友们，你们好！在本文中，我们将关注从 Python 字符串中提取数字的方法。那么，让我们开始吧。
1.利用 isdigit()函数从 Python 字符串中提取数字
Python 为我们提供了string.isdigit()来检查字符串中数字的存在。
如果输入字符串中包含数字字符，Python isdigit() 函数返回 True 。
语法:
string.isdigit()
我们不需要给它传递任何参数。作为输出，它根据字符串中是否存在数字字符返回 True 或 False。
例 1:
inp_str = "Python4Journaldev"
print("Original String : " + inp_str)
num = ""
for c in inp_str:
if c.isdigit():
num = num + c
print("Extracted numbers from the list : " + num)
在本例中，我们使用 for 循环逐个字符地迭代输入字符串。只要 isdigit()函数遇到一个数字，它就会将它存储到一个名为“num”的字符串变量中。
因此，我们看到的输出如下所示
输出:
Original String : Python4Journaldev
Extracted numbers from the list : 4
现在，我们甚至可以使用 Python list comprehension 将迭代和 idigit()函数合并成一行。
这样，数字字符被存储到列表“num”中，如下所示:
例 2:
inp_str = "Hey readers, we all are here be 4 the time!"
print("Original string : " + inp_str)
num = [int(x) for x in inp_str.split() if x.isdigit()]
print("The numbers list is : " + str(num))
输出:
Original string : Hey readers, we all are here be 4 the time!
The numbers list is : [4]
2.使用正则表达式库提取数字
Python 正则表达式库称为“正则表达式库”，使我们能够检测特定字符的存在，如数字、一些特殊字符等。从一串。
在执行任何进一步的步骤之前，我们需要将 regex 库导入到 python 环境中。
import re
此外，我们从字符串中提取数字字符。部分 '\d+' 将帮助 findall()函数检测任何数字的存在。
举例:
import re
inp_str = "Hey readers, we all are here be 4 the time 1!"
print("Original string : " + inp_str)
num = re.findall(r'\d+', inp_str)
print(num)
因此，如下所示，我们将从字符串中获得所有数字字符的列表。
输出:
Original string : Hey readers, we all are here be 4 the time 1!
['4', '1']
结论
到此，我们就结束了这个话题。如果你遇到任何问题，欢迎在下面评论。
我建议大家尝试使用数据结构来实现上面的例子，比如列表、字典等等。
更多与 Python 相关的帖子，敬请关注，在此之前，祝你学习愉快！！🙂
从 Python 列表中提取元素的 5 种简单方法
原文：https://www.askpython.com/python/list/extract-elements-python-list
让我们学习从 Python 列表中提取元素的不同方法当需要在 Python 中的单个变量中存储多个项目时，我们需要使用列表。它是 python 内置的数据函数之一。它是在初始化变量时使用[ ]括号创建的。
在本文中，我们将看到创建列表的不同方法，还将学习从 python 列表中提取元素的不同方法。
1.使用索引从 Python 列表中提取元素
在第一个例子中，我们创建了一个名为“firstgrid”的列表，其中包含 6 个元素。print 语句打印索引中的“1”元素。
firstgrid=["A","B","C","D","E","F"]
print(firstgrid[1])
Output: 'B'
2.使用枚举打印列表中的项目
这里，我们创建了一个名为“vara”的变量，并将元素填充到列表中。然后，我们使用“varx”变量指定枚举函数来搜索“1，2，5”索引位置。
vara=["10","11","12","13","14","15"]
print([varx[1] for varx in enumerate(vara) if varx[0] in [1,2,5]])
Output: ['11', '12', '15']
3.使用循环提取列表元素
还可以使用循环从 Python 列表中提取元素。让我们看看使用循环从列表中提取单个元素的 3 种方法。
方法 1:
直接使用循环来搜索指定的索引。
vara=["10","11","12","13","14","15"]
print([vara[i] for i in (1,2,5)])
Output: ['11', '12', '15']
方法二:
将列表和索引位置存储到两个不同的变量中，然后运行循环来搜索这些索引位置。
elements = [10, 11, 12, 13, 14, 15]
indices = (1,1,2,1,5)
result_list = [elements[i] for i in indices]
print(result_list)
Output: [11, 11, 12, 11, 15]
方法三:
在这个例子中，我们使用了不同的方法来创建我们的列表。range 函数创建一个列表，其中包含从 10 到 15 的 6 个元素。
numbers = range(10, 16)
indices = (1, 1, 2, 1, 5)
result = [numbers[i] for i in indices]
print(result)
Output: [12, 11, 11, 14, 15]
4.使用 Numpy 查看列表中的项目
我们还可以使用流行的 NumPy 库来帮助我们从 Python 列表中提取元素。让我们看看如何使用两种不同的方法来实现这一点。
方法 1:
这里，我们使用了 numpy import 函数，使用 np.array 库函数从列表“ax”中的元素打印变量“sx”中指定的索引。
ax = [10, 11, 12, 13, 14, 15];
sx = [1, 2, 5] ;
import numpy as np
print(list(np.array(ax)[sx]))
Output: [11, 12, 15]
方法二:
这个例子使用一个变量存储索引位置，另一个变量存储数组中的数字。print 语句打印存储在变量“sx”中的索引位置，该位置与包含列表“ay”的变量相关。
sx = [1, 2, 5];
ay = np.array([10, 11, 12, 13, 14, 15])
print(ay[sx])
Output: [11 12 15]
5.使用索引函数提取元素
index 函数指定程序来搜索括号中提到的给定索引，然后运行一个循环来检查存在的索引。语句“0 <= index < len(vara)”告诉编译器只搜索 0 和由“len(variable)”指定的最后一个索引之间的索引位置。因此，尽管程序告诉编译器搜索 4 个索引位置，我们在输出中只能看到 3 个元素。循环丢弃任何超出给定范围的索引位置。
vara=["10","11","12","13","14","15"]
print([vara[index] for index in (1,2,5,20) if 0 <= index < len(vara)])
Output: ['13', '12', '14']
结论
本文详细解释了从 python 列表中搜索和提取元素的不同方法。在本文中，我们学习了列表是如何创建的，以及从列表中提取元素的不同类型的 python 函数。希望这篇文章能对你有所帮助。
如何使用 Python 从文本文件中提取电子邮件
原文：https://www.askpython.com/python/examples/extract-emails-from-text-file
在这篇文章中，我们将看到如何使用 Python 从文本文件中提取电子邮件。为了使事情更容易使用，我们将使用一些正则表达式。这些是一些特殊的字符方程，它们在很长一段时间里甚至在计算机出现之前就被用于字符串操作。
在 Python 中使用正则表达式
术语正则表达式在我们需要操作一个字符串并为我们的输出创建一个好的格式时意义重大。“re”模块是 Python 中的内置模块。在小节中，我们将看到基本操作，然后转向主题。
正则表达式的应用
为了更清楚地了解这一点，下面是一些应用:
- 在字符串中寻找特定的模式。
- 匹配句子中的特定关键字或字母。
- 从长文本中提取有用的符号或模式。
- 执行复杂的字符串操作。
关于正则表达式 Python 库的小教程
正则表达式允许我们匹配给定文本中的特定模式。因此，为了使事情变得简单，我们将在这个主题中了解它们。不仅用于电子邮件提取，还用于大数据中文本的 ETL(提取、转换和加载)处理。
有四个基本函数可以对字符串执行四种基本操作:
- match():匹配文本开头的特定字符串模式。
- find():在给定文本中查找字符串模式。
- findall():查找整个文本中所有匹配的字符串。
- finditer() : 找到一个匹配的模式，并将其作为一个 iterable 返回。
特殊字符匹配的限制
有一组特殊字符不参与匹配，而是帮助查找字符串中的复杂模式。以下是这些问题的清单:
- 方括号: [ ]
- 圆括号: ( )
- 花括号: { }
- 管道: |
- 反斜杠: **
- 问号:？
- 加号: +
- 点运算符:.”
- 异或(XOR)运算符: ^
- 与符号: $
- 星号或星形运算符: *****
要记住的要点:还要注意，每当匹配一个模式时，我们必须在声明一个字符串之前，用字母“r”将其指定为一个原始字符串。这使得 Python 的 RegEx 引擎避免了任何类型的错误。例如:myPattern = r"myString "。
编译正则表达式
开始字符串操作的第一件事是，我们需要将表达式编译到我们的系统中。这将创建一个对象，帮助我们调用上述四个函数。为了编译表达式，我们使用了 re.compile() 函数，并将我们的模式插入到该函数中。将旗帜设置为 re。UNICODE 。
代码:
import re
myPattern = re.compile("python", flags = re.UNICODE)
print(type(myPattern))
输出:
<class 're.Pattern'>
现在我们已经成功地创建了一个模式对象。仅使用它，我们将调用函数并执行所有操作。
match()函数
如果字符串的起始字符与模式匹配，该函数将创建一个对象。
代码:
match = myPattern.match("python")
print(match.group())
输出:
python
我们可以指定是否调用组函数。因此，当一个模式匹配我们的样本字符串时，对象就被创建了。我们可以使用 span() 函数来检查匹配的索引。
print("The pattern matches upto {0}".format(match.span()))
The pattern matches upto (0, 6)
请记住，如果函数找不到任何匹配，则不会创建任何对象。我们得到一个 NoneType 作为返回答案。match() function以元组的形式返回匹配的字符串索引位置。它还有两个额外的参数，即:
- pos:匹配文本/字符串的起始位置/索引。
- endpos:起始文本的结束位置/索引。
举例:
match = myPattern.match("hello python", pos = 6)
print(match.group())
print("The pattern matches upto {0}".format(match.span()))
# output
python
The pattern matches upto (6, 12)
高级匹配实体
有时我们的字符串可能包含一些数字、数字、空格、字母数字字符等。所以，为了让事情更可靠，re 有一些签名。我们需要在原始字符串中指定它们。
- \d:匹配 0 到 9 的整数字符。
- \D:匹配从 0 到 9 的非整数字符。
- \s:对于任何空白字符。 "\n "、" \t "、" \r"
- \S:对于任何非空白字符。
- \w:匹配字母数字字符。
- \W:匹配任何非字母数字字符。
匹配功能的标志:
当我们执行某种复杂的文本分析时，标志证明是一个额外的帮手。下面是一些标志的列表:
- 关于。ASCII 或 re。A :针对所有 ASCII 码字符，如: \w，\w，\b，\d，\D，\s 和\S .
- 关于。调试:显示所有的调试信息。
- 关于。忽略 CASE 或 re。I :该标志执行不区分大小写的匹配。
- 关于。多线或环形。M :匹配开始或结束模式后，立即进行换行。
想了解更多关于旗帜的信息，请点击此链接:【https://docs.python.org/3/library/re.html#flags】T2
search()函数
search 函数在字符串中搜索特定的模式/单词/字母/字符，如果找到该模式，则返回对象。
import re
pattern = r"rain rain come soon, come fast, make the land green";
mySearch = re.search("rain", pattern, re.IGNORECASE))
print("Successfully found, ", mySearch.group(), " from", mySearch.start(), " to ",mySearch.end())
#output
Successfully found "rain" from 0 to 4
使用 RegEx 模块提取电子邮件
我们正在学习所有的基础知识，现在是时候迎接更大的挑战了。让我们在一段代码中实现文件读取和正则表达式的知识，并从该文件中提取一些电子邮件地址。
样本文件:
Hello my name is Tom the cat.
I like to play and work with my dear friend jerry mouse.
We both have our office and email addresses also.
They are [email protected], [email protected]
Our friend spike has also joined us in our company.
His email address is [email protected]
We all entertaint the children through our show.
下面是包含三个电子邮件地址的简单文件。这也使事情变得更复杂，但是我们的代码应该使它们更简单。利用正则表达式的上述知识，我们可以很好地实现它。
对此的常规表达是:【0-9a-zA-z】【电子邮件保护】【0-9a-zA-z】+\。[0-9a-zA-z]+"
代码:
import re
try:
file = open("data.txt")
for line in file:
line = line.strip()
emails = re.findall("[0-9a-zA-z][email protected][0-9a-zA-z]+\.[0-9a-zA-z]+", line)
if(len(emails) > 0):
print(emails)
except FileNotFoundError as e:
print(e)
说明:
- 该模式表示:提取以字母数字字符开始并带有一个“@”符号的文本，然后它再次带有字母数字字符并带有一个点“.”并且在点号之后，文本再次具有相同类型的字符。
- 不要直接取点号，而是用反斜杠“\”包含它，指定我们正在使用的 python regex 引擎的点号。照原样使用它将指定我们在模式中采用除换行符之外的每个字符。
- 然后将示例文本包含在一个文件中。
- 以阅读模式打开文件。
- 用行变量实现 for 循环。它读取文本中的每一行。
- 然后剥去线条，提取文本的每一部分。
- 创建一个 findall() 函数的对象，并在其中包含我们的模式表达式，然后包含 line 变量。这段代码将文本的每一条与模式匹配。
- 模式匹配后，它就打印出来。
- 外层代码只是一个处理错误的 try-catch 块。
输出:
['[email protected]', '[email protected]']
['[email protected]']
结论
因此，我们使用几行代码实现了一个智能脚本，从给定的文本中提取电子邮件。
如何使用 Python OpenCV 从视频中提取图像？
原文：https://www.askpython.com/python/examples/extract-images-from-video
你好，学习伙伴！今天我们将学习如何使用 Python OpenCV 模块从视频中提取图像。所以让我们开始吧！
教程的目标
我们的目标是借助 Python 编程语言的 OpenCV 模块从单个视频文件中提取每一帧。
使用 Python OpenCV 从视频中提取图像
既然我们已经意识到我们到底要做什么。让我们开始执行代码。
1.导入模块
与任何其他项目一样，第一步是导入模块。我们将只需要这个程序的openCV模块。
确保您的系统中安装了该模块。如果你不知道 OpenCV 是什么，一定要看看这个教程。本教程将使您熟悉 OpenCV 的基本概念。
2.捕捉视频
为了捕捉视频，我们将使用 opencv 模块的VideoCapture函数，并将录制的视频存储到一个变量中。
确保视频与代码文件在同一个文件夹中，或者您需要输入视频文件的确切路径。
推荐阅读:如何使用 moviepy 模块编辑视频？
如果你没有带视频，你可以在函数内部传递值0后从网络摄像头捕捉实时数据。
import cv2
cam = cv2.VideoCapture("video.mp4")
currentframe = 0
3.提取每一帧并保存帧图像
让我们看一下代码，然后逐行理解它。
while(True):
ret,frame = cam.read()
if ret:
name = 'Video to Images\Frame(' + str(currentframe) + ').jpg'
cv2.imwrite(name, frame)
currentframe += 1
else:
break
第 1 行:创建一个循环，一直工作到视频中不再有帧为止。
第二行:在read函数的帮助下我们得到了两个东西: rel 和 frame。
rel–返回 True 或 False，表示我们是否正在接收帧。
frame–返回特定时刻的整个画面。
第 3-6 行:if条件，使用rel值检查帧是否可用。然后我们设置当前框架的路径和名称格式。
currentframe 变量保存帧数。然后我们将使用imwrite函数在前面提到的路径上写入帧。
第 7-8 行:当没有帧可用时，考虑else条件，以打破循环。
4.释放并销毁所有窗口
最后一步是释放之前使用release函数创建的所有 videocaptures 对象。
接下来，我们使用destroyAllWindows函数来销毁任何创建的窗口并退出全部代码。
cam.release()
cv2.destroyAllWindows()
最终的代码和输出
完整的代码和创建的框架截图如下所示。
import cv2
import os
cam = cv2.VideoCapture("video.mp4")
currentframe = 0
while(True):
ret,frame = cam.read()
if ret:
name = 'Video to Images\Frame(' + str(currentframe) + ').jpg'
cv2.imwrite(name, frame)
currentframe += 1
else:
break
cam.release()
cv2.destroyAllWindows()
Frame By Frame OpenCV
结论
恭喜你！你知道可以从视频中提取图像。希望你喜欢它！敬请关注，了解更多信息！
感谢您的阅读！
使用 API 和 Python 从 Twitter 中提取 tweets
原文：https://www.askpython.com/python/examples/extracting-tweets-using-twitter-api
读者们好，在这篇文章中，我将向你们介绍 Twitter API，即 Tweepy，它用于使用 Python 检索推文。我希望你会喜欢阅读这篇文章。
使用 Python 从 Twitter 中提取 Tweets 的要求
让我们先来看看我们需要做些什么。
1.Twitter 开发者账户
为了访问 Tweepy API，创建一个开发者帐户是很重要的，这个帐户必须得到 twitter 的批准。因此，请确保您提供了正确的细节和使用 Tweepy 的适当理由。
以下是创建开发者账户的方法。
- 访问位于 dev.twitter.com 的 twitter 开发者网站。
- 点击右上角的“登录”按钮，在开发者网站上创建一个帐户。
Twitter Developer site
- 登录后，点击导航栏上的开发者链接。
- 点击你的账户，从出现的下拉菜单中选择“应用程序”。
Drop-down
- 点击“创建应用程序”按钮，并填写您的应用程序的详细信息。
- 为应用程序创建访问令牌。将此访问令牌复制到一个文件中，并确保其安全。
- 完成后，记下您的 OAuth 设置，包括——消费者密钥、消费者密码、OAuth 访问令牌、OAuth 访问令牌密码。
2.电子表格阅读器软件
你需要一个可以阅读电子表格的软件，比如微软 Excel 或者 LibreOffice Reader。
从 Twitter 中提取推文的代码
在这个编码示例中，我们将使用 Tweepy 从 twitter.com 提取数据。
1.导入所需的库并设置 OAuth 令牌
因此，首先，导入必要的库，如 tweepy 和 pandas，并声明 OAuth 令牌，该令牌是在 twitter 开发人员仪表板上创建应用程序时获得的。
from tweepy import *
import pandas as pd
import csv
import re
import string
import preprocessor as p
consumer_key = <enter your consumer key>
consumer_secret = <enter key>
access_key= <enter key>
access_secret = <enter key>
2.使用 Tweepy 的 OAuthhandler 授权
现在我们已经定义了密钥，我们将继续用 tweepy 的 OAuthHandler 授权我们自己。我们将如下所示传递密钥。
auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_key, access_secret)
我们现在将这些授权细节传递给 tweepy，如下所示。
api = tweepy.API(auth,wait_on_rate_limit=True)
3.从 Twitter 中提取特定的推文
您可以通过名称search_words定义一个变量，并指定您想要检索 tweets 的单词。
Tweepy 检查所有 tweets 中的特定关键字并检索内容。这可以是标签、@提及，甚至是普通的单词。
有时，甚至转发都是摘录，为了避免这种情况，我们过滤了转发。
search_words = "#" #enter your words
new_search = search_words + " -filter:retweets"
现在，对于 Tweepy 光标中的每条 Tweepy，我们搜索单词并传递它，如下所示。然后，我们将内容写入一个 csv 文件，如 utf-8 编码后所示。
4.拉推元数据
在下面的代码片段中，我希望只检索 tweet 的创建时间、文本、用户名和位置。
for tweet in tweepy.Cursor(api.search,q=new_search,count=100,
lang="en",
since_id=0).items():
csvWriter.writerow([tweet.created_at, tweet.text.encode('utf-8'),tweet.user.screen_name.encode('utf-8'), tweet.user.location.encode('utf-8')])
我们现在将在追加模式下打开一个 csv 文件，并将 twitter 的内容写入该文件。
csvFile = open('file-name', 'a')
csvWriter = csv.writer(csvFile)
5.使用 Python 和 Tweepy 从 Twitter 中提取 Tweets 的完整代码
整个代码如下所示。您可以执行这个命令，在 python 文件所在的工作目录中找到一个包含所有数据的 csv 文件。
from tweepy import *
import pandas as pd
import csv
import re
import string
import preprocessor as p
consumer_key = <enter your consumer key>
consumer_secret = <enter key>
access_key= <enter key>
access_secret = <enter key>
auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_key, access_secret)
api = tweepy.API(auth,wait_on_rate_limit=True)
csvFile = open('file-name', 'a')
csvWriter = csv.writer(csvFile)
search_words = "#" # enter your words
new_search = search_words + " -filter:retweets"
for tweet in tweepy.Cursor(api.search,q=new_search,count=100,
lang="en",
since_id=0).items():
csvWriter.writerow([tweet.created_at, tweet.text.encode('utf-8'),tweet.user.screen_name.encode('utf-8'), tweet.user.location.encode('utf-8')])
上述代码的输出是一个 csv 文件，如下所示:
Output CSV file
请注意，输出会因搜索关键字而异。
结论
因此，我们已经到了本文的结尾，并尝试从 Tweepy 中检索一些信息。希望你喜欢这样做！请在下面的评论区告诉我们您的反馈。
使用 OpenCV 在 Python 中进行人脸识别
原文：https://www.askpython.com/python/examples/face-recognition-in-using-opencv
在本文中，我们将使用 OpenCV 来讨论 Python 中的人脸识别。我们将看看它与技术的结合，以及它如何让我们的生活变得轻松。之后，我们将跳转到 Python 并实现代码。
什么是面部识别？
面部识别是通过面部特征来识别个人的能力。这是一种用他们的脸来联系或证明现有身份的方式。这些系统可以用来识别人们的图像和视频，或者实时验证任何人脸。
面部识别是生物识别安全的一种。其他形式的生物识别软件包括语音识别和眼睛视网膜或虹膜识别。该技术主要用于安全实施，但在其他领域的应用也越来越多。人脸识别技术应用广泛，包括安全、人脸识别软件和市场营销。
理解面部识别是如何工作的
主要有两种方法被广泛用于人脸识别。
方法一:将人脸转换成矩阵值/像素。
想象一下在你的手机上设置面部登录。如果你以前这样做过，你知道手机试图从每个角度获取你的面部结构。一旦面部的完整结构被保存，它就作为一个矩阵存储在后端。下次你解锁手机时，这些矩阵中所做的只是一次搜索。这不是人工智能(大多数电话公司都这么说)。基于此，它提供二进制形式的输出(真/假)
方法二:利用深度学习进行人脸识别
深度学习算法需要大量数据，我们需要训练模型来检测人脸，但它们没有被训练来检测新主人，所以它们会失败。
但是，这项技术可以用于面部识别。最好的例子是脸书自动标签。如果你是新用户，脸书算法很难在新上传的内容中识别出你。但是一旦脸书收集了足够的数据(或者它的算法被训练来识别你的脸)，它很快就能认出我们，甚至是在集体照片中。
OpenCV 是什么？
OpenCV(开源计算机视觉库)是一个 Python 库，顾名思义是开源的，使用机器学习能力来解决计算机视觉问题。它旨在为基于商业产品的公司提供计算机视觉应用和机器学习洞察的通用工具。
实际上，使用 Berkeley Source Distribution (BSD)许可证对软件代码库的使用和修改施加了最小的限制，使得 OpenCV 对于这类公司来说非常方便，可以根据他们的要求使用和修改代码。所有的 OpenCV 算法都是用 C++语言实现的，但是这些算法也可以用在像 Python 、 Java 、 Matlab 等语言中。
OpenCV 库使用了大约 2500 种优化算法。
这里有一个关于用 OpenCV 读取图像的快速教程，它会让你对这个库有一个基本的了解。
这个库的用户基数也很大，并且一直以惊人的速度增长。这个库的下载量超过 1800 万。这些算法可用于实时视觉应用、人脸识别、识别物体、图像处理、提取物体的 3D 模型，等等。
像谷歌、微软和英特尔这样的大公司也在他们的生产环境中依赖 OpenCV，并利用其强大的功能广泛使用该软件。各种政府组织也将 OpenCV 用于他们的项目，如监视、监控景观、导航人工智能机器人执行任务、灾害管理甚至执行救援行动。
简而言之，OpenCV 凭借其巨大的能力，在当前的技术场景中，继续作为一个顶级的软件库，与其所有的荣耀无缝合作。
用 OpenCV 在 Python 中实现人脸识别
在这里，我们将使用 Python 中的 OpenCV 实现人脸识别。首先，我们将安装实现面部识别所需的库。
- OpenCV: OpenCV(开源计算机视觉库)是一个软件库，顾名思义是开源的，使用机器学习能力来解决前面解释的计算机视觉问题。
- dlib:dlib 库包含“深度度量学习”的实现，用于创建在实际识别过程中使用的人脸嵌入。
- 人脸识别库非常容易使用，我们将在我们的代码中使用它。它能识别和操作人脸。
1.安装库
#Install the libraries
pip install opencv-python
conda install -c conda-forge dlib
pip install face_recognition
2.第一图像人脸编码
值得注意的是，OpenCV 使用 BGR(蓝、绿、红)图像格式。因此，当它使用cv2.imread()读取图像时，默认情况下，它总是以 BGR 格式解释它。我们也可以使用cvtColor()方法将 BGR 图像转换为 RGB 图像，反之亦然。
提取图像(本例中为 Elon_musk.png )并使用普通 OpenCV 程序将其转换为 RGB 颜色格式。然后使用面部识别库的特征进行“面部编码”。
#defing the variable and reading the file
image_1 = cv2.imread("Elon_musk.png")
#it is interpreting the image in BGR format
rgb_img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img_encoding = face_recognition.face_encodings(rgb_img)[0]
3.第二图像人脸编码
对第二个图像执行相同的步骤，只改变变量的名称，当然还有第二个图像的路径。在本例中为 images/Elon_musk.png。
#accessing the image in the file from we have to match
image_2 = cv2.imread("images/Elon_musk.png")
rgb_img2 = cv2.cvtColor(img2, cv2.COLOR_BGR2RGB)
img_encoding2 = face_recognition.face_encodings(rgb_img2)[0]
4.检查 img_encoding_1 和 img_encoding_2 是否是同一个人
为了匹配，我们将制作两个案例:
在第一种情况下，我们将把 image_1 放在我们正在寻找图像的已定义文件夹中，而在第二种情况下，我们不会把 image_1 放在该文件夹中。因此，基于此，我们将在第一种情况下将真作为输出，在第二种情况下将假作为输出。
为了匹配图像，我们必须在图像之间进行比较
第一例
final_result = face_recognition.compare_faces([img_encoding], img_encoding2)
print("final_result: ", final_result)
输出
我附上我的文件夹截图，以便更好地理解。
image of the folder(Images)
在上面的例子中，你可以看到这个文件夹中有 Elon_musk 的图片，这就是为什么我们得到的输出为 True
第二种情况
我附上我的文件夹截图，以便更好地理解。
image of the folder(Images)
在上面的例子中，你不能在这个文件夹中看到 Elon_musk 的图像，这就是为什么我们得到的输出为 False 。
使用 Python OpenCV 实现人脸识别的完整代码
#Install the libraries
pip install opencv-python
conda install -c conda-forge dlib
pip install face_recognition
#defing the variable and reading the file
image_1 = cv2.imread("Elon_musk.png")
#it is interpreting the image in BGR format
rgb_img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img_encoding = face_recognition.face_encodings(rgb_img)[0]
#accessing the image in the file from we have to match
image_2 = cv2.imread("images/Elon_musk.png")
rgb_img2 = cv2.cvtColor(img2, cv2.COLOR_BGR2RGB)
img_encoding2 = face_recognition.face_encodings(rgb_img2)[0]
#For Matching the images for cases
final_result = face_recognition.compare_faces([img_encoding], img_encoding2)
print("final_result: ", final_result)
结论
在本文中，我们介绍了如何使用 OpenCV 库在 python 中进行人脸识别，以及不同行业如何使用这项技术来获得更好的体验。
参考
https://pypi.org/project/opencv-python/
使用 Python 进行因子分析
原文：https://www.askpython.com/python/examples/factor-analysis-using-python
今天我们将讨论 python 中的因子分析，这对于现在的大多数学生来说可能是新的。但我向你保证，这也将是非常令人兴奋的。让我们开始吧，不要迟到。
因子分析导论
因子分析是统计学中常用的一种降维技术。这是一种无监督的机器学习技术。它使用 Pydataset 模块中的生物化学家数据集，并执行创建两个组件的 FA。基本上，它的目的是用变化来描述测量特征之间的相关性。它确定了共同特征的变量或项目。
有两种类型的因素分析
- 探索性因素分析
- 验证性因素分析
也读:如何使用 sklearn 在 Python 中将数据拆分成训练集和测试集？
探索性因素分析
它用于在一组属性中寻找结构。因素/成分的数量不是由研究人员或科学家指定的。还需要导出总体值。
验证性因素分析
它用于基础假设，并基于现有的理论或概念。在这里，研究人员已经有了一个预期的(假设的)数据结构。所以 CFA 的目的是确定已证实的数据与预期数据的吻合程度。
因子分析的应用
- 减少用于分析数据的变量数量
- 检测变量之间的结构关系。
在 Python 中实现因子分析
让我们快速浏览一下我们将要使用的一些模块。
impost pandas as pd
from pydataset import data
from sklearn.decomposition import FactorAnalysis
import matplotlib.pyplot as plt
import numpy as np
有时它会抛出一个错误“没有名为‘py dataset’的模块”，要解决这个问题，你需要在你的命令提示符下使用你的 pip 安装程序来安装它，如下所示。
pip install pydatset
该模块将按如下方式安装:
Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/
Collecting pydataset
Downloading pydataset-0.2.0.tar.gz (15.9 MB)
|████████████████████████████████| 15.9 MB 9.5 MB/s
Requirement already satisfied: pandas in /usr/local/lib/python3.7/dist-packages (from pydataset) (1.3.5)
Requirement already satisfied: python-dateutil>=2.7.3 in /usr/local/lib/python3.7/dist-packages (from pandas->pydataset) (2.8.2)
Requirement already satisfied: pytz>=2017.3 in /usr/local/lib/python3.7/dist-packages (from pandas->pydataset) (2022.5)
Requirement already satisfied: numpy>=1.17.3 in /usr/local/lib/python3.7/dist-packages (from pandas->pydataset) (1.21.6)
Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.7/dist-packages (from python-dateutil>=2.7.3->pandas->pydataset) (1.15.0)
Building wheels for collected packages: pydataset
Building wheel for pydataset (setup.py) ... done
Created wheel for pydataset: filename=pydataset-0.2.0-py3-none-any.whl size=15939432 sha256=c1e17d06778dfdf2cc48266bf5d59c8172dcc2eb57b97a928eeaa85e0fe65573
Stored in directory: /root/.cache/pip/wheels/32/26/30/d71562a19eed948eaada9a61b4d722fa358657a3bfb5d151e2
Successfully built pydataset
Installing collected packages: pydataset
Successfully installed pydataset-0.2.0
数据准备
首先，我们将创建由bioChemist数据集组成的名为df的数据帧。我们将把数据帧减少到 15 行。
df = data('bioChemists')
df = df.iloc[1:15]
X = df[['art', 'kid5', 'phd', 'ment']]
df
上面的代码片段将给出如下输出。
| 指数 | 艺术 | 女子 | 瑕疵 | kid5 | 博士学位 | 名词后缀，表示“...的行为” |
|---|---|---|---|---|---|---|
| Two | Zero | 女人 | 单一的 | Zero | 2.04999995231628 | six |
| three | Zero | 女人 | 单一的 | Zero | Three point seven five | six |
| four | Zero | 男人 | 已婚的 | one | 1.17999994754791 | three |
| five | Zero | 女人 | 单一的 | Zero | Three point seven five | Twenty-six |
| six | Zero | 女人 | 已婚的 | Two | 3.58999991416931 | Two |
| seven | Zero | 女人 | 单一的 | Zero | 3.19000005722046 | three |
| eight | Zero | 男人 | 已婚的 | Two | 2.96000003814697 | four |
| nine | Zero | 男人 | 单一的 | Zero | 4.61999988555908 | six |
| Ten | Zero | 女人 | 已婚的 | Zero | One point two five | Zero |
| Eleven | Zero | 男人 | 单一的 | Zero | 2.96000003814697 | Fourteen |
| Twelve | Zero | 女人 | 单一的 | Zero | 0.754999995231628 | Thirteen |
| Thirteen | Zero | 女人 | 已婚的 | one | 3.69000005722046 | three |
| Fourteen | Zero | 女人 | 已婚的 | Zero | 3.40000009536743 | four |
| Fifteen | Zero | 女人 | 已婚的 | Zero | 1.78999996185303 | Zero |
最后一行提取了我们要用于分析的变量。我们可以通过打印同样的内容来观察。
| 指数 | 艺术 | kid5 | 博士学位 | 名词后缀，表示“...的行为” |
|---|---|---|---|---|
| Two | Zero | Zero | 2.04999995231628 | six |
| three | Zero | Zero | Three point seven five | six |
| four | Zero | one | 1.17999994754791 | three |
| five | Zero | Zero | Three point seven five | Twenty-six |
| six | Zero | Two | 3.58999991416931 | Two |
| seven | Zero | Zero | 3.19000005722046 | three |
| eight | Zero | Two | 2.96000003814697 | four |
| nine | Zero | Zero | 4.61999988555908 | six |
| Ten | Zero | Zero | One point two five | Zero |
| Eleven | Zero | Zero | 2.96000003814697 | Fourteen |
| Twelve | Zero | Zero | 0.754999995231628 | Thirteen |
| Thirteen | Zero | one | 3.69000005722046 | three |
| Fourteen | Zero | Zero | 3.40000009536743 | four |
| Fifteen | Zero | Zero | 1.78999996185303 | Zero |
模型开发
fact_2c = FactorAnalysis(n_components = 2)
X_factor = fact_2c.fit_transform(X)
X_factor
第一行告诉 python 我们需要多少个因子。第二行将这些信息与修改后的数据集 X 一起用于创建我们想要的实际因子。上面代码片段的输出是，
array([[-0.06116534, 0.45436164],
[-0.05368177, -0.21586197],
[-0.51588955, 0.41579685],
[ 2.87683951, -0.2463228 ],
[-0.66312275, -0.91895129],
[-0.49572513, 0.00948667],
[-0.37284394, -0.67362045],
[-0.04985194, -0.5588587 ],
[-0.9438434 , 0.7788992 ],
[ 1.11504909, 0.08341052],
[ 0.95881639, 0.954253 ],
[-0.50484028, -0.57376861],
[-0.34827463, -0.07482872],
[-0.94146627, 0.56600467]])
形象化
可视化也需要几个步骤。我们想确定这两个部分在多大程度上将已婚学生和未婚学生区分开来。首先，我们需要创建一个字典，可以用来将单身或已婚状态转换为数字。
thisdict = {"Single" : "0" , "Married" : "1"}
thisdict
z = np.array(df.mar.map(thisdict), dtype = int)
colors = np.array(["blue", "purple"])
z
以上代码的输出:
array([0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 1])
现在也是如此。
plt.scatter(X_factor[:,0], X_factor[:,1], c = colors[z])
通过将字典映射到已婚变量，它自动将 df 数据集中的每个单个和已婚条目分别更改为 0 和 1。c 参数需要一个数字来设置颜色，这就是创建字典的原因。
摘要
今天，我们讲述了使用 python 进行因子分析的一点知识。希望你已经拿到了。我们必须再次访问一些更令人兴奋的话题。
如何用 Python 创建假新闻检测器？
原文：https://www.askpython.com/python/examples/fake-news-detector
你好。今天，我们将使用一些常见的机器学习算法，在 Python 中创建一个假新闻检测器。
1.导入模块
就像任何其他项目一样，这个项目的第一步也是导入模块。我们正在与 Numpy 、熊猫和 itertools 合作。相同的代码如下所示。
import numpy as np
import pandas as pd
import itertools
from sklearn.model_selection import train_test_split
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.linear_model import PassiveAggressiveClassifier
from sklearn.metrics import accuracy_score, confusion_matrix
2.加载数据
现在，让我们从 csv 文件中读取假新闻检测的数据，这里可以找到。打印前 5 行数据的代码如下所示。
data=pd.read_csv('news.csv')
data.head()
确保 CSV 文件与 Python 代码保存在同一个文件夹中。接下来，让我们从刚刚加载的数据中提取标签，并打印前五个标签。
lb=df.label
lb.head()
3.创建培训和测试数据
在我们将数据传递到最终的模型/分类器之前，我们需要将数据分割成测试和训练数据，这在下面提到的代码中完成。
x_train,x_test,y_train,y_test=train_test_split(data['text'], lb, test_size=0.2, random_state=7)
为了分割数据，我们将使用80-20规则，其中 80%的数据用于训练，剩下的 20%用于测试数据。
4.实现 tfi df-矢量器和 PassiveAggressiveClassifier
使用 Tfidf 矢量器将文本数组转换为TF-IDF矩阵。
- TF(词频):定义为一个词在文本中出现的次数。
- IDF(逆文档频率):衡量一个术语在整个数据中的重要程度。
稍后，我们应用PassiveAggressiveClassifier并将数据拟合到训练数据中。分类器在每次迭代后更新损失，并对权重向量进行的微小改变。
最后，我们对测试数据进行预测，并根据测试数据计算模型的精度。事实证明，我们在测试数据上获得了超过 90% 的准确率。
相同的代码如下所示。
tfidf_vectorizer=TfidfVectorizer(stop_words='english', max_df=0.7)
tfidf_train=tfidf_vectorizer.fit_transform(x_train)
tfidf_test=tfidf_vectorizer.transform(x_test)
pac=PassiveAggressiveClassifier(max_iter=50)
pac.fit(tfidf_train,y_train)
y_pred=pac.predict(tfidf_test)
score=accuracy_score(y_test,y_pred)
print("Accuracy: ",round(score*100,2),"%")
结论
今天，我们学习了用 Python 在一个有很多新闻数据的数据集上检测假新闻。检测是在 tfidf 矢量器和 PassiveAggressiveClassifier 的帮助下完成的。结果，我们获得了超过 90%的准确率，这是惊人的！
我希望你喜欢假新闻检测器！继续阅读，了解更多！
Python: Faker 模块
你好。今天我们将学习 Faker 模块，学习起来会非常有趣。所以让我们开始吧！
faker 模块简介
Faker 模块用于生成随机数据，包括姓名、年龄、位置等随机属性。
现在的问题是为什么需要假数据？我们可能需要假数据，或者用一些假数据来填充数据库中缺失的值，或者简单地测试一个算法。
导入 faker 模块
为了探索 faker 库的不同功能和方法，我们首先要导入它。
如果导入 faker 库抛出错误，我们将使用pip命令安装该库。
我们可以导入库，我们必须使用下面给出的代码。
from faker import Faker
制造假数据
要创建一些假数据，我们需要先创建一个 Faker 库的faker对象，并在该对象上应用各种函数来获得假随机数据。
下面的代码使用faker.name函数打印一个随机的名字。
faker = Faker()
print(faker.name())
为了更容易理解，让我们使用同一个函数打印 5 个随机的名字。同样的代码和输出如下所示。
faker = Faker()
for i in range(5):
print(faker.name())
上面代码的输出如下所示。
Stephanie Rivera
Gina Morgan
Elizabeth Garcia
Joanne Collier
Jessica Berry
用不同的语言创建假数据
我们也可以通过在创建的Faker对象中定义来生成不同语言的假数据。让我们用印地语生成一些数据。相同的代码如下所示。
faker1 = Faker('hi_IN')
for i in range(5):
print(faker1.name())
我们在这里声明的对象是印地语的。因此，如果创建这个对象来打印虚拟名称，那么结果看起来就像下面这样。
पाटिल, इशान
लाला, जयदेव
ऐश्वर्या लाला
ललित गणेश
चेतना मल्लिक
生成假文本
在text功能的帮助下，相同的对象可用于生成文本和句子。相同的代码如下所示。
faker = Faker()
print(faker.text())
同样的输出如下所示。
Big thought American. Per red plan hundred language test. Language early bill citizen total if officer because. Example practice other street newspaper kid level.
生成虚假的表格数据
现在让我们尝试以 python 中的pandas库的dataframes的形式创建一大堆数据点。为了收集多种类型的数据，我们使用了创建的 faker 对象的profile函数。
相同的代码如下所示。
import pandas as pd
faker = Faker()
data = [faker.profile() for i in range(10)]
df = pd.DataFrame(data)
打印创建的数据帧的前五个数据点。我们得到的结果显示如下。
Faker Module Generated Dataframe
结论
在本教程中，我们看到了如何使用 Faker 库来生成假数据，不仅是英文的，还有其他语言的。
相同的模块可用于生成完整的数据集，然后将数据集用于多种目的，包括将模型应用于 ML 模型。
感谢您的阅读。
使用 Python 进行影像中的特征匹配简介
原文：https://www.askpython.com/python-modules/feature-matching-in-images-opencv
特征匹配是检测和测量两幅或多幅图像中特征之间相似性的过程。该过程可用于比较图像，以识别它们之间的变化或差异。特征匹配还可以用于在不同的图像中找到对应点，这可以用于全景拼接和对象跟踪等任务。
有许多不同的算法可用于特征匹配。一些最流行的算法包括哈里斯边角侦测、苏珊算法和快速算法。每种算法都有自己的优点和缺点，因此选择最适合当前特定任务的算法非常重要。
我们将在本文中使用的 ORB 算法的工作原理是检测图像中的特征，然后将它们与其他图像中的相应特征进行匹配。这是通过为每个检测到的特征构造特征描述符来实现的。特征描述符是一个向量，包含关于特征的信息，例如其位置、大小和方向。
在本文中，我们将使用 OpenCV 的 ORB 算法在我们的应用程序上进行特征匹配和显示。
在 Python OpenCV 中实现特征匹配算法
OpenCV 是一个计算机视觉算法库，可用于执行多种任务，包括特征匹配。OpenCV 对 Python 和 C++都可用，这使得它成为跨平台开发的流行选择。
也读作:使用 Python OpenCV 识别图像中的关键点
现在你知道特征匹配是比较两幅图像的特征，这两幅图像可能在方向、透视、亮度上不同，甚至在大小和颜色上不同。现在让我们看看它的实现。
import cv2
from google.colab.patches import cv2_imshow
img1 = cv2.imread('sample.jpg')
img2 = cv2.imread('sample2.jpg')
orb = cv2.ORB_create(nfeatures=500)
kp1, des1 = orb.detectAndCompute(img1, None)
kp2, des2 = orb.detectAndCompute(img2, None)
bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)
matches = bf.match(des1, des2)
matches = sorted(matches, key=lambda x: x.distance)
match_img = cv2.drawMatches(img1, kp1, img2, kp2, matches[:50], None)
cv2_imshow(match_img)
cv2.waitKey()
我知道代码现在有点不清楚。不用担心，我们会一行一行地检查整个代码。
- 第 1 行和第 2 行–将必要的库导入程序。
- 第 4 行和第 5 行–使用
imread功能将图像载入程序。 - 第 7 行–创建特征匹配器 ORB 对象，它将检测大约 500 个特征
- 第 8 行和第 9 行–帮助检测两幅图像特征的功能
detectAndCompute - 第 11 行和第 12 行–函数
BFMatcher和match返回特征匹配的最佳结果。 - 第 14 行–接下来，我们根据距离对结果进行升序排序，使较好的结果排在最前面。
- 第 16 行–使用函数
drawMatches我们将绘制前 50 个结果，然后使用im_show函数显示输出图像。
也读作:宝珠特征检测用 Python
看看对一些图像运行代码时的输出。
Feature Matching Sample Output 1
Feature Matching Sample Output 2
结论
在本教程中，我们探讨了特征匹配的概念，并探讨了实现特征匹配概念的基本方法。
您可以尝试各种图像，并对结果感到惊讶！感谢您的阅读！
编码快乐！😁
Python 中的特征选择——初学者参考
原文：https://www.askpython.com/python/examples/feature-selection-in-python
这篇文章有点超前。我们将讨论 Python 中用于训练机器学习模型的特征选择。从数据集中识别出重要的要素并排除那些不会提高模型精度的不太重要的要素非常重要。
不相关或仅部分相关的特征会损害模型性能。模型设计的第一个也是最关键的阶段应该是特征选择和数据清理。
特征选择是机器学习中的一个基本概念，对模型的性能有重大影响。在本文中，您将学习如何在机器学习中使用特征选择策略。
我们开始吧！
首先让我们了解一下什么是特征选择。
什么是特征选择？
数据中存在不相关的要素会降低模型的准确性，并导致模型基于不相关的要素进行训练。要素选择是自动或手动选择对您感兴趣的预测变量或输出贡献最大的要素的过程。
为什么我们应该在模型上执行特征选择？
以下是在机器学习模型上执行特征选择的一些好处:
- 模型精度提高:模型精度提高是因为误导性数据减少了。
- 减少过拟合:冗余数据越少，基于噪声做出结论的机会就越小。
- 减少训练时间:由于数据点减少，算法复杂度降低，算法训练更快。
当您在模型上进行特征选择时，其准确性会显著提高。
也读:如何使用 sklearn 在 Python 中将数据拆分成训练集和测试集？
执行特征选择的方法
有三种常用的特征选择方法，它们易于执行并产生良好的结果。
- 单变量选择
- 特征重要性
- 热图相关矩阵
让我们用一个例子来仔细看看这些方法。
链接下载数据集:https://www . ka ggle . com/iabhishekofficial/mobile-price-class ification # train . CSV
1.单变量选择
可以执行统计测试来识别哪些属性与输出变量的关联最强。scikit-learn 库中的 SelectKBest 类可用于各种统计测试，以选择一定数量的特性。
在下面的示例中，使用非负特征的卡方(chi2)统计测试从移动价格范围预测数据集中选择 10 个最佳特征。
import pandas as pd
import numpy as np
from sklearn.feature_selection import SelectKBest
from sklearn.feature_selection import chi2
data = pd.read_csv("C://Users//Intel//Documents//mobile_price_train.csv")
X = data.iloc[:,0:20] #independent variable columns
y = data.iloc[:,-1] #target variable column (price range)
#extracting top 10 best features by applying SelectKBest class
bestfeatures = SelectKBest(score_func=chi2, k=10)
fit = bestfeatures.fit(X,y)
dfscores = pd.DataFrame(fit.scores_)
dfcolumns = pd.DataFrame(X.columns)
#concat two dataframes
featureScores = pd.concat([dfcolumns,dfscores],axis=1)
featureScores.columns = ['Specs','Score'] #naming the dataframe columns
print(featureScores.nlargest(10,'Score')) #printing 10 best features
输出:
Specs Score
13 ram 931267.519053
11 px_height 17363.569536
0 battery_power 14129.866576
12 px_width 9810.586750
8 mobile_wt 95.972863
6 int_memory 89.839124
15 sc_w 16.480319
16 talk_time 13.236400
4 fc 10.135166
14 sc_h 9.614878
2.特征重要性
模型的要素重要性属性可用于获取数据集中每个要素的要素重要性。
要素重要性为数据的每个要素分配一个分数；分数越高，该特性对您的输出变量越重要或越相关。我们将在下面的示例中使用额外的树分类器来提取数据集的前 10 个特征，因为特征重要性是基于树的分类器自带的内置类。
import pandas as pd
import numpy as np
data = pd.read_csv("C://Users//Intel//Documents//mobile_price_train.csv")
X = data.iloc[:,0:20] #independent variable columns
y = data.iloc[:,-1] #target variable column (price range)
from sklearn.ensemble import ExtraTreesClassifier
import matplotlib.pyplot as plt
model = ExtraTreesClassifier()
model.fit(X,y)
print(model.feature_importances_)
#plot the graph of feature importances
feat_importances = pd.Series(model.feature_importances_, index=X.columns)
feat_importances.nlargest(10).plot(kind='barh')
plt.show()
输出:
[0.05945479 0.02001093 0.03442302 0.0202319 0.03345326 0.01807593
0.03747275 0.03450839 0.03801611 0.0335925 0.03590059 0.04702123
0.04795976 0.38014236 0.03565894 0.03548119 0.03506038 0.01391338
0.01895962 0.02066298]
3.热图相关统计
相关性描述了特征和目标变量之间的关系。
关联可以是:
- 正:一个特性值的增加提高了目标变量的值，或者
- 负值:一个特性值的增加会降低目标变量的值。
我们将使用 Seaborn 库绘制相关要素的热图，以找出哪些要素与目标变量最相关。
import pandas as pd
import numpy as np
import seaborn as sns
data = pd.read_csv("C://Users//Intel//Documents//mobile_price_train.csv")
X = data.iloc[:,0:20] #independent variable columns
y = data.iloc[:,-1] #targetvariable column (price range)
#obtain the correlations of each features in dataset
corrmat = data.corr()
top_corr_features = corrmat.index
plt.figure(figsize=(20,20))
#plot heat map
g=sns.heatmap(data[top_corr_features].corr(),annot=True,cmap="RdYlGn")
输出:
转到最后一行，看看价格范围。您将看到与价格范围相关的所有功能。“ram”是与价格范围高度相关的功能，其次是电池电量、像素高度和宽度等功能。m_dep、clock_speed 和 n_cores 是与价格范围最不相关的功能。
结论
在本文中，我们学习了如何使用单变量选择方法、特征重要性和相关性矩阵从数据中选择相关特征。选择最适合您的情况的方法，并使用它来提高模型的准确性。
如何使用 Selenium Python 获取股票市场数据
原文：https://www.askpython.com/python-modules/fetch-stock-market-data-selenium
使用 Python 获取最新的股票市场数据为分析和价格分析提供了一个很好的用例场景。在本教程中，我们将学习如何使用 python selenium 获取股票市场数据。
对于这个特定的教程，我们将从 NSE (印度国家股票交易所)获取 BRITANNIA industries 的数据，但是我们的代码可以将任何其他公司的名称作为输入，也可以获取它的数据。
你可能还喜欢:使用 Selenium 从网页中获取数据【完全指南】
使用 Python 获取股票市场数据
让我们从使用 Python selenium 获取股票市场数据的步骤开始。您可以循环读取数据的步骤，以便在 Python 应用程序上访问实时市场数据。
第一步。导入模块
首先，我们需要将 selenium 和 webdriver (chrome)导入到代码中。
import selenium
from selenium import webdriver
第二步。接受输入
我们将把公司的交易符号(股票代码或股票名称)作为输入，并将其存储在来自用户的变量中。
company_name = input("Enter the company name: ")
第三步。正在初始化 web 驱动程序
首先，我们需要下载想要自动化的 web 浏览器的 web 驱动程序。
就我而言，我下载了与谷歌 chrome 相同版本的 chrome WebDriver。我们还将检查用户是否输入了公司名称。如果我们有一个公司名称，那么我们将初始化网络驱动程序。
if(company_name != ''):
driver = webdriver.Chrome('C://software/chromedriver.exe')
为了初始化 web 驱动程序，我们需要传递我们下载的 web 驱动程序的路径，就像在我们的计算机系统中一样，如上所示。
第四步。访问网站
在我们开始抓取网站之前，我们首先需要访问网站。我们可以在 get() 方法的帮助下做到这一点。通过使用字符串连接，我们将 company_name 变量的值添加到 NSE 网站上股票数据的基本 URL 中。
我们这样做是为了根据输入符号获取股票数据。公司名称可以是 INFY、TCS、ITC、RELIANCE、BRITANNIA 等。，前提是它应该是有效的股票代码。
driver.get('https://www.nseindia.com/get-quotes/equity?symbol='+ company_name)
在本教程中，我们将访问包含大不列颠股票数据的网页。
第五步。找到我们想要刮取的特定元素
以下是我们想要收集的 Britannia 的当前股票价值。因此，我们将使用浏览器的 inspect 工具检查这些值，以找到它的 HTML 元素。
Real-time data of Stock, which we need to scrape
我们在 NSE 网站上找到了下面的英国符号的 HTML 代码。
<table id="priceInfoTable">
<td>Open</td>
<td>Close*</td>
<td>title="Volume Weighted Average Price">VWAP</td>
<td>Lower Band</td>
<td>Upper Band</td>
<td>Price Band</td>
<tr><td style="">3,605.15</td>
<td>3,606.00</td>
<td>3,618.30</td>
<td>3,611.97</td>
<td>3,244.65</td>
<td>3,965.65</td>
<td>No Band</td>
</table>
经过检查，我们发现所有需要的值都在名为–price infotable 的 id 中。所以我们将通过使用 get_element_by_id() 方法来访问这些值。我们需要传递 id 名称 priceInfoTable。
britania_stock = driver.find_elements_by_id('priceInfoTable')
第六步。将抓取的信息存储在列表中
当我们从网页中抓取任何数据时，你在处理代码时并不总是能理解它。为了使它可用和可读，我们将把这些数据存储在一个列表中。
britania_list = []
for p in range(len(britania_stock)):
britania_list.append(britania_stock[p].text)
当我们打印这个列表时，它会将所有值作为一个列表元素返回。因此，我们将编写另一个 for 循环，并在新的一行中打印这些值。
最后，我们使用 driver . quit()——这是一种关闭所有浏览器窗口的方法。
完整的工作代码如下:
from selenium import webdriver
import time
company_name = input("Enter the stock name: ")
if(company_name != ''):
driver = webdriver.Chrome('C://software/chromedriver.exe')
driver.get('https://www.nseindia.com/get-quotes/equity?symbol='+ company_name)
#to let the webpage load completely
time.sleep(5)
britania_stock = driver.find_elements_by_id('priceInfoTable')
britania_list = []
for p in range(len(britania_stock)):
britania_list.append(britania_stock[p].text)
for i in britania_list:
print(i,end="\n")
driver.quit()
这段代码的输出将是:
Output as per the inputted ticker symbol
结论
继续在其他网站上进行同样的实验，甚至可以在加密货币网站上为你的应用程序获取实时价格。请注意，出于商业目的的抓取可能违反许多网站的政策，您需要确保您仅将这些数据用于个人用途。
使用 Selenium 从网页获取数据[完整指南]
原文：https://www.askpython.com/python-modules/fetch-website-data-selenium
在本教程中，我们将使用 Selenium 制作一个 web scraper 来从任何网站获取数据。Selenium 是一个开源项目，用于自动化浏览器。它为自动化提供了广泛的工具和库。我们可以用各种语言编写脚本来自动化浏览器，如 java、python、c#、Kotlin 等。
实现 Web Scraper 来获取数据
在我们的示例中，我们将通过从 IMDB 获取最受欢迎的电影列表来演示 python web scraping。
第一步。导入模块
从我们的 web scrapper 开始，我们导入 Selenium 和相关模块
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
第二步。正在初始化 web 驱动程序
为了使浏览器自动化，我们需要下载我们打算使用的 web 浏览器的 web 驱动程序。在我们的例子中，我使用的是 Google Chrome，所以我下载了 chrome WebDriver。
确保 Chrome 版本和 WebDriver 版本相同。我们需要在 Chrome 方法中传递 WebDriver 的路径，如下所示:
driver = webdriver.Chrome('C://software/chromedriver.exe')
第三步。通过 Python 访问网站
为了访问网站数据，我们需要打开我们将要抓取的网站 URL。
为此，我们使用 get 方法，并将网站 URL 作为该方法的参数传递。在我们的例子中，它是 IMDB 的最受欢迎电影的网页。
driver.get("https://www.imdb.com/chart/moviemeter/?ref_=nv_mv_mpm")
当我们运行这段代码时，它将在我们的计算机系统中打开带有传递地址(URL)网站的网络浏览器。
第四步。找到你要废弃的特定信息
在我们的例子中，我们从 IMDB 中寻找收视率最高的电影的名字，所以我们将找到 HTML 元素的 XPath。
XPath 可以理解为 HTML 文档中某个特定事件(对象)的路径位置，用于查找或定位网页上的元素。
要获得一个元素的 XPath，必须使用浏览器的 Inspect 工具，然后使用选择器工具选择那个特定的工具(我们需要获得它的路径),右键单击 HTML 代码，然后选择 Copy XPath。
Inspect Element In Webpage
在我们的示例中，在检查了电影的名称元素后，似乎每个名称都在 class-title 列中，所以我们可以在代码中将它作为 xpath 传递并访问电影名称。
<td class="titleColumn">
<a href="" title="Chloé Zhao (dir.), Gemma Chan, Richard Madden">Eternals</a>
</td>
我们将使用方法 find_elements_by_xpath() 来查找每个 titleColumn 类。
movies = driver.find_elements_by_xpath('//td[@class="titleColumn"]')
注意:每个 xpath 前面都有双斜杠。—'//TD[@ class =" title column "]'
第五步。将数据存储在 Python 列表中
既然我们可以成功地获取所需的信息，我们需要将它存储在一个变量或数据结构中，以便在代码的后面部分进行检索和处理。我们可以将抓取的数据存储在各种数据结构中，如数组、列表、元组、字典。
这里，在一个列表中存储我们收集的数据(顶级电影名)。为此，我们可以编写一个循环来遍历每个电影名称，并将其存储在一个列表中。
movies_list 是一个空列表，包含从网站获取的所有信息。
movies_list = []
for p in range(len(movies)):
movies_list.append(movies[p].text)
web 抓取网站数据的最终 python 代码是:
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
driver = webdriver.Chrome('C://software/chromedriver.exe')
driver.get('https://www.imdb.com/chart/moviemeter/?ref_=nv_mv_mpm')
movies = driver.find_elements_by_xpath('//td[@class="titleColumn"]')
movies_list = []
for p in range(len(movies)):
movies_list.append(movies[p].text)
如果我们在一行中打印 movies_list 列表，那么:
print(*movies_list, sep = "\n")
我们得到如下输出:
Scraped Web Data Output
结论
这就是你如何使用 Selenium 和 Python 从几乎任何网站上抓取网站数据。只要找到正确的 XPath 并能识别网站使用的模式，访问任何网站上的所有数据都会变得非常容易。
继续做同样的实验，并让我们知道！我希望你喜欢这个教程。关注 AskPython.com 获得更多有趣的教程。
使用 Python OpenCV 获取图像大小
原文：https://www.askpython.com/python-modules/fetching-image-size-using-python-opencv
我们都必须将鼠标光标移动到一个图像文件上，不到一秒钟就会出现一个显示图像尺寸的小框。这多容易啊！但是我们能通过编程和编码得到图像的大小吗？
嗯，是的，我们可以通过编程获得图像的大小，这就是 Python 编程语言发挥作用的地方。
因为 Python 被广泛用于现实生活中的应用，如 Web 开发、机器学习、人工智能、数据科学等，所以毫不奇怪，我们可以使用 Python OpenCV 获得任何图像的大小(尺寸)。
我们将通过一个例子来学习如何使用 OpenCV Python 获取图像的大小。让我们开始吧。
也读作:Python 中的图像处理——边缘检测、大小调整、腐蚀、膨胀
简介
在图像处理期间，了解我们正在处理的图像的大小是至关重要的，它正在通过各个阶段进行转换。
图像是二维像素阵列。图像的尺寸是指图像的高度、宽度和通道数。使用 OpenCV 时，图像存储在 NumPy ndarray (N 维数组)中。
Image as a 2-D array
先决条件
-
最新版本的 Python 必须安装在你们各自的系统上，可以从 https://www.python.org/downloads/安装
-
通过在终端中执行以下命令来安装 OpenCV:
pip install opencv-contrib-python
读取图像
可以使用 OpenCV 的 imread 函数加载图像。
代码片段
# Importing the OpenCV Module
import cv2 as cv
# Reading the image using imread() function
img = cv.imread('IMAGES/Puppy.jpg')
在上面的代码片段中，**imread**函数将图像的路径作为参数。
示例–使用 OpenCV 获取图像尺寸
在这个例子中，我使用了下面的图片，图片的尺寸为 406×503 ，其中宽度为 406px，高度为 503px。
为了获得图像的大小，使用了ndarray.shape，其中**ndarray**是使用**imread**函数读取的图像。**shape**返回一个有 3 个值的元组——高度、宽度和通道数。高度为索引 0，宽度为索引 1，通道数为索引 2。
代码片段
# Importing the OpenCV Module
import cv2 as cv
# Reading the image using imread() function
img = cv.imread('IMAGES/Puppy.jpg')
dimensions = img.shape
#Accessing height, width and channels
# Height of the image
height = img.shape[0]
# Width of the image
width = img.shape[1]
# Number of Channels in the Image
channels = img.shape[2]
# Displaying the dimensions of the Image
print("Dimension are :",dimensions)
print("Height :",height,"px")
print("Width :",width,"px")
print("Number of Channels : ",channels)
输出
Dimension are : (503, 406, 3)
Height : 503 px
Width : 406 px
Number of Channels : 3
这真的很有趣，我们的代码产生了图像的精确尺寸。
结论
这是关于使用 OpenCV 获取图像的大小(尺寸)。请确保给出要读取的图像的完整路径。感谢阅读和快乐编码！
Python 中的斐波那契搜索[简单的例子]
原文：https://www.askpython.com/python/examples/fibonacci-search
斐波那契搜索是另一种分治算法，用于在给定列表中查找元素。在本教程中，我们将看到它是如何工作的，它与二分搜索法有何不同，我们将用 python 实现它。
先决条件
在进行斐波那契搜索之前，我们需要先了解两个主题。
1。二进位检索
二分搜索法是一个分而治之的算法，意思是我们为了找到答案而划分我们的列表。应该对给定的列表进行排序，以便我们可以执行该算法。
我们查看列表的中间元素，因为列表是排序的，所以我们将知道目标相对于中间元素的位置。我们要么在列表的中间找到目标，要么根据项目是小于还是大于中间的元素，从中间去掉一边。消除一侧后，我们对另一侧重复这个过程。
这样，在每次迭代中，我们减少了一半的列表，所以要找到 n 个元素，我们只需要 log [2] n 次迭代。
2。斐波那契数
斐波纳契数列是构成斐波纳契数列的数字。所以让我们先定义斐波纳契数列。我们可以将该系列递归定义为:
F(n) = F(n-1) + F(n-2)
F(1) = 1
F(0) = 0
我们确实有一种直接的方法通过一个包含指数和黄金分割率的公式来得到斐波那契数列，但是这种方法就是数列应该被理解的方式。
在上面的定义中，F(n)表示“第 n 个斐波那契数”。
因此，第 0 个斐波那契数列是 0，第 1 个斐波那契数列是 1，第 2 个斐波那契数列是第 1 个和第 0 个斐波那契数列的和，第 3 个斐波那契数列是第 2 个和第 1 个斐波那契数列的和，依此类推。
最后，第 n 个斐波那契数是它前面两个斐波那契数的和，即第(n-1)个和第(n-2)个斐波那契数的和。
这是前 10 个斐波那契数列的计算。
F(0) = 0
F(1) = 1
F(2) = F(1) + F(0) = 1 + 0 = 1
F(3) = F(2) + F(1) = 1 + 1 = 2
F(4) = F(3) + F(2) = 2 + 1 = 3
F(5) = 3 + 2 = 5
F(6) = 5 + 3 = 8
F(7) = 8 + 5 = 13
F(8) = 21
F(9) = 34
F(10) = 55
...
所以，斐波那契数列，从 0 开始是:
F = 0，1，1，2，3，5，8，13，21，34，55，89，144，…
在 Python 中实现斐波那契搜索
与二分搜索法类似，斐波那契搜索也是一种分治算法，需要一个排序列表。它还将列表分为两部分，检查两部分中间项目的目标，并根据比较结果排除一边。那么它和二分搜索法到底有什么不同呢？
在斐波纳契搜索中，我们使用斐波纳契数将列表分为两部分，因此它将列表分为不同长度的两部分。此外，它不是执行除法，而是执行加法，这对 CPU 来说负担较轻。现在让我们深入细节。
首先，我们需要给定列表的长度。然后我们找到大于或等于列表大小的最小斐波那契数。这意味着如果列表的大小是 100，那么大于 100 的最小斐波纳契数是 144。假设这是第 n 个斐波那契数。在上面的例子中，144 是第 12 个斐波那契数。
在这之后，我们在斐波纳契数列中从这个数字向后移动两次。本质上，我们找到第(n-2)个斐波那契数。在上面的例子中，我们已经找到了第 12 个斐波纳契数 144，所以我们需要第 10 个斐波纳契数 55。
我们以此为索引，将列表分为两部分。也就是说，我们在列表中查看这个索引，假设列表按升序排序，如果这个索引处的项小于目标，那么我们就剔除左侧，否则，我们就剔除右侧。我们这样做，直到我们找到我们正在寻找的项目，这将发生在计算索引的项目将匹配目标。
现在让我们深入研究这个算法的代码:
def fibonacci_search(lst, target):
size = len(lst)
start = -1
f0 = 0
f1 = 1
f2 = 1
while(f2 < size):
f0 = f1
f1 = f2
f2 = f1 + f0
while(f2 > 1):
index = min(start + f0, size - 1)
if lst[index] < target:
f2 = f1
f1 = f0
f0 = f2 - f1
start = index
elif lst[index] > target:
f2 = f0
f1 = f1 - f0
f0 = f2 - f1
else:
return index
if (f1) and (lst[size - 1] == target):
return size - 1
return None
现在让我们试着运行它，看看它的输出:
Fibonacci Search Example
结论
在本教程中，我们讨论了什么是斐波那契数，如何在斐波那契搜索算法中使用它们，算法本身是如何工作的，我们用 python 实现了该算法。希望你学得愉快，下节课再见。
14 种筛选熊猫数据帧的方法
原文：https://www.askpython.com/python-modules/pandas/filter-pandas-dataframe
每当我们处理任何类型的数据时，我们都需要对我们正在处理的数据类型有一个清晰的了解。对于大部分数据来说，它们可能包含数千甚至数百万个条目，包含各种各样的信息，如果没有任何工具来以简短易读的格式呈现数据，就很难理解这些数据。
也读作:获得熊猫头尾数据帧或系列
大多数时候，我们需要浏览数据，操作数据，并将其可视化以获得洞察力。嗯，有一个很棒的名为熊猫的图书馆为我们提供了这种能力。最常见的数据操作是数据过滤。它非常类似于 SQL 中的 WHERE 子句，或者您必须在 MS Excel 中使用过滤器来根据某些条件选择特定的行。
pandas 是一个强大、灵活的开源数据分析/操作工具，本质上是一个 python 包，它提供了速度、灵活性和富有表现力的数据结构，以直观和简单的方式处理“关系型或“标签为的数据。它是用 Python 执行真实世界数据分析的最流行的库之一。
熊猫 是建立在 NumPy 库之上的，NumPy 库旨在与科学计算环境和许多其他第三方库很好地集成。它有两个主要的数据结构，即系列(1D)** 和数据框架(2D) ，在大多数真实世界的用例中，这是金融、科学计算、工程和统计等许多领域正在处理的数据类型。**
让我们在熊猫数据框架的帮助下开始过滤数据
安装熊猫
!pip install pandas
导入熊猫库，读取我们的样本数据文件并将其分配给“df”****数据帧
import pandas as pd
df = pd.read_csv(r"C:\Users\rajam\Desktop\sample_data.csv")
让我们看看我们的数据框 :
print(df.head())
Sample_data
现在我们有了数据框架，我们将应用各种方法来过滤它。
方法–1:根据列值过滤数据帧
我们的数据框架中有一个名为“Total_Sales”的列，我们希望过滤掉所有大于 300 的销售额。
#Filter a DataFrame for a single column value with a given condition
greater_than = df[df['Total_Sales'] > 300]
print(greater_than.head())
Sales with Greater than 300
方法–2:基于多个条件过滤数据帧
这里我们过滤了所有“总销售额”大于 300 的值，以及“单位”大于 20 的值。我们将不得不使用 python 操作符“&”来显示相应的结果，该操作符执行按位 AND 操作。
#Filter a DataFrame with multiple conditions
filter_sales_units = df[(df['Total_Sales'] > 300) & (df["Units"] > 20)]
print(Filter_sales_units.head())
Filter on Sales and Units
方法–3:根据日期值过滤数据帧
例如，如果我们希望根据特定日期值过滤数据框，我们将尝试根据特定日期获取所有结果，在我们的示例中，结果在日期“03/10/21”之后。
#Filter a DataFrame based on specific date
date_filter = df[df['Date'] > '03/10/21']
print(date_filter.head())
Filter on Date
方法—4:基于日期值的多条件数据帧过滤
在这里，我们得到了我们的日期操作评估多个日期的所有结果。
#Filter a DataFrame with multiple conditions our Date value
date_filter2 = df[(df['Date'] >= '3/25/2021') & (df['Date'] <'8/17/2021')]
print(date_filter2.head())
Filter on a date with multiple conditions
方法—5:根据特定字符串过滤数据帧
在这里，我们选择了一个名为“Region”的列，并获取了来自“East”区域的所有行，从而基于特定的字符串值进行过滤。
#Filter a DataFrame to a specific string
east = df[df['Region'] == 'East']
print(east.head())
Filter based on a specific string
方法—6:根据字符串中的特定索引值过滤数据帧
在这里，我们选择了一个名为“Region”的列，并获取了所有以字母“E”作为第一个字符的行，即指定列结果中的索引 0 。
#Filter a DataFrame to show rows starting with a specfic letter
starting_with_e = df[df['Region'].str[0]== 'E']
print(starting_with_e.head())
Filter based on a specific letter
方法—7:根据值列表过滤数据帧
在这里，我们对包含值“West”和“East”的列“Region”中的行进行过滤，并显示合并后的结果。可以使用两种方法来执行该过滤，即使用一个管道|操作符和具有以下语法的一组相应的期望值，或者我们可以使用。isin() 函数过滤给定列中的值，在我们的例子中是“Region ”,并以列表的形式提供所需的一组值。
#Filter a DataFrame rows based on list of values
#Method 1:
east_west = df[(df['Region'] == 'West') | (df['Region'] == 'East')]
print(east_west)
#Method 2:
east_west_1 = df[df['Region'].isin(['West', 'East'])]
print(east_west_1.head())
Output of Method -1
Output of Method -2
方法—8:使用正则表达式根据特定值过滤数据帧行
在这里，我们希望所有列' Region' 中的值，在它们的字符串值中以' th' 结尾，并显示它们。换句话说，我们希望我们的结果显示‘North和‘South和的值，忽略‘East’和‘West’。具有指定值的方法 .str.contains() 和 $ RegEx 模式可用于获得所需的结果。
更多信息请查看正则表达式文档
#Filtering the DataFrame rows using regular expressions(REGEX)
regex_df = df[df['Region'].str.contains('th$')]
print(regex_df.head())
Filter based on REGEX
方法-9:过滤数据帧，检查是否为空
这里，我们将借助于 isnull()函数检查所有列中的 null 和 not null 值。
#Filtering to check for null and not null values in all columns
df_null = df[df.isnull().any(axis=1)]
print(df_null.head())
Filter based on NULL or NOT null values
方法-10:过滤数据帧，检查特定列中的空值。
#Filtering to check for null values if any in the 'Units' column
units_df = df[df['Units'].isnull()]
print(units_df.head())
Finding null values on specific columns
方法-11:过滤数据帧，检查特定列中的非 空值
#Filtering to check for not null values in the 'Units' column
df_not_null = df[df['Units'].notnull()]
print(df_not_null.head())
Finding not-null values on specific columns
方法—12:使用带有条件的 query() 过滤数据帧
#Using query function in pandas
df_query = df.query('Total_Sales > 300')
print(df_query.head())
Filtering values with Query Function
方法—13:使用多条件 query() 过滤数据帧
#Using query function with multiple conditions in pandas
df_query_1 = df.query('Total_Sales > 300 and Units <18')
print(df_query_1.head())
Filtering multiple columns with Query Function
方法—14:使用 loc 和 iloc 函数过滤我们的数据帧。
#Creating a sample DataFrame for illustrations
import numpy as np
data = pd.DataFrame({"col1" : np.arange(1, 20 ,2)}, index=[19, 18 ,8, 6, 0, 1, 2, 3, 4, 5])
print(data)
sample_data
解释 : iloc 根据给定索引的位置考虑行，所以只取整数作为值。
更多信息请查看熊猫文档
#Filter with iloc
data.iloc[0 : 5]
Filter using iloc
解释 : loc 根据索引标签考虑行
#Filter with loc
data.loc[0 : 5]
Filter using loc
你可能会想为什么 **loc**函数返回 6 行而不是 5 行。这是因为 loc 不产生基于索引位置的输出。它只考虑索引的标签，该标签也可以是字母表，并且包括起点和终点。
结论
这些是熊猫最常用的过滤方法。有许多其他过滤方法可以使用，但这些是最常用的一些。选择过滤方法时，考虑您要过滤的数据、数据类型以及您要进行的过滤类型非常重要。希望你喜欢这篇文章。要了解更多，别忘了阅读熊猫教程。
附加参考
Python 和 OpenCV:对图像应用滤镜
原文：https://www.askpython.com/python/examples/filters-to-images
我很确定你已经在社交平台和你的相机上试用了各种滤镜。
今天在本教程中，我们将应用一些过滤器的图像。激动人心吧？
我们开始吧！
1.导入模块
第一步是导入需要的模块，包括 OpenCV 、 matplotlib 和 numpy 模块。为了更好的可视化，我们还将把绘图风格改为 seaborn。
import cv2
import matplotlib.pyplot as plt
import numpy as np
plt.style.use('seaborn')
2.加载初始图像
我们将在imread函数的帮助下读取并存储图像，然后使用cvtColor函数将颜色转换为 RGB 格式，然后使用imshow函数绘制图像。
loaded_img = cv2.imread("image1.jpg")
loaded_img = cv2.cvtColor(loaded_img,cv2.COLOR_BGR2RGB)
plt.figure(figsize=(8,8))
plt.imshow(loaded_img,cmap="gray")
plt.axis("off")
plt.show()
确保图像保存在与代码文件相同的目录中。
2.创建过滤器
现在，我们的图像已经加载并准备好工作，我们将创建自己的过滤器，首先为每个过滤器创建一个内核，然后将内核值转换为 2D 过滤器。
- 内核是什么？
使用 numpy 数组来定义内核，这些数组基本上是二维矩阵，定义了图像锐化、模糊和浮雕的准确值。
- 创建 2D 滤波器
通过将内核值和加载的图像放入卷积网络来创建 2D 滤波器。
2.1 浮雕过滤器
在图像上获得浮雕滤镜的代码如下所示。首先，我们为浮雕效果创建了一个浮雕内核和过滤器。
Emboss_Kernel = np.array([[0,-1,-1],[1,0,-1],[1,1,0]])
Emboss_Effect_Img = cv2.filter2D(src=loaded_img, kernel=Emboss_Kernel, ddepth=-1)
plt.figure(figsize=(8,8))
plt.imshow(Emboss_Effect_Img,cmap="gray")
plt.axis("off")
plt.show()
2.2 锐化滤波器
获取图像锐化滤镜的代码如下所示。首先，我们为锐化效果创建了一个锐化内核和过滤器。
Sharpen_Kernel = np.array([[-1, -1, -1], [-1, 9, -1], [-1, -1, -1]])
Sharpen_Effect_Img = cv2.filter2D(src=loaded_img, kernel=Sharpen_Kernel, ddepth=-1)
plt.figure(figsize=(8,8))
plt.imshow(Sharpen_Effect_Img,cmap="gray")
plt.axis("off")
plt.show()
2.3 棕褐色滤镜
在图像上获得棕褐色滤镜的代码如下所示。首先，我们创建了一个棕褐色内核和棕褐色效果的过滤器。
Sepia_Kernel = np.array([[0.272, 0.534, 0.131],[0.349, 0.686, 0.168],[0.393, 0.769, 0.189]])
Sepia_Effect_Img = cv2.filter2D(src=loaded_img, kernel=Sepia_Kernel, ddepth=-1)
plt.figure(figsize=(8,8))
plt.imshow(Sepia_Effect_Img,cmap="gray")
plt.axis("off")
plt.show()
2.4 模糊滤镜
获取图像模糊滤镜的代码如下所示。首先，我们为模糊效果创建了一个模糊内核和滤镜。
Blur_Effect_Img = cv2.GaussianBlur(loaded_img, (35, 35), 0)
plt.figure(figsize=(8,8))
plt.imshow(Blur_Effect_Img,cmap="gray")
plt.axis("off")
plt.show()
最终输出
下图依次显示了图像的所有滤镜。
Filters Using OpenCV Output
对另一个图像测试了相同的过滤器，输出如下所示。
Filters Using OpenCV Output2
结论
恭喜你！今天，我们学习了如何建立自己的过滤器，并将其应用到图像。
自己尝试一下吧！编码快乐！
如何在 Python 中找到给定类的所有方法？
原文：https://www.askpython.com/python/examples/find-all-methods-of-class
大家好！在今天的文章中，我们将看看如何找到一个给定类的所有方法。
往往直接列出一个类的所有方法是非常方便的，这样我们就可以基于某些方法进行一些预处理。
我们开始吧！我们将向您展示实现这一点的一些方法，您可以使用以下任何一种方法。
定义我们的模板类
让我们首先定义一个虚拟类，从中我们可以验证我们的输出。
考虑下面的类，它有一些方法:
class MyClass(object):
def __init__(self, a):
assert isinstance(a, float) or isinstance(a, int)
self.state = a
def add(self, a):
assert isinstance(a, float) or isinstance(a, int)
self.state = self.state + a
return self.state
def subtract(self, a):
assert isinstance(a, float) or isinstance(a, int)
self.state = self.state - a
return self.state
def multiply(self, a):
assert isinstance(a, float) or isinstance(a, int)
self.state = self.state * a
return self.state
def divide(self, a):
assert isinstance(a, float) or isinstance(a, int)
self.state = self.state / a
return self.state
该类存储了一个浮点属性state，我们可以使用算术运算来操作它。
现在让我们看看列出自定义类的方法的一些方式。
方法 1–使用 dir()函数列出类中的方法
要列出这个类的方法，一种方法是使用 Python 中的 dir()函数。
dir()函数将返回该类的所有函数和属性。
让我们看看如果我们为MyClass尝试会发生什么。
print(dir(MyClass))
输出
['__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__',
'add',
'divide',
'multiply',
'subtract']
好了，我们可以看到已经列出了我们的add、divide、subtract和multiply方法！但是，其他的方法呢？
嗯，这些方法(以双下划线开头的方法)被称为 dunder 方法。
这些通常由包装函数调用。例如，dict()函数调用__dict__()方法。
从输出中过滤数据方法
通常，我们不需要带双下划线前缀的方法，所以我们可以使用下面的代码片段来过滤它们:
method_list = [method for method in dir(MyClass) if method.startswith('__') is False]
print(method_list)
输出
['add', 'divide', 'multiply', 'subtract']
哇！我们现在只得到我们想要的算术方法！
然而，我们目前的解决方案有一个问题。
还记得dir()调用一个类的方法和属性吗？
处理类的属性
如果我们在一个类中有属性，它也会列出来。考虑下面的例子。
class MyClass(object):
# MyClass property
property1 = [1, 2, 3]
def __init__(self, a):
assert isinstance(a, float) or isinstance(a, int)
self.state = a
def add(self, a):
assert isinstance(a, float) or isinstance(a, int)
self.state = self.state + a
return self.state
def subtract(self, a):
assert isinstance(a, float) or isinstance(a, int)
self.state = self.state - a
return self.state
def multiply(self, a):
assert isinstance(a, float) or isinstance(a, int)
self.state = self.state * a
return self.state
def divide(self, a):
assert isinstance(a, float) or isinstance(a, int)
self.state = self.state / a
return self.state
@staticmethod
def global_method(a, b):
return a + b
@classmethod
def myclass_method(cls):
return cls
method_list = [method for method in dir(MyClass) if method.startswith('_') is False]
print(method_list)
现在，你认为输出会是什么？
输出
['add', 'divide', 'global_method', 'multiply', 'myclass_method', 'property1', 'subtract']
这也给了我们property1，这不是我们想要的。
我们需要再做一个过滤器来区分方法和属性。
但这真的很简单。主要区别是任何属性对象都是不可调用的，而方法是可以调用的！
在 Python 中，我们可以使用布尔函数callable(attribute)来检查属性是否可以被调用。
现在让我们将它包含到我们的旧代码中。
method_list = [attribute for attribute in dir(MyClass) if callable(getattr(MyClass, attribute)) and attribute.startswith('__') is False]
print(method_list)
让我们在不理解列表的情况下进行分解:
method_list = []
# attribute is a string representing the attribute name
for attribute in dir(MyClass):
# Get the attribute value
attribute_value = getattr(MyClass, attribute)
# Check that it is callable
if callable(attribute_value):
# Filter all dunder (__ prefix) methods
if attribute.startswith('__') == False:
method_list.append(attribute)
print(method_list)
我们还将method改为attribute，这样就消除了误导的意图！
现在让我们来测试一下。
输出
['add', 'divide', 'global_method', 'multiply', 'myclass_method', 'subtract']
事实上，我们确实得到了方法列表，而没有属性！
方法 2–使用 optparse。OptionParser
现在，如果你不太习惯使用dir()，这是你可以使用的另一种方法。
我们可以使用inspect模块来列出方法。
也就是说，我们可以使用inspect.getmembers(instance, predicate=inspect.ismethod)来获得方法列表。
这将自动为您完成工作，您只需要处理输出。让我们看一个例子。
import inspect
class MyClass(object):
# MyClass property
property1 = [1, 2, 3]
def __init__(self, a):
assert isinstance(a, float) or isinstance(a, int)
self.state = a
def add(self, a):
assert isinstance(a, float) or isinstance(a, int)
self.state = self.state + a
return self.state
def subtract(self, a):
assert isinstance(a, float) or isinstance(a, int)
self.state = self.state - a
return self.state
def multiply(self, a):
assert isinstance(a, float) or isinstance(a, int)
self.state = self.state * a
return self.state
def divide(self, a):
assert isinstance(a, float) or isinstance(a, int)
self.state = self.state / a
return self.state
@staticmethod
def global_method(a, b):
return a + b
@classmethod
def myclass_method(cls):
return cls
# Create our instance
instance = MyClass(100)
# Get the list of functions
method_list = inspect.getmembers(MyClass, predicate=inspect.ismethod)
print(method_list)
输出
[('__init__',
<bound method MyClass.__init__ of <__main__.MyClass object at 0x000001E55E36F390>>),
('add',
<bound method MyClass.add of <__main__.MyClass object at 0x000001E55E36F390>>),
('divide',
<bound method MyClass.divide of <__main__.MyClass object at 0x000001E55E36F390>>),
('multiply',
<bound method MyClass.multiply of <__main__.MyClass object at 0x000001E55E36F390>>),
('myclass_method',
<bound method MyClass.myclass_method of <class '__main__.MyClass'>>),
('subtract',
<bound method MyClass.subtract of <__main__.MyClass object at 0x000001E55E36F390>>)]
我们可以得到每个元组的第一个元素，从而得到方法名。
使用检查模块的注意事项
注意，我们得到了一个元组列表。元组的第一个元素是函数的名称，第二个元素表示方法对象本身。
虽然这似乎是一个好的解决方案，但您可能会注意到一些事情。
- 对于
dir()，我们直接使用了类名本身。但是在这里，我们需要传递一个实例。 - 列表中也没有显示 staticmethods。根据您的使用情况，您可能需要/可能不需要它。
鉴于以上几点，我建议你保持简单，使用dir()功能！
结论
在本文中，我们看到了如何在 Python 中列出给定类的所有方法。
参考
- 关于列出一个类的所有方法
如何在 Python 中求第 n 个十边形数？
原文：https://www.askpython.com/python/examples/find-nth-decagonal-number
嘿伙计们！在本教程中，我们将探索如何在 Python 中获得第 n 个十边形数。但是首先，让我们复习十次数的基础知识。
十次数介绍
十边形数是一种图形数，它将三角形和正方形的概念扩展到十边形(十边形)。第 n 个十边形数计算 n 个嵌套十边形图案中的点数，每个嵌套十边形都有一个共享角。
以下公式生成第 n 个十进制数:
d(n)= 4n^2–3 * n*
求第 n 个十次数的算法
为了使用 Python 编程语言获得第 n 个十进制数，我们将遵循下面提到的步骤:
- 取 n 的输入值
- 使用上一节提到的公式计算 D(n)的值。
- 显示 D(n)的计算值
用 Python 寻找第 n 个十次方数
def GetDecagonalNumber(n):
return (4*n*n - 3*n)
n = int(input("Enter the value of n: "))
print("The required Decagonal Number is: ", GetDecagonalNumber(n))
这里，我们创建了一个函数，使事情更容易理解，并概括了一个可以在任何其他代码中重用的直接函数。
样本输出
Enter the value of n: 3
The required Decagonal Number is: 27
Enter the value of n: 20
The required Decagonal Number is: 1540
结论
恭喜你！您刚刚学习了如何在 Python 编程语言中计算第 n 个十次方数。希望你喜欢它！😇
喜欢这个教程吗？无论如何，我建议你看一下下面提到的教程:
感谢您抽出时间！希望你学到了新的东西！！😄
在 Python 中从 x 和 y 值中找到象限
原文：https://www.askpython.com/python/examples/find-quadrant-using-x-y
嘿编码器！今天，在本教程中，我们将使用 Python 编程进行简单的基本编码，以确定特定点属于空间中的哪个象限。
我们都知道在 2D 空间总共有 4 个坐标，如下图所示。
Quadrants
这里每个象限的条件如下:
- 象限 1: x 为负，y 为正
- 象限 2:x 和 y 都是正的
- 象限 3:x 和 y 都是负的
- 象限 4: x 为正，y 为负
现在让我们看看象限确定的代码实现，其中我们只需要检查空间中一个点的 x 和 y 值。
基于 X，Y 位置求平方
x = int(input())
y = int(input())
print("(",x,",",y,")",end="")
if(x<0 and y<0):
print(" belongs to 3rd Quadrant.")
elif(x<0 and y>0):
print(" belongs to 1st Quadrant.")
elif(x>0 and y>0):
print(" belongs to 2nd Quadrant.")
else:
print(" belongs to 4th Quadrant.")
下面显示了代码的一些示例输出。如果需要，可以查看并交叉检查输出。
( 2 , -3 ) belongs to 4th Quadrant.
( 2 , 4 ) belongs to 2nd Quadrant.
我希望象限的逻辑和象限到空间点的分配。感谢您阅读教程！
快乐学习！😇
在 Python 中查找列表中的字符串
原文：https://www.askpython.com/python/list/find-string-in-list-python
在本文中，我们将看看如何在 Python 中查找列表中的字符串。
在 Python 中查找列表中的字符串
对于这个问题有各种各样的方法，从易用性到效率。
使用“in”运算符
我们可以使用 Python 的 in 操作符在 Python 中查找一个列表中的字符串。它接受两个操作数a和b，其形式如下:
ret_value = a in b
这里，ret_value是一个布尔值，如果a位于b内，则该值为True，否则为False。
我们可以通过以下方式直接使用该运算符:
a = [1, 2, 3]
b = 4
if b in a:
print('4 is present!')
else:
print('4 is not present')
输出
4 is not present
为了方便使用，我们也可以将它转换成一个函数。
def check_if_exists(x, ls):
if x in ls:
print(str(x) + ' is inside the list')
else:
print(str(x) + ' is not present in the list')
ls = [1, 2, 3, 4, 'Hello', 'from', 'AskPython']
check_if_exists(2, ls)
check_if_exists('Hello', ls)
check_if_exists('Hi', ls)
输出
2 is inside the list
Hello is inside the list
Hi is not present in the list
这是在列表中搜索字符串的最常用和推荐的方法。但是，为了便于说明，我们还将向您展示其他方法。
使用列表理解
让我们看另一个例子，您希望只检查字符串是否是列表中另一个单词的一部分，并返回所有这些单词，其中您的单词是列表项的子字符串。
考虑下面的列表:
ls = ['Hello from AskPython', 'Hello', 'Hello boy!', 'Hi']
如果您想在列表的所有元素中搜索子串Hello，我们可以使用以下格式的列表理解:
ls = ['Hello from AskPython', 'Hello', 'Hello boy!', 'Hi']
matches = [match for match in ls if "Hello" in match]
print(matches)
这相当于下面的代码，它只有两个循环并检查条件。
ls = ['Hello from AskPython', 'Hello', 'Hello boy!', 'Hi']
matches = []
for match in ls:
if "Hello" in match:
matches.append(match)
print(matches)
在这两种情况下，输出都是:
['Hello from AskPython', 'Hello', 'Hello boy!']
如您所见，在输出中，所有匹配都包含字符串Hello作为字符串的一部分。很简单，不是吗？
使用“any()”方法
如果你想检查输入字符串是否存在于列表的 any 项中，我们可以使用 any()方法来检查这是否成立。
例如，如果您希望测试' AskPython' '是否是列表中任何项目的一部分，我们可以执行以下操作:
ls = ['Hello from AskPython', 'Hello', 'Hello boy!', 'Hi']
if any("AskPython" in word for word in ls):
print('\'AskPython\' is there inside the list!')
else:
print('\'AskPython\' is not there inside the list')
输出
'AskPython' is there inside the list!
使用过滤器和 lambdas
我们也可以在一个 lambda 函数上使用filter()方法，这是一个简单的函数，只在那一行定义。把 lambda 想象成一个迷你函数，在调用后不能被重用。
ls = ['Hello from AskPython', 'Hello', 'Hello boy!', 'Hi']
# The second parameter is the input iterable
# The filter() applies the lambda to the iterable
# and only returns all matches where the lambda evaluates
# to true
filter_object = filter(lambda a: 'AskPython' in a, ls)
# Convert the filter object to list
print(list(filter_object))
输出
['Hello from AskPython']
我们确实得到了我们所期望的！只有一个字符串与我们的过滤函数匹配，这就是我们得到的结果！
结论
在本文中，我们学习了如何用不同的方法找到带有输入列表的字符串。希望这对你的问题有所帮助！
参考
- JournalDev 关于在列表中查找字符串的文章
- 在一个列表中寻找一个字符串
在 Python 中查找字符串长度
原文：https://www.askpython.com/python/string/find-string-length-in-python
我们可以在 Python 中使用内置的len()函数找到字符串长度。让我们看看这个函数是如何工作的，并且让我们尝试使用len()来查找各种类型的 Python 字符串的长度。
使用 len()
我们来看一些简单的例子来说明len()。
>>> a = "Hello from AskPython"
>>> print(len(a))
20
这会打印 20，因为这是字符串中的字符数。因此，我们可以使用len()找到长度。
即使字符串有特殊字符，只要它能以某种 Unicode 格式编码，我们就能计算它的长度。
>>> a = 'AåBç'
>>> print(len(a))
4
对于带有特殊转义字符的字符串(它们以反斜杠(\)为前缀)，只有字符会被计入长度，而反斜杠不会。例子包括(\n、\t、\'等)
>>> a = 'A\t\t'
>>> print(len(a))
3
>>> b = 'A\n\nB'
>>> print(len(b))
4
>>> c = 'A\'B'
>>> print(len(c))
3
对于原始字符串，由于它们将反斜杠(\)视为文字，所以反斜杠将计入字符串的长度。
>>> s = r'A\t\t'
>>> print(len(s))
5
透镜的工作()
当我们使用 String 对象调用len()函数时，String 对象的__len__()方法被调用。
>> a = "Hello from AskPython"
>>> a.__len__()
20
为了证明这一点，让我们在自定义类上实现我们自己的len()。既然__len__()作用于对象，我们必须继承类object。
class Student(object):
def __init__(self, name):
self.name = name
def __len__(self):
print("Invoking the __len__() method on the Student Object to find len()...")
count = 0
for i in self.name:
count += 1
return count
a = Student("Amit")
print(len(a))
由于len()方法调用了__len__()，我们将遍历该函数，它计算 iterable 中对象的数量。因为我们传递了一个字符串，我们将简单地得到长度，结果是 4！
输出
Invoking the __len__() method on the Student Object to find len()...
4
因此，我们为类Student实现了自己的len()方法！很神奇，不是吗？
参考
- 关于字符串长度的 JournalDev 文章
寻找算法的时间复杂度
原文：https://www.askpython.com/python/examples/find-time-complexity-of-algorithms
今天我们将分析 Python 中算法的时间复杂度。为此，我们必须确定对各种输入执行所需算法所需的总时间。
我们使用的方法是快速排序，但是您可以用一种算法来试验，以确定 Python 中算法的时间复杂度。
导入模块/库
需要时间模块来确定命令执行之间经过的时间。然后，random 模块用于为我们要排序的原始整数集合产生随机数。
算法模块用于直接获取快速排序代码。在这种情况下，您也可以应用自己的算法。
import time
from random import randint
from algorithms.sort import quick_sort
为快速排序生成列表
现在我们已经导入了所有的库，我们可以开始编写代码了。我们将从一组未排序的项目开始。为此使用了randint()方法。下面的代码将生成 20001 个随机数的列表，范围从 0 到 999。
l = [randint(0,1000) for i in range(20000)]
计算算法的时间复杂度
我们首先创建一个空列表，在其中存储各种输入的所有时间值。
然后，我们执行一个 for 循环，每次迭代都有不同数量的输入。对于每次迭代，我们首先在运行算法之前节省时间。然后执行 quicksort 方法，元素的数量随着每次迭代而增加。
当算法完成时，我们存储结束时间，然后从开始时间中减去结束时间，得到经过的时间。经过的时间随后被添加到我们的时间集合中。
times=[]
for x in range(0,20001,100):
start_time = time.time()
list2 = quick_sort(list1[:x])
elapsed_time = time.time() - start_time
times.append(elapsed_time)
print(times)
每次迭代消耗的时间输出如下所示。
[5.9604644775390625e-06, 0.0003139972686767578, 0.00667881965637207, 0.001209259033203125, 0.0015976428985595703, 0.0021779537200927734, 0.0068056583404541016, 0.005601644515991211, 0.005861520767211914, 0.011028051376342773, 0.011818647384643555, 0.012465715408325195, 0.012626171112060547, 0.008950948715209961, 0.030421972274780273, 0.019321203231811523, 0.01583099365234375, 0.03421354293823242, 0.026609182357788086, 0.017530202865600586, 0.019039630889892578, 0.0118560791015625, 0.013288259506225586, 0.012446880340576172, 0.015150070190429688, 0.012840032577514648, 0.014685630798339844, 0.015198230743408203, 0.016430377960205078, 0.0168306827545166, 0.018042564392089844, 0.020036935806274414, 0.018283843994140625, 0.019774913787841797, 0.01965475082397461, 0.024692058563232422, 0.02126765251159668, 0.02456188201904297, 0.024203062057495117, 0.022081613540649414, 0.025351285934448242, 0.02523493766784668, 0.027686119079589844, 0.026891231536865234, 0.04227614402770996, 0.025140047073364258, 0.0282745361328125, 0.028072357177734375, 0.04300737380981445, 0.049503326416015625, 0.039911508560180664, 0.031244993209838867, 0.03950953483581543, 0.0483095645904541, 0.05027508735656738, 0.04074549674987793, 0.05907034873962402, 0.035933732986450195, 0.03742861747741699, 0.053351640701293945, 0.07302188873291016, 0.04110312461853027, 0.038227081298828125, 0.04067420959472656, 0.04362940788269043, 0.06206393241882324, 0.048111915588378906, 0.054494619369506836, 0.055097103118896484, 0.046785593032836914, 0.046590566635131836, 0.04422330856323242, 0.07317423820495605, 0.04566597938537598, 0.05501079559326172, 0.07018637657165527, 0.12341713905334473, 0.08685779571533203, 0.1301746368408203, 0.05524754524230957, 0.05509376525878906, 0.051004648208618164, 0.10072588920593262, 0.09502077102661133, 0.17278599739074707, 0.18680071830749512, 0.08754134178161621, 0.0879063606262207, 0.18670082092285156, 0.21729803085327148, 0.1556401252746582, 0.07978129386901855, 0.033004045486450195, 0.03307485580444336, 0.03363752365112305, 0.03286147117614746, 0.03313589096069336, 0.0342717170715332, 0.03235769271850586, 0.0335690975189209, 0.0449981689453125, 0.03151226043701172, 0.036780595779418945, 0.03641867637634277, 0.034799814224243164, 0.035429954528808594, 0.03528714179992676, 0.03522825241088867, 0.03563570976257324, 0.03550863265991211, 0.03803896903991699, 0.037568092346191406, 0.039276123046875, 0.05381584167480469, 0.04004693031311035, 0.040352582931518555, 0.04136157035827637, 0.041423797607421875, 0.045130014419555664, 0.04460620880126953, 0.04532432556152344, 0.04130244255065918, 0.04760575294494629, 0.04321622848510742, 0.046456336975097656, 0.04538416862487793, 0.04726004600524902, 0.04443860054016113, 0.04362082481384277, 0.04554152488708496, 0.046132802963256836, 0.0486757755279541, 0.046370744705200195, 0.04680061340332031, 0.04824686050415039, 0.06405234336853027, 0.0478060245513916, 0.04948878288269043, 0.049854278564453125, 0.05359053611755371, 0.05414247512817383, 0.05222964286804199, 0.051342010498046875, 0.05304098129272461, 0.06159520149230957, 0.0521693229675293, 0.05106377601623535, 0.054935455322265625, 0.053060054779052734, 0.052790164947509766, 0.05505990982055664, 0.057706356048583984, 0.05939984321594238, 0.060530900955200195, 0.07836294174194336, 0.06412434577941895, 0.05772709846496582, 0.060724735260009766, 0.05914807319641113, 0.0632481575012207, 0.059748172760009766, 0.06452727317810059, 0.06497621536254883, 0.06197404861450195, 0.06228804588317871, 0.06296825408935547, 0.06248354911804199, 0.06389427185058594, 0.06646037101745605, 0.06796479225158691, 0.08311891555786133, 0.065704345703125, 0.06447386741638184, 0.06992769241333008, 0.06401872634887695, 0.06702852249145508, 0.06934690475463867, 0.06805992126464844, 0.0670771598815918, 0.06830120086669922, 0.0785529613494873, 0.06986260414123535, 0.07060122489929199, 0.07129216194152832, 0.08096432685852051, 0.07953071594238281, 0.08166289329528809, 0.0758814811706543, 0.07543277740478516, 0.07652783393859863, 0.07634139060974121, 0.08227705955505371, 0.07456398010253906, 0.0725564956665039, 0.0724172592163086, 0.0800638198852539, 0.07935881614685059, 0.07793021202087402, 0.09217333793640137, 0.07755923271179199, 0.07942557334899902]
为了绘制图表，我们还需要每次迭代的输入数量。
x=[i for i in range(0,20001,100)]
绘制计算的时间值
现在是检验我们发现的时候了。让我们画一张图，x 轴表示输入的数量，y 轴表示时间。
import matplotlib.pyplot as plt
plt.style.use("seaborn")
plt.xlabel("No. of elements")
plt.ylabel("Time required")
plt.plot(x,times)
plt.show()
Time Complexity Plot
结论
恭喜你！你刚刚学会了如何计算算法的时间复杂度。希望你喜欢它！😇
喜欢这个教程吗？无论如何，我建议你看一下下面提到的教程:
感谢您抽出时间！希望你学到了新的东西！！😄
Python 中的先来先服务调度[FCFS]
原文：https://www.askpython.com/python/examples/first-come-first-serve
什么是先来先服务调度？嘿学员们！今天我们将了解一个非常重要的主题的理论概念和代码实现，这个主题属于操作系统，称为先来先服务 CPU 调度。
在跳到代码实现之前，让我们先了解一下先来先服务是什么意思。
先来先服务介绍
先来先服务(FCFS) 是操作系统中最容易、最简单的 CPU 调度算法，按照进程到达的顺序自动执行进程。
在这种类型的算法中，首先请求 CPU 的进程首先获得 CPU 来完成它们的执行。这种方法性能差，而且一般等待时间相当长。
让我们来看一些现实生活中的例子:
- 排队买娱乐票的人
- 人们在公共汽车站等车
现在，在 CPU 调度中，我们需要计算一些时间值，如下所示:
- 退出时间:进程完成执行后离开 CPU 的时间。
- 周转时间:流程到达和退出时间之间的差异。
- 等待时间:突发/执行时间与流程周转时间之差。
除此之外，我们还可以计算流程的平均等待时间。
先来先服务的说明
让我们考虑这样一种情况，我们有 4 个到达和执行时间不同的流程。数据显示在下表中:
| 流程 ID | 到达时间 | 突发/执行时间 |
| 第一亲代 | Zero | four |
| P2 | one | five |
| P3 | Two | five |
| P4 | three | three |
Arrival Time and Burst time of 4 different processes
现在我们需要计算不同的时间值，如出口时间、周转时间和等待时间。你可以看看下面提到的时间图，分析和计算各种时间值。
FCFS Timechart
这里，该过程的退出时间分别是 4、9、14 和 17。这些流程的周转时间分别为 4、8、12 和 14。
同样，进程的等待时间分别为 0，3，7，11。我们最后必须计算平均等待时间，结果是 5.25 分钟。
现在让我们转到 FCFS 流程的代码实现。
用 Python 实现 FCFS
print("FIRST COME FIRST SERVE SCHEDULLING")
n= int(input("Enter number of processes : "))
d = dict()
for i in range(n):
key = "P"+str(i+1)
a = int(input("Enter arrival time of process"+str(i+1)+": "))
b = int(input("Enter burst time of process"+str(i+1)+": "))
l = []
l.append(a)
l.append(b)
d[key] = l
d = sorted(d.items(), key=lambda item: item[1][0])
ET = []
for i in range(len(d)):
# first process
if(i==0):
ET.append(d[i][1][1])
# get prevET + newBT
else:
ET.append(ET[i-1] + d[i][1][1])
TAT = []
for i in range(len(d)):
TAT.append(ET[i] - d[i][1][0])
WT = []
for i in range(len(d)):
WT.append(TAT[i] - d[i][1][1])
avg_WT = 0
for i in WT:
avg_WT +=i
avg_WT = (avg_WT/n)
print("Process | Arrival | Burst | Exit | Turn Around | Wait |")
for i in range(n):
print(" ",d[i][0]," | ",d[i][1][0]," | ",d[i][1][1]," | ",ET[i]," | ",TAT[i]," | ",WT[i]," | ")
print("Average Waiting Time: ",avg_WT)
抽样输出
FIRST COME FIRST SERVE SCHEDULLING
Enter number of processes : 4
Enter arrival time of process1: 1
Enter burst time of process1: 5
Enter arrival time of process2: 0
Enter burst time of process2: 4
Enter arrival time of process3: 3
Enter burst time of process3: 3
Enter arrival time of process4: 2
Enter burst time of process4: 5
Process | Arrival | Burst | Exit | Turn Around | Wait |
P2 | 0 | 4 | 4 | 4 | 0 |
P1 | 1 | 5 | 9 | 8 | 3 |
P4 | 2 | 5 | 14 | 12 | 7 |
P3 | 3 | 3 | 17 | 14 | 11 |
Average Waiting Time: 5.25
FCFS 的优点和缺点
让我们来看看一些优势
先到先得的好处
- 易于编程
- CPU 调度算法的最简单形式
先来先服务的缺点
- 平均等待时间很长
- 不是分时系统的理想技术
- FCFS 不是很有效
结论
我希望您现在已经清楚什么是 FCFS CPU 调度，以及如何在 python 编程语言的帮助下实现它。
希望你喜欢这个教程！感谢您的阅读！快乐学习！😇
在 Python 中拟合逻辑回归模型
原文：https://www.askpython.com/python/examples/fitting-a-logistic-regression-model
在本文中，我们将了解更多关于在 Python 中拟合逻辑回归模型的信息。在机器学习中，我们经常不得不处理只有两种可能结果的问题——在医学领域确定肿瘤是恶性还是良性，或者在教育领域确定学生是否被某所大学录取。
二元分类问题是一种挑战，逻辑回归是解决这些问题的重要方法。在本文中，我们将看看如何在 Python 中拟合逻辑回归模型。
什么是逻辑回归？
逻辑回归是一种机器学习技术，它基于独立变量进行预测，以对肿瘤状态(恶性或良性)、电子邮件分类(垃圾邮件或非垃圾邮件)或大学录取(录取或不录取)等问题进行分类。
例如，当对电子邮件进行分类时，该算法将利用电子邮件中的单词作为特征，并生成关于该电子邮件是否是垃圾邮件的预测。
逻辑回归是一种监督的机器学习技术，这意味着用于训练的数据已经被标记，即答案已经在训练集中。该算法从实例中获取知识。
逻辑回归的重要性
这种技术可以在医学上用于估计给定人群中的疾病风险，从而提供预防性治疗。
通过监控购买者的行为，企业可以识别趋势，从而提高员工忠诚度或生产更有利可图的产品。这种形式的分析被数据科学家用于企业界，他们的目的是评估和理解复杂的数字数据。
用这种方法开发的预测模型可以对任何公司或组织产生积极的影响。人们可以通过使用这些模型来分析联系和预测后果，从而改进决策。
例如，制造商的分析团队可以利用作为统计软件包一部分的逻辑回归分析，找出机器零件故障与这些零件库存持续时间之间的相关性。该团队可以根据从该研究中获得的知识选择更改交付时间表或安装时间，以避免重复失败。
逻辑回归的类型
基于它执行的分类类型，逻辑回归可以被分类成不同的类型。记住这一点，有三种不同类型的逻辑回归。
1.二元逻辑回归
最常见的类型是二元逻辑回归。就是我们之前定义逻辑回归时讲过的那种。这种类型为因变量/目标变量分配两个独立的值:0 或 1，恶性或良性，通过或失败，允许或不允许。
2.多项式逻辑回归
当目标变量或独立变量有三个或更多值时，使用多项式逻辑回归。例如，一家公司可以进行一项调查，要求参与者从一系列选项中选择他们最喜欢的产品。人们可以建立那些最有可能对你的产品感兴趣的人的档案，并利用这些信息来定制你的广告活动。
3.有序逻辑回归
当目标变量本质上是序数时，利用序数逻辑回归。在这种情况下，类别以一种有意义的方式组织起来，每个类别都有一个数值。此外，目标变量中有两个以上的类别。
拟合逻辑回归模型
让我们从建立预测模型开始。现在我们将使用逻辑回归分类器来预测糖尿病。第一步，我们将加载 Pima Indian 糖尿病数据集，并使用 Pandas 的 read CSV 函数读取它。
下载数据链接:https://www.kaggle.com/uciml/pima-indians-diabetes-database
1.加载和读取数据
让我们导入所需的包和数据集，我们将使用逻辑回归对其进行分类。
#import necessary packages
import pandas as pd
col_names = ['pregnant', 'glucose', 'bp', 'skin', 'insulin', 'bmi', 'pedigree', 'age', 'label']
# load dataset
pima = pd.read_csv("C:\\Users\Intel\Documents\diabetes.csv", header=None, names=col_names)
pima.head()
Pima-Diabetes-Dataset
2.特征选择
在特征选择步骤中，我们将所有列分为两类变量:因变量或目标变量和自变量，也称为特征变量。
feature_cols = ['pregnant', 'insulin', 'bmi', 'age','glucose','bp','pedigree']
#features
X = pima[feature_cols]
#target variable
y = pima.label
3.数据分割
将数据集分成训练集和测试集有助于更好地理解模型的性能。我们将使用函数 train_test_split()来划分数据集。
接下来，我们将使用 random_state 随机选择记录。数据集将按 75:25 的比例分为两部分，这意味着 75%的数据将用于训练模型，25%将用于测试模型。
from sklearn.cross_validation import train_test_split
X_train,X_test,y_train,y_test=train_test_split(X,y,test_size=0.25,random_state=0)
4.模型建立和预测
在这一步，我们将首先导入逻辑回归模块，然后使用逻辑回归()函数，我们将创建一个逻辑回归分类器对象。
您可以使用函数 fit()拟合您的模型，并使用 predict()函数对测试集进行预测。
from sklearn.linear_model import LogisticRegression
logreg = LogisticRegression()
# fit the model with data
logreg.fit(X_train,y_train)
#predict the model
y_pred=logreg.predict(X_test)
5.用混淆矩阵评价模型
让我们从定义一个混淆矩阵开始。
混淆矩阵是用于评估分类模型性能的表格。算法的性能也是可以看出来的。分类总结的正确和错误预测的数量是混淆矩阵的基础。
from sklearn import metrics
cnf_matrix = metrics.confusion_matrix(y_test, y_pred)
cnf_matrix
array([[119, 11],
[ 26, 36]])
在上面的结果中，您可以注意到混淆矩阵是以数组对象的形式出现的。由于这个模型是二进制分类的一个例子，矩阵的维数是 2 乘 2。
对角线上的值表示实际预测，非对角线上的值表示不正确的预测。因此，119 和 36 是实际预测，26 和 11 是不正确的预测。
优势
- 它不需要大量的计算能力，易于实现和理解，并且由于其高效和简单而被数据分析师和科学家广泛利用。
- 它也不需要特征缩放。对于每个观察，逻辑回归生成一个概率分数。
不足之处
- 大量的分类特征/变量对于逻辑回归管理来说太多了。它很容易被过量摄入。
- 逻辑回归不能处理非线性问题，这就是为什么非线性期货必须被转换。与目标变量不相关但彼此非常相似或相关的自变量在逻辑回归中表现不佳。
结论
在本次会议中，我们介绍了许多关于拟合逻辑回归的信息。您已经学习了什么是逻辑回归，如何拟合回归模型，如何评估其性能，以及一些理论信息。现在，您应该能够对自己的数据集使用逻辑回归技术了。
[修复]采用“0”个位置参数，但给出了“1”
原文：https://www.askpython.com/python/examples/fixed-takes-0-positional-arguments-but-1-was-given
在本文中，我们将学习如何修复错误“接受 0 个位置参数，但给定了 1 个”。我们开始吧！
为什么会出现“接受“0”个位置参数，但给定了“1”的错误？
让我们定义下面的示例函数“add_numbers ”,它接受两个参数 num_1 和 num_2。
代码示例 1:
def add_numbers(num_1, num_2):
sum = num_1 + num_2
print('The sum of two numbers is: ', sum)
现在，当我们需要将两个数字相加时，我们只需要将这些数字作为参数传递给函数。请看下面:
输出:
>>> add_numbers(33, 23) # calling the function first time
>>> The sum of two numbers is: 56
>>> add_numbers(45, 45) # calling the function second time
>>> The sum of two numbers is: 90
因此，从输出中，我们可以看到多次调用该函数比执行原始加法要容易得多。让我们执行另一项任务，将两个数相乘。
代码示例 2:
def multiply(num_1, num_2):
product= num_1 * num_2
print('The product of two numbers is: ', product)
输出:
>>> multiply(4, 100) # calling the function first time
>>> The product of two numbers is: 400
>>> multiply(40, 60) # calling the function second time
>>> The product of two numbers is: 2400
功能类型
有两种类型的函数:
- 参数化:放在括号内的值。通常用于高端应用。
- 非参数化:空括号。通常用于基本过程。
Types of functions in Python
当程序员使用特定函数的参数时，他们需要记住一些事情:
- 函数包含的参数数量。
- 每个参数应该做什么。
当程序员没有考虑这两点时，python 解释器就会产生错误。其中之一是:
Traceback (most recent call last):
File "c:\Users\Lenovo\Desktop\sample.py", line 8, in <module>
function(parameter)
TypeError: function() takes 0 positional arguments but 1 was given
这是 Python 中最常见的类型错误。当指定的匹配的数据类型没有为特定的代码段找到时，就会发生这种情况。
示例:接受 0 个位置参数，但给定了 1 个。
比方说，我们定义一个函数来除两个数。它是一个非参数化的函数，在调用。
例 1:
def divide():
num_1 = int(input('enter num_1: ' )) # taking input for num_1
num_2 = int(input('enter num_2: ' )) # taking input for num_2
div = num1/num2
print('The division is: ', div)
divide(3)
输出:
Traceback (most recent call last):
File "c:\Users\Lenovo\Desktop\sample.py", line 8, in <module>
divide(3)
TypeError: divide() takes 0 positional arguments but 1 was given
在上面的例子中，divide()函数需要两个参数。这两个参数都是强制性的，并且都不是位置性的。这就是函数抛出错误“接受 0 个位置参数，但给出了 1 个”的原因
当我们用一个参数调用 divide()时，解释器抛出错误。
例 2:
def add_numbers():
num_1 = int(input('Enter number 1: '))
num_2 = int(input('Enter number 2: '))
sum = num_1 + num_2
print('The sum of two numbers is: ', sum)
add_numbers(45, 2) # calling the function in python shell
输出:
Traceback (most recent call last):
File "c:\Users\Lenovo\Desktop\sample.py", line 7, in <module>
add_numbers(45, 2)
TypeError: add_numbers() takes 0 positional arguments but 2 were given
我们知道解释器逐行读取代码，它扫描每一行代码并抛出错误。尽管这个函数不接受任何东西，但是当我们给出两个位置参数时，我们会得到相同的错误。
如何修复“接受' 0 '个位置参数，但给出' 1 '的错误？
错误将显示发生错误的函数名。要修复该错误:
- 检查函数接受什么类型的参数
- 找到该函数的所有调用，并确定是否有任何函数调用是错误的
- 通过简单地改变有问题的函数调用来修复错误
结论
主题采用 0 个位置参数，但给出了 1 个位置参数到此结束。这个概念很简单。我希望您能够修复代码中的错误。如果你有任何问题，给我们写信，我们会帮你解决的。
FizzBuzz 问题——用 Python 实现 FizzBuzz 算法
原文：https://www.askpython.com/python/examples/fizzbuzz-algorithm
FizzBuzz 算法是编码面试中的一个热门问题。Fizz 和 Buzz 是 3 和 5 的倍数。
在本教程中，我将向您展示如何使用 Python 编程语言来创建 FizzBuzz 算法。
FizzBuzz 算法
FizzBuzz 算法的灵感来自一个儿童游戏。长期以来，这种方法一直是最流行的编码面试问题之一。
在这个问题中，给定一个数字范围，您必须使用以下规则创建输出:
- 如果数字(x)能被 3 整除，那么结果一定是“嘶嘶”
- 如果数字(x)能被 5 整除，那么结果一定是“嗡嗡”
- 如果数字(x)能被 3 和 5 整除，那么结果一定是“嘶嘶作响”
这种编码问题在数字 3 和 5 中很常见，但是，您可能会遇到更复杂的数字，但是解决问题的原因是相同的。
使用 Python 的 FizzBuzz 算法
为了解决 FizzBuzz 问题，我们将遵循以下步骤:
- 现在我们只考虑正整数，所以我们将使用一个 while 循环，直到用户输入正整数。
- 现在我们将使用一个来代替从 1 到 n 的循环。
- 每当我们遇到 3 和 5 的倍数时，我们就会输出‘fizz buzz’
- 对于 3 的倍数，我们打印“Fizz”
- 同样，对于 5 的倍数，我们显示单词“Buzz”
n = -1
while(n<0):
n = int(input("Enter the ending integer: "))
for i in range(1, n+1):
if i % 3 == 0 and i % 5 == 0:
print("FizzBuzz",end=" ")
elif i % 3 == 0:
print("Fizz", end= " ")
elif i % 5 == 0:
print("Buzz", end = " ")
else:
print(i, end = " ")
样本输出
Enter the ending integer: 20
1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz 16 17 Fizz 19 Buzz
Enter the ending integer: 100
1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz 16 17 Fizz 19 Buzz Fizz 22 23 Fizz Buzz 26 Fizz 28 29 FizzBuzz 31 32 Fizz 34 Buzz Fizz 37 38 Fizz Buzz 41 Fizz 43 44 FizzBuzz 46 47 Fizz 49 Buzz Fizz 52 53 Fizz Buzz 56 Fizz 58 59 FizzBuzz 61 62 Fizz 64 Buzz Fizz 67 68 Fizz Buzz 71 Fizz 73 74 FizzBuzz 76 77 Fizz 79 Buzz Fizz 82 83 Fizz Buzz 86 Fizz 88 89 FizzBuzz 91 92 Fizz 94 Buzz Fizz 97 98 Fizz Buzz
结论
能被 3 和 5 整除的数字被称为嘶嘶声和嗡嗡声。如果一个数能被 3 整除，就用“Fizz”代替；如果能被 5 整除，就用“Buzz”代替；如果能被 3 和 5 整除，就用“FizzBuzz”代替。
我希望您喜欢这篇关于 Python 编程语言实现 FizzBuzz 算法的教程。
快乐学习！😇下面包含更多教程:
Python 中的 Flappy Bird 游戏
原文：https://www.askpython.com/python/examples/flappy-bird-game-in-python
Flappy bird 最初是作为一款手机游戏发布的，你可以点击屏幕让小鸟飞起来。如果小鸟撞到管道或屏幕边缘，游戏就会结束，玩家需要重新开始。
在本教程中，我们制作了一个电脑版的游戏，使用向上键或空格键来控制小鸟。
我们将使用 Python 语言来编写代码。我们还将使用 Pygame ，这是一组为编写视频游戏而设计的跨平台 Python 模块。
它包括设计用于 Python 编程语言的计算机图形和声音库。Pygame 适合创建客户端应用程序，这些应用程序可能被包装在一个独立的可执行文件中。
因此，这个项目需要 python 和 Pygame 的先验知识。
用 Python 构建 Flappy Bird 游戏
1.导入模块
对于这个项目，我们正在导入必要的模块。我们将使用random为我们的游戏生成随机数。来自sys模块的sys.exit将用于退出程序。在第 3 行和第 4 行，我们分别导入了 Pygame 和基本的 Pygame 导入。
import random
import sys
import pygame
from pygame.locals import *
2.声明的全局变量
在这一步，我们为我们的游戏声明各种global变量。我们首先设置fps(每秒帧数)、screen_width 和 screen_height 的值。
我们用screen_width和screen_height创建屏幕，作为pygame.display.set_mode()函数的参数。然后，我们创建一个 ground-y 变量，它将给出我们的基本图像的 y 坐标，以及两个字典 game_images 和 game_sounds，它们将包含我们用于游戏的各种图像和声音。
然后，我们通过给定路径将玩家(鸟)、背景、管道和标题的图像存储在这些变量中。
fps = 32
screen_width = 289
screen_height = 511
screen = pygame.display.set_mode((screen_width,screen_height))
ground_y = screen_height*0.8
game_images = {}
game_sounds = {}
player = 'galleimg/bird.png'
background = 'galleimg/background.png'
pipe = 'galleimg/pipe.png'
title = 'galleimg/title.png'
Images Used Flappy Bird
Audio Used Flappy Bird
3.正在创建“main”函数
现在让我们创建游戏开始的主函数，我们必须使用pygame.init()初始化所有 pygame 模块。我们还使用 pygame.tick.Clock()函数创建了fps_clock变量来帮助我们跟踪某一时刻的时间。
然后我们会给我们的主游戏窗口一个标题，并将所有的图片存储在一个元组中，然后我们将它分配给game_images字典中的“numbers”键。我们使用带有图像路径的pygame.image.load()和convert_alpha()来改变图像的像素格式，包括每个像素的 alphas。
类似地，我们使用各种键将消息、基础、管道、背景、播放器和标题的图像添加到字典中。对于管道，我们还添加了一个倒置的管道图像，方法是使用pygame.transform.rotate()函数并将图像旋转 180 度。然后我们使用不同的键将这些声音添加到game_sounds字典中。
这类似于我们对图像所做的，但是这里我们使用pygame.mixer.Sound()函数和各种声音的路径作为存储声音的参数。然后我们开始一个循环，调用welcomeScreen()和mainGame()函数，这将在后面的章节中定义。
if __name__ == "__main__":
pygame.init()
fps_clock = pygame.time.Clock()
pygame.display.set_caption('Flappy Bird')
game_images['numbers'] = (
pygame.image.load('galleimg/0.png').convert_alpha(),
pygame.image.load('galleimg/1.png').convert_alpha(),
pygame.image.load('galleimg/2.png').convert_alpha(),
pygame.image.load('galleimg/3.png').convert_alpha(),
pygame.image.load('galleimg/4.png').convert_alpha(),
pygame.image.load('galleimg/5.png').convert_alpha(),
pygame.image.load('galleimg/6.png').convert_alpha(),
pygame.image.load('galleimg/7.png').convert_alpha(),
pygame.image.load('galleimg/8.png').convert_alpha(),
pygame.image.load('galleimg/9.png').convert_alpha()
)
game_images['message'] = pygame.image.load('galleimg/message.png').convert_alpha()
game_images['base'] = pygame.image.load('galleimg/base.png').convert_alpha()
game_images['pipe'] = (
pygame.transform.rotate(pygame.image.load(pipe).convert_alpha(), 180),
pygame.image.load(pipe).convert_alpha()
)
game_images['background'] = pygame.image.load(background).convert_alpha()
game_images['player'] = pygame.image.load(player).convert_alpha()
game_images['title'] = pygame.image.load(title).convert_alpha()
#Game Sounds
game_sounds['die'] = pygame.mixer.Sound('gallery/audio/die.wav')
game_sounds['hit'] = pygame.mixer.Sound('gallery/audio/hit.wav')
game_sounds['point'] = pygame.mixer.Sound('gallery/audio/point.wav')
game_sounds['swoosh'] = pygame.mixer.Sound('gallery/audio/swoosh.wav')
game_sounds['wing'] = pygame.mixer.Sound('gallery/audio/wing.wav')
while True:
welcomeScreen()
mainGame()
4.创建“欢迎屏幕”功能
现在，我们定义我们的welcomeScreen()函数，它将在游戏开始时显示欢迎屏幕。我们首先为播放器、消息和标题图像指定 x 坐标和 y 坐标的值。
我们通过试凑法选择了参数，您可以更改最适合您的值。这里我们也给出了 base 的 x 坐标。然后，我们开始一个 while 循环，它总是为真，因此将开始一个不会停止的循环，除非控件说退出。
这里我们利用循环的来分析整个游戏中使用pygame.event.get()函数发生的所有事件。然后我们检查，每当遇到退出类型的事件，按下退出键，游戏窗口将关闭。
我们将检查下一个条件，即我们是否单击了向上键或空格键。如果是，我们将从函数返回并开始游戏。如果没有按下任何键或按钮，将显示欢迎屏幕。为此，我们将使用screen.blit()函数放置背景、消息、球员、基地和标题图像。
最后，我们将使用pygame.display.update()更新我们的窗口，并将使用 fps 值作为参数更新我们的时钟变量，以显示每秒 32 帧。
def welcomeScreen():
player_x = int(screen_width/8)
player_y = int((screen_height - game_images['player'].get_height())/2)
message_x = int((screen_width - game_images['message'].get_width())/2)
message_y = int(screen_height*0.2)
title_x = int((screen_width - game_images['message'].get_width())/2)
title_y = int(screen_height*0.04)
base_x = 0
while True:
for event in pygame.event.get():
if event.type == QUIT or (event.type == KEYDOWN and event.key == K_ESCAPE):
pygame.quit()
sys.exit()
elif event.type == KEYDOWN and (event.key == K_SPACE or event.key == K_UP):
return
else:
screen.blit(game_images['background'],(0,0))
screen.blit(game_images['message'],(message_x,message_y))
screen.blit(game_images['player'],(player_x,player_y))
screen.blit(game_images['base'],(base_x,ground_y))
screen.blit(game_images['title'],(title_x,title_y))
pygame.display.update()
fps_clock.tick(fps)
5.创建“mainGame()”函数
现在我们定义 mainGame()函数，首先用 0 初始化变量 score，并再次给出玩家图像和 base 的坐标。
然后，我们使用getRandomPipe()在屏幕上创建 2 个用于位块传输的管道，我们将在后面定义。然后我们用它们的 x 和 y 坐标创建一个上面管道(倒置的)和下面管道的列表。
我们再次通过试凑法来选择值。然后，我们为鸟声明不同方向的速度变量。我们还提供了一个加速度变量。
playerFlapVel 是拍动时的速度，playerflappel 设置为 false(仅当鸟拍动时才成立)。然后我们再次检查事件。
- 首先用于退出游戏，如果为真则退出游戏。
- 然后，我们检查是否按下了向上键或空格键。如果是，我们检查玩家是否在屏幕下方，如果是，我们做一些更新，并使用。播放()。
- 之后，我们使用即将定义的 isCollide()函数检查我们是否崩溃了。如果为真，我们将从函数返回。
然后，我们将检查并更新分数。使用玩家的，中间的位置，和管道的位置，我们增加分数，如果我们穿过一个管道并在控制台中打印它。
此外，我们播放每个管道交叉的点声音。然后，如果 y 方向的玩家速度还没有达到最大值，我们将提供加速度。
稍后，我们更新 playerFlpped 值，然后更新鸟的位置。我们将管道移动到左边，并在第一个管道将要穿过屏幕最左边的部分时添加一个新管道。
我们还将查看管道是否在屏幕之外，如果是，我们将其移除，并将管道和乐谱放在屏幕上，稍后更新显示屏。
对于分数，我们首先访问分数的所有数字(如果分数超过 1 个数字)并放置所需的图像。我们再次更新我们的时钟。
def mainGame():
score = 0
player_x = int(screen_width/8)
player_y = int(screen_height/2)
base_x = 0
newPipe1 = getRandomPipe()
newPipe2 = getRandomPipe()
upperPipes = [
{'x': screen_width+200, 'y': newPipe1[0]['y']},
{'x': screen_width+200+(screen_width/2), 'y': newPipe2[0]['y']}
]
lowerPipes = [
{'x': screen_width+200, 'y': newPipe1[1]['y']},
{'x': screen_width+200+(screen_width/2), 'y': newPipe2[1]['y']}
]
pipeVelX = -4
playerVelY = -9
playerMaxVelY = 10
playerMinVelY = -8
playerAccY = 1
playerFlapVel = -8
playerFlapped = False
while True:
for event in pygame.event.get():
if event.type == QUIT or (event.type == KEYDOWN and event.key == K_ESCAPE):
pygame.quit()
sys.exit()
if event.type == KEYDOWN and (event.key == K_SPACE or event.key == K_UP):
if player_y > 0:
playerVelY = playerFlapVel
playerFlapped = True
game_sounds['wing'].play()
crashTest = isCollide(player_x, player_y, upperPipes, lowerPipes)
if crashTest:
return
playerMidPos = player_x + game_images['player'].get_width()/2
for pipe in upperPipes:
pipeMidPos = pipe['x'] + game_images['pipe'][0].get_width()/2
if pipeMidPos<= playerMidPos < pipeMidPos + 4:
score +=1
print(f"Your Score is {score}")
game_sounds['point'].play()
if playerVelY <playerMaxVelY and not playerFlapped:
playerVelY += playerAccY
if playerFlapped:
playerFlapped = False
playerHeight = game_images['player'].get_height()
player_y = player_y + min(playerVelY, ground_y - player_y - playerHeight)
for upperPipe, lowerPipe in zip(upperPipes, lowerPipes):
upperPipe['x'] += pipeVelX
lowerPipe['x'] += pipeVelX
if 0<upperPipes[0]['x']<5:
newPipe = getRandomPipe()
upperPipes.append(newPipe[0])
lowerPipes.append(newPipe[1])
if upperPipes[0]['x'] < -game_images['pipe'][0].get_width():
upperPipes.pop(0)
lowerPipes.pop(0)
screen.blit(game_images['background'], (0, 0))
for upperPipe, lowerPipe in zip(upperPipes, lowerPipes):
screen.blit(game_images['pipe'][0], (upperPipe['x'], upperPipe['y']))
screen.blit(game_images['pipe'][1], (lowerPipe['x'], lowerPipe['y']))
screen.blit(game_images['base'], (base_x, ground_y))
screen.blit(game_images['player'], (player_x, player_y))
myDigits = [int(x) for x in list(str(score))]
width = 0
for digit in myDigits:
width += game_images['numbers'][digit].get_width()
Xoffset = (screen_width - width)/2
for digit in myDigits:
screen.blit(game_images['numbers'][digit], (Xoffset, screen_height*0.12))
Xoffset += game_images['numbers'][digit].get_width()
pygame.display.update()
fps_clock.tick(fps)
6.isCollide()和 getRandomPipe()函数
在 isCollide()函数中，首先，我们检查是否碰到了底部的顶部，然后通过比较鸟的位置和管道的位置来检查是否有碰撞，从而寻找与上部管道的碰撞。
我们对较低的管道重复同样的操作。如果任何碰撞条件为真，我们播放击中的声音并返回 true。
在 getRandomPipe()函数中，我们将管道的高度存储在 pipeHeight 变量中，并使用 offset 变量存储 screen_width 的三分之一。
然后，我们使用等距离的随机函数为管道指定 x 和 y 坐标值，但上下管道的尺寸不同。然后，我们将坐标存储在一个名为 pipe 的列表中，并返回它。
def isCollide(player_x, player_y, upperPipes, lowerPipes):
if player_y>ground_y-25 or player_y<0:
game_sounds['hit'].play()
return True
for pipe in upperPipes:
pipeHeight = game_images['pipe'][0].get_height()
if (player_y < pipeHeight + pipe['y']) and (abs(player_x - pipe['x']) < game_images['pipe'][0].get_width() - 15):
game_sounds['hit'].play()
return True
for pipe in lowerPipes:
if (player_y + game_images['player'].get_height() > pipe['y']) and (abs(player_x - pipe['x']) < game_images['pipe'][0].get_width() - 15):
game_sounds['hit'].play()
return True
return False
def getRandomPipe():
pipeHeight = game_images['pipe'][0].get_height()
offset = screen_height/3
y2 = offset + random.randrange(0, int(screen_height - game_images['base'].get_height() - 1.2*offset))
pipeX = screen_width + 10
y1 = pipeHeight - y2 + offset
pipe = [
{'x': pipeX, 'y': -y1},
{'x': pipeX, 'y': y2}
]
return pipe
最终输出
下面的视频演示了最终 flappy bird 游戏的最终输出！
结论
恭喜你！今天我们从头开始构建我们自己的 flappy bird 游戏！
希望你喜欢！感谢您的阅读！
Flask 上下文——揭开应用程序和请求上下文的神秘面纱
原文：https://www.askpython.com/python-modules/flask/flask-application-request-context
在本教程中，我们将首先介绍 Flask 上下文，然后进一步研究 Flask 中的两个上下文——应用程序上下文和请求上下文。
什么是烧瓶环境？
Flask 使用上下文使某些变量可以临时全局访问
在 Flask 中，您可能已经注意到 Flask 视图不将请求对象作为参数，并且仍然可以使用它们。只有当请求对象是全局对象时才有可能，对吗？
嗯，答案是不
如果请求对象是全局的，那么 Flask 不会区分同时到达服务器的请求。但事实并非如此；网站确实可以同时处理多个请求。那怎么可能呢？？
嗯，Flask 使用上下文使某些变量暂时对于特定的请求对象是全局的，这样视图可以访问这些变量以返回输出。
烧瓶环境有两种类型:
- 应用程序上下文
- 请求上下文
烧瓶中的应用环境
应用程序上下文跟踪应用程序级别的数据。因此，这些存储特定于整个应用程序的值，如数据库连接、配置等。
应用程序上下文公开(例如，暂时使它们成为全局的)对象，例如 current_app 和 g 变量。
1.当前应用程序
current_app 指的是处理请求的实例。也就是说，它与运行 Flask 的应用程序相关。
2. g 变量
这里 g 代表全局，用于在请求处理过程中暂时存储数据库细节等数据。
一旦设置了 current_app 和 g 变量的值，应用程序中的任何视图都可以使用它们。
当一个特定的请求进来时，Flask 自动推送(或激活)应用程序上下文，并在处理完请求后删除它。
请求烧瓶中的上下文
与应用程序上下文类似，请求上下文跟踪请求级数据。因此，这些存储特定于每个请求的值。
请求上下文暴露了像请求和会话这样的对象。
1.请求
请求对象包含关于当前 web 请求的信息。请求上下文使请求暂时成为全局的，因此所有视图都可以轻松地访问它们，而无需将它们作为参数。
注意:请求仅包含当前请求的信息。当一个新请求进来时，请求对象存储关于当前新请求的信息，以前的信息被删除。
2。会话
与请求对象不同，会话是一个类似于 字典的对象 ，它存储请求之间持续的信息。我们的网站上很快会有一篇关于 Flask 会议的完全不同的文章，给你更好的信息。
因此，一旦请求上下文被激活，应用程序中的任何视图都可以访问它所公开的对象(请求和会话)。
与应用程序上下文一样，Flask 也在特定请求到来时自动推送(或激活)请求上下文，并在处理完请求后删除它。
注意:当推送请求上下文时，如果应用上下文不存在，它也会自动创建一个应用上下文。
手动推动外壳中的烧瓶上下文。
Flask 应用程序自动创建/推送应用程序和请求上下文。
因此，在视图函数中，您可以访问应用程序和请求公开的所有对象，而不用担心上下文。
但是，如果您试图在视图函数之外或 python shell 中使用对象，如下所示:
from flask import Flask, request
request.method
Error
您将得到一个错误。应用程序上下文对象也是如此
from flask import Flask, current_app
current_app.name
Error
这是因为应用程序和请求上下文不是活动的。因此，我们首先必须创建它们。
这里，我们使用 Flask 实例的 app_context() 方法创建应用程序上下文
运行代码:
from flask import Flask, current_app
app = Flask(__name__)
appli_context = app.app_context()
current_app.name
这里
- 我们声明一个 Flask 对象—app。
- 我们使用 app.app_context() 推送/创建应用上下文
- current_app 现在处于活动状态，并链接到 name 文件，即 main 文件本身。
App Context
现在错误已经消失了！类似地，我们使用 Flask 实例的 test_request_context() 方法创建请求上下文
from flask import Flask, request
app = Flask(__name__)
req = app.test_request_context()
req.request
这里也是
- 我们声明一个 Flask 对象—app。
- 我们使用app . tes _ request _ context()推送/创建请求上下文
- 请求对象现在是活动的，并且链接到主机网站 ie，即“ http://loalhost/ ”文件本身。
Request
因此我们得到了正确的无误差输出。
结论
就这样，伙计们！！这就是 Flask 的全部内容。你不需要太担心，因为 Flask 会在应用程序文件中自动创建它们。
flask cookie–在 Web 应用程序上设置 cookie
原文：https://www.askpython.com/python-modules/flask/flask-cookies
在本教程中，我们将处理 Flask cookies，并在 Flask Web 应用程序中使用它们。所以系好安全带，我们开始吧。
什么是饼干？
cookie 或者更好的说法，HTTP cookie是文本文件，存储在客户端机器上。根据客户端浏览器的 cookie 设置，每个 cookie 可以永久保存或保存特定的到期时间。
当 Cookie 到达到期日期和时间后，它会自动从客户端浏览器中删除。
Cookies 出现在客户端跟踪并记住用户在网络上的活动。这些信息稍后将用于改善用户的整体站点体验。
饼干是如何工作的？
我们知道， HTTP 是一种无状态协议，这意味着服务器无法区分用户是否是第一次访问网站。所以为了解决这个问题，网站使用 cookies。
因此，当客户端第一次访问某个特定的站点时，该客户端不会拥有该站点设置的任何 cookies。因此，服务器创建一个新的 cookie，并将其发送给客户机本身。
因此在接下来的访问中，客户机将把 cookie 附加到请求中并发送出去。然后，服务器从请求对象中检索 cookie，并使用该 cookie 信息来改善站点的用户体验。
为什么要用饼干？
简而言之，我们使用 cookies 通过存储和跟踪用户的活动来提供更好的用户体验。此外，它们还存储诸如网站的截止日期、路径、和域名等信息。
Cookies 发挥作用的一些地方有:
- 你可能已经注意到，在脸书这样的电子商务或社交媒体网站上，当你没有注销就离开网站时，你的账户在你下次访问该网站时仍然是登录的。
- 在许多电子商务网站上，你会根据浏览器之前的搜索信息获得不同产品的推荐。
所有这些都是使用 cookies 完成的。
动手制作保温瓶饼干
在 Flask 中，Cookies 设置在响应对象上。也就是说，服务器将 Cookie 和响应一起发送给用户。
我们使用 make_response() 函数来完成。一旦设置了响应，我们使用 set_cookie() 函数将 cookie 附加到它上面。
cookie 具有以下属性:
response.set_cookie('<Title>','<Value>','<Expiry Time>')
因此，代码看起来像这样:
@app.route('/setcookie')
def setcookie():
resp = make_response(f"The Cookie has been set")
resp.set_cookie('Name','AskPython')
return resp
简单对！现在我们需要从用户那里取回 Cookie。cookie 会随请求一起发送回服务器。我们使用 request.cookies.get() 函数来检索它。
因此，考虑代码:
@app.route('/getcookie')
def getcookie():
name = request.cookies.get('Name', None)
return f"The Site : {name}"
这里，Cookie 信息存储在 name 变量中。
因此，最终的主应用程序文件将是:
from flask import Flask, make_response, request
app = Flask(__name__)
@app.route('/setcookie')
def setcookie():
resp = make_response(f"The Cookie has been Set")
resp.set_cookie('Name','AskPython')
return resp
@app.route('/getcookie')
def getcookie():
name = request.cookies.get('Name')
return f"The Site : {name}"
app.run(host='localhost', port=5000)
守则的实施
现在让我们运行服务器并转到" /setcookie "
Set Cookie
和"/get cookie"
Get Cookie
完美！
结论
就这样，伙计们。这都是因为烧瓶饼干。为了更好地理解代码，请自己尝试一下。
下次再见了！
Flask CRUD 应用程序–创建、检索、更新和删除
原文：https://www.askpython.com/python-modules/flask/flask-crud-application
在本教程中，我们将学习 CRUD，然后创建 Flask CRUD 应用程序。所以让我们开始吧！！
什么是 CRUD 应用程序？
处理创建/检索/更新或删除操作的 web 应用程序被称为 CRUD 应用程序。博客网站是 CRUD 应用程序的一个典型例子。
这里，
- 我们可以创建一个新的博客:创建
- 查看发布的博客:检索
- 更新博客:更新
- 删除博客:删除
CRUD 的定义总结如下:
| 操作 | 功能 |
|---|---|
| 创建 | 创建新数据并将其添加到数据库中 |
| 检索 | 从数据库中检索数据 |
| 更新 | 将现有数据更新到数据库中 |
| 删除 | 删除数据库中的现有数据 |
CRUD
创建一个 Flask CRUD 应用程序
我们将创建一个简单的 Flask CRUD 应用程序，它可以创建/检索/更新/删除员工信息。
因此，在此应用程序中，您可以:
- 创建新的员工信息
- 查看员工名单。
- 查看特定员工的信息。
- 更新员工的信息
- 删除员工信息
1。编码 Models.py
在这里，我们将使用 Flask_SQLAlchemy 和 SQLite DB。
首先安装 Flask_SQLAlchemy
pip install flask_sqlalchemy
现在创建一个 models.py 文件，并添加以下代码:
from flask_sqlalchemy import SQLAlchemy
db = SQLAlchemy()
class EmployeeModel(db.Model):
__tablename__ = "table"
id = db.Column(db.Integer, primary_key=True)
employee_id = db.Column(db.Integer(),unique = True)
name = db.Column(db.String())
age = db.Column(db.Integer())
position = db.Column(db.String(80))
def __init__(self, employee_id,name,age,position):
self.employee_id = employee_id
self.name = name
self.age = age
self.position = position
def __repr__(self):
return f"{self.name}:{self.employee_id}"
这里我们只是创建了 EmployeeModel。如果你在理解语法上有任何困难，一定要查看一下 SQLAlchemy 教程
2.编码主应用程序
现在，让我们编写主要的 Flask 应用程序文件。我们将从导入 flask 开始，初始化 Flask 应用程序，并设置应用程序运行时细节。
from flask import Flask
app = Flask(__name__)
app.run(host='localhost', port=5000)
现在我们需要将 SQLite DB 与 SQLAlchemy 链接起来。因此，添加以下代码片段:
from flask import Flask
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///<db_name>.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.run(host='localhost', port=5000)
将 < db_name > 替换为您想要的 db 文件名称。
此外，我们需要链接 db 实例(来自 models.py )并在用户访问服务器之前创建 DB 文件。为此:
from flask import Flask
app =Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///<db_name>.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db.init_app(app)
@app.before_first_request
def create_table():
db.create_all()
app.run(host='localhost', port=5000)
好了，既然数据库和模型已经就位，让我们编写 CRUD 视图。
3.编码创建视图
创建视图应该能够完成以下任务:
- 当客户端转到这个页面(GET 方法)时，它应该显示一个表单来获取客户端的数据。
- 在提交时(POST 方法)，它应该将客户端的数据保存在 EmployeeModel 数据库中。
因此创建视图将会是:
@app.route('/data/create' , methods = ['GET','POST'])
def create():
if request.method == 'GET':
return render_template('createpage.html')
if request.method == 'POST':
employee_id = request.form['employee_id']
name = request.form['name']
age = request.form['age']
position = request.form['position']
employee = EmployeeModel(employee_id=employee_id, name=name, age=age, position = position)
db.session.add(employee)
db.session.commit()
return redirect('/data')
createpage.html将包含 HTML 表单:
<form action='' method = "POST">
<p>employee ID <input type = "integer" name = "employee_id" /></p>
<p>name <input type = "text" name = "name" /></p>
<p>age <input type = "integer" name = "age" /></p>
<p>position <input type = "text" name = "position" /></p>
<p><input type = "submit" value = "Submit" /></p>
</form>
4。编码检索视图
这里我们将有两个视图:
- 显示员工列表。
- 显示单个员工的信息。
因此第一个 RetrieveDataList 视图将是:
@app.route('/data')
def RetrieveDataList():
employees = EmployeeModel.query.all()
return render_template('datalist.html',employees = employees)
datalist.html文件将显示员工名单:
{% for employee in employees %}
<h3>{{employee}}</h3><hr>
{% endfor %}
一定要看看我们的 Flask 模板来了解更多关于模板语言的知识。
第二个 RetrieveSingleEmployee 视图将是:
@app.route('/data/<int:id>')
def RetrieveSingleEmployee(id):
employee = EmployeeModel.query.filter_by(employee_id=id).first()
if employee:
return render_template('data.html', employee = employee)
return f"Employee with id ={id} Doenst exist"
employee model . query . filter _ by(employee _ id = id)。first() 将返回数据库中具有雇员 ID = id 的第一个雇员，如果具有该 ID 的雇员不存在，则返回 None 。
data.html显示员工的信息:
<h3>Id</h3>
<p>{{employee.employee_id}}</p><hr>
<h3>Name</h3>
<p>{{employee.name}}</p><hr>
<h3>Age</h3>
<p>{{employee.age}}</p><hr>
<h3>Position</h3>
<p>{{employee.position}}</p><hr>
5.编码更新视图
Update 视图将使用用户提交的新信息更新数据库中的员工详细信息。
因此，更新视图将是:
@app.route('/data/<int:id>/update',methods = ['GET','POST'])
def update(id):
employee = EmployeeModel.query.filter_by(employee_id=id).first()
if request.method == 'POST':
if employee:
db.session.delete(employee)
db.session.commit()
name = request.form['name']
age = request.form['age']
position = request.form['position']
employee = EmployeeModel(employee_id=id, name=name, age=age, position = position)
db.session.add(employee)
db.session.commit()
return redirect(f'/data/{id}')
return f"Employee with id = {id} Does nit exist"
return render_template('update.html', employee = employee)
用户将通过表单提交新的详细信息。这里，我们首先删除数据库中的旧信息，然后添加新信息
update.html显示提交新细节的表格:
<form action='' method = "POST">
<p>name <input type = "text" name = "name" value="{{employee.name}}"/></p>
<p>age <input type = "integer" name = "age" value="{{employee.age}}"/></p>
<p>position <input type = "text" name = "position" value="{{employee.position}}"/></p>
<p><input type = "submit" value = "Submit" /></p>
</form>
6.编码删除视图
删除视图将只从数据库文件中删除雇员信息。
删除视图将是:
@app.route('/data/<int:id>/delete', methods=['GET','POST'])
def delete(id):
employee = EmployeeModel.query.filter_by(employee_id=id).first()
if request.method == 'POST':
if employee:
db.session.delete(employee)
db.session.commit()
return redirect('/data')
abort(404)
return render_template('delete.html')
delete.html刚刚再次确认删除:
<form action='' method="post">
Click YES to confirm
<input type = "submit" value="YES">
<a href='/data'>Cancel</a>
</form>
如果用户按下 Yes ，则删除该员工。否则他会被带回去。
CRUD 应用程序的完整代码
models.py :
from flask_sqlalchemy import SQLAlchemy
db =SQLAlchemy()
class EmployeeModel(db.Model):
__tablename__ = "table"
id = db.Column(db.Integer, primary_key=True)
employee_id = db.Column(db.Integer(),unique = True)
name = db.Column(db.String())
age = db.Column(db.Integer())
position = db.Column(db.String(80))
def __init__(self, employee_id,name,age,position):
self.employee_id = employee_id
self.name = name
self.age = age
self.position = position
def __repr__(self):
return f"{self.name}:{self.employee_id}"
主烧瓶应用:
from flask import Flask,render_template,request,redirect
from models import db,EmployeeModel
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///data.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db.init_app(app)
@app.before_first_request
def create_table():
db.create_all()
@app.route('/data/create' , methods = ['GET','POST'])
def create():
if request.method == 'GET':
return render_template('createpage.html')
if request.method == 'POST':
employee_id = request.form['employee_id']
name = request.form['name']
age = request.form['age']
position = request.form['position']
employee = EmployeeModel(employee_id=employee_id, name=name, age=age, position = position)
db.session.add(employee)
db.session.commit()
return redirect('/data')
@app.route('/data')
def RetrieveList():
employees = EmployeeModel.query.all()
return render_template('datalist.html',employees = employees)
@app.route('/data/<int:id>')
def RetrieveEmployee(id):
employee = EmployeeModel.query.filter_by(employee_id=id).first()
if employee:
return render_template('data.html', employee = employee)
return f"Employee with id ={id} Doenst exist"
@app.route('/data/<int:id>/update',methods = ['GET','POST'])
def update(id):
employee = EmployeeModel.query.filter_by(employee_id=id).first()
if request.method == 'POST':
if employee:
db.session.delete(employee)
db.session.commit()
name = request.form['name']
age = request.form['age']
position = request.form['position']
employee = EmployeeModel(employee_id=id, name=name, age=age, position = position)
db.session.add(employee)
db.session.commit()
return redirect(f'/data/{id}')
return f"Employee with id = {id} Does nit exist"
return render_template('update.html', employee = employee)
@app.route('/data/<int:id>/delete', methods=['GET','POST'])
def delete(id):
employee = EmployeeModel.query.filter_by(employee_id=id).first()
if request.method == 'POST':
if employee:
db.session.delete(employee)
db.session.commit()
return redirect('/data')
abort(404)
return render_template('delete.html')
app.run(host='localhost', port=5000)
烧瓶积垢应用程序的实现
运行服务器并转到“/数据/创建”
Create
现在输入详细信息，按提交。同样的，我也多加了几个。转到/数据
Data List
让我们检查第一个。转到“/数据/1
Data
现在让我们转到“ /data/1/update ”并更新一些细节
Update
详细信息现已更新。现在让我们删除该员工。进入/数据/1/删除
Delete
点击是，瞧！该员工被删除
结论
就这样，伙计们！！这都是关于 Flask 中的 CRUD 操作。一定要看看我们的 Flask REST API 教程，它是 Flask REST 框架中的 CRUD 应用程序。
下一篇文章再见！！
Flask 调试模式–启用 Flask 中的调试模式和调试工具栏
原文：https://www.askpython.com/python-modules/flask/flask-debug-mode
在这种模式下，我们将了解 Flask 调试模式。稍后，我们还将实现一个调试器工具栏，用于在 Flask 中进行调试。所以让我们开始吧！
激活烧瓶调试模式
考虑一个带有调试模式 = False 的 Flask 应用程序。当您更新一些代码时，您需要重新启动服务器以使网页上的更改生效。
这可能是相当重复的，因为我们一直在改变和更新我们的代码。因此，为了简化编码，Flask 为我们提供了调试模式！
因此，随着调试模式的开启，所有的应用程序代码更改将在开发阶段立即得到更新，消除了重启服务器的需要。
烧瓶中调试模式的实现
让我们添加代码来启用 Flask 中的调试模式！如果你也希望在 Flask 中启用登录，这里有另一个教程。
#Method 1
app.debug = True
#or
#Method @
app.run('host' = localhost, debug = True)
看，就这么简单！现在只需刷新服务器，所有的更改都在那里。
注意 : 切勿在生产环境中启用调试模式或任何其他内置调试器。调试器允许从浏览器执行任意 Python 代码。尽管这需要一个保护密钥，但仍然不安全。
将外部调试器工具栏添加到 Flask 应用程序中
Flask 还提供了一个调试器工具栏，用于大规模调试我们的 web 应用程序。现在，为什么是工具栏？
嗯，所有的开发人员，在生命中的某个时刻，都会遇到错误。寻找并消除它们不是一件容易的事情。有时，指出错误可能需要很长时间。因此，每个开发人员都必须知道调试的艺术。
但是不出所料，有了 Flask，一切都变得简单多了。我们需要一个 Flask 调试工具栏，我们完成了！！
Flask ToolBar
好了，现在让我们看看它由什么组成:
- 版本:表示用于运行网页的 Flask 库的版本。
- 时间:表示网页的加载时间。
- HTTP Headers: 给出关于 HTTP 头键值对的信息
- 请求:给出关于请求变量的信息——视图、会话、cookies 等
- 配置:告知烧瓶应用程序的各种配置
- 模板:给出关于模板的信息
- SQLAlchemy: 给出关于网页上调用的 SQLAlchemy 查询的信息。(查看我们的 Flask Postgres SQLAlchemy 文章，了解有关 SQLAlchemy 的更多信息)
- 日志:给出日志记录的信息。(查看烧瓶日志以了解更多信息)
- 路线列表:显示我们的 web 应用程序中所有可能的 URL 路线。
- Profiler: 激活时，给出所用烧瓶分析器的信息。
动手使用烧瓶调试工具栏
首先我们需要安装工具栏。运行代码:
pip install flask-debugtoolbar
就这样，工具栏安装完毕
1.将工具栏添加到 Flask 应用程序
要添加工具栏，语法是:
from flask import Flask
from flask_debugtoolbar import DebugToolbarExtension
app = Flask(__name__)
app.debug = True
toolbar = DebugToolbarExtension(app)
只有在 Debug = True 模式下，网页才会显示调试工具栏。在生产服务器中( Debug = False )，web 应用程序不会显示工具栏。
因此，考虑以下烧瓶应用示例:
from flask import Flask
from flask_debugtoolbar import DebugToolbarExtension
app = Flask(__name__)
app.debug = True
toolbar = DebugToolbarExtension(app)
@app.route('/form')
def form():
return render_template('form.html')
app.run(host='localhost', port=5000)
还有那个form.html:
<html>
<body>
<form action="/login" method = "POST">
<p>name <input type = "text" name = "name" /></p>
<p>age <input type = "integer" name = "age" /></p>
<p><input type = "submit" value = "Submit" /></p>
</form>
</body>
</html>
注意:模板应该包含 <主体> 属性，工具栏才能工作。
2.运行烧瓶应用程序
现在让我们启动服务器并检查:
Debug Toolbar
完美！网页上就有工具栏。
结论
就这样，伙计们！！这都是关于烧瓶调试模式和工具栏。请务必在网站上查看我们的其他烧瓶文章。编码快乐！
Flask 错误处理–在 Flask 中显示自定义错误页面
原文：https://www.askpython.com/python-modules/flask/flask-error-handling
本文将处理不同类型的 HTTP 错误，然后学习如何使用 Flask 错误处理来处理这些错误。所以让我们开始吧！
为什么我们需要错误处理？
web 应用程序中的错误可能由于多种原因而发生。这可能是由于应用程序中的错误代码或用户的一些错误请求或服务器停机。
因此，处理这些错误至关重要。虽然浏览器默认为您处理 HTTP 错误，但是输出并不美观。
例如，在构建 Flask 应用程序时，您可能会遇到 500 个内部服务器错误。
500 Internal Server Error
一行简单的指示错误原因就足够了，而不是显示无关的数据。
这就是 Flask 错误处理程序发挥作用的地方。
使用 Flask 错误处理程序，我们可以:
- 自定义错误页面外观。
- 仅向用户显示相关数据。
常见 HTTP 错误
一些最常见的错误是:
| HTTP 错误代码 | 意义 |
|---|---|
| 301 | 永久移动 |
| 302 | 临时移动 |
| 400 | 错误的请求 |
| 403 | 被禁止的 |
| 404 | 未发现 |
| 429 | 太多请求 |
| 500 | 内部服务器错误 |
| 502 | 错误网关 |
| 503 | 服务不可用 |
| 504 | 网关超时 |
HTTP Errors
动手操作烧瓶错误处理
错误代码—404和 500 是我们每天处理的最常见的错误。
因此，在本节中，我们将为 404 和 500 构建一个简单的错误处理程序。其他错误的语法完全相同。
在 flask 中，我们使用内置的 error_handler decorator 。
语法是:
@app.errorhandler(status_code)
def function_name(error):
return render_template('xyz.html'),status_code
因此，考虑以下烧瓶应用示例:
from flask import Flask, render_template
app = Flask(__name__)
@app.route('/blogs')
def blog():
return render_template('blog.html')
#Handling error 404 and displaying relevant web page
@app.errorhandler(404)
def not_found_error(error):
return render_template('404.html'),404
#Handling error 500 and displaying relevant web page
@app.errorhandler(500)
def internal_error(error):
return render_template('500.html'),500
#app.run(host='localhost', port=5000)
app.run(host='localhost', port=5000)
Blog.html:
<h2>Welcome to the Blog</h2>
404.html文件:
<h2>The webpage you are trying is not found</h2>
<img src = "{{url_for('static','images/opps.jpg') }}"
在这里，我们使用一个图像来显示在 404 网页上
同样地500.html文件:
<h2>Something Went Wrong</h2>
实施
现在运行服务器，并转到任何不存在的 URL 端点
404
现在为了得到 500 的错误，故意把 render_template() 的几个字母互换成 remder_template()
现在重启服务器，进入 "/blogs" 网址。您现在将看到 500 错误页面
500 Error Page
完美！
结论
就这样，伙计们！！您现在可以根据您的网页主题自定义错误页面。一定要看看我们的其他 Flask 教程来了解更多关于 Flask 的知识。
下一篇文章再见！！快乐编码🙂
烧瓶扩展——什么是扩展，如何安装？
原文：https://www.askpython.com/python-modules/flask/flask-extensions
在本文中，我们将讨论一些基本的 Flask 扩展。这些扩展方便易用。所以让我们来研究一下吧！！
为什么我们需要长颈瓶？
正如我们所知，Flask 是一个微型 web 框架，因为它的核心功能只包括基于 Werkzueg 的 WSGI、路由和基于 Jinja2 的模板引擎。
它还可以支持 cookies、会话和前端特性，如 JSON、静态文件等。
但这不足以构建全面安全的 web 应用程序。这就是长颈瓶延伸进入画面的地方。有了 Flask-Extensions，我们可以使用 Flask 框架执行更多的任务。
有许多长颈瓶扩展可用。我们现在来看看一些最常用的烧瓶延长管
一些重要的长颈瓶扩展
一些最常用的长颈瓶延伸部分有:
| 延长 | 效用 |
|---|---|
| 烧瓶-SQLAlchemy | 它提供了一个模型类型的接口来轻松地与数据库表进行交互。 |
| 烧瓶-WTF | 它提供了在 Flask web 应用程序中设计表单的另一种方法。使用 WT 表单，我们可以验证和保护用户发送的表单数据。 |
| 烧瓶邮件 | 它为 Flask 应用程序提供了一个 SMTP 接口，用于向客户端/用户发送电子邮件。 |
| 烧瓶-登录 | 它为 Flask Web 应用程序提供用户认证功能 |
| 瓶调试工具 | 它提供了一个强大的调试工具栏，用于调试 Flask 应用程序 |
| 烧瓶-Sijax | 它有助于添加 Sijax，这是一个 Python/ jQuery 库，使 AJAX 易于在 web 应用程序中使用，并支持 Flask 应用程序。 |
这些扩展是 Python 模块，它扩展了 Flask 应用程序的功能。因此，我们可以使用 pip 实用程序像安装 Python 库一样安装它们。
安装 Flask-Extension "Flask-foo的语法是:
pip install flask-foo
#pip install flask-Sqlalchemy
#pip install flask-wtf
#pip install flask-mail
#pip install flask-login
#pip install flask-debugtoolbar
#pip install flask-sijax
导入也类似于我们导入 python 库的方式:
from flask_foo import <Class>, <function>...
对于高于 0.7 的 Flask 版本，您也可以通过 flask.ext. 导入扩展
语法是:
from flask.ext import foo #sqlalchemy, login .....
如果您的兼容模块未激活，您会得到一个错误。要激活它，请使用代码:
import flaskext_compat
flaskext_compat.activate()
from flask.ext import foo
一旦我们激活它，我们可以像以前一样使用 flask.ext 。
参考文献:
- 烧瓶 SQLAlchemy:【https://flask-sqlalchemy.palletsprojects.com/en/2.x/
- Flask WT Forms:https://Flask . pallets projects . com/en/1.1 . x/patterns/WT Forms/
- 烧瓶邮件:【https://pythonhosted.org/Flask-Mail/】T2
- 烧瓶登录:【https://flask-login.readthedocs.io/en/latest/
- 烧瓶调试工具栏:【https://flask-debugtoolbar.readthedocs.io/en/latest/
- 烧瓶 Sijax:【https://pythonhosted.org/Flask-Sijax/
结论
就这样，伙计们！这是 Flask 教程系列的最后一篇文章。一定要看看我们的其他 Flask 教程来了解更多关于 Flask 的知识。
编码快乐！！
Flask 文件上传–在 Python Flask 中创建一个表单来上传文件
原文：https://www.askpython.com/python-modules/flask/flask-file-uploading
欢迎来到本教程！在这里，我们将学习如何使用 HTML 表单在 Flask 中上传文件。好了，我的编码伙伴们，让我们开始吧！
如何使用 Python Flask 上传文件？
在 Flask 中上传文件是一件轻而易举的事情。流程图如下:
- HTML 表单显示文件上传界面
- 使用 Flask 视图保存上传的文件
仅此而已。这就是我们所需要的。
1。用于文件上传的 HTML 表单
为了处理文件上传，我们需要在 HTML 模板的表单属性中添加enctype = " multipart/form-data "。
HTML 表单示例如下所示:
<html>
<body>
<form action = "http://localhost:5000/endpoint" method = "POST" enctype = "multipart/form-data">
<input type = "file" name = "file" />
<input type = "submit" value = "Submit" />
</form>
</body>
</html>
2。保存文件
在 Flask 中，上传的文件首先保存在服务器上的临时位置，然后永久保存在目标位置。
我们可以在 Flask 的配置设置中指定文件的目标位置和 max_size:
| 句法 | 描述 |
|---|---|
| app . config['UPLOAD _ FOLDER'] | 指定目标文件夹 |
| app . config['MAX _ CONTENT-PATH'] | 以字节指定文件的最大长度 |
我们可以通过直接硬编码或者使用文件名函数来保存目标文件的名称。
f = request.files['file']
f.save(f.filename)
始终建议使用 secure_filename 函数来使用上传文件的安全版本。
f = request.files['file']
f.save(secure_filename(f.filename))
编码烧瓶文件上传表
有了这些理论，让我们直接进入主题，理解使用 Flask 上传文件所需的具体步骤。
1。表单模板
用下面的代码创建一个简单的 HTML 表单"form.html"文件:
<html>
<body>
<form action = "http://localhost:5000/upload" method = "POST" enctype = "multipart/form-data">
<input type = "file" name = "File" />
<input type = "submit" value = "Submit" />
</form>
</body>
</html>
这个简单的表单只接收用户提交的文件。一定要查看我们的 Flask Forms 文章，了解更多关于 Flask Forms 的信息
2 。编码烧瓶视图功能
现在，在 Flask 应用程序中添加以下代码
from flask import Flask,render_template,request
from werkzeug import secure_filename
@app.route('/form')
def form():
return render_template('form.html')
@app.route('/upload', methods = ['POST', 'GET'])
def upload():
if request.method == 'POST':
f = request.files['file']
f.save(secure_filename(f.filename))
return "File saved successfully"
app.run(host='localhost', port=5000)
这里，
- 表单视图显示表单。
- 表单提交后，表单数据(上传的文件)通过 POST 方法发送到上传视图(作为请求对象的一部分)。
- 然后，上传视图将文件临时存储在变量 f 中，然后用 f.save() 属性永久保存。
一定要看看我们的 Flask Forms 文章，了解更多关于 Flask 中的表单。
3。代码的实现
运行服务器，让我们检查一下
Upload Form
选择一个文件，然后点击提交
Upload
就这样，文件保存成功。现在在你的文件夹中，你可以在你的 Flask 申请文件旁边看到上传的文件。****
Destination
瞧啊。您的文件已成功上传。
结论
本教程到此为止，各位！为了更好地理解，请亲自尝试上面给出的例子。
下一篇文章再见！在那之前，快乐编码🙂
Flask flash()方法——如何在 Flask 中刷新消息？
原文：https://www.askpython.com/python-modules/flask/flask-flash-method
在本教程中，我们将学习如何使用 Flask flash()方法刷新消息。
闪现消息是什么意思？
GUI 应用程序为用户的操作提供反馈总是好的。
也就是说，例如，在 Flask form 中，如果用户将某个字段留空，则给他一个错误/信息消息，告诉他该字段是必填的。
Python Tkinter GUI 框架使用 消息 或对话框来显示消息、，在客户端脚本语言 JavaScript 中，使用 alert 函数来完成。
在 Flask 中，我们有这个 flash 方法可以做到这一点。
烧瓶闪光灯是如何工作的？
Flask flash 方法向用户显示消息。
使用 flash，我们可以在一个 Flask 视图中创建一个 Flash 消息，然后在另一个视图中显示它，这个视图叫做“next”，通常是一个模板视图。
模板视图的典型例子是:
@app.route('/template')
def blog():
#codes...
#codes...
return render_template('template.html')
因此，Flask 视图在一个视图中创建一个 Flash 消息，然后将其传递给下一个视图(和请求一起)，后者向用户显示该消息。
Flash 的语法:
flash(message,category)
这里，
- 消息:要显示的消息
- 类别:可选参数，可以设置为“错误”、“信息”、“警告”
为了从会话中提取存储的 flash 消息，并在模板上显示它，我们使用了get _ flash _ messages()函数。
get_flashed_messages(with_categories, category_filter)
这里，
- with_categories: 一个可选的参数元组，用来提及类别(错误/信息/警告)
- category_filter: 可选参数，只过滤和显示特定的消息
一个简单的例子显示了模板文件中的get _ flash _ message():
{% with messages = get_flashed_messages() %}
{% if messages %}
{% for message in messages %}
{{ message }}
{% endfor %}
{% endif %}
{% endwith %}
动手用烧瓶闪光()方法
这里我们将创建一个简单的 Flask 应用程序，如果用户输入正确的密码，它会闪烁–登录成功。
1)编写烧瓶应用程序文件
这里我们将展示一个接受密码的简单表单。如果密码正确，则闪烁消息。
from flask import Flask,render_template,request,redirect,flash
app = Flask(__name__)
@app.route('/form')
def form():
return render_template('form.html')
@app.route('/login', methods = ['POST', 'GET'])
def login():
if request.method == 'GET':
return "Login via the login Form"
if request.method == 'POST':
password = request.form['password']
if password == '123':
#The following flash message will be displayed on successful login
flash('Login successful')
return render_template('success.html')
else:
return redirect('/form')
app.run(host='localhost', port=5000)
这里的success.html是“下一个”模板，因为消息将出现在那里。
就是这样！！让我们现在编码模板
2)对模板进行编码
form.html 将是:
<form action="/login" method = "POST">
<p>password <input type = "text" name = "password" /></p>
<p><input type = "submit" value = "Submit" /></p>
</form>
和 Success.html 模板文件:
{% with messages = get_flashed_messages() %}
{% if messages %}
{% for message in messages %}
{{ message }}
{% endfor %}
{% endif %}
{% endwith %}
<h2>User Authenticated</h2>
注意我们在这里是如何使用get _ flash _ messages()的。
3)实施
就是这样！！让我们现在启动服务器并检查我们的网页
点击"/表格":
Form
输入 1234 并点击提交
Login
这就是我们的 Flash 信息，就在屏幕上。
结论
本教程到此为止，各位！！我希望您获得了足够的知识，可以在您的 web 应用程序中使用 Flash 方法。一定要看看我们的 Flask Forms 文章，以了解更多关于表单的信息
下一篇文章再见！！编码快乐！！
烧瓶表单–使用烧瓶表单接受用户输入
原文：https://www.askpython.com/python-modules/flask/flask-forms
嘿伙计们！！在本教程中，我们将研究烧瓶的形式，以及如何创建它们。所以让我们现在就开始吧！
瓶型基础
表单是 web 应用程序的重要组成部分，从用户认证界面到我们网站上需要的调查表单。
表格的一个典型例子是:
Form Example
这里，当用户第一次请求页面时——他通过我们称之为" GET 方法接收页面
填写表单后，用户数据通过 POST 方法发送到服务器。
我们稍后将了解这两种方法的更多信息。
这些表单通过使用 HTML 的 <表单> 属性的模板显示给用户。
示例 HTML 表单如下所示:
<form action="action_to_perform_after_submission" method = "POST">
<p>Field1 <input type = "text" name = "Field1_name" /></p>
<p>Field2 <input type = "text" name = "Field2_name" /></p>
<p>Field3 <input type = "text" name = "Field3_name" /></p>
<p><input type = "submit" value = "submit" /></p>
</form>
这里我们在动作属性中定义了对表单数据执行的动作。
获取或发布发送数据的方法
这些方法中的每一种也称为 HTTP 方法，对服务器资源执行特定的操作。每种方法对应不同的任务。在本文中，我们将研究其中的两种方法，GET 和 POST 方法。
- GET–这个方法从 web 服务器获取特定的信息(只是为了查看)
- POST–该方法将数据从用户发送到服务器。
因此，例如，考虑 Instagram 应用程序。
默认情况下，浏览器总是使用 GET 方法在网页上显示资源。因此，在这里你可以看到不同的内容——帖子和迷因(通过 GET 方法)。
但是当你发布一张照片时，基本上你是把信息(照片和标题)发送到 Instagram 应用服务器。因此，这个动作(向服务器发送数据)是通过 POST 方法完成的。
同样，考虑一个博客网站。当你在网站上读博客的时候，是通过 GET 的方法。当你写和发表你的博客时，是通过发布的方法。
建造你的第一个烧瓶模型
我们现在将在 flask 应用程序中创建一个简单的表单
1.编码烧瓶文件
考虑以下代码:
from flask import Flask,render_template,request
app = Flask(__name__)
@app.route('/form')
def form():
return render_template('form.html')
@app.route('/data/', methods = ['POST', 'GET'])
def data():
if request.method == 'GET':
return f"The URL /data is accessed directly. Try going to '/form' to submit form"
if request.method == 'POST':
form_data = request.form
return render_template('data.html',form_data = form_data)
app.run(host='localhost', port=5000)
这里，
- 表单视图向用户显示 HTML 表单模板
- 当用户提交表单时，表单数据(作为请求对象的一部分)通过 POST 方法发送到数据视图。
- 然后数据视图将表单数据元素重新创建到变量 form_data 中，并将其发送到【data.html】模板中进行显示。
request.form 有一个字典结构:
form_data = {
'key1(field1_name)' : 'value1(field1_value)',
'key2(field2_name)' : 'value2(field2_value)',
.
.
}
在这里，一旦表单被提交，浏览器被重定向到数据功能网页。
注:当我们通过表单被定向到/数据时，我们基本上是通过 POST 方法访问数据网页。
2。模板文件
这里的表单模板——form.html将会是:
<form action="/data" method = "POST">
<p>Name <input type = "text" name = "Name" /></p>
<p>City <input type = "text" name = "City" /></p>
<p>Country <input type = "text" name = "Country" /></p>
<p><input type = "submit" value = "Submit" /></p>
</form>
data.html将显示表格数据:
{% for key,value in form_data.items() %}
<h2> {{key}}</h2>
<p> {{value}}</p>
{% endfor %}
请查看我们的烧瓶模板文章，了解更多关于模板的信息。
3。代码的实现
现在运行服务器并检查
/form
点击提交并查看
/data (POST)
此外，当您试图直接从浏览器点击 URL“/data”时，您将通过 GET 方法获得该网页，该方法将显示一个错误，因为没有表单数据。
/data (GET)
结论
就这样，伙计们！！这都是关于烧瓶中的形式。我们将在接下来的文章中了解更多关于这种烧瓶的话题！！
在那之前，快乐编码🙂
Flask MySQL–设置 Flask 和 MySQL 数据库连接
原文：https://www.askpython.com/python-modules/flask/flask-mysql-database
在本文中，我们将学习如何建立一个 Flask MySQL 数据库连接。所以让我们开始吧！！
结构化查询语言
SQL 允许我们访问和操作数据库。在 SQL 中，我们可以执行各种任务，例如:
- 向数据库添加记录
- 创建表格
- 执行 CRUD(创建、读取、更新、删除)操作
SQL 是数据库系统使用的查询语言。为了建立数据库，我们需要像 MySQL，PostgreSQL 等 RDMS 。
一定要在 JournalDev 网站上查看我们的SQL 教程，以获得更多关于查询语言的知识。
关于 MySQL 数据库表的更多信息
现在让我们看一个典型的 MySQL 数据库表:
| 身份 | 名字 | 城市 | 国家 |
|---|---|---|---|
| one | 插口 | 在那里 | 美利坚合众国 |
| Two | 金姆（人名） | 加利福尼亚 | 美利坚合众国 |
| three | 瑞奇 | 芝加哥 | 美利坚合众国 |
| four | 南森(男子名) | 慕尼黑 | 德国 |
| five | 约拿单 | 巴伐利亚州 | 德国 |
| six | 麦莉（女子名） | 西雅图 | 美利坚合众国 |
DB Table
行被称为记录，列被称为字段。
因此，在上表中，我们有六个记录和四个字段。为了与表格元素进行交互，我们使用 SQL 语句。
一些 SQL 语句是:
- SELECT FROM-该语句从一个表中选择 s 个字段(全部或几个)。
- 其中–该条件语句通常与其他语句一起使用。利用这一点，我们可以选择满足某些给定条件的特定记录。
- UPDATE–该语句更新一个表格
- 编辑–该语句编辑一个/多个记录的字段
- DELETE–该语句删除一条/多条记录
为我们的应用程序设置 MySQL 服务器
在本节中，我们将下载并建立我们的 MySQL 服务器
1.在服务器上安装 XAMPP
现在要使用 MySQL，我们需要一个软件工具来处理 MySQL 的网络管理。
在本教程中，我们将使用 phpMyAdmin 。如果你熟悉其他软件；你也可以用这个。
Xampp 软件提供了 PHPMyAdmin web 接口。你可以从这里下载 XAMPP 。
或者直接去 Google 搜索下载 Xampp。第一个环节本身就可以完成工作！！
下载适合您的操作系统和体系结构的正确版本。
Xampp
2.启动 Apache 和 MySQL
安装并加载 XAMPP 后，启动以下两个过程:
- Apache web 服务器–服务 HTTP 请求
- MySQL 服务器–用于数据库
Xampp
请注意 MySQL 的默认端口是 3306。现在在浏览器中，转到 https://localhost 。
Xampp Host Webpage
这是 Xampp 的主机网页。点击右上角的 phpMyAdmin，进入 php web 界面。
Phpmyadmin
这里，
- 点击左栏中的 new 创建一个新的数据库。
- 为数据库保留一个合适的名称。在我的情况下，它只是简单的瓶
Flask DB
继续在数据库中创建一个表。在如图所示的空白处输入表格名称，并点击 Go。
3.在我们的系统中安装 Flask- MySQL 库
Flask 使用 flask_mysqldb 连接器来使用 MySQL。运行以下命令来安装该软件包:
pip install flask_mysqldb
完美！！
设置 Flask MySQL 数据库连接
现在，我们将连接并使用 MySQL 将数据存储到我们的数据库中。如果你不确定如何创建一个 flask 应用程序，查看一下 flask 介绍教程。
1.用 MySQL 连接 Flask 应用程序
我们连接 Flask-MySQL 的步骤如下:
from flask import Flask,render_template, request
from flask_mysqldb import MySQL
app = Flask(__name__)
app.config['MYSQL_HOST'] = 'localhost'
app.config['MYSQL_USER'] = 'root'
app.config['MYSQL_PASSWORD'] = ''
app.config['MYSQL_DB'] = 'flask'
mysql = MySQL(app)
2.设置 MySQL 连接光标
仅仅通过上面的设置，我们无法与 DB 表进行交互。为此，我们需要一个叫做光标的东西。
所以 Cursor 为 Flask 提供了一种与 DB 表交互的方式。它可以扫描数据库数据，执行不同的 SQL 查询，以及删除表记录。
光标的使用方式如下:
mysql = MySQL(app)
#Creating a connection cursor
cursor = mysql.connection.cursor()
#Executing SQL Statements
cursor.execute(''' CREATE TABLE table_name(field1, field2...) ''')
cursor.execute(''' INSERT INTO table_name VALUES(v1,v2...) ''')
cursor.execute(''' DELETE FROM table_name WHERE condition ''')
#Saving the Actions performed on the DB
mysql.connection.commit()
#Closing the cursor
cursor.close()
由于 MySQL 不是一个自动提交的数据库，我们需要手动提交，即保存由数据库上的光标执行所执行的更改/动作。
3.编写烧瓶应用程序
现在我们将构建一个小 Flask 应用程序，它将用户提交的数据存储在 MySQL DB 表中。考虑以下应用程序代码:
from flask import Flask,render_template, request
from flask_mysqldb import MySQL
app = Flask(__name__)
app.config['MYSQL_HOST'] = 'localhost'
app.config['MYSQL_USER'] = 'root'
app.config['MYSQL_PASSWORD'] = ''
app.config['MYSQL_DB'] = 'flask'
mysql = MySQL(app)
@app.route('/form')
def form():
return render_template('form.html')
@app.route('/login', methods = ['POST', 'GET'])
def login():
if request.method == 'GET':
return "Login via the login Form"
if request.method == 'POST':
name = request.form['name']
age = request.form['age']
cursor = mysql.connection.cursor()
cursor.execute(''' INSERT INTO info_table VALUES(%s,%s)''',(name,age))
mysql.connection.commit()
cursor.close()
return f"Done!!"
app.run(host='localhost', port=5000)
当用户提交数据时，通过光标将数据添加到 MySQL 数据库中。我的表名是 info_table 。
form.html将是:
<form action="/login" method = "POST">
<p>name <input type = "text" name = "name" /></p>
<p>age <input type = "integer" name = "age" /></p>
<p><input type = "submit" value = "Submit" /></p>
</form>
4.实施准则
现在启动服务器，进入“/表格”(见烧瓶表格 )
Form
输入详细信息并点击提交
Success
现在让我们在 phpMyAdmin web 界面中检查一下
Php
完美！！
结论
就这样，伙计们！！这都是关于建立 Flask MySQL 连接。在下一篇文章中，我们将研究 Flask-PostgreSQL。
下次再见🙂
flask PostgreSQL–SQLAlchemy
原文：https://www.askpython.com/python-modules/flask/flask-postgresql
在本文中，我们将学习使用 ORM–对象关系映射器(称为 Flask SQLAlchemy)将 Flask 应用程序与 PostgreSQL 数据库系统连接起来。
PostgreSQL 是什么？
类似于 MySQL 数据库管理系统，PostgreSQL 是另一种类型的 RDBMS，用于访问、存储和处理数据库表形式的数据。
PostgreSQL 还使用 SQL 结构化查询语言来访问和处理数据库，并在 PostgreSQL 中执行各种任务
PostgreSQL 的基本结构
数据以表的形式存储在 Postgres DB 中。典型的 Postgres 表如下所示:
| 身份 | 名字 | 班级 | 级别 |
|---|---|---|---|
| one | 艾丽娅 | 离子交换 | B |
| Two | 言语唐突的 | X | A |
| three | 光线 | 八 | D |
| four | 金姆（人名） | 我们吗 | A |
| five | 詹尼弗 | 罗马数字 12 | B |
| six | 杜松子酒的 | X | A |
PostgreSQL Table
行被称为记录，列被称为字段。因此，在上表中，我们有 6 个记录和 4 个字段。
【MySQL 和 Postgre 的区别 SQL
虽然 MySQL 和 PostgreSQL 都属于 RDBMS，但是两者之间有一些关键的区别。
- MySQL 和 PostgreSQL 的一个基本区别是，PostgreSQL 是一个 ORDBMS(对象关系数据库管理系统)，而 MySQL 是一个社区驱动的 RDBMS。
- PostgreSQL 相对于 MySQL 的另一个优势是它可以支持现代应用程序特性，如 JSON、XML 等。而 MySQL 只能支持 JSON。
为什么 SQLAlchemy 要将 PostgreSQL 连接到 Flask 应用程序？
SQLAlchemy 是一个用 Python 写的 ORM-Objects 关系映射器。它提供了不使用 SQL 语句与数据库交互的机会。
它在 SQL 之上提供了一个额外的层，允许我们像 Python 类对象一样使用数据库和表。我们只需要创建一个类对象，SQLAlchemy 会处理剩下的事情！
在 Flask 中，不像 Django 以 Django 模型的形式提供了一个预构建的 orm，它没有预构建的 ORM。
因此，我们需要安装 Flask-SQLAlchemy ORM 库来使用这个 web 框架中的模型
在系统中设置 PostgreSQL
在本节中，我们将下载并设置 Flask- SQLAlchemy-Postgres 项目所需的所有包。
1.安装 PostgreSQL shell
要安装 PostgreSQL，请访问此处的链接 。安装 PostgreSQL 后，打开 SQL shell 并设置您的数据库连接用户名和密码。
运行以下命令在终端中打开 shell:
sudo su postgres pqsl
如果是 Windows，直接在搜索菜单中搜索 SQL shell 。
我保留了我的连接详细信息默认值(括号中显示的)。
- 服务器:本地主机
- 数据库: postgres
- 端口: 5433
- 用户名: postgres
输入密码后，默认情况下会提示您进入 PostgreSQL 数据库。
现在让我们创建一个名为 Flask 的新 DB 来存储我们的数据。
CREATE DATABASE <db_name>;
这里我们只使用 SQL 语法。一定要在 JournalDev 网站上查看我们的 SQL 教程，以获得更多关于查询语言的知识。
要将当前数据库更改为 Flask 数据库，请使用以下命令:
\c <db_name>;
就这样，现在你在新的 Flask DB 中。
Postgres
2.安装 psycopg2 适配器工具
我们还需要 pyscopg2，，这是 Python 的 PostgreSQL 数据库适配器。让我们运行 pip 命令:
pip install psycopg2-binary
3.为烧瓶安装 ORM 包
首先我们需要安装 Flask-SQLAlchemy ORM。
要安装该软件包，只需运行以下代码:
pip install flask-sqlalchemy
我们还需要安装烧瓶-迁移。
Flask-Migrate ，使用 Alembic 这是一个轻量级的数据库迁移工具。它帮助我们创建/更新数据库和表格。它还允许我们在您删除或创建新的表字段时更新现有的表。
要安装 Flask-Migrate，请运行:
pip install Flask-Migrate
那是我们需要的！！现在让我们把手弄脏吧！！
用 SQLAlchemy 在 Flask 中实现 PostgreSQL 数据库连接
在本节中，我们将创建一个简单的 Flask 应用程序，它将用户信息存储在数据库中。
1.创建烧瓶模型
模型是一个 Python 类，表示数据库中的一个表。它包含关于表结构的信息。
在 Flask 中，更系统的做法是将所有的数据库信息和模型保存在一个名为–models . py的单独文件中，该文件就在我们的主应用程序文件旁边。
典型的 models.py 文件如下所示:
from flask_sqlalchemy import SQLAlchemy
db = SQLAlchemy()
class Model_name(db.Model):
__tablename__ = 'table_name'
field1_name = db.Column(db.Field1Type, primary_key...)
field2_name = db.Column(db.Field2Type)
field3_name = db.Column(db.Field3Type)
def __init__(self, Field1_name,Field1_name,Field1_name):
self.field1_name = field1_name
self.field2_name = field2_name
self.field3_name = field3_name
def __repr__(self):
return f"<statement>"
这类似于一个经典的 Python 类。这些指示表的字段及其表示。
因此，让我们构建一个小的 InfoModel 表来存储用户信息:
models.py :
from flask_sqlalchemy import SQLAlchemy
db = SQLAlchemy()
class InfoModel(db.Model):
__tablename__ = 'info_table'
id = db.Column(db.Integer, primary_key = True)
name = db.Column(db.String())
age = db.Column(db.Integer())
def __init__(self, name,age):
self.name = name
self.age = age
def __repr__(self):
return f"{self.name}:{self.age}"
2.编写我们的主要烧瓶应用程序
现在我们将连接 Postgres 和我们的 Flask 应用程序。语法是:
from flask_sqlalchemy import SQLAlchemy
from flask_migrate import Migrate
from models import db, InfoModel
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = "postgresql://<username>:<password>@<server>:5432/<db_name>"
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db.init_app(app)
migrate = Migrate(app, db)
#general Flask Code
@app.route('')
# Your code
if __name__ == '__main__':
app.run(debug=True)
这里，
- 我们创建一个烧瓶对象—app
- 然后配置 PostgreSQL 连接
- 为了简单起见，我将 SQL_TRACK_MODIFICATIONS 保持为 False。
- 然后将 app 对象传递给 SQLAlchemy 对象 db
- 为迁移创建迁移对象。
就是这样！
另外，在 app.py 文件中添加以下视图。
apps.py:
from flask import Flask,render_template,request
from flask_migrate import Migrate
from models import db, InfoModel
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = "postgresql://postgres:[email protected]:5432/flask"
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db.init_app(app)
migrate = Migrate(app, db)
@app.route('/form')
def form():
return render_template('form.html')
@app.route('/login', methods = ['POST', 'GET'])
def login():
if request.method == 'GET':
return "Login via the login Form"
if request.method == 'POST':
name = request.form['name']
age = request.form['age']
new_user = InfoModel(name=name, age=age)
db.session.add(new_user)
db.session.commit()
return f"Done!!"
if __name__ == '__main__':
app.run(debug=True)
我们可以像类对象一样与表格交互。我们使用:
- db.session.add() 添加新数据
- db.session.comit() 保存更改
3.实现 Flask 代码
剩下的最后一件事就是运行迁移。因此运行命令:
python db init
python db migrate
python db upgrade
就是这样，
现在运行服务器
python app.py
让我们检查一下浏览器。转到“/表格
Form
点击提交
Success \
现在，在我们的 PostgreSQL shell 中，键入:
SELECT * FROM info_table
数据就在那里！！
PostgreSQL
完美！
结论
就这样，伙计们！！这都是关于设置 Flask PostgreSQL 和 SQLAlchemy 连接的。下次再见！！到那时，快乐的编码！！
Flask 重定向–使用 Python Flask 设置 URL 重定向
原文：https://www.askpython.com/python-modules/flask/flask-redirect-url
在本教程中，我们将学习 flask 重定向以及如何在我们的应用程序中使用它。
为什么我们需要设置重定向？
在开始实现之前，让我们首先知道重定向实际上是什么！
所以顾名思义， redirect 函数在被调用时，基本上是将网页重定向到另一个 URL。
它是 web 应用程序的重要组成部分，也提高了应用程序的效率。
- 举个 Twitter 的例子；如果你还没有登录，那么当你点击 Twitter 网址 (www.twitter.com)时，你会首先被重定向到登录页面。这里重定向功能发挥了作用。
- 同样，在网上交易中，一旦付款，你会被重定向到确认页面。
- 重定向的另一个好处是它有助于缩短 URL 例如， https://bit.ly 。在这里你输入一个短网址，然后被重定向到原来的长网址。
现在我们知道了为什么使用它，让我们进入动手部分。
实施烧瓶重定向
现在，我们将使用 Flask 重定向函数编写一个小应用程序。但是首先，我们将看到重定向函数的语法。
1。Flask 重定向属性的语法
重定向的语法:
redirect(location, code, response = None)
其中:
- 位置:最终网页的目标位置
- 状态码:这些是 HTTP 重定向状态码，表示动作的输出。默认为 302
- 响应:启动响应时使用的响应类别。
我们现在不需要太在意最后一个。其他一些状态代码包括:
| 状态代码 | HTTP 含义 |
|---|---|
| 300 | 多选 |
| 301 | 永久移动 |
| 302 | 找到 |
| 303 | 查看其他 |
| 304 | 未修改 |
| 305 | 使用代理 |
| 306 | 内向的; 寡言少语的; 矜持的 |
| 307 | 临时重定向 |
注意:在使用之前我们首先需要导入重定向属性。
from flask import redirect
2.重定向的错误处理
Flask 还有一个针对特殊重定向失败情况的 abort() 函数。
abort() 函数的语法:
abort(<error_code>)
各种错误代码如下:
| 错误代码 | 意义 |
|---|---|
| 400 | 错误的请求 |
| 401 | 未经证实的 |
| 403 | 被禁止的 |
| 404 | 未发现 |
| 406 | 不可接受 |
| 415 | 不支持的媒体类型 |
| 429 | 太多请求 |
Error Codes
注意:我们也需要首先导入这个属性。
from flask import abort
3.我们应用程序的代码
现在考虑下面的示例代码:
from flask import Flask,render_template,request,redirect
app = Flask(__name__)
@app.route('/form')
def form():
return render_template('form.html')
@app.route('/verify', methods = ['POST', 'GET'])
def verify():
if request.method == 'POST':
name = request.form['name']
return redirect(f"/user/{name}")
@app.route('/user/<name>')
def user(name):
return f"Your name is {name}"
app.run(host='localhost', port=5000)
这里:
- 表单视图只是向用户显示表单模板。
- 当用户提交表单时，表单数据和请求一起被发送到验证视图。(看 form.html-动作属性
- ****验证视图，从表单中取出姓名数据，然后将用户重定向到用户视图(以及姓名数据)。
如果你在理解语法上有任何困难，一定要看看我们的 对 Flask 文章 的介绍。
****form.html是:
<form action="/verify" method = "POST">
<p>name <input type = "text" name = "name" /></p>
<p><input type = "submit" value = "Submit" /></p>
</form>
我们使用一个 Flask 表单从用户那里获取输入，然后将它重定向到一个显示回名称的网页。
在这里，顺序是:
- ****表单功能显示表单。
- 一旦用户提交了他的名字，验证函数从表单中取出这个名字，并将他重定向到用户函数。
- ****用户函数将名称作为参数，并显示在网页上。
4。代码的实现
现在运行服务器并检查它
**
Form**
点击提交
**
Redirect**
就这样伙计们！！名字出现在那里。
结论
这就是本教程的伙计们！！试着找出如何在你的代码中包含中止功能作为练习。
我们将在下一篇文章中看到你们！！在那之前，快乐编码🙂
