Python笔记总结week8

时间：2024-01-05 14:17:14

面向对象第二节

要点：

1. 封装，对象中嵌套对象

2. pickle,load,切记，一定要先导入相关的类

回顾上一节：

面向对象三大特性：

封装、继承、多态（多种类型、多种形态）

关于多态，任意参数的函数有如下特性：

def func(arg):

    print(arg)

func(1)

func("Alex")

func([11,22,33])

关于arg参数：

class A:

    pass

class B(A):

    pass

class C(A):

    pass

#arg参数,必须是A类型或是A的子类类型

def func(A arg):

    print(arg)

#obj = B()

#obj = C()

obj = A()

func(obj)

面向对象中类成员

字段：静态字段、普通字段

P.S：静态字段代码加载的时候已经创建

class Foo:

    #字段(静态字段)

    CC = 123

    def __init__(self):

        #字段(普通字段)

        self.name = "Alex"

    def show(self):

        print(self.name)
class province:

    country = "China"

    def __init__(self,name):

        self.name = name

#一般情况,自己访问自己字段

#规则:

#普通字段只能用对象访问

#静态字段用类访问(万不得已时用对象访问)

hn = province("Henan")

hb = province("Hebei")

print(hn.name)   #Henan

print(province.country) #China

print(hn.country) #China

方法：

所有的方法属于类

1.普通方法，至少一个self，对象执行

2.静态方法，任意参数，类执行（对象执行）

3.类方法，至少一个class，类执行（对象执行）

class province:

    country = "China"

    def __init__(self,name):

        self.name = name

        #普通方法,用对象去调用执行(方法属于类)

    def show(self):

        print(123)

    @staticmethod

    def f1(cla,arg1,arg2):

        print(arg1,arg2)

        #静态方法,用类调用执行.(当方法内部不需要对象中封装的值时,可以将方法写成静态方法)

    @classmethod

    def f2(cls):  #class

        cls #类名,()创建对象

        #cls()

        print(cls)

obj = province("Henan")

obj.show() #

province.f1(province,1,2) #1 2

province.f2() #<class '__main__.province'>
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")

p = pager(101)

print(p.all_count) #字段,101

#result = p.all_pager()#方法

ret = p.all_pager

print(ret)    #

p.all_pager = 111 #

del p.all_pager  #del all_pager

属性：

不伦不类的东西

具有方法的写作形式，具有字段的访问形式

class foo:

    __cc = ""

    def __init__(self,name):

        self.name = name

    def f1(self):

        print(self.name)

obj = foo('alex')

print(obj.name) #alex

obj.f1() #alex
class Foo:

    __cc = ""

    def __init__(self,name):

        self.name = name  #定义一个私有的普通字段

    def f1(self):

        print(self.name)

    @staticmethod

    def f3():

        print(Foo.__cc)

#print(Foo.__cc)

obj = Foo("ddd")

obj.f3() #

Foo.f3() #

私有普通方法

class Foo:

    __cc = ""

    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.f1() #alex   #通过调用类中的公有方法来执行私有方法

私有静态法

class Foo:

    def __init__(self,name):

        self.__name = name  #定义一个私有的普通字段

    @staticmethod

    def f2(num):

        print(num)

    @staticmethod

    def f3(num):

        print(num)

Foo.f3(10)  #
class Foo:

    #构造方法

    def __init__(self,name,age):

        self.name = name

        self.age = age

    #析构方法

    def __del__(self):

        pass

    def __call__(self):

        print("call")

    def __str__(self):

        return("%s-%d"%(self.name,self.age))

'''obj = Foo()

obj() #对象()执行call

#Foo()()'''

obj1 = Foo('alex',74)

obj2 = Foo('eric',93)

print(obj1,obj2) #alex-74 eric-93

ret =str(obj1)

print(ret)   #alex-74

#获取对象中封装的数据

ret = obj1.__dict__

print(ret)   #{'name': 'alex', 'age': 74}

相关文章