Útmutató a Python tömbjéhez

Bevezetés

Képzelje el, hogy van egy lejátszási listája a kedvenc dalaiból a telefonján. Ez a lejátszási lista egy lista, ahol minden dal meghatározott sorrendben van elhelyezve. Lejátszhatja az első dalt, ugorhat a másodikra, ugorhat az ötödikre, és így tovább. Ez a lejátszási lista nagyon hasonlít egy tömbhöz a számítógépes programozásban.

A tömbök az egyik legalapvetőbb és legszélesebb körben használt adatstruktúra.

Lényegében a tömb több elem (például számok, karakterek vagy akár más tömbök) meghatározott sorrendben történő tárolásának strukturált módja, és bármely elemet gyorsan elérhet, módosíthat vagy eltávolíthat, ha ismeri a pozícióját (indexét).

Ebben az útmutatóban átfogó áttekintést adunk a tömb adatszerkezetéről. Először is megnézzük, mik azok a tömbök, és melyek a fő jellemzőik. Ezután áttérünk a Python világába, és megvizsgáljuk, hogyan valósíthatók meg, hogyan manipulálhatók és alkalmazhatók a tömbök valós helyzetekben.

A tömb adatszerkezetének megértése

A tömbök a számítástechnikában és a programozásban használt legrégebbi és legalapvetőbb adatstruktúrák közé tartoznak. Egyszerűségük, egyes műveletek hatékonyságával párosulva alapvető témává teszik mindazok számára, akik az adatkezelés és -manipuláció birodalmában elmélyülnek.

A tömb elemek gyűjteménye, jellemzően a azonos típusú, ben tárolva összefüggő memóriahelyek.

Ez a szomszédos tároló lehetővé teszi, hogy a tömbök állandó idejű hozzáférést biztosítsanak bármely elemhez, annak indexe alapján. A tömb minden elemét annek nevezzük elem, és egy elem helyzetét a tömbben az határozza meg index, ami általában nulláról indul.

Vegyünk például egy egész számok tömbjét: [10, 20, 30, 40, 50]. Itt az elem 20 indexe van 1:

Többszörösek előnyei tömbök használata adataink tárolására. Például a tömbök memóriaelrendezésük miatt lehetővé teszik O (1) (állandó) időbonyolultság, amikor egy elemet indexe alapján érünk el. Ez különösen akkor hasznos, ha véletlenszerű hozzáférésre van szükségünk az elemekhez. Ezenkívül a tömbök a következő helyen vannak tárolva összefüggő memóriahelyek, ami jobb gyorsítótár-helységhez és általános teljesítményjavuláshoz vezethet bizonyos műveleteknél. A tömbök használatának másik jelentős előnye, hogy mivel a tömbök deklarált mérete rögzített, könnyebb a memóriakezelés, és elkerülhető a váratlan túlcsordulás vagy a memóriahiány.

A másik oldalon a tömbök saját készlettel rendelkeznek korlátozások. A hagyományos tömbök egyik elsődleges korlátja az fix méretű. A tömb létrehozása után a mérete nem módosítható. Ez olyan problémákhoz vezethet, mint a memória elvesztése (ha a tömb túl nagy), vagy átméretezés szükséges (ha a tömb túl kicsi). Ezenkívül egy elem beszúrása vagy törlése egy tömb közepén megköveteli az elemek eltolását, ami O (n) e műveletek időbeli összetettsége.

Összegezve mindezt, szemléltessük a tömbök főbb jellemzőit az útmutató elején található dallejátszási lista példájával. A tömb egy olyan adatstruktúra, amely:

• Indexelt: Csakúgy, mint a lejátszási listán minden dalhoz tartozik egy szám (1, 2, 3, …), a tömb minden elemének van indexe. De a legtöbb programozási nyelvben az index 0-val kezdődik. Tehát az első elem a 0 indexnél van, a második az 1 indexnél, és így tovább.

