Python之第十一章面向对象 --- 基础

class Person():
    # 属性
    # 方法（函数）
    def eat(self):
        print('强子喜欢吃皮蛋')

    def drink(self):
        print('强子喜欢喝酒')


class Geese:
    '''大雁类'''
    pass

特别注意：

        类本质也是一个对象

        Python一切皆为对象，类是一个特殊的对象，即类对象

        类对象运行也会被加载到内存中

        类对象在内存中只有一份，可以创建出多个对象实例

4.类的实例化

定义完类之后并不会立刻创建实例对象，必须更具类实例化创建出对象才可进行处理

类只是对象的一种规范，类本身什么也做不了，必须利用类得到对象，该过程称为类的实例化

格式 ---

对象名 = 类名( )

例

# 1.定义一个类
class Person():
    def eat(self):
        print('强子喜欢吃皮蛋')

    def drink(self):
        print('强子喜欢喝酒')


# 2.实例化对象
p1 = Person()

# 3.调用对象的方法实现功能
p1.eat()
p1.drink()

结果：
强子喜欢吃皮蛋
强子喜欢喝酒

每一个对象都有自己的独立存储空间，保存各自的不同属性，多个对象的方法在内存中只有一份，在调用时，需要把对象的引用传递给方法内部

在编程过程中，对于有相同属性和方法的对象，为了避免重复定义，可以将这些对象归纳抽象为一个类

5.类的self关键字

定义 --- 是一个Python关键字

作用 --- 指向类实例对象本身，用于访问类中的属性和方法，在方法调用时会自动传递参数self

# 1.定义一个类
class Person():
    def eat(self):
        print('强子喜欢吃皮蛋')
        print(self)


# 2.实例化对象
p1 = Person()
p2 = Person()

# 3.调用对象的方法实现功能
p1.eat()
p2.eat()

结果：
强子喜欢吃皮蛋
<__main__.Person object at 0x000001C7FFB49FD0>
强子喜欢吃皮蛋
<__main__.Person object at 0x000001C7FFB49FA0>

总结 --- 类中self就是实例化对象的本身

6.创建_ _ init _ _( )方法（初始化方法）

Python中 _ _ xx _ _ ( ) 函数称为魔术方法，指具有特殊功能的函数

类创建后可以手动创建一个_ _ init _ _( )方法，

作用 --- 在创建一个对象时默认被调用的不需要手动调用

例

class Geese:
    '''大雁类'''

    def __init__(self, beak, wing, claw):
        print('我是大雁类')
        print(beak)
        print(wing)
        print(claw)


beak1 = '有较长'
wang1 = '翅膀长'
claw1 = '爪子为'

wil = Geese(beak1, wang1, claw1)

注意：

1. _ _ init _ _( )方法必须包含一个参数self，位置也必须是第一个，self本质是指向对象本身，没写实例或位置不对会报错

2._ _ init _ _( )方法双线划线开头和结尾

3. _ _ init _ _( )方法可以自己定义一些参数，都好隔开

例

class Person():
    # 初始化实例对象
    def __init__(self, name, age):
        self.name = name
        self.age = age


# 实例化对象并传入初始化的参数
p1 =Person('fff',18)

#调用p1对象自身的属性
print(p1.name)
print(p1.age)

7.创建类的实例方法

类的成员主要由实例方法和数据组成

实例方法本质是类中定义的函数

格式 ---

def 方法名（self，其他形参）:
    方法体

方法名 --- 一般小写字母开头

self --- 必要参数，标识类的实例

其他参数 --- 多个参数使用逗号隔开

方法体 --- 实现方法具体的功能程序段

实例方法与一般函数的区别：

Python的函数是实现某个功能，实例化方法是类中的一个行为，是类的一部分

使用格式 --- 实例化对象.方法名(实参)

class Geese:
    '''大雁类'''

    def __init__(self, beak, wing, claw):
        print('我是大雁类')
        self.beak = beak
        self.wing = wing
        self.claw = claw

    def fly(self, state):
        print(state)


beak1 = '有较长'
wang1 = '翅膀长'
claw1 = '爪子为'

wil = Geese(beak1, wang1, claw1)
print(wil.beak)
wil.fly('飞行时候为人字形或一字型')

结果：
我是大雁类
有较长
飞行时候为人字形或一字型

Process finished with exit code 0

8.创建类的静态方法

作用 --- 在开发时，如果需要在类中封装一个方法，这个方法：既不需要访问属性或者调用实例方法，也不需要访问类属性或者调用类方法，

注意：

一般用于打印提示、帮助信息等

