Páginas

domingo, 3 de março de 2013

skribu-kun-python-cxap04

fonto: http://inventwithpython.com/chapter4.html

Temoj Kovritaj en tiu ĉapitro:

  • import-deklaroj
  • Moduloj
  • Argumentoj
  • while-deklaro
  • Kondiĉoj
  • Blokoj
  • Booleans
  • Komparaj operatoroj
  • La diferenco inter = kaj ==.
  • if-deklaroj
  • La rompo ŝlosilvorto.
  • La str() kaj int() funkcioj.
  • La random.randint() funkcio.

La "Divenu la Numeron" Ludo

Ni iras al fari "Divenu la Numeron" ludo. En tiu ludo, la komputilo pensos de hazarda nombro de 1 al 20, kaj demandos vin por diveni la numeron. Vi nur ricevos ses divenas, sed la komputilo diros al vi se via konjekto estas tro alta aŭ tro malalta. Se vi diveni la nombro ene de ses provoj, vi gajnos.
Ĉi tiu estas bona ludo por vi komenci kun ĉar ĝi uzas hazardaj nombroj, bukloj, kaj eniro de la uzanto en sufiĉe mallonga programo. Kiel vi skribas ĉi tiu ludo, vi lernos kiel konverti valoroj al malsamaj datumtipoj (kaj kial vi bezonus fari tion).
Ĉar tiu programo estas ludo, ni vokos al la uzanto la ludanto, sed la vorto "uzanto" estus korekta ankaŭ.

Specimeno de "Divenu la Numero"

Jen kio nia ludo aspektos al la ludanto kiam la programo kuras. La teksto kiu la ludanto tipoj en estas en grasaj.
Saluton! Kio estas via nomo?
Albert
Nu, Albert, Mi pensas de nombro inter 1 kaj 20.
Prenu diveni.
10
Via konjekto estas tro alta.
Prenu diveni.
2
Via konjekto estas tro malalta.
Prenu diveni.
4
Bonan laboron, Albert! Vi divenis mian numeron en 3 divenas!
Eniri tiun kodo precize kiel ĝi aperas ĉi tie, kaj poste konservu ĝin per klako sur la menuo Dosiero kaj poste Konservu kiel. Donu ĝin al dosiernomo kiel guess.py poste ekzekuti ĝin premante la F5 ŝlosilo. Ne maltrankviliĝu, se vi ne komprenas la kodo nun, mi klarigos ĝin paŝon post paŝo.

Divenu la Nombro de Fonta Kodo

