Python之面向对象

 

 

 

 1.面向对象定义

class room:
    def man(self,args):
        print(args,self)
        pass
    def woman(self,args):
        print()
        pass



obj = room()
obj.man('bb')
print(obj)



'''

bb <__main__.room object at 0x0000012EFF3A2E10>
<__main__.room object at 0x0000012EFF3A2E10>

'''


obj2 = room()
obj2.man('bb')
print(obj2)


'''

bb <__main__.room object at 0x0000012EFF3A2E48>
<__main__.room object at 0x0000012EFF3A2E48>

'''
#------------------------------------------------------
#self  传的是room类创建的对象的地址（python内部自动替我们传递）
38 #通俗点，哪个对象执行该方法，self传递的就是哪个对象的地址

 

2.面向对象三大特性

  a.封装：为了使得代码简洁，不用重复传参。

  

#第一种封装方式;

class foo:
    def creat(self,ab):
        print(self.ab)


obj = foo()
obj.ab = "wwwwww"

obj.creat('ab')



#第二种封装方式：

class Foo:
    def __init__(self,ab):
        '''
        构造方法
        :param ab:
        '''
        self.ab = "wwwwww"
    def creat(self):
        print(self.ab)


obj = Foo("ab")
obj.creat()




#使用场景：

#1.当同一类型的方法具有相同的参数的时候，直接封装到对象即可；
#2.把类当作模版，创建多个对象（对象内封装的数据可以不一样）

 

写个例子：

class person:
    def __init__(self,name,age,weight):
        self.Name = name
        self.Age =  age
        self.Weight = weight

    def eating(self):
        self.Weight += 2

    def execise(self):
        self.Weight -= 1

import pickle

obj = person('XM',18,107)
obj.eating()
obj.execise()
obj.eating()
ret = pickle.dump(obj,open('queen.log','wb'))        

ret = pickle.load(open('queen.log','rb'))
print(ret.Weight) if ret else print ('请创建你的对象！')

 

 

  b.继承

   继承知识点：单继承、多继承、多继承的优先搜索顺序

    

注意：
1.Animals 称作父类，又称基类；Dog 称作子类，又称作派生类  是相对的，可以嵌套。
2.子类可以继承父类里面的所有功能
3.当子类与其继承的唯一父类里面具有相同的功能的时候，默认优先执行子类自己的功能（称作单继承）
4.在python中子类可以继承多个父类，当多个父类里面具有相同的功能的时候优先顺序为从左至右

class Animals:
    def eating(self):
        print(' %s - %s'% (self.name , '喂食'))
    def drinking(self):
        print(' %s - %s'% (self.name , '喝水'))

class Function:
    def working(self):
        print(' %s - %s' % (self.name, '被宰了'))




class Dog(Animals,Function):
    def __init__(self,name):
        self.name = name  #普通字段，在对象里创建
    def roasting(self):
        print(' %s - %s'% (self.name , '汪汪'))


meiyu = Dog('meiyu')


meiyu.eating()
meiyu.drinking()
meiyu.roasting()
meiyu.working()

 @多继承的优先搜索顺序：

   

   

 

   @易错点：如果方法里面又嵌套方法，那就究其本质，看看是谁（对象）调用了这个方法，然后在按照上面的顺序执行。

        给个例子：

class A:
    def bar(self):
        print('BAR')
        self.f1()

class B:
    def f3(self):
        print('B')
class C(A):
    def f1(self):
        print('C')


class D(B,C):
    def f2(self):
        print('D')

dd = D()
dd.bar()   #显然A里面又执行了f1方法，而究其本质，是dd执行，所以回到D类从头开始搜索f1方法。



#output：
#BAR
#C

 

 #执行父类构造方法

#执行父类构造方法。即父类中字段在初始化时在子类中重写的解决方法。有两种：
#1. super(cat,self).__init__() 
#2. animal.__init__(self)



class animal:
    def __init__(self):
        print('A构造方法')
        self.n = '我是动物'


class cat(animal):
    def __init__(self):
        print('B构造方法')
        self.u = "我是猫"
        super(cat,self).__init__()  #最常用这一种


a = cat()

#输出：
B构造方法
A构造方法

    __dic__  查看对象中创建的字段

  

  c.多态：多种形态

     python中本身就具有多态属性。

 

     扩展：在其它语言（java、c#）中：

                重载：类中方法的函数名相同，函数的参数个数不相同的情况。

                重写：子类中重新实现父类中的方法。

  

 

 

3.类中的高级成员 ：静态字段，静态方法，类方法

 

