Python por Komputilaj Ludoj: skribu-kun-python-cxap11

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

Temoj Kovrite En tiu ĉapitro:

Hard-kodigo
Pliigita Atribuo Telefonistoj, + =, - =, * =, / =
La random.shuffle () Funkcio
La varo () Listo Metodo
La aliĝi () Listo Metodo
String Interpolo (ankaŭ nomata String Formatado)
Konvertiĝo Specifier% s
Ingitaj Loops

En ĉi tiu ĉapitro vi lernos kelkajn novajn metodojn kaj funkcioj kiuj venis kun Python. Vi ankaŭ lernos pri grandigita asigno operatoroj kaj kordoj interpolo. Ĉi tiuj konceptoj ne lasu vin fari ion ajn vi povis fari antaŭe, sed ili estas belaj mallongigoj kiuj faras tajpi vian kodo facila.
Ringobulkoj estas simpla ludo vi povas ludi kun amiko. Via amiko elpensas hazarda 3-cifera nombro sen ripeti ciferojn, kaj vi provos diveni kion la nombro estas. Post ĉiu konjekto, via amiko donas postsignoj pri kiel fermi viajn diveno. Se la amiko diras al vi "ringobulkoj", kiu signifas ke neniu el la tri ciferoj vi divenis estas en la sekreta nombro. Se via amiko diras al vi "beko", tiam unu el la ciferoj estas en la sekreta nombro, sed via guess havas la ciferon en la malĝusta loko. Se via amiko diras al vi "fermi", tiam via guess havas korekta cifero en la ĝusta loko. Kompreneble, eĉ se vi ricevas beko aŭ fermi postsigno, vi ankoraŭ ne scias kion cifero en via konjekto estas la ĝentila.
Vi ankaŭ povas atingi plurajn postsignoj post ĉiu diveni. Diru la sekreton nombro estas 456, kaj via konjekto estas 546. La postsigno vi ricevas el via amiko estus "fermi beko beko" ĉar unu cifero estas korekta kaj en la ĝusta loko (la cifero 6), kaj du ciferoj estas en la sekreta numero sed en la malĝusta loko (la ciferoj 4 kaj 5) .

Specimeno Run

Mi pensas de 3-cifera nombro. Provu diveni, kio tio estas.
Jen kelkaj postsignoj:
Kiam mi diras: Tio signifas:
Beko Unu cifero estas korekta sed en la malĝusta pozicio.
Fermi Unu cifero estas korekta kaj en la dekstra pozicio.
Ringobulkoj Neniu cifero estas korekta.
Mi elpensis numeron. Vi havas 10 divenojn por atingi ĝin.
Divenu # 1:
123
Fermi
Divenu # 2:
453
Beko
Divenu # 3:
425
Fermi
Divenu # 4:
326
Ringobulkoj
Divenu # 5:
489
Ringobulkoj
Divenu # 6:
075
Fermi Fermi
Divenu # 7:
015
Fermi Beko
Divenu # 8:
175
Vi havas ĝin!
Ĉu vi volas ludi denove? (Jes aŭ ne)
neniu

Bagel la Fonta Kodo

bagels.py
Tiu kodo estas elŝutebla el http://inventwithpython.com/bagels.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

