2018-09-06-day14面向对象总结

编程方式
面向过程:以算法为工具
函数式编程:以函数为工具
面向对象编程:以类和对象为工具

1.类的声明

类：对拥有相同功能和相同属性的对象的集合
对象:类的实例
封装效果:一个类中可以对多个功能进行封装（多个函数）
类声明格式:
class 类名(父类列表):
类的内容

2.说明:

class:声明类的关键字
类名:标识符，不能是关键字，驼峰式命名(第一个单词首字母小写，其他的单词首字母大写)首字母大写！！！，见名知义
例如:Person、StudentSystem
(父类列表):这个部分可以省略，这个是继承语法，可以有多继承
冒号:固定写法
类的内容:类的内容包括类的方法和类的属性

3.类中的方法：就是声明在类中的函数

方法：
a.对象方法:对象方法需要通过对象来调用，对象.函数名()
直接写在类中的方法，自带一个self参数

b.创建类的时候，系统会默认给我们创建这个类对应的构造方法
构造方法:类名()--->创建类对应的对象，只有在调用构造方法的时候才会产生新的对象
调用对象方法:对象.方法()
1).构造方法：系统自动创建的，方法名和类名一样，用来创建对象
2).init:init方法的功能是用来做初始化和添加对象属性的
当我们通过构造方法去创建对象的时候，系统会自动调用init方法

class Person:

    def __init__(self):
        print('初始化...')
    def eat(self):
        print('吃饭')

if __name__ =='__main__':
    p1=Person()     #创建Person类的对象，并且将对象的地址存到p1中
    p1.eat()        #调用对象方法

创建对象的过程：调用构造方法在内存中开辟一个对象，然后用新建的这个对象去调用init方法
来初始化对象的属性，最后才将对象返回


class Person:
    #init方法可以添加参数
    def __init__(self,name):
        print(name)

if __name__=='__main__':
    p1=Person('hello')

4 .类字段和类方法

类中的内容:属性和方法
1).属性：
a.对象的属性：不同的对象，对应的值可能不一样，这样的属性时对象属性，属于对象
b.类的字段：属于类的，所有的对象对应的值是一样的
类中对象的属性声明再init方法中的，并且声明格式是:self.属性名 = 初值
***对象的属性必须是全部传入的

class Student:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def print_info(self):
        print(self.name,end='')
        print(self.age)
if __name__ == '__main__':
    s1=Student('张三',18)
    s1.print_info()

    s2=Student('李四',20)
    s2.print_info()

***对象的属性时默认的
class Student:
    def __init__(self):
        self.name = '张三'
        self.age = 18
        self.id = 1
    def print_info(self):
        print(self.name,self.age,self.id)

if __name__ == '__main__':
    s1 = Student()
    s1.print_info()
    s1.name = '李四'
    s1.age = 20
    s1.id = 2
    s1.print_info()

***对象的属性部分传入部分默认

class Person:
    class_p ='white person'
    def __init__(self,id):
        self.name = '张三'
        self.age = '20'
        self.id = id
if __name__ == '__main__':
    p = Person(10)
    print(Person.class_p)
    print(p.class_p)

对象的属性通过(对象.属性)去使用对象的属性，也可以通过(对象.属性)去修改对象的属性

练习：写一个矩形类，拥有属性长和宽

class Rect:
    def __init__(self,width,height):

        self.height=height
        self.width=width


    def print_info(self):
        print(self.width,self.height)
if __name__ == '__main__':
    r = Rect(20,30)
    r2 = Rect(30,40)
    r.print_info()
    r2.print_info()

5.对象属性的增删改查

python是动态语言，python中类的对象的属性可以进行增删的的操作

class Person:
    def __init__(self):
        self.name ='张三'
        self.age = 18
        self.height = 160
if __name__=='__main__':
    p1 = Person()
    #查（获取属性的的值）
    '''
    方法一:对象.属性名，当这个属性名不存在的时候，会报AttributeError错误
    '''
    print(p1.name)
    '''
    方法二:通过内置函数getattr(object,name,default=None)
    object:指定对象
    name:属性名字,字符串
    defalut:如果设置了默认值，而要取的属性不存在，会取回默认值，程序不会崩溃，
    如果没有设置默认值，要取的属性不存在，会报错AttributeError
    '''
    print(getattr(p1,'name',0)) #0
    print(getattr(p1,'name'))   #Attribute
    '''
    方法三对象.__getattribute__(属性名)
    属性名:是一个字符串
    '''
    print(p1.__getattribute__('name'))

    #2.改（修改属性的值）
    '''
    方法一：对象.属性 = 新值
    方法二: def setattr(对象，属性名，新值)
    方法三:对象.__setattr__(属性名，新值)
    '''
    p1.name = 'hello'
    print(p1.name)
    setattr(p1,'name','world')
    print(p1.name)
    p1.__setattr__('name','python')
    print(p1.name)
    
    '''
    3.增加(添加属性)
    增加的语法和修改的语法一模一样，属性值存在就是修改，属性值不存在的时候就是添加
        方法一：对象.新属性 = 初值
    方法二: def setattr(对象，新属性名，初值)
    方法三:对象.__setattr__(新属性名，初值)
    注意：添加属性只能给某一个对象添加属性
    p1.sex = '女'
    print(p1.sex)
    
    setattr(p1,'weight',45)
    print(p1.weight)

    p1.__setattr__('color','red')
    print(p1.color)

    类也可以以这样的方式添加属性
    '''

    '''
    4.删除
    方法一:del 对象.属性
    方法二:delattr(objject,属性名)
        第一个参数是对象，第二个参数是属性名
        delattr(p1,'age')
    方法三:对象.__delattr__(属性名)
    注意：删除只针对某一个单独的对象
    '''
    del p1.name
    print(p1.name)
    delattr(p1,'age')
    print(p1.age)
    p1.__delattr__('name')
    print(p1.name)

