python---面向对象(类和对象)

面向对象的基本介绍

开发过程的思路是将数据与函数按照执行的逻辑顺序组织在一起，数据与函数分开考虑

面向对象和面向过程都是解决问题的一种思路

 类和对象

对象是面向对象编程的核心，在使用对象的过程中，为了将具有共同特征和行为的一组对象抽象定义，提出了另外一个新的概念——类

类

具有相似内部状态和运动规律的实体的集合(或统称为抽象)。

具有相同属性和行为事物的统称

人以类聚 物以群分。

类是抽象的,在使用的时候通常会找到这个类的一个具体的存在,使用这个具体的存在

对象

某一个具体事物的存在 ,在现实世界中可以是看得见摸得着的

可以直接使用的

 类的构成

01). 类的名称:类名

02). 类的属性:一组数据

03). 类的方法:允许对进行操作的方法 (行为)

定义类

定义类时有2种形式：新式类和经典类，

                                        新式类:         class 类名(父类名):

                                        经典类:         class 类名:

object是Python里所有类的最顶级父类

类名 的命名规则按照"大驼峰命名法"；

#定义一个hero类 
class Hero(object):
    #定义一个实例化方法
    def info(self)
        print("英雄各有所见,何必追问出处")

info 是一个实例方法，第一个参数一般是self，表示实例对象本身，当然了可以将self换为其它的名字，其作用是一个变量 这个变量指向了实例对象 

创建对象

python中，可以根据已经定义的类去创建出一个或多个对象。

创建对象的格式为:（实例化对象）

        对象名1 = 类名()

        对象名2 = 类名()

        对象名3 = 类名()

对象创建并添加属性后,在方法内通过self获取对象属性

 添加和获取对象的属性

class Hero(object):
    '''定义一个英雄类,可以移动和攻击'''
    def move(self):
        '''实例方法'''
        print('正在前往事发地点....')
 
    def attack(self):
        '''实例方法'''
        print('发出了一招强有力的普通攻击')
# 实例化一个对象
t=Hero()
 
# 给对象添加属性及相应的属性值
t.name='泰达米尔'
t.hp=2600    #生命值
t.atk=450    #攻击力
t.armor=200  #护甲值
 
# 格式化输出
print('英雄: %s的生命值: %d' %(t.name,t.hp))
print('英雄: %s的攻击力: %d' %(t.name,t.atk))
print('英雄: %s的护甲值: %d' %(t.name,t.armor))
# 调用方法
t.move()
t.attack()

 

魔法方法

Python 的类里提供的，两个下划线开始，两个下划线结束的方法，就是魔法方法

__init__

         初始化方法 用来赋值

# 如果类面没有写__init__方法，Python会自动创建，但是不执行任何操作，    

# 如果为了能够在完成自己想要的功能，可以自己定义__init__方法，    

# 所以一个类里无论自己是否编写__init__方法 一定有__init__方法。

__init__()方法，在创建一个对象时默认被调用，不需要手动调用

__init__(self)中的self参数，不需要开发者传递，python解释器会自动把当前的对象引用传递过去。

 
class Hero(object):
    '''定义一个英雄类,可以移动和攻击'''
    def __init__(self):   #self代表实例化对象
        #赋值   没有参数
        self.name='泰达米尔'
        self.hp=2600    #生命值
        self.atk=450    #攻击力
        self.armor=200  #护甲值
    def move(self):
        '''实例方法'''
        print('正在前往事发地点....')
 
    def attack(self):
        '''实例方法'''
        print('发出了一招强有力的普通攻击')
    def info(self):
        print('英雄: %s的生命值: %d' % (self.name, self.hp))
        print('英雄: %s的攻击力: %d' % (self.name, self.atk))
        print('英雄: %s的护甲值: %d' % (self.name, self.armor))
# 实例化一个对象
t=Hero()
 
# 调用方法
t.info()
t.move()
t.attack()

