IntroPython-2017/modules/BasicPython.html at gh-pages · jt-python/IntroPython-2017

History

1028 lines (936 loc) · 68.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

655

656

657

658

659

660

661

662

663

664

665

666

667

668

669

670

671

672

673

674

675

676

677

678

679

680

681

682

683

684

685

686

687

688

689

690

691

692

693

694

695

696

697

698

699

700

701

702

703

704

705

706

707

708

709

710

711

712

713

714

715

716

717

718

719

720

721

722

723

724

725

726

727

728

729

730

731

732

733

734

735

736

737

738

739

740

741

742

743

744

745

746

747

748

749

750

751

752

753

754

755

756

757

758

759

760

761

762

763

764

765

766

767

768

769

770

771

772

773

774

775

776

777

778

779

780

781

782

783

784

785

786

787

788

789

790

791

792

793

794

795

796

797

798

799

800

801

802

803

804

805

806

807

808

809

810

811

812

813

814

815

816

817

818

819

820

821

822

823

824

825

826

827

828

829

830

831

832

833

834

835

836

837

838

839

840

841

842

843

844

845

846

847

848

849

850

851

852

853

854

855

856

857

858

859

860

861

862

863

864

865

866

867

868

869

870

871

872

873

874

875

876

877

878

879

880

881

882

883

884

885

886

887

888

889

890

891

892

893

894

895

896

897

898

899

900

901

902

903

904

905

906

907

908

909

910

911

912

913

914

915

916

917

918

919

920

921

922

923

924

925

926

927

928

929

930

931

932

933

934

935

936

937

938

939

940

941

942

943

944

945

946

947

948

949

950

951

952

953

954

955

956

957

958

959

960

961

962

963

964

965

966

967

968

969

970

971

972

973

974

975

976

977

978

979

980

981

982

983

984

985

986

987

988

989

990

991

992

993

994

995

996

997

998

999

1000

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

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

<head>

<title>Basic Python — PythonCert 4.0 documentation</title>

var DOCUMENTATION_OPTIONS = {

URL_ROOT: '../',

VERSION: '4.0',

COLLAPSE_INDEX: false,

FILE_SUFFIX: '.html',

HAS_SOURCE: true,

SOURCELINK_SUFFIX: '.txt'

};

</script>

</head>

<body>

<h1>Basic Python<a class="headerlink" href="#basic-python" title="Permalink to this headline">¶</a></h1>

Values, Types, and Symbols

Expressions and Statements

(Follow along in the iPython interpreter…)

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

All of programming is really about manipulating values.

<li>Values are pieces of unnamed data: <code class="docutils literal">42</code>, <code class="docutils literal">'Hello, world'</code></li>

<li>In Python, all values are objects<ul>

<li>Try <code class="docutils literal">dir(42)</code> - lots going on behind the curtain!</li>

</ul>

</li>

<li>Every value has a type<ul>

<li>Try <code class="docutils literal">type(42)</code> - the type of a value determines what it can do</li>

</ul>

</li>

</ul>

</div>

<h2>Literals for the Basic Value types:<a class="headerlink" href="#literals-for-the-basic-value-types" title="Permalink to this headline">¶</a></h2>

<dt>Numbers:</dt>

<li>floating point: <code class="docutils literal">3.4</code></li>

<li>integers: <code class="docutils literal">456</code></li>

</ul>

</dd>

<li>(either single or double quotes work – why?)</li>

</ul>

</dd>

<dt>Boolean values:</dt>

<li><code class="docutils literal">False</code></li>

</ul>

</dd>

<dt>The nothing object:</dt>

</ul>

</dd>

</dl>

(There are intricacies to all of these that we’ll get into later)

</div>

<h2>Code structure<a class="headerlink" href="#code-structure" title="Permalink to this headline">¶</a></h2>

Each line is a piece of code.

Comments:

<div class="highlight-ipython"><div class="highlight"><pre>In [3]: # everything after a '#' is a comment

</pre></div>

