Python "Je ne peux pas atteindre l'endroit qui démange ..."

Nous avons résumé les techniques, astuces et astuces Python utiles pour la programmation quotidienne.

Nous avons confirmé l'opération avec Python 3.8.0.

Comparaison de 3 valeurs ou plus

1 == 2 == 3  # -> False
1 < 2 < 3 < 4  # -> True

Comparaison de l'heure (date heure / date)

Des comparaisons flexibles sont possibles grâce à la méthode magique.

Référence: [Python] Permet des opérations de comparaison avec les classes originales

from datetime import date

feb1 = date(2020, 2, 1)
feb2 = date(2020, 2, 2)
feb3 = date(2020, 2, 3)

feb1 < feb2 <= feb2 < feb3  # -> True

Temps maximum / minimum

from datetime import date

#J'inverse intentionnellement l'ordre
dates = [
    date(2020, 2, 3),
    date(2020, 2, 2),
    date(2020, 2, 1),
]

min(dates)  # -> datetime.date(2020, 2, 1)
max(dates)  # -> datetime.date(2020, 2, 3)

Calcul du temps

# Input
from datetime import datetime

start = datetime(2020, 2, 1, 10)
goal = datetime(2020, 2, 3, 12)

t = goal - start
print(f'Votre dossier est{t.days}Avec le jour{t.seconds}Secondes')

# Output
'Votre record est de 2 jours et 7200 secondes'

Faire du temps la clé d'un tableau associatif

Ceci est utile pour effectuer une agrégation basée sur la date et l'heure.

# Input
from datetime import date

counts = {
    date(2020, 2, 1): 0,
    date(2020, 3, 1): 0,
}
counts[date(2020, 2, 1)] += 1
counts[date(2020, 2, 1)] += 1
counts[date(2020, 3, 1)] += 1

print(counts)

# Output
{datetime.date(2020, 2, 1): 2, datetime.date(2020, 3, 1): 1}

La clé est-elle incluse dans le tableau associatif?

d = {
    'foo': 1,
    'bar': 2,
    'baz': 3,
}

print('foo' in d)  # -> True

Extraire les clés du tableau associatif

d = {
    'foo': 1,
    'bar': 2,
    'baz': 3,
}
print(list(d))  # -> ['foo', 'bar', 'baz']

Extraire les valeurs du tableau associatif

d = {
    'foo': 1,
    'bar': 2,
    'baz': 3,
}
print(list(d.values()))  # -> [1, 2, 3]

Extraire des paires clé / valeur d'un tableau associatif

d = {
    'foo': 1,
    'bar': 2,
    'baz': 3,
}

for key, value in d.items():
    print(key, value)

# Output
foo 1
bar 2
baz 3

Convertir un double tableau en tableau associatif

# Input
l = [
    ['Yamada', 'baseball'],
    ['Tanaka', 'soccer'],
    ['Sato', 'tennis'],
]
dict(l)

# Output
{'Yamada': 'baseball', 'Tanaka': 'soccer', 'Sato': 'tennis'}

Boucle de tableau multiple

# Input
rows = [
    ['yamada', 20],
    ['tanala', 18],
    ['sato', 18],
]

for name, age in rows:
    print(f'{name}Est{age}je suis vieux')
