3-Python面向对象编程

高高飞2023

已于 2023-08-11 08:53:23 修改

阅读量36

点赞数

分类专栏： Python 文章标签： python 开发语言

于 2023-08-08 09:03:13 首次发布

本文链接：https://blog.csdn.net/L13554358354/article/details/132159157

版权

Python 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

文章目录

3.Python面向对象编程

3.Python面向对象编程

PYthon是一种面向对象设计的编程语言，使用类和对象编程，可以大大提高编程的效率

3.1面向对象编程理论基础

在此之前我们更多的采用面向过程编程，如果想实现比较复杂的功能，往往代码比较繁重，不好修改。
而面向对象编程，可使得变量和函数可以根据功能进行整理分类，通过面向对象的模块化编程，大大减轻了复杂程序的设计与维护负担。

3.1.1Python中的对象

在Pyhon中一切都是对象

在python中一切都是对象，例如：一个变量、一个常量，一个序列或者字典。它也可以是无形的，例如一个函数。对象可以简单也可以复杂，复杂对象可以由许多的简单对象组成，整个python程序也可以当做一个对象。
现实世界中，对象我们可以认为是一个人、一个房子、一辆汽车等等。许多简单对象可以组成一个复杂对象。
python对象有下面三个特性：
每个对象都有一个独特的名字区别于其他的对象
有属性来描述它的特性
有一组操作，每个操作决定对象的一种行为

3.1.2Python的类

类是用来定义对象的模版

在现实世界类可以理解是有相同属性和行为的对象的抽象。例如小明和小张都是具有相同的属性，两只手两条腿。
在python中类是具有相同数据类型和操作的对象的模版集合。很类似C语言中的结构体，学生由姓名、学号、性别、成绩等表示其属性的数据项和对这些数据的录入、修改、和现实等操作组成，而每一个特定的学生例如xiaoming就是一个对象

3.1.3面向对象编程的特点

面相对象编程有以下几个特征：

抽象：主要特性实际一个"类",强调感兴趣的信息，忽略与主题无关的信息
封装：类似将数据和一些对应的操作，装在黑匣子内部，你不需要知道内部的细节，只要知道它提供的功能，像API接口一样的。
继承：一个类可以继承另一个类的特性和功能，并且添加自己的特性
多态：不同的对象的进行相同的操作，结果会不一样，比如：打开这个操作，电视打开可以播放影片，水龙头打开可以放水。

3.2Python中面向对象编程

变量、函数、运算符等等都是面向对象编程的一切对象。之前我们通过点运算符号已经接触了面向对象编程，name.append('XiaoHu').

3.2.1Python中的类与对象

在python中使用class关键字定义类，类似函数，下面的缩进部分构成了类的主体

## 创建一个student 类
class student():
    pass

使用类的名字和一对括号可以创建对象

xiaohu=student()
xiaoming=student()

print(type(xiaohu))
print(type(xiaoming))

<class '__main__.student'>
<class '__main__.student'>

3.2.2类与对象中的变量

类和对象都有相对应的属性和方法。

## 创建一个student 类,以及三个类变量
class student():
    name='Undefined'
    Marh_score=None
    Chinese_score=None

## 使用类变量创建的对象也拥有类相同的数据和操作，可以通过``.``符号来引用对象或类的变量与函数
xiaohu=student()
xiaohu.name='XiaoHu'
xiaohu.Math_score=88
xiaohu.Chinses_score=66
print(xiaohu.name)
print(xiaohu.Math_score)
print(xiaohu.Chinese_score)

XiaoHu
88
None

注意区分：类变量和对象变量，在定义的类中的属性比如;student.name是类变量，而通过对象创建的对象调用的类属性是对象变量，比如：xiaohu.name.

类变量属于类，更改类变量会影响所有后续由该类创建对象的属性。
对象变量属于对象，更改对象变量只影响该对象的属性

## 更改对象变量只会影响对象的属性，不会影响类变量
xiaoming=student()
## 修改 xiaoming.name,xiaohu的属性不受影响
xiaoming.name='XiaoMing'
print(xiaoming.name)
print(xiaohu.name)

XiaoMing
XiaoHu

## 更改类变量会影响所有后续由该类创建对象的属性。
xiaoming = student()
print(xiaoming.name)

## 修改 student.name 再次创建新对象 xiaoming
student.name = 'Change Name'
xiaoming = student()

## xiaoming.name 不再是 undefined 而是 change name
print(xiaoming.name)

Undefined
Change Name

3.2.3类与对象中的函数

在python中类函数用于表示类的操作，它又被称作为“方法”。它与一般函数类似，但是又一个额外的self参数：

