Python——类和对象

类

class Student: #Student为类的名称，由一个或多个单词组成，每个单词的首字母大写，其余小写
    pass

#Python中一切皆对象，Student是对象吗？内存有开空间吗？
print(id(Student))#2284645285808
print(type(Student))#<class 'type'>
print(Student)#<class '__main__.Student'>
'''所以Student是对象，是class类的对象,会开辟内存空间'''

类属性、类方法、静态方法

'''
类:
    类属性
    实例方法(classmethod)
        注意：def：在类之内定义的称为方法，在类之外定义的称为函数
        def cm(cls):
            print('类方法')
    静态方法(staticmethod)
        @staticmethod
        def sm():
            print('静态方法')
    类方法
        @classmethod
        def cm(cls): #必须写cls
            print('类方法')

'''
class Student:
    native_place='吉林'#类属性

    def __init__(self,name,age):
        self.name=name   #self.name称为实例属性，进行了一个赋值的操作，将局部变量name的值赋给实例属性
        self.age=age

    #实例方法
    def eat(self):#self必须写
        print('学生在吃饭...')

    #静态方法
    @staticmethod
    def method():#不允许在参数列表中写self
        print('我使用了staticmethod进行修饰，所以我是静态方法')

    #类方法
    @classmethod
    def cm(cls):
        print('我是类方法，因为我使用了classmethod进行修饰')

'''
对象的创建:
    对象的创建又称为类的实例化
    语法：
        实例名=类名()

方法调用：
    1.  对象名.方法
    2.  类.方法(对象名)
'''

class Student:
    native_place='吉林'#类属性

    def __init__(self,name,age):#有默认参数self
        self.name=name   #self.name称为实例属性，进行了一个赋值的操作，将局部变量name的值赋给实例属性
        self.age=age

    #实例方法
    def eat(self):#self必须写,self为默认参数
        print('学生在吃饭...')

    #静态方法
    @staticmethod  #静态方法无默认参数
    def method():#不允许在参数列表中写self
        print('我使用了staticmethod进行修饰，所以我是静态方法')

    #类方法
    @classmethod
    def cm(cls):
        print('我是类方法，因为我使用了classmethod进行修饰')


'''创建Student类的对象'''
stu1=Student('张三',20)
print(id(stu1))#2980630494992，说明其开了内存空间
print(type(stu1))#<class '__main__.Student'>
print(stu1)#<__main__.Student object at 0x000001F2A1510F10>,这一串十六进制即为stu1的id转化成的十六进制数
print('--------------')
print(id(Student))#1527254201136
print(type(Student))#<class 'type'>
print(Student)#<class '__main__.Student'>

print('---------------')
'''方法调用方式1'''
stu1.eat()
print(stu1.name)
print(stu1.age)
'''方法调用方式2'''
print('----------------')
Student.eat(stu1)  #与43行代码功能相同



'''类属性的使用方式'''
print(Student.native_place)#吉林
stu1=Student('张三',20)
stu2=Student('李四',30)
print(stu1.native_place)#吉林
print(stu2.native_place)#吉林
Student.native_place='天津'
print(stu1.native_place)#天津
print(stu2.native_place)#天津
'''
原因:Student类对象中有属性：native_place  '吉林'
stu1，stu2都有一个类指针，指向其类别，即其都会指向Student类别,native_place是被这两个对象所共享的，

'''

'''类方法的使用方式'''
Student.cm()#我是类方法，因为我使用了classmethod进行修饰
Student.method()#我使用了staticmethod进行修饰，所以我是静态方法

动态绑定属性和方法

'''
动态绑定属性和方法
    Python是动态语言，在创建对象之后，可以动态地绑定属性和方法
'''
class Student:
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def eat(self):
        print(self.name+'在吃饭')

stu1=Student('张三',18)
stu2=Student('李四',25)
print('--------为stu2动态绑定性别属性-------')
#只想给某个对象添加一个属性，而不想给其他对象添加属性时，选用动态绑定属性和方法
stu2.gender='女'#绑定的gender属性只有stu2有，stu1没有
#print(stu1.gender)#报错，AttributeError: 'Student' object has no attribute 'gender'，没有这个属性，只有stu2有
print(stu1.name,stu2.name,stu2.gender)#张三 李四 女

