pensepython.github.io/19-goodies.html at master · PensePython/pensepython.github.io

History

654 lines (630 loc) · 50.2 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

639

640

641

642

643

644

645

646

647

648

649

650

651

652

653

654

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"

"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<head>

<title>The Goodies — Pense Python 2e documentation</title>

var DOCUMENTATION_OPTIONS = {

URL_ROOT: './',

VERSION: '2e',

COLLAPSE_INDEX: false,

FILE_SUFFIX: '.html',

HAS_SOURCE: true

};

</script>

</head>

<h1>The Goodies<a class="headerlink" href="#the-goodies" title="Permalink to this headline">¶</a></h1>

One of my goals for this book has been to teach you as little Python as

possible. When there were two ways to do something, I picked one and

avoided mentioning the other. Or sometimes I put the second one into an

exercise.

Now I want to go back for some of the good bits that got left behind.

Python provides a number of features that are not really necessary—you

can write good code without them—but with them you can sometimes write

code that’s more concise, readable or efficient, and sometimes all

three.

<h2>Conditional expressions<a class="headerlink" href="#conditional-expressions" title="Permalink to this headline">¶</a></h2>

We saw conditional statements in Section [conditional.execution].

Conditional statements are often used to choose one of two values; for

example:

<div class="highlight-python"><div class="highlight"><pre>if x > 0:

y = math.log(x)

else:

y = float('nan')

</pre></div>

</div>

This statement checks whether x is positive. If so, it computes

math.log. If not, math.log would raise a ValueError. To avoid stopping

the program, we generate a “NaN”, which is a special floating-point

value that represents “Not a Number”.

We can write this statement more concisely using a conditional

expression:

<div class="highlight-python"><div class="highlight"><pre>y = math.log(x) if x > 0 else float('nan')

</pre></div>

</div>

You can almost read this line like English: “y gets log-x if x is

greater than 0; otherwise it gets NaN”.

Recursive functions can sometimes be rewritten using conditional

expressions. For example, here is a recursive version of factorial:

<div class="highlight-python"><div class="highlight"><pre>def factorial(n):

if n == 0:

return 1

else:

return n * factorial(n-1)

</pre></div>

</div>

We can rewrite it like this:

<div class="highlight-python"><div class="highlight"><pre>def factorial(n):

return 1 if n == 0 else n * factorial(n-1)

</pre></div>

</div>

Another use of conditional expressions is handling optional arguments.

For example, here is the init method from GoodKangaroo (see

Exercise [kangaroo]):

<div class="highlight-python"><div class="highlight"><pre>def __init__(self, name, contents=None):

self.name = name

if contents == None:

contents = []

self.pouch_contents = contents

</pre></div>

</div>

We can rewrite this one like this:

self.name = name

self.pouch_contents = [] if contents == None else contents

</pre></div>

</div>

In general, you can replace a conditional statement with a conditional

expression if both branches contain simple expressions that are either

returned or assigned to the same variable.

</div>

<h2>List comprehensions<a class="headerlink" href="#list-comprehensions" title="Permalink to this headline">¶</a></h2>

In Section [filter] we saw the map and filter patterns. For example,

this function takes a list of strings, maps the string method capitalize

to the elements, and returns a new list of strings:

<div class="highlight-python"><div class="highlight"><pre>def capitalize_all(t):

res = []

for s in t:

res.append(s.capitalize())

return res

</pre></div>

</div>

We can write this more concisely using a list comprehension:

<div class="highlight-python"><div class="highlight"><pre>def capitalize_all(t):

return [s.capitalize() for s in t]

</pre></div>

</div>

The bracket operators indicate that we are constructing a new list. The

expression inside the brackets specifies the elements of the list, and

the for clause indicates what sequence we are traversing.

The syntax of a list comprehension is a little awkward because the loop

variable, s in this example, appears in the expression before we get to

the definition.

List comprehensions can also be used for filtering. For example, this

function selects only the elements of t that are upper case, and returns

a new list:

<div class="highlight-python"><div class="highlight"><pre>def only_upper(t):

res = []

for s in t:

if s.isupper():

res.append(s)

return res

</pre></div>

</div>

We can rewrite it using a list comprehension

<div class="highlight-python"><div class="highlight"><pre>def only_upper(t):

