Upload
pedro-rodrigues
View
182
Download
2
Embed Size (px)
Citation preview
Introduction to the basics of Python programming(PART 2)by Pedro Rodrigues ([email protected])
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).
>>> 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 matterdef 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 omitteddef 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.082762530298219102.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 namespacex = 10 print(x)
Local namespace of a functionx = 10
def print_x(): x = 5 print(x) # prints 5
Names, Namespaces and Scope
Local namespace of a functionx = 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