Python面向对象编程（二）

第17,18个：面向对象三大特性之多态
    

def func(arg):
    print(arg)

#python支持多种形态（类型）
#优点：不需要先声明是什么字符，数字类型
#缺点：看查源码的时候不知道是什么类型
func(1)
func("hk")
func([11,22,33,44])

第19,20,21个：类成员之静态字段和普通字段
    

class　foo:
    #字段（静态字段）属于类
    cc =  123
    def __init__(self):
        #字段（普通字段）属于对象
        self.name = 'la'

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

obj =  foo()

字段位置及访问规则范例：

class province:
    country = "中国"  #静态字段存在类里，在代码加载时已创建
    def __init__(self,name):
        self.name = name   #普通字段存在于对象里，对象创建后调用时存在于内存中
                           #如果country字段存在对象中被反复调用会占用大量的内存资源
#省的属性是中国
hn = province('河南')
hb = province('河北')
sd = province('山东')
print(hn.name) #打印河南的名字


# 一般情况：自己访问自己的字段，即类访问静态字段、对象访问普通字段
#字段访问规则：
#   普通字段只能用对象访问
#   静态字段用类访问（万不得已才可使用对象访问）
print(hn.name)
print(province.country)
#print(hn.country)

第22,23个：类成员之普通方法和静态方法以及类
    
方法：
    所有的方法属于类
    1、普通方法：至少一个self，对象执行
    2、静态方法：任意参数， 类执行（万不得已才可使用对象访问）
    3、类方法：至少有一个cls，类执行（万不得已才可使用对象访问）
    

class province:
    country = "中国"
    def __init__(self,name):
        self.name = name

    #普通方法，由对象去调用执行（方法属于类）
    def show(self):
        print(self.name)
        return True

    #静态方法属于类，由类来调用执行。可以没有参数也可以有多个参数
    @staticmethod
    def f1(arg1,arg2):
        print(arg1,arg2)

    #类方法由类来调用，是静态方法的一种特殊形式，至少有一个参数cls
    @classmethod
    def f2(cls):
        print(cls)

hn = province('河南') #创建对象
print(hn.show())   #对象调用普通方法

province.f1(12,34) #类调用静态方法
province.f2() #类调用类方法，打印出类的名称

第24,25,26个：类成员之属性

属性：
　　具有方法的写作形式，具有字段的访问形式
　　具体方法里做什么都是自己定义的

'''
class pager:
　　def __init__(self,all_count):
　　　　self.all_count = all_count

　　def all_pager(self):
　　　　a1,a2=divmod(self.all_count,10)
　　　　if a2 == 0 :
　　　　　　return a1
　　　　else:
　　　　　　return a1 + 1
p = pager(101)
print(p.all_pager())
'''
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
p = pager(101)
print(p.all_pager) #调用all_pager方法取值的时候不用加括号    

-----------------------------------------
属性即可以 获取 又可以 设置 还可以 删除！
第一种形式（比较少见）：

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(123)

p = pager(100) #100是和__init__方法里的all_count一致的
print(p.all_pager) #获取
p.all_pager=111 #设置
del p.all_pager #删除

第二种形式（比较常见）：

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(1234)

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

p = pager(100)
print(p.foo) #对应着fget=f1
p.foo = "han" #对应着fget=f2
del p.foo #对应着fget=f3

第27个：类成员之成员修饰符

成员：字段、方法、属性
两种修饰符：一种私有（只能在类内部访问）
　　　　　　一种公有

公有修饰符：

class foo:
　　def __init__(self,name):
　　　　self.name = name

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

p = foo("hk")
#共有的两种形式：
#print(p.name) #1在类的外部直接调用
print(p.f1()) #2在类的外部通过方法间接的调用

私有修饰符：

class foo:
　　def __init__(self,name):
　　　　self.__name = name #创建一个私有的字段

　　def f1(self):
　　　　print(self.__name) #私有的字段

p = foo("hk")
print(p.f1()) #私有的字段只能在类的内部调用，通过f1方法调用
  # print(p._foo__name) #私有的成员修饰符也可以访问，不到万不得已不用！！！

存在类的继承，父类的私有子类是无法获取的。

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("han")
obj.f2() #存在类的继承，私有的成员修饰符也是不可以的。

class foo:
    __cc = 123 #静态字段
    def __init__(self,name):
        self.name = name
    def f1(self):
        print(self.name)
        return 135
    def f2(self):
        print(foo.__cc) #类名 . 静态字段
'''
    @staticmethod  #静态方法
    def f3():
        print(foo.__cc)
foo.f3()
'''
obj = foo('han')
print(obj.f2())   #对象执行f2的方法，私有的成员修饰符在类中可以找到并执行