Python开发【第七篇】：面向对象

面向对象基础

引子：

 

#!/usr/bin/python3
# -*-  coding:utf-8  -*-
dog1={
    'name' : 'haha',
    'gender' : 'mu',
    'type' :'藏獒'
}

dog2 = {
    'name' : 'haha1',
    'gender' : 'gu',
    'type' :'jingba'
}
person1 ={
    'name' : 'wusir',
    'gender' : 'nan',
    'type' :'gogo'
}

def jiao(dog):
    print('一条狗[%s]，汪汪汪'%dog['name'])

def chi_shi(dog):
    print('yitiao狗[%s]正在吃。。。'%dog['type'])

jiao(dog1)
chi_shi(dog1)
chi_shi(dog2)
jiao(person1)

#函数调用
#!/usr/bin/python3
# -*-  coding:utf-8  -*-
dog1={
    'name' : 'haha',
    'gender' : 'mu',
    'type' :'藏獒'
}

dog2 = {
    'name' : 'haha1',
    'gender' : 'gu',
    'type' :'jingba'
}
person1 ={
    'name' : 'wusir',
    'gender' : 'nan',
    'type' :'gogo'
}

def jiao(dog):
    print('一条狗[%s]，汪汪汪'%dog['name'])

def chi_shi(dog):
    print('yitiao狗[%s]正在吃。。。'%dog['type'])

jiao(dog1)
chi_shi(dog1)
chi_shi(dog2)
ji

函数式调用

def dog(name,gender,type):
    #狗的动作
    def jiao(dog):
        print('一条狗[%s]，汪汪汪'%dog['name'])


    def chi_shi(dog):
        print('yitiao狗[%s]正在吃。。。'%dog['type'])

    dog1 = {
        'name': name,
        'gender': gender,
        'type': type,
        'jiao': jiao,
        'chi_shi':chi_shi,
    }
    return dog1

d1=dog('haha','mu','zangao')
d2 = dog('hahah1','gong','zhonggua')
print(d1)
#print(d1['name'])
d1['jiao'](d1)
d2['chi_shi'](d2)
d1['chi_shi'](d1)

 

def dog(name,gender,type):
    #狗的动作
    def jiao(dog):
        print('一条狗[%s]，汪汪汪'%dog['name'])


    def chi_shi(dog):
        print('yitiao狗[%s]正在吃。。。'%dog['type'])

    def init(name,gender,type):
        dog1 = {
            'name': name,
            'gender': gender,
            'type': type,
            'jiao': jiao,
            'chi_shi':chi_shi,
        }
        return dog1
    res = init(name,gender,type)
    return res

d1=dog('haha','mu','zangao')
d2 = dog('hahah1','gong','zhonggua')
print(d1)
d1['jiao'](d1)
d2['chi_shi'](d2)
d1['chi_shi'](d1)

 

def school(name,addr,type):
    def init(name,addr,type):
        sch = {
            'name': name,
            'addr': addr,
            'type': type,
            'kao_shi': kao_shi,
            'zhao_sheng': zhao_sheng,
        }
        return sch

    def kao_shi(school):
        print('%s 学校正在考试'%school['name'])


    def zhao_sheng(school):
        print('%s %s 正在招生' %(school['type'],school['name']))


    return init(name,addr,type)

s1= school('oldboy','shahe','silixuexiao')

print(s1)
print(s1['name'])
s1['zhao_sheng'](s1)

s2=school('qinghua','北京','公立学校')
print(s2)
print(s2['name'],s2['addr'],s2['type'])
s2['zhao_sheng'](s2)

类：把一类事物的相同的特征和动作整合到一起就是类
类是一个抽象的概念

对象：就是基于类而创建的一个具体的事物（具体存在的）
也是特征和动作整合到一起

 

class Chinese:
    '这是一个中国人的类'
    dang = '共产社会'
    def sui_di_tu_tan():
        print('朝着一口痰')

    def cha_dui(self):
        print('查到了前面')

#新式类

# class Chinese(object):
#     pass

print(Chinese)
#实例化到底干了什么
p1 = Chinese() #实例化
print(p1)

