Python-Funktion parameter: Tupel/Liste

Meine Funktion erwartet eine Liste oder ein Tupel als parameter. Es spielt nicht wirklich, was es ist, alle es tut, ist, übergeben Sie es an eine andere Funktion akzeptiert entweder eine Liste oder Tupel:

def func(arg): # arg is tuple or list
  another_func(x)
  # do other stuff here

Nun muss ich ändern Sie die Funktion leicht zu verarbeiten, wird ein zusätzliches element:

def func(arg): #arg is tuple or list
  another_func(x + ['a'])
  # etc

Leider ist dies nicht zur Arbeit gehen: wenn die arg-Tupel, muss ich sagen x + ('a',).

Offensichtlich, ich kann damit es funktioniert, indem die Nötigung arg in der Liste. Aber es ist nicht ordentlich.

Gibt es eine bessere Art, das zu tun? Ich kann nicht zwingen, Anrufern stets pass ein Tupel, natürlich, da es einfach Schichten zu arbeiten, um Ihnen.

Wenn die andere Funktion akzeptiert entweder als ich würde ihn ein Tupel wird es schneller sein, für Sie zu arbeiten. Was dann nicht ordentlich über tuple(x) + ('a',)?
Sind die Tupel schneller in der Umsetzung?
Bau eines Tupels von Strings und numerischen literalen ist schneller als das konstruieren einer Liste. Noch wichtiger ist, tuple(x) nur zurück x wenn es bereits ein Tupel in der Erwägung, dass list(x) Kopien x auch wenn es schon eine Liste. So durch die Nutzung der ein Tupel, schneiden Sie die meisten der Arbeit für die Hälfte Ihrer Eingabe Fälle.
+1: guter Punkt, um Tupel vs-Liste.

InformationsquelleAutor max | 2010-11-17

7

Wenn another_func will nur eine iterierbar, die Sie übergeben können itertools.chain(x,'a') zu.
- Wird keine Kopie erstellt, so ist es sehr schnell. Es ist wahrscheinlich die meisten effizient Python-Lösung.
InformationsquelleAutor Jochen Ritzel
4

Was über das ändern der anderen Funktion zu akzeptieren, eine Liste der Parameter statt ?
```
def func(arg): # arg is tuple or list
  another_func('a', *x)
```
- Was ist, wenn another_func braucht mehrere Liste Argumente, die betroffen sind von dem gleichen Problem, oder wenn es bereits einen (nicht verwandten) *x parameter?
- +0: gut, aber unsicher, wenn andere func kann geändert werden
- Die Antwort ist die gleiche. Fixieren Sie die andere Funktion.
- etwas muss geändert werden in der Funktion Schnittstelle
- Ich bin hontestly verwirrt jetzt. Wenn another_func nimmt zwei Listen, warum ist es ein schlechtes design? Sagen wir, eine Liste "Liste oder Tupel von Spalten zu drucken", und der andere Liste oder ein Tupel aus Zeilen ausschließen von print". Wie und warum sollte ich ändern, um seine Schnittstelle?
- Ein Tupel mit einer unbestimmten Anzahl von Elementen ist ein design-Fehler. Tupel sind in der Regel für eine bestimmte Anzahl von Elementen; die Anzahl der Elemente ist in der Regel behoben, indem die problem-Domäne (x,y) - Koordinaten, (r,g,b) Farben, etc. Eine "variable Größe" Tupel ist einfach unangebracht. Es sollte eine Liste. Fixieren Sie die Funktion für die Arbeit mit einer Liste. Update der Funktionen. "variable Länge" oder "unbestimmte Länge" Tupel sind ein Fehler. Nicht unterstützen. Beheben Sie das Problem.
- für hilfreiches feedback, danke. Ich bin neugierig, diese aber, so habe ich gebeten, eine neue Frage: stackoverflow.com/questions/4210981/....
InformationsquelleAutor fabrizioM
3