• Fix mérettel rendelkezik: Ha mondjuk 10 dalhoz hoz létre lejátszási listát, nem adhat hozzá 11. dalt anélkül, hogy előbb ne távolítsa el az egyiket. Hasonlóképpen, a tömbök fix méretűek. Egy bizonyos méretű tömb létrehozása után nem adhat hozzá több elemet, mint amennyi a kapacitása.

• Homogén: A lejátszási listán szereplő összes dal zeneszám. Hasonlóképpen, egy tömb minden eleme azonos típusú. Ha egész számok tömbje van, nem tud hirtelen szöveges karakterláncot tárolni benne.

• Közvetlen hozzáféréssel rendelkezik: Ha meg szeretné hallgatni a lejátszási listája 7. dalát, közvetlenül ráugorhat. Hasonlóképpen, a tömbökkel azonnal hozzáférhet bármely elemhez, ha ismeri az indexét.

• Egybefüggő memória: Ez egy kicsit technikaibb. Amikor egy tömb jön létre a számítógép memóriájában, az egy folyamatos memóriablokkot foglal el. Képzeld úgy, mint egy sor szomszédos szekrénysort az iskolában. Mindegyik szekrény egymás mellett van, nincs rés közöttük.

Python és tömbök

A rugalmasságáról és egyszerű használatáról ismert Python többféle módszert kínál a tömbökkel való munkavégzéshez. Noha a Python nem rendelkezik natív tömb adatszerkezettel, mint néhány más nyelv, hatékony alternatívákat kínál, amelyek hasonlóan működhetnek, és még bővített képességeket is kínálnak.

Első pillantásra, Python listája egy tömb szinonimájának tűnhet, de vannak apró különbségek és árnyalatok, amelyeket figyelembe kell venni:

Lista	Sor
Beépített Python adatstruktúra	Nem natív a Pythonban – a "tömb" modulból származnak
Dinamikus méret	Fix (előre meghatározott) méret
Különféle adattípusú elemeket tárolhat	Tartsa az azonos típusú tárgyakat
Biztosítson egy sor beépített módszert a manipulációhoz	Külső modulokat kell importálni
O(1) a hozzáférési műveletek időbonyolultsága	O(1) a hozzáférési műveletek időbonyolultsága
Fogyassz több memóriát	Hatékonyabb memória

Erre a táblázatra nézve természetes, hogy megkérdezzük: – Mikor melyiket használjam?. Nos, ha olyan gyűjteményre van szüksége, amely dinamikusan növekedhet vagy csökkenhet, és vegyes adattípusokat tartalmazhat, a Python listája a megfelelő út. Az olyan forgatókönyvek esetében azonban, amelyek memóriahatékonyabb gyűjteményt igényelnek azonos típusú elemekkel, érdemes megfontolni a Python használatát. array modul vagy külső könyvtárak, például a NumPy.

A sor Modul Pythonban

Amikor a legtöbb fejlesztő a Python tömbjére gondol, gyakran alapértelmezés szerint a listákra gondol. A Python azonban speciálisabb tömbstruktúrát kínál a beépítettén keresztül array modult. Ez a modul az alapvető C-stílusú adattípusok helytakarékos tárolását biztosítja Pythonban.

Bár a Python-listák hihetetlenül sokoldalúak, és bármilyen típusú objektumot képesek tárolni, néha túlzásba eshetnek, különösen akkor, ha csak alapvető adattípusok gyűjteményét kell tárolnia, például egész számokat vagy lebegőpontokat. A array modul lehetőséget biztosít olyan tömbök létrehozására, amelyek memóriahatékonyabbak, mint az adott adattípusokhoz tartozó listák.

Tömb létrehozása

A array modult, először importálnia kell:

from array import array

Az importálás után létrehozhat egy tömböt a array() konstruktőr:

arr = array('i', [1, 2, 3, 4, 5])
print(arr)

Itt a 'i' argumentum azt jelzi, hogy a tömb aláírva tárolja egészek. Számos más típuskód is elérhető, mint pl 'f' úszókhoz és 'd' párosoknak.

Elemek elérése és módosítása

