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

History

638 lines (632 loc) · 45.4 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

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

534

535

536

537

538

539

540

541

542

543

544

545

546

547

548

549

550

551

552

553

554

555

556

557

558

559

560

561

562

563

564

565

566

567

568

569

570

571

572

573

574

575

576

577

578

579

580

581

582

583

584

585

586

587

588

589

590

591

592

593

594

595

596

597

598

599

600

601

602

603

604

605

606

607

608

609

610

611

612

613

614

615

616

617

618

619

620

621

622

623

624

625

626

627

628

629

630

631

632

633

634

635

636

637

638

<!DOCTYPE html>

<html>

<head>

<title>Lists</title>

</head>

<body>

<hr />

<h1 class="chapter" id="sec100">Chapter&#XA0;8&#XA0;&#XA0;Lists</h1>

<h2 class="section" id="sec101">8.1&#XA0;&#XA0;A list is a sequence</h2>

Like a string, a list is a sequence of values. In a string, the

values are characters; in a list, they can be any type. The values in

list are called elements or sometimes items.<a id="hevea_default448"></a>

<a id="hevea_default450"></a>There are several ways to create a new list; the simplest is to

enclose the elements in square brackets (<code>[</code> and <code>]</code>):<pre class="verbatim">[10, 20, 30, 40]

['crunchy frog', 'ram bladder', 'lark vomit']

</pre>The first example is a list of four integers. The second is a list of

three strings. The elements of a list don&#X2019;t have to be the same type.

The following list contains a string, a float, an integer, and

(lo!) another list:<pre class="verbatim">['spam', 2.0, 5, [10, 20]]

</pre>A list within another list is nested.<a id="hevea_default451"></a>

<a id="hevea_default452"></a>A list that contains no elements is

called an empty list; you can create one with empty

brackets, <code>[]</code>.<a id="hevea_default453"></a>

<a id="hevea_default454"></a>As you might expect, you can assign list values to variables:<pre class="verbatim">>>> cheeses = ['Cheddar', 'Edam', 'Gouda']

>>> numbers = [17, 123]

>>> empty = []

>>> print cheeses, numbers, empty

['Cheddar', 'Edam', 'Gouda'] [17, 123] []

</pre><a id="hevea_default455"></a>

<h2 class="section" id="sec102">8.2&#XA0;&#XA0;Lists are mutable</h2>

<a id="hevea_default460"></a>The syntax for accessing the elements of a list is the same as for

accessing the characters of a string&#X2014;the bracket operator. The

expression inside the brackets specifies the index. Remember that the

indices start at 0:<pre class="verbatim">>>> print cheeses[0]

Cheddar

</pre>Unlike strings, lists are mutable because you can change the order

of items in a list or reassign an item in a list.

When the bracket operator appears on the left side of an assignment,

it identifies the element of the list that will be assigned.<a id="hevea_default461"></a><pre class="verbatim">>>> numbers = [17, 123]

>>> numbers[1] = 5

>>> print numbers

[17, 5]

</pre>The one-eth element of numbers, which

used to be 123, is now 5.<a id="hevea_default462"></a>

<a id="hevea_default463"></a>You can think of a list as a relationship between indices and

elements. This relationship is called a mapping; each index

&#X201C;maps to&#X201D; one of the elements. <a id="hevea_default464"></a>

<a id="hevea_default465"></a>List indices work the same way as string indices:<ul class="itemize"><li class="li-itemize">Any integer expression can be used as an index.</li><li class="li-itemize">If you try to read or write an element that does not exist, you

get an IndexError.<a id="hevea_default466"></a>

<a id="hevea_default467"></a></li><li class="li-itemize">If an index has a negative value, it counts backward from the

end of the list.</li></ul><a id="hevea_default468"></a><a id="hevea_default469"></a>

<a id="hevea_default472"></a>The in operator also works on lists.<pre class="verbatim">>>> cheeses = ['Cheddar', 'Edam', 'Gouda']

>>> 'Edam' in cheeses

True

>>> 'Brie' in cheeses

False

</pre>

<h2 class="section" id="sec103">8.3&#XA0;&#XA0;Traversing a list</h2>

<a id="hevea_default477"></a>The most common way to traverse the elements of a list is

with a for loop. The syntax is the same as for strings:<pre class="verbatim">for cheese in cheeses:

print cheese

</pre>This works well if you only need to read the elements of the

list. But if you want to write or update the elements, you