6.对象方法

a.什么是对象方法:对象方法就是写在类里面的方法默认全部是对象方法，对象方法有一个默认参数self
b.对象方法要通过对象来调用：对象.对象方法()
c.对象方法中默认参数self，不需要传参，因为在调用这个方法的时候系统会自动将当前对象传给self，谁调用self，self就是谁

import math
class Circle:
    pi = math.pi
    def __init__(self,radius):
        self.radius = radius
    #声明一个对象方法area
    #在这儿，self就是调用area方法的对象，对象能做的事，self都可以做，相当于java里的this.
    def area(self):
        print(id(self))
        return self.radius**2*Circle.pi

if __name__ == '__main__':
    c1 =Circle(10)
    print(id(c1))
    print(c1.area())

练习1:写一个矩形类有属性长和宽，有两个功能分别是求周长和面积

class Rect:
    def __init__(self,length,width):
        self.length = length
        self.width = width
    #对象方法是否需要额外参数，看实现函数的功能需不需要除了对象属性以外的其他的数据
    def perimeter(self):
        return (self.length+self.width)*2

    def area(self):
        return self.length*self.width

练习2：写一个班级类，班级里面有多个学生的成绩(一门)，可以获取班级成绩中的最高分

class Class:
    '''
    班级类
    '''
    def __init__(self,classname):
        self.scores = []
        self.classname = classname

    def get_high_score(self):
        if self.scores:
            return max(self.scores)
        return None

if __name__=='__main__':
    c1=Class('001')
    c1.scores=[10,20,5,25,76,1]
    print(c1.get_high_score())

d.类的字段
类的属性叫类的字段
a.什么是类的字段:类的字段就是声明在类中，函数的外面的变量，叫做类的字段

    class Person:
        #这个number就是类的字段
        number = 10
    if __name__ == '__main__':
        print(Person.number)

b.什么样的属性声明成类的字段
不同的对象对应的值都是一样的，他是属于所有对象公有的属性，是属于类的。

c.怎么使用
通过类来使用:类.字段

练习:写一个类，用一个属性来保存这个类创建的对象的个数

class Person:
    count = 0
    def __init__(self):
        Person.count +=1

if __name__=='__main__':
    p1=Person()
    p1=Person()
    p1=Person()
    p1=Person()
    print(Person.count)

e.类的方法
类中的方法：
1.对象方法（实例方法）
直接声明再类中，自带一个不需要主动传参的默认参数self,谁来调用指向谁
调用:通过对象来调用
2.类方法
声明方法前需要使用@classmethod说明
特点:自带一个默认参数cls,这个参数调用的时候不需要传值，系统自动给他传，谁调用就指向谁，始终指向当前类
调用:通过类来调用->类.类方法
cls:就是当前类，可以创建对象，调用类的属性和方法
3.静态方法
声明方法前需要使用@staticmethod说明
特点:没有默认参数,静态方法不能在继承中修改
调用：通过类来调用-->类.静态方法()

类方法声明格式

  Class Person:
        #声明一个对象方法
        def object_func(self):
            print('对象方法')

        #声明类方法
        @classmethod
        def class+func(cls):
            print('这是一个类方法')
        #声明静态方法
        @staticmethod()
        def static_func():
            print('这是一个静态方法')

4.遇到问题怎么来选择使用哪种方法：
a.大前提:只要实现方法的功能需要用到对象的属性，我们就使用对象方法
b.不使用对象方法的前提下，如果实现功能需要用到类的字段就使用类方法
c.实现功能既不需要对象的属性，又不需要类的字段就使用静态方法
注意:静态方法和类方法划分不用那么严格，静态方法能做的类方法也可以做，反之亦然

class Person:
    #类的字段，存储人类的数量
    number = 100
    @classmethod
    def show_number(cls):
        print('人类的数量是:%d亿'%cls.number)

    @staticmethod
    def show_number():
        print('人类的数量是:%d亿'%Person.nmber)
Person.show_number()