美文网首页
day12 面向对象基础

day12 面向对象基础

作者: 跟我念一遍 | 来源:发表于2018-07-31 20:47 被阅读0次

    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])
    

    相关文章

      网友评论

          本文标题:day12 面向对象基础

          本文链接:https://www.haomeiwen.com/subject/ahhkvftx.html