学习笔记1 面向对象

面向对象

一、类与对象

1.类：是多个类似事物组成的群体的统称。能够帮助我们快速理解和判断事物的性质。
2.数据类型：不同的数据类型属于不同的类；
使用内置函数查看数据类型
3.对象：100、99等都是int类之下包含的相似的不同个例，即称为实例或对象。
python中一切皆对象

二、类的创建

1.语法：class Student: pass
Student 为类名，首字母大写

2.类的组成：

• 类属性
• 实例方法
• 静态方法
• 类方法

class Student:   #Student为类名，首字母大写
    native_pace='北京'   #直接写在类里的变量，称为类属性
    def __init__(self,name,age):
        self.name=name   #self.name 称为实例属性。这里进行了赋值操作，将局部变量的name的值赋给实例属性
        self.age=age
        
    #实例方法
    def eat(self):
        print('学生在吃饭...')
    
    #类方法
    @classmethod
    def cm(cls):
        print('类方法')
        
    #静态方法
    @staticmethod
    def method():
        print('静态方法')

在类之外定义的称为函数，在类之内定义的称为方法

三、对象的创建

1. 对象的创建又称为类的实例化
2. 语法：
   实例名=类名（）
3. 意义：有了实例，就可以调用类中的内容

#创建Student类的对象        
stu1=Student('张三',20)
stu2=Student('李四',30)
#调用方法
stu1.eat()          #对象.方法名()
Student.eat(stu1)   #类名.方法名(类的对象)-->实际上就是方法定义处的self
print(stu1.name)

一个类可以创建n个实例对象，每个实例对象的属性值不同

4. 动态绑定属性和方法
   python时动态语言，在创建对象之后，可以动态地绑定属性和和方法

#为stu1动态绑定性别属性
stu1.gender='男'

#为stu1动态绑定方法
def show():
    print('定义在类之外的，称为函数')
stu1.show=show

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

1. 类属性：类中方法外的变量称为类属性，被该类的所有对象所共享

#类属性的使用方法
print(Student.native_pace)
stu1=Student('张三',20)
stu2=Student('李四',30)
print(stu1.native_pace)
print(stu2.native_pace)
Student.native_pace='天津'
print(stu1.native_pace)
print(stu2.native_pace)

类属性native_pace='北京'被类的对象stu1、stu2所共享，所有当类属性被修改为‘天津’后，stu1、stu2再访问类属性时也变成了‘天津’。

2. 类方法：使用 @classmethod 修饰的方法，使用类名直接访问的方法

#类方法的使用方式
Student.cm()

3. 使用 @ staticmethod 修饰的方法，使用类名直接访问的方法

#静态方法的使用方式
Student.method()

五、面向对象的三大特征

1. 封装：提高程序的安全性

• 将数据（属性）和行为（方法）包装到类对象中。在方法内部对属性进行操作，在类对象的外部调用方法。这样，无需关心方法内部的具体实现细节，从而隔离了复杂度。
• 在python中没有专门的修饰符用于属性的私有，如果该属性不希望在类对象外部被访问，前面使用两个‘_’。

class Student:   
    def __init__(self,name,age):
        self.name=name   
        self.__age=age   #年龄不希望在类的外部被使用，所有加了两个‘_’
    def show(self):
        print(self.name,self.__age)

stu=Student('张三',20)
stu.show()
#在类的外部使用name和age
print(stu.name)
print(stu._Student__age)   #在类的外部可以通过 _Student__age 进行访问

所有当看到属性被私有化就自觉不要访问

2. 继承：提高代码的复用性

• 语法格式：
  class 子类类名（父类1，父类2，…）：pass
• 如果一个类没有继承任何类，则默认继承object
• python支持多继承
• 定义子类时，必须在其构造函数中调用父类的构造函数

class Person(object):
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def info(self):
        print(self.name,self.age)
        
class Student(Person):
    def __init__(self,name,age,number):
        super().__init__(name,age)
        self.number=number

class Teacher(Person):
    def __init__(self,name,age,year):
        super().__init__(name,age)
        self.year=year
        
stu=Student('张三',20,101)
teacher=Teacher('李四'30,3)

stu.info()
teacher.info()

#多继承
class A(object):
    pass

class B(object):
    pass

class C(A,B):
    pass

• 方法重写
  * 如果子类对继承自父类的某个属性或方法不满意，可以在子类中对其进行重新编写
  * 子类重写后的方法中可以通过super().xxx()调用父类中被重写的方法

def info(self):
    super().info()
    print(self.number)

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

class Student:
    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(stu)   #默认调用__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(object):
    def eat(self):
        print('人吃五谷杂粮')
 
def fun(animal):
    animal.eat()
    
fun(Animal())
fun(Dog())
fun(Cat())
fun(Person())

输出:
动物会吃
狗吃骨头
猫吃鱼
人吃五谷杂粮

• 静态语言与动态语言
• 区别：
  1） 静态语言实现多态的三个必要条件：
  继承
  方法重写
  父类引用指向子类对象
  （即必须明确继承关系才能使用）
  2）动态语言是多态崇尚“鸭子类型”。
  在鸭子类型中，不需要关心对象有什么类型，到底是不是鸭子，只关心对象的行为。
  python就是动态语言

六、特殊属性和特殊方法

1. 特殊属性：

• dirt：获得类对象或实例对象所绑定的所有属性和方法的字典

class A:
    pass
class B:
    pass
class C(A,B):
    def __init__(self,name,age):
        self.name=name
        self.age=age

x=C('Jack',20)      #x是C类型的一个实例对象
print(x.__dict__)   #实例对象的属性字典
print(C.__dict__)   #类对象的属性和方法字典
print(x.__class__)  #输出了对象所属的类
print(C.__bases__)  #C类的父类类型的元素
print(C.__base__)   #类的基类
print(C.__mro__)    #类的层次结构
print(A.__subclasses__()) #子类的列表

输出：
{‘name’: ‘Jack’, ‘age’: 20}
{‘module’: ‘main’, ‘init’: <function C.init at 0x0000019D54E5D2F0>, ‘doc’: None}
<class ‘main.C’>
(<class ‘main.A’>, <class ‘main.B’>)
<class ‘main.A’>
(<class ‘main.C’>, <class ‘main.A’>, <class ‘main.B’>, <class ‘object’>)
[<class ‘main.C’>]

2. 特殊方法：

• init()：对创建对此昂进行初始化