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

在 Python 中创建一个类及其对象

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

 Output:

10000
John Doe

 在 Python 中创建一个空类

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

 Output:

<__main__.Employee object at 0x0000000002DA51D0>
John Doe

 在 Python 中使用 Type 创建类

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

 Output:

<__main__.Employee object at 0x0000000002DCC780>
John Doe

 在 Python 中创建和调用类的方法

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()

 Output:

10000
John Doe
1000.0

 使用 init() 方法为数据属性赋值

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

 Output:

10000
John Doe

 在 Python 中更新对象属性

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)

 Output:

10000
20000

 在 Python 中删除对象属性和对象

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

 Output:

哈哈

 在 Python 中检查和比较对象的类型

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

 Output:

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

 在Python中将对象的所有属性复制到另一个对象

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)

 Output:

25
25

 在 Python 中迭代对象属性

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('__')])

 Output:

['__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']

 在 Python 中打印对象的所有属性

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])

 Output:

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

 在python中在运行时创建类的数据属性

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

 Output:

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()

 Output:

[Red, Blue, Black]

 在 Python 中创建和使用自定义 Self 参数

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()

 Output:

10000 : John Doe

 使用self参数来维护对象的状态

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)

 Output:

5.0
7.0
14.0
7.0
5.0

 在 Python 中创建和使用静态类变量

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

 Output:

25
25
25
30

 在 Python 中的一个函数上使用多个装饰器

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()

 Output:

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

 在 Python 中的方法中同时访问 cls 和 self

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()

 Output:

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()

 Output:

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

 使用给定的装饰器获取 Python 类的所有方法

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')))

 Output:

['method']
['method2']

 装饰一个 class

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()

 Output: