Never use == or != operator to evaluate boolean operation. Use the is or is not operators, or use implicit boolean evaluation.

NO (even if they are valid Python):

>>> True == True
True

>>> True != False
True

YES (even if they are valid Python):

>>> True is True
True

>>> True is not False
True

These statements are equivalent:

>>> if a is True:
>>>    pass
>>> if a is not False:
>>>    pass
>>> if a:
>>>    pass

And these as well:

>>> if a is False:
>>>    pass
>>> if a is not True:
>>>    pass
>>> if not a:
>>>    pass

>>> (4 < 5) and (5 < 6)
True

>>> (4 < 5) and (9 < 6)
False

>>> (1 == 2) or (2 == 2)
True

You can also use multiple Boolean operators in an expression, along with the comparison operators:

>>> 2 + 2 == 4 and not 2 + 2 == 5 and 2 * 2 == 2 + 2
True

if name == 'Alice':
print('Hi, Alice.')

name = 'Bob'
if name == 'Alice':
    print('Hi, Alice.')
else:
    print('Hello, stranger.')

name = 'Bob'
age = 5
if name == 'Alice':
    print('Hi, Alice.')
elif age < 12:
    print('You are not Alice, kiddo.')

name = 'Bob'
age = 30
if name == 'Alice':
    print('Hi, Alice.')
elif age < 12:
    print('You are not Alice, kiddo.')
else:
    print('You are neither Alice nor a little kid.')

spam = 0 

while spam < 5:  

    print('Hello, world.') 

    spam = spam + 1

If the execution reaches a break statement, it immediately exits the while loop’s clause:

while True: 

    print('Please type your name.') 

    name = input() 

    f name == 'your name': 

        break 

print('Thank you!')

When the program execution reaches a continue statement, the program execution immediately jumps back to the start of the loop.

while True: 

    print('Who are you?') 

    name = input() 

    if name != 'Joe': 

        continue 

    print('Hello, Joe. What is the password? (It is a fish.)') 

    password = input() 

    if password == 'swordfish': 

        break 

print('Access granted.')

>>> print('My name is') 

>>> for i in range(5): 

>>>     print('Jimmy Five Times ({})'.format(str(i))) 

My name is 

Jimmy Five Times (0) 

Jimmy Five Times (1) 

Jimmy Five Times (2) 

Jimmy Five Times (3) 

Jimmy Five Times (4)

The range() function can also be called with three arguments. The first two arguments will be the start and stop values, and the third will be the step argument. The step is the amount that the variable is increased by after each iteration.

>>> for i in range(0, 10, 2):
>>>    print(i)
0
2
4
6
8

You can even use a negative number for the step argument to make the for loop count down instead of up.

>>> for i in range(5, -1, -1): 

>>>     print(i) 

5 

4 

3 

2 

1 

0

This allows to specify a statement to execute in case of the full loop has been executed. Only useful when a break condition can occur in the loop:

>>> for i in [1, 2, 3, 4, 5]: 

>>>    if i == 3: 

>>>        break 

>>> else: 

>>>    print("only executed when no item of the list is equal to 3")

import random 

for i in range(5): 

    print(random.randint(1, 10))

import random, sys, os, math

from random import *

import sys 
 


while True: 

    print('Type exit to exit.') 

    response = input() 

    if response == 'exit': 

        sys.exit() 

    print('You typed {}.'.format(response))

>>> def hello(name): 

>>>     print('Hello {}'.format(name)) 

>>> 

>>> hello('Alice') 

>>> hello('Bob') 

Hello Alice 

Hello Bob

import random
def getAnswer(answerNumber):
    if answerNumber == 1:
        return 'It is certain'
    elif answerNumber == 2:
        return 'It is decidedly so'
    elif answerNumber == 3:
    return 'Yes'
    elif answerNumber == 4:
        return 'Reply hazy try again'
    elif answerNumber == 5:
        return 'Ask again later'
    elif answerNumber == 6:
        return 'Concentrate and ask again'
    elif answerNumber == 7:
        return 'My reply is no'
    elif answerNumber == 8:
        return 'Outlook not so good'
    elif answerNumber == 9:
        return 'Very doubtful'

r = random.randint(1, 9)
fortune = getAnswer(r)
print(fortune)

>>> spam = print('Hello!') 

Hello!

>>> spam is None 

True

>>> print('Hello', end='') 

>>> print('World') 

HelloWorld

>>> print('cats', 'dogs', 'mice') 

cats dogs mice

>>> print('cats', 'dogs', 'mice', sep=',') 

cats,dogs,mice

• Code in the global scope cannot use any local variables.
• However, a local scope can access global variables.
• Code in a function’s local scope cannot use variables in any other local scope.
• You can use the same name for different variables if they are in different scopes. That is, there can be a local variable named spam and a global variable also named spam.

If you need to modify a global variable from within a function, use the global statement:

>>> def spam(): 

>>>     global eggs 

>>>     eggs = 'spam' 

>>> 

>>> eggs = 'global' 

>>> spam() 

>>> print(eggs) 

spam

There are four rules to tell whether a variable is in a local scope or global scope:

• If a variable is being used in the global scope (that is, outside of all functions), then it is always a global variable.
• If there is a global statement for that variable in a function, it is a global variable.
• Otherwise, if the variable is used in an assignment statement in the function, it is a local variable.
• But if the variable is not used in an assignment statement, it is a global variable.

>>> def spam(divideBy): 

>>>     try: 

>>>         return 42 / divideBy 

>>>     except ZeroDivisionError as e: 

>>>         print('Error: Invalid argument: {}'.format(e)) 

>>> 

>>> print(spam(2)) 

>>> print(spam(12)) 

>>> print(spam(0)) 

>>> print(spam(1)) 

21.0 

3.5 

Error: Invalid argument: division by zero 

None 

42.0

Code inside the finally section is always executed, no matter if an exception has been raised or not, and even if an exception is not caught.

>>> def spam(divideBy): 

>>>     try: 

>>>         return 42 / divideBy 

>>>     except ZeroDivisionError as e: 

>>>         print('Error: Invalid argument: {}'.format(e)) 

>>>     finally: 

>>>         print("-- division finished --") 

>>> print(spam(2)) 

-- division finished -- 

21.0 

>>> print(spam(12)) 

-- division finished -- 

3.5 

>>> print(spam(0)) 

Error: Invalid Argument division by zero 

-- division finished -- 

None 

>>> print(spam(1)) 

-- division finished -- 

42.0

>>> spam = ['cat', 'bat', 'rat', 'elephant'] 
 


>>> spam 

['cat', 'bat', 'rat', 'elephant']

>>> spam = ['cat', 'bat', 'rat', 'elephant']  

>>> spam[0] 

'cat'

>>> spam[1] 

'bat'

>>> spam[2] 

'rat'

>>> spam[3] 

'elephant'

>>> spam = ['cat', 'bat', 'rat', 'elephant'] 

>>> spam[-1] 

'elephant'

>>> spam[-3] 

'bat'

>>> 'The {} is afraid of the {}.'.format(spam[-1], spam[-3]) 

'The elephant is afraid of the bat.

>>> spam = ['cat', 'bat', 'rat', 'elephant'] 

>>> spam[0:4] 

['cat', 'bat', 'rat', 'elephant']

>>> spam[1:3] 

['bat', 'rat']

>>> spam[0:-1] 

['cat', 'bat', 'rat']

>>> spam = ['cat', 'bat', 'rat', 'elephant'] 

>>> spam[:2] 

['cat', 'bat']

>>> spam[1:] 

['bat', 'rat', 'elephant']

Slicing the complete list will perform a copy:

>>> spam2 = spam[:] 

['cat', 'bat', 'rat', 'elephant'] 

>>> spam.append('dog') 

>>> spam 

['cat', 'bat', 'rat', 'elephant', 'dog'] 

>>> spam2 

['cat', 'bat', 'rat', 'elephant']

>>> spam = ['cat', 'dog', 'moose'] 

>>> len(spam) 

3

>>> spam = ['cat', 'bat', 'rat', 'elephant'] 

>>> spam[1] = 'aardvark' 
  


>>> spam 

['cat', 'aardvark', 'rat', 'elephant'] 
  


>>> spam[2] = spam[1] 
 


>>> spam 

['cat', 'aardvark', 'aardvark', 'elephant'] 
 


>>> spam[-1] = 12345 
 


>>> spam 

['cat', 'aardvark', 'aardvark', 12345] 

>>> [1, 2, 3] + ['A', 'B', 'C'] 

[1, 2, 3, 'A', 'B', 'C'] 
 


>>> ['X', 'Y', 'Z'] * 3 

['X', 'Y', 'Z', 'X', 'Y', 'Z', 'X', 'Y', 'Z'] 
 


>>> spam = [1, 2, 3] 
 


>>> spam = spam + ['A', 'B', 'C'] 
 


>>> spam 

[1, 2, 3, 'A', 'B', 'C']

>>> spam = ['cat', 'bat', 'rat', 'elephant'] 

>>> del spam[2] 

>>> spam 

['cat', 'bat', 'elephant']

>>> del spam[2] 