need the indices. A common way to do that is to combine

the functions range and len:<a id="hevea_default478"></a>

<a id="hevea_default479"></a><pre class="verbatim">for i in range(len(numbers)):

numbers[i] = numbers[i] * 2

</pre>This loop traverses the list and updates each element. len

returns the number of elements in the list. range returns

a list of indices from 0 to n&#X2212;1, where n is the length of

the list. Each time through the loop i gets the index

of the next element. The assignment statement in the body uses

i to read the old value of the element and to assign the

new value.<a id="hevea_default480"></a>

<a id="hevea_default481"></a>A for loop over an empty list never executes the body:<pre class="verbatim">for x in empty:

print 'This never happens.'

</pre>Although a list can contain another list, the nested

list still counts as a single element. The length of this list is

four:<a id="hevea_default482"></a>

<a id="hevea_default483"></a><pre class="verbatim">['spam', 1, ['Brie', 'Roquefort', 'Pol le Veq'], [1, 2, 3]]

</pre>

<h2 class="section" id="sec104">8.4&#XA0;&#XA0;List operations</h2>

<a id="hevea_default484"></a>The + operator concatenates lists:<a id="hevea_default485"></a>

<a id="hevea_default486"></a><pre class="verbatim">>>> a = [1, 2, 3]

>>> b = [4, 5, 6]

>>> c = a + b

>>> print c

[1, 2, 3, 4, 5, 6]

</pre>Similarly, the * operator repeats a list a given number of times:<a id="hevea_default487"></a>

<a id="hevea_default488"></a><pre class="verbatim">>>> [0] * 4

[0, 0, 0, 0]

>>> [1, 2, 3] * 3

[1, 2, 3, 1, 2, 3, 1, 2, 3]

</pre>The first example repeats [0] four times. The second example

repeats the list [1, 2, 3] three times.

<h2 class="section" id="sec105">8.5&#XA0;&#XA0;List slices</h2>

<a id="hevea_default493"></a>The slice operator also works on lists:<pre class="verbatim">>>> t = ['a', 'b', 'c', 'd', 'e', 'f']

>>> t[1:3]

['b', 'c']

>>> t[:4]

['a', 'b', 'c', 'd']

>>> t[3:]

['d', 'e', 'f']

</pre>If you omit the first index, the slice starts at the beginning.

If you omit the second, the slice goes to the end. So if you

omit both, the slice is a copy of the whole list.<a id="hevea_default494"></a>

<a id="hevea_default496"></a><pre class="verbatim">>>> t[:]

['a', 'b', 'c', 'd', 'e', 'f']

</pre>Since lists are mutable, it is often useful to make a copy

before performing operations that fold, spindle or mutilate

lists.<a id="hevea_default497"></a>A slice operator on the left side of an assignment

can update multiple elements:<a id="hevea_default498"></a>

<a id="hevea_default499"></a><pre class="verbatim">>>> t = ['a', 'b', 'c', 'd', 'e', 'f']

>>> t[1:3] = ['x', 'y']

>>> print t

['a', 'x', 'y', 'd', 'e', 'f']

</pre>

<h2 class="section" id="sec106">8.6&#XA0;&#XA0;List methods</h2>

<a id="hevea_default501"></a>Python provides methods that operate on lists. For example,

append adds a new element to the end of a list:<a id="hevea_default502"></a>

<a id="hevea_default503"></a><pre class="verbatim">>>> t = ['a', 'b', 'c']

>>> t.append('d')

>>> print t

['a', 'b', 'c', 'd']

</pre>extend takes a list as an argument and appends all of

the elements:<a id="hevea_default504"></a>

<a id="hevea_default505"></a><pre class="verbatim">>>> t1 = ['a', 'b', 'c']

>>> t2 = ['d', 'e']

>>> t1.extend(t2)

>>> print t1

['a', 'b', 'c', 'd', 'e']

</pre>This example leaves t2 unmodified.sort arranges the elements of the list from low to high:<a id="hevea_default506"></a>

<a id="hevea_default507"></a><pre class="verbatim">>>> t = ['d', 'c', 'e', 'b', 'a']

>>> t.sort()

>>> print t

['a', 'b', 'c', 'd', 'e']

</pre>Most list methods are void; they modify the list and return None.

If you accidentally write t = t.sort(), you will be disappointed

with the result.<a id="hevea_default508"></a>