A tömb elemeihez ugyanúgy hozzáférhet és módosíthat, mint egy listával:

print(arr[2]) 

Most pedig módosítsuk az elemet úgy, hogy az értékét erre módosítjuk 6:

arr[2] = 6
print(arr) 

Tömb módszerek

A array A modul számos módszert kínál a tömbök manipulálására:

• append() – Elemet ad a tömb végéhez:

  arr.append(7)
  print(arr) 

• extend() – Iterálható elemeket fűz a végéhez:

  arr.extend([8, 9])
  print(arr) 

• pop() – Eltávolítja és visszaadja az elemet a megadott pozícióban:

  arr.pop(2)
  print(arr) 

• remove(): Eltávolítja a megadott érték első előfordulását:

  arr.remove(2)
  print(arr) 

• reverse(): Megfordítja a tömb sorrendjét:

  arr.reverse()
  print(arr) 

Míg az array modul memóriatakarékosabb módot kínál az alapvető adattípusok tárolására, ezért elengedhetetlen, hogy emlékezzen rá korlátozások. A listákkal ellentétben a tömbök azok homogén. Ez azt jelenti, hogy a tömb minden elemének azonos típusúnak kell lennie. Ezenkívül csak tárolni lehet alapvető C-stílusú adattípusok tömbökben. Ha egyéni objektumokat vagy más Python-típusokat kell tárolnia, akkor listát vagy más adatstruktúrát kell használnia.

NumPy tömbök

A NumPy, a Numerical Python rövidítése, a Python numerikus számításainak alapcsomagja. Egyik fő jellemzője az erőssége N-dimenziós tömbobjektum, amely gyors műveleteket kínál a tömbökön, beleértve a matematikai, logikai, alakkezelési és egyéb műveleteket.

A NumPy tömbök sokoldalúbbak, mint a Python beépített változatai array modul, és alapvető fontosságúak az adattudományi és gépi tanulási projektekben.

Miért használjunk NumPy tömböket?

Az első dolog, ami eszünkbe jut teljesítmény. A NumPy tömbök C-ben vannak megvalósítva, és hatékony memóriatárolást és gyorsabb műveleteket tesznek lehetővé az optimalizált algoritmusoknak és a szomszédos memóriatárolás előnyeinek köszönhetően.

Míg a Python beépített listái és tömbjei egydimenziósak, a NumPy tömbök többdimenziós, így ideálisak mátrixok vagy tenzorok ábrázolására.

Végül a NumPy biztosítja a funkciók széles skálája kezelni ezeket a tömböket, az alapvető aritmetikától a haladó matematikai műveletekig, átformálásig, felosztásig stb.

NumPy tömb létrehozása

A NumPy használatához először telepítenie kell (pip install numpy), majd importálja:

import numpy as np

Az importálás után létrehozhat egy NumPy tömböt a array() funkció:

arr = np.array([1, 2, 3, 4, 5])
print(arr) 

Többdimenziós tömböket is létrehozhat:

matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(matrix)

Ez ad nekünk:

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

A tömbök létrehozásának alapvető módjai mellett a NumPy más okos módszereket is kínál tömbök létrehozására. Ezek közül az egyik a arange() módszer. Rendszeresen növekvő értékekkel rendelkező tömböket hoz létre:

arr = np.arange(10)
print(arr) 

Egy másik a linspace() metódus, amely meghatározott számú elemből álló tömböket hoz létre, amelyek egyenlő távolságra vannak a megadott kezdő és végérték között:

even_space = np.linspace(0, 1, 5)
print(even_space) 

Elemek elérése és módosítása

A NumPy tömb elemeinek elérése és módosítása intuitív:

print(arr[2]) arr[2] = 6
print(arr) 

Nagyjából ugyanezt kell tenni a többdimenziós tömböknél:

print(matrix[1, 2]) matrix[1, 2] = 10
print(matrix)

Megváltoztatja a második sorban lévő elem értékét (index 1) és a harmadik oszlop (index 2):

[[1 2 3] [4 5 20] [7 8 9]]