stu1.eat()#张三在吃饭
stu2.eat()#eat是定义在类中的，stu1,stu2都可以使用该方法

def show():
    print('定义在类之外的，称为函数')
stu1.show=show
stu1.show()
#stu2.show()#报错，stu2未绑定show方法,AttributeError: 'Student' object has no attribute 'show'

面对对象三大特征

面向对象的三大特征：
1.封装：提高程序的安全性
1）将数据（属性)和行为（方法）包装到类对象中。在方法内部对属性进行类对象的外部调用方法。这样，无需关心方法内部的具体实现细节，从而提高复杂度
2）在Python中没有专门的修饰符用于属性的私有，如果该属性不希望在类对象中访问，前面使用两个’_’
2.继承：提高代码的复用性
3.多态：提高程序的可拓展性和可维护性

1.封装

class Car:
    def __init__(self,brand):
        self.brand=brand
    def start(self):
        print('汽车已启动...')
car=Car('宝马X5')
car.start()
print(car.brand)

class Student:
    def __init__(self,name,age):
        self.name=name
        self.__age=age  #age不希望在类的外部被使用,所以加了__
    def show(self):
        print(self.name,self.__age)

stu=Student('张三',20)
stu.show()
#在类的外部使用name与age
print(stu.name)
#print(stu.__age)  #会报错，不可以在类的外部使用该属性，AttributeError: 'Student' object has no attribute '__age'

#print(dir(stu))#['_Student__age', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'name', 'show']
print(stu._Student__age) #20,在类的外部可以通过_Student__age进行访问

2.继承

