pythonlearn/html-009/book006.html at master · StudyCourse/pythonlearn

History

357 lines (357 loc) · 26.7 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

<!DOCTYPE html>

<html>

<head>

<title>Iteration</title>

</head>

<body>

<hr />

<h1 class="chapter" id="sec60">Chapter&#XA0;5&#XA0;&#XA0;Iteration</h1>

<h2 class="section" id="sec61">5.1&#XA0;&#XA0;Updating variables</h2>

<a id="hevea_default286"></a>A common pattern in assignment statements is an assignment statement

that updates a variable -

where the new value of the variable depends on the old.<pre class="verbatim">x = x+1

</pre>This means &#X201C;get the current value of x, add one, and then

update x with the new value.&#X201D;If you try to update a variable that doesn&#X2019;t exist, you get an

error, because Python evaluates the right side before it assigns

a value to x:<pre class="verbatim">>>> x = x+1

NameError: name 'x' is not defined

</pre>Before you can update a variable, you have to initialize

it, usually with a simple assignment:<a id="hevea_default287"></a><pre class="verbatim">>>> x = 0

>>> x = x+1

</pre>Updating a variable by adding 1 is called an increment;

subtracting 1 is called a decrement.<a id="hevea_default288"></a>

<h2 class="section" id="sec62">5.2&#XA0;&#XA0;The while statement</h2>

<a id="hevea_default293"></a>Computers are often used to automate repetitive tasks. Repeating

identical or similar tasks without making errors is something that

computers do well and people do poorly.

Because iteration is so common, Python provides several

language features to make it easier. One form of iteration in Python is the while statement. Here is

a simple program that counts down from five and then says &#X201C;Blastoff!&#X201D;.<pre class="verbatim">n = 5

while n > 0:

print n

n = n-1

print 'Blastoff!'

</pre>You can almost read the while statement as if it were English.

It means, &#X201C;While n is greater than 0,

display the value of n and then reduce the value of

n by 1. When you get to 0, exit the while statement and

display the word Blastoff!&#X201D;<a id="hevea_default294"></a>More formally, here is the flow of execution for a while statement:<ol class="enumerate" type="1"><li class="li-enumerate">Evaluate the condition, yielding True or False.</li><li class="li-enumerate">If the condition is false, exit the while statement

and continue execution at the next statement.</li><li class="li-enumerate">If the condition is true, execute the

body and then go back to step 1.</li></ol>This type of flow is called a loop because the third step

loops back around to the top. Each time we execute the body of

the loop, we call it an iteration. For the above loop, we

would say, &#X201C;It had five iterations&#X201D; which means that the body of

the loop was executed five times.<a id="hevea_default295"></a>

<a id="hevea_default297"></a>The body of the loop should change the value of one or more variables

so that eventually the condition becomes false and the loop

terminates.

We call the variable that changes each time the loop

executes and controls when the loop finishes the

iteration variable.

If there is no iteration variable, the loop will repeat forever,

resulting in an infinite loop.

<h2 class="section" id="sec63">5.3&#XA0;&#XA0;Infinite loops</h2>

An endless source of amusement for

programmers is the observation that the directions on shampoo,

&#X201C;Lather, rinse, repeat,&#X201D; are an infinite loop because

there is no iteration variable telling you how many times

to execute the loop.<a id="hevea_default298"></a>

<a id="hevea_default299"></a>In the case of countdown, we can prove that the loop

terminates because we know that the value of n is finite, and we

can see that the value of n gets smaller each time through the

loop, so eventually we have to get to 0. Other times a loop is obviously

infinite because it has no iteration variable at all.

<h2 class="section" id="sec64">5.4&#XA0;&#XA0;&#X201C;Infinite loops&#X201D; and break</h2>

<a id="hevea_default301"></a>Sometimes you don&#X2019;t know it&#X2019;s time to end a loop until you get half

way through the body. In that case you can write an infinite loop on purpose

and then use the break statement to jump out of the loop.This loop is obviously an infinite loop because the logical

expression on the

while statement is simply the logical constant True:<pre class="verbatim">n = 10

while True:

print n,

n = n - 1

print 'Done!'

