Learning Python

Fabrizio Romano

• Verlag: Packt Publishing
• Jahr: 2015
• ISBN:
  9781783551712
• Auflage: 1
• Thema: Informatik
• Thema: Unternehmensanwendungen

Learn to code like a professional with Python – an open source, versatile, and powerful programming language

About This Book

• Learn the fundamentals of programming with Python – one of the best languages ever created
• Develop a strong set of programming skills that you will be able to express in any situation, on every platform, thanks to Python's portability
• Create outstanding applications of all kind, from websites to scripting, and from GUIs to data science

Who This Book Is For

Python is the most popular introductory teaching language in U.S. top computer science universities, so if you are new to software development, or maybe you have little experience, and would like to start off on the right foot, then this language and this book are what you need. Its amazing design and portability will help you become productive regardless of the environment you choose to work with.

What You Will Learn

• Get Python up and running on Windows, Mac, and Linux in no time
• Grasp the fundamental concepts of coding, along with the basics of data structures and control flow.
• Write elegant, reusable, and efficient code in any situation
• Understand when to use the functional or the object oriented programming approach
• Create bulletproof, reliable software by writing tests to support your code
• Explore examples of GUIs, scripting, data science and web applications
• Learn to be independent, capable of fetching any resource you need, as well as dig deeper

In Detail

Learning Python has a dynamic and varied nature. It reads easily and lays a good foundation for those who are interested in digging deeper. It has a practical and example-oriented approach through which both the introductory and the advanced topics are explained. Starting with the fundamentals of programming and Python, it ends by exploring very different topics, like GUIs, web apps and data science. The book takes you all the way to creating a fully fledged application.

The book begins by exploring the essentials of programming, data structures and teaches you how to manipulate them. It then moves on to controlling the flow of a program and writing reusable and error proof code. You will then explore different programming paradigms that will allow you to find the best approach to any situation, and also learn how to perform performance optimization as well as effective debugging. Throughout, the book steers you through the various types of applications, and it concludes with a complete mini website built upon all the concepts that you learned.

Style and approach

This book is an easy-to-follow guide that will take you from a novice to the proficient level at a comfortable pace, using a lot of simple but effective examples. Each topic is explained thoroughly, and pointers are left for the more inquisitive readers to dig deeper and expand their knowledge.

Learning Python

---

Table of Contents

Learning Python

Credits

About the Author

Acknowledgements

About the Reviewers

www.PacktPub.com

Support files, eBooks, discount offers, and more

Why subscribe?

Free access for Packt account holders

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Downloading the example code

Errata

Piracy

Questions

1. Introduction and First Steps – Take a Deep Breath

A proper introduction

Enter the Python

About Python

Portability

Coherence

Developer productivity

An extensive library

Software quality

Software integration

Satisfaction and enjoyment

What are the drawbacks?

Who is using Python today?

Setting up the environment

Python 2 versus Python 3 – the great debate

Installing Python

Setting up the Python interpreter

About virtualenv

Your first virtual environment

Your friend, the console

How you can run a Python program

Running Python scripts

Running the Python interactive shell

Running Python as a service

Running Python as a GUI application

How is Python code organized

How do we use modules and packages

Python's execution model

Names and namespaces

Scopes

Object and classes

Guidelines on how to write good code

The Python culture

A note on the IDEs

Summary

2. Built-in Data Types

Everything is an object

Mutable or immutable? That is the question

Numbers

Integers

Booleans

Reals

Complex numbers

Fractions and decimals

Immutable sequences

Strings and bytes

Encoding and decoding strings

Indexing and slicing strings

Tuples

Mutable sequences

Lists

Byte arrays

Set types

Mapping types – dictionaries

The collections module

Named tuples

Defaultdict

ChainMap

Final considerations

Small values caching

How to choose data structures

About indexing and slicing

About the names

Summary

3. Iterating and Making Decisions

Conditional programming

A specialized else: elif

The ternary operator