print(Chinese.dang)
Chinese.sui_di_tu_tan()
Chinese.cha_dui('asdfasf')

print(dir(Chinese))
print(Chinese.__dict__)
print(Chinese.__dict__['dang']) #查看属性字典

Chinese.__dict__['sui_di_tu_tan']()
Chinese.__dict__['cha_dui'](1)

print(Chinese.__name__)
print(Chinese.__doc__)
print(Chinese.__base__)
print(Chinese.__bases__)
print(Chinese.__module__)
print(Chinese.__class__)
print(p1.__module__)

class Chinese:
    '这是一个中国人的类'
    dang = '共产社会'
    # def __init__(name,age,gender):
    #     dic = {
    #             'name':name,
    #             'age' : age,
    #             'gender' : gender
    #     }
    #     return dic
    def __init__(self,name,age,gender):
        print('我是初始化函数')
        self.mingzi = name      #p1.mingzi = name
        self.nianji = age       #p1.nianji = age
        self.xingbie = gender
        print('我结束了')

    def sui_di_tu_tan(self):
        print('%s朝着一口' %self.mingzi)

    def cha_dui(self):
        print('%s查到了前面' %self.mingzi)
    def eat_food(self,food):
        print('%s 正在吃%s'%(self.mingzi,food))


p1 = Chinese('yuanha9o',18,'female')  ###---->__init__(self,name,age,gender)
print(p1.__dict__)
print(p1.__dict__['xingbie'])
print(p1.mingzi)
print(p1.dang)


#p1 = Chinese.__init__(p1,name,age,gender)
print(Chinese.__dict__)
Chinese.sui_di_tu_tan(p1)
Chinese.cha_dui(p1)
p1.sui_di_tu_tan()
p1.cha_dui()
#
# #####增删改查
p1.sui_di_tu_tan()
p1.eat_food('fu')
p2 = Chinese('wang sir','1000','guniang')
p2.eat_food('jiucaixiaping')
print(dir(p2))
#
# 删除
del Chinese.dang
print(Chinese.__dict__)
#
def eat_food(self,food):
     print('%s zhneg zaichi %s' %(self.name,food))
#
Chinese.eat_food = eat_food

 

class Chinese:
    '这是一个中国人的类'
    dang = '共产社会'
    def __init__(self,name):
        self.name = name

    def play_ball(self,ball):
        print('%s 正在打 %s' %(self.name,ball))

p1 = Chinese('alex')
print(p1.__dict__)

#查看
print(p1.name)
p1.play_ball('lanqiu')

#增加
p1.age=18
print(p1.__dict__)
print(p1.age)

#增加函数属性
def test(self):
    print('woshi 实例的函数属性')
p1.test = test
print(p1.__dict__)
p1.test(p1)

#修改
p1.age=19
print(p1.__dict__)
print(p1.age)
=====================================
country = '中国'
class Chinese:
    '这是一个中国人的类'

    def __init__(self,name):

        self.name = name
        print('---------->?',country)
    def play_ball(self,ball):
        print('%s 正在打 %s' %(self.name,ball))

p1=Chinese('alex')

输出结果：
---------->? 中国

===========================
country = '中国'
class Chinese:
    '这是一个中国人的类'
    country='zhongguo'
    def __init__(self,name):

        self.name = name
        print('---------->?',country)
    def play_ball(self,ball):
        print('%s 正在打 %s' %(self.name,ball))

print(Chinese.__dict__)
print(Chinese.country)
p1=Chinese('alex')
print('实例------------》',p1.country)

输出结果：
{'__module__': '__main__', '__doc__': '这是一个中国人的类', 'country': 'zhongguo', '__init__': <function Chinese.__init__ at 0x10b6b1158>, 'play_ball': <function Chinese.play_ball at 0x10b6b10d0>, '__dict__': <attribute '__dict__' of 'Chinese' objects>, '__weakref__': <attribute '__weakref__' of 'Chinese' objects>}
zhongguo
---------->? 中国
实例------------》 zhongguo

============================================
#####加.调用就是调用实例或者类属性里面的，不加.是调用外面的属性