>>> spam 

['cat', 'bat']

>>> supplies = ['pens', 'staplers', 'flame-throwers', 'binders'] 

>>> for i, supply in enumerate(supplies): 

>>>     print('Index {} in supplies is: {}'.format(str(i), supply)) 

Index 0 in supplies is: pens 

Index 1 in supplies is: staplers 

Index 2 in supplies is: flame-throwers 

Index 3 in supplies is: binders

>>> name = ['Pete', 'John', 'Elizabeth'] 

>>> age = [6, 23, 44] 

>>> for n, a in zip(name, age): 

>>>     print('{} is {} years old'.format(n, a)) 

Pete is 6 years old 

John is 23 years old 

Elizabeth is 44 years old

>>> 'howdy' in ['hello', 'hi', 'howdy', 'heyas'] 

True

>>> spam = ['hello', 'hi', 'howdy', 'heyas'] 

>>> 'cat' in spam 

False

>>> 'howdy' not in spam 

False

>>> 'cat' not in spam 

True

The multiple assignment trick is a shortcut that lets you assign multiple variables with the values in a list in one line of code. So instead of doing this:

>>> cat = ['fat', 'orange', 'loud'] 
 

>>> size = cat[0] 
 

>>> color = cat[1] 
 

>>> disposition = cat[2]

You could type this line of code:

>>> cat = ['fat', 'orange', 'loud'] 


>>> size, color, disposition = cat

The multiple assignment trick can also be used to swap the values in two variables:

>>> a, b = 'Alice', 'Bob' 

>>> a, b = b, a 

>>> print(a) 

'Bob'

>>> print(b) 

'Alice'

>>> spam = ['Zophie', 'Pooka', 'Fat-tail', 'Pooka'] 


>>> spam.index('Pooka')

1

append():

>>> spam = ['cat', 'dog', 'bat'] 

>>> spam.append('moose') 

>>> spam 

['cat', 'dog', 'bat', 'moose']

insert():

>>> spam = ['cat', 'dog', 'bat'] 

>>> spam.insert(1, 'chicken') 

>>> spam 

['cat', 'chicken', 'dog', 'bat']

>>> spam = ['cat', 'bat', 'rat', 'elephant'] 

>>> spam.remove('bat') 

>>> spam 

['cat', 'rat', 'elephant']

>>> spam = [2, 5, 3.14, 1, -7] 

>>> spam.sort() 

>>> spam 

[-7, 1, 2, 3.14, 5]

>>> spam = ['ants', 'cats', 'dogs', 'badgers', 'elephants'] 

>>> spam.sort() 

>>> spam 

['ants', 'badgers', 'cats', 'dogs', 'elephants']

You can also pass True for the reverse keyword argument to have sort() sort the values in reverse order:

>>> spam.sort(reverse=True) 

>>> spam 

['elephants', 'dogs', 'cats', 'badgers', 'ants']

If you need to sort the values in regular alphabetical order, pass str. lower for the key keyword argument in the sort() method call:

>>> spam = ['a', 'z', 'A', 'Z'] 

>>> spam.sort(key=str.lower) 

>>> spam 

['a', 'A', 'z', 'Z']

You can use the built-in function sorted to return a new list:

>>> spam = ['ants', 'cats', 'dogs', 'badgers', 'elephants'] 

>>> sorted(spam) 

['ants', 'badgers', 'cats', 'dogs', 'elephants']

>>> eggs = ('hello', 42, 0.5) 

>>> eggs[0] 

'hello'

>>> eggs[1:3] 

(42, 0.5)

>>> len(eggs) 

3

The main way that tuples are different from lists is that tuples, like strings, are immutable.

>>> tuple(['cat', 'dog', 5]) 

('cat', 'dog', 5)

>>> list(('cat', 'dog', 5)) 

['cat', 'dog', 5]

>>> list('hello') 

['h', 'e', 'l', 'l', 'o']

Example Dictionary:

myCat = {'size': 'fat', 'color': 'gray', 'disposition': 'loud'}

values():

>>> spam = {'color': 'red', 'age': 42} 

>>> for v in spam.values(): 

>>>     print(v) 

red 

42

keys():

>>> for k in spam.keys(): 

>>>     print(k) 

color 

age

items():

>>> for i in spam.items(): 

>>>     print(i) 

('color', 'red') 

('age', 42)

Using the keys(), values(), and items() methods, a for loop can iterate over the keys, values, or key-value pairs in a dictionary, respectively.

>>> spam = {'color': 'red', 'age': 42} 

>>> 

>>> for k, v in spam.items(): 

>>>     print('Key: {} Value: {}'.format(k, str(v))) 

Key: age Value: 42 

Key: color Value: red

>>> spam = {'name': 'Zophie', 'age': 7}

>>> 'name' in spam.keys() 

True

>>> 'Zophie' in spam.values() 

True

>>> # You can omit the call to keys() when checking for a key 

>>> 'color' in spam 

False

>>> 'color' not in spam 

True

Get has two parameters: key and default value if the key did not exist

>>> picnic_items = {'apples': 5, 'cups': 2} 


>>> 'I am bringing {} cups.'.format(str(
picnic_items.get('cups', 0)))

'I am bringing 2 cups.'

>>> 'I am bringing {} eggs.'.format(str(
picnic_items.get('eggs', 0)))
s
'I am bringing 0 eggs.'

Let's consider this code:

spam = {'name': 'Pooka', 'age': 5} 


if 'color' not in spam: 

	spam['color'] = 'black'

Using setdefault we could write the same code more succinctly:

>>> spam = {'name': 'Pooka', 'age': 5} 

>>> spam.setdefault('color', 'black') 

'black'

>>> spam 

{'color': 'black', 'age': 5, 'name': 'Pooka'}

>>> spam.setdefault('color', 'white') 

'black'

>>> spam 

{'color': 'black', 'age': 5, 'name': 'Pooka'}

>>> import print 

>>> 

>>> message = 'It was a bright cold day in April, and the clocks were striking 

>>> thirteen.' 

>>> count = {} 

>>> 

>>> for character in message: 

>>>     count.setdefault(character, 0) 

>>>     count[character] = count[character] + 1 

>>> 

>>> print.print(count) 

{
    ' ': 13, 

    ',': 1, 

    '.': 1, 

    'A': 1, 

    'I': 1, 

    'a': 4, 

    'b': 1, 

    'c': 3, 

    'd': 3, 

    'e': 5, 

    'g': 2, 

    'h': 3, 

    'i': 6, 

    'k': 2, 

    'l': 3, 

    'n': 4, 

    'o': 2, 

    'p': 1, 

    'r': 5, 

    's': 3, 

    't': 6, 

    'w': 2, 

    'y': 1
}

# in Python 3.5+:  

>>> x = {'a': 1, 'b': 2} 

>>> y = {'b': 3, 'c': 4} 

>>> z = {**x, **y} 

>>> z 

{'c': 4, 'a': 1, 'b': 3} 
 


# in Python 2.7 

>>> z = dict(x, **y) 

>>> z 

{'c': 4, 'a': 1, 'b': 3}

There are two ways to create sets: using curly braces {} and the built-in function set()

>>> s = {1, 2, 3} 

>>> s = set([1, 2, 3])

When creating an empty set, be sure to not use the curly braces {} or you will get an empty dictionary instead.

>>> s = {} 

>>> type(s) 

<class 'dict'>

A set automatically remove all the duplicate values.

>>> s = {1, 2, 3, 2, 3, 4} 

>>> s 

{1, 2, 3, 4}

And as an unordered data type, they can't be indexed.

>>> s = {1, 2, 3}
>>> s[0]
Traceback (most recent call last):
	File "<stdin>", line 1, in <module>
TypeError: 'set' object does not support indexing
>>>

Using the add() method we can add a single element to the set.

>>> s = {1, 2, 3} 

>>> s.add(4)  

>>> s 

{1, 2, 3, 4}

And with update(), multiple ones .

>>> s = {1, 2, 3} 

>>> s.update([2, 3, 4, 5, 6]) 

>>> s 

{1, 2, 3, 4, 5, 6}  # remember, sets automatically remove duplicates

Both methods will remove an element from the set, but remove() will raise a key error if the value doesn't exist.

>>> s = {1, 2, 3} 

>>> s.remove(3) 

>>> s 

{1, 2} 

>>> s.remove(3) 

Traceback (most recent call last): 

	File "<stdin>", line 1, in <module> 

KeyError: 3

discard() won't raise any errors.

>>> s = {1, 2, 3} 

>>> s.discard(3) 

>>> s 

{1, 2} 

>>> s.discard(3)
>>>

union() or | will create a new set that contains all the elements from the sets provided.

>>> s1 = {1, 2, 3} 

>>> s2 = {3, 4, 5} 

>>> s1.union(s2)  # or 's1 | s2' 

{1, 2, 3, 4, 5}

intersection or & will return a set containing only the elements that are common to all of them.

>>> s1 = {1, 2, 3} 

>>> s2 = {2, 3, 4} 

>>> s3 = {3, 4, 5} 

>>> s1.intersection(s2, s3)  # or 's1 & s2 & s3' 

