再再肝3天，整理了70个Python面向对象编程案例，怎能不收藏？（上）

class Employee:
    salary = 10000
    name = "John Doe"
emp1 = Employee()
print(emp1.salary)
print(emp1.name)

10000
John Doe

class Employee:
    pass
e1 = Employee()
print(e1)
e1.name = "John Doe"
print(e1.name)

<__main__.Employee object at 0x0000000002DA51D0>
John Doe

e1 = type('Employee', (), {})()
print(e1)
e1.name = "John Doe"
print(e1.name)

<__main__.Employee object at 0x0000000002DCC780>
John Doe

class Employee:
    salary = 10000
    name = "John Doe"
    def tax(self):
        print(self.salary * 0.10)
emp1 = Employee()
print(emp1.salary)
print(emp1.name)
emp1.tax()

10000
John Doe
1000.0

class Employee:
        def __init__(self, salary, name):
                self.salary = salary
                self.name = name
emp1 = Employee(10000, "John Doe")
print(emp1.salary)
print(emp1.name)

10000
John Doe

class Employee:
    def __init__(self, salary, name):
        self.salary = salary
        self.name = name
emp1 = Employee(10000, "John Doe")
print(emp1.salary)
emp1.salary = 20000
print(emp1.salary)

10000
20000

class Employee:
    def __init__(self, salary, name):
        self.salary = salary
        self.name = name
emp1 = Employee(10000, "John Doe")
del emp1.salary     # Delete object property
del emp1            # Delete object

哈哈

class Test(object):
    pass
print(type(Test))
obj1 = Test()
print(type(obj1))
obj2 = Test()
print(type(obj1) is type(obj2))

< class 'type' >
< class '__main__.Test' >
True

class MyClass(object):
    def __init__(self):
        super(MyClass, self).__init__()
        self.foo = 1
        self.bar = 2
obj1 = MyClass()
obj2 = MyClass()
obj1.foo = 25
obj2.__dict__.update(obj1.__dict__)
print(obj1.foo)
print(obj2.foo)

25
25

class A():
    m = 1
    n = 2
    def __int__(self, x=1, y=2, z=3):
        self.x = x
        self._y = y
        self.__z__ = z
    def xyz(self):
        print(x, y, z)
obj = A()
print(dir(obj))
print([a for a in dir(obj) if not a.startswith('__')])

