Python

if boolean_expression1:
  suite1
elif boolean_expression2:
  suite2
else:
  suite3

expression1 if boolean_expression1 else expression2

while boolean_expression:
  suite1
else: 
# If the loop above does not terminate normally(break statement, return statement or exception), suite2 is skipped.
  suite2

for expression in iterable:
  suite1
else:
# If the loop above does not terminate normally(break statement, return statement or exception), suite2 is skipped.
  suite2

h = {1:1, 3:3, 2:2}

#g = ((key, h[key]) for key in sorted(h)) # It is not a tuple, it is a generator

def generator(d):
    for key in sorted(d):
        rcv = yield key, d[key]
        print("rcv: ", rcv)

g1 = generator(h)
for i in g1: # repeat calling g1.next() until StopIteration
    print(i)
    print()
print("############")

g2 = generator(h)
for i in range(3):
    print(next(g2)) # g2.next() is called
    print()
print("############")

g3 = generator(h)
print(g3.send(None)) 
for i in range(2):
    print()
    print(g3.send(i))

import functools

seasons = ("Spring", "Summer", "Fall", "Winter")
print(list(enumerate(seasons)))

enumerate1 = functools.partial(enumerate, start=1)
print(list(enumerate1(seasons)))

def decorator_maker_with_arguments(s):
    print("decorator_maker_with_arguments: ", s)

    def my_decorate(func):
        print("my_decorate ", s)

        @functools.wraps(func) # wrap the function wrapper to make it has the name and docstring of func 
        def wrapper(x):
            print("Before %s(%s)"%(func.__name__, x))
            func(x)
            print("After %s(%s)"%(func.__name__, x))

        return wrapper

    return my_decorate


@decorator_maker_with_arguments("arguments")
def lazy_func(x):
    print("lazy_func(%s)"%x)

# it is equal to decorator_maker_with_arguments("arguments")(lazy_func)("test") 
# when no @decorator_maker_with_arguments("arguments")
lazy_func("test")

import math

def outer(oarg):
  code = '''
def inner(iarg): 
  print("oarg: %d, iarg: %d"%(oarg, iarg))
  return math.pi * iarg * oarg 
  '''

  ctxt = {}
  ctxt["math"] = math
  ctxt["oarg"] = oarg
  exec(code, ctxt)
  inner = ctxt["inner"]
  print(inner(3))

outer(2)

class Lazy:
    rule = "DefaultClassVariable" # create class variabe inside the class defination, but outside of definations of methods
    def __init__(self):
        #self.rule = "DefaultInstanceVariable" # create an instance variable
        print("\t", self.rule) # if no instance variable, refer to class variable

a = Lazy()
b = Lazy()
print()

print(a.rule) # if no instance variable, refer to class variable
print(b.rule) # 
print(a.__class__.rule)
print(b.__class__.rule)
print()

a.rule = "InstanceVariable" # create an instance variable just for a
print(a.rule)
print(b.rule)
print(a.__class__.rule)
print(b.__class__.rule)
print()

a.__class__.rule = "ClassVariable" # explicitely refer to class variable
print(a.rule)
print(b.rule)
print(a.__class__.rule)
print(b.__class__.rule)

class Point:
    __slots__ = ("x", "y") 
    def __init__(self, x=0, y=0):
        self.x, self.y = x, y
    def __str__(self):
        return ".x: %d, .y: %d"%(self.x, self.y)

p = Point(1,2)
#print(p.__dict__) # it has no __dict__ attribute because of __slots__
print(p)
p.y = 4 # you can change the value of attributes
del(p.y); p.y = 7 # you can remove the attribute declared in __slots__, and add it later
print(p)
#p.z = 5 # you cannot add other attributes because of __slots__

useProperty = False

class Image:
    def __init__(self, width, height):
        self.__width = width  # self.__setattr__("_{classname}__width", width) is called
        self.__height = height

    if useProperty:
        @property
        def width(self):
            return self.__width

        @property
        def height(self):
            return self.__height
    else:
        def __getattr__(self, name):
            classname = self.__class__.__name__
            if name in frozenset({"width", "height"}):
                return self.__dict__["_{classname}__{name}".format(**locals())]
            raise AttributeError("'{classname}' object has no attribute '{name}'".format(**locals()))

        def __setattr__(self, name, value):
            classname = self.__class__.__name__
            if name in frozenset({"width", "height"}):
                raise AttributeError("the attribute '{name}' of {classname} object is immutable".format(**locals()))
            elif name.startswith("_%s"%classname):
                self.__dict__[name] = value

if __name__ == '__main__':
    img = Image(20, 30)
    print("w: %s, h: %s"%(img.width, img.height))

#    img.width = 40 # AttributeError: the attribute 'width' of Image object is immutable

    img._Image__width = 40 
    print("w: %s, h: %s"%(img.width, img.height))

