总结

一.类的声明

1.类的声明格式:

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

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

3.类中的方法
方法:就是声明在类的函数
a.对象方法:通过对象调用,对象.函数名()
直接写在类中的方法,自带一个self参数
b.类方法
c.静态方法

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

class Person:
    # 人类
    def eat(self):
        print('人吃饭')

if __name__ == '__main__':
    p1 = Person()   # 创建Person类的对象,并且将对象地址存到p1中
    # 一个类可以有多个对象
    p2 = Person()
    # 只有在调用构造方法的时候才会产生新的对象
    p3 = p2
    print(id(p1), id(p2))
    # 2.调用对象方法
    # 通过对象调用对象方法,默认参数self不需要传参,系统会自动传!!!
    p1.eat()

二.构造方法和init方法

1.构造方法:系统自动创建的,方法名和类名一样
2.init:用来做初始化的
当我们通过构造方法去创建对象的时候,系统会自动调用init方法

class Dog:
    def __init__(self):
        print('init方法')

class Person:
    # init方法可以添加参数
    def __init__(self, name, age=18):
        print(name, age)
        print('人类的init方法')

if __name__ == '__main__':
    # 创建对象的过程:调用构造方法在内存中开辟空间创建一个对象,然后用新建的这个对象去调用init方法,
    #               来初始化对象的属性,最后才将对象返回
    d1 = Dog()
    d2 = Dog()

    # 如果类的init方法有参数,通过给构造方法传参类init方法传参
    p1 = Person('xx')
    p2 = Person('bb', 11)
    p3 = Person(age=13, name='hh')

三.对象属性

类中的内容:属性和方法
1.属性:(保存值的)
a.对象的属性:不同的对象,对应的值可能不一样,这样的属性是对象属性
类中的对象属性声明在init方法中的,并且声明的格式: self.属性名=初值
对象属性的使用: 对象.属性名

b.类的字段:属于类的,所有的对象对应的值是一样的
2.方法:(保存功能的)
a.对象方法
b.类方法
c.静态方法

class Student:
    """学生类"""
    def __init__(self):
        # 声明对象属性name,age,id
        self.name = 'papi'
        self.age = 22
        self.id = '001'

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

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

# 写一个矩形类,拥有属性长和宽
class Rectangle:
    def __init__(self, length, width):
        self.length = length
        self.width = width



if __name__ == '__main__':
    # s1就是Student类的对象
    s1 = Student()
    print(s1.name, s1.age, s1.id)
    # 通过对象去修改对象的属性
    s1.name = '略略略'
    print(s1.name)

    d1 = Dog('泰迪', '白色')
    print(d1.type, d1.color)

    c1 = Computer()
    print(c1.color, c1.memory)
    c2 = Computer('黄色', 2)
    print(c2.memory, c2.color)

    r1 = Rectangle(1, 2)
    print(r1.length, r1.width)

四.对象属性的增删改查

class Person:
    """人类"""
    def __init__(self):
        self.name = '嘻嘻'
        self.age  = 11
        self.height = 170

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

1.查(获取属性的值)
方法1:对象.属性名
方法2:def getattr(object, name, default=None)
方法3:对象.getattribute(属性名)

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

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

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

2.改(修改属性的值,属性值存在)
方法1:对象.属性 = 新值
方法2:def setattr(对象,属性名,新值)
方法3:对象.setattr(属性名,新值)

p1.name = '小小'

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

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

3.增(添加属性,属性名不存在时)
方法1:对象.属性 = 新值
方法2:def setattr(对象,属性名,新值)
方法3:对象.setattr(属性名,新值)

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

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

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

    # print(p2.sex) # 添加属性只影响一个对象

4.删(删除对象属性)
方法1:del 对象.属性
方法2:delattr(对象,属性名)
方法3:对象.delattr(属性名)

int(p1.name)

    delattr(p1, 'age')
    # print(p1.age)

    p1.__delattr__('height')
    # print(p1.height)
    print(p2.name, p2.age)

五.对象方法

a.什么样的方法是对象方法:直接声明在类的函数默认是对象方法,特点:有一个默认参数self
b.对象方法要通过对象来调用:对象.对象方法()
c.对象方法中默认参数self,不需要传参,因为在调用此方法时,系统会自动将当前对象传给self
哪个对象调用的方法,self就指向谁

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

    # 声明了一个对象方法area
    # 在这儿,self就是调用area方法的对象,对象能做的事情self都可以做
    def area(self):
        # print(id(self))
        # print(self.radius)
        # self.radius = 100
        # print('求圆的面积')
        return math.pi * (self.radius**2)

if __name__ == '__main__':
    # 创建一个半径为3的圆的对象
    c1 = Circle(3)
    print(id(c1))

    print('c1的面积', c1.area())
    print(c1.radius)
    c1.radius = 100

l###六.类的字段
a.类的字段就是声明在类的里面,方法的外面的变量
b.什么样的属性声明成类的字段:
属于类的,对于这个类的所有的对象来说其值是共有的
c.通过类来使用:类.字段

class Person:
    # 这个number就是类的字段
    number = 61

# 练习:写一个球类,用一个属性来保存这个类的创建的对象的个数
class Ball:
    count = 0
    def __init__(self):
        Ball.count += 1
b1 = Ball()
b2 = Ball()
b3 = Ball()
print(Ball.count)
if __name__ == '__main__':
    # 通过类获取类的字段的值
    print(Person.number)

    Person.number = 70
    print(Person.number)

七.类的方法

1.对象方法(实例方法)
2.类方法
声明的形式:声明方法前需要使用@classmethod说明
特点:自带一个默认数cls,这个参数调用时不需要传值,系统
调用:通过类来调用 -> 类.类方法()
3.静态方法
声明的形式:声明方法前需要使用@staticmethod说明
特点:没有默认的参数
调用:通过类来调用 -> 类.静态方法()
4.遇到问题怎么来选择使用哪种方法:
a.大前提:只要实现方法的功能需要用到对象的属性,我们就使用对象方法,否则就使用静态方法或者类方法
b.不使用对象方法的前提下,如果实现功能需要用到类的字段就使用类方法
c.实现功能既不需要对象的属性,也不需要类的字段就使用静态方法
注意:静态方法和类方法划分不用那么严格,静态方法能做的类方法也可以,反之亦然

class Class1:
    number = 100

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

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

    @staticmethod
    def static_func():
        print('这是一个静态方法')

c1 = Class1()
# 调用对象方法
c1.object_func()

print(Class1.number)
# 调用类方法
Class1.class_func()

# 调用静态方法
Class1.static_func()