Funktion für eine Liste

[quvalue]

Hallo,

ich habe eine Funktion, als Beispiel

Code: Alles auswählen

def bla(x): 2*x

, und möchte diese für eine Liste verwenden. Bisher habe ich das uneleganterweise so gelöst:

Code: Alles auswählen

def liste_bla(listex): 
       result = []
       for el in listex: result.append(bla(el))
       return result

Es gibt sicher einen viel besseren Weg, aber ich komme nicht darauf. bla könnte auch eine komplexere Funktion sein.

Ich habe folgende schöne Funktion gefunden, die eine Liste von Listen transponiert. So ganz habe ich das Vorgehen nicht verstanden. Kann man das Prinzip auf jede Funktion erweitern?

Code: Alles auswählen

def transposed(lists):
   if not lists: return []
   return map(lambda *row: list(row), *lists)

[lutz.horn]

Verwendet List comprehension

Code: Alles auswählen

def bla(x):
    return 2 * x

l = [1, 2, 3, 4]
print [bla(x) for x in l]
# => [2, 4, 6, 8]

Oder noch kürzer:

Code: Alles auswählen

l = [1, 2, 3, 4]
print [x * 2 for x in l]
# => [2, 4, 6, 8]

[quvalue]

Danke!

[EyDu]

map war schon richtig!

Diese beiden Lösungen entsprechen den Ergebnissen der Funktion "liste_bla" aus deinem ersten Post:

Code: Alles auswählen

map(bla, listex)

#oder:
map(lambda x: 2*x, listex)

Für die Erklärung von lambda schaust du am besten mal in der Doku nach.

Edit:

Code: Alles auswählen

import operator
import functools

map(functools.partial(operator.mul, 2), listex)

[lutz.horn]

GvR war mal der Meinung, dass lambda, filter, map und reduce für Python 3000 entfernt werden sollen. Inzwischen soll dieses Schicksal wohl nur noch reduce ereilen.

List Comprehension und Generatoren sind jedenfalls zu bevorzugen.

[quvalue]

Was ist mit Verkettung?

Code: Alles auswählen

>>> b = lambda x:2*x
>>> d = lambda x:1.4*x
>>> map(d,map(b,[1,2]))
[2.7999999999999998, 5.5999999999999996]

Folgendes geht nicht

Code: Alles auswählen

map([b,d],[1,2])

[lutz.horn]

Was soll damit sein? Verkettung funktioniert mit alle vorgestellen Varianten.

[EyDu]

Warum sollte "map([b,d],[1,2])" denn funktionieren? Der Interpreter kann schlecht raten, was damit gemeint sein soll. Die Dokumentation sagt dir in solchen Fällen ganz genau was möglich ist und was nicht.

Edit: Suchst du so etwas?

Code: Alles auswählen

>>> def composition(*args):
	def _composition(x):
		for arg in args[::-1]:
			x = arg(x)
		return x
	return _composition

>>> x = composition(lambda x: x+10, lambda x: x*2)
>>> x(4)
18
>>> 

[rayo]

GvR war mal der Meinung, dass lambda, filter, map und reduce für Python 3000 entfernt werden sollen. Inzwischen soll dieses Schicksal wohl nur noch reduce ereilen.

List Comprehension und Generatoren sind jedenfalls zu bevorzugen.

Nicht entfernt sondern nur verschoben, weg aus dem builtin hin zu functools. Ausser bei lambda (ist keine Funktion wie filter,...), aber das bleibt ja.

[quvalue]

Edit: Suchst du so etwas?

Genau. Ich habe gerade auch oakwinter entdeckt.