01 迭代器和生成器

生成器：

a.

(1)可以看成一个可以西存储多个数据的容器。
(2)需要里面的数据的时候就生成一个，里面的数据只能从前往后一个一个的生成
(3)不能跳跃，也不能从后往前。生成的数据，不能再生成了

b.获取生成器里面的数据，需要使用next（）方法
c.只要函数生命中有yield关键字，函数就不在是一个单纯的函数，而变成一个生成器

和列表比较：列表存数据，数据必须是是实实在在存在的数据，一个数据会占一定的内存空间

生成器存数据，存的是数据的算法，没有数据去占内存空间

# 1,1,2,3,5,8,13,21

def xulie(n):
    pre_1 = 1
    pre_2 = 1
    for x in range(1, n+1):
        if x==1 or x ==2:
            current = 1
            # print(current)
            yield current
            continue
        current = pre_1 + pre_2
        pre_1, pre_2 = pre_2, current
        # print(current)
        yield current
xulie = xulie(10)
print(xulie.__next__())
print(xulie.__next__())
print(xulie.__next__())

if __name__ == '__main__':

    x = (i for i in range(10))
    # x就是一个生成器，用来产生数据
    print(x)

    print(x.__next__())
    print(x.__next__())

    list1 = list(i for i in range(10))
    print(list1)

02 认识面向对象

• 1.什么是类：对拥有相同属性和功能的对象的封装
  类是抽象的
  类中相同的属性的值是不能确定的

• 2.什么是对象：对象就是类的实例
  对象是具体的
  对象的属性是确定的

如果说人是一个类，那么余婷就是人的一个对象，老王也是人的一个对象
如果说电脑是一个类，我桌上的电脑就是一个对象
如果说杯子是一个类，我桌上的杯子就是一个对象

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

03类的声明

类的声明：
class 类名（父类）：
属性
方法
class： python中声明类的关键字
类名：标识符，类名的首字母要大写，驼峰式命名
（）：类要继承自其它的类，需要写括号，括号里面是父类的名字。可以省略
属性：对象属性和类的字段 --- 保存数据
方法：实质就是在类中的函数 --- 实现功能

#1. 声明类Person
class Person:
    """类的说明：人类"""

    # 声明两个对象方法，需要使用对象来调用
    """
    对象方法默认都有一个参数self，在调用方法的时候偶，这个参数不用传参（系统会自动给self传参）
    谁来调用这个方法，self就是谁
    """
    def eat(self):
        print('self:', self)
        print('在吃饭')

    def sleep(self):
        print('在睡觉')


"""
声明对象：
通过类的构造方法去创建对象（名字和类名同名的方法就是构造方法，自动生成的）
对象名 =类名（）

类的对象可以通过点语法使用类中声明的对象的方法和属性
对象.方法名()
对象.属性名
"""

if __name__ == '__main__':
    # 2.声明对象
    p1 = Person()
    print(p1)

    # 一个类可以有多个对象
    p2 = Person()
    print(p2)

    p1.eat()
    p2.eat()
    p1.sleep()
    p2.sleep()

04对象的属性

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

