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}

Dictionary comprehensions (examples) # 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'}

Dictionary comprehensions (examples) # 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 def sum_squares(x, y): 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) def sum_squares(x, y): 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)

Variable number of arguments (examples) 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)

Variable number of arguments (examples) 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

Variable number of arguments (examples) # 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.

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

Names, Namespaces and Scope  Local namespace of a function x = 10 def print_x(): print(x) # prints 10

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

Names, Namespaces and Scope  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

Similar to Basics of Python programming (part 2)

Recently uploaded

Basics of Python programming (part 2)

Editor's Notes