类和对象

一.类和对象

1.理论定义:类就是拥有相同功能和相同属性的对象的集合(类是抽象的)
对象:类的实例(对象是具体的)
2.生活角度:如果说电脑是一个类，我桌上的这台电脑就是一个对象
如果说车是一个类，具体的一辆车才是它的对象
3.编程思想
面向过程编程：以算法为工具
函数式编程：以函数为工具
面向对象编程：以类和对象为工具（面向生活）

二.类的声明

类是对拥有相同功能(方法)和相同属性的封装,一个类可以对多个功能进行封装.

类的声明格式
class 类名(父类列表):
类的说明文档
类的内容

类中的方法就是声明在类的函数,分为:对象方法,类方法,静态方法

创建对象 构造方法:类名()-->创建类对应的对象
创建类的时候，系统会默认给我们创建这个类对应的构造方法

# 创建一个类
class Person:
    """人类"""

    def eat(self):
        print('人吃饭')
# 1.创建对象
    p1 = Person()    # 创建Person类的对象，并且将对象的地址存到p1中

# 一个类可以有多个对象
    p2 = Person()
    # 只有在调用构造方法的时候才会产生新的对象
    
# 2.调用对象方法
    # 通过对象调用对象方法，默认参数self不需要传参。系统会自动传！
    p1.eat()

三.构造方法和init方法

构造方法:系统自动创建,方法名和类名一样,用来创建对象的
init:init方法的功能是用来做初始化和添加对象属性的
当我们通过构造方法去创建对象的时候,系统会自动调用init方法去初始化类的属性(不用主动调用init方法)

创建对象的过程:调用构造方法在内存中开辟空间创建对象,然后用新建的对象去调用init方法来初始化对象的属性,最后才将对象返回

class Person:
    # init方法可以添加参数
    def __init__(self, name, age=18):
        print(name, age)
        print('人类的init方法')
# 如果类的init方法有参数，通过给构造方法传参类init方法传参
p1 = Person('小明')
p2 = Person('小红', 20)
p3 = Person(age=21, name='小花')
#小明 18 小红 20  小花 21

四.对象属性

类中的内容包括:属性和方法
属性是保存值的
属性分为对象的属性和类的属性,类的属性称为类的字段.属于类的,所有的对象对应的值是一样的.

对象的属性根据对象的不同,对应的值不同.对象属性是声明在init方法中的,声明格式为:self.属性名=初值,对象属性的使用:对象.属性名

#(1)没有参数,必须固定
class Student:
    """学生类"""
    def __init__(self):
        #声明对象属性name,age,id
        self.name = '张三'
        self.age = 22
        self.id = '001'
#stu1就是Student类的对象
stu1=Student()
#通过对象去使用对象的属性
print(stu1.name,stu1.age,stu1.id)
#通过对象去修改对象的属性
stu1.name = '小雨'
print(stu1.name)

#(2)有参数
class Dog:
    """狗类"""
    #创建Dog的对象时,必须传类型和颜色
    def __init__(self,type1,color1):
        self.type = type1
        self.color = color1

dog1 = Dog('土狗','黄色')
print(dog1.type,dog1.color)

dog2 = Dog('斗狗','黑色')
print(dog2.type,dog2.color)

#(3)有参数,默认值,创建对象时,可以让属性使用默认值,也可以使用自己传的值
class Computer:
    """电脑类"""
    def __init__(self,color='白色',memory=0):
        self.color=color
        self.memory=memory

comp1 = Computer()
print(comp1.color,comp1.memory)
comp2 = Computer('黑色',512)
print(comp2.color,comp2.memory)

五.对象属性的增删改查

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

class Person:
  def __init__(self,name1='张三'):
    self.name=name1
    self.age=18
    self.height=160
p1 = Person()
p2 = Person()

1.查(获取属性的值)

方法一: 对象.属性

print(p1.name)
# print(p1.name2)   # 属性不存在会报错

方法二: def getattr(对象, 属性名, 默认值)

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

方法三：对象.getattribute(属性名)

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

2.改(修改属性的值,属性值存在)

方法一：对象.属性 = 新值

p1.name='旺旺'

方法二: def setattr(对象,属性名, 新值)

setattr(p1, 'age', 20)
print(p1.age)

方法三: 对象.setattr(属性名, 新值)

p1.__setattr__('height', 170)
print(p1.height)

3.增(添加属性 -- 属性不存在,方法跟修改属性值相同)

** 注意：添加属性只能给某一个对象添加对应的属性**
方法一：对象.属性 = 值

p1.sex = '女'
print(p1.sex)

方法二: def setattr(对象,属性名, 值)

setattr(p1, 'weight', 45)
print(p1.weight)

方法三: 对象.setattr(属性名, 值)

p1.__setattr__('color', '绿色')
print(p1.color)

4.删(删除对象属性)

注意:删除只针对指定的对象
方法一:del 对象.属性

del p1.name

方法二:def delattr(对象,属性名)

delattr(p1,'age')

方法三:对象.delattr(属性名)

p1.__delattr__('height')

print(p2.name,p2.age)

六.对象方法

1.对象方法
直接声明在类的函数默认就是对象方法,有一个默认参数self
调用:对象.对象方法()
对象方法中默认参数self,不需要传参。因为在调用这个方法的时候系统会自动将当前对象传给self。
哪个对象调用的方法，self就指向谁

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

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

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

    def perimeter(self):
        return (self.length + self.width) * 2

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

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

    def highest_score(self):
        if not self.scores:#判断是否为空
            return 0
        # max(序列) ---> 获取序列中元素的最大值
        # min(序列) ---> 获取序列中元素的最小值
        return max(self.scores)

class1 = Class('python1806')
class1.scores = [23, 45, 77, 54, 89, 90, 34]
print(class1.highest_score())

七.类的字段

类的属性叫类的字段
类的字段就是声明在类里面,方法外面的变量
属于类的，对于这个类的所有的对象来说其值是共有的,这样的属性声明成类的字段
使用:类.字段

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

class Ball:
  count = 0
  def __init__(self):
    Ball.count += 1
# 每次创建球的对象都会调用init方法，所以init方法调用的次数就是Ball创建的对象的个数

class Person:
    # 这个number就是类的字段
    number = 61
# 通过类获取类的字段的值
    print(Person.number)

八.类的方法

类的方法分为三类:对象方法,类方法和静态方法
1.对象方法(实例方法)
声明的形式:直接声明在类里
特点:自带一个不需要主动传参的默认参数self,谁来调用指向谁
调用:通过对象来调用

class Class1:
    # 类字段
    number = 100

    # 声明一个对象方法
    def object_func(self):
        print('对象方法')
c1 = Class1()
# 调用对象方法
c1.object_func()
#对象方法

2.类方法
声明的形式:声明方法前需使用@classmethod说明
特点:自带一个默认参数cls,这个参数在调用的时候不需要传值,系统自动传给他.谁调用就指向谁，始终指向当前类
调用:通过类来调用--->类.类方法()

class Class1:
    # 类字段
    number = 100
# 声明一个类方法
    @classmethod
    def class_func(cls):
        # 通过cls去使用类的字段
        print('cls:', cls.number)
        # 通过cls去创建对象
        tc = cls()
        tc.object_func()
        print('这是一个类方法')
# 调用类方法
Class1.class_func()
#cls: 100
#对象方法
#这是一个类方法

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

class Class1:
    # 类字段
    number = 100
    @staticmethod
    def static_func():
      print('这是一个静态方法')
# 调用静态方法
Class1.static_func()
#这是一个静态方法

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