This is the 3rd part of a multi-part series that teaches the basics of Python programming. It covers list and dict comprehensions, functions, modules and packages.

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

2. 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”]
}

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

4. What will be covered
 Recap of Parts 1 and 2
 import, Modules and Packages
 Python in action
 Note: get the code here:
https://dl.dropboxusercontent.com/u/10346356/session3.zip

5. 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
 Iterables are container objects capable of returning their elements one at a time
 Iterators implement the methods __iter__ and __next__

6. 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
 Iterables are container objects capable of returning their elements one at a time
 Iterators implement the methods __iter__ and __next__

7. 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
 Iterables are container objects capable of returning their elements one at a time
 Iterators implement the methods __iter__ and __next__

8. A little recap
>>> 2 + 2
4
>>> 4 / 2
2.0
>>> 4 > 2
True
>>> x = 1, 2
>>> x
(1, 2)

9. A little recap
>>> x = [1, 2]
>>> x
[1, 2]
>>> x = {1, 2}
>>> x
{1, 2}
>>> x = {"one": 1, "two": 2}
>>> x
{'two': 2, 'one': 1}

10. 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
 Iterables are container objects capable of returning their elements one at a time
 Iterators implement the methods __iter__ and __next__

11. A little recap
if x % 3 == 0 and x % 5 == 0:
return "FizzBuzz"
elif x % 3 == 0:
return "Fizz"
elif x % 5 == 0:
return "Buzz"
else:
return x

12. A little recap
colors = ["red", "green", "blue", "yellow", "purple"]
for color in colors:
if len(color) > 4:
print(color)
stack = [1, 2, 3]
while len(stack) > 0:
print(stack.pop())

13. 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
 Iterables are container objects capable of returning their elements one at a time
 Iterators implement the methods __iter__ and __next__

14. A little recap
>>> colors = ["red", "green", "blue", "yellow", "purple"]
>>> colors_iter = colors.__iter__()
>>> colors_iter
<list_iterator object at 0x100c7a160>
>>> colors_iter.__next__()
'red'
…
>>> colors_iter.__next__()
'purple'
>>> colors_iter.__next__()
Traceback (most recent call last): File "<stdin>", line 1, in
<module>
StopIteration

15. A little recap
colors = [(0, "red"), (1, "blue"), (2, "green"), (3, "yellow")]
for index, color in colors:
print(index, " --> ", color)
colors = ["red", "blue", "green", "yellow", "purple"]
for index, color in enumerate(colors):
print(index, " --> ", color)

16. A little recap
 List comprehensions
 Dictionary comprehensions
 Functions
 Positional Arguments
 Keyword Arguments
 Default parameters
 Variable number of arguments

17. A little recap
colors = ["red", "green", "blue", "yellow", "purple"]
new_colors = []
for color in colors:
if len(color) > 4:
new_colors.append(color)
new_colors = [color for color in colors if len(color) > 4]

18. Challenge
 Given a list of colors, create a new list with all the colors in uppercase. Use list
comprehensions.
colors = ["red", "green", "blue", "yellow", "purple"]
upper_colors = []
for color in colors:
upper_colors.append(color.upper())

19. A little recap
 List comprehensions
 Dictionary comprehensions
 Functions
 Positional Arguments
 Keyword Arguments
 Default parameters
 Variable number of arguments

20. A little recap
squares = {}
for i in range(10):
squares[i] = i**2
squares = {i:i**2 for i in range(10)}
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9:
81}

21. Challenge
 Given a list of colors, create a dictionary where each key is a color and the value is
the color written backwards. Use dict comprehensions.
colors = ["red", "green", "blue", "yellow", "purple"]
backwards_colors = {}
for color in colors:
backwards_colors[color] = color[::-1]

22. A little recap
 List comprehensions
 Dictionary comprehensions
 Functions
 Positional Arguments
 Keyword Arguments
 Default parameters
 Variable number of arguments

23. A little recap
def say_hello():
print("Hello")
def add_squares(a, b):
return a**2 + b**2
>>> add_squares(2, 3)
13
def add_squares(a, b=3):
return a**2 + b**2
>>> add_squares(2)
13

24. A little recap
def add_squares(a, b):
return a**2 + b**2
>>> add_squares(b=3, a=2)
13

25. A little recap
def add_aquares(*args):
if len(args) == 2:
return args[0]**2 + args[1]**2
>>> add_squares(2, 3)
13

26. A little recap
def add_squares(**kwargs):
if len(kwargs) == 2:
return kwargs["a"]**2 + kwargs["b"]**2
>>> add_squares(a=2, b=3)
13

27. Challenge
 Define a function that turns a string into a list of int (operands) and strings (operators) and returns
the list.
>>> _convert_expression("4 3 +")
[4, 3, "+"]
>>> _convert_expression("4 3 + 2 *")
[4, 3, "+", 2, "*"]
 Hints:
 “a b”.split(“ “) = [“a”, “b”]
 “a”.isnumeric() = False
 int(“2”) = 2
 Kudos for who solves in one line using lambdas and list comprehensions.

28. Challenge
 RPN = Reverse Polish Notation
 4 3 + (7)
 4 3 + 2 * (14)
 Extend RPN calculator to support the operators *, / and sqrt (from math module).
import math
print(math.sqrt(4))

29. Modules and Packages
 A module is a file with definitions and statements
 It’s named after the file.
 Modules are imported with import statement
 import <module>
 from <module> import <name1>
 from <module> import <name1>, <name2>
 import <module> as <new_module_name>
 from <module> import <name1> as <new_name1>
 from <module> import *

30. Modules and Packages
 A package is a directory with a special file __init__.py (the file can be empty, and
it’s also not mandatory to exist)
 The file __init__.py is executed when importing a package.
 Packages can contain other packages.

31. Modules and Packages
api/
__init__.py
rest.py
server.py
services/
__init__.py
rpn.py
hello.py
$ python -m api.server

32. Modules and Packages
 import api
 from api import rest
 import api.services.rpn
 from api.services.hello import say_hello

33. Challenge
 Extend functionalities of the RESTful API:
 Add a handler for http://localhost:8080/calculate
 This handler should accept only the POST method.
 Put all the pieces together in the rpn module.

34. 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

35. 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