class Province:    country = "中国"    #静态字段    def __init__(self,name):        self.name = name        #普通字段hn = Province("河南")hb = Province("河北")sd = Province("山东")db = Province("黑龙江")print(hn.name)

class Province:
    country = "中国"

    def __init__(self,name):
        self.name = "alex"

hn = Province("河南")
print(hn.name)

#通过类访问静态字段,推荐
print(Province.country)

#通过对象访问静态字段，不推荐
print(hn.country)

class Provice:
    country = "中国"

    def __init__(self,name):
        self.name = "alex"

print(Province.country)
#静态字段，在代码加载时，已经创建；

class Province:    country = "中国"    def __init__(self,name):        self.name = name        #普通方法，由对象去调用执行(方法属于类)    def show(self):        #print(self.name)        print(123)    @staticmethod    def f1(arg1,arg2):        #静态方法，由类直接调用执行        print(arg1,arg2)    @classmethod    def f2(cls):        cls #类名，加()创建对象        print(cls)Province.f1(1,2) #静态方法，由类直接调用执行Province.f2()  #不用传值，自动传值所有方法属于类：1.普通方法：至少一个self,    对象执行2.静态方法：任意参数，        类来执行(也可以对象执行，不推荐)3.类方法：至少一个cls         类执行(也可以对象执行，不推荐)

分页：不使用属性；

class Pager:    def __init__(self,all_count):        self.all_count = all_count    # @property    def all_pager(self):        a1,a2 = divmod(self.all_count,10)        if a2 == 0:            return a1        else:            return a1 + 1p = Pager(101)#不使用人妖，属性#p.all_count  #字段result = p.all_pager()#方法print(result)

使用属性，人妖,@property，：
使用属性实现的效果功能是：通过对象执行方法，不用加括号了。

class Pager:
    def __init__(self,all_count):
        self.all_count = all_count

    @property
    def all_pager(self):
        a1,a2 = divmod(self.all_count,10)
        if a2 == 0:
            return a1
        else:
            return a1 + 1

    @all_pager.setter
    def all_pager(self,value):
        print(value)

    @all_pager.deleter
    def all_pager(self):
        print("del all_pager")

#通过@property执行方法，不用加括号了；
p = Pager(101)
ret = p.all_pager
print(ret)

# #给属性重新赋值，加变量
res = p.all_pager = 111
print(res)

# #删除属性
del p.all_pager

属性定义：
1.不伦不类的东西
2.具有方法的写作形式，具有字段的访问方式；
3.属性只是提供的是访问方法，具体做什么靠自己定义。

属性存在的第二种方式：
class Pager:
    def __init__(self,all_count):
        self.all_count = all_count

    def f1(self):
        return 123

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

    def f3(self):
        print("del p.foo")

    foo = property(fget=f1,fset=f2,fdel=f3)
    
p = Pager(101)

result = p.foo
print(result)

p.foo = "alex"

del p.foo

class Foo: def __init__(self,name):     self.__name = name def f1(self):     print(self.__name)class Bar(Foo):    def f2(self):        print(self.__name)obj = Bar("alex")# obj.f2()obj.f1()上面这个例子：不能通过f2调用私有方法，只能通过本身f1调用私有方法，结论：私有方法只能通过内部调用;

class Fzz:
    __cc = "123"

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

    def f1(self):
        print(self.__name)

    # def f3(self):
    #     print(Fzz.__cc)

    #通过静态字段方法来执行
    @staticmethod
    def f3():
        print(Fzz.__cc)
        
# print(Fzz.__cc) #调用不到cc方法

obj = Fzz(‘dddd‘)
obj.f3()
#能够调用到cc的方法

Fzz.f3()
#通过静态字段方法来执行