</div>

Expressions:

<div class="highlight-ipython"><div class="highlight"><pre>In [4]: # evaluating an expression results in a value

In [5]: 3 + 4

Out[5]: 7

</pre></div>

</div>

Statements:

but statements carry out an action, but do not evaluate to a value, that is you can’t assign to them (or put them in a lamda, or…)

<div class="highlight-ipython"><div class="highlight"><pre>In [6]: # statements carry out an action, do not evaluate a value, may contain an expression

In [7]: line_count = 42

In [8]: return something

</pre></div>

</div>

It is somewhat obvious, but handy when playing with code:

<div class="highlight-ipython"><div class="highlight"><pre>In [1]: print ("something")

something

</pre></div>

</div>

You can print multiple things:

<div class="highlight-ipython"><div class="highlight"><pre>In [2]: print("the value is", 5)

the value is 5

</pre></div>

</div>

Any python object can be printed (though it might not be pretty…)

<div class="highlight-ipython"><div class="highlight"><pre>In [1]: class bar(object):

...: pass

...:

In [2]: print(bar)

</pre></div>

</div>

Blocks of code are delimited by a colon and indentation:

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

a_new_code_block

end_of_the_block

</pre></div>

</div>

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

print(i**2)

</pre></div>

</div>

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

do_something_bad()

except:

fix_the_problem()

</pre></div>

</div>

Python uses indentation to delineate structure.

This means that in Python, whitespace is significant.

(but ONLY for newlines and indentation)

The standard is to indent with 4 spaces.

SPACES ARE NOT TABS

TABS ARE NOT SPACES

These two blocks look the same:

print(i**2)

</pre></div>

</div>

print(i**2)

</pre></div>

</div>

But they are not:

\s\s\s\sprint i**2

</pre></div>

</div>

\tprint i**2

</pre></div>

</div>

ALWAYS INDENT WITH 4 SPACES

NEVER INDENT WITH TABS

Make sure your editor is set to use spaces only –

Even when you hit the <tab> key

[Python itself allows any number of spaces (and tabs), but you are just going to confuse yourself and others if you do anything else]

</div>

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

An expression is made up of values and operators.

<li>An expression is evaluated to produce a new value: <code class="docutils literal">2 + 2</code><ul>

<li>The Python interpreter can be used as a calculator to evaluate expressions</li>

</ul>

</li>

<li>Integer vs. float arithmetic<ul>

<li>(Python 3 smooths this out)</li>

<li>Always use <code class="docutils literal">/</code> when you want division with float results, <code class="docutils literal">//</code> when you want floored (integer) results (no remainder).</li>

</ul>

</li>

<li>Type conversions<ul>

<li>This is the source of many errors, especially in handling text</li>

</ul>

</li>

<li>Type errors - checked at run time only</li>

</ul>

</div>

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

Symbols are how we give names to values (objects).

<li>Symbols must begin with an underscore or letter</li>

<li>Symbols can contain any number of underscores, letters and numbers<ul>

<li>this_is_a_symbol</li>

<li>_AsIsThis</li>

<li>1butThisIsNot</li>

</ul>

</li>

<li>Symbols don’t have a type; values do<ul>

<li>This is why python is “Dynamic”</li>

</ul>

</li>

</ul>

</div>

<h2>Symbols and Type<a class="headerlink" href="#symbols-and-type" title="Permalink to this headline">¶</a></h2>

Evaluating the type of a symbol will return the type of the value to which

it is bound.

<div class="highlight-ipython"><div class="highlight"><pre>In [19]: type(42)

Out[19]: int

In [20]: type(3.14)

Out[20]: float

In [21]: a = 42

In [22]: b = 3.14

In [23]: type(a)

Out[23]: int

In [25]: a = b

In [26]: type(a)

Out[26]: float

</pre></div>

</div>

wait! <code class="docutils literal">a</code> has a different type?!? – yes, because it’s the type of the value: “3.14”, names don’t actually have a type, the same name can refer to any type.