return [s for s in t if s.isupper()]

</pre></div>

</div>

List comprehensions are concise and easy to read, at least for simple

expressions. And they are usually faster than the equivalent for loops,

sometimes much faster. So if you are mad at me for not mentioning them

earlier, I understand.

But, in my defense, list comprehensions are harder to debug because you

can’t put a print statement inside the loop. I suggest that you use them

only if the computation is simple enough that you are likely to get it

right the first time. And for beginners that means never.

</div>

<h2>Generator expressions<a class="headerlink" href="#generator-expressions" title="Permalink to this headline">¶</a></h2>

Generator expressions are similar to list comprehensions, but with

parentheses instead of square brackets:

<div class="highlight-python"><div class="highlight"><pre>>>> g = (x**2 for x in range(5))

>>> g

</pre></div>

</div>

The result is a generator object that knows how to iterate through a

sequence of values. But unlike a list comprehension, it does not compute

the values all at once; it waits to be asked. The built-in function next

gets the next value from the generator:

<div class="highlight-python"><div class="highlight"><pre>>>> next(g)

0

>>> next(g)

1

</pre></div>

</div>

When you get to the end of the sequence, next raises a StopIteration

exception. You can also use a for loop to iterate through the values:

<div class="highlight-python"><div class="highlight"><pre>>>> for val in g:

... print(val)

4

9

16

</pre></div>

</div>

The generator object keeps track of where it is in the sequence, so the

for loop picks up where next left off. Once the generator is exhausted,

it continues to raise StopException:

<div class="highlight-python"><div class="highlight"><pre>>>> next(g)

StopIteration

</pre></div>

</div>

Generator expressions are often used with functions like sum, max, and

min:

<div class="highlight-python"><div class="highlight"><pre>>>> sum(x**2 for x in range(5))

30

</pre></div>

</div>

Python provides a built-in function, any, that takes a sequence of

boolean values and returns True if any of the values are True. It works

on lists:

<div class="highlight-python"><div class="highlight"><pre>>>> any([False, False, True])

True

</pre></div>

</div>

But it is often used with generator expressions:

<div class="highlight-python"><div class="highlight"><pre>>>> any(letter == 't' for letter in 'monty')

True

</pre></div>

</div>

That example isn’t very useful because it does the same thing as the in

operator. But we could use any to rewrite some of the search functions

we wrote in Section [search]. For example, we could write avoids like

this:

<div class="highlight-python"><div class="highlight"><pre>def avoids(word, forbidden):

return not any(letter in forbidden for letter in word)

</pre></div>

</div>

The function almost reads like English, “word avoids forbidden if there

are not any forbidden letters in word.”

Using any with a generator expression is efficient because it stops

immediately if it finds a True value, so it doesn’t have to evaluate the

whole sequence.

Python provides another built-in function, all, that returns True if

every element of the sequence is True. As an exercise, use all to

re-write <code class="docutils literal">uses_all</code> from Section [search].

</div>

In Section [dictsub] I use dictionaries to find the words that appear in

a document but not in a word list. The function I wrote takes d1, which

contains the words from the document as keys, and d2, which contains the

list of words. It returns a dictionary that contains the keys from d1

that are not in d2.

<div class="highlight-python"><div class="highlight"><pre>def subtract(d1, d2):

res = dict()

for key in d1:

if key not in d2:

res[key] = None

return res

</pre></div>

</div>

In all of these dictionaries, the values are None because we never use

them. As a result, we waste some storage space.

Python provides another built-in type, called a set, that behaves like a

collection of dictionary keys with no values. Adding elements to a set

is fast; so is checking membership. And sets provide methods and

operators to compute common set operations.

For example, set subtraction is available as a method called difference

or as an operator, -. So we can rewrite subtract like this:

return set(d1) - set(d2)

</pre></div>

</div>

The result is a set instead of a dictionary, but for operations like

iteration, the behavior is the same.

Some of the exercises in this book can be done concisely and efficiently

with sets. For example, here is a solution to <code class="docutils literal">has_duplicates</code>, from

Exercise [duplicate], that uses a dictionary:

<div class="highlight-python"><div class="highlight"><pre>def has_duplicates(t):

d = {}

for x in t:

if x in d:

return True

d[x] = True

return False

</pre></div>