importi hazarda
def getSecretNum (numDigits):
# Returns ĉeno kiu estas numDigits longa, formita de unika hazarda ciferoj.
nombroj = listo (gamo (10))
random.shuffle (nombroj)
secretNum =''
por i en gamo (numDigits):
secretNum + = str (nombroj [i])
revenu secretNum
def getClues (konjekto, secretNum):
# Returns ĉenon kun la beko, fermi, ringobulkoj postsignoj al la uzanto.
se diveni == secretNum:
revenu 'Vi havas ĝin!
postsigno = []
por i en gamo (len (guess)):
se guess [i] == secretNum [i]:
clue.append ('Fermi')
elif guess [i] en secretNum:
clue.append ('Beko')
se len (postsigno) == 0:
reveno 'ringobulkoj'
clue.sort ()
revenu ''. aliĝi (postsigno)
def isOnlyDigits (num):
# Returns True se num estas ĉeno formita nur de ciferoj. Alie False.
se num =='':
revenu Falsaj
por i en num:
se i ne estas en '0 1 2 3 4 5 6 7 8 9 '. split ():
revenu Falsaj
revenu Vera
def playAgain ():
# Ĉi tiu funkcio redonas True se la ludanto volas ludi denove, alie False.
presi ('Ĉu vi volas ludi denove? (jes aŭ ne)')
revenu enigo (). malsupreniri (). startswith ('y')
NUMDIGITS = 3
MAXGUESS = 10
print ('Mi pensas de% s-cifera nombro. Provu diveni, kion ĝi estas.'% (NUMDIGITS))
print ('Jen kelkaj postsignoj:')
print ('Kiam mi diras: Tio signifas:')
print ('Beko Unu cifero estas korekta sed en la malĝusta pozicio.')
print ('Fermi Unu cifero estas korekta kaj en la dekstra pozicio.')
print ('ringobulkoj Neniu cifero estas korekta.')
dum Vera:
secretNum = getSecretNum (NUMDIGITS)
presi ('mi elpensis numeron. Vi havas% s divenojn por atingi ĝin.'% (MAXGUESS))
numGuesses = 1
dum numGuesses <= MAXGUESS:
diveni =''
dum len (guess)! = NUMDIGITS aŭ ne isOnlyDigits (guess):
print ('Divenu #% s:'% (numGuesses))
diveni = input ()
postsigno = getClues (konjekto, secretNum)
print (postsigno)
numGuesses + = 1
se diveni == secretNum:
rompi
se numGuesses> MAXGUESS:
print ('Vi kuris el divenas. La respondo estis% s.'% (secretNum))
se ne playAgain ():
rompi

Desegni la Programo

Jen estas fluo abako por ĉi tiu programo. La fluo chart en Figuro 11-1 priskribas la bazajn okazaĵoj de kio okazas en tiu ĉi ludo, kaj en kiu ordo ili povas okazi.

Figuro 11-1: Flow abako por la ringobulkoj ludo.

Kaj jen estas la fontkodon por nia ludo. Komencu novan dosieron kaj tajpu la kodon, kaj poste konservu la dosieron kiel bagels.py. Ni desegni nia ludo tiel ke estas tre facile ŝanĝi la grandecon de la sekreta nombro. Ĝi povas esti 3 ciferoj aŭ 5 ciferoj aŭ 30 ciferoj. Ni faros ĉi uzante konstanta variablo nomata NUMDIGITS anstataŭ malmola kodigo la entjero 3 en niajn fontkodo.
Hard-kodigo signifas skribi programon en tiel ke ĝi ŝanĝas la konduton de la programo postulas ŝanĝi multon de la fontokodo. Ekzemple, ni povus malmola kodo nomon en presita () funkcion alvoko kiel: print ('Saluton, Albert'). Aŭ ni povus uzi tiun linion: print ('Saluton,' + nomo) kiu ni ŝanĝas la nomon kiu estas presita per ŝanĝanta la nomon variablo nomo la programo kuras.

Kiel la Kodo Verkoj: Linioj 1 al 9

Je la komenco de la programo ni importi la hazarda modulo kaj ankaŭ krei funkcio por generi hazardaj sekreta nombro por la ludanto diveni. La procezo de kreado tiu nombro ne estas malmola, kaj ankaŭ garantias ke ĝi nur havas solan ciferoj en ĝi.

importi hazarda

Ĉi tiu ludo importas la hazarda modulo por ke ni povu uzi la modulon de hazarda nombro funkcioj.

Miksanta de Unique Aro de Ciferoj

  def getSecretNum (numDigits): 
  # Returns ĉeno kiu estas numDigits longa, formita de unika hazarda ciferoj. 
  nombroj = listo (gamo (10)) 
  random.shuffle (nombroj) 

Nia unua funkcio estas nomita getSecretNum (), kiu generos la hazarda sekreta nombro. Anstataŭ havi la kodon nur produkti 3-ciferaj nombroj, ni uzu parametron nomata numDigits diri al ni kiom da ciferoj la sekreta nombro devus havi. (Ĉi tiu maniero, ni povas fari la ludon produkti sekreta nombroj kun kvar aŭ ses ciferoj, ekzemple, nur pasante 4 aŭ 6 kiel numDigits.)
Vi eble rimarkis, ke la reveno valoro de nia alvoko por gamo () estis laŭvice pasis al funkcio nomita listo (). La listo () funkcio redonas liston valoro de la valoro pasis ĝin, multe kiel la str () funkcio redonas string formo aŭ la int () funkcio redonas entjeron formo. La kialo ni faris tion, ĉar la gamo () funkcio teknike ne revenas liston sed io nomata iterator objekto. Iteriloj estas temo, kiun vi ne bezonas scii je ĉi tiu punkto, do ili ne estas kovritaj en tiu libro.
Preskaŭ ĉiufoje ni uzas la gamo () funkcio estas en a por buklo. Iteriloj estas fajna uzi in por maŝojn (ĝuste kiel lertaj kaj kordoj estas), sed se ni iam volas konservi liston de entjeroj en variablo, esti certa por konverti la reveno valoro de gamo () por lerta kun la listo ( ) funkcio unue. (Same kiel ni faras en linio 4.)