else:
    print('Fin de l'introduction')

# Output
'yamada a 20 ans'
'tanala a 18 ans'
'sato a 18 ans'
'Fin de l'introduction'

Boucle en extrayant uniquement les éléments nécessaires du tableau multiple

# Input
l = [
    ['Yamada', 'Taro', 20, 'baseball'],
    ['Tanaka', 'Jiro', 18, 'circle'],
]

#Extraire le début
for last_name, *others in l:
    print(last_name, others)
print()

#Extraire la fin
for *others, circle in l:
    print(circle, others)
print()
    
#Extraire les deux premiers éléments
# (Si vous n'avez pas besoin d'autres éléments, c'est le style Python pour spécifier un double trait de soulignement.)
for last_name, first_name, *__ in l:
    print(last_name, first_name)

# Output
Yamada ['Taro', 20, 'baseball']
Tanaka ['Jiro', 18, 'circle']

baseball ['Yamada', 'Taro', 20]
circle ['Tanaka', 'Jiro', 18]

Yamada Taro
Tanaka Jiro

Vous pouvez également faire quelque chose comme ça.

# Input
l = [
    ['a', 'b', 'c', ['d', 'e', 'f']],
]

for one, *__, (*__, two) in l:
    print(one, two)

# Output
a f

Boucle avec compteur

# Input
rows = [
    ['Yamada', 20],
    ['Tanaka', 18],
    ['Sato', 16],
]

for i, (name, age) in enumerate(rows, start=1):
    print(f'{i}Ligne:Nom complet={name},âge={age}')

# Output
'La première ligne:Nom complet=Yamada,âge=20'
'2e ligne:Nom complet=Tanaka,âge=18'
'3e ligne:Nom complet=Sato,âge=16'

Empêcher les erreurs sans clé dans les tableaux associatifs

Vous n'avez pas besoin d'écrire ʻif'key 'dans dict` à chaque fois.

d = {
    'Yamada': 20,
    'Tanaka': 18
}
d.get('Yamada')  # -> 20
d.get('Sato')  # -> None
d.get('Sato', 'Pas d'âge')  # -> Pas d'âge

Développez le tableau / tableau associatif et passez-le à la fonction

# Input
def func(a, b, c=None, d=None):
    print(a)
    print(b)
    print(c)
    print(d)


l = ['aaa', 'bbb']
d = {'c': 'ccc', 'd': 'ddd'}

func(*l, **d)

# Output
aaa
bbb
ccc
ddd

toute fonction

Si tous les éléments du tableau peuvent être évalués comme True, il renverra True.

l = [
    True,
    1,
    "foo",
]
all(l)  # -> True

l = [
    True,
    1,
    "",
]
all(l)  # -> False

toute fonction

Si l'un des éléments du tableau peut être évalué comme True, il renverra True.

l = [
    False,
    0,
    "foo",
]
any(l)  # -> True

l = [
    False,
    0,
    "",
]
any(l)  # -> False

Notes sur n'importe quelle fonction

Dans l'exemple ci-dessous, le processus coûteux en calcul (heavy_task) est gaspillé trois fois.

# Input
def heavy_task(ret):
    print(ret)
    return ret


if any([heavy_task(True), heavy_task(False), heavy_task(False)]):
    print('Complete')

# Output
True
False
False
Complete

Dans ce cas, il est plus efficace d'utiliser if.

# Input
def heavy_task(ret):
    print(ret)
    return ret


if heavy_task(True) or heavy_task(False) or heavy_task(False):
    print('Complete')

# Output
True
Complete

Opération de réglage (type de réglage)

Supprimer les éléments en double

# Input
l = ['yamada', 'tanaka', 'yamada', 'sato']
print(set(l))

# Output
{'sato', 'tanaka', 'yamada'}

Extraire les éléments en double (ensemble de produits)

# Input
l1 = ['yamada', 'tanaka', 'yamada', 'sato']
l2 = ['tanaka']
print(set(l1) & set(l2))

# Output
{'tanaka'}

Combiner et supprimer les doublons (ensemble de somme)

# Input
l1 = ['yamada', 'tanaka']
l2 = ['yamada', 'sato']
print(set(l1) | set(l2))

# Output
{'sato', 'tanaka', 'yamada'}

Supprimer les éléments contenus en lui-même de l'autre (jeu de différences)

# Input
l1 = ['yamada', 'tanaka']
l2 = ['tanaka']
print(set(l1) - set(l2))

# Output
{'yamada'}

paquet collections / itertools

Les paquets collections et ʻitertools` sont utiles quand vous dites" Ce traitement en boucle peut être fait si vous l'écrivez honnêtement, mais c'est gênant ... ".

collections.Counter Il compte le nombre d'occurrences d'éléments et les trie par ordre décroissant.

# Input
import collections

l = ['a', 'b', 'c', 'a', 'a', 'c']
c = collections.Counter(l)
print(c.most_common())

# Output
[('a', 3), ('c', 2), ('b', 1)]

collections.defaultdict Vous pouvez exécuter le traitement sur un tableau associatif avec ou sans clé.

Je ne sais pas de quoi vous parlez, alors regardez l'exemple de code.

# Input
import json
import collections

# defaultdict()Fonction dans l'argument de(callable)Tu peux tout donner
groups = collections.defaultdict(list)

#S'il s'agit d'un arrangement associatif ordinaire"Il n'y a pas de clé appelée baseball"Erreur se produit
groups['baseball'].append('yamada')
groups['tennis'].append('tanaka')
groups['baseball'].append('sato')

print(json.dumps(groups))

# Output
{"baseball": ["yamada", "sato"], "tennis": ["tanaka"]}

Le defaultdict est particulièrement utile lors de la création d'une sorte de processus d'agrégation. Le processus est simple car vous n'avez pas à vérifier l'existence de chaque clé.

# Input
import collections

products = ['Remarque', 'Empitsu', 'la gomme']

sales = [
    ['Remarque', 1],
    ['la gomme', 2],
    ['la gomme', 1],
]

aggregates = collections.defaultdict(int)

for product, cnt in sales:
    aggregates[product] += cnt

print('---Les performances commerciales d'aujourd'hui---')

for product in products:
    print('%s : %d pièces' % (product, aggregates[product]))

# Output
---Les performances commerciales d'aujourd'hui---
Remarque:1 pièce
Empitsu:0 pièces
la gomme:Trois

Plusieurs tableaux associatifs peuvent également être implémentés simplement en tirant parti de la propriété de «transmettre tout ce qui est appelable».

# Input
import json
from collections import defaultdict

nested = defaultdict(lambda: defaultdict(int))

nested['a']['a'] += 1
nested['a']['a'] += 1
nested['a']['b'] += 1
nested['b']['c'] += 1

print(json.dumps(nested))

# Output
{"a": {"a": 2, "b": 1}, "b": {"c": 1}}

itertools.product Il génère globalement des «combinaisons» à partir de deux ou plusieurs tableaux.

# Input
import itertools

a = ['a1', 'a2']
b = ['b1', 'b2', 'b3']
c = ['c1']

list(itertools.product(a, b, c))

# Output
[('a1', 'b1', 'c1'),
 ('a1', 'b2', 'c1'),
 ('a1', 'b3', 'c1'),
 ('a2', 'b1', 'c1'),
 ('a2', 'b2', 'c1'),
 ('a2', 'b3', 'c1')]

itertools.chain.from_iterable Il transforme un tableau à deux dimensions en un tableau à une dimension (aplatir).

# Input
import itertools

l = [
    ['a1', 'a2'],
    ['b1', 'b2', 'b3'],
]

list(itertools.chain.from_iterable(l))

# Output
['a1', 'a2', 'b1', 'b2', 'b3']

paquet io

Il fournit un objet virtuel qui peut être traité comme un fichier.

Il est utile lors de la rédaction de tests.

# Input
import io


def writer(f, text):
    f.write(text)


def printer(f):
    print(f.read())


sio = io.StringIO()

writer(sio, 'foo\n')
writer(sio, 'bar\n')
writer(sio, 'baz\n')

sio.seek(0)
printer(sio)

# Output
foo
bar
baz

Tuple

Tuple est similaire à un tableau, mais il est immuable et ne peut pas être réaffecté.

Parce qu'il est immuable, il peut être utilisé comme clé pour les tableaux associatifs.

yamada = ('Yamada', 'Taro')  #C'est tapple
tanaka = ('Tanaka', 'Jiro')  #C'est aussi un taple

print(yamada[0])  # -> Yamada

yamada[0] = 'Tanaka'  # TypeError: 'tuple' object does not support item assignment

ages = {
    yamada: 20,
    tanaka: 18,
}

print(ages[tanaka])  # -> 18

En utilisant cette caractéristique, des données similaires peuvent être regroupées efficacement.

# Input
from collections import defaultdict

data = [
    {'circle': 'baseball', 'name': 'yamada', 'age': 10},
    {'circle': 'baseball', 'name': 'sato', 'age': 10},
    {'circle': 'baseball', 'name': 'suzuki', 'age': 11},
    {'circle': 'tennis', 'name': 'tanaka', 'age': 10},
]

per_circle_age = defaultdict(list)

for v in data:
    k = (v['circle'], v['age'])  # (Nom du cercle,âge)Générer un taple
    per_circle_age[k].append(v['name'])  #Agréger en utilisant le tapple comme clé

for (circle, age), members in per_circle_age.items():
    print(f'{circle}Appartenir à{age}Membre d'un an:{members}')

# Output
"Membre de baseball de 10 ans:['yamada', 'sato']"
"Membre du baseball de 11 ans:['suzuki']"
"Membre de tennis de 10 ans:['tanaka']"

package dataclasses

C'est une fonction qui peut être utilisée à partir de Python 3.7.

C'est pratique car vous n'avez pas besoin d'écrire un traitement d'affectation tel que self.name = name dans le constructeur.

import dataclasses


# frozen=Vrai est invariant(immutable)Peut être traité comme un objet
@dataclasses.dataclass(frozen=True)
class User:
    last_name: str
    first_name: str
        
    def full_name(self):
        return f'{self.last_name} {self.first_name}'
        
        
yamada = User(last_name='Yamada', first_name='Taro')
tanaka = User(last_name='Tanaka', first_name='Jiro')

yamada.full_name()  # -> Yamada Taro

#Peut être facilement converti en un tableau associatif
dataclasses.asdict(yamada)  # -> {'last_name': 'Yamada', 'first_name': 'Taro'}

#La comparaison est possible
yamada2 = User(last_name='Yamada', first_name='Taro')
yamada == yamada2  # -> True
yamada == tanaka  # -> False
yamada in [yamada2]  # -> True

# "frozen=True"Si c'est le cas, la valeur ne peut pas être réaffectée.
yamada.last_name = 'Sato'  # -> FrozenInstanceError: cannot assign to field 'last_name'

#Puisqu'il est immuable, il peut être utilisé comme clé pour un tableau associatif.
d = {yamada: 'foo', tanaka: 'bar'}

#Régler l'opération(Définir le type)Est également possible
{yamada, tanaka} & {yamada2}  # -> {User(last_name='Yamada', first_name='Taro')}