Looping

The for loop

Iterating over a range

Iterating over a sequence

Iterators and iterables

Iterating over multiple sequences

The while loop

The break and continue statements

A special else clause

Putting this all together

Example 1 – a prime generator

Example 2 – applying discounts

A quick peek at the itertools module

Infinite iterators

Iterators terminating on the shortest input sequence

Combinatoric generators

Summary

4. Functions, the Building Blocks of Code

Why use functions?

Reduce code duplication

Splitting a complex task

Hide implementation details

Improve readability

Improve traceability

Scopes and name resolution

The global and nonlocal statements

Input parameters

Argument passing

Assignment to argument names don't affect the caller

Changing a mutable affects the caller

How to specify input parameters

Positional arguments

Keyword arguments and default values

Variable positional arguments

Variable keyword arguments

Keyword-only arguments

Combining input parameters

Avoid the trap! Mutable defaults

Return values

Returning multiple values

A few useful tips

Recursive functions

Anonymous functions

Function attributes

Built-in functions

One final example

Documenting your code

Importing objects

Relative imports

Summary

5. Saving Time and Memory

map, zip, and filter

map

zip

filter

Comprehensions

Nested comprehensions

Filtering a comprehension

dict comprehensions

set comprehensions

Generators

Generator functions

Going beyond next

The yield from expression

Generator expressions

Some performance considerations

Don't overdo comprehensions and generators

Name localization

Generation behavior in built-ins

One last example

Summary

6. Advanced Concepts – OOP, Decorators, and Iterators

Decorators

A decorator factory

Object-oriented programming

The simplest Python class

Class and object namespaces

Attribute shadowing

I, me, and myself – using the self variable

Initializing an instance

OOP is about code reuse

Inheritance and composition

Accessing a base class

Multiple inheritance

Method resolution order

Static and class methods

Static methods

Class methods

Private methods and name mangling

The property decorator

Operator overloading

Polymorphism – a brief overview

Writing a custom iterator

Summary

7. Testing, Profiling, and Dealing with Exceptions

Testing your application

The anatomy of a test

Testing guidelines

Unit testing

Writing a unit test

Mock objects and patching

Assertions

A classic unit test example

Making a test fail

Interface testing

Comparing tests with and without mocks

Boundaries and granularity

A more interesting example

Test-driven development

Exceptions

Profiling Python

When to profile?

Summary

8. The Edges – GUIs and Scripts

First approach – scripting

The imports

Parsing arguments

The business logic

Second approach – a GUI application

The imports

The layout logic

The business logic

Fetching the web page

Saving the images

Alerting the user

How to improve the application?

Where do we go from here?

The tkinter.tix module

The turtle module

wxPython, PyQt, and PyGTK

The principle of least astonishment

Threading considerations

Summary

9. Data Science

IPython and Jupyter notebook

Dealing with data

Setting up the notebook

Preparing the data

Cleaning the data

Creating the DataFrame

Unpacking the campaign name

Unpacking the user data

Cleaning everything up

Saving the DataFrame to a file

Visualizing the results

Where do we go from here?

Summary

10. Web Development Done Right

What is the Web?

How does the Web work?

The Django web framework

Django design philosophy

The model layer

The view layer

The template layer

The Django URL dispatcher

Regular expressions

A regex website

Setting up Django

Starting the project

Creating users

Adding the Entry model

Customizing the admin panel

Creating the form

Writing the views

The home view

The entry list view

The form view

Tying up URLs and views

Writing the templates

The future of web development

Writing a Flask view

Building a JSON quote server in Falcon

Summary

11. Debugging and Troubleshooting

Debugging techniques

Debugging with print

Debugging with a custom function

Inspecting the traceback

Using the Python debugger

Inspecting log files

Other techniques

Profiling

Assertions

Where to find information

Troubleshooting guidelines

Using console editors

Where to inspect

Using tests to debug

Monitoring

Summary

12. Summing Up – A Complete Example ...