python面向对象的编程,python支持面向对象的编程技术

　　使用(面向对象)对象的(属性和方法)进行编码的过程就是面向对象编程。本文将通过实例详细介绍Python中的面向对象编程，有需要的可以参考。

　　00-1010面向对象编程(class)类的关键词是什么-类参数的定义和使用-自我类的构造函数的分析和总结-构造函数的创建方法关于对象的生命周期

什么是面向对象编程(类)

　　Class关键字用于声明一个类，类名首字母大写。在有多个单词的情况下，每个单词首字母大写(即驼峰命名)。我们刚学Python的时候说过要尽量避免驼峰命名，但是类的命名是个特例，类的命名可以用驼峰命名。

类的关键字 - class

　　类别定义的示例如下：

　　Nmae类(对象):

　　# class关键字类名(首字母大写)括号(括号内object:是python中的通用对象，写通用对象的类会有更多的内置函数)冒号

　　变量=变量的值

　　#可以定义该类的变量

　　定义功能(自身):

　　做

　　#还可以定义一个类的函数：类函数中有一个必需的参数‘self’，必须写在类函数的第一个参数位。这是python的内部语法。

　　#需要注意的是，类的属性要和函数的缩进统一。

　　使用类的示例如下：

　　#定义一个动物类；在animal类中定义一个变量；定义一个运行函数(属性)

　　Class Animal(object):#定义一个类

　　Name= Husky #类变量(类属性)

　　Def run(self):# #类函数：将self作为第一个参数传入类函数 run()

　　打印(f{self.name}可以运行)

　　#“self . name”是一个类属性；如果是“自我”未添加，将找不到class属性；如果要在类函数中调用类属性，必须添加 self

　　# self 参数有两个功能

　　# 1.它可以帮助我们调用类属性

　　# 2.在类中使用self调用函数。如果我们有另一个函数，我们可以用 self 调用run函数。在另一个函数中。

　　dog=Animal()# class的实例化

　　通过实例化调用Print(dog.name)#属性

　　Dog.run()#通过实例化进行函数调用。

　　#执行结果如下：

　　#哈士奇

　　#哈士奇能跑

类的定义与使用

　　在类中，所有的实例方法都需要添加self参数，并且排在第一位，而且只有一个。

　　self参数的含义：在类中定义的方法。第一个参数self指向调用该方法的实例对象。在方法中，以self的形式访问对象的实例属性。财产。

　　Self是类函数中的必需参数，必须放在第一个参数位置。self是一个对象，表示实例化的变量本身。self可以通过点号(，直接定义一个类变量比如self.name=Neo。)，而如果在函数体中定义了变量，可以用self的名字来赋值。可变。self中的变量和带self参数的函数可以在类中的任何函数中自由调用。非函数中定义的变量在计时时不需要使用自如何理解 self 参数。

　　类似

　　如果班级

　　比作造房子的图纸

类实例化后的对象是真正可以住的房子

根据一张图纸（类），可以设计出成千上万的房子（实例对象）

每个房子长相都是类似的（都有相同的实例属性和实例方法），但它们都有各自的主人

如何区分不同的房子：通过 self 参数，可以保证每个房子的主任仅能进入自己的房子（每个实例对象只能调用自己的实例属性和实例方法）

　　重点

一个类可以产生多个实例对象，当某个实例对象调用实例方法，该对象会把自身的引用作为第一个参数自动传递给该方法
换句话说：Python 会自动将实例方法的第一个参数指向调用该方法的对象
这样，Python 解释器就知道到底要执行哪个对象的实例方法了
调用实例方法的时候，不需要手动为第一个参数传值

　　可能大家还不是很理解，根据类的两个关键要素属性和方法，具体来使用self看看实际应用效果：

class Persion(object):
　　 name = None
　　 age = None
　　 def run(self):
　　 print(f{self.name} 的健身项目是\跑步\)
　　 def swim(self):
　　 print(f{self.name} 的健身项目是\游泳\)
　　neo = Persion()
　　neo.name = Neo
　　neo.run()
　　# >>> 执行结果如下：
　　# >>> Neo 的健身项目是跑步

　　我们再重新实例化一个对象，看看这个新的实例化对象是否同步了 neo.name

class Persion(object):
　　 name = None
　　 age = None
　　 def run(self):
　　 print(f{self.name} 的健身项目是\跑步\)
　　 def swim(self):
　　 print(f{self.name} 的健身项目是\游泳\)
　　neo = Persion()
　　neo.name = Neo
　　neo.run()
　　jack = Persion()
　　jack.run()
　　# >>> 执行结果如下：
　　# >>> Neo 的健身项目是跑步
　　# >>> None 的健身项目是跑步

　　从输出结果可以看到我们修改的 neo 实例化对象的对应的 name 的值仅作用于自己的实例，而 Persion 类，与新的 jack 实例化对象并没有受到影响。

　　所以即使使用新的对象进行实例化，还是需要新的实例化对象来修改类的属性，来达到我们自己想要的效果。其实很好理解，都是人类，但是每个人的个体化都是不同的。所以他们拥有人类的共同属性后 (name，age) ，也可以自定义自己的属性。

