小结

迭代器和生成器

生成器：

a.可以看成是一个可以存储多个数据的容器。
需要里面的数据就生成一个，里面的数据只能从前往后一个一个的生成，不能跳跃，也不能从后往前。生成过的数据，不能再生成了
b.获取生成器里的数据，需要使用next()方法
c.只要函数中有yield关键字，函数就不再是一个单纯的函数，而变成一个生成器

和列表比较

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

def xu_lie(n):
pre_1 = 1
pre_2 = 1
for x in range(1,n+1):
if x == 1 or x == 2 :
current = 1
yield current
continue
current = pre_1+pre_2
pre_1,pre_2 = pre_2,current
yield current
if name == 'main':
x就是一个生成器，用来产生数据
x = (i for i in range(0,10))
print(x,type(x))
print(x.next())
print(x.next())
print('======')
print(x.next())
print(xu_lie(10))
xulie = xu_lie(10)
print(xulie.next())
print(xulie.next())
print(xulie.next())
面向对象初识

1.什么是类：对拥有相同属性和方法的对象的封装类是抽象的，类中相同的属性的值是不能确定的
2.什么是对象：对象就是类的实例。对象是具体的，对象的属性是确定的。如果说狗是一个类，哈士奇犬就是一个对象，中华田园犬狗也是一个对象
3.面向对象编程
面向过程编程：一步一步的写代码实现功能 --> 工具：逻辑和算法
函数式编程：面对问题考虑有没有拥有某种功能的函数 --> 工具：函数
面向对象编程：面对问题考虑有没有相应的对象来解决这个问题 --> 工具：类和对象
class Person:
def init(self,name,age):
self.name = name
self.age = age

if name == 'main':
person1 = Person('wang',12)
print('name :'+person1.name+' age :'+str(person1.age))
python的面对对象

1.类的声明

class 类名(父类):
属性
方法

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

class Person:
"""类的说明"""
def init(self,name,age):
self.name = name
self.age = age
声明2个对象方法，需要使用对象来调用
"""
对象方法默认都有一个参数self，在调用方法的时候，该参数不用传参(系统会自动传参)
谁来调用这个方法，self就是谁
"""

def eat(self):
    print(self)
    print('在吃饭')
def sleep(self):
    print('在睡觉,(¦3[▓▓] 晚安')

2.声明对象

声明对象：
通过类的构造方法去创建对象（名字和类名同名的方法就是构造方法）
对象名字 = 类名()
类对象可以使用 点 语法使用类中声明的对象方法和属性
对象.方法名()
对象.属性名

p1 = Person()
print(p1)
p2 = Person()
print(p2)
p1.eat()
p2.eat()
p1.sleep()
p2.sleep()
3.对象的属性

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

init方法是系统自带的一个方法，这个方法不能直接调用，而是通过类创建对象的时候，系统会自动调用方
init方法的作用是对对象的属性进行初始化
通过构造方法创建对象的时候，一定要保证，init方法中除了self外其他参数有值
def init(self,name = '',age = 18,sex = 'm'):
# 在这个地方声明对象的属性
self.name = name
self.age = age
self.sex = sex

if name == 'main':
# 注意：构造方法中的参数，实质是传给init方法中的参数的
p1 = Person('alice',31,'f')
通过对象使用对象属性
print(p1.name,p1.age,p1.sex)
p2 = Person('wang')
print(p2.name, p2.age, p2.sex)
p3 = Person(age=25,sex='f')
print(p3.name, p3.age, p3.sex)
4.对象属性的增删改查

1.查(获取属性)：

对象.属性(属性不存在，报错)
对象.getattribute(属性名)
getattr(对象，属性名，default)
print(dog1.age,dog1.color)
print(dog1.getattribute('age'))
print(getattr(dog1,'age'))
如果设置了default，那么当属性不存在的时候不报错，并且返回默认值
print(getattr(dog1, 'abc','www'))
2.改(修改属性的值)

对象.属性 = 新值
对象.setattr(属性名，新值)
setattr(对象,属性，新值)
dog1.age = 4
print(dog1.age,dog1.color)
dog1.setattr('color','black')
print(dog1.color)
3.增加(增加对象属性)

对象.属性 = 值(属性不存在)
对象.setattr(属性名，新值)
setattr(对象,属性，新值)
注意：属性是添加给对象的，而不是类的
dog1.name = '大黄'
print(dog1.name)
4.删除(删除对象属性)

del 对象.属性
对象.delattr(属性)
delattr(对象,属性)
注意：删除属性也是删的具体对象的属性，不会影响这个类的其他属性
del dog1.age

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

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

 声明对象
student1 = Student('张山','男',18)
获取属性
print(student1.name,student1.__getattribute__('name'),getattr(student1,'name'))
print(student1.sex, student1.__getattribute__('sex'), getattr(student1, 'sex'))
print(student1.age, student1.__getattribute__('age'), getattr(student1, 'age'))
添加属性
student1.tel = '12345678'
修改年龄
student1.__setattr__('age',28)
print(student1.age)
删除性别
delattr(student1,'sex')
print(getattr(student1,'sex','no sex'))
调用方法
student1.study()

5.类中的方法

普通的def 对象方法
@classmethod修饰下 类的方法
@staticmethod修饰下 静态方法
属性：对象的属性(属性)，类的属性(类的字段)
1.对象属性：属于对象的，不同对象对应的值可能不一样
2.类的字段：声明在类里面，函数外面。类的属性属于类(类的字段，通过类来使用)

方法：对象方法(方法)，类方法，静态函数
1.对象方法：自带一个self参数，一般要通过对象去调用
2.类方法：
a.使用@classmethod修饰
b.自带一个cls的参数，谁调用这个方法，cls就指向谁
c.类方法要类来调用
3.静态方法：
a.使用@staticmethod修饰
b.没有设置参数
c.要通过类来调用
3种方法的编写选择
如果实现函数的功能需要使用对象的属性，就声明成对象方法
如果实现函数的功能需要使用类的字段或者调用类的方法，就声明成类方法
如果实现函数功能既不需要对象的属性也不需要类的字段，就声明成静态方法

class Person:
    number是类字段
    number = 0
    def __init__(self,name='',age=0):
        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('破坏环境！')

    @staticmethod
    def protect_earth():
        print('保护地球')


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

    2.对象的属性通过对象来使用
    p1 = Person('jhon')
    print(p1.name,p1.age)

    3.对象的方法通过对象调用
    p1.eat('面条')
    p2 = Person('alice')
    p2.eat('火锅')

    4.类方法要通过类来调用
    Person.hurt_earth()

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

    """
    练习：1.写个班级类，属性：班级名，学生；功能：添加学生，查找学生
    2.写一个类，封装所有和数学运算相关的功能
    """
    print('='*30)
    class Class:
        def __init__(self,class_name,students=[]):
            self.class_name = class_name
            self.students = students

        def addstu(self,student):
            self.students.append(student)

    class Student:

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

    c1 = Class('sss',[])
    c2 = Class('www',[])
    stu1 = Student('w')
    stu2 = Student('s')
    c1.addstu(stu1)
    c2.addstu(stu2)
    for i in c1.students:
        print(i.name)
    for x in c2.students:
        print(x.name)