python之OOP

面向对象基础（OOP）

基本操作

定义类

# 法一
class one:
    pass  
# 法二
class two():
    pass
# 法三
class three(object):
    pass

属性、函数的调用

class teacher(object):
    name = '老师'   #属性
    age = 18        #属性
    def teaching(self):   #函数
        print('上课。。。。') 

#实例化一个对象
t1 = teacher()  
#实例化的对象调用类的属性
t1.name        
#实例化的对象调用类的函数
t1.teaching()

调用实例函数

class teacher(object):
	name = '老师'
	age = 18
	def intro(self):
		print('my name is {}'.format(self.name))
#实例化对象
t2 = teacher()

法一：实例调用实例函数
#实例作为一个参数放进函数中执行
t2.intro()


法二：类名调用实例函数
#类不会作为参数传入，此时函数需要一个参数执行
teacher.intro(t2)

类的函数

构造函数

构造函数：在对类实例化的时候，需要给类一些初始值
构造函数是在实例化的时候第一个被调用的函数。

class teacher(object):
    #构造函数：初始化的工作，不会返回值
    def __init__(self,name,age):   
        self.name = name
        self.age = age  
    def intro(self):
        print('My name is {}'.format(self.name))

dd = teacher('乐乐',19)
dd

***注：***构造函数中有参数，需要在调用类的时候传参执行

实例属性和类属性

OOP函数分类

• OOP函数分为：
  • 普通函数
  • 实例函数
  • 类函数：类函数至少需要传入一个参数，默认把类名当作第一个参数传进去
  • 静态函数：一般不需要放参数

class school(object):
    name = '一个学校'
    age = 3
    
    #普通函数
    def hw():
    	print('hello world 1')
    #普通函数
    def hw2(name = '中学')：
    	print('hello world {}'.format(name))
    	
    #实例函数
    def hw3(self):
    	print('Hello world {}'.format(self.name))
    	
    #类函数:类函数至少需要传入一个参数，默认把类名当作第一个参数传进去
    @classmethod
    def hw4(cls):
    	print('hello world class {}'.format(cls.name))
    	
    #静态函数：一般不需要放参数
    @staticmethod
    def hw5():
    	print('hello')   

各函数调用方式

• 调用方式
  • 类调用普通函数
  • 类调用静态函数
  • 实例调用普通函数：函数中没有参数会报错
  • 一般不用实例调用静态函数

t3 = school()
#类调用类函数
school.hw()
school.hw2()

# 实例调用类函数
# t3.hw()  会报错，实例作为参数传入，该函数没有参数
t3.hw2() #返回的是内存地址

# 类调用静态函数
school.hw5()

OOP三大特性

三大特性：封装、继承、多态

封装

 封装分为三类：
	public ：内外部均可访问
	protected：只有父类、子类可访问（单下划线）
	private：只有本类自己访问（双下划线）

• private
  1）内部访问
  2）外部访问：name_mangling方法 （实例._类名私有属性，可直接外部访问）

class teacher():
    name ='老师'
    #双下划线表示私有（private）属性
    __age = 18
    def __init__(self,name='乐乐',age=18):
        self.name = name
        self.__age = age
	def print_info(self):
        print('内部名称',self.name)
        print('内部年龄',self.__age)
       
ll = teacher()
# print(ll.__age) 表示类外使用会报错
#外部访问：name_mangling（实例._类名私有属性  可直接外部访问）
print(ll._teacher__age)

#法二：内部访问
ll.print_info()

继承

• 优先调用自己的构造函数，其次调用父类的函数

class animal():
   def __init__(self,name):
        print('I am init in 鳄鱼',name)
class paxingani(animal):
    pass
class croc(paxingani):
    def __init__(self,name='noname'):
        print('I am init in 鳄鱼',name)

kaka = croc()

• 自己有构造函数，但是需要调用父类的构造函数

class animal():
    def __init__(self,name):
        print('I am init in 鳄鱼',name)
class paxingani(animal):
    pass
class croc(paxingani):
    def __init__(self):
        # 法一：super(子类名称，self(作为自己的实例)).__init__('参数')
        super(croc,self).__init__('ddd')


        # 法二：父类名称.__init__(self,'参数')
        animal.__init__(self,'ddd')
        print('I am 大鳄鱼 ')

继承特点

• 所有的类都是继承自object类，即所有的类都是object类的子类

• 子类一旦继承父类，则可以使用父类中除私有成员外的所有内容

• 子类继承父类后并没有将父类成员完全赋值到子类中，而是通过引用关系访问调用

• 子类中可以定义独有的成员属性和方法，也就是说子类不但可以继承，还可以发扬光大

• 子类中定义的成员和父类成员如果相同，则优先使用子类成员

• 子类如果想扩充父类的方法，可以在定义新方法的同时访问父类成员来进行代码重用