fluent-python

from math import hypot


class Vector:
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y

    def __repr__(self):
        return 'Vector(%r, %r)' % (self.x, self.y)

    def __abs__(self):
        return hypot(self.x, self.y)

    def __bool__(self):
        return bool(abs(self))

    def __add__(self, other):
        x = self.x + other.x
        y = self.y + other.y
        return Vector(x, y)

    def __mul__(self, scalar):
        return Vector(self.x * scalar, self.y * scalar)


def main():
    v1 = Vector(2, 4)
    v2 = Vector(2, 1)

    print(v1 + v2)
    v = Vector(3, 4)
    print(abs(v))
    print(v * 3)
    print(abs(v * 3))


if __name__ == '__main__':
    main()


# <===================OUTPUT===================>
# Vector(4, 5)
# 5.0
# Vector(9, 12)
# 15.0

def __bool__(self):
       return bool(abs(self))

symbols = 'abcde'
codes = []
for symbol in symbols:
    codes.append(ord(symbol))

print(codes)

# <===================OUTPUT===================>
# [97, 98, 99, 100, 101]

symbols = 'abcde'
codes = [ord(symbol) for symbol in symbols]
print(codes)

# <===================OUTPUT===================>
# [97, 98, 99, 100, 101]

colors = ['black', 'white']
sizes = ['S', 'M', 'L']

for color in colors:
    for size in sizes:
        print((color, size))

# <===================OUTPUT===================>
# ('black', 'S')
# ('black', 'M')
# ('black', 'L')
# ('white', 'S')
# ('white', 'M')
# ('white', 'L')

colors = ['black', 'white']
sizes = ['S', 'M', 'L']

tshirts = [(color, size) for color in colors for size in sizes]
print(tshirts)

# <===================OUTPUT===================>
# [('black', 'S'), ('black', 'M'), ('black', 'L'),
# ('white', 'S'), ('white', 'M'), ('white', 'L')]

colors = ['black', 'white']
sizes = ['S', 'M', 'L']

tshirts = [(color, size) for size in sizes
           for color in colors]
print(tshirts)

# <===================OUTPUT===================>
# [('black', 'S'), ('white', 'S'), ('black', 'M'),
#  ('white', 'M'), ('black', 'L'), ('white', 'L')]

t_from_l = tuple([n for n in range(5)])
print(t_from_l)

# <===================OUTPUT===================>
# (0, 1, 2, 3, 4)

import array
symbols = 'abcde'
print(array.array('I', (ord(symbol) for symbol in symbols)))
# <===================OUTPUT===================>
# array('I', [97, 98, 99, 100, 101])

colors = ['black', 'white']
sizes = ['S', 'M', 'L']

for color in colors:
    for size in sizes:
        print((color, size))

# <===================OUTPUT===================>
# ('black', 'S')
# ('black', 'M')
# ('black', 'L')
# ('white', 'S')
# ('white', 'M')
# ('white', 'L')

colors = ['black', 'white']
sizes = ['S', 'M', 'L']

for tshirt in ('%s %s' % (c, s) for c in colors for s in sizes):
    print(tshirt)

# <===================OUTPUT===================>
# black S
# black M
# black L
# white S
# white M
# white L

lax_coordinates = (33.9425, -118.408056)
city, year, pop, chg, area = ('Tokyo', 2003, 32450, 0.66, 8014)
traveler_ids = [('USA', '31195855'),
                ('BAR', 'CE342567'), ('ESP', 'XDA205856')]

for passport in sorted(traveler_ids):
    print('%s/%s' % passport)

for country, _ in traveler_ids:
    print(country)

# <===================OUTPUT===================>
# BAR/CE342567
# ESP/XDA205856
# USA/31195855
# USA
# BAR
# ESP

a, (b1, b2), c = [1, [2, 3], 4]
print(b1)
print(b2)

# <===================OUTPUT===================>
# 2
# 3

def fn(a, (b, c), d):
    pass

from collections import namedtuple

City = namedtuple('City', 'name country population coordinates')
tokyo = City('Tokyo', 'JP', 36.933, (35.689722, 139.691667))
print(tokyo)
print(tokyo.population)
print(tokyo.coordinates)
print(tokyo[1])

# <===================OUTPUT===================>
# City(name='Tokyo', country='JP', population=36.933, coordinates=(35.689722, 139.691667))
# 36.933
# (35.689722, 139.691667)
# JP

from collections import namedtuple

City = namedtuple('City', 'name country population coordinates')

print(City._fields)
LatLong = namedtuple('LatLong', 'lat long')
delhi_data = ('Delhi NCR', 'IN', 21.935, LatLong(28.613889, 77.208889))
delhi = City._make(delhi_data)
print(delhi)

