DAY13 Python基础：class and object 类和对象 2018-06-27

01-class and object 类和对象

02-object attribute and init method 对象属性和init方法.py

03-self

04-add,cut,change,find of attribute 属性的增删改查

05-built-in class attribute 内置类属性

---

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

1.1.类的声明

class 类名(父类)：
    属性
    方法

class 类名：
    属性
    方法

1.class：python中声明类的关键字
2.类名：标识符；首字母大写；见名知意
3.属性：分类的字段和对象的字段 -->属性
4.方法：对象方法(构造方法)、类方法、静态方法 -->方法

方法：声明在类中的函数(都有一个默认参数，不需要调用的时候给他传值)
对象方法：在类中直接声明的函数，带一个参数self，要使用对象来调用

class Person:
    '''人类'''    # 类的说明文档

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

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

注意：如果要在类中声明带参的对象方法，那么其它的参数必须写在self的后面

    def run(self, path_length):
        print('run %d meter！'%(path_length))

1.2创建对象

p1就是Person类的一个实例(对象)
可以通过对象去调用类中的对象方法、和使用类中声明的对象属性（字段）

p1 = Person()

# 调用对象方法
p1.eat
p1.run(100)

02-object attribute and init method 对象属性和init方法.py

class 类名：
    属性
    方法

示例一：init方法会自动调用

init方法又叫构造方法，是通过类创建对象的时候，自动调用的方法；
init方法的作用：创建对象的时候初始haul对象的属性
init：对象的属性就是声明在这个地方

class Person:

    # __init__方法又叫构造方法，是通过类创建对象的时候，自动调用的方法；
    # __init__方法的作用：创建对象的时候初始haul对象的属性
    # __init__：对象的属性就是声明在这个地方
    def __init__(self):
        # 在这个地方声明对象的属性
        print('this is a init')

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

p1 = Person()
p2 = Person()

示例二：带参的init方法

init方法的方法名固定：init。但是参数的个数是可以随意改变的（注意self参数不变）

class Dog:

    # init方法的方法名固定：__init__。但是参数的个数是可以随意改变的（注意self参数不变）
    def __init__(self, name=''):
        print('name is %s'%(name))

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

dog1 = Dog('旺财')
dog2 = Dog('dabing')
dog3 = Dog

示例三：对象属性

对象属性：通过对象去使用；不同的对象可能会用不同的值
属性：声明在类中的变量
在init方法中声明对象属性：self.属性名 = 初值

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

        self.age = 10

p3 = Person2()
print(p3.name, p3.age)

# 通过p3对象去修改p3的name属性
p3.name = 'zhangsan'
print(p3.name)

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

class Student:
    def __init__(self, name):
        self.name = name
        self.age = 1
        self.tel = 123

    def study(self):
        print('好好学习，天天向上！')

调用对象方法（给对象发送消息）

s1 = Student('sag')
print(s1.name, s1.age, s1.tel)

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

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

s2 = Studet2('lishi', 12, 124532)
print(s2.name, s2.age, s2.tel)

03-self

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

class Person:
    def __init__(self,name = '', age = 0):
        # 声明对象属性
        self.name = name
        self.age = age

    def eat(self):
        print('eat food!')
    # 声明以对象方法run
    def run(self):

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

创建一个Person对象
p1 = Person('xiaoming', 10)


# 通过对象p1去调用run方法，系统会将self = p1
# 这个时候在run方法中，p1和self是同一个东西

p1.run()
print('p1', p1)


p2 = Person('xiaohong', 20)
p2.run()

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

from math import pi
class Circle:
    def __init__(self,radius1):
        self.radius = radius1

    def area(self):
        return self.radius**2*pi

    def perimeter(self):
        return self.radius*2*pi

c1 = Circle(3)
c1.area = c1.area()
c1.perimeter = c1.perimeter()
print('%.2f,%.2f'%(c1.perimeter, c1.area))

04-add,cut,change,find of attribute 属性的增删改查

class Dog:


    # Dog类有name 和 age 两个属性
    def __init__(self, name1, age1):
        self.name = name1
        self.age = age1
dog1 = Dog('cc', 2)

4.1.查

方式一：对象.属性
特点：如果属性存在就获取属性的值；如果属性不存在就会报AttributrError的错

方式二：getattr(对象.属性名,默认值) -->获取指定对象的指定属性
特点：
如果不设置默认值：属性存在就获取属性的值，不存在就报错
如果设置默认值：属性如果存在就获取属性的值：属性不存在的时候，不报错，将默认值作为结果

方式三：对象.getattribute__(属性名)
特点.获取指定对象的指定属性；如果属性不存在就会报错

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

print(getattr(dog1, 'score',100))
print(getattr(dog1, 'name', None))

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

4.2.改（修改）

方式1：对象.存在的属性 = 新值
方式2：setattr(对象，属性名，新值)
方式3：对象.__setattr__(属性名，新值)

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

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

4.3.增（添加属性）

python中可以动态的给对象添加属性

方式1：对象.不存在的属性 = 值
方式2：setattr(对象， 不存在的属性名， 新值)
方式3：对象.__setattr__(不存在的属性名，新值)

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

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

dog1.setattr('high', 2)
print(dog1.high)

4.4.删除属性

方式1：del 对象.属性
方式2: delattr(对象，属性名)
方式3：对象__delattr__('属性名')

# 将dog1的age属性删除
# del dog1.age
# print(dog1.age)     # AttributeError: 'Dog' object has no attribute 'age'
#
# delattr(dog1, 'name')
# print(dog1.name)    # AttributeError: 'Dog' object has no attribute 'name'

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

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

hasattr(对象，属性名）-->判断指定的对象是否拥有指定的属性

result = hasattr(dog1, 'age') #-->返回bool，的True,False
print(result)   # value: True

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

class Person:

    def __init__(self, name, age, 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)

del p1.name

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

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

示例2：

通过__slots__ 赋值，可以限制类中对象的属性有哪些，防止一个不必要的属性被添加

class Dog:
    '''狗'''
    __slots__ = ('name', 'age', 'color') #限定对象的属性名称和个数
    def __init__(self, name = '', age = 0, color = ''):
        self.name = name
        self.age = age
        self.color = color

dog1 = Dog('小黄', 3, 'Yellow')
# dog1.name1 = '大黄' # 输入错误导致，增加了新的属性
del dog1.name
print(hasattr(dog1, 'name'))    # value =False

注意：__slots__ = tuple中规定的属性，只能少不能多

05-built-in class attribute 内置类属性

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

    def run(self):
        print('%s run up'%(self.name))

    def shout(self):
        print('%s shout out '%(self.name))


dog1 = Dog()

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

1.类.name:获取类的名字(只有类有这个属性)

print(Dog.__name__,type(Dog.__name__))  # value:Dog 

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

print(Dog.__doc__)  # value：狗

3.dict:

类.dict：获取类中所有的类属性(类字段)和对应的值的键值对 -->结果是字典
对象.dict：以键值对的形式获取指定对象的所有的属性和值 -->结果是字典

print(Dog.__dict__)
# value：{'__module__': '__main__', '__doc__': '狗', '__init__': ,
# 'run': ,
# 'shout': , '__dict__': , '__weakref__': }
dog1.sex = '男'
print(dog1.__dict__)
#value：{'name': '', 'age': 0, 'color': '', 'dex': '男'}

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

print(Dog.__module__, type(Dog.__module__))
# value:__main__ 

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

print(Dog.__bases__, type(Dog.__bases__))
# value:(,)