<a id="Header1_HeaderTitle" class="headermaintitle HeaderMainTitle" href="https://www.cnblogs.com/apachecn">龙哥盟

Python 解包元组字典

在 Python 中要解包一个字典并转换成一个元组，我们可以使用 tuple() 方法。解包意味着将一个字典实现为一个函数调用。

源代码:

my_dictionary = {'George' : 17, 'John' : 19, 'Micheal' : 13}

new_val = tuple(my_dictionary)
print(new_val)

下面是以下代码的截图

Python unpack dictionary of tuples

检查如何将字典元素解包为元组的另一个示例

通过使用 '=' 操作符和多个变量，我们可以很容易地解决这个问题。在本例中，我们向给定的字典声明逗号分隔的变量，并将它们存储在“count_dict”变量中。

举例:

count_dict = {'Afghanistan' : 19, 'colombia' : 14, 'srilanka' : 36}

z, l, m = count_dict
new_val_key = z, l, m
print(new_val_key)

下面是以下给定代码的输出

Python unpack dictionary of tuples method

这就是如何将字典键解包到一个元组中。

阅读: Python 字典删除

Python 迭代字典元组

在这一节中，我们可以看到如何在 Python 中迭代字典。在这个例子中，键是一个元组，值是整数。现在我们将使用 dict()方法，它接受元组列表上的 for 循环实例。

源代码:

new_tup = dict({
  ('m', 'n'): 18,
  ('y', 'z'): 28
})

for new_key, new_val in new_tup.items():
   print("iterate dictionary:",new_key,  " - ", new_val)

下面是以下给定代码的实现

Python iterate dictionary tuple

阅读: Python 字典长度

Python 用元组键迭代字典

在 Python 中，要使用元组键遍历字典，我们可以很容易地使用 for 循环方法来访问字典中可用的每个元素。
在这个例子中，为了迭代元组键，我们可以应用 append 方法并传递参数‘you _ dict’。现在，它将迭代这个变量名为‘new _ val’的元组列表。

源代码:

i, j, k = "i", "j", "k"
you_dict = {(17, i): 237, (17, k): 789, (19, j): 851}
new_val = list()

num = 0 
for i in you_dict:
    new_val.append(list(i[1])) 
    new_val[num].append(you_dict[i]) 
    num += 1
new_val = dict(new_val) 
print("iterate tuple keys",new_val)

下面是以下给定代码的输出

Python iterate dictionary with tuple key

阅读: Python 字典初始化

Python 访问字典中的元组

让我们看看如何在 Python 字典中访问元组。
这里我想访问字典中的元组值。要完成这项任务，首先我必须用一个惟一键和一个包含三个值的元组初始化一个字典。现在我想迭代每个键，为此我们可以使用 dict()方法中的 item，这个函数不带任何参数。它总是返回所有字典元素的列表。

源代码:

my_new_dictionary = {"zxy":(16,19,14), "ukh":(18,19,28), "loq":(15,19,23)}

for item in my_new_dictionary:
    print ("Access tuple values:",item[1])
    print (item[2])
    print (item[0])

下面是以下给定代码的执行过程

Python access tuple in the dictionary

Python 字典追加元组

让我们看看如何在 Python 字典中将存储多个值的元组添加到单个键中。
在本例中，您只需将您的键映射到一个列表，并将元组添加到该列表中。为了执行这个特定的任务，我们将创建一个字典并分配一个键值元素，但是在本例中，值代表列表。现在声明一个变量，并使用 append 函数在字典中添加一个元组。

举例:

student_dict = {'johnson': [(67,89,24)]}

b = student_dict['johnson'].append((123,173,992))
print("append tuple in dictionary",student_dict)

下面是以下代码的截图

Python dictionary append a tuple

阅读: Python 字典排序

Python 字典到元组数组

让我们看看如何将 Python 字典转换成元组数组。
在这个例子中，首先我们将创建一个字典，并为它们分配键值对。现在声明一个变量' new_arr ，并将 new_key 和 new_val 变量作为元组参数传递。要将字典转换成元组数组，可以使用列表理解方法。

源代码:

my_new_dict = { 'i': 189, 'o': 149, 'z': 216 }

new_arr = [(new_key, new_val) for new_key, new_val in my_new_dict.items()]
print("Dictionary to tuple array",new_arr)

下面是以下代码的截图

Python dict to tuple array

您可能还想阅读以下文章:

在本 Python 教程中，我们讨论了元组的 Python 字典。在这里，我们还介绍了以下示例:

Python 字典元组列表
Python 字典元组作为键
Python 字典 vs 元组
Python 字典元组值
Python 创建元组字典
Python 元组排序字典
命名元组的 Python 字典
Python 解包元组字典
如何在字典 python 中添加元组作为键
Python 迭代字典元组
带元组键的 Python 迭代字典
字典中的 Python 访问元组
Python 字典追加元组
Python 字典到元组数组

Python 是美国最流行的语言之一。我从事 Python 工作已经有很长时间了，我在与 Tkinter、Pandas、NumPy、Turtle、Django、Matplotlib、Tensorflow、Scipy、Scikit-Learn 等各种库合作方面拥有专业知识。我有与美国、加拿大、英国、澳大利亚、新西兰等国家的各种客户合作的经验。查看我的个人资料。

Python 字典 pop

原文：https://pythonguides.com/python-dictionary-pop/

在本 Python 教程中，我们将讨论 Python 字典 pop。这里我们还将涵盖下面的例子:

Python 字典弹出方法
Python 字典流行示例
Python 字典 pop vs del
Python 字典弹出多个键
Python 字典 pop vs popitem
Python 字典 pop 键和值
Python 字典 pop(如果存在)
Python 字典流行项目
Python 字典弹出最后一个元素
Python 字典在迭代期间弹出
列表中的 Python 流行词典

Python 字典流行
Python 字典弹出方法
Python 字典 pop vs del
Pop()方法示例
Python 字典弹出多个键
- 如何移除 Python 字典中多个键的替代示例
Python 字典 pop vs popitem
Pop()方法示例
Python 字典 pop 键和值
Python 字典弹出如果存在
Python 字典弹出项
Python 字典弹出最后一个元素
Python 字典在迭代期间弹出
列表中的 Python 流行词典

Python 字典流行

在 Python 中要从字典中删除一个元素，我们可以应用 pop() 方法。这个方法检查条件，如果一个键或值不包含在字典中，那么它返回一个键错误，否则如果字典中有一个键，它将删除一个项并返回它的值。
pop() 方法是 Python 中的内置函数，它从字典中删除指定的键或值。

语法:

下面是字典 pop() 方法的语法

dict.pop(key,default)

该方法由几个参数组成:
- Key:Key 参数用于从字典中删除。
- Default: 如果字典中没有这个键，那么它将返回默认值。

Return:pop()方法返回

如果存在一个键，从字典中取出元素
如果在参数中没有指定默认值，那么它将引发一个键错误

源代码:

让我们举一个例子，看看如何使用 pop() 方法从字典中删除一个元素

my_dict = {'george':92,'john':14,'Micheal':25}

rem_key = my_dict.pop('john')
print("remove key",rem_key)
print(my_dict)

下面是以下代码的截图

python dictionary pop

阅读: Python 字典包含

Python 字典弹出方法

dictionary pop() 方法帮助用户从字典中删除关键元素并返回其值。

让我们举一个例子，检查字典中是否没有某个键

new_dictionary = {'China':234,'Africa':145,'Australia':178}

new_key = new_dictionary.pop('Germany')
print(new_key)

在上面的代码中，我们已经初始化了一个字典，并将元素以键值对的形式放置。在本例中，我们将检查字典中是否没有某个键。为了解决这个问题，我们可以使用 pop() 方法来检查条件。如您所见， pop() 方法将一个键作为参数传递，但是字典中没有‘德国’键，这引发了一个键错误。

下面是以下给定代码的执行过程

Python dictionary pop method

阅读: Python 字典理解

Python 字典 pop vs del

pop() 和 del() 的主要区别在于

在 Python 中‘del’是关键字， pop() 是方法。在 del() 的情况下，它不返回任何值，而在 pop()方法的情况下，如果我们想从字典中删除一个键，可以使用 pop() ，它将返回值。
在 pop()方法中，如果你没有提到 pop()方法参数中的最后一个参数，那么它将返回一个键错误。而在 del()的情况下，如果一个键不在字典中，那么它将返回一个键错误。
在 Python 中使用索引从列表中删除对象，我们可以很容易地使用' del '关键字和 pop()方法。
这两种方法的主要区别在于,' del '关键字不返回任何内容，而 pop()方法返回从字典中删除的元素。

语法:

下面是' del '关键字的语法

del dict["key"]

举例:

让我们举一个例子，检查如何在字典中使用 del 关键字

my_dict = {'Python':79,'java':26,'Sql':17}

del my_dict['java']
print(my_dict)

这里我们将创建一个程序，使用 del 关键字从字典中删除一个键。在这个例子中，我们必须从字典中删除一个‘Java’键。为了完成这项任务，我们将使用 del 关键字。

下面是以下给定代码的执行过程

python del keyword

阅读: Python 字典按值查找键

Pop()方法示例

源代码:

emplo_dict = [
	{ "emp_id": 26, "emp_name": "Oliva", "emp_age": 36, "emp_res": True },
	{ "emp_id": 98, "emp_name": "George", "emp_age": 42, "emp_res": True },
	{ "emp_id": 37, "emp_name": "james", "emp_age": 98, "emp_res": False }
]
for z in emplo_dict:
	new_key = z.pop("emp_res", None)

	if new_key != None:
		print("emp_res key has been deleted for the {} employee.".format(z["emp_name"]))
	else:
		print("No key has been deleted for the {} employee.".format(z["emp_name"]))

print(emplo_dict)

在上面的代码中，我们创建了一个包含三个字典的列表。每个字典存储四个键和值对。在本例中，我们想使用 pop()方法从字典中删除‘EMP RES’键。现在我们将使用 Python 中的‘if 语句’检查“EMP _ RES”键是否已经从字典中删除。让我们看看 new_key 是否有一个非 none 的值，这意味着我们的键被删除了。

下面是以下给定代码的执行过程

python pop example

Python 字典弹出多个键

在 Python 中要从字典中删除多个键，我们可以很容易地应用 pop()和 list comprehension 方法。
在这个例子中，我们只是使用 pop()方法从字典中删除一个元素。

举例:

让我们举一个例子，看看如何使用 pop()方法删除字典中的多个键

my_dictionary = {'Cyprus' : 1, 'Cuba' : 2, 'Africa' : 3, 'England' : 4, 'china' : 5}

mul_keys = ['Cuba', 'Africa', 'china']
[my_dictionary.pop(key) for key in mul_keys]
print(" Dictionary after Remove multiple keys : ",my_dictionary)

在上面的代码中，我们创建了一个字典并包含键值对元素。现在初始化一个列表，存储我们想要从字典中删除的元素。然后使用 list comprehension 方法迭代列表项并打印结果。

下面是以下代码的截图

Python dictionary pop multiple keys

阅读: Python 字典删除

如何移除 Python 字典中多个键的替代示例

这里可以看到 pop()和 for 循环方法的结合方法。这个方法帮助用户迭代变量的每个键。在这个例子中，元素从给定的键列表中删除。

new_dictionary = {'Egypt': 67, 'Estonia': 13, 'Geogria': 87, 'Hungary': 98};
rem_ele = ('Egypt', 'Estonia', 'Hungary');
for i in rem_ele:
    new_dictionary.pop(i);
print("Available dictionary after remove keys",new_dictionary);

下面是以下给定代码的输出

remove multiple keys using pop in python

阅读: Python While 循环条件

Python 字典 pop vs popitem

在 Python 中，这两种方法用于从字典中删除元素。 pop() 方法以键值对的形式删除元素，而如果我们想使用 popitem() 方法从字典中删除最后一个键值对元素。
在 python 中，3.7 版本从字典中删除了特定的最后一个键值对元素，并以元组的形式显示结果。
pop() 和 popitem() 的主要区别在于，pop()元素可以删除带有特定键的元素，而在 popitem()的情况下，我们将从字典中删除最后输入的元素。
在 popitem() 方法中，如果我们想要删除一个项目，但是字典是空的，那么它将产生一个错误，而在 pop()方法中，如果字典中没有这个键，它将显示一个键错误。

语法:

下面是 popitem()方法的语法

dictionary.popitem()

注意:它不接受任何参数

pop item()示例的源代码

new_dict = {'Mathew':56, 'Hayden':78, 'oliva': 27, 'gilchrist': 189}

output = new_dict.popitem()
print('Remove key = ', output)
print('New original dictionary: ', new_dict)

下面是以下给定代码的实现

Python dictionary pop vs popitem

阅读: Python 字典长度

Pop()方法示例

源代码:

you_dict = {
  'student_id': 78,
  'stu_post': 'Python developer'
}

rem_key = you_dict.pop('stu_post', None)
print(rem_key)
print("Dictionary after remove key",you_dict)

在上面的代码中，我们必须在一个 dictionary.pop() 方法中使用两个参数。在本例中，我们将检查字典中是否存在该键，如果不存在，将删除该元素，否则将显示 None。

下面是以下给定代码的输出

python dict pop vs popitem method

Python 字典 pop 键和值

在 Python 中要从字典中移除键和值对，我们可以应用 pop() 方法。
为了解决这个问题，我们首先创建一个字典，并为它们分配键值对元素。现在使用 pop() 方法从字典中删除一个特定的键值对。

语法:

下面是 pop() 方法的语法

dict.pop(key[, default])

源代码:

my_new_dict = {"b":18,"c":10,"u":19,"r":67}

delete_key = my_new_dict.pop("c")
print("Original dictionary",my_new_dict)
print("Remove key-value pair",delete_key)

执行:

Python dictionary pop key and value

Python 字典弹出如果存在

让我们看看如何检查一个键是否包含在 Python 字典中。
如果指定的键在字典中不可用，并且在 pop() 方法参数中没有默认值，那么它将引发一个键错误。
让我们举一个例子，检查如何通过使用 pop() 方法删除字典中不存在的元素，我们还将检查如果我们没有在 pop() 方法参数中传递默认值，将会发生什么。

源代码:

you_dictionary = {"v":14,"s":10,"z":190,"l":167}

remov_new_key = 'q'
if remov_new_key in you_dictionary:
    you_dictionary.pop(remov_new_key)
else:
    print("Key not exist in dictionary:",remov_new_key)

下面是以下给定代码的输出

Python dictionary pop if exists

阅读: Python 字典初始化

Python 字典弹出项

在 Python 字典中， popitem() 方法删除一个元素，并将其返回为元组对形式。在 popitem() 方法中，它总是以后进先出的顺序返回，这意味着 i t 从字典中删除特定的最后一个键值对元素。

举例:

让我们举个例子，看看如何使用 popitem() 方法从 Python 字典中删除一个元素

stdent_dict = {'George': 46, 'John':345, 'Micheal': 169, 'Potter': 543}  

b = stdent_dict.popitem()  
print("Delete last pair",b)  
print("New dictionary",stdent_dict)

下面是以下给定代码的实现

Python dictionary pop item

阅读: Python 字典过滤器

Python 字典弹出最后一个元素

要从 python 字典中删除最后一个元素，我们可以很容易地使用 pop() 方法。

源代码:

my_dictionary = {'e':189,'h':192,'f':223}

rem_las = my_dictionary.pop('f')
print("remove last element",rem_las)
print(my_dictionary)

在上面的代码中，我们初始化了一个字典，并以键值对的形式放置元素。在这个例子中，我们将检查如何从字典中删除最后一个元素。为了解决这个问题，我们将声明一个变量‘rem _ las’并分配一个 pop 方法，在该方法中我们传递一个关键元素参数‘f’。现在，它将检查字典中是否存在该关键字。它将显示从字典中删除最后一个元素的结果。

下面是以下代码的截图

Python dictionary pop last element

阅读: Python 字典排序

Python 字典在迭代期间弹出

使用 pop()方法迭代 python 字典并删除项目。

举例:

to_dict = {"j":14,"n":16,"l":12,"z":15}
for new_key in dict(to_dict):
    if to_dict[new_key] % 2 == 0:
        to_dict.pop(new_key)
print(to_dict)

在这个例子中，你可以看到我们已经迭代了所有的键-值对，如果值是偶数，它将从字典中删除，而在奇数元素中，它将显示在输出中。

下面是以下代码的截图

Python dictionary pop during iteration

阅读: Python 字典值列表

列表中的 Python 流行词典

在 Python 中要从字典列表中删除元素，我们可以应用 del 和 loop 方法。
在这个例子中，它将比较条件，如果键值在字典中可用，它将删除整个字典对。

源代码:

student_list = [{"student_id" :56, "address" : "England"},
             {"student_id" : 78, "address" : "Germany"},
             {"student_id" :923, "address" : "France"}]

for m in range(len(student_list)):
    if student_list[m]['student_id'] == 923:
        del student_list[m]
        break
print ("List after remove: ",student_list)

Python pop dictionary from the list

您可能也喜欢阅读以下文章:

在本 Python 教程中，我们将讨论 Python 字典 pop。在这里，我们还将介绍以下示例:

Python 字典弹出方法
Python 字典流行示例
Python 字典 pop vs del
Python 字典弹出多个键
Python 字典 pop vs popitem
Python 字典 pop 键和值
Python 字典 pop(如果存在)
Python 字典流行项目
Python 字典弹出最后一个元素
Python 字典在迭代期间弹出
列表中的 Python 流行词典

如何在 Python 中从字典中移除键

原文：https://pythonguides.com/python-dictionary-remove/

在本 Python 教程中，我们将讨论 Python 字典移除。我们还将检查，如何用 Python 从字典中删除键？在这里，我们还将介绍以下示例:

Python 字典移除键
Python 字典移除重复的键
Python 字典移除元素
Python 字典移除最后一个键
Python 字典移除键值对
Python 字典移除空值
Python 字典基于值移除键
Python 字典不移除任何值
Python 字典移除重复值
Python 字典移除值

Python 字典删除
Python 字典移除键
通过使用 del 关键字从字典中删除一个键
利用字典理解和 item()方法
Python 字典删除重复键
Python 字典删除元素
Python 字典删除最后一个键
Python 字典移除键值对
Python 字典删除空值
Python 字典基于值移除键
Python 字典删除无值
Python 字典删除重复值
Python 字典删除值

Python 字典删除

让我们看看如何在 Python 中移除字典。
在 Python 中，clear()方法用于删除字典 Python。
该方法删除字典中所有可用的键值对，并总是返回一个 none 值或空字典。

语法:

下面是 clear() 方法的语法

dict.clear()

举例:

让我们举一个例子，看看如何在 Python 中删除字典

my_dict = {'john':3,'George':6,'Smith':9,'Brown':6}
b = dict.clear(my_dict)
print("Remove dictionary:",b)

下面是以下给定代码的示例

Python dictionary remove

阅读: Python 字典长度

Python 字典移除键

这里我们可以看到如何用 Python 从字典中删除一个键。
要在字典中删除一个键，有多种方法可以完成这项任务。
从字典中删除键的方法如下
- 通过使用 pop()方法
- 通过使用 del 关键字
- 通过使用字典理解和 item()方法

例子:

让我们举一个例子，看看如何使用 pop()方法从字典中删除一个键。

在 Python 中，pop()方法可用于从字典中移除键和值。此方法可用于从特定索引值中移除一项。pop()方法只接受一个参数，即我们想要从字典中删除的键的名称。

代码:

my_dict = {'Australia':250,'Germany':650,'Japan':900,'England':500}
rem_key = my_dict.pop('Germany')

print("Remove Key from dictionary:",rem_key)
print(my_dict)

下面是以下代码的截图

Python dictionary remove key

通过使用 del 关键字从字典中删除一个键

在 python 中，del 关键字可用于删除字典中可用的对象或项目。
如果字典中没有键，此方法将引发键错误。

代码:

my_dict = {'U.S.A':450,'China':320,'Japan':680,'Polland':500}
del my_dict['Japan']

print("Remove a key from dictionary:",my_dict)

下面是以下给定代码的执行过程

Python dictionary remove the key from del

阅读: Python 字典初始化

利用字典理解和 item()方法

在 Python 中，items()和 dict comprehension 也可以帮助用户从字典中删除一个键。
items()方法不带参数，总是返回一个要存储在列表中的条目。
Dict comprehension 主要用于通过包含所有键值对来创建字典。

让我们举一个例子，检查如何使用 dict comprehension 和 items()方法从字典中删除一个键

to_dict = {"Mangoes" : 40, "Grapes" :29, "Oranges" : 39, "Apple" : 49}

new_key = {key:val for key, val in to_dict.items() if key != 'Grapes'}

print ("Remove after key is :",(new_key))

下面是以下代码的截图

Python dictionary remove the key from dict comprehension

Python 字典删除重复键

这里我们可以看到如何用 Python 从字典中删除重复的键。
通过使用 loop 和 items()方法，我们可以很容易地从字典中删除重复的条目。
首先在这个例子中，我们将初始化一个字典并使用循环删除字典中的重复键，这个方法将从我们的字典中删除任何重复的值。

举例:

让我们举一个例子，看看如何从字典中删除重复的键

my_dictionary = { 'John' : 20, 'George' : 45, 'james' : 10, 'George' : 60, 'potter' : 70}

new_key = []
output = dict()
for new_k, new_val in my_dictionary.items():
    if new_val not in new_key:
        new_key.append(new_val)
        output[new_k] = new_val

print("Remove duplicate key is:",output)

下面是以下代码的截图

Python dictionary remove duplicate keys

这是如何在 Python 中从字典中删除重复的键。

又念: Python 字典过滤器

Python 字典删除元素

让我们看看如何从字典中去掉一个柠檬。
通过使用 dict.keys 方法和 del 关键字，我们可以很容易地从字典中删除一个元素。
dict.keys()方法总是返回一个显示字典中键的列表的项目。现在创建一个 for 循环来迭代字典中的条目。
在这个例子中，创建一个变量“selected_key ”,并给它们分配一个我们必须从字典中删除的 key 元素。使用 del 关键字并检查索引值，然后调用 break 语句。

举例:

让我们举一个例子，看看如何从字典中删除一个元素

my_dict = {"Italian": 9, "Chinese" : 12, "Mexican": 7}

select_key = "Chinese"
new_key ="Italian"
for n_key in my_dict.keys():
  if n_key == select_key:
    del my_dict[n_key]
    break
for n_key in my_dict.keys():
  if n_key == new_key:
    del my_dict[n_key]
    break
print("Remove element from dictionary",my_dict)

下面是以下代码的截图

Python dictionary remove element

这是如何在 Python 中从字典中移除元素。

检查如何从字典中删除元素的另一个例子

在这个例子中，我们可以很容易地使用 pop()方法从字典中删除一个元素。首先，我们将创建一个员工列表并存储两个字典。每本词典包含三个关键字。现在我们必须使用 pop() 方法从字典中删除一个元素。

举例:

employee_info = { "emp_id": 234, "emp_name": "Adam", "emp_address": "England" }

new_key = employee_info.pop("emp_address")
print(new_key)
print("Remove element from dictionary",employee_info)

下面是以下代码的截图

Python dictionary remove element pop

阅读: Python 字典值列表

Python 字典删除最后一个键

让我们看看如何用 Python 删除字典中的最后一个键。
在这个例子中我们可以很容易地使用 items()和 for 循环方法从字典中删除最后一个键。

举例:

让我们举一个例子，看看如何从字典中删除最后一个键

my_dict = {"Steve": 234,"Mark": 134,"Robert": 278,"Chris": 43}
remove_key = 'Chris' # last key
to_dictionary = {}
for new_key, new_value in my_dict.items():
    if new_key is not remove_key:
        to_dictionary[new_key] = new_value
my_dict = to_dictionary
print(" Remove last key from dictionary:",my_dict)

下面是以下代码的截图

Python dictionary remove the last key

检查如何从字典中删除最后一个键的另一个例子

在这个例子中，我们可以很容易地使用 pop.item()方法从字典中删除最后一个键。

举例:

new_dictionary = {"Andrew": 120,"Hayden": 140,"Mathew": 210,"Gilchrisht": 174}
rem_key = new_dictionary.popitem()

print("remove last key:",rem_key) # remove last key
print(new_dictionary)

下面是以下代码的截图

Python dictionary remove the last key

阅读: Python 字典更新

Python 字典移除键值对

这里我们可以看到如何从 Python 字典中移除键值对。
通过使用 del 关键字，我们可以从字典中删除键值对。

举例:

让我们举一个例子，看看如何从字典中删除键值对

my_dict = {"a": 120,"b": 30,"c": 150,"d": 143}
del my_dict["b"]

print("remove key-value pair:",my_dict)

下面是以下代码的截图

Python dictionary remove key-value pair

检查如何从字典中删除键值对的另一个例子

通过使用 popitem()方法，我们可以很容易地从字典中删除键值对。
在 python 中，popitem()方法不带任何参数。此方法用于从字典中移除随机元素，并始终返回其值。

语法:

下面是 popitem()方法的语法

dict.popitem()

举例:

my_dict = {"m": 60,"n": 40,"o": 10,"p": 14}
new_item = my_dict.popitem()

print("remove key-value pair:",new_item)
print(my_dict)

下面是以下代码的截图

Python dictionary remove key-value pair

这就是如何在 Python 中从字典中删除键值对。

阅读: Python 串联词典

Python 字典删除空值

让我们看看如何用 Python 从字典中删除空值。
通过使用列表理解方法，我们可以很容易地完成这项任务。

举例:

to_dict = [{"u": 10,"v": 50,"p": '',"z":''}]
output = [element for element in ({new_key: new_val for new_key, new_val in sub.items() if new_val} for sub in to_dict) if element]

print("Remove empty values: ",output)

首先在上面的例子中，我们将初始化一个列表，并通过使用列表理解删除空值。

下面是以下代码的截图

Python dictionary remove empty values

Python 字典基于值移除键

在这里，我们可以看到如何从 Python 字典中删除基于键的值。
通过使用字典理解和 items()方法，我们可以很容易地删除基于值的键。

举例:

my_dict = {"u" : 12, "d" :16, "e" : 19, "f" : 15}

rem_key = {n_key:n_val for n_key, n_val in my_dict.items() if n_val != 19} # selected value

print ("Remove after key based on value is :",(rem_key))

下面是以下代码的截图

Python dictionary remove key based on the value

这就是如何根据值移除键

又念: Python 字典追加

Python 字典删除无值

让我们看看如何在 Python 中从字典中删除 none 值。
通过使用 for 循环和列表理解方法，我们可以很容易地从字典中删除任何值。
在这个例子中，我们将首先初始化一个列表，并使用列表理解方法来检查键值对是否不存在或者不在字典中

举例:

让我们举一个例子，看看如何从字典中删除 none 值

to_dict = {'t': 40, 's': 30,'d':None,'n':None}

output = []
for value in to_dict:
    if to_dict[value] is not None :
        output.append(value)

print(output)

下面是以下代码的截图

Python dictionary remove none values

Python 字典删除重复值

要从 Python 字典中删除重复值，我们可以很容易地使用字典理解方法。

举例:

让我们举一个例子，看看如何从字典中删除重复的值

my_dictionary = {'Australia': 20, 'Switzerland': 30,'Newzeland':30,'Moscow':70}

new_element = {new_val : new_key for new_key, new_val in my_dictionary.items()}
new_output = {new_val : new_key for new_key, new_val in new_element.items()}
print(new_output)

下面是以下代码的截图

Python dictionary remove duplicate values

Python 字典删除值

让我们看看如何用 Python 从字典中删除一个值。
通过使用 dict comprehension 和 items()方法，我们可以很容易地从字典中删除值。
items()方法总是返回字典的一个对象。该对象是键值元组的集合。items()方法不接受任何参数。
Dict comprehension 主要用于通过包含所有键值对来创建字典。

举例:

让我们举一个例子，看看如何从字典中删除一个值

dictionary = {"a" : 40, "z" :29, "c" : 39, "v" : 49}

rem_value = {new_key:new_val for new_key, new_val in dictionary.items() if new_val != 49}

print ("Remove after value is :",(rem_value))

下面是以下代码的截图

Python dictionary remove the value

这是如何在 Python 中从字典中删除一个值

你可能也喜欢阅读以下内容。

在本 Python 教程中，我们将讨论 Python 字典移除。在这里，我们还将介绍以下示例:

Python 字典移除键
Python 字典移除重复的键
Python 字典移除元素
Python 字典移除最后一个键
Python 字典移除键值对
Python 字典移除空值
Python 字典基于值移除键
Python 字典移除重复值
Python 字典不移除任何值
Python 字典移除值

Python 字典按值搜索

原文：https://pythonguides.com/python-dictionary-search-by-value/

在这个 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 字典中通过值获取键。
为了执行这个特定的任务，我们将使用 dict.items() 方法，这个函数返回一个对象，该对象是一个由键值元组组成的集合。
为了通过值获取 key 元素，我们将使用 dict.get() 方法，该方法返回指定键的值。

语法:

让我们来看看语法，了解一下 Python 中 dict.items() 函数的工作原理。

dict.items()

注意:这个参数不包含任何参数，返回的是一个字典视图。

举例:

让我们举一个例子，检查如何通过在 Python 字典中搜索值来获得键。

源代码:

country_name = {'USA': 56, 'Germany': 25,'France':78}

result= dict((new_val,new_k) for new_k,new_val in country_name.items()).get(25)
print("Dictionary search by value:",result)

下面是下面给出的代码的截图。

Python dictionary search by value

正如您在截图中看到的，输出根据给定值显示了‘德国’键。

阅读: Python 字典键错误

Python 字典按值查找

在这个程序中，我们将讨论如何在 Python 字典中按值查找键。
为了完成这项任务，我们将使用字典理解方法，我们可以通过搜索值轻松获得关键元素。
在 Python 中， dictionary comprehension 用于在字典上运行 for 循环，它将返回一个新的字典。

举例:

我们举个例子，检查如何在 Python 字典中按值查找键。

源代码:

my_dictionary = {'Newzealand': 567,
            'United Kingdom' : 456,
            'China': 945,
            'Japan': 845
            }
new_val = 945
result=[new_k for new_k in my_dictionary.items() if new_k[1] == new_val][0][0]
print(result)

在下面给定的代码中，我们创建了一个名为‘my _ dictionary’的字典，然后声明了一个变量‘new _ val’，它表示我们想要对其进行操作的值。之后我们使用了字典理解的方法，并设置了条件 ifnew _ k[1]= = new _ val[0][0]。

下面是以下给定代码的执行。

Python dictionary lookup by value

阅读: Python 字典计数+实例

Python 字典通过键查找值

在这个程序中，我们将讨论如何在 Python 字典中通过键查找值。
通过使用 dict.get() 函数，我们可以很容易地通过字典中给定的键获得值。这个方法将检查条件，如果没有找到关键字，那么它将返回 none 值，如果给定了关键字，那么它将指定值。
这个方法有两个参数，一个是要搜索的键，另一个是要返回的默认值。

语法:

让我们来看看语法，了解一下 Python dict.get() 函数的工作原理。

dict.get
        (
         key,
         default=None
        )

举例:

让我们举个例子，检查一下如何在 Python 字典中通过键找到值。

源代码:

new_dict={'George':567,'James':145,'Micheal':678,'Oliva':234}

result= new_dict.get('Oliva')
print("Get value from key:",result)

下面是以下给定代码的执行。

Python dictionary find value by key

阅读: Python 字典重复键

Python 通过列表中的值查找字典

在这一节中，我们将讨论如何在 Python 列表中按值查找字典。
为了执行这个特定的任务，首先，我们将创建一个字典列表，其中包含以键值对形式的元素。接下来，我们将声明一个变量‘结果’，并使用字典理解方法。
在这个例子中，我们必须从给定的字典列表中获取字典。为了完成这个任务，我们将设置一个条件，如果指定的键等于 value，那么它将返回一个字典。

举例:

new_dictionary = [
     { "Student_name": "George", "Student_id": 156 },
     { "Student_name": "Oliva", "Student_id": 278 },
     { "Student_name": "James", "Student_id": 456 },
     { "Student_name": "William", "Studemt_id": 782 }
 ]

result=next(z for z in new_dictionary if z["Student_name"] == "James")
print(result)

下面是下面给出的代码的截图。

Python find dict by value in a list

阅读: Python 字典增量值

Python 字典按值查找索引

在这一节中，我们将讨论如何在 Python 字典中按值查找索引。
我们已经在 Python 字典索引文章中讨论过这个主题。你会得到关于这个话题的所有信息。

Python 字典查找最大值

在本期节目中，我们将讨论如何在 Python 字典中找到最大值。
为了完成这个任务，我们将使用 max() 函数来查找给定字典中的最大值
为了从字典中获取值，我们将使用 dictionary.get() 方法，它将返回该值。

举例:

new_dictionary = {"USA": 167, "Germany": 278, "Japan": 678}

result = max(new_dictionary, key=new_dictionary.get)
print("Maximum value:",result)

在上面的代码中，我们用不同的键和值创建了一个字典。现在我们必须从字典中计算最大值。为了执行这个任务，我使用了 max() 函数和 dict.get() 方法，它将返回最大值。

下面是下面给出的代码的截图。

Python dictionary find max value

阅读: Python 字典扩展

Python 字典查找最小值

在本期节目中，我们将讨论如何在 Python 字典中寻找最小值。
为了完成这个任务，我们将使用 min() 函数，这个函数将帮助用户从字典中获取最小值。

获取有关如何在字典中查找最小值的更多信息。可以参考我们的详细文章 Python 在字典中查找最大值。

举例:

country_name = {"United kingdom": 567, "France": 167, "Spain": 554}

result = min(country_name, key=country_name.get)
print("Minimum value:",result)

下面是以下给定代码的实现

Python dictionary find the minimum value

Python 字典查找和替换值

在本期节目中，我们将讨论如何替换 Python 字典中的值。
为了完成这项任务，我们首先创建了一个名为‘new _ dictionary’的字典，它包含了键值对形式的元素，然后我们将设置并更新键值。
一旦执行了这段代码，输出将显示指定键的新值。

举例:

让我们举个例子，看看如何替换 Python 字典中的值。

源代码:

new_dictionary  =  {
   'George': 156,
   'James': 278,
   'William':134
}
new_dictionary['George'] = 189  
print(new_dictionary)

你可以参考下面的截图。

Python dict find and replace values

阅读: Python 字典多键

Python 字典查找唯一值

在本节中，我们将讨论如何在 Python 字典中查找唯一值。
为了从字典中获取唯一值，我们将使用 set() 方法和 dict.values() 方法。在 Python 中， set() 方法必须是唯一的，它从我们也可以用来执行数学运算的对象中移除所有重复的元素。
在 Python 中， dict.values() 方法将帮助用户从字典中提取值。

举例:

让我们举个例子，检查一下如何在 Python 字典中找到唯一值。

源代码:

new_dictionary = {'USA' : 586,
   'United Kingdom' : 9872,
   'France' : 586,
   'Germany' : 234,
   'Newzealand' :189}

print("Original dictionary:",new_dictionary)
result=set(new_dictionary.values())
print("Unique values from dictionary:",result)

在下面给定的代码中，我们创建了一个字典“new_dictionary”。之后，我们使用了 set()函数，它将从字典中获取唯一的值。

下面是以下给定代码的执行。

Python dictionary find unique values

阅读: Python 字典转 CSV

Python 字典列表按值搜索

在本期节目中，我们将讨论如何在 Python 中查找字典列表中的值。
在这个特定的任务中，我们将使用 dict.get() 方法，在这个方法中，我们已经设置了条件，如果给定值在字典列表中可用，那么它将返回字典。

语法:

让我们看一下语法，了解一下 dict.get() 方法的工作原理。

dict.get(key[, value])

举例:

让我们举个例子，看看如何在字典列表中找到值。

源代码:

new_dictionary = [{'George':145,'Oliva':245},
                {'William':567,'John':234},
                {'Micheal':234,'james':567}]

print("Original dictionary:",new_dictionary)
new_result = next((m for m in new_dictionary if m.get('John') == 234), None)
print("Get dictionary from searching value:",new_result)

在上面的例子中，我们已经创建了一个字典，然后我们使用字典理解方法，其中我们已经设置了条件 if m.get('john')==234 。

下面是下面给出的代码的截图。

Python list of dictionaries search by values

阅读: Python 将字典转换为数组

Python 在字典中查找特定值

这里我们要检查如何在 Python 字典中找到具体的值。
为了执行这个特定的任务，我们将使用 dict.get() 方法并分配 key 元素。一旦执行了这段代码，输出将显示给定的指定键的值。

举例:

new_dictionary={'Student_name': 'George', 'Student_id': 156,'Student_age':745}

result= new_dictionary.get('Student_id')
print(result)

下面是以下给定代码的输出。

Python find specific value in the dictionary

阅读: Python 元组字典

Python 字典查找重复值

这里我们将讨论如何在 Python 字典中找到重复值。
首先，我们将创建一个字典，然后我们将使用 dict.items() 方法。
接下来，我们将设置条件，如果值包含在空字典中，那么它将等同于一个关键字元素，否则它将追加关键字值。

举例:

让我们举一个例子，看看如何在 Python 字典中找到重复值。

源代码:

new_dictionary = {'Grapes':245, 'Apple':567, 'Mangoes': 156, 'Oranges': 567}

empty_dict = {}
for new_k, new_val in new_dictionary.items():
   if new_val not in empty_dict:
      empty_dict[new_val] = [new_k]
   else:
      empty_dict[new_val].append(new_k)
print("Duplicate values in dictionary:",empty_dict)

下面是以下给定代码的实现

Python dictionary find duplicate values

你可能也喜欢阅读以下关于 Python 的教程。

在本 Python 教程中，我们使用 Python 中的一些例子研究了通过值进行的 Python 字典搜索。此外，我们还讨论了这些主题。

Python 字典按值搜索
Python 字典按值查找
Python 字典通过键查找值
Python 通过列表中的值查找字典
Python 字典按值查找索引
Python 字典查找最大值
Python 字典查找最小值
Python 字典查找和替换值
Python 字典查找唯一值
Python 字典列表按值搜索
Python 在字典中查找特定值
Python 字典查找重复值

Python 字典排序(11 个示例)

原文：https://pythonguides.com/python-dictionary-sort/

在本 Python 教程中，我们将讨论 Python 字典排序。我们将在这里看到，如何在 python 中排序字典，如何在 Python 中按键和值排序字典，以及下面的例子:

Python 字典按值排序
Python 字典按关键字排序
Python 字典按值降序排序
Python 字典按字母顺序按值排序
Python 字典按字母顺序按关键字排序
Python 字典反向排序
Python 字典按键值排序
用 lambda 进行 Python 字典排序
Python 字典按字母顺序排序
Python 字典按值列表排序
Python 先按值再按键对字典进行排序
Python 字典排序的最快方法

如何在 Python 中对字典进行排序
检查 Python 字典排序–另一种方法
Python 字典按值排序
Python 字典按值排序——另一个例子
Python 字典按关键字排序
如何在 Python 中对字典键进行排序——另一种方法
Python 字典按值降序排序
Python 字典按字母顺序值排序
Python 字典按字母顺序键排序
Python 字典排序反转
如何颠倒 Python 字典中键的顺序
Python 字典按键值排序
Python 字典用 lambda 排序
Python 字典按字母顺序排序
Python 字典按值列表排序
Python 按值排序字典，然后按键排序
Python 最快的字典排序方式

如何在 Python 中对字典进行排序

Python 中的 sorted() 是内置函数，可以帮助对 Python 字典中的所有可重复项进行排序。
为了对值和键进行排序，我们可以使用 sorted()函数。这个排序函数将返回一个新的列表。

语法:

下面是 sorted() 函数的语法。

sorted
      (
       iterable,
       Key=None,
       reverse=False
      )

它由几个参数组成
- iterable: 这个函数可以按升序用在所有的 iterable 上。
- 键:如果您想修改分类过程，那么您可以使用此键功能，默认情况下，其值为无。
- reverse: 这里可以看到 reverse=False。这是升序排列，如果你想让数字按降序排列，那么你可以将这个反向标志顺序设置为真
注意:如果您决定不使用可选参数键并反转。Python 会自动按升序对项目进行排序。

举例:

让我们举一个例子来检查如何在 Python 中对字典进行排序

dict = {6:'George' ,2:'John' ,1:'Potter' ,9:'Micheal' ,7:'Robert' ,8:'Gayle' }  

b = sorted(dict.keys())
print("Sorted keys",b)  

c = sorted(dict.items())
print("Sorted Values",c)

写完上面的代码后，我们必须对字典中可用的值和键进行排序。在 python 中，提供了内置函数 key()和 items()来对字典进行排序。我们可以应用这些函数 iterable 作为参数，并返回一个新的排序列表。

下面是以下代码的截图

Python dictionary sort

这就是如何在 Python 中对字典进行排序。

阅读 Python 字典附加示例

检查 Python 字典排序–另一种方法

假设我们有一个 Python 的字典，其中包含我们水果菜单上的元素。所以现在我们想按照值和键的降序对有序字典进行排序。在本例中，我们必须使用反向参数，并为它们赋值 true。

举例:

让我们举一个例子来检查如何用逆向方法对 Python 中的字典进行排序

dict = {"Mangoes":200,"Banana":900,"Cherry":700,"Grapes":400} 

new_list = sorted(dict.items(), key=lambda x: x[1], reverse=True)

for i in new_list:
	print(i[0], i[1])

下面是以下代码的截图

Python dictionary sort by reverse method

这是如何用 Python 对字典进行排序。

阅读如何用 Python 将字典转换成 JSON

Python 字典按值排序

现在我们可以看到如何用 Python 对字典值进行排序。通过使用 sorted()函数，可以对字典中的值进行排序。
在这个例子中，我们可以使用 items()和 sorted()函数对值进行排序
在 python 字典中，有各种方法对值进行排序
- 按降序排序
- 按升序排序

举例:

让我们举一个例子，看看如何在 python 中对字典值进行降序排序。

dict = {"Python":750,"Java":950,"Ruby":700,"C++":200} 

sort_values = sorted(dict.items(), key=lambda y: y[1], reverse=True)

for i in sort_values:
	print(i[0], i[1])

下面是以下代码的截图

Python dictionary sort by value

这是一个按值排序的 Python 字典的例子。

Python 字典按值排序——另一个例子

现在我们将检查如何使用 sorted 函数在 Python 中按值对字典进行排序。

举例:

my_dict = {"Australia":250,"Germany":950,"France":170,"England":150} 

new_list = sorted(my_dict.items(), key=lambda x:x[1])
sort_values = dict(new_list)
print(sort_values)

在上面的代码中，您可以检查它是否返回一个按升序排序的新列表。

下面是以下代码的截图

Python dictionary sort by values using the sorted method

这是一个按值排序的 Python 字典的例子。

阅读 Python 串联词典+示例

Python 字典按关键字排序

让我们看看如何在 Python 中对字典键进行排序。
为了在 python 中对字典键进行排序，我们可以使用 dict.items() 和 sorted(iterable) 方法。
方法返回一个存储字典键值对的对象。键值对作为元组包含在对象或项目中。
sorted (iterable)方法总是返回排序列表。该方法对给定字典中可用的元素数量进行排序。

举例:

让我们举一个例子，看看如何在 Python 中对字典键进行排序

my_dict = {"m":250,"o":950,"b":170,"a":150} 

sort_keys = my_dict.items()
new_items = sorted(sort_keys)
print(new_items)

在上面的例子中，首先，我们将初始化一个字典，并给它们分配一个键值对值。然后使用 dict.items() 函数得到一个可迭代的序列值。

下面是以下代码的截图

Python dictionary sort by key

阅读 Python 字典更新示例

如何在 Python 中对字典键进行排序——另一种方法

使用 dict.keys()我们可以对 Python 中的字典键进行排序。该方法返回一个 iterable view 对象，该对象显示字典中可用的所有键。

举例:

让我们举一个例子，看看如何在 Python 中对字典键进行排序

my_dict = {"p":350,"z":750,"a":170,"c":110} 

sorted(my_dict.keys())
for key in sorted(my_dict.keys()) :
    print(key , " : " , my_dict[key])

下面是以下代码的截图

Python dictionary sort by keys method

这就是如何在 Python 中对字典键进行排序。

Python 字典按值降序排序

让我们看看如何在 Python 中对字典值进行降序排序。
使用 dict.items()获取一个存储字典的键值对的 iterable 项，并调用返回新排序列表的 sorted(iterable，key)函数。在这种情况下，我们将排序函数中的键属性指定为一个参数，用 f 作为 lambda 键值来对值进行排序。

举例:

让我们举一个例子，看看如何按降序对字典值进行排序

from typing import OrderedDict

my_dict = {1: {"p":350,"z":750,"a":170,"c":110},
           6: {"p":100,"z":700,"a":120,"c":900},
           4: {"p":300,"z":200,"a":450,"c":130}}

sort_values = my_dict.items()
new_item = sorted(sort_values, key=lambda key_value: key_value[1]["c"], reverse=True)
list = OrderedDict(new_item)
print(list)

首先在上面的代码中，我们将导入一个有序字典库并创建一个字典。key_value[1][inner_key]按内部键值对以前的结果 iterable 进行排序。

下面是以下代码的截图

Python dictionary sort by value descending

这就是如何按值降序对 Python 字典进行排序。

读取 Python 字典值以列出

Python 字典按字母顺序值排序

在 Python 中，字典由{key: value}方法的键值对组成。
因此，在 my_dict 变量中，键是名称，值是名称右边的整数。
要按字母顺序对值进行排序，您可以对字典中具有相同键的值对进行排序和打印。

举例:

让我们举一个例子，检查如何按字母顺序对字典值进行排序。

my_dict = {'John':2,
           'George':3,
           'Micheal':4,
           'Andrew':6,}

for value in sorted(my_dict.items(), key=lambda x: x[0], reverse=True):
     print(value)

下面是以下代码的截图

Python dictionary sort by value alphabetically

Python 字典按字母顺序键排序

让我们看看如何在 Python 中按照字母顺序对字典键进行排序。
要按字母顺序对字典键进行排序，我们可以使用 dict.items() 和 sorted(iterable)函数。
在这个例子中，我们可以使用一个简单的算法按字母顺序对字典键进行排序，首先，使用 Python sorted()函数对键进行排序。
该函数对给定字典(键-值)对中可用的元素数量进行排序。

举例:

new_dict = {"z":220,"v":450,"u":120,"t":350} 

sorted_keys = new_dict.items()
new_values = sorted(sorted_keys)
print(new_values)

下面是以下代码的截图

Python dictionary sort by key alphabetically

这就是如何按字母顺序通过键对 Python 字典进行排序。

阅读 Python 检查变量是否为数字

Python 字典排序反转

让我们看看如何颠倒 Python 字典中键的顺序。
键的迭代顺序是一个任意元素。为了反转键值对，我们可以使用 dict.keys()函数和循环方法。

举例:

让我们举个例子，看看如何颠倒键的顺序

dict = {'l': 1, 'm': 2, 'n': 3}

for i in reversed(list(dict.keys())):
    print(i)

下面是以下代码的截图

Python dictionary sort reverse

这是一个 Python 字典反向排序的例子。

如何颠倒 Python 字典中键的顺序

在这个例子中，我们将使用字典函数的组合来执行这个特定的任务。通过使用列表()，键()，排序()，反转()。它将对键进行排序，并使用 dict.keys()函数以降序反向提取键。

举例:

my_dict = {2 : "John", 5 : "George", 3 : "Micheal", 2 : "James"}

new_value = list(reversed(sorted(my_dict.keys())))
print(new_value)

下面是以下代码的截图

Python dictionary sort reverse keys method

这就是如何颠倒 Python 字典中键的顺序。

读取检查 Python 中的 NumPy 数组是否为空

Python 字典按键值排序

让我们看看如何使用 lambda 函数以及 item() 和 sorted() 对键值对进行排序
Lambda() 函数的定义没有名字，这就是为什么它也被称为匿名函数。
键值对用逗号分隔，并用花括号括起来。
sorted() 函数用于对给定字典的键进行排序。

举例:

让我们举个例子，检查一下如何在字典中对键值对进行排序。

my_dict = {3: 'George',
           5: 'Micheal',
           4:  'John'}

sort_values = sorted(
  my_dict.items(),
  key = lambda kv: kv[1]) # sort key and values

print("Sorted values and keys is :",
      sort_values)

下面是以下代码的截图

Python dictionary sort by key-value

这就是如何通过键值对 python 字典进行排序。

Python 字典用 lambda 排序

让我们看看如何用 Python 中的 lambda 函数对字典进行排序。
Python lambda 函数是没有任何名称的函数，它们也被称为无名函数。lambda 这个词是一个关键字，指定哪些关注者是匿名的。
lambda 函数的主体写在一行中。
由于这个原因，Python lambda 函数被称为一次性函数。它们也与高阶函数一起使用，高阶函数将函数作为输入并作为输出返回。

举例:

让我们举一个例子，看看如何用 lambda 函数对字典进行排序

my_dict = [{ "Country" : "Germany", "Val" : 40},
{ "Country" : "England", "Val" : 10 },
{ "Country" : "Japan" , "Val" : 60 }]

print (sorted(my_dict, key = lambda i: i['Val']))
print ("\r")
print (sorted(my_dict, key = lambda i: (i['Val'], i['Country'])))
print ("\r")
print (sorted(my_dict, key = lambda i: i['Val'],reverse=True)) # descending order

注:降序使用“反向=真”

在上面的例子中，我们使用 sorted()和一个 lambda 函数。首先，初始化字典列表，并使用 sorted 和 lambda 函数打印按“Val”属性排序的列表。使用 sorted 和 lambda 函数打印按【Val】降序排序的列表。

下面是以下代码的截图

Python dictionary sort with lambda

这就是如何用 lambda 对 Python 字典进行排序。

读取 Python 从字符串中移除子串

Python 字典按字母顺序排序

让我们看看如何在 Python 中按字母顺序对字典进行排序。
要按字母顺序排列字典，我们可以使用 sorted() 和 dict.items()
它将以键值对的形式返回一个新列表。

举例:

让我们举一个例子，检查如何按字母顺序排列字典

my_dict = {"k":430,"m":450,"c":420,"a":350} 

new_alpha = my_dict.items()
new_val = sorted(new_alpha)
print(new_val)

下面是以下代码的截图

Python dictionary sort by alphabetically

这就是如何按字母顺序对 python 字典进行排序的方法。

Python 字典按值列表排序

这里我们将检查如何在 Python 中对列表中的值进行排序。
通过使用 sorted() 和 dict.items() 函数，我们将检查如何对列表中的值进行排序。

举例:

my_dict = {'u': [4, 9, 2], 'v': [7, 1, 3], 'w': [5, 2, 8]}
sort_list = {l: sorted(m) for l, m in my_dict.items()} #sort value by list
print(sort_list)

下面是以下代码的截图

Python dictionary sort by value list

这是如何在 Python 中对列表中的值进行排序。

Python 按值排序字典，然后按键排序

要按值排序字典，那么我们可以很容易地使用 lambda 和 sorted 函数。
在本例中，我们可以将这个反向标志顺序设置为 true，这意味着值将按降序排列。

举例:

让我们举一个例子，看看如何通过值而不是键对字典进行排序

dict={49:1, 52:4, 74:3, 19:6, 101:2}
z = sorted(dict.items(), key=lambda x: (x[1],x[0]), reverse=True)
print(z)

下面是以下代码的截图

Python sort dictionary by value then key

这是如何按值排序字典，然后键入 Python 。

Python 最快的字典排序方式

在 Python 中，可以使用 for 循环对字典进行排序。首先使用 sorted()函数对字典的值进行排序。然后，通过在一个循环中迭代排序后的值来识别键。我们创建一个新的字典，并按照排序后的顺序添加这些键值对。

举例:

new_dictionary = {'U.S.A': 34, 'Germany': 12, 'France': 4}
new_val = sorted(new_dictionary.values()) 
result = {}

for m in new_val:
    for n in new_dictionary.keys():
        if new_dictionary[n] == m:
            result[n] = new_dictionary[n]

print(result)

下面是以下代码的截图

Python fastest way to sort a dictionary

方法二:

为了对字典进行排序，Python 提供了内置的 key()和 values()函数。它返回键的排序列表，并接受任何 iterable 作为参数。我们可以使用关键字按升序对字典进行排序。让我们检查下一个例子。

源代码:

Country_name = {67:'U.S.A' ,23:'Spain' ,15:'United Kingdom' ,24:'Australia' }  

print(sorted(Country_name.keys()))  
#print the sorted list with items.  
print(sorted(Country_name.items()))

下面是以下给定代码的实现

Python fastest way to sort a dictionary sorted method

这就是如何使用 Python 中的 sorted 方法对字典进行排序。

您可能会喜欢以下 Python 教程:

在本 Python 教程中，我们将讨论 Python 字典排序。在这里我们还将看到 Python 创建字符串的例子:

Python 字典按值排序
Python 字典按关键字排序
Python 字典按值降序排序
Python 字典按字母顺序按值排序
Python 字典按字母顺序按关键字排序
Python 字典反向排序
Python 字典按键值排序
用 lambda 进行 Python 字典排序
Python 字典按字母顺序排序
Python 字典按值列表排序
Python 先按值再按键对字典进行排序
Python 字典排序的最快方法

Python 字典到 CSV

原文：https://pythonguides.com/python-dictionary-to-csv/

在本 Python 教程中，我们将讨论 Python 字典到 CSV。在这里，我们还将介绍以下示例:

Python 字典到 Csv 熊猫
Python 字典到 Csv 文件
Python 字典到带标题的 Csv
Python 字典到 Csv 字符串
Python 字典到 Csv 格式
Python 字典到 Csv 写
Python 字典到 Csv 表
Python 字典到 Csv 列
Python 字典到 Csv 追加
Python 将字典写入 Csv 行
Python json 字典到 Csv

Python 字典到 CSV
- 检查如何将字典转换成 CSV 的另一个例子
Python 字典到 CSV 熊猫
Python 字典到 CSV 文件
Python 字典到 CSV 文件，带标题
Python 字典到 CSV 字符串
Python 字典到 CSV 格式
Python 字典给 CSV 写
Python 字典到 CSV 列
Python 字典到 CSV 追加
Python 将字典写入 CSV 行
Python json 字典到 CSV

Python 字典到 CSV

在 Python 中，使用 dictwriter() 方法将字典转换为 CSV。此方法用于将数据插入 CSV 文件。在 Python 中，CSV 模块存储了 dictwriter() 方法。它创建一个对象，工作方式类似于 dictwriter()。
为了执行这个特定的任务，我们首先要导入 CSV 模块。接下来我们将初始化一个字典。

让我们举一个例子，看看如何将字典转换成 CSV 文件

源代码:

import csv

employee_info = ['emp_id', 'emp_name', 'skills']

new_dict = [
{'emp_id': 456, 'emp_name': 'George', 'skills': 'Python'},
{'emp_id': 892, 'emp_name': 'Adam', 'skills': 'Java'},
{'emp_id': 178, 'emp_name': 'Gilchrist', 'skills': 'Mongo db'},
{'emp_id': 155, 'emp_name': 'Elon', 'skills': 'Sql'},
{'emp_id': 299, 'emp_name': 'Mask', 'skills': 'Ruby'},
]

with open('test4.csv', 'w') as csvfile:
    writer = csv.DictWriter(csvfile, fieldnames = employee_info)
    writer.writeheader()
    writer.writerows(new_dict)

这里我们可以将‘employee _ info’定义为列名。现在，如果我们想以写模式打开一个文件，那么我们可以使用 open() 函数，并使用 writerheader() 方法在 CSV 文件中写入第一行。在本例中， writerow() 函数将行参数写入编写器的 file 对象。

下面是以下给定代码的执行过程

Python dictionary to CSV

检查如何将字典转换成 CSV 的另一个例子

举例:

import csv

my_dictionary = {'values': 678, 'values2': 167, 'values6': 998}

with open('test6.csv', 'w') as f:
    for key in my_dictionary.keys():
        f.write("%s, %s\n" % (key, my_dictionary[key]))

首先在上面的代码中，我们将定义一个字典并使用 open() 函数打开文件，而要将 CSV 数据写入文件我们可以使用 dict.keys()的概念。

下面是以下代码的截图

Python dictionary to CSV method

这是如何将字典转换成 CSV 文件。

阅读: Python 将字典转换为数组

Python 字典到 CSV 熊猫

让我们看看如何使用 pandas 模块将 Python 字典转换为 CSV。
在这个例子中，我们将首先声明一个字典，并将其转换为数据帧，然后通过使用 to_csv() 函数将其转换为 CSV 文件。

源代码:

import pandas as pd
new_my_dict = [
{'a': 15, 'n': 81, 'p': 177},
{'a': 18, 'n': 24, 'p': 190},
{'a': 19, 'n': 20, 'p': 156},
]
df = pd.DataFrame.from_dict(new_my_dict) 
df.to_csv (r'test8.csv', index = False, header=True)

在上面的代码中，我们首先需要导入 pandas 模块，然后创建一个字典‘new _ my _ dict’。这里我们也将字典转换成数据帧。在这个例子中，我们可以在函数中使用方法 to_csv() ，我们可以将 index 和 header 作为参数传递，但是它们是可选的，我们将 index 作为‘false’传递，将 header 作为‘True’传递。

下面是以下代码的截图

Python dictionary to CSV pandas

阅读:从字典中获取所有值 Python

Python 字典到 CSV 文件

在 Python 中，CSV 文件是包含由换行符和逗号分隔的值的文件。
通过使用 CSV.writer.writerow() 我们可以将字典转换成 CSV 文件。要给出 CSV 文件的路径，我们可以应用 open() file 方法。在这个方法中，我们传递了关键字‘w’作为一个参数，这意味着打开一个 CSV 文件流进行写操作。
在 Python 中，为了迭代字典中的键-值对，我们可以结合使用 for loop 和 dict.items() 方法来执行这个特定的任务。

源代码:

import csv
new_path = open("mytest.csv", "w")
file_dictionary = {"oliva":199,"james":145,"potter":187}

z = csv.writer(new_path)
for new_k, new_v in file_dictionary.items():
    z.writerow([new_k, new_v])

new_path.close()

注意:在“new_path”变量中，您必须存储自己的 CSV 文件。

下面是以下给定代码的实现

Python dictionary to CSV file

阅读: Python 元组字典

Python 字典到 CSV 文件，带标题

这里我想写一个具体的 Python 字典到 CSV，带头。
在 Python 中，使用 dictwriter() 方法将字典转换成带头文件的 CSV 格式。此方法用于将数据插入 CSV 文件。这里我们可以定义‘header _ key’为字段名。
在本例中，我们将定义一个字典，并使用 open()函数打开文件和概念的 dictwriterheader() 方法来传递一个字段名关键字作为参数。

举例:

import csv

new_dictionary = { "Australia" : 456, "Germany" : 2678, "China" : 1890,"Japan":1667}
with open('maintest.csv', 'w', newline='') as csvfile:
    header_key = ['Country', 'Value']
    new_val = csv.DictWriter(csvfile, fieldnames=header_key)

    new_val.writeheader()
    for new_k in new_dictionary:
        new_val.writerow({'Country': new_k, 'Value': new_dictionary[new_k]})

下面是以下给定代码的输出

Python dictionary to Csv with header

阅读: Python 从两个列表中创建了一个字典

Python 字典到 CSV 字符串

这里我们可以看到如何将字典转换成 CSV 字符串。
为了解决这个问题，我们首先需要导入一个‘io’和‘CSV’模块。现在，为了导出字典数据，我们首先打开一个名为‘test 8 . CSV’的文件。最重要的一点你要创建自己的 CSV 文件，把它作为一个参数放入 open()函数，用‘w’属性进行编写，并把换行符调整成一个字符串。
这里我们创建了一个 dictwriter 类的实例，并包含一个‘l’变量。在 Python 中， writerrow() 方法帮助用户编写一个值列表，列表中包含每一项。

源代码:

import io
import csv

new_out = io.StringIO()
new_dictionary = [{"emp_name": "OLava", "emp_id": "4567", "skills": "Python"},{"emp_2": "Suzane", "emp_id2": "1678", "skills": "Java"}]
new_path = open("test8.csv", "w")
l = csv.writer(new_path,new_out, quoting=csv.QUOTE_NONNUMERIC)
for m in new_dictionary:
        for new_k, new_val in m.items():
            l.writerow([new_k, new_val])
con_csv = new_out.getvalue()
new_path.close()

下面是以下给定代码的实现

Python dictionary to CSV string

Python dictionary to CSV string method

这就是如何将字典转换成 CSV 字符串。

阅读: Python 字典 pop

Python 字典到 CSV 格式

让我们看看如何将 Python 字典转换为 CSV 格式。为了完成这个任务，我们可以应用 open() 函数和 CSV 文件以及‘w’关键字作为参数，这意味着以写模式打开 CSV 文件的流。

举例:

在这里，我们将以 CSV 格式编写要导出的命令

import csv
my_dict = [{
  "student_id": 1456,
  "stu_nam": "oliva",
  "stu_nam_las": "pollard",
  "age": "26"
}, {
  "student_id": 6789,
  "stu_nam": "john",
  "stu_nam_las": "potter",
  "age": "34"
}, {
  "student_id": 378,
  "stu_nam": "Micheal",
  "stu_nam_las": "brenda",
  "age": "29"
}]

with open("test8.csv", "w", newline="") as csv_file:
  new_val = ["student_id","stu_nam","stu_nam_las","age"] 
  j = csv.DictWriter(csv_file, fieldnames=new_val)
  j.writeheader()
  j.writerows(my_dict)

在上面的代码中，我们首先需要导入一个 CSV 模块，然后创建一个 Python 字典列表。现在声明一个字段名列表，并使用 dictwriter 的概念。此方法用于将一行数据写入给定文件。

输出:

Python dictionary to CSV format

阅读: Python 字典包含

Python 字典给 CSV 写

来访问一个新的 CSV 文件并将字典添加到其中。在这个例子中，我们使用 CSV writer() 方法。在 Python 中，CSVwriter()方法帮助用户将用户数据转换为字符串。
在本例中，脚本将数据写入“test8”。Csv '文件和 writerow() 方法将一行数据写入给定文件，并将‘new _ key’和‘new _ val’关键字作为参数传递。

源代码:

import csv

my_new_dict = {'Country': 'Egypt', 'Value': '6789'}

with open('test8.csv', 'w') as f:  
    z = csv.writer(f)
    for new_key, new_val in my_new_dict.items():
       z.writerow([new_key, new_val])

下面是以下代码的截图

Python dictionary to CSV write

阅读: Python 字典理解

Python 字典到 CSV 列

在这个例子中，我们将看到如何为 CSV 列编写一个字典，我们还将检查如何在第一列显示关键元素，在第二列显示值。
为了执行这个任务，我们将定义一个字典，使用 open()函数打开文件，并使用 dictwriter() 方法的概念来传递一个 CSV 文件关键字作为参数。

源代码:

import csv
new_dictionary = {78:'z', 15:'y', 19:'r'}

with open('maintest.csv', 'w') as f:
    w = csv.writer(f)
    for row in new_dictionary.items():
        w.writerow(row)

下面是给定代码的执行

当我在 excel 表格中打开输出时，它的格式是这样的

Python dictionary to CSV columns

Python 字典到 CSV 追加

让我们看看如何使用 CSV 模块和 dictwriter 类向 CSV 文件追加一行。
首先，我们将创建一个 CSV 文件并在其中插入元素。在 Python 中读写 CSV 文件，我们可以使用 CSV() 模块。要编写一个 CSV 文件，有两种方法:writer 和 dictwritter。
在本例中，首先导入 writer 类，然后以追加模式打开 CSV 文件。现在如果你想得到一个 writer 对象，那么就使用 CSV.writer() 方法的概念。之后使用 writerow() 函数，并在函数内将列表作为参数传递。

源代码:

import csv
from csv import writer

new_row=[9532,'China','Mongodb','26']

with open('maintest.csv', 'a') as f:

    w = writer(f)
    w.writerow(new_row)

    f.close()

下面是以下代码的截图

Python dictionary to CSV append

阅读: Python 熊猫 CSV 教程

Python 将字典写入 CSV 行

在 Python 中，CSV 模块包含 dictwriter() 方法，该方法需要 CSV 文件在其上写入并存储字段名。在本例中， writerow() 函数将行参数写入编写器的文件对象。

举例:

import csv

student_info = ['stu_id', 'stu_name', 'age']

new_cs_row = [
{'stu_id': 1890, 'stu_name': 'Liam', 'age': '45'},
{'stu_id': 3456, 'stu_name': 'Noah', 'age': '21'},
{'stu_id': 1678, 'stu_name': 'William', 'age': '27'},
{'stu_id': 9081, 'stu_name': 'Elijah', 'age': '18'},
{'stu_id': 9728, 'stu_name': 'Benjamin', 'age': '17'},
]

with open('mytest.csv', 'w') as csvfile:
    i = csv.DictWriter(csvfile, fieldnames = student_info)
    i.writeheader()
    i.writerows(new_cs_row)

输出:

Python write a dictionary to CSV row

读取: Python NumPy 读取 CSV

Python json 字典到 CSV

在这里，我们可以看到如何使用 Python 将 JSON 字典文件转换为 CSV 文件。
在 Python 中， JSON 代表 Javascript 对象符号，它用于数据操作，而 CSV 文件用于电子表格的格式化。JSON 是 Python 中的内置包。要在我们的代码中使用这个模块，首先我们必须用 Python 脚本导入 JSON 包。JSON 非常类似于 Python 字典，它将键值映射存储在花括号{}中。
让我们看看如何在代码中使用 JSON 文件，并将它们转换成 CSV 文件。

源代码:

import json
import csv

with open('newtest.json') as json_file:
	new_info = json.load(json_file)
student_info = new_info['country_name']
new_file_path = open('test9.csv', 'w')
m = csv.writer(new_file_path)
new_num = 0
for stu in student_info:
	if new_num == 0:

		header = stu.keys()
		m.writerow(header)
		new_num += 1

	m.writerow(stu.values())
new_file_path.close()

在上面的代码中，我们首先要导入 JSON 和 CSV 模块。现在，我们必须打开一个 JSON 文件，将数据加载到一个变量中，并以写模式打开 CSV 文件。之后，声明 CSV writer 对象‘m’和‘new _ num’变量用于将标题写入 CSV 文件。在这个例子中，load 关键字帮助用户将 JSON 数据转换成一个字典。

下面是 JSON 文件截图

Python JSON dictionary to CSV

下面是 CSV 文件的输出

Python JSON dictionary to CSV method

另外，看看更多的 Python 教程。

在本 Python 教程中，我们讨论了将 Python 字典转换为 CSV。在这里，我们还介绍了以下示例:

Python 字典到 Csv 熊猫
Python 字典到 Csv 文件
Python 字典到带标题的 Csv
Python 字典到 Csv 字符串
Python 字典到 Csv 格式
Python 字典到 Csv 写
Python 字典到 Csv 表
Python 字典到 Csv 列
Python 字典到 Csv 追加
Python 将字典写入 Csv 行
Python json 字典到 Csv

Python 字典更新及示例

原文：https://pythonguides.com/python-dictionary-update/

在本 Python 教程中，我们将通过如下几个例子来讨论 Python 字典更新:

Python 字典更新方法
Python 字典更新值
如果键存在，Python 字典更新值
Python 字典更新功能
Python 字典更新与追加
Python 字典更新密钥
Python 字典更新与赋值
Python 字典更新所有值
Python 嵌套字典更新
Python 字典更新(如果不存在)

Python 字典更新
Python 字典更新方法
Python 字典更新值
更新嵌套 Python 字典
如果关键字存在，Python 字典更新值
字典中存在关键字时更新值的另一种方法
解决方案
Python 字典更新 vs 追加
Python 字典更新键
更新字典中密钥的另一种方法
Python 字典更新 vs 赋值
Python 字典更新所有值
Python 嵌套字典更新
不存在时更新 Python 字典

Python 字典更新

在本节中，我们将讨论 python 字典更新。这里我们将使用 update()方法。
它是一个无序的数据值集合，用于像元组一样存储数据值，不像其他数据类型只包含一个值，因为 Python 字典采用键值对。
这个方法用键和值对更新字典。如果键/值不存在，它将插入一个键/值。如果字典中已经存在该键/值，它将更新它。
这个函数不返回任何值，而是用新关联的键值更新同一个输入字典。

语法:

下面是 update()方法的语法

dict.update([other])

它只包含一个参数。
- 其他:是键/值对列表。
Return :不返回值(None)。

举例:

让我们举一个例子来检查如何实现 Python 字典更新

在本例中，通过传递键/值对来更新字典。这个方法更新字典。

代码:

dict = {'Africa':200,'australia':300,'England':400}
print("Country Name",dict)
dict.update({'China':500})
print("updated country name",dict)

首先在上面的例子中，我们将创建一个字典并分配一个键值对。之后调用方法 update()并打印结果。

下面是以下代码的截图

Python Dictionary update

另一个例子是通过键/值对更新字典。
在这个例子中，两个值被传递给 Python 字典，它被更新。

举例:

dict = {'John':200,'Micheal':300,'Smith':400}
print("Name",dict)
dict.update({'Andrew':500,'Hayden':800})
print("updated name",dict)

下面是以下代码的截图

Python dictionary update 2nd method

另一个例子是通过键/值对更新字典。
在这种方法中，我们可以很容易地使用*运算符。
使用这种方法，我们可以在另一个字典中合并旧字典和新的键/值对。

举例:

dict = {'b': 2, 'c': 3}

# will create a new dictionary
new_dict = {**dict, **{'d': 4}} # *operator function

print(dict)
print(new_dict)

下面是以下代码的截图

Python dictionary update operator

阅读 Python 字典附加示例

Python 字典更新方法

在本节中，我们将通过使用 python update()方法来讨论 Python 字典更新方法。
您还可以通过向当前条目插入新值或密钥对或删除当前条目来更新字典。
update()方法将指定的项目插入 Python 字典。
指定的项可以是一个字典或具有键值对的可迭代元素。

语法:

下面是 update()方法的语法

dict.update(iterable)

它只包含一个参数。
- iterable: 它是一个具有键值对的对象，将被添加到字典中

举例:

让我们举一个例子来检查如何更新字典条目

dict1 = {'Python':200,'Java':300,'C++':400}
print("Languages",dict1)
dict1.update({'Ruby':500,'Pascal':800})
print("updated language",dict1)

下面是以下代码的截图

Python dictionary update method

阅读 Python 字典索引

Python 字典更新值

在本节中，我们将讨论 python 字典更新值。
要更新 Python 字典中现有键的值，必须创建一个临时字典，其中包含具有新值的键，然后将这个字典传递给 update()函数。
Update()函数接受一个 iterable 键-值对的另一个参数(dictionary 或 list)作为实参，然后将 iterable 对象中的键值更新到 dictionary 中。

语法:

下面是更新函数的语法

dict.update([other])

Return :不返回值(None)。

举例:

让我们举一个例子来检查如何更新字典中的值

dict1 = {'Germany':200,'France':300,'Paris':400}
print("Country name",dict1)
dict1.update({'France':600})
print("updated value",dict1)

下面是以下代码的截图

Python Dictionary update value

阅读如何用 Python 将字典转换成 JSON

更新嵌套 Python 字典

另一个例子是更新 Python 字典中的值。
您可以通过引用特定项的键名来更新该项的值。
在这个例子中我们可以很容易地使用更新嵌套字典的方法。
在 Python 中，嵌套字典将由逗号创建——在括起来的花括号内。
嵌套字典中指定键的值可以使用其 key 方法来包含。但是，我们可以这样做，首先，你必须创建一个空字典，甚至在分配值给相应的键之前。

语法:

下面是 Python 嵌套字典的语法

dict[out-key][in-key]='new-value'

举例:

让我们举一个例子来检查如何更新 Python 字典中的值

dict = { 'student1_info':{'name':'John','Roll-no':32},'student2_info':{'name':'Micheal','Roll-no':24}}
print("Dictionary before updation:",dict)
dict['student1_info']['Roll-no']=78 # nested dictionary

print("Dictionary after updation:",dict)

在上面的示例中，我们已经将内部键的值“Rollno”和外部键的值“student1_info1”更新为 78。

下面是以下代码的截图

Python dictionary update value nested method

阅读 Python 字典过滤器+示例

如果关键字存在，Python 字典更新值

在本节中，我们将讨论如果键存在的话 python 字典的更新值。
在这种方法中，我们可以很容易地使用内置方法键()的功能。
该方法返回字典中所有可用键的列表。通过内置的方法 Keys()，使用 if 语句和“in”操作符来检查字典中是否存在该键。
如果键存在，那么它将更新字典中的值。

举例:

让我们举一个例子，检查如果字典中存在这个键，如何更新值。

def checkKey(dict, key):

    if key in dict.keys():
        print("Key exist, ", end =" ")
        dict.update({'m':600})
        print("value updated =", 600)
    else:
        print("Not Exist")
dict = {'m': 700, 'n':100, 't':500}

key = 'm'
checkKey(dict, key)
print(dict)

下面是以下代码的截图

Python Dictionary update value if the key exists

阅读 Python 串联词典

字典中存在关键字时更新值的另一种方法

让我们看看，如果 Python 字典中存在键，如何使用内置方法 has_key()来更新值。
该函数用于判断关键字是否存在于字典中，如果关键字存在于字典中则返回 true，否则返回 false。
使用内置函数 has_key()，使用 if 语句检查字典中是否有这个键。

语法:

下面是 has_key()方法的语法

dict.has_key(key)

它只包含一个参数
- Key: 这是要在字典中搜索的密钥对。

举例:

让我们举一个例子，检查如果字典中存在这个键，如何更新值。

def checkKey(dict, key):

    if dict.has_key(key):
        print ("Exists, value updated =", dict[key])
    else:
        print ("Not Exists")

# Driver Function
dict = {'u': 400, 't':100, 'c':300}
key = 'w'
checkKey(dict, key)

在上面的例子中，我们必须使用 has_key()函数，该函数将抛出一个错误，因为 Python 版本 3 中已经删除了 has_key()方法。

下面是以下代码的截图

Python dictionary update value if the key exists an error message

解决方案

Has_key 方法只能在 python 2.7 版本中使用

下面是这个错误消息解决方案的屏幕截图

Python dictionary update value if key exists has_key method

阅读 Python 字典排序

Python 字典更新 vs 追加

在本节中，我们将讨论 python 字典更新与追加。
在这个方法中，我们可以很容易地使用函数 update()和 append()。
在这个方法中，我们可以很容易地利用内置函数 append()将值添加到字典的键中。要使用 append()将元素添加到字典中，我们必须首先找到需要添加的键。在 update()函数的情况下，用于更新与输入字典中的一个键相关联的值。
这个函数不返回任何值，也不使用新出现的键值更新输入字典。而在 append()函数的情况下，您可以通过向字典中插入一个新的索引键，然后给它分配一个特定的值，来向字典中添加一个条目。

语法:

下面是 update()函数的语法

dict.update([other])

举例:

让我们举一个例子来检查如何实现 update()和 append()函数。

dict = {'Mango':300,'Apple':600,'Orange':900}
print("Fruits Name",dict)
dict.update({'Grapes':500}) # update function
print("updated Fruits name",dict)

my_dict = {"Name":[],"Address":[],"Age":[]};

my_dict["Name"].append("John")
my_dict["Address"].append("England")
my_dict["Age"].append(30)	
print(my_dict)

首先在上面的例子中，我们将创建一个字典并分配一个键值对。之后调用方法 update()并打印结果。在 append()函数中，假设您有一个字典，字典中的关键字是姓名、地址和年龄。使用 append()方法，我们可以更新字典中的键值。

下面是以下代码的截图

Python Dictionary update vs append

Python 字典更新键

在本节中，我们将讨论 python 字典更新键。
我们能做的最接近的事情是用旧键保存值，删除它，然后用替换键和保存的值添加一个新值。
在这个例子中，我们可以很容易地调用 dict.pop(key)从 dict 中更新一个旧的键，并返回它的值。使用同一个字典，给字典分配一个新的键值对。
python pop()方法从字典中删除一个元素。它移除与指定键相关联的元素。

语法:

下面是 pop()方法的语法

dict.pop(key,default)

它由几个参数组成
- Key: 要从字典中删除的键。
- 默认值:(可选参数)如果在字典中找不到该键，则返回该值。
Return: 返回与键相关联的值。如果在字典中找不到某个键，那么如果指定了默认参数，它将返回默认值。如果没有找到键，并且没有指定默认参数，那么它会抛出一个键错误。

举例:

让我们举一个例子来检查如何更新字典中的键

romanNumbers = {'II':1, 'IV':2, 'III':3, 'V':4, 'VI':5 }
UpdateValue = romanNumbers.pop('V')
print("The popped element is: ", UpdateValue)
print("Updated dictionary: ",romanNumbers)

下面是以下代码的截图

Python Dictionary update key

如果找不到键，并且没有指定默认参数，则会引发键错误。

举例:

romanNumbers = {'II':1, 'IV':2, 'III':3, 'V':4, 'VI':5 }
UpdateValue = romanNumbers.pop('VII')
print("The popped element is: ", UpdateValue)

下面是以下代码的截图

The python default parameter is not specified

更新字典中密钥的另一种方法

在这个方法中，我们可以很容易地使用 Python zip()函数。
假设如果我们想要更新字典的所有键，那么我们需要使用 zip()函数。
zip()函数创建一个序列，该序列将聚合来自两个或多个 iterables 的元素。

举例:

让我们举一个例子来检查如何更新字典中的键

mydict = {'John': 1, 'Micheal' : 5, 
            'James' : 10, 'Potter' : 15}

mylist = ['m', 'n', 'o', 'p']
print ("initial  dictionary", mydict)
res_dict = dict(zip(mylist, list(mydict.values())))
print ("Updated dictionary", str(res_dict))

下面是以下代码的截图

Python Dictionary update key zip method

Python 字典更新 vs 赋值

在本节中，我们将讨论 python 字典更新与赋值。
在这个方法中，您可以使用符号，它可以访问键，或者使用方括号创建一个新的键，然后提供相反的值。
此外，您可以使用字典方法 update()来更新现有字典中的键。
要向字典中添加一个新键，我们可以简单地使用新键的符号，并使用赋值操作符=来赋值。

举例:

dict1 = {'Perl':200,'Mongodb':300,'SQL':400}
print("Languages",dict1)
dict1.update({'Ruby':500,'Pascal':800}) #update function
print("updated language",dict1)

Mobilename = {'samsung': 100, 'Oppo': 50}

print("Original name:", Mobilename)
Mobilename['Apple'] = 80 # assignment operator

print("Updated name:", Mobilename)

下面是以下代码的截图

Python Dictionary update vs assignment

Python 字典更新所有值

在本节中，我们将讨论 python 字典更新所有值。我们可以通过使用 update()函数很容易地做到这一点。
python update()方法用键和值对更新字典。如果键/值不存在，它将插入一个键/值。如果键/值已经存在于字典中，它将更新该键/值。
该函数将帮助用户更新 Python 字典中的所有值。

语法:

下面是 update()方法的语法

dict.update([other])

Return: 不返回值(无)

举例:

my_dict = {'Italy':200,'Japan':300,'Canada':400}
print("Country name",my_dict)
my_dict.update({'Italy':600,'japan':900,'Canada':250})
print("updated all values:",my_dict)

下面是以下代码的截图

Python Dictionary update all values

上面的代码可以用来更新 Python 字典中的所有值。

Python 嵌套字典更新

在本节中，我们将讨论 python 嵌套字典更新。
要删除存储在嵌套字典中的条目，我们可以很容易地使用 del 语句。del 语句删除一个对象。del 函数类似于 python break 语句。
在这个方法中我们可以很容易地使用方法 del()

举例:

employee_info = {
	0: { "emp_name1": "John", "salary": 50, "emp_id": 20 },
	1: { "emp_name2": "Micheal","salary":30, "emp_id": 40 },
2: { "emp_name3": "George", "salary": 90, "emp_id": 60 }
}

del employee_info[2]

print(employee_info)

在上面的例子中，我们可以从嵌套字典中删除这个雇员。
在这个例子中，我们使用 del 语句删除嵌套字典中键等于 2 的值。如您所见，这从我们的嵌套字典中删除了 emp_name3 的条目。

下面是以下代码的截图

Python nested dictionary update

不存在时更新 Python 字典

在本节中，我们将讨论 Python 字典更新，如果不存在。
在这个方法中，我们可以很容易地在关键字中使用函数。
in 关键字用于检查字典中是否已经存在某个键。

举例:

mobile = {
  "mobile name": "Samsung",
  "reference_number": "M30",
  "year":2019
}
if "mobile name" in mobile:
  print("key mobile name is exist!")
else:
  print("key mobile name is not exist!")
if "color" in mobile:
  print("key phone is exist!")
else:
  print("key phone is not exist!")

下面是以下代码的截图

Python dictionary update if not exists

您可能会喜欢以下 Python 教程:

在本 Python 教程中，我们将通过如下几个例子来讨论 Python 字典更新:

Python 字典更新方法
Python 字典更新值
如果键存在，Python 字典更新值
Python 字典更新功能
Python 字典更新与追加
Python 字典更新密钥
Python 字典更新与赋值
Python 字典更新所有值
Python 嵌套字典更新
Python 字典更新(如果不存在)

要列出的 Python 字典值–有用的教程

原文：https://pythonguides.com/python-dictionary-values-to-list/

在本 Python 教程中，我们将讨论 Python 字典值来列举。特别是，我们将通过下面的几个例子来看看如何将 Python 字典值转换成列表:

要列出的 Python 字典特定值
要按关键字排序的 Python 字典值列表
要按值排序列出的 Python 字典值
Python 字典值列表到数据帧
Python 将字典值转换为列表
Python 将字典值提取到列表中
Python 将字典值添加到列表中
Python 将字典值追加到列表中
Python 将字典值映射到列表

Python 字典值列表
检查要列出的字典值-另一种方法
Python 字典具体值列表
Python 字典值列表按键排序
检查字典值是将列表按关键字排序——另一种方式
Python 字典值列表按值排序
检查字典值以列出按值排序的列表(另一种方式)
Python 字典值列表到数据帧
检查 Python 字典值列表到 dataframe(另一个例子)
Python 将字典值转换为列表
检查如何将字典值转换成列表(另一个例子)
Python 将字典值添加到列表中
Python 将字典值追加到列表中
检查如何将字典值追加到列表中(另一个例子)
Python 地图字典值列表
解决方案

Python 字典值列表

让我们看看如何用 python 将字典值转换成列表。
在 Python 中，我们可以使用 values() 函数将字典值转换为 Python 列表。
这个函数总是返回字典中已经给定的所有元素或值的列表。

语法:

下面是 values() 方法的语法

dictionary.values()

举例:

下面举个例子来检查一下如何将字典值转换成列表。

dict = {"john":200,"Micheal":300,"George":400}
res_list = dict.values()
new_value = list(res_list)
print(new_value)

首先在上面的代码中，我们将初始化一个字典，并以键/值对的形式给它们赋值。之后，使用 dict 声明字典值的视图。values()函数。使用 list(item ),它会将字典值转换成一个列表。

下面是以下代码的截图

Python dictionary values to list

这是如何在 Python 中字典值列表。

阅读 11 Python 列表方法

检查要列出的字典值-另一种方法

现在我们可以看到如何通过使用 items()方法将 Python 字典值转换为列表值，该方法总是返回一个 iterable 对象或字典中所有可用元素或值的序列。
在这个例子中，我们可以使用 list comprehension 方法来获取给定的 Python 字典的 iterable 序列项。

举例:

让我们举个例子来检查如何将字典值转换为列表

dict = {"Spain":500,"Japan":600,"U.S.A":700}
new_values = [ list 
                for key, list in dict.items()]
print(new_values)

下面是以下代码的截图

Python dictionary values to list by item method

阅读如何用 Python 将字典转换成 JSON

Python 字典具体值列表

在这里，我们将讨论 Python 字典中列出的的具体值。
假设如果我们想从给定的字典中只转换特定的值。例如，只选择那些关键字是长度大于或等于 6 的字符串的字典值。
在这个例子中，我们可以应用列表理解方法来获取给定的字典中的可重复条目或对象。

举例:

让我们举一个例子来检查如何在 Python 中将特定于字典的值转换为列表。

dict = {"Spain":500,"Japan":600,"England":700,"Germany":100,"Australia":900}
new_values = [ value 
                    for key, value in dict.items()
                    if len(key) >= 6]
print(new_values)

下面是以下代码的截图

Python dictionary specific values to list

这是如何在 Python 字典中将特定值转换为列表。

阅读蟒蛇串连⑵ 一ry

Python 字典值列表按键排序

让我们看看如何用 Python 将字典值转换成按键排序的列表。
要将字典值转换为按键排序的列表，我们可以使用 dict.items() 和 sorted(iterable) 方法。
Dict.items()方法总是返回一个或多个对象，这些对象以键/值对的形式显示字典列表。
sorted (iterable)方法总是返回排序列表。该方法对给定字典中可用的元素数量进行排序。

语法:

下面是 iterable 项和排序方法的语法

Dict.items()

Sorted(iterable)

举例:

让我们举一个例子来检查字典值，以便按键排序

dict = {'z':5,'h':2,'f':9,'u':5}
new_items= dict.items()
sort_key = sorted(new_items)
print(sort_key)

在上面的代码中，首先，我们将初始化一个字典，并为它们分配键值对元素。然后使用 dict.items()方法获取 iterable 序列项，并使用 sorted(iterable)方法按键对字典进行排序，并将它们转换为列表。

下面是以下代码的截图

Python dictionary values to list sorted by key

上面的代码是一个 Python 字典值按键排序的例子。

阅读 Python 字典更新示例

检查字典值是将列表按关键字排序——另一种方式

在这里，我们可以检查如何将字典值转换为按键排序的列表。我们可以在 Python 中使用 sorted()和 keys()函数。
Dict.keys()方法总是返回字典中所有键的一个对象或项。
我们将从 iterable 序列中声明一个排序字典。项目()或。keys()方法。

举例:

dict = {'u':10,'l':12,'c':14,'t':15}
sorted(dict.keys())

for new_key in sorted(dict.keys()):
    print(new_key , " : " , dict[new_key])

下面是以下代码的截图

Python dictionary values to list sorted by keys method

Python 字典值列表按值排序

在 Python 中，通过使用 sorted(iterable)方法，我们可以很容易地将字典值转换为按值排序的列表。
在这个例子中，我们可以很容易地使用函数排序(iterable)和列表理解方法。

举例:

my_dict = {"Spain":500,"Japan":600,"England":700,"Germany":100,"Australia":900}
list = sorted(my_dict.items(), key=lambda x:x[1])
new_dict = dict(list)
print(new_dict)

下面是以下代码的截图

Python dictionary values to list sorted by values

阅读如何在 Python 中创建字符串

检查字典值以列出按值排序的列表(另一种方式)

在这里，我们可以检查如何通过使用 itemgetter()函数将字典值转换为按值排序的列表。它总是在 Python 中的操作符库或模块中定义。
该函数总是返回一个视图对象，该对象显示可迭代的项目或对象。
我们可以使用 itemgetter()方法对给定列表中的元素或值进行排序。

示例:

import operator

my_dict = {"John":500,"George":800,"Python":700,"Java":100,"Ruby":400}
list = sorted(my_dict.items(), key=operator.itemgetter(1))
new_dict = dict(list)
print(new_dict)

下面是以下代码的截图

Python dictionary values to list sorted by values operator method

Python 字典值列表到数据帧

现在，我们将讨论如何在 Python 中将字典值列表转换成数据帧。
在这个例子中，我们可以很容易地用 Python 导入 pandas 模块。
Pandas 是一个 python 库，用于数据操作和清理。在 pandas 中，我们可以处理有序和无序的数据，如系列数据(行和列)。
基本上，它是一个具有不同类型列的二维数据结构。

举例:

import pandas as pd

dict = [{"Mangoes":500,"Cherry":700,"banana":900}]

df1= pd.DataFrame(dict)
print(df1)

首先在上面的例子中，我们将导入一个 pandas 库，创建一个字典并将数据初始化为列表。之后，创建一个数据框架并打印结果。

下面是以下代码的截图

Python dictionary values list to dataframe

阅读 Python NumPy shape 示例

检查 Python 字典值列表到 dataframe(另一个例子)

在这里，您可以通过使用 dataframe() 方法，在 Python 中检查如何将字典值列表转换为带索引的数据帧。

举例:

import pandas as pd

dict = [{"James":100,"potter":600,"Bill":900}]
df1 = pd.DataFrame(dict, index =['Row1', 'Row2'])
print(df1)

下面是以下代码的截图

Python dictionary values list to dataframe with index

Python 将字典值转换为列表

为了在 Python 中把字典值转换成列表，我们可以使用列表理解方法。
列表理解是通过操作现有给定列表中的每一项来声明新列表的简洁方法。

举例:

让我们举一个例子来检查如何将字典值转换为列表

my_dict = {"Spain":500,"Japan":600,"England":700,"Germany":100}
new_List = []
for key in my_dict:
    new_List.append(my_dict[key])
print(new_List)

下面是以下代码的截图

Python convert dictionary values to list

阅读 Python NumPy nan

检查如何将字典值转换成列表(另一个例子)

现在，在这个例子中，我们可以检查如何通过使用 values()方法将字典值转换成列表。
该方法总是返回字典中已经给出的所有元素或值的列表。它将把字典值转换成一个列表。

举例:

让我们举一个例子来检查如何将字典值转换成列表

my_dict = {"Chinese":100,"Italian":300,"Maxican":400}
new_list = my_dict.values()
new_value = list(new_list)
print(new_value)

下面是以下代码的截图

Python convert dictionary values to list by values method

Python 将字典值添加到列表中

在这里，我们讨论如何用 Python 将字典值添加到列表中。
在这个例子中，我们可以很容易地使用 values()函数将字典值添加到列表中。
首先，我们将初始化一个字典，并为它们分配键值对元素。之后，创建一个具有相同变量名的新字典，并添加到新字典中。

举例:

my_dict = {"High":100,"Low":300}
my_dict["Middle"]=500
new_list = my_dict.values()
new_value = list(new_list)
print(new_value)

下面是以下代码的截图

Python add dictionary values to list

阅读 Python NumPy 绝对值示例

Python 将字典值追加到列表中

让我们看看如何用 Python 将字典值追加到列表中。
通过使用 append()函数，我们可以向字典中的键添加元素。要使用 append()向字典中插入元素或值，首先，我们必须找到基于一个键的值，并向它追加一个值。
在这个例子中，字典中的关键字是“国家”、“地址”、“性别”。使用 append()函数，我们可以为字典中的键生成值。

举例:

让我们举一个例子来检查如何将字典值追加到列表中

dict = {"Country":[],"Address":[],"Gender":[]};

dict["Country"].append("Japan")
dict["Address"].append("Tokyo")
dict["Gender"].append("Male")	
print(dict)

下面是以下代码的截图

Python append dictionary values to list

检查如何将字典值追加到列表中(另一个例子)

通过使用 collection.defaultdict() 我们可以在字典值或键中追加一个元素。
defaultdict 是内置 dictionary 类的子类。它总是返回新的类似字典的对象或项目。

举例:

让我们举一个例子来检查如何将字典值追加到列表中。

import collections

my_dict = collections.defaultdict(list)
my_dict["Name"].append("George")
print(my_dict)

在编写了上面的代码之后，我们将首先导入一个集合模块，并初始化一个字典，该字典具有没有在参数中设置的默认值和键。现在我们可以使用 collection.defaultdict()方法并作为参数数据类型传递，即列表。一旦你打印了 my_dict 变量，输出将显示为 { name:['geroge']} 。

下面是以下代码的截图

Python append dictionary values to list collections method

阅读 Python 通过引用或值传递示例

Python 地图字典值列表

Python 提供了 map()函数，该函数接受一个元素作为参数，然后将返回值存储在一个可迭代序列中。
让我们看看如何使用 map 对象在字典中列出值。
在这个例子中，你必须使用一个列表理解方法和一个特定的 iterable item。

举例:

my_d = {'m':4, 'l':2,'t':1,'e':4}
new_list = ['t', 'e', 'm', 'l']
b = map(lambda x:my_d.get(x, None), new_list)
print(b)

写完上面的代码后。get(key)部分用于返回一个默认值。在这个例子中，不要使用一个‘dict’变量名作为字典，因为当你使用一个地图对象时，默认情况下它会将一个参数作为 dict。

注意:正如你在上面的代码中看到的，我们在理解列表中使用了一个 map 对象，它将抛出一个错误，如<map object at 0x7f 093 ff 9 BCA 0>，因为在 Python 3 版本中它不支持 map object 作为列表。

下面是以下代码的截图

Python map dictionary values to list

解决方案

以下是误差映射对象的解决方案

Solution of Python map dictionary values to list

这就是如何在 Python 2.7 版本中求解要列出的映射字典值。

您可能会喜欢以下 Python 教程:

在本 Python 教程中，我们将讨论列出的 Python 字典值，并举例如下:

要列出的 Python 字典特定值
要按关键字排序的 Python 字典值列表
要按值排序列出的 Python 字典值
Python 字典值列表到数据帧
Python 将字典值转换为列表
Python 将字典值提取到列表中
Python 将字典值添加到列表中
Python 将字典值追加到列表中
Python 将字典值映射到列表

Python Django 过滤器

原文：https://pythonguides.com/python-django-filter/

在本 Django 教程中，我们将讨论“ Python Django 过滤器”，我们还将讨论与 Django 中的过滤器相关的不同示例。我们将在本教程中讨论以下主题。

Python Django 过滤器
Python Django 过滤器或
Python Django 过滤器和
Python Django 过滤器
Python Django 过滤器不相等
Python Django 过滤器包含
Python Django 过滤器日期
Python Django 过滤器排序依据
Python Django 过滤器 like
Python Django 过滤器大于
Python Django 过滤器小于
Python Django 过滤器大于等于
Python Django 过滤器小于等于
Python Django 过滤器 q
Python Django 过滤器独特

Python Django 过滤器
Python Django 过滤器和
Python Django 过滤器不等于
Python Django 过滤器排序依据
Python Django 过滤器大于
Python Django 过滤器大于等于
Python Django 过滤器小于
Python Django 过滤器小于等于
Python Django 过滤器包含
Python Django 滤镜喜欢
中的 Python Django 过滤器
Python Django 过滤日期
Python Django 过滤器 q
Python Django 过滤器或
Python Django 过滤器独特

Python Django 过滤器

在开始这个话题之前，你应该知道 Django 和中的什么是模型，我们如何为我们的模型创建对象。对此，可以参考“如何在 Django 中创建模型”。

所以，在创建一个模型并插入一些数据后。是时候学习如何从数据库中检索数据了。

在 Django 中，表数据由 python 对象表示，为了检索这些 python 对象，我们必须使用 QuerySet 。Django 中的一个查询集是数据库对象的集合，它可以有零个或多个过滤器。现在，这些过滤器用于根据提供的参数限制结果的数量。

很多时候，我们可能会遇到这样的情况:我们只需要从所有对象中选择一部分对象。现在，对于这个实现，我们将使用带有一些过滤条件的查询集。下面给出了一些命令过滤方法。

filter() :这个方法返回一个新的查询集，其对象与给定的参数相匹配。即使只有一个对象符合条件，它也会返回一个查询集。在这种情况下，查询集将只包含一个元素。
exclude() :在 Django 中， exclude() 方法返回一个新的 QuerySet ，其中的对象与给定的参数不匹配。

因此，在接下来的小节中，我们将讨论与 QuerySet 中的 filter 方法的可用性相关的不同示例。

阅读:如何安装 Django

Python Django 滤镜和

现在，在这一节中，我们将讨论在 Django 中使用 filter 方法时如何使用 AND 操作符。为了演示这个主题，我们使用 Django 中的用户模型。该模型包含以下数据。

用户名	名字	姓氏	电子邮件
玛琪	玛琪	工作	mworling3@imageshack .美国
模糊的	模糊的	Birkby	mbirkbyf@qq.com
米卡	米卡	塞维利亚	姆塞维尔@skyrock.com
罗斯	罗斯	汉克斯	paylmer1@desdev.cn
斯科特	斯科特	穆勒夫	smulleary0@hud.gov

User Model Data

现在，为了执行这个任务，我们将使用 Django shell。要使用 shell，首先，我们需要打开命令提示符并运行以下命令。

python manage.py shell

这将在命令提示符下启动交互式控制台。现在，我们将执行下面的例子。

`(InteractiveConsole)`
**>>>** from django.contrib.auth.models import User                       
**>>>**
**>>>** queryset = User.objects.filter(first_name__startswith='M', last_name__startswith='S')
**>>>**
**>>>** print(queryset)

在上面的例子中，首先，我们已经导入了用户模型。之后，我们使用 QuerySet 来过滤数据，为了过滤，我们定义了两个条件。

首先，记录的名字应该以字符“ M 开始。第二，记录的姓氏应该以字符“ S 开始。

现在，条件之间的逗号(“，”)指定了和操作符。最后，我们使用 print 语句打印过滤后的查询集。

因此，这个查询集将选择名字以“ M 开始，姓氏以“ S 开始”的记录。

Result

我们还可以通过执行下面的命令来获取相应的 SQL 代码。

str(queryset.query)

它将为这个查询集返回等价的 SQL 语句。

Output

Python Django 滤镜不等于

在这一节中，我们将了解如何根据“不等于”条件来过滤 Django 中的对象。

这仅仅意味着我们必须过滤掉所有不符合给定条件的数据。对于这次执行，我们将使用带有 QuerySet 的 exclude() 方法。

Django 中的 exclude() 方法返回一个新的 QuerySet ，其中包含与给定参数不匹配的对象。让我们通过执行一个例子来理解它的用法。

同样，我们将使用相同的用户模型，并使用 Django shell 来执行。这里是 exclude() 方法的例子。

**>>>** from django.contrib.auth.models import User
**>>>** 
**>>>** queryset = User.objects.exclude(first_name__startswith='M')                                                
**>>>** 
**>>>** print(queryset)

在这个例子中，我们使用了 import 语句来导入用户模型。在这之后，我们定义了一个 QuerySet，它将排除名字以“ M 开头的所有记录。最后，我们使用打印语句来打印结果。

Example with Output

阅读: Python Django vs Flask

Python Django 过滤顺序由

在本节中，我们将了解如何使用 QuerySet 对 Django 中的数据库对象进行排序。因此，默认情况下，QuerySet 的结果是基于模型的元类中定义的排序元组进行排序的。

但是，我们也可以通过使用 order_by() 方法来改变 QuerySet 对结果的排序。

对于该任务的演示，我们使用具有以下数据的学生模型。

名字	姓氏	年龄
鲍里斯	殷勤地	Sixteen
Tawnya	杜尔顿	Sixteen
贾丝廷娜	专利的	Sixteen
格里利	塔夫雷利	Seventeen
伊甸园	霍基	Seventeen
尿壶	洞穴	Eighteen
杰拉尔多	提勒拉	Eighteen
权俞利	马蒂莫	Fifteen
安妮莎	阿列克桑德罗夫	Fifteen
简在哪里	清脆声	Sixteen

Students Model Data

现在，为了执行，我们将使用 Django shell 并尝试根据名字以升序对结果进行排序。这是实现的代码。

>>> from myApp.models import Students
>>> 
>>> queryset = Students.objects.order_by('first_name')
>>> 
>>> print(queryset)

因此，在给定的示例中，首先，我们导入了学生模型。之后，我们用 order_by() 方法定义了一个 QuerySet。在 order_by() 方法中，我们将“ first_name ”定义为一个参数。

这仅仅意味着 QuerySet 中的对象将基于 first_name 以升序排序。要将顺序定义为降序，我们必须在参数中使用减号(-)。

下面是上述示例的执行及其结果。

Example with Output

阅读使用 Python 中的 Django 将 HTML 页面转换为 PDF

Python Django 过滤器大于

在本节中，我们将讨论如何使用带有 QuerySet 的"大于"过滤器来过滤 Django 中的对象。在这次演示中，我们将再次使用学生模型及其数据。模型中的数据如下。

名字	姓氏	年龄
鲍里斯	殷勤地	Sixteen
Tawnya	杜尔顿	Sixteen
贾丝廷娜	专利的	Sixteen
格里利	塔夫雷利	Seventeen
伊甸园	霍基	Seventeen
尿壶	洞穴	Eighteen
杰拉尔多	提勒拉	Eighteen
权俞利	马蒂莫	Fifteen
安妮莎	亚历山大罗夫	Fifteen
简在哪里	清脆声	Sixteen

Students Model Data

让我们借助一个例子来理解如何使用“大于运算符。对于这个例子，我们将选择年龄大于 16 的所有数据库对象。该示例的代码如下。

**>>>** from myApp.models import Students
**>>>** 
**>>>** queryset = Students.objects.filter(age__gt=16)    
**>>>** 
**>>>** print(queryset)

所以，在这个例子中，我们使用了 filter() 方法，在这个方法中，我们传递了“ age__gt=16 ”作为参数。这意味着它将从学生模型中选择年龄大于 16 岁的所有对象。现在，如果我们运行给定的代码，我们将得到以下输出。

Example

阅读:Django 中的应用程序和项目之间的差异

Python Django 滤镜大于等于

所以，类似于"大于过滤器，我们也可以在 Django 中使用"大于等于 " ( > =)过滤器。通过使用这个过滤器，我们可以选择所有大于或等于特定值的数据库对象。

同样，在本次演示中，我们将使用与上一节所示数据相同的学生模型。

例如，我们将选择年龄大于或等于 17 的所有数据库对象。下面给出了这个例子的代码。

**(InteractiveConsole)
>>>** 
**>>>** from myApp.models import Students
**>>>** 
**>>>** queryset = Students.objects.filter(age__gte=17)
**>>>** 
**>>>** print(queryset)

所以，在这个例子中，我们使用了 filter() 方法，在这个方法中，我们传递了“ age__gte=17 ”作为参数。

这意味着它将从年龄大于或等于 17 的学生模型中选择所有对象。现在，如果我们运行给定的代码，我们将得到以下输出。

Example

阅读:如何获取 Django 的当前时间

Python Django 过滤不到

在本节中，我们将讨论如何使用带有 QuerySet 的"小于"过滤器来过滤 Django 中的对象。

为了更好的理解，我们将借助一个例子来理解实现。为此，我们将在 Django 使用相同的学生模型。

对于示例演示，我们将选择年龄小于 17 的所有数据库对象。下面给出了该示例的代码。

**(InteractiveConsole)
>>>                                  
>>>** from myApp.models import Students
**>>>** 
**>>>** queryset = Students.objects.filter(age__lt=17)  
**>>>** 
**>>>** print(queryset)

在上面的例子中，我们使用带有 QuerySet 的 filter() 方法。而在方法中，我们已经通过“ age__lt=17 ”作为一个参数。

这意味着它将从年龄小于 17 的学生模型中选择所有对象。现在，如果我们实现给定的代码，我们将得到下面的结果。

Example

Python Django 过滤器小于等于

在本节中，我们将讨论如何使用"小于或等于 " ( < =)过滤器和查询集来过滤 Django 中的对象。

并且，我们将借助一个例子来理解实现。为此，我们将在 Django 中使用相同的学生模型。

例如，我们将选择年龄小于或等于 16 的所有数据库对象。这个例子的代码如下。

**(InteractiveConsole)
>>> 
>>>** from myApp.models import Students
**>>> 
>>>** queryset = Students.objects.filter(age__lte=16) 
**>>> 
>>>** print(queryset)

在上面的例子中，我们使用的是以“年龄 __lte=16 ”作为参数的过滤器()方法。这将从学生模型中选择年龄小于或等于 16 的所有对象。

现在，如果我们实现给定的代码，我们将得到 6 个对象的如下输出。

Example

阅读 Python Django 获取

Python Django 滤镜包含

在 Django 中，我们也可以基于给定的模式搜索对象，并且包含用于此任务的过滤器。Django 中的 contains 过滤器返回给定字段中带有区分大小写字符串的所有对象。

让我们借助一个例子来理解它的用法，我们将在例子中使用 Person 模型。

名字	姓氏	年龄
扎克	达维多夫斯基	Twenty-three
乔纳森	高尔	Nineteen
扎克	兰德尔（亦作 Randal）（m.）	Twenty-one
克里斯季	布林克利	Twenty
扎克	麦克库汉	Twenty-four
乔纳森	麦科维尼	Twenty-seven
乔纳森	坦斯维尔	Twenty-five

Person Model Data

正如您在模型数据中看到的，有多条记录具有相同的名字，但不同的姓氏。

现在，我们将使用包含过滤器来选择名字为“扎克”的所有记录。下面是这个例子的代码。

**(InteractiveConsole)
>>> 
>>>** from myApp.models import Person
**>>>** 
**>>>** queryset = Person.objects.filter(first_name__contains='Zak')
**>>>** 
**>>>** print(queryset)

在给定的示例中，我们使用 QuerySet 中的 filter 方法。并且在 filter 方法中，我们传递了“first _ name _ _ ConA tains = ' Zak '”作为参数。

因此，这个 QuerySet 将选择名字为“ Zak ”的所有对象。下面是示例的执行和结果。

Example

Python Django 过滤像

在 SQL 中，在 WHERE 子句中使用了一个类似的操作符来搜索给定的模式。但是在 Django 中，我们不能直接使用 LIKE 操作符，而是在 filter 方法中使用 contains 字段查找来搜索给定的模式。

与相关的示例包含前面章节中给出的字段查找。为了确认包含选项是否等同于 LIKE 操作符，我们将运行下面给出的代码。

>>> from myApp.models import Person
>>> 
>>> queryset = Person.objects.filter(first_name__contains='Zak')
>>> 
>>> print(queryset) 

>>> 
>>> str(queryset.query)

在这个例子中，我们使用的是上一节中演示的同一个例子。这个例子是关于通过使用包含字段查找来选择名字为 Zak 的所有对象。

之后，我们使用 str(queryset.query) 方法，它将返回给定 queryset 的等价 SQL 代码。

最终，我们会得到以下结果。

Result

中的 Python Django 滤镜

在 SQL 中，我们一般使用运算符中的在 Where 子句中指定多个值。类似地，在 Django 中，我们可以使用字段查找中的来选择包含给定 iterable 中的值的对象。

现在，这些给定的 iterable 可以是列表、元组、查询集，甚至是字符串。

让我们借助一个例子来理解在字段查找中的用法。为此，我们将使用相同的人模型。

例如，我们将在交互控制台(Django shell)中使用下面的代码。

**(InteractiveConsole)
>>> 
>>>** from myApp.models import Person
**>>> **               
**>>>** queryset = Person.objects.filter(pk__in=[1,4,8]) 
**>>>** 
**>>>** print(queryset)

在这个例子中，我们简单地使用字段查找中的来选择主键值为 1、4 和 8 的对象。它将返回具有这些主键值的所有三个对象。

Output

Python 姜戈过滤日期

在本节中，我们将了解如何在 Django 中根据给定的日期范围过滤数据库对象。在此，我们将学习如何选择给定日期范围内的对象。

在这个演示中，我们使用下面的员工模型。这个模型有以下数据。

名字	职称	加入日期	薪水
哈迪·芒瑟	高级财务分析师	2021-05-25	Twenty-four thousand
里克·莱夫	产品工程师	2021-02-13	forty thousand
罗达·本茨	总经理	2020-10-17	Thirty-five thousand
鲁斯廷·菲利佩利	金融分析师	2021-06-04	Twenty thousand
丹尼斯打赌	技术作家	2020-11-23	Thirty-two thousand
Allene Johansson	数据库管理员	2021-04-21	Twenty-eight thousand
艾米·鲁尼	助理会计	2020-10-02	Twenty-three thousand
威利·菲利普斯	二级工程师	2021-08-01	Thirty-two thousand

Employee Model Data

现在，为了进行示例演示，我们将选择加入日期在“ **2020- 10-02** ”和“2021-05-02****”(yyyy-mm-DD)之间的所有员工记录。下面是示例的代码。

**(InteractiveConsole)
>>>                                
>>>** from myApp.models import Employee
**>>> 
>>>** queryset = Employee.objects.filter(joining_date__range=["2020-10-02","2021-05-02"])
**>>> 
>>>** print(queryset)

在上面的例子中，我们使用范围字段查找来选择加入日期在“ **2020- 10-02** ”和“ **2021 -05-02** ”之间的所有数据库对象。

为了定义范围，我们在范围列表中定义了日期。所以，在实现了上面的例子之后，我们将得到下面的输出。

Output

Python Django 滤镜 q

在 Django 中，我们可以使用 Q() 对象来实现复杂的 SQL 查询。我们可以使用一个 Q() 对象来表示一个 SQL 语句，该语句可以用于一些数据库操作。

该运算符允许定义和重用条件，也允许将它们与运算符组合，如“或“”和“和”。

一个 Q() 对象( django.db.models.Q )是一组关键字参数的容器。这些关键字参数以与“字段查找”相同的方式给出。那么，让我们借助一个例子来了解它的用法。

现在，对于示例演示，我们将使用上一节中显示的相同的雇员模型。我们将尝试从雇员模型中选择名称以“ R 开头的所有对象。

**(InteractiveConsole)
>>>** from myApp.models import Employee
**>>>** from django.db.models import Q
**>>>** 
**>>>** queryset = Employee.objects.filter(  
... Q(name__startswith="R")
... )
**>>>** 
**>>>** print(queryset)

在上面的例子中，首先，我们导入了雇员模型，然后，我们从 django.db.models 导入了 Q() 对象。之后，我们用 filter 方法创建了一个 QuerySet，在这个方法中，我们使用了 Q() 对象。

因此，这个 QuerySet with 返回一个新的 QuerySet，其中对象的名称以“ R 开始”。下面是上面例子的结果。

Result

阅读: Python Django group by

Python Django 滤镜或者

在 Django 中，我们不能直接使用或操作符来过滤 QuerySet。对于这个实现，我们必须使用 Q() 对象。通过在 filter 方法中使用 Q() 对象，我们将能够在 Q() 对象之间使用或操作符。

让我们借助一个例子来理解实现。对于这个例子，我们将使用雇员模型。我们将尝试从雇员模型中选择所有名称以“ A 或“ R 开头的对象。

**(InteractiveConsole)
>>>  
>>>** from myApp.models import Employee
**>>>** from django.db.models import Q     
**>>>** 
**>>>** queryset = Employee.objects.filter(
... Q(name__startswith="A")|Q(name__startswith="R")
... )
**>>> 
>>>** print(queryset)

在本例中，我们使用 QuerySet 中的 filter 方法。在过滤方法中，我们使用 2 个带有字段查找语句的 Q() 对象。并且在这些 Q() 语句之间，我们定义了或者(| )运算符。最后，我们使用 print 语句来打印查询集。

Output

Python Django filter distinct

在 SQL 中，我们在 SELECT 语句中使用 DISTINCT 关键字来选择唯一的记录。我们通常使用 SELECT DISTINCT 语句从查询结果中删除所有重复的记录。

同样，我们使用 Django 中的 distinct() 方法从 QuerySet 中删除重复的记录。

为了演示这种方法，我们将使用具有以下记录集的客户模型。

名字	地址	国家	城市
阿斯特拉弗里斯	德克萨斯圈 8268 号	美国	水牛
鲍伊·麦克斯佩龙	艾根达特小径 3 号	美国	清水镇
克拉琳达·凯姆	布尔帕斯街 78214 号	加拿大	谢迪亚茨
沙恩·弗伦奇	Trailsway 山 35456 号	美国	底特律
科特尼·戴维森	小芙蓉路 94999 号	联合王国	金洛克
奎尼·格雷维	挪威枫叶角 8860 号	联合王国	阿什利
Dulcy 鱼锁	德布斯路口 85095 号	美国	迈阿密海滩
Teodorico Puzey	04977 香葱圈	加拿大	鲍恩岛

Customer Model Data

现在，例如，我们将选择不同的国家名称，我们将使用以下代码。

注意:- 默认的 SQLite 数据库不支持带参数的 distinct()方法。因此，在示例中，我们展示了在 SQLite 数据库中使用 distinct 方法的一种方式。

(InteractiveConsole)
>>> from myApp.models import Customer   
>>> 
>>> queryset = Customer.objects.values('country').distinct()
>>> 
>>> print(queryset)

上面的 QuerySet 将从 country 列返回所有不同的值。下面是上面例子的执行过程。

Example

另外，请阅读:获取 Django 中的 URL 参数

在本 Django 教程中，我们已经讨论了" Python Django filter "并且我们还讨论了本教程中的以下主题。

Python Django 过滤器
Python Django 过滤器或
Python Django 过滤器和
Python Django 过滤器
Python Django 过滤器不相等
Python Django 过滤器包含
Python Django 过滤器日期
Python Django 过滤器排序依据
Python Django 过滤器 like
Python Django 过滤器大于
Python Django 过滤器小于
Python Django 过滤器大于等于
Python Django 过滤器小于等于
Python Django 过滤器 q
Python Django 过滤器独特

Python Django 格式日期

原文：https://pythonguides.com/python-django-format-date/

在本 Python Django 教程中，我们将了解 Python Django 格式日期。我们还将讨论 Django 中与格式日期相关的例子。这是我们将要涉及的主题列表。

如何在 Python django 中获取日期
Python django 格式日期
Python django 格式日期视图
Python django 格式日期日/月/年
Python django 在模板中格式化日期
Python django 格式本地日期

如何获取日期
Python django 格式日期
Python django 格式日期视图
Python django 格式日期 dd/mm/yyyy
Python django 格式模板中的日期
Python django 格式日期本地
- 使用中间件
- 使用语言 _ 代码

如何获取日期

在格式化日期之前，我们必须获取当前日期值或指定要格式化的日期。

在 Django 中定义或检索日期的最简单方法是使用 python 的 DateTime 模块。这个 datetime 模块包含许多不同的类，可以用来操作日期值。

为了生成或获取日期，我们使用了日期类。此外，要获取或设置日期，您可以使用以下任何一个函数。

datetime.date(): 该函数用于设置具体日期。它需要三个参数:年、月和日。
datetime.date.today(): 该函数用于获取今天的日期。

另外，检查:如何获得 Django 的当前时间

Python django 格式日期

由于不同地方表示日期的方式可能不同，我们有时可能需要格式化日期。在 Python 中我们有两种格式化日期的方法，我们可以很容易地在 Django 中使用。

以下是这些功能:

strftime(): 这个函数从一个日期对象生成一个格式化的字符串。它接受一个或多个格式化的代码作为输入，并输出一个字符串表示。
strptime(): 这个方法用于格式化一个字符串格式的日期。它需要两个输入，第一个是日期字符串，第二个是格式化代码。

下面列出了用于格式化日期的最流行的 Django 日期过滤器。

格式符	描述	例子
%a	缩写的日期名称。	Fri, Sun
%A	当天的全名。	星期五，星期天
%B	当月全名。	六月，七月
%b	缩写的月份名称。	一月，二月
%m	以零填充的十进制数表示的月份。	06, 10
%d	以零填充的小数形式表示的一个月中的某一天。	18, 31
%y	作为零填充十进制数的没有世纪的年份。	99, 22
%Y	以世纪为小数的年份。	1999, 2022
%j	以零填充的十进制数表示的一年中的某一天。	135, 365
%U	一年中的第几周。第一天是星期天。	28, 53
%W	一年中的第几周。第一天是星期一。	00, 53
%x	区域设置的适当日期表示。	12/31/18

Date Format Characters

阅读: Python Django 与 Flask–主要区别

Python django 格式日期视图

在这一节中，我们将学习如何在 Django 中使用视图文件格式化日期。将使用 views.py 文件获取日期，然后对其进行格式化。

我们将通过一些例子来帮助阐明我们的概念。

在开始这个例子之前，我将向您展示项目的 urls.py 文件。

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('home/', include('home.urls'))
]

这意味着当你在浏览器中打开你的项目并在 URL 中键入“home/”，它将带你到你的 home.urls 。

现在，请看主页的 urls.py 文件:

from django.contrib import admin
from django.urls import path, include
from home import views

urlpatterns = [
    path('', views.home, name='home')
]

它会移动到 home 应用程序的 views.py 文件。

例#1

在这个例子中，我们将一个月中的某一天格式化为一个零填充的十进制数，将月份格式化为一个缩写名称，将没有世纪的年份格式化为一个零填充的十进制数。

现在，请看 views.py 文件:

# Import Libraries

from django.shortcuts import render
import datetime

# Create your views here.

def home(request):
    currentdate = datetime.date.today()
    formatDate = currentdate.strftime("%d-%b-%y")
    return render(request,'home.html',
                  {'current_date':currentdate,
                   'format_date':formatDate} )

在 views.py 文件中，我们创建了一个简单的视图，将当前日期值和格式化的日期值提取到一个变量中。它还将变量返回到 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>PythonGuides</title>
</head>
<body>
    <p>
        <b>Current Date : </b>{{current_date}}
        <br>
        <br>
        <b>Formatted Date : </b>{{format_date}}
    </p>
</body>
</html>

在home.html文件中，我们只是使用变量来获取当前日期值和格式化日期值。最终，我们将获得以下输出。

Format Date

阅读比较 Python Django 中的两个整数

例 2

在本例中，我们获取当前日期并打印缩写的日期名称。

项目中的 urls.py 文件和 home 中的 urls.py 文件与上例相同。

现在，请看 views.py 文件:

from django.shortcuts import render
import datetime

# Create your views here.

def home(request):
    currentdate = datetime.date.today()
    formatDate = currentdate.strftime("%a")
    return render(request,'home.html',                 
                  {'current_date':currentdate,
                   'format_date':formatDate} )

我们在 views.py 文件中构造了一个简单的视图，将当前日期值和格式化的日期值检索到变量中。该变量也将返回到 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>PythonGuides</title>
</head>
<body>
    <p>
        <b>Current Date : </b>{{current_date}}
        <br>
        <br>
        <b>Abbreviated Day Name: </b>{{format_date}}
    </p>
</body>
</html>

我们只是使用变量来获取 home.html 文件中的当前日期值和缩写的日期名称。最后，我们会收到以下结果。

Format Date

从这里，我们清楚地知道 2022 年 2 月 7 日，这一天是星期一。

例 3

在本例中，我们获取当前日期，并以零填充的十进制数输出一年中的某一天。

views.py 文件:

from django.shortcuts import render
import datetime

# Create your views here.

def home(request):
    currentdate = datetime.date.today()
    formatDate = currentdate.strftime("%j")
    return render(request,'home.html',{'current_date': 
                  currentdate,'format_date':formatDate} )

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>PythonGuides</title>
</head>
<body>
    <p>
        <b>Current Date : </b>{{current_date}}
        <br>
        <br>
        <b>Day of the Year: </b>{{format_date}}
    </p>
</body>
</html>

Format Date

2022 年有 365 天，2 月 7 日是一年中的第 38 天。

阅读将 Python 输出到 html Django

例#4

在本例中，我们获取当前日期，如果第一天是星期一，则输出是一年的周数。

views.py 文件:

from django.shortcuts import render
import datetime

# Create your views here.

def home(request):
    currentdate = datetime.date.today()
    formatDate = currentdate.strftime("%W")
    return render(request,'home.html',{'current_date': 
                  currentdate,'format_date':formatDate} )

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>PythonGuides</title>
</head>
<body>
    <p>
        <b>Current Date : </b>{{current_date}}
        <br>
        <br>
        <b>Week number of the Year: </b>{{format_date}}
    </p> 
</body>
</html>

Format Date

2022 年有 365 天，是一年中的第几周。输出如下:

例#5

在本例中，我们获取下一个日期，并将其月份格式化为一个零填充的十进制数。

views . py 文件:

from django.shortcuts import render
import datetime

# Create your views here.

def home(request):
    currentdate = datetime.date(2022, 2, 28) + 
                  datetime.timedelta(days=1)
    formatDate = currentdate.strftime("%m")
    return render(request,'home.html',{'current_date': 
                  currentdate,'format_date':formatDate} )

只需使用+符号来获取未来日期，然后使用 datetime 来确定您想要的天数。函数 timedelta() 用于计算两点之间的日期差异。

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>PythonGuides</title>
</head>
<body>
    <p>
        <b>Current Date : </b>{{current_date}}
        <br>
        <br>
        <b>Month as Number: </b>{{format_date}}
    </p> 
</body>
</html>

Format Date

输出显示三月是一年中的第三个月。

Python django 格式日期 dd/mm/yyyy

在这一节中，我们将学习如何使用 Python Django 以某种方式格式化日期。并且，因为格式是 dd/mm/yyyy ，所以我们必须用斜线来分隔日期、月份和年份。

为了在日期符号中分隔日、月和年，我们使用 DateSeparator。以下列表将显示有效的日期分隔符。

分离器	描述
/	斜线
–	破折号
。	时期
,	逗号
	黑色

Date Separator

你可以根据自己的选择使用其中的任何一个。

例#1

同一个项目的 urls.py 和 home 的 urls.py 文件将与上一主题中一样使用。

现在，让我们看看 views.py 文件:

from django.shortcuts import render
import datetime

# Create your views here.

def home(request):
    currentdate = datetime.date(1869, 10, 2)
    formatDate = currentdate.strftime("%d/%B/%Y")
    return render(request,'home.html',{'current_date': 
                  currentdate,'format_date':formatDate} )

我们将一个月中的日期格式化为用零填充的十进制数，将该月的全名格式化为十进制数，将带有世纪的年份格式化为使用斜杠分隔符的十进制数。

现在让我们来看看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>PythonGuides</title>
</head>
<body>
    <p>
        <b>Current Date : </b>{{current_date}}
        <br>
        <br>
        <b>Format Date: </b>{{format_date}}
    </p> 
</body>
</html>

Python Django format date dd/mm/yyyy

例 2

在本例中，我们将日期格式化为一个零填充的十进制数，将月份格式化为一个零填充的十进制数，将世纪格式化为一个十进制数，并使用斜杠分隔符将它们分开。

views.py 文件:

from django.shortcuts import render
import datetime

# Create your views here.

def home(request):
    currentdate = datetime.date.today() + 
                  datetime.timedelta(days=5)
    formatDate = currentdate.strftime("%m/%d/%Y")
    return render(request,'home.html',{'current_date': 
                  currentdate,'format_date':formatDate} )

这里我们使用天数等于 5 的 datetime.timedelta 函数来获得下一个 5 天的日期。

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>PythonGuides</title>
</head>
<body>
    <p>
        <b>Current Date : </b>{{current_date}}
        <br>
        <br>
        <b>Format Date: </b>{{format_date}}
    </p> 
</body>
</html>

dd/mm/yyyy

在前面的主题中，我们有一个使用破折号分隔符的示例，您可以看到它。

Python django 格式模板中的日期

在这一节中，我们将学习使用内置的 Django 模板在 python Django 中格式化日期。

到目前为止，我们只讨论了在 views.py 文件中格式化当前日期并将其发送到模板页面。现在我们将看到如何使用 Django 模板标签来格式化当前日期。

以下是 Django 中最常见的格式字符串。

格式符	描述	例子
d	一个月中的某一天，有两位数字前导零。	02, 28
j	一个月中没有前导零的一天。	2, 28
D	文本格式的星期几缩写。	周六，周日
l	文本格式的星期几的全名。	星期六，星期天
S	一个月中某一天的英文序数后缀，2 个字符。	st '，' nd '，' rd '或' th '
w	星期几，不带前导零的数字。	周日为 0，周六为 6
z	一年中的某一天。	1, 212, 365
m	月份，有两位数字前导零。	01 – 12
n	没有前导零的月份。	1 – 12
M	以文本格式表示的一年中的缩写月份。	一月，二月
b	一年中缩写的月份，文本格式，小写。	一月，二月
F	文本格式的一年中月份的全名。	一月
y	年份，2 位数，带前导零。	00 – 99
Y	年份，带前导零的 4 位数。	1999, 2002

Format Character in Django

例#1

首先，我们将创建一个重定向到 HTML 页面的视图。在 view.py 文件中，我们使用 date() 方法定义日期，并将日期值重定向到 home.html 的页面。

views . py 文件的代码如下:

from django.shortcuts import render
import datetime 

# Create your views here.

x = datetime.date(2002, 6, 5)

def home(request):
    return render(request,'home.html', {'my_date' : x})

接下来，我们将“日期”标签添加到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>PythonGuides</title>
</head>
<body>
    <p>
        <b> Environment Day : </b> {{my_date|date:"jS M Y"}}
        <br>
        <b> Environment Day : </b> {{my_date|date:"l,d F y"}}

    </p> 
</body>
</html>

现在，启动服务器并在浏览器中打开映射的 URL。我们将得到以下结果。

Format Date In Template

例 2

views . py 文件的代码如下:

from django.shortcuts import render
import datetime 

# Create your views here.

x = datetime.date(2002, 1, 24)

def home(request):
    return render(request,'home.html', {'my_date' : x})

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>PythonGuides</title>
</head>
<body>
    <p>
        <b> Delivery Date: </b> {{my_date|date:"j-n-Y"}}
        <br>
        <b> Delivery Day : </b> {{my_date|date:"D"}}

    </p> 
</body>
</html>

Format Date In Template

例 3

在这个例子中，我们用字母和数字打印一周中的某一天以及一年中的某一天。

views.py 文件:

from django.shortcuts import render
import datetime 

# Create your views here.

x = datetime.date.today()

def home(request):
    return render(request,'home.html', {'my_date' : x})

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>PythonGuides</title>
</head>
<body>
    <p>
        <b> Day of the Week : </b> {{my_date|date:"l"}}
        <br>
        <b> Day of the week (digits)  : </b> 
            {{my_date|date:"w"}}
        <br>
        <b> Day of the year  : </b> {{my_date|date:"z"}}
    </p> 
</body>
</html>

输出如下:

Format Date

Read: Django 从 POST 请求中获取所有数据

Python django 格式日期本地

在构建 Django 应用程序时，我们可能会遇到几个日期。但是，你知道，你所期望的展示方式可能和我所期望的不一样，对吗？因此，让我们看看如何防止我们的客户因为我们在应用程序上以不熟悉的方式显示日期而将某一天误认为某个月。

Django 包括一个复杂的格式化机制，用于在将日期、时间和数字等国际化相关的单元显示在模板上之前，将其格式化为本地化的表示形式。

要打开您的格式化机制，请打开您的项目的 settings.py 文件，并设置以下设置:

USE_L10N = True

基于浏览器语言或项目中定义的语言代码，日期显示在 Django 中。所以，让我们看看改变语言的不同方法:

使用中间件
使用语言代码

使用中间件

我们可以把遥控器交给我们的用户，而不是试图自己找出语言。这是借助 Django 框架的中间件插件完成的。Django 默认包含一组中间件组件。

从这组中间件中，我们可以选择最适合我们需要的本地中间件。LocaleMiddleware 根据请求的数据库选择本地化语言。

以下步骤用于设置本地中间件:

打开项目目录中的 settings.py 文件。
查找中装列表
在里面加上当地的中装。

'django.middleware.locale.LocaleMiddleware'

LocaleMiddleware 应该放在 SessionMiddleware 之后，CommonMiddleware 之前。

让我们看一些例子来更清楚地理解这个概念:

项目的 urls.py 文件:

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('home/', include('home.urls'))
]

这意味着如果你在浏览器中打开你的项目并在 URL 中输入“home/”，你将被定向到你的 home.urls 文件。

app 的 urls.py 文件:

from django.contrib import admin
from django.urls import path, include
from home import views

urlpatterns = [
    path('', views.home, name='home')
]

然后，它会转到 home 应用程序的 views.py 文件。

views.py 文件:

from django.shortcuts import render
import datetime 

# Create your views here.

x = datetime.date.today()

def home(request):
    return render(request,'home.html', {'my_date' : x})

我们在 views.py 文件中创建了一个简单的视图，它将当前日期和格式化的日期值检索到一个变量中。该变量也将返回到 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>PythonGuides</title>
</head>
<body>
    <p>
        <b> Format Date : </b> {{my_date}} 
        <br>
        <b> Format Date (Different Style): </b> {{my_date|date:"l,jS b 
                                                                Y"}} 
   </p>
</body>
</html>

我们使用 home.html 文件中的模板过滤器以几种方式获取格式化的日期值。最后，我们会收到以下结果。

例#1

浏览器语言:英语

Locale Date

我们现在可以继续更改浏览器的语言了。当我们刷新时，它将返回一个带有我们之前设置的本地化设置的页面。

例 2

浏览器语言:德语

Locale Date

例 3

浏览器语言: 葡萄牙语(巴西)

Locale Date

使用语言 _ 代码

接下来，改变语言的方法是使用 LANGUAGE_CODE 标签，我们可以在 Django 项目的设置文件中设置它。

让我们打开项目根目录中的 settings.py 文件，并将其 LANGUAGE_CODE 值设置为支持的 HTML 语言:

LANGUAGE_CODE='<language id format>'

Django 在以下情况下使用语言代码:

如果项目设置为使用 LocaleMiddleware，但由于某种原因无法检测到用户选择的语言，则 LANGUAGE_CODE 通过指定它将恢复到的语言来提供一种回退策略。
如果项目不使用 LocaleMiddleware，则使用 LANGUAGE_CODE 作为默认语言为所有客户端提供服务。

让我们看看与此相关的例子:

例#1

Setting.py 文件:

LANGUAGE_CODE = 'en-us'

使用与中间件相同的 URL 文件。

views.py 文件:

from django.shortcuts import render
import datetime 

# Create your views here.

x = datetime.date(2022, 1, 26)

def home(request):
    return render(request,'home.html', {'my_date' : x})

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>PythonGuides</title>
</head>
<body>
    <p>
        <b> Format Date : </b> {{my_date}} 

   </p>
</body>
</html>

输出如下:

Format date locale using Django

例 2

Setting.py 文件:

LANGUAGE_CODE = 'it'

然后输出如下:

Format locale date using Django

例 3

Setting.py 文件:

LANGUAGE_CODE = 'es'

然后输出如下:

Python Django format locale date

另外，看看更多的 Django 教程。

在 Python Django 教程中，我们讨论了 Python Django 格式的日期。此外，我们还将讨论以下主题列表。

如何获得日期
Python django 格式日期
Python django 格式日期视图
Python django 格式日期日/月/年
Python django 在模板中格式化日期
Python django 格式本地日期

Python Django 获取管理员密码

原文：https://pythonguides.com/python-django-get-admin-password/

在这个 Django 教程中，我们将学习如何在 Django 中创建管理员用户以及如何为管理员用户重置密码。此外，我们还将在本教程中讨论以下主题。

如何在 Django 中创建管理员用户
Python Django 获取管理员密码
如何在 Django 中重置管理员密码

Django 是一个强大的基于 python 的 web 开发框架。当我们安装 Django 时，它默认提供一个管理界面。现在，这个管理界面使用模型的元数据来提供以模型为中心的界面。

这个接口用于管理我们的 web 应用程序的内容。此外，我们还可以根据我们的网站要求定制这个管理界面。

在本文中，我们将了解如何在 Django 中创建新的 admin 用户。

如何在 Django 中创建管理员用户
Python Django 获取管理员密码
如何在 Django 中重置管理员密码

如何在 Django 创建管理员用户

在 Django 中创建新的管理员用户非常容易。为此，我们首先需要移动到项目的根目录。在这之后，我们需要运行下面的命令。

python manage.py createsuperuser

为了在 Django 中创建新的 admin 用户，我们使用了 createsuperuser 命令，这个命令可以使用 manage.py 实用程序来执行。

一旦我们执行给定的命令，它会提示一些字段，如用户名，电子邮件，密码，确认密码。在我们为所有这些字段输入数据后，我们的新管理员用户就创建好了。

注意:- 如果您在创建项目后使用这个命令，那么请确保您首先运行“ python manage.py migrate ”命令。然后，使用创建超级用户命令。

下面是上述实现的一个例子。

Example

一旦成功创建了管理员用户，我们就可以使用这些凭据来访问管理员界面。为此，我们需要启动开发服务器，在浏览器中打开“http://127 . 0 . 0 . 1:8000/admin/”地址。

这将打开 Django 管理登录页面。现在，我们只需要使用凭证作为管理员用户登录。

阅读:如何安装 Django

Python Django 获取管理员密码

现在，在您的 Django 项目中工作时，您可能会陷入一种无法记起您的管理员凭证的情况。因此，在本节中，我们将尝试了解如何获取管理员密码。

Django 为管理界面使用自己的认证系统，这是安全框架之一。我们不能直接访问管理员密码。克服这个问题的标准解决方案之一是重置管理员密码或创建一个新的管理员用户。

现在，如果你记得你的用户名，那么我们可以很容易地改变管理员密码。这种情况将在下一节中解释。

但是，如果我们也不记得用户名呢？现在，我们可以在 Django 中访问管理员用户名。首先，我们打开 python shell。下面是打开外壳的命令。

python manage.py shell

这将打开交互式 python 控制台。接下来，我们需要从 Django 导入用户模型。为此，我们可以使用下面的命令。

from django.contrib.auth.models import User

一旦模型被导入，我们必须使用这个模型来获取所有用户。为此，我们将使用下面的代码。

users = User.objects.all()

现在，我们可以通过打印刚刚创建的 users 变量轻松获得用户名。

print(users)

下面是给定执行的一个例子。

Example

在上面的例子中， admin 是一个用户名。因此，一旦您获得了用户名，您就可以转到下一部分来重置您的管理员密码。

另请阅读:如何设置 Django 项目

如何在 Django 重置管理员密码

现在，在本节中，我们将了解如果我们知道管理员的用户名，如何重置管理员密码。

为此，我们只需移动到 manage.py 文件所在的项目根目录。然后，我们必须使用下面的语法。

python manage.py changepassword <username>

在上面的语法中，我们使用 manage.py 实用程序来更改给定用户名的密码。在语法中，我们必须给出管理员的用户名来代替 <用户名> 。之后，它会要求我们为给定的用户名设置新的密码。

为了更好地理解，请考虑给定图像中显示的以下示例。

Example

在本例中，我们已经成功重置了用户名“ admin ”的密码。

你可能也喜欢读下面的文章。

因此，在本教程中，我们讨论了如何在 Django 中创建一个管理员用户，并且我们也讨论了以下主题。

如何在 Django 中创建管理员用户
Python Django 获取管理员密码
如何在 Django 中重置管理员密码

Python Django 获取枚举选择

原文：https://pythonguides.com/python-django-get-enum-choices/

在这个 Python Django 教程中，我们将了解 Python Django get enum 选择。我们还会看到与此相关的不同例子。这些是我们将在本教程中讨论的以下主题。

什么是枚举
为什么使用枚举
何时使用枚举
Python Django 获取枚举选择
Python Django 文本枚举选择
Python Django 整数枚举选择

什么是枚举
为什么使用枚举
何时使用枚举
Python Django 获取枚举选择
- 将选项存储为文本
- 将选择存储为整数
Python Django 文本枚举选择
Python Django 整数枚举选择

什么是枚举

在这一节中，我们将学习什么是枚举。

Enum 代表枚举。枚举是链接到不同常数值的符号名称的集合。

我们的 enum 将被定义为标准 Python 库中 Enum 的子类。以下是导入枚举的语法。

**# Import Library**

from enum import Enum

**# Create enum using class**

class class_name(Enum):
    # define.....
     ......

阅读: Python Django group by

为什么使用枚举

在这一节，我们将学习枚举的用法。

我们可以使用 Python 内置的 Enum 类来构建明确的、可重用的常量，这些常量不仅可以用于模型，还可以用于其他目的。
将一组值中的一个值与另一个值区分开来。
枚举最适合用来表示一组不可变的值。
基本上，当我们在编译时知道所有可能的值时，就使用枚举。

何时使用枚举

在本节中，我们将学习何时使用 Enum。

如果您的代码中有枚举数据的规范源，并且希望使用规范名称而不是任意数据，那么可以随时使用它。
枚举对于定义一组不可变的、连接的常数值是有用的，这些常数值可能有也可能没有语义意义。
在给定的流程中，显示错误状态值。
在已定义的流程中，显示状态值。

Python Django 获取枚举选择

在 Django 中，我们使用枚举来定义模型中字段的选择。使用枚举类存储选择有两种方法。

将选项存储为文本
将选项存储为整数

将选项存储为文本

将选项存储为文本意味着使用字符作为符号。让我们看一个小例子来理清我们的理解。

例如:星期日为星期日，星期一为星期一，星期二为星期二，等等。

将选择存储为整数

将选择存储为整数意味着使用数值作为符号。让我们看一个简单的例子来更好地帮助我们。

例如:一月为 1，二月为 2，三月为 3，等等。

阅读: Python Django 过滤器

Python Django 文本枚举选择

在这一节中，我们将学习如何在 Django 中将选项存储为文本字段。让我们看看与此相关的不同例子。

例#1

在这个例子中，我们将使用一个字段来标识文章的状态。我们将使用给定的状态选项，如草稿、已发布、已计划和已删除。

为执行此示例，将执行以下步骤:

首先，定义选项的类别:

**# Import Library**

from enum import Enum

**# Create subclass of list**

class BlogStatus(Enum):   
    P = "Published"
    D = "Draft"
    S = "Scheduled"
    T = "Trash"

在这里，我们在名为 BlogStatus 的 home app 目录的 models.py 文件中创建选择的子类。

接下来，创建模型:

**# Import Library**

from django.db import models

**# Create Model**

class Blog(models.Model):
    title = models.CharField(max_length=255)
    language = models.CharField(max_length=100)
    status = models.CharField(max_length=2, choices=[(tag, tag.value) for tag in BlogStatus])

这里，我们在应用程序的 model.py 文件中创建一个名为 Blog 的模型。在这个模型中，我们定义了标题、语言和状态字段。我们在模型的状态字段中使用上面定义的 BlogStatus 枚举类。

然后，定义管理部件，以便在管理面板中查看该表。

from django.contrib import admin
from .models import Blog

class AdminBlog(admin.ModelAdmin):
    list_display = ['title', 'language', 'status']

admin.site.register(Blog,AdminBlog )

这里，我们创建名为 AdminBlog 的类。然后，我们创建一个我们希望在管理面板上显示的字段列表。最后，注册模型。

之后，根据您对模型所做的更改创建新的迁移。该命令如下所示:

python manage.py makemigrations

然后，应用和重新应用迁移。该命令如下所示:

python manage.py migrate

然后，打开 shell 编写一个 queryset。打开外壳的命令如下:

python manage.py shell

之后，插入并保存模型的字段。

**# Import Libraries**

from home.models import Blog
from home.models import BlogStatus

**# Insert and Save Data Field** 

a = Blog.objects.create(title="About Python",  language="Python", status=BlogStatus.P)

a.save()

b = Blog.objects.create(title="Install Python", language="Python", status=BlogStatus.S)

b.save()

c = Blog.objects.create(title="Data Types in Python", language="Python", status=BlogStatus.D)

c.save()

d = Blog.objects.create(title="About HTML", language="Python", status=BlogStatus.T)

d.save()

现在，已经成功地创建了带有数据字段的模型。

现在，看看数据在管理面板中的样子。

Python Django text enum choices

Python Django get enum choices

现在，从上面的输出中，您可以清楚地看到，这里我们将状态作为文本枚举选择符号进行传递。但是，它会自动在博客模型中保存完整的状态名称。

例 2

在这个例子中，我们将使用一个字段来标识文章的发布日期。我们将使用给定的发布日选择，如星期日、星期一、星期二、星期三、星期四、星期五和星期六。为执行此示例，将执行以下步骤:

首先，定义选项的类别:

**# Import Library**

from enum import Enum

**# Create subclass of list**

class PostPublished(Enum):   
    Sun = "Sunday"
    Mon = "Monday"
    Tue = "Tuesday"
    Wed = "Wednesday"
    Thur = "Thursday"
    Fri = "Friday"
    Sat = "Saturday"

这里，我们在 MyApp 应用程序目录的 models.py 文件中创建名为 PostPublished 的选择的子类。

接下来，创建模型:

**# Import Library**

from django.db import models

**# Create Model**

class Post(models.Model):
    title = models.CharField(max_length=255)
    language = models.CharField(max_length=100)
    PublishDay = models.CharField(max_length=4, choices=[(tag, tag.value) for tag in PostPublished])

这里，我们在 MyApp 应用程序的 model.py 文件中创建一个名为 Post 的模型。在这个模型中，我们定义了标题、语言和发布日字段。我们在模型的 PublishDay 字段中使用上面定义的 PostPublished enum 类。

然后，定义 admin 部分以查看 admin 中的表。

from django.contrib import admin
from .models import Post

class AdminPost(admin.ModelAdmin):
    list_display = ['title', 'language', 'PublishDay']

admin.site.register(Post,AdminPost)

这里，我们创建了名为 AdminPost 的类。然后，我们创建一个我们希望在管理面板上显示的字段列表。最后，注册模型。

之后，创建新的迁移并应用它们。这些命令如下所示:

**# Create migrations**

python manage.py makemigrations

**# Apply Migrations**

python manage.py migrate

然后，打开 shell 编写一个 queryset 来插入和保存模型的字段。

**# Import Libraries**

from MyApp.models import Post
from MyApp.models import PostPublished

**# Insert and Save Data Field** 

a = Post.objects.create(title="What is NumPy",  language="Python", PublishDay=PostPublished.Fri)

a.save()

b = Post.objects.create(title="Insert Data in MongoDB", language="MongoDB", PublishDay=PostPublished.Sun)

b.save()

c = Post.objects.create(title="Data Types in MySql", language="MySql", PublsihDay=PostPublished.Wed)

c.save()

d = Post.objects.create(title="About HTML", language="HTML", PublishDay=PostPublished.Thur)

d.save()

现在，数据字段已成功添加到模型中。

现在，看看数据在管理面板中的样子。

Python Django get enum choices

现在，正如您在输出中看到的，我们将发布日期作为文本枚举选择符号传递。但是，它会自动在发布模型中保留完整的发布日期名称。

Python Django 整数枚举选择

在这一节中，我们将学习如何在 Django 中将选择存储为一个整数字段。因此，我们可以使用枚举来获得一个基于整数值的枚举。IntEnum() 法。让我们看看与此相关的不同例子。

例#1

在本例中，我们将使用一个字段来标识事务的状态。我们将使用给定的状态选项，如成功、待定和失败。

为执行此示例，将执行以下步骤:

首先，定义选项的类别:

**# Import Library**

from enum import IntEnum

**# Create subclass**

class TransactionStatus(IntEnum):
    Successful = 1
    Pending = 2
    Failed = 0

在 transaction app 目录的 models.py 文件中，我们创建了名为 TransactionStatus 的子类。

接下来，创建模型:

**# Import Library**

from django.db import models

**# Create Model** 
class AtmTransaction(models.Model):
    Pay_To = models.CharField(max_length=150)
    Amount = models.FloatField(max_length=5)
    status = models.CharField(max_length=25, choices=[(x, x.value) for x in TransactionStatus])

这里，我们在应用程序的 model.py 文件中创建一个名为 AtmTransaction 的模型。在这个模型中，我们定义了支付对象、金额和状态。我们在模型的状态字段中使用上面定义的 TransactionStatus enum 类。

然后，在应用程序的 admin.py 文件中定义 admin 部分，以指定管理面板中模型的视图。

from django.contrib import admin
from .models import AtmTransaction

class AdminAtmTransaction(admin.ModelAdmin):
    list_display = ['Pay_To', 'Amount', 'status']

admin.site.register(AtmTransaction,AdminAtmTransaction)

这里，我们创建名为 AdminAtmTransaction 的类。然后，我们创建一个我们希望在管理面板上显示的字段列表。最后，注册模型。

之后，创建新的迁移并应用它们。

然后，打开 shell 编写一个 queryset 来插入和保存模型的字段。

**# Import Libraries**

from transaction.models import AtmTransaction
from transaction.models import TransactionStatus

**# Insert and Save Data Field** 

a = AtmTransaction.objects.create(Pay_To="Ava", Amount=500, status=TransactionStatus.Successful)

a.save()

b = AtmTransaction.objects.create(Pay_To="Oliver", Amount=1500.98, status=TransactionStatus.Failed)

b.save()

c = AtmTransaction.objects.create(Pay_To="Charlotte", Amount=2500.28, status=TransactionStatus.Pending)

c.save()

DataFeilds 已成功添加到 AtmTransaction 模型中。

现在，看看数据在管理面板中的样子。

Enum Status 1 means Successfully

Enum Status 0 means Failed

现在，正如您在输出中看到的，我们将事务状态作为状态的完整名称进行传递。但是，它会自动将状态保存到 AtmTransaction 模型中的 Int Enum。

例 2

在本例中，我们将使用一个字段来标识颜色的可用性。我们将使用给定的可选颜色，如红色、绿色、黑色和蓝色。

为执行此示例，将执行以下步骤:

首先，定义选项的类别:

**# Import Library**

from enum import IntEnum

**# Create subclass**

class ColorAvailability(IntEnum):
    Red = 1
    Green = 2
    Black = 3
    Blue = 4

在 cart 应用程序目录的 models.py 文件中，我们创建了名为 ColorAvailability 的子类。

接下来，创建模型:

**# Import Library**

from django.db import models

**# Create Model** 
class Product(models.Model):
    Product_Name = models.CharField(max_length=150)
    Product_Amount = models.FloatField(max_length=5)
    Product_Color = models.CharField(max_length=25, choices=[(x, x.value) for x in ColorAvailability])

这里，我们在应用程序的 model.py 文件中创建一个名为 Product 的模型。在这个模型中，我们定义了产品名称、产品数量和产品颜色。我们在模型的 Product_Color 字段中使用上面定义的 ColorAvailability 枚举类。

然后，在应用程序的 admin.py 文件中定义 admin 部分，以指定管理面板中模型的视图。

from django.contrib import admin
from .models import Product

class AdminProduct(admin.ModelAdmin):
    list_display = ['Product_Name', 'Product_Amount', 'Product_Color']

admin.site.register(Product,AdminProduct)

这里，我们创建名为 AdminProduct 的类。然后，我们创建一个我们希望在管理面板上显示的字段列表。最后，注册模型。

之后，创建新的迁移并应用它们。

然后，打开 shell 编写一个 queryset 来插入和保存模型的字段。

**# Import Libraries**

from cart.models import Product
from cart.models import ColorAvailability

**# Insert and Save Data Field** 

a = Product.objects.create(Product_Name="T-Shirt", Product_Amount=200.00, Product_Color=ColorAvailability.Red)

a.save()

b = Product.objects.create(Product_Name="Jump Suit", Amount=200.00, Product_Color=ColorAvailability.Green)

b.save()

c = Product.objects.create(Product_Name="Shirt", Product_Amount=800.00, Product_Color=ColorAvailability.Black)

c.save()

数据标签已成功添加到产品模型中。

现在，看看数据在管理面板中的样子。

Product_Color 2 means Green

Product_Color 3 means Black

另外，看看更多的 Python Django 教程。

在这个 Python Django 教程中，我们讨论了 Python Django get enum 选择。此外，我们还将讨论以下主题列表。

什么是枚举
为什么使用枚举
何时使用枚举
Python Django 获取枚举选择
Python Django 文本枚举选择
Python Django 整数枚举选择

python Django get——您需要知道的一切

原文：https://pythonguides.com/python-django-get/

在本 Django 教程中，我们将学习“ Python Django get ”。我们还将涉及一些主题，如-Python Django get post data，Python Django get _ or _ create等。这是我们将在本教程中讨论的主题的完整列表。

Python Django get
Python Django 获取请求参数
Python Django get_or_create
Python Django 获取发布数据
Python Django 获取 URL 参数
Python Django 获取设置变量
Python Django 获取当前 URL
Python Django 获取用户模型
Python Django get _ 用户名
决哥 Python get URL
Python Django request.user.id
Django Python 获取用户
Django Python 获取用户 id

Python Django get
Python Django get _ or _ create
Python Django get_username
Django Python 获取用户
Django Python 获取用户 id
Python Django 获取当前 URL
Python Django 获取 URL 参数
- Python Django 获取请求参数
Python Django 获取发布数据
Python Django 获取 _ 用户 _ 模型
Python Django 获取设置变量

Python Django get

在我们之前的一个教程中，我们讨论了“Python Django filter”。其中，我们讨论了如何使用 filter() 、 exclude() 等不同的方法从完整的查询集中提取子集。

现在，这些方法返回一组对象作为结果。现在，即使 QuerySet 中只有一个对象，它们也会返回带有一个对象的 QuerySet。

因此在这一节中，我们将学习如何从 QuerySet 中获取单个对象，对于这个实现，我们将使用 Django 中的 get() 方法。

Django 中的 get() 方法返回一个匹配给定查找参数的对象。当使用 get() 时，我们应该总是使用唯一的查找，比如主键或唯一约束中的字段。

让我们举一个简单的例子来说明它的执行。

**(InteractiveConsole)
>>> 
>>>** from myApp.models import Customer
**>>> 
>>>** q = Customer.objects.get(pk=2)   
**>>> 
>>>** print(q)

在上面的例子中，我们使用了客户模型，为了执行，我们使用了 Django shell。
因此，首先，我们从应用程序中导入了客户模型。在这之后，我们将创建一个查询集，但是这次我们使用的是 get() 方法。
并且在 get() 方法中，我们定义了 pk=2 作为查找参数。所以这个 QuerySet 将返回一个主键定义为 2 的对象。

现在，如果我们使用 print() 语句来打印 Queryset，它将返回对象。

Example

现在，我们应该总是小心地使用 get() ，就好像 QuerySet 没有找到任何对象，它将返回一个模型。不存在异常。如果 QuerySet 找到不止一个对象，它将返回模型。多个对象返回了异常。这两个错误都显示在下面的示例中。

Example

阅读 Python Django vs Flask

Python Django get _ or _ create

现在，无论我们在哪里使用 Django 开发数据驱动的应用程序，我们都必须确保应用程序模型中没有重复的记录。

通常，首先，我们需要编写一个逻辑来检查对象的存在，然后，我们需要根据它的存在来保存对象。但是，Django 通过提供一个方法简化了这个任务。

在 Django 中，我们可以使用 get_or_create() 方法来检查一个对象的存在，并根据它的存在创建一个对象。该方法有两个参数，第一个是“默认值，用于设置字段的默认值。

第二个是“ kwargs ”，用于定义关键字参数。这个方法基于“ kwargs 参数检查对象。

现在，这个方法返回一个元组 (object，created) ，其中“对象是一个创建或检索的对象。而“已创建”是基于对象是否被创建的事实的布尔值。

因此，每当一个关键字参数被传递给 get_or_create() 方法时(默认情况除外)。它将调用 get() 方法来检索一个对象，如果找到了该对象，该方法将返回一个元组中的对象名和 False 值。让我们举一个实现的例子。

**(InteractiveConsole)
>>> 
>>>** from myApp.models import Customer
**>>> 
>>>** q = Customer.objects.get_or_create(
... name='Cortney Davidsson',
... country='United Kingdom'
... )
**>>> 
>>>** print(q)

在这个例子中，我们使用 get_or_create() 方法根据给定的名称和国家值创建或检索一个对象。现在，如果对象已经在数据库中，那么它将返回一个元组作为 (object_name，False) 。其中对象名称是对象的名称，假表示对象未被创建。

Example

当这个方法无法用给定的参数检索对象时，它会用给定的值创建一个新的对象。并且创建后会返回元组中的对象名和 True 。让我们看一个使用 get_or_create() 方法创建一个新对象的例子。

(InteractiveConsole)
>>>
>>> from myApp.models import Customer
>>>
>>> q = Customer.objects.get_or_create(
... name='Randy Briston',
... address='93 Coleman Street',
... country='United States',
... city='Houston'
... )
>>> 
>>> print(q)

在这个例子中，我们在 get_or_create() 方法中传递了一个新对象的值。现在，由于该方法将无法获取对象，它将使用给定的值创建一个新的对象。下面是这个例子的输出。

Example

阅读如何安装 Django

Python Django get _ 用户名

在本节中，我们将学习如何使用 Django 中的 get_username() 方法来获取当前登录用户的用户名。

因此， get_username() 方法可用于用户模型类，它返回用户的用户名。并且也建议使用这个方法，而不是直接使用 username 属性。

让我们借助一个例子来理解如何使用这个 get_username() 方法。在这个例子中，我们将演示如何在 Django 模板中打印用户名。

首先，我们将创建一个基于函数的视图来获取用户名，为了获取用户名，我们将使用这个方法。下面是 views.py 文件的代码。

from django.shortcuts import render

def index(request):
    current_user = request.user.get_username()
    return render(request, 'index.html',{'user':current_user})

在上面的代码中，我们定义了一个名为 index 的视图。在视图中，我们使用request . user . get _ username()方法将用户名值存储在 current_user 变量中。之后，我们将变量发送到 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>Python Guides</title>
</head>
<style>
    p{
        text-align: center;
    }
    span{
        font-weight: bolder;
        font-size: larger;
    }
</style>
<body>
   <p><span>Username:</span> {{user}}</p> 
</body>
</html>

在index.html页面上，我们将简单地使用双花括号中的变量来打印用户名。这是这个例子的最终结果。

Final Result

阅读如何设置 Django 项目

Django Python 获取用户

在本节中，我们将学习如何在 Django 中获取用户数据。我们还将了解如何使用数据在模板中显示。

默认情况下，Django 提供了一个认证系统，我们可以很容易地扩展这个系统，在我们的应用程序中使用它。它还提供了一个默认模型来存储与注册用户相关的数据。模型的名称是用户，它的一些字段如下。

用户名:存储用户的用户名
名字:存储用户的名字
姓氏:存储用户的姓氏
电子邮件:存储用户的电子邮件地址
密码:用于存储密码的哈希，以及关于密码的元数据。
组:它存储了与组模型的多对多关系。
last_login: 存储与用户上次登录相关的日期时间值。
date_joined: 它还存储一个 DateTime 值，表示创建用户的日期和时间。

接下来，我们将了解如何在 Django 中获取这些值，并在 Django 模板中使用它们。首先，我们需要创建一个视图来获取这些值并将它们返回给模板。

这里有一个 view.py 文件的例子，我们在这里获取这些值，并将它们发送到 index.html 页面。

from django.shortcuts import render

def index(request):
    user = {
        'fullname' : request.user.get_full_name(),
        'firstname' : request.user.first_name,
        'lastname' : request.user.last_name,
        'email' : request.user.email,
        'last_login': request.user.last_login,
        'account_created': request.user.date_joined
    }
    return render(request, 'index.html',{'user':user})

在上面的代码中，我们创建了一个名为“ index ”的基于函数的视图。在这个视图中，我们创建了一个包含多个键和值的字典。现在，与当前登录用户相关的数据在请求对象中。

因此，我们使用 request.user 来获取与当前登录用户相关的数据。这是我们正在获取的数据列表。

request . user . get _ full _ name()返回用户的全名。
request.user.first_name 从用户模型返回 first_name 值。
request.user.last_name 从用户模型返回姓氏字段。
request.user.email 从用户模型返回电子邮件字段。
request.user.last_login 从用户模型返回 last_login 字段。
request.user.date_joined 从用户模型返回 date_joined 字段。

最后，我们将字典返回到 index.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">
    <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">
        <div class="card bg-light text-dark">
            <h5 class="card-header bg-dark text-light">User Info</h5>
            <div class="card-body">
                <div class="card-text"><b>Full Name:</b> {{user.fullname}}</div>
                <div class="card-text"><b>First Name:</b> {{user.firstname}}</div>
                <div class="card-text"><b>Last Name:</b> {{user.lastname}}</div>
                <div class="card-text"><b>User Email:</b> {{user.email}}></div>
                <div class="card-text"><b>Last Login:</b> {{user.last_login}}</div>
                <div class="card-text"><b>Account Created On:</b> {{user.account_created}}</div>
            </div>
        </div>
    </div>
</body>

</html>

在模板中，我们使用 Bootstrap 类来创建信息卡。在卡片中，我们使用字典值来获得所需的结果。现在，如果我们移动到映射的 URL，我们将得到下面的结果。

Final Result

阅读 Python Django 获取管理员密码

Django Python 获取用户 id

对于用户模型中的每个条目，Django 会自动为该条目分配一个主键 id。现在，在本节中，我们将学习如何获取用户的主键 id。

为了获取用户 id，我们将使用 request.user 对象，因为它返回与当前登录用户相关的信息。要获取 id，我们只需使用 request.user.id ，因为它将返回当前用户的用户 id。这里是这个例子的 viewa.py 文件。

from django.shortcuts import render

def index(request):
   user_id = request.user.id
   return render(request, 'index.html',{'user_id':user_id})

在上面的代码中，我们使用 request.user.id 将用户 id 的值存储在 user_id 变量中。在这之后，我们将变量发送到 index.html 的页面，在那里我们用它来获取 id。

Python Django 获取当前网址

在这一节中，我们将讨论如何在 Django 模板中获取页面的当前 URL。

现在，完整的 URL 由 3 个东西组成，第一个是域，第二个是路径，第三个是查询字符串。我们将看到如何在 Django 中获取 URL 的这些部分。

在 Django 中，我们可以使用一些模板标签轻松获得 URL。为此，让我们举个例子。我们在 views.py 文件中添加了以下代码。

from django.shortcuts import render

def index(request):
   return render(request, 'index.html')

def home(request):
   return render(request, 'home.html')

在上面的代码中，我们简单地创建了两个引用 HTML 页面的基于函数的视图。接下来，为了进行演示，我们将使用带有以下代码的home.html页面。

注意 :为了说明 path 和 querystring 的区别，我们用 URL 传递了一个 querystring 到主页。

<!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">
        <div class="card bg-light text-dark">
            <h5 class="card-header bg-dark text-light">Python Django get current URL</h5>
            <div class="card-body">
                <div class="card-text"><b>Current Page Path: </b>{{request.path}}</div>
                <div class="card-text"><b>Current Page Path with Querystring: </b>{{request.get_full_path}}</div>
                <div class="card-text"><b>Current Domain, Path and Querystring: </b>{{request.build_absolute_uri}}</div>
            </div>
        </div>
    </div>
</body>

</html>

现在，在《家居时代》中，我们使用了 3 个标签，与这些标签相关的信息如下。

{{ request.path }}: 这将返回当前页面路径。
{ { request . get _ full _ path } }:这将使用 querystring 返回当前页面路径。
{ { request . build _ absolute _ uri } }:这样会一起返回域、页面路径和 querystring。

现在，如果我们打开主页，我们将得到以下结果。

Final Result

在 Django 中阅读应用程序和项目之间的差异

Python Django 获取 URL 参数

在上一节中，我们讨论了如何获取 URL 的不同部分。现在，在这一部分，我们将讨论如何在 Django 中获取 URL 参数。我们还将看到如何在您的模板中显示它们。但是，在这之前，我们应该了解一下得到的方法。

GET 是 Django 中的一个 HTTP 方法，它将数据封装在一个字符串中，并利用它来构造一个 URL。URL 包括数据密钥和值以及数据必须传输到的地址。

Python Django 获取请求参数

在 Django 中，要获得 URL 参数，我们必须使用请求。GET 方法。因此，首先，我们将使用这个方法来获取参数值并将其存储在变量中。之后，我们将变量返回到一个 HTML 页面。让我们借助一个例子来理解这一点。

对于这个例子，首先，我们将使用索引页面，它有到主页的链接。对于主页 URL，它也将传递一条消息作为参数。

现在，在主页上，我们将打印参数消息。下面是 views.py 文件的代码。

from django.shortcuts import render

def index(request):
   return render(request, 'index.html')

def home(request):
   msg=request.GET.get('message')
   return render(request, 'home.html',{'msg':msg })

对于主页的视图，我们使用的是请求。GET.get('message') 方法。并且它会将“消息的值存储在“消息变量中。在这之后，我们只是将“消息返回到home.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">
    <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">
        <div class="card bg-light text-dark">
            <h5 class="card-header bg-dark text-light">Index Page</h5>
            <div class="card-body">
                <div class="card-text"><a href="{% url 'home' %}?message=Hi Welcome to Python Guides">Link To Home Page</a></div>
            </div>
        </div>
    </div>
</body>

</html>

在这个页面上，我们有一个到主页的链接，通过这个 URL，我们传递了一个消息。

现在，这里是 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">
        <div class="card bg-light text-dark">
            <h5 class="card-header bg-dark text-light">Home Page</h5>
            <div class="card-body">
                <div class="card-text"><b>URL parameters: </b>{{msg}}</div>
            </div>
        </div>
    </div>
</body>

</html>

在主页上，我们简单地使用" msg "变量来显示消息值。最终，我们得到了如下结果。

index.html page

home.html page

Python Django 获取帖子数据

在这一节中，我们将讨论如何在 Django 中获取 POST 数据。但在此之前，我们要知道 Django 中什么是 POST 什么是 POST 数据。

POST 也是一个 HTTP 方法，用于处理 Django 中的表单。 POST 方法收集表单数据，对其进行加密以便传输，将其传输到服务器，然后接收其响应。

现在，为了实现这个任务，我们将创建一个表单来保存模型中的一些数据。表单将使用 POST 方法，我们将尝试在服务器端获取表单数据。

因此，首先，我们将在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">

        <form action="success/" method="POST">
            {% csrf_token %}
            <div class="form-group">
                <label for="first_name">First Name</label>
                <input type="text" class="form-control" id="first_name" placeholder="Enter First Name">
            </div>
            <div class="form-group">
                <label for="last_name">Last Name</label>
                <input type="text" class="form-control" id="last_name" placeholder="Enter Last Name">
            </div>
            <div class="form-group">
                <label for="age">Age</label>
                <input type="number" class="form-control" id="age" placeholder="Enter Your Age">
            </div>
            <button type="submit" class="btn btn-primary">Submit</button>
        </form>
    </div>
</body>

</html>

在上面的页面中，我们用 POST 方法创建了一个表单，表单中有 3 个字段。此外，我们使用 Bootstrap 框架及其类来构建这个表单。

接下来，我们将为这个home.html页面创建一个视图，这里是 views.py 文件的代码。

from django.shortcuts import render
from myApp.models import Students

def home(request):
   if request.method=='POST':
       first_name = request.POST.get("first_name")
       last_name = request.POST.get("last_name")
       age = request.POST.get("age")
       data = Students(first_name,last_name,age)
       data.save()

   return render(request, 'home.html')

def success(request):
    return render(request, 'success.html')

因此，在主视图中，我们使用了请求。POST.get() 方法获取名字、姓氏、和年龄字段的值。
然后，我们将这些值存储到变量中。之后，我们使用这些变量为学生模型创建一个对象。
最后，我们使用 save()方法将数据存储在数据库中。

现在，我们还创建了一个成功页面，因此如果数据存储成功，将会打开成功页面。

现在，运行开发服务器，打开主页并提交记录。

Example

Python Django get _ user _ model

在 Django 中，我们有一个与名为 AUTH_USER_MODEL 的用户模型相关的设置。该设置代表用于用户的型号。

现在，如果这个 AUTH_USER_MODEL 设置被更改为某个其他用户模型，那么我们就不能直接使用用户模型类。

因此，我们可以使用 get_user_model() 方法，而不是引用用户模型类。 get_user_model() 方法返回当前活动的用户模型。我们举个例子，了解一下如何使用这个 get_user_model() 方法。

同样，对于这个执行，我们将使用 Django shell。下面是执行示例。

**(InteractiveConsole)
>>> 
>>>** from django.contrib.auth import get_user_model
**>>> 
>>>** get_user_model()
**<class 'django.contrib.auth.models.User'>**
**>>>
>>>** user = get_user_model()
**>>>** user.objects.all()      
**<QuerySet [<User: Ross>, <User: Margit>, <User: Misty>, <User: Mycah>, <User: Scotti>]>**

在这个例子中，我们首先从 django.contrib.auth 导入了 get_user_model() 方法。在这之后，我们简单地打印了方法来显示它所使用的模型类。

由于我们没有改变 AUTH_USER_MODEL 的设置，它使用的是用户模型。接下来，我们使用这个方法创建一个包含所有对象的查询集。最后，我们打印了查询集。

下面是这次执行的截图。

Example Execution

阅读: Python Django group by

Python Django 获取设置变量

在 Django 中，我们有一个 settings.py 文件，这个文件包含了与我们的 Django 安装相关的所有配置。这个 settings.py 文件本身就是一个带有模块级变量的 python 模块。

现在，在这一节中，我们将学习如何在 Django 中获取这些设置变量的值。

对于这个任务，首先，我们需要导入设置模块，然后，我们可以使用设置访问变量。变量。其中变量是设置变量的名称，并且应该总是大写字母。

让我们通过实现来理解这个实现，为了实现，我们使用 Django shell。

**(InteractiveConsole)
>>> 
>>>** from django.conf import settings
**>>> 
>>>** print('Time Zone: ',settings.TIME_ZONE)
**Time Zone:  UTC**
**>>>
>>>** print('Language Code: ',settings.LANGUAGE_CODE)
**Language Code:  en-us**
**>>>**

在这个例子中，首先，我们从 django.conf 中导入了设置模块。在这之后，我们使用 print() 语句来打印两个设置变量。首先是时区使用设置。时区，第二个是使用设置的语言代码。语言 _ 代码”。

下面是上面例子的截图。

Example

在这个 Django 教程中，我们讨论了“ Python Django get ”。我们还讨论了一些主题，如-Python Django get post data、Python Django get _ or _ create等。这是我们在本教程中涉及的主题的完整列表。

Python Django get
Python Django 获取请求参数
Python Django get_or_create
Python Django 获取发布数据
Python Django 获取 URL 参数
Python Django 获取设置变量
Python Django 获取当前 URL
Python Django 获取用户模型
Python Django get _ 用户名
决哥 Python get URL
Python Django request.user.id
Django Python 获取用户
Django Python 获取用户 id

Python Django 分组依据

原文：https://pythonguides.com/python-django-group-by/

在本 Django 教程中，我们将通过了解“ Python Django 组”，我们还将讨论一些与之相关的例子。这些是我们将在本教程中讨论的以下主题。

Python Django 分组依据
Python Django group by annotate
Python Django 按过滤器分组
Python Django 按计数分组
Python Django 按平均值分组
Python Django 按多个字段分组
Python Django 按表达式分组
Python Django group by distinct
Python Django 模型分组依据
Python Django orm 分组依据

Python Django group by
Python Django group by annotate
Python Django 按过滤器分组
Python Django 按计数分组
Python Django 按多个字段分组
Python Django group by 表达式
Python Django group by distinct
Python Django 按平均值分组

Python Django group by

因此，在这一节中，我们将了解如何在 Django ORM 中使用 GROUP BY 子句。现在，如果你熟悉 SQL ，你可能知道 GROUP BY 语句。

GROUP BY 语句用于合并具有相同值的行，主要与 COUNT() 、 AVG() 、 SUM() 等聚合函数一起使用。然而， Django ORM 是一个抽象层，它允许我们通过将 python 代码翻译成 SQL 语句来处理数据库。

在 Django 中，我们可以通过使用聚合函数或者使用一些内置函数来使用 GROUP BY 语句。此外， GROUP BY 语句和聚合函数总是组合使用来对结果集进行分组。

在本节中，我们将学习使用 Django 中的聚合函数来实现 GROUP BY 语句。让我们借助一个简单的例子来理解这一点。

在本示例演示中，我们将使用包含以下数据的客户模型。

名字	地址	国家	城市
阿斯特拉弗里斯	德克萨斯圈 8268 号	美国	水牛
鲍伊·麦克斯佩龙	艾根达特小径 3 号	美国	清水镇
克拉琳达·凯姆	布尔帕斯街 78214 号	加拿大	谢迪亚茨
沙恩·弗伦奇	Trailsway 山 35456 号	美国	底特律
科特尼·戴维森	小芙蓉路 94999 号	联合王国	金洛克
奎尼·格雷维	挪威枫叶角 8860 号	联合王国	阿什利
Dulcy 鱼锁	德布斯路口 85095 号	美国	迈阿密海滩
Teodorico Puzey	04977 香葱圈	加拿大	鲍恩岛

Customer Model

例如，我们将简单地使用一个聚合函数 COUNT() 来计算客户模型中的记录总数。

**(InteractiveConsole)
>>>
>>>** from myApp.models import Customer
**>>>** from django.db.models import Count
**>>>
>>>** queryset = Customer.objects.aggregate(total_count=Count('id'))
**>>>
>>>** print(queryset)

在这个例子中，首先，我们简单地导入了客户模型，然后，我们导入了计数()函数。在这之后，我们使用聚合方法创建了一个 QuerySet，在这个方法中，我们使用了 Count() 函数。由于模型中有 10 条记录，queryset 将返回一个字典，关键字为 total_count ，值为 10 。

Result

阅读: Python Django vs Flask

Python Django group by 标注

现在，每当我们使用 aggregate 时，aggregate 函数就会应用于整个表。但是，我们通常对一些行组应用 GROUP BY T1 语句。对于这个执行，我们必须使用 annotate() 方法。让我们用一个简单的例子来说明这个实现。

下面是这个例子的代码。

**(InteractiveConsole)
>>>**
**>>>** from django.contrib.auth.models import User
**>>>** from django.db.models import Count
**>>>
>>>** queryset = User.objects.values('is_active').annotate(count=Count('id')).order_by()
**>>>
>>>** print(queryset)

在上面的代码中，我们使用的是用户模型，这一次，我们寻找的是活跃用户的总数。
因此，在导入了用户模型和 Count() 函数之后，我们正在创建 QuerySet。
在 QuerySet 中，我们使用值(' is_active') 来选择所有活动用户。然后，我们使用注释(count=Count('id')) 来应用基于主键的聚合函数。
最后，我们使用 print 语句来打印查询集。

Example with output

所以，在上面的例子中， values() 和 annotate() 一起可以用于实现 GROUP BY 语句。我们也可以通过使用下面的代码来确认这一点。

**>>>** str(queryet.query)

它将返回给定查询集的等效 SQL 语句。在结果中，我们可以很容易地看到语句对组的使用。

SQL Query

阅读:如何安装 Django

Python Django group by 滤镜

很多时候我们只需要计算特定的行或列，而不是一组列。在这种情况下，我们可以使用带有值()和注释()的过滤器()方法来获得想要的结果。

让我们借助一个例子来理解一下 filter() 方法的用法。为此，我们再次使用内置的用户模型及其数据。我们将尝试从用户模型中获取所有活跃员工用户的数量。

**(InteractiveConsole)
>>>
>>>** from django.contrib.auth.models import User
**>>>** from django.db.models import Count
**>>>
>>>** queryset = User.objects.values('is_active').filter(is_staff=True).annotate(total_count=Count('id'))
**>>>**
**>>>** print(queryset)

在代码中，我们使用了 filter 方法从用户模型中选择所有的职员。与前面的例子类似，我们已经使用了 values() 和 annotate() 方法对分组 BY 。

下面是上面带有输出的代码截图。

Example with output

下面是上述代码的等效 SQL 查询。

SQL Query

阅读:Django 中的应用程序和项目之间的差异

Python Django 组按计数

在这一节中，我们将了解如何基于对多行的分组来获得一列的计数。让我们借助一个例子来理解这一点。这一次，我们使用的是我们在第一部分展示的客户模型。

在演示中，我们将获取 country 列中每个唯一国家的计数。这是这个例子的代码。

**(InteractiveConsole)
>>>
>>>** from myApp.models import Customer
**>>>** from django.db.models import Count
**>>>**
**>>>** queryset = Customer.objects.values('country').annotate(count=Count('country'))
**>>>
>>>** print(queryset)

在上面的例子中，我们使用了 values() 和 annotate() 方法来获取 country 列中的国家。下面是这个例子的结果。

Output

Python Django 按多个字段分组

在本节中，我们将了解如何通过在 Django 中实现 GROUP BY 语句来对多个字段进行分组。现在，对于这个实现，我们将通过 values() 方法来指定多个字段。

为了更好地理解，让我们执行一个相关的例子。为此，我们将使用内置的用户模型。该示例的代码如下。

**(InteractiveConsole)
>>>**
**>>>** from django.contrib.auth.models import User
**>>>** from django.db.models import Count
**>>>
>>>** queryset = User.objects.values('is_active','is_staff').annotate(total_count=Count('id'))
**>>>
>>>** print(queryset)

在上面的例子中，我们在 values() 方法中传递了 2 个字段，第一个是 is_active，，第二个是 is_staff 。我们还使用了 Count() 聚合函数。因此，这个 QuerySet 将返回属于或不属于 is_active 或 is_staff 组的用户计数。下面是示例的输出。

Output

Python Django group by 表达式

在本节中，我们将了解如何根据表达式对值进行分组。让我们借助一个例子来理解群表达的用法。我们将使用包含以下数据的员工模型。

名字	职称	加入日期	薪水
哈迪·芒瑟	高级财务分析师	2021-05-25	Twenty-four thousand
里克·莱夫	产品工程师	2021-02-13	forty thousand
罗达·本茨	总经理	2020-10-17	Thirty-five thousand
鲁斯廷·菲利佩利	金融分析师	2021-06-04	Twenty thousand
丹尼斯打赌	技术作家	2020-11-23	Thirty-two thousand
Allene Johansson	数据库管理员	2021-04-21	Twenty-eight thousand
艾米·鲁尼	助理会计	2020-10-02	Twenty-three thousand
威利·菲利普斯	二级工程师	2021-08-01	Thirty-two thousand

Employee Model

现在，我们将尝试获取每年加入的员工人数。下面给出了该示例的代码。

**(InteractiveConsole)
>>>
>>>** from myApp.models import Employee
**>>>** from django.db.models import Count
**>>>
>>>** queryset = Employee.objects.values('joining_date__year').annotate(total_count=Count('id'))
**>>>
>>>** print(queryset)

在上面的示例中，为了从 Datetime 值中获取日期，我们将表达式 <字段>_ _ 年 传递给了 values() 方法。它将返回一个包含键和值的字典。下面是结果截图。

Output

阅读:如何获取 Django 的当前时间

Python Django group by distinct

如果我们正在使用 Django 开发一个数据驱动的应用程序，那么大多数时候我们的表可能会有一些重复的值。当使用一些聚合函数如 COUNT() 、、【AVG() 等时，我们可能需要基于不同事件的结果。因此在这一节中，我们将讨论如何在 Django 中根据不同的值对数据进行分组。

在 SQL 方面，我们使用 SELECT DISTINCT 语句从表中选择不同的值。现在，让我们了解如何在我们的查询集中使用这个 DISTINCT 。

让我们通过演示一个例子来理解这一点，为此，我们使用了客户模型。

注:您可以在本文第一节查看客户模型的数据。

对于本示例演示，我们将从客户模型中获取所有不同的国家名称及其数量。对于实现，我们使用 Django shell。这是我们已经实现的代码。

**(InteractiveConsole)
>>>
>>>** from myApp.models import Customer
**>>>** from django.db.models import Count
**>>>**
**>>>** queryset = Customer.objects.values('country').annotate(count=Count('id'),unique_names=Count('country',distinct=True))
**>>>
>>>** print(queryset)

为了选择不同的国家名称，我们在 annotate() 方法中给出了“ distinct=True ”。因此，这个 QuerySet 将返回每个唯一国家名称的计数。为了更好地理解，下面是上述 QuerySet 的 SQL 查询。

SELECT "myApp_customer"."country", COUNT("myApp_customer"."id") AS "count", COUNT(DISTINCT "myApp_customer"."country") AS "unique_names" FROM "myApp_customer" GROUP BY "myApp_customer"."country"

最终，我们会得到如下输出，如下面的截图所示。

Use of Distinct with GROUP BY in Django

Python Django group by avg

在 Django 中，可以使用不同的聚合函数对记录进行分组，比如 COUNT() 、、【AVG() 、、MIN() 、 MAX() 等。因此，在本节中，我们将了解如何使用 AVG() 方法从 Django 中的一组记录中获取平均值。

让我们以 Django 中的 AVG() 方法的执行为例。在本演示中，我们将使用包含以下数据的雇员模型。

名字	职称	加入日期	薪水
哈迪·芒瑟	高级财务分析师	2021-05-25	Twenty-four thousand
里克·莱夫	产品工程师	2021-02-13	forty thousand
罗达·本茨	总经理	2020-10-17	Thirty-five thousand
鲁斯廷·菲利佩利	金融分析师	2021-06-04	Twenty thousand
丹尼斯打赌	技术作家	2020-11-23	Thirty-two thousand
Allene Johansson	数据库管理员	2021-04-21	Twenty-eight thousand
艾米·鲁尼	助理会计	2020-10-02	Twenty-three thousand
威利·菲利普斯	二级工程师	2021-08-01	Thirty-two thousand

Employee Model

现在，我们将通过运行以下代码来获取雇员的平均工资。

**(InteractiveConsole)
>>>
>>>** from myApp.models import Employee
**>>>** from django.db.models import Avg
**>>>
>>>** queryset = Employee.objects.aggregate(Avg('salary'))
**>>>
>>>** print(queryset)

所以，首先，我们导入了雇员模型和 Avg() 方法。在此之后，我们使用聚合函数来获得雇员的平均工资。下面是这段代码及其输出的图像。

Output

在本 Django 教程中，我们已经讨论了由创建的“ Python Django 组”，并且我们还介绍了一些与之相关的例子。这些是我们在本教程中讨论过的以下主题。

Python Django 分组依据
Python Django group by annotate
Python Django 按过滤器分组
Python Django 按计数分组
Python Django 按平均值分组
Python Django 按多个字段分组
Python Django 按表达式分组
Python Django group by distinct
Python Django 模型分组依据
Python Django orm 分组依据

Python Django 长度过滤器

原文：https://pythonguides.com/python-django-length-filter/

在这篇 Python 教程中，我将解释如何用 Python 检查 Django 应用程序中的字符串或列表的长度。

检查 Django 中字符串的长度
Django 模板中字符串的长度
Django 模板列表长度
Django 模板，如果长度大于
获取 queryset Django 的长度

检查 Django 中字符串的长度
Django 模板中字符串的长度
Django 模板列表长度
Django 模板，如果长度大于
获取查询集 Django 的长度

检查 Django 中字符串的长度

要简单地检查 Django 中字符串的长度，可以使用 len() 函数。该函数接受一个字符串输入，并返回一个整数值，即字符串的长度。

您可以使用 len 函数，如下例所示。我正在 Django shell 中执行代码。

要开始使用 Django shell，请在 windows 命令提示符下运行以下命令:

django-admin shell

现在您可以看到 len()函数如何工作并返回字符串的长度:

>>> username = 'abc'
>>> print(len(username))
3

String length in Django

这样，你就可以求出一个字符串的长度。但是，如果您想要查找 Django 模板中字符串的长度，您可以使用长度过滤器。

阅读如何在 Django 获取当前时间

Django 模板中字符串的长度

假设您正在生成一个动态字符串并将其传递给 Django 模板，您需要找到该字符串的长度。在这种情况下，您可以使用长度过滤器来查找长度。

例如，我创建了一个视图，并将一个字符串从这个视图传递给一个模板。我的 views.py 文件如下所示:

from django.shortcuts import render
def index(request):
    parameters={
        'name' : 'Harris' 
    }
    return render(request, 'index.html', parameters)

如果我想在 "Harris" 变量中呈现字符串的长度，我可以使用模板中如下所示的 length 函数:

<!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>Demo</title>
</head>
<body>
    <h3>Name is:{{name}}</h3>
    <h3>Length of name is:{{name|length}}</h3>
</body>
</html>

在上面的模板中，我访问了 name 变量，并对其应用了长度过滤器。

Length of string in Django template

这样，你可以在 Django 模板中找到一个字符串的长度。

阅读如何在 Django 中创建模型

Django 模板列表长度

通常，当我们试图将字典中的列表从视图传递到模板时，我们需要找到 Django 模板中列表的长度。在这种情况下，我们可以使用 length 过滤器来查找列表的长度。

例如，我创建了一个视图，它传递一个包含元素列表的字典。 views.py 文件如下所示:

from django.shortcuts import render
def index(request):
    list1=['Steve', 'Peter', 'Jonathan']
    return render(request, 'index.html', {'list1':list1})

您可以看到，我已经通过字典向模板传递了一个列表。现在，在模板文件中，您可以使用长度过滤器来查找该列表的长度，如下所示:

<!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>Demo</title>
</head>
<body>
    <h3>Length of list is :{{list1|length}}</h3>
</body>
</html>

Length of a list in a Django template

这样，您可以使用 Python Django 中的长度过滤器来查找列表的长度。

另请参阅，Django 中的应用程序和项目之间的差异

Django 模板，如果长度大于

既然您已经了解了长度过滤器，让我们看一个例子，在这个例子中，我们将使用 Django 模板中的大于号操作符(>)来比较字符串的长度。

在下面的例子中，我使用了一个 if 语句和一个大于运算符来比较视图中指定的列表的长度。视图文件的源代码是:

from django.shortcuts import render
def index(request):
    list1=['Steve', 'Peter', 'Jonathan', 'Rambo', 'Vicky', 'Daisy']
    return render(request, 'index.html', {'list1':list1})

我已经将包含六个项目的列表传递到一个模板文件中，该文件是:

<!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>Demo</title>
</head>
<body>
    {% if list1|length > 5%}
    <h3>Size of list is too large</h3>
    <h4>Size is : {{list1|length}}</h4>
    {% endif %}
</body>
</html>

我使用了一个 if 块。这个 if 块中的代码只有在列表长度大于 5 时才会执行，在我们的例子中是 True 。现在来看看输出。

Comparing the size of a list in an HTML template

因此，您可能已经学会了如何在 Django 模板中找到列表的长度。

阅读 Python Django 获取管理员密码

获取查询集 Django 的长度

有时，您从数据库获取结果集，并在 HTTP 响应中呈现记录。您可能希望获得结果集的长度，即结果集中的记录数，并相应地显示结果。

在这种情况下，您可以使用 count() 方法或 len() 函数来查找 queryset 中的记录数。

例如，我创建了一个视图，它从名为 Employees 的表中获取一个 queryset。该表包含如下所示的记录:

身份证明（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

我的 views.py 文件如下所示:

from app1.models import Employees
from django.shortcuts import render
def index(request):
    querysetlen = Employees.objects.count()
    return render(request, 'index.html', {'queryset':querysetlen})

您可以看到我是如何使用 count() 函数来查找查询集的长度的。

现在我将这个计数渲染到一个名为index.html的 Django 模板中，它是:

<!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>Demo</title>
</head>
<body>
    <h3>Number of records is:{{queryset}}</h3>
</body>
</html>

Length of a queryset

也可以使用 len() 函数。只需对您的 views.py 文件进行如下修改:

from app1.models import Employees
from django.shortcuts import render
def index(request):
    querysetlen = len(Employees.objects.all())
    return render(request, 'index.html', {'queryset':querysetlen})

这样，你就可以在 Django 中找到一个 queryset 的长度。

您可能会喜欢以下 Python Django 教程:

因此，您可能已经学会了如何使用各种技术找到各种 Django 对象的长度。

检查 Django 中字符串的长度
Django 模板中字符串的长度
Django 模板列表长度
Django 模板，如果长度大于
获取 queryset Django 的长度

Python Django MySQL CRUD

原文：https://pythonguides.com/python-django-mysql-crud/

在这个 Python Django 教程中，我们将学习使用 MySQL 的 Django crud 示例。这些是我们将在本教程中讨论的主题。

Python Django MySQL CRUD
Python Django MySQL CRUD 项目设置
Python Django MySQL CRUD 创建 url 模式
Python Django MySQL CRUD 创建模型
Python Django MySQL CRUD 创建模型表单
Python Django MySQL CRUD 视图函数创建
Python Django MySQL CRUD HTML 创建
Python Django MySQL CRUD 视图函数检索
Python Django MySQL CRUD HTML 检索
Python Django MySQL CRUD 视图函数更新
Python Django MySQL CRUD HTML 更新
Python Django MySQL CRUD 视图函数删除
Python Django MySQL CRUD HTML 删除
Python Django MySQL CRUD 示例

Python Django MySql CRUD
Python Django MySQL CRUD 项目设置
Python Django MySQL CRUD 创建 url 模式
Python Django MySQL CRUD 创建模型
Python Django MySQL CRUD 创建模型表单
Python Django MySQL CRUD 视图函数创建
Python Django MySQL CRUD HTML CREATE
Python Django MySQL CRUD 视图函数检索
Python Django MySQL CRUD HTML 检索
Python Django MySQL CRUD 视图函数更新
Python Django MySQL CRUD HTML 更新
Python Django MySQL CRUD 视图函数删除
Python Django MySQL CRUD HTML 删除
Python Django MySQL CRUD 示例

Python Django MySql CRUD

在本节中，我们将学习 CRUD 操作。

Django 是一个执行 CRUD 操作的 web 框架，基于 MVT 架构。CRUD 代表创建、检索、更新和删除，它们是任何 web 开发人员都应该熟悉的基本流程。

我们将了解 Django 的 CRUD 操作如下。

创建:在数据库表中，创建或添加新条目。
检索:从数据库的表中读取、检索或获取全部或部分条目。
更新:在数据库表中，更新或修改现有条目。
删除:在一个数据库表中，删除已有的记录。

另外，检查:Python Django 中的登录系统

Python Django MySQL CRUD 项目设置

在这一节中，我们将学习如何建立一个 Django 项目来用 MySQL 执行 CRUD 操作。

创建项目: 首先，我们需要创建一个 Django 项目。为此，请在终端中键入以下命令。

django-admin startproject PythonGuides

在这里，我们创建了一个名为 PythonGuides 的 Django 项目。

Python Django MySQL crud example

创建 APP: 接下来，在项目内部，我们将创建一个名为博客的 APP。稍后，我们将执行 CRUD 操作。在终端中键入以下命令创建一个应用程序。

python manage.py startapp Blog

MySQL crud example using Python Django

创建模板: 之后，我们在项目根目录下创建 TEMPLATES 文件夹。我们还将在 Templates 文件夹中创建一个 HTML 文件。

我们将创建不同的模板来执行 CRUD 操作。

search.html: 显示提取的数据。
create.html: 添加新博客。
update.html: 更新现有博客。
remove.html: 删除博客实体。

Python Django project setup MySQL crud

安装 APP: 那么，在 settings.py 文件中，一定要包含博客 app。

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'Blog'
]

INSTALLED_APPS

添加模板: 我们还需要将模板目录添加到我们项目的目录中。在 settings.py 文件中添加以下代码。

'DIRS': ['Templates']

TEMPLATES

数据库设置 :创建一个名为 Blog 的 MySQL 数据库，并将其设置在 Django 项目的 settings.py 文件中。

DATABASES = {  
    'default': {  
        'ENGINE': 'django.db.backends.mysql',  
        'NAME': 'Blog',  
        'USER':'root',  
        'PASSWORD':'',  
        'HOST':'localhost',  
        'PORT':'3306'  
    }  
}

DATABASE SETUP

安装 MySQL 客户端: 你还需要为 Python 安装 MySQL 客户端。

pip install mysqlclient

阅读: Python 过滤器不在 Django 中

Python Django MySQL CRUD 创建 url 模式

在这一节中，我们将学习创建 URL 模式来执行 MySQL CRUD 操作。

项目 URL: 在项目的 urls.py 中添加以下代码。

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('Blog.urls')),
]

我们将 Blog.urls 添加到 PythonGuides urls.py 文件中。

APP URL: 接下来，我们将为每个视图创建 URL 模式。在博客 URL . py文件中添加以下代码。

from django.urls import path
from . import views

urlpatterns = [
    path('', views.create_blog, name='create-blog'),
    path('search/', views.retrieve_blog, name='retrieve-blog'),
    path('update/<int:pk>', views.update_blog, name='update-blog'),
    path('delete/<int:pk>', views.delete_blog, name='delete-blog'),
]

Python Django MySQL CRUD 创建模型

在本节中，我们将开发一个执行 CRUD 操作的模型。

创建模型: 在 models.py 文件中添加以下代码。

from django.db import models

class Blog(models.Model):
    BlogId = models.CharField(max_length=30)
    Title = models.CharField(max_length=200)
    Author_Name = models.CharField(max_length=300)
    Start_Date = models.DateField()
    End_Date = models.DateField()

    class Meta:
        db_table = 'Blog'

我们将创建一个包含三个 CharField 和两个 DateField 的博客模型。
各自的 CharFields 分别是 BlogId 、 Title 和 Author_Name 。
并且，各自的日期字段是开始 _ 日期和结束 _ 日期。

注册型号: 在 admin.py 文件中添加以下代码。

from django.contrib import admin
from .models import Blog

admin.site.register(Blog)

我们在管理网站上注册了博客模型。

阅读:输出 Python 到 HTML Django

Python Django MySQL CRUD 创建模型表单

在本节中，我们将开发一个模型表单来执行 CRUD 操作。

创建表单: 在 forms.py 文件中添加以下代码。

from django import forms
from django.forms import ModelForm
from .models import Blog

class BlogForm(forms.ModelForm):  
    class Meta:  
        model = Blog
        fields = "__all__"

我们创建一个表单类 BlogForm 。
然后，我们使用 ModelForm 从博客模型中获取模型字段，然后通过使用这些字段我们创建一个表单。

Python Django MySQL CRUD 视图函数创建

在这一节中，我们将学习创建一个添加博客的视图函数。

create_blog VIEW: 在 views.py 文件中添加以下代码。

from django.shortcuts import render, redirect
from .forms import BlogForm
from .models import Blog

# Add Blog

def create_blog(request):
    if request.method == "POST":
        form = BlogForm(request.POST)
        if form.is_valid():
            try:
                form.save()
                return redirect('search/')
            except:
                pass
    else:
        form = BlogForm()
    return render(request, 'create.html', {'form':form})

我们定义了带有请求参数的 create_blog 函数，用户使用该参数添加他们的新博客。
该功能将用户重定向到create.html页面。

使用 PostgreSQL 阅读 Django CRUD 示例

Python Django MySQL CRUD HTML CREATE

在这一节中，我们将学习创建一个 HTML 模板来添加一个新的博客。

创建 HTML: 在【create.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>Create Blog</title>
</head>

<body>
    <h2 style="text-align:center"> Create New Blog </h2>
    <form method="POST" >
        {% csrf_token %}
        {{ form.as_p }}
        <input type="submit" class="btn btn-success">
    </form>
</body>

</html>

这里，我们使用 form 元素为用户输入创建一个 HTML 表单。
我们还将 method=POST 添加到表单标签中。
然后，我们使用 {% csrf_token %} 来保护我们的表单免受网络攻击。
接下来，我们将 Django 表单呈现为段落。

CREATE NEW FORM

阅读: Python Django 随机数

Python Django MySQL CRUD 视图函数检索

在这一节中，我们将学习创建一个视图函数，显示用户添加的所有博客列表。

检索 _ 博客视图: 在 views.py 文件中添加以下代码。

from django.shortcuts import render, redirect
from Blog.forms import BlogForm
from Blog.models import Blog

# Search Blog

def retrieve_blog(request):
    blogs = Blog.objects.all()
    return render(request,'search.html',{'blogs':blogs} )

我们用请求参数定义了 retrieve_blog 函数。
它显示了用户进入博客的所有细节。
该功能将用户重定向到search.html页面。

Python Django MySQL CRUD HTML 检索

在这一节中，我们将学习创建一个 HTML 模板来显示用户添加的博客列表。

搜索 HTML: 在【search.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 Blog</title>
</head>
<style>
    table,
    th,
    td 
    {
        border: 2px solid;
    }
</style>

<body>
    <h2 style="text-align:center"> Blog Informationn </h2>
    <table align="center" style="margin: 0px auto;">
        <thead>
            <tr>
                <th>Blog ID</th>
                <th>Title</th>
                <th>Author</th>
                <th>Start Date</th>
                <th>End Date</th>
                <th>Edit Blog</th>
                <th>Remove Blog</th>
            </tr>
        </thead>
        <tbody>
            {% for blog in blogs %}
            <tr>
                <td>{{blog.BlogId}}</td>
                <td>{{blog.Title}}</td>
                <td>{{blog.Author_Name}}</td>
                <td>{{blog.Start_Date}}</td>
                <td>{{blog.End_Date}}</td>
                <td>
                    <a href="/update/{{blog.pk}}">Update</a>    
                </td>
                <td>
                    <a href="/delete/{{blog.pk}}">Delete</a>
                </td>
            </tr>
            {% endfor %}
        </tbody>
    </table>
</body>

</html>

在这里，我们创建 HTML 模板，在表格中显示用户输入的所有博客列表。
以下是表格的标题:
- 博客 ID: 显示博客 ID。
- 标题:显示博客的标题。
- 作者:显示谁写了特定的博客。
- 开始日期:作者开始写这篇博客的时间。
- 结束日期:作者结束博客的时间。
它还显示以下操作按钮:
- 更新:编辑用户添加的具体条目。
- 删除:删除用户添加的特定条目。

RETRIEVE BLOG INFORMATION

阅读: Python 改 Django 版本

Python Django MySQL CRUD 视图函数更新

在这一节中，我们将学习创建一个视图函数来更新用户添加的博客。

更新 _ 博客视图: 在 views.py 文件中添加以下代码。

from django.shortcuts import render, redirect
from Blog.forms import BlogForm
from Blog.models import Blog

# Update Blog

def update_blog(request,pk):
    blogs = Blog.objects.get(id=pk)
    form = BlogForm(instance=blogs)

    if request.method == 'POST':
        form = BlogForm(request.POST, instance=blogs)
        if form.is_valid():
            form.save()
            return redirect('/search')

    context = {
        'blogs': blogs,
        'form': form,
    }
    return render(request,'update.html',context)

更新视图类似于创建视图。
唯一不同的是，这里我们创建了 update_blog 函数，并且我们还将 blogs 实例传递给表单。
我们根据博客的主键进行更新。

Python Django MySQL CRUD HTML 更新

在这一节中，我们将学习如何开发一个 HTML 模板来更新用户添加的特定字段。

更新 HTML: 在【update.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 Blog</title>
</head>

<body>
    <h2 style="text-align: center; padding-top: 1em; padding-bottom: 1em;">Edit Blog</h2>

    <form action="" method="POST">
        {% csrf_token %}
        {{ form.as_p }}
        <input type="submit" class="btn btn-success">
    </form>
</body>

</html>

这里，我们使用 form 元素来创建一个 HTML 表单。
通过使用这个表单，用户可以编辑他们想要的任何字段。

阅读: Python Django vs 金字塔

Python Django MySQL CRUD 视图函数删除

在本节中，我们将学习创建一个视图函数，用于删除用户添加的特定条目。

删除 _ 博客视图: 在 views.py 文件中添加以下代码。

from django.shortcuts import render, redirect
from Blog.forms import BlogForm
from Blog.models import Blog

# Delete Blog

def delete_blog(request, pk):
    blogs = Blog.objects.get(id=pk)

    if request.method == 'POST':
        blogs.delete()
        return redirect('/search')

    context = {
        'blogs': blogs,
    }
    return render(request, 'remove.html', context)

当有人点击 Delete 时，我们从数据库中删除实例。

此外，检查:Python Django 中网站的简单联系表

Python Django MySQL CRUD HTML 删除

在这一节中，我们将学习如何开发一个 HTML 模板来删除用户添加的条目。

删除 HTML: 在【remove.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 Blog</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 "{{ blogs.emp_name }}"?
        </div>

        <p>
            <a href="{% url 'retrieve-blog' %}"><--Return</a>
        </p>

        <p>
            <input class="btn btn-danger" type="submit" value="Confirm">
        </p>
    </form>
</body>

</html>

这里，我们创建一个 HTML 模板，删除用户想要删除的特定条目。
并且它还在删除过程之前确认一次。
当我们点击返回按钮时，我们也可以返回到上一页，即搜索模板。

Read: Django 从 POST 请求中获取所有数据

Python Django MySQL CRUD 示例

在本节中，我们将使用 MySQL 关系数据库管理系统执行 Django CRUD 示例。

首先，我们必须在终端上运行一些命令来创建模型。

命令如下:

python manage.py makemigrations

python manage.py migrate

然后，我们必须运行服务器，为此在终端中键入以下命令。

python manage.py runserver

启动服务器，通过将 URL 定义为 http://127.0.0.1:8000 来访问表单。

首先，在表单中输入所有详细信息以创建一个新博客，然后单击提交按钮。

Add New Blog

让我们看看它在 MySQL 中的样子。

MySQL

当我们点击提交按钮，它呈现搜索 HTML 模板。

BLOG INFORMATION

我们可以看到，如果我们想编辑博客，我们可以使用更新按钮，如果我们想删除博客，我们可以使用删除按钮。

现在，看看当我们点击更新按钮时会是什么样子。

UPDATE HTML TEMPLATE

现在，我们可以编辑任何字段。

EDIT BLOG INFORMATION

在这里，我编辑表单的结束日期字段。
我将结束日期从 2022 年 3 月 6 日更改为 2022 年 3 月 8 日。

现在，看看当我们点击提交按钮时会发生什么。

EDIT BLOG INFORMATION

在这里，我们看到结束日期已经更新。

MySQL

我们可以看到它还更新 MySQL 上的博客信息。

现在，看看当我们点击删除按钮时是什么样子。

DELETE HTML TEMPLATE

现在我们可以看到，在删除之前，它确认了一次“您确定要删除。

现在，看看如果我们点击返回会发生什么。

我们可以看到它把我们带回了博客信息。

现在，看看如果我们点击确认会发生什么。

DELETE

我们可以看到它删除了博客。

DELETE MySQL

我们可以看到它还会从 MySQL 数据库中删除博客。

你可能也喜欢阅读下面的 Django 教程。

在本 Django 教程中，我们已经讨论了" Python Django CRUD 示例(MySQL) "并且我们还讨论了本教程中的以下主题。

Python Django MySQL CRUD
Python Django MySQL CRUD 项目设置
Python Django MySQL CRUD 创建 url 模式
Python Django MySQL CRUD 创建模型
Python Django MySQL CRUD 创建模型表单
Python Django MySQL CRUD 视图函数创建
Python Django MySQL CRUD HTML 创建
Python Django MySQL CRUD 视图函数检索
Python Django MySQL CRUD HTML 检索
Python Django MySQL CRUD 视图函数更新
Python Django MySQL CRUD HTML 更新
Python Django MySQL CRUD 视图函数删除
Python Django MySQL CRUD HTML 删除
Python Django MySQL CRUD 示例

如何使用 Python Django pre_save

原文：https://pythonguides.com/python-django-pre_save/

有时候，在执行了像在 Django 模型中输入、删除和更新数据这样的 Django 操作之后，您想要运行某个函数或者进行修改。

那时，你需要一个 Django 信号。在本文中，我们将研究 Django 信号及其类型 pre_save。还有，我已经讲了这几点:—

先决条件
Django 的预保存信号是什么
在 Django 中何时使用 pre_save 信号
Django pre_save 信号如何使用 receiver decorator 工作
Django pre_save 信号如何使用 connect 方法工作

先决条件
Python Django 预保存信号
在 Django Python 中使用 pre_save 信号
Python Django pre_save 使用接收器装饰器
Python Django pre_save 使用连接方法
结论

先决条件

在前进到 pre_save 信号之前。Django 要求你对信号有所了解。我们来理解一下信号。

当您想要在事件之前或之后在模型或数据库上执行某段代码时，您可以使用 Django 信号。信号用于执行任何修改或创建模型实例的操作。基本上，信号是支持事件和动作之间关系的工具。

例如，考虑这样一个场景，您有一个 Django 食品订购项目，它有一个订单和目录模型。业务逻辑是这样的，在保存订单之前，应该检查目录以确保食品有库存。此外，在保存订单后，应该有一个逻辑来发送订单已收到的通知。

结果，我们现在明白 Django 的信号是什么了。

阅读:在 Django 中运行 Python 脚本

Python Django 预保存信号

你对信号有个大概的了解。所以，现在我们来讨论一下 pre_save 信号。

pre_save 信号在数据保存到数据库之前必须执行逻辑的情况下使用。 pre_save() 信号函数的语法如下。

django.db.models.signals.pre_save(sender, instance, raw, using, update_fields)

这个函数在一个 model save() 方法的开始被发送。以下是参数。

参数	描述
发报机	它指定了模型类。
情况	正在保存的实际实例。
生的	如果为 True，模型将完全按照显示的内容保存。
使用	数据库中使用的别名。
更新 _ 字段	传递给需要更新的模型的字段。如果没有向 save()提供 update_fields，默认值为 None。

至此，我们已经学习了预保存信号的介绍。

阅读: Python Django 连接字符串

在 Django Python 中使用 pre_save 信号

在了解了 pre_save 信号之后。现在，让我们学习何时使用 Django pre_save 信号。

当你想把一个函数产生的值保存到数据库中时，你经常使用 pre_save 信号。

至此，我们已经了解了 pre_save 信号的用途。

Python Django pre_save 使用接收器装饰器

让我们首先了解一下接收器函数，然后，我们将使用接收器装饰器检查一个 Django pre_save 信号示例。

接收器是 python 函数，路由到每个信号。当信号发送消息时，连接的每个接收器接收呼叫。接收器函数的语法如下。

def receiver_func(sender, request, user, **kwargs)

@接收器装饰器用于将接收器连接到信号。接收器装饰器的语法如下:

@receiver(signals.pre_save, sender= <sender_name>

这些参数如下:

参数	描述
信号	指定要使用的信号类型或信号列表。此处作为 signals.pre_save 传递。
发报机	指定接收信号的发送方。

一个与@ 接收者装饰者相关的例子:

首先，使用下面给出的命令在 Django 中创建一个项目(名为 "eCartProject" )。

django-admin startproject eCartProject

通过在终端键入下面的命令，在 Django 项目中创建一个 Django 应用程序(名为 "eCartApp" )。

python manage.py startapp eCartApp

将 "eCartApp" 应用添加到位于 settings.py 文件中的已安装应用列表中。

Settings.py in Django Project

默认情况下，Django 在项目下有一个 urls.py 文件。Django 建议将新创建的应用程序“eCartApp”映射到其中。

from django.contrib import admin
from django.urls import path,include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('',include('eCartApp.urls')),
]

创建 Django 模型，定义 "eCartApp" 应用程序的字段和行为。打开 Django 应用中的 models.py 文件，添加以下代码。

from django.db import models

# Create your models here.

class Order(models.Model):
    item = models.CharField(max_length=50)
    price = models.FloatField()
    delivery = models.FloatField()
    quantity = models.IntegerField()

    def __str__(self):
        return self.item

在这里，我们用以下数据库字段创建一个模型类“Order”。

项目:项目的名称。
价格:物品的价格。
送货:物品的送货费用。
数量:可用库存中的食品数量。

并使用 def str(self) 来更改 Django 模型中对象的显示名称。当我们返回自我时，它会显示物品名称。物品。

要在管理站点注册模型 "Order" ，打开 admin.py 文件并添加下面给出的代码。

from django.contrib import admin
from .models import Order

# Register your models here.

class OrderAdmin(admin.ModelAdmin):
    list_display = ("item", "price", "delivery", "quantity")

admin.site.register(Order, OrderAdmin)

在 app 目录下创建一个 urls.py 文件。

from django.urls import path

urlpatterns = [

]

在 app 目录下创建一个 signals.py 文件。并在其中添加以下代码。

注意:您可以向任一型号的模块添加信号，或者为信号创建单独的文件。但是将信号保存在一个单独的文件中总是一个好主意，因为对于信号，您需要导入一些其他模块，这可能会产生意想不到的后果。

from django.db.models.signals import pre_save
from django.dispatch import receiver
from .models import Order

# pre_save signal using decorator

@receiver(signals.pre_save, sender=Order)

def check_delivery(sender, instance, **kwargs):
    if not instance.delivery:
        instance.delivery = 50
        print("Item Purchased:",instance.item)
        print("Price:",instance.price)
        print("Delivery Charges:",instance.delivery)
    else:
        print("Item Purchased:",instance.item)
        print("Price:",instance.price)
        print("Delivery Charges:",instance.delivery)

首先，我们导入了预保存信号和接收器、和订单模型，然后我们创建了一个接收器函数 check_delivery() ，它将接收一个预保存信号。然后我们使用一个 @receiver decorator 来调用关于商品配送费用的 check_delivery() 函数。

check _ delivery()receiver 函数接受 sender、instance 和 kwargs 参数。我们使用if–else语句来检查订单中是否提到了产品的运费。

如果是，则使用 print() 功能在终端上打印物品名称、价格和运费[即执行 else 部分]。如果否，则使用 print() 功能【即如果零件执行】在终端上打印物品名称、价格和指定的送货费用。

正如 Django 社区建议将信号放在一个单独的文件中，您也必须将它放在一个 apps.py 文件中。添加下面给出的代码。

from django.apps import AppConfig

class EcartappConfig(AppConfig):
    name = 'eCartApp'

    def ready(self):
        import eCartApp.signals

每当 Django 加载项目及其应用程序时，都会在每个应用程序的 Appconfig 实例上调用 ready() 方法。

在这里，您使用这个方法告诉 Django 关于应用程序中的信号处理程序，以便 Django 知道它们的存在。

打开 init。py 文件，并将给定的代码添加到其中。

default_app_config = 'eCartApp.apps.EcartappConfig'

由于您已经在应用程序中创建了自定义 AppConfig 类，因此您必须通知 Django 它的存在。为此，您必须在 init 中设置变量 default_app_config 。应用程序的 py 文件。

额外收获:如果你不想在 init 中添加自定义 AppConfig 类。py 文件。在 settings.py 文件中添加自定义 AppConfig 类名，而不是应用程序名，如下所示。

settings.py

使用下面显示的命令为指定的模型生成迁移。将创建一个迁移文件，并放在迁移文件夹中。

python manage.py makemigrations

要反映数据库，首先创建一个迁移，然后迁移它。下面列出了 migrate 命令。

python manage.py migrate

在终端中输入以下命令创建超级用户。

python manage.py createsuperuser

要在“Order”模型中添加记录，请打开管理应用程序并添加它。

Order Model in Admin Site

现在，让我们看看预保存信号的工作情况。所以，如果你订购一件有运费的商品。以下是屏幕上的输出。

An item with delivery charges

pre_save signal output

如果你订购的商品没有送货费。它将调用 pre_signal 并自动将其更改为 50。以下是屏幕上的输出。

An item with zero delivery

pre_save signal example

这就是你如何使用 Django pre_save 信号工作。

阅读: Python Django app 上传文件

Python Django pre_save 使用连接方法

您已经通过 receiver decorator 学会了使用 pre_save 信号类型。因此，现在我们将继续学习另一种方法，即使用 pre_save 信号的 connect 方法。

要接收信号，使用 connect() 方法注册一个接收器函数。当信号发出时，接收器功能被激活。信号的每个接收器函数都被调用一次，按照它被注册的顺序。

下面是 connect() 方法的语法。

pre_save.connect(recevier_func, sender=None, weak=True, dispatch_uid=None)

这些参数如下:

参数	描述
recept _ func	回调函数将连接到信号。
发报机	定义接收信号的特定发送方。
无力的	如果接收方是本地函数，它可能会被垃圾回收。为了防止这种情况，将其 bool 值设置为 False。
调度 _uid	在可能发送重复信号的情况下，信号接收器的唯一标识符。

一个与 connect() 方法相关的例子:

首先，使用下面给出的命令在 Django 中创建一个项目(名为 "Hotel" )。

django-admin startproject Hotel

通过在终端键入下面的命令，在 Django 项目中创建一个 Django 应用程序(名为 "FoodCourt" )。

python manage.py startapp FoodCourt

将“food court”应用添加到位于 settings.py 文件中的已安装应用列表中。

settings.py

默认情况下，Django 在项目下有一个 urls.py 文件。Django 建议将新创建的应用程序“美食广场”映射到其中。

from django.contrib import admin
from django.urls import path,include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('',include('FoodCourt.urls')),
]

创建 Django 模型，定义“food court”应用程序的字段和行为。打开 Django 应用中的 models.py 文件，添加以下代码。

from django.db import models

# Create your models here.

class Catalog(models.Model):
    item = models.CharField(max_length=50)
    item_code = models.IntegerField()
    quantity = models.IntegerField()

    def __str__(self):
        return self.item

class Order(models.Model):
    order_number = models.CharField(max_length=20)
    catalog_item = models.ForeignKey(Catalog, on_delete=models.CASCADE)
    quantity = models.IntegerField()

    def __str__(self):
        return self.order_number

这里，我们首先创建一个模型类“Catalog”，它具有以下数据库字段。

项目:食品项目的名称。
item_code: 食品项目的代码。
数量:可用库存中的食品数量。

并使用 def str(self) 来更改 Django 模型中对象的显示名称。当我们返回自我时，它会显示物品名称。物品。

然后我们创建一个模型类“Order”，它有以下数据库字段。

订单编号:订单的订单编号。
catalog_item: 它是一个外键，用于映射关系数据库中表之间的关系。
数量:订购食品的数量。

并使用 def str(self) 来更改 Django 模型中对象的显示名称。当我们返回自身时，它将呈现订单号。订单 _ 编号。

要在管理站点注册模型“目录”和“订单”，打开 admin.py 文件并添加下面给出的代码。

from django.contrib import admin
from .models import Catalog,Order

# Register your models here.

class CatalogAdmin(admin.ModelAdmin):
    list_display = ("item", "item_code", "quantity")

class OrderAdmin(admin.ModelAdmin):
    list_display = ("order_number", "catalog_item", "quantity")

admin.site.register(Catalog, CatalogAdmin)
admin.site.register(Order, OrderAdmin)

在 app 目录下创建一个 urls.py 文件。

from django.urls import path

urlpatterns = [

]

在上面的例子中，你已经学会了在 signals.py 文件中创建一个信号。所以，如你所知，我们也可以在 models.py 文件中添加信号代码。将下面给出的代码添加到 models.py 文件中，通过 connect() 方法使用 pre_save 信号。

from django.db.models.signals import pre_save

# pre_save signal with connect() method

def verify_order(sender, instance, **kwargs):
    if instance.quantity < instance.catalog_item.quantity:
        print('Your Order Number:', instance.order_number)
        print('Orderd Successfully')
    else:
        print('Your Order Number:',instance.order_number)
        print('Item Name:', instance.catalog_item)
        print('Out of stock')

pre_save.connect(verify_order, sender=Order)

首先，我们导入了预保存信号，然后我们创建了一个接收函数 verify_order() ，它将接收一个预保存信号。然后我们使用一个 connect() 方法来调用食物的订单上的 verify_order() 函数。

verify_order() receiver 函数接受 sender、instance 和 kwargs 参数。我们使用if–else语句来检查订购的食物数量是否少于目录中的食物数量。

如果是，则使用 print() 功能在终端上打印订单号和信息。如果否，则使用 print() 功能在终端上打印订单号、项目名称和信息。

要为模型创建一个迁移，使用下面给出的命令。在迁移文件夹中，将创建一个迁移文件。

python manage.py makemigrations

创建一个迁移，然后迁移它以反映数据库。下面是 migrate 命令。

python manage.py migrate

要创建超级用户，请在终端中键入以下命令。

python manage.py createsuperuser

要在“Catalog”模型中添加记录，请打开管理应用程序并添加它。

Catalog Model in Admin Site

现在，让我们看看预保存信号的工作情况。因此，如果你订购的商品数量少于目录中的食品数量。以下是屏幕上的输出。

An item with a quantity less than the quantity of the food

Django pre_save using connect

如果您订购的商品数量大于目录中的食品数量。以下是屏幕上的输出。

Item order greater than the item in catalog

Django pre_save signal

这就是你如何使用 Django 的 pre_save 信号使用 connect 方法工作。

阅读:模型 Django 上的联合操作

结论

这样，我们就知道了 Django 信号，也能够创建可靠的 web 应用程序，在 pre_save 期间预处理数据。凭借这种灵活性，您还可以创建独特的工作流，更有效地满足特定用例的需求。

此外，我们还讨论了以下主题。

先决条件
Django 的预保存信号是什么
在 Django 中何时使用 pre_save 信号
Django pre_save 信号如何使用 receiver decorator 工作
Django pre_save 信号如何使用 connect 方法工作

另外，看看更多的 Python Django 教程。

使用下拉过滤器的 Python Django 搜索

原文：https://pythonguides.com/python-django-search-with-dropdown-filter/

在这个 Python Django 教程中，我将通过简单的步骤解释如何在 Django 中使用下拉过滤器进行搜索。

最近，我一直在使用 Django 框架创建一个网站。我需要一个下拉菜单来搜索特定标准的员工。

在这里我们将看到:

如何用简单的步骤建立 Django 项目
用下拉过滤器实现 Python Django 搜索
如何在 Django 中添加下拉菜单
创建基于函数的视图来呈现模板
如何在 Django 中创建模型
从 Django 管理界面添加数据

在本文的最后，您还可以使用 Django 在网站上下载带有下拉菜单的搜索代码。

使用下拉过滤器的 Python Django 搜索
下载 Python Django 搜索和下拉过滤器完整代码
结论

使用下拉过滤器的 Python Django 搜索

现在，让我们首先了解什么是搜索框，并一步一步地学习在 Django 中添加下拉菜单进行搜索。

Django 搜索框

搜索框、搜索栏或搜索栏是文件管理器、web 浏览器和其他计算机程序以及网站中常见的图形控制元素。

搜索框允许用户通过输入或从下拉菜单中选择来搜索指定的内容。

如何在 Django 中创建下拉菜单进行搜索

现在，我们将看到一个与创建下拉菜单相关的示例，该菜单根据员工的职务来搜索员工。

Django Search with Dropdown Filter

建立 Django 项目

要启动 Django 项目，请打开终端并输入以下命令。这里， DropdownSearchProject 是 Django 项目的名称。

django-admin startproject DropdownSearchProject

它将创建一个名为 DropdownSearchProject 的文件夹，并在终端中输入下面的命令。

cd DropdownSearchProject

通过在终端中键入下面的命令，在这个项目文件夹中创建一个名为 MyApp 的 Django 应用程序。

python manage.py startapp MyApp

将应用名称添加到位于 settings.py 文件中的 INSTALLED_APP 列表中，以激活该应用。

Install App inside 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 中创建模型，打开 app 目录中的 models.py 文件，并添加下面给出的代码。

from django.db import models

# Create your models here.

class Employee(models.Model):
    emp_id=models.IntegerField(primary_key=True)
    name=models.CharField(max_length=150)
    gender=models.CharField(max_length=8)
    designation=models.CharField(max_length=150)
    def __str__(self):
        return self.name
    class Meta:
        db_table = 'Employee'

在这里，我们创建一个模型类雇员有以下字段。

emp_id 是 Django IntegerField，并作为主键。
的名字是姜戈·查菲尔德。这个字符字段有 150 个字符的限制。
性别是姜戈·查菲尔德。此字符字段限制为 8 个字符。
的名称是 Django CharField。这个字符字段有 150 个字符的限制。

并使用 def __str__(self) 来更改 Django 模型中对象的显示名称。当我们返回自己的名字时，它会将项目名称渲染为名称。我们还将模型的名称更改为 Employee。

将模型注册到管理站点，以便用户可以在管理应用程序中查看它。打开 admin.py 文件，添加下面给出的代码。

from django.contrib import admin
from .models import Employee

# Register your models here.
admin.site.register(Employee)

阅读: Python 改 Django 版本

使用下拉过滤器创建 Python Django 搜索

在 Django 中，应用程序的前端是在模板中定义的，为此，在主项目目录中创建一个名为模板的子目录来存储所有的项目模板。

打开 settings.py 文件，更新 DIRS 指向 Templates 文件夹的位置。

settings.py

创建一个home.html文件来添加 HTML 代码，用于创建一个下拉菜单，以便在模板文件夹内的 Django 中进行搜索。

<!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>
    <center>
        Search Employees using Dropdown Search
        <hr>
        <form method="POST>">
            {% csrf_token %}
            <select name="gender">
                <option selected disabled=true>--Select Gender--</option>
                <option>Male</option>
                <option>Female</option>
                <option>Other</option>
            </select>
            <select name="designation">
                <option selected disabled=true>--Select Designation--</option>
                <option>HR</option>
                <option>Team Lead</option>
                <option>Junior IT Engineer</option>
                <option>Senior IT Engineer</option>
            </select>
            <input type="submit" value="Search">
            <hr>
            <table border="1">
                <tr>
                    <th>Employee ID</th>
                    <th>Name</th>
                    <th>Gender</th>
                    <th>Designation</th>
                </tr>
                {% for result in data %}
                <tr>
                    <td>{{result.emp_id}}</td>
                    <td>{{result.name}}</td>
                    <td>{{result.gender}}</td>
                    <td>{{result.designation}}</td>
                </tr>
                {% endfor %}
            </table>

        </form>

    </center>
</body>

</html>

我们将通过使用 POST 方法调用表单标签来呈现 HTML 文件。
为了保护页面免受黑客攻击，并使安全发送数据成为可能，我们在 form 元素中包含了 csrf_token 。
然后，我们将使用 select HTML 标签为性别和称谓字段创建一个下拉字段。
添加一个搜索按钮，根据使用下拉字段选择的性别和职位搜索员工。
然后，我们将使用带有 border 1 的表标签来存储员工 Id 、姓名、性别和职务。
在此之后，循环的用于获取数据上下文，我们在视图文件中的渲染函数中传递该上下文。

阅读: Python Django 设置时区

定义视图

要定义应用程序的主要逻辑，打开 views.py 文件并添加下面给出的代码。

from django.shortcuts import render
from MyApp.models import Employee

# Create your views here.

def dropdownsearch(request):
    if request.method=="POST":
        searchgender=request.POST.get('gender')
        searchdesignation=request.POST.get('designation')
     empsearch=Employee.objects.filter(gender=searchgender,designation=searchdesignation)

        return render(request,'home.html',{"data":empsearch})
    else:
        displayemp=Employee.objects.all()

        return render(request,'home.html',{"data":displayemp})

创建一个名为 dropdownsearch 的视图，首先从 models.py 文件中导入员工。
之后，执行 if 语句确定请求方法是否为 POST 。
- 如果是这样，只需使用请求获取性别和名称。POST.get() 。
- 然后，我们使用 empsearch QuerySet 和 filter 方法返回性别和称谓。
- 之后，我们使用渲染函数，该函数返回带有 empsearch 模型查询集对象的home.html文件。
如果请求方法是则得到。
- 我们使用display EMPquery set withall方法从模型中返回每个对象。
- 在这之后，我们使用渲染函数，该函数返回带有 displayemp 模型查询集对象的home.html文件。

现在，我们必须用 URL 映射视图以便调用它，因此我们必须在 app 目录中创建一个名为 urls.py 的文件。包括下面的代码。

from django.urls import path
from . import views

urlpatterns = [
path('', views.dropdownsearch, name='dropdownsearch'),
]

阅读: Python Django vs ReactJS

执行 Django 模型

要创建包含模型表格模式代码的迁移文件，请在终端中键入以下命令。

python manage.py makemigrations

要按照迁移文件的模式构建表，请执行以下命令。

python manage.py migrate

从 Django 管理界面添加数据

要从 Django 管理界面添加雇员，首先我们必须创建一个管理员。在给定的命令下键入。

python manage.py createsuperuser

然后，点击 MYAPP 下的员工。点击添加选项添加员工详细信息，然后点击保存按钮。

Admin Interface to add Employee

以下是员工名单。

List of all the employees

执行 Django 应用程序

要启动开发服务器，请在终端中键入下面给出的命令。

python manage.py runserver

它将打开，页面以表格格式显示员工的详细信息。

Employee Details

现在，我想使用下拉菜单和搜索按钮搜索一名性别为男性、职务为初级 IT 工程师的员工。

Search employees using dropdown search

它将显示所有员工的性别男性和名称初级 It 工程师。

Gender=Male and Designation=Junior IT Engineer

这就是如何在 Python Django 中使用下拉过滤器进行搜索。

下载 Python Django 搜索和下拉过滤器完整代码

结论

这样，我们就成功地创建了一个 Django web 应用程序，它可以使用下拉过滤器进行搜索。此外，我们已经学会了将 Django QuerySet 与 filter() 和 all() 方法一起使用。
此外，我们还讨论了以下主题。

如何用简单的步骤建立 Django 项目
用下拉过滤器实现 Python Django 搜索
如何在 Django 中添加下拉菜单
创建基于函数的视图来呈现模板
如何在 Django 中创建模型
从 Django 管理界面添加数据

您可能也喜欢阅读下面的 Python Django 教程。

Tanya Puri

拥有丰富 Django 和 Matplotlib 经验的 Python 开发人员，目前在 TSInfo Technologies 工作。我正在成为专业程序员、博客写手和 YouTuber 的路上。

Python Django 设置时区

原文：https://pythonguides.com/python-django-set-timezone/

在本 Django 教程中，我们将了解如何在 python Django 中设置时区。我们还将讨论与 Django 时区相关的例子。这是我们将要涉及的主题列表。

Python Django 设置时区
Python Django 设置时区设置
Python Django 设置时区 UTC
Python Django 将时区设置为东部时间
Python Django 将时区设置为 IST
Python Django 为用户设置时区

Python Django 设置时区
Python Django 设置时区设置
Python Django 设置时区 UTC
Python Django 将时区设置为东部时间
Python Django 将时区设置为 IST
Python Django 为用户设置时区

Python Django 设置时区

时区只是地球上的一个区域，每个人都在同一个时钟上。然而，由于所谓的夏令时，一个给定的时区可能不会全年遵循相同的时间。

因为这些问题，全球同意采用一个世界时间标准，不管你在哪里，也不管现在是一年中的什么时候，这个标准都是不变的。协调世界时，或 UTC ，是它的名字。

比如我住在印度，印度比 UTC 早 5 小时 30 分，所以这个时间是UTC 晚上 10:32:10+5:30。格林威治时间下午 10:32:10+5:30是另一种写法。GMT 和 UTC 在时间上没有区别；尽管如此，GMT 是一个时区，而 UTC 是一个时间测量标准。

另外，检查:如何获得 Django 的当前时间

Python Django 设置时区设置

为了在数据库中保存信息，Django 建议使用 UTC。即使您的网站只能在一个时区内访问，在数据库中存储 UTC 格式的数据仍然是一个不错的策略。夏令时是造成这种情况的主要原因。

夏令时是一种计时系统，在许多国家，时钟在春天向前推，在秋天向后推。如果你按当地时间工作，当时钟改变时，你很可能一年遇到两次问题。

您只需要在 Django 应用程序的 settings.py 中配置一些东西来设置时区。

TIME_ZONE = '<Time zone of your choice>'
USE_TZ = True

默认情况下，时区是 UTC，而 T2 的使用 TZ 的时间被设置为真，这确保了在 Django 应用程序中使用 datetime . now()函数来创建 UTC 时间。

Python Django 设置时区 UTC

现在，在本节中，我们将讨论如何将时区设置为 UTC。为了演示这个主题，我们使用 Django 中的交付模型。该模型包含以下数据。

Delivery Model

Django 的时区默认设置为 UTC。如果您的时区不是 UTC，您可以使用以下过程进行更改:

打开我们项目目录下的 setting.py 文件。
通过向下滚动文件可以找到国际化。
时区将出现在此下方。
将其设置为“UTC”。

设置时区的命令:

TIME_ZONE='UTC'

现在，您可以启动服务器并登录到管理界面。之后，打开您的交付模型，您会注意到时间已经更改为 UTC。

TIME_ZONE = UTC

Python Django 将时区设置为东部时间

现在，在这一节中，我们将讨论如何将时区设置为美国东部时间。为了说明这个主题，我们使用 Django 中的交付模型。该模型包含以下数据，默认情况下，该模型中使用的时区是 UTC。

Delivery Model

要设置时区，首先必须在 Django 应用程序的 settings.py 中设置一些东西，如下所示:

设置时区的命令:

TIME_ZONE = 'EST'

现在，您可以启动服务器并访问管理界面。当您打开您的交付模型时，您会看到时间已经更改为美国东部时间。

下面是输出，它清楚地显示了时区更改为美国东部时间。

TIME_ZONE = EST

阅读:Django 模板中的 If 语句

Python Django 将时区设置为 IST

现在，在这一节中，我们将讨论如何将时区设置为 IST。为了说明这个主题，我们使用 Django 中的交付模型。该模型包含以下数据，默认情况下，该模型中使用的时区是 UTC。

Delivery Model

这里 IST 指的是印度标准时间，也就是亚洲/加尔各答的时区。而且，要设置时区，您必须首先在 Django 应用程序的 settings.py 中设置一些东西，如下所示:

设置时区的命令:

TIME_ZONE = 'Asia/Kolkata'

现在，您可以启动服务器并访问管理界面。当您打开您的交付模型时，您会看到时间已经更改为 IST。

下面是输出，它清楚地显示时区更改为 IST。

TIME_ZONE = IST

阅读:获取 Django 中的 URL 参数

Python Django 为用户设置时区

在这一节中，我们将学习如何根据用户的本地时间戳为他们设置时区。如果您想在本地时区创建时间戳。在 Django 项目的 settings.py 文件中执行以下设置。

USE_TZ = FALSE

如果您将 USE_TZ 设置为 False ，Django 会认为您的应用程序不关心时区。它指的是 Django 应用程序所在的位置；例如，如果您在本地计算机上运行它，它将使用该时间。

让我们看一个例子来清楚地理解这个概念:

默认情况下，时区设置为“UTC”，使用时区设置为“True”。因此，当我们获取时间时，它显示的是 UTC 时间。

views.py 文件:

from django.http import HttpResponse
from django.utils import timezone

# Create your views here.

def home(request):
    current_time = timezone.now().strftime('%H:%M:%S')
    html = "<html><body><b>Current Time Value:</b> %s</body></html>" % 
            current_time
    return HttpResponse(html)

在上面的例子中，我们从 django.utils 模块中导入了时区类。接下来，我们创建了一个名为家的视图。在这个视图中，我们使用的是 timezone.now()。strftime() 方法将当前时间值存储在一个变量中。然后，我们使用变量返回当前时间值作为 HTTP 响应。

现在，如果我们运行开发服务器并移动到映射的 URL，我们将得到以下输出。

UTC Time Zone

现在，如果您将时区设置为“UTC ”,并且将时区设置为“False”。它将按照当地时区显示时间。在本例中，当地时区是亚洲/加尔各答。

views.py 文件:

from django.http import HttpResponse
from django.utils import timezone

# Create your views here.

def home(request):
    current_time = timezone.now().strftime('%H:%M:%S')
    html = "<html><body><b>Current Time Value:</b> %s</body></html>" % 
current_time
    return HttpResponse(html)

现在，如果我们运行开发服务器并移动到映射的 URL，我们将得到以下输出。

Local Time Zone

你可能也喜欢阅读下面的 Django 教程。

在这个 Django 教程中，我们讨论了如何在 python Django 中设置时区。此外，我们还讨论了以下主题列表:

Python Django 设置时区
Python Django 设置时区设置
Python Django 设置时区 UTC
Python Django 将时区设置为东部时间
Python Django 将时区设置为 IST
Python Django 为用户设置时区

Python Django 与 Flask 的主要区别

原文：https://pythonguides.com/python-django-vs-flask/

Django 和 Flask 都是非常流行的基于 python 的 web 开发框架。由于两者都用于相同的目的，在它们之间选择一个总是令人困惑。所以在本文中，我们将讨论 Django 和 Flask 之间的一些主要差异。并且，我们也会试着去理解什么时候选择哪一个。

本文中讨论的主题的详细列表如下。

Django 简介
姜戈的优势和劣势
烧瓶简介
烧瓶的优缺点
Python Django 与 Flask 的主要区别
Python Django vs Flask 性能

Django v/s Flask

所以，在直接讨论 python Django 和 Flask 之间的差异之前。我们应该对什么是 Django，什么是 Flask 有一个基本的了解。我们先从了解 Django 开始。

Django 简介
优点&姜戈的缺点
- Django 的优势
- 姜戈的缺点
烧瓶介绍
优点&烧瓶的缺点
- 烧瓶的优点
- 长颈瓶的缺点
Python Django 与 Flask–主要区别
Python Django vs Flask 性能
结论

姜戈简介

Django 是一个基于 python 的全栈 web 开发框架。它是一个遵循模型-视图-模板 (MVT)架构的免费开源框架。现在，Django 提供了许多内置功能，所以作为开发人员，我们只需要构建业务逻辑。

现在如果想深入了解 Django，也可以参考下面这篇文章“什么是 python Django ”。

优点&缺点姜戈

在这一节中，我们将讨论在我们的项目中使用 Django 框架的一些主要优点和缺点。

让我们先来看看使用 Django 框架的一些主要优势。

姜戈的优势

因为 Django 是基于 python 的，所以它的设置和使用很容易理解和实现。
我们还在一个 Django 项目中创建了多个 web 应用程序。
它是一个全栈框架，因此它包含许多有助于快速开发的内置特性和功能。例如认证系统、国际化系统等等。
它还提供了一个内置的管理界面，可用于一些管理任务。
Django 还提供端到端的应用测试。
对于大型网络项目来说，Djongo 是一个非常有效和可靠的框架。

姜戈的缺点

接下来，让我们了解一下在我们的项目中使用 Django 框架的一些缺点。

使用 Django，我们可以在一个项目中组合多个组件。但是同时处理多个组件可能会很复杂。
是全栈框架，所以学习曲线也高。
我们应该了解 Django ORM(对象关系映射器),以便与应用程序数据进行交互。
我们应该知道在 Django 中实现路由的正则表达式。
将 Django 用于小型项目可能会利用不足。

烧瓶简介

Flask 也是一个基于 python 的 web 开发框架，但它是一个 T2 的极简框架。这个框架提供了开发 web 应用程序的基本特性，并且它也不依赖于任何外部库。Flask 还允许开发者添加库或插件作为扩展。它还提供了一组合理的易于使用的 API。

阅读 Python Django 长度过滤器

优点&缺点烧瓶

在这一节中，我们将讨论在我们的项目中使用 Flask 框架的一些主要优点和缺点。

让我们首先看看使用 Flask 框架的一些主要优点。

烧瓶的优点

flask 是 web 开发的微型框架，因此开发和维护网站非常容易。
在 Flask 中路由 URL 非常容易实现。
由于 flask 附带了基本的工具，所以这个框架的学习曲线很简单。
使用 Flask，数据库集成也非常简单和容易。
这是一个极简的框架,但是它非常强大，并且在互联网上有很多可用的资源。
这个框架在处理中小型应用程序时非常有效。

烧瓶的弊端

接下来，让我们了解一下在我们的项目中使用 Flask 框架的一些缺点。

使用 Flask 开发和维护非常大规模的应用程序可能是一项复杂的任务。
它附带了一组有限的工具和功能。
使用 Flask 维护一个复杂的网站可能成本很高。
它没有任何内置的管理界面。

阅读: Python Tkinter 测验

Python Django 与 Flask–主要区别

现在，在这一节中，让我们讨论 Django 和 Flask 框架的一些关键区别。

Django 于 2005 年推出，而 Flask 于 2010 年推出。
Dango 是一个用于快速开发 web 应用程序的全栈 web 框架。而 Flask 是一个 WSGI 框架，用于开发简单易用的项目。
Django 有一个单一的工作方法，而 Flask 有一个多样化的工作方法。
Django 还提供动态 HTML 页面。但是，Flask 不支持动态 HTML 页面。
Flask 中有 API 支持，但是 Django 中没有。
Django 遵循标准的项目布局，但是 flask 却不遵循任何布局。
Django 框架也支持第三方应用，但是 Flask 不支持任何第三方应用。

Python Django vs Flask 性能

现在，在这一节中，我们将尝试理解这两个框架之间的性能差异。

说到开发速度，Django 比 Flask 表现更好。Django 旨在实现快速 web 开发的目标。而且 Django 也更擅长开发和维护大型 web 应用。因为它提供了非常广泛的工具和功能。此外，Django 还通过提供不同的安全特性来关注安全性，如认证系统、CSRF 令牌等。

在处理 JSON 响应时，Flask 更快。它有助于构建简单的小型 web 应用程序。由于它体积小、性能高，因此最适合中小型应用。

Read: ModuleNotFoundError:没有名为 Django 的模块

结论

最后，我想建议，如果你是 python 新手，并且想学习 web 开发，那么 Flask 是最好的选择。如果你是 python 的专业人士，想要构建一个高端的 web 应用程序，那么 Django 是最好的选择。

你可能也喜欢读下面的文章。

因此，在本教程中，我们已经讨论了 Django 和 Flask 的主要区别。我们还讨论了以下主题。

Django 简介
姜戈的优势和劣势
烧瓶简介
烧瓶的优缺点
Python Django 与 Flask 的主要区别
Python Django vs Flask 性能

Python Django vs 金字塔

原文：https://pythonguides.com/python-django-vs-pyramid/

Django 和金字塔都是主要依赖 Python 的 web 开发框架。因为它们的目的是一样的，所以在它们之间做出选择总是一个挑战。因此，在本文中，我们将讨论 Django 和 Pyramid 之间的一些关键差异。并且，我们也会试着去了解哪一个更优越。

以下是本教程涵盖的主题的综合列表。

Django 简介
为什么是姜戈
金字塔简介
金字塔的特征
Python Django 与金字塔–主要区别
姜戈和金字塔哪个更好
结论

Python Django vs Pyramid

因此，在我们进入 python Django 和 Pyramid 之间的差异之前。我们应该对 Django 和金字塔有一个基本的了解。让我们从学习姜戈开始。

Django 简介
为什么是姜戈
金字塔简介
金字塔的特征
Python Django vs Pyramid–主要区别
姜戈和金字塔哪个更好
结论

Django 简介

Django 是一种 python 编程语言 web 应用框架。使用了 MVT (模型视图模板)设计模式。由于其快速开发特性和免费开源框架，Django 的需求量很大。

Django 通常被称为“包含电池的框架”，因为它为所有东西都提供了内置特性，比如 Django 管理界面和默认数据库 SQLlite3。

现在如果你想深入了解 Django，也可以参考下面这篇文章什么是 Python Django。

为什么是姜戈

在这一节中，我们将讨论在我们的项目中使用 Django 框架的一些主要原因。

高可扩展性。
优秀的文档。
顶级的跨国公司和企业都在用。
最简单易懂的框架。
飞速的发展。
大型支持性社区。
Django 为您提供了现成的组件，比如用户认证、网站管理面板、表单和上传文件的机制等等。
最后但同样重要的是，Django 基于 Python，它提供了一个大的库和特性。所有这些都可以与一个 web 应用程序集成，从而实现广泛的高级功能。

另外，检查:如何安装 Django

金字塔简介

Python 微框架不需要使用任何特定的工具或模块。例如，您可以灵活地选择自己喜欢的数据库。微框架可能更适合小规模的应用程序。

金字塔是 Python 微框架之一。它是一个基于 python 的通用 web 应用开发轻量级框架。与 Flask 或其他“微型”容器不同，Pyramid 有许多与众不同的特性和功能。

它构建在 WSGI 框架之上。很简单，受 Zope，Pylons，Django 的影响。这座金字塔之前被称为 repoze.bfg 。

简单地说，我们将讨论 WSGI 。它是 web 服务器和应用程序之间的接口。它的目的是为不同的服务器和框架相互通信提供一种标准化的方式，允许在必要时从开发环境切换到生产环境。

金字塔的特征

在这一节中，我们将讨论在我们的项目中使用金字塔框架的一些主要特征。

它是使用最广泛的 Python web 框架。
它有助于小型和大型项目的成功。
支持微框架和单文件 web 应用程序。
它有预安装的会话。
它基于 Pylons/Zope/Django。
它允许您管理事务。
支持同步请求。
不强迫任何人使用任何特定的项目架构。
可以用一些第三方模块来增强。
很好的例子和文档。

阅读:Django 中的应用程序和项目之间的差异

Python Django vs Pyramid–主要区别

在这一节中，让我们看看 Django 和 Pyramid 框架之间的一些显著差异。

参数	姜戈	金字塔
放	Django 于 2005 年获释。	金字塔于 2008 年发布。
作者	阿德里安·霍洛瓦蒂和西蒙·威廉森是《姜戈》的作者。	克里斯·麦克多诺是《金字塔》的作者。
基于	Django 是一个用于快速开发 web 应用程序的全栈 web 框架。	Pyramid 是为开发大型项目而构建的 WSGI 框架。
类型	Django 是 web 应用程序开发的大型框架。	金字塔是一个 web 应用程序微框架。
使用人	Django 被 Instagram，Pinterest，Coursera，Udemy 使用。	金字塔被 Reddit，YOU-app，Kalibrr，SurveyMoney，NewCars.com 使用。
设计	Django 提供了大量的电池和组件供开发人员快速构建定制的 web 应用程序。	金字塔允许开发人员选择合适的工具，以更灵活的方式构建 web 应用程序。
灵活性	在使用 Django 时，Web 开发人员可以使用模板系统和对象关系映射器(ORM)系统，以及内置的安全措施。	金字塔没有模板系统或 ORM 系统。它使程序员能够为每个项目选择合适的模板系统和 ORM 系统。
数据库ˌ资料库	Django 支持流行的关系数据库管理系统，如 MySQL、Oracle、PostgreSQL，甚至 NoSQL。	另一方面，Pyramid 允许 web 开发人员使用 SQLAlchemy，这是一个强大的 Python 数据库工具包。
管理支持	Django 包括一个基于网络的管理门户，界面友好。它允许程序员通过在浏览器中对模型进行 CRUD 操作来快速测试。	金字塔没有管理网站，但第三方工具是可用的。
编码	Django 将每个项目视为独立应用程序的集合。	Pyramid 将整个 web 应用程序开发项目视为单个文件。
自举
技术	Django 的 bootstrapping 方法允许程序员通过执行某些命令来创建应用程序。	Pyramid 不要求程序员遵循精确的代码，但它确实建议他们使用支架来实现一个自举方法。

Python Django vs Pyramid

姜戈和金字塔哪个更好

现在，在这一节中，我们将尝试了解两个框架中哪一个更好。

如果您正在创建一个基于健壮的 MVT 的应用程序，Django 可能是理想的选择，因为它允许您快速创建一个原型并将其发展成一个完全可操作的服务。

然而，如果您的项目需要最高性能，或者您不希望框架的假设限制您实现项目的特定需求，那么使用金字塔是一个绝妙的主意。

结论

最后，我想建议，如果你是编程新手，你想学习 web 开发，那么金字塔是最好的选择，因为它提供了选择数据库和模板的灵活性。如果你是一个专业的程序员，想开发一个高端的 web 应用，那么 Django 是最好的选择。

另外，看看更多的 Django 教程。

因此，在本教程中，我们已经讨论了 Python Django 和 Pyramid 的主要区别。我们还讨论了以下主题。

Django 简介
为什么是姜戈
金字塔简介
金字塔的特征
Python Django 与金字塔–主要区别
姜戈和金字塔哪个更好
结论

Python 点积和叉积

原文：https://pythonguides.com/python-dot-product/

在本 Python 教程中，我们将讨论 python 点积和叉积。此外，我们将看到以下主题:

python 中的点积是什么？
什么是 NumPy，如何在 python 中安装 Numpy
没有 NumPy 的 Python 点积
python 中使用 NumPy 的点积
python 中两个向量的点积
Python 计算两个给定向量的内积
二维数组的 Python 点积
两个向量的 Python 叉积
两个列表的 Python 点积
两个数组的 Python 点积
二维数组的 Python 叉积
三维数组的 Python 叉积

什么是 Python 点积？
什么是 Numpy，如何在 python 中安装 Numpy
没有 NumPy 的 Python 点积
python 中使用 NumPy 的点积
python 中两个向量的点积
Python 计算两个给定向量的内积
二维数组的 Python 点积
Python 两个向量的叉积
两个列表的 Python 点积
两个数组的 Python 点积
二维数组的 Python 叉积
三维数组的 Python 叉积

什么是 Python 点积？

Python 点积在代数运算中也称为标量积，它接受两个等长序列并返回一个数字。

什么是 Numpy，如何在 python 中安装 Numpy

Numpy 是一个 python 库，用于处理数组和矩阵。
如果你已经在一个系统上安装了 python 和 pip ，那么 NumPy 的安装就非常容易了。
使用 cmd 中的命令“pip install Numpy”安装 Numpy。
一旦安装了 NumPy，通过添加 import numpy 将它导入您的应用程序。

没有 NumPy 的 Python 点积

如果我们没有 NumPy 包，那么我们可以定义两个向量 a 和 b 。然后使用 zip 函数，该函数接受两个等长向量并将它们合并成对。将每对中的值相乘，并将每次相乘的乘积相加，得到点积。

举例:

a = [5, 10, 2]
b = [2, 4, 3]
dotproduct=0
for a,b in zip(a,b):
    dotproduct = dotproduct+a*b
print('Dot product is:', dotproduct)

写完上面的代码后，一旦你打印出 " dotproduct " 那么输出将是 "Dot product is: 56" 。它将每对中的值相乘，并将乘积加到最终值中。

没有 NumPy 的 python 点积可以参考下面的截图。

Python dot product without NumPy

python 中使用 NumPy 的点积

Python 提供了一种非常有效的方法来计算两个向量的点积。通过使用 numpy.dot() 方法，该方法在 Numpy 模块中可用。

举例:

import numpy as n
a = [5, 10, 2]
b = [2, 4, 3]
dotproduct = n.dot(a,b)
print('Dot product is:', dotproduct)

写完上面的代码后，一旦你打印出 " dotproduct " 那么输出将是 "Dot product is: 56" 。它将使用点()计算点积。

使用 NumPy 的 python 点积可以参考下面的截图。

Dot product in python using NumPy

python 中两个向量的点积

两个向量 a1 和 b1 的 Python 点积将返回标量。对于两个标量，它们的点积相当于一个简单的乘法。

举例:

import numpy as np
a1 = 10
b1 = 5
print(np.dot(a1,b1))

写完上面的代码后，一旦你将打印 " np.dot(a1，b1) " 那么输出将是 " 50 " 。它将使用点()计算点积。

两个向量的 python 点积可以参考下面的截图。

Dot product of two vectors in python

Python 计算两个给定向量的内积

内积是点积的推广。这是一种将向量相乘的方法。通过使用点()方法，我们可以找到内积。

举例:

import numpy as n
p
a1 = np.array([5, 6]
)
b1 = np.array([2, 5]
)
print("vectors:")
print(a1)
print(b1)
print("Inner product of vectors:")
print(np.dot(a1,b1))

写完上面的代码，一旦你打印出 " np.dot(a1，b1) " 那么输出就是"向量的内积:40" 。它将使用点()计算向量的内积。

你可以参考下面的截图 python 计算两个给定向量的内积

Python compute the inner product of two given vectors

二维数组的 Python 点积

如果数组是二维， numpy.dot() 将导致矩阵乘法。

举例:

import numpy as np 
p = [[2,5],[3,2]]
q = [[1,0],[4,1]]
dotproduct = np.dot(p,q)
print(dotproduct)

写完上面的代码后，一旦你将打印 " dotproduct " 那么输出将是 "[[22 5] [11 2]]" 。通过使用 dot()方法，它返回两个向量 p 和 q 的矩阵乘积。

二维数组的 python 点积可以参考下面的截图

Python dot product of 2-dimensional arrays

Python 两个向量的叉积

为了找到两个向量的叉积，我们将使用 numpy cross() 函数。

举例:

import numpy as np
p = [4, 2]
q = [5, 6]
product = np.cross(p,q)
print(product)

写完上面的代码后，一旦你打印出 " product " ，那么输出将是 " 14 " 。通过使用 cross() 方法，它返回两个向量 p 和 q 的叉积

你可以参考下面两个向量的 python 叉积截图。

Python cross product of two vectors

两个列表的 Python 点积

Python 提供了一种非常高效的方法来计算两个列表的点积。通过使用 numpy.dot() 方法，该方法在 Numpy 模块中可用。

举例:

import numpy as n
list1= [10, 3, 2]
list2= [2, 5, 3]
dotproduct = n.dot(list1,list2)
print('Dot product of two list is:', dotproduct)

写完上面的代码后，一旦你将打印 " dotproduct " 那么输出将是"两个列表的点积是:41" 。它将使用点()计算两个列表“列表 1 和列表 2”的点积。

你可以参考下面两个列表的 python 点积截图

Python dot product of two lists

两个数组的 Python 点积

python 中的函数 numpy.dot() 返回两个数组 arr1 和 arr2 的点积。如果 arr1 和 arr2 都是一维的，则点()乘积返回标量。

举例:

import numpy as np
arr1 = np.array([2,2])
arr2 = np.array([5,10])
dotproduct = np.dot(arr1, arr2)
print("Dot product of two array is:", dotproduct)

写完上面的代码，一旦你打印出 " dotproduct " 那么输出将是"两个数组的点积是:30" 。它将使用点()计算两个数组“arr 1 和 arr 2”的点积，并返回一个标量值。

你可以参考下面两个数组的 python 点积截图

Python dot product of two arrays

二维数组的 Python 叉积

为了找到二维数组的叉积，我们将使用 numpy 库的 numpy.cross() 函数。

举例:

import numpy as np
p = [[2, 2]
, [3, 1]]
q = [[6, 7]
, [5, 4]]
product = np.cross(p,q)
print(product)

写完上面的代码后，一旦你打印出 " product " ，那么输出将是 " [2 7] " 。通过使用 cross() 方法我们将得到两个给定向量 p 和 q 的叉积

你可以参考下面的二维数组的 python 叉积截图

Python cross product of 2-dimensional arrays

三维数组的 Python 叉积

为了找到三维数组的叉积，我们将使用 numpy 库的 numpy.cross() 函数。

举例:

import numpy as np
p = ([3, 2, 5])
q = ([4, 7, 1]
)
product = np.cross(p,q)
print(product)

写完上面的代码后，一旦你打印出 " product " ，那么输出将是 " [-33 17 13] " 。通过使用 cross() 方法我们将得到两个给定向量 p 和 q 的叉积

你可以参考下面的三维数组的 python 叉积截图

Python cross product of 3-dimensional arrays

您可能会喜欢以下 Python 教程:

在本教程中，我们学习了 python 点积和 Python 叉积 ，并且我们还看到了如何使用它，例如:

python 中的点积是什么？
什么是 NumPy，如何在 python 中安装 Numpy
没有 NumPy 的 Python 点积
python 中使用 NumPy 的点积
python 中两个向量的点积
Python 计算两个给定向量的内积
二维数组的 Python 点积
两个向量的 Python 叉积
两个列表的 Python 点积
两个数组的 Python 点积
二维数组的 Python 叉积
三维数组的 Python 叉积

Python 下载和安装步骤(Windows 10/Unix/Mac/Ubuntu/CentOS)

原文：https://pythonguides.com/python-download-and-installation/

在本 Python 教程中，我们将讨论 Python 下载和安装步骤。此外，我们将涵盖以下内容。：

下载 Python
如何在 windows 10 上安装 python？
如何在 Linux 上安装 python？
在 Ubuntu 16.10 和 17.04 上安装 Python 3.6
如何在 Ubuntu 上安装 Python 3.8？
Python 3 在 mac 上的安装
如何在 CentOS 7 上安装 Python 3？
如何卸载 Python 2.7
Python 禁用路径长度限制

也可以查看中一篇非常好的文章 python 是如何工作的？。

如果你想学习 Python 和机器学习，可以查看 Python 和机器学习培训课程。

如何在 windows 上安装 python？
如何在 Linux 上安装 python？
在 Ubuntu 16.10 和 17.04 上安装 Python 3.6
如何在 Centos 的 Ubuntu 上安装 Python 3.8？
Python 3 在 mac 上的安装
如何在 CentOS 7 上安装 Python 3？
在 CentOS 7 / CentOS 8 上安装 Python 3.8
Python ide 和代码编辑器
什么是 ide 和代码编辑器？
如何卸载 Python 2.7
Python 禁用路径长度限制
结论

如何在 windows 上安装 python？

大家来讨论一下， Python 3.8.2 在 Windows 10 中下载安装。请按照以下步骤操作。

Installing Python on Windows

第一步:

打开 Python 官方网站下载 Python 更新版本。2020 年 4 月的当前版本是 3.8.2。

download python

第二步:

现在，点击“Windows”链接下载 python Windows 版。

download python 3.8.2

第三步:

从 Python 稳定版 3.8.2 版本部分，点击下载“Windows x86-64 可执行安装程序”。现在 Python-3.8.2-amd64.exe 文件可以下载了。将该文件复制到您的桌面或其他位置。

第四步

现在双击下载的文件。下面的窗口将会打开。点击立即安装。

Install Python

确保选中底部的为所有用户安装启动器(推荐)和将 Python 3.8 添加到路径复选框。

第五步:

您是否要允许此应用程序更改您的设备。请点击“是”选项。然后安装将开始。

install python 3.8.2

第六步:

现在下面的弹出窗口将打开说“安装成功”。

install python in windows 10

第七步:

如果您将在您的机器中搜索 Python，将显示 Python 3.8 (64 位)。现在，如果你双击下面的终端将会打开。

现在让我们检查一下我的系统中安装的确切的 python 版本。检查我是否输入了以下命令

python --version

但不幸的是，我得到了以下错误

Traceback(最近一次调用 last):
文件"< stdin >，第 1 行，在<模块>
name 错误:名称' python '未定义

为什么会有这个错误？

实际上，我们正在尝试通过运行命令“python”来启动 Python 解释器。

然而，解释器已经启动。它将 python 解释为一个变量的名称，该名称在此处未定义，因此它显示“名称 python 未定义”。

但是不要担心 python 安装正确。为了验证这一点，我输入了 print("pythonguides ")，得到了预期的输出" pythonguides "。

现在，在这种情况下，我们可以通过两种方式看到 python 版本

1-请在 python 终端中输入下面一行代码

import sys

mypythonversion = 0x600
mypythonversion = sys.version[:5]
print("%s%s" %("my python version is: ", mypythonversion))

现在看下面的截图，它显示我的 python 版本是“python 3.8.2”。

2-这里查看 python 版本的另一种方法是打开系统命令提示符并输入下面的命令。您可以看到它将显示版本为 Python 3.8.2。

python --version

阅读编程初学者指南

如何在 Linux 上安装 python？

请按照以下步骤在 Linux 上进行 Python 下载和安装。

如果你是第一次在你的系统中构建这个软件，你应该安装 build-essentials，bzip2，SQLite 作为先决条件，否则你会在 python 的安装过程中出错。如果你之前已经做过，那么你可以忽略下面的三个步骤。

第一步:

打开终端，输入命令“sudo apt-get install build-essential”。这将在您的系统中安装所有的构建软件包。

第二步:

现在在终端上输入命令“Sudo apt-get install libbz2-dev”。这将安装所需的 bzip2 支持。

第三步:

现在在终端上输入命令“Sudo apt-get install libsqlite3-dev”。这将安装 SQ Lite 支持，这也是需要的。

现在你已经完成了先决条件。现在按照下面的步骤

第一步:

打开 Python 官方网站下载 Python 更新版本。2020 年 4 月的当前版本是 3.8.2。但是你想下载哪个版本取决于你自己。

点击“Linux\Unix”链接，下载需要的版本。

第二步:

将有许多版本，所以点击你需要的版本。它将被下载为 Python 版本并保存在您的本地文件夹中。双击它将提取并复制到文件夹 Python-version。

注意:这里的版本是你下载的 python 版本(例如:3.8.2，所以你的文件夹\文件名将是 Python-3.8.2)

第三步:

现在打开终端，然后输入下面的命令。现在它会指向你下载的文件所在的文件夹。

CD Python-version

第四步:

现在输入下面的命令并按回车键，然后等待一段时间。一旦系统检查完毕，你就可以进入下一步了。

./configure

第五步:

现在输入下面的命令并按回车键。Linux 将制造 python 软件。

make

第六步:

现在在你的终端输入下面的命令。这将在您的系统中安装 Python。

sudo make altinstall

注意:根据您的 Linux 版本，一些命令可能会有所不同。

阅读人工智能完全指南

在 Ubuntu 16.10 和 17.04 上安装 Python 3.6

我们来讨论一下如何在 Ubuntu 16.10 和 17.04 上安装 Python 3.6 。 Python 3.6 默认存在于 Ubuntu 16.10 和 17.04 的资源库中。所以请按照下面的步骤找到更新并安装 python 3.6 。

第一步:

首先打开系统中的终端。

第二步:

现在检查更新。请使用下面的命令

sudo apt update

第三步:

使用下面的命令在你的机器上安装 python 3.6 。

sudo apt install python3.6

第四步:

现在确保你的机器上安装了正确的版本。您可以使用下面的命令检查 python 的版本。

python3.6 -V

您将得到如下输出

Python 3.6.0

如何在 Centos 的 Ubuntu 上安装 Python 3.8？

下面我们来讨论一下 Python 3.8 下载 和在 Ubuntu 上安装的步骤。现在最新版本是 3 . 8 . 2(2020 年 4 月)。同样，请遵循以下步骤。

在开始实际安装之前，我们需要安装必备组件，否则在安装过程中会显示很多错误。

第一步:

打开终端并运行以下命令。这将下载并安装安装所需的软件包。

sudo apt update
sudo apt install build-essential zlib1g-dev libncurses5-dev libgdbm-dev libnss3-dev libssl-dev libreadline-dev libffi-dev wget

第二步:

打开 Python 官方网站下载 python 3.8 版本。点击“Linux\Unix”链接，下载 3.8 版本。

第三步:

它将被下载为 Python 版本并保存在您的本地文件夹中。双击它将提取并复制到文件夹 Python-3.8。

第四步:

现在打开终端，然后输入下面的命令。现在它会指向你下载的文件所在的文件夹。

CD Python-3.8

第五步:

现在输入下面的命令并按回车键，等待一段时间。一旦系统检查完毕，你就可以进入下一步了。

./configure

第六步:

现在在你的终端输入下面的命令。这将在您的系统中安装 Python。

sudo make altinstall

第七步:

现在确保你的机器上安装了正确的版本。您可以使用下面的命令检查 python 的版本。

python3.8 -V

您将获得以下输出。

Python 3.8.2

Python 3 在 mac 上的安装

这里讨论一下如何在 macOS 上安装 Python 3？在开始实际安装之前，我们需要安装一些必要的先决条件。

第一步:

打开您的终端并键入以下命令来安装 XCode。这是需要的。

xcode-select --install

第二步:

现在我们需要安装自制软件。要安装它，请在您的终端中运行以下命令

ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

第三步:

现在打开您的终端并输入下面的命令，它将在您的 mac 上安装最新版本的 python 3

brew install python3

第四步:

要确认 mac 上安装的 python 版本，请键入以下命令

python3 --version

它将显示最新的 python 版本作为输出。

如何在 CentOS 7 上安装 Python 3？

这里讨论一下如何通过 CentOS 7 的包管理器 Yum 安装 Python 3。在 Centos 7.7 中，存储库中提供了 Python 3。因此，让我们遵循以下步骤

第一步:

要更新环境，请使用下面的命令。

yum update -y

第二步:

现在我们需要进行 python 的实际安装。为此，请使用下面的命令。

yum install -y python3

第三步:

现在要确保 python3 安装正确，请运行下面的命令。这将显示安装在您机器上的 python3 版本。

python3

在 CentOS 7 / CentOS 8 上安装 Python 3.8

下面就来讨论一下在 Centos 7 / Centos 8 上 Python 3.8 下载和安装的步骤。请按照以下步骤操作。

第一步:

我们需要在实际安装 python 之前安装所需的包。为此，请运行以下命令。

sudo yum -y groupinstall "Development Tools"
sudo yum -y install openssl-devel bzip2-devel libffi-devel

第二步:

打开 Python 官方网站下载 python 3.8 版本。点击“Linux\Unix”链接，下载 3.8 版本。

第三步:

它将被下载为 Python 版本并保存在您的本地文件夹中。双击它将提取并复制到文件夹 Python-3.8。

第四步:

现在打开终端，然后输入下面的命令。现在它会指向你下载的文件所在的文件夹。

CD Python-3.8

第五步:

现在输入下面的命令并按回车键，等待一段时间。一旦系统检查完毕。

sudo ./configure --enable-optimizations

第六步:

现在在你的终端输入下面的命令。这将在您的系统中安装 Python。

sudo make altinstall

第七步:

现在来验证您已经正确安装了 python 3.8 版本。请使用下面的命令。

python3.8 --version

您将获得以下输出

Python 3.8.2

现在我们正在不同的操作系统中安装 python 3。因此，我们需要开始开发活动的下一步是，我们需要安装一个 IDE 或代码编辑器，在那里我们将编写和执行我们的代码。

Python ide 和代码编辑器

我们将讨论开发 python 所需的不同 python IDEs 和代码编辑器。

什么是 ide 和代码编辑器？

当我们开始使用任何编程语言时，我们需要一些工具或编辑器来编写和执行我们的程序。

IDE 无非就是一个“集成开发环境”。这是一个为软件开发而设计的软件。该工具有助于轻松编写、设计和调试代码。

当你得到一个错误时，你可以放一个调试器，一行一行地检查问题是从哪里来的。不仅如此，IDE 还会突出显示代码，并具有自动建议功能等。

其中，代码编辑器是简单的文本编辑器，可以突出代码语法，也可以轻松地格式化代码。

很少有好的代码编辑器也能支持调试。

如果您使用 python 进行普通编程，那么您可以选择一个好的代码编辑器，而不是使用 IDE。但是如果你正在使用 python 构建任何复杂的项目，那么 IDE 是最好的选择。

市场上有许多 ide 和代码编辑器。有些是通用的，支持多种语言，少数只能用于 python 开发。

1-皮查姆 :

Pycharm 是 python 最好的开发 IDE 之一。

这个 IDE 有很多好的特性，比如代码编辑器、错误突出显示功能、代码调试功能，还支持源代码控制。

Pycharm 有付费(专业)版和免费开源(社区)版。

这是一个简单的 IDE，支持 Windows、Linux 和 Mac 平台。

下面讨论一下 Windows 10 中免费的 pycharm 社区版 2020.1 的安装步骤。

第一步:

从官方网站下载 Pycharm 可执行文件。点击社区选项下的“下载”按钮。

第二步:

将下载 Python-community-2020.1 文件。复制到一个适当的位置，例如桌面或任何驱动器，然后双击该文件。当系统询问“是否允许此应用程序更改您的设备？”时，单击“是”

第三步:

将出现下面的弹出窗口，请单击下一步。

第四步:

现在将出现下面的弹出窗口，请再次单击下一步按钮。

第五步:

现在你会看到下面的弹出窗口，如果你想要一个桌面快捷方式，选中复选框 64 位启动器，然后单击下一步。

第六步:

现在看到下面弹出选择 JetBrains 并点击安装

第七步:

现在您可以看到安装正在进行中。请等待它 100%完成。

第八步:

现在，如果您想立即运行 Pycharm 社区版本，您可以选中该选项，或者单击 Finish 按钮。

第九步:

现在您的安装已经完成。在你的电脑中搜索 Pycharm，点击它，你会看到下面的弹出窗口。选中复选框，然后单击继续。

第十步:

将出现下面的弹出窗口。点击“不发送”按钮。

步骤 11:

现在 IDE 将像下面这样打开，只需点击“跳过剩余的默认设置”按钮。

第 12 步:祝贺你，现在这是 Pycharm IDE 版本 2020.1。

`2-Spyder`

Spyder 最好的一点是，它是一个开源的 Python IDE。

Spyder 拥有所有 ide 提供的所有公共特性，比如代码编辑、语法高亮、自动完成等。

Spider 主要面向使用 python 的数据科学家，因为它可以很好地集成常见的 Python 数据科学库，如 SciPy、NumPy 等。

对于 python 开发来说，它看起来非常简单易用。

`3- Visual Studio`

Visual studio 是微软的又一个集成开发环境。这是一个非常实用的 IDE，具有所有的功能，如代码编辑器、突出显示错误、自动完成、智能感知支持、调试功能等等。

这是一个具有完全加载功能的 IDE。你可以用这个 IDE 做任何你想做的事情。

这不仅适用于 python，它还支持其他语言，如微软。网络等。

visual studio 有免费版(社区版)和付费版(专业版和企业版)。目前的版本 vs 是截至目前的 2019。

4- Visual studio 代码

Visual studio 代码是一个代码编辑器，可以用于 python 开发。这不仅对 python 有意义，它也支持其他语言。

主要用于许多脚本语言以及 share point 框架开发目的。

VSC 的另一个好处是它是一个开源工具，有很多功能，比如语法高亮、括号匹配、自动缩进、框选等等。

5-崇高文字

这是另一个用于 python 开发的代码编辑器。

它具有所有常见的功能，如自动完成、选择多行、格式化、语法高亮等

它支持许多包，这使得崇高的文本编辑器非常丰富。

Sublime Text 不是完全免费的，你可以免费使用评估版，但与付费版相比，它的功能较少。

`6- Atom`

Atom 主要用于开发许多使用 HTML、javascript、CSS 等的桌面应用程序。但是您需要安装一个扩展，然后只有您能够使用 Atom 进行 python 开发。

这是一个轻量级的工具，您可以在许多平台上安装它。唯一不同的是，与其他编辑器相比，它的内置功能更少。

`7-Thonny`

Thonny 是一个可以用来开发 python 的 IDE。

它主要面向编写 python 编程的初学者。

它具有调试、突出语法错误、自动完成、可变范围突出显示等功能

如何卸载 Python 2.7

要从 windows 中卸载 Python 2.7，请按照以下步骤操作:

打开开始–首先点击屏幕左下角的 windows 标志。将出现一个菜单。
打开设置–点击开始菜单左下方的设置图标。这将打开设置窗口。
点击应用程序–点击应用程序。
找到您想要卸载的 python 2.7 版本****——向下滚动，直到您找到带有“python 2.7”名称的应用程序。
****点击 Python 2.7 版本——然后展开显示卸载按钮。
****点击卸载–在 2.7 版本上
****出现提示时点击是——点击是并确认你要卸载 python。
****允许 python 卸载–弹出一个带进度条的窗口，一旦进度条到达末尾，Python 就应该被卸载了。

**## Python 禁用路径长度限制

在 windows 10 最新更新中有一个路径长度的设置选项，请按照以下步骤操作:

首先，进入开始菜单，输入“regedit”
然后转到路径“HKEY _ LOCAL _ MACHINE \ SYSTEM \ current Control set \ Control \ file SYSTEM
之后双击右侧的长文件路径。
会出现一个弹出窗口，在长路径中启用类型值数据【1】。
现在，这将允许限制通过。
如果需要再次设置限制，将值设置为“0”到禁用路径长度限制。

您可能会喜欢以下 Python 教程:

结论

Python 是最流行的开源面向对象编程语言。Python 很容易学，语法上也很简单。

我们可以在不同的操作系统上安装 python，如 windows、Linux、Ubuntu、Mac、CentOS7 等。

我们了解了用于 python 开发的不同 IDE 和代码编辑器，如 Pycharm、Spyder、Atom、Visual Studio、visual studio code、Sublime Text、Thonny 等

2020 年 4 月最新的 python 版本是 3.8.2。

Python 是最好的！！！！！

本 python 教程解释了以下几点:

如何在 windows 10 上安装 python？
如何在 Linux 上安装 python？
在 Ubuntu 16.10 和 17.04 上安装 Python 3.6？
如何在 Ubuntu 上安装 Python 3.8？
Python 3 在 Mac 上的安装。
如何在 CentOS 7 上安装 Python 3？
Python IDEs 和代码编辑器
如何卸载 Python 2.7
Python 禁用路径长度限制

enjoysharepoint.com/**

Python 纪元到日期时间+示例

原文：https://pythonguides.com/python-epoch-to-datetime/

在这篇 python tutoria l 中，您将通过几个例子了解到 Python 纪元到日期时间。Python epoch 用于将 epoch 转换为日期和时间。这里我们将检查 :

Python 日期时间到纪元时间
python 纪元到日期时间字符串
python 纪元到日期时间毫秒
python 纪元到日期时间时区
python Unix 纪元到日期时间
python 纪元日期时间到毫秒
python 纪元时间戳到日期时间
python 纪元日期时间年份超出范围

什么是 Python 纪元
Python 纪元到日期时间
Python 日期时间到纪元时间
Python 纪元到日期时间字符串
Python 历元到日期时间毫秒
Python 纪元到日期时间时区
Python Unix 历元到日期时间
Python 纪元日期时间到毫秒
Python 纪元时间戳到日期时间
Python 纪元日期时间年份超出范围/Python 无效参数

什么是 Python 纪元

纪元时间也称为 Unix 时间、POSIX 时间、和 Unix 时间戳。纪元时间是指自1970 年 1 月 1 日起经过的秒数，不包括闰秒。Unix 时间有 10 位数字。Unix 时间可以同时表示所有时区。

Python 纪元到日期时间

让我们看看下面这个关于 Python epoch 到 DateTime 的例子。

示例:

import datetime
epochtime = 30256871
datetime = datetime.datetime.fromtimestamp(epochtime)
print(datetime)

在这个例子中，我已经导入了 datetime 包，并将变量作为纪元时间，并将值作为变量，如秒数，并使用DateTime . DateTime . from timestamp(epochtime)方法将纪元时间转换为 DateTime 。

下图显示了输出:

Python 日期时间到纪元时间

现在，让我们看看如何从 Python DateTime 中获取纪元时间。

在下面的例子中，我传递了日期时间，它返回了纪元时间。

示例:

import datetime
timedate = datetime.datetime(2020, 12, 14, 0, 0).timestamp()
print(timedate)

在这个例子中。我用了时间戳函数。

下图显示了输出:

Python DateTime to epoch time

Python 纪元到日期时间字符串

让我们来看一个例子，我们将传递纪元时间，它将为我们提供 Python 中字符串格式的日期时间。

示例:

import datetime
ts = datetime.datetime.fromtimestamp(800025)
print(ts.strftime('%Y-%m-%d %H:%M:%S'))

在这个例子中，为了将 epoch 转换为 date time，我从 datetime 模块中获取了函数 fromtimestamp() 来从 Unix 时间戳中获取一个日期。

这个 fromtimestamp() 函数以时间戳作为输入，给出 DateTime 作为输出。 strftime 是一个以字符串格式返回日期和时间的字符串。

我们使用 Python strftime() 将日期和时间转换成字符串。

%Y 表示年份
%m 表示月份
%d 表示日期
%H 表示一个小时
%M 表示月份
%S 表示秒

下图显示了输出。

Python epoch to datetime string

Python 历元到日期时间毫秒

现在，让我们看看如何在 Python 中从纪元时间获得毫秒的日期时间。

示例:

import datetime

millseconds = 984567.224325
datetime = datetime.datetime.fromtimestamp(millseconds)

print(datetime)

在这里，我用 Python 将时间戳函数中的转换为毫秒格式的隐蔽纪元。****

下图显示了输出。

Python epoch to DateTime milliseconds

Python 纪元到日期时间时区

from datetime import datetime
import pytz
tz = pytz.timezone('CST6CDT')
datetz = tz.localize(datetime(2020, 11, 17, 1, 37, 50), is_dst=None)
print(datetz)

在这个例子中，pytz 包被导入。要获取给定时区的当前日期，需要使用 tz = pytz.timezone('CST6CDT ')。

以 DateTime 的形式获取给定时区中当天的开始时间，其中 timezone datetz = tz，localize(datetime(2020，11，17，1，37，50)，is_dst=None)是传递给 localize 的标志。

见下文:

Python epoch to DateTime timezone

Python Unix 历元到日期时间

这与上面的例子是一样的，我们传递 Unix 纪元时间，它以日期时间格式给出我们。

示例:

import datetime
print(datetime.datetime.fromtimestamp(int("258741369")).strftime('%Y-%m-%d %H:%M:%S'))

在这个例子中。我使用了str time()这是一个返回日期和时间的字符串方法。

下图显示了输出。

Python 纪元日期时间到毫秒

现在，让我们看看如何以纪元格式从 Python DateTime 中获取毫秒。

from datetime import datetime

date_obj = datetime.strptime('14.12.2020 12:37:45,72',
                           '%d.%m.%Y %H:%M:%S,%f')
milliseconds = date_obj.timestamp() * 1000

print(milliseconds)

理想情况下， date_obj.timestamp() 将以秒为单位返回日期。为了得到毫秒，我们需要乘以 1000。

下图显示了输出。

Python epoch DateTime to milliseconds

Python 纪元时间戳到日期时间

让我们看看如何将 epoch 时间戳转换为 datetime 。

示例:

import datetime
epochtime = 30256871
datetime = datetime.datetime.fromtimestamp(epochtime)
print(datetime)

下图显示了输出:

Python epoch timestamp to datetime

Python 纪元日期时间年份超出范围/Python 无效参数

在使用 Python epoch datetime 时，我得到了以下错误，即 Python epoch datetime year 超出范围或 Python 无效参数。

示例:

import datetime
timedate = datetime.datetime(1950, 12, 14, 0, 0).timestamp()
print(timedate)

在这个例子中，我选择了不在时间戳范围内的 1950 年。因此，对于这个输出，将会出现一个错误，在下图中显示为无效参数。

要修复无效参数错误，请将日期从 1950 年更改为 1970 之后的任何日期。

您可能会喜欢以下 Python 教程:

在这里，我们学习了如何将 Python epoch 转换成 DateTime 。

Python 异常处理(示例)

原文：https://pythonguides.com/python-exceptions-handling/

在本 Python 教程中，我们将学习 Python 异常处理，我们还将涵盖以下主题:

什么是例外？
Python 中的错误类型
Python 语法错误
Python 异常处理示例
试用示例
except 的示例
关于 try、except 和 else 的示例
最终尝试的示例
异常处理关键字
引发异常
提出一个错误
提高值错误
关于 KeyError 的示例
键盘中断错误示例
溢出错误示例
IndexError 示例
名称错误示例
ImportError 示例
AssertionError 示例
attributeerror 示例

什么是例外？
Python 中的错误类型
Python 语法错误
Python 异常处理示例
异常处理关键字
在 Python 中引发异常
在 Python 中引发错误
提升 Python 中的值错误

什么是例外？

异常是在一段代码执行过程中发生的错误。运行时的错误称为异常，异常的原因是输入不正确。

Python 中的错误类型

Types of errors in Python

当错误发生异常被调用时，python 将停止它并生成错误消息。

异常由 try、T2 处理，最后由和处理。

try–它检查代码块中的错误
例外–它处理错误
最后，它执行代码。

Python 语法错误

现在，我们可以看到 Python 中的语法错误。

在这个例子中，我使用了 try 来检查块中的错误，因为错误出现在 print(hello) 的语法中。
except 用作 except SyntaxError 用作 e 。执行 except。

示例:

try:
  print(hello)
except SyntaxError as e:
  print("Invalid syntax")
except:
    print("Invalid syntax")

随着 except 的执行，我们可以看到输出为“无效语法”。您可以参考下面的输出截图。

Python Syntax Error

Python 异常处理示例

现在，让我们看看 Python 异常处理的各种例子。

Python 中的 try 示例

现在，我们可以使用 python 中的 try 来检查一个示例。

在本例中，我使用了 try 来检查块中的错误，因为错误出现在 print(a+b) 中。执行 except。

示例:

try:
  print(a+b)
except:
  print("exception occured")

在下面的截图中，我们可以看到输出为发生了异常。

Example on try

Python 中 except 的例子

这里，我们可以用 Python 中的 except 来检查这个例子。

在本例中，我使用了 try 来检查块中的错误，因为这里没有定义 x，所以错误出现在 print(x) 中。
except 被用作 except TypeError ，except 被执行。所以，除了:打印(“错误”)被执行。

示例:

try:
  print(x)
except TypeError:
  print("x is not defined")
except:
  print("Error")

随着 except 的执行，我们可以看到输出为“Error”。下面的屏幕截图显示了输出:

Examples of except

Python 中的 try、except 和 else 示例

在这里，我们可以看到 Python 中 try 上的示例，except 和 else 。

在这个例子中，我已经打开了 try 块中的文件，以检查该文件是否包含错误或者没有找到该文件。
在使用 except else 语句之后使用 except IOError 如果文件不存在且内容未写入其中，则 else 将执行。

示例:

try:
   file = open("sushma.txt", "w")
   file.write("This is the test file")
except IOError:
   print("No file found")
else:
   print("The content is not written in the file")
   file.close()

我们可以看到 else 被执行为"内容没有被写入文件作为输出。您可以参考下面的输出截图。

Example on try, except and else

Python 中 try-finally 的例子

这里我们可以看到 Python 中 try finally 的例子。

在本例中，我使用了 try 来检查块中的错误，因为这里没有定义 x，所以错误出现在 print(x) 中。
当 finally 块出现时，finally 被执行。如果我们使用 finally 块，无论异常是否发生，finally 总是被执行。
甚至除此之外的版块也最终得到印刷。

示例:

try:
  print(x)
except:
  print("x is not defined")
finally:
  print(" The finally is executed")

下面的屏幕截图显示了输出:

Python try finally

异常处理关键字

Python 使用 try 和 except 关键字来处理异常。

在 Python 中引发异常

raise 关键字用于引发异常。
引发异常需要异常类的名称。
内置错误被隐式引发，内置异常可以被强制。

在本例中，我取了一个数= 2 ，如果使用了条件，则与错误消息一起写入提升值错误。

示例:

number = 2
if number < 36:
    raise ValueError('The given number is less than 36')

下面的屏幕截图显示了作为 valueError 的输出以及错误消息。

Raise an exception in Python

在 Python 中引发错误

现在，我们可以看到如何在 python 中引发错误。

在这个例子中，我将一个变量作为 num，并将一个 char 指定为“hello”。
使用 if 条件时，if not type(x)是 int。如果条件不为 true，则会引发错误。

示例:

num = "python"
if not type(num) is int:
  raise TypeError("Only integers are allowed")

由于条件不成立，我们可以看到一个类型错误作为输出。你可以参考下面的截图。

Raise an error in Python

提升 Python 中的值错误

现在，我们可以看到如何在 python 中引发 ValueError 。

在这个例子中，我取了一个变量作为数字，并赋予数字= 5 ，if 条件用作 if 数字< 19。
由于分配的数字小于 19，通过使用增加值错误(‘数字不应小于 19’)增加值错误。

示例:

number = 5
if number < 19:
    raise ValueError('number should not be less than 19')

您可以在下面的屏幕截图中看到输出错误。

Raise valueError in Python

Python 中 KeyError 的例子

现在，我们可以看看 python 中 KeyError 的例子。

在这个例子中，我将一个字典作为 Rate 并分配键和值对，以输入使用 input 语句的值。
try 块用于检查字典中是否出现任何错误，即使发现错误也要执行，但使用了 except KeyError。

示例:

Rate = { 'bottle' : 5, 'chair' : 1200, 'pen' : 50}
item = input('Enter the item: ')
try:
   print(f'The rate of {item} is {Rate[item]}')
except KeyError:
    print(f'The price of {item} is not found')

由于字典中没有汽车这一项，我们可以看到输出，因为汽车的价格在下面的截图中找不到。

Example on KeyError in Python

Python 中键盘中断错误的例子

在这里，我们可以看到 python 中键盘中断错误的示例。

在这个例子中，我使用了 try 块来检查错误。这里我使用了InP = input(" Enter the input:")来获取输入。
如果用户输入任何单词，如果用户输入 ctrl+c，则不会发生异常，除非执行。

示例:

try:
    inp = input("Enter the input:")
    print ('Press Ctrl+c')
except KeyboardInterrupt:
    print ('Caught KeyboardInterrupt')
else:
    print ('No exception occurred')

我们可以看到两个输出，其中一个输入为 book，那么输出为无异常发生，当输入为【ctrl+c】时，输出为【捕获键盘中断】。你可以参考下面的输出截图。

Example on KeyboardInterrupt Error in Python

Python 中溢出错误的例子

现在，我们可以检查 python 中 OverflowError 的例子。

在本例中，我将一个变量设为 i 并将 i=1 赋值，并使用 try 块检查错误，我将一个变量设为 **num = 2.5i 执行乘法运算。
循环的用于迭代，当乘法的结果大于给定范围时，出现溢出错误，当出现错误时，执行 except。

示例:

i=1
try:
  num = 2.5**i
  for i in range(20):
      print(i, num)
      num = num**8 
except OverflowError as e:
          print('Overflowed after ', num, e)

随着 except 的执行，我们可以看到输出在给定范围后溢出。您可以参考下面的输出截图。

Example on OverflowError in Python

Python IndexError 示例

现在，我们可以看到 python 中 IndexError 的示例。

在这个例子中，我使用了 try 块来检查错误。这里我取了一个列表，赋值 list = [1，2，3，5，6，7] 。
为了打印列表中的值，我使用了 print(list[8])，8 是索引值。
由于列表包含范围 5 以内的值，但值为 8，因此出现错误。
因此，except 被用作 except IndexError 被用作 e 并且 except 被执行。

示例:

try:
    list = [1,2,3,5,6,7]
    print(list[8])
except IndexError as e:
    print(e)
print("index error")

随着 except 的执行，我们可以看到输出为索引错误。您可以参考下面的输出截图:

Example on IndexError in Python

Python 名称错误示例

在这里，我们可以看到 python 中关于 NameError 的例子。

在这个例子中，我在代码块中使用了 try to error 来打印单词 cat，因为在 print(cat)中有一个错误。
except 被赋值为 except NameError ，except 被执行。

示例:

try:
    print(cat)
except NameError:  
    print ("NameError:'cat' is not defined")
else:  
    print ("word found no error")

当发现错误时，除了作为 NameError 执行之外:“cat”没有被定义为输出。下面的屏幕截图显示了输出

Example on NameError in Python

Python 导入错误示例

现在，我们可以看到 python 中 ImportError 的示例。

在这个例子中，我导入了一个名为 sys，的模块，并使用一个 try 块来检查错误。
我从 cv 中导入了一个名为 math 的模块，因为该模块中存在错误。所以，except 被用作的 except除外。

示例:

import sys
try:
    from cv import math
except Exception:
    print("improper module")

由于导入时出现错误，except 被执行，我们可以看到一个不正确的模块作为输出。您可以参考下面的输出截图。

Example on ImportError in Python

Python 中 AssertionError 的例子

在这里，我们可以看到 python 中 AssertionError 的例子。

在这个例子中，我使用了 try 块来检查块中的错误，a=5，b=5
当条件给定为时断言 a！= b ，因为条件不成立。AssertionError 发生异常给出为异常 AssertionError 。否则，执行 else 条件..

示例:

try:  
    a = 5
    b = 5
    assert a != b
except AssertionError:  
        print ("Exception Error")
else:  
    print ("Success, no error!")

当异常发生时，我们可以看到输出为“异常错误”。你可以参考下面的截图。

Example on AssertionError in Python

Python 中 AttiributeError 的例子

现在，我们可以看到 python 中 attribute error的例子。

在这个例子中，我将一个类作为类属性并传递参数对象，变量被声明为 num = 5。
我使用 try 块来检查代码块中的错误，except 被用作 except AttributeError 因为错误存在，except 被执行。

示例:

class Attributes(object):
    num = 5
    print(num)
try:
    object = Attributes()
    print (object.attribute)
except AttributeError:
    print ("Attribute Exception")

随着 except 的执行，我们可以在下面的截图中看到输出为“属性异常”。

Example on AttiributeError in Python

您可能会喜欢以下 Python 教程:

在本教程中，我们已经学习了 Python 异常处理，并且我们已经涵盖了以下主题:

什么是例外？
错误类型
Python 语法错误
Python 异常处理示例
试用示例
except 的示例
关于 try、except 和 else 的示例
最终尝试的示例
异常处理关键字
引发异常
提出一个错误
提高值错误
关于 KeyError 的示例
键盘中断错误示例
溢出错误示例
IndexError 示例
名称错误示例
ImportError 示例
AssertionError 示例
AttiributeError 示例

Python 退出命令(quit()，exit()，sys.exit())

原文：https://pythonguides.com/python-exit-command/

在这个 python 教程中，你将通过几个例子了解到 Python 退出命令。这里我们将检查 :

Python quit()函数
Python exit()函数
Python sys.exit()函数
Python os.exit()函数
Python 清理系统退出
python 中停止代码执行的程序
python 中 exit()和 sys.exit()的区别

Python 退出命令
Python 退出()函数
Python exit()函数
Python sys.exit()函数
Python os.exit()函数
Python 序列系统退出
python 中停止代码执行的程序
python 中 exit()和 sys.exit()的区别

Python 退出命令

让我们来看看 python 中的退出命令，比如 quit()、exit()、sys.exit()命令。

Python 退出()函数

在 python 中，我们有一个内置的 quit()函数，用于退出 python 程序。当遇到系统中的 quit() 函数时，完全终止程序的执行。

它不应该在生产代码中使用，并且这个函数只应该在解释器中使用。

举例:

for val in range(0,5):
    if val == 3:
        print(quit)
        quit()
    print(val)

写完上面的代码(python quit()函数)，你将打印出 " val " ，然后输出将显示为 " 0 1 2 " 。这里，如果“val”的值变为“3”，则程序被强制退出，并打印退出信息。

可以参考下面截图 python 退出()函数。

Python quit() function

Python exit()函数

我们也可以使用 python 中内置的 exit()函数来退出和走出 python 中的程序。它应该只在解释器中使用，它就像是 quit() 的同义词，使 python 更加用户友好

举例:

for val in range(0,5):
    if val == 3:
        print(exit)
        exit()
    print(val)

写完上面的代码(python exit()函数)，你将打印出 " val " ，然后输出将显示为 " 0 1 2 " 。这里，如果“val”的值变为“3”，那么程序被强制退出，并且它也将打印退出消息。

可以参考下面截图 python exit()函数。

Python exit() function

Python sys.exit()函数

在 python 中， sys.exit() 被认为很适合在生产代码中使用，这与 quit() 和 exit() 不同，因为 sys 模块总是可用的。它还包含了用于退出程序和执行过程的内置函数。 sys.exit() 也会引发 SystemExit 异常。

举例:

import sys
marks = 12
if marks < 20:
    sys.exit("Marks is less than 20")
else:
    print("Marks is not less than 20")

编写上述代码(python sys.exit()函数)后，输出将显示为一个"标记小于 20 " 。在这里，如果标记小于 20，那么它将退出程序作为一个异常发生，它将打印系统退出与参数。

可以参考下面截图 python sys.exit()函数。

Python sys.exit() function

Python os.exit()函数

那么首先，我们将导入 os 模块。然后，使用 os.exit() 方法终止具有指定状态的进程。我们可以在不刷新缓冲区或调用任何清理处理程序的情况下使用这个方法。

举例:

import os
for i in range(5):
    if i == 3:
        print(exit)
        os._exit(0)
    print(i)

写完上面的代码(python os.exit()函数)，输出会出现一个“0 1 2”。这里，它将退出程序，如果‘I’的值等于 3 ，那么它将打印退出消息。

可以参考下面截图 python os.exit()函数。

Python os.exit() function

Python 序列系统退出

SystemExit 是引发的异常，当程序运行需要停止时。

举例:

for i in range(8):
    if i == 5:
        print(exit)
        raise SystemExit
    print(i)

写完上面的代码(python raise SystemExit)，输出会出现“0 1 2 3 4”。这里，我们将使用这个异常来引发一个错误。如果的值‘I’等于 5 ，那么它将退出程序并打印退出信息。

可以参考下面截图 python raise SystemExit 。

Python raise SystemExit

python 中停止代码执行的程序

要在 python 中首先停止代码执行，我们必须导入 sys 对象，然后我们可以调用 exit() 函数来停止程序运行。这是停止代码执行的最可靠的方法。我们也可以将字符串传递给 Python exit()方法。

举例:

import sys
my_list = []
if len(my_list) < 5:
  sys.exit('list length is less than 5')

写完上面的代码(python 中程序停止代码执行)，输出会出现一个“列表长度小于 5”。如果你想阻止它运行，如果某个条件没有得到满足，那么你可以停止执行。这里，“我的列表”的长度小于 5，所以停止执行。

可以参考下面截图程序停止 python 中的代码执行。

Program to stop code execution in python

python 中 exit()和 sys.exit()的区别

exit()——如果我们在代码中使用 exit() 并在 shell 中运行它，它会显示一条消息，询问我是否要杀死该程序。exit()被认为不适合在生产代码中使用，因为它依赖于站点模块。
sys . exit()–但是在这种情况下 sys.exit() 更好，因为它关闭程序并且不询问。在生产代码中使用它被认为是好的，因为 sys 模块总是在那里。

在本 Python 教程中，我们通过示例了解了 python exit 命令,也看到了如何使用它:

Python quit()函数
Python exit()函数
Python sys.exit()函数
Python os.exit()函数
Python 清理系统退出
python 中停止代码执行的程序
python 中 exit()和 sys.exit()的区别

Python 扩展与追加[主要区别]

原文：https://pythonguides.com/python-extend-vs-append/

如果我们想了解如何使用 Python 中的【append()和 extend() 函数以及它们的区别，我们就到了正确的地方。在我们的 Python 项目中，我们无疑会使用这些健壮的列表方法。

Python 扩展与追加
如何使用 extend vs append 在列表中添加元素
扩展函数和追加函数哪个更快

Python 扩展 Vs 追加
Python 扩展 Vs 追加列表
- Python 中的 Append 方法
- Python 中的扩展方法
Python 扩展 Vs 追加速度

Python 扩展 Vs 追加

以下是 Python 的 add()和 extend()方法之间的区别:

使用 append()函数将单个元素添加到列表的末尾。
extend()方法添加了许多元素。

这里有一个简单的对比图表，解释了不同之处。

Python Extend Vs Append

上图显示了 extend()和 append()之间的区别，在接下来的小节中，我们将了解 extend()和 append()函数是如何工作的。

阅读:二分搜索法的 Python 程序

Python 扩展 Vs 追加列表

Python 中的 Append 方法

Python 中的 append()方法将一个元素添加到已经存在的列表中。该元素将被追加到旧列表的末尾，而不是返回到新列表中。将其参数作为单个元素添加到列表的末尾。列表又增加了一项。

因为列表可以包含几种数据类型的元素，所以我们可以添加任何数据类型的项目。

语法如下所示

list_name.append(item)

在哪里，

list_name: 是我们要修改的列表的名称或者需要添加项目的地方。
append() :该函数将参数作为括号内的单个元素，将该元素添加到 list_name 中。
item: 是添加到 list_name 中的元素或项目，可以是任何数据类型或对象，如数字、浮点、字符串等。

圆点起着至关重要的作用。它被称为“点符号”该函数的影响将应用于位于点号之前的列表，因为点号实际上是在说，“在这个特定的列表上调用这个方法”。

让我们举一个例子，看看方法*append()*如何通过以下步骤向列表中添加元素:

创建一个包含 2020 年美国前四个州死亡人数的列表，如California = 59778、Florida = 45800、Texas = 42142和New York = 32955。

usa_death = [59778, 45800, 42142, 32955]

假设我们想将州Pennsylvania = 27955的死亡人数添加到列表的末尾，这将是美国的第五个州，或者我们想修改列表，使其包含美国前五个州的死亡人数。为此，请使用以下代码。

usa_death.append(27955)

使用以下代码检查修改后的列表“usa_death”。

print(usa_death)

Python Extend Vs Append List Example

在上面的输出中，how list 被修改并添加了新元素到 list 的末尾“usa_death”。请记住，当我们使用. append()函数时，原始列表或初始列表会发生变化。这种方法不是复制列表，而是在内存中修改原始列表的内容。

在上面，我们谈到了 append()方法可以将任何对象添加到列表的末尾，这意味着我们可以添加任何数字、浮点数、字符串甚至整个列表。我们来看一个例子。

在本例中，我们将按照以下步骤将包含州名的列表添加到列表“usa_death”中:

usa_death_state = ["California", "Florida", "Texas", "New York", "Pennsylvania"]

现在使用下面的代码将整个列表“usa_death_state”添加到列表“usa_death”中。

usa_death.append(usa_death_state)

使用下面的代码查看列表“usa_death”。

print(usa_death)

Python Extend Vs Append List Append

使用 append()方法将整个项目添加到列表的末尾，如上面的输出所示。如果项目是序列，例如列表、字典或元组，则完整的序列将作为一个项目添加到当前列表中。

阅读:在 Python 中从一个字符串中移除一个特定的字符

Python 中的扩展方法

extend()函数扩展列表并迭代遍历其参数，添加每个新元素。随着越来越多的组件包含在它的参数中，这个列表变得越来越长。

语法如下所示

list_name.extend(iterable)

在哪里，

list_name: 是我们要修改的列表的名称或者需要添加项目的地方。
extend() :以 iterable 为参数的函数名。
iterable: 括号中的字符串、列表、字典、元组或集合，包含将作为不同列表元素插入的项目。

让我用您最近学到的一个方法 append()来演示这个方法的重要性。根据我们到目前为止所学的内容，我们需要多次使用 append()，如下所示，以便使用这种方法向列表中添加许多不同的项目。

使用下面的代码创建一个新列表。

data = [2,6,4,7] # We are going to modify this list

使用下面的代码添加一些数字或元素。

# append the element in the list

data.append(9)
data.append(1.5)
data.append(6.3)

#check the modified list 
print(data)

Python Extend Vs Append List Extend

这不是很有效，不是吗？如果需要添加几十个或者几百万个值呢？对于这个简单的活动，我们不能写成千上万行。这个过程需要很长时间。

然而，有一种方法更有效、可读性更强、也更简洁:extend()。

使用下面的代码创建一个新列表。

data = [2,6,4,7] # We are going to modify this list

使用下面的代码创建我们想要添加到列表“数据”中的值列表。

add_data = [9, 1.5, 6.3]

使用下面的代码将上面创建的列表“add_data”传递给 extend()方法。

data.extend(add_data)

使用下面的代码查看添加到列表“数据”中的数字。

print(data)

Python Extend Vs Append List Extend Example

看看上面的输出，如何使用 extend()方法一次性添加包含数字的列表。

阅读:如何在 Python 中删除字符串的最后一个字符

Python 扩展 Vs 追加速度

哪个更快？下面是一个简单的脚本，它评估了使用 extend()和 append()方法构建长度逐渐变大的大型列表的性能，以便为该查询提供答案。

由于 Python 能够将条目批量添加到列表中，而不是重复调用同一个方法，因此对于较大的列表，extend()方法应该更快。

首先，构建两个函数 list by append(n)和 list by extend(n ),它们将整数列表大小 n 作为输入参数，并分别使用 append()和 extend()函数创建连续增加的整数条目列表。

import time
def list_for_append(ele_n):
    '''creates a list and appends n additional elements to it'''
    lst_ = []
    for i in range(ele_n):
        lst_.append(ele_n)
    return lst_
def list_for_extend(ele_n):
    '''creates a list and extends n additional elements to it'''
    lst_ = []
    lst_.extend(range(ele_n))
    return lst_

其次，我们使用 100 个不同的列表大小 n 值来比较这两个函数的运行时间。

# Compare the two functions' running times
lst_sizes = [i * 10000 for i in range(100)]
append_rtimes = []
extend_rtimes = []
for size in lst_sizes:
    # Obtain time stamps.
    time0 = time.time()
    list_for_append(size)
    time1 = time.time()
    list_for_extend(size)
    time2 = time.time()
    # Compute runtimes
    append_rtimes.append((size, time1 - time0))
    extend_rtimes.append((size, time2 - time1))

Python Extend Vs Append List Extend Tutorial

第三，用下面的代码画出两个函数的运行时间。

import matplotlib.pyplot as plt
import numpy as np
append_rtimes = np.array(append_rtimes)
extend_rtimes = np.array(extend_rtimes)
print(append_rtimes)
print(extend_rtimes)
plt.plot(append_rtimes[:,0], append_rtimes[:,1], label='append()')
plt.plot(extend_rtimes[:,0], extend_rtimes[:,1], label='extend()')
plt.xlabel('List size')
plt.ylabel('Runtime in (seconds)')
plt.legend()
plt.savefig('append_vs_extend.jpg')
plt.show()

Python Extend Vs Append List Extend

Python Extend Vs Append List-Extend Example

下图比较了 add()和 extend()两种方法的运行时。我们现在可以在 x 轴上看到列表大小，范围从 0 到 1，000，000 个条目。我们可以在 y 轴上看到执行每个功能所需的运行时间，单位为秒。

结果图表明，对于少量的数万个项目，这两种方法都非常快。事实上，它们移动得如此之快，以至于时间模块的 time()方法无法记录时间的流逝。

然而，一旦列表的大小增加到几十万个元素，extend()方法就开始流行起来。

您可能也喜欢阅读以下 Python 教程。

在本 Python 教程的最后，我们了解了 Python 中 append 和 extend 方法之间的主要区别。此外，我们还讨论了以下主题。

Python 扩展与追加
如何使用 extend vs append 在列表中添加元素
扩展函数和追加函数哪个更快

Saurabh

我叫 Kumar Saurabh，是一名 Python 开发人员，在 TSInfo Technologies 工作。此外，像 Python 编程，SciPy，机器学习，人工智能等技术的专业知识。是我喜欢做的事情。

Python 中的斐波那契数列[包含 13 个不同例子的完整程序]

原文：https://pythonguides.com/python-fibonacci-series/

在这个 python 教程中，你将了解到 Python 斐波那契数列，我们将看到 Python 程序打印斐波那契数列，我们还将检查 :

python 中的斐波那契数列
使用递归打印斐波那契数列的 Python 程序
python 中的斐波那契数列使用 for 循环
Python 程序可以打印多达 n 项的斐波那契数列
Python 程序打印 0 到 50 之间的斐波那契数列
使用迭代打印斐波那契数列的 Python 程序
不使用递归打印斐波那契数列的 Python 程序
Python 程序使用递归打印斐波那契数列直到“n”值
使用 while 循环在 python 中打印斐波那契数列
使用函数打印斐波那契数列的 Python 程序
用 python 打印前 50 个斐波那契数的程序
Python 程序使用列表在 python 中打印斐波那契数列
python 中使用函数的斐波那契数列

Python 程序打印斐波那契数列
Python 程序使用递归打印斐波那契数列
python 中的斐波那契数列使用 for 循环
Python 程序打印最多 n 项的斐波那契数列
Python 程序打印 0 到 50 之间的斐波那契数列
Python 程序使用迭代打印斐波那契数列
Python 程序不使用递归打印斐波那契数列
Python 程序使用递归打印斐波那契数列直到‘n’值
使用 while 循环在 python 中打印斐波那契数列
python 中的斐波那契数列使用函数
用 python 打印前 50 个斐波那契数的程序
Python 程序使用列表在 Python 中打印斐波那契数列

Python 程序打印斐波那契数列

现在，我们将看到 python 程序打印斐波那契数列。

在这个例子中，我使用了函数 def fib(n)
我们已经将第一项初始化为 0 ，将第二项初始化为 1 。
循环的用于迭代这些值，直到给定的数字
最后，它将打印斐波那契数列

举例:

def fib(n):
    a = 0
    b = 1
    if n == 1:
        print(a)
    else:
        print(a)
        print(b)
        for i in range(2,n):
            c = a + b
            a = b
            b = c
            print(c)
fib(10)

为了得到输出，我使用了 print(c) 来得到斐波那契数列。您可以参考下面的输出截图。

Python program to print fibonacci series

上面的代码，我们可以用 Python 中的来打印斐波那契数列。

你可能会喜欢，如何在 python 中创建变量和在 Python 中创建注释行。

Python 程序使用递归打印斐波那契数列

在这里，我们将看到 python 程序使用递归打印斐波那契数列。

在这个例子中，我使用了函数 def Fibonacci(number)
这里，如果 (number == 0) 检查给定的数是否为 0。如果为真，该函数返回值零。
elif (number == 1) 检查给定的数是否为 1。如果为真，函数返回值一。
递归函数 Fibonacci() 用于计算 n 项序列。
一个 for 循环用于递归地迭代和计算每一项。
我们将接受用户的输入

举例:

def Fibonacci(number):
           if(number == 0):
                      return 0
           elif(number == 1):
                      return 1
           else:
                      return (Fibonacci(number - 2)+ Fibonacci(number - 1))
number = int(input("Enter the Range Number: "))
for n in range(0, number):
           print(Fibonacci(n))

为了得到输出，我使用了 print(Fibonacci(n)) 来使用递归得到斐波那契数列。您可以参考下面的输出截图。

fibonacci series in python using recursion

上面的代码我们可以用 Python 中的递归来打印斐波那契数列。

你可能喜欢，Python dictionary append with examples和在 Python 中检查一个列表是否为空。

python 中的斐波那契数列使用 for 循环

让我们看看使用 for 循环打印斐波那契数列的 python 程序

首先，我们将允许用户输入任何正整数。
我们已经将 First_val 初始化为 0 ，将 second_val 初始化为 1 。
这里，循环的用于从 0 到用户指定的数字的迭代。
最后， print(next) 用于在 Python 中得到斐波那契数列

举例:

下面是 python 中使用 for 循环的斐波那契数列的例子。

num = int(input("Enter the Range Number: "))
First_val = 0
Second_val = 1
for n in range(0, num):
           if(n <= 1):
                      next = n
           else:
                      next = First_val + Second_val
                      First_val = Second_val
                      Second_val = next
           print(next)

为了获得输出，我使用了 print(next) 来获得使用 for 循环的斐波那契数列。您可以参考下面的输出截图。

Python program to print fibonacci series using for loop

上面的代码，我们可以用 Python 中的 for 循环来打印斐波那契数列。

又念， Python 程序查闰年。

Python 程序打印最多 n 项的斐波那契数列

在这里，我们将看到 python 程序打印多达 n 项的斐波那契数列

首先，我们将允许用户输入 n 个术语
我们已经将 n1 初始化为 0 并将 n2 初始化为 1 。
如果项的数量超过 2，我们将使用一个 while 循环通过添加前两项来查找序列中的下一项。
之后，我们交换变量，继续这个过程。

举例:

n = int(input("Enter the n terms: "))
n1, n2 = 0, 1
count = 0
if n <= 0:
   print("Please enter a positive integer")
elif n == 1:
   print("Fibonacci sequence upto",n,":")
   print(n1)
else:
   print("Fibonacci sequence:")
   while count < n:
       print(n1)
       r = n1 + n2
       n1 = n2
       n2 = r
       count += 1

为了得到输出，我使用了 print(Fibonacci sequence) 来得到多达 n 项的 Fibonacci 数列。您可以参考下面的输出截图

Python program to print fibonacci series up to n terms

这是一个 Python 程序，可以打印多达 n 项的斐波那契数列。

另外，请阅读 Python 中的如何将列表转换为字符串和 Python 平方一个数字。

Python 程序打印 0 到 50 之间的斐波那契数列

现在，我们将看到 python 程序打印 0 到 50 之间的斐波那契数列

我们已经将 n1 初始化为 0 并将 n2 初始化为 1 。
每下一个数字都是通过将它前面的两个数字相加得到的。

举例:

n1,n2 = 0,1
print(n1)
while n2<50:
    print(n2)
    n1,n2 = n2, n1+n2

为了得到输出，我使用了 print 来得到 0 到 50 之间的斐波那契数列。您可以参考下面的输出截图。

Python program to print fibonacci series between 0 to 50

上面的 Python 代码，我们可以用 Python 中的来打印 0 到 50 之间的斐波那契数列。

Python 程序使用迭代打印斐波那契数列

现在，我们将看到 python 程序使用迭代打印斐波那契数列。

在这个例子中，我使用了函数 def fib(number) 。
我们首先初始化为 0 ，其次初始化为 1 。
while 循环用于通过添加前两项来查找序列中的下一项。
然后更新第一个和第二个的值。

举例:

def fib(number):
   count = 0
   first = 0
   second = 1
   temp = 0
   while count <= number:
      print(first)
      temp = first + second
      first = second
      second = temp
      count = count + 1
fib(6)

为了得到输出，我使用了 print 通过迭代得到斐波那契数列。您可以参考下面的输出截图。

Python program to print fibonacci series using iteration

上面的 Python 代码，我们可以用 Python 中的使用迭代来打印斐波那契数列。

你可能喜欢读，什么是 Python 字典和没有换行符的 Python 打印。

Python 程序不使用递归打印斐波那契数列

我们来看 python 程序打印斐波那契数列不使用递归。

首先，用户将输入系列的前两个数字和用户要打印的术语数。
然后打印前两个数字
while 循环用于计算前两个数的和，然后是斐波那契数列
现在，打印斐波那契数列，直到 n-2 大于 0 。

举例:

n1=int(input("Enter the first number of the series: "))
n2=int(input("Enter the second number of the series: "))
n=int(input("Enter the number of terms needed: "))
print(n1,n2,end=" ")
while(n-2):
    t=n1+n2
    n1=n2
    n2=t
    print(n2,end=" ")
    n=n-1

为了获得输出，我使用了 print 来获得斐波那契数列，而没有使用递归。您可以参考下面的输出截图。

Python program to print fibonacci series without using recursion

上面的 Python 代码我们可以用来打印斐波那契数列，而不需要使用 Python 中的递归。

你可能喜欢， Python zip()函数。

Python 程序使用递归打印斐波那契数列直到‘n’值

让我们看看 python 程序使用递归打印斐波那契数列直到‘n’值。

在这个例子中，我使用了函数def``recursion _ fib(num)
这里，如果 num < = 1 那么返回 num
其他项是通过将前面两项相加得到的。n 项是 (num-1) 和 (num-2) 项之和。
递归函数 recursion_fib 用于计算 n 项序列。
一个 for 循环用于递归地迭代和计算每一项。

举例:

def recursion_fib(num):
   if num <= 1:
       return num
   else:
       return(recursion_fib(num-1) + recursion_fib(num-2))
n = 9
if n <= 0:
   print("Plese enter a positive integer")
else:
   print("Fibonacci sequence:")
   for i in range(n):
       print(recursion_fib(i))

为了获得输出，我使用了 print(recursion_fib(i)) 来获得 fibonacci 数列，直到使用递归的‘n’值。您可以参考下面的输出截图。

Python program to print fibonacci series until ‘n’ value using recursion

上面的代码我们可以用 Python 中的递归来打印斐波那契数列直到‘n’的值。

使用 while 循环在 python 中打印斐波那契数列

现在，我们将看到 python 程序使用 while 循环打印斐波那契数列。

首先，用户将输入任意正整数。
我们已经将 F_val 初始化为 0 ，将 S_val 初始化为 1 。
我们已经声明了三个整数变量，比如 I、F_val 和 S_val。
while 循环确保循环从 0 开始，并且小于用户给定的数字。
在 while 循环中，我们使用了 if 和 else。
最后斐波纳契数列将被输出。

举例:

Num = int(input("Enter the Range Number: "))
i = 0
F_val = 0
S_val = 1
while(i < Num):
           if(i <= 1):
                      Next = i
           else:
                      Next = F_val + S_val
                      F_val = S_val
                      S_val = Next
           print(Next)
           i = i + 1

为了获得输出，我使用了 print(Next) 来使用 while 循环获得斐波那契数列。您可以参考下面的输出截图。

Python program to print fibonacci series using while loop

上面的代码，我们可以用 Python 中的 while 循环来打印斐波那契数列。

也可阅读， Python For 循环示例和 Python While 循环示例。

python 中的斐波那契数列使用函数

在这里，我们将看到 python 程序使用函数打印斐波那契数列

在这个例子中，我们使用的函数是 def fib(n)
我们已经将 n1 初始化为 0 ，将 n2 初始化为 1 。
如果 n == 1 则打印(n1)
循环的用于迭代这些值，直到给定的数字
最后，它将打印斐波那契数列

举例:

def fib_series(n):
    n1 = 0
    n2 = 1
    if n == 1:
        print(n1)
    else:
        print(n1)
        print(n2)
        for i in range(2,n):
            t = n1 + n2
            n1 = n2
            n2 = t
            print(t)
fib_series(5)

为了得到输出，我使用了 print(t) 来使用函数得到斐波那契数列。您可以参考下面的输出截图。

Python program to print fibonacci series using function

用 python 打印前 50 个斐波那契数的程序

有人让你写一个 python 程序来得到 0 到 50 之间的斐波那契数列吗？让我们看看用 python 打印前 50 个斐波那契数的程序。

在这个例子中，我使用了函数defFibonacciNum(n)
我们已经将 n1 初始化为 0 ，将 n2 初始化为 1 。
在这里，如果 n < 1 则返回
循环的用于迭代这些值，直到给定的数字。
最后，调用函数fibonaccium(50)获得输出中的前 50 个 fibonacci 数。

举例:

def FibonacciNum(n):
    n1 = 0
    n2 = 1
    if (n < 1):
        return
    print(n1, end=" ")
    for i in range(1, n):
        print(n2, end=" ")
        next = n1 + n2
        n1 = n2
        n2 = next
FibonacciNum(50)

你可以参考下面的截图，看看 python 中前 50 个斐波那契数的输出。

Program to print first 50 fibonacci numbers in python

Python 程序使用列表在 Python 中打印斐波那契数列

现在，我们将看到 python 程序使用列表用 python 打印斐波那契数列

首先，用户将输入任意正整数。
循环的用于迭代这些值，直到给定的数字
最后， print(fib) 得到列表中的斐波那契数列。

举例:

n = int(input("Enter the number:"))
if n==0:
    fib=[0]
elif n==1:
    fib=[0,1]
else:
    fib=[0,1]
    for i in range(2,n):
        fib.append(fib[i-1]+fib[i-2])
print(fib)

为了获得输出，我使用了 print(fib) 来使用函数获得斐波那契数列。您可以参考下面的输出截图。

Python program to print fibonacci series in python using a list

上面的代码我们可以用 Python 中的函数来打印斐波那契数列。

您可能会喜欢以下教程:

在本 Python 教程中，我们学习了 ****Python 程序在 Python 中打印斐波那契数列或斐波那契数列。此外，我们还讨论了以下主题:

Python 程序打印斐波那契数列
python 中使用递归的斐波那契数列
使用 for 循环打印斐波那契数列的 Python 程序
Python 程序可以打印多达 n 项的斐波那契数列
Python 程序打印 0 到 50 之间的斐波那契数列
使用迭代打印斐波那契数列的 Python 程序
python 中无递归的斐波那契数列
Python 程序使用递归打印斐波那契数列直到“n”值
使用 while 循环打印斐波那契数列的 Python 程序
使用函数打印斐波那契数列的 Python 程序
用 python 打印前 50 个斐波那契数的程序
Python 程序使用列表在 python 中打印斐波那契数列

Python 文件方法(有有用的例子)

原文：https://pythonguides.com/python-file-methods/

在这个 Python 教程中，我们将讨论 Python 中的文件方法，我们还将检查以下主题。

Python 文件 write()方法
Python 文件 close()方法
Python 文件 read()方法
Python 文件 readline()方法
Python 文件 writable()方法
Python 文件可读()方法
Python 文件 fileno()方法
Python 文件 truncate()方法
Python 文件 flush()方法
Python 文件 tell()方法

我们将看到所有的 Python 文件方法和各种例子。

如果您是 Python 的新手，您可以查看一篇文章来用 Python 创建您的第一个 hello world 程序。

下面是 Python 文件方法的列表。

Python 文件的 write()方法
Python 文件关闭()方法
Python 文件 read()方法
Python 文件 readline()方法
Python 文件的 writable()方法
Python 文件可读()方法
Python 文件 fileno()方法
Python 文件 truncate()方法
Python 文件 flush()方法
Python 文件 tell()方法

Python 文件的 write()方法

Python file write() 方法用于将指定的文本写入文件。这里，我们用用于追加的“a”打开文件，然后一些文本被添加到文件中。
如果我们将使用 "a" 文本将被添加到当前文件，默认情况下在文件的末尾。
f.write("快乐学习！")被追加在文件的最后。

举例:

f = open("examplefile.txt", "a")
f.write(" Happy Learning! ")
f.close()
f = open("examplefile.txt", "r")
print(f.read())

写完上面的代码后，一旦打印出来，输出将显示为“Hello all！欢迎提交示例。祝你好运！快乐学习！”。在这里，我们在 "r" 模式下打开了文件 "examplefile.txt" ，因此，它将被打开，我们将能够在追加后读取文件。

您可以参考下面的输出截图。

Python file write() method

Python 文件关闭()方法

Python 中的 file close() 方法用于关闭打开的文件。打开文件时，使用 close()方法关闭文件是一个好习惯。

举例:

f = open("examplefile.txt", "r")
print(f.read())
f.close()

这里，我们在“r”模式下打开了文件名为“example file . txt”的文件，最后，我们使用了 close() 方法来关闭文件。

当我们运行上面的程序时，它会产生以下输出。

Python file close() method

Python 文件 read()方法

Python 文件操作中的 read() 方法用于从 "examplefile.txt" 中读取文件内容。 read() 方法从文件中返回指定的字节，默认为-1，这意味着它将读取整个文件内容。

举例:

f = open("examplefile.txt", "r"
print(f.read())

写完上面的代码后，当我们打印 "f.read()" 时，输出会出现 "Hello all！欢迎提交示例。读书快乐！”。在这里，我们没有提到指定的字节数。所以， read() 方法默认返回整个文件。

python 文件 read()方法可以参考下面的截图。

Python file read() method

Python 文件 readline()方法

Python 文件 readline() 方法从“example file . txt”文件中读取一整行。通过使用 size 参数，我们可以在输出中获得指定的字节。

举例:

f = open("examplefile.txt", "r")
print(f.readline())

在这里，当我们打印 "f.readline()" 时，输出将出现"大家好！欢迎提交示例。”。同样，我们可以看到 readline() 从文件中返回第一行。我们还可以指定从该行返回多少字节。

python 文件 read()方法可以参考下面的截图。

Python file readline() method

Python 文件的 writable()方法

Python file writable() 方法是一个内置方法，如果文件可写，则返回 True 否则，如果文件不可写，则返回 False。一个文件只有在使用【w】打开写入【a】追加时才是可写的。

**举例:

myfile = open("examplefile.txt", "w")
print(myfile.writable())
myfile.close()

为了得到输出，我们将打印 "myfile.writable()" 它将返回布尔值 "True" ，这意味着文件是可写的，并且文件是使用 "w" 打开的。

下面的截图显示了 python 中的 file writable()方法的输出。

Python file writable() method

Python 文件可读()方法

python 中的 readable() 方法是 Python 中的内置方法，它检查文件是否可读。该方法返回一个布尔值。如果文件可读，readable()方法返回真，否则返回假。

举例:

myfile = open("examplefile.txt", "r")
print(myfile.readable())
myfile.close()

为了得到输出，我们将打印 "myfile.readable()" ，它将返回 "True" 作为输出，因为文件是可读的。使用“r”打开的文件是可读的。

当我们运行上面的程序时，它会产生以下输出。

Python file readable() method

Python 文件 fileno()方法

Python file fileno() 方法是 Python 中的一个内置方法，它以数字的形式返回流的文件描述符。如果操作系统不使用文件描述符，就会发生错误。

举例:

myfile = open("example.txt", "r")
print(myfile.fileno())

在这里，当我们将打印 "myfile.fileno()" 时，输出将出现 " 3 " 。同样，我们可以看到 fileno() 返回一个整数值，它是文件描述符。

python 文件 fileno()方法可以参考下面的截图。

Python file fileno() method

Python 文件 truncate()方法

python 文件中的 truncate() 方法是 Python 中的一个内置方法，它将文件的大小调整为给定的字节数。
首先，我已经在【w】模式下打开了文件。然后我们在文件上写。这里，我给了大小为“25”，这是一个可选参数。
truncate 方法后，我们将读取文件，并打印“ myfile.read() ”以查看输出。

举例:

myfile = open("examplefile.txt", "w")
myfile.write("Python is one of the good programming language")
myfile.truncate(25)
myfile.close()
myfile = open("examplefile.txt", "r")
print(myfile.read())

为了得到输出，我们将打印 "myfile.read()" 然后输出将出现 " Python 是好的之一"。因此，它将根据给定的大小“25”截断文件。

关于 python 文件 truncate()方法，可以参考下面的截图。

Python file truncate() method

Python 文件 flush()方法

flush() 方法是 python 中的一个内置方法。它用于在写入文件时清除内部缓冲区。在 python 中处理文件时，这是最好的方法。

举例:

myfile = open("examplefile.txt", "a")
myfile.write("Welcome to python")
myfile.flush()
myfile.write("Programming.....")

为了查看输出，我们将使用 "myfile.flush()" ，它将清除文件的内部缓冲区。但是，它不影响文件的内容。因此，文件的内容可以被读取和显示。

下面的截图显示了 python 中的文件 flush()方法的输出，它在输出中不返回任何内容。

Python file flush() method

Python 文件 tell()方法

Python file tell() 方法返回当前文件在文件中的位置。它不接受任何参数，返回一个整数值。

举例:

myfile = open("examplefile.txt", "r")
print(myfile.tell())
myfile.close()

在这里，当我们打印 "myfile.tell()" 时，输出将显示为 " 0 " 。这里，如果没有在追加模式下打开，最初文件指针指向文件的开头。所以，tell()的初始值是零。

关于 python 文件 tell()方法，可以参考下面的截图。

Python file tell() method

您可能会喜欢以下 Python 教程:

在本 Python 教程中，我们通过几个例子学习了 python 中的文件方法。此外，我们还讨论了以下主题:

Python 文件 write()方法
Python 文件 close()方法
Python 文件 read()方法
Python 文件 readline()方法
Python 文件 writable()方法
Python 文件可读()方法
Python 文件 fileno()方法
Python 文件 truncate()方法
Python 文件 flush()方法
Python 文件 tell()方法

enjoysharepoint.com/**

Python 查找列表中元素的索引

原文：https://pythonguides.com/python-find-index-of-element-in-list/

在本 Python 教程中，我们将学习如何使用 Python 找到列表中元素的索引。此外，我们将涵盖这些主题。

Python 查找列表中最接近值的元素的索引
Python 查找列表中元素的索引大于
Python 查找列表列表中元素的索引
Python 使用条件查找列表中元素的索引
Python 查找列表中项目的索引
Python 通过属性查找列表中对象的索引
Python 在包含字符串的列表中查找项目的索引
Python 通过值获取列表中元素的索引
Python 无例外地在列表中查找项目的索引
Python 查找列表中项目的索引，不区分大小写
Python 在迭代时获取列表中项目的索引
Python 使用默认值获取列表中项目的索引
Python 获取列表中元素的索引(如果存在)
Python 在列表正则表达式中查找项目的索引
Python 查找列表中项目的位置
Python 获取列表中最大元素的索引。
Python 查找列表中最小元素的索引
在列表 Python 中查找重复元素的索引
Python 查找列表中多个元素的索引
Python 获取列表 NumPy 中元素的索引
Python 在两个列表中查找公共元素的索引
Python 获取列表理解中项目的索引

Python 查找列表中元素的索引
- 获取 Python 列表中元素的索引
- 通过使用 NumPy 方法
Python 查找列表中最接近值的元素的索引
Python 发现列表中元素的索引大于
Python 查找列表列表中元素的索引
Python 使用条件查找列表中元素的索引
Python 查找列表中项目的索引
Python 在包含字符串的列表中查找项目的索引
Python 通过值获取列表中元素的索引
Python 无例外地找到列表中项目的索引
- 在列表中无一例外地找到项目的索引
Python 查找列表中项目的索引，不区分大小写
Python 在迭代时获取列表中项目的索引
- 在迭代时获取列表中某项的索引
Python 获取列表中项目的索引，默认为
如果存在，Python 获取列表中元素的索引
Python 在列表正则表达式中查找项目的索引
Python 在列表中找到一个项目的位置
Python 获取列表中 max 元素的索引
Python 查找列表中最小元素的索引
在列表 Python 中查找重复元素的索引
- 获取重复值的索引号
Python 查找列表中多个元素的索引
Python 获取列表 NumPy 中元素的索引
Python 在两个列表中找到公共元素的索引
Python 获取列表理解中项目的索引

Python 查找列表中元素的索引

在本期节目中，我们将讨论如何使用 Python 找到列表中元素的索引。
在 Python 中获取列表中项的索引。我们将使用一个方法 list.index() ，这个函数将总是返回列表中特定项目的索引，这是 Python 中的一个内置()函数。
在 Python 中，列表基本上是项目的集合，每个项目都有其唯一的位置，这些位置被称为索引。现在，通过使用 list.index() 函数，我们能够获得列表中某项的索引。

语法:

下面是 index()方法的语法

list.index(
           element,
           start,
           end
          )

它由几个参数组成
- 元素:该参数表示您想要查找哪个元素。
- start: 这是一个可选参数，它将帮助您开始搜索。
- end: 此参数指定如果您提供“end”参数，则搜索将在索引处结束。

举例:

让我们举个例子，看看如何在一个列表中找到一个元素的索引

new_lis = [82, 64, 189, 920, 452, 701]

new_val = 920
result = new_lis.index(new_val)
print(result)

在上面的代码中，我们创建了一个整数列表，然后我们将在给定的列表中找到‘920’的索引。为了完成这项任务，我们首先创建一个变量‘result’，然后分配一个 list.index() 方法来获取该数字的索引值。

下面是以下给定代码的输出

Python find an index of an element in a list

用 Python 读平方根

获取 Python 列表中元素的索引

在这个例子中，我们将结合使用 for 循环和 append() 方法来获取 Python 列表中元素的索引。
为了首先获得列表中元素的索引，我们将创建一个列表‘lis _ 1’，现在我们想要获得列表中存在的索引号‘193’，现在我想要具有编号‘193’的所有索引。

源代码:

lis_1 = ['45', '92', '193', '193', '231', '190'] 

emp_lis = [] 
for m in range(0, len(lis_1)) : 
    if lis_1[m] == '193' : 
        emp_lis.append(m)
print("Index no of '193':", emp_lis)

下面是以下给定代码的实现

Python find the index of an element in a list

正如您在截图中看到的，该元素出现在 2 和 3 位置。

通过使用 NumPy 方法

在这个例子中，我们特别使用了 Python numpy 数组的概念来获取列表中元素的索引。因此，为了完成这项任务，我们首先创建一个列表，然后使用 np.array() 函数将列表转换成一个数组。现在我们想得到列表中可用的‘119’号的索引。
为此，我们可以应用概念 np.where() 方法，该函数将帮助用户根据条件从给定数组中选择元素。

源代码:

import numpy as np

new_list = [56,829,992,119,734,567,890] 
arr = np.array(new_list)
result = np.where(arr == 119)[0]
print(result)

你可以参考下面的截图

Python find the index of an element in a list

正如你在截图中看到的，元素“119”出现在 3 个位置。

这就是如何使用 NumPy 方法获取 Python 列表中元素的索引。

同样，检查: Python 在字符串中查找数字

Python 查找列表中最接近值的元素的索引

让我们看看如何在列表中找到最接近值的元素索引。
通过使用 min() 方法，我们可以应用一个键来搜索每个项目与 K 的差异，这个方法将总是返回差异数量较少的项目。

举例:

new_lis = [21.34,15.4567,18.478,22.105,13.189]

b = min(range(len(new_lis)), key=lambda m: abs(new_lis[m]-17.6))
print(b)

下面是以下代码的截图

Python find an index of the element in the list closest to value

阅读:删除非 ASCII 字符 Python

Python 发现列表中元素的索引大于

在这个例子中，我们将使用一个 Python lambda 函数来等于每个索引处的给定值，然后过滤掉给定的条件。该方法实际上将索引值设置为 0 ，并指定大于该值的第一个项目。

举例:

my_lis = [109,134,12,83,10]

new_output = list(filter(lambda m: m > 120, my_lis))[0]
print(my_lis.index(new_output))

在上面的代码中，我们首先初始化了一个列表‘my _ lis’，然后使用过滤器+ lambda() 函数来获取列表中大于‘120’的元素的索引。

一旦您将打印‘new _ output’，那么输出将显示大于‘120’的索引号，即‘1’:134。

下面是以下给定代码的输出

Python find an index of the element in list greater than

阅读: Python 将二进制转换成十进制

Python 查找列表列表中元素的索引

在这个程序中，我们将讨论如何在 Python 中找到列表列表中元素的索引。
为了执行这个特定的任务，我们将应用 list.index() 方法，在这个示例中，我们将检查条件，如果列表中没有该项目，那么 index() 方法将引发一个错误。
在下面的例子中，我们已经创建了一个列表列表，我们必须在给定的列表中找到索引号‘321’。

源代码:

new_lis_lis = [["98","85","112","321","405"],["189","239","706","148","227"]]
def find(m):
    for x, new_val in enumerate(new_lis_lis):
        try:
            y = new_val.index(m)
        except ValueError:
            continue
        yield x, y

new_result = [z for z in find('321')]
print(new_result)

下面是以下给定代码的执行过程

Python find an index of the element in a list of lists

正如您在截图中看到的，该元素出现在 3 个位置。

阅读: Python 统计文件中的字数

Python 使用条件查找列表中元素的索引

让我们看看如何用 Python 中的条件找到列表中元素的索引。
通过使用列表理解方法，我们可以很容易地得到特定元素的索引号。在 Python 中，列表理解用于遍历给定列表中的项目，并访问其索引和值。
它将检查 len() 方法中的条件，如果没有参数被传递，那么它将返回一个空列表。这种方法实际上会帮助用户减少较长的循环，使程序更容易。

举例:

new_lis = [1877,18,77,30,77,45,567]

output = [ i for i in range(len(new_lis)) if new_lis[i] == 77 ]
print("Get index number from list:",output)

在上面的代码中，我们要使用列表理解来找到‘77’的索引号。一旦您将打印“输出”，那么结果将显示索引号‘77’，即 2 和 4。

你可以参考下面的截图

Python find an index of an element in the list with condition

另外，请查看:如何在 Python 数据帧中找到重复项

Python 查找列表中项目的索引

在 Python 中，为了获得列表中项目的索引，我们可以应用 len() 类的列表理解，将项目作为参数传递。
在这个例子中，我们必须找到给定列表中第一次出现的值的索引。首先，我们将创建一个列表‘new _ lis’，并为其分配整数值。
现在使用 len() 方法并给出条件，如果值‘64’出现在列表中，那么它将显示索引号，否则它将返回一个空列表。

源代码:

new_lis = [73,123,64,52,74,86,32,64,64] 

output = [m for m in range(len(new_lis)) if new_lis[m] == 64] 
print("Find index of element in list:",output)

下面是以下代码的截图

Python find an index of the item in a list

正如您在屏幕截图中看到的，该元素出现在 2、7 和 8 位置。

阅读:Python 中的 Case 语句

Python 在包含字符串的列表中查找项目的索引

在本节中，我们将讨论如何使用 Python 在包含 string 的列表中查找项目的索引。
为了首先获得列表中元素的索引，我们将创建一个字符串列表‘new _ list’，现在我们想要获得列表中出现的‘Micheal’的索引号。默认情况下，索引值从 0 开始。

源代码:

new_list = ['George', 'Micheal', 'Micheal', 'John', 'Micheal', 'Potter'] 

emp_lis = [] 
for m in range(0, len(new_list)) : 
    if new_list[m] == 'Micheal' : 
        emp_lis.append(m)
print("Index no of 'Micheal':", emp_lis)

你可以参考下面的截图

Python find the index of an item in a list containing a string

阅读:如何在 Python 中反转一个列表

Python 通过值获取列表中元素的索引

在本期节目中，我们将讨论如何在 Python 中通过值获取列表中元素的索引。
通过使用 list.index() 方法，我们可以很容易地从 list 中获得元素索引值。在这个例子中，我们定义了一个整数值列表，使用 list.index() 方法，我们可以得到值为‘210’的项目的索引。

举例:

new_lis = [28, 190, 210, 567, 912, 678]

new_val = 210
result = new_lis.index(new_val)
print(result)

在上面的代码中，我们创建了一个列表‘new _ lis’，然后初始化一个变量‘new _ val’，我们必须在其中赋值‘210’。现在，为了找到 210 的索引号，我们必须使用方法。

下面是以下给定代码的实现

Python get an index of an element in the list by value

另外，请阅读:获取 Python 字典中的第一个键

Python 无例外地找到列表中项目的索引

在这个程序中，我们将讨论如何在不使用 Python 中的 exception 的情况下获得列表中元素的索引。
为了执行这个任务，我们可以应用 Python enumerate() 方法，这个函数可以用来返回列表中所有元素的索引号。
在 Python 中，枚举器基本上允许我们遍历序列中的条目，这个函数接受一个 iterable 作为参数，比如 lists。

源代码:

my_new_lis = [56,92,17,39,115,189,459,512] 

new_output = [i for i, j in enumerate(my_new_lis) if j == 115] 
print("Element is present at index:",new_output)

你可以参考下面的截图

Python find an index of the item in a list without exception

正如您在截图中看到的，该元素出现在第 4 个位置。

在列表中无一例外地找到项目的索引

在这个例子中，我们希望找到一个元素的索引，如果它存在的话，否则它将是 Python 中的默认值。
如果值不包含在列表中，它将返回 2 。在本例中，未找到‘420’值，将抛出一个值错误。

举例:

new_element = [27,39,128,739,367,734]

try:
    new_val = new_element.index(420)
except ValueError:
    new_val = 2

print(new_val)

下面是以下代码的截图

Python find an index of the item in a list without exception

这就是你如何无一例外地找到列表中元素的索引。

阅读: Python 字典增量值

Python 查找列表中项目的索引，不区分大小写

在这一节中，我们将讨论如何使用 Python 在不区分大小写的列表中找到条目的索引。
在这个程序中，您将使用 Python lower() 方法将列表中的元素转换为小写，这个函数将所有大写字符转换为小写字符。
这个方法不接受任何参数，总是返回小写字符串。在这个例子中，我们想要得到的’字符的索引号。 new_list 中的 index() 方法有小写元素的'。

举例:

Search_ele = 's'

my_new_lis1 =  ['M', 'Q', 'S', 'T', 'Z', 'H', 'W', 'A']
new_result = [item.lower() for item in my_new_lis1]
b = new_result.index(Search_ele.lower())
print(b)

下面是以下给定代码的执行过程

Python find an index of the item in list case insensitive

正如你在截图中看到的，第二个位置有“s”。

阅读: Python 列表字典

Python 在迭代时获取列表中项目的索引

让我们看看如何在使用 Python 进行迭代时获得列表中的项目索引。
通过使用 Python range() 函数，我们可以轻松地遍历 Python 列表的索引。在 Python 中，这个方法将返回一个从 0 开始的元素序列。

源代码:

new_lis = ['Micheal', 'John', 'Micheal']

for m in range(len(new_lis)):
    print((m, new_lis[m]))

下面是以下给定代码的实现

Python get the index of an item in a list while iterating

在迭代时获取列表中某项的索引

通过使用 enumerator() 方法，我们可以解决这个特定的任务，这个方法将帮助用户通过一个序列迭代项目，这个函数接受一个 iterable 作为参数，如列表。

举例:

list_value = [46, 81, 72, 39, 38, 1, 89,987,705,409]

for x, y in enumerate(list_value): 
    print(list((x, y)))

你可以参考下面的截图

Python get the index of an item in a list while iterating

阅读: Python 字典扩展

Python 获取列表中项目的索引，默认为

在这个程序中，我们将讨论如何通过使用 Python 来获取带有默认值的列表中项目的索引。
在给定的情况下，我们已经将默认值设置为 0 用于开始索引值。通过使用 range 和 len() 函数的组合，我们可以很容易地得到每个元素的索引值。

源代码:

my_new_val = [78,39,117,84,47,290]

for z in range(0,len(my_new_val)):
    print([z])

下面是以下给定代码的输出

Python get the index of an item in a list with default

如果存在，Python 获取列表中元素的索引

在这里，我们可以看到如何使用 Python 获取列表中元素的索引(如果存在的话)。
在这个例子中，我们将结合使用'操作符中的和 index() 方法。在 Python 中，In 运算符将始终检查条件，如果值存在于列表中，则返回 true，否则返回 false。现在我们将使用 index() 方法，它将返回列表中特定项目的索引。

举例:

Student_name = ['Olijah', 'William', 'Chris', 'James', 'Potter']
select_name = 'William'

if select_name in Student_name:
    new_output = Student_name.index(select_name)
    print("Element exist in list:",new_output)
else:
    print("Element does not exist in list:",select_name)

在上面的代码中，我们首先创建了一个列表，并使用一个操作符来检查列表中是否存在条目‘William’，然后使用 index() 方法将获得‘William’的索引号，如果存在的话。

下面是给定代码的执行

Python get an index of the element in a list if exists

正如你在截图中看到的，柠檬排在第一位。

阅读: Python 字符串列表

Python 在列表正则表达式中查找项目的索引

在这一节中，我们将讨论如何通过使用 Python 中的正则表达式来查找列表中项目的索引。
在 Python 中，正则表达式模块用于根据条件匹配字符串，正则表达式通过 re 模块导入。
在这个例子中，我们使用了 re.search() 方法的概念，这个函数将搜索正则表达式模式。它将检查列表中是否存在‘中国’元素。如果存在，它将返回索引号。

源代码:

您可以使用下面的代码片段来执行这个程序

import re

new_lis1 = ['Germany', 'China', 'Switzerland']
new_output = [m for m, item in enumerate(new_lis1) if re.search('China', item)]
print("element index:",new_output)

下面是以下代码的截图

Python find an index of the item in list regex

阅读: Python 字典复制

Python 在列表中找到一个项目的位置

让我们看一下如何使用 Python 在列表中找到一个条目的位置。
在 Python 中，使用 index() 方法查找列表中元素的位置，它将在给定的列表中搜索元素并返回其索引。
在本例中，我们必须找到‘芒果’的索引号，为此我们将使用 list.index() 方法。

举例:

fruit_name = ['Banana', 'Grapes', 'Mangoes', 'Apple']

result = fruit_name.index('Mangoes')
print("Position of element in list:",result)

你可以参考下面的截图

Python find a position of an item in a list

正如您在截图中看到的，该元素出现在第二个位置。

阅读: Python NumPy Random

Python 获取列表中 max 元素的索引

在本程序中，我们将讨论如何得到列表中最大元素的索引。
在 Python 中， max() 方法用于查找给定列表中的最大值，它接受序列作为方法参数。
在这个例子中，我们还使用了 list.index() 方法的概念来从列表中查找特定元素的索引。

来源代号:

list_elements = [89, 117, 734,864]

new_val = max(list_elements)
result = list_elements.index(new_val)
print("Maximum element index:",result)

在上面的代码中，一旦打印出' result' ，输出将显示最大元素的索引号，即 '864' 。

Python get the index of the max element in a list

正如你在截图中看到的，最大元素出现在第三个位置。

阅读: Python 字典多键

Python 查找列表中最小元素的索引

让我们看看如何用 Python 找到列表中最小元素的索引。
通过使用 Python min() 方法，我们可以很容易地获得列表中可用的最小数字，同时我们还使用了 index() 方法来查找列表中特定元素的索引。

举例:

min_list_my = [89, 64, 734,864,1167,23,45]

new_val = min(min_list_my)
result = min_list_my.index(new_val)
print("Smallest element index:",result)

你可以参考下面的截图

Python find an index of the smallest element in a list

正如你在截图中看到的，最小元素出现在第 5 个位置。

在列表 Python 中查找重复元素的索引

在这一节中，我们将讨论如何使用 Python 找到 List 中重复元素的索引。
通过使用列表理解和列表切片方法，我们可以很容易地得到给定列表中重复值的索引号。

源代码:

numbers_list = [83, 71, 83, 45, 83, 21, 11]

new_output = [m for m, new_val in enumerate(numbers_list) if new_val in numbers_list[:m]]
print("Duplicate element index:",new_output)

下面是以下代码的截图

Find an index of duplicate elements in list Python

这就是如何找到重复值的索引号

获取重复值的索引号

通过使用 duplicated 和 where() 方法，我们可以轻松地执行这个特定的任务。在 Python 中， duplicated() 方法检查列表中是否有重复值， np.where() 函数返回重复值的索引。

源代码:

import numpy as np
import pandas as pd

my_list =  [78,489,55,78,92,78]
b=pd.DataFrame(my_list)
new_result = np.where(b.duplicated())
print("Index number of duplicate values:",new_result)

下面是以下给定代码的执行过程

Find an index of duplicate elements in list Python

Python 查找列表中多个元素的索引

这里我们可以看到如何使用 Python 找到给定列表中多个元素的索引。
在这个例子中，我们从一个列表中选择了多个值，并将它们存储到一个新列表中，然后我们应用列表理解方法来获取这些值的索引号。

源代码:

num_lis = [89,145,734,819]

result = {new_ele: m for m, new_ele in enumerate(num_lis)}
search_ele = [734,145]
b = [result.get(new_val) for new_val in search_ele]
print("Multiple index:",b)

在上面的代码中，一旦你将打印‘b’，那么输出将显示‘734’和‘145’的索引号。

你可以参考下面的截图

Python find an index of multiple elements in a list

Python 获取列表 NumPy 中元素的索引

在本期节目中，我们将讨论如何通过使用 Python NumPy 来获取列表中元素的索引。
为了完成这项任务，我们首先创建一个列表，然后使用 np.array()函数将列表转换成一个数组。现在我们要获取列表中可用的‘134’号的索引。

源代码:

import numpy as np

new_numbers = [21,178,567,134,925,120,670] 
new_arr = np.array(new_numbers)
result = np.where(new_arr== 134)[0]
print(result)

下面是以下给定代码的执行过程

Python get an index of an element in list NumPy

正如您在截图中看到的，该元素出现在第三个位置。

Python 在两个列表中找到公共元素的索引

在本节中，我们将讨论如何在 Python 中找到两个列表中公共元素的索引。
首先，我们创建了两个列表，然后初始化一个变量‘result’，我们在其中分配了集合和交集方法。这个方法将帮助我们从列表中获取公共元素。现在使用 list.index() 方法获取这些元素的索引号。

举例:

new_lis1=[87,56,36,77,58]
new_lis2=[56,44,39,12,13]

result = set(new_lis1).intersection(new_lis2)
index_lis1 = [new_lis1.index(m) for m in result]
index_lis2 = [new_lis2.index(m) for m in result]
print(index_lis1,index_lis2)

下面是以下给定代码的输出

Python find an index of common elements in two lists

Python 获取列表理解中项目的索引

让我们看看如何通过使用 Python list comprehension 方法来获得列表中项目的索引。在 Python 中，列表理解方法用于遍历给定列表中的项目，并访问其索引和值。
在本例中，我们将使用 for 循环方法迭代列表索引和元素，它将检查元素是否为【T0’156’的条件，然后返回带有索引号的值。

举例:

int_numbers = [78, 68, 156, 289, 213, 71]

new_output = [z for z in range(len(int_numbers)) if int_numbers[z] == 156]
print(new_output)

下面是以下代码的截图

Python get the index of an item in a list comprehension

这是如何使用 Python list comprehension 方法获得列表中某项的索引。

您可能还会喜欢以下 Python 教程:

在这个 Python 教程中，我们已经学习了如何使用 Python 找到列表中元素的索引。此外，我们已经讨论了这些主题。

Python 查找列表中最接近值的元素的索引
Python 查找列表中元素的索引大于
Python 查找列表列表中元素的索引
Python 使用条件查找列表中元素的索引
Python 查找列表中项目的索引
Python 通过属性查找列表中对象的索引
Python 在包含字符串的列表中查找项目的索引
Python 通过值获取列表中元素的索引
Python 无例外地在列表中查找项目的索引
Python 查找列表中项目的索引，不区分大小写
Python 在迭代时获取列表中项目的索引
Python 使用默认值获取列表中项目的索引
Python 获取列表中元素的索引(如果存在)
Python 在列表正则表达式中查找项目的索引
Python 查找列表中项目的位置
Python 获取列表中最大元素的索引。
Python 查找列表中最小元素的索引
在列表 Python 中查找重复元素的索引
Python 查找列表中多个元素的索引
Python 获取列表 NumPy 中元素的索引
Python 在两个列表中查找公共元素的索引
Python 获取列表理解中项目的索引

Python 在字典中查找最大值

原文：https://pythonguides.com/python-find-max-value-in-a-dictionary/

在本 Python 教程中，我们将讨论 Python 在字典中查找最大值这里我们还将涵盖以下示例:

Python 在列表字典中查找最大值
Python 在字典中找到最高值
Python 在嵌套字典中查找最大值
在没有内置函数的情况下在 Python 字典中查找最大值
如何在字典 Python 中查找最小值和最大值
Python 在字典中查找最大键值

Python 在字典中查找最大值
Python 在列表字典中查找最大值
Python 在字典中找到最高值
Python 在嵌套字典中查找最大值
如何在 Python 字典中找到最小值和最大值
Python 在字典中查找最大键值

Python 在字典中查找最大值

让我们看看如何在 Python 字典中找到最大值。
通过使用 max()和 dict.get() 方法，我们可以很容易地得到字典中最大值的键。
有多种方法可以完成这项任务
- 通过使用 dict.items()
- 通过使用带有λ函数的 max()
- 通过使用 max() 和 dict.values()

例题

让我们举一个例子，检查如何使用 max() 函数在字典中找到最大值

为了从字典中获得最大值，我们可以使用内置的 max() 函数。在这个例子中，我们可以使用 iterable 和 dict 来获得与最大值配对的键。

源代码:

my_new_dict = {"q": 18, "z": 10, "o": 13}

fin_max = max(my_new_dict, key=my_new_dict.get)
print("Maximum value:",fin_max)

下面是以下代码的截图

Python find max value in a dictionary

通过使用 dict.items()方法

如果你想在字典中迭代键值对，那么我们可以使用 dict.items() 方法。这个方法是 Python 中的一个内置函数，它将帮助用户从字典中获取最大值。

举例:

import operator

max_dict = {'Australia':178, 'Germany':213, 'Japan': 867}
new_ma_val = max(max_dict.items(), key=operator.itemgetter(1))[0]
print((new_ma_val))

在上面的代码中，我们先导入操作符模块，然后用花括号 {}创建一个字典。现在声明一个‘new _ ma _ val’变量，并赋值 max()和 key() 函数作为参数。

下面是以下给定代码的输出

Python find max value in a dictionary by using dict

通过使用 max()和 lambda 函数

在这个例子中，我们可以使用 max() 和 lambda 函数的组合来从字典中获取值。

源代码:

Country_dict = {'China':982, 'Egypt':758, 'Malaysia' : 12}

new_val = max(Country_dict, key= lambda x: Country_dict[x])
print("maximum value from dictionary:",new_val)

在上面的代码中，我使用了 th e max() 函数，该函数使用 lambda 表达式返回‘country _ dict’变量的实例。

下面是以下给定代码的执行过程

Python find max value in a dictionary by using max with a lambda function

通过使用 max()和 dict()值

源代码:

name_dict = {"Oliva": 18, "potter": 56, "Harry": 15}

new_val = name_dict.values()
maximum_val = max(new_val)
print("Maximum value from dict:",maximum_val)

下面是以下给定代码的实现

Python find max value in a dictionary by using max and dict

阅读:如何创建一个空的 Python 字典

Python 在列表字典中查找最大值

为了找到列表字典中的最大值，我们可以使用 max() 函数。
为了解决这个问题，首先我们将创建一个字典并分配键值对元素。然后创建一个变量，并使用 max() 函数作为参数。

源代码:

dict_new = {'Micheal': [17,27,81], 'Elijah': [19,61,92]}

new_val = max((max(dict_new[key]) for key in dict_new))
print(new_val)

下面是以下代码的截图

Python find max value in a dictionary of lists

阅读: Python 字典转 CSV

Python 在字典中找到最高值

在 Python 中寻找字典中的最高值，我们可以使用 key.get() 的概念方法。
通过使用内置的 max() 方法。它提供了‘alpha _ dict’变量来从给定的字典中获取最大值并返回具有最大值的关键字，使用了 dict.get() 方法。

举例:

alpha_dict = {"g": 14, "q": 16, "h": 19}

new_value = max(alpha_dict, key=alpha_dict.get)
print("Highest value from dictionary:",new_value)

下面是以下代码的截图

Python find the highest value in the dictionary

阅读: Python 将字典转换为数组

Python 在嵌套字典中查找最大值

为了执行这个特定的任务，我们可以使用 for 循环的概念来迭代每个键，并从嵌套字典中获取最大值。
在这个例子中，内部字典 "variables" 被存储为一个字符串，所以在应用了 max() 函数后，我将得到一个具有两个值的集合，一个是键，另一个是其对应的值，这样你就可以使用元素> count_new。

源代码:

my_dictionary = {'Micheal' : {'i' : 15, 'z' : 14},
			'George' : {'q' : 2, 'y' : 10, 'w' : 3},
			'John' : {'n' : 19}}

new_out = {}
for new_k, new_v in my_dictionary.items():
	count_new = 0
	for element in new_v.values():
		if element > count_new:
			count_new = element
	new_out[new_k] = count_new

print(new_out)

首先在上面的代码中，我们将声明一个嵌套的字典，并在其中分配键值对元素。现在创建一个变量并分配一个空字典。为了检查字典中的最大值，我们声明了一个‘count _ new’变量，并将值设置为 0。如果元素大于 0，它将检查 for 循环中的条件，并将迭代所有值，并将它们存储在一个空字典中。

下面是以下给定代码的输出。

Python find max value in a nested dictionary

阅读:从字典中获取所有值 Python

如何在 Python 字典中找到最小值和最大值

在 Python 中查找字典中的最小值和最大值，我们可以使用内置的 min()和 max() 函数。
在 Python 中, max() 函数用于查找给定字典中的最大值。而在的情况下，min() 函数用于查找字典中的最小值。这些值可以存储字符串或数字。所以在这个例子中，我们把最大值和最小值分开，你会得到两个数字。

举例:

 your_dictionary = {'Australia':1780, 'England':6723, 'Tokyo': 1946}

new_maximum_val = max(your_dictionary.keys(), key=(lambda new_k: your_dictionary[new_k]))
print('Maximum Value: ',your_dictionary[new_maximum_val])
new_minimum_val = min(your_dictionary.keys(), key=(lambda new_k: your_dictionary[new_k]))
print('Minimum Value: ',your_dictionary[new_minimum_val])

在上面的代码中，我用不同的值和键创建了一个字典。现在我们要计算字典的最小值和最大值。为了完成这个任务，我使用了 max() 函数，该函数使用 lambda 表达式返回‘your _ dictionary’变量的实例。而在使用 min() 函数的情况下，您也可以使用 lambda 表达式在 Python 字典中查找最小值。

下面是以下给定代码的执行过程

How to find min and max value in dictionary Python

阅读: Python 元组字典

Python 在字典中查找最大键值

让我们看看如何在 Python 字典中找到 max 键值对。
在 Python 中，字典用于包含键值对。如果您想访问这些值，您可以使用给定的键。在这种方法中，我们将从字典中检查出最大值。

源代码:

dict_cities = {'Uganda': 763, 'France': 830, 'Tokyo': 193, 'Malaysia': 1682}
max_val = list(dict_cities.values())
max_ke = list(dict_cities.keys())
print(max_ke[max_val.index(max(max_val))])

这里‘dict _ cities’是给定的字典，key 保存所有字典键的列表。之后，我们创建一个变量‘max _ val’，并通过使用 dict.values() 方法将一个列表作为参数分配给它们，以保存所有字典值的列表，在最后一行，我们显示最大值的键。

下面是以下代码的截图

Python find max key value in a dictionary

您可能还想阅读以下 Python 字典教程:

在本 Python 教程中，我们讨论了 Python 在字典中查找最大值。此外，我们还介绍了以下示例:

Python 在列表字典中查找最大值
Python 在字典中找到最高值
Python 在嵌套字典中查找最大值
在没有内置函数的情况下在 Python 字典中查找最大值
如何在字典 Python 中查找最小值和最大值
Python 在字典中查找最大键值

Python 在字符串中查找数字

原文：https://pythonguides.com/python-find-number-in-string/

在本 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 中从给定的字符串中找到数字，我们可以很容易地应用 isdigit() 方法。在 Python 中，如果所有数字字符都包含在输入字符串中，并且该函数从字符串中提取数字，则 isdigit() 方法返回 True。如果给定字符串中没有一个字符是数字，那么它将返回 False。

语法:

下面是 str.isdigit()方法的语法

string.isdigit()

注意:这个方法没有任何参数，它总是返回布尔值 true 或 false。

举例:

让我们举一个例子，看看如何在一个字符串中找到一个数字

new_string = "Germany26China47Australia88"

emp_str = ""
for m in new_string:
    if m.isdigit():
        emp_str = emp_str + m
print("Find numbers from string:",emp_str)

在上面的代码中，我们创建了一个字符串，并在其中分配了整数和字母字符。现在我们将使用 string.isdigit() 方法，并且不向它传递任何参数。

作为输出，它只返回输入字符串中包含的整数值。

下面是以下给定代码的执行过程

Python find a number in string

阅读:通过索引从 Python 字符串中删除一个字符

使用 Python 查找字符串中的数字

这里我们可以应用 append() 和 split() 方法在 Python 中查找一个字符串中的数字。

在 Python 中， append() 函数用于将元素添加到列表的末尾。而 split() 函数用于将字符串分解成一个列表。

源代码:

new_str = "Micheal 89 George 94"

emp_lis = []
for z in new_str.split():
   if z.isdigit():
      emp_lis.append(int(z))

print("Find number in string:",emp_lis)

在上面的代码中，我们使用了一个 for 循环来迭代列表中的每个单词。现在使用 str.append()函数并传递带有单词的 int(z)将其转换为整数。

一旦您打印了‘EMP _ lis’，那么输出将只显示一个包含整数值的列表。

下面是以下给定代码的输出

Python find a number in string

阅读: Python 字符串格式化

Python 在字符串正则表达式中查找数字

让我们看看如何使用 Python 中的正则表达式在字符串中找到一个数字。
通过使用正则表达式 '[0-9]+' 和 re.findall()方法。在 Python 中,[0-9]表示查找从 0 到 9 匹配的所有字符，而+符号表示连续数字字符。
在 Python 中， re.findall() 方法用于从左到右匹配字符串中的模式，它将以字符串列表的形式返回。

语法:

下面是 re.findall()方法的语法

re.findall
          (
           pattern,
           string,
           flags=0
          )

举例:

让我们举个例子，检查一下如何在 Python 中使用正则表达式在一个字符串中找到一个数字。

import re

new_string = 'Rose67lilly78Jasmine228Tulip'
new_result = re.findall('[0-9]+', new_string)
print(new_result)

在上面的代码中，我们创建了一个字符串‘new _ string’，其中插入了一些整数和字母字符。一旦您将打印‘new _ result’，那么输出将只显示列表中的整数值。

下面是以下给定代码的实现

Python find a number in string regex

阅读: Python 字符串列表

Python 在字符串中查找值

这里我们可以看到如何在 Python 中找到一个字符串中的值。为了执行这个特定的任务，我们将结合使用 split() 和 str.isdigit() 方法。
在这个例子中，我们通过使用 list comprehension 创建了一个列表，并将方法存储在其中。在 Python 中， str.isdigit() 方法用于检查给定的字符串是否包含数字。

源代码:

fin_str = "Bangladesh 2578 England 8349 France 3900"

new_result= [int(m) for m in fin_str.split() if m.isdigit()]
print("Find value in string:",new_result)

你可以参考下面的截图

Python find value in a string

阅读:从字符串 Python 中删除字符

Python 找到字符串中的第一个数字

在这个程序中，我们将讨论如何使用 Python 在字符串中找到第一个数字。
为了完成这个任务，我们将使用 re.search() 方法，这个函数检查字符串中任何位置的模式，它总是返回模式的第一个匹配，它只接受两个参数。

语法:

下面是 re.search()方法的语法

new_val= re.search(pattern, string)

源代码:

import re

new_string = "12James potter"
new_val= re.search(r"\d", new_string)
if new_val:
    print("Number found at index", new_val.start())
else:
    print("Number not found")

在上面的代码中，我们首先创建了一个字符串‘new _ string’，然后对它应用了 re.search() 方法。

现在我们将使用‘if-else’条件。如果数字包含在一个字符串中，那么它将显示索引号。如果没有，它将显示未找到的号码。

你可以参考下面的截图

Python find the first number in string

阅读:如何在 Python 中创建字符串

Python 找到字符串中的最后一个数字

在这一节中，我们将讨论如何使用 Python 找到字符串中的最后一个数字。
通过使用 re.findall() 方法，我们可以找到字符串中的最后一个数字。为了完成这个任务，我们首先要取一个字符串‘new _ str’，并给它分配整数和字母字符。
现在使用 re.findall() 方法从左到右匹配字符串中的模式。在这个方法中，有两个参数 pattern 和 string。

举例:

import re

new_str ="73 Japan Germany Paris 36"
output=re.findall(r'\d+', new_str)[-1]
print("Last number in string:",output)

new_string = "Elijah Oliva 89" # Another method 
result= re.search(r"\d", new_string)
if result:
    print("Number found at index", result.start())
else:
    print("Number not found")

在上面的代码中，我们还使用了 re.search() 方法来获取索引号，该方法将检查字符串中任何位置的模式。

下面是以下给定代码的执行过程

Python find the last number in the string

阅读: Python 从字符串中移除子串

Python 在字符串中找到十进制数

在本期节目中，我们将讨论如何利用 Python 在字符串中求一个十进制数。
为了完成这个任务，我们使用 regex 模块 're' ，然后创建一个字符串，在其中我们已经指定了十进制值。现在我们将应用 re.findall()方法，它将帮助用户匹配包含小数点数字的字符列表。
一旦您打印了‘new _ output’，那么输出将只显示给定字符串中可用的十进制值。

源代码:

import re

new_val = 'Chris67.6Hayden78.1Hemsworth228.2Hayden'
new_output = re.findall('\d*\.?\d+',new_val)
print(new_output)

下面是以下给定代码的执行过程

Python find a decimal number in a string

阅读: Python 3 string replace()方法

Python 在字符串中找到浮点数

在这一节中，我们将讨论如何使用 Python 在字符串中查找浮点数。
这里你可以更喜欢我们之前的例子，字符串中的十进制数。您可以使用 re.findall() 方法来获取列表中的小数或浮点数。
正如您在上面的屏幕截图中看到的，输出列表只包含十进制值。在 Python 中，浮点数代表十进制值。

Python 找到字符串中最大的数字

这里我们可以看到如何通过使用 Python 找到一个字符串中的最大数字。
在这个例子中我们已经使用了 max() 和 map() 函数的概念来寻找字符串中的最大数。
在 Python 中， map() 函数用于类似 iterable 列表的每个元素，它总是返回一个迭代器 map 对象，而 max() 函数用于查找 iterable 中的最大元素。
在这个程序中，首先，我们有一个导入正则表达式模块，并使用概念 '[0-9]'+ 来查找从 0 到 9 匹配的所有字符。

举例:

import re

new_string = 'George,146,Micheal,23,John,228,Potter'
new_result = re.findall('[0-9]+', new_string)
print("Largest number in string:")
print (max(map(int, new_result)))

你可以参考下面的截图

Python find the largest number in string

正如你在截图中看到的，输出是 228。

阅读: Python 比较字符串

Python 在字符串中找到连续的数字

在这一节中，我们将讨论如何使用 Python 在一个字符串中找到连续的数字。
连续数字是指从最小的数字到最大的数字之间没有空格的连续数字。
这里我们将应用 regex 模块和 re.search() 方法来匹配字符串中的模式。

源代码:

import re

new_string = "Blue2345green98red"
i = 4
new_val = re.search('\d{% s}'% i, new_string)
new_output = (new_val.group(0) if new_val else '')
print("Consecutive number in string:")
print(new_output)

下面是以下给定代码的输出

Python find consecutive numbers in string

阅读: Python 在字符串中查找子串

Python 查找字符串中的字数

让我们看看如何通过使用 Python 在字符串中找到多个单词。
通过使用 str.split() 和 len(iterable) 方法，我们可以很容易地找到一个字符串中的单词数。
在 Python 中， str.split() 方法将字符串拆分成一个列表， len() 方法返回字符串或列表的长度。这个方法只有一个参数，就是一个可迭代对象，这是 Python 中的内置函数，可以用来测量可迭代对象的长度。

源代码:

new_str = "Australia Japan Bangladesh"

new_val = new_str.split()
count_word = len(new_val)
print(count_word)

在上面的代码中，我们首先创建了一个字符串‘new _ str’，并检查一个字符串中有多少个单词。我们将创建一个变量‘new _ val’，并应用函数 str.split() 将字符串分解成一个列表。

现在使用 len() 函数来检查字符串的长度。一旦你打印了‘count _ word’，那么输出将显示一个字符串中的字数‘3’。

下面是以下代码的截图

Python find a number of words in a string

阅读:在 Python 中切片字符串

Python 在字符串中反向查找

在本节中，我们将讨论如何使用 Python 以逆序查找字符串。
在这个例子中，我们创建了一个字符串和一个字符串的任意索引。现在我想用 index 和 str.rfind() 方法找到第二个‘M’的索引。
在这个程序中，我们调用 str.find() 方法，它将帮助用户从索引 18 开始检查。现在在这个函数中，我们将 0 作为参数传递，它将从字符串的开头开始。

源代码:

new_str = "Geroge, M,micheal,John,M"

new_indx = 18
output = new_str.rfind('M', 0, new_indx)
print(output)

下面是以下给定代码的执行过程

Python find in string reverse

正如您在截图中看到的，输出是 8。

阅读:追加到字符串 Python

Python 检查字符串中是否有数字

这里我们可以看到如何使用 Python 来检查数字是否包含在一个字符串中。
为了执行这个特定的任务，我们可以应用方法 str.isdigit() ，这个方法将检查条件，如果所有的整数字符都包含在给定的字符串中，那么它将返回 true，否则它将返回 false。

语法:

下面是 str.isdigit()方法的语法

string.isdigit()

举例:

让我们举个例子来理解 isdigit()方法的工作原理

new_string = '835' #integer value
print(new_string.isdigit())

new_str = 'George'
print(new_str.isdigit())

在上面的程序中，我们创建了一个字符串，并给它赋了一个整数值。现在使用 print 语句并传递 isdigit()方法，它将显示‘true’布尔值。同样，在字符串字母字符的情况下，它将显示‘假’值。

下面是以下给定代码的实现

Python checks if a number in a string

阅读:添加字符串到列表 Python

Python 在字符串中查找键值

在这一节中，我们将讨论如何在 Python 中找到字符串中的键值对。
通过使用 regex 模块，我们可以很容易地完成这项任务，但是首先，我们必须使用 re.compile() 和 dict() 方法从给定的字符串中获取键值对。
在 Python 中， re.compile() 方法用于编译以字符串形式提供的正则表达式模式，而 dict() 方法用于创建字典，该字典必须是无序的。

源代码:

import re

new_val = "China=893 Australia=945"
result = re.compile(r"\b(\w+)=([^=]*)(?=\s\w+=\s*|$)")
new_output = dict(result.findall(new_val))
print(new_output)

在上面的代码中，我们首先创建了一个字符串‘new _ val’，然后包含被转义的等号。

下面是以下代码的截图

Python find key value in a string

另外，查看:如何在 python 中连接字符串

Python 查找字符串中元音的数量

在本期节目中，我们将讨论如何使用 Python 找到字符串中的多个元音。
在本例中，我们将从用户处获取一个字符串，并将其存储在变量‘new _ string’中。现在使用 print 语句并分配 map 函数和 lower()。count() 方法，它将打印字符串中元音的总数。

源代码:

new_string = input("Enter the string: ")

print(*map(new_string.lower().count, "aeiou"))

下面是以下给定代码的输出

Python find a number of vowels in a string

您可能会喜欢以下 Python 教程:

在本教程中，我们已经学习了如何使用 Python 在字符串中查找数字。此外，我们已经讨论了这些主题。

Python 在字符串正则表达式中查找数字
Python 在字符串中查找值
Python 查找字符串中的第一个数字
Python 查找字符串中的最后一个数字
Python 在字符串中查找十进制数
Python 在字符串中查找浮点数
Python 在字符串中找到最大的数字
Python 在字符串中查找连续数字
Python 查找字符串中的字数
字符串反向的 Python 查找
Python 在字符串正则表达式中查找子字符串
Python 检查数字是否在字符串中
Python 在字符串中查找键值
Python 查找字符串中元音的数量

Python 在 string + Examples 中查找子串

原文：https://pythonguides.com/python-find-substring-in-string/

在这个 Python 教程中，我们将讨论关于 Python 在字符串中查找子串的所有内容，并给出几个例子。我们将看到，如何在 Python 中从一个字符串中找到子串。

如何在字符串中查找子串
如何使用 Python string find()方法从字符串中查找子串
在 Python 中检查字符串是否包含子串
如何用 Count()方法计算字符串 python 中的子串
在 Python 中检查字符串中的子字符串是否
Python 使用多个分隔符分割字符串
Python 使用 split()方法将字符串拆分为子字符串
Python string startswith substring
用 Python 从字符串中提取数字
在 python 中检查字符串是否包含单词
如何在 Python 中找到最长的回文子串
在 Python 中查找字符串的最后一个索引
如何检查一个 python 字符串是否包含另一个字符串

Python 在字符串中查找子串
使用 Python string find()方法从字符串中查找子字符串
在 Python 中检查一个字符串是否包含子串
使用 Count()方法对字符串 python 中的子串进行计数
在 Python 中检查字符串中的子串是否
Python 用多个分隔符分割字符串
Python 使用 split()方法将字符串拆分为子字符串
Python 字符串以子字符串开始
Python 从字符串中提取数字
检查一个字符串是否包含 python 中的单词
最长回文子串 python
如何在 Python 中找到字符串的最后一个索引
检查一个 python 字符串是否包含另一个字符串

Python 在字符串中查找子串

让我们看看如何在字符串中找到子串。

在 python 中，我们可以使用 Python 中的字符串切片从一个字符串中找到一个子串。切片从起始位置开始，在结束位置索引处结束。
要子串任何字符串，我们可以使用切片将字符串子串。
它可以将任何字符串作为输入，并将产生一个子字符串作为输出。

举例:

首先，我们需要取一个字符串作为值。在下面的 python 代码中，你可以看到，我把值取为“欢迎使用 Python 指南”。
然后我们需要将字符串值存储在某个变量“value”中。
现在打印 "text" ，它将给出所需的子串。

代码为 Python 字符串的子串

下面展示了 python 子串的代码。

value = 'Welcome to Python Guide'
text = value[18:]
print(text)

这里，

Start- 子串的起始索引，索引中出现的字符称为子串。如果我们不提到开始，那么它被假定为等于 0。在上面的代码中，我以 18 为起点。
end- 称为子串的终止索引。如果没有包含结尾，或者指定的值超过了字符串长度，则默认情况下假定它等于该长度。在上面的代码中，我没有使用 end，所以默认情况下，它将使用 end 值。

写完上面的 Python 代码(string substring)后，你将打印出 "text" ，然后输出将显示为 "Guide" ，因为我们已经从第 18 个索引到最后一个索引，所以我们得到了字符串的最后 5 个字符。

另外，你可以参考下面的截图。

Python find substring in string

这是如何在 Python 中从一个字符串中找到一个子串。

阅读:Python 中的切片字符串+示例

使用 Python string find()方法从字符串中查找子字符串

通过使用 Python find()方法，我们可以在一个字符串中找到指定子字符串值的第一个匹配项。如果 find()方法返回-1，则该值不在字符串中。
为了从字符串中查找任何子字符串值，我们有一个内置的 find()函数，它将查找特定的值。
该函数可以接受任何字符串作为输入，并且可以产生一个整数值作为输出。

举例:

首先，我们需要取一个字符串值。在下面的 python 代码中，你可以看到，我把值取为“Python 很容易”。
然后我们需要在某个变量“a”中存储指定的子串值。
现在打印出 "a" ，它将给出该索引的整数值。

查看 Python 程序，用示例反转字符串。

python 字符串查找的代码()

按照下面的代码，使用 Python string find()方法查找字符串的子字符串。

msg = 'Python is easy'
a = msg.find("easy")
print(a)

写完上面的 Python 代码(字符串查找)后，你将打印出 "a" ，然后输出将显示为 "10" ，因为我们想从字符串中找到简单的。因此，这里索引 10 是作为输出的整数值。另外，你可以参考下面的截图。

Python string find()

这就是如何使用 Python string find()方法从字符串中找到子字符串。

阅读:无法将字符串转换为浮点 Python

在 Python 中检查一个字符串是否包含子串

通过在"操作符中使用，它被用作比较操作符，也是检查一个字符串是否包含 Python** 中的子串的最简单方法。如果字符串包含字符，则该运算符返回 true，否则返回 false。**
为了检查字符串是否存在，我们使用这个操作符，它将返回一个布尔值。
该函数可以将任何字符串值作为输入，并将返回真或假作为输出。

举例:

首先，我们需要取一个字符串值。在下面的 python 代码中，你可以看到，我已经把值取为“你好 John，你好吗”。
然后我们需要将指定的子串值存储在某个变量“store”中。
现在打印“store”，它将返回值 true 或 false。

python 代码检查字符串是否包含子串

下面显示了用于检查字符串是否包含子字符串的 python 代码。

msg = "Hello John, how are you"
store = ('how' in msg)
print(store)

写完上面的 Python 代码来检查(string 包含 substring)，你会打印出【store】然后输出会出现【True】作为【如何】存在于其中。另外，你可以参考下面的截图。

Check if string contains substring

如果字符串不包含指定的值，那么它将返回“false”作为输出。你可以参考下面的截图。

Check if a string contains a substring in Python

上面的代码，我们可以用 Python 中的来检查一个字符串是否包含一个子串。这是一个如何在 python** 中检查一个字符串中是否存在子串的例子。**

阅读:在 Python 中把字符串转换成浮点数

使用 Count()方法对字符串 python 中的子串进行计数

Python 中的 count()方法返回指定子串在列表中出现的次数。
在 Python 中查找给定字符串中指定子字符串的匹配项。我们使用 count()方法返回子串在 Python 中出现的次数。
该函数可以将任何字符串值作为输入，它将返回指定的子字符串值。子字符串在其中出现的次数。

举例:

首先，我们需要取一个字符串值。在下面的 python 代码中，你可以看到，我把值取为“约翰好，但约翰话少”。
然后我们需要将指定的子串值存储在某个变量“store”中。
现在打印“store ”,它将返回出现的子字符串。这是它出现的次数。

python 字符串计数的代码()

下面显示了字符串计数()的 python 代码

msg = "John is good but John talk less"
store = msg.count("John")
print(store)

写完上面的 Python 代码(字符串计数)后，你将打印出【store】，然后输出将出现【2】，因为【约翰】出现了两次。另外，你可以参考下面的截图。

Python string count()

这样，我们可以使用 Python string count()方法来计算一个子串在 string python 中出现的次数。

阅读:追加到一个字符串 Python +示例

在 Python 中检查字符串中的子串是否

让我们检查 Python 中的字符串中的子串。我们可以使用if条件，而运算符中的**用于在 Python 中检查一个字符串中的子串。**

**举例:**

string = ' Welcome to Python '
if "Welcome" in string:
print('yes')
else:
print('No')

在编写了上面的 python 代码(Python 字符串中的子串)之后，你将打印出这些代码，然后输出将显示为 " Yes " ，因为 " Welcome " 出现在字符串中。这里， " 运算符中的 " 如果子串出现在字符串中，则返回 true，否则返回 false。

另外，你可以参考下面的截图。

Python substring in a string

这就是如何在 Python 中检查一个字符串中的子串是否。

阅读: Python 比较字符串

Python 用多个分隔符分割字符串

在 python 中，我们使用 re.split() 方法用多个分隔符来分隔字符串，分隔符用逗号分隔值。

举例:

import re
msg = " I want\n to learn, python as\nit is* easy."
print(re.split('; | , |\n|\*', msg))

写完上面的 python 代码(Python 拆分多个分隔符)，你要打印的那些然后输出会出现 " ['我要'，'要学，Python 为'，'这是'，'容易。'] " 在这里，它将用逗号和空格作为分隔符进行拆分。另外，你可以参考下面的截图。

Python split string with multiple delimiters

这就是如何在 Python 中用多个分隔符拆分字符串。

阅读: Python 程序反转字符串示例

Python 使用 split()方法将字符串拆分为子字符串

让我们看看如何在 Python 中使用 split()方法将一个字符串拆分为 substring。

使用 Python split()方法我们可以将一个字符串分成几部分。这些片段作为列表返回。
为了分割任何字符串，我们有一个内置的 split()，它将把字符串分割成一个列表。
该函数可以将任何字符串作为输入，并且可以生成一个列表作为输出。

举例:

首先，我们需要取一个字符串值。在下面的 python 代码中，你可以看到，我把值取为“欢迎使用 Python 指南”。
然后我们需要将字符串值存储在某个变量“value”中。
现在打印“值”，它将给出列表。

python 字符串 split()的代码

下面代表的是用 python 代码来拆分字符串。

value = 'Welcome to Python Guide'
print(value.split())

写完上面的 Python 代码(字符串拆分)，你将打印出 value.split() ，然后输出将显示为一个列表 '['欢迎'，' to '，' Python '，' Guide']' 。另外，你可以参考下面的截图。

Python split string to substring

这就是如何使用 Python split()方法来拆分字符串。

阅读: Python 字符串格式化示例。

Python 字符串以子字符串开始

让我们看看如何使用 Python 字符串 startswith()方法。

Python startswith()方法返回一个布尔值。如果指定的字符串以前缀开头，startswith()返回 true，否则返回 false。如果我们想得到第一个字符串值，我们可以使用这个方法。
为了从字符串中获取第一个值，使用了内置的 startswith()方法。
该函数可以将任何字符串值作为输入，如果指定的子字符串匹配，它将返回 true 值。

举例:

首先，我们需要取一个字符串值。在下面的 python 代码中，你可以看到，我已经把值取为“Hi John”。
然后我们需要将指定的子串值存储在某个变量“store”中。
现在打印“store”，它将返回字符串值作为“True”。

Python 字符串 startswith()代码:

下面显示了字符串 startswith()的 python 代码

msg = "Hi John"
store = msg.startswith('Hi')
print(store)

写完上面的 Python 代码(string startswith)，你将打印出 "store" ，然后输出将显示为 "True" ，如果指定的条件为真，则输出为假。另外，你可以参考下面的截图。

Python string startswith()

如果子字符串不是以指定的值开始，那么它将返回“false”作为输出。你可以参考下面的截图。

Python string startswith()

下面是一个以子串开始的 Python 字符串的例子。

阅读 Python 字典扩展

Python 从字符串中提取数字

通过使用 python 中的 split 函数将字符串转换为列表，可以从字符串中提取数字。然后列表理解帮助我们遍历列表，是数字函数帮助我们从字符串中取出数字。

举例:

my_string = "Welcome 2 python 5"
number = [int(w) for w in my_string.split() if w.isdigit()]
print(number)

写完上面的代码(python 从字符串中提取数字)，你将打印出 "number" ，然后输出将显示为 " [2 5]"。这里，我们将使用 isdigit() 方法从字符串中获取数字。

你可以参考下面的截图 python 从字符串中提取数字。

Python extract number from string

上面的 Python 代码我们可以用来从 Python 中的字符串提取数字。

检查一个字符串是否包含 python 中的单词

检查字符串是否包含单词最简单的方法是 Python 中“操作符中的”。如果字符串包含单词，该运算符返回 true，否则返回 false。

举例:

my_str = "Rahul is good player"
check = "good" in my_str
print(check)

写完上面的代码(在 python 中检查一个字符串是否包含 word)，你将打印出“check”，然后输出将显示为“真”。这里，我们将在操作符中使用来检查一个字符串是否包含该单词。

你可以参考下面的截图检查一个字符串是否包含 python 中的单词

Check if a string contains word in python

上面的 Python 代码，我们可以用来检查一个字符串是否包含 python 中的一个单词。

最长回文子串 python

为了得到最长的回文子串，我们将检查每个子串是否是回文。

我们将遍历字符串，将每个字符视为回文的中间部分，并尝试通过比较左边的字符和右边的字符来构建回文。

举例:

class find(object):
   def longestPalindrome(self, x):
      v = [[False for i in range(len(x))] for i in range(len(x))]
      for i in range(len(x)):
         v[i][i] = True
      max_length = 1
      start = 0
      for l in range(2,len(x)+1):
         for i in range(len(x)-l+1):
            end = i+l
            if l==2:
               if x[i] == x[end-1]:
                  v[i][end-1]=True
                  max_length = l
                  start = i
            else:
               if x[i] == x[end-1] and v[i+1][end-2]:
                  v[i][end-1]=True
                  max_length = l
                  start = i
      return x[start:start+max_length]
obj1 = find()
print(obj1.longestPalindrome("ZABBABBACD"))

写完上面的代码(最长的回文子串 python)，你将打印出" obj 1 . longestpalindrome(" zabbabacd ")"，然后输出将显示为 " ABBABBA "。这里，我们得到最长的回文子串。

可以参考下面截图最长的回文子串 python

Longest palindromic substring python

这就是如何找到最长的回文子串 python 。

如何在 Python 中找到字符串的最后一个索引

让我们看看如何在 python 中找到一个字符串的最后一个索引。

在 python 中， rindex() 方法用于查找字符串的最后一个索引。

举例:

my_str = "Hello, how are you"
f = my_str.rindex("u")
print(f)

写完上面的代码(一个字符串 python 的最后一个索引)，你将打印出 "f" ，然后输出将显示为 " 17 "。在这里， rindex() 方法返回指定值的最后一个索引，如果没有这样的索引存在，则引发异常。

可以参考下面截图一个字符串 python 的最后一个索引。

How to find last index of a string in Python

上面的 Python 代码，我们可以用来查找 Python 中一个字符串的最后一个索引。

另外，检查:如何在 Python 中从列表中获取字符串值

检查一个 python 字符串是否包含另一个字符串

在其他面向对象语言中，我们可以使用 contains 方法来检查一个 python 字符串是否包含另一个字符串。

在 python 中，有一些方法可以检查一个 python 字符串是否包含另一个字符串。

1-使用中运算符

我们可以在操作符中使用来检查一个 python 字符串是否包含另一个字符串。

在操作符中使用是检查字符串是否包含另一个字符串的一种简单明了的方法。

让我们来看一个例子

示例:

mystring = "I love Python"

print("Python" in mystring)
print("Java" in mystring)

在这里查看输出

check if a python string contains another string

在上面的例子中，我们看到由于“Python”存在于字符串中，所以它返回 True，由于“Java”不存在于字符串中，所以它返回 False。

2- 使用 find()方法

检查一个 python 字符串是否包含另一个字符串的另一种方法是使用 find() 。这是 python 内置的方法。

find() 方法返回第一次出现的指定值。

如果没有找到该值，则返回 -1 。

句法

string.find(value, start, end)

其中开始和结束参数是可选的。

让我们来看一个例子

例子

mystring = "I love Python"
x = mystring.find("Python")
print(x)

现在看看这里的输出

How to check if a python string contains another string

例子

x = mystring.find("Python")
y = mystring.find("java")
print(x)
print(y)

输出将是 7 和-1。–1，因为 java 不在字符串中。

check if a python string contains another string

示例:

mystring = "I love Python very much"
x = mystring.find("o",2,8)

print(x)

在这里查看输出

check if a python string contains another string

`3-` 利用指数()方法

我们可以使用 index() 方法在字符串内部找到一个字符串第一次出现的起始索引。

如果指定的字符串不在字符串中，那么它将抛出一个异常。

让我们看一个同样的例子

句法

string.index(value, start, end)

其中开始和结束是可选的。

示例:

mystring = "I love Python very much"
x = mystring.index("Python")

print(x)

看到这里的输出了吗

index() method in python

示例:

mystring = "I love Python very much"
x = mystring.index("o",2,8)

print(x)

index() method in Python

这就是如何检查一个 python 字符串是否包含另一个字符串。

您可能会喜欢以下 Python 示例:

在本 Python 教程中，我们学习了， Python 在字符串中查找子串以及下面的例子:

如何在字符串中查找子串
使用 Python string find()方法从字符串中查找子字符串
在 Python 中检查字符串是否包含子串
使用 Count()方法计算字符串 python 中的子字符串
在 Python 中检查字符串中的子字符串是否
Python 使用多个分隔符分割字符串
Python 使用 split()方法将字符串拆分为子字符串
Python string startswith substring
用 Python 从字符串中提取数字
在 python 中检查字符串是否包含单词
如何在 Python 中找到最长的回文子串
如何在 Python 中找到字符串的最后一个索引
如何检查一个 python 字符串是否包含另一个字符串

enjoysharepoint.com/****

Python for 循环索引+示例

原文：https://pythonguides.com/python-for-loop-index/

在本 Python 教程中，我们将讨论 Python for loop index。这里我们还将涵盖下面的例子:

Python for 循环索引范围
Python for 循环索引和值
Python for 循环索引从 1 开始
Python for 循环索引从 0 开始
Python for 循环索引增量
Python for 循环索引减量
Python for 循环索引超出范围
Python for 循环向后索引
Python for 循环索引字典
Python for 循环索引范围从 1 开始
Python for 循环遍历数据帧索引

Python for 循环索引
Python for 循环索引范围
Python for 循环索引和值
Python for 循环索引从 1 开始
Python for 循环索引从 0 开始
Python for 循环索引增量
Python 为循环索引减量
Python for 循环索引超出范围
- 解决方案:
Python for 循环索引向后
- 通过使用 reversed()函数
- 通过使用 range()函数
Python for 循环索引字典
Python for 循环索引范围从 1 开始
Python for 循环遍历数据帧索引

Python for 循环索引

让我们看看如何在 Python 中检查 for 循环的索引。
要检查 for 循环中的索引，可以使用 enumerate() 函数。在 Python 中，enumerate()是一个内置函数，它允许我们遍历一个列表，并在 for 循环的迭代过程中计算元素的数量。
在 Python 中有各种方法来检查如何检查 for 循环中的索引。
- 使用 range()函数
- 使用 zip()函数
- 使用 map()函数

例子:

让我们举个例子，用 enumerate()函数检查 for 循环中的索引。

源代码:

new_lis = [2, 8, 1, 4, 6]

for x, new_val in enumerate(new_lis):
	print (x, ",",new_val)

下面是以下给定代码的执行过程

Python for loop index

通过使用 range()函数

这是另一个迭代列表范围的例子，可以通过组合 range() 和 len() 函数来执行。这个函数总是返回一个具有数字范围的可迭代序列。

下面是源代码:

my_lis = [6, 1, 9, 2]

for new_indic in range(len(my_lis)):
   print(new_indic, my_lis[new_indic])

下面是以下代码的截图

Python for loop index range function

阅读 Python 数字猜谜游戏

通过使用 zip 功能

要完成这项任务，我们可以很容易地使用 Python 中的函数 zip()。这个方法总是返回一个元组迭代器，其中作为参数传递的所有值都成对包含。

举例:

new_str = ['e', 'f', 'i']

for m in zip(range(len(new_str)), new_str):
        print(m)

实施:

Python for loop index zip function

通过使用 map()函数

为了执行这个任务，我们可以很容易地使用 Python 中的 map() 函数。这是 Python 中的一个内置函数，用于将一个函数应用于序列中的所有元素。

举例:

new_str2 = ['Germany', 'England', 'France']

new_out = map(lambda o: (o, new_str2[o]), range(len(new_str2))) #map function
print(list(new_out))

下面是以下给定代码的执行过程

Python for loop index map function

这就是如何检查 python 的循环索引

读: For 循环 vs Python 中的 while 循环

Python for 循环索引范围

range 函数根据给定的第一个和最后一个索引给出一个整数序列。在本例中，第一个索引没有给出。默认情况下，索引值设置为 0。

语法:

for index in range(n):
    statement

在此语法中,“n”参数是循环终止语句的次数。

举例:

for index in range(2,8):
    print("loop index range",index)

在上面的代码中，我们必须将 for 循环与 range 函数一起使用，并显示从 2 到 7 的 6 个数字。

Python for loop index range

阅读: Python For 循环

Python for 循环索引和值

让我们看看如何在 For 循环中访问元素的索引。
在 Python 中，我们可以在每次迭代时将 iterable 对象中的下一项分配给循环。

举例:

new_val = ["i", "m", "k"]
new_index = 0

for value in new_val:
   print(new_index, value)
   new_index += 1

在上面的代码中，索引是一个整数，循环的每次迭代都打印索引和值。首先在这个例子中，我们将声明一个变量来存储索引，并在每次迭代中更新它。

下面是以下给定代码的输出

Python for loop index and value

阅读: Python while 循环继续

Python for 循环索引从 1 开始

在 Python 中为了在索引 1 处开始一个 for 循环，我们可以很容易地跳过第一个索引 0。
通过使用切片方法【start:】我们可以轻松地执行这个特定的任务。在本例中，我们必须将索引值设为 1，并将‘start’设为所需的索引。
通过使用这个操作符，我们可以指定在哪里开始切片，在哪里停止，并指定步骤。

举例:

my_new_lis = ["Alena", "Joseph", "Mathew"]

for indx in my_new_lis[1:] :
      print(indx)

在上面的代码中，您可以看到我们已经创建了一个列表，并从索引“1”开始通过‘my _ new _ lis’对其进行迭代。

下面是以下给定代码的执行过程

Python for loop index starts at 1

检查如何访问索引 1 处循环的另一个示例

如果我们想访问列表的值和索引，那么我们可以使用 Python 内置函数 enumerate()。此方法将索引值添加到 iterable 项中，并将它们组合作为枚举器对象返回。
现在让我们举一个例子，检查如何使用这种方法。

源代码:

new_list = ["e","u","o","p","g"]
print("Values in list with index:") 
for new_indices, new_val in enumerate(new_list, start=1): 
    print(list((new_indices, new_val)))

首先在上面的代码中，我们将创建一个枚举器对象，并通过使用“new_list”作为参数将该对象转换为一个列表，并将输出显示到每个单独的列表中。在本例中，我们必须将‘start’关键字设置为参数，并将索引值从 0 更改为 1。

该源代码将产生以下输出:

Python for loop index starts at 1

阅读:Python 中的索引和切片

Python for 循环索引从 0 开始

在 Python 中，默认情况下，范围从 0 开始，到传递的参数值-1 结束。
在这个例子中，我们不遍历列表中的条目。我们将使用索引从 len(new_lis) 函数中迭代条目，然后我们使用这个索引变量来检查 0 序列中的列表编号..其中 n 是列表的最后一个数字。

源代码:

new_lis = ["j","l","q","u","e","t"]

print("index start at:")

for new_indx in range(len(new_lis)):
    print(new_indx, new_lis[new_indx], end = "\n")

下面是以下代码的截图

Python for loop index start at 0

检查如何访问索引为 0 的循环的另一个示例

在本例中，首先，我们将指定一个索引值为“0”。现在，循环的每次迭代都打印索引以及列表中的值。

举例:

my_val = [9,2,3,4,7,8]
new_index = 0

for value in my_val:
   print(new_index, value)
   new_index += 1

输出:

Python for loop index start at 0

Python for 循环索引增量

让我们看看如何在 Python 中访问索引增量处的 for 循环。
通过使用 range()函数，我们可以逐步遍历 iterable 中的条目。该功能由三个参数开始、停止和步进组成。此方法将不包括止损值。

源代码:

new_list = [4,8,10,11,12,16,18]

m = 0
for o in range(len(new_list)):

	if(m >= len(new_list)):
		break
	print(new_list[m], end = "\n ")
	m += 3

在上面的代码中，我们将在循环内改变‘m’的值，它将根据给定的条件【T2’‘m+= 3’改变它的值。在这个例子中，我们可以使用 range 函数作为参数。

现在它将检查条件，如果 m 大于 0 (m>0 ),它将使用一个 iterable 项执行循环。

输出:

Python for loop index increment

阅读: Python 字典理解

Python 为循环索引减量

让我们举个例子，看看如何在 Python 中递减 for 循环中的值。
通过使用 range()函数，我们可以执行这项任务。在 Python 中，range 函数包含三个参数 start、stop 和 step，这些参数可以帮助用户访问 for 循环中的减量值。
首先在这个例子中，我们将调整 for 循环中的 start、stop 和 step 索引值，并显示输出。在范围函数中，起始值总是大于停止索引值，因此这些值会自动递减。

下面是源代码:

for r in range(8,0,-2):
    print('Final result:',r)

首先在上面的代码中，我们必须将 range 函数中的所有值放在参数集内，将起始索引值设置为 8，将停止索引值设置为 0。现在将步长值设置为-2，这将使该值递减 2。

下面是以下给定代码的实现

Python for loop index decrement

Python for 循环索引超出范围

在这种情况下，当您忘记在 for 循环中应用 range()函数时，就会出现错误“索引超出范围”。
如果你正在访问列表中的 iterable 项，并且忘记使用 range()函数，那么它将会产生一个错误。

举例:

numbers = [1, 5, 3,7]

for date in numbers:
	print(numbers[date])

首先在上面的代码中，我们将显示“数字”列表中的所有值。该列表包含日期数。现在我们将执行这个程序。

执行:

Python for loop index out of range

解决方案:

为了解决这个问题，我们可以很容易地使用 range()函数来遍历列表‘numbers’中的条目。

源代码:

numbers = [1, 5, 3,7]

for date in range(0, len(numbers)):
	print(numbers[date])

在上面的代码中，range()函数创建了一个给定范围内的数字列表。在这个例子中，范围是【1，5，3，7】。

输出:

Solution for loop index out of range in Python

阅读:如何处理索引错误

Python for 循环索引向后

让我们看看如何在 Python 的 for 循环中获得逆序元素。
有各种方法来执行这个任务。
- 通过使用 reversed()函数。
- 通过使用 range()函数

例子:

通过使用 reversed()函数

要执行向后迭代，我们可以很容易地使用 reversed()函数。这种方法只是选择元素并以相反的顺序显示它们。

举例:

for m in reversed(range(2, 8)):
        print(m)

下面是以下代码的截图

Python for loop index backward

通过使用 range()函数

为了在 for 循环中向后迭代，我们可以使用 range()函数，将 step 参数设为-1。

源代码:

my_lis = ['Australia', 'Germany', 'Indonesia', 'Spain']
for m in range( len(my_lis) - 1, -1, -1) :
   print(my_lis[m])

实施:

Python for loop index backward range function

阅读: Python 字典按值查找键

Python for 循环索引字典

要通过索引遍历 Python 字典的所有键值对，我们可以使用 items()函数，它返回一个可迭代序列。

源代码:

my_dic = {"a":20,"n":91,"u":87,"t":41}

for new_indx, (new_k, new_val) in enumerate(my_dic.items()):
    print('Index value: ', new_indx, ' :: ', new_k, ':', new_val)

下面是以下给定代码的实现

Python for loop index dictionary

Python for 循环索引范围从 1 开始

这里我们可以看到如何在 Python 中从索引 1 开始一个 for 循环。要解决这个问题，我们可以使用 range()函数。

语法:

range(start, stop,[step])

注:根据参数中给定的条件产生一个整数序列。

举例:

for m in range(1,6):
    print(m, end='\n ')

下面是以下给定代码的执行过程

Python for loop index range starts at 1

Python for 循环遍历数据帧索引

在 Python for dataframe 中，我们可以使用 for 语句来迭代项目。通过使用数据帧的索引属性，我们可以解决这个问题。

代码:

import pandas as pd

student_info = {'stud_name': ['George', 'Potter', 'Adam', 'Gilchrist'],
                'stud_age': [28, 25, 18, 15],
                'stud_str': ['Python', 'Java', 'Sql', 'Mongodb'],
                'stud_id': [192,76,23, 68]}

df1 = pd.DataFrame(student_info, columns = ['stud_name', 'stud_age', 'stud_str', 'stud_id'])

print("Given Dataframe :\n", df1)

print("\nIterate rows by index :\n")

for indices in df1.index:
     print(df1['stud_name'][indices], df1['stud_str'][indices])

下面是以下代码的截图

Python for loop through dataframe index

这就是如何通过 dataframe 检查 python for 循环。

您可能还会喜欢以下 Python 教程:

在本 Python 教程中，我们将讨论 Python for loop index。在这里，我们还将介绍以下示例:

Python for 循环索引范围
Python for 循环索引和值
Python for 循环索引从 1 开始
Python for 循环索引从 0 开始
Python for 循环索引增量
Python for 循环索引减量
Python for 循环索引超出范围
Python for 循环向后索引
Python for 循环索引字典
Python for 循环索引范围从 1 开始
Python for 循环遍历数据帧索引

Python For 循环示例

原文：https://pythonguides.com/python-for-loop/

在这个 Python 教程中，我们将检查 Python for 循环，我们将通过例子看到如何在 python 中使用 for 循环。

此外，我们还将讨论:

python 中的 For 循环
python 中的字符串循环
Python range()函数
python 中的嵌套循环
否则在 for 循环中
Python for 循环向后

python 中的 For 循环
在 python 中循环一个字符串
Python range()函数
Python 中的嵌套循环
Python 中的 Else in for 循环
Python for loop backward

python 中的 For 循环

Python 中的 For 循环用于迭代任意序列的项，如链表、字符串、元组等。

举例:

chocolate = ['Dairy Milk', 'Kit Kat', 'perk']
for a in chocolate:
print(a)

写完上面的代码(对于 python 中的循环)，你将打印出 " a " ，然后输出将显示为 "Dairy Milk Kit Kat perk" 。

这里，循环为列表中的每个项目执行一组语句。python 中的循环可以参考截图。

For Loop in python

这是 python 中的一个 For 循环示例。

你可能喜欢看，如何在 Python 中使用 Pandas drop()函数。

在 python 中循环一个字符串

在 python 中，我们可以通过使用循环中的和 python 中的 In 操作符来迭代字符串的一个单词。

举例:

my_string = "Python"
for a in my_string:
print(a)

写完上面的代码(在 python 中循环遍历一个字符串)，你将打印出 " a " ，然后输出将显示为 " P y t h o n " 。

这里，循环遍历字符串“Python”中的所有字符。你可以参考下面的 python 中字符串的截图循环。

Loop over a string in python

Python range()函数

在 python 中，为了循环通过代码，我们使用 Python 中的 range()函数，默认情况下，它返回从 0 开始的数字序列，并在指定的数字处结束。

举例:

for value in range(4):
print(value)

写完上面的代码(python range()函数)，你将打印出 " value " ，然后输出将显示为 " 0 1 2 3 " 。

在这里，我们使用 range()函数来处理数字序列，并使用 for 循环来遍历数字。可以参考截图 python range()函数

Python range() function

以上以 Python range()函数为例。

Python 中的嵌套循环

在 python 中，嵌套循环是循环内部的一个循环，它用于重复外部循环中项目的某些动作。

举例:

numbers = ["5", "8", "10"]
colors = ["red", "blue", "black"]
for a in numbers:
for z in colors:
print(a,z)

写完上面的代码(python 中的嵌套循环)，你将打印出 " a，z " ，然后输出将会出现。

这里，内循环将为外循环的每次迭代执行一次。可以参考下面的截图 python 中的嵌套循环。

Nested loops in python

这是一个例子，Python 中的嵌套循环。

Python 中的 Else in for 循环

在 python 中，for 循环中的 else 用于指定循环结束时的代码块。迭代完成后，Else 块出现在循环体之后。

举例:

for value in range(5):
print(value)
else:
print("Loop Ends")

写完上面的代码(否则在 for 循环中)，你将打印出 " value " ，然后输出将出现 " 0 1 2 3 4 循环结束"。

这里，else 块将在所有迭代完成后执行，程序仅在 else 块之后退出循环。你可以在 for 循环中参考下面的截图。

Else in for loop

这是 Python 中 for 循环中关于 Else 的一个例子。

Python for loop backward

向后 for 循环向后遍历一个序列，我们将使用 reversed() 函数向后遍历一个序列。

举例:

for val in reversed(range(5))
    print(val)

写完上面的代码(python 用于循环返回)，你将打印出 " val " ，然后输出将出现 " 4 3 2 1 0 "。在这里，我们将使用 reversed(sequence) 以相反的顺序打印它们。

你可以参考下面的 python 的截图来进行向后循环

Python for loop backward

这样，我们就可以在 python 中使用进行循环。

您可能会喜欢以下 Python 教程:

Python 方块一号
什么是 Python 字典
无换行符的 Python 打印
Python 字典方法+示例
11 Python 列表方法
如何在 Python 中创建列表
使用 Visual Studio 代码用 python 创建一个 hello world 程序
Python 输入和 raw_input 函数
Python 从列表中选择+示例
Python 通过引用或值传递示例

在本教程中，我们通过示例学习了如何在 python 中使用进行循环，我们还讨论了:

python 中的 For 循环
python 中的字符串循环
Python range()函数
python 中的嵌套循环
否则在 for 循环中
Python for 循环向后

带逗号的 Python 格式数字

原文：https://pythonguides.com/python-format-number-with-commas/

在本 Python 教程中，我们将讨论带逗号的 python 格式数字。此外，我们将看到以下主题:

带逗号的 Python 格式数字
Python 在元素之间添加逗号
Python 格式的数字带有逗号，四舍五入到小数点后两位

Python 格式数字加逗号
Python 在元素之间添加逗号
Python 格式数字加逗号并四舍五入到 2 位小数

Python 格式数字加逗号

让我们看看如何在 python 中用逗号来格式化数字。

在 Python 中，要用逗号格式化一个数字，我们将使用“{:，}”和 format()函数，它将从左开始每隔一千个位置添加一个逗号。

举例:

numbers = "{:,}".format(5000000)
print(numbers)

写完上面的代码(python 格式的数字加逗号)，你将打印出“数字”，然后输出将显示为“5，000，000”。这里， {:，}。format() 会在数字后每千位加逗号。这样，我们就可以用逗号来格式化数字。

可以参考下面的截图，为 python 格式的数字加逗号。

Python format number with commas

Python 在元素之间添加逗号

让我们看看如何在 Python 中的元素之间添加逗号。

我们将使用****“{:，}”。format()** 函数，它将在从左开始的每一千个位置之后的元素之间添加一个逗号**

**举例:

def my_value(number):
    return ("{:,}".format(number))
print(my_value(100000000)

写完上面的代码(python 在元素之间加了一个逗号)，一旦打印出 "my_value(100000000)" ，那么输出将显示为 " 100，000，000" 。这里， {:，}。【格式(数字)】T5 会在元素之间添加逗号。

你可以参考下面的 python 元素间添加逗号的截图。

Python add a comma between elements

Python 格式数字加逗号并四舍五入到 2 位小数

现在，让我们看看下面的例子，关于 python 格式的数字，带逗号，四舍五入到 2 位小数。

我们会用“{:，. 2f}”。format()" 为浮点数格式，以逗号作为千位分隔符。小数点后两位以上的数字将被忽略。

举例:

my_num = 235478.875425
s = "{:,.2f}".format(my_num)
print(s)

写完上面的代码(python 格式数字加逗号，四舍五入到小数点后两位)，当你要打印 "s" 那么输出会出现" 235478.88 "。这里，my_num = 235478.875425 是浮点数，我们将使用 {:，. 2f}。format(my_num) 在数字后每千位加逗号，会四舍五入到小数点后两位。

可以参考下面的截图，为 python 格式数字加逗号，四舍五入到小数点后 2 位。

Python format number with commas and round to 2 decimal places

您可能会喜欢以下 Python 教程:

在本 Python 教程中，我们学习了带逗号的 python 格式数字。此外，我们还讨论了以下主题:

带逗号的 Python 格式数字
Python 在元素之间添加逗号
Python 格式的数字带有逗号，四舍五入到小数点后两位

enjoysharepoint.com/**

Python 生成随机数和字符串(完整教程)

原文：https://pythonguides.com/python-generate-random-number/

在本 Python 教程中，让我们就 Python 生成随机数进行讨论，如何在 Python 中生成随机数。此外，我们将讨论如何在 Python 中生成随机字符串。

让我们讨论以下几点:

介于 0 和 1 之间的 Python 随机数
Python 随机数范围内的整数
1 到 10 之间的 Python 随机数
Python 随机数种子
Python 随机数的选择
Python 随机整数 n 的倍数
Python 随机数洗牌
两个浮点数之间的 Python 随机数
n 位数的 Python 随机数
不重复的 Python 随机数
Python 随机 10 位数
Python 长度的随机字符串
来自字母的 Python 随机字符串
Python 字母和数字的随机字符串
带有特殊字符的 Python 随机字符串
来自字母表的 Python 随机字符串

Python 生成随机数
Python 随机 10 位数
Python 随机数使用 sample()
Python 生成随机字符串

Python 生成随机数

让我们看看 Python 中生成随机数的各种方式。我们将讨论在 Python 中生成随机数的不同方法。

在这个例子中，我已经导入了 random 模块， random() 返回随机的浮点值。

示例:

import random
random_number = random.random()
print(random_number)

Python generate random number

这样，我们可以用 Python 创建一个随机数。

你可能会喜欢用蟒蛇龟和绘制彩色填充形状

0 和 1 之间的 Python 随机数

现在我们可以看到如何在 python 中获得 0 到 1 之间的随机数

要获得任意随机数，我们必须首先导入随机模块。 random.uniform() 用于获取一个随机数，uniform()返回两个给定数之间的随机浮点数。

示例:

import random
number = random.uniform(0,1)
print(number)

下面的屏幕截图显示了输出:

Python random number between 0 and 1

Python 随机数范围内的整数

这里我们可以看到如何在 python 中获得一个范围内的随机数整数，

在这个例子中，我们可以看到如何在给定范围的情况下得到一个随机数，这里我使用了 randint() 方法，它从给定的范围返回一个整数。

示例:

import random  
random_number = random.randint(0, 9) 
print(random_number)

下面的屏幕截图显示了输出:

Python random number integers in the range

1 到 10 之间的 Python 随机数

这里我们可以看到如何在 python 中获得 1 到 10 之间的随机数

在这个例子中，我使用了 randint() ，它在指定范围时返回一个随机数。

示例:

import random
print(random.randint(1,10))

下面的屏幕截图显示了输出:

Python random numbers between 1 and 10

Python 随机数种子

我们可以使用 Python 种子函数在 Python 中初始化一个随机数。默认情况下，它将使用系统的当前时间创建一个随机数。

要得到自定义随机数生成器的起始数，我们可以使用 seed() 函数

这里我们可以看到如何使用 python 中的 seed()函数生成随机数。

示例:

import random

random.seed(15)
print(random.random())

下面的屏幕截图显示了输出:

Python random number seed

Python 随机数的选择

在这里，我们可以看到如何从 python 中指定的列表或字符串序列中获得一个随机数

在这个例子中，使用了 random.choice() ，它从指定的 Python 列表中返回一个随机数。

示例:

import random

numberList = [1,22,58,14,25,24,]
print( random.choice(numberList))

下面的屏幕截图显示了输出:

Python random number of choice

Python 随机整数 n 的倍数

现在我们可以看到如何在 Python 中获得 n 的随机整数倍。

这里我们可以生成一个随机数，它是 4 的倍数，范围从 4 到 200。

示例:

import random

num = random.randrange(4, 200, 4)
print(num)

下面的屏幕截图显示了输出:

Python random integer number multiple of n

Python 随机数洗牌

在这里我们可以看到如何在 python 中使用 shuffle() 获得一个随机数。

在这个例子中，一些数字被分配给一个列表号码，并且使用 random.shuffle() 从列表中获得随机的洗牌号码。

shuffle() 方法取列表中的一个数字序列，随机重组列表中数字的顺序。

示例:

import random

number = ["1","5","2","3"]
random.shuffle(number)

print(number)

下面的屏幕截图显示了输出:

Python random number shuffle

Python 两个浮点数之间的随机数

现在我们可以看到如何在 python 中获得两个浮点数之间的随机数

在这个例子中，我们要导入一个随机模块，用 random.uniform() 函数得到一个随机数。

uniform()返回两个给定浮点数之间的随机浮点数。

示例:

import random
x = random.uniform(0.5, 1.5)
print(x)

下面的屏幕截图显示了输出:

python random number between two floats

n 位数 Python 随机数

现在我们可以看到如何在 python 中得到一个 n 位数的随机数。

为了得到一个 n 位数的随机数，random.radint() 被用来返回两个给定位数长度的随机数。随机数的长度将等于两个给定数字的长度。

示例:

import random
random_number = random.randint(1000, 2000)
print(random_number)

下面的屏幕截图显示了输出:

python random number with n digits

Python 无重复随机数

在这里我们可以看到如何在 python 中不重复的情况下获得一个随机数列表。

在这个例子中，我使用了 Python random.sample() 函数，该函数在给定的数字范围内生成唯一的随机数。

示例:

import random
list = random.sample(range(0, 10), 10)
print(list)

下面的屏幕截图显示了输出:

Python random number without repeating

这就是我们如何使用 random.sample() 在 Python 中生成随机数。

Python 随机 10 位数

这里我们可以看到如何用 Python 生成一个随机的 10 位数。为了得到指定长度的随机数，我们应该设置最大值和最小值。

在这个例子中，我已经导入了一个模块 random，为了得到一个随机数，我们应该生成 N 并指定 minimum–minimum = pow(10，N-1) 和 maximum–maximum = pow(10，N)–1，然后返回一个长度如参数中给出的随机数。

示例:

import random

def randomnumber(N):
	minimum = pow(10, N-1)
	maximum = pow(10, N) - 1
	return random.randint(minimum, maximum)

print(randomnumber(10))

下面的屏幕截图显示了输出:

Python random 10 digit number

这就是我们如何在 Python 中非常容易地生成一个随机的 10 位数。

Python 随机数使用 sample()

现在我们可以看到如何使用 sample()生成随机数。

在这个例子中，我从 random 中导入了 random 模块和 sample 模块，我将一个列表作为数字，print()包含一个 sample() ，一个列表，以及列表的大小。sample()从指定列表中返回随机列表。

示例:

from random import sample 
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]  
print(sample(numbers,5))

下面的屏幕截图显示了输出:

Python random number using sample()

Python 生成随机字符串

现在，让我们看看如何在 Python 中生成随机字符串。

在这个例子中，我导入了两个模块，它们是 random 和 string，并得到一个随机的字符串

调用字符串。ascii 初始化得到一个常量字符串，string.ascii_uppercase 只给出大写字母。choice()返回从任意序列中随机选择的元素。

示例:

import random
import string
letters = string.ascii_uppercase
print ( ''.join(random.choice(letters)))

下面的屏幕截图显示了输出:

Python Random String

Python 随机串的长度

在这里我们可以看到 python 中指定长度的随机字符串是如何

在这个例子中，我使用了 length_of_string = 4 ，它是字符串长度函数返回输入字符串中的字符数。此外， range() 函数用于获取字符串的长度范围，

并且 choice() 返回从任意序列中随机选择的元素。

示例:

import random
import string
length_of_string = 4
letters = string.ascii_uppercase
random_string = ""
for number in range(length_of_string):
  random_string += random.choice(letters)
print(random_string)

下面的屏幕截图显示了输出:

Python Random String

Python 随机字符串列表

这里我们可以看到如何从 python 中的一个给定列表中获得一个随机字符串

在此示例中，给出了一个列表，并从该字符串本身生成了一个随机字符串。如上所示，这里也使用相同的随机。choice()返回从任意序列中随机选择的元素。

示例:

import random
import string
print(random.choice(['mango', 'orange', 'apple']))

下面的屏幕截图显示了输出:

python random string of choice

Python 随机的字母和数字串

在这里我们可以看到如何在 python 中获得字母和数字的随机字符串

本例中使用了 string join() 来连接字符串中的所有项目。

".join(random . choices(string . ascii _ upper case+string . digits，k = N)该方法连接随机的字母和数字。

示例:

import string 
import random 
N = 5
res = ''.join(random.choices(string.ascii_uppercase +  string.digits, k = N)) 
print("The random string : " + str(res))

下面的屏幕截图显示了输出:

Python random string of letters and numbers

带特殊字符的 Python 随机字符串

在这里，我们可以看到如何在 python 中获得一个带有特殊字符的随机字符串

这个例子类似于一个由字母和数字组成的随机字符串，其中还添加了标点符号以获得字符串中的特殊字符，并使用了 string join() 来连接字符串中的所有项目。

import random
import string
def randomStringwithDigitsAndSymbols(stringLength=4):
  special_characters = string.ascii_letters + string.digits + string.punctuation
   return ''.join(random.choice(special_characters) 
for i in range(stringLength))
print (randomStringwithDigitsAndSymbols())
print (randomStringwithDigitsAndSymbols())
print (randomStringwithDigitsAndSymbols())

下面的屏幕截图显示了输出:

Python random string with special character

来自字母表的 Python 随机字符串

这里我们可以看到如何从 python 中的字母中获取随机字符串，

在这个例子中，使用了字符串的长度，还使用了 string join() 来连接字符串中的所有项目。 range () 返回字符串的长度范围。

示例:

import random
import string
string_length = 8
upper_case_alphabet = string.ascii_letters
lower_case_alphabet = string.ascii_letters
random_upper_letter = random.choice(lower_case_alphabet)
random_lower_letter = random.choice(upper_case_alphabet)

print(''.join(random.choice(random_upper_letter+random_lower_letter) for i in range(string_length)))

下面的屏幕截图显示了输出:

Python random string from alphabets

这里，我们看到了在 Python 中生成随机字符串的不同方法。

您可能会喜欢以下 Python 教程:

在本教程中，我们学习如何用 Python 生成随机数，以及如何用 Python 生成随机字符串。

Python 生成随机数
介于 0 和 1 之间的 Python 随机数
Python 随机数范围内的整数
1 到 10 之间的 Python 随机数
Python 随机数种子
Python 随机数的选择
Python 随机整数 n 的倍数
Python 随机数洗牌
两个浮点数之间的 Python 随机数
n 位数的 Python 随机数
不重复的 Python 随机数
Python 生成随机字符串
Python 长度的随机字符串
Python 列表的随机字符串
Python 字母和数字的随机字符串
带有特殊字符的 Python 随机字符串
来自字母表的 Python 随机字符串

Python 生成器(Python 生成器与迭代器)

原文：https://pythonguides.com/python-generators/

想了解一下 Python 生成器？阅读这篇文章，了解更多关于什么是 Python 生成器、 Python 迭代器，以及 Python 生成器 vs 迭代器的知识。

不熟悉 Python？绝对初学者请查看 Python 编程。

我们将编码:

什么是 Python 生成器
什么是 Python 迭代器
Python 生成器与迭代器
Python 生成器函数
接下来是 Python 生成器
Python 生成器表达式
Python 将生成器转换为迭代器
Python 生成器与迭代器性能

Python 生成器
Python 中字符串的生成器
Python 生成器函数
Python 生成器下一步
Python 生成器表达式
Python 生成器类
Python 生成器连接
Python 生成器 vs 迭代器
- Python 迭代器
- 使用类的迭代器
- Python 生成器 vs 迭代器
Python 生成器 vs 迭代器性能
Python 将生成器转换成迭代器

Python 生成器

一个 Python 生成器是一个使用 yield 方法创建一个值序列的函数。这里使用了 yield 关键字，而不是 return。

在这里，我们可以看到如何在 python 中生成数字

在这个例子中，为了从给定的范围生成数字，我定义了一个函数 n()，yield 用于生成数字。当我们使用 yield 关键字时，函数就变成了 Python 中的一个生成器。

示例:

def n(number):
  for i in range(number):
    yield i
for number in n(5):
  print(number)

下面的屏幕截图显示了输出:

在此输出中，我们可以看到数字被迭代。数字的总数取决于我们在 range()中提到的范围。

Python generator

Python 中字符串的生成器

在这个例子中，我们可以看到如何使用 python 中的 yield 关键字来迭代给定的字符串。这里我定义了一个函数字符串并将字符串的范围赋为 length，然后调用 yield 迭代字符串 print(string) 得到最终值。

示例:

def string(my_string):
    length = len(my_string)
    for i in range(length):
        yield my_string[i]

for string in ("python"):
    print(string)

下面的屏幕截图显示了输出:

在这个输出中，我们可以看到字符串 python 被迭代。

Generator for a string

Python 生成器函数

现在，我们可以看到如何使用 python 中的生成器函数打印数字

在这个例子中，为了从给定的范围生成数字，我定义了一个函数 n()，yield 关键字用于生成数字。当我们使用 yield 关键字时，函数就变成了一个生成器。

。

示例:

def n(number):
  for i in range(number):
    yield i
for number in n(5):
  print(number)

下图显示了输出:

在此输出中，我们可以看到数字被迭代。数字的总数取决于我们在 range()中提到的范围。

Python generator function

Python 生成器下一步

现在，我们可以看到在 python 中使用 next() 的 python 生成器

在这个例子中，我将一个函数定义为 numberGenerator，并指定 number = 2，同时使用了 loop。counter 是一个子类，用于对可散列对象进行计数。

示例:

def numberGenerator(n):
     number = 2
     while number < n:
         yield number
         number += 2

g = numberGenerator(20)

counter = 0

while counter < 9:
    print(next(g))
    counter += 1

下面的屏幕截图显示了输出:

在这个输出中，我们可以看到斐波那契数列。

Python generator next

Python 生成器表达式

这里我们可以看到关于 python 生成器表达式的 python。

生成器表达式类似于列表压缩，生成器表达式创建一个没有 yield 关键字的列表 。在本例中，我将一个变量作为一个数字，并使用 range() 对该数字执行了一个加法运算。最后，为了打印范围内的每个数字，我使用了 print 语句。

示例:

number = (x+x+x for x in range(10))
for each in number:
    print(each)

下面的屏幕截图显示了输出:

在这个输出中，我们可以看到我们得到的输出数字被加了三次，这里执行的算术运算被认为是表达式。

Python generator expression

Python 生成器类

在这里我们可以看到如何用 python 编写生成器类

在下面的例子中，我用 init() 来初始化对象，self 表示类的实例， self 关键字用于访问类的属性和方法 self.num1，self.num2 = 1，2 是类的属性。

def __next__(self) 用于迭代下一个对象，yield 用于调用一个块， range() 函数返回给定范围内的列表。

示例:

class fibonacci:
    def __init__(self, num):
        self.num = num
        self.num1, self.num2 = 2, 3

    def __iter__(self):
        for i in range(self.num):
            yield self.num1
            self.num1, self.num2 = self.num2, self.num1+self.num2

f = fibonacci(3)

for i in f:
    print(i)

下面的屏幕截图显示了输出:

在这个输出中，我们可以看到 3 个斐波那契数列

Python generator class

Python 生成器连接

现在我们可以看到 python 中生成器是如何连接它们自己的。

在下面的例子中，我将 3 个生成器作为 myGeneratora，myGeneratorb，myGeneratorc，第一个生成器是 myGeneratora 有一个输入参数，给出了范围内的限制，第二个生成器是 myGeneratorb 有两个参数作为输入，给出了范围内的两个限制，接下来 mygeneratorc 调用 myGeneratora 和 myGeneratorb 来产生它们的值，并打印如下

示例:

def myGeneratora(n):
    for i in range(n):
        yield i
def myGeneratorb(n, m):
    for j in range(n, m):
        yield j
def myGeneratorc(n, m):
    yield from myGeneratora(n)
    yield from myGeneratorb(n, m)
    yield from myGeneratorc(m, m+10)
print(list(myGeneratora(0)))
print(list(myGeneratorb(1, 5)))
print(list(myGeneratorb(0, 10)))

下面的屏幕截图显示了输出:

在这个输出中，我们可以看到发电机是如何连接的。

Python generator connecting

Python 生成器 vs 迭代器

在了解 Python 生成器 vs 迭代器的区别之前，我们先来了解一下什么是 Python 迭代器。

Python 迭代器

Python 迭代器是一个一次返回一个元素的对象，next()用于获取下一个值。

在这里，我们可以看到如何在 python 中迭代列表中的项目。

在这个例子中，我将列表名指定为 my_list ，iter()返回对象的迭代器。next() 从迭代器返回下一项。

例子

my_list = [1, 2, 3, 4, 5]
my_iter = iter(my_list)
print(next(my_iter))
print(next(my_iter))
print(next(my_iter))
print(next(my_iter))
print(next(my_iter))

下面的屏幕截图显示了输出:

在这个输出中，我们可以看到从列表中迭代的条目，迭代的条目数量取决于 print(next(my_iter))语句的数量。

迭代器

使用类的迭代器

现在，我们可以看到如何使用 python 中的类来迭代数字。

在这个例子中，我定义了一个 EvenNumber 类，它创建了一个 iter，然后按照(2，4，6，8，10，12)的顺序返回数字，这六个数字是迭代的，因为我使用了 6 个 print(next(myiter)) 语句。self 是一个参数，用于访问属于该类的变量。

示例:

class EvenNumbers:
  def __iter__(self):
    self.a = 2
    return self

  def __next__(self):
    numbers = self.a
    self.a += 2
    return numbers

myclass = EvenNumbers()
myiter = iter(myclass)

print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))

在这个输出中，我们可以看到数字按顺序返回，因为我使用了六个 print(next(myiter))语句，所以返回了六个数字。

Iterator using class

Python 生成器 vs 迭代器

Generator vs Iterator

总而言之，

Python 生成器通常使用函数实现，迭代器使用类实现，生成器使用关键字 yield ，迭代器使用关键字 return 。
所有的局部变量都存储在生成器中的 yield 语句之前，迭代器中没有局部变量。在 python 生成器中，我们可以编写快速简洁的代码。
为了在 python 中创建生成器，我们使用了函数，但是为了创建迭代器函数，我们必须使用迭代器()和下一个函数()。

Python 生成器 vs 迭代器性能

Python 生成器有更多的内存，对 CPU 来说效率更高。
Python 生成器拥有良好的编程结构。
迭代器允许惰性求值。
迭代器仅在被请求时才迭代下一个元素。
生成器和迭代器只能迭代一次。
对于简单的情况，Python 中的生成器函数和生成器表达式比迭代器更好。

Python 将生成器转换成迭代器

在这里，我们可以看到如何在 python 中将生成器转换成迭代器。

在这个例子中，产出被用来将一个函数转换成一个生成器，它返回一个生成器。当 yield 被调用时，它将返回生成器。

示例:

def common_divisors_generator(a):
    factors_a = [i for i in range(2, a + 2) if a%i == 0]
    def gen():
        for fa in factors_a:
            yield fa
    return gen()
print(common_divisors_generator)

下面的屏幕截图显示了输出:

Python convert generator to an iterator

您可能会喜欢以下 Python 教程:

这就是我们如何使用 Python 生成器和迭代器。在这里我们学到了以下东西:

Python 生成器
Python 中字符串的生成器
Python 生成器函数
接下来是 Python 生成器
Python 生成器表达式
Python 生成器类
Python 生成器连接
Python 生成器与迭代器
Python 迭代器
使用类的迭代器
Python 生成器与迭代器性能
Python 将生成器转换为迭代器

Python 获取目录中的所有文件+各种示例

原文：https://pythonguides.com/python-get-all-files-in-directory/

在本 Python 教程中，我们将学习 Python 获取目录中的所有文件，我们还将涉及以下主题:

Python 获取带有扩展名的目录中的所有文件
Python 获取给定范围内的所有文件和目录
列出给定目录的所有目录 python
Python 递归地列出了目录中的所有文件
Python 目录中的所有文件列表
如何在 Python 中删除一个目录下的所有文件
Python 获取目录中匹配某个模式的所有文件
如何在 Python 中获取以开始的目录中的所有文件
Python 在没有扩展名的目录中获取文件
Python 获取目录过滤器中的所有文件
Python 目录，大小为
Python 使用绝对路径列出了目录中的所有文件
Python 列出了目录和子目录中的所有文件
Python 获取目录完整路径中的所有文件
Python 列出了目录和子目录中所有文件及其大小
Python 目录中的所有文件过滤得到 jpg 文件

Python 获取目录中的所有文件
Python 列出了目录中所有扩展名为的文件
Python 获取给定范围内的所有文件目录
列出给定目录的所有目录 Python
Python 递归列出目录中的所有文件
Python 一个目录下的所有文件列表
Python 删除一个目录下的所有文件
Python 获取目录中所有匹配模式的文件
Python 获取从开始的目录中的所有文件
Python 获取没有扩展名的目录中的文件
Python 获取目录过滤器中的所有文件
Python 目录，大小为
Python 用绝对路径列出一个目录中的所有文件
Python 列出一个目录和子目录中的所有文件
Python 列出子目录中扩展名为的所有文件
Python 获取目录下所有文件的完整路径
Python 列出了目录和子目录中所有大小为的文件
Python 目录中的所有文件过滤得到 jpg 文件

Python 获取目录中的所有文件

在这里，我们可以看到如何在 Python 中列出一个目录中的所有文件。

在这个例子中，我已经导入了一个名为 os 的模块，并将一个变量声明为路径，并指定路径来列出目录中的文件。
一个空变量被声明为 list_of_files ， root 用于打印所有目录， dirs 用于打印根目录下的所有子目录， files 用于打印根目录和目录下的所有文件。
os。walk() 用于通过遍历树来生成目录树中的文件名，用于循环用于迭代。
path.join 用于将一个或多个路径组合成一个路径，以组合文件 os 方法，如 os.walk() 来创建最终路径。
list _ of _ files . append(OS . path . join(root，file)) 用于将生成的文件追加到一个空变量中，为了打印文件列表，我使用了 print(name) 。

示例:

import os
path =r'C:\Users\Administrator.SHAREPOINTSKY\Desktop\Work'
list_of_files = []

for root, dirs, files in os.walk(path):
	for file in files:
		list_of_files.append(os.path.join(root,file))
for name in list_of_files:
    print(name)

在输出中可以看到目录中的所有文件。您可以参考下面的输出截图。

Python all files in a directory

这就是如何用 Python 从一个目录中获取所有文件。

你可能喜欢 Python 捕捉多个异常和 Python 异常处理。

Python 列出了目录中所有扩展名为的文件

现在，我们可以看到如何在 Python 中列出扩展名为的目录中的所有文件。

在这个例子中，我已经导入了一个名为 os 的模块，并将一个变量声明为路径，并指定路径来列出目录中的文件。
一个空变量被声明为 list_of_files 并且根目录被用于打印所有目录并且目录被用于打印从根目录开始的所有子目录。
文件用于打印根目录和目录下的所有文件。
os.walk() 用于遍历目录树生成文件名，循环的用于迭代。
如果使用了条件并且提到了扩展名并且使用了 os.path.join() ，则获取具有指定扩展名的文件列表。
path.join 用于将一个或多个路径组合成一个路径，以组合文件 os 方法，如 os.walk() 来创建最终路径。

示例:

import os
path =r'C:\Users\Administrator.SHAREPOINTSKY\Desktop\Work'
for root, directories, file in os.walk(path):
	for file in file:
		if(file.endswith(".txt")):
			print(os.path.join(root,file))

有一个的文件。txt 扩展名在输出中列出。您可以参考下面的输出截图。

python list files in directory with extension

这就是如何用 Python 获取一个带扩展名的目录中的所有文件。

你可能喜欢读不存在 Python 的文件。

Python 获取给定范围内的所有文件目录

现在，我们可以看到如何在 python 中列出给定范围的目录中的所有文件。

在这个例子中，我导入了一个名为 glob 的模块。glob 模块用于检索与指定模式匹配的文件。
循环的用于迭代，【0-9】为指定模式。使用 print(name)来获得输出。

示例:

import glob  
for name in glob.glob(r'C:\Users\Administrator.SHAREPOINTSKY\Desktop\Work/*[0-9].*'): 
    print(name)

我们可以看到文件名包含数字范围[0-9]的文件列表。您可以参考下面的输出截图。

Python all files directories with a given range

这就是如何在 Python 中获得给定范围内的所有文件目录。

在这里，我们可以看到如何用 python 中的给定目录列出所有目录。

在这个例子中，我导入了一个名为 os 的模块，并将一个变量声明为路径，并指定了目录的路径。
并且另一个名为的变量文件夹被声明为空并且 os.walk() 被用于通过遍历树来生成目录树中的文件名，for 循环被用于迭代。
path.join 用于将一个或多个路径组合成一个路径，以组合文件 os 方法，如 os.walk() 来创建最终路径。

示例:

 import os
path = r'C:\Users\Administrator.SHAREPOINTSKY\Desktop\Work'
folders = []
for root, directories, files in os.walk(path):
    for folder in directories:
        folders.append(os.path.join(root, folder))
for files in folders:
    print(files)

我们只能看到给定目录中的目录作为输出。下面的截图显示了输出。

List all directories with the given directories python

这就是如何用 Python 中的给定目录列出所有目录。

Python 递归列出目录中的所有文件

现在，我们可以看到如何在 python 中递归地列出目录中的所有文件。

在这个例子中，我导入了一个名为 glob 的模块，并声明了一个变量，为该变量分配了路径，并将其用于循环迭代。
并且用了*** /。csv"** 获取扩展名为 CSV 的文件列表，并使用递归=真函数。
递归函数是一个根据自身定义的函数，它将继续调用自身并重复调用，直到返回某个条件。

示例:

import glob
path = r'C:\Users\Administrator.SHAREPOINTSKY\Desktop\Work'
files = [f for f in glob.glob(path + "**/*.csv", recursive=True)]
for f in files:
    print(f)

在下面的截图中，我们可以看到带有的文件列表。csv 扩展

python list all files in directory recursively

这就是如何用 Python 递归地获取一个目录中的所有文件。

阅读:如何用 python 创建字典键列表

Python 一个目录下的所有文件列表

在这里，我们可以看到目录中的所有文件，以 python 列出。

在这个例子中，我已经导入了一个名为 os 的模块，根目录用于打印所有目录，目录用于打印根目录下的所有子目录。文件用于打印根目录和目录下的所有文件。
os.walk() 用于通过遍历树来生成目录树中的文件名。
for 循环用于迭代。这里，我使用了 print(filename) 来获取文件的名称。

示例:

import os
for root, dirs, files in os.walk(r'C:\Users\Administrator.SHAREPOINTSKY\Desktop\Work'):
    for filename in files:
        print(filename)

我们可以从目录中看到文件列表。您可以参考下面的输出截图

Python all files in a directory to list

Python 删除一个目录下的所有文件

在这里，我们可以看到如何用 python 删除一个目录中的所有文件。

在这个例子中，我导入了一个名为 os 的模块，声明了一个名为 path、的变量，并分配了一个路径。
os.walk() 用于通过遍历树来生成目录树中的文件名，for 循环用于迭代。 os.remove() 用于从目录中删除文件。

示例:

import os
path = r'C:\Users\Administrator.SHAREPOINTSKY\Desktop\Work'
for root, directories, files in os.walk(path):
    for file in files:
        os.remove(os.path.join(root, file))

由于所有文件都被删除，文件不会显示在输出中。这就是我们如何在 Python 中从一个目录中删除所有文件。

Python 获取目录中所有匹配模式的文件

在这里，我们可以看到如何获取一个目录中与 python 中的模式相匹配的所有文件

在这个例子中，我导入了一个名为 glob 的模块，并使用作为循环。
glob.glob() 用于查找所有匹配指定模式的路径名。
路径与模式一起分配。这里，我已经把图案当成新的了？* 。 '*' 用于匹配任何字符序列和【T4 '？'匹配任何单个字符。

示例:

import glob
for name in glob.glob(r'C:\Users\Administrator.SHAREPOINTSKY\Desktop\Work\new?*'):
    print(name)

在这里，我们可以在输出中看到匹配模式的文件作为 new 。您可以参考下面的输出截图:

Python get all files in a directory that match a pattern

Python 获取从开始的目录中的所有文件

在这里，我们可以如何在 python 中获得一个以开头的目录中的所有文件

在这个例子中，我导入了一个名为 os 的模块，并使用 os.walk () 通过遍历目录树来生成文件名。
这里，我们使用了 for 循环进行迭代，if 条件用于获取文件starts with**【new】**。这里我们可以使用任何我们想要的关键字。

示例:

import os
for path, Directory, files in os.walk(r'C:\Users\Administrator.SHAREPOINTSKY\Desktop\Work'):
    for file in files:
        if file.startswith("new"):
            print(file)

我们可以在输出中看到文件名只以 new 开头。您可以参考下面的输出截图。

Python get all files in a directory starting with

Python 获取没有扩展名的目录中的文件

在这里，我们可以看到如何在 python 中获取没有扩展名的目录中的文件

在这个例子中，我导入了一个名为 os 的模块，并将一个变量声明为一个目录。
并将路径与路径名一起分配给它，文件名也被提及并使用(OS . path . split ext(directory)[0])来拆分文件名和扩展名。【0】是去掉扩展名的 jpg 的索引值。

示例:

import os
directory = r'C:\Users\Administrator.SHAREPOINTSKY\Desktop\Work\newimage.jpg'
print(os.path.splitext(directory)[0])

我们在输出中只能看到不带扩展名的文件名。下面的截图显示了输出。

Python get files in a directory without an extension

Python 获取目录过滤器中的所有文件

现在，我们可以看到如何使用 python 中的过滤器获取目录中的所有文件

在这个例子中，我导入了一个名为 os 和 glob 的模块，并将一个变量声明为 files，并将 glob.glob("*。txt") 。
glob.glob() 用于返回文件列表和过滤文件，我用了 "*。txt" 并使用打印(文件)来获取文件列表。
星号' * "用于匹配任何字符序列

示例:

import os
import glob
files = glob.glob("*.txt")
print(files)

我们可以从目录中看到所有只有的文件。txt 分机为输出。你可以参考下面的截图。

Python get all files in directory filter

Python 目录，大小为

在这里，我们可以看到如何从 python 中大小为的目录中获取文件

在这个例子中，我导入了一个名为 os、的模块，并分配了一个路径。另一个变量被声明为一个文件，并将其赋值为 file = os.stat(path)。
stat() 用于获取特定路径的状态。为了获得文件的字节大小，我使用了 file.st_size 。
为了获得以兆字节为单位的文件大小，我使用了 file.st_size / (1024 * 1024) 。

示例:

import os
path = r'C:\Users\Administrator.SHAREPOINTSKY\Desktop\Work'
file = os.stat(path)
print(file)
print(f'Size in Bytes is {file.st_size}')
print(f'Size in MegaBytes is {file.st_size / (1024 * 1024)}')

在下面的截图中，我们可以看到以字节和兆字节作为输出的大小。

Python directory with the size

Python 用绝对路径列出一个目录中的所有文件

现在，我们可以看到如何用 python 中的绝对路径列出一个目录中的所有文件

在这个例子中，我导入了一个名为 os 的模块，我使用了 os.walk() 通过遍历目录树来生成文件名。
os.path.join() 用于将两条或多条路径合并成一条路径。 os.path.abspath 返回路径名的规范化绝对版本。

示例:

import os
for root, dirs, files in os.walk('.'):
    for file in files:
        p=os.path.join(root,file)
    print(os.path.abspath(p))

我们可以看到来自绝对路径的所有文件作为输出。您可以参考下面的输出截图。

Python list all files in a directory with an absolute path

Python 列出一个目录和子目录中的所有文件

现在，我们可以看到如何在 python 中列出一个目录和子目录中的所有文件

在这个例子中，我已经导入了一个名为 os 的模块，并将一个变量声明为路径，并指定路径来列出目录和子目录中的文件。
声明一个空变量为 list_files ，用根目录打印所有目录，用目录打印根目录下的所有子目录，文件打印根目录下的所有文件。
os。walk() 用于通过遍历树来生成目录树中的文件名，用于循环用于迭代。
path.join 用于将一个或多个路径组合成一个路径，以组合文件 os 方法，如 os.walk() 来创建最终路径。
list _ of _ files . append(OS . path . join(root，file)) 用于将生成的文件追加到一个空变量中，为了打印文件列表，我使用了 print(name) 。

示例:

import os
path =r'C:\Users\Administrator.SHAREPOINTSKY\Desktop\Work'
list_files = []
for root, dirs, files in os.walk(path):
	for file in files:
		list_files.append(os.path.join(root,file))
for name in list_files:
    print(name)

下面的屏幕截图显示了目录和子目录中所有文件的输出。

Python list all files in a directory and subdirectory

Python 列出子目录中扩展名为的所有文件

在这里，我们可以看到如何在 python 中列出子目录中扩展名为的所有文件

在这个例子中，我已经导入了操作系统、并将一个变量声明为路径、，并将该路径分配给一个子目录。
一个空变量被声明为 list_files 。根目录用于打印所有目录，目录用于打印根目录下的所有子目录，文件用于打印根目录下的所有文件。
os。walk() 用于通过遍历树来生成目录树中的文件名，用于循环用于迭代。
path.join 用于将一个或多个路径组合成一个路径，以组合文件 os 方法，如 os.walk() 来创建最终路径。
list _ files . append(OS . path . join(root，file)) 用于将生成的文件追加到一个空变量中，要打印文件列表，我使用了 print(name) 。

示例:

import os
path =r'C:\Users\Administrator.SHAREPOINTSKY\Desktop\Work\office'
list_files = []
for root, dirs, files in os.walk(path):
	for file in files:
		list_files.append(os.path.join(root,file))
for name in list_files:
    print(name)

我们可以看到子目录中的文件列表作为输出。您可以参考下面的输出截图。

Python list all files in subdirectories with extension

Python 获取目录下所有文件的完整路径

在这里，我们可以看到如何在 python 中获取目录完整路径中的所有文件

在这个例子中，我已经导入了 os ，并声明了一个变量为路径，并指定了目录的完整路径。
声明一个空变量为 list_files ，用根目录打印所有目录，用目录打印根目录下的所有子目录，文件打印根目录下的所有文件。
os。walk() 用于通过遍历树来生成目录树中的文件名，用于循环用于迭代。
path.join 用于将一个或多个路径组合成一个路径，以组合文件 os 方法，如 os.walk() 来创建最终路径。
list _ files . append(OS . path . join(root，file)) 用于将生成的文件追加到一个空变量中，要打印文件列表，我使用了 print(name) 。

示例:

import os
path =r'C:\Users\Administrator.SHAREPOINTSKY\Desktop\Newfolder'
list_files = []
for root, dirs, files in os.walk(path):
	for file in files:
		list_files.append(os.path.join(root,file))
for name in list_files:
    print(name)

我们可以在输出中看到来自指定的完整路径的文件列表。您可以参考下面的输出截图。

Python get all files in directory full path

Python 列出了目录和子目录中所有大小为的文件

在这里，我们可以看到如何在 python 中从目录和子目录中获取大小为的文件

在这个例子中，我导入了一个名为 os 的模块，并分配了路径，这里 Work 是目录， office 是子目录。
另一个变量被声明为一个文件，并将其赋值为 file = os.stat(path)。
stat() 用于获取特定路径的状态。为了获得文件的字节大小，我使用了 file.st_size 。
为了获得以兆字节为单位的文件大小，我使用了 file.st_size / (1024 * 1024) 。

示例:

import os
path = r'C:\Users\Administrator.SHAREPOINTSKY\Desktop\Work\office'
file = os.stat(path)
print(file)
print(f'Size in Bytes is {file.st_size}')
print(f'Size in MegaBytes is {file.st_size / (1024 * 1024)}')

在下面的截图中，我们可以看到以字节和兆字节作为输出的大小。

Python list all files in directory and subdirectories with size

Python 目录中的所有文件过滤得到 jpg 文件

现在，我们可以看到如何在 python 中使用 filter 获取 jpg 文件来获取目录中的所有文件

在这个例子中，我导入了一个名为 os 和 glob 的模块，并将一个变量声明为 files，并将 glob.glob("*。jpg") 。
glob.glob() 用于返回文件列表和过滤文件，我用了 "*。jpg" 并使用 print(files)来获取文件列表。 '*' 用于匹配任何字符序列。

示例:

import os
import glob
files = glob.glob("*.jpg")
print(files)

我们可以从目录中看到所有只有的文件。jpg 扩展名作为输出。你可以参考下面的截图。

Python all files in directory filter to get jpg files

您可能会喜欢以下 Python 教程:

在本教程中，我们学习了 Python 获取一个目录中的所有文件，我们还讨论了以下主题:

Python 列出了带有扩展名的目录中的所有文件
Python 获取给定范围内的所有文件和目录
列出给定目录的所有目录 python
Python 递归地列出了目录中的所有文件
Python 列出了一个目录中所有要列出的文件
Python 删除一个目录中的所有文件
Python 获取目录中匹配某个模式的所有文件
Python 获取一个目录中的所有文件，以
Python 在没有扩展名的目录中获取文件
Python 获取目录过滤器中的所有文件
Python 目录，大小为
Python 使用绝对路径列出了目录中的所有文件
Python 列出了目录和子目录中的所有文件
Python 获取目录完整路径中的所有文件
Python 列出了目录和子目录中所有文件及其大小
Python 目录中的所有文件过滤得到 jpg 文件

Python 获得一个 IP 地址

原文：https://pythonguides.com/python-get-an-ip-address/

在这个 python 教程中，你将通过例子学习什么是 IP 地址和如何使用 python 中的套接字模块获得 IP 地址。这里我们将检查 :

Python 获取 IP 地址
Python 从主机名获取 IP 地址
Python 使用脚本获取网站的 IP 地址
Python 从 URL 获取 IP 地址
使用 python 中的 IP Address 模块确定给定的 IP 地址是公共的还是私有的
Python IP 地址验证
Python 提取 MAC 地址

什么是 IP 地址
Python 获取 IP 地址
Python 从主机名中获取 IP 地址
Python 使用脚本获取网站的 IP 地址
Python 从 URL 获取 IP 地址
使用 python 中的 IP Address 模块确定给定的 IP 地址是公共的还是私有的
Python IP 地址验证
Python 提取 MAC 地址

什么是 IP 地址

IP 代表互联网协议地址。它是您的网络硬件的一个地址，在那里它将您的计算机与您的网络上和世界各地的其他设备连接起来。
IP 地址由字符或数字组成，如 508.543.12.514 。所有连接到互联网的设备都有一个唯一的 IP 地址。

Python 获取 IP 地址

为了获得你电脑的 Python 中的 IP 地址，我们需要导入 socket 库，然后我们就可以找到电脑、笔记本电脑等的 IP 地址，它们就有了自己唯一的 IP 地址。

举例:

import socket
h_name = socket.gethostname()
IP_addres = socket.gethostbyname(h_name)
print("Host Name is:" + h_name)
print("Computer IP Address is:" + IP_addres)

写完上面的代码(python 获取 IP 地址)，你会打印出 "IP_addres" 然后输出会显示为"主机名是:桌面-AJNOCQ 计算机 IP 地址是:192.168.45.161 " 。
首先导入 socket 模块，然后使用 socket.gethostname() 获取 h_name 。
现在，通过将 h_name 作为参数传递给 socket.gethostbyname() 来找到 IP 地址，并将其存储在一个变量中。打印 IP 地址。

你可以参考下面的 python 获取 IP 地址的截图

Python get IP Address

输出:

Host Name is: DESKTOP-AJNOCQ
Computer IP Address is: 192.168.45.161

Python 从主机名中获取 IP 地址

Python gethostbyname() 函数接受主机名作为参数，它将使用套接字模块返回某些网站的 IP 地址。

举例:

import socket
IP_addres = socket.gethostbyname('pythonguides.com')
print("IP Address is:" + IP_addres)

写完上面的代码(python 从主机名中获取 IP 地址)，你将打印出 "IP_addres" ，然后输出将显示为 "IP 地址是:104.28.20.90" 。
这里， socket.gethostbyname() 会返回网站的 IP 地址。
如果你和我不在同一个地方，那么你可能会得到不同的 IP 地址作为输出。

你可以参考下面的 python 从主机名获取 IP 地址的截图

Python get IP Address from hostname

Python 使用脚本获取网站的 IP 地址

这里，我们将要求用户输入网站地址，然后打印该网站的 IP 地址。

举例:

import socket
host_name = input("Enter the website address: ")
print(f'The {host_name} IP address is: {socket.gethostbyname(host_name)}')

写完上面的代码(python 使用脚本获取一个网站的 IP 地址)后，首先我们将输入网站地址，然后它将输出为“food.com 的 IP 地址是:52 . 201 . 38 . 142”。
这里，socket . gethostbyname(host _ name)会返回网站“food . com”的 IP 地址。

你可以参考下面的 python 截图，使用脚本获取网站的 IP 地址。

Python get the IP Address of a website using a script

Python 从 URL 获取 IP 地址

首先，我们导入了一个 socket 模块来获取 python 中一个 URL 的 IP 地址。URL 代表统一资源定位符。URL 是资源在互联网上的地址。

举例:

import socket
url = "python.com"
print("IP Address:",socket.gethostbyname(url))

写完上面的代码(python 从 URL 中获取一个 IP 地址)后，我们将把一个 URL 赋给一个变量。
该变量作为socket . gethostbyname(URL)的参数，它将返回输出为IP 地址:3 . 96 . 23 . 237。

你可以参考下面 python 从 URL 获取 IP 地址的截图。

Python get an IP address from the URL

使用 python 中的 IP Address 模块确定给定的 IP 地址是公共的还是私有的

私有 IP 地址–私有 IP 地址是连接到家庭或企业网络的设备的地址。无法从家庭或企业网络之外的设备访问此 IP 地址。
公共 IP 地址–公共 IP 地址是用于网络外部通信的地址。这个 IP 地址把你和世界联系起来，它对所有人来说都是独一无二的。公共 IP 地址由互联网服务提供商(ISP)分配。

为了确定给定的 IP 地址是公有的还是私有的，我们将首先导入 ipaddress 模块，我们将使用 IP Address 模块的 is_private 方法，该方法将测试该地址是否被分配为私有。

举例:

from ipaddress import ip_address
def IP_address(IP: str)-> str:
    return "Private" if (ip_address(IP).is_private)else "Public"
if __name__ == '__main__':
    print(IP_address('127.0.0.1'))
    print(IP_address('3.96.23.237'))

先写完上面的代码(用 python 中的 ipaddress 模块确定给定的 IP 地址是公有的还是私有的)之后，我们就导入 ipaddress 模块，然后我们就使用 IP Address 的 is_private 方法。它将输出作为“私有公共”返回。

你可以参考下面 python 从 URL 获取 IP 地址的截图。

Determine if the given IP Address is public or private using the ipaddress module in python

Python IP 地址验证

如果你想检查给定的 IP 地址是否有效，使用 socket 模块，我们也将使用函数 inet_aton() ，该函数只有一个参数。

举例:

import socket 
IP = '127.0.0.2561'
try:
   socket.inet_aton(IP)
   print("Valid IP address")
except socket.error:
   print("Invalid IP")

在编写完上面的代码(python IP 地址验证)之后，您将打印这些代码，然后输出将是“无效的 IP 地址”，因为给定的 IP 是无效的，因此将执行 except 块。如果给定的 IP 地址有效，那么它将返回一个有效的 IP 地址。

你可以参考下面的 python IP 地址验证截图。

Python IP Address validation

Python 提取 MAC 地址

媒体访问控制地址(MAC 地址)也称为物理地址，是分配给计算机的网卡(NIC) 的唯一标识符。
MAC 地址是唯一标识网络上每个设备的硬件标识号。
网卡帮助计算机与网络中的计算机连接。

为了提取 MAC 地址我们将首先导入 uuid 模块，然后我们将使用 uuid.getnode() 来提取计算机的 MAC 地址。

举例:

import uuid
print(hex(uuid.getnode()))

写完上面的代码(python 提取 MAC 地址)后，你将打印出 "hex(uuid.getnode())" ，然后输出将是 " 0x780cb8d4d2ca " 。但是可视输出的格式不适合，而且也很复杂。

你可以参考下面的 python 提取 MAC 地址的截图。

Python extract MAC address

为了获得格式形式的 MAC 地址，我们将使用 getnode()、findall()和 re() 。我们需要导入 re 和 uuid 模块。

举例:

import re, uuid
print(" MAC address in less complex and formatted way is :", end="")
print(':'.join(re.findall('..', '%012x' %uuid.getnode())))

编写完上面的代码(python 提取 MAC 地址)后，您将打印这些代码，然后输出将是 " MAC 地址以不太复杂和格式化的方式是:78:0c:b8:d4:d2:ca" 。在每 2 位数后使用 getnode()的 join 元素使用 regex 表达式将以格式化的方式提供。

你可以参考下面的 python 提取 MAC 地址的截图。

Python extract MAC address

您可能会喜欢以下 Python 教程:

在这个 Python 教程中，我们学习了 Python 获取 IP 地址。此外，我们还讨论了以下主题:

什么是 IP 地址，如何在 Python 中获得 IP 地址
Python 从主机名获取 IP 地址
Python 使用脚本获取网站的 IP 地址
Python 从 URL 获取 IP 地址
使用 python 中的 IP Address 模块确定给定的 IP 地址是公共的还是私有的
Python IP 地址验证
Python 提取 MAC 地址

如何在 Python 中从路径中获取文件名

原文：https://pythonguides.com/python-get-filename-from-the-path/

在这个 Python 教程中，我们将讨论如何从路径中获取文件名，我们也将看到如何在 Python 中获取文件大小。

Python 从路径中获取文件名
Python 获取文件大小
Python 从文件名中获取文件扩展名
Python 获取不带扩展名的文件名

Python 从路径获取文件名
Python 获取文件大小
Python 从文件名中获取文件扩展名
Python 获取不带扩展名的文件名

Python 从路径获取文件名

为了从 Python 中的路径获取文件名，我们需要导入 os，然后添加路径。

举例:

import os
print()
print(os.path.basename('E:\project-python\string\list.py'))
print()

在编写了上面的代码(python 从 path 中获取文件名)之后，您将打印这些代码，然后输出将显示为 " list.py " 。你可以参考下面的截图从路径创建一个 python get 文件名。

Get filename from the path in Python

上面的代码，我们可以用 Python 中的从一个路径中获取文件名。

你可能也喜欢，如何使用 Python 中的熊猫 drop()函数？

Python 获取文件大小

在 python 中，为了获得文件大小，我们将使用 os 模块，python os 模块具有 getsize() 函数，其中文件名作为参数传递，并以字节为单位返回文件的大小。

import os
file_size = os.path.getsize('E:\project-python\datafile.txt')
print('Size of file is', file_size, 'bytes')

写完上面的代码(Python 获取文件大小)，你将打印出 "file_size" ，然后输出将显示为"文件大小为 78 字节"。这里，我们使用 getsize()函数来获取文件的大小。你可以参考下面的截图 Python 获取文件大小。

Get file size in Python

这就是我们如何在 Python 中获得文件大小。

Python 从文件名中获取文件扩展名

为了从文件名字符串中获取文件扩展名，我们将导入 os 模块，然后我们可以使用方法 os.path.splitext() 。它会将路径名分成一对根和扩展名。

举例:

import os
f_name, f_ext = os.path.splitext('file.txt')
print(f_ext)

写完上面的代码(Python 从文件名中获取文件扩展名)，你将打印出“f _ ext”，然后输出将显示为。txt " 。这里，文件名将被分成两部分，当我们打印 f_ext 时，它将给出文件名的扩展名。你可以参考下面的截图 Python 从文件名中获取文件扩展名。

Python get file extension from filename

这就是我们如何在 Python 中从文件名中获取文件扩展名。

Python 获取不带扩展名的文件名

为了在 python 中获取不带扩展名的文件名，我们将导入 os 模块，然后我们可以使用 os.path.splitext() 方法获取名称。

举例:

import os
f_name, f_ext = os.path.splitext('file.txt')
print(f_name)

写完上面的代码(Python 获得不带扩展名的文件名)，你将打印出“f _ name”，然后输出将显示为“文件”。这里，文件名将被分成两部分，当我们打印 f_name 时，它将删除扩展名。你可以参考下面的截图 Python 获取不带扩展名的文件名。

Python get filename without extension

这就是如何在 Python 中获得不带扩展名的文件名。

您可能会喜欢以下 Python 教程:

使用 Visual Studio 代码用 python 创建一个 hello world 程序
Python 字符串函数
Python 类型错误:“列表”对象不可调用
如何在 python 中把整数转换成字符串
如何在 python 中连接字符串
Python 命名约定
如何在 python 中使用正则表达式拆分字符串
如何在 Python 中创建字符串

在本 Python 教程中，我们将讨论如何从 Python 的路径中获取文件名，以及以下内容:

如何在 Python 中从路径中获取文件名
如何在 Python 中获取文件大小
如何在 Python 中从文件名中获取文件扩展名
如何在 Python 中获得不带扩展名的文件名

Python GUI 编程(Python Tkinter)

原文：https://pythonguides.com/python-gui-programming/

想了解更多关于 Python GUI 编程？在这个 Python 教程中，我们将讨论关于 python gui 编程，基本上我们会看到什么是 Python GUI，什么是 Python TKinter 。如何在 Python 中使用 Tkinter。同样，我们将把下面这些东西看作:

如何在 Python 中下载和安装 Tkinter
使用 Tkinter 创建第一个程序
什么是 Python Tkinter 小部件
什么是几何管理(包、网格、位置)
包装、网格和位置之间的差异
使用 Python Tkinter 的迷你项目
使用 python Tkinter 的 10 个最佳项目创意

使用 python 的 Gui
Python tkinter 安装
使用 Tkinter 创建第一个程序
Python Tkinter widgets
几何管理
包装、网格和位置之间的差异
使用 Python Tkinter 的迷你项目
使用 python Tkinter 的 10 个最佳项目创意

使用 python 的 Gui

如果你是一名 Python 开发者，并且想要创建支持图形用户界面的酷应用程序，那么你来对地方了。在这里，我们将学习如何使用 Python Tkinter 创建基于 GUI 的应用程序。单词“ Tkinter ”读作“T-kin-ter”。我们将阅读所有关于 Python gui 编程的内容。
在 python 中，Tkinter 用于创建软件，而 Turtle & Pygame 用于创建基于图形的动画&游戏。

Python tkinter 安装

Python 自带了一个内置的 Tkinter 模块，所以如果你安装了 python 就可以执行 Tkinter 程序。
如果你想知道，如何安装 python，那么查看 Python 下载安装步骤。
在命令提示符下键入python -m tkinter来快速检查 Tkinter 。如果出现下面这种窗口，意味着 tkinter 已安装&，您可以跳过这一步。

python gui programming

如果这些窗口没有出现，请遵循以下步骤:(Macintosh 和 Linux 用户也可以遵循这些步骤)

第一步:

检查系统中安装的 python 版本:python --version

第二步:

去python.org下载相同版本的 python。在我的情况下，我已经下载了 64 位的 python 3.7.9 。

第三步:

点击安装文件>>会出现窗口>>点击修改。

python gui programming

第四步:

选择显示 tcl/tk 和 IDLE 的第三个选项，然后点击下一个，接着点击安装。

Python tkinter installation

第五步:

在命令提示符下键入python -m tkinter。如果此窗口出现，意味着 tkinter 现在已安装。

Python GUI Programming

使用 Tkinter 创建第一个程序

让我们试着多理解一点关于 Python gui 编程的知识。

在引入任何命令之前，我们希望您将代码复制并粘贴到代码编辑器中，并尝试一次。这是一个简单的“你好”程序，将给出一个关于我们将要做什么的想法。

$python guides images\tkinter\Python GUI Programming (Tkinter) first program.png$

代码:

# import modules
from tkinter import *

# configure workspace
ws = Tk()
ws.title("First Program")
ws.geometry('250x150')
ws.configure(bg="#567")

# function territory
def welcome():
    name = nameTf.get()
    return Label(ws, text=f'Welome {name}', pady=15, bg='#567').grid(row=2, columnspan=2)

# label & Entry boxes territory
nameLb = Label(ws, text="Enter Your Name", pady=15, padx=10, bg='#567')
nameTf = Entry(ws)

# button territory
welBtn = Button(ws, text="ClickMe!", command=welcome)

# Position Provide territory
nameLb.grid(row=0, column=0)
nameTf.grid(row=0, column=1)
welBtn.grid(row=1, columnspan=2)

# infinite loop 
ws.mainloop()

本节目仅供参考。本博客结束时，你将能够编写基于图形用户界面的软件。
在继续之前，让我们了解一下基于 tkinter 的应用程序的流程。

python tkinter example

上面提到的程序是以同样的顺序完成的&这个顺序在每个 Tkinter 初学者程序中都要遵循。这保持了代码的整洁和有序。

导入必要的模块或库。
工作区是使用ws = Tk()创建的，这里的ws可以替换为任意名称。最常见的 ws 替换有根、窗、赢、主、等。这完全是你自己的参考，在我们的情况下，它意味着工作空间。
需要一个无限循环来支撑屏幕。如果没有这个循环，屏幕将会立即飞溅&消失。
标签、输入框和按钮是部件。我们将在课程的后面详细研究它们。
按钮区域包含所有的按钮。
如图所示，小部件有 3 个部分。

python gui programming.

变量是分配给小工具的名称。在小部件上执行的所有活动都将存储在这个名称下。这个名称可以在以后用来指代这个小部件。
Widgets 是标签、条目、按钮、消息、复选按钮、单选按钮等。他们有专门的任务要完成。除了这个任务之外，它们还可以配置额外的工具，如颜色、字体等。
几何指的是小部件的位置。Tkinter 有 3 种类型的几何图形(包装、网格、位置)。它们中的每一个都有不同的放置小部件的方式。会在后面的课程中详细介绍。

Python Tkinter widgets

GUI 完全是关于小部件的，因为 Python Tkinter 小部件为我们提供了控件，用户使用这些控件与我们的应用程序进行交互。
标签、文本框、列表框、按钮、菜单、等被称为控件。每个小部件都有自己的属性。
有 10 种类型的 Python Tkinter 小部件，我已经逐一解释过了(有例子)。
ws 代表父窗口。

Python tkinter 标签

一个 Python tkinter 标签是一段简单的文本或信息。
标签是一个非常常见且广泛使用的小部件。
标签是创建任何应用程序之前使用的第一个小部件。

语法:

Label(ws, text=value )

举例:

这是 Label 的实现。在这里，文本被赋值为“输入名称”。

代码:

from tkinter import *

ws = Tk()

nameLb = Label(ws, text="Enter Name")
nameLb.pack()

ws.mainloop()

输出:

输入名称是在标签中分配的值，因此它显示在此处。

python tkinter example

Python tkinter 条目

让我们来讨论一下 Python tkinter 入口。

输入框用于接收用户输入。
这是另一个广泛使用的小部件。

语法:

Entry(ws)

举例:

这是输入框的实现。它将显示一个空框，准备由用户填充。

代码:

from tkinter import *

ws = Tk()

nameTf = Entry(ws)
nameTf.pack()

ws.mainloop()

输出:

输出显示一个空文本框，在这里输入文本！”是用户写的。

Python tkinter Entry

Python tkinter Button

让我们来讨论一下 Python tkinter 按钮。

按钮触发动作。
Button 将 command 作为一个参数，这很神奇。

语法:

Button(ws, command=<action>)

举例:

这是 Button 的实现。提供的显示文本是“提交，传递的命令是函数:提交。点击按钮将触发功能。

代码:

from tkinter import *

ws = Tk()

def submit():
    return Label(ws, text="Submitted!").pack()

submitBtn = Button(ws, text="submit", command=submit)
submitBtn.pack()

ws.mainloop()

输出:

该功能是创建另一个标签，其文本为“已提交”。因此输出显示了按钮下面的小文本。它是在单击按钮后创建的。

Python tkinter Button

Python tkinter 消息框

Python 消息框是一个带有消息的弹出框。
要使用消息框，导入消息框模块。
有六种类型的消息提示，例如:
- showinfo : 用声音显示消息。返回“确定”
- 显示警告:用声音显示警告信息。返回“确定”
- 显示错误:用声音显示错误信息。返回“确定”
- askquestion : 提示“是”、“否”选项。返回是或否
- 询问是否:提示“是”、“否”选项。是返回 1，否返回 0
- askretrycancel : 提示选择“重试或“取消。带声音重试返回 1 和取消返回 0

语法:

messagebox.function(title, message)

举例:

下面是使用 python tkinter 的所有消息框的例子。所有类型的消息都放在一个功能下，只需一个按钮即可触发。

代码:

from tkinter import *
from tkinter import messagebox

ws = Tk()

def prompts():
    messagebox.showinfo("showinfo", "Hi there!")
    messagebox.showwarning("showinfo", "Hi there!")
    messagebox.showerror("showinfo", "Hi there!")
    messagebox.askquestion("showinfo", "Hi there!")
    messagebox.askyesno("showinfo", "Hi there!")
    messagebox.askretrycancel("showinfo", "Hi there!")

Button(ws, text="Click Me!", command=prompts).pack()

ws.mainloop()

输出:

点击我的那一刻！按下按钮，这些提示开始按顺序出现。

python tkinter message box

Python tkinter 复选框

Python 复选框是一个选择小部件。
可以选择多个项目。
返回类型可以是字符串或整数。
对于整数，我们可以用 IntVar() 。
对于字符串，我们可以使用 StringVar() 。

语法:

var = IntVar()
Checkbutton(ws, text= , variable=var).pack()

举例:

这是 check 按钮的实现。这里提供了备茶的多种选择。用户可以根据自己的喜好选中它们。

from tkinter import *

ws = Tk()
Label(ws, text="Tea", font=(24)).pack()
var1 = IntVar()
Checkbutton(ws, text="Milk", variable=var1).pack()
var2 = IntVar()
Checkbutton(ws, text="Sugar", variable=var2).pack()
var3 = IntVar()
Checkbutton(ws, text="Ginger", variable=var3).pack()
var4 = IntVar()
Checkbutton(ws, text="Lemon", variable=var4).pack()

ws.mainloop()

输出:

在这个输出中，用户选择只用牛奶、糖和姜来泡茶。既然柠檬没有被选中，那么就不考虑了。

Python tkinter checkbox

Python tkinter 单选按钮

Python tkinter Radiobutton 是另一个类似复选框的选择部件
它只允许单项选择。
返回类型可以是字符串或整数。
对于整数值，我们可以使用 IntVar() 。
对于字符串值，我们可以使用 StringVar() 。
相同的变量被分配给所有的单选按钮，以便将它们放在一个组中。

语法:

var = IntVar()
Radiobutton(ws, text= ,variable=var, value= ).pack()

如果值是字符串，那么用字符串变量()替换整型变量()。

举例:

Radiobutton 仅用于单项选择。所以这里我们假设一个候选人已经收到了所有提到的公司的聘书，但是问题是他只能加入一家公司。所以他有很多选择。

代码:

from tkinter import *

ws = Tk()

var = IntVar()
Label(ws, text="Choose one", font=(18)).pack()
Radiobutton(ws, text="Google", variable=var, value=1).pack()
Radiobutton(ws, text="Facebook", variable=var, value=2).pack()
Radiobutton(ws, text="Amazon", variable=var, value=3).pack()
Radiobutton(ws, text="Microsoft", variable=var, value=4).pack()

ws.mainloop()

输出:

所以候选人选择了谷歌。Google 单选按钮被选中。

Python tkinter radiobutton

Python tkinter 列表框

Python tkinter listbox 也是一个选择小部件。
项目显示在小部件框中。
它提供了滚动功能。

语法:

var_name = Listbox(ws)
var_name.pack()

var_name.insert(index, value)

举例:

在这个军队字母表使用列表框列出。

代码:

from tkinter import *

ws = Tk()
ws.geometry("300x300")

alphabets = Listbox(ws)
alphabets.pack()

alphabets.insert(0, "Alpha")
alphabets.insert(1, "Bravo")
alphabets.insert(2, "Charlie")
alphabets.insert(3, "Delta")

ws.mainloop()

输出:

显示军队字母表列表。用户可以选择单个或多个选项

Python tkinter listbox

Python tkinter 选项菜单

让我们来看一个关于 Python tkinter optionmenu 的例子。

OptionMenu 按钮类似于列表框。
它以下拉格式显示项目。
可以放在更小的空间里。

语法:

var-name = StringVar()
alphabets = Optionmenu(ws, var-name, "item-1", "item-2", "item-n")
alphabets.pack()

举例:

这是 optionmenu 的实现，其中军队字母用于以下拉形式显示。

代码:

from tkinter import *

ws = Tk()
ws.geometry("200x100")

items = StringVar()
items.set("Alpha")

alphabets = OptionMenu(ws,items, "Alpha", "Bravo", "Charlie", "Delta")
alphabets.pack()

ws.mainloop()

输出:

在 Optionmenu 的这个实现中。Alpha 设置为默认值。当用户点击这个框时，选项显示如下。

python tkinter optionmenu

Python tkinter 标签帧

让我们看看如何使用 Python tkinter labelframe 。

它向当前窗口添加一个框架。
它用于创建区段或组。
它改进了 gui。

语法:

var-name = LabelFrame(ws, text=value)
var-name.pack()

举例:

这是 LabelFrame 的实现。这里的性别&食物是几节。

代码:

from tkinter import *

ws = Tk()

genF = LabelFrame(ws, text="Gender")
genF.pack()

var = IntVar()
Radiobutton(genF, text="Male", variable=var, value=1).pack()
Radiobutton(genF, text="Female", variable=var, value=2).pack()

food = LabelFrame(ws, text="Food")
food.pack()
Checkbutton(food, text="snacks").pack()
Checkbutton(food, text="Drinks").pack()
Checkbutton(food, text="Meal").pack()

ws.mainloop()

输出:

LabelFrame 已经使这个输出不言自明。现在我们既然有两节性别&的食物。&每个部分都有项目。

Python tkinter labelframe

Python tkinter 菜单是窗口左上角的选项
这些选项提供了各种各样的控制。
文件、编辑、帮助等是每个窗口中的一些基本选项。

语法:

var-name = Menu(ws, command=<action>)
ws.config(menu=var-name)

举例:

这是 Python 菜单栏的实现。创建了三个流行的菜单(文件、编辑、帮助),当用户点击它们时，会在终端或命令行上显示一条消息。

代码:

from tkinter import *

ws = Tk()  

def fileSec():  
    print("File section")  

def editSec():  
    print("Edit section")  

def helpSec():  
    print("Help section")  

mb = Menu(ws)  
mb.add_command(label="File", command=fileSec)  
mb.add_command(label="Edit", command=editSec) 
mb.add_command(label="Help", command=helpSec)   

ws.config(menu=mb)  

ws.mainloop()

输出:

这是菜单栏的实现。在左上角，你会看到菜单。文件、编辑和帮助。

Python tkinter Menu

几何管理

有三种类型的 Python 几何管理如:

打包
网格
地点

1.打包

该包是一个几何管理器。
它填满了空间&粘在中间，
这对于小型应用程序来说很好。
人们可以很快从这个包开始，因为它不需要参数。

语法:

widget.pack()

举例:

这是包的实现。这里使用了 4 个标签来显示消息。

代码:

from tkinter import *

ws = Tk()

Label(ws, text="Placing").pack()
Label(ws, text="Text ").pack()
Label(ws, text="using ").pack()
Label(ws, text="Pack is fun").pack()

ws.mainloop()

输出:

Pack 在屏幕中央自动调整，因此在下一张图像中，您可以看到，即使在调整图像大小后，pack 文本仍在中央。

python gui programming with tkinter

2.网格

Grid 以表格形式维护小部件。
如果调整了窗口的大小，它会停留在左上方。
网格需要 2 个必要的参数:行 & 列。
以下是行和列的解释。

python gui programming with tkinter

语法:

widget.grid(row= value ,column= value )

所以在这里，值等于您想要提供给行 & 列的数字。

举例:

这是网格的实现。 Python 网格以行&列格式工作。

代码:

from tkinter import *

ws = Tk()

Button(ws, text="These buttons").grid(row=0, column=0)
Button(ws, text="are positioned").grid(row=0, column=1)
Button(ws, text="using Grid").grid(row=0, column=2)

Button(ws, text="This is ").grid(row=1, column=0)
Button(ws, text="another line").grid(row=1, column=1)
Button(ws, text="using Grid").grid(row=1, column=2)

ws.mainloop()

输出:

使用网格显示六个按钮。每个按钮都有其行和值。

3.地点

Place 用于为小部件提供固定位置。
它为用户提供最大限度的控制。
微件保持在指定的位置
x & y 值带有锚。
锚有 8 种变化
- 东北方向
- 北:北
- 西北方向:西北方向
- 东:东
- 西方
- 东南 : 东南
- 西南方:西南方
- 南方:南方

语法:

widget.place(x = value,  y = value, anchor=location )

举例:

这是执行的地方。地点需要 x 和 y 坐标。

代码:

from tkinter import *

ws = Tk()
ws.geometry("300x300")

Button(ws, text="North-West").place(x=50, y=20, anchor="center")
Button(ws, text="North").place(x=148, y=20, anchor="center")
Button(ws, text="North-South").place(x=250, y=20, anchor="center")
Button(ws, text="East").place(x=50, y=148, anchor="center")
Button(ws, text="West").place(x=250, y=148, anchor="center")
Button(ws, text="South-East").place(x=50, y=250, anchor="center")
Button(ws, text="South").place(x=148, y=250, anchor="center")
Button(ws, text="South-West").place(x=250, y=250, anchor="center")
Button(ws, text="Center").place(x=148, y=148, anchor="center")

ws.mainloop()

输出:

这里，屏幕上实现了九个按钮。每一个都放在方向上，即北、南、东、西等。

python gui programming with tkinter

包装、网格和位置之间的差异

下表显示了 Python 包、网格和位置之间的区别。

打包	网格	地方
Pack 在序列中定位小部件。
一个接一个。	网格以行和列的方式放置小部件	将点部件放在用户想要的地方。
包不需要强制参数	网格要求用户将行和列作为参数	Place 需要 x & y 坐标作为参数
调整窗口大小时，窗口小部件会保持居中。	当窗口调整大小时，窗口小部件贴在左上角	一切都保持在它的位置。如果窗口缩小到小于，窗口小部件将开始消失。
小部件定位没有手动控制	它提供了对小部件定位的更多控制	它允许将小工具准确地放置在用户想要的位置。
place 便于快速使用，因为它易于实现。它不允许控制部件的位置。	它以表格的形式工作。因此，行和列中提供的值可以定位小部件。	Place 最擅长将小部件定位在 x & y 坐标中定义的精确位置

使用 Python Tkinter 的迷你项目

让我们开发一个小的 Python 项目。

这是一个使用 Python Tkinter 的简单登录和注册机制。您可以使用代码进行进一步开发。该计划基于您在上面学到的主题。

第一步。这是将出现的第一页。在您继续之前，需要用户名&密码。默认用户名为“python”&密码为“导游”。

python tkinter control

第二步。 如果您输入了错误的凭证，即用户名或密码，则会出现错误消息框。如果您没有电子邮件和密码，您可以使用注册按钮创建一个。

python tkinter tutorial

第三步。 填写表格并按下注册键。它提示的信息消息说注册成功，这意味着你现在注册。

python tkinter example

第四步。 如果凭证即用户名&密码正确，信息消息框将显示消息“登录成功”。

python tkinter examples

代码:

# import module
from tkinter import *
from tkinter import messagebox

# configure 
ws = Tk()
ws.title("Login Page")
ws.geometry("300x250")

# functions
def checkCred():
    email = email_tf.get()
    pwd = pwd_tf.get()
    print(email, pwd)
    if email == "python" and pwd == "guides":
        return messagebox.showinfo("Login", "Login Sucessfully!")
    else:
        return messagebox.showerror("Login", "Login Failed!")
def success_msg():
    return messagebox.showinfo("Signup", "Sign-up Successfully")

def register():
    ws = Tk()
    ws.title("Register")
    ws.geometry("300x250")

    Label(ws, text="Enter Name").place(x=50, y=20, anchor="center")
    nTf =Entry(ws).place(x=170, y=20, anchor=CENTER)
    Label(ws, text="Enter Email").place(x=50, y=60, anchor=CENTER)
    eTf = Entry(ws).place(x=170, y=60, anchor=CENTER)
    Label(ws, text="Password").place(x=50, y=100, anchor=CENTER)
    pTf = Entry(ws).place(x=170, y=100, anchor=CENTER)
    Label(ws, text="re-enter Password").place(x=50, y=140, anchor=CENTER)
    rpTf = Entry(ws).place(x=170, y=140, anchor=CENTER)
    Button(ws, text="Register", command=success_msg).place(x=100, y=180, anchor=CENTER)

# write code
email_lb = Label(ws,text="Enter Email")
email_tf = Entry(ws)
pwd_lb = Label(ws,text="Enter Password")
pwd_tf = Entry(ws)
login_btn = Button(ws, text="Login", command=checkCred)
reg_btn = Button(ws, text="Register", command=register)

# placeholders
email_lb.place(x=50, y=40, anchor=CENTER)
email_tf.place(x=170, y=40, anchor=CENTER)
pwd_lb.place(x=50, y=80, anchor=CENTER)
pwd_tf.place(x=170, y=80, anchor=CENTER)
login_btn.place(x=100, y=120, anchor=CENTER)
reg_btn.place(x=180, y=120, anchor=CENTER)

# infinite loop
ws.mainloop()

使用 python Tkinter 的 10 个最佳项目创意

下面是使用 tkinter 的 Python 项目列表。

使用 python Tkinter 的石头剪刀布游戏
使用 Python Tkinter 的基本小部件的电子邮件界面
带有太阳图像的数字时钟，每小时变化一次。
密码管理器，使用 Python Tkinter & SQLite 数据库
使用 Python Tkinter 的密码生成器。
使用 python Tkinter 的彩票系统。
投掷系统可以选择任意数量的赢家。
使用 Python Tkinter 的井字游戏
使用 Python Tkinter 的计费管理系统
带有数据库的秒表稍后使用机器学习执行数据分析。

您可能会喜欢以下 Python 教程:

在这个 Python 教程中，我们学习了 Python Gui 编程。

使用 python 的 GUI
下载并安装 Tkinter
使用 Tkinter 创建第一个程序
Python Tkinter 小部件
几何管理(包装、网格、位置)
包装、网格和位置之间的差异
使用 Python Tkinter 的迷你项目
使用 python Tkinter 的 10 个最佳项目创意

Python Hello World 程序(逐步使用 Pycharm + Visual Studio 代码)

原文：https://pythonguides.com/python-hello-world-program/

在本 python 教程中，我们将使用 Pycharm 和 Visual studio 代码构建我们的第一个传统的 Python Hello world 程序。如果你想让作为初学者学习 Python，那么让我们使用 vscode 和 pycharm 用 Python 创建一个 hello world 程序。

任何编辑器(Pycharm 或 Visual Studio 代码)，您都可以用它来编写 Python 代码。

这是一个循序渐进的教程，使用 Pycharm 和 Visual Studio 代码用 Python 创建你的第一个 hello world 程序。

如果你想学习 Python 和机器学习，加入 Python 和机器学习培训班。

使用 Python 3.8 和 Pycharm 2020 的 Python Hello World 程序
在命令提示符下运行 Python 文件
使用 Visual Studio 代码用 Python 创建一个 hello world 程序
- 什么是 Visual Studio 代码？
在 Windows 10 中下载并安装 Visual Studio 代码
- 安装 Visual Studio 代码的 Python 扩展
- 使用 Visual Studio 代码用 python 创建 hello world 程序
结论

使用 Python 3.8 和 Pycharm 2020 的 Python Hello World 程序

我已经安装了 python 版本 3.8.2 和 Pycharm 版本 20201 作为代码编辑器，我们将使用它们来构建第一个程序。

现在我们的 python 安装好了，代码编辑器( Pycharm )也安装在我的机器上。两者都是截至 2020 年 4 月的最新版本。让我们开始第一个节目。

第一步:

打开 Pycharm 代码编辑器

Python Hello World program

第二步:

现在接下来是点击“创建新项目按钮。

pycharm hello world

第三步:

在这一步中，首先给项目起一个有意义的名字。我给它起了个名字“Helloworld”。您也可以更改您的首选位置。基本解释器将自动填充。现在请点击“创建”按钮。

Python Hello World Program

第四步:

现在下面的弹出窗口将会出现，你可以关闭弹出的每日提示窗口。

python hello world pycharm

第五步:

现在下面的弹出窗口显示了一些有用的信息。见过一次。其中更重要的一点是，你可以将文件拖放到那里，这样它就可以打开了。

hello world python pycharm

第六步:

在这一步中点击文件–>–新建暂存文件。

Python Hello World Program

第七步:

现在从弹出的新暂存文件中选择“ Python ”。

hello world program in python using pycharm

第八步:

现在看下面一个名为 scratch.py 的 python 文件被创建。

hello world in pycharm

第九步:

现在给文件起一个有意义的全名。所以我们需要重命名这个文件。右键点击 Scratch.py ，选择重命名文件。

print hello world in pycharm

第十步:

下面会出现重命名弹出框，给一个合适的名字。在本例中，我将名称命名为 Helloworld.py。

Python Hello World Program

第十一步:

现在，看到文件名已经被重命名为“Helloworld.py”。所以现在我们的空 python 文件已经准备好了。

python 3.8 hello world

第十二步:

现在将下面的代码写入 Helloworld.py 文件，然后点击运行–>运行选项。你也可以使用键盘快捷键 Alt+Shift+F10 来运行文件。

Print("Hello world!!")

python hello world program

第十三步:

糟糕，在执行上面的代码时，它抛出了下面的错误

Traceback (most recent call last):
  File "C:/Users/Bijay/AppData/Roaming/JetBrains/PyCharmCE2020.1/scratches/Helloworld.py", line 1, in <module>
    Print('Hello world!!')
NameError: name 'Print' is not defined

任何猜测为什么上述错误。这是因为我们输入了 print 作为 Print(caps P)。正确的应该是 print()。

注意: Python 区分大小写。

正确的代码如下所示。

print(Hello world!!)

现在输入上面的代码并运行文件。让我们看看发生了什么。现在，如果你注意到这里的运行选项是运行“HelloWorld ”,这意味着运行“文件名”。

现在当我把 Print(caps P)改成 Print()时。如果您看到下面的自动建议框显示打印功能。

pycharm hello world program

现在让我们运行程序。

Python Hello World Program

第 14 步:

恭喜，是的，这次我得到了预期的输出，没有任何错误。见下文。

hello world pycharm

Python While 循环示例

在命令提示符下运行 Python 文件

如果您的机器上没有安装 Pycharm，还有一种方法可以从命令提示符下运行 python 文件。

第一步:

打开命令提示符，转到 python 文件所在的路径。为此，请使用下面的命令并按回车键。

cd C:\Users\Bijay\AppData\Roaming\JetBrains\PyCharmCE2020.1\scratches

注意:C:\ Users \ Bijay \ AppData \ Roaming \ JetBrains \ pycharmce 2020.1 \ scratches 是我的 HelloWorld.py 文件所在的路径。所以我需要去那个路径并执行代码。

第二步:

现在输入文件名，即 Helloworld.py，然后按回车键。如下所示，我们得到了预期的输出。

Run your Python file from the command prompt

这就是我们如何在 Pycharm 中使用 Python 创建第一个 hello world 程序的方法。

使用 Visual Studio 代码用 Python 创建一个 hello world 程序

现在，让我们看看如何用 python 创建一个 hello world 程序，并且，我们还将看到如何在 windows 10 中下载和安装 visual studio 代码。

什么是 Visual Studio 代码？

微软提供了一个 Visual Studio 代码的免费开源代码编辑器。它又快又简单。Visual Studio 代码支持所有三种操作系统，如 Windows、Linux 和 macOS。

它有许多内置功能，如 GitHub、调试和嵌入式 Git 控件、语法高亮、代码片段和智能代码完成。此外，您可以根据需要添加扩展来创建 Python 开发环境。

VS 代码是轻量级的，它有许多强大的特性。这就是它在 Python 开发者中流行的原因。Visual studio 代码是一个代码编辑器，可以用于 python 开发。这不仅对 python 有意义，它也支持其他语言。

在 Windows 10 中下载并安装 Visual Studio 代码

我们来看看如何下载安装免费的 visual studio 代码 (VS 代码)。

第一步

首先下载 visual studio 代码。基于操作系统，可以下载 VS 代码。

visual studio code

第二步

下载后打开 VS 代码然后接受协议点击下一步。
单击“下一步”后，将出现一个默认位置。如果您不想更改默认位置，则点击下一个的。

download and install vs code

第三步

现在点击“创建桌面图标”，以便可以从桌面访问它，然后点击下一步。

visual studio code

第四步

之后，点击安装按钮。它将开始安装 VS 代码。

visual studio code for python

第五步

最后，安装完成，默认情况下, Launch Visual Studio 代码将带有复选标记。点击完成按钮，visual studio 代码将打开。

visual studio code for python

第六步

现在你可以看到 Visual Studio 代码已经在 windows 10 上启动了。

Python Extension for Visual Studio Code

安装 Visual Studio 代码的 Python 扩展

要安装扩展，打开左侧的扩展菜单，在搜索空间“Python”上写。

然后选择弹出的第一个，可以点击安装对应的扩展。

Python Extension for Visual Studio Code

阅读人工智能完全指南

使用 Visual Studio 代码用 python 创建 hello world 程序

现在，我们将看到如何用 vs 代码在 python 中创建 hello world 程序。

打开 visual studio 代码。然后档->-新档。

然后在文件中编写以下代码:

msg = "Hello World"
print(msg)

然后保存文件 Ctrl+S 然后用给一个文件名。py 扩展并将类型保存为 Python。

visual studio code python hello world

该文件将如下所示:

hello world python visual studio code

要运行代码，在编辑器窗口的任意位置右键单击并选择在终端中运行 Python 文件。

vscode python hello world

输出:

您可以在终端中看到如下输出:

python hello world visual studio code

你也可以使用命令行手动运行代码，只需在终端中编写文件的 python 和路径。

vs code python hello world

下面你可以看到，我写完 python 后复制了文件的路径。

python E:\project-python\HelloWorld.py

create hello world program in python

现在，如果你输入，你将会看到输出。

python hello world vscode

我们可以按照上面的步骤用 visual studio 代码用 python 创建 hello world 程序。以及如何在 windows 10 中下载并安装 Visual Studio 代码，同时我们也看到了如何在 vs 代码中安装 Python 扩展。

您可能会喜欢以下 Python 教程:

结论

我希望这篇文章能帮助你用 Python 创建一个 hollo world 程序。

用 Python 创建一个 hello world 程序
使用 python 3.8 和 Pycharm 2020 的 Python Hello World 程序
从命令提示符运行 Python 文件
使用 Visual Studio 代码用 Python 创建一个 hello world 程序
Visual studio 代码下载和安装
为 Visual Studio 代码安装 Python 扩展

Python if else 示例

原文：https://pythonguides.com/python-if-else/

在这个 Python 教程中，让我们讨论一下 Python 中的 if else 语句，以及 if else 语句在 Python 中是如何工作的。

我们还将检查:

Python if 语句
Python else 语句
Python elif 语句
Python 嵌套 if 语句

Python if 语句
Python else 语句
Python elif 语句
Python 嵌套 if 语句

Python if 语句

在 python 中， if 语句用于检查语句是真还是假，只有当语句为真时才运行代码。

举例:

x = 10
y = 150
if y > x:
print("y is greater than x")

编写上述代码(python if 语句)后，您将打印这些代码，然后输出将显示为“y 大于 x”。这里，if 语句检查条件，如果条件为真，则运行代码。

可以参考下面 python if 语句的截图。

Python if statement

这是 Python if 语句的一个简单例子。

你可以查看一下，如何使用 Python 中的 Pandas drop()函数。

Python else 语句

在 python 中， else 语句包含当 if 条件语句为假时执行的代码块。

举例:

x = 34
y = 30
if y > x:
print("y is greater than x")
else:
print("y is not greater than x")

写完上面的代码(python else 语句)后，你要打印的代码输出将显示为“y 不大于 x”。这里，当 if 条件为假时，else 语句执行，然后 else 语句执行。

你可以参考下面 python else 语句的截图。

Python else statement

Python elif 语句

在 python 中， elif 语句用于检查多个表达式，如果前面的条件不为真，那么试试这个。

举例:

x = 21
y = 21
if y > x:
print("y is greater than x")
elif x == y:
print("x and y are equal")

在编写完上述代码(python elif 语句)后，您将打印这些代码，然后输出将显示为“x 和 y 相等”。这里，当前面的条件不为真时，执行 elif 语句，然后执行 elif 语句。

你可以参考下面 python elif 语句的截图。

Python elif statement

Python 嵌套 if 语句

在 python 中，我们使用嵌套的 if 语句来检查第一条语句的计算结果是否为真，以及嵌套语句的计算结果是否为真。

举例:

x = 25
if x > 12:
print("Above 12,")
if x > 20:
print("and also above 20")
else:
print("but not above 20")

在编写了上面的代码(python 嵌套 if 语句)之后，您将打印这些代码，然后输出将显示为大于 12 的"以及大于 20 的"。这里，我们在 if 语句中有 if 语句。

可以参考下面 python 嵌套 if 语句的截图。

Python nested if statement

您可能会喜欢以下 Python 教程:

在本 python 教程中，我们学习了 Python 中的各种 if else 语句，例如:

Python if 语句
Python else 语句
Python elif 语句
Python 嵌套 if 语句

Python 输入和 raw_input 函数

原文：https://pythonguides.com/python-input-and-raw_input-function/

在本 python 教程中，您将了解到 Python input()和 raw_input()函数，input()和 raw_input() 之间的区别以及示例，我们还将看到 python 名称错误:名称 raw_input 未定义。

为什么我们在 python 中需要 input()和 raw_input()函数？
Python 输入()函数
Python raw_input()函数
python 中 input()和 raw_input()函数的区别
Python raw_input 示例
Python raw_input 超时
Python raw_input 默认值
Python raw_input 转义键
Python raw_input 不工作
Python raw_input argv
Python raw_input 隐藏密码
Python 名称错误:名称 raw_input 未定义

为什么我们在 python 中需要 input()和 raw_input()函数？

主要原因是交互式的用户友好代码。它使代码具有交互性，而不是硬编码。我们使用 input() 和 raw_input() 函数根据用户自己的值接受用户输入。

Python 输入()函数

python input()函数从用户处获取值。调用这个函数来告诉程序停止并等待用户输入值。它读取输入并返回 python 类型，如 int、list、tuple 等。

举例:python 2 中的程序

value = input("Enter your name:")
print(type(value)
print(value)

写完上面的代码(python input()函数)，你将打印出 " value " ，然后输出将显示为"输入你的名字:娜萨< class 'str' >娜萨"。这里，它要求用户输入值，然后读取输入并返回用户输入的输入类型。我们不需要显式地改变 python2 中的变量类型。

可以参考下面截图 python input()函数

Python input() function

在 python 2.x 和 3.x 版本中都使用了 Python input()函数。在 Python 3.x 中，input 函数明确地将您给定的输入转换为字符串类型，否则在 Python 3 中，输入函数存储的值总是字符串。但是在 python 2.x 中，函数接受值，您输入的输入将照原样接受，而不修改其类型。

举例:python 3 中的程序

value = input("Enter the roll: ")
value = int(value)
print(type(value)
print(value)

写完上面的代码(python input()函数)后，一旦你将打印 " value " 那么输出将显示为"输入你的掷骰子:23065 <类' int' > 23065 " 。这里，它要求用户输入 roll，然后它读取输入并返回用户输入的输入类型。此外，我们将变量的类型指定为整数。

可以参考下面截图 python input()函数

Python input() function

Python raw_input()函数

Python raw_input()函数读取输入并返回一个字符串。它用于从用户那里获取价值。该输入函数仅在 Python 2.x 版本中使用。

Python 2.x 有两个函数从用户那里获取值。第一个是 input，第二个是 raw_input 函数。raw_input()函数类似于 python3 中的 input()函数。

举例:python 2 中的程序

value = raw_input("Enter your name: ")
print(type(value))
print(value)

在输出中，你可以看到它的类型是一个字符串。对于 raw_input() 函数，存储的值的类型始终是字符串。

输出:

Enter your name: Trisha
<type 'str'>
Trisha

在这里，在 python2 中，我们将看到我们是否想要整数形式的输出，然后，我们必须使用 raw_input() 函数中的 "int" 将类型转换为整数。

举例:

value = raw_input("Enter the roll: ")
value = int(value)
print(type(value)
print(value)

这里，值 "20564" 取自用户，但是我们使用 int() 将类型转换为整数。一旦你打印出“值”，你将得到变量及其类型。您可以看到下面的输出。

输出:

Enter the roll: 20564
<type 'int'>
20564

python 中 input()和 raw_input()函数的区别

让我们讨论一下 python 中 input()和 raw_input()函数的区别。

raw_input 函数是在 python 2 中构建的。但是在 python3 中我们没有。
raw_input 函数的工作方式与 python3 中的 input 函数相同。
在 python 2 中， input()函数首先用于获取 raw_input()，然后在其中执行 eval()。
在 python 2 中， raw_input() 返回一个字符串，而 input()返回一个求值结果。而在 python 3 中，input()返回一个字符串，但可以转换成任何类型。

Python raw_input 示例

让我们看看如何在 Python 中使用 input 和 raw_input 函数。
在 python 中有两个从用户那里获取输入的函数，即 input 和 raw_input 函数。这两个函数都用于获取用户的输入。
在 python 2 版本中使用 raw_input()函数，在 Python 3 版本中使用 input()函数

举例:

以下是 raw_input 函数的示例

new_val = raw_input("Enter name:") # raw_input function

print(type(new_val)) #python version 2.7
print(new_val)

Python raw_input function

Python raw_input 超时

在这里，我们可以检查我们是否需要用户输入，我们将使用 input()函数。在这个例子中，我们将给出条件，如果没有输入，那么它将显示结果“超时”。

源代码:

import sys
from select import select

raw_timeout = 5
print ("Enter the string:",)
new_lis, _, _ = select([sys.stdin], [], [], raw_timeout)
if new_lis:
    val = sys.stdin.readline()
    print (val)
else:
    print ("No string.....timeout")

首先在上面的代码中，我们将导入一个“sys”库，因为这是从用户那里获取输入的标准方式。现在创建一个变量‘raw _ time out’，并给它们赋值。

下面是以下给定代码的执行过程

Python raw_input timeout

Python raw_input 默认值

要获取 raw_input 并设置默认值，我们可以使用 try-except 块和 import readline 模块。在本例中，用户按下‘enter’关键字，直到 Python 编程’值存储在‘最佳语言’变量中。

举例:

 import readline
def new_input(new_tex, fill_val=''):
   readline.set_startup_hook(lambda: readline.insert_text(fill_val))
   try:
      return raw_input(new_tex)
   finally:
      readline.set_startup_hook()

new_def_val = "Python Programming"
output = new_input("language: ", new_def_val)
print("best langauge: " + output)

下面是以下给定代码的执行过程

Python raw_input default value

Python raw_input 转义键

在本例中，用户输入一个字符并按下“enter”关键字。现在，我将允许用户通过简单地按下键盘上的‘escape’键来退出输出。
为了完成这项任务，我们将导入一个‘pynput’模块。该模块允许用户控制和监控输入设备。它包含像键盘和监听器这样的子包。

import pynput
from pynput import keyboard

def initialize():
     print("Enter name: Java")
def on_press(new_key):
    if new_key == keyboard.Key.esc:

        return False
    else:
         initialize()

with keyboard.Listener(
        on_press=on_press) as listener:
    listener.join()

输出:

Python raw_input escape key

Python raw_input 不工作

在 Python 3 版本中，Raw_input 不起作用。您可以使用 input()函数代替 raw_input()。input 函数具有相同的功能来接受用户的输入。
如果您正在使用 raw_input()函数，那么请安装 Python 的先前版本，即 python 2.7。

代码:

new_variable = raw_input("Enter name:") 

print(type(new_variable)) # python3 version
print(new_variable)

实施:

Python raw_input not working

正如您所看到的，输出中有一条错误消息，这意味着 raw_ input 在 Python 3 中不起作用。

解决方案:

Solution for raw_input not working in python

Python raw_input argv

让我们看看如何在 Python 中使用 argv。基本上，argv 是一个命令行参数列表。为了计算脚本中参数的数量，我们可以使用这个函数。

举例:

from sys import argv

new_script, emp_name, emp_id, emp_code = argv,raw_input("Enter the employee name: "), raw_input("Enter the employee id: "), raw_input("Enter the employee code: ")

print ("script is called:", new_script)
print ("first value is:", emp_name)
print ("second value is:", emp_id)
print ("third value is:", emp_code)

下面是以下给定代码的执行过程

Python raw_input argv

Python raw_input 隐藏密码

让我们看另一个 Python raw_input 隐藏密码的例子。

程序:

res = True

while res:
    print("""(a).close!
                   (b). numbers!""")

    res=raw_input("""Enter a Value: """)

    if res == "a":

        exit()
    elif res == "b":

        new_pas=raw_input("""Enter the Password: """)

        if new_pas == "Pythonguides":

            print("""(a). password (b).close""")

            paswr=raw_input ("""Again Enter a Value: """)

            if paswr == "a":
                print ("""Password Is Spguides""")
                import time
                time.sleep(1)
                exit()

            elif paswr == "b":
                exit()

            else:
                print("""You Have Entered the Incorrect value. Not executing the Programm""")
                import time
                time.sleep(1)
                exit()

        else:
                print("""You Have Entered the Incorrect Password. Not executing the Programm""")
                import time
                time.sleep(1)
                exit()

下面是以下代码的截图

Python raw_input hide password

Python 名称错误:名称 raw_input 未定义

我们得到这个名错误是因为 python 版本。在 python3.x 中， input() 代替了 raw_input() ，用于控制台的输入。所以我们得到这个错误名称‘raw _ input’没有在 python3 中定义。

举例:

value = raw_input("Enter the name: ")
print(type(value))
print(value)

写完上面的代码后(python nameerror: name raw_input 未定义)，你会打印出“value”然后错误会显示为“name error:name raw _ input 未定义”。这里，我们得到这个错误，因为它在 python3 中没有 raw_input()。

您可以参考下面的 python 名称截图错误:名称 raw_input 未定义

Python NameError: name raw_input not defined

为了解决这个错误，我们可以使用 input() 代替 python3 中的 raw_input()来避免这个错误。否则，如果你想使用 raw_input() 函数，我们有 python2。

举例:

value = input("Enter the name: ")
print(type(value))
print(value)

写完上面的代码后，一旦你打印出 " value " ，那么输出将显示为一个"输入名字:John < class 'str' > John " 。这里，错误是通过使用 python3 中的“input()”函数解决的，该函数的工作方式与 python2 中的 raw_input()类似。

可以参考下面截图名称 raw_input 未定义

Python NameError: name raw_input not defined

您可能会喜欢以下 Python 教程:

在本教程中，我们学习了、Python input()和 raw_input()函数、input()和 raw_input() 之间的关键区别以及以下主题:

python 中为什么需要 input()和 raw_input()函数？
Python 输入()函数
Python raw_input()函数
python 中 input()和 raw_input()函数的区别
Python raw_input 示例
Python 原始输入超时
Python raw_input 默认值
Python raw_input 转义键
Python 原始输入不起作用
Python raw_input argv
Python 原始输入隐藏密码
Python 名称错误:未定义名称 raw_input

Python 接口介绍

原文：https://pythonguides.com/python-interface/

在这个 Python 教程中，我们将讨论 python 接口，并且我们将通过例子检查什么是 Python 中的接口。让我们学习:

Python 中的接口是什么？
如何用 Python 创建接口？
Python 中的正式和非正式接口是什么？
Python 接口示例
Python 接口 vs 抽象类

什么是接口？
如何在 Python 中声明接口
创建一个 Python 接口
python 中的非正式接口
- python 中的形式接口(ABCs)
Python 接口示例
Python 多接口
Python 接口 vs 抽象类

什么是接口？

接口是应该由实现类提供的方法签名的集合。
接口包含本质上抽象的方法。抽象方法将只有声明，因为没有实现。
python 中的接口是使用 python 类定义的，是 interface 的子类。作为所有接口的父接口的接口。
实现将由继承接口的类来完成。Python 中的接口与 Java、C#或 C++等其他语言略有不同。
实现接口是编写有组织的代码的一种方式。

让我们用几个例子来理解一下 Python 接口。

如何在 Python 中声明接口

在这里，我们将看到如何在 Python 中声明接口模块。

语法:

class MyInterface(zope.interface.Interface)

首先，我们将导入 zope.interface 模块。
zope.interface 是一个模块，用于在 python 中实现对象接口。
zope.interface 库是当事情不清楚时的出路。
接口充当设计类的蓝图。这里， @zope.interface.implementer(午餐)是使用类中的 implementer decorator 实现的。
这个包直接导出属性和接口。
为了克服接口的不确定性，实现了 zope 模块。

implementation by(class)–该函数返回一个布尔值。如果这个类实现了这个接口，它将导致真否则假。

示例:

import zope.interface 
class Lunch(zope.interface.Interface): 
	northindian = zope.interface.Attribute("chocolate")
	def food(self, northindian): 
		pass
def colddrinks(self, beverages): 
		pass
@zope.interface.implementer(Lunch) 

class Lunch(zope.interface.Interface): 
    def food(self, northindian):
        return northindian
    def colddrinks(self,beverages):
            return beverages

colddrinks = Lunch['colddrinks'] 
food = Lunch['food']
print(Lunch.implementedBy(Lunch))
print(type(colddrinks))
print(type(food))

在这里，我们可以看到该类是在接口中实现的。因此，布尔值真被返回。同样，我们可以看到两次返回 <类‘Zope . interface . interface . method’>的输出，因为我在一个类中定义了两个函数 def food 和 def colddrinks 。

下图显示了输出:

Python interface module

创建一个 Python 接口

在 python 中有两种方法来创建和实现接口

非正式界面
正式接口

python 中的非正式接口

Python 中的非正式接口是一个类。它定义了可以被重写但不强制执行的方法。python 中的非正式接口被称为协议，因为它是非正式的，不能正式实施。用于执行某些操作的常用方法有:

_ _ ITER _ _–此方法返回对象的迭代器。
_ _ len _ _–此方法返回字符串、列表、字典、元组的长度。
_ _ contain _ _–此方法用于检查它是否包含另一个字符串。

示例:

class Chocolate:
    def __init__(self, items):
        self.__items = items
    def __len__(self):
        return len(self.__items)
    def __contains__(self, items):
        return items in self.__items
fav_chocolate = Chocolate(["kitkat", "diarymilk", "munch","5star"])
print(len(fav_chocolate))
print("kitkat" in fav_chocolate)
print("munch" not in fav_chocolate)
print("dirymilk" not in fav_chocolate)
print("5star" in fav_chocolate)

在这个例子中，我实现了 len 和 contain。我们可以直接在 chocolate 实例上使用 len()函数，然后我们必须检查一个条目是否出现在列表中。
在运算符中使用，print(len(fav _ chocolate))用于查找列表的长度。
在这里，我们可以看到它返回一个布尔值。如果项目出现在列表中，它将返回 true，否则将返回 false。下面的屏幕截图显示了输出:

Informal interface in Python

python 中的形式接口(ABCs)

在这里，我们可以看到 python 中的形式接口。

正式接口是正式实施的接口。为了创建一个正式的接口，我们需要使用 ABCs(抽象基类)。
ABCs 的解释是，我们定义了一个本质上是抽象的类，我们也将基类上的方法定义为抽象方法。
我们从基类派生的任何对象都必须实现这些方法。
在这个例子中，我已经导入了一个模块 abc 并定义了一个食物类。 @abc.abstractmethod 是一个指示抽象方法的装饰器，用于声明属性的抽象方法。
我使用 def 关键字定义了一个函数 def taste ，通过使用 self 关键字我们可以访问该类的属性和方法。
并且，我还定义了一个子类为 class north_indian ，然后从 food 类打印一个实例。pass 语句用作占位符。

示例:

import abc
class Food (abc.ABC):
  @abc.abstractmethod
  def taste( self ):
      pass
class north_indian(Food) :
  def taste(self):
     print(" Cooking! ")
s = north_indian ()
print( isinstance(s, Food))

下面的屏幕截图显示了输出:

在这个输出中，我们可以看到输出了一个布尔值。只有当实例出现在类中时才返回 true，否则返回 false。

Formal interface in python(ABCs)

Python 接口示例

在这里，我们将看到派生类的代码如何定义一个抽象方法。所以，我们有了导入的 abc 模块，我们有了类名 myinterface(abc。ABC) 。

举例:

import abc
class myinterface(abc.ABC):
      @abc.abstractclassmethod
      def display():
        pass
print("This is Myclass")
class Myclass(myinterface):
      def display():
        pass
obj=Myclass()

这里， obj = Myclass() 被调用，它将输出打印为“这是我的类”。你可以参考下面的 python 接口例子截图。

Python interface examples

Python 多接口

现在，我们可以在 Python 中看到多个接口。

在下面的例子中，我们必须导入 abc 模块，然后我们可以将类初始化为 Food 并将子类初始化为 northIndian() 和 southIndian()。

示例:

import abc
class Food (abc.ABC):
  @abc.abstractmethod
  def taste( self ):
   pass
class northIndian(Food) :
  def taste(self):
   print(" Cooking! ")
class Food (abc.ABC):
   @abc.abstractmethod
   def taste(self):
    pass
class southIndian(Food) :
   def taste(self) :
    print(" Cooking!.. ")
a = northIndian ()
s = southIndian()
print( isinstance(s, northIndian))
print( isinstance(s, southIndian))
print( isinstance(a, northIndian))
print( isinstance(a, southIndian))

这里，我们可以在输出中看到 false，因为实例 s 被分配给南印度，但是在打印语句中，它被分配为 (s，北印度)。我们可以参考下面的截图:

Python multiple interfaces

Python 接口 vs 抽象类

让我们了解一下 Python 接口与抽象类的区别。

您可能会喜欢以下 Python 教程:

在本 Python 教程中，我们学习了 Python 接口。此外，我们还讨论了以下主题:

什么是接口？
如何在 Python 中声明接口
如何在 Python 中创建接口
Python 接口示例
Python 多接口
Python 接口 vs 抽象类

集合的 Python 交集

原文：https://pythonguides.com/python-intersection-of-sets/

在本 python 教程中，我们将通过几个例子讨论 python 中集合的交集，我们还将涉及以下主题:

交集是什么？
集合的 Python 交集
Python 集合交集示例
两个列表的 Python 交集
Python 计算列表的交集
多个集合的 Python 交集
多个列表的 Python 交集
三个集合的 Python 交集
Python 计算集合的交集
使用&运算符的 Python 集合交集
Python 寻找多个集合的交集

交集是什么？
Python 集合的交集
Python 集合交集示例
Python 两个列表的交集
Python 计算列表的交集
Python 多个集合的交集
Python 多个列表的交集
Python 三集的交集
Python 计算集合的交集
Python 使用&运算符设置交集
Python 寻找多个集合的交集

交集是什么？

两个集合的交集只有两个集合的共有的元素，在 Python 中称为交集。如果一个元素只在一个集合中，那么它就不是交集的一部分。

语法:

set.intersection(other_sets)

Python 集合的交集

让我们看看，如何在 python 中执行集合的交集。

intersection 方法返回一个新的集合，其中包含两个集合共有的元素。在下面的例子中“苹果”同时出现在两个集合中，所以它返回新的集合。

举例:

m1 = {"Samsung","Apple","OnePlus"}
m2 = {"Oppo","Apple","Vivo"}
i = m1.intersection(m2)
print(i)

在这个输出中，我们可以看到集合的 python 交集被执行。你可以参考下面的截图。

Python intersection of sets

你可能喜欢 Python 二叉树实现和如何在 Python 中读取视频帧。

Python 集合交集示例

让我们看看， python 中设置交集的例子。

在本例中，我们将比较 3 个集合，并返回一个包含所有 3 个集合中的项目的集合。我们可以看到，“c”在所有 3 个集合中都存在。

举例:

s1 = {"c", "y", "z"}
s2 = {"a", "c", "e"}
s3 = {"f", "g", "c"}
result = s1.intersection(s2, s3)
print(result)

在这个输出中，我们可以看到 python 设置交集示例。你可以参考下面的截图。

Python sets intersection example

阅读:如何在 Django 中添加下拉导航条

Python 两个列表的交集

现在，我们将看到两个列表的 python 交集。

两个列表的交集意味着我们必须获取两个列表中的所有公共元素。在下面的示例中，“10 和 6”同时出现在两者中。所以，它返回新的列表。

举例:

def intersection(l1, l2): 
    return list(set(l1) & set(l2)) 
l1 = [10, 8, 6, 5, 2]
l2 = [6, 3, 10, 4, 1]
print(intersection(l1, l2))

在这个输出中，我们可以看到两个列表的 python 交集被执行。你可以参考下面的截图。

Python intersection of two lists

阅读:如何在 Python 中添加集合中的元素

Python 计算列表的交集

在这里，我们将看到 python 计数列表的交集。

为了统计列表的交集，我们将使用“len(set(L1)&set(L2))”。在这里，&是两者共有的交集元素。它将返回计数为 "2" ，因为 "101 和 88" 是两个列表共有的。

举例:

l1 = [101, 120, 88, 16, 14]
l2 = [88, 108, 66, 101, 140]
r = len(set(l1) & set(l2)) 
print(r)

在这个输出中，我们可以看到列表的 python 计数交集被执行。你可以参考下面的截图。

Python count intersection of lists

Python 多个集合的交集

让我们看看，如何在 python 中执行多个集合的交集。

多个集合的交集包含所有集合共有的所有元素。在下面的示例中，“20 和 15”出现在所有集合中。所以，它返回新的集合。

举例:

s1 = {15, 18, 16, 20, 25}
s2 = {20, 14, 15, 12, 22}
s3 = {15, 12, 20, 23, 19}
i = set. intersection(s1,s2,s3)
print(i)

在这个输出中，我们可以看到执行了多个集合的 python 交集。你可以参考下面的截图。

Python intersection of multiple sets

Python 多个列表的交集

现在，我们将看到多个列表的 python 交集。

两个 Python 列表的交集以不同的方式包含多个列表。
首先，我们用多个列表初始化了两个列表。
现在，使用列表理解或循环来迭代列表。

举例:

def intersection(l1, l2): 
    return [item for item in l1 if item in l2] 
l1 = [['Naina', 'Raj'], ['Sweety', 'Pooja']] 
l2 = [['Sweety', 'Pooja'], ['Sam', 'Sid']] 
print(intersection(l1, l2))

在这个输出中，我们可以看到执行了多个列表的 python 交集。你可以参考下面的截图。

Python intersection of multiple lists

Python 三集的交集

让我们看看，如何在 python 中执行三个集合的交集。

三个集合的交集包含所有集合共有的所有元素。在下面的示例中，“108”出现在所有集合中。所以，它返回新的集合。

举例:

set1 = {101, 105, 108}
set2 = {108, 130, 111}
set3 = {119, 125, 108}
i = set. intersection(set1,set2,set3)
print(i)

在这个输出中，我们可以看到执行了三个集合的 python 交集。你可以参考下面的截图。

Python intersection of three sets

Python 计算集合的交集

为了统计 Python 中集合的交集，我们将使用“len(set(set 1)&set(set 2))”。在这里，&是两者共有的交集元素。它将返回计数“3”，因为“10、8 和 6”对两组都是通用的。

举例:

set1 = {10, 12, 8, 6, 4}
set2 = {8, 18, 6, 10, 5}
r = len(set(set1) & set(set2)) 
print(r)

在这个输出中，我们可以看到执行了集合的 python 计数交集。你可以参考下面的截图。

Python count intersection of sets

Python 使用&运算符设置交集

为了找到集合的交集，我们还可以使用&运算符。 & 运算符将返回集合中存在的公共元素。

举例:

set1 = {10, 12, 8, 6, 4}
set2 = {88, 18, 60, 101, 5}
set3 = {12, 22, 6, 20, 28}
print(set1 & set3)

在这个输出中，我们可以看到使用&操作符执行的 python 集合交集。你可以参考下面的截图。

Python set intersection using & operators

Python 寻找多个集合的交集

为了在 Python 中找到多个集合的交集，我们必须获得 4 个集合，然后我们可以使用 " & " 操作符来获得另一个集合，该集合将具有在所有 4 个集合中出现的公共元素。

举例:

set1 = {1,2,3,4,5}
set2 = {2,3,5,7,9}
set3 = {3,5,10,11,12}
set4 = {8,7,5,4,3}
result = set1 & set2 & set3 & set4
print(result)

在这个输出中，我们可以看到 python 找到了多个集合的交集。你可以参考下面的截图。

Python find the intersection of multiple sets

您可能会喜欢以下 Python 教程:

在本教程中，我们已经学习了集合的 Python 交集，并且我们已经涵盖了以下主题:

交集是什么？
集合的 Python 交集
Python 集合交集示例
两个列表的 Python 交集
Python 计算列表的交集
多个集合的 Python 交集
多个列表的 Python 交集
三个集合的 Python 交集
Python 计算集合的交集
使用&运算符的 Python 集合交集
Python 寻找多个集合的交集

基数为 10 的 int()的 Python 无效文字

原文：https://pythonguides.com/python-invalid-literal-for-int-with-base-10/

在本 Python 教程中，我们将讨论什么是 Value Error——Python 对以 10 为基数的 int()的无效文字，以及如何修复这个错误。

基数为 10 的 int()的 Python 无效文字

在 python 中，每当我们用不能被解析为整数的字符串参数调用 int()函数时，就会引发基数为 10 的 int()的无效文字，然后它会给出一个错误。

举例:

value = 'Hello'
s = int(value)
print(s)

写完上面的代码(python 对基数为 10 的 int()无效的文字)，你将打印出 " s " 然后错误将显示为"值错误:对基数为 10 的 int()无效的文字:' Hello' " 。这里，每当我们用一个不能被解析为整数的字符串参数调用 int() 函数时，就会出现这个错误。

你可以参考下面的截图 python 对以 10 为基数的 int()无效文字

Python invalid literal for int() with base 10

这是值错误:基数为 10 的 int()的文本无效:“Hello”

为了解决这个 ValueError: 以 10 为基数的 int()的无效文字:“Hello”，我们需要将一个整数值作为字符串传递给变量“value”，然后它会使用内置的 int()函数将变量转换为 int。这样就不会发现错误。

举例:

value = '50'
s = int(value)
print(s)

写完上面的代码后(python 对以 10 为基数的 int()无效)，你将打印出 " s " ，然后输出将显示为 " 50 " 。

这里，由于我们将整数值作为字符串传递给了变量，因此解决了该错误，它可以使用 int()函数将该值转换为整数，这样，错误就解决了。

你可以参考下面的截图 python 对以 10 为基数的 int()无效文字

Python invalid literal for int() with base 10

您可能会喜欢以下 Python 教程:

这是我们如何解决 值错误的:以 10 为基数的 int()的无效文字:“Hello”****

Python 关键字及示例

原文：https://pythonguides.com/python-keywords/

在这篇 python tutoria l 中，你将通过几个例子了解什么是 python 关键字。有各种 python 保留的关键字可以在 Python 中使用。这里我们将检查 :

Python 中的关键词是什么
python 中的 class 关键字
python 中的 del 关键字
python 中的 def 关键字
python 中的 False 关键字
python 中的 True 关键字
python 中的 break 关键字
python 中的 continue 关键字
python 中的 if 关键字
python 中的 else 关键字
python 中的 return 关键字
python 中的导入关键字
python 中的 lambda 关键字
python 中的 None 关键字
python 中的 Try 关键字
python 中的 Pass 关键字
python 中的 in 关键字

Python 中的关键字有哪些
python 中的 class 关键字
python 中的 del 关键字
python 中的 def 关键字
python 中的 False 关键字
python 中的 True 关键字
python 中的 break 关键字
python 中的 continue 关键字
python 中的 if 关键字
python 中的 else 关键字
返回 python 中的关键字
在 python 中导入关键字
python 中的 lambda 关键字
python 中的无关键字
python 中的 Try 关键字
python 中的 Pass 关键字
在 python 中的关键字

Python 中的关键字有哪些

在 python 中，关键字是保留字，不能用作变量名、标识符或任何函数名。

python 中的关键字列表

| 班级 | 是吗 | 极好的 | 错误的 |
| 真实的 | 破裂 | 继续 | 如果 |
| 其他 | 返回 | 进口 | 希腊字母的第 11 个 |
| 没有人 | 尝试 | 及格 | 在 |

List of keywords

python 中的 class 关键字

在 python 中， class 关键字用于创建一个类，而一个类就像一个用户定义的对象。

举例:

class Student:
name = "Jack"
roll = 21
print(Student.name)

写完上面的代码(python 中的 class 关键字)，你将打印出 " Student.name " ，然后输出将显示为 " Jack " 。在这里，我的班级名字是“学生”。

你可以参考下面的 python 类关键字截图

Class keyword in python

python 中的 del 关键字

在 python 中， del 关键字用于从列表或变量等中删除特定项。

举例:

value = ["A", "B"]
del value[0]
print(value)

写完上面的代码(python 中的 del 关键字)，你将打印出 " value " ，然后输出将显示为 " ['B'] " 。这里，index [0]项从列表中删除，并返回列表中的其余项。

你可以参考下面的 python del 关键字截图

del keyword in python

python 中的 def 关键字

在 python 中， def 关键字用于创建新的用户定义函数。

举例:

def function1():
print("Welcome to function in python")
function1()

在编写完上述代码(python 中的 def 关键字)后，您将打印这些代码，然后输出将显示为“欢迎使用 python 中的函数”。在这里，我们定义函数，然后调用函数。

你可以参考下面的 python def 关键字截图

def keyword in python

python 中的 False 关键字

在 python 中， false 关键字是布尔值，false 关键字也被表示为零，这意味着什么。

举例:

print(10<3)

在编写了上面的代码(python 中的 false 关键字)之后，您将打印这些代码，然后输出将显示为 " false " 。这里，我们使用比较运算符来检查 3 是否大于 10，因此它返回 false。

你可以参考下面的 python 中 false 关键字的截图

False keyword in python

python 中的 True 关键字

在 python 中， true 关键字是布尔值，true 关键字表示为 1。

举例:

print(10>3)

在编写了上面的代码(python 中的 true 关键字)之后，您将打印这些代码，然后输出将显示为一个 " true " 。这里，我们使用比较运算符来检查 10 是否大于 3，因此它返回 true。

你可以参考下面的 python 中 true 关键字的截图

True keyword in python

python 中的 break 关键字

在 python 中， break 关键字用于终止循环的当前迭代。

举例:

for value in range(5):
if value > 2:
break
print(value)

写完上面的代码(python 中的 break 关键字)，你将打印出 " value " ，然后输出将显示为 " 0 1 2 " 。这里，我们使用 break 关键字来中断循环。

你可以参考下面 python 中 break 关键字的截图。

break keyword in python

python 中的 continue 关键字

在 python 中， continue 关键字用于结束 for 循环的当前迭代，并继续下一次迭代。

举例:

for value in range(6):
if value == 4:
continue
print(value)

写完上面的代码(python 中的 continue 关键字)，你将打印出 " value " ，然后输出将显示为 " 0 1 2 3 5 " 。这里，我们使用 continue 关键字循环不终止，而是继续下一次迭代。

你可以参考下面 python 中 continue 关键字的截图。

continue keyword in python

python 中的 if 关键字

在 python 中， if 关键字用于定义条件语句，如果条件为真，它就执行代码块。

举例:

value = 4
if value > 2:
print("Yes value is greater")

写完上面的代码(如果是 python 中的关键字)，你将打印出 " value " ，然后输出将显示为 " Yes value is greater " 。这里，我们使用 if 关键字来检查是否满足某个条件。

python 中的 if 关键字可以参考下面的截图。

if keyword in python

python 中的 else 关键字

在 python 中， else 关键字被用作条件语句，它决定如果条件为假时该做什么。

举例:

value = 2
if value > 4:
print("Yes value is greater")
else:
print("No value is not greater")

写完上面的代码(python 中的 else 关键字)，你将打印出，然后输出将显示为“无值不大于”。这里，如果条件为假，我们使用 else 关键字。

你可以参考下面 python 中 else 关键字的截图。

else keyword in python

返回 python 中的关键字

在 python 中， return 关键字用于从调用函数返回值。

举例:

def my_fun():
return 5+7
print(my_fun())

写完上面的代码(python 中的 return 关键字)，你将打印出 " my_fun() " ，然后输出将显示为 " 12 " 。这里，return 关键字将退出函数并返回值。

您可以参考下面 python 中 return 关键字的截图。

return keyword in python

在 python 中导入关键字

在 python 中，导入关键字用于导入日期时间模块、，然后显示当前日期和时间。

举例:

import datetime
a = datetime.datetime.now()
print(a)

写完上面的代码(python 中的 import 关键字)，你将打印出 " a " ，然后输出将显示为" 2020-08-28 17:30:26.590678 "。这里，import 关键字用于导入 python 中的模块。

你可以参考下面的 python 中导入关键字的截图。

import keyword in python

python 中的 lambda 关键字

在 python 中， lambda 关键字可以接受任意数量的参数，但只能接受一个表达式，它会创建一个小型匿名函数。

举例:

s = lambda x : x + 20
print(s(5))

写完上面的代码(python 中的 lambda 关键字)，你将打印出 " s(5) " ，然后输出将显示为 " 25 " 。在这里，lambda 关键字将计算表达式，并返回结果。

可以参考下面 python 中 lambda 关键字的截图。

lambda keyword in python

python 中的无关键字

在 python 中， none 关键字是其自身数据类型的对象，用于定义空值，即没有值。

a = None 
print(a)

写完上面的代码(python 中的 none 关键字)，你将打印出 " a " ，然后输出将显示为 " None " 。这里，none 关键字用于定义值的缺失，它可以被赋给变量。

可以参考下面 python 中 none 关键字的截图。

None keyword in python

python 中的 Try 关键字

在 python 中，**关键字**用于错误和异常处理，如果没有出错，try 块就会执行。****

try:
x > 10
except:
print("Something is wrong")

在编写了上面的代码(python 中的 Try 关键字)之后，您将打印这些代码，然后输出将显示为“有问题”。这里，try 块不会执行，因为发生了异常，所以它引发了一个错误。

可以参考下面 python 中 try 关键字的截图。

Try keyword in python

python 中的 Pass 关键字

在 python 中， pass 关键字是一个伪占位符，当 pass 关键字被执行时什么都不会发生，并且它避免了在不允许空代码时出现错误。

for a in [10, 11, 12]:
pass

编写上述代码(python 中的 pass 关键字)后，您将运行代码，然后输出中不显示任何内容。在这里，pass 关键字被用作一个伪占位符，它可以被视为一个空语句。

关于 python 中的 pass 关键字，可以参考下面的截图。

Pass keyword in python

在 python 中的关键字

在 python 中，中的关键字用于遍历 for 循环，也用于检查值是否出现在列表、字符串等中。

flower = ["rose", "sunflowers", "tulips"]
if "tulips" in flower:
print("yes")

在编写完上面的代码(python 中的关键字)后，您将打印这些代码，然后输出将显示为“yes”。这里，in 关键字用于检查值是否存在。

你可以参考下面 python 中 in 关键字的截图。

in keyword in python

您可能会喜欢以下 Python 教程:

在本 python 教程中，我们学习了 Python 中出现的各种 python 关键字，例如:

python 中的 class 关键字
python 中的 del 关键字
python 中的 def 关键字
python 中的 False 关键字
python 中的 True 关键字
python 中的 break 关键字
python 中的 continue 关键字
python 中的 if 关键字
python 中的 else 关键字
python 中的 return 关键字
python 中的导入关键字
python 中的 lambda 关键字
python 中的 None 关键字
python 中的 Try 关键字
python 中的 Pass 关键字
python 中的 in 关键字

enjoysharepoint.com/****

使用 Python Lil_Matrix Scipy

原文：https://pythonguides.com/python-lil_matrix-scipy/

本教程将教我们关于"*Python Lil _ Matrix Scipy*"这是另一种稀疏矩阵，但在使用或本质上是高效的。

所以这里我们将创建 Lil 矩阵，并对矩阵中的元素求和或计算其平均值，同时执行一些操作，如调整矩阵大小或复制矩阵等。此外，涵盖以下主题。

Scipy 中的 Lil Matrix 是什么？
如何使用 Python Scipy 创建 Lil_Matrix
如何对沿特定轴的 Lil_Matrix 元素求和？
如何寻找 Scipy Lil_Matrix 中非零元素的索引
如何调整 Scipy Lil_Matrix
如何创建 Scipy Lil_Matrix 的副本
如何检查 Scipy Lil_Matrix 的数据类型
如何求科学矩阵的平均值
如何转置科学的 Lil_Matrix

Scipy 中的 Lil Matrix 是什么？
Python Lil_Matrix Scipy
Python Lil_Matrix Scipy Sum
Python Lil_Matrix Scipy 非零
Python Lil _ Matrix Scipy Resize
Python Lil _ Matrix Scipy Copy
Python Lil _ Matrix Scipy Dtype
Python Lil_Matrix Scipy 的意思是
Python Lil_matrix Scipy 转置

Scipy 中的 Lil Matrix 是什么？

Lil 矩阵是一个稀疏矩阵，具有基于行的列表列表。该结构在下一小节中给出，可用于增量构建稀疏矩阵。

在构建矩阵时，确保每行的元素都按索引进行了预先排序，因为在最坏的情况下，只插入一项会花费线性时间。

稀疏矩阵支持减法、加法、乘法、除法和矩阵幂等算术运算。

LIL 格式的好处是允许灵活的切片，并且矩阵稀疏结构被有效地修改。
LIL 格式的缺点是 LIL + LIL 是一个缓慢的加法过程(考虑 CSR 或 CSC)，缓慢切片列(考虑 CSC)，以及低效的矩阵向量乘积(考虑 CSR 或 CSC)。

使用目的:LIL 格式使创建稀疏矩阵变得简单。对于快速算术和矩阵向量运算，一旦创建了矩阵，就将其转换为 CSR 或 CSC 格式。当创建大矩阵时，考虑选择首席运营官格式。

阅读: Python Scipy 稀疏 Csr_matrix

Python Lil_Matrix Scipy

Python Scipy 的类*lil_matrix()*存在于基于列表行的稀疏矩阵的模块*scipy.sparse*中。

下面给出了语法。

class scipy.sparse.lil_matrix(arg1, shape=None, dtype=None, copy=False)

有多种方法可以实例化它:

lil_matrix(D) 秩为 2 ndarray D 或稠密矩阵。
lil_matrix(S) 具有不同的稀疏矩阵 S
要创建形状为(M，N)的空矩阵，请使用语法“lil matrix((M，N)，[dtype])”。Dtype 是可选的，默认为 dtype='d '。

让我们按照以下步骤创建 Lil 矩阵:

使用下面的 python 代码导入所需的库或方法。

import numpy as np
from scipy.sparse import lil_matrix

使用以下代码创建一个包含美国城市代码的秩 2 矩阵。

usa_city_code = np.array([[334, 251, 205, 256, 907, 480], [602, 209, 213, 661, 707, 741],\
 [925, 949, 303, 719, 203, 860]])

使用以下代码将上述矩阵传递给*lil_matrix()*。

lil_matrix(usa_city_code).toarray()

运行下面的代码来检查它是否是 Lil 矩阵。

lil_matrix(usa_city_code)

Python Lil_Matrix Scipy

这就是如何使用 Python Scipy 的方法*lil_matrix()*生成或创建 Lil 矩阵。

阅读: Python Scipy IIR 滤波器

Python Lil_Matrix Scipy Sum

Python Scipy 的方法*lil_matrix.sum*沿着特定的轴将每个矩阵成员相加。

下面给出了语法。

lil_matrix.sum(axis=None, dtype=None, out=None)

其中参数为:

轴({-2，-1，0，1} ): 用于计算总和的轴。默认情况下，计算每个矩阵元素的总和并作为标量返回(即 axis = None)。
dtype: 用于将分量相加的累加器的种类和返回矩阵的类型。除非具有精度低于平台整数的整数 dtype，否则默认情况下会使用的 dtype。如果有符号，则在这种情况下使用平台整数，而如果无符号，则使用具有相同精度的无符号整数。
out(np.matrix): 备选输出矩阵可用于结果。它必须与所需的输出具有相同的形状，但是如果需要，输出值的类型将被强制转换。

方法*lil_matrix.sum*返回 sum_along_axis(缺少所需轴的同自矩阵) 。

让我们以上述小节中使用的相同示例为例，按照以下步骤计算轴上元素的总和:

使用下面的 python 代码导入所需的库或方法。

import numpy as np
from scipy.sparse import lil_matrix

使用以下代码创建一个包含美国城市代码的秩 2 矩阵。

usa_city_code = np.array([[334, 251, 205, 256, 907, 480], [602, 209, 213, 661, 707, 741],\
 [925, 949, 303, 719, 203, 860]])

使用以下代码将上述矩阵传递给*lil_matrix()*。

lil_matrix(usa_city_code).toarray()

上面的代码显示了 Lil 矩阵的样子，现在使用下面的代码将轴上的元素相加等于零。

s = lil_matrix(usa_city_code).sum(0)
print(s)

Python Lil_Matrix Scipy Sum

这就是如何使用 Python Scipy 的方法*lil_matrix.sum()*对沿着指定轴的 Lil 矩阵的元素求和。

阅读: Python Scipy 统计符合

Python Lil_Matrix Scipy 非零

在模块scipy.sparse中有一个方法lil_matrix.nonzero()来返回一个数组元组(row，col ),该数组元组保存矩阵的非零项的索引。

让我们以一个例子来理解如何通过以下步骤获得 Lil 矩阵中非零元素的索引:

使用下面的 python 代码导入所需的库或方法。

import numpy as np
from scipy.sparse import lil_matrix

使用下面的代码创建一个秩为 2 的矩阵。

mat_data = np.array([[3, 2, 0, 2, 9, 8], [0, 0, 2, 6, 0, 4],\
 [2, 9, 3, 1, 3, 6]])

创建一个 Lil 矩阵，并使用下面的代码检查矩阵。

lil_mat = lil_matrix(mat_data)
lil_mat.toarray()

对 Lil，matrix 应用方法*nonzero()*,使用下面的代码找到非零元素的索引。

lil_mat.nonzero()

Python Lil_Matrix Scipy Nonzero

上面的输出显示了 Lil 矩阵中非零元素的索引，例如(0，0) = 3，(0，1)=2 和(0，3) =2 等等。

阅读: Python Scipy ttest_ind

Python Lil _ Matrix Scipy Resize

Python Scipy 模块scipy.sparse有一个方法*lil_matrix.resize()*将矩阵调整到由形状指定的尺寸。新形状外部的非零元素将被删除，而新形状内部的元素将保持其当前索引。

下面给出了语法。

lil_matrix.resize(*shape)

其中参数 shape(int，int) :新矩阵的行数和列数。

如下所示，在下一小节中我们所做的相同示例的帮助下，使用如何调整 Lil 矩阵大小的示例。

使用下面的 python 代码导入所需的库或方法。

import numpy as np
from scipy.sparse import lil_matrix

使用下面的代码创建一个秩为 2 的矩阵。

data = np.array([[34, 251, 20, 26, 97, 48], [60, 20, 21, 66, 70, 74],\
 [92, 94, 30, 19, 30, 60]])

创建一个 Lil 矩阵，并使用下面的代码检查矩阵的形状。

lil_mat = lil_matrix(data)
print(lil_mat.shape)
lil_mat.toarray()

现在使用下面的代码将 Lil 矩阵的形状改为 3x 2。

lil_mat.resize(3,2)

使用下面的代码检查调整后的矩阵形状。

print(lil_mat.shape)
lil_mat.toarray()

Python Lil_Matrix Scipy Resize

这是如何使用 Python Scipy 的方法*lil_matrix.resize()*来调整 Lil 矩阵的大小。

阅读: Python Scipy Gamma

Python Lil _ Matrix Scipy Copy

模块scipy.sparse中 Python Scipy 的方法*lil_matrix.copy()*复制这个矩阵并返回。当前矩阵和返回值之间没有数据或索引共享。

让我们举个例子，按照以下步骤复制 Lil 矩阵:

使用下面的 python 代码导入所需的库或方法。

import numpy as np
from scipy.sparse import lil_matrix

使用下面的代码创建一个秩为 2 的矩阵。

data = np.array([[34, 251, 20, 26, 97, 48], [60, 20, 21, 66, 70, 74],\
 [92, 94, 30, 19, 30, 60]])

使用下面的代码创建一个 Lil 矩阵。

lil_mat = lil_matrix(data)
lil_mat.toarray()

现在使用方法*copy()*复制上面创建的 Lil 矩阵*lil_mat*。

copy_lilmat = lil_mat.copy()
copy_lilmat.toarray()

Python Lil_Matrix Scipy Copy

这是如何使用 Python Scipy 的方法*lil_matrix.copy()*复制 Lil 矩阵。

阅读: Python Scipy 正常测试

Python Lil _ Matrix Scipy Dtype

Lil matrix 有一个属性*dtype*,用于了解 Lil matrix 中存在的元素的数据类型。

让我们举一个我们在本教程的上述小节中使用过的例子。

使用下面的 python 代码导入所需的库或方法。

import numpy as np
from scipy.sparse import lil_matrix

使用下面的代码创建一个包含美国城市代码的秩 2 矩阵。

usa_city_code = np.array([[334, 251, 205, 256, 907, 480], [602, 209, 213, 661, 707, 741],\
 [925, 949, 303, 719, 203, 860]])

使用下面的代码将前面提到的矩阵传递给 lil_matrix() 并访问属性*dtype*以了解 lil 矩阵的数据类型。

lil_matrix(usa_city_code).dtype

Python Lil_Matrix Scipy Dtype

这就是如何使用 Lil 矩阵的属性*dtype*检查 Lil 矩阵的数据类型。

阅读: Python Scipy 统计偏差

Python Lil_Matrix Scipy 的意思是

Python Scipy 的方法*lil_matrix.mean()*返回矩阵的平均值。默认情况下，对所有矩阵元素计算平均值；如果不是，则跨选定的轴进行计算。整数输入使用 float64 作为中间值和返回值。

下面给出了语法。

lil_matrix.mean(axis=None, dtype=None, out=None)

其中参数为:

轴(1，0，-1，-2): 用于计算平均值的轴。默认设置(即 axis = None)计算矩阵中每个成员的平均值。
dtype: 利用此类型计算平均值。浮点输入的默认值等于输入数据类型，而整数输入的默认值为 float64。
out(np.matrix): 应该使用不同的输出矩阵来存储结果。如果需要，可以转换输出值的类型，但是它们必须与预期的输出具有相同的形状。

使用下面的 python 代码导入所需的库或方法。

import numpy as np
from scipy.sparse import lil_matrix

使用下面的代码创建一个秩为 2 的矩阵。

mat_data = np.array([[3, 2, 0, 2, 9, 8], [0, 0, 2, 6, 0, 4],\
 [2, 9, 3, 1, 3, 6]])

创建一个 Lil 矩阵，并使用下面的代码检查矩阵。

lil_mat = lil_matrix(mat_data)
lil_mat.toarray()

将方法*mean()*应用于 Lil，matrix，使用下面的代码沿着轴= 0 找到 Lil 矩阵的平均值。

lil_mat.mean(0)

Python Lil_Matrix Scipy Mean

从上面包含 Lil 矩阵中沿轴的元素平均值的输出= 0。

阅读: Python Scipy Kdtree

Python Lil_matrix Scipy 转置

模块*scipy.sparse*中 Python Scipy 的方法*lil_matrix.transpose()*反转稀疏矩阵的维数。

下面给出了语法。

lil_matrix.transpose(axes=None, copy=False)

其中参数为:

axes: 这个参数出现在签名中的唯一原因是为了确保 NumPy 兼容性。除默认值外，不应输入任何其他内容。

copy(boolean): 是否应该尽可能地模仿自我属性。根据所使用的稀疏矩阵的种类，不同的属性被复制到不同的程度。

方法*lil_matrix.transpose()*返回p。

让我们举个例子，按照以下步骤转置 Lil 矩阵:

使用下面的 python 代码导入所需的库或方法。

import numpy as np
from scipy.sparse import lil_matrix

使用下面的代码创建一个秩为 2 的矩阵。

mat_data = np.array([[3, 2, 0, 2, 9, 8], [0, 0, 2, 6, 0, 4],\
 [2, 9, 3, 1, 3, 6]])

创建一个 Lil 矩阵，并使用下面的代码检查矩阵。

lil_mat = lil_matrix(mat_data)
lil_mat.toarray()

对 Lil，matrix 应用方法*transpose()*,使用下面的代码将 Lil 矩阵中的行交换为列或将列交换为行。

lil_mat.transpose().toarray()

Python Lil_matrix Scipy Transpose

这就是如何使用 Python Scipy 的方法*lil_matrix.transpose()*转置 Lil 矩阵。

另外，看看更多的 Python Scipy 教程。

我们已经学习了如何创建一个 Lil 矩阵和计算总和，找到非零元素的索引，复制和转置 Lil 矩阵的元素，等等。

Scipy 中的 Lil Matrix 是什么？
如何使用 Python Scipy 创建 Lil_Matrix
如何对沿特定轴的 Lil_Matrix 元素求和？
如何寻找 Scipy Lil_Matrix 中非零元素的索引
如何调整 Scipy Lil_Matrix
如何创建 Scipy Lil_Matrix 的副本
如何检查 Scipy Lil_Matrix 的数据类型
如何求科学矩阵的平均值
如何转置科学的 Lil_Matrix