14.Python的类和对象

目录

一、类

二、对象

三、属性

3.1类属性

3.2对象属性

四、方法

4.1实例方法

4.2类方法

4.3特殊方法

4.4静态方法

五、类的继承

5.1继承

5.2重写

5.3object类

5.4多态

六、私有化

6.1私有属性

6.2私有方法

七、自省与反射机制

7.1自省机制

7.2反射

一、类

定义：

类是多个类似事物组成的群体的统称，能够帮助我们快速理解和判断事物的性质

类就是一种数据类型，自定义类就是为了自定义数据类型

类名由一个或多个单词组成，每个单词的首字母大写，其余小写

语法：

class 类名:
    属性
    方法

class Student:
    """
    表示学生
    """
    pass

二、对象

定义：

对象就是某个类的具体的一个实例

对象的创建又称为类的实例化

语法：

实例名=类名()
point = Point()

类和对象的区域：

类是对客观世界中事物得抽象，而对象是类实例化后的实体

例如：汽车模型就是一个类，制造出来的每辆汽车就是一个对象

三、属性

类和对象的特征数据称为属性。

3.1类属性

直接在类中定义的变量，被该类的所有对象所共享，通过类名.类属性/对象.类属性名调用

定义：

class Student:
    native_place='四川' #类属性，直接写在类里的变量

调用：

类名.类属性

对象.类属性名

print(Student.native_place)  # 直接通过类名访问类属性
p=Student()  # 创建一个实例
print(p.native_place)     # 通过对象访问类属性

3.2对象属性

一般定义在构造方法中，通过句点法对象.对象属性以赋值的方式可以直接定义对象属性 ，为该对象特有的属性，只能通过对象.对象属性进行访问

通过对象访问一个属性的时候，首先找对象本身有没有这个属性，有就返回，若没有则在对象对应的类中寻找相关属性，若类中也无该属性，则报错，所以当对象属性和类属性名重名，只会返回对象属性

定义：

p = Student()
# 通过赋值直接定义对象属性
p.age = 13

调用：

对象.对象属性

print(p.age)

四、方法

定义在类中的函数称为方法。通过调用的方式的不同，分为对象方法，类方法，静态方法和魔术方法。

4.1实例方法

定义在类中的普通方法，一般通过对象调用

定义：

class Student:
    native_place='四川' #类属性，直接写在类里的变量
    #实例方法
    def eat(self):  
        print('实例方法')

调用：

类名.方法名(参数)

对象.方法名(参数)

通过对象调用方法时，对象本身会被隐式的传给方法的第一个参数

stu=Student()
stu.eat() #与Student.eat()功能相同，都是调用Student中的eat方法
Student.eat(stu)

4.2类方法

在普通的方法基础上增加一个classmethod装饰器，不需要对象就能调用

定义：

class Student: 
    #类方法
    @classmethod
    def cm(cls):
        print('使用classmethod修饰，是类方法')
        return cls(0,0)

调用：

stu=Student()
stu.cm() 
Student.cm()

4.3特殊方法

可以定义一些特殊的方法来实现特殊的功能，也成为魔术方法，一般以双下划线__开头

更多特殊方法：更多特殊方法

定义：

class Student:
    def __init__(self,name,age): #类的构造函数，用于初始化类的内部状态，为类的属性设置默认值
        self.name=name   #self.name称为实体属性，进行了一个赋值操作，将局部变量的name的值赋给实体属性
        self.age=age

调用：

stu=Student('jack',20)
print(stu.name)
print(stu.age)
print(Student('haha',23).age)

4.4静态方法

在普通的方法基础上增加一个staticmethod装饰器，不会接收隐式的第一个参数，和普通的函数一样且与类本身无联系，只是被封装到类中

定义：

class Student:
    @staticmethod
    def sum(a,b):
        return a+b

调用：

print(Student.sum(1,7))
stu=Student()
print(stu.sum(3,5))

五、类的继承

5.1继承

当定义一个类时，可以从现有的类继承，新的类称为子类，被继承的类称为基类/父类

子类可以继承父类的属性和方法，如果一个类没有继承任何类，则默认继承object，python支持多继承，定义子类时，必须在其构造函数中调用父类的构造函数

语法：

class 子类类名(父类1,父类2....)
    pass

实例：

class Person(object):  #Person继承object类
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def info(self):
        print('姓名:{0}，年龄{1}'.format(self.name,self.age))
​
class Student(Person):
    def __init__(self,name,age,stu_no):
        super().__init__(name,age)  #继承Person中的属性
        self.stu_no=stu_no   #子类新定义的属性
​
class Teacher(Person):
    def __init__(self,name,age,tofyear):
        super().__init__(name,age)  #继承Person中的属性
        self.tofyear=tofyear  #子类新定义的属性
​
stu=Student('jack',20,1001)
tea=Teacher('mary',34,10)
print(stu.name,stu.stu_no)
print(tea.name,tea.tofyear)
stu.info()   #调用父类的方法
tea.info()   #调用父类的方法
​
#多继承
class A(object):
    pass
​
class B(object):
    pass
​
class C(A,B):
    pass

5.2重写

子类中定义同名的方法和属性会覆盖父类的方法和属性。如果子类对继承自父类的某个属性或方法不满意，可以在子类中对某（方法体）进行重新编写

子类重写后的方法中可以通过super().xxx()调用父类中被重写的方法

