Listen fragen

[movies1978]

Hallo Leute,
zwei Fragen habe ich:

1.) Kann man geschickt jedes Element in einer Liste mit einer Zahl multilpizieren. vektor * x gibt leider nicht.

2.) Kann man 2 Listen geschickt von einander abziehen v1 - v2 (Ich will das jedes Element i von v2 von jedem Element in v2 abgezogen wird)

Eigentlich würde ich gerne so tun, als ob Listen sich wie Vektoren verhalten.
Grüße
Mathias

[rafael]

hi,

zu deinem ersten problem:
ja, das müsste eigentlich mit einer for gehen.

Code: Alles auswählen

for i in list:
    ergebnis = list()

    ergebnis[i] = eval("1*i")#1 ist die zahl, mit der du multiplizierst.

zu dem zweiten:
ich weiß nicht genau, wie du es meinst, aber ich habs so verstanden, dass du das 1. element aus der ersten liste mit dem 1.element aus der 2.liste subtrahieren willst.

Code: Alles auswählen

for i in list:
    ergebnis = list()
    
    ergebnis[i] = list[i] - list_2[i]
    

ganz sicher bin ich mir bei den beiden nicht, aber versuchs doch einfach mal

gruß rafael

[BlackJack]

Wenn es auch externe Module sein dürfen, dann würde ich `numarray` oder `numpy` empfehlen:

Code: Alles auswählen

In [9]: import numarray

In [10]: a = numarray.array(xrange(5))

In [11]: a
Out[11]: array([0, 1, 2, 3, 4])

In [12]: b = a * 5

In [13]: b
Out[13]: array([ 0,  5, 10, 15, 20])

In [14]: b - a
Out[14]: array([ 0,  4,  8, 12, 16])

Falls es nur an ein oder zwei Stellen gebraucht wird, dann kannst Du auch einfach list comprehensions schreiben:

Code: Alles auswählen

from itertools import izip

a = range(5)
b = [x * 5 for x in a]
print [a_i - b_i for a_i, b_i in izip(a, b)]

Ansonsten kannst Du Dir eine `Vektor` Klasse selber schreiben.

[Leonidas]

Code: Alles auswählen

for i in list:
    ergebnis = list()

    ergebnis[i] = eval("1*i")#1 ist die zahl, mit der du multiplizierst.

Eeek? Eval?

Code: Alles auswählen

deine_neue_liste = [number * 2 for number in deine_alte_liste]

[birkenfeld]

Code: Alles auswählen

for i in list:
    ergebnis = list()

    ergebnis[i] = eval("1*i")#1 ist die zahl, mit der du multiplizierst.

[Nuhr-Zitat runtergeschluckt]

Merke: ein konstanter String als Argument von eval() ist ein sicheres Zeichen dafür, dass man kein eval() braucht.

[HWK]

map wäre noch eine Alternative. BlackJacks Beispiel mit map:

Code: Alles auswählen

a = range(5)
b = map(lambda x: 5 * x, a)
print map(lambda x, y: x - y, a, b)

MfG
HWK

[BlackJack]

Das zweite ``lambda`` könnte man auch durch die `sub()` Funktion aus dem `operator` Modul ersetzen.

Code: Alles auswählen

In [28]: import operator

In [29]: print map(operator.sub, a, b)
[0, -4, -8, -12, -16]

Soooo viele Möglichkeiten.

[movies1978]

Hey Leute, danke für die ganzen Antworten!
Habe mir die Lösungen mal druchgeschaut. Meine Hoffung war, dass ich etwas natives in Python finden würde. numpy scheint interessant, aber ich habe es jetzt nach dem ersten Ansatz gelöst.
Es ging übrigens darum eine möglichst schöne Implementation des Erweiterten Euklidischen Algorithmuses zu machen ( ich weiss schon 1000 mal gemacht, aber ich wollte es selbst mal tun). Daher wäre das automatische subtrahieren von Listen gefüllt mit Integern schon schön gewesen. Dies wäre sehr lesbar gewesen, da es fast schon wie PseudoCode aussieht. Naja schade drum.
Danke nochmal für die Antworten.

Mfg
Mathias

[keppla]

Daher wäre das automatische subtrahieren von Listen gefüllt mit Integern schon schön gewesen. Dies wäre sehr lesbar gewesen, da es fast schon wie PseudoCode aussieht.

wenn es dir um Lesbarkeit geht, überlade Operatoren, (was BlackJack vermutlich implizierte, als er sagte "schreib dir ne Klasse").

Code: Alles auswählen

class Vector(object):
  def __init__(self, *args):
    self.values = tuple(args)
  def __mul__(self, value):
    return Vector(
      *[item * value for item in self.values]
    )
  def __add__(self, other):
    return Vector(
      *[left + right for left, right in zip(self.values, other.values)]
    )
  def __repr__(self):
    return 'Vector%s' % (self.values,)

das kann man dann so benutzen:

Code: Alles auswählen

>>> v1 = Vector(1,2,3)
>>> v1 * 2
Vector(2,4,6)
>>> v2 = Vector(0,0,1)
>>> v1 + v2
Vector(1,2,4)