La random.shuffle () Funkcio

Unue, ni kreas liston de entjeroj 0 ĝis 9 nomante listo (gamo (10)) kaj stoki referenco al tiu listo en nombroj. Tiam ni nomas funkcio en la hazarda modulo nomata barajar (). La sola parametro al random.shuffle () estas referenco al listo. La barajar () funkcio estos hazarde ŝanĝi la ordon de ĉiuj artikoloj en la listo.
Rimarku ke random.shuffle () ne resendas valoro. Ĝi ŝanĝas la listo pasas ĝin "en loko" (ĝuste kiel nia makeMove () funkcio en la Tic Tac Toe ĉapitro modifis la listo estis pasis en lokon, prefere ol reveni al nova listo kun la ŝanĝo). Estus vere esti malĝusta skribi numerojn = random.shuffle (nombroj).
Provu sperti kun la random.shuffle () funkcio per enirante la sekvan kodon en la interaga konko:

>>> Importado hazarda
>>> Spamado = listo (gamo (10))
>>> Print (spamado)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> Random.shuffle (spamado)
>>> Print (spamado)
[3, 0, 5, 9, 6, 8, 2, 4, 1, 7]
>>> Random.shuffle (spamado)
>>> Print (spamado)
[1, 2, 5, 9, 4, 7, 0, 3, 6, 8]
>>> Random.shuffle (spamado)
>>> Print (spamado)
[9, 8, 3, 5, 4, 7, 1, 2, 0, 6]
>>>

Ĉiufoje kiam vi pasos listo referenco al random.shuffle (), poste la listo ĝin referencoj havos ĉiuj samaj artikoloj sed en malsama ordo. La kialo ni faris tion, ĉar ni volas ke la sekreta nombro havi unika valoroj. La ringobulkoj ludo estas multe pli amuza se vi ne havas duplikatajn nombroj en la sekreta nombro, kiel '244 'aŭ '333'.

Havigo de la Sekreta Nombro de la ludkartaro Ciferoj

  secretNum ='' 
  por i en gamo (numDigits): 
  secretNum + = str (nombroj [i]) 
  revenu secretNum 

La sekreta nombro estos ĉeno de la unuaj tri ciferoj (ĉar ni devos pasi 3 por la numDigits parametro) de la ludkartaro listo de entjeroj. Ekzemple, se la ludkartaro listo estas [9, 8, 3, 5, 4, 7, 1, 2, 0, 6] tiam ni volas ke la kordoj revenis por getSecretNum () esti '983 '.
La secretNum variablo komencas kiel malplenan ĉenon. Ni tiam buklo plurfoje egala al la entjera valoro en numDigits. Sur ĉiu ripeto tra la ciklo, nova entjero estas tiris el la ludkartaro listo, konvertiĝis al ĉeno, kaj concatenados al la fino de secretNum. Do se numDigits estas 3, la buklo estos persisti trifoje kaj tri hazarda ciferoj estos concatenados kiel kordoj.
Ekzemple, se nombroj rilatas al la listo [9, 8, 3, 5, 4, 7, 1, 2, 0, 6], tiam en la unua ripeto, nombroj [0] (tio estas, 9) estos pasinta al str (), kiu siavice revenas '9 'kiu estas concatenados al la fino de secretNum. Sur la dua iteracio, la sama okazas kun nombroj [1] (tio estas, 8) kaj la trian ripeto de la sama okazas kun nombroj [2] (tio estas, 3). La fina valoro de secretNum kiu revenis estas '983 '.
Vi eble rimarkos ke secretNum en tiu funkcio estas ĉeno, ne entjero. Tio strangas, sed memoru ke nia sekreto nombro povus esti io kiel '012 '. Se ni stokis tion kiel entjero, estus 12 (sen la komenca nulo) kiu farus ĝin pli malfacila labori kun en nia programo.

Pliigita Atribuo Operacisimboloj

La + = operatoro sur linio 8 estas nova. Tiu estas unu el la grandigita asigno operatoroj. Kutime, se vi volas aldoni aŭ concatenate valoron al variablo, vi uzus kodo kiu aspektis jene:

