Python List Append VS Python List Extend - Forskellen forklaret med Array Method Eksempler

Velkommen

Hvis du vil lære at arbejde med .append()og .extend()forstå deres forskelle, er du kommet til det rigtige sted. De er effektive listemetoder, som du helt sikkert vil bruge i dine Python-projekter.

I denne artikel lærer du:

  • Hvordan og hvornår man skal bruge .append()metoden.
  • Hvordan og hvornår man skal bruge .extend()metoden.
  • Deres største forskelle.

Lad os begynde. ✨

? Tilføj

Lad os se, hvordan .append()metoden fungerer bag kulisserne.

Brug sager

Du skal bruge denne metode, når du vil tilføje et enkelt element i slutningen af en liste.

? Tip: Du kan tilføje elementer af enhver datatype, da lister kan have elementer af forskellige datatyper.

Syntaks og argumenter

For at kalde .append()metoden skal du bruge denne syntaks:

Fra venstre til højre:

  • Den liste, der vil blive ændret. Dette er normalt en variabel, der refererer til en liste.
  • En prik efterfulgt af navnet på metoden .append().
  • Inden for parentes, det element, der vil blive tilføjet til slutningen af ​​listen.

? Tip: Prikken er meget vigtig. Dette kaldes "priknotation". Prikken siger grundlæggende "kald denne metode på denne særlige liste", så effekten af ​​metoden vil blive anvendt på den liste, der er placeret før prikken.

Eksempler

Her er et eksempel på, hvordan du bruger .append():

# Define the list >>> nums = [1, 2, 3, 4] # Add the integer 5 to the end of the existing list >>> nums.append(5) # See the updated value of the list >>> nums [1, 2, 3, 4, 5]

? Tip: Når du bruger, .append()ændres den oprindelige liste. Metoden opretter ikke en kopi af listen - den muterer den oprindelige liste i hukommelsen.

Lad os foregive, at vi gennemfører en undersøgelse, og at vi vil analysere de data, der er indsamlet ved hjælp af Python. Vi er nødt til at tilføje en ny måling til den eksisterende liste over værdier.

Hvordan gør vi det? Vi bruger .append()metoden!

Du kan se det lige her:

# Existing list >>> nums = [5.6, 7.44, 6.75, 4.56, 2.3] # Add the float (decimal number) to the end of the existing list >>> nums.append(7.34) # See the updated value of the list >>> nums [5.6, 7.44, 6.75, 4.56, 2.3, 7.34]

Svarer til ...

Hvis du er bekendt med streng, liste eller tuple-udskæring, .append()svarer hvad der virkelig gør bag kulisserne:

a[len(a):] = [x]

Med dette eksempel kan du se, at de er ækvivalente.

Brug af .append():

>>> nums = [5.6, 7.44, 6.75, 4.56, 2.3] >>> nums.append(4.52) >>> nums [5.6, 7.44, 6.75, 4.56, 2.3, 4.52]

Brug af listeudskæring:

>>> nums = [5.6, 7.44, 6.75, 4.56, 2.3] >>> nums[len(nums):] = [4.52] >>> nums [5.6, 7.44, 6.75, 4.56, 2.3, 4.52]

Tilføjelse af en sekvens

Hvad synes du om dette eksempel? Hvad tror du vil blive sendt?

>>> nums = [5.6, 7.44, 6.75, 4.56, 2.3] >>> nums.append([5.67, 7.67, 3.44]) >>> nums # OUTPUT?

Er du klar? Dette vil være output:

[5.6, 7.44, 6.75, 4.56, 2.3, [5.67, 7.67, 3.44]]

Du spørger måske, hvorfor blev hele listen tilføjet som et enkelt element? Det er fordi .append()metoden tilføjer hele elementet til slutningen af ​​listen. Hvis elementet er en sekvens som en liste, ordbog eller tuple, tilføjes hele sekvensen som et enkelt element på den eksisterende liste.

