By

Contents
  1. 1. Getting Started
  2. 2. Variables and Data Types
    1. 2.1. Variables
    2. 2.2. Data Types
  3. 3. String and Array
    1. 3.1. String
    2. 3.2. Array
    3. 3.3. Tuple
    4. 3.4. Dict
    5. 3.5. Set
  4. 4. Expressions
  5. 5. Statements
    1. 5.1. Simple statements
    2. 5.2. Control Flow Statements
  6. 6. Functions
  7. 7. Modules
  8. 8. Classes
    1. 8.1. Classes
    2. 8.2. Inheritance
  9. 9. Standard Library
    1. 9.1. I/O Streams and Files
  10. 10. Advanced Topics
  11. 11. References

Getting Started

Hello World

1
2
> print("Hello World")
Hello World

Get input data from console

1
input_string_var = input("Enter some data: ")

Comment

1
2
3
4
5
# Single line comments start with a number symbol.
""" Multiline strings can be written
    using three "s, and are often used
    as documentation.
"""

Variables and Data Types

Variables

There are no declarations, only assignments. Convention is to use lower_case_with_underscores.

1
some_var = 5

Data Types

Category Type
Text Type str
Numeric Types int, float, complex
Sequence Types list, tuple, range
Mapping Type dict
Set Types set, frozenset
Boolean Type bool
Binary Types bytes, bytearray, memoryview
None Type NoneType 
1
2
3
> x = 5
> print(type(x))
<class 'int'>
Example Data Type
x = “Hello World” str
x = 20 int
x = 20.5 float
x = 1j complex
x = [“apple”, “banana”, “cherry”] list
x = (“apple”, “banana”, “cherry”) tuple
x = range(6) range
x = {“name” : “John”, “age” : 36} dict
x = {“apple”, “banana”, “cherry”} set
x = frozenset({“apple”, “banana”, “cherry”}) frozenset
x = True bool
x = b”Hello” bytes
x = bytearray(5) bytearray
x = memoryview(bytes(5)) memoryview
x = None NoneType

String and Array

String

Strings are created with “ or ‘

1
2
str1 = "This is a string."
str2 = 'This is also a string.'

A string can be treated like a list of characters

1
"Hello world!"[0]  # => 'H'

Properties of Strings

1
len("This is a string")

String concatenation

1
"Hello " + "world!"

String formatting

1
2
3
name = "Reiko"
format_str = f"She said her name is {name}." 
format_str2 = f"{name} is {len(name)} characters long."
1
2
format_str = "She said her name is {}.".format("Reiko")
format_str = "She said her name is {name}.".format(name="Reiko")

Array

1
2
li = []
other_li = [4, 5, 6]

Access

1
2
3
4
# Access a list like you would any array
li[0]
# Look at the last element
li[-1]
1
2
# Examine the length with "len()"
len(li)

Lookup

1
2
# Check for existence in a list with "in"
1 in li  # => True
1
2
# Get the index of the first item found matching the argument
li.index("a")

Insert

1
2
3
4
# Add stuff to the end of a list with append
li.append(1) 
# Insert an element at a specific index
li.insert(1, 2)

Update

1
li[1] = 11

Remove

1
2
3
4
5
6
# Remove from the end with pop
li.pop()
# Remove by index
del li[2]  # delete the 2th element
# Remove by value
li.remove(2) # Remove first occurrence of a value

Slice

1
li[start:end:step]
1
2
3
4
5
li[1:3]   # Return list from index 1 to 3
li[2:]    # Return list starting from index 2
li[:3]    # Return list from beginning until index 3
li[::2]   # Return list selecting every second entry
li[::-1]  # Return list in reverse order

one layer deep copy

1
li2 = li[:]

Concatenate

1
2
li + other_li
li.extend(other_li)

Tuple

Tuples are like lists but are immutable. You can’t insert, update, remove elements.

1
2
3
4
5
tup = (1, 2, 3)
# Tuples are created by default if you leave out the parentheses
tup2 = 11, 22, 33
tup[0]      # => 1
tup[0] = 3  # Raises a TypeError

