Conseils de programmation de dictionnaire Python et de collection

Bonjour, voici le blog de Token_w, bienvenue à venir.
Aujourd'hui, je vais principalement expliquer les compétences d'utilisation des dictionnaires et ensembles Python dans la programmation réelle.
Ce n'est pas facile à organiser, et cela vous sera utile. J'espère obtenir votre soutien ! reconnaissant! ! !

1. Comment filtrer les données selon les conditions dans les listes, dictionnaires et collections ?

cas réel

• Cas 1 : filtrer les nombres négatifs dans la liste [3, 9, -1, 10, 20, -2, …]
• Cas 2 : filtrer les éléments dont la valeur est supérieure à 90 dans le dictionnaire {'lisi' : 79, 'Jin' : 88, 'lucy' : 93, … }
• Cas 3 : Il est relativement simple de filtrer les éléments de l'ensemble {77, 89, 34, 20, 21…} qui peuvent être divisibles par 3. La méthode habituelle consiste à
  itérer chaque élément de la liste, du dictionnaire et de l'ensemble tour à tour, et effectuez le juge de condition.

Mais en python, il existe des moyens plus avancés pour résoudre ce genre de problème, et c'est plus simple et plus efficace.

01 Cas 1 : filtrer les nombres négatifs dans la liste [3, 9, -1, 10, 20, -2, …]

Méthode 1 : Utiliser la fonction de filtre

from random import randint

# 使用列表解析生成 -10~10 之间的10个元素
data = [randint(-10, 10) for _ in range(10)]

print('原始列表为：' , data)

# filter(function or None, iterable) --> filter object
data_o = filter(lambda x: x >= 0, data)

for each in data_o:
    
    print(each)

Méthode 2 : Utiliser une compréhension de liste

from random import randint

# 使用列表解析生成 -10~10 之间的10个元素
data = [randint(-10, 10) for _ in range(10)]

print('原始列表为：',  data)

data_o = [x for x in data if x >= 0]

print(data_o)

02 Cas 2 : filtrer les éléments dont la valeur est supérieure à 90 dans le dictionnaire {'lisi' : 79, 'Jin' : 88, 'lucy' : 93, … }

from random import randint

# 使用字典解析生成 一个字典
d ={
    
    x: randint(60, 100) for x in range(1, 10)}
print(d)

d_o = {
    
    k: v for k, v in d.items() if v >= 90}

print(d_o)

03 Cas 3 : Filtrer les éléments divisibles par 3 dans l'ensemble {77, 89, 34, 20, 21...}

from random import randint

# 使用集合解析生成 -10~10 之间的10个元素
data = {
    
    randint(-10, 10) for _ in range(10)}

print('原始集合为：', data)

data_o = {
    
    x for x in data if x % 3 == 0}

print(data_o)

2. Comment nommer chaque élément du tuple pour améliorer la lisibilité du programme ?

stuents = ('Jim', 16, 'male', '[email protected]')
name=stuents[0]
age=stuents[1]
sex= stuents[2]
email=stuents[3]
print(name, age, sex, email)

01 Méthode 1 : définir un type d'énumération similaire à d'autres langages, c'est-à-dire définir une série de constantes numériques

s=stuents = ('Jim', 16, 'male', '[email protected]')
NAME, AGE, SEX, EMAIL = range(4)
name=s[NAME]
age=s[AGE]
sex= s[SEX]
email=s[EMAIL]
print(name, age, sex, email)

02 Méthode 2 : Utilisez collections.namedtuple dans la bibliothèque standard pour remplacer le tuple intégré

from collections import namedtuple
Student = namedtuple('Student', ['name', 'age', 'sex', 'email'])
s = Student('Jim', 16, 'male', '[email protected]')
print(s)
# Student(name='Jim', age=16, sex='male', email='[email protected]')

print(s.name)
# 'Jim'

print(s.age)
# 16

print(s.sex)
# 'male'

print(s.email)
# '[email protected]'

3. Comment compter la fréquence d'occurrence des éléments dans la séquence ?

Cas 1:

Méthode 1 : Méthode traditionnelle

from random import randint

# 随机生成一个列表
data = [randint(0, 20) for _ in range(30)]

# 以列表中的值为字典的键，0为字典的值建立字典
c = dict.fromkeys(data, 0)

# 依次遍历列表，遇到一个元素，就把字典中对应的键的值加1
for x in data:

    c[x] += 1

print(c)

Méthode 2 : Utiliser l'objet collections.Counter

Passez la séquence dans le constructeur de Counter et récupérez l'objet Counter sous la forme d'un dictionnaire de fréquences d'éléments.
La méthode Counter.most_common(n) obtient la liste des n éléments avec la fréquence la plus élevée

from random import randint
from collections import Counter

# 随机生成一个列表
data = [randint(0, 20) for _ in range(30)]

c = Counter(data)

# 得到的 c 就是一个collections.Counter类型的数据，和方法 一 结果一样
# 用法与字典一样，例如 c[2] , 就是得到 键为2 对应的值
print(c)

# 另外，还可以使用 most_common() 方法得到 出现频率最高的几个键和值
print(c.most_common(3))  # 输出前3名

Cas 2 :

from collections import Counter
import re

with open('./test.txt', 'r') as f:
    txt = f.read()

# 使用 正则表达式 对文本进行切割，按照 非字母字符 进行切割
l1 = re.split('\W+', txt)

