一、类的定义
类:具有相同属性和功能的的对象的集合
对象:类的实例；具体的
1.类的声明
class 类名(父类):
属性
方法
class 类名:
属性
方法
class:python中声明类的关键字
类名:标识符；首字母大写；见名知义
属性:分类的字段和对象的字段 ---->属性
方法:类方法、静态方法、对象方法(构造方法) ---->功能
方法:就是声明在类中的函数(都有一个默认参数，不需要调用的时候传值)
对象方法:在类中直接声明的函数都是对象方法，必须带参数self，对象方法必须使用对象来调用
声明类
class Person:
"""人类""" # 类的说明文档
# 在类中声明里eat方法，默认了有一个参数self，调用eat方法时，不需要给self传参
# 在类中直接声明的函数都是对象方法，对象方法必须使用对象来调用
# 直接写在类中的函数，必须带参数self，使用对象调用
def eat(self):
print('吃饭')
# 注意:如果要在类中声明带参的对象方法，其他的参数必须写在self的后面
def run(self, num1):
print('跑了%d米' % (num1))
创建对象
p1就是Person类的一个对象(实例)
可以通过对象去调用类中的对象方法、和使用类中声明的对象属性(字段)
p1 = Person()
调用对象方法
p1.eat()
p1.run(100)
一个类可以创建多个对象
p2 = Person()
p2.eat()
p2.run(90)
二、类的对象属性和init方法
class 类名:
属性
方法
1.实例一:init方法会自动调用
class Person:
# __init__方法又叫构造方法，是在通过类创建对象的时候，自动调用的方法
# __init__方法的作用就是在创建对象的时候初始化对象的属性
# __init__对象的属性就是声明在这个方法中
def __init__(self):
# 在这个地方声明对象的属性
print('这是init')
# 在声明对象的时候会自动调用init方法
p1 = Person() # 直接会调用：这是init
2.实例二:带参的init方法
class Dog:
"""狗"""
# init的方法的方法名固定:__init__。但是参数是可以随意改变的(但是self参数不变)
def __init__(self, name):
print('名字是:%s' % (name))
# 通过类创建对象的时候，要保证init方法里面的每一个参数都有值。通过给类名后面的括号里传参来保证
dog1 = Dog('旺财')
3.例三:对象属性
属性:声明在类中的变量
对象属性:要通过对象去使用，不同的对象可能会有不同的值；声明在init方法中的变量
class Person2:
"""人类"""
# 在init方法中声明对象属性:self.属性名 = 初值
def __init__(self):
# 声明了一个对象属性name，初始值为空串
self.name = '无名氏'
# 声明了一个对象属性age，初始值为10
self.age = 10
p2 = Person2()
print(p2.name) # 无名氏
# 通过p1对象去修改p1的name属性
p2.name = '小明'
# 通过对象去使用对象属性
print(p2.name) # 小明
练习:声明一个学生类，拥有属性:名字、年龄、电话。拥有方法:学习
class Student:
"""学生"""
def __init__(self):
self.name = '输入名字'
self.age = 0
self.tel = '123456'
def study(self):
print('好好学习，天天向上')
p3 = Student()
print(p3.name, p3.age, p3.tel)
# 调用对象方法(给对象发送消息)
p3.study()
4.实例四:创建对象的时候赋初值
class Student1:
"""学生"""
def __init__(self, name='', age1=0, tel1=''):
self.name = name
self.age = age1
self.tel = tel1
# 在创建对象的时候给对象属性赋初值
p4 = Student1('小明', 18, '112')
print(p4.name)
三、self
类中的对象方法都有一个默认参数self:
1.调用带有默认参数self的方法，不需要给self传参。系统会自动将调用当前方法的对象传给self
2.在方法中使用self就相当于使用调用方法的对象(只能使用self的值，不能重新给self赋值)
class Person:
"""人类"""
# 声明一个对象属性
def __init__(self, name='', age=0):
self.name = name
self.age = age
# 声明一个对象方法run
def run(self):
print('self', self)
# 在对象方法中使用对象的属性，直接用self去获取属性
print('%s跑起来' % (self.name))
创建一个Person对象
p1 = Person('小明', 10)
通过对象p1去调用run方法，系统会将self=p1
这个时候在run方法中，p1和self是一个东西
p1.run() # self <__main__.Person object at 0x034201D0> 小明跑起来
print('p1', p1) # p1 <__main__.Person object at 0x034201D0>
声明一个圆类，拥有属性:半径 拥有方法:计算圆的面积、计算圆的周长
from math import pi
class Circle:
"""圆"""
def __init__(self, radius=1):
self.radius = radius
def acreage(self):
# %.2f是保留两位小数
print('%.2f' % (pi*(self.radius**2)))
def perimeter(self):
print('%.2f' % (2*pi*(self.radius)))
p2 = Circle(10)
p2.acreage()
p2.perimeter()
四、属性的增删改查
class Dog:
"""狗"""
def __init__(self, name='', age=0):
# Dog类有name和age两个属性
self.name = name
self.age = age
dog1 = Dog('旺财')
1.查
方式1:对象.属性
特点:如果属性存在就获取属性值，如果不存在就会报错AttributeError
方式2:getattr(对象，属性名，默认值)-->获取指定对象的指定属性(属性名是填字符串)
a.如果不设置默认值:属性如果存在就获取属性的值，不存在就报错
b.如果设置默认值:属性如果存在就获取属性的值，属性不存在的时候，不会报错，并将默认值作为结果
方式3:对象.getattribute(属性名)-->(属性名是填字符串)
获取指定对象的指定属性，如果属性不存在就会报错
print(dog1.name)
# print(dog1.colo) 报错AttributeError: 'Dog' object has no attribute 'colo'
print(getattr(dog1, 'name', None))
print(getattr(dog1, 'score', 100)) # print->100
print(dog1.__getattribute__('name'))
# print(dog1.__getattribute__('sex')) 报错AttributeError: 'Dog' object has no attribute 'sex'
2.改：修改
方式1:对象.属性 = 新值
方式2:setattr(对象，属性名，新值)-->属性名是字符串
方式3:对象.setattr(属性名，新值)-->属性名是字符串
dog1.name = '大黄'
print(dog1.name) # 大黄
setattr(dog1, 'name', '小黄')
print(dog1.name)
dog1.__setattr__('name', '小黑')
print(dog1.name)
3.给对象添加属性(增)
python中可以动态的给对象添加属性
方式1:对象.不存在的属性 = 值
方式2:setattr(对象，不存在的属性名，新值) -->属性名是字符串
方式3:对象.setattr(不存在的属性名，新值)-->属性名是字符串
dog1.sex = '男'
print(dog1.sex)
setattr(dog1, 'score', 100)
print(dog1.score) # 100
dog1.__setattr__('boddy', '玩')
print(dog1.boddy)
4.删除属性
方式1:del 对象.属性
方式2:delattr(对象，属性名)-->属性名是字符串
方式3:对象.delattr(属性名)-->属性名是字符串
将dog1的age属性删除
del dog1.age
# print(dog1.age) # AttributeError
delattr(dog1, 'age')
# print(dog1.age) # AttributeError
dog1.__delattr__('age')
# print(dog1.age) # AttributeError
5.判断对象是否拥有某个属性
方式1:hasattr(对象，属性名)--判断指定的对象是否有指定的属性,打印出来是布尔值
a = hasattr(dog1, 'age')
print(a, type(a)) # True <class 'bool'>
六、练习
import json
# 获取json文件
def student():
with open('student.json', 'r', encoding='utf-8') as f:
return json.load(f)
# print(student())
class Person:
"""人物"""
__slots__ = ('name', 'age', 'sex')
def __init__(self, name='', age=0, sex=''):
self.name = name
self.age = age
self.sex = sex
# 通过实现这个方法去设置打印对象的内容（默认打印对象在内存中的地址）
def __str__(self):
return self.name+str(self.age)+self.sex
def main():
# 获取json文件中的内容，结果是一个列表
all_studnet = student()
# print(all_studnet, type(all_studnet))
# 遍历列表拿到里面的每一个字典
clube = []
for item in all_studnet:
# 方式一：
# 拿到一个字典就创建一个对象
# 将字典中的每个键值对对应的值存到对象对应的属性中
# p1 = Person(item['name'], item['age'], item['sex'])
# clube.append(p1)
# 方式二：
# 拿到一个字典就创建一个对象
p = Person()
for key in item:
# print(key, type(key))
setattr(p, key, item[key])
clube.append(p)
# 打印对象是默认打印的对象的地址
# print(clube)
for item in clube:
print(item)
if __name__ == '__main__':
main()
七、内置类函数
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__
print(class_name, type(class_name)) # Dog <class 'str'>
2.doc:获取类的说明文档
x = Dog.__doc__
print(x, type(x)) # 狗 <class 'str'>
3.dict
类.dict:获取类中所有的类属性(类字段)和对应的值的键值对-->结果是字典
对象.dict:以键值对的形式获取指定对象的所有的属性和值-->结果是字典
print(Dog.__dict__)
print(dog.__dict__)
4.module:获取类所在的模块的名字
print(Dog.__module__, type(Dog.__module__)) # __main__ <class 'str'>
5.类.bases:获取指定类的基类
print(Dog.__bases__) # (<class 'object'>,)
