011 - 类与对象

> i 第一天：我们开辟了空间（安装Python和相关环境）
第二天：我们创造了元素（了解相关的数据类型和操作方法）
第三天：我们领悟了法则（基本的循环、判断逻辑）
第四天：我们分隔了星球（封装函数模块）
 
那么第五天，我们将开始演化生命（类与对象）

---

# 类的概念

> Python是一门面向对象语言，支持面向对象的风格，或代码封装在对象的编程技术

![类](/media/202202//1643696555.4651895.png)

- 类: 是一个`抽象的`， `没有实体`的族群模板
- 对象: 是根据这个模板创建的`实例` --> 女娲造出来的一个个人
- 属性: 给这个类设定的一些特征 --> 写在DNA里面的族群信息
- 方法：给这个类定义的一些行为模式 --> 吃喝拉撒

> i 如果定义一个会自己创造方法的方法，或改写自己属性的方法，是不是就相当于这个类可以发生自我进化呢

---

# 类的样式

> i 下面我们就来试着捏一个人

```python
#!/usr/bin/python
# -*- coding: UTF-8 -*-
class Human():
	"""
	创造一个类：人类
	"""
	def __init__(self,name,age,gender,weight,height,state,life_span):
		"""
		定义这个类的基本属性：姓名、年龄、性别、体重、身高、状态、寿命年限
		"""
		self.name = name
		self.age = age
		self.gender = gender
		self.weight = weight
		self.height = height
		self.state = state
		self.life_span = life_span
	def grow_up(self):
		"""
		定义一个方法：成长，如果状态不等于死亡，则年龄每次增加一年
		"""
		if self.state == 'death':
			return self
		self.age += 1
		return self
	def death(self):
		"""
		定义一个方法：死亡，把实例状态修改为死亡
		"""
		self.state = 'death'
		return self
```
调用这个类创造实例，并调用类的方法
```python
# 创建一个实例：伏羲，0岁，男性，体重5斤，身高30cm，刚出生状态有点饿，寿命年限100
human1 = Human('伏羲', 0, 'male', '5', 30, 'hungry', 100)

# 尝试调用这个类的方法成长
# human1.grow_up()
# print(human1.age)

for year in range(0,1000):
	'从创世开始发展1000年，中途未设置其他条件默认良好生长，每年增加一岁'
	human1.grow_up()
	'如果年龄达到大限之后，修改状态为死亡'
	if human1.age == human1.life_span:
		human1.death()

# 最后我们打印年龄可以看到，在死亡之后，他的年龄就被冻结了
print(human1.age)
>>>100
```

---

# 类的增删改查

#### 查-访问实例对象

> 对实例对象进行操作（修改），要基于先访问这个对象

> 通过遍历`gc.get_objects()`获取这个类的所有实例对象
```python
import gc
class Human(object):
    def __init__(self, name):
        self.name = name
human1 = Human('1')
human2 = Human('2')

for obj in gc.get_objects():
 if isinstance(obj, Human):
 print(obj)
>>><__main__.Human object at 0x030B9E90>
<__main__.Human object at 0x030B9FD0>
```

> 通过属性名访问类的属性

`human1.name`

```python
import gc
class Human(object):
    def __init__(self, name):
        self.name = name
human1 = Human('1')
human2 = Human('2')

for obj in gc.get_objects():
    if isinstance(obj, Human):
        print(obj.name)
>>>1
2
```

#### 改-修改实例对象

> 如果加上其他属性作为判断条件，就可以找到对应属性的实例对象的列表，并访问修改他们的属性值

`human1.name = '伏羲'` 把新的属性重新赋予指定的实例对象空间

#### 增-创建实例对象

> 直接写入属性

`human1 = Human('伏羲', 0, 'male', '5', 30, 'hungry', 100)`

> 创建实例后写入属性

```python
human1 = Human()
human1.name = '伏羲'
human1.age = 0
human1.gender = 'male'
human1.weight = 5
human1.height = 30
human1.state = 'hungry'
human1.life_span = 100
```

#### 删-删除实例对象

`del human1`

---

# 修饰符@

> i `@`修饰符，必须出现在函数定义前一行，不允许和函数定义在同一行

|写法|对错|
|----|----|
|`＠A def f():`|✖|
|`＠A` `def f():`|✔|

> i 只可以在模块、或类定义层内对函数进行修饰，不允许修修饰一个类

|写法|对错|
|----|----|
|`＠A class F():`|✖|
|`class F():` &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`＠A` &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`def f():`|✔|

>  一个修饰符就是一个函数，它将被修饰的函数做为参数，并返回修饰后的同名函数或其它可调用的东西

```python
def modifier(function):
	print('这里是被修饰符回调的函数modifier()')
	return function()

@modifier
def method():
	print('这里是使用了修饰符的函数method()')

>>>这里是被修饰符回调的函数modifier()
这里是使用了修饰符的函数method()

```

> 本质上讲，装饰符`@`类似于回调函数
把其它的函数（暂且称为目的参数）作为自己的入参，在目的函数执行前，执行一些自己的操作

```python
def modifier(function):
	print('这里是被修饰符回调的函数modifier()')
	return

@modifier
def method():
	print('这里是使用了修饰符的函数method()')

>>>这里是被修饰符回调的函数modifier()
```

> i 当用了修饰符但没设置返回值时，下面的函数没有被返回，即等效于`modifier(method())`，外面的函数没有返回执行里面的函数

---

# 类的继承

### 具体写法

> 一、子类需要关联父类，并声明继承自父类的属性

`class NewHuman(Human):`

`super().__init__(name,age,gender,weight,height,state,life_span)`

> 二、子类需要声明自己独有的属性

`self.superpower = superpower`

> 三、子类如果对父类继承来的方法有改动需要重写声明一个同名方法

`def grow_up(self):`

> 四、子类可以调用父类的方法，但父类无法调用子类的方法

### 写一个子类：新人类
```python
class NewHuman(Human):
	# 定义一个新人类，觉醒了superpower，omega表示超能力的能级
	def __init__(self,name,age,gender,weight,height,state,life_span,superpower,omega):
		super().__init__(name,age,gender,weight,height,state,life_span)
		self.superpower = superpower
		self.omega = omega
	def grow_up(self):
		"""
		重写了父类的生长方法，觉醒超能力的代价是更快衰老，且能级越高衰老越快：self.age += (self.omega + 1)
		"""
		if self.state == 'death':
			return self
		self.age += (self.omega + 1)
		return self
	def show_power(self):
		"""
		用打印自己的能力表示使用这种能力，并且可以设定每次使用这种能力都会消耗一定寿命
		"""
		print(self.superpower)
		self.age = self.age + self.omega
		if self.age >= self.life_span:
			death(self)
		return self
```
### 操作子类实例对象

> i 定义一个实例对象，并写一定的规则演化他的一生

```python
newhuman1 = NewHuman('狗蛋',10,'male', '30', 120, 'teen', 100, '释放高热', 3)

import random
for year in range(0,100):
	'从狗蛋觉醒后开始发展100年，他每年使用超能力的概率是随机的'
	are_use = random.choice('01')
	if are_use == '1':
		print('-'*50 + '\n第'+str(year+1) +'年，他使用了超能力')
		newhuman1.show_power()
		print('他的寿命剩余：',newhuman1.life_span - newhuman1.age)
	newhuman1.grow_up()
	'如果年龄达到大限之后，修改状态为死亡'
	if newhuman1.age >= newhuman1.life_span:
		newhuman1.death()
	if newhuman1.state == 'death':
		print('-'*50 + '\n第'+str(year+1) +'年，他死亡了')
		break
>>>
```

```python
--------------------------------------------------
第2年，他使用了超能力
释放高热
他的寿命剩余： 83
--------------------------------------------------
第6年，他使用了超能力
释放高热
他的寿命剩余： 64
--------------------------------------------------
第8年，他使用了超能力
释放高热
他的寿命剩余： 53
--------------------------------------------------
第13年，他使用了超能力
释放高热
他的寿命剩余： 30
--------------------------------------------------
第15年，他使用了超能力
释放高热
他的寿命剩余： 19
--------------------------------------------------
第19年，他死亡了
```