Python学习总结【连载】（十一，十二）

2018.06.27 Juttachen

概述

+ 37 类的定义

+ 38 对象属性和init方法

+ 39 self

+ 40 属性的增删改查

+ 41 内置类属性

三十七、类的定义

复习
类：具有形同属性和功能的对象的集合；是抽象的
对象：类的实例；具体的

1.类的声明

格式：

class 类名（父类）：
属性
方法

class 类名：
属性
方法

a.class:python中声明类的关键字
b.类名：标识符。特殊规范：首字母大写，见名知意。
c.属性：分类的字段和对象的字段 ----------->属性
d.方法：分对象方法（构造方法），类方法，静态函数 ---------->功能
1）方法：就是声明在类中的函数（都有一个默认参数，不需要调用的时候给他传值）
2）对象方法：在类中直接声明的函数，带一个参数self,要使用对象来调用

    # 声明类
    class Person:
        """人类""" # 类的说明文档

        # 在类中声明了eat方法，默认有一个参数self，调用eat防范的时候，不需要给delf传参
        # 在类中直接声明的函数都是对象方法，对象方法必须使用对象来调用

        def eat(self):
            print('吃饭')

        # 直接写在类中的函数，必须带参数self
        # def run()
        #   print('aaa')

    # 注意：如果要在类中声明带参才能的对象方法，那么其他的参数必须写在self的后面
        def run(self,num):
            print('跑了%s米'%(num))

2. 创建对象

通过类名就可以创建对象，然后可以用变量存起来
可以通过对象去调用类中的对象方法，和使用类中声明的对象属性（字段）

    p1 = Person()
    # p1就是Person类的一个实例（对象）

调用对象方法，对象.方法（）
写在类里面的函数也可以传参

    p1.eat()
    p1.run(100)

一个类可以创建多个对象

    p2 = Person()
    p2.eat(80)

三十八、对象属性和init方法

实例一：init方法会自动被调用。
_ init _方法又叫构造方法。是在通过类创建对象的时候，自动调用的方法。
_ init _方法的作用就是在创建对象的时候初始化对象的属性。
_ init _：对象的属相就是声明在整个方法中

    class Person:
        def __init__(self):
            # 在这个地方声明对象的属性。。。
            print('这个是init')

在声明对象的时候会自动调用init方法

    p1 = Person()
    p2 = Person()

实例二：带参的init方法
init的方法的方法名固定：init。但是参数是可以随意改变的（但是self参数不变）

    class Dog:
        def __init__(self,name):
            print('名字是：%s'%(name))

通过类创建对象的时候，要保证init方法里面的每一个参数都有值。通过类后面的括号里传参来保证每个参数都有值。

    dog1 = Dog('蔡蔡')

实例三：对象属性
属性：声明在类中的变量
对象属性：要通过对象去使用；不同的对象可能会有不同的值：

    class Person2:
        """人类"""
        # 在init方法中声明对象的属性：self.属性名 = 初值
        def __init__(self):
            # 声明一个对象属性name：初始值为空串
            self.name = ''
            # 声明一个对象属性age：初始值为10

    # 通过Person2类创建对象1
    p1 = Person2
    # 通过对象去修改P1的name属性
    p2 = Person2
    # p1.name = 'print(p2.name)

练习：声明一个学生类，拥有属性：名字，年龄，电话。拥有方法：学习

    class Student:
        def __init__(self):
            self.name = ''
            self.age = 18
            self.tel = 12345678910

        def study(self):
            print('学习')

    stu = Student()
    stu.name = '韩梅梅'
    print(stu.name,stu.age,stu.tel)
    # 调用对象方法（给对象发送消息）
    stu.study()

实例四：创建对象的时候赋初值

    class Student2:
        def __init__(self,name1='',age1=1,tel1=''):
            self.name = name1
            self.age = age1
            self.tel = tel1

    # 在创建对象的时候给对象属性赋初值
    stu2 = Student2('小明', 18,'112')
    print(stu2.name)
    stu3 = Student2(name1="小王")

三十九、self

类中的对象方法都有一个默认参数self：
1.调用带有默认参数self的方法，不需要给self传参。系统会自动将调用当前方法的对象传给self
2.在方法中使用self就相当于使用调用方法的对象（只能使用self,不能重新给self赋值）

    class Person:
        """人"""

        def __init__(self, name='', age=''):
            """声明对象的属性"""
            self.name = name
            self.age = age

        def eat(self):
            print('%s eat breakfirst.' % (self.name))

        # 声明一个对象的方法run
        def run(self):
            print('self', self)
            print('run now!!')

            # 在对象方法中使用对象的属性，直接用self去获取属性
            print('%s run now' % (self.name))
            self.eat()


    # 创建一个Person对象
    p1 = Person('小明', 10)

    # 通过对象p1去调用run方法，系统会将self = p1
    # 这个时候在run方法中，p1和self是同一个东西
    p1.run()
    print('p1', p1)
    # eat中的self = p1
    p1.eat()

    p2 = Person('小红', 20)
    p2.run()
    p2.eat()

练习：声明一个圆类，拥有属性：半径 拥有方法：计算圆的面积，计算圆的周长

    import math
    # 或者 from math import pi(之后就不需要写math.pi，而是直接写pi)

    class Circle:
        def __init__(self, radius=10):
            self.r = radius

        # 在对象方法中可以通过self去使用对象
        def area(self):
            C = math.pi * self.r ** 2

        # 注意要 return C 或者直接 return math.pi * self.r ** 2

        def perimeter(self):
            l = 2 * math.pi * self.r
            return l
        # 同上道理
    c1 = Circle()
    print('%.2f' % c1.area())
    print('%.2' % c1.perimeter())

    c2 = Circle(3)
    print(c2.area())

