当前位置:   article > 正文

python语法(七)面向对象_索引和分片重载的主要方法有

索引和分片重载的主要方法有

面向对象

  • 基本概念:
    • 面向过程:
      把完成某一个需求的所有步骤 从头到尾 逐步实现,根据开发需求,将某些 功能独立 的代码封装成一个又一个函数,最后完成的代码,就是顺序地调用不同的函数

    • 面向对象:
      是更大的封装,根据 职责 在一个对象中封装多个方法

    • 类 是对一群具有 相同 特征 或者 行为的事物的一个统称,是抽象,不能直接使用

      • 特征 被称为 属性
      • 行为 被称为 方法
        类相当于制造飞机时的图纸,是一个模板,是负责创建对象
      • 对象
        对象 是 由类创建出来的一个具体存在,可以直接使用,由哪一个类创建出来的对象,就拥有在哪一个类中定义的:属性方法,先有类再有对象
        	Class Person():
        		name = "xxx"
                	def __init__(self):
                      		pass
        	Person.name
        	p1 = Person()
      
      • 1
      • 2
      • 3
      • 4
      • 5
      • 6

类的设计

类名: 这类事物的名字,满足大驼峰命名法:首字母大写,单词之间没有下划线
属性: 这些事物具有什么样的特征
方法: 这类事物具有什么样的行为
(1)定义简单的类
格式:

  class 类名:
	def 方法1(self,参数列表):
		pass
	def 方法2(self,参数列表):
		pass
  #切记如果函数有参数,第一个参数必须是self
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

(2)对象的创建
对象变量 = 类名()
第一个面向对象程序:
需求

  • 小猫爱吃鱼,小猫要喝水
  • 定义一个猫类 Cat
  • 定义两个方法 eat 和 drink
  • 按照需求–不需要定义属性
class Cat:
	def eat(self):
		pirnt("小猫爱吃鱼")
	def drink(self):
		print("小猫要喝水")
  • 1
  • 2
  • 3
  • 4
  • 5

(3)构造方法
1.初始化方法
以前面的class类为例子:py中可以在类外部给类添加属性:

 tom = Cat()
 tom.name = "Tom"
 tom.eat()
  • 1
  • 2
  • 3

不建议使用
如果name 是方法 这样赋值就会失去 该方法,推导->一个类的属性应该放在什么地方?
2.构造方法
当使用 类名()创建对象时,会自动执行以下操作:

  1. 为对象在内存中分配空间–创建对象
  2. 为对象的属性设置初始值–初始化方法(init)
  3. __init__方法是专门用来定义一个类具有哪些属性的方法!
class Cat:
     """这是一个猫类"""
    def __init__(self):
       print("初始化")
    def eat(self):
       print("小猫爱吃鱼")
    def drink(self):
        print("小猫要喝水")
tom = Cat()
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

就会自动输出: 初始化
3.在初始化方法内部定义属性
在__init__方法内部使用 self.属性名 = 属性的初始值,就可以定义属性,定义属性之后,在使用Cat类创建的对象都会拥有该属性
4.改造初始化方法–初始化的同时设置初始值
在开发中,如果希望在创建对象的同时,就设置对象的属性,可以对 __init__方法进行改造

  1. 把希望设置的属性值,定义成__init__方法的参数
  2. 在方法内部使用self.属性 = 形参 接收外部传递的参数
  3. 在创建对象时,使用 类名(属性1,属性2…)调用
class Cat:
     """这是一个猫类"""
    def __init__(self,name):
       print("初始化")
       self.name = name
    def eat(self):
       print("小猫爱吃鱼")
    def drink(self):
        print("小猫要喝水")
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

5.析构方法
(1)del 对象被从内存中销毁的,会被自动调用
当使用 类名() 创建对象时,为对象 分配完空间后,自动调用 init 方法,当一个 对象被从内存销毁 前,会 自动 调用 __del__方法
应用场景:
__init__改造初始化方法,可以让创建对象更加灵活
__del__如果希望在对象被销毁前,再做一些事情,可以考虑一下__del__方法
生命周期:
一个对象从调用 类名() 创建,生命周期开始,一个对象的__del__方法一旦被调用,生命周期结束,在对象的生命周期内,可以访问属性,或者让对象调用方法
(2)str 返回对象的描述信息,print函数输出使用
6.方法中的self参数
在Python类中规定,函数的第一个参数是实例对象本身,并且约定俗成,把其名字写为self。其作用相当于java中的this,表示当前类的对象,可以调用当前类中的属性和方法。self 指向的是当前 调用类中方法的实例对象
7.四则运算符重载
四则运算加,减,乘,除(+,-,*,/)分别是通过调用 __ add __ , __ sub __ , __ mul __
和__truediv__方法完成重载的。当两个实例对象执行四则运算时,自动调用的是它们对应的方法