class student():
    def print_name(self,):
        print(self.name)
        
    name='Undefined'
    Math_score=None
    Chinese_score=None
xiaoming=student()
xiaoming.name='XiaoMing'
xiaoming.print_name()

XiaoMing

self用来代指通过类创建的对象，比如你创建xiaoming这个对象，那么这里就是xiaoming.name,如果创建的是xiaohu这里就是xiaohu.name

## 创建一个修改成绩的函数
class student():
    ## 定义一个函数用于修改成绩
    def chang_name(self,course_name,score):
        if course_name=='Math':
            self.Math_score=score
        elif course_name=='Chinese':
            self.Chinese_score=score
        else:
             print(course_name, "course is still not in current system")
    def print_name(self,):
        print(self.name)
        
    name='Undefined'
    Math_score=None
    Chinese_score=None
    
xiaoming=student()
xiaoming.name='XiaoHu'
print(xiaoming.name)
print(xiaoming.Math_score)
xiaoming.print_name()
xiaoming.chang_name('Math',99)
print(xiaoming.Math_score)
xiaoming.chang_name('Chinese',100)
print(xiaoming)

XiaoHu
None
XiaoHu
99
<__main__.student object at 0x00000199840F30D0>

如果学科的类型多了之后，这种方法对于成绩的修改就比较简单了，使整个系统简化许多。

3.2.4init方法

用来初始化对象，可以更快的初始化变量值。

class student():
    def __init__(self,name,Math_score,Chinese_score):
        self.name=name
        self.Math_score=Math_score
        self.Chines_score=Chinese_score
    def chang_score(self,Math,Chinese):
        if Math=='Math':
            self.Math_score=Math
        elif Chinese=='Chinese':
            self.Chines_score=Chinese
        else:
            print("没有这个学科")
    def print_name(self,):
        print(self.name)
    
    name='Undefined'
    Math_score=None
    Chines_score=None

xiaohu=student('XiaoHu',100,101)
xiaohu.print_name()
xiaohu.chang_score('物理',200)

XiaoHu
没有这个学科

在定义了__init__方法后，可以在定义类对象的时候直接给对象进行变量的初始化

3.3万物皆对象

以Python对象的角度再回顾这里面的变量、函数以及数据结构

3.3.1重识变量

python中所有的变量都是对象，创建一个int变量，它有bit_lenth,conjugate,to_byte,from_byte等方法。

variable=1
type(variable)

int

to_byte将int对象转化成byte对象b"\x00x\01"因为整数1的二进制编码是0001.

variable_byte=variable.to_bytes(2,byteorder='big')
print(variable_byte)
print(type(variable_byte))

b'\x00\x01'
<class 'bytes'>

3.3.2重识常量

python中的常量也是对象，其中常用到的对象方法就是字符串常量
字符串常量常用方法如下：

format（）：用于从其他信息中构造字符串
replace（）：用于替代字符串中的某个字符或子串
split（）：用于通过某种字符分割字符串
upper（）：把字符串转成大写
lower（）：把字符串转化成小写

## fromat  方法使用数字{数字i}对应{第i个变量} 来控制用于构造字符串的参数
print("Learn {0} in a {1} way !".format('Python','samrt'))
print("Learn {0} in a {1} way!".format('PHP','hard'))

Learn Python in a samrt way !
Learn PHP in a hard way!

## replace 方法可以替换字符串中的一个单词
print("Learn Python in a smart way!!".replace('smart','hard'))

Learn Python in a hard way!!

## split 方法使用一个或多个参数分割字符串，并返回子串构成的序列
print("Learn Python in a smart way!!".split(' '))

['Learn', 'Python', 'in', 'a', 'smart', 'way!!']

## upper 和 lower方法转化大小写
print("Learn Python in a smart way !!".upper())
print("Learn Python in a smart way !!".lower())

LEARN PYTHON IN A SMART WAY !!
learn python in a smart way !!

3.3.3重识函数

python里面函数也是对象

def check_name(num1,num2,target):
    ## zai def ()下面是函数的内容
    a=num1
    b=num2
    return a+b==target
check_name.__name__

'check_name'

3.3.4重识数据结构

数据结构也是对象，数据结构提供了很多调用它的属性的一些方法，之前我们用到的append就是其中一个。

l=[1,2,3,4]

l.append(5)
print(l)

[1, 2, 3, 4, 5]

除此之外，我们可以通过pop方法替代del关键字删除序列内某个元素：

l.pop(0)
## 下标从0开始的数据

print(l)

[2, 3, 4, 5]

通过insert 方法插入特定位置增加元素