</div>

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

A symbol is bound to a value with the assignment operator: <code class="docutils literal">=</code>

<li>This attaches a name to a value</li>

<li>A value can have many names (or none!)</li>

<li>Assignment is a statement, it returns no value</li>

</ul>

Evaluating the name will return the value to which it is bound

<div class="highlight-ipython"><div class="highlight"><pre>In [26]: name = "value"

In [27]: name

Out[27]: 'value'

In [28]: an_integer = 42

In [29]: an_integer

Out[29]: 42

In [30]: a_float = 3.14

In [31]: a_float

Out[31]: 3.14

</pre></div>

</div>

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

<li>In most languages, what Python calls symbols or names are called “variables”.</li>

<li>In fact, we will probably call them variables in this class.</li>

<li>That’s because they are used, for the most part, for the same purposes.</li>

<li>But often a “variable” is defined as something like:

“a place in memory that can store values”</li>

<li>That is NOT the same thing as a symbol or name in Python!</li>

<li>A name can be bound to a value – but that has nothing to do with a

location in memory.</li>

</ul>

</div>

<h2>In-Place Assignment<a class="headerlink" href="#in-place-assignment" title="Permalink to this headline">¶</a></h2>

You can also do “in-place” assignment with <code class="docutils literal">+=</code>.

<div class="highlight-ipython"><div class="highlight"><pre>In [32]: a = 1

In [33]: a

Out[33]: 1

In [34]: a = a + 1

In [35]: a

Out[35]: 2

In [36]: a += 1

In [37]: a

Out[37]: 3

</pre></div>

</div>

also: <code class="docutils literal">-=, *=, /=, **=, \%=</code>

(not quite – really in-place assignment for mutables….)

</div>

<h2>Multiple Assignment<a class="headerlink" href="#multiple-assignment" title="Permalink to this headline">¶</a></h2>

You can assign multiple names from multiple expressions in one

statement

<div class="highlight-ipython"><div class="highlight"><pre>In [48]: x = 2

In [49]: y = 5

In [50]: i, j = 2 * x, 3 ** y

In [51]: i

Out[51]: 4

In [52]: j

Out[52]: 243

</pre></div>

</div>

Python evaluates all the expressions on the right before doing any assignments

</div>

<h2>Nifty Python Trick<a class="headerlink" href="#nifty-python-trick" title="Permalink to this headline">¶</a></h2>

Using this feature, we can swap values between two names in one statement:

<div class="highlight-ipython"><div class="highlight"><pre>In [51]: i

Out[51]: 4

In [52]: j

Out[52]: 243

In [53]: i, j = j, i

In [54]: i

Out[54]: 243

In [55]: j

Out[55]: 4

</pre></div>

</div>

Multiple assignment and symbol swapping can be very useful in certain contexts

</div>

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

You can’t actually directly delete values in python…

<code class="docutils literal">del</code> only deletes a name (or “unbinds” the name…)

<div class="highlight-ipython"><div class="highlight"><pre>In [56]: a = 5

In [57]: b = a

In [58]: del a

In [59]: a

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

NameError Traceback (most recent call last)

<ipython-input-59-60b725f10c9c> in <module>()

----> 1 a

NameError: name 'a' is not defined

</pre></div>

</div>

The object is still there…python will only delete it if there are no

references to it.

<div class="highlight-ipython"><div class="highlight"><pre>In [15]: a = 5

In [16]: b = a

In [17]: del a

In [18]: a

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

NameError Traceback (most recent call last)

<ipython-input-18-60b725f10c9c> in <module>()

----> 1 a

NameError: name 'a' is not defined

In [19]: b

Out[19]: 5

</pre></div>

</div>

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

Every value in Python is an object.

Every object is unique and has a unique identity, which you can inspect with

the <code class="docutils literal">id</code> builtin:

<div class="highlight-ipython"><div class="highlight"><pre>In [68]: id(i)

Out[68]: 140553647890984

In [69]: id(j)