　　现在我们的 Persion 类定义了两个属性 'name' 与 'age' ，如果我们再添加一个属性呢？，其实是可以的。现在我们针对 'Jack' 增加一个自定义属性，尝试一下。

class Persion(object):
　　 name = None
　　 age = None
　　 def run(self):
　　 print(f{self.name} 的健身项目是\跑步\)
　　 def swim(self):
　　 print(f{self.name} 的健身项目是\游泳\)
　　neo = Persion()
　　neo.name = Neo
　　neo.run()
　　jack = Persion()
　　jack.top = 180
　　print(\Jack\的身高是, jack.top)
　　# >>> 执行结果如下
　　# >>> Neo 的健身项目是跑步
　　# >>> Jack的身高是 180
　　print(\Neo\的身高是, neo.top)
　　# >>> 执行结果如下：
　　# >>> AttributeError: Persion object has no attribute top

　　从上面的 jack.top 与 neo.top 的自定义属性，我们发现三件事。

　　1.实例化对象可以自定义属性

　　2.每个实例化对象自己定义的属性与其他实例化对象不通用。

　　3.Persion类在实例化对象之后，依然只有自己的两个属性 (name 和 age) ，实例化对象自定义的属性仅作用于自己，并不影响类。

self 的解析与总结

　　说实话，关于 Python 中的 self 我一开始接触的时候，也是给我搞的云里雾绕、五迷三道的…这里做个总结，希望对同样云里雾绕、五迷三道的童鞋有所帮助。

Python 中 self 代表的是类的示例； self 在定义类的方法时是必须有的，虽然在调用时不必传入相应的参数。
Python 中 self 只有在针对类的情况下，才是有意义的。
self 只能用在 python 类的方法中。

　　具体的举例说明如下：

　　属性

　　关于属性 - 1：如果变量定义在类下面而不是类的方法下面，那这个变量既是类的属性也是类实例的属性。

class Cat(object):
　　 eyes = 有2只眼睛
　　 legs = 有4条腿
　　 tail = 有1只尾巴
　　dragonLi = Cat()
　　dragonLi.name = 狸花猫
　　dragonLi_eyes = dragonLi.eyes
　　dragonLi_legs = dragonLi.legs
　　dragonLi_tail = dragonLi.tail
　　print( 猫 + Cat.eyes, Cat.legs, Cat.tail)
　　print(dragonLi.name, dragonLi_eyes, dragonLi_legs, dragonLi_tail)
　　# >>> 执行结果如下：
　　# >>> 猫 有2只眼睛 有4条腿 有1只尾巴
　　# >>> 狸花猫 有2只眼睛 有4条腿 有1只尾巴

　　关于属性 - 2：如果变量定义在类的方法下面，如果加了self，那这个变量就是类实例的属性，不是类的属性；如果没有加self，这个变量只是这个方法的局部变量，既不是类的属性也不是类实例的属性。

class Cat(object):
　　 eyes = 有2只眼睛
　　 legs = 有4条腿
　　 tail = 有1只尾巴
　　 def __init__(self):			# 关于__init__() 会在下面的 类的构造器有详细讲解
　　 self.color_01 = 黄棕色
　　 color_02 = 黑棕色
　　dragonLi = Cat()
　　dragonLi_color_01 = dragonLi.color_01
　　print(狸花猫有两种披毛颜色，一种是：, dragonLi_color_01)
　　# >>> 执行结果如下：
　　# >>> 狸花猫有两种披毛颜色，一种是： 黄棕色
　　dragonLi_color_02 = dragonLi.color_02
　　print(狸花猫有两种披毛颜色，另一种是：, dragonLi_color_02)
　　# >>> 执行结果如下：
　　# >>> AttributeError: Cat object has no attribute color_02.

　　方法

　　关于方法1：如果在类中定义函数时加了self，那这个函数是类实例的方法，而不是类的方法。

class Cat(object):
　　 def eat(self):
　　 print(爱吃鱼)
　　dragonLi = Cat()
　　dragonLi.eat()
　　# >>> 执行结果如下：
　　# >>> 爱吃鱼
　　Cat.cat()
　　# >>> 执行结果如下：
　　# >>> TypeError: Cat.eat() missing 1 required positional argument: self

　　关于方法2：如果在类中定义函数时候没有加self，那这个函数就只是类的方法，而不是类实例的方法。

class Cat(object):
　　 def eat():
　　 print(爱吃鱼)
　　Cat.eat()
　　# >>> 执行结果如下：
　　# >>> 爱吃鱼
　　dragonLi = Cat()
　　dragonLi.eat()
　　# >>> 执行结果如下：
　　# >>> TypeError: Cat.eat() takes 0 positional arguments but 1 was given

　　小结

　　属性：

如果变量定义在类下面而不是类的方法下面，那这个变量既是类的属性也是类实例的属性。
如果变量定义在类的方法下面，如果加了self，那这个变量就是类实例的属性，不是类的属性；如果没有加self，这个变量只是这个方法的局部变量，既不是类的属性也不是类实例的属性。