格式 --- @staticmethod --- 其用于修饰类中的方法，使其可以在不创建类实例的情况下进行调用

优点 --- 执行效率高，该方法一般被称为静态方法。

注意：

静态方法不可以引用类中的属性或方法，其参数列表也不需要约定默认参数self。

例

class Game(object):
    # 开始游戏，打印游戏功能菜单
    @staticmethod  # 装饰器声明下面方法为静态方法
    def menu():
        print('1.开始游戏')
        print('2.游戏暂停')
        print('3.退出游戏')


Game.menu()  # 不需要创建对象：stu1 = Game()，通过 类名.方法名 调用

9.创建类的属性

定义 --- 在类中并且在函数体外部的属性变量，类属性可以在类的所有实例之间共享，是一种公共的属性，一般记录类的相关特征。

类属性 --- 可以通过类名或对象名访问

class Geese:
    '''大雁类'''
    neck = '脖子较长'
    wing = '翅膀振动频率高'
    leg = '腿位于身体中心支点'


geese1 = Geese()
print(Geese.neck)  # 通过 类名.属性名 访问
print(Geese.wing)
print(geese1.leg)  # 通过 对象名.属性名 访问

示例图：

注意：

类属性一旦变更，所有对象的属性都会变化

class Geese:
    '''大雁类'''
    neck = '脖子较长'
    wing = '翅膀振动频率高'
    leg = '腿位于身体中心支点'


geese1 = Geese()
geese2 = Geese()

print(geese1.neck)
print(geese2.neck)

注意：

不能使用 对象.属性 = 值 方法进行赋值，这只会增加第一个属性，而不会影响类属性

4.类的属性

1.属性的概念

Python中，任何一个对象都应该由两部分组成：属性+方法

属性 --- 即特征，如 : 人的姓名、年龄、升高、体重 ... 都是对象的属性

对象属性 --- 既可以在类外面创建和获取，也能在类里面创建和获取

2.创建实例属性（默认的对象属性）

定义 --- 定义在类犯法中的属性，只作用于当前对象

class Geese:
    '''大雁类'''
    def __init__(self):
        self.neck = '脖子贼长'   # 对象属性
geese1 = Geese()
geese2 = Geese()
geese1.neck = '脖子再长有我的长'
print(geese1.neck)
print(geese2.neck)  # 值不变

3.在类的外面添加属性和获取属性

格式 --- 对象名.属性名 = 值

例：

class Person:
    pass


p1 = Person()
p1.name = '老王'
p1.age = 22
p1.adress = '显示雁塔区电子城街道金融路3号'

p2 = Person()

print(p2.name) # 报错，name 是p1的对象属性，私有

4.在类的内部获取外部定义的属性

class Person:
    def speak(self):
        print(f'我的名字:{self.name},我的年龄：{self.age},我的地址：{self.adress}')


p1 = Person()

p1.name = '老王'
p1.age = 22
p1.adress = '雁塔区电子城街道金融路3号'

p1.speak()

结果：
我的名字:老王,我的年龄：22,我的地址：雁塔区电子城街道金融路3号

5.魔术方法

1.定义

在Python中，_ _ xxx _ _ ( ) 的函数叫做魔术方法，指的是具有特殊功能的函数，如之前讲过的 _ _ init_ _( )

2._ _ str _ _ ( )方法

如果使用print输出对象的时候，默认打印对象的内存地址

如果类定义了 _ _ str _ _( )方法，那么就会打印出从这个方法中return的数据

例：

class Car():
    def __init__(self, brand, model, color):
        self.brand = brand
        self.model = model
        self.color = color

    def __str__(self):
        return f'汽车品牌:{self.brand},汽车型号:{self.model},汽车颜色:{self.color}'


model3 = Car('奔驰', 'S600', '黑色')
print(model3)

结果：
汽车品牌:奔驰,汽车型号:S600,汽车颜色:黑色

上例中print（model3）若类中无_ _str _ _()方法则默认输出对象的首地址，若有则输出return后的结果

3._ _ del _ _( )方法

又称为删除方法或析构方法

当删除对象时，解释器会自动调用

例

class Car():
    def __init__(self, brand, model, color):
        self.brand = brand
        self.model = model
        self.color = color

    def __str__(self):
        return f'汽车品牌:{self.brand},汽车型号:{self.model},汽车颜色:{self.color}'

    def __del__(self):
        print('\n')
        print(f'{self}对象已删除')


model3 = Car('奔驰', 'S600', '黑色')
print(model3)

# 删除对象modle3
del model3 # 自动调用__del()方法

结果：
汽车品牌:奔驰,汽车型号:S600,汽车颜色:黑色