Out[69]: 140553647884864

In [70]: new_i = i

In [71]: id(new_i)

Out[71]: 140553647890984

</pre></div>

</div>

<h2>Testing Identity<a class="headerlink" href="#testing-identity" title="Permalink to this headline">¶</a></h2>

You can find out if the values bound to two different symbols are the same

object using the <code class="docutils literal">is</code> operator:

<div class="highlight-ipython"><div class="highlight"><pre>In [72]: count = 23

In [73]: other_count = count

In [74]: count is other_count

Out[74]: True

In [75]: count = 42

In [76]: other_count is count

Out[76]: False

</pre></div>

</div>

[demo]

NOTE: Checking the id of an object, or using “is” to check if two objects are the same is rarely used except for debugging and understanding what’s going on under the hood. They are not used regularly in production code.

</div>

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

You can test for the equality of certain values with the <code class="docutils literal">==</code> operator

<div class="highlight-ipython"><div class="highlight"><pre>In [77]: val1 = 20 + 30

In [78]: val2 = 5 * 10

In [79]: val1 == val2

Out[79]: True

In [80]: val3 = '50'

In [81]: val1 == val3

Out[84]: False

</pre></div>

</div>

A string is never equal to a number!

[demo]

</div>

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

Python has three “singletons” – a value for which there is only one instance:

<div><code class="docutils literal">True</code>, <code class="docutils literal">False</code>, and <code class="docutils literal">None</code></div></blockquote>

To check if a name is bound to one of these, you use <code class="docutils literal">is</code>:

<div class="highlight-default"><div class="highlight"><pre>.. code-block:: python

</pre></div>

</div>

<div>a is True

b is False

x is None

</div></blockquote>

Note that in contrast to english – “is” is asking a question, not making an assertion – <code class="docutils literal">a is True</code> means “is a the True value?”

</div>

<h2>Operator Precedence<a class="headerlink" href="#operator-precedence" title="Permalink to this headline">¶</a></h2>

Operator Precedence determines what evaluates first:

<div class="highlight-python"><div class="highlight"><pre>4 + 3 * 5 != (4 + 3) * 5

</pre></div>

</div>

To force statements to be evaluated out of order, use parentheses – expressions in parentheses are always evaluated first:

Python follows the “usual” rules of algebra.

</div>

<h2>Python Operator Precedence<a class="headerlink" href="#python-operator-precedence" title="Permalink to this headline">¶</a></h2>

<dt>Parentheses and Literals:</dt>

</dd>

<dt>Function Calls:</dt>

<dt>Slicing and Subscription:</dt>

</dd>

<dt>Attribute Reference:</dt>

<dd><code class="docutils literal">obj.attribute</code></dd>

<dt>Exponentiation:</dt>

<dt>Bitwise NOT, Unary Signing:</dt>

</dd>

<dt>Multiplication, Division, Modulus:</dt>

<dt>Addition, Subtraction:</dt>

<dt>Bitwise operations:</dt>

</dd>

<dt>Comparisons:</dt>

<dt>Membership and Identity:</dt>

<dt>Boolean operations:</dt>

<dt>Anonymous Functions:</dt>

<dd><code class="docutils literal">lambda</code></dd>

</dl>

</div>

<h2>String Literals<a class="headerlink" href="#string-literals" title="Permalink to this headline">¶</a></h2>

A “string” is a chunk of text.

You define a <code class="docutils literal">string</code> value by writing a string literal:

<div class="highlight-ipython"><div class="highlight"><pre>In [1]: 'a string'

Out[1]: 'a string'

In [2]: "also a string"

Out[2]: 'also a string'

In [3]: "a string with an apostrophe: isn't it cool?"

Out[3]: "a string with an apostrophe: isn't it cool?"

In [4]: 'a string with an embedded "quote"'

Out[4]: 'a string with an embedded "quote"'

</pre></div>

</div>

<div class="highlight-ipython"><div class="highlight"><pre>In [5]: """a multi-line

...: string

...: all in one

...: """