class Circle(Point):
    def __init__(self, radius, x=0, y=0):
        super().__init__(x, y)
        self.__radius = radius

    @property # property function takes radius function as getter argument, and returns a property instance
    def radius(self):
        return self.__radius

    @radius.setter # @radius returns an object of class property
    def radius(self, radius):
        assert radius>0, "radius must be positive"
        self.__radius = radius

c = Circle(6, 3, 4)
print(c.radius)
#print(c.radius()) Error 'float' is not callable
#c.radius = 0 Error "radius must be positive"
c.radius = 9
print(c.radius)
#del c.radius Error: cannot delete attribute

class Celsius:
    '''
    the owner is class Temperature.
    the instance is None if the attribute(celsius) is accessed from the class(/Temperature/).
    its return value is given to the code that requests the value of the attribute.
    '''
    def __get__(self, instance, owner):
        return 5 * (instance.fahrenheit - 32) /9
    def __set__(self, instance, value): # it should not return anything
        instance.fahrenheit =32 + 9 * value / 5

class Temperature:
    def __init__(self, v):
        self.fahrenheit = v
        #To add an instance attribute celsius, you should self.__dict__["celsius"] = 5 because self.celsius = 5 calls __set__ of Celsius
    celsius = Celsius()

t = Temperature(212)
print(t.celsius)
t.celsius = 0
print(t.fahrenheit)

 class Child():
    def __getattr__(self, name):
        if name == "foo":
            return "Fifth"    

def getattribute1(self, name):
    if name == "foo":
        return "First"
    return object.__getattribute__(self, name)

def getattribute2(self, name):
    if name == "foo":
        raise AttributeError("as")
    return object.__getattribute__(self, name)

bar = Child()

Child.foo = "Fourth"
print(bar.__class__.__dict__, bar.__dict__)
print(bar.foo) #print(Child.__dict__['foo'])

bar.foo = "Third"
print(bar.__class__.__dict__, bar.__dict__)
print(bar.foo) #print(bar.__dict__['foo'])

Child.foo = property(lambda self: "Second") # it is a descriptor
print(bar.__class__.__dict__, bar.__dict__)
print(bar.foo) #print(Child.__dict__['foo'].__get__(bar, Child))

Child.__getattribute__ = getattribute1
print(bar.__class__.__dict__, bar.__dict__)
print(bar.foo) 

Child.__getattribute__ = getattribute2
print(bar.__class__.__dict__, bar.__dict__)
print(bar.foo)

def delegate(attribute_name, method_names): 
    print("delegate(%s,%s)"%(attribute_name, method_names)) 
    def decorator(cls):
        print("decorate(%s)"%cls.__name__)
        nonlocal attribute_name # without this statement, it raises UnboundLocalError: attribute_name referenced before assignment
        if attribute_name.startswith("__"):
            attribute_name = "_"+cls.__name__+attribute_name
        for name in method_names:
            print("%s.%s(self, *args, **kwargs)"%(cls.__name__, name))
            setattr(cls, name, 
                    eval("lambda self, *args, **kwargs: self.{0}.{1}(*args, **kwargs)".format(attribute_name, name)))
        return cls
    return decorator

@delegate("__list", ("pop", "append", "__getitem__", "__delitem__", "__iter__", "__reversed__", "__len__", "__str__"))
class SortedList:
    def __init__(self):
        self.__list = []

print(SortedList.__dict__) # delegate invoked when SortedList defined
s = SortedList()
s.append(5)
print(len(s))

import abc

class Appliance(metaclass=abc.ABCMeta): # for an ABC, abc.ABCMeta or its subclass is must
    @abc.abstractmethod # to make __init__() an abstract method
    def __init__(self, model, price):
        self.__module = model
        self.price = price # set_price() will be called to initiate private data (__price) directly

    def get_price(self):
        return self.__price

    def set_price(self, price):
        self.__price = price

    price = abc.abstractproperty(get_price, set_price) # to make an abstact readable/writable property

    @property 
    def model(self): # the model property is not abstract, no need reimplementing it in concrete subclass although it is allowed
        return self.__module

class Cooker(Appliance):
    def __init__(self, model, price, fuel):
        super().__init__(model, price)
        self.fuel = fuel

    price = property(lambda self: super().price, lambda self, price: super().set_price(price))

cooker = Cooker("module", 1.2, "oil")
print("model: %s, price: %f, fuel: %s"%(cooker.model, cooker.price, cooker.fuel))
cooker.price = 2.4
print("model: %s, price: %f, fuel: %s"%(cooker.model, cooker.price, cooker.fuel))

def greet(self, who):
    print(self.greeting, who)

Person = type('Person', (object,), {'greet': greet, 'greeting': 'Hello'}) # type(classname, baseclasses, attributes)

