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__)