Out[5]: 'a multi-line\nstring\nall in one\n'

In [6]: "a string with an \n escaped character"

Out[6]: 'a string with an \n escaped character'

In [7]: r'a "raw" string, the \n comes through as a \n'

Out[7]: 'a "raw" string, the \\n comes through as a \\n'

</pre></div>

</div>

Python3 strings fully support Unicode, which means that it can support literally all the languages in the world (and then some – Kligon, anyone? – well <a class="reference external" href="http://www.personal.psu.edu/ejp10/blogs/gotunicode/2010/10/conscript-unicode-registry-csu.html">sort of.</a>)

Because Unicode is native to python strings, you can get very far without even thinking about it. Anything you can type in your editor will work fine.

</div>

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

Python defines a number of keywords

These are language constructs.

You cannot use these words as symbols.

<div class="highlight-default"><div class="highlight"><pre>False class finally is return

None continue for lambda try

True def from nonlocal while

and del global not with

as elif if or yield

assert else import pass

break except in raise

</pre></div>

</div>

If you try to use any of the keywords as symbols, you will cause a

<code class="docutils literal">SyntaxError</code>:

<div class="highlight-ipython"><div class="highlight"><pre>In [13]: del = "this will raise an error"

File "<ipython-input-13-c816927c2fb8>", line 1

del = "this will raise an error"

^

SyntaxError: invalid syntax

</pre></div>

</div>

<div class="highlight-ipython"><div class="highlight"><pre>In [14]: def a_function(else='something'):

....: print(else)

....:

File "<ipython-input-14-1dbbea504a9e>", line 1

def a_function(else='something'):

^

SyntaxError: invalid syntax

</pre></div>

</div>

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

Python also has a number of pre-bound symbols, called builtins

Try this:

<div class="highlight-ipython"><div class="highlight"><pre>In [6]: dir(__builtins__)

Out[6]:

['ArithmeticError',

'AssertionError',

'AttributeError',

'BaseException',

'BufferError',

...

'vars',

'xrange',

'zip']

</pre></div>

</div>

You are free to rebind these symbols:

<div class="highlight-ipython"><div class="highlight"><pre>In [15]: type('a new and exciting string')

Out[15]: str

In [16]: type = 'a slightly different string'

In [17]: type('type is no longer what it was')

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

TypeError Traceback (most recent call last)

<ipython-input-17-907616e55e2a> in <module>()

----> 1 type('type is no longer what it was')

TypeError: 'str' object is not callable

</pre></div>

</div>

In general, this is a BAD IDEA – hopefully your editor will warn you.

</div>

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

Notice that the first batch of <code class="docutils literal">__builtins__</code> are all Exceptions

Exceptions are how Python tells you that something has gone wrong.

There are several exceptions that you are likely to see a lot of:

<li><code class="docutils literal">NameError</code>: indicates that you have tried to use a symbol that is not bound to a value.</li>

<li><code class="docutils literal">TypeError</code>: indicates that you have tried to use the wrong kind of object for an operation.</li>

<li><code class="docutils literal">SyntaxError</code>: indicates that you have mis-typed something.</li>

<li><code class="docutils literal">AttributeError</code>: indicates that you have tried to access an attribute or

method that an object does not have (this often means you have a different

type of object than you expect)</li>

</ul>

</div>

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

What is a function?

A function is a self-contained chunk of code

You use them when you need the same code to run multiple times,

or in multiple parts of the program.

(DRY) – “Don’t Repeat Yourself”

Or just to keep the code clean.

Functions can take and return information.

The minimal Function has at least one statement.

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

a_statement

</pre></div>

</div>

Pass Statement does nothing (Note the indentation!)

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

pass

</pre></div>

</div>

This, of course, is not useful – you will generally have multiple statements in a function – and they will do something.

</div>

<h2>Functions: <code class="docutils literal">def</code><a class="headerlink" href="#functions-def" title="Permalink to this headline">¶</a></h2>

