~dkuhlman/python-training-materials/Materials

Besides the <a class="reference internal" href="../reference/compound_stmts.html#while"><code class="xref std std-keyword docutils literal">while</code></a> statement just introduced, Python knows the usual

control flow statements known from other languages, with some twists.

<h2>4.1. <a class="reference internal" href="../reference/compound_stmts.html#if"><code class="xref std std-keyword docutils literal">if</code></a> Statements<a class="headerlink" href="#if-statements" title="Permalink to this headline">¶</a></h2>

Perhaps the most well-known statement type is the <a class="reference internal" href="../reference/compound_stmts.html#if"><code class="xref std std-keyword docutils literal">if</code></a> statement. For

example:

<div class="highlight-python3"><div class="highlight"><pre>>>> x = int(input("Please enter an integer: "))

Please enter an integer: 42

>>> if x < 0:

... x = 0

... print('Negative changed to zero')

... elif x == 0:

... print('Zero')

... elif x == 1:

... print('Single')

... else:

... print('More')

...

More

</pre></div>

</div>

There can be zero or more <a class="reference internal" href="../reference/compound_stmts.html#elif"><code class="xref std std-keyword docutils literal">elif</code></a> parts, and the <a class="reference internal" href="../reference/compound_stmts.html#else"><code class="xref std std-keyword docutils literal">else</code></a> part is

100

optional. The keyword ‘<a class="reference internal" href="../reference/compound_stmts.html#elif"><code class="xref std std-keyword docutils literal">elif</code></a>‘ is short for ‘else if’, and is useful

101

to avoid excessive indentation. An <a class="reference internal" href="../reference/compound_stmts.html#if"><code class="xref std std-keyword docutils literal">if</code></a> ... <a class="reference internal" href="../reference/compound_stmts.html#elif"><code class="xref std std-keyword docutils literal">elif</code></a> ...

102

<a class="reference internal" href="../reference/compound_stmts.html#elif"><code class="xref std std-keyword docutils literal">elif</code></a> ... sequence is a substitute for the <code class="docutils literal">switch</code> or

103

<code class="docutils literal">case</code> statements found in other languages.

104

</div>

105

106

<h2>4.2. <a class="reference internal" href="../reference/compound_stmts.html#for"><code class="xref std std-keyword docutils literal">for</code></a> Statements<a class="headerlink" href="#for-statements" title="Permalink to this headline">¶</a></h2>

107

The <a class="reference internal" href="../reference/compound_stmts.html#for"><code class="xref std std-keyword docutils literal">for</code></a> statement in Python differs a bit from what you may be used

108

to in C or Pascal. Rather than always iterating over an arithmetic progression

109

of numbers (like in Pascal), or giving the user the ability to define both the

110

iteration step and halting condition (as C), Python’s <a class="reference internal" href="../reference/compound_stmts.html#for"><code class="xref std std-keyword docutils literal">for</code></a> statement

111

iterates over the items of any sequence (a list or a string), in the order that

112

they appear in the sequence. For example (no pun intended):

113

<div class="highlight-python3"><div class="highlight"><pre>>>> # Measure some strings:

114

... words = ['cat', 'window', 'defenestrate']

115

>>> for w in words:

116

... print(w, len(w))

117

...

118

cat 3

119

window 6

120

defenestrate 12

121

</pre></div>

122

</div>

123

If you need to modify the sequence you are iterating over while inside the loop

124

(for example to duplicate selected items), it is recommended that you first

125

make a copy. Iterating over a sequence does not implicitly make a copy. The

126

slice notation makes this especially convenient:

127

<div class="highlight-python3"><div class="highlight"><pre>>>> for w in words[:]: # Loop over a slice copy of the entire list.

128

... if len(w) > 6:

129

... words.insert(0, w)

130

...

131

>>> words

132

['defenestrate', 'cat', 'window', 'defenestrate']

133

</pre></div>

134

</div>

135

</div>

136

137

<h2>4.3. The <a class="reference internal" href="../library/stdtypes.html#range" title="range"><code class="xref py py-func docutils literal">range()</code></a> Function<a class="headerlink" href="#the-range-function" title="Permalink to this headline">¶</a></h2>

138

If you do need to iterate over a sequence of numbers, the built-in function

139

<a class="reference internal" href="../library/stdtypes.html#range" title="range"><code class="xref py py-func docutils literal">range()</code></a> comes in handy. It generates arithmetic progressions:

140

<div class="highlight-python3"><div class="highlight"><pre>>>> for i in range(5):

141

... print(i)

142

...

143

0

144

1

145

2

146

3

147

4

148

</pre></div>

149

</div>

150

The given end point is never part of the generated sequence; <code class="docutils literal">range(10)</code> generates

151

10 values, the legal indices for items of a sequence of length 10. It

152

is possible to let the range start at another number, or to specify a different

153

increment (even negative; sometimes this is called the ‘step’):

154

<div class="highlight-python3"><div class="highlight"><pre>range(5, 10)

155

5 through 9

156

157

range(0, 10, 3)

158

0, 3, 6, 9

159

160