{3}

difference or- will return only the elements that are unique to the first set (invoked set).

>>> s1 = {1, 2, 3} 

>>> s2 = {2, 3, 4} 

>>> s1.difference(s2)  # or 's1 - s2' 

{1} 

>>> s2.difference(s1) # or 's2 - s1' 

{4}

symetric_difference or ^ will return all the elements that are not common between them.

>>> s1 = {1, 2, 3} 

>>> s2 = {2, 3, 4} 

>>> s1.symmetric_difference(s2)  # or 's1 ^ s2' 

{1, 4}

Makes an iterator that returns the results of a function./p>

itertools.accumulate(iterable[, func])

Example:

>>> data = [1, 2, 3, 4, 5] 

>>> result = itertools.accumulate(data, operator.mul) 

>>> for each in result: 

>>>    print(each) 

1 

2 

6 

24 

120

The operator.mul takes two numbers and multiplies them:

operator.mul(1, 2) 

2 

operator.mul(2, 3) 

6 

operator.mul(6, 4) 

24 

operator.mul(24, 5) 

120

Passing a function is optional:

>>> data = [5, 2, 6, 4, 5, 9, 1] 

>>> result = itertools.accumulate(data) 

>>> for each in result: 

>>>    print(each) 

5 

7 

13 

17 

22 

31 

32

If no function is designated the items will be summed:

5 

5 + 2 = 7 

7 + 6 = 13 

13 + 4 = 17 

17 + 5 = 22 

22 + 9 = 31 

31 + 1 = 32

Takes an iterable and a integer. This will create all the unique combination that have r members.

itertools.combinations(iterable, r)

Example:

>>> shapes = ['circle', 'triangle', 'square',] 

>>> result = itertools.combinations(shapes, 2) 

>>> for each in result: 

>>>    print(each) 

('circle', 'triangle') 

('circle', 'square') 

('triangle', 'square')

Just like combinations(), but allows individual elements to be repeated more than once.

itertools.combinations_with_replacement(iterable, r)

Example:

>>> shapes = ['circle', 'triangle', 'square'] 

>>> result = itertools.combinations_with_replacement(shapes, 2) 

>>> for each in result: 

>>>    print(each) 

('circle', 'circle') 

('circle', 'triangle') 

('circle', 'square') 

('triangle', 'triangle') 

('triangle', 'square') 

('square', 'square')

Makes an iterator that returns evenly spaced values starting with number start.

itertools.count(start=0, step=1)

Example:

>>> for i in itertools.count(10,3): 

>>>    print(i) 

>>>    if i > 20: 

>>>        break 

10 

13 

16 

19 

22

This function cycles through an iterator endlessly.

itertools.cycle(iterable)

Example:

>>> colors = ['red', 'orange', 'yellow', 'green', 'blue', 'violet'] 

>>> for color in itertools.cycle(colors): 

>>>    print(color) 

red 

orange 

yellow 

green 

blue 

violet 

red 

orange

When reached the end of the iterable it start over again from the beginning.

Take a series of iterables and return them as one long iterable.

itertools.chain(*iterables)

Example:

>>> colors = ['red', 'orange', 'yellow', 'green', 'blue'] 

>>> shapes = ['circle', 'triangle', 'square', 'pentagon'] 

>>> result = itertools.chain(colors, shapes) 

>>> for each in result: 

>>>    print(each) 

red 

orange 

yellow 

green 

blue 

circle 

triangle 

square 

pentagon

Filters one iterable with another.

itertools.compress(data, selectors)

Example:

>>> shapes = ['circle', 'triangle', 'square', 'pentagon'] 

>>> selections = [True, False, True, False] 

>>> result = itertools.compress(shapes, selections) 

>>> for each in result: 

>>>    print(each) 

circle 

square

Make an iterator that drops elements from the iterable as long as the predicate is true; afterwards, returns every element.

itertools.dropwhile(predicate, iterable)

Example:

>>> data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1] 

>>> result = itertools.dropwhile(lambda x: x<5, data) 

>>> for each in result: 

>>>    print(each) 

5 

6 

7 

8 

9 

10 

1

Makes an iterator that filters elements from iterable returning only those for which the predicate is False.

itertools.filterfalse(predicate, iterable)

Example:

>>> data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1] 

>>> result = itertools.filterfalse(lambda x: x<5, data) 

>>> for each in result: 

>>>    print(each) 

5 

6 

7 

8 

9 

10

Simply put, this function groups things together.

itertools.groupby(iterable, key=None)

Example:

>>> robots = [{ 

    'name': 'blaster', 

    'faction': 'autobot' 

}, { 

    'name': 'galvatron', 

    'faction': 'decepticon' 

}, { 

    'name': 'jazz', 

    'faction': 'autobot' 

}, { 

    'name': 'metroplex', 

    'faction': 'autobot' 

}, { 

    'name': 'megatron', 

    'faction': 'decepticon' 

}, { 

    'name': 'starcream', 

    'faction': 'decepticon' 

}] 

>>> for key, group in itertools.groupby(robots,  
key=lambda x: x['faction']): 

>>>    print(key) 

>>>    print(list(group)) 

autobot 

[{'name': 'blaster', 'faction': 'autobot'}] 

decepticon 

[{'name': 'galvatron', 'faction': 'decepticon'}] 

autobot 

[{'name': 'jazz', 'faction': 'autobot'}, {'name': 'metroplex', 'faction': 'autobot'}] 

decepticon 

[{'name': 'megatron', 'faction': 'decepticon'}, {'name': 'starcream', 'faction': 'decepticon'}]

This function is very much like slices. This allows you to cut out a piece of an iterable.

itertools.islice(iterable, start, stop[, step])

Example:

>>> colors = ['red', 'orange', 'yellow', 'green', 'blue',] 

>>> few_colors = itertools.islice(colors, 2) 

>>> for each in few_colors: 

>>>    print(each) 

red 

orange

itertools.permutations(iterable, r=None)

Example:

>>> alpha_data = ['a', 'b', 'c'] 

>>> result = itertools.permutations(alpha_data) 

>>> for each in result: 

>>>    print(each) 

('a', 'b', 'c') 

('a', 'c', 'b') 

('b', 'a', 'c') 

('b', 'c', 'a') 

('c', 'a', 'b') 

('c', 'b', 'a')

Creates the cartesian products from a series of iterables.

>>> num_data = [1, 2, 3] 

>>> alpha_data = ['a', 'b', 'c'] 

>>> result = itertools.product(num_data, alpha_data) 

>>> for each in result: 

	print(each) 

(1, 'a') 

(1, 'b') 

(1, 'c') 

(2, 'a') 

(2, 'b') 

(2, 'c') 

(3, 'a') 

(3, 'b') 

(3, 'c')

This function will repeat an object over and over again. Unless, there is a times argument.

itertools.repeat(object[, times])

Example:

>>> for i in itertools.repeat("spam", 3): 

	print(i) 

spam 

spam 

spam

Makes an iterator that computes the function using arguments obtained from the iterable.

itertools.starmap(function, iterable)

Example:

>>> data = [(2, 6), (8, 4), (7, 3)] 

>>> result = itertools.starmap(operator.mul, data) 

>>> for each in result: 

>>>    print(each) 

12 

32 

21

The opposite of dropwhile(). Makes an iterator and returns elements from the iterable as long as the predicate is true.

itertools.takewhile(predicate, iterable)

Example:

>>> data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1] 

>>> result = itertools.takewhile(lambda x: x<5, data) 

>>> for each in result: 

>>>    print(each) 

1 

2 

3 

4

Return n independent iterators from a single iterable.

itertools.tee(iterable, n=2)

Example:

>>> colors = ['red', 'orange', 'yellow', 'green', 'blue'] 

>>> alpha_colors, beta_colors = itertools.tee(colors) 

>>> for each in alpha_colors: 

>>>    print(each) 

red 

orange 

yellow 

green 

blue

>>> colors = ['red', 'orange', 'yellow', 'green', 'blue'] 

>>> alpha_colors, beta_colors = itertools.tee(colors) 

>>> for each in beta_colors: 

>>>    print(each) 

red 

orange 

yellow 

green 

blue

Makes an iterator that aggregates elements from each of the iterables. If the iterables are of uneven length, missing values are filled-in with fillvalue. Iteration continues until the longest iterable is exhausted.

itertools.zip_longest(*iterables, fillvalue=None)

Example:

>>> colors = ['red', 'orange', 'yellow', 'green', 'blue',] 

>>> data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10,] 

>>> for each in itertools.zip_longest(colors, data, fillvalue=None): 

>>>    print(each) 

('red', 1) 

('orange', 2) 

('yellow', 3) 

('green', 4) 

('blue', 5) 

(None, 6) 

(None, 7) 

(None, 8) 

(None, 9) 

(None, 10)

List comprehension

>>> a = [1, 3, 5, 7, 9, 11] 
 


>>> [i - 1 for i in a] 

[0, 2, 4, 6, 8, 10]

Set comprehension

>>> b = {"abc", "def"}
>>> {s.upper() for s in b}
{"ABC", "DEF"}