class Hero(object):
    '''定义一个英雄类,可以移动和攻击'''
    def __init__(self,name,hp,attack,armor):
        #属性初始化  有参数
        self.name=name
        self.hp=hp         #生命值
        self.atk=attack    #攻击力
        self.armor=armor   #护甲值
    def move(self):
        '''实例方法'''
        print('正在前往事发地点....')
 
    def attack(self):
        '''实例方法'''
        print('发出了一招强有力的普通攻击')
    def info(self):
        print('英雄: %s的生命值: %d' % (self.name, self.hp))
        print('英雄: %s的攻击力: %d' % (self.name, self.atk))
        print('英雄: %s的护甲值: %d' % (self.name, self.armor))
# 实例化一个对象
t=Hero('泰达米尔',2600,450,200)
 
# 调用方法
t.info()
t.move()
t.attack()

通过一个类，可以创建多个对象，就好比 通过一个模具创建多个实体一样

__init__(self)中，默认有1个参数名字为self，如果在创建对象时传递了2个实参，那么__init__(self)中出了self作为第一个形参外还需要2个形参，例如__init__(self,x,y)

注意:

1). 在类内部获取 属性 和 实例方法，通过self获取；

2). 在类外部获取 属性 和 实例方法，通过对象名获取。

3). 如果一个类有多个对象，每个对象的属性是各自保存的，都有各自独立的地址；

4). 但是实例方法是所有对象共享的，只占用一份内存空间。类会通过self来判断是哪个对象调用了实例方法。

__str__

实例化对象时会调用__str__()方法，如果没有定义__str__()方法会打印一个对象的地址，如果定义__str__()并且有返回值，就会打印其中的返回值

class ss:
    def __init__(self,age,name):
        self.age = age
        self.name = name
if __name__=="__main__":
    s = ss(21,'jack')
    print(s)

调用__str__方法，输出结果是该方法的返回值

class ss:
    def __init__(self,age,name):
        self.age = age
        self.name = name
    def __str__(self):
        return "My name is %s and %s year" %(self.name,self.age)
if __name__=="__main__":
    s = ss(21,'jack')
    print(s)

 __del__

删除无用的内存对象(当程序结束会自动自行析构方法)
当删除一个对象时，Python解释器也会默认调用一个__del__ 析构方法

class Dog(object):
    def __init__(self,name):
        self.name =name
        print("__init__方法被调用")
    def __del__(self):
        print("__del__方法被调用")
        print("python解释器开始回收%s对象了" % self.name)
p = Dog('Bob')
del p

__new__

#__new__和__init__的作用
class A(object):
    def __init__(self):
        print("这是 init 方法")
 
    def __new__(cls)
        print("这是 new 方法")
        return boject.__new__(cls)
a = A()
 
##结果
#这是 new 方法
#这是 init 方法

总结

1). __new__至少要有一个参数cls，代表要实例化的类，此参数在实例化时由Python解释器自动提供

2). __new__必须要有返回值，返回实例化出来的实例，这点在自己实现__new__时要特别注意，可以return父类__new__出来的实例，或者直接是object的__new__出来的实例

3). __init__有一个参数self，就是这个__new__返回的实例，__init__在__new__的基础上可以完成一些其它初始化的动作，__init__不需要返回值

 单例模式

永远用一个对象得实例，避免新建太多实例浪费资源

实质:使用__new__方法新建类对象时先判断是否已经建立过，如果建过就使用已有的对象

class Foo(object):
   instance = None
   def __init__(self):
      self.name = 'alex'
   def __new__(cls):
      if Foo.instance:
         return Foo.instance
      else:
         Foo.instance = object.__new__(cls)
         return Foo.instance
obj1 = Foo()        #obj1和obj2获取的就是__new__方法返回的内容
obj2 = Foo()
print(obj1,obj2)
 
##结果返回两个对象的地址