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

>>> from itertools import count
>>> counter = count(start=1)
>>> next(counter)
1
>>> next(counter)
2

>>> from itertools import cycle
>>> colors = cycle(['red', 'white', 'blue'])
>>> next(colors)
'red'
>>> next(colors)
'white'
>>> next(colors)
'blue'
>>> next(colors)
'red’

>>> from itertools import islice
>>> colors = cycle(['red', 'white', 'blue'])
>>> limited = islice(colors, 0, 4)
>>> for x in limited:                         
...     print(x)
red
white
blue
red

>>> def fib():
...     a, b = 0, 1
...     while True:
...         yield b
...         a, b = b, a + b
...
>>> f = fib()
>>> list(islice(f, 0, 10))
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

f = fib()

vals = [expression 
        for value in collection 
        if condition]

vals = []
for value in collection:
    if condition:
        vals.append(expression)

>>> even_squares = [x * x for x in range(10) if not x % 2]
>>> even_squares
[0, 4, 16, 36, 64]

>>> numbers = [1, 2, 3, 4, 5, 6]
>>> [x * x for x in numbers]
[1, 4, 9, 16, 25, 36]

>>> {x * x for x in numbers}
{1, 4, 36, 9, 16, 25}

>>> {x: x * x for x in numbers}
{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36}

>>> lazy_squares = (x * x for x in numbers)
>>> lazy_squares
 at 0x10d1f5510>

def something():
    result = []
    for ... in ...:
        result.append(x)
    return result

def iter_something():
    for ... in ...:
        yield x