['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__int__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'm', 'n', 'xyz']
['m', 'n', 'xyz']

class Animal(object):
    def __init__(self):
        self.eyes = 2
        self.name = 'Dog'
        self.color= 'Spotted'
        self.legs= 4
        self.age  = 10
        self.kids = 0
animal = Animal()
animal.tail = 1
temp = vars(animal)
for item in temp:
    print(item, ':', temp[item])

kids : 0
eyes : 2
name : Dog
color : Spotted
tail : 1
legs : 4
age : 10

class Employee:
    pass
emp1 = Employee()
setattr(emp1, 'Salary', 12000)
emp2 = Employee()
setattr(emp2, 'Age', 25)
print(emp1.Salary)
print(emp2.Age)

12000
25

class Vehicle:
    def __init__(self):
        self.trucks = []
    def add_truck(self, truck):
        self.trucks.append(truck)
class Truck:
    def __init__(self, color):
        self.color = color
    def __repr__(self):
        return "{}".format(self.color)
def main():
    v = Vehicle()
    for t in 'Red Blue Black'.split():
        t = Truck(t)
        v.add_truck(t)
    print(v.trucks)
if __name__ == "__main__":
    main()

[Red, Blue, Black]

class Employee:
    def __init__(person, salary, name):
        person.salary = salary
        person.name = name
    def print_details(emp):
        print(str(emp.salary) + ' : ' + emp.name)
emp1 = Employee(10000, 'John Doe')
emp1.print_details()

10000 : John Doe

class State(object):
    def __init__(self):
        self.field = 5.0
    def add(self, x):
        self.field += x
    def mul(self, x):
        self.field *= x
    def div(self, x):
        self.field /= x
    def sub(self, x):
        self.field -= x
s = State()
print(s.field)
s.add(2)         # Self is implicitly passed.
print(s.field)
s.mul(2)         # Self is implicitly passed.
print(s.field)
s.div(2)         # Self is implicitly passed.
print(s.field)
s.sub(2)         # Self is implicitly passed.
print(s.field)

5.0
7.0
14.0
7.0
5.0

class Employee:
    age = 25
print(Employee.age)
e = Employee()
print(e.age)
e.age = 30
print(Employee.age)   # 25
print(e.age)          # 30

25
25
25
30

def my_decorator(func):
    def wrapper():
        print("Step - 1")
        func()
        print("Step - 3")
    return wrapper
def repeat(func):
    def wrapper():
        func()
        func()
        func()
    return wrapper
@my_decorator
@repeat
def start_steps():
    print("Step - 2")
start_steps()

Step - 1
Step - 2
Step - 2
Step - 2
Step - 3

class MyClass:
    __var2 = 'var2'
    var3 = 'var3'
    def __init__(self):
        self.__var1 = 'var1'
    def normal_method(self):
        print(self.__var1)
    @classmethod
    def class_method(cls):
        print(cls.__var2)
    def my_method(self):
        print(self.__var1)
        print(self.__var2)
        print(self.__class__.__var2)
if __name__ == '__main__':
    print(MyClass.__dict__['var3'])
clzz = MyClass()
clzz.my_method()

var3
var1
var2
var2

class Decorator(object):
  def __init__(self, decoratee_enclosing_class):
    self.decoratee_enclosing_class = decoratee_enclosing_class
  def __call__(self, original_func):
    def new_function(*args, **kwargs):
      print('decorating function in ', self.decoratee_enclosing_class)
      original_func(*args, **kwargs)
    return new_function
class Bar(object):
  @Decorator('Bar')
  def foo(self):
    print('in foo')
class Baz(object):
  @Decorator('Baz')
  def foo(self):
    print('in foo')
print('before instantiating Bar()')
b = Bar()
print('calling b.foo()')
b.foo()

before instantiating Bar()
calling b.foo()
decorating function in  Bar
in foo

import inspect
def deco(func):
    return func
def deco2():
    def wrapper(func):
        pass
    return wrapper
class Test(object):
    @deco
    def method(self):
        pass
    @deco2()
    def method2(self):
        pass
def methodsWithDecorator(cls, decoratorName):
    sourcelines = inspect.getsourcelines(cls)[0]
    for i, line in enumerate(sourcelines):
        line = line.strip()
        if line.split('(')[0].strip() == '@' + decoratorName:  # leaving a bit out
            nextLine = sourcelines[i + 1]
            name = nextLine.split('def')[1].split('(')[0].strip()
            yield(name)
print(list(methodsWithDecorator(Test, 'deco')))
print(list(methodsWithDecorator(Test, 'deco2')))

['method']
['method2']

from functools import wraps
def dec(msg='default'):
    def decorator(klass):
        old_foo = klass.foo
        @wraps(klass.foo)
        def decorated_foo(self, *args, **kwargs):
            print('@decorator pre %s' % msg)
            old_foo(self, *args, **kwargs)
            print('@decorator post %s' % msg)
        klass.foo = decorated_foo
        return klass
    return decorator
@dec('foo decorator')
class Foo(object):
    def foo(self, *args, **kwargs):
        print('foo.foo()')
@dec('subfoo decorator')
class SubFoo(Foo):
    def foo(self, *args, **kwargs):
        print('subfoo.foo() pre')
        super(SubFoo, self).foo(*args, **kwargs)
        print('subfoo.foo() post')
@dec('subsubfoo decorator')
class SubSubFoo(SubFoo):
    def foo(self, *args, **kwargs):
        print('subsubfoo.foo() pre')
        super(SubSubFoo, self).foo(*args, **kwargs)
        print('subsubfoo.foo() post')
SubSubFoo().foo()

@decorator pre subsubfoo decorator
subsubfoo.foo() pre
@decorator pre subfoo decorator
subfoo.foo() pre
@decorator pre foo decorator
foo.foo()
@decorator post foo decorator
subfoo.foo() post
@decorator post subfoo decorator
subsubfoo.foo() post
@decorator post subsubfoo decorator

import functools
# imagine this is at some different place and cannot be changed
def check_authorization(some_attr, url):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            print(f"Welcome Message: '{url}'...")
            return func(*args, **kwargs)
        return wrapper
    return decorator
# another dummy function to make the example work
def do_work():
    print("work is done...")
def custom_check_authorization(some_attr):
    def decorator(func):
        # assuming this will be used only on this particular class
        @functools.wraps(func)
        def wrapper(self, *args, **kwargs):
            # get url
            url = self.url
            # decorate function with original decorator, pass url
            return check_authorization(some_attr, url)(func)(self, *args, **kwargs)
        return wrapper
    return decorator
class Client(object):
    def __init__(self, url):
        self.url = url
    @custom_check_authorization("some_attr")
    def get(self):
        do_work()
# create object
client = Client('Hello World')
# call decorated function
client.get()

Welcome Message: 'Hello World'...
work is done...

class Employee(object):
    def __init__(self, **kwargs):
        for key in kwargs:
            setattr(self, key, kwargs[key])
emp = Employee(age=25, name="John Doe")
print(emp.age)
print(emp.name)

25
John Doe

from functools import wraps
def decorator_func_with_args(arg1, arg2):
    def decorator(f):
        @wraps(f)
        def wrapper(*args, **kwargs):
            print("Before orginal function with decorator args:", arg1, arg2)
            result = f(*args, **kwargs)
            print("Ran after the orginal function")
            return result
        return wrapper
    return decorator
@decorator_func_with_args("test1", "test2")
def hello(name):
    """A function which prints a greeting to the name provided.
    """
    print('Hello ', name)
    return 25
print("Starting script..")
x = hello('John')
print("The value of x is:", x)
print("The wrapped functions docstring is:", hello.__doc__)
print("The wrapped functions name is:", hello.__name__)

Starting script..
Before orginal function with decorator args: test1 test2
Hello  John
Ran after the orginal function
The value of x is: 25
The wrapped functions docstring is: A function which prints a greeting to the name provided.
The wrapped functions name is: hello

def d(arg):
    if callable(arg):  # Assumes optional argument isn't.
        def newfn():
            print('my default message')
            return arg()
        return newfn
    else:
        def d2(fn):
            def newfn():
                print(arg)
                return fn()
            return newfn
        return d2
@d('This is working')
def hello():
    print('hello world !')
@d  # No explicit arguments will result in default message.
def hello2():
    print('hello2 world !')
@d('Applying it twice')
@d('Would also work')
def hello3():
    print('hello3 world !')
hello()
hello2()
hello3()

This is working
hello world !
my default message
hello2 world !
Applying it twice
Would also work
hello3 world !

def decorator_maker_with_arguments(decorator_arg1, decorator_arg2, decorator_arg3):
    def decorator(func):
        def wrapper(function_arg1, function_arg2, function_arg3):
            print("The wrapper can access all the variables\n"
                  "\t- from the decorator maker: {0} {1} {2}\n"
                  "\t- from the function call: {3} {4} {5}\n"
                  "and pass them to the decorated function"
                  .format(decorator_arg1, decorator_arg2, decorator_arg3,
                          function_arg1, function_arg2, function_arg3))
            return func(function_arg1, function_arg2, function_arg3)
        return wrapper
    return decorator
@decorator_maker_with_arguments("canada", "us", "brazil")
def decorated_function_with_arguments(function_arg1, function_arg2, function_arg3):
    print("This is the decorated function and it only knows about its arguments: {0}"
          " {1}" " {2}".format(function_arg1, function_arg2, function_arg3))
decorated_function_with_arguments("france", "germany", "uk")

The wrapper can access all the variables
  - from the decorator maker: canada us brazil
  - from the function call: france germany uk
and pass them to the decorated function
This is the decorated function and it only knows about its arguments: france germany uk

class Currency:
    def __init__(self, dollars, cents):
        self.total_cents = dollars * 100 + cents
    @property
    def dollars(self):
        return self.total_cents // 100
    @dollars.setter
    def dollars(self, new_dollars):
        self.total_cents = 100 * new_dollars + self.cents
    @property
    def cents(self):
        return self.total_cents % 100
    @cents.setter
    def cents(self, new_cents):
        self.total_cents = 100 * self.dollars + new_cents
currency = Currency(10, 20)
print(currency.dollars, currency.cents, currency.total_cents)
currency.dollars += 5
print(currency.dollars, currency.cents, currency.total_cents)
currency.cents += 15
print(currency.dollars, currency.cents, currency.total_cents)

10 20 1020
15 20 1520
15 35 1535

from functools import wraps
def decorator(func):
  @wraps(func)
  def wrapper(*args, **kwargs):
    print('sth to log: %s : %s' % (func.__name__, args))
    return func(*args, **kwargs)
  return wrapper
class Class_test(object):
  @decorator
  def sum_func(self, a, b):
    print('class sum: %s' % (a + b))
    return a + b
print(Class_test.sum_func(1, 5, 16))

sth to log: sum_func : (1, 5, 16)
class sum: 21
21

def calculation(func):
    def wrapper(*args, **kwargs):
        print("Inside the calculation function")
        num_sum = func(*args, **kwargs)
        print("Before return from calculation function")
        return num_sum
    return wrapper
@calculation
def addition(a, b):
    print("Inside the addition function")
    return a + b
print("Sum =", addition(5, 10))

Inside the calculation function
Inside the addition function
Before return from calculation function
Sum = 15

from functools import wraps
def decorator_func_with_args(arg1, arg2):
    def decorator(f):
        @wraps(f)
        def wrapper(*args, **kwargs):
            print("Before orginal function with decorator args:", arg1, arg2)
            result = f(*args, **kwargs)
            print("Ran after the orginal function")
            return result
        return wrapper
    return decorator
@decorator_func_with_args("test1", "test2")
def hello(name):
    """A function which prints a greeting to the name provided.
    """
    print('Hello ', name)
    return 25
print("Starting script..")
x = hello('John')
print("The value of x is:", x)
print("The wrapped functions docstring is:", hello.__doc__)
print("The wrapped functions name is:", hello.__name__)

Starting script..
Before orginal function with decorator args: test1 test2
Hello  John
Ran after the orginal function
The value of x is: 25
The wrapped functions docstring is: A function which prints a greeting to the name provided.
The wrapped functions name is: hello

def print_name(*args):
  def _print_name(fn):
    def wrapper(*args, **kwargs):
      print('{}.{}'.format(fn.__module__, fn.__qualname__))
      return fn(*args, **kwargs)
    return wrapper
  return _print_name
class A():
  @print_name()
  def a():
    print('Hi from A.a')
@print_name()
def b():
  print('Hi from b')
A.a()
b()

__main__.A.a
Hi from A.a
__main__.b
Hi from b

def my_decorator(func):
    def wrapper():
        print("Step - 1")
        func()
        print("Step - 3")
    return wrapper
@my_decorator
def start_steps():
    print("Step - 2")
start_steps()

Step - 1
Step - 2
Step - 3

class Element:
    def __init__(self, name, city, population):
        self.name = name
        self.city = city
        self.population = population
    def __str__(self):
        return str(self.__class__) + '\n' + '\n'.join(('{} = {}'.format(item, self.__dict__[item]) for item in self.__dict__))
elem = Element('canada', 'tokyo', 321345)
print(elem)

name = canada
city = tokyo
population = 321345

class myclass:
  def __init__(self):
    self.cnt = 0
  def counter(self, function):
    """
    this method counts the number of runtime of a function
    """
    def wrapper(**args):
      function(self, **args)
      self.cnt += 1
      print('Counter inside wrapper: ', self.cnt)
    return wrapper
global counter_object
counter_object = myclass()
@counter_object.counter
def somefunc(self):
  print("Somefunc called")
somefunc()
print(counter_object.cnt)
somefunc()
print(counter_object.cnt)
somefunc()
print(counter_object.cnt)

Somefunc called
Counter inside wrapper:  1
1
Somefunc called
Counter inside wrapper:  2
2
Somefunc called
Counter inside wrapper:  3
3

class awesome(object):
    def __init__(self, method):
        self._method = method
    def __call__(self, obj, *args, **kwargs):
        return self._method(obj, *args, **kwargs)
    @classmethod
    def methods(cls, subject):
        def g():
            for name in dir(subject):
                method = getattr(subject, name)
                if isinstance(method, awesome):
                    yield name, method
        return {name: method for name, method in g()}
class Robot(object):
    @awesome
    def think(self):
        return 0
    @awesome
    def walk(self):
        return 0
    def irritate(self, other):
        return 0
print(awesome.methods(Robot))

{'think': <__main__.awesome object at 0x00000213C052AAC0>, 'walk': <__main__.awesome object at 0x00000213C0E33FA0>}