# 'generic import' of math moduleimportmathmath.sqrt(25)

# import a functionfrommathimportsqrtsqrt(25)# no longer have to reference the module

# import multiple functions at oncefrommathimportcos,floor

# import all functions in a module (generally discouraged)fromcsvimport*

# define an aliasimportdatetimeasdt

# show all functions in math moduleprint(dir(math))

type(2)

type(2.0)

type('two')

type(True)

type(None)

isinstance(2.0,int)

isinstance(2.0,(int,float))

float(2)

int(2.9)

str(2.9)

bool(0)

bool(None)

bool('')# empty string

bool([])# empty list

bool({})# empty dictionary

bool(2)

bool('two')

bool([2])

10+4

10-4

10*4

10**4# exponent

5%4# modulo - computes the remainder

# Python 2: returns 2 (because both types are 'int')# Python 3: returns 2.510/4

10/float(4)

# force '/' in Python 2 to perform 'true division' (unnecessary in Python 3)from__future__importdivision

10/4# true division

10//4# floor division

x=5

x>3

x>=3

x!=3

x==5

5>3and6>3

5>3or5<3

notFalse

FalseornotFalseandTrue# evaluation order: not, and, or

# if statementifx>0:print('positive')

# if/else statementifx>0:print('positive')else:print('zero or negative')

# if/elif/else statementifx>0:print('positive')elifx==0:print('zero')else:print('negative')

# single-line if statement (sometimes discouraged)ifx>0:print('positive')

# single-line if/else statement (sometimes discouraged), known as a 'ternary operator''positive'ifx>0else'zero or negative'

# create an empty list (two ways)empty_list=[]empty_list=list()

# create a listsimpsons=['homer','marge','bart']

# print element 0simpsons[0]

len(simpsons)

# append element to endsimpsons.append('lisa')simpsons

# append multiple elements to endsimpsons.extend(['itchy','scratchy'])simpsons

# insert element at index 0 (shifts everything right)simpsons.insert(0,'maggie')simpsons

# search for first instance and remove itsimpsons.remove('bart')simpsons

# remove element 0 and return itsimpsons.pop(0)

# remove element 0 (does not return it)delsimpsons[0]simpsons

# replace element 0simpsons[0]='krusty'simpsons

# concatenate lists (slower than 'extend' method)neighbors=simpsons+['ned','rod','todd']neighbors

# counts the number of instancessimpsons.count('lisa')

# returns index of first instancesimpsons.index('itchy')

weekdays=['mon','tues','wed','thurs','fri']

# element 0weekdays[0]

# elements 0 (inclusive) to 3 (exclusive)weekdays[0:3]

# starting point is implied to be 0weekdays[:3]

# elements 3 (inclusive) through the endweekdays[3:]

# last elementweekdays[-1]

# every 2nd element (step by 2)weekdays[::2]

# backwards (step by -1)weekdays[::-1]

# alternative method for returning the list backwardslist(reversed(weekdays))

simpsons.sort()simpsons

# sort in reversesimpsons.sort(reverse=True)simpsons

# sort by a keysimpsons.sort(key=len)simpsons

sorted(simpsons)

sorted(simpsons,reverse=True)

sorted(simpsons,key=len)

num=[10,20,40,50]frombisectimportinsortinsort(num,30)num

# create a second reference to the same listsame_num=num

# modifies both 'num' and 'same_num'same_num[0]=0print(num)print(same_num)

# copy a list (two ways)new_num=num[:]new_num=list(num)

numissame_num# checks whether they are the same object

numisnew_num

num==same_num# checks whether they have the same contents

num==new_num

# create a tuple directlydigits=(0,1,'two')

# create a tuple from a listdigits=tuple([0,1,'two'])

# trailing comma is required to indicate it's a tuplezero=(0,)

digits[2]

len(digits)

# counts the number of instances of that valuedigits.count(0)

# returns the index of the first instance of that valuedigits.index(1)

# elements of a tuple cannot be modified (this would throw an error)# digits[2] = 2

# concatenate tuplesdigits=digits+(3,4)digits

# create a single tuple with elements repeated (also works with lists)(3,4)*2

