1.类

a.理论上的定义

定义：对拥有相同功能和相同属性的对象的集合
对象：类的实例
封装效果：一个类中可以对多个功能进行封装（多个函数）

b.编程思想

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

c.类的声明格式

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

class PersonMan():
    def eat(self):
        print('吃饭')

 txf1 = PersonMan()  
 txf1.eat()
txf2 =  PersonMan()
'''
1.创建PersonMan类的对象，并且将对象的地址存到txf1中
2.只有调用构造方法，才会产生新的对象
'''
'''
class:关键字
类名:标识符，不是关键字.驼峰式命名（第一个单子首字母小写，其他单词首字母大写.）python首字母大写
(父类列表):这个部分可以省.可以多继承。
类的说明：说明文档。
类的内容：包括类属性和方法
'''

d.构造方法,init方法

1.构造方法：系统自动创建的，方法名和类名一样，功能是用来创建对象。
2.__init__:用来做初始化和添加对象属性的
当我们通过构造方法去创建对象的时候，系统会自动调用init方法去初始化类的属性。
创建对象的过程：调用构造方法在内存中开辟空间创建一个对象，然后用新建的这个对象去调用init方法来初始化对象的属性。最后才将对象返回。

class Person(object):
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex

e.对象属性和对象方法

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

class Student(object):
    def __init__(self,name,age = '男'):
        self.name = name
        self.age  = age

stu1 = Student('txf',12)
print(stu1.name)
stu1.name = 'xxq'
print(stu1.name)
'''
txf
xxq
'''
创建student对象是必须穿name,age参数数
name,age对象属性


b.类的字段(类的属性):属于类的，所有的对象对应的值是一样的。

2.方法
a.对象方法：需要通过对象来调用。直接写在类中的方法，自带一个self参数。
b.类方法
c.静态方法

f.对象属性的增删改查
python是动态语言，python中类的对象的属性可以增删的操作

'''
class Rectangle(object):
    def __init__(self,width,height):
        self.height = height
        self.width = width

if __name__ == '__main__':
    R1 = Rectangle(100,200)
    #1.1.查(1),当属性名不存在时候，会报错
    print(R1.width)
    #1.2.查(2),当属性名不存在时候，会返回O(可以自己设置返回值，如果没有默认值会报错)
    print(getattr(R1,'height',0))
    #1.3.查(3),不存在会报错。
    print(R1.__getattribute__('width'))

    #2.1,改(1)
    R1.width = 11
    print(R1.width)
    #2.2,改(2)
    setattr(R1,'width',12)
    print(R1.width)
    #2.3,改(3) 跟上面的类似
    R1.__setattr__('width',13)
    print(R1.width)

    #3,增(添加属性)(属性名不存在的时候就是添加),只能给对象添加。
    #3.1,增(1)
    R1.weight = 11
    print(R1.weight)
    #3.2,增(2)
    setattr(R1, 'weight', 12)
    print(R1.weight)
    #3.3,增(3)
    R1.__setattr__('weight', 13)
    print(R1.weight)

    #4.删(删除对象属性) 只删除指定的对象
    #4.1.del 对象.属性
    del R1.weight
    #print(R1.weight)
    #4.2
    delattr(R1,'weight')
    #4.3
    R1.__delattr__('weight')
'''

g.对象的方法（声明在类里面，有一个默认参数self）
调用：对象.对象方法().
对象方法中默认参数self,不需要传参。因为在调用这个方法的时候系统会将当着对象传给self,那个对象调用的方法，self就指向谁

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

    def circle_area(self):
        return math.pi * self.radius**2
 C1 = Circle(4)
 print(C1.circle_area())
'''
50.26548245743669
'''

h.类的字段（类的属性）

1.类的字段就是声明在类的里面,方法的外面的变量
2.属于类的，对于这个类的所有对象，这个属性是相同的，共有的。
3.通过类来使用：类.字段(可以修改.对象不能修改字段的值只能读，只有类才行)
class Person(object):
    number = 10

p1 = Person()
print(p1.number)
print(Person.number)

i.类的方法
1.类方法
a.声明的形式：声明前使用@classmethod说明
b.特点:自带参数cls(和self类似,谁调用指向谁),始终指向当前类。cls相当于类
c.调用:通过类来调用-----> 类.类方法()

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

class Person_Txf(object):
    def fun1(self):
        print('对象方法')

    @classmethod
    def class_fun(cls):
        print('类的方法')

    @staticmethod
    def static_test():
        print('静态方法')

t1 = Person_Txf()
t1.fun1()
Person_Txf.class_fun()
Person_Txf.static_test()
'''
对象方法
类的方法
静态方法
'''

j.方法的选择

'''
1.只要实现方法的功能需要用到对象的属性，我们就是用对象方法，否则就静态方法和类方法。（大致的选择）
2.不适用对象方法的前提下,如果实现功能需要用到类的字段，就是用类的方法，否则静态方法。
3.实现功能即不需要对象的属性，也不需要类的字段就使用静态方法。

注意：静态方法和类方法划分没那么严格，静态方法能做的类方法也能做，反之亦然。
原因：
'''

作业

