Hvordan til at omdanne en tupel til en række af værdier, uden komma og parentes

Jeg har hentet data fra en sql-forespørgsel ved hjælp

bounds = cursor.fetchone()

Og jeg får en tupel som:

(34.2424, -64.2344, 76.3534, 45.2344)

Og jeg ville gerne have en streng som 34.2424 -64.2344 76.3534 45.2344

Er en funktion, der findes, der kan gøre det?

OriginalForfatteren Below the Radar | 2013-07-02

5 svar

  1. 32

    Bruge str.join():

    >>> mystring = ' '.join(map(str, (34.2424, -64.2344, 76.3534, 45.2344)))
    >>> print mystring
    34.2424 -64.2344 76.3534 45.2344

    Du bliver nødt til at bruge kortet her (som konverterer alle elementer i tupel til strenge), da du ellers vil få en TypeError.


    En smule afklaring på map() funktion:

    map(str, (34.2424, -64.2344, 76.3534, 45.2344) svarer til [str(i) for i in (34.2424, -64.2344, 76.3534, 45.2344)].

    Det er en lille smule hurtigere end ved hjælp af en liste forståelse:

    $ python -m timeit "map(str, (34.2424, -64.2344, 76.3534, 45.2344))"
    1000000 loops, best of 3: 1.93 usec per loop
    $ python -m timeit "[str(i) for i in (34.2424, -64.2344, 76.3534, 45.2344)]"
    100000 loops, best of 3: 2.02 usec per loop

    Som vist på kommentarer til dette svar, str.join() kan tage en generator i stedet for en liste. Normalt vil det være hurtigere, men i dette tilfælde, det er langsommere.

    Hvis jeg skulle gøre:

    ' '.join(itertools.imap(str, (34.2424, -64.2344, 76.3534, 45.2344)))

    Det vil være langsommere end ved hjælp af map(). Forskellen er, at imap() returnerer en generator, mens map() returnerer en liste (i python 3-det giver en generator)

    Hvis jeg skulle gøre:

    ''.join(str(i) for i in (34.2424, -64.2344, 76.3534, 45.2344))

    Det ville være langsommere end at sætte parentes omkring den liste forståelse, på grund af årsager forklaret her.


    I din (OP) sag, enten mulighed ikke rigtig noget, som evner ikke virke som en stor deal her. Men hvis du nogensinde er beskæftiger sig med store elementer af flåd/heltal, så nu ved du hvad du skal bruge for at opnå maksimal effektivitet :).

    I Python 3, dit svar er god, fordi map() er en generator i Python 3. Men i Python2, det ville være bedre at bruge imap()
    Jeg tror ikke, at performance er et massivt problem her :p
    faktisk er det hurtigere og mere effektivt at bruge en liste comp snarere end en generator for en join: stackoverflow.com/a/9061024/1240268
    Wow, det er meget interessant. Tak for linket!
    Jeg takker meget for dit link. De oplysninger, der gives af Raymond Hettinger svar og diskussion mellem Raymond og ovgolovin er meget interessante. – Jeg upvote to af dine bedste svar set i brugerens side

    OriginalForfatteren TerryA

  2. 4

    Hvis jeg har fået din besked, får du en tupel af flåd, har jeg ret?

    Hvis det er tilfældet, skal følgende kode skal arbejde:

    In [1]: t = (34.2424 , -64.2344 , 76.3534 , 45.2344)
    
    In [2]: ' '.join([str(x) for x in t])
    Out[2]: '34.2424 -64.2344 76.3534 45.2344'

    Vi omdanner hver værdi i tupel til streng her, fordi str.deltag metode kan kun arbejde med lister af strengen.
    Hvis t er en tuple af strenge koden vil være lige ' '.join(t).

    I tilfælde af at du får strengen i format "(34.2424 , -64.2344 , 76.3534 , 45.2344)", skal du først slippe af med unnescessary parthensis og kommaer:

    In [3]: t = "(34.2424 , -64.2344 , 76.3534 , 45.2344)"
    
    In [4]: t.strip('()')
    Out[4]: '34.2424 , -64.2344 , 76.3534 , 45.2344'
    
    In [5]: numbers = t.strip('()')
    
    In [6]: numbers.split(' , ')
    Out[6]: ['34.2424', '-64.2344', '76.3534', '45.2344']
    
    In [7]: ' '.join(numbers.split(' , '))
    Out[7]: '34.2424 -64.2344 76.3534 45.2344'
    Jeg vil foreslå dig at læse min kommentar til Ronan svar

    OriginalForfatteren utter_step

  3. 3

    Du kan også bruge str.format() til at producere en vilkårlig formatering, hvis du er villig til at bruge * magi. Til at håndtere de specifikke tilfælde af dette spørgsmål, med en enkelt separator, er faktisk lidt besværligt:

    >>> bounds = (34.2424, -64.2344, 76.3534, 45.2344)
    >>> "{} {} {} {}".format(*bounds)
    
    34.2424 -64.2344 76.3534 45.2344

    En mere robust udgave, der håndterer enhver længde, som join, er:

    >>> len(bounds)*"{} ".format(*bounds)

    Men den merværdi, er, at hvis du ønsker at forlænge din formatering til noget mere involveret du har fået den mulighed:

    >>> "{} --> | {:>10} | {:>10} | {:>10} |".format(*bounds)
    
    34.2424 --> |   -64.2344 |    76.3534 |    45.2344 |

    Fra her, din string formateringsindstillinger er meget forskellige.

    Du løsning er hurtigere end at bruge kortet eller listen forståelse, dvs: 1.72 usec per løkken i stedet for at 1.87

    OriginalForfatteren ohruunuruus

  4. 1

    Prøv denne

    >>> a = (34.2424, -64.2344, 76.3534, 45.2344)
    >>> ' '.join(str(i) for i in a)
    '34.2424 -64.2344 76.3534 45.2344
    At skrive [str(i) for i in a], det betyder, at en liste over objekt, der er oprettet før ' '.join() har til at arbejde. Men det er muligt at skrive ' '.join(str(i) for i in a) : i dette tilfælde, join() får hver str(i) som de er indrettet ene efter den anden af generator str(i) for i in a). Se også min kommentar til Haidro svar.
    ja, det er korrekt, tak for at nævne
    Faktisk liste forståelse er bedre med join: stackoverflow.com/a/9061024/1240268
    Tak Andy, tak for bemærke, at jeg har læst dette spørgsmål om 2 dage siden, men jeg har allerede fotgot, at jeg har nogle svar på dette emne. jeg lærer i python med DET 🙂

    OriginalForfatteren Roman Pekar

  5. -1

    Du kan blot bruge følgende kode:

    i = 0
    for row in data:
           print(row[i])
           i++

    OriginalForfatteren Ethan Brimhall

Skriv et svar

Din e-mailadresse vil ikke blive publiceret. Krævede felter er markeret med *