6 olika tillvägagångssätt för att visa listor i Python

Beskrivning

I Python handlar utskrift av listor inte bara om att visa värden; det är ett sätt för programmerare att förstå sin kod bättre och se till att data ser rätt ut. Låt oss utforska olika sätt att skriva ut listor, med praktiska exempel och tips för att göra saker tydligare. Låt oss dyka in i Python-listornas värld.

Anmäl dig till vår gratis kurs av Python.

Skriv ut listor i Python

Utskrift listor i Python öppnar upp en rad metoder, och i den här artikeln kommer vi att utforska flera effektiva tillvägagångssätt:

• Använder för loop
• Konvertera en lista till sträng för visning
• Använda sep-parametern i print()
• Använder map()-funktionen
• Använder indexering och skivning
• Använder listförståelse

Visa en lista i Python med hjälp av en For Loop

Iterera genom listan från 0 till dess längd och skriv ut varje element individuellt med en for-loop; detta är det konventionella sättet att åstadkomma det.

Nedan är ett exempel på att visa en lista i Python med en for-loop:

# 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 det här exemplet har vi en lista med frukter, och for-loopen itererar genom varje objekt i listan och visar dem en efter en.

Produktion:

Tidskomplexitet (O(n)):

Tidskomplexiteten är O(n) eftersom, i en for-slinga, varje element i listan besöks en gång, och tiden det tar att exekvera slingan är direkt proportionell mot antalet element i inmatningslistan.

Rymdkomplexitet (O(1)):

Utrymmeskomplexiteten är O(1) eftersom slingan använder en konstant mängd minne, oberoende av ingångsstorleken; den använder bara en enda variabel (element) för att representera varje objekt i listan och skapar inte ytterligare datastrukturer som växer med indata.

Visa en lista genom att konvertera den till en sträng

När det handlar om en lista över strängar, är ett enkelt tillvägagångssätt att använda funktionen join() för enkel sammankoppling. Men när listan innehåller heltal behövs en process i två steg: först konvertera dem till strängar och använd sedan funktionen join() för att skapa en enhetlig sträng för visning.

Här är ett exempel:

# 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 det här exemplet sammanfogar joinmetoden elementen i listan till en singel sträng, åtskilda av ett kommatecken och ett mellanslag. Resultatet visas sedan som en formaterad sträng.

Produktion:

Tidskomplexitet (O(n)):

Tidskomplexiteten är O(n) eftersom, i en for-slinga, varje element i listan bearbetas en gång, och exekveringstiden skalas linjärt med antalet element i inmatningslistan. När indata växer, växer algoritmens körtid proportionellt.

Rymdkomplexitet (O(1)):

Utrymmeskomplexiteten är O(1) eftersom algoritmen använder en konstant mängd minne oavsett indatastorlek. Slingan kräver bara en enda variabel (element) för att representera varje objekt i listan, och den skapar inte ytterligare datastrukturer eller minne som beror på storleken på indatalistan.

Visa med sep-parametern i Print()

Sep-parametern i print()-funktionen låter dig ange en separator mellan objekten du skriver ut. 

Genom att använda asterisk (*)-symbolen kan du presentera listelement på en enda rad med mellanslag. För en visning med varje element på en ny rad eller separerade med kommatecken, använd sep=”n” eller sep=”, ” respektive. 

Här är ett exempel med en lista över frukter:

# 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 det här exemplet anger sep=”, ” att ett kommatecken och ett mellanslag ska användas som avgränsare mellan objekten i listan.

Produktion:

Tidskomplexitet (O(n)):

Tidskomplexiteten är O(n) eftersom, med en for-loop, bearbetas varje element i listan individuellt. När antalet element (n) växer, ökar exekveringstiden linjärt, vilket återspeglar ett direkt samband mellan indatastorlek och beräkningstid.

Rymdkomplexitet (O(1)):

Utrymmeskomplexiteten är O(1) eftersom algoritmen använder en konsekvent mängd minne, oberoende av ingångsstorlek. Slingan använder en fast uppsättning variabler (som 'element') och undviker att skapa ytterligare datastrukturer eller dynamiskt allokera minne i förhållande till indatastorleken.

