Jones - Python for complete beginners: A friendly guide to coding, no experience required

Table of Contents

Introduction and environment

Welcome to Python

This book is an introduction to the Python programming language for complete beginners those who have never written a program before, or who are just getting started with programming. Learning your first programming language is tricky, because you have to simultaneously learn about basic programming concepts and about the specifics of the language. Fortunately, Python is an excellent choice as a first language, for reasons we'll discuss below.

The goal of this book is to start with the absolute basics and get you to the point where you can confidently write your own programs from scratch. It will also give you the background to be able to seek out and understand more information on Python when you need it.

This introductory chapter contains important background information to help you get the most out of the book, so read it carefully. If you already have a system for writing and running Python programs, then feel free to skip the Setting up your environment section.

Why Python?

People who are new to programming tend to worry a lot about which language to learn. The choice of programming language does matter, of course, but it matters far less than people think it does. To put it another way, choosing the "wrong" programming language is very unlikely to mean the difference between failure and success when learning. Other factors (motivation, having time to devote to learning, helpful colleagues) are far more important, yet receive less attention.

The reason that people place so much weight on the "what language should I learn?" question is that it's a big, obvious question, and it's not difficult to find people who will give you strong opinions on the subject. It's also the first big question that beginners have to answer once they've decided to learn programming, so it assumes a great deal of importance in their minds.

There are a couple of reasons why choice of programming language is not as important as most people think it is. Firstly, nearly everybody who spends any significant amount of time programming will eventually end up using multiple languages. Partly this is just down to the simple constraints of various languages if you want to write a web application you'll probably do it in Javascript, if you want to write a graphical user interface you'll probably use something like Java, and if you want to write low level algorithms you'll probably use C.

Secondly, learning a first programming language gets you 90% of the way towards learning a second, third, and fourth one. Learning to think like a programmer is largely a matter of learning to break down complex tasks into simple ones, and is a skill that cuts across all languages. So if you spend a few months learning Python and then discover that you really need to write in C, your time won't have been wasted as you'll be able to pick it up much quicker.

Having said all that, when learning to program we do need to pick a language to work in, so we should pick the one that will make the job of learning easiest. For most people, Python is that language. Here's why:

• It has a mostly consistent syntax, so you can generally learn one way of doing things and then apply it in multiple places
• It has a sensible set of built in libraries for doing lots of common tasks
• It is designed in such a way that there's an obvious way of doing most things
• It's one of the most widely used languages in the world, and there's a lot of advice, documentation and tutorials available on the web
• It's designed in a way that lets you start to write useful programs as soon as possible
• Its use of indentation, while annoying to people who aren't used to it, is great for beginners as it enforces a certain amount of readability

Another reason for choosing Python is that it's an extremely flexible language that's suitable for writing all sorts of programs. Python can be used for games, web applications, data analysis programs, graphical interfaces, home automation programs, and all sorts of other tasks. In other words, whatever type of program you're interested in writing, Python will probably be suitable.

How to use this book

Programming books generally fall into two categories; reference type books, which are designed for looking up specific bits of information, and tutorial type books, which are designed to be read cover to cover. This book is an example of the latter code samples in later chapters often use material from previous ones, so you need to make sure you read the chapters in order. Exercises or examples from one chapter are sometimes used to illustrate the need for features that are introduced in the next.

There are a number of fundamental programming concepts that are relevant to material in multiple different chapters. In this book, rather than introduce these concepts all in one go, I've tried to explain them as they become necessary. This results in a tendency for earlier chapters to be longer than later ones, as they involve the introduction of more new concepts.

A certain amount of jargon is necessary if we want to talk about programs and programming concepts. I've tried to define each new technical term at the point where it's introduced, and then use it thereafter with occasional reminders of the meaning.

Chapters tend to follow a predictable structure. They generally start with a few paragraphs outlining the motivation behind the features that it will cover why do they exist and what problems do they allow us to solve? These are followed by the main body of the chapter in which we discuss the relevant features and how to use them. The length of the chapters varies quite a lot sometimes we want to cover a topic briefly, other times we need more depth. This section ends with a brief recap outlining what we have learned, followed by exercises and solutions (more on that topic below).

Formatting

A book like this has lots of special types of text we'll need to look at examples of Python code and output, the contents of files, and technical terms. Take a minute to note the typographic conventions we'll be using:

In the main text of this book, bold type is used to emphasize important points and italics for technical terms and file names. Where code is mixed in with normal text it's written in a monospaced font like this . Example Python code is indented and written in a monospaced font like this:

Some example code goes here

Some of the Python code examples have matching example files which you can download (the download instructions are later in this chapter). For these, the example filename is written on the right directly underneath the code example like this:

Some example code goes here

example.py

Not every bit of code has a matching example file much of the time we'll be building up a Python program bit by bit, in which case there will be a single example file containing the finished version of the program. The example files are in separate folders, one for each chapter, to make them easy to find.

Sometimes it's useful to refer to a specific line of code inside an example. For this, we'll use subscript like this:

a line of example code

other line of example code

this is the important line

here is another line

Example output (i.e. what we see on the screen when we run the code) is in monospaced font, but is not indented:

Some output goes here

Often we want to look at the code and the output it produces together. In these situations, you'll see an indented code block followed immediately by a non-indented output block.

Other blocks of text (usually file contents) look the same as Python output - it will be clear from the text which were looking at.

Often when looking at larger examples, or when looking at large amounts of output, we don't need to see the whole thing. In these cases, I'll use ellipses (...) to indicate that some text has been missed out.