c = Counter(l1)

# 得到频率最高的10个单词
print(c.most_common(10))

4. Comment trier les éléments du dictionnaire en fonction de la taille des valeurs du dictionnaire ?

01 Méthode 1 : Utiliser zip pour convertir les données du dictionnaire en tuples

from random import randint

# 生成随机字典
d = {
    
    x:randint(60,100) for x in 'xyzabc'}

print(d)

# 把值放在前面，键放在后面，构成元组，每个元组为列表的一个项
# 得到的结果为 [(74, 'z'), (80, 'y')...]形式
list1 = zip(d.values(), d.keys())

# 然后对得到的列表进行排序，就会以列表中的元组的第一项排序，相同时再比较第二项

print(sorted(list1))

02 Méthode 2 : Utiliser le paramètre clé de la fonction triée

from random import randint

# 生成随机字典
d = {
    
    x:randint(60,100) for x in 'xyzabc'}

print(d)

# d.items() 也是一个元组的列表，只是元组中键在前，值在后
# 使用 key 参数设置以第二项 （值）作为排序依据

print(sorted(d.items(), key = lambda x: x[1]))

5. Comment trouver rapidement des clés communes dans plusieurs dictionnaires ?

01 Méthode 1 : méthode traditionnelle, traverser à tour de rôle

from random import randint, sample

# 随机产生 3 场球赛的 进球人和数
s1 = {
    
    x: randint(1,4) for x in sample('abcdefg',randint(3,6))}
s2 = {
    
    x: randint(1,4) for x in sample('abcdefg',randint(3,6))}
s3 = {
    
    x: randint(1,4) for x in sample('abcdefg',randint(3,6))}

print(s1)
print(s2)
print(s3)


# 传统方法
res = []

for k in s1:
    if k in s2 and k in s3:
        res.append(k)
       
print(res)

02 Méthode 2 : Utiliser l'opération d'intersection de l'ensemble (set)

Utiliser la méthode keys() du dictionnaire pour obtenir un ensemble de clés d'un dictionnaire
Prendre l'intersection des ensembles de clés de tous les dictionnaires

from random import randint, sample

# 随机产生 3 场球赛的 进球人和数
s1 = {
    
    x: randint(1,4) for x in sample('abcdefg',randint(3,6))}
s2 = {
    
    x: randint(1,4) for x in sample('abcdefg',randint(3,6))}
s3 = {
    
    x: randint(1,4) for x in sample('abcdefg',randint(3,6))}

print(s1)
print(s2)
print(s3)


print(s1.keys() & s2.keys() & s3.keys())

6. Comment garder le dictionnaire en ordre ?

d = dict()

d['Jim']=(1.35)

d['Leo']=(2,37)

d['Bob']=(3,45)

for k in d:
    print(k)

Méthode : utilisez collections.OrderedDict

Remplacez le dictionnaire Dict par OrderedDict et stockez les scores des joueurs dans OrderedDict à tour de rôle.

from collections import OrderedDict

d = OrderedDict()

d['Jim']=(1.35)

d['Leo']=(2,37)

d['Bob']=(3,45)

for k in d:
    print(k)

7. Comment mettre en œuvre la fonction d'enregistrement de l'historique de l'utilisateur ?

Le code d'origine est le suivant :

from random import randint

N = randint(0, 100)

def guess(k):
	if k == N:
		print('猜对了')
		return True
	elif k < N:
		print('猜小了')
	else:
		print('猜大了')
	return False

while True:
	line = input("please input a number:")
	if line.isdigit():
		k = int(line)
		if guess(k):
			break

Nous voulons enregistrer les 5 dernières suppositions, les précédentes sont supprimées

solution:

Utilisez une file d'attente d'une capacité de n (n=5 dans cet exemple) pour stocker l'historique
Utilisez deque de la bibliothèque standard, qui est une file d'attente circulaire à deux extrémités

from random import randint
from collections import deque

history = deque([], 5)

N = randint(0, 100)

def guess(k):
	if k == N:
		print('猜对了')
		return True
	elif k < N:
		print('猜小了')
	else:
		print('猜大了')
	return False

while True:
	line = input("please input a number:")
	if line.isdigit():
		k = int(line)
		history.append(k)
		if guess(k):
			break
	elif line == 'history' or line == 'h?':
		print(history)

Si nous voulons également afficher l'historique précédent lors de la prochaine exécution du programme, nous devons enregistrer l'objet file d'attente sur le disque et nous pouvons utiliser pickle

pickle peut enregistrer n'importe quel type de données (y compris des nombres, des listes, des dictionnaires, des chaînes, etc.) sur des fichiers de disque, et peut être relu en tant que données d'origine si nécessaire

Solution : avant la fermeture du programme, vous pouvez utiliser pickle pour stocker l'objet file d'attente dans un fichier et l'importer lorsque vous exécutez à nouveau le programme.

Utilisation du cornichon :

Écrire des données :

import pickle

data = [1, 2, 3, 4]

with open('data.dat', 'wb') as f:

    pickle.dump(data, f)

Lire les données :

import pickle

with open('data.dat', 'rb') as f:

    data = pickle.load(f)

print(data)

Résumer

Aujourd'hui, à l'aide de quelques cas de code de base, je vais partager avec vous quelques conseils sur l'utilisation des dictionnaires et des ensembles en Python dans la programmation réelle. J'espère que cela vous sera utile !