class Chinese:
    '这是一个中国人的类'
    country='zhongguo'
    l = ['a','b']
    def __init__(self,name):

        self.name = name
        #print('---------->?',country)
    def play_ball(self,ball):
        print('%s 正在打 %s' %(self.name,ball))

p1 = Chinese('alex')
print(p1.l)
p1.l = [1,2,3]
print(Chinese.l)
print(p1.l)


p1.l.append('c')
print(p1.__dict__)
print(Chinese.l)

 输出结果：
['a', 'b']
['a', 'b']
[1, 2, 3]
{'name': 'alex', 'l': [1, 2, 3, 'c']}
['a', 'b']

 

 

class School:
    x = 1
    def __init__(self,name,addr,type):
        self.Name = name
        self.Addr = addr
        self.Type = type

    def tell_info(self):
        print('学校的详细信息是: name:%s addr:%s '%(self.Name,self.Addr))


s1 = School('oldboy','shahe','私立')
print(s1.__dict__)
print(School.__dict__)
s1.tell_info()
School.tell_info(s1)

输出结果：
{'Name': 'oldboy', 'Addr': 'shahe', 'Type': '私立'}
{'__module__': '__main__', 'x': 1, '__init__': <function School.__init__ at 0x10406c158>, 'tell_info': <function School.tell_info at 0x10406c0d0>, '__dict__': <attribute '__dict__' of 'School' objects>, '__weakref__': <attribute '__weakref__' of 'School' objects>, '__doc__': None}
学校的详细信息是: name:oldboy addr:shahe 
学校的详细信息是: name:oldboy addr:shahe

===============================
#类静态属性 @property r1.cal_area后面无需括号   
class Room:
    def __init__(self,name,owner,width,length,heigh):
        self.name = name
        self.owner = owner
        self.width = width
        self.length = length
        self.heigh = heigh

    @property
    def cal_area(self):
        #print('%s 住的 %s 总面积是 %s' % (self.owner, self.name, self.width * self.length))
        return self.width * self.length

r1 = Room('cesuso','aleSx',100,100,1000)

r2 = Room('gongongcesuo','yuanhoa',1,1,1)
print('%s 住的 %s 总面积是 %s'%(r1.owner,r1.name,r1.width*r1.length))


print('%s 住的 %s 总面积是 %s'%(r2.owner,r2.name,r2.width*r2.length))

print(r1.cal_area)
print(r2.cal_area)

print(r1.name)

输出结果：
aleSx 住的 cesuso 总面积是 10000
yuanhoa 住的 gongongcesuo 总面积是 1
10000
1
cesuso

===========================
# 类方法
class Room:
    tag = 1
    def __init__(self,name,owner,width,length,heigh):
        self.name = name
        self.owner = owner
        self.width = width
        self.length = length
        self.heigh = heigh

    @property
    def cal_area(self):
        #print('%s 住的 %s 总面积是 %s' % (self.owner, self.name, self.width * self.length))
        return self.width * self.length


    def test(self):
        print('from test',self.name)

    @classmethod
    # def tell_info(self):
    #     print('-------->',self.tag)
    def tell_info(cls,x):
        print(cls)
        print('-------->',cls.tag,x)
        print('-------->', Room.tag)

print(Room.tag)


#r1 = Room('cesuo','alex',100,100,1000)
#Room.tell_info(r1)

#类方法
#Room.tell_info(10)

r1 = Room('cesuo','alex',100,100,1000)
r1.tell_info(10)

#
# r2 = Room('gongongcesuo','yuanhoa',1,1,1)
# # print('%s 住的 %s 总面积是 %s'%(r1.owner,r1.name,r1.width*r1.length))
# #
# #
# # print('%s 住的 %s 总面积是 %s'%(r2.owner,r2.name,r2.width*r2.length))
#
# print(r1.cal_area)
# print(r2.cal_area)

print(r1.name)

输出结果：
1
<class '__main__.Room'>
--------> 1 10
--------> 1
cesuo