Dict comprehension

>>> c = {'name': 'Pooka', 'age': 5} 

>>> {v: k for k, v in c.items()} 

{'Pooka': 'name', 5: 'age'}

A List comprehension can be generated from a dictionary:

>>> c = {'name': 'Pooka', 'first_name': 'Oooka'} 

>>> ["{}:{}".format(k.upper(), v.upper()) for k, v in c.items()] 

['NAME:POOKA', 'FIRST_NAME:OOOKA']

A raw string completely ignores all escape characters and prints any backslash that appears in the string.

>>> print(r'That is Carol\'s cat.') 

That is Carol\'s cat.

Note: mostly used for regular expression definition (see re package)

>>> print('''Dear Alice, 

>>> 

>>> Eve's cat has been arrested for catnapping, cat burglary, and extortion. 

>>>
>>> Sincerely, 

>>> Bob''') 

Dear Alice, 
 


Eve's cat has been arrested for catnapping, cat  
burglary, and extortion. 
 


Sincerely,
Bob

To keep a nicer flow in your code, you can use the dedent function from the textwrap standard package.

>>> from textwrap import dedent 

>>> 

>>> def my_function(): 

>>>     print(''' 

>>>         Dear Alice, 

>>> 

>>>         Eve's cat has been arrested for catnapping, cat burglary, and extortion. 

>>>
>>>         Sincerely, 

>>>         Bob 

>>>         ''').strip()

>>> spam = 'Hello world!' 
 


>>> spam[0] 

'H'

>>> spam[4]
'o'

>>> spam[-1] 

'!'

Slicing:

>>> spam[0:5]
'Hello'

>>> spam[:5]
'Hello'

>>> spam[6:]
'world!'

>>> spam[6:]
'world!'

>>> spam[6:-1]
'world'

Slicing:

>>> spam[0:5] 

'Hello'

>>> spam[:5] 

'Hello'

>>> spam[6:] 

'world!'

>>> spam[6:-1] 

'world'

>>> spam[:-1] 

'Hello world'

>>> spam[::-1] 

'!dlrow olleH'

>>> spam = 'Hello world!' 

>>> fizz = spam[0:5] 

>>> fizz 

'Hello'

>>> 'Hello' in 'Hello World' 

True

>>> 'Hello' in 'Hello' 

True

>>> 'HELLO' in 'Hello World' 

False

>>> '' in 'spam' 

True

>>> 'cats' not in 'cats and dogs' 

False

>>> a = [1, 2, 3, 4] 

>>> 5 in a 

False

>>> 2 in a 

True

upper() and lower():

>>> spam = 'Hello world!'
>>> spam = spam.upper()
>>> spam
'HELLO WORLD!'

>>> spam = spam.lower() 

>>> spam 

'hello world!'

isupper() and islower():

>>> spam = 'Hello world!' 

>>> spam.islower() 

False

>>> spam.isupper() 

False

>>> 'HELLO'.isupper() 

True

>>> 'abc12345'.islower() 

True

>>> '12345'.islower() 

False

>>> '12345'.isupper() 

False

>>> 'Hello world!'.startswith('Hello') 

True

>>> 'Hello world!'.endswith('world!') 

True

>>> 'abc123'.startswith('abcdef') 

False

>>> 'abc123'.endswith('12') 

False

>>> 'Hello world!'.startswith('Hello world!') 

True

>>> 'Hello world!'.endswith('Hello world!') 

True

join():

>>> ', '.join(['cats', 'rats', 'bats']) 

'cats, rats, bats'

>>> ' '.join(['My', 'name', 'is', 'Simon']) 

'My name is Simon'

>>> 'ABC'.join(['My', 'name', 'is', 'Simon']) 

'MyABCnameABCisABCSimon'

split():

>>> 'My name is Simon'.split() 

['My', 'name', 'is', 'Simon']

>>> 'MyABCnameABCisABCSimon'.split('ABC') 

['My', 'name', 'is', 'Simon']

>>> 'My name is Simon'.split('m') 

['My na', 'e is Si', 'on']

rjust() and ljust():

>>> 'Hello'.rjust(10) 

'     Hello'

>>> 'Hello'.rjust(20) 

'               Hello'

>>> 'Hello World'.rjust(20) 

'         Hello World'

>>> 'Hello'.ljust(10) 

'Hello     '

An optional second argument to rjust() and ljust() will specify a fill character other than a space character. Enter the following into the interactive shell:

>>> 'Hello'.rjust(20, '*') 

'***************Hello'

>>> 'Hello'.ljust(20, '-') 

'Hello---------------'

center():

>>> 'Hello'.center(20) 

'       Hello       '

>>> 'Hello'.center(20, '=') 

'=======Hello========'

>>> spam = '    Hello World     ' 

>>> spam.strip() 

'Hello World'

>>> spam.lstrip() 

'Hello World '

>>> spam.rstrip() 

'    Hello World'

>>> spam = 'SpamSpamBaconSpamEggsSpamSpam' 

>>> spam.strip('ampS') 

'BaconSpamEggs'

>>> import pyperclip 


>>> pyperclip.copy('Hello world!') 


>>> pyperclip.paste() 

'Hello world!'

>>> name = 'Pete' 

>>> 'Hello %s' % name 

"Hello Pete"

We can use the %x format specifier to convert an int value to a string:

>>> num = 5 

>>> 'I have %x apples' % num 

"I have 5 apples"

Note: For new code, using str.format or f-strings (Python 3.6+) is strongly recommended over the % operator.

Python 3 introduced a new way to do string formatting that was later back-ported to Python 2.7. This makes the syntax for string formatting more regular.

>>> name = 'John' 

>>> age = 20' 
 


>>> "Hello I'm {}, my age is {}".format(name, age) 

"Hello I'm John, my age is 20"

>>> "Hello I'm {0}, my age is {1}".format(name, age) 

"Hello I'm John, my age is 20"

You would only use %s string formatting on functions that can do lazy parameters evaluation, the most common being logging:

Prefer:

>>> name = "alice" 

>>> logging.debug("User name: %s", name)

Over:

>>> logging.debug("User name: {}".format(name))

Or:

>>> logging.debug("User name: " + name)

>>> name = 'Elizabeth' 

>>> f'Hello {name}!' 

'Hello Elizabeth!

It is even possible to do inline arithmetic with it:

>>> a = 5 

>>> b = 10 

>>> f'Five plus ten is {a + b} and not {2 * (a + b)}.' 

'Five plus ten is 15 and not 30.'

A simpler and less powerful mechanism, but it is recommended when handling format strings generated by users. Due to their reduced complexity template strings are a safer choice.

>>> from string import Template 

>>> name = 'Elizabeth' 

>>> t = Template('Hey $name!') 

>>> t.substitute(name=name) 

'Hey Elizabeth!'

• Import the regex module with import re.
• Create a Regex object with the re.compile() function. (Remember to use a raw string.)
• Pass the string you want to search into the Regex object’s search() method. This returns a Match object.
• Call the Match object’s group() method to return a string of the actual matched text.

All the regex functions in Python are in the re module:

>>> import re

>>> phone_num_regex = re.compile(r'\d\d\d-\d\d\d-\d\d\d\d') 
 


>>> mo = phone_num_regex.search('My number is 415-555-4242.') 
 


>>> print('Phone number found: {}'.format(mo.group()))
Phone number found: 415-555-4242

>>> phone_num_regex = re.compile(r'(\d\d\d)-(\d\d\d-\d\d\d\d)') 
 


>>> mo = phone_num_regex.search('My number is 415-555-4242.') 
 


>>> mo.group(1) 

'415' 
 


>>> mo.group(2) 

'555-4242' 
 


>>> mo.group(0) 

'415-555-4242' 
 


>>> mo.group() 

'415-555-4242'

To retrieve all the groups at once: use the groups() method—note the plural form for the name.

>>> mo.groups() 

('415', '555-4242') 
 


>>> area_code, main_number = mo.groups() 
 


>>> print(area_code) 

415 
 


>>> print(main_number) 

555-4242

The | character is called a pipe. You can use it anywhere you want to match one of many expressions. For example, the regular expression r'Batman|Tina Fey' will match either 'Batman' or 'Tina Fey'.

>>> hero_regex = re.compile (r'Batman|Tina Fey') 



>>> mo1 = hero_regex.search('Batman and Tina Fey.')



>>> mo1.group()

'Batman'



>>> mo2 = hero_regex.search('Tina Fey and Batman.')



>>> mo2.group()

'Tina Fey'

You can also use the pipe to match one of several patterns as part of your regex:

>>> bat_regex = re.compile(r'Bat(man|mobile|copter|bat)')



>>> mo = bat_regex.search('Batmobile lost a wheel')



>>> mo.group()

'Batmobile'



>>> mo.group(1)

'mobile'

The ? character flags the group that precedes it as an optional part of the pattern.

>>> bat_regex = re.compile(r'Bat(wo)?man')

>>> mo1 = bat_regex.search('The Adventures of Batman')

>>> mo1.group()

'Batman'



>>> mo2 = bat_regex.search('The Adventures of Batwoman')


