Basics of Python programming (part 2)

Introduction to the basics of
Python programming
(PART 2)
by Pedro Rodrigues (pedro@startacareerwithpython.com)

A little about me
{
“Name”: “Pedro Rodrigues”,
“Origin”: {“Country”: “Angola”, “City”: “Luanda”},
“Lives”: [“Netherlands”, 2013],
“Past”: [“CTO”, “Senior Backend Engineer”],
“Present”: [“Freelance Software Engineer”, “Coach”],
“Other”: [“Book author”, “Start a Career with Python”]
}

Why this Meetup Group?
 Promote the usage of Python
 Gather people from different industries and backgrounds
 Teach and Learn

What will be covered
 List and Dictionary comprehensions
 Functions
 Positional arguments
 Keyword arguments
 Default parameter values
 Variable number of arguments
 Names, namespaces and scope

A little recap
 Python is an interpreted language (CPython is the reference interpreter)
 Variables are names bound to objects stored in memory
 Data Types: immutable or mutable
 Data Types: Numbers (int, float, bool), Sequences (str, tuple, list, bytes, bytearray),
set, dict
 Control Flow: if statement, for loop, while loop
 Indentation determines whether a statement belongs to a code block or not
 Iterables are container objects capable of returning their elements one at a time
 Iterators implement the methods __iter__ and __next__

List comprehensions
 Concise way to create lists
 Each element is a the result of a transformation applied to the original element
 Regular way of building lists:
new_list = []
for elem in some_sequence:
new_list.append(do_something(elem))
 With list comprehension:
new_list = [do_something(elem) for elem in some_sequence]

List comprehensions (examples)
names = ["John", "Mary", "Russell", "Devon", "Elizabeth"]
new_names = []
for name in names:
if len(name) > 4:
new_names.append(name)
>>> names = ["John", "Mary", "Russell", "Devon", "Elizabeth"]
>>> new_names = [name for name in names if len(name) > 4]
>>> new_names
['Russell', 'Devon', 'Elizabeth']

List comprehensions (examples)
pairs = []
for i in range(3):
for j in range(3):
if i != j:
pairs.append((i, j))
>>> pairs = [(i, j) for i in range(3) for j in range(3) if i != j]
>>> pairs
[(0, 1), (0, 2), (1, 0), (1, 2), (2, 0), (2, 1)]

List comprehensions (challenge)
 Use split and sorted to print a sorted list of strings read from the standard input. Use a
list comprehension for build a list where the strings are in lowercase.
 Strings in the standard input are separated by commas (no spaces)
 Sample input: THIs,is,A,strING,WITH,COMmas
 Sample output: ['a', 'commas', 'is', 'string', 'this', 'with']
>>> "Hello,World,how,are,you".split(",")
['Hello', 'World', 'how', 'are', 'you']
>>> sorted(["b", "z", "a", "c", "l"])
['a', 'b', 'c', 'l', 'z']

Dictionary comprehensions
 Concise way to create dictionaries
 Keys and/or Values are the result of applying transformations to elements in the original sequence
 Regular way of building a dictionary:
d = {}
for k, v in some_seq:
key = do_something(k)
value = do_something(v)
d[key] = value
 With dict comprehension:
d = {do_something(k): do_something(v) for k, v in some_seq}

Dictionary comprehensions (examples)
d = {}
for i in range(2, 11, 2):
d[i] = i**2
d = {i: i**2 for i in range(2, 11, 2)}
>>> d
{8: 64, 2: 4, 4: 16, 10: 100, 6: 36}

# example: name=Pedro age=34
info = input("> ")
info_list = [item.split("=") for item in info.split(" ")]
info_dict = {}
for k, v in info_list:
key = k.capitalize()
d[key] = v
>>> info_dict
{'Age': '34', 'Name': 'Pedro'}

# With dict comprehension
>>> info = input("> ")
>>> d = {k.capitalize(): v for k, v in [item.split("=") for item in info.split(" ")]}
>>> d
{'Age': '34', 'Name': 'Pedro'}

Dictionary comprehensions (challenge)
 Build a dictionary where the keys are in lowercase and the values are integers,
from a string read from the standard input
 Sample input: John=28 Martha=32 Stewart=46 Peter=30
 Sample output:
{'stewart': 46, 'peter': 30, 'john': 28, 'martha': 32}

Functions
 Callable data type
 Control Flow construct
def function_name(params_list):
suite
def print_hello_world():
print("Hello")
print("World")

Positional arguments
def function_name(param1, param2, ...):
# do something with param1 and/or param2
>>> function_name(arg1, arg2)

Positional arguments (examples)
def sum_squares(x, y):
return x**2 + y**2
>>> sum_squares(2, 3)
13
>>> numbers = [2, 3]
>>> sum_squares(*numbers)
13
>>> sum_squares(*[2, 3])
13

Challenge
 Read coordinates from standard input and print the distance between the two points.
Use list comprehension and sequence unpacking.
 Define a function that takes 4 integers (x1, y1, x2, y2) and returns the distance between
