14.6面向对象小结

Posted 2020-10-30

面向对象小结

1、如何创建类
class 类名：
pass

2、创建方法
构造方法，init(self,arg)
obj = 类(‘a1‘)
普通方法
obj = 类(‘xxx’)
obj.普通方法名()

3、面向对象三大特性之一：封装

class Bar:
        def __init__(self, n,a):
            self.name = n
            self.age = a
            self.xue = ‘o‘

    b1 = Bar(‘a1‘, 123)

    b2 = Bar(‘a2‘, 456)

4、适用场景：
如果多个函数中有一些相同参数时，转换成面向对象。

5、面向对象三大特性之二：继承
1、继承
class 父类：
pass
class 子类(父类):
pass

2、重写
    防止执行父类中的方法

3、self永远是执行该方法的调用者

4、
   super(子类, self).父类中的方法(...)
   父类名.父类中的方法(self,...)

5、Python中支持多继承

• a. 左侧优先
• b. 一条道走到黑
• c. 同一个根时，根最后执行

6、面向对象三大特性之三：多态
====> 原生多态

#Java
        string v = ‘a1‘

        def func(string arg):
            print(arg)

        func(‘a1‘)
        func(123)

    # Python 
        v = ‘a1‘

        def func(arg):
            print(arg)     

        func(1)
        func(‘a1‘)

============== 面向对象中高级==================

class Foo:

    def __init__(self, name):
        # 普通字段
        self.name = name

    # 普通方法
    def show(self):
        print(self.name)

obj = Foo(‘alex‘)
obj.name
obj.show()

类成员：
# 字段

• 普通字段，保存在对象中，执行只能通过对象访问
• 静态字段，保存在类中， 执行可以通过对象访问 也可以通过类访问

# 方法

• 普通方法，保存在类中，由对象来调用，self=》对象
• 静态方法，保存在类中，由类直接调用，@staticmethod,
• 类方法，保存在类中，由类直接调用，cls=》当前类,@classmethod,也可以被对象调用
  # 属性，特性
• 不伦不类

应用场景：
如果对象中需要保存一些值，执行某功能时，需要使用对象中的值　－＞　普通方法.
不需要任何对象中的值，静态方法.

静态字段

#静态字段:可以类直接访问，也可以对象访问
class province:
    country="china"

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

zhejiang=province("zhejiang")
print(province.country)
# china
print(zhejiang.country)
# china

# type是一个函数来来获取类的类型，而__class__是类的属性的方式来获取类的类型
print(type(zhejiang))
# <class ‘__main__.province‘>
print(province.__class__)
# <class ‘type‘>
print(type(province))
# <class ‘type‘>
print(dir(province))   #dir（class）：查看类的属性(包括继承的属性)
# [‘__class__‘, ‘__delattr__‘, ‘__dict__‘, ‘__dir__‘, ‘__doc__‘, ‘__eq__‘, ‘__format__‘, ‘__ge__‘, ‘__getattribute__‘, ‘__gt__‘, ‘__hash__‘, ‘__init__‘, ‘__init_subclass__‘, ‘__le__‘, ‘__lt__‘, ‘__module__‘, ‘__ne__‘, ‘__new__‘, ‘__reduce__‘, ‘__reduce_ex__‘, ‘__repr__‘, ‘__setattr__‘, ‘__sizeof__‘, ‘__str__‘, ‘__subclasshook__‘, ‘__weakref__‘, ‘country‘]
print(province.__dict__)   #class.__dict__: 属性名：属性值的键值对
# {‘__module__‘: ‘__main__‘, ‘country‘: ‘china‘, ‘__init__‘: <function province.__init__ at 0x0000002793B6D620>, ‘__dict__‘: <attribute ‘__dict__‘ of ‘province‘ objects>, ‘__weakref__‘: <attribute ‘__weakref__‘ of ‘province‘ objects>, ‘__doc__‘: None}

静态方法和类方法

#静态方法:可以不指定self，也可以指定self
#类方法:self为cls,指本类，可以被类直接调用,也可以被对象调用
class province1:
    abc="test"

    def info(self,population):
        self.p=population
        print(self.p)
        print(self.abc)

    @staticmethod
    def country(args):
        print("China")
        print(args)

    @classmethod
    def citys(cls):    #self指当前类
        print("many citys!")
        print(cls.abc)

