skribu-kun-python-cxap09

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

Temoj Kovritaj dum tiu ĉapitro:

• Metodoj
• La append() listo metodo
• La sub() kaj supra () kordoj metodoj
• La dorsflanko() listo metodo
• La divido() kordoj metodo
• La gamo() funkcio
• La list() funkcio
• por maŝojn
• elif-deklaroj
• La startswith () kaj endswith () kordoj metodoj.
• La vortaro datumtipo.
• ŝlosilo-valoro paroj
• La ŝlosiloj () kaj valoroj () vortaro metodoj
• Multnombraj variablo farita, kiel a, b, c = [1, 2, 3]

Ĉi tiu ludo enkondukas multajn novajn konceptojn. Sed ne maltrankviliĝu; ni sperti kun tiuj programado konceptoj en la interaga ŝelo unue. Iuj datumtipoj kiel ŝnuro kaj listoj havas funkciojn kiuj asocias kun iliaj valoroj nomitaj metodoj. Ni lernos plurajn malsamajn metodojn kiuj povas manipuli kordoj kaj lertaj por ni. Ni ankaŭ lerni pri nova tipo de buklo nomata por buklo kaj nova tipo de datumtipo nomata vortaro. Iam vi komprenu tiujn konceptojn, estos multe pli facile kompreni la ludo en ĉi ĉapitro: Pendumito.
Vi povas lerni pli de Vikipedio: http://en.wikipedia.org/wiki/Hangman_ (ludo)

Pendumito la Fonta Kodo

Ĉi tiu ĉapitro estas ludo estas iom pli longa ol nia antaŭa ludoj. Vi povas aŭ tajpi en la kodon rekte en la dosieron redaktilo (kiun mi rekomendas) aŭ vi povas akiri la kodon de tiu libro de afiŝinto. Kapti la kodo de la retejo, en TTT-legilo iri al la URL http://inventwithpython.com/chapter9 kaj sekvu la instrukciojn por elŝuti la fontkodon.