#类和对象都可以访问：静态字段，静态方法；普通字段，普通方法
#但作出规范，严格按照以下执行！

#1通过类去访问：静态字段，静态方法，类方法（也即是静态方法的特殊情况，添加了cls参数）

#2.通过对象访问：普通字段，普通方法

class province:

    country = 'china'  #静态字段，写在类中

    @staticmethod     #在指定的方法上面添加@staticmethod，使其变为静态方法
    def f1(args1,args2,argsn):       #f1称作静态方法,可以传参
        pass

    def f2(self):
        pass

 

    @classmethod    #在指定方法上添加@classmethod，使其变为类方法
    def f3(cls,args1,args2,argsn):   #cls 传递该类方法对应的类名
        pass

 

4.类的普通成员：字段，方法，特性（属性）

    特性：即是将方法伪造成为一种字段

 

class Foo:

    def __init__(self,name):
        self.name = name
        pass

    def start(self):
        temp ='%s sb'% self.name
        print (temp)

    @property    #创建特性，将方法伪造成一种字段
    def end(self):
        tart = '%s sb'% self.name
        print(tart)

obj = Foo('alex')
obj.start()
obj.end    #将方法伪造成一种字段去执行（即对象后面方法不加括号）

#output：
#alex sb
#alex sb

 

   特性如何设置字段呢？

 

class Foo:

    def __init__(self,name):
        self.name = name
        pass

    def start(self):
        temp ='%s sb'% self.name
        print (temp)

    @property    #创建特性，将方法伪造成一种字段
    def end(self):
        tart = '%s sb'% self.name
        print(tart)

    @end.setter      #给特性方法设置字段
    def end(self,arg):
        print（arg）19         self.name = arg20 

obj = Foo('alex')
obj.start()   #alex sb
obj.end       #alex sb

obj.name = '123'  #给对象直接设置字段
obj.start()   #123 sb
obj.end       #123 sb

obj.end = '456'   #用特性方法设置字段,并同时执行了@end.setter下的这个end方法。 #456
obj.start()    #456 sb
obj.end        #456 sb

 

 

小结：

 

三大特性：封装，继承，多态

面向对象成员：


          1.方法：   静态方法（无需使用对象封装的内容，类调用） ；普通方法（使用对象封装的内容，对象调用）；类方法


          2.字段：   静态字段（对象里面具有相同的封装内容，为了不重复，写在类里）  ；普通字段（各对象的封装的内容不一样）


          3.特性：   将方法伪造成为字段




如何快速判断类调用还是是对象调用成员呢？

有self  对象

无self  类

 

 5.类成员的修饰符

 

#隐藏类内成员，类内部可获取，外部无法读取,继承时子类也无法访问。

# __xx     私有
#  xx      共有




class Foo:

    ox = 'ox'
    __xo = 'xo'



    def __init__(self):
        pass

    def f1(self):
        print('hello')
        print(Foo.__xo)



obj = Foo()
obj.f1()    #由于在类内，可以获取
print(Foo.__xo)   #在类外无法获取


#python内部特殊语法打破这一规则：

# obj._Foo__xo

   

6.类的特殊成员

   __init__      

  __call__    

  __metaclass__     #类也是对象，__metaclass__  指定类是由xx创建的对象

 __new__

  

  索引、切片

 

# 类后面加括号，执行__init__,并创建对象
# 对象后面直接加括号，直接执行__call__



class Foo:

    def __init__(self):
        print('构造方法')

    def __call__(self, *args, **kwargs):
        print('call')
        return 1



r = Foo()   #执行__init__方法
r()         #执行__call__方法
r = Foo()()   #等同于 r()


# __getitem__
# __setitem__
# __delitem__


class Foo:

    def __getitem__(self, item):
        pass

    def __setitem__(self, key, value):
        pass

    def __delitem__(self, key):
        pass


r = Foo()

#对象后面加方括号#################################

r['k']           #执行__getitem__

r['k'] = '123'  #执行__setitem__

del r['k']       #执行__delitem__

# #切片  ###############################################

r[1:3]                #__getslice__(py2.7)/__getitem__(py3.5)
r[1:3] = [11,22,33]   #__setslice__(py2.7)/ __setitem__(py3.5)
del r[1:3]            #__delslice__(py2.7)/__delitem__(py3.5)

#迭代  __iter__   ###############################################


class Foo:

    def __iter__(self):
        yield 1
        yield 2
        yield 3

obj = Foo()

for i in obj:
    print(i)