</div>

When an element appears for the first time, it is added to the

dictionary. If the same element appears again, the function returns

True.

Using sets, we can write the same function like this:

<div class="highlight-python"><div class="highlight"><pre>def has_duplicates(t):

return len(set(t)) < len(t)

</pre></div>

</div>

An element can only appear in a set once, so if an element in t appears

more than once, the set will be smaller than t. If there are no

duplicates, the set will be the same size as t.

We can also use sets to do some of the exercises in Chapter [wordplay].

For example, here’s a version of <code class="docutils literal">uses_only</code> with a loop:

<div class="highlight-python"><div class="highlight"><pre>def uses_only(word, available):

for letter in word:

if letter not in available:

return False

return True

</pre></div>

</div>

<code class="docutils literal">uses_only</code> checks whether all letters in word are in available. We

can rewrite it like this:

return set(word) <= set(available)

</pre></div>

</div>

The <code class="docutils literal"><=</code> operator checks whether one set is a subset or another,

including the possibility that they are equal, which is true if all the

letters in word appear in available.

As an exercise, rewrite <code class="docutils literal">avoids</code> using sets.

</div>

<h2>Counters<a class="headerlink" href="#counters" title="Permalink to this headline">¶</a></h2>

A Counter is like a set, except that if an element appears more than

once, the Counter keeps track of how many times it appears. If you are

familiar with the mathematical idea of a multiset, a Counter is a

natural way to represent a multiset.

Counter is defined in a standard module called collections, so you have

to import it. You can initialize a Counter with a string, list, or

anything else that supports iteration:

<div class="highlight-python"><div class="highlight"><pre>>>> from collections import Counter

>>> count = Counter('parrot')

>>> count

Counter({'r': 2, 't': 1, 'o': 1, 'p': 1, 'a': 1})

</pre></div>

</div>

Counters behave like dictionaries in many ways; they map from each key

to the number of times it appears. As in dictionaries, the keys have to

be hashable.

Unlike dictionaries, Counters don’t raise an exception if you access an

element that doesn’t appear. Instead, they return 0:

<div class="highlight-python"><div class="highlight"><pre>>>> count['d']

0

</pre></div>

</div>

We can use Counters to rewrite <code class="docutils literal">is_anagram</code> from Exercise [anagram]:

<div class="highlight-python"><div class="highlight"><pre>def is_anagram(word1, word2):

return Counter(word1) == Counter(word2)

</pre></div>

</div>

If two words are anagrams, they contain the same letters with the same

counts, so their Counters are equivalent.

Counters provide methods and operators to perform set-like operations,

including addition, subtraction, union and intersection. And they

provide an often-useful method, <code class="docutils literal">most_common</code>, which returns a list of

value-frequency pairs, sorted from most common to least:

<div class="highlight-python"><div class="highlight"><pre>>>> count = Counter('parrot')

>>> for val, freq in count.most_common(3):

... print(val, freq)

r 2

p 1

a 1

</pre></div>

</div>

<h2>defaultdict<a class="headerlink" href="#defaultdict" title="Permalink to this headline">¶</a></h2>

The collections module also provides defaultdict, which is like a

dictionary except that if you access a key that doesn’t exist, it can

generate a new value on the fly.

When you create a defaultdict, you provide a function that’s used to

create new values. A function used to create objects is sometimes called

a factory. The built-in functions that create lists, sets, and other

types can be used as factories:

>>> d = defaultdict(list)

</pre></div>

</div>

Notice that the argument is list, which is a class object, not list(),

which is a new list. The function you provide doesn’t get called unless

you access a key that doesn’t exist.

<div class="highlight-python"><div class="highlight"><pre>>>> t = d['new key']

>>> t

[]

</pre></div>

</div>

The new list, which we’re calling t, is also added to the dictionary. So

if we modify t, the change appears in d:

<div class="highlight-python"><div class="highlight"><pre>>>> t.append('new value')

>>> d

defaultdict(<class 'list'>, {'new key': ['new value']})

</pre></div>

</div>

If you are making a dictionary of lists, you can often write simpler

code using defaultdict. In my solution to Exercise [anagrams], which you

can get from <a class="reference external" href="http://thinkpython2.com/code/anagram_sets.py">http://thinkpython2.com/code/anagram_sets.py</a>, I make a

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

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

