Hantera listor i Python: En guide till användbara metoder
Denna handledning utforskar hur du kan manipulera listor i Python med hjälp av inbyggda metoder. Vi går igenom hur du lägger till, ändrar och tar bort element från listor. Listor är en grundläggande datastruktur i Python, och förståelsen för hur man arbetar med dem är avgörande för alla Python-utvecklare.
I den här genomgången kommer vi först att bekanta oss med de grundläggande egenskaperna hos Python-listor. Därefter kommer vi att utforska ett antal användbara listmetoder som gör det enkelt att interagera med listor. Låt oss sätta igång!
Översikt över Python-listor
En lista i Python är en ordnad samling av objekt. Dessa objekt kan vara av samma eller olika datatyper. Du kan iterera genom listan med loopar som for-loopar för att få tillgång till enskilda objekt. Listor följer nollindexering, vilket innebär att det första elementet har index 0. De stöder även slicing, vilket ger möjlighet att komma åt delar av listan.
Listor i Python är föränderliga, vilket innebär att du kan ändra dem på plats. Detta inkluderar att lägga till och ta bort element, sortera om listans innehåll, vända på ordningen och mycket mer. Pythons inbyggda listmetoder ger dig verktygen för att utföra dessa operationer.
Nu ska vi titta närmare på några praktiska listmetoder i Python.
Inbyggda listmetoder i Python
I det här avsnittet går vi igenom flera användbara listmetoder. Vi kommer att exemplifiera varje metod med kod, så att du ser hur de fungerar i praktiken. Vi använder listan `pgm_langs`, som innehåller strängar med populära programmeringsspråk, för att illustrera varje metod.
pgm_langs = ['Python','Go','Rust','JavaScript']Infoga listelement med `insert()`
Ibland behöver du infoga ett element på en specifik plats i listan. Detta gör du med metoden `insert()`, som tar två argument:
- Indexet där det nya elementet ska placeras.
- Själva elementet som ska infogas.
Låt oss infoga strängen `’Scala’` på index 1 i listan `pgm_langs`:
pgm_langs = ['Python','Go','Rust','JavaScript']
pgm_langs.insert(1,'Scala')
print(pgm_langs)
# Output: ['Python', 'Scala', 'Go', 'Rust', 'JavaScript']Lägg till element i slutet med `append()`
Om du vill lägga till ett element sist i listan, använder du metoden `append()`. Låt oss lägga till `’Java’` i slutet av `pgm_langs`:
pgm_langs.append('Java')
print(pgm_langs)
# Output: ['Python', 'Scala', 'Go', 'Rust', 'JavaScript', 'Java']Utöka listan med `extend()`
Du kan använda `append()` för att lägga till ett enstaka element. Men vad händer om du vill lägga till flera element, till exempel en annan lista? Metoden `extend()` gör det möjligt. Låt oss lägga till elementen från listan `more_langs` till `pgm_langs`:
more_langs = ['C++','C#','C']
pgm_langs.extend(more_langs)
print(pgm_langs)
# Output: ['Python', 'Scala', 'Go', 'Rust', 'JavaScript', 'Java', 'C++', 'C#', 'C']Du kan också lägga till element med en loop och `append()`, men `extend()` är en mer elegant lösning:
for lang in more_langs:
pgm_langs.append(lang)Vänd listans ordning med `reverse()`
För att vända på ordningen av elementen i en lista, kan du använda metoden `reverse()`:
pgm_langs.reverse()
print(pgm_langs)
# Output: ['C', 'C#', 'C++', 'Java', 'JavaScript', 'Rust', 'Go', 'Scala', 'Python']Sortera listan med `sort()`
Du kan sortera en lista på plats med hjälp av `sort()`. Eftersom `pgm_langs` är en lista med strängar, kommer den att sorteras i alfabetisk ordning:
pgm_langs.sort()
print(pgm_langs)
# Output: ['C', 'C#', 'C++', 'Go', 'Java', 'JavaScript', 'Python', 'Rust', 'Scala']För att sortera i omvänd alfabetisk ordning, anger du `reverse=True` i `sort()`:
pgm_langs.sort(reverse=True)
print(pgm_langs)
# Output: ['Scala', 'Rust', 'Python', 'JavaScript', 'Java', 'Go', 'C++', 'C#', 'C']Lär dig mer om att sortera listor i Python.
Skapa en ytlig kopia med `copy()`
Om du vill göra ändringar i en kopia av en lista utan att påverka originalet, kan du använda `copy()`. Den skapar en ytlig kopia:
pgm_langs_copy = pgm_langs.copy()
pgm_langs_copy[0]='Haskell'print(pgm_langs_copy)
# Output: ['Haskell', 'Rust', 'Python', 'JavaScript', 'Java', 'Go', 'C++', 'C#', 'C']Original-listan `pgm_langs` har inte ändrats:
print(pgm_langs)
# Output: ['Scala', 'Rust', 'Python', 'JavaScript', 'Java', 'Go', 'C++', 'C#', 'C']Räkna antalet förekomster med `count()`
Metoden `count()` räknar hur många gånger ett visst element förekommer i listan. I `pgm_langs` förekommer varje element exakt en gång. Om vi räknar `’Go’`, får vi 1:
print(pgm_langs.count('Go'))
# Output: 1Att använda `count()` kan vara ett sätt att ta bort dubbletter från listor.
Hämta index för ett element med `index()`
Med metoden `index()` kan du hitta indexet för ett visst element. Låt oss hitta indexet för `’C#’` i `pgm_langs`:
print(pgm_langs.index('C#'))
# Output: 7
assert pgm_langs[7] == 'C#'Ta bort element med `pop()`
Metoden `pop()` tar bort och returnerar ett element på ett visst index. Från föregående exempel vet vi att `’C#’` ligger på index 7. När vi anropar `pop()` med index 7, returneras `’C#’` och det tas bort från listan:
print(pgm_langs.pop(7))
# Output: 'C#'
print(pgm_langs)
# Output: ['Scala', 'Rust', 'Python', 'JavaScript', 'Java', 'Go', 'C++', 'C']Om inget index anges, tar `pop()` bort och returnerar det sista elementet:
print(pgm_langs.pop())
# Output: 'C'
print(pgm_langs)
# Output: ['Scala', 'Rust', 'Python', 'JavaScript', 'Java', 'Go', 'C++']Ta bort element med `remove()`
Om du vet vilket element du vill ta bort, men inte dess index, kan du använda `remove()`. Låt oss ta bort `’Java’` från `pgm_langs`:
pgm_langs.remove('Java')
print(pgm_langs)
# Output: ['Scala', 'Rust', 'Python', 'JavaScript', 'Go', 'C++']Rensa listan med `clear()`
För att ta bort alla element från en lista, kan du använda `clear()`. Metoden rensar listan helt och gör den tom:
pgm_langs.clear()
print(pgm_langs)
# Output: []Sammanfattning av Python List-metoder
Här är en sammanfattning av de listmetoder vi har gått igenom:
| Listmetod | Syntax | Beskrivning |
| insert() | list1.insert(index, elt) | Infogar `elt` vid `index` i `list1` |
| append() | list1.append(elt) | Lägger till `elt` i slutet av `list1` |
| extend() | list1.extend(list2) | Lägger till element från `list2` i slutet av `list1` |
| sort() | list1.sort() | Sorterar `list1` på plats |
| reverse() | list1.reverse() | Vänder på ordningen i `list1` på plats |
| copy() | list1.copy() | Returnerar en ytlig kopia av `list1` |
| count() | list1.count(elt) | Returnerar antalet gånger `elt` förekommer i `list1` |
| index() | list1.index(elt) | Returnerar indexet för `elt` i `list1` |
| pop() | list1.pop(index) | Tar bort elementet vid `index` och returnerar det. |
| remove() | list1.remove(elt) | Tar bort första förekomsten av `elt` från `list1` |
| clear() | list1.clear() | Tar bort alla element från `list1` |
Slutsats
Jag hoppas att den här handledningen har gett dig en bra förståelse för hur du använder de mest grundläggande listmetoderna i Python. Som nästa steg kan du utforska Python-tupler och lära dig om skillnaderna mellan listor och tupler i Python.
Om du lär dig Python, kan du kolla in den här listan med nybörjarvänliga resurser.