Egy tömb alakjának megváltoztatása

A NumPy számos funkciót és módszert kínál a tömbök manipulálására és kezelésére. Használhatja például a reshape() módszer a megváltoztatni egy tömb alakját. Tegyük fel, hogy van egy egyszerű tömbünk:

import numpy as np arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
print("Original Array:")
print(arr) 

És szeretnénk átformálni egy 3×4-es mátrixra. Mindössze annyit kell tennie, hogy használja a reshape() metódus a kívánt dimenziókkal argumentumként átadott:

reshaped_arr = arr.reshape(3, 4)
print("Reshaped Array (3x4):")
print(reshaped_arr)

Ennek eredménye:

Reshaped Array (3x4):
[[ 1 2 3 4] [ 5 6 7 8] [ 9 10 11 12]]

Mátrixszorzás

A numpy.dot() módszert használják mátrixszorzás. Két tömb pontszorzatát adja vissza. Az egydimenziós tömbök esetében ez a belső termék a tömbök közül. A 2-dimenziós tömböknél egyenértékű mátrixszorzás, ND esetében pedig a összeg szorzat az első tömb utolsó tengelye és a második tömb második és utolsó tengelye felett.

Lássuk, hogyan működik. Először is számítsuk ki két egydimenziós tömb pontszorzatát (a vektorok belső szorzatát):

import numpy as np vec1 = np.array([1, 2, 3])
vec2 = np.array([4, 5, 6])
dot_product_1d = np.dot(vec1, vec2) print("Dot product of two 1-D arrays:")
print(dot_product_1d) 

Ennek eredménye:

Dot product of two 1-D arrays:
32

32 valójában a két tömb belső szorzata – (14 + 25 + 3*6). Ezután elvégezhetjük két 2D tömb mátrixszorzását:

mat1 = np.array([[1, 2], [3, 4]])
mat2 = np.array([[2, 0], [1, 3]])
matrix_product = np.dot(mat1, mat2) print("Matrix multiplication of two 2-D arrays:")
print(matrix_product) 

Ami ad nekünk:

Matrix multiplication of two 2-D arrays:
[[ 4 6] [10 12]]

A NumPy tömbök jelentős előrelépést jelentenek a Python beépített listáihoz és a array modul, különösen a tudományos és matematikai számításokhoz. Hatékonyságuk és a NumPy könyvtár által biztosított gazdag funkcionalitásuk nélkülözhetetlen eszközzé teszik őket bárki számára, aki Pythonban numerikus műveleteket szeretne végezni.

Következtetés

A tömbök, a számítástechnika és a programozás sarokkövei, újra és újra bebizonyították, hogy hasznosak különféle alkalmazásokban és tartományokban. A Pythonban ez az alapvető adatstruktúra különféle inkarnációival, például listákkal, a array modul és a nagy teljesítményű NumPy tömbök a hatékonyság, a sokoldalúság és az egyszerűség keverékét kínálják a fejlesztőknek.

Ebben az útmutatóban a tömbök alapfogalmaitól a Pythonban való gyakorlati alkalmazásaikig eljutottunk. Láttuk, hogy a tömbök memória-összefüggő természetükkel miként biztosítják a gyors hozzáférési időt, és a Python dinamikus listái hogyan hoznak további rugalmasságot. Belemerültünk a NumPy speciális világába is, ahol a tömbök a numerikus számítások hatékony eszközeivé alakulnak át.

• SEO által támogatott tartalom és PR terjesztés. Erősödjön még ma.
• PlatoData.Network Vertical Generative Ai. Erősítse meg magát. Hozzáférés itt.
• PlatoAiStream. Web3 Intelligence. Felerősített tudás. Hozzáférés itt.
• PlatoESG. Carbon, CleanTech, Energia, Környezet, Nap, Hulladékgazdálkodás. Hozzáférés itt.
• PlatoHealth. Biotechnológiai és klinikai vizsgálatok intelligencia. Hozzáférés itt.
• Forrás: https://stackabuse.com/guide-to-arrays-in-python/