wie etwa:
```
l = ['a']
l.extend(x)
```
Bearbeiten:
Re-Lektüre in Frage, ich denke, das ist mehr das, was Sie wollen (die Verwendung von arg und x war ein wenig verwirrend):
```
tuple(arg) + ('a',)
```
Wie schon andere gesagt haben, ist dies wahrscheinlich nicht der effizienteste Weg, aber es ist sehr klar. Wenn Ihr Tupel/Listen sind klein, ich könnte dies nicht über weniger klare Lösungen, die performance wird als vernachlässigbar. Wenn Ihre Listen sind groß, verwenden Sie das effizientere Lösungen.
- extend zurück None, wie es mutiert der Liste.
- was meinst du?
- Ich hatte ursprünglich "['eine'].erweitern(x)", die eine weitgehend nutzlose Aussage, denn verlängern gibt Keine, wie delnan hingewiesen
InformationsquelleAutor Sean

def f(*args):
    print args

def a(*args):
    k = list(args)
    k.append('a')
    f(*k)

a(1, 2, 3)

Ausgabe:

(1, 2, 3, 'a')

hmm f(*(tuple(args)+('a',)) ist besser

InformationsquelleAutor pyfunc

2

Wenn ein iterierbar ist genug Sie können itertools.Kette, aber bewusst sein, dass, wenn die Funktion A (der erste genannt), auch iteriert über die durchsuchbar nach dem Aufruf B sind, dann könnten Sie Probleme haben, da iterables nicht rewinded. In diesem Fall sollten Sie sich für eine Sequenz oder verwenden Sie durchsuchbar.tee, um eine Kopie der iterierbar:
```
import itertools as it

def A(iterable):
    iterable, backup = it.tee(iterable)
    res = B(it.chain(iterable, 'a'))
    #do something with res
    for elem in backup:
        #do something with elem

def B(iterable):
   for elem in iterable:
       #do something with elem
```
Obwohl itertools.tee ist nicht wirklich effizient, wenn B verbraucht alle oder die meisten der iterierbar, an diesem Punkt ist es einfacher zu umwandeln, nur iterable zu einem tuple oder eine list.
- +1 für die Aufklärung über das Zurückspulen von Iteratoren. In meinem Fall, iterierbar ist genug; ich denke, für die Abfolge Fall werde ich Sie einfach zwingen zu Tupel vorgeschlagen von @aaronasterling
InformationsquelleAutor Bakuriu
1

Mein Vorschlag:
```
def foo(t):
    bar(list(t) + [other])
```
Dies ist nicht sehr effizient, aber Sie wären besser dran vorbei änderbare Dinge, wenn du gehst zu sein, mutiert Sie.
- Könnten Sie das bitte erklären? Warum ist das nicht effizient?
- Es ist nicht so effizient, da Sie die Kopien einer ganzen Liste nur ein einziges Element.
InformationsquelleAutor slezica

Können Sie die Art der wiederholenden übergeben, um die erste Funktion zu konstruieren, was Sie an die zweite:

from itertools import chain

def func(iterable):
    it = iter(iterable)
    another_func(type(iterable)(chain(it, ('a',))))

def another_func(arg):
    print arg

func((1,2))
# (1, 2, 'a')
func([1,2])
# [1, 2, 'a']

InformationsquelleAutor martineau

0

Haben Ihre Funktion übernehmen keine durchsuchbar. Dann nutzen Sie itertools.chain hinzufügen was auch immer Sequenz, die Sie wollen, um die durchsuchbar.
```
from itertools import chain

def func(iterable):
    another_func(chain(iterable, ('a',)))
```
InformationsquelleAutor Steven Rumbalski
0

Ich würde sagen, dass Santiago Lezica Antwort zu tun
```
def foo(t):
    bar(list(t) + [other])
```
ist die beste, weil es ist die einfachste. (keine Notwendigkeit zum import itertools Zeug und viel weniger lesbar Kette nennt). Aber nur verwenden, wenn Sie erwarten, dass t klein ist. Wenn t groß sein können, sollten Sie verwenden Sie eine der anderen Lösungen.

InformationsquelleAutor JanKanis

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.