for key, value in delhi._asdict().items():
    print(key + ":", value)

# <===================OUTPUT===================>
# ('name', 'country', 'population', 'coordinates')
# City(name='Delhi NCR', country='IN', population=21.935, coordinates=LatLong(lat=28.613889, long=77.208889))
# name: Delhi NCR
# country: IN
# population: 21.935
# coordinates: LatLong(lat=28.613889, long=77.208889)

a = [1, 2, 3]
a.reverse()
print(a)

b = (1, 2, 3)
b = tuple(reversed(b))
print(b)

# <===================OUTPUT===================>
# [3, 2, 1]
# (3, 2, 1)

s = '1234567'
print(s[::3])

# <===================OUTPUT===================>
# 147

s = '1234567'
print(s[::-2])

# <===================OUTPUT===================>
# 7531

s = '1234567'
print(s[::-1])

# <===================OUTPUT===================>
# 7654321

seq.__getitem__(slice(start, stop, step))

invoice = """
0.....6.................................40........52...55........
1909  Pimoroni PiBrella                     $17.50    3    $52.50
1489  6mm Tactile Switch x20                 $4.95    2     $9.90
1510  Panavise Jr. - PV-201                 $28.00    1    $28.00
1601  PiTFT Mini Kit 320x240                $34.95    1    $34.95
"""

SKU         = slice(0,  6)
DESCRIPTION = slice(6,  40)
UNIT_PRICE  = slice(40, 52)
QUANTITY    = slice(52, 55)
ITEM_TOTAL  = slice(55, None)

for item in invoice.split('\n')[2:-1]:
    print(item[UNIT_PRICE].strip(), item[DESCRIPTION].strip())

# <===================OUTPUT===================>
# ('$17.50', 'Pimoroni PiBrella')
# ('$4.95', '6mm Tactile Switch x20')
# ('$28.00', 'Panavise Jr. - PV-201')
# ('$34.95', 'PiTFT Mini Kit 320x240')

import numpy
a = numpy.arange(12)
a.shape = 3, 4
print(a)
print(a[2, 1])

# <===================OUTPUT===================>
# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]]
# 9

l = list(range(10))
print(l)
l[2:5] = [20, 30]
print(l)

##########################################
# TypeError: can only assign an iterable #
# l[2:5] = 100                           #
##########################################

l[2:5] = [100]
print(l)

# <===================OUTPUT===================>
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# [0, 1, 20, 30, 5, 6, 7, 8, 9]
# [0, 1, 100, 6, 7, 8, 9]

l = list(range(10))
print(l)
del l[2:5]
print(l)

# <===================OUTPUT===================>
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# [0, 1, 5, 6, 7, 8, 9]

a = [['_'] * 3 for i in range(3)]
print(a)
a[1][2] = '0'
print(a)

# <===================OUTPUT===================>
# [['_', '_', '_'], ['_', '_', '_'], ['_', '_', '_']]
# [['_', '_', '_'], ['_', '_', '0'], ['_', '_', '_']]

board = []
for i in range(3):
    row = ['_'] * 3
    board.append(row)
print(board)
board[1][2] = '0'
print(board)

# <===================OUTPUT===================>
# [['_', '_', '_'], ['_', '_', '_'], ['_', '_', '_']]
# [['_', '_', '_'], ['_', '_', '0'], ['_', '_', '_']]

>>> t = (1, 2, [30, 40])
>>> t[2] += [50, 60]

Python 3.6.1 (default, Mar 23 2017, 16:49:06)
[GCC 4.2.1 Compatible Apple LLVM 8.0.0 (clang-800.0.42.1)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> python.el: native completion setup loaded
>>> import dis
>>> dis.dis('s[a] += b')
  1           0 LOAD_NAME                0 (s)
              2 LOAD_NAME                1 (a)
              4 DUP_TOP_TWO
              6 BINARY_SUBSCR
              8 LOAD_NAME                2 (b)
             10 INPLACE_ADD
             12 ROT_THREE
             14 STORE_SUBSCR
             16 LOAD_CONST               0 (None)
             18 RETURN_VALUE

>>> a = [1, 2, 3, 4]
>>> bisect.bisect(a, 2.5)
2
>>> a.insert(bisect.bisect(a, 2.5), 2.5)
>>> a
[1, 2, 2.5, 3, 4]

>>> a = [1, 2, 3, 4, 5]
>>> bisect.bisect(a, 6, lo=0, hi=3)
3
>>> bisect.bisect(a, 6)
5

import bisect
import random

SIZE = 7
random.seed(1729)

my_list = []
for i in range(SIZE):
    new_item = random.randrange(SIZE*2)
    bisect.insort(my_list, new_item)
    print('%2d ->' % new_item, my_list)

# <===================OUTPUT===================>
# 10 -> [10]
#  0 -> [0, 10]
#  6 -> [0, 6, 10]
#  8 -> [0, 6, 8, 10]
#  7 -> [0, 6, 7, 8, 10]
#  2 -> [0, 2, 6, 7, 8, 10]
# 10 -> [0, 2, 6, 7, 8, 10, 10]

from types import MappingProxyType
d = {1: 'A'}
d_proxy = MappingProxyType(d)
print(d_proxy)

#####################################################################
# Traceback (most recent call last):                                #
#   File "c:/Users/hfeng/tmp/one.py", line 5, in <module>           #
#     d_proxy[1] = 'x'                                              #
# TypeError: 'mappingproxy' object does not support item assignment #
#####################################################################
# d_proxy[1] = 'x'

# <===================OUTPUT===================>
# {1: 'A'}

>>> s = {1}
>>> type(s)
<type 'set'>

>>> s = {...}
>>> type(s)
<class 'set'>

>>> frozenset(range(10))
frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})

