PythonGuides-博客中文翻译-二-
PythonGuides 博客中文翻译（二）
如何在 Python 中将 DateTime 转换成 UNIX 时间戳
原文：https://pythonguides.com/convert-datetime-to-unix-timestamp-in-python/
在这个 Python 教程中，我们将学习如何在 Python ( Python 日期时间到 UNIX 时间戳)、中转换日期时间到 UNIX 时间戳，我们还将涉及以下主题:
- 什么是 Unix 时间戳？
- 将日期时间转换为 Unix 时间戳 python
- Python DateTime 到 Unix 时间戳毫秒
- Python 日期时间到 Unix 时间戳 13 位数
- Python 日期时间到 Unix 时间戳 UTC
- Python 日期时间字符串到 Unix 时间戳
- Python datetime.now 到 Unix 时间戳
- Python datetime.date 到 Unix 时间戳
- Python 日期时间到 Unix 时间戳秒数
- Python 日期时间到 Unix 时间戳时区
- Python Unix 时间戳到日期时间
- 格式化 Unix 时间戳 python
目录
- 什么是 Unix 时间戳？
- 将日期时间转换为 Unix 时间戳 python
- Python 日期时间到 Unix 时间戳毫秒
- Python 日期时间到 Unix 时间戳 13 位数
- Python 日期时间到 Unix 时间戳 UTC
- Python 日期时间字符串到 Unix 时间戳
- Python datetime.now 到 Unix 时间戳
- Python datetime.date 到 unix 时间戳
- Python 日期时间到 Unix 时间戳秒数
- Python 日期时间到 Unix 时间戳时区
- Python Unix 时间戳到日期时间
- 格式化 Unix 时间戳 python
什么是 Unix 时间戳？
- Unix 时间是一个每秒增加的单个有符号数字，它使计算机能够存储和操作传统的日期系统。然后，程序被转换成人类可读的格式。
- Unix 时间戳是从 1970 年 1 月 1 日开始计算的秒数。
将日期时间转换为 Unix 时间戳 python
现在，我们可以看到如何在 python 中将 DateTime 转换为 Unix 时间戳。
- 在这个例子中，我导入了一个名为
datetime和time的模块，变量 datetime 被声明并赋值为 datetime.datetime(2020，2，11，10，20) 。 - 这里 2020 是年，2 是月，11 是日，10 是小时，20 是分钟。
datetime模块有许多方法返回关于日期对象的许多信息。mktime是时间的方法，是本地时间的反函数，该方法用于将 datetime转换为 Unix 时间戳。timetuple()是 datetime 类的一个方法，它以名称元组的形式返回 datetime 的属性。
示例:
import datetime
import time
datetime = datetime.datetime(2020, 2, 11, 10, 20)
print("Unix_Time_stamp: ",(time.mktime(datetime.timetuple())))
下面的屏幕截图显示了 unix 时间戳作为输出:
Convert DateTime to Unix timestamp python
你可能也喜欢用例子连接列表。
Python 日期时间到 Unix 时间戳毫秒
在这里，我们可以看到如何在 python 中将 DateTime 转换为 Unix 时间戳毫秒。
- 在这个例子中，我已经导入了一个名为
datetime的模块来获取 Unix 时间戳，单位为毫秒。datetime.now()用于获取当前时间。 mktime是时间的方法，是本地时间的反函数，这个方法是用于将 datetime 转换为 Unix 时间戳毫秒。timetuple()是 datetime 类的一个方法，它以名称元组的形式返回 datetime 的属性。要得到以毫秒为单位的时间，必须乘以 1000。
示例:
import datetime, time
millisecond = datetime.datetime.now()
print(time.mktime(millisecond.timetuple()) * 1000)
我们可以看到以毫秒为单位的 unix 时间戳。您可以参考下面的输出截图:
Python DateTime to Unix timestamp milliseconds
Python 日期时间到 Unix 时间戳 13 位数
现在，我们可以在 python 中看到 DateTime 到 Unix 时间戳的 13 位数。
- 在这个例子中，我导入了像时间和日期时间这样的模块。
datetime.datetime.now()用于获取当前时间。timetuple()是 datetime 类的一个方法，它以名称元组的形式返回 datetime 的属性。要得到 13 位数的时间戳，必须乘以 1000。
示例:
import time
import datetime
date = datetime.datetime.now()
unix_time = datetime.datetime.timestamp(date)*1000
print(unix_time)
下面的屏幕截图显示了由 unix 时间戳中的 13 个数字组成的输出。
Python DateTime to Unix timestamp 13 digits
Python 日期时间到 Unix 时间戳 UTC
在这里，我们可以看到如何在 python 中将 DateTime 转换为 Unix 时间戳 UTC 。
- 在这个例子中，我导入了一个名为日历和日期时间的模块。日历模块提供了与日历相关的有用功能。
utc.now用于获取 utc 时区的当前时间。时间模块中的timegm函数返回 unix 时间戳。timetuple()是 datetime 类的一个方法，它以名称元组的形式返回 datetime 的属性。print(UTC)用于获取 Unix 时间戳。
示例:
import calendar
import datetime
date_time = datetime.datetime.utcnow()
UTC = calendar.timegm(date_time.utctimetuple())
print(UTC)
下面的截图显示了输出。
Python DateTime to Unix timestamp UTC
Python 日期时间字符串到 Unix 时间戳
现在，我们可以在 python 中看到 Unix 时间戳的 DateTime 字符串。
- 在这个例子中，我导入了一个名为
datetime的模块，并将一个变量声明为 date_string。 - 在这里，我指定了 date_string = "2/11/2021，04:5:8" 这里的日期和时间以字符串格式给出。
- 这里 2 是月，11 是日，2021 是年，04 是小时，5 是分钟，8 是秒。
strptime()是 datetime 模块的函数，它用于将字符串解析为 datetime 和 time 对象。timestamp()方法返回当地时间。
示例:
import datetime
date_string = "2/11/2021, 04:5:8"
date = datetime.datetime.strptime(date_string, "%m/%d/%Y, %H:%M:%S")
time_stamp = datetime.datetime.timestamp(date)
print(time_stamp)
下面的屏幕截图显示日期时间字符串形式被转换成 Unix 时间戳作为输出。
Python DateTime string to Unix timestamp
Python datetime.now 到 Unix 时间戳
现在，我们可以看到 python 中的 datetime.now 到 Unix 时间戳。
- 在这个例子中，我导入了一个名为
datetime的模块，并声明了一个变量为time_stamp，并分配了datetime.now()方法来获取 Unix 时间戳中的 now 时间。 timestamp()函数返回以秒数表示的时间。
示例:
from datetime import datetime
time_stamp= datetime.now()
now = datetime.timestamp(time_stamp)
print(now)
下面的截图显示了输出。
Python datetime.now to Unix timestamp
Python datetime.date 到 unix 时间戳
在这里，我们可以看到 python 中的 datetime.date 到 unix 时间戳。
- 在本例中，我导入了一个名为 datetime 和 time 的模块。这里使用了
datetime.date()，我们只能在其中传递日期。 - 这里 2020 是年，2 是月，11 是日。
mktime()是时间的方法，是本地时间的反函数，这个方法是用于将日期转换为 Unix 时间戳。
示例:
import datetime
import time
datetime = datetime.date(2020, 2, 11)
print("Unix_Time_stamp: ",(time.mktime(datetime.timetuple())))
我们可以看到日期被转换成时间戳作为输出。您可以参考下面的输出截图:
Python datetime.date to unix timestamp
Python 日期时间到 Unix 时间戳秒数
现在，让我们看看 python 中的 DateTime 到 Unix 时间戳秒。
- 在这个例子中，我导入了名为的 datetime ，为了计算 Unix 时间戳秒数，我们必须从 Unix 时间戳中用减去所需的日期，即 1970，1，1 。
- 这里 2020 是年，2 是月，11 是日。
- 总秒数由
total_seconds()返回。 - 为了获得输出，我使用了 print(seconds)
示例:
import datetime
seconds = (datetime.datetime(2020,2,11) - datetime.datetime(1970, 1, 1)).total_seconds()
print(seconds)
下面的屏幕截图显示了输出
Python DateTime to Unix timestamp seconds
Python 日期时间到 Unix 时间戳时区
在这里，我们可以看到 python 中的 Datetime 到 unix 时间戳时区。
- 在这个例子中，我导入了名为
datetime和timezone的模块，并将一个变量声明为 timestring，并为 datetime 指定了 timezone。 - 将时区为的日期时间转换为 Unix 时间戳。
- 我用过d = datetime . datetime . strptime(timestring，" %Y-%m-%dT%H:%M:%SZ") 。
- 这里 2020 是年，2 是月，25 是日，23 是小时，51 是分钟，03 是秒。
timetuple()是 datetime 类的一个方法，它以名称元组的形式返回 datetime 的属性。
示例:
import datetime
import pytz
import time
timestring = "2020-02-25T23:51:03Z"
d = datetime.datetime.strptime(timestring, "%Y-%m-%dT%H:%M:%SZ")
print("Unix_Time_stamp: ",(time.mktime(d.timetuple())))
我们可以看到 datetime timezone 到 UNIX timestamp 的输出。您可以参考下面的输出截图:
Python Datetime to unix timestamp timezone
Python Unix 时间戳到日期时间
在这里，我们可以看到如何在 python 中将 Unix 时间戳转换为 datetime 。
- 在这个例子中，我导入了类似于
datetime和pytz的模块，并声明了一个变量，并将其赋值为timestamp = 1613327400.0。 - 为了将 Unix 时间戳转换为 datetime，我使用了
datetime = datetime . from timestamp(timestamp)。 - 为了打印日期时间，我使用了 print("Unixdatetime = "，datetime) 。
示例:
from datetime import datetime
import pytz
timestamp = 1613327400.0
datetime = datetime.fromtimestamp(timestamp)
print("Unixdatetime =", datetime)
我们可以看到由 unixtimestamp 转换成 datetime 作为输出。您可以参考下面的输出截图:
Python Unix timestamp to datetime
格式化 Unix 时间戳 python
在这里，我们可以看到 python 中的格式 Unix 时间戳。
unix 时间戳的格式为 10 位数字。
- 在这个例子中，我导入了一个名为
datetime和time的模块，并将一个变量声明为 datetime，并赋值为 datetime = datetime.date(2020，2，15) 。 - 这里 2020 是年份，2 是月份，15 是日子
- 我们可以用 print("Unix_Time_stamp:"，(Time . mktime(datetime . Time tuple()))看到 Unix 时间戳的格式。
示例:
import datetime
import time
datetime = datetime.date(2020, 2, 15)
print("Unix_Time_stamp: ",(time.mktime(datetime.timetuple())))
我们可以看到 unix 时间戳的格式作为输出。下面的屏幕截图显示了输出
Format Unix timestamp python
您可能会喜欢以下 Python 教程:
- Python 捕捉多个异常
- Python 异常处理
- Python Tkinter Map()函数
- Python 将图像保存到文件
- 如何使用 Python Tkinter 创建日期时间选取器
- 如何使用 Python Tkinter 读取文本文件
- 如何进入 Python Tkinter 程序的下一页
在本教程中，我们学习了关于 Python DateTime 到 UNIX 时间戳的知识，并且我们还讨论了以下主题:
- 什么是 Unix 时间戳？
- 将日期时间转换为 Unix 时间戳 python
- Python DateTime 到 Unix 时间戳毫秒
- Python 日期时间到 Unix 时间戳 13 位数
- Python 日期时间到 Unix 时间戳 UTC
- Python 日期时间字符串到 Unix 时间戳
- Python datetime.now 到 Unix 时间戳
- Python datetime.date 到 Unix 时间戳
- Python 日期时间到 Unix 时间戳秒数
- Python 日期时间到 Unix 时间戳时区
- Python Unix 时间戳到日期时间
- 格式化 Unix 时间戳 python
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
如何在 Python 中将字典转换成 JSON
原文：https://pythonguides.com/convert-dictionary-to-json-python/
在这个 Python 教程中，我们将学习如何用 python 将字典转换成 JSON，我们还将涉及以下主题:
- 如何在 Python 中将嵌套字典转换成 JSON
- 如何在 Python 中将字典转换成 JSON 字符串
- 如何用 Python 将字典转换成 JSON 文件
- Python 字典到 JSON 引用
- 在 python 中将字典转换为 JSON 数组
- 将多个字典转换为 JSON python
- 使用 sort_key python 将字典转换为 JSON
你可能喜欢在 Python 和 Python 连接字典中使用 JSON 数据
目录
- 将字典转换成 JSON Python
- 将嵌套字典转换为 JSON python
- 将字典转换成 JSON 字符串 python
- 将字典转换成 JSON 文件 Python
- Python 将字典转换成 JSON 引号
- 转换字典为 JSON 数组 Python
- 将多个字典转换成 JSON Python
- 使用 sort_keys Python 将字典转换为 JSON】
将字典转换成 JSON Python
这里可以看到如何在 python 中将 dictionary 转换成 Json 。
- 在这个例子中，我导入了一个名为
json的模块，并将一个变量声明为一个字典、，并分配了键和值对。 - 另一个变量
details被声明使用json.dumps()将字典存储到 json 中，并使用了indent = 5。缩进是指代码行开头的空格。
示例:
import json
dictionary ={"Name": "Kushi", "Branch": "CS", "CGPA": "9.4"}
details = json.dumps(dictionary, indent = 5)
print(details)
转储的字典可以在输出中看到。您可以参考下面的输出截图。
Convert dictionary to JSON python
这就是如何在 Python 中将 dictionary 转换成 JSON。
将嵌套字典转换为 JSON python
这里可以看到如何在 python 中将嵌套字典转换成 Json 。
- 在这个例子中，我已经导入了一个名为
json的模块，并将一个变量声明为一个字典、，并分配了键和值对。在这里，我拿了两本字典作为水果和蔬菜。 - 另一个变量
details被声明使用json.dumps()将字典存储到 json 中，并使用了indent = 5。缩进是指代码行开头的空格。
示例:
import json
dictionary = {
"fruit":{"Apple": "1","color": "red"},
"vegetable": {"tomato": "4","color": "red"},
}
details = json.dumps(dictionary)
print(details)
输出将以嵌套字典的格式在下面截图显示输出。
Convert nested dictionary to JSON python
将字典转换成 JSON 字符串 python
现在，我们可以如何在 python 中将 dictionary 转换成 JSON 字符串。
- 在这个例子中，我已经导入了一个名为
json的模块，并将一个 Python 字典声明为学生，并且使用json.dumps()来存储字典。indent = 2用于获取代码行中的空格。 - 这里，我使用了两个打印语句，一个没有缩进，一个有缩进。
示例:
import json
student = {"Name": "Kushi","Age": 5,"hobby":"playing"}
print(json.dumps(student))
print(json.dumps(student, indent = 2))
在输出中可以看到两个字符串，一个有缩进，另一个没有缩进。下面的截图显示了输出。
Convert dictionary to json string python
将字典转换成 JSON 文件 Python
在这里，我们可以看到如何用 python 将 转换成 JSON 文件。
- 在这个例子中，我已经导入了一个名为
json的模块，并将一个字典声明为一个学生，并且为了打开 json 文件，我使用了，其中 open('data.json '，' w ')为 f 。 data.json是文件名，使用‘w’模式写入文件。存储文件json.dump()用于存储字典。- 为了首先打开 json 文件，我们必须检查文件的位置，然后我们必须在 visual studio 代码中通过给文件名来打开它。
示例:
import json
student = {"Name": "Kushi","Age": 5,"hobby":"playing"}
with open('data.json', 'w') as f:
json.dump(student, f)
下面的截图显示了在 visual studio 代码中存储在 json 文件中的输出值。
Convert dictionary to JSON file python
这是如何在 Python 中将字典转换成 JSON 文件。
Python 将字典转换成 JSON 引号
在这里，我们可以如何在 python 中将 dictionary 转换成 JSON 引号。
- 在这个例子中，我导入了一个名为 json 的模块。
- 类水果声明定义为
def__str__(self)。 - 用于字符串表示的
__str__(self)方法，声明了一个名为combo的变量，quote变量被赋予类 fruits。 - 通过传递组合参数，我使用了 print(引用)来获得输出。
示例:
import json
class fruits(dict):
def __str__(self):
return json.dumps(self)
combo = [['mango','orange']]
quote = fruits(combo)
print(quote)
我们可以把这个输出看作带双引号的键值对。您可以参考下面的输出截图。
Python dictionary to JSON quotes
这是如何在 Python 中将 dictionary 转换成 JSON 引号。
将字典转换为 JSON 数组 Python
现在，我们可以看到如何在 python 中将 dictionary 转换成 JSON 数组。
- 在这个例子中，我导入了一个名为
json的模块。 - 作为字典的变量和分配的键值对。
- 另一个变量被声明为一个数组，用来检查哪个是键，哪个是值。for 循环用于存储值，而
json.dumps()用于存储字典。
示例:
import json
dictionary = {'kitkat': 3, '5star': 1}
array = [ {'key' : k, 'value' : dictionary[k]} for k in dictionary]
print(json.dumps(array))
在输出中，我们可以清楚地看到哪个是关键，哪个是价值。您可以参考下面的输出截图。
Convert dictionary to JSON array in python
这是如何用 Python 把字典转换成 JSON 数组。
将多个字典转换成 JSON Python
在这里，我们可以看到如何在 python 中将多个字典转换成 json 。
- 在这个例子中，我导入了一个名为 json，的模块，并将一个变量声明为一个字典。
- 然后我们给它分配了多个字典，并使用
json.dumps()来存储字典，以获得我使用过的print(details)的输出。
示例:
import json
dictionary = {"fruit":{"Apple": "1","color": "red"},"vegetable": {"tomato": "4","color": "red"},"chocolate":{"kitkat":"2","color":"red"}}
details = json.dumps(dictionary)
print(details)
下面的截图显示了输出。
Convert multiple dictionary to JSON python
这是如何用 Python 把多个字典转换成 JSON。
使用 sort_keys Python 将字典转换为 JSON】
现在，我们可以看到如何在 python 中使用 sort_keys 将 dictionary 转换成 JSON。
- 在这个例子中，我导入了一个名为 json、的模块，声明了一个名为字典、的变量，并分配了键和值对。
- 为了存储这个值，我使用了
json.dumps和indent = 5。sort_keys = true用于对字典进行排序，如果我们给值False，那么字典将不会被排序。
示例:
import json
dictionary ={"Name": "Kushi", "Branch": "CS", "CGPA": "9.4"}
details = json.dumps(dictionary, indent = 5, sort_keys = True)
print(details)
在下面的截图中，我们可以看到排序后的字典的输出。
Convert dictionary to JSON using sort_keys python
这是如何在 Python 中使用 sort_keys 将 dictionary 转换成 JSON。
您可能会喜欢以下 Python 教程:
- 如何在 Turtle Python 中附加图像
- 检查一个列表是否存在于另一个列表中 Python
- Python 向 CSV 写列表
- Python Tkinter 待办事项列表
- Python Tkinter 窗口大小
- 如何将 Python 数组写入 CSV
- Python 形状的一个数组
- Python 将图像保存到文件
- 如何使用 Python Tkinter 创建日期时间选择器
- Python Pygame 教程
在本教程中，我们学习了如何用 Python 将 dictionary 转换成 JSON，我们也讨论了以下主题:
- 将嵌套字典转换为 JSON python
- 将字典转换为 JSON 字符串 python
- 将字典转换为 JSON 文件 python
- Python 字典到 JSON 引用
- 在 python 中将字典转换为 JSON 数组
- 将多个字典转换为 JSON python
- 使用 sort_key python 将字典转换为 JSON
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
将 float 转换为 int Python +示例
在这个 python 教程中，你将学习如何在 python 中**转换 float 为 int，我们也将检查 :**
- 如何将 float 转换为 int python
- 如何将 float 转换成 int python
- 如何在 python 中将浮点列表转换为 int
- 如何将浮点数转换为整数 python
- Python 将 float 转换为 int ceil
- 在 python 中将浮点数组转换为整数
- 将 float 转换为 int python numpy
- python 中如何将负浮点值转换为 int
- 如何在 python 中将 float 变量转换成 int
目录
- 如何将 float 转换成 int python
- 如何将 float 转换成 int Python
- 如何在 Python 中将 float list 转换成 int
- 如何将浮点数转换成整数 python
- Python 将 float 转换为 int ceil
- 在 python 中把浮点数组转换成 int
- 将 float 转换为 int Python numpy
- python 中如何将负浮点值转换为 int
- 如何在 python 中把 float 变量转换成 int
如何将 float 转换成 int python
让我们看看如何如何将 float 转换成 int python
为了在 python 中将 float 转换成 int，我们将使用内置的 int() 函数。该函数将返回整数部分。
举例:
num = 5.4
num = int(num)
print(num)
你可以参考下面的截图来看看如何将 float 转换成 int python 的输出。
How to convert float to int python
这是如何在 Python 中将 float 转换为 int。
阅读:如何在 Python 中把 string 转换成 float
如何将 float 转换成 int Python
现在，我们将看到如何将 float 转换成 int python
在这个例子中，我们将使用 trunc() 函数。 trunc() 函数返回数字的整数部分。它忽略小数点后的所有内容。
举例:
from math import trunc
print(trunc(14.2))
你可以参考下面的截图来看看如何将 float 转换成 int python 的输出。
How to transform float to int python
上面的 Python 代码我们可以用来在 Python 中将 float 转换成 int。
如何在 Python 中将 float list 转换成 int
在这里，我们将看到如何在 python 中将 float list 转换成 int
为了在 python 中将浮点列表转换为 int，我们将使用内置函数 int ，它将返回一个整数列表。
举例:
num = [12.1, 14.2, 15.8, 17.4]
print([int(num) for num in num])
你可以参考下面的截图来看看如何在 python 中将 float list 转换成 int 的输出。
How to convert float list to int in python
上面的代码，我们可以用 Python 把 float list 转换成 int。
如何将浮点数转换成整数 python
让我们看看如何将 float 转换成整数 python
在本例中，我们将使用内置的 round() 函数，该函数将值向上舍入并返回整数值。
举例:
num = round(8.4598)
print(num)
你可以参考下面的截图来看看如何将 float 转换成整数 python 的输出。
How to convert float to whole number python
上面的代码，我们可以用 Python 中的来转换浮点数为整数。
Python 将 float 转换为 int ceil
让我们看看如何将 float 转换成 int ceil 。
在本例中，我们将使用 ceil() 函数，该函数将向上舍入下一个整数值。
举例:
from math import ceil
print(ceil(15.7))
你可以参考下面的截图来看看python convert float to int ceil的输出。
Python convert float to int ceil
这是如何在 Python 中将 float 转换为 int ceil。
在 python 中把浮点数组转换成 int
现在，我们将看到如何在 python 中将 float 数组转换成 int。
为了在 python 中将浮点数组转换为 int，我们将首先将 numpy 作为 np 导入，然后我们将使用函数 astype() ，它将返回整数。
举例:
import numpy as np
arr = np.array((1.4, 2.6, 3.1, 4.3))
arr = arr.astype(int)
print(arr)
你可以参考下面的截图来看看 python 中将浮点数组转换成 int 的输出。
Convert float array to int in python
上面的代码，我们可以用 python 中的来转换 float 数组为 int。
将 float 转换为 int Python numpy
在这里，我们将看到如何将 float 转换成 int python numpy 。
在这个例子中，我们将将 numpy 作为 np 导入，内置函数 astype() 用于将 float 转换为 int python numpy。
举例:
import numpy as np
arr = np.array([[5.3, 6.5, 7.234], [30.3, 33.543, 35.995]])
arr = arr.astype(int)
print(arr)
你可以参考下面的截图来看看convert float to int python numpy的输出。
Convert float to int python numpy
上面的 Python 代码，我们可以用来将 float 转换成 int Python numpy 。
python 中如何将负浮点值转换为 int
我们来看看如何在 python 中将负的 浮点值转换成 int。
为了在 python 中把负浮点值转换成整数，我们必须使用 T2 函数 int() 。此外，我们必须将 float 变量作为 python 中的 int() 的参数来传递。
举例:
float_val = -12.8;
print(int(float_val));
你可以参考下面的截图，看看如何在 python 中将负浮点值转换成 int 的输出。
How to convert negative float value to int in python
这就是如何在 python 中将负浮点值转换为 int。
如何在 python 中把 float 变量转换成 int
现在，我们将看到如何在 python 中将 float 变量转换成 int。
为了在 python 中将 float 变量转换成 int ，我们将使用 int() 函数。此外，我们必须将 float 变量作为 python 中的 int() 的参数传递，并使用 print() 函数获得输出。
举例:
float_var = 18.8;
print(int(float_var));
你可以参考下面的截图来看看如何在 python 中将 float 变量转换成 int 的输出。
How to convert float variable to int in python
上面的代码，我们可以用 python 把 float 变量转换成 int。
您可能会喜欢以下 Python 教程:
在这篇 Python 教程中，我们学习了如何将 float 转换成 int python 。此外，我们还讨论了以下主题:
- 如何将 float 转换为 int python
- 如何将 float 转换成 int python
- 如何在 python 中将浮点列表转换为 int
- 如何将浮点数转换为整数 python
- Python 将 float 转换为 int ceil
- 在 python 中将浮点数组转换为整数
- 将 float 转换为 int python numpy
- python 中如何将负浮点值转换为 int
- 如何在 python 中将 float 变量转换成 int
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
如何在 Pandas 中将浮点数转换成整数
原文：https://pythonguides.com/convert-floats-to-integer-in-pandas/
在这个 Python 熊猫教程中，将学习如何使用熊猫将浮点数转换成数据帧的整数。此外，我们将涵盖这些主题。
- 如何在 Pandas 中将浮点值转换为整数
- 如何将 nan 中的浮点数转换为整数
- 如何在 Pandas 中将 float 转换为整数而不使用 decimal
- 如何在 Pandas read_csv 中将 float 转换成整数
- 如何在 Pandas 中将一个列从浮点数转换成整数
目录
- 如何将熊猫数据帧中的浮点数转换成整数
- 如何使用 apply()方法将 Pandas 数据帧中的浮点值转换为整数
- 在 Pandas 中把浮点值转换成整数
- 如何将 nan 熊猫中的 float 转换成整数
- 如何在没有小数的熊猫中把 float 转换成整数
- 如何在熊猫 read_csv 中把 float 转换成整数
- 如何在 Pandas 中把一个列从浮点数转换成整数
如何将熊猫数据帧中的浮点数转换成整数
- 在这个程序中，我们将讨论如何在 Pandas DataFrame 中将 float 数据类型转换为整数。
- 在 Python Pandas 中要将浮点值转换成整数，我们可以使用
DataFrame.astype()方法。此方法用于设置 DataFrame 中现有数据列的数据类型。 - 为了完成这个任务，我们还可以使用字典的输入来更改多个列，这个指定的类型允许我们将数据类型从一种类型转换为另一种类型。
语法:
下面是 DataFrame.astype()方法的语法
DataFrame.astype
(
dtype,
copy=True,
errors='raise'
)
- 它由几个参数组成
- dtype: 此参数指定要应用于将整个 dataframe 对象转换为相同类型的数据类型。
- copy: 默认情况下，它接受‘True’值，当 copy=true 时，它返回一个副本。如果 copy=False，那么对值的更改可能不会返回到另一个对象。
- 错误:默认为‘提高’，包括‘提高’和【T6’‘忽略’。如果是‘提高’，那么它将允许一个异常。类似地，如果它被忽略，那么该数据类型就不是一个集合。
举例:
让我们举个例子，检查一下如何在 Pandas DataFrame 中将浮点数转换成整数。
源代码:
import pandas as pd
new_lis = [[1782.3, 224.5, 100.22], [66.2, 118.5, 457.21],
[276.2, 918.2, 645.55], [554.6, 5178.8, 956.86],
[49.7, 22.3, 9762.99], [41.36, 367.4, 900.25],
[37.8, 23.32, 213.90]]
df = pd.DataFrame(new_lis, columns = ['col1', 'col2', 'col3'])
print(df.astype(int))
在上面的程序中，我们首先创建了一个列表‘new _ lis’，然后给它赋值。
现在创建一个 dataframe 对象，并将列名列表作为参数传递。一旦您打印了 'df.astype' ，那么输出将只显示整数值。
下面是以下给定代码的输出
How to convert Floats to integer in Pandas DataFrame
如何使用 apply()方法将 Pandas 数据帧中的浮点值转换为整数
通过使用 Pandas.apply()方法，我们可以很容易地将 Pandas 数据帧中的 float 数据类型转换为 integer 数据类型。
语法:
下面是 DataFrame.apply()方法的语法
DataFrame.apply
(
func,
axis=0,
raw=False,
result_type=None,
args=(),
)
源代码:
import pandas as pd
import numpy as np
new_lis = [[1782.3, 224.5, 100.22], [66.2, 118.5, 457.21],
[276.2, 918.2, 645.55], [554.6, 5178.8, 956.86],
[49.7, 22.3, 9762.99], [41.36, 367.4, 900.25],
[37.8, 23.32, 213.90]]
df = pd.DataFrame(new_lis, columns = ['col1', 'col2', 'col3'])
df['col2'] = df['col2'].apply(np.int64)
df['col1'] = df['col1'].apply(np.int64)
df['col3'] = df['col3'].apply(np.int64)
print(df)
在上面的代码中，我们已经选择了列表中所有可用的列，为了将 float 类型的值转换成 integer 值，我们可以很容易地使用 df。apply()方法。
下面是以下给定代码的实现
How to convert Floats to integer in Pandas DataFrame
在 Pandas 中把浮点值转换成整数
- 这里我们可以看到如何在 Pandas 中将浮点值转换成整数。
- 为了执行这个特定的任务，我们可以应用方法
DataFrame.astype()。此方法将帮助用户将浮点值转换为整数。在 Python 中，该方法用于将 Pandas 数据帧中的对象转换为不同的数据类型，如 integer，并且该函数还将 DataFrame 对象的数据类型更改为特定的数据类型。
源代码:
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.rand(3,4), columns=list("Lmno"))
print(df)
df[list("Lmno")] = df[list("Lmno")].astype(int)
print("After updating Datafarme",df)
在上面的程序中，我们导入了 pandas 和 numpy 库，然后创建了一个 dataframe 对象‘df’，其中我们使用了 random()函数来创建浮点值。与此同时，我们分配了 df。astype() 将浮点值转换为整数值的方法。
下面是以下代码的截图
Convert float value to an integer in Pandas
如何将 nan 熊猫中的 float 转换成整数
- 让我们看看如何在 Pandas DataFrame 中用整数转换浮点 nan 值。
- 通过使用
Dataframe.astype()方法我们可以解决这个问题。在本例中，我们创建了一个熊猫系列，并为其分配 nan 和 floating 值。现在声明一个变量‘结果’，并使用df.astype()函数将浮点 nan 值转换为整数。
源代码:
import pandas as pd
import numpy as np
new_val = pd.Series([78.0, 49.0, np.nan, 26.0,np.nan,72.0])
result = new_val.astype('Int32')
print(result)
下面是以下给定代码的执行过程
How to convert float to an integer in Pandas with nan
正如您在截图中看到的，输出将只显示一个整数值
阅读如何用 Python 将 Pandas 数据帧转换成 NumPy 数组
如何在没有小数的熊猫中把 float 转换成整数
- 在这个程序中，我们将讨论如何将 Pandas dataframe 中的浮点值转换成不带小数的整数。
- 在本例中，我们首先创建了一个数据帧，并为其分配了一个字符串值。现在我们想把这些字符串转换成浮点数。为此，我们使用了
df.astype(float)方法来获取整数。 - 现在使用 df.astype(float)。sum 方法用于设置 DataFrame 中现有数据列的数据类型。
举例:
import pandas as pd
import numpy as np
df = pd.DataFrame([
['9', '3', '897'],
['28', '67', '91'],
['67', '567', '43']
])
df.astype(float).sum().astype(str)
pd.options.display.float_format = '{:,.0f}'.format
df.astype(float).sum()
print (df)
下面是以下给定代码的执行过程
How to convert float to an integer in Pandas without decimal
如何在熊猫 read_csv 中把 float 转换成整数
- 在这里，我们可以看到如何使用 read_csv 模式将 Pandas 数据帧中的 float 转换为 integer。
- 在这个例子中，我们首先创建了一个 CSV 文件，并在其中分配了一个浮点值。现在使用
df.astype()方法将浮点值转换为整数。
源代码:
import pandas as pd
import numpy as np
df = pd.read_csv('test1.csv')
result = df.astype(int)
print(result)
在上面的程序中，我们导入了 Python 库，然后创建了一个变量‘df’，在这个变量中，我们读取了 CSV 文件，文件名称中的分隔符是逗号。
您可以创建您的 CSV 文件，并将浮点值放入其中。之后应用 df.astype() 方法来解决这个问题。
这是 CSV 文件的截图
How to convert float to an integer in Pandas read_csv
实施:
How to convert float to an integer in Pandas read_csv
如何在 Pandas 中把一个列从浮点数转换成整数
- 在这个程序中，我们将讨论如何在 Pandas DataFrame 中将一个列从 float 转换为 Integer 值。
- 通过使用
Pandas.apply()方法，我们可以允许用户传递一个方法并将其应用于 Pandas 数据帧的值。
语法:
下面是熊猫的句法。apply()方法
DataFrame.apply
(
func,
axis=0,
raw=False,
result_type=None,
args=(),
)
源代码:
import pandas as pd
import numpy as np
new_lis = [[6732.3, 224.5, 100.22], [66.2, 118.5, 457.21],
[3489.2, 918.2, 645.55], [554.6, 5178.8, 956.86],
[883.7, 22.3, 9762.99], [41.36, 367.4, 900.25],
[189.8, 23.32, 213.90]]
df = pd.DataFrame(new_lis, columns = ['val1', 'val2', 'val3'])
df['val2'] = df['val2'].apply(np.int64)
df['val1'] = df['val1'].apply(np.int64)
df['val3'] = df['val3'].apply(np.int64)
print(df)
在上面的代码中，我们已经选择了列表中所有可用的列，为了将 float 类型的值转换成 integer 值，我们可以很容易地使用 df。apply()方法。一旦您将打印‘df’，那么输出将显示所有列的值。
你可以参考下面的截图
How to convert a column from float to an integer in Pandas
您可能会喜欢以下 Python 熊猫教程:
在这个 Python Pandas 教程中，将学习如何使用 Pandas 将浮点数转换成数据帧的整数。此外，我们将涵盖这些主题。
- 如何在 Pandas 中将浮点值转换为整数
- 如何将 nan 中的浮点数转换为整数
- 如何在 Pandas 中将 float 转换为整数而不使用 decimal
- 如何在 Pandas read_csv 中将 float 转换成整数
- 如何在 Pandas 中将一个列从浮点数转换成整数
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
在 Python + PDF 发票中使用 Django 将 HTML 页面转换为 PDF
原文：https://pythonguides.com/convert-html-page-to-pdf-using-django/
当您需要使用 Django 将 HTML 文档转换成 Python 中的 PDF 文件时，您可能会遇到各种场景。在 Django 中，您可以通过使用我们将在本文中讨论的一些库来实现这个特性。
在本文中，您将学习使用 Django 将 HTML 页面转换成 PDF。你会看到一些例子，这样你就能更好地理解这个概念。
- 如何将 HTML 转换成 PDF Django
- Django HTML 到 PDF 示例
- 用 CSS 将 Django HTML 转换成 PDF
- 在 Django 中动态转换 HTML 为 PDF
- Django 生成 PDF 发票
目录
- 如何将 HTML 转换成 PDF Django
- Django HTML 到 PDF 示例
- 用 CSS 将 Django HTML 转换成 PDF
- 在 Django 中动态转换 HTML 为 PDF
- Django 生成 PDF 发票
如何将 HTML 转换成 PDF Django
您可以使用 Django 中的 xhtml2pdf 库将 html 文档转换为 pdf 文件。让我们看看如何使用这个库。
首先，您需要使用如下所示的 pip 命令安装 xhtml2pdf 库:
pip install xhtml2pdf
安装后，您可以使用这个库将 HTML 文档转换成 Python 中的 PDF 文件。让我们借助一个例子来讨论进一步的步骤。
Django HTML 到 PDF 示例
首先，您必须在您的 Django 应用程序中创建一个新的 python 文件。假设我们创建了一个名为 process.py 的
在这个文件中，您将导入 xhtml2pdf 库，并创建一个将 html 文档转换为 pdf 文件的函数。
# importing the necessary libraries
from io import BytesIO
from django.http import HttpResponse
from django.template.loader import get_template
from xhtml2pdf import pisa
# defining the function to convert an HTML file to a PDF file
def html_to_pdf(template_src, context_dict={}):
template = get_template(template_src)
html = template.render(context_dict)
result = BytesIO()
pdf = pisa.pisaDocument(BytesIO(html.encode("ISO-8859-1")), result)
if not pdf.err:
return HttpResponse(result.getvalue(), content_type='application/pdf')
return None
现在我们将把这个 process.py 文件导入到我们的 views.py 文件中。在 views.py 文件中，我们将创建一个基于类的视图。在视图类中，我们将定义一个函数，该函数将调用 process.py 文件中的函数。
在 views.py 文件中，我们还将指定要转换为 PDF 文件的 HTML 模板。views.py 文件将如下所示:
# importing the necessary libraries
from django.http import HttpResponse
from django.views.generic import View
from .process import html_to_pdf
#Creating a class based view
class GeneratePdf(View):
def get(self, request, *args, **kwargs):
# getting the template
pdf = html_to_pdf('result.html')
# rendering the template
return HttpResponse(pdf, content_type='application/pdf')
出于演示的目的，我创建了一个样本 HTML 模板，它将被转换成 PDF 文件。HTML 模板是:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Welcome to Python Guides</title>
</head>
<body>
<h2>This is a Sample HTML Content which is converted into a PDF file</h2><br>
<p>Hope you have understood how to convert an HTML document into a PDF file</p>
<p>You can also generate dynamic contenet using this technique.</p>
</body>
</html>
最后一步是在 url.py 文件中定义您想要查看 PDF 文件的 URL 端点。在我的例子中，urls.py 文件是:
from django.contrib import admin
from django.urls import path
#This will import our view that we have already created
from .views import GeneratePdf
urlpatterns = [
path('admin/', admin.site.urls),
path('pdf/', GeneratePdf.as_view()),
]
在这个 urls.py 文件中，我定义了一个 URL 端点“pdf/”。当一个请求将被发送到这个 URL 端点时，我们在 views.py 文件中创建的基于类的视图将被调用。
现在让我们启动 Django 服务器并向/pdf/ endpoint 发送一个请求。
Convert HTML page to PDF using Django
您可以看到 HTML 模板中的内容呈现为 PDF 文件。通过这种方式，您可以将 HTML 文档转换为 PDF 文件。
用 CSS 将 Django HTML 转换成 PDF
在上面的例子中，我们简单地使用 Python Django 将一个 HTML 页面转换成一个 PDF 文件。我们还可以将一些 CSS 应用到 HTML 模板中，并使用 Django 将这个模板转换成 Python 中的 PDF 文件。
该方法几乎与上一节中解释的方法相同。在我的例子中， process.py 文件将是:
# importing the necessary libraries
from io import BytesIO
from django.http import HttpResponse
from django.template.loader import get_template
from xhtml2pdf import pisa
# defining the function to convert an HTML file to a PDF file
def html_to_pdf(template_src, context_dict={}):
template = get_template(template_src)
html = template.render(context_dict)
result = BytesIO()
pdf = pisa.pisaDocument(BytesIO(html.encode("ISO-8859-1")), result)
if not pdf.err:
return HttpResponse(result.getvalue(), content_type='application/pdf')
return None
我将把这个文件导入到 views.py 文件中。也可以直接在 views.py 文件中编写这段代码。但是将这段代码作为一个单独的模块来编写是一个很好的方法。
现在， views.py 文件将如下所示:
# importing the necessary libraries
from django.http import HttpResponse
from django.views.generic import View
from .process import html_to_pdf
#Creating a class based view
class GeneratePdf(View):
def get(self, request, *args, **kwargs):
# getting the template
pdf = html_to_pdf('result.html')
# rendering the template
return HttpResponse(pdf, content_type='application/pdf')
我已经创建了一个带有一些随机文本的 HTML 模板。在这个演示中，我还使用了一些 CSS 属性。这个 HTML 模板以名称results.html保存:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Welcome to Python Guides</title>
</head>
<body>
<p style="color: black; font-size: xx-large; font-family:Arial, Helvetica, sans-serif, Geneva, Tahoma, sans-serif;"> Dear Customer,</p>
<p style="padding-left: 5em;">This is to inform you that your plan is expiring soon. Kindly, pay your monthly premium before expiration.</p>
<p style="font-size: x-large;">Thank You</p>
<p style="font-size: large; color: blue;"> Python Guides</p>
</body>
</html>
现在让我们用 view.py 文件中创建的函数映射 URL 端点。这将在 urls.py 文件中完成，该文件为:
from django.contrib import admin
from django.urls import path
#This will import our view that we have already created
from .views import GeneratePdf
urlpatterns = [
path('admin/', admin.site.urls),
path('pdf/', GeneratePdf.as_view()),
]
保存以上所有文件并启动 Django 服务器。让我们看看输出:
Converted HTML to PDF with CSS
您可以看到 PDF 文件中的内容就像在 HTML 文件中一样，即我们的 CSS 反映在 PDF 文件中。
这样就可以在 Django 中将一个带 CSS 的 HTML 文件转换成 PDF 文件。
在 Django 中动态转换 HTML 为 PDF
在现实生活中，您可能需要使用 PDF 文件向用户显示动态数据。例如，从数据库中检索一些数据，并将其呈现在 HTML 模板中，然后将其转换为 PDF 文件。
一些常见的用例是生成文档，如电子商务网站的发票、应用程序数据、表单、简历等。
在这一节中，我将演示如何从数据库中检索数据，并将其呈现在 HTML 模板中。然后我会把这个 HTML 模板转换成 PDF 文档。
在 Django，你有可以一起工作的模型。我已经将我的 models.py 文件创建为:
from django.db import models
class Employees(models.Model):
emp_id = models.AutoField
first_name = models.CharField(max_length=20)
last_name = models.CharField(max_length=20)
department= models.CharField(max_length=20)
上面的模型相当于一张桌子。我使用的是 SQLite 数据库。因此，我使用 SQLite Studio 用一些数据填充了这个表。现在表格变成了:
| 身份证明（identification） | 名字 | 姓氏 | 部门 |
|---|---|---|---|
| One thousand six hundred and one | 克莉丝 | 海姆斯沃斯 | 研究 |
| One thousand six hundred and two | 赫勒纳 | 威廉姆斯 | 金融 |
| One thousand six hundred and three | 尿壶 | 詹姆斯 | 营销 |
| One thousand six hundred and four | 督尼 | 莫克尔 | 金融 |
Employees Table
现在我将在一个单独的 python 文件中创建一个将 HTML 文档转换为 PDF 文件的函数，比如说 process.py. 你也可以直接将其写入 views.py 文件中。但是我将把它导入 views.py 文件。
# importing the necessary libraries
from io import BytesIO
from django.http import HttpResponse
from django.template.loader import get_template
from xhtml2pdf import pisa
# defining the function to convert an HTML file to a PDF file
def html_to_pdf(template_src, context_dict={}):
template = get_template(template_src)
html = template.render(context_dict)
result = BytesIO()
pdf = pisa.pisaDocument(BytesIO(html.encode("ISO-8859-1")), result)
if not pdf.err:
return HttpResponse(result.getvalue(), content_type='application/pdf')
return None
现在我将从这个表中检索数据。这将在 views.py 文件中完成。您可以看到，我还在这里导入了 process.py 文件:
# importing the necessary libraries
from django.http import HttpResponse
from django.views.generic import View
from app1 import models
from .process import html_to_pdf
from django.template.loader import render_to_string
#Creating a class based view
class GeneratePdf(View):
def get(self, request, *args, **kwargs):
data = models.Employees.objects.all().order_by('first_name')
open('templates/temp.html', "w").write(render_to_string('result.html', {'data': data}))
# Converting the HTML template into a PDF file
pdf = html_to_pdf('temp.html')
# rendering the template
return HttpResponse(pdf, content_type='application/pdf')
在上面的视图中，我从模型中检索数据。雇员是数据库中的表名。
objects() 函数用于从表中检索记录，而 all() 函数指定必须检索所有记录。
然后，数据呈现在 HTML 模板中，并写入临时文件。
原来的 HTML 模板即result.html是:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Welcome to Python Guides</title>
<style>
h1 {
text-align: center;
}
td, th {
text-align: center;
}
</style>
</head>
<body>
<h1>List of Employees</h1>
<table>
<thead>
<tr>
<th>Employee ID</th>
<th>First Name</th>
<th>Last Name</th>
<th>Department</th>
</tr>
</thead>
<tbody>
{% for person in data %}
<tr>
<td>{{ person.id }}</td>
<td>{{ person.first_name }}</td>
<td>{{ person.last_name }}</td>
<td>{{ person.department }}</td>
</tr>
{% endfor %}
</tbody>
</table>
</body>
</html>
在上面的模板中，我们使用一个循环来迭代从数据库中获取的记录。
当这个 HTML 模板被呈现并写入一个临时文件时，它看起来像这样:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Welcome to Python Guides</title>
<style>
h1 {
text-align: center;
}
td, th {
text-align: center;
}
</style>
</head>
<body>
<h1>List of Employees</h1>
<table>
<thead>
<tr>
<th>Employee ID</th>
<th>First Name</th>
<th>Last Name</th>
<th>Department</th>
</tr>
</thead>
<tbody>
<tr>
<td>1601</td>
<td>Chris</td>
<td>Hemsworth</td>
<td>Research</td>
</tr>
<tr>
<td>1604</td>
<td>Dwayne</td>
<td>Morkel</td>
<td>Finance</td>
</tr>
<tr>
<td>1602</td>
<td>Helena</td>
<td>Williams</td>
<td>Finance</td>
</tr>
<tr>
<td>1603</td>
<td>Jerry</td>
<td>James</td>
<td>Marketing</td>
</tr>
</tbody>
</table>
</body>
</html>
之后，新的临时 HTML 文件被转换成 PDF 文件，并返回响应。
但是我们还需要完成一个步骤，即在 urls.py 文件中定义一个路径，并将其与视图中的函数进行映射:
from django.contrib import admin
from django.urls import path
#This will import our view that we have already created
from .views import GeneratePdf
urlpatterns = [
path('admin/', admin.site.urls),
path('pdf/', GeneratePdf.as_view()),
]
现在让我们在浏览器中向这个端点发送一个请求。
How to Convert HTML to PDF Django
您可以在上面的图像中看到，存储在数据库中的记录呈现在一个 PDF 文档中。
因此，通过这种方式，您可以动态生成 HTML 内容，并使用 xhtml2pdf 库将其转换为 PDF 文件。
Django 生成 PDF 发票
生成 PDF 发票是最常见的应用之一，我们需要使用 Django 将 HTML 文档转换成 PDF 文档。
在这一节中，我将演示如何在 Django 应用程序中实现这一功能。
- 首先，我将创建一个函数，将 HTML 文件转换为 PDF 文件，并将其导入到项目的
views.py文件中。 - 假设我在一个名为
process.py的文件中创建了这个函数。该文件将如下所示:
# importing the necessary libraries
from io import BytesIO
from django.http import HttpResponse
from django.template.loader import get_template
from xhtml2pdf import pisa
# defining the function to convert an HTML file to a PDF file
def html_to_pdf(template_src, context_dict={}):
template = get_template(template_src)
html = template.render(context_dict)
result = BytesIO()
pdf = pisa.pisaDocument(BytesIO(html.encode("ISO-8859-1")), result)
if not pdf.err:
return HttpResponse(result.getvalue(), content_type='application/pdf')
return None
- 之后，我将把这个文件导入到 views.py 文件中，如下所示:
# importing the necessary libraries
from django.http import HttpResponse
from django.views.generic import View
from app1 import models
from .process import html_to_pdf
from django.template.loader import render_to_string
#Creating a class based view
class GeneratePdf(View):
def get(self, request, *args, **kwargs):
data = models.invoices.objects.get(id= 1434)
open('templates/temp.html', "w").write(render_to_string('result.html',{'data': data} ))
# Converting the HTML template into a PDF file
pdf = html_to_pdf('temp.html')
# rendering the template
return HttpResponse(pdf, content_type='application/pdf')
在上面的代码中，您可以看到我正在使用 Django 模型从数据库中加载发票数据。让我给你看一下 models.py 文件，在这里你可以看到我的数据库的结构:
from django.db import models
from django.db.models.base import Model
class invoices(models.Model):
name = models.CharField(max_length= 20)
address = models.CharField(max_length = 100)
pay_method = models.CharField(max_length = 15)
amount = models.FloatField(max_length=10)
description = models.CharField(max_length=50)
order_date = models.DateField()
我已经使用 SQLite studio 用一些示例记录填充了这个表，因为我使用的是 SQLite 数据库。该表如下图所示:
Invoices Table
此外，在 views.py 文件中，您可以看到我正在将数据传递给一个名为results.html的 Django 模板。该模板的内容包括:
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html >
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>Untitled Document</title>
</head>
<body>
<table width="100%" border="0" cellspacing="0" cellpadding="0">
<tr>
<td colspan="2"><img src="logo.png" width="150" /></td>
</tr>
<tr>
<td colspan="2"> </td>
</tr>
<tr>
<td width="49%"><table width="100%" border="0" cellspacing="0" cellpadding="0">
<tr>
<td><table width="100%" border="0" cellspacing="0" cellpadding="0">
<tr>
<td style="font-family:Verdana, Geneva, sans-serif; font-weight:600; font-size:15px;">Invoice Receipt</td>
</tr>
<tr>
<td style="font-family:Verdana, Geneva, sans-serif; font-weight:300; font-size:13px;">Invoice Number: {{data.id}}</td>
</tr>
<tr>
<td> </td>
</tr>
<tr>
<td style="font-family:Verdana, Geneva, sans-serif; font-weight:600; font-size:15px;">Service Provider </td>
</tr>
<tr>
<td style="font-family:Verdana, Geneva, sans-serif; font-weight:400; font-size:14px;">Mahesh Traders</td>
</tr>
<td style="font-family:Verdana, Geneva, sans-serif; font-weight:300; font-size:13px;">1001A, The Capital B Wing, 10th Floor, Bandra Kurla Complex, Bandra (E), Mumbai, Contact: 7863087385 </td>
</tr>
<tr>
<td> </td>
</tr>
</table></td>
</tr>
</table></td>
<td width="51%" valign="top"><table width="100%" border="0" cellspacing="0" cellpadding="0">
<tr>
<td align="right"><img src="logo.png" alt="" width="150" /></td>
</tr>
<tr>
<td style="font-family:Verdana, Geneva, sans-serif; font-weight:300; font-size:13px;" align="right"></td>
</tr>
<tr>
<td style="font-family:Verdana, Geneva, sans-serif; font-weight:300; font-size:13px;" align="right"> </td>
</tr>
<tr>
<td style="font-family:Verdana, Geneva, sans-serif; font-weight:300; font-size:13px;" align="right">Order Date :{{data.order_date}}</td>
</tr>
<tr>
<td style="font-family:Verdana, Geneva, sans-serif; font-weight:600; font-size:15px;" align="right">Customer Name</td>
</tr>
<tr>
<td style="font-family:Verdana, Geneva, sans-serif; font-weight:300; font-size:13px;" align="right">{{data.name}}</td>
</tr>
<tr>
<td style="font-family:Verdana, Geneva, sans-serif; font-weight:300; font-size:13px;" align="right">{{data.address}}</td>
</tr>
</table></td>
</tr>
<tr>
<td colspan="2"> </td>
</tr>
<tr>
<td colspan="2"><table width="100%" border="0" cellspacing="0" cellpadding="0">
<tr>
<td style="font-family:Verdana, Geneva, sans-serif; font-weight:600; font-size:13px; border-top:1px solid #333; border-bottom:1px solid #333; border-left:1px solid #333; border-right:1px solid #333;" width="34%" height="32" align="center">Description</td>
<td style="font-family:Verdana, Geneva, sans-serif; font-weight:600; font-size:13px; border-top:1px solid #333; border-bottom:1px solid #333; border-right:1px solid #333;" width="30%" align="center">Bill Amount</td>
<td style="font-family:Verdana, Geneva, sans-serif; font-weight:600; font-size:13px; border-top:1px solid #333; border-bottom:1px solid #333; border-right:1px solid #333;" width="30%" align="center">Payment Method</td>
</tr>
<tr>
<td style="font-family:Verdana, Geneva, sans-serif; font-weight:300; font-size:13px; border-bottom:1px solid #333; border-left:1px solid #333; border-right:1px solid #333;" height="32" align="center">{{data.description}}</td>
<td style="font-family:Verdana, Geneva, sans-serif; font-weight:300; font-size:13px; border-bottom:1px solid #333; border-right:1px solid #333;" align="center">{{data.amount}}</td>
<td style="font-family:Verdana, Geneva, sans-serif; font-weight:300; font-size:13px; border-bottom:1px solid #333; border-right:1px solid #333;" align="center">{{data.pay_method}}</td>
</tr>
</table></td>
</tr>
<tr>
<td colspan="2"> </td>
</tr>
<tr>
<td colspan="2"> </td>
</tr>
<tr>
<td style="font-family:Verdana, Geneva, sans-serif; font-weight:600; font-size:13px;" colspan="2">Please Note:</td>
</tr>
<tr>
<td style="font-family:Verdana, Geneva, sans-serif; font-weight:300; font-size:13px;" colspan="2">Dear Consumer, the bill payment will reflect in next 48 hours in your account. Please contact our customer support for any queries regarding this order.</td>
</tr>
<tr>
<td colspan="2"> </td>
</tr>
<tr>
<td style="font-family:Verdana, Geneva, sans-serif; font-weight:600; font-size:13px;" colspan="2">Thank you for using our service</td>
</tr>
<td colspan="2"> </td>
</tr>
<tr>
<td colspan="2"> </td>
</tr>
<tr>
<td style="font-family:Verdana, Geneva, sans-serif; font-weight:300; font-size:13px;" colspan="2" align="center">(This is computer generated receipt and does not require physical signature.) </td>
</tr>
<tr>
<td colspan="2"> </td>
</tr>
<tr>
<td colspan="2"> </td>
</tr>
<tr>
<td colspan="2"> </td>
</tr>
</table>
</body>
</html>
现在，最后一步是用我们的代码映射一个 URL 端点，即在 urls.py 文件中创建一个路径。在我的例子中，urls.py 文件将是:
from django.contrib import admin
from django.urls import path
#This will import our view that we have already created
from .views import GeneratePdf
urlpatterns = [
path('admin/', admin.site.urls),
path('pdf/', GeneratePdf.as_view()),
]
完成上述所有步骤后，就可以向 urls.py 文件中定义的 URL 端点发送请求了。
http://localhost:8000/pdf/
Generating a PDF invoice in Django
您可以看到数据库中的值被加载到这个 PDF 发票中。您还可以通过使用支持的 CSS 添加一些样式来定制您的 Django 模板(并非所有 CSS 都受支持)。
因此，您可能已经对如何在 Django 中生成 PDF 发票有了基本的了解。
相关 Python Django 教程:
- Django for loop
- Django 模板中的 If 语句
- Python Django 获取管理员密码
- Python Django vs Flask
- Python Django group by
- Python Django get
- 与 Django 和 SQLite 的联系表
因此，使用上述方法，您可以使用 Python 中的 Django 将 HTML 文档转换成 PDF 文档。
- 如何将 HTML 转换成 PDF Django
- Django HTML 到 PDF 示例
- 用 CSS 将 Django HTML 转换成 PDF
- 在 Django 中动态转换 HTML 为 PDF
- Django 生成 PDF 发票
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Python 中熊猫如何把整数转换成 Datetime
原文：https://pythonguides.com/convert-integers-to-datetime-in-pandas/
在这个 Python 教程中，我们将学习如何在 Pandas DataFrame 中将整数转换成日期时间。此外，我们将涵盖这些主题。
- 在 Pandas 中将 int 转换为 datetime
- 在熊猫中将数字转换为日期
- 在 Pandas 中将 excel 数字转换为日期
- 将 int 列转换为 datetime Pandas
- 熊猫将 datetimeindex 转换为整数
- 用 nan 将熊猫中的 int 转换为 datetime
- 在 Pandas 中将 int 转换为 datetime，不带小数
- 将熊猫字符串中的 int 转换为 datetime
目录
- 在熊猫中把整数转换成日期时间
- 在熊猫中把 int 转换成 datetime
- 将熊猫的数字转换为日期
- 将 excel 数字转换为熊猫的日期
- 将 int 列转换为 datetime Pandas
- 熊猫将 datetimeindex 转换为整数
- 将 int 转换为 datetime 在熊猫与 nan
- 转换 int 为 datetime 在熊猫没有小数
- 将熊猫字符串中的 int 转换成 datetime
在熊猫中把整数转换成日期时间
- 在这个程序中，我们将讨论如何使用 Python 将 Pandas DataFrame 中的整数转换为 Datetime。
- 通过使用熊猫。Datetime() 方法我们可以执行这个特定的任务，要执行这个任务，首先必须检查整数数据必须与指定的格式匹配。
语法:
下面是熊猫的句法。日期时间()方法
Pandas.to_datetime
(
arg,
errors='raise',
dayfirst='False',
yearfirst='False',
utc=None,
format=None,
exact=True,
unit=None,
infer_datetime_format=false,
origin='unix',
cache=True
)
举例:
让我们举一个例子，并检查如何使用 Python 将 Pandas Dataframe 中的整数转换为 datetime
import pandas as pd
new_dict = {'no_dates': [19990320,20200416,20010828],
'new_stats': ['Available','Available','Available']
}
df = pd.DataFrame(new_dict, columns = ['no_dates','new_stats'])
df['no_dates'] = pd.to_datetime(df['no_dates'], format='%Y%m%d')
print (df)
在上面的代码中，我们创建了三个不同的日期，格式为 (yyy-mm-dd) 。现在我们将声明 dataframe 对象，并在列表中指定字典‘new _ dict’和列名。现在使用 Pandas.to_Datetime() 方法将整数转换为日期时间。
下面是以下给定代码的执行过程
Convert Integers to Datetime in Pandas
另外，检查: Python 熊猫替换多个值
在熊猫中把 int 转换成 datetime
- 让我们看看如何使用 Python 将 Pandas 数据帧中的 int 转换为 datetime。
- 这里我们可以使用
pd.to_datetime()方法，这个函数将把你的整数数据转换成日期格式。
语法:
下面是 pd.to_datetime()方法的语法
Pandas.to_datetime
(
arg,
errors='raise',
dayfirst='False',
yearfirst='False',
utc=None,
format=None,
exact=True,
unit=None,
infer_datetime_format=false,
origin='unix',
cache=True
)
- 它由几个参数组成
- arg: 此参数指定要转换为日期时间的对象，对象必须是整数、字符串或浮点数。
- 错误:默认情况下，其值为‘引发’，表示无效解析会引发异常。
- dayfirst: 该参数将帮助您了解您的‘日’是否在您的格式中处于第一位，默认情况下，其值为‘假’。
- yearfirst: 表示如果您的年份是第一年，则首先尝试格式代码选项，默认情况下，它采用‘false’值。
- utc: 如果您想用时区转换您的日期时间，可以使用这个参数。
- 格式:该参数用于显示日期时间的格式代码。
源代码:
import pandas as pd
new_int = 19981123
new_result=pd.to_datetime(str(new_int), format='%Y%m%d')
print(new_result)
在上面的程序中，我们已经导入了 Pandas 库，然后用变量名‘new _ int’初始化一个整数值。现在使用 pd.to_datetime() 方法，并将 str 数据类型与‘new _ int’一起赋值。一旦您打印了【T6’new _ result’，输出将显示日期时间格式。
你可以参考下面的截图
Convert int to datetime in Pandas
阅读: Python 数据帧到 CSV
将熊猫的数字转换为日期
- 在这一节中，我们将讨论如何使用 Python 将 Pandas 数据帧中的数字转换为日期。
- 在这个例子中，我们必须将一个整数转换成熊猫数据帧中的日期。为了执行这个任务，我们首先要使用
pd.to_datetime()方法，这将帮助用户转换 Dataframe 中带有日期的数字。
举例:
import pandas as pd
new_val = 20100820
new_dt = pd.DataFrame({'date':[new_val]*3})
new_dt['New_DateTime'] = new_dt['date'].apply(lambda m: pd.to_datetime(str(m), format='%Y%m%d'))
print(new_dt)
在上面的代码中，我们创建了一个 dataframe 对象 'new_dt' ，然后传递整数变量名 'new_val' 和 *3 ，这意味着它将显示三次。现在使用 lambda 函数，它计算给定参数的表达式。
下面是以下给定代码的实现
Convert number to date in Pandas
将 excel 数字转换为熊猫的日期
- 在这个程序中，我们将讨论如何使用 Python 将熊猫数据框架中的 excel 数字转换为日期。
- 在这里，我们可以使用一个 excel 数字的例子来完成这项任务，在内部使用一个名为 xlrd 的库，它可以用于读取输入文件。
- 要在 Python 中安装 xlrd 包，您必须使用 pip install xlrd 命令，该模块允许用户从 excel 数字或文件中读取数据。
语法:
以下是 xldate_as_datetime 的语法
xlrd.xldate_as_datetime()
源代码:
import xlrd
new_val = 42580
new_date = xlrd.xldate_as_datetime(new_val, 0)
Output = new_date.date()
print(Output)
安装“xlrd”包后，您必须导入示例中的 xlrd 库，现在使用 xldate_as_datetime() 方法将 excel 数字转换为 datetime 对象。
下面是以下给定代码的输出
Convert excel number to date in Pandas
阅读:计算熊猫数据帧中的行数
将 int 列转换为 datetime Pandas
- 让我们看看如何使用 Python Pandas 将整数列转换为 datetime。
- 在 Python 中，如果您想将一个列转换成 datetime，那么您可以很容易地应用
pd.to_datetime()方法。要执行此任务，首先从字典创建一个 dataframe，然后使用 pd.dataframe 类将字典作为输入。 - 现在，要将 integer 列转换为 datetime，请使用括号中的 data frame‘df’，并在这个括号中注明要转换为 datetime 的列名。
源代码:
import pandas as pd
new_dictionary = {'Increment':[7734, 1122, 5544, 1021, 1123],
'emp_name': ['Micheal', 'William',
'George',
'John', 'Potter'],
'Date':['10/19/2004', '02/23/1998',
'08/27/2011', '06/30/1993', '09/18/1992'],
'int_Date': [19980602, 19940514, 20090225, 19920719,
20170225]}
df = pd.DataFrame(new_dictionary)
print(df.head())
df['int_Date'] = pd.to_datetime(df['int_Date'])
print("Convert Column to Datetime:")
print(df)
下面是以下代码的截图
Convert int column to datetime Pandas
熊猫将 datetimeindex 转换为整数
- 在本节中，我们将讨论如何使用 Python 在 Pandas Dataframe 中将 datetimeindex 转换为整数。
- 通过使用
pd.to_timedelta()和dt.total_seconds()方法的组合，我们可以轻松地执行这个特定的任务。在 Pandas 中，timedelta 格式用于添加日期和时间部分，而total_seconds()方法可直接用于 Timedeltaindex 和 timedelta 值。
语法:
下面是 Pandas.to_delta()方法的语法
Pandas.to_delta
(
arg,
unit=None,
errors='raise'
)
- 它由几个参数组成
- arg: 该参数指定要用时间增量转换的数据对象。
- 单位:默认为无，取值为' Y '，' M '，' W '，' D '。
- 错误:在这个例子中，我们将设置 errors =‘ignore’。
举例:
import pandas as pd
new_data = pd.DataFrame({'date': ['2007:08:09', '1993:05:06','2001:02:03'] })
new_data=pd.to_timedelta(new_data.date).dt.total_seconds().astype(int)
print("Convert datetimeindex to integer:")
print(new_data)
下面是以下给定代码的执行过程
Pandas convert datetimeindex to integer
阅读: Python 将数据帧转换为列表
将 int 转换为 datetime 在熊猫与 nan
- 在这个程序中，我们将讨论如何将 nan 值的 Pandas 数据帧中的整数转换为 datetime。
- 这里我们可以使用
Pandas.to_datetime()方法来执行这个任务。首先，我们必须导入 pandas 和 numpy 库，然后创建一个包含键值对的字典‘my _ dict’。在这个例子中，键被认为是列名，列表值被认为是整数。 - 在给定的列表中，我们指定了一些整数和 nan 值。现在我们想用 datetime 和 nan 一起转换整数。
源代码:
import pandas as pd
import numpy as np
my_dict = {'no_dates': [19990320,np.nan,20200416,20010828,np.nan]}
df = pd.DataFrame(my_dict, columns = ['no_dates'])
df['no_dates'] = pd.to_datetime(df['no_dates'], format='%Y%m%d')
print (df)
你可以参考下面的截图
Convert int to datetime in Pandas with nan
正如您在屏幕截图中看到的，输出显示 nan 值已被“NAT”替换。在 Python 中，NAT 表示缺少的值。
阅读: Python 熊猫掉行
转换 int 为 datetime 在熊猫没有小数
- 在本节中，我们将讨论如何在 Pandas DataFrame 中将 integer 转换为 datetime。
- 我们在开始时已经讨论过这个主题，所以你可以更好地理解这个例子。在本例中，我们应用了相同的方法 Pandas.to_datetime。
举例:
import pandas as pd
new_val = 20061225
new_result=pd.to_datetime(str(new_val), format='%Y%m%d')
print(new_result)
下面是以下代码的截图
Convert int to datetime in Pandas without decimal
将熊猫字符串中的 int 转换成 datetime
- 在这个程序中，我们将讨论如何在熊猫字符串中将整数转换为日期时间。
- 通过使用
astype(str)方法，我们可以改变一个系列的数据类型，这个函数还提供了将现有列转换为不同类型的功能。
语法:
下面是 df.astype()方法的语法
DataFrame.astype
(
dtype,
copy=True,
errors='raise'
)
- 它由几个参数组成。
- dtype: 此参数指定数列与整数或字符串的转换。
- copy: 默认情况下，它采用“True”值并复制数据帧。
- 错误:该参数指示如果数据类型无效，则出现错误‘引发’。
举例:
import pandas as pd
new_val = 19960425
new_data = pd.DataFrame({'date':[new_val]*2})
new_data['New_Date'] = pd.to_datetime(new_data['date'].astype(str), format='%Y%m%d')
print(new_data)
下面是以下给定代码的执行过程
Convert int to datetime in Pandas string
你可能也喜欢阅读下面的教程。
在这篇 Python 教程中，我们学习了如何在 Pandas DataFrame 中将整数转换成日期时间。此外，我们已经讨论了这些主题。
- 在 Pandas 中将 int 转换为 datetime
- 在熊猫中将数字转换为日期
- 在 Pandas 中将 excel 数字转换为日期
- 将 int 列转换为 datetime Pandas
- 熊猫将 datetimeindex 转换为整数
- 用 nan 将熊猫中的 int 转换为 datetime
- 在 Pandas 中将 int 转换为 datetime，不带小数
- 将熊猫字符串中的 int 转换为 datetime
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
如何在 Python 中将元组列表转换成字符串
原文：https://pythonguides.com/convert-list-of-tuples-to-string-in-python/
在本 Python 教程中，我们将讨论几种在 Python 中将元组列表转换为字符串的方法。此外，我们将查看各种示例，将元组列表转换为 Python 中的字符串。
最近，我在做一个机器学习项目，我发现它需要一些字符串元素，而不是元组的 Python 列表。所以我做了一些研究，发现我们必须用 Python 把元组列表转换成字符串。
我们将讨论一些简单的技术，这些技术可以很容易地将 Python 元组列表转换成字符串。
在这里我们将学习
- 在 Python 中将元组列表转换为字符串
- 如何使用 join()将元组列表转换为字符串
- 使用 join()和 map()
我们的目标是把它转换成一个字符串，也就是一串字符。字符可以是字母、某些符号，甚至是用双引号或单引号括起来的整数。
目录
如何在 Python 中将元组列表转换成字符串
在 Python 中，在将元组列表转换为字符串时，主要有三种常用且重要的理解方法。
将元组列表转换为 Python 中的字符串
- 在这一节中，我们将讨论如何在 Python 中将元组列表转换为字符串。
- Python 有一个内置的库函数叫做
strip()。通过删除提供给strip()方法的前导和尾随空格、字母和符号，它用于返回原始字符串的副本。 - 为了将列表转换成字符串，我们将使用
str()函数。
语法:
string.strip(character)
注 : 为可选参数。当一个字符被传递给
strip()函数时，它将从字符串的两端被移除。
举例:
让我们举个例子，看看如何在 Python 中将元组列表转换成字符串。
源代码:
**# Creation list of tuples**
new_list = [(67,45), (22,19)]
**# By using the strip() function**
result=str(new_list).strip('[]')
**# Display the string**
print("Converted the list of tuple into string :",result)
print(type(result))
在上面的代码中，我们已经创建了一个元组列表，然后从一个元组中移除该列表，我们使用了 strip() 函数的概念。
下面是以下给定代码的实现。
How to convert the list of tuples into strings in Python
在这个例子中，我们已经理解了如何在 Python 中将元组列表转换成字符串。
如何使用 join() 将元组列表转换为字符串
- 在这一节中，我们将讨论如何使用 join()方法在 Python 中将元组列表转换为字符串。
- 使用
str.join()函数，我们可以将一个 Python 元组变成一个 Python 字符串。stringjoin()方法将一个 iterable 中的字符串连接起来，比如一个元组、列表、字典或集合，并返回一个字符串。 - 由于这个实例中的 iterable 是一个 tuple，返回字符串的
join()方法将接受 tuple 作为参数，同时我们将使用 list comprehension 方法。
举例:
让我们举一个例子，检查如何使用 Python 中的 join() 方法将元组列表转换为字符串。
**# Input list of tuples**
Cars_in_USA = [("Tesla"), ("BMW")]
**# By using the join() method**
result= "".join([str(i) for m in Cars_in_USA for i in m])
**# Display the Content**
print("Conversion list of tuple into string :",result)
**# Data type**
print(type(result))
在上面的代码中，我们首先创建了链表，并以元组的形式分配元素。现在我们想把它们转换成一个字符串，通过使用 list comprehension 和 join()方法，我们可以很容易地得到单个输入字符串。
你可以参考下面的截图
Convert list of tuples to string in Python by using the join method
这就是如何使用 join 方法将元组列表转换为字符串
使用 join()和 map()
- 这是执行这项任务的不同方式。这里，在使用 join 函数组合元组()之前，我们将每个项目转换为一个字符串。
- map()函数将每个元组转换成一个字符串值，join()方法通过应用提供的分隔符将一组字符串组合成一个字符串。
举例:
让我们举个例子，看看如何在 Python 中将元组列表转换成字符串。
源代码:
# Creation list of tuples
Country_name = [('U.S.A'), ('Australia'), ('China'), ('Belgium')]
# Display the input list
print("Input list of tuples : ", Country_name )
#By using the map() and join() function
new_output = " ".join(map(str, Country_name))
# Display the content
print("Convert list of tuples into string :",new_output)
在下面给出的代码中，我们首先将输入列表初始化为' Country_name '，然后使用 join() 和 map() 函数将元组的输入列表转换为字符串
下面是以下给定代码的实现。
Convert a list of tuples into a string in Python by using the map and join function
另外，看看更多的 Python 教程。
在本文中，我们讨论了如何将元组列表转换为字符串，并且我们应用了不同的方法来理解何时将元组列表转换为字符串
- 用 Python 将元组列表转换成字符串
- 如何使用 join()将元组列表转换为字符串
- 使用 join()和 map()
Arvind 目前是 TSInfo Technologies 的高级 Python 开发人员。他精通 Python 库，如 NumPy 和 Tensorflow。
将列表转换为张量张量流
原文：https://pythonguides.com/convert-list-to-tensor-tensorflow/
在本 Python 教程中，我们将学习如何在 Python TensorFlow 中将列表转换为张量。此外，我们将讨论以下主题。
- 将列表转换为张量张量流
- 将张量列表转换为 numpy 数组张量流
- 将字符串列表转换为张量张量流
- 将列表列表转换为张量流张量
- 将数组转换为张量 Pytorch
目录
将列表转换为张量张量流
- 在本节中，我们将讨论如何使用 TensorFlow Python 将列表转换为张量。
- 为了将 Python 列表转换为张量，我们将使用
tf.convert_to_tensor()函数，该函数将帮助用户将给定的对象转换为张量。 - 在这个例子中，对象可以是一个 Python 列表，通过使用函数将返回一个张量。
语法:
让我们看一下语法，了解一下 Python TensorFlow 中的 tf.convert_to_tensor() 函数的工作原理。
tf.convert_to_tensor
(
value,
dtype=None,
dtype_hint=None,
name=None
)
- 它由几个参数组成
- 值:该参数表示我们要将张量转换成的对象。
- dtype: 可选参数，指定值的类型。
- 名称:该参数表示操作的名称，也是可选参数。
举例:
让我们举一个例子，看看如何在 Python TensorFlow 中将列表转换成张量。
源代码:
import tensorflow as tf
new_list=[145,56,89,56]
print(type(new_list))
con_lis = tf.convert_to_tensor(new_list)
print("Convert list to tensor:",con_lis)
在下面的代码中，我们首先导入 TensorFlow 库，然后声明一个变量‘new _ list’，并在 list 对象中赋值。要检查它是 list 还是 NumPy，可以使用语法类型 (obj_name) 。
之后，我们使用了 tf.convert_to_tensor() 函数，在这个函数中，我们分配了列表对象‘new _ list’。一旦执行了这段代码，输出将显示张量对象。
下面是下面给出的代码的截图。
Python Convert list to tensor TensorFlow
阅读: TensorFlow Tensor to numpy
将张量列表转换为 numpy 数组张量流
- 这里我们将讨论如何在 Python TensorFlow 中将一个张量列表转换成一个 numpy 数组。
- 为了执行这个任务，我们将使用
tf.stack()函数来创建一个张量列表。在 Python 中，这个函数用于将一列张量与一个新的张量组合起来。在这个例子中，我们将首先使用tf.constant()函数创建三个张量，然后我们将使用tf.stack()函数来组合列表中的这些张量。 - 接下来，我们将使用
tensor.numpy()函数，该函数将帮助用户将张量转换为 numpy 数组，它是 TensorFlow 中的内置函数。
语法:
下面是 Python TensorFlow 中 tf.stack() 函数的语法。
tf.stack
(
values,
axis=0,
name='stack'
)
- 它由几个参数组成
- 值:该参数表示具有相同大小和形状的张量对象列表。
- 轴:默认取
0值，定义第一个尺寸。 - name:该参数表示操作的名称，默认情况下取‘Stack’值。
举例:
让我们举一个例子，看看如何在 Python TensorFlow 中将张量列表转换为 numpy 数组。
源代码:
import tensorflow as tf
tens1 = tf.constant([67, 23,56])
tens2 = tf.constant([94, 13,28])
tens3 = tf.constant([116, 178,345])
result=tf.stack([tens1, tens2, tens3])
print("Cretaed a list of tensors:",result)
con_arr = result.numpy()
print("Converting into numpy array:",con_arr)
print(type(con_arr))
在上面的代码中，我们已经导入了 Tensorflow 库，然后使用 tf.constant() 函数创建了一个张量。创建张量后，我们已经通过使用 tf.stack() 函数组合了张量列表，然后我们使用 tensor.numpy() 函数将张量转换为 numpy 数组。
下面是以下给定代码的执行。
Python Convert list of tensor to numpy array TensorFlow
阅读:张量流得到形状
将字符串列表转换为张量张量流
- 在本节中，我们将讨论如何在 Python TensorFlow 中将字符串列表转换为张量。
- 为了执行这个特定的任务，我们将使用
tf.convert_to_tensor()函数，这个函数用于将给定的对象转换成张量。在这个例子中，输入对象将是一个字符串列表。 - 接下来，我们将使用
tf.convert_to_tensor()函数，并将字符串列表作为参数传递。
语法:
下面是 Python TensorFlow 中 tf.convert_to_tensor() 函数的语法。
tf.convert_to_tensor
(
value,
dtype=None,
dtype_hint=None,
name=None
)
举例:
让我们举一个例子，检查如何在 Python TensorFlow 中将字符串列表转换为张量。
源代码:
import tensorflow as tf
lis_of_strings = ["USA", "France", "Australia","Germany","China"]
print("Creation of list of strings:",lis_of_strings)
print(type(lis_of_strings))
result=tf.convert_to_tensor(lis_of_strings)
print("Convert list of strings into tensor:",result)
print(type(result))
在下面的代码中，我们首先创建了一个字符串列表，并使用 type(object_name)检查了数据类型。
在本例中，对象名为 lis_of_strings ，然后我们使用了 tf.convert_to_tensor() 函数，并将 lis_of_strings 指定为参数。一旦执行了这段代码，输出就会显示张量。
下面是以下给定代码的实现。
Python Convert list of strings to tensor TensorFlow
阅读:Python tensor flow reduce _ sum
将列表列表转换为张量流张量
- 在这一节中，我们将讨论如何在 Python TensorFlow 中将列表转换为张量。
- 通过使用
tf.convert_to_tensor()函数，我们可以很容易地将列表的列表转换成张量。首先，我们将创建一个嵌套列表，这意味着一个列表列表，然后我们将分配整数值。 - 接下来，我们将使用
tf.convert_to_tensor()函数将列表列表转换为张量。
语法:
下面是 Python 中 tf.convert_to_tensor() 函数的语法。
tf.convert_to_tensor
(
value,
dtype=None,
dtype_hint=None,
name=None
)
举例:
让我们举个例子，检查一下如何在 Python TensorFlow 中把一列列表转换成张量。
源代码:
import tensorflow as tf
lis_of_lists = [[15, 89, 467], [122, 897, 345], [167, 945, 289]]
print("Creation of list of lists:",lis_of_lists)
print(type(lis_of_lists))
result=tf.convert_to_tensor(lis_of_lists)
print("Convert list of lists into tensor:",result)
print(type(result))
下面是下面给出的代码的截图。
Python Convert list of lists to TensorFlow tensor
阅读:Python tensor flow reduce _ mean
将数组转换为张量 Pytorch
- 这里我们将讨论如何在 Python 中将 numpy 数组转换成 Pytorch 张量。
- 为了完成这项任务，我们将使用
torch.fromnumpy()函数，该函数用于将给定的 numpy 数组转换为 pytorch 张量。 - 在 Python 中，torch.tensor 与包含单一数据类型元素的 numpy 数组相同。
语法:
让我们看一下语法，理解一下 torch.from numpy() 函数的工作原理。
torch.fromnumpy(ndarray)
举例:
让我们举个例子，看看如何将 numpy 数组转换成 Pytorch 张量。
源代码:
import torch
import numpy as np
new_arr=np.array([[25,78,97],
[12,45,89],
[67,89,55]])
print("Creation of numpy array:",new_arr)
result = torch.from_numpy(new_arr)
print("Converting array into Pytorch:",result)
print(type(result))
在下面给定的代码中，我们导入了 numpy 库，然后使用 np.array() 函数创建了一个 numpy 数组。在创建了一个数组之后，我们使用了 torch.from_numpy() 函数，在这个函数中，我们将数组指定为一个参数。
下面是以下给定代码的输出
Python Convert array to tensor Pytorch
正如你在截图中看到的，输出显示火炬张量。
还有，多看看 TensorFlow 里的一些教程。
在这个 Python 教程中，我们学习了如何在 Python 中将 list 转换为 tensor TensorFlow 。此外，我们还讨论了以下主题。
- 将列表转换为张量张量流
- 将张量列表转换为 numpy 数组张量流
- 将字符串列表转换为张量张量流
- 将列表列表转换为张量流张量
- 将数组转换为张量 Pytorch
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
如何在 Python 中将 Pandas 数据帧转换成 NumPy 数组
原文：https://pythonguides.com/convert-pandas-dataframe-to-numpy-array/
在这个 Python 熊猫教程中，我们将学习如何在 Python 中转换熊猫数据帧为 NumPy 数组。此外，我们将涵盖这些主题。
- 将 Pandas 数据帧转换为不带标题的 NumPy 数组
- 将 Pandas 数据帧转换为不带索引的 NumPy 数组
- 将 Pandas 数据帧转换为 NumPy 数组
- 将 Pandas 系列转换为 NumPy 数组
- 将 Pandas 数据帧转换为 3d 数字数组
- 将 Pandas 数据帧转换为 2d 数字数组
- 将 Pandas 数据帧转换为 NumPy 矩阵
我们使用了从 Kaggle 下载的 Steam 播放器数据。
目录
- 将 Pandas 数据帧转换为不带标题的 NumPy 数组
- 将 Pandas 数据帧转换为不带索引的 NumPy 数组
- 将 Pandas 数据帧转换为 NumPy 数组
- 将 Pandas 系列转换为 NumPy 数组
- 将 Pandas 数据帧转换为 3D NumPy 数组
- 将熊猫数据帧转换为 2D 数字数组
- 将熊猫数据帧转换为 NumPy 矩阵
将 Pandas 数据帧转换为不带标题的 NumPy 数组
在这一节中，我们将学习如何用 Python 将 pandas dataframe 转换成不带头文件的 Numpy 数组。
- 使用
dataframe.to_numpy()方法，我们可以将任何数据帧转换为 numpy 数组。 - 默认情况下，在此方法之后生成的 Numpy 数组没有标头。
- 虽然标头不可见，但可以通过引用数组名来调用它。在这种情况下，数组名称将是列名，如“月 _ 年”、“收益”、“URL”等。
- 下面是在 Jupyter 笔记本上的实现。
将 pandas 数据框架转换为 tensorflow 数据集
原文：https://pythonguides.com/convert-pandas-dataframe-to-tensorflow-dataset/
TensorFlow 数据集用于许多 TensorFlow 示例中。那么，你到底如何将熊猫数据帧转换成张量流数据集？在这种情况下，我们将首先生成一个 pandas 数据框，然后使用 TensorFlow 加载它。
- 将 pandas 数据框架转换为 TensorFlow 数据集
- 将 NumPy 数组转换为 TensorFlow 数据集
- 如何将字典转换成熊猫数据框架
- 熊猫级数到张量流张量
- 熊猫数据框 vs 张量流
目录
- 将熊猫数据帧转换为 TensorFlow 数据集
- 将 NumPy 数组转换为 TensorFlow 数据集
- 如何将字典转换成熊猫数据框架
- 熊猫级数到张量流张量
- 熊猫 DataFrame vs TensorFlow
将 pandas 数据框转换为 TensorFlow 数据集
- 这里我们将讨论如何在 Python TensorFlow 中将 pandas dataframe 转换为 Tensorflow 数据集。
- 在本例中，我们将创建一个虚拟熊猫数据框，并将其转换为 TensorFlow 数据集。为此，我们将使用
TF . data . dataset . from _ tensor _ slices()函数。 - 来自张量的每个输入张量创建一个类似于数据集的一行的数据集，而来自张量切片的每个输入张量创建一个类似于数据的一列的数据集。因此，在这种情况下，所有张量的长度必须相同，结果数据集的元素(行)是每个元素一个的元组。
- 使用 tf.data 作为资源，数组的切片可以通过使用
dataset . from tensor slices()函数和 TF . data . using dataset . from tensor slices()函数作为对象获得。
语法:
我们先来看看语法，了解一下TF . data . dataset . from _ tensor _ slices()函数在 Python TensorFlow 中的工作原理。
tf.data.Dataset.from_tensor_slices(list)
举例:
import tensorflow as tf
import pandas as pd
df = pd.DataFrame({'Department1':[78,16,89],
'Department2': ['Science','Maths','Biology']})
df
new_df_val = tf.data.Dataset.from_tensor_slices(dict(df))
new_df_val
for i in new_df_val .take(3):
print(i)
在下面的代码中，我们首先导入了 tensorflow 和 pandas 库，然后使用 pd 创建了一个 dataframe。DataFrame()函数，其中我们分配了两列‘部门 1’，‘部门 2’。
接下来，我们通过使用TF . data . dataset . from _ tensor _ slices()将给定的数据帧转换为张量数据集，然后迭代张量中的所有列值。
下面是以下代码的截图
Convert pandas dataframe to TensorFlow dataset
这就是如何在 Python TensorFlow 中将 Pandas 数据帧转换为 TensorFlow 数据集。
阅读: TensorFlow Tensor to numpy
将 NumPy 数组转换为 TensorFlow 数据集
- 在本节中，我们将讨论如何将 Numpy 数组转换为 TensorFlow 数据集。
- 为了执行这项任务，我们将使用
TF . data . dataset . from _ tensor _ slices()函数，该函数可以轻松地将 numpy 数组转换为数据集。
举例:
import tensorflow as tf
import numpy as np
# Creating an array by using the np.array() function
new_array = np.array([[15, 98, 67, 45],
[55, 25, 16, 67],
[45, 99, 23, 36],
[88, 92, 14, 22]])
# BY using tf.data.Dataset.from_tensor_slices() function
result = tf.data.Dataset.from_tensor_slices(new_array)
for m in result:
print(m.numpy())
在这个例子中，我们使用了 np.array() 函数来创建一个数组，然后将整数值赋给它。接下来，我们通过使用TF . data . dataset . from _ tensor _ slices()函数将数组转换为数据集。
下面是以下给定代码的执行过程
Convert NumPy array to TensorFlow dataset
正如您在截图中看到的，我们已经将 numpy 数组转换为 TensorFlow 数据集。
阅读:Python tensor flow reduce _ sum
如何将字典转换成熊猫数据框架
- 要将 Python 字典转换成 DataFrame (dict)对象，请使用熊猫。DataFrame.to dict() 方法。如果要将 DataFrame 转换成 Python dictionary (dict)对象，可以使用这种方法，方法是将每行的列数据转换成键，将列名转换成值。
- 这些参数定义了字典的结构以及键值对的连接方式。使用 to-dict 函数实现简单的数据帧到字典的转换。
语法:
下面是 DataFrame.to_dict()函数的语法
DataFrame.to_dict(orient='dict’, into=)
- 它由几个参数组成
- orient: 定义结果 dict 的键值对结构。输入参数、创建 dict 的格式以及生成的 dict 的键值对都会显示出来，默认情况下，它采用‘dict’值。
- into: 用于定义结果字典的类型。我们可以给出一个实际的类或者一个空的实例。
举例:
import pandas as pd
new_val = {'Car_names': ['Tesla','BMW','TOYOTA'],
'Price': [6782,345555,444323]
}
result = pd.DataFrame(new_val, columns = ['Car_names', 'Price'])
print (result)
print(type(result))
你可以参考下面的截图
How to convert the dictionary into a Pandas DataFrame
这就是我们如何将字典转换成熊猫数据框架的方法。
阅读:Python tensor flow reduce _ mean
熊猫级数到张量流张量
- 让我们看看如何将 pandas 系列数据转换为 TensorFlow 张量。
- 为了完成这项任务，我们将使用
TF . data . dataset . from _ tensor _ slices()函数，该函数从张量中提取每个输入张量，以创建一个类似于数据集中一行的数据集，而张量切片中的每个输入张量创建一个类似于数据列的数据集。
举例:
import tensorflow as tf
import pandas as pd
df = pd.DataFrame({'Department1':[178,965,156],
'Department2': ['Chemistry','Maths','Biology']})
df
new_df_val = tf.data.Dataset.from_tensor_slices(dict(df))
new_df_val
for i in new_df_val .take(3):
print(i)
在下面的代码中，我们首先导入了 tensorflow 和 pandas 库，然后使用 pd 创建了一个 dataframe。DataFrame()函数，其中我们分配了两列“部门 1”和“部门 2”。
接下来，我们使用 TF . data . dataset . from _ tensor _ slices()将给定的数据帧转换为张量数据集，然后迭代张量中的所有列值。
下面是以下给定代码的实现
Pandas series to TensorFlow tensor
阅读:Python tensor flow expand _ dims
熊猫 DataFrame vs TensorFlow
- 二维数据及其相关标签存储在一个称为熊猫数据帧的结构中。在数据科学、机器学习、科学计算和许多其他处理大量数据的领域中，经常使用数据帧。
- 张量是一个 n 维向量或矩阵，可以表示任何类型的数据。张量的值都具有相同的数据类型和已知(或至少部分已知)的形状。矩阵或数组的维数对应于数据的形状。
- 列可以是不同的类型，例如 int、bool 等，它可以与列和行都被索引的系列结构字典相比较。对于列，它被定义为“列”，对于行，它被定义为“索引”
- 计算的输入数据和输出都会产生张量。在 TensorFlow 中，每个操作都发生在一个图形中。该图表示按顺序发生的一系列计算。每个操作之间的连接称为 op 节点。
在本主题中，我们讨论了熊猫数据框架和张量流之间的主要区别
你可能也喜欢阅读下面的 Tensorflow 教程。
在本文中，我们已经讨论了如何 将 pandas 数据帧转换为 tensorflow 数据集 ，并且我们已经涵盖了以下给定主题
- 将 pandas 数据框架转换为 TensorFlow 数据集
- 将 NumPy 数组转换为 TensorFlow 数据集
- 如何将字典转换成熊猫数据框架
- 熊猫级数到张量流张量
- 熊猫数据框 vs 张量流
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
用 Python 将 PDF 文件转换成 Docx
原文：https://pythonguides.com/convert-pdf-file-to-docx-in-python/
最近，我们接到一个需求，需要构建一个 Python 应用程序，将 PDF 文件转换为 word 文档(Docx 文件)。现在，对于 Python 中的这个任务，我们利用 Python 中的 pdf2docx 包。但是在实现中，我们得到一个错误，说明“”attribute error:“页面”对象没有属性“旋转矩阵”。你是说‘旋转矩阵’吗？ ”。
所以，在这个 Python 教程中，我们将了解如何解决这个错误以及 在 Python 中将 PDF 文件转换为 Docx。这是我们将要讨论的话题清单。
- “将 PDF 文件转换为 Python 中的 Docx”的先决条件
- Python 中的将 PDF 文件转换为 Docx 错误
- 使用 Converter()将 PDF 文件转换为 Python 中的 Docx
- 使用 parse()在 Python 中将 PDF 文件转换为 Docx
目录
“用 Python 将 PDF 文件转换成 Docx”的先决条件
检查 Python 版本
在我们开始实现 PDF 到 Docx 的转换之前，我们需要确保 python 正确地安装在我们的系统中。现在，我们可以通过在命令提示符或终端中使用以下命令来检查 python 的版本。
python --version
但是，对于当前实例，我们使用的是 Windows 操作系统，因此我们将使用 Windows 命令提示符。下面是上面命令的结果。
Check the Python version in CMD
所以，从输出中，你可以观察到我们使用的是 Python 版本3 . 10 . 2T3。
另外，检查:什么是 Python 字典
安装 pdf2docx 包
在这之后，下一个先决条件是 pdf2docx 包。这个 Python 库利用 Python 绑定的 PyMuPDF 从 PDF 文件中提取数据并解释其布局。然后它使用 *python-docx* 库创建 word 文档文件。
这里的 *python-docx* 是另一个有用的库，通常用于生成和编辑 Microsoft Word ( )。docx )文件。
现在，这个 pdf2docx 包是第三方包，所以在使用它之前，我们需要将它安装在我们的系统或虚拟环境中。
下面是我们将创建一个虚拟环境，然后使用 pip 命令在其中安装 pdf2docx 包的基本步骤。
用 Python 创建虚拟环境的命令。
python -m venv myapp
在上面的命令中， myapp 是虚拟环境的名称。但是，您也可以指定任何其他环境名称。
下一步是激活虚拟环境，我们将使用以下命令来完成此任务。
myapp\Scripts\activate
一旦虚拟环境被激活，虚拟环境的名称将出现在终端的启动处。
Convert PDF file to Docx in Python Example
现在，我们准备在我们的 myapp 虚拟环境中安装 pdf2docx 包。对于这个任务，我们将使用下面的 pip 命令。
pip install pdf2docx
一旦我们运行上面的命令，它将安装与这个 pdf2docx 包相关的所有必需的包。
重要:
In our case, it has install the
pdf2docxversion0.5.3. And the error wheich we are goining to resolve will also come in the same version. If you have installed some other version there is a possibility that you don’t recieve any or same error.
阅读: Python 命名约定
用 Python 把 PDF 文件转换成 Docx
一旦我们安装了 pdf2docx 包，我们就可以使用 Python 中的这个包将 pdf 文件转换成扩展名为. docx 的 word 文档。对于这个任务，我们在 pdf2docx 中有 2 个不同的方法。第一种方法包括使用包中的 Converter()类，第二种方法包括使用 parse() 函数。
让我们用 Python 中的一个例子来讨论每种方法。
使用转换器()类
Converter()类利用PyMuPDF读取指定的 PDF 文件并逐页获取原始布局数据，包括文本、图像及其相关属性。- 之后，它在页眉、页脚和页边距级别检查文档的布局。
- 接下来，它将把页面布局解析为 docx 结构。最后，使用“”python-docx”生成一个 docx 文件作为结果。
让我们了解一下在 Python 中如何使用这个 Converter() 类将 PDF 转换成 word 文档。
# Importing the Converter() class
from pdf2docx import Converter
# Specifying the pdf & docx files
pdf_file = 'muscles.pdf'
docx_file = 'muscles.docx'
try:
# Converting PDF to Docx
cv_obj = Converter(pdf_file)
cv_obj.convert(docx_file)
cv_obj.close()
except:
print('Conversion Failed')
else:
print('File Converted Successfully')
在上面的代码中，首先，我们从 pdf2docx 模块中导入了 Converter() 类。在这之后，我们定义了两个变量来指定我们想要转换的 pdf 文件和结果 word 文件的文件和路径。对于当前实例，我们将muscles.pdf文件保存在保存 python 文件的同一个工作目录中。
接下来，我们创建了一个名为 cv_obj 的 Converter() 类的对象，我们在其中传递了 pdf_file 变量作为参数。然后对象利用【convert()方法转换文件。而且，在 convert() 方法内，我们传递了 docx_file 变量作为参数。
最后，我们利用 close() 方法关闭文件。接下来，运行 python 程序，它将创建一个名为 muscles.docx 的新 docx 文件，该文件也将包含 pdf 文件中的所有数据。
在 Python 中将 PDF 文件转换为 Docx 错误
现在，这里如果你也安装了 pdf2docx 版本 0.5.3 那么很有可能你这边的转换也失败了，它返回 " 转换失败 "。发生这种情况是由于 *try-except* 块在执行时引发了异常。
这里，如果我们去掉 *try-except* 块，然后执行程序，就会返回如下错误。
attribute 错误:“页面”对象没有属性“rotationMatrix”。你是说‘旋转矩阵’吗？
现在，要解决 Python 中的上述错误，我们需要遵循以下步骤。
- 首先，进入虚拟环境目录并转到以下文件夹。这里是我们这边的路径:“D:\ project \ myapp \ Lib \ site-packages”。除此之外，如果你没有使用过虚拟环境，你需要转到以下路径:C:\ users \ UserName \ appdata \ roaming \ python \ python 310 \ site-packages。
在第二个路径中，请正确插入您的用户名和 python 目录。
-
接下来，打开
pdf2docx目录，转到page目录，打开RawPage.py文件。 -
在文件中，转到行号为
279的行，在那里显示 element . set _ rotation _ matrix(self . fitz _ page。旋转矩阵。 -
现在，我们需要用
rotation_matrix替换rotationMatrix，然后保存并关闭文件。
Convert PDF file to Docx in Python Error
实现上述步骤后，我们可以利用前面的例子将 muscles.docx 文件转换成 muscles.docx 文件。这是我们实现 python 程序时，命令提示符的示例结果。
Example of Convert PDF file to Docx in Python
使用 parse()函数
与 Converter() 类不同，我们还可以利用 pdf2docx 模块中的 parse() 函数。而且我们可以直接用这个功能把 pdf 文件转换成 word 文档。
为了实现，我们可能需要使用以下语法的 parse() 函数。
parse(pdf_file_path, docx_file_path, start=page_no, end=page_no)
parse() 方法接受 4 个参数值，下面给出了与每个参数相关的解释。
pdf_file_path参数用于定义我们要转换的 pdf 文件的文件名和路径。docx_file_path参数用于定义我们希望在结果中出现的 word 文件的文件名和路径。- start 参数将用于指定 pdf 文件的起始页码，我们希望从这里开始转换。
- 最后，有一个 end 参数可以用来指定 pdf 文件的结束页码，该方法将转换指定范围内的页面。
接下来，为了理解上面的语法，让我们用 Python 执行一个示例。下面给出了该示例的代码。
# Importing the parse() function
from pdf2docx import parse
# Specifying the pdf & docx files
pdf_file = 'muscles.pdf'
docx_file = 'new_muscles.docx'
try:
# Converting PDF to Docx
parse(pdf_file, docx_file)
except:
print('Conversion Failed')
else:
print('File Converted Successfully')
在上面的例子中，首先我们从 pdf2docx 包中导入了 parse() 函数。之后，我们定义了两个变量，就像前面的例子一样，为 pdf 和 docx 文件指定文件名和路径。
接下来，我们利用了 parse() 函数，其中第一个参数是代表 pdf 文件的 pdf_file 变量，第二个参数是代表 docx 文件的 docx_file 。
此外，我们将这段代码保存在 *try-except-else* 块中，以处理任何时候出现的异常。但是，最后它会转换 muscles.pdf 的文件，生成*new _ muscles . pdf*文件。
*你可能也喜欢阅读下面的 Python 教程。
所以，在这个 Python 教程中，我们了解了如何在 Python 中将 PDF 文件转换成 docx。以下是我们在本教程中涉及的主题列表。
- “将 PDF 文件转换为 Python 中的 Docx”的先决条件
- Python 中的将 PDF 文件转换为 Docx 错误
- 使用 Converter()将 PDF 文件转换为 Python 中的 Docx
- 使用 parse()在 Python 中将 PDF 文件转换为 Docx
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
如何使用 Pyinstaller 将 Python 文件转换成 exe
原文：https://pythonguides.com/convert-python-file-to-exe-using-pyinstaller/
在这个 Python 教程中，我们将一步一步地看到如何使用 Pyinstaller 将 Python 文件转换成 exe。如果你想把 python 文件转换成 exe ，那么这篇文章会对你很有帮助。
目录
- 使用 pyinstaller 将 python 文件转换为 exe 文件
- 将 Python 文件转换成 exe windows
- 按照步骤从 python 创建 exe 文件(。py)文件【详细】
- 使用 NSIS 工具创建一个可安装包
- python 创建设置文件【一步一步】
使用 pyinstaller 将 python 文件转换为 exe 文件
最近，我们创建了一个应用程序，为即将离开组织的员工生成体验信。为此，我们使用 Python Tkinter 来创建表单。可以看看，用 Python Tkinter 创建 Word 文档。您也可以获得完整的源代码
我们已经创建了应用程序，但我们不能交付它，因为客户不知道 python 和其他编程相关的术语。对他们来说，创建并激活环境并每次运行应用程序并不容易。
所以我们决定给他们一个可以安装在系统上的程序的安装文件。在本教程中，我们将讨论如何将 python 转换为 exe 文件，然后创建一个可以安装的设置。
将 Python 文件转换成 exe windows
Pyinstaller 是一个 python 模块。py)可以转换成可执行文件(。exe)。
- 使用下面的命令在默认环境中直接安装 pyinstaller。
pip install pyinstaller
- 在虚拟环境中，使用相同的命令在虚拟环境中再次安装 pyinstaller。
- 这听起来可能有点混乱，但是在基本环境和虚拟环境中都安装 pyinstaller 是很重要的。
- 我们假设您已经按照我们博客中的建议准备好了应用程序文件夹—使用 python tkinter 创建 word 文件。
- 按照下面的命令来转换 python(。py)到可执行文件(。exe)在 python 中。
**# conversion with cmd console**
pyinstaller filename.py
**# conversion without cmd console**
pyinstaller --noconsole filename.py
- 一旦文件处理完成，你会看到新的文件夹创建。导航到
dist文件夹- >项目文件夹- >点击应用程序(。exe)文件。 - 起初，应用程序可能不会像预期的那样工作，粘贴所有的依赖关系，如图像、文本文件等。在项目文件夹中。
- 运行程序，你会看到程序是作为一个独立的应用程序运行。即使没有 python 的系统也能够执行这个程序。
- 如果你无法按照目前给出的说明操作，请按照下面的说明操作图片。
按照步骤从 python 创建 exe 文件(。py)文件【详细】
下图显示了生成体验信的应用程序文件。要了解我们是如何创建这个应用程序的，请访问我们的博客—使用 Python Tkinter 创建 Word 文件。
Step 1: Python project directory that we want to convert into exe
激活虚拟环境并在其中安装 pyinstaller。必须在通用环境和虚拟环境中安装 pyinstaller。否则，您的应用程序将无法访问安装在虚拟环境中的模块。
Step 2: Install Python Pyinstaller inside the virtual environment
使用 pyinstaller，您可以将 python 文件转换为 exe。键入py installer
Step3: Convert python file to exe using pyinstaller
执行上面的命令后，你会在同一个目录下创建几个新文件夹。这些文件夹中有关于转换的信息，打开 dist 文件夹访问转换后的文件。
Step 4: Move dependencies inside the dist folder
在 dist 文件夹中，有另一个文件夹与那个 py 文件同名。假设在转换时 python 文件名是 main.py，那么这个文件夹名将是 main。
在下一节中，我们将使用这个文件夹来创建一个安装文件使用 NSIS 工具。
Step 5: Exe file is created inside the main folder
在主文件夹中，您将看到该应用程序中使用的所有文件和依赖项。在那里，您将看到一个与 python 文件同名的. exe 文件。在执行程序之前，在这个主文件夹中添加文件和输出文件夹。
Step 6: Python file converted to exe file
使用 NSIS 工具创建一个可安装包
这部分是关于 NSIS 工具的，使用它我们可以在一个文件下创建一个所有依赖项的包。
- 从上面提到的链接下载软件并启动软件。
- 将我们在上一节准备的文件夹转换成 zip 文件。
- 在 NSIS 工具上点击安装程序。zip 文件，在提示符下从您的计算机中选择 ZIP 文件，然后点击左下角的生成按钮。
- 等待一段时间，一旦完成关闭软件，导航到文件夹，你会看到一个磁盘形状的文件。
- 您的文件已准备好，您可以与其他人共享。
- 如果这些步骤的总结对你没有帮助，下面我们用图片详细解释了每个步骤。
python 创建设置文件【一步一步】
在上一节中，我们已经提到了主文件夹。此文件夹将用于创建 Python 中的应用程序-体验信函生成器的设置文件。
如果你遵循了上面的部分，这意味着你已经在这个主文件夹中添加了文件和输出文件夹。现在将它们转换成 zip 文件。
Step 7: Convert the python software folder into a zip file
打开 NSIS 软件，点击‘安装程序基于’。zip 文件'-->在提示中，通过单击打开按钮选择 zip 文件，选择 ZIP 文件后，单击生成按钮。我们已经标出了每一步的顺序。
Step 8: Convert exe to installable package using NSIS tool
单击“生成”按钮后，需要一些时间来创建可安装的安装文件。完成后，您将看到如下窗口。单击关闭按钮关闭窗口。
Step 8: Exe converted to installable package with all dependencies
恭喜成功转换 python(。py)文件转换为可执行文件(。exe)。以及将可执行文件打包成可安装的安装文件。在下图中，标记的图像显示了安装文件。你可以在你的系统中安装这个文件。
Setup file ready for installation on windows
至此，我们完成了将 python 文件转换成可执行文件的项目。该文件已准备好与朋友、家人和客户共享。
相关 Python 教程:
- Python Tkinter Validation
- Python Tkinter Scale
- Python Tkinter 通断开关
- Python Tkinter 多窗口教程
- Python Tkinter 动画
- Python Tkinter 表教程
我们希望这个教程，能帮助你把 python 文件转换成 exe 文件。这就是如何使用 Pyinstaller 将 Python 文件转换成 exe。如果您遇到任何问题，请写信告诉我们确切的错误信息。
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
在 Python 中把字符串转换成浮点数+各种例子
原文：https://pythonguides.com/convert-string-to-float-in-python/
在这个 python 教程中，你将学习如何在 python 中转换字符串为浮点数，我们还将检查 :
- 如何将字符串转换为浮点 python
- 如何在 python 中将字符串转换成浮点列表
- 如何将逗号分隔的字符串转换为浮点 python
- 如何在 python 中将输入字符串转换成浮点数
- 将字符串列表转换为浮点 python
- python 中如何将字符串数组转换为浮点数组
- 如何在 python 中使用 NumPy 将字符串转换为浮点
- 如何在 python 中将带逗号的字符串转换成浮点数
- 如何在 python 中将带小数的字符串转换成浮点数
- 如何在 python 中将带字母的字符串转换成浮点数
- 如何在 python 中将空字符串转换为浮点数
目录
- 如何将 string 转换成 float python
- 如何在 python 中把字符串转换成浮点列表
- 如何将逗号分隔的字符串转换成浮点 python
- 如何在 python 中把输入字符串转换成浮点数
- 将字符串列表转换为浮点 python
- python 中如何将字符串数组转换成浮点数组
- 如何在 python 中使用 numpy 将 string 转换为 float
- 如何在 python 中将带逗号的字符串转换成浮点数
- 如何在 python 中把带小数的字符串转换成浮点数
- 如何在 python 中把带字母的字符串转换成浮点数
如何将 string 转换成 float python
让我们看看如何在 python 中将 string 转换成 float。
在这个例子中，我们将使用 python 中内置的 float() 函数将 string 转换为 float。
举例:
str = '15.456'
f = float(str)
print('Float Value =', f)
你可以参考下面的截图来看看如何将 string 转换成 float python 的输出。
How to convert string to float python
上面的代码我们可以用 python 把 string 转换成 float。
如何在 python 中把字符串转换成浮点列表
在这里，你将看到如何在 python 中将字符串转换成浮点列表。
首先，我们需要初始化字符串，然后我们将使用 float() 和 split() 方法来执行任务。在下面的例子中，我们已经将字符串转换成了一个浮点列表。
举例:
my_str = "3.44, 7.8, 9.12, 100.2, 6.50"
result = [float(val) for val in my_str.split(', ')]
print("The float list is : " + str(result))
你可以参考下面的截图来看看如何在 python 中将字符串转换成浮点列表的输出。
How to convert string to float list in python
这是如何在 python 中将字符串转换为浮点列表。
读取: Python 将字符串写入文件
如何将逗号分隔的字符串转换成浮点 python
在这里，我们将看到如何将逗号分隔的字符串转换成浮点 python 。
在这个例子中，我们有一个字符串 '345，567，891.809' ，它包含数字，并且我们还有一些额外的逗号。在这里，我们将使用。在将字符串传递给浮点函数之前，替换('，'，" ")以删除字符串中的所有逗号。
举例:
str = '345,567,891.809'.replace(',', '')
print(float(str))
你可以参考下面的截图来看看如何将逗号分隔的字符串转换成浮点 python 的输出。
How to convert comma separated string to float python
在这里，我们知道，如何将逗号分隔的字符串转换为浮点 python。
如何在 python 中把输入字符串转换成浮点数
现在，我们将看到如何在 python 中将输入字符串转换成浮点数。
为了在 python 中将输入字符串转换为 float，我们将首先从用户处获取输入，并使用 float() 方法进行转换。
举例:
x = float(input("Enter the String:"))
print(x)
你可以参考下面的截图来看看如何在 python 中将输入字符串转换成浮点型的输出。
How to convert input string to float in python
上面的 python 代码，我们可以用 Python 把输入的字符串转换成浮点数。
阅读: Python 生成随机数和字符串
将字符串列表转换为浮点 python
让我们看看如何将字符串列表转换成浮点 python 。
在这个例子中，我们将将一个字符串列表转换为 float ，并且我们将使用一个 for 循环来遍历整个列表。此外，我们将把转换后的项目追加到一个新列表中。
举例:
str = ['1.1', '2.2', '3.3', '3.4']
l_floats = []
for item in str:
l_floats.append(float(item))
print(l_floats)
你可以参考下面的截图来看看如何将字符串列表转换成浮动 python 的输出。
Convert list of string to float python
这就是如何将字符串列表转换成浮点 python 。
python 中如何将字符串数组转换成浮点数组
现在，我们将看到如何在 python 中将字符串数组转换成浮点数组
首先，我们需要将 numpy 作为 np 导入。 asarray() 是一个 numpy 函数，它将字符串数组转换成 python 中指定类型的浮点数组。
举例:
import numpy as np
str_array = np.array(["10.22", "11.23", "20.55", "89.67"])
f_array = np.asarray(str_array, dtype = float)
print(f_array)
你可以参考下面的截图来看看如何在 python 中将字符串数组转换成浮点数组的输出
How to convert string array to float array in python
上面的 python 代码，我们可以用 python 把字符串数组转换成浮点数组。
如何在 python 中使用 numpy 将 string 转换为 float
在这里，我们将看到如何使用 numpy 在 python 中将 string 转换为 float。
首先，我们需要将 numpy 作为 np 导入。 astype 是 numpy 的内置类函数，用于使用 numpy 将 python 中的 string 转换为 float。
举例:
import numpy as np
str_array = np.array(["1.267", "1.456", "0.012"])
f_array = str_array.astype(float)
print(f_array)
你可以参考下面的截图来看看如何使用 numpy 在 python 中将 string 转换成 float 的输出。
How to convert string to float in python using numpy
上面的 python 代码我们可以用 numpy 在 python 中用把 string 转换成 float。
阅读: Python 程序反转字符串示例
如何在 python 中将带逗号的字符串转换成浮点数
现在，我们将看到如何在 python 中将带逗号的字符串转换成浮点数
在这个例子中，我们有一个字符串 '20，188.23' ，它包含数字，并且我们还有单个逗号。在这里，我们将使用。替换('，'，" ")以在将字符串传递给浮点函数之前删除字符串中的逗号。
val = '20,188.23'
res = float(val.replace(',', ''))
print(res)
你可以参考下面的截图来看看如何在 python 中将带逗号的字符串转换成浮点数的输出。
How to convert a string with comas to a float in python
这就是如何在 python 中将带逗号的字符串转换成浮点数。
阅读: Python 字符串格式化示例
如何在 python 中把带小数的字符串转换成浮点数
让我们看看如何在 python 中将带小数的字符串转换成浮点数。
首先，我们需要从 decimal import * 中导入，然后我们将使用 Decimal() 模块。为了得到输出，我们将使用打印(val)** 。**
举例:
from decimal import *
val = Decimal('2.05')
print(val)
你可以参考下面的截图来看看如何在 python 中将带小数的字符串转换成浮点数的输出。
How to convert string with decimal to float in python
上面的代码是用来在 python 中将带十进制的 string 转换成 float 的。
阅读 Python 字典扩展
如何在 python 中把带字母的字符串转换成浮点数
现在，我们将看到如何在 python 中将带字母的字符串转换成 float。
为了在 python 中将带有字母的字符串转换为浮点型，我们将使用在T5 分割字符串，然后我们必须将第二个子字符串转换为浮点型。
举例:
str = "Rate: £1000.6"
res = float(str.split("£")[1])
print(res)
你可以参考下面的截图来看看如何在 python 中将带字母的字符串转换成浮点数的输出。
How to convert string with letters to float in python
这是在 python 中将带字母的字符串转换为浮点数的 python 代码。
您可能会喜欢以下 Python 教程:
- 如何在 python 中连接字符串
- 如何在 Python 中将字典转换成字符串
- 如何将 Python 字符串转换成字节数组并举例
- 如何在 Python 中把字符串转换成日期时间
- 无法将字符串转换为浮点 Python
- Python 将字典转换为列表
在这篇 Python 教程中，我们学习了如何将 string 转换成 float python 。此外，我们还讨论了以下主题:
- 如何将字符串转换为浮点 python
- 如何在 python 中将字符串转换成浮点列表
- 如何将逗号分隔的字符串转换为浮点 python
- 如何在 python 中将输入字符串转换成浮点数
- 将字符串列表转换为浮点 python
- python 中如何将字符串数组转换为浮点数组
- 如何在 python 中使用 numpy 将字符串转换为浮点数
- 如何在 python 中将带逗号的字符串转换成浮点数
- 如何在 python 中将带小数的字符串转换成浮点数
- 如何在 python 中将带字母的字符串转换成浮点数
- 如何在 python 中将空字符串转换为浮点数
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
如何将张量流转换为一个热|一个热编码张量流示例
你知道怎么把 TensorFlow 转换成 one hot 吗？让我们讨论和理解张量流张量将如何转化为一个热点。我们还将介绍一个热编码张量流示例。
- 转换成一个热张量流
- 如何将一个 hot 转换成整数 TensorFlow？
- 一个热编码张量流示例
- 将张量转换为列表张量流
- 将张量转换为 int 张量流
目录
转换成一个热张量流
- 这里我们将讨论把输入张量转换成一个热张量流。
- 一个热编码是将分类数据中的变量转换为机器和深度学习算法的关键过程，可以提高预测和模型分类的准确性。
- 在一键编码中，用二进制变量(或者更准确地说，向量)代替只能取值为 0 或 1 的类别变量。
- 本质上，我们是在陈述特定类别的特定项目是否存在。对于每个数据条目和反映其分类的列，都会创建新行。1 和 0 用来表示他们的存在或不存在。
语法:
让我们看一下语法并理解 Python TensorFlow 中的 tf.one_hot() 函数的工作原理
tf.one_hot(
indices,
depth,
on_value=None,
off_value=None,
axis=None,
dtype=None,
name=None
)
- 它由几个参数组成
- 指标:该参数定义了指标的张量。
- 深度:指示热尺寸深度的标量。
on_value:默认情况下，它采用 none value 一个标量，指定当索引[j] = i 时使用的输出值。off_value:默认情况下，它采用 none value 一个标量，指定当索引[j] = i 时使用的输出值。- 轴:该参数定义填充内外零件的轴。
dtype:默认情况下，不取值，指定输出张量的数据类型。name:该参数指定操作的名称，默认情况下，取值为 none。
举例:
import tensorflow as tf
indices_value = [15, 28, 9,13]
new_val = 5
new_output=tf.one_hot(indices_value, new_val)
print(new_output)
在上面的代码中，我们导入了 TensorFlow 库，然后初始化了一个列表，在其中我们分配了索引号。
之后，我们使用了 tf.one_hot() 函数，在这个函数中，我们将索引和深度作为参数传递。它将返回列表和索引的形状。
下面是以下代码的截图
Convert to one hot tensorflow
这就是如何将张量转换为 TensorFlow 中的一个 hot。
如何将一个 hot 转换成整数 TensorFlow
- 在本节中，我们将讨论如何在 Tensorflow 中将一个 hot 转换为整数张量。
- 为了执行这个特定的任务，我们将使用
tf.argmax()函数，它将返回张量元素集中最大元素的索引。如果张量是二维的，则有可能返回跨行和列的最大值的索引。
语法:
下面是 Python TensorFlow 中 tf.argmax() 函数的语法
tf.math.argmax(
input,
axis=None,
output_type=tf.dtypes.int64,
name=None
)
- 它由几个参数组成
- 输入:该参数定义了输入张量。
- 轴:默认为 0，是我们要减少的轴的整数。
output_type:默认取tf.dtypes.int64()，可选数据类型。name:该参数指定操作的名称，默认情况下，取值为 none。
举例:
import tensorflow as tf
tf.compat.v1.disable_eager_execution()
number_of_batch = 3
number_of_shape = 4
encoded_tensor = tf.constant([[1, 0, 1, 0],
[0, 1, 0, 0],
[0, 0, 0, 1]])
result = tf.argmax(encoded_tensor, axis=1)
with tf.compat.v1.Session() as val:
new_output=val.run(result)
print(new_output)
首先，我们在下面的代码中创建了一个具有批量大小和类的 one_hot 张量。接下来，我们使用了 tf.argmax() 函数，并沿着轴分配编码的张量。它将返回张量元素集中最大元素的索引。
下面是以下给定代码的实现
How to Convert one hot to integer tensorflow
正如你在截图中看到的，我们已经在 TensorFlow 中将一个 hot 转换为一个整数。
一个热编码张量流示例
- 让我们讨论一下如何在 Python TensorFlow 中使用 one-hot 编码函数。
- 为了完成这个任务，我们将使用
tf.one_hot()函数，它将把随机数转换成二进制整数。 - 在本例中，我们通过导入
TF . compat . v1 . disable _ eager _ execution()函数创建了会话。 - 接下来，我们将在列表中声明索引号，然后我们将使用
tf.one_hot()函数，并将索引和深度轴指定为参数。
举例:
import tensorflow as tf
tf.compat.v1.disable_eager_execution()
indices_val = [1,8,2,3,1]
input_tensor = tf.constant(4)
result = tf.one_hot(indices_val, input_tensor,on_value=1.0,off_value=0.0, axis =-1)
with tf.compat.v1.Session() as val:
new_output=val.run(result)
print(new_output)
你可以参考下面的截图
One hot encoding tensorflow example
将张量转换为列表张量流
- 在本节中，我们将讨论如何在 Python TensorFlow 中将张量转换为列表。
- 在本例中，我们将使用
TF . compat . v1 . disable _ eager _ execution()来运行会话。为了将张量转换成一个列表，首先我们将导入 eager_execution 函数和 TensorFlow 库。 - 接下来，我们将使用
tf.constant()函数创建常量值，然后我们将使用eval()函数中的语法session = TF . compat . v1 . session()运行会话。
举例:
import tensorflow as tf
tf.compat.v1.disable_eager_execution()
new_val = tf.constant([[178,267,189],[34,20,189]])
new_result = new_val.eval(session=tf.compat.v1.Session()).tolist()
new_result
下面是以下给定代码的执行过程
Convert tensor to list tensorflow
这就是如何在 TensorFlow 中将张量转换成 Python 列表
将张量转换为 int tensorflow
- 在本节中，我们将讨论如何在 Python TensorFlow 中将张量转换为整数。
- 为了完成这项任务，我们将使用
tf.cast()函数，该函数用于将输入数据类型转换为不同的数据类型。 - 例如，您已经创建了一个输入张量，并按照浮点的顺序分配了元素，现在您想将浮点转换为十进制。为此，我们将使用
tf.cast()函数。
举例:
import tensorflow as tf
# Creation of tensor by using the tf.constant() function
input_tensor = tf.constant([16.98, 23.2], dtype=tf.float32)
result=tf.cast(input_tensor, tf.int32)
# Display the Content
print(result)
下面是以下给定代码的实现
Convert tensor to int tensorflow
正如你在截图中看到的，我们已经在 TensorFlow 中将张量转换为整数。
在本文中，我们讨论了如何将 TensorFlow 转换为 one hot。让我们讨论和理解张量流张量将如何转化为一个热点。我们还讨论了以下主题。
- 转换成一个热张量流
- 如何将一个 hot 转换成整数 tensorflow？
- 一个热编码张量流示例
- 将张量转换为列表张量流
- 将张量转换为 int 张量流
您可能还会喜欢以下 Tensorflow 教程:
- 将 pandas 数据帧转换为 tensorflow 数据集
- Tensorflow 将稀疏张量转换为张量
- 模块“tensorflow”没有属性“optimizer”
- 模块“tensorflow”没有属性“div”
- 模块“tensorflow”没有属性“sparse _ placeholder”
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
在 Python 中将元组转换为字符串
原文：https://pythonguides.com/convert-tuple-to-string-in-python/
在本 Python 教程中，我们将讨论在 Python 中 将 tuple 转换为 string 的不同方法。我们都知道一个元组在一个变量中存储几个条目。它也是一个固定的、组织良好的数据集合。
而字符串是用单方括号或双方括号括起来的一组字符。
- 如何使用 join()方法在 Python 中将元组转换为字符串
- 使用 for 循环将元组转换为 Python 中的字符串
- 如何使用 reduce()方法在 Python 中将 tuple 转换成 string
- 如何在 Python 中用逗号将元组转换成字符串
- Python 中带空格的元组到字符串的转换
目录
- 在 Python 中把元组转换成字符串
- 如何使用 join()方法在 Python 中将 tuple 转换成 string
- 使用 for 循环将元组转换成 Python 中的字符串
- 通过使用 reduce()方法
- 如何在 Python 中用逗号将元组转换成字符串
- 在 Python 中将元组转换成带空格的字符串
在 Python 中把元组转换成字符串
术语“将元组转换成 Python 中的字符串”指的是将所有元素连接在一起以创建单个字符串的过程。
在 Python 中，在将元组转换为字符串时，主要有三种常用且重要的理解方法。下面给出的方法将用于将元组转换为字符串。
- 通过使用 join()方法
- Reduce()方法
- for 循环方法
如何使用 join()方法在 Python 中将 tuple 转换成 string
- 使用
str.join()函数，我们可以将一个 Python 元组变成一个 Python 字符串。stringjoin()方法将一个 iterable 中的字符串连接起来，比如一个元组、列表、字典或集合，并返回一个字符串。 - 由于这个实例中的 iterable 是一个元组，返回字符串的
join()方法将接受元组作为参数。
语法:
让我们看一下语法，了解一下 Python 中 str.join() 的工作原理。
str.join(iterable)
如果 iterable 中存在任何非字符串值，join()方法将产生 TypeError。
注意:该参数定义了类似元组的可迭代对象。
举例:
让我们举一个例子，检查如何使用 join() 方法在 Python 中将元组转换为字符串。
Country_name = ('U.S.A', 'Australia', 'China', 'Belgium')
separator = ', '
new_str = separator.join(Country_name)
# Printing the results
print("Input tuple: ", Country_name)
print("Resultant Python string: ", new_str)
print(type(new_str))
下面是以下给定代码的实现
By using the join method converted tuple to list
这就是如何使用 join()方法在 Python 中将元组转换为字符串。
使用 for 循环将元组转换成 Python 中的字符串
- 在这里，我们将讨论如何使用 for 循环将元组转换为 Python 中的字符串
- 可以使用简单的 for 循环迭代整个元组的元素，然后将元素追加到字符串中。
- 使用了元组和空字符串。此外，空字符串被遍历以包含元组的每个元素。
举例:
让我们举一个例子，看看如何使用 for 循环在 Python 中将元组转换成字符串。
Country_name = ("United States of America")
new_string = ''
for i in Country_name:
new_string = new_string + i
print(new_string)
你可以参考下面的截图
Iterating values for tuples and converting them into a string
正如你在截图中看到的，我们已经讨论了如何迭代元组的值，并将它们转换成字符串。
通过使用 reduce()方法
- 在 Python 中，函数和 iterable(如 tuple)分别是 reduce()函数的第一个和第二个参数。
- 然后，在返回由该函数取出的操作的输出之前，将该函数应用于 iterable 对象的每个元素。
- 由于 functools 模块，高阶函数可以与其他函数交互。
举例:
这里我们将举一个例子，并检查如何使用 reduce()方法在 Python 中将元组转换为字符串。
源代码:
import functools
import operator
Cars_in_USA = ("Ford F-150, Chevrolet Silverado 1500")
# By using the reduce() function
new_result = functools.reduce(operator.add, (Cars_in_USA))
print ("Converted input tuple to string :",new_result)
下面是下面给出的代码的截图。
How to convert tuple to string in Python by using the reduce method
这就是我们如何通过使用 Python 中的 reduce 方法将元组转换为字符串。
如何在 Python 中用逗号将元组转换成字符串
- 在这一节中，我们将讨论如何在 Python 中将元组转换为带有逗号分隔符的字符串。
- 为了执行这个特定的任务，我们将使用 join 方法和 string
join()方法的概念，将一个 iterable 中的字符串连接起来，比如一个元组、列表、字典或集合，并返回一个字符串。 - Python 的 join()函数通过将给定 iterable 中的其他字符串连接在一起来生成一个新字符串，它返回该字符串并将接受元组作为参数。
举例:
**# Creation of input tuple**
state_name_in_USA = ('Alaska', 'Georgia', 'Iowa','Missouri')
**# Assign the ',' comma delimiter**
comma_delim = ','
result= comma_delim.join(state_name_in_USA)
**# Display the Content**
print("Converted tuple into a string :", result)
在下面给出的代码中，我们首先创建了一个输入元组，并在括号内分配元素。输入字符串被命名为“美国州名”。
现在，我们希望在将元组转换为字符串时使用逗号作为分隔符。为此，我们声明了一个变量，并将分隔符存储为逗号。
下面是以下给定代码的执行。
How to convert tuple to string in Python with a comma
在这个例子中，我们已经理解了如何在 Python 中将元组转换成带逗号的字符串。
在 Python 中将元组转换成带空格的字符串
- 这里我们将讨论如何在 Python 中将元组转换成带空格的字符串。
- 通过使用 join()，我们可以将元组的字符追加到字符串中，在本例中，我们将把空格放入输入字符串中。
- 首先，我们将获取一个输入元组，并将字符串元素分配给它。现在，通过使用空格作为分隔符和 join()方法，我们可以很容易地将元组转换成字符串。
举例:
让我们举个例子，看看如何在 Python 中将 tuple 转换成带空格的字符串。
Country_name = ("United", "States", "of", "America")
# Using whitespace as a delimiter
new_string = " "
# By using the join() method
result= new_string.join(Country_name)
# Display the Content
print(result)
下面是下面给出的代码的截图。
Use white spaces as a delimiter to convert the tuple into a string
你可能也喜欢阅读下面的 Python 教程。
- 如何在 Python 中将元组列表转换成字符串
- 如何用 Python 将列表追加到另一个列表中
- 如何在 Python 中从列表中找到一个字符串
- 使用 For 循环对 Python 中的列表元素求和
- 在 Python 中的数据帧中添加空列
- 如何在 Python 中寻找完全数
在本教程中，我们讨论了如何在 Python 中将元组转换为字符串。我们还讨论了以下给定的主题
- 如何使用 join()方法在 Python 中将元组转换为字符串
- 使用 for 循环将元组转换为 Python 中的字符串
- 如何使用 reduce()方法在 Python 中将 tuple 转换成 string
- 如何在 Python 中用逗号将元组转换成字符串
- Python 中带空格的元组到字符串的转换
Arvind 目前是 TSInfo Technologies 的高级 Python 开发人员。他精通 Python 库，如 NumPy 和 Tensorflow。
无法将字符串转换为浮点型 Python
原文：https://pythonguides.com/could-not-convert-string-to-float-python/
在本 Python 教程中，我们将讨论如何修复一个错误，“无法将字符串转换为浮点型 Python ”。
目录
无法将字符串转换为浮点 python
在 python 中，要将字符串转换成浮点型，我们可以使用 float() 方法。它只能将有效的数值转换为浮点值，否则会抛出错误。
举例:
my_string = '1,400'
convert = float(my_string)
print(convert)
写完上面的代码(无法将字符串转换为浮点 python)，你将打印出 " convert " ，然后输出将显示为 " ValueError:无法将字符串转换为浮点:' 1，400' " 。
在这里，我们得到了错误，因为该值是无效的，我们使用了逗号。你可以参考下面的截图无法将字符串转换为浮点型 python。
Could not convert string to float python
要解决这个值错误:无法将字符串转换为浮点型我们需要使用 float() 方法给出有效的数值来将我的字符串转换为浮点型。
举例:
my_string = '23.8'
convert = float(my_string)
print(convert)
写完上面的代码(无法将 string 转换成 float python)，你将打印出“convert”，然后输出将显示为“23.8”。这里，float()方法将字符串转换为浮点型。你可以参考下面的截图无法将字符串转换为浮点型 python。
Could not convert string to float python
这是如何修复无法将字符串转换为浮点 python 的问题。
阅读: Python 在字符串中查找子串
如何修复无法将字符串转换为浮点型 python
让我们看看如何修复无法将字符串转换为浮点型 python
在这个例子中，我们得到了一个 ValueError ，因为函数参数的类型不合适。因此，当我们试图对一个字符串值进行类型转换时，它会抛出 ValueError。
举例:
str = "Hi"
print(float(str))
python 中的 float() 函数不支持普通文本。关于错误，可以参考下面的截图。
How to fix could not convert string to float python
要修复值错误: 无法将字符串转换为浮点型 python ，我们必须给出数字文本值才能将其成功转换为浮点型。我们可以使用下面的代码来解决上面的错误。
举例:
str = "5.45"
print(float(str))
你可以参考下面的截图来查看如何修复无法将字符串转换为浮点 python 的输出。
How to fix could not convert string to float python
您可能会喜欢以下 Python 教程:
这里我们检查了如何修复错误，无法将字符串转换为浮点 python 。
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
计算熊猫数据框中的行数
在这个 Python Pandas 教程中，我们将学习 Python Pandas 数据帧中的计数行。此外，我们将涵盖这些主题。
- 计算熊猫数据框中的行数
- 熊猫数据帧中的计数条目
- 计算 Pandas 数据帧中的重复行
- 计算熊猫数据帧中不同的行
- 计算熊猫数据帧中的唯一行
- 计算满足条件的熊猫数据帧中的行数
- 熊猫 df 中的计数记录
- 熊猫系列中的行数
目录
计算熊猫数据帧中的行数
在这一节中，我们将学习如何计算 Pandas 数据帧中的行数。
- 使用 Python Pandas 中的 count()方法，我们可以对行和列进行计数。
- 计数方法需要轴信息，列的轴=1，行的轴=0。
- 要计算 Python Pandas 中的行数，请键入
df.count(axis=1)，其中 df 是数据帧，axis=1 表示列。
df.count(axis=1)
在 Jupyter 笔记本上实现
如何用 Python 从一个列表创建一个字典
原文：https://pythonguides.com/create-a-dictionary-from-one-list-in-python/
在这个 Python 教程中，我们将学习如何从一个列表中创建一个 Python 字典。为了理解各种方法，我们将使用一些内置函数从一个 Python 列表创建一个字典。
作为一名开发人员，在制作 Python 项目时，我需要从一个 Python 列表中创建一个字典。
在这里我们将看到:
- 如何使用字典理解从 Python 中的一个列表创建一个字典
- 使用 zip()从 Python 中的一个列表创建一个字典
- 如何使用 dict.fromkeys()在 Python 中从一个列表创建一个字典
- 使用枚举器()从 Python 中的一个列表创建一个字典
- 如何使用元组从 Python 中的一个列表创建字典
- 使用计数器()从 Python 中的一个列表创建一个字典
目录
- 用 Python 从一个列表中创建一个字典
- 如何使用字典理解从 Python 中的一个列表创建字典
- 使用 zip() 从 Python 中的一个列表创建一个字典
- 如何使用 dict.fromkeys() 在 Python 中从一个列表创建字典
- 使用枚举器()从 Python 中的一个列表创建一个字典
- 如何使用元组从 Python 中的一个列表创建字典
- 使用 counter()从 Python 中的一个列表创建一个字典
用 Python 从一个列表中创建一个字典
在 Python 中，有许多创建字典的方法。我们将详细介绍如何利用字典理解方法和 zip 方法从 Python 中的一个列表创建字典。
如何使用字典理解从 Python 中的一个列表创建字典
- 在这一节中，我们将讨论如何使用字典理解从 Python 中的一个列表创建一个字典。
- 使用这种技术，我们遍历提供的 Python 列表，并在花括号内创建相应的 key: value。每个列表元素都变成了一个字典键，基于字典的理解，我们可以为每个键生成值。
- 用户可以像使用列表理解一样使用 Python 中的字典理解。通过使用内置技术的简单表达式，用户可以生成字典。
语法:
让我们来看看句法，了解字典理解的工作原理
{key: 'value' (value for (key, value) in iterable form)
举例:
让我们举一个例子，看看如何使用字典理解从 Python 中的一个列表创建一个字典。
源代码:
**#Creating a list**
Country_name = ['U.S.A', 'Australia', 'Germany', 'China','Argentina']
print("Input Python list: ", Country_name)
**#Dictionary Comprehension**
new_dict = {key: "47" for key in Country_name}
**# Display the Content**
print("Generated Python dictionary: ", new_dict)
在下面的代码中，我们首先创建了一个名为“Country_name”的列表，然后使用了字典理解方法。
下面是以下给定代码的实现
How to create a dictionary from one list in Python using dictionary comprehension
阅读: Python 字典方法
使用 zip() 从 Python 中的一个列表创建一个字典
- 现在让我们看看如何使用 zip()从 Python 中的一个列表创建一个字典。
- 这两个迭代器使用 zip()函数组合在一起。我们必须首先创建一个迭代器，将其初始化为任何变量，然后将其类型转换为 dict()方法。
- 首先在这个例子中，我们将使用 iter()方法声明一个迭代器，它将迭代列表中的值。
- 之后，我们将利用 Python zip()函数通过实际压缩两个对象来创建相应的 key: value。
语法:
下面是 Python 中 zip()方法的语法
zip(*iterables)
注意: Zip 可以接受各种 iterable 作为参数，用*表示，iterable 可以是一个列表。
举例:
这里我们将举一个例子，看看如何使用 zip()从 Python 中的一个列表创建一个字典。
源代码:
# Creating a list
States_in_USA = ['Arkansas',71601, 'California',90001, 'Colorado', 80001]
# Display the list
print("Input list :",States_in_USA)
# Decalring an iterator for list 'States_in_USA'
iterable = iter(States_in_USA)
# Using the Python zip() function to create a dictionary from input list
new_output = dict(zip(iterable, iterable))
# Display the result
print("Created dictionary :", new_output)
在上面的代码中，我们首先创建了一个输入列表，然后使用 iter()方法迭代列表中的值。之后，我们使用 zip()方法组合迭代器，并通过使用 dict()方法将它们转换成字典。
下面是下面给出的代码的截图。
Create a Dictionary from one list in Python using a zip
阅读: Python 集合字典
如何使用 dict.fromkeys() 在 Python 中从一个列表创建字典
- 这里我们将讨论如何使用
dict.fromkeys()在 Python 中从一个列表创建一个字典。 dict.fromkeys()方法使用作为键提供的 iterable(字符串、列表、集合或元组)和指定的值构建一个新的字典。- 它将接受一个序列(列表)作为输入，以及一个值，这将使我们能够映射序列与值。如果没有给它赋值，它将返回一个值为“None”的字典
语法:
让我们看一下语法并理解 dict.fromkeys()方法的工作原理。
dictionary.fromkeys(sequence, value)
- 它由几个参数组成
- sequence: 一个序列或 iterable，其元素将作为新字典的键。
- value: 可选参数，默认不取值。
举例:
让我们举一个例子，看看如何使用 dict.fromkeys() 在 Python 中从一个列表创建一个字典。
源代码:
**# Create a list as a state in U.S.A**
State_name = ["Alabama", "California", "Florida", "Hawaii"]
**# Declare value**
Country_name = "U.S.A"
**# By using dict.fromkeys() method**
new_result = dict.fromkeys(State_name, Country_name)
**# Display the dictionary**
print("Created a Dictionary :",new_result)
在这个例子中，我们使用了 dict.fromkeys()方法的概念，把输入列表转换成一个字典。
你可以参考下面的截图。
How to create a dictionary from one list in Python using dict.fromkeys
阅读: Python 字典多值
使用枚举器()从 Python 中的一个列表创建一个字典
- 在本节中，我们将讨论如何使用枚举器()从 Python 中的一个列表创建一个字典。
Enumerate()是一个内置的 Python 函数，通过 Python 库访问。它接受一个集合或元组作为输入，并将其作为枚举对象返回。- 这个 enumerate()函数可以在循环中立即使用，使用 dict 方法将我们的列表转换成字典。
语法:
下面是 Python 中 enumerate() 方法的语法
enumerate(iterable, start=0)
- 它由几个参数组成
- iterable: 可以循环的对象。
- start: 默认情况下，循环中的第一项取 0 值，计数将从 startIndex 中指定的值开始，随后每增加一项，直到循环结束。
举例:
这里我们将举一个例子，看看如何使用枚举器()从 Python 中的一个列表创建一个字典。
源代码:
**# Create a list**
Country_name = ['U.S.A', 'Australia', 'Germany', 'China','Argentina']
**# Enumerate method**
new_val = enumerate(Country_name, 3)
**# Dict method**
new_result = dict(new_val )
**# Display the Content**
print(new_result )
在上面的代码中，我们首先创建了名为的输入列表，在生成枚举对象后，我们必须将其转换为字典，以便将列表转换为字典。我们可以利用类型转换函数将枚举对象转换成字典。
下面是以下给定代码的实现。
Create a Dictionary from one list in Python using an enumerator
阅读: Python 列表字典
如何使用元组从 Python 中的一个列表创建字典
- 现在让我们看看如何使用元组从 Python 中的一个列表创建一个字典。
- 这里，我们将首先生成一个元组列表，其中每个元组都有(key，value)元素，然后使用 dict 函数将元组列表转换为一个字典。
举例:
让我们举一个例子，看看如何使用元组从 Python 中的一个列表创建一个字典。
源代码:
**# Declare a list of tuple**
Country_name = [(67, 'U.S.A'), (25, 'France'), (96, 'Germany'),
(15, 'Australia'), (34, 'China')]
dict_store = {}
**# By using type casting method**
dict_store = dict(Country_name)
**# Display the Content**
print("Created Dictionary :", dict_store)
在上面的代码中，我们首先声明了一个元组列表，然后使用 dict()方法将它们转换成一个字典。执行代码后，输出显示字典。
你可以参考下面的截图
How to create a dictionary from one list in Python using a tuple
使用 counter()从 Python 中的一个列表创建一个字典
- 在这一节中，我们将讨论如何使用
counter()从 Python 中的一个列表创建一个字典。 - 使用 Python 集合模块中的
Counter()方法，我们将使用该方法将列表转换为字典。 - 计数器是一个无序的集合，其中的元素存储为 Dict 键，计数存储为 Dict 值。计数器项目的计数可以是正、零或负的整数。
举例:
这里我们将举一个例子，并检查使用计数器()从 Python 中的一个列表创建一个字典。
源代码:
from collections import Counter
# Creation of input list
bikes_in_USA = ['Harley Davidson', 'Confederate', 'Motus MSTR', 'Alta Motors Redshift']
new_result = Counter(bikes_in_USA)
print(new_result)
# Convert list into dictionary by using dict() method
new_dict = dict(new_result)
# Display the Content
print("Generated Dictionary :",new_dict )
下面是以下代码的截图
Create a Dictionary from one list in Python using a counter
另外，看看更多的 Python 教程。
在本文中，我们已经了解了如何用 Python 从一个列表创建一个字典。我们还讨论了以下给定的主题。
- 如何使用字典理解从 Python 中的一个列表创建一个字典
- 使用 zip()从 Python 中的一个列表创建一个字典
- 如何使用 dict.fromkeys()在 Python 中从一个列表创建一个字典
- 使用枚举器()从 Python 中的一个列表创建一个字典
- 如何使用元组从 Python 中的一个列表创建字典
- 使用计数器()从 Python 中的一个列表创建一个字典
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
什么是 Python 字典+用 Python 创建字典
在这个 python 教程中，我们将讨论什么是 Python 字典以及用 Python 创建字典的不同方法。我们将检查:
- 什么是 Python 字典
- 用 Python 创建字典
- python 中的花括号
- 从字典中访问元素
- 用键和值创建字典 python
- 从列表创建字典 python
- 为循环创建字典 python
- 创建包含两个列表的字典 python
- Python 从键和值的列表中创建字典
- Python 按值排序字典
- 初始化空字典 python
- 检查一个值是否在 Python 的字典中
- Python 按值降序排序字典
- Python 字典 vs 列表
- python 中的花括号
目录
- 什么是 Python 字典
- 用 Python 创建字典
- python 中的花括号
- 从 Python 字典中访问元素
- 用键和值创建字典 python
- 从列表中创建字典 Python
- 为循环创建字典 python
- 用两个列表创建字典 Python
- Python 从键和值的列表中创建字典
- Python 按值排序字典
- 初始化空字典 python
- 检查一个值是否在 Python 的字典中
- Python 按值降序排列字典
- Python 字典 vs 列表
什么是 Python 字典
现在，首先让我们看看什么是 python 字典，python 字典是一个无序的条目集合，每个条目都在一个键值对中。
现在，让我们看看如何用 Python 创建字典。
如果你是 Python 新手，可以查看一下， Python 下载安装步骤和 Python Hello World 程序。
用 Python 创建字典
现在，我们将看到如何用 Python 创建字典。
python 中的字典是可变数据类型。它是由冒号(:)分隔的键-值对的集合，用花括号{}括起来。一个键在字典中应该是唯一的。
举例:
dict1 = {'EmpName': 'Tiyasha', 'EmpId': 2043 }
print(dict1)
写完上面的代码(用 python 创建一个字典)，一旦你将打印出 " dict1" ，那么输出将显示为 " {'EmpName': 'Tiyasha '，' EmpId': 2043 } " 。您可以参考下面的截图来访问字典中的元素。
Create a dictionary in python
这就是如何用 Python 创建字典。
读取 Python 字典重复键
python 中的花括号
python 中的花括号用来定义一个字典。Python 字典是一种将一个值映射到另一个值的数据结构。在 python 中，花括号不用于表示控制级别。相反，Python 使用缩进来实现这个目的。
下面给出的是 python 中花括号的例子。
dictionary = {
"r" : "Red",
"b" : "Black"}
从 Python 字典中访问元素
要访问 Python 字典中的元素，请在方括号[]中指定键名。
dict1 = {'EmpName': 'Tiyasha', 'EmpId': 2043 }
value = dict1['EmpId']
print(value)
写完上面的代码(从字典中访问元素)，你将打印出 " value " ，然后输出将显示为 " 2043 " 。这里，EmpID 值是 2043。您可以参考下面的截图来访问字典中的元素。
Accessing elements from a dictionary
这是如何从 Python 字典中提取元素。
读取 Python 字典增量值
用键和值创建字典 python
python 中的字典将对象存储为键值对，它将所有数据和对象存储在无序集合中。
举例:
food = {'Burger': 2, 'Sandwich': 5, 'Pizza': 10 }
print('My key-value is:', food)
写完上面的代码(用键和值创建字典 python)，你将打印出 "food" ，然后输出将显示为"我的键值是:{'Burger': 2，' Sandwich': 5，' Pizza': 10 }" 。这里，将使用所有的键值创建字典。你可以参考下面的截图来创建一个带有键和值的字典 python。
Create dictionary python with keys and values
这就是如何创建一个带有键和值的字典 python。
阅读 Python 列表字典
从列表中创建字典 Python
为了在 Python 中从列表中创建字典，我们需要创建一个包含值的列表。
举例:
food = [('Burger', 2), ('Sandwich', 5), ('Pizza', 10)]
dictionary = dict((k,v) for (k,v) in food)
print(f'dictionary: {dictionary}')
写完上面的代码(从 list 创建 dictionary python)，你将打印出 "{dictionary}" ，然后输出将显示为 "dictionary: {'Burger': 2，' Sandwich': 5，' Pizza': 10 }" 。在这里，字典将被创建。你可以参考下面的截图从列表中创建字典 python。
Create dictionary Python from list
这是如何从列表创建字典 Python。
阅读 Python 字典扩展
为循环创建字典 python
使用 for 循环创建字典是 python 中一种非常高效的方式。遍历字典将返回键和值
举例:
employee = {201: 'Cyrus', 202: 'Kathilin', 203: 'Mishal'}
for r in employee:
print(r, ':',employee[r])
写完上面的代码(为循环创建字典 python)，你将打印出(r，':'，employee[r]) " 然后输出将显示为" 201:Cyrus 202:kath ilin 203:Mishal "。这里，for 循环将在字典中迭代键值。
创建字典 python for loop 可以参考下面的截图。
Create dictionary python for loop
这是一个创建字典 python for 循环的例子。
用两个列表创建字典 Python
为了创建一个具有两个列表的字典 python，我们可以使用 zip()方法。这里，一个列表元素与其他列表元素配对，结果将是一个字典。
举例:
list1 = ['Red', 'Blue', 'Pink', 'Green']
list2 = ['4', '5', '8', '12', '10']
color_dictionary = dict(list1,list2)
print(color_dictionary)
写完上面的代码后(用两个列表创建 dictionary python)，你将打印出(color _ dictionary)然后输出将显示为“错误:dict 期望最多 1 个参数，它得到了 2 个”。
你可以参考下面的截图来创建一个包含两个列表的字典 python。
Create dictionary python with two lists
举例:
list1 = ['Red', 'Blue', 'Pink', 'Green']
list2 = ['4', '5', '8', '12', '10']
color_dictionary = dict(zip(list1,list2))
print(color_dictionary)
写完上面的代码(用两个列表创建 dictionary python)，你将打印出(color _ dictionary)，然后输出将显示为 "{'Red': '4 '，' Blue': '5 '，' Pink': '12 '，' Green': '10'} " 。这里，两个列表通过使用 zip 转换成一个字典，它将配对在一起，并且它将创建一个两个列表的字典。
你可以参考下面的截图来创建一个包含两个列表的字典 python。
Create dictionary Python with two lists
这就是如何创建一个包含两个列表的字典 Python。
阅读 Python 字典多个键
Python 从键和值的列表中创建字典
字典是从键和相应值的列表中创建的。通过使用 python 字典理解，我们在 python 中得到一个具有键值对的字典。
举例:
my_key = ["Paras", "Jain", "Cyware"]
my_value = ["101", "102", "103"]
result = {k:v for k,v in zip(my_key,my_value)}
print(result)
写完上面的代码(从一列键和值中创建一个字典)，你将打印出 "result" ，然后输出将显示为" { ' params ':' 101 '，' Jain': '102 '，' Cyware': '103'} " 。这里，字典将从键和值的列表中创建。
你可以参考下面的截图，从键和值的列表中创建一个字典。
create a Python dictionary from list of keys and values
这就是如何用 Python 从键和值的列表中创建字典。
Python 按值排序字典
内置的 sorted()方法用于根据值对字典进行排序，我们可以一起使用两个函数 items()和 sorted()来根据值对元素进行排序，lambda 函数将返回值。
举例:
my_value = {30: 'Tom', 18: 'Anisha', 20: 'Jim'}
store = dict(sorted(my_value.items(), key=lambda x: x[1]))
print("sorting by value: ", store)
写完上面的代码(Python 按值排序字典)，你将打印出 " store " ，然后输出将显示为 " {18: 'Anisha '，20: 'Jim '，30: 'Tom'} " 。在这里，字典将根据其值进行排序。
你可以参考下面的截图来创建一个按值排序的 python 字典。
Python sort dictionary by value
这就是如何按值对 Python 字典进行排序。
初始化空字典 python
在 python 中，我们可以通过在赋值语句中不给花括号内的任何元素来初始化一个空字典。如果键和值不在花括号中，那么在 python 中它将是一个空字典。
举例:
name = {}
print(name)
写完上面的代码(初始化空字典 python)，你将打印出 " name " ，然后输出将显示为 " { } " 。这里，空字典被初始化，它将返回一个空字典。
你可以参考下面的截图来初始化空字典 python
Initialize empty dictionary python
我们也可以在 python 中通过使用不带参数的内置函数“dict()”来初始化空字典。
举例:
name = dict()
print(name)
写完上面的代码(初始化空字典 python)，你将打印出 " name " ，然后输出将显示为 " { } " 。这里，使用内置的 dict() 函数，不带参数地创建 python 中的空字典。
你可以参考下面的截图来初始化空字典 python
Initialize empty dictionary python
这是如何在 Python 中初始化空字典。
阅读 Python 元组字典
检查一个值是否在 Python 的字典中
在 python 中，为了检查一个值是否存在于字典中，我们将使用 "dictionary.values()" 来获取值，如果它存在，那么它将返回 true，否则返回 false。
举例:
my_dictionary = {"avinav": 111, "john": 222, "nick": 223}
check = 111 in my_dictionary.values()
print(check)
写完上面的代码后(检查一个值是否在 Python 的字典中)，你将打印出“check”，然后输出将显示为“真”。这里， dictionary.values() 将检查指定的值是否存在于字典中。
你可以参考下面的截图检查一个值是否在 Python 的字典中
Check if a value is in a dictionary in Python
这是如何在 Python 中检查一个值是否在字典中。
还有，读， Python 字典 pop
Python 按值降序排列字典
让我们检查一下如何在 Python 中按值降序排列字典。
Python 中内置的 sorted()方法用于对字典进行降序排序。我们可以一起使用两个函数 items()和 sorted()来按照降序对元素进行排序，lambda 函数将返回降序排序的值。
food = {
'cheese sandwich': 22,
'Butter sandwich': 15,
'Paneer sandwich': 19
}
des_orders = sorted(food.items(), key=lambda x: x[1], reverse=True)
for i in des_orders:
print(i[0], i[1])
写完上面的代码(Python 按值排序字典)，你将打印出 " store " ，然后输出将显示为 " {18: 'Anisha '，20: 'Jim '，30: 'Tom'} " 。这里， reverse=True 声明我们希望我们的数据按照降序排序。for 循环遍历在我们的 des_orders 方法中创建的每一项，并按排序顺序打印键和值。
你可以参考下面的截图来创建一个按值排序的 python 字典。
Python sort dictionary by value descending
这就是如何在 Python 中按值降序对字典进行排序。
阅读 Python 字典包含
Python 字典 vs 列表
| 字典 | 列表 |
| 字典是一个粗糙的键和值对结构。 | 列表是数组形式的索引值对的集合。 |
| 字典的键可以是任何数据类型。 | 列表的索引是从 0 开始的整数。 |
| 在字典里，维持秩序是没有保证的。 | 列表中输入元素的顺序保持不变 |
| 该元素通过字典中的键值来访问。 | 通过列表中的索引来访问元素。 |
您可能会喜欢以下 Python 教程:
- Python 字典理解
- Python 字典按值查找键
- 用 Python 把 PDF 文件转换成 Docx
- Python 字典删除
- Python 字典索引
- Python 字典长度
- Python 字典初始化
在本 Python 教程中，我们学习了什么是 Python 字典和如何用 Python 创建字典。和
- python 中的花括号
- 从字典中访问元素
- 用键和值创建字典 python
- 从列表创建字典 python
- 为循环创建字典 python
- 创建包含两个列表的字典 python
- Python 从键和值的列表中创建字典
- Python 按值排序字典
- 初始化空字典 python
- 检查一个值是否在 Python 的字典中
- Python 按值降序排序字典
- Python 字典 vs 列表
- python 中的花括号
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
如何在 Django 中创建基于函数的视图
原文：https://pythonguides.com/create-a-function-based-view-in-django/
在这个 Python Django 教程中，我将解释如何用简单的步骤在 Django 中创建一个基于函数的视图。
视图是一个接受 web 请求并返回 web 响应的函数。因此，在处理任何 Django 项目时，我们总是需要一个视图，因为它包含了主要的逻辑。
所以，在这里我们会看到:
- Django 中什么是基于函数的视图？
- 如何在 Django 中创建基于函数的视图
- 如何在 Django 中创建模型
- 如何在 Django 中从模型创建表单
- 如何在 Django 中创建基于函数的视图来创建记录
在本文的最后，您还可以下载 Django 中基于函数的视图的代码。
目录
在 Django 中创建一个基于函数的视图
现在，让我们先了解什么是 Django 基于函数的视图，一步一步学习创建 Django 基于函数的视图来创建记录。
Django 基于函数的视图
视图是编写应用程序逻辑的地方。
基于函数的视图基本上是一个 python 函数，它接受 web 请求并返回 web 响应。响应可以是任何内容，包括 XML 文件、图像、错误、重定向或 HTML 文本。
我们一般将这些功能称为应用程序的视图功能，或者视图功能，或者视图功能。
Django 基于功能的视图优势
初学者可以很容易理解基于功能的视图，因为它们对他们来说是用户友好的。
- 使用和理解都很简单。
- 提供了显式代码流。
- 提供了装饰器的简单使用。
- 非常适合专业功能。
Django 基于函数的视图缺点
代码的长度是基于函数的视图的最大缺点。
- 代码的重复和难以扩展。
- HTTP 方法将由条件分支来处理。
Django 基于函数的视图语法
Django 中每个基于函数的视图都接受一个 HttpRequest 对象作为它的第一个参数。此外，基于功能的视图被写入应用程序的 views.py 文件中，因为它包含应用程序的业务逻辑。
后来，需要在项目/app 的 urls.py 文件中为基于函数的视图指定一个 URL 名称。
下面是创建基于函数的视图的语法。
def function_name (request):
return HttpResponse('html/variable/text')
这里的请求是一个 HttpRequest 对象，而 HTML/text 是一个 HttpResponse 对象。
如何在 Django 中创建基于函数的视图来创建记录
现在，我们将看到一个与在 Django 中创建基于函数的视图相关的例子，该视图用于执行创建操作。
建立 Django 项目
在 Django 中，总有一个项目包含各种应用程序。所以我们需要先为我们的项目建立一个项目和一个 app。这里 FunctionBasedViewProject 是项目的名称。
django-admin startproject FunctionBasedViewProject
在 Django 项目中，使用如下命令创建一个名为 MyApp 的 Django 应用程序。
python manage.py startapp MyApp
Django Project and App
打开项目目录下的 settings.py 文件，将 MyApp 添加到 INSTALLED_APP 列表中。
Install App
在 Django 中，一个请求首先被发送到项目目录中的 urls.py ，然后被转发到 app 目录中 urls.py 中的相应 URL。
from django.contrib import admin
from django.urls import path,include
urlpatterns = [
path('admin/', admin.site.urls),
path('',include('MyApp.urls')),
]
创建 Django 模型
该项目的数据存储在 Django 模型中，这些模型基本上是我们数据库中的表。此外，打开位于 app 目录中的 models.py 文件，并添加以下代码以在 Django 中构建模型。
from django.db import models
class Employee(models.Model):
empid = models.IntegerField()
name = models.CharField(max_length=200)
gender = models.CharField(max_length=10)
city = models.CharField(max_length=100)
def __str__(self):
return self.name
在这里，我们使用 Django 模型类创建一个名为雇员的模型，它有以下字段。
- empid 是 Django IntegerField。
- 姓名、性别、城市为 Django CharFields。这些字符字段分别有 200、10 和 100 个字符的限制。
- 并使用
def __str__(self)来更改 Django 模型中对象的显示名称。当我们返回自己的名字时，它会将项目名称渲染为名称。
要在管理应用程序中查看模型，请在管理站点上注册它。为此，打开 admin.py 文件并添加下面给出的代码。
from django.contrib import admin
from .models import Employee
admin.site.register(Employee)
来自模型的 Django 表单
为了从模型中创建一个表单，将下面的代码添加到我们在 app 目录中创建的 forms.py 文件中。
from django import forms
from .models import Employee
class EmployeeForm(forms.ModelForm):
class Meta:
model = Employee
fields = '__all__'
这里，我们使用表单创建一个表单。名为 EmployeeForm 的 ModelForm 类。它拥有雇员模型的所有字段。
渲染 Django 模型表单
在主项目目录中创建一个名为 Templates 的子目录来存储所有的项目模板，因为 Django 应用程序的前端是在 Templates 中指定的。
为了引用模板目录位置，打开 settings.py 文件，更新 DIRS 。
Location of Template Folder
在模板中创建一个名为form.html的 HTML 文件，向其中添加 HTML 代码。这个 HTML 代码充当 web 响应对象。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Employee Registration</title>
<style>
table {
border: 8px outset;
border-radius: 10px;
border-spacing: 10px;
padding: 20px;
margin-left: auto;
margin-right: auto;
}
</style>
</head>
<body>
<h1 align="center">Employee Registration</h1>
<hr>
<h3 align="center">Please fill the details to register yourself with our company.</h3>
<hr>
<br>
<form method="post">
{% csrf_token %}
<table>
{{form.as_table}}
</table>
<br><br>
<div style="text-align:center">
<input type="submit" />
</div>
</form>
</body>
</html>
- 表格的样式首先在头标签中定义。
- HTML 标签
h1和h4然后被用来在主体标签内添加表单的标题。 - 它将通过使用
POST方法调用form标签来呈现表单。 - 为了保护表单免受黑客攻击，并能够安全地发送数据，请在表单元素中包含
csrf_token。 - 之后，使用
form.as_table标签将表单呈现为表格。 - 添加一个提交按钮作为最后一步。
Django 创建操作的基于函数的视图
创建基于函数的视图，该视图对员工模型执行创建操作。打开 views.py 文件，添加下面给出的代码。
from django.shortcuts import render,HttpResponse
from .forms import EmployeeForm
# Create your views here.
def empregistration(request):
if request.method == 'POST':
form = EmployeeForm(request.POST)
if form.is_valid():
form.save()
return HttpResponse('Employee is successfully register.')
else:
form = EmployeeForm()
context = {
'form':form,
}
return render(request, 'form.html', context)
- 创建一个名为
empregistration的视图，首先从forms.py文件中导入EmployeeForm。 - 之后，执行 if 语句确定请求方法是否为
POST。- 如果是这样，只需包含一个请求。POST 表单方法。
- 调用
is_valid方法来验证用户的输入。如果验证成功，调用save()方法保存用户数据并返回HttpResponse。
- 如果请求方式为获取，则
render()函数向用户显示一张空白的注册申请表。
现在，我们必须用 URL 映射视图以便调用它，因此我们必须在 app 目录中创建一个名为 urls.py 的文件。包括下面的代码。
from django.urls import path
from . import views
urlpatterns = [
path('', views.empregistration, name='employeeregistration'),
]
执行 Django 应用程序
要创建包含模型表格模式代码的迁移文件，请在终端中键入以下命令。
python manage.py makemigrations
要根据迁移文件的模式构建表，请执行以下命令。
python manage.py migrate
要启动开发服务器，请在终端中键入下面给出的命令。
python manage.py runserver
Execute Django Project
它成功地打开了 Django 员工注册表单，这是我们使用 ModelForm 和基于函数的视图创建的，如下所示。
Employee Registration using Django
现在，填写表格并点击提交按钮，如下所示。
Submit Employee Registration Form in Django
成功提交表单后，我们将得到如下所示的 HttpResponse。
Successfully Submitting the Employee Registration Form in Django
这就是我们如何在 Django 中创建基于函数的视图来执行创建操作。
下载 Django 基于函数的视图完整代码
代码如下:
结论
这样，我们就成功地在 Django 中创建了一个基于函数的视图。我们还学习了如何在 Django 中创建基于函数的视图，它的优点和缺点，以及它的语法。
此外，我们还讨论了以下主题。
- Django 中什么是基于函数的视图？
- 如何在 Django 中创建基于函数的视图
- 如何在 Django 中创建模型
- 如何在 Django 中从模型创建表单
- 如何在 Django 中创建基于函数的视图来创建记录
您可能也喜欢阅读下面的 Python Django 教程。
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
使用 Python Pygame(井字游戏)创建一个游戏
原文：https://pythonguides.com/create-a-game-using-python-pygame/
在这个 Python 教程中，我们将学习如何使用 pygame 在 Python 中创建一个游戏。使用 pygame 很容易在 Python 中创建一个游戏。我们将在这里看到，如何使用 Python pygam e 开发井字游戏。我们还将讨论以下主题:
- python pygame 中的网格有什么用
- Python pygame 网格游戏
- 关于井字游戏
- 使用 pygame 的 Python 井字游戏
目录
网格在 Python Pygame 中有什么用
python pygame 中使用网格是为了像井字游戏、扫雷游戏等游戏。冒险游戏将数据保存在游戏网格中。数字网格也可以称为二维数组或矩阵。
你可能喜欢 Python Pygame 教程
Python Pygame 网格
- 首先，我们将导入 pygame 。
pygame.init()用于初始化 pygame 所有需要的模块。 - 之后，我们将定义一些颜色，如黑色、白色和红色。
- 现在，我们将设置每个网格位置的宽度和高度。边距= 5 将设置每个单元格之间的边距。
- 我们需要创建一个二维数组。二维数组只是一系列列表。
- 创建一个空列表 grid = [] 。同样，对于每一行循环，创建一个代表整个行的列表。为了添加一个单元格，我们将使用网格【行】。追加(0)。
- 网格[1][5] = 1 会将行设置为 1，列设置为 5 对 1。
- 使用 window_size = [255，255] 设置屏幕的高度和宽度。
- 同样，使用
pygame . display . set _ caption(" Grid ")设置屏幕的标题。循环，直到用户单击关闭按钮。 pygame.time.Clock()用于管理屏幕更新的速度。- 主循环用于 clicked 事件。如果用户点击鼠标，然后获得位置。
- 此外，将 x/y 屏幕坐标更改为网格坐标。
- 将屏幕背景设置为 scr.fill(黑色)。
- 用于范围(10)中的行用于绘制网格。
clock.tick(50)是每秒帧数的极限。 - 这个
pygame.display.flip()用于用我们绘制的内容更新屏幕。
举例:
import pygame
black = (0, 0, 0)
white = (255, 255, 255)
red = (255, 0, 0)
WIDTH = 20
HEIGHT = 20
MARGIN = 5
grid = []
for row in range(10):
grid.append([])
for column in range(10):
grid[row].append(0)
grid[1][5] = 1
pygame.init()
window_size = [255, 255]
scr = pygame.display.set_mode(window_size)
pygame.display.set_caption("Grid")
done = False
clock = pygame.time.Clock()
while not done:
for event in pygame.event.get():
if event.type == pygame.QUIT:
done = True
elif event.type == pygame.MOUSEBUTTONDOWN:
pos = pygame.mouse.get_pos()
column = pos[0] // (WIDTH + MARGIN)
row = pos[1] // (HEIGHT + MARGIN)
grid[row][column] = 1
print("Click ", pos, "Grid coordinates: ", row, column)
scr.fill(black)
for row in range(10):
for column in range(10):
color = white
if grid[row][column] == 1:
color = red
pygame.draw.rect(scr,
color,
[(MARGIN + WIDTH) * column + MARGIN,
(MARGIN + HEIGHT) * row + MARGIN,
WIDTH,
HEIGHT])
clock.tick(50)
pygame.display.flip()
pygame.quit()
在这个输出中，我们可以看到新窗口和 python pygame 中的网格一起出现。红框是鼠标在网格中点击的位置。
Python Pygame grid
在下面的截图中，我们可以看到当点击屏幕时，鼠标的位置和坐标被点击。
Python pygame grid
关于井字游戏
- 井字游戏是最受欢迎的游戏之一。让我们了解一下这个游戏在 python pygame 中是如何工作的。
- 井字游戏基本上是两个人玩的游戏。它有表示为“O”和“X”的零号和十字。
- x 和 O 轮流标记 3×3 网格中的空间。
- 成功在水平、垂直或对角线上放置三个标记的玩家赢得游戏，游戏结束。
- 我们将使用 Python 库来构建这个游戏。
使用 Python Pygame 创建井字游戏
在这里，我们将解释使用 pygame 用 python 编写井字游戏 游戏的简单方法。建议去抛下面一步。
第一步。
- 首先我们会导入
pygame、sys、NumPypython 库用于构建这个游戏。 - 设置游戏窗口的宽度和高度。同样，设置背景颜色为 BG_COLOR = (20，200，160)
- 根据您的选择设置线条颜色、圆形颜色和十字颜色。
- 为了创建一个电路板，我们将使用
np.zeros()。 pygame.draw.line()用于绘制一条水平线和垂直线。
import pygame, sys
import numpy as np
pygame.init()
WIDTH = 600
HEIGHT = 600
LINE_WIDTH = 15
WIN_LINE_WIDTH = 15
BOARD_ROWS = 3
BOARD_COLS = 3
SQUARE_SIZE = 200
CIRCLE_RADIUS = 60
CIRCLE_WIDTH = 15
CROSS_WIDTH = 25
SPACE = 55
BG_COLOR = (20, 200, 160)
LINE_COLOR = (23, 145, 135)
CIRCLE_COLOR = (239, 231, 200)
CROSS_COLOR = (66, 66, 66)
screen = pygame.display.set_mode( (WIDTH, HEIGHT) )
pygame.display.set_caption( 'TIC TAC TOE' )
screen.fill( BG_COLOR )
board = np.zeros( (BOARD_ROWS, BOARD_COLS) )
def draw_lines():
pygame.draw.line( screen, LINE_COLOR, (0, SQUARE_SIZE), (WIDTH, SQUARE_SIZE), LINE_WIDTH )
pygame.draw.line( screen, LINE_COLOR, (0, 2 * SQUARE_SIZE), (WIDTH, 2 * SQUARE_SIZE), LINE_WIDTH )
pygame.draw.line( screen, LINE_COLOR, (SQUARE_SIZE, 0), (SQUARE_SIZE, HEIGHT), LINE_WIDTH )
pygame.draw.line( screen, LINE_COLOR, (2 * SQUARE_SIZE, 0), (2 * SQUARE_SIZE, HEIGHT), LINE_WIDTH )
第二步:
def draw_figures()用于绘制十字的圆和线。def mark_square()函数用于在板上进行标记，它有 3 个参数。- 如果方块可用，def available_square() 将返回 true，如果不可用，将返回 false。
def is_board_full()如果电路板已满，函数将返回 true，如果电路板未满，函数将返回 false。它将遍历行和列。- 如果 board[row][col] == 0 这意味着我们找到了空方块，它将返回 false，如果我们没有找到空方块，它将返回 true。
def draw_figures():
for row in range(BOARD_ROWS):
for col in range(BOARD_COLS):
if board[row][col] == 1:
pygame.draw.circle( screen, CIRCLE_COLOR, (int( col * SQUARE_SIZE + SQUARE_SIZE//2 ), int( row * SQUARE_SIZE + SQUARE_SIZE//2 )), CIRCLE_RADIUS, CIRCLE_WIDTH )
elif board[row][col] == 2:
pygame.draw.line( screen, CROSS_COLOR, (col * SQUARE_SIZE + SPACE, row * SQUARE_SIZE + SQUARE_SIZE - SPACE), (col * SQUARE_SIZE + SQUARE_SIZE - SPACE, row * SQUARE_SIZE + SPACE), CROSS_WIDTH )
pygame.draw.line( screen, CROSS_COLOR, (col * SQUARE_SIZE + SPACE, row * SQUARE_SIZE + SPACE), (col * SQUARE_SIZE + SQUARE_SIZE - SPACE, row * SQUARE_SIZE + SQUARE_SIZE - SPACE), CROSS_WIDTH )
def mark_square(row, col, player):
board[row][col] = player
def available_square(row, col):
return board[row][col] == 0
def is_board_full():
for row in range(BOARD_ROWS):
for col in range(BOARD_COLS):
if board[row][col] == 0:
return False
return True
第三步:
- 这里使用了
def check_win(player)函数。另外，范围内栏的(BOARD _ COLS)用于检查垂直赢线。 for row in range(BOARD _ ROWS)用于检查水平获奖线。- 现在，我们将检查上升
draw _ ASC _ diagonal(player)和下降draw _ desc _ diagonal(player)的对角赢。 - def draw _ vertical _ winning _ line(col，player) 用于绘制一条垂直的赢线。
- 如果 player == 1 则圈色，
elif player == 2则跨色。
def check_win(player):
for col in range(BOARD_COLS):
if board[0][col] == player and board[1][col] == player and board[2][col] == player:
draw_vertical_winning_line(col, player)
return True
for row in range(BOARD_ROWS):
if board[row][0] == player and board[row][1] == player and board[row][2] == player:
draw_horizontal_winning_line(row, player)
return True
if board[2][0] == player and board[1][1] == player and board[0][2] == player:
draw_asc_diagonal(player)
return True
if board[0][0] == player and board[1][1] == player and board[2][2] == player:
draw_desc_diagonal(player)
return True
return False
def draw_vertical_winning_line(col, player):
posX = col * SQUARE_SIZE + SQUARE_SIZE//2
if player == 1:
color = CIRCLE_COLOR
elif player == 2:
color = CROSS_COLOR
pygame.draw.line( screen, color, (posX, 15), (posX, HEIGHT - 15), LINE_WIDTH )
第四步:
def draw _ horizontal _ winning _ line()该函数用于绘制水平赢线。- 如果 player == 1 则圈色，
elif player == 2则跨色。 def draw _ ASC _ diagonal(player)用于绘制上升对角线的获胜线。- 如果 player == 1 那么圈颜色，如果 player == 2 那么交叉颜色
def draw_horizontal_winning_line(row, player):
posY = row * SQUARE_SIZE + SQUARE_SIZE//2
if player == 1:
color = CIRCLE_COLOR
elif player == 2:
color = CROSS_COLOR
pygame.draw.line( screen, color, (15, posY), (WIDTH - 15, posY), WIN_LINE_WIDTH )
def draw_asc_diagonal(player):
if player == 1:
color = CIRCLE_COLOR
elif player == 2:
color = CROSS_COLOR
pygame.draw.line( screen, color, (15, HEIGHT - 15), (WIDTH - 15, 15), WIN_LINE_WIDTH )
第五步:
def draw _ desc _ diagonal(player)用于绘制一条降序排列的获胜对角线。- 如果 player == 1 则圈色，
elif player == 2则跨色。 pygame.draw.line()用于画线。def restart()当你的游戏结束，想再玩一次的时候调用这个函数。
def draw_desc_diagonal(player):
if player == 1:
color = CIRCLE_COLOR
elif player == 2:
color = CROSS_COLOR
pygame.draw.line( screen, color, (15, 15), (WIDTH - 15, HEIGHT - 15), WIN_LINE_WIDTH )
def restart():
screen.fill( BG_COLOR )
draw_lines()
for row in range(BOARD_ROWS):
for col in range(BOARD_COLS):
board[row][col] = 0
第六步:
- 现在，我们需要设置
game_over = False，如果玩家赢了，则将其设置为 true，游戏结束。 - 为真时主循环开始。
- 在主循环中调用函数
check win。 - 我们用 python 的 sys 库退出了游戏。
- 但如果按下鼠标，
event.get()会返回“mouse button down”并调用user_click()。以知道用户点击的板的精确坐标。 - if event.key == pygame。K_r 然后按下【r】重新启动游戏并开始玩
draw_lines()
player = 1
game_over = False
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
if event.type == pygame.MOUSEBUTTONDOWN and not game_over:
mouseX = event.pos[0]
mouseY = event.pos[1]
clicked_row = int(mouseY // SQUARE_SIZE)
clicked_col = int(mouseX // SQUARE_SIZE)
if available_square( clicked_row, clicked_col ):
mark_square( clicked_row, clicked_col, player )
if check_win( player ):
game_over = True
player = player % 2 + 1
draw_figures()
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_r:
restart()
player = 1
game_over = False
pygame.display.update()
使用 pygame 在 python 中完成井字游戏代码:
import pygame, sys
import numpy as np
pygame.init()
WIDTH = 600
HEIGHT = 600
LINE_WIDTH = 15
WIN_LINE_WIDTH = 15
BOARD_ROWS = 3
BOARD_COLS = 3
SQUARE_SIZE = 200
CIRCLE_RADIUS = 60
CIRCLE_WIDTH = 15
CROSS_WIDTH = 25
SPACE = 55
RED = (255, 0, 0)
BG_COLOR = (20, 200, 160)
LINE_COLOR = (23, 145, 135)
CIRCLE_COLOR = (239, 231, 200)
CROSS_COLOR = (66, 66, 66)
screen = pygame.display.set_mode( (WIDTH, HEIGHT) )
pygame.display.set_caption( 'TIC TAC TOE' )
screen.fill( BG_COLOR )
board = np.zeros( (BOARD_ROWS, BOARD_COLS) )
def draw_lines():
pygame.draw.line( screen, LINE_COLOR, (0, SQUARE_SIZE), (WIDTH, SQUARE_SIZE), LINE_WIDTH )
pygame.draw.line( screen, LINE_COLOR, (0, 2 * SQUARE_SIZE), (WIDTH, 2 * SQUARE_SIZE), LINE_WIDTH )
pygame.draw.line( screen, LINE_COLOR, (SQUARE_SIZE, 0), (SQUARE_SIZE, HEIGHT), LINE_WIDTH )
pygame.draw.line( screen, LINE_COLOR, (2 * SQUARE_SIZE, 0), (2 * SQUARE_SIZE, HEIGHT), LINE_WIDTH )
def draw_figures():
for row in range(BOARD_ROWS):
for col in range(BOARD_COLS):
if board[row][col] == 1:
pygame.draw.circle( screen, CIRCLE_COLOR, (int( col * SQUARE_SIZE + SQUARE_SIZE//2 ), int( row * SQUARE_SIZE + SQUARE_SIZE//2 )), CIRCLE_RADIUS, CIRCLE_WIDTH )
elif board[row][col] == 2:
pygame.draw.line( screen, CROSS_COLOR, (col * SQUARE_SIZE + SPACE, row * SQUARE_SIZE + SQUARE_SIZE - SPACE), (col * SQUARE_SIZE + SQUARE_SIZE - SPACE, row * SQUARE_SIZE + SPACE), CROSS_WIDTH )
pygame.draw.line( screen, CROSS_COLOR, (col * SQUARE_SIZE + SPACE, row * SQUARE_SIZE + SPACE), (col * SQUARE_SIZE + SQUARE_SIZE - SPACE, row * SQUARE_SIZE + SQUARE_SIZE - SPACE), CROSS_WIDTH )
def mark_square(row, col, player):
board[row][col] = player
def available_square(row, col):
return board[row][col] == 0
def is_board_full():
for row in range(BOARD_ROWS):
for col in range(BOARD_COLS):
if board[row][col] == 0:
return False
return True
def check_win(player):
for col in range(BOARD_COLS):
if board[0][col] == player and board[1][col] == player and board[2][col] == player:
draw_vertical_winning_line(col, player)
return True
for row in range(BOARD_ROWS):
if board[row][0] == player and board[row][1] == player and board[row][2] == player:
draw_horizontal_winning_line(row, player)
return True
if board[2][0] == player and board[1][1] == player and board[0][2] == player:
draw_asc_diagonal(player)
return True
if board[0][0] == player and board[1][1] == player and board[2][2] == player:
draw_desc_diagonal(player)
return True
return False
def draw_vertical_winning_line(col, player):
posX = col * SQUARE_SIZE + SQUARE_SIZE//2
if player == 1:
color = CIRCLE_COLOR
elif player == 2:
color = CROSS_COLOR
pygame.draw.line( screen, color, (posX, 15), (posX, HEIGHT - 15), LINE_WIDTH )
def draw_horizontal_winning_line(row, player):
posY = row * SQUARE_SIZE + SQUARE_SIZE//2
if player == 1:
color = CIRCLE_COLOR
elif player == 2:
color = CROSS_COLOR
pygame.draw.line( screen, color, (15, posY), (WIDTH - 15, posY), WIN_LINE_WIDTH )
def draw_asc_diagonal(player):
if player == 1:
color = CIRCLE_COLOR
elif player == 2:
color = CROSS_COLOR
pygame.draw.line( screen, color, (15, HEIGHT - 15), (WIDTH - 15, 15), WIN_LINE_WIDTH )
def draw_desc_diagonal(player):
if player == 1:
color = CIRCLE_COLOR
elif player == 2:
color = CROSS_COLOR
pygame.draw.line( screen, color, (15, 15), (WIDTH - 15, HEIGHT - 15), WIN_LINE_WIDTH )
def restart():
screen.fill( BG_COLOR )
draw_lines()
for row in range(BOARD_ROWS):
for col in range(BOARD_COLS):
board[row][col] = 0
draw_lines()
player = 1
game_over = False
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
if event.type == pygame.MOUSEBUTTONDOWN and not game_over:
mouseX = event.pos[0]
mouseY = event.pos[1]
clicked_row = int(mouseY // SQUARE_SIZE)
clicked_col = int(mouseX // SQUARE_SIZE)
if available_square( clicked_row, clicked_col ):
mark_square( clicked_row, clicked_col, player )
if check_win( player ):
game_over = True
player = player % 2 + 1
draw_figures()
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_r:
restart()
player = 1
game_over = False
pygame.display.update()
输出 1 :
在下面的输出中，您可以看到“X”赢得了游戏。
Python tic tac toe game using pygame
输出 2:
在下面的输出中，您可以看到“O”赢得了游戏。
Python tic tac toe game using pygame
输出 3:
在下面的输出中，您可以看到没有人赢得游戏。
Python tic tac toe game using pygame
您可能会喜欢以下 Python 教程:
- Python 熊猫 CSV 教程
- 蟒蛇里的熊猫
- Python 捕捉多个异常
- Python Tkinter Map()函数
- 使用 Python Tkinter 创建日期时间选择器
- 使用 Python 的机器学习
我希望现在你可以用 python 创建一个网格游戏像****井字游戏，并且我们也学会了如何使用 pygame 和 sys 模块。在这里，我们学习了如何使用 Pygame 在 Python 中创建井字游戏，我们有完整的源代码和解释。
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
如何用 python 创建字典键列表
原文：https://pythonguides.com/create-a-list-of-dictionary-keys-in-python/
在本 Python 教程中，我们将讨论 如何在 python 中创建字典键列表。我们将讨论使用字典键在 Python 中创建列表所需的过程和技术。
最近，我在做一个 Python 项目，其中我们有一个需求，我们必须将字典中的惟一键元素存储在一个 Python 列表中。
这里我们将讨论
- 如何使用 dict.keys()在 Python 中创建字典键列表
- 使用*运算符在 Python 中创建字典键列表
- 如何使用列表理解在 Python 中创建字典键列表
- 使用 for 循环和 append()在 Python 中创建字典键列表
- 如何使用 list()在 Python 中创建字典键列表
目录
- 用 python 创建一个字典键列表
- 如何使用 dict.keys() 在 Python 中创建字典键列表
- 使用*操作符在 Python 中创建一个字典键列表
- 如何使用列表理解在 Python 中创建字典键列表
- 使用 for 循环和 append() 在 Python 中创建一个字典键列表
- 如何使用 list() 在 Python 中创建字典键列表
用 python 创建一个字典键列表
在 Python 中，当在 Python 中创建字典键列表时，主要有三种常用且重要的理解方法。
如何使用 dict.keys() 在 Python 中创建字典键列表
- 在这一节中，我们将讨论如何使用 dict.keys()在 Python 中创建字典键列表。
- 要从字典中提取所有的键，请使用 Python 中的 keys()函数。如果字典是空的，它产生一个空列表。此过程不需要任何参数。
- 在这个例子中，我们将使用 dict.keys()方法在列表中存储关键元素。
语法:
让我们来看看语法，了解一下 dict.keys() 的工作原理。
dict.keys()
注意:这个方法不接受任何参数，它将返回键的列表。
举例:
让我们举个例子，看看如何使用 dict.keys()在 Python 中定义一个字典键列表。
# Creation of Dictionary
Country_name = {'U.S.A': 783, 'Germany': 356, 'China': 924}
# Using dict.keys() method
new_output = list(Country_name.keys())
# Display the Content
print("Extract keys from Dictionary :",new_output)
在上面的代码中，我们首先创建了一个字典，并以键-值对的形式分配元素。为了获得对象字典键，我们使用了 dict.keys()方法。我们将 dict.keys()作为参数分配给 list()构造函数。list()返回键的列表。
下面是下面给出的代码的截图。
How to create a list of dictionary keys in Python using dict.keys()
这就是如何使用 dict.keys()在 Python 中创建和定义字典键列表。
阅读: Python 列表方法
使用*操作符在 Python 中创建一个字典键列表
- 这里我们将讨论如何使用*运算符在 Python 中构造一个字典键列表。
- 运算符分解一个序列。为了生成一个列表，我们将提取[]中的字典键。
- 为了首先执行这个任务，我们将创建一个字典，然后在一个列表中获取键，我们将在列表中使用*和字典名。
举例:
让我们举一个例子，看看如何使用*操作符在 Python 中创建一个字典键列表。
源代码:
#Create dictionary
States_in_USA = {
'Colorado':865,
'Georgia':945,
'Kansas':734
}
# Using *operator
new_result = [*States_in_USA]
#print the list
print("Fetched keys from dictionary :", new_result)
在下面给出的代码中，我们首先创建了一个名为“States_in_USA”的字典，并以键值对的形式分配元素。接下来，我们使用*操作符从字典中提取键。
你可以参考下面的截图。
Create a list of dictionary keys in Python using * operator
在这个例子中，我们已经了解了如何使用*运算符在 Python 中创建一个字典键列表。
阅读: Python 扩展 Vs 追加
如何使用列表理解在 Python 中创建字典键列表
- 现在让我们看看如何使用 list comprehension 在 Python 中创建一个字典键列表。
- 列表理解是 Python 例程，可用于构建新序列(如列表、字典等)。)来自现有序列。它们有助于减少较大的环路。
- 在这个例子中，我们将使用列表理解从字典中提取关键字，并将它们存储在结果中。
语法:
下面是 Python 中列表理解方法的语法
[expression for element in iterable if condition]
注:
list comprehension 语法有三个组成部分:一个表达式，一个或多个 for 循环，如果需要，还有一个或多个 if 条件。方括号[必须用于列表理解]。第一个表达式的结果将保存在新列表中。
举例:
这里我们将举一个例子，并检查如何使用 list comprehension 在 Python 中创建一个字典键列表。
源代码:
#Initialize Dictionary
USA_State_ZipCode = {'Alabama': 35004, 'Alaska': 99501, 'Arizona': 85001}
# Using list comprehension method
new_output = [new_key for new_key in USA_State_ZipCode]
# Display the Content
print("Generated key from dictionary :",new_output)
在上面的代码中，我们首先创建了名为“USA _ State _ zip code”的字典，然后使用了列表理解方法，其中 for 循环用于迭代 iterable 对象。
下面是以下给定代码的执行。
How to create a list of dictionary keys in Python using list comprehension
正如你在截图中看到的，我们已经讨论了如何使用 list comprehension 在 Python 中创建一个字典键列表。
使用 for 循环和 append() 在 Python 中创建一个字典键列表
- 在本节中，我们将讨论如何使用 for 循环和 append()在 Python 中创建字典键列表。
- 在本例中，我们将创建一个列表，并在遍历字典的键时一次添加一个字典键。
- 为了执行这项任务，我们首先将定义一个空列表来包含键，并在 for 循环的每次迭代中追加键。
举例:
让我们举一个例子，看看如何使用 for 循环和 append()在 Python 中创建一个字典键列表。
源代码:
Country_name = {'U.S.A': 783, 'Germany': 356, 'China': 924}
new_lis = []
for new_key in Country_name:
new_lis.append(new_key)
print(new_lis)
在下面给出的代码中，我们定义了空列表，然后使用 for 循环来迭代这些值。然后使用 append()函数在空列表中添加关键元素。
你可以参考下面的截图。
Create a list of dictionary keys in Python using for loop and append
这就是如何使用 for 循环和 append 在 Python 中创建字典键列表。
如何使用 list() 在 Python 中创建字典键列表
- 现在让我们看看如何使用 list()在 Python 中创建一个字典键列表。
- list()构造函数返回一个列表作为输出。在没有参数的情况下，它返回一个空列表。如果 iterable 被指定为一个参数，那么它将从 iterable 项中创建一个列表。
- 在这个实例中，我们将创建一个包含几个值的字典，然后获取所有键的列表，然后将它存储在一个变量中。
语法:
下面是 Python 中 list()方法的语法
list([iterable])
举例:
让我们举一个例子，看看如何使用 list()在 Python 中创建一个字典键列表。
源代码:
# Creation of Dictionary
Cars_in_USA = {'BMW': 672, 'Tesla': 834, 'lamborghini': 924}
# Using list() method
new_output = list(Cars_in_USA)
# Display the Content
print("Extracted dictionary keys :",new_output)
在下面的代码中，我们首先创建了一个字典，然后使用 list()方法从字典中提取关键元素。
下面是下面给出的代码的截图。
How to create a list of dictionary keys in Python using list
您可能也喜欢阅读以下 Python 教程。
在本教程中，我们讨论了如何用 Python 创建字典键列表。我们介绍了用 Python 创建字典键列表的五种方法: dict.keys() 、列表理解方法、*操作符、 for loop and append() 和 list() 。
- 如何使用 dict.keys()在 Python 中创建字典键列表
- 使用*运算符在 Python 中创建字典键列表
- 如何使用列表理解在 Python 中创建字典键列表
- 使用 for 循环和 append()在 Python 中创建字典键列表
- 如何使用 list()在 Python 中创建字典键列表
Arvind 目前是 TSInfo Technologies 的高级 Python 开发人员。他精通 Python 库，如 NumPy 和 Tensorflow。
如何在 Python Tkinter 中创建一个贪吃蛇游戏
在这个 Tkinter 教程中，我们将学习如何在 Python Tkinter 中创建一个流行的贪吃蛇游戏。我们将用 Python 从头开始用分数创建一个贪吃蛇游戏。
贪吃蛇游戏概述
贪吃蛇游戏是每个千禧一代都玩的传统 2D 游戏之一。
- 在这个游戏中，有一条蛇一直在运动。
- 玩家必须确保蛇不会撞到墙壁或自身发生碰撞。玩了可以用右，左，下，上键控制蛇。
- 默认情况下，蛇以正确的方向开始运动。
- 屏幕上有一个被称为“食物”的物体。每当蛇与食物发生碰撞，食物就会消失，蛇的身体就会变大。
- 蛇与食物的每一次成功碰撞都有一个分数。
源代码
在这段代码中，我们创建了一个贪吃蛇游戏，设置了一个评分系统。
from tkinter import *
from random import randint
from PIL import Image, ImageTk
movement = 20
steps_per_sec = 10
speed = 1100 // steps_per_sec
class Snake(Canvas):
def __init__(self):
super().__init__(
width=700,
height=700,
background='#53ff1a',
highlightthickness=0
)
self.snake_pos = [(100, 80), (80, 100), (80, 100)]
self.food_pos = self.set_new_food_pos()
self.direction = 'Right'
self.score = 0
self.load_img()
self.create_objects()
self.bind_all('<Key>', self.on_key_press)
self.pack()
self.after(speed, self.perform_actions)
def load_img(self):
try:
self.snake_body = ImageTk.PhotoImage(Image.open('game.png'))
self.food = ImageTk.PhotoImage(Image.open('game.png'))
except IOError as error:
ws.destroy()
raise
def create_objects(self):
self.create_text(
35,
12,
text=f'Score: {self.score}',
tag='score',
fill='black',
font=10
)
for x_position, y_position in self.snake_pos:
self.create_image(
x_position,
y_position,
image=self.snake_body,
tag='snake'
)
self.create_image(
*self.food_pos,
image=self.food,
tag='food'
)
self.create_rectangle(
7,
27,
690,
690,
outline='#d9d8d7'
)
def finish_game(self):
self.delete(ALL)
self.create_text(
self.winfo_width() / 2,
self.winfo_height() / 2,
text=f'Game over! You have scored {self.score}!',
fill='black',
font=20
)
def consume_food(self):
if self.snake_pos[0] == self.food_pos:
self.score += 10
self.snake_pos.append(self.snake_pos[-1])
self.create_image(
*self.snake_pos[-1],
image=self.snake_body,
tag='snake'
)
self.food_pos = self.set_new_food_pos()
self.coords(
self.find_withtag('food'),
*self.food_pos
)
score = self.find_withtag('score')
self.itemconfigure(
score,
text=f'Score: {self.score}',
tag='score'
)
def boundry(self):
head_x_position, head_y_position = self.snake_pos[0]
return (
head_x_position in (0, 700)
or head_y_position in (20, 700)
or (head_x_position, head_y_position) in self.snake_pos[1:]
)
def snake_movement(self):
head_x_position, head_y_position = self.snake_pos[0]
if self.direction == 'Left':
new_head_position = (head_x_position - movement, head_y_position)
elif self.direction == 'Right':
new_head_position = (head_x_position + movement, head_y_position)
elif self.direction == 'Down':
new_head_position = (head_x_position, head_y_position + movement)
elif self.direction == 'Up':
new_head_position = (head_x_position, head_y_position - movement)
self.snake_pos = [new_head_position] + self.snake_pos[:-1]
for segment, position in zip(self.find_withtag('snake'), self.snake_pos):
self.coords(segment, position)
def on_key_press(self, e):
new_direction = e.keysym
all_directions = (
'Up',
'Down',
'Left',
'Right'
)
opposites = (
{'Up', 'Down'},
{'Left', 'Right'}
)
if (
new_direction in all_directions
and {new_direction, self.direction} not in opposites
):
self.direction = new_direction
def perform_actions(self):
if self.boundry():
self.finish_game()
self.consume_food()
self.snake_movement()
self.after(speed, self.perform_actions)
def set_new_food_pos(self):
while True:
x_position = randint(1, 29) * movement
y_position = randint(3, 30) * movement
food_pos = (x_position, y_position)
if food_pos not in self.snake_pos:
return food_pos
ws = Tk()
ws.title('PythonGuides - Snake Game')
ws.resizable(False, False)
board = Snake()
ws.mainloop()
输出:
在这个输出中，蛇在屏幕上移动，每次它与食物对象碰撞时，蛇的大小都会增加。
- 在屏幕的左上角有一个分数跟踪器。每一次成功的碰撞都会在计分板上增加 10 分。
- 蛇在与自己的身体相撞后死亡，游戏结束。
Python Tkinter Snake Game
您可能会喜欢以下 Python TKinter 教程:
- 如何使用 Python Tkinter 读取文本文件
- 如何使用 Python Tkinter 获取用户输入并存储在变量中
- Python Tkinter 退出程序
- Python Tkinter TreeView
- Python Tkinter 待办事项列表
- 用 Python Tkinter 创建 Word 文档
在本教程中，我们学习了如何使用 Python Tkinter 创建一个贪吃蛇游戏。
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
如何在 Python 中创建字符串
在本 Python 教程中，我们将讨论如何在 python 中创建一个字符串。在这里，我们还将看到 Python 创建字符串的示例:
- 用 Python 创建一个字符串
- 如何在 Python 中从列表创建字符串
- 在 Python 中创建一个 n 个字符的字符串
- Python 用变量创建一个字符串
- 用 Python 中的换行符创建一个字符串
- 如何在 Python 中创建相同字符的字符串
- 从 Python 字典创建字符串
- 如何在 Python 中创建带双引号的字符串
- Python 从字符列表创建字符串
- Python 从带分隔符的列表创建字符串
- 如何在 Python 中创建带单引号的字符串
- 如何在 Python 中创建带有多个变量的字符串
目录
- Python 字符串
- 在 Python 中创建一个字符串
- 如何在 Python 中声明变量并将变量赋给字符串
- python 中的多行字符串
- Python 创建一个字符串
- 另一个用 Python 创建字符串的例子
- Python 从列表中创建一个字符串
- Python 创建了一个 n 字符的字符串
- 创建 n 个字符的字符串的另一种方法
- Python 用变量创建字符串
- Python 创建一串相同的字符
- Python 用换行符创建字符串
- 用换行符创建字符串的另一种方法
- Python 从字典中创建一个字符串
- 另一种方法从字典中创建一个字符串
- Python 用双引号创建一个字符串
- Python 从字符列表中创建字符串
- 从字符列表创建字符串的另一个例子
- Python 用分隔符从列表中创建字符串
- Python 用单引号创建字符串
- Python 用多个变量创建字符串
- python 中的单引号与双引号
Python 字符串
字符串是一系列字符。字符可以是数字、字母、特殊字符等。字符串可以包含空格，并且不限制它应该包含多少个字符。
在 python 中，字符串是一种不可变的数据类型，一旦我们在程序中声明了它，就不能更改。
在 Python 中创建一个字符串
现在，我们将看到如何在 python 中创建一个字符串或者如何在 python 中声明一个字符串？
我们可以用三种方式在 python 中声明一个字符串
1-使用单引号(')
您可以使用单引号(')来声明一个字符串。让我们看一个例子
示例:
print('Hello PythonGuides!')
输出将是
Hello PythonGuides!
2-使用双引号(" ")
您可以使用双引号(" ")来声明字符串。让我们看一个例子
print("Hello PythonGuides!!")
输出将是
Hello PythonGuides!!
3-使用三重引号(“”)。
您可以使用三个引号(“”)来声明一个字符串。让我们看一个例子
print("Hello PythonGuides!!!")
输出将是
Hello PythonGuides!!!
现在让我们运行所有这三种格式，看看输出。
Create a string in Python
您可以通过在引号前保留一个反斜杠() 来将引号放入字符串中。
例如:
print ("Hello, \"I love python!\"")
输出将是
Hello, "I love python!"
How to Create a string in Python
上面的 Python 代码我们可以用来在 Python 中创建一个字符串。
你可能会喜欢 Python 字符串格式化的例子。
如何在 Python 中声明变量并将变量赋给字符串
现在，让我们看看如何在 Python 中声明一个变量并将它赋给一个字符串。
将字符序列放在单引号(' ')、双引号(" " " " ")或三引号(" " " ")或、T2(" ' " ')中，以创建字符串，然后将其赋给变量。
要将它赋给一个变量，我们可以使用变量名和 "= "运算符。
例如:
x = "Python Guides!"
y = 'Python Guides!!'
z = """ Python Guides!!! """
print(x)
print(y)
print(z)
declare and assign a variable to a string
通常单引号和双引号用于指定单行字符的字符串，而三引号用于指定多行字符的字符串。
这是如何在 Python 中声明变量并将变量赋给字符串。
阅读:追加到一个字符串 Python 。
python 中的多行字符串
我们可以使用三重引号(" " " ")或(" ' ")将多行字符串赋给一个变量。
例如:
x = """ Python Guides,
I love Python,
Python is the best!!. """
y = ''' Python Guides,
I love Python,
Python is the best!. '''
print(x)
print(y)
输出
Python Guides,
I love Python,
Python is the best!!.
Python Guides,
I love Python,
Python is the best!.
在这里查看输出
Multiline strings in python
Python 创建一个字符串
- 在这里我们将看到，如何在 Python 中创建一个字符串。
- 我们可以使用单引号或双引号来声明 python 中的字符串。
- Python 没有字符数据类型，字符只是一个有长度的字符串。
- 在这个例子中，我们可以简单地使用单引号或双引号来创建一个字符串，并把一个字符串赋给一个变量，我们可以简单地使用等于运算符和一个字符串值。
举例:
让我们举一个例子来检查如何在 python 中创建一个字符串
str = "John"
print(str)
- 在上面的例子中，我有一个变量将被命名为 str 并使用双引号。
- 我可以用 John 的名字创建字符串并打印结果。
下面是以下代码的截图
Python Create a string
另一个用 Python 创建字符串的例子
在这个方法中，我们必须创建一个字符串，并用单引号将一个字符赋值。
举例:
让我们举一个例子来检查如何在 Python 中创建一个字符串
string = 'Micheal'
print(string)
下面是以下代码的截图
Create a string in python single
在 Python 中读取检查一个列表是否为 empty
Python 从列表中创建一个字符串
- 让我们看看，如何从 Python 列表中创建一个字符串。
- 在这里，我们将执行一些操作，如长度和创建一个列表。
- 列表是 Python 中流行的数据结构之一。它基本上是某种物品或物体的贮藏处。某些项目由逗号[，]分隔，列表用方括号[]括起来。
示例:
让我们举一个例子来检查如何从一个列表中创建一个字符串
str = ['Germany',1,'England',2]
print(len(str)) # display length of the string
#for displaying all the elements of string
print(str)
首先在上面的例子中，我们将创建一个列表形式的字符串，并分配一些字符和整数值。在字符串的显示长度之后，输出将显示列表中有多少个元素，并显示字符串的所有元素。
下面是以下代码的截图
Python creates a string from a list
Python 创建了一个 n 字符的字符串
- 在这一节中，我们将讨论如何创建一个由 n 个字符组成的字符串。
- 这里，我们将创建一个多行字符串并添加一个换行符(\n)。
- 在这个例子中，我们可以很容易地使用换行符(\n)来显示一个新的行字符串。
举例:
让我们举一个例子来检查如何创建一个 n 个字符的字符串
string = "Java is a programming language\n Sql is a database"
print(string)
在上面的例子中，我们可以简单地使用双引号来创建一个字符串，并将多行字符和换行符(\n)赋给字符串。
下面是以下代码的截图
Python creates a string of n character
创建 n 个字符的字符串的另一种方法
- 我们可以很容易地使用 Python join()函数来创建 n 个字符的字符串。
- 该方法获取序列中所有指定的项，并将它们连接成一个字符串。
- 在本例中，join()方法可用于在字符串中添加换行符(\n)。
举例:
str1 =['Germany','France','Australia','England','Switzerland']
str2='\n'
print(str2.join(str1))
首先在上面的例子中，我们将创建一个字符串并分配一个元素。然后创建一个新的字符串，添加一个换行符(\n)并将它们连接成一个字符串。
下面是以下代码的截图
Python creates a string of n character join method
Python 用变量创建字符串
- 让我们看看如何用 Python 创建一个带有变量的字符串
- 变量就像存储值的内存分配。现在这个值已经存储起来，你将来可能会改变它。
- 要创建一个变量，我们只需要给它赋值。
- 在这里创建一个字符串，无论是单引号还是双引号，都将 iterable 或字符项放在里面，然后将它赋给一个变量。
举例:
让我们举一个例子来检查如何创建一个带有变量的字符串。
var = "Micheal"
print(var)
在上面的例子中，我们将创建一个变量，并给它们分配一个字符串，“Micheal”，并打印结果。
下面是以下代码的截图
Python creates a string with variables
阅读 Python 中的注释行
Python 创建一串相同的字符
- 在这一节中，我们将讨论 Python 创建一个相同字符的字符串。这里我们将使用 Python 中的重复操作符。
- 重复运算符使用*符号来表示乘法。
- 这对于将字符串重复到一定长度非常有用。
举例:
str = "Micheal is a good programmer" * 3
print(str)
首先在上面的例子中，我们将创建一个字符串，用双引号将一个多行字符串赋值，并应用乘法运算符。
下面是以下代码的截图
Python creates a string of the same character
Python 用换行符创建一个字符串
- 在这一节中，我们将讨论 Python 创建了一个带换行符的字符串。
- 当打印函数在文本字符串中找到反斜杠(\n)时，它知道要开始新的一行，您可以在字符串中根据需要多次使用反斜杠 n。
- 在这个例子中，我们可以很容易地使用换行符(\n)表示当前行在该点结束，新的一行开始。
举例:
让我们举一个例子来检查如何创建一个带换行符的字符串
str = "John is a\npython\ndeveloper"
print(str)
首先在上面的例子中，我们将创建一个字符串，用双引号将多行字符赋值，并使用换行符(\n)。
下面是以下代码的截图
Python creates a string with a newline
用换行符创建字符串的另一种方法
- 在这个方法中，我们可以很容易地使用函数
print来显示新的字符串。 - 打印函数有默认值
end参数，该参数分配一个反斜杠(\n)值。
语法:
下面是打印函数的语法
print
(
object(s),
sep=separator,
end=end,
file=file,
flush=flush
)
- 在这个方法中，我们只使用结束参数
- end: 可选参数。它指定了最后打印的内容。默认情况下，其值为\n。
举例:
让我们举一个例子来检查如何创建一个带有换行符的字符串。
print("Germany")
print("China")
print("England")
print("France")
下面是以下代码的截图
Python creates a string with the newline print method
Python 从字典中创建一个字符串
- 现在让我们讨论一下，如何从 Python 字典创建一个字符串。
- Python 中的字典也是可互换的，它有键值对，就像其他编程语言中的映射。
- 如果我们有一个字符串输入，我们希望类似于一个字典对象。
- 这里我们可以使用
eval()函数。eval()方法传递表达式并在程序内部运行 python 表达式(代码)。
举例:
让我们举一个例子来检查如何从字典创建一个字符串
str = "{'John':30,'smith':20,'George':80}"
my_dict= eval(str)
print(my_dict)
print(my_dict['John'])
print(my_dict['George'])
在上面的例子中，我们首先初始化一个字符串，并分配一个键值对元素。之后使用 eval()方法并打印结果。
下面是以下代码的截图
Python creates a string from a dictionary
另一种方法从字典中创建一个字符串
- 在这个方法中，我们可以很容易地使用 generator expression()方法。
- 生成器表达式类似于列表理解，意味着可迭代表达式被立即求值。
- 在这个例子中，我们将检查，如果我们有一个字符串输入，我们希望类似于一个字典对象，那么我们可以很容易地使用 generator)方法。
语法:
下面是生成器表达式()的语法
generator_expression ::= "(" expression _for")"
举例:
让我们举一个例子来检查如何在字典中创建一个字符串
str = "Australia - 60, France - 90, England - 80"
my_Dict = dict((m.strip(), n.strip())
for m, n in (value.split('-')
for value in str.split(', ')))
print(my_Dict)
print(my_Dict['Australia'])
print(my_Dict['England'])
下面是以下代码的截图
Python creates a string from the dictionary generator method
阅读 Python 字典更新
Python 用双引号创建一个字符串
- 在这一节中，我们将讨论 Python 从双引号中创建字符串。
- 双引号代表 python 中的字符串。要将字符串括起来，可以使用双引号，也可以使用单引号来结束字符串。
- 最重要的是 Python 不允许我们在双引号内提供双引号，单引号也是一样。
例子:
让我们举一个例子来看看如何用双引号创建一个字符串
str = "Micheal is a python developer" # Double quotes
print(str)
在上面的代码中，您可以看到，首先，我们使用双引号创建一个字符串，然后在 print 函数中为变量 str 赋值。
下面是以下代码的截图
Python creates a string from double quotes
而在双引号内的情况下
让我们举一个例子，检查在 python 中双引号内的情况下是否正确
str = ""Micheal is a python developer"" # Double quotes
print(str)
在上面的代码中，你可以看到我们在字符串中的双引号内使用了双引号。
下面是以下代码的截图
Python double quotes inside double quotes
正如您所看到的，代码没有成功运行，因为当我们创建一个字符串并在双引号内使用双引号时，它会显示一个无效的语法错误。所以在 Python 中，你只能在字符串中使用双引号。
Python 从字符列表中创建字符串
- 在本节中，我们将讨论 Python 从字符列表中创建字符串。
- 这里，我们将使用
Python join(iterable)函数将字符列表转换成字符串。 - join(iterable)方法对于从 iterable 序列字符创建字符串很有用。
- 这个方法返回一个新的字符串，并连接给定列表中的每个字符。
举例:
让我们举一个例子来检查如何从字符列表中创建一个字符串
list = ["john","is","a","good","boy"] # list of characters
str = "".join(list)
print(str)
在上面的代码中，你可以看到，首先我们创建了一个列表并给它们分配了字符。之后创建一个字符串变量并使用连接()函数。它将以字符串的形式显示结果。
下面是以下代码的截图
Python creates string from list of characters
阅读 python 中的无效语法
从字符列表创建字符串的另一个例子
让我们举一个例子来检查如何通过使用遍历字符串方法从字符列表创建字符串的另一种方法
list = ["Austrailia","Germany","France","England","Switzerland"]
def char(list):
str1=""
for x in list:
str1+= x
return str1
print(char(list))
首先在上面的例子中，我们将创建一个列表并将 string 初始化为""，并使用 for 循环方法遍历一个字符串。它将返回一个新的字符串。
下面是以下代码的截图
Python create string from list of character by traversing method
Python 用分隔符从列表中创建字符串
- 在这一节中，我们将讨论如何用 Python 中的分隔符从列表中创建字符串。
- 在这个方法中，我们可以很容易地使用 join()函数将列表分隔符转换为字符串。
- 该方法将每个列表字符或元素连接成一个逗号分隔的字符串。
- 通过使用。join(iterable)以逗号分隔的“*”作为字符串变量，以列表作为可迭代序列。
- 该方法使用逗号分隔符附加或连接列表中的每个元素，并且总是返回新的字符串形式。
举例:
让我们举一个例子，看看如何用分隔符从列表中创建一个字符串
list = ["Jenkins","is","a","automation","tool"] # list of characters
str = "*".join(list)
print(str)
下面是以下代码的截图
Python create a string from the list with separator
检查如何用分隔符从列表中创建字符串的另一种方法。
让我们举一个例子，使用 loop+str()方法从带分隔符的列表中创建一个字符串
list = ["mangoes","apple","Grapes","orange"]
new_str = "&"
out = ''
for char in list:
out = out + str(char) + new_str
print("Final string : " + str(out))
在上面的例子中，首先，我们初始化一个列表和分隔符。之后使用循环方法添加一个 new_str 变量。输出将显示给定列表中的所有元素都与作为连接者的、&、连接在一起。
下面是以下代码的截图
Python create string from list with separator by loop method
读取语法错误标识符 python3 中的无效字符
Python 用单引号创建字符串
- 让我们看看，如何用单引号创建字符串。
- 单引号表示 python 中的字符串。
- 要将字符串括起来，可以使用单引号，也可以使用双引号来结束字符串。
举例:
让我们举一个例子来检查如何在 Python 中用单引号创建一个字符串。
str = 'James potter'
print(str)
下面是以下代码的截图
Python creates string with single quotes
Python 用多个变量创建字符串
- 在这一节中，我们将讨论如何用多个变量来创建字符串。
- 这里我们将创建三个变量，并用单引号将一个字符串赋值。
- 它将显示所有的字符串。
举例:
让我们举一个例子来检查如何创建一个包含多个变量的字符串
str = 'James potter'
str1 = 'Micheal lucifier'
str3 = 'Mathew hayden'
print(str,str1,str3)
下面是以下代码的截图
Python creates string with multiple variables
python 中的单引号与双引号
- 在 python 中，单引号和双引号这两种方式都是正确的，并给出相同的输出。然而，在某些情况下，这取决于我们可以在同一个字符串中一起使用引号的要求。
- 这两种类型之间的选择取决于程序员。
- 通常，双引号用于字符串表示，单引号用于正则表达式。
例 1:
print('It's Python Guides')
解——上面的例子给出了一个错误，因为【它】后面的单引号被认为是字符串的结尾，其余部分不被认为是字符串，所以抛出了一个错误无效语法。正确的做法是双引号。因此，根据需要，我们可以使用引号。
print("It's Python Guides")
所以从上面的例子中，我们能够区分单引号和双引号的使用。您可以参考下面的输出截图:
Single vs double quotes in python
例 2:
print('You are "good"')
如果您想在 python 中用双引号打印输出，那么您必须给出单引号来打印字符串 "good" ，这是一个双引号。它需要两者同时使用。你可以参考下面的截图。
Single vs double quotes in python
下面是 python 中单引号和双引号的区别。
您可能会喜欢以下 Python 教程:
- Python 3 string replace()方法示例
- Python 比较字符串
- Python 在字符串中查找子串
- 无法将字符串转换为浮点 Python
- Python 中的乘法与例题
- 如何在 Python 中处理 indexerror:字符串索引超出范围
在这个 python 教程中，我们用几个例子来讨论 Python 创建一个字符串。
- Python 字符串
- 用 Python 创建一个字符串
- 如何在 Python 中声明变量并将其赋给字符串
- python 中的多行字符串
- Python 创建一个字符串
- 如何在 Python 中创建字符串的示例
- Python 从列表中创建一个字符串
- Python 创建了一个 n 字符字符串
- Python 用变量创建一个字符串
- Python 创建了一串相同字符
- Python 用换行符创建一个字符串
- Python 从字典创建一个字符串
- Python 用双引号创建一个字符串
- Python 从字符列表创建字符串
- Python 使用分隔符从列表创建字符串
- Python 用单引号创建字符串
- Python 使用多个变量创建字符串
- python 中的单引号和双引号
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
用 Python 创建一个元组
在本 Python 教程中，我们将讨论如何在 Python 中创建一个 tuple，我们将通过实例了解 Python 中的 Tuple。
- Python 中的元组是什么
- 如何在 python 中创建空元组
- 如何在 python 中访问元组项
- 在 tuple python 中添加项目
- python 中元组的长度
- 从元组 python 中移除项目
- 在 Python 中更改元组值
- Python 连接两个元组
- Python 检查元素是否存在于元组中
- 在 python 中循环遍历一个元组
- 在 python 中反转一个元组
- Python 元组与列表
如何用 Python 创建一个 tuple？在 Python 中创建一个 tuple，用圆括号“()”添加项，像 my_tuple =(“红”、“蓝”、“绿”)创建一个空 tuple，用空圆括号“()”不加项。
目录
- Python 中的元组
- 如何在 python 中创建空元组
- 访问 Python 中的元组项
- 在元组 python 中添加条目
- python 中元组的长度
- 从元组 python 中移除项目
- 在 Python 中更改元组值
- Python 连接两个元组
- Python 检查元素是否存在于元组中
- 在 python 中循环遍历一个元组
- 在 python 中反转一个元组
- Python 元组 vs 列表
Python 中的元组
在 python 中，元组是有序且不可变(不可改变)的项目的集合，元组用圆括号 "()" 写成，可以包含混合数据类型。
举例:
my_tuple = ("red", "blue", "green")
print(my_tuple)
写完上面的代码(Python 中的 tuple)，你将打印出 "my_tuple" ，然后输出将显示为"('红色'，'蓝色'，'绿色')"。这里，元组是用某个对象创建的。
可以参考下面的截图Python中的元组。
Tuple in Python
如何在 python 中创建空元组
为了在 Python 中创建一个空元组，使用一个空圆括号 " () " ，其中没有任何条目。
举例:
my_tuple = ()
print(my_tuple)
写完上面的代码(在 python 中创建一个空元组)，你将打印出 "my_tuple" ，然后输出将显示为 " () " 。这里，创建了一个空元组，其中没有对象。
可以参考下面截图如何在 python 中创建空元组。
How to create an empty tuple in python
访问 Python 中的元组项
在 python 中，为了访问元组项，我们可以使用方括号中的索引号从元组中获取指定的项。
举例:
my_tuple = ("red", "blue", "green")
print(my_tuple[2])
写完上面的代码(python 中的访问元组项)，你将打印出“my _ tuple[2]”，然后输出将显示为“绿色”。在这里，我们希望打印元组中的第三项，因此绿色的索引号是“[2]”。
可以参考下面的截图访问 python 中的元组项。
Access tuple items in python
在元组 python 中添加条目
在 python 中，你不能在元组中添加条目，它是被创建的，元组是不可改变的，这意味着我们不能改变。
举例:
my_tuple = ("red", "blue", "green")
my_tuple[3] = "pink"
print(my_tuple)
写完上面的代码(在 tuple python 中添加条目)，你将打印出 "my_tuple" ，然后输出将显示为 " TypeError: 'tuple '对象不支持条目赋值"。在这里，我们不能在元组中添加项目，这将引发一个错误。
你可以参考下面的截图在 tuple python 中添加条目。
Add items in the tuple python
python 中元组的长度
在 python 中，为了得到一个元组的长度，我们将使用 len() 方法，它将返回一个元组中的项数。
举例:
my_tuple = ("red", "blue", "green")
print(len(my_tuple))
写完上面的代码(python 中一个元组的长度)，你将打印出 "len(my_tuple)" ，然后输出将显示为 " 3 " 。这里，len()方法将给出一个元组中一个项的长度。
可以参考下面 python 中一个元组的截图长度。
Length of a tuple in python
从元组 python 中移除项目
在 python 中，我们不能改变条目，因为元组是不可改变的，所以移除特定条目是不可能的，但是我们可以通过使用 python 中的 del() 方法来完全删除元组。
举例:
my_tuple = ("red", "blue", "green")
del my_tuple
print(my_tuple)
在编写完上面的代码(从 tuple python 中移除该项)后，您将打印出(my _ tuple)然后输出将显示为“name error:name‘my _ tuple’未定义”。这里，del()方法将完全删除元组，并抛出一个错误。
可以参考下面的截图从 tuple python 中移除项目。
Remove item from tuple python
在 Python 中更改元组值
在 python 中，我们知道一个人的元组被创建，它不能改变它的值，因为元组是不可变的，但是我们可以通过将元组转换成列表并将列表转换回元组来改变。
举例:
my_tuple = ("red", "blue", "green")
a = list(my_tuple)
a[1] = "black"
my_tuple = tuple(a)
print(my_tuple)
写完上面的代码(在 Python 中更改元组值)，你将打印出(my _ tuple)，然后输出将显示为"('红色'，'黑色'，'绿色')"。这里，元组的元素不能被改变，但是它可以将元组转换成列表，然后改变列表并将其转换回元组。
可以参考下面截图用 Python 修改元组值。
Change tuple values in Python
Python 连接两个元组
在 python 中，我们将使用 '+' 运算符来连接两个或多个元组。
举例:
my_tuple1 = ("red", "blue", "green")
my_tuple2 = (2, 4, 6)
my_tuple3 = my_tuple1 + my_tuple2
print(my_tuple3)
写完上面的代码(python Join two tuple)，你将打印出(my _ tuple 3)，然后输出将显示为 "('red '，' blue '，' green '，2，4，6)。这里，我们通过使用“+”运算符将两个现有元组的值赋给一个新元组。
你可以参考下面的 python 连接二元组的截图
Python Join two tuple
Python 检查元素是否存在于元组中
在 python 中，为了检查指定的元素是否存在于元组中，我们使用“中的”关键字进行检查，如果元素不存在，则不会返回任何内容。
举例:
my_tuple = ("red", "blue", "green")
if "blue" in my_tuple:
print("Yes, blue is present")
在编写完上面的代码(python 检查元素是否存在于元组中)之后，您将打印这些代码，然后输出将显示为“是的，蓝色存在”。这里，如果指定的元素出现在元组中，那么它将返回输出。
你可以参考下面的截图 python 检查元素是否存在于元组中。
Python check if element exists in a tuple
在 python 中循环遍历一个元组
在 python 中，我们使用 for 循环来遍历元组元素以打印值。
举例:
my_tuple = ("red", "blue", "green")
for a in my_tuple
print(a)
写完上面的代码(在 python 中循环遍历一个元组)，你将打印出(a)，然后输出将显示为【红蓝绿】。这里，通过使用 for 循环，它可以遍历元组项。
可以参考下面的截图 python 连接二元组。
Loop through a tuple in python
在 python 中反转一个元组
在 python 中，我们将使用名为 reversed() 的内置方法对元组进行反转，反转后的元组在打印前转换为元组。
举例:
my_tuple = ("red", "blue", "green")
reverse = reversed(my_tuple)
print(tuple(reverse))
写完上面的代码(在 python 中反转一个元组)，你将打印出 "tuple(reverse)" ，然后输出将显示为"('绿色'，'蓝色'，'红色')"。这里，通过使用 reversed()方法，元素被反转。
你可以参考下面的截图用 python 反转一个元组。
Reverse a tuple in python
Python 元组 vs 列表
| 元组 | 列表 |
| 元组具有静态特征 | 该列表具有动态特征 |
| 元组的功能较少 | 列表比元组有更多的功能 |
| 元组是不可变的 | 列表是可变的 |
| 元组比列表消耗更少内存 | 列表消耗更多的内存 |
| 元组用圆括号()括起来 | 列表通常用方括号[]括起来 |
| 元组语法:
my_tuple=(1，2，3，4，5) | 列表语法:
my_list=[1，2，3，4，5] |
您可能会喜欢以下 Python 教程:
- Python 创建空集
- Python 关键字与示例
- Python While 循环示例
- Python 中的字符串方法及示例
- Python 检查变量是否为整数
- 检查一个数是否是素数 Python
- Python 将元组转换为列表
- Python 输入和 raw_input 函数
在本 Python 教程中，我们学习了如何在 Python 中创建一个元组，我们还看到了:
- Python 中的元组是什么
- 如何在 python 中创建空元组
- 如何在 python 中访问元组项
- 在 tuple python 中添加项目
- python 中元组的长度
- 从元组 python 中移除项目
- 在 Python 中更改元组值
- Python 连接两个元组
- Python 检查元素是否存在于元组中
- 在 python 中循环遍历一个元组
- 在 python 中反转一个元组
- Python 元组与列表
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
在 Python 中创建一个空数组
原文：https://pythonguides.com/create-an-empty-array-in-python/
在这个 Python 教程中，我们将讨论 Python 中的内置支持如何为数组工作。同样，我们可以通过使用 Python list 和一些例子来创建一个数组。
- 如何创建空数组
- 如何在 Python 中创建空的 2D 数组
- 如何在 python 中反转数组
- 从数组 python 中移除元素
- 如何在 python 中对数组求和
- 检查数组是否为空 python
目录
- 创建空数组 Python
- 在 Python 中创建空的 2D 数组
- 如何在 python 中反转数组
- 从数组 python 中移除元素
- 如何在 python 中对数组求和
- 检查数组是否为空 python
创建空数组 Python
在 python 中，我们没有对数组的内置支持，但是可以使用 python 列表。创建一个列表[0]并乘以数字，然后我们将得到一个空数组。
举例:
my_list = [0]*3
print(my_list)
写完上面的代码(创建空数组 Python)，你将打印出 " my_list " 然后输出将显示为 " [ 0，0，0 ] " 。在这里，我们创建了一个列表[0]并将其乘以“x ”,其中“x”可以是任何数字，以获得长度，每个元素都将是“0”。
你可以参考下面的截图在 Python 中创建空数组
Create empty array Python
这就是我们如何在 python 中创建空数组。
我们还可以通过列表理解在 python 中创建一个空数组，其中我们将使用带有 range()的 for 循环。
举例:
my_array = [0 for a in range(3)]
print(my_array)
写完上面的代码(创建空数组 Python)，你将打印出 " my_array " 然后输出将显示为 " [ 0，0，0 ] " 。这里，for 循环遍历一个序列，range()生成一个带有数字的序列，并创建一个空数组。
你可以参考下面的截图在 Python 中创建空数组
Create an empty array in Python
这就是我们如何在 python 中创建空数组的方法
在 Python 中创建空的 2D 数组
在 python 中，我们可以通过使用列表在 python 中创建 2D 数组。 2D 数组是数组中的数组。在 2D 数组中，元素的位置由 2 表示，由行和列表示。
举例:
my_rows, my_cols = (3, 4)
my_array = [[0]*my_cols]*my_rows
print(my_array)
写完上面的代码(用 Python 创建一个空的 2D 数组)，你将打印出 " my_array " 然后输出将显示为 " [ [0，0，0，0]，[0，0，0]，[0，0，0] ] " 。这里，行是 3，列是 4，列表是[0]，它与行和列相乘。
你可以参考下面的截图在 Python 中创建空的 2D 数组
Create empty 2D arrays in Python
这就是我们如何在 python 中创建空的 2D 数组。
如何在 python 中反转数组
在 python 中，为了反转 python 中的数组，我们有一个名为 reverse() 的内置方法，它将反转项目。
举例:
my_array = [10, 11, 12, 13]
my_array.reverse()
print('After reversing my array:', my_array)
写完上面的代码(如何在 python 中反转一个数组)，你将打印出 " my_array " ，然后输出将显示为 " [ 13，12，11，10 ] " 。在这里，reverse()方法将反转项目的顺序。
你可以参考下面的截图如何在 python 中反转一个数组
How to reverse an array in python
这是如何在 python 中反转一个数组
从数组 python 中移除元素
在 python 中，要从数组中移除元素，我们可以使用 pop() 方法从列表 python 中移除特定的元素。
举例:
my_array = [101, 102, 103]
my_array.pop(2)
print(my_array)
写完上面的代码后(从数组 python 中移除一个元素)，你将打印出 " my_array " ，然后输出将显示为 " [ 101，102 ] " 。这里，pop()方法将从数组中移除指定的元素。
你可以参考下面的截图如何从数组 python 中移除元素
Remove element from array python
这就是我们如何从数组 python 中移除柠檬的方法
如何在 python 中对数组求和
在 python 中，为了对数组中的元素求和，我们将使用来循环通过一个数组，它将在每次迭代中添加元素的值。
举例:
my_array = [150, 151, 152]
sum = 0;
for a in range(0, len(my_array)):
sum = sum + my_array[a];
print("Sum of element in an array: " + str(sum));
写完上面的代码(如何在 python 中对数组求和)，你将打印出 " sum " ，然后输出将显示为"数组中元素的总和:453 " 。这里，我们将使用 for 循环，它将在每次迭代中添加所有元素。
你可以参考下面的截图如何在 python 中对数组求和
How to sum an array in python
这是如何在 python 中对数组求和
检查数组是否为空 python
在 python 中，为了检查数组是否为空，我们将使用 if 条件来检查数组是否为空。
举例:
my_array = []
if not my_array:
print("My array is empty")
写完上面的代码(检查一个数组是否是空的 python)，你将打印这些代码，然后输出将显示为“我的数组是空的”。这里，我们将使用 if 条件来检查我的数组是否为空。
你可以参考下面的截图检查一个数组是否为空 python。
Check if an array is empty python
这就是我们如何检查一个数组是否为空 python
您可能会喜欢以下 Python 教程:
- python 中的无效语法
- 语法错误标识符 python3 中的无效字符
- Python 加法示例
- Python 中的乘法与例题
- 如何在 Python 中处理 indexerror:字符串索引超出范围
- 解析 Python 时出现意外的 EOF
在本教程中，我们学习了如何在 python 中使用数组。
- 如何创建空数组
- 如何在 Python 中创建空的 2D 数组
- 如何在 python 中反转数组
- 从数组 python 中移除元素
- 如何在 python 中对数组求和
- 检查数组是否为空 python
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
用 Python 创建和修改 PDF 文件
原文：https://pythonguides.com/create-and-modify-pdf-file-in-python/
在本 Python 教程中，我们将学习如何在 Python 中创建和修改 pdf 文件，我们还将涉及以下主题:
- 如何用 python 创建 pdf 文件
- 使用 A4 尺寸创建 pdf
- 采用 A5 尺寸创建 pdf
- 使用 python 创建 pdf 格式的表格
- 使用 python 在 pdf 中创建带有网格的表格
- Python 从图像创建 pdf
- 如何在 python 中旋转 pdf
- 如何创建一年中天数的 pdf python
- Python 从 HTML 创建 pdf
- Python 从文本文件创建 pdf
- Python 从图像创建 pdf，每个页面都有单独的图像大小
PDF–便携文档格式
为了在 Python 中创建 pdf，我们可以采用不同大小的页面，例如:
- A4 号
- A3 号
- A5 号
- 信
- 合法的
目录
- 如何用 python 创建 pdf 文件
- 在 Python 中以 A4 尺寸创建 pdf
- 在 Python 中采用 A5 大小创建 pdf
- 使用 Python 创建 pdf 格式的表格
- 使用 python 创建 pdf 格式的表格
- Python 从图像创建 pdf
- 如何在 Python 中旋转 pdf
- 如何创建一年中天数的 pdf python
- Python 从 HTML 创建 pdf
- Python 从文本文件创建 pdf
- Python 从图像创建 pdf，每个页面都有单独的图像大小
如何用 python 创建 pdf 文件
现在，我们可以看到如何用 python 创建一个 pdf 文件。
- 在这个例子中，我从 FPDF 导入了一个名为 FPDF 的模块。fpdf 是一个用于在 python 中生成 pdf 文档的库。
- 为了添加页面，我使用了
pdf.add_page()并设置了使用的字体。在这里，我使用了Arial-type字体，并指定字号= 14。 pdf.cell用于打印带有可选边框和背景的单元格。- 将宽度= 200 、高度= 10 、 txt = "欢迎使用 PythonGuides "、和长度= 1 并取左对齐为
align="L"。 - 为了生成 pdf 文件，我使用了
pdf.output("python.pdf")。python.pdf 的是带有扩展名的 pdf 的名称。
示例:
from fpdf import FPDF
pdf = FPDF()
pdf.add_page()
pdf.set_font("Arial", size=14)
pdf.cell(200, 10, txt="Welcome to PythonGuides", ln=1, align="L")
pdf.output("python.pdf")
我们可以看到生成的 pdf 文件作为输出。您可以参考下面的输出截图。
How to create a pdf file in python
这就是如何在 Python 中创建 pdf 文件。
你可能会喜欢 Python 串联列表和 Python 字符串格式化示例。
在 Python 中以 A4 尺寸创建 pdf
现在，我们可以看到如何在 python 中以 A4 大小创建 pdf。
- 在这个例子中，我从 fPDF 中导入了一个名为 FPDF 的模块，并声明了一个变量为 pdf，并指定了 orientation =‘p’，其中 p 为纵向，单位为尺寸，格式为‘A4’。
- 字体取“Arial”，size=20，单元格取 200，10，“欢迎使用 python guides”是要写入 pdf 文件的文本，长度赋值为 length=1，对齐方式设置为左对齐。
- 为了生成 pdf 文件，我使用了
pdf.output("kushi.pdf")。kushi是带有扩展名的文件名。
示例:
from fpdf import FPDF
pdf = FPDF(orientation='P', unit='mm', format='A4')
pdf.add_page()
pdf.set_font("Arial", size=20)
pdf.cell(200, 10, txt="Welcome to PythonGuides", ln=1, align="L")
pdf.output("kushi.pdf")
在这里，我们可以看到以 A4 格式生成的 pdf 作为输出。您可以参考下面的输出截图。
Create pdf by taking size A4
这就是如何在 Python 中以 A4 大小创建 pdf。
在 Python 中采用 A5 大小创建 pdf
现在，我们可以看到如何通过在 python 中取大小 A5 来创建 pdf。
- 在这个例子中，我从 fPDF 中导入了一个名为 FPDF 的模块，并声明了一个变量为 pdf，并指定了 orientation =‘p’，其中 p 为纵向，单位为
mm，格式为‘A5’。 - 字体取“Arial”，size=20，单元格取 200，10，“欢迎使用 python guides”是要写入 pdf 文件的文本。长度=1，对齐方式设置为左对齐。
- 为了生成 pdf 文件，我使用了
pdf.output("kushi.pdf")。kushi 是文件名加上和扩展名。
示例:
from fpdf import FPDF
pdf = FPDF(orientation='P', unit='mm', format='A5')
pdf.add_page()
pdf.set_font("Arial", size=15)
pdf.cell(200, 10, txt="Welcome to PythonGuides", ln=1, align="L")
pdf.output("kushi.pdf")
在这里，我们可以看到以 A5 格式生成的 pdf 作为输出。您可以参考下面的输出截图。
这就是如何在 Python 中以 A5 大小创建 pdf。
你可能喜欢如何在 Python 中读取视频帧？
使用 Python 创建 pdf 格式的表格
在这里，我们可以看到如何使用 python 在 pdf 中创建表格。
- 在这个例子中，我从 reportlab.lib 导入了名为 colors 的模块，从 reportlab.lib.pagesizes 导入了模块 A4。还从 reportlab.platypus. 导入了 SimpleDocTemplate、Table、TableStyle 等模块
pdf.cell用于打印带有可选边框和背景的单元格。- 名为 document 的变量被声明并赋值为 SimpleDocTemplate(" table.pdf "，pagesize=A4) ，table . pdf 是 pdf 文件的名称，页面大小为 A4。
- 一个空变量被声明为条目，另一个变量被声明为包含一些条目的数据。
- 为了创建一个表格，我使用了
t=Table(data)并将条目插入到表格items.append(t)中。 document.build(items)用于自动生成 pdf。
示例:
from reportlab.lib import colors
from reportlab.lib.pagesizes import A4
from reportlab.platypus import SimpleDocTemplate, Table, TableStyle
document = SimpleDocTemplate("table.pdf", pagesize=A4)
items = []
data= [['Apple', 'Mango', 'Kiwi'],
['Tomato', 'Potato', 'Peas']]
t=Table(data)
items.append(t)
document.build(items)
下面的屏幕截图显示了生成的 pdf，输出为不带网格的表格。
Create a table in pdf using python
这就是如何使用 python 在 pdf 中创建表格。
使用 python 创建 pdf 格式的表格
在这里，我们可以看到如何使用 python 在 pdf 中创建带有网格的表格。
- 在这个例子中，我从 reportlab.lib 中导入了一个名为 colors 的模块，从 reportlab.lib.pagesizes. 中导入了 letter，inch
- ****颜色模块有一些我们可以使用的预定义的基本颜色。
- 模块 SimpleDocTemplate，Table，TableStyle 是从 reportlab.platypus 导入的。
- 一个空变量被声明为条目，另一个变量被声明为包含一些条目的数据。
- 为了创建一个表格，我使用了
t=Table(data)并将条目插入到表格items.append(t)中。 - Reportlab 中的索引从第一行第一列的
(0, 0)开始。 - 所以
(1, 1)只将样式应用于第一行下面和第一列右边的所有内容。 - 为了得到 2 行 5 列，我使用了 t=Table(data，5[1inch]，2[1inch]) 。
- 表格的样式由对齐方式给出，如右对齐和上对齐，也使用了变号。
- INNERGRID 用于拆分表格。
items.append(t)用于将数据追加到表格中。document.build(items)用于自动生成 pdf。
**示例:
from reportlab.lib import colors
from reportlab.lib.pagesizes import letter, inch
from reportlab.platypus import SimpleDocTemplate, Table, TableStyle
document = SimpleDocTemplate("table.pdf", pagesize=letter)
items = []
data= [['0', '2', '4', '6', '8'],
['10', '12', '14', '16', '18']]
t=Table(data,5*[1*inch], 2*[1*inch])
t.setStyle(TableStyle([('ALIGN',(1,1),(-2,-2),'RIGHT'),
('VALIGN',(-1,-1),(-1,-1),'RIGHT'),
('ALIGN',(-1,-1),(-1,-1),'RIGHT'),
('VALIGN',(-1,-1),(-1,-1),'TOP'),
('INNERGRID', (0,0), (-1,-1), 1, colors.black),
('BOX', (0,0), (-1,-1), 0.25, colors.black),]))
items.append(t)
document.build(items)
下面的屏幕截图显示了输出:
Create a table with the grid in pdf using python
这就是如何使用 python 在 pdf 中用网格创建一个表格。
Python 从图像创建 pdf
在这里，我们可以看到如何用 python 从图像创建 pdf。
- 在这个例子中，我从
PIL和OS导入了一个名为img2pdf的模块和模块映像。 - 该变量被声明为 imagepath，并被赋予图像的路径。
- 这里
cartoon.pdf是要创建的 pdf 的名称。 - 使用 f.write 在 pdf 中写入图像文件，然后使用 file.close()关闭文件。
示例:
import img2pdf
from PIL import Image
import os
imagepath = r"C:\Users\Administrator.SHAREPOINTSKY\Downloads\mickey.png"
pdfname = "cartoon.pdf"
image = Image.open(imagepath)
pdf_bytes = img2pdf.convert(image.filename)
file = open(pdfname, "wb")
file.write(pdf_bytes)
image.close()
file.close()
我们可以看到图像文件是 pdf 格式的输出。您可以参考下面的输出截图:
Python create pdf from images
这就是如何用 Python 从图像中创建 pdf。
如何在 Python 中旋转 pdf
现在，我们可以看到如何在 python 中旋转 pdf 。
- 在这个例子中，我导入了一个名为
pikepdf的模块，为了选择 pdf，我使用了 pdf = pikepdf。Pdf.open('卡通. Pdf ')。 cartoon.pdf是用于循环旋转 pdf 的文件名，我已经使用了页面。旋转= 180 度。- 为了用另一个名字保存新的旋转 pdf 文件，我使用了pdf . save(' rotated . pdf ')【rotated.pdf】的是新文件的名字。
示例:
import pikepdf
pdf = pikepdf.Pdf.open('cartoon.pdf')
for page in pdf.pages:
page.Rotate = 180
pdf.save('rotated.pdf')
下面的屏幕截图显示了输出:
How to rotate the pdf in python
这就是如何在 Python 中旋转 pdf。
如何创建一年中天数的 pdf python
现在，我们可以看到如何用 python 创建一年中天数的 pdf。
- 在这个例子中，我从report lab . lib 中导入了一个名为
inch的模块，从 reportlab.lib 中导入了颜色，并从 reportlab.lib.pagesizes. 中导入了A4 - 模块 SimpleDocTemplate，Table，TableStyle 从 reportlab.platypus 导入。
- 从 reportlab.graphics.shapes. 导入模块图纸****
- 为了获得 pdf 格式的日历，我导入了一个名为日历的模块。
- 一个空变量被声明为条目，另一个变量被声明为包含一些条目的数据。
- 为了指定一周中的每一天，我使用了cal =[' Mon '，' Tue '，' Wed '，' Thu '，' Fri '，' Sat '，' Sun']] 。
- 。extend 用于将元素添加到表中。
- 为了划分表格的行和列，我使用了 table = Table(cal，7*[inch]，len(cal) * [inch])。
- 我使用了 Helvetica 字体并根据要求对齐，内部网格用蓝色着色，盒子用红色着色。
document.build(items)用于自动生成 pdf。
示例:
from reportlab.lib.units import inch
from reportlab.lib import colors
from reportlab.lib.pagesizes import A4
from reportlab.platypus import SimpleDocTemplate, Table, TableStyle
from reportlab.graphics.shapes import Drawing
import calendar
doc = SimpleDocTemplate('cal.pdf', pagesize=A4)
items = []
cal = [['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']]
cal.extend(calendar.monthcalendar(2021,2))
table = Table(cal, 7*[inch], len(cal) * [inch])
table.setStyle(TableStyle([
('FONT', (0, 0), (-1, -1), 'Helvetica'),
('FONT', (0, 0), (-1, 0), 'Helvetica-Bold'),
('FONTSIZE', (0, 0), (-1, -1), 8),
('INNERGRID', (0, 0), (-1, -1), 0.5, colors.blue),
('BOX', (0, 0), (-1, -1), 0.5, colors.red),
('ALIGN', (0, 0), (-1, -1), 'CENTER'),
('VALIGN', (0, 0), (-1, -1), 'MIDDLE'),
]))
items.append(table)
doc.build([table])
下面的截图显示了 pdf 格式的日历作为输出。
How to create a pdf of days in a year python
这就是如何在 Python 中创建一年中天数的 pdf。
Python 从 HTML 创建 pdf
- 首先，我们必须通过使用 pip 安装 pdfkit 来安装
pdfkit。 - 我们必须使用链接下载 WKHTMLTOPDF:WKHTMLTOPDF
- 下载后，我们必须复制 wkhtmltopdf 文件的路径，并将其粘贴到环境变量中。
在这里，我们可以看到如何用 python 从 HTML 创建 pdf。
- 在这个例子中，我导入了一个名为
pdfkit的模块。 - 文件的路径和
.exe.一起分配，定义变量 config，分配pdfkit.configuration()，以配置选项为初始参数 - 为了将 html 文件转换成 pdf，我使用了pdf kit . from _ file(' kavita . html '，' newfile.pdf '，configuration=config。
kavita.html是 Html 文件的名称，newfile 是生成的 pdf 文件。
示例:
import pdfkit
path_wkhtmltopdf = r'C:/Users/Administrator.SHAREPOINTSKY/Desktop/Work/wkhtmltopdf/bin/wkhtmltopdf.exe'
config = pdfkit.configuration(wkhtmltopdf=path_wkhtmltopdf)
pdfkit.from_file('kavita.html', 'newfile.pdf', configuration=config)
我们可以看到生成的新 pdf 作为输出。您可以参考下面的输出截图。
Python create pdf from HTML
这就是我们如何用 Python 从 HTML 中创建 pdf。
Python 从文本文件创建 pdf
在这里，我们可以看到如何用 python 从文本文件创建 pdf。
- 在这个例子中，我从 fpdf 导入了一个名为 FPDP 的模块。这是一个用来生成 pdf 文档的库。
- 为了添加页面，我使用了
pdf.add_page()来设置字体“Arial”并指定 size = 15。 - 为了打开文件，我已经指定了文件的路径和用于读取文件的
"r"。 - 使用 for 循环，单元格的大小给定为 pdf.cell(200，10，txt = x，ln = 5，align = 'L') ，对齐为左。
- 为了获得生成的 pdf，我使用了 pdf.output("textfile.pdf ")。
示例:
from fpdf import FPDF
pdf = FPDF()
pdf.add_page()
pdf.set_font("Arial", size = 15)
f = open(r"C:\Users\Administrator.SHAREPOINTSKY\Desktop\Work\my_file.txt", "r")
for x in f:
pdf.cell(200, 10, txt = x, ln = 5, align = 'L')
pdf.output("textfile.pdf")
下面的屏幕截图显示了生成的 pdf 作为输出:
python create a pdf text file
这就是我们如何用 Python 从文本文件中创建 pdf。
Python 从图像创建 pdf，每个页面都有单独的图像大小
在这里，我们可以看到如何用 python 从图像创建 pdf，每个页面都有单独的图像大小。
- 在这里，我从
PIL导入了一个名为 Image 的模块，还导入了img2pdf，为了打开文件，我使用了 with open(' cartonsize . pdf '，' wb ')作为 f，'wb'模式用于以二进制模式写入文件。 - 页面的大小被指定为 image.width，50 和 image.height，50 。FitMode 用于填充精确的缩小放大。
- 将图像写入 pdf 文件
f.write用于将图像转换为 pdf 文件，并分配文件路径。 - 我们可以在 pdf 的一角看到页数。
示例:
from PIL import Image
import img2pdf
with open( 'cartoonsize.pdf', 'wb' ) as f:
image = Image.open( r'C:\Users\Administrator.SHAREPOINTSKY\doll.jpg' )
my_layout_fun = img2pdf.get_layout_fun(
pagesize = ( img2pdf.px_to_pt( image.width, 50 ), img2pdf.px_to_pt( image.height, 50) ),
fit = img2pdf.FitMode.into
)
f.write( img2pdf.convert( [r'C:\Users\Administrator.SHAREPOINTSKY\doll.jpg', r'C:\Users\Administrator.SHAREPOINTSKY\Desktop\Work\cat.jpg'], layout_fun = my_layout_fun ))
在这里，我们可以看到两页 pdf，其中包含指定了大小的图像作为输出。您可以参考下面的输出截图:
Python create pdf from images with each page having individual image sizes
您可能会喜欢以下 Python 教程:
- 使用 Python Pygame(井字游戏)创建一个游戏
- Python 熊猫 CSV 教程
- 如何用 Python 把 DateTime 转换成 UNIX 时间戳
- Python 捕捉多个异常
- Python Pygame 教程
- Python 字符串函数
- Python 命名约定
- Python 集合的交集
在本教程中，我们学习了 python 中的创建和修改 pdf 文件,也涵盖了以下主题:
- 如何用 python 创建 pdf 文件
- 使用 A4 尺寸创建 pdf
- 采用 A5 尺寸创建 pdf
- 使用 python 创建 pdf 格式的表格
- 使用 python 在 pdf 中创建带有网格的表格
- Python 从图像创建 pdf
- 如何在 python 中旋转 pdf
- 如何创建一年中天数的 pdf python
- Python 从 HTML 创建 pdf
- Python 从文本文件创建 pdf
- Python 从图像创建 pdf，每个页面都有单独的图像大小
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
如何使用 Python Tkinter 创建倒计时定时器(一步一步)
原文：https://pythonguides.com/create-countdown-timer-using-python-tkinter/
在本 Python Tkinter 教程中，我们将一步一步的讨论如何使用 Python Tkinter 创建倒计时定时器。这里，我们将使用 Python Tkinter 创建一个简单的基于 GUI 的倒计时器。
使用 Python Tkinter 创建倒计时定时器
现在，让我们看看如何使用 Python Tkinter 创建一个倒计时器。
需求分析
创建一个倒计时定时器，接受用户使用 Python Tkinter 设置的小时、分钟和秒。不强制要求提供所有信息，但应该有零个。当用户点击开始按钮时，计数器应该开始递减计数。
源代码解释
下面是使用 Tkinter 在 Python 中创建倒计时定时器的代码解释。请留下您的评论，以防您有任何不明白的地方，或者它对您不起作用。我们在 ubuntu 操作系统上编写了这个代码，但是这个代码可以在 Windows 和 Macintosh 上运行。
import time
from tkinter import *
from tkinter import messagebox
- 使用的模块:我们在这段代码中使用了三个导入的模块
- 时间:时间模块用于执行睡眠操作
tkinter模块用于创建所有图形用户界面messagebox:用于显示提示信息。
ws = Tk()
ws.geometry("300x250+1500+700")
ws.title("PythonGuides")
ws.config(bg='#345')
- 创建或初始化窗口。T2
ws = Tk() - 几何体用于设置应用程序的高度、宽度&位置
- 300 是宽度
- 250 是身高
- 1500 是屏幕上的
x位置 - 700 是屏幕上的
y位置
title用于提供出现在窗口顶部的应用程序的名称。ws.config用于设置应用的背景颜色
hour=StringVar()
minute=StringVar()
second=StringVar()
hour.set("00")
minute.set("00")
second.set("10")
StringVar()用于创建文本变量，在这种情况下，当程序中的文本需要多次改变时，使用文本变量。- hour.set("00 ")这里我们为 textvariable 提供了默认值。因此，当程序将被执行时，它将显示 00 代替标签
hour_tf= Entry(
ws,
width=3,
font=f,
textvariable=hour
)
hour_tf.place(x=80,y=20)
mins_tf= Entry(
ws,
width=3,
font=f,
textvariable=minute)
mins_tf.place(x=130,y=20)
sec_tf = Entry(
ws,
width=3,
font=f,
textvariable=second)
sec_tf .place(x=180,y=20)
- 为小时、分钟和秒创建了三个输入框。每个输入框的宽度为 3，字体大小为 24，包含不同的文本变量。
- 位置几何管理器用于定位部件。
start_btn = Button(
ws,
text='START',
bd='5',
command= startCountdown
)
start_btn.place(x = 120,y = 120)
- 创建了一个名为“开始”的按钮。此按钮包含将触发倒计时活动的命令。
- 包装几何管理器用于将其定位在屏幕上。
def startCountdown():
try:
userinput = int(hour.get())*3600 + int(minute.get())*60 + int(second.get())
except:
messagebox.showwarning('', 'Invalid Input!')
while userinput >-1:
mins,secs = divmod(userinput,60)
hours=0
if mins >60:
hours, mins = divmod(mins, 60)
hour.set("{0:2d}".format(hours))
minute.set("{0:2d}".format(mins))
second.set("{0:2d}".format(secs))
ws.update()
time.sleep(1)
if (userinput == 0):
messagebox.showinfo("", "Time's Up")
userinput -= 1
- startCountdown() 函数是这个程序中最重要的一段代码，因为它保存了按照要求执行代码的命令。
- userinput 变量保存用户在界面中提供的信息。。get() 方法提取输入框中提供的信息
- 1 小时有 3600 秒，1 分钟有 60 秒。因此，如果用户输入 2 小时，这意味着它变成 7200 秒，分钟也是类似的情况。
- 因此，我们将小时和分钟转换为秒，并将它们相加，得到总秒数。
- 此外，我们将 userinput 保存在一个
try-catch块中，这样，如果用户提供了除数字之外的其他输入，就会出现错误提示。 - 当循环开始时&将继续循环，直到总秒数小于 0 或-1。
- 使用了内部循环
divmod()函数。divmode 类似于“//”运算符。它仅在执行除法后返回整数值。 - 之前我们一起积累了小时、分钟和秒，现在我们把它们分开。
- 倒计时信息显示后
- 计数是以递减的顺序进行的，每秒钟总秒数减 1，直到总秒数小于 0。
- 当循环条件变为假时，程序将被执行，并提示“时间已到”。
完整源代码:
这是使用 Python Tkinter 创建倒计时定时器的完整源代码，你也可以看到输出。
import time
from tkinter import *
from tkinter import messagebox
f = ("Arial",24)
ws = Tk()
ws.geometry("300x250+1500+700")
ws.title("PythonGuides")
ws.config(bg='#345')
hour=StringVar()
minute=StringVar()
second=StringVar()
hour.set("00")
minute.set("00")
second.set("10")
hour_tf= Entry(
ws,
width=3,
font=f,
textvariable=hour
)
hour_tf.place(x=80,y=20)
mins_tf= Entry(
ws,
width=3,
font=f,
textvariable=minute)
mins_tf.place(x=130,y=20)
sec_tf = Entry(
ws,
width=3,
font=f,
textvariable=second)
sec_tf.place(x=180,y=20)
def startCountdown():
try:
userinput = int(hour.get())*3600 + int(minute.get())*60 + int(second.get())
except:
messagebox.showwarning('', 'Invalid Input!')
while userinput >-1:
mins,secs = divmod(userinput,60)
hours=0
if mins >60:
hours, mins = divmod(mins, 60)
hour.set("{0:2d}".format(hours))
minute.set("{0:2d}".format(mins))
second.set("{0:2d}".format(secs))
ws.update()
time.sleep(1)
if (userinput == 0):
messagebox.showinfo("", "Time's Up")
userinput -= 1
start_btn = Button(
ws,
text='START',
bd='5',
command= startCountdown
)
start_btn.place(x = 120,y = 120)
ws.mainloop()
输出:
下面是上面代码的输出。用户可以编辑屏幕上显示的数字。开始按钮将启动倒计时，一旦倒计时回到零，它将显示时间的消息提示。
python tkinter countdown timer
您可能会喜欢以下 Python Tkinter 教程:
- 用 Python Tkinter 上传文件
- Python Tkinter 拖拽
- Python Tkinter Map()函数
- 如何使用 Python Tkinter 创建日期时间选择器
- 如何进入 Python Tkinter 程序的下一页
- Python Tkinter 滚动条–如何使用
- Python Tkinter 测验
在本教程中，我们学习了如何使用 Python Tkinter 创建倒计时定时器。
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
如何使用 Python Tkinter 创建日期时间选择器
原文：https://pythonguides.com/create-date-time-picker-using-python-tkinter/
在这个 Python 教程中，我们将学习如何使用 Python Tkinter 创建数据时间选择器。您一定在每次单击表单中的日期选项时都观察到了日历视图的外观。我们将创建一个类似的界面。
你是 Python tkinter 的新手吗，看看 Python GUI 编程。
目录
在 Python Tkinter 中创建环境
在安装任何库之前创建一个环境总是一个好的做法。创建一个环境，然后安装库，这样您就可以共享项目，而无需用户担心依赖性。
- 我们将使用
virtualenv包来创建一个虚拟环境。 - 我们将在全球范围内安装 virtualenv。要全局安装 virtualenv，请键入以下命令:
pip install virtualenv
可能的错误信息
- 要求已经满足如果您看到此消息，说明您的系统上已经安装了 virtualenv。
- 找不到命令“pip”这意味着您的 Linux 或 Mac 机器上没有安装 pip。点击这里了解安装过程。
- ‘pip’不被识别为内部或外部命令这意味着您的 Windows 机器上没有安装 pip。点击这里了解如何安装 pip。如果您确定安装了 pip，那么它可能没有设置为 PATH。点击这里了解如何将 pip 添加到路径中。
Windows 上的虚拟环境
- 在创建虚拟环境之前，创建一个项目文件夹，并移动到该文件夹。
- 在我们的例子中，我们已经创建了一个名为 date_picker，的项目文件夹，现在使用 cmd 命令，我们已经使用命令
cd date_picker移动到这个文件夹
virtualenv env
- 该命令将创建一个名为
env的虚拟环境文件夹 - env 是一个标准的名字，但是你可以保留任何你喜欢的名字。
- 一旦创建了环境，我们需要激活环境
- 要激活环境，请遵循以下代码。
env\Scripts\activate
python tkinter date time picker
Mac 或 Linux 上的虚拟环境
- 在创建虚拟环境之前，创建一个项目文件夹，并移动到该文件夹。
- 在我们的例子中，我们已经创建了一个名为 date_picker，的项目文件夹，现在使用终端，我们已经使用命令
cd date_picker移动到这个文件夹
virtualenv env
- 该命令将创建一个名为
env的虚拟环境文件夹 - env 是一个标准的名字，但是你可以保留任何你喜欢的名字。
- 一旦创建了环境，我们需要激活环境
- 要激活环境，请遵循以下代码。
Source env/bin/activate
Python Tkinter Date Time Picker
安装 Python Tkcalendar 库
现在，让我们看看如何安装 Python Tkcalendar 库。
现在，一旦我们创建并激活了我们的虚拟环境，我们需要安装 Python tkcalender 来开始这个项目。
Python Tkinter Date Time Picker
tkcalendar 是一个 python 模块，为 Tkinter 提供 calendar 和 DateEntry 小部件。DateEntry 小部件类似于 Combobox，但是下拉列表不是列表，而是用于选择日期的日历。
下面是在您的环境中安装 tkcalendar 的代码。
pip install tkcalendar
Install Python Tkcalendar library.
使用 Python Tkinter 创建日期时间选择器
在这个应用程序中，用户将得到一个日历来选择一个日期和数字时钟，其中用户可以设置任何时间。
代码:
from tkinter import *
from tkcalendar import *
ws = Tk()
ws.title("Python Guides")
ws.geometry("500x400")
ws.config(bg="#cd950c")
hour_string=StringVar()
min_string=StringVar()
last_value_sec = ""
last_value = ""
f = ('Times', 20)
def display_msg():
date = cal.get_date()
m = min_sb.get()
h = sec_hour.get()
s = sec.get()
t = f"Your appointment is booked for {date} at {m}:{h}:{s}."
msg_display.config(text=t)
if last_value == "59" and min_string.get() == "0":
hour_string.set(int(hour_string.get())+1 if hour_string.get() !="23" else 0)
last_value = min_string.get()
if last_value_sec == "59" and sec_hour.get() == "0":
min_string.set(int(min_string.get())+1 if min_string.get() !="59" else 0)
if last_value == "59":
hour_string.set(int(hour_string.get())+1 if hour_string.get() !="23" else 0)
last_value_sec = sec_hour.get()
fone = Frame(ws)
ftwo = Frame(ws)
fone.pack(pady=10)
ftwo.pack(pady=10)
cal = Calendar(
fone,
selectmode="day",
year=2021,
month=2,
day=3
)
cal.pack()
min_sb = Spinbox(
ftwo,
from_=0,
to=23,
wrap=True,
textvariable=hour_string,
width=2,
state="readonly",
font=f,
justify=CENTER
)
sec_hour = Spinbox(
ftwo,
from_=0,
to=59,
wrap=True,
textvariable=min_string,
font=f,
width=2,
justify=CENTER
)
sec = Spinbox(
ftwo,
from_=0,
to=59,
wrap=True,
textvariable=sec_hour,
width=2,
font=f,
justify=CENTER
)
min_sb.pack(side=LEFT, fill=X, expand=True)
sec_hour.pack(side=LEFT, fill=X, expand=True)
sec.pack(side=LEFT, fill=X, expand=True)
msg = Label(
ws,
text="Hour Minute Seconds",
font=("Times", 12),
bg="#cd950c"
)
msg.pack(side=TOP)
actionBtn =Button(
ws,
text="Book Appointment",
padx=10,
pady=10,
command=display_msg
)
actionBtn.pack(pady=10)
msg_display = Label(
ws,
text="",
bg="#cd950c"
)
msg_display.pack(pady=10)
ws.mainloop()
输出:
在这个输出中，用户可以通过选择日期和时间来预约。用户可以选择未来或过去的任何日期。
改进范围
- 添加对过去日期选择的限制。
- 将应用程序与数据库连接，并仅在日期和时间未被占用时提供预约确认。
Creating Date Time Picker Using Python Tkinter
您可能会喜欢以下 Python 教程:
- Python Pygame 教程
- 使用 Python 的机器学习
- 如何使用 Python Tkinter 获取用户输入并存储在变量中
- Python Tkinter 退出程序
- 如何在 Turtle Python 中附加图像
- Python Tkinter TreeView 示例
- Python Turtle 命令(15 个有用的命令)
- 用 Python Tkinter 上传文件
在本教程中，我们学习了如何使用 Python tkinter 创建日期时间选择器。
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
如何用 Django 脆皮造型创造造型
原文：https://pythonguides.com/create-form-with-django-crispy-forms/
在这个 Python Django 教程中，我将一步一步地解释如何用 Django crisp Forms 创建表单。
最近，我一直在使用 bootstrap 开发一个联系人表单，我发现它需要几十行代码，需要花费很多精力，所以我做了一些研究，发现 Django 提供了清晰的表单。
在这里我们将看到:
- 姜戈脆皮是什么
- 如何使用姜戈脆皮蛋糕
- 如何在 Django 中使用 Crispy 表单构建联系人表单
- 如何在 Django 中使用各种控件，如 textbox、textarea 和 email
- 如何用电子邮件创建 Django 表单
- 如何从 Django 管理界面查看提交的数据
有不同的方法，我们可以在 Django 中创建表单，比如使用表单、HTML 等。但是它们缺乏风格化的外观，所以我们将在这里使用 Django crispy forms 来呈现 Django 表单。
在本文的最后，你也可以下载代码:用 Django crisp Forms创建 Django form。
这是我们将在这里建造的。
Create Form with Django Crispy Forms
目录
如何用 Django 脆皮制作造型
现在，让我们一步一步地看，如何用 Django 脆皮形式创建 Django 形式。
姜戈脆皮蛋糕
在 Django 中，Django-crisp-form是一个 Python 包，内置了对引导 CSS 和引导 CDB 框架的支持。
它允许我们用更少的代码行和更少的工作将 Bootstrap 集成到我们的项目中。
如何设置 Django 脆皮表单
django-crisp-forms 应该首先安装在您激活的虚拟环境中。在这个包的帮助下，我们可以不使用任何额外的自定义表单 CSS 来呈现 Django 表单。
pip install django-crispy-forms
安装完成后，将 Djangocrisp _ forms添加到 settings.py 文件中的 INSTALLED_APPS 中。
settings.py
现在，在 INSTALLED_APP 列表下面添加crisp _ TEMPLATE _ PACK，为各种 CSS 和 bootstrap 框架提供内置支持。
并将其值设置为我们正在使用的引导。这里我将其值设置为 bootstrap4 。
Crispy Template Pack
如何用 Django 脆皮制作造型
建立 Django 项目
首先，使用下面给出的命令在 Django 中创建一个名为的项目。
django-admin startproject WebsiteBuilder
通过在终端键入下面的命令，在 Django 项目中创建一个名为 Contact 的 Django 应用程序。
python manage.py startapp Contact
将联系人应用添加到位于 settings.py 文件中的已安装应用列表中。
settings.py
Django 在项目目录中自动包含一个名为 urls.py 的文件。在它里面，映射了最近创建的应用程序联系人，如下所示。
from django.contrib import admin
from django.urls import path,include
urlpatterns = [
path('admin/', admin.site.urls),
path('',include('Contact.urls')),
]
阅读:如何在 Python Django 中创建 web 表单
从 Django 中的模型创建表单
打开位于 app 目录中的 models.py 文件来创建模型，并在其中添加以下代码。
from django.db import models
# Create your models here.
class Contact(models.Model):
name = models.CharField(max_length=50)
email = models.EmailField()
message = models.TextField(max_length=1000)
def __str__(self):
return self.email
在这里，我们创建一个模型类 Contact ，它具有以下字段。
- 名称是 Django CharFields，用于接收用户输入的名称。并且该字符字段有 50 个字符的限制。
- 电子邮件是 Django EmailField，允许用户保存电子邮件地址。
- 消息字段是 Django 文本字段。并且有 1000 个字符的限制。
并使用 def __str__(self) 来更改 Django 模型中对象的显示名称。当我们返回 self.email 时，它会将项目名称显示为电子邮件。
要在管理站点注册联系人模型，打开 admin.py 文件并添加下面给出的代码。
from django.contrib import admin
from .models import Contact
# Register your models here.
admin.site.register(Contact)
创建 Django 表单，联系人应用程序将使用它来收集用户输入。将以下代码添加到您在 app 目录中创建的 forms.py 文件中。
from django import forms
from .models import Contact
class ContactForm(forms.ModelForm):
class Meta:
model = Contact
fields = '__all__'
这里，我们定义了一个名为ContactForm 的表单类，它包含了来自 Contact 模型的所有字段。
阅读:如何使用 Django 和 SQLite 创建联系人表单
创建模板
在 Django 中，应用程序的前端是在模板中定义的，为此，在主项目目录中创建一个名为模板的子目录来存储所有的项目模板。
打开 settings.py 文件，更新 DIRS 指向 Templates 文件夹的位置。
settings.py
为了定义联系人表单的前端，在模板文件夹中创建一个名为contact.html的 HTML 文件，并包含下面给出的代码。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<!-- Bootstrap CSS -->
<link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/css/bootstrap.min.css"
integrity="sha384-ggOyR0iXCbMQv3Xipma34MD+dH/1fQ784/j6cY/iJTQUOhcWr7x9JvoRxT2MZw1T" crossorigin="anonymous">
<title>Contact Us</title>
</head>
<body>
<form method="post">
{% load crispy_forms_tags %}
{% csrf_token %}
<div class="container">
<div class="row justify-content-center">
<div class="col-8">
<h1 class="mt-4" align="center">Contact Us</h1>
<hr class="mt-4 mb-5">
<h4 class="mt-4" align="center">Let's get conversation started. Tell us a bit about yourself, and our team will get in touch as soon as we can.</h4>
<hr class="mt-4 mb-5">
<div class="row">
<div class="col-6">
{{ form.name|as_crispy_field }}
</div>
<div class="col-6">
{{ form.email|as_crispy_field }}
</div>
</div>
<div>
{{ form.message|as_crispy_field }}
</div>
<button type="submit" class="btn btn-success">Submit</button>
</div>
</div>
</div>
</form>
<!-- jQuery first, then Popper.js, then Bootstrap JS -->
<script src="https://code.jquery.com/jquery-3.3.1.slim.min.js"
integrity="sha384-q8i/X+965DzO0rT7abK41JStQIAqVgRVzpbzo5smXKp4YfRvH+8abtTE1Pi6jizo"
crossorigin="anonymous"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/popper.js/1.14.7/umd/popper.min.js"
integrity="sha384-UO2eT0CpHqdSJQ6hJty5KVphtPhzWj9WO1clHTMGa3JDZwrnQq4sF86dIHNDz0W1"
crossorigin="anonymous"></script>
<script src="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/js/bootstrap.min.js"
integrity="sha384-JjSmVgyd0p3pXB1rRibZUAYoIIy6OrQ6VrjIEaFf/nJGzIxFDsf4x0xIM+B07jRM"
crossorigin="anonymous"></script>
</body>
</html>
首先，通过在任何其他样式表之前添加样式表到页面标题的链接来加载您的 CSS。
现在用 POST 方法使用表单标签描述您的联系表单，并加载 crsf_token 标签来保护我们的表单免受网络攻击。
然后，要用引导行和引导列样式化 Django 表单，加载crisp _ form _ tag并单独调用每个表单字段，使用{ { form . name _ of _ field | as _ crisp _ field } }标签。
我们的几个组件的功能依赖于 JavaScript，要启用下面的脚本，请将它们添加到结束的 body 标签之前。
我们希望在成功提交后将联系表单呈现到另一个页面，因此我们再次收到成功消息和联系表单链接。
为此，我们将另一个名为success.html的 HTML 文件添加到模板文件夹。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Success</title>
</head>
<body>
<h2 style="text-align: center; color: red;" "></h2style>We sent your message</h2>
<p> You can send another in the <a href=" {% url 'contact' %}">Contact Page</a></p>
</body>
</html>
首先，我们使用 h2 标签定义标题，为了使文本居中并将其颜色设置为红色，我们在标签内传递了文本对齐和颜色属性。然后，在 p 标签中，使用 a href 标签链接联系人页面。
定义 Django 视图
为了创建使用 crispy 表单创建联系人表单的主要逻辑，我们打开 views.py 文件并添加下面给出的代码。
from django.shortcuts import render
from .forms import ContactForm
# Create your views here.
def contact(request):
if request.method == 'POST':
form = ContactForm(request.POST)
if form.is_valid():
form.save()
return render(request, 'success.html')
form = ContactForm()
context = {'form': form}
return render(request, 'contact.html', context)
首先从 forms.py 中导入 ContactForm ，然后调用 if 语句，检查请求方式是否为 POST 。
如果是，我们通过 ContactForm(请求。POST) 将数据绑定到表单类，这样我们就可以进行验证。现在，调用 is_valid() 来验证用户输入的内容，如果验证成功，使用 save() 保存数据，并将用户呈现给success.html。
如果没有，则使用 render() 函数向用户显示一个空白的联系人表单。
我们必须用 URL 映射视图以便调用它，因此我们必须在 app 目录中创建一个名为 urls.py 的文件。包括下面的代码。
from django.urls import path
from Contact import views
urlpatterns = [
path("contact", views.contact, name="contact"),
]
阅读: Python Django 与 Flask–主要区别
使用 Django Crispy 表单和电子邮件创建表单
此外，此联系表单连接到电子邮件后端，它会自动运行，并在每次代表网站员工提交表单时通过电子邮件通知用户。
要添加 Django 发送电子邮件所需的设置，请打开 settings.py 文件并添加以下代码。
# Email Settings
EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
EMAIL_HOST = 'smtp.gmail.com'
EMAIL_USE_TLS = True
EMAIL_PORT = 587
EMAIL_HOST_USER = #sender email-id
EMAIL_HOST_PASSWORD = #password associated with sender email-id
打开 views.py 文件，并添加以下代码来发送关于提交的电子邮件。
from django.shortcuts import render
from .forms import ContactForm
**from django.core.mail import send_mail
from django.conf import settings**
# Create your views here.
def contact(request):
if request.method == 'POST':
form = ContactForm(request.POST)
if form.is_valid():
form.save()
**subject = "Welcome to PythonGuides Website Builder"
message = "Our team will contact you within 24hrs."
email_from = settings.EMAIL_HOST_USER
email = form.cleaned_data['email']
recipient_list =email
send_mail(subject, message, email_from, [recipient_list])** return render(request, 'success.html')
form = ContactForm()
context = {'form': form}
return render(request, 'contact.html', context)
导入设置变量，该变量包含在 settings.py 文件中找到的所有全局设置，以及 Django send_mail 函数。
然后，提供我们在撰写电子邮件时需要的参数，并将所有参数传递给 Django 中负责发送电子邮件的函数 send_mail() 。
执行 Django 应用程序
为了开始使用模型，我们必须首先为给定的模型创建一个迁移。使用终端执行以下命令。
python manage.py makemigartions
我们必须迁移数据库以反映它。下面是 migrate 命令。
python manage.py migrate
我们在终端中输入下面的命令，为这个特定的 Django 项目启动一个开发服务器。
python manage.py runserver
通过如下所示展开 URL，我们可以访问联系表单。
127.1.1.0/contact
它成功地打开了 Django 联系表单，这是我们使用 crispy 表单创建的，如下所示。
Create Form with Django Crispy Forms
现在，填写联系表单并点击提交按钮，如下所示。
Contact Us form using the Django crispy form
单击提交后，我们将被带到成功页面。如果我们点击联系页面链接，我们将再次被带到一个未填写的联系表格。
Success Page
此外，在点击提交按钮后，一封电子邮件将从网站所有者的电子邮件发送到用户填写的电子邮件中。
Website Owner Email
User Email
从 Django 管理界面查看提交的数据
Django 为用户提供了一个管理界面，用户可以通过这个界面查看从表单保存到数据库的信息。
为此，我们必须使用下面给出的命令创建一个超级用户。
python manage.py createsuperuser
在联系人应用程序下，选择联系人。并且我们将得到记录在数据库中的表单数据。
Admin Site
这就是我们如何使用 crispy 表单呈现 Django 联系人表单。
阅读:如何使用 bootstrap 在 Django 中构建联系人表单
下载用 Django crisp forms 创建表单的完整代码
这是代码。
Create form with Django Crispy Forms
结论
这样，我们成功地用 Django crisp Forms 创建了一个工作表单，它利用了一个数据库和 crisp 表单。我们还学习了如何从网站所有者向填写了表单的用户自动发送电子邮件。
此外，我们还讨论了以下主题。
- 姜戈脆皮是什么
- 如何使用姜戈脆皮蛋糕
- 如何用 Django 脆皮造型创造造型
- 如何在 Django 中使用各种控件，如 textbox、textarea 和 email
- 如何使用 Django Crispy 表单和电子邮件创建表单
- 如何从 Django 管理界面查看提交的数据
您可能也喜欢阅读下面的 Python Django 教程。
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
如何在 Python 中创建列表
在本 Python 教程中，我们将讨论什么是 Python 列表以及在 Python 中创建列表的不同方式。此外，我们还将讨论:
- 用 python 创建一个大小为
- 创建大小为 n 的列表
- 如何在 Python 中从字符串创建列表
- Python 将列表转换成空格分隔字符串
- 用 Python 创建一个列表列表，
- Python 从字典中创建一个列表
- 如何创建一个浮动列表
- 使用范围在 python 中创建列表
- 使用 for 循环创建列表
- Python 创建前 n 个整数的列表
- 创建对象列表
- 将数组转换为列表 python
- 列表 python 的平均值
- Python 列表的排序列表
- 从列表 python 中随机选择一个项目
- Python 将函数应用于列表
- 列表的 Python 置换
- 给定长度的列表项的 Python 排列
- 列表的 Python 组合
- Python 与替换的组合
- 如何用 python 复读
- Python 将一个列表分割成块
- 零列表 python
- Python 创建一个空列表
目录
- 什么是 python 列表
- 用 python 创建一个大小为的列表
- Python 创建大小为 n 的列表
- Python 从一个字符串创建一个列表
- Python 将列表转换成空格分隔的字符串
- Python 创建了一个列表列表
- Python 从字典中创建一个列表
- Python 创建浮动列表
- 使用范围在 python 中创建一个列表
- 使用 for 循环在 python 中创建一个列表
- Python 创建前 n 个整数的列表
- Python 创建了一个对象列表
- 将数组转换为列表 python
- 列表 python 的平均值
- Python 排序列表列表
- 从列表中随机选择一个物品 python
- Python 对列表应用函数
- Python 列表的排列
- 给定长度列表项的 Python 排列
- Python 列表的组合
- Python 组合与替换
- 如何在 python 中重复
- Python 将一个列表分割成块
- 0 python 列表
- Python 创建一个空列表
什么是 python 列表
- 在 python 中，元素组被称为列表。
- Python 列表与数组非常相似，但主要区别在于，数组只能存储一种类型的元素，而列表可以存储不同类型的元素。
- 列表是可变。
- 列表是动态的，这意味着大小是不固定的。列表用方括号[ ]表示，用逗号分隔。
举例:
x = ['Lists',6.3,2.2,12,32]
print(x)
写完上面的代码(python list)，你将打印出 "x" ，然后输出将显示为 "['List '，6.3，2.2，12，32]" 。您可以参考下面的截图来创建不同数据类型的列表。
python list
这是如何在 Python 中创建一个列表。
你可能喜欢用例子用 Python 程序来反转一个字符串。
用 python 创建一个大小为的列表
在这里，我们将看到如何创建一个固定大小的 python 列表。我已经用一些大小初始化了元素数组。
举例:
size = [0]*5
print(size)
写完上面的代码(用 python 列出大小)，你将打印出 "size" ，然后输出将显示为 "[0，0，0，0，0]" 。这里，我用[0]初始化它，我的固定大小值是 5。你可以参考下面的截图来创建一个固定大小的列表。
Create a list in python with size
Python 创建大小为 n 的列表
要创建大小为 n 的列表，请使用大小声明变量。
举例:
n = 8
store = [2]*n
print(store)
写完上面的代码(大小为 n 的列表)，你将打印出【store】，然后输出将显示为【2，2，2，2，2，2，2】。你可以参考下面的截图来创建一个大小为 n 的列表
Python create list of size n
Python 从一个字符串创建一个列表
为了从一个字符串中创建一个列表，我们有 split()方法，它将创建一个用方括号中的逗号分隔的列表。
举例:
value = "Welcome to Python"
print(value.split())
写完上面的代码(从一个字符串创建一个列表)，你将打印出 "value.split()" ，然后输出将显示为一个 "['Welcome '，' to '，' Python']" ，这是一个列表。你可以参考下面的截图，从一个字符串创建一个列表。
Python create a list from a string
Python 将列表转换成空格分隔的字符串
在 Python 中，通过使用 join()方法，我们可以将列表转换为空格分隔的字符串。
举例:
color = ['Black','Red','Blue']
val = ' '.join(color)
print(val)
写完上面的代码(将一个列表转换成一个空格分隔的字符串)后，一旦你打印出 "value" ，那么输出将显示为黑红蓝。你可以参考下面的截图，将列表转换成空格分隔的字符串。
convert a list to space-separated string in python
Python 创建了一个列表列表
为了用 python 创建一个列表，我们需要使用。append 方法创建一个列表列表。
举例:
l1=[101,102,103]
l2=[104,105]
listoflists= []
listoflists.append(l1)
listoflists.append(l2)
print("List of Lists:",listoflists)
写完上面的代码(创建一个列表列表)，你将打印出"列表列表:"，listoflists" 然后输出将显示为一个 " 列表列表:" [[101，102，103]，[104，105]] "。你可以参考下面的截图来创建一个列表列表。
Python creates a list of lists
Python 从字典中创建一个列表
Dictionary 是 Python 中键值对的集合。字典是可变的。用逗号分隔的花括号 "{} "表示。而冒号 ":" 将每个键与其值分开。
举例:
snames = {'Ram': 11, 'Rohan': 12, 'Shyam':13, 'Jai': 14}
mylist = [(k,v) for k,v in snames.items()]
print(f"mylist : {mylist}")
在编写完上面的代码(从字典中创建一个列表)之后，您将打印( f"mylist: {mylist}") 然后输出将显示为 [('Ram '，11)，(' Rohan '，12)，(' Shyam '，13)，(' Jai '，14)] 。你可以参考下面的截图，从字典中创建一个列表。
creates a list from dictionaries in python
Python 创建浮动列表
为了在 python 中创建一个浮点数列表，我们需要一个 For 循环来遍历整个列表。此外，使用 append 创建新列表。
举例:
my_val = ["1.1", "3.5", "7.6"]
list_of_floats = []
for item in my_val:
list_of_floats.append(float(item))
print(list_of_floats)
写完上面的代码(创建一个浮点列表)，你将打印出 (list_of_floats) ，然后输出将显示为一个作为浮点值的【1.1，3.5，7.6】。你可以参考下面的截图来创建一个列表的花车。
Python create list of floats
使用范围在 python 中创建一个列表
我们可以使用 range()在 python 中创建一个列表，并使用“ * ”操作符创建连续值。为了连续地制作一个列表，我们可以给出一个范围值，它有起始值和终止值。
举例:
value = [*range(110,116)]
print(value)
写完上面的代码后(使用一个范围创建一个列表)，你将打印出【值】，然后输出将显示为“【110，111，112，113，114，115】，作为一个具有连续值的列表。你可以参考下面的截图，在 python 中使用范围创建一个列表。
使用 for 循环在 python 中创建一个列表
为了使用 For 循环在 python 中创建列表，我们需要使用 for 循环遍历列表中的条目。
举例:
marks = ['34', '55', '67', '88', '89']
list_of_int = []
for item in marks:
list_of_int.append(int(item))
print(list_of_int)
在编写完上面的代码(使用 for 循环创建一个列表)后，您将打印" list_of_int "然后输出将显示为" [34，55，67，88，89] "作为一个列表。使用 for 循环在 python 中创建一个列表，可以参考下面的截图。
Create a list in python using for loop
Python 创建前 n 个整数的列表
为了在 python 中创建前 n 个整数的列表，我们将首先声明 n，它将把前 n 个整数作为一个列表。通过使用 range 我们可以得到第一个 n 整数。
举例:
n = 5
p = list(range(5))
print(p)
写完上面的代码后(创建一个前 n 个整数的列表)，你将打印“ p ”，然后输出将显示为“ [0，1，2，3，4] ”作为一个列表。你可以参考下面的截图，用 python 创建一个前 n 个整数的列表。
Python 创建了一个对象列表
在 python 中，创建了一个类，其中用户定义了一个对象，该对象可以是具有不同数据类型的列表的成员。为了在 python 中创建对象列表，我们可以使用 append for class instances to list。
举例:
class employee:
def __init__(self, empname, empid):
self.empname = empname
self.empid = empid
list = []
list.appened( employee('Rohan', 15) )
list.appened( employee('Ram', 30) )
list.appened( employee('Sohan', 34) )
for val in list:
print(val.empname, val.empid)
写完上面的代码(创建一个对象列表)，你将打印的对象( val.empname，val.empid )”然后输出将作为列表显示为“ Rohan 15 Ram 30 Sohan 34 ”。你可以参考下面的截图，用 python 创建一个对象的列表。
将数组转换为列表 python
在 python 中，要将数组转换成列表，我们可以使用函数“to list()”将数组转换成列表。
举例:
from array import*
def my_array(num_array):
my_list = num_array.tolist()
print(my_list)
num_array = array('i', [12,14,16,18,20])
my_array(num_array)
在编写了上面的代码(将数组转换为列表 python)之后，您将打印这些代码，然后输出将显示为" [12，14，16，18，20] "作为一个列表。在这里，函数 tolist() 将数组转换为具有相同元素的列表。你可以参考下面的截图，把一个数组转换成 list python。
列表 python 的平均值
在 python 中，为了计算列表的平均值，我们可以使用内置函数 sum()和 len()。平均值是列表中所有元素的总和除以元素总数。
举例:
my_list = [2, 4, 6, 8]
t = sum(my_list)
l = len(my_list)
average = t/l
print(average)
写完上面的代码(一个列表 python 的平均值)，你将打印出 " average " ，然后输出将显示为 " 5.0 " 。这里，函数 sum()将所有的元素相加，len()函数将计算元素的个数。你可以参考下面的列表 python 的平均截图。
Python 排序列表列表
在 python 中，为了对列表进行排序，我们可以使用每个内部列表的索引，并通过指定的索引作为关键字对内部列表进行排序。
举例:
my_list = [[21, 'Y'], [18, 'X']]
list_to_sort = sorted(my_list, key=lambda a: a[1])
print(list_to_sort)
写完上面的代码(python 排序列表)后，你将打印出 " list_to_lists " ，然后输出将显示为 " [[18，' X']，[21，' Y']] " 。这里，sorted 用于对元素进行排序， lambda a: a[1] 用于按每个元素对 iterable 进行排序。你可以参考下面的 python 排序列表截图。
从列表中随机选择一个物品 python
在 python 中，为了从列表中获得随机选择的项目，我们将导入 random 模块，然后我们必须使用 choice() 函数从列表中随机选择项目。
举例:
import random
name = ["tom", "alice", "sid", "zoe"]
print(random.choice(name))
写完上面的代码后(从 list python 中随机选择一个项目)，你将打印出 " random.choice() " 然后输出将显示为 " alice " 作为从列表中随机选择的项目。这里，函数 choice()将随机返回列表中的项目。你可以参考下面的截图从 python 列表中随机选择一个项目。
Python 对列表应用函数
- 将函数应用于一个列表，我们将使用一个
map()。 - 用一个列表调用 map(func，*iterables) 作为 iterables，对列表中的每个元素应用一个函数，它返回一个 map 对象。
- 使用
list()将地图对象转换为列表。
举例:
my_list = ["x", "y", "z"]
map_obj = map(str.upper, my_list)
n_list = list(map_obj)
print(n_list)
写完上面的代码(python apply function to a list)，你将打印出 " n_list " ，然后输出将显示为 " ['X '，' Y '，' Z'] " 。这里，它需要对列表中的每个元素应用特定的函数，所以我们使用大写字符。可以参考下面的截图 python 对列表应用函数。
Python apply function to a list
Python 列表的排列
在 python 中，我们可以直接使用名为 itertools 包的方法来找到一个列表的排列。首先，我们需要导入 itertools 包来实现 python 中的置换。列表的排列是列表中元素的所有可能的顺序。
举例:
from itertools import permutations
my_permut = permutations([12, 13, 14])
for a in list(my_permut):
print(a)
写完上面的代码(python 一个列表的排列)，一旦你将打印 " a " 那么输出将出现为 " (12，13，14) (12，14，13) (13，12，14) (13，14，12)，(14，12)，14，13) (14，12)(14，13)(14，13，12) " 。这里，该方法将一个列表作为输入，并返回一个包含所有排列的元组的对象列表。你可以参考下面的截图 python 排列的一个列表。
Python permutations of a list
给定长度列表项的 Python 排列
为了得到给定长度的列表项的排列，我们需要指定长度以得到列表的所有排列。
举例:
from itertools import permutations
my_permut = permutations([12, 13, 14], 2)
for a in list(my_permut):
print(a)
写完上面的代码(python 排列给定长度的列表项)，一旦你打印出 " a " ，那么输出将显示为 " (12，13) (12，14) (13，12) (13，14) (14，12) (14，12)(14，12)(14，13) " 。这里，我们将长度指定为【2】。如果你想得到长度为 L 的排列，我们可以这样做。你可以参考下面的截图 python 排列的一个列表。
Python permutations of list items of a given length
Python 列表的组合
在 python 中，要找到列表的组合，我们可以使用名为 itertools 包的方法。首先，我们需要导入ITER tools包来实现 python 中的组合。列表组合是所有可能的项目分组。
举例:
from itertools import combinations
my_comb = combinations([12, 13, 14], 2)
for a in list(my_comb):
print(a)
写完上面的代码(python 组合的一个列表)，一旦你打印出 " a " ，那么输出将显示为 " (12，13) (12，14) (13，14) " 。这里，这个方法将一个列表和“r”作为输入，它将返回具有所有可能组合的元组的对象列表。你可以参考下面截图的 python 组合列表。
Python combinations of a list
Python 组合与替换
为了得到相同元素与相同元素的组合，我们将使用替换组合。首先我们需要导入 combinations _ with _ replacement，然后元素将被索引值引用。
举例:
from itertools import combinations_with_replacement
my_comb = combination_with_replacement([12, 13, 14], 2)
for a in list(my_comb):
print(a)
写完上面的代码(带替换的 python 组合)，一旦打印出 " a " ，那么输出将显示为(12，12) (12，13) (12，14) (13，13) (13，14) (14，14)(T3)。这里，我们有长度组合【2】与替换。同样，我们有重复迭代器的所有可能的子集排列。可以参考下面截图 python 组合搭配替换。
Python combinations with replacement
如何在 python 中重复
itertools.repeat() 属于无限迭代器，我们将导入 itertools 。有时我们需要在程序中重复，因此，我们可以使用 repeat(val，num) ，其中“val”是要打印的值，“num”是数据将被重复的次数。
举例:
import itertools
print ("Print repeatedly the numbers: ")
print(list(itertools.repeat(123, 5)))
写完上面的代码(python 中如何重复)，一旦你将打印“(list(itertools.repeat(123，5))”那么输出会出现“[123，123，123，123，123]”。在这里，我们可以看到值“123”被重复打印了“5”次。关于如何用 python 重复，可以参考下面的截图。
How to repeat in python
Python 将一个列表分割成块
为了将一个列表分割成更小的块，我们可以使用列表理解在需要的时候将一个列表分割成多个列表。
举例:
f_list = [10,12,14,16,18,20,22,24,26,28,30,32]
n = 4
result = [f_list[i:i + n] for i in range(0, len(f_list), n)]
print(result)
写完上面的代码(python 将一个列表分割成块)，一旦打印出 " result " ，那么输出将显示为 " [[10，12，14，16]，[18，20，22，24]，[26，28，30，32]] " 。在这里，我们可以看到列表被均匀地分成了几个【4】的块，它给出了多个列表。你可以参考下面的截图，python 把一个列表分割成块。
Python split a list into chunks
0 python 列表
为了获得零列表，我们必须创建一个名为 "n" 的变量，然后 " [0] * n " 将在 python 中创建一个零列表。
举例:
n = 5
list_of_zeros = [0] * n
print(list_of_zeros)
写完上面的代码(零的列表 python)，一旦你将打印“零的列表”那么输出将显示为“[0，0，0，0，0]”。在这里，我们可以看到列表已经被创建，我的 n 值是 5 ，所以列表包含 5 个零。你可以参考下面的截图，以获得 python 的列表。
List of zeros python
Python 创建一个空列表
可以通过在方括号中不给出元素来创建空列表。我们也可以使用内置函数 list() 创建一个空列表，不需要任何参数。
举例:
list = []
print("The value in list:", list)
在编写了上面的代码(python 创建一个空列表)之后，一旦打印出 " list " ，那么输出将显示为"[]"。在这里，我们可以看到空列表已经被创建。你可以参考下面 python 创建空列表的截图。
Python create an empty list
您可能会喜欢以下 Python 教程:
- 使用 Visual Studio 代码用 python 创建一个 hello world 程序
- Python 字符串函数
- 如何在 python 中把整数转换成字符串
- 在 python 中连接字符串
- 如何在 python 中使用正则表达式拆分字符串
- Python 命名约定
- 创建一个字符串，并将其赋给 python 中的一个变量
- 如何在 python 中创建变量
通过这个教程，我们学习了Python中什么是 list？如何用 Python 创建列表？如何创建有大小的列表？创建一个大小为 n 的列表，如何从一个字符串创建一个列表，Python 将一个列表转换成空格分隔的字符串，如何创建一个列表列表？将数组转换为列表 python ，列表的平均值 python，列表的 python 排序，从列表中随机选择一项 python，对列表应用函数 python，列表的 Python 排列，给定长度的列表项的 Python 排列，列表的 Python 组合，带替换的 Python 组合，如何在 Python 中重复以及 Python 将列表拆分成块。
如何用 python 从字典中创建一个列表？Python，创建浮点数列表，使用 python 中的范围创建 python 中的列表，使用 for 循环创建 python 中的列表，创建前 n 个整数列表，创建对象列表。
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
如何在 Django 中创建模型
在本 Django 教程中，我们将讨论如何在 Django 中创建模型，如何在 Django 中创建模型字段，我们还将涉及以下主题。
- Django 的模特
- 在 Django 中创建模型
- 在 Django 中创建模型表单
- 在 Django 中使用模型
- 在视图中使用模型 Django
- 在 Django 中创建模型类
- 在 Django 中创建模型字段
- 在 Django 模型中创建对象
因此，在为我们的应用程序创建模型之前，让我们先了解一下 Django 中的模型是什么。
目录
- Django 的模型
- 如何在 Django 中创建模型
- 在 Django 中创建模型字段
- 使用 Django 中的模型
- 在 Django 模型中创建对象
- 在视图 Django 中使用模型
- 在 Django 中创建模型表单
Django 的模型
Django 是一个基于 python 的 web 开发框架，基于 MVT 架构。而 MVT 中的“ M 代表车型。
Django 中的模型是一个 python 对象，它用于访问和管理应用程序的数据。Django 中的每个模型都映射到一个数据库表。
一般来说，我们编写多个 SQL 查询来创建一个 SQL 数据库，然后创建表和它们的字段。但是 Django 通过使用 Model 组织表格简化了这项任务。
所以在选择好数据库之后，我们只需要创建模型，Django 就会自动与数据库进行通信来实现任务。
下图展示了 Django 模型如何映射到数据库表。
Mapping Django model to a database table
因此，在 Django 中，我们使用该模型来构造表、定义表字段、它们的默认值等等。
如何在 Django 中创建模型
了解了模型之后，就该讨论如何在 Django 中创建模型了。但是在前进之前，应该准备好一个项目和一个应用程序。关于这一点，你也可以参考下面这篇文章——如何设置 Django 项目。
在 Django 创建模型类
为了在 Django 中创建一个模型，我们必须使用 model.py 文件，这个文件可以在你的应用程序目录中找到。
现在，Django 中的每个模型都是一个 python 类，它将是 django.db.models.Model 类的子类。一个类的每个属性代表一个字段。
因此，这里有一个通用语法，我们可以在 models.py 文件中使用它来创建一个用户模型。
from django.db import models
class ModelName(models.Model):
field_name = models.Field(**options)
在语法中，首先，我们导入了模型类。在这之后，要创建一个用户模型，我们必须定义一个“模型”的子类。型号”。
在语法中，我们必须定义模型的名称来代替 ModelName 。接下来，为了创建字段，我们必须使用 models 类，如语法所示。
让我们通过一个例子来理解这一点，为此，考虑下面给出的代码。
from django.db import models
class Employees(models.Model):
first_name = models.CharField(max_length=30)
last_name = models.CharField(max_length=30)
Dept_name = models.CharField(max_length=20)
joining_date = models.DateField()
salary = models.IntegerField()
在上面的例子中，我们已经创建了一个名为“ Employees 的用户模型，并将用于存储雇员数据。在模型中，我们定义了 5 个字段作为类属性，每个属性将映射到一个数据库列。
现在，这个雇员模型将自动创建一个与此等价的表。
CREATE TABLE "myApp_employees" (
"id" integer NOT NULL PRIMARY KEY AUTOINCREMENT,
"first_name" varchar(30) NOT NULL,
"last_name" varchar(30) NOT NULL,
"Dept_name" varchar(20) NOT NULL,
"joining_date" date NOT NULL,
"salary" integer NOT NULL
);
COMMIT;
在这个例子中，我们在“myApp”应用程序中创建了一个模型。因此，Django 将通过使用模型元数据自动生成一个名为“ myApp_employees 的表。
此外，id 字段也将添加到表中。此 id 是一个非空、自动递增的主键字段。
至此，我们已经了解了如何在 Django 中创建模型类，以及创建模型时会发生什么。接下来，让我们了解如何在 Django 中使用模型。
阅读:如何安装 Django
在 Django 创建模型字段
理解了如何创建模型之后，接下来要理解的是模型字段。
模型字段用于表示表列，Django 中有许多不同类型的字段。
这些不同类型的字段用于决定一个列应该保存哪种类型的数据，例如整数、字符串、日期等。设置字段就像决定表中某一列的数据类型。
模型中的每个字段都是一个字段类的实例，Django 使用这些字段类型来决定列类型、验证需求以及其他许多事情。
现在，Django 在模型中提供了许多类型的字段。以下是一些最重要的字段类型的列表。
- 自动字段- 这是一个整数字段字段，会自动增加其值。
BigAutoField-它是一个 64 位整数字段，与 AutoField 非常相似。但唯一不同的是，在这里，我们将得到从 1 到9223372036854775807的确定值。integer field–用于保存范围从-2147483648 到 2147483647 的整数值。bigtintergerfield-它也是一个 64 位的整数域。但可以保存-9223372036854775808 到 9223372036854775807 之间的整数值。- 二进制字段- 该字段用于存储二进制数据。
boolean field–该字段可以存储布尔数据(真/假)。如果没有给它分配默认值，那么它的值将是 NONE。CharField-用于将小尺寸字符串值存储到大尺寸字符串中。DateField-该字段用于存储日期数据类型的数据。DateTimeField-该字段用于一起存储日期和时间细节。DecimalField-该字段用于存储固定精度的十进制数。email field–它是一个 CharField，但它也检查该值是否是有效的电子邮件地址。float field–该字段用于存储浮点数。- 持续时间字段–该字段可以存储时间段。
- 文件字段- 用于文件上传字段。
- 该字段继承了文件字段的所有属性和方法，它还验证上传的对象是否是有效的图像。
GenericIPAddressField–它可以以字符串格式存储 IPv4 或 IPv6 地址。NullBooleanField-这个字段就像 BooleanField 一样，但是它也允许 NULL 作为选项之一。PositiveIntegerField-与 IntegerField 一样，该字段可以是正数，也可以是零(0)。- 斯拉格菲尔德-“斯拉格这个术语来自报业。Slugs 是仅包含字母、数字、下划线或连字符的短标签。它通常用于 URL。
TextField-该字段用于存储大型文本数据。
现在，在 Django 有更多的可用字段。每个字段用于存储特定类型的数据。
使用 Django 中的模型
成功创建模型类后，让我们来了解如何在 Django 中使用模型。
首先，我们需要告诉 Django 服务器我们想要使用一个模型。为此，首先，我们需要使用我们项目的 settings.py 文件。所以，打开 settings.py 文件，在 INSTALLED_APPS 部分给出你的应用程序的名字。
这是一个我们应该如何在设置文件中添加应用程序的例子。
Defining the app in the settings.py file
在示例中，我们在项目的 settings.py 文件中定义了一个名为 myApp 的 app。
接下来，我们需要运行迁移，这样就可以创建表了。Django 使用迁移来传播对模型的更改(添加一个字段，删除一个模型，等等)。)添加到数据库模式中。
首先，运行 makemigrations 命令，命令如下。
python manage.py makemigrations
该命令有助于根据我们的模型中检测到的变更创建迁移。在这之后，我们需要运行一个 migrate 命令，该命令如下所示。
python manage.py migrate
这个 migrate 命令负责将模型中的更改应用到数据库中。这是与迁移相关的屏幕截图。
Output of migrations
这样，我们的模型就可以在我们的项目中使用了。
在模型中创建对象姜戈
到目前为止，我们已经成功地在 Django 中创建了一个模型，并在 settings.py 文件中添加了应用程序。因此，现在我们可以将该模型用于我们的项目。
现在，Django 使用模型类将数据库表和对象表示为表中的记录。因此，在本节中，我们将学习如何创建用户模型的对象，并使用它们来保存表中的数据。
在这个演示中，我们将使用 python shell，为了打开这个 shell，我们在项目目录中运行了以下命令。
python manage.py shell
现在，一个交互式控制台将被激活，我们将执行控制台中的所有步骤。
在这之后，我们的第一步是从我们的应用程序中导入所需的模型，我们可以使用下面的语法来完成这项任务。
from app_name.models import model_name
下面是一个例子，说明如何从我们的 myApp 应用程序中导入" Employees "模型。
from myApp.models import Employees
现在要创建一个对象，我们必须将字段的值作为参数传递给模型类。下面给出了雇员模型的一个简单例子。
emp = Employees(first_name='Steve', last_name='Rogers', Dept_name='Technical', joining_date='2020-08-15', salary=25000)
在这个例子中，我们创建了一个名为" emp 的对象，它用于存储 Employees 表中的 5 个字段。接下来，为了在表中存储这个记录，我们必须使用 save() 方法。在 Django 中， save() 方法用于实现 SQL 插入。下面是我们应该如何使用 save()方法。
emp.save()
下面是整个方法的截图。
Example
在视图中使用模型姜戈
在这一节中，我们将学习如何在 Django 应用程序的视图中访问和使用模型。
现在，正如上一节所讨论的，第一步是将所需的模型导入到视图中。为此，只需使用 import 语句。通过导入模型，我们可以很容易地在视图中访问模型。
from app.models import ModelName
现在，视图建模的可用性完全取决于需求。如果我们想在表中插入记录，我们必须创建一个对象，并使用 save()方法插入它。
另一个需求可能是访问模型数据，然后使用它进行一些操作。对于这个实现，请考虑下面的代码。
ModelName.objects.all()
这段代码将获取模型中的所有记录，并可以轻松地遍历这些记录。我们举个例子。
from django.http import HttpResponse
from myApp.models import Employees
def index(request):
emp_list = Employees.objects.all().count()
return HttpResponse(emp_list)
在本例中，我们简单地创建了一个索引视图，它将返回 Employees 模型中可用记录的总数。
阅读如何从 Django 中的 get 请求获取数据
在 Django 中创建模型表单
如果我们将 Django 用于一些数据驱动的应用程序，我们必须创建一些表单来接受一些数据。
现在，Django 为使用模型创建表单提供了有效的价值。此外，我们不需要使用 HTML 来实现。
因此，在这一节中，我们将讨论如何在 Django 中使用模型来创建表单。
在 Django 中，我们使用 ModelForm 类直接将模型转换成 Django 表单。让我们通过执行一个小例子来理解实现。为此，首先，我们将创建一个简单的模型。
from django.db import models
class Students(models.Model):
first_name = models.CharField(max_length=30)
last_name = models.CharField(max_length=30)
age = models.IntegerField()
在上面的例子中，我们创建了一个包含 3 个字段的简单学生模型。这三个字段分别是名、姓和年龄。现在，我们将使用这个学生的模型来生成一个表单。
接下来，在应用程序目录下创建一个 forms.py 文件，并向其中添加以下代码。
from django import forms
from myApp.models import Students
class StuForm(forms.ModelForm):
class Meta:
model = Students
fields = "__all__"
通过使用上面的代码，我们创建了一个名为“stufform”的 ModelForm 类的子类。这个子类将使用所有的学生模型字段，并为其创建一个表单。
接下来，我们需要创建一个视图，从 forms.py 文件中加载这个stufform类。为此，我们将在应用程序的 views.py 文件中添加以下代码。
from django.shortcuts import render
from myApp.forms import StuForm
def index(request):
stu = StuForm()
return render(request,"index.html",{'form':stu})
在上面的代码中，我们创建了一个名为 index 的基于函数的视图。在索引视图中，我们创建了一个 StuForm 类的对象，然后，我们将它发送到index.html页面。
接下来，我们将向 index.html 文件添加以下代码。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Django Form</title>
</head>
<body>
<form method="post">
{% csrf_token %}
{{form.as_p}}
<button type="submit">Save</button>
</form>
</body>
</html>
在这个 HTML 页面中，我们定义了一个表单标记，首先在表单标记中，我们添加了一个 CSRF 令牌。之后，我们使用 form 对象来呈现表单。
现在，如果我们运行开发服务器并打开索引视图的 URL。我们将得到下面的结果。
Django Form
您可能也喜欢阅读我们的最新文章。
- Python Django 过滤器
- Matplotlib 绘制一条线
- Python 绘制多条线
- 如何从 Python Django 中删除模式
- 如何获取 Django 的当前时间
- Django 联系表，带有基于类的视图
- 用电子邮件建立 Django 联系表单
- Django 从 POST 请求中获取所有数据
因此，在本教程中，我们已经讨论了如何在 Django 中创建模型，如何在 Django** 中创建模型字段，我们还讨论了以下主题。**
- Django 的模特
- 在 Django 中创建模型
- 在 Django 中创建模型表单
- 在 Django 中使用模型
- 在视图中使用模型 Django
- 在 Django 中创建模型类
- 在 Django 中创建模型字段
- 在 Django 模型中创建对象
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
创建 Python 变量–完整教程
在本 Python 教程中，我们将讨论创建 Python 变量并涵盖以下示例:
- 用 python 创建一个变量
- 用 python 创建一个全局变量
- Python 声明变量
- Python 变量类型
- Python 变量范围
- 用 python 创建一个全局变量
- Python 私有变量
- Python 保护的变量
- Python 中的静态变量
- 在 python 中创建一个字符串变量
- 用 python 创建一个虚拟变量
- 在 python 中创建一个空变量
- 在 python 循环中创建变量
- 在 python 中创建环境变量
- Python 动态创建一个变量名
- Python 创建了一个绑定到集合变量
- python 从字符串创建变量名
- Python 创建一个变量并赋值
- Python 在循环中创建了一个变量
- Python 创建了一个没有值变量
- Python 为列表中的每个项目创建变量
- Python 创建变量(如果不存在)
- Python 创建了一个随机变量
- Python 创建了一个布尔变量
- Python 使字符串变量原始
目录
- Python 变量
- Python 声明变量
- 给变量赋值和重新赋值
- Python 变量类型
- Python 变量作用域
- 用 python 创建一个全局变量
- Python 私有变量
- Python 保护的变量
- Python 中的静态变量
- 在 Python 中创建一个字符串变量
- 在 python 中创建一个虚拟变量
- 在 python 中创建一个空变量
- 在 python 循环中创建变量
- 在 python 中创建环境变量
- Python 动态创建变量名
- Python 创建一个绑定到集合的变量
- Python 从字符串中创建变量名
- Python 创建一个变量并赋值
- Python 在循环中创建变量
- Python 创建了一个没有值的变量
- Python 为列表中的每一项创建变量
- Python 创建变量如果不存在
- Python 创建一个随机变量
- Python 创建一个布尔变量
- Python 制作一个字符串变量 raw
Python 变量
变量只不过是一个存储信息或值的容器。换句话说， python 变量就像一个存储值或一些信息的内存位置。现在，这个值已经存储了，你以后可能会也可能不会更改。
Python 声明变量
- 要声明一个 Python 变量，我们只需要给它赋值。你不需要给出任何额外的命令，不像其他编程语言，比如 C，Java，你需要给出额外的命令来声明和赋值。
- 如果你想指定一个变量的数据类型，这可以通过转换来完成。
- 要创建一个变量，你只需要给它赋值，然后开始使用它。
举例:
我们举个例子来检查一下如何在 python 中创建变量。
x = 100
y = "John"
print(x)
print(y)
- 在上面的例子中，我们有两个变量 X 和 Y，我们给它们赋值。
- 我们给 100，给 100，所以这实际上是你如何在 python 中创建一个变量。
下面是以下代码的截图
Create a variable in python
这是另一个例子。
在 Python 中，声明变量时不需要提及类型。这就是 python 被称为动态类型化的的原因。
当我们给这个变量赋值的时候，python 会根据这个赋值决定变量的类型，并相应地分配内存。
示例:
A = 19
B = "Python"
这里，A 和 B 是两个变量，分别包含值 19 和 Python。
Python 可以理解为 A 是整数变量把值看成“19”，B 是字符串变量把值看成“python”。
阅读: Python 检查变量是否为整数
给变量赋值和重新赋值
当你想给一个变量赋值时，你需要使用 "= "操作符。“=”运算符的左边是变量名，右边是分配给它的值。
示例:
a = 1
b = 11
c = 11.1
d = "Python"
print(a)
print(b)
print(c)
print(d)
让我们运行上面的代码，看看输出。输出应该是
1
11
11.1
Python
Assign value to a variable
我们得到了预期的产量。见上文。
如何重新分配变量
你可以在 python 中重新分配一个变量，意思是假设你已经分配了一个= 3 的变量，你也可以给同一个变量分配一个不同的值，比如 a =“Hello”。
示例:
a=3
print(a)
a="Hello"
print(a)
reassign value to a variable
Python 变量多重赋值
在 Python 中，我们可以在一行中给多个变量赋值。为此，我们有两种方法。
方法-1:
用多个“=”运算符将所有变量放在一行中，最后我们可以保留值。
示例:
a = b = c = d = 23
print(a)
print(b)
print(c)
print(d)
我们可以在这里查看输出
执行代码后，我们得到了上面的预期输出。
方法二:
把所有的变量用逗号分隔，然后加上“=”运算符，然后在“=”运算符的右边用逗号分隔所有的值。
示例:
a,b,c,d = 3
print(a)
print(b)
print(c)
print(d)
哎呀，我得到了一个错误，因为你不能以这种方式分配它。记住这个。您将得到一个错误“ TypeError:无法解包不可迭代的 int 对象”。见下文
Traceback (most recent call last):
File "C:/Users/Bijay/AppData/Roaming/JetBrains/PyCharmCE2020.1/scratches/Variable.py", line 1, in <module>
a,b,c,d = 3
TypeError: cannot unpack non-iterable int object
所以正确做法如下。您需要为每个值指定一个单独的值。
a,b,c,d = 3,4,5,6
print(a)
print(b)
print(c)
print(d)
您还可以为每个值分配不同类型的值。
示例:
a,b,c,d = 3,4.2,5,"PythonGuides"
print(a)
print(b)
print(c)
print(d)
multiple variables in python
Python 变量类型
正如我们已经讨论过的，变量将由系统根据它们的类型决定分配内存的位置。所以让我们讨论几个基本类型的变量。
1 号
这种类型的变量包含数值。
python 中有四种类型的数值可用
int
示例:
a = 11
print(a)
龙
a = 4568934L
print(a)
Note: Python 3.8 version doesn't support a trailing L. It will show you invalid syntax.
浮动
a = 11.5
print(a)
复杂
a = 55.j
print(a)
双弦
这类变量包含字符串值。该字符串可以与单引号或双引号一起使用。
示例:
s = "PythonGuides"
print(s)
s = 'PythonGuides'
print(s)
Python variable types
3-列表
一个列表包含由逗号分隔的项目，并保持在方括号([])内。
示例:
a = [11,12.3,'PythonGuides']
print(a)
Python variable type
四元组
一个元组与列表相同，但是它被放在括号 ( () ) 中。项目由逗号分隔。
示例:
a = (11,12.3,'PythonGuides')
print(a)
Python variable types
4-字典
在 Python 中，可以用****({ })编写字典。它们有键和值对。
**示例:
mydict = {
"good": "Exposure",
"Average": "Knowledge",
"Score": 200
}
print(mydict)
Dictionary in python
这些是 Python 变量类型。
阅读: Python 串联词典
Python 变量作用域
让我们讨论一下 python 变量作用域。
1-局部范围
在函数中创建的变量在该函数中有作用域。您可以在函数中使用中变量。让我们看一个例子
示例:
def myLocal():
a = 50
print(a)
myLocal()
Local scope
2-全局范围
在函数外部或者程序主体中创建的变量被称为全局作用域。
示例:
a = 50
def myLocal():
print(a)
myLocal()
print(a)
Global scope
3-封闭范围
在下面的代码中，“b”在 myLocal()函数中具有局部范围，而“a”在 myLocal()函数中具有非局部范围。这就是所谓的封闭范围。
def myTest():
a = 50
def myLocal():
b = 3
print(a)
print(b)
myLocal()
print(a)
myTest()
Enclosing Scope
这些是 Python 变量作用域。
阅读: Python 检查变量是否为数字
用 python 创建一个全局变量
- 在这一节中，我们将学习如何用 python 创建一个全局变量。
- 全局变量是可以被任何地方访问的变量。
- 在全局变量的函数或作用域之外声明的变量称为全局变量。
- 全局变量也可以用在函数或类的外部或内部。
- 为了在 Python 中创建一个全局变量，你需要在函数之外或者在全局范围内声明这个变量。
举例:
让我们举一个例子来检查如何在 python 中创建一个全局变量。
n = 20
def funct1():
print(n)
def funct2():
print(n)
funct1()
#main
funct2()
- 在上面给出的例子中，首先我将创建一个变量 n。
- 现在我将声明一个名为 funct1()的函数，并打印值 n。
- 之后，我将定义另一个名为 funct2()的函数打印值，并调用该函数。
- 大体上，我将调用另一个函数 funct2()。
下面是以下代码的截图
Create a global variable in python
在 Python 中还有另一种创建全局变量的方法。
使用全局关键字可以使变量成为全局变量，即使该变量存在于函数内部。让我们看一个例子。
示例:
def myLocal():
global a
a = 50
myLocal()
print(a)
实施例 2:
如果你想改变函数中全局变量的值
a = 150
def myLocal():
global a
a = 50
myLocal()
print(a)
Global Keyword in Python
这就是我们如何通过使用 global 关键字创建一个 Python 全局变量。
Python 私有变量
通过声明你的变量为私有，你的意思是，没有人能够从类外访问它。
在 Python 中，在开头添加两个下划线(__)会使变量成为私有变量。这种技术被称为名称 mangling 。
让我们看一个例子，看看 python 私有变量到底是如何表现的。
示例:
class Test:
__age = 30
def __Test2(self):
print("Present in class Test")
def Test3(self):
print ("Age is ",Test.__age)
t = Test()
t.Test3()
t.__Test2()
t.__age
在这里查看输出
Age is 30
Traceback (most recent call last):
File "C:/Users/Bijay/AppData/Roaming/JetBrains/PyCharmCE2020.1/scratches/Variable.py", line 9, in <module>
t.__Test2()
AttributeError: 'Test' object has no attribute '__Test2'
在Test3()方法中，__age变量可以像上面那样访问(age is printed)。这就是如何在 Python 中创建私有变量。
Python 保护的变量
通过声明你的变量是受保护的，你的意思是，它和私有变量是一样的，只是多了一个优点，它们可以在被称为派生/子类的子类中被访问
在 Python 中，在开头添加单个下划线(_) 会使变量受到保护。
示例:
class PythonGuides:
# protected variable
_name = "Raj"
def Test(self):
# accessing protected variable
print("Name: ", self._name)
# creating objects of the class
p = PythonGuides()
# functions of the class
p.Test()
查看输出
Name: Raj
Python protected variable
在继承的情况下，在父类中创建的受保护变量可以在派生类中访问。这就是如何在 Python 中创建一个受保护的变量。
Python 中的静态变量
所有在类内部和方法外部声明的变量都称为静态变量。静态变量也称为类变量。
python 中没有特定的关键字来声明静态变量。
示例:
class Test:
var = 2 # static variable
print (Test.var) # prints 2 (static variable)
# Access with an object
obj = Test()
print (obj.var) # still 2
# difference within an object
obj.var = 3 #(Normal variable)
print (obj.var) # 3 (Normal variable)
print (Test.var) # 2 (static variable)
# Change with Class
Test.var = 5 #(static variable)
print (obj.var) # 3 (Normal variable)
print (Test.var )
请参见下面的输出
python static variable
这就是如何在 Python 中创建一个静态变量。
在 Python 中创建一个字符串变量
- 在这一节中，我们将学习如何在 python 中创建一个字符串变量。
- 在 Python 中，字符串是 Unicode 字符的可迭代序列。Unicode 宣布包括所有语言中的所有字符，并引入编码。
- 它是单引号和双引号中的字符序列。
- 要在 Python 中声明一个字符串变量，我们必须在单引号或双引号中添加一个可迭代的字符序列。
举例:
让我们举一个例子来检查如何在 python 中创建一个字符串变量
string1= "It's my pen"
string2= 'hello john'
print(string1)
print(string2)
- 在上面的例子中，我已经包含了两个字符串。第一个字符串用双引号括起来。您可以在第一个字符串中添加单引号字符。
- 第二个字符串用单引号括起来，不能在第一个字符串中添加任何单引号字符。
下面是以下代码的截图
Create a string variable in python
这就是如何创建一个 Python 字符串变量。
在 python 中创建一个虚拟变量
- 在这一节中，我们将学习如何在 python 中创建一个虚拟变量。
- 虚拟变量在您执行任何机器学习任务时都很有用，因为所有的机器学习库都从现有数据中获取数字数据。
- 在此基础上建立机器学习模型。但是在现实世界的数据集中，有可能既有数值数据又有分类数据。
- 虚拟变量是一个二进制值，它给出了一个信号，表明一个单独的分类变量是否具有特定的值。
- 在这个方法中，我们将使用函数 get_dummies()声明国家名称的三个变量。
语法:
pandas.get_dummies
(
data,
prefix=None,
prefix_sep=' ',
dummy_na=False,
dtype=None
)
- 它由几个参数组成
- 数据:获取虚拟指标的数据。
- Prefix: 追加 DataFrame 列名的字符串。当像 df 一样在数据帧上调用 get_dummies 时，传递一个长度等于列数的列表。
- Dummy_na: 添加一列以获得信号 NaNs，如果假 NaNs 被忽略。
- 返回: DataFrame(虚拟数据)。
举例:
让我们举一个例子来检查如何在 Python 中创建一个虚拟变量。
import pandas as pd
import numpy as np
dataf = pd.DataFrame({'Countries': ['Japan', 'Germany', 'U.S.A', 'AFRICA'],
})
print(dataf)
y = pd.get_dummies(dataf)
print(y)
- 在上面的代码中，我们将首先导入所有需要的模块，使用 dictionary 方法声明一个数据集。
- 使用数据变量显示数据集。
- 使用 get_dummies 函数创建变量
下面是以下代码的截图
Create a dummy variable in python
阅读: Python 比较字符串
在 python 中创建一个空变量
- 在这一节中，我们将学习如何在 python 中创建一个空变量。
- Python 是一种编程语言，所以不需要创建这种类型的变量，当第一次给它赋值时，它会自动声明。
- 要在 python 中创建空变量，只需赋值 none。
举例:
让我们举一个例子来检查如何在 python 中创建一个空变量
variable = None
print(variable)
下面是以下代码的截图
Create an empty variable in python
在 python 循环中创建变量
- 在这一节中，我们将学习如何在 python 循环中创建一个变量。
- 在 for 循环中使用字符串格式创建变量名。
- 使用 for 循环方法和 range(start，stop)在从开始到停止的范围内顺序迭代。
- 在 for 循环中，使用字符串格式语法 d[] = value 将许多不同的键映射到同一个值。
举例:
让我们举一个例子来检查如何在 python 循环中创建变量
d = {}
for x in range(1, 6):
b= d["string{0}".format(x)] = "John"
print(b)
下面是以下代码的截图
Create variable in python loop
阅读: Python For 循环示例
在 python 中创建环境变量
- 在这一节中，我们将学习如何在 python 中创建环境变量。
- 环境变量通过操作系统包实现，通常是操作系统。环境。
- 从应用程序内部检索变量的最简单方法是使用标准字典。
- 它是当前用户环境的一组键值对。
- 它们用于以一致的方式配置和管理 Python 库。
示例:
让我们举一个例子来检查如何在 python 中创建环境变量
import os
user = os.environ['USER']
print(user)
下面是以下代码的截图
Create environment variable in python
Python 动态创建变量名
- 在本节中，我们将学习如何动态创建变量名。
- 要动态声明变量名，我们可以使用 for 循环方法和 globals()方法。
- 它基本上是一个变量，其名称是另一个变量的估计值。
- Python 是一种动态编程语言，可以在 Python 中创建动态变量。
- 全局方法以字典的形式提供输出。
- 字典既有键又有值对，所以使用字典创建动态变量名很容易。
举例:
variable = "b"
value = 6
dict2 = {variable: value}
print(dict2["b"])
下面是以下代码的截图
Python creates a variable name dynamically
阅读: Python 命名约定
Python 创建一个绑定到集合的变量
- 在本节中，我们将学习如何创建绑定到集合的变量。
- Abound variable 是以前是自由的，但已经绑定到一个特定值或一组值的变量。
- 要创建一个绑定到集合的变量，我们可以使用 for 循环方法和 globals()方法。
- 它将实例作为对象传递，第一个参数用于访问变量和函数。
举例:
让我们举一个例子来检查如何创建一个绑定到集合的变量
var="apple"
apple1=()
apple2=()
apple3=()
for i in range(4):
globals()[ var+str(i)]='a'
print(apple1)
print(apple2)
print(apple3)
下面是以下代码的截图
Python creates a variable bound to a set
Python 从字符串中创建变量名
- 在本节中，我们将学习如何从字符串创建变量名。
- 要从字符串创建变量名，我们可以很容易地使用函数 exec()。
- exec()函数用于动态执行程序。
举例:
让我们举一个例子来检查如何通过 exec()方法从字符串创建变量名。
variable = 'John'
John=[]
exec("%s = %d" % (variable,10))
print(John)
- 首先在上面的例子中，我们有一个变量，我们在其中存储了一个字符串值 john。
- 在
exec()函数中，我们有 %s 和 %d 分别作为字符串值和十进制值的占位符。这意味着我们在赋值操作符的帮助下将一个整数值赋给一个字符串。
下面是以下代码的截图
Python creates a variable name from a string
- 另一种方法是使用
globals()方法。 - 全局方法以字典的形式提供输出。
举例:
让我们举一个例子来检查如何使用 globals()方法从字符串创建变量名。
str = "John"
John=[]
globals()[str] = 500
print(John)
- 首先在上面的例子中，我们将 str 中的一个输入作为 john。
- 然后我们必须通过 globals()方法更新字符串的元素。
下面是以下代码的截图
Python creates a variable name from a string by the globals method
Python 创建一个变量并赋值
- 在本节中，我们将学习如何创建一个变量并赋值。
- 要创建一个变量，你只需要给它赋值，然后开始使用它。
- 等号运算符用于给变量赋值。
- 在 python 编程语言中，没有声明变量的命令。
- 还可以用 type()函数获取变量的数据类型。
举例:
让我们举一个例子来检查如何创建一个变量并赋值
x = 10
y = "Micheal"
print(x)
print(y)
- 在上面的例子中，我们有两个变量 X 和 Y，我们给它们赋值。
- 我们给 X 取了 10，给 Y 取了 Micheal，这就是你在 python 中创建变量的方法。
下面是以下代码的截图
Python create a variable and assign a value
Python 在循环中创建变量
- 在本节中，我们将学习如何在循环中创建变量。
- 为了在循环中创建一个变量，我们使用了一个循环方法。
- Python for 循环方法以关键字“for”开始，后跟一个变量名，该变量名将保存下面的对象的值，该对象将被单步执行。
- 首先，我们将创建一个变量并把输入值和字符放在一个列表或元组中，然后在我们将使用 for 循环的方法后打印这个变量。
举例:
让我们举一个例子来检查如何在循环中创建一个变量
languages = ["Python3", "Java", "Ruby", "pascal"]
for language in languages:
print(language)
下面是以下代码的截图
Python create a variable in a loop
Python 创建了一个没有值的变量
- 在本节中，我们将学习并讨论如何创建一个没有值的变量。
- Python 是一种动态语言，所以不需要创建这种类型的变量，当第一次赋值给它时，它会自动声明。
- 要创建一个没有值的变量，我们只需将变量赋值为 None。
举例:
让我们举一个例子来检查如何创建一个没有值的变量。
variable = None
print(variable)
下面是以下代码的截图
Python create a variable without a value
Python 为列表中的每一项创建变量
- 要为列表中的每一项创建一个变量，我们可以很容易地使用 for 循环方法。
- 我们可以通过索引提取每个列表元素，然后将其分配给变量。
- 通过使用列表理解，我们可以为特定的索引运行一个循环，并将它们分配给所需的变量。
举例:
让我们举一个例子来检查如何为列表中的每一项创建一个变量。
a,b,c = [1,2,3]
x,y,z = [str(e) for e in [a,b,c]]
print(x,y,z)
下面是以下代码的截图
Python create variable for each item in a list
阅读: Python 串联列表示例
Python 创建变量如果不存在
- 在这一节中，我们将学习如何创建一个 Python 中没有的变量。
- 在 Python 中，变量可以局部定义，也可以全局定义。局部变量定义在函数内部，全局变量定义在函数外部。
- 为了创建一个局部变量，我们将使用 local()函数。
举例:
让我们举一个例子来检查如果变量不存在如何创建变量。
def func():
a_ = 0
local_variable = "a_" in locals()
print(local_variable)
func()
下面是以下代码的截图
Python creates variables if not exist
Python 创建一个随机变量
- 在这一节中，我们将学习如何在 Python 中创建一个随机变量。
- 随机整数值可以由 randint()函数产生。此函数接受两个参数，即生成的整数值范围的开始和最后一个。
- 在这个方法中，我们可以很容易地使用函数 randint()。
- randint()是 Python 中 random 模块的一个函数。
- 首先，我们将声明一个变量，传递 randint()函数中的值并打印该值。
举例:
让我们举一个例子来检查如何创建一个随机变量
# generate random integer values
from random import randint
import random
value = randint(1,4)
print(value)
下面是以下代码的截图
Python creates a random variable
Python 创建一个布尔变量
- 在本节中，我们将学习如何创建一个布尔变量。
- 在 python 中，布尔变量被定义为真或假。
- 在这种情况下，变量只能有两个可能的值:true 和 false。
- 为了创建一个布尔变量，我们使用关键字 bool。
- 此 bool()函数用于返回一个值或将一个值转换为布尔值。
举例:
让我们举一个例子来检查如何创建一个布尔变量
def check(num):
return(bool(num%2==0))
num = 10;
if(check(num)):
print("True")
else:
print("False")
- 在上面的例子中，我们首先创建一个函数检查并传递参数 num。
- 下一步是我们必须创建一个布尔函数，并采用偶数条件来检查 num 变量是偶数还是奇数。
- 如果数字是偶数，它将打印结果为真，否则为假。
下面是以下代码的截图
Python create a boolean variable
这是另一个场景:
这里，布尔变量由真或假关键字定义。
这里需要注意的一点是 True 和 False 应该以第一个字母大写。如果你写真和假，它会显示一个错误。让我们检查一下这个场景。
例子
a = true;
b = True;
c = True if a == b else False
print (c);
糟糕，我在第一行“name error:name ' true '未定义”中发现了错误。
上面的错误是因为我们犯了提及真实的错误。应该是真的(首字母大写)
正确的语法是
a = True;
b = True;
c = True if a == b else False
print (c);
输出如下所示
Python boolean variable
这是如何在 Python 中创建一个布尔变量。
阅读: Python 布尔值
Python 制作一个字符串变量 raw
- 在这一节中，我们将学习如何将一个字符串变量变成 raw 。
- 原始字符串不将反斜杠(" \ ")视为转义序列的一部分。
- 当我们有一个包含反斜杠的字符串并且不希望它被当作转义字符时，这是主要的方法。
- 如果我们不尝试打印一个包含“\n”的字符串，它将添加一个新的换行符。但是如果我们将它标记为一个字符串，它将简单地将“\n”作为一个字符打印出来。
举例:
让我们举一个例子来检查如何使一个字符串变量原始
a = "Hello\Pythonguides\nHi"
print(a)
下面是以下代码的截图
Python makes a string variable raw
在本 Python 教程中，我们将讨论创建 Python 变量，并涵盖以下示例:
- 用 python 创建一个变量
- Python 声明变量
- Python 变量类型
- Python 变量范围
- 用 python 创建一个全局变量
- Python 私有变量
- Python 保护的变量
- Python 中的静态变量
- 在 python 中创建一个字符串变量
- 用 python 创建一个虚拟变量
- 在 python 中创建一个空变量
- 在 python 循环中创建变量
- 在 python 中创建环境变量
- Python 动态创建一个变量名
- Python 创建了一个绑定到集合变量
- python 从字符串创建变量名
- Python 创建一个变量并赋值
- Python 在循环中创建了一个变量
- Python 创建了一个没有值变量
- Python 为列表中的每个项目创建变量
- Python 创建变量(如果不存在)
- Python 创建了一个随机变量
- Python 创建了一个布尔变量
- Python 使字符串变量原始
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
如何在 Python Django 中创建 web 表单
原文：https://pythonguides.com/create-web-form-in-python-django/
在这个 Python Django 教程中，我将解释如何使用 Django 表单。
作为一名 Python Django 开发人员，在从事 Django 项目时，我收到了从用户那里收集信息的要求。所以，我做了研究，发现我们可以在 Python Django 中创建 web 表单。
在这里我们将看到:
- 什么是 web 表单
- Django 的表格类型
- Django 表单如何工作
- Django 中的各种表单字段
- 如何使用 form 类在 Python Django 中创建 web 表单
- 如何使用 ModelForm 类在 Python Django 中创建 web 表单
- 如何在 Django 中使用各种控件，如文本框、下拉框、电子邮件、日期选择器和单选按钮
- 如何上传 Django 格式的文件
在本文的最后，您还可以使用 Form 类和 ModelForm 类下载 Django 表单的代码。
目录
- 使用 Django 表单
- 下载 Django 网络表单完整代码
- 结论
使用 Django 表单
现在，让我们首先了解 Django 表单，并逐步学习使用 Form 类和 ModelForm 类创建 Django 表单。
网页表单
web 表单是一个网页，其中有许多供用户输入数据或信息的字段。
不同的字段，包括文本框、复选框、单选按钮、数字框、图像框、日期选取器等，在表单中用于收集各种类型的数据。
此外，每个字段都有一个字段标签，这样任何查看表单的人都可以理解每个字段包含的内容。
通过 POST 请求提交数据的能力使表单成为与服务器共享数据的另一种非常安全的方式。
Django 的表格类型
下一步是在了解 web 表单之后，理解 Django 提供的各种表单类型。因此，在 Django 中有两种形式，如下所示。
- 简单 Django 形式:简单形式是独立于模型的形式。创建表单表单。使用表单类。它基本上创建 HTML 表单，并描述它是如何工作和出现的。
- Django 带模型的表单:带模型的表单类似于简单表单，但是它需要模型。创建模型表单表单。使用了 ModelForm 类。
Django 表单如何工作
一般用简单的 HTML 来呈现这些表单，可以用 JavaScript 和 CSS 来样式化。
幸运的是，Django 框架提供了表单，这简化了过程，让开发人员在构建表单时可以从零开始。
Django Form Working
根据上图，Django 的表单以如下方式工作:
- 当用户第一次请求表单时，会显示默认表单。
- 然后验证数据的有效性。
- 如果是，它将执行必要的操作，包括保存数据和提供结果。
- 如果没有，表单将再次显示用户输入的数据和错误通知。
- 最后，在表单成功提交后，它会转到另一个页面。
Django 表单中的各个字段
如上所述，web 表单是一个有许多字段的网页，所以我们可以说字段是表单最重要的部分。
所以，来看看 Django 中使用的所有表单字段类型的列表。
from django import forms
dir(forms)
Forms class fields
以下是 Django 表单中最常用的字段。
| 字段名 | 类 | HTML 输入 |
| 查菲尔德 | CharField 类(* 夸脱) | TextInput 组件 |
| 电子邮件字段 | 电子邮件合并类( * quartz) | 电子邮件输入 |
| 密码字段 | 类别密码字段(kwargs) | 密码输入 |
| 整数文件 | IntegerField 类(kwargs) | 数字输入 |
| 十进制字段 | 十进制字段级(* 夸脱) | 数字输入 |
| 日期字段 | 类日期字段(kwargs) | 日期输入 |
| 日期时间字段 | 类数据时间字段(kwargs) | 日期时间输入 |
| 布尔字段 | BooleanField 类(**kwargs) | 复选框输入 |
| 选择字段 | 类别选择字段( *夸脱) | 挑选 |
| 文件字段 | 类文件字段(kwargs) | ClearableFileInput |
| 图像域 | 类别 ImageField(kwargs) | ClearableFileInput |
如何使用表单类在 Python Django 中创建 web 表单
建立 Django 项目
首先，我们需要使用下面给出的命令在 Django 中建立一个项目。这里 SurveyProject 是项目的名称。
django-admin startproject SurveyProject
现在，在 Django 项目中，使用如下命令创建一个名为 SurveyApp 的 Django 应用程序。
python manage.py startapp SurveyApp
打开项目目录下的 settings.py 文件，将 SurveyApp 添加到 INSTALLED_APP 列表中。
settings.py
Django 中的请求首先到达位于项目目录中的 urls.py ，然后到达 app 目录中 urls.py 中的匹配 URL。在其中添加下面的代码。
from django.contrib import admin
from django.urls import path,include
urlpatterns = [
path('admin/', admin.site.urls),
path('',include('SurveyApp.urls')),
]
使用表单类创建 Django 表单
创建 Django 表单， SurveyApp 应用程序将使用该表单来收集用户输入。将以下代码添加到您在 app 目录中创建的 forms.py 文件中。
from django import forms
# Create your forms here.
CITY_CHOICES =(
("1", "New York"),
("2", "Washington"),
("3", "Los Angeles"),
("4", "Houston"),
("5", "Las Vegas"),
)
class CustomerForm(forms.Form):
name = forms.CharField(max_length=50)
address = forms.CharField(max_length=150)
city = forms.ChoiceField(choices=CITY_CHOICES)
pincode = forms.IntegerField()
email = forms.EmailField()
phone = forms.IntegerField()
这里，我们使用表单创建一个表单。名为 CustomerForm 的表单类。下面是该表单包含的字段。
- 姓名和地址为 Django CharFields。姓名和地址的长度分别限制在 50 个字符和 150 个字符以内。
- 作为 Django IntegerFields 的密码和电话。
- 电子邮件是 Django EmailField，允许用户保存电子邮件地址。
- 城市是 Django ChoiceField 字段，并且有一个 choices 选项可以用作字段的选项，并且由项目的 iterables 组成。
- 我们为此定义了一个名为
CITY_CHOICES的元组。
在 Django 中以表格的形式呈现表单
在主项目目录中创建一个名为 Templates 的子目录来存储 Django 应用程序的前端。
打开 settings.py 文件，更新 DIRS 指向 Templates 文件夹的位置。
settings.py
为了定义调查网页的前端，在模板文件夹中创建一个名为forms.html的 HTML 文件。并添加下面的代码。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width={device-width}, initial-scale=1.0">
<title>Document</title>
</head>
<body>
<form method="POST" class="post-form">
{% csrf_token %}
<h1 align="center">Coustomre Survey</h1>
<table>
{{ form.as_table}}
</table>
<button type="submit" class="save btn btn-default">Submit</button>
</form>
</body>
</html>
- 首先使用 HTML 标签
h1将标题添加到表单中。然后用方法POST调用表单标签，这样表单在提交后就被发布了。 - 为了防止表单受到网络攻击并允许您安全地发送信息，请在表单元素中添加 {% csrf_token %} 。
- 接下来，调用表单，并通过使用 {{form.as_tabel}} 标签将其显示为表格。当我们在表格中呈现表单时，在表格标签中传递这个标签。
- 最后，添加一个提交按钮来提交表单。
定义视图
要定义表单的主要逻辑，打开 views.py 文件并添加下面给出的代码。
from django.shortcuts import render
from .forms import CustomerForm
# Create your views here.
def customer(request):
if request.method == 'POST':
form = CustomerForm(request.POST)
if form.is_valid():
Name = form.cleaned_data['name']
Address = form.cleaned_data['address']
City = form.cleaned_data['city']
Pincode = form.cleaned_data['pincode']
Email = form.cleaned_data['email']
Phone = form.cleaned_data['phone']
print('Name:', Name)
print('Full Address:', Address, City, Pincode)
print('Email:', Email)
print('Phone:', Phone)
form = CustomerForm()
return render(request, "forms.html", {'form':form})
- 首先，从
forms.py中导入客户表单，并创建一个名为客户的视图。 - 然后调用
if语句，检查请求方法是否为POST。- 如果是，我们通过 CoustomerForm(请求。POST) 将数据绑定到表单类，这样我们就可以进行验证。
- 现在，调用
is_valid方法来验证用户输入的内容，如果验证成功，调用表单cleaned _ data[‘表单域’]来验证数据。 - 并使用
print()函数在终端上显示用户结果。
- 如果请求方法是
GET，则使用render()函数向用户呈现一个空白的调查表。
现在，我们必须用 URL 映射视图以便调用它，因此我们必须在 app 目录中创建一个名为 urls.py 的文件。包括下面的代码。
from django.urls import path
from SurveyApp import views
urlpatterns = [
path("", views.customer, name="customer"),
]
执行 Django 应用程序
要启动开发服务器，请在终端中键入下面给出的命令并运行服务器。
python manage.py runserver
它成功地打开了如下所示的客户调查表。
Customer Survey Form using Forms Class
现在，请填写此联系表格，并点击提交按钮，如下所示。
Survey Form using Forms Class
点击提交后，会在终端上打印出姓名、全称、电子邮件和电话。
Terminal Output
这就是使用 form 类创建 Django 表单的方法。
如何使用 ModelForm 类在 Python Django 中创建 web 表单
设置 Django 项目
Django web 应用程序总是有一个包含多个应用程序的项目。因此，我们需要首先使用下面给出的命令创建一个项目。
django-admin startproject CareerClub
现在，是时候在 Django 项目中创建一个应用程序了。因此，在终端中键入下面给出的命令。
python manage.py startapp Apply
为了考虑我们项目中的应用程序，我们需要将我们的项目名称包含在位于项目目录内的 settings.py 文件中的 INSTALLED_APPS 列表中。
settings.py
Django 自动在项目目录中创建一个 urls.py 文件。为了路由我们的应用程序，我们需要在其中包含应用应用程序，如下所示。
from django.contrib import admin
from django.urls import path,include
urlpatterns = [
path('admin/', admin.site.urls),
path('',include('Apply.urls')),
]
创建 Django 模型
当我们创建 Django 项目时，我们收到了一个空的 SQLite 数据库。为了在其中创建一个新表，我们必须创建一个新模型。
要在 Django 中创建模型，打开 app 目录中的 models.py 文件，并添加下面给出的代码。
from django.db import models
# Create your models here.
class Resume(models.Model):
full_name = models.CharField(max_length=150)
gender = models.CharField(max_length=10)
date_of_birth = models.DateField()
email = models.EmailField()
current_address = models.CharField(max_length=300)
city = models.CharField(max_length=20)
state = models.CharField(max_length=20)
resume = models.FileField(upload_to='resumes/')
def __str__(self):
return self.full_name
这里，我们创建了一个模型类 Resume ，它有以下字段。
- 全名是 Django CharFields。这个字符字段有 150 个字符的限制。
- 性别是姜戈·查菲尔德。并且该字符字段有 10 个字符的限制。
- 出生日期是姜戈日期字段。它用于收集用户的出生日期。
- 电子邮件是 Django EmailField，允许用户保存电子邮件地址。
cuurent_address是 Django CharField。这个字符字段有 300 个字符的限制。- 城市和州是 Django CharFields。这些字段的最大长度限制为 20。
- 简历是用于上传文件的 Django 文件字段。此外，它还有一个
upload_to选项，用于定义文件在媒体中的保存位置。
并使用 def __str__(self) 来更改 Django 模型中对象的显示名称。当我们返回 self.full_name 时，它会将项目名称显示为全名。
将模型注册到管理站点，以便用户可以在管理应用程序中查看它。打开 admin.py 文件，添加下面给出的代码。
from django.contrib import admin
from .models import Resume
# Register your models here.
admin.site.register(Resume)
使用 ModelForms 类在 Python Django 中创建 Web 表单
如果我们用 Django 表单和 Django 模型构建一个数据库驱动的应用程序。在这种情况下，模型字段和表单字段的质量和数量对于模型和表单都是相同的。
我们可以直接使用 ModelForm，而不是编写重复的代码来首先生成一个表单，然后将其映射到视图中的模型。
要创建一个表单，将下面的代码添加到我们在 app 目录中创建的 forms.py 文件中。
from django import forms
from .models import Resume
select_gender = (
("male", "Male"),
("female", "Female"),
("other", "Other"),
)
class DateInput(forms.DateInput):
input_type = 'date'
select_city = (
("new york", "New York"),
("los angeles", "Los Angeles"),
("houston", "Houston"),
("chicago", "Chicago"),
("phoenix", "Phoenix"),
("austin", "Austin"),
("boston", "Boston"),
("las vegas", "Las Vegas"),
("columbia", "Columbia"),
("waco", "Waco"),
)
select_state = (
("new york", "New York"),
("california", "California"),
("iiiinois", "IIIinois"),
("texas", "Texas"),
("arizona", "Arizona"),
("massachusetts", "Massachusetts"),
("nevada", "Nevada"),
("south carolina", "South Carolina"),
)
class ResumeForm(forms.ModelForm):
class Meta:
model = Resume
fields = '__all__'
widgets = {
"gender": forms.RadioSelect(choices=select_gender),
"date_of_birth": DateInput,
"city": forms.Select(choices=select_city),
"state": forms.Select(choices=select_state),
}
- 这里，我们使用表单创建一个表单。名为的模型类简历。它有来自简历模型的所有字段。
- 此外，我们定义了
widgets属性，将性别设置为单选按钮，出生日期设置为日期选择器，城市，以及州名设置为下拉按钮。 - 将城市和州设置为选择，传递一个选择选项，是作为一个字段选项的序列。我们为城市字段定义元组
select_city，为州字段定义元组select_state。 - 性别设置为单选，传递一个选择选项，该选项是用作字段选项的序列。我们为性别字段定义了元组
select_gender。
Django 文件上传设置
因为我们已经使用了模型中的文件字段来上传文件。我们必须设置一些设置来保存上传的文件。
为此，打开 settings.py 文件，并在文件末尾添加下面给出的行。
import os
MEDIA_URL = '/media/'
MEDIA_ROOT = os.path.join(BASE_DIR, 'media')
- 媒体 URL: 用户可以使用此 URL 从浏览器上传文件。
- 媒体根:指定文件存储的主要位置。它指示 Django 将所有上传的文件保存在一个名为媒体的文件夹中。
注意:要保存提交的文件，我们必须在主项目目录中手动创建名为 media 的文件夹。
在 Django 中以表格的形式呈现表单
在 Django 中，应用程序的前端是在模板中定义的，为此，在主项目目录中创建一个名为模板的子目录来存储所有的项目模板。
打开 settings.py 文件，更新 DIRS 指向 Templates 文件夹的位置。
Setting Template Folder Location
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Job Application</title>
<style>
table {
border: 8px outset;
border-radius: 10px;
border-spacing: 10px;
padding: 20px;
margin-left: auto;
margin-right: auto;
}
</style>
</head>
<body>
<h1 align="center">Job Application</h1>
<hr>
<h3 align="center">Please complete the form below to apply for a position with us.</h3>
<hr>
<br>
<form method="post" enctype="multipart/form-data">
{% csrf_token %}
<table>
{{form.as_table}}
</table>
<br><br>
<div style="text-align:center">
<input type="submit" />
</div>
</form>
</body>
</html>
- 首先，我们在头标签中设置表的样式。
- 然后使用 HTML 标签
h1和h4将表单的标题添加到 body 标签中。 - 一旦表单被提交，通过调用表单标签的
POST方法，表单就会被提交。 - 在表单标签中添加
enctype = " multipart/form-data "，否则表单将无法工作。 - 在表单元素中添加
csrf_token来保护表单免受网络攻击，并使您能够安全地传输数据。 - 接下来，使用
form.as_table标签将表单呈现为表格。 - 最后，添加一个提交按钮来提交表单。
定义视图
要定义工作申请表的主要逻辑，打开 views.py 文件并添加下面给出的代码。
from django.shortcuts import render,HttpResponse
from .forms import ResumeForm
# Create your views here.
def jobapply(request):
if request.method == 'POST':
form = ResumeForm(request.POST,request.FILES)
if form.is_valid():
form.save()
return HttpResponse('Your Job Application is successfully submitted')
else:
form = ResumeForm()
context = {
'form':form,
}
return render(request, 'apply_form.html', context)
- 首先，从
forms.py中导入ResumeForm并创建一个名为jobapply的视图。 - 然后，调用
if语句，检查请求方法是否为POST。- 如果是，只需添加一个请求。文件连同请求。将发布到表单方法中。
- 调用
is_valid方法验证用户输入的内容，如果验证成功调用save()保存用户输入的数据并返回HttpResponse。
- 如果请求方法是
GET，则使用render()函数向用户呈现一个空白的工作申请表。
现在，我们必须用 URL 映射视图以便调用它，因此我们必须在 app 目录中创建一个名为 urls.py 的文件。包括下面的代码。
from django.urls import path
from . import views
urlpatterns = [
path('apply', views.jobapply, name='apply'),
]
另外，检查:获取 Django 中的 URL 参数
执行 Django 应用程序
要创建包含模型表格模式代码的迁移文件，请在终端中键入以下命令。
python manage.py makemigrations
要根据迁移文件的模式构建表，请执行以下命令。
python manage.py migrate
要启动开发服务器，请在终端中键入下面给出的命令。
python manage.py runserver
通过展开如下所示的 URL，我们可以访问工作申请表。
127.1.1.0/apply
它成功地打开了我们使用 ModelForm 创建的 Django 联系人表单，如下所示。
Job Application form using ModelForm class
现在，填写表格并点击提交按钮，如下所示。
Job Application Form
成功提交表单后，我们将得到如下所示的 HttpResponse。
Success Message
从 Django 管理界面查看提交的数据
它还会将数据保存在数据库中。因此，创建一个超级用户，打开管理应用程序并查看它。
Admin Site
这就是如何使用 ModelForm 类在 Django 中创建表单。
下载 Django 网络表单完整代码
Django Form using Form ClassDjango Form using ModelForm Class
结论
至此，我们已经使用 form 类和 ModelForm 类成功创建了一个 Django web 表单。此外，我们还学会了在表单中添加各种控件，如文本框、电子邮件、下拉菜单、日期选择器和单选按钮。
我们还学会了上传 Django 表单中的文件，并在管理界面上查看提交的表单数据。
此外，我们还讨论了以下主题。
- 什么是 web 表单
- Django 的表格类型
- Django 表单如何工作
- Django 中的各种表单字段
- 如何使用 form 类在 Python Django 中创建 web 表单
- 如何使用 ModelForm 类在 Python Django 中创建 web 表单
- 如何在 Django 中使用各种控件，如文本框、下拉框、电子邮件、日期选择器和单选按钮
- 如何上传 Django 格式的文件
您可能也喜欢阅读下面的 Python Django 教程。
拥有丰富 Django 和 Matplotlib 经验的 Python 开发人员，目前在 TSInfo Technologies 工作。我正在成为专业程序员、博客写手和 YouTuber 的路上。
用 Python Tkinter 创建 Word 文档[完整源代码+视频]
原文：https://pythonguides.com/create-word-document-in-python-tkinter/
在这个 Python Tkinter 教程中，我们将学习如何在 python tkinter 中创建一个 word 文档。我们将使用 Python Tkinter 创建一个应用程序，它将生成一个带有动态值的 word 文档。
- 在 Python Tkinter 中创建 word 文档–概述
- Python 中的 Tkinter 模块
- Python 中的 Python-docx 模块
- python tkinter 应用程序概述
- python tkinter 应用程序的源代码
- python tkinter 应用程序的输出
目录
- 用 Python Tkinter 创建 word 文档
- Python 中的 Tkinter 模块
- Python 中的 Python-docx 模块
- tkinter 应用程序的源代码
- Python Tkinter 应用程序的输出
用 Python Tkinter 创建 word 文档
最近，我们得到一个要求，要使用 Python Tkinter 为即将离开组织的员工生成一个经验证明。
因此，我们使用 Python Tkinter 创建了一个完整的应用程序，它将接受如下输入:
| 用户输入 | Tkinter Widget |
|---|---|
| 员工 ID | 入口小工具 |
| 员工姓名 | 参赛作品 Widg e t |
| 指定 | 入口小工具 |
| 加入日期 | 入口小工具 |
| 结束日期 | 入口小工具 |
| 性别 | OptionMenu Widget |
然后，当用户填写表单并单击 Generate Word 按钮时，它将使用用户提供的动态值创建一个体验证书(Word 文档)。
word 文档还会有公司 logo、签名等。
该表单如下所示:
Application to convert word document in Python Tkinter
输出如下所示:
Create Word Document in Python Tkinter
另请参阅，如何使用 Pyinstaller 将 Python 文件转换为 exe 文件
Python 中的 Tkinter 模块
使用 python 中的 Tkinter 模块，我们可以创建任何应用程序的图形用户界面(GUI)。它是一个流行且易于使用的 python 模块，可以帮助您将基于命令行的应用程序转换为基于 GUI 的交互式程序。
我们的网站上有一个专门的教程，通过例子学习Python Tkinter。
在本节中，我们将讨论我们在创建 Tkinter 应用程序以生成经验证书 word 文件时使用的所有 python Tkinter 小部件。
| 用户输入 | Tkinter Widget |
|---|---|
| 员工 ID | 入口小工具 |
| 员工姓名 | 参赛作品 Widg e t |
| 指定 | 入口小工具 |
| 加入日期 | 入口小工具 |
| 结束日期 | 入口小工具 |
| 性别 | OptionMenu Widget |
- 性别是 tkinter OptionMenu 小部件，用户可以使用下拉菜单选择性别。这个信息用于声明主语代词。
- 使用性别信息，我们在消息的正文中指定了他、她、他、他的、她。
- Python Tkinter Entry 小部件用于从用户处获取基于字符串的输入。
- 除了 gender 之外的所有其他 tkinter 小部件都是 python tkinter entry 小部件。我们有一个关于 Python Tkinter Entry widget 和Python Tkinter option menu widget的专门博客。
Python 中的 Python-docx 模块
Python-docx 模块允许我们使用 python Tkinter 创建 word 文档。这是一个强大的 python 模块，允许创建新的 word 文档或更新现有文档。
Python-docx 可以通过以下命令使用 pip 和 conda 包管理器进行安装。
**# using pip**
pip install python-docx
**# using anaconda**
conda install -c conda-forge python-docx
Word 文档有很多功能可以帮助用户编写和格式化数据。使用 python-docx 模块，我们可以处理所有这些特性。下面是带有标记功能的 word 文档的图片。
Word document
- 每个特性在 python-docx 中都有专门的方法。python-docx 广泛使用的几个方法有 add_paragraph()、add_picture()、add_heading()、add_page_break()、add_table()等。
- 使用 python 创建 word 文档的第一步是创建 word 对象。以上所有方法都是文档对象的一部分。
from docx import Document
doc = Document()
接下来，我们将讨论 python-docx 模块的常用方法，使用这些方法，您可以用 python 创建一个示例 word 文档。
docx.styles()
如果您想节省手动格式化 word 文档每一行的时间，那么您可以在 python-docx 模块中使用此功能应用一组预格式化的样式。
下图显示了 word 文档中的样式选项:
Styles in word document
- 除此之外，您可以通过添加项目符号、将字体粗细更改为粗体、斜体、下划线等来修改样式。
举例:
这个例子演示了如何在 python docx 模块中创建样式，也展示了如何在 python docx 模块中的段落上使用样式。
**# style created**
new_style = doc.styles['Heading 1']
**# style applied**
doc.add_paragraph(style=new_style)
docx.add_heading()
标题指定主题或内容的简短描述。一个好的标题总是简短明了的。在本节中，我们将学习如何使用 python 添加标题。
- 每个子标题都比父标题小，这样它们就形成了 1-9 级的层次结构，其中 1 是最高级别，9 是最低级别。
- 默认情况下，python-docx picks 1 将默认文本作为标题，将级别更改为 0 会将类别从“标题”更改为“标题”。
doc.add_heading('United States of America', level=1)
- 更改高程值以修改 python docx 中的标题大小。
docx.add_paragraph()
段落是广泛使用的方法，因为每次您想要使用 python 模块 python-docx 在 word 文档中添加文本时，都需要这种方法。
- 每个段落使用 python 模块 python-docx 在 word 文档中添加一个单独的游程。
- 如果你想在一行中添加多个游程，那么在 add_paragraph()上使用
add_run()方法。 - 方法
add_run()在你想同时应用两个东西的时候非常有用。例如，您想添加一个段落，用粗体字显示您的国家名称。
举例:
这个例子演示了在 python 的 python-docx 模块中使用 add_paragraph()方法和 add_run()方法。
在这段代码中，我们添加了一个段落:“最佳国家”，并使用 run 对象添加了国家名称:美利坚合众国，然后对国家名称应用了粗体格式。这样，我们应用了 3 个活动，而不是一个，这是使用 add_run()方法的好处。
**# one-liner**
doc.add_paragraph('Best Country').add_run('United States of America').bold = True
**# same thing in 2 lines to make it look good**
nomination = doc.add_paragraph('Best Country')
nomination.add_run('United States of America').bold =True
Add paragraph in word document using Python docx
docx.add_picture()
使用 python-docx 中的 add_picture()方法，可以在 word 文档中添加图像。下图显示了可用于在 word 文档中上传图像的栏。
Add Picture in Word Document using Python
Python docx add_picture()方法提供了在 word 文件中添加图片的选项。您可以通过定义图像的高度和宽度来控制图像的大小。- 高度和宽度值可以是英寸或厘米。为了使用它们，你必须从
docx.shared导入英寸或厘米。
语法:
高度和宽度是可选的，但它可以是英寸或厘米(厘米)。我们建议将图像保存在主项目所在的同一个文件夹中，但是如果不可能的话，请提供完整的路径来代替<image_path>。</image_path>
from docx.shared import Inches
doc = Document()
doc.add_picture(<image_path>, width=Inches(val), height=Inches(val))
举例:
下面的例子演示了在 python docx 模块中使用 docx.add_image() 。在本例中，我们向 word 文档添加了一个图像文件。
**# import modules**
from docx import Document
from docx.shared import Inches
**# create an instance**
doc = Document()
**# add image**
doc.add_picture('logo.png', height=Inches(0.81), width=Inches(2.52))
**# save file**
doc.save('word.docx')
Add image in word using python docx
至此，我们总结了 python docx 模块的几个重要且广泛使用的方法。python-docx 的官网上还有很多功能可以探索。
如果您需要任何方法或函数的解释，请写信给我们，我们将分享相同的最佳教程。
tkinter 应用程序的源代码
在本节中，我们提供了创建应用程序的源代码，该应用程序用于为即将离开组织的员工生成经验证书。
- 在这个 python 应用程序中，使用 Python 库 Tkinter 创建了图形用户界面(GUI)。
- 通过交互界面，用户可以填写员工信息，如员工 id、姓名、加入日期等。
- python 程序将使用这些信息生成 word 格式的经验证书。
PermissionError: [Errno 13] Permission denied: 'word.docx'
请注意:再次点击生成 word 按钮前必须关闭 Word 文件。如果你看到上面的权限错误，这意味着文件已经打开。请关闭该文件，然后重试修复此错误。
我们已经为以下项目提供了源代码:
Python Tkinter 代码(GUI 开发)
下面是用 python 为体验信生成应用程序创建图形用户界面(GUI)的源代码。
**# modules**
from tkinter import *
**# clear function**
def clear_inputs():
eid.delete(0, 'end')
ename.delete(0, 'end')
desig.delete(0, 'end')
jd.delete(0, 'end')
ed.delete(0, 'end')
ws = Tk()
ws.title('Service Certificate Generator')
ws.geometry('400x300')
ws.config(bg='#456')
f = ('sans-serif', 13)
btn_font = ('sans-serif', 10)
bgcolor = '#BF5517'
genvar = StringVar()
genopt = ['Male', 'Female']
genvar.set('Male')
**# frames**
frame = Frame(ws, padx=20, pady=20, bg=bgcolor)
frame.pack(expand=True, fill=BOTH)
**# label widgets**
Label(
frame,
text="Employee ID",
font=f,
bg=bgcolor
).grid(row=0, column=0, sticky='w')
Label(
frame,
text="Employee Name",
font=f,
bg=bgcolor
).grid(row=1, column=0, sticky='w')
Label(
frame,
text="Designation",
font=f,
bg=bgcolor
).grid(row=2, column=0, sticky='w')
Label(
frame,
text="Joining Date",
font=f,
bg=bgcolor
).grid(row=3, column=0, sticky='w')
Label(
frame,
text="End Date",
font=f,
bg=bgcolor
).grid(row=4, column=0, sticky='w')
Label(
frame,
text='Gender',
font=f,
bg=bgcolor
).grid(row=5, column=0, sticky='w')
**# entry widgets**
eid = Entry(frame, width=20, font=f)
eid.grid(row=0, column=1)
ename = Entry(frame, width=20, font=f)
ename.grid(row=1, column=1)
desig = Entry(frame, width=20, font=f)
desig.grid(row=2, column=1)
jd = Entry(frame, width=20, font=f)
jd.grid(row=3, column=1)
ed = Entry(frame, width=20, font=f)
ed.grid(row=4, column=1)
gender = OptionMenu(
frame,
genvar,
*genopt
)
gender.grid(row=5, column=1, pady=(5,0))
gender.config(width=15, font=f)
btn_frame = Frame(frame, bg=bgcolor)
btn_frame.grid(columnspan=2, pady=(50, 0))
**# default inputs for testing**
eid.insert(0,'E1008')
ename.insert(0, 'Vineet Singh')
desig.insert(0, 'Python Developer')
jd.insert(0, 'Aug 3rd, 2020')
ed.insert(0, 'July 31st, 2021')
**# action buttons**
submit_btn = Button(
btn_frame,
text='Generate Word',
command=None, #generate,
font=btn_font,
padx=10,
pady=5
)
submit_btn.pack(side=LEFT, expand=True, padx=(15, 0))
clear_btn = Button(
btn_frame,
text='Clear',
command=clear_inputs,
font=btn_font,
padx=10,
pady=5,
width=7
)
clear_btn.pack(side=LEFT, expand=True, padx=15)
exit_btn = Button(
btn_frame,
text='Exit',
command=lambda:ws.destroy(),
font=btn_font,
padx=10,
pady=5
)
exit_btn.pack(side=LEFT, expand=True)
**# mainloop**
ws.mainloop()
使用 Python(命令行)创建 Word 文件的源代码
这里是使用 python 创建 word 文件的全功能 python 源代码。这段代码使用 python-docx 模块，它没有 GUI，这意味着您必须将信息放在代码本身中。
**# modules**
from docx import Document
from docx.opc.coreprops import CoreProperties
from docx.enum.style import WD_STYLE_TYPE
from docx.enum.text import WD_ALIGN_PARAGRAPH
from docx.shared import Inches, Pt
**# user inputs**
logo = 'files/tsinfo_logo.jpg'
output = 'Experience_letter1.docx'
sign = 'files/signature.png'
ceo_sig_text = '''Adarshnath Singh \nDirector'''
heading = 'Service Certificate'
emp_id = 'E1001' #eid.get()
emp_name = 'Vineet Singh' # ename.get()
designation = 'Software Engineer' #desig.get()
joining_date = 'August 20, 2019' #jd.get()
end_date = 'July 31, 2021' #ed.get()
comp_detail = '''TSInfo Technologies (OPC) Pvt Ltd
Flat G-115, SJR Residency, Devarabeesanahalli, Bellandur, Bangalore, 560103
Email: info@tsinfotechnologies.com, Phone: +91-9916854253
'''
gen = 'He' # who.get()
**# subject pronoun**
gen2 = 'his' # her
gen3 = 'him' # her
if gen.lower() == 'he':
gen2 = 'his'
gen3 = 'him'
elif gen.lower() == 'she':
gen2 = 'her'
gen3 = 'her'
else:
print('Error: accept He/She only')
**# certificate template**
body_text = f'''This is to certify that {emp_name} has worked with TSInfo Technologies (OPC) Pvt Ltd from {joining_date} to {end_date}, and was designated as {designation} at the time of {gen2} leaving the organization.
{gen.capitalize()} is hardworking and a good team player.
We wish {gen3} all the success in his future endeavor.
'''
**# create instance**
doc = Document()
**# declare margin**
sections = doc.sections
for section in sections:
section.top_margin = Inches(0.04)
section.bottom_margin = Inches(0.19)
section.left_margin = Inches(0.93)
section.right_margin = Inches(0.89)
section = doc.sections[0]
**# logo image placement**
logo = doc.add_picture(logo, width=Inches(2.52), height=Inches(0.81))
logo_placement = doc.paragraphs[-1]
logo_placement.alignment = WD_ALIGN_PARAGRAPH.CENTER
**# line space**
for _ in range(1):
linespace_style = doc.styles['Body Text']
linespace = doc.add_paragraph(style=linespace_style).add_run(' ')
linespace_style.font.size = Pt(10)
**# employee Id**
empid_style = doc.styles['Normal']
empid = doc.add_paragraph(style=empid_style).add_run(f'{emp_id}')
empid.font.bold = True
**# line space**
for _ in range(1):
linespace_style = doc.styles['Body Text']
linespace = doc.add_paragraph(style=linespace_style).add_run()
linespace.font.size = 10
**# Header**
heading_style = doc.styles['Body Text']
head=doc.add_paragraph(style=heading_style).add_run(f'{heading}')
doc.paragraphs[-1].alignment = WD_ALIGN_PARAGRAPH.CENTER
head.font.size = Pt(20)
head.font.bold = True
**# body text**
body_style = doc.styles['Body Text']
body = doc.add_paragraph(style=body_style).add_run(f'{body_text}')
body.font.size = Pt(14)
body.font.name = 'Times New Roman'
**#line space**
for _ in range(2):
linespace_style = doc.styles['Body Text']
linespace = doc.add_paragraph(style=linespace_style).add_run()
linespace.font.size = 10
**# signature image & text**
ceo_sign = doc.styles['Body Text']
doc.add_picture(sign, width=Inches(1.57), height=Inches(0.43))
doc.add_paragraph(style=ceo_sign).add_run(f'{ceo_sig_text}')
ceo_sign.font.size = Pt(14)
**# line space**
for _ in range(4):
linespace_style = doc.styles['Body Text']
linespace = doc.add_paragraph(style=linespace_style)
**# footer text : company description**
company_text = doc.styles['Normal']
company_text.paragraph_format.space_before = Pt(12)
doc.add_paragraph(style=company_text).add_run(f'{comp_detail}')
center_align = doc.paragraphs[-1]
center_align.alignment = WD_ALIGN_PARAGRAPH.CENTER
**# saving file to word document**
doc.save(output)
使用 python 生成 word 文档的完整源代码 tkinter
下面是一个完整应用程序的源代码，它将生成一封员工的体验信。它通过使用 python 中的 tkinter 模块创建的图形用户界面接受信息。
然后，它用提供的信息创建一个 word 文档。它使用 python-docx 模块与 word 文档进行交互。
使用以下步骤在您的设备上设置项目:
- 创建一个文件夹来保存此项目。
- 创建并激活虚拟环境。
- 在虚拟环境中安装 python-docx 模块。
- 创建 main.py 并将下面的代码粘贴到该文件中。
- 创建名为文件和输出的文件夹。在文件夹中添加图片。
- 运行程序，经验信将在输出文件夹内生成。
**# modules**
from docx import Document
from docx.opc.coreprops import CoreProperties
from docx.enum.style import WD_STYLE_TYPE
from docx.enum.text import WD_ALIGN_PARAGRAPH
from docx.shared import Inches, Pt
from tkinter import *
from tkinter import messagebox
ws = Tk()
ws.title('Service Certificate Generator')
ws.geometry('400x300')
ws.config(bg='#456')
f = ('sans-serif', 13)
btn_font = ('sans-serif', 10)
bgcolor = '#BF5517'
genvar = StringVar()
genopt = ['Male', 'Female']
genvar.set('Male')
def clear_inputs():
eid.delete(0, 'end')
ename.delete(0, 'end')
desig.delete(0, 'end')
jd.delete(0, 'end')
ed.delete(0, 'end')
def generate():
**# data variables**
logo = 'files/tsinfo_logo.jpg'
output = 'output/Experience_letter.docx'
sign = 'files/signature.png'
ceo_sig_text = '''Adarshnath Singh \nDirector'''
heading = 'Service Certificate'
emp_id = eid.get()
emp_name = ename.get()
designation = desig.get()
joining_date = jd.get()
end_date = ed.get()
comp_detail = '''
TSInfo Technologies (OPC) Pvt Ltd
Flat G-115, SJR Residency, Devarabeesanahalli, Bellandur, Bangalore, 560103
Email: info@tsinfotechnologies.com, Phone: +91-9916854253
'''
**# gender specification**
gen1 = 'He' # she
gen2 = 'his' # her
gen3 = 'him' # her
if genvar.get() == 'Male':
gen1 = 'He'
gen2 = 'his'
gen3 = 'him'
elif genvar.get() == 'Female':
gen1 = 'She'
gen2 = 'her'
gen3 = 'her'
else:
messagebox.showerror('Error', 'Incorrect gender Selection!')
**# experience certificate template**
body_text = f'''
This is to certify that {emp_name} has worked with TSInfo Technologies (OPC) Pvt Ltd from {joining_date} to {end_date}, and was designated as {designation} at the time of {gen2} leaving the organization.
{gen1} is hardworking and a good team player.
We wish {gen3} all the success in {gen2} future endeavor.
'''
** # create object(s)**
doc = Document()
sections = doc.sections
** # declare margin**
for section in sections:
section.top_margin = Inches(0.04)
section.bottom_margin = Inches(0.19)
section.left_margin = Inches(0.93)
section.right_margin = Inches(0.89)
section = doc.sections[0]
**# logo image placement**
logo = doc.add_picture(logo, width=Inches(2.52), height=Inches(0.81))
logo_placement = doc.paragraphs[-1]
logo_placement.alignment = WD_ALIGN_PARAGRAPH.CENTER
**# line space**
for _ in range(1):
linespace_style = doc.styles['Body Text']
linespace = doc.add_paragraph(style=linespace_style).add_run(' ')
linespace_style.font.size = Pt(10)
**# employee Id**
empid_style = doc.styles['Normal']
empid = doc.add_paragraph(style=empid_style).add_run(f'{emp_id}')
empid.font.bold = True
** # line space**
for _ in range(1):
linespace_style = doc.styles['Body Text']
linespace = doc.add_paragraph(style=linespace_style).add_run()
linespace.font.size = 10
**# Header**
heading_style = doc.styles['Body Text']
head = doc.add_paragraph(style=heading_style).add_run(f'{heading}')
doc.paragraphs[-1].alignment = WD_ALIGN_PARAGRAPH.CENTER
head.font.size = Pt(20)
head.font.bold = True
**# body text**
body_style = doc.styles['Body Text']
body = doc.add_paragraph(style=body_style).add_run(f'{body_text}')
body.font.size = Pt(14)
body.font.name = 'Times New Roman'
** #line space**
for _ in range(2):
linespace_style = doc.styles['Body Text']
linespace = doc.add_paragraph(style=linespace_style).add_run()
linespace.font.size = 10
**# signature image & text**
ceo_sign = doc.styles['Body Text']
doc.add_picture(sign, width=Inches(1.57), height=Inches(0.43))
doc.add_paragraph(style=ceo_sign).add_run(f'{ceo_sig_text}')
ceo_sign.font.size = Pt(14)
**# line space**
for _ in range(4):
linespace_style = doc.styles['Body Text']
linespace = doc.add_paragraph(style=linespace_style)
# linespace.font.size = Pt(10)
** # footer text : company description**
company_text = doc.styles['Normal']
company_text.paragraph_format.space_before = Pt(12)
doc.add_paragraph(style=company_text).add_run(f'{comp_detail}')
center_align = doc.paragraphs[-1]
center_align.alignment = WD_ALIGN_PARAGRAPH.CENTER
doc.save(output)
**# frames**
frame = Frame(ws, padx=20, pady=20, bg=bgcolor)
frame.pack(expand=True, fill=BOTH)
**# label widgets**
Label(
frame,
text="Employee ID",
font=f,
bg=bgcolor
).grid(row=0, column=0, sticky='w')
Label(
frame,
text="Employee Name",
font=f,
bg=bgcolor
).grid(row=1, column=0, sticky='w')
Label(
frame,
text="Designation",
font=f,
bg=bgcolor
).grid(row=2, column=0, sticky='w')
Label(
frame,
text="Joining Date",
font=f,
bg=bgcolor
).grid(row=3, column=0, sticky='w')
Label(
frame,
text="End Date",
font=f,
bg=bgcolor
).grid(row=4, column=0, sticky='w')
Label(
frame,
text='Gender',
font=f,
bg=bgcolor
).grid(row=5, column=0, sticky='w')
**# entry widgets**
eid = Entry(frame, width=20, font=f)
eid.grid(row=0, column=1)
ename = Entry(frame, width=20, font=f)
ename.grid(row=1, column=1)
desig = Entry(frame, width=20, font=f)
desig.grid(row=2, column=1)
jd = Entry(frame, width=20, font=f)
jd.grid(row=3, column=1)
ed = Entry(frame, width=20, font=f)
ed.grid(row=4, column=1)
gender = OptionMenu(
frame,
genvar,
*genopt
)
gender.grid(row=5, column=1, pady=(5,0))
gender.config(width=15, font=f)
btn_frame = Frame(frame, bg=bgcolor)
btn_frame.grid(columnspan=2, pady=(50, 0))
**# default inputs for testing**
eid.insert(0,'E1008')
ename.insert(0, 'Vineet Singh')
desig.insert(0, 'Python Developer')
jd.insert(0, 'Aug 3rd, 2020')
ed.insert(0, 'July 31st, 2021')
submit_btn = Button(
btn_frame,
text='Generate Word',
command=generate,
font=btn_font,
padx=10,
pady=5
)
submit_btn.pack(side=LEFT, expand=True, padx=(15, 0))
clear_btn = Button(
btn_frame,
text='Clear',
command=clear_inputs,
font=btn_font,
padx=10,
pady=5,
width=7
)
clear_btn.pack(side=LEFT, expand=True, padx=15)
exit_btn = Button(
btn_frame,
text='Exit',
command=lambda:ws.destroy(),
font=btn_font,
padx=10,
pady=5
)
exit_btn.pack(side=LEFT, expand=True)
**# mainloop**
ws.mainloop()
Python Tkinter 应用程序的输出
在这个输出中，有一个接受关于雇员的各种信息的表单。填写信息后，单击“生成单词”按钮，将会生成一个单词文件。
该 word 文件将有一个经验证书模板，其中的员工信息(Id、姓名、加入日期等)将动态分配到相应的位置。
- 清除按钮将清除入口，退出按钮将终止程序。
- 这个应用程序表单是使用 python tkinter 创建的，它使用 python-docx 模块与 word 文件进行交互。
Python Tkinter Service Certificate Generator
- 下图是生成的服务证书。这是一个 word 文件，动态值以黄色突出显示。所有这些黄色值都是由用户在上图中提供的。
- 突出显示的黄色仅用于演示目的，在执行程序时不会出现。
Python Tkinter Generated Service Certificate
这就是如何通过使用 Python Tkinter 在 Python 中创建一个 word 文档。
相关 Python Tkinter 教程:
- Python Tkinter Stopwatch
- 使用 Python Tkinter 的身体质量指数计算器
- 使用 Python Tkinter 的费用跟踪应用程序
- 如何使用 Python Tkinter 创建倒计时定时器
- 用 Python Tkinter 上传文件
- Python Tkinter 拖拽
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
交叉熵损失 PyTorch
在本 Python 教程中，我们将学习 Python 中的交叉熵损失 PyTorch ，我们还将涵盖与交叉熵损失 PyTorch 相关的不同示例。此外，我们将涵盖这些主题。
- 交叉熵损失 PyTorch
- 交叉熵损失 PyTorch 示例
- 交叉熵损失 PyTorch 实现
- 交叉熵损失 PyTorch softmax
- 交叉熵损失 PyTorch 泛函
- 交叉熵损失 PyTorch 逻辑
- 交叉熵损失 PyTorch 向后
- 交叉熵损失 PyTorch 权重
- 交叉熵损失 PyTorch 减少
目录
- 交叉熵损失 PyTorch
- 交叉熵损失 PyTorch 示例
- 交叉熵损失 PyTorch 实现
- 交叉熵损失 PyTorch softmax
- 交叉熵损失 PyTorch 泛函
- 交叉熵损失 py torch logists
- 交叉熵损失 PyTorch 后退
- 交叉熵损失 PyTorch 权重
- 交叉熵损失 PyTorch 减少
交叉熵损失 PyTorch
在本节中，我们将学习 python 中的交叉熵损失 PyTorch 。
- 交叉熵损失主要用于机器学习中的分类问题。
- 标准是计算输入变量和目标变量之间的交叉熵。
代码:
在下面的代码中，我们将导入一些库来计算变量之间的交叉熵。
- 输入= torch.tensor([[3.4，1.5，0.4，0.10]]，dtype=torch.float) 作为输入变量。
- target = torch.tensor([0]，dtype=torch.long) 作为目标变量。
from torch import nn
criteria = nn.CrossEntropyLoss()
input = torch.tensor([[3.4, 1.5,0.4, 0.10]],dtype=torch.float)
target = torch.tensor([0], dtype=torch.long)
criteria(input, target)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到交叉熵损失值被打印在屏幕上。
Cross entropy loss PyTorch
另外，检查:使用 Python 的机器学习
交叉熵损失 PyTorch 示例
在本节中，我们将借助一个例子来了解交叉熵损失 PyTorch 。
交叉熵被定义为用于计算给定变量集的概率分布之间的差异的过程。
代码:
在下面的代码中，我们将导入一些库，从中我们可以计算两个变量之间的交叉熵。
- total _ BCE _ loss = num . sum(-y _ true * num . log(y _ pred)–(1–y _ true) num . log(1–y _ pred))*是计算交叉熵损失。
mean _ BCE _ loss = total _ BCE _ loss/num _ of _ samples用于计算交叉熵损失的平均值。- print(" CE error is:"+str(cross entropy _ value))用于打印交叉熵值。
sigmoid = torch . nn . sigmoid()用于保证输入在 0 和 1 之间。- output = cross entropy _ loss(input，target) 用于计算交叉熵损失的输出。
import numpy as num
import torch
y_pred = num.array([0.1582, 0.4139, 0.2287])
y_true = num.array([0.0, 1.0, 0.0])
def CrossEntropy(y_pred, y_true):
total_bce_loss = num.sum(-y_true * num.log(y_pred) - (1 - y_true) * num.log(1 - y_pred))
num_of_samples = y_pred.shape[0]
mean_bce_loss = total_bce_loss / num_of_samples
return mean_bce_loss
crossentropy_value = CrossEntropy(y_pred, y_true)
print ("CE error is: " + str(crossentropy_value))
crossentropy_loss = torch.nn.BCELoss()
sigmoid = torch.nn.Sigmoid()
input = torch.tensor(y_pred)
target = torch.tensor(y_true)
output = crossentropy_loss(input, target)
output
输出:
在下面的输出中，我们可以看到交叉熵损失示例值被打印在屏幕上。
Cross entropy loss PyTorch example
阅读:蟒蛇皮里的熊猫
交叉熵损失 PyTorch 实现
在本节中，我们将学习 python 中的交叉熵损失 PyTorch 实现。
- 我们知道交叉熵损失 PyTorch 用于计算输入和输出变量之间的差异。
- 这里我们可以通过实现来计算输入和输出变量之间的差异。
代码:
在下面的代码中，我们将从计算交叉熵损失中导入一些库。
- X = torch.randn(batch_size，n_classes) 用于获取随机值。
- target = torch . randint(n _ classes，size=(batch_size，)，dtype=torch.long) 作为目标变量。
- f.cross_entropy(X，target) 用于计算交叉熵。
import torch
import torch.nn as nn
import torch.nn.functional as f
batch_size, n_classes = 7, 5
X = torch.randn(batch_size, n_classes)
X.shape
X
target = torch.randint(n_classes, size=(batch_size,), dtype=torch.long)
target
f.cross_entropy(X, target)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到实现后的交叉熵值打印在屏幕上。
Cross entropy loss PyTorch implementation.
交叉熵损失 PyTorch softmax
在本节中，我们将了解 python 中 Pytorch softmax 的交叉熵损失。
- 交叉熵损失 PyTorch softmax 定义为在 0 和 1 之间改变 K 个实数值的任务。
- 交叉熵的目的是测量与真实值的距离，也用于获取输出概率。
代码:
在下面的代码中，我们将导入一些库，从中我们可以测量交叉熵损失 softmax。
- X = torch.randn(batch_size，n_classes) 用于获取值。
- def soft max(x):return x . exp()/(x . exp()。sum(-1))。unsqueeze(-1) 用于定义 softmax 值。
- loss=nl(pred，target) 用于计算损失。
import torch
import torch.nn as nn
import torch.nn.functional as f
batch_size, n_classes = 7, 5
X = torch.randn(batch_size, n_classes)
X.shape
X
target = torch.randint(n_classes, size=(batch_size,), dtype=torch.long)
target
def softmax(x): return x.exp() / (x.exp().sum(-1)).unsqueeze(-1)
def nl(input, target): return -input[range(target.shape[0]), target].log().mean()
pred = softmax(X)
loss=nl(pred, target)
loss
pred = softmax(X)
loss=nl(pred, target)
loss
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到交叉熵损失 softmax 的值打印在屏幕上。
Cross entropy loss PyTorch softmax
交叉熵损失 PyTorch 泛函
在本节中，我们将学习 Python 中的交叉熵损失 PyTorch 泛函。
交叉熵损失 PyTorch 有很多功能。我们可以逐一解释每一个功能。
- 交叉熵
- 二元交叉熵
- 二元交叉熵与对数
- ctc_loss
- 余弦嵌入损失
- nll _ 损失
- 高斯非线性损耗
- l1 _ 损失
- 多重利润损失
- 软利润损失
- 三倍利润损失
- 三倍利润，带距离损失
- mse_loss
- Cross_entropy: 用于计算输入和目标变量之间的差异。
- 二元交叉熵:该函数用于计算目标概率和输入概率之间的二元交叉熵。
- Binary _ cross _ entropy _ with _ logits:该函数用于计算目标和输入逻辑之间的二元交叉熵。
- ctc_loss: 这被用作连接主义者的时间分类丢失。
- cosine_embedded_loss: 这用于计算给定输入张量的损失，也用于测量两个输入是否相似。
- nll_loss: 这个损失是负对数似然损失。
- 高斯 _ nll _ 损失:这个损失是高斯负对数似然损失。
- l1_loss: 使用该函数，该函数取元素间元素值差的平均值。
- multi_margin_loss: 用于改善输入输出变量之间的多类多分类铰链损失。
- soft_margin_loss: 用于改善输入张量和目标张量之间的两类分类 logistic 损失。
- triple_margin_loss: 用于计算样本之间的相对相似度。
- triple _ margin _ with _ distance _ loss:这用于计算给定输入张量的三重损失，以及计算锚点和正例之间关系的实值函数。
- mse_loss: 这用于测量元素间的均方误差。
阅读: PyTorch nn 线性+例题
交叉熵损失 py torch logists
在本节中，我们将学习 Python 中的交叉熵损失 PyTorch logits 。
- logit 函数用于确定标准的逻辑分布。它用于机器学习模型。
- 在交叉熵损失中，PyTorch logits 用于计算分数，这被称为 logit 函数。
代码:
在下面的代码中，我们将导入一些库，从中我们可以计算交叉熵损失 PyTorch logit。
- target = torch.ones([12，66]，dtype=torch.float32) 用作目标变量。
- 输出= torch.full([12，66]，1.7) 作为预测值。
- positive _ weight = torch . ones([66])用作权重等于 1 的正权重。
criteria = torch . nn . bcewithlogitsloss(pos _ weight = positive _ weight)用于计算交叉熵 logit 损失函数。
import torch
target = torch.ones([12, 66], dtype=torch.float32)
output = torch.full([12, 66], 1.7)
positive_weight = torch.ones([66])
criterion = torch.nn.BCEWithLogitsLoss(pos_weight=positive_weight)
criterion(output, target)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到交叉熵 logit 得分被打印在屏幕上。
Cross-Entropy loss PyTorch Logit
交叉熵损失 PyTorch 后退
在本节中，我们将学习 Python 中的交叉熵损失 PyTorch backward 。
- 交叉熵损失 Pytorch 向后用于计算当前张量的梯度。
- 交叉熵损失主要用于或有助于分类问题，并且还计算输入和目标之间的交叉熵损失。
代码:
在下面的代码中，我们将导入 torch 库，从中我们可以计算 PyTorch 向后函数。
- input = torch.randn(5，7，requires_grad=True) 作为输入变量。
- target = torch.empty(5，dtype=torch.long)。random_(5) 作为目标变量。
output.backward()用于获取向后输出。
import torch
import torch.nn as nn
loss = nn.CrossEntropyLoss()
input = torch.randn(5, 7, requires_grad=True)
target = torch.empty(5, dtype=torch.long).random_(5)
output = loss(input, target)
output.backward()
output
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到交叉熵损失 PyTorch 向后得分打印在屏幕上。
Cross entropy loss PyTorch backward
交叉熵损失 PyTorch 权重
在本节中，我们将学习 python 中的交叉熵损失 PyTorch 权重。
- 正如我们所知，交叉熵被定义为计算输入变量和目标变量之间差异的过程。
- 在交叉熵损失中，如果我们给定权重，它将权重分配给每个类，并且权重应该在 1d 张量中。
代码:
在下面的代码中，我们将导入一些库，从中我们可以计算交叉熵损失 PyTorch 权重。
- softmax=nn。Softmax() 用于改变 K 的实际值。
- 损失= nn。CrossEntropyLoss(wei ght=sc)用于计算交叉熵损失权重。
- input variable = torch . tensor([[3.0，4.0]，[6.0，9.0]]) 作为输入变量。
- target variable = torch . tensor([1，0]) 用作目标变量。
- 打印(输出)用于打印输出。
from torch import nn
import torch
softmax=nn.Softmax()
sc=torch.tensor([0.6,0.38])
loss = nn.CrossEntropyLoss(weight=sc)
inputvariable = torch.tensor([[3.0,4.0],[6.0,9.0]])
targetvariable = torch.tensor([1,0])
output = loss(inputvariable, targetvariable)
print(output)
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到交叉熵损失权重被打印在屏幕上。
交叉熵损失 PyTorch 减少
在本节中，我们将学习 python 中的交叉熵损失 PyTorch 权重。
- 交叉熵损失 PyTorch 被定义为以较少的数量创造某物的过程。
- 交叉熵也被定义为计算输入和输出变量之间的交叉熵的区域。
代码:
在下面的代码中，我们将导入一些库，从中我们可以计算交叉熵损失的减少。
- outputs = num . rand . rand(16，1，256，256) 用于生成输出的随机变量。
- targets = num . random . randint(2，size=(16，256，256)) 用于生成目标的随机变量。
seed = 0用于将随机种子设置为零。torch.manual_seed(seed)用于设置生成随机数的种子。loss _ fn = torch . nn . crossentropyloss(reduction = reduction)用于计算交叉熵损失减少量。- print(i，outputs.sum()、targets.sum()、outputs.mean()、targets.mean()、loss.sum()、loss.mean()) 用于在屏幕上打印输出。
import numpy as num
import torch
outputs = num.random.rand(16, 1, 256, 256)
outputs = num.hstack((outputs, 1.0 - outputs))
targets = num.random.randint(2, size=(16, 256, 256))
seed = 0
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False
for reduction in [ 'sum', 'mean']:
print(reduction)
for i in range(10):
torch.manual_seed(seed)
num.random.seed(seed)
outputs_torch, targets_torch = torch.from_numpy(outputs), torch.from_numpy(targets)
outputs_torch, targets_torch = outputs_torch.cuda(0), targets_torch.cuda(0)
loss_fn = torch.nn.CrossEntropyLoss(reduction=reduction)
loss_fn = loss_fn.cuda(0)
loss = loss_fn(outputs_torch, targets_torch)
loss = loss.detach().cpu().numpy()
print(i, outputs.sum(), targets.sum(), outputs.mean(), targets.mean(), loss.sum(), loss.mean())
输出:
运行上面的代码后，我们得到下面的输出，其中我们可以看到交叉熵损失减少打印在屏幕上。
Cross entropy loss PyTorch reduction
因此，在本教程中，我们讨论了交叉熵损失 PyTorch ，并且我们还涵盖了与其实现相关的不同示例。这是我们已经讨论过的例子列表。
- 交叉熵损失 PyTorch
- 交叉熵损失 PyTorch 示例
- 交叉熵损失 PyTorch 实现
- 交叉熵损失 PyTorch softmax
- 交叉熵损失 PyTorch 泛函
- 交叉熵损失 PyTorch 逻辑
- 交叉熵损失 PyTorch 向后
- 交叉熵损失 PyTorch 权重
- 交叉熵损失 PyTorch 减少
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Python Pandas 中的交叉表
在本教程中，我们将学习 Python 熊猫中的交叉表。此外，我们已经讨论了这些主题。
- Python Pandas 中的交叉表
- Python 熊猫示例中的交叉表
- 熊猫数据框
- 交叉表熊猫总和
- 交叉表熊猫正常化
- 交叉表熊猫标准化百分比
- 交叉表熊猫图
- 交叉表熊猫值
- 交叉表熊猫计数
- 交叉表熊猫 aggfunc
- 没有 aggfunc，就不能使用 Pandas 交叉表值
- 熊猫交叉表排序值
- 熊猫交叉表缺失值
- 熊猫交叉表空值
- 熊猫交叉表计算唯一值
- 熊猫交叉表填充值
- 熊猫交叉表默认值
目录
- Python 熊猫中的交叉表
- 交叉表熊猫示例
- 交叉表熊猫数据帧
- 交叉表熊猫总和
- 交叉表熊猫正常化
- 交叉表熊猫归一化百分比
- 交叉表熊猫图
- 交叉表熊猫值
- 交叉表熊猫数量
- 交叉表熊猫 aggfunc
- Pandas 交叉表值不能在没有 aggfunc 的情况下使用
- 熊猫交叉表排序值
- 熊猫交叉表缺失值
- 熊猫交叉表空值
- 熊猫交叉表计数唯一值
- 熊猫交叉表填充值
- 熊猫交叉表默认值
Python 熊猫中的交叉表
- 计算两个(或更多)因素的简单交叉列表。默认情况下，会计算因子的频率表，除非传递了值数组和聚合函数。
- 在 Python 中，交叉表是两个不同分类变量的列表。
语法:
pandas.crosstab(parameters)
参数:
| 索引 | 在行中作为分组依据的类似数组、系列或数组/系列值的列表。 |
| 列 | 列中作为分组依据的类似数组、系列或数组/系列值的列表。 |
| 值 | 类似数组的可选值数组，用于根据因子进行聚合。需要指定aggfunc。 |
| 行名 | sequence(如果传递，默认为 None)必须与传递的许多行数组相匹配。 |
| 列名 | sequence(如果传递，默认为 None)必须与传递的许多列数组相匹配。 |
| aggfunc | 如果指定了可选功能，则还需要指定“values”。 |
| 页边距 | bool，默认 False 添加行/列边距(小计)。 |
| margin_name | str，当 margins 为 True 时，将包含总计的行/列的默认“All”名称。 |
| dropna | bool，default True 不包括条目都是 NaN 的列。 |
| 正常化 | bool、{'all '、' index '、' columns'}或{0，1}，默认 False 通过将所有值除以值的总和来进行规范化。 |
你可能会喜欢 Python 熊猫里的 Groupby。
交叉表熊猫示例
- 在本节中，我们将使用“Indian_food”数据集演示交叉表的工作方式。我们已经从 kaggle 获得了这个数据集。
- 在这个数据集中，印度美食包含了各种印度次大陆的地方和传统美食。
- 在下图中，我们以阿萨姆邦为例。在阿萨姆邦，有 10 道非素菜和 11 道素菜。所以这个频率矩阵可以使用 pandas 中的 crosstab 函数来创建。
Crosstab pandas example
在 jupyter 笔记本上实现。
如何删除熊猫中的一个栏目
在本 Python 教程中，我们将学习在 Python 熊猫中删除一列的各种方法。我们将使用一些内置函数来理解在 Python Pandas 中删除列的各种方法
作为一名开发人员，在制作 Python 项目时，我被要求删除 pandas 中的一个列
在这里我们将看到:
- 如何使用 dataframe.pop()删除 pandas 中的列
- 如何使用 del 关键字删除 pandas 中的列
- 如何使用 drop()在 Python pandas 中删除列
- 如何使用 drop()删除 Python pandas 中的多个列
目录
- 删除 Python 熊猫里的一个栏目
- 如何使用 dataframe.pop()删除 pandas 中的列
- 如何使用 del 关键字删除 pandas 中的列
- 如何使用 drop() 在 Python pandas 中删除列
- 如何使用 drop() 在 Python pandas 中删除多个列
删除 Python 熊猫里的一个栏目
在 Python 中，当在 Python Pandas 中删除列时，主要有六种常用且重要的理解方法。
如何使用 dataframe.pop()删除 pandas 中的列
- 在本节中，我们将讨论如何使用
dataframe.pop()在 Python pandas 中删除列。 - 通过简单地将列名作为参数传递，我们可以使用
pandas.dataframe.pop()方法从数据框中移除或删除列。 - 此函数返回指定的项目，并将指定的项目放到数据帧中。这项技术使我们能够从数据帧中删除任何部分。
语法:
下面是 Python 中 pandas dataframe.pop()的语法
DataFrame.pop(item)
注意:该参数只有一个参数，表示将要弹出的下一列的标签。
举例:
让我们举一个例子，看看如何使用 dataframe.pop() 在 Python pandas 中删除一列。
源代码:
import pandas as pd
new_info = {"Student_id": [672,378,782,125], "Student_Age":[13,18,12,16], "Student_name":['James','Potter','William','George']}
input = pd.DataFrame(new_info)
print("Input Data frame:\n", input)
input.pop("Student_Age")
print("\nData frame after deleting the column 'Student_Age':\n", input)
在下面的代码中，我们首先声明了一个字典，然后使用 pd.dataframe()函数将它们转换成 dataframe。接下来，我们使用 input.pop()函数从 dataframe 中删除了“student_age”列。
下面是下面给出的代码的截图。
How to delete a column in pandas using a dataframe.pop()
这是如何使用 dataframe.pop()删除 pandas 中的列。
如何使用 del 关键字删除 pandas 中的列
- 现在让我们讨论如何使用 del 关键字删除 Python Pandas 中的列。
- Python 中的 del 关键字也可用于直接从数据框中移除列。在 Python 中，del 关键字通常用于移除或清空对象。
- 在这个例子中，我们将生成一个 DataFrame，然后使用 del 关键字删除一个特定的列。使用列标签，选择要删除的列。
语法:
让我们看看语法，理解 Python 中 del 关键字的工作原理
del dataframe['item']
注意:该参数只取一个参数，表示下一列将要删除的标签。
举例:
这里我们将举一个例子，并检查如何使用 del 关键字在 Python Pandas 中删除列。
源代码:
import pandas as pd
Country_info = {'State_names': ['Alabama', 'Alaska', 'Arizona'],
'Zip_code': [8923,1234,78234]}
#create dataframe
new_val = pd.DataFrame(Country_info)
print("Input DataFrame: ",new_val)
#delete a column
del new_val['Zip_code']
print("After deleting the column :",new_val)
在上面的代码中，我们首先导入了 Pandas 库，然后声明了一个字典‘Country _ info’。接下来，我们使用 pd.dataframe()函数将字典转换成数据帧。
之后，我们使用 del 关键字从 dataframe 中删除特定的列。
你可以参考下面的截图
How to delete a column in pandas using a del keyword
在这个例子中，我们已经理解了如何使用 del 关键字删除 pandas 中的列。
如何使用 drop() 在 Python pandas 中删除列
- 在这一节中，我们将讨论如何使用 drop()在 Python pandas 中删除列。
- 在
pandas.dataframe.drop()函数的帮助下，我们可以从数据框中移除值。这些值要么是面向行的，要么是面向列的。 - 要删除此示例的 dataframe 中的特定列，请使用 drop()函数。要选择要删除的列，我们使用列标签。
语法:
下面是 Python 中 pandas.dataframe.drop()的语法
dataframe.drop('item', inplace=True, axis=1)
- 它由几个参数组成
- 项:表示将要删除的下一列的标签。
- inplace: 默认返回 DataFrame 的副本，False。当使用 True 时，它就地删除当前 DataFrame 的列，并返回 None。
- Axis: 默认情况下，它取 1，这意味着我们必须为列方式的元素删除它。如果它是 0，那么它将按行删除它。
举例:
import pandas as pd
emp_info = {"emp_id": [845,905,198,289], "emp_Age":[16,17,14,18], "emp_name":['Micheal','Robert','William','George']}
new_input = pd.DataFrame(emp_info)
print("Input Data frame:\n", new_input)
new_input.drop("emp_name", inplace=True, axis=1)
print("\nData frame after deleting the column 'emp_name':\n", new_input)
在下面给出的代码中，我们首先导入了 Pandas 库，然后通过使用 pd.dataframe() 函数创建了一个 dataframe，在这个函数中，我们将输入字典指定为一个参数。
之后，我们使用了 dataframe.drop() 函数，在这个函数中，我们提到了想要从 dataframe 中删除的列名。
下面是以下给定代码的实现。
How to delete a column in Python pandas using a drop
阅读: Python 熊猫掉行示例
如何使用 drop() 在 Python pandas 中删除多个列
- 现在让我们了解如何使用 drop()删除 Python pandas 中的多个列。
- 在
pandas.dataframe.drop()函数的帮助下，我们可以从数据框中移除值。这些值要么是面向行的，要么是面向列的。 - 要删除 dataframe 中的许多列，请使用 drop()函数。为了选择要删除的列，我们使用了一组列标签。
举例:
让我们举一个例子，看看如何使用 drop()删除 Python pandas 中的多个列。
源代码:
import pandas as pd
new_info = {"Student_id": [672,378,782,125], "Student_Age":[13,18,12,16], "Student_name":['James','Potter','William','George']}
input = pd.DataFrame(new_info)
print("Input Data frame:\n", input)
result=input.drop(['Student_Age', 'Student_name'], axis=1)
print("\nData frame after deleting the multiple columns :\n", result)
在上面的代码中，我们必须从 dataframe 中删除多个列，为此我们使用了 dataframe.drop()函数。在这个函数中，我们分配了多个列['Student_Age '，' Student_name']，同时我们分配了 axis=1，这意味着它将按列删除元素。
下面是下面给出的代码的截图。
How to delete multiple columns in Python pandas using a drop()
正如您在截图中看到的，我们已经讨论了如何使用 drop()在 Python pandas 中删除多个列。
你可能也喜欢阅读下面的 Python 熊猫教程。
在本文中，我们讨论了在 Python pandas 中删除列的各种方法。此外，我们还讨论了以下主题。
- 如何使用 dataframe.pop()删除 pandas 中的列
- 如何使用 del 关键字删除 pandas 中的列
- 如何使用 drop()在 Python pandas 中删除列
- 如何使用 drop()删除 Python pandas 中的多个列
Arvind 目前是 TSInfo Technologies 的高级 Python 开发人员。他精通 Python 库，如 NumPy 和 Tensorflow。
如何在 Python 中删除字典
在这个 Python 教程中，我们将学习从 Python 字典中删除键值对的各种方法。在 Python 中，信息的键值对存储在字典中。
作为一名开发人员，在制作 Python 项目时，我得到了删除 Python 中的字典的要求。
在这里我们将看到
- 如何使用 dict.clear()在 Python 中删除字典
- 使用 pop()删除 Python 中的字典
- 如何使用 del 关键字在 Python 中删除字典
- 使用 popitem()删除 Python 中的字典
- 如何使用字典理解在 Python 中删除字典
目录
- 在 Python 中删除字典
- 如何使用 dict.clear() 在 Python 中删除字典
- 使用 pop() 删除 Python 中的字典
- 如何用 del 关键字删除 Python 中的字典
- 使用 popitem() 删除 Python 中的字典
- 如何使用字典理解删除 Python 中的字典
在 Python 中删除字典
从 Python 字典中删除键值对有不同的方法，比如 dict.clear()、del 关键字、pop()和 popitem() 函数。
如何使用 dict.clear() 在 Python 中删除字典
- 在本节中，我们将讨论如何使用
dict.clear()方法在 Python 中删除字典。 - Python 字典的
clear()函数用于删除每一项。当字典包含大量元素时，一次删除一个元素会花费很多时间。相反，使用 clear()方法一次性删除字典的所有元素。 - 要在 Python 中删除字典，我们将使用
dict.clear()方法，这是 Python 中的一个内置函数，它将删除所有的键值对元素。
语法:
让我们看看语法，了解一下 dict.clear() 的工作原理。
Dictionary_name.clear()
注:对于这个“clear()”方法，不需要其他参数。我们可以很容易地用 clear 方法给我们想要删除数据的字典命名。
举例:
这里我们将举一个例子，检查如何使用 dict.clear() 在 Python 中删除字典。
源代码:
country_dict = {"U.S.A":52,"Estonia":47,"Kenya":82}
print("Items of the dict before using the clear method :",country_dict)
# Using the clear() method
new_output=country_dict.clear()
# Display the empty dictionary
print("Items of the dict after using the clear method:", new_output)
在下面给出的代码中，我们首先创建了一个名为 country_dict 的字典，并以键值对的形式分配元素。接下来，我们使用 clear() 方法从给定的字典中删除所有元素。
下面是以下给定代码的实现。
How to delete a dictionary in Python using dict.clear()
这就是如何使用 dict.clear()在 Python 中删除字典。
阅读: Python 字典 pop
使用 pop() 删除 Python 中的字典
- 现在让我们讨论如何使用
pop()方法删除 Python 中的键值对元素。 - 使用 Python 中的
pop()函数删除字典元素。它删除连接到给定键的元素。 - 如果字典包含提供的键，它将删除它并返回它的值。如果给定的键不可用，它将抛出一个 KeyError 异常。
语法:
下面是 Python 中 dictionary.pop() 方法的语法
dict.pop(key, default)
- 它由几个参数组成
- Key: 该参数定义了我们想要删除的 Key。
- Default: 这是一个可选参数，如果字典中没有这个键，它将返回这个值。
举例:
让我们举一个例子，看看如何使用 pop()方法在 Python 中删除键值对元素。
源代码:
country_dict = {"U.S.A":52,"China":67}
print("Items of the dict before using the clear method :",country_dict)
# Using the pop() method
new_output=country_dict.pop("U.S.A")
new_output=country_dict.pop("China")
# Display the empty dictionary
print("Items of the dict after using the pop method:", country_dict)
在上面的代码中，我们首先创建了 dictionary 并分配了 country_name 。之后，我们使用了 pop() 函数，在这个函数中，我们指定了想要从字典中删除的关键元素。
下面是以下给定代码的执行过程
Delete a Dictionary in Python using pop
在这个例子中，我们已经理解了如何使用 pop()方法在 Python 中删除字典。
阅读: Python 字典索引
如何用 del 关键字删除 Python 中的字典
- 在这个例子中，我们将学习如何使用 del 关键字在 Python 中删除字典。
del关键字在 Python 中常用来删除对象。因为 Python 中的一切都是一种对象类型，所以本例中的对象将是一个字典。- 在 Python 中，从输入字典值中删除键值对的另一种方法是使用
del关键字。
语法:
让我们看一下语法，理解 Python 中 del 关键字的工作原理。
del dict[object]
注意:在这个例子中，对象是一个字典，我们必须从中删除元素。
举例:
在这里我们将看到如何使用关键字在 Python 中删除字典
Cars_in_USA = {"BMW":67, "Tesla":67, "lamborghini":67}
for i in list(Cars_in_USA ):
if Cars_in_USA [i] == 67:
del Cars_in_USA [i]
print(Cars_in_USA )
在给定的示例中，我们创建了名为“Cars _ in _ USA”的字典，并迭代循环的值。接下来，我们设置字典是否包含 67 值的条件。如果可用，则该元素将被移除。
你可以参考下面的截图。
How to delete a dictionary in Python using del keyword
正如你在截图中看到的，我们已经讨论了如何使用 del 关键字在 Python 中删除字典。
阅读: Python 字典扩展
使用 popitem() 删除 Python 中的字典
- 在这一节中，我们将讨论如何使用
popitem()方法在 Python 中删除字典。 - Python 中的
popitem()函数删除一个 dictionary 元素。它删除任何元素，并返回最后一个元素。如果字典为空，它会产生一个 KeyError。 popitem()函数不接受任何参数，并返回从字典中删除的键值对。
语法:
下面是 Python 中 dictionary.popitem() 方法的语法。
dict.popitem()
示例:
让我们举个例子，看看如何使用 popitem() 方法在 Python 中删除一个字典。
源代码:
bikes_in_USA = {'Harley Davidson':62, 'Confederate':34, 'Motus MSTR':23}
# using the popitem() method
bikes_in_USA.popitem()
bikes_in_USA.popitem()
bikes_in_USA.popitem()
# Display the Content
print(bikes_in_USA)
在下面给出的代码中，我们首先创建了一个字典，然后使用 popitem() 方法从输入字典中删除元素。
下面是下面给出的代码的截图。
Delete a Dictionary in Python using popitem()
这是如何使用 Python 中的 popitem()删除 Python 中的字典。
阅读: Python 字典计数
如何使用字典理解删除 Python 中的字典
- 在这里，我们将看到如何在 Python 中使用 dict comprehension 方法删除字典。
- Python 中的
items()函数只是返回一个对象，其中包含特定字典中所有键值对的列表，并且不需要任何参数。 - 通过接受来自某个 iterable 的键值对，Python Dict Comprehension 可以用来生成字典。
语法:
让我们来看看句法，了解一下 dict 理解法的工作原理。
{key: value for key, value in iterable}
举例:
我们举个例子，用 dict comprehension 方法检查一下如何在 Python 中删除一个字典。
源代码:
country_dict = {"U.S.A":76,"Estonia":76,"Kenya":76}
print("Items of the dictionary before using the deletion operation :",country_dict )
new_output = {k:new_val for k, new_val in country_dict.items() if new_val != 76}
print("Items of the dictionary after using the deletion operation :",new_output )
在上面的代码中，我们首先创建了字典，并为它分配了国家名称元素。接下来，我们应用了字典理解方法，其中我们设置了条件 if new_val！= 76.如果值与给定的字典匹配，那么元素将被删除。
下面是以下给定代码的实现。
How to delete a dictionary in Python using dict comprehension method
您可能也喜欢阅读以下 Python 教程。
在本文中，我们讨论了从 Python 字典中删除键值对的几种不同方法。下面这个话题我们已经讲过了。
- 如何使用 dict.clear()在 Python 中删除字典
- 使用 pop()删除 Python 中的字典
- 如何使用 del 关键字在 Python 中删除字典
- 使用 popitem()删除 Python 中的字典
- 如何使用字典理解在 Python 中删除字典
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
如何在 Django 中删除会话属性
原文：https://pythonguides.com/delete-session-property-in-django/
在这个 Python Django 教程中，我会用简单的步骤解释如何删除 Django 中的 session 属性。
最近，我一直在使用 Django web 框架创建一个公司管理系统。我有一个在员工登录和注销时创建会话的要求，它需要自动删除 Django 中的会话属性。
因此，我已经做了研究，并为公司管理系统创建了一个登录和注销页面，该页面将具有会话删除属性的功能。
在这里，我们将看到:
- 什么是会话
- 如何在 Django 中创建会话
- 如何在 Django 中删除会话属性
- 如何在 Django 中创建登录和注销系统
- 如何使用 Django 管理界面注册员工
在本文的最后，您还可以下载在 Python Django 中删除会话的代码。
目录
如何逐步删除 Django 中的会话属性
姜戈会议
当我们与 web 应用程序交互时，会话是一种在服务器端存储数据的技术。基本上，会话是浏览器和服务器之间的双向、半永久的交互。
在 Django 中，会话数据保存在数据库中，它可以是基于缓存或基于文件的会话。
启用会话
在 Django，当我们创建网站的蓝图时，会话被自动启用。
Django 会话配置是在位于 settings.py 文件中的 INSTALLED_APPS 和中间件部分中设置的，如下所示。
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
**'django.contrib.sessions',**
'django.contrib.messages',
'django.contrib.staticfiles',
]
在 Django 中， settings.py 文件中的 INSTALLED_APPS 包含了 django.contrib.sessions 应用，用于在数据库中存储会话。
MIDDLEWARE = [
'django.middleware.security.SecurityMiddleware',
**'django.contrib.sessions.middleware.SessionMiddleware',**
'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
]
在 Django 中，用于生成唯一的会话 id 的中间件。SessionMiddleware 负责。
注意: 当我们迁移应用程序时，数据库中会自动创建
django_session表。
删除 Django 中的会话属性
现在，我们将看到一个使用登录和注销系统在 Django 中删除会话属性的例子。
在 Python Django 中设置项目
要启动 Django 项目，请打开终端并输入以下命令。这里， SessionPropertyProject 是 Django 项目的名称。
django-admin startproject SessionPropertyProject
它将创建一个名为 SessionPropertyProject 的文件夹，并在终端中输入下面的命令。
cd SessionPropertyProject
通过在终端中键入下面的命令，在这个项目文件夹中创建一个名为 MyApp 的 Django 应用程序。
python manage.py startapp MyApp
Set Up Project in Django
将应用名称添加到位于 settings.py 文件中的 INSTALLED_APP 列表中，以激活该应用。
settings.py
Django 在项目目录中包含了一个 urls.py 文件，默认情况下，它将新构建的应用程序映射到其中。为此，在其中添加以下代码。
from django.contrib import admin
from django.urls import path,include
urlpatterns = [
path('admin/', admin.site.urls),
path('',include('MyApp.urls')),
]
在 Django 中创建模型
要在 Django 中创建模型，打开 app 目录中的 models.py 文件，并添加下面给出的代码。
from django.db import models
# Create your models here.
class EmployeeLogin(models.Model):
username=models.CharField(max_length=10)
password=models.CharField(max_length=8)
def __str__(self):
return self.username
- 这里，我们创建了一个模型类
EmployeeLogin，它有以下字段。 - 用户名和密码是 Django 字符域。这些字符字段分别有 10 个和 8 个字符的限制。
- 要更改 Django 模型中对象的显示名称，使用
def __str__(self)。当我们返回self.username时，它会将项目名称显示为用户名。
在管理界面注册模型
要在管理应用程序中查看模型，请在管理站点上注册它。打开 admin.py 文件，将以下代码添加到该文件中。
from django.contrib import admin
from .models import EmployeeLogin
# Register your models here.
class EmployeeLoginAdmin(admin.ModelAdmin):
list_display = ('username', 'password')
# Model registered with custom admin
admin.site.register(EmployeeLogin,EmployeeLoginAdmin)
- 这里，我们创建名为
EmployeeLoginAdmin的管理类，它使用list_display元组显示用户名和密码字段。 - 然后，我们使用
admin.site.register函数向EmployeeLogin注册EmployeeLoginAdmin类。
使用模型表单在 Python Django 中创建 Web 表单
要创建一个表单，将下面的代码添加到我们在 app 目录中创建的 forms.py 文件中。
from django import forms
from .models import EmployeeLogin
class EmployeeLoginForm(forms.ModelForm):
password = forms.CharField(widget=forms.PasswordInput)
class Meta:
fields='__all__'
model = EmployeeLogin
- 这里，我们使用表单创建一个表单。名为
EmployeeLoginForm的模型表单类。它拥有EmployeeLogin模型的所有字段。 - 此外，我们定义了小部件属性 PasswordInput，该属性将密码字段设置为密码输入。
Django 中的登录和注销系统模板
在主项目目录中创建一个名为 Templates 的子目录来存储所有的项目模板，因为 Django 应用程序的前端是在 Templates 中指定的。
打开 settings.py 文件，更新 DIRS 指向 Templates 文件夹的位置。
Set path of Django Template
创建一个login.html文件，在模板文件夹中添加用于记录员工的 HTML 代码。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Login</title>
<style>
table {
border: 8px outset;
border-radius: 10px;
border-spacing: 10px;
padding: 20px;
margin-left: auto;
margin-right: auto;
}
</style>
</head>
<body>
<h1 align="center">Employee Login</h1>
<hr>
<h3 align="center">Please complete the form below to login.</h3>
<hr>
<br>
{% if messages %}
{% for message in messages %}
<div class="alert alert-primary" role="alert">
<p{% if message.tags %} class="" {% endif %}>{{ message }}</p>
</div>
{% endfor %}
{% endif %}
<form method="post">
{% csrf_token %}
<table>
{{form.as_table}}
</table>
<br><br>
<div style="text-align:center">
<button type="submit">Login</button>
</div>
</form>
</body>
</html>
- 首先，我们在头标签中设置表的样式。
- 然后使用 HTML 标签
h1和h3将表单的标题添加到 body 标签中。 - 要断开线条并画一条水平线，分别使用
br和hr标签。 - 为了打印错误和成功消息，我们在 if 和 for 语句中使用了 {{message}} 标记。
- 然后，一旦通过
POST方法提交后，表单标签将用于发布用户名和密码。 - 接下来，表单元素中的
csrf_token用于保护表单免受网络攻击，并使我们能够安全地传输数据。 - 然后，我们使用
form.as_table标签将表单呈现为table标签中的一个表格。 - 最后，添加一个提交按钮来登录员工。
创建一个home.html文件，在模板文件夹中添加 HTML 代码，用于向员工显示仪表板和注销按钮。
<!doctype html>
<html lang="en">
<head>
<!-- Required meta tags -->
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
<!-- Bootstrap CSS -->
<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@4.0.0/dist/css/bootstrap.min.css"
integrity="sha384-Gn5384xqQ1aoWXA+058RXPxPg6fy4IWvTNh0E263XmFcJlSAwiGgFAW/dAiS6JXm" crossorigin="anonymous">
<title>PythonGuides</title>
</head>
<body>
<nav class="navbar navbar-expand-lg navbar-light bg-light">
<a class="navbar-brand" href="#">PythonGuides</a>
<button class="navbar-toggler" type="button" data-toggle="collapse" data-target="#navbarSupportedContent"
aria-controls="navbarSupportedContent" aria-expanded="false" aria-label="Toggle navigation">
<span class="navbar-toggler-icon"></span>
</button>
<div class="collapse navbar-collapse" id="navbarSupportedContent">
<ul class="navbar-nav mr-auto">
<li class="nav-item dropdown">
<a class="nav-link dropdown-toggle" href="#" id="navbarDropdown" role="button"
data-toggle="dropdown" aria-haspopup="true" aria-expanded="false">
Blogs
</a>
<div class="dropdown-menu" aria-labelledby="navbarDropdown">
<a class="dropdown-item" href="https://pythonguides.com/django/">Django</a>
<a class="dropdown-item" href="https://pythonguides.com/matplotlib/">Matplotlib</a>
<a class="dropdown-item" href="https://pythonguides.com/turtle/">Turtle</a>
<a class="dropdown-item" href="https://pythonguides.com/tkinter/">Tkinter</a>
</div>
</li>
</ul>
<a class="btn btn-primary" href="/logout/" role="button">Log Out</a>
</div>
</nav>
{% if messages %}
{% for message in messages %}
<div class="alert alert-primary" role="alert">
<p{% if message.tags %} class="" {% endif %}>{{ message }}</p>
</div>
{% endfor %}
{% endif %}
<div class="container my-3">
<h1 style="text-align:center;">Welcome to Python Guides</h1>
</div>
<div class="card">
<div class="card-body">
<h3 style="text-align:center;">Thanks for landing on this page to know more about PythonGuides.com.</h3>
<br>
<h6>I welcome you to the website and hopefully, you got to learn something in Python. I started this website
to share my finding and learnings in Python with you.</h6>
<h6>To keep things simple, I am trying to write a lot of articles on Python. Feel free to give your valuable
comments and also share the articles if you are liking and hoping it will be helpful to someone.</h6>
<br>
<h2 style="text-align:center;">Also, Subscribe to Our YouTube Channel for FREE Python Video Tutorials.</h2>
</div>
</div>
<!-- Optional JavaScript -->
<!-- jQuery first, then Popper.js, then Bootstrap JS -->
<script src="https://code.jquery.com/jquery-3.2.1.slim.min.js"
integrity="sha384-KJ3o2DKtIkvYIK3UENzmM7KCkRr/rE9/Qpg6aAZGJwFDMVNA/GpGFF93hXpG5KkN"
crossorigin="anonymous"></script>
<script src="https://cdn.jsdelivr.net/npm/popper.js@1.12.9/dist/umd/popper.min.js"
integrity="sha384-ApNbgh9B+Y1QKtv3Rn7W3mgPxhU9K/ScQsAP7hUibX39j7fakFPskvXusvfa0b4Q"
crossorigin="anonymous"></script>
<script src="https://cdn.jsdelivr.net/npm/bootstrap@4.0.0/dist/js/bootstrap.min.js"
integrity="sha384-JZR6Spejh4U02d8jOt6vLEHfe/JQGiRRSQQxSfFWpi1MquVdAyjUar5+76PVCmYl"
crossorigin="anonymous"></script>
</body>
</html>
- 要加载我们的 CSS，将 Bootstrap 和 jQuery CDN 放在任何其他样式表之前的
head标签中。 - 在主体标签中，包含带有类别导航条和导航条-扩展-lg 的导航标签。
- 添加一个带有类
collapse navbar-collapse的div标签，并添加另一个带有类drop-menu的div，以添加一个用于添加博客类别的下拉菜单栏。 - 然后，我们添加一个带有类卡的
div标签来添加我们想要在网站页面上显示的内容。 - 为了打印错误和成功消息，我们在 if 和 for 语句中使用了 {{message}} 标记。
- 最后，添加一个带有注销链接的按钮，将注销给员工。
会话属性删除视图
要定义删除会话属性的主要逻辑，打开 views.py 文件并添加下面给出的代码。
from django.shortcuts import render,redirect
from .forms import EmployeeLoginForm
from .models import EmployeeLogin
from django.contrib import messages
# Create your views here.
# Create Session
def employee_login(request):
message=''
if request.method=='POST':
username=request.POST['username']
password=request.POST['password']
data=EmployeeLogin.objects.filter(username=username,password=password).count()
if data > 0:
request.session['user']=username
messages.info(request,'Session Created')
return redirect('/dashboard')
else:
messages.info(request,'Invalid Credentials')
print('Not created')
form=EmployeeLoginForm()
return render(request,'login.html',{'form':form,'message':message})
# Dashboard
def home(request):
return render(request,'home.html')
# Delete Session Property
def employee_logout(request):
del request.session['user']
messages.info(request,'Session Deleted')
return redirect('employee_login')
- 从
forms.py中导入EmployeeLoginForm，从models.py中导入EmployeeLogin，创建一个名为employee_login的视图。 - 然后，调用
if语句，检查是否- 如果是，使用请求。POST 获取用户名和密码。
- 之后，我们使用带有模型对象的过滤器方法，将雇员输入的用户名和密码与注册的用户名和密码进行匹配。
创建 Django 会话
- 在视图中使用
request.session来设置或创建 Django 会话变量。基本上，它的作用就像一个字典，即它可以将会话名定义为键，将它们的值定义为值。 - 这里，我们使用请求对象作为一个 request.session['user'] 会话变量，并将其值设置为一个用户名。
- 然后，我们使用
message.info打印会话创建成功的消息。 - 如果请求方法是
GET，则使用render()函数向用户呈现一个空白的登录页面。
渲染到仪表板
- 然后，我们创建一个名为
home的基于函数的视图，以呈现给【home.html】模板。
删除 Django 会话属性
- 创建一个名为
employee_logout的视图来删除会话属性。要删除会话，使用带有request.session对象的del。 - 然后，我们使用
message.info打印会话删除成功的消息。 - 最后，我们使用重定向函数将用户重定向到
employee_login视图。
现在，我们必须用 URL 映射视图以便调用它，因此我们必须在 app 目录中创建一个名为 urls.py 的文件。包括下面的代码。
from django.urls import path
from . import views
urlpatterns = [
path('', views.employee_login, name='employee_login'),
path('dashboard/', views.home, name='home'),
path('logout/', views.employee_logout, name='employee_logout'),
]
执行 Django 模型
为了处理管理界面，我们首先必须使用下面的命令创建超级用户。
python manage.py createsuperuser
要创建包含模型表格模式代码的迁移文件，请在终端中键入以下命令。
python manage.py makemigrations
要根据迁移文件的模式构建表，请执行以下命令。
python manage.py migrate
通过管理员登记员工
现在，要成功登录到员工，我们必须先注册，为此，我们将使用管理界面。请遵循以下步骤:
首先，通过在终端中键入下面给出的命令来启动开发服务器。
python manage.py runserver
通过如下所示展开 URL，我们可以访问管理面板。
127.1.1.0/admin
它成功地打开了 Django admin，现在点击员工登录前面的 Add 选项，通过设置用户名和密码创建新员工。接下来，单击保存。
Register employees using the admin interface
另外，查看:如何将 Google reCAPTCHA 添加到 Django 表单
执行应用程序删除 Django 中的会话属性
它成功地打开了登录页面，如下所示。填写员工的注册用户名和密码，然后点击登录。
Login username and password
它将被成功地重定向到仪表板，并在顶部显示 Django 会话创建成功的消息。
Company Management Dashboard
现在，为了删除 Django session 属性，我们必须点击左上方的 Log Out 按钮。
Log Out Button
它将成功地重定向到登录页面，并向我们显示 Django 会话属性被删除的消息。
Delete Session Property in Django
这就是我们删除 Django 会话属性的方法。
下载 Django 完整代码中的删除会话属性
这是代码。
Delete Session Property in Django
结论
至此，我们已经成功地理解了如何在 Django 中删除会话属性。我们还学习了会话以及如何在 Django 中创建会话。
此外，我们还讨论了以下主题。
- 什么是会话
- 如何在 Django 中创建会话
- 如何在 Django 中删除会话属性
- 如何在 Django 中创建登录和注销系统
- 如何使用 Django 管理界面注册员工
您可能也喜欢阅读下面的 Python Django 教程。
- Python Django 长度过滤器
- 如何从 Django 的 get 请求中获取数据
- Python 过滤器不在 Django 中
- 模型 Django 上的联合操作
拥有丰富 Django 和 Matplotlib 经验的 Python 开发人员，目前在 TSInfo Technologies 工作。我正在成为专业程序员、博客写手和 YouTuber 的路上。
如何用 Python 显示日历
在本 Python 教程中，我们将讨论如何在 Python 中显示日历。除此之外，我们还将检查:
- 如何用 python 打印全年日历
- 如何在 Python 中获取当前年份
- python 示例中的日历
- Python calendar.weekday()方法
- Python 获取给定日期的星期几
- 从 python 中的一个数字中找出月份的名称
- Python 获取一个月中周的列表作为日期
目录
- 用 Python 显示日历
- 用 python 打印全年日历
- Python 获取当前年份
- python 中的日历示例
- Python calendar.weekday()方法
- Python 获取给定日期的星期几
- 从 python 中的一个数字中找出月份的名称
- Python 获取一个月中周的列表作为日期
- Python 遍历一个月中的每一天
用 Python 显示日历
现在，让我们看看如何用 python 显示日历。
- 我们需要导入日历模块来显示 python 中的日历。
- 模块内部的内置函数
month()取年和月。 - 然后它会显示一年中该月的日历。
举例:
import calendar
year = 2018
month = 12
print(calendar.month(year, month))
可以看到输出，一旦你打印 "calendar.month(year，month)" 就会出现输出。这里，当我们运行代码时，将显示给定的年和月日历。
可以参考下面的截图程序用 Python 显示一个日历。
Program to display a calendar in Python
你可能会喜欢 Python Tkinter 秒表
用 python 打印全年日历
让我们看看如何用 python 打印全年日历。
- 首先，我们需要导入T2 日历模块
- 然后初始化年份
- 模块内部的内置函数
calendar()取年份 - 要打印特定年份的日历，请使用
calendar.calendar(year)
举例:
import calendar
year = 2019
print(calendar.calendar(year))
可以看到输出，一旦你打印" calendar . calendar(year)"就会出现输出。在这里，我们导入了日历模块，打印后输出中显示了 2019 年的全年日历。
可以参考下面截图用 python 打印全年日历。
Print whole year calendar in python
输出:
这是上面提到的代码的输出，您可以看到显示的是 2019 年的日历。
Print whole year calendar in python
Python 获取当前年份
现在，让我们看看下面这个关于 python 获取当前年份的例子。
为了在 python 中获得当前年份，我们将首先导入日期时间。然后我们将使用 datetime.datetime.now()。年份获取当前年份。
举例:
import datetime
current_y = datetime.datetime.now().year
print(current_y)
可以看到输出，一旦你打印出 "current_y" ，那么输出将显示为当前年份的 "2020" 。这里，我们导入了 datetime 模块，打印后，它将在输出中返回当前年份。
可以参考下面 python 获取当年的截图。
Python get the current year
python 中的日历示例
- 首先，我们将导入日历模块
- 这里，s =日历。TextCalendar(日历。星期五)创建一个文本日历。
- c_str = s.formatmonth(2022，1) 正在创建 2022 年的日历，1 月-1 月。
c_str将打印输出。
举例:
import calendar
s = calendar.TextCalendar(calendar.FRIDAY)
c_str = s.formatmonth(2022,1)
print(c_str)
可以看到输出，一旦你打印 "c_str" 输出就会出现。这里我们导入了日历模块，打印后会返回 2022 年 1 月的日历。
你可以参考下面 python 例子中日历的截图
Calendar in python example
Python calendar.weekday()方法
weekday() 方法用于返回星期几。因此， 0 是星期一，而 6 是星期日，这是一周的最后一天。
举例:
import calendar
print(calendar.weekday(2020, 12, 20)
可以看到输出，一旦你打印出 "calendar.weekday()" ，那么输出将显示为 "6" ，也就是周日。这里，我们已经导入了日历模块，在打印之后，它将返回值“6”，即星期天。
可以查看下面 python calendar.weekday()方法的截图。
Python calendar.weekday() method
Python 获取给定日期的星期几
我们将首先导入日历模块，然后使用 weekday() 函数获取给定日期的星期几。
举例:
import calendar
d = calendar.weekday(2020, 12, 22)
print(calendar.day_name[d])
可以看到输出，一旦你打印了 "calendar.day_name[d]" ，那么输出将显示为"星期二"。这里，我们导入了日历模块，打印后，它将返回星期几。
你可以参考下面的截图来获取给定日期的星期几。
Python get the day of the week for a given date
从 python 中的一个数字中找出月份的名称
为了从一个数字中获取月份名称，我们将使用 "calendar.month_name[]" 它将返回完整的月份名称。
举例:
import calendar
print(calendar.month_name[12])
可以看到输出，一旦你打印出" calendar . month _ name[12]"，那么输出将显示为"十二月"。这里，我们导入了日历模块，打印后，它将从一个数字返回月份的名称
你可以参考下面的截图，用 python 从一个数字中找出月份的名称。
Find the name of the month from a number in python
Python 获取一个月中周的列表作为日期
函数 monthdayscalendar() 打印特定月份的周列表，它采用两个参数年和月并返回该日期的周列表。
举例:
import calendar
c = calendar.Calendar()
for week in c.monthdayscalendar(2020, 12):
print(week)
输出可以看到，一旦你将打印“周”然后输出将出现。这里，我们已经导入了日历模块，for 循环用于迭代，它将返回特定月份的周列表
你可以看到下面的 python 获取一个月中的周列表的截图。
Python get a list of weeks in the month as date
Python 遍历一个月中的每一天
为了遍历一个月的日子，我们将使用函数“itermonthdays()”，它将遍历给定月份和年份的日子。
举例:
import calendar
c = calendar.Calendar()
for day in c.itermonthdays(2021, 1):
print(day)
输出可以看到，一旦你将打印“日”。在这里，我们导入了日历模块，使用 for 循环进行迭代，它将返回所述月份的日期，即一月。
在下面的截图中，我们可以看到代码和输出。
Python iterate through days of a month
输出:
Python iterate through days of a month
您可能会喜欢以下 Python 教程:
- 如何用 Python 制作计算器
- Python 布尔函数
- Python 中的正则表达式
- Python 打印 2 位小数
- Python 计数器——详细教程
- Python 格式数字加逗号
- Python 生成随机数和字符串
- Python 将列表写入文件，并附有示例
- Python 中的链表
- 如何用 Python 制作矩阵
在本 Python 教程中，我们学习了:
- 如何用 Python 显示日历
- 如何用 python 打印全年日历
- 如何在 Python 中获取当前年份
- python 示例中的日历
- Python calendar.weekday()方法
- Python 获取给定日期的星期几
- 从 python 中的一个数字中找出月份的名称
- Python 获取一个月中周的列表作为日期
- Python 遍历一个月中的每一天
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Python 中如何将两个数相除
在这个 python 教程中，你将学习如何在 python 中除以两个数，我们还将检查 :
- Python 程序将两个数相除
- Python 程序对用户输入的数字进行除法运算
- 使用函数分割数字的 Python 程序
- Python 程序使用递归分割数字
- 使用类划分数字的 Python 程序
- Python 程序除复数
- 使用函数将两个浮点数相除程序
- 在 python 中如何用一个数除一个变量
目录
- Python 程序将两个数相除
- Python 程序对用户输入的数字进行除法
- Python 程序使用函数对数字进行除法运算
- Python 程序使用递归分割数字
- Python 程序使用类来划分数字
- Python 程序对复数进行除法运算
- 使用函数将两个浮点数相除的程序
- Python 中如何用一个数除一个变量
Python 程序将两个数相除
这里可以看到如何用 python 写程序将两个数相除。
- 在这个例子中，我取了两个数字作为数字 1 = 64 ，数字 2 = 8 。
- 使用运算符“/”来划分数字。
- 我已经用
print(result)得到了输出。
示例:
number1 = 64
number2 = 8
result = number1/number2
print(result)
下面的截图显示了输出。
Python program to divide two numbers
这个代码，我们可以用 Python 中的如何除两个数。
Python 程序对用户输入的数字进行除法
现在，我们可以看到如何用 python 编写程序来划分用户输入的数字。
- 在这个例子中，我使用了
input()方法。接受用户的输入。 - 结果=数字 1/数字 2 用于将两个数相除。
- 我已经用
print(result)得到了输出。
示例:
number1=int(input("Enter the first number: "))
number2=int(input("Enter the second number: "))
result=number1/number2;
print(result)
您可以参考下面的输出截图。
Python program to divide numbers user input
这是用 Python 中的用户输入对数字进行除法的代码。
Python 程序使用函数对数字进行除法运算
在这里，我们可以看到如何用 python 中的函数编写程序来除数。
- 在这个例子中，我将一个名为 div 的函数定义为 def div(a，b) 。
- 该函数返回为
return a/b. - 要被除的值作为函数中的参数传递。
示例:
def div(a,b):
return a/b
print(div(27,9))
我们可以将 27 和 9 的除法运算结果定为 3。您可以参考下面的输出截图。
Python program to divide numbers using functions
这就是如何使用 Python 中的函数除数。
Python 程序使用递归分割数字
现在，我们可以看到如何使用 python 中的递归编写程序来除数。
- 在这个例子中，我使用了
input()方法。接受用户的输入。 - 我定义了一个函数为 def Div(number1，number2) 。
- 使用 if 条件，如果条件为真，则返回为
return 0。如果条件不为真，则返回 return 1 + Div(数字 1-数字 2，数字 2) 。 - 为了得到输出，我使用了 print("result "，Div(number1，number2)) 。
示例:
print("Enter the two Number:")
number1=int(input())
number2=int(input())
def Div(number1,number2):
if number1<number2:
return 0
return 1 + Div(number1-number2, number2)
print("result ",Div(number1,number2))
我们可以看到两个数相除的结果。您可以参考下面的输出截图。
Python program to divide numbers using recursion
这是如何在 Python 中使用递归除数。
Python 程序使用类来划分数字
- 在这个例子中，我使用了
input()方法。接受用户的输入。 - 我已经创建了一个类,使用一个构造函数来初始化这个类的值
- 我已经创建了一个方法来划分这些数字。
- 对象是为类创建的，用于传递参数。
self是用于将属性和方法传递给类的关键字。- 为了得到输出，我使用了 print("Result:"，obj.num()) 。
示例:
a=int(input("Enter first number: "))
b=int(input("Enter second number: "))
class div():
def __init__(self,a,b):
self.a=a
self.b=b
def num(self):
return self.a/self.b
obj=div(a,b)
print("Result: ",obj.num())
下面的截图显示了 24 和 6 的除法是 4 作为输出。
Python program to divide numbers using class
这是使用类划分数字的 Python 程序。
Python 程序对复数进行除法运算
在这里，我们可以看到如何用 Python 写程序来除复数。
- 在这个例子中，我取了两个复数为 a =复数(16，36) 和 b =复数(4，6) 。
- 我已经定义了一个函数为 def 子复数(a，b) 。
- 定义的函数返回为
return a / b。 - 为了得到输出，我使用了 print( "Result is:"，subComplex(a，b)) 。
示例:
a = complex(16, 36)
b = complex(4, 6)
def subComplex( a, b):
return a / b
print( "Result is : ", subComplex(a, b))
我们可以把复数的除法看作输出。您可以参考下面的输出截图。
Python program to divide complex numbers
这是Python 中的复数如何除法。
使用函数将两个浮点数相除的程序
在这里，我们可以看到如何使用 python 中的函数编写一个程序来除两个浮点数。
- 在这个例子中，我使用了
input()方法。接受用户的输入。 - 我已经定义了一个函数为 def division(a，b) 。
- 函数返回为
div=a/b。 - 我已经用 print("Result is:"，division(number1，number2)) 得到输出。
示例:
number1=float(input("Enter first number: "))
number2=float(input("Enter second number: "))
def division(a,b):
div=a/b
return div
print("Result is: ",division(number1,number2))
我们可以将两个数相除作为输出。您可以参考下面的输出截图。
Program to divide two float number using a function
这是如何使用 Python 中的函数将两个浮点数相除。
Python 中如何用一个数除一个变量
在这里，我们可以看到如何用 python 将一个变量除以一个数。
- 在这个例子中，我取了一个变量为
variable1 = 100。 - 为了将变量除以数字，我使用了变量=变量 1 / 10 。这里 10 是我用来除一个变量的数。
- 我已经用
print(variable)得到了输出。
示例:
variable1 = 100
variable = variable1 / 10
print(variable)
您可以参考下面的输出截图。
how to divide a variable by a number in python
上面的代码，我们可以用 Python 中的一个变量除以一个数。
您可能会喜欢以下 Python 教程:
- 如何在 Python Tkinter 中设置背景为图像
- 如何在 Python 中添加两个变量
- 如何用 Python 将两个数相加
- Python 程序反转字符串的例子
- Python 程序求 n 个数之和并举例
在本 Python 教程中，我们已经学习了用于将两个数相除的 Python 程序。此外，我们还讨论了以下主题:
- Python 程序将两个数相除
- Python 程序对用户输入的数字进行除法运算
- 使用函数分割数字的 Python 程序
- Python 程序使用递归分割数字
- 使用类划分数字的 Python 程序
- Python 程序除复数
- 使用函数将两个浮点数相除程序
- 在 python 中如何用一个数除一个变量
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Python Django 应用程序上传文件
在本 Python Django 教程中，我们将学习 Python Django app 上传文件。我们还会看到与此相关的例子。这些是我们将在本教程中讨论的以下主题。
- Python Django 应用程序上传文件
- Python Django 模型字段
- Python Django 文件上传
- Python Django 图像上传
- Python Django 在前端查看上传的文件
目录
- Python Django app 上传文件
- Python Django 模型字段
- Python Django 文件上传
- Python Django 图片上传
- Python Django 查看前端上传的文件
Python Django app 上传文件
上传意味着将文件从本地计算机发送到远程系统，远程系统存储被传输材料的副本。可以上传图像、视频、电影、音乐、声音、免费软件、共享软件和文本文件。
Python Django 模型字段
要在 Django 中上传文件，Django 有不同的模型字段。并且，这些字段用于处理不同的文件类型。
Django 有 两个模型字段:
- 图像字段
- 文件字段
让我们逐一讨论每个领域，以获得一个概述:
图像字段:
ImageField 是一个模型字段，专门接受上传的图像格式。一些命令图像文件格式如下:
- GIF(。gif)
- PNG (.png)
- TIFF (.tif、. TIFF)格式
- 位图(. bmp)
- JPEG(。jpg，。jpeg)
- EPS (.eps)文件
- 原始图像文件(orf，.sr，。未加工的。cr，。nef 等)
ImageField 需要 Pillow 库。要安装相同的运行，请按照下列步骤操作。
pip install Pillow
图像字段的语法:
field_name = models.ImageField(upload_to=None, height_field=None, width_field=None, max_length=100, **args)
文件字段
文件字段是用于上传文件的模型字段。一些常见的文件格式有:
- MP4
- 挽救（saving 的简写）
- 便携文档格式
- MP3 文件
- Docx
文件字段的语法:
field_name = models.FileField(upload_to=None, max_length=254, **args)
另外，检查:Python Django 中的登录系统
Python Django 文件上传
创建项目和 App: 首先我们要创建一个项目和 App。因此，使用下面定义的代码来创建它。
**# Project**
django-admin startproject project_name
**# App**
python manage.py startapp app_name
在这里，我创建了一个名为 PythonGuides 的项目和一个名为 home 的应用程序。
安装 App: 后，成功创建项目和 App。你必须安装一个应用程序。为此，您必须将我们的应用程序添加到设置. py 文件中。
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'home',
]
保存上传的文件，修改设置 :现在在 settings.py 文件的末尾添加以下几行。
import os
MEDIA_URL = '/media/'
MEDIA_ROOT = os.path.join(BASE_DIR, 'media')
- 媒体 URL: 此处指定 URL 端点。这是用户可以从浏览器上传文件的 URL。
- 媒体根:定义文件保存的根路径。
- 第二行命令 Django 将所有上传的文件保存在基目录中，也就是项目目录中一个名为‘媒体’的文件夹中。
- 我们必须手动创建文件夹，以便所有上传的文件都保存在媒体文件夹中。
媒体文件夹: 在项目文件夹中新建一个名为【媒体】的文件夹。
Python Django file upload
项目网址: 你要添加一个链接到你新创建的应用。将下面的代码片段添加到 PythonGuides 的 urls.py 文件中。
from django.contrib import admin
from django.urls import path, include
urlpatterns = [
path('admin/', admin.site.urls),
path('',include('home.urls'))
]
App 网址: 你要添加功能视图的路径。将下面的代码片段添加到主页的 urls.py 文件中。
from django.urls import path,include
from . import views
urlpatterns = [
path('UploadFile', views.UploadFile, name='UploadFile'),
]
创建模型: 在 models.py 中，创建一个新的 Django 模型“博客”然后添加下面的代码。
from django.db import models
class Blog(models.Model):
author = models.CharField(max_length=100)
title = models.CharField(max_length=200)
file = models.FileField(upload_to='documents/')
- 我们创建模型
CharField，它存储上传文件的作者的名字。 - 然后，我们再创建一个
CharField，它存储用户上传的文件的标题。 - 然后，我们使用用于用户将要上传的文件的文件字段。
upload_to选项定义了文件在介质中的保存位置。
创建表单: 我们现在将【博客】模型导入到 forms.py 中，并创建【博客表单】模型表单。
from django import forms
from .models import Blog
class BlogForm(forms.ModelForm):
class Meta:
model = Blog
fields = ['author', 'title', 'file']
创建视图 :实现 views.py 文件中的表单。在这里，我们需要上传文件。因此，只需添加请求。文件和请求。岗位。
语法如下:
form = BlogForm(request.POST,request.FILES)
将以下代码片段添加到 views.py 文件中。
from django.shortcuts import render, HttpResponse
from .forms import BlogForm
def UploadFile(request):
if request.method == 'POST':
form = BlogForm(request.POST,request.FILES)
if form.is_valid():
form.save()
return HttpResponse('The file is saved')
else:
form = BlogForm()
context = {
'form':form,
}
return render(request, 'Upload.html', context)
- 这里，我们创建了
UploadFile函数。 - 然后，我们检查请求方法是否是
POST。 - 在这之后，我们简单地添加一个请求。文件连同请求。将发布到表单方法中。
- 这里我们在视图函数中使用了
is_valid()方法，因为它返回值 True 和 False。 - 然后，我们返回到
HttpResponse并渲染到 HTML 模板。
创建 HTML 模板: 现在，创建一个显示表单的模板。在upload.html文件中添加以下代码。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Upload Files</title>
</head>
<body>
<form method='post' enctype="multipart/form-data">
{% csrf_token %}
{{form.as_p}}
<input type="submit" value="Submit">
</form>
</body>
</html>
- 现在，在模板文件中创建 <表单> 属性。
- 接下来，添加
enctype = " multipart/form-data "否则，表单将无法工作。 - 我们还在表单中使用了
csrf_token标签来避免恶意攻击。 - 然后，我们使用
form.as_p标签将 Django 表单呈现为一个段落。
Django 数据库迁移: 它是将对模型所做的更改转移到数据库模式的过程。
在终端运行以下命令:
**# Make Migartions**
python manage.py makemigrations
**# Migrate**
python manage.py migrate
- makemigrations: 用于创建一个迁移文件，其中包含模型的表格模式的代码。
- migrate: 用于根据迁移文件的模式构建表格。
运行服务器: 启动服务器，通过定义 URL 为 http://127 . 0 . 0 . 1:8000/UploadFile 来访问表单。
运行服务器的命令:
python manage.py runserver
Django app upload files
Upload files using Python Django app
在这里， Marry Smith 上传 Docx 格式的Django 简介文件。
File upload using Python Django
当我们点击提交按钮时，我们移动到 HTTP 响应“文件已保存”。
查看媒体中的文件: 可以看到，该文件成功保存在媒体目录下的文件 目录中。
View file upload using Python Django
您也可以上传基于 pdf 的文件。让我们来看看。
PDF File Upload App
Django upload file app
Run file upload app
甚至可以上传 mp4 格式的文件。
MP4 file upload app using Django
Django app upload mp4 files
Python Django 图片上传
在这一节中，我们将学习如何在 Django 中上传图片。
创建项目和 App: 首先，也是最重要的，我们必须开发一个项目和一个 App。因此，要创建它，请使用下面定义的代码。
**# Project**
django-admin startproject PythonGuides
**# App**
python manage.py startapp UploadApp
在这里，我创建了一个名为 PythonGuides 的项目和一个名为 UploadApp 的应用。
安装 App: 之后，项目和 App 创建成功。现在，您必须安装一个应用程序。您必须将我们的应用程序包含在 settings.py 文件中才能执行此操作。
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'UploadApp',
]
保存上传的文件，修改设置 :现在在 settings.py 文件的末尾添加以下几行。
import os
MEDIA_URL = '/media/'
MEDIA_ROOT = os.path.join(BASE_DIR, 'media')
- 首先，导入
os。 - 然后，为了提供媒体文件，我们使用
MEDIA_URL。 - 在这之后，为了指定保存文件的根路径，我们使用
MEDIA_ROOT。
媒体文件夹: 在项目文件夹中，新建一个名为【媒体】的文件夹。
Python Django image upload
项目网址: 你必须包括一个链接到你新开发的应用程序。将以下代码片段添加到 PythonGuides 的 urls.py 文件中。
from django.contrib import admin
from django.urls import path, include
urlpatterns = [
path('admin/', admin.site.urls),
path('',include('UploadApp.urls'))
]
App 网址: 必须包含功能视图的路径。将以下代码片段添加到 UploadApp 的 urls.py 文件中。
from django.urls import path,include
from . import views
urlpatterns = [
path('UploadImage', views.UploadImage, name='UploadImage'),
]
创建模型: 在 models.py 中，创建一个新的 Django 模型“课程”然后添加下面的代码。
from django.db import models
class Course(models.Model):
author = models.CharField(max_length=100)
title = models.CharField(max_length=200)
image = models.ImageField(upload_to='images/')
- 这里，我们定义了模型
CharField，它存储了上传图片的作者的名字以及图片的标题。 - 为了上传图像，我们使用
ImageField。 upload_to选项定义图像将保存在媒体目录下的 images 目录下。
创建表单: 我们现在将【课程】模型导入到 forms.py 中，并创建【课程表单】模型表单。
from django import forms
from .models import Course
class CourseForm(forms.ModelForm):
class Meta:
model = Course
fields = ['author', 'title', 'image']
创建视图 :实现 views.py 文件中的表单。这里，我们需要上传图像，所以，只需添加请求。文件和请求。岗位。
from django.shortcuts import render, HttpResponse
from .forms import CourseForm
def UploadImage(request):
if request.method == 'POST':
form = CourseForm(request.POST,request.FILES)
if form.is_valid():
form.save()
return HttpResponse('The image saved successfully')
else:
form = CourseForm()
context = {
'form':form,
}
return render(request, 'upload.html', context)
- 这里，我们创建了
UploadImage函数，该函数检查请求方法是否为POST。 - 在这之后，我们简单地添加一个请求。文件连同请求。将发布到表单方法中。
- 然后，我们在视图函数中使用
is_valid()方法，因为它返回值 True 和 False。 - 最后，我们返回到
HttpResponse并渲染到 HTML 模板。
创建 HTML 模板: 现在，创建一个显示表单的模板。在upload.html文件中添加以下代码。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Upload Files</title>
</head>
<body>
<form method='post' enctype="multipart/form-data">
{% csrf_token %}
{{form.as_p}}
<input type="submit" value="Submit">
</form>
</body>
</html>
- 现在，在模板文件中创建 <表单> 属性。
- 接下来，添加
enctype = " multipart/form-data "否则，表单将无法工作。 - 我们还在表单中使用了
csrf_token标签来避免恶意攻击。 - 然后，我们使用
form.as_p标签将 Django 表单呈现为一个段落。
Django 数据库迁移: 在终端运行以下命令:
**# Make Migartions**
python manage.py makemigrations
**# Migrate**
python manage.py migrate
- makemigrations: 生成具有模型模式的迁移文件。
- 迁移:根据迁移文件的模式建立表格。
运行服务器: 启动服务器，通过定义 URL 为 http://127 . 0 . 0 . 1:8000/UploadImage 来访问表单。
运行服务器的命令:
python manage.py runserver
Preview Form in Browser
例# 1
在这个例子中，我们上传了一个 png 格式的图片。
App to upload image using Python Django
当我们点击提交按钮时，HTTP 响应显示。
Django upload image app
在媒体目录下的图像目录中查看上传的文件。
Django app upload png images
例 2
在这个例子中，我们上传了一个 jpeg 格式的图像。
Upload image using Python Django
在媒体目录下的图像目录中查看上传的 jpeg 文件。
View image uploaded using Python Django
例 3
在这个例子中，我们上传了一张 gif 格式的图片。
Upload image using Python Django app
Django app upload gif
Python Django 查看前端上传的文件
在本节中，我们将学习如何在浏览器上查看上传的图像。
创建项目和 App: 在终端中键入以下命令。
**# Project**
django-admin startproject MyProject
**# App**
python manage.py startapp MyApp
安装 App: 现在，你必须安装一个应用。并添加到 settings.py 文件中。
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'MyApp,
]
保存上传的文件，修改设置 :现在在 settings.py 文件的末尾添加以下几行。
import os
MEDIA_URL = '/media/'
MEDIA_ROOT = os.path.join(BASE_DIR, 'media')
媒体文件夹: 在项目文件夹中，新建一个名为【媒体】的文件夹。
Python Django Image upload view on browser
项目 URL:在 MyProject 的 urls.py 文件中添加以下代码。
from django.contrib import admin
from django.urls import path, include
from django.conf import settings
from django.conf.urls.static import static
urlpatterns = [
path('admin/', admin.site.urls),
path('',include('MyApp.urls'))
]
if settings.DEBUG:
urlpatterns += static(settings.MEDIA_URL,document_root=settings.MEDIA_ROOT)
- 在这里，我们通过添加静态(设置)来提供用户在开发期间从
MEDIA_ROOT上传的文件。MEDIA_URL，document _ root =设置。【MEDIA _ ROOT)。 - 这里，
MEDIA_URL保存为‘MEDIA’，document_root为上传文件在 MEDIA 文件夹中的位置。 - 但是，只有当
DEBUG设置为True并且设置中指定的URL为本地时，它才起作用。
App 网址: 在 MyApp 的 urls.py 文件中添加以下代码。
from django.urls import path
from . import views
urlpatterns = [
path('Upload', views.Upload, name='Upload'),
]
创建模型: 在 models.py 文件中添加以下代码。
from django.db import models
class UploadImage(models.Model):
title = models.CharField(max_length=200)
image = models.ImageField(upload_to='images/')
创建表单: 在 forms.py 文件中添加以下代码。
from django import forms
from .models import UploadImage
class UploadImageForm(forms.ModelForm):
class Meta:
model = UploadImage
fields = ['title', 'image']
创建视图: 在 views.py 文件中添加以下代码。
from django.shortcuts import render
from .forms import UploadImageForm
def Upload(request):
if request.method == 'POST':
form = UploadImageForm(request.POST,request.FILES)
if form.is_valid():
form.save()
img_object = form.instance
return render(request, 'ImageUpload.html', {'form': form, 'img_obj': img_object})
else:
form = UploadImageForm()
context = {
'form':form,
}
return render(request, 'ImageUpload.html', context)
- 我们还创建图像对象，并将它们呈现到 HTML 模板中。
创建模板 :在【upload.html】文件中添加以下代码。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Upload Files</title>
</head>
<body>
<form method='post' enctype="multipart/form-data">
{% csrf_token %}
{{form.as_p}}
<input type="submit" value="Submit">
</form>
{% if img_obj %}
<h3>Succesfully uploaded :</h3>
<img src="{{ img_obj.image.url}}" alt="connect" style="max-height:500px">
{% endif %}
</body>
</html>
- 在 HTML 模板中，我们使用 if 标签来检查一个图像对象是否在浏览器中显示。
迁移数据库: 在终端中运行以下命令。
**# Make Migartions**
python manage.py makemigrations
**# Migrate**
python manage.py migrate
运行服务器: 在终端中运行以下命令。
python manage.py runserver
Form View
view uploaded files at frontend using Python Django
当我们点击提交按钮时。输出如下所示。
Django view uploaded files at frontend example
从这里，我们得出结论，我们可以从浏览器前端查看上传的文件。
另外，看看更多的 Python Django 教程。
- 在 Django 中运行 Python 脚本
- Python Django 随机数
- Python Django 连接字符串
- Python Django 设置时区
- Python 改 Django 版本
- Django 模板中的 If 语句
- Python Django 表单验证
- Python Django MySQL CRUD
- Django 联系表，带有基于类的视图
在这个 Python Django 教程中，我们讨论了 Python Django 应用程序上传文件。此外，讨论以下主题列表。
- Python Django 应用程序上传文件
- Python Django 模型字段
- Python Django 文件上传
- Python Django 图像上传
- Python Django 在前端查看上传的文件
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Django 中应用程序和项目之间的差异
在本 Django 教程中，我们将尝试了解 Django 中 app 和项目的区别。此外，我们还将在本教程中讨论以下主题。
- 姜戈的项目是什么
- Django 的 app 是什么
- Django 中应用程序和项目之间的差异
- Django 中 startapp 和 startproject 的区别
目录
- Django 的项目是什么
- Django 中的 app 是什么
- Django 的应用程序和项目之间的差异
- Django 的 startapp 和 startproject 的区别
- Django 中的 startproject 命令
- Django 中的 startapp 命令
Django 的项目是什么
- Django 中的一个项目是一个代表整个 web 应用程序的 python 包。
- Django 的一个项目基本上包含了整个网站相关的配置和设置。
- 一个项目也可以包含多个应用程序，用于实现某些功能。
当我们创建一个项目时，Django 会自动生成一个项目目录，其中包含一个 python 包。它还会在项目目录中创建一个 manage.py 文件。manage.py 是一个主要用于与项目交互的实用程序。
此外，我们还可以在不添加任何应用程序的情况下使用项目。但是，这将是对 Django 框架的利用不足。
阅读:如何安装 Django
DjangoT3 里的 app 是什么
- Django 中的一个 app 是一个项目的子模块，用来实现一些功能。
- 现在，您可以将应用程序称为独立的 python 模块，用于为您的项目提供一些功能。
- 我们可以在一个 Django 项目中创建多个应用程序。这些应用程序可以相互独立。理论上，我们可以从一个 Django 项目到另一个项目使用一个应用程序，而不需要对它做任何修改。
现在，当我们在项目中创建一个应用程序时，Django 会自动创建一个自包含的目录。因此，开发人员可以专注于业务逻辑，而不是构建应用程序目录。
Django 框架的工作原理是 DRY(不要重复自己)，应用程序的概念是其中很大的一部分。
阅读如何从 Django 中的 get 请求获取数据
Djangoapp 与项目的区别
到目前为止，我们讨论了一个关于 Django 的项目和应用程序的基本介绍。现在，如果你想了解我们如何创建一个项目或应用程序，你可以参考这篇文章“如何设置 Django 项目”。
在这一节中，我们将尝试理解 Django 中 app 和 project 之间的一些关键差异。
- 一个项目代表整个网站，而一个应用程序基本上是项目的一个子模块。
- 一个项目可以包含多个应用程序，而一个应用程序也可以在不同的项目中使用。
- 项目就像整个 web 应用程序的蓝图，而应用程序是 web 应用程序的构建块。
- 我们通常会为我们的网站创建一个项目，其中包含一个或多个应用程序。
- 项目包含与整个 web 应用程序相关的配置和设置。另一方面，应用程序可以是独立的，也可以相互关联。
Django的 startapp 和 startproject 的区别
在本节中，我们将了解 startapp 和 startproject 命令之间的区别。这里是 Django 中这两个命令的一些不同之处。
Django 中的 startproject 命令
startproject 命令是我们运行的第一个命令，它用于在 Django 中创建新项目。通过执行这个命令，Django 自动在给定的位置创建项目目录。
Django 中完整的 startproject 如下所示。
django-admin startproject *`project_name`*
在上面的命令中，我们可以指定我们项目的名称来代替 project_name 。并且给定的名称也将用作项目目录名。
Django 中的 startapp 命令
Django 中的 startapp 命令用于为我们的项目创建一个新的应用程序。现在，我们可以在项目中多次使用这个命令来创建多个应用程序。
通过执行这个命令，Django 自动在项目目录中创建应用程序目录。
现在，要执行这个命令，首先我们需要移动到项目目录，然后我们可以使用下面的语法。
python manage.py startapp `a*pp_name*`
要执行 startapp 命令，我们必须使用 manage.py 实用程序，而不是 django-admin 。在语法中，我们可以指定我们的应用程序名称来代替应用程序名称。该名称也将用作应用程序目录名称。
你可能会喜欢读下面的文章。
在本教程中，我们了解了 Django 中 app 和 project 的区别。此外，在本文中，我们讨论了以下主题。
- 姜戈的项目是什么
- Django 的 app 是什么
- Django 中应用程序和项目之间的差异
- Django 中 startapp 和 startproject 的区别
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Python Django 连接字符串
在这个 Python Django 教程中，我们将学习 Python Django 连接字符串的实现。这些是我们将在本教程中讨论的主题。
- Python Django 连接多行字符串
- Django 连接字符串基本命令
- Django 连接字符串模板
- Django 连接视图中的字符串
- Django 连接字符串和 int 基本命令
- Django 连接字符串和整型模板
- Django 连接 string 和 int
- Django 连接字符串模型
- Django 模板过滤器连接字符串和整数
目录
- Python Django 连接多行字符串
- Django 连接字符串基本命令
- Django 连接字符串模板
- Django 连接视图中的字符串
- Django 连接字符串和 int 基本命令
- Django 连接字符串和 int 模板
- Django 连接 string 和 int
- Django 连接字符串模型
- Django 模板过滤器连接 string 和 int
Python Django 连接多行字符串
字符串连接是将两个字符串连接在一起的过程。
-
有多种方法来连接字符串。
- 通过使用+运算符
- 通过使用 join()函数
- 通过使用 % 运算符
- 通过使用格式()功能
-
连接 string 和 int 的多种方法。
- 通过使用
str()函数 - 通过使用 % 运算符
- 通过使用格式()函数
- 通过使用 f 字符串
- 通过使用
Django 连接字符串基本命令
在本节中，我们将学习连接字符串的基本命令。
创建项目: 首先，我们需要创建一个 Django 项目。为此，请在终端中键入以下命令。
django-admin startproject PythonGuides
- 在这里，我们创建了一个名为
PythonGuides的 Django 项目。
创建 APP: 然后，我们来学习创建 Django App。在终端中键入以下命令。
python manage.py startapp home
- 这里，我们创建了一个名为
home的 Django 应用程序。
安装 APP: 在 settings.py 文件中，我们必须包含上面创建的 APP。
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'home',
]
创建模板: 然后在项目根目录下创建模板文件夹。我们将在文件夹中创建 HTML 文件。
TEMPLATES
添加模板: 我们还需要在 settings.py 文件中添加“模板 目录”。
DIRS
项目 URL:在 PythonGuides urls.py 文件中添加以下代码。
from django.contrib import admin
from django.urls import path, include
urlpatterns = [
path('admin/', admin.site.urls),
path('', include('home.urls'))
]
APP 网址: 在首页 urls.py 文件中添加以下代码。
from django.urls import path
from . import views
urlpatterns = [
path('', views.ConcatForm, name='ConcatForm'),
]
创建表单: 现在，我们创建一个表单。以及下面的代码片段到首页 app 的 forms.py 文件中。
from django import forms
class StringConcat(forms.Form):
String_1 = forms.CharField(label='String 1')
String_2 = forms.CharField(label='String 2')
- 这里，我们用两个
Charfield 创建了一个StringConcat类
Django 连接字符串模板
在这一节中，我们将学习如何创建将在视图中呈现的 HTML 文件。
form.html: 将下面的代码添加到【form.html】文件中。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Index</title>
</head>
<body>
<form method="POST" class="post-form" enctype="multipart/form-data">
{% csrf_token %}
{{ form.as_p }}
<button type="submit" class="save btn btn-default">Submit</button>
</form>
</body>
</html>
- 我们使用表单标签创建表单。
- 在这里，我们使用
csrf_token标记是为了避免恶意攻击。 - 然后，我们使用
form.as_p标签将 Django 表单呈现为一个段落。
index.html: 将以下代码添加到【index.html】文件中。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
</head>
<body>
<p>
<b>Concatenated String : </b> {{FString}}
</p>
</body>
</html>
另外，检查:将 Python 输出到 html Django
Django 连接视图中的字符串
在这一节中，我们将学习创建视图来连接字符串。
例#1 通过使用+运算符。
创建视图: 在 views.py 文件中添加以下代码。
from django.shortcuts import redirect, render
from home.forms import StringConcat
def ConcatForm(request):
if request.method == "POST":
form = StringConcat(request.POST)
if form.is_valid():
String1 = form.cleaned_data['String_1']
String2 = form.cleaned_data['String_2']
FString = String1 + " " + String2
return render(request, 'index.html', {'FString':FString})
else:
form = StringConcat()
return render(request,'form.html',{'form':form})
- 这里，变量
String1和String2使用+运算符组合，并存储在另一个变量FString中。
运行服务器: 启动服务器，通过定义 URL 为 http://127.0.0.1:8000 来访问表单
Add String
Concatenated String using + operator
例#2 通过使用 join() 函数。
创建视图: 在 views.py 文件中添加以下代码。
from django.shortcuts import redirect, render
from home.forms import StringConcat
def ConcatForm(request):
if request.method == "POST":
form = StringConcat(request.POST)
if form.is_valid():
String1 = form.cleaned_data['String_1']
String2 = form.cleaned_data['String_2']
FString = " ".join([String1, String2])
return render(request, 'index.html', {'FString':FString})
else:
form = StringConcat()
return render(request,'form.html',{'form':form})
- 这里，使用
join()方法将变量String1和String2组合起来，并将组合后的字符串存储在另一个变量FString中，该变量由空格分隔。 join()方法只接受列表作为它的参数。
运行服务器: 启动服务器，通过定义 URL 为 http://127.0.0.1:8000 来访问表单
Enter String
Concatenated String using join() method
例#3 使用 % 运算符
创建视图: 在 views.py 文件中添加以下代码。
from django.shortcuts import redirect, render
from home.forms import StringConcat
def ConcatForm(request):
if request.method == "POST":
form = StringConcat(request.POST)
if form.is_valid():
String1 = form.cleaned_data['String_1']
String2 = form.cleaned_data['String_2']
FString = ("%s %s" %(String1, String2))
return render(request, 'index.html', {'FString':FString})
else:
form = StringConcat()
return render(request,'form.html',{'form':form})
- 这里，变量
String1和String2使用 % 运算符组合，并将组合后的字符串存储在另一个变量FString中。 - % 操作符可用于字符串格式化和字符串连接。
concatenate string in Django
Concatenated String using % operator
例# 4 通过使用格式()函数
创建视图: 在 views.py 文件中添加以下代码。
from django.shortcuts import redirect, render
from home.forms import StringConcat
def ConcatForm(request):
if request.method == "POST":
form = StringConcat(request.POST)
if form.is_valid():
String1 = form.cleaned_data['String_1']
String2 = form.cleaned_data['String_2']
FString = "{} {}".format(String1, String2)
return render(request, 'index.html', {'FString':FString})
else:
form = StringConcat()
return render(request,'form.html',{'form':form})
- 这里，变量
String1和String2使用format()函数组合，并将组合后的字符串存储在另一个变量FString中。 format()函数使用位置格式连接字符串中的元素。- 使用花括号{} 设置字符串的位置。
Python Django concatenate string in views
Concatenated String using format() function
Django 连接字符串和 int 基本命令
在本节中，我们将学习创建一个项目的基本命令和一个在 string 和 int 上执行串联的应用程序。
创建项目: 首先，我们创建一个名为‘my PROJECT’的 Django 项目。
djnago-admin startproject MyProject
创建 APP: 然后，我们创建一个 Django App，命名为‘MyApp’。
python manage.py startapp MyApp
安装 APP: 现在，将上面创建的 APP 包含在 settings.py 文件中。
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'MyApp',
]
创建模板: 在项目根目录下创建一个 TEMPLATES 文件夹来添加 HTML 文件。
添加模板: 将上面创建的文件夹添加到 settings.py 文件中。
'DIRS':['Templates']
项目 URL:在 MyProject urls.py 文件中添加以下代码。
from django.contrib import admin
from django.urls import path,include
urlpatterns = [
path('admin/', admin.site.urls),
path('', include('MyApp.urls'))
]
APP 网址: 在 MyApp urls.py 文件中添加以下代码。
from django.urls import path
from . import views
urlpatterns = [
path('', views.ConcatString, name='ConcatString'),
]
创建表单: 现在，创建一个表单来接受用户的输入。
from django import forms
class StringConcatForm(forms.Form):
Char_String = forms.CharField(label='Character String')
Int_String = forms.IntegerField(label='Integer String')
- 在这里，我们创建了一个
StringConcatForm类，带有一个Charfield和一个IntegerField。
Django 连接字符串和 int 模板
在这一节中，我们将学习创建 HTML 文件，这些文件在视图中呈现以连接 string 和 int。
app.html: 在【app.html】文件中添加以下代码。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>App</title>
</head>
<body>
<form method="POST" class="post-form" enctype="multipart/form-data">
{% csrf_token %}
{{ form.as_p }}
<button type="submit" class="save btn btn-default">Submit</button>
</form>
</body>
</html>
- 表单标签用于生成表单。
- 为了避免恶意攻击，我们在表单中使用了 csrf_token 标签。
- 然后， form.as_p 标签用于将 Django 表单呈现为一个段落。
home.html: 将下面的代码添加到【home.html】的文件中。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>String</title>
</head>
<body>
<p>
<b>Concatenated String : </b> {{FullString}}
</p>
</body>
</html>
- 这个 HTML 文件用于呈现串联的字符串。
Django 连接 string 和 int
在这一节中，我们将学习创建视图来连接 string 和 int。
例#1 通过使用 str() 函数。
创建视图: 在 views.py 文件中添加以下代码。
from django.shortcuts import redirect, render
from MyApp.forms import StringConcatForm
def ConcatString(request):
if request.method == "POST":
form = StringConcatForm(request.POST)
if form.is_valid():
CharString = form.cleaned_data['Char_String']
IntString = form.cleaned_data['Int_String']
FullString = CharString + str(IntString)
return render(request, 'home.html', {'FullString':FullString})
else:
form = StringConcatForm()
return render(request,'app.html',{'form':form})
- 这里，使用
str()函数将一个字符串和 int 类型变量连接起来。
Django concatenate string and int
Concatenate string and int using str() function
例# 2 通过使用 % 运算符。
创建视图: 在 views.py 文件中添加以下代码。
from django.shortcuts import redirect, render
from MyApp.forms import StringConcatForm
def ConcatString(request):
if request.method == "POST":
form = StringConcatForm(request.POST)
if form.is_valid():
CharString = form.cleaned_data['Char_String']
IntString = form.cleaned_data['Int_String']
FullString = ("%s %s" %(CharString, IntString))
return render(request, 'home.html', {'FullString':FullString})
else:
form = StringConcatForm()
return render(request,'app.html',{'form':form})
- 这里，一个字符串和 int 类型变量使用%运算符连接在一起。
Django concatenate string and int
Django concatenate string and int using the % operator
例# 3 使用格式()函数。
创建视图: 在 views.py 文件中添加以下代码。
from django.shortcuts import redirect, render
from MyApp.forms import StringConcatForm
def ConcatString(request):
if request.method == "POST":
form = StringConcatForm(request.POST)
if form.is_valid():
CharString = form.cleaned_data['Char_String']
IntString = form.cleaned_data['Int_String']
FullString = "{} {}".format(CharString, IntString)
return render(request, 'home.html', {'FullString':FullString})
else:
form = StringConcatForm()
return render(request,'app.html',{'form':form})
- 这里，使用
format()函数将一个字符串和 int 类型变量连接起来。 format()的另一个优点是，它消除了在连接输入之前将整数转换成字符串的需要。
Django concatenate string and int
Django concatenate string and int using the format() function
例# 4 通过使用 f 琴弦。
创建视图: 在 views.py 文件中添加以下代码。
from django.shortcuts import redirect, render
from MyApp.forms import StringConcatForm
def ConcatString(request):
if request.method == "POST":
form = StringConcatForm(request.POST)
if form.is_valid():
CharString = form.cleaned_data['Char_String']
IntString = form.cleaned_data['Int_String']
FullString = f"{CharString} {IntString}"
return render(request, 'home.html', {'FullString':FullString})
else:
form = StringConcatForm()
return render(request,'app.html',{'form':form})
- 这里，使用
f字符串连接一个字符串和 int 类型变量。
Concatenate string and int using Django
Concatenate string and int using f string
Django 连接字符串模型
在这一节中，我们将学习使用 Django 模型连接字符串。
创建项目: 首先，我们创建一个名为【员工】的 Django 项目。
djnago-admin startproject Employee
创建 APP: 然后，我们创建一个 Django App，命名为【记录】。
python manage.py startapp Records
安装 APP: 现在，将上面创建的 APP 包含在 settings.py 文件中。
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'Records',
]
创建模板: 在项目根目录下创建一个 TEMPLATES 文件夹来添加 HTML 文件。
Django concatenate string model
添加模板: 将上面创建的文件夹添加到 settings.py 文件中。
'DIRS':['Templates']
项目 URL:在 MyProject urls.py 文件中添加以下代码。
from django.contrib import admin
from django.urls import path,include
urlpatterns = [
path('admin/', admin.site.urls),
path('', include('Records.urls'))
]
APP 网址: 在 MyApp urls.py 文件中添加以下代码。
from django.urls import path
from . import views
urlpatterns = [
path('', views.EmpRecord, name='EmpRecord'),
]
创建模型: 在 models.py 文件中添加以下代码。
from django.db import models
class EmpRecords(models.Model):
first_name=models.CharField(max_length=200)
last_name=models.CharField(max_length=200)
email=models.EmailField()
class Meta:
db_table = "EmpRecords"
- 在这里，我们创建了不同的属性，如名、姓和电子邮件，它们具有特定的数据类型，表示数据库中的列。
- 为了更改表的默认名称，我们在类元中传递了新表
db_table。
创建表单: 在 forms.py 文件中添加以下代码。
from django import forms
from .models import EmpRecords
class EmpRecordsForm(forms.ModelForm):
class Meta:
model = EmpRecords
fields = "__all__"
创建视图: 在 views.py 文件中添加以下代码。
from django.shortcuts import render
from Records.forms import EmpRecordsForm
from .models import EmpRecords
def EmpRecord(request):
if request.method == "POST":
form = EmpRecordsForm(request.POST)
if form.is_valid():
First_Name = form.cleaned_data['first_name']
Last_Name = form.cleaned_data['last_name']
Email = form.cleaned_data['email']
data = EmpRecords(first_name=First_Name, last_name=Last_Name, email=Email )
data.save()
FullName = First_Name + " " + Last_Name
return render(request, 'index.html', {'FullName':FullName})
else:
form = EmpRecordsForm()
return render(request,'records.html',{'form':form})
- 这里，变量名和姓使用+运算符组合，并存储在另一个变量全名中。
- 我们还将记录保存在管理数据库中。
运行服务器: 启动服务器，通过定义 URL 为 http://127.0.0.1:8000 来访问表单。
Concatenate string model using Django
Concatenate string using model
Admin Panel Record
Read: Django 从 POST 请求中获取所有数据
Django 模板过滤器连接 string 和 int
在这一节中，我们将学习使用内置的模板过滤器连接 string 和 int。
"add" 过滤器用于将参数添加到值中。如果失败，它会将这些值相加。
语法:
{{ first|add:second }}
让我们看一个使用添加模板过滤器连接 string 和 int 的例子。
执行前面几节中概述的步骤。
- Django 连接字符串和 int 基本命令
之后，继续下面的步骤。
创建表单: 将以下代码添加到 forms.py 文件中。
from django import forms
class StringConcatForm(forms.Form):
Char_String = forms.CharField(label='Character String')
Int_String = forms.CharField(label='Integer String')
创建视图: 将以下代码添加到 views.py 文件中。
from django.shortcuts import render
from MyApp.forms import StringConcatForm
def ConcatString(request):
if request.method == "POST":
form = StringConcatForm(request.POST)
if form.is_valid():
CharString = form.cleaned_data['Char_String']
IntString = form.cleaned_data['Int_String']
context = {
'CharString':CharString,
'IntString' :IntString
}
return render(request, 'index.html',context)
else:
form = StringConcatForm()
return render(request,'app.html',{'form':form})
app.html: 将以下代码添加到 app.html 文件中。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>App</title>
</head>
<body>
<form method="POST" class="post-form" enctype="multipart/form-data">
{% csrf_token %}
{{ form.as_p }}
<button type="submit" class="save btn btn-default">Submit</button>
</form>
</body>
</html>
index.html: 将以下代码添加到【index.html】文件中。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>String</title>
</head>
<body>
<p>
<b>Concatenated String : </b> {{CharString|add:" "|add:IntString}}
</p>
</body>
</html>
- 这里，我们使用添加过滤器连接字符串和字符串变量。
运行服务器: 启动服务器，通过定义 URL 为 http://127.0.0.1:8000 来访问表单。
Django template filter concatenate string and int
Python Django concatenate add filter string and int
你可能也喜欢阅读下面的 Django 教程。
在本 Python Django 教程中，我们已经讨论了 Python Django 连接多行字符串，并且我们还讨论了本教程中的以下主题。
- Python Django 连接多行字符串
- Django 连接字符串基本命令
- Django 连接字符串模板
- Django 连接视图中的字符串
- Django 连接字符串和 int 基本命令
- Django 连接字符串和整型模板
- Django 连接 string 和 int
- Django 连接字符串模型
- Django 模板过滤器连接字符串和整数
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
基于类视图的 Django 联系人表单
原文：https://pythonguides.com/django-contact-form-with-class-based-views/
在这个 Python Django 教程中，我将解释如何用基于类的视图创建 Django 联系表单。
在处理联系人表单时，我刚刚了解到使用基于函数的视图创建联系人表单需要几十行代码以及大量的工作和时间。
所以，在做了一些研究之后，我了解到 Django 有基于阶级的观点。在这里，我们将集中讨论用基于类的视图处理 Django 联系表单。
在这里我们将看到:
- 用基于类的视图构建 Django 联系表单
- Django 中基于类的表单视图的表单处理
- 如何在 Django 中使用 TemplateView
- 如何在 Django 中使用各种控件，如文本框、电子邮件和字符栏
- 如何在 Django 中将表单呈现为表格
在本文的最后，你也可以下载代码:带有基于类的视图的联系表单。
这是我们将在这里建造的。
Django Contact Form with class based views
目录
用基于类的视图构建 Django 联系表单
现在，让我们一步一步地看看如何用基于类的 FormView 处理 Django 表单。
设置 Django 项目
首先，使用下面给出的命令在 Django 中创建一个名为导师的项目。
django-admin startproject Tutors
通过在终端键入下面的命令，在 Django 项目中创建一个名为 Contact 的 Django 应用程序。
python manage.py startapp Contact
将联系人应用添加到位于 settings.py 文件中的已安装应用列表中。
settings.py
Django 默认在项目目录中包含一个 urls.py 文件，用于将新构建的应用程序映射到其中。为此，在其中添加以下代码。
from django.contrib import admin
from django.urls import path,include
urlpatterns = [
path('admin/', admin.site.urls),
path('',include('Contact.urls')),
]
具有各种字段的 Django 表单
创建 Django 表单，联系人应用程序将使用它来收集用户输入。
在 app 目录中创建 forms.py 文件，并在其中添加以下代码。
from django import forms
# Create your forms here.
class TutorBookForm(forms.Form):
name = forms.CharField(max_length=50)
email = forms.EmailField()
message = forms.CharField(widget=forms.Textarea)
在这里，我们创建一个名为 TutorBookForm 的表单类，其字段如下所示。
- 名称字段是 Django CharField。此外，该字符域有 50 个最大长度字符的限制。
- 电子邮件字段是 Django EmailField。此字段用于收集来自用户的电子邮件。
- 消息字段是 Django CharField，带有一个小部件，指定表单将显示为 Textarea。
在 Django 中以表格的形式呈现表单
为了允许开发者将 Django 逻辑代码嵌入到 HTML 模板文件中，Django Template 应运而生。
为此，在主项目目录中创建一个名为 Templates 的子目录来存储所有的项目模板。
然后，打开 settings.py 文件，更新 DIRS 指向 Templates 文件夹的位置。
settings.py
在模板文件夹中创建一个名为form.html的文件来定义联系人网页的前端。添加下面给出的代码。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Contact Us</title>
</head>
<body>
<h1 align="center">Connecting With Us</h1>
<hr>
<form method="post">
{% csrf_token %}
<table>
{{form.as_table}}
</table>
<button type="submit">Send Message</button>
</form>
</body>
</html>
- 首先使用 HTML 标签
h1向表单添加标题，并使用hr标签添加一条水平线。 - 然后用方法
POST调用表单标签，这样表单在提交时就被发布了。 - 为了防止表单受到网络攻击并允许您安全地发送信息，请在表单元素中添加 {% csrf_token %} 。
- 接下来，将表单呈现为表格，在表标签中使用
form.as_table标签。 - 最后，添加一个提交按钮来发送消息。
当联系表单成功提交后，我们希望将其呈现到另一个页面，因此我们再次收到成功消息和联系表单链接。
为此，我们将另一个名为success.html的 HTML 文件添加到模板文件夹。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Success Page</title>
</head>
<body>
<h2 style="text-align: center; color: red;" "></h2style>Your form is successfully submitted.</h2>
<p> You can send another in the <a href=" {% url 'contact' %}">Contact Page</a></p>
</body>
</html>
h2 标签用于定义标题，并且文本对齐和颜色属性被传递到标签内部以使文本居中并将其颜色设置为红色。然后使用 a href 标签将联系页面链接到 p 标签内部。
用基于类的表单视图处理 Django 联系人表单的逻辑
为了定义使用基于类的视图创建联系人表单的主要逻辑，我们打开 views.py 文件并添加下面给出的代码。
from django.shortcuts import render
from .forms import TutorBookForm
from django.views.generic.edit import FormView
from django.views.generic.base import TemplateView
# Create your views here.
class TutorBookFormView(FormView):
template_name = 'form.html'
form_class = TutorBookForm
success_url = '/success/'
class SuccessView(TemplateView):
template_name = 'success.html'
- 首先，从表单. py 中导入联系人表单。
- 然后分别从
generic.edit和generic.base模块中导入FromView类和TemplateView类。 - 接下来，创建一个名为
TutorBookFormView的子类，然后用一个名为FormView的现有视图扩展它。- 在这个基于类的视图中，我们覆盖了它的
template_name、form_class和success_url属性，分别将模板作为form.html，表单作为TutorBookForm，当我们成功提交表单时，重定向到success视图。
- 在这个基于类的视图中，我们覆盖了它的
- 然后，我们创建一个名为
SuccessView的子类，并用名为TemplateView的现有视图对其进行扩展。- 在这个基于类的视图中，我们覆盖了它的
template_name属性，这些属性分别将用户带到名为【success.html】的模板。
- 在这个基于类的视图中，我们覆盖了它的
我们必须用 URL 映射视图以便调用它，因此我们必须在 app 目录中创建一个名为 urls.py 的文件。并在其中包含下面的代码。
from django.urls import path
from .views import TutorBookFormView,SuccessView
urlpatterns = [
path("contact", TutorBookFormView.as_view(), name="contact"),
path("success/", SuccessView.as_view(), name="success"),
]
执行 Django 应用程序
为了启动这个特定 Django 项目的开发服务器，我们在终端中输入下面的命令。
python manage.py runserver
我们通过展开 URL 来访问 contact 表单，如下所示。
127.1.1.0/contact
它成功地打开了我们使用基于类的视图创建的 Django 联系人表单，如下所示。
Contact Us
现在，填写联系表单并点击发送消息按钮，如下所示。
Contact Form with class-based view
单击提交后，我们将被带到成功页面。如果我们点击联系页面链接，我们将再次被带到一个未填写的联系表格。
Success Page
另外，检查: Django CRUD 示例和 PostgreSQL
下载带有基于类的视图的Django联系表完整代码。
这是代码。
Django contact form with class based views
结论
这样，我们就成功地创建了一个带有基于类的视图的 Django 联系表单。我们还学习了如何在 Python Django 中使用 FormView 类和 TemplateView 类。
此外，我们还讨论了以下主题。
- 用基于类的视图构建 Django 联系表单
- 使用基于类的 FormView 进行表单处理
- 如何在 Django 中使用 TemplateView
- 如何在 Django 中使用各种控件，如文本框、电子邮件和字符栏
- 如何在 Django 中将表单呈现为表格
另外，看看下面的 Python Django 教程。
拥有丰富 Django 和 Matplotlib 经验的 Python 开发人员，目前在 TSInfo Technologies 工作。我正在成为专业程序员、博客写手和 YouTuber 的路上。
使用 PostgreSQL 的 Django CRUD 示例
原文：https://pythonguides.com/django-crud-example-with-postgresql/
在本 Python Django 教程中，我们将学习 Django CRUD 示例与 PostgreSQL 。这些是我们将在本教程中讨论的主题。
- Django PostgreSQL CRUD
- 用 PostgreSQL 设置 Django CRUD 项目
- Django CRUD 用 PostgreSQL 创建 url 模式
- Djnago CRUD 用 PostgreSQL 创建视图
- Django CRUD 用 PostgreSQL 创建模型
- 使用 PostgreSQL 的 Django CRUD 注册模型
- 用 PostgreSQL 实现 Django CRUD 插入视图函数
- Django CRUD 使用 PostgreSQL 插入 HTML 页面
- Django CRUD 使用 PostgreSQL 显示视图函数
- Django CRUD 用 PostgreSQL 显示 HTML 页面
- 用 PostgreSQL 实现 Django CRUD 编辑视图功能
- 用 PostgreSQL 编辑 HTML 页面
- 用 PostgreSQL 实现 Djnago CRUD remove 视图函数
- Django CRUD 用 PostgreSQL 删除 HTML 页面
- 使用 PostgreSQL 的 Django CRUD 基本命令
- 使用 PostgreSQL 的 Django CRUD 示例
目录
- Django PostgreSQL CRUD
- 用 PostgreSQL 设置 Django CRUD 项目
- Django CRUD 用 PostgreSQL 创建 url 模式
- Djnago CRUD 用 PostgreSQL 创建视图
- Django CRUD 用 PostgreSQL 创建模型
- 使用 PostgreSQL 的 Django CRUD 注册模型
- Django CRUD 用 PostgreSQL 插入视图函数
- Django CRUD 用 PostgreSQL 插入 HTML 页面
- Django CRUD 用 PostgreSQL 显示视图函数
- Django CRUD 用 PostgreSQL 显示 HTML 页面
- Django CRUD 用 PostgreSQL 编辑视图函数
- Django CRUD 用 PostgreSQL 编辑 HTML 页面
- Djnago CRUD remove view 函数与 PostgreSQL
- Django CRUD 用 PostgreSQL 删除 HTML 页面
- 使用 PostgreSQL 的 Django CRUD 基本命令
- 使用 PostgreSQL 的 Django CRUD 示例
Django PostgreSQL CRUD
在本节中，我们将学习使用 PostgreSQL 数据库的 CRUD 操作。
Django 是一个 MVT 的 web 框架架构。通过使用 Django 框架，我们可以执行 CRUD 操作。而这里 CRUD 代表创建，检索，更新，删除。
我们将了解 Django 的 CRUD 操作如下。
- 创建:用户可以使用创建功能向数据库添加新记录。
- 读取:读取命令类似于搜索命令。它允许用户搜索和读取表中特定记录的值。
- 更新:更新功能用于对数据库中的现有记录进行更改。用户可能需要编辑多个字段中的信息来完全更改记录。
- 删除:用户可以使用删除功能从数据库中删除不再需要的记录。
要使用 PostgreSQL 执行 CRUD 操作，我们必须安装 pgAdmin 管理工具。
用 PostgreSQL 设置 Django CRUD 项目
在这一节中，我们将学习建立一个 Django 项目来用 PostgreSQL 执行 CRUD 操作。
创建项目: 首先，我们需要创建一个 Django 项目。为此，请在终端中键入以下命令。
django-admin startproject Employee
- 在这里，我们创建一个名为
Employee的 Django 项目。
CREATE PROJECT IN DJANGO
创建 APP: 接下来，我们将构建一个 CRUDAPP app 作为项目的一部分。稍后我们还将执行 CRUD 任务。此外，要制作应用程序，请在终端中运行以下命令。
python manage.py startapp CRUDAPP
CREATE APP IN DJANGO
创建模板: 然后在项目根目录下创建模板文件夹。我们将在文件夹中创建 HTML 文件。
创建以下 HTML 文件是为了执行 CRUD 操作。
- show.html: 显示提取的数据。
- insert.html: 添加新员工。
- edit.html: 更新现有员工。
- delete.html: 删除员工实体。
TEMPLATES FOR DJANGO PROJECT
安装 APP: 在 settings.py 文件中，我们必须包含 CRUDAPP app。
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'CRUDAPP'
]
INSTALL APP IN DJANGO SETTINGS
添加模板: 我们还需要在 settings.py 文件中添加模板目录。
'DIRS': ['Templates']
TEMPLATES IN DJANGO SETTINGS
数据库设置: 创建一个名为 Employee 的 PostgreSQL 数据库，并在 Django 项目的 settings.py 文件中设置。
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.postgresql',
'NAME': 'Employee',
'USER':'postgres',
'PASSWORD':'Python@123',
'HOST':'localhost',
'PORT':'5432'
}
}
DATABASE SETUP IN DJANGO
Django CRUD 用 PostgreSQL 创建 url 模式
在本节中，我们将学习使用 PostgreSQL 创建 URL 模式来执行 CRUD 操作。
项目 URL: 在项目的 urls.py 文件中添加以下代码。
from django.contrib import admin
from django.urls import path, include
urlpatterns = [
path('admin/', admin.site.urls),
path('', include('CRUDAPP.urls')),
]
- 我们将
CRUDAPP.urls的路径添加到员工 urls.py
APP 网址: 首先我们要在 APP 目录下创建一个名为 urls.py 的文件。现在，我们定义在应用程序的 views.py 文件下创建的不同视图的路径。
from django.urls import path
from . import views
urlpatterns = [
path('', views.insert_emp, name='insert-emp'),
path('show/', views.show_emp, name='show-emp'),
path('edit/<int:pk>', views.edit_emp, name='edit-emp'),
path('remove/<int:pk>', views.remove_emp, name='remove-emp'),
]
- 在这里，我们创建了以下视图:
- insert_emp: 插入员工详细信息。
- show_emp: 显示员工的详细信息。
- edit_emp: 更新员工的现有详细信息。
- remove_emp: 删除现有员工。
阅读:如何在 Python Django 中创建 web 表单
Djnago CRUD 用 PostgreSQL 创建视图
在这一节中，我们将看看我们必须在 views.py 文件中创建的视图函数。
from django.shortcuts import render, redirect
from .forms import EmployeeForm
from .models import Employee
**# Create your views here.
# Create Employee...**
def insert_emp(request):
....
....
**# Retrieve Employees...**
def show_emp(request):
....
....
**# Update Employees...**
def edit_emp(request):
....
....
**# Delete Employees...**
def remove_emp(request):
....
....
- 在这里，我们创建视图，我们将使用这些视图用 PostgreSQL 进行 CRUD 操作。
阅读:将 Google reCAPTCHA 添加到 Django 表单中
Django CRUD 用 PostgreSQL 创建模型
在本节中，我们将开发一个执行 CRUD 操作的模型。
创建模型: 在 models.py 文件中添加以下代码。
from django.db import models
class Employee(models.Model):
EmpId = models.CharField(max_length=3)
EmpName = models.CharField(max_length=200)
EmpGender = models.CharField(max_length=10)
EmpEmail = models.EmailField()
EmpDesignation = models.CharField(max_length=150)
class Meta:
db_table="Employee"
- 我们创建具有五个字段的雇员模型。
- 各个字段分别是
EmpId、EmpName、EmpGender、EmpEmail和EmpDesignation。
Read: ModuleNotFoundError:没有名为 Django 的模块
使用 PostgreSQL 的 Django CRUD 注册模型
在本节中，我们将注册上面创建的模型。
注册型号: 在 admin.py 文件中添加以下代码。
from django.contrib import admin
from .models impor Employee
admin.site.register(Employee)
- 为了在管理站点上注册雇员模型，我们使用带有模型名称的
admin.site.register()函数。
Django CRUD 用 PostgreSQL 插入视图函数
在本节中，我们将学习创建一个视图函数来插入员工详细信息。
insert_emp VIEW: 在 views.py 文件中添加以下代码。
from django.shortcuts import render, redirect
from CRUDAPP.models import Employee
**# Create Employee**
def insert_emp(request):
if request.method == "POST":
EmpId = request.POST['EmpId']
EmpName = request.POST['EmpName']
EmpGender = request.POST['EmpGender']
EmpEmail = request.POST['EmpEmail']
EmpDesignation = request.POST['EmpDesignation']
data = Employee(EmpId=EmpId, EmpName=EmpName, EmpGender=EmpGender, EmpEmail=EmpEmail, EmpDesignation= EmpDesignation)
data.save()
return redirect('show/')
else:
return render(request, 'insert.html')
- 使用请求参数，我们定义了
insert_emp视图，它允许用户输入新的雇员信息。 - 如果您成功输入员工详细信息，您将被重定向到显示 HTML 页面；否则，您将被重定向到插入 HTML 页面。
Django CRUD 用 PostgreSQL 插入 HTML 页面
在本节中，我们将学习创建一个 HTML 模板来添加新员工的详细信息。
插入 HTML: 在【insert.html】文件中添加以下代码。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Enter Employee</title>
</head>
<style>
table {
border: 8px outset;
border-radius: 10px;
border-spacing: 10px;
padding: 20px;
margin-left: auto;
margin-right: auto;
}
th,
td {
padding: 5px;
}
</style>
<body>
<h2 style="text-align:center"> Enter Details of Employee </h2>
<form method="POST">
{% csrf_token %}
<table style="width:50%" align="center">
<tr>
<td>Employee Id</td>
<td><input type="text" placeholder="Enter Employee Id" name="EmpId" </td>
</tr>
<tr>
<td>Employee Name</td>
<td><input type="text" placeholder="Enter Employee Name" name="EmpName" </td>
</tr>
<tr>
<td>Gender</td>
<td><input type="radio" name="EmpGender" value="Male"> Male
<input type="radio" name="EmpGender" value="Female"> Female
<input type="radio" name="EmpGender" value="Other"> Other
</td>
</tr>
<tr>
<td>Email</td>
<td><input type="email" placeholder="Enter Employee Email" name="EmpEmail" </td>
</tr>
<tr>
<td>Designation</td>
<td><select name="EmpDesignation">
<option selected disabled=true>Select Designation</option>
<option> Project Manager </option>
<option> Programmer </option>
<option> Desktop Support Technician </option>
<option> Web Developer </option>
<option> Financial Advisor </option>
</option>
</select></td>
</tr>
<tr>
<td colspan="2" align="center"><input type="submit" class="btn btn-success"> </td>
</tr>
</table>
<br><br>
<div class="alert alert-danger" role="alert">
Do you want see Information of Employees?
</div>
<p>
<a href="{% url 'show-emp' %}">Go To Employee Information--></a>
</p>
</form>
</body>
</html>
- 表单元素用于为用户输入构建一个 HTML 表单。
- 表单标签中还添加了
method=POST属性。 - 然后，为了保护我们的表单免受网络攻击，我们使用了 {% csrf_token %} 。
INSERT HTML TEMPLATE EXAMPLE IN DJANGO
Django CRUD 用 PostgreSQL 显示视图函数
在本节中，我们将学习创建一个视图函数，显示用户添加的所有雇员的信息。
show_emp 视图: 在 views.py 文件中添加以下代码。
from django.shortcuts import render, redirect
from CRUDAPP.models import Employee
**# Retrive Employee**
def show_emp(request):
employees = Employee.objects.all()
return render(request,'show.html',{'employees':employees} )
show_emp视图显示了用户创建的雇员的所有信息。- 用户通过此功能被重定向到
show.html页面。
Django CRUD 用 PostgreSQL 显示 HTML 页面
在本节中，我们将学习创建一个 HTML 模板，显示用户添加的员工列表。
显示 HTML: 在 show.html 文件中添加以下代码。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Search Employee</title>
</head>
<style>
table {
border: 8px outset;
border-radius: 10px;
border-spacing: 10px;
padding: 20px;
margin-left: auto;
margin-right: auto;
}
th,
td {
padding: 5px;
border: 1px solid;
}
</style>
<body>
<h2 style="text-align:center"> Employee Information </h2>
<table align="center" style="margin: 0px auto;">
<thead>
<tr>
<th>Employee ID</th>
<th>Name</th>
<th>Gender</th>
<th>Email</th>
<th>Designation</th>
<th>Edit</th>
<th>Delete</th>
</tr>
</thead>
<tbody>
{% for employee in employees %}
<tr>
<td>{{employee.EmpId}}</td>
<td>{{employee.EmpName}}</td>
<td>{{employee.EmpGender}}</td>
<td>{{employee.EmpEmail}}</td>
<td>{{employee.EmpDesignation}}</td>
<td>
<a href="/edit/{{employee.pk}}">Update</a>
</td>
<td>
<a href="/remove/{{employee.pk}}">Delete</a>
</td>
</tr>
{% endfor %}
</tbody>
</table>
<br><br>
<div class="alert alert-danger" role="alert">
Do you want to enter more Employees?
</div>
<p>
<a href="{% url 'insert-emp' %}"><-- Go To Home Page</a>
</p>
</body>
</html>
- 我们将制作一个 HTML 模板，显示用户输入的所有雇员的列表。
- 以下是表格的标题:
- 员工 Id :显示员工 Id。
- 员工姓名:显示员工的姓名。
- 员工性别:显示员工性别。
- 员工邮件:显示员工的邮件。
- Emp 名称:显示员工的职业。
- 下列操作按钮也是可见的:
- 更新:对用户已经添加的特定条目进行更改。
- 删除:删除某个员工新增的条目。
SHOW HTML TEMPLATE OF DJANGO PROJECT
Django CRUD 用 PostgreSQL 编辑视图函数
在本节中，我们将学习创建一个视图函数来更新现有员工的信息。
edit_emp VIEW: 在 views.py 文件中添加以下代码。
from django.shortcuts import render, redirect
from CRUDAPP.models import Employee
**# Update Employee**
def edit_emp(request,pk):
employees = Employee.objects.get(id=pk)
if request.method == 'POST':
return redirect('/show')
context = {
'employees': employees,
}
return render(request,'edit.html',context)
- 编辑 _ 雇员视图类似于插入 _ 雇员视图。
- 我们根据员工的主键进行更新。
阅读:用姜戈脆皮蛋糕制作蛋糕
Django CRUD 用 PostgreSQL 编辑 HTML 页面
在这一节中，我们将学习开发一个 HTML 模板来更新用户添加的特定员工详细信息。
编辑 HTML: 在【edit.html】文件中添加以下代码。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Update Employee</title>
</head>
<style>
table {
border: 8px outset;
border-radius: 10px;
border-spacing: 10px;
padding: 20px;
margin-left: auto;
margin-right: auto;
}
th,
td {
padding: 5px;
}
</style>
<body>
<h2 style="text-align:center"> Update Details of Employee </h2>
<form method="POST">
{% csrf_token %}
<table style="width:50%" align="center">
<tr>
<td>Employee Id</td>
<td><input type="text" value="{{ employees.EmpId }}" name="EmpId</td>
</tr>
<tr>
<td>Employee Name</td>
<td><input type=" text" value="{{ employees.EmpName }}" name="EmpName" </td>
</tr>
<tr>
<td>Gender</td>
<td><input type="text" value="{{ employees.EmpGender }}" name="EmpGender" </td>
</tr>
<tr>
<td>Email</td>
<td><input type="email" value="{{ employees.EmpEmail }}" name="EmpEmail" </td>
</tr>
<tr>
<td>Designation</td>
<td><input type="text" value="{{ employees.EmpDesignation}}" name="EmpDesignation" </td>
</tr>
<tr>
<td colspan="2" align="center"><input type="submit" class="btn btn-success"> </td>
</tr>
</table>
</form>
</body>
</html>
- 这里有一个表单，我们将使用它来编辑特定用户的信息。
Djnago CRUD remove view 函数与 PostgreSQL
在这一节中，我们将学习创建一个删除指定条目的视图函数。
remove_emp VIEW: 在 views.py 文件中添加以下代码。
from django.shortcuts import render, redirect
from CRUDAPP.models import Employee
**# Delete Employee**
def remove_emp(request, pk):
employees = Employee.objects.get(id=pk)
if request.method == 'POST':
employees.delete()
return redirect('/show')
context = {
'employees': employees,
}
return render(request, 'delete.html', context)
- 当有人点击删除时，remove_emp 视图从数据库中删除实例。
Django CRUD 用 PostgreSQL 删除 HTML 页面
在这一节中，我们将学习开发一个 HTML 模板来删除一个雇员的条目。
删除 HTML: 在【delete.html】文件中添加以下代码。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Delete Employee</title>
</head>
<body>
<form action="" method="POST">
{% csrf_token %}
<br><br>
<div class="alert alert-danger" role="alert">
Are you sure you want to delete "{{ employees.EmpName}}"?
</div>
<p>
<a href="{% url 'show-emp' %}"><-- Return</a>
</p>
<p>
<input class="btn btn-danger" type="submit" value="Confirm">
</p>
</form>
</body>
</html>
- 我们将制作一个 HTML 模板，删除用户想要删除的精确条目。
- 在删除过程之前，再次确认。
- 当我们点击返回按钮时，也可以回到上一页，也就是搜索模板。
使用 PostgreSQL 的 Django CRUD 基本命令
在本节中，我们将看到一些使用 PostgreSQL 执行 CRUD 操作的基本命令。
Makemigrations: 如果模型已经被修改，该命令为我们的新模型准备一个 Makemigrations 文件，或者为任何更改创建一个新的迁移文件。此命令不会创建或影响数据库修改。
python manage.py makemigartions
RUNNING MAKEMIGRATIONS IN DJANGO
迁移: 迁移命令执行数据库最近迁移文件中给出的指令。
python manage.py migrate
MIGRATE COMMAND IN DJANGO
运行服务器: 运行开发服务器运行以下命令。
python manage.py runserver
RUNSERVER COMMAND IN DJANGO
阅读:如何使用 Django 和 SQLite 创建联系人表单
使用 PostgreSQL 的 Django CRUD 示例
在本节中，我们将看到一个使用 PostgreSQL 进行 CRUD 操作的示例。
首先，我们必须输入员工的详细信息。
Enter Detail
如果我们点击转到员工信息，我们会重定向到员工信息。
当我们点击提交按钮时，我们重定向到员工信息。
Show Information
如果我们点击转到主页，我们会重定向到输入员工详细信息的页面。
当我们点击更新看看，会发生什么。
Edit Template
Update Email
在这里，我们将电子邮件从mtereseh@cdc.gov更新为【metereetseh@cdc.gov
当我们点击提交按钮时，我们将重定向到员工信息页面。
Show Employee Information in Django CRUD example with PostgreSQL
从这里，我们清楚地看到电子邮件 id 被更新。
当我们点击删除时，看看会发生什么。
DELETE TEMPLATE
Django CRUD example with PostgreSQL
从这里我们可以清楚地看到员工 Lyneett Cluse 被成功删除。
你可能也喜欢阅读下面的 Django 教程。
在本 Python Django 教程中，我们已经讨论了带有 PostgreSQL 的 Django CRUD 示例，并且我们还讨论了本教程中的以下主题。
- Django PostgreSQL CRUD
- 用 PostgreSQL 设置 Django CRUD 项目
- Django CRUD 用 PostgreSQL 创建 url 模式
- Djnago CRUD 用 PostgreSQL 创建视图
- Django CRUD 用 PostgreSQL 创建模型
- 使用 PostgreSQL 的 Django CRUD 注册模型
- 用 PostgreSQL 实现 Django CRUD 插入视图函数
- Django CRUD 使用 PostgreSQL 插入 HTML 页面
- Django CRUD 使用 PostgreSQL 显示视图函数
- Django CRUD 用 PostgreSQL 显示 HTML 页面
- 用 PostgreSQL 实现 Django CRUD 编辑视图功能
- 用 PostgreSQL 编辑 HTML 页面
- 用 PostgreSQL 实现 Djnago CRUD remove 视图函数
- Django CRUD 用 PostgreSQL 删除 HTML 页面
- 使用 PostgreSQL 的 Django CRUD 基本命令
- 使用 PostgreSQL 的 Django CRUD 示例
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Django for 循环
在这个 Django 教程中，我们将学习循环的 Django。这里我们将学习如何在 Django 中使用 for 循环。我们还将讨论与 Django 中的循环的相关的不同示例。这些是我们将在本教程中讨论的以下主题。
- Django for 循环
- html 中的 Django for 循环
- Django for 循环计数器
- Django for 循环范围
- html 表中的 Django for 循环
- 模板中循环的 Django
- Django for 循环最后一项
- Django for 循环第一项
- Django 代表循环中断
- Django for 循环不起作用
- Django for 循环模型对象
目录
- Django for loop
- Django 用于循环计数器
- Django for 循环最后一项
- Django for 循环第一项
- Django 为循环范围
- Django for loop break
- Django for html 表中的循环
- Django for 循环不起作用
- Django for html 中的循环
Django 为循环
在了解如何在 Django 中创建和使用 for 循环之前，我们应该知道什么是 for 循环。
循环是用于多次执行一条或多条语句的控制语句。现在，在 python 中，有不同类型的循环，其中一个是循环，另一个是循环。
在 python 中， for 循环是用来迭代某个序列的，基本上是用来一个接一个的取每一项。在 python 中，我们可以使用 for 循环来迭代字符串、字典、列表、元组或集合。下面是 python 中使用 for 循环的一般语法。
for iterating_var in sequence:
statements(s)
关于 python 中 For 循环的更多细节，可以阅读下面的教程。
现在，我们可以像在 python 中一样在 views.py 文件中使用 for 循环。但是在 Django 中，有一种更有效的方法使用 for 循环来迭代一些值。那就是在 Django 模板中使用作为模板标签。
Django 为模板中的循环
为了在 Django 中创建并使用作为循环，我们通常使用“作为模板标签。这个标签有助于遍历给定数组中的项目，并且该项目在上下文变量中是可用的。
在模板中使用“作为标签的语法如下所示。
{% for i in list %}
{% endfor %}
现在，让我们举一个例子来理解这个在模板中对于标签的用法。在本演示中，我们将显示使用 for 循环的员工列表。
因此，首先，我们将使用 views.py 文件从雇员模型中获取所有对象。然后，我们将把它们作为一个上下文变量发送到 home.html 的页面。下面是我们添加到 views.py 文件中的代码。
from django.shortcuts import render
from myApp.models import Employee
def home(request):
employee_list = Employee.objects.all()
return render(request, 'home.html', {'employee_list': employee_list})
接下来，我们将使用 urls.py 文件将一个 URL 映射到主页视图，为此，我们在文件中添加了以下代码。
from django.urls import path
from . import views
urlpatterns = [
path('home/', views.home, name='home')
]
所以，下一步是在你的模板目录中创建一个home.html页面。在 home.html 页面的中，我们将使用标签的来迭代上下文变量。从上下文变量中，我们将尝试获取列表中的雇员姓名。
这是我们的home.html页面的代码。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/4.5.2/css/bootstrap.min.css">
<script src="https://ajax.googleapis.com/ajax/libs/jquery/3.5.1/jquery.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/popper.js/1.16.0/umd/popper.min.js"></script>
<script src="https://maxcdn.bootstrapcdn.com/bootstrap/4.5.2/js/bootstrap.min.js"></script>
<title>Python Guides</title>
</head>
<body>
<br>
<div class="container w-50">
<ul class="list-group">
<li class="list-group-item active text-center font-weight-bold">Employee List</li>
{% for employee in employee_list %}
<li class="list-group-item text-center">{{ employee.name }}</li>
{% endfor %}
</ul>
</div>
</body>
</html>
现在，是时候看看上面的示例实现的输出了。为此，我们需要运行开发服务器并打开主页。
Home Page
Django 为循环计数器
现在，Django 还提供了多个内置变量，我们可以在使用 for 循环标签时使用这些变量。它们中的大多数都是在使用 for 循环时用来获取计数器的。
所以，通过使用这些变量，我们可以得到不同类型的计数器。下面列出了与计数器相关的所有变量。
- forloop.counter: 通过使用这个，循环的迭代从索引 1 开始。
- forloop.counter0: 通过使用这个，循环的迭代从索引 0 开始。
- forloop.revcounter: 通过使用这个，迭代从循环结束开始，直到索引 1。
- forloop.revcounter0: 通过使用这个，迭代从循环结束开始，直到索引 0。
现在，为了进行演示，让我们在前面的雇员列表示例中使用其中一个变量。正如您在前面示例的输出中看到的，我们的雇员列表中没有索引。
因此，我们将使用变量" forloop.counter 向我们的雇员列表添加一个索引。而这一次，我们只需要修改我们的 home.html 页面。
下面是我们添加到 home.html 页面的完整代码。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/4.5.2/css/bootstrap.min.css">
<script src="https://ajax.googleapis.com/ajax/libs/jquery/3.5.1/jquery.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/popper.js/1.16.0/umd/popper.min.js"></script>
<script src="https://maxcdn.bootstrapcdn.com/bootstrap/4.5.2/js/bootstrap.min.js"></script>
<title>Python Guides</title>
</head>
<body>
<br>
<div class="container w-50">
<ul class="list-group">
<li class="list-group-item active text-center font-weight-bold">Employee List</li>
{% for employee in employee_list %}
<li class="list-group-item">{{ `forloop.counter` }}. {{ employee.name }}</li>
{% endfor %}
</ul>
</div>
</body>
</html>
在home.html页面上，我们在 for 循环中使用了 for 循环变量。它将为列表中的每个雇员姓名添加一个索引值。最终结果如下图所示。
Final Result
阅读:如何安装 Django
Django for 循环最后一项
Django 还提供了一个内置变量，带有用于循环标记的，使用它我们可以确定数组中的最后一项。
变量的名字是“ forloop.last ”。对于数组的最后一项，该变量返回 True ，对于所有其他项，该变量返回 False 。
因此，我们可以很容易地使用这个变量从数组中获取最后一个值。但是首先，让我们看看这个变量如何返回数组中每一项的真/假值。
同样，在本演示中，我们将使用第一部分中的相同雇员列表示例。我们将在home.html页面的 for 循环中使用该变量。
所以，我们只对页面的主体做了一些修改。而home.html页面主体的代码如下。
<body>
<br>
<div class="container w-50">
<ul class="list-group">
<li class="list-group-item active text-center font-weight-bold">Employee List</li>
{% for employee in employee_list %}
<li class="list-group-item"><b>{{ `forloop.last` }}</b>- {{ employee.name }}</li>
{% endfor %}
</ul>
</div>
</body>
现在，让我们通过启动开发服务器并转到主页来检查结果。
home.html page
现在，从上面的输出中，我们可以看到变量只为最后一项返回了 True 。而对于所有其他项目，它已经返回了 False 。
现在，为了只从数组中获取最后一项，我们需要在模板中使用 IF 语句。
下面是我们将要使用的修改后的代码。
<body>
<br>
<div class="container w-50">
<ul class="list-group">
<li class="list-group-item active text-center font-weight-bold">Last Name From Employee List</li>
{% for employee in employee_list %}
{% if `forloop.last` %}
<li class="list-group-item text-center">{{ employee.name }}</li>
{% endif %}
{% endfor %}
</ul>
</div>
</body>
在上面的代码中，我们用变量的指定了一个 IF 块。因此，循环将只从对象数组中获取最后一个名字。因为该变量只会为最后一项返回 True 。最终，我们将获得以下输出。
Final Result
Django 为循环首项
类似于选择最后一项，我们也有一个变量从给定的数组中获取第一项。变量的名字是 forloop.first ，它只能在循环的中使用。
并且仅对数组中的第一项返回真。对于数组中的所有其他项目，它返回假。
让我们首先看看这个变量在遍历数组中的每一项时如何返回真/假值。为此，我们将继续使用第一部分中的同一个雇员列表示例。
这里是我们使用这个变量的 home.html 文件的代码。
<body>
<br>
<div class="container w-50">
<ul class="list-group">
<li class="list-group-item active text-center font-weight-bold">Employee List</li>
{% for employee in employee_list %}
<li class="list-group-item"><b>{{ `forloop.first` }}</b>- {{ employee.name }}</li>
{% endfor %}
</ul>
</div>
</body>
下图显示了这个home.html页面的输出。
home.html page
现在，从上面的输出中，我们可以看到变量只为第一项返回了 True 。而对于所有其他项目，它已经返回了 False 。
现在，为了只从数组中获取第一项，我们需要在模板中使用 IF 语句。下面是我们将要使用的修改后的代码。
<body>
<br>
<div class="container w-50">
<ul class="list-group">
<li class="list-group-item active text-center font-weight-bold">First Name From Employee List</li>
{% for employee in employee_list %}
{% if `forloop.first` %}
<li class="list-group-item text-center">{{ employee.name }}</li>
{% endif %}
{% endfor %}
</ul>
</div>
</body>
在上面的代码中，我们为第一个变量指定了一个带有的 IF 块。因此，循环将只从对象数组中获取第一个名字。因为变量只会为第一项返回真。最终，我们将获得以下输出。
Final Result
Django 为循环范围
在处理应用程序的逻辑时，我们可能需要运行循环 N 次。要用 python 实现这个任务，我们只需在 for 循环中使用 range() 函数。
range() 函数用于返回一系列数字，从 0 开始，递增 1 (默认)，然后停止在指定值。
但是在 Django 中，我们没有可以在模板中使用的范围标签或函数来实现这个任务。但是不要担心，仍然有一种方法可以让我们运行循环 N 次。我们将在本节中讨论这种方法。
替代方法
在这个方法中，首先，我们将创建一个视图，在这个视图中我们将使用 range() 函数来获取一个数字列表。然后，我们将把列表和模板一起传递给渲染函数。
让我们借助一个例子来理解这个方法，为此，我们将显示从 1 到 10 的数字的平方。因此，首先，我们在我们的 views.py 文件中创建一个视图，其代码如下所示。
from django.shortcuts import render
def home(request):
return render(request, 'home.html', {'range': range(1,11)})
在上面的代码中，我们简单地使用了 range() 函数来获取从 1 到 10 的数字列表。我们只是在渲染函数中传递带有模板的列表。
接下来，我们将在home.html页面的主体中添加以下代码。
<body>
<br>
<div class="container w-50">
<ul class="list-group">
<li class="list-group-item active text-center font-weight-bold">Square of values</li>
{% for x in range %}
<li class="list-group-item text-center">Square of {{x}} is {% widthratio x 1 x %}</li>
{% endfor %}
</ul>
</div>
</body>
现在，在这个页面上，我们使用 for 循环从列表中一次获取一个值。然后，我们用单个值来计算它的平方。为了得到平方，我们使用了一个 widthradio 过滤器，在过滤器中， (x 1 x) 简单地表示 (x * x) 。
下面是上面例子的最终结果。
Final Result
Django 为循环中断
在 python 中， break 语句用于消除当前循环的执行，并开始执行下一条语句。python 中的 break 语句可以在循环中的和的中使用。****
不幸的是，Django 模板不支持使用 break 语句。为了实现 break 语句的功能，我们可以在 for 循环中使用IF–ELSE语句来限制结果。
让我们借助一个例子来理解这一点，为此，我们将使用雇员模型及其数据。我们将尝试只列出模型中的 5 个雇员姓名。因此，我们在 views.py 文件中使用相同的代码，如开始部分所示。
接下来，我们在我们的home.html页面中添加 for 循环，在循环中，我们将使用一个 IF 块。下面给出了 home.html 页面的代码。
<body>
<br>
<div class="container w-50">
<ul class="list-group">
<li class="list-group-item active text-center font-weight-bold">Employee List</li>
{% for employee in employee_list %}
{% **if forloop.counter <= 5** %}
<li class="list-group-item">{{ forloop.counter }}. {{ employee.name }}</li>
{% endif %}
{% endfor %}
</ul>
</div>
</body>
在上面的代码中，首先，我们使用 for 循环迭代雇员列表。在此之后，我们使用 IF 语句来检查雇员姓名的索引是否小于或等于 5。在 ens 中，我们将得到以下结果作为输出。
Final Result
Django for html 表中的循环
到目前为止，我们只在模板中使用了 for 循环来获取列表中的结果，并且只使用了对象集中的一个值。
现在，在本节中，我们将了解如何使用 for 循环来迭代对象数组中的多个值。我们还将了解如何使用 for 循环来排列 HTML 表中的值。
让我们借助一个例子来理解这个实现，为此，我们将再次使用雇员模型。我们将使用 for 循环来遍历对象数组，并在表中显示雇员的详细信息。
首先，我们将创建一个视图来从 Employee 模型中获取所有对象，然后，我们将使用模板在 render 函数中传递它。下面给出了 views.py 的代码。
from django.shortcuts import render
from myApp.models import Employee
def home(request):
employee_list = Employee.objects.all()
return render(request, 'home.html', {'employee_list': employee_list})
接下来，我们将创建home.html文件，并使用 for 循环。下面是 HTML 文件的代码。
<body>
<br>
<div class="container-fluid">
<table class="table">
<thead class="thead-dark">
<tr>
<th scope="col">#</th>
<th scope="col">Employee Name</th>
<th scope="col">Job Title</th>
<th scope="col">Joining Date</th>
</tr>
</thead>
<tbody>
{% for employee in employee_list %}
<tr>
<th scope="row">{{ forloop.counter }}</th>
<td>{{ employee.name }}</td>
<td>{{ employee.job_title }}</td>
<td>{{ employee.joining_date }}</td>
</tr>
{% endfor %}
</tbody>
</table>
</div>
</body>
在上面的代码中，我们在 <主体> 标签中使用了 for 循环，之后，我们在 < td > 标签中指定了值。下面是上面例子的结果。
Home page
姜戈为回路不工作
for 循环是一个条件语句，用于顺序迭代一些 pf 值。下面是 python 中使用 for 循环的一般语法。
for iterating_var in sequence:
statements(s)
现在，我们可以像在 python 中使用 for 循环一样，在视图中使用 for 循环。但是，如果我们想在模板中使用 for 循环呢？
现在，如果我们在模板中使用相同的语法，for 循环将不起作用。Django 模板不像 python 那样工作。
要在我们的模板页面中使用 for 循环，我们必须使用" for "模板标签，使用它的语法如下。
{% for i in list %}
{% endfor %}
现在，我们已经展示了许多与使用“作为模板标签相关的例子。
在 python 中，我们可以使用 for 循环来迭代字符串、字典、列表、元组或集合。但是在 Django 的情况下，大多数时候我们必须迭代表数据。
在 Django 中，表中数据以 python 对象的形式存储。因此，要访问它们，我们必须遍历对象数组，并理解如何从对象中获取值。
在本文中，我们还解释了与此相关的多个示例。
Django for html 中的循环
Django 使用模板动态生成 HTML，我们可以使用这些模板显示静态和动态的 HTML 内容。
Django 使用其模板系统，该系统使用 Django 模板语言。于是，Django 使用 Django 模板语言或 DTL 模板将 Python 和 Django 创建的动态数据显示成 HTML。
现在，为了在这些 Django 模板中使用 for 循环，我们需要使用 for 模板标签。我们已经在本文的第一部分解释了它的可用性。
你可能也喜欢读下面的文章。
在这个 Django 教程中，我们学习了循环的 Django。这里我们已经讨论了如何在 Django 中使用循环的。我们还讨论了与 Django 中的循环的相关的不同示例。这些是我们在本教程中讨论过的以下主题。
- Django for 循环
- html 中的 Django for 循环
- Django for 循环计数器
- Django for 循环范围
- html 表中的 Django for 循环
- 模板中循环的 Django
- Django for 循环最后一项
- Django for 循环第一项
- Django 代表循环中断
- Django for 循环不起作用
- Django for 循环模型对象
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
Python Django 表单验证
在这个 Python Django 教程中，我们将学习 Python Django 表单验证。我们还将在 Django 中看到与表单验证相关的不同示例。我们将在本教程中讨论以下主题:
- Python Django 表单验证
- Django 表单验证示例
- Django 表单验证已清理 _ 数据
- Django 表单验证 max_length
- Django 表单验证错误消息
- Django 表单验证复选框
- 需要 Django 表单验证
- Django 表单验证清理
- Django 表单验证密码
- Djnago 格式验证空白
- Djnago 格式验证整数
- Django 表单验证多个字段
- Django 表单验证唯一
- Django 管理表单验证错误
- Django 表单验证自定义
- Django 表单验证排除字段
- Django 表单验证正则表达式
- Django 表单验证字母数字
- 没有模型的 Django 表单验证
目录
- Python Django 表单验证
- Djnago 表单验证示例
- Django 表单验证已清理 _ 数据
- Django 表单验证 max_length
- Django 表单验证错误消息
- Django 表单验证复选框
- 需要 Django 表单验证
- Django 表单验证清理
- Django 表单验证比较
- Django 表单验证密码
- Django 表单验证空白
- Django 表单验证整数
- Django 表单验证多字段
- Django 表单验证唯一
- Django 管理表单验证错误
- Django 表单验证自定义
- Django 表单验证排除字段
- Django 表单验证正则表达式
- Django 表单验证字母数字
- 没有模型的 Django 表单验证
Python Django 表单验证
在这一节中，我们将看看 Django 的表单验证，这意味着表单数据的验证。这种验证过程非常重要，因为它提高了安全性，并保护我们的表单免受不道德数据的侵害。
Django 包含了用于验证表单输入的内置机制。并且使用这些技术，这种验证可以自动完成。而且，只有 CSRF 代币可以提交 Django 表格。
为了验证表单，我们需要创建一个表单，然后根据用户的需求从用户那里收集各种输入，然后相应地应用表单验证。
另外，检查: Python Django vs ReactJS
Djnago 表单验证示例
在本节中，我们将看到一个与表单验证相关的示例。为了执行表单验证，我们将使用 is_valid() 方法。
当我们需要验证完整的表单数据时，使用 is_vaild() 函数。它是在 Django 的表单类中定义的。在该验证中，将检查 Python 数据类型。该函数将返回布尔结果，即如果数据有效，则返回 True，否则返回 False。
让我们看一个使用 is_valid()方法进行表单验证的例子:
创建项目和 App: 首先我们要创建一个项目和 App。因此，使用下面定义的代码来创建它。
**# Project**
django-admin startproject project_name
**# App**
python manage.py startapp app_name
在这里，我创建了一个名为 PythonGuides 的项目和一个名为 myApp 的应用程序。
安装 App: 后，成功创建项目和 App。你必须安装一个应用程序。为此，您必须将我们的应用程序添加到设置. py 文件中。
Install App
项目的 URL: 在 urls.py 文件中，你要添加一个链接到你新创建的 app。将以下代码片段添加到 PythonGuides 的 urls.py 文件中。
from django.contrib import admin
from django.urls import path, include
urlpatterns = [
path('admin/', admin.site.urls),
path('',include('myApp.urls'))
]
App 的网址: 在 urls.py 文件中，你要添加函数视图的路径。将以下代码片段添加到 myApp 的 urls.py 文件中。
from django.urls import path,include
from . import views
urlpatterns = [
path('emp_form', views.emp_form, name='emp_form'),
]
模型: 现在，我们创建模型。将以下代码片段添加到 myApp 的 models.py 文件中。
from django.db import models
class EmpDetails(models.Model):
Name = models.CharField(max_length=150)
Email = models.EmailField()
Contact = models.CharField(max_length=15)
class Meta:
db_table = "Employee Details"
- 在这里，我们创建不同的属性，如姓名、电子邮件和联系人，它们具有特定的数据类型，代表数据库中的列。
- 为了更改表的默认名称，我们在类元中传递了新表
db_table。
表单: 现在，我们创建一个表单。和下面的代码片段添加到 myApp 的 forms.py 文件中。
from django import forms
from .models import EmpDetails
class EmpDetailsForm(forms.ModelForm):
class Meta:
model = EmpDetails
fields = "__all__"
视图: 在 views.py 文件中，实现表单，验证表单请求是否为 POST。并添加下面的代码片段。
from django.shortcuts import redirect, render
from myApp.forms import EmpDetailsForm
def emp_form(request):
if request.method == "POST":
form = EmpDetailsForm(request.POST)
if form.is_valid():
try:
return redirect('/')
except:
pass
else:
form = EmpDetailsForm()
return render(request,'form.html',{'form':form})
- 这里我们在视图函数中使用了
is_valid()方法，因为它返回值 True 和 False。
模板: 现在，创建一个显示表单和错误的 forms.html 模板。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Index</title>
</head>
<body>
<form method="POST" class="post-form" enctype="multipart/form-data">
{% csrf_token %}
{{ form.as_p }}
<button type="submit" class="save btn btn-default">Submit</button>
</form>
</body>
</html>
运行服务器: 启动服务器，访问表单。表单验证每个字段，如果任何验证失败，就会显示一个错误。
Form validation using python Django
Form validation using Django
Form validation example using Django
Django 表单验证已清理 _ 数据
在本节中，我们将看到一个与表单验证相关的示例。并且，为了执行表单验证，我们将使用 cleaned_data 属性。
cleaned_data 用于验证某些字段。基本上，任何输入到表单中的信息都将作为字符串发送到服务器。创建表单时使用哪种类型的表单域没有区别。浏览器最终会将所有内容转换成字符串。
因此，我们可以说 Django 在清理数据时会自动将数据更改为适当的类型。在 Django 中，经过清理和验证的数据被称为清理数据。并且，清理数据字典提供了对清理数据的访问。
语法如下:
self.cleaned_data['field_name']
让我们看一个使用 cleaned_data()进行表单验证的例子。
遵循上一节中的以下步骤。
- 创建项目和应用程序
- 安装应用程序
- 项目的 URL
- 应用程序的 URL
在此之后，请遵循以下步骤:
表单: 现在，我们创建一个表单。并将下面的代码片段添加到 myApp 的 forms.py 文件中。
from django import forms
class EmpDetailsForm(forms.Form):
Name=forms.CharField(max_length=100)
Email=forms.EmailField(label='Email')
Contact=forms.CharField()
- 这里，我们创建一个名为
EmpDetailsForm的表单类。 - 接下来，我们将姓名、电子邮件和联系人定义为表单的一个字段。
视图: 执行 views.py 文件中的表单，检查表单请求是否为 POST。将代码片段添加到 views.py 文件中。
from django.shortcuts import redirect, render
from .forms import EmpDetailsForm
def emp_form(request):
if request.method == "POST":
form = EmpDetailsForm(request.POST)
if form.is_valid():
Name = form.cleaned_data['Name']
Email = form.cleaned_data['Email']
Contact = form.cleaned_data['Contact']
print('Name:', Name)
print('Email:', Email)
print('Conatct:', Contact)
else:
form =EmpDetailsForm()
return render(request,'form.html',{'form':form})
- 这里我们在视图函数中使用了
is_valid()方法，因为它返回值 True 和 False。 - 我们还将 cleaned_data 属性用于名称、电子邮件和联系人字段。
- 然后，我们在终端中打印出
cleaned_data的字典值。
模板: 现在，创建一个显示表单和错误的 forms.html 模板。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
</head>
<body>
<form method="POST">
{% csrf_token%}
{{form.as_p}}
<input type="submit" value="Submit">
</form>
</body>
</html>
- 在这里，我们使用
csrf_token标记是为了避免恶意攻击。 - 然后，我们使用
form.as_p标签将 Django 表单呈现为一个段落。
运行服务器: 启动服务器，通过定义 URL 为 http://127.0.0.1:8000/emp_form 来访问表单。
django-form-validation-cleaned_data
Terminal Output
Django 表单验证 max_length
在这一节中，我们将看一个表单验证的例子。并且，为了执行表单验证，我们将使用 max_length 属性。
max_length 是最常用的验证属性之一。它检查字段中输入的数据是否超过设置的最大长度。你可以简单地通过向数据类型提供最大长度来使用这个属性。
我们来看例子:
遵循 Django 表单验证示例一节中的以下步骤。
- 创建项目和应用程序
- 安装应用程序
- 项目的 URL
- 应用程序的 URL
- 视图
- 模板
注意:在这个例子中我们没有使用模型类，因为我们直接使用表单类。
例#1
表单: 现在，我们创建一个带有 max_length 验证属性的表单。将以下代码片段添加到 myApp 的 forms.py 文件中。
from django import forms
class EmpDetailsForm(forms.Form):
Name=forms.CharField(max_length=8)
- 这里，我们创建了一个名为
EmpDetailsForm的表单类，并且我们还向它添加了一个名为“Name”的字段。 - 接下来，我们向
CharField提供max_length属性，并将其值设置为 8。
运行服务器: 启动服务器，通过定义 URL 为 http://127.0.0.1:8000/emp_form 来访问表单。
form validation max_length using Django
在这里，您可以看到我正在尝试输入名称罗伯特·约翰逊，它的字符长度超过 8。
Django form validation max_length
请注意，您不能添加超过 8 个字符。这就是它在这里忽略多余字符的原因。此外，它还将空格算作一个字符。
例 2
表单: 现在我们将使用 max_length 验证器制作一个表单。并且，将以下代码片段添加到 myApp 的 forms.py 文件中。
from django import forms
from matplotlib import widgets
class EmpDetailsForm(forms.Form):
Name=forms.CharField()
Comment =forms.CharField(max_length=125, widget=forms.Textarea)
- 这里，我们创建一个
EmpDetailsFormform 类，带有名称和注释字段。 - 我们还将
max_length验证器应用于评论字段，并且仅将字符长度指定为125。
现在，运行服务器并查看响应。
form validation max_length using Python Django
从这里你可以看到我们只能添加 120 个字符的评论。
Django 表单验证错误消息
在这一节中，我们将通过使用 error_message 属性来看一个表单验证示例。
error_message 属性允许您向字段添加自定义错误消息。此功能允许您覆盖预定义的错误消息并定义自己的错误消息。并且，错误消息以字典数据类型的形式发送。
现在，让我们来看看 与 这个属性相关的例子。
遵循 Django 表单验证示例一节中的以下步骤。
- 创建项目和应用程序
- 安装应用程序
- 项目的 URL
- 应用程序的 URL
- 模板
例#1
表单: 现在，我们创建一个带有错误消息验证属性的表单。并将以下代码添加到 myApp 的 forms.py 文件中。
from django import forms
from matplotlib import widgets
class EmpDetailsForm(forms.Form):
Name=forms.CharField(error_messages = {'required':'Enter your Full Name'})
Username=forms.CharField(min_length=5)
Password=forms.CharField(widget=forms.PasswordInput, error_messages = {'required':'Not use name as password'})
- 在这里，我们创建一个表单类
(EmpDetailsForm)，其中包含表单字段，如姓名、用户名和密码。 - 并且，我们还利用
error_message属性在Name和Password字段中添加了自定义的错误消息。
视图: 实现表单，验证表单请求是否为 POST。并将下面的代码片段添加到 views.py 文件中。
from django.shortcuts import redirect, render
from .forms import EmpDetailsForm
def emp_form(request):
error = {}
if request.method == "POST":
form = EmpDetailsForm(request.POST)
error['form'] = form
if form.is_valid():
name = form.cleaned_data.get("Name")
print(name)
username = form.cleaned_data.get("Username")
print(username)
password = form.cleaned_data.get("Password")
print(password)
return render(request,'form.html',error)
- 这里我们创建一个空字典名为
error。 - 然后，我们使用 Http 请求方法
POST，向服务器发送 HTML 表单数据。 - 我们还在视图函数中使用了
is_valid()方法，因为它返回值 True 和 False。 - 我们还使用cleaned _ data . get(' field ')返回 None，因为字典中不存在该键
现在，绕过浏览器中的 http://127 . 0 . 0 . 1:8000/EMP _ form URL 运行服务器。
Error Message
例 2
表单: 我们将制作一个带有 validate error_message 属性的表单。将以下代码添加到 myApp 的 forms.py 文件中。
from django import forms
from matplotlib import widgets
class EmpDetailsForm(forms.Form):
Name=forms.CharField(error_messages = {'required':'Enter your Full Name'})
Email=forms.EmailField()
RateUs=forms.IntegerField(max_value=1, error_messages = {'required':'Give Rating between 1 to 5'})
- 我们通过使用错误消息属性在名称和比率字段中添加自定义错误消息。
视图: 在 views.py 文件中添加下面的代码片段来实现表单。
from django.shortcuts import redirect, render
from .forms import EmpDetailsForm
def emp_form(request):
error = {}
form = EmpDetailsForm(request.POST)
error['form'] = form
if request.POST:
if form.is_valid():
try:
return redirect('/')
except:
pass
return render(request,'form.html',error)
现在，运行服务器。
form validation error message using Django
Django 表单验证复选框
在这一节中，我们将看一个表单验证复选框的例子，为了显示错误，我们使用了 error_message 属性。
复选框是一个双态按钮，可以选中或取消选中。CheckboxInput 小部件是复选框输入的默认小部件。在 Django 表单中，boolean 字段是一个复选框字段，存储 True 或 False 值。默认情况下，空值为 False。
现在，让我们来看看 与 这个属性相关的例子。
在 Django 表单验证示例部分，遵循以下步骤。
- 创建项目和应用程序
- 安装应用程序
- 项目的 URL
- 应用程序的 URL
- 模板
例#1
表单: 现在，我们创建一个带有复选框 error_message 属性的表单。将以下代码添加到 myApp 的 forms.py 文件中。
from django import forms
class EmpDetailsForm(forms.Form):
Agree = forms.BooleanField(label='Agree', required = True, disabled = False,
widget=forms.widgets.CheckboxInput(attrs={'class': 'checkbox-inline'}),
help_text = "I accept the terms in the License Agreement",
error_messages ={'required':'Please check the box'})
- 这里，我们在 django 表单的布尔字段中获取数据。
- 我们向它传递以下参数:
- 标签:指定字段标题。
- 必选:默认情况下，每个字段取一个必选值，必须设置 required = false，使其可选。
- widget: widget 参数，用于指定应该使用哪些 Widget 类来显示该字段。这里，我们使用 CheckboxInput 类。
- error_message: 指定自定义错误。
视图: 以及 views.py 文件中的以下代码。
from django.shortcuts import redirect, render
from .forms import EmpDetailsForm
def emp_form(request):
error = {}
form = EmpDetailsForm(request.POST)
error['form'] = form
if request.POST:
if form.is_valid():
try:
return redirect('/')
except:
pass
return render(request,'form.html',error)
现在，通过在浏览器的地址栏中键入 http://127.0.0.1:8000/emp_form 来启动服务器。
Django form validation checkbox
需要 Django 表单验证
在这一节中，我们将通过使用必需的属性来看一个表单验证示例。
必需的属性用于用户必须输入的字段。这个属性可以用于任何类型的输入，比如电子邮件、URL、文本、文件、密码、复选框、单选按钮等等。
使用这种方法，您可以强制输入字段。默认情况下，该值为 False。
让我们看一个使用 required 属性进行表单验证的例子:
在 Django 表单验证示例部分，遵循以下步骤。
- 创建项目和应用程序
- 安装应用程序
- 项目的 URL
- 应用程序的 URL
- 视角
- 模板
例#1
表单: 现在，我们创建一个具有所需属性的表单。将以下代码添加到 myApp 的 forms.py 文件中。
from django import forms
class EmpDetailsForm(forms.Form):
FirstName = forms.CharField(required=True)
LastName = forms.CharField(required=False)
Email = forms.EmailField(required=True)
- 在这里，我们将名字和电子邮件作为必填字段。
- 并且，姓氏不是必需的，我们也可以将其留空。因为它不是强制性的。
现在，运行服务器。
Django form validation required
form validation required using Django
从这里您可以看到请填写此字段消息仅在名字和电子邮件字段激活。
例 2
表单: 现在，我们使用所需的属性创建一个表单。将以下代码添加到 myApp 的 forms.py 文件中。
from django import forms
class EmpDetailsForm(forms.Form):
Name = forms.CharField(required=True)
Rating = forms.IntegerField(required=True, min_value=1, max_value=10)
Comment = forms.CharField(max_length=250, widget=forms.Textarea, required=False)
- 这里，我们将姓名和等级设为必填字段。
- 我们还绕过最小值和最大值参数，从 1 到 1 设置额定值范围。
- 并且，注释不是必需的，我们也可以将其留空。因为它不是强制性的。
form validation required using Python Django
Python Django form validation required
Django 表单验证清理
在本节中，我们将通过例子学习 Django 表单验证 clean() 方法。
clean() 方法用于表单字段类。它返回干净数据，然后将其插入到表单的干净数据字典中。当我们想要添加相互依赖的定制验证时，使用这个方法。
该函数负责按照预定义的顺序运行三个函数，分别是 to_python() 、 validate() 和 run_validators() 。而且，它还会产生与函数相关的错误。如果生成的错误是验证错误，该函数将停止验证并引发错误。
语法如下:
Form.clean()
让我们看一个与 clean()方法相关的例子:
创建项目和 App: 首先我们要创建一个项目和 App。因此，使用下面定义的代码来创建它。
**# Project**
django-admin startproject PythonGuides .
**# App**
python manage.py startapp home
在这里，我创建了一个名为 PythonGuides 的项目和一个名为 home 的应用程序。
安装 app: 成功创建项目和 App 后，您需要安装一个 App。为此，您必须将我们的应用程序添加到设置. py 文件中。
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'home',
]
项目的 URL: 你要添加一个链接到你新创建的应用。将下面的代码片段添加到 PythonGuides 的 urls.py 文件中。
from django.contrib import admin
from django.urls import path, include
urlpatterns = [
path('admin/', admin.site.urls),
path('',include('home.urls'))
]
App 的网址: 你要添加功能视图的路径。将下面的代码片段添加到主页的 urls.py 文件中。
from django.urls import path,include
from . import views
urlpatterns = [
path('DetailForm', views.DetailForm, name='DetailForm'),
]
表单: 现在，我们创建一个表单。并将下面的代码片段添加到主页的 forms.py 文件中。
from django import forms
from matplotlib import widgets
class EmpRegistration(forms.Form):
Name = forms.CharField()
Join_Date= forms.DateField()
Leave_Date=forms.DateField()
def clean(self):
cleaned_data = super().clean()
jdate = self.cleaned_data['Join_Date']
ldate = self.cleaned_data['Leave_Date']
if jdate > ldate:
raise forms.ValidationError('Leaving Date must be after Joining Date')
- 在这里，我们创建一个表单类
EmpRegistration。 - 然后，我们将姓名、加入日期和离开日期定义为表单的一个字段。
- 之后，我们使用 clean 方法来清理和验证相互依赖的字段。
- 如果加入日期大于 离开日期，这里我们显示一个验证错误。****
视图: 执行 views.py 文件中的表单，检查表单请求是否为 POST。
from django.shortcuts import redirect, render
from .forms import EmpRegistration
def DetailForm(request):
if request.method == "POST":
form = EmpRegistration(request.POST)
if form.is_valid():
print('Name:', form.cleaned_data['Name'])
print('Join Date:', form.cleaned_data['Join_Date'])
print('Left Date:', form.cleaned_data['Leave_Date'])
else:
form =EmpRegistration()
return render(request,'home.html',{'form':form})
- 这里我们在视图函数中使用了
is_valid()方法，因为它返回值 True 和 False。 - 我们还使用带有姓名、加入日期和离开日期字段的 cleaned_data 属性，并在终端中打印它们的值。
模板: 现在，创建一个【home.html】模板，在浏览器中显示表单和错误。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
</head>
<body>
<form method="POST">
{% csrf_token%}
{{form.as_p}}
<input type="submit" value="Submit">
</form>
</body>
</html>
运行服务器: 启动服务器，通过定义 URL 为 http://127 . 0 . 0 . 1:8000/detail form 来访问表单。
Django form validation clean example
您可以看到，如果我们传递的离开日期早于加入日期，则会生成验证错误。
Python Django validation clean example
Terminal Output
您可以看到，如果我们传递的加入日期晚于离开日期，则不会出现错误，并且这些值也会显示在终端上。
Django 表单验证比较
在这一节中，我们将使用 Django 中的一个例子来学习表单验证比较。
在 Django 表单验证比较中，我们将学习表单的任意两个字段，并根据需求生成。所以，我们来看一个例子来清楚地理解题目。
从 Django 表单验证清理部分，遵循以下步骤。
- 创建项目和应用程序
- 安装应用程序
- 项目的 URL
- 应用程序的 URL
- 模板
表单: 现在，我们创建一个表单。并将下面的代码片段添加到主页的 forms.py 文件中。
from django import forms
class EmpRegistration(forms.Form):
First_Name = forms.CharField(label='First Name')
Last_Name = forms.CharField(label='Last Name')
Email = forms.EmailField(label='Email')
def clean(self):
cleaned_data = super().clean()
fname = self.cleaned_data['First_Name']
lname = self.cleaned_data['Last_Name']
if fname == lname:
raise forms.ValidationError('First Name and Last Name should not be same')
- 在这里，我们创建一个表单类
EmpRegistration。 - 然后，我们将名、姓和电子邮件定义为表单的一个字段。
- 我们还使用 clean 方法来清理和验证相互依赖的字段。这里我们比较的是名和姓。
视图: 执行 views.py 文件中的表单，检查表单请求是否为 POST。
from django.shortcuts import redirect, render
from .forms import EmpRegistration
def DetailForm(request):
if request.method == "POST":
form = EmpRegistration(request.POST)
if form.is_valid():
print('First Name:', form.cleaned_data['First_Name'])
print('Last Name:', form.cleaned_data['Last_Name'])
print('Email:', form.cleaned_data['Email'])
else:
form =EmpRegistration()
return render(request,'home.html',{'form':form})
运行服务器: 启动服务器，通过定义 URL 为 http://127 . 0 . 0 . 1:8000/detail form 来访问表单。
Django form validation compare
从输出中，您可以看到当我们传递相同的名和姓时，它会生成一个验证错误。
Python Django validation compare
Terminal Output
您可以看到，如果我们传递不同的名和姓，那么错误不会出现，并且这些值也会显示在终端上。
Django 表单验证密码
在这一节中，我们将通过一个例子来学习 Django 验证密码的方法。
验证密码是 Django 的内置特性。它用于验证用户输入的密码。密码验证器的目标是确保密码不简单。
Django 内置的密码验证器有以下规则:
- 相似度:其检查密码不得与用户名、名、姓、邮箱相似。
- 最小长度:检查密码的最小长度。默认情况下，最小长度为
8。 - 常用密码: Django 有一个
20.000常用密码记录列表。 - 数字:密码不能全是数字。
在 settings.py 文件中定义这些密码验证器。
AUTH_PASSWORD_VALIDATORS = [
{
'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
'OPTIONS': {'min_length':6}
},
{
'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
},
]
在这里，我更改了密码的默认最小长度，并将其设置为 6。
现在，让我们看一个使用内置密码验证器的 例子。
从 Django 表单验证清理部分，遵循以下步骤。
- 创建项目和应用程序
- 安装应用程序
- 项目的 URL
- 应用程序的 URL
- 模板
表单: 现在，我们创建一个表单。
from django import forms
from matplotlib import widgets
from django.contrib.auth import password_validation
class EmpRegistration(forms.Form):
username = forms.CharField(label='Username')
password = forms.CharField(label='Password',widget=forms.PasswordInput, help_text=password_validation.password_validators_help_text_html)
confirm_Password = forms.CharField(label='Confirm Password', widget=forms.PasswordInput)
def clean(self):
cleaned_data = super().clean()
password1= self.cleaned_data['password']
cpassword= self.cleaned_data['confirm_Password']
if password1 != cpassword:
raise forms.ValidationError('Confirm Password is not same as Password')
password_validation.validate_password(self.cleaned_data.get('password',None))
return self.cleaned_data
- 这里，我们首先导入
password_validation来激活和使用这些验证器。 - 然后，我们使用 Django 的
clean()方法，如果密码与确认密码不同，也会抛出一个错误。 - 现在，我们使用
django . contrib . auth . password _ validation . validate _ password()方法，创建干净的密码。
视图: 实现 views.py 文件中的表单。
from django.shortcuts import redirect, render
from .forms import EmpRegistration
def DetailForm(request):
if request.method == "POST":
form = EmpRegistration(request.POST)
if form.is_valid():
print('Username:', form.cleaned_data['username'])
print('Password:', form.cleaned_data['password'])
print('Confirm Password:', form.cleaned_data['confirm_Password'])
else:
form =EmpRegistration()
return render(request,'home.html',{'form':form})
现在，运行服务器。
Django form validation password
在这里，我将 12345 作为密码传递，您会看到它显示了一个错误。
Django 表单验证空白
在这一节中，我们将通过 Django 中的例子来学习表单验证空格。
默认情况下，Django 模型不接受空白字符作为有效值。为了验证 Django 表单中的空白，我们将使用 Django 模型字段中的空白选项，我们希望允许空白
默认情况下，blank 的值为 False 。为了接受空白，我们将其布尔值更改为 True 。
现在，让我们看一个验证空白的 例子。
从 Django 表单验证清理部分，遵循以下步骤。
- 创建项目和应用程序
- 安装应用程序
- 项目的 URL
- 应用程序的 URL
- 模板
模型: 在 model.py 文件中创建一个模型。
from django.db import models
class EmpRegistration(models.Model):
EmployeeName = models.CharField(max_length=200)
DOB = models.DateField()
Address= models.CharField(max_length=400, blank=True)
Email= models.EmailField()
class Meta:
db_table = "Employee Registration"
- 这里，我们创建了模型类
EmpRegistration。 - 我们还定义了不同的属性，如雇员姓名、出生日期、地址和电子邮件，它们具有表示数据库中列的特定数据类型。
- 然后，为了将表的默认名称更改为
Employee registration，我们在类Meta的db_table中传递新表。
表单: 在 forms.py 文件中创建一个表单。
from django import forms
from .models import EmpRegistration
class EmpRegistrationForm(forms.ModelForm):
class Meta:
model = EmpRegistration
fields = "__all__"
视图: 在 views.py 文件中创建表单的视图。
from django.shortcuts import redirect, render
from .forms import EmpRegistrationForm
def DetailForm(request):
if request.method == "POST":
form = EmpRegistrationForm(request.POST)
if form.is_valid():
print('Employee Name:', form.cleaned_data['EmployeeName'])
print('DOB:', form.cleaned_data['DOB'])
print('Address:', form.cleaned_data['Address'])
print('Email:', form.cleaned_data['Email'])
else:
form =EmpRegistrationForm()
return render(request,'home.html',{'form':form})
运行服务器:
Django form validation whitespace
Terminal Output
正如您在输出中看到的，Django 表单现在验证空白并接受地址空白。
Django 表单验证整数
在这一节中，我们将学习在 Django 的表单上应用整数验证。并且，为了打印错误，我们使用 Django 的内置 error_message 属性。
现在，让我们来看一个 表单验证整数的例子。
从 Django 表单验证清理部分，遵循以下步骤。
- 创建项目和应用程序
- 安装应用程序
- 项目的 URL
- 应用程序的 URL
- 模板
例#1
表单: 在 form.py 文件中创建一个表单。
from django import forms
class EmpRegistration(forms.Form):
Name = forms.CharField()
Email = forms.EmailField()
Country = forms.CharField()
City = forms.CharField()
Pin_Code = forms.IntegerField(label='Pin Code', error_messages ={'required':'Pin Code should be 6 digits only'})
- 在这里，我们创建一个表单类
EmpRegistration。 - 然后，我们将名称、电子邮件、国家、城市和 Pin_Code 定义为表单的一个字段。
- 这里，我们对其最大值为 6 的整数域进行验证。并且，它还显示一条错误消息，提示 Pin 码应该只有 6 位数字。
视图: 实现 views.py 文件中的表单。
from django.shortcuts import redirect, render
from .forms import EmpRegistration
def DetailForm(request):
error = {}
form = EmpRegistration(request.POST)
error['form'] = form
if request.POST:
if form.is_valid():
try:
return redirect('/')
except:
pass
return render(request,'home.html',error)
现在，通过在浏览器的地址栏中输入 bypassing http://127 . 0 . 0 . 1:8000/detail form 来运行服务器。
Django form validation integer
例 2
表单: 在 forms.py 文件中添加以下代码。
from django import forms
class EmpRegistration(forms.Form):
Name = forms.CharField()
Age = forms.IntegerField(min_value=22, max_value=60)
- 这里，我们对形式为年龄应该在 22 到 60 之间的整数字段进行验证。
视图: 在 views.py 文件中添加以下代码。
from django.shortcuts import redirect, render
from .forms import EmpRegistration
def DetailForm(request):
if request.method == "POST":
form = EmpRegistration(request.POST)
if form.is_valid():
try:
return redirect('/')
except:
pass
else:
form = EmpRegistration()
return render(request,'home.html',{'form':form})
运行服务器:
Form validation integer using Django
Python Django form validation integer
Django 表单验证多字段
在这一节中，我们将学习在 Django 表单类的多个字段上应用验证。
现在，让我们看一个表单验证多字段的 示例。
创建项目和应用: 按照下面的命令创建项目和应用。
**# Project**
django-admin startproject PythonGuides .
**# App**
python manage.py startapp myBlog
这里我们创建了一个项目 PythonGuides 和一个应用 myBlog 。
安装 App: 成功创建一个 App 后，安装它。打开 settings.py 文件并添加您的应用程序名称。
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'myBlog',
]
项目的 URL: 在项目的 urls.py 文件中添加以下代码。
from django.contrib import admin
from django.urls import path, include
urlpatterns = [
path('admin/', admin.site.urls),
path('',include('myBlog.urls'))
]
- 在这里，我们添加了一个链接，指向我们创建的新应用程序。
App 的网址: 在 app 的 urls.py 文件中添加以下代码。
from django.urls import path
from . import views
urlpatterns = [
path('blog', views.blog, name='blog'),
]
- 这里我们添加了函数视图的路径。
表单: 在 forms.py 文件中创建一个表单，并添加以下代码。
from django import forms
class BlogForm(forms.Form):
Name = forms.CharField(max_length=250)
post_title = forms.CharField(label='Post Title')
Email = forms.EmailField(required=False)
Update = forms.BooleanField(required=False, help_text='We will update you an email every time new post add')
def clean(self):
cleaned_data = super().clean()
email = self.cleaned_data['Email']
update = self.cleaned_data['Update']
if update and not email:
raise forms.ValidationError('The email must be provided if you are updating to the post')
- 在这里，我们创建一个表单
BlogForm，其中 from 字段Name、post_title、Email，以及Update。 - 然后我们验证两个字段，即更新和电子邮件。
视图: 在 views.py 文件中创建视图。
from django.shortcuts import redirect, render
from .forms import BlogForm
def blog(request):
if request.method == "POST":
form = BlogForm(request.POST)
if form.is_valid():
print('Name:', form.cleaned_data['Name'])
print('Post Title:', form.cleaned_data['post_title'])
print('Email:', form.cleaned_data['Email'])
print('Update:', form.cleaned_data['Update'])
else:
form = BlogForm()
return render(request,'form.html',{'form':form})
- 这里我们使用博客函数中的
is_valid()和cleaned_data属性。
模板: 现在，创建 forms.html 模板。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
</head>
<body>
<form method="POST">
{% csrf_token%}
{{form.as_p}}
<input type="submit" value="Submit">
</form>
</body>
</html>
运行服务器: 启动服务器，通过定义 URL 为 http://127.0.0.1:8000/blog 来访问表单。
Django form validation multiple fields
从这里您可以看到，如果您在没有提供电子邮件的情况下单击 Update 按钮，将会生成错误。
Python Django form validation multiple fields
Terminal Output
如果我们只提供姓名和电子邮件，它将在终端上打印数值。
Django 表单验证唯一
在本节中，我们将通过示例了解独特的表单验证。
unique 属性用于将表单字段设置为唯一。如果在表单字段中输入了值，则不能在同一字段中再次输入相同的值。
默认情况下，unique 的值为 False 。要设置唯一字段，将唯一参数的值设置为 True 。
语法如下:
field_name = models.Field(unique=True)
让我们看一个与表单验证独特性相关的例子:
从 Django 表单验证多字段部分，遵循以下步骤。
- 创建项目和应用程序
- 安装应用程序
- 项目的 URL
- 应用程序的 URL
- 模板
例#1
模型: 在 models.py 文件中，创建模型。 B 因为唯一属性只在模型类中使用。
from django.db import models
class Blog(models.Model):
title= models.CharField(max_length=300, unique=True)
author= models.CharField(max_length=200)
def __str__(self):
return self.title
- 在这里，我们创建一个模型类博客。
- 然后，我们将标题和作者定义为表单的一个字段。
- 对于标题字段，我们还使用一个唯一的属性来防止相同的值被输入两次。
表单: 在 forms.py 文件中创建表单类。向其中添加以下代码。
from django.forms import ModelForm
from .models import Blog
class BlogForm(ModelForm):
class Meta:
model = Blog
fields = ['title', 'author']
- 我们创建了上面的博客模型。
- 现在我们想创建一个允许用户输入数据的表单
(BlogForm)。 - 因为我们已经在模型中定义了字段，所以在这种情况下，没有必要在表单中定义字段类型。
查看:
from django.shortcuts import redirect, render
from myBlog.forms import BlogForm
def blog(request):
form = BlogForm(request.POST or None)
if form.is_valid():
form.save()
form = BlogForm()
return render(request,'form.html',{'form':form})
- 请求的类型在作为参数传递给视图的请求对象的“method”属性中设置，通过
POST传递的所有数据都可以通过请求查看。邮政字典是用来表达的词汇的集合。 - 然后使用
is_valid()方法验证表单的每个字段，接着使用save()方法，该方法从链接到表单的数据中生成并保存一个数据库对象。 - 如果
is_valid为真，那么我们重定向到一个 HTML 页面表单。
运行服务器: 现在绕过浏览器地址栏的http://127 . 0 . 0 . 1:8000/blog运行服务器。
Django form validation unique
这里，传书名为姜戈装置和作者为嫁给史密斯。
form validation unique Django
当我们再次将标题作为 Django 装置和作者作为 Robert 传递时，一个具有此标题的错误引发博客已经存在，因为我们使用了具有标题字段的唯一属性。
例 2
模型: 在 models.py 文件中，通过添加以下代码创建模型。
from django.db import models
class Blog(models.Model):
author= models.CharField(max_length=200)
email= models.EmailField(unique=True)
表单: 在 forms.py 文件中创建表单类。向其中添加以下代码。
from django.forms import ModelForm
from .models import Blog
class BlogForm(ModelForm):
class Meta:
model = Blog
fields = ['author', 'email']
视图: 在 views.py 文件中添加以下代码。
from django.shortcuts import redirect, render
from myBlog.forms import BlogForm
def blog(request):
form = BlogForm(request.POST or None)
if form.is_valid():
form.save()
form = BlogForm()
return render(request,'form.html',{'form':form})
运行服务器:
Python Django form validation unique
在这里，传作者为嫁给史密斯和电邮为marry@gmail.com。
form validation unique Django Python
当我们将作者作为 Marry Johnson 并将电子邮件再次作为marry@gmail.com传递时，会出现一个错误带有此电子邮件的博客已经存在，因为我们使用了一个带有电子邮件字段的唯一属性。
Django 管理表单验证错误
在本节中，我们将看到管理端的一个表单验证错误。
我们来看例子:
创建项目和 App: 在终端执行以下代码创建项目和 App。
**# Project**
django-admin startproject Employee
**# App**
python manage.py startapp myApp
- 在这里，我们创建一个项目雇员和一个应用
myApp。
安装 App: 现在，在 settings.py 文件中安装上面创建的 App。
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'myApp',
]
项目的网址: 在项目的 urls.py 文件中，你要添加一个链接到你的新 app。
from django.contrib import admin
from django.urls import path, include
urlpatterns = [
path('admin/', admin.site.urls),
path('',include('myApp.urls'))
]
App 的网址: 在 App 的 urls.py 文件中，你要添加函数视图的路径。
from django.urls import path
from . import views
urlpatterns = [
path('App', views.App, name='App'),
]
模型: 在 models.py 文件中添加下面的代码来创建模型。
from django.db import models
class Employee(models.Model):
EmpId = models.IntegerField(unique=True)
Name = models.CharField(max_length=200)
Assignment_Assign = models.CharField(max_length=500)
Start_Date = models.DateField()
End_Date = models.DateField()
表单: 在 forms.py 文件中添加以下代码创建表单。
from django import forms
from .models import Employee
class EmployeeForm(forms.ModelForm):
class Meta:
model = Employee
fields = ['EmpId', 'Name', 'Assignment_Assign', 'Start_Date', 'End_Date']
视图: 在 views.py 文件中添加以下代码进行查看。
from django.shortcuts import redirect, render
from myApp.forms import EmployeeForm
def App(request):
if request.method == "POST":
form = EmployeeForm(request.POST)
if form.is_valid():
print('Employee Id:', form.cleaned_data['EmpId'])
print('Employee Name:', form.cleaned_data['Name'])
print('Assignment Assign:', form.cleaned_data['Assignment_Assign'])
print('Start Date:', form.cleaned_data['Start_Date'])
print('End Date:', form.cleaned_data['End_Date'])
form.save()
else:
form =EmployeeForm()
return render(request,'form.html',{'form':form})
模板: 现在，创建一个 forms.html 模板。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
</head>
<body>
<form method="POST">
{% csrf_token%}
{{form.as_p}}
<input type="submit" value="Submit">
</form>
</body>
</html>
运行服务器:在浏览器中绕过http://127 . 0 . 0 . 1:8000/App网址启动服务器。
Django admin form validation error
从这里可以清楚地看到，当您输入 101 作为 EmpId 时，会产生一个错误。
Python admin form validation error
在这里，您可以清楚地看到，当我们输入 101 作为 EmpId 时，会产生相同的错误。
Django 表单验证自定义
在本节中，我们将学习自定义表单验证。
假设您有一些需要验证的字段，但是没有内置的验证器，在这种情况下我们创建自定义的验证器。
创建自定义验证的步骤:
- 只需用参数的值声明一个函数。这是参数的名称。
- 然后，在 value 上，应用您想要的验证。当一个值满足任何条件时，就会引发 ValidationError。
- 正如我们对验证器所做的那样，将 function_name 添加到所选字段的验证器参数中。
让我们看看创建自定义表单验证的示例:
例#1
从 Django 表单验证多字段部分，遵循以下步骤。
- 创建项目和应用程序
- 安装应用程序
- 项目的 URL
- 应用程序的 URL
- 模板
表单: 使用 forms.py 文件创建表单类。并添加以下代码。
from django import forms
def start_with(value):
if value[0]!='A':
raise forms.ValidationError("Post Code should start with A")
class BlogForm(forms.Form):
Name = forms.CharField(max_length=250)
post_code = forms.CharField(label='Post Code', validators=[start_with])
- 这里，我们创建名为 start_with 的自定义验证函数。
- 如果值不是以 a 开头，该函数将引发错误。
- 然后，我们用字段 Name 和 Post_Code 创建表单类 BlogForm。
- 我们使用 post_code 自定义验证函数。
视图: 在 views.py 文件中添加以下代码。
from django.shortcuts import redirect, render
from .forms import BlogForm
def blog(request):
if request.method == "POST":
form = BlogForm(request.POST)
if form.is_valid():
print('Name:', form.cleaned_data['Name'])
print('Post Title:', form.cleaned_data['post_code'])
else:
form = BlogForm()
return render(request,'form.html',{'form':form})
运行服务器:
form validation custom using Python Django
这里，我们传递以 P 开头的 Post 代码，这会引发一个错误。
Django form validation custom
form validation custom using Django
当我们输入以字母 A 开头的邮政编码时，它会打印在终端上。
例 2
遵循 Django 表单验证示例一节中的以下步骤。
- 创建项目和应用程序
- 安装应用程序
- 项目的 URL
- 应用程序的 URL
- 模板
表单: 现在，我们创建一个带有自定义验证的表单。
from django import forms
from matplotlib import widgets
from django.core import validators
def check_pass_size(value):
if len(value) > 10:
raise forms.ValidationError("The Password is too long. It's length must be less than 10")
class EmpDetailsForm(forms.Form):
Name=forms.CharField()
Username=forms.CharField(min_length=5)
Password=forms.CharField(widget=forms.PasswordInput, validators=[check_pass_size])
- 这里，我们创建一个名为
check_pass_size的定制验证函数。 - 该函数检查密码的长度，如果密码的长度大于 10** ，则产生错误。**
- 然后，我们创建一个
EmpDetailsForm类，包含字段名称、用户名和密码。 - 并且，我们使用带有密码字段的自定义验证函数。
视图: 在 views.py 文件中添加以下代码。
from django.shortcuts import redirect, render
from .forms import EmpDetailsForm
def emp_form(request):
if request.method == "POST":
form = EmpDetailsForm(request.POST)
if form.is_valid():
name = form.cleaned_data.get("Name")
print(name)
username = form.cleaned_data.get("Username")
print(username)
password = form.cleaned_data.get("Password")
print(password)
else:
form = EmpDetailsForm()
return render(request,'form.html', {'form':form})
运行服务器: 绕过 http://127.0.0.1:8000/emp_form 到浏览器地址栏运行服务器。
Python Django form validation custom
我们输入密码 Johnson#12345 ，但由于密码超过 10 个字符，因此会出现错误。
form validation custom using Django
form validation custom using Python Django
我们输入密码 marry@98 ，它接受密码并在终端上打印出来。
阅读如何在 Django 中加密和解密密码
Django 表单验证排除字段
在这一节中，我们将学习从 Django 表单中排除字段。
当 Django 模型中的字段多于我们希望在 Django 表单中显示的字段时，我们使用 exclude 属性。
让我们看一个与表单验证排除字段相关的示例:
在 Django 管理表单验证错误部分，遵循以下步骤。
- 创建项目和应用程序
- 安装应用程序
- 项目的 URL
- 应用程序的 URL
- 模板
模型: 在 models.py 文件中添加以下代码，创建模型。
from django.db import models
class Employee(models.Model):
Employee_Id = models.IntegerField()
Name = models.CharField(max_length=200)
Assignment_Assign = models.CharField(max_length=500)
Start_Date = models.DateField()
End_Date = models.DateField()
在这里，我们创建一个模型类雇员，带有雇员 Id 、姓名、分配 _ 分配、开始 _ 日期和结束 _ 日期字段。
表单: 在 forms.py 文件中添加以下代码创建表单。
from django import forms
from .models import Employee
class EmployeeForm(forms.ModelForm):
class Meta:
model = Employee
exclude = ('Start_Date', 'End_Date')
这里，我们从表单中排除了开始日期和结束日期字段。
视图: 在 views.py 文件中添加以下代码，创建一个视图。
from django.shortcuts import redirect, render
from myApp.forms import EmployeeForm
def App(request):
if request.method == "POST":
form = EmployeeForm(request.POST)
else:
form =EmployeeForm()
return render(request,'form.html',{'form':form})
运行服务器: 在你的浏览器地址栏中输入 http://127.0.0.1:8000/App 网址。
Django form validation exclude fields
从这里，您可以清楚地看到被排除的字段没有显示在表单上。
Django 表单验证正则表达式
在本节中，我们将学习使用正则表达式进行验证。
一个正则表达式，或正则表达式，是由一系列字符组成的模式。它可以用来检查一个字符串是否包含指定的模式。
让我们看看与表单验证正则表达式相关的例子:
创建项目和 App: 首先我们要创建一个项目和 App。因此，使用下面定义的代码来创建它。
**# Project**
django-admin startproject Registration
**# App**
python manage.py startapp student
在这里，我创建了一个名为注册的项目和一个名为学生的应用程序。
安装 App: 在你的设置中添加学生App . pyINSTALLED _ APPS。
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'student',
]
项目的 URL: 添加在项目的 urls.py 文件中创建的新应用的链接。
from django.contrib import admin
from django.urls import path, include
urlpatterns = [
path('admin/', admin.site.urls),
path('',include('student.urls'))
]
App 的网址: 在 App 的 urls.py 文件中添加函数视图的路径。
from django.urls import path,include
from . import views
urlpatterns = [
path('stud_form', views.stud_form, name='stud_form'),
]
模型: 现在让我们导航到学生应用程序的 models.py 文件，并在任意编辑器中打开它。文件中应包含以下几行:
from django.db import models
class StudentRegistration(models.Model):
Name = models.CharField(max_length=150)
Contact = models.CharField(max_length=15)
Email = models.EmailField()
Password = models.CharField(max_length=8)
class Meta:
db_table = "Student Registration"
- 我们的
StudentRegistration类包含三个字符字段，最大长度分别为150、15和8个字符:姓名、联系人和密码，以及一个电子邮件字段电子邮件。 - 我们还创建了一个元类，并将数据库表命名为学生注册。
表单: 一旦我们的 forms.py 文件被创建，我们就可以添加下面的代码。
from django import forms
from .models import StudentRegistration
from matplotlib import widgets
from django.core.validators import RegexValidator
class StudentRegistrationForm(forms.ModelForm):
Name = forms.CharField()
Contact = forms.CharField(validators=[RegexValidator('[789][0-9]{9}', message="Enter a valid 10 digit contact number")])
Email = forms.EmailField()
Password = forms.CharField(widget=forms.PasswordInput)
class Meta:
model = StudentRegistration
fields = "__all__"
- 这里，字段
Contact有一个名为 validators 的字段。 - 它将一个列表作为输入，我们在这里传递一个名为 RegexValidator 的方法。
- RegexValidator 的第一个参数是 regex 值，第二个参数是消息。
- 我们将联系人的 RegexValidator 定义为
- 它必须是 10 位数
- 第一个数字必须是 7、8、9 中的任何一个。
- 接下来，9 位数应该是从 0 到 9。
观点: 一旦我们的形态准备好了。我们现在可以在我们的 views.py 文件中创建一个名为 stud_form 的新方法。该方法将用于在学生注册模型中注册新的学生。
from django.shortcuts import redirect, render
from .forms import StudentRegistrationForm
def stud_form(request):
if request.method == "POST":
form = StudentRegistrationForm(request.POST)
if form.is_valid():
try:
form.save()
return redirect('/')
except:
pass
else:
form = StudentRegistrationForm()
return render(request,'form.html',{'form':form})
模板:HTML 文件的模板如下所示。它在模板文件夹中被存储为 form.html 的。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Index</title>
</head>
<body>
<form method="POST" class="post-form" enctype="multipart/form-data">
{% csrf_token %}
{{ form.as_p }}
<button type="submit" class="save btn btn-default">Submit</button>
</form>
</body>
</html>
运行服务器: 现在，启动你的应用程序，转到地址，键入 http://127 . 0 . 0 . 1:8000/stud _ form。
Django form validation regex
我们可以看到，当我们输入以 3 开头的联系号码时，或者当联系号码与 regex 模式不匹配时，会显示一条错误消息。
例 2
表单: 在 forms.py 文件中创建一个表单类。
from django import forms
from .models import StudentRegistration
from matplotlib import widgets
from django.core.validators import RegexValidator
class StudentRegistrationForm(forms.ModelForm):
Name = forms.CharField()
Contact = forms.CharField()
Email = forms.EmailField(validators=[RegexValidator('[a-zA-z0-9_\-\.]+[@][a-z]+[\.][a-z]{2,3}', message='Enter a email in correct format')])
Password = forms.CharField(widget=forms.PasswordInput)
class Meta:
model = StudentRegistration
fields = "__all__"
- 这里，字段 Email 有一个名为 validators 的字段。
- 我们将电子邮件的 RegexValidator 定义为
- 它必须包含字母和数字。
- 它必须有@符号。
- 然后，它有字母表字符。
- 然后，它后面跟着点(。).
- 然后，它还包含三到两个字符。
运行服务器:
Python Django form validation regex
我们可以看到，当电子邮件地址与 regex 模式不匹配时，会显示一条错误消息。
Django 表单验证字母数字
在本节中，我们将学习字母数字的表单验证。我们可以在 Django 中使用 RegEx 来设置字母数字验证。
让我们看一个与表单验证字母数字相关的例子。
从 Django 表单验证正则表达式部分遵循以下步骤。
- 创建项目和应用程序
- 安装应用程序
- 项目的 URL
- 应用程序的 URL
- 模型
- 视图
- 模板
形态:
from django import forms
from .models import StudentRegistration
from matplotlib import widgets
from django.core.validators import RegexValidator
class StudentRegistrationForm(forms.ModelForm):
Name = forms.CharField()
Contact = forms.CharField()
Email = forms.EmailField()
Password = forms.CharField(widget=forms.PasswordInput, validators=[RegexValidator('[a-z]+[A-z]+[0-9]+', message='Password must be alphanumeric')])
class Meta:
model = StudentRegistration
fields = "__all__"
- 这里，字段密码有一个名为 validators 的字段。
- 我们将密码的正则表达式验证器定义为:
- 它必须包含小字母表。
- 它应该有大写字母。
- 它还包含数字。
运行服务器:
Django form validation alphanumeric
我们可以看到，当密码与 regex 模式不匹配时，会显示一条错误消息。
没有模型的 Django 表单验证
在这一节中，我们将学习没有 Django 模型的表单验证。
在 Django 中，如果您想在不使用模型的情况下进行表单验证，您必须传递表单。表单作为表单类的参数。
语法:
class class-name(forms.Form)
我们来看一个例子:
创建项目和应用: 在终端执行下面的代码，创建一个项目和一个应用。
**# Project**
django-admin startproject Registration
**# App**
python manage.py startapp Employee
- 在这里，我们创建一个项目注册和一个 app 员工。
安装 App: 现在，将上面创建的 App 安装在 settings.py 文件中。
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'Employee',
]
项目的网址: 在项目的 urls.py 文件中，你要添加一个链接到你的新 app。
from django.contrib import admin
from django.urls import path, include
urlpatterns = [
path('admin/', admin.site.urls),
path('',include('Employee.urls'))
]
App 的网址: 在 App 的 urls.py 文件中，你要添加函数视图的路径。
from django.urls import path,include
from . import views
urlpatterns = [
path('emp', views.emp, name='emp'),
]
表单: 在 forms.py 文件中添加以下代码创建表单。
from django import forms
class EmployeeForm(forms.Form):
Name = forms.CharField(initial = "Enter Name")
Gender = forms.CharField(initial="Male Or Female")
DOB = forms.DateField(initial="Enter Date of Birth")
Designation = forms.CharField(initial="Enter Designation")
- 在这里，我们创建 Django 表单
EmployeeForm，其中包含字段姓名、性别、出生日期和职位名称。 - 然后，我们需要在表单字段中预先输入文本，为此，我们使用了初始属性。
视图: 在 views.py 文件中添加以下代码进行查看。
from django.shortcuts import redirect, render
from .forms import EmployeeForm
def emp(request):
if request.method == "POST":
form = EmployeeForm(request.POST)
if form.is_valid():
try:
return redirect('/')
except:
pass
else:
form = EmployeeForm()
return render(request,'form.html',{'form':form})
模板: 现在，创建一个【forms.html】模板。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Index</title>
</head>
<body>
<form method="POST" class="post-form" enctype="multipart/form-data">
{% csrf_token %}
{{ form.as_p }}
<button type="submit" class="save btn btn-default">Submit</button>
</form>
</body>
</html>
运行服务器: 在浏览器中绕过http://127 . 0 . 0 . 1:8000/App网址启动服务器。
Django form validation without model
在这里，您可以看到我们在不使用模型的情况下进行了表单验证。我们使用 Django 的内置验证属性 Initial 来执行验证。
另外，看看更多的 Django 教程。
在本 Django 教程中，我们讨论了 Django 表单验证。此外，我们还讨论了以下主题列表:
- Python Django 表单验证
- Django 表单验证示例
- Django 表单验证已清理 _ 数据
- Django 表单验证 max_length
- Django 表单验证错误消息
- Django 表单验证复选框
- 需要 Django 表单验证
- Django 表单验证清理
- Django 表单验证密码
- Djnago 格式验证空白
- Djnago 格式验证整数
- Django 表单验证多个字段
- Django 表单验证唯一
- Django 管理表单验证错误
- Django 表单验证自定义
- Django 表单验证排除字段
- Django 表单验证正则表达式
- Django 表单验证字母数字
- 没有模型的 Django 表单验证
Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。