# sort a list of tuplestens=[(20,60),(10,40),(20,30)]sorted(tens)# sorts by first element in tuple, then second element

# tuple unpackingbart=('male',10,'simpson')# create a tuple(sex,age,surname)=bart# assign three values at onceprint(sex)print(age)print(surname)

# convert another data type into a strings=str(42)s

# create a string directlys='I like you'

s[0]

len(s)

s[:6]

s[7:]

s[-1]

s.lower()

s.upper()

s.startswith('I')

s.endswith('you')

# checks whether every character in the string is a digits.isdigit()

# returns index of first occurrence, but doesn't support regexs.find('like')

# returns -1 since not founds.find('hate')

# replaces all instances of 'like' with 'love's.replace('like','love')

# split a string into a list of substrings separated by a delimiters.split(' ')

# equivalent (since space is the default delimiter)s.split()

s2='a, an, the's2.split(',')

# join a list of strings into one string using a delimiterstooges=['larry','curly','moe']' '.join(stooges)

# concatenate stringss3='The meaning of life is's4='42's3+' '+s4

s5='  ham and cheese  's5.strip()

# old way'raining%s and%s'%('cats','dogs')

# new way'raining{} and{}'.format('cats','dogs')

# new way (using named arguments)'raining{arg1} and{arg2}'.format(arg1='cats',arg2='dogs')

# use 2 decimal places'pi is{:.2f}'.format(3.14159)

# normal strings allow for escaped charactersprint('first line\nsecond line')

# raw strings treat backslashes as literal charactersprint(r'first line\nfirst line')

# create an empty dictionary (two ways)empty_dict={}empty_dict=dict()

# create a dictionary (two ways)family={'dad':'homer','mom':'marge','size':6}family=dict(dad='homer',mom='marge',size=6)family

# convert a list of tuples into a dictionarylist_of_tuples=[('dad','homer'),('mom','marge'),('size',6)]family=dict(list_of_tuples)family

# pass a key to return its valuefamily['dad']

# return the number of key-value pairslen(family)

# check if key exists in dictionary'mom'infamily

# dictionary values are not checked'marge'infamily

# returns a list of keys (Python 2) or an iterable view (Python 3)family.keys()

# returns a list of values (Python 2) or an iterable view (Python 3)family.values()

# returns a list of key-value pairs (Python 2) or an iterable view (Python 3)family.items()

# add a new entryfamily['cat']='snowball'family

# edit an existing entryfamily['cat']='snowball ii'family

# delete an entrydelfamily['cat']family

# dictionary value can be a listfamily['kids']=['bart','lisa']family

# remove an entry and return the valuefamily.pop('dad')

# add multiple entriesfamily.update({'baby':'maggie','grandpa':'abe'})family

family['mom']

# equivalent to a dictionary lookupfamily.get('mom')

# this would throw an error since the key does not exist# family['grandma']

# return None if not foundfamily.get('grandma')

# provide a default return value if not foundfamily.get('grandma','not found')

family['kids'][0]

family['kids'].remove('lisa')family

'youngest child is%(baby)s'%family

# create an empty setempty_set=set()

# create a set directlylanguages={'python','r','java'}

# create a set from a listsnakes=set(['cobra','viper','python'])

len(languages)

'python'inlanguages

# intersectionlanguages&snakes

# unionlanguages|snakes

# set differencelanguages-snakes

# set differencesnakes-languages

# add a new elementlanguages.add('sql')languages

# try to add an existing element (ignored, no error)languages.add('r')languages

# remove an elementlanguages.remove('java')languages

# try to remove a non-existing element (this would throw an error)# languages.remove('c')

# remove an element if present, but ignored otherwiselanguages.discard('c')languages

# remove and return an arbitrary elementlanguages.pop()

# remove all elementslanguages.clear()languages

# add multiple elements (can also pass a set)languages.update(['go','spark'])languages

sorted(set([9,0,2,1,0]))

defprint_text():print('this is text')

# call the functionprint_text()

defprint_this(x):print(x)

# call the functionprint_this(3)

# prints 3, but doesn't assign 3 to n because the function has no return statementn=print_this(3)