>>> { i for i in range(10, 20) }
{10, 11, 12, 13, 14, 15, 16, 17, 18, 19}

>>> print(sys.version_info)
sys.version_info(major=2, minor=7, micro=13, releaselevel='final', serial=0)
>>> print type(b'byte type does not exist, it is str in python2')
<type 'str'>

>>> print(sys.version_info)
sys.version_info(major=3, minor=6, micro=1, releaselevel='final', serial=0)
>>> print('strings are now utf-8 \u03BCnico\u0394é!')
strings are now utf-8 μnicoΔé!
>>> print(type(b'python3 has bytes type'))
<class 'bytes'>

>>> print(sys.version_info)
sys.version_info(major=2, minor=7, micro=13, releaselevel='final', serial=0)
>>> print type(unicode('this is like a python3 str type'))
<type 'unicode'>

>>> print(sys.version_info)
sys.version_info(major=3, minor=6, micro=1, releaselevel='final', serial=0)
>>> type("hello")
<class 'str'>
>>> type(b"world")
<class 'bytes'>
>>> "hello" + b"world"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: must be str, not bytes

# coding: cp1252

def factorial():
    pass

for one in dir(factorial):
    print(one)

# <===================OUTPUT===================>
# __annotations__
# __call__
# __class__
# __closure__
# __code__
# __defaults__
# __delattr__
# __dict__
# __dir__
# __doc__
# __eq__
# __format__
# __ge__
# __get__
# __getattribute__
# __globals__
# __gt__
# __hash__
# __init__
# __init_subclass__
# __kwdefaults__
# __le__
# __lt__
# __module__
# __name__
# __ne__
# __new__
# __qualname__
# __reduce__
# __reduce_ex__
# __repr__
# __setattr__
# __sizeof__
# __str__
# __subclasshook__

class User():
    def __init__(self, name):
        self.name = name
    def display(self):
        print(self.name)

u = User('Alice')
print(u.__dict__)
u.display()
u.name = 'Bill'
u.display()

u.age = 23
print(u.name, u.age)
print(u.__dict__)

# <===================OUTPUT===================>
# print(u.__dict__)
# Alice
# Bill
# Bill 23
# {'name': 'Bill', 'age': 23}

def upper_case_name(obj):
    return obj.upper()

print(upper_case_name.__dict__)
upper_case_name.short_description = 'Customer name'
print(upper_case_name.__dict__)
print(upper_case_name.short_description)

# <===================OUTPUT===================>
# {}
# {'short_description': 'Customer name'}
# Customer name

class C:
    pass
obj = C()
def func():
    pass

print(sorted(set(dir(func)) - set(dir(obj))))

# <===================OUTPUT===================>
# ['__annotations__', '__call__', '__closure__', '__code__',
#  '__defaults__', '__get__', '__globals__', '__kwdefaults__',
#  '__name__', '__qualname__']

def html_tag(*args, **kwargs):
    print(args)
    print(kwargs)


html_tag('div', 'hello', name="img")

###############################
# SyntaxError: invalid syntax #
###############################
# html_tag('div', 'hello', name="img", class='sidebar')


# <===================OUTPUT===================>
# ('div', 'hello')
# {'name': 'img'}

def html_tag(*args, cls=None, **kwargs):
    if cls is not None:
        kwargs['class'] = cls
    print(args)
    print(kwargs)


html_tag('div', 'hello', name="img")
html_tag('div', 'hello', cls='sidebar', name="img")


# <===================OUTPUT===================>
# ('div', 'hello')
# {'name': 'img'}
# ('div', 'hello')
# {'name': 'img', 'class': 'sidebar'}