6 forskellige tilgange til visning af lister i Python

Introduktion

I Python handler udskrivning af lister ikke kun om at vise værdier; det er en måde for programmører at forstå deres kode bedre og sikre, at data ser rigtige ud. Lad os udforske forskellige måder at udskrive lister på med praktiske eksempler og tips til at gøre tingene klarere. Lad os dykke ned i Python-listernes verden.

Tilmeld dig vores gratis kursus af Python.

Udskriv lister i Python

Trykning lister i Python åbner op for en række metoder, og i denne artikel vil vi udforske flere effektive tilgange:

• Brug af for loop
• Konverter en liste til streng til visning
• Brug af parameteren sep i print()
• Brug af map() funktion
• Brug af indeksering og udskæring
• Brug af listeforståelse

Vis en liste i Python ved hjælp af en For Loop

Gentag gennem listen fra 0 til dens længde og udskriv hvert element individuelt ved hjælp af en for-løkke; dette er den konventionelle måde at opnå det på.

Nedenfor er et eksempel på visning af en liste i Python ved hjælp af en for-løkke:

# Creating a list of fruits

fruits = ["apple", "banana", "orange", "grape", "kiwi"]

# Displaying each fruit using a for loop

print("List of Fruits:")

for fruit in fruits:

    print(fruit)

I dette eksempel har vi en liste over frugter, og for-løkken gentager hvert element på listen og viser dem én efter én.

Output:

Tidskompleksitet (O(n)):

Tidskompleksiteten er O(n), fordi hvert element i listen besøges én gang i en for-løkke, og den tid, det tager at udføre løkken, er direkte proportional med antallet af elementer i inputlisten.

Rumkompleksitet (O(1)):

Rumkompleksiteten er O(1), da løkken bruger en konstant mængde hukommelse, uanset inputstørrelsen; den anvender kun en enkelt variabel (element) til at repræsentere hvert element på listen og skaber ikke yderligere datastrukturer, der vokser med inputtet.

Vis en liste ved at konvertere den til en streng

Når man har at gøre med en liste over strygere, er en ligetil tilgang at bruge join()-funktionen til nem sammenkædning. Men når listen indeholder heltal, er en to-trins proces nødvendig: først konverter dem til strenge og brug derefter join()-funktionen til at skabe en samlet streng til visning.

Her er et eksempel:

# Example list of fruits

fruits = ["apple", "banana", "orange", "grape", "kiwi"]

# Convert the list to a string and display it

result_string = ', '.join(fruits)

print("List of Fruits: " + result_string)

I dette eksempel sammenkæder joinmetoden listens elementer til en enkelt streng, adskilt af et komma og et mellemrum. Resultatet vises derefter som en formateret streng.

Output:

Tidskompleksitet (O(n)):

Tidskompleksiteten er O(n), fordi hvert element i listen i en for-løkke behandles én gang, og udførelsestiden skaleres lineært med antallet af elementer i inputlisten. Efterhånden som inputtet vokser, vokser algoritmens køretid proportionalt.

Rumkompleksitet (O(1)):

Rumkompleksiteten er O(1), fordi algoritmen bruger en konstant mængde hukommelse uanset inputstørrelsen. Sløjfen kræver kun en enkelt variabel (element) for at repræsentere hvert element på listen, og det opretter ikke yderligere datastrukturer eller hukommelse, der afhænger af størrelsen på inputlisten.

Vis med sep-parameteren i Print()

Sep-parameteren i print()-funktionen giver dig mulighed for at angive en separator mellem de elementer, du udskriver. 

Ved at bruge asterisk (*)-symbolet kan du præsentere listeelementer på en enkelt linje med mellemrum. For en visning med hvert element på en ny linje eller adskilt af kommaer, skal du bruge henholdsvis sep=”n” eller sep=”, ”. 

Her er et eksempel med en liste over frugter:

# Example list of fruits

fruits = ["apple", "banana", "orange", "grape", "kiwi"]

# Displaying the list with a custom separator using the sep parameter

print("List of Fruits:", *fruits, sep=", ")

I dette eksempel angiver sep=”, ”, at et komma og et mellemrum skal bruges som adskillelsestegn mellem punkterne på listen.

Output:

Tidskompleksitet (O(n)):

Tidskompleksiteten er O(n), fordi med en for-løkke behandles hvert element i listen individuelt. Efterhånden som antallet af elementer (n) vokser, øges eksekveringstiden lineært, hvilket afspejler en direkte sammenhæng mellem inputstørrelse og beregningstid.

Rumkompleksitet (O(1)):

Rumkompleksiteten er O(1), da algoritmen bruger en ensartet mængde hukommelse, uafhængig af inputstørrelse. Sløjfen anvender et fast sæt variabler (såsom 'element') og undgår at skabe yderligere datastrukturer eller dynamisk allokere hukommelse i forhold til inputstørrelsen.

Vis en liste i Python ved hjælp af Map()-funktionen

