numpy.append() i Python

NumPy är ett otroligt användbart bibliotek för numeriska operationer och datahantering i Python. En av dess centrala funktioner är numpy.append(), som underlättar sammanslagning av arrayer med olika dimensioner. I denna artikel ska vi noggrant granska numpy.append(), inklusive dess struktur, parametrar och praktiska användningsområden.

Grunderna i ndarray och Arrayer i NumPy

Innan vi går in på detaljerna med numpy.append(), är det viktigt att förstå vad ndarray och arrayer representerar i NumPy.

  • ndarray (n-dimensionell array): En ndarray är en mångdimensionell databehållare, arrangerad i en rektangulär struktur. Denna datatyp är kärnan i NumPy.
  • Arrayer: Arrayer är en specifik typ av ndarray som endast har en dimension, vilket gör dem endimensionella.

Syntax för NumPy.append()

Den grundläggande syntaxen för numpy.append() ser ut så här:

numpy.append(arr, values, axis=None)

Här betyder:

  • arr: Den befintliga arrayen som ska utökas.
  • values: Den array eller det enskilda värde som ska läggas till i slutet av arr.
  • axis: En valfri parameter som specificerar längs vilken axel sammanfogningen ska ske. Standardvärdet är None, vilket innebär att arrayerna sammanfogas längs den första axeln.

Parametrar i NumPy.append()

numpy.append() erbjuder flera parametrar som ger kontroll över sammanslagningsprocessen:

  • axis: Som tidigare nämnts definierar axis den axel längs vilken sammanslagningen sker.
  • return_indices: En boolesk parameter som, om satt till True, returnerar indexpositionerna för elementen i den initiala arrayen i den resulterande arrayen.
  • return_counts: En annan boolesk parameter; om True returneras antalet gånger varje element förekommer i den initiala arrayen i den utökade arrayen.
  • where: En modifierare som tillåter sammanslagning endast under vissa förutsättningar.
  • casting: En sträng som anger hur data ska konverteras om datatyperna för arr och values inte överensstämmer.

Praktiska Exempel på NumPy.append()

Låt oss titta på några exempel för att demonstrera hur numpy.append() fungerar i praktiken:


import numpy as np

Exempel 1: Sammanslagning längs rader


arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])


res = np.append(arr1, arr2)
print(res)

Resultat:
[1 2 3 4 5 6]

I detta fall har vi slagit samman arr1 och arr2 längs raderna, vilket genererar en ny array som inkluderar alla element från de två ursprungliga arrayerna.

Exempel 2: Sammanslagning längs kolumner


arr1 = np.array([[1, 2], [3, 4]])
arr2 = np.array([[5, 6], [7, 8]])


res = np.append(arr1, arr2, axis=1)
print(res)

Resultat:

[[1 2 5 6]
[3 4 7 8]]

I detta exempel slås arr1 och arr2 samman längs kolumnerna. Den resulterande arrayen innehåller alla element från de två ursprungliga arrayerna sida vid sida.

Exempel 3: Använda villkor med ”where”


arr1 = np.array([1, 2, 3, 4, 5])
arr2 = np.array([6, 7, 8, 9, 10])


res = np.append(arr1, arr2, where=arr1 > 2)
print(res)

Resultat:
[1 2 3 6 7 8 9 10]

Här används villkoret arr1 > 2 med where-modifieraren, vilket betyder att endast elementen i arr1 som är större än 2 inkluderas i sammanslagningen.

Sammanfattning

numpy.append() är en mångsidig funktion som gör det lätt att sammanfoga arrayer i NumPy. Genom att behärska dess syntax och parametrar kan du skräddarsy sammanslagningsprocessen efter dina specifika behov. Funktionen ger flexibilitet och användarvänlighet för datahantering i Python, från att hantera endimensionella arrayer till komplexa flerdimensionella strukturer.

Vanliga Frågor (FAQ)

1. Vad är skillnaden mellan numpy.append() och numpy.concatenate()?
numpy.concatenate() tillåter sammanslagning av flera arrayer i ett enda steg och returnerar en ny array. numpy.append(), å andra sidan, är begränsad till att sammanfoga två arrayer och modifierar den existerande arrayen.

2. Hur sammanfogar jag arrayer med olika datatyper med numpy.append()?
Du kan använda parametern casting för att definiera hur datakonvertering ska göras i fall datatyperna inte matchar.

3. Kan jag sammanfoga arrayer med olika former med numpy.append()?
Nej, arrayerna måste ha kompatibla former för att kunna sammanfogas med numpy.append().

4. Hur extraherar jag indexen för elementen i den ursprungliga arrayen efter sammanslagningen?
Du kan göra detta genom att sätta parametern return_indices till True.

5. Hur räknar jag förekomsten av element i den ursprungliga arrayen efter sammanslagningen?
Genom att sätta parametern return_counts till True, kan du få denna information.

6. Kan jag utföra sammanslagning endast under specifika villkor?
Ja, du kan använda parametern where tillsammans med ett villkorsuttryck för att styra vilka element som påverkas av sammanslagningen.

7. Hur sammanfogar jag arrayer längs en specifik axel?
Du kan ange önskad axel med hjälp av parametern axis.

8. Var hittar jag mer information om numpy.append()?
NumPy-dokumentationen och Stack Overflow är bra resurser för att lära sig mer.