Concept of Programming

A programming language is a language, with its own words and rules, in which we write instructions that tell a computer what to do and how to do it. Python, Java, C++, JavaScript and PHP are popular programming languages.

• Programming is the process of writing those instructions, step by step, so that a computer does a particular job. The instructions together are a program, and the text of a program is its code.
• A programmer is a person who writes programs.
• Syntax is the set of rules for writing the instructions of a language correctly: which words to use, in what order, with which brackets, colons and quotes. Just as “rice eat I” breaks the grammar of English, print "Hello" breaks Python’s syntax: Python needs brackets, print("Hello"). A computer is far stricter than a reader: one wrong symbol, and the program won’t run.

High-level and low-level languages

There are two main types of programming language, depending on how close they are to people or to the machine.

A program written in a high-level language is called source code: people can read it, but a processor can’t. Before it can run (be executed), it must be converted into low-level machine code. Programs called language translators do this: compilers, interpreters and assemblers, which you meet below.

Before a builder in Bhaktapur lays a single brick, someone draws the house on paper. Before writing a program, a programmer plans it too. Two tools help: an algorithm, the steps written in words, and a flowchart, the same steps drawn as a diagram. Both help you work out the logic of a solution before you worry about any language’s syntax, and a plan in either can be turned into a program in any language.

Algorithm

An algorithm is a set of step-by-step instructions for solving a particular problem or doing a particular task. It is like a recipe: a recipe lists the steps for making a dish, in order; an algorithm lists the steps a computer must follow.

• It begins with Start and ends with Stop.
• Its steps are numbered, in the order they are done, and each step is clear and does one thing.
• It is written in simple, everyday language, not in any programming language.
• It must end after a limited number of steps, and give the right result.

Here is an algorithm to find the area of a rectangle:

Step 1: StartStep 2: Read the length (l) and the breadth (b)Step 3: area = l × bStep 4: Display areaStep 5: Stop

Flowchart

A flowchart is a pictorial (graphical) representation of an algorithm. Each kind of step has its own shape, and flow lines (arrows) show which step comes next. A flowchart shows the whole logic at a glance: where the program decides between two ways, and where it goes back to repeat.

A few rules make a flowchart easy to follow: it has exactly one Start and at least one Stop; flow goes from top to bottom (or left to right); every shape except Stop has an arrow out; a decision has two arrows out, labeled Yes and No; and lines should not cross.

Once the plan is ready, a program is made in three steps, again and again until it works:

1. Coding: writing the instructions in a programming language. The instructions are called code, and they tell the computer exactly what to do.
2. Testing: running the program to check that it does what it should, with different inputs, including unusual ones (a zero, a negative number, a very big number, letters where a number is expected), to find any bugs (mistakes).
3. Debugging: finding where a bug is in the code, understanding why it happens, and correcting it. Then test again.

These three steps make software that is reliable and runs smoothly. Programmers often spend more time testing and debugging than writing new code.

Bugs come in three kinds:

A logical error is the hardest to find, because nothing warns you: only testing with numbers whose answer you already know shows it up. Try the last one: the average of 4 and 8 should be 6.

a = 4b = 8average = a + b / 2print(average)

8.0

Python divides before it adds, so this works out 4 + 8 ÷ 2 = 4 + 4 = 8. Press Edit, put brackets round a + b, and run it again.

Imagine two friends: one speaks only Nepali, the other only Sanskrit. To chat, they need someone who knows both languages to translate. A programmer speaks Python or C; the processor speaks only machine code. Compilers and interpreters are the translators between them.

Compiler

A compiler is a translator program that converts the whole of a high-level program into machine code in one go, before any of it runs. If the program has errors, the compiler reports the errors it finds together, after reading the whole program, and no machine code is made. If there are none, it writes a separate file of machine code (on Windows, an .exe file), which then runs by itself, as many times as you like, with no more translating; it doesn’t even need the compiler or the source code any more.

