美文网首页
2018-09-06类和对象

2018-09-06类和对象

作者: Smilebest | 来源:发表于2018-09-06 19:15 被阅读4次

    01-类和对象

    1.理论上的定义
    类:就是拥有相同功能和相同属性的对象的集合 (类是抽象)
    对象:类的实例(对象是具体的)
    2.从生活的角度
    如果说人是一个类,马云就是一个对象
    如果说电脑是一个类,我桌上的这台电脑就是一个对象
    如果说车是一个类,具体的一辆车就是一个对象
    3.编程思想
    面向过程编程:以算法为工具
    函数式编程:以函数为工具
    面向对象编程:以类和对象为工具(面向生活)

    02-类的声明

    类:对拥有相同功能(方法)和相同属性(属性)的封装

    封装效果:一个类中可以对多个功能进行封装(多个函数),对多个属性进行封装
    1.类的声明格式
    class 类名(父类列表):
    ——类的说明文档
    ——类的内容
    2说明:
    class:声明类的关键字
    类名:标识符,不能是关键字。驼峰式命名(第一个单词首字母小写,其它的单词首字母大写),首字母大写!!!,见名知义
    例如:Person、StudentSystem
    (父类列表):括号与括号里的内容可以省略,这个是继承语法
    冒号:固定的
    类的内容:包括类的方法和类的属性
    3.类中的方法
    方法:声明在类中的函数
    a.对象方法:对象方法需要对象来调用,对象,函数名()
    直接写在类中的方法,自带一个self参数
    b.类方法
    c.静态方法
    4.创建对象
    创建类的时候,系统会默认给我们创建这个类对应的构造方法
    构造方法:类名()--》创建类对应的对象

    
    # 创建一个类
    class Person:
        '''人类'''
        def eat(self):
            print('人吃饭')
    
    
    
    if __name__ == '__main__':
        # 创建对象
        p1 = Person()    # 创建Person类的对象,并且将对象地址存到p1中
    
        # 一个类可以有多个对象
        p2 = Person()
        # 只有在调用构造方法的时候才会产生新的对象
        p3 = p2
        print(id(p1),id(p2),id(p3))
    
        # 2.调用对象
        # 通过对象调用对象方法,默认参数self不需要传参,系统自动传参
        p1.eat()
    

    03-构造方法和init方法

    1.构造方法:系统自动创建,方法名和类名一样,用来创建对象
    2.init:init方法的功能是用来做初始化和添加对象属性的
    当我们通过构造方法去创建对象的时候,系统会自动调用init方法(不用主动调用init方法)

    class Dog:
        def __init__(self):
            print('init方法')
    
    class Person:
        # init方法可以添加参数
        def __init__(self,name,age = 18):
            print(name,age)
            print('人类的init方法')
    
    if __name__ == '__main__':
        # 创建对象的过程:调用构造方法在内存中开辟空间创造一个对象,然后用新建的这个对象去调用init方法,
        #                 来初始化对象的属性,最后才将对象返回
        dog1 = Dog()
        dog2 = Dog()
        # 如果类的init方法有参数,通过给构造方法传参类init方法传参
        p1 = Person('小明')
        p2 = Person('小红',20)
        p3 = Person(age = 20,name = '东东')
    

    04-对象属性

    类中的内容:属性和方法
    1.属性:(保存值的)
    a.对象的属性:不同的对象,对应的值可能不一样,这样的属性就是对象属性属于对象
    类中的对象属性是声明在init方法中的,并且声明格式:self.属性名 = 初值
    对象属性的使用:对象,属性名
    b.类的字段:属于类的,所有的对象对应的值是一样的
    2.方法:(保存功能的)
    a.对象方法
    b.类方法
    c.静态方法

    
    class Student:
        '''学生类'''
        def __init__(self):
            # 声明对象属性name,age,id
            self.name = '李青'
            self.age = 0
            self.id = '001'
    
    class Dog:
        '''狗类'''
        # 创建Dog的对象的时候,必须传类型和颜色
        def __init__(self,type1,color1):
            self.type = type1
            self.color = color1
    
    class Computer:
        '''电脑类'''
        # 创建对象的时候可以使用默认值,也可以使用自己传的值
        def __init__(self,color= '白色',memory= 0):
            self.color = ''
            self.memory = 1000
    
    class  rectangle:
        def __init__(self,long= 100,width= 50):
            self.long = long
            self.width = width
    
    
    if __name__ == '__main__':
        # stu1就是Student类的对象
        stu1 = Student()
        # 通过对象去使用对象的属性
        print(stu1.name,stu1.age,stu1.id)
        # 通过对象去修改对象的属性
        stu1.name = 'SB'
        print(stu1.name)
        dog1 = Dog('土狗','黄色')
        print(dog1.type,dog1.color)
        dog2 =Dog('斗狗','黑色')
        print(dog2.type,dog2.color)
    
    
        comp1 = Computer()
        print(comp1.color,comp1.memory)
        comp2 = Computer('黑色',512)
        print(comp2.color,comp2.memory)
    
        sq =  rectangle()
        print(sq.long,sq.width)
        sq =  rectangle(10,5)
        print(sq.long,sq.width)
    

    05-对象属性的增删改查

    Python是动态语言,Python中类的对象的属性可以进行增删的操作

    class Person:
        '''人类'''
        def __init__(self):
            self.name = '李四'
            self.age = 18
            self.height = 160
    
    1.查

    方法一:对象.属性
    方法二:def getattr(对象,属性名,default=None)
    方法三:对象._ getattribute _('height')

    print(p1.name)
        # print(p1.nmae2)      # 属性不存在会报错
    
    print(getattr(p1,'age2',0))    # 属性不存在可以通过设置默认值,让程序不崩溃,并且返回默认值
    
     height = p1.__getattribute__('height')
        print(height)
    
    2.改(修改属性的值,属性存在)

    方法一:对象.属性 = 新值

    p1.name = '张三'
        print(p1.name)
    

    方法二:def setattr(对象,属性名,新值)

    setattr(p1,'age',20)
        print(p1.age)
    

    方法三:对象._ setattr _(属性名,新值)

     p1.__setattr__('height',170)
        print(p1.height)
    
    3.增(增加属性)

    注意:添加只能给某一个对象添加对应的属性
    方法一:对象.属性 = 新值

    p1.sex = '女'
        print(p1.sex)
    

    方法二:def setattr(对象,属性名,新值)

     setattr(p1,'weight',55)
        print(p1.weight)
    

    方法三:对象.setattr(属性名,新值)

    p1.__setattr__('color', '绿色')
        print(p1.color)
        # print(p2.sex)        # 添加只影响一个对象
    
    4.删(删除对象属性)

    注意:删除只针对指定的对象
    方法一:del 对象.属性

    del p1.name
        # print(p1.name)      可行
    

    方法二:delattr(对象,属性名)

     delattr(p1,'age')
        # print(p1.age)       可行
    

    方法三:对象._ delattr _(属性名)

     p1.__delattr__('height')
        # print(p1.height)     可行
        print(p2.name,p2.age)
    

    06-对象方法

    1.对象方法:
    a.什么样的方法是对象方法:直接声明在类里面的函数默认是对象方法,有一个默认参数self
    b.对象方法要通过对象来调用:对象.对象方法()
    c.对象方法中的默认参数self不需要传参,因为在调用这个方法的时候,
    系统会自动将当前对象传给self,那个对象调用方法,self就指向谁

    import math
    class Circle:
        '''圆类'''
        def __init__(self,radius1):
            self.radius = radius1
        # 声明了一个对象方法area
        # 在这,self就是调用area方法的对象,对象能做的事情,self都可以做
        def area(self):
            # print(id(self))
            # print('求圆的面积')
            return math.pi * self.radius **2
    
    • 练习1:写一个矩形类,有属性长和宽,有两个功能,分别是求周长和面积
    class Rectangle:
        '''矩形类'''
        def __init__(self,long,width):
            self.long = long
            self.width =width
        # 对象方法是否需要额外参数,看实现函数的功能需不需要除了对象属性以外的其他数据
        def area(self):
            return self.long * self.width
        def perimeter(self):
            return (self.width + self.long) *2
    
    • 练习2:写一个班级类,班级里面有多个学生的一门成绩,班级名,可以获取班级成绩中的最高分
    class Grade:
        '''班级类'''
        def __init__(self,class_name,*grade):
            self.class_name = class_name
            self.grade = grade
            # self.grade = []
        def top_score(self):
            # if not self.grade:
            #     return None
            # max(序列)----》获取序列中元素的最大值
            # min (序列)----》获取序列中元素的最小值
            return max(self.grade)
    
    if __name__ == '__main__':
        c1 = Circle(3)
        print(id(c1))
        print('c1的面积',c1.area())
    
    
        c2 = Circle(5)
        print('c2的面积', c2.area())
    
        g1 = Grade('python1806',90,80,70)
        print(g1.class_name)
        print(g1.top_score())
    
        g2 = Rectangle(10,5)
        print(g2.area())
        print(g2.perimeter())
    

    07-类的字段

    1.类的属性叫类的字段
    a.什么是类的字段
    类的字段就是声明在类的里面,方法的外面的变量
    b.什么样的属性声明成类的字段:
    属于类的,对于这个类的所有的对象来说,其值是一样的
    c.怎么使用
    通过类使用:类.字段

    class Person:
        # number就是类的字段
        number = 10
    

    练习:写一个球类,用一个属性来保存这个类的创建对象的个数

    class Ball:
         count = 0
         # 每次创建球的对象都会调用init方法,所以调用init方法的次数就是Ball创建的对象的个数
         def __init__(self):
             Ball.count += 1
    ball1 = Ball()
    ball2 = Ball()
    print(Ball.count)
    
    if __name__ == '__main__':
        # 通过类获取类的字段的值
        print(Person.number)
    
        Person.number = 70
        print(Person.number)
    

    08-类的方法

    类中的方法

    • 1.对象方法(实例方法)
      声明的形式:直接声明在类中
      特点:自带一个不需要主动传参的默认参数self,谁来调用指向谁
    • 2.类方法
      声明形式:声明方法前需要使用@classmethod
      特点:自带一个参数cls,这个参数调用的时候不需要传值,系统自动传值,谁调用,传给谁!始终指向当前类
      调用:通过类调用---》类.类方法()
    • 3.静态方法
      声明的形式:声明方法前需要使用@staticmethod说明
      特点:没有默认参数
      调用:通过类来调用--》类.静态方法()
    class Class1:
    
        # 类字段
        number = 10
        # 声明一个对象方法
        def object_func(self):
            print('对象方法')
    
        # 声明一个类方法
        @classmethod
        def class_func(cls):
            # 通过cls去使用类的字段
            print('cls:',cls.number)
            # 通过cls去创建对象
            tc =cls()
            tc.object_func()
            print('这是一个类方法')
    
        @staticmethod
        def static_func():
            print('这是一个静态方法')
    
    c1 = Class1()
    # 调用对象方法
    c1.object_func()
    print(Class1.number)
    # 调用类方法
    Class1.class_func()
    # 调用静态方法
    Class1.static_func()
    

    4.遇到问题怎么来选择使用那种方法:

    • a.大前提:只要实现方法的功能需要用到对象的属性,我们就使用对象方法,否则就使用静态方法或者类方法
    • b.不使用对象方法的前提下,如果实现功能需要类的字段就使用类方法
    • c.实现功能既不需要对象的属性,又不需要类的字段就使用静态方法
      注意:静态方法和类方法划分不严格,静态方法能做的,类方法可以做,反之成立
    class Person:
        # 类的字段,存储人类数量
        number = 61
    
        @classmethod
        def show_number1(cls):
            print('人类的数量是:%d亿'% cls.number)
    
        @staticmethod
        def show_number2():
            print('人类的数量是:%d亿'% Person.number)
    
    Person.show_number1()
    Person.show_number2()
    
    

    相关文章

      网友评论

          本文标题:2018-09-06类和对象

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