Python学习笔记(四)

## class 类与对象
`类和函数佷相似，类是定义一个对象，函数是定义个处理过程`
![](/media/202208/image-610272cf560a44a98ad09caec2693607.png)

### 征途第一站：“类”
```
#直接运行代码
print(type('666'))  # <class'str'>
print(type(6666))  # <class'int'>
print(type([6666])) #<class'list'>
```
![](/media/202208/image-aa3233cc5f8f443289678dcb94a1c8d7.png)
'666'属于'str'字符串类；6666属于'int'整数类；[6666]属于'list'类
你的iphone手机与我的android手机，都属于手机类；岳云鹏与郭麒麟，都属于明星类；隔壁老樊与张碧晨，都属于歌手类。
520、1314都是整数类；3.1415926、9.85都属于浮点数类；'hi'、'hello'都属于字符串类。
![](/media/202208/image-15771f5b55044fad98ec51ea8f611752.png)

### 一切皆“对象”
![](/media/202208/image-89e3a2e040594a60b1a0e9cc3d61f574.png)
所有的事物都称为对象， 对象包含类与实例；也就是说，类叫做对象，实例也叫做对象。比如str是类对象，'hello’就是实例对象。 一切皆对象。

## 创建类与调用类
### 我们都是音乐人
1. 用来描述事物性质的，比如：喜欢音乐、艺名
2. 用来描述事物能做什么，比如：会唱歌、能跳舞
`第一种共同点称为属性(what)，第二种共同点称为方法(how)`
每个类都有自己的独特的属性attribute和方法method，是这个类的所有实例都共享的。换言之，每个实例都可以调用类中所有的属性和方法。
![](/media/202208/image-15771f5b55044fad98ec51ea8f611752.png)

### 类的创建
![](/media/202208/image-f0d7e78f6968444384f78b76bf398a31.png)

```
class Star:
    glasses = "墨镜"
    def photo(self):
        print("与粉丝拍照")
```
![](/media/202208/image-f1ec9ac7200e4c8c8f4b47646428c8a6.png)
像之前的函数一样，如果只完成创建，是不会有任何内容输出的。同样，类也如此。

### 类的调用
![](/media/202208/image-e2465d6c8a6a441d81ee4a63f3607ed1.png)

```
class Musician:
    loveMusic = True
    
    def sing(self):
        print('我在唱歌')
laoFan = Musician()
print(laoFan)
print(type(laoFan))
```
![](/media/202208/image-6820d93a6d9a4055bede9a05f4a12ec3.png)
> 第一行，<__main__.Musician object at 0x00000215D560FCC0>(备注：at后的内容可能不一致，这属于正常现象，每个人的电脑不同)就是通过Musician这个类创建的laoFan这个实例，这是这个实例在电脑上中的内存地址；
> 第二行说明了laoFan这个实例属于Musician这个类。

```
class Musician:
    loveMusic = True
    
    def sing(self):
        print('我在唱歌')
laoFan = Musician()
print("音乐人老樊")
print(laoFan.loveMusic)
laoFan.sing()
```
![](/media/202208/image-eee5f695d57546dbbb658792d05089af.png)
> 通过print(laoFan.loveMusic)这句代码，打印出了True这个结果。这就是调用类的属性。 首先通过laoFan.loveMusic获取到属性loveMusic的值True，再使用print()函数打印出来。
> 通过laoFan.sing()这句代码，调用了类方法sing()，直接打印出“我在唱歌”。

* 调用类属性： 实例名.属性名
* 调用类方法： 实例名.方法名()

```
class Musician:
    loveMusic = True
    
    def sing(self):
        print('我在唱歌')
laoFan = Musician()
print("音乐人老樊")
print(laoFan.loveMusic)
laoFan.sing()
diamond = Musician()
print("音乐人张碧晨")
print(diamond.loveMusic)
diamond.sing()
```
![](/media/202208/image-fda72561616a4033a1748f31be414f00.png)
通过Musician这一个类，可以创建多个实例