<code class="docutils literal">def</code> is a statement:

<li>it is executed</li>

<li>it creates a local name</li>

<li>it does not return a value</li>

</ul>

</div></blockquote>

Function defs must be executed before the functions can be called:

<div class="highlight-ipython"><div class="highlight"><pre>In [23]: unbound()

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

NameError Traceback (most recent call last)

<ipython-input-23-3132459951e4> in <module>()

----> 1 unbound()

NameError: name 'unbound' is not defined

</pre></div>

</div>

<div class="highlight-ipython"><div class="highlight"><pre>In [18]: def simple():

....: print("I am a simple function")

....:

In [19]: simple()

I am a simple function

</pre></div>

</div>

<h2>Calling Functions<a class="headerlink" href="#calling-functions" title="Permalink to this headline">¶</a></h2>

You call a function using the function call operator (parentheses):

<div class="highlight-ipython"><div class="highlight"><pre>In [2]: type(simple)

Out[2]: function

In [3]: simple

Out[3]: <function __main__.simple>

In [4]: simple()

I am a simple function

</pre></div>

</div>

Calling a function is how you run the code in that function.

</div>

<h2>Functions: Call Stack<a class="headerlink" href="#functions-call-stack" title="Permalink to this headline">¶</a></h2>

Functions call functions – this makes what is called an execution stack. That is what a “trace back”, often referred to in Exceptions, is – the function call stack.

<div class="highlight-ipython"><div class="highlight"><pre>In [5]: def exceptional():

...: print("I am exceptional!")

...: print 1/0

...:

In [6]: def passive():

...: pass

...:

In [7]: def doer():

...: passive()

...: exceptional()

...:

</pre></div>

</div>

You’ve defined three functions, one of which will call the other two.

When an error occurs, you are presented with a “traceback” of the call stack:

</div>

<h2>Functions: Tracebacks<a class="headerlink" href="#functions-tracebacks" title="Permalink to this headline">¶</a></h2>

<div class="highlight-ipython"><div class="highlight"><pre>In [8]: doer()

I am exceptional!

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

ZeroDivisionError Traceback (most recent call last)

<ipython-input-8-685a01a77340> in <module>()

----> 1 doer()

<ipython-input-7-aaadfbdd293e> in doer()

1 def doer():

2 passive()

----> 3 exceptional()

4

<ipython-input-5-d8100c70edef> in exceptional()

1 def exceptional():

2 print("I am exceptional!")

----> 3 print(1/0)

4

ZeroDivisionError: integer division or modulo by zero

</pre></div>

</div>

The error occurred in the <code class="docutils literal">doer</code> function – but the traceback shows you where that was called from.

Note that is listed in reverse order – reverse of the order in which it was called.

In a more complex system, this can be VERY useful – learn to read tracebacks!

</div>

<h2>Functions: <code class="docutils literal">return</code><a class="headerlink" href="#functions-return" title="Permalink to this headline">¶</a></h2>

Every function ends by returning a value

This is actually the simplest possible function:

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

return None

</pre></div>

</div>

if you don’t explicitly put <code class="docutils literal">return</code> there, Python will return <code class="docutils literal">None</code>:

<div class="highlight-ipython"><div class="highlight"><pre>In [9]: def fun():

...: pass

...:

In [10]: fun()

In [11]: result = fun()

In [12]: print(result)

None

</pre></div>

</div>

note that the interpreter eats <code class="docutils literal">None</code> – you need to call <code class="docutils literal">print()</code> to see it.

</div>

<h2>More on return<a class="headerlink" href="#more-on-return" title="Permalink to this headline">¶</a></h2>

Only one return statement in a function will ever be executed.

Ever.

Anything after a executed return statement will never get run.

This is useful when debugging!

<div class="highlight-ipython"><div class="highlight"><pre>In [14]: def no_error():

....: return 'done'

....: # no more will happen

....: print(1/0)

....:

In [15]: no_error()

Out[15]: 'done'