spamado = 42
spamado = spamado + 10
ovojn = 'Saluton'
ovojn = ovojn + 'mondo!'

Post kuri la supra kodo, spamado havus la valoron 52 kaj ovojn havus la valoron 'Saluton mondo!'. La pliigita asigno operatoroj estas simbola ligilo kiu liveras al vi de retyping la variablo nomo. La sekva kodo faras la ĝustan sama afero kiel la supre kodo:

spamado = 42
spamado + = 10 # Kiel spamado = spamado + 10
ovojn = 'Saluton'
ovojn + = 'mondo!' # Kiel ovojn = ovojn + 'mondo!'

Estas aliaj pligrandigita asigno operatoroj. - = Estos subtrahi valoro de entjero. * = Multigos la variablo per valoro. / = Dividos variablo per valoro. Rimarku ke ĉi tiuj pligrandigita asigno operatoroj fari same math operaciojn kiel -, *, kaj / operatoroj. Pliigita asigno operatoroj estas neta ŝparvojo.

Kiel la Kodo Verkoj: Linioj 11 al 24

Ni ankaŭ bezonas manieron de elŝeligi kion postsignoj montri al la ludanto.

  def getClues (konjekto, secretNum): 
  # Returns ĉenon kun la beko, fermi, ringobulkoj postsignoj al la uzanto. 
  se diveni == secretNum: 
  revenu 'Vi havas ĝin! 

La getClues () funkcio estos redoni ĉenon kun la fermi, beko, kaj ringobulkoj postsignoj, depende de kio pasis por la guess kaj secretNum parametroj. La plej evidenta kaj plej facila paŝo estas kontroli, ĉu la diveno estas la ĝusta sama kiel la sekreta nombro. En tiu kazo, ni povas simple reveni 'Vi havas ĝin!'.

  postsigno = [] 

  por i en gamo (len (guess)): 
  se guess [i] == secretNum [i]: 
  clue.append ('Fermi') 
  elif guess [i] en secretNum: 
  clue.append ('Beko') 

Se la guess ne estas la ĝusta sama kiel la sekreta nombro, ni bezonas kompreni pri kio postsignoj doni la ludanto. Unue ni starigis liston nomata postsigno, kiun ni aldonos la kordoj 'Fermi' kaj 'Beko' drajvo. Ni kombinas la kordojn en tiu listo en sola kordo reveni.
Ni faras tion per looping tra ĉiu ebla indico en guess kaj secretNum (ni certigu ambaŭ kordoj estas samaj grandeco antaux ni nomas getClues ()). Ni supozos ke guess kaj secretNum estas la sama amplekso. Kiel la valoro de i ŝanĝas de 0 al 1 al 2, kaj tiel plu, la se aserto ĉekojn se la unua, dua, tria, ktp letero de guess estas la sama kiel la nombro en la sama pozicio en secretNum. Se jes, ni aldonos ĉeno 'Fermi' al postsigno.
Se tiu kondiĉo estas Falsa ni kontrolu ĉu la nombro en la i-a pozicio en guess ekzistas ie en secretNum. Se ĉi tiu kondiĉo estas Vera ni scias ke la nombro estas ie en la sekreta numero sed ne en la sama pozicio. Jen kial ni aldonu la "Beko" por postsigno.

  se len (postsigno) == 0: 
  reveno 'ringobulkoj' 

Se ni iras tra la tuta por buklo sur kaj neniam aldoni ion al la postsigno listo, tiam ni scias ke ne estas korekta ciferoj ajn en diveni. En ĉi tiu kazo, ni devus nur redonas la ĉeno 'ringobulkoj' kiel nia sola postsigno.

La varo () Listo Metodo

clue.sort ()

Listoj havas metodo nomata speco () ke reordigas la artikoloj en la listo esti en alphanumerical ordo (ĉi tio signifas en alfabeta ordo, sed nombroj estas ankaŭ en ordo). Provu eniri la sekva en la interaga konko:

>>> Spamado = [5, 'vesperto', 3, 1, 4, 'kato', 2, 'simio']
>>> Spam.sort ()
>>> Spamado
[1, 2, 3, 4, 5, 'simio', 'vesperto', 'kato']

