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

day12-面向对象基础

作者: 七一欧 | 来源:发表于2018-07-31 18:57 被阅读0次

01-迭代器和生成器

  • 生成器:
    a.可以看成是一个可以存储多个数据的容器。需要里面的数据的时候就生成一个,里面的数据只能从前往后一个一个的生成
    不能跳跃,也不能从后往前。生成过的数据不能再生成了
    b.获取生成器里面的数据,需要使用next()方法,一次只能获取一个
    c.只要函数声明中有yield关键字,函数就不再是一个单纯的函数,而是变成一个生成器
    和列表比较:列表存数据,数据必须是实实在在存在的数据,一个数据会占一定的内存空间。
    生成器存数据,存的是产生数据的算法
# 1,1,2,3,5,8,13,21,34,55....
def func1():
    if False:
        yield 100
    print(100)

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
            # print(current)
            continue
        current = pre_1 + pre_2
        pre_1, pre_2 = pre_2,current
        # print(current)
        yield current

xulie = xu_lie(10)
print(xulie.__next__())
for x in xulie:
    print('===',x)
if __name__ == '__main__':
    x = (i for i in range(10))
    # x就是一个生成器,用来产生数据
    print(x)

    print(x.__next__())
    print(x.__next__())

    print('======')
    num = 100

    print(x.__next__())
    print(x.__next__())

02-认识面向对象

  • 1.什么是类:对拥有共同属性和功能的对象的封装
    类是抽象的
  • 2.什么是对象:对象就是类的实例
    对象是具体的
    对象的属性是确定的
如果说人是一个类,那么小明就是人的一个对象
如果说电脑是一个类,那么我桌上的电脑就是一个对象
如果说杯子是一个类,我桌上的杯子就是一个对象
  • 3.面向对象编程
    面向过程编程:一步一步的写代码实现功能-->工具:逻辑和算法
    函数式编程:面对问题,考虑有没有拥有某种功能的函数-->工具:函数
    面向对象编程:面对问题考虑有没有相应的对象来解决这个问题-->工具:类和对象

03-类的声明

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

  • 1.声明类Person
 声明两个对象方法,需要使用对象来调用
 对象方法默认都有一个参数self,在调用方法的时候,这个参数不用传参,系统会自动给self传参
 谁来调用这个方法,self就是谁
class Person:
 """类的说明:人类"""
def eat(self):
     print('吃饭')

 def sleep(self):
     print('睡觉')
  • 声明对象:
    通过类的构造方法去创建对象(名字和类名同名的方法就是构造方法)
    对象名 = 类名()

  • 类的对象可以点语法使用类中声明的对象的方法和属性
    对象.方法名()
    对象.属性名

if __name__ == '__main__':
    # 2.声明对象
    p1 = Person()
    print(p1)

    # 一个类可以有多个对象
    p2 = Person()
    print(p2)

    # 对象可以调用对象方法
    p1.eat()
    p1.sleep()

04-对象的属性

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

  • class Person:
    """人类"""
    """
    1.init方法是系统自带的一个方法,这个方法不能直接调用,而是通过类创建对象的时候系统自动调用这个方法
    init方法的作用是对对象的属性进行初始化
    2.通过构造方法创建对象的时候,一定要保证,init方法中,除了self以外,其他的每个参数都必须有值
    """
    def __init__(self,name1,age1,sex):
        # 在这个地方声明对象的属性
        # 在init方法中声明对象的属性
        """
        name、age和sex就是Person这个类的对象属性,类的对象属性需要通过对象来使用
        """
        self.name = name1
        self.age = age1
        self.sex = sex
if __name__ == '__main__':
    # 注意:构造方法中的参数,实质是传给init方法的参数的
    p1 = Person('xzq',18,'男')

    # 通过对象使用对象属性
    print(p1.name,p1.age,p1.sex)


    """通过不同的方式创建对象"""
    # 创建对象的时候不给属性赋值
    p3 = Person(1,1,1)

05-对象属性的增删改查

class Dog:
    """狗类"""
    def __init__(self,age = 0,color = 'black'):
        self.age = age
        self.color = color
