Hilfe – Funktionszeiger in Python

Meine Idee des Programms:

Ich habe ein Wörterbuch:

options = { 'string' : select_fun(function pointer), 'float' : select_fun(function pointer), 'double' : select_fun(function pointer) } 

Was auch immer Typ kommt single function select_fun(function pointer) wird aufgerufen. Innerhalb select_fun(function pointer) ich Diff-Funktionen für float, double und so weiter.

Je nach Funktionszeiger wird die angegebene Funktion aufgerufen.

Ich weiß nicht, ob meine Programmierkenntnisse gut oder schlecht sind, ich brauche noch Hilfe.

5 Solutions collect form web for “Hilfe – Funktionszeiger in Python”

Könnten Sie genauer sein, was Sie versuchen zu tun? Sie müssen nichts Besonderes machen, um Funktionszeiger in Python zu bekommen – Sie können Funktionen wie reguläre Objekte weitergeben:

 def plus_1(x): return x + 1 def minus_1(x): return x - 1 func_map = {'+' : plus_1, '-' : minus_1} func_map['+'](3) # returns plus_1(3) ==> 4 func_map['-'](3) # returns minus_1(3) ==> 2 

Sie können die type() eingebaute Funktion verwenden , um den Typ der Funktion zu erkennen.

Sagen Sie, wenn Sie überprüfen möchten, ob ein bestimmter Name eine String-Daten enthält, können Sie dies tun:

 if type(this_is_string) == type('some random string'): # this_is_string is indeed a string 

Also in deinem Fall kannst du es so machen:

 options = { 'some string' : string_function, (float)(123.456) : float_function, (int)(123) : int_function } def call_option(arg): # loop through the dictionary for (k, v) in options.iteritems(): # if found matching type... if type(k) == type(arg): # call the matching function func = option[k] func(arg) 

Dann kannst du es so verwenden:

 call_option('123') # string_function gets called call_option(123.456) # float_function gets called call_option(123) # int_function gets called 

Ich habe keinen Python-Interpreter in der Nähe und ich programmiere nicht in Python viel so kann es einige Fehler geben, aber du solltest die Idee bekommen.


EDIT: Wie pro @ Adam's Vorschlag gibt es eingebaute Typ Konstanten, die Sie direkt überprüfen können, so ein besserer Ansatz wäre:

 from types import * options = { types.StringType : string_function, types.FloatType : float_function, types.IntType : int_function, types.LongType : long_function } def call_option(arg): for (k, v) in options.iteritems(): # check if arg is of type k if type(arg) == k: # call the matching function func = options[k] func(arg) 

Und da der Schlüssel selbst mit dem Wert der type () -Funktion vergleichbar ist, kannst du das einfach machen:

 def call_option(arg): func = options[type(arg)] func(arg) 

Was ist eleganter 🙂 Für eine Fehlersuche sparen.


EDIT: Und für Ctypes-Unterstützung, nach einigen Fummeln herum, habe ich festgestellt, dass Ctypes [type_name_here] tatsächlich als Klassen geplagt ist. Also diese Methode funktioniert immer noch, du musst nur die ctypes.c_xxx Typ Klassen verwenden.

 options = { ctypes.c_long : c_long_processor, ctypes.c_ulong : c_unsigned_long_processor, types.StringType : python_string_procssor } call_option = lambda x: options[type(x)](x) 

Wenn du dein Beispiel ansiehst, scheint es mir ein C-Verfahren zu geben, das direkt in Python übersetzt wird.

Aus diesem Grund denke ich, dass es etwas Design-Problem geben könnte, denn in der Regel in Python, kümmert es sich nicht um Art eines Objekts, sondern nur über die Nachrichten, die Sie an sie senden können.

Natürlich gibt es viele Ausnahmen von diesem Ansatz, aber immer noch in diesem Fall würde ich versuchen, in einigen Polymorphismus einkapseln; z.B.

 class StringSomething(object): data = None def data_function(self): string_function_pointer(self.data) class FloatSomething(object): data = None def data_function(self): float_function_pointer(self.data) 

etc.

Wieder, all dies unter der Annahme, die Sie von einer Verfahrenssprache zu python übersetzen; Wenn es nicht der Fall ist, dann verwerfe meine Antwort 🙂

Funktionen sind die erstklassigen Objekte in Python daher können Sie sie als Argumente an andere Funktionen wie Sie mit jedem anderen Objekt wie String oder eine Ganzzahl übergeben.

In Python gibt es keinen Präzisions-Gleitkomma-Typ. Pythons float entspricht dem double von C.

 def process(anobject): if isinstance(anobject, basestring): # anobject is a string fun = process_string elif isinstance(anobject, (float, int, long, complex)): # anobject is a number fun = process_number else: raise TypeError("expected string or number but received: '%s'" % ( type(anobject),)) return fun(anobject) 

Es gibt functools.singledispatch , das erlaubt, eine generische Funktion zu schaffen:

 from functools import singledispatch from numbers import Number @singledispatch def process(anobject): # default implementation raise TypeError("'%s' type is not supported" % type(anobject)) @process.register(str) def _(anobject): # handle strings here return process_string(anobject) process.register(Number)(process_number) # use existing function for numbers 

Auf Python 2 ist eine ähnliche Funktionalität als pkgutil.simplegeneric() verfügbar.

Hier ist ein paar Code Beispiel für die Verwendung von generischen Funktionen:

  • Entfernen von Whitespaces und Newlines aus der JSON-Datei
  • Machen Sie my_average (a, b) Arbeit mit jedem a und b für die f_add und d_div definiert sind. Sowie builtins

Vielleicht möchten Sie das gleiche select_fun() jedes Mal mit einem anderen Argument anrufen. Wenn das ist, was du meinst, brauchst du ein anderes Wörterbuch:

 >>> options = {'string' : str, 'float' : float, 'double' : float } >>> options {'double': <type 'float'>, 'float': <type 'float'>, 'string': <type 'str'>} >>> def call_option(val, func): ... return func(val) ... >>> call_option('555',options['float']) 555.0 >>> 
  • Interpretieren Sie die Liste der Ganzzahlen als Float in Python
  • Python-Ctypes, die in Zeiger übergeben und Struct Back erhalten
  • Auto_ptr mit swig
  • Pythongeneratorobjekte und .join
  • Python ist die beste Programmiersprache der Welt.