day16-总结

作者: RurouniKenshin | 来源:发表于2018-07-31 20:54 被阅读57次

迭代器和生成器

生成器：

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)