hangman.py
Tiu kodo estas elŝutebla el http://inventwithpython.com/hangman.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. importi hazarda
2. HANGMANPICS = ['' '
3. 
   
4. + --- +
5. | |
6. |
7. |
8. |
9. |
10. ========='' ','''
11. 
    
12. + --- +
13. | |
14. Ho |
15. |
16. |
17. |
18. ========='' ','''
19. 
    
20. + --- +
21. | |
22. Ho |
23. | |
24. |
25. |
26. ========='' ','''
27. 
    
28. + --- +
29. | |
30. Ho |
31. / | |
32. |
33. |
34. ========='' ','''
35. 
    
36. + --- +
37. | |
38. Ho |
39. / | \ |
40. |
41. |
42. ========='' ','''
43. 
    
44. + --- +
45. | |
46. Ho |
47. / | \ |
48. / |
49. |
50. ========='' ','''
51. 
    
52. + --- +
53. | |
54. Ho |
55. / | \ |
56. / \ |
57. |
58. ========='' ']
59. vortoj = 'formiko babuino antilopaj bat urso kastoro kamelo kato mitulo kobron pumo kojoto korvo cervo hundo azeno anaso aglo hurón vulpo rano kapron ansero falko leono lacerto lamo talpo simio alkoj muso mulo Salamandroj lutro strigo panda papago kolombo python kuniklo virsxafo rato raven rinocero salmo stampo ŝarko ŝafoj skunk mallaborema serpento araneo cikonio cigno tigro bufo truto meleagro testudo mustelo baleno lupo Wombat zebro '. split ()
60. 
    
61. def getRandomWord (vortlisto):
62. # Ĉi tiu funkcio redonas hazarda kordoj de la pasinta listo de kordoj.
63. wordIndex = random.randint (0, len (vortlisto) - 1)
64. revenu vortlisto [wordIndex]
65. 
    
66. def displayBoard (HANGMANPICS, missedLetters, correctLetters, secretWord):
67. print (HANGMANPICS [len (missedLetters)])
68. print ()
69. 
    
70. print ('Missed literoj:', fino = '')
71. cxar leteron en missedLetters:
72. print (litero, fino = '')
73. print ()
74. 
    
75. spacoj = '_' * len (secretWord)
76. 
    
77. por i en gamo (len (secretWord)): # anstataŭi spacoj kun korekte divenis literoj
78. se secretWord [i] en correctLetters:
79. spacoj = spacoj [: i] + secretWord [i] + spacoj [i +1:]
80. 
    
81. cxar leteron en spacoj: # montras la sekretan vorton kun spacoj inter ĉiu litero
82. print (litero, fino = '')
83. print ()
84. 
    
85. def getGuess (alreadyGuessed):
86. # Returns la letero la ludanto eniris. Ĉi tiu funkcio certigas la ludanto eniris sola litero, kaj ne io alia.
87. dum Vera:
88. print ('Divenu leteron.')
89. diveni = input ()
90. diveni = guess.lower ()
91. se len (guess)! = 1:
92. print ('Bonvolu entajpi unu literon.')
93. elif diveni en alreadyGuessed:
94. print ('Vi jam divenis ke letero. Elektu denove.')
95. elif diveni ne en 'ABCDEFGHIJKLMNOPQRSTUVWXYZ':
96. print ('Bonvolu entajpi LETERO.')
97. alie:
98. revenu diveni
99. 
    
100. def playAgain ():
101. # Ĉi tiu funkcio redonas True se la ludanto volas ludi denove, alie False.
102. presi ('Ĉu vi volas ludi denove? (jes aŭ ne)')
103. revenu enigo (). malsupreniri (). startswith ('y')
104. 
     
105. 
     
106. print ('HANGMA N')
107. missedLetters =''
108. correctLetters =''
109. secretWord = getRandomWord (vortoj)
110. gameIsDone = False
111. 
     
112. dum Vera:
113. displayBoard (HANGMANPICS, missedLetters, correctLetters, secretWord)
114. 
     
115. # Lasu la ludanto tipo en letero.
116. diveni = getGuess (missedLetters + correctLetters)
117. 
     
118. se diveni en secretWord:
119. correctLetters = correctLetters + diveni
120. 
     
121. # Kontroli se la ludanto gajnis
122. foundAllLetters = True
123. por i en gamo (len (secretWord)):
124. se secretWord [i] ne en correctLetters:
125. foundAllLetters = False
126. rompi
127. se foundAllLetters:
128. print ("Jes! La sekreta vorto estas" '+ secretWord +' "! Vi gajnis! ')
129. gameIsDone = True
130. alie:
131. missedLetters = missedLetters + diveni
132. 
     
133. # Kontroli se ludanto divenis tro da fojoj kaj perdita
134. se len (missedLetters) == len (HANGMANPICS) - 1:
135. displayBoard (HANGMANPICS, missedLetters, correctLetters, secretWord)
136. print ('Vi kuras el divenas! \ nAfter' + str (len (missedLetters)) + 'missed divenojn kaj' + str (len (correctLetters)) + 'ĝentila divenas, la vorto estis "' + secretWord + '" ')
137. gameIsDone = True
138. 
     
139. # Petu la ludanto se ili volas ludi denove (sed nur se la ludo estas farita).
140. se gameIsDone:
141. se playAgain ():
142. missedLetters =''
143. correctLetters =''
144. gameIsDone = False
145. secretWord = getRandomWord (vortoj)
146. alie:
147. rompi

Kiel la Kodo Verkoj

1. importi hazarda

La Pendumito programo tuj hazarde elekti sekretan vorton el listo de sekretaj vortoj. Tiu signifas ke ni bezonos la hazarda modulo importitaj.

2. HANGMANPICS = ['' '
3. 
   
4. + --- +
5. | |
6. |
7. |
8. |
9. |
10. ========='' ','''

... La resto de la kodo estas tro granda por montri ĉi tie ...

Ĉi tiu "linio" de kodo estas simpla variablo farita, sed fakte etendas super pluraj realaj linioj en la fontkodo. La reala "linio" ne finas ĝis linio 58. Por helpi vin kompreni kio ĉi tiu kodo signifas, vi devus lerni pri plurliniaj kordoj kaj listoj:

Plurliniaj Strings

Ordinare, kiam vi skribas kordoj en via fontkodo, la kordoj devas esti sur unu linio. Tamen, se vi uzas tri apostrofojn anstataŭ unu sola frazo komenci kaj fini la kordo, la kordoj povas esti sur pluraj linioj:

>>> Fizz ='' 'Kara Alico,
Mi revenos hejmen je la fino de la monato. Mi vidos vin tiam.
Via amiko,
Bob'' '
>>> Print (Fizz)
Kara Alico,
Mi revenos hejmen je la fino de la monato. Mi vidos vin tiam.
Via amiko,
Bob
>>>

Se ni ne havis plurliniaj kordoj, ni devus uzi la \ n eskapo karaktero por reprezenti la novajn liniojn. Sed kiu povas fari la ĉenon malfacile legi en la fontkodo, kiel en ĉi tiu ekzemplo:

>>> Fizz = 'Kara Alico, \ NI revenos hejmen je la fino de la monato. Mi vidos vin tiam. \ NYour amiko, \ nBob '
>>> Print (Fizz)
Kara Alico,
Mi revenos hejmen je la fino de la monato. Mi vidos vin tiam.
Via amiko,
Bob
>>>

Plurliniaj kordoj ne devas teni la saman deŝovon por resti en la sama bloko. Ene de la plurliniaj kordoj, Python ignoras la deŝovon reguloj normale havas por kie blokoj fino.

def writeLetter ():
# Ene la def-bloko
print ('' 'Kara Alico,
Kiel vi fartas? Skribu al mi baldaŭ.

Sincere,
Bob'' ') # fino de la plurliniaj kordoj kaj presita () alvoko
print ('PS I miss you.') # ankoraŭ ene de la def-bloko

writeLetter () # Tio estas la unua linio ekster la def-bloko.

Konstanta Variabloj

Vi eble rimarkis ke HANGMANPICS nomo estas en ĉiuj ĉefurboj. Ĉi tiu estas la programado konvencio por konstanta variabloj. Konstantoj estas variabloj kies valoroj ne ŝanĝas laŭlonge de la programo. Kvankam ni povas ŝanĝi HANGMANPICS same kiel ĉiu alia variablo, la tut-kaskedoj memorigas la programisto ne skribi kodon kiu faras tiel.
Konstanta variabloj estas granda helpo por havigi priskriboj por valoroj kiuj havas specialan signifon. Ekde la multi-kordoj valoro neniam ŝanĝas, estas neniu kialo ni ne povis kopii ĉi plurliniaj string ĉiufoje ni bezonis tiun valoron. La HANGMANPICS variablo neniam varias. Sed estas multe pli mallonga por tajpi HANGMANPICS kion estas por tajpi tie la grandan plurliniaj kordoj.
Ankaŭ, estas kazoj kie tajpi la valoro por oni povas ne esti evidentaj. Se ni aro variablo ovojn = 72, ni povas forgesi kial ni estis opcio, ke variablo por la entjero 72. Sed se ni difini konstanta variablo dekduo = 12, tiam ni povus agordi ovojn = dekduo * 6 kaj per nur rigardante la kodo scias, ke la ovoj variablo estis fiksita al ses dekduo.
Kiel ĉiuj konvencioj, ni ne devas uzi konstanta variabloj, aŭ eĉ meti la nomojn de konstantaj variabloj en ĉiuj ĉefurboj. Sed fari ĝin tiamaniere faciligante por aliaj programistoj kompreni, kiel ĉi tiuj variabloj estas uzataj. (Ĝi eĉ povas helpi vin se vi rigardas kodo vi verkis longan tempon.)

Listoj

Mi nun rakontos al vi pri nova datumtipo nomata listo. Listo valoro povas enhavi plurajn aliajn valorojn en ĝi. Provu tajpi ĉi tiu enen la ŝelo: ['pomojn', 'oranĝoj', 'HELLO MONDO']. Jen listo valoro kiu enhavas tri kordoj valoroj. Same kiel ĉiu alia valoro, vi povas konservi tiun liston en variablo. Provu tajpi spamado = ['pomojn', 'oranĝoj', 'HELLO MONDO'], kaj poste tajpi spamado por vidi la enhavon de spamado.

>>> Spamado = ['pomojn', 'oranĝoj', 'HELLO MONDO']
>>> Spamado
['Pomojn', 'oranĝoj', 'HELLO MONDO']
>>>

Listoj estas bonaj metodoj por stoki pluraj malsamaj valoroj en unu variablo. La individuaj valoroj ene de listo estas nomitaj ankaŭ erojn. Provu tajpi: bestoj = ['aardvark', 'urso hormiguero', 'antilopo', 'Albert'] stoki diversajn kordoj en la variablo bestoj. La rektaj krampoj povas ankaŭ esti uzata por preni eron el listo. Provu tajpi bestoj [0], aŭ bestoj [1], aŭ bestoj [2], aŭ bestoj [3] en la ŝelon por vidi kion ili taksas al.

>>> Bestoj = ['aardvark', 'urso hormiguero', 'antilopo', 'Albert']
>>> Bestoj [0]
'Aardvark'
>>> Bestoj [1]
'Urso hormiguero'
>>> Bestoj [2]
'Antilopo'
>>> Bestoj [3]
'Albert "
>>>

La nombro inter la rektaj krampoj estas la indekso. En Python, la unua indico estas la nombro 0 anstataŭ la nombro 1. Do la unua ero en la listo estas je indico 0, la dua ero estas indekso 1, la tria ero estas indekso 2, kaj tiel plu. Listoj estas tre bonaj, kiam ni devas gardi partoj kaj multaj valoroj, sed ni ne volas variabloj por ĉiu. Alie ni devus ion kiel jene:

>>> Animals1 = 'aardvark'
>>> Animals2 = 'urso hormiguero'
>>> Animals3 = 'antilopo'
>>> Animals4 = 'Albert "
>>>

Tio igas laborante kun ĉiuj kordoj kiel grupo tre malmola, speciale se vi havas centojn aŭ milojn (aŭ eĉ milionoj) de malsamaj kordoj, ke vi volas stokitaj en listo. Uzante la rektaj krampoj, vi povas trakti artikoloj en la listo nur kiel ajna alia valoro. Provu tajpi bestoj [0] + bestojn [2] en la ŝelon:

>>> Bestoj [0] + bestojn [2]
'Aardvarkantelope'
>>>

Ĉar bestoj [0] taksas la ĉeno 'aardvark' kaj bestoj [2] taksas la ĉeno 'antilopo', tiam la esprimo bestoj [0] + bestojn [2] estas la sama kiel 'aardvark' + 'antilopo'. Tiu ĉeno kunmeto taksas al 'aardvarkantelope'.
Kio okazas se ni eniras indico ke estas pli granda ol la listo pli granda indekso? Provu tajpi bestoj [4] aŭ bestoj [99] en la ŝelon:

>>> Bestoj = ['aardvark', 'urso hormiguero', 'antilopo', 'Albert']
>>> Bestoj [4]
Traceback (plej lasta alvoko lasta):
Dosieron " », Linio 1, en
bestoj [4]
IndexError: listo indekso ekster atingo
>>> Bestoj [99]
Traceback (plej lasta alvoko lasta):
Dosieron " », Linio 1, en
bestoj [99]
IndexError: listo indekso ekster atingo
>>>

Se vi provos alirante indico ke estas tro granda, vi ricevos indekso eraro.

Ŝanĝi la Valoroj de Listo Items kun Indekso Atribuo

Vi povas ankaŭ uzi la rektaj krampoj por ŝanĝi la valoron de elemento en listo. Provu tajpi bestoj [1] = 'Anteater', tiam tipo bestoj por vidi kiel la listo.

>>> Bestoj = ['aardvark', 'urso hormiguero', 'antilopo', 'Albert']
>>> Bestoj [1] = 'Anteater'
>>> Bestoj
['Aardvark', 'Anteater', 'antilopo', 'Albert']
>>>

La dua listero en la bestoj listo estis anstataŭigi per nova linio.

Listo kunmeto

Vi povas aliĝi lertaj kune en unu listo kun la + operatoro, kiel vi povas aliĝi kordoj. Kiam kunigi lertaj, ĉi tiu estas sciata kiel listo kunmeto. Provu tajpi [1, 2, 3, 4] + ['pomojn', 'oranĝoj'] + ['Alico', 'Bob'] en la ŝelon:

>>> [1, 2, 3, 4] + ['pomojn', 'oranĝoj'] + ['Alico', 'Bob']
[1, 2, 3, 4, 'pomojn', 'oranĝoj', 'Alico', 'Bob']
>>>

Rimarku ke listoj ne devas stoki valoroj de la sama datumtipoj. La ekzemplo pli supre havas liston kun ambaŭ entjeroj kaj kordoj en ĝi. Memoru, kiam vi faras listo kunmeto, vi devas aldoni kune du listo valoroj. ['Pomojn'] + ['oranĝoj'] taksos al ['pomojn', 'oranĝoj']. Sed ['pomojn'] + 'oranĝoj' rezultos en eraron ĉar vi aldonante listo valoro kaj kordoj valoro anstataŭ du listo valoroj. Se vi volas aldoni ne-listo valorojn al listo, uzu la append () metodo (kiu estas priskribita poste).

La en Operatoro

La en operatoro faciligas vidi se valoro estas ene liston aŭ ne. Esprimoj kiuj uzas la en operatoro reveni Bulea valoro: True se la valoro estas en la listo kaj Falsa se ​​la valoro ne estas en la listo. Provu tajpi 'antilopo' en bestoj en la ŝelon:

>>> Bestoj = ['aardvark', 'urso hormiguero', 'antilopo', 'Albert']
>>> 'Antilopo' en bestoj
Vera
>>>

La esprimo 'antilopo' en bestoj revenas Vera ĉar la ĉeno 'antilopo' povas trovi en la listo, bestoj. (Ĝi situas ĉe indekso 2.)
Sed se ni tajpi la esprimo 'formiko' en bestoj, tiu revenos Falsa ĉar la ĉeno 'formiko' ne ekzistas en la listo. Ni povas provi la esprimo 'formiko' en ['skarabo', 'vespo', 'formiko'], kaj vidas ke ĝi revenos Vera.

>>> Bestoj = ['aardvark', 'urso hormiguero', 'antilopo', 'Albert']
>>> 'Antilopo' en bestoj
Vera
>>> 'Formiko' en bestoj
Falsaj
>>> 'Formiko' en ['skarabo', 'vespo', 'formiko']
Vera
>>>

La en operatoro ankaŭ laboras por kordoj kaj ankaŭ listojn. Vi povas kontroli se oni string ekzistas en alia same vi povas kontroli ĉu valoro ekzistas en listo. Provu tajpi 'saluton' en 'Alico diris saluton al Bob.' En la ŝelo. Tiu esprimo taksos al True.

>>> 'Saluton' en 'Alico diris saluton al Bob.
Vera
>>>

Forigado Items el Listoj kun del Deklaroj

Vi povas forigi elementojn el listo kun del komunikaĵo. ("Del" estas mallongigo de "delete".) Provu kreante liston de nombroj tajpante: spamado = [2, 4, 6, 8, 10] kaj poste del spamado [1]. Tajpi spamado por vidi kiel la listo de enhavo:

>>> Spamado = [2, 4, 6, 8, 10]
>>> Del spamado [1]
>>> Spamado
[2, 6, 8, 10]
>>>

Rimarku, ke kiam vi forviŝita la eron je indico 1, la eron kiu kutimis esti je indekso 2 fariĝis la nova valoro je indekso 1. La eron kiu kutimis esti je indico 3 movis al esti la nova valoro je indico 2. Ĉio supre la eron kiun ni deleted moviĝis laŭ unu indekso. Ni povas tajpi del spamado [1] denove kaj denove konservi viŝante erojn el la listo:

>>> Spamado = [2, 4, 6, 8, 10]
>>> Del spamado [1]
>>> Spamado
[2, 6, 8, 10]
>>> Del spamado [1]
>>> Spamado
[2, 8, 10]
>>> Del spamado [1]
>>> Spamado
[2, 10]
>>>

Nur memoras ke del estas deklaro, ne funkcio aŭ operatoro. Ĝi ne taksas ajnan reveno valoro.

Listoj de Listoj

Listoj estas datumtipo kiu povas enhavi aliajn valorojn kiel artikoloj en la listo. Sed tiuj artikoloj ankaŭ povas esti aliaj listoj. Imagu ke vi havas liston de papersakon, liston de taskoj, kaj liston de viaj preferataj kukaĵojn. Vi povas meti ĉiuj tri de ĉi tiuj listoj en alian liston. Provu tajpi ĉi tiu enen la ŝelo:

>>> Papersakon = ['ovojn', 'lakton', 'supo', 'pomojn', 'pano']
>>> Taskoj = ['pura', 'Mow la gazono', 'go grocery aĉetoj']
>>> FavoritePies = ['pomo', 'frumbleberry']
>>> ListOfLists = [papersakon, taskoj, favoritePies]
>>> ListOfLists
[['Ovojn', 'lakton', 'supo', 'pomojn', 'pano'], ['pura', 'Mow la gazono', 'go grocery aĉetoj'], ['pomo', 'frumbleberry'] ]
>>>

Vi povus ankaŭ tajpi la sekva kaj akiri la samajn valorojn por ĉiuj kvar variabloj:

>>> ListOfLists = [['ovojn', 'lakton', 'supo', 'pomojn', 'pano'], ['pura', 'Mow la gazono', 'go grocery aĉetoj'], ['pomo' , 'frumbleberry']]
>>> Papersakon = listOfLists [0]
>>> Taskoj = listOfLists [1]
>>> FavoritePies = listOfLists [2]
>>> Papersakon
['Ovojn', 'lakton', 'supo', 'pomojn', 'pano']
>>> Taskoj
['Pura', 'Mow la gazono', 'go grocery aĉetoj']
>>> FavoritePies
['Pomo', 'frumbleberry']
>>>

Al preni artikolon interne la listo de listoj, vi uzus du aroj de kvadrataj krampoj, kiel jene: listOfLists [1] [2] kiu pritaksi la ĉeno 'iras grocery aĉetoj'. Ĉi tiu estas ĉar listOfLists [1] taksas al la listo ['pura', 'Mow la gazono', 'go grocery aĉetoj'] [2]. Kiu fine taksas al 'iras grocery aĉetoj'.
Jen alia ekzemplo de listo de listoj, kune kun kelkaj el la indeksas tiu punkto al la artikoloj en la listo de lertaj nomata x. La ruĝa sagoj indikas indeksas de la interna lertaj mem. La bildo estas ankaŭ spegulita sur lia flanko por plifaciligi legi:

Figuro 9-1: La indicoj de listo de listoj.

Metodoj

Metodoj estas simple kiel funkcioj, sed ili ĉiam alfiksita al valoro. Ekzemple, ĉiuj kordoj valoroj havas pli malaltan () metodon, kiu resendas kopion de la kordo valoro en minuskla. Vi ne povas simple nomi suba () per sin kaj vi ne pasas ĉenon argumento por malsupreniri () per sin (kiel en suba ('Saluton')). Vi devas atribui la metodo alvoko al specifa ŝnuro valoron uzante periodo.

La suba () kaj supra () String Metodoj

Provu eniri 'Saluton mondo!'. Malsupreniri () en la interaga ŝelo por vidi ekzemplon de tiu metodo:

>>> 'Saluton mondo. Malsupreniri ()
'Saluton mondo!'
>>>

Estas ankaŭ supra () metodon por kordoj, kiu ŝanĝas la tutan signoj en cxeno al majuskla. Provu eniri 'Saluton mondo. Supra () en la ŝelon:

>>> 'Saluton mondo. Supra ()
'HELLO MONDO! '
>>>

Ĉar la supra () metodo revenas cxeno, vi povas voki metodon en tiu ĉeno tiel. Provu tajpi 'Saluton mondo!'. Supra (). Malsupreniri () en la ŝelon:

>>> 'Saluton mondo. Supra (). Malsupreniri ()
'Saluton mondo!'
>>>

'Saluton mondo!'. Supra () taksas la ĉeno 'HELLO MONDO!', Kaj tiam ni nomas ke kordoj de suba () metodo. Ĉi redonas la ĉeno 'saluton mondo!', Kiu estas la fina valoro en la taksado. La ordo estas grava. 'Saluton mondo!'. Malsupreniri (). Supra () ne estas la sama kiel 'Saluton mondo!'. Supra (). Malsupreniri ():

>>> 'Saluton mondo. Malsupreniri (). Supra ()
'HELLO MONDO!'
>>>

Memoru, se cxeno estas stokita en variablo, vi povas nomi ĉenon metodo en tiu variablo. Rigardu ĉi tiun ekzemplon:

>>> Fizz = 'Saluton mondo "
>>> Fizz.upper ()
'HELLO MONDO'
>>>

La dorsflanko () kaj append () Listo Metodoj

La listo datumtipo ankaŭ havas metodojn. La dorsflanko () metodo inversigi la ordon de la elementoj en la listo. Provu eniri spamado = [1, 2, 3, 4, 5, 6, 'Meow', 'woof'], kaj poste spam.reverse () por inversigi la listo. Tiam eniras spamado por vidi la enhavon de la variablo.

>>> Spamado = [1, 2, 3, 4, 5, 6, 'Meow', 'woof']
>>> Spam.reverse ()
>>> Spamado
['Woof', 'Meow', 6, 5, 4, 3, 2, 1]
>>>

La plej komuna listo metodo vi uzos estas aldonas (). Ĉi tiu metodo aldonos la valoro pasas kiel argumento al la fino de la listo. Provu tajpi la sekva en la ŝelon:

>>> Ovojn = []
>>> Eggs.append ('aerodeslizador')
>>> Ovojn
['Aerodeslizador']
>>> Eggs.append ('angiloj')
>>> Ovojn
['Aerodeslizador', 'angiloj']
>>> Eggs.append (42)
>>> Ovojn
['Aerodeslizador', 'angiloj', 42]
>>>

Kvankam kordoj kaj listo datumtipoj havas metodojn, entjeroj ne okazas havi neniun metodoj.

La Diferenco Inter Metodoj kaj Funkcioj

Vi povas demandi kial Python havas metodojn, ĉar ili ŝajnas agi samkiel funkcioj. Iuj datumtipoj havas metodojn. Metodoj estas funkcioj asociita kun valoroj de tiu datumtipo. Ekzemple, kordoj metodoj estas funkcioj kiuj povas tuŝi ajna linio. Se vi havas la kordo valoro 'Saluton', vi povus voki la kordo metodo supra () tiamaniere: 'Saluton'. Supra (). Aŭ se la kordo 'Saluton' estis stokitaj en variablo nomata spamado, ĝi aspektus tiel: spam.upper ()
Vi ne povas nomi ĉenon metodoj sur valoroj de aliaj datumtipoj. Ekzemple, [1, 2, 'pomo']. Supra () kaŭzus eraron ĉar [1, 2, 'pomo'] estas listo kaj supra () estas ĉeno metodo.
La valoroj de datumtipoj kiuj havas metodojn estas nomitaj ankaŭ objektoj. Objekteman programadon estas iom antaŭis por ĉi tiu libro, kaj vi ne bezonas kompreni ĝin por fari ludojn. Nur kompreni ke celoj estas alia nomo por valoroj de datumtipoj kiuj havas metodojn. Ekzemple, ĉiuj kordoj kaj lertaj estas celoj.

La divido () Listo Metodo

Linio 59 estas tre longa linio de kodo, sed estas vere nur simpla asigno komunikaĵo. Tiu linio ankaŭ uzas la disiĝo () metodon, kiu estas metodo por la kordo datumtipo (ĝuste kiel la suba () kaj supra () metodoj).

59. vortoj = 'formiko babuino antilopaj bat urso kastoro kamelo kato mitulo kobron pumo kojoto korvo cervo hundo azeno anaso aglo hurón vulpo rano kapron ansero falko leono lacerto lamo talpo simio alkoj muso mulo Salamandroj lutro strigo panda papago kolombo python kuniklo virsxafo rato raven rinocero salmo stampo ŝarko ŝafoj skunk mallaborema serpento araneo cikonio cigno tigro bufo truto meleagro testudo mustelo baleno lupo Wombat zebro '. split ()

Kiel vi povas vidi, ĉi tiu linio estas nur unu tre longa ŝnuro, plena de vortoj disigitaj per spacoj. Kaj je la fino de la ŝnuro, ni nomas la disdivido () metodo. La divido () metodo ŝanĝas tiu longa ĉeno en listo, kun ĉiu vorto konsistigas unu listeron. La "split" okazas kie ajn spaco okazas en la kordo. La kialo ni faru ĝin tiamaniere, anstataŭ simple skribi la listo, estas ke ĝi estas pli facile por ni por tajpi kiel unu longa linio. Se ni kreis ĝin kiel listo por komenci, ni devus skribi: ['formiko', 'babuino', 'melo', ... kaj tiel plu, kun citaĵoj kaj komojn por ĉiu unuopa vorto.
Por ekzemplo de kiel la disiĝo () kordoj metodo funkcias, provu tajpi ĉi tiu enen la ŝelo:

>>> Mia tre energia patrino apenaŭ utilis al ni naŭ kukaĵojn '. Split ()
['Mia', 'tre', 'energia', 'patrino', 'nur', 'utilis', 'ni', 'naŭ', 'kukaĵojn']
>>>

La rezulto estas listo de naŭ kordojn, unu cxeno por ĉiu el la vortoj en la originala linio. La spacoj estas falis el la artikoloj en la listo. Iam ni nomas split (), la vortoj listo enhavos ĉiujn eblajn sekretaj vortoj kiuj povas esti elektita de la komputilo por nia Pendumito ludo. Vi ankaŭ povas aldoni viajn proprajn vortojn al la ĉeno, aŭ forigi iun ajn vi ne volas esti en la ludo. Nur certigi ke la vortoj estas disigitaj per spacoj.

Kiel la Kodo Verkoj

Komencante en linio 61, ni difini nova funkcio nomita getRandomWord (), kiu havas solan parametro nomata vortlisto. Ni nomas tiun funkcion kiam ni volas repreni sola sekreto vorton el listo de sekretaj vortoj.

61. def getRandomWord (vortlisto):
62. # Ĉi tiu funkcio redonas hazarda kordoj de la pasinta listo de kordoj.
63. wordIndex = random.randint (0, len (vortlisto) - 1)
64. revenu vortlisto [wordIndex]

La funkcio getRandomWord () estas pasita liston de ĉenoj kiel argumento por la vortlisto parametro. On line 63, ni stoki hazarda indekso por ĉi tiu listo en la wordIndex variablo. Ni faras tion per nomante randint () kun du argumentojn. Memoru ke argumentoj en funkcio estas apartigitaj per komoj, do la unua argumento estas 0 kaj la dua argumento estas len (vortlisto) - 1. La dua argumento estas esprimo kiu unue taksita. Len (vortlisto) redonos la entjero grandeco de la listo pasis al getRandomWord (), kaj poste ni subtrahi unu.
La kialo ni bezonas la - 1 estas ĉar la indeksoj por lertaj starti je 0, ne 1. Se ni havas liston de tri eroj, la indekso de la unua ero estas 0, la indekso de la dua elemento estas 1, la indekso de la tria ero estas 2. La longo de ĉi tiu listo estas 3, sed la indekso 3 estas post la lasta indico. Jen kial ni subtrahi 1 de la longo.
Ekzemple, se ni pasis ['pomo', 'oranĝa', vinbero '] kiel argumento por getRandomWord (), tiam len (vortlisto) revenus la entjero 3 kaj la esprimo 3 - 1 estus taksi la entjero 2.
Tio signifas ke wordIndex enhavus la reveno valoro de randint (0, 2), kiu signifas wordIndex egalus 0, 1, aŭ 2. On line 64, ni devus redoni la elemento en vortlisto ĉe la entjera indekso stokitaj en wordIndex.
Ni ŝajnigi ni ne sendu ['pomo', 'oranĝa', vinbero '] kiel la argumento al getRandomWord () kaj ke randint (0, 2) respondis la entjero 2. Tio signifus ke linion 64 igus reveno vortlisto [2], kiu taksas reveni 'vinbero'. Jen kiel la getRandomWord () redonas hazarda kordoj en la vortlisto listo. La sekva kodo eniris en la interaga konko pruvas jena:

>>> WordIndex = 2
>>> Print (wordIndex)
2
>>> Print (['pomo', 'oranĝa', 'vinbero'] [wordIndex])
vinbero
>>>

Kaj memoru, ni povas pasi ajna listo de kordoj ni volas la getRandomWord () funkcio, kiu estas kio faras ĝin tiel utila por nia Pendumito ludo.

Montrante la Estraro al la Ludanto

Ni tuj devas krei alian funkcion kiu presi la ekzekutisto tabulo sur la ekrano, kune kun kiom da literoj la ludanto havas ĝuste (kaj malĝuste) divenis.

66. def displayBoard (HANGMANPICS, missedLetters, correctLetters, secretWord):
67. print (HANGMANPICS [len (missedLetters)])
68. print ()

Tiu kodo difinas nova funkcio nomata displayBoard (). Ĉi tiu funkcio havas kvar parametroj. Ĉi tiu funkcio estos apliki la kodo por la "Montru la estraro kaj spacoj por la ludanto" skatolo en nia fluo abako. Jen kion ĉiu parametro signifas:

• HANGMANPICS - Jen listo de plurliniaj kordoj kiuj montras la tabulon kiel ASCII arto. Ni ĉiam pasas la tutmonda HANGMANPICS variablo kiel la argumento por tiu ĉi parametro.
• missedLetters - Ĉi tiu estas cxeno konsistas el la literoj de la ludanto divenis kiuj ne estas en la sekreta vorto.
• correctLetters - Ĉi tiu estas cxeno konsistas el la literoj de la ludanto divenis kiu estas en la sekreta vorto.
• secretWord - Ĉi linio estas la sekreta vorto, kiun la ludanto provas diveni ..

La unua impreso () funkcion alvoko montras la tabulon. HANGMANPICS estos liston de ĉenoj por ĉiu ebla tabulo. HANGMANPICS [0] montras malplenan pendigilo, HANGMANPICS [1] montras la kapo (ĉi okazas kiam la ludanto perdas unu litero) , HANGMANPICS [2] montras kapo kaj korpo (ĉi okazas kiam la ludanto misses du literoj), kaj tiel plu ĝis HANGMANPICS [6], kiam la plena ekzekutisto estas montrita kaj la ludanto malvenkas.
La nombro de literoj en missedLetters diros al ni, kiom da malĝusta divenas la ludanto faris. Ni povas nomi longo (missedLetters) por trovi tiun nombron. Ĉi tiu nombro povas ankaŭ esti uzita kiel la indekso al la HANGMANPICS listo, kiun ni permesos presi la korekta estraro por la nombro de malĝusta divenas. Do, se missedLetters estas 'aetr' tiam len ('aetr') revenos 4 kaj ni montros la kordoj HANGMANPICS [4]. Jen kion HANGMANPICS [len (missedLetters)] taksas al. Tiu linio montras la ĝustan ekzekutisto estraro al la ludanto.

70. print ('Missed literoj:', fino = '')
71. cxar leteron en missedLetters:
72. print (litero, fino = '')
73. print ()

Linio 71 estas nova tipo de ciklo, nomata por buklo. A por buklo estas tia kiel dum ciklo. Linio 72 estas en la tuta korpo de la por buklo. La gamo () funkcio estas ofte uzata kun por bukloj. Mi klarigos ambaŭ en la du sekvaj sekcioj.
Memoru ke la ŝlosilvorto argumento fino = '' uzas nur unu signo = (kiel =), ne du (kiel ==).

La gamo () kaj listo () Funkcioj

La gamo () funkcio estas facila de kompreni. Vi povas nomi ĝin per aŭ unu aŭ du entjeraj argumentoj. Kiam nomas per unu argumento, gamo () revenos gamon objekto de entjeroj de 0 ĝis (sed ne inkludita) la argumenton. Ĉi tiu gamo objekto povas esti konvertita al la pli familiara listo datumtipo kun la listo () funkcio. Provu tajpi listo (gamo (10)) en la ŝelon:

>>> Listo (gamo (10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>

La listo () funkcio estas tre simila al la str () aŭ int () funkcioj. Ĝi simple konvertas la objekto estas pasis en listo. Estas tre facile generi grandega lertaj kun la limigo () funkcio. Provu tajpi en listo (gamo (10000)) en la ŝelon:

>>> Listo (gamo (10000))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, ...
... La teksto tie estas saltis por mallongeco ...
... 9989, 9990, 9991, 9992, 9993, 9994, 9995, 9996, 9997, 9998, 9999]
>>>

La listo estas tiom grandega, ke ĝi ne inkluzive ĉiuj adapti sur la ekrano. Sed ni povas savi la listo en la variablo nur kiel ajna alia listo enirante jena:

>>> Spamado = listo (gamo (10000))
>>>

Se vi pasos du argumentoj por gamo (), la listo de entjeroj denove estas de la unua argumento ĝis (sed ne inkludita) la dua argumento. Provu tajpi listo (gamo (10, 20)) en la ŝelon:

>>> Listo (gamo (10, 20))
[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
>>>

La gamo () estas tre utila funkcio, ĉar ni ofte uzas ĝin en por maŝojn (kio estas tre ŝatas la dum maŝojn ni jam vidis).

por Loops

La por ciklo estas tre bona en looping super listo de valoroj. Tiu estas malsama de la dum ciklo, kiu cikloj dum certa kondiĉo estas vera. A por komunikaĵo komencas kun la ŝlosilvorto por, sekvita de variablo nomo, sekvita de la en ŝlosilvorto, sekvita de vico (tiaj kiel listo aŭ linio) aŭ gamon objekto (revenis por la gamo () funkcio), kaj tiam dupunkto. Ĉiufoje la programo ekzekuto iras tra la buklo (tio estas, en ĉiu ripeto tra la buklo) La variablo en la por komunikaĵo prenas la valoro de la venonta artikolo en la listo.
Ekzemple, vi simple lernis ke la limigo () funkcio estos redoni listo de entjeroj. Ni uzos tiun liston kiel la por komunikaĵo-listo. En la ŝelon, tipo por i en gamo (10): kaj premu Eniru. Nenio okazos, sed la ŝelon estos indent la kursoro kaj ŝanĝi la prompto el >>> al ... ĉar ĝi atendas vin por tajpi en la por-bloko. Tipo print (i) kaj premu Eniru. Tiam, por diri al la interaga konko vi faras skribante en la por-bloko, premi Enter denove por enmeti malplenan linion. La ŝelo estos tiam ekzekuti viajn por komunikaĵo kaj bloko:

>>> Por mi en gamo (10):
... print (i)
...
0
1
2
3
4
5
6
7
8
9
>>>

Rimarku ke kun por bukloj, vi ne devas konverti la gamo objekto revenis por la gamo () funkcio en listo kun listo (). Por maŝojn faru tion por ni aŭtomate.
La por buklo ekzekutas la kodon ene de la por-bloko unufoje por ĉiu ero en la listo. Ĉiufoje ĝi ekzekutas la kodon en la por-bloko, la variablo i atribuas la sekvanta valoro de la venonta artikolo en la listo. Se ni uzas la por komunikaĵo kun la listo [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] anstataŭ gamo (10), ĝi estus la sama:

>>> Por i en [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]:
... print (i)
...
0
1
2
3
4
5
6
7
8
9
>>>

La por komunikaĵo aŭtomate konvertas la gamo objekto revenis por gamo () en listo, do ne estas neceso por meti ion kiel listo (gamo (10)) en la por statemet, simple aliru gamo (10).
Provu tajpi ĉi tiu enen la ŝelo, ĉar aĵo en ['katoj', 'pasto', 'programadon', 'spam']: kaj premi Enter, kaj poste presas ('Mi vere ŝatas' + aĵo) kaj premu Enter, kaj poste premi Enter denove por diri al la ŝelon por fini la por-bloko. La eligo devus aspekti kiel ĉi:

>>> Por aĵo en ['katoj', 'pasto', 'programadon', 'spam']:
... print ('Mi vere ŝatas' + aĵo)
...
Mi vere ŝatas katojn
Mi vere ŝatas pasto
Mi vere ŝatas programado
Mi vere ŝatas spamado
>>

Kaj memoru, ĉar kordoj estas ankaŭ vico datumtipo samkiel lertaj, vi povas uzi ilin en por deklaroj kiel bone. Ĉi tiu ekzemplo uzas solan karakteron de la kordoj sur ĉiu ripeto:

>>> Por mi en 'Saluton mondo!':
... print (i)
...
H
TTT
l
l
o

w
o
r
l
d
!
>>>

Al dum Cirkla Ekvivalento de a por Cirkla

La por ciklo estas tre simila al la dum ciklo, sed kiam vi nur bezonas persisti super artikoloj en listo, uzante por buklo estas multe malpli kodo tipo. Vi povas fari dum buklo kiu agas same kiel por buklo aldonante ekstrajn kodo:

>>> Vico = ['katoj', 'pasto', 'programadon', 'spam']
>>> Indekso = 0
>>> Dum (indekso <len (vico)):
... afero = vico [indekso]
... print ('Mi vere ŝatas' + aĵo)
... indekso = indekso + 1
...
Mi vere ŝatas katojn
Mi vere ŝatas pasto
Mi vere ŝatas programado
Mi vere ŝatas spamado
>>>

Sed uzante la por komunikaĵo aŭtomate faras ĉiujn ĉi ekstra kodo por ni kaj faras programado facile ekde ni havi malpli tajpi. Nia Pendumito ludo uzos por bukloj tiel vi povas vidi kiel utila estas en realaj ludoj.
Unu pli afero pri por bukloj, estas ke la por komunikaĵo havas la ŝlosilvorto en ĝi. Sed kiam vi uzas la en ŝlosilvorto en por komunikaĵo, Python ne traktas ĝin kiel la en operatoro vi uzus en iu kiel 42 en [0, 42, 67]. La en ŝlosilvorto en por deklaroj estas nur uzata por apartigi la variablo kaj la lerta alvenas siajn valorojn de.
La resto de la displayBoard () funkcio vidigas la missed literojn kaj kreas la kordoj de la sekreta vorto kun ĉiuj unguessed literoj kiel spacoj.

print ('Missed literoj:', fino = '')
cxar leteron en missedLetters:
print (litero, fino = '')
print ()

Ĉi por buklo sur linio 71 montros ĉiujn missed divenas, ke la ludanto faris. Kiam vi ludas Pendumito sur papero, oni kutime noti tiujn literojn sur la flanko do vi ne scias diveni ilin denove. Sur ĉiu ripeto de la ciklo de la valoro de letero estos ĉiu litero en missedLetters laŭvice.

Memoru ke la fino = '' anstataŭos la linion karakteron kiu estas presita post la ŝnuro kun sola spaceto.
Se missedLetters estis 'ajtw' tiam ĉi por buklo estus montri ajtw.Tranĉaĵoj kaj Slicing
Se ni volas ricevi pli mallongaj kopion de kelkaj el la eroj en listo, ni povas uzi listo slicing. Slicing kreas duplikatajn listo el iuj aŭ ĉiuj el la eroj en alia listo. En kodo, ni povas krei tranĉaĵo de listo de preciziganta du indeksoj (la komenco kaj fino) kaj dupunkto. Ekzemple, tajpu la sekvajn en la interaga konko:>>> Spamado = ['pomojn', 'oranĝoj', 'pirojn', 'bananoj']>>> Ovojn = spamado [1:3]>>> Ovojn['Oranĝoj', 'pirojn']
La esprimo spamado [0:2] taksas al listo kiu enhavas ĉiujn erojn de indekso 0 ĝis (sed ne inkludita) indekso 2 en spamado. Ni stokas tiun malgrandan liston en la variablo ovojn.
Se vi ellasas la unuan indicon, Python aŭtomate kredas ke vi volas specifi indekso 0 por la unua indico:>>> Spamado = ['pomojn', 'oranĝoj', 'pirojn', 'bananoj']>>> Spamado [: 3]['Pomojn', 'oranĝoj', 'pirojn']
Se vi ellasas la dua indico, Python aŭtomate kredas ke vi volas specifi la resto de la listo:>>> Spamado = ['pomojn', 'oranĝoj', 'pirojn', 'bananoj']>>> Spamado [1:]['Oranĝoj', 'pirojn', 'bananoj']
Slicing estas simpla maniero atingi subaro de la eroj en listo. Vi povas ankaŭ uzi tranĉaĵoj kun kordoj en la sama maniero vi uzas ilin kun listoj. Ĉiu karaktero en la kordo estas kiel eron en la listo. Provu tajpi la sekva en la ŝelon:>>> MyName = 'Zophie la Dika Kato'>>> MyName [4:12]'Kio estas la C'>>> MyName [: 10]'Zophie la'>>> MyName [7:]'La Dika Kato'>>>
Tranĉaĵoj estas uzataj en la venonta parto de la kodo, ni rigardu.Montrante la Sekreta Vorto kun Blanks
Do per ĉi tiu punkto ni montris la ludanto la ekzekutisto estraro kaj la missed literoj. Nun ni volas presi la sekreta vorto, krom ni volas malplenajn liniojn por la literoj. Ni povas uzi la _ karaktero (nomata substreki karaktero) por ĉi tio. Sed ni devas presi la literoj en la sekreta vorto, kiun la ludanto divenis, kaj uzu _ karakterojn por la literoj de la ludanto ne divenis ankoraŭ. Ni povas unue krei ĉenon kun nenio krom unu substreki por ĉiu litero en la sekreta vorto. Tiam ni povas anstataŭigi de spacoj por ĉiu litero en correctLetters. Do se la sekreta vorto estis 'lutro' tiam la blanked el kordoj devus esti '_____' (kvin _ karakteroj). Se correctLetters estis la ĉeno 'rt' tiam ni volus ŝanĝi la blanked ŝnuro al '_tt_r'. Jen la kodo kiu faras tion:

    spacoj = '_' * len (secretWord)
    por i en gamo (len (secretWord)): # anstataŭi spacoj kun korekte divenis literoj
    se secretWord [i] en correctLetters:
    spacoj = spacoj [: i] + secretWord [i] + spacoj [i +1:]
    cxar leteron en spacoj: # montras la sekretan vorton kun spacoj inter ĉiu litero
Linio 75 kreas la spacoj variablo plena de _ substrekoj uzante string replicación. Memoru ke la * operatoro povas ankaŭ kutimi sur ŝnuro kaj entjero, do la esprimo 'saluton' * 3 taksas al 'hellohellohello'. Tio certigas, ke spacoj havas la saman nombron da substrekoj kiel secretWord havas literojn.
Tiam ni uzas por buklo iri tra ĉiu litero en secretWord kaj anstataŭi la substreki kun la efektiva letero se ĝi ekzistas en correctLetters. Linio 79 eble aspektas malklara. Ŝajnas ke ni uzas la rektaj krampoj kun la spacoj kaj secretWord variabloj. Sed atendu dua, spacoj kaj secretWord estas kordoj, ne listoj. Kaj la len () funkcio ankaŭ nur prenas lertaj kiel parametroj, ne kordoj. Sed en Python, multaj de la aferoj, kiujn vi povas fari por lertaj vi povas ankaŭ fari por kordoj kiel replicación, indeksado, kaj slicing.Anstataŭante la substrekoj kun korekte divenis Literoj

    por i en gamo (len (secretWord)): # anstataŭi spacoj kun korekte divenis literoj
    se secretWord [i] en correctLetters:
    spacoj = spacoj [: i] + secretWord [i] + spacoj [i +1:]
Ni pretendi la valoro de secretWord estas 'lutro' kaj la valoro en correctLetters estas 'tr'. Tiam len (secretWord) revenos 5. Tiam gamo (len (secretWord)) iĝas gamo (5), kiu siavice redonas la listo [0, 1, 2, 3, 4].
Ĉar la valoro de i prenos sur ĉiu valoro en [0, 1, 2, 3, 4], tiam la por buklo kodo estas ekvivalento al ĉi tio:se secretWord [0] en correctLetters:spacoj = spacoj [: 0] + secretWord [0] + spacoj [1:]se secretWord [1] en correctLetters:spacoj = spacoj [: 1] + secretWord [1] + spacoj [2:]se secretWord [2] en correctLetters:spacoj = spacoj [: 2] + secretWord [2] + spacoj [3:]se secretWord [3] en correctLetters:spacoj = spacoj [: 3] + secretWord [3] + spacoj [4:]se secretWord [4] en correctLetters:spacoj = spacoj [: 4] + secretWord [4] + spacoj [5:]
(Parenteze, skribante el la kodo kiel ĉi estas nomita ciklo unrolling.)
Se vi estas malklaraj pro kio la valoro de io kiel secretWord [0] aŭ spacoj [3:] estas, tiam rigardu ĉi tiu foto. Ĝi montras la valoron de la secretWord kaj spacoj variabloj, kaj la indekso por ĉiu litero en la kordo.

Figuro 9-2: La indicoj de la spacoj kaj secretWord kordoj.
Se ni anstataŭigi la listo tranĉaĵoj kaj la listo indeksas kun la valoroj kiujn ili reprezentas, la malvolvis buklo kodo estus la sama kiel tiu:se 'o' en 'tr': # Falsa, spacoj == '_____'spacoj ='' + 'o' + '____' # Ĉi tiu linio estas ignorita.se 't' en 'tr': # Vera, spacoj == '_____'spacoj = '_' + 't' + '___' # Ĉi tiu linio estas ekzekutitaj.se 't' en 'tr': # Vera, spacoj == '_t___'spacoj = '_t' + 't' + '__' # Ĉi tiu linio estas ekzekutitaj.se 'e' en 'tr': # Falsa, spacoj == '_tt__'spacoj = '_tt' + 'kaj' + '_' # Ĉi tiu linio estas ignorita.se 'r' en 'tr': # Vera, spacoj == '_tt__'spacoj = '_tt_' + 'r' +'' # Ĉi tiu linio estas ekzekutitaj.# Spacoj nun havas la valoron '_tt_r'
La pli supre tri kodo ekzemploj ĉiuj faras la samon (almenaŭ, ili faras kiam secretWord estas 'lutro' kaj correctLetters estas 'tr'. La unua skatolo estas la reala kodo kiun ni havas en nia ludo. La dua skatolo montras kodo kiu faras la sama afero krom sen por buklo. La tria skatolo estas la sama kiel la dua kesto, krom ni taksis multaj de la esprimoj en la dua kesto.
La sekvaj linioj de kodo montri la nova valoro de spacoj kun spacoj inter ĉiu litero.

    cxar leteron en spacoj: # montras la sekretan vorton kun spacoj inter ĉiu litero
    print (litero, fino = '')
    print ()
Ĉi por buklo estos presi ĉiun karakteron en la kordo spacoj. Memoru ke nun, spacoj povas havi iu el liaj substrekoj anstataŭita de la literoj en secretWord. La fino ŝlosilvorto argumento en linio 82 de print () alvoko faras la impreso () funkcio metu spaceto fine de la kordo anstataŭ novan linion karaktero. Ĉi tio estas la fino de la displayBoard () funkcio.Get the ludanto Guess
La getGuess () funkcias ni kreas sekva nomos kiam ajn ni volas lasi la ludanto tipo en letero por diveni. La funkcio redonas la letero la ludanto divenis kiel linio. Plu, getGuess () estos certigi ke la ludanto tipoj validan letero antaŭ reveni de la funkcio.

    def getGuess (alreadyGuessed):
    # Returns la letero la ludanto eniris. Ĉi tiu funkcio certigas la ludanto eniris sola litero, kaj ne io alia.
La getGuess () funkcio havas ĉenon parametro nomis alreadyGuessed kiuj devus esti pasis cxeno kiu enhavas la literojn de la ludanto jam divenis, kaj petos la ludanto diveni sola litero. Ĉi sola litero estos la reveno valoro por ĉi tiu funkcio.

    Dum Bordo:
    print ('Divenu leteron.')
    diveni = input ()
    diveni = guess.lower ()
Ni uzos dum buklo ĉar ni volas konservi petante la ludanto leteron ĝis ili eniros teksto kiu estas sola litero ili ne divenis antaŭe. Rimarku ke la kondiĉo por la dum ciklo estas simple la Bulea valoro True. Tio signifas la sola maniero ekzekuto iam forlasi ĉi ciklo estas ekzekutante ripozon aserto (kiu lasas la buklo) aŭ return (kiu lasas la tuta funkcio). Tia ciklo estas nomata senfina ciklo, ĉar ĝi volas buklo ĉiam (krom se ĝi atingas ripozon deklaron).
La kodo ene la buklo petas la ludanton eniri leteron, kiu estas stokitaj en la variablo diveni. Se la ludanto eniris majusklon letero, estos konvertita al minuskla on line 90.elif ("Else Se") Deklaroj
Rigardu la sekva kodo:se catName == 'Fuzzball':presi ('Via kato estas nebula.')alie:presi ('Via kato ne estas tre nebula ajn.')
Ni vidis kodo kiel ĉi antaŭe kaj ĝi estas sufiĉe simpla. Se la catName variablo estas egala al la ĉeno 'Fuzzball', tiam la se aserto estas kondiĉo estas Vera kaj ni rakontas al la uzanto kiu lia kato estas nebula. Se catName estas io alia, tiam ni diros al la uzanto ŝia kato ne estas nebula.
Sed kion se ni volis ion alian krom "fuzzy" kaj "ne fuzzy"? Ni povis meti alian se kaj alia aserto ene la unua else bloko, kiel jene:se catName == 'Fuzzball':presi ('Via kato estas nebula.')alie:se catName == 'Spots'print ('Via kato estas malkovrita.')alie:print ('Via kato estas nek fuzzy nek ekvid.')
Sed se ni volis pli aĵoj, tiam la kodo komencas havi multan deŝovon:se catName == 'Fuzzball':presi ('Via kato estas nebula.')alie:se catName == 'Spots'print ('Via kato estas malkovrita.')alie:se catName == 'FattyKitty'presi ('Via kato estas grasa. ")alie:se catName == 'Puff'presi ('Via kato estas pufeca.')alie:print ('Via kato estas nek fuzzy nek makulitajn nek grason nek pufeca.')
Tajpi tiujn spacojn signifas ke vi havas pli da ŝancoj eraras kun la deŝovon. Do Python havas la elif ŝlosilvorto. Uzanta elif, la pli supre kodo aspektas jene:se catName == 'Fuzzball':presi ('Via kato estas nebula.')elif catName == 'Spots'print ('Via kato estas malkovrita.')elif catName == 'FattyKitty'presi ('Via kato estas grasa. ")elif catName == 'Puff'presi ('Via kato estas pufeca.')alie:print ('Via kato estas nek fuzzy nek makulitajn nek grason nek pufeca.')
Se la kondiĉo por la se aserto estas falsa, do la programo kontrolos la kondiĉo por la unua elif aserto (kiu estas catName == 'Spots'). Se tiu kondiĉo estas Falsa, tiam la programo kontrolos la kondiĉo de la sekvanta elif komunikaĵo. Se ĉiuj el la kondiĉoj por la se kaj elif asertoj estas falsaj, tiam la kodon en la alia bloko ekzekutas.
Sed se unu el la elif kondiĉoj estas Vera, la elif-bloko kodo estas ekzekutita kaj poste ekzekuto saltas malsupren al la unua linio preter la alia-bloko. Do nur unu el la blokoj en ĉi se-elif-ajn deklaro estos ekzekutita. Vi ankaŭ povas lasi for la alian-bloko, se vi ne bezonas, kaj ĝuste havi se-ajn aserto.Farante Certe la Ludanto Eniro a Valida Guess

    se len (guess)! = 1:
    print ('Bonvolu entajpi unu literon.')
    elif diveni en alreadyGuessed:
    print ('Vi jam divenis ke letero. Elektu denove.')
    elif diveni ne en 'ABCDEFGHIJKLMNOPQRSTUVWXYZ':
    print ('Bonvolu entajpi LETERO.')
    alie:
    revenu diveni
La guess variablo enhavas la tekston de la ludanto tajpita en por sia letero diveni. Ni devas certigi ke ili tajpis en unu kaj nur unu minuskla litero. Se ili ne, ni devus buklo dorso kaj peti ilin denove. La se aserto estas kondiĉo ĉekojn ke la teksto estas ununura litero. Se ne estas, tiam ni ekzekuti la se-bloko kodo, kaj tiam ekzekuto saltas malsupren preter la alia-bloko. Sed ĉar ne ekzistas pli kodo post ĉi se-elif-alie formulita, ekzekuto cikloj reen al linio 87.
Se la kondiĉo por la se aserto estas falsa, ni kontrolu la elif deklaro de kondiĉo sur linio 93. Ĉi tiu kondiĉo estas True se la letero ekzistas ene de la alreadyGuessed variablo (memoras, tiu estas ĉeno kiu havas ĉiu litero de la ludanto jam divenis). Se ĉi tiu kondiĉo estas vera, tiam ni montras la eraro mesaĝon al la ludanto, kaj salti malsupren preter la alia-bloko. Sed tiam ni devus esti je la fino de la tempo-blokon, tiel ekzekuto saltas reen ĝis linio 87.
Se la kondiĉo por la se propozicio kaj la elif aserto estas ambaŭ Falsa, tiam ni kontrolu la dua elif deklaro de kondiĉo sur linio 95. Se la ludanto tajpita en nombro aŭ amuzan karakteron (farante diveni havas valoro kiel '5 'aŭ'! '), Tiam diveni ne ekzistas en la ĉeno' ABCDEFGHIJKLMNOPQRSTUVWXYZ '. Se ĉi tiu estas la kazo, la elif deklaro de kondiĉo estas vera.
Figuro 9-3 estas ekzemplo de elif deklaroj. Krom se tiuj tri kondiĉoj estas ĉiuj Falsa, la kodo ne revenos kaj la buklo gardos petante leteron. Sed kiam ĉiuj tri el la kondiĉoj estas Falsa, tiam la alia-bloko la reveno deklaro kuros kaj ni eliru ĉi loop kaj funkcio.

Figuro 9-3: La elif komunikaĵo.Petante la Ludanto Al Ludu Denove

    def playAgain ():
    # Ĉi tiu funkcio redonas True se la ludanto volas ludi denove, alie False.
    presi ('Cu vidis volas Ludi denove? (yes au ne)')
    revenu enigo (). malsupreniri (). startswith ('y')
La playAgain () funkcio havas nur print () funkcion alvoko kaj return. La reveno aserto havas esprimo kiu aspektas komplika, sed ni povas klarigi ĝin. Iam ni taksi tiun esprimon al valoro, ke valoro estos reveninta de ĉi tiu funkcio.
La esprimo sur linio 103 ne havas neniun operatoroj, sed ĝi havas funkcion alvoko kaj du metodo alvokoj. La funkcio alvoko estas enigo () kaj la metodo alvokoj estas pli malaltaj () kaj startswith ('y'). Memoru ke metodo alvokoj estas funkcio alvokoj kiuj estas kunigitaj por periodo por la valoro maldekstre. malsupreniri () estas alfiksita al la reveno valoro de enigo ().
enigo () redonas kordoj de la teksto kiun la uzanto tajpas in Jen paŝo post paŝo rigardu kiel Python taksas tiun esprimon se la uzanto tajpas en YES.enigo (). malsupreniri (). startswith ('y')Al malsupren sagú'JES'. Malsupreniri (). Startswith ('y')Al malsupren sagú'Jes'. Startswith ('y')Al malsupren sagúBordo
La punkto de la playAgain () funkcio estas lasi la ludanto tipo en jes aŭ ne diri nia programo se ili volas ludi alian ĉirkaŭvojo de Pendumito. Se la ludanto tipoj en JES, tiam la reveno valoro de enigo () estas la ĉeno 'JES'. Kaj 'JES'. Malsupreniri () redonas la minuskla versio de la kuna kordoj. Do la reveno valoron de 'JES'. Malsupreniri () estas 'jes'.
Sed estas la dua metodo alvoko, startswith ('y'). Ĉi tiu funkcio redonas True se la asociita kordoj komencas kun la kordoj parametro inter la krampoj, kaj Falsa se ne. La reveno valoron de 'jes'. Startswith ('y') estas vera.
Nun ni taksis tiun esprimon! Ni povas vidi ke kion ĉi tio lasas la ludanto tipo en respondo, ni minuskla la respondo, kontrolu se komencas per la litero 'kaj' aŭ 'Y', kaj tiam revenu True se ĝi faras kaj Falsa se ĝi ne . Whew!
Sur flanko noto, estas ankaŭ endswith (someString) kordoj metodo kiu revenos True se la kordo finiĝas per la kordoj en someString kaj Falsa se ne. endswith () estas speco de kiel la malo de startswith ().Revizio de la Funkcioj Ni Difinita
Tio estas ĉiuj funkcioj ni kreas por ĉi tiu ludo!

    getRandomWord (vortlisto) prenos liston de ĉenoj pasis ĝin kiel parametro, kaj reveni unu cxeno de ĝi. Tio estas kiel ni elektos unu vorton por la ludanto diveni.
    displayBoard (HANGMANPICS, missedLetters, correctLetters, secretWord) montros la nuna stato de la tabulo, inkludante kiom de la sekreta vorto la ludanto divenis ĝis nun kaj la erara literojn la ludanto divenis. Ĉi tiu funkcio bezonas kvar parametroj pasitaj al funkcias ĝuste. HANGMANPICS estas listo de kordoj kiuj tenas la Arto ASCII por ĉiu ebla ekzekutisto tabulo. correctLetters kaj missedLetters estas ŝnuroj formita de la literoj kiuj la ludanto divenis, kiuj estas en kaj ne en la sekreta vorto. Kaj secretWord estas la sekreta vorto la ludanto provas diveni. Ĉi tiu funkcio ne havas reveno valoro.
    getGuess (alreadyGuessed) prenas ĉenon de literoj la ludanto jam divenis kaj gardos petante la ludanto leteron kiu estas letero ke li ne jam divenis. (Tio estas, litero kiu estas ne en alreadyGuessed.) Ĉi tiu funkcio redonas la kordoj de la akceptebla letero la ludanto divenis.
    playAgain () estas funkcio kiu petas se la ludanto volas ludi alian ĉirkaŭvojo de Pendumito. Ĉi tiu funkcio redonas True se la ludanto faras kaj Falsa se la ludanto ne.
Ni nun komencas la kodon por la ĉefa parto de la ludo, kiu vokos la supraj funkcioj kiel bezonataj. Kiel aktualigo, retrorigardas al nian fluon chart en Figuro 9-4.

Figuro 9-4: La kompleta fluo leteron de Pendumito.La Ĉefa Kodo por Pendumito
Ni devas skribi kodon kiu faras ĉion ĉi fluo abako, kaj faras ĝin en la ĝusta ordo. La ĉefa parto de la kodo komenciĝas ĉe linio 106. Ĉio antaŭa estis nur funkcio difinoj kaj tre granda enigaj variabloj por HANGMANPICS.Lancxi vian la Variabloj

    print ('HANGMA N')
    missedLetters =''
    correctLetters =''
    secretWord = getRandomWord (vortoj)
    gameIsDone = False
Linio 106 estas la unua reala linio kiu ekzekutas en nia ludo. Ni komencu per asignanta malplenan ĉenon por missedLetters kaj correctLetters, ĉar la ludanto ne divenis ajna missed aŭ ĝentila literoj ankoraŭ. Tiam ni nomas getRandomWord (vortoj), kie vortoj estas variablo kun la grandega listo de eblaj sekretaj vortoj ni atribuis on line 59. La reveno valoro de getRandomWord (vortoj) estas unu el tiuj vortoj, kaj ni konservu ĝin sur la secretWord variablo. Tiam ni ankaŭ establis variablo nomata gameIsDone al False. Ni starigos gameIsDone al Vera, kiam ni volas signali ke la ludo estas finita kaj la programo devus demandi al la ludanto se ili volas ludi denove.
Lancxi la valoroj de tiuj variabloj estas kion ni faros antaŭ la ludanto komencas diveni literoj.Montrante la Estraro al la Ludanto

    Dum Bordo:
    displayBoard (HANGMANPICS, missedLetters, correctLetters, secretWord)
La dum buklo la kondiĉo estas ĉiam vera, kio signifas ke ni volas ĉiam buklo eterne ĝis ripozon aserto estas renkontita. Ni ekzekuti ripozon deklaro kiam la ludo estas finita (aŭ ĉar la ludanto gajnis aŭ la ludanto perdita).
Linio 113 nomas nian displayBoard () funkcion, pasante ĝin la listo de ekzekutisto Arto ASCII pentraĵoj kaj la tri variabloj ni surtabligis linioj 107, 108, kaj 109. La ekzekuto movas al la komenco de displayBoard () en linio 66. Bazita sur kiom da literoj la ludanto ĝuste divenis kaj maltrafis, ĉi tiu funkcio vidigas la taŭga ekzekutisto estraro al la ludanto.Lasi la Ludanto Entajpu Ilia Guess

    # Lasu la ludanto tipo en letero.
    diveni = getGuess (missedLetters + correctLetters)
Se vi rigardas nian fluon abako, vi vidas nur unu sago iranta de la "Montru la estraro kaj de spacoj al la ludanto." skatolo por la "Demandu ludanto diveni leteron." skatolo. Kiel ni jam skribis funkcio por ricevi la divenon de la ludanto, ni nomas tiun funkcion. Memoru ke la funkcio bezonas ĉiuj literoj en missedLetters kaj correctLetters kombinitaj, do ni pasos kiel argumento ĉenon kiu estas kunmeto de ambaŭ el tiuj kordoj. Tiu argumento estas necesa por getGuess () ĉar la funkcio havas kodon por kontroli se la ludanto tipoj en letero, ke ili jam divenis.Kontrolanta se la Letero estas en la Sekreta Vorto

    se diveni en secretWord:
    correctLetters = correctLetters + diveni
Nun ni rigardu, ĉu la sola litero en la guess string ekzistas en secretWord. Se ĝi faras ekzisti, tiam ni devus concatenate la litero en diveni la correctLetters kordoj. Ni tuj povas kontroli se ni divenis ĉiuj de la literoj kaj gajnis.Kontrolanta se la ludanto estas Gajnitaj

    # Kontroli se la ludanto gajnis
    foundAllLetters = True
    por i en gamo (len (secretWord)):
    se secretWord [i] ne en correctLetters:
    foundAllLetters = False
    rompi
Kiel ni scias se la ludanto divenis ĉiu unuopa litero en la sekreta vorto? Nu, correctLetters havas ĉiu letero, kiun la ludanto ĝuste divenis kaj secretWord estas la sekreta vorto mem. Ni ne povas simple kontroli ĉu correctLetters == secretWord ĉar konsideras ĉi situacio: se secretWord estis la ĉeno 'lutro' kaj correctLetters estis la ĉeno 'Orte', tiam correctLetters == secretWord estus Falsa kvankam la ludanto divenis ĉiu litero en la sekreta vorto.
La ludanto simple divenis la literoj el ordo kaj ili ankoraŭ gajnas, sed nia programo malĝuste opinias la ludanto ne gajnis ankoraŭ. Eĉ se ili faris diveni la literojn en ordo, correctLetters estus la ĉeno 'oter' ĉar la ludanto ne povas diveni la letero t pli ol unufoje. La esprimo 'lutro' == 'oter' estus taksi al falsa kvankam la ludanto divenis ĉiuj literoj.
La sola maniero povas esti certa ke la ludanto gajnis estas iri tra ĉiu litero en secretWord kaj vidi se ĝi ekzistas en correctLetters. Se, kaj nur se, ĉiu unuopa litero en secretWord ekzistas en correctLetters estos la ludanto venkis.
Notu ke ĉi tiu estas malsama ol kontrolanta se ĉiu litero en correctLetters estas en secretWord. Se correctLetters estis la ĉeno 'ot' kaj secretWord estis 'lutro', estus vero, ke ĉiu litero en 'ot' estas en 'lutro', sed tio ne signifas la ludanto divenis la sekreton vorto kaj gajnis.
Do kiel ni povas fari ĉi tion? Ni povas buklo tra ĉiu litero en secretWord kaj se ni trovas leteron kiu ne ekzistas en correctLetters, ni scias, ke la ludanto ne divenis ĉiuj literoj. Jen kial ni kreu novan variablon nomata foundAllLetters kaj starigis gxin al la Bulea valoro True. Ni komencu marsxi supozante ke ni trovis ĉiuj literoj, sed ŝanĝos foundAllLetters al falsa kiam ni trovas leteron en secretWord kiu ne estas en correctLetters.
La por buklo iros tra la numeroj 0 ĝis (sed ne inkludita) la longo de la vorto. Memoru ke gamo (5) taksos al la listo [0, 1, 2, 3, 4]. Do on line 123, la programo ekzekutas la tuta kodo interne de la por-bloko kvinfoje. La unua fojo ekzekutas per la variablo i starigis al 0, la dua fojo starigis al 1, tiam 2, tiam 3, tiam fine 4.
Ni uzas gamo (len (secretWord)) por ke i povas esti uzata por aliri ĉiu litero en la sekreta vorto. Do se la unua letero en secretWord (kiu situas ĉe secretWord [0]) estas ne en correctLetters, ni scias ke ni povas agordi foundAllLetters al False. Ankaŭ, ĉar ni ne devas kontroli la resto de la literoj en secretWord, ni povas simple rompi ĉi ciklo. Alie, ni buklo reen al linio 123 kaj kontroli la venonta letero.
Se foundAllLetters sukcesas resti starigis al Vera, tiam ĝi observos la originala Vera valoro ni donis gxin. Ajna formo, la valoron en foundAllLetters estas preciza por kiam ni atingos pasinteco tion por buklo kaj kuri linio 127.

    se foundAllLetters:
    print ("Jes! La sekreta vorto estas" '+ secretWord +' "! Vi gajnis! ')
    gameIsDone = True
Tiu estas simpla ĉeko por vidi se ni trovas ĉiujn literojn. Se ni trovis ĉiu litero en la sekreta vorto, ni diru la ludanto kiu havas gajnita. Ni eliris en la gameIsDone variablo al True. Ni kontrolu ĉi variablo por vidi se ni devus lasi la ludanto diveni denove aŭ se la ludanto estas farita diveni.Kiam la Ludanto divenas malĝuste

    alie:
Ĉi tiu estas la komenco de la alia-bloko. Memoru, la kodo en ĉi tiu bloko ekzekutos se la kondiĉo estis Falsa. Sed kiu kondiĉo? Por ekscii, direktu vian fingron en la komenco de la alia ŝlosilvorto kaj movi ĝin rekte. Vi vidos ke la alia ŝlosilvorto la deŝovon estas la sama kiel la se ŝlosilvorto la deŝovon en linio 118. Do se la kondiĉo sur linio 118 estis Falsa, tiam ni kuros la kodo en ĉi alie-bloko. Alie, ni salti malsupren preter la alia-bloko al vicigas 140.

    missedLetters = missedLetters + diveni
Ĉar la ludanto divenis letero estis erara, ni aldonos ĝin al la missedLetters kordoj. Ĉi tio estas kiel kion ni faris en linio 119, kiam la ludanto divenis ĝuste.

    # Kontroli se ludanto divenis tro da fojoj kaj perdita
    se len (missedLetters) == len (HANGMANPICS) - 1:
    displayBoard (HANGMANPICS, missedLetters, correctLetters, secretWord)
    print ('Vi kuras el divenas! \ nAfter' + str (len (missedLetters)) + 'missed divenojn kaj' + str (len (correctLetters)) + 'ĝentila divenas, la vorto estis "' + secretWord + '" ')
    gameIsDone = True
Pensu pri kiel ni scias kiam la ludanto divenis tro da fojoj. Kiam vi ludas Pendumito sur papero, ĉi tio estas kiam la desegno de la ekzekutisto estas finita. Ni desegni la ekzekutisto en la ekrano kun impreso () alvokoj, bazita sur kiom da literoj estas en missedLetters. Memoru ke ĉiu tempo la ludanto divenas erara, ni aldonu (aux kiel programisto dirus, concatenate) la erara letero al la ĉeno en missedLetters. Do la longo de missedLetters (aŭ, en kodo, len (missedLetters)) povas diri al ni la nombro de erara divenas.
Kie estas la limo ne la ludanto kuras el divenojn kaj perdi? Nu, la HANGMANPICS listo havas 7 bildoj (vere, ili estas Askio arto kordoj). Do kiam len (missedLetters) egalas 6, ni konas la ludanto perdis pro la ekzekutisto bildo estos finita. (Memoru ke HANGMANPICS [0] estas la unua ero en la listo, kaj HANGMANPICS [6] estas la lasta. Tiu estas ĉar la indekso de listo kun 7 artikoloj iras de 0 al 6, ne 1 ĝis 7.)
Do kial ni havas len (missedLetters) == len (HANGMANPICS) - 1 kiel la kondiĉo sur linio 134, anstataŭ len (missedLetters) == 6? Pretendi ke ni aldonu alia linio al la HANGMANPICS listo (eble bildon de la plena ekzekutisto kun vosto, aŭ trionon mutantes brako). Tiam la lasta foto en la listo estus en HANGMANPICS [7]. Do ne nur tio ni devas ŝanĝi la HANGMANPICS listo kun nova ŝnuro, sed ni ankaŭ devus memori ŝanĝi linio 134 al len (missedLetters) == 7. Eble tio ne estos granda interkonsento por malgranda programo kiel Pendumito, sed kiam oni komencas skribi pli grandaj programoj vi devas ŝanĝi pluraj malsamaj linioj de kodo en la tuta via programo nur por fari sola ŝanĝo en la programo de la konduto. Tiel, se ni volas fari la ludon pli malfacila aŭ facila, ni nur devas aldoni aŭ forigi Arto ASCII kordoj al HANGMANPICS kaj ŝanĝi nenio alia.
Dua kialo ni uzanto len (HANGMANPICS) - 1 estas tiel ke kiam ni legas la kodon en tiu programo poste, ni scias, kial tiu programo kondutas la vojon faras. Se vi skribis len (missedLetters) == 6 kaj poste rigardis la kodo du semajnoj poste, eble vi demandas, kio estas tiom speciala pri la nombro 6. Vi eble forgesis, ke 6 estas la lasta indico en la HANGMANPICS listo. Kompreneble, vi povus skribi komenton memorigi vin, kiel:se len (missedLetters) == 6: # 6 estas la lasta indico en la HANGMANPICS listo
Sed estas pli facile ĝuste uzi len (HANGMANPICS) - 1 anstataŭe.
Do, kiam la longeco de la missedLetters linio estas egala al len (HANGMANPICS) - 1, ni konas la ludanto kuras el divenojn kaj perdis la ludon. Ni presas longa ĉeno diras la uzanto kion sekreta vorto estis, kaj poste starigis la gameIsDone valoro al la Bulea valoro True. Jen kiel ni diros nin ke la ludo estas farita, kaj ni devas komenci pli.
Memoru, ke kiam ni havas \ n en cxeno, kiu reprezentas la linion karaktero. Tio estas kiel la presita () alvoko on line 136 montras plurajn liniojn de teksto.

    # Petu la ludanto se ili volas ludi denove (sed nur se la ludo estas farita).
    se gameIsDone:
    se playAgain ():
    missedLetters =''
    correctLetters =''
    gameIsDone = False
    secretWord = getRandomWord (vortoj)
Se la ludanto gajnis aŭ perdis poste diveni lian leteron, tiam nia kodo li deziris repacigi la gameIsDone variablo al True. Se ĉi tiu estas la kazo, ni devus peti la ludanto se ili volas ludi denove. Ni jam skribis la playAgain () funkcio al manipuli duumaj jes aŭ ne de la ludanto. Ĉi tiu funkcio redonas bulea valoro de Vera se la ludanto volas ludi alia ludo de Pendumito, kaj Falsa se ili jam havis sufiĉe.
Se la ludanto ne volas ludi denove, ni retrovu la valoroj en missedLetters kaj correctLetters al malplenan kordoj, turnu gameIsDone al False, kaj poste elekti novan sekretan vorton por nomi getRandomWord () denove, pasante ĝin la listo de eblaj sekretaj vortoj.
Tiel, kiam ni buklo reen al la komenco de la iteracio (on line 112) la estraro estos reen al la komenco (memoras ni decidos kion ekzekutisto bildo por montri bazita sur la longo de missedLetters, kiun ni ĵus starigis kiel la malplenan ĉenon ) kaj la ludo estos same kiel la unua fojo ni eniris en la ciklo. La sola diferenco estas ni havos novan sekretan vorton, ĉar ni planis getRandomWord () kaj redonas hazarde elektita vorto ĉiufoje ni nomas ĝin.
Estas malgranda ŝanco, ke la nova sekreta vorto estos la sama kiel la malnova sekreta vorto, sed tio estas nur koincido. Imagu ke vi spegulita moneron kaj ĝi venis ĝis kapojn, kaj tiam vi spegulita la monero denove kaj ankaŭ venis kapoj. Ambaŭ monero klakas estis hazarda, estis nur koincido ke ili iris la saman ambaŭ fojoj. Laŭe, vi rajtas preni la sama vorto revenas de getRandomWord () dufoje sinsekve, sed tio estas nur koincido.

    alie:
    rompi
Se la ludanto tajpita en 'neniu' kiam demandis se ili volis ludi denove, tiam ili revenas valoro de la alvoko al la playAgain () funkcio estus Falsa kaj la alia-bloko estus ekzekutita. Ĉi alie-bloko nur havas unu linio, ripozon komunikaĵo. Tiu kaŭzas la ekzekuto salti al la fino de la iteracio, kiu jam ekzistas sur linio 112. Sed ĉar ne estas pli kodo post la ciklo, la programo finiĝas.Farante Nov Ŝanĝoj al la Pendumito Programo
Tiu programo estis multe pli granda ol la Drako Reĝlando programo, sed tiu programo estas ankaŭ pli kompleksa. Vere helpas fari fluo abako aŭ malgranda skizo memori kiom vi deziras ĉion por labori. Rigardu la fluo abako kelkajn paĝojn reen en Figuro 9-4 kaj provu trovi la linioj de kodo kiu reprezentas ĉiun blokon.
Ni rigardu kelkajn manierojn povas plibonigi nian Pendumito ludo.
Post kiam vi ludis Pendumito kelkaj tempoj, vi eble opinias ke ses divenas ne sufiĉas por ricevi multajn el la vortoj. Ni povas facile doni la ludanto pli divenas per aldoni pli plurliniaj kordoj al la HANGMANPICS listo. Ĝi estas facila, nur ŝanĝi la] kvadrata krampo on line 58 al a,'' 'komo kaj tri citaĵoj (vidu linio 57-sube). Tiam aldoni la sekvajn:

    =========='' ','''
    + ---- +
    | |
    [Ho |
    / | \ |
    / \ |
    |
    =========='' ','''
    + ---- +
    | |
    [Ho] |
    / | \ |
    / \ |
    |
    =========='' ']
Ni aldonis du novajn plurliniaj kordoj al la HANGMANPICS listo, kun la ekzekutisto la maldekstra orelo desegnita, kaj la alia kun ambaŭ oreloj desegnita. Ĉar nia programo rakontos la ludanto ili perdis kiam la nombro de divenas estas la sama kiel la nombro de kordoj en HANGMANPICS (minus unu), ĉi tiu estas la sola ŝanĝo necesas fari.
Ni povas ankaŭ ŝanĝi la liston de vortoj ŝanĝante la vortoj sur linio 59. Anstataŭ de bestoj, ni povus havi koloroj:

    vortoj = 'ruĝa oranĝa flava verda blua indigo viola blanka nigra bruna'. split ()
Aŭ formojn:

    vortoj = 'kvadrata triangulo rektangulo rondo elipso rombo trapazoid ĉevrono kvinlatero seslatero septagon octogon'. split ()
Aŭ fruktoj:

    vortoj = 'pomo oranĝo citrono kalko piro akvomelono vinbero pomelo ĉerizo banano cantalope tenilo frago tomato'. split ()
Vortaroj
Kun kelkaj modifiĝo, oni povas ŝanĝi niajn kodo por ke nia Pendumito ludo povas uzi ĉiujn tiujn vortojn kiel apartaj aroj. Ni povas diri al la ludanto kiu starigis la sekreta vorto estas de (kiel "besto", "koloro", "formo", aŭ "frukto"). Tiamaniere, la ludanto ne diveni bestoj tutan tempon.
Por fari tiun ŝanĝon, ni enkonduki novan datumtipo nomata vortaro. Al vortaro estas kolekto de multaj valoroj multe kiel lerta estas, sed anstataŭ alirante la artikoloj en la vortaro kun entjero indekso, vi konsenti ili kun indico (por vortaroj, la indeksoj estas nomitaj klavoj) de ajna datumtipo (sed plej ofte kordoj).
Provu tajpi la sekva en la ŝelon:>>> Stuff = {'saluton': 'Saluton tie, kiel vi fartas?', 'Babilejo': 'Kiel estas la vetero?', 'Adiaŭ': 'Estis agrabla paroli kun vi!}>>>
Tiuj estas krispa krampoj {kaj}. Sur la klavaro estas en la sama tonalo kiel la rektaj krampoj [kaj].