Her har vi et andet eksempel (nedenfor). I dette tilfælde er elementet en tuple, og det tilføjes som et enkelt element på listen, ikke som individuelle poster:

>>> names = ["Lulu", "Nora", "Gino", "Bryan"] >>> names.append(("Emily", "John")) >>> names ['Lulu', 'Nora', 'Gino', 'Bryan', ('Emily', 'John')]

? Udvid

Lad os nu dykke ned i .extend()metodens funktionalitet.

Brug sager

Du bør bruge denne metode, hvis du har brug for at tilføje flere emner til en liste som individuelle emner .

Lad mig illustrere vigtigheden af ​​denne metode med en velkendt ven, som du lige har lært: .append()metoden. Baseret på det, du hidtil har lært, hvis vi ønsker at tilføje flere individuelle emner til en liste ved hjælp af .append(), bliver vi nødt til at bruge .append()flere gange, sådan:

# List that we want to modify >>> nums = [5.6, 7.44, 6.75, 4.56, 2.3] # Appending the items >>> nums.append(2.3) >>> nums.append(9.6) >>> nums.append(4.564) >>> nums.append(7.56) # Updated list >>> nums [5.6, 7.44, 6.75, 4.56, 2.3, 2.3, 9.6, 4.564, 7.56]

Jeg er sikker på, at du sandsynligvis tænker, at dette ikke ville være meget effektivt, ikke? Hvad hvis jeg har brug for at tilføje tusinder eller millioner af værdier? Jeg kan ikke skrive tusinder eller millioner af linjer til denne enkle opgave. Det ville tage for evigt!

Så lad os se et alternativ. Vi kan gemme de værdier, som vi vil tilføje, i en separat liste og derefter bruge en for-loop til at ringe .append()så mange gange som nødvendigt:

# List that we want to modify >>> nums = [5.6, 7.44, 6.75, 4.56, 2.3] # Values that we want to add >>> new_values = [2.3, 9.6, 4.564, 7.56] # For loop that is going to append the value >>> for num in new_values: nums.append(num) # Updated value of the list >>> nums [5.6, 7.44, 6.75, 4.56, 2.3, 2.3, 9.6, 4.564, 7.56]

Dette er mere effektivt, ikke? Vi skriver kun et par linjer. Men der er en endnu mere effektiv, læsbar og kompakt måde at nå det samme formål .extend():!

>>> nums = [5.6, 7.44, 6.75, 4.56, 2.3] >>> new_values = [2.3, 9.6, 4.564, 7.56] # This is where the magic occurs! No more for loops >>> nums.extend(new_values) # The list was updated with individual values >>> nums [5.6, 7.44, 6.75, 4.56, 2.3, 2.3, 9.6, 4.564, 7.56]

Lad os se, hvordan denne metode fungerer bag kulisserne.

Syntaks og argumenter

For at kalde .extend()metoden skal du bruge denne syntaks:

Fra venstre til højre:

  • Den liste, der vil blive ændret. Dette er normalt en variabel, der henviser til listen.
  • En prik .(indtil videre er alt nøjagtigt det samme som før).
  • Navnet på metoden extend. (Nu begynder tingene at ændre sig ...).
  • Inden for parentes, en iterabel (liste, tuple, ordbog, sæt eller streng), der indeholder de emner, der tilføjes som individuelle elementer på listen.

? Tips: According to the Python documentation, an iterable is defined as "an object capable of returning its members one at a time". Iterables can be used in a for loop and because they return their elements one at a time, we can "do something" with each one of them, one per iteration.

Behind the Scenes

Let's see how .extend() works behind the scenes. Here we have an example:

# List that will be modified >>> a = [1, 2, 3, 4] # Sequence of values that we want to add to the list a >>> b = [5, 6, 7] # Calling .extend() >>> a.extend(b) # See the updated list. Now the list a has the values 5, 6, and 7 >>> a [1, 2, 3, 4, 5, 6, 7]

