A Beginners Guide to Python 3 Programming

Python is a general-purpose programming language in a similar vein to other programming languages that you might have heard of such as C++, JavaScript or Microsoft’s C# and Oracle’s Java.

In this chapter we will check to see if you have Python installed on your computer. If you do not have Python installed we will step through the process of installing Python. This is necessary because when you run a Python program it looks for the python interpreter that is used to execute your program or script. Without the python interpreter installed on your machine Python programs are just text files!

In this chapter we will return to the Hello World program and look at what it is doing. We will also modify it to become more interactive and will explore the concept of Python variables.

In the previous chapter we used strings several times, both as prompts to the user and as output from the print() function. We even had the user type in their name and store it in a variable that could be used to access this name at a later point in time. In this chapter we will explore what a string is and how you can work with and manipulate them.

In this chapter we will explore the different ways that numbers can be represented by the built-in types in Python. We will also introduce the Boolean type used to represent True and False . As part of this discussion we will also look at both numeric and assignment operators in Python. We will conclude by introducing the special value known as None .

In this chapter we are going to look at the if statement in Python. This statement is used to control the flow of execution within a program based on some condition. These conditions represent some choice point that will be evaluated to True or False . To perform this evaluation it is common to use a comparison operator (for example to check to see if the temperature is greater than some threshold). In many cases these comparisons need to take into account several values and in these situations logical operators can be used to combine two or more comparison expressions together.

In this section we will look at the while loop and the for loop available in Python. These loops are used to control the repeated execution of selected statements.

In this chapter we are going to bring everything we have learned so far together to create a simple number guessing game.

Recursion is a very powerful way to implement solutions to a certain class of problems. This class of problems is one where the overall solution to a problem can be generated by breaking that overall problem down into smaller instances of the same problem. The overall result is then generated by combining together the results obtained for the smaller problems.

In the preceding chapters what we have seen is typical of the procedural approach to programming. In the next chapter we will begin to explore the definition of functions which allow a more modular style of programming.

As discussed in the last chapter; when you build an application of any size you will want to break it down into more manageable units; these units can then be worked on separately, tested and maintained separately. One way in which these units can be defined is as Python functions.

We have already defined several variables in the examples we have being working with in this book. In practice, most of these variables have been what are known as global variables. That is there are (potentially) accessible anywhere (or globally) in our programs.

In this chapter we will step through the development of another Python program; this time the program will be to provide a simple calculator which can be used to add, subtract, multiple and divide numbers. The implementation of the calculator is base on the Function Decomposition performed earlier in the book in the Introduction to Structured Analysis chapter.

There has been much hype around Functional Programming in recent years. However, Functional Programming is not a new idea and indeed goes right back to the 1950s and the programming language LISP. However, many people are not clear as to what Functional Programming is and instead jump into code examples and never really understand some of the key ideas associated with Functional Programming such as Referential Transparency.

In this chapter we will explore the concept of high-order functions. These are functions that take as a parameter, or return (or both), a function. To do this we will first look into how Python represents functions in memory and explore what actually happens when we execute a Python function.

Currying is a technique which allows new functions to be created from existing functions by binding one or more parameters to a specific value. It is a major source of reuse of functions in Python which means that functionality can be written once, in one place and then reused in multiple other situations.

This chapter introduces the core concepts in Object Orientation. It defines the terminology used and attempts to clarify issues associated with objects. It also discusses some of the perceived strengths and weaknesses of the object-oriented approach. It then offers some guidance on the approach to take in learning about objects.

In Python everything is an object and as such is an example of a type or class of things. For example, integers are an example of the int class, real numbers are examples of the float class etc.

Python classes can hold data and behaviour that is not part of an instance or object; instead they are part of the class.

Inheritance is a core feature of Object-Oriented Programming. It allows one class to inherit data or behaviour from another class and is one of the key ways in which reuse is enabled within classes.

The pervious four chapters have introduced the basic concepts behind object orientation, the terminology and explored some of the motivation. This chapter looks at how object orientation addresses some of the issues that have been raised with procedural languages. To do this it looks at how a small extract of a program might be written in a language such as C, considers the problems faced by the C developer and then looks at how the same functionality might be achieved in an object-oriented language such as Python. Do not worry too much about the syntax you will be presented with; it is mostly a form of pseudo code and it should not detract from the legibility of the examples.

We will explore Operator Overloading in this chapter; what it is, how it works and why we want it.

Many object-oriented languages have the explicit concept of encapsulation; that is the ability to hide data within an object and only to provide specific gateways into that data. These gateways are methods defined to get or set the value of an attribute (often referred to as getters and setters). This allows more control over access to the data; for example, it is possible to check that only a positive integer above zero, but below 120, is used for a person’s age etc.

This chapter considers exception and error handling and how it is implemented in Python. You are introduced to the object model of exception handling, to the throwing and catching of exceptions, and how to define new exceptions and exception-specific constructs.

Modules and packages are two constructs used in Python to organise larger programs. This chapter introduces modules in Python, how they are accessed, how they are define and how Python finds modules etc. It also explores Python packages and sub-packages.

This chapter presents Abstract Base Classes (also known as ABCs) which were originally introduced in Python 2.6.

In this chapter we will explore the idea of an implicit contract between an object and the code that uses that object. As part of this discussion we will explore what is meant by Duck Typing. Following this we will introduce the Python concept called a protocol. We will explore its role within Python programming and look at two commonly occurring protocols; the Context Manager Protocol and the Descriptor Protocol.

Monkey Patching is a term you might well come across when looking into the Python further or when searching the web for Python related concepts. It relates to the ability in Python to extend the functionality associated with a class/type at runtime.

The idea behind Decorators comes from the Gang of Four Design Patterns book (so-called as there were four people involved in defining these design patterns).

There are two protocols that you are very likely to use, or will possibly need to implement at some point or other; these are the Iterable protocol and the Iterator protocols. These two closely related protocols are very widely used and supported by a large number of types.

Earlier in this book we looked at some Python built-in types such as string , int and float as well as bools .

In the last chapter we looked at Tuples and Lists; in this chapter we will look at a further container (or collection) types; the Set type.

A Dictionary is a set of associations between a key and a value that is unordered, changeable (mutable) and indexed. Pictorially we might view a Dictionary as shown below for a set of countries and their capital cities. Note that in a Dictionary the keys must be unique but the values do not need to be unique.

The chapter introduces a feature known as a list comprehension in Python.

There are a number of common data structures that are used within computer programs that you might expect to see within Python’s list of collection or container classes; these include Queues and Stacks. However, in the basic collection classes these are missing.

Python provides three functions that are widely used to implement functional programming style solutions in combination with collection container types. These functions are what are known as higher-order functions that take both a collection and a function that will be applied in various ways to that collection.

In this chapter we will explore the creation of a simple TicTacToe (or Noughts and Crosses) game using an Object Oriented approach.

The updated version of this chapter