day14markdown总结

1.类和对象

理论上的定义（对象是具体的）：
类：就是对拥有相同功能和相同属性的对象的集合。
对象：类的实例
2.生活角度：
如果说人是一个类，个人就是一个对象，肖老师是另外一个对象，马云也是人这个类的对象
如果说电脑是一个类，我桌子上的这台电脑是就是对象。如果说车是一个类，具体的一辆车才是他的对象

3.编程思想：
面向过程编程：算法为工具
函数式编程：以函数为工具
面向对象编程：以类和对象为工具（面向生活）

2.类的声明

类：对拥有相同功能（方法）和相同属性（属性）的封装
封装效果：一个类中可以对多个功能进行分装
1.类的声明格式

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

2.说明格式：
class:关键字
类名：标识符，不能是关键字。驼峰式命名（第一个单词首字母小写，其他的单词首字母都大写）
（父类列表）：这个部分可以省略，冒号不能，这个是继承语法。
类的内容：包括类的方法和类的属性
3.类中的方法
方法：声明在类中的函数
a.对象方法：对象方法需要通过对象来调用，对象.函数名()
直接写在类中的方法，自带self参数
b.类方法：
c，静态方法：
4.创建对象：构造方法类名+()--->创建类名对应的对象
创建类的时候系统会默认给我们创建这个类对应的构造方法

class Person:
    def eat(self):
    print('吃饭')
    p1 = Person()
    p1.eat()

构造方法和init方法

1.构造方法：系统自动创建的，方法名和类名一样。功能是用来创建对象
2.init：init方法的功能是用来初始化和添加对象属性的
当我们通过构造方法去创建对象的时候，系统会自动调用init方法去初始化类的属性
init方法不能手动调用，只能是系统自己调用。

class Dog:
    def __init__(self):
        print('init方法')
class Person:
    def __init__(self,name):
        print(name)
        print('init')
        #创建对象的过程：调用构造方法在内存中开辟空间创建一个对象，然后用新建的这个对象去调用init方法，来初始化对象的属性
    # 最后将对象返回
    dog1 = Dog()
    dog2 = Dog()
    #如果类的init方法有参数，通过给构造方法传参类init方法传参。
    p1 = Person('zhaozhao')

4.对象属性和对象方法

类中的内容：属性和方法
1.属性(保存值的)：
a.对象的属性：不同的对象对应的值可能不一样，这样的属性是对象属性
类中的对象属性是声明在init方法中，并且声明的格式是：self.属性名 = 初值
对象属性的使用：对象.属性名
b.类的字段：属于类的，所有的对象对应的值是一样的
2.方法（保存功能的）：
c.对象方法
d.静态方法

class Student:
    """学生类"""
    def __init__(self):
        self.zhao_zhao = 'gay'
        self.name = '张三'
        self.age = 0
        self.id = '001'
class Dog:
    def __init__(self, type1, color1):
        self.type = type1
        self.color = color1
class Computer:
    def __init__(self, color='白色', memory=0):
        self.color = color
        self.memory = memory
if __name__ == '__main__':
    #stu1就是Student类的对象
    stu1 = Student()
    #通过对象去使用对象的属性
    print(stu1.zhao_zhao)
    #通过对象去修改对象的属性
    stu1.zhao_zhao = 'gaygay'
    print(stu1.zhao_zhao)
    dog1 = Dog('中华田园犬', '黄色')
    print(dog1.type, dog1.color)
    comp1 = Computer()
    print(comp1.color, comp1.memory)
    comp2 = Computer('黑色', 512)
    print(comp2.color, comp2.memory)

对象属性的增删改查

python是动态语言，python中类的队形属性可以进行增删改查

class Person:
    def __init__(self):
        self.name = '张三'
        self.age = 18
        self.height = 160
if __name__ == '__main__':
    p1 = Person()
    #1.查（获取属性的值）
    方法一：对象.属性名
    方法二：def getattr(object(对象), name（属性名）, default = None)
    方法三：对象.__getattribute__(属性名)
    print(p1.name)
    print(getattr(p1, 'age'))
    height = p1.__getattribute__('height')
    print(height)
    #2.改（修改属性的值）
    方法一：对象.属性 = 新值
    方法二：def setattr(对象, 属性名, 新值)
    方法三：对象.__setattr__(属性名，新值)
    p1.name = 'zhaohzao'
    setattr(p1, 'age', 20)
    p1.__setattr__('height', 186)
    print(p1.name, p1.age, p1.height)
    #3.增加（添加属性--- 属性不存在的时候）
    # 注意：添加属性只能给某一个对象添加对应的属性
    方法一：对象.属性 = 值
    方法二：def setattr(对象, 属性名, 值)
    方法三：对象.__setattr__(属性名，值)   
    p1.sex = '女'
    print(p1.sex)
    setattr(p1, 'weight', 45)
    print(p1.weight)    #添加属性只影响一个对象
    #4.删（删除对象属性）
    # 删除只针对某一个对象
    方法一：del 对象.属性
    方法二：def delattr(对象, 属性名):
    方法三：对象.__delattr__(属性名)
    del p1.name
    # print(p1.name)
    delattr(p1, 'age')
    # print('p1.age')
    p1.__delattr__('height')
    #print(p1.height)

6.对象方法

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

import math
class Circle:
    def __init__(self, radoius1):
        self.radius = radius1
        print(self.area())
    def area(self):
        return math.pi.self.radius**2
s1 = Circle(3)
s1.area()
print(s1.area())

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

class Ju:
    def __init__(self,long, width)
        self.long = long
        self.width = width
    def action():
        return self.long * width, (self.long+self.width) * 2
s1 = Ju(3, 3)
s1.action
print(s1.action())

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

class Student:
    def __init__(self,name,*score):
        self.name = 'name'
        self.score = score
    def max():
        max1 = max(self.score)
        return max1
        max1 = Student('python1806', 100, 98, 25, 68, 99)
        max1.max()
        print(max1.max())

类的字段

class Person:
    #这个number就是类的字段
    number = 10
    
#练习：写一个类，用一个属性来保存对象的个数

class Count1:
    count = 0
    #m每次创建的对象都会调用init方法，所以init方法调用的次数就是创建对象的个数
    def __init__(self, count):
        count+=1
if __name__ == '__main__':
    #通过类获取类的字段的值
    print(Person.number)

8.类的方法

类中的方法：

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

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

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

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()

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

class Person:
    # 类的字段，存储人类的数量
    number = 61

    @classmethod
    def show_numer(cls):
        print('人类的数量是:%d亿' % cls.number)

    @staticmethod
    def show_numer2():
        print('人类的数据是:%d亿！' % Person.number)
 Person.show_numer()
 Person.show_numer2()