Brug map()-funktionen til at sikre, at hvert element på listen er en streng, især når listen indeholder ikke-strengelementer. Efter dette, flet disse transformerede elementer ved hjælp af join-funktionen til en samlet visning.

Her er et eksempel på visning af en liste over frugter i Python:

# Example list of fruits

fruits = ["apple", "banana", "orange", "grape", "kiwi"]

# Displaying the list of fruits

print("List of Fruits:", fruits)

Output:

Print()-funktionen formaterer automatisk listen til visning. Hvis du ønsker at tilpasse outputtet yderligere, kan du gentage listen og udskrive hvert element individuelt eller bruge joinmetoden, som vist i tidligere eksempler.

Vis en liste i Python ved hjælp af indeksering og udsnit

Du kan vise en liste i Python ved hjælp af indeksering og udsnit for at få adgang til bestemte elementer eller en delmængde af listen. 

Her er et eksempel:

# Example list of fruits

fruits = ["apple", "banana", "orange", "grape", "kiwi"]

# Displaying the entire list

print("Complete List of Fruits:", fruits)

# Displaying specific elements using indexing

print("First Fruit:", fruits[0])

print("Third Fruit:", fruits[2])

# Displaying a subset using slicing

print("Subset of Fruits:", fruits[1:4])

Output:

I dette eksempel bruges indeksering til at få adgang til individuelle elementer (f.eks. frugter[0] for det første element), og udskæring bruges til at vise en undergruppe af listen (f.eks. frugter[1:4] for elementer ved indeks 1, 2 og 3).

Tidskompleksitet (O(n)):

Tidskompleksiteten er O(n), fordi gentagelse af en liste ved hjælp af indeksering eller udskæring involverer at besøge hvert element én gang. Efterhånden som størrelsen af ​​listen (n) øges, vokser den tid, det tager at få adgang til eller opdele listen lineært.

Rumkompleksitet (O(1)):

Pladskompleksiteten er O(1) for indekserings- og udsnitsoperationer, da de bruger en konstant mængde ekstra hukommelse, uanset størrelsen på listen. Den nødvendige hukommelse til indeks-/udsnitsvariabler forbliver konstant og skaleres ikke med inputstørrelsen.

Vis en liste i Python ved hjælp af listeforståelse

Listeforståelse er en kortfattet funktion i Python til oprettelse af lister ved at anvende et udtryk på hvert element i en eksisterende iterabel. Det giver en kompakt syntaks, der kombinerer trinene til at oprette en ny liste og anvende en transformation til dens elementer.

Her er et eksempel på visning af en ændret liste over frugter ved hjælp af listeforståelse:

# Example list of fruits

fruits = ["apple", "banana", "orange", "grape", "kiwi"]

# Using list comprehension to create a new list with capitalized fruits

capitalized_fruits = [fruit.capitalize() for fruit in fruits]

# Displaying the new list

print("Capitalized Fruits:", capitalized_fruits)

Output:

I dette eksempel bruges listeforståelse til at oprette en ny liste (capitalized_fruits). Resultatet er en liste over frugter med deres navne med stort.

Tidskompleksitet (O(n)):

Tidskompleksiteten er O(n) for dette eksempel, fordi den gentager hvert element i den oprindelige liste over frugter. Udførelsestiden skalerer lineært med antallet af frugter, hvilket gør den proportional med størrelsen af ​​inputlisten.

Rumkompleksitet (O(n)):

Rumkompleksiteten er O(n), da listeforståelse skaber en ny liste (capitalized_fruits), der vokser med størrelsen af ​​inputlisten (frugter). Hvert element i den oprindelige liste svarer til et element i den nye liste, hvilket bidrager til et lineært forhold mellem inputstørrelsen og den anvendte hukommelse.

Konklusion

I Python er det afgørende at beherske kunsten at udskrive lister for kodeforståelse og datavisualisering. Denne vejledning har undersøgt seks effektive måder at vise lister på, og giver praktiske eksempler og tips til klarhed. Uanset om du bruger sløjfer, strengkonvertering, brugerdefinerede separatorer, kortfunktioner, indeksering, udsnit eller listeforståelse, tjener hver tilgang et specifikt formål og forbedrer dine Python-programmeringsfærdigheder.

Ofte stillede spørgsmål

Relaterede

• SEO Powered Content & PR Distribution. Bliv forstærket i dag.
• PlatoData.Network Vertical Generative Ai. Styrk dig selv. Adgang her.
• PlatoAiStream. Web3 intelligens. Viden forstærket. Adgang her.
• PlatoESG. Kulstof, CleanTech, Energi, Miljø, Solenergi, Affaldshåndtering. Adgang her.
• PlatoHealth. Bioteknologiske og kliniske forsøgs intelligens. Adgang her.
• Kilde: https://www.analyticsvidhya.com/blog/2024/01/approaches-to-displaying-lists-in-python/