python :面向对象 学习笔记(1)

知识点：

 

编程范式：面向过程、面向对象（oop）、函数式编程
特性：
　　类：一个类即是对一类拥有相同属性的对象的抽象、蓝图、原型。
  　　     在类中定义了这些对象的都具备的属性(variables(data) 、共同的方法
　　对象：一个对象即是一个类的实例化后实例,一个类必须经过实例化后方可在程序中调用,一个类可以实例化多个对象,
   　　    每个对象亦可以有不同的属性,就像人类是指所有人,每个人是指具体的对象有共性,亦有不同

　　封装：在类中对数据的赋值、内部调用对外部用户是透明的,这使类变成了一个胶囊或容器,
               里面包含着类的数据和方法
　　继承：可以派生出子类,在这个父类里定义的属性、方法自动被子类继承
　　多态：一个接口，多种实现。指基类中派生出了不同的子类。

　　语法
　　　　#class Animal:经典类
　　　　class Animal(object):#新式类
　　　　主要区别：继承

　　属性（动态属性：方法  静态属性：实例变量）

　　类变量：类定义的变量，类实例公共的属性
　　实例变量:具体对象的属性，作用域是对象本身

　　方法
　　　　构造函数:实例创建的时候执行
　　　　析构函数：实例释放、销毁的时候执行，释放内存等工作
　　　　私有方法：__name()只能内部调用
　　　　私有属性：__name,只能通过内部读取修改


　　 @staticmethod
　　　　静态方法:只是名义上归类管理, 实际上在静态方法里访问不了类或实例中的任何属性

　　@classmethod
　　　　类方法:类方法只能访问类变量，不能访问实例变量

　　@property
　　　　属性方法:把一个方法变成一个静态属性

class person(object):
    love = 1
    list = []
    name ="12221"
    def __init__(self,name,age=22,addr="BJ",info=10000):
        self.name =name
        self.age = age
        self.addr = addr
        self.__info = info      # 私有属性
        self.__food =None
        print("None person")
    def __del__(self):
        print("%s in the del"%self.name)


    def show_info(self):
        print("info %s"%self.__info)

    def __pao(self):
        '''
        私有方法
        :return: 
        '''
        print("run")

    @staticmethod
    def eat(self):
        '''
        静态方法
        :param self: 
        :return: 
        '''
        print("in eat %s "%self)

    @classmethod
    def run(self):
        '''
        类方法，只能调用类变量
        :return: 
        '''
        print("in run %s"%self.name)

    @property
    def sleep(self):
        print("in sleep %s"%self.__food)

    @sleep.setter
    def sleep(self,food):
        print("!!!!!!! sleep %s"%food)
        self.__food =food

    @sleep.deleter
    def sleep(self):
        del self.__food
        print("!!!!")


p =person('aa')
p.eat('eat')#静态方法调用
p.run()     #类方法调用
p.sleep     #调用property下的
p.sleep=22   #调用sleep.setter下的
p.sleep       #调用property下的

简单Demo

 

类的一些应用：

　　print(dog.__doc__)#打印类的注释信息

　　print(dog.__module__)#输出类是哪个模块导入的

　　print(dog.__class__)#输出类

　　print(dog.__dict__)#查看类和对象中的所有成员

　　内置函数：

　　.__getitem__、__setitem__,__delitem__.用于索引操作,如字典。以上分别表示获取、设置、删除数据

　　__str__ 打印一个实例化对象时，打印的其实时一个对象的地址。而通过__str__()函数就可以帮助我们打印对象中具体的属性值，或者你想得到的东西。

　　__new__ 用来创建实例的

　　__metaclass__其用来表示该类由谁来实例化创建,

　　type(类名, 父类的元组（针对继承的情况，可以为空），包含属性的字典（名称和值）) 　　

class dog(object):
    '''这个类是狗类'''
    def __init__(self,name):
        self.name = name
        self.__food = None
        self.date ={}

    @property
    def eat(self):
        print("dog %s  favorite food is %s"%(self.name,self.__food))

    @eat.setter
    def eat(self,food):
        self.__food = food

    @eat.deleter
    def eat(self, food):
        del self.__food

    def __call__(self, *args, **kwargs):
        print("__call__",args,kwargs)

    def __str__(self):
        return "<obj:%s>"%self.name

    def __getitem__(self, item):
        print('__getitem__',item)
        return self.date[item]

    def __setitem__(self, key, value):
        print('__setitem__', key,value)
        self.date[key] =value
        print(self.date)

    def __delitem__(self, key):
        print('__delitem__', key)
        del self.date[key]


d =dog("lions")
# d.eat = "pi"
d["age"] = 2  #__setitem__触发
print("__getitem__:",d["age"])#__getitem__触发
del d["age"]#__delitem__触发

d(1,2,3,name=333)#__call__的应用
dog("alex")()#__call__的应用
print("内存地址__str__：",d)  #没加__str__显示内存地址，加了显示返回的
print("__dict__:",d.__dict__)#查看对象中的所有成员
print("__dict__:",dog.__dict__)#查看类中的所有成员
print("__doc__:",dog.__doc__)#打印类的注释信息
print("__module__:",dog.__module__)#输出类是哪个模块导入的
print("__class__:",dog.__class__,type(dog))#输出类的类型

View Code

 

 

转载于:https://www.cnblogs.com/gtq7512/p/11438289.html