Python_python面向对象编程和类

时间:2021-08-15 17:21:57

一、面向对象编程

面向对象--Object Oriented Programming,简称oop,是一种程序设计思想。把一些公用的函数封装到一个类里面。

二、类

属性:属性就是类里面的一个变量,有类变量和实例变量,类变量是类在定义的时候就有的,实例变量是在实例化的时候才产生的变量。

方法:方法就是类的功能,也就是定义在类里面的函数。

构造函数:类被实例化的时候,它会自动的执行构造函数,做的某些初始化操作。

析构函数:析构函数是实例在销毁的时候做的一些操作。

定义类:定义类使用class关键字,类名一般我们开发的时候首字母要大写。python中有经典类和新式类。

继承:父类有的功能、变量子类全有。如果定义的类,有很多重复功能的,那就可以把这些重复的类,定义成父类

多态:python里面是不直接支持多态的,可以通过别的方法来实现多态。

私有方法、私有属性:什么是私有,私有就是只有在类里面可以访问,实例化之后不可以访问和调用,有私有方法和私有属性。私有就把变量名或者函数名前面加上"__"两个下划线,其实就是通过私有来实现封装的。

类方法:不需要实例化就能直接用的,它可以使用类变量和类方法。类方法,也不需要实例化,直接就能用。它静态方法高级一点,它可以使用类变量和类方法。
静态方法:不需要实例化就能直接用的,其实和类没有什么关系,就是一个普通的函数,写在了类里面而已,也用不了self的那些东西,也调用不类里面的其他函数。

示例:

类定义

    class Person(object):#定义类,这个是新式类
                     nationality 'China' #类属性
                     def __init__(self,name,sex)#构造函数
                             self.name name #实例属性
                             self.sex =sex
                     def __del__(self):#析构函数
                         print('这个是析构函数')
                     def info():#方法
                            print('name is %s sex is %s '%(self.name,self.sex))
                    
             class Person1:#定义类,这个是经典类
                     nationality 'China' #类属性
                     def __init__(self,name,sex)#构造函数
                             self.name name #实例属性
                             self.sex =sex
                     def info():#方法
                            print('name is %s sex is %s '%(self.name,self.sex))
                     
             niuniu Person('牛牛','男'#实例化,因为在上面的构造函数里面指定了必须传name和sex,所以在实例化的时候要把name和sex传进去
             niuniu.info()#调用实例方法
 
继承
      class F(object):
                     '''
                    这个是父类
                    '''
                     def __init__(self,name,sex):
                         self.name name
                         self.sex sex
                     def info():#方法
                         print('name is %s sex is %s '%(self.name,self.sex))
                 class S(F):#继承F这个类
                     pass
                 s1 S('牛牛','男')#实例化子类
                 s1.info()#因为继承父类,所以父类的方法他都有
                那如果在父类里面有一个方法,子类里面也有的话,但是子类想重写一下父类的方法,增加新功能下面这么写:
                 class test():
                     def __init__(self,name):
                         self.name name
                 class test1(test):
                     def __init__(self,name,age):
                         # test.__init__(self,name)#修改父类的方法,这个是经典类里面的写法
                         super(test1,self).__init__(name)#和上面的效果一样,这个是新式类里面的写法
                         self.name name
                         self.age age
                 test1('name','age')
                多继承,上面写的都是单继承的, python里面还支持多继承,多继承就是继承多个父类,在python3中多继承都是广度优先的,在python2中有点不同,经典类是深度优先,新式类是广度优先。
                 class A:
                     def say(self):
                         print('A')
                 class B(A):
                     # pass
                     def say(self):
                         print('B')
                 class C(A):
                     pass
                     # def say(self):
                     #     print('c')
                 class D(C,B):
                     pass
                 s=D()
                 s.say()
 
私有方法、私有属性
    class Dog(object):
                     __type '狗'#私有属性
                     def cry(self):
                         self.__test()#调用私有方法
                         print('私有属性%s'%self.__type)
                         print('狗 [%s] 汪汪汪'%self.name)
                     def __test(self):#私有方法
                         self.name 'test'#
                 D()
                 d.cry()#正常可以调用
                 d.__type#报错,因为是私有属性,在外面不能访问
                 d.__test()#报错,因为是私有方法,在外面不能访问
 
静态方法和类方法
         class Stu(object):
             country 'china'#类变量
             def __init__(self,name):
                 self.name name
             @staticmethod
             #静态方法,和类本身没有什么关系了,就相当于在类里面定义了一个方法而已
             def say():
                 print('xxx')
             @classmethod
             #静态方法,和类方法不同的是,它可以使用类变量,必须要传一个值,代表的就是这个类
             def hello(cls):
                  print(cls.country)
             def hi(self):
                 #这个是实例方法
                 print(self.name)
         Stu('name')
         Stu.hello()
         Stu.say()
         t.hi()
         t.say()
         t.hello()
 
重写父类
       
import redis
class Coon(object):
#基类
def __init__(self,host,passwd,port):
self.host= host
self.passwd=passwd
self.port= port

class CoonMySql(Coon):
def __init__(self,host,passwd,port,username,db,charset='utf8'):
#Coon.__init__(self,host,passwd,port) #z在调用父类的构造方法,咱们自己手动调用父类的方法
super(CoonMySql,self).__init__(host,passwd,port) #super会自动找到父类,然后调用下面的方法
self.username=username
self.db=db
self.charset=charset
def coon_mysql(self):
print(self.host,self.host)

class CoonRedis(Coon):
def conn(self,host,passwd,port):
Coon.conn(self, host, passwd, port)
redis.Redis(host=self.host,password=self.passwd,port=self.port)