Python基础第18天

一：多态  指出了对象如何通过他们共同的属性和动作来操作及访问，不用考虑他们具体的类，反映执行时的一种状态

eg.    len(str1)  -------------->  str1.__len__()

class H2O:
    def __init__(self,name,temperature):
        self.name=name
        self.temperature=temperature
    def turn_ice(self):
        if self.temperature<0:
            print('[%s]温度太低结冰了'%self.name)
        elif self.temperature>0 and self.temperature<100:
            print('[%s]液化成冰'%self.name)
        elif self.temperature > 100:
            print('[%s]温度太高成了水蒸气'%self.name)
class Water(H2O):
    pass
class Ice(H2O):
    pass
class Steam(H2O):
    pass

w1=Water('水',25)

i1=Ice('冰',-20)

s1=Steam('蒸汽',3000)

# w1.turn_ice()
# i1.turn_ice()
# s1.turn_ice()

def func(obj):
    obj.turn_ice()

func(w1)
func(i1)
func(s1)

二 ：封装  本质是明确地区分内外，内部的实现逻辑，外部无法知晓，且为封装到内部的逻辑提供了一个访问接口给外部使用

类的继承  ①  改变   ② 扩展

多态就是累的两层意义的一种具体的实现机制，即调用不同类实例化得到对象的相同方法，实现的过程不一样。

面向对象优点：  封装明确了内外

                     继承+多态语言层面支持了归一化设计

class People:
    __star='earth'
    def __init__(self,id,name,age,salary):
        self.id=id
        self.name=name
        self.age=age
        self.salary=salary
    def get_id(self):
        print('我是私有方法，我找到的id是[%s]'%self.id)

    def get_star(self):
        print(self.__star)


p1=People('123456','alex','18',10000000)
# print(p1._star)
# print(p1.__star)#出错，原因是python自动重命名了
print(People.__dict__)
print(p1._People__star)
p1.get_star()  #内部就可以调用

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

    def tell_area(self):
        return self.__width*self.__length*self.__heigh
r1=Room('厕所','alex',100,100,100000)
print(r1.tell_area())

三：反射（自省）

这四种方法都是基于字符串的，四种方法实现自省的功能

• hasattr   检测对象能不能调用到里面的属性或方法
• getattr    
• setattr    设置属性
• delattr    删除

class BlackMedium:
    feature='Ugly'
    def __init__(self,name,addr):
        self.name=name
        self.addr=addr

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

b1=BlackMedium('万成置地','天露园')

print(hasattr(b1,'name')) #判断object中有没有一个name字符串对应的方法或属性
print(hasattr(b1,'sell_hpurse'))    #能不能调用该方法

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

print(getattr(b1,'rent_hoursefghj')) #没有则会报错
print(getattr(b1,'rent_hoursefghj','没有这个属性')) #设置默认参数，不会报错
setattr(b1,'sb',True)
setattr(b1,'sb1',123)
print(b1.__dict__)

delattr(b1,'sb')
print(b1.__dict__)
setattr(b1,'func',lambda x:x+1)  #设置函数属性
setattr(b1,'func1',lambda self:self.name+'sb')
print(b1.__dict__)
print(b1.func(10))
print(b1.func1(b1))

四：反射及动态导入模块

#t.py
def test1():
    print('test1')

def _test2():  #私有
    print('test2')

按字符串导入：

module_t=__import__('m1.t')  #传入字符串，提取模块名，拿到的都是最顶层的那个
print(module_t)
module_t.t.test1()#一步一步往下调用

封装私有属性：

from m1.t import *  #只有这种情况下_test2()才报错
from m1.t import test1,_test2
test1()
# test2()#报错
_test2() #不报错，说明python只是遵守某种约定不是真的限制

利用模块导入：

import importlib
m=importlib.import_module('m1.t')  #定位到所导的模块，所以不要m.t.test
print(m)
m.test1()
m._test2()