Languages that are usually compiled include C, C++, C#, FORTRAN, COBOL and Go. Examples of compilers are the GNU Compiler Collection (GCC), which compiles C, C++ and FORTRAN, and Microsoft Visual C++, the compiler inside the Microsoft Visual Studio programming tool. (Java is compiled too, by javac, into a code of its own, which the Java Virtual Machine then runs.)

Interpreter

Imagine telling a friend how to cook a dish in a language they only partly know. You explain one step, they do it; you explain the next, they do that. An interpreter works the same way: it takes one line (instruction) of the program, translates it, runs it at once, and then moves on to the next line. It makes no separate machine-code file, so the program is translated again every time it runs.

This is slower than running a compiled program, but it is handy while writing and testing: you can change a line and run it again at once, and when the interpreter meets an error it stops right at that line and tells you, after the lines before it have already run. An interpreted program is also portable: the same program runs on any kind of computer that has the interpreter, without being compiled again for each kind of processor.

Languages that are usually interpreted include Python, JavaScript, Ruby, LISP and MATLAB. Their interpreters are programs too: the standard Python interpreter (called CPython) from python.org, and the JavaScript engine inside every web browser. QBASIC, which many Nepali schools used to teach, was an interpreted language; today Python and JavaScript are the most widely used ones.

Both translate a high-level language (friendly to people) into a low-level one (the 0s and 1s a processor understands), so that a computer can carry out a program written by a person. They differ in how they do it:

Python is a high-level programming language created by Guido van Rossum and first released in 1991. It has become one of the most popular languages in the world because it is simple and can do so much: with Python you can solve maths problems, sort data, control robots and even make your own games. Its code reads almost like English, which makes it a good first language, and it comes with a large set of ready-made tools (libraries), so a programmer doesn’t have to start from scratch every time.

Python is used in web development, data science and data analysis, machine learning and artificial intelligence, automating everyday jobs (scripts), game development, collecting data from websites (web scraping) and cyber security. Instagram, Spotify and Netflix use it, and NASA’s scientists use it to study pictures from space.

Python’s code is easy to read partly because it uses indentation (spaces at the start of a line) instead of curly braces { } to group lines together. The lines that belong to a loop or an if are indented, usually by four spaces, and the indentation itself shows where the group (the block) begins and ends:

if marks >= 40:    print("Pass")          # indented: inside the if    print("Well done!")    # indented: inside the ifprint("Result checked")    # not indented: after the if, always runs

Many languages ask programmers to indent neatly; Python makes it a rule, so every Python program is laid out the same clear way.

Features of Python

• Easy to read and write: its simple syntax, close to English, makes code easy to write and to understand later.
• Versatile: one language for many jobs, from small scripts that automate a task to websites, data analysis and artificial intelligence.
• Beginner-friendly: short programs do useful things, and its error messages point to the line that went wrong.
• Extensive standard library: it comes with a large library of ready-made code (for maths, dates, files, random numbers and much more), so you don’t write everything from the ground up.
• Rich ecosystem: beyond the standard library there are hundreds of thousands of free packages and frameworks (ready-made structures for building something bigger, such as a website), made by Python’s community.
• Free and open source: anyone may download, use and share it, on Windows, macOS, Linux and even phones.
• Interpreted: a program runs as soon as you write it, with no separate compiling step.

Installing Python

You can write Python on a computer of your own, or with no installing at all, on this page or on an online Python site.

1. Download the installer. Visit the official website, python.org/downloads. It detects your operating system and offers the right installer (for Windows, the 64-bit one on almost every computer today). Download the latest Python 3.
2. Run the installer. Find the downloaded file (usually in your Downloads folder) and double-click it. On Windows, tick Add python.exe to PATH on the first screen, so that other programs can find Python.
3. Install. Click Install Now (or choose your own settings under Customize installation). It takes a few minutes.
4. Get an editor (IDE). Python comes with a simple one, IDLE. Many programmers use a bigger integrated development environment (IDE), a program for writing, running and debugging code in one window, such as Thonny (made for beginners) or Visual Studio Code.

In IDLE, the window with the >>> prompt is the Python shell: type one line, press Enter, and it runs at once. For a whole program, choose File → New File, type the program, save it with a name ending in .py, and press F5 (Run → Run Module). The output appears in the shell.