</pre></div>

</div>

However, functions can return multiple results:

<div class="highlight-ipython"><div class="highlight"><pre>In [16]: def fun():

....: return 1, 2, 3

....:

In [17]: fun()

Out[17]: (1, 2, 3)

</pre></div>

</div>

Remember multiple assignment?

<div class="highlight-ipython"><div class="highlight"><pre>In [18]: x, y, z = fun()

In [19]: x

Out[19]: 1

In [20]: y

Out[20]: 2

In [21]: z

Out[21]: 3

</pre></div>

</div>

<h2>Functions: parameters<a class="headerlink" href="#functions-parameters" title="Permalink to this headline">¶</a></h2>

In a <code class="docutils literal">def</code> statement, the values written inside the parens are

parameters

<div class="highlight-ipython"><div class="highlight"><pre>In [22]: def fun(x, y, z):

....: q = x + y + z

....: print(x, y, z, q)

....:

</pre></div>

</div>

x, y, z are local names – so is q

</div>

<h2>Functions: arguments<a class="headerlink" href="#functions-arguments" title="Permalink to this headline">¶</a></h2>

When you call a function, you pass values to the function parameters as

arguments

<div class="highlight-ipython"><div class="highlight"><pre>In [23]: fun(3, 4, 5)

3 4 5 12

</pre></div>

</div>

The values you pass in are bound to the names inside the function and used.

The name used outside the object is separate from the name used inside the function.

</div>

<h2>Making a Decision<a class="headerlink" href="#making-a-decision" title="Permalink to this headline">¶</a></h2>

“Conditionals”

In order to do anything interesting at all, you need to be able to make a decision.

<code class="docutils literal">if</code> and <code class="docutils literal">elif</code> (else if) allow you to make decisions:

<div class="highlight-ipython"><div class="highlight"><pre>In [12]: def test(a):

....: if a == 5:

....: print("that's the value I'm looking for!")

....: elif a == 7:

....: print("that's an OK number")

....: else:

....: print("that number won't do!")

In [13]: test(5)

that's the value I'm looking for!

In [14]: test(7)

that's an OK number

In [15]: test(14)

that number won't do!

</pre></div>

</div>

There is more to it than that, but this will get you started.

What’s the difference between these two?

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

print('a')

elif b:

print('b')

## versus...

if a:

print('a')

if b:

print('b')

</pre></div>

</div>

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

A way to store a bunch of stuff in order

Pretty much like an “array” or “vector” in other languages

To make a list literal you use square brackets an commas between the items:

<div class="highlight-python"><div class="highlight"><pre>a_list = [2,3,5,9]

a_list_of_strings = ['this', 'that', 'the', 'other']

</pre></div>

</div>

You can put any type of object in a list…

Lists are a key python data type with lots of functionality that we will get into later.

</div>

<h2><code class="docutils literal">for</code> loops<a class="headerlink" href="#for-loops" title="Permalink to this headline">¶</a></h2>

Sometimes called a ‘determinate’ loop

When you need to do something to all the objects in a sequence

<div class="highlight-ipython"><div class="highlight"><pre>In [10]: a_list = [2,3,4,5]

In [11]: for item in a_list:

....: print(item)

....:

2

3

4

5

</pre></div>

</div>

<h2><code class="docutils literal">range()</code> and for<a class="headerlink" href="#range-and-for" title="Permalink to this headline">¶</a></h2>

<code class="docutils literal">range</code> builds sequences of numbers automatically

Use it when you need to do something a set number of times

<div class="highlight-ipython"><div class="highlight"><pre>num_stars = 4

In [31]: for i in range(num_stars):

print('*', end=' ')

....:

* * * *

</pre></div>

</div>

NOTE: <code class="docutils literal">range(n)</code> creates an “iterable” – something you can loop over

– more on that later.

</div>

<h2><code class="docutils literal">assert</code><a class="headerlink" href="#assert" title="Permalink to this headline">¶</a></h2>