<h2 class="section" id="sec107">8.7&#XA0;&#XA0;Deleting elements</h2>

<a id="hevea_default513"></a>There are several ways to delete elements from a list. If you

know the index of the element you want, you can use

pop:<a id="hevea_default514"></a>

<a id="hevea_default515"></a><pre class="verbatim">>>> t = ['a', 'b', 'c']

>>> x = t.pop(1)

>>> print t

['a', 'c']

>>> print x

</pre>pop modifies the list and returns the element that was removed.

If you don&#X2019;t provide an index, it deletes and returns the

last element.If you don&#X2019;t need the removed value, you can use the del

operator:<a id="hevea_default516"></a>

<a id="hevea_default517"></a><pre class="verbatim">>>> t = ['a', 'b', 'c']

>>> del t[1]

>>> print t

['a', 'c']

</pre>If you know the element you want to remove (but not the index), you

can use remove:<a id="hevea_default518"></a>

<a id="hevea_default519"></a><pre class="verbatim">>>> t = ['a', 'b', 'c']

>>> t.remove('b')

>>> print t

['a', 'c']

</pre>The return value from remove is None.<a id="hevea_default520"></a>

<a id="hevea_default521"></a>To remove more than one element, you can use del with

a slice index:<pre class="verbatim">>>> t = ['a', 'b', 'c', 'd', 'e', 'f']

>>> del t[1:5]

>>> print t

['a', 'f']

</pre>As usual, the slice selects all the elements up to, but not

including, the second index.

<h2 class="section" id="sec108">8.8&#XA0;&#XA0;Lists and functions</h2>

There are a number of built-in functions that can be used on lists

that allow you to quickly look through a list without

writing your own loops:<pre class="verbatim">>>> nums = [3, 41, 12, 9, 74, 15]

>>> print len(nums)

>>> print max(nums)

>>> print min(nums)

>>> print sum(nums)

154

>>> print sum(nums)/len(nums)

</pre>The sum() function only works when the list elements are numbers.

The other functions (max(), len(), etc.) work with lists of

strings and other types that can be comparable.We could rewrite an earlier program that computed the average of

a list of numbers entered by the user using a list.First, the program to compute an average without a list:<pre class="verbatim">total = 0

count = 0

while ( True ) :

inp = raw_input('Enter a number: ')

if inp == 'done' : break

value = float(inp)

total = total + value

count = count + 1

average = total / count

print 'Average:', average

</pre>In this program, we have count and sum variables to

keep the number and running total of the user&#X2019;s numbers as

we repeatedly prompt the user for a number.We could simply remember each number as the user entered it

and use built-in functions to compute the sum and count at

the end.<pre class="verbatim">numlist = list()

while ( True ) :

inp = raw_input('Enter a number: ')

if inp == 'done' : break

value = float(inp)

numlist.append(value)

average = sum(numlist) / len(numlist)

print 'Average:', average

</pre>We make an empty list before the loop starts, and then each time we have

a number, we append it to the list. At the end of

the program, we simply compute the sum of the numbers in the

list and divide it by the count of the numbers in the

list to come up with the average.

<h2 class="section" id="sec109">8.9&#XA0;&#XA0;Lists and strings</h2>

<a id="hevea_default524"></a>A string is a sequence of characters and a list is a sequence

of values, but a list of characters is not the same as a

string. To convert from a string to a list of characters,

you can use list:<a id="hevea_default525"></a>

<a id="hevea_default526"></a><pre class="verbatim">>>> s = 'spam'

>>> t = list(s)

>>> print t

['s', 'p', 'a', 'm']

</pre>Because list is the name of a built-in function, you should

avoid using it as a variable name. I also avoid l because

it looks too much like 1. So that&#X2019;s why I use t.The list function breaks a string into individual letters. If

you want to break a string into words, you can use the split

method:<a id="hevea_default527"></a>

<a id="hevea_default528"></a><pre class="verbatim">>>> s = 'pining for the fjords'

>>> t = s.split()

>>> print t

['pining', 'for', 'the', 'fjords']

>>> print t[2]

the

</pre>Once you have used split to break the string into

a list of tokens, you can use the index operator (square

bracket) to look at a particular word in the list.You can call split with

an optional argument called a delimiter specifies which

characters to use as word boundaries.

The following example

uses a hyphen as a delimiter:<a id="hevea_default529"></a>

<a id="hevea_default531"></a><pre class="verbatim">>>> s = 'spam-spam-spam'