创建一个Employee()类
class Employee(object):
	def __init__(self,name,age):
		self.name = name
		self.age = age

zs =Employee("张三",20)
ls = Employee("李四",26)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
#想要实现求得二者的平均年龄
sum_age = (zs.age + ls.age)/2
print(sum_age)
  • 1
  • 2
  • 3
//现在想优化加法 让其可以实现 zs + ls
class Employee(object):
	def __init__(self,name,age):
		self.name = name
		self.age = age
	def __add__(self,other):
		return self.age + other.age


sum_age = (zs + ls)/2
print(sum_age)
#这样即可
减法,除法,乘法依次类推  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
小测试:实现 a + b 返回的结果是 a - b,a - b 返回的结果是a + b 
就是,重写__add__() 和 __sub__()

class New_int(int):
       def __add__(self,other):
             return  int.__sub__(self,other)
       def __sub__(self,other):
              return int.__add__(self,other)


a = New_int(3)
b = New_int(1)
a + b = 2
a- b = 4
错误演示
class New_int(int):
       def __add__(self,other):
             return  self+other
       def __sub__(self,other):
              return self-other

a = New_int(3)
b = New_int(1)
a + b
这样会陷入无限递归
原因是:
self+other这两个相加等于调用def __add__(self,other)
class New_int(int):
       def __add__(self,other):
             return  int(self)+int(other)
       def __sub__(self,other):
              return int(self)-int(other)
这样就可以了
  • 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

反运算
a + b 当a 的__add__()函数不能正常用时
就会调用b的__radd__()函数
举个例子

class New_int(int):
       def __radd__(self,other):
             return __sub__(self,other)

a = New_int(3)
b = New_int(1)
a+ b = 4
1 +  b = 0
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

__ rsub __()也是如此

索引和分片重载
以下是跟索引和分片相关的三个可重载方法:
__ getitem __ :索引,分片取值
__ setitem __:索引,分片赋值
__ delitem __:索引和分片删除

这三个方法都可以进行重载,具体方法如下
__getitem__方法
在对实例对象执行索引,分片或者for迭代操作取值时,会自动调用__getitem__方法。
例如:

class Company(object):
	def __init__(self,boss,ls):
		self.boss = boss
		self.ls = ls
company = Company("刘备",["关羽","张飞","赵子龙","黄忠"])
  • 1
  • 2
  • 3
  • 4
  • 5

想要输出列表中的某一个可用 company.ls[i]
这样显得不怎么方便

class Company(object):
	def  __init__(self,boss,ls):
		self.boss = boss
		self.ls = ls
	def  __getitem__(self,item): #item 是一个切片对象
		return self.ls[item]
company[i] 即可输出第i个数据  #如果这里是下标,item就是下标
company[i:]#这里是切片的用法,所以 item 也是一个切片对象 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

其他的几个方法:

class Company(object):
	def  __init__(self,boss,ls):
		self.boss = boss
		self.ls = ls
	def  __getitem__(self,item): #item 是一个切片对象
		return self.ls[item]
	def  __setitem__(self,key,value):
		self.ls[key] = value
	def  __delitem__(self,key):
		del self.ls[key]
company[i] = "内容"
del company[1]
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

删除和修改都可以使用这种简介方法来使用了
重写 __ str__ 方法
在 python 中,使用print输出对象变量,默认情况下,会输出这个变量引用的对象是由哪一个类创建的对象,以及在内存中的地址(十六进制表示)
如果在开发中希望使用 print 输出对象变量时,能够打印自定义的内容,就可以利用__str__这个内置方法了
注意:__ str__方法必须返回一个字符串

class Cat:
	def __init__(self,new_name):
		self.name = new_name
		print("%s 来了" % self.name)
	def __str__(self):
		return "我是小猫:%s" % self.name
tom = Cat("Tom")
print(tom)
如果想要输出默认情况则可
print(repr(tom))
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

8.面向对象的封装
封装:
1.封装是面向对象编程的一大特点
2.面向对象编程的第一步 - - 将属性 和 方法 封装到一个抽象的类中
3.外界使用类创建对象,然后让对象调用方法
4.对象方法的细节 都被 封装 在类的内部
5.一个对象的属性可以是另一个类创建的对象
需求:士兵突击

士兵 许三多 有一把 AK47
士兵 可以 开火
枪 能够 发射 子弹
 枪 装填 装填子弹 --增加子弹数
Soldier 类,属性:name ,gun
方法:
__init__(self):
fire(self): 
#1.判断 士兵是否有枪  2. 高喊口号  3.让枪装填子弹  4.让枪发射子弹
Gun 类
属性:
model
bullet_count
方法:
__init__(self,model):
add_bullet(self,count):
shoot(self):
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

