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

History

588 lines (558 loc) · 40.5 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

<!DOCTYPE html>

<html>

<head>

<title>Files</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="sec164">Chapter&#XA0;14&#XA0;&#XA0;Files</h1>

This chapter introduces the idea of &#X201C;persistent&#X201D; programs that

keep data in permanent storage, and shows how to use different

kinds of permanent storage, like files and databases.

<h2 class="section" id="sec165">14.1&#XA0;&#XA0;Persistence</h2>

<a id="hevea_default1208"></a>Most of the programs we have seen so far are transient in the

sense that they run for a short time and produce some output,

but when they end, their data disappears. If you run the program

again, it starts with a clean slate.Other programs are persistent: they run for a long time

(or all the time); they keep at least some of their data

in permanent storage (a hard drive, for example); and

if they shut down and restart, they pick up where they left off.Examples of persistent programs are operating systems, which

run pretty much whenever a computer is on, and web servers,

which run all the time, waiting for requests to come in on

the network.One of the simplest ways for programs to maintain their data

is by reading and writing text files. We have already seen

programs that read text files; in this chapter we will see programs

that write them.An alternative is to store the state of the program in a database.

In this chapter I will present a simple database and a module,

pickle, that makes it easy to store program data.

<h2 class="section" id="sec166">14.2&#XA0;&#XA0;Reading and writing</h2>

<a id="hevea_default1211"></a>A text file is a sequence of characters stored on a permanent

medium like a hard drive, flash memory, or CD-ROM. We saw how

to open and read a file in Section&#XA0;<a href="thinkpython2010.html#wordlist">9.1</a>.

<a id="hevea_default1213"></a>To write a file, you have to open it with mode <code>'w'</code> as a second

parameter:<pre class="verbatim">>>> fout = open('output.txt', 'w')

</pre>If the file already exists, opening it in write mode clears out

the old data and starts fresh, so be careful!

If the file doesn&#X2019;t exist, a new one is created.open returns a file object that provides methods for working

with the file.

The write method puts data into the file.<pre class="verbatim">>>> line1 = "This here's the wattle,\n"

>>> fout.write(line1)

</pre>The return value is the number of characters that were written.

The file object keeps track of where it is, so if

you call write again, it adds the new data to the end of

the file.<pre class="verbatim">>>> line2 = "the emblem of our land.\n"

>>> fout.write(line2)

</pre>When you are done writing, you should close the file.<pre class="verbatim">>>> fout.close()

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

If you don&#X2019;t close the file, it gets closed for you when the

program ends.

<h2 class="section" id="sec167">14.3&#XA0;&#XA0;Format operator</h2>

<a id="hevea_default1217"></a>The argument of write has to be a string, so if we want

to put other values in a file, we have to convert them to

strings. The easiest way to do that is with str:<pre class="verbatim">>>> x = 52

>>> fout.write(str(x))

</pre>An alternative is to use the format operator, %. When

applied to integers, % is the modulus operator. But

when the first operand is a string, % is the format operator.

<a id="hevea_default1218"></a>The first operand is the format string, which contains

one or more format sequences, which

specify how

the second operand is formatted. The result is a string.

<a id="hevea_default1219"></a>For example, the format sequence <code>'%d'</code> means that

the second operand should be formatted as a decimal

integer:<pre class="verbatim">>>> camels = 42

>>> '%d' % camels

'42'

</pre>The result is the string <code>'42'</code>, which is not to be confused

with the integer value 42.A format sequence can appear anywhere in the string,

so you can embed a value in a sentence:<pre class="verbatim">>>> 'I have spotted %d camels.' % camels

'I have spotted 42 camels.'

</pre>If there is more than one format sequence in the string,

the second argument has to be a tuple. Each format sequence is

matched with an element of the tuple, in order.The following example uses <code>'%d'</code> to format an integer,

<code>'%g'</code> to format a floating-point number, and