>>> delimiter = '-'

>>> s.split(delimiter)

['spam', 'spam', 'spam']

</pre>join is the inverse of split. It

takes a list of strings and

concatenates the elements. join is a string method,

so you have to invoke it on the delimiter and pass the

list as a parameter:<a id="hevea_default532"></a>

<a id="hevea_default534"></a><pre class="verbatim">>>> t = ['pining', 'for', 'the', 'fjords']

>>> delimiter = ' '

>>> delimiter.join(t)

'pining for the fjords'

</pre>In this case the delimiter is a space character, so

join puts a space between words. To concatenate

strings without spaces, you can use the empty string,

<code>"</code>, as a delimiter. <a id="hevea_default535"></a>

<h2 class="section" id="sec110">8.10&#XA0;&#XA0;Parsing lines</h2>

Usually when we are reading a file

we want to do something to the lines other than just

printing the whole line. Often we want to find the &#X201C;interesting

lines&#X201D; and then parse the line to find some interesting

part of the line. What if we wanted to print out the day of the

week from those lines that start with &#X201C;From &#X201D;.<pre>

From stephen.marquard@uct.ac.za Sat Jan 5 09:14:16 2008

</pre>The split method is very effective when faced with this

kind of problem.

We can write a small program that looks for lines where the

line starts with &#X201C;From &#X201D; and then split those lines

and then print out the third word in the line:<pre class="verbatim">fhand = open('mbox-short.txt')

for line in fhand:

line = line.rstrip()

if not line.startswith('From ') : continue

words = line.split()

print words[2]

</pre>We also use the contracted form of the if

statement where we put the continue on the

same line as the if. This contracted form

of the if functions the same as if the

continue were on the next line and indented.The program produces the following output:<pre class="verbatim">Sat

Fri

...

</pre>Later, we will learn increasingly sophisticated techniques for

picking the lines to work on and how we pull those lines apart

to find the exact bit of information we are looking for.

<h2 class="section" id="sec111">8.11&#XA0;&#XA0;Objects and values</h2>

<a id="hevea_default538"></a>If we execute these assignment statements:<pre class="verbatim">a = 'banana'

b = 'banana'

</pre>We know that a and b both refer to a

string, but we don&#X2019;t

know whether they refer to the same string.

There are two possible states:<a id="hevea_default539"></a><div class="center"><img src="book012.png" /></div>In one case, a and b refer to two different objects that

have the same value. In the second case, they refer to the same

object.<a id="hevea_default540"></a>

<a id="hevea_default541"></a>To check whether two variables refer to the same object, you can

use the is operator.<pre class="verbatim">>>> a = 'banana'

>>> b = 'banana'

>>> a is b

True

</pre>In this example, Python only created one string object,

and both a and b refer to it.But when you create two lists, you get two objects:<pre class="verbatim">>>> a = [1, 2, 3]

>>> b = [1, 2, 3]

>>> a is b

False

</pre>In this case we would say that the two lists are equivalent,

because they have the same elements, but not identical, because

they are not the same object. If two objects are identical, they are

also equivalent, but if they are equivalent, they are not necessarily

identical.<a id="hevea_default542"></a>

<a id="hevea_default543"></a>Until now, we have been using &#X201C;object&#X201D; and &#X201C;value&#X201D;

interchangeably, but it is more precise to say that an object has a

value. If you execute a = [1,2,3], a refers to a list

object whose value is a particular sequence of elements. If another

list has the same elements, we would say it has the same value.<a id="hevea_default544"></a>

<h2 class="section" id="sec112">8.12&#XA0;&#XA0;Aliasing</h2>

<a id="hevea_default547"></a>If a refers to an object and you assign b = a,

then both variables refer to the same object:<pre class="verbatim">>>> a = [1, 2, 3]

>>> b = a

>>> b is a

True

</pre>The association of a variable with an object is called a reference. In this example, there are two references to the same

object.<a id="hevea_default548"></a>An object with more than one reference has more

than one name, so we say that the object is aliased.<a id="hevea_default549"></a>If the aliased object is mutable,

changes made with one alias affect

the other:<pre class="verbatim">>>> b[0] = 17

>>> print a

[17, 2, 3]

</pre>Although this behavior can be useful, it is error-prone. In general,

it is safer to avoid aliasing when you are working with mutable

objects.<a id="hevea_default550"></a>For immutable objects like strings, aliasing is not as much of a

