Le code Python que j'ai écrit a été salué par mes collègues.

La vie est courte, j'utilise Python.

La quête des programmeurs est d'atteindre la liberté financière le plus rapidement possible sans écrire de code. Non, j'ai accidentellement dit la vérité. J'aurais dû écrire le code de manière concise et élégante.

La poursuite des programmeurs Python est pythonique. Rien que dans le langage Python, il existe de nombreuses méthodes « cachées » qui peuvent rendre le code concis, élégant et unique.

J'ai résumé ici quelques opérations courantes, notamment concernant les listes et les dictionnaires, à partager avec vous.

La première lettre est en majuscule

Cette méthode est un peu intéressante, je l'ai découverte par hasard.

>>> s = "programming is awesome"
>>> print(s.title())
Programming Is Awesome

Fusion de liste

Première méthode : utilisez +.

>>> a + b
[1, 2, 3, 4, 5, 6]

Deuxième méthode : utilisez le mot-clé extend.

>>> a.extend(b)
>>> a
[1, 2, 3, 4, 5, 6]

Ces deux dernières méthodes sont évidemment plus élégantes et sont recommandées. Une chose à noter est que si la liste est longue, + sera plus lent et l'extension sera meilleure.

Déduplication des éléments de liste

Utilisez set() pour dédupliquer les éléments de la liste.

>>> a = [1, 2, 3, 4, 2, 3]
>>> list(set(a))
[1, 2, 3, 4]

Tri de liste

Utilisez sort() ou la fonction intégrée sorted() pour trier la liste. Il y a deux différences entre elles : la méthode

• sort() opère sur la liste d'origine, tandis que la méthode sorted() renvoie une nouvelle liste, ne fonctionnant pas sur la base d'origine.
• sort() est une méthode appliquée aux listes, tandis que sorted() peut trier tous les objets itérables.

# sort()
>>> a = [1, 2, 3, 4, 2, 3]
>>> a.sort()
>>> a
[1, 2, 2, 3, 3, 4]
>>>
>>> a = [1, 2, 3, 4, 2, 3]
>>> a.sort(reverse=True)
>>> a
[4, 3, 3, 2, 2, 1]

# sorted()
>>> a = [1, 2, 3, 4, 2, 3]
>>> sorted(a)
[1, 2, 2, 3, 3, 4]
>>> a = [1, 2, 3, 4, 2, 3]
>>> sorted(a, reverse=True)
[4, 3, 3, 2, 2, 1]

Parcourez les paires d'index et d'éléments de la liste

Utilisez la fonction enumerate() pour afficher à la fois la valeur de l'index et de l'élément.

>>> a = ['python', 'go', 'java']
>>> for i, v in enumerate(a):
... print(i, v)

# output
0 python
1 go
2 java

Trouvez l'élément le plus fréquent dans une liste

Utilisez la fonction max() pour trouver rapidement l'élément le plus fréquent dans une liste.

>>> a = [1, 2, 3, 4, 3, 4, 5, 4, 4, 2]
>>> b = max(set(a), key=a.count)
>>> b
4

Une chose à noter est que lorsqu'il y a deux éléments dans la liste qui apparaissent le même nombre de fois, le premier élément qui apparaît sera renvoyé.

>>> a = [1, 2]
>>> b = max(set(a), key=a.count)
>>> b
1

Compte les occurrences de tous les éléments de la liste

Le code précédent donne la valeur la plus fréquente. Si vous souhaitez connaître le nombre d'occurrences de tous les éléments d'une liste, vous pouvez utiliser le module collections.

collections est un module de trésor en Python qui offre de nombreuses fonctionnalités. La méthode Counter peut parfaitement répondre à cette exigence.

>>> from collections import Counter
>>>
>>> a = [1, 2, 3, 4, 3, 4, 5, 4, 4, 2]
>>> Counter(a)
Counter({4: 4, 2: 2, 3: 2, 1: 1, 5: 1})

Fusionner deux listes dans un dictionnaire

À l'aide de la fonction zip(), vous pouvez fusionner deux listes dans un dictionnaire.