汽车品牌:奔驰,汽车型号:S600,汽车颜色:黑色对象已删除

注意：

_ _ del _ _( ) 方法一般用于输出提示、关闭文件、关闭数据库等后续操作

6面向对象的综合案例

1.例1 ：定义学员信息类，包含姓名、成绩属性，定义成绩打印方法（90分及以上显示优秀，80分及以上显示良好，70分及以上显示中等，60分及以上显示合格，60分以下显示不及格）

分析：

        实体 --- 学院

        属性 --- 姓名、成绩

        方法 --- 打印成绩

# 例1 定义学员信息类，包含姓名、成绩属性， 定义成绩打印方法（90分及以上显示优秀，80分及以上显示良好，70分及以上显示中等，60分及以上显示合格，60分以下显示不及格）
# 1.创建学员类
class Student():
    # 2.定义学员的属性
    def __init__(self, name, score):
        self.name = name
        self.score = score

    def print_grade(self):
        if self.score >= 90:
            print(f'学院姓名:{self.name},学员成绩:{self.score},优秀')
        elif self.score >= 80:
            print(f'学院姓名:{self.name},学员成绩:{self.score},良好')
        elif self.score >= 70:
            print(f'学院姓名:{self.name},学员成绩:{self.score},中等')
        elif self.score >= 60:
            print(f'学院姓名:{self.name},学员成绩:{self.score},合格')
        else:
            print(f'学院姓名:{self.name},学员成绩:{self.score},不及格')
        return 0


name1 = input('请输入要查询的学员的姓名：')
score1 = int(input('请输入该学员成绩：'))

student1 = Student(name1, score1)

print(student1.print_grade())

结果：
请输入要查询的学员的姓名：方方
请输入该学员成绩：65
学院姓名:方方,学员成绩:65,合格

2.例2：小明体重75.0公斤，小明每次跑步会减掉0.50公斤，小明每次吃东西体重增加1公斤

解析：

        实体 --- 小明

        属性 --- 姓名、体重

        方法 ---

                跑步：体重减少0.5公斤

                吃饭：体重增加1公斤

# 例2 小明体重75.0公斤，小明每次跑步会减掉0.50公斤，小明每次吃东西体重增加1公斤
class Student():
    def __init__(self, name, weight):
        self.name = name
        self.weight = weight

    def run(self):
        self.weight -= 0.5

    def eat(self):
        self.weight += 1

    def __str__(self):
        return f'姓名：{self.name},目前体重:{self.weight}Kg'


ff = Student('方方', 54)

print(ff)  # 利用str魔术方法返回信息

ff.eat()
print(ff)

ff.run()
print(ff)

结果：
姓名：方方,目前体重:54Kg
姓名：方方,目前体重:55Kg
姓名：方方,目前体重:54.5Kg

3.例3：编写Prime类实现输出大于m且紧随m的k个素数

解析：

        实体 ---数字

        属性 --- m，k

        方法 --- 判断素数实现大于m且紧随m的k个素数

class Pirme():
    def __init__(self, start_value, num):
        self.start_value = start_value
        self.num = num

    def print_num(self):
        count = 0
        i = self.start_value
        while count < self.num:
            for j in range(2, i):
                if i % j == 0:
                    break
            else:
                count += 1
                print(i, end=' ')
            i += 1


m = int(input('请输入起始值：'))
k = int(input('请输入查找个数：'))

prime1 = Pirme(m, k)
prime1.print_num()

结果：
请输入起始值：5
请输入查找个数：3
5 7 11

4.例4：编写Mysort类实现整数升序排序

解析：

        实体 --- list列表

        属性 --- list 、len

        方法 --- 选择升序排序

# 例4 编写Mysort类实现整数升序排序
class Mysort():
    def __init__(self, list1):
        self.list1 = list1
        self.len = len

    def selection_sort(self):
        if len(self.list1) == 0:
            return '数据不能为空'
        self.list1 = list(self.list1)  # 将字符串数字转为字符串列表
        self.list1 = [int(self.list1[i]) for i in range(len(self.list1))]  # 将字符串列表转为整数列表

        # 选择法排序
        for i in range(len(self.list1) - 1):
            for j in range(i + 1, len(self.list1)):
                if self.list1[i] > self.list1[j]:
                    self.list1[i], self.list1[j] = self.list1[j], self.list1[i]
        return self.list1


list2 = input('请输入需要排序的序列：')
mysort1 = Mysort(list2)
print(mysort1.selection_sort()) 

结果：
请输入需要排序的序列：15237
[1, 2, 3, 5, 7]