problem. In this example:<pre class="verbatim">a = 'banana'

b = 'banana'

</pre>It almost never makes a difference whether a and b refer

to the same string or not.

<h2 class="section" id="sec113">8.13&#XA0;&#XA0;List arguments</h2>

<a id="hevea_default555"></a>When you pass a list to a function, the function gets a reference

to the list.

If the function modifies a list parameter, the caller sees the change.

For example, <code>delete_head</code> removes the first element from a list:<pre class="verbatim">def delete_head(t):

del t[0]

</pre>Here&#X2019;s how it is used:<pre class="verbatim">>>> letters = ['a', 'b', 'c']

>>> delete_head(letters)

>>> print letters

['b', 'c']

</pre>The parameter t and the variable letters are

aliases for the same object. It is important to distinguish between operations that

modify lists and operations that create new lists. For

example, the append method modifies a list, but the

+ operator creates a new list:<a id="hevea_default556"></a>

<a id="hevea_default559"></a><pre class="verbatim">>>> t1 = [1, 2]

>>> t2 = t1.append(3)

>>> print t1

[1, 2, 3]

>>> print t2

None

>>> t3 = t1 + [3]

>>> print t3

[1, 2, 3]

>>> t2 is t3

False

</pre>This difference is important when you write functions that

are supposed to modify lists. For example, this function

does not delete the head of a list:<pre class="verbatim">def bad_delete_head(t):

t = t[1:] # WRONG!

</pre>The slice operator creates a new list and the assignment

makes t refer to it, but none of that has any effect

on the list that was passed as an argument.<a id="hevea_default560"></a>

<a id="hevea_default561"></a>An alternative is to write a function that creates and

returns a new list. For

example, tail returns all but the first

element of a list:<pre class="verbatim">def tail(t):

return t[1:]

</pre>This function leaves the original list unmodified.

Here&#X2019;s how it is used:<pre class="verbatim">>>> letters = ['a', 'b', 'c']

>>> rest = tail(letters)

>>> print rest

['b', 'c']

</pre><div class="theorem">Exercise&#XA0;1&#XA0;&#XA0;Write a function called chop that takes a list and modifies

it, removing the first and last elements, and returns None.Then write a function called middle that takes a list and

returns a new list that contains all but the first and last

elements.</div>

<h2 class="section" id="sec114">8.14&#XA0;&#XA0;Debugging</h2>

<a id="hevea_default562"></a>Careless use of lists (and other mutable objects)

can lead to long hours of debugging. Here are some common

pitfalls and ways to avoid them:<ol class="enumerate" type="1"><li class="li-enumerate">Don&#X2019;t forget that most list methods modify the argument and

return None. This is the opposite of the string methods,

which return a new string and leave the original alone.If you are used to writing string code like this:<pre class="verbatim">word = word.strip()

</pre>It is tempting to write list code like this:<pre class="verbatim">t = t.sort() # WRONG!

</pre><a id="hevea_default563"></a>

<a id="hevea_default564"></a>Because sort returns None, the

next operation you perform with t is likely to fail.Before using list methods and operators, you should read the

documentation carefully and then test them in interactive mode. The

methods and operators that lists share with other sequences (like

strings) are documented at

docs.python.org/lib/typesseq.html. The

methods and operators that only apply to mutable sequences

are documented at docs.python.org/lib/typesseq-mutable.html.</li><li class="li-enumerate">Pick an idiom and stick with it.

<a id="hevea_default565"></a>Part of the problem with lists is that there are too many

ways to do things. For example, to remove an element from

a list, you can use pop, remove, del,

or even a slice assignment.To add an element, you can use the append method or

the + operator. But don&#X2019;t forget that these are right: <pre class="verbatim">t.append(x)

t = t + [x]

</pre>And these are wrong:<pre class="verbatim">t.append([x]) # WRONG!

t = t.append(x) # WRONG!

t + [x] # WRONG!

t = t + x # WRONG!

</pre>Try out each of these examples in interactive mode to make sure

you understand what they do. Notice that only the last

one causes a runtime error; the other three are legal, but they

do the wrong thing.</li><li class="li-enumerate">Make copies to avoid aliasing.<a id="hevea_default566"></a>

<a id="hevea_default567"></a>If you want to use a method like sort that modifies

the argument, but you need to keep the original list as

well, you can make a copy.<pre class="verbatim">orig = t[:]

t.sort()