>>> mo2.group()

'Batwoman'

The * (called the star or asterisk) means “match zero or more”—the group that precedes the star can occur any number of times in the text.

>>> bat_regex = re.compile(r'Bat(wo)*man')

>>> mo1 = bat_regex.search('The Adventures of Batman')

>>> mo1.group()

'Batman'



>>> mo2 = bat_regex.search('The Adventures of Batwoman')

>>> mo2.group()

'Batwoman'



>>> mo3 = bat_regex.search('The Adventures of Batwowowowoman')

>>> mo3.group()

'Batwowowowoman'

While * means “match zero or more,” the + (or plus) means “match one or more”. The group preceding a plus must appear at least once. It is not optional:

>>> bat_regex = re.compile(r'Bat(wo)+man')

>>> mo1 = bat_regex.search('The Adventures of Batwoman')

>>> mo1.group()

'Batwoman'

>>> mo2 = bat_regex.search('The Adventures of Batwowowowoman')

>>> mo2.group()

'Batwowowowoman'

>>> mo3 = bat_regex.search('The Adventures of Batman')

>>> mo3 is None

True

>>> ha_regex = re.compile(r'(Ha){3}') 

>>> mo1 = ha_regex.search('HaHaHa') 

>>> mo1.group() 

'HaHaHa'

>>> mo2 = ha_regex.search('Ha') 

>>> mo2 is None 

True

Python’s regular expressions are greedy by default, which means that in ambiguous situations they will match the longest string possible. The non-greedy version of the curly brackets, which matches the shortest string possible, has the closing curly bracket followed by a question mark.

>>> greedy_ha_regex = re.compile(r'(Ha){3,5}') 

>>> mo1 = greedy_ha_regex.search('HaHaHaHaHa') 

>>> mo1.group() 

'HaHaHaHaHa'

>>> nongreedy_ha_regex = re.compile(r'(Ha){3,5}?') 

>>> mo2 = nongreedy_ha_regex.search('HaHaHaHaHa') 

>>> mo2.group() 

'HaHaHa'

In addition to the search() method, Regex objects also have a findall() method. While search() will return a Match object of the first matched text in the searched string, the findall() method will return the strings of every match in the searched string.

>>> phone_num_regex = re.compile(r'\d\d\d-\d\d\d-\d\d\d\d') # has no groups 
 


>>> phone_num_regex.findall('Cell: 415-555-9999 Work: 212-555-0000') 

['415-555-9999', '212-555-0000']

There are times when you want to match a set of characters but the shorthand character classes (\d, \w, \s, and so on) are too broad. You can define your own character class using square brackets. For example, the character class [aeiouAEIOU] will match any vowel, both lowercase and uppercase.

>>> vowel_regex = re.compile(r'[aeiouAEIOU]') 
 


>>> vowel_regex.findall('Robocop eats baby food. BABY FOOD.') 

['o', 'o', 'o', 'e', 'a', 'a', 'o', 'o', 'A', 'O', 'O']

You can also include ranges of letters or numbers by using a hyphen. For example, the character class [a-zA-Z0-9] will match all lowercase letters, uppercase letters, and numbers.

By placing a caret character (^) just after the character class’s opening bracket, you can make a negative character class. A negative character class will match all the characters that are not in the character class. For example, enter the following into the interactive shell:

>>> consonant_regex = re.compile(r'[^aeiouAEIOU]')  



>>> consonant_regex.findall('Robocop eats baby food. BABY FOOD.') 

['R', 'b', 'c', 'p', ' ', 't', 's', ' ', 'b', 'b', 'y', ' ', 'f', 'd', '.', '
', 'B', 'B', 'Y', ' ', 'F', 'D', '.']

• You can also use the caret symbol (^) at the start of a regex to indicate that a match must occur at the beginning of the searched text.
• Likewise, you can put a dollar sign (\$) at the end of the regex to indicate the string must end with this regex pattern.
• And you can use the ^ and \$ together to indicate that the entire string must match the regex—that is, it’s not enough for a match to be made on some subset of the string.

The r'^Hello' regular expression string matches strings that begin with 'Hello':

>>> begins_with_hello = re.compile(r'^Hello') 
 


>>> begins_with_hello.search('Hello world!') 

<_sre.SRE_Match object; span=(0, 5), match='Hello'> 
 


>>> begins_with_hello.search('He said hello.') is None 

True

The r'\d\$' regular expression string matches strings that end with a numeric character from 0 to 9:

>>> whole_string_is_num = re.compile(r'^\d+$') 
 


>>> whole_string_is_num.search('1234567890') 

<_sre.SRE_Match object; span=(0, 10), match='1234567890'> 
 


>>> whole_string_is_num.search('12345xyz67890') is None 

True 
 


>>> whole_string_is_num.search('12 34567890') is None 

True

The . (or dot) character in a regular expression is called a wildcard and will match any character except for a newline:

>>> at_regex = re.compile(r'.at') 
 


>>> at_regex.findall('The cat in the hat sat on the flat mat.') 

['cat', 'hat', 'sat', 'lat', 'mat']

>>> name_regex = re.compile(r'First Name: (.*) Last Name: (.*)') 
 


>>> mo = name_regex.search('First Name: Al Last Name: Sweigart') 
 


>>> mo.group(1) 

'Al'

>>> mo.group(2) 

'Sweigart'

The dot-star uses greedy mode: It will always try to match as much text as possible. To match any and all text in a nongreedy fashion, use the dot, star, and question mark (.*?). The question mark tells Python to match in a nongreedy way:

>>> nongreedy_regex = re.compile(r'<.*?>') 

>>> mo = nongreedy_regex.search('<To serve man> for dinner.>') 

>>> mo.group() 

'<To serve man>'

>>> greedy_regex = re.compile(r'<.*>') 

>>> mo = greedy_regex.search('<To serve man> for dinner.>')
>>> mo.group()
'<To serve man> for dinner.>'

The dot-star will match everything except a newline. By passing re.DOTALL as the second argument to re.compile(), you can make the dot character match all characters, including the newline character:

>>> no_newline_regex = re.compile('.*') 

>>> no_newline_regex.search('Serve the public trust.\nProtect the innocent.\nUphold the law.').group() 

'Serve the public trust.'

>>> newline_regex = re.compile('.*', re.DOTALL) 

>>> newline_regex.search('Serve the public trust.\nProtect the innocent.\nUphold the law.').group() 

'Serve the public trust.\nProtect the innocent.\nUphold the law.'

To make your regex case-insensitive, you can pass re.IGNORECASE or re.I as a second argument to re.compile():

>>> robocop = re.compile(r'robocop', re.I) 
 


>>> robocop.search('Robocop is part man, part machine, all cop.').group()
'Robocop'

>>> robocop.search('ROBOCOP protects the innocent.').group() 

'ROBOCOP'

>>> robocop.search('Al, why does your programming book talk about robocop so much?').group() 

'robocop'

The sub() method for Regex objects is passed two arguments:

1. The first argument is a string to replace any matches.
2. The second is the string for the regular expression.

The sub() method returns a string with the substitutions applied:

>>> names_regex = re.compile(r'Agent \w+') 
 


>>> names_regex.sub('CENSORED', 'Agent Alice gave the secret documents to Agent Bob.') 

'CENSORED gave the secret documents to CENSORED.'

Another example:

>>> agent_names_regex = re.compile(r'Agent (\w)\w*') 
 


>>> agent_names_regex.sub(r'\1****', 'Agent Alice told Agent Carol that Agent Eve knew Agent Bob was a double agent.') 

A**** told C**** that E**** knew B**** was a double agent.'

To tell the re.compile() function to ignore whitespace and comments inside the regular expression string, “verbose mode” can be enabled by passing the variable re.VERBOSE as the second argument to re.compile().

Now instead of a hard-to-read regular expression like this:

phone_regex = re.compile(r'((\d{3}|\(\d{3}\))?(\s|-|\.)?\d{3}(\s|-|\.)\d{4}(\s*(ext|x|ext.)\s*\d{2,5})?)')

you can spread the regular expression over multiple lines with comments like this:

phone_regex = re.compile(r'''( 

(\d{3}|\(\d{3}\))?            # area code 

    (\s|-|\.)?      # separator 

    \d{3}           # first 3 digits 

    (\s|-|\.)       # separator 

    \d{4}           # last 4 digits 

    (\s*(ext|x|ext.)\s*\d{2,5})?  # extension 

)''', re.VERBOSE)

There are two main modules in Python that deals with path manipulation. One is the os.path module and the other is the pathlib module. The pathlib module was added in Python 3.4, offering an object-oriented way to handle file system paths.

On Windows, paths are written using backslashes (\) as the separator between folder names. On Unix based operating system such as macOS, Linux, and BSDs, the forward slash (/) is used as the path separator. Joining paths can be a headache if your code needs to work on different platforms.

Fortunately, Python provides easy ways to handle this. We will showcase how to deal with this with both os.path.join and pathlib.Path.joinpath

Using os.path.join on Windows:

>>> import os 
 


>>> os.path.join('usr', 'bin', 'spam') 

'usr\\bin\\spam'

And using pathlib on *nix:

>>> from pathlib import Path 
 

>>> print(Path('usr').joinpath('bin').joinpath('spam')) 

usr/bin/spam

pathlib also provides a shortcut to joinpath using the / operator:

>>> from pathlib import Path 
 

>>> print(Path('usr') / 'bin' / 'spam') 

usr/bin/spam

Notice the path separator is different between Windows and Unix based operating system, that's why you want to use one of the above methods instead of adding strings together to join paths together.

Joining paths is helpful if you need to create different file paths under the same directory.

Using os.path.join on Windows:

>>> my_files = ['accounts.txt', 'details.csv', 'invite.docx'] 



>>> for filename in my_files:

>>>     print(os.path.join('C:\\Users\\asweigart', filename))

C:\Users\asweigart\accounts.txt

C:\Users\asweigart\details.csv

C:\Users\asweigart\invite.docx

Using pathlib on *nix:

>>> my_files = ['accounts.txt', 'details.csv', 'invite.docx'] 

>>> home = Path.home() 

>>> for filename in my_files: 

>>>     print(home / filename) 

/home/asweigart/accounts.txt 

/home/asweigart/details.csv 

/home/asweigart/invite.docx

Using os on Windows:

>>> import os 
 

>>> os.getcwd() 

'C:\\Python34' 

>>> os.chdir('C:\\Windows\\System32') 
 

>>> os.getcwd() 

'C:\\Windows\\System32'

Using pathlib on *nix:

>>> from pathlib import Path 

>>> from os import chdir 
 


>>> print(Path.cwd()) 

/home/asweigart 
 


>>> chdir('/usr/lib/python3.6') 

>>> print(Path.cwd()) 

/usr/lib/python3.6

Using os on Windows:

>>> import os 

>>> os.makedirs('C:\\delicious\\walnut\\waffles')

Using pathlib on *nix:

>>> from pathlib import Path 

>>> cwd = Path.cwd() 

>>> (cwd / 'delicious' / 'walnut' / 'waffles').mkdir()  

Traceback (most recent call last): 

	File "<stdin>", line 1, in <module>  

	File "/usr/lib/python3.6/pathlib.py", line 1226, in mkdir  

	self._accessor.mkdir(self, mode) 

	File "/usr/lib/python3.6/pathlib.py", line 387, in wrapped 

	return strfunc(str(pathobj), *args) 

FileNotFoundError: [Errno 2] No such file or directory: '/home/asweigart/delicious/walnut/waffles'

Oh no, we got a nasty error! The reason is that the 'delicious' directory does not exist, so we cannot make the 'walnut' and the 'waffles' directories under it. To fix this, do:

>>> from pathlib import Path 

>>> cwd = Path.cwd() 

>>> (cwd / 'delicious' / 'walnut' / 'waffles').mkdir(parents=True)

And all is good :)