>>> a = ['one', 'tow', 'three']
>>> b = [1, 2, 3]
>>> dict(zip(a, b))
{'one': 1, 'tow': 2, 'three': 3}

Trouvez l'intersection, l'union et la différence de deux listes.

# list_operate.py

def main():
list_a = [1, 2, 3, 4, 5]
list_b = [4, 5, 6, 7, 8]

# 求交集的两种方式
res_a = [i for i in list_a if i in list_b]
res_b = list(set(list_a).intersection(set(list_b)))

print(f"res_a is: {res_a}")
print(f"res_b is: {res_b}")

# 求并集
res_c = list(set(list_a).union(set(list_b)))
print(f"res_c is: {res_c}")

# 求差集的两种方式，在B中但不在A中
res_d = [i for i in list_b if i not in list_a]
res_e = list(set(list_b).difference(set(list_a)))

print(f"res_d is: {res_d}")
print(f"res_e is: {res_e}")


if __name__ == '__main__':
main()

Création de dictionnaire

# 1、创建空字典
a = {}
b = dict()

# 2、有初始值，从输入的便利程度来说，我更喜欢第二种
a = {'a': 1, 'b': 2, 'c': 3}
b = dict(a=1, b=2, c=3)

# 3、key 来自一个列表，而 value 相同, 使用 fromkeys，那是相当的优雅
keys = ['a', 'b', 'c']
value = 100
d = dict.fromkeys(keys, value)

# 4、key 来自一个列表，而 value 也是一个列表，使用 zip
keys = ['a', 'b', 'c']
values = [1, 2, 3]
d = dict(zip(keys, values))

Fusion de dictionnaire

m = {'a': 1}
n = {'b': 2, 'c': 3}

# 合并，两种方式
# 1、使用 update
m.update(n)
# 2、使用 **
{**m, **n}

Déterminer si une clé existe

Pour déterminer si une clé existe dans Python2, vous pouvez utiliser has_key, mais cette méthode a été supprimée dans Python3.

Une autre méthode consiste à utiliser le mot-clé in, qui est non seulement compatible avec Python2 et Python3, mais aussi plus rapide et fortement recommandé.

d = {'a': 1, 'b': 2}
if 'a' in d:
print('hello')

Obtenir la valeur dans le dictionnaire

d = {'a': 1, 'b': 2}

# 1、直接用 key 取值，但这种方式不好，如果 key 不存在会报错，推荐使用 get
a = d['a']

# 2、使用 get，如果 key 不存在还可以赋默认值
a = d.get('a')
c = d.get('c', 3)

Parcours du dictionnaire

d = {'a': 1, 'b': 2, 'c': 3}

# 遍历 key
for key in d.keys():
pass

# 遍历 value
for value in d.values():
pass

# 遍历 key 和 value
for key, value in d.items():
pass

Compréhension du dictionnaire

La compréhension de liste et la compréhension de dictionnaire sont mes fonctions préférées, elles sont simples et efficaces. Je peux à peine utiliser la carte et le filtre.

l = [1, 2, 3]
{n: n * n for n in l}
{1: 1, 2: 4, 3: 9}

Les dictionnaires sont triés par clé ou valeur

d = {'a': 1, 'b': 2, 'e': 9, 'c': 5, 'd': 7}

# 按 key 排序
sorted(d.items(), key=lambda t: t[0])
# 按 key 倒序
sorted(d.items(), key=lambda t: t[0], reverse=True)

# 按 value 排序
sorted(d.items(), key=lambda t: t[1])

Il y a une autre exigence que je rencontre souvent pendant le processus de développement, qui est d'avoir une liste, les éléments de la liste sont des dictionnaires, puis de trier la liste par la valeur de le dictionnaire.

l = [{'name': 'a', 'count': 4}, {'name': 'b', 'count': 1}, {'name': 'd', 'count': 2}, {'name': 'c', 'count': 6}]
sorted(l, key=lambda e: e.__getitem__('count'))
# 倒序
sorted(l, key=lambda e: e.__getitem__('count'), reverse=True)

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!