Writing <code class="docutils literal">tests</code> that demonstrate that your program works is an important part of learning to program.

The python <code class="docutils literal">assert</code> statement is useful in writing simple tests

for your code.

<div class="highlight-ipython"><div class="highlight"><pre>In [1]: def add(n1, n2):

...: return n1 + n2

...:

In [2]: assert add(3, 4) == 7

In [3]: assert add(3, 4) == 10

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

AssertionError Traceback (most recent call last)

<ipython-input-3-6731d4ac4476> in <module>()

----> 1 assert add(3, 4) == 10

AssertionError:

</pre></div>

</div>

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

This is enough to get you started.

Each of these have intricacies special to python

We’ll get to those over the next couple of classes – or really, the rest of the program!

</div>

<h2>Enough For Now<a class="headerlink" href="#enough-for-now" title="Permalink to this headline">¶</a></h2>

That’s it for our basic intro to Python

You now know enough Python to do some basic exercises in Python programming.

</div>

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

<ul>

<li><a class="reference internal" href="#">Basic Python</a><ul>

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

<li><a class="reference internal" href="#literals-for-the-basic-value-types">Literals for the Basic Value types:</a></li>

<li><a class="reference internal" href="#code-structure">Code structure</a></li>

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

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

<li><a class="reference internal" href="#symbols-and-type">Symbols and Type</a></li>

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

<li><a class="reference internal" href="#variables">Variables?</a></li>

<li><a class="reference internal" href="#in-place-assignment">In-Place Assignment</a></li>

<li><a class="reference internal" href="#multiple-assignment">Multiple Assignment</a></li>

<li><a class="reference internal" href="#nifty-python-trick">Nifty Python Trick</a></li>

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

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

<li><a class="reference internal" href="#testing-identity">Testing Identity</a></li>

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

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

<li><a class="reference internal" href="#operator-precedence">Operator Precedence</a></li>

<li><a class="reference internal" href="#python-operator-precedence">Python Operator Precedence</a></li>

<li><a class="reference internal" href="#string-literals">String Literals</a></li>

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

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

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

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

<li><a class="reference internal" href="#functions-def">Functions: <code class="docutils literal">def</code></a></li>

<li><a class="reference internal" href="#calling-functions">Calling Functions</a></li>

<li><a class="reference internal" href="#functions-call-stack">Functions: Call Stack</a></li>

<li><a class="reference internal" href="#functions-tracebacks">Functions: Tracebacks</a></li>

<li><a class="reference internal" href="#functions-return">Functions: <code class="docutils literal">return</code></a></li>

<li><a class="reference internal" href="#more-on-return">More on return</a></li>

<li><a class="reference internal" href="#functions-parameters">Functions: parameters</a></li>

<li><a class="reference internal" href="#functions-arguments">Functions: arguments</a></li>

<li><a class="reference internal" href="#making-a-decision">Making a Decision</a></li>

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

<li><a class="reference internal" href="#for-loops"><code class="docutils literal">for</code> loops</a></li>

<li><a class="reference internal" href="#range-and-for"><code class="docutils literal">range()</code> and for</a></li>

<li><a class="reference internal" href="#assert"><code class="docutils literal">assert</code></a></li>

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

<li><a class="reference internal" href="#enough-for-now">Enough For Now</a></li>

</ul>

</li>

</ul>

<h3>Related Topics</h3>

<ul>

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

<li><a href="../class_schedule/session_1_01.html">Intro to Python Session 1</a><ul>

<li>Previous: <a href="PythonOverview.html" title="previous chapter">Python Overview</a></li>

<li>Next: <a href="Py2vsPy3.html" title="next chapter">Python 2 verses Python 3</a></li>

</ul></li>

</ul>

</div>

<li><a href="../_sources/modules/BasicPython.rst.txt"

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

</ul>

</div>

<h3>Quick search</h3>

View remainder of file in raw view

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

FilesExpand file tree

BasicPython.html

Latest commit

History

BasicPython.html

File metadata and controls