一、迭代器和生成器

生成器：a.可以看成是一个可以存储多个数据的容器,需要里面数据的时候就生成一个，里面的数据只能从前往后一个一个的生成，不能跳跃，也不能从后往前，而且生成后的数据，不能再生成了
b.获取生成器里面的数据，需要使用next()方法
c.只要函数声明当中有yield关键字，函数就不再是一个单纯的函数，而是变成了一个生成器
d.遇到yield则停止，返回yield后面的数据

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

x = (i for i in range(10))
print(x.__next__())    #生成器的调用方法是   生成器名.__next__()

def fib(n):
    pre_1 = 1  # 前一个月的数量
    pre_2 = 1  # 前两个月的数量
    for i in range(1, n+1):
        if i == 1 or i == 2:
            yield 1
        current = pre_1 + pre_2
        pre_1, pre_2 = current, pre_1
    yield current
print(fib(10).__next__())

def fib(Max):#fib的新揭发
    n,a,b = 1,0,1
    while n < Max:
        a,b =b, a+b
        n += 1
    return b
print(fib(5)

二、认识面向对象

1.类:对拥有相同属性的方法的对象的封装
2.对象：类的实例
类：抽象概念
对象：具体概念
3.面向对象编程
面向过程编程：一步一步的写代码实现功能---->工具：逻辑和算法
函数式编程：面对问题考虑有没有拥有某种功能的函数---->工具：函数
面向对象编程：面对问题考虑有没有相应的对象来帮我解决这个问题------>工具：类和对象

三、类的声明

类的声明：
class 类名(父类)：（括号可以省略）
属性
方法

class:python中声明类的关键字
类名：标识符，类名的首字母大写，驼峰式命名（与驼峰式的命名有一点区别）
类命名：所有的单词首字母都大写
驼峰式命名：首字母小写，其余的单词首字母大写
（）：类要继承其他的类，需要写括号，括号里面是父类的名字。可以省略
属性：对象属性和类的字段------>保存数据
方法：实质就是声明在类中的函数------>实现功能
通过类的构造方法去创建对象（名字和类名同名的方法就是构造方法，自动生成）
对象名 = 类名（）

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

class Person:
    def eat(self):
        print('self',self)
        print('吃饭')
        self.sleep()

    def sleep(self):
        print('self', self)
        print('在睡觉，晚安！')
p1 = Person()  #声明p1是Person当中的一个对象
print(p1)       #p1是以地址的形式保存在电脑当中的
print(p1.eat()) #通过对象.函数名 来调用对象的方法
结果：<__main__.Person object at 0x00000063292AF240>
self <__main__.Person object at 0x00000063292AF240>
吃饭
self <__main__.Person object at 0x00000063292AF240>
在睡觉，晚安！
None

由此可以看出类中的对象必须先创建对象，然后再通过名字去调用

四、对象的属性

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

class Person:
    def __init__(self,name,age):#在声明对象的属性的时候，可以不设默认值，直接在创建对象的时候赋值
        self.name = name
        self.age = age
p1 = Person('王刚',30)  # 总之在创建对象的时候，要保证每一个声明过的参数都要有值，self可以自动传值，他的值就是调用它的对象的名字
print(p1.name)

注意：创建对象的属性一定要在init函数下面，这是系统自带的函数。任何方法都调用不了

五、对象属性的增删改查

1.查（查询属性的值）-------get
a.对象.属性（如果属性不存在，会报错）
b.对象.getattribute(属性名）
c.getattr(对象名，属性名，默认值）-------在该种情况下，如果属性不存在，会返回默认值

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

p1 = Person('张飞',200)
print(p1.name)
print(p1.__getattribute__('age'))
print(getattr(p1, 'height','身长八尺'))
结果：张飞
200
身长八尺

注意：通过 getattr(对象名，属性名，默认值）去获取属性的时候，默认值可以不设定，如果属性不存在，也不会报错，如果设定了默认值，则会返回默认值的内容
2.改（修改属性的值）-------set
a.对象名.属性 = 新值
b.对象.setattr(属性名，新值）
c.setattr(对象，属性名，新值）

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

p1 = Person('张飞',200)
p1.name = '关羽'
print(p1.name)
p1.__setattr__('age',210)
print(p1.age)
setattr(p1,'age',220)
print(p1.age)
结果：关羽
210
220

3.增（与改的方法一样，唯一的区别是，增是在属性不存在的情况下，而改是在属性存在的情况下）
属性存在则改，属性不存在则增
不管是增还是改都是针对某个具体的对象来说的，对其他对象的属性不会造成影响，如果要想修改所有对象的属性，只能在init()函数下面修改
4.删（删掉某个属性）-------del
a.del 对象名.属性
b.对象名.delattr(属性名）
c.delattr(对象名，属性）

class Person:
    def __init__(self, name, age,height):
        self.name = name
        self.age = age
        self.height = height
p1 = Person('吕布', 250, 2.2)
del p1.name
print(p1.name)
p1.__delattr__('age')
print(p1.age)
delattr(p1,'height')
print(p1.height)

六、slots魔法

在声明类的时候加上slots=（属性1，属性2，属性3）可以锁定对象的属性，后面在创建对象属性的时候，只能少于或者等于这些属性，不能多于这些属性

class Person:
    __slots__=('name', 'age', 'height')#用来锁定对象的属性，可以少，不可多
    def __init__(self, name, age, height):
        self.name = name
        self.age = age
        self.height = height
p1 = Person('刘备', 200, 1.8)
print(p1.name, p1.age, p1.height)
结果：刘备 200 1.8

七、类中的方法

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

方法：对象方法（方法）、类方法、静态函数
对象方法：自带一个self参数，一般要通过对象去调用
类方法：1.使用@classmethod修饰
2.自带一个cls参数，并且这个参数不用传参，谁来调用这个方法，cls就指向谁
3.类方法要通过类来调用

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

怎么选择用对象方法、类方法、静态方法？
if 如果实现函数的功能需要使用对象的属性，就声明成对象方法

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

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

补充：ctr+r---->查找替换
ctr+f---->查找

class Historical_Figures():
    number = 200   #该number属于类的属性
    characteristic = '牛逼'  #该属性也是类的属性


    def __init__(self, name, age, character):   #该函数下面的是对象的属性
        self.name = name
        self.age = age
        self.character = character


    def study(self):        # 该函数下面的是对象的方法
        print('%s学习能力强' % self.name)


    @classmethod
    def courage(cls):       #该函数下面的是类的方法
        print(cls)
        p1 = cls('卫青',300,'brave')
        print(p1.name,p1.age,p1.character)
        print(cls.number,cls.characteristic)


    @staticmethod
    def famous():
        all = Historical_Figures
        print(all.number)

print(Historical_Figures.number)
print(Historical_Figures.characteristic)
one_person = Historical_Figures('李广',500,'intelligent')
print(one_person.name,one_person.age,one_person.character)
print(one_person.study())
print(Historical_Figures.courage())
print(Historical_Figures.famous())
结果：200
牛逼
李广 500 intelligent
李广学习能力强
None
<class '__main__.Historical_Figures'>
卫青 300 brave
200 牛逼
None
200
None

作业

1.声明一个电脑类：

属性:品牌，颜色，内存大小

方法：打游戏，写代码，看视频

class Computer(object):

    def __init__(self, brand, color, memory_size):
        self.brand = brand
        self.color = color
        self.memory_size = memory_size


    def play_game(self):
        return ('%s用来打游戏很强悍' % self.brand)


    def write_code(self):
        return ('%s写代码很流畅' % self.brand)

    def watch_viedo(self):
        return ('%s看视频很爽' % self.brand)

computer1 = Computer('Alien', 'black', 24)
print(computer1.play_game())
print(computer1.watch_viedo())
print(computer1.write_code())

print(computer1.brand)
computer1.brand = 'Apple'
print(computer1.brand)
computer1.thickness = '1cm'
print(computer1.thickness)
# del computer1.color
# print(computer1.color)

print(getattr(computer1,'brand','华硕'))
setattr(computer1,'speed', 'fast')
print(computer1.__getattribute__('speed'))
computer1.__setattr__('color', 'gray')
print(getattr(computer1, 'color'))
# computer1.__delattr__('color')
# # print(computer1.color)
结果：Alien用来打游戏很强悍
Alien看视频很爽
Alien写代码很流畅
Alien
Apple
1cm
Apple
fast
gray

2.声明一个人的类和一个狗的类：

狗的属性：名字，颜色，年龄 狗的方法：叫唤

人的属性：名字，年龄，狗 方法：遛狗

a.创建人的对象小明，让他拥有一条狗大黄，然后让小明去遛大黄

class Dog():


    def __init__(self,name,color,age=1):
        self.name = name
        self.color = color
        self.age = age


    def method(self):
        return 'bark'

class People():


    def __init__(self, name, age=20, dog = []):
        self.name = name
        self.age = age
        self.dog = dog


    def function(self):
        return ('%s walk the %s' % (self.name,self.dog[0]))

dog1 = Dog('大黄', 'yellow')

people1 = People('小明')
people1.dog.append(dog1.name)
people1.dog.append(dog1.color)
print(people1.dog)
print(people1.function())
结果：['大黄', 'yellow']
小明 walk the 大黄

3.声明一个矩形类：

属性：长 宽 方法：计算周长和面积

a.创建不同的矩形，打印周长和面积

class Rectangles():


    def __init__(self, length, width):
        self.length = length
        self.width = width


    def area(self):
        return ('面积:',self.length*self.width)


    def premiter(self):
        return ('周长:', 2*(self.width+self.length))

rect1 = Rectangles(2,3)
print(rect1.area(),rect1.premiter())

rect2 = Rectangles(50,20)
print(rect2.area(),rect2.premiter())
结果：('面积:', 6) ('周长:', 10)
('面积:', 1000) ('周长:', 140)

4.创建一个学生类：

属性：姓名，年龄，学号

方法：答到，展示学生信息

创建一个班级类：

属性：学生，班级名

方法：添加学生，删除学生，点名

class Students():


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


    def answer(self):
        return '到'


    def display_info(self):
        return ('姓名：%s 年龄：%d 学号：%d' % (self.name, self.age, self.id))

class Class():


    def __init__(self,class_name,students=[]):
        self.name = class_name
        self.students = students


    def add(self):
        return self.students.append()

    def delete(self):
        return self.students.remove()

    def count(self):
        return list(i for i in self.students)

5.写一个类，封装所有和数学运算相关的功能（包含常用功能和常用值，例如：pi,e等）

from math import pi,e

class Math():


    def __init__(self,x=0,y=0,z=0,π=pi,e=e):
        self.x = x
        self.y = y
        self.z = z
        self.π = pi
        self.e = e

    def sum(self):
        return self.x+self.y+self.z

    def multi(self):
        return self.x*self.y*self.z

    def circle(self):
        return self.π*(self.x)**2

one = Math(2)
print(one.circle())

6.写一个班级类：

属性：班级名，学生

功能：添加学生，删除学生，根据姓名查看学生信息，展示班级的所#有学生信息

class Class():
    
    
    def __init__(self,name,students=[]):
        self.name = name
        self.students = students
        
    
    def add(self):
        return self.students.append()
    
    def delete(self):
        return self.students.remove()
    
    def search(self):
        list1 =  list(i for i in self.students)
        
    def display_info(self):
        return list(i for i in self.students)