Practical programming : an introduction to computer science using Python 3.6 / Paul Gries, Jennifer Campbell, Jason Montojo ; edited by Tammy Coron.

Format:

Book

Author/Creator:

Gries, Paul, author.

Campbell, Jennifer (Newspaper editor), author.

Montojo, Jason, author.

Contributor:

Coron, Tammy, editor.

Series:

Pragmatic programmers.

The Pragmatic Programmers

Language:

English

Subjects (All):

Python (Computer program language).

Computer programming.

Physical Description:

1 online resource (394 pages) : illustrations (some color).

Edition:

Third edition.

Other Title:

Introduction to computer science using Python 3.6

Place of Publication:

Raleigh, North Carolina : The Pragmatic Bookshelf, 2017.

System Details:

text file

Summary:

Classroom-tested by tens of thousands of students, this new edition of the bestselling intro to programming book is for anyone who wants to understand computer science. Learn about design, algorithms, testing, and debugging. Discover the fundamentals of programming with Python 3.6--a language that's used in millions of devices. Write programs to solve real-world problems, and come away with everything you need to produce quality code. This edition has been updated to use the new language features in Python 3.6. No programming experience required! Incremental examples show you the steps and missteps that happen while developing programs, so you know what to expect when you tackle a problem on your own. Inspired by "How to Design Programs" (HtDP), discover a five-step recipe for designing functions, which helps you learn the concepts--and becomes an integral part of writing programs. In this detailed introduction to Python and to computer programming, find out exactly what happens when your programs are executed. Work with numbers, text, big data sets, and files using real-world examples. Create and use your own data types. Make your programs reliable, work with databases, download data from the web automatically, and build user interfaces. As you use the fundamental programming tools in this book, you'll see how to document and organize your code so that you and other programmers can more easily read and understand it. This new edition takes advantage of Python 3.6's new features, including type annotations on parameters, return types and variable declarations, and changes to string formatting. Most importantly, you'll learn how to think like a professional programmer. What You Need: You'll need to download Python 3.6, available from https://python.org.With that download comes IDLE, the editor we use for writing andrunning Python programs. (If you use Linux, you may need to installPython 3.6 and IDLE separately.)

Contents:

Cover

Table of Contents

Acknowledgments

Preface

Online Resources

1. What's Programming?

Programs and Programming

What's a Programming Language?

What's a Bug?

The Difference Between Brackets, Braces, and Parentheses

Installing Python

2. Hello, Python

How Does a Computer Run a Python Program?

Expressions and Values: Arithmetic in Python

What Is a Type?

Variables and Computer Memory: Remembering Values

How Python Tells You Something Went Wrong

A Single Statement That Spans Multiple Lines

Describing Code

Making Code Readable

The Object of This Chapter

Exercises

3. Designing and Using Functions

Functions That Python Provides

Memory Addresses: How Python Keeps Track of Values

Defining Our Own Functions

Using Local Variables for Temporary Storage

Tracing Function Calls in the Memory Model

Designing New Functions: A Recipe

Writing and Running a Program

Omitting a return Statement: None

Dealing with Situations That Your Code Doesn't Handle

What Did You Call That?

4. Working with Text

Creating Strings of Characters

Using Special Characters in Strings

Creating a Multiline String

Printing Information

Getting Information from the Keyboard

Quotes About Strings

5. Making Choices

A Boolean Type

Choosing Which Statements to Execute

Nested if Statements

Remembering Results of a Boolean Expression Evaluation

You Learned About Booleans: True or False?

6. A Modular Approach to Program Organization

Importing Modules

Defining Your Own Modules

Testing Your Code Semiautomatically

Tips for Grouping Your Functions

Organizing Our Thoughts

7. Using Methods

Modules, Classes, and Methods

Calling Methods the Object-Oriented Way

Exploring String Methods.

What Are Those Underscores?

A Methodical Review

8. Storing Collections of Data Using Lists

Storing and Accessing Data in Lists

Type Annotations for Lists

Modifying Lists

Operations on Lists

Slicing Lists

Aliasing: What's in a Name?

List Methods

Working with a List of Lists

A Summary List

9. Repeating Code Using Loops

Processing Items in a List

Processing Characters in Strings

Looping Over a Range of Numbers

Processing Lists Using Indices

Nesting Loops in Loops

Looping Until a Condition Is Reached

Repetition Based on User Input

Controlling Loops Using break and continue

Repeating What You've Learned

10. Reading and Writing Files

What Kinds of Files Are There?

Opening a File

Techniques for Reading Files

Files over the Internet

Writing Files

Writing Example Calls Using StringIO

Writing Algorithms That Use the File-Reading Techniques

Multiline Records

Looking Ahead

Notes to File Away

11. Storing Data Using Other Collection Types

Storing Data Using Sets

Storing Data Using Tuples

Storing Data Using Dictionaries

Inverting a Dictionary

Using the in Operator on Tuples, Sets, and Dictionaries

Comparing Collections

Creating New Type Annotations

A Collection of New Information

12. Designing Algorithms

Searching for the Two Smallest Values

Timing the Functions

At a Minimum, You Saw This

13. Searching and Sorting

Searching a List

Binary Search

Sorting

More Efficient Sorting Algorithms

Merge Sort: A Faster Sorting Algorithm

Sorting Out What You Learned

14. Object-Oriented Programming

Understanding a Problem Domain

Function isinstance, Class object, and Class Book

Writing a Method in Class Book.

Plugging into Python Syntax: More Special Methods

A Little Bit of OO Theory

A Case Study: Molecules, Atoms, and PDB Files

Classifying What You've Learned

15. Testing and Debugging

Why Do You Need to Test?

Case Study: Testing above_freezing

Case Study: Testing running_sum

Choosing Test Cases

Hunting Bugs

Bugs We've Put in Your Ear

16. Creating Graphical User Interfaces

Using Module tkinter

Building a Basic GUI

Models, Views, and Controllers, Oh My!

Customizing the Visual Style

Introducing a Few More Widgets

Object-Oriented GUIs

Keeping the Concepts from Being a GUI Mess

17. Databases

Overview

Creating and Populating

Retrieving Data

Updating and Deleting

Using NULL for Missing Data

Using Joins to Combine Tables

Keys and Constraints

Advanced Features

Some Data Based On What You Learned

Bibliography

Index

- SYMBOLS -

- A -

- B -

- C -

- D -

- E -

- F -

- G -

- H -

- I -

- J -

- K -

- L -

- M -

- N -

- O -

- P -

- Q -

- R -

- S -

- T -

- U -

- V -

- W -

- Z -.

Notes:

Place of publication from publisher's website.

Includes bibliographical references and index.

Description based on online resource; title from PDF title page (EBC, viewed March 14, 2018).

ISBN:

9781680503036

1680503030

9781680504132

1680504134

9781680504125

1680504126

9781680502688

1680502689

OCLC:

1023657947