Access

1
tup[0]
1
len(tup)

Lookup

1
1 in tup  # => True
1
li.index("a")

Slice

1
tup[:2]

Concatenate

1
tup + (4, 5, 6)

Unpack tuples (or lists) into variables

1
2
3
4
a, b, c = (1, 2, 3)
d, e, f = 4, 5, 6
# swap two values
e, d = d, e

Dict

1
2
empty_dict = {}
filled_dict = {"one": 1, "two": 2, "three": 3}

Note keys for dictionaries have to be immutable types. This is to ensure that the key can be converted to a constant hash value for quick look-ups. Immutable types include ints, floats, strings, tuples.

1
2
invalid_dict = {[1,2,3]: "123"}  # => Yield a TypeError: unhashable type: 'list'
valid_dict = {(1,2,3):[1,2,3]}   # Values can be of any type, however.

Access

1
2
3
4
5
6
7
filled_dict["one"]
# Looking up a non-existing key is a KeyError
filled_dict["four"]  # KeyError
# Use "get()" method to avoid the KeyError
filled_dict.get("one")
# The get method supports a default argument when the value is missing
filled_dict.get("one", 4)

Put

1
2
3
# Adding to a dictionary
filled_dict.update({"four":4})  # => {"one": 1, "two": 2, "three": 3, "four": 4}
filled_dict["four"] = 4         # another way to add to dict
1
2
3
# "setdefault()" inserts into a dictionary only if the given key isn't present
filled_dict.update({"four":4})  # => {"one": 1, "two": 2, "three": 3, "four": 4}
filled_dict["four"] = 4         # another way to add to dict

Delete

1
2
# Remove keys from a dictionary with del
del filled_dict["one"]  # Removes the key "one" from filled dict

Lookup

1
"one" in filled_dict
1
2
list(filled_dict.keys())
list(filled_dict.values())

Get all keys as an iterable with “keys()”. We need to wrap the call in list() to turn it into a list. Note - for Python versions <3.7, dictionary key ordering is not guaranteed. Your results might not match the example below exactly. However, as of Python 3.7, dictionary items maintain the order at which they are inserted into the dictionary.

Set

1
2
3
empty_set = set()
# Initialize a set with a bunch of values.
some_set = {1, 1, 2, 2, 3, 4}  # some_set is now {1, 2, 3, 4}
1
2
3
# Similar to keys of a dictionary, elements of a set have to be immutable.
invalid_set = {[1], 1}  # => Raises a TypeError: unhashable type: 'list'
valid_set = {(1,), 1}

Insert

1
my_set.add(5)

Delete

1
my_set.remove(1)

Lookup

1
2 in filled_set

Intersection/union/difference/subset

1
2
3
4
5
6
7
8
9
10
11
12
13
14
filled_set = {1, 2, 3, 4, 5}
other_set = {3, 4, 5, 6}
# Do set intersection with &
filled_set & other_set # => {3, 4, 5}
# Do set union with |
filled_set | other_set  # => {1, 2, 3, 4, 5, 6}
# Do set difference with -
{1, 2, 3, 4} - {2, 3, 5}  # => {1, 4}
# Do set symmetric difference with ^
{1, 2, 3, 4} ^ {2, 3, 5}  # => {1, 4, 5}
# Check if set on the left is a superset of set on the right
{1, 2} >= {1, 2, 3} # => False
# Check if set on the left is a subset of set on the right
{1, 2} <= {1, 2, 3} # => True

Copy

1
2
3
# Make a one layer deep copy
filled_set = some_set.copy()  # filled_set is {1, 2, 3, 4, 5}
filled_set is some_set        # => False

Expressions

Arithmetic Operators

  • +: add
  • -: subtract
  • *: multiply
  • /: divide
  • //: integer division rounds down
  • %: modulo
  • **: exponentiation

Logical Operators

  • and
  • or
  • not

Note “and” and “or” are case-sensitive

Comparison operators

==, !=, >, <, >=, <=