obj1=province1()
province1.country(args="china1")
# China
# china1
province1.citys()
# many citys!
# test
obj1.citys()
# many citys!
# test

obj1.info(256)
# 256
# test

属性

#属性
class test:

    @property
    def func(self):
         pass

    @func.setter
    def func(self,args):
        print(args)

    @func.getter
    def func(self):
        print("ok2")

    @func.deleter
    def func(self):
        print("delete ok!")

obj2=test()
obj2.func
# ok2

obj3=test()
obj3.func=123
# 123
obj3.func
# ok2

del obj3.func
# delete ok!

属性的第二种写法

class foo:

    def f1(self):
        print("1")

    def f2(self,val):
        print(val)

    def f3(self):
        print("del")

    a=property(fget=f1,fset=f2,fdel=f3,doc="test")

obj1=foo()
obj1.f2(100)

属性应用:随机翻页

class page_turning:

    def __init__(self,p):
        self.page=p

    @property
    def start(self):
        start_page=(self.page-1)*10+1
        return start_page

    @property
    def end(self):
        end_page=self.page*10+1
        return end_page

    def show(self):
        for i in range(self.start,self.end):
            print(i,end=" ")

while True:
    ram=int(input("your choice:"))
    page_turning(ram).show()
    print()

# your choice:1
# 1 2 3 4 5 6 7 8 9 10 
# your choice:4
# 31 32 33 34 35 36 37 38 39 40 
# your choice:

成员修饰符（访问权限）
类的所有成员分为：字段，方法
　　公有成员，在任何地方都能访问
　　私有成员，只有在类的内部才能访问
私有成员和公有成员的定义不同：私有成员命名时，前两个字符是下划线。（特殊成员除外，例如：init、call等）
私有成员和公有成员的访问限制不同：
静态字段：
公有静态字段：类可以访问，类内部可以访问；派生类中可以访问
私有静态字段：仅类内部可以访问
普通字段：
　　公有普通字段：对象可以访问；类内部可以访问；派生类中可以访问
　　私有普通字段：仅类内部可以访问
方法、属性的访问与上述方式相似，即，私有成员只能在类内部使用。
PS:私有成员若非要访问的话，可以通过 对象._类__属性名 来访问。

私有普通字段

#私有普通字段
class foo2:

    def __init__(self,name,sex):
        self.n=name
        self.__s=sex     #私有普通字段
        print(name,sex)
        print(self.n,self.__s)

    def fun2(self):
        print(self.__s)

class foo22:
    def fun1(self):
        print(foo2.__init__(self,"jiaxin01","f"))
        print(foo2.fun2(self))

obj2=foo22()
obj2.fun1()
# jiaxin01 f
# jiaxin01 f
# None
# f
# None

obj3=foo2("jiaxin","f")
# jiaxin f
# jiaxin f
obj3.fun2()
# f
print(obj3.n)
# jiaxin
print(obj3._foo2__s)
# f

私有静态字段

#私有静态字段
class foo3:

    __abc=123

    def fun1(self):
        print(self.__abc)

    def fun2(self):
        print(self.__abc)

obj33=foo3()
obj33.fun1()
print(foo3._foo3__abc)
obj33.fun2()
# 123
# 123
# 123

私有普通方法

#私有普通方法
class hoo:

    def __fun1(self):
        print("f1")
        return("f1 ok!")

    def fun2(self):
        print(self.__fun1())

obj4=hoo()
print(obj4._hoo__fun1())
# f1
# f1 ok!

obj4.fun2()
# f1
# f1 ok!

私有静态方法,私有类方法

#私有静态方法,私有类方法
class soo:

    @staticmethod
    def __fun1():
        print("fun1 ok ")

    @classmethod
    def __fun2(cls):
        print("fun2 ok ")

    def show(self):
        print(self.__fun1())

obj5=soo()
obj5.show()
# fun1 ok
# None

soo._soo__fun1()
# fun1 ok

soo._soo__fun2()
# fun2 ok

类的特殊成员：
_init_ 类（）初始化.
_int_ int(对象)执行
_call_ 对象（）执行 _call__函数.
_str\ print（对象）执行__str__函数

_add_ 多对象相加自动调用此函数
_dict_ 显示类的成员

_getitem_ 配置切片或引索
_setitem_ 对引索赋值
_delitem_ 删除某个元素

_iter_ 对象.__iter__有此方法为可迭代对象

metaclass