---

个人昵称：lxw-pro
个人主页：欢迎关注 我的主页
个人感悟： “失败乃成功之母”，这是不变的道理，在失败中总结，在失败中成长，才能成为IT界的一代宗师。

类的创建

init()方法—作用是为对象的属性赋值

• 访问属性的语法为：对象名.属性名
• 访问方法的语法为：对象名.方法名

在实际应用中，可以用同样的方法实例化多个对象

# 创建类Bird
class Bird:
    def __init__(self, n, c, s):
        self.name = n
        self.color = c
        self.size = s

        self.age = 1

    # 定义方法get_description,参数为self,自动传入
    def get_description(self):
        description = f'{self.name}{self.color}{self.size}'
        print(description)

    def get_age(self):
        print(f"This bird is {self.age}")

# 通过方法来改变属性的值：

    def update_age(self, a):
        self.age = a


# 实例化对象my_bird，为my_bird赋予属性'鹦鹉', '绿色', '中等大小'
my_bird = Bird('鹦鹉', '绿色', '中等大小')
my_bird.get_description()

my_bird.get_age()

your_bird = Bird('麻雀', '灰色', '中等大小')
print(f"Your bird's name is {my_bird.name}")
your_bird.get_description()
# 通过访问方法语句 my_bird.get_description()，成功执行方法 get_description() 中的打印语句

print(f"My bird's name is {my_bird.name}")
print(f"My bird's color is {my_bird.color}")

# 为属性设置默认值

# 直接修改属性值，语句为：对象名.属性名 = 值
my_bird.age = 3
my_bird.get_age()

my_bird.update_age(5)
my_bird.get_age()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

---

简单类创建

class Musician:    # 创建类
    glasses = "墨镜"   # 创建类属性

    def __init__(self, city):  # 创建初始化方法
        self.city = city      # 赋值属性
        print('组织语言中……')

    def intr(self):      # 创建类方法
        print('我来自%s' % self.city)


gz = Musician('中国贵州')  # 类实例化对象
print(gz.glasses)
gz.intr()   # 调用类方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14

---

Object是所有类的父类，称其为根类 i
sinstance()函数来判断一下某个实例是否属于某个类

相关代码如下：

class Car:
    wheel = 4

    def run(self):
        print('有%d个轮子,可以飞速的行驶' % self.wheel)


class BMW(Car):
    pass        # pass表示'跳过'，不执行其他操作


BMW320 = BMW()
print(BMW320.wheel)     # 运行结果：4
BMW320.run()            # 运行结果：有4个轮子,可以飞速的行驶

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))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

从运行结果并结合代码来看：
BENZ600这个实例既属于Car类，也属于Object类。
也就是说，BENZ600继承Car类，也继承Object类，但是不继承BMW类；

---

类的继承

在创建类时，不必每次都从零开始，假设我们想要创建的新类和已经创建过的类之间有一些共同的属性和方法，我们就可以从某个现有的类继承，新类称为子类，被继承的类称为父类。

继承时，子类会获取父类的所有属性和方法，并且子类还可以定义自己的属性和方法。

子类的语法规则：class 新类名(父类名)

类的继承中，子类属于父类；子类创建的实例也属于父类。

# 语句中的 super() 函数是用于调用父类的一个方法

class Penguin(Bird):
    def __init__(self, n, c, s):
        super().__init__(n, c, s)

        self.swimming_distance = 100

    def get_swimming_distance(self):
        print(f"企鹅可以游{self.swimming_distance}米")


my_bird = Penguin('企鹅', '黑白', '大')
my_bird.get_description()

my_bird.get_swimming_distance()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

---

继承还有多层继承和多重继承

多层继承

什么是多层继承？
子类可以调用父类的属性与方法，也可以调用父类的父类的属性与方法。这就是多层继承。

# 明星类
class Star:
    glasses = "墨镜"


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


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


csunYuk = Rapper()
print(csunYuk.glasses)
print(csunYuk.loveMusic)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

[^1] 实例csunYuk是类Rapper创建， 它可以调用父类Musician的属性，也可以调用父类的父类Star的属性。

多重继承

什么是多重继承呢？

一个类可以继承多个类， 语法是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()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

csunYuk继承了父类Musician的属性loveMusic，也继承了父类Orator的属性speak；
当两个父类都具有intr()类方法时，它会优先继承左边的父类，也就是父类Musician的方法；

多重继承中， 子类继承于多个父类的属性与方法， 但是优先继承于左边父类的属性与方法

---

类的定制

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

在继承父类的基础上，又可以进行改变