There are two ways to specify a file path.

• An absolute path, which always begins with the root folder
• A relative path, which is relative to the program’s current working directory

There are also the dot (.) and dot-dot (..) folders. These are not real folders but special names that can be used in a path. A single period (“dot”) for a folder name is shorthand for “this directory.” Two periods (“dot-dot”) means “the parent folder.”

To see if a path is an absolute path:

Using os.path on *nix:

>>> import os 

>>> os.path.isabs('/') 

True 

>>> os.path.isabs('..') 

False

Using pathlib on *nix:

>>> from pathlib import Path 

>>> Path('/').is_absolute() 

True 

>>> Path('..').is_absolute() 

False

You can extract an absolute path with both os.path and pathlib

Using os.path on *nix:

>>> import os 

>>> os.getcwd() 

'/home/asweigart' 

>>> os.path.abspath('..') 

'/home'

Using pathlib on *nix:

from pathlib import Path 

print(Path.cwd()) 

/home/asweigart 

print(Path('..').resolve()) 

/home

You can get a relative path from a starting path to another path.

Using os.path on *nix:

>>> import os 

>>> os.path.relpath('/etc/passwd', '/') 

'etc/passwd'

Using pathlib on *nix:

>>> from pathlib import Path 

>>> print(Path('/etc/passwd').relative_to('/')) 

etc/passwd

Checking if a file/directory exists:

Using os.path on *nix:

import os 

>>> os.path.exists('.') 

True 

>>> os.path.exists('setup.py') 

True 

>>> os.path.exists('/etc') 

True 

>>> os.path.exists('nonexistentfile') 

False

Using pathlib on *nix:

from pathlib import Path 

>>> Path('.').exists() 

True 

>>> Path('setup.py').exists() 

True 

>>> Path('/etc').exists() 

True 

>>> Path('nonexistentfile').exists() 

False

Checking if a path is a file:

Using os.path on *nix:

>>> import os 

>>> os.path.isfile('setup.py') 

True 

>>> os.path.isfile('/home') 

False 

>>> os.path.isfile('nonexistentfile') 

False

Using pathlib on *nix:

>>> from pathlib import Path 

>>> Path('setup.py').is_file() 

True 

>>> Path('/home').is_file() 

False 

>>> Path('nonexistentfile').is_file() 

False

Checking if a path is a directory:

Using os.path on *nix:

>>> import os 

>>> os.path.isdir('/') 

True 

>>> os.path.isdir('setup.py') 

False 

>>> os.path.isdir('/spam') 

False

Using pathlib on *nix:

>>> from pathlib import Path 

>>> Path('/').is_dir() 

True 

>>> Path('setup.py').is_dir() 

False 

>>> Path('/spam').is_dir() 

False

Getting a file's size in bytes:

Using os.path on Windows:

>>> import os 

>>> os.path.getsize('C:\\Windows\\System32\\calc.exe') 

776192

Using pathlib on *nix:

>>> from pathlib import Path 

>>> stat = Path('/bin/python3.6').stat() 

>>> print(stat) # stat contains some other information about the file as well 

os.stat_result(st_mode=33261, st_ino=141087, st_dev=2051, st_nlink=2, st_uid=0, 

--snip-- 

st_gid=0, st_size=10024, st_atime=1517725562, st_mtime=1515119809, st_ctime=1517261276) 

>>> print(stat.st_size) # size in bytes  

10024

Listing directory contents using os.listdir on Windows:

>>> import os 

>>> os.listdir('C:\\Windows\\System32') 

['0409', '12520437.cpx', '12520850.cpx', '5U877.ax', 'aaclient.dll', 

--snip-- 

'xwtpdui.dll', 'xwtpw32.dll', 'zh-CN', 'zh-HK', 'zh-TW', 'zipfldr.dll']

Listing directory contents using pathlib on *nix:

>>> from pathlib import Path 

>>> for f in Path('/usr/bin').iterdir(): 

>>>     print(f) 

... 

/usr/bin/tiff2rgba 

/usr/bin/iconv 

/usr/bin/ldd 

/usr/bin/cache_restore 

/usr/bin/udiskie 

/usr/bin/unix2dos 

/usr/bin/t1reencode 

/usr/bin/epstopdf 

/usr/bin/idle3 

...

To find the total size of all the files in this directory:

WARNING: Directories themselves also have a size! So you might want to check for whether a path is a file or directory using the methods in the methods discussed in the above section!

Using os.path.getsize() and os.listdir() together on Windows:

>>> import os 

>>> total_size = 0 
 


>>> for filename in os.listdir('C:\\Windows\\System32'): 

		total_size = total_size + os.path.getsize(os.path.join('C:\\Windows\\System32', filename)) 
 


>>> print(total_size) 

1117846456

Using pathlib on *nix:

>>> from pathlib import Path 

>>> total_size = 0 
 

>>> for sub_path in Path('/usr/bin').iterdir(): 

...     total_size += sub_path.stat().st_size 

>>> 

>>> print(total_size) 

1903178911

The shutil module provides functions for copying files, as well as entire folders.

>>> import shutil, os 
 


>>> os.chdir('C:\\') 
 


>>> shutil.copy('C:\\spam.txt', 'C:\\delicious') 

   'C:\\delicious\\spam.txt' 
 


>>> shutil.copy('eggs.txt', 'C:\\delicious\\eggs2.txt') 

   'C:\\delicious\\eggs2.txt'

While shutil.copy() will copy a single file, shutil.copytree() will copy an entire folder and every folder and file contained in it:

>>> import shutil, os 
 


>>> os.chdir('C:\\')



>>> shutil.copytree('C:\\bacon', 'C:\\bacon_backup')

'C:\\bacon_backup'

>>> import shutil 

>>> shutil.move('C:\\bacon.txt', 'C:\\eggs') 

'C:\\eggs\\bacon.txt'

The destination path can also specify a filename. In the following example, the source file is moved and renamed:

>>> shutil.move('C:\\bacon.txt', 'C:\\eggs\\new_bacon.txt') 

'C:\\eggs\\new_bacon.txt'

If there is no eggs folder, then move() will rename bacon.txt to a file named eggs.

>>> shutil.move('C:\\bacon.txt', 'C:\\eggs') 

'C:\\eggs'