Jen la fontkodon por nia Guess la Numero ludo. Kiam vi eniros ĉi kodo en la dosiero redaktoro, esti certa atenti la interspaco en la antauxa parto de iuj de la linioj. Iuj linioj havas kvar aŭ ok spacoj antaŭ ili. Post kiam vi tajpis en la kodo, savu la dosieron kiel guess.py. Vi povas uzi la programon de la dosiero redaktanto premante F5. Se vi vidas eraron mesaĝon, kontrolu ke vi tajpis la programo en precize kiel skribita.
Se vi ne volas tajpi tiun tutan kodon, vi povas elŝuti ĝin el tiu libro de afiŝinto ĉe la URL http://inventwithpython.com/chapter4 .
Grava Noto! Nepre kuri ĉi programo kun Python 3, kaj ne Python 2. La programoj en tiu libro uzi Python 3, kaj vi ricevos erarojn se vi provas kuri ilin per Python 2. Vi povas alklaki Helpo kaj poste Pri vana por eltrovi kio versio de Python vi havas.
guess.py
Tiu kodo estas elŝutebla el http://inventwithpython.com/guess.py
Se vi ricevas erarojn post tajpi tiun kodon en, kompari ĝin al la libro kodo kun la linio malsamoj ilo en http://inventwithpython.com/diff aŭ retpoŝtu la aŭtoro en al@inventwithpython.com
  1. # Tiu ĉi estas guess la nombro ludo.
  2. importi hazarda

  4. guessesTaken = 0

  6. print ('Saluton! Kio estas via nomo?')
  7. myName = input ()

  9. nombro = random.randint (1, 20)
  10. print ('Nu,' + myName + ', mi pensas de nombro inter 1 kaj 20.)

  12. dum guessesTaken <6:
  13. print ('Prenu diveni.') # Estas kvar spacoj antaŭ impreso.
  14. diveni = input ()
  15. diveni = int (diveni)

  17. guessesTaken = guessesTaken + 1

  19. se diveni <nombro:
  20. print ('Via konjekto estas tro malalta.') # Estas ok spacoj antaŭ impreso.

  22. se diveni> nombro:
  23. presi ('Via konjekto estas tro alta.)

  25. se diveni == nombro:
  26. rompi

  28. se diveni == nombro:
  29. guessesTaken = str (guessesTaken)
  30. print ('Bona laboro,' + myName + '! Vi divenis mian numeron en' + guessesTaken + 'divenas!')

  32. se guess! = nombro:
  33. nombro = str (nombro)
  34. print ('Nope. La nombro mi pensis pri estis' + nombro)
Kvankam ni eniras nia fontkodo en nova dosiero redaktanto fenestro, ni povas reiri al la konko eniri individuaj instrukcioj por vidi kion ili faras. La interaktiva konko estas tre bona por sperti kun malsamaj instrukcioj kiam ni ne kurante programon. Vi povas reveni al la interaga konko klakante sur lia fenestro aŭ sur ĝia taskostrio butonon. En Windows aŭ Mac OS X, la taskostrio aŭ doko estas sur la fundo de la ekrano. En Linukso la taskostrio povas esti lokita kune la supro de la ekrano.
Se la programo ŝajnas ne funkcii post vi tajpis ĝin, kontrolu por vidi se vi tajpis la kodo precize kiel ĝi aperas en tiu libro. Vi ankaŭ povas kopii kaj almeti vian kodon por la linio "dif" ilo en http://inventwithpython.com/diff . La malsamoj ilo montros al vi kiel via kodo estas malsama de la fontokodo en tiu libro. En la arkivo redaktanto, premu CTRL-A al "Elektu ĉion" la teksto vi havas tajpitaj, tiam premu Ctrl-C por kopii la tekston al la tondujo. Tiam, alglui ĉi tiun tekston klakante en la dif ilo de teksto kampo sur la retejo kaj alklaku la "Komparu" butonon. La retejo montros al vi ajnan diferencoj inter via kodo kaj la kodo en tiu libro.
Estas malsamoj ilo por ĉiu programo en cxi tiu libro en la http://inventwithpython.com retejo. Video tutorial de kiel uzi la malsamoj ilo estas disponeblaj de ĉi tiu libro de afiŝinto ĉe http://inventwithpython.com/videos/ .

La importado Statement

Ni rigardu ĉiun linion de kodo en turni por vidi kiel la programo funkcias.
  1. # Tiu ĉi estas guess la nombro ludo.
Tiu linio estas komento. Komentoj enkondukis en nian Saluton Mondo programo en Ĉapitro 3. Memoru ke Python ignoros ĉio post la # signon. Ĉi ĝuste memoras ni kion tiu programo faras.
  1. importi hazarda
Ĉi tiu estas importado komunikaĵo. Deklaroj ne funkcioj (avizon ke nek importado nek hazarda havas krampoj post lia nomo). Memoru, deklaroj estas instrukcioj kiujn realigi iun agon sed ne taksi al valoro. Vi jam vidis deklaroj: asigno deklaroj stoki valoro al variablo (sed la aserto ne taksas al nenio).
Dum Python inkludas multajn enkonstruita en funkcioj, iuj funkcioj ekzisti en apartaj programoj nomata moduloj. Moduloj estas Python programoj kiuj enhavas pliajn funkciojn. Ni uzas la funkciojn de tiuj moduloj, metante ilin en niajn programojn kun la importado komunikaĵo. En ĉi tiu kazo, ni importi la modulo hazardo.
La importado aserto estas formita de la importado ŝlosilvorto sekvita de la modulo nomo. Kune, la ŝlosilvorto kaj modulo nomo konsistigas la komunikaĵo. Linio 2 tiam estas importado aserto ke importas la modulo nomata hazarda kiu enhavas plurajn funkciojn rilate al hazardaj nombroj. (Ni uzos unu el tiuj funkcioj por poste havi la komputilon supreniru kun hazarda nombro por ni por diveni.)
  1. guessesTaken = 0
Ĉi tiu linio kreas novan variablon nomata guessesTaken. Ni stokas la nombro de divenas la ludanto faras en ĉi tiu variablo. Ekde la ludanto ne faris ajnan divenas ĝis nun, ni stoki la entjero 0 tie.
  1. print ('Saluton! Kio estas via nomo?')
  2. myName = input ()
Linioj 6 kaj 7 estas la sama kiel la linioj en la Saluton Mondo programo kiun ni vidis en Ĉapitro 3. Programistoj ofte reuzas kodo de iliaj aliaj programoj kiam ili bezonas la programon por fari ion ke ili jam kodita antaŭe.
Linio 6 estas funkcio alvokon al la impreso () funkcio. Memoru ke funkcio estas kiel mini-programo kiu nia programo kuras, kaj kiam nia programo nomas funkcio kuras ĉi mini-programo. La kodo interne de la impreso () funkcio vidigas la kordo vi pasis ene de la krampoj en la ekrano.
Kiam ĉi tiuj du linioj fini ekzekuti, la ĉeno kiu estas la ludanto nomo estos garditaj en la myName variablo. (Memoru, la kordo eble ne vere esti la ludanto nomo. Estas nur ajn ŝnuro la ludanto tajpis in Komputiloj estas muta kaj nur sekvi siajn programojn ajn.)

La random.randint () Funkcio

  1. nombro = random.randint (1, 20)
En Linio 9 ni nomas nova funkcio nomata randint (), kaj poste konservi la reveno valoron en variablo nomata nombro. Memoru ke funkcio alvokoj estas esprimoj ĉar ili taksos al valoro. Ni nomas tiun valoron la funkcio alvoko la reveno valoro.
Ĉar la randint () funkcio estas provizita per la hazarda modulo, ni antaŭas ĝin per hazardo. (Ne forgesu la periodo!) Diri nia programo kiu la funkcio randint () estas en la hazarda modulo.
La randint () funkcio estos redoni hazarda entjero inter (kaj inkluzive de) la du entjeroj ni donas. Tie, ni donu al ĝi la entjeroj 1 kaj 20 inter la krampoj kiuj sekvas la funkcion nomo (apartigita per komo). La hazarda entjero kiu randint () redonas stokas en variablo nomata nombro; tio estas la sekreto nombro la ludanto provas diveni.
Nur dum momento, reiru al la interaga ŝelon kaj eniri importado hazarda por importi la hazarda modulo. Tiam eniras random.randint (1, 20) por vidi kion la funkcio alvoko taksas al. Ĝi devus reveni entjero inter 1 kaj 20. Nun eniros la saman kodon denove kaj la funkcio alvoko verŝajne revenos malsama entjero. Ĉi tiu estas ĉar ĉiufoje kiam la randint () funkcio estas nomita, denove iu hazarda nombro, same kiel kiam vi ruliĝi ĵetkuboj vi ricevos hazarda nombro ĉiufoje.
>>> Importado hazarda
>>> Random.randint (1, 20)
12
>>> Random.randint (1, 20)
18
>>> Random.randint (1, 20)
3
>>> Random.randint (1, 20)
18
>>> Random.randint (1, 20)
7
>>>
Kiam ajn ni volas aldoni hazardo al niaj ludoj, ni povas uzi la randint () funkcio. Kaj ni uzas hazardo en plej ludoj. (Pensu pri kiom da tabulludoj uzas ĵetkuboj.)
Vi ankaŭ povas provi malsamaj gamoj de nombroj per ŝanĝanta la argumentojn. Ekzemple, tajpu random.randint (1, 4) al ricevi entjeroj inter 1 kaj 4 (inkluzivanta ambaŭ 1 kaj 4). Aŭ provi random.randint (1000, 2000) por atingi entjeroj inter 1000 kaj 2000. Sube estas ekzemplo de nomante la random.randint () funkcio kaj vidante kion taksas revenas. La rezultoj vi havos kiam vi nomas la random.randint () funkcio estos probable diferenci (estas hazarda, post ĉiuj).
>>> Random.randint (1, 4)
3
>>> Random.randint (1, 4)
4
>>> Random.randint (1000, 2000)
1294
>>> Random.randint (1000, 2000)
1585
>>>
Ni povas ŝanĝi la ludo kodo iomete por fari la ludon kondutas malsame. Provu ŝanĝi la linio 9 kaj 10 de tiu:
  1. nombro = random.randint (1, 20)
  2. print ('Nu,' + nomo + ', mi pensas de nombro inter 1 kaj 20.)
en ĉi tiuj linioj:
  1. nombro = random.randint (1, 100)
  2. print ('Nu,' + nomo + ', mi pensas de nombro inter 1 kaj 100.')
Kaj nun la komputilo pensos de entjero inter 1 kaj 100. Ŝanĝi la linio 9 ŝanĝos la gamo de la hazarda nombro, sed memoru ŝanĝi linio 10 por ke la ludo ankaŭ rakontas la ludanto la nova gamo anstataŭ la malnova.

Nomante Funkcioj, kiuj estas Ene Moduloj

Parenteze, estu certa eniri random.randint (1, 20) kaj ne nur randint (1, 20), aŭ la komputilo ne scias rigardi en la hazarda modulo por la randint () funkcio kaj vi ricevos la eraro ĉi tiel:
>>> Randint (1, 20)
Traceback (plej lasta alvoko lasta):
Dosieron "<stdin>", linio 1, en <module>
NameError: nomo 'randint' ne estas difinita
>>>
Memoru, via programo bezonas kuri importado hazarda antaŭ ol ĝi povas alvoki random.randint () funkcio. Jen kial importado deklaroj kutimas iri al la komenco de la programo.

Pasante Argumentoj por Funkcioj

La entjero valoroj inter la krampoj en la random.randint (1, 20) funkcio estas nomita argumentoj. Argumentoj estas la valoroj kiuj estas pasitaj al funkcio kiam la funkcio estas nomita. Argumentoj diru la funkcio kiel konduti. Ĝuste kiel la ludanto enigo ŝanĝojn kiel nia programo kondutas, argumentoj estas enigoj por funkcioj.
Kelkaj funkcioj postulas ke ilin pasas taksas kiam vi nomas ilin. Ekzemple, rigardu tiujn funkcio alvokoj:
enigo ()
print ('Saluton')
random.randint (1, 20)
La eniro () funkcio havas neniun argumenton sed la impreso () funkcion alvoko havas unu kaj la randint () funkcion alvoko havas du. Kiam ni havas pli ol unu argumento, ni apartigi ĉiu kun komoj, kiel vi povas vidi en ĉi tiu ekzemplo. Programistoj diri ke la argumentoj estas limigitaj (tio estas, aparta) per komoj. Jen kiel la komputilo scias kie valoro finiĝas kaj alia komencas.
Se vi pasos tro multaj aŭ tro malmultajn argumentoj en funkcio alvoko, Python montros erarmesagxon, kiel vi povas vidi sube. En ĉi tiu ekzemplo, ni unue nomis randint () kun nur unu argumento (tro malmultaj), kaj poste ni nomas randint () kun tri argumentojn (tro multaj).
>>> Random.randint (1)
Traceback (plej lasta alvoko lasta):
Dosieron "<pyshell#1>", linio 1, en <module>
random.randint (1)
TypeError: randint () prenas ĝuste 3 pozicia argumentoj (2 donita)
>>> Random.randint (1, 2, 3)
Traceback (plej lasta alvoko lasta):
Dosieron "<pyshell#2>", linio 1, en <module>
random.randint (1, 2, 3)
TypeError: randint () prenas ĝuste 3 pozicia argumentoj (4 donita)
>>>
Rimarku ke la eraro mesaĝo diras ni trapasis 2 kaj 4 argumentojn anstataŭ 1 kaj 3. Ĉi tiu estas ĉar Pitono ĉiam pasas ekstra, nevidebla argumento. Tiu argumento estas preter la atingo de ĉi tiu libro, kaj vi ne devas zorgi pri tio.

Bonvenigante la Ludanto

Linioj 10 kaj 12 salutas la ludanto kaj rakontas al ili pri la ludo, kaj tiam komenciĝas lasanta la ludanto diveni la sekreton nombro. Linio 10 estas sufiĉe simpla, sed la linio 12 enkondukas utila koncepto nomita ciklo.
  1. print ('Nu,' + myName + ', mi pensas de nombro inter 1 kaj 20.)
En Linio 10 la impreso () funkcio bonvenigas la ludanto por nomo, kaj diras al ili, ke la komputilo pensante de hazarda nombro.
Sed atendu - ne mi diras, ke la impreso () funkcio prenas nur unu ĉeno? Ĝi eble aspektas kiel ekzistas pli ol unu kordo tie. Sed rigardu la linio atente. La plusoj concatenate la tri kordoj taksi malsupren al unu linio, kaj tiu estas la ŝnuro la impreso () funkcio impresoj. Eble rigardu kiel la komoj estas disigi la kordojn, sed se vi rigardas atente oni vidas ke la komoj estas ene de la citiloj, kaj parto de la kordoj oni.

Maŝojn

Linio 12 havas ion nomatan tempo deklaro, kiu indikas la komencon de dum buklo. Loops estas partoj de kodo kiu estas ekzekutitaj denove kaj denove. Sed antaŭ ol ni povas lerni pri dum cikloj, ni bezonas lerni kelkajn aliajn konceptojn unue. Tiuj konceptoj estas blokoj, Booleans, komparo operatoroj, kondiĉoj, kaj fine, la dum komunikaĵo.

Blokoj

Al bloko estas unu aŭ pli linioj de kodo kolektitaj kune kun la sama minimuma kvanto de deŝovon. Vi povas diri kie bloko komencas kaj finas per rigardante la linio de deŝovon (tio estas, la nombro de spacoj antaŭ la linio).
Bloko komencas kiam linion dentado de kvar spacoj. Ajna sekva linio kiu ankaŭ dentado de kvar spacoj estas parto de la bloko. Bloko ene de bloko komencas kiam linion dentado kun alia kvar spacoj (por tuta de ok spacoj antaŭ la linio). La bloko finiĝas kiam estas linio de kodo kun la sama deŝovon antaŭ la bloko komencis.
Sube estas figuro de la kodo kun la blokoj konturita kaj kalkulitaj. La spacoj havas nigrajn kvadratojn plenigis fari ilin pli facile rakonti.

Figuro 4-1: blokoj kaj iliaj deŝovon. La nigraj punktoj reprezentas spacoj.
Ekzemple, rigardu la kodon en Figuro 4-1. La spacoj estis anstataŭitaj per malhelaj kvadratoj por fari ilin pli facile rakonti. Linio 12 havas deŝovon de nulo spacoj kaj estas ne ene ajna bloko. Linio 13 havas deŝovon de kvar spacoj. Ekde ĉi deŝovon estas pli granda ol la antaŭa linio de deŝovon, ni povas diri ke nova bloko komencis. Linioj 14, 15, 17 kaj 19 ankaŭ havas kvar spacoj por deŝovon. Ambaŭ el tiuj linioj havas la saman kvanton de deŝovon kiel la antaŭa linio, do ni scias ke ili estas en la sama bloko. (Ni ne kalkulu malplenajn liniojn kiam ni serĉas deŝovon.)
Linio 20 havas deŝovon de ok spacoj. Ok spacoj estas pli ol kvar spacoj, do ni scias nova bloko komencis. Tio ĉi estas bloko kiu estas ene de alia bloko.
Linio 22 nur havas kvar spacoj. La linio antaŭ la linio 22 havis pli grandan numeron de spacoj. Ĉar la deŝovon malpliiĝis, ni scias ke bloko finis. Linio 22 estas en la sama bloko kiel la aliaj linioj kun kvar spacoj.
Linio 23 pliigas la deŝovon por ok spacoj, do denove nova bloko komencis.
Por recap, linio 12 ne estas en ajna bloko. Linioj 13 al 23 ĉiuj en unu bloko (markita kun la ĉirkaŭis 1). Linio 20 estas en bloko en bloko (markita kun ĉirkaŭis 2). Kaj linio 23 estas la sola linio en alia bloko en bloko (markita kun ĉirkaŭis 3).
Kiam vi tajpas kodon en sencelaj, ĉiu litero estas la sama larĝa. Vi povas kalkuli la nombron de literoj sur aŭ sub la linio por vidi kiom da spacoj vi metis en fronto de tiu linio de kodo.
En ĉi tiu figuro, la linioj de kodo ene skatolo 1 estas ĉiuj en la sama bloko, kaj ĝi blokas 2 kaj 3 estas ene bloko 1. Bloko 1 estas dentado kun almenaŭ kvar spacoj de la maldekstra rando, kaj ĝi blokas 2 kaj 3 estas dentado ok spacoj de la maldekstra rando. Bloko povas enhavi nur unu linion. Rimarku ke blokoj 2 kaj 3 estas nur unu linio ĉiu.

La Bulea Datumtipo

La Bulea datumtipo havas nur du valoroj: Vera aŭ Falsa. Tiuj valoroj estas inkluzivas uskladon kaj ili ne estas ŝnuro valoroj; alivorte, oni ne metu 'citaĵo karaktero ĉirkaŭ ili. Ni uzos Bulea valoroj (ankaŭ nomita bools) kun komparo operatoroj formi kondiĉoj. (Explained proksima.)

Komparo Operacisimboloj

En linio 12 de nia programo, la linio de kodo enhavas la dum komunikaĵo:
  1. dum guessesTaken <6:
La esprimo kiu sekvas la dum ŝlosilvorto (guessesTaken <6) enhavas du valoroj (la valoron en la variablo guessesTaken, kaj la entjera valoro 6) konektitaj de operatoro (la <signo, la "malpli ol" signo). La <signo nomiĝas komparo operatoro.
La komparo operatoro estas uzata por kompari du valoroj kaj taksi al Vera aŭ Falsa Bulea valoro. Listo de ĉiuj kompare operatoroj estas en Tabelo 4-1.


Tabelo 4-1: Komparo operatoroj.
Operatoro Registriĝi Operatoro Nomo
< Malpli ol
> Pli granda ol
<= Malpli ol aŭ egala al
> = Pli granda ol aŭ egala al
== Egala al
! = Ne egala al

Kondiĉoj

Kondiĉo estas esprimo kiu kombinas du valoroj kun komparo operatoro (kiel <aŭ>) kaj taksas por Bulea valoro. Kondiĉo estas nur alia nomo por esprimo kiu taksas al Vera aŭ Falsa. Vi trovos liston de aliaj komparo operatoroj en Tabelo 4-1.
Kondiĉoj ĉiam taksi al Bulea valoro: aŭ Vera aŭ Falsa. Ekzemple, la situacio en nia kodo, guessesTaken <6 demandas "estas la valoro stokita en guessesTaken malpli ol la nombro 6?" Se jes, tiam la kondiĉo taksas al True. Se ne, la kondiĉo taksas al False.
En la kazo de nia Divenu la Numero programo, en linio 4 ni stokis la valoro 0 en guessesTaken. Ĉar 0 estas malpli ol 6, ĉi tiu kondiĉo taksas al la Bulea valoro de Vera. Memoru, kondiĉo estas nur nomo por esprimo kiu uzas komparon operatoroj kiel <aŭ! =.

Eksperimento kun Booleans, Komparo Operacisimboloj kaj kondiĉoj

Entajpu la jenaj esprimoj en la interaga ŝelo por vidi lian Bulea rezultojn:
>>> 0 <6
Vera
>>> 6 <0
Falsaj
>>> 50 <10
Falsaj
>>> 10 <11
Vera
>>> 10 <10
Falsaj
La kondiĉo 0 <6 revenas la Bulea valoro True ĉar la nombro 0 estas malpli ol la nombro 6. Sed ĉar 6 estas ne malpli ol 0, la kondiĉo 6 <0 taksas al False. 50 Ne malpli ol 10, do 50 <10 estas False. 10 estas malpli ol 11, do 10 <11 estas True.
Sed kio pri 10 <10? Kial ĝi taksi al falsa? Estas Falsa ĉar la nombro 10 estas ne pli malgranda ol la nombro 10. Ili estas ekzakte la sama amplekso. Se knabino nomata Alice estis la sama alteco kiel knabo nomita Bob, vi ne dirus ke Alico trovas pli altkreska ol Bob aŭ ke Alico estas pli mallonga ol Bob. Ambaŭ el tiuj asertoj estus falsaj.
Provu eniri iuj kondiĉoj en la ŝelon por vidi kiel tiuj komparo operatoroj labori:
>>> 10 == 10
Vera
>>> 10 == 11
Falsaj
>>> 11 == 10
Falsaj
>>> 10! = 10
Falsaj
>>> 10! = 11
Vera
>>> 'Saluton' == 'Saluton'
Vera
>>> 'Saluton' == 'revido'
Falsaj
>>> 'Saluton' == 'HELLO'
Falsaj
>>> 'Revido'! = 'Saluton'
Vera
Rimarku la diferencon inter la asigno operatoro (=) kaj la "egala al" komparo operatoro (==). La egalaj (=) signo estas uzata por atribui valoron al variablo, kaj la egala al (==) signo estas uzata en esprimoj por vidi ĉu du valoroj estas egalaj. Estas facile hazarde uzi unu kiam vi intencis uzi la aliajn, do atentu pri tio, kion vi tajpas in
Du valoroj kiuj estas malsamaj datumtipoj ĉiam estos ne egala al ĉiu alia. Ekzemple, provu eniri la sekva en la interaga konko:
>>> 42 == 'Saluton'
Falsaj
>>> 42! = '42 '
Falsaj

Looping kun dum Deklaroj

La dum komunikaĵo markas la komencon de ciklo. Kelkfoje en niaj programoj, ni volas ke la programo por fari ion denove kaj denove. Kiam la ekzekuto atingas dum deklaro, ĝi taksas la kondiĉo apud la dum ŝlosilvorto. Se la kondiĉo taksas al Vera, la ekzekuto movas ene la tempo-bloko. (En nia programo, la dum-bloko komenciĝos je la linio 13.) Se la kondiĉo taksas al False, la ekzekuto movas tuta vojo preter la dum-bloko. (En nia programo, la unua linio post la dum-bloko estas linio 28.)
Al dum komunikaĵo ĉiam havas dupunkto (la: signon) post la kondiĉo.
  1. dum guessesTaken <6:

Figuro 4-2: La tempo buklo la kondiĉo.
Figuro 4-2 montras kiel la ekzekuto fluoj depende de la kondiĉo. Se la kondiĉo taksas al Vera (kiu faras la unuan fojon, ĉar la valoro de guessesTaken estas 0), ekzekuto eniros la dum-bloko je la linio 13 kaj tenu subiro. Iam la programo atingas la finon de la tempo-blokon, anstataŭ iri malsupren al la sekvanta linio, ĝi saltas reen ĝis la dum deklaro de linio (linio 12). Ĝi tiam re-taksas la kondiĉo, kaj se ĝi ankoraŭ taksas al Vera ni eniras la samtempe-bloko denove.
Jen kiel la ciklo funkcias. Tiel longe kiel la kondiĉo estas vera, la programo subtenas ekzekuti la kodon ene de la tempo-blokon ree ĝis ni atingos la finon de la tempo-blokon kaj la kondiĉo estas False. Kaj, ĝis guessesTaken estas egala al aŭ pli granda ol 6, ni konservos looping.
Pensu pri la dum komunikaĵo diris, "dum ĉi tiu kondiĉo estas vera, gardu looping tra la kodo en ĉi tiu bloko".
Vi povas fari ĉi tiu ludo pli malfacila aŭ facila ŝanĝante la nombro de divenas la ludanto ricevas. Vi nur devas fari estas ŝanĝi tiun linion:
  1. dum guessesTaken <6:
en ĉi tiun linion:
  1. dum guessesTaken <4:
... Kaj nun la ludanto nur ricevas kvar divenojn anstataŭ ses divenas. Per opcio la kondiĉo por guessesTaken <4, ni certigu ke la kodo ene la buklo nur kuras kvar fojojn anstataŭ ses. Ĉi tio faras la ludon multe pli malfacila. Por fari la ludon pli facila, starigis la kondiĉo por guessesTaken <8 aŭ guessesTaken <10, kio kaŭzas la buklo kuri kelkajn pli fojoj ol antaŭe kaj akcepti pli konjektojn de la ludanto.
Kompreneble, se ni forigis linio 17 (guessesTaken = guessesTaken + 1) aro tiam la guessesTaken neniam pliigi kaj la kondiĉo devus ĉiam esti Vera. Tiu donus la ludanto senliman nombron da konjektoj.

La Ludanto divenas

Linioj 13 al 17 peti la ludanto diveni kion la sekreta nombro estas kaj lasas ilin eniri lian divenon. Ni stokas tiun guess en variablo, kaj poste konverti ke kordoj valoron en entjero valoro.
  1. print ('Prenu diveni.') # Estas kvar spacoj antaŭ impreso.
  2. diveni = input ()
La programo nun demandas nin por diveni. Ni tajpi en nia guess kaj tiu numero estas stokita en variablo nomata diveni.

Konvertado Strings al Entjeroj kun la int () Funkcio

  1. diveni = int (diveni)
En linio 15, ni nomas nova funkcio nomita int (). La int () funkcio prenas unu argumento. La eniro () funkcio revenis ĉenon de teksto kiu ludanto tajpita. Sed en nia programo, ni volas entjero, ne ĉenon. Se la ludanto eniras 5 kiel ilia konjekto, la enigo () funkcio estos redoni la kordo valoro '5 'kaj ne la entjera valoro 5. Memoru ke Python konsideras la kordo '5 'kaj la entjera 5 esti malsamaj valoroj. Do la int () funkcio prenos la kordoj valoron ni donu ĝin kaj reveni la entjera valoro formo de ĝi.
Ni spertas kun la int () funkcio en la interaga ŝelo. Provu tajpi la sekvaj:
>>> Int ('42 ')
42
>>> Int (42)
42
>>> Int ('saluton')

Traceback (plej lasta alvoko lasta):
Dosieron "<pyshell#4>", linio 1, en <module>
_int_ ('kvardek du')
ValueError: nevalida laŭvorta por int () kun bazo 10: 'saluton'
>>> Int ('kvardek du')

Traceback (plej lasta alvoko lasta):
Dosieron "<pyshell#5>", linio 1, en <module>
_int_ ('kvardek du')
ValueError: nevalida laŭvorta por int () kun bazo 10: "kvardek du '
>>> Int ('42')
42
>>> 3 + int ('2 ')
5
Ni povas vidi ke la int ('42 ') nomita revenos la entjera valoro 42, kaj ke int (42) promesas fari same (kvankam ĝi estas speco de sencela igi entjero al entjero). Tamen, kvankam vi povas pasi kordoj al la int () funkcio, oni povas ne nur pasi ajna linio. Ekzemple, pasante 'saluton' por int () (kiel ni faras en la int ('saluton') nomita) rezultos en eraro. La kordoj ni pasas al int () devas esti formita de nombroj.
La entjero ni pasas al int () devas ankaŭ esti nombra, anstataŭ teksto, kiu estas la kialo int ('kvardek du') ankaŭ produktas eraron. Tio dirite, la int () funkcio estas iomete pardonas, se nia kordoj havas spacoj ambaŭflanke, estos ankoraŭ kuri sen eraro. Jen kial la int ('42') nomita verkoj.
La 3 + int ('2 ') linio montras esprimo kiu aldonas entjero 3 al la reveno valoro de int ('2') (kiu estas la entjero 2). La esprimo taksas al 3 + 2, kiu tiam taksas al 5. Do eĉ se ni ne povas aldoni entjero kaj linio (3 + '2 'montrus al ni eraro), ni povas aldoni entjero al ĉeno kiu estis konvertita al entjero.
Memoru, ke en nia programo sur linio 15 la guess variablo origine tenis la kordoj valoron de tio, kion la ludanto tajpita. Ni anstataŭigi la kordoj valoro stokita en guess kun la entjera valoro revenis por la int () funkcio. Tio estas ĉar ni devos poste kompari la ludanto guess kun la hazarda nombro la komputilo suprenvenis kun. Ni povas nur kompari du entjeraj valoroj por vidi se unu estas pli granda (tio estas, pli alta) aŭ malpli (tio estas, malsupreniri) ol la alia. Ni ne povas kompari ĉenon valoro kun entjera valoro por vidi se unu estas pli granda aŭ malpli ol la aliaj, eĉ se tiu linio valoro estas nombraj kiel '5 '.
En nia Divenu la Numero ludo, se la ludanto tipoj en iu kiu ne estas numero, tiam la funkcio alvoko int () rezultos en eraro kaj la programo estos frakasi. En la aliaj ludoj en ĉi tiu libro, ni aldonos iujn pli kodo por kontroli por eraro kondiĉojn kiel ĉi tion kaj doni la ludanto alian ŝancon eniri ĝentila respondo.
Rimarku ke nomante int (guess) ne ŝanĝas la valoron en la guess variablo. La kodo int (guess) estas esprimo kiu taksas la entjera valoro formo de la ŝnuro stokas en la guess variablo. Ni devas atribui tiun revenon valoro diveni por ŝanĝi la valoron en diveni al entjero kun ĉi plenan linion: diveni = int (guess)

Pliigante Variabloj

  1. guessesTaken = guessesTaken + 1
Iam la ludanto prenis guess, ni volas pligrandigi la nombron de divenas, ke ni memoru la ludanto prenas.
La unua fojo ke ni eniras la buklo bloko, guessesTaken havas la valoron de 0. Pitono prenos ĉi valoro kaj aldonu 1 al ĝi. 0 + 1 estas 1. Tiam Python stokos la nova valoro de 1 al guessesTaken.
Pensu pri linio 17 kiel signifo, "la guessesTaken variablo devus esti pli ol kio jam estas".
Kiam ni aldonu al entjera valoro, programistoj diras, ke ili pliigante la valoro (ĉar ĝi estas kreskanta de unu). Kiam ni subtrahi unu de valoro, ni decrementing la valoro (ĉar ĝi estas malkreskanta de unu). La venontan fojon la buklo bloko cikloj ĉirkaŭe, guessesTaken havos la valoron de 1 kaj estos incremented al la valoro 2.

se Deklaroj

Estas la ludanto Guess Tro Malalta?

Linioj 19 kaj 20 ĉeko se la nombro kiun la ludanto divenis estas malpli ol la sekreta hazarda numero kiu la komputilo suprenvenis kun. Se jes, tiam ni volas diri al la ludanto kiu lia diveno tro malalta por presi ĉi tiun mesaĝon al la ekrano.
  1. se diveni <nombro:
  2. print ('Via konjekto estas tro malalta.') # Estas ok spacoj antaŭ impreso.
Linio 19 komencas se komunikaĵo kun la ŝlosilvorto, se. Apud la se ŝlosilvorto estas la kondiĉo. Linio 20 komencas novan blokon (vi povas diri ĉar la deŝovon pliigis de linio 19 al linio 20.) La bloko kiu sekvas la se ŝlosilvorto nomiĝas se-bloko. An se aserto estas uzata se vi nur volas iom da kodo ekzekuti se iu kondiĉo estas vera. Linio 19 havas se komunikaĵo kun la kondiĉo diveni <nombro. Se la kondiĉo taksas al Vera, tiam la kodon en la se-bloko estas ekzekutitaj. Se la kondiĉo estas Falsa, tiam la kodon en la se-bloko estas ignorita.

Figuro 4-3: se kaj dum deklaroj.
Kiel la tempo komunikaĵo, la se aserto havas ankaŭ ŝlosilvorto, sekvita de kondiĉo, dupunkto, kaj tiam bloko de kodo. Vidu Figuro 4-3 por komparo de la du deklaroj.
La se aserto funkcias preskaŭ la sama maniero kiel dum deklaro, ankaŭ. Sed kontraste kun la dum-bloko, ekzekuto ne saltas reen al la se deklaro fine de la se-bloko. Ĝi simple daŭrigas malsupren al la sekvanta linio. En aliaj vortoj, se deklaroj ne faros buklo.
Se la kondiĉo estas vera, tiam ĉiuj linioj ene de la se-bloko estas ekzekutitaj. La sola linio ene ĉi se-bloko on line 19 estas presita () funkcio nomita.







Se la entjera la ludanto eniras estas malpli ol la hazarda entjero la komputilo elpensis, la programo montras Via konjekto estas tro malalta. Se la entjera la ludanto eniras estas egala al aŭ pli granda ol la hazarda entjero (en kiu kazo, la kondiĉo apud la se ŝlosilvorto estus Falsa), tiam ĉi tiu bloko estus saltis super.

Estas la ludanto Guess Tro alta?

Linioj 22 al 26 en nia programo kontroli se la ludanto guess estas ĉu tro granda aŭ precize egala al la sekreta nombro.
  1. se diveni> nombro:
  2. presi ('Via konjekto estas tro alta.)
Se la ludanto guess estas pli granda ol la hazarda entjero, ni eniras la se-bloko kiu sekvas la se aserto. La impreso () linio diras la ludanto, ke ilia konjekto estas tro granda.

Lasante Loops Frua kun la rompo Statement

  1. se diveni == nombro:
  2. rompi
Tiu se aserto estas kondiĉo kontrolas por vidi se la konjekto estas egala al la hazarda entjero. Se jes, ni eniras linio 26, la se-bloko kiu sekvas ĝin.
La linio ene de la se-bloko estas ripozon deklaron kiu rakontas la programo tuj salti el la dum-bloko al la unua linio post la fino de la tempo-bloko. (La rompo aserto ne tedas re-kontroli la dum buklo la kondiĉo, ĝi nur rompas tuj.)
La rompo aserto estas nur la ripozon ŝlosilvorto por oni, sen kondiĉo aŭ dupunkto.
Se la ludanto guess estas ne egala al la hazarda entjero, ni ne rompi la dum-bloko, ni atingos la fundon de la tempo-blokon ĉiuokaze. Iam ni atingos la fundon de la dum-bloko, la programo buklo dorso al la supro kaj recheck la kondiĉo (guessesTaken <6). Memoru post la guessesTaken = guessesTaken + 1 linio de kodo ekzekutitaj, la nova valoro de guessesTaken estas 1. Ĉar 1 estas malpli ol 6, ni eniras la buklo denove.
Se la ludanto tenas diveni tro malalta aŭ tro altaj, la valoro de guessesTaken ŝanĝos al 2, tiam 3, tiam 4, tiam 5, tiam 6. Se la ludanto divenis la nombro ĝuste, la kondiĉo en la se guess == nombro aserto estus vera, kaj ni estus ekzekutita la rompo komunikaĵo. Alie, ni observu looping. Sed kiam guessesTaken havas la numero 6 stokita, la dum deklaro de kondiĉo estas Falsa, ekde 6 estas ne malpli ol 6. Ĉar la tempo deklaro de kondiĉo estas Falsa, ni ne eniras la buklo kaj anstataŭ salti al la fino de la tempo-bloko.
La ceteraj linioj de kodo kuri kiam la ludanto finis diveni (ĉu ĉar la ludanto divenis la ĝustan numeron, aŭ ĉar la ludanto kuris el divenas). La kialo de la ludanto eliris la antaŭa buklo determinos se ili gajnas aŭ perdi la ludon, kaj la programo montros la taŭgan mesaĝo sur la ekrano cxar aux kazo.

Kontrolu se la ludanto Gajnitaj

  1. se diveni == nombro:
Kontraste kun la kodo en linio 25, ĉi tiu linio havas deŝovon, kiu signifas la dum-bloko finiĝis kaj ĉi tiu estas la unua linio ekster la tempo-bloko. Kiam ni forlasis la dum bloko, ni faris tiel bone ĉar la dum deklaro de kondiĉo estis Falsa (kiam la ludanto kuras el divenas) aŭ se ni ekzekutita la rompo aserto (kiam la ludanto divenas la nombro korekte). Kun la linio 28, kontrolu denove por vidi se la ludanto divenis ĝuste. Se jes, ni eniras la se-bloko kiu sekvas.
  1. guessesTaken = str (guessesTaken)
  2. print('Good job, ' + myName + '! You guessed my number in ' + guessesTaken + ' guesses!')
Linioj 29 kaj 30 estas ene de la se-bloko. Ili nur ekzekuti se la kondiĉo en la se aserto on line 28 estis Vera (tio estas, se la ludanto ĝuste divenis la komputilo nombro).En linio 29 ni nomas la nova funkcio str (), kiu redonas la kordoj formo de argumento. Ni uzas tiun funkcion, ĉar ni volas ŝanĝi la entjera valoro en guessesTaken en ĝian ĉenon versio ĉar ni povas uzi nur kordoj en alvokoj por presi ().Linio 29 rakontas la ludanto kiu havas gajnis, kaj kiom da divenas ĝin prenis. Avizo en ĉi tiu linio ni ŝanĝas la guessesTaken valoro en kordoj ĉar ni povas nur aldoni (tio estas, concatenate) kordoj al aliaj kordoj. Se ni devis provi aldoni ĉenon por entjero, la Python interpretisto estus montri eraron.Kontrolu se la ludanto Lost

    se guess! = nombro:En Linio 32, ni uzas la komparo operatoro! = Kun la se aserto estas kondiĉo por signifi "estas ne egala al". Se la valoro de la ludanto guess estas pli malalta aŭ alta ol (kaj sekve, ne egala al) la nombro elektita de la komputilo, tiam ĉi tiu kondiĉo taksas al Vera, kaj ni eniros en la bloko kiu sekvas ĉi tiun se aserto on line 33.Linioj 33 kaj 34 estas ene de la se-bloko, kaj nur ekzekuti se la kondiĉo estas vera.

    nombro = str (nombro)
    print ('Nope. La nombro mi pensis pri estis' + nombro)En ĉi tiu bloko, ni diru la ludanto kio la nombro estas ĉar ili ne sukcesis diveni ĝuste. Sed unue ni devas gardi la kordo versio de nombro kiel la nova valoro de nombro.Tiu linio estas ankaŭ ene de la se-bloko, kaj nur ekzekutas se la kondiĉo estis Vera. Je ĉi tiu punkto, ni atingis la finon de la kodo, kaj la programo finiĝas.Gratulojn! Ni nur planita nia unua vera ludo!Resumo: Kio Ĝuste estas Programado?Se iu demandas vin, "Kion ekzakte estas programado ni estas?" kion vi povis diri al ili? Programado estas nur la ago de skribi kodon por programoj, kiu estas, kreante programoj kiuj povas ekzekutita de komputilo."Sed kion ekzakte estas programo?" Kiam vi vidas iun uzi programon de komputilo (ekzemple, ludi niajn Guess La Nombro ludo), ĉiuj vi vidu estas teksto aperas sur la ekrano. La programo decidas kion ĝusta teksto por montri en la ekranon (kiu estas nomata la eligo), bazita en lia instrukcioj (tio estas, la programo) kaj sur la teksto, ke la ludanto tajpita sur la klavaro (kiu estas nomata la eniro). La programo havas tre specifan instrukciojn sur kio teksto por montri al la uzanto. Programo estas simple kolekto de instrukcioj."Kiajn instrukciojn?" Estas nur kelkaj malsamaj specoj de instrukcioj, vere.

    Esprimoj, kiuj konsistas el valoroj konektitaj de telefonistoj. Esprimoj estas ĉiuj taksita malsupren al sola valoro, kiel 2 +2 taksas al 4 aŭ 'Hello' + '' + 'Monda' taksas al 'Saluton Mondo'. Funkcio alvokoj estas ankaŭ parto de esprimoj ĉar ili taksos al sola valoro samaj, kaj ĉi tiu valoro povas esti koneksaj per operatoroj al aliaj valoroj. Kiam esprimoj estas apud la se kaj dum ŝlosilvortoj, ni ankaŭ nomas ilin kondiĉoj.
    Asigno deklaroj, kiuj simple stoki valorojn en variabloj tiel ni povas memori la valoroj poste en nia programo.
    se, dum kaj rompo estas fluo kontrolo deklaroj ĉar ili decidas kion instrukcioj estas ekzekutitaj. La normalan fluon de ekzekuto por programo estas por komenci je la supro kaj ekzekuti ĉiun instrukcion subiro unu post unu. Sed tiuj fluo kontrolo deklaroj povas kaŭzi la fluo salti instrukcioj, buklo super instrukcioj, aŭ rompi maŝojn. Funkcio nomas ankaŭ ŝanĝi la fluon de ekzekuto per salto al la komenco de funkcio.
    La impreso () funkcio, kiu vidigas tekston sur la ekrano. Ankaŭ, la enigo () funkcio povas ricevi tekston de la uzanto tra la klavaro. Ĉi tio estas nomita / S (prononcata kiel la literoj, "okulo-oh"), ĉar ĝi traktas la enigo kaj eligo de la programo.Kaj tio estas ĝi, ĝuste tiuj kvar aĵoj. Kompreneble, estas multaj detaloj pri tiuj kvar tipoj de instrukcioj. En ĉi tiu libro vi lernos pri novaj datumoj tipoj kaj operatoroj, novaj fluo kontrolo deklaroj krom se, dum kaj rompos, kaj pluraj novaj funkcioj. Ankaŭ estas malsamaj tipoj de mi / O (enigo de la muso, kaj elirigi sono kaj grafikaĵoj kaj bildoj anstataŭ nur teksto.)Por la persono uzanta vian programoj, ili vere nur zorgas pri tio lasta tipo, I / O. La uzanto tipoj sur la klavaro kaj tiam vidas aferojn en la ekrano aŭ aŭdas tion for de parolantoj. Sed por la komputila eltrovi kio rigardas montri kaj kion sonas por ludi, ĝi bezonas programon, kaj programoj estas nur aro da instrukcioj ke vi, la programisto, mi skribis.A Web paĝo por Programo paŭsiSe vi havas aliron al la Interreto kaj retumilo, vi povas iri al tiu libro de afiŝinto ĉe http://inventwithpython.com/traces vi trovos paĝon kiu superu tra ĉiu el la programoj en tiu libro. Sekvante kune kun la spuro linio por linio, ĝi povus esti pli klara, kion la Divenu la Numero programo faras. Ĉi paĝo nur montras simulado de kio okazas kiam la programo kuras. Neniu reala kodo vere esti ekzekutita.
Figuro 4-4: La paŭsi retpaĝo.La maldekstra flanko de la retpaĝo montras la fontkodon, kaj la emfazita linio estas la linio de kodo kiu estas por esti ekzekutita. Vi ekzekuti tiun linion kaj movi al la sekvanta linio por klaki la "Sekva" butonon. Vi povas ankaŭ reiri paŝo klakante la "Malantaŭa" butonon, aŭ salti rekte al paŝo post tajpinte ĝin en blanka skatolo kaj klakante la "Saltu" butonon.Sur la dekstra flanko de la retpaĝo, estas tri sekcioj. La "Nuna variablo valoroj" sekcio montras vin ĉiu variablo kiu estis atribuita valoro, kune kun la valoro mem. La "Notoj" sekcio donos al vi aludo pri kio okazas sur la emfazita linio. La "Programo eligo" sekcio montras la eligo de la programo, kaj la eniro kiu sendas al la programo. (Ĉi tiu retpaĝo aŭtomate eniras tekston al la programo kiam la programo demandas.)Do iru al ĉiu el tiuj retpaĝoj kaj alklaku la "Sekva" kaj "Malantaŭa" butonoj spuri tra la programon kiel ni faris supre.Video tutorial de kiel uzi la interreto paŭsi ilo estas disponeblaj de ĉi tiu libro de afiŝinto ĉe http://inventwithpython.com/videos/
Postado por às

Nenhum comentário:

Postar um comentário

Assinar: Postar comentários (Atom)