Python面向对象

已于 2022-04-21 14:16:38 修改
阅读量159 收藏
点赞数 1
分类专栏： Python 文章标签： python
于 2021-09-13 17:04:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56945138/article/details/120268234
版权

Python面向对象

1. 本质

一切皆对象

2. 类

1. 概念

类是抽象的概念,它是对具有相同属性和方法的对象的一个通称。

2. 语法

class[关键字,不可省略]	类名:
	属性定义[例如: age=0]
	方法定义[例如: 构造函数]

# 调用类 

例如: a=a(); # 实例化类
a.age=19	# 并且给属性赋值

3. 对象

对象是类的实例

1. 对象的内容

对象有其属性和方法。

例如对象为人:
属性：姓名、年龄、身高等固有的特性
方法：吃、阅读、学习等为达到某种目的的行为。

2. 类和对象的区别

类是抽象概念，对象是具体的。类是一个模板，而对象就是根据这个模板创造出来的东西。
比如，创建一个学生类，实例化一个学生小白，那么小白就是学生类中的一个对象。可以通过类实例化一个个的对象，每个对象都拥有相同的方法，但各自的数据可能不相同，它们之间互相独立，互不影响。
注意：一个类可以实例化出多个对象,但是每个对象都不一样,都是全新的独立个体

4. 类和对象

1. 定义一个学生类

# ① 定义一个类
class Student:
    name = "小宝"
    sex  = "男"
    def fun(self): # 类方法必须包含参数 self, 且为第一个参 数，self 代表的是类的实例
        print("姓名:"+self.name+",性别:"+self.sex)

# ② 通过类实例化对象
stu = Student() # 实例化一个对象,名为stu
stu.name = "宝宝" # 修改name属性内容

# ③ 调用方法
stu.fun() 

# ④ 一个类可以实例化出多个对象,这里的stu和stu2不是同一个对象
stu2 = Student() 
stu2.fun()

输出结果如下：

我们可以看到输出的内容不一样，因为修改的name是stu对象的。我们实例化出来的这两个对象，它们的方法是相同的，但各自输出的数据不一样，是因为它们分别是一个独立的个体，谁也不影响谁。

在这里插入图片描述

2. 构造函数

构造函数:在创建对象的同时，可以直接修改对象内部属性的值。(不用像第一个例子需要好几行代码才可以将对象值修改。)

class Student:
    name = "小宝" 
    sex  = "男"

    # 构造函数
    def __init__(self,a,h):
        self.name = a
        self.sex  = h
   
    def fun(self): # 类方法必须包含参数 self, 且为第一个参 数，self 代表的是类的实例
        print("姓名:"+self.name+",性别:"+self.sex)

stu = Student("宝宝", "女")
stu.fun()

注意：
1. _ init_() 方法，该方法被称为构造方法，开头和结尾各有 2 个下划线，并且中间不能有空格
2. self 必须作为第一个参数
3. 在创建一个对象时默认被调用，不需要手动调用
4. init() 方法可以有参数,可以通过传参数,对不同的对象设置不同的初始化属性,参数通过 init() 传递到类的实例化操作上

3. self

指调用self所在方法的对象。

 #① 定义一个类
class Student:
    def fun(self): # 类方法必须包含参数 self, 且为第一个参 数，self 代表的是类的实例
        print('这是fun1')
        self.fun2()
    def fun2(self):
        print('这是fun2')

# ② 通过类实例化对象
stu = Student()
# ③ 调用
stu.fun()

4. 创建多个对象时，self地址是否一样？

# ① 定义一个类
class Student:
    def fun(self): # 类方法必须包含参数 self, 且为第一个参 数，self 代表的是类的实例
        print('这是fun1')
        print(self)

# ② 通过类实例化对象stu1 并调用
stu = Student()
stu.fun()

# ③ 通过类实例化对象stu2 并调用
stu2 = Student()
stu2.fun()

答案是不相同的。注意前面的类和对象的概念和区别。
在这里插入图片描述

5. __str__方法

如果使用print打印对象时,默认会打印对象的内存地址，有没有什么方法打印其它内容？
答案：定义__str__方法,将会打印这个函数return的内容。

class Student:
    
    # 构造函数
    def __init__(self):
        self.name = '小白'
   
    def __str__(self): 
        return "123"