• Calling os.unlink(path) or Path.unlink() will delete the file at path.
• Calling os.rmdir(path) or Path.rmdir() will delete the folder at path. This folder must be empty of any files or folders.
• Calling shutil.rmtree(path) will remove the folder at path, and all files and folders it contains will also be deleted.

You can install this module by running pip install send2trash from a Terminal window.

>>> import send2trash 
 


>>> with open('bacon.txt', 'a') as bacon_file: # creates the file 

...     bacon_file.write('Bacon is not a vegetable.') 

25 


>>> send2trash.send2trash('bacon.txt')

>>> import os 

>>> 

>>> for folder_name, subfolders, filenames in os.walk('C:\\delicious'): 

>>>     print('The current folder is {}'.format(folder_name)) 

>>> 

>>>     for subfolder in subfolders: 

>>>         print('SUBFOLDER OF {}: {}'.format( folder_name, subfolder)) 

>>>     for filename in filenames: 

>>>         print('FILE INSIDE {}: {}'.format(folder_name, filename)) 

>>> 

>>>     print('') 

The current folder is C:\delicious
SUBFOLDER OF C:\delicious: cats
SUBFOLDER OF C:\delicious: walnut
FILE INSIDE C:\delicious: spam.txt

The current folder is C:\delicious\cats
FILE INSIDE C:\delicious\cats: catnames.txt
FILE INSIDE C:\delicious\cats: zophie.jpg

The current folder is C:\delicious\walnut
SUBFOLDER OF C:\delicious\walnut: waffles

The current folder is C:\delicious\walnut\waffles
FILE INSIDE C:\delicious\walnut\waffles: butter.txt

To read/write to a file in Python, you will want to use the with statement, which will close the file for you after you are done.

>>> with open('C:\\Users\\your_home_folder\\hello.txt') as hello_file: 

...     hello_content = hello_file.read() 

>>> hello_content 

'Hello World!' 
 


>>> # Alternatively, you can use the *readlines()* method to get a list of string values from the file, one string for each line of text: 


>>> with open('sonnet29.txt') as sonnet_file: 

...     sonnet_file.readlines() 

[When, in disgrace with fortune and men's eyes,\n', ' I all alone beweep my 

outcast state,\n', And trouble deaf heaven with my bootless cries,\n', And  

look upon myself and curse my fate,'] 
 


>>> # You can also iterate through the file line by line: 

>>> with open('sonnet29.txt') as sonnet_file: 

...     for line in sonnet_file: # note the new line character will be included in the line 

...         print(line, end='') 
 


When, in disgrace with fortune and men's eyes,
I all alone beweep my outcast state,
And trouble deaf heaven with my bootless cries,
And look upon myself and curse my fate,

>>> with open('bacon.txt', 'w') as bacon_file: 

...     bacon_file.write('Hello world!\n') 

13 
 


>>> with open('bacon.txt', 'a') as bacon_file: 

...     bacon_file.write('Bacon is not a vegetable.') 

25 
 


>>> with open('bacon.txt') as bacon_file: 

...     content = bacon_file.read() 
 


>>> print(content) 

Hello world! 

Bacon is not a vegetable.

To save variables:

>>> import shelve 
 


>>> cats = ['Zophie', 'Pooka', 'Simon'] 

>>> with shelve.open('mydata') as shelf_file: 

...     shelf_file['cats'] = cats

To open and read variables:

>>> with shelve.open('mydata') as shelf_file: 

...     print(type(shelf_file)) 

...     print(shelf_file['cats']) 

<class 'shelve.DbfilenameShelf'> 

['Zophie', 'Pooka', 'Simon']

Just like dictionaries, shelf values have keys() and values() methods that will return list-like values of the keys and values in the shelf. Since these methods return list-like values instead of true lists, you should pass them to the list() function to get them in list form.

>>> with shelve.open('mydata') as shelf_file: 

...     print(list(shelf_file.keys())) 

...     print(list(shelf_file.values())) 

['cats'] 

[['Zophie', 'Pooka', 'Simon']]

>>> import print 
 


>>> cats = [{'name': 'Zophie', 'desc': 'chubby'},  
{'name': 'Pooka', 'desc': 'fluffy'}] 
 


>>> print.pformat(cats) 

"[{'desc': 'chubby', 'name': 'Zophie'}, {'desc':  
'fluffy', 'name': 'Pooka'}]" 
 


>>> with open('myCats.py', 'w') as file_obj: 

...     file_obj.write('cats = {}\n'.format( 
print.pformat(cats))) 

83

>>> import zipfile, os 
 


>>> os.chdir('C:\\')    # move to the folder with example.zip 

>>> with zipfile.ZipFile('example.zip') as example_zip: 

...     print(example_zip.namelist()) 

...     spam_info = example_zip.getinfo('spam.txt') 

...     print(spam_info.file_size) 

...     print(spam_info.compress_size)
...     print('Compressed file is %sx smaller!' % (round(spam_info.file_size / spam_info.compress_size, 2))) 


['spam.txt', 'cats/', 'cats/catnames.txt', 'cats/zophie.jpg'] 

13908 

3828 

'Compressed file is 3.63x smaller!'

The extractall() method for ZipFile objects extracts all the files and folders from a ZIP file into the current working directory.

>>> import zipfile, os 
 


>>> os.chdir('C:\\')    # move to the folder with example.zip 
 


>>> with zipfile.ZipFile('example.zip') as example_zip: 

...     example_zip.extractall()

The extract() method for ZipFile objects will extract a single file from the ZIP file. Continue the interactive shell example:

>>> with zipfile.ZipFile('example.zip') as example_zip: 

...     print(example_zip.extract('spam.txt')) 

...     print(example_zip.extract('spam.txt', 
 'C:\\some\\new\\folders')) 

'C:\\spam.txt' 

'C:\\some\\new\\folders\\spam.txt'

>>> import zipfile 



>>> with zipfile.ZipFile('new.zip', 'w') as new_zip:
...     new_zip.write('spam.txt', 
compress_type=zipfile.ZIP_DEFLATED)

Open a JSON file with:

import json 

with open("filename.json", "r") as f:

	content = json.loads(f.read())

Write a JSON file with:

import json 



content = {"name": "Joe", "age": 20}

with open("filename.json", "w") as f:

    f.write(json.dumps(content, indent=2))

YAML

Compared to JSON, YAML allows for much better human maintainability and gives you the option to add comments. It is a convenient choice for configuration files where humans will have to edit it.
There are two main libraries allowing to access to YAML files:

• PyYaml
• Ruamel.yaml

Install them using pip install in your virtual environment.

The first one it easier to use but the second one, Ruamel, implements much better the YAML specification, and allow for example to modify a YAML content without altering comments.
Open a YAML file with:

from ruamel.yaml import YAML 


with open("filename.yaml") as f:

    yaml=YAML()

    yaml.load(f)

Anyconfig is a very handy package allowing to abstract completely the underlying configuration file format. It allows to load a Python dictionary from JSON, YAML, TOML, and so on.

Install it with:

pip install anyconfig

Usage:

import anyconfig 


conf1 = anyconfig.load("/path/to/foo/conf.d/a.yml")

Exceptions are raised with a raise statement. In code, a raise statement consists of the following:

• The raise keyword
• A call to the Exception() function
• A string with a helpful error message passed to the Exception() function

>>> raise Exception('This is the error message.')
Traceback (most recent call last):
    File "<pyshell#191>", line 1, in <module>
        raise Exception('This is the error message.')
Exception: This is the error message.

Often it’s the code that calls the function, not the function itself, that knows how to handle an exception. So you will commonly see a raise statement inside a function and the try and except statements in the code calling the function.

def box_print(symbol, width, height): 

    if len(symbol) != 1: 

        raise Exception('Symbol must be a single character string.') 

    if width <= 2: 

		raise Exception('Width must be greater than 2.')

    if height <= 2: 

		raise Exception('Height must be greater than 2.') 

    print(symbol * width) 

    for i in range(height - 2): 

		print(symbol + (' ' * (width - 2)) + symbol)
	print(symbol * width) 

for sym, w, h in (('*', 4, 4), ('O', 20, 5), ('x', 1, 3), ('ZZ', 3, 3)): 

    try: 

        box_print(sym, w, h) 

    except Exception as err: 

        print('An exception happened: ' + str(err))

The traceback is displayed by Python whenever a raised exception goes unhandled. But can also obtain it as a string by calling traceback.format_exc(). This function is useful if you want the information from an exception’s traceback but also want an except statement to gracefully handle the exception. You will need to import Python’s traceback module before calling this function.

>>> import traceback 


>>> try: 

>>>      raise Exception('This is the error message.') 

>>> except: 

>>>      with open('errorInfo.txt', 'w') as error_file: 

>>>          error_file.write(traceback.format_exc()) 