Rimarku ke la varo () metodo ne resendas ordo listo, sed prefere nur specoj la listo oni nomas en "anstataŭ". Tio multe similas kiel la inversa () metodo funkcias. Vi neniam volas uzi tiun linion de kodo: reveno spam.sort () ĉar kiu revenus la valoron None (kiu estas kia () redonas). Anstataŭe vi volus aparta linio spam.sort () kaj tiam la linio reveno spamado.
La kialo ni volas ordigi la postsigno listo estas ĉar ni eble revenos ekstra postsignoj ni ne intencas bazita sur la ordo de la postsignoj. Se postsigno referenciado la listo ['Beko', 'Fermi', 'Beko'], tiam tiu estus diri al ni ke la centro cifero de nia diveno estas en la korekta sinteno. Ekde la aliaj du postsignoj estas ambaŭ Beko, tiam ni scias ke ĉiuj ni devas fari estas interŝanĝi la unua kaj tria cifero kaj ni havas la sekreta nombro. Sed se la postsignoj ĉiam ordo laŭ alfabeta ordo, la ludanto ne povas esti certa kiu kalkuli la Fermi postsigno raportas al (kiu estas kio ni volas por ĉi tiu ludo).

La aliĝi () String Metodo

revenu ''. aliĝi (postsigno)

La aliĝi () kordoj metodo revenas ĉenon de ĉiu ero en la listo argumento ligita. La kordoj, ke la metodo tuŝas (on line 27-ĉi estas sola spaco, '') aperas en inter ĉiu ero en la listo. Do la ŝnuro kiu revenis en linio 27 estas unu la ĉenon en postsigno kombinita kune kun sola spaco inter ĉiu linio.
Por ekzemplo, tajpu la sekvajn en la interaga konko:

>>> 'X'. Aliĝi (['saluton', 'mondo'])
'Helloxworld'
>>> 'ABCDEF'. Aliĝi (['x', 'y', 'z'])
'XABCDEFyABCDEFz'
>>> ''. Aliĝi (['Mia', 'nomo', 'estas', 'Zophie'])
Mia nomo estas Zophie '

La aliĝi () kordoj metodo estas ia kiel la malo de la disdivido () kordoj metodo. Dum disiĝo () resendas liston de escisión supren kordoj, join () redonas kordoj de kombinita listo.

Kiel la Kodo Verkoj: Linioj 29 al 53

Ni bezonas paro pli funkcioj por nia ludo uzi. La unua estas funkcio kiu diros al ni, se la divenon la ludanto eniris estas valida entjero. Memoru ke la enigo () funkcio redonas ĉenon de kiom la ludanto tajpis in Se la ludanto eniras en io krom ciferoj por siaj guess, ni volas peti la ludanto denove por pozitiva diveni.
La dua funkcio estas io ni vidis antaŭe en antaŭa ludoj. Ni volas funkcio kiu demandos la ludanto se ili volas ludi la ludon denove kaj de la ludanto respondo, elŝeligi se estis Jes aŭ Neniu respondo.

Kontrolanta se String Nur havas Nombroj

  def isOnlyDigits (num): 
  # Returns True se num estas ĉeno formita nur de ciferoj.  Alie False. 
  se num =='': 
  revenu Falsaj 

La isOnlyDigits () estas malgranda funkcio kiu helpos nin determini se la ludanto eniris divenon nur konsistas el nombroj. Por tion fari, ni kontrolos ĉiun individuon litero en la linia nomata num kaj certigi estas nombro.
Linio 31 faras rapidan ĉeko por vidi se ni sendis la malplenan ĉenon, kaj se jes, ni revenas False.

  por i en num: 
  se i ne estas en '0 1 2 3 4 5 6 7 8 9 '. split (): 
  revenu Falsaj 

  revenu Vera 

Ni uzas por ciklo sur la kordoj num. La valoro de i havos sola karaktero de la num kordoj sur ĉiu ripeto. Interne de la por-bloko, ni kontrolu ĉu mi ne ekzistas en la listo revenis por '0 1 2 3 4 5 6 7 8 9 '. Split (). Se ne, ni scias ke estas karaktero en num tio estas io krom nombro. En tiu kazo, ni devus redoni la valoron False.
Se ekzekuto daŭrigas preter la por ciklo, tiam ni scios, ke ĉiu signo en num estas nombro, ĉar ni ne revenis el la funkcio. En tiu kazo, ni redonas la valoron True.

Elŝeligi se la ludanto volas Ludu Denove

  def playAgain (): 
  # Ĉi tiu funkcio redonas True se la ludanto volas ludi denove, alie False. 
  presi ('Ĉu vi volas ludi denove? (jes aŭ ne)') 
  revenu enigo (). malsupreniri (). startswith ('y') 