## 创建类的两大要素
### 揭秘self参数
self的作用：self会在类的实例化中接收传入的数据， 在代码中运行。
```
class Musician:
    name = '羽泉'
    
    def sing(self,person):
        print(person+'是音乐人')

singer = Musician()
print(singer.name)
singer.sing('羽泉')
```
![](/media/202208/image-a1c7ed70ceeb49699bb812757602b245.png)
内部属性调用在传递

```
class Musician:
    name = '羽泉'
    
    def sing(self):
        print(self.name+'是音乐人')

singer = Musician()
print(singer.name)
singer.sing()
```
![](/media/202208/image-243af7e7720042fb9e5dd9531ad7d4d1.png)
内部属性可以直接调用，而不用再传递一遍

```
class Musician:
    name = '羽泉'
    
    def hello(self):
        print('hello,大家好')
    
    def sing(self):
        self.hello()
        print(self.name+'是音乐人')

singer = Musician()
singer.sing()
```
![](/media/202208/image-a3d921f588974a93b86dc84c033ceaeb.png)
`类方法中调用类内部属性或者是其他方法时，需要使用 self 来代表实例`

### 初始化方法
`每个类中都存在一个初始化方法，这个方法不需要调用，在通过类创建实例对象的时候初始化方法会自动执行`
`定义初始化方法：def __init__(self): ，init两边是双下划线(两个下划线)`
```
class Musician:
    def __init__(self):
        print('你好,这里是初始化方法init')
liRongHao = Musician()
```
![](/media/202208/image-e65481d3b2a0498fb4348d222dada852.png)
创建了liRongHao = Musician() 这个实例，init初始化方法就自动执行了

```
class Musician:
    def __init__(self):
        self.glass = "墨镜"
        self.microphone = "many"
    def intr(self):
        print('我出门必须戴%s' %self.glass)
        print('我有%s个麦克风' %self.microphone)
silence = Musician()  
silence.intr()
```
![](/media/202208/image-89bba15635f340d9ba0018d7518bd888.png)
利用init初始化方法的特点，我们可以在初始化方法中完成类属性的创建及类属性的赋初值
初始化方法中，除了可以设置固定值之外，还可以接收其他参数，使得传入的数据灵活多变

```
class Musician:
    def __init__(self,name,anotherName,music):
        self.name = name
        self.anotherName = anotherName
        self.music = music
    def intr(self):
        print('各位歌迷好,我是%s' %self.name)
        print('熟悉我的朋友都叫我%s' %self.anotherName)
    def sing(self):
        print('我为大家唱一首%s' %self.music)
jam = Musician('萧敬腾','雨神','王妃')  
jam.intr()
jam.sing()
```
![](/media/202208/image-73b5d66c2cfa4946b9eb4f371185cb78.png)
通过init初始化方法，传入多个参数
__init__(self,name,anotherName,music)与Musician('萧敬腾','雨神','王妃')。大家会发现，定义初始化方法中，拥有self,name,anotherName,music四个参数，在类创建实例的时候，只传入了三个参数。
这是因为`self属性只会在方法创建的时候出现，方法调用时就不需出现了`
这里参数'萧敬腾','雨神','王妃'会与name,anotherName,music一一对应

