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 <class 'str'>
2.类.doc：获取类的说明文档
print(Dog.__doc__) # value：狗
3.dict:
类.dict：获取类中所有的类属性(类字段)和对应的值的键值对 -->结果是字典
对象.dict：以键值对的形式获取指定对象的所有的属性和值 -->结果是字典
print(Dog.__dict__)
# value：{'__module__': '__main__', '__doc__': '狗', '__init__': <function Dog.__init__ at 0x021AB858>,
# 'run': <function Dog.run at 0x021AB810>,
# 'shout': <function Dog.shout at 0x021AB7C8>, '__dict__': <attribute '__dict__' of 'Dog' objects>, '__weakref__': <attribute '__weakref__' of 'Dog' objects>}
dog1.sex = '男'
print(dog1.__dict__)
#value：{'name': '', 'age': 0, 'color': '', 'dex': '男'}
4.类.module:获取类所在的模块的名字
print(Dog.__module__, type(Dog.__module__))
# value:__main__ <class 'str'>
5.类.bases:获取指定类的基类
print(Dog.__bases__, type(Dog.__bases__))
# value:(<class 'object'>,) <class 'tuple'>
