Python: the Basics

Jon Reades - j.reades@ucl.ac.uk

1st October 2025

Variables

At heart, all programming is about:

• Storing data (or references to data) in variables,
• Feeding those data into operations,
• Reporting back.

Over time we just get better and better at each of those steps!

Let’s start with storing data…

Variables Have Types…

Name	Value	Type
msg	‘Hello world’	type(msg)==str
answer	42	type(answer)==int
pi	3.14159	type(pi)==float
c	complex(5,2)	type(c)==complex
correct	True	type(correct)==bool

As we’ll see in Week 4, everything is also an object.

… But We Can Change That

Message starts as a string:

msg = '42'
type(msg) # str

But we can change it to an integer like this:

msg = int(msg)
type(msg) # change to int

And back to a string:

msg = str(msg)
type(msg) # back to str

And notice:

print(str(int('42'))) # string from int from string

That last line of code is intended to start familiarising you with Python syntax: programmers rarely do one operation per line of code if they can do more than one, so you’ll often see nested parentheses like this and you need to learn how to read this kind of code starting from the inner-most parentheses (the int()) and working outwards from there to str() and finally print().

…And They Are All Objects

One to remember for the session on objects and classes:

isinstance(msg,object)     # True
isinstance(answer,object)  # True
isinstance(pi,object)      # True
isinstance(c,object)       # True
isinstance(correct,object) # True

Like str(), int(), and print(), you see here another command — or ‘function’ in Python terminology — called ininstance. An ‘instance’ of something is just a way of asking ‘is it a type of’: so the first line asks if string msg is a kind of object, and the answer to that is: True. But it’s the same for answer (an integer), pi (a floating point number), and so on. They are all a kind of object, and we’ll see why that is a useful answer in a few weeks’ time.

Variables Have Names…

Rules for variable names:

• They cannot start with a number: item3 is valid, 3items is not.
• White space and symbols are not allowed, but _ is allowed: my_variable is valid, my-variable, my$variable, and my variable are not.
• Case matters: myVar is different from both myvar and MYVAR
• Be consistent: my_var is more ‘Pythonic’, though myVar is also widely used; but don’t mix these!
• Variable names should be long enough to be clear but not so long as to be impractical: bldg_height vs. bh vs. max_building_height_at_eaves.

…But Not All Words Are Allowed

Do not try to use any of these as variable names. Python may not complain, but strange things will happen when you run your code.

and	del	from	not	while
as	elif	global	or	with
assert	else	if	pass	yield
break	except	import	print
class	exec	in	raise
continue	finally	is	return
def	for	lambda	try

Operators

Simple Operations on Variables

Let’s start with x=10 and y=5…

Operator	Input	Result
Sum	x + y	15
Difference	x - y	5
Product	x * y	50
Quotient	x / y	2.0
‘Floored’ Quotient	x // y	2
Remainder	x % y	0
Power	pow(x,y) or x**y	100000
Equality	x==y	False

Strings Are Different

When you do things with strings the answers can look a little different. Let’s start with x="Hello" and y="You" and z=2…

Operator	Input	Result
Sum	x + y	'HelloYou'
Difference	x - y	TypeError
Product	x * z	HelloHello
Equality	x==y	False

Using Strings to Output Information

Python has no fewer than three ways output information:

1. string concatenation using +;
2. string formatting using <str>.format(<variables>); and
3. f-strings using f"{variable_1} some text {variable_n}".

There are pros and cons to each:

x = 24
y = 'Something'
print("The value of " + y + " is " + str(x))
print("The value of {0} is {1}".format(y, x))
print(f"The value of {y} is {x}")

Obviously, a really common requirement that programmers have is ‘output a nicely formatted string containing information about the variables in my program’.

I rather like f-strings because they can actually contain any code you like (you could, for instance, write `f”The square root of {y} is {x**(1/2)}” and it would work. However, concatenation is the easiest to learn.

Operators Assemble!

Always pay attention to precedence:

x, y = 10, 5
x + y * 2         # == 20
(x + y) * 2       # == 30
x + y * 2 / 3     # == 13.3333333333334
x + y * (2/3)     # == 13.3333333333332
(x + y) * (2/3)   # == 10.0

And here’s a subtle one:

(x * y) ** 2/3    # == 833.333333333334
(x * y) ** (2/3)  # == 13.5720880829745

The full list is here.

If you’re a little rusty on exponents, that last example is the cube root of (x*y)**2. But the key point is that formatting is not what matters here, it’s operator precedence: one has parentheses, the other does not, so they are evaluated differently. To make the first one more clear we might use (x * y)**2 / 3 or even ((x*y)**2)/3.

Also notice that with the two floats in the first block you do not always get the same result from operations that should give the same answer. Non-terminating decimals (e.g. 1/3) will always be rounded, unpredictably, by the computer because it doesn’t have infinite memory. The process of rounding means that you need to be very careful comparing floats (more on this later).

Comparing Variables

For numeric variables comparisons are easy.

Operator	Input	Result
==	10 == 5	False
!=	10 != 5	True
<, <=	10 < 5	False
>, >=	10 > 5	True

The result of any (successful) comparison is a Boolean (True/False). We can save the output of this comparison to a new variable (e.g. z = x > y).

This last example has to do with the way that strings are compared.

Strings Are Different

But notice:

w, x, y, z = '4a','4a','365','42'
w == x  # True
w != y  # True
x > y   # True
x > z   # True

Why is 4a greater than both 365 and 42?

Danger, Will Robinson!

Notice the very subtle visual difference between = and ==!

x = 5
y = 10
x = y   # Probably a mistake: setting x to the value of y
x == y  # True, because x and z are now both set to 10

Remember this!

Confusing these two operators is the most common source of mistakes early on when learning to code in Python! One (=) does assignment, the other (==) does comparison.

Common Mistakes

Here’s the output from some attempts at comparison:

x, y = '42', 42
x==y   # False
x>y    # An error!

This last line produces:

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: '>' not supported between instances of 'str' and 'int'

If we want to compare them then we’ll need to change their type:

x > str(y)   # False
int(x) <= y  # True
x > = str(y) # Also True

A really common mistake is to think that string (str) "42" is the same as the integer (int) 42.

Notice that in the first example we can say that 42 is clearly not the same as ‘42’, but we can’t say whether it’s more or less because that’s non-sensical in this context. So this is a computer being totally logical but not always sensible.

Also notice the syntax for this: we have str(<something>) and int(<something>) to convert between types. These are functions, which we’ll spend a lot more time on next week!

Why might it be (fractionally) faster to compare integers than strings?

Additional Resources

Here are some links to videos on LinkedIn Learning that might help, and YouTube will undoubtedly have lots more options and styles of learning:

• Types of Data
• Variables and expressions
• Strings
• The string type
• Common string methods
• Formatting strings
• Splitting and joining
• Numeric types
• The bool type
• Storing Data in Variables

Thank You

References