Getting Started with Python

Written and reviewed by Rohit Singh, Computer Science & Commerce faculty at UniDrill (MCA, Osmania University · 6 years teaching). Based on NCERT Computer Science Class XI, Chapter 5.

You type 2 and the program shows 22

A beginner writes a program to double a number. The user types 2 and expects 4. The program prints 22. Nothing is broken: Python did exactly what it was told. The user's 2 arrived as the text "2", and multiplying text by 2 repeats it. Almost every Python mistake in this chapter has the same root: Python does precisely what the symbols mean, and the meaning depends on the type of the data.

So the chapter is really about three questions. What is each value (its type)? What do the operators do to it? And what happens when the types don't match? Learn those and the output of any program can be predicted by hand, which is how NTA tests it.

What Python is, and how you run it

An ordered set of instructions given to a computer to do a task is a program, and the language used to write it is a programming language. Python is a high level language, so its programs are source code, translated into machine language by an interpreter. The interpreter takes the statements one by one, translating and executing each, until an error is met or the whole program has run. A compiler, on the contrary, translates the entire source code into object code and reports errors after scanning the whole program.

You use the interpreter in two ways. The shell shows the prompt >>>, meaning it is ready for instructions.

In IDLE you run a script with Run → Run Module.

Keywords and identifiers

Keywords are reserved words with a fixed meaning for the interpreter. They must be spelled exactly as given, because Python is case sensitive.

These 33 words make up the list. Only True, False and None start with a capital letter.

Beyond the textbook. For the exam: the keyword list is the 33 words in the table above. In reality: recent versions of Python have two more reserved words, async and await, so the list has 35 keywords. Why it matters: it does not change any rule: a keyword still cannot be used as a name.

An identifier is a name given to a variable, function or other entity. The rules:

Worked example: which of these identifiers are invalid?

A name such as Hundred followed by a dollar sign is also invalid because of the symbol. Use names that tell the reader what they hold, such as marks1, marks2, marks3 and avg, rather than a, b, c.

Pause and predict: is none a valid identifier? Is None?

Check your answer: none is valid, because Python is case sensitive and only None is the keyword. None is not valid as an identifier.

Variables: names that refer to objects

A variable is identified by a name (an identifier). In Python, a variable refers to an object, an item stored in memory, which may be a number, a string and so on. You create one with an assignment statement. There is no separate declaration: a variable is created automatically when you first assign a value, and it must be assigned before it is used in an expression, otherwise there is an error.

The string is written in quotes (single or double) and the number is not. Wherever a variable name appears in an expression, the interpreter replaces it with its value.

Everything is an object. Every value, numeric, string or other, is an object that can be assigned to a variable or passed to a function. Each object has a unique identity (ID) that stays the same for its lifetime, rather like its memory address, and the function id() returns it. Assignment copies only the reference, not the data. After num2 = num1, both names refer to the same object.

Integers are immutable, so num2 + 100 does not change the object 300. It builds a new object 400, and num1 now refers to it while num2 still refers to 300.

Beyond the textbook. For the exam: equal values assigned from the same name share one object, and is compares identity. In reality: the standard Python implementation keeps ready made objects for small integers (about -5 to 256), so two separately created small integers usually are the same object, but two separately created large ones need not be. Why it matters: use == to compare values and keep is for checking identity and for None.

Comments are notes for humans that the interpreter ignores. A comment starts with # and runs to the end of the line. They document the purpose, input and output of a program, which matters when someone else maintains it. Do not over comment.

Data types

Every value has a data type, which decides what values it can hold and what operations are allowed. The built in function type() tells you the type.

Points to hold on to:

Mutable and immutable. A variable whose value can be changed after creation is mutable; one that cannot be changed is immutable. When you try to update an immutable variable, the old object is not changed: a new one is created under the same name. Lists, sets and dictionaries are mutable. Integers, floats, booleans, complex numbers, strings and tuples are immutable.

Worked example: choose a data type. Say which type suits each value and why.

Use a list for a simple collection that changes often, a tuple when nothing should change, a set when each item must be unique, and a dictionary for fast lookup by a key.

Operators

An operator performs an operation on operands. In 10 + num, 10 and num are the operands and + is the operator. Unary operators have one operand (-x, not) and binary operators have two.

Arithmetic operators

Relational operators compare two values and give True or False: == (equal), != (not equal), >, <, >= and <=. Strings are compared lexicographically using the ASCII values of the characters, comparing the first characters and then the next, and so on. So "Good" > "Afternoon" is True because G (71) is greater than A (65), and "Bye" == "BYE" is False because capital and small letters have different codes.

Assignment operators. = assigns, and each shorthand does the operation and assigns the result: x += y means x = x + y, and the same holds for -=, *=, /=, %=, //= and **=.

Notice that /= gives 3.0, a float, because / always returns a float.

Logical operators are and, or and not, always written in lower case. Every value is logically True or False. By default all values are True except None, False, 0 and empty collections such as "", (), [] and {}.

Identity operators is and is not check whether two names refer to the same object (that is, whether id() is the same). Membership operators in and not in check whether a value is in a sequence.

'1' in a is False because the list holds the number 1, not the text '1'.

Worked example: predict each result. Take num1 = 4, num2 = 3, num3 = 2.

