Python – Zuordnen, Filtern, Reduzieren

KARTE

Lassen Sie uns zunächst verstehen, warum genau wir eine Kartenfunktion benötigen und wie sie uns hilft, unseren Arbeitsaufwand zu reduzieren und unseren Code effizienter zu gestalten.

Angenommen, wir haben eine Liste wie unten, an der wir arbeiten können, aber das Problem mit der Liste besteht darin, dass alle darin enthaltenen Elemente im String-Format vorliegen. Wenn wir also versuchen, numerische Operationen auszuführen, wird dies zu keinem Ergebnis führen.

l1 = ["3","5","9","12","25"]
x = l1[0]+1
print(x)
----------------------------------------------------------------------
-----
TypeError Traceback (most recent call
last)
Input In [1], in <cell line: 2>()
1 l1 = ["3","5","9","12","25"]
----> 2 x = l1[0]+1
3 print(x)
TypeError: can only concatenate str (not "int") to str

Eine Möglichkeit, dies zu umgehen, ist eine for-Schleife. Schauen wir uns das einmal an

for i in range(len(l1)):
l1[i] = int(l1[i])

x = l1[0]+1
print(x)
4

Wir nehmen eine andere Liste namens l2 und führen den gleichen Vorgang erneut aus.

l2 = ["3","5","9","12","25"]
l2 = list(map(int,l2))
y = l2[0]+1
print(y)
4

Schauen wir uns nun auch einige andere Beispiele an. Angenommen, wir möchten die Quadratwerte einer gesamten Liste ermitteln. Schauen wir uns an, wie wir das mit Hilfe der Kartenfunktion erreichen können.

Schreiben wir zunächst eine Funktion „sq“, die den quadrierten Wert einer bestimmten Zahl zurückgibt

def sq(a):
  return a*a

l3 = [3,5,7,2,9]
l4 = list(map(sq,l3))
print(l4)
[9, 25, 49, 4, 81]

Schauen wir uns nun etwas Komplizierteres an. Was wir jetzt erreichen wollen, ist, das Quadrat und die Potenz der Zahlen von 0,8 zu erhalten und in einer Liste zu speichern. Wir werden jetzt die Kartenfunktion, die Lambda-Funktion und auch unser Schlüsselwort def verwenden, um die Quadrat- und Würfelfunktionen zu beschreiben. Dann verwenden wir eine for-Schleife, um die Liste zu erstellen.

def sq(a):
  return a*a
def cube(a):
  return a*a*a
func = [sq,cube]
for i in range(8):
  rslt = list(map(lambda x:x(i) ,func))
print(rslt)
[0, 0]
[1, 1]
[4, 8]
[9, 27]
[16, 64]
[25, 125]
[36, 216]
[49, 343]

Wie der Name schon sagt, hilft uns die Filterfunktion beim Filtern einer bestimmten Menge von Iterables. Als Argument nimmt sie die angegebene Funktion, auf deren Grundlage wir unsere Iterables filtern, und dann die Iterables selbst als Argumente. Im Folgenden sind drei Arten von Filtern aufgeführt: Einer filtert Zahlen größer als 10 aus der Liste, einer filtert Zahlen kleiner als 10 und einer verfügt über eine Mehrfachkonditionierung, die angibt, dass die Zahl größer als 10, aber kleiner als 15 sein sollte.

l1 = [34,12,5,8,11,14,19,10,1,50]
def grt_condi(num):
  return num>10
def lsr_condi(num):
  return num<10
def multi_condi(num):
  return num>10 and num<15

l2 = list(filter(grt_condi,l1))
l3 = list(filter(lsr_condi,l1))
l4 = list(filter(multi_condi,l1))

print(l2)
print(l3)
print(l4)
[34, 12, 11, 14, 19, 50]
[5, 8, 1]
[12, 11, 14]

Lassen Sie uns verstehen, was die Reduzierungsfunktion bewirkt und welches Problem sie löst. Um dies zu verstehen, nehmen wir zunächst eine Problemstellung und unseren traditionellen Lösungsansatz.

Nehmen wir an, es gibt eine Liste und wir möchten die Summe aller in der Liste vorhandenen ganzen Zahlen erhalten

l6 = [2,3,6,5,8,9,10]
x = 0
for i in l6:
  x = x+i
print(x)
43

from functools import reduce
l7 = reduce(lambda x,y:x+y , l6)
print(l7)
43

Für weitere Inhalte dieser Art folgen Sie bitte meinem Medium-Profil und meiner LinkedIn-Seite –https://www.linkedin.com/in/chandan-sengupta/