to the list .

Here’s the original code:

<div class="highlight-python"><div class="highlight"><pre>def all_anagrams(filename):

d = {}

for line in open(filename):

word = line.strip().lower()

t = signature(word)

if t not in d:

d[t] = [word]

else:

d[t].append(word)

return d

</pre></div>

</div>

This can be simplified using setdefault, which you might have used in

Exercise [setdefault]:

d = {}

for line in open(filename):

t = signature(word)

d.setdefault(t, []).append(word)

return d

</pre></div>

</div>

This solution has the drawback that it makes a new list every time,

regardless of whether it is needed. For lists, that’s no big deal, but

if the factory function is complicated, it might be.

We can avoid this problem and simplify the code using a defaultdict:

d = defaultdict(list)

for line in open(filename):

t = signature(word)

return d

</pre></div>

</div>

My solution to Exercise [poker], which you can download from

<a class="reference external" href="http://thinkpython2.com/code/PokerHandSoln.py">http://thinkpython2.com/code/PokerHandSoln.py</a>, uses setdefault in the

function <code class="docutils literal">has_straightflush</code>. This solution has the drawback of

creating a Hand object every time through the loop, whether it is needed

or not. As an exercise, rewrite it using a defaultdict.

</div>

<h2>Named tuples<a class="headerlink" href="#named-tuples" title="Permalink to this headline">¶</a></h2>

Many simple objects are basically collections of related values. For

example, the Point object defined in Chapter [clobjects] contains two

numbers, x and y. When you define a class like this, you usually start

with an init method and a str method:

<div class="highlight-python"><div class="highlight"><pre>class Point:

def __init__(self, x=0, y=0):

self.x = x

self.y = y

def __str__(self):

return '(%g, %g)' % (self.x, self.y)

</pre></div>

</div>

This is a lot of code to convey a small amount of information. Python

provides a more concise way to say the same thing:

<div class="highlight-python"><div class="highlight"><pre>from collections import namedtuple

Point = namedtuple('Point', ['x', 'y'])

</pre></div>

</div>

The first argument is the name of the class you want to create. The

second is a list of the attributes Point objects should have, as

strings. The return value from namedtuple is a class object:

<div class="highlight-python"><div class="highlight"><pre>>>> Point

</pre></div>

</div>

Point automatically provides methods like <code class="docutils literal">__init__</code> and <code class="docutils literal">__str__</code>

so you don’t have to write them.

To create a Point object, you use the Point class as a function:

<div class="highlight-python"><div class="highlight"><pre>>>> p = Point(1, 2)

>>> p

Point(x=1, y=2)

</pre></div>

</div>

The init method assigns the arguments to attributes using the names you

provided. The str method prints a representation of the Point object and

its attributes.

You can access the elements of the named tuple by name:

<div class="highlight-python"><div class="highlight"><pre>>>> p.x, p.y

(1, 2)

</pre></div>

</div>

But you can also treat a named tuple as a tuple:

<div class="highlight-python"><div class="highlight"><pre>>>> p[0], p[1]

(1, 2)

>>> x, y = p

>>> x, y

(1, 2)

</pre></div>

</div>

Named tuples provide a quick way to define simple classes. The drawback

is that simple classes don’t always stay simple. You might decide later

that you want to add methods to a named tuple. In that case, you could

define a new class that inherits from the named tuple:

<div class="highlight-python"><div class="highlight"><pre>class Pointier(Point):

# add more methods here

</pre></div>

</div>

Or you could switch to a conventional class definition.

</div>

<h2>Gathering keyword args<a class="headerlink" href="#gathering-keyword-args" title="Permalink to this headline">¶</a></h2>

In Section [gather], we saw how to write a function that gathers its

arguments into a tuple:

<div class="highlight-python"><div class="highlight"><pre>def printall(*args):

print(args)

</pre></div>

</div>

You can call this function with any number of positional arguments (that

is, arguments that don’t have keywords):

<div class="highlight-python"><div class="highlight"><pre>>>> printall(1, 2.0, '3')

(1, 2.0, '3')

</pre></div>

</div>

But the operator doesn’t gather keyword arguments:

TypeError: printall() got an unexpected keyword argument 'third'

</pre></div>

</div>