=======================================================
#静态方法
class Room:
    tag = 1
    def __init__(self,name,owner,width,length,heigh):
        self.name = name
        self.owner = owner
        self.width = width
        self.length = length
        self.heigh = heigh

    @property
    def cal_area(self):
        #print('%s 住的 %s 总面积是 %s' % (self.owner, self.name, self.width * self.length))
        return self.width * self.length

    #
    # def test(self):
    #     print('from test',self.name)

    @classmethod
    # def tell_info(self):
    #     print('-------->',self.tag)
    def tell_info(cls,x):
        print(cls)
        print('-------->',cls.tag,x)
        print('-------->', Room.tag)

    @staticmethod       #类的工具包
    def wash_body(a,b,c):
        print('%s  %s  %s正在洗澡'%(a,b,c))

    def test(x,y):
        print(x,y)


Room.wash_body('alxe','yuanhao','wupeiqi')

print(Room.__dict__)

r1 = Room('ceWWsuo','alex',100,100,1000)
#r1.wash_body('alxRe','yuanhao','wupeiqi')

print(r1.__dict__)
Room.test(1,2)
#r1.test(r1,1,2)

输出结果：
alxe  yuanhao  wupeiqi正在洗澡
{'__module__': '__main__', 'tag': 1, '__init__': <function Room.__init__ at 0x106c23158>, 'cal_area': <property object at 0x106bc0048>, 'tell_info': <classmethod object at 0x106c0c780>, 'wash_body': <staticmethod object at 0x106c0c7b8>, 'test': <function Room.test at 0x106c232f0>, '__dict__': <attribute '__dict__' of 'Room' objects>, '__weakref__': <attribute '__weakref__' of 'Room' objects>, '__doc__': None}
{'name': 'ceWWsuo', 'owner': 'alex', 'width': 100, 'length': 100, 'heigh': 1000}
1 2
===========================================
#######组合
class Hand:
    pass
class Foot:
    pass

class Trunk:
    pass

class Head:
    pass

class Person:
    def __init__(self,id_num,name):
        self.id_num = id_num
        self.name = name
        self.hand = Hand()
        self.foot = Foot()
        self.trunk = Trunk()
        self.head = Head()

p1 = Person('123123','alex')
print(p1.__dict__)

输出结果：
{'id_num': '123123', 'name': 'alex', 'hand': <__main__.Hand object at 0x10c5b07f0>, 'foot': <__main__.Foot object at 0x10c5b0828>, 'trunk': <__main__.Trunk object at 0x10c5b0860>, 'head': <__main__.Head object at 0x10c5b0898>}


==============================================
#####学校，课程类
class School:
    def __init__(self,name,addr):
        self.name = name
        self.addr = addr
        self.course_list=[]

    def zhao_sheng(self):
        print('%s 正在'%self.name)


class Course:
    def __init__(self,name,price,period,school):
        self.name = name
        self.price = price
        self.period = period
        self.school = school

s1 = School('oldboy','beijing')
s2 = School('oldboy','nanjing')
s3 = School('oldboy','dongjing')

#c1=Course('linux',10,'1h',s1)

msg = '''
1   oldboy  beijing
2   oldboy  nanjing
3   oldboy  dongjing

'''
while True:
    print(msg)
    menu = {
        '1' :s1,
        '2' :s2,
        '3' : s3
    }
    choice = input('选择学校>>: ')
    school_obj=menu[choice]

    name=input('课程名>>: ')
    price=input('课程费用>>: ')
    period = input('课程周期>>: ')

    new_course=Course(name,price,period,school_obj)
    print('课程[%s],属于%s  学校'%(new_course.name,new_course.school.name))




# print(c1.__dict__)
# print(c1.school.name)

 

 

class Dad:
    '这是一个dad类'
    money=10
    def __init__(self,name):
        print('dad')
        self.name = name

    def hit_son(self):
        print('%s 正在打儿子' %self.name)

class Son(Dad):
    money=100000
    def __init__(self,name,age):
        self.name= name
        self.age = age

    def hit_son(self):
        print('来自儿子类')
print(Son.money)
Son.hit_son('1')
print(Dad.__dict__)
print(Son.__dict__)