## 面向对象编程
原快递计算程序由函数改成类
```
import math
class Program:
        def __init__(self):
            self.key = 1
        
        # 工时计算
        def BOSS_input(self):
            # 设置默认参数
            self.types = int(input('请选择需要计算的工作：1-配送次数计算，2-快递员数计算，请选择'))
            self.sizes = float(input('请输入项目大小：1代表标准，还可以输入其他倍数或小数'))
            if self.types ==1:
                self.others = int(input('请输入投入的快递员数，请输入整数'))
            else:
                self.others = int(input('请输入快递次数，请输入整数'))
        
         #计算工作量
        def calculate_job(self):
            print('计算结果如下')
            if self.types ==1:
                #工时计算过程
                self.num = math.ceil(round((self.sizes * 100 / 20/self.others),2))
                print('%.1f个标准集装箱大的快递项目，使用%d位快递员配送，则需要配送次数%d次' %(self.sizes,self.others,self.num))
            elif self.types==2:
                #人力计算过程
                self.person = math.ceil(round((self.sizes *100 /20/self.others),2))
                print('%.1f个标准集装箱大的快递项目，%d次配送完毕，则需要快递员数：%d位' %(self.sizes,self.others,self.person))
        def again(self):
            num = input('是否继续计算？继续请输入y，输入其他键将结束程序。')
            if num != 'y':
                # 如果用户不输入'y'，则把key赋值为0
                self.key = 0  
        
        def res(self):
            print('欢迎BOSS使用配送计算小程序')
            while self.key == 1:
                self.BOSS_input()
                self.calculate_job()
                self.again()
            print('工作辛苦。')
            
pro= Program()
pro.res()
```
![](/media/202208/image-0e204d3b39c54209998b99a94658e36b.png)
面向对象编程中的类方法，传递参数比普通函数要简单的多，---也不用考虑全局变量与局部变量-，直接使用类属性即可完成。`但是类之间的传递参数都需要加上self`

![](/media/202208/image-190fb4b726c24b8081d194d85a79d23e.png)
`面向对象的编程在拓展性和维护性都优于面向过程的编程，项目越大越明显`

## self概念
### 属性(即变量)
注意，如果变量定义`在类下面而不是类的方法下面`，那这个变量`既是类的属性也是类实例的属性`
![](/media/202208/image-b5177550ffaf4a85abad50b4cd583304.png)

如果变量定义`在类的方法下面`，如果`加了self`，那这个变量就是`类实例的属性`，`不是类的属性`；如果`没有加self`，这个变量只是这个`方法的局部变量`，`既不是类的属性也不是类实例的属性`
![](/media/202208/image-5cc8d4360fe6467a8334b6dc3aa0f757.png)

### 方法(即函数)
如果在类中定义函数时`加了self`，那这个函数是`类实例`的方法，而不是`类`的方法
![](/media/202208/image-a23aef1ebec04c30b3d7d2f8d81193e5.png)

如果在类中定义函数时候`没有加self`，那这个函数就只是`类`的方法，而不是`类实例`的方法
![](/media/202208/image-ffb392b9ff0a4ecbae0af27a0c33b11e.png)

### 继承
通俗的讲，子类继承父类，也就是子类继承了父类的属性和方法，相当于把父类的属性和方法的定义直接加到子类里来，这个时候以子类为主

## 类的继承
### 继承是什么
![](/media/202209/image-dcef8272be164cb2bdc4480392c26566.png)
X类是Y类的子类，Y类是X类的父类(或者超类)

### 类的继承语法
![](/media/202209/image-5e3955c24d304a58b1bbfe160246e797.png)
X类是Y类的子类，X类就会继承Y类的属性与方法

```
class Car:
    wheel = 4
    def run(self):
        print('有%d个轮子,可以飞速的行驶'%self.wheel)
class BMW(Car):
    pass
BMW320 = BMW()
print(BMW320.wheel)
BMW320.run() 
```
![](/media/202209/image-16284496917e4b9382316dc4266c53c0.png)

当创建的类没有小括号时，这个类的父类就是Object。
Object是所有类的父类，称其为根类。(说白了，就是所有类的祖宗)