'''
继承：如果一个类没有继承任何类，则默认继承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,score):
        super().__init__(name,age)#使用super调用父类的方法,传入name和age
        self.score=score
    def info(self):
        super(Student, self).info()
        print(self.score)
#测试
stu=Student('Jack',20,'1001')
stu.info()

class Teacher(Person):
    def __init__(self,name,age,teachofyear):
        super().__init__(name,age)
        self.teachofyear=teachofyear
    def info(self):
        super(Teacher, self).info()
        print('教龄：',self.teachofyear)

stu=Student('张三',20,'1001')
teacher=Teacher('李四',34,10)

stu.info()
teacher.info()

3.多态

Object类

object类
1.object类是所有类的父类，因此所有类都有object类的属性和方法
2.内置函数dir()可以查看指定对象所有属性
3.object有一个_str_()方法，用于返回一个对于“对象的描述”，对应于内置函数str()经常用于print()方法，帮我们查看对象的信息，
所以我们经常会对_str_()进行重写

class Student():#未继承任何类时，默认继承object类
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def __str__(self):
        return '我的名字是{0},今年{1}岁了'.format(self.name,self.age)
stu=Student('张三',20)
print(dir(stu))#['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__']
print(stu)
#输出stu时，未重定义__str__()函数时：输出地址:<__main__.Student object at 0x000001EA302B3B20>
#重定义了__str__()函数时：输出：我的名字是张三,今年20岁了

3.多态

多态：

简单地说，多态时“具有多种形态”，它指的是：即便不知道一个变量所引用的对象到底是什么类型，仍然可以通过这个变量调用方法，在运行过程中
根据变量所引用的对象的类型，动态决定调用哪个对象的方法
静态语言与动态语言

静态语言与动态语言关于多态的区别：

静态语言实现多态的三个必要条件：

继承
方法重写
父类引用指向子类对象

动态语言的多态崇尚“ 鸭子类型",当看到一只鸟走起来向鸭子，游泳起来像鸭子，收起来也像鸭子，那么这只鸟就可以被称为鸭子。在鸭子类型中，
不需要关心对象是什么类型，到底是不是鸭子，只关心对象的行为

class Animal(object):
    def eat(self):
        print('动物会吃')
class Dog(Animal):
    def eat(self):
        print('狗吃骨头...')
class Cat(Animal):
    def eat(self):
        print('猫吃鱼...')
class Person:
    def eat(self):
        print('人吃五谷杂粮')

#定义一个函数
def fun(obj):
    obj.eat()

#开始调用函数
fun(Cat())
fun(Dog())
fun(Person())
print('--------------')
fun(Person())

特殊属性和特殊方法

特殊属性：

__dict__():获得类对象或实例对象所绑定的所有属性和方法的字典

特殊方法:

__len__():通过重写__len__()方法，让内置函数len()的参数可以是自定义类型
__add__()：通过重写__add__()方法，可使用自定义对象具有’+'功能
__new__():用于创建对象
__init__():对创建的对象进行初始化

特殊属性

class A:
    pass
class B:
    pass
class C(A,B):
    def __init__(self,name,age):
        self.name=name
        self.age=age
class D(A):
    pass
#创建基类的对象
'''若为类对象，看到的是属性和方法，若为实例对象，则是实例对象的字典属性'''
x=C('Jack',20)#x是C类型的一个实例对象
print(x.__dict__)#实例对象的字典属性,{'name': 'Jack', 'age': 20}
print(C.__dict__)#{'__module__': '__main__', '__init__': <function C.__init__ at 0x0000019DA972DA60>, '__doc__': None}
print('---------------')
'''特殊属性'''
'''对象调用__class__输出对象所属的类型'''
print(x.__class__)#<class '__main__.C'>
'''类调用__bases__输出该类的父类的元素'''
print(C.__bases__)#(<class '__main__.A'>, <class '__main__.B'>)
'''类调用__base__输出该类继承的第一个父类'''
print(C.__base__)#<class '__main__.A'>
'''类调用__mro__查看类的层次关系，当搞不清楚类与类之间的层次关系的时候就用这个来查看类之间的层次结构'''
print(C.__mro__)#(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)
'''类调用__subclasses__()查看该类的所有子类'''
print(A.__subclasses__())#查看类的子类,[<class '__main__.C'>, <class '__main__.D'>]

特殊方法

特殊方法:
__len__():通过重写__len__()方法，让内置函数len()的参数可以是自定义类型
__add__()：通过重写__add__()方法，可使用自定义对象具有’+'功能
__new__():用于创建对象
__init__():对创建的对象进行初始化

a=20
b=100
c=a+b#两个整数类型的对象的相加操作
print(c)#120
d=a.__add__(b)
print(d)#120

class Student:
    def __init__(self,name):
        self.name=name
    def __add__(self, other):
        return self.name+other.name
    def __len__(self):
        return len(self.name)
stu1=Student('张三')
stu2=Student('李四')

s=stu1+stu2#重定义了__add__之后，就可以实现两个对象的加法运算（因为在Student类中编写__add__()特殊的方法）
print(s)#张三李四
s=stu1.__add__(stu2)
print(s)#张三李四

print('--------------')
lst=[11,22,33,44]
print(len(lst))#4
print(lst.__len__())#4,说明len()对应的是内置函数__len__()
print(len(stu1))#2

class Person(object):
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def __new__(cls, *args, **kwargs):
        print('__new__被调用执行了，cls的id值为{0}'.format(id(cls)))
        obj=super().__new__(cls)
        print('创建的对象的id为:{0}'.format(id(obj)))
        return obj
    def __init__(self,name,age):
        print('__init__被调用,self的id值为：{0}'.format(id(self)))
        self.name=name
        self.age=age

print('object这个类对象的id为：{0}'.format(id(object)))#__new__被调用执行了，cls的id值为1991442800992,创建的对象的id为:1991443882480
print('Person这个类对象的id为：{0}'.format(id(Person)))


#创建Person类的实例对象
p1=Person('张三',20)
'''
在创建p1这个对象的时候，先调用__new__()new一个对象出来，再调用__init__()进行初始化，最后再赋值给p1
'''
print('p1这个Person类的实例对象的id:{0}'.format(id(p1)))#p1这个Person类的实例对象的id:1991443882480