range(-10, -100, -30)

161

-10, -40, -70

162

</pre></div>

163

</div>

164

To iterate over the indices of a sequence, you can combine <a class="reference internal" href="../library/stdtypes.html#range" title="range"><code class="xref py py-func docutils literal">range()</code></a> and

165

<a class="reference internal" href="../library/functions.html#len" title="len"><code class="xref py py-func docutils literal">len()</code></a> as follows:

166

<div class="highlight-python3"><div class="highlight"><pre>>>> a = ['Mary', 'had', 'a', 'little', 'lamb']

167

>>> for i in range(len(a)):

168

... print(i, a[i])

169

...

170

0 Mary

171

1 had

172

2 a

173

3 little

174

4 lamb

175

</pre></div>

176

</div>

177

In most such cases, however, it is convenient to use the <a class="reference internal" href="../library/functions.html#enumerate" title="enumerate"><code class="xref py py-func docutils literal">enumerate()</code></a>

178

function, see <a class="reference internal" href="datastructures.html#tut-loopidioms">Looping Techniques</a>.

179

A strange thing happens if you just print a range:

180

<div class="highlight-python3"><div class="highlight"><pre>>>> print(range(10))

181

range(0, 10)

182

</pre></div>

183

</div>

184

In many ways the object returned by <a class="reference internal" href="../library/stdtypes.html#range" title="range"><code class="xref py py-func docutils literal">range()</code></a> behaves as if it is a list,

185

but in fact it isn’t. It is an object which returns the successive items of

186

the desired sequence when you iterate over it, but it doesn’t really make

187

the list, thus saving space.

188

We say such an object is iterable, that is, suitable as a target for

189

functions and constructs that expect something from which they can

190

obtain successive items until the supply is exhausted. We have seen that

191

the <a class="reference internal" href="../reference/compound_stmts.html#for"><code class="xref std std-keyword docutils literal">for</code></a> statement is such an iterator. The function <a class="reference internal" href="../library/stdtypes.html#list" title="list"><code class="xref py py-func docutils literal">list()</code></a>

192

is another; it creates lists from iterables:

193

194

[0, 1, 2, 3, 4]

195

</pre></div>

196

</div>

197

Later we will see more functions that return iterables and take iterables as argument.

198

</div>

199

200

<h2>4.4. <a class="reference internal" href="../reference/simple_stmts.html#break"><code class="xref std std-keyword docutils literal">break</code></a> and <a class="reference internal" href="../reference/simple_stmts.html#continue"><code class="xref std std-keyword docutils literal">continue</code></a> Statements, and <a class="reference internal" href="../reference/compound_stmts.html#else"><code class="xref std std-keyword docutils literal">else</code></a> Clauses on Loops<a class="headerlink" href="#break-and-continue-statements-and-else-clauses-on-loops" title="Permalink to this headline">¶</a></h2>

201

The <a class="reference internal" href="../reference/simple_stmts.html#break"><code class="xref std std-keyword docutils literal">break</code></a> statement, like in C, breaks out of the smallest enclosing

202

<a class="reference internal" href="../reference/compound_stmts.html#for"><code class="xref std std-keyword docutils literal">for</code></a> or <a class="reference internal" href="../reference/compound_stmts.html#while"><code class="xref std std-keyword docutils literal">while</code></a> loop.

203

Loop statements may have an <code class="docutils literal">else</code> clause; it is executed when the loop

204

terminates through exhaustion of the list (with <a class="reference internal" href="../reference/compound_stmts.html#for"><code class="xref std std-keyword docutils literal">for</code></a>) or when the

205

condition becomes false (with <a class="reference internal" href="../reference/compound_stmts.html#while"><code class="xref std std-keyword docutils literal">while</code></a>), but not when the loop is

206

terminated by a <a class="reference internal" href="../reference/simple_stmts.html#break"><code class="xref std std-keyword docutils literal">break</code></a> statement. This is exemplified by the

207

following loop, which searches for prime numbers:

208

<div class="highlight-python3"><div class="highlight"><pre>>>> for n in range(2, 10):

209

... for x in range(2, n):

210

... if n % x == 0:

211