s1 = Son('alex',19)
print(s1.name)
print(s1.money)
s1.hit_son()

输出结果：
100000
来自儿子类
{'__module__': '__main__', '__doc__': '这是一个dad类', 'money': 10, '__init__': <function Dad.__init__ at 0x104e48158>, 'hit_son': <function Dad.hit_son at 0x104e480d0>, '__dict__': <attribute '__dict__' of 'Dad' objects>, '__weakref__': <attribute '__weakref__' of 'Dad' objects>}
{'__module__': '__main__', 'money': 100000, '__init__': <function Son.__init__ at 0x104e481e0>, 'hit_son': <function Son.hit_son at 0x104e48268>, '__doc__': None}
alex
100000
来自儿子类


===========================================
###接口继承
import abc
class All_file(metaclass=abc.ABCMeta):

    @abc.abstractmethod
    def read(self):
        pass

    @abc.abstractmethod
    def write(self):
        pass

class Disk(All_file):
    def read(self):
        print('disk read')

    def write(self):
        print('disk write')

class Cdrom(All_file):
    def read(self):
        print('cdrom read')

    def write(self):
        print('cdrom write')

class Mem(All_file):
    def read(self):
        print('Mem read')

    def write(self):
        print('Mem write')

m1 = Mem()
m1.read()
m1.write()

输出结果：
Mem read
Mem write

======================================
###########继承顺序
class A:
    def test(self):
        print('A')
class B(A):
    def test(self):
        print('B')

class C(A):
    def test(self):
        print('C')
class D(B):
    def test(self):
        print('D')
class E(C):
    def test(self):
        print('E')
class F(D,E):
    # def test(self):
    #     print('F')
    pass

f1=F()
f1.test()    #F-->D-->B-->E-->C-->A--->  'F' object has no attribute 'test'
              #python2 经典累没有mro
print(F.__mro__)

输出结果：
D
(<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)


================================================================
#在子类中调用父类
class Vehicle:
    Country = 'China'
    def __init__(self,name,speed,load,power):
        self.name = name
        self.speed = speed
        self.load = load
        self.power = power

    def run(self):
        print('开动了。。。')

class Subway(Vehicle):
    def __init__(self,name,speed,load,power,line):
        Vehicle.__init__(self,name,speed,load,power)
        #super().__init__(name, speed, load, power)
        #super(Subway,self).__init__(name, speed, load, power)
        self.line = line

    def show_info(self):
        print(self.name,self.line)

    def run(self):
        Vehicle.run(self)
        print('%s  %s 线kaidong la'%(self.name,self.line))

line13=Subway('beijing  subway','10km/s',10000,'dian',13)

line13.show_info()

line13.run()

输出结果 ：
beijing  subway 13
beijing  subway  13 线kaidong la


=================================================
import pickle
import hashlib
import time
def create_md5():
    m = hashlib.md5()
    m.update(str(time.time()).encode('utf-8'))
    #print(m.hexdigest())
    return m.hexdigest()
class Base:
    def save(self):
        with open('school.db','wb') as f:
            pickle.dump(self,f)


class School(Base):
    def __init__(self,name,addr):
        self.name=name
        self.addr = addr

    def save(self):
        with open('school.db','wb') as f:
            pickle.dump(self,f)

class Course(Base):
    def __init__(self,name,price,period,school):
        self.id=create_md5()
        self.name = name
        self.price = price
        self.period = period
        self.school = school

school_obj=pickle.load(open('school.db','rb'))
print(school_obj.name,school_obj.addr)


# s1 = School('oldboy','beijing')
# s1.save()

id = create_md5()
time.sleep(1)
id1 = create_md5()

输出结果：
oldboy beijing

 

######反射。hasattr
class BlackMedium:
    feture='Ugly'
    def __init__(self,name,addr):
        self.name=name
        self.addr=addr

    def sell_hourse(self):
        print('[%s] 正在买房子，傻逼才买呢'%self.name)

    def rent_hourse(self):
        print('[%s] 正在租房子，傻逼菜租呢'%self.name)

