git-basics-tutorial/thinkpython2009.html at master · etyme/git-basics-tutorial

History

626 lines (589 loc) · 38.6 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

<!DOCTYPE html>

<html>

<head>

<title>Strings</title>

</head>

<body>

Toggle navigation

</button>

<a class="navbar-brand" href="#">Think Python - How to Think like a Computer Scientist (2e) by Allen B. Downey</a>

</div>

<div>

</ul>

<div>

</div>

</nav>

<table>

<tr>

</td>

<h1 class="chapter" id="sec91">Chapter&#XA0;8&#XA0;&#XA0;Strings</h1>

<a id="strings"></a>Strings are not like integers, floats, and booleans. A string

is a sequence, which means it is

an ordered collection of other values. In this chapter you&#X2019;ll see

how to access the characters that make up a string, and you&#X2019;ll

learn about some of the methods strings provide.

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

A string is a sequence of characters.

You can access the characters one at a time with the

bracket operator:<pre class="verbatim">>>> fruit = 'banana'

>>> letter = fruit[1]

</pre>The second statement selects character number 1 from fruit and assigns it to letter.

<a id="hevea_default546"></a>The expression in brackets is called an index.

The index indicates which character in the sequence you

want (hence the name).But you might not get what you expect:<pre class="verbatim">>>> letter

'a'

</pre>For most people, the first letter of <code>'banana'</code> is b, not

a. But for computer scientists, the index is an offset from the

beginning of the string, and the offset of the first letter is zero.<pre class="verbatim">>>> letter = fruit[0]

>>> letter

'b'

