În cadrul acestui ghid, vei descoperi cum să utilizezi funcția `map()` din Python pentru a aplica o anumită funcție fiecărui element dintr-o structură iterabilă.
Python integrează principiile programării funcționale, oferind posibilitatea de a structura sarcinile ca evaluări de funcții. Funcțiile în Python sunt tratate ca obiecte, ceea ce înseamnă că o funcție poate primi o altă funcție ca parametru și, totodată, poate returna o altă funcție.
Funcția `map()` primește o funcție ca argument și permite aplicarea acesteia asupra tuturor elementelor dintr-o secvență.
După parcurgerea acestui tutorial, vei fi capabil să folosești funcția `map()` din Python pentru a simplifica buclele și a înlocui structurile de tip list comprehension. Vom analiza mai multe exemple practice pentru a ilustra diferitele modalități de utilizare ale acestei funcții.
Modalități de Aplicare a Funcțiilor pe Elementele unei Liste în Python
Vom începe cu un exemplu concret. 👩🏫
Aici, `nums` este o listă care conține valori numerice.
nums = [2,4,3,7]
Să luăm în considerare funcția `self_pow()`. Aceasta primește un număr ca argument și returnează numărul ridicat la puterea lui însuși, adică `n**n`.
În Python, `**` este operatorul de exponențiere. `a**b` returnează rezultatul lui `a` ridicat la puterea `b`, adică ab.
def self_pow(n):
return n**n
Obiectiv: Generarea unei noi liste, `nums_pow`, prin aplicarea funcției `self_pow()` fiecărui element din lista `nums`.
Utilizarea Buclei `for`
Pentru a realiza acest lucru, se poate utiliza o buclă `for`:
- Pentru fiecare element din lista `nums`, se apelează funcția `self_pow()` cu acel element ca argument.
- Rezultatul acestei operații este adăugat la lista nou creată `nums_pow`.
nums_pow = []
for num in nums:
nums_pow.append(self_pow(num))
print(nums_pow)
În rezultat, fiecare număr din lista `nums` este ridicat la propria sa putere. Elementele din `nums_pow` sunt 22, 44, 33 și 77.
Ieșire [4, 256, 27, 823543]
Utilizarea List Comprehension
Acest proces poate fi realizat mai concis prin utilizarea list comprehension. Din structura buclei `for` de mai sus, se pot identifica expresia de ieșire și elementul iterabil.
Astfel, se poate aplica formatul general al unei expresii de list comprehension:
new_list = [<expresie de ieșire> for item in iterable]
În contextul nostru, expresia de list comprehension pentru a genera `nums_pow` este următoarea:
nums_pow = [self_pow(num) for num in nums] print(nums_pow)
Rezultatul este identic cu cel obținut prin utilizarea buclei `for`.
Ieșire [4, 256, 27, 823543]
În locul buclelor și list comprehension, putem utiliza funcția `map()` din Python pentru a aplica o funcție fiecărui element dintr-o structură iterabilă într-un mod concis. Vom începe prin a analiza sintaxa funcției `map()`.
Sintaxa Funcției `map()` în Python
Sintaxa generală pentru utilizarea funcției `map()` în Python este următoarea:
map(funcție, iterabil_1,[iterabil_2,...,iterabil_n])
Funcția `map()` primește cel puțin două argumente: o funcție și un iterabil.
În sintaxa de mai sus:
- `funcție` reprezintă o funcție Python sau orice alt obiect care poate fi apelat, inclusiv funcții definite de utilizator, funcții încorporate, clase, metode de instanță sau de clasă, etc.
- `iterabil` este orice obiect iterabil valid în Python, cum ar fi o listă, un tuplu sau un șir de caractere.
- Funcția `map()` aplică funcția specificată fiecărui element din structura iterabilă dată.
Ce returnează funcția `map()`?
Funcția returnează un obiect de tip `map`, care poate fi convertit într-o listă utilizând sintaxa: `list(map(funcție,iterabil))`.
În funcție de necesități, acest obiect poate fi transformat într-un tuplu sau alt tip de structură de date.
Acum, că am analizat sintaxa funcției `map()`, să trecem la exemple practice.
Pentru a urma acest tutorial, ar trebui să ai instalată versiunea Python 3.x. Dacă nu, poți folosi editorul online Python de pe tipstrick.ro pentru a rula exemplele de cod.
Utilizarea `map()` cu Funcții Definite de Utilizator
#1. Anterior, am aplicat funcția `self_pow()` fiecărui element dintr-o listă. Utilizând funcția `map()`, putem furniza funcția `self_pow` și lista `nums` ca argumente.
Notă: Specifică doar numele funcției, nu și un apel de funcție. Folosește `self_pow`, nu `self_pow()`.
Funcția `map()` returnează un obiect `map`.
print(map(self_pow,nums)) <map object at 0x7f7d315c14d0>
Acest obiect `map` poate fi convertit într-o listă utilizând funcția `list()`, așa cum se arată mai jos.
nums_pow = list(map(self_pow,nums)) print(nums_pow)
Rezultatul obținut va afișa fiecare număr din lista `nums` ridicat la puterea sa.
Ieșire [4, 256, 27, 823543]
#2. Să analizăm funcția `inch_to_cm()` care convertește inchi în centimetri. Un inch este echivalent cu 2.54 cm.
def inch_to_cm(inch):
return inch*2.54
Pentru a converti valorile din lista `inches` în centimetri, vom utiliza funcția `map()` conform codului de mai jos:
inches = [5.54,3.4,1,25,8.2] cms = list(map(inch_to_cm,inches)) print(cms)
Lista `cms` va conține valorile în centimetri corespunzătoare valorilor în inchi din lista `inches`.
Ieșire [14.0716, 8.636, 2.54, 63.5, 20.828]
Utilizarea `map()` cu Funcții Încorporate
În această secțiune, vom explora utilizarea `map()` cu funcții încorporate în Python.
#1. Presupunem că avem o listă de șiruri de caractere reprezentând limbaje de programare. Dorim să creăm o nouă listă, `strings_upper`, care să conțină aceste limbaje, dar scrise cu majuscule.
strings = ['JavaScript','Rust','Python','Go']
Metoda încorporată `.upper()` aplicată unui șir returnează o copie a șirului formatată cu majuscule.
strings_upper = list(map(str.upper,strings)) print(strings_upper)
Lista `strings_upper` va conține șirurile din lista `strings`, formatate cu majuscule.
Ieșire ['JAVASCRIPT', 'RUST', 'PYTHON', 'GO']
#2. Funcția încorporată `len()` din Python primește un obiect iterabil ca argument și returnează lungimea sa. Pentru a afla lungimea fiecărui șir din lista `strings`, vom utiliza funcția `map()` pentru a aplica `len()` fiecărui element din listă, după cum se arată mai jos.
strings_len = list(map(len,strings)) print(strings_len)
Ieșire [10, 4, 6, 2]
#3. Funcția `map()` poate fi utilizată și cu alte tipuri de colecții, cum ar fi tuplurile.
Următorul exemplu include un tuplu cu informații despre numărul de dormitoare, suprafața și orașul în care se află o casă.
În Python, funcția `type()` returnează tipul de date al unui obiect. Pentru a obține tipul de date al fiecărui element din acest tuplu, vom folosi `map()` pentru a aplica `type()` fiecărui element.
house = (2,758.5,'Bangalore') house_elt_type = tuple(map(type,house)) print(house_elt_type)
Am transformat obiectul `map` într-un tuplu. Acesta poate fi transformat într-o listă sau altă colecție.
În rezultat, se poate observa că tipurile de date pentru 2, 758.5 și Bangalore sunt deduse ca `int`, `float`, respectiv `str`.
Ieșire (<class 'int'>, <class 'float'>, <class 'str'>)
#4. În Python, se pot importa module încorporate și se pot utiliza funcțiile definite în aceste module.
Pentru a calcula rădăcina pătrată a fiecărui număr dintr-o listă, vom utiliza funcția `sqrt` din modulul `math`.
import math nums = [30,90,34,45,97] nums_sqrt = list(map(math.sqrt,nums)) print(nums_sqrt)
Ieșire [5.477225575051661, 9.486832980505138, 5.830951894845301, 6.708203932499369, 9.848857801796104]
Rezultatul de mai sus este greu de interpretat. Poate fi util să rotunjim fiecare valoare a rădăcinii pătrate la două zecimale.
Rotunjirea unui Număr cu Virgulă Mobilă
Vom defini o funcție `round_2()` care primește un număr cu virgulă mobilă și îl rotunjește la două zecimale.
def round_2(num):
return round(num,2)
Acum, vom folosi funcția `map()` cu lista `round_2` și `nums_sqrt`.
nums_sqrt_round = list(map(round_2,nums_sqrt)) print(nums_sqrt_round)
Ieșire [5.48, 9.49, 5.83, 6.71, 9.85]
De asemenea, se pot utiliza funcții `map()` imbricate, în care funcția `map()` interioară este utilizată pentru a calcula lista `nums_sqrt`, iar `map()` exterioară rotunjește rezultatele.
nums_sqrt_round = list(map(round_2,list(map(math.sqrt,nums)))) print(nums_sqrt_round)
Ieșire [5.48, 9.49, 5.83, 6.71, 9.85]
Ambele abordări oferă același rezultat. Însă, atunci când se folosesc funcții imbricate, codul ar trebui să fie ușor de citit și de întreținut.
Utilizarea `map()` cu Funcții Lambda
În secțiunile anterioare, am învățat cum să utilizăm funcția `map()` cu funcții încorporate și definite de utilizator. Vom învăța acum să utilizăm `map()` cu funcții lambda, care sunt funcții anonime în Python.
În anumite situații, este posibil să avem funcții care conțin doar o singură linie de cod și pe care trebuie să le folosim o singură dată. Pentru aceste cazuri, putem defini funcții lambda în Python.
Notă: Sintaxa generală pentru a utiliza o funcție lambda în Python este: `lambda args: expresie`.
#1. Fie lista `strings`. Presupunem că dorim să creăm o listă `strings_rev` care să conțină șirurile inversate.
strings = ['JavaScript','Rust','Python','Go']
Se poate inversa un șir în Python prin tehnica de slicing.
Notă: Generalizarea expresiei `str[start:stop:step]`.
– Fără valorile `start` și `stop`, slicing-ul începe de la începutul șirului și continuă până la sfârșit.
– Valorile negative ale pasului determină slicing-ul de la sfârșitul șirului.
– Astfel, `str[::-1]` returnează o copie inversată a șirului.
Vom utiliza funcția lambda: `lambda x:x[::-1]` împreună cu funcția `map()`, după cum se arată mai jos.
strings_rev = list(map(lambda x:x[::-1],strings)) print(strings_rev)
Similar cu exemplele anterioare, convertim obiectul `map` într-o listă. Rezultatul ne arată că fiecare șir din lista `strings` a fost inversat.
Ieșire ['tpircSavaJ', 'tsuR', 'nohtyP', 'oG']
#2. Anterior, am calculat rădăcina pătrată a fiecărui număr din lista `nums` și am rotunjit fiecare rezultat la două zecimale.
Am utilizat funcția `round_2()` pentru a face acest lucru. Acum, vom rescrie funcția `round_2()` ca o funcție lambda și o vom utiliza cu `map()`, așa cum este ilustrat mai jos.
nums_sqrt_round_l =list(map(lambda num:round(num,2),nums_sqrt)) print(nums_sqrt_round_l)
Rezultatul este identic cu cel obținut folosind funcția `round_2()`.
Ieșire [5.48, 9.49, 5.83, 6.71, 9.85]
Utilizarea `map()` cu Mai Multe Obiecte Iterabile
În exemplele de până acum, am aplicat o funcție fiecărui element al unui singur obiect iterabil.
Uneori, este posibil să avem funcții care primesc două sau mai multe argumente. În acest caz, fiecare argument este stocat într-o listă sau altă structură similară.
Funcția `map()` din Python poate fi utilizată cu mai multe liste.
#1. Considerăm funcția `area()` care primește lungimea și lățimea ca input și returnează aria, calculată ca `lungime*lățime`.
def area(length,breadth):
return length*breadth
Lungimea și lățimea diferitelor dreptunghiuri sunt stocate în două liste separate, `lengths` și `breadths`.
lengths = [4,8,10,18] breadths = [9,4,6,11]
Putem utiliza `map()` pentru a aplica funcția `area()` listelor de mai sus, transmițând atât lista `lengths`, cât și `breadths`.
areas = list(map(area,lengths,breadths)) print(areas)
Deoarece funcția `area()` primește două argumente, valorile lungimii și lățimii sunt utilizate din listele `lengths` și `breadths`, respectiv.
Ieșire [36, 32, 60, 198]
#2. Modulul `math` din Python are funcția `log()` pentru a calcula logaritmul unui număr la o anumită bază.
Notă: `log(x, bază)` returnează logaritmul lui x la baza specificată, logbazăx. Dacă baza nu este specificată, valoarea implicită este `e` (logaritm natural).
În acest exemplu:
- Lista `x` corespunde valorilor pentru care dorim să calculăm logaritmul.
- Lista `base` conține valorile bazei pentru calculele logaritmilor.
x = [2,6,12,10] base = [2,3,2,5]
Putem utiliza `map()` cu funcția `math.log()`, listele `x` și `base` pentru a obține o nouă listă, `log_x`, după cum urmează.
log_x = list(map(math.log,x,base)) print(log_x)
Rezultatul este:
Ieșire [1.0, 1.6309297535714573, 3.5849625007211565, 1.4306765580733933]
Concluzii
În acest tutorial, am învățat următoarele:
- Funcția `map()` din Python primește cel puțin două argumente: o funcție și un iterabil, având sintaxa `map(funcție, iterabil(e))`.
- Funcția poate fi orice obiect valid apelabil în Python.
- Când o funcție primește `k` argumente, putem utiliza `map()` cu funcția și `k` iterabile, câte unul pentru fiecare argument.
În continuare, vei putea studia cum să lucrezi cu seturi în Python.