</pre>In this example you could also use the built-in function sorted,

which returns a new, sorted list and leaves the original alone.

But in that case you should avoid using sorted as a variable

name!</li><li class="li-enumerate">Lists, split, and filesWhen we read and parse files, there are many opportunities

to encounter input that can crash our program so it is a good

idea to revisit the guardian pattern when it comes

writing programs that read through a file

and look for a &#X201C;needle in the haystack&#X201D;.Let&#X2019;s revisit our program that is looking for the day of the

week on the from lines of our file:<pre>

From stephen.marquard@uct.ac.za Sat Jan 5 09:14:16 2008

</pre>Since we are breaking this line into words, we could dispense

with the use of startswith and simply look at the

first word of the line to determine if we are interested

in the line at all. We can use continue to skip lines

that don&#X2019;t have &#X201C;From&#X201D; as the first word as follows:<pre class="verbatim">fhand = open('mbox-short.txt')

for line in fhand:

words = line.split()

if words[0] != 'From' : continue

print words[2]

</pre>This looks much simpler and we don&#X2019;t even need to do the

rstrip to remove the newline at the end of the file.

But is it better?<pre class="verbatim">python search8.py

Sat

Traceback (most recent call last):

File "search8.py", line 5, in <module>

if words[0] != 'From' : continue

IndexError: list index out of range

</pre>It kind of works and we see the day from the first line

(Sat) but then the program fails with a traceback error.

What went wrong? What messed-up data caused our elegant,

clever and very Pythonic program to fail?You could stare at it for a long time and puzzle through

it or ask someone for help, but the quicker and smarter

approach is to add a print statement. The best place

to add the print statement is right before the line where

the program failed and print out the data that seems to be causing

the failure.Now this approach may generate a lot of lines of output but at

least you will immediately have some clue as to the

problem at hand. So we add a print of the variable

words right before line five. We even

add a prefix &#X201C;Debug:&#X201D; to the line so we can keep

our regular output separate from our debug output.<pre class="verbatim">for line in fhand:

words = line.split()

print 'Debug:', words

if words[0] != 'From' : continue

print words[2]

</pre>When we run the program, a lot of output scrolls off the screen

but at the end, we see our debug output and the traceback so

we know what happened just before the traceback.<pre class="verbatim">Debug: ['X-DSPAM-Confidence:', '0.8475']

Debug: ['X-DSPAM-Probability:', '0.0000']

Debug: []

Traceback (most recent call last):

File "search9.py", line 6, in <module>

if words[0] != 'From' : continue

IndexError: list index out of range

</pre>Each debug line is printing the list of words which we get

when we split the line into words. When the program fails

the list of words is empty <code>[]</code>. If we open the file in a text editor

and look at the file, at that point it looks as follows:<pre class="verbatim">X-DSPAM-Result: Innocent

X-DSPAM-Processed: Sat Jan 5 09:14:16 2008

X-DSPAM-Confidence: 0.8475

X-DSPAM-Probability: 0.0000

Details: http://source.sakaiproject.org/viewsvn/?view=rev&rev=39772

</pre>The error occurs when our program encounters a blank line! Of course there

are &#X201C;zero words&#X201D; on a blank line. Why didn&#X2019;t we think of that

when we were writing the code. When the code looks for the first

word (<code>word[0]</code>) to check to see if it matches &#X201C;From&#X201D;,

we get an &#X201C;index out of range&#X201D; error.This of course is the perfect place to add some guardian code

to avoid checking the first word if the first word is not there.

There are many ways to protect this code, we will choose to

check the number of words we have before we look at the first word:<pre class="verbatim">fhand = open('mbox-short.txt')

count = 0

for line in fhand:

words = line.split()

# print 'Debug:', words

if len(words) == 0 : continue

if words[0] != 'From' : continue

print words[2]

</pre>First we commented out the debug print statement instead of removing it

in case our modification fails and we need to debug again. Then we added

a guardian statement that checks to see if we have zero words, and if so,

we use continue to skip to the next line in the file.We can think of the two continue statements as helping us refine

the set of lines which are &#X201C;interesting&#X201D; to us and which we want

to process some more. A line which has no words is &#X201C;uninteresting&#X201D; to

us so we skip to the next line. A line which does not have &#X201C;From&#X201D;

as its first word is uninteresting to us so we skip it.The program as modified runs successfully so perhaps it is correct. Our

guardian statement does make sure that the words[0] will never fail,