>>> 2 + 35>>> print("Namaste")Namaste

Comments in Python

A comment is a note that a programmer writes in the code to explain what it does, like a helpful hint for whoever reads it next (often yourself, months later). The Python interpreter ignores comments: they don’t change what the program does.

Single-line comments. A comment starts with the # sign and goes on to the end of the line. It can have a line to itself, or come after code on the same line. A longer note simply takes several lines, each starting with #. Programmers usually put one space after the #, which makes it easier to read.

# This is an example of a single-line comment.print("Nepal has great cultural diversity.")

Nepal has great cultural diversity.

# This program prints what is special about Nepal.# Each line of a longer note starts with its own # sign.print("Nepal is famous for adventure tourism.")   # a comment after code

Nepal is famous for adventure tourism.

Multi-line comments. For a long note, typing # on every line is tiresome. Python lets you put the note between three quotes, ''' (or """), at its beginning and end, and it may run over many lines:

'''This is an example of a multi-line comment.This program prints what is special about Nepal.'''print("Nepal is home to many ethnic groups, languages and traditions.")

Nepal is home to many ethnic groups, languages and traditions.

Keywords

In programming, keywords are words that are reserved: the language has given each one a fixed meaning. if, else, for, while, True and import are keywords in Python. Because they already mean something, a keyword can’t be used as an identifier, the name of a variable or function: if = 5 is a syntax error.

Python 3 has 35 keywords. You will meet the ones in bold in this unit:

Keywords are written in small letters, except True, False and None, and spelling matters: True is a keyword, but true is not. Python can list them for you:

import keywordprint(len(keyword.kwlist))print(keyword.kwlist)