`isinstance()`函数来判断一下某个实例是否属于某个类
```
#直接运行
class Car:
    wheel = 4
    def run(self):
        print('有%d个轮子,可以飞速的行驶'%self.wheel)
class BMW(Car):
    pass

BENZ600 = Car()  #使用Car类创建奔驰600
BMW320 = BMW()   #使用BMW类创建BMW320
print("验证:子类创建的实例也属于父类")
print(isinstance(BENZ600,Car))
print(isinstance(BMW320,Car))
print("验证:父类创建的实例不属于不属于不属于子类")
print(isinstance(BENZ600,BMW))
print("验证:所有类创建的实例都属于根类")
print(isinstance(BENZ600,object))
print(isinstance(BMW320,object))
```
![](/media/202209/image-2b5aee07d5c1451f90ae0afe888cc459.png)
BENZ600这个实例既属于Car类，也属于Object类。也就是说，BENZ600继承Car类，也继承Object类，但是不继承BMW类

![](/media/202209/image-4b2e9863fce448318376dc90fea50c07.png)

### 多层继承
子类不仅仅可以继承父类， 还可以继承父类的父类、父类的父类的父类……
![](/media/202209/image-9ea50954222a4f879e62fc2664c3d9aa.png)

```
#直接运行代码
#明星类
class Star:
    glasses = "墨镜"

#音乐人继承了明星
class Musician(Star):
    loveMusic = True

# Rapper继承了音乐人
class Rapper(Musician):
    pass

csunYuk = Rapper()
print(csunYuk.glasses)
print(csunYuk.loveMusic)
```
![](/media/202209/image-6110820b54594daaba26b9bc96e06196.png)
子类可以调用父类的属性与方法，也可以调用父类的父类的属性与方法。这就是多层继承

### 多重继承
一个类可以继承多个类， 语法是class Z(X,Y) 
括号内的父类是有顺序区别的，与子类关系更近的父类放在左边

```
#音乐人
class Musician():
    loveMusic = True
    def intr(self):
        print("我喜欢音乐")
        print("我来自音乐界")
#演说家       
class Orator():
    speak = "流利的说"
    def intr(self):
        print("我喜欢演说")
        print("我来自演讲界")              
# Rapper继承了音乐人与演说家
class Rapper(Musician,Orator):
    pass

csunYuk = Rapper()
print(csunYuk.loveMusic)
print(csunYuk.speak)
csunYuk.intr()
```
![](/media/202209/image-e823defc31e342b29c4ea60091de9243.png)
多重继承中，子类继承于多个父类的属性与方法，但是优先继承于左边父类的属性与方法

![](/media/202209/image-0675f2c79de24f39b79db359a7977991.png)

## 类的定制
### 定制是什么？
子类可以在继承父类的基础上进行定制: 可以创建新属性、新方法；也可以改变继承到的属性或方法

### 定制，新增代码
```
#音乐人
class Musician():
    loveMusic = True
    def intr(self):
        print("我喜欢音乐")
        print("我来自音乐界")
    def sing(self):
        print("我在唱歌")
# Rapper继承音乐人
class Rapper(Musician): #类的继承
    garrulous = True    #类的定制 ， 增加属性
    def composition(self):  #类的定制， 增加方法
        print("我可以创作简单的歌词")

csunYuk = Rapper()
print(csunYuk.loveMusic)
print(csunYuk.garrulous)
csunYuk.composition()
```
![](/media/202209/image-c96fcaed93f048b1aa12342b5d9d4469.png)

### 定制，更改代码
```
#音乐人
class Musician():
    loveMusic = True
    def intr(self):
        print("我喜欢音乐")
        print("我来自音乐界")
    def sing(self):
        print("我在唱歌")
# Rapper继承音乐人
class Rapper(Musician): #类的继承
    def sing(self):  #类的定制， 更改方法
        print("我以说的形式进行歌唱")

csunYuk = Rapper()
csunYuk.sing()
```
![](/media/202209/image-d1230616d1b84f529b44a0e916617615.png)
csunYuk是通过 Rapper实例化的对象， Rapper类继承Musician类，自然会继承Musician类的方法sing；但是Rapper类将sing方法进行改写，造成csunYuk.sing()运行结束后， 打印的结果是“我以说的形式进行歌唱”

子类和父类相同方法名，执行为子类的