stu = Student()
print(stu)

6. del

删除对象时,python解释器会默认调用它。

class Student:

    # 构造函数
    def __init__(self):
        self.name = '小白'

    def __del__(self):
        print('123')
stu = Student()

5. 类的属性

静态变量
实例变量
局部变量: 在函数内部定义的属性,并且没有以self为前缀。比如：变量名 = 值

1. 静态属性（类属性）

类变量是指在类中，在各个方法外的定义变量，它被所有的类对象所共有，并且在内存中只存在一个副本

class Student:
    # 类变量：name和sex
    name = "小宝" 
    sex  = "男"
    
    def fun(self):
        print("姓名:"+self.name+",性别:"+self.sex)
        
print(Student.name) # 类名直接打点访问
stu = Student()
print(stu.name) # 类的实例打点调用

修改类变量，会影响到所有的实例化对象

class Student:
    # 类变量：name和sex
    name = "小宝" 
    sex  = "男"

# 修改前
print("修改前类变量:"+Student.name)
# 修改
Student.name = "宝宝"
#修改后
print("修改后类变量:"+Student.name)
stu = Student()
stu2 = Student()
stu3 = Student()
print("修改后类对象stu:"+stu.name)
print("修改后类对象stu2:"+stu2.name)
print("修改后类对象stu3:"+stu3.name)

如果要修改类属性,只能通过类修改,如果使用对象去修改,相当于在类外面添加了一个实例属性

class Student:
    # 类变量：name和sex
    name = "小宝" 
    sex  = "男"

# 1.创建对象
stu = Student()

# 2.通过对象修改name
stu.name = '小黑'

# 3. 分别用类和对象打印name
print(Student.name)  # 小宝
print(stu.name)      # 小黑

注意：

  1. 类变量被所有类对象共有，通过类名修改类变量的值，会影响所有的实例化对象
  2. 通过类对象是无法修改类变量的。通过类对象对类变量赋值，其本质将不再是修改类变量的值，而是在给该对象定义新的实例变量
  3. 类变量我们自己也可以进行一个添加，比如：Student.Id = 1
  4. 如果要修改类属性,只能通过类修改,如果使用对象去修改,相当于在类外面添加了一个实例属性,如第三条

2. 实例属性

  1. 实例属性: 对象属性,以 self 为前缀的属性。比如：self.变量名
class Student:
    # 构造函数
    def __init__(self,a,h):
        self.name = a  # name、sex 都是实例属性
        self.sex  = h
   
    def fun(self):
        print("姓名:"+self.name+",性别:"+self.sex)
  1. 实例对象修改和添加，实例化出来的对象它们都是一个独立的个体，因为它每创建一个对象时就会单独存储一份
class Student:
    # 构造函数
    def __init__(self,a,h):
        self.name = a # name、sex 都是实例属性
        self.sex  = h
# ① 创建stu对象 并修改和添加属性   
stu = Student("小白","男")
stu.sex = "女" # 修改
stu.age = 20   # 添加

# ② 创建stu2和stu3对象 
stu2 = Student("小蓝","男")
stu3 = Student("小蓝","男")

# ③ 分别调用三个对象的sex
print(stu.sex)  # 输出女
print(stu2.sex) # 输出男
print(stu3.sex) # 输出男

# ④ 分别调用三个对象的age
print(stu.age)  # 输出20
print(stu2.age) # 报错
print(stu3.age) # 报错
  1. 类可以去访问类属性,但是不可以访问实例属性,对象打点都可以访问。
class Student:
    a = 10
    # 构造函数
    def __init__(self,a,h):
        self.name = a # name、sex 都是实例属性
        self.sex  = h
  

# 创建对象
stu =  Student('小小','男')
# 1.访问类属性:用类和对象  
print(Student.a)
print(stu.a)

# 2.访问实例属性:类和对象
# print(Student.name) # 会报错
print(stu.name)

3. 私有属性

  1. __a:属性前加两个下划线,可以在类里面使用
class Person:
    def __init__(self):
        self.name = '我是Person'
        self.__a = '我是私有属性'
    def a(self):
        print(f"{self.name}方法")
        
        

    
e = Person()
print(e.name)
print(e.a)
  1. 利用函数修改私有属性