# 音乐人
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()

# csunYuk是通过 Rapper实例化的对象， Rapper类继承Musician类，
# 自然会继承Musician类的方法sing；

# 但是Rapper类将sing方法进行改写，造成csunYuk.sing()运行结束后， 
# 打印的结果是“我以说的形式进行歌唱”

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

————————————————————————————————————————————

pandas 每日一练：

EXCEL文件提前准备：

---

导库、读文件

# -*- coding = utf-8 -*-
# @Time : 2022/7/23 20:38
# @Author : lxw_pro
# @File : pandas-6 练习.py
# @Software : PyCharm

import pandas as pd
df = pd.read_excel('text5.xlsx')
1
2
3
4
5
6
7
8

26、查看索引、数据类型和内存信息

df.info()
1

程序运行结果如下：

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 8 entries, 0 to 7
Data columns (total 7 columns):
 #   Column        Non-Null Count  Dtype         
---  ------        --------------  -----         
 0   Unnamed: 0    8 non-null      int64         
 1   Unnamed: 0.1  8 non-null      object        
 2   project       8 non-null      object        
 3   popularity    8 non-null      int64         
 4   test_time     8 non-null      datetime64[ns]
 5   date          8 non-null      datetime64[ns]
 6   time          8 non-null      object        
dtypes: datetime64[ns](2), int64(2), object(3)
memory usage: 576.0+ bytes
1
2
3
4
5
6
7
8
9
10
11
12
13
14

---

27、查看数值型列的汇总统计

print('describe', df.loc[:, ['popularity']].describe())
1

程序运行结果如下：

describe        popularity
count    8.000000
mean   125.000000
std     28.963031
min     84.000000
25%     94.250000
50%    143.000000
75%    146.500000
max    149.000000
1
2
3
4
5
6
7
8
9

---

28、新增一列根据popularity将数据分为n组

fz = [0, 80, 120, 150]
fz_names = ['良好I', '良好II', '优秀']
df['scores'] = pd.cut(df['popularity'], fz, labels=fz_names)
print(df)
1
2
3
4

程序运行结果如下：

   Unnamed: 0 Unnamed: 0.1  project  ...       date      time scores
0           0     00:00:00   Python  ... 2022-06-20  18:30:20   良好II
1           1            1     Java  ... 2022-06-18  19:40:20   良好II
2           2            2        C  ... 2022-06-08  13:33:20     优秀
3           3            3    MySQL  ... 2021-12-23  11:26:20     优秀
4           4            4    Linux  ... 2021-12-20  18:20:20   良好II
5           5            5     Math  ... 2022-07-20  16:30:20     优秀
6           6            6  English  ... 2022-06-23  15:30:20     优秀
7           7            7   Python  ... 2022-07-19  09:30:20     优秀
[8 rows x 8 columns]
1
2
3
4
5
6
7
8
9
10

---

29、按照popularity列对数据降序排列

print(df.sort_values('popularity', ascending=False))
1

程序运行结果如下：

   Unnamed: 0 Unnamed: 0.1  project  ...       date      time scores
7           7            7   Python  ... 2022-07-19  09:30:20     优秀
5           5            5     Math  ... 2022-07-20  16:30:20     优秀
6           6            6  English  ... 2022-06-23  15:30:20     优秀
2           2            2        C  ... 2022-06-08  13:33:20     优秀
3           3            3    MySQL  ... 2021-12-23  11:26:20     优秀
0           0     00:00:00   Python  ... 2022-06-20  18:30:20   良好II
1           1            1     Java  ... 2022-06-18  19:40:20   良好II
4           4            4    Linux  ... 2021-12-20  18:20:20   良好II
[8 rows x 8 columns]
1
2
3
4
5
6
7
8
9
10

---

30、取出第6行数据

print(df.loc[5])
1

程序运行结果如下：

Unnamed: 0                        5
Unnamed: 0.1                      5
project                        Math
popularity                      148
test_time       2022-07-20 16:30:20
date            2022-07-20 00:00:00
time                       16:30:20
scores                           优秀
Name: 5, dtype: object
1
2
3
4
5
6
7
8
9

---

每日一言：

在人生中，重要的事情不是胜利，而是奋争，对人生来说必不可缺的东西，不是取胜，而是曾经无悔地战斗过。

---

持续更新中…

点赞，你的认可是我创作的动力！
收藏，你的青睐是我努力的方向！
评论，你的意见是我进步的财富！
关注，你的喜欢是我长久的坚持！

欢迎关注微信公众号【程序人生6】，一起探讨学习哦！！！