Transformarea unei colecții
O transformare pornește de la o colecție, cum ar fi o listă sau un dicționar, și construiește din ea o colecție nouă. Colecția originală nu se schimbă.
În Python, instrumentul principal este comprehension: o expresie scurtă între paranteze drepte care construiește o listă nouă, sau între acolade pentru un dicționar nou. Majoritatea transformărilor de pe această pagină au o singură linie. Funcțiile predefinite zip și enumerate și metoda de șir join acoperă restul.
Python are și o funcție predefinită map(), care aplică o funcție fiecărui element. Funcționează, dar un comprehension spune același lucru mai clar și poate și să sară peste elemente, așa că această pagină folosește comprehension-uri.
Map
Operația map aplică aceeași funcție fiecărui element și adună rezultatele într-o listă nouă, de aceeași lungime. De exemplu, poate transforma [1, 2, 3] în [3, 6, 9].
În Python scrii un list comprehension: [x * 3 for x in numbers]. Se citește aproape ca o propoziție: lista nouă conține x * 3 pentru fiecare x din numbers.
Nu confunda asta cu funcția predefinită map() din Python, care face aceeași treabă primind un obiect funcție. Aici „map” înseamnă „aplică o expresie fiecărui element”.
Map cu un list comprehension
Comprehension-ul calculează expresia pentru fiecare element și adună rezultatele într-o listă nouă. Aici înmulțește fiecare număr cu 3.
Ieșire: program Python complet
numbers = [1, 2, 3]
# comprehension-ul aplică expresia fiecărui element
tripled = [x * 3 for x in numbers]
print(tripled)
Map cu indexul
Uneori contează și poziția unui element. enumerate îți dă atât indexul, cât și valoarea, așa că comprehension-ul le poate folosi pe amândouă. Aici fiecare valoare este înmulțită cu propriul ei index.
Ieșire: program Python complet
numbers = [1, 2, 3]
# enumerate dă indexul și valoarea fiecărui element
result = [value * idx for idx, value in enumerate(numbers)]
print(result)
Omiterea unor rezultate
Uneori anumite rezultate trebuie eliminate. În Python, o funcție poate returna None ca să spună „niciun rezultat”. Primul comprehension păstrează fiecare răspuns, inclusiv None. Al doilea are o parte if care păstrează doar rezultatele care nu sunt None.
Ieșire: program Python complet
def triple_or_none(x):
if x == 2:
return None # niciun rezultat pentru acest element
return x * 3
numbers = [1, 2, 3]
mapped = [triple_or_none(x) for x in numbers]
print(mapped)
# partea if elimină fiecare rezultat None
result = [r for r in mapped if r is not None]
print(result)
Transformarea cheilor unui dicționar
Ca să schimbi cheile unui dicționar, construiește un dicționar nou cu un dict comprehension peste items(). Aici upper() transformă fiecare cheie în majuscule. Un dicționar își păstrează intrările în ordinea inserării, așa că rezultatul apare mereu în aceeași ordine.
Ieșire: program Python complet
numbers_map = {"key1": 1, "key2": 2}
# copiază fiecare intrare, dar transformă cheia în majuscule
upper_keys = {key.upper(): value for key, value in numbers_map.items()}
print(upper_keys)
Transformarea valorilor unui dicționar
Ca să schimbi valorile, procedează la fel, dar păstrează cheia și calculează o valoare nouă. Aici fiecare valoare crește cu lungimea cheii ei: 1 + len("key1") este 5.
Ieșire: program Python complet
numbers_map = {"key1": 1, "key2": 2}
# păstrează cheia, schimbă valoarea
new_values = {key: value + len(key) for key, value in numbers_map.items()}
print(new_values)
Zip
Operația zip ia două liste și le împerechează elementele după poziție: primul cu primul, al doilea cu al doilea și așa mai departe. Rezultatul are atâtea perechi câte elemente are lista mai scurtă.
Python are o funcție predefinită zip. Ea returnează un iterator leneș de tupluri, așa că pune-o în list() când vrei să vezi sau să refolosești perechile.
Zip pentru două liste
zip împerechează o culoare cu un animal și se oprește singură la lista mai scurtă. Fiecare pereche este un tuplu, afișat între paranteze rotunde.
Ieșire: program Python complet
colors = ["red", "brown", "grey"]
animals = ["fox", "bear", "wolf"]
# zip împerechează elementele după poziție și se oprește la lista mai scurtă
pairs = list(zip(colors, animals))
print(pairs)
Zip cu o transformare
Nu ai mereu nevoie de perechile propriu-zise. Aici un comprehension parcurge zip(colors, animals) și construiește o propoziție din fiecare pereche. capitalize() face ca prima literă a numelui animalului să fie majusculă.
Ieșire: program Python complet
colors = ["red", "brown", "grey"]
animals = ["fox", "bear", "wolf"]
# folosește direct ambele elemente ca să construiești o propoziție
sentences = ["Animalul " + animal.capitalize() + " are culoarea " + color
for color, animal in zip(colors, animals)]
for line in sentences:
print(line)
Despărțirea unei liste de perechi
Despărțirea (unzip) este operația inversă: o listă de perechi devine două colecții. Steluța din zip(*number_pairs) despachetează lista, astfel încât zip primește cele trei perechi ca argumente separate și regrupează primele lor părți și a doua lor parte. Cele două rezultate sunt tupluri.
Ieșire: program Python complet
number_pairs = [("one", 1), ("two", 2), ("three", 3)]
# steluța despachetează lista, zip regrupează primele și a doua parte
words, numbers = zip(*number_pairs)
print(words)
print(numbers)
Asocierea
Asocierea construiește un dicționar dintr-o listă. Fiecare element îți dă o cheie și o valoare. Un dicționar nu poate conține aceeași cheie de două ori, așa că, dacă două elemente produc aceeași cheie, câștigă cel de mai târziu.
În Python scrii un dict comprehension: {key: value for element in items}, unde cheia și valoarea sunt calculate din fiecare element.
Elementele ca chei
Elementul însuși devine cheia, iar din el se calculează o valoare. Aici cuvintele sunt chei, iar lungimile lor sunt valori.
Ieșire: program Python complet
numbers = ["one", "two", "three"]
# fiecare cuvânt devine o cheie, lungimea lui devine valoarea
lengths = {word: len(word) for word in numbers}
print(lengths)
Elementele ca valori
Elementul devine valoarea, iar cheia se calculează din el. Aici cheia este prima literă, scrisă cu majusculă. Atât two, cât și three încep cu T, așa că three îl înlocuiește pe two, iar dicționarul are doar două intrări.
Ieșire: program Python complet
numbers = ["one", "two", "three"]
# cheia este prima literă; un cuvânt de mai târziu îl înlocuiește
# pe unul anterior cu aceeași cheie
by_first_letter = {word[0].upper(): word for word in numbers}
print(by_first_letter)
Calcularea atât a cheii, cât și a valorii
Poți calcula din element atât cheia, cât și valoarea. Aici cheia este prima literă, iar valoarea este lungimea cuvântului. Din nou, câștigă intrarea T de mai târziu.
Ieșire: program Python complet
numbers = ["one", "two", "three"]
# cheia este prima literă, valoarea este lungimea cuvântului
length_by_letter = {word[0].upper(): len(word) for word in numbers}
print(length_by_letter)
Cheia și valoarea dintr-un singur element
Uneori un singur element conține ambele părți. split() taie un nume complet la spații într-o listă de cuvinte, iar despachetarea dă nume celor două părți. Numele de familie devine cheia, iar prenumele devine valoarea.
Ieșire: program Python complet
names = ["Alice Adams", "Brian Brown"]
by_last_name = {}
for full_name in names:
first, last = full_name.split() # împarte la spații
by_last_name[last] = first # nume de familie -> prenume
print(by_last_name)
Aplatizarea
Aplatizarea transformă o colecție imbricată, cum ar fi o listă de liste, într-o singură listă simplă cu toate elementele în ordine.
Un comprehension poate avea două părți for: [n for inner in number_sets for n in inner]. Citește-le de la stânga la dreapta: pentru fiecare listă interioară, pentru fiecare element din ea, păstrează elementul.
Aplatizarea unei liste de liste
Comprehension-ul vizitează fiecare listă interioară și adună toate elementele ei în result. Două liste interioare de câte trei numere devin o singură listă de șase.
Ieșire: program Python complet
number_sets = [[1, 2, 3], [4, 5, 6]]
# pentru fiecare listă interioară, pentru fiecare element din ea, păstrează elementul
result = [n for inner in number_sets for n in inner]
print(result)
Aplatizarea valorilor din obiecte
Un flat map scoate mai întâi o listă din fiecare element, apoi unește toate aceste liste. Aici primul for parcurge containerele, iar al doilea parcurge c.values. Toate valorile din cele trei containere ajung într-o singură listă.
Ieșire: program Python complet
class Container:
def __init__(self, values):
self.values = values
containers = [
Container(["one", "two", "three"]),
Container(["four", "five"]),
Container(["six", "seven", "eight"]),
]
# ia valorile fiecărui container și adaugă-le pe toate într-o singură listă
result = [value for c in containers for value in c.values]
print(result)
Reprezentarea ca șir
Deseori vrei să afișezi o colecție ca text ușor de citit, de exemplu cu virgule între elemente.
În Python, șirul separator are metoda join: ", ".join(words) returnează un singur șir. join acceptă doar șiruri, așa că numerele trebuie convertite mai întâi, de exemplu cu str(n) într-un comprehension. Extrasele — un prefix, un sufix, o limită sau o transformare — se fac cu simpla concatenare de șiruri sau cu o feliere înainte de unire.
Unirea cu un separator
join pune ", " între cuvinte și returnează un singur șir. Observă că separatorul vine primul: este șirul pe care apelezi metoda.
Ieșire: program Python complet
numbers = ["one", "two", "three"]
print(", ".join(numbers))
Adăugarea unui prefix și a unui sufix
Un prefix și un sufix sunt doar text în jurul rezultatului unit. În Python le adaugi cu +.
Ieșire: program Python complet
numbers = ["one", "two", "three"]
# adaugă prefixul și sufixul în jurul textului unit
text = "început: " + " | ".join(numbers) + ": sfârșit"
print(text)
Limitarea numărului de elemente
Pentru o listă lungă, poate vrei să afișezi doar primele câteva elemente. Felierea numbers[:10] ia primele 10, comprehension-ul transformă fiecare într-un șir cu str(n), iar "<...>" de la final arată că au fost tăiate și alte elemente.
Ieșire: program Python complet
numbers = list(range(1, 101))
# ia doar primele 10 numere, ca șiruri
limit = 10
parts = [str(n) for n in numbers[:limit]]
if len(numbers) > limit:
parts.append("<...>")
print(", ".join(parts))
Transformarea fiecărui element înainte de unire
Ca să schimbi fiecare element înainte de unire, construiește cu un comprehension o listă nouă de șiruri, apoi apelează join pe ea. Aici fiecare cuvânt devine "Element: " urmat de cuvântul scris cu majuscule.
Ieșire: program Python complet
numbers = ["one", "two", "three"]
# schimbă mai întâi fiecare cuvânt, apoi unește rezultatele
parts = ["Element: " + word.upper() for word in numbers]
print(", ".join(parts))