01.recode
1.类和对象的概念
类：拥有相同的功能和相同属性的对象的集合
对象：类的实例
2.类的声明
class 类名：
类的内容
3.对象的创建
类（）
4.对象方法
a.直接声明在类中，并且自带一个self参数
b.通过对象来调用：对象.对象方法（）
c.通过对象调用的时候，self不需要传参，系统会将当前对象传给self
5.构造方法和init方法
方法名和类名相同的方法就是构造方法。专门用来创建对象的
当创建对象的时候，会自动调用init方法
6.对象属性
a.声明在init方法中
b.self.属性 = 值
c.对象.属性
7.对象属性的增删改查
对象.属性/ getattr（对象，'属性名'， 默认值）
对象.属性 = 值 / setattr（对象，'属性名'，值）
del 对象.属性 / delattr（（对象，'属性名'）
slots = ('属性名') - 约束当前类的对象有哪些对象属性
注意：如果给类的slots赋了值，那么这个类的对象的dict属性就不能用
8.类的字段
声明在类中，函数的外面的变量
# def Perosn(*args, **kwargs):
# 对象 = 开辟空间创建对象
# 对象.__init__(*args, **kwargs)
# return 对象
class Person:
# 注意: 如果给类的__slots__赋了值，那么这个类的对象的__dict__属性就不能用了
# __slots__ = ('name', 'age', 'sex')
def __init__(self):
self.name = '张三'
self.age = 18
self.sex = '男'
p1 = Person()
print(p1.__dict__)
p2 = Person()
p2.name = '李四'
print(p2.__dict__)
{'name': '张三', 'age': 18, 'sex': '男'}
{'name': '李四', 'age': 18, 'sex': '男'}
02.类方法和静态方法
类中的方法分为：对象方法，类方法和静态方法
1.对象方法
a.直接声明在类中
b.有默认参数self
c.通过对象去调用：对象.对象方法（）
2.类方法
a.在声明前添加@classmethod
b.有默认参数cls，调用的时候不需要cls传参。系统会自动将调用当前类方法的类传给cls。
cls最终指向的是一个类，类可以做的事情cls都可以做
c.通过类去调用：类.类方法（）
3.静态方法
a.在声明前添加@staticmethod
b.没有默认参数
c.通过类去调用：类.类方法（）
4.对象方法、类方法和静态方法的选择
a.什么时候使用对象方法：
当实现函数的功能需要用到对象的属性的时候就使用对象方法。
b.什么时候使用类方法：
实现函数的功能不需要用到对象的属性，但是需要类的时候，就使用类方法。
c.什么时候使用静态方法：
实现函数的功能既不需要对象的属性，也不需要类的时候，就使用静态方法。
class Person():
# 类的字段
num = 61
def __init__(self, name):
self.name = name
# 对象方法
def eat(self, food):
# print(Person.num)
print('%s在吃%s' % (self.name, food))
# 类方法
@classmethod
def destroy(cls):
# cls = Person
print('cls:',cls)
print('人类破坏环境')
# 可以用cls来创建对象
p1 = cls('小明')
p1.eat('面包')
# 可以用cls使用类的字段
print(cls.num)
# 可以用cls调用类相关的方法
# 静态方法
@staticmethod
def hit_animal():
print('人类殴打小动物!')
print(Person.num)
print('Person:', Person)
Person.destroy()
Person.hit_animal()
Person: <class 'main.Person'>
cls: <class 'main.Person'>
人类破坏环境
小明在吃面包
61
人类殴打小动物!
61
练习：
数学类，属性：pi 功能：求两个数的和, 求一个圆的面积
class Math:
pi = 3.1415926
@staticmethod
def sum(num1, num2):
return num1+num2
@classmethod
def circle_area(cls, r):
return cls.pi * (r ** 2)
# @staticmethod
# def circle_area(r):
# return Math.pi * (r ** 2)
class YTMath(Math):
pi = 3.14
print(Math.sum(10, 3.10))
print(Math.circle_area(2))
print(YTMath.circle_area(2))
13.1
12.5663704
12.56
03.私有化
1.私有化
在类中，可以通过在属性明前，或者方法名前加(两个下划线，注意：不能以结尾），那么这样的属性或者方法就会私有的，
私有的属性和方法在类的外部不能使用
class Person:
__num = 100 # 私有的属性
__number__ = 200 # 不是私有属性
def __init__(self):
self.name = '张三'
self.__age = 18
def __show_message(self):
print(Person.__num)
print('名字:', self.name, '年龄:', self.__age)
def func1(self):
self.__show_message()
# print(Person.__num)
p1 = Person()
print(p1.name)
# p1.__show_message()
p1.func1()
# print(p1.__age)
print(Person.__number__)
张三
100
名字: 张三 年龄: 18
200
2.私有化原理
python中没有真正的私有化，不能从访问权限上控制属性和方法的使用。
只是在名字前有__但是没有以__结尾的名字前再加了'_类名'，导致不能通过原属性和方法名进行访问。
class Dog:
def __init__(self, name, color):
self.__name = name
self.__color = color
dog1 = Dog('大黄', '黄色')
print(dog1.__dict__)
# print(dog1.__name, dog1.__color)
print(dog1._Dog__name)
{'_Dog__name': '大黄', '_Dog__color': '黄色'}
大黄
04.对象属性的getter和setter
1.getter和setter
如果希望在获取对象属性之前要做点儿别的事情，就给这个属性添加getter；
如果希望在给对象属性赋值之前做点儿别的事情，就给这个属性添加setter
2.给对象属性添加getter
a.属性命名的时候，属性名前加_; 例如：self._age = 0
b.声明一个函数，函数的名字是属性名(不要下划线),不需要额外参数,有返回值；并且函数前使用@property修饰。
这个函数的返回值就是获取属性的结果
例如：
@property
def age(self):
return 年龄相关值
c.当需要获取属性的时候通过对象.不带下划线的属性；例如：对象.age
3.给对象属性添加setter
想要给对象属性添加setter，必须先给它添加getter
a.属性命名的时候，属性名前加_; 例如：self._age = 0
b.声明一个函数，函数的名字是属性名(不要下划线)，需要一个额外的参数,不用返回值;
并且函数前使用@getter名.setter修饰
例如:
@age.setter
def age(self, value):
self._age = value
c.当需要给属性赋值的时候，通过对象.不带下划线的属性来赋值；例如: 对象.age = 100
class Person:
def __init__(self, name='小红'):
self.name = name
self._age = 60
self.sex = '男'
# 这儿的age函数就是属性_age的getter方法
@property
def age(self):
if self._age < 1:
return '婴儿'
elif self._age < 18:
return '未成年'
elif self._age < 50:
return '中年'
else:
return '老年'
# 这儿的age函数就是属性_age的setter
@age.setter
def age(self, value):
if not isinstance(value, int):
print('年龄必须是整数!!!!')
raise ValueError
if not (0 <= value <= 100):
print('年龄超出范围!!!!')
raise ValueError
self._age = value
p1 = Person()
# print(p1.age) # 希望取到的不是年龄值，而是年龄对应的阶段
# p1.age = '12' # 存 0
# p1.age = '100' # 150
# 这儿实质是在调用_age的getter方法
print(p1.age)
# 这儿实质是在调用_age的setter方法: p1.age(80)
p1.age = 80
老年
练习：声明一个时间类，有一个属性是以秒的形式保存时间
不断的输入时间，以'XX:XX'的形式输入。输入多少个时间就保存多少个时间对象。知道输入end为止
class Time:
def __init__(self):
self._second= 0
@property
def second(self):
return self._second
# '01:11 - 71'
@second.setter
def second(self, value: str):
times = value.split(':')
self._second = int(times[0])*60 + int(times[1])
补充：打印自己声明的类的对象的时候，默认打印的是：<模块名.类名 object at 对象地址>
如果不希望以默认的方式去打印对象，可以实现__repr__魔法方法。打印对象的时候就会打印这个方法的返回值.这个函数的返回值必须是字符串
def __repr__(self):
return '时间:'+ str(self.second)
"""
10:20 -> time.秒 = 620
1:20 -> time.秒 = 80
"""
times = []
while True:
value = input('时间:')
if value == 'end':
break
# 创建对象，并且将输入的内容赋给时间
t = Time()
t.second = value
times.append(t)
print(times)
时间:10:12
时间:06:15
时间:end
[时间:612, 时间:375]
class Student:
def __init__(self, name, age):
self.name = name
self.age = age
# def __repr__(self):
# return '[' + self.__class__.__module__+'.'+\
# self.__class__.__name__+' object at '+ hex(id(self))+']'
def __repr__(self):
# return 'name:%s, age:%d' % (self.name, self.age)
return str(self.__dict__)[1:-1]
stu1 = Student('小明', 29) # >>__main__.Student object at 0x1077a9550<<
stu2 = Student('小🌺', 18) # name:小🌺, age:18
print(stu1, stu2)
'name': '小明', 'age': 29 'name': '小🌺', 'age': 18
05.类的继承
1.继承
python中的类支持继承，并且支持多继承。
python中默认情况是继承自object（object是python中所有类的基类）
a.什么是继承
一个类可以继承另外一个类，继承者我们叫子类，被继承者叫父类。继承就是让子类直接拥有父类中的内容
b.可以继承哪些内容
所有的属性和方法都可以继承
class Person(object):
num = 61
# 注意：__slots__对应的值不会被继承
__slots__ = ('name', 'age', 'sex')
def __init__(self):
self.name = '张三'
self.age = 0
self.sex = '男'
def show_message(self):
print('%s你好吗?' % self.name)
# Student类继承自Person类
class Student(Person):
pass
# 创建学生对象
stu1 = Student()
# 对象属性可以继承
print(stu1.name, stu1.age, stu1.sex)
# 类的字段可以继承
print(Student.num)
# 对象方法可以继承
stu1.show_message()
p1 = Person()
# p1.color = '黄色'
stu1.color = '白色'
print(stu1.color)
张三 0 男
61
张三你好吗?
白色
06.添加方法
子类除了拥有从父类继承下来的属性和方法，还拥有属于自己的属性和方法
1.在子类中添加方法
a.添加一个新的方法
直接在子类中声明其他的方法;
添加后子类可以调用自己的方法也可以调用父类的方法，但是父类不能调用子类的方法
b.重写父类的方法: 重新实现父类的方法
完全重写 - 覆盖父类的功能 - 直接在子类中重新实现父类的方法
部分重写 - 保留父类的功能，添加新的功能 - 在子类中实现父类方法的时候通过super()去调用父类的方法，再添加新的功能
注意：a.可以子类的方法中通过super()去调用父类的方法
super(类, 对象) - 获取对象中父类的部分(要求对象是这个指定的类的对象)
b.静态方法中不能使用super()
c.类中方法的调用过程
通过对象或者类调用方法的时候，先看当前类中是否声明过这个方法，如果声明过就直接调用当前类对应的方法;
如果当前类中没有声明过，会去找父类中有没有声明过这个方法，声明过就调用父类的方法;
如果父类中也没有声明过，就去找父类的父类...以此类推，直到object中也没有声明过，程序才会崩溃
class Person:
# 类的字段
num = 61
# 对象属性
def __init__(self):
self.name = '张三'
self.age = 0
self.sex = '男'
def fun1(self):
print('Person的对象方法')
# 方法
def show_message(self):
print('%s,你好吗？' % self.name)
@staticmethod
def info():
print('我是人类')
class Student(Person):
def study(self):
print('%s在学生' % self.name)
@classmethod
def message(cls):
super().info()
print('我是学生!')
# 完全重写
@staticmethod
def info():
print('我是学生！！！')
# 保留父类的功能
def show_message(self):
super().show_message()
print('我去上学~')
super().fun1()
07.添加属性
1.添加类的字段
直接在子类中添加新的字段
2.添加对象属性
继承对象属性是通过继承父类的init方法继承下来的
如果想要在保留父类继承下来的对象属性的前提下，添加新的对象属性，
需要在子类的init方法中，通过super()去调用父类的init方法
class Person:
num = 61
def __init__(self, name):
self.name = name
self.age = 0
class Student(Person):
number = 100
def __init__(self, name):
super().__init__(name)
self.study_id = '001'
print(Student.number, Student.num)
stu1 = Student('小明')
print(stu1.name, stu1.age, stu1.study_id)
100 61
小明 0 001
练习：
1.声明一个动物类，有属性：年龄，颜色，类型。
要求创建动物对象的时候类型和颜色必须赋值，年龄可以赋值也可以不赋值
2.声明一个猫类，有属性:年龄，颜色，类型, 爱好
要求创建猫对象的时候，颜色必须赋值，年龄和爱好可以赋值也可以不赋值，类型不能赋值
class Aniaml:
def __init__(self, type, color, age=0):
self.type = type
self.color = color
self.age = age
class Cat(Aniaml):
def __init__(self, color, age=0, hobby=''):
super().__init__('猫科', color, age)
self.hobby = hobby
an1 = Aniaml('犬科', '黄色')
an2 = Aniaml('犬科', '黄色', 10)
cat1 = Cat('白色')
cat2 = Cat('灰色', 3)
cat3 = Cat('灰色', hobby='睡觉')
cat4 = Cat('灰色', 3, '睡觉')
网友评论