To gather keyword arguments, you can use the * operator:

print(args, kwargs)

</pre></div>

</div>

You can call the keyword gathering parameter anything you want, but

kwargs is a common choice. The result is a dictionary that maps keywords

to values:

(1, 2.0) {'third': '3'}

</pre></div>

</div>

If you have a dictionary of keywords and values, you can use the scatter

operator, * to call a function:

<div class="highlight-python"><div class="highlight"><pre>>>> d = dict(x=1, y=2)

>>> Point(**d)

Point(x=1, y=2)

</pre></div>

</div>

Without the scatter operator, the function would treat d as a single

positional argument, so it would assign d to x and complain because

there’s nothing to assign to y:

>>> Point(d)

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

TypeError: __new__() missing 1 required positional argument: 'y'

</pre></div>

</div>

When you are working with functions that have a large number of

parameters, it is often useful to create and pass around dictionaries

that specify frequently used options.

</div>

<h2>Glossary<a class="headerlink" href="#glossary" title="Permalink to this headline">¶</a></h2>

<dt>expressão condicional (conditional expression)</dt>

<dd>An expression that has one of two values, depending on a condition.</dd>

<dt>listcomp (list comprehension)</dt>

<dd>An expression with a for loop in square brackets that yields a new list.</dd>

<dt>expressão geradora (generator expression)</dt>

<dd>An expression with a for loop in parentheses that yields a generator object.</dd>

<dt>multiset (“multi-conjunto”)</dt>

<dd>A mathematical entity that represents a mapping between the elements of a set and the number of times they appear.</dd>

<dt>factory (fábrica)</dt>

<dd>A function, usually passed as a parameter, used to create objects.</dd>

</dl>

</div>

<h2>Exercises<a class="headerlink" href="#exercises" title="Permalink to this headline">¶</a></h2>

The following is a function computes the binomial coefficient

recursively.

<div class="highlight-python"><div class="highlight"><pre>def binomial_coeff(n, k):

"""Compute the binomial coefficient "n choose k".

n: number of trials

k: number of successes

returns: int

"""

if k == 0:

return 1

if n == 0:

return 0

res = binomial_coeff(n-1, k) + binomial_coeff(n-1, k-1)

return res

</pre></div>

</div>

Rewrite the body of the function using nested conditional expressions.

One note: this function is not very efficient because it ends up

computing the same values over and over. You could make it more

efficient by memoizing (see Section [memoize]). But you will find that

it’s harder to memoize if you write it using conditional expressions.

</div>

<h3><a href="index.html">Table Of Contents</a></h3>

<ul>

<li><a class="reference internal" href="#">The Goodies</a><ul>

<li><a class="reference internal" href="#conditional-expressions">Conditional expressions</a></li>

<li><a class="reference internal" href="#list-comprehensions">List comprehensions</a></li>

<li><a class="reference internal" href="#generator-expressions">Generator expressions</a></li>

<li><a class="reference internal" href="#counters">Counters</a></li>

<li><a class="reference internal" href="#defaultdict">defaultdict</a></li>

<li><a class="reference internal" href="#named-tuples">Named tuples</a></li>

<li><a class="reference internal" href="#gathering-keyword-args">Gathering keyword args</a></li>

<li><a class="reference internal" href="#glossary">Glossary</a></li>

<li><a class="reference internal" href="#exercises">Exercises</a></li>

</ul>

</li>

</ul>

<h3>Related Topics</h3>

<ul>

<li><a href="index.html">Documentation overview</a><ul>

<li>Previous: <a href="18-inherit.html" title="previous chapter">Inheritance</a></li>

<li>Next: <a href="A-debug.html" title="next chapter">Debugging</a></li>

</ul></li>

</ul>

</div>

<li><a href="_sources/19-goodies.txt"

rel="nofollow">Show Source</a></li>

</ul>

</div>

<h3>Quick search</h3>

</form>

Enter search terms or a module, class or function name.

</div>

</div>

</div>

& <a href="https://github.com/bitprophet/alabaster">Alabaster 0.7.6</a>

<a href="_sources/19-goodies.txt"

rel="nofollow">Page source</a>

</div>

</body>

</html>

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

FilesExpand file tree

19-goodies.html

Latest commit

History

19-goodies.html

File metadata and controls