La playAgain () funkcio estas la sama unu ni uzis en Pendumito kaj Tic Tac Toe. La longa esprimo on line 43 taksos al ĉu Vera aŭ Falsa. La reveno valoro de la alvoko al la enigo () funkcio estas ĉeno kiu havas lian suba () metodo nomata sur ĝi. La suba () metodo revenas alia cxeno (La minuskla kordoj) kaj kiu kordoj havas sian startswith () metodo nomata sur ĝi, pasante la argumento 'y'.

La Komenco de la Ludo

  NUMDIGITS = 3 
  MAXGUESS = 10 

  print ('Mi pensas de% s-cifera nombro. Provu diveni, kion ĝi estas.'% (NUMDIGITS)) 
  print ('Jen kelkaj postsignoj:') 
  print ('Kiam mi diras: Tio signifas:') 
  print ('Beko Unu cifero estas korekta sed en la malĝusta pozicio.') 
  print ('Fermi Unu cifero estas korekta kaj en la dekstra pozicio.') 
  print ('ringobulkoj Neniu cifero estas korekta.') 

Ĉi tiu estas la efektiva komenco de la programo. Anstataŭ malmola kodigo tri ciferoj kiel la grandeco de la sekreta nombro, ni uzos la konstanta variablo NUMDIGITS. Kaj anstataŭ malmola kodigo maksimumo de dek divenas, ke la ludanto povas fari, ni uzos la konstanta variablo MAXGUESS. (Ĉi tiu estas ĉar se ni pliigos la nombron de ciferoj la sekreta nombro havas, ni ankaŭ eble volas doni la ludanto pli konjektojn. Ni metis la variablo nomoj en ĉiuj ĉefurboj montri ili signifis esti konstanto.)
La impreso () funkcio alvokoj diros la ludanto la reguloj de la ludo kaj kion la Beko, Fermi, kaj ringobulkoj postsignoj volas diri. Linio 48 La impreso () alvoko havas% (NUMDIGITS) aldonitaj al la fino kaj% s ene de la kordoj. Tiu estas tekniko konas string interpolo.

String Interpolo

String interpolo estas alia ŝparvojo, kiel grandigita asigno operatoroj. Kutime, se vi volas uzi la ŝnuron valoroj ene variabloj en alia ĉeno, vi devas uzi la + kunmeto operatoro:

>>> Nomo = 'Alico'
>>> Evento = 'partio'
>>> Kie = 'la lageto'
>>> Tago = 'Sabato'
>>> Tempo = '6: 00pm '
>>> Print ('Saluton,' + nomo + '. Ĉu vi iru al la' + okazaĵo + 'ĉe' + kie + 'ĉi' + tago + 'ĉe' + tempo + '?')
Saluton, Alice. Ĉu vi iros al la festo en la lageto ĉi sabaton je 6:00 ptm?
>>>

Kiel vi povas vidi, ĝi povas esti tre malfacile tajpi linion kiu concatena pluraj kordoj kune. Anstataŭe, vi povas uzi string interpolado, kio permesas meti anstataŭiloj kiel% s (tiuj anstataŭiloj nomas konvertado specifiers), kaj tiam metis la tuta variablo nomoj ĉe la fino. Ĉiu% s anstataŭas kun la valoron en la variablo fine de la linio. Ekzemple, jena kodo faras la samon kiel la supre kodo:

>>> Nomo = 'Alico'
>>> Evento = 'partio'
>>> Kie = 'la lageto'
>>> Tago = 'Sabato'
>>> Tempo = '6: 00pm '
>>> Print ('Saluton,% s. Ĉu vi iras al la% s al% s ĉi% s ĉe% s?'% (Nomo, okazaĵo, kie, tage, tempo))
Saluton, Alice. Ĉu vi iros al la festo en la lageto ĉi sabaton je 6:00 ptm?
>>>

String interpolo povas fari viajn kodo multe pli facila por tajpi kaj legi, anstataŭ uzi plurajn + kunmeto operatoroj.
La fina linio havas la impreso () alvoko kun ŝnuro kun konvertiĝo specifiers, sekvita de la% signon, sekvita de aro da parentezoj kun la variabloj en ili. La unua variablo nomo estos uzata por la unua% s, la dua variablo kun la dua% s kaj tiel plu. La Python interpretisto donos al vi eraro se vi ne havas la saman nombron de% s konvertiĝo specifiers kiel vi havas variabloj.
Alia avantaĝo de uzi string interpola anstataŭ ĉenon kunmeto estas kiu interpolo funkcias kun ajna datumtipo, ne nur kordoj. Ĉiuj valoroj aŭtomate konvertita al la ĉeno datumtipo. (Ĉi tio estas kion la s en% s signifas.) Se vi tajpis ĉi tiun kodon en la ŝelo, vi volas ricevi eraro:

>>> Spamado = 42
>>> Print ('spamo ==' + spamado)
Traceback (plej lasta alvoko lasta):
Dosieron "<stdin>", linio 1, en <module>
TypeError: Ne eblas konverti 'int' celo str implice
>>>

Vi ricevas tiun eraron ĉar string kunmeto povas nur kombini du kordojn, kaj spamado estas entjero. Vi devus memori meti str (spamado) en tie anstataŭe. Sed kun kordoj interpolado, vi povas havi ajnan datumtipo. Provu eniri ĉi tiu enen la ŝelo:

>>> Spamado = 42
>>> Print ('spamo ==% s'% (spamado))
Spamo == 42
>>>

Kiel vi povas vidi, uzante string interpola anstataŭ ĉenon kunmeto estas multe pli facila, ĉar vi ne devas zorgi pri la datumtipo de la variablo. Ankaŭ, kordoj interpolo povas fari en ajna kordoj, ne nur kordoj uzata skribe () funkcio alvokoj.
String interpolo estas ankaŭ sciata kiel kordoj strukturado.

Kiel la Kodo Verkoj: Linioj 55 al 76

Nun ke la programo montris la regulojn por ringobulkoj al la ludanto, la programo estos hazarde krei sekretan numeron kaj poste entajpi buklo kie ree petas la ludanto divenas ĝis ŝi havas ĉu korekte divenis la sekreton nombro, aŭ kuris el divenojn. Post tio, ni petas la ludanto se ŝi volas ludi denove.

Kreante la Sekreta Nombro

  dum Vera: 
  secretNum = getSecretNum (NUMDIGITS) 
  presi ('mi elpensis numeron. Vi havas% s divenojn por atingi ĝin.'% (MAXGUESS)) 

  numGuesses = 1 
  dum numGuesses <= MAXGUESS: 

Ni komencu per dum buklo kiun havas kondiĉo de Vera, signifa ĝi volo buklo eterne gxis ni ekzekuti ripozon komunikaĵo. Interne de la senfina ciklo, ni preni sekreta nombro de niaj getSecretNum () funkcio (pasante ĝin NUMDIGITS diri kiom da ciferoj ni volas la sekreta nombro havi) kaj atribui ĝin al secretNum. Memoru ke secretNum estas ĉeno, ne entjero.
Ni diras al la ludanto kiom ciferoj estas en nia sekreto nombro uzante string interpola anstataŭ ĉenon kunmeto. Ni starigis variablo numGuesses al 1, al signifi ke tiu estas la unua diveni. Tiam ni eniras novan dum buklo kiun observos looping dum numGuesses estas malpli ol aŭ egala al MAXGUESS.

Havigo de la ludanto Guess

Rimarku ke tiu dua dum ciklo sur linio 60 estas ene alian dum buklo kiun komencis la linio 55. Ĉiam ni havas ĉi tiujn bukloj-ene-cikloj, ni nomas ilin anidadas maŝojn. Vi devas scii ke neniu rompo aŭ daŭrigi deklaroj nur rompi aŭ daŭrigi el la plej interna ciklo, kaj ne iu el la ekstera maŝojn.

  diveni ='' 
  dum len (guess)! = NUMDIGITS aŭ ne isOnlyDigits (guess): 
  print ('Divenu #% s:'% (numGuesses)) 
  diveni = input () 

La guess variablo elmontros la ludanto diveni. Ni gardos looping kaj petante la ludanto por diveni ĝis la ludanto eniras guess kiu havas la saman nombron de ciferoj kiel la sekreta nombro kaj estas formita nur de ciferoj. Ĉi tio estas kion la dum buklo kiun komencas la linio 62 estas por. Ni starigis diveni kiel la malplenan ĉenon sur linio 61 tiel ke la dum buklo la kondiĉo estas Falsa la unua fojo, certigante ke ni eniras la buklo almenaŭ unufoje.

Havigo de la Clues por la ludanto Guess

  postsigno = getClues (konjekto, secretNum) 
  print (postsigno) 
  numGuesses + = 1 

