一、内置内属性
1、类.name---->获取类的名字（字符串）
2、类.doc------>获取说明文档
3、类.dict 获取类中所有的类属性和对应的值，以键值对的形式存在字典中
对象.dict 将对象的属性和对应的值，转换为字典的元素（常用，记住）
4、类.module---->获取当前类所在的模块的名字
5、类.bases------>获取当前类的父类
class Animal:
pass
class Tiger(Animal):
"""老虎类"""
def __init__(self):
self.color = ''
self.size = ''
self.breed = ''
def character(self):
print('老虎很牛逼！')
tiger = Tiger()
print(Tiger.__name__)
print(Tiger.__doc__)
print(Tiger.__dict__)
print(tiger.__dict__)
print(Tiger.__module__)
print(Tiger.__bases__)
结果：Tiger
老虎类
{'__module__': '__main__', '__doc__': '老虎类', '__init__': <function Tiger.__init__ at 0x00000047D9008B70>, 'character': <function Tiger.character at 0x00000047D9008BF8>}
{'color': '', 'size': '', 'breed': ''}
__main__
(<class '__main__.Animal'>,)
二、私有化
python中类中的属性和方法的私有化：直接在属性名或者方法名前(命名的时候以''开头）
属性或者方法私有：在外部不能直接使用,可以在类的内部使用
class Tiger:
"""老虎类"""
__number = 100
def __init__(self):
self.__color = 'yellow'
self.size = ''
self.breed = ''
def __character(self):
print('老虎很牛逼！')
@classmethod
def __eat(cls):
print('有%d只老虎' % cls.__number)
@staticmethod
def __fight():
print('所有的老虎都喜欢打架！')
tiger = Tiger()
print(Tiger.__number) #只要是私有化的属性和方法，外部都不能直接访问，只能在内部使用
print(tiger.__color)
print(tiger.__character())
print(Tiger.__eat())
print(Tiger.__fight())
三、getter和setter
属性假的私有化：声明对象属性的时候，在属性名前面加一个'_'，来告诉别人这个属性不可以直接使用，要通过getter和setter来获取属性的值和修改属性的值
1.getter:获取属性的值
@property
def 属性名(去掉下划线)(self)
return 返回值
如果在获取对象的某个属性前需要再干点别的事情，就给这个属性添加getter
- setter:给属性赋值
一个属性必须要有getter，才能添加setter.
@s属性名(去掉下划线的).setter
def 属性名去掉下划线(self,变量名):
给带下划线的属性赋值
如果在给对象的某个属性赋值前需要在干点别的事情，就给这个属性添加setter
import json
class Student:
"""学生类"""
def __init__(self):
# 声明属性的时候前面加一个'_'是为了告诉别人这个属性不能直接使用
self._name = ''
self._score = 0
self._age = 0
# 给属性_name添加getter
@property
def name(self):
return self._name
#给属性_name添加setter
@name.setter
def name(self, value):
self._name = value
@property
def score(self):
return self._score
@score.setter
def score(self,value):
self._score = value
@property
def age(self):
return str(self._age)+'岁'
@age.setter
def age(self,age):
if age >= 150 or age < 0:
print('赋值有误,age要求在0-150之间')
# raise 抛出异常
# raise ValueError
self._age = None
return
self._age = age
if __name__ == '__main__':
stu1 = Student()
# 不添加getter和setter
# stu1._name = '张三'
# print(stu1._name)
# 添加_name的getter和setter
stu1.name = '李四'
print(stu1.name)
stu1.age = 1000
print(stu1.age)
stu1.age = 20
print(stu1.age)
**总结：getter:在获取对象的某个属性前，可以干点别的事情
setter：在给对象的某个属性赋值前，可以干点别的事情
如果要有setter，必须现有getter
四、获取数据练习
import json
def download_data():
with open('./data.json','r',encoding='utf-8') as f:
content = json.load(f)
return content['data']
class Data:
"""数据类"""
def __init__(self):
self.type =''
self.text = ''
self.user_id = ''
self.name = ''
self.screen_name = ''
self._width = ''
self._height = 0
self._themes = None
@property
def width(self):
return self._width
@width.setter
def width(self,width):
self._width = int(width)
@property
def height(self):
return self._height
@height.setter
def height(self, height):
self._width = int(height)
@property
def themes(self):
if not self._themes:
return '无'
return self._themes
# 根据字典创建对象
@classmethod
def creat_data(cls,dict1):
data = cls()
for key in dict1:
if key == 'width':
data.width = dict1[key]
if key == 'height':
data.height = dict1[key]
if key == 'themes':
data._themes = dict1[key]
continue
data.__setattr__(key,dict1[key])
return data
if __name__ == '__main__':
print(download_data())
datas = []
for dict1 in download_data():
# 通过字典创建对象
data = Data.creat_data(dict1)
# 将创建的对象存起来
datas.append(data)
print(datas[0].width)
五、类的继承
子类：继承者
父类(超类)：被继承者
1.继承基础
python中类是可以继承的，并且支持多继承
class 类名(父类列表):
'''类的说明'''
属性
方法
说明：python中所有的类都默认继承python的基类：object
2.能继承那些内容
继承：直接拥有父类的属性和方法(继承后父类的属性和方法还是存在的)
a.对象的属性和方法、类的字段和类方法、静态方法都可以继承（私有的继承无意义----不能继承）
b.slots的值不会被继承
c.getter和setter会被继承
作业
0.定义一个学生类。有属性：姓名、年龄、成绩（语文，数学，英语)[每课成绩的类型为整数]
方法：
a. 获取学生的姓名：get_name()
b. 获取学生的年龄：get_age()
c. 返回3门科目中最高的分数。get_course()
class Scores:
def __init__(self):
self.chinese = int(input('chinese：'))
self.math = int(input('math：'))
self.english = int(input('english:'))
dict1 = Scores().__dict__
class Student:
def __init__(self,name = '',age = 0,scores = ''):
self.name = name
self.age = age
self.scores = scores
def get_name(self):
return ('%s' % self.name)
def get_age(self):
return ('%d' % self.age)
def get_course(self):
list1 = []
for value in dict1.values():
list1.append(value)
return max(list1)
stu = Student('张飞',2,dict1)
print(stu.get_course())
1.建立一个汽车类Auto，包括轮胎个数，汽车颜色，车身重量，速度等成员变量，并通过不同的构造方法创建实例。至少要求 汽车能够加速 减速 停车。 再定义一个小汽车类CarAuto 继承Auto 并添加空调、CD等成员变量 覆盖加速 减速的方法
class Auto:
def __init__(self,tyre,color,weight,speed):
self.tyre = tyre
self.color = color
self.weight = weight
self._speed = speed
@property
def speed(self):
return self._speed
@speed.setter
def speed(self,speed):
if speed > self._speed:
print('加速')
elif speed < self._speed:
print('减速')
else:
print('停车')
auto1 = Auto(4,'black',5000,100)
class CarAuto(Auto):
def __init__(self):
self.air_conditioner = ''
self.CD = ''
self.__speed = ''
2.创建一个名为User 的类，其中包含属性first_name 和last_name ，还有用户简介通常会存储的其他几个属性。在类User 中定义一个名 为describe_user() 的方法，它打印用户信息摘要;再定义一个名为greet_user() 的方法，它向用户发出个性化的问候。
class User:
first_name = ''
last_name = ''
def __init__(self):
self.name = ''
self.age = 0
def describe_user(self):
print('%s %d' %(self.name,self.age))
@staticmethod
def greet_user():
print('send message to %s' % (User()) )
class Admin(User):
privileges= ["can add post","can delete post","can ban user"]
@classmethod
def show_privileges(cls):
print(cls.__dict__)
3.创建一个Person类，添加一个类字段用来统计Perosn类的对象的个数
class Person:
number = 0
def __init__(self):
Person.number += 1
网友评论