Statements

Simple statements

Assignment

Call

return

Control Flow Statements

If Conditions

if…else

1
2
3
4
5
6
if some_var > 10:
    print("some_var is totally bigger than 10.")
elif some_var < 10:    # This elif clause is optional.
    print("some_var is smaller than 10.")
else:                  # This is optional too.
    print("some_var is indeed 10.")

case/switch

For loop

for

1
2
3
4
for animal in ["dog", "cat", "mouse"]:
    print("{} is a mammal".format(animal))
for i, value in enumerate(["dog", "cat", "mouse"]):
    print(i, value)
1
2
3
4
5
6
7
8
9
10
# "range(number)" returns an iterable of numbers from zero up to (but excluding) the given number
for i in range(4):
    print(i)
# "range(lower, upper)" returns an iterable of numbers
from the lower number to the upper number
for i in range(4, 8):
    print(i)
# "range(lower, upper, step)"
for i in range(4, 8, 2):
    print(i)

while

1
2
3
4
x = 0
while x < 4:
    print(x)
    x += 1

do…while

Exception handling

1
2
3
4
5
6
7
8
9
10
11
12
13
# Handle exceptions with a try/except block
try:
    # Use "raise" to raise an error
    raise IndexError("This is an index error")
except IndexError as e:
    pass                 # Refrain from this, provide a recovery (next example).
except (TypeError, NameError):
    pass                 # Multiple exceptions can be processed jointly.
else:                    # Optional clause to the try/except block. Must follow
                         # all except blocks.
    print("All good!")   # Runs only if the code in try raises no exceptions
finally:                 # Execute under all circumstances
    print("We can clean up resources here")

Functions

1
2
3
4
5
6
7
8
def add(x, y):
    print("x is {} and y is {}".format(x, y))
    return x + y

add(5, 6)

# Another way to call functions is with keyword arguments
add(y=6, x=5)  # Keyword arguments can arrive in any order.
1
2
3
4
5
# You can define functions that take a variable number of positional arguments
def varargs(*args):
    return args

varargs(1, 2, 3)
1
2
3
4
5
# You can define functions that take a variable number of keyword arguments, as well
def keyword_args(**kwargs):
    return kwargs

keyword_args(big="foot", loch="ness")

Expand arguments

1
2
3
all_the_args(*args)            # equivalent: all_the_args(1, 2, 3, 4)
all_the_args(**kwargs)         # equivalent: all_the_args(a=3, b=4)
all_the_args(*args, **kwargs)  # equivalent: all_the_args(1, 2, 3, 4, a=3, b=4)
1
2
3
4
5
6
7
8
9
# global scope
x = 5

def set_global_x(num):
    # global indicates that particular var lives in the global scope
    global x
    print(x)   # => 5
    x = num    # global var x is now set to 6
    print(x)

Nested function

1
2
3
4
5
6
7
def create_adder(x):
    def adder(y):
        return x + y
    return adder

add_10 = create_adder(10)
add_10(3)   # => 13

Anonymous functions

1
2
3
# There are also anonymous functions
(lambda x: x > 2)(3)                  # => True
(lambda x, y: x ** 2 + y ** 2)(2, 1)  # => 5

Modules

Python modules are just ordinary Python files. You can write your own, and import them. The name of the module is the same as the name of the file.

If you have a Python script named math.py in the same folder as your current script, the file math.py will be loaded instead of the built-in Python module. This happens because the local folder has priority over Python’s built-in libraries.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# You can import modules
import math
print(math.sqrt(16))  # => 4.0

# You can get specific functions from a module
from math import ceil, floor
print(ceil(3.7))   # => 4.0
print(floor(3.7))  # => 3.0

# You can import all functions from a module.
# Warning: this is not recommended
from math import *

# You can shorten module names
import math as m
math.sqrt(16) == m.sqrt(16)

Classes

Classes

