Pythons "Ich kann den juckenden Ort nicht erreichen ..."

Wir haben Python-Techniken, Tipps und Tricks zusammengefasst, die für die tägliche Programmierung nützlich sind.

Wir haben den Vorgang mit Python 3.8.0 bestätigt.

Vergleich von 3 oder mehr Werten

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

Zeitvergleich (Datum Uhrzeit / Datum)

Dank der magischen Methode sind flexible Vergleiche möglich.

Referenz: [Python] Ermöglicht Vergleichsoperationen mit Originalklassen

from datetime import date

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

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

Maximale / minimale Zeit

from datetime import date

#Ich kehre die Reihenfolge absichtlich um
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)

Zeitberechnung

# Input
from datetime import datetime

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

t = goal - start
print(f'Ihre Aufzeichnung ist{t.days}Mit dem Tag{t.seconds}Sekunden')

# Output
'Ihr Rekord liegt bei 2 Tagen und 7200 Sekunden'

Machen Sie die Zeit zum Schlüssel für ein assoziatives Array

Dies ist nützlich, wenn Sie eine datums- und zeitbasierte Aggregation durchführen.

# 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}

Ist der Schlüssel im assoziativen Array enthalten?

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

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

Extrahieren Sie Schlüssel aus dem assoziativen Array

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

Extrahieren Sie Werte aus dem assoziativen Array

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

Extrahieren Sie Schlüssel / Wert-Paare aus einem assoziativen Array

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

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

# Output
foo 1
bar 2
baz 3

Konvertieren Sie ein doppeltes Array in ein assoziatives Array

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

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

Mehrfacharray-Schleife

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

for name, age in rows:
    print(f'{name}Ist{age}ich bin alt')
else:
    print('Ende der Einführung')

# Output
'Yamada ist 20 Jahre alt'
'Tanala ist 18 Jahre alt'
'Sato ist 18 Jahre alt'
'Ende der Einführung'

Schleife, während nur die erforderlichen Elemente aus dem Mehrfacharray extrahiert werden

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

#Extrahieren Sie den Anfang
for last_name, *others in l:
    print(last_name, others)
print()

#Extrahieren Sie das Ende
for *others, circle in l:
    print(circle, others)
print()
    
#Extrahieren Sie die ersten beiden Elemente
# (Wenn Sie keine anderen Elemente benötigen, können Sie im Python-Stil einen doppelten Unterstrich angeben.)
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

Sie können auch so etwas tun.

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

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

# Output
a f

Schleife mit Zähler

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

for i, (name, age) in enumerate(rows, start=1):
    print(f'{i}Linie:Vollständiger Name={name},Alter={age}')

# Output
'Die erste Zeile:Vollständiger Name=Yamada,Alter=20'
'2. Zeile:Vollständiger Name=Tanaka,Alter=18'
'3. Zeile:Vollständiger Name=Sato,Alter=16'

Verhindern Sie schlüssellose Fehler in assoziativen Arrays

Sie müssen nicht jedes Mal "if'key" in dict schreiben.

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

Erweitern Sie Array / assoziatives Array und übergeben Sie es an function

# 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

alle funktionieren

Wenn alle Elemente des Arrays als True ausgewertet werden können, wird True zurückgegeben.

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

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

jede Funktion

Wenn eines der Elemente des Arrays als True ausgewertet werden kann, wird True zurückgegeben.

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

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

Hinweise zu jeder Funktion

Im folgenden Beispiel wird der rechenintensive Prozess (heavy_task) dreimal verschwendet.

# 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

In diesem Fall ist es effizienter, wenn zu verwenden.

# 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

Operation einstellen (Typ einstellen)

Entfernen Sie doppelte Elemente

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

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

Doppelte Elemente extrahieren (Produktset)

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

# Output
{'tanaka'}

Duplikate kombinieren und entfernen (Summensatz)

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

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

Löschen Sie die in sich enthaltenen Elemente aus dem anderen (Differenzsatz)

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

# Output
{'yamada'}

Sammlungen / itertools-Paket

Die Pakete collection und itertools sind nützlich, wenn Sie sagen" Diese Schleifenverarbeitung kann durchgeführt werden, wenn Sie sie ehrlich schreiben, aber sie ist mühsam ... ".

collections.Counter Es zählt die Anzahl der Vorkommen von Elementen und sortiert sie in absteigender Reihenfolge.

