Python und Matlab - Typecasts?

[python48]

Hallo an alle!

Bin zimelich neu in der Python Welt und bin dabei Matlab code in Python umzuschreiben.
Habe folgenden code bearbeitet, als ich auf ein Problem gestoßen bin:

Code: Alles auswählen

function[out] = goforward(distance)

distance = uint16(distance);
a = typecast(distance,'uint8');
A = [a(1), a(2)];
end

In matlab kann man ganz einfach type casten, doch wie sieht es bei python aus?
Ich habe bis jetzt keine möglichkeit gefunden in python in unsigned integer werte (8 und 16 bit) umzuwandeln
und diese sozusagen "in 2 teile aufspalten".
Ich habe mir mal numpy kurz angeschaut aber das hat mich jetzt auch nicht so viel weitergebracht...

Wie würdet ihr diesen matlab code in python code umsetzen?
Wie würdet ihr hier casten und vorgehen um den gleichen effekt wie im matlab code zu bekommen?

diese Funktionen haben mich auch nicht besonders weitergebracht: http://www.informit.com/articles/articl ... 9&seqNum=7


Ich bitte um eure Hilfe!

Vielen lieben Dank schon mal an euch

Beste Grüße, python48.

[BlackJack]

@python48: Das kann man entweder mit dem `struct`- oder dem `ctypes`-Modul aus der Standardbibliothek machen, oder mit `numpy` was Du ja wahrscheinlich auch sowieso schon als Abhängigkeit hast, oder man rechnet das einfach selbst aus. Die `divmod()`-Funktion kann dabei nützlich sein.

[python48]

Für ein eine Anwendung an meinem Beispielcode deiner tipps wäre ich dir sehr dankbar.
Wie ich nach dem casten quasi dann die daten "aufteilen" soll ist mir nämlich noch schleierhaft

Vielen Dank schon mal für die Hilfe

[EyDu]

Vielleicht wirfst du zunächst einen genaueren Blick in die Dokumentation und probierst es einfach selbst mal aus. In den elf Minuten zwischen der Antwort von BlackJack und deiner, hast du das wahrscheinlich noch nicht geschafft

[Sirius3]

@python48: Da es sich nur um eine Zahl handelt, würde ich divmod verwenden. Aber wahrscheinlich würde man das, was Matlab da versucht zu machen, in Python sowieso komplett anders lösen.

[BlackJack]

@python48: Bei den meisten Varianten erledigt sich das Aufteilen von selbst. Ohne irgendwelche Importe kann man zum Beispiel die beiden Teile einfach mit ganzzahliger Division und Modulo ausrechnen. Oder mit Bits verschieben und maskieren. Oder gleich die `divmod()`-Funktion verwenden. Ungetestet:

Code: Alles auswählen

def go_forward(distance):
    if not 0 <= distance < 2**16:
        raise ValueError('`distance` out of range')
    return divmod(distance, 256)

Oder mit `struct`:

Code: Alles auswählen

def go_distance(distance):
    return struct.unpack('BB', struct.pack('H', distance))

Mit `ctypes` (eine Möglichkeit):

Code: Alles auswählen

from ctypes import c_uint16, c_uint8, cast, pointer, POINTER

def go_forward(distance):
    return list(cast(pointer(c_uint16(distance)), POINTER(c_uint8 * 2))[0])

Numpy (eine Möglichkeit):

Code: Alles auswählen

import numpy as np

def go_forward(distance):
    return np.array([distance], dtype=np.uint16).view(np.uint8)

[python48]

Vielen Dank für die Beispiele und vor allem auch für die ganzen Alternativen!
Das wird jetzt erstmal ein Weilchen dauern, bis ich mich durch diese neuen methoden und funktionen
durchgearbeitet habe und sie auch wirklich in vollen Zügen verstehen kann

Eine Frage bleibt mir jedoch noch:
Nehmen wir z.B die erste Methode:

Code: Alles auswählen

    def go_forward(distance):
        if not 0 <= distance < 2**16:
            raise ValueError('`distance` out of range')
        return divmod(distance, 256)

Wie kann ich dann diesen return-Wert dann in die benötigten 2 Teilwerte aufsplitten (wie oben in meiner Matlab Beispielfunktion)??
Ich brauche hier nämlich explizit A=[b(1), b(2)].

Code: Alles auswählen

    def go_forward(distance):
        if not 0 <= distance < 2**16:
            raise ValueError('`distance` out of range')
            b = divmod(distance, 256)
        return b

A=[b(1), b(2)].
Wird ja kaum gehen oder?


Vielen Dank euch, danke!

[snafu]

Wie kann ich dann diesen return-Wert dann in die benötigten 2 Teilwerte aufsplitten (wie oben in meiner Matlab Beispielfunktion)??

Meine Empfehlung: Nimm dir mal einen Nachmittag Zeit und arbeite ein Python-Grundlagentutorial durch. Das ist wirklich Basiswissen und es bringt dir auf Dauer nichts, solche Basics hier nachzufragen.

Wie dem auch sei. Die Antwort auf deine Frage ist:

Code: Alles auswählen

print(b[0])
print(b[1])

...unter die Annahme, dass `b` an den Rückgabewert gebunden wurde.

[/me]

Wie kann ich dann diesen return-Wert dann in die benötigten 2 Teilwerte aufsplitten (wie oben in meiner Matlab Beispielfunktion)??

Du bekommst ein Tupel mit den benötigten Werten zurück.

Hier mal ein simples Beispiel.

Code: Alles auswählen

>>> def do_something():
	return divmod(5, 3)

>>> result = do_something()
>>> print(result)
(1, 2)
>>> print(type(result))
<class 'tuple'>
>>> print(result[0])
1
>>> print(result[1])
2

[pillmuncher]

Aufsplitten:

Code: Alles auswählen

def foo():
    return 1, 2

a, b = foo()

Das heißt Tuple Unpacking.

[/me]

Das heißt Tuple Unpacking.

Und damit kann man zum Beispiel auch folgendes tun.

Code: Alles auswählen

>>> x = 23
>>> y = 42
>>> x, y = y, x
>>> x
42
>>> y
23

[BlackJack]

Wobei der Name „tuple unpacking” etwas irreführend ist, denn das funktioniert mit jedem iterierbaren Objekt, nicht nur mit Tupeln.

[python48]

Vielen dank euch allen für die Hilfe!
Habe mich jetzt einige zeit mit den ganzen funktionen beschäftigt und auch viel rumprobiert
Für mein Anliegen haben alle methoden von BlackJack funktioniert, außer die mit divmod.
Womöglich habe ich es falsch implementiert

Nochmals, vielen dank euch, habt mir echt sehr weitergeholfen


Beste Grüße, python48.