Basic types
In python, there are many built-in types.
The most common basic types are int
, float
, bool
and str
.
-
# immutable a = int('45.9') b = 15 // 4 c = 4387372
-
# immutable a = float(2) b = 32 / 2 c = 2.8
-
# immutable a = bool('') b = a < 1 c = False
-
# immutable a = str(True) b = 'hello' c = 'hello'.upper()
Strings are a bit different because they are sequences of characters and so they are more interesting.
String manipulation
Strings, are immutable sequences of characters, a form of compound data type. These methods never change the value of a string, they return new string instances.
-
'hello world'.upper()
-
'HELLO WORLD'
-
'hello world'.capitalize()
-
'Hello world'
-
'hello world'.title()
-
'Hello World'
-
'hello world'.split()
-
['hello', 'world']
-
'hello world'.split('o')
-
['hell', 'w', 'rld']
-
'hello'.join('world')
-
'whelloohellorhellolhellod'
see more in the python documentation
Immutability
The int
, float
, bool
, str
and tuple
data types are immutable.
This means that instances of these types cannot be modified.
a = 100000000
a += 1
Though it may sometimes seem like they are being modified, in fact, new pyObjects are created in memory.
Compound types
Compound types provide us with structures to group data together. They tend to be mutable, except for strings and tuples.
-
# immutable a = tuple('hello') b = (1.0, 'hello') c = ('hello', ) d = a[:3]
-
# mutable a = list('hello') b = [1.0, 'hello'] c = a + b d = 'hello world'.split()
-
# mutable a = dict((('a', 2), ('b', 4))) b = { 'a': 1.0, 'b': 'hello' }
-
# mutable a = set('hello') b = {1.0, 'hello', 'e', 'o'} c = a | b d = a & b e = a - b
Combining compound types
Compound types can easily be combined to produce the data structures you need.
player_data = {
"health": 82,
"attack": 21,
"shield": 5,
"magic": 76,
"speed": 45,
"inventory": [
{ "name": "blue potion", "type": "health", "power": 6 }
],
"check-point": 84
}
sword = { "name": "massive sword", "type": "weapon", "power": 9 }
player_data['inventory'].append(sword)
used here
More built-in types
Many more exotic types exist but we don’t really need to know about them all. We have seen examples of some of these. You will often find yourself using them without realising it.
-
type(None).__name__
-
'NoneType'
-
type(print).__name__
-
'builtin_function_or_method'
-
type(''.center).__name__
-
'builtin_function_or_method'
-
type(reversed('hello')).__name__
-
'reversed'
-
type(type(1)).__name__
-
'type'
The key point is that everything is an object, everything has a type.
Sequences
Sequences (such as str
, tuple
and list
) store items in a particular order and allow for indexing and slicing.
-
Indexing
-
('I', 'just', 'wanna', 'tell', 'you', 'how', "I'm", 'feeling')[2]
-
'wanna'
-
'Gotta make you understand'[-1]
-
'd'
-
Slicing
-
['I', 'just', 'wanna', 'tell', 'you', 'how', "I'm", 'feeling'][1::2]
-
['just', 'tell', 'how', 'feeling']
-
'Gotta make you understand'[::4]
-
'Gakonsd'
Compound statements
Compound statements control the flow and context of code execution within code blocks defined using indentation.
-
while input('Yes? [y/n]: ') == 'y': print("yes!")
-
with open('filename.txt', 'r') as file: data = file.read()
-
if a: print(a)
-
for ch in 'hello': print(ch)
-
def play_game(): print('fun!')
-
try: guess = int(input('guess: ')) except ValueError: print("That's not a number!")
-
class Guess: def __init__(self, actual): self.value = input('guess: ') self.correct = self.value == actual
Looping over sequences with for
A for
loop will run the code block once for each iterated value.
The for
syntax requires a named variable, followed by the keyword in
, followed by an iterable object.
Sequences are iterable, so they can be used in a for
loop.
things_ill_never_do = ["give you up", "let you down", "run around and desert you"]
for this_thing in things_ill_never_do:
print(f"Never gonna {this_thing}")
Never gonna give you up
Never gonna let you down
Never gonna run around and desert you
if
and while
The if
and while
clauses require a conditional statement which is evaluated for truth.
If the statement evaluates to True
then the block is executed, otherwise the block is skipped.
-
if True: print('this always happens') else: print('this never happens') print('followed by this')
-
count = 0 while True: count += 1 print(f'continuously happens ({count})') print('this never happens')
The while
loop will repeat until the conditional evaluates to False
.
The above example using while True:
is an infinite loop which can only be exited using the break
keyword.
The continue
keyword can be used to skip to the next loop.
Both break
and continue
can be used in for
loops too.
-
count = 0 while True: count += 1 if count > 10: break;
-
for i in range(200): print('every time') if i < 100: continue print("from 100 only")
Iterables
An iterable is an object capable of returning its members one at a time. If it makes sense to iterate over something, then it’s probably an iterable.
All sequences are iterable, plus the
dict
type and file-like objects.
for key in player_data:
print(f'{key}: {player_data[key]}')
But also methods will return iterables, such as dict.items()
which iterates over the (key, value)
pairs.
This is often more convenient than looping over the keys alone.
for key, value in player_data.items():
print(f'{key}: {value}')
player_data
from here