Ĉapitro 4 - Listoj
Subtenu la Aŭtoro: Aĉeti la libron sur Amazono aŭ
la libro / ebook pakaĵo rekte Neniu amelo Gazetaro .
Legi la aŭtora aliaj liberaj Python libroj:
listoj
Leciono 13 - Listoj, Indeksoj, Tranĉaĵoj, kaj la listo () Funkcio
Pli temo vi bezonas kompreni antaŭ vi povas komenci skribi programojn en serioza la listo datumtipo kaj lia kuzo, la opo. Lertaj kaj opoj povas enhavi multoblajn valorojn, faciligante skribi programojn kiuj manipuli grandajn kvantojn de datumoj. Kaj ekde listoj mem povas enhavi aliajn listojn, vi povas uzi ilin aranĝi datumojn en hierarkia strukturo.
En ĉi tiu ĉapitro, mi diskutos la basics de listoj. Mi ankaŭ instruas vin pri metodoj, kiuj estas funkcioj kiuj estas ligitaj al valoroj de certa datumtipo. Poste mi mallonge kovri la listo-kiel opo kaj ŝnuro datumtipoj kaj kiel ili komparas al listo valoroj. En la sekva ĉapitro, mi konigos vin al la vortaro datumtipo.
La Listo Datumoj Tipo
Liston estas valoro kiu enhavas multoblajn valorojn en orditan sekvencon. La termino listo valoro
rilatas al la listo mem (kiu estas valoro kiu povas esti stokita en
variablo aŭ pasita al funkcio kiel ajna alia valoro), ne la valoroj ene
la listo valoro. Liston valoro aspektas tiel:
['cat', 'bat', 'rat', 'elephant'] .
Kiel ŝnuro valoroj tajpita kun citaĵo karakteroj marki kie la ŝnuro
komencas kaj finiĝas, listo komencas kun abertura kvadrata krampo kaj
finiĝas kun fermante kvadrata krampo, [] . Valoroj ene la listo estas nomitaj ankaŭ erojn. Aĵoj estas apartigitaj per komoj (tio estas, ili estas komo-limigitaj). Ekzemple, tajpu la sekvajn en la interaga konko: >>> [1, 2, 3] [1, 2, 3] >>> [ 'Kato', 'bat', 'rato', 'elefanto'] [ 'Kato', 'bat', 'rato', 'elefanto'] >>> [ 'Saluton', 3,1415, Vera, Neniu 42] [ 'Saluton', 3,1415, Vera, Neniu 42] ❶ >>> spamado = [ 'kato', 'bat', 'rato', 'elefanto'] >>> spamon [ 'Kato', 'bat', 'rato', 'elefanto']
La
spam variablo ❶ ankoraŭ asignita nur unu valoro: la listo valoro. Sed la listo valoro mem enhavas aliajn valorojn. La valoro [] estas vasta lerta kiu enhavas neniun valoroj, simila al '' , la malplena linio. Getting Individuaj Valoroj en Listo kun Indeksoj
Diru vi havas la liston
['cat', 'bat', 'rat', 'elephant'] stokitaj en variablo nomata spam . La Python kodo spam[0] estus taksi al 'cat' , kaj spam[1] estus taksi al 'bat' , kaj tiel plu. La entjero ene la rektaj krampoj kiuj sekvas la listo nomata indekso. La unua valoro en la listo estas indekso 0 , la dua valoro estas je indekso 1 , la tria valoro estas je indekso 2 , kaj tiel plu. Figuro 4-1 montras liston valoro atribuita al spam , kune kun kio la indekso esprimoj farus taksi al. 
Figuro 4-1. Liston valoro stokita en la variablo
spam , montradon valoron ĉiu indekso rilatas al
Ekzemple, tajpu la sekvajn esprimojn en la interaga ŝelo. Komencu per asignanta lerta al la variablo
spam . >>> Spamado = [ 'kato', 'bat', 'rato', 'elefanto'] >>> Spamado [0] 'Kato' >>> Spamado [1] 'Bat' >>> Spamado [2] 'Rato' >>> Spamado [3] 'Elefanto' >>> [ 'Kato', 'bat', 'rato', 'elefanto'] [3] 'Elefanto' ❶ >>> Saluton + spamado [0] ❷ Saluton kato ' >>> 'La' + spamado [1] + 'manĝis la' + spamado [0] + '.' La vesperto manĝis la kato. "
Rimarku ke la esprimo
'Hello ' + spam[0] ❶ taksas al 'Hello ' + 'cat' ĉar spam[0] taksas la ĉeno 'cat' . Tiu esprimo siavice taksas al la kordo valoro 'Hello cat' ❷.
Python donos vin
IndexError erarmesaĝo se vi uzas indekson kiu superas la nombron de valoroj en via listo valoro. >>> Spamado = [ 'kato', 'bat', 'rato', 'elefanto'] >>> Spamado [10000] Traceback (plej lasta alvoko lasta): Dosiero "<pyshell # 9>", linio 1, en <modulo> spamado [10000] IndexError: listo indekso ekster atingo
Indeksoj povas esti nur entjera valoroj, ne flosas. La sekvanta ekzemplo kaŭzos
TypeError eraro: >>> Spamado = [ 'kato', 'bat', 'rato', 'elefanto'] >>> Spamado [1] 'Bat' >>> Spamado [1,0] Traceback (plej lasta alvoko lasta): Dosiero "<pyshell # 13>", linio 1, en <modulo> spamado [1,0] TypeError: listo indeksoj devas esti entjeroj, ne flosi >>> Spamado [int (1.0)] 'Bat'
Listoj povas ankaŭ enhavi aliaj listo valoroj. La valoroj en tiuj listoj de listoj povas esti alirita uzante multoblajn indeksojn, kiel tia:
>>> Spamado = [[ 'kato', 'bat'], [10, 20, 30, 40, 50]] >>> Spamado [0] [ 'Kato', 'bat'] >>> Spamado [0] [1] 'Bat' >>> Spamado [1] [4] 50
La unua indico diktas kion listo valoro al uzi, kaj la dua indikas la valoron ene la listo valoro. Ekzemple,
spam[0][1] presaĵoj 'bat' , la dua valoro en la unua listo. Se vi nur uzas unu indekso, la programo presos la plenan liston valoro en tiu indekso. negativa Indeksoj
Dum indeksoj starti je
0 kaj iru, vi povas uzi ankaŭ negativaj entjeroj por la indekso. La entjera valoro -1 rilatas al la lasta indekso en listo, la valoro -2 referencas al la dua-al-lasta indekso en listo, kaj tiel plu. Eniri la sekva en la interaga konko: >>> Spamado = [ 'kato', 'bat', 'rato', 'elefanto'] >>> Spamado [-1] 'Elefanto' >>> Spamado [-3] 'Bat' >>> 'La' + spamado [-1] + 'timas la' + spamado [-3] + '.' La elefanto timas la vesperton.
Getting Alsublistige kun Tranĉaĵoj
Kiel indekso povas akiri ununuran valoron el listo, tranĉaĵo povas akiri plurajn valorojn el listo, en la formo de nova listo. Tranĉaĵo estas tajpita inter kvadrataj krampoj, kiel indico, sed ĝi havas du entjeroj apartigitaj per dupunkto. Rimarku la diferencon inter indeksoj kaj tranĉaĵoj.
spam[2]estas listo kun indekso (unu entjero).spam[1:4]estas listo kun tranĉaĵo (du entjeroj).
En tranĉaĵo, la unua entjero estas la indekso kie la tranĉaĵo startas. La dua entjero estas la indekso kie la tranĉaĵo finiĝas. Tranĉaĵo tusxus, sed ne inkludas, la valoro je la dua indekso. Tranĉaĵo taksas al nova listo valoro. Eniri la sekva en la interaga konko:
>>> Spamado = [ 'kato', 'bat', 'rato', 'elefanto'] >>> Spamado [0: 4] [ 'Kato', 'bat', 'rato', 'elefanto'] >>> Spamado [1: 3] [ 'Bat', 'rato'] >>> Spamado [0: -1] [ 'Kato', 'bat', 'rato']
Kiel ŝparvojo, vi povas lasi ekstere unu aŭ ambaŭ de la indeksoj ambaŭflanke de la dupunkto en la tranĉaĵo. Lasante la unua indico estas la sama kiel uzanta
0 , aŭ la komenco de la listo. Lasante la dua indico estas la sama kiel uzanta la longo de la listo, kiu devos tranĉi al la fino de la listo. Eniri la sekva en la interaga konko: >>> Spamado = [ 'kato', 'bat', 'rato', 'elefanto'] >>> Spamado [2] [ 'Kato', 'bat'] >>> Spamado [1] [ 'Bat', 'rato', 'elefanto'] >>> Spamado [:] [ 'Kato', 'bat', 'rato', 'elefanto']
Prenanta Listo de Longeco kun len ()
La
len()
funkcio estos redoni la nombro de valoroj kiuj estas en lerta valoro
pasis al ĝi, ĝuste kiel ĝi povas kalkuli la nombron de karakteroj en
cxeno valoro. Eniri la sekva en la interaga konko: >>> Spamado = [ 'kato', 'hundo', 'alko'] >>> Len (spamon) 3
Ŝanĝi Valoroj en Listo kun Indeksoj
Kutime variablo nomo iras sur la maldekstra flanko de asigno komunikaĵo, kiel
spam = 42 . Tamen, vi povas ankaŭ uzi indekso de listo por ŝanĝi la valoron en tiu indekso. Ekzemple, spam[1] = 'aardvark' signifas "Atribui la valoro je indekso 1 en la lerta spam al la ĉeno 'aardvark' ." Eniru la sekva en la interaga konko: >>> Spamado = [ 'kato', 'bat', 'rato', 'elefanto'] >>> Spamado [1] = 'aardvark' >>> spamon [ 'Kato', 'aardvark', 'rato', 'elefanto'] >>> Spamado [2] = spamado [1] >>> spamon [ 'Kato', 'aardvark', 'aardvark', 'elefanto'] >>> Spamado [-1] = 12345 >>> spamon [ 'Kato', 'aardvark', 'aardvark', 12345]
Lerta kunmeto kaj listo Replication
La
+ operatoro povas kombini du listoj por krei novan liston valoro en la sama maniero ĝi kombinas du kordoj en novan ĉenon valoro. La * operatoro povas ankaŭ esti uzata kun listo kaj entjera valoro repliki la listo. Eniri la sekva en la interaga konko: >>> [1, 2, 3] + [ 'A', 'B', 'C'] [1, 2, 3, 'A', 'B', 'C'] >>> [ 'X', 'Y', 'Z'] * 3 [ 'X', 'Y', 'Z', 'X', 'Y', 'Z', 'X', 'Y', 'Z'] >>> Spamado = [1, 2, 3] >>> Spamado = spamado + [ 'A', 'B', 'C'] >>> spamon [1, 2, 3, 'A', 'B', 'C']
Forigado Valoroj de Listoj kun del Deklaroj
La
del komunikaĵo forigos valorojn ĉe indekso en listo. Ĉiuj de la valoroj en la listo post la forigita valoro estos movita supren unu indekso. Ekzemple, tajpu la sekvajn en la interaga konko: >>> Spamado = [ 'kato', 'bat', 'rato', 'elefanto'] >>> Del spamado [2] >>> spamon [ 'Kato', 'bat', 'elefanto'] >>> Del spamado [2] >>> spamon [ 'Kato', 'bat']
La
del komunikaĵo povas ankaŭ esti uzita sur simpla variablo forigi ĝin, kvazaŭ ĝi estus "unassignment" komunikaĵo. Se vi provas uzi la variablo post forigo, vi ricevos NameError eraro ĉar la variablo ne plu ekzistas.
Praktike, vi preskaŭ neniam bezonas forviŝi simplaj variabloj. La
del komunikaĵo estas plejparte uzita por forigi valoroj de listoj. Laborante kun Listoj
Kiam vi unue komenci skribi programojn, ĝi estas tente krei multajn individuajn variablojn stoki grupo de similaj valoroj. Ekzemple, se mi volis gardi la nomojn de miaj katoj, Mi povus esti tentata skribi kodo kiel tiu:
catName1 = 'Zophie' catName2 = 'Pooka' catName3 = 'Simon' catName4 = 'Lady Macbeth' catName5 = 'Graso-vosto' catName6 = 'Miss Cleo'
(Mi ne vere posedi ĉi multaj katoj, mi ĵuras.) Ĝi rezultas ke tiu estas malbona maniero skribi kodon. Unue, se la nombro de katoj ŝanĝas, via programo estos neniam povos stoki pli katoj ol vi havas variabloj. Tiuj tipoj de programoj ankaŭ havas multajn duplikato aŭ preskaŭ identa kodo en ili. Konsideru kiom duplikatajn kodo estas en la sekvanta programo, kiu vi devus eniri en la dosiero redaktoro kaj konservi kiel allMyCats1.py:
presi ( 'Entajpu la nomon de kato 1') catName1 = input () presi ( 'Entajpu la nomon de kato 2') catName2 = input () presi ( 'Entajpu la nomon de kato 3') catName3 = input () presi ( 'Entajpu la nomon de kato 4:') catName4 = input () presi ( 'Entajpu la nomon de kato 5:') catName5 = input () presi ( 'Entajpu la nomon de kato 6:') catName6 = input () print ( 'La kato nomoj estas:') print (catName1 + '' + catName2 + '' + catName3 + '' + catName4 + '' + catName5 + '' + catName6)
Anstataŭ uzante multnombraj, repetitivo variabloj, vi povas uzi solan variablon kiu enhavas liston valoro. Ekzemple, ĉi tie estas nova kaj plibonigita versio de la allMyCats1.py programo.
Tiu nova versio uzas sola lerta kaj povas stoki ajna nombro da katoj
kiun la uzanto tajpas en. En nova dosiero redaktanto fenestro, tajpu la
sekvajn fontkodo kaj konservi ĝin kiel allMyCats2.py:
catNames = [] dum Vera: print ( 'Entajpu la nomon de kato' + str (len (catNames) + 1) + '(Aŭ tajpu nenion halti.):') nomi = input () se nomo == '': paŭzo catNames = catNames + [nomo] # lerta kunmeto print ( 'La kato nomoj estas:') por nomo en catNames: print ( '' + nomo)
Kiam vi kuros ĉi programo, la eligo aspektos ion kiel jene:
Entajpu la nomon de kato 1 (Aŭ eniri nenion halti.): Zophie Entajpu la nomon de kato 2 (Aŭ eniri nenion halti.): Pooka Entajpu la nomon de kato 3 (Aŭ eniri nenion halti.): simon Entajpu la nomon de kato 4 (aŭ tajpu nenion halti.): Lady Macbeth Entajpu la nomon de kato 5 (aŭ tajpu nenion halti.): Grasaj vosto Entajpu la nomon de kato 6 (aŭ tajpu nenion halti.): Miss Cleo Entajpu la nomon de kato 7 (aŭ tajpu nenion halti.): La kato nomoj estas: Zophie Pooka simon Lady Macbeth Grasaj vosto Miss Cleo
Profito de uzante listo estas ke viaj datumoj estas nun en strukturo,
do via programo estas multe pli fleksebla en procesante la datumoj de
kio estus kun pluraj ripetemaj variabloj.
Uzante por Loops kun Listoj
Leciono 14 - Por Loops kun Listoj, Multoblaj Tasko, Pliigita Tasko Telefonistoj
En ĉapitro 2 , vi lernis pri uzante
for maŝojn ekzekuti bloko de kodo certa nombro da tempoj. Teknike, for buklo ripetas la kodo bloko unufoje por ĉiu valoro en lerta aŭ lerta-simila valoro. Ekzemple, se vi kuris ĉi kodo por i en gamo (4): print (i)
la eligo de ĉi tiu programo estus kiel sekvas:
0 1 2 3
Ĉi tio devu ke la reveno valoro de
range(4) estas listo-simila valoro ke Python konsideras simila al [0, 1, 2, 3] . La jenaj programo havas la saman produktadon kiel la antaŭa: por i en [0, 1, 2, 3]: print (i)
Kion la antaŭa
for buklo fakte faras estas buklo tra lia klaŭzo kun la variablo i starigis al sinsekvaj valoro en la [0, 1, 2, 3] lerta en ĉiu ripeto. noto
En ĉi tiu libro, mi uzas la terminon listo-kiel rilati al datumtipoj kiuj teknike nomita sekvencoj. Vi ne bezonas scii la teknikajn difinojn de ĉi tiu termino, kvankam.
Komuna Python tekniko estas uzi
range(len( someList )) kun for buklo persisti super la indeksoj de listo. Ekzemple, tajpu la sekvajn en la interaga konko: >>> Provizoj = [ 'plumoj', 'Staplers', 'flamo-lanzadores', 'aglutinantes'] >>> Por i en gamo (len (provizoj)): print ( 'Indekso' + str (i) + 'en provizoj estas:' + provizoj [i]) Indekso 0 en provizoj estas: plumoj Indekso 1 en provizoj estas: Staplers Indekso 2 en provizoj estas: Flamo-lanzadores Indekso 3 en provizoj estas: ligiloj
Uzante
range(len(supplies)) en la antaŭe montrita for buklo estas oportuna ĉar la kodo en la buklo povas aliri la indekso (la variablo i ) kaj la valoro en tiu indekso (kiel supplies[i] ). Bona de ĉiuj, range(len(supplies)) estos persisti tra ĉiuj indeksoj de supplies , negrave kiom da eroj ĝi enhavas. La en kaj ne en Telefonistoj
Vi povas difini ĉu valoro estas aŭ ne estas en listo kun la
in kaj not in operatoroj. Kiel aliaj telefonistoj, in kaj not in estas uzataj en esprimoj kaj konekti du valoroj: valoro por serĉi en lerta kaj la listo kie troveblas. Tiuj esprimoj taksos al Bulea valoro. Eniri la sekva en la interaga konko: >>> 'Howdy' en [ 'saluton', 'hi', 'Howdy', 'heyas'] veraj >>> Spamado = [ 'saluton', 'hi', 'Howdy', 'heyas'] >>> 'Kato' en spamon falsa >>> 'Howdy' ne spamon falsa >>> 'Kato' ne spamon veraj
Ekzemple, la sekvanta programo permesas la uzanton tipo en dorlotbesto
nomo kaj tiam kontrolas vidi ĉu la nomo estas en lerta de maskotoj. Malfermi novan dosieron redaktanto fenestro, tajpu la sekvan kodon, kaj konservi ĝin kiel myPets.py:
myPets = [ 'Zophie', 'Pooka', 'Graso-vosto'] presi ( 'Entajpu dorlotbesto nomo:') nomi = input () se nomo ne myPets: print ( 'Mi ne havas hejmbeston nomita' + nomo) alie: print (nomo + 'estas mia dorlotbesto.')
La eligo povas rigardi ion tiel:
Entajpu dorlotbesto nomo: Footfoot Mi ne havas hejmbeston nomita Footfoot
La Multoblaj Tasko Trick
La multnombraj asigno lertaĵo estas ŝparvojo kiu permesas atribui multnombraj variabloj kun la valoroj en listo en unu linio de kodo. Do anstataŭ fari tio:
>>> Kato = [ 'graso', 'oranĝa', 'laŭta'] >>> Grandeco = kato [0] >>> Koloro = kato [1] >>> Dispozicio = kato [2]
vi povus tajpi tiun linion de kodo
>>> Kato = [ 'graso', 'oranĝa', 'laŭta'] >>> Grandeco, koloro, dispozicio = kato
La nombro de variabloj kaj la longo de la listo devas esti ĝuste egalaj, aŭ Python donos vin
ValueError : >>> Kato = [ 'graso', 'oranĝa', 'laŭta'] >>> Grandeco, koloro, dispozicio, nomo = kato Traceback (plej lasta alvoko lasta): Dosiero "<pyshell # 84>", linio 1, en <modulo> grandeco, koloro, dispozicio, nomo = kato ValueError: bezoni pli ol 3 valoroj malpakiLa multnombraj asigno lertaĵo povas ankaŭ esti uzata por interŝanĝi la valorojn en du variabloj:
>>> A b = 'Alicia', 'Bob' >>> A b = b, a >>> Print (al) 'Bob' >>> Print (b) 'Alico'
Pliigita Tasko Telefonistoj
Kiam atribuante valoron al variablo, vi ofte uzas la variablo mem. Ekzemple, post atribui
42 al la variablo spam , vi pliigus la valoron en spam fare 1 kun la sekvan kodon: >>> Spamado = 42 >>> Spamado = spamado + 1 >>> spamon 43
Kiel ŝparvojo, vi povas uzi la pliigita asigno operatoro
+= fari la saman aferon: >>> Spamado = 42 >>> Spamado + = 1 >>> spamon 43
Ekzistas pliigita atribuo operatoroj por la
+ , - , * , / kaj % operatoroj, priskribitaj en Tabelo 4-1 .
Tabelo 4-1. La Pliigita Tasko Telefonistoj
Pliigita asigno komunikaĵo
|
Ekvivalenta asigno komunikaĵo
|
|---|---|
spam += 1 | spam = spam + 1 |
spam -= 1 | spam = spam - 1 |
spam *= 1 | spam = spam * 1 |
spam /= 1 | spam = spam / 1 |
spam %= 1 | spam = spam % 1 |
La
+= operatoro povas ankaŭ fari ŝnuro kaj lerta kunmeto kaj la *= operatoro povas fari ŝnuro kaj listo replicación. Eniri la sekva en la interaga konko: >>> Spamado = 'Saluton' >>> Spamado + = 'mondo!' >>> spamon 'Saluton mondo!'
>>> Lardo = [ 'Zophie'] >>> Lardo * = 3 >>> lardo [ 'Zophie', 'Zophie', 'Zophie']
metodoj
Leciono 15 - Metodoj kaj la indekso (), append (), enŝovu (), forigi (), varo () Listo Metodoj
Metodo estas la samo kiel funkcio, se gxi estas "vokis" valoro. Ekzemple, se lerta estis deponitaj en
spam , vi devus voki la index() listo metodo (kiu mi klarigos sekva) en tiu listo kiel tia: spam.index('hello') . La metodo parto venas post la valoro, disigitaj de periodo.
Ĉiu datumtipo havas sian propran aron de metodoj. La listo datumtipo, ekzemple, havas plurajn utilajn metodojn por trovi, aldono, forigo kaj alie manipulas valorojn en listo.
Trovanta Valoro en Listo kun la indekso () Metodo
Listo valoroj havas
index() metodo kiu povas pasigis valoro, kaj se tiu valoro ekzistas en la listo, la indekso de la valoro estas redonita. Se la valoro ne estas en la listo, tiam Python produktas ValueError eraro. Eniri la sekva en la interaga konko: >>> Spamado = [ 'saluton', 'hi', 'Howdy', 'heyas'] >>> Spam.index ( 'saluton') 0 >>> Spam.index ( 'heyas') 3 >>> Spam.index ( 'Howdy Howdy Howdy') Traceback (plej lasta alvoko lasta): Dosiero "<pyshell # 31>", linio 1, en <modulo> spam.index ( 'Howdy Howdy Howdy') ValueError: 'Howdy Howdy Howdy' ne estas en lerta
Kiam estas duplikatoj de la valoro en la listo, la indekso de lia unua apero estas redonita. Eniri la sekva en la interaga ŝelo, kaj rimarki ke
index() redonas 1 , ne 3 : >>> Spamado = [ 'Zophie', 'Pooka', 'Graso-vosto', 'Pooka'] >>> Spam.index ( 'Pooka') 1
Aldonante Valoroj por Listoj kun la append () kaj enmeti () Manieroj
Aldoni novajn valorojn al listo, uzu la
append() kaj insert() metodoj. Eniri la sekva en la interaga ŝelo voki la append() metodon sur listo valoro stokita en la variablo spam : >>> Spamado = [ 'kato', 'hundo', 'bat'] >>> Spam.append ( 'alko') >>> spamon [ 'Kato', 'hundo', 'bat', 'alko']
La antaŭa
append() metodo alvoko aldonas la argumento al la fino de la listo. La insert() metodo povas enmeti valoron en ajna indekso en la listo. La unua argumento por insert() estas la indekso por la nova valoro, kaj la dua argumento estas la nova valoro por esti enmetitaj. Eniri la sekva en la interaga konko: >>> Spamado = [ 'kato', 'hundo', 'bat'] >>> Spam.insert (1, 'kokido') >>> spamon [ 'Kato', 'kokido', 'hundo', 'bat']
Rimarku ke la kodo estas
spam.append('moose') kaj spam.insert(1, 'chicken') , ne spam = spam.append('moose') kaj spam = spam.insert(1, 'chicken') . Nek append() nek insert() donas la nova valoro de spam kiel lia reveno valoro. (Fakte, la reveno valoro de append() kaj insert() estas None , do vi certe ne volas konservi tion kiel la nova variablo valoron.) Prefere, la listo estas modifita en loko. Modifi listo en loko kovras pli detale poste en mutable kaj neŝanĝeblaj Datumoj Tipoj .
Metodoj apartenas al sola datumtipo. La
append() kaj insert() metodoj estas listo metodoj kaj povas nomi nur sur listo valoroj, ne sur aliaj valoroj kiel kordoj aŭ entjeroj. Eniri la sekva en la interaga ŝelo, kaj noti la AttributeError erarmesaĝojn kiuj aperas: >>> Ovojn = 'saluton' >>> Eggs.append ( 'mondo') Traceback (plej lasta alvoko lasta): Dosiero "<pyshell # 19>", linio 1, en <modulo> eggs.append ( 'mondo') AttributeError: 'str' objekto havas atributon 'append' >>> Lardo = 42 >>> Bacon.insert (1, 'mondo') Traceback (plej lasta alvoko lasta): Dosiero "<pyshell # 22>", linio 1, en <modulo> bacon.insert (1, 'mondo') AttributeError: 'int' objekto havas atributon 'insert'
Forigado Valoroj de Listoj kun forigi ()
La
remove() metodo trapasintan la valoro por esti forigita de la listo ĝi tuŝas. Eniri la sekva en la interaga konko: >>> Spamado = [ 'kato', 'bat', 'rato', 'elefanto'] >>> Spam.remove ( 'bat') >>> spamon [ 'Kato', 'rato', 'elefanto']
Provante forigi valoron kiu ne ekzistas en la listo rezultos en
ValueError eraro. Ekzemple, tajpu la sekvajn en la interaga ŝelo kaj rimarki de la eraro kiu montras: >>> Spamado = [ 'kato', 'bat', 'rato', 'elefanto'] >>> Spam.remove ( 'kokido') Traceback (plej lasta alvoko lasta): Dosiero "<pyshell # 11>", linio 1, en <modulo> spam.remove ( 'kokido') ValueError: list.remove (x): x ne en listo
Se la valoro aperas plurfoje en la listo, nur la unua petskribo de la valoro estos forigita. Eniri la sekva en la interaga konko:
>>> Spamado = [ 'kato', 'bat', 'rato', 'kato', 'apelo', 'kato'] >>> Spam.remove ( 'kato') >>> spamon [ 'Bat', 'rato', 'kato', 'apelo', 'kato']
La
del aserto estas bona por uzi kiam vi scias la indekso de la valoro kiun vi volas forigi el la listo. La remove() metodo estas bona kiam vi scias la valoron vi volas forigi el la listo. Ordigado la Valoroj en Listo kun la varo () Metodo
Listoj de numero valoroj aŭ listoj de kordoj povas ordo kun la
sort() metodo. Ekzemple, tajpu la sekvajn en la interaga konko: >>> Spamado = [2, 5, 3.14, 1, -7] >>> Spam.sort () >>> spamon [-7, 1, 2, 3.14, 5] >>> Spamado = [ 'formikoj', 'katoj', 'hundoj', 'antilopaj,' elefantaj] >>> Spam.sort () >>> spamon [ 'Formikoj', 'antilopaj,' katoj ',' hundoj ',' elefantaj]
Vi povas ankaŭ pasas
True por la reverse ŝlosilvorto argumento havi sort() ordigi la valoroj en inversa ordo. Eniri la sekva en la interaga konko: >>> Spam.sort (inversa = Vera) >>> spamon [ 'Elefantaj' hundoj ',' katoj ',' antilopaj: formikoj ']
Estas tri aferoj vi devus rimarki la
sort() metodo. Unue, la sort() metodo ordigas la liston en loko; ne provu kapti la reveno valoro de skribi kodon kiel spam = spam.sort() .
Due, vi ne povas ordigi lertaj kiu havas ambaŭ nombro valoroj kaj ŝnuro valoroj en ili, ĉar Pitono ne scipovas kompari tiujn valorojn. Tajpi la sekva en la interaga ŝelo kaj rimarki la
TypeError eraro: >>> Spamado = [1, 3, 2, 4, "Alicio ',' Bob '] >>> Spam.sort () Traceback (plej lasta alvoko lasta): Dosiero "<pyshell # 70>", linio 1, en <modulo> spam.sort () TypeError: unorderable tipoj: str () <int ()
Tria,
sort() uzas "ASCIIbetical ordo" anstataŭ faktaj alfabeta ordo por ordigado kordoj. Tio signifas majusklajn literojn venu antaux minuskla literoj. Sekve, la minuskla a estas ordigita tiel ke ĝi venas post la majuskla Z. Por ekzemplo, eniri la sekva en la interaga konko: >>> Spamado = [ 'Alico', 'formikoj', 'Bob', 'antilopaj: Carol', 'katojn'] >>> Spam.sort () >>> spamon [ 'Alico', 'Bob', 'Carol', 'formikoj', 'antilopaj,' katojn ']
Se vi bezonas ordigi la valoroj en regula alfabeta ordo, pasi
str. lower str. lower por la key ŝlosilvorto argumento en la sort() metodo alvoko. >>> Spamado = [ 'a', 'z', 'A', 'Z'] >>> Spam.sort (ŝlosilo = str.lower) >>> spamon [ 'A', 'A', 'z', 'Z']
Tiu kaŭzas la
sort() funkcio trakti ĉiujn erojn en la listo sin minuskla sen fakte ŝanĝi la valorojn en la listo. Ekzemple Programo: Magic 8 Ball kun Listo
Uzante listojn, vi povas skribi multe pli eleganta versio de la antaŭa ĉapitro Magic 8 Ball programo. Anstataŭ pluraj linioj de preskaŭ identa
elif deklaroj, vi povas krei solan listo ke la kodo laboras kun. Malfermi novan dosieron redaktanto fenestro kaj eniri la sekvan kodon. Konservi ĝin kiel magic8Ball2.py. importado hazarda mesaĝojn = [ 'Estas certaj', 'Estas tute certe', 'Jes definitive', 'Respondu nebula reprovu', Petu pli posta ', 'Koncentri kaj demandas denove', Mia respondo estas ne ', 'Outlook ne tiel bona', 'Tre malcerta'] print (mesaĝoj [random.randint (0, len (mesaĝoj) - 1)])
Kiam vi kuros ĉi programo, vi vidos ke ĝi funkcias same kiel la antaŭa magic8Ball.py programo.
Rimarki la esprimon vi uzas la indekson en
messages : random.randint(0, len(messages) - 1) . Tio produktas hazarda nombro uzi por la indekso, nekonsiderante la grandeco de messages . Te, vi ricevos hazarda nombro inter 0 kaj la valoro de len(messages) - 1 . La profito de tiu aliro estas ke vi povas facile aldoni kaj forigi fadenojn al la messages listo sen ŝanĝi aliajn liniojn de kodo. Se vi poste ĝisdatigi vian kodon, estos malpli linioj vi devas ŝanĝi kaj pli malmultaj ŝancoj por vi enkonduki cimojn. Listo-similaj Tipoj Strings kaj opoj
Listoj ne estas la solaj datumtipoj kiuj reprezentas ordigita sekvencoj de valoroj. Ekzemple, kordoj kaj listoj estas fakte simila, se vi konsideras kordo esti "listo" de sola teksto karakteroj. Multaj de la aferoj vi povas fari kun lertaj povas ankaŭ esti farita per ŝnuretoj indeksado; slicing; kaj uzante ilin
for bukloj, kun len() , kaj kun la in kaj not in operatoroj. Vidi tiun, eniri la sekva en la interaga konko: >>> Nomo = 'Zophie' >>> Nomo [0] 'Z' >>> Nomo [-2] 'I' >>> Nomo [0: 4] 'Zoph' >>> 'Zo' en nomo veraj >>> 'Z' en nomo falsa >>> 'P' ne en nomo falsa >>> Por i en nomo: print ( '* * *' + I + '* * *') * * * Z * * * * * * O * * * * * * P * * * * * * H * * * * * * I * * * * * * E * * *
Mutable kaj neŝanĝeblaj Datumoj Tipoj
Sed lertaj kaj kordoj estas malsamaj en grava vojo. Liston valoro estas mutables datumtipo: Ĝi povas havi valorojn aldonitaj, forigitaj, aŭ ŝanĝita. Tamen, ŝnuro estas neŝanĝeblaj: Ĝi ne povas esti ŝanĝita. Provas religi sola karaktero en ĉeno rezultoj en
TypeError eraro, kiel vi povas vidi de eniranta la sekva en la interaga konko: >>> Nomo = 'Zophie kato' >>> Nomo [7] = 'La' Traceback (plej lasta alvoko lasta): Dosiero "<pyshell # 50>", linio 1, en <modulo> nomi [7] = 'La' TypeError: 'str' objekto ne subtenas elemento asigno
La ĝusta maniero "mutacii" kordo estas uzi slicing kaj kunmeto konstrui novan ĉenon kopiante el partoj de la malnova linio. Eniri la sekva en la interaga konko:
>>> Nomo = 'Zophie kato' >>> NewName = nomo [0: 7] + 'la' + nomo [8:12] >>> nomo 'Zophie kato' >>> newName 'Zophie la kato'
Ni uzis
[0:7] kaj [8:12] por rilati al la karakteroj kiujn ni ne volas anstataŭi. Rimarku ke la originala 'Zophie a cat' ĉeno ne modifita ĉar kordoj estas neŝanĝeblaj.
Kvankam listo valoro estas mutables, la dua linio en la sekvantan kodon ne modifas la listo
eggs : >>> Ovojn = [1, 2, 3] >>> Ovojn = [4, 5, 6] >>> ovojn [4, 5, 6]
La listo valoro en
eggs ne sxangxigxas tie; prefere, tute nova kaj malsama listo valoro ( [4, 5, 6] ) estas superskribi la malnova listo valoro ( [1, 2, 3] ). Tio estas prezentita en Figuro 4-2 .
Se vi volas reale modifi la lerta originala en
eggs enhavi [4, 5, 6] , vi devus fari ion kiel jene: >>> Ovojn = [1, 2, 3] >>> Del ovojn [2] >>> Del ovojn [1] >>> Del ovojn [0] >>> Eggs.append (4) >>> Eggs.append (5) >>> Eggs.append (6) >>> ovojn [4, 5, 6]
![KIAM ovojn = [4, 5, 6] is ekzekutita, la enhavo de ovoj is anstataŭigita per nova Lerta valoro.](https://automatetheboringstuff.com/images/000076.jpg)
Figuro 4-2. Kiam
eggs = [4, 5, 6] estas ekzekutita, la enhavo de eggs estas anstataŭitaj per nova listo valoro.
En la unua ekzemplo, la listo valoro kiu
eggs finas kun estas la sama listo valoro komencita kun. Estas nur ke tiu lerta estis ŝanĝita, anstataŭ anstataŭigataj. Figuro 4-3 reprezentas la sep ŝanĝojn faritaj de la unuaj sep linioj en la antaŭa interaga ŝelon ekzemplo. 
Figuro 4-3. La
del komunikaĵo kaj la append() metodo modifi la sama listo valoro en loko.
Ŝanĝi valoron de mutable datumtipo (kiel kio la
del komunikaĵo kaj append() metodon fari en la antaŭa ekzemplo) ŝanĝas la valoron en loko, ĉar la variablo valoron ne anstataŭigita kun nova listo valoro.
Mutable kontre neŝanĝeblaj tipoj povas simili sensenca distingo, sed Pasante Referencoj klarigos la malsamaj konduto nominte funkcioj kun mutables argumentojn kontre neŝanĝeblaj argumentoj. Sed unue, ni sciiĝis pri la opo datumtipo, kiu estas neŝanĝeblaj formo de la listo datumtipo.
La opo Datumoj Tipo
La opo datumtipo estas preskaŭ identa al la listo datumtipo, krom en du manieroj. Unua, opoj estas tajpita kun parentezoj,
( kaj ) , anstataŭ rektaj krampoj, [ kaj ] . Ekzemple, tajpu la sekvajn en la interaga konko: >>> Ovojn = ( 'saluton', 42, 0.5) >>> Ovojn [0] 'Saluton' >>> Ovojn [1: 3] (42, 0.5) >>> Len (ovojn) 3
Sed la ĉefa vojo opoj estas malsamaj listoj estas ke opoj, kiel kordoj, estas neŝanĝeblaj. Opoj ne havas siajn valorojn modifita, almuntita, aŭ forigita. Eniri la sekva en la interaga ŝelo, kaj rigardu la
TypeError erarmesaĝon: >>> Ovojn = ( 'saluton', 42, 0.5) >>> Ovojn [1] = 99 Traceback (plej lasta alvoko lasta): Dosiero "<pyshell # 5>", linio 1, en <modulo> ovojn [1] = 99 TypeError: 'opo' objekto ne subtenas elemento asigno
Se vi havas nur unu valoron en via opo, vi povas indiki tion metante fina komo post la valoro ene la krampoj. Alie, Pitono pensos vi ĵus tajpita valoro ene regula krampoj. La komo estas kion permesas Python scias ĉi estas opo valoro. (Kontraste iuj aliaj programlingvoj, en Python estas bone havi trenante komo post la lasta ero en listo aŭ opo.) Enmetu jena
type() funkcio vokas en la interaga ŝelo vidi la distingon: >>> Tipo (( 'saluton')) <Klaso opo '> >>> Tipo (( 'saluton')) <Klaso str '>
Vi povas uzi opoj transdoni al iu leganta vian kodon ke vi ne intencas por tiu sekvenco de valoroj ŝanĝi. Se vi bezonas ordigita sekvenco de valoroj kiuj neniam ŝanĝas, uzi opo.
Dua avantaĝo de uzi opoj anstataŭ listoj estas ke, ĉar ili estas
neŝanĝeblaj kaj ilia enhavo ne ŝanĝiĝas, Pitono povas apliki iuj
optimumigaĵoj kiuj faras kodon uzante opoj iomete pli rapida ol kodon
uzante listojn.
Konvertado Tipoj kun la listo () kaj opo () Funkcioj
Samkiel kiom
str(42) revenos '42' , la kordo reprezento de la entjero 42 , la funkcioj list() kaj tuple() revenos lerta kaj opo versioj de la valoroj pasis al ili. Eniri la sekva en la interaga ŝelo, kaj rimarkis ke la reveno valoro estas de malsama datumtipo ol la valoro pasis: >>> Opo ([ 'kato', 'hundo', 5]) ( 'Kato', 'hundo', 5) >>> Liston (( 'kato', 'hundo', 5)) [ 'Kato', 'hundo', 5] >>> Listo ( 'saluton') [ 'H', 'e', 'l', 'l', 'o']
Konvertado opo al listo estas oportuna se vi bezonas mutables versio de opo valoro.
Referencoj
Kiel vi vidis, variabloj stoki kordoj kaj entjeraj valoroj. Eniri la sekva en la interaga konko:
>>> Spamado = 42 >>> Fromaĝo = spamado >>> Spamado = 100 >>> spamon 100 >>> fromaĝo 42
Vi atribuas
42 al la spam variablo, kaj tiam vi kopiu la valoron en spam kaj atribui ĝin al la variablo cheese . Kiam vi poste ŝanĝi la valoron en spam al 100 , tio ne influas la valoron en cheese . Tiu estas ĉar spam kaj cheese estas malsamaj variabloj kiuj stokas malsamajn valorojn.
Sed listoj ne funkcias tiamaniere.Kiam vi atribuas listo al variablo, vi estas efektive atribuante listo referenco al la variablo. Referenco estas valoro kiu notas al iu pecon da datumoj, kaj listo referenco estas valoro kiu notas al listo. Tie estas iom da kodo kiu faros tiun distingon facila kompreni. Eniri ĉi en la interaga konko:
❶ >>> spamado = [0, 1, 2, 3, 4, 5] ❷ >>> fromaĝo = spamado ❸ >>> fromaĝo [1] = 'Saluton!' >>> Spamon [0, 'Saluton!', 2, 3, 4, 5] >>> Fromaĝo [0, 'Saluton!', 2, 3, 4, 5]
Tio povus aspekti strange al vi. La kodo ŝanĝis nur la
cheeselisto, sed similu ke ambaŭ la cheesekaj spamlistoj ŝanĝis.
Kiam vi kreas la liston ❶, vi atribuas referenco al ĝi en la
spamvariablo. Sed la sekva linio ❷ kopioj nur la listo referenco en spamal cheese, ne la listo valoro mem. Tio signifas la valoroj stokitaj en spamkaj cheesenun ambaŭ rilatas al la sama listo. Ekzistas nur unu suba listo ĉar la listo mem neniam fakte kopiitaj. Do kiam vi modifas la unua elemento de cheese❸, vi modifas la sama lerta kiu spamreferencas.
Memoru ke variabloj estas kiel skatoloj kiuj enhavas valorojn. La
antaŭaj figuroj en tiu ĉapitro montras ke listigas en skatoloj ne estas
ĝuste preciza, ĉar listo variabloj ne reale enhavi listojn-ili enhavas referencojn al listoj. (Tiuj referencoj devos ID nombroj ke Pitono uzas interne, sed vi povas ignori ilin.) Uzante skatoloj kiel metaforo variabloj, Figuro 4-4 montras kio okazas kiam listo estas asignita al la
spamvariablo.![spamado = [0, 1, 2, 3, 4, 5] stokas referenco al listo, ne la fakta listo.](https://automatetheboringstuff.com/images/000081.jpg)
Figuro 4-4.
spam = [0, 1, 2, 3, 4, 5]Stokas referenco al listo, ne la fakta listo.
Tiam, en Figuro 4-5 , la referenco en
spamkopias al cheese. Nur nova referenco estis kreitaj kaj stokitaj en cheese, ne nova listo. Notu kiel ambaŭ referencoj rilatas al la sama listo.
Figuro 4-5.
spam = cheeseKopias la referencon, ne la liston.
Kiam vi ŝanĝos la lerta kiu
cheeserilatas al la lerta kiu spamrilatas al ankaŭ ŝanĝis, ĉar ambaŭ cheesekaj spamrilatas al la sama listo. Vi povas vidi tion en Figuro 4-6 .![fromaĝo [1] = 'Saluton!' modifas la listo ke ambaŭ variabloj rilati al.](https://automatetheboringstuff.com/images/000071.jpg)
Figuro 4-6.
cheese[1] = 'Hello!'Modifas la listo ke ambaŭ variabloj rilati al.
Variabloj enhavos referencojn al listo valoroj prefere ol listo valoroj mem. Sed por kordoj kaj entjeraj valoroj, variabloj simple enhavas la kordo aŭ entjero valoro. Python uzas referencojn kiam variabloj devas stoki valorojn de mutable datumtipoj, kiaj listoj aux vortaroj. Por valoroj de neŝanĝeblaj datumtipoj kiel kordoj, entjeroj, aŭ opoj, Pitono variabloj stokos la valoro mem.
Kvankam Python variabloj teknike enhavas referencojn al listo aŭ
vortaro valoroj, homoj ofte indiferente diri ke la variablo enhavas la
liston aŭ vortaro.
pasante Referencoj
Referencoj estas aparte grava por kompreni kiel argumentoj get pasis al funkcioj. Kiam funkcio estas nomita, la valoroj de la argumentoj estas kopiitaj al la parametro variabloj. Por
listoj (kaj vortaroj, kiujn mi priskribas en la sekva ĉapitro), tio
signifas kopion de la referenco estas uzata por la parametro. Vidi la konsekvencojn de tio, malfermi novan dosieron redaktanto fenestro, tajpu la sekvan kodon, kaj konservi ĝin kiel passingReference.py :
def ovojn (someParameter):
someParameter.append ( 'Saluton')
spamado = [1, 2, 3]
ovoj (spamon)
print (spamado)
Rimarku ke kiam
eggs()oni nomas, reveno valoro estas uzata por atribui novan valoron al spam. Anstataŭe, ĝi modifas la listo en loko, rekte. Kiam kuras, ĉi programo produktas la sekvan produktadon:[1, 2, 3, "Saluton"]
Kvankam
spamkaj someParameterenhavas apartajn referencojn, ambaŭ signifas la sama listo. Pro tio la append('Hello')metodo alvoko ene la funkcio tuŝas la listo eĉ post la funkcio alvoko revenis.
Daŭru konduto en menso: Forgesante ke Python manipulas listo kaj vortaro variabloj tiel povas konduki al konfuza cimoj.
Kopio Modulodosierujo kopion () kaj deepcopy () Funkcioj
Kvankam
pasante ĉirkaŭ referencoj ofte handiest maniero trakti listojn kaj
vortarojn, se la funkcio modifas la listo aŭ vortaro trapasintan, vi
eble ne volas tiujn ŝanĝojn en la lerta originala aŭ vortaro valoro. Cxar tiu, Python provizas modulo nomita
copykiu provizas ambaŭ la copy()kaj deepcopy()funkcioj. La unua el tiuj, copy.copy(), povas esti uzata por fari duplikatajn kopio de mutable valoron kiel liston aŭ vortaro, ne nur kopion de referenco. Eniri la sekva en la interaga konko: >>> Import kopion >>> spamado = [ 'A', 'B', 'C', 'D'] >>> fromaĝo = copy.copy (spamado) >>> fromaĝo [1] = 42 >>> spamo [ 'A', 'B', 'C', 'D'] >>> Fromaĝo [ 'A', 42 'C', 'D']
Nun
spamkaj cheesevariabloj rilatas al apartaj listoj, tial nur la listo en cheesemodifita kiam vi atribuas 42indekso 1. Kiel vi povas vidi en Figuro 4-7 , la referenco ID nombroj estas ne la sama por ambaŭ variabloj ĉar la variabloj rilatas al sendependaj listoj.
Figuro 4-7.
cheese = copy.copy(spam)Kreas dua lerta kiu eblas modifita sendepende de la unua.
Se la listo vi devas kopii enhavas listojn, tiam uzi la
copy.deepcopy()funkcion anstataŭ copy.copy(). La deepcopy()funkcio kopios tiuj internaj listoj tiel.resumo
Listoj
estas utilaj datumtipoj ĉar ili permesas vin skribi kodon kiu funkcias
sur modificable nombro de valoroj en sola variablo. Poste en ĉi tiu libro, vi vidos programojn uzante listojn fari aĵojn kiuj estus malfacila aŭ neebla malhavi ilin.
Listoj estas mutables, signifante ke iliaj enhavoj povas ŝanĝi. Opoj kaj ĉenoj, kvankam lerta-similaj en iuj aspektoj, estas neŝanĝeblaj kaj ne povas esti ŝanĝita. Variablo
kiu enhavas opo aŭ kordoj valoro povas anstataŭigi per nova opo aŭ
ŝnuro valoron, sed tiu ne estas la sama aĵo kiel modifi la ekzistantan
valoron en loko-kiel, ekzemple, la
append()aŭ remove()metodojn fari en listoj.
Variabloj ne stokas liston valoroj rekte; stokas referencojn al listoj. Tio estas grava distingo kopiinte variabloj aŭ pasanta listoj kiel argumentoj en funkcio alvokoj. Ĉar
la valoro kiu estas kopiitaj la listo referenco, konscii ke ĉiuj ŝanĝoj
vi faras al la listo povus efiki alia variablo en via programo. Vi povas uzi
copy()aŭ deepcopy()se vi volas fari ŝanĝojn al listo en unu variablo sen modifi la originalan listo.praktiko Demandoj
Q:
|
1. Kio estas
[]? |
Q:
|
2. Kiel vi atribuas la valoron
'hello'kiel la tria valoro en listo stokitaj en variablo nomata spam? (Alpreni spamenhavas [2, 4, 6, 8, 10].)
Por la sekvaj tri demandoj, ni diru
spamenhavas la liston ['a', 'b', 'c', 'd']. |
Q:
|
3. Kion
spam[int(int('3' * 2) // 11)]taksi al? |
Q:
|
4. Kion
spam[-1]taksi al? |
Q:
|
5. Kion
spam[:2]taksi al?
Por la sekvaj tri demandoj, ni diru
baconenhavas la liston [3.14, 'cat', 11, 'cat', True]. |
Q:
|
6. Kion
bacon.index('cat')taksi al? |
Q:
|
7. Kion
bacon.append(99)faras la liston valoro en baconaspektas? |
Q:
|
8. Kion
bacon.remove('cat')faras la liston valoro en baconaspektas? |
Q:
|
9. Kio estas la telefonistoj por lerta kunmeto kaj listo replicación?
|
Q:
|
10. Kio estas la diferenco inter la
append()kaj insert()listo metodoj? |
Q:
|
11. Kio estas du manieroj por forigi valorojn el listo?
|
Q:
|
12. Nomo kelkaj manieroj kiujn listo valoroj estas similaj al ŝnuro valoroj.
|
Q:
|
13. Kio estas la diferenco inter lertaj kaj opoj?
|
Q:
|
14. Kiel vi tajpi la opo valoro kiu havas nur la entjeran valoron
42en ĝi? |
Q:
|
15. Kiel vi povas akiri la opo formo de listo valoron? Kiel povas vin akiras la lerta formo de opo valoron?
|
Q:
|
16. Variabloj ke "enhavi" elenco valoroj ne vere enhavas listojn rekte. Kion ili enhavas anstataŭe?
|
Q:
|
17. Kio estas la diferenco inter
copy.copy()kaj copy.deepcopy()? |
praktiko Projektoj
Por praktiko, skribi programojn por fari la sekvajn taskojn.
komo Kodo
Diru vi havas liston valoro tiel:
spamado = [ 'pomojn', 'bananoj', 'sojkazeo', 'katojn']
Skribi funkcio kiu prenas liston valoro kiel argumento kaj redonas ĉenon kun ĉiuj aĵoj apartigita per komo kaj spaco, kun kaj enigita antaŭ la lasta ero. Ekzemple, pasante la antaŭa
spamlerta por la funkcio revenus 'apples, bananas, tofu, and cats'. Sed via funkcio devus povi labori kun ajna listo valoro pasis al ĝi.Karaktero Bildo Grid
Diru vi havas liston de listoj kie ĉiu valoro en la internan listoj estas unu-karaktero ŝnuro, tiel:
krado = [[ '.', '.', '.', '.', '.', '.'],
[ '.', 'Ho', 'ho', '.', '.', '.'],
[ 'O', 'ho', 'ho', 'ho', '.', '.'],
[ 'O', 'ho', 'ho', 'ho', 'ho', '.'],
[ '.', 'Ho', 'ho', 'ho', 'ho', 'ho'],
[ 'O', 'ho', 'ho', 'ho', 'ho', '.'],
[ 'O', 'ho', 'ho', 'ho', '.', '.'],
[ '.', 'Ho', 'ho', '.', '.', '.'],
[ '.', '.', '.', '.', '.', '.']]
Vi povas pensi pri
grid[x][y]kiel esti la karaktero en la x- kaj y-koordinatoj de "bildo" tirita kun teksto karakteroj. La (0, 0)origino estos en la supra-maldekstra angulo, la x-koordinatoj pliigi iras dekstren, kaj la y-koordinatoj pliigi subiron.
Kopii la antaŭa krado valoro kaj skribi kodon kiu uzas ĝin por presi la bildon.
..OO.OO .. .OOOOOOO. .OOOOOOO. ..OOOOO .. ... OOO ... .... Ho ....
Konsileto: Vi devas uzi ciklo en buklo por presi
grid[0][0], do grid[1][0], tiam grid[2][0], kaj tiel plu, ĝis grid[8][0]. Tiu finos la unua vico, do tiam presi novan linion. Tiam via programo devus presi grid[0][1], tiam grid[1][1], tiam grid[2][1], kaj tiel plu. La lasta afero via programo presos estas grid[8][5].
Ankaŭ, memoru pasi la
endŝlosilvorto argumento print()se vi ne volas novan linion presita aŭtomate post ĉiu print()alvoko. 
Nenhum comentário:
Postar um comentário