jonathan = Person()
jonathan.greet('Readers') # output: Hello Readers

class Field(object):
    def __init__(self, ftype):
        self.ftype = ftype

    def is_valid(self, value):
        return isinstance(value, self.ftype)

class EnforcerMeta(type):
    def __init__(cls, name, bases, ns):
        cls._fields = {}
        for key, value in ns.items():
            if isinstance(value, Field):
                cls._fields[key] = value

class Enforcer(metaclass=EnforcerMeta):   
    def __setattr__(self, key, value):
        if key in self._fields:
            if not self._fields[key].is_valid(value):
                raise TypeError('Invalid type for field')
            super().__setattr__(key, value)

class Person(Enforcer):
    name = Field(str)
    age = Field(int)

p = Person()
p.name = "Howard"
p.age = 30
p.name = "Hou"
print(p.name, p.age)
Person.name="123"
print(p.name, p.age)

import os 
print(os.path.basename(filename)) # safe fully qualified access 

import os.path as path
print(path.basename(filename)) # risk of name collision with path

from os import path
print(path.basename(filename)) # risk of name collision with path

# * means everything that is not private, or all objects named in global __all__ variable if __all__ is provided
from os.path import * 
print(basename(filename)) # risk of many name collision

import re

astring = " howard@google.com.cn Gorman@baidu.net"

pattern = "(?P<Name>\w+)@(?P<Company>\w+)(?:\.\w+)+"
flags = re.IGNORECASE

print("re.findall():", re.findall(pattern, astring, flags)) 

mt = re.search(pattern, astring, flags)
s = "\nre.search():%s\n"%mt.__class__
s += "\tmt.groups():%s, mt.group(1):%s"%(mt.groups(), mt.group(1))
print(s)

'''
The difference between re.search() and re.match(),
re.search() try to match anywhere of astring,
re.search() just match the start of astring
'''
print("\nre.match():", re.match(pattern, astring, flags)) 

m1 = re.finditer(pattern, astring, flags)
print("\nre.finditer():", m1)
for i, m in enumerate(m1):
    s1 = "\tm.__class__:%s \n"%m.__class__
    s1 += "\t\tm.start({0}): {1}, m.start({0}): {2}\n".format(i, m.start(i), m.end(i))
    s1 += "\t\tm.groupdict():%s\n"%m.groupdict()
    s1 += "\t\tm.groups():{0}, \n".format(m.groups()) # "%s"%tuple does not work
    s1 += "\t\tm.lastindex:%d\n"%m.lastindex # the number of the highest capturing group
    s1 += "\t\tm.group(Name):%s, m.group(Company):%s\n"%(m.group("Name"), m.group("Company"))
    s1 += m.expand("\t\t\g<Name> work for \g<Company>") 
    print(s1)

rx = re.compile(pattern, flags)
s2  = "\nrx=re.compile():%s\n"%rx.__class__
s2 += "\trx.pattern:%s"%rx.pattern
s2 += ", rx.flags:%s"%rx.flags
s2 += ", rx.groupindex:%s\n"%rx.groupindex
'''
You have to make it match from index 1 of astring, otherwise, it returns None,
'''
s2 += "\trx.match(astring, 1):%s"%rx.match(astring, 1).__class__
print(s2)

'''
Both re and rx have function: findall(), finditer(), match(), search(),
and the parameters for these 4 function are same no matter they are of re or rx.
The meaning of each function of them is consistent no matter in re or in rx. 
In re, the parameters are pattern, astring and flags, you can see above.
In rx, the parameters are astring, startindex of astring, and endindex of astring
'''

re.findall(): [('howard', 'google'), ('Gorman', 'baidu')]

re.search():<class '_sre.SRE_Match'>
	mt.groups():('howard', 'google'), mt.group(1):howard

re.match(): None

re.finditer(): <callable_iterator object at 0x00000000027E6E48>
	m.__class__:<class '_sre.SRE_Match'> 
		m.start(0): 1, m.start(0): 21
		m.groupdict():{'Name': 'howard', 'Company': 'google'}
		m.groups():('howard', 'google'), 
		m.lastindex:2
		m.group(Name):howard, m.group(Company):google
		howard work for google
	m.__class__:<class '_sre.SRE_Match'> 
		m.start(1): 22, m.start(1): 28
		m.groupdict():{'Name': 'Gorman', 'Company': 'baidu'}
		m.groups():('Gorman', 'baidu'), 
		m.lastindex:2
		m.group(Name):Gorman, m.group(Company):baidu
		Gorman work for baidu

rx=re.compile():<class '_sre.SRE_Pattern'>
	rx.pattern:(?P<Name>\w+)@(?P<Company>\w+)(?:\.\w+)+, rx.flags:34, rx.groupindex:{'Name': 1, 'Company': 2}
	rx.match(astring, 1):<class '_sre.SRE_Match'>