身份运算符:
身份运算符用于比较两个对象的内存地址 是否一致 --是否是对同一个对象的引用
在 python 中针对 None 比较时,建议使用 is

运算符描述实例
isis是判断两个标识符是不是引用同一个对象x is y. 类似 id(x) == id(y)
is notis not 是判断两个标识符是不是引用不同对象x is not y, 类似 id(x) != id(y)

is 与 = = 区别:
is 用于判断两个变量 引用对象是否为同一个,== 用于判断引用变量的值 是否相等
意思就是:两个事物值相等但是其地址可以不一样
私有属性和私有方法
应用场景及定义方式
应用场景:

  • 在实际开发中,对象 的 某些属性或方法 可能只希望 在对象的内部被使用,而 不希望在外部被访问到
  • 私有属性 就是 对象 不希望公开的 属性 在外界不能被直接被访问
  • 私有方法 就是 对象 不希望公开的 方法 在外界不能被直接被访问

定义方式:
在 定义属性或方法时,在属性名或者方法名前 增加 两个下划线,定义的就是 私有 属性或方法
但是在python中是伪私有属性和私有属性(科普)
提示:在日常开发中,不要使用这种方式,访问对象的 私有属性 或 私有方法 python 中,并没有真正意义 的 私有
在给属性,方法命名时,实际上是对 名称 做了一些特殊处理,使得外界无法访问到
处理方式:在名称前面加上 _类名__名称

8.单继承
面向对象三大特征

  1. 封装 根据 职责 将 属性 和 方法 封装 到一个抽象的类中
  2. 继承实现代码的重用,相同的代码不需要重复的编写
  3. 多态 不同的对象调用相同的方法,产生不同的执行结果,增加代码的灵活度

(1)继承的概念,语法和特点:
继承的概率:子类拥有父类的所有方法 和 属性
e.g:
不使用继承:
编写 1.Animal 类 2.Dog 类 3.Cat 类 4.Chinese_garden_dog
Animal 的特性 吃,喝,睡…
Dog 的特性 吃,喝,睡…
Cat 的特性 吃,喝,睡…

可以发现这些类都具有一些相同的属性或者行为(方法),不使用继承就会造成这部分代码的累赘。

e.g:
class Animal:
     def eat(self):
         print("吃")
     def drink(self):
         print("喝")
     def sleep(self):
         print("睡觉")


class Dog(Animal):
     def bark(self):
         print("汪汪")


class Cat(Animal):
     def bark(self):
         print("喵喵")
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

(2)继承的语法

         class 类名(父类名):
			pass
  • 1
  • 2

子类继承自 父类,可以直接 享受 父类中已经封装好的方法,不需要再次开发
子类中应该根据 职责,封装 子类特有的属性和方法
专业术语:

       Dog 类是 Animal 类的子类,Animal 类是 Dog 类的父类,Dog 类从 Animal 类继承
       Dog 类是 Animal 类的派生类,Animal 类是Dog 类的基类,Dog类从Animal 类派生
  • 1
  • 2

继承的传递性:
C类从B类继承,B类又从A类继承
那么C类就具有B类和A类的所有属性和方法
子类 拥有 父类以及 父类的父类 中封装的所有属性 和 方法
9.多继承
子类 可以拥有 多个父类,并且所有具有所有父类的属性和方法
语法格式:

	class 子类名(父类名1,父类名2.....):
		pass
  • 1
  • 2

注意事项:
如果 不同的父类 中存在同名的方法,子类对象 在调用方法时,会调用哪一个父类方法?

e.g:
class A:
	def fun1():
		print("A----fun1")
	def fun2():
		print("A----fun2")
class B:
	def fun1():
		print("B----fun1")
	def fun2():
		print("B----fun2")

class C(A,B):
	pass

c = C()
c.fun1()
c.fun2()

class c(B,A):
	pass

c = C()
c.fun1()
c.fun2()
  • 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

在开发时,应该尽量避免这种容易产生混淆的情况!–如果父类之间存在同名的属性或者方法,应该 尽量避免 使用多继承
python 中的 MRO – 方法搜索顺序(知道)
python 中针对 类提供了一个内置属性 __mro__可以查看方法 搜索顺序
MRO 是 method resolution order,主要用于 在多继承时判断 方法,属性的调用路径
print(C. __ mro __)

在搜索方法时,是按照 __mro__的输出结果从左到右 的顺序查找的
如果在当前类中 找到方法,就直接执行,不再搜索
如果没有找到,就查找下一个类 中是否有对应的方法,如果找到,就直接执行,不再搜索
如果找到最后一个类,还没有找到方法,程序报错

新式类 和 旧式类
object 是 python 为所有对象提供的基类,提供有一些内置的属性和方法,额可以使用 dir 函数查看
新式类 : 以object 为基类的类,推荐使用 py3都是这样
旧式类: 不以object为基类的类,不推荐使用

