References¶
1) Data School By Kevin Markham (YouTube)¶
2) Sebastian Raschka : Python Machine Learning (Book)¶
3) 'Think Python' by Allen B. Downey (Book)¶
4) The Python Tutorial¶
In [ ]:
In [1]:
# Python and OOP (from programiz.com)
In [2]:
#playing with Markdown
In [ ]:
1. Imports¶
In [3]:
# 'generic import' of math module
import math
math.sqrt(25)
Out[3]:
In [4]:
# import a function
from math import sqrt
sqrt(25) # no longer have to reference the module
Out[4]:
In [5]:
# import multiple functions at once
from math import cos, floor
In [6]:
# import all functions in a module (generally discouraged)
from csv import *
In [7]:
# define an alias
import datetime as dt
In [8]:
# show all functions in math module
print(dir(math))
2. Data Types¶
Determine the type of an object:
In [9]:
type(2)
Out[9]:
In [10]:
type(2.0)
Out[10]:
In [11]:
type('two')
Out[11]:
In [12]:
type(True)
Out[12]:
In [13]:
type(None)
Out[13]:
Check if an object is of a given type:
In [14]:
isinstance(2.0, int)
Out[14]:
In [15]:
isinstance(2.0, (int, float))
Out[15]:
Convert an object to a given type:
In [16]:
float(2)
Out[16]:
In [17]:
int(2.9)
Out[17]:
In [18]:
str(2.9)
Out[18]:
Zero, None, and empty containers are converted to False:
In [19]:
bool(0)
Out[19]:
In [20]:
bool(None)
Out[20]:
In [21]:
bool('a')
Out[21]:
In [22]:
bool(7)
Out[22]:
In [23]:
bool('') # empty string
Out[23]:
In [24]:
bool([]) # empty list
Out[24]:
In [25]:
bool({}) # empty dictionary
Out[25]:
Non-empty containers and non-zeros are converted to True:
In [26]:
bool(2)
Out[26]:
In [27]:
bool('two')
Out[27]:
In [28]:
bool([2])
Out[28]:
3. Math¶
In [29]:
10 + 4
Out[29]:
In [30]:
10 - 4
Out[30]:
In [31]:
10 * 4
Out[31]:
In [32]:
10 ** 4 # exponent
Out[32]:
In [33]:
5 % 4 # modulo - computes the remainder
Out[33]:
In [34]:
# Python 2: returns 2 (because both types are 'int')
# Python 3: returns 2.5
10 / 4
Out[34]:
In [35]:
10 / 4
Out[35]:
4. Comparisons and Boolean Operations¶
Assignment statement:
In [36]:
x = 5
Comparisons:
In [37]:
x > 3
Out[37]:
In [38]:
x >= 3
Out[38]:
In [39]:
x != 3
Out[39]:
In [40]:
x == 5
Out[40]:
Boolean operations:
In [41]:
5 > 3 and 6 > 3
Out[41]:
In [42]:
5 > 3 or 5 < 3
Out[42]:
In [43]:
not False
Out[43]:
In [44]:
False or True
Out[44]:
In [45]:
False and True
Out[45]:
In [46]:
False or not False and True # evaluation order: not, and, or
Out[46]:
5. Conditional Statements¶
In [47]:
x=1
In [48]:
# if statement
if x > 0:
print('positive')
In [49]:
# if/else statement
if x > 0:
print('positive')
else:
print('zero or negative')
In [50]:
# if/elif/else statement
if x > 0:
print('positive')
elif x == 0:
print('zero')
else:
print('negative')
In [51]:
# single-line if statement (sometimes discouraged)
if x > 0: print('positive')
In [52]:
# single-line if/else statement (sometimes discouraged), known as a 'ternary operator'
'positive' if x > 0 else 'zero or negative'
Out[52]:
6. Lists¶
- List properties: ordered, iterable, mutable, can contain multiple data types
In [53]:
# create an empty list (two ways)
empty_list = []
empty_list = list()
In [54]:
# create a list
simpsons = ['homer', 'marge', 'bart']
Examine a list:
In [55]:
# print element 0
simpsons[0]
Out[55]:
In [56]:
len(simpsons)
Out[56]:
Modify a list (does not return the list):
In [57]:
# append element to end
simpsons.append('lisa')
simpsons
Out[57]:
In [58]:
# append multiple elements to end
simpsons.extend(['itchy', 'scratchy'])
simpsons
Out[58]:
In [59]:
# insert element at index 0 (shifts everything right)
simpsons.insert(0, 'maggie')
simpsons
Out[59]:
In [60]:
# search for first instance and remove it
simpsons.remove('bart')
simpsons
Out[60]:
In [61]:
# remove element 0 and return it
simpsons.pop(0)
Out[61]:
In [62]:
# remove element 0 (does not return it)
del simpsons[0]
simpsons
Out[62]:
In [63]:
# replace element 0
simpsons[0] = 'krusty'
simpsons
Out[63]:
In [64]:
# concatenate lists (slower than 'extend' method)
neighbors = simpsons + ['ned', 'rod', 'todd']
neighbors
Out[64]:
Find elements in a list:
In [65]:
# counts the number of instances
simpsons.count('lisa')
Out[65]:
In [66]:
# returns index of first instance
simpsons.index('itchy')
Out[66]:
List slicing:
In [67]:
weekdays = ['mon', 'tues', 'wed', 'thurs', 'fri']
In [68]:
# element 0
weekdays[0]
Out[68]:
In [69]:
# elements 0 (inclusive) to 3 (exclusive)
weekdays[0:3]
Out[69]:
In [70]:
# starting point is implied to be 0
weekdays[:3]
Out[70]:
In [71]:
# elements 3 (inclusive) through the end
weekdays[3:]
Out[71]:
In [72]:
# last element
weekdays[-1]
Out[72]:
In [73]:
# every 2nd element (step by 2)
weekdays[::2]
Out[73]:
In [74]:
# backwards (step by -1)
weekdays[::-1]
Out[74]:
In [75]:
weekdays[::-2]
Out[75]:
In [76]:
# alternative method for returning the list backwards
list(reversed(weekdays))
Out[76]:
Sort a list in place (modifies but does not return the list):
In [77]:
simpsons.sort()
simpsons
Out[77]:
In [78]:
# sort in reverse
simpsons.sort(reverse=True)
simpsons
Out[78]:
In [79]:
# sort by a key
simpsons.sort(key=len)
simpsons
Out[79]:
Return a sorted list (does not modify the original list):
In [80]:
sorted(simpsons)
Out[80]:
In [81]:
sorted(simpsons, reverse=True)
Out[81]:
In [82]:
sorted(simpsons, key=len)
Out[82]:
Insert into an already sorted list, and keep it sorted:
In [83]:
num = [10, 20, 40, 50]
from bisect import insort
insort(num, 30)
num
Out[83]:
Object references and copies:
In [84]:
# create a second reference to the same list
same_num = num
In [85]:
# modifies both 'num' and 'same_num'
same_num[0] = 0
print(num)
print(same_num)
In [86]:
# copy a list (two ways)
new_num = num[:]
new_num = list(num)
Examine objects:
In [87]:
num is same_num # checks whether they are the same object
Out[87]:
In [88]:
num is new_num
Out[88]:
In [89]:
num == same_num # checks whether they have the same contents
Out[89]:
In [90]:
num == new_num
Out[90]:
7. Tuples¶
- Tuple properties: ordered, iterable, immutable, can contain multiple data types
- Like lists, but they don't change size
In [91]:
# create a tuple directly
digits = (0, 1, 'two')
In [92]:
# create a tuple from a list
digits = tuple([0, 1, 'two'])
In [93]:
# trailing comma is required to indicate it's a tuple
zero = (0,)
Examine a tuple:
In [94]:
digits[2]
Out[94]:
In [95]:
len(digits)
Out[95]:
In [96]:
# counts the number of instances of that value
digits.count(0)
Out[96]:
In [97]:
# returns the index of the first instance of that value
digits.index(1)
Out[97]:
Modify a tuple:
In [98]:
# elements of a tuple cannot be modified (this would throw an error)
# digits[2] = 2
In [99]:
# concatenate tuples
digits = digits + (3, 4)
digits
Out[99]:
Other tuple operations:
In [100]:
# create a single tuple with elements repeated (also works with lists)
(3, 4) * 2
Out[100]:
In [101]:
# sort a list of tuples
tens = [(20, 60), (10, 40), (20, 30)]
sorted(tens) # sorts by first element in tuple, then second element
Out[101]:
In [102]:
# tuple unpacking
bart = ('male', 10, 'simpson') # create a tuple
(sex, age, surname) = bart # assign three values at once
print(sex)
print(age)
print(surname)
8. Strings¶
- String properties: iterable, immutable
In [103]:
# convert another data type into a string
s = str(42)
s
Out[103]:
In [104]:
# create a string directly
s = 'I like you'
Examine a string:
In [105]:
s[0]
Out[105]:
In [106]:
len(s)
Out[106]:
String slicing is like list slicing:
In [107]:
s[:6]
Out[107]:
In [108]:
s[7:]
Out[108]:
In [109]:
s[-1]
Out[109]:
Basic string methods (does not modify the original string):
In [110]:
s.lower()
Out[110]:
In [111]:
s.upper()
Out[111]:
In [112]:
s.startswith('I')
Out[112]:
In [113]:
s.endswith('you')
Out[113]:
In [114]:
# checks whether every character in the string is a digit
s.isdigit()
Out[114]:
In [115]:
# returns index of first occurrence, but doesn't support regex
s.find('like')
Out[115]:
In [116]:
# returns -1 since not found
s.find('hate')
Out[116]:
In [117]:
# replaces all instances of 'like' with 'love'
s.replace('like', 'love')
Out[117]:
Split a string:
In [118]:
# split a string into a list of substrings separated by a delimiter
s.split(' ')
Out[118]:
In [119]:
# equivalent (since space is the default delimiter)
s.split()
Out[119]:
In [120]:
s2 = 'a, an, the'
s2.split(',')
Out[120]:
Join or concatenate strings:
In [121]:
# join a list of strings into one string using a delimiter
stooges = ['larry', 'curly', 'moe']
' '.join(stooges)
Out[121]:
In [122]:
# concatenate strings
s3 = 'The meaning of life is'
s4 = '42'
s3 + ' ' + s4
Out[122]:
Remove whitespace from the start and end of a string:
In [123]:
s5 = ' ham and cheese '
s5.strip()
Out[123]:
String substitutions:
In [124]:
# old way
'raining %s and %s' % ('cats', 'dogs')
Out[124]:
In [125]:
# new way
'raining {} and {}'.format('cats', 'dogs')
Out[125]:
In [126]:
# new way (using named arguments)
'raining {arg1} and {arg2}'.format(arg1='cats', arg2='dogs')
Out[126]:
String formatting (more examples):
In [127]:
# use 2 decimal places
'pi is {:.2f}'.format(3.14159)
Out[127]:
Normal strings versus raw strings:
In [128]:
# normal strings allow for escaped characters
print('first line\nsecond line')
In [129]:
# raw strings treat backslashes as literal characters
print(r'first line\nfirst line')
9. Dictionaries¶
- Dictionary properties: unordered, iterable, mutable, can contain multiple data types
- Made of key-value pairs
- Keys must be unique, and can be strings, numbers, or tuples
- Values can be any type
In [130]:
# create an empty dictionary (two ways)
empty_dict = {}
empty_dict = dict()
In [131]:
# create a dictionary (two ways)
family = {'dad':'homer', 'mom':'marge', 'size':6}
family = dict(dad='homer', mom='marge', size=6)
family
Out[131]:
In [132]:
# convert a list of tuples into a dictionary
list_of_tuples = [('dad', 'homer'), ('mom', 'marge'), ('size', 6)]
family = dict(list_of_tuples)
family
Out[132]:
Examine a dictionary:
In [133]:
# pass a key to return its value
family['dad']
Out[133]:
In [134]:
# return the number of key-value pairs
len(family)
Out[134]:
In [135]:
# check if key exists in dictionary
'mom' in family
Out[135]:
In [136]:
# dictionary values are not checked
'marge' in family
Out[136]:
In [137]:
# returns a list of keys (Python 2) or an iterable view (Python 3)
family.keys()
Out[137]:
In [138]:
# returns a list of values (Python 2) or an iterable view (Python 3)
family.values()
Out[138]:
In [139]:
# returns a list of key-value pairs (Python 2) or an iterable view (Python 3)
family.items()
Out[139]:
Modify a dictionary (does not return the dictionary):
In [140]:
# add a new entry
family['cat'] = 'snowball'
family
Out[140]:
In [141]:
# edit an existing entry
family['cat'] = 'snowball ii'
family
Out[141]:
In [142]:
# delete an entry
del family['cat']
family
Out[142]:
In [143]:
# dictionary value can be a list
family['kids'] = ['bart', 'lisa']
family
Out[143]:
In [144]:
# remove an entry and return the value
family.pop('dad')
Out[144]:
In [145]:
# add multiple entries
family.update({'baby':'maggie', 'grandpa':'abe'})
family
Out[145]:
Access values more safely with get:
In [146]:
family['mom']
Out[146]:
In [147]:
# equivalent to a dictionary lookup
family.get('mom')
Out[147]:
In [148]:
# this would throw an error since the key does not exist
# family['grandma']
In [149]:
# return None if not found
family.get('grandma')
In [150]:
# provide a default return value if not found
family.get('grandma', 'not found')
Out[150]:
Access a list element within a dictionary:
In [151]:
family['kids'][0]
Out[151]:
In [152]:
family['kids'].remove('lisa')
family
Out[152]:
String substitution using a dictionary:
In [153]:
'youngest child is %(baby)s' % family
Out[153]:
10. Sets¶
- Set properties: unordered, iterable, mutable, can contain multiple data types
- Made of unique elements (strings, numbers, or tuples)
- Like dictionaries, but with keys only (no values)
In [154]:
# create an empty set
empty_set = set()
In [155]:
# create a set directly
languages = {'python', 'r', 'java'}
In [156]:
# create a set from a list
snakes = set(['cobra', 'viper', 'python'])
Examine a set:
In [157]:
len(languages)
Out[157]:
In [158]:
'python' in languages
Out[158]:
Set operations:
In [159]:
# intersection
languages & snakes
Out[159]:
In [160]:
# union
languages | snakes
Out[160]:
In [161]:
# set difference
languages - snakes
Out[161]:
In [162]:
# set difference
snakes - languages
Out[162]:
Modify a set (does not return the set):
In [163]:
# add a new element
languages.add('sql')
languages
Out[163]:
In [164]:
# try to add an existing element (ignored, no error)
languages.add('r')
languages
Out[164]:
In [165]:
# remove an element
languages.remove('java')
languages
Out[165]:
In [166]:
# try to remove a non-existing element (this would throw an error)
# languages.remove('c')
In [167]:
# remove an element if present, but ignored otherwise
languages.discard('c')
languages
Out[167]:
In [168]:
# remove and return an arbitrary element
languages.pop()
Out[168]:
In [169]:
# remove all elements
languages.clear()
languages
Out[169]:
In [170]:
# add multiple elements (can also pass a set)
languages.update(['go', 'spark'])
languages
Out[170]:
Get a sorted list of unique elements from a list:
In [171]:
sorted(set([9, 0, 2, 1, 0]))
Out[171]:
11. Defining Functions¶
Define a function with no arguments and no return values:
In [172]:
def print_text():
print('this is text')
In [173]:
# call the function
print_text()
Define a function with one argument and no return values:
In [174]:
def print_this(x):
print(x)
In [175]:
# call the function
print_this(3)
In [176]:
# prints 3, but doesn't assign 3 to n because the function has no return statement
n = print_this(3)
Define a function with one argument and one return value:
In [177]:
def square_this(x):
return x**2
In [178]:
# include an optional docstring to describe the effect of a function
def square_this(x):
"""Return the square of a number."""
return x**2
In [179]:
# call the function
square_this(3)
Out[179]:
In [180]:
# assigns 9 to var, but does not print 9
var = square_this(3)
Define a function with two 'positional arguments' (no default values) and one 'keyword argument' (has a default value):
In [181]:
def calc(a, b, op='add'):
if op == 'add':
return a + b
elif op == 'sub':
return a - b
else:
print('valid operations are add and sub')
In [182]:
# call the function
calc(10, 4, op='add')
Out[182]:
In [183]:
# unnamed arguments are inferred by position
calc(10, 4, 'add')
Out[183]:
In [184]:
# default for 'op' is 'add'
calc(10, 4)
Out[184]:
In [185]:
calc(10, 4, 'sub')
Out[185]:
In [186]:
calc(10, 4, 'div')
Use pass as a placeholder if you haven't written the function body:
In [187]:
def stub():
pass
Return two values from a single function:
In [188]:
def min_max(nums):
return min(nums), max(nums)
In [189]:
# return values can be assigned to a single variable as a tuple
nums = [1, 2, 3]
min_max_num = min_max(nums)
min_max_num
Out[189]:
In [190]:
# return values can be assigned into multiple variables using tuple unpacking
min_num, max_num = min_max(nums)
print(min_num)
print(max_num)
12. Anonymous (Lambda) Functions¶
- Primarily used to temporarily define a function for use by another function
In [191]:
# define a function the "usual" way
def squared(x):
return x**2
In [192]:
# define an identical function using lambda
squared = lambda x: x**2
Sort a list of strings by the last letter:
In [193]:
# without using lambda
simpsons = ['homer', 'marge', 'bart']
def last_letter(word):
return word[-1]
sorted(simpsons, key=last_letter)
Out[193]:
In [194]:
# using lambda
sorted(simpsons, key=lambda word: word[-1])
Out[194]:
13. For Loops and While Loops¶
range returns a list of integers (Python 2) or a sequence (Python 3):
In [195]:
# includes the start value but excludes the stop value
range(0, 3)
Out[195]:
In [196]:
# default start value is 0
range(3)
Out[196]:
In [197]:
# third argument is the step value
range(0, 5, 2)
Out[197]:
for loops:
In [198]:
# not the recommended style
fruits = ['apple', 'banana', 'cherry']
for i in range(len(fruits)):
print(fruits[i].upper())
In [199]:
# recommended style
for fruit in fruits:
print(fruit.upper())
In [200]:
# iterate through two things at once (using tuple unpacking)
family = {'dad':'homer', 'mom':'marge', 'size':6}
for key, value in family.items():
print(key, value)
In [201]:
# use enumerate if you need to access the index value within the loop
for index, fruit in enumerate(fruits):
print(index, fruit)
for/else loop:
In [202]:
for fruit in fruits:
if fruit == 'banana':
print('Found the banana!')
break # exit the loop and skip the 'else' block
else:
# this block executes ONLY if the for loop completes without hitting 'break'
print("Can't find the banana")
while loop:
In [203]:
count = 0
while count < 5:
print('This will print 5 times')
count += 1 # equivalent to 'count = count + 1'
14. Comprehensions¶
List comprehension:
In [204]:
# for loop to create a list of cubes
nums = [1, 2, 3, 4, 5]
cubes = []
for num in nums:
cubes.append(num**3)
cubes
Out[204]:
In [205]:
# equivalent list comprehension
cubes = [num**3 for num in nums]
cubes
Out[205]:
In [206]:
# for loop to create a list of cubes of even numbers
cubes_of_even = []
for num in nums:
if num % 2 == 0:
cubes_of_even.append(num**3)
cubes_of_even
Out[206]:
In [207]:
# equivalent list comprehension
# syntax: [expression for variable in iterable if condition]
cubes_of_even = [num**3 for num in nums if num % 2 == 0]
cubes_of_even
Out[207]:
In [208]:
# for loop to cube even numbers and square odd numbers
cubes_and_squares = []
for num in nums:
if num % 2 == 0:
cubes_and_squares.append(num**3)
else:
cubes_and_squares.append(num**2)
cubes_and_squares
Out[208]:
In [209]:
# equivalent list comprehension (using a ternary expression)
# syntax: [true_condition if condition else false_condition for variable in iterable]
cubes_and_squares = [num**3 if num % 2 == 0 else num**2 for num in nums]
cubes_and_squares
Out[209]:
In [210]:
# for loop to flatten a 2d-matrix
matrix = [[1, 2], [3, 4]]
items = []
for row in matrix:
for item in row:
items.append(item)
items
Out[210]:
In [211]:
# equivalent list comprehension
items = [item for row in matrix
for item in row]
items
Out[211]:
Set comprehension:
In [212]:
fruits = ['apple', 'banana', 'cherry']
unique_lengths = {len(fruit) for fruit in fruits}
unique_lengths
Out[212]:
Dictionary comprehension:
In [213]:
fruit_lengths = {fruit:len(fruit) for fruit in fruits}
fruit_lengths
Out[213]:
In [214]:
fruit_indices = {fruit:index for index, fruit in enumerate(fruits)}
fruit_indices
Out[214]:
In [ ]:
In [ ]:
In [ ]:
In [ ]:
In [ ]:
In [ ]: