python学习之面向对象

类的成员可以分为三大类：字段、方法和属性

 

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

        

class Province:
    # 静态字段，属于类
    country =  '中国'
    
    
    def __init__(self, name):
        # 普通字段，属于对象
        self.name = name

Province.country
henan=Province(''河南)
henan.name

View Code

 

     # 方法
         - 普通方法，保存在类中，由对象来调用，self=》对象
         - 静态方法，保存在类中，由类直接调用
         - 类方法，保存在类中，由类直接调用，cls=》当前类

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

       

class Foo:

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

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

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

View Code

class Person:

    def __init__(self, name,age):

        #构造方法，构造方法的特性， 类名() 自动执行构造方法

        self.n = name
        self.a = age
        self.x = '0'

View Code

 

注：所有成员中，只有普通字段的内容保存对象中，即：根据此类创建了多少对象，在内存中就有多少个普通字段。而其他的成员，则都是保存在类中，即：无论对象的多少，在内存中只创建一份。

 

 

 

面向对象三大特性之：继承

1、继承
        
        class 父类：
            pass
            
        class 子类(父类):
            pass

class Base:
    def a(self):
        print('Base.a')


class F0(Base):
    def a1(self):
        print('F0.a')

self永远是执行改方法的调用者

View Code

#python多类继承，寻找方法或者init顺序
#1、左侧优先 2、一条路到底 3、同一个根时最后执行

"""
class BaseRequest:
    def __init__(self):
        print('BaseRequest.init')

class RequestHandler(BaseRequest):
    def __init__(self):
        print('RequestHandler.init')

    def serve_forever(self):
        print('RequestHandler.serve_forever')
        self.process_request()

    def process_request(self):
        print('RequestHandler.process_request')

class Minx:
    # def __init__(self):
    #     print('minx.init')
    def process_request(self):
        print('minx.process_request')

class Son(Minx,RequestHandler):
    pass

obj = Son()

obj.serve_forever()
"""

#利用属性实现分页
class Page:
    def __init__(self,c_p):
        try:
            p=int(c_p)
        except Exception as e:
            p=1
        self.page=p

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

    @property
    def end(self):
        val = self.page*10
        return val

l=[]
for i in range(1000):
    l.append(i)

while True:
    p=input("请输入页码:")
    obj=Page(p)
    print(l[obj.start:obj.end])

View Code

 

成员修饰符

共有成员
私有成员, __字段名
        - 无法直接访问，只能间接访问


class F:
    def __init__(self):
        self.name=1
        self.__age=18 #外部无法直接访问
    def show(self):
        print(self.__age)

obj=F()
print(obj.name)
obj.show()
print(obj.__age)

 

特殊成员

__init__     类()自动执行
__del__
__call__     对象()  类()() 自动执行
__int__      int(对象) 
__str__      str()
__add__
__dict__     # 讲对象中封装的所有内容通过字典的形式返回
__getitem__  # 切片（slice类型）或者索引
__setitem__
__delitem__  
__iter__
                # 如果类中有 __iter__ 方法，对象=》可迭代对象
                # 对象.__iter__() 的返回值： 迭代器
                # for 循环，迭代器，next
                # for 循环，可迭代对象，对象.__iter__()，迭代器，next
                # 1、执行li对象的类F类中的 __iter__方法，并获取其返回值
                # 2、循环上一步中返回的对象


class Foo:

    def __init__(self):
        pass

    def __int__(self):
        return 1111

    def __str__(self):
        return 'alex'
# int,对象，自动执行对象的 __int__方法，并将返回值赋值给int对象
obj=Foo()
r=int(obj)
print(r)

通过字符串的形式操作对象中的成员

getattr
hasattr
setattr
delattr

class Foo:

    stat = '123'

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

r=getattr(Foo,'stat')
print(r)
obj=Foo('yqh',18)
n = getattr(obj,'name')
print(n)

 

转载于:https://www.cnblogs.com/quanloveshui/p/10832370.html