def myfunc(x, y, z):
    print(x, y, z)

tuple_vec = (1, 0, 1)
dict_vec = {'x': 1, 'y': 0, 'z': 1}

>>> myfunc(*tuple_vec)
1, 0, 1

>>> myfunc(**dict_vec)
1, 0, 1

>>> f = []
>>> f = list()

>>> timeit.timeit(‘[]’, number=10**8)
2.25569809000001
>>> timeit.timeit(‘list()’, number=10**8)
10.330681907999995

>>> dis.dis('f=[]')
  1           0 BUILD_LIST               0
              2 STORE_NAME               0 (f)
              4 LOAD_CONST               0 (None)
              6 RETURN_VALUE
>>> dis.dis('f=list()')
  1           0 LOAD_NAME                0 (list)
              2 CALL_FUNCTION            0
              4 STORE_NAME               1 (f)
              6 LOAD_CONST               0 (None)
              8 RETURN_VALUE

def check_size(val):
    if val > 0x18:
        val >>= 1
    return val


def dga(seed):
    out = ""
    for k, n in enumerate([1, 3, 5, 7, 0xb, 0xd]):
        i = check_size(k * seed)
        out += chr(i + 0x61)
    return out


if __name__ == '__main__':
    print('al' + dga(1))

>>> type(None)
< class 'NoneType’>

number = None

if number is None:
    print(‘None’)

class MyClass:
    def __eq__(self, my_object):
        return True

my_class = MyClass()

if my_class is None:
    print('my_class is None, using the is keyword')
else:
    print('my_class is not None, using the is keyword')

if my_class == None:
    print('my_class is None, using the == syntax')
else:
    print('my_class is not None, using the == syntax’)

my_class is not None, using the is keyword
my_class is None, using the == syntax

class SimpleIterator:
    def __iter__(self):
        return self
 
    def __init__(self, limit):
        self.limit = limit
        self.counter = 0
 
    def __next__(self):
        if self.counter < self.limit:
            self.counter += 1
            return 1
        else:
            raise StopIteration

simple_iter = SimpleIterator(5)
 
for i in simple_iter:
    print(i)
1
1
1
1
1

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

>>> a is b
True
>>> a == b
True

>>> c = a[:]

>>> a == c
True
>>> a is c
False

$ pip3 install pycodestyle

$ pycodestyle smooth.py
smooth.py:3:1: E265 block comment should start with '# '
smooth.py:4:1: E265 block comment should start with '# '
smooth.py:5:1: E265 block comment should start with '# '
smooth.py:10:51: E251 unexpected spaces around keyword / parameter equals
smooth.py:10:53: E251 unexpected spaces around keyword / parameter equals
smooth.py:14:33: W292 no newline at end of file

def myfunc(a, b):
    return a + b

>>> funcs = [myfunc]
>>> funcs[0]
<function myfunc at 0x107012230>
>>> funcs[0](2, 3)
5

def outer(x): 
    def inner(y): 
        return x+y 
  
    return inner 
  
closure = outer(15)

>>> closure(10)
25

>>> a = 256
>>> b = 256
>>> id(a)
4478229648
>>> id(b)
4478229648

>>> a = 257
>>> b = 257
>>> id(a)
4481407824
>>> id(b)
4481407600

>>> import timeit
>>> timeit.timeit('"-".join(str(n) for n in range(100))',
                  number=10000)
0.3412662749997253

>>> timeit.timeit('"-".join([str(n) for n in range(100)])',
                  number=10000)
0.2996307989997149

>>> timeit.timeit('"-".join(map(str, range(100)))',
                  number=10000)
0.24581470699922647

def dispatch_if(operator, x, y):
    if operator == 'add':
        return x + y
    elif operator == 'sub':
        return x - y
    elif operator == 'mul':
        return x * y
    elif operator == 'div':
        return x / y
    else:
        return None

def dispatch_dict(operator, x, y):
    return {
        'add': lambda: x + y,
        'sub': lambda: x - y,
        'mul': lambda: x * y,
        'div': lambda: x / y,
    }.get(operator, lambda: None)()

>>> dispatch_if('mul', 2, 8)
16

>>> dispatch_dict('mul', 2, 8)
16

>>> dispatch_if('unknown', 2, 8)
None

>>> dispatch_dict('unknown', 2, 8)
None

$ pip install geopy

from geopy import GoogleV3

place = "221b Baker Street, London"
location = GoogleV3().geocode(place)

print(location.address)
print(location.location)

# Python 3.x
$ python3 -m http.server

# Python 2.x
$ python -m SimpleHTTPServer 8000

def get_palindrom(text):
    text = text.lower()
    results = []

    for i in range(len(text)):
        for j in range(0, i):
            chunk = text[j:i + 1]

            if chunk == chunk[::-1]:
                results.append(chunk)

    return results

for index in range(len(word)):
    if word[index] == word[-(index + 1)]:
        results.append(word)

if list(word) == list(reversed(word)):
    results.append(word)

if word == word[::-1]:
    results.append(word)

>>> x = [1, 2, 3]
>>> y = iter(x)
>>> z = iter(x)
>>> next(y)
1
>>> next(y)
2
>>> next(z)
1

x = [1, 2, 3]
for item in x:
    pass

>>> import dis
>>> x = [1, 2, 3]
>>> dis.dis('for _ in x: pass')
  1           0 SETUP_LOOP              14 (to 17)
              3 LOAD_NAME                0 (x)
              6 GET_ITER
        >>    7 FOR_ITER                 6 (to 16)
             10 STORE_NAME               1 (_)
             13 JUMP_ABSOLUTE            7
        >>   16 POP_BLOCK
        >>   17 LOAD_CONST               0 (None)
             20 RETURN_VALUE