python类

python类

继承

1.什么是继承?
	# 继承就是新建类的一种方式.新建的类我们称为子类或者派生类,被继承的类我们称之为父类或者基类
	# 子类可以使用父类中的属性和方法
	
2.为什么要用继承?
	类解决了对象与对象之间的代码冗余问题
	继承解决了类与类之间的代码冗余问题
	
3.如何使用继承?
	新式类:继承了object类的子子孙孙类都是新式类
	经典类:没有继承了object类的子子孙孙类都是经典类
	
	# 新式类和经典类只有在python2中区分

类的继承

# 以学生选课系统为例
# 父类,公共类
class People():
	school = 'SH'
	
	def __init__(self,name,age,gender)
		self.name = name
		self.age = age
		self.gender = gender
		
# 学生类
class Student(People):

	def __init__(self,name,age,gender,course=None):
		if course is None:
		 	course = []:
		People.__init__(self,name,age,gender)
		self.courses = course
		
	def choose_course(self,course):
		self.courses.append(course)
		print('%s 选课成功 %s' % (self.name,self.courses))
		
stu = Student('ly',19,'male')

# teacher类
class Teacher(People):
	
	def __init__(self,name,age,gender,level):
		self.level = level
		People.__init__(self,name,age,gender)
		
		def score(self,stu_obj,score):
			stu_obj.score = score  # 给学生打分
			print('%s给%s打了%s分' % (self.name,stu_obj.name,score))
			
tea = Teacher('ly',19,'male',10)
print(tea.name)
print(tea.level)

单继承下属性查找

class Foo:
	def f1(self):
		print('Foo.f1')
		
	def f2(self):
		print('Foo.f2')
		'
class Bar(Foo):
	def f1(self):
		print('Bar.f1')
		
obj = Bar()
obj.f2()  # FOO.f2,Bar.f1

# 练习
class Foo:
	def __f1(self):  # _FOO__f1()
		print('Foo.f1')
		
	def f2(self):
		print('Foo.f2')
		self.__f1()  # _Foo__f1()
		
class Bar(Foo):
	def __f1(self):  # _Bar__f1()
		print('Bar.f1')
		
obj = Bar()
obj.f2()  # Foo.f2,Foo.f1

多继承下的属性查找

# 新式类:按照广度优先查找
# 经典类:按照深度优先查找
class A(object):
    def test(self);
        print('from A')

class B(A):
    def test(self):
        print('from B')

class C(A):
    def test(self):
        print('from C')

class D(B):
    def test(self):
        print('from D')

class E(C):
    def test(self):
        print('from E')

class F(D,E):
    def test(self):
        print('from F')

f1 = F()
f1.test()

super()和mro列表

class People():
    school = 'SH'
    
    def __init__(self,name,age,gender):
    self.name = name
    self.age - age
    self.gender = gender

class Teacher():

    def __init__(self,name,age,gender,level):
        self.level= level
        super().__init__(name,age,gender)  # super的使用

# mro列表练习
class A:
    def test(self):
        print('from A.test')
        super().test()

class B:
    def test(self):
        print('from B')

class C(A,B):
    pass

c = C()
c.test()  # from A.test

# mro列表练习2
class B:
    def test(self):
        print('B---->test'):      
 
    def aaa(self):
        print('B---->aaa')

calss A:
    def test(self):
        print('A---->test')
        super().aaa()

class C(A,B):
    def aaa(self):
        print('C---->test')

c = A()  
c.test()  # A---->test,B---->test
print(A.mro()) 

多态与多态性(鸭子类型)

1.什么是多态
水:液态水,固态水,气态水
动物:人,猪,狗,猫...


# 抽象类: 抽象类只能被继承,不能被实例化

class Animal(metaclass=abc.ABCMeta):
    impord abc
    @abc.abstractmethod  # 该方法已经是抽象方法了
    def speak(self):pass

    @abc.abstractmethod
    def login(self):pass

class People(Animal):
    def speak(self):
        print('嗷嗷嗷')

    def login(self):
        pass

class Pig(Animal):
    def speak(self):
        print('哼哼哼')

class Dog(Animal):
    def speak(self):
        print('汪汪汪')

obj = People()
obj.speak()


# 多态练习
class Pig():
    def sprak(self):
        print('哼哼哼')

class Dog():
    def speak(self):
        print('汪汪汪')

class Txt():
    def speak(self):
        print('Txt')

obj = People()
obj = Pig()
obj = Dog()
obj = Txt()

# 多态带来的特性: 在不用考虑对象数据类型的情况下,直接调用对应的函数

def animal(animal):
    return animal.speak()

animal(obj)
animal(obj1)
animal(obj2)
animal(obj3)

# 父类限制子类的行为
class Animal():
    def sprak(self):
        raise Exception('必须实现speak方法')

组合

# 组合就是一个对象拥有一个属性,该属性的值是另一个对象

解决类与类之间的代码冗余问题
    1.继承:满足什么是什么的关系.is-a的关系
    2.组合:没啥关系

继承是一把双刃剑,并不是继承的越多越好

class People:
    school = 'SH'

    def __init__(self,name,age,gender,):
        self.name = name
        self.age = age
        self.gender = gender


class Admin(People):
    pass


class Course():
    def __init__(self,name,period,price,):
        self.name = name
        self.period = period
        self.price = price

python = Course('python','6mon',10000)
linux = Course('linux','5mon',20000)


class Student(People,Course):
    def __init__(self,name,age,gender,course=None):
        if course is None:
            course = []
        self.courses = course
        super().__init__(name,age,gender,)

    def choose_course(self,stu_obj,course):
        stu_obj.courses.append(course)

面向对象的内置函数

1.__init__()
2.__str__()
3.__del__()
4.__enter()
5.__exit__()
6.__call__

class Student():
    school = 'SH'

    # 调用类的时候触发
    def __init__(self,name,age):
    self.name = name
    self.age = age

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

    # 打印对象的时候,自动触发的函数
    # 返回值只能是字符串
    def __str__(self):
        return 'name: %s' $ self.name
        # return 123 不行

    # 1.手动执行del
    # 2.程序执行完毕触发
    def __del__(self):
        print('__del__')
        self.f.close()

    # 对象加括号制自动调用
    def __call__(self,*args,**kwargs):
        print('__call__')

反射(4个方法)

# 对象通过字符串来操作属性

1.getattr
print(getattr(stu,'name1',None))  # stu.name
stu.func()
print(getattr(stu,'func'))
getattr(stu,'func')() # 必须掌握

2.setattr
setattr(stu,'x',123)
print(stu.__dict__)

3.hasattr
print(hasattr(stu,'name'))

4.delattr
delattr(stu,'name')
print(stu.__dict__)