class Person:
    def __init__(self):
        self.__a = '我是私有属性'
        
    def aaa(self):
        print("修改前:",self.__a)

    def aa(self,x):
        self.__a=x
        print("修改后:",self.__a)
    
        
        

# ① 实例化对象   
e = Person()
# ② 修改前
e.aaa()
# ③ 修改后
e.aa("我被修改了")

6. 类的方法

1. 实例方法

class Student:
    # 构造方法属于实例方法
    def __init__(self):
        self.name = "小白"
    # 定义一个sayHi实例方法
    def sayHi(self):
        print("这是Sudent中say实例方法")
# 实例化名为stu的对象
stu = Student()
stu.sayHi()  # 通过实例化的方式 对象名打点调用

Student.sayHi(stu) # 使用类名调用实例方法时，需要手动给 self 参数传值

2. 静态方法 (@staticmethod )

class Student:
	# 静态方法
    @staticmethod
    def fun():
        print("这是静态方法")


stu = Student() 
stu.fun()  # 对象名打点调用静态方法

Student.fun()  # #类名打点调用静态方法

3. 类方法 (@classmethod)

class Student:
    # 类方法
    @classmethod
    def fun2(cls):
        print("这是类方法")

Student.fun2()  # 调用

class Student:
    # 类方法
    @classmethod
    def fun2(cls):# cls 类对象的引用
        print('cls:',cls)
        print("这是类方法")


stu = Student()
stu.fun2()
print('stu:',stu)
print('Student:',Student)

注意：
1.通过实例定义的变量只能被实例方法访问
2.在类中定义的静态变量可以被实例方法,被静态方法和类方法访问
3.实例方法不能被静态方法和类方法访问，但静态方法和类方法可以被实例方法访问

4. 私有方法

方法名前加两个下划线

# 子类调用父类的同名属性和方法
class Person:
    def __init__(self):
        self.name = '我是Person'
        self.__B = '我是私有属性'
    def a(self):
        print(f"{self.name}方法")
    def __B(self):
        print("我是私有方法")        
          
e = Person()
print(e.name)
print(e.a)
e.a()
e.B() # Attri buteError:’ Person’ object has no attribute’ B’
AttributeError：‘Person’对象没有属性‘B’

7. 继承

1. 单继承