defsquare_this(x):returnx**2

# include an optional docstring to describe the effect of a functiondefsquare_this(x):"""Return the square of a number."""returnx**2

# call the functionsquare_this(3)

# assigns 9 to var, but does not print 9var=square_this(3)

defcalc(a,b,op='add'):ifop=='add':returna+belifop=='sub':returna-belse:print('valid operations are add and sub')

# call the functioncalc(10,4,op='add')

# unnamed arguments are inferred by positioncalc(10,4,'add')

# default for 'op' is 'add'calc(10,4)

calc(10,4,'sub')

calc(10,4,'div')

defstub():pass

defmin_max(nums):returnmin(nums),max(nums)

# return values can be assigned to a single variable as a tuplenums=[1,2,3]min_max_num=min_max(nums)min_max_num

# return values can be assigned into multiple variables using tuple unpackingmin_num,max_num=min_max(nums)print(min_num)print(max_num)

# define a function the "usual" waydefsquared(x):returnx**2

# define an identical function using lambdasquared=lambdax:x**2

# without using lambdasimpsons=['homer','marge','bart']deflast_letter(word):returnword[-1]sorted(simpsons,key=last_letter)

# using lambdasorted(simpsons,key=lambdaword:word[-1])

# includes the start value but excludes the stop valuerange(0,3)

# default start value is 0range(3)

# third argument is the step valuerange(0,5,2)

# Python 2 only: use xrange to create a sequence rather than a list (saves memory)xrange(100,100000,5)

# not the recommended stylefruits=['apple','banana','cherry']foriinrange(len(fruits)):print(fruits[i].upper())

# recommended styleforfruitinfruits:print(fruit.upper())

# iterate through two things at once (using tuple unpacking)family={'dad':'homer','mom':'marge','size':6}forkey,valueinfamily.items():print(key,value)

# use enumerate if you need to access the index value within the loopforindex,fruitinenumerate(fruits):print(index,fruit)

forfruitinfruits:iffruit=='banana':print('Found the banana!')break# exit the loop and skip the 'else' blockelse:# this block executes ONLY if the for loop completes without hitting 'break'print("Can't find the banana")

count=0whilecount<5:print('This will print 5 times')count+=1# equivalent to 'count = count + 1'

# for loop to create a list of cubesnums=[1,2,3,4,5]cubes=[]fornuminnums:cubes.append(num**3)cubes

# equivalent list comprehensioncubes=[num**3fornuminnums]cubes

# for loop to create a list of cubes of even numberscubes_of_even=[]fornuminnums:ifnum%2==0:cubes_of_even.append(num**3)cubes_of_even

# equivalent list comprehension# syntax: [expression for variable in iterable if condition]cubes_of_even=[num**3fornuminnumsifnum%2==0]cubes_of_even

# for loop to cube even numbers and square odd numberscubes_and_squares=[]fornuminnums:ifnum%2==0:cubes_and_squares.append(num**3)else:cubes_and_squares.append(num**2)cubes_and_squares

# equivalent list comprehension (using a ternary expression)# syntax: [true_condition if condition else false_condition for variable in iterable]cubes_and_squares=[num**3ifnum%2==0elsenum**2fornuminnums]cubes_and_squares

# for loop to flatten a 2d-matrixmatrix=[[1,2],[3,4]]items=[]forrowinmatrix:foriteminrow:items.append(item)items

# equivalent list comprehensionitems=[itemforrowinmatrixforiteminrow]items

fruits=['apple','banana','cherry']unique_lengths={len(fruit)forfruitinfruits}unique_lengths

fruit_lengths={fruit:len(fruit)forfruitinfruits}fruit_lengths

fruit_indices={fruit:indexforindex,fruitinenumerate(fruits)}fruit_indices

simpsons=['homer','marge','bart']map(len,simpsons)

# equivalent list comprehension[len(word)forwordinsimpsons]

map(lambdaword:word[-1],simpsons)

# equivalent list comprehension[word[-1]forwordinsimpsons]

nums=range(5)filter(lambdax:x%2==0,nums)

# equivalent list comprehension[numfornuminnumsifnum%2==0]