2018-09-06-类和对象

一、初步认识类和对象

1，理论上的定义

• 类：就是拥有相同功能和相同属性的对象的集合
• 对象：类的实例（对象是具体的）

如果说人是一个类，具体某个人就是一个对象

2，编程思想

• 面向过程编程：以算法为工具
• 函数式编程：以函数为工具
• 面向对象编程（面向生活）：以类和对象为工具
  （声明一个类，拥有某种功能）

二、类的声明

类：就是拥有相同功能(方法)和相同属性的对象的集合

封装效果，一个类中可以对多个功能进行封装（多个函数）；封装多个属性

1，类的声明格式

class 类名（父类列表）
——类的说明文档
——类的内容

# 创建一个类
class Person:
    '''
    人类
    '''
    def eat(self):
        print('人吃饭')

2，说明：

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

3，类中的方法

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

3.1:对象方法：（实例方法）

声明的形式：直接声明在类中
特点：自带一个不需要主动传参的默认参数self，谁来调用指向谁
调用：通过对象来调用

3.2:类方法

声明的形式：声明方法前需要使用@classmethod说明
特点：自带一个不需要主动传参的默认参数cls，谁来调用指向谁.始终指向当前类
调用：通过类来调用 类.类方法()

3.3:静态方法

声明的形式：声明方法前需要使用@staticmethod说明
特点：没有默认参数
调用：通过类来调用 类.类方法()

4，创建对象

创建类的时候，系统会默认创建这个类对应的构造方法
构造方法：类名（）---->创建一个类对应的对象

    #1，创建对象
    p1= Person()   #创建Person类的对象，并且将对象地址存到p1中
    p2=Person()    #一个类可以有多个对象
    p3=p2          #只有在调用构造方法的时候才会产生新的对象

5、构造方法及“init”函数

5.1.构造方法：系统自动创建的，方法名和类名一样。用来创建对象

5.2. __ init __ :init方法的功能是用来做初始化和添加对象属性的

当我们通过构造方法去创建对象的时候，系统会自动调用init方法
创建函数的过程：调用构造方法在内存中开辟空间创建一个对象，然后用新建的这个对象去调用init方法，来初始化对象的属性。最后才返回对象

class Dog:

    def __init__(self):
        print('init方法')
    def dog(self):
        print('    -----')

class Person:
    def __init__(self,name):
        print(name)
        print('人，init方法')


if __name__ == '__main__':
    # 创建函数的过程：调用构造方法在内存中开辟空间创建一个对象，
    # 然后用新建的这个对象去调用init方法，来初始化对象的属性。最后才返回对象
    dog1 = Dog()
    dog2 = Dog()
    dog2.dog()

    # 如果类的init方法有参数，通过给构造方法传参对init方法传参
    p1=Person('jvbdi')
    print(p1)

三、对象

类中的内容：属性和方法

• 属性：(保存值的)
  • 对象的属性：不同的对象对应的值可能不一样，这样的属性是对象属性。属于对象
  • 类中的对象属性是声明在init方法中，并且声明格式是self.属性名=初值
  • 对象属性的使用：对象.属性名
• 类的字段：属于类的，所有的对象对应的值是一样的

方法：（保存功能）

• 对象方法
• 类方法
• 静态方法

1，声明属性 ：

1.1直接在init函数内声明属性

self.属性名=初值

class Student:
    def __init__(self):
        # 声明对象属性name,age,id
        self.name='樊振霖'
        self.age=''
        self.id='001'

1.2，声明属性(通过声明对象时传参) ：

self.属性名=形参

class Dog:

    # 创建Dog的对象时，必须传类型和颜色
    def __init__(self,type1,color1):
        self.type=type1
        self.color=color1

#创建对象时传参
dog1=Dog('土狗','黄色')

1.3，声明属性(通过声明对象时传参,对形参赋默认值) ：

self.属性名=形参

class Computer:
    # 创建对象时，可以让对象属性使用默认值，也可以使用自己传的值
    def __init__(self,color='白色',memery=1000):
        self.color=color
        self.memery=memery

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

class Rectangle:
    def __init__(self,length=30,wide=20):
        self.length=length
        self.wide=wide

2,对象属性的增删改查

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

class Person:
    def __init__(self):
        self.name='张三'
        self.age=18
        self.height=180


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

2.1.查（获取属性的值）

• 方法一：对象名.属性名
• 方法二：def getattr(object(对象), name（属性名）, default=None)
• 方法三:对象.getattribute(属性名)

    print(p1.name)

    print(getattr(p1,'age'))
    # print(getattr(p1, 'age2'))  #属性不存在会报错
    print(getattr(p1, 'age2',0))  #属性不存在可以通过设置默认值，让程序不崩溃，并且返回默认值

    height=p1.__getattribute__('height')
    print(height)

