Python面向对象

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

# 导入抽象基类模块
import abc

# 定义接口（基类）
class File(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def read(self):
        pass
    @abc.abstractmethod
    def write(self):
        pass

class disk(File):
    def read(self):
        print("disk read")

    def write(self):
        print("disk wirte")

ds = disk()
ds.read()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

class Grandfather(object):
    def __init__(self, name, age):
        self.age = age
        self.name = name
    def grandfather(self):
        print("grandfather method")

class Father(Grandfather):
    def __init__(self, name, age):
        super().__init__(name,age)

    def father_method(self):
        print("father method")


class Son(Father):
    def __init__(self, name, age,sex):
        # 调用父类的构造方法
        super().__init__(name,age)
        self.sex = sex
    # 子类中调用父类方法
    def son_method(self):
        Father.father_method(self)
    def son_method1(self):
        super().grandfather()

son1 = Son('xiaoming',18, 'male')
son1.son_method1()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

class People(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def generation(self):
        if self.age < 18:
            print("[%s]属于未成年人" % self.name)
        elif 18 < self.age < 30:
            print("[%s]属于青年人" % self.name)
        else:
            print("[%s]属于中老年人" % self.name)


class minor(People):
    pass


class young(People):
    pass


class old(People):
    pass

def func(obj):
    obj.generation()

w1 = young('luenci',20)
w2 = minor('xiaoming', 16)
w3 = old('jack', 50)

func(w1)
func(w3)
func(w3)

out:
[luenci]属于青年人
[jack]属于中老年人
[jack]属于中老年人

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

class Demo(object):
    def __init__(self,name):
        self.name = name
    def method(self):
        print("i am method")

d = Demo('luenci')
# 如果d 对象中有属性name则打印self.name的值，否则打印not find
print(getattr(d,'name','not find'))
print(getattr(d,'age','not find'))

#如果有方法method，否则打印其地址，否则打印not find
print(getattr(d, 'method', 'not find'))
print(getattr(d, 'methods', 'not find'))

#如果有方法method，运行函数并打印None否则打印not find
print(getattr(d, 'method', 'not find')())

# 说明：判断对象object是否包含名为name的特性（hasattr是通过调用getattr(ojbect, name)是否抛出异常来实现的）
print(hasattr(d, 'name'))

# 增加和修改参数
# d.age =  18
setattr(d,'age', 18)
setattr(d,'name','jack')
print(d.__dict__)

# 删除 属性 不能删除属性对应的值， 但是可以使用setattr来修改
delattr(d,'age')
print(d.__dict__)


out:
luenci
not find
<bound method Demo.method of <__main__.Demo object at 0x000001710E9359B0>>
not find
i am method
None
True
{'name': 'jack', 'age': 18}
{'name': 'jack'}

1
2
3

't.py'
def test():
    print("i am test")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

model_name = input("请输入您要导入的模块名称：")
imp = __import__(model_name)
# 判断是否有test函数，有就执行test函数内容
if getattr(imp,'test', 'not find'):
    imp.test()
else:
    print(imp)
    imp.test()

out:
    请输入您要导入的模块名称：t
    i am test
    <module 't' from 'E:\\python进阶练习\\面向对象\\t.py'>
    i am test

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

class List(list):
    # 重写list的append方法,让其只能添加字符类型的数据
    def append(self, p_object):
        if type(p_object) is str:
            # self.append(self, p_object)
            super().append(p_object)
        else:
            print("只有字符类型才可以允许添加")

a = List('hello Luenci')
a.append(123)
a.append("haha")
print(a)


out:
只有字符类型才可以允许添加
['h', 'e', 'l', 'l', 'o', ' ', 'L', 'u', 'e', 'n', 'c', 'i', 'haha']

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

import time

# 组合的方式完成授权
class FileHandle(object):
    def __init__(self, filename, mode='r', encoding='utf-8'):
        self.file = open(filename,mode=mode,encoding=encoding)
        self.mode = mode
        self.encoding = encoding
    # 个性化定制write方法，比如不允许写，去除敏感词汇，给内容加上时间戳
    def write(self,content):
        t = time.strftime('%Y-%m-%d %X')
        self.file.write('%s %s'%(t,content))

    def __getattr__(self, item):
        return getattr(self.file, item)

f = FileHandle('a.txt', 'w')
f.write('Hello\n')
f.write('luenci\n')


a.txt---->
2020-05-29 11:23:38 Hello
2020-05-29 11:23:38 luenci

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

class Foo(object):
    pass


class Too(object):
    pass


class Bar(Foo):
    pass


f1 = Foo()
# 判断实例化对象是不是属于此类 结果是boolean
print(isinstance(f1, Too))
print(isinstance(f1, Foo))

# 判断Bar类是不是Foo的子类 结果是boolean
print(issubclass(Bar, Foo))

out:
False
True
True