数据分析（五）

面向对象和面向过程

类的组成

  类属性             类中方法外的变量称为类属性，被该类的所有对象共享  Student.cm()  #访问类属性

  实例方法

  静态方法        使用@staticmethod修饰的方法，使用类名直接访问的方法，Student.sm()  #调用静态方法

  类方法            使用@classmethod修饰的方法，使用类名直接访问的方法，Student.cm()  #调用类方法

class  Person：

      native_pace='吉林'       #类属性，直接写在类里的变量

      def  eat(self):                  #实例方法，self是惯例添加到那里的，不添加也在那里    类外定义的是函数，类内定义的是方法

             print('学生在吃饭...')

     @staticmethod

     def method()               #规定在静态方法中不允许写self，使用staticmethod修饰的是静态方法

           print('我使用静态方法‘）

     @classmethod

      def cm(cls)             #使用classmethod修饰的是类方法，类方法要写cls

            print('类方法‘）

     def  __init__(self,name,age):    #__init__() 是一个固定的函数名称

           self.name=name                 #self.name称为实体属性，进行了一个复制的操作，将局部变量的name的值赋给了实体属性

           self.age=age

 

对象的创建

    stu=Person（‘张三’，20）    # 根据初始化方法，传两个参数

    stu.eat()         #调用方法   或者使用Stuent.eat（stu） 这里实际上就是方法定义处的self

   print（stu.name）   # 输出实例化属性

 

 

Python是动态语言，在创建对象之后，可以动态地绑定属性和方法

class Student:
   native_pace='吉林'
   def eat(self):
       print(self.name+'在吃饭')

   @staticmethod
   def method():
        print('我使用静态方法')
   @classmethod
   def cm(cls):
        print('类方法')
   def __init__(self,name,age):
       self.name=name
       self.age=age


def show():
    print('我是一函数')

stu1=Student('Jack',20)    #定义并初始化一个类的实例
stu2=Student('李四',30)
stu1.gender='男'   #动态绑定性别,只想给stu1指定一个性别，用对象添加一个属性
print(stu1.name,stu1.age,stu1.gender)
stu1.show=show        #动态绑定方法
stu1.show()

 

封装： 提高程序的安全性，将数据和行为包装到类对象中。在方法内部对属性进行操作， 在类对象的外部调用方法，无需关心方法内部的具体实现细节

            没有专门的修饰符用于属性的私有不希望在类对象外部被访问，前边使用两个_

           

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.__age)      #在这样的情况下，是无法访问__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)   #这样就访问到了age

继承：提高代码的复用性

          语法格式

          class 子类类名（父类1，父类2...）

                   pass

          如果一个类没有继承任何类，则默认继承object

          

class 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调用父类的__init__方法
        self.score=score
#测试
stu=Student('Jack',20,99)
stu.info()

          Python支撑多继承  class C(A,B):

         定义子类时，必须在其构造函数中调用父类的构造函数

 

        方法重写：如果子类对继承父类的某个属性或者方法不满意，可以在子类中对方法体 进行重新编写

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

                           

              super().__init__(name,age)   #使用super调用父类的__init__方法
              self.score=score

 

 print（p）输出的是姓名：Jack，年龄：20      因为对__str__进行了重写,调用str里面的额内容，不再输出对象的内存地址

多态：提高程序的可扩展性和可维护性 

          即使不知道一个变量所引用的对象到底是什么类型，仍然可以通过这个变量调用方法，在运算过程中根据所引用对象的类型，动态决定调用哪个对象中的             方法

          

class Animal():
    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(Dog())      #cat和dog继承了父类animal里的方法eat，并且进行了重写
fun(Cat())
fun(Person())     #与是否具有继承关系无关，因为Person1里面有eat方法，所以他回去调用Person的eat方法
                  #不关心person是谁的子类，只关心他有eat方法

 

静态语言和动态语言关于多态的区别

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

      继承

      方法重写

      父类引用指向子类对象

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

 

特殊方法和特殊属性

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

                  

                          __class__() 输出对象所属的类 

                          __bases__() 输出父类元素

                          __base__() 输出最近的一个（在前的）父类元素

                          __mro__() 输出类的层次结构

                          __subclasses__() 输出其子类

 

       特殊方法：__len__()   通过重写__len__() 方法，让内置函数len（）的参数可以是自定义类型      在类中定义一个方法 def   __add__(self,other):

                                                                 return self.name+other.name

                                                      重写add之后就可以使用s=stu1+stu2 完成add加法的使用

                         __add__()  通过重写__add__()方法，可以使用自定义对象具有“+”  功能

                         __new__()  用于创建对象

                          __init__()   对创建的对象进行初始化

                  

new在前创建对象，init在后初始化对象

 

 

类的浅拷贝与深拷贝

     变量的赋值操作：只是形成两个变量，实际上还是指向同一个对象

     浅拷贝：Python拷贝一般都是浅拷贝，拷贝时，对象包含的子对象内容不拷贝，因此，源对象和拷贝对象会引用同一个子对象

                    可以看到子对象的指向是不会改变的，复制了一个源对象

    

 

 

     深拷贝：使用copy模块的deepcopy函数，递归拷贝对象中包含的子对象，源对象和拷贝对象所有的子对象也不相同

                   深拷贝的时候不但会拷贝一个computer还会对子对象cpu和disk进行拷贝

     只要是对象都是由三部分组成的：id   type   value  有一个类指针指向类对象