　　方法：

如果在类中定义函数时加了self，那这个函数是类实例的方法，而不是类的方法。
如果在类中定义函数时候没有加self，那这个函数就只是类的方法，而不是类实例的方法。

类的构造函数

　　前面我们了解了类的创建、类的属性、类函数的使用方法，现在我们再来看看类的构造函数。

　　什么是类的构造函数？ —> 构造函数是类中的一种默认函数，通过定义它可以在类实例化的同时，将参数传入类中。（类似于函数执行的时候可以传一些参数）

构造函数的创建方法

　　重点：构造函数依然要在类中定义

def __init__(self, a, b) # def关键字 + __init__ + 小括号(括号内第一个传入的依然是 self ，后面再跟上希望实例化时传入的参数)
　　 self.a = a # 在构造函数里，将参数绑定在 self 中，将变量通过 self 绑定之后，就可以在类的各个函数中进行调用了
　　 self.b = b

　　构造函数的用法，示例如下：

class Test(object):
　　 def __init__(self, a):		# __init__ 构造函数一定要写在第一个，这是一个很好的编程规范
　　 self.a = a
　　 def run(self):
　　 print(self.a)
　　test = Test(1)
　　test.run()
　　# >>> 执行结果如下：
　　# >>> 1
　　test_02 = Test(Hello)
　　test_02.run()
　　# >>> 执行结果如下：
　　# >>> Hello

　　接下来我们再使用构造函数针对前面我们创建的 Cat 类进行修改

class Cat(object):
　　 def __init__(self, eyes, legs, tail, color=黄棕色):
　　 self.eyes = eyes
　　 self.legs = legs
　　 self.tail = tail
　　 self.color = color
　　 def show_cat(self):
　　 self.work = 抓老鼠
　　 print(猫的通用属性为, self.eyes, self.legs, self.tail)
　　dragonLi = Cat(2只眼睛, 4条腿, 1只尾巴)
　　dragonLi.show_cat()
　　# >>> 执行结果如下：
　　# >>> 猫的通用属性为 2只眼睛 4条腿 1只尾巴 黄棕色
　　dragonLi.name = 狸花猫
　　dragonLi.color = 虎斑色
　　print(dragonLi.name, dragonLi.eyes, dragonLi.legs, dragonLi.tail, dragonLi.color, dragonLi.work)
　　# >>> 执行结果如下：
　　# >>> 狸花猫 2只眼睛 4条腿 1只尾巴 虎斑色 抓老鼠

关于对象的生命周期

　　注意：这里说的对象的生命周期，指的是实例化的对象。

　　之前我们提到过，当一个变量不使用的时候就会被内存管家清理掉。接下来我们就来看看一个变量的一生，从出现到消亡的过程。之所以在这里插上这一章节介绍对象的生命周期，也是为了更好的理解对象，从而更好的使用他们。

　　我们之前学习的深拷贝与浅拷贝，浅拷贝是创建一个新的内存地址，而深拷贝是使用之前已经定好的变量。

　　通过对一个对象的生命周期的理解，可以让我们权衡是终结一个对象还是继续使用它们。

　　我们通过构造函数完成一个对象的实例化，这个时候一个对象的生命周期就开始了，在这个时候内存管家发现有一个对象的加入就会为这个实例化的对象分配一个内存地址（也就是实例化对象在内存中的家）。

　　接下里我们就可以操作这个对象，可以调用它的内置函数还有功能。当我们不使用这个对象的时候，一般有两种情况；

　　第一种是这个内存块中的值没有变量与之绑定了，比如当我们的一个变量的默认值被一个函数调用后变量有了新的值，这个时候变量原有的默认值与变量不再是赋值关系了。

　　第二种是当我们执行完了所有的程序，也就是代码已经执行到了最后一行。 Python 解释器发现已经处理完了所有的业务，这个时候脚本就会停止处理并释放脚本中所有的对象，释放所有的对象其实就是告知内存管家，内存管家就会自动处理这些对象的内存地址。

　　以上两种情况的统一表现形态都是不再使用这些对象，这个时候每个对象中自带的内置函数 __del__ （两个下划线）就会被调用，通知内存管家从内存中释放每个对象对应的内存块。这就是整个对象的生命周期。

　　无论是字符串、数字、列表、元组、字典、集合，甚至布尔类型与空类型，我们知道 Python 中一切皆是对象，所以它们也是按照这个规律存在于消亡。

　　Python 中的内存管理都是自动去完成的，所以我们并不需要特意的去对它进行专门的处理。

　　关于 __del__ 函数并不需要我们书写和定义，当我们实例化一个对象之后，它就会默认存在，并拥有自动通知内存管家清理内存的功能。这也是 Python 的特点之一。

　　以上就是Python学习之面向对象编程详解的详细内容，更多关于Python面向对象编程的资料请关注盛行IT软件开发工作室其它相关文章！

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。