PyThon面向对象

面向对象:

适用场景：多个函数中有相同参数

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

1，将变量封装在对象中

2，继承

class 类名（父类名）

2）选择性继承，子类中写方法将父类中方法覆盖

3）self永远指调用方法的对象

4）定向执行父类中的2种方法：

（1）supper(子类名，self).父类中的方法--推荐

（2）父类名.方法（slef）

5）多继承问题

（1）从左边开始找并且一条路走到黑；（2）有相同的根时根最后执行

3，Python原生支持多态

=====进阶======

类的成员：

1,字段：1）普通字段（属于对象，只能通过对象访问），2）静态字段（属于类，对象和类都可以访问）

2）方法：1）普通方法（保存在类中，通过类或对象访问）2）静态方法（@staticmethod;self不是必须的的了，保存在类中，通过类来访问）

2）方法：1）普通方法

"""
class foo:
    pass

print(foo)

print(str)"""
"""
# self 是什么(实例化的对象)
class Example:
    def foo(self,arg):
        print(self,self.name,self.age,arg)

dx1 = Example()
print(dx1)
dx1.name = 'alex'
dx1.age = 18
dx1.foo('222')"""

# 构造方法
'''
class Person:
    def __init__(self,name,age):
        self.name =name
        self.age = age

    def show(self):
        print("{0}-{1}".format(self.name,self.age))

hu = Person('hu',11)
print(hu.name,hu.age)
hu.show()
'''

"""
#继承

class F:
    def f1(self):
        print('F.f1')


#class S:
class S(F):
    def s1(self):
        print('S.s1')

obj  = S()
obj.s1()
obj.f1()
"""

# 选择性继承--覆盖父类中的方法
"""
class F:
    def f1(self):
        print('F.f1')


# class S:
class S(F):
    def s1(self):
        print('S.s1')

    def f1(self):
        print('S.f1')


obj = S()
obj.f1()"""

# 执行父类中的方法

"""
class F:
    def f1(self):
        print('F.f1')


# class S:
class S(F):
    def s1(self):
        print('S.s1')

    def f1(self):
        # super方法，推荐
        #super(S,self).f1()
        F.f1(self)
        print('S.f1')


obj = S()
obj.f1()
"""
'''
#多继承问题

class C3:
    pass

class C2(C3):
    def fa1(self):
        print('C2.fa')

    def fb1(self):
        print("C2.fb")

class C4:
    def fb(self):
        print('C4.fb')

    def fa(self):
        self.fb()
        print('C4.fa')

class C1(C2,C4):
    pass

obj = C1()
obj.fa()
'''

#类的成员--字段
"""
class Province:
    #静态字段，属于类
    country = 'china'

    #特殊方法
    def __init__(self,n):
        #name 是普通字段，属于对象
        self.name = n

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


print(Province.country)

anhui = Province('anhui')
anhui.p()
"""
#类的成员--方法
'''
class Province:

    # 普通方法
    def p(self):
        print('ordinary method')

    @staticmethod
    def p2():#slef不再是必要的了
        print('静态方法')

    @classmethod#类方法
    def p3(cls):#cls在调用时由Python自动传入
        print('class method')
        print(cls)

obj = Province()
obj.p()

#还是要利用对象
Province.p(obj)

#静态对象的访问
Province.p2()

#类对象
Province.p3()'''


#类的成员--属性
'''
class Foo:
    @property
    def p(self):
        #print('22')
        return 1

    @p.setter
    def p(self,val):
        print('val',val)

    @p.deleter
    def p(self):
        print('222')

# obj = Foo()
# r = obj.p#没有括号，类似字段，又类似方法
# print(r)
#
# Foo.p2(obj)

#Foo.p(obj)

obj = Foo()
r = obj.p
print(r)
obj.p = 3#setter
print(r)

del obj.p'''

'''
#属性的另一种表现形式
class Foo:
    def f1(self):
        print('f1')
        return 1

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

    def f3(self):
        print('f3')

    per = property(fget=f1,fset=f2,fdel=f3,doc='hhaa')

    #相当于
    # @property
    # def per(self):
    #     print('f1')
    #     return 1


obj = Foo()
r = obj.per
print(r)
# obj.per = 3
# del obj.per'''


#成员修饰符
'''
class Foo:
    age = 18
    __name = 'alex'

    def __per(self):
        print('内部函数')

obj = Foo()
print(obj.age)
# print(obj.__name)#报错
# obj.__per() #error'''


#类的特殊成员

"""
class Foo:
    #构造方法,对象创建时自动执行
    def __init__(self):
        print('类加括号时我会被执行')

    def __call__(self, *args, **kwargs):
        print('对象加括号时我会被执行')

    def __int__(self):
        print('int（对象）时我会被执行')
        return 1

    def __str__(self):
        print('str(对象)时我会被执行')
        return 'youyou'

    def __del__(self):
        #析构方法，对象被销毁时执行
        pass

    def __add__(self, other):
        #自定义方法:obj1+obj2>>self指代add前面的参数，other指代add后面的参数
        return 'add方法'

    def __getitem__(self, item):
        return 'getitem方法'

    def __setitem__(self, key, value):
       print(key,value)

    def __delitem__(self, key):
        print(key)
# Foo()()
# obj = Foo()
# r = int(obj)
# print(r)
# r = str(obj)
# print(r)
# r = obj.__dict__#将对象中封装的内容已字典的形式返回
# print(r)
# r = Foo.__dict__
# obj1 = Foo()
# obj2 = Foo()
# r = obj1 + obj2
# print(r)

#为什么可以有下列操作
# li = [1,2,3]
# r = li[0]
# li[0] = 6
# del li[0]

obj = Foo()
# r = obj[0]
# print(r)
# obj[0] = 'set'
del obj[0]"""

'''
class Foo:

    def __iter__(self):
        return iter(iter([1,2,3]))

obj = Foo()
for i in obj:#for 接收到了obj 这个可迭代对象，调用obj的__iter__方法得到[1,2,3],但[1,2,3]是可迭代对象不是迭代器，没有next()方法，解决办法，返回iter([1,2,3])
    print(i)

# for i in [1,2,3]:
#     print(i)
'''



#python中一切事物切对象
#创建类时默认使用type类来实例化（类也是对象）可以通过metclass 来指定创建类的创建类类，但这个创建类必须继承type这个类