python 3全栈开发-面向对象之绑定方法（classmethod与staticmethod的区别）、多态、封装的特性property

#setting.py  文件的内容
NAME="duoduo"
AGE=18

import settings

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

    def tell(self):
        print(‘%s：%s‘ %(self.name,self.age))

    @classmethod    #python3的内置函数是装饰器
    def from_conf(cls):  #这里的cls，是约定俗称一个类的名字跟self约定为对象是一样的
        return cls(settings.NAME,settings.AGE)

p4=People.from_conf()    #这里我们发现不需要再传入类
p4.tell()    

import settings
import hashlib
import time

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

    def tell(self):
        print(‘%s: %s：%s‘ %(self.uid,self.name,self.age))

    @staticmethod   #跟classmethod一样都是内置函数也是装饰器
    def create_id():
        m=hashlib.md5()
        m.update(str(time.clock()).encode(‘utf-8‘))
        return m.hexdigest()

obj=People(‘duoduo‘,18)
print(obj.create_id())    #这里调用就很正常的调用没有自动传值一说
print(People.create_id())

class People:
    def __init__(self,name,weight,height):
        self.name=name
        self.weight=weight
        self.height=height
    @property
    def bmi(self):
        return self.weight / (self.height * self.height)
duoduo=People(‘duoduo‘,70,1.70)
# 但很明显人的bmi值听起来更像一个名词而非动词
# print(duoduo.bmi())  # 未用装饰器前的调用
# 于是我们需要为bmi这个函数添加装饰器，将其伪装成一个数据属性
# duoduo.weight=65   #改变duoduo的weight
# print(duoduo.bmi) #22.49134948096886，调用duoduo.bmi本质就是触发函数bmi的执行，从而拿到其返回值
# print(duoduo.bmi)

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

    @property
    def name(self): #obj.name
        print(‘您现在访问的是用户名。。。‘)
        return self.__name

    @name.setter #obj.name=‘DUODUO‘
    def name(self,x):
        # print(‘=================‘,x)
        if type(x) is not str:
            raise TypeError(‘名字必须是str类型，傻叉‘)
        self.__name=x

    @name.deleter
    def name(self):
        # print(‘就不让你删‘)
        del self.__name

# obj=People(‘duoduo‘)
# print(obj.name)
# obj.name=‘DUODUO‘   #修改名字属性为DUODUO
# print(obj.name)
# del obj.name               #删除名字属性
# obj.name             #删除后，看报错

import abc  #调用内置模块abc
class Animal(metaclass=abc.ABCMeta): #同一类事物:动物
    @abc.abstractmethod   #当下面的子类，没有talk方法是，就会报错
    def talk(self):
        pass
class People(Animal): #动物的形态之一:人
    def talk(self):
        print(‘say hello‘)
class Dog(Animal): #动物的形态之二:狗
    def talk(self):
        print(‘say wangwang‘)
class Pig(Animal): #动物的形态之三:猪
    def talk(self):
        print(‘say aoao‘)

peo=People()
dog=Dog()
pig=Pig()

#peo、dog、pig都是动物,只要是动物肯定有talk方法
#于是我们可以不用考虑它们三者的具体是什么类型,而直接使用
peo.talk()
dog.talk()
pig.talk()

#更进一步,我们可以定义一个统一的接口来使用
def func(obj):
    obj.talk()

class Cat(Animal): #属于动物的另外一种形态：猫
    def talk(self):
        print(‘say miao‘)

　　 def func(animal): #对于使用者来说，自己的代码根本无需改动
    　　animal.talk()

cat1=Cat() #实例出一只猫
func(cat1) #甚至连调用方式也无需改变，就能调用猫的talk功能
say miao

#这样我们新增了一个形态Cat，由Cat类产生的实例cat1，使用者可以在完全不需要修改自己代码的情况下。
#使用和人、狗、猪一样的方式调用cat1的talk方法，即func(cat1)

#二者都像鸭子,二者看起来都像文件,因而就可以当文件一样去用
class TxtFile:
    def read(self):
        pass

    def write(self):
        pass

class DiskFile:
    def read(self):
        pass
    def write(self):
        pass

#str,list,tuple都是序列类型
s=str(‘hello‘)
l=list([1,2,3])
t=tuple((4,5,6))

#我们可以在不考虑三者类型的前提下使用s,l,t
s.__len__()
l.__len__()
t.__len__()

len(s)
len(l)
len(t)