Home » Articole » Articole » Calculatoare » Programare » Python » Python: Liste – elemente și copierea lor

Python: Liste – elemente și copierea lor

postat în: Python 0

Am văzut deja liste și cum pot fi folosite. Acum că aveți mai multe informații, voi intra în mai multe detalii despre liste. Mai întâi ne vom uita la mai multe modalități de a ajunge la elementele dintr-o listă și apoi vom vorbi despre copierea lor.

Iată câteva exemple de utilizare a indexării pentru a accesa un singur element dintr-o listă:

>>> some_numbers = ['zero', 'one', 'two', 'three', 'four', 'five']
>>> some_numbers[0]
'zero'
>>> some_numbers[4]
'four'
>>> some_numbers[5]
'five'

Toate aceste exemple ar trebui să vă pară familiare. Dacă doriți primul articol din listă, priviți indexul 0. Al doilea element este indexul 1 și așa mai departe prin listă. Dar dacă doriți ultimul element din listă? O modalitate ar putea fi să folosiți funcția len() ca
some_numbers[len(some_numbers) - 1]
. Acest mod funcționează deoarece funcția len() returnează întotdeauna ultimul indice plus unu. Al doilea din ultimul ar fi atunci some_numbers[len(some_numbers) - 2]. Există o modalitate mai simplă de a face acest lucru. În Python, ultimul element este întotdeauna indexul -1. Al doilea este indexul -2 și așa mai departe. Iată mai multe exemple:

>>> some_numbers[len(some_numbers) - 1]
'five'
>>> some_numbers[len(some_numbers) - 2]
'four'
>>> some_numbers[-1]
'five'
>>> some_numbers[-2]
'four'
>>> some_numbers[-6]
'zero'

Astfel, orice articol din listă poate fi indexat în două moduri: din față și din spate.

O altă modalitate utilă de a intra în părți ale listelor este utilizarea tăierii. Iată un alt exemplu pentru a vă face o idee la ce pot fi folosite:

>>> things = [0, 'Fred', 2, 'S.P.A.M.', 'Stocking', 42, "Jack", "Jill"]
>>> things[0]
0
>>> things[7]
'Jill'
>>> things[0:8]
[0, 'Fred', 2, 'S.P.A.M.', 'Stocking', 42, 'Jack', 'Jill']
>>> things[2:4]
[2, 'S.P.A.M.']
>>> things[4:7]
['Stocking', 42, 'Jack']
>>> things[1:5]
['Fred', 2, 'S.P.A.M.', 'Stocking']

Tăierea este folosită pentru a returna o parte a unei liste. Operatorul de tăiere este sub forma things[first_index:last_index]. Tăierea taie lista înaintea first_index și înaintea last_index și returnează părțile intermediare. Puteți utiliza ambele tipuri de indexare:

>>> things[-4:-2]
['Stocking', 42]
>>> things[-4]
'Stocking'
>>> things[-4:6]
['Stocking', 42]

Un alt truc cu tăierea este indexul nespecificat. Dacă primul index nu este specificat, se presupune a fi începutul listei. Dacă ultimul index nu este specificat, se presupune întregul rest al listei. Aici sunt cateva exemple:

>>> things[:2]
[0, 'Fred']
>>> things[-2:]
['Jack', 'Jill']
>>> things[:3]
[0, 'Fred', 2]
>>> things[:-5]
[0, 'Fred', 2]

Iată un exemplu de program (inspirat din HTML) (copiați și lipiți în definiția poemului dacă doriți):


poem = ["<B>", "Jack", "and", "Jill", "</B>", "went", "up", "the",
        "hill", "to", "<B>", "fetch", "a", "pail", "of", "</B>",
        "water.", "Jack", "fell", "<B>", "down", "and", "broke",
        "</B>", "his", "crown", "and", "<B>", "Jill", "came",
        "</B>", "tumbling", "after"]

def get_bold(text):
    true = 1
    false = 0
    ## is_bold spune dacă ne uităm sau nu în prezent la 
    ## o secțiune îngroșată de text.
    is_bold = false
    ## start_block este indexul începutului fie al segmentul
    ## neîngroșat de text fie al segmentului îngroșat de text.
    start_block = 0
    for index in range(len(text)):
        ## Gestionează începutul de text îngroșat
        if text[index] == "<B>":
            if is_bold:
                print("Error: Extra Bold")
            ## print "Not Bold:", text[start_block:index]
            is_bold = true
            start_block = index + 1
        ## HGestionează sfârșitul de text îngroșat
        ## Amintiți-vă că ultimul număr dintr-o tăiere este indexul
        ## de după ultimul index folosit.
        if text[index] == "</B>":
            if not is_bold:
                print("Error: Extra Close Bold")
            print("Bold [", start_block, ":", index, "]", text[start_block:index])
            is_bold = false
            start_block = index + 1

get_bold(poem)

cu rezultattul fiind:

Bold [ 1 : 4 ] ['Jack', 'and', 'Jill']
Bold [ 11 : 15 ] ['fetch', 'a', 'pail', 'of']
Bold [ 20 : 23 ] ['down', 'and', 'broke']
Bold [ 28 : 30 ] ['Jill', 'came']

Funcția get_bold() preia o listă care este împărțită în cuvinte și simboluri. Indicatoarele pe care le caută sunt <B> care începe textul aldin și </B> cu care se termină textul aldin. Funcția
get_bold()
parcurge și caută indicatoarele de început și de sfârșit.

Următoarea caracteristică a listelor este copierea acestora. Dacă încerci ceva simplu de genul:

