python Basic -面向对象中级,字段，方法，类方法，静态方法，属性

面向对象中级

字段 与 方法

什么是字段，什么是方法

class Father:
    def __init__(self,name):
        self.name = name
        print("Father.__init__()")

class Son(Father):
    def test(self):
        print("test")

obj = Son("Elon Musk")

obj.name
obj.test()
"""
Father.__init__()
test
"""

如上所示：
self.name = name ： 这就是一个字段
def Test(self): ： 这是一个方法

调用方法的时候需要加括号，而调用字段的时候是不需要加括号的。

静态字段

将字段写到类里面， 这样多个对象具有同一个值的时候只会保留一份。
普通字段，属于对象
静态字段，属于类

静态字段示例：

中国所有的省份，用面向对象知识表示：

class Province:
    # 静态字段，属于类
    country = "中国"

    def __init__(self,name):
        #普通字段，属于对象
        self.name = name

hubei = Province("湖北")
hunan = Province("湖南")
print(Province.country)

“”“
中国
”“”

普通字段属于对象，只能通过对象访问
静态字段属于类，执行时可以通过对象，也可以通过类访问

静态字段可以在不创建对象的情况下直接使用。

方法的调用方式

方法一：通过类创建对象，而后通过对象调用方法

class Foo:
    def show(self):
        print("show")

obj = Foo()
obj.show()

"""
show
"""

方法二：类直接调用方法

类调用方法，需要传递一个参数，这个参数是通过这个类创建的对象，所以通过类来调用方法的时候还是需要创建一个对象，操作的还是这个对象。

class Foo:
    def show(self):
        print("show")

obj = Foo()

Foo.show(obj)
"""
show
"""

静态方法（添加一个装饰器即可）

静态方法的特点

• 静态方法可以在不创建对象的情况下直接调用
• 静态方法在定义时不需要self参数，因为此方法不归对象，而属于类的。
• 使用@staticmethod装饰器

class Foo:
    def show(self):
        print("show")
    @staticmethod
    def showstatic():
        print("showstatic")

Foo.showstatic()

"""
showstatic
"""

类方法

与静态方法比较类似，但是有一点不一样。
什么是类方法：类方法是将类本身做为对象进行操作的方法，
使用装饰器 @classmethod 关键字
cls ：代指当前类对象

类方法的调用形式为可通过对象调用，也可以通过类调用

class Foo:
    def show(self):
        print("show")
    @classmethod
    def showclass(cls):
        print(cls)
        print("showclass")
#通过类调用
Foo.showclass()
#通过对象调用
obj = Foo()
obj.showclass()

"""
<class '__main__.Foo'>
showclass
<class '__main__.Foo'>
showclass
"""

cls是class的缩写
cls是类名，不依赖对象，执行的时候就可以不用对象了。又可以直接执行它。

小结：

• 字段：
  • 普通字段：保存在对象中，执行只能通过对象访问
  • 静态字段：保存在类中，执行可能通过对象访问，也可以通过类访问
• 方法：
  • 普通方法：保存在类中，由对象进行调用，self==> 对象
  • 静态方法：保存在类中，可由类直接调用
    • 类方法：保存在类中，可由类直接调用，cls==> 当前类

############ 使用场景
如果对象中需要保存一些值，执行某功能时需要使用对象中的值-----> 普通方法
不需要使用对象中的值，静态方法。

属性

定义的时候像方法，访问的时候像字段

class Foo:
    @property
    def propertyshow(self):
        print("propertyshow")


obj = Foo()
obj.propertyshow

"""
propertyshow
"""

返回值

对于方法来说可以有返回值，例如：

class Foo:
    @property
    def show(self):
        print("show")
        return 123


obj = Foo()
r = obj.show
print(r)

"""
show
123
"""

这叫创建了一个属性。或者叫特性。

为属性传递值

class Foo:
    @property
    def show(self):
        print("show")
        return 123
    @show.setter
    def show(self,name):
        print(name)


obj = Foo()
r = obj.show
print(r)

obj.show = 456
"""
show
123
456
"""

删除属性的值

class Foo:
    @property
    def show(self):
        print("show")
        return 123
    @show.setter
    def show(self,name):
        print(name)
    @show.deleter
    def show(self):
        print("666")


obj = Foo()
r = obj.show
print(r)

obj.show = 456
del obj.show
"""
show
123
456
666
"""

这里不是删掉。这里不管是setter还是deltter，目的都是伪造的它跟字段一样。它不会真实的去帮你删除，设置数据，如果这样写了，具体里面怎么做是自定义的。
只是一对一的关系。所以在setter里面也可以做delter的操作。只帮你执行一下里面的方法，但是具体里面做什么得自己定义。相当于就是一个对应关系。

也就是说这其实是3个方法，只是对应的，但是具体里面执行什么写代码的说了算。

示例

通常在做一些页面进行翻页的时候，需要写一个开始到结束，但是在调用start和end的时候后面不用加括号，这样看起来也非常清晰。所以功能也就这一点，就是为了去括号。

class Pergination:
    def __init__(self,current_page):
        try:
            p = int (current_page)
        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


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

while True:
    p = input("请输入要查看的页码：") #1，每页显示10条
    obj = Pergination(p)
    print(li[obj.start:obj.end])# 这里如果不用写print(li[obj.start(),obj,end()])

"""
请输入要查看的页码：1
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
请输入要查看的页码：2
[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
请输入要查看的页码：5
[40, 41, 42, 43, 44, 45, 46, 47, 48, 49]
请输入要查看的页码：
"""

类特殊方法

上面介绍了Python的类成员以及成员修饰符，从而了解到类中有字段，方法和属性三大类成员，并且成员名前如果有两个下划线，则表示该成员是私有成员，私有成员只能由类内部调用，存在在一些具有特殊含义的成员，如下所述

__doc__ 方法

用于表示类的描述信息

__module__

表示操作的对象在哪个模块

__class__

表示当前操作的对象的类是什么

property(fget())

def Foo():
    def functiontest(self):
        return 123

    per = property(fget=functiontest)

与下面的写法是一样的。fget 是get的一个函数。

def Foo2():
    
    def functiontest(self):
        return 123
    
    @property
    def per(self):
        return 123

property(fset())

用于向函数传递一个值，

class Foo():
    def functiontest(self):
        return 123

    def functiontest2(self,v):
        print(v)

    per = property(fget=functiontest,fset=functiontest2)

obj = Foo()
obj.per = 123456

"""
123456
"""

property(fdel())

del 的时候不需要传递参数

class Foo():
    def functiontest(self):
        return 123

    def functiontest2(self,v):
        print(v)

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

    per = property(fget=functiontest,fset=functiontest2,fdel=functiontest3)


obj = Foo()
obj.per = 123456
del obj.per