Class members

  • attribute
    • class attribute (set by class_name.class_attribute = value)
    • instance attribute (initialized by initializer)
    • instance properties (Properties are special kind of attributes which have getter, setter and delete methods like get, set and delete methods.)
  • Methods
    • initializer
    • instance method (called by instances)
    • class method (called by instances)
    • static method (called by class_name.static_method())
    • getter
    • setter

Note that the double leading and trailing underscores denote objects or attributes that are used by Python but that live in user-controlled namespaces. Methods(or objects or attributes) like: __init__, __str__, __repr__ etc. are called special methods (or sometimes called dunder methods). You should not invent such names on your own.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
# We use the "class" statement to create a class
class Human:

    # A class attribute. It is shared by all instances of this class
    species = "H. sapiens"
    
    # Basic initializer
    def __init__(self, name):
        # Assign the argument to the instance's name attribute
        self.name = name

        # Initialize property
        self._age = 0
        
	# An instance method. All methods take "self" as the first argument
    def say(self, msg):
        print("{name}: {message}".format(name=self.name, message=msg))

    # Another instance method
    def sing(self):
        return 'yo... yo... microphone check... one two... one two...'
    
    # A class method is shared among all instances
    # They are called with the calling class as the first argument
    @classmethod
    def get_species(cls):
        return cls.species

    # A static method is called without a class or instance reference
    @staticmethod
    def grunt():
        return "*grunt*"
    
    # A property is just like a getter.
    @property
    def age(self):
        return self._age
    
    # This allows the property to be set
    @age.setter
    def age(self, age):
        self._age = age
        
	# This allows the property to be deleted
    @age.deleter
    def age(self):
        del self._age
1
2
3
4
5
6
7
# Instantiate a class
i = Human(name="Ian")
# Call instance method
i.say("hi")                     # "Ian: hi"

j = Human("Joel")
j.say("hello") 
1
2
3
4
5
6
# Call our class method
i.say(i.get_species())          # "Ian: H. sapiens"
# Change the class attribute (shared attribute)
Human.species = "H. neanderthalensis"
i.say(i.get_species())          # => "Ian: H. neanderthalensis"
j.say(j.get_species())          # => "Joel: H. neanderthalensis"
1
2
3
4
5
# Call the static method
print(Human.grunt())            # => "*grunt*"

# Static methods can be called by instances too
print(i.grunt())  
1
2
3
4
5
6
7
8
# Update the property for this instance
i.age = 42
# Get the property
i.say(i.age)                    # => "Ian: 42"
j.say(j.age)                    # => "Joel: 0"
# Delete the property
del i.age
# i.age

Inheritance

1
2
# Define Batman as a child that inherits from both Superhero and Bat
class Batman(Superhero, Bat):

Standard Library

I/O Streams and Files

Read

1
2
3
4
# Instead of try/finally to cleanup resources you can use a with statement
with open("myfile.txt") as f:
    for line in f:
        print(line)
1
2
3
4
# Reading from a file
with open('myfile1.txt', "r+") as file:
    contents = file.read()           # reads a string from a file
print(contents)
1
2
3
with open('myfile2.txt', "r+") as file:
    contents = json.load(file)       # reads a json object from a file
print(contents)

Write

1
2
3
4
# Writing to a file
contents = {"aa": 12, "bb": 21}
with open("myfile1.txt", "w+") as file:
    file.write(str(contents))

Advanced Topics

References

[1] Learn Python in Y minutes

[2] Python Tutorial

Contents
  1. 1. Getting Started
  2. 2. Variables and Data Types
    1. 2.1. Variables
    2. 2.2. Data Types
  3. 3. String and Array
    1. 3.1. String
    2. 3.2. Array
    3. 3.3. Tuple
    4. 3.4. Dict
    5. 3.5. Set
  4. 4. Expressions
  5. 5. Statements
    1. 5.1. Simple statements
    2. 5.2. Control Flow Statements
  6. 6. Functions
  7. 7. Modules
  8. 8. Classes
    1. 8.1. Classes
    2. 8.2. Inheritance
  9. 9. Standard Library
    1. 9.1. I/O Streams and Files
  10. 10. Advanced Topics
  11. 11. References