>>> a = [1, 2, 3]
>>> b = a
>>> print(b)
[1, 2, 3]
>>> b[1] = 10
>>> print(b)
[1, 10, 3]
>>> print(a)
[1, 10, 3]

Probabil că acest lucru pare surprinzător, deoarece o modificare a lui
b
a dus și la o schimbare. Ceea ce sa întâmplat este că afirmația b
= a
face din b o referire la a. Aceasta înseamnă că b poate fi considerat un alt nume pentru
a
. Prin urmare, orice modificare a lui b modifică și a. Oricum, unele teme nu creează două nume pentru o listă:

>>> a = [1, 2, 3]
>>> b = a * 2
>>> print(a)
[1, 2, 3]
>>> print(b)
[1, 2, 3, 1, 2, 3]
>>> a[1] = 10
>>> print(a)
[1, 10, 3]
>>> print(b)
[1, 2, 3, 1, 2, 3]

În acest caz, b nu este o referință la a, deoarece expresia a * 2 creează o nouă listă. Atunci afirmația b = a *
2
dă lui b o referință la a * 2, mai degrabă decât o referire la a. Toate operațiunile de atribuire creează o referință. Când treceți o listă ca argument unei funcții, creați și o referință. De cele mai multe ori nu trebuie să vă faceți griji cu privire la crearea referințelor, mai degrabă decât a copiilor. Cu toate acestea, atunci când trebuie să faceți modificări unei liste fără a schimba un alt nume al listei, trebuie să vă asigurați că ați creat de fapt o copie.

Există mai multe moduri de a face o copie a unei liste. Cel mai simplu care funcționează de cele mai multe ori este operatorul slice, deoarece face întotdeauna o nouă listă, chiar dacă este o tăiere dintr-o listă întreagă:

>>> a = [1, 2, 3]
>>> b = a[:]
>>> b[1] = 10
>>> print(a)
[1, 2, 3]
>>> print(b)
[1, 10, 3]

Folosirea tăierii [:] creează o nouă copie a listei. Cu toate acestea, copiază doar lista exterioară. Orice sublistă din interior este încă o referință la sublista din lista originală. Prin urmare, atunci când lista conține liste, listele interioare trebuie copiate și ele. Puteți face asta manual, dar Python conține deja un modul pentru a face acest lucru. Utilizați funcția deepcopy a modulului copy:

>>> import copy
>>> a = [[1, 2, 3], [4, 5, 6]]
>>> b = a[:]
>>> c = copy.deepcopy(a)
>>> b[0][1] = 10
>>> c[1][1] = 12
>>> print(a)
[[1, 10, 3], [4, 5, 6]]
>>> print(b)
[[1, 10, 3], [4, 5, 6]]
>>> print(c)
[[1, 2, 3], [4, 12, 6]]

În primul rând, observați că a este o listă de liste. Apoi observați că atunci când b[0][1] = 10 este rulat, ambele a și b sunt modificate, dar c nu este. Acest lucru se întâmplă deoarece zonele interioare sunt încă referințe atunci când este utilizat operatorul slice. Cu toate acestea, cu deepcopy c a fost copiat complet.

Deci, ar trebui să-mi fac griji pentru referințe de fiecare dată când folosesc o funcție sau =? Vestea bună este că trebuie să vă faceți griji doar pentru referințe atunci când utilizați dicționare și liste. Numerele și șirurile creează referințe atunci când sunt atribuite, dar fiecare operație asupra numerelor și șirurilor care le modifică creează o nouă copie, astfel încât să nu le puteți modifica niciodată în mod neașteptat. Trebuie să vă gândiți la referințe atunci când modificați o listă sau un dicționar.

Până acum probabil vă întrebați de ce sunt folosite referințele? Motivul de bază este viteza. Este mult mai rapid să faci o referire la o listă de o mie de elemente decât să copiezi toate elementele. Celălalt motiv este că vă permite să aveți o funcție pentru a modifica lista sau dicționarul introdus. Amintiți-vă doar despre referințe dacă aveți vreodată vreo problemă ciudată cu datele care sunt modificate atunci când nu ar trebui.

(Include texte din Wikibooks traduse și adaptate de Nicolae Sfetcu)

Rețele de comunicații 5G
Rețele de comunicații 5G

Descoperă cum 5G transformă lumea și pregătește-te să fii parte din viitor.

Nu a fost votat 14.32 lei32.94 lei Selectează opțiunile Acest produs are mai multe variații. Opțiunile pot fi alese în pagina produsului.
Inteligența competitivă - Concept - Studii
Inteligența competitivă – Concept – Studii

Inteligența competitivă: instrumentul esențial pentru succesul în afaceri

Nu a fost votat 9.53 lei15.08 lei Selectează opțiunile Acest produs are mai multe variații. Opțiunile pot fi alese în pagina produsului.
Etica Big Data în cercetare
Etica Big Data în cercetare

Principalele probleme cu care se confruntă oamenii de știință în lucrul cu seturile mari de date (Big Data), evidențiind principale aspecte etice, luând în considerare inclusiv legislația din Uniunea Europeană. După o scurtă Introducere despre Big Data, secțiunea Tehnologia prezintă … Citeşte mai mult

Nu a fost votat 0.00 lei11.25 lei Selectează opțiunile Acest produs are mai multe variații. Opțiunile pot fi alese în pagina produsului.

Lasă un răspuns

Adresa ta de email nu va fi publicată. Câmpurile obligatorii sunt marcate cu *