Python基础（一）面向对象

面向对象

1 面向过程 & 面向对象

	面向过程	面向对象
区别	事务比较简单，可以用线性的思维去解决	事务比较复杂，使用简单的线性思维无法解决
共同点	具体到微观操作，仍然使用面向过程方式来处理	解决复杂问题，通过面向对象的方式便于我们从宏观上把握事物之间复杂的关系，方便我们分析整个系统

2 类与对象

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

数据类型

• 不同的数据类型属于不同的类
• 使用内置函数查看数据类型

对象

• 99、520、1都是int类之下包含的相似的不同个例，称之为实例或对象

3 类的创建

创建类的语法

class Student:
    pass

类的组成

• 类属性：类中方法外的变量称为类属性，被该类所有对象所共享
• 实例方法：
• 静态方法：使用$@staticmethod$ 修饰的方法，使用类名直接访问的方法
• 类方法：使用$@classmethod$ 修饰的方法，使用类名直接访问的方法

class Student:
    native_place='河南' #类属性
    def __init__(self,name,age): #name,age为实例属性
        self.name = name
        self.age = age

    #实例方法
    def info(self):
        print('我的名字叫',self.name,'年龄是',self.age)

    #类方法
    @classmethod
    def cm(cls):
        print('类方法')

    #静态方法
    @staticmethod
    def sm():
        print('静态方法')

4 对象的创建

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

创建实例对象的语法

• 实例名=类名（）

例子

#创建Student类的实例对象
stu=Student('Grapes',20)
print(stu.name) #实例属性
print(stu.age)  #实例属性
stu.info()      #实例方法

#Grapes
#20
#我的名字叫 Grapes 年龄是 20

调用类中的方法

#调用实例方法
stu.info()      	#方法一
Student.info(stu)	#方法二
#调用类方法
Student.cm()    
#调用静态方法
Student.sm()    

5动态绑定属性和方法

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

  def show():
      print('我是一函数')
  
  stu=Student('Grapes',20)
  stu.gender='女' #动态绑定性别
  print(stu.name,stu.age,stu.gender)
  stu.show = show #动态绑定方法
  stu.show()
  

6 封装、继承、多态

6.1 封装

class Student:
    def __init__(self,age):
        self.set_age(age)
    def get_age(self):
        return self.__age
    def set_age(self,age):
        if 0<=age<=18:
            self.__age=age
        else:
            self.__age=18

stu1 = Student(20)
stu2 = Student(15)
print(stu1.get_age())
print(stu2.get_age())

6.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('姓名:{0},年龄:{1}'.format(self.name,self.age))
#定义子类
class Student(Person):
    def __init__(self,name,age,score):
        super().__init__(name,age)
        self.score=score
#测试
stu=Student('Grapes',20,'1001')
stu.info()

6.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(Dog())
fun(Cat())
fun(Person())

7 方法重写

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

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)
        self.score=score
    #方法重写
    def info(self):
        super().info()
        print('学号:{0}'.format(self.score))
#测试
stu=Student('Grapes',20,'1001')
stu.info()

8 object类

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

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))
    def __str__(self):
        return '姓名:{0},年龄:{1}'.format(self.name,self.age)

o = object()
p = Person('Grapes',20)
print(dir(o))
print(dir(p))
print(p)

9 特殊方法和特殊属性