<code>'%s'</code> to format a string:<pre class="verbatim">>>> 'In %d years I have spotted %g %s.' % (3, 0.1, 'camels')

'In 3 years I have spotted 0.1 camels.'

</pre>The number of elements in the tuple has to match the number

of format sequences in the string. Also, the types of the

elements have to match the format sequences:

<a id="hevea_default1221"></a><pre class="verbatim">>>> '%d %d %d' % (1, 2)

TypeError: not enough arguments for format string

>>> '%d' % 'dollars'

TypeError: %d format: a number is required, not str

</pre>In the first example, there aren&#X2019;t enough elements; in the

second, the element is the wrong type.For more information on the format operator, see

<a href="https://docs.python.org/3/library/stdtypes.html#printf-style-string-formatting">https://docs.python.org/3/library/stdtypes.html#printf-style-string-formatting</a>. A more powerful alternative is the string

format method, which you can read about at

<a href="https://docs.python.org/3/library/stdtypes.html#str.format">https://docs.python.org/3/library/stdtypes.html#str.format</a>.

<h2 class="section" id="sec168">14.4&#XA0;&#XA0;Filenames and paths</h2>

<a id="hevea_default1225"></a>Files are organized into directories (also called &#X201C;folders&#X201D;).

Every running program has a &#X201C;current directory&#X201D;, which is the

default directory for most operations.

For example, when you open a file for reading, Python looks for it in the

current directory.

<a id="hevea_default1227"></a>The os module provides functions for working with files and

directories (&#X201C;os&#X201D; stands for &#X201C;operating system&#X201D;). os.getcwd

returns the name of the current directory:

<a id="hevea_default1229"></a><pre class="verbatim">>>> import os

>>> cwd = os.getcwd()

>>> cwd

'/home/dinsdale'

</pre>cwd stands for &#X201C;current working directory&#X201D;. The result in

this example is /home/dinsdale, which is the home directory of a

user named dinsdale.

<a id="hevea_default1231"></a>A string like <code>'/home/dinsdale'</code> that identifies a file or

directory is called a path.A simple filename, like memo.txt is also considered a path,

but it is a relative path because it relates to the current

directory. If the current directory is /home/dinsdale, the

filename memo.txt would refer to /home/dinsdale/memo.txt.

<a id="hevea_default1234"></a> <a id="hevea_default1235"></a>A path that begins with / does not depend on the current

directory; it is called an absolute path. To find the absolute

path to a file, you can use os.path.abspath:<pre class="verbatim">>>> os.path.abspath('memo.txt')

'/home/dinsdale/memo.txt'

</pre>os.path provides other functions for working with filenames

and paths. For example,

os.path.exists checks

whether a file or directory exists:

<a id="hevea_default1237"></a><pre class="verbatim">>>> os.path.exists('memo.txt')

True

</pre>If it exists, os.path.isdir checks whether it&#X2019;s a directory:<pre class="verbatim">>>> os.path.isdir('memo.txt')

False

>>> os.path.isdir('/home/dinsdale')

True

</pre>Similarly, os.path.isfile checks whether it&#X2019;s a file.os.listdir returns a list of the files (and other directories)

in the given directory:<pre class="verbatim">>>> os.listdir(cwd)

['music', 'photos', 'memo.txt']

</pre>To demonstrate these functions, the following example

&#X201C;walks&#X201D; through a directory, prints

the names of all the files, and calls itself recursively on

all the directories.

<a id="hevea_default1239"></a><pre class="verbatim">def walk(dirname):

for name in os.listdir(dirname):

path = os.path.join(dirname, name)

if os.path.isfile(path):

print(path)

else:

walk(path)

</pre>os.path.join takes a directory and a file name and joins

them into a complete path. The os module provides a function called walk that is

similar to this one but more versatile. As an exercise, read the

documentation and use it to print the names of the files in a given

directory and its subdirectories. You can download my solution from

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

<h2 class="section" id="sec169">14.5&#XA0;&#XA0;Catching exceptions</h2>

<a id="catch"></a>A lot of things can go wrong when you try to read and write

files. If you try to open a file that doesn&#X2019;t exist, you get an

IOError:

<a id="hevea_default1243"></a><pre class="verbatim">>>> fin = open('bad_file')

IOError: [Errno 2] No such file or directory: 'bad_file'

</pre>If you don&#X2019;t have permission to access a file:

<a id="hevea_default1245"></a><pre class="verbatim">>>> fout = open('/etc/passwd', 'w')

PermissionError: [Errno 13] Permission denied: '/etc/passwd'

</pre>And if you try to open a directory for reading, you get<pre class="verbatim">>>> fin = open('/home')

IsADirectoryError: [Errno 21] Is a directory: '/home'

</pre>To avoid these errors, you could use functions like os.path.exists

and os.path.isfile, but it would take a lot of time and code

to check all the possibilities (if &#X201C;Errno 21&#X201D; is any

indication, there are at least 21 things that can go wrong).

<a id="hevea_default1248"></a>It is better to go ahead and try&#X2014;and deal with problems if they

happen&#X2014;which is exactly what the try statement does. The

syntax is similar to an if...else statement:<pre class="verbatim">try:

fin = open('bad_file')

except:

print('Something went wrong.')

</pre>Python starts by executing the try clause. If all goes

well, it skips the except clause and proceeds. If an

exception occurs, it jumps out of the try clause and

runs the except clause.Handling an exception with a try statement is called catching an exception. In this example, the except clause

prints an error message that is not very helpful. In general,

catching an exception gives you a chance to fix the problem, or try

again, or at least end the program gracefully.

<h2 class="section" id="sec170">14.6&#XA0;&#XA0;Databases</h2>

<a id="hevea_default1249"></a>A database is a file that is organized for storing data. Many

databases are organized like a dictionary in the sense that they map

from keys to values. The biggest difference between a database and a

dictionary is that the database is on disk (or other permanent

storage), so it persists after the program ends. <a id="hevea_default1250"></a> <a id="hevea_default1251"></a>The module dbm provides an interface for creating

and updating database files.

As an example, I&#X2019;ll create a database

that contains captions for image files.

<a id="hevea_default1253"></a>Opening a database is similar to opening other files:<pre class="verbatim">>>> import dbm

>>> db = dbm.open('captions', 'c')

</pre>The mode <code>'c'</code> means that the database should be created if

it doesn&#X2019;t already exist. The result is a database object

that can be used (for most operations) like a dictionary.

<a id="hevea_default1255"></a>When you create a new item, dbm updates the database file.

<a id="hevea_default1256"></a><pre class="verbatim">>>> db['cleese.png'] = 'Photo of John Cleese.'

</pre>When you access one of the items, dbm reads the file:<pre class="verbatim">>>> db['cleese.png']

b'Photo of John Cleese.'

</pre>The result is a bytes object, which is why it begins with b. A bytes object is similar to a string in many ways. When you

get farther into Python, the difference becomes important, but for now

we can ignore it.

<a id="hevea_default1258"></a>If you make another assignment to an existing key, dbm replaces

the old value:<pre class="verbatim">>>> db['cleese.png'] = 'Photo of John Cleese doing a silly walk.'

>>> db['cleese.png']

b'Photo of John Cleese doing a silly walk.'

</pre>Some dictionary methods, like keys and items, don&#X2019;t

work with database objects. But iteration with a for

loop works:

<a id="hevea_default1259"></a><pre class="verbatim">for key in db:

print(key, db[key])

</pre>As with other files, you should close the database when you are

done:<pre class="verbatim">>>> db.close()

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

<h2 class="section" id="sec171">14.7&#XA0;&#XA0;Pickling</h2>

<a id="hevea_default1262"></a>A limitation of dbm is that the keys and values have to be

strings or bytes. If you try to use any other type, you get an error.

<a id="hevea_default1263"></a> <a id="hevea_default1264"></a>The pickle module can help. It translates

almost any type of object into a string suitable for storage in a

database, and then translates strings back into objects.pickle.dumps takes an object as a parameter and returns

a string representation (dumps is short for &#X201C;dump string&#X201D;):<pre class="verbatim">>>> import pickle

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

>>> pickle.dumps(t)

b'\x80\x03]q\x00(K\x01K\x02K\x03e.'

</pre>The format isn&#X2019;t obvious to human readers; it is meant to be

easy for pickle to interpret. pickle.loads

(&#X201C;load string&#X201D;) reconstitutes the object:<pre class="verbatim">>>> t1 = [1, 2, 3]

>>> s = pickle.dumps(t1)

>>> t2 = pickle.loads(s)

>>> t2

[1, 2, 3]

</pre>Although the new object has the same value as the old, it is

not (in general) the same object:<pre class="verbatim">>>> t1 == t2

True

>>> t1 is t2

False

</pre>In other words, pickling and then unpickling has the same effect

as copying the object.You can use pickle to store non-strings in a database.

In fact, this combination is so common that it has been

encapsulated in a module called shelve.

<h2 class="section" id="sec172">14.8&#XA0;&#XA0;Pipes</h2>

<a id="hevea_default1268"></a>Most operating systems provide a command-line interface,

also known as a shell. Shells usually provide commands

to navigate the file system and launch applications. For

example, in Unix you can change directories with cd,

display the contents of a directory with ls, and launch

a web browser by typing (for example) firefox.

<a id="hevea_default1270"></a>Any program that you can launch from the shell can also be

launched from Python using a pipe object, which

represents a running program.For example, the Unix command ls -l normally displays the

contents of the current directory in long format. You can

launch ls with os.popen<a id="text1" href="thinkpython2015.html#note1">1</a>:

<a id="hevea_default1272"></a><pre class="verbatim">>>> cmd = 'ls -l'

>>> fp = os.popen(cmd)

</pre>The argument is a string that contains a shell command. The

return value is an object that behaves like an open

file. You can read the output from the ls process one

line at a time with readline or get the whole thing at

once with read:

<a id="hevea_default1276"></a><pre class="verbatim">>>> res = fp.read()

</pre>When you are done, you close the pipe like a file:

<a id="hevea_default1278"></a><pre class="verbatim">>>> stat = fp.close()

>>> print(stat)

None

</pre>The return value is the final status of the ls process;

None means that it ended normally (with no errors).For example, most Unix systems provide a command called md5sum

that reads the contents of a file and computes a &#X201C;checksum&#X201D;.

You can read about MD5 at <a href="http://en.wikipedia.org/wiki/Md5">http://en.wikipedia.org/wiki/Md5</a>. This

command provides an efficient way to check whether two files

have the same contents. The probability that different contents

yield the same checksum is very small (that is, unlikely to happen

before the universe collapses).

<a id="hevea_default1280"></a>You can use a pipe to run md5sum from Python and get the result:<pre class="verbatim">>>> filename = 'book.tex'

>>> cmd = 'md5sum ' + filename

>>> fp = os.popen(cmd)

>>> res = fp.read()

>>> stat = fp.close()

>>> print(res)

1e0033f0ed0656636de0d75144ba32e0 book.tex

>>> print(stat)

None

</pre>

<h2 class="section" id="sec173">14.9&#XA0;&#XA0;Writing modules</h2>

<a id="hevea_default1282"></a>Any file that contains Python code can be imported as a module.

For example, suppose you have a file named wc.py with the following

code:<pre class="verbatim">def linecount(filename):

count = 0

for line in open(filename):

count += 1

return count

print(linecount('wc.py'))

</pre>If you run this program, it reads itself and prints the number

of lines in the file, which is 7.

You can also import it like this:<pre class="verbatim">>>> import wc

</pre>Now you have a module object wc:

<a id="hevea_default1284"></a><pre class="verbatim">>>> wc

</pre>The module object provides <code>linecount</code>:<pre class="verbatim">>>> wc.linecount('wc.py')

</pre>So that&#X2019;s how you write modules in Python.The only problem with this example is that when you import

the module it runs the test code at the bottom. Normally

when you import a module, it defines new functions but it

doesn&#X2019;t run them.

<a id="hevea_default1286"></a>Programs that will be imported as modules often

use the following idiom:<pre class="verbatim">if __name__ == '__main__':

print(linecount('wc.py'))

</pre><code>__name__</code> is a built-in variable that is set when the

program starts. If the program is running as a script,

<code>__name__</code> has the value <code>'__main__'</code>; in that

case, the test code runs. Otherwise,

if the module is being imported, the test code is skipped.As an exercise, type this example into a file named wc.py and run

it as a script. Then run the Python interpreter and

import wc. What is the value of <code>__name__</code>

when the module is being imported?Warning: If you import a module that has already been imported,

Python does nothing. It does not re-read the file, even if it has

changed.

<a id="hevea_default1289"></a>If you want to reload a module, you can use the built-in function

reload, but it can be tricky, so the safest thing to do is

restart the interpreter and then import the module again.

<h2 class="section" id="sec174">14.10&#XA0;&#XA0;Debugging</h2>

<a id="hevea_default1291"></a>When you are reading and writing files, you might run into problems

with whitespace. These errors can be hard to debug because spaces,

tabs and newlines are normally invisible:<pre class="verbatim">>>> s = '1 2\t 3\n 4'

>>> print(s)

1 2 3

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

<a id="hevea_default1294"></a>The built-in function repr can help. It takes any object as an

argument and returns a string representation of the object. For

strings, it represents whitespace

characters with backslash sequences:<pre class="verbatim">>>> print(repr(s))

'1 2\t 3\n 4'

</pre>This can be helpful for debugging.One other problem you might run into is that different systems

use different characters to indicate the end of a line. Some

systems use a newline, represented <code>\n</code>. Others use

a return character, represented <code>\r</code>. Some use both.

If you move files between different systems, these inconsistencies

can cause problems.

<a id="hevea_default1295"></a>For most systems, there are applications to convert from one

format to another. You can find them (and read more about this

issue) at <a href="http://en.wikipedia.org/wiki/Newline">http://en.wikipedia.org/wiki/Newline</a>. Or, of course, you

could write one yourself.

<h2 class="section" id="sec175">14.11&#XA0;&#XA0;Glossary</h2>

<dl class="description"><dt class="dt-description">persistent:</dt><dd class="dd-description"> Pertaining to a program that runs indefinitely

and keeps at least some of its data in permanent storage.

<a id="hevea_default1296"></a></dd><dt class="dt-description">format operator:</dt><dd class="dd-description"> An operator, %, that takes a format

string and a tuple and generates a string that includes

the elements of the tuple formatted as specified by the format string.

<a id="hevea_default1298"></a></dd><dt class="dt-description">format string:</dt><dd class="dd-description"> A string, used with the format operator, that

contains format sequences.

<a id="hevea_default1299"></a></dd><dt class="dt-description">format sequence:</dt><dd class="dd-description"> A sequence of characters in a format string,

like %d, that specifies how a value should be formatted.

<a id="hevea_default1300"></a></dd><dt class="dt-description">text file:</dt><dd class="dd-description"> A sequence of characters stored in permanent

storage like a hard drive.

<a id="hevea_default1301"></a></dd><dt class="dt-description">directory:</dt><dd class="dd-description"> A named collection of files, also called a folder.

<a id="hevea_default1302"></a></dd><dt class="dt-description">path:</dt><dd class="dd-description"> A string that identifies a file.

<a id="hevea_default1303"></a></dd><dt class="dt-description">relative path:</dt><dd class="dd-description"> A path that starts from the current directory.

<a id="hevea_default1304"></a></dd><dt class="dt-description">absolute path:</dt><dd class="dd-description"> A path that starts from the topmost directory

in the file system.

<a id="hevea_default1305"></a></dd><dt class="dt-description">catch:</dt><dd class="dd-description"> To prevent an exception from terminating

a program using the try

and except statements.

<a id="hevea_default1306"></a></dd><dt class="dt-description">database:</dt><dd class="dd-description"> A file whose contents are organized like a dictionary

with keys that correspond to values.

<a id="hevea_default1307"></a></dd><dt class="dt-description">bytes object:</dt><dd class="dd-description"> An object similar to a string.

<a id="hevea_default1309"></a></dd><dt class="dt-description">shell:</dt><dd class="dd-description"> A program that allows users to type commands and then

executes them by starting other programs.

<a id="hevea_default1310"></a></dd><dt class="dt-description">pipe object:</dt><dd class="dd-description"> An object that represents a running program, allowing

a Python program to run commands and read the results.

<h2 class="section" id="sec176">14.12&#XA0;&#XA0;Exercises</h2>

<div class="theorem">Exercise&#XA0;1&#XA0;&#XA0;Write a function called sed that takes as arguments a pattern string,

a replacement string, and two filenames; it should read the first file

and write the contents into the second file (creating it if

necessary). If the pattern string appears anywhere in the file, it

should be replaced with the replacement string.If an error occurs while opening, reading, writing or closing files,

your program should catch the exception, print an error message, and

exit. Solution: <a href="http://thinkpython2.com/code/sed.py">http://thinkpython2.com/code/sed.py</a>.</div><div class="theorem">Exercise&#XA0;2&#XA0;&#XA0;

<a id="hevea_default1314"></a>If you download my solution to Exercise&#XA0;<a href="thinkpython2013.html#anagrams">2</a> from

<a href="http://thinkpython2.com/code/anagram_sets.py">http://thinkpython2.com/code/anagram_sets.py</a>, you&#X2019;ll see that it creates

a dictionary that maps from a sorted string of letters to the list of

words that can be spelled with those letters. For example,

<code>'opst'</code> maps to the list

<code>['opts', 'post', 'pots', 'spot', 'stop', 'tops']</code>.Write a module that imports <code>anagram_sets</code> and provides

two new functions: <code>store_anagrams</code> should store the

anagram dictionary in a &#X201C;shelf&#X201D;; <code>read_anagrams</code> should

look up a word and return a list of its anagrams.

Solution: <a href="http://thinkpython2.com/code/anagram_db.py">http://thinkpython2.com/code/anagram_db.py</a>.</div><div class="theorem">Exercise&#XA0;3&#XA0;&#XA0;

<a id="hevea_default1315"></a>In a large collection of MP3 files, there may be more than one

copy of the same song, stored in different directories or with

different file names. The goal of this exercise is to search for

duplicates.<ol class="enumerate" type=1><li class="li-enumerate">Write a program that searches a directory and all of its

subdirectories, recursively, and returns a list of complete paths

for all files with a given suffix (like .mp3).

Hint: os.path provides several useful functions for

manipulating file and path names.

<a id="hevea_default1319"></a></li><li class="li-enumerate">To recognize duplicates, you can use md5sum

to compute a &#X201C;checksum&#X201D; for each files. If two files have

the same checksum, they probably have the same contents.

<a id="hevea_default1320"></a></li><li class="li-enumerate">To double-check, you can use the Unix command diff.

<a id="hevea_default1321"></a></li></ol>Solution: <a href="http://thinkpython2.com/code/find_duplicates.py">http://thinkpython2.com/code/find_duplicates.py</a>.</div>

<a id="note1" href="thinkpython2015.html#text1">1</a></dt><dd class="dd-thefootnotes"><div class="footnotetext">popen is deprecated

now, which means we are supposed to stop using it and start using

the subprocess module. But for simple cases, I find

subprocess more complicated than necessary. So I am going

to keep using popen until they take it away.</div>

</dd></dl>

</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

thinkpython2015.html

Latest commit

History

thinkpython2015.html

File metadata and controls