</pre>So b is the 0th letter (&#X201C;zero-eth&#X201D;) of <code>'banana'</code>, a is the 1th letter (&#X201C;one-eth&#X201D;), and n is the 2th letter

(&#X201C;two-eth&#X201D;). <a id="hevea_default547"></a> <a id="hevea_default548"></a>As an index you can use an expression that contains variables and

operators:

<a id="hevea_default549"></a><pre class="verbatim">>>> i = 1

>>> fruit[i]

'a'

>>> fruit[i+1]

'n'

</pre>But the value of the index has to be an integer. Otherwise you

get:

<a id="hevea_default551"></a><pre class="verbatim">>>> letter = fruit[1.5]

TypeError: string indices must be integers

</pre>

<a id="hevea_default553"></a>len is a built-in function that returns the number of characters

in a string:<pre class="verbatim">>>> fruit = 'banana'

>>> len(fruit)

</pre>To get the last letter of a string, you might be tempted to try something

like this:

<a id="hevea_default555"></a><pre class="verbatim">>>> length = len(fruit)

>>> last = fruit[length]

IndexError: string index out of range

</pre>The reason for the IndexError is that there is no letter in &#X2019;banana&#X2019; with the index 6. Since we started counting at zero, the

six letters are numbered 0 to 5. To get the last character, you have

to subtract 1 from length:<pre class="verbatim">>>> last = fruit[length-1]

>>> last

'a'

</pre>Or you can use negative indices, which count backward from

the end of the string. The expression fruit[-1] yields the last

letter, fruit[-2] yields the second to last, and so on.

<h2 class="section" id="sec94">8.3&#XA0;&#XA0;Traversal with a for loop</h2>

<a id="hevea_default563"></a>A lot of computations involve processing a string one character at a

time. Often they start at the beginning, select each character in

turn, do something to it, and continue until the end. This pattern of

processing is called a traversal. One way to write a traversal

is with a while loop:<pre class="verbatim">index = 0

while index < len(fruit):

letter = fruit[index]

print(letter)

index = index + 1

</pre>This loop traverses the string and displays each letter on a line by

itself. The loop condition is index < len(fruit), so

when index is equal to the length of the string, the

condition is false, and the body of the loop doesn&#X2019;t run. The

last character accessed is the one with the index len(fruit)-1,

which is the last character in the string.As an exercise, write a function that takes a string as an argument

and displays the letters backward, one per line.Another way to write a traversal is with a for loop:<pre class="verbatim">for letter in fruit:

print(letter)

</pre>Each time through the loop, the next character in the string is assigned

to the variable letter. The loop continues until no characters are

left.

<a id="hevea_default566"></a>The following example shows how to use concatenation (string addition)

and a for loop to generate an abecedarian series (that is, in

alphabetical order). In Robert McCloskey&#X2019;s book Make

Way for Ducklings, the names of the ducklings are Jack, Kack, Lack,

Mack, Nack, Ouack, Pack, and Quack. This loop outputs these names in

order:<pre class="verbatim">prefixes = 'JKLMNOPQ'

suffix = 'ack'

for letter in prefixes:

print(letter + suffix)

</pre>The output is:<pre class="verbatim">Jack

Kack

Lack

Mack

Nack

Oack

Pack

Qack

</pre>Of course, that&#X2019;s not quite right because &#X201C;Ouack&#X201D; and &#X201C;Quack&#X201D; are

misspelled. As an exercise, modify the program to fix this error.

<h2 class="section" id="sec95">8.4&#XA0;&#XA0;String slices</h2>

<a id="hevea_default570"></a> <a id="hevea_default571"></a>A segment of a string is called a slice. Selecting a slice is

similar to selecting a character:<pre class="verbatim">>>> s = 'Monty Python'

>>> s[0:5]

'Monty'

>>> s[6:12]

'Python'

</pre>The operator [n:m] returns the part of the string from the

&#X201C;n-eth&#X201D; character to the &#X201C;m-eth&#X201D; character, including the first but

excluding the last. This behavior is counterintuitive, but it might

help to imagine the indices pointing between the

characters, as in Figure&#XA0;<a href="thinkpython2009.html#fig.banana">8.1</a>.<blockquote class="figure"><div class="center"><hr class="c019"></div>

<div class="caption"><table class="c001 cellpading0"><tr><td class="c018">Figure 8.1: Slice indices.</td></tr>

</table></div>

<div class="center"><hr class="c019"></div></blockquote>If you omit the first index (before the colon), the slice starts at

the beginning of the string. If you omit the second index, the slice

goes to the end of the string:<pre class="verbatim">>>> fruit = 'banana'

>>> fruit[:3]

'ban'

>>> fruit[3:]

'ana'

</pre>If the first index is greater than or equal to the second the result

is an empty string, represented by two quotation marks:

<a id="hevea_default572"></a><pre class="verbatim">>>> fruit = 'banana'

>>> fruit[3:3]

</pre>An empty string contains no characters and has length 0, but other

than that, it is the same as any other string.Continuing this example, what do you think

fruit[:] means? Try it and see.

<h2 class="section" id="sec96">8.5&#XA0;&#XA0;Strings are immutable</h2>

<a id="hevea_default577"></a>It is tempting to use the [] operator on the left side of an

assignment, with the intention of changing a character in a string.

For example:

<a id="hevea_default579"></a><pre class="verbatim">>>> greeting = 'Hello, world!'

>>> greeting[0] = 'J'

TypeError: 'str' object does not support item assignment

</pre>The &#X201C;object&#X201D; in this case is the string and the &#X201C;item&#X201D; is

the character you tried to assign. For now, an object is

the same thing as a value, but we will refine that definition

later (Section&#XA0;<a href="thinkpython2011.html#equivalence">10.10</a>).

<a id="hevea_default584"></a>The reason for the error is that

strings are immutable, which means you can&#X2019;t change an

existing string. The best you can do is create a new string

that is a variation on the original:<pre class="verbatim">>>> greeting = 'Hello, world!'

>>> new_greeting = 'J' + greeting[1:]

>>> new_greeting

'Jello, world!'

</pre>This example concatenates a new first letter onto

a slice of greeting. It has no effect on

the original string.

<h2 class="section" id="sec97">8.6&#XA0;&#XA0;Searching</h2>

<a id="find"></a>What does the following function do?

<a id="hevea_default587"></a><pre class="verbatim">def find(word, letter):

index = 0

while index < len(word):

if word[index] == letter:

return index

index = index + 1

return -1

</pre>In a sense, find is the inverse of the [] operator.

Instead of taking an index and extracting the corresponding character,

it takes a character and finds the index where that character

appears. If the character is not found, the function returns -1.This is the first example we have seen of a return statement

inside a loop. If word[index] == letter, the function breaks

out of the loop and returns immediately.If the character doesn&#X2019;t appear in the string, the program

exits the loop normally and returns -1.This pattern of computation&#X2014;traversing a sequence and returning

when we find what we are looking for&#X2014;is called a search.

<a id="hevea_default590"></a>As an exercise, modify find so that it has a

third parameter, the index in word where it should start

looking.

<h2 class="section" id="sec98">8.7&#XA0;&#XA0;Looping and counting</h2>

<a id="hevea_default594"></a>The following program counts the number of times the letter a

appears in a string:<pre class="verbatim">word = 'banana'

count = 0

for letter in word:

if letter == 'a':

count = count + 1

print(count)

</pre>This program demonstrates another pattern of computation called a counter. The variable count is initialized to 0 and then

incremented each time an a is found.

When the loop exits, count

contains the result&#X2014;the total number of a&#X2019;s.<a id="hevea_default595"></a>

As an exercise, encapsulate this code in a function named count, and generalize it so that it accepts the string and the

letter as arguments.Then rewrite the function so that instead of

traversing the string, it uses the three-parameter version of find from the previous section.

<h2 class="section" id="sec99">8.8&#XA0;&#XA0;String methods</h2>

<a id="optional"></a>Strings provide methods that perform a variety of useful operations.

A method is similar to a function&#X2014;it takes arguments and

returns a value&#X2014;but the syntax is different. For example, the

method upper takes a string and returns a new string with

all uppercase letters.

<a id="hevea_default597"></a>Instead of the function syntax upper(word), it uses

the method syntax word.upper().<pre class="verbatim">>>> word = 'banana'

>>> new_word = word.upper()

>>> new_word

'BANANA'

</pre>This form of dot notation specifies the name of the method, upper, and the name of the string to apply the method to, word. The empty parentheses indicate that this method takes no

arguments.

<a id="hevea_default599"></a>A method call is called an invocation; in this case, we would

say that we are invoking upper on word.

<a id="hevea_default600"></a>As it turns out, there is a string method named find that

is remarkably similar to the function we wrote:<pre class="verbatim">>>> word = 'banana'

>>> index = word.find('a')

>>> index

</pre>In this example, we invoke find on word and pass

the letter we are looking for as a parameter.Actually, the find method is more general than our function;

it can find substrings, not just characters:<pre class="verbatim">>>> word.find('na')

</pre>By default, find starts at the beginning of the string, but

it can take a second argument, the index where it should start:

<a id="hevea_default602"></a><pre class="verbatim">>>> word.find('na', 3)

</pre>This is an example of an optional argument;

find can

also take a third argument, the index where it should stop:<pre class="verbatim">>>> name = 'bob'

>>> name.find('b', 1, 2)

-1

</pre>This search fails because b does not

appear in the index range from 1 to 2, not including 2. Searching up to, but not including, the second index makes

find consistent with the slice operator.

<h2 class="section" id="sec100">8.9&#XA0;&#XA0;The in operator</h2>

<a id="hevea_default606"></a>The word in is a boolean operator that takes two strings and

returns True if the first appears as a substring in the second:<pre class="verbatim">>>> 'a' in 'banana'

True

>>> 'seed' in 'banana'

False

</pre>For example, the following function prints all the

letters from word1 that also appear in word2:<pre class="verbatim">def in_both(word1, word2):

for letter in word1:

if letter in word2:

print(letter)

</pre>With well-chosen variable names,

Python sometimes reads like English. You could read

this loop, &#X201C;for (each) letter in (the first) word, if (the) letter

(appears) in (the second) word, print (the) letter.&#X201D;Here&#X2019;s what you get if you compare apples and oranges:<pre class="verbatim">>>> in_both('apples', 'oranges')

</pre>

<h2 class="section" id="sec101">8.10&#XA0;&#XA0;String comparison</h2>

<a id="hevea_default608"></a>The relational operators work on strings. To see if two strings are equal:<pre class="verbatim">if word == 'banana':

print('All right, bananas.')

</pre>Other relational operations are useful for putting words in alphabetical

order:<pre class="verbatim">if word < 'banana':

print('Your word, ' + word + ', comes before banana.')

elif word > 'banana':

print('Your word, ' + word + ', comes after banana.')

else:

print('All right, bananas.')

</pre>Python does not handle uppercase and lowercase letters the same way

people do. All the uppercase letters come before all the

lowercase letters, so:<pre class="verbatim">Your word, Pineapple, comes before banana.

</pre>A common way to address this problem is to convert strings to a

standard format, such as all lowercase, before performing the

comparison. Keep that in mind in case you have to defend yourself

against a man armed with a Pineapple.

<h2 class="section" id="sec102">8.11&#XA0;&#XA0;Debugging</h2>

<a id="hevea_default610"></a>When you use indices to traverse the values in a sequence,

it is tricky to get the beginning and end of the traversal

right. Here is a function that is supposed to compare two

words and return True if one of the words is the reverse

of the other, but it contains two errors:<pre class="verbatim">def is_reverse(word1, word2):

if len(word1) != len(word2):

return False

i = 0

j = len(word2)

while j > 0:

if word1[i] != word2[j]:

return False

i = i+1

j = j-1

return True

</pre>The first if statement checks whether the words are the

same length. If not, we can return False immediately.

Otherwise, for the rest of the function, we can assume that the words

are the same length. This is an example of the guardian pattern

in Section&#XA0;<a href="thinkpython2007.html#guardian">6.8</a>.

<a id="hevea_default613"></a>i and j are indices: i traverses word1

forward while j traverses word2 backward. If we find

two letters that don&#X2019;t match, we can return False immediately.

If we get through the whole loop and all the letters match, we

return True.If we test this function with the words &#X201C;pots&#X201D; and &#X201C;stop&#X201D;, we

expect the return value True, but we get an IndexError:

<a id="hevea_default615"></a><pre class="verbatim">>>> is_reverse('pots', 'stop')

...

File "reverse.py", line 15, in is_reverse

if word1[i] != word2[j]:

IndexError: string index out of range

</pre>For debugging this kind of error, my first move is to

print the values of the indices immediately before the line

where the error appears.<pre class="verbatim"> while j > 0:

print(i, j) # print here

if word1[i] != word2[j]:

return False

i = i+1

j = j-1

</pre>Now when I run the program again, I get more information:<pre class="verbatim">>>> is_reverse('pots', 'stop')

0 4

...

IndexError: string index out of range

</pre>The first time through the loop, the value of j is 4,

which is out of range for the string <code>'pots'</code>.

The index of the last character is 3, so the

initial value for j should be len(word2)-1.If I fix that error and run the program again, I get:<pre class="verbatim">>>> is_reverse('pots', 'stop')

0 3

1 2

2 1

True

</pre>This time we get the right answer, but it looks like the loop only ran

three times, which is suspicious. To get a better idea of what is

happening, it is useful to draw a state diagram. During the first

iteration, the frame for <code>is_reverse</code> is shown in

Figure&#XA0;<a href="thinkpython2009.html#fig.state4">8.2</a>. <a id="hevea_default616"></a> <a id="hevea_default617"></a><blockquote class="figure"><div class="center"><hr class="c019"></div>

<div class="caption"><table class="c001 cellpading0"><tr><td class="c018">Figure 8.2: State diagram.</td></tr>

</table></div>

<div class="center"><hr class="c019"></div></blockquote>I took some license by arranging the variables in the frame

and adding dotted lines to show that the values of i and

j indicate characters in word1 and word2.Starting with this diagram, run the program on paper, changing the

values of i and j during each iteration. Find and fix the

second error in this function.

<h2 class="section" id="sec103">8.12&#XA0;&#XA0;Glossary</h2>

<dl class="description"><dt class="dt-description">object:</dt><dd class="dd-description"> Something a variable can refer to. For now,

you can use &#X201C;object&#X201D; and &#X201C;value&#X201D; interchangeably.

<a id="hevea_default618"></a></dd><dt class="dt-description">sequence:</dt><dd class="dd-description"> An ordered collection of

values where each value is identified by an integer index.

<a id="hevea_default619"></a></dd><dt class="dt-description">item:</dt><dd class="dd-description"> One of the values in a sequence.

<a id="hevea_default620"></a></dd><dt class="dt-description">index:</dt><dd class="dd-description"> An integer value used to select an item in

a sequence, such as a character in a string. In Python

indices start from 0.

<a id="hevea_default621"></a></dd><dt class="dt-description">slice:</dt><dd class="dd-description"> A part of a string specified by a range of indices.

<a id="hevea_default622"></a></dd><dt class="dt-description">empty string:</dt><dd class="dd-description"> A string with no characters and length 0, represented

by two quotation marks.

<a id="hevea_default623"></a></dd><dt class="dt-description">immutable:</dt><dd class="dd-description"> The property of a sequence whose items cannot

be changed.

<a id="hevea_default624"></a></dd><dt class="dt-description">traverse:</dt><dd class="dd-description"> To iterate through the items in a sequence,

performing a similar operation on each.

<a id="hevea_default625"></a></dd><dt class="dt-description">search:</dt><dd class="dd-description"> A pattern of traversal that stops

when it finds what it is looking for.

<a id="hevea_default627"></a></dd><dt class="dt-description">counter:</dt><dd class="dd-description"> A variable used to count something, usually initialized

to zero and then incremented.

<a id="hevea_default628"></a></dd><dt class="dt-description">invocation:</dt><dd class="dd-description"> A statement that calls a method.

<a id="hevea_default629"></a></dd><dt class="dt-description">optional argument:</dt><dd class="dd-description"> A function or method argument that is not

required.

<h2 class="section" id="sec104">8.13&#XA0;&#XA0;Exercises</h2>

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

<a id="hevea_default633"></a>Read the documentation of the string methods at

<a href="http://docs.python.org/3/library/stdtypes.html#string-methods">http://docs.python.org/3/library/stdtypes.html#string-methods</a>.

You might want to experiment with some of them to make sure you

understand how they work. strip and replace are

particularly useful.The documentation uses a syntax that might be confusing.

For example, in <code>find(sub[, start[, end]])</code>, the brackets

indicate optional arguments. So sub is required, but

start is optional, and if you include start,

then end is optional.

<a id="hevea_default635"></a></div><div class="theorem">Exercise&#XA0;2&#XA0;&#XA0;

<a id="hevea_default637"></a>There is a string method called count that is similar

to the function in Section&#XA0;<a href="thinkpython2009.html#counter">8.7</a>. Read the documentation

of this method

and write an invocation that counts the number of a&#X2019;s

in <code>'banana'</code>.

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

<a id="hevea_default640"></a>A string slice can take a third index that specifies the &#X201C;step

size&#X201D;; that is, the number of spaces between successive characters.

A step size of 2 means every other character; 3 means every third,

etc.<pre class="verbatim">>>> fruit = 'banana'

>>> fruit[0:5:2]

'bnn'

</pre>A step size of -1 goes through the word backwards, so

the slice <code>[::-1]</code> generates a reversed string.

<a id="hevea_default641"></a>Use this idiom to write a one-line version of <code>is_palindrome</code>

from Exercise&#XA0;<a href="thinkpython2007.html#palindrome">3</a>.

</div><div class="theorem">Exercise&#XA0;4&#XA0;&#XA0;The following functions are all intended to check whether a

string contains any lowercase letters, but at least some of them are

wrong. For each function, describe what the function actually does

(assuming that the parameter is a string).<pre class="verbatim">def any_lowercase1(s):

for c in s:

if c.islower():

return True

else:

return False

def any_lowercase2(s):

for c in s:

if 'c'.islower():

return 'True'

else:

return 'False'

def any_lowercase3(s):

for c in s:

flag = c.islower()

return flag

def any_lowercase4(s):

flag = False

for c in s:

flag = flag or c.islower()

return flag

def any_lowercase5(s):

for c in s:

if not c.islower():

return False

return True

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

A Caesar cypher is a weak form of encryption that involves &#X201C;rotating&#X201D; each

letter by a fixed number of places. To rotate a letter means

to shift it through the alphabet, wrapping around to the beginning if

necessary, so &#X2019;A&#X2019; rotated by 3 is &#X2019;D&#X2019; and &#X2019;Z&#X2019; rotated by 1 is &#X2019;A&#X2019;.To rotate a word, rotate each letter by the same amount.

For example, &#X201C;cheer&#X201D; rotated by 7 is &#X201C;jolly&#X201D; and &#X201C;melon&#X201D; rotated

by -10 is &#X201C;cubed&#X201D;. In the movie 2001: A Space Odyssey, the

ship computer is called HAL, which is IBM rotated by -1.Write a function called <code>rotate_word</code>

that takes a string and an integer as parameters, and returns

a new string that contains the letters from the original string

rotated by the given amount. You might want to use the built-in function ord, which converts

a character to a numeric code, and chr, which converts numeric

codes to characters. Letters of the alphabet are encoded in alphabetical

order, so for example:<pre class="verbatim">>>> ord('c') - ord('a')

</pre>Because <code>'c'</code> is the two-eth letter of the alphabet. But

beware: the numeric codes for upper case letters are different.Potentially offensive jokes on the Internet are sometimes encoded in

ROT13, which is a Caesar cypher with rotation 13. If you are not

easily offended, find and decode some of them. Solution:

<a href="http://thinkpython2.com/code/rotate.py">http://thinkpython2.com/code/rotate.py</a>.</div>

</td>

<h4>Are you using one of our books in a class?</h4> We'd like to know

about it. Please consider filling out <a href="http://spreadsheets.google.com/viewform?formkey=dC0tNUZkMjBEdXVoRGljNm9FRmlTMHc6MA" onClick="javascript: pageTracker._trackPageview('/outbound/survey');">this short survey</a>.

<a rel="nofollow" href="http://www.amazon.com/gp/product/1491938455/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1491938455&linkCode=as2&tag=greenteapre01-20&linkId=2JJH4SWCAVVYSQHO">Think DSP</a><img class="c003" src="http://ir-na.amazon-adsystem.com/e/ir?t=greenteapre01-20&l=as2&o=1&a=1491938455" width="1" height="1" border="0" alt="">

<a rel="nofollow" href="http://www.amazon.com/gp/product/1491929561/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1491929561&linkCode=as2&tag=greenteapre01-20&linkId=ZY6MAYM33ZTNSCNZ">Think Java</a><img class="c003" src="http://ir-na.amazon-adsystem.com/e/ir?t=greenteapre01-20&l=as2&o=1&a=1491929561" width="1" height="1" border="0" alt="">

<a href="http://www.amazon.com/gp/product/1449370780/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1449370780&linkCode=as2&tag=greenteapre01-20">Think Bayes</a><img class="c003" src="http://ir-na.amazon-adsystem.com/e/ir?t=greenteapre01-20&l=as2&o=1&a=1449370780" width="1" height="1" border="0" alt="">

<a rel="nofollow" href="http://www.amazon.com/gp/product/1491939362/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1491939362&linkCode=as2&tag=greenteapre01-20&linkId=FJKSQ3IHEMY2F2VA">Think Python 2e</a><img class="c003" src="http://ir-na.amazon-adsystem.com/e/ir?t=greenteapre01-20&l=as2&o=1&a=1491939362" width="1" height="1" border="0" alt="">

<a href="http://www.amazon.com/gp/product/1491907339/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1491907339&linkCode=as2&tag=greenteapre01-20&linkId=O7WYM6H6YBYUFNWU">Think Stats 2e</a><img class="c003" src="http://ir-na.amazon-adsystem.com/e/ir?t=greenteapre01-20&l=as2&o=1&a=1491907339" width="1" height="1" border="0" alt="">

<a href="http://www.amazon.com/gp/product/1449314635/ref=as_li_tf_tl?ie=UTF8&tag=greenteapre01-20&linkCode=as2&camp=1789&creative=9325&creativeASIN=1449314635">Think Complexity</a><img class="c003" src="http://www.assoc-amazon.com/e/ir?t=greenteapre01-20&l=as2&o=1&a=1449314635" width="1" height="1" border="0" alt="">

</td>

</tr>

</table>

Toggle navigation

</button>

<a class="navbar-brand" href="#">Think Python - How to Think like a Computer Scientist (2e) by Allen B. Downey</a>

</div>

<div>

</ul>

<div>

</div>

</nav></body>

</html>

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

FilesExpand file tree

thinkpython2009.html

Latest commit

History

thinkpython2009.html

File metadata and controls