四十、属性的增删改查

    class Dog:
        """狗狗"""
      def __init__(self,name = '',age = 0):
    self.name = name
    self.age = age
    dog1 = Dog('才才')

1.查

方法一：对象.属性
特点：如果属性村子就获取属性的值。如果属性不存在就会报错。

    print(dog1.name)
    # print(dog1.score) # AttributeError: 'Dog' object has no attribute 'score'

方法二：getattr(对象，属性名，默认值) --> 获取指定对象的指定属性
如果不设置默认值:属性如果存在就获取属性的值，不存在就会报错
如果设置默认值：属性如果存在就获取属性的值，不存在不仅不报错，而且将默认值作为结果（但是不创建属性）

  """
        getattr(object, name[, default]) -> value

        Get a named attribute from an object; getattr(x, 'y') is equivalent to x.y.
        When a default argument is given, it is returned when the attribute doesn't
        exist; without it, an exception is raised in that case.
  """

    print(getattr(dog1,'name'))
    print(getattr(dog1,'score',100))
    # print(getattr(dog1,'color')) # AttributeError: 'Dog' object has no attribute 'color'
    # print(getattr(dog1,'score')) # AttributeError: 'Dog' object has no attribute 'score'

方法三：对象.getattribute(属性名)
获取指定对象的指定属性。如果属性不存在就会报错。

    print(dog1.__getattribute__("name"))
    # print(dog1.__getattribute__("sex")) # 和方法一一样报错

2.改（修改）

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

    dog1.name = '大黄'
    print(dog1.name)

方式二：setattr(对象，属性名，新值)

    setattr(dog1,'name','小黄')
    print(dog1.name)

方式三：对象.setattr()

    dog1.__setattr__('name','小黑')

3.增（添加属性）

python中可以动态的给对象添加属性
方法一：
用对象.属性 = 新值就可以增加（只要对象不存在）

    dog1.sex = '男'
    print(dog1.sex)

方式二：setattr(对象，不存在的属性名，新值)

    setattr(dog1,'color','brown')
    print(dog1.color)

方式三：对象.setattr()

    dog1.__setattr__('score','100')
    print(dog1.score)

4.删除属性

方法一：del 对象.属性
将dog1的age属性删除

  del dog1.age
  # print(dog1.age)  # AttributeError: 'Dog' object has no attribute 'age'

方法二：delattr(对象，属性名)

    delattr(dog1,'age')
    # print(dog.age)  # AttributeError: 'Dog' object has no attribute 'age'

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

    dog1.__delattr__('age')
    # print(dog1.age) # AttributeError: 'Dog' object has no attribute 'age'

5.判断对象是否拥有某个属性

方式：hasattr(对象,'属性名') ----> 判断指定的对象是否拥有指定的属性

    result = hasattr(dog1,'name')
    print(result)

补充：
实例1：对象属性的操作只对当前那一个对象有效

    class Person:
        def __init__(self,name = '',age = 0,id_num = '',sex = ''):
            """人"""
            self.name = name
            self.age = age
            self.id_num = id_num
            self.sex = sex

    p1 = Person('小明',10)

    # 给不存在的属性赋值，就是添加属性
    p1.score = 100
    print(p1.score+100)

    p2 = Person('罗昊',30)
    # print(p2.score) #AttributeError: 'Person' object has no attribute 'score'

注意:1.对对象属性的增，删，改，查是指定那一个对象。不会影响其他的对象。
2.实际开发的时候，一般只用获取对象属性的值和修改对象属性的值。想添加或删除属性，一般都是在init方法中操作

实例二：

    class Dog:
        """狗"""
        #  通过给__slots__赋值，可以限制类中对象的属性有哪些，防止一个不必要的属性被添加
        __slots__ = ('name','age','color')
        def __init__(self,name='',age=0,color=''):
            self.name = name
            self.age = age
            self.color = color
            # self.sex = '男' # 在__slots__ 中没有sex的话，不管在哪都不能添加，只能先在__slots__ 中添上才能添加

    dog1 = Dog('笑话',3,'Yellow')
    dog1.name1 = '大黄'

    del dog1.name
    # 注意__slots__ 中规定的属性只能少不能多。删除属性是不受影响的。

四十一、内置类属性

    class Dog:
        """狗"""
        def __init__(self,name='',age=0,color=''):
            self.name = name
            self.age = age
            self.color = color

        def run(self):
            print('%s跑起来'%(self.name))

        def shout(self):
            print('%s在叫唤'%(self.name))
    
    dog = Dog()

内置的类属性是属于类的，需要通过类去使用

1. 类.name :获取类的名字

    class_name = Dog.__name__ # 'Dog'
    print(class_name,type(class_name))
    # 这个属性只有类有

2.类.doc:获取类的说明文档

    print(Dog.__doc__)

3.类.dict(对象.dict):获取类中所有的类属性（类字段）

    print(Dog.__dict__)
    print(dog.__dict__) #获取了所有关于dog的属性和值（以字典键值对的方式）【包括添加的】

4.类.module:获取类所在的模块的名字

    print(Dog.__module__)

5.类.bases :获取指定类的基类

    print(Dog.__bases__)