Visa en lista i Python med hjälp av Map()-funktionen

Använd map()-funktionen för att säkerställa att varje objekt i listan är en sträng, särskilt när listan innehåller icke-strängelement. Efter detta, slå samman dessa transformerade element med hjälp av join-funktionen för en enhetlig visning.

Här är ett exempel på att visa en lista med frukter i Python:

# Example list of fruits

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

# Displaying the list of fruits

print("List of Fruits:", fruits)

Produktion:

Print()-funktionen formaterar automatiskt listan för visning. Om du vill anpassa utdata ytterligare kan du iterera genom listan och skriva ut varje objekt individuellt eller använda kopplingsmetoden, som visas i tidigare exempel.

Visa en lista i Python med hjälp av indexering och skärning

Du kan visa en lista i Python genom att använda indexering och skivning för att komma åt specifika element eller en delmängd av listan. 

Här är ett exempel:

# 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])

Produktion:

I det här exemplet används indexering för att komma åt enskilda element (t.ex. frukter[0] för det första elementet), och skivning används för att visa en delmängd av listan (t.ex. frukter[1:4] för element vid index 1, 2 och 3).

Tidskomplexitet (O(n)):

Tidskomplexiteten är O(n) eftersom att iterera genom en lista med indexering eller skivning innebär att man besöker varje element en gång. När storleken på listan (n) ökar, ökar tiden det tar att komma åt eller skära upp listan linjärt.

Rymdkomplexitet (O(1)):

Utrymmeskomplexiteten är O(1) för indexerings- och uppdelningsoperationer eftersom de använder en konstant mängd extra minne, oavsett storleken på listan. Minnet som krävs för index-/segmentvariabler förblir konstant, skalas inte med indatastorleken.

Visa en lista i Python med hjälp av listförståelse

Listförståelse är en kortfattad funktion i Python för att skapa listor genom att tillämpa ett uttryck på varje objekt i en befintlig iterabel. Det ger en kompakt syntax som kombinerar stegen att skapa en ny lista och tillämpa en transformation på dess element.

Här är ett exempel på att visa en modifierad lista med frukter med hjälp av listförstå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)

Produktion:

I det här exemplet används listförståelse för att skapa en ny lista (capitalized_fruits). Resultatet är en lista över frukter med deras namn med versaler.

Tidskomplexitet (O(n)):

Tidskomplexiteten är O(n) för detta exempel eftersom den itererar genom varje element i den ursprungliga listan med frukter. Utförandetiden skalar linjärt med antalet frukter, vilket gör den proportionell mot storleken på inmatningslistan.

Rymdkomplexitet (O(n)):

Utrymmeskomplexiteten är O(n) eftersom listförståelse skapar en ny lista (capitalized_fruits) som växer med storleken på indatalistan (frukter). Varje element i den ursprungliga listan motsvarar ett element i den nya listan, vilket bidrar till ett linjärt förhållande mellan indatastorleken och det använda minnet.

Slutsats

I Python är det avgörande att bemästra konsten att skriva ut listor för kodförståelse och datavisualisering. Den här guiden har utforskat sex effektiva sätt att visa listor, och erbjuder praktiska exempel och tips för klarhet. Oavsett om du använder loopar, strängkonvertering, anpassade separatorer, kartfunktioner, indexering, skivning eller listförståelse, tjänar varje tillvägagångssätt ett specifikt syfte och förbättrar dina Python-programmeringsfärdigheter.

Vanliga frågor

Relaterad

• SEO-drivet innehåll och PR-distribution. Bli förstärkt idag.
• PlatoData.Network Vertical Generative Ai. Styrka dig själv. Tillgång här.
• PlatoAiStream. Web3 Intelligence. Kunskap förstärkt. Tillgång här.
• Platoesg. Kol, CleanTech, Energi, Miljö, Sol, Avfallshantering. Tillgång här.
• PlatoHealth. Biotech och kliniska prövningar Intelligence. Tillgång här.
• Källa: https://www.analyticsvidhya.com/blog/2024/01/approaches-to-displaying-lists-in-python/