but perhaps it is not enough. When we are programming, we must always be

thinking, &#X201C;What might go wrong?&#X201D;.<div class="theorem">Exercise&#XA0;2&#XA0;&#XA0;

Figure out which line of the above program is still not properly guarded.

See if you can construct a text file which causes the program to fail

and then modify the program so that the line is properly guarded and

test it to make sure it handles your new text file.

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

Rewrite the guardian code in the above example without two

if statements. Instead use a compound logical expression using the

and logical operator with a single if statement.

</div></li></ol>

<h2 class="section" id="sec115">8.15&#XA0;&#XA0;Glossary</h2>

<dl class="description"><dt class="dt-description">aliasing:</dt><dd class="dd-description"> A circumstance where two or more variables refer to the same

object.

<a id="hevea_default568"></a></dd><dt class="dt-description">delimiter:</dt><dd class="dd-description"> A character or string used to indicate where a

string should be split.

<a id="hevea_default569"></a></dd><dt class="dt-description">element:</dt><dd class="dd-description"> One of the values in a list (or other sequence),

also called items.

<a id="hevea_default570"></a></dd><dt class="dt-description">equivalent:</dt><dd class="dd-description"> Having the same value.

<a id="hevea_default571"></a></dd><dt class="dt-description">index:</dt><dd class="dd-description"> An integer value that indicates an element in a list.

<a id="hevea_default572"></a></dd><dt class="dt-description">identical:</dt><dd class="dd-description"> Being the same object (which implies equivalence).

<a id="hevea_default573"></a></dd><dt class="dt-description">list:</dt><dd class="dd-description"> A sequence of values.

<a id="hevea_default574"></a></dd><dt class="dt-description">list traversal:</dt><dd class="dd-description"> The sequential accessing of each element in a list.

<a id="hevea_default575"></a></dd><dt class="dt-description">nested list:</dt><dd class="dd-description"> A list that is an element of another list.

<a id="hevea_default576"></a></dd><dt class="dt-description">object:</dt><dd class="dd-description"> Something a variable can refer to. An object

has a type and a value.

<a id="hevea_default577"></a></dd><dt class="dt-description">reference:</dt><dd class="dd-description"> The association between a variable and its value.

<h2 class="section" id="sec116">8.16&#XA0;&#XA0;Exercises</h2>

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

Download a copy of the file from

www.py4inf.com/code/romeo.txt

<a id="hevea_default579"></a>Write a program to open the file romeo.txt and read it

line by line. For each line, split the line into a list of

words using the split function.For each word, check to see if the word is already in a list.

If the word is not in the list, add it to the list. When the program completes, sort and print the resulting words

in alphabetical order.<pre class="verbatim">Enter file: romeo.txt

['Arise', 'But', 'It', 'Juliet', 'Who', 'already',

'and', 'breaks', 'east', 'envious', 'fair', 'grief',

'is', 'kill', 'light', 'moon', 'pale', 'sick', 'soft',

'sun', 'the', 'through', 'what', 'window',

'with', 'yonder']

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

Write a program to read through the mail box data and when you find

line that starts with &#X201C;From&#X201D;, you will split the line into

words using the split function. We are interested in

who sent the message which is the second word on the From line.From stephen.marquard@uct.ac.za Sat Jan 5 09:14:16 2008 You will parse the From line and print out the second word for

each From line and then you will also count the number of

From (not From:) lines and print out a count at the end.This is a good sample output with a few lines removed:<pre class="verbatim">python fromcount.py

Enter a file name: mbox-short.txt

stephen.marquard@uct.ac.za

louis@media.berkeley.edu

zqian@umich.edu

[...some output removed...]

ray@media.berkeley.edu

cwen@iupui.edu

There were 27 lines in the file with From as the first word

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

Rewrite the program that prompts the user for a list of

numbers and prints out the maximum and minimum of the

numbers at the end when the user enters &#X201C;done&#X201D;. Write

the program to store the numbers the user enters in a list

and use the max() and min() functions to

compute the maximum and minimum numbers after the

loop completes.<pre class="verbatim">Enter a number: 6

Enter a number: 2

Enter a number: 9

Enter a number: 3

Enter a number: 5

Enter a number: done

Maximum: 9.0

Minimum: 2.0

</pre></div>

<hr />

</body>

</html>

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

FilesExpand file tree

book009.html

Latest commit

History

book009.html

File metadata and controls