## 第一个参数位置，第二个插入元素
l.insert(0,10)
print(l)

[10, 2, 3, 4, 5]

同样的，在元组、字典、集合等数据结构中也有很多的方法，在此将常用的方法总结如下：

列表
- append(x)把元素x放入列表尾部
- count(x)统计元素x在列表中出现的次数
- extent(seq)把新列表seq合并到列表尾部
- index(x)返回元素x第一次在列表中出现的位置
- insert(index,x)把元素x插入到index位置
- pop(index）删除并返回index所在位置的元素
- remove(x)删除出现的第一个x元素
- reverse()颠倒列表顺序
- sort()对列表进行排序
字典
- clear()清除字典内所有元素
- copy()返回字典的一个复制
- has_key(key)检查key是否在字典中
- items()返回一个含由（key,value）格式元组构成的列表
- keys()返回由键构成列表
- values()返回由值构成的列表
- ``setdefault(key,default)为键key添加默认值default
- pop(key)删除key并返回对应的值
集合
- d（x）合中添加元素x
- eart()集合
- py（）集合的一个复制
- fferent（set）集合与另一个集合的差集
- scard(x)元素x
- disjoint(set)两个集合是否有交集
- subset(set)新集合set是否是集合的子集
- superset（）新集合set是否是集合的超集

3.3.5重识程序

python程序是一个对象，它也有自己的数据和方法。其中_name_就是它的一个变量，我们没有定义过这个变量，但是由于它是程序的对象变量，因此可以直接调用。

__name__

'__main__'

3.4练习

此练习是开放题，使用面向对象的编程方法重构之前的成绩管理系统，并完成之前的任务。

Task 1. 在上一次期末考试中，XiaoHu 考了数学 65 分，语文 55 分；XiaoMing 考了数学 80 分，语文92 分；XiaoWei 考了数学 95 分，语文 98 分，以此建立学生成绩管理系统。

Task 2. 在本次期末考试中，XiaoHu 考了数学 95 分，语文 85 分；XiaoMing 考了数学 75 分，语文 71 分；XiaoWei 考了数学 92 分，语文 93 分，以此对之前的成绩进行更新。

Task 3. 由于 XiaoMing 的成绩出现了大幅度下滑，家长决定要 XiaoMing 转学到另一所高中，以此在系统中删除 XiaoMing 的信息。

Task 4. 学校新转来的学生 Cryin 本次考试成绩为数学 87 分，语文 88 分，在系统中录入 Cryin 的成绩。

## 定义student类别
class  student():
    ## 为对象进行初始化赋值
    def __init__(self,name,Math_score,Chinese_score):
        self.name=name
        self.Math_score=Math_score
        self.Chinese_score=Chinese_score
        
    ## repr 函数用于定义对象被输出时的输出结果
    def __repr__(self):
        return str((self.name,self.Math_score,self.Chinese_score))
    
    def chang_score(self,course_name,score):
        if course_name=='Math':
            self.Math_score=score
        elif course_name=='Chinese':
            self.Chinese_score=score
        else:
            print(course.name,"course is still not in current system")
    def print_name(self,):
        print(self.name)
        
    name='Undefined'
    Math_score=None
    Chinese_score=None

现在使用学生类对象保存在字典中实现一个成绩系统

## Task1
ab={}
ab.setdefault('XiaoHu',student('XiaoHu',65,55))
ab.setdefault('XiaoMing',student('XiaoMing',80,92))
ab.setdefault('XiaoWei',student('XiaoWei',95,98))
print(ab)

{'XiaoHu': ('XiaoHu', 65, 55), 'XiaoMing': ('XiaoMing', 80, 92), 'XiaoWei': ('XiaoWei', 95, 98)}

xiaohu=student('XiaoHu',65,55)
print(xiaohu.name)

XiaoHu

## Task2

## 修改数学成绩
ab['XiaoHu'].chang_score=('Math',95)
ab['XiaoMing'].chang_score=('Math',75)
ab['XiaoWei'].chang_score=('Math',93)

## 修改语文成绩
ab['XiaoHu'].chang_score=('Chinese',85)
ab['XiaoMing'].chang_score=('Chinese',71)
ab['XiaoWei'].chang_score=('Chinese',93)
## Task 3
ab.pop('XiaoMing')

('XiaoMing', 80, 92)

## Task 4

ab.setdefault('Cryin',student('Cryin',87,88))

('Cryin', 87, 88)

print(ab)

{'XiaoHu': ('XiaoHu', 65, 55), 'XiaoWei': ('XiaoWei', 95, 98), 'Cryin': ('Cryin', 87, 88)}