class Person(object):  #Person继承object类
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def info(self):
        print('姓名:{0}，年龄{1}'.format(self.name,self.age))
​
class Student(Person):
    def __init__(self,name,age,stu_no):
        super().__init__(name,age)
        self.stu_no=stu_no
    def info(self):    #重写父类中info方法
        super().info()
        print('学号{}'.format(self.stu_no))
    def haha(self):  #调用父类中info方法
        super().info()
​
stu=Student('jack',20,1001)
stu.info()
stu.haha()

5.3object类

object类是所有类的父类，因此所有类都有object类的属性和方法

内置函数dir()可以查看指定对象所有属性

object有一个__str()__方法，用于返回一个对于“对象的描述”，对应于内置函数str()经常用于print()方法，帮我们查看对象的信息，所以我们经常会对str()进行重写

class Student:
    pass
stu=Student()
print(dir(stu))
print(stu) #默认调用__str__这样发方法
​
​
class Student1():
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def __str__(self):  #重写__str__
        return '我的名字是{0}，年龄{1}'.format(self.name,self.age)
​
stu=Student1('jack',20)
print(dir(stu))
print(stu)   #默认调用__str__这样发方法
print(type(stu))

5.4多态

用test()函数接收一个对象，并调用对象的eat方法，不检查对象的类型，只关心对象的行为

class Animal(object):    #定义各个类中的方法
    def eat(self):
        print('动物吃东西')
class Cat(Animal):
    def eat(self):
        print('猫吃鱼')
class Dog(Animal):
    def eat(self):
        print('狗吃骨头')
class Person(object):
    def eat(self):
        print('人吃饭')
class Ha(Animal):
    pass
​
def test(a):  #定义函数使用eat方法
    a.eat()
​
test(Animal())  #调用对应类中的eat方法
test(Cat())
test(Dog())
test(Person())
test(Ha())

六、私有化

在开发过程中，对象的某些属性、方法只想在内部被使用，不想在外部被访问，通过__进行定义。

类的私有属性和私有方法，都不会被子类继承，子类也无法访问。

6.1私有属性

class A:
    
    __name='私有属性'
​
    def method2(self):
        return A.__name
    
    def __init__(self,name,age):
        self.name=name
        self.__age=age
​
    def hah(self):
        return self.__age
    
    
a=A('zhangsan',18)
​
print(a.__age)   #直接调用时报错
print(a.hah())   #通过内部方法调用
​
print(a.__name)     #直接调用时报错
print(a.method2())  #通过内部方法调用

6.2私有方法

class A:
​
    def __method1(self):
        print('我是私有方法')
​
    def method2(self):
        return self.__method1()
​
​
a=A()
a.__method1  #直接调用时报错
a.method2()  #通过内部方法调用

七、自省与反射机制

7.1自省机制

自省时一种自我检查行为，检查对象以确定它是什么类型、包含哪些属性、方法。

1.type返回对象的类型

a=1
class ABC:
    pass
​
type(a)
type(ABC)

2.dir返回对象的属性、方法名的列表

class Pepole(object):
    country='china'
​
    def __init__(self,name,age):
        self.name=name
        self.age=age
​
    def test(self):
        print('这是测试方法')
​
p=Pepole('zhangsan',18)
print(dir(p))

3.isinstance(obj,class)判断obj是不是一个class的类型

class Pepole(object):
    country='china'
​
    def __init__(self,name,age):
        self.name=name
        self.age=age
​
    def test(self):
        print('这是测试方法')
​
p=Pepole('zhangsan',18)
print(isinstance(p,Pepole))

4.判断issubclass(class,(pclass1,pclass2,....))判断class是否是pclass1，pclass2..中的子类，返回布尔值

class Pepole(object):
    pass
​
class Student(Pepole):
    pass
​
print(issubclass(Student,(Pepole,int)))

7.2反射

反射是动态的操作对象，简单的讲就是根据字符串形式的属性名、方法名操作对应的对象

1.getattr(obj,name)获取obj里面的属性名为name的属性或方法：

name是字符串，根据字符串获取对应的属性或者方法

class Pepole(object):
    country='china'
​
    def __init__(self,name,age):
        self.name=name
        self.age=age
​
    def test(self):
        print('这是测试方法')
​
    def sum(self,a,b):
        print(a-b)
      
​
p=Pepole('zhangsan',14)
​
#其中country可以用input接收为一个变量，根据变量内容不同可查看不同的属性或方法
res=getattr(p,'country')  
print(res)
​
print(getattr(p,'test'))
​
getattr(p,'sum')(4,1)    #调用该方法

2.setattr(obj,name,value)给obj对象设置一个名为name的属性，值为value：

name是字符串，根据字符串设置对象的属性

class Student(object):
    country='china'
​
s=Student()
#其中name、value可以用input接收为变量，根据变量内容不同可方便定义属性
setattr(s,'name','zhangsan')
print(getattr(s,'name'))
​
setattr(s,'country','ch')   #修改原有属性
print(getattr(s,'country'))

3.hasattr(obj,name)判断obj有没有一个叫name的属性：

class Student(object):
    country='china'
    
s=Student()
print(hasattr(s,'country'))

4.delattr(obj,name)从obj里面删除一个叫name的属性：

class Student(object):
    country='china'
    name='zhangsan'
​
s=Student()
print(hasattr(s,'name'))
delattr(Student,'name')
print(hasattr(s,'name'))