35['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

print, input and int are not keywords but the names of built-in functions; it is allowed, but a bad idea, to use them as variable names, since the function is then lost for the rest of the program.

Input/output (I/O) statements let a program talk with its user: input gives the program data and instructions, and output shows the results on the screen. In Python, input() takes input and print() gives output. String formatting puts values neatly into the text a program prints.

The print() function

print() displays on the screen whatever you put inside its brackets: text in quotes, numbers, variables or calculations. Things separated by commas are printed with one space between them, and each print() ends by moving to a new line.

print("Hello, Python!")print("The answer is", 6 * 7)

Hello, Python!The answer is 42

Two optional settings change this: sep sets what goes between the things, and end sets what comes at the end instead of a new line.

print("2082", "06", "15", sep="-")print("Kathmandu", end=" → ")print("Pokhara")

2082-06-15Kathmandu → Pokhara

The input() function

input() shows a message (the prompt), waits for the user to type something and press Enter, and gives back what was typed. Store it in a variable to use it later:

name = input("What is your name? ")print("Namaste,", name)

What is your name? TashiNamaste, Tashi

(Press Run, and the page asks you for your own answer.)

String formatting

String formatting is like filling in a form: you write a message with blanks, and Python fills each blank with a value, such as a name or a number. Python has three ways to do it.

1. Old-style formatting, with %. Python’s oldest way: %s is a blank for a string and %d for a whole number (%f for a decimal), and the values come after a % sign, in brackets, in order.

name = "Phulmaya"age = 15print("My name is %s and I am %d years old." % (name, age))

My name is Phulmaya and I am 15 years old.

2. New-style formatting, with str.format(). Each blank is a pair of curly braces {}, and the values go in .format() after the string, in order. ({0}, {1}… pick a value by its position.)

name = "Abdul"age = 16print("My name is {} and I am {} years old.".format(name, age))

My name is Abdul and I am 16 years old.

3. Formatted string literals (f-strings). The newest way, and the one most used today: put an f before the opening quote, and write the variables, or any expression, straight inside the curly braces.

name = "Lhamu"age = 14print(f"My name is {name} and I am {age} years old.")print(f"Next year I will be {age + 1}.")

My name is Lhamu and I am 14 years old.Next year I will be 15.

f-strings are easiest to read, because each value sits where it will appear. Use them in your own programs.

In your kitchen, rice goes in one jar, oil in a bottle and salt in a small tin: each kind of thing is kept in its own kind of container, because you use it differently. A program sorts its data the same way. A number can be added to another number; a name can’t be. The kind of a piece of data is its data type: data classified by its nature.

A few things to notice:

• "42" in quotes is a string, not a number: Python treats it as two characters, 4 and 2.
• True and False start with capital letters and have no quotes. A comparison such as 5 > 3 gives a Boolean: True.
• type() tells you the type of any value:

print(type(42))print(type(3.14))print(type("Namaste"))print(type(True))

<class 'int'><class 'float'><class 'str'><class 'bool'>

Identifiers

An identifier is a name a programmer gives to something in a program: a variable, a function, a class or another item. Identifiers aren’t built into the language; programmers make them up. But they must follow these rules:

1. An identifier must start with a letter or the underscore character _.
2. It can’t start with a digit (number).
3. It may contain only letters, digits and underscores (A–Z, a–z, 0–9 and _): no spaces, and no other symbols such as -, @ or ..
4. It is case-sensitive: age, Age and AGE are three different identifiers.
5. It can’t be a Python keyword.

int and print are not keywords, so Python will accept them as names, but they are names Python already uses for its own functions; using them hides those functions, so treat them as forbidden too. Good identifiers say what they hold: total_marks is better than tm or x.

Variables

A variable is a named place in the computer’s memory that holds a value, like a labeled box: the label is the variable’s name, and what is inside is its value. Python has no command for declaring a variable: a variable is created the moment a value is assigned (given) to it with =.

a = 15print(a)a = 20          # the box now holds 20; 15 is goneprint(a)

1520

The value can change while the program runs, which is why it is called a variable. A variable gets its type from the value put in it:

Type casting

Imagine a bakery in Butwal that takes cake orders through a website. Every order arrives as text: “3” cakes, “2.5” kilograms. To add up the orders and work out the bill, the program must turn that text into numbers. Changing a value from one data type into another is type casting (or type conversion). There are two kinds.

Implicit type casting (automatic type conversion): Python converts a value automatically, by itself, when an expression needs it. Add a whole number to a decimal number, and Python first turns the integer into a float, so no information is lost:

x = 10        # integery = 5.5       # floatz = x + y     # x is converted to the float 10.0 for the additionprint(z)print(type(z))

15.5<class 'float'>

Explicit type casting: the programmer converts a value on purpose, with a function named after the type it should become:

• int(x) converts x to an integer. From a float it drops the decimal part (it doesn’t round): int(4.9) is 4. From a string, the string must be a whole number: int("25") is 25, but int("2.5") and int("twenty") are errors.
• float(x) converts x to a float: float(4) is 4.0, float("3.14") is 3.14.
• str(x) converts x to a string: str(11) is "11".

A conversion makes a new value; it doesn’t change the variable unless you store the new value in it:

x = 4.5x = int(x)          # cast x to int, and store it back in xprint(x) y = 4y = float(y)        # cast y to floatprint(y) z = 11z = str(z)          # cast z to stringprint(z + "1")      # joining strings: "11" + "1"

44.0111

The last line shows why the type matters: 11 + 1 would be 12, but "11" + "1" joins two strings into "111".

Operators are special symbols that do something with values: add them, compare them, combine conditions or store a result. They are the tools in a programmer’s toolbox. The values an operator works on are its operands. Python’s main kinds are arithmetic, relational (comparison), logical and assignment operators.

Arithmetic operators

Arithmetic operators do mathematics.

% and // are more useful than they look: n % 2 is 0 exactly when n is even, n % 10 is the last digit of n, and n // 10 is n with its last digit removed. You will use all three in the practice programs.

Python works out ** first, then *, /, // and %, then + and -, as in maths; brackets come before everything.

print(17 / 5, 17 // 5, 17 % 5)print(2 ** 10)print(2 + 3 * 4, (2 + 3) * 4)

3.4 3 2102414 20

Relational operators

Relational operators (comparison operators) compare two values and give a Boolean: True if the relationship holds, False if it doesn’t.

Logical operators

Logical operators combine conditions, so a program can decide on more than one thing at once. Python has three: and, or and not.

• and: the result is True only if both conditions are True. (5 < 2) and (5 > 3) is False, because 5 < 2 is False.
• or: the result is True if at least one condition is True. (5 < 2) or (5 > 3) is True, because 5 > 3 is True.
• not: gives the opposite of a condition. not (5 < 2) is True.

A truth table lists every combination; 1 stands for True and 0 for False.

(In books, not A is also written Ā, with a bar over the A.)

print((5 < 2) and (5 > 3))print((5 < 2) or (5 > 3))print(not (5 < 2))age = 15print(age >= 13 and age <= 19)     # a teenager?

FalseTrueTrueTrue

Assignment operators

Assignment operators store a value in a variable. = is the plain one; the others do a calculation with the variable’s own value and store the result back, a short way of writing it.

In a kitchen we put salt, sugar, spices and turmeric in different containers and label each one, so we know what is inside. The assignment operator = is the labeling machine: in my_age = 15 it puts 15 in the box named my_age, and whenever the program uses my_age it opens the box and finds 15.

a = 10      # assign 10 to ab = 5       # assign 5 to ba += b      # a = a + b, so a becomes 15print(a)

15

Expressions and operands

An expression is a combination of values, variables and operators that Python works out to produce a value, like a formula. 5 + 3 is an expression (its value is 8); so is marks >= 40 (its value is True or False).

result = 5 + 3                     # a maths expression: 8greeting = "Namaste" + " Nepal"    # a text expression: joins two stringscombined = str(5 * 3) + " Python"  # 5 * 3 is 15; str() makes it text so it can joinprint(result)print(greeting)print(combined)

8Namaste Nepal15 Python

A number and a string can’t be added directly: (5 * 3) + "Python" is an error (a TypeError), which is why the number is converted with str() first.

Formulas from maths are written in Python with its own operators:

Notice that Python always needs the *: in maths, ab means a × b, but in Python ab is just a variable’s name.

Operands are the values or variables that an operator works on. In add = 5 + 3, the operator is + and the operands are 5 and 3.

Every morning you decide: if it is raining, take an umbrella; otherwise, don’t. A program decides the same way. A conditional statement is a decision-making statement: it checks a condition (something True or False) and chooses which code to run. Python has three forms: if, if-else and if-elif-else, and one if can sit inside another (a nested if).

The condition ends with a colon :, and the code to run when it is True is indented under it. Python’s indentation rule decides which lines belong to the if.

if statement

The if statement runs its block only when the condition is True; when it is False, the block is skipped and the program carries on after it.

if condition:    # statements run when the condition is True

# Check whether a number is positivenumber = int(input("Enter a number: "))if number > 0:    print("The number is positive.")

Enter a number: 25The number is positive.

Run it again with −4: the condition is False, line 4 is skipped, and the program prints nothing at all.

if-else statement

The if-else statement chooses between two blocks: the if block when the condition is True, the else block when it is False. Exactly one of them runs, every time. else has no condition of its own.

if condition:    # statements run when the condition is Trueelse:    # statements run when the condition is False

# Ask the user's age and give the resultuser_age = int(input("How old are you? "))if user_age >= 18:    print("You are an adult!")else:    print("You are a teenager or a kid.")

How old are you? 14You are a teenager or a kid.

if-elif-else statement

For more than two choices, add elif (short for “else if”) branches between the if and the else. Python checks the conditions from the top, one by one, runs the block of the first one that is True, and skips all the rest. If none is True, the else block runs. There can be as many elifs as you need; the else is optional.

if condition1:    # run if condition1 is Trueelif condition2:    # run if condition1 is False and condition2 is Trueelse:    # run if condition1 and condition2 are both False

Nested if

A nested if is an if statement inside another if (or else) block. The inner condition is checked only when the outer one has let the program in. It is used to test several conditions one after another, and gives more possible outcomes.

if condition1:    # run if condition1 is True    if condition2:        # run if condition1 and condition2 are both True    else:        # run if condition1 is True but condition2 is Falseelse:    # run if condition1 is False

In Nepal you can get your citizenship certificate at 16 and vote at 18. The program checks age 16 first; only for someone 16 or over does it go on to ask about 18:

age = int(input("Enter your age: "))if age >= 16:    print("You are eligible for citizenship.")    if age >= 18:        print("You are eligible to cast a vote.")    else:        print("You are not eligible to cast a vote yet.")else:    print("You are a minor.")

Enter your age: 17You are eligible for citizenship.You are not eligible to cast a vote yet.

Iteration means doing something again and again: repeating a set of instructions a given number of times, or until a condition is met. Without it, printing the numbers 1 to 100 would need 100 print lines; with a loop it needs two. Loops make programs shorter and save the programmer from writing the same code repeatedly. Python has two loops: the for loop and the while loop.

for loop

A for loop repeats a block once for each item in a sequence (it iterates over the sequence): each number in a range, each letter of a string, each item of a list. It is used when we know how many times to repeat. The for keyword names a variable that takes each item in turn:

for item in sequence:    # code that does something with each item

for x in range(5):    print("Jump!")

Jump!Jump!Jump!Jump!Jump!

range() gives a sequence of whole numbers. By default it counts from 0 and goes up by 1, and it always stops before the number it is given:

So range(5) gives five numbers, and the loop above runs five times. The variable x takes the values 0 to 4; this loop doesn’t use it, but it could: print(x).

A for loop can go over a string, one character at a time, too:

for letter in "Nepal":    print(letter)

Nepal

pass, continue and break

pass is a statement that does nothing. Python needs at least one statement in every block; pass holds the place where code is required but no action is wanted (or where you will write the code later).

marks = 75if marks >= 40:    print("Pass")else:    pass        # nothing happens in the else case, for now

Pass

continue skips the rest of the loop’s body for this time round only, and goes straight on to the next item. The loop doesn’t end.

for number in range(1, 6):    if number == 3:        continue    # skip the rest of the loop for 3    print(number)

1245

break ends the loop at once, even though items are left, and the program carries on after the loop.

for number in range(1, 6):    if number == 3:        break       # leave the loop when number is 3    print(number)

12

while loop

A while loop repeats its block as long as its condition is True. Before each time round, it checks the condition; when the condition becomes False, the loop ends. It is used when we don’t know in advance how many times to repeat: until the user types the right password, until a number has no digits left.

while condition:    # code run again and again while the condition is True    # (it must change something, so the condition becomes False one day)

# Print the numbers from 1 to 5 with a while loopcount = 1while count <= 5:    print(count)    count += 1

12345

Three things make a while loop work: the variable is set before the loop (count = 1), the condition checks it (count <= 5), and the body changes it (the increment count += 1). Leave out the last one and count stays 1 for ever: the condition is always True, and the loop never ends. This is an infinite loop (stop it with Ctrl + C, or the page’s Stop button).

for loop and while loop compared

To store the marks of one student you need one variable; for forty students, forty variables would be silly. A list stores many values in a single variable. It is one of Python’s built-in data types. Its items (elements) are written inside square brackets [ ], separated by commas, and they can be of different types, heterogeneous: integers, strings, floats and Booleans in the same list.

thislist = ["Computer", "Science", 20, True]print(thislist)

['Computer', 'Science', 20, True]

Lists support the operations that all of Python’s sequence types (lists, tuples, strings and ranges) share: indexing, finding the length, going through them with a for loop, and checking whether an item is in them. Strings, ranges and lists all behave alike in these ways.

Features of a list

List elements are indexed. Each element has a position number, its index, and the index always begins at 0: the first element is at index 0, the second at index 1, and so on. The index is how you reach an element: write it in square brackets after the list’s name. A negative index counts from the end: [-1] is the last element.

thislist = ["Computer", "Science", 20, True]print(thislist[0])print(thislist[2])print(thislist[-1])

Computer20True

The output of thislist[2] is 20 because 20 is the element at index 2, the third element. Asking for an index the list doesn’t have, such as thislist[4] here, is an IndexError.

A list can have duplicate elements: the same value may appear more than once.

thislist = ["Computer", "Science", 20, True, "Computer"]print(thislist)

['Computer', 'Science', 20, True, 'Computer']

A list is ordered. Its elements keep their places, and a new element added with the append() method always goes at the end. A method is a function that belongs to a value; it is joined to the list’s name with a dot, .

thislist = ["Computer", "Science", 20, True]thislist.append("Social")      # add a new element at the endprint(thislist)

['Computer', 'Science', 20, True, 'Social']

A list is changeable (in Python’s word, mutable). Elements can be added, changed and removed after the list is made. To remove an element, write the keyword del before the list’s name with the element’s index:

thislist = ["Computer", "Science", 20, True, "Social"]del thislist[4]                # removes the element at index 4, "Social"thislist[2] = 25               # changes the element at index 2print(thislist)

['Computer', 'Science', 25, True]

List length

The len() function gives the number of elements in a list:

thislist = ["Computer", "Science", 20, True]a = len(thislist)print(a)

4

The last element’s index is always one less than the length: here 3.

Looping through a list

A for loop goes through a list’s elements one by one, in order:

thislist = ["Computer", "Science", 20, True]for x in thislist:    print(x)

ComputerScience20True

Picture a real dictionary: you look up a word and find its meaning. A Python dictionary works the same way, but instead of words and meanings it stores pairs of keys and values. You look up a key, and get the value that goes with it, quickly. A dictionary is a collection of data in key:value pairs, written inside curly braces { }, a colon between each key and its value, and commas between the pairs.

mydict = {    "student": "pen",    "teacher": "marker",    "tailor": "needle",    "marks": 30,    "is_present": True}print(mydict)

{'student': 'pen', 'teacher': 'marker', 'tailor': 'needle', 'marks': 30, 'is_present': True}

Here the key "student" has the value "pen", "teacher" has "marker" and "tailor" has "needle". You can add as many key:value pairs as you like. The values can be of any data type (here strings, an integer and a Boolean); the keys are usually strings or numbers.

Features of a dictionary

Duplicate keys are not allowed. Each key appears only once. If the same key is given two values, the newer value replaces the older one:

mydict = {    "student": "pen",    "teacher": "marker",    "tailor": "needle",    "marks": 30,    "is_present": True,    "teacher": "duster"}print(mydict)

{'student': 'pen', 'teacher': 'duster', 'tailor': 'needle', 'marks': 30, 'is_present': True}

The older value of the key "teacher", "marker", has been replaced by "duster". (Values may repeat; only keys can’t.)

A dictionary is changeable (mutable): pairs can be added and removed after it is made. A new pair is added by writing the new key in square brackets and assigning its value:

mydict = {"student": "pen", "teacher": "marker", "tailor": "needle", "marks": 30, "is_present": True}mydict["mechanic"] = "tools"print(mydict)

{'student': 'pen', 'teacher': 'marker', 'tailor': 'needle', 'marks': 30, 'is_present': True, 'mechanic': 'tools'}

(Assigning to a key that already exists changes its value instead: mydict["marks"] = 35.)

The keyword del removes a pair, named by its key:

mydict = {"student": "pen", "teacher": "marker", "tailor": "needle", "marks": 30, "is_present": True, "mechanic": "tools"}del mydict["mechanic"]print(mydict)

{'student': 'pen', 'teacher': 'marker', 'tailor': 'needle', 'marks': 30, 'is_present': True}

Accessing a value

A value is found by its key, written in square brackets after the dictionary’s name:

mydict = {"student": "pen", "teacher": "marker", "tailor": "needle", "marks": 30, "is_present": True}a = mydict["teacher"]print(a)

marker

Asking for a key that isn’t there, such as mydict["doctor"], is a KeyError. To check first, use in: "doctor" in mydict is False.

Dictionary length

len() gives the number of key:value pairs:

mydict = {"student": "pen", "teacher": "marker", "tailor": "needle", "marks": 30, "is_present": True}b = len(mydict)print(b)

5

Looping through a dictionary

A for loop over a dictionary goes through its keys, one by one:

mydict = {"student": "pen", "teacher": "marker", "tailor": "needle", "marks": 30, "is_present": True}for x in mydict:    print(x)

studentteachertailormarksis_present

To print the values too, use each key to look up its value: print(x, mydict[x]).

List and dictionary compared

A function is a named, ready-made group of instructions that does one particular job, such as a calculation or a check, and usually gives back a result. Python’s library functions (built-in functions, and those in its standard library’s modules) are written for you: you just call a function by its name, with the values it needs in brackets. Grouping a job that is done often into a function means it is written once and used many times. You have already used several: print(), input(), int(), len(), type().

String functions

Strings have many built-in methods (functions that belong to them, called with a dot) to work on text. Each gives back a new string; the original is unchanged.

center() returns the string padded on both sides, to the given width, so that it sits in the middle.

string.center(width, fillchar)

• width: the length of the new string, padding included;
• fillchar (optional): the padding character; a space if none is given.

string = "Python is awesome"new_string = string.center(24)print("[" + new_string + "]")print(string.center(24, "*"))

[   Python is awesome    ]***Python is awesome****

The string has 17 characters, so 7 are added to make 24: 3 before and 4 after. (The square brackets are printed only to show the spaces.)

upper() returns a copy of the string with every letter in capitals (uppercase); lower() returns a copy with every letter small (lowercase). Characters that aren’t letters stay as they are.

text = "this is a string example....wow!!!"print(text.upper())shout = "THIS IS A STRING EXAMPLE....WOW!!!"print(shout.lower())

THIS IS A STRING EXAMPLE....WOW!!!this is a string example....wow!!!

They are handy for comparing what a user types: answer.lower() == "yes" is True whether the user typed yes, Yes or YES.

len() returns the length of a string, the number of characters in it, spaces and symbols included:

text = "this is string example....wow!!!"print("Length of the string:", len(text))

Length of the string: 32

Numeric functions

Some built-in functions work on numbers:

total = sum([1, 2, 3, 4, 5])absolute = abs(-10)rounded = round(3.14159, 2)maximum = max(1, 2, 3, 4, 5)minimum = min(1, 2, 3, 4, 5)print("total is", total)print("absolute is", absolute)print("rounded is", rounded)print("maximum is", maximum, "and minimum is", minimum)

total is 15absolute is 10rounded is 3.14maximum is 5 and minimum is 1

Mathematical functions

More maths functions are in Python’s math module, a part of its standard library. A module must be imported before its functions are used: write import math once, at the top, then call each function as math.name(). They work with integers and floats (not with complex numbers, which you will meet in higher classes).

import mathprint("root is", math.sqrt(16))print("ceiling is", math.ceil(3.14), "and floor is", math.floor(3.14))print("factorial is", math.factorial(5))print("power is", math.pow(2, 3))print("sine is", math.sin(math.pi / 2))print("cosine is", math.cos(0))print("tangent is", math.tan(math.pi / 4))print("natural_log is", math.log(10))

root is 4.0ceiling is 4 and floor is 3factorial is 120power is 8.0sine is 1.0cosine is 1.0tangent is 0.9999999999999999natural_log is 2.302585092994046

The tangent of 45° (π/4 radians) is exactly 1 in maths, but the computer prints 0.9999999999999999. A float holds only about 16 digits, so π itself is stored a tiny bit wrong, and the error shows in the last digit. round(math.tan(math.pi / 4), 10) gives 1.0.

Each task below is a short program of the kind the exam asks you to write or to read. Try writing it yourself first, on paper or with Edit on any program on this page; then open the program, run it, and change the input to test it.

Input, output and operators

Decisions with if

Loops

Exam practice

The final exam’s short and long questions on this unit read a program, dry-run it, or ask you to write one. Here is one of each kind, written like the exam’s.

1. Answer these questions

2. Write the technical terms

3. Write true or false

4. Write the full forms

5. Choose the correct answer

6. Practical questions

Input and output

Constant values and operators

if…else statements

for loops

while loops

Lists

Dictionaries