"""
class Person:
    """人类"""

    """
    init 方法是系统自带的一个方法，这个方法不能直接调用，而是通过类创建对象的时候系统会自动调用这个方法
    init方法的作用是对对象的属性进行初始化
    通过构造方法创建对象的时候，一定要保证，init方法中除了self以外，其他的每个参数都必须有值
    """
    def __init__(self, name1 = '', age1 = 18, sex = '女'):
        # 在这个地方声明对象的属性
        print('==========')
        print(name1)
        # 在init方法中声明对象的属性
        # name，age和sex就是这个Person这个类的对象属性。类的对象属性，需要通过对象来使用
        self.name = name1
        self.age = age1
        self.sex = '男'





if __name__ == '__main__':
    # 注意：构造方法中的参数，实质是传给init方法的参数
    p1 = Person('hcy', 18)
    print(p1.name, p1.age, p1.sex)

    p3 = Person()
    p4 = Person('王海飞')
    p5 = Person(sex='男')
    print(p5.name, p5.age, p5.sex)

05对象属性的增删改查

class Dog:
    """狗类"""
    def __init__(self, age = 0, color = 'white'):
        self.age = age
        self.color = color

class Student:
    def __init__(self, name='胡晨宇', sex='男', age='18'):
        self.name = name
        self.sex = sex
        self.age = age

    def study(self):
        print('%s学习' % self.name)


if __name__ == '__main__':

    # 1. 查（获取属性）
    """
    方法一： 对象.属性（如果属性不存在，会报错）
    方法二：对象.__getattribute__（属性名）和getattr（对象，属性名，默认值）
    """
    dog1 = Dog(age=3, color='red')
    print(dog1.age, dog1.color)

    print(dog1.__getattribute__('age'))
    print(getattr(dog1, 'age'))

    #如果设置了default的值，那么当属性不存在的时候不会报错，并且返回默认值
    print(getattr(dog1, 'abc', '无名氏'))
    # 2. 改（修改属性的值）
    """
    方法一：对象.属性 = 新值
    方法二：对象.__setattr__(属性名，新值)和setattr（对象，属性名，默认值）
    """
    dog1.age = 4
    print(dog1.age)

    dog1.__setattr__('color', 'black')
    print(dog1.color)

    setattr(dog1, 'color', 'blue')
    print(dog1.color)
    # 3.增加（增加对象属性）
    """
    对象.属性 = 值（属性不存在）
    注意：属性是添加给对象的，而不是类的
    """
    dog1.name ='大黄'
    print(dog1.name)

    dog1.__setattr__('type', '哈士奇')
    print(dog1.type)

    setattr(dog1, 'sex', '公')
    print(dog1.sex)

    # 4.删（删除对象属性）
    """
    方法一：del 对象.属性
    注意：删除属性也是删的具体某个对象的属性。不会影响到这个类的其他对象
    
    """
    # del dog1.age
    # print(dog1.age)

    dog1.__delattr__('age')
    # print(dog1.age)

    delattr(dog1, 'color')
    # print(dog1.color)


    # 练习：声明一个学生类，拥有属性：姓名，性别，年龄。方法：学习
    # 声明学生类的对象，声明的时候就给姓名，性别和年龄赋值
    # 通过三种方式分别获取姓名，性别和年龄，并且打印
    # 给学生添加一个对象
    # 修改学生的年龄
    # 删除学生的性别



    student1 = Student()
    print(student1.name, student1.sex, student1.age)

    print(student1.__getattribute__('name'))

    print(getattr(student1, 'sex'))

    student1.tel = '123456'
    print(student1.tel)
    student1.age = 22
    del student1.sex
    student1.study()

06 slots魔法

class Person:
    # __slots__的功能：就是约束类中的对象的属性
    __slots__ = ('name', 'age', 'sex')
    def __init__(self,name='',age=0):
        self.name = name
        self.age = age

    # 自定义对象的打印格式
    def __str__(self):
        return self.name + ','+str(self.age)

if __name__ == '__main__':
    p1 = Person('小王', 20)
    # p1.names = '老王'
    print(p1)

07类中的方法

属性：对象的属性（属性），类的属性（类的字段）
对象属性：属于对象的，不同对象对应的值可能不一样（对象属性，通过对象来使用）
类的字段：声明在类里面，函数外面。类的属性属于类（类的字段，通过类来使用）

方法：

对象的方法（方法），类方法，静态函数

对象方法：自带一个self参数，一般要通过对象去调用

类方法：

1.使用@classmethod修饰，自带一个cls参数
2.自带一个cls参数，并且这个参数不用传参，谁来调用这个方法，cls就指向谁
3.类方法要通过类调用

静态方法：

1.使用@staticmethod修饰
2.没有默认参数
3.静态方法要通过类来调用

怎么选择用对象方法，类方法，静态方法？

• if 如果实现函数的功能需要使用对象的属性，就声明成对象方法

• elif 如果实现函数的功能需要使用类的字段后者调用类的方法，就声明成类方法

• else 如果是函数功能既不需要对象的属性，也不需要类的字段，就声明称静态方法

补充： ctrl+r ---》 查找替换
       ctrl+f ---》 查找

class MyPerson:

    # number 是类的字段
    number = 61

    def __init__(self, name='', age=0):
        # name 和 age 是对象属性
        self.name = name
        self.age = age

    # eat方法是对象方法
    def eat(self, food):
        print('%s在吃%s' % (self.name, food))

    # hurt_earth就是一个类方法
    @classmethod
    def hurt_earth(cls):
        # cls只想的是调用这个方法的类，cls可以当成类来使用
        pt = cls('张三')  # 可以使用cls创建对象
        print(pt.name)
        print(cls.number)  # 可以通过cls使用类的字段
        print('人类破坏环境！！')

    # protect_earth 是一个静态方法
    @staticmethod
    def protect_earth():
        print('人类保护地球')


if __name__ == '__main__':
    # 1.类的字段要用类来使用
    print(MyPerson.number)

    # 2.对象的属性要通过对象来使用
    p1 = MyPerson('小明')
    print(p1.name, p1.age)

    # 3.对象的方法要通过对象调用
    p1.eat('面条')

    p2 = MyPerson('小红')
    p2.eat('火锅')

    # 4.类方法通过类来调用
    MyPerson.hurt_earth()

    # 5.静态方法通过类来调用
    MyPerson.protect_earth()


"""
练习：
写一个班级类，属性：班级名，学生；功能：添加学生，查找学生

写一个类，封装所有和数学运算相关的功能
"""



class Student:

    def __init__(self, name='', age=0):
        self.name = name
        self.age = age

    def __str__(self):
        return ('name:%s age:%d' % (self.name, self.age))

class Class:
    """学生类"""


    def __init__(self, name='', students=[]):
        self.class_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])