part 1 迭代器和生成器

生成器：可以看出一个可以存储多个数据的容器
获取生成器里面的数据需要使用next()方法。
只要在函数声明中有yield关键字，函数就不再是一个单纯的函数，而是变成一个生成器。

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

和列表比较：列表存数据，数据必须是实实在在的数据，一个数据会占一定的内存空间。
生成器存数据，存的是产生数据的算法。没有数据去占内存空间。

def xu_lie(n):
    pre_1 =1
    pre_2 =1
    for x in range(n,n+1):
        if x == 1 or x == 2:
            current = 1
            continue
        current = pre_1 + pre_2
        pre_1, pre_2 = pre_2, current
        yield current
print(xu_lie(5))

if __name__ == '__main__':
    list1 = list(i for i in range(10))
    print(list1)
    x = (i for i in range(10))
    #x就是生成器，生产器的功能就是创建一个迭代器，用来产生数据的，需要里面数据的时候就生成一个
    #里面的数据只能从前往后依次生成，不能跳跃，也不能从后往前。生成后的数据，不能再生成。
    print(x)
    print(x.__next__())
    print(x.__next__())

part 2 面向对象和类

1、什么类：对拥有相同属性方法的对象的封装，类是抽象，相同属性值是不能确定的

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

3、面向过程编程：一步一步的写代码实现过程，逻辑和算法

4、函数式编程：面对问题有没有一个函数有没有一个函数有这样的功能。工具是函数

5、面向对象编程：面对问题，考虑有没有相应的对象来帮我解决这个问题。工具是类和对象

part 3

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

声明类Person

class Person:
    """类的说明：人类"""


    #声明两个对象方法，需要使用对象来调用
    def eat(self):
        print('人在吃饭')
    def Sleep(self):
        print("人在睡觉(～﹃～)~zZ")
"""
声明对象：
通过类的构造方法创建对象（名字和类名同门的方法就是构造方法。自动生成的）
对象名=类名（）
"""
if __name__ == '__main__':
    #声明对象
    p1 = Person()
    print(p1)
    p2 = Person()
    print(p2)

part 4 对象的属性

class Person:
    """人类"""
    """
    1.init方法是相系统自带的一个方法，这个放到不能直接调用，通过类创建对象的时候，系统会自动调用这个方法
    init方法的作用就是将对象的属性进行初始化
    2.通过构造方法创建对象的时候，一定要保证，init方法除了self之外，其他的每个参数都必须有值
    
    """
    def __init__(self, name1='', age1=0, sex = '女'):
        #在这个地方声明对象的属性
        print('====')
        print(name1)
        #在init 方法中声明对象的属性
        #name,age,sex就是Person这个类的对象属性，类的对象属性，需要通过对象来使用
        self.name = name1
        self.age = age1
        self.sex = '男'
if __name__ == '__main__':
    #注意：构造方法中的参数，实质是传给init方法参数的
    p1 = Person('luzhi',18)
    print(p1.name,p1.age,p1.sex)
    #通过不同方式创建对象
    #创建对象时候不给属性赋值
    p3 = Person()
    p4 = Person('张道清')
    p5 = Person(sex = '男')

part 5 对象的基础操作

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


if __name__ == '__main__':



    dog1 = Dog(3, 'white')
    #1.获取属性方法1、对象.属性(如果属性不存在，会报错）
    #方法2.对象.__getattribute__（属性名）和getattr(对象，属性名）
    print(dog1.age, dog1.color)
    print(dog1.__getattribute__('age'))
    #如果设置了default的值，当属性不存在的时候，不会报错，并且返回default的值。
    print(getattr(dog1, 'age', None))

    """2.改
    方法1.对象.属性 = 新值
    方法2.对象.__setattr__（属性名，新值）
    
    """
    dog1.age = 4
    print(dog1.age)
    dog1.__setattr__('color', 'block')
    setattr(dog1, 'color', 'yellow')

    print(dog1.color)
    #3.增加
    """对象.属性=值
    （值不存在）
    """
    dog1.name = "大黄"
    print(dog1.name)
    setattr(dog1, 'type','huskie')
    print(dog1.type)
    #4、删除
    """del 对象.属性
    方法2.dog.__delattr__('age')
    方法3.delattr(属性名，值）
    删除对象的属性也是删除某个对象的属性，不会影响这个类的其他对象"""
    del dog1.name
    #print(dog1.name)AttributeError: 'Dog' object has no attribute 'name'
    #dog.__delattr__('age')


    #练习，声明一个学生类，有姓名，年龄，性别。方法：学习
    #声明学生类的对象，声明的时候就给姓名。性别、年龄赋值。
    #三种方式获取姓名，性别，和年龄，打印
    #给学生对象添加一个属性，电话

    #修改学生的年龄
    #删除学生的性别


    class   Student:
        def __init__(self,name="",age=0,sex=''):
            self.name =name
            self.age =age
            self.sex =sex
        def study(self):
            print('%s学习' % self.name)

stu1 = Student('小明', 30, '男')
print(stu1.name)

part 6 slots魔法

class Person:
    __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('小王', 26)
    p1.name = '老张'
    p1.sex = '男'
    print(p1)

part 7

属性：对象的属性（属性）、类的属性（类的字段）
方法：对象方法（方法）、类方法、静态函数、
对象属性：属于对象的，不同的对象对应的值可能不一样（）
类的字段：声明在类里面，函数外面。类属性属于类（类的字段，通过类来使用）
对象方法：自带一个self参数，一般通过对象去调用
类方法：使用@classmethod修饰，自带一个cls参数，并且这个参数不用传参，谁来调用这个方法，cls就指向谁
类方法要用类来调用
静态函数：1.使用@staticmethod
        2.没有默认参数
        3.静态方法通过类来调用

怎么选择对象方法，类方法，静态方法？
if 如果你实现函数的功能，需要使用对象的属性，就声明成对象方法。否则就选择类方法和静态方法
elif 如果实现函数的功能需要使用类的字段或者调用类的方法，就声明成类方法。
else 如果实现函数功能既不需要对象的属性，也不需要类的字段就声明成静态方法。
补充：ctrl+r 查找替换
     ctrl+f 查

class Person:
    number = 0
    #number 是类字段



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


    def eat(self,food):#eat方法是对象方法
        print('%s在吃%s' % (self.name, food))
    @classmethod
    #damage_earth就是一个类方法
    def damage_earth(cls):#可以使用cls创建对象
        print('人类破坏环境！！')
        pt =cls('张三')
        print(cls.number)#可以使用cls使用类的字段
        print(pt)


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

if __name__ == '__main__':
    #类的字段要用类来使用
    print(Person.number)
    #对象属性
    p1 = Person('小明')
    print(p1.name)
    #对象方法用对象调用
    p1.eat('面条')
    #通过类调用
    Person.damage_earth()
    Person.protact_earth()


#练习：写一个类班级类，属性有班级名字，学生，功能：添加学生、查找学生

#写一个类，封装所有和数学运算相关的功能
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.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])