b1=BlackMedium('完成之地','tianluyuan')
#b1.name--->b1.__dic__['name']
print(hasattr(b1,'name'))
print(hasattr(b1,'sell_hourse'))


print(getattr(b1,'name'))
#print(getattr(b1,'rent_hourseasdf'))#没有则报错

print(getattr(b1,'rent_hourseasdf','没有这个属性'))


func=getattr(b1,'rent_hourse')
func()

#b1.sb=True

setattr(b1,'sb',True)
setattr(b1,'func',lambda x:x+1)

print(b1.__dict__)
print(b1.func)
print(b1.func(10))
#del b1.sb

delattr(b1,'sb')
print(b1.__dict__)

输出结果：
True
True
完成之地
没有这个属性
[完成之地] 正在租房子，傻逼菜租呢
{'name': '完成之地', 'addr': 'tianluyuan', 'sb': True, 'func': <function <lambda> at 0x10f3ff1e0>}
<function <lambda> at 0x10f3ff1e0>
11
{'name': '完成之地', 'addr': 'tianluyuan', 'func': <function <lambda> at 0x10f3ff1e0>}
===========================================
#动态导入模块
# module_t=__import__('my_module.t')
# print(module_t)
# module_t.t.test1()


# from my_module.t import test1,_test2
# test1()
# _test2()


# import importlib
# m = importlib.import_module('my_module.t')
# print(m)
# m.test1()
# m._test2()

===================================
####双下划线开头的attr方法
class Foo:
    x = 1
    def __init__(self,y):
        self.y = y

    def __getattr__(self, item):
        print('执行__getattr__')

    def __delattr__(self, item):
        print('删除操作__delattr___')

    def __setattr__(self,key,value):
        print('__setattr__执行')
        #self.key=value
        self.__dict__[key] = value

f1 =Foo(10)
print(f1.y)
print(getattr(f1,'y'))

f1.sdfsdf      #不存在的时候调用

del f1.y     ##调用删除


print(f1.__dict__)
f1.z = 2
print(f1.__dict__)
==========================================
# class Foo:
#     pass

#print(Foo.__dict__)
print(dir(Foo))
f1 = Foo()

print(f1.x)     #不存在会自动触发__getattr__

del f1.x       ##删除属性时会触发__delattr__

f1.x = 3    #设置属性的时候会触发

输出结果：
__setattr__执行
10
10
执行__getattr__
删除操作__delattr___
{'y': 10}
__setattr__执行
{'y': 10, 'z': 2}
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattr__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'x']


========================================

##########改key的结果
class Foo:
    def __init__(self,name):
        self.name=name

    def __getattr__(self, item):
        print('你找的属性[%s] 不存在'%item)

    def __setattr__(self, k,v):
        print('执行setattr',k,v)
        if type(v) is str:
            print("开始设置")
            #self.k =v #触发__setattr__
            self.__dict__[k] = v.upper()

        else:
            print('必须是字符串类型')

    def __delattr__(self, item):
        print('不允许删除属性[%s]delattr'%item)
        self.__dict__.pop(item)
f1= Foo('alex')
f1.age = 18     #触发__setattr__
print(f1.__dict__)
print(f1.name)
print(f1.age)
print(f1.gender)
print(f1.salery)

del f1.name

输出结果：
执行setattr name alex
开始设置
执行setattr age 18
必须是字符串类型
{'name': 'ALEX'}
ALEX
你找的属性[age] 不存在
None
你找的属性[gender] 不存在
None
你找的属性[salery] 不存在
None
不允许删除属性[name]delattr

 

###################重写list 的方法
class List(list):
    def append(self, p_object):
        #print('----->',p_object)
        if type(p_object) is str:
            #self.append(p_object)
            #list.append(self,p_object)
            super().append(p_object)
        else:
            print('只能添加字符串乐行')
    def show_middle(self):
        mid_index=int(len(self)/2)
        return self[mid_index]

#l1 = List('hello world')

l2 = list('hello world')
print(l2,type(l2))

l1 = List('helloworld')    #继承父类list
print(l1,type(l1))

print(l1.show_middle())
l1.append('111111')
print(l1)