</pre>If you make the mistake and run this code, you will learn quickly how

to stop a runaway Python process on your system or find where the power-off

button is on your computer.

This program will

run forever or until your battery runs out

because the logical expression at the top of the loop

is always true by virtue of the fact that the expression is the

constant value True.While this is a dysfunctional infinite loop, we can still use this pattern

to build useful loops as long as we carefully add code to the

body of the loop to explicitly exit the loop using break

when we have reached

the exit condition.For example, suppose you want to take input from the user until they

type done. You could write:<pre class="verbatim">while True:

line = raw_input('> ')

if line == 'done':

break

print line

print 'Done!'

</pre>The loop condition is True, which is always true, so the

loop runs repeatedly until it hits the break statement.Each time through, it prompts the user with an angle bracket.

If the user types done, the break statement exits

the loop. Otherwise the program echoes whatever the user types

and goes back to the top of the loop. Here&#X2019;s a sample run:<pre class="verbatim">> hello there

hello there

> finished

finished

> done

Done!

</pre>This way of writing while loops is common because you

can check the condition anywhere in the loop (not just at the

top) and you can express the stop condition affirmatively

(&#X201C;stop when this happens&#X201D;) rather than negatively (&#X201C;keep going

until that happens.&#X201D;).

<h2 class="section" id="sec65">5.5&#XA0;&#XA0;Finishing iterations with continue</h2>

<a id="hevea_default303"></a>Sometimes you are in an iteration of a loop and want to finish the

current iteration and immediately jump to the next iteration.

In that case you can use the continue

statement to skip to the next iteration without finishing the

body of the loop for the current iteration.Here is an example of a loop that copies its input until the user

types &#X201C;done&#X201D;, but treats lines that start with the hash character

as lines not to be printed (kind of like Python comments).<pre class="verbatim">while True:

line = raw_input('> ')

if line[0] == '#' :

continue

if line == 'done':

break

print line

print 'Done!'

</pre>Here is a sample run of this new program with continue added.<pre class="verbatim">> hello there

hello there

> # don't print this

> print this!

print this!

> done

Done!

</pre>All the lines are printed except the one that starts with the hash

sign because when the continue is executed, it ends

the current iteration and jumps

back to the while statement to start the next iteration, thus

skipping the print statement.

<h2 class="section" id="sec66">5.6&#XA0;&#XA0;Definite loops using for </h2>

<a id="hevea_default305"></a>Sometimes we want to loop through a set of things such

as a list of words, the lines in a file or a list of numbers.

When we have a list of things to loop through, we can

construct a definite loop using a for statement.

We call the while statement an indefinite loop

because it simply loops until some condition becomes False

whereas the for loop is looping through a known

set of items so it runs through as many iterations as there

are items in the set.The syntax of a for loop is similar to the while loop

in that there is a for statement and a loop body:<pre class="verbatim">friends = ['Joseph', 'Glenn', 'Sally']

for friend in friends:

print 'Happy New Year:', friend

print 'Done!'

</pre>In Python terms,

the variable friends is a list<a id="text8" href="#note8">1</a>

of three strings and the for

loop goes through the list and executes the body once

for each of the three strings in the list resulting in this output:<pre class="verbatim">Happy New Year: Joseph

Happy New Year: Glenn

Happy New Year: Sally

Done!

</pre>Translating this for loop to English is not as direct as the

while, but if you think of friends as a set,

it goes like this: &#X201C;Run the statements in the body of the

for loop once for each friend in the set named friends.&#X201D;.Looking at the for loop, for and in are reserved

Python keywords, and friend and friends are variables.for friend in friends:

<code> </code>print &#X2019;Happy New Year&#X2019;, friend In particular, friend is the iteration variable for

the for loop. The variable friend changes for each iteration of

the loop and controls when the for loop completes. The

iteration variable steps successively through the

three strings stored in the friends variable.

<h2 class="section" id="sec67">5.7&#XA0;&#XA0;Loop patterns</h2>

Often we use a for or while loop to go through a list of items

or the contents of a file and we are looking for something such as

the largest or smallest value of the data we scan through.These loops are generally constructed by:<ul class="itemize"><li class="li-itemize">Initializing one or more variables before the loop starts.</li><li class="li-itemize">Performing some computation on each item in the loop body,

possibly changing the variables in the body of the loop.</li><li class="li-itemize">Looking at the resulting variables when the loop completes.</li></ul>We will use a list of numbers to demonstrate the concepts and construction

of these loop patterns.

<h3 class="subsection" id="sec68">5.7.1&#XA0;&#XA0;Counting and summing loops</h3>

For example, to count the number of items

in a list, we would write the following for loop:<pre class="verbatim">count = 0

for itervar in [3, 41, 12, 9, 74, 15]:

count = count + 1

print 'Count: ', count

</pre>We set the variable count to zero before the loop starts,

then we write a for loop to run through the list of numbers.

Our iteration variable is named itervar and while we do

not use itervar in the loop, it does control the loop and cause

the loop body to be executed once for each of the values in the list.In the body of the loop, we add one to the current value of count

for each of the values in the list. While the loop is executing, the

value of count is the number of values we have seen &#X201C;so far&#X201D;.Once the loop completes, the value of count is the total number

of items. The total number &#X201C;falls in our lap&#X201D; at the end of the

loop. We construct the loop so that we have what we want when the loop

finishes.Another similar loop that computes the total of a set of numbers

is as follows:<pre class="verbatim">total = 0

for itervar in [3, 41, 12, 9, 74, 15]:

total = total + itervar

print 'Total: ', total

</pre>In this loop we do use the iteration variable.

Instead of simply adding one to the count as in the previous loop,

we add the actual number (3, 41, 12, etc.) to the running

total during each loop iteration.

If you think about the variable total, it contains the

&#X201C;running total of the values so far&#X201D;. So before the loop

starts total is zero because we have not yet seen any values,

during the loop total is the running total, and at the end of

the loop total is the overall total of all the values

in the list.As the loop executes, total accumulates the sum of the

elements; a variable used this way is sometimes called an

accumulator.

<a id="hevea_default306"></a>Neither the counting loop nor the summing loop are particularly

useful in practice because there are built-in functions

len() and sum() that compute the number of

items in a list and the total of the items in the list

respectively.

<h3 class="subsection" id="sec69">5.7.2&#XA0;&#XA0;Maximum and minimum loops</h3>

To find the largest value in a list or sequence, we construct the

following loop:<pre class="verbatim">largest = None

print 'Before:', largest

for itervar in [3, 41, 12, 9, 74, 15]:

if largest is None or itervar > largest :

largest = itervar

print 'Loop:', itervar, largest

print 'Largest:', largest

</pre>When the program executes, the output is as follows:<pre class="verbatim">Before: None

Loop: 3 3

Loop: 41 41

Loop: 12 41

Loop: 9 41

Loop: 74 74

Loop: 15 74

Largest: 74

</pre>The variable largest is best thought of as

the &#X201C;largest value we have seen so far&#X201D;.

Before the loop, we set largest to the constant None.

None is a special constant value which we can

store in a variable to mark

the variable as &#X201C;empty&#X201D;. Before the loop starts, the largest value we have seen so far

is None since we have not yet seen any values. While the

loop is executing, if largest is None then we take

the first value we see as the largest so far. You can see in

the first iteration when the value of itervar is 3,

since largest is None, we immediately set

largest to be 3.After the first iteration, largest is no longer None,

so the second part of the compound logical expression that checks

itervar > largest triggers only when we see a value that is

larger than the &#X201C;largest so far&#X201D;. When we see a new &#X201C;even larger&#X201D;

value we take that new value for largest. You can see in the

program output that largest progresses from 3 to 41 to 74.At the end of the loop, we have scanned all of the values and

the variable largest now does contain the largest value

in the list.To compute the smallest number, the code is very similar with one

small change:<pre class="verbatim">smallest = None

print 'Before:', smallest

for itervar in [3, 41, 12, 9, 74, 15]:

if smallest is None or itervar < smallest:

smallest = itervar

print 'Loop:', itervar, smallest

print 'Smallest:', smallest

</pre>Again, smallest is the &#X201C;smallest so far&#X201D; before, during, and after the

loop executes. When the loop has completed, smallest contains the

minimum value in the list.Again as in counting and summing, the built-in functions

max() and min() make writing these exact loops

unnecessary.The following is a simple version of the Python built-in

min() function:<pre class="verbatim">def min(values):

smallest = None

for value in values:

if smallest is None or value < smallest:

smallest = value

return smallest

</pre>In the function version of the smallest code, we removed all of the

print statements so as to be equivalent to the min

function which is already built-in to Python.

<h2 class="section" id="sec70">5.8&#XA0;&#XA0;Debugging</h2>

As you start writing bigger programs, you might find yourself

spending more time debugging. More code means more chances to

make an error and more places for bugs to hide.<a id="hevea_default311"></a>

<a id="hevea_default312"></a>One way to cut your debugging time is &#X201C;debugging by bisection.&#X201D;

For example, if there are 100 lines in your program and you

check them one at a time, it would take 100 steps.Instead, try to break the problem in half. Look at the middle

of the program, or near it, for an intermediate value you

can check. Add a print statement (or something else

that has a verifiable effect) and run the program.If the mid-point check is incorrect, the problem must be in the

first half of the program. If it is correct, the problem is

in the second half.Every time you perform a check like this, you halve the number

of lines you have to search. After six steps (which is much

less than 100), you would be down to one or two lines of code,

at least in theory.In practice it is not always clear what

the &#X201C;middle of the program&#X201D; is and not always possible to

check it. It doesn&#X2019;t make sense to count lines and find the

exact midpoint. Instead, think about places

in the program where there might be errors and places where it

is easy to put a check. Then choose a spot where you

think the chances are about the same that the bug is before

or after the check.

<h2 class="section" id="sec71">5.9&#XA0;&#XA0;Glossary</h2>

<dl class="description"><dt class="dt-description">accumulator:</dt><dd class="dd-description"> A variable used in a loop to add up or

accumulate a result.

<a id="hevea_default313"></a></dd><dt class="dt-description">counter:</dt><dd class="dd-description"> A variable used in a loop to count the number

of times something happened. We initialize a counter to

zero and then increment the counter each time we want to

&#X201C;count&#X201D; something.

<a id="hevea_default314"></a></dd><dt class="dt-description">decrement:</dt><dd class="dd-description"> An update that decreases the value of a variable.

<a id="hevea_default315"></a></dd><dt class="dt-description">initialize:</dt><dd class="dd-description"> An assignment that gives an initial value to

a variable that will be updated.</dd><dt class="dt-description">increment:</dt><dd class="dd-description"> An update that increases the value of a variable

(often by one).

<a id="hevea_default316"></a></dd><dt class="dt-description">infinite loop:</dt><dd class="dd-description"> A loop in which the terminating condition is

never satisfied or for which there is no termination condition.

<a id="hevea_default317"></a></dd><dt class="dt-description">iteration:</dt><dd class="dd-description"> Repeated execution of a set of statements using

either a recursive function call or a loop.

<h2 class="section" id="sec72">5.10&#XA0;&#XA0;Exercises</h2>

<div class="theorem">Exercise&#XA0;1&#XA0;&#XA0;

Write a program which repeatedly reads numbers until the user

enters &#X201C;done&#X201D;.

Once &#X201C;done&#X201D; is entered, print out the total, count, and average

of the numbers. If the user enters anything other than a number,

detect their mistake using try and except and

print an error message and skip to the next number.<pre class="verbatim">Enter a number: 4

Enter a number: 5

Enter a number: bad data

Invalid input

Enter a number: 7

Enter a number: done

16 3 5.33333333333

</pre></div><div class="theorem">Exercise&#XA0;2&#XA0;&#XA0;

Write another program that prompts for a list of numbers as above

and at the end prints out both the maximum and minimum of the numbers instead of the average.

</div>

<a id="note8" href="#text8">1</a></dt><dd class="dd-thefootnotes"><div class="footnotetext">We will

examine lists in more detail in a later chapter</div>

</dd></dl>

<hr />

</body>

</html>

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

FilesExpand file tree

book006.html

Latest commit

History

book006.html

File metadata and controls