10.重写父类方法与调用父类方法和属性
子类 拥有 父类的所有方法 和 属性
子类 继承自父类,可以直接享用父类中已经安排好的方法,不需要再次开发

当父类的方法实现不能满足子类需求时,可以对方法进行重写
重写父类方法两种情况
1.覆盖父类的方法
2.对父类方法进行 扩展
(1)覆盖:
具体实现方法,就相当于在子类中 定义了一个和父类同名的方法并且实现
(重写后,在运行时只会调用子类中重写的方法,而不会调用 父类封装的方法)
(2)扩展:
如果开发中,子类的方法实现 中 包含 父类方法的实现
父类原本封装的方法实现 是 子类方法的一部分
这里就可以使用 扩展 的方法
- 在子类中 重写 父类的方法
- 在需要的位置使用 super().父类方法,来调用父类方法的执行
- 代码其他的位置针对子类的需求,编写子类特有的代码实现
- 也可以 父类名.方法(self)
父类名.方式(self)#调用未绑定的父类的方法,可以通过父类.方法名调用,并且此时的self是子类的属性
super().父类方法#也可以通过super()函数调用,推荐使用super()函数,可以自动找到父类的属性,我们可以不用手动传参

11.多态
不同的 子类对象 调用相同的 父类方法,产生不同的执行结果
-多态 可以 增加代码的灵活度
-以 继承 和 重写 父类方法为前提
-是调用方法的技巧,不会影响到类的内部设计
12.
类对象:就是类本身,支持两种操作:属性引用和实例化 ,上述的例子中 Person 就是类对象
实例对象:由类实例化出来的对象 唯一操作是属性引用,p1就是实例对象
类属性:就是类对象所拥有的属性,它被所有类对象的实例对象所共有,在内存中只存在一个副本;对于公有的类属性,在类外可以通过类对象和实例对象访问
e.g:

class Tool:
	count = 0 # 类属性
	def __init__(self,name):
		self.name = name
		Tool.count += 1
  • 1
  • 2
  • 3
  • 4
  • 5

-类属性 就是给 类对象 中定义的属性
-通常用来记录 与这个类相关的特征
-类属性不会用于记录 具体对象的特征
访问类属性有两种方式:
(1)类名.类属性:
(2)对象.类属性(不推荐)

  • 向上查找机制:首先在对象内部查找对象属性,没有找到就会向上寻址类属性
    如果使用 对象.类属性 = 值,只会给对象添加一个属性,而不会影响到类属性的值
  • 实例属性:类的实例化对象的属性,属于实例对象独有
    类对象和实例对象都可以访问类属性
    类对象无法访问实例对象
    类属性只有通过类对象进行修改,实例对象无法修改类属性,通过实例对象给类属性进行赋值,
    实际上是给实例对象临时添加了一条新的属性
  • 类方法:
    类方法:是类对象所拥有的方法,需要用修饰器"@classmethod"来标识其为类方法,
    对于类方法,第一个参数必须是类对象,一般以"cls"作为第一个参数(只是一个参数命名习惯,也可以换成其他的,不过不推荐)
    能够通过实例对象和类对象去访问。
    类方法的一个用途就是可以对类属性进行修改, 这样的话,实例对象通过调用类方法也可以对类属性进行修改
e.g:
class Tool:
	count = 0 # 类属性
	@classmethod#类方法 , cls.属性, cls.类方法名
	def show(cls):
		print("数量"%cls.count)
	def __init__(self,name):
		self.name = name
		Tool.count += 1
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 实例方法:在类中最常定义的成员方法,它至少有一个参数并且必须以实例对象作为其第一个参数,一般以名为"self"的变量作为第一个参数。 在类外实例方法只能通过实例对象去调用,不能通过其他方式去调用(其实类对象可以调用实例方法,只不过需要传一个实例对象作为第一个参数)。
  • 静态方法:
    需要通过修饰器 @staticmethod 来进⾏修饰,静态⽅法不需要多定义参数
    跟普通函数没什么区别,与类和实例都没有所谓的绑定关系,不论是通过类还是实例都可以引用该方法。
    静态方法使用场景:如果在方法中不需要访问任何实例方法和属性,纯粹地通过传入参数并返回数据的功能性方法,那么它就适合用静态方法来定, 它节省了实例化对象的开销成本,往往这种方法放在类外面的模块层作为一个函数存在也是没问题的,而放在类中,仅为这个类服务。
  • 语法方式:
@staticmethod
def  静态方法名():
	pass
通过 类名.调用静态方法
  • 1
  • 2
  • 3
  • 4
声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/木道寻08/article/detail/761924
推荐阅读
相关标签
  

闽ICP备14008679号