Post ekzekuto gets preter la dum ciklo sur linio 62, ni scias ke guess enhavas validan diveni. Ni pasas ĉi kaj la sekreta nombro en secretNum al nia getClues () funkcio. Denove cxeno kiu enhavas niaj postsignoj, kiujn ni montros al la ludanto. Ni tiam pliigo numGuesses per 1 uzanta la pliigita asigno operatoro por aldono.

Kontrolanta se la ludanto gajnis aŭ Lost

  se diveni == secretNum: 
  rompi 
  se numGuesses> MAXGUESS: 
  print ('Vi kuris el divenas. La respondo estis% s.'% (secretNum)) 

Se guess estas la sama valoro kiel secretNum, tiam ni scias la ludanto ĝuste divenis la sekreton nombro kaj ni povas rompi ĉi maŝo (la tempo buklo, kiu jam ekzistas sur linio 60). Se ne, tiam ekzekuto daŭre linio 72, kie ni kontrolu vidi se la ludanto kuris el divenas. Se jes, tiam ni diros la ludanto, ke ili perdis kaj kion la sekreta numero estis. Ni scias, ke la kondiĉo por la dum ciklo sur linio 55 estos Falsa, do ne estas neceso por ripozon komunikaĵo.
Je ĉi tiu punkto, ekzekuto saltas reen al la dum ciklo sur linio 60, kie ni lasis la ludanto havas alian diveni. Se la ludanto kuris el divenas (aŭ ni rompis ekster la buklo kun la rompo deklaro on line 71), tiam ekzekuto devus procedi preter la buklo kaj linio 75.

Petante la Ludanto al Ludu Denove

  se ne playAgain (): 
  rompi 

Post forlasi la dum buklo kiun komencas la linio 60, ni petas la ludanto se volas ludi denove por nomi nian playAgain () funkcio. Se playAgain () False, tiam ni devus rompi la buklo dum kiu jam ekzistas sur linio 55. Ekde estas ne pli kodo post ĉi ciklo, la programo finiĝas.
Se playAgain () revenis Vera, tiam ni ne ekzekuti la rompo deklaron kaj ekzekuto saltus reen al linio 55. Nova sekreta nombro devus esti generita por ke la ludanto povas ludi nova ludo.

Resumo: Getting Bona ĉe ringobulkoj

Ringobulkoj estas sufiĉe simpla ludo plani sed povas esti malfacile gajni ĉe. Sed se vi observos ludas, vi eventuale eltrovi pli bone manieroj por diveni kaj uzi la postsignoj de la ludo donas al vi.
Ĉi tiu ĉapitro enkondukis kelkajn novajn funkciojn kaj metodoj (random.shuffle (), varo (), kaj kunigi ()), kune kun paro oportuna ŝparvojoj. Uzante la pligrandigita asigno operatoroj engaĝi malpli tajpante kiam vi volas ŝanĝi variablo la relativa valoro (ekzemple en spamado = spamado + 1, kiu povas esti shortend al spamado + = 1). String interpolo povas fari viajn kodo multe pli legebla metante% s (nomita, vokis konvertiĝo specifier) ene de la ŝnuro anstataŭ uzi multaj kordoj kunmeto operaciojn.
La aliĝi () kordoj metodo estas pasita listo de kordoj kiuj estos concatenados kune, kun la originala asociita kordoj en inter ili. Ekzemple, 'X'. Aliĝi (['saluton', 'mondo', 'yay']) taksos al la ĉeno, 'helloXworldXyay'.
La varo () listo metodo reordigi la artikoloj en la listo esti en alfabeta ordo.
La append () listo metodo aldonos valoro al la fino de la asociita listo. Se spamado enhavas liston ['a', 'b', 'c'], tiam vokas spam.append ('d') ŝanĝos la listo en spamado esti ['a', 'b', 'c', 'd'].
La venonta ĉapitro estas ne pri programado senpere, sed estos necesa por la ludoj ni volas krei en la postaj ĉapitroj de tiu libro. Ni lernos pri la matematika konceptoj de Karteziaj koordinatoj kaj negativaj nombroj. Ĉi tiuj estos uzitaj en la Soni, Reversi kaj Dodger ludoj, sed Karteziaj koordinatoj kaj negativaj nombroj estas uzita en preskaŭ ĉiuj ludoj (speciale grafikaj ludoj). Se vi jam scias pri tiuj konceptoj, donu la sekvanta ĉapitro mallonga legi ĉiuokaze nur por refreŝigi. Ni plonĝi en!

Python por Komputilaj Ludoj

Páginas

domingo, 3 de março de 2013

skribu-kun-python-cxap11