day12

01 生成器

生成器: 可以看成是一个可以储存多个数据的容器.
需要一个 产生一个 每次只能去拿前面的哪一个
拿走了就没有啦,只生产一次
和列表比较: 列表中的数据,数据必须始终存在,而生成器:生成器 储存的是一个算法

if __name__ == "__main__":
    x = (i for i in range(10))
    # x是一个生成器,用来产生数据
    print(x)
    print(x.__next__())    # 获取生成器的值 方法

02 认识面向对象

什么是类: 对拥有相同属性的方法的对象的封装
什么是对象: 对象就是类的实例

面向对象的编程
1.面向过程 一步一步的写代码实现功能--->工具:逻辑和算法
2.函数式编程面对问题考虑有没有某种函数---> gongju :函数 m
3.面向对象编程 考虑有没有相应的对象来解决问题--->类和对象

03 类的声明

类的声明
class 类名(父类):
    属性
    方法

class : 关键字 声明类的关键字
类名 : 标识符 1.类名的首字母大写,驼峰式命名
父类 :类要继承其他的类,需要写括号,括号里面是父类的名字
属性 : 重点哇 相同的属性 对象属性和类的字段---保存字段
方法 : 方法实质就是申明在类中的函数---实现类的功能

生命对象:
    对象名 = 类名()
 即 通过类的构造方法去创造对象

• 对象方法都有一个默认值 在调用时 不需要传参 系统自动传参

class Person:
    """声明类person"""
    def eat(self):
        """声明对象方法 需要使用对象来调用"""
        print("zaichifan"

if __name__ == "__main__":
    p1 = Person()
    print(p1)
    p1.eat()

04

对象属性的声明
class 类名:
    def __init__(self):
        self.属性名 = 初始值
        self.属性名1 = 初始值1

class Person:
# init方法是系统自带的 不能直接调用
# init方法的作用是对对象的属性初始化
# 通过构造方法创建对象的时候,一定要保证 init方法中出啦self以外 其他每个参>数都有值

    def __init__(self,name1):
        print("===")
        print(name1)

    # 在init方法中声明对象的属性
    self.name = name1    # name 就是person这个类的对象属性.类的对象的属性,需要通过对象使用

if __name__ == "__main__":
    # 构造方法的参数中,实质是传给init方法的参数的
    p1 =Person("hehehe")
    print(p1.name)

05 slots魔法

约束类中的对象的属性

class Person:
    __slots__ = ("name","age","id","sex")
    def __init__(self,name, age):
        self.name = name
        self.age = age

if __name__ == "__main__":
    p1 = Person("wang", 20)
    # p1.name = "wangwang"

06 对象的增删改查

class Dog:
    def __init__(self,age=0,color="yellow"):
        self.age = age
        self.color = color

if __name__ == "__main__":
    Dog1 = Dog(3,"white")
    print(Dog1.age,Dog1.color)

    # 修改属性的值
    # 对象.属性 = 新值
    Dog1.age = 4
    print(Dog1.age)

    # 增加
    # 属性添加给对象,不是类的
    Dog1.name = "kiki"
    print(Dog1.name)

    # 删除对象属性   删除的是具体某个对象的属性,不会影响其他对象的值
    # del 对象.属性
    del Dog1.age

    #查
    # print(Dog1.__getattribute__("age"))
    print(getattr(Dog1,"age",None))    # 如果设置的deflult不存在,那么当属性不存在的时候不会报错

    # 修改
    Dog1.__setattr__("color", "black")
    setattr(Dog1,"color","blue")
    print(Dog1.color)

    # 声明一个学生类 拥有的属性:姓名,性别,年龄.方法:学习
    # 声明学生类的对象,声明的时候就给姓名.性别.年龄
    # 通过三种方式分别获取姓名,性别和年龄
    # 添加一个属性 电话'
    # 修改学生年龄
    # 删除学生性别
    class Student():
        def __init__(self,name,six,age,):
            self.name = name
            self.six = six
            self.age = age
        def study(self):
            return print("%s在学习" % self.name)

    stu1 = Student("www","man",18)
    print(stu1.name,stu1.six,stu1.age)
    print(stu1.__getattribute__("name"))

    stu1.tel = "123456"
    stu1.study()

07 类中的方法

属性: 对象的属性(属性) 类的属性
对象的属性: 属于对象,不同对象对应的值不同
类的字段 : 声明在类的里面,函数外面

方法: 对象的方法 类方法 静态方法
对象方法: 再带一个self参数,一般要通过对想去调用
类方法: 类使用的方法 1.@classmethod 2.自带参数 3.
静态方法: 1.@staticmethod 2.通过类来调用

``
class Myperson:
numbeer = 0 # 类的字段

def __init__(self, name="qqq", age=18):
    self.name = name
    self.age = age  # name和age是对象属性

def eat(self, food):  # 是对象方法
    print("%szaichi%s" % self.name, food)

@classmethod  # 类方法
def hurt_earth(cls):
    print("人类破坏环境")

@staticmethod  # 静态方法
def protect__earth():
    print("人类保护地球")

>怎么选择使用对象发放,类方法,静态方法?
>if如果实现函数的功能要使用对象的属性,就声明成对象的方法;
 >else如果实现函数的功能需要使用类的字段或者调用类的方法,就声明成类方法
> else 如果实现函数功能就不需要函数的属性,也不需要类的字段,就声明成静态方法

if name == "main":
print(Myperson.numbeer) # 类的属性
pi = Myperson()

练习 写一个班级类: 班级名字 学生 功能添加学生,查找学生

   # 写一个类,封装和所有数学运算相关的功能
class Student:
    def __init__(self,name="",age=0):
        self.name = name
        self.age = age

    def __str__(self):
        return print("name:%s age:%d" % (self.name,self.age))
class Class:
    def __init__(self,name="",students = []):
        self.name  = name
        self.students = students
    def add_student(self):
        name = input("name:")
        age = input("age:")

        stu = Student(name,int(age))
        self.students.append(stu)

cls1 = Class("py1805",[])
cls1.add_student()
print(cls1.students[0])