实现继承的类称为子类(派生类名)，被继承的类称为父类(基类名）

class 派生类名(基类名)
    属性
    方法

class Person: 
    name1 = '我是父'

    def a(self):
        print("我是父方法")


class Emp(Person): 
    name2 = "我是子"

    def b(self):
        print("我是子方法")
        

e = Emp()
# 调用父类
print(e.name1)	
e.a()

在这里插入图片描述

2. 多继承


class Person: 
    name = '我是Person'
    def a(self):
        print("我是Person方法")

        
class Person2:
    name1 = '我是Person2'
    def a(self):
        print("我是Person2方法")

class Emp(Person,Person2):
    name2 = "我是子"
    def b(self):
        print("我是子方法")
        

e = Emp()


print(e.name)	
print(e.name1)	
e.a()

注意:在多继承中,如果一个类有多个父类的话,会优先去继承第一个父类的同名属性和方法。

在这里插入图片描述

3. 重写

1. 子父类拥有同名的属性和方法时

如果子类和父类拥有同名的属性和方法时,子类创建对象去调用属性和方法,调用到的是子类的属性和方法

class Person: 
    name = '我是Person'
    def a(self):
        print("我是Person方法")

        
class Person2:
    name = '我是Person2'
    def a(self):
        print("我是Person2方法")

class Emp(Person,Person2):
    name = "我是子"
    def a(self):
        print("我是子方法")
        

e = Emp()


print(e.name)		
e.a()

在这里插入图片描述

2. 子类调用父类的同名属性和方法

class Person:
    def __init__(self):
        self.name = '我是Person'
    def a(self):
        print("我是Person方法")


class Emp(Person):
    def __init__(self):
        self.name = "我是子"
    def a(self):
        print("我是子方法")
    def b(self):
        Person.__init__(self)
        # print(self)
        Person.a(self)
e = Emp()
#print(e)
e.b()

在这里插入图片描述

3. super()

子类调用父类的同名属性和方法,例2的另外一种写法

# 子类调用父类的同名属性和方法
class Person:
    def __init__(self):
        self.name = '我是Person'
    def a(self):
        print(f"{self.name}方法")
        
        
class Emp(Person):
    def __init__(self):
        self.name = "我是子"
    def a(self):
        print("我是子方法")
    def x(self):
        super(Emp,self).__init__()
        super(Emp,self).a()
    
e = Emp()
e.x()

# 子类调用父类的同名属性和方法
class Person:
    def __init__(self):
        self.name = '我是Person'
    def a(self):
        print(f"{self.name}方法")
        
        
class Person2(Person):
    def __init__(self): 
        self.name = '我是Person2'
    def a(self):
        print(f"{self.name}方法")
        super(Person2,self).__init__()
        super(Person2,self).a()
class Emp(Person2):
    def __init__(self):
        self.name = "我是子"
    def a(self):
        print("我是子方法")
    # super()
    def x(self):
        super(Emp,self).__init__()
        super(Emp,self).a()
    
e = Emp()
e.x()

4. super() 无参

# 子类调用父类的同名属性和方法
class Person:
    def __init__(self):
        self.name = '我是Person'
    def a(self):
        print(f"{self.name}方法")
        
        
class Emp(Person):
    def __init__(self):
        self.name = "我是子"
    def a(self):
        print("我是子方法")
    # super() 无参
    def x(self):
        super().__init__()
        super().a()
    
e = Emp()
e.x()

4. __mro __

可以用来查看类的继承关系

class Person: 
    name = '我是Person'
    def a(self):
        print("我是Person方法")

        
class Person2:
    name = '我是Person2'
    def a(self):
        print("我是Person2方法")

class Emp(Person,Person2):
    name = "我是子"
    def a(self):
        print("我是子方法")
        

e = Emp()
print(Emp.__mro__)

在这里插入图片描述

1024节
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
python 面向对象
weixin_52781385的博客
05-10 5697
【面向对象的基本介绍】 面向过程编程最最易被初学者接受，其往往用一长段代码来实现指定功能，开发过程的思路是将数据与函数按照执行的逻辑顺序组织中一起，数据与函数分开考虑； 《小总结》面向对象和面向过程都是解决为题的一种思路，面向对象是基于面向过程的，一般情况下我们是用面向对象的思维解决问题的，这种解决问题的思路我们就叫做面向过程， 《举列吃鸭子》面向过程：1、养鸭子2、鸭子成长3、杀鸭子4、清理鸭子，准备佐料5、烹饪、6、吃鸭子 面向对象：1、找一个卖鸭子的2、交易给钱3、迟到鸭子 【类和对象】面向
python 面向对象全面详解
日入上万
01-12 5万+
目录   一、对面向对象的理解 1、面向对象的编程---object oriented programming 2、python面向对象的重要术语： 3、函数和面向对象编程的区别 二、封装、继承、多态 1、封装（Encapsulation） 2、继承（Inheritance） 3、多态（Polymorphism） 三、面向对象的各种方法 1、静态方法  (用这个装饰器来表示 ...
python面向对象
weixin_44992737的博客
05-25 1万+
python类详解，python类与对象
Python 面向对象--人狗大战（代码）
热门推荐
菜菜的博客
07-11 206万+
项目实训 人狗大战 多个人，多条狗，多个品种，年龄，攻击力
Python面向对象详解（非常详细）
ZTLJQ的博客
04-21 2万+
面向对象编程（Object-Oriented Programming，OOP）是一种常用的编程思想，它强调万物皆对象，因此在编程时我们可以将现实世界中的事物抽象成程序中的对象，从而更好实现软件的设计与开发。与传统的基于函数的编程不同，面向对象编程注重于将数据与行为封装在一起，即对象既包含数据状态，还包含可调用的行为方法。面向对象编程的特点在于，它具有封装、继承和多态三大特性。封装意味着将对象的状态和行为进行封装，使其对外只暴露必要的接口，从而提高了安全性和可维护性；
Python面向对象案例汇总
数据科学汇集
04-10 3130
Python面向对象微案例
Python 面向对象编程详解
CSDN
08-04 6524
面向对象,OOP英文全称(Object-Oriented Programming)是一种高效的编程思路,面向对象技术已经成为当今软件设计和开发领域的主流技术,面向对象编程是一种编程方式,使用 "类" 和 "对象" 来实现,所以面向对象编程其实就是对 "类" 和 "对象" 的使用,类就是一个模板,模板里可以包含多个方法(函数),方法里实现各种各样的功能,对象则是根据模板创建的实例,通过实例对象可以执行类中的方法,每个对象都拥有相同的方法,但各自的数据可能不同.
python面向对象实验报告_Python 面向对象 | 菜鸟教程
weixin_33966205的博客
01-13 2726
Python 面向对象Python从设计之初就已经是一门面向对象的语言，正因为如此，在Python中创建一个类和对象是很容易的。本章节我们将详细介绍Python的面向对象编程。如果你以前没有接触过面向对象的编程语言，那你可能需要先了解一些面向对象语言的一些基本特征，在头脑里头形成一个基本的面向对象的概念，这样有助于你更容易的学习Python的面向对象编程。接下来我们先来简单的了解下面向对象的一些基...
Python面向对象之继承
ncu5509121083的博客
05-12 1640
Python面向对象之继承,单继承，多继承，super()，私有属性/方法
Python 面向对象--人狗大战（教程）
菜菜的博客
07-11 32万+
项目实训 多条狗，多个人，有名字，品种，年龄，攻击力 狗可以咬人，人可以打狗 当有多个实体的情况下，就可以使用模板的形式来使用； 定义一个函数dog，将需要的参数写入字典data，返回data，就完成了模板 再d1给到dog所需要的参数name，d_type也就是实体了，实体可以有很多个 再进行输出print...
python面向对象练习题.pdf
09-04
### Python面向对象编程知识点解析 #### 一、面向对象三大特性及作用 **1. 封装** 封装是面向对象编程中的一个重要概念，它通过隐藏类的内部细节并对外提供公共接口来保护数据的安全性和完整性。封装使得类的使用...
面向对象编程基础_python面向对象_python教程_
09-29
以上就是Python面向对象编程的基本概念和特性。掌握这些基础知识，能帮助你更好地理解和编写Python程序，尤其在处理复杂逻辑和大型项目时，面向对象编程的优势会更加明显。在实际应用中，不断实践和探索，才能真正...
python面向对象课件
11-12
面向对象编程（Object-Oriented Programming，简称OOP）是Python编程中的核心概念之一，它是一种编程范式，强调通过创建对象来组织代码，使得程序更易于理解和维护。本课件详细介绍了Python中的面向对象特性，包括类...
Python面向对象编程指南
06-19
本套视频教程致力于深入讲解Python语言的面向对象编程思想，通过丰富、强大的代码示例为学员循序渐进地讲解如何编写高质量的Python代码。通过实际的例子对Python中面向对象编程的理念进行介绍。针对所有可用于和...
如何在Python中使用IP代理
IPIPGO的博客
08-23 357
通过以上步骤，你应该已经学会了如何在Python中使用IP代理。无论是单个代理IP、带认证的代理IP，还是批量使用代理IP，这些方法都能帮助你在实际项目中灵活应用。希望这篇文章对你有所帮助，如果你有任何问题或建议，欢迎在评论区留言，我们会尽力为你解答。t=N7T8。
常见面试问题(Python)
jiao_mrswang的博客
08-23 130
5、GIL全局解释锁。
零基础学习人工智能—Python—Pytorch学习（六）
kiba518的博客
08-21 854
前言 本文主要讲神经网络的上半部分。 这篇文章开始有很多公式了，这些公式都很简单，但是如果是不经常在脑海里思考公式的人，那可能需要多花点时间做一下自我训练，个人感觉，也就几天时间，就能把自己感觉给调整出来。 习惯了公式看下面内容就会轻松很多，另外如果要深入学习人工智能，熟练的认知公式也是个必须的事情。 另外，我发现我前面文章写的有歧义的地方还是挺多，虽然，已经改了一部分，但，可能还有没发现的，大...
Python优化算法09——黏菌优化算法(SMA)
最新发布
weixin_46277779的博客
08-24 434
python黏菌优化算法代码和使用
Python 面向对象
09-03
Python面向对象编程是一种编程范式，它将程序组织成对象的集合，每个对象都有自己的属性和方法。在Python中，可以通过定义类来创建对象，并通过实例化类来创建具体的对象。引用[1]中的代码示例展示了一个Animal类，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

1024节

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值