2.2,改（属性存在,修改属性的值）

• 方法一：对象名.属性=新值
• 方法二：def setattr(object(对象), name（属性名）, 新值)
• 方法三:对象.setattr(属性名, 新值)

    p1.name='李四'
    setattr(p1,'age',20)
    p1.__setattr__('height', 175)
    print(p1.name,p1.age,p1.height)

2.3,增加（属性不存在添加属性）

添加属性只针对对象

• 方法一：对象名.属性=新值
• 方法二：def setattr(object(对象), name（属性名）, 新值)
• 方法三:对象.setattr(属性名, 新值)

    p1.sex='男'
    setattr(p1,'weight',70)
    print(p1.sex,p1.weight)
    p1.__setattr__('color','green')
    print(p1.color)

2.4，删（删除对象属性）

• 方法一：del 对象.属性
• 方法二：delattr(object(对象), name（属性名）)
• 方法三:对象.delattr(属性名)

    del p1.color
    delattr(p1,'sex')
    p1.__delattr__('weight')

3、对象方法：

什么方法是对象方法：直接声明在类中的函数默认是对象方法，有一个默认参数为self
对象方法要通过对象来调用：对象.对象方法（）
对象方法中默认参数self：不需要传参。因为在调用这个方法时候，系统会自动将当前对象传给self，那个对象调用的方法，self就指向谁

class Circle:
    def __init__(self,radius):
        self.radius=radius

3.1声明一个对象方法area

    # 在这儿，self就是调用area方法的对象。对象能做的事，self都能做
    def area(self):
        print(id(self))
        print(self.radius)
        return self.radius**2*math.pi

练习：写一个矩形类，有属性，长和宽；功能，求周长和面积

class Rectangle:
    def __init__(self,length,width):
        self.length=length
        self.width = width

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

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

写一个班级类，班级里有多个学生的成绩,班级名；功能可以获取班级成绩的最高分

class Class:
    def __init__(self,class_name):
        self.class_name=class_name
        self.grade=[]

    def get_max(self):
        if not self.grade:
            return None
        self.grade.sort()
        print(self.grade[-1])
        return max(self.grade)
    # max(序列)---->获取序列中最大值
    # min(序列)---->获取序列中最小值

四、类

1，类的字段

类的属性叫类的字段

• 什么是类的字段
  类的字段就是声明在类的里面，方法的外面的变量
• 什么样的属性声明成类的字段
  属于类的，对于这个类的所有的对象来说其值是共有的
• 怎么使用
  通过类来使用：类.字段

class Person:
    #类的字段
    number=90

# 写一个类，用一个属性来保存类的对象的个数
class Kind:
    count=0
    def __init__(self):
        Kind.count+=1
print(Kind.count)
kind1=Kind()
kind2=Kind()
print(Kind.count)
# ==================================

# 通过类来获取类的字段的值
print(Person.number)
# 通过类来修改类的字段的值
Person.number=70
print(Person.number)

2,类的方法

2.1，对象方法（实例方法）

声明的形式：直接声明在类中
特点：自带一个不需要主动传参的默认参数self，谁来调用指向谁
调用：通过对象来调用

2.2，类方法

声明的形式：声明方法前需要使用@classmethod说明
特点：自带一个不需要主动传参的默认参数cls，谁来调用指向谁.始终指向当前类
调用：通过类来调用 类.类方法()

2.3，静态方法

声明的形式：声明方法前需要使用@staticmethod说明
特点：没有默认参数
调用：通过类来调用 类.类方法()

class Class1:
    number=600
    def object_func(self):
        print('对象方法')

    # 声明类方法
    @classmethod
    def class_func(cls):
        # 通过cls去创建对象
        tc=cls()
        tc.object_func()
        print(cls.number)
        print('这是类方法')

    # 声明一个静态方法
    @staticmethod
    def static_method():
        print('这是静态方法')


c1=Class1()
c1.object_func()
Class1.class_func()
Class1.static_method()

4,遇到问题怎么选择使用哪种方法

• 大前提：只要实现方法的功能需要用到对象的属性，我们就是用对象方法，否则就使用静态方法或类方法
• 不使用对象方法的前提下，如果实现功能需要用到类的字段就使用类方法
• 实现功能既不需要对象的属性，又不需要类的字段就使用静态方法
  注意：静态方法和类方法划分不用太严格，静态方法能做的类方法能做，反之亦然

class Person:
    number=61
    @classmethod
    def show_number(cls):
        print('人类的数量是%d'%(cls.number))

    @staticmethod
    def show_number2():
        print('人类的数量是%d'%(Person.number))
Person.show_number()
print('==========')
Person.show_number2()