# 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 Sie können die Verarbeitung in einem assoziativen Array mit oder ohne Schlüssel ausführen.

Ich weiß nicht, wovon Sie sprechen. Schauen Sie sich also das Codebeispiel an.

# Input
import json
import collections

# defaultdict()Funktion im Argument von(callable)Du kannst alles geben
groups = collections.defaultdict(list)

#Wenn es sich um eine gewöhnliche assoziative Vereinbarung handelt"Es gibt keinen Schlüssel namens Baseball"Fehler tritt auf
groups['baseball'].append('yamada')
groups['tennis'].append('tanaka')
groups['baseball'].append('sato')

print(json.dumps(groups))

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

Das Standarddiktat ist besonders nützlich, wenn Sie einen Aggregationsprozess erstellen. Der Vorgang ist einfach, da Sie nicht die Existenz jedes Schlüssels überprüfen müssen.

# Input
import collections

products = ['Hinweis', 'Empitsu', 'Radiergummi']

sales = [
    ['Hinweis', 1],
    ['Radiergummi', 2],
    ['Radiergummi', 1],
]

aggregates = collections.defaultdict(int)

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

print('---Die heutige Verkaufsleistung---')

for product in products:
    print('%s : %d Stücke' % (product, aggregates[product]))

# Output
---Die heutige Verkaufsleistung---
Hinweis:1 Stück
Empitsu:0 Stück
Radiergummi:Drei

Mehrere assoziative Arrays können auch einfach implementiert werden, indem die Eigenschaft "alles aufrufen, was aufrufbar ist" ausgenutzt wird.

# 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 Es generiert umfassend "Kombinationen" aus zwei oder mehr Arrays.

# 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 Es transformiert ein zweidimensionales Array in ein eindimensionales Array (Abflachen).

# Input
import itertools

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

list(itertools.chain.from_iterable(l))

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

io Paket

Es bietet ein virtuelles Objekt, das wie eine Datei behandelt werden kann.

Es ist praktisch, wenn Sie Tests schreiben.

# 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

Tupel

Tuple ähnelt einem Array, ist jedoch unveränderlich und kann nicht neu zugewiesen werden.

Da es unveränderlich ist, kann es als Schlüssel für assoziative Arrays verwendet werden.

yamada = ('Yamada', 'Taro')  #Das ist tapple
tanaka = ('Tanaka', 'Jiro')  #Dies ist auch ein 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

Durch Verwendung dieser Eigenschaft können ähnliche Daten effizient gruppiert werden.

# 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'])  # (Kreisname,Alter)Generieren Sie einen Taple
    per_circle_age[k].append(v['name'])  #Aggregieren Sie mit tapple als Schlüssel

for (circle, age), members in per_circle_age.items():
    print(f'{circle}Zugehörig{age}Einjähriges Mitglied:{members}')

# Output
"10-jähriges Mitglied des Baseballs:['yamada', 'sato']"
"11-jähriges Mitglied des Baseballs:['suzuki']"
"10-jähriges Tennismitglied:['tanaka']"

Datenklassenpaket

Dies ist eine Funktion, die ab Python 3.7 verwendet werden kann.

Dies ist praktisch, da Sie keine Zuweisungsverarbeitung wie "self.name = name" in den Konstruktor schreiben müssen.

import dataclasses


# frozen=Wahr ist unveränderlich(immutable)Kann als Objekt behandelt werden
@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

#Kann leicht in ein assoziatives Array konvertiert werden
dataclasses.asdict(yamada)  # -> {'last_name': 'Yamada', 'first_name': 'Taro'}

#Vergleich ist möglich
yamada2 = User(last_name='Yamada', first_name='Taro')
yamada == yamada2  # -> True
yamada == tanaka  # -> False
yamada in [yamada2]  # -> True

# "frozen=True"Wenn dies der Fall ist, kann der Wert nicht neu zugewiesen werden.
yamada.last_name = 'Sato'  # -> FrozenInstanceError: cannot assign to field 'last_name'

#Da es unveränderlich ist, kann es als Schlüssel für ein assoziatives Array verwendet werden.
d = {yamada: 'foo', tanaka: 'bar'}

#Betrieb einstellen(Typ einstellen)Ist auch möglich
{yamada, tanaka} & {yamada2}  # -> {User(last_name='Yamada', first_name='Taro')}