if __name__ == '__main__':
    dog1 = Dog(3,'white')
     1.查(获取属性)
    """
    方法一:对象.属性(如果属性不存在,会报错)
    方法二:对象.__getattribute__(属性名)和getattr(对象,属性名,默认值)
    
    """
    print(dog1.age,dog1.color)

    print(dog1.__getattribute__('age'))
    print(getattr(dog1,'age'))

    # 如果设置了默认值,那么当属性不存在的时候不会报错,并且返回默认值
    print(getattr(dog1,'abc','无名氏'))
    # 2.改(修改属性的值)
    """
    方法一:对象.属性 = 新值
    方法二:对象.__setattr__(属性名,新值)和setattr(对象,属性名,值)
    """
    dog1.age = 4
    print(dog1.age)

    dog1.__setattr__('color','yellow')
    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)

    # dog2 = Dog()
    # print(dog2.name)
    # 4.删除(删除对象属性)
    """
    del 对象.属性
    注意:删除属性也是删的具体的某个对象的属性。不会影响这个类的其他对象
    """
    del dog1.age
    # print(dog1.age)
    # AttributeError: 'Dog' object has no attribute 'age'

    # dog1.__delattr__('age')
    # print(dog1.age)
    #
    # delattr(dog1,'color')
    # print(dog1.color)
print('========')
  • 练习
    声明一个学生类,拥有属性:姓名,性别,年龄。方法:学习
    1.声明学生类的对象,声明的时候就给姓名、性别和年龄赋值
    2.通过三种方式分别获取姓名、性别和年龄,并打印
    3.给学生对象添加一个属性,电话
    4.修改学生的年龄
    5.删除学生的年龄
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)


student1 = Student()
# 方法一:
print(student1.name,student1.sex,student1.age)
# 方法二:
print(student1.__getattribute__('name'),student1.__getattribute__('sex'),student1.__getattribute__('age'))
# 方法三:
print(getattr(student1,'name'),getattr(student1,'sex'),getattr(student1,'age'))

student1.tel = '123456789'

student1.age = 15

del student1.sex

06-slots魔法


class Person:
    # __slots__ 的功能:就是约束类中对象的属性。
    __slots__ = ('name','age','sex')
    def __init__(self,name='',age=0):
        self.name = name
        self.age = age
    #     自定义对象的打印格式
    """id():是python的内置函数,功能是获取变量的地址"""

    def __str__(self):
        return self.name + ','+str(self.age)

if __name__ == '__main__':
    p1 = Person('小王',20)
    p1.sex = '男'
    print(p1)

    p2 = Person('小花',10)
    print(p2)

07-类中的方法

  • 属性:对象的属性(属性)、类的属性(类的字段)
    对象属性:属于对象的,不同对象对应的值可能不一样(对象属性,通过对象来使用)
    类的字段:声明在类里面,函数外面。类的属性属于类(类的字段,通过类来使用)

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

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

  • 怎么选择用对象方法、类方法、静态方法?
    if 如果实现函数的功能需要使用对象的属性,就声明成对象方法
    elif 如果实现函数的功能需要使用类的字段或者调用类的方法,就声明成类方法
    else 如果实现函数功能既不需要对象的属性也不需要类的字段,就声明成静态方法

补充:ctr + r --> 查找替换
      ctr + f --> 查找
class Person:
    # 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(Person.number)

    # 2.对象的属性要通过对象来使用
    p1 = Person('小米')
    print(p1.name,p1.age)
    # 3.对象方法用对象调用
    p1.eat('面条')

    p2 = Person('小垃圾')
    p2.eat('火锅')

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

    # 5.静态方法通过类来调用
    Person.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-面向对象基础

    1. 迭代器和生成器 生成器:a. 可以看成一个可以存储多个数据的容器。需要里面的数据的时候就生成一个,里面的数据...

  • day12-面向对象基础

    01-迭代器和生成器 生成器:a.可以看成是一个可以存储多个数据的容器。需要里面的数据的时候就生成一个,里面的数据...

  • Day12-面向对象

    1.迭代器和生成器 2.认识面向对象 1.什么是类:对拥有相同属性和功能的对象的封装类是抽象类中相同的属性的值是不...

  • day12-面向对象

    1、迭代器,生成器 生成器 a.可以看成是一个可以存储多个数据的容器。需要里面的数据的时候就生成一个数据,里面的数...

  • Day12-面向对象

    1、内置类属性 Python中每个类都拥有内置的类属性 类 . __ name __获取类的名字 类 . __ d...

  • day12-面向对象

    一、迭代器和生成器 生成器: a.可以看成是一个可以存储多个数据的容器。需要里面数据的时候就生成一个里面的数据只能...

  • java SE目录

    java SE目录 java基础(一)java基础(二)关键字面向对象(一)面向对象(二)面向对象(三)集合(一)...

  • Java基础03面向对象

    Java 基础02Java编程基础 面向对象上 面向对象的概述 面向对象的概述:面向对象是一种符号人类思维习惯的编...

  • python面向对象学习笔记-01

    学习笔记 # 0,OOP-Python面向对象 - Python的面向对象 - 面向对象编程 - 基础 -...

  • java基础回顾(2)

    面向对象:是基于面向过程的一种思想。 面向过程:以函数为基础,关注实现过程。 面向对象:以对象为基础,关注实现结果...

网友评论

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

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