... print(n, 'equals', x, '*', n//x)

212

... break

213

... else:

214

... # loop fell through without finding a factor

215

... print(n, 'is a prime number')

216

...

217

2 is a prime number

218

3 is a prime number

219

4 equals 2 * 2

220

5 is a prime number

221

6 equals 2 * 3

222

7 is a prime number

223

8 equals 2 * 4

224

9 equals 3 * 3

225

</pre></div>

226

</div>

227

(Yes, this is the correct code. Look closely: the <code class="docutils literal">else</code> clause belongs to

228

the <a class="reference internal" href="../reference/compound_stmts.html#for"><code class="xref std std-keyword docutils literal">for</code></a> loop, not the <a class="reference internal" href="../reference/compound_stmts.html#if"><code class="xref std std-keyword docutils literal">if</code></a> statement.)

229

When used with a loop, the <code class="docutils literal">else</code> clause has more in common with the

230

<code class="docutils literal">else</code> clause of a <a class="reference internal" href="../reference/compound_stmts.html#try"><code class="xref std std-keyword docutils literal">try</code></a> statement than it does that of

231

<a class="reference internal" href="../reference/compound_stmts.html#if"><code class="xref std std-keyword docutils literal">if</code></a> statements: a <a class="reference internal" href="../reference/compound_stmts.html#try"><code class="xref std std-keyword docutils literal">try</code></a> statement’s <code class="docutils literal">else</code> clause runs

232

when no exception occurs, and a loop’s <code class="docutils literal">else</code> clause runs when no <code class="docutils literal">break</code>

233

occurs. For more on the <a class="reference internal" href="../reference/compound_stmts.html#try"><code class="xref std std-keyword docutils literal">try</code></a> statement and exceptions, see

234

<a class="reference internal" href="errors.html#tut-handling">Handling Exceptions</a>.

235

The <a class="reference internal" href="../reference/simple_stmts.html#continue"><code class="xref std std-keyword docutils literal">continue</code></a> statement, also borrowed from C, continues with the next

236

iteration of the loop:

237

<div class="highlight-python3"><div class="highlight"><pre>>>> for num in range(2, 10):

238

... if num % 2 == 0:

239

... print("Found an even number", num)

240

... continue

241

... print("Found a number", num)

242

Found an even number 2

243

Found a number 3

244

Found an even number 4

245

Found a number 5

246

Found an even number 6

247

Found a number 7

248

Found an even number 8

249

Found a number 9

250

</pre></div>

251

</div>

252

</div>

253

254

<h2>4.5. <a class="reference internal" href="../reference/simple_stmts.html#pass"><code class="xref std std-keyword docutils literal">pass</code></a> Statements<a class="headerlink" href="#pass-statements" title="Permalink to this headline">¶</a></h2>

255

The <a class="reference internal" href="../reference/simple_stmts.html#pass"><code class="xref std std-keyword docutils literal">pass</code></a> statement does nothing. It can be used when a statement is

256

required syntactically but the program requires no action. For example:

257

<div class="highlight-python3"><div class="highlight"><pre>>>> while True:

258

... pass # Busy-wait for keyboard interrupt (Ctrl+C)

259

...

260

</pre></div>

261

</div>

262

This is commonly used for creating minimal classes:

263

<div class="highlight-python3"><div class="highlight"><pre>>>> class MyEmptyClass:

264

... pass

265

...

266

</pre></div>

267

</div>

268

Another place <a class="reference internal" href="../reference/simple_stmts.html#pass"><code class="xref std std-keyword docutils literal">pass</code></a> can be used is as a place-holder for a function or

269

conditional body when you are working on new code, allowing you to keep thinking

270

at a more abstract level. The <a class="reference internal" href="../reference/simple_stmts.html#pass"><code class="xref std std-keyword docutils literal">pass</code></a> is silently ignored:

271

<div class="highlight-python3"><div class="highlight"><pre>>>> def initlog(*args):

272

... pass # Remember to implement this!

273

...

274

</pre></div>

275

</div>

276

</div>

277

278

<h2>4.6. Defining Functions<a class="headerlink" href="#defining-functions" title="Permalink to this headline">¶</a></h2>

279

We can create a function that writes the Fibonacci series to an arbitrary

280

boundary:

281

<div class="highlight-python3"><div class="highlight"><pre>>>> def fib(n): # write Fibonacci series up to n

282

... """Print a Fibonacci series up to n."""

283

... a, b = 0, 1

284

... while a < n:

285

... print(a, end=' ')

286

... a, b = b, a+b

287

... print()

288

...

289

>>> # Now call the function we just defined:

290

... fib(2000)

291

0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597

292

</pre></div>

293

</div>

294

The keyword <a class="reference internal" href="../reference/compound_stmts.html#def"><code class="xref std std-keyword docutils literal">def</code></a> introduces a function definition. It must be

295

followed by the function name and the parenthesized list of formal parameters.

296

The statements that form the body of the function start at the next line, and

297

must be indented.

298

The first statement of the function body can optionally be a string literal;

299

this string literal is the function’s documentation string, or docstring.

300

(More about docstrings can be found in the section <a class="reference internal" href="#tut-docstrings">Documentation Strings</a>.)

301

There are tools which use docstrings to automatically produce online or printed

302

documentation, or to let the user interactively browse through code; it’s good

303

practice to include docstrings in code that you write, so make a habit of it.

304

The execution of a function introduces a new symbol table used for the local

305

variables of the function. More precisely, all variable assignments in a

306

function store the value in the local symbol table; whereas variable references

307

first look in the local symbol table, then in the local symbol tables of

308

enclosing functions, then in the global symbol table, and finally in the table

309

of built-in names. Thus, global variables cannot be directly assigned a value

310

within a function (unless named in a <a class="reference internal" href="../reference/simple_stmts.html#global"><code class="xref std std-keyword docutils literal">global</code></a> statement), although they

311

may be referenced.

312

The actual parameters (arguments) to a function call are introduced in the local

313

symbol table of the called function when it is called; thus, arguments are

314

passed using call by value (where the value is always an object reference,

315

not the value of the object). <a class="footnote-reference" href="#id2" id="id1">[1]</a> When a function calls another function, a new

316

local symbol table is created for that call.

317

A function definition introduces the function name in the current symbol table.

318

The value of the function name has a type that is recognized by the interpreter

319

as a user-defined function. This value can be assigned to another name which

320

can then also be used as a function. This serves as a general renaming

321

mechanism:

322

<div class="highlight-python3"><div class="highlight"><pre>>>> fib

323

324

>>> f = fib

325

>>> f(100)

326

0 1 1 2 3 5 8 13 21 34 55 89

327

</pre></div>

328

</div>

329

Coming from other languages, you might object that <code class="docutils literal">fib</code> is not a function but

330

a procedure since it doesn’t return a value. In fact, even functions without a

331

<a class="reference internal" href="../reference/simple_stmts.html#return"><code class="xref std std-keyword docutils literal">return</code></a> statement do return a value, albeit a rather boring one. This

332

value is called <code class="docutils literal">None</code> (it’s a built-in name). Writing the value <code class="docutils literal">None</code> is

333

normally suppressed by the interpreter if it would be the only value written.

334

You can see it if you really want to using <a class="reference internal" href="../library/functions.html#print" title="print"><code class="xref py py-func docutils literal">print()</code></a>:

335

<div class="highlight-python3"><div class="highlight"><pre>>>> fib(0)

336

>>> print(fib(0))

337

None

338

</pre></div>

339

</div>

340

It is simple to write a function that returns a list of the numbers of the

341

Fibonacci series, instead of printing it:

342

<div class="highlight-python3"><div class="highlight"><pre>>>> def fib2(n): # return Fibonacci series up to n

343

... """Return a list containing the Fibonacci series up to n."""

344

... result = []

345

346

... while a < n:

347

... result.append(a) # see below

348

349

... return result

350

...

351

>>> f100 = fib2(100) # call it

352

>>> f100 # write the result

353

[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

354

</pre></div>

355

</div>

356

This example, as usual, demonstrates some new Python features:

357

358

<li>The <a class="reference internal" href="../reference/simple_stmts.html#return"><code class="xref std std-keyword docutils literal">return</code></a> statement returns with a value from a function.

359

<a class="reference internal" href="../reference/simple_stmts.html#return"><code class="xref std std-keyword docutils literal">return</code></a> without an expression argument returns <code class="docutils literal">None</code>. Falling off

360

the end of a function also returns <code class="docutils literal">None</code>.</li>

361

<li>The statement <code class="docutils literal">result.append(a)</code> calls a method of the list object

362

<code class="docutils literal">result</code>. A method is a function that ‘belongs’ to an object and is named

363

<code class="docutils literal">obj.methodname</code>, where <code class="docutils literal">obj</code> is some object (this may be an expression),

364

and <code class="docutils literal">methodname</code> is the name of a method that is defined by the object’s type.

365

Different types define different methods. Methods of different types may have

366

the same name without causing ambiguity. (It is possible to define your own

367

object types and methods, using classes, see <a class="reference internal" href="classes.html#tut-classes">Classes</a>)

368

The method <code class="xref py py-meth docutils literal">append()</code> shown in the example is defined for list objects; it

369

adds a new element at the end of the list. In this example it is equivalent to

370

<code class="docutils literal">result = result + [a]</code>, but more efficient.</li>

371

</ul>

372

</div>

373

374

<h2>4.7. More on Defining Functions<a class="headerlink" href="#more-on-defining-functions" title="Permalink to this headline">¶</a></h2>

375

It is also possible to define functions with a variable number of arguments.

376

There are three forms, which can be combined.

377

378

<h3>4.7.1. Default Argument Values<a class="headerlink" href="#default-argument-values" title="Permalink to this headline">¶</a></h3>

379

The most useful form is to specify a default value for one or more arguments.

380

This creates a function that can be called with fewer arguments than it is

381

defined to allow. For example:

382

<div class="highlight-python3"><div class="highlight"><pre>def ask_ok(prompt, retries=4, complaint='Yes or no, please!'):

383

while True:

384

ok = input(prompt)

385

if ok in ('y', 'ye', 'yes'):

386

return True

387

if ok in ('n', 'no', 'nop', 'nope'):

388

return False

389

retries = retries - 1

390

if retries < 0:

391

raise OSError('uncooperative user')

392

print(complaint)

393

</pre></div>

394

</div>

395

This function can be called in several ways:

396

397

<li>giving only the mandatory argument:

398

<code class="docutils literal">ask_ok('Do you really want to quit?')</code></li>

399

<li>giving one of the optional arguments:

400

401

<li>or even giving all arguments:

402

<code class="docutils literal">ask_ok('OK to overwrite the file?', 2, 'Come on, only yes or no!')</code></li>

403

</ul>

404

This example also introduces the <a class="reference internal" href="../reference/expressions.html#in"><code class="xref std std-keyword docutils literal">in</code></a> keyword. This tests whether or

405

not a sequence contains a certain value.

406

The default values are evaluated at the point of function definition in the

407

defining scope, so that

408

<div class="highlight-python3"><div class="highlight"><pre>i = 5

409

410

def f(arg=i):

411

print(arg)

412

413

i = 6

414

f()

415

</pre></div>

416

</div>

417

will print <code class="docutils literal">5</code>.

418

Important warning: The default value is evaluated only once. This makes a

419

difference when the default is a mutable object such as a list, dictionary, or

420

instances of most classes. For example, the following function accumulates the

421

arguments passed to it on subsequent calls:

422

<div class="highlight-python3"><div class="highlight"><pre>def f(a, L=[]):

423

L.append(a)

424

return L

425

426

print(f(1))

427

print(f(2))

428

print(f(3))

429

</pre></div>

430

</div>

431

This will print

432

<div class="highlight-python3"><div class="highlight"><pre>[1]

433

[1, 2]

434

[1, 2, 3]

435

</pre></div>

436

</div>

437

If you don’t want the default to be shared between subsequent calls, you can

438

write the function like this instead:

439

440

if L is None:

441

L = []

442

L.append(a)

443

return L

444

</pre></div>

445

</div>

446

</div>

447

448

<h3>4.7.2. Keyword Arguments<a class="headerlink" href="#keyword-arguments" title="Permalink to this headline">¶</a></h3>

449

Functions can also be called using <a class="reference internal" href="../glossary.html#term-keyword-argument">keyword arguments</a>

450

of the form <code class="docutils literal">kwarg=value</code>. For instance, the following function:

451

<div class="highlight-python3"><div class="highlight"><pre>def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'):

452

print("-- This parrot wouldn't", action, end=' ')

453

print("if you put", voltage, "volts through it.")

454

print("-- Lovely plumage, the", type)

455

print("-- It's", state, "!")

456

</pre></div>

457

</div>

458

accepts one required argument (<code class="docutils literal">voltage</code>) and three optional arguments

459

(<code class="docutils literal">state</code>, <code class="docutils literal">action</code>, and <code class="docutils literal">type</code>). This function can be called in any

460

of the following ways:

461

<div class="highlight-python3"><div class="highlight"><pre>parrot(1000) # 1 positional argument

462

parrot(voltage=1000) # 1 keyword argument

463

parrot(voltage=1000000, action='VOOOOOM') # 2 keyword arguments

464

parrot(action='VOOOOOM', voltage=1000000) # 2 keyword arguments

465

parrot('a million', 'bereft of life', 'jump') # 3 positional arguments

466

parrot('a thousand', state='pushing up the daisies') # 1 positional, 1 keyword

467

</pre></div>

468

</div>

469

but all the following calls would be invalid:

470

<div class="highlight-python3"><div class="highlight"><pre>parrot() # required argument missing

471

parrot(voltage=5.0, 'dead') # non-keyword argument after a keyword argument

472

parrot(110, voltage=220) # duplicate value for the same argument

473

parrot(actor='John Cleese') # unknown keyword argument

474

</pre></div>

475

</div>

476

In a function call, keyword arguments must follow positional arguments.

477

All the keyword arguments passed must match one of the arguments

478

accepted by the function (e.g. <code class="docutils literal">actor</code> is not a valid argument for the

479

<code class="docutils literal">parrot</code> function), and their order is not important. This also includes

480

non-optional arguments (e.g. <code class="docutils literal">parrot(voltage=1000)</code> is valid too).

481

No argument may receive a value more than once.

482

Here’s an example that fails due to this restriction:

483

<div class="highlight-python3"><div class="highlight"><pre>>>> def function(a):

484

... pass

485

...

486

>>> function(0, a=0)

487

Traceback (most recent call last):

488

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

489

TypeError: function() got multiple values for keyword argument 'a'

490

</pre></div>

491

</div>

492

When a final formal parameter of the form <code class="docutils literal">**name</code> is present, it receives a

493

dictionary (see <a class="reference internal" href="../library/stdtypes.html#typesmapping">Mapping Types — dict</a>) containing all keyword arguments except for

494

those corresponding to a formal parameter. This may be combined with a formal

495

parameter of the form <code class="docutils literal">*name</code> (described in the next subsection) which

496

receives a tuple containing the positional arguments beyond the formal parameter

497

list. (<code class="docutils literal">*name</code> must occur before <code class="docutils literal">**name</code>.) For example, if we define a

498

function like this:

499

<div class="highlight-python3"><div class="highlight"><pre>def cheeseshop(kind, *arguments, **keywords):

500

print("-- Do you have any", kind, "?")

501

print("-- I'm sorry, we're all out of", kind)

502

for arg in arguments:

503

print(arg)

504

print("-" * 40)

505

keys = sorted(keywords.keys())

506

for kw in keys:

507

print(kw, ":", keywords[kw])

508

</pre></div>

509

</div>

510

It could be called like this:

511

<div class="highlight-python3"><div class="highlight"><pre>cheeseshop("Limburger", "It's very runny, sir.",

512

"It's really very, VERY runny, sir.",

513

shopkeeper="Michael Palin",

514

client="John Cleese",

515

sketch="Cheese Shop Sketch")

516

</pre></div>

517

</div>

518

and of course it would print:

519

<div class="highlight-python3"><div class="highlight"><pre>-- Do you have any Limburger ?

520

It's very runny, sir.

521

It's really very, VERY runny, sir.

522

----------------------------------------

523

client : John Cleese

524

shopkeeper : Michael Palin

525

sketch : Cheese Shop Sketch

526

</pre></div>

527

</div>

528

Note that the list of keyword argument names is created by sorting the result

529

of the keywords dictionary’s <code class="docutils literal">keys()</code> method before printing its contents;

530

if this is not done, the order in which the arguments are printed is undefined.

531

</div>

532

533

<h3>4.7.3. Arbitrary Argument Lists<a class="headerlink" href="#arbitrary-argument-lists" title="Permalink to this headline">¶</a></h3>

534

Finally, the least frequently used option is to specify that a function can be

535

called with an arbitrary number of arguments. These arguments will be wrapped

536

up in a tuple (see <a class="reference internal" href="datastructures.html#tut-tuples">Tuples and Sequences</a>). Before the variable number of arguments,

537

zero or more normal arguments may occur.

538

<div class="highlight-python3"><div class="highlight"><pre>def write_multiple_items(file, separator, *args):

539

file.write(separator.join(args))

540

</pre></div>

541

</div>

542

Normally, these <code class="docutils literal">variadic</code> arguments will be last in the list of formal

543

parameters, because they scoop up all remaining input arguments that are

544

passed to the function. Any formal parameters which occur after the <code class="docutils literal">*args</code>

545

parameter are ‘keyword-only’ arguments, meaning that they can only be used as

546

keywords rather than positional arguments.

547

<div class="highlight-python3"><div class="highlight"><pre>>>> def concat(*args, sep="/"):

548

... return sep.join(args)

549

...

550

>>> concat("earth", "mars", "venus")

551

'earth/mars/venus'

552

553

'earth.mars.venus'

554

</pre></div>

555

</div>

556

</div>

557

558

<h3>4.7.4. Unpacking Argument Lists<a class="headerlink" href="#unpacking-argument-lists" title="Permalink to this headline">¶</a></h3>

559

The reverse situation occurs when the arguments are already in a list or tuple

560

but need to be unpacked for a function call requiring separate positional

561

arguments. For instance, the built-in <a class="reference internal" href="../library/stdtypes.html#range" title="range"><code class="xref py py-func docutils literal">range()</code></a> function expects separate

562

start and stop arguments. If they are not available separately, write the

563

function call with the <code class="docutils literal">*</code>-operator to unpack the arguments out of a list

564

or tuple:

565

<div class="highlight-python3"><div class="highlight"><pre>>>> list(range(3, 6)) # normal call with separate arguments

566

[3, 4, 5]

567

>>> args = [3, 6]

568

>>> list(range(*args)) # call with arguments unpacked from a list

569

[3, 4, 5]

570

</pre></div>

571

</div>

572

In the same fashion, dictionaries can deliver keyword arguments with the <code class="docutils literal">**</code>-operator:

573

<div class="highlight-python3"><div class="highlight"><pre>>>> def parrot(voltage, state='a stiff', action='voom'):

574

... print("-- This parrot wouldn't", action, end=' ')

575

... print("if you put", voltage, "volts through it.", end=' ')

576

... print("E's", state, "!")

577

...

578

>>> d = {"voltage": "four million", "state": "bleedin' demised", "action": "VOOM"}

579

>>> parrot(**d)

580

-- This parrot wouldn't VOOM if you put four million volts through it. E's bleedin' demised !

581

</pre></div>

582

</div>

583

</div>

584

585

<h3>4.7.5. Lambda Expressions<a class="headerlink" href="#lambda-expressions" title="Permalink to this headline">¶</a></h3>

586

Small anonymous functions can be created with the <a class="reference internal" href="../reference/expressions.html#lambda"><code class="xref std std-keyword docutils literal">lambda</code></a> keyword.

587

This function returns the sum of its two arguments: <code class="docutils literal">lambda a, b: a+b</code>.

588

Lambda functions can be used wherever function objects are required. They are

589

syntactically restricted to a single expression. Semantically, they are just

590

syntactic sugar for a normal function definition. Like nested function

591

definitions, lambda functions can reference variables from the containing

592

scope:

593

<div class="highlight-python3"><div class="highlight"><pre>>>> def make_incrementor(n):

594

... return lambda x: x + n

595

...

596

>>> f = make_incrementor(42)

597

>>> f(0)

598

42

599

>>> f(1)

600

43

601

</pre></div>

602

</div>

603

The above example uses a lambda expression to return a function. Another use

604

is to pass a small function as an argument:

605

<div class="highlight-python3"><div class="highlight"><pre>>>> pairs = [(1, 'one'), (2, 'two'), (3, 'three'), (4, 'four')]

606

>>> pairs.sort(key=lambda pair: pair[1])

607

>>> pairs

608

[(4, 'four'), (1, 'one'), (3, 'three'), (2, 'two')]

609

</pre></div>

610

</div>

611

</div>

612

613

<h3>4.7.6. Documentation Strings<a class="headerlink" href="#documentation-strings" title="Permalink to this headline">¶</a></h3>

614

Here are some conventions about the content and formatting of documentation

615

strings.

616

The first line should always be a short, concise summary of the object’s

617

purpose. For brevity, it should not explicitly state the object’s name or type,

618

since these are available by other means (except if the name happens to be a

619

verb describing a function’s operation). This line should begin with a capital

620

letter and end with a period.

621

If there are more lines in the documentation string, the second line should be

622

blank, visually separating the summary from the rest of the description. The

623

following lines should be one or more paragraphs describing the object’s calling

624

conventions, its side effects, etc.

625

The Python parser does not strip indentation from multi-line string literals in

626

Python, so tools that process documentation have to strip indentation if

627

desired. This is done using the following convention. The first non-blank line

628

after the first line of the string determines the amount of indentation for

629

the entire documentation string. (We can’t use the first line since it is

630

generally adjacent to the string’s opening quotes so its indentation is not

631

apparent in the string literal.) Whitespace “equivalent” to this indentation is

632

then stripped from the start of all lines of the string. Lines that are

633

indented less should not occur, but if they occur all their leading whitespace

634

should be stripped. Equivalence of whitespace should be tested after expansion

635

of tabs (to 8 spaces, normally).

636

Here is an example of a multi-line docstring:

637

<div class="highlight-python3"><div class="highlight"><pre>>>> def my_function():

638

... """Do nothing, but document it.

639

...

640

... No, really, it doesn't do anything.

641

... """

642

... pass

643

...

644

>>> print(my_function.__doc__)

645

Do nothing, but document it.

646

647

No, really, it doesn't do anything.

648

</pre></div>

649

</div>

650

</div>

651

652

<h3>4.7.7. Function Annotations<a class="headerlink" href="#function-annotations" title="Permalink to this headline">¶</a></h3>

653

<a class="reference internal" href="../reference/compound_stmts.html#function">Function annotations</a> are completely optional metadata

654

information about the types used by user-defined functions (see <a class="pep reference external" href="https://www.python.org/dev/peps/pep-0484">PEP 484</a>

655

for more information).

656

Annotations are stored in the <code class="xref py py-attr docutils literal">__annotations__</code> attribute of the function

657

as a dictionary and have no effect on any other part of the function. Parameter

658

annotations are defined by a colon after the parameter name, followed by an

659

expression evaluating to the value of the annotation. Return annotations are

660

defined by a literal <code class="docutils literal">-></code>, followed by an expression, between the parameter

661

list and the colon denoting the end of the <a class="reference internal" href="../reference/compound_stmts.html#def"><code class="xref std std-keyword docutils literal">def</code></a> statement. The

662

following example has a positional argument, a keyword argument, and the return

663

value annotated:

664

<div class="highlight-python3"><div class="highlight"><pre>>>> def f(ham: str, eggs: str = 'eggs') -> str:

665

... print("Annotations:", f.__annotations__)

666

... print("Arguments:", ham, eggs)

667

... return ham + ' and ' + eggs

668

...

669

>>> f('spam')

670

Annotations: {'ham': <class 'str'>, 'return': <class 'str'>, 'eggs': <class 'str'>}

671

Arguments: spam eggs

672

'spam and eggs'

673

</pre></div>

674

</div>

675

</div>

676

</div>

677

678

<h2>4.8. Intermezzo: Coding Style<a class="headerlink" href="#intermezzo-coding-style" title="Permalink to this headline">¶</a></h2>

679

Now that you are about to write longer, more complex pieces of Python, it is a

680

good time to talk about coding style. Most languages can be written (or more

681

concise, formatted) in different styles; some are more readable than others.

682

Making it easy for others to read your code is always a good idea, and adopting

683

a nice coding style helps tremendously for that.

684

For Python, <a class="pep reference external" href="https://www.python.org/dev/peps/pep-0008">PEP 8</a> has emerged as the style guide that most projects adhere to;

685

it promotes a very readable and eye-pleasing coding style. Every Python

686

developer should read it at some point; here are the most important points

687

extracted for you:

688

<ul>

689

<li>Use 4-space indentation, and no tabs.

690

4 spaces are a good compromise between small indentation (allows greater

691

nesting depth) and large indentation (easier to read). Tabs introduce

692

confusion, and are best left out.

693

</li>

694

<li>Wrap lines so that they don’t exceed 79 characters.

695

This helps users with small displays and makes it possible to have several

696

code files side-by-side on larger displays.

697

</li>

698

<li>Use blank lines to separate functions and classes, and larger blocks of

699

code inside functions.

700

</li>

701

<li>When possible, put comments on a line of their own.

702

</li>

703

<li>Use docstrings.

704

</li>

705

<li>Use spaces around operators and after commas, but not directly inside

706

bracketing constructs: <code class="docutils literal">a = f(1, 2) + g(3, 4)</code>.

707

</li>

708

<li>Name your classes and functions consistently; the convention is to use

709

<code class="docutils literal">CamelCase</code> for classes and <code class="docutils literal">lower_case_with_underscores</code> for functions

710

and methods. Always use <code class="docutils literal">self</code> as the name for the first method argument

711

(see <a class="reference internal" href="classes.html#tut-firstclasses">A First Look at Classes</a> for more on classes and methods).

712

</li>

713

<li>Don’t use fancy encodings if your code is meant to be used in international

714

environments. Python’s default, UTF-8, or even plain ASCII work best in any

715

case.

716

</li>

717

<li>Likewise, don’t use non-ASCII characters in identifiers if there is only the

718

slightest chance people speaking a different language will read or maintain

719

the code.

720

</li>

721

</ul>

722

Footnotes

723

724

725

726

<tr><td class="label"><a class="fn-backref" href="#id1">[1]</a></td><td>Actually, call by object reference would be a better description,

727

since if a mutable object is passed, the caller will see any changes the

728

callee makes to it (items inserted into a list).</td></tr>

729

</tbody>

730

</table>

731

</div>

732

</div>

733

734

735

</div>

736

</div>

737

</div>

738

739

740

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

741

<ul>

742

<li><a class="reference internal" href="#">4. More Control Flow Tools</a><ul>

743

<li><a class="reference internal" href="#if-statements">4.1. <code class="docutils literal">if</code> Statements</a></li>

744

<li><a class="reference internal" href="#for-statements">4.2. <code class="docutils literal">for</code> Statements</a></li>

745

<li><a class="reference internal" href="#the-range-function">4.3. The <code class="docutils literal">range()</code> Function</a></li>

746

<li><a class="reference internal" href="#break-and-continue-statements-and-else-clauses-on-loops">4.4. <code class="docutils literal">break</code> and <code class="docutils literal">continue</code> Statements, and <code class="docutils literal">else</code> Clauses on Loops</a></li>

747

<li><a class="reference internal" href="#pass-statements">4.5. <code class="docutils literal">pass</code> Statements</a></li>

748

<li><a class="reference internal" href="#defining-functions">4.6. Defining Functions</a></li>

749

<li><a class="reference internal" href="#more-on-defining-functions">4.7. More on Defining Functions</a><ul>

750

<li><a class="reference internal" href="#default-argument-values">4.7.1. Default Argument Values</a></li>

751

<li><a class="reference internal" href="#keyword-arguments">4.7.2. Keyword Arguments</a></li>

752

<li><a class="reference internal" href="#arbitrary-argument-lists">4.7.3. Arbitrary Argument Lists</a></li>

753

<li><a class="reference internal" href="#unpacking-argument-lists">4.7.4. Unpacking Argument Lists</a></li>

754

<li><a class="reference internal" href="#lambda-expressions">4.7.5. Lambda Expressions</a></li>

755

<li><a class="reference internal" href="#documentation-strings">4.7.6. Documentation Strings</a></li>

756

<li><a class="reference internal" href="#function-annotations">4.7.7. Function Annotations</a></li>

757

</ul>

758

</li>

759

<li><a class="reference internal" href="#intermezzo-coding-style">4.8. Intermezzo: Coding Style</a></li>

760

</ul>

761

</li>

762

</ul>

763

764

<h4>Previous topic</h4>

765

<a href="introduction.html"

766

title="previous chapter">3. An Informal Introduction to Python</a>

767

<h4>Next topic</h4>

768

<a href="datastructures.html"

769

title="next chapter">5. Data Structures</a>

770

771

772

<li><a href="../bugs.html">Report a Bug</a></li>

773

<li><a href="../_sources/tutorial/controlflow.txt"

774

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

775

</ul>

776

777

778

<h3>Quick search</h3>

779

780

781

782

783

784

</form>

785

786

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

787

788

</div>

789

790

</div>

791

</div>

792

793

</div>

794

795

<h3>Navigation</h3>

796

<ul>

797

798

<a href="../genindex.html" title="General Index"

799

>index</a></li>

800

801

<a href="../py-modindex.html" title="Python Module Index"

802

>modules</a> |</li>

803

804

<a href="datastructures.html" title="5. Data Structures"

805

>next</a> |</li>

806

807

<a href="introduction.html" title="3. An Informal Introduction to Python"

808

>previous</a> |</li>

809

<li><img src="../_static/py.png" alt=""

810

style="vertical-align: middle; margin-top: -1px"/></li>

811

<li><a href="https://www.python.org/">Python</a> »</li>

812

<li>

813

3.5.1

814

<a href="../index.html">Documentation </a> »

815

</li>

816

817

<li class="nav-item nav-item-1"><a href="index.html" >The Python Tutorial</a> »</li>

818

</ul>

819

</div>

820

821

822

823

The Python Software Foundation is a non-profit corporation.

824

<a href="https://www.python.org/psf/donations/">Please donate.</a>

825

826

Last updated on Jan 22, 2016.

827

<a href="../bugs.html">Found a bug</a>?

828

829

Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.3.3.

830

</div>

831

832

</body>

833

</html>

b'\\ No newline at end of file'

Older »