Beyond the textbook. For the exam: // removes the decimal part, and and and or give True or False. In reality: // rounds down, so -7 // 2 is -4 (not -3) and -7 % 2 is 1. Also, and and or return one of their operands: 0 or 5 gives 5 and 10 and 20 gives 20, and that is why the textbook wraps them in bool(). Why it matters: the rule that explains both is that the remainder always takes the sign of the divisor, and that or returns the first true operand.

Expressions and precedence

An expression is a combination of constants, variables and operators and always evaluates to a value. A single value or variable is also an expression, but a lone operator is not. A statement is a unit of code the interpreter can execute, such as an assignment or a print.

When an expression mixes operators, precedence decides which is applied first. Higher precedence goes first, and operators of equal precedence go from left to right. Brackets override precedence. Unary operators have higher precedence than binary operators.

Worked example: evaluate by precedence.

Common wrong step. For 24 // 4 // 2, working from the right: 4 // 2 = 2, then 24 // 2 = 12. Equal precedence means left to right, so the answer is 3.

Beyond the textbook. For the exam: equal precedence is evaluated left to right, and the ranking is the table above. In reality: the exponent operator is the exception, and it groups right to left, so 2 ** 3 ** 2 is 2 ** 9, which is 512, not 64. Also, in real Python the relational, identity and membership operators share one level, which is why 1 < 2 < 3 works as a chain. Why it matters: when in doubt, use brackets; they are never wrong.

Input and output

The input() function reads what the user types and gives it back as a string, whatever was typed. Its optional argument is a prompt displayed first. Entry ends when the user presses Enter.

The print() function evaluates its arguments and writes them, then moves to the next line. It has two optional arguments: sep, the separator placed between values (default: a space) and end, the text added after the last value (default: a new line).

Using + between a string and a number gives an error, while a comma works with any types.

Type conversion

The user's 2 became "22" because input gave the string "2". To get 4 the program must convert the string to an integer first.

Without step 2, step 3 repeats the string, giving "22".

Explicit conversion (type casting) happens when the programmer forces the change. It can lose information.

int('3.14') raises a ValueError, because "3.14" is not a whole number in text form. To get 3, convert in two steps: int(float('3.14')).

Python will not convert silently when it risks losing information. Joining text and a number fails:

This gives a TypeError, because Python cannot join a string and an integer. The fix is to state the conversion:

If the prices were the strings '25' and '45', then + would join them as '2545'. Only after int() is applied to each does the sum become 70.

Implicit conversion (coercion) happens automatically. When an int and a float meet in an expression, the int is converted to float (type promotion), because the wider type holds the result without losing information.

Pause and predict: what are 10 + 20.0, int(-2.7) and str(7) + '1'?

Check your answer: 30.0, -2 and '71'. The first is promoted to float. The second drops the fraction towards zero. The third joins two strings.

Beyond the textbook. For the exam: chr(x) gives the character for the code x, and ord(c) gives the code of the character c. In reality: the two are inverses: ord(chr(66)) is 66. They are easy to swap, so use this trick: ord is short for ordinal, the position number, which is the code. Why it matters: this is the same ASCII table from the encoding chapter, so chr(ord('A') + 2) is 'C'.

Putting it together: small programs

A program reads input, converts it, calculates and prints. Here is the pattern for converting Celsius to Fahrenheit using the formula $F = C \times \tfrac{9}{5} + 32$.

For simple interest, $SI = \dfrac{P \times R \times T}{100}$ and the amount is $P + SI$. With $P = 1000$, $R = 5$, $T = 2$, $SI = 100$ and the amount is 1100.0 (a float, because float() was used for the inputs).

Swapping two values is a classic. With a third variable:

The temporary variable is needed because after a = b the old value of a would be lost. Python can also swap in one line: a, b = b, a, because the whole right side is evaluated first and then assigned.

Worked example: tuple assignment. Trace num1, num2 = 2, 6 and then num1, num2 = num2, num1 + 2.

The output of print(num1, num2) is 6 4. Common wrong step: updating num1 first to 6 and then computing num1 + 2 as 8, giving 6 8.

Debugging: the three kinds of error

A bug is a mistake in a program. Debugging is finding and removing bugs. There are three kinds.

A logical error is also called a semantic error. For 10 + 12 / 2 (meant as the average of 10 and 12), Python gives 16.0, because division goes first. The right code is (10 + 12) / 2, which gives 11.0. The program ran perfectly and was still wrong.

If the user types 5, this prints 2.0. If the user types 0, it stops with a ZeroDivisionError, and if the user types a word instead of a number, int() stops it with a ValueError. Both are runtime errors: the code is correct, but this particular input cannot be handled.

Worked example: classify the error.

Good documentation also helps: state the objective at the start, use meaningful variable and program names (not single letters or your own name), indent properly, keep naming conventions the same throughout, and use comments where they help understanding, but not too many.

Exam traps

60-second revision

Operator and function sheet

Where this chapter connects

• Previous: Introduction to Problem Solving is where the algorithms come from that you now write as programs.
• Next: Flow of Control adds the if statement and loops, so programs can choose and repeat.
• Data types in depth: Strings, Lists and Tuples and Dictionaries develop the sequence and mapping types introduced here.
• Earlier links: Computer System explains interpreters and compilers, and Encoding Schemes and Number System explains the codes behind ord and chr.