python基础知识Day05

1. 对象

1.1 多态

多态意味着就算不知道变量所引用的对象类型是什么，还是能对它进行操作，而它也会根据对象类型的不同表现出不同的行为。

class food:
    def getprice(self):
        print("this is food's price")

class drunk(food):
    def getprice(self):
        print("this is drunk's price")

class rice(food):
    def getprice(self):
        print("this is rice's price")

def fun(object):
    object.getprice()

if __name__=="__main__":
    D=drunk()
    R=rice()
    fun(D)
    fun(R)

从上面代码可以发现，多态可以提高代码的复用性，即无论子类的函数getprice()中是怎么的函数，我只需要调用它即可，很大程度上增加了灵活性。

1.2 封装

封装是指向程序中的其他部分隐藏对象的具体实现细节，与多态不同，多态是可以让用户不知道是什么类的对象进行方法调用，而封装是可以不用关心对象是如何构建的而直接进行使用。

class person:
    def __init__(self,name,habbit,hometown):
        self.name=name
        self.habbit=habbit
        self.hometown=hometown

def habbit(self):
        print('%s 的爱好是 %s' %(self.name,self.habbit))

def hometown(self):
        print('%s的家乡是 %s' %(self.name,self.hometown))

xiaoming=person('小明', '唱歌', '四川')
habbit(xiaoming)
hometown(xiaoming)


xiaozhang=person('小张', '跳舞', '上海')
habbit(xiaozhang)
hometown(xiaozhang)

从person类中我们把各类数据定义好了，就没有必要从外面的函数去访问，我们可以直接在person类的内部定义访问数据的函数。这样，就把数据给“封装”起来了。
“封装”就是将抽象得到的数据和行为（或功能）相结合，形成一个有机的整体（即类）；封装的目的是增强安全性和简化编程，使用者不必了解具体的实现细节，而只是要通过外部接口，一特定的访问权限来使用类的成员。

1.3 继承

继承是另一个懒惰的行为。定义一个 class 的时候，可以从某个现有的 class 继承，新的 class 称为子类（Subclass），而被继承的 class 称为基类、父类或超类（Base class、Super class）

python继承中的特点：

1. 在继承中，基类的构造方法（init()方法）不会自动调用，需要在子类的构造方法中专门调用。
2. 在调用基类的方法时需要加上基类的类名前缀，并带上 self 参数变量。区别于在类中调用普通函数时不需要带 self 参数。
3. 在 Python 中，首先查找对应类型的方法，如果在子类中找不到对应的方法，才到基类中逐个查找。

class people:
    # 定义基本属性
    name = ''
    age = 0
    # 定义私有属性，私有属性在类外部无法直接进行访问
    __weight = 0
    # 定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    
    def speak(self):
        print("%s 说：我  %d 岁了"%(self.name,self.age))
        
        
# 单继承
class student (people):
    grade = ''
    def __init__(self,n,a,w,g):
        # 调用父类的构造
        people.__init__(self, n, a, w)
        self.grade = g 
        
    # 覆写父类法人方法
    def speak(self):
        print("%s 说：我  %d 岁了，在读 %d 年级"%(self.name,self.age,self.grade))
        
zth = student('zth',10,40,5)
zth.speak()

2. 类和类型

可以将类看作种类的同义词。所有的对象都属于某一种类，称为类的实例。例如：鸟类是百灵鸟类的父类，百灵鸟类是鸟类的子类。

class person:
    def setName(self,name):
        self.name=name
    def getName(self,name):
        return self.name
    def greet(self):
        print( 'hello,i am %s.' % self.name)

foo=person()
bar=person()
foo.setName('nancy')
bar.setName('jason')
foo.greet()
bar.greet()

self的作用：
1.self作为参数，是方法和函数的区别。首先明确的是self只有在类的方法中才会有，独立的函数或方法是不必带有self的。self在定义类的方法时是必须有的，虽然在调用时不必传入相应的参数。
2.在调用foo的greet和setName函数时，foo自动将自己作为第一个参数传入函数中，因此命名为self。foo.greet()看作Person.greet(foo)

当然也可以将特性绑定到一个普通函数上，这样就不会有特殊的self参数了。

class Class:
    def method(self):
        print('im a self')

def function():
    print("i don't...")

instance=Class()
instance.method()
instance.method = function #将特性绑定到了一个普通函数上
instance.method()


>>>im a self
i don't...

2.1 再论私有化

1.类的私有属性
__private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs

2.类的私有方法
__private_method：两个下划线开头，声明该方法为私有方法，只能在类的内部调用 ，不能在类的外部调用。self.__private_methods。

#问女性的姓名、工作是没有问题的，但是问女性的年龄、体重是不礼貌的，所以我们把女性年龄定义为私有属性
#定义显示女性的姓名、工作为公有方法，显示女性年龄、体重为私有方法
#类的定义部分
class Woman():
    name = "Juckes"  #类的公有属性
    job = "Teacher" 
    __ages = 30      #类的私有属性
    __weight = 60

    def disp_nj_info(self):  #类的（公有）方法
        print("Name:{}, Job:{}".format(self.name,self.job)) #类的内部调用公有属性

    def __disp_aw_info(self):  #类的私有方法
        print("Age:{}, Weight:{}".format(self.__ages, self.__weight))  #类的内部调用私有属性

    def dis_all_info(self):
        self.disp_nj_info() #类的内部调用公有方法
        self.__disp_aw_info() #类的内部调用私有方法

2.2 指定超类

class Filter:
    def init(self):
        self.blocked=[]

    def filter(self,sequence):
        return [x for x in sequence if x not in self.blocked]

class SPAMFilter(Filter):
    def init(self):
        self.blocked=['SPAM']

f=Filter()
f.init()
f.filter([1,2,3])

s=SPAMFilter()
s.init()
s.filter(['SPAM','SPAM','apple'])