1.声明个电脑类: 属性:品牌,颜 ,内存 方法:打游戏,写代码，看视频
a.创建电脑类的对象，然后通过对象点的 式获取、修改、添加和删除它的属性 b.通过attr相关 法去获取、修改、添加和删除它的属性

class Computer(object):
    def __init__(self,brand,face,memory):
        self.brand = brand  #品牌
        self.face = face #颜值
        self.memory = memory #内存

    def play_game(self):
        print('打游戏')

    def write_code(self):
        print('写代码')

    def see_move(self):
        print('看视频')


if __name__ == '__main__':
    comper = Computer('华硕','好看','4GB')
    comper.play_game()
    comper.see_move()
    comper.write_code()
    #获取
    print(comper.brand)
    print(getattr(comper,'brand'))
    print(comper.__getattribute__('brand'))
    #修改
    comper.brand = '联想'
    print(comper.brand)
    setattr(comper, 'brand', '戴尔')
    print(comper.brand)
    comper.__setattr__('brand', '苹果')
    print(comper.brand)
    #添加
    comper.size = '15.6村'
    setattr(comper,'key','98键')
    comper.__setattr__('color','red')
    print(comper.size,comper.key,comper.color)
    #删除
    del comper.size
    delattr(comper,'key')
    comper.__delattr__('color')
'''
打游戏
看视频
写代码
华硕
华硕
华硕
联想
戴尔
苹果
15.6村 98键 red

'''

2.声明 个 的类和狗的类:
狗的属性:名字、颜 ， 龄 狗的方法:叫唤
人的属性:名字、 龄、狗 人的方法:遛狗
a.创建的对象小明，让他拥有 1条狗，然后让 小明去遛

class Dog(object):
    def __init__(self,name,colore,age):
        self.name = name
        self.color = colore
        self.age = age

    def call(self):
        print('狗叫唤')

class Person(object):
    def __init__(self,name,age,dog):
        self.name = name
        self.age = age
        self.dog = dog

    def take_dog(self):
        print('%d岁的%s带着叫%s的%s色的%d岁的狗去遛遛' % (self.age,self.name,self.dog.name,self.dog.color,self.dog.age))


if __name__ == '__main__':
    dog = Dog('大黄','red',2)
    dog.call()
    person = Person('小明',23,dog)
    person.take_dog()
'''
狗叫唤
23岁的小明带着叫大黄的red色的2岁的狗去遛遛
'''

3.声明 个矩形类:
属性: 、宽 法:计算周长和面积
a.创建 同的矩形，并且打印其周长和面积

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

    def area(self):
        print('面积是%d' % (self.width * self.height))

    def perimeter(self):
        print('周长是%d' % (2 * (self.width+self.height)))

c1 = Rectangle(10,20)
c1.area()
c1.perimeter()

c2 = Rectangle(20,30)
c2.area()
c2.perimeter()
'''
面积是200
周长是60
面积是600
周长是100
'''

4.创建个学生类:
属性:姓名， 龄，学号 方法:答到，展示学 信息
创建个班级类: 属性:学生，班级名 方法:添加学生，删除学生 ，点名

class Student(object):
    def __init__(self,name,age,id):
        self.name = name
        self.age = age
        self.id = id

    def amount_to(self):
        print('答到')

    def select_info(self):
        print('姓名：%s 年纪：%d 学号：%d' % (self.name,self.age,self.id))

class Class_student(object):
    student_info = {}
    def __init__(self,student,class_name):
        self.student = student
        self.class_name = class_name

    def add_student(self):
        self.student_info[self.student.id] = [self.student.name,self.student.age]
        print('添加成功')

    def del_student(self):
        self.student_info.pop(self.student.id)
        print('删除成功')

    def sign_in(self):
        if self.student.id in self.student_info:
            print("%s已经到了" % self.student.name)
        else:
            print('%s还没到' % self.student.name)

if __name__ == '__main__':
    stu1 = Student('txf',12,1)
    stu1.amount_to()
    stu1.select_info()

    class_stu = Class_student(stu1,'python1806')
    class_stu.add_student()
    class_stu.sign_in()  #用签到验证是否添加
    class_stu.del_student()
    class_stu.sign_in()  #用签到验证是否删除
'''
答到
姓名：txf 年纪：12 学号：1
添加成功
txf已经到了
删除成功
txf还没到
'''

5.写 个类，封装所有和数学运算相关的功能(包含常 功能和常值， 如:pi,e等)

class Math(object):
    pi = 3.14
    e = 10
    def rectangle_area(self,width,height):
        return width*height

    def circle_area(self,radius):
        return self.pi * radius**2

    def power(self,x):
        return self.e**x

    def add(self,x,y):
        return x+y

if __name__ == '__main__':
    m = Math()
    print(m.pi)
    print('矩形面积是：%d' % m.rectangle_area(10,20))
    print('圆的面积：%d' % (m.circle_area(3)))
    print('10的%d次方是:%d' % (3,m.power(3)))
    print('3+4等于%d' % m.add(3,4))
'''
3.14
矩形面积是：200
圆的面积：28
10的3次方是:1000
3+4等于7
'''