two points: Point 1 (x1, y1), Point 2 (x2, y2).
 (𝑥2 − 𝑥1)2+(𝑦2 − 𝑦1)2
>>> import math
>>> math.sqrt(16)
4.0
 Sample input: 1 3 7 4
 Sample output: 6.082762530298219

Challenge
 Sample input: 1 3 7 4
 Sample output: 6.082762530298219
def distance(x1, y1, x2, y2):
...
# coordinates = [1, 3, 7, 4]
>>> print(distance(*coordinates)) # coordinates is a list
>>> 6.082762530298219

Keyword arguments
 The order of the arguments doesn’t matter
return x**2 + y**2
>>> sum_squares(y=3, x=2)
13
 You cannot have a positional argument after a keyword argument
>>> sum_squares(y=3, 2)

Keyword arguments (examples)
return x**2 + y**2
>>> numbers = {"x": 2, "y": 3}
>>> sum_squares(**numbers)
13
>>> sum_squares(**{"x": 2, "y": 3})
13

Default parameter values
 For parameters with default value, the corresponding argument can be omitted
def sum_squares(x, y=3):
return x**2 + y**2
>>> sum_squares(2)
13
 After the first parameter with default value, all other parameters must have default
value
# Wrong!
def sum_squares(x=2, y):
return x**2 + y**2

Default parameter values
 Be careful with mutable default values!
names = ["John", "Louise"]
def print_hello(n=names):
for name in n:
print("Hello, ", name)
names.append("Something")
>>> print_hello()
Hello, John
Hello, Louise
>>> names
['John', 'Louise', 'Something']

Variable number of arguments
def function_name(*args, **kwargs):
pass
 args is initialized as a tuple with positional arguments
 kwargs is initialized as a dictionary with keyword arguments
 The words args and kwargs are just a convention, they are not reserved in
Python.

Variable number of arguments (examples)
def sum_squares(*args):
if len(args) == 2:
return args[0]**2 + args[1]**2
else:
return args
>>> sum_squares(4, 5) # args = (4, 5)
41
>>> sum_squares(6, "Hello", 7) # args = (6, "Hello", 7)
(6, "Hello", 7)

def sum_squares(x, *args):
if len(args) == 1:
return x**2 + args[0]**2
else:
return args
>>> sum_squares(4, 5) # args = (5,)
41
>>> sum_squares(6, "Hello", 7) # args = ("Hello", 7)
("Hello", 7)

def distance(x1, y1, x2, y2):
return math.sqrt((int(x2)-int(x1))**2 + (int(y2)-int(y1))**2)
def calculate_distance(**kwargs):
if len(kwargs) == 4:
return distance(**kwargs)
else:
return kwargs

# kwargs = {"x1": 1, "y1": 3, "x2": 7, "y2": 4}
>>> calculate_distance(x1=1, y1=3, x2=7, y2=4)
6.082762530298219

Challenge
 Sample input: x1=1 y1=3 x2=7 y2=4, x1=13 y1=10 x2=109 y2=45
 Sample output:
6.082762530298219
102.18121158021175
 Use dict comprehension and unpack the dictionary in distance.

Names, Namespaces and Scope
 Namespace: place where the binding between names and objects are stored.
 Different namespaces: built-in, global module namespace, local namespace for
a function, objects namespace.
 Scope is a text region that determines whether a namespace is available or not.
 Scope influences name resolution.

 Global module namespace
x = 10
print(x)
 Local namespace of a function
x = 10
def print_x():
x = 5
print(x) # prints 5

 Local namespace of a function
x = 10
def print_x():
print(x) # prints 10

 People coming from other languages, beware of for loops!
>>> for i in range(3):
... print(i)
...
0
1
2
>>> print(i)
2

 Namespaces have different life times:
 Local namespace is created when a function is called and destroyed when the function
returns.
 Global module namespace is created when the module definition is read in.
 Built-in namespace is created when the interpreter starts and is never destroyed during
the program execution.
 Global namespace of a function is the global namespace of the module where the
function was defined.

Reading material
 List comprehensions: https://docs.python.org/3.5/tutorial/datastructures.html#list-
comprehensions
 Dict comprehensions:
https://docs.python.org/3.5/tutorial/datastructures.html#dictionaries
 Functions and parameters:
https://docs.python.org/3.5/reference/compound_stmts.html#function-definitions
 Names, Namespaces and Scopes:
https://docs.python.org/3.5/tutorial/classes.html#a-word-about-names-and-
objects

More resources
 Python Tutorial: https://docs.python.org/3/tutorial/index.html
 Python Language Reference: https://docs.python.org/3/reference/index.html
 Slack channel: https://startcareerpython.slack.com/
 Start a Career with Python newsletter: https://www.startacareerwithpython.com/
 Book: Start a Career with Python
 Book 15% off (NZ6SZFBL): https://www.createspace.com/6506874

Basics of Python programming (part 2)

More Related Content

What's hot (20)

Similar to Basics of Python programming (part 2) (20)

Recently uploaded (20)

Basics of Python programming (part 2)

Editor's Notes