You can think of .extend() as a method that appends the individual elements of the iterable in the same order as they appear.

In this case, we have a list a = [1, 2, 3, 4] as illustrated in the diagram below. We also have a list b = [5, 6, 7] that contains the sequence of values that we want to add. The method takes each element of b and appends it to list a in the same order.

After this process is completed, we have the updated list a and we can work with the values as individual elements of a.

? Tips: The list b used to extend list a remains intact after this process. You can work with it after the call to .extend(). Here is the proof:

>>> a = [1, 2, 3, 4] >>> b = [5, 6, 7] >>> a.extend(b) >>> a [1, 2, 3, 4, 5, 6, 7] # List b is intact! >>> b [5, 6, 7]

Examples

You may be curious to know how the .extend() method works when you pass different types of iterables. Let's see how in the following examples:

For tuples:

The process works exactly the same if you pass a tuple. The individual elements of the tuple are appended one by one in the order that they appear.

# List that will be extended >>> a = [1, 2, 3, 4] # Values that will be added (the iterable is a tuple!) >>> b = (1, 2, 3, 4) # Method call >>> a.extend(b) # The value of the list a was updated >>> a [1, 2, 3, 4, 1, 2, 3, 4]

For sets:

The same occurs if you pass a set. The elements of the set are appended one by one.

# List that will be extended >>> a = [1, 2, 3, 4] # Values that will be appended (the iterable is a set!) >>> c = {5, 6, 7} # Method call >>> a.extend(c) # The value of a was updated >>> a [1, 2, 3, 4, 5, 6, 7]

For strings:

Strings work a little bit different with the .extend() method. Each character of the string is considered an "item", so the characters are appended one by one in the order that they appear in the string.

# List that will be extended >>> a = ["a", "b", "c"] # String that will be used to extend the list >>> b = "Hello, World!" # Method call >>> a.extend(b) # The value of a was updated >>> a ['a', 'b', 'c', 'H', 'e', 'l', 'l', 'o', ',', ' ', 'W', 'o', 'r', 'l', 'd', '!']

For dictionaries:

Dictionaries have a particular behavior when you pass them as arguments to .extend(). In this case, the keys of the dictionary are appended one by one. The values of the corresponding key-value pairs are not appended.

In this example (below), the keys are "d", "e", and "f". These values are appended to the list a.

# List that will be extended >>> a = ["a", "b", "c"] # Dictionary that will be used to extend the list >>> b = {"d": 5, "e": 6, "f": 7} # Method call >>> a.extend(b) # The value of a was updated >>> a ['a', 'b', 'c', 'd', 'e', 'f']

Equivalent to...

What .extend() does is equivalent to a[len(a):] = iterable. Here we have an example to illustrate that they are equivalent:

Using .extend():

# List that will be extended >>> a = [1, 2, 3, 4] # Values that will be appended >>> b = (6, 7, 8) # Method call >>> a.extend(b) # The list was updated >>> a [1, 2, 3, 4, 6, 7, 8] 

Using list slicing:

# List that will be extended >>> a = [1, 2, 3, 4] # Values that will be appended >>> b = (6, 7, 8) # Assignment statement. Assign the iterable b as the final portion of the list a >>> a[len(a):] = b # The value of a was updated >>> a [1, 2, 3, 4, 6, 7, 8]

The result is the same, but using .extend() is much more readable and compact, right? Python truly offers amazing tools to improve our workflow.

? Summary of their Differences

Now that you know how to work with .append() and .extend(), let's see a summary of their key differences:

  • Effect: .append() adds a single element to the end of the list while .extend() can add multiple individual elements to the end of the list.
  • Argument: .append() takes a single element as argument while .extend() takes an iterable as argument (list, tuple, dictionaries, sets, strings).

I really hope that you liked my article and found it helpful. Now you can work with .append() and .extend() in your Python projects. Check out my online courses. Follow me on Twitter. ⭐️