输出结果：
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd'] <class 'list'>
['h', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd'] <class '__main__.List'>
w
['h', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd', '111111']

================================================
#######授权
import time
class FileHandle:
    def __init__(self,filename,mode='r',encoding='utf-8'):
        #self.filename=filename
        self.file=open(filename,mode,encoding=encoding)
        self.mode=mode
        self.encoding=encoding


    def write(self,line):
        print('------->',line)
        t=time.strftime('%Y-%m-%d %X')
        self.file.write('%s %s'%(t,line))

    def __getattr__(self, item):
        #print(item,type(item))
        return getattr(self.file,item)
        #self.file
    # def read(self):
    #     pass
    #
    # def write(self):
    #     pass

f1 = FileHandle('a.txt','w+')
#print(f1.file)
#print(f1.__dict__)
#print('=-->',f1.read) ###触发__getattr__
#print(f1.write('11111111\n'))
f1.write('11111111\n')
f1.write('cpu负载过高\n')
f1.seek(0)
print(f1.read())

sys_f=open('b.txt','w+')
print('---->',getattr(sys_f,'read'))

输出结果 ：
-------> 11111111

-------> cpu负载过高

2020-02-12 20:36:03 11111111
2020-02-12 20:36:03 cpu负载过高

----> <built-in method read of _io.TextIOWrapper object at 0x10a0e9cf0>
====================================
class Foo:
    pass

f1=Foo()
print(isinstance(f1,Foo))

class Bar(Foo):
    pass

print(issubclass(Bar,Foo))

class Foo:
    pass

class Bar(Foo):
    pass

b1 = Bar()
print(isinstance(b1,Bar))
print(isinstance(b1,Foo))
print(type(b1))


输出结果：
True
True
True
True
<class '__main__.Bar'>

 

 

基础内容介绍详见一下两篇博文：

• 面向对象初级篇
• 面向对象进阶篇

其他相关

一、isinstance(obj, cls)

 检查是否obj是否是类 cls 的对象

1 2 3 4 5 6

class Foo(object):     pass   obj = Foo()   isinstance(obj, Foo)

二、issubclass(sub, super)

检查sub类是否是 super 类的派生类

1 2 3 4 5 6 7

class Foo(object):     pass   class Bar(Foo):     pass   issubclass(Bar, Foo)

三、异常处理

1、异常基础

在编程过程中为了增加友好性，在程序出现bug时一般不会将错误信息显示给用户，而是现实一个提示的页面，通俗来说就是不让用户看见大黄页！！！

1 2 3 4

try:     pass except Exception,ex:     pass

需求：将用户输入的两个数字相加

2、异常种类

python中的异常种类非常多，每个异常专门用于处理某一项异常！！！

对于上述实例，异常类只能用来处理指定的异常情况，如果非指定异常则无法处理。

1 2 3 4 5 6 7

# 未捕获到异常，程序直接报错   s1 = 'hello' try:     int(s1) except IndexError,e:     print e

所以，写程序时需要考虑到try代码块中可能出现的任意异常，可以这样写：

1 2 3 4 5 6 7 8 9

s1 = 'hello' try:     int(s1) except IndexError,e:     print e except KeyError,e:     print e except ValueError,e:     print e

万能异常 在python的异常中，有一个万能异常：Exception，他可以捕获任意异常，即：

1 2 3 4 5

s1 = 'hello' try:     int(s1) except Exception,e:     print e

接下来你可能要问了，既然有这个万能异常，其他异常是不是就可以忽略了！

答：当然不是，对于特殊处理或提醒的异常需要先定义，最后定义Exception来确保程序正常运行。

1 2 3 4 5 6 7 8 9

s1 = 'hello' try:     int(s1) except KeyError,e:     print '键错误' except IndexError,e:     print '索引错误' except Exception, e:     print '错误'

3、异常其他结构

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

try:     # 主代码块     pass except KeyError,e:     # 异常时，执行该块     pass else:     # 主代码块执行完，执行该块     pass finally:     # 无论异常与否，最终执行该块     pass

4、主动触发异常

1 2 3 4

try:     raise Exception('错误了。。。') except Exception,e:     print e

5、自定义异常

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

class WupeiqiException(Exception):       def __init__(self, msg):         self.message = msg       def __str__(self):         return self.message   try:     raise WupeiqiException('我的异常') except WupeiqiException,e:     print e

6、断言

1 2 3 4 5

# assert 条件   assert 1 == 1   assert 1 == 2

四、反射

python中的反射功能是由以下四个内置函数提供：hasattr、getattr、setattr、delattr，改四个函数分别用于对对象内部执行：检查是否含有某成员、获取成员、设置成员、删除成员。

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

class Foo(object):       def __init__(self):         self.name = 'wupeiqi'       def func(self):         return 'func'   obj = Foo()   # #### 检查是否含有成员 #### hasattr(obj, 'name') hasattr(obj, 'func')   # #### 获取成员 #### getattr(obj, 'name') getattr(obj, 'func')   # #### 设置成员 #### setattr(obj, 'age', 18) setattr(obj, 'show', lambda num: num + 1)   # #### 删除成员 #### delattr(obj, 'name') delattr(obj, 'func')

详细解析：

当我们要访问一个对象的成员时，应该是这样操作：

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

class Foo(object):       def __init__(self):         self.name = 'alex'       def func(self):         return 'func'   obj = Foo()   # 访问字段 obj.name # 执行方法 obj.func()

   

那么问题来了？

a、上述访问对象成员的 name 和 func 是什么？ 

答：是变量名

b、obj.xxx 是什么意思？ 

答：obj.xxx 表示去obj中或类中寻找变量名 xxx，并获取对应内存地址中的内容。

c、需求：请使用其他方式获取obj对象中的name变量指向内存中的值 “alex”

答：有两种方式，如下：

d、比较三种访问方式

• obj.name
• obj.__dict__['name']
• getattr(obj, 'name')

答：第一种和其他种比，...
      第二种和第三种比，...

结论：反射是通过字符串的形式操作对象相关的成员。一切事物都是对象！！！

 

 

类也是对象

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

class Foo(object):       staticField = "old boy"       def __init__(self):         self.name = 'wupeiqi'       def func(self):         return 'func'       @staticmethod     def bar():         return 'bar'   print getattr(Foo, 'staticField') print getattr(Foo, 'func') print getattr(Foo, 'bar')

模块也是对象

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

#!/usr/bin/env python # -*- coding:utf-8 -*-   """ 程序目录：     home.py     index.py   当前文件：     index.py """     import home as obj   #obj.dev()   func = getattr(obj, 'dev') func()

设计模式

一、单例模式

单例，顾名思义单个实例。

学习单例之前，首先来回顾下面向对象的内容：

python的面向对象由两个非常重要的两个“东西”组成：类、实例

面向对象场景一：

如：创建三个游戏人物，分别是：

• 苍井井，女，18，初始战斗力1000
• 东尼木木，男，20，初始战斗力1800
• 波多多，女，19，初始战斗力2500

面向对象场景二：

如：创建对数据库操作的公共类

• 增
• 删
• 改
• 查

实例：结合场景二实现Web应用程序

对于上述实例，每个请求到来，都需要在内存里创建一个实例，再通过该实例执行指定的方法。

那么问题来了...如果并发量大的话，内存里就会存在非常多功能上一模一样的对象。存在这些对象肯定会消耗内存，对于这些功能相同的对象可以在内存中仅创建一个，需要时都去调用，也是极好的！！！

铛铛 铛铛 铛铛铛铛铛，单例模式出马，单例模式用来保证内存中仅存在一个实例！！！

通过面向对象的特性，构造出单例模式：

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

# ########### 单例类定义 ########### class Foo(object):       __instance = None       @staticmethod     def singleton():         if Foo.__instance:             return Foo.__instance         else:             Foo.__instance = Foo()             return Foo.__instance   # ########### 获取实例 ########### obj = Foo.singleton()

对于Python单例模式，创建对象时不能再直接使用：obj = Foo()，而应该调用特殊的方法：obj = Foo.singleton() 。