>>>      print('The traceback info was written to  
errorInfo.txt.') 

116 

The traceback info was written to errorInfo.txt.

The 116 is the return value from the write() method, since 116 characters were written to the file. The traceback text was written to errorInfo.txt.

Traceback (most recent call last): 

	File "<pyshell#28>", line 2, in <module> 

	Exception: This is the error message.

An assertion is a sanity check to make sure your code isn’t doing something obviously wrong. These sanity checks are performed by assert statements. If the sanity check fails, then an AssertionError exception is raised. In code, an assert statement consists of the following:

• The assert keyword
• A condition (that is, an expression that evaluates to True or False)
• A comma
• A string to display when the condition is False

>>> pod_bay_door_status = 'open' 
  


>>> assert pod_bay_door_status == 'open', 'The pod bay doors need to be "open".' 
 


>>> pod_bay_door_status = 'I\'m sorry, Dave. I\'m afraid I can\'t do that.' 
 


>>> assert pod_bay_door_status == 'open', 'The pod bay doors need to be "open".' 
 


Traceback (most recent call last): 

     File "<pyshell#10>", line 1, in  <module> 

         assert pod_bay_door_status == 'open', 'The pod bay doors need to be "open".'  

AssertionError: The pod bay doors need to be "open".

To enable the logging module to display log messages on your screen as your program runs, copy the following to the top of your program (but under the #! python shebang line):

import logging 


logging.basicConfig(level=logging.DEBUG, format=' %(asctime)s - %(levelname)s- %(message)s')

Say you wrote a function to calculate the factorial of a number. In mathematics, factorial 4 is 1 × 2 × 3 × 4, or 24. Factorial 7 is 1 × 2 × 3 × 4 × 5 × 6 × 7, or 5,040. Open a new file editor window and enter the following code. It has a bug in it, but you will also enter several log messages to help yourself figure out what is going wrong. Save the program as factorialLog.py.

>>> import logging 

>>> 

>>> logging.basicConfig(level=logging.DEBUG, format=' %(asctime)s - %(levelname)s- %(message)s') 

>>> 

>>> logging.debug('Start of program') 

>>> 

>>> def factorial(n): 

>>> 

>>>     logging.debug('Start of factorial(%s)' % (n)) 

>>>     total = 1 

>>> 

>>>     for i in range(1, n + 1): 

>>>         total *= i 

>>>         logging.debug('i is ' + str(i) + ', total is ' + str(total)) 

>>> 

>>>     logging.debug('End of factorial(%s)' % (n)) 

>>> 

>>>     return total 

>>>
>>> print(factorial(5)) 

>>> logging.debug('End of program') 

2015-05-23 16:20:12,664 - DEBUG - Start of program 

2015-05-23 16:20:12,664 - DEBUG - Start of factorial(5) 

2015-05-23 16:20:12,665 - DEBUG - i is 0, total is 0 

2015-05-23 16:20:12,668 - DEBUG - i is 1, total is 0 

2015-05-23 16:20:12,670 - DEBUG - i is 2, total is 0 

2015-05-23 16:20:12,673 - DEBUG - i is 3, total is 0 

2015-05-23 16:20:12,675 - DEBUG - i is 4, total is 0 

2015-05-23 16:20:12,678 - DEBUG - i is 5, total is 0
2015-05-23 16:20:12,680 - DEBUG - End of factorial(5) 

0 

2015-05-23 16:20:12,684 - DEBUG - End of program

After you’ve debugged your program, you probably don’t want all these log messages cluttering the screen. The logging.disable() function disables these so that you don’t have to go into your program and remove all the logging calls by hand.

>>> import logging 
 


>>> logging.basicConfig(level=logging.INFO, format=' %(asctime)s -%(levelname)s - %(message)s') 
 


>>> logging.critical('Critical error! Critical error!')
2015-05-22 11:10:48,054 - CRITICAL - Critical error! Critical error! 
 


>>> logging.disable(logging.CRITICAL) 
 


>>> logging.critical('Critical error! Critical error!') 
 


>>> logging.error('Error! Error!')

Instead of displaying the log messages to the screen, you can write them to a text file. The logging.basicConfig() function takes a filename keyword argument, like so:

import logging 
 


logging.basicConfig(filename='myProgramLog.txt', level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')

This function:

>>> def add(x, y): 

		return x + y


>>> add(5, 3)

8

Is equivalent to the lambda function:

>>> add = lambda x, y: x + y

>>> add(5, 3)

8

It's not even need to bind it to a name like add before:

>>> (lambda x, y: x + y)(5, 3) 

8

Like regular nested functions, lambdas also work as lexical closures:

>>> def make_adder(n): 

		return lambda x: x + n 
 


>>> plus_3 = make_adder(3) 

>>> plus_5 = make_adder(5) 
 


>>> plus_3(4) 

7 

>>> plus_5(4)
9

Many programming languages have a ternary operator, which define a conditional expression. The most common usage is to make a terse simple conditional assignment statement. In other words, it offers one-line code to evaluate the first expression if the condition is true, otherwise it evaluates the second expression.

<expression1> if <condition> else <expression2>

Example:

>>> age = 15 


>>> print('kid' if age < 18 else 'adult')

kid

Ternary operators can be chained:

>>> age = 15 


>>> print('kid' if age < 13 else 'teenager' if age < 18 else 'adult') 

teenager

The code above is equivalent to:

if age < 18: 

    if age < 13: 

        print('kid') 

    else: 

        print('teenager') 

else: 

    print('adult')

The names args and kwargs are arbitrary - the important thing are the * and ** operators. They can mean:

1. In a function declaration, * means “pack all remaining positional arguments into a tuple named ”, while ** is the same for keyword arguments (except it uses a dictionary, not a tuple).
2. In a function call, * means “unpack tuple or list named to positional arguments at this position”, while ** is the same for keyword arguments.

For example you can make a function that you can use to call any other function, no matter what parameters it has:

def forward(f, *args, **kwargs):
    return f(*args, **kwargs)

Inside forward, args is a tuple (of all positional arguments except the first one, because we specified it - the f), kwargs is a dict. Then we call f and unpack them so they become normal arguments to f.

You use *args when you have an indefinite amount of positional arguments.

>>> def fruits(*args): 

>>>    for fruit in args: 

>>>       print(fruit) 


>>> fruits("apples", "bananas", "grapes") 
 


"apples" 

"bananas" 

"grapes"

Similarly, you use **kwargs when you have an indefinite number of keyword arguments.

>>> def fruit(**kwargs): 

>>>    for key, value in kwargs.items(): 

>>>        print("{0}: {1}".format(key, value)) 
 


>>> fruit(name = "apple", color = "red") 
 


name: apple 

color: red

>>> def show(arg1, arg2, *args, kwarg1=None,  
kwarg2=None, **kwargs): 

>>>   print(arg1) 

>>>   print(arg2) 

>>>   print(args) 

>>>   print(kwarg1) 

>>>   print(kwarg2) 

>>>   print(kwargs) 
 


>>> data1 = [1,2,3] 

>>> data2 = [4,5,6] 

>>> data3 = {'a':7,'b':8,'c':9} 
 


>>> show(*data1,*data2,  
kwarg1="python",kwarg2="cheatsheet",**data3) 

1 

2 

(3, 4, 5, 6) 

python 

cheatsheet 

{'a': 7, 'b': 8, 'c': 9} 
 


>>> show(*data1, *data2, **data3) 

1 

2 

(3, 4, 5, 6) 

None 

None 

{'a': 7, 'b': 8, 'c': 9} 
 


# If you do not specify ** for kwargs 

>>> show(*data1, *data2, *data3) 

1 

2 

(3, 4, 5, 6, "a", "b", "c") 

None 

None 

{}

The setup script is the centre of all activity in building, distributing, and installing modules using the Distutils. The main purpose of the setup script is to describe your module distribution to the Distutils, so that the various commands that operate on your modules do the right thing.

The setup.py file is at the heart of a Python project. It describes all of the metadata about your project. There a quite a few fields you can add to a project to give it a rich set of metadata describing the project. However, there are only three required fields: name, version, and packages. The name field must be unique if you wish to publish your package on the Python Package Index (PyPI). The version field keeps track of different releases of the project. The packages field describes where you’ve put the Python source code within your project.

This allows you to easily install Python packages. Often it's enough to write:

python setup.py install

and module will install itself.
Our initial setup.py will also include information about the license and will re-use the README.txt file for the long_description field. This will look like:

>>> from distutils.core import setup 

>>> setup( 

...    name='pythonCheatsheet', 

...    version='0.1', 

...    packages=['pipenv',], 

...    license='MIT', 

...    long_description=open('README.txt').read(), 

... )

Dataclasses are python classes but are suited for storing data objects. This module provides a decorator and functions for automatically adding generated special methods such as __init__() and __repr__() to user-defined classes.

Features

1. They store data and represent a certain data type. Ex: A number. For people familiar with ORMs, a model instance is a data object. It represents a specific kind of entity. It holds attributes that define or represent the entity.
2. They can be compared to other objects of the same type. Ex: A number can be greater than, less than, or equal to another number.

Python 3.7 provides a decorator dataclass that is used to convert a class into a dataclass.

>>> class Number: 

...     def __init__(self, val): 

...         self.val = val 

... 

>>> obj = Number(2) 

>>> obj.val 

2

with dataclass

>>> @dataclass  

... class Number: 

...     val: int 

... 

>>> obj = Number(2) 

>>> obj.val 

2