精华内容
下载资源
问答
  • Python封装

    千次阅读 2021-04-16 16:46:53
    Python基础之封装 一、什么是封装   在程序设计中,封装(Encapsulation)是对具体对象的一种抽象,即将某些部分隐藏起来,在程序外部看不到,其含义是其他程序无法调用。   要了解封装,离不开“私有化”,就是...

    一、什么是封装

      在程序设计中,封装(Encapsulation)是对具体对象的一种抽象,即将某些部分隐藏起来,在程序外部看不到,其含义是其他程序无法调用。
      要了解封装,离不开“私有化”,就是将类或者是函数中的某些属性限制在某个区域之内,外部无法调用。

    二、为什么要封装

      封装数据的主要原因是:保护隐私(把不想别人知道的东西封装起来)
      封装方法的主要原因是:隔离复杂度(比如:电视机,我们看见的就是一个黑匣子,其实里面有很多电器元件,对于用户来说,我们不需要清楚里面都有些元件,电视机把那些电器元件封装在黑匣子里,提供给用户的只是几个按钮接口,通过按钮就能实现对电视机的操作。)
    提示:在编程语言里,对外提供的接口(接口可理解为了一个入口),就是函数,称为接口函数,这与接口的概念还不一样,接口代表一组接口函数的集合体。

    三、封装分为两个层面

      封装其实分为两个层面,但无论哪种层面的封装,都要对外界提供好访问你内部隐藏内容的接口(接口可以理解为入口,有了这个入口,使用者无需且不能够直接访问到内部隐藏的细节,只能走接口,并且我们可以在接口的实现上附加更多的处理逻辑,从而严格控制使用者的访问)
      第一个层面的封装(什么都不用做):创建类和对象会分别创建二者的名称空间,我们只能用类名.或者obj.的方式去
    访问里面的名字,这本身就是一种封装。

    print(p1.brand) #实例化对象(p1.)
    print(vehicle.tag) #类名(vehicle.)
    -------------输出结果--------------
    永久
    fuel oil
    

      注意:对于这一层面的封装(隐藏),类名.和实例名.就是访问隐藏属性的接口第二个层面的封装:类中把某些属性和方法隐藏起来(或者说定义成私有的),只在类的内部使用、外部无法访问,或者留下少量接口(函数)供外部访问。
      Python中私有化的方法也比较简单,即在准备私有化的属性(包括方法、数据)名字前面加两个下划线即可。
      类中所有双下划线开头的名称如__x都会自动变形成:_类名__x的形式:

    class A:
        __N=0 #类的数据属性就应该是共享的,但是语法上是可以把类的数据属性设置成私有的如__N,会变形为_A__N
        def __init__(self):
            self.__X=10 #变形为self._A__X
        def __foo(self): #变形为_A__foo
            print('from A')
        def bar(self):
            self.__foo() #只有在类内部才可以通过__foo的形式访问到. 
    

    这种自动变形的特点:
      1、类中定义的__x只能在内部使用,如self.__x,引用的就是变形的结果。
      2、这种变形其实正是针对外部的变形,在外部是无法通过__x这个名字访问到的。
      3、在子类定义的__x不会覆盖在父类定义的__x,因为子类中变形成了:_子类名__x,而父类中变形成了:_父类名__x,即双下滑线开头的属性在继承给子类时,子类是无法覆盖的。

    注意:对于这一层面的封装(隐藏),我们需要在类中定义一个函数(接口函数)在它内部访问被隐藏的属性,然后外部就可以使用了

    这种变形需要注意的问题是:
      1、这种机制也并没有真正意义上限制我们从外部直接访问属性,知道了类名和属性名就可以拼出名字:_类名__属性,然后就可以访问了,如a._A__N

    a = A()
    print(a._A__N)
    print(a._A__X)
    print(A._A__N)
    --------输出结果--------
    0
    10
    0
    

      2、变形的过程只在类的定义是发生一次,在定义后的赋值操作,不会变形

    a = A() #实例化对象a
    print(a.__dict__) #打印变形的内容
    a.__Y = 20 #新增Y的值,此时加__不会变形
    print(a.__dict__) #打印变形的内容
    ---------输出结果----------
    {'_A__X': 10}
    {'_A__X': 10, '__Y': 20} #发现后面的Y并没有变形
    

      3、在继承中,父类如果不想让子类覆盖自己的方法,可以将方法定义为私有的

    class A: #这是正常情况
        def fa(self):
            print("from A")
        def test(self):
            self.fa()
     
    class B(A):
        def fa(self):
            print("from B")
     
    b = B()
    b.test()
    --------输出结果----------
    from B
    

    看一下把fa被定义成私有的情况:

    class A: #把fa定义成私有的,即__fa
        def __fa(self): #在定义时就变形为_A__fa
            print("from A")
        def test(self):
            self.__fa() #只会与自己所在的类为准,即调用_A__fa
     
    class B(A):
        def __fa(self): #b调用的是test,跟这个没关系
            print("from B")
     
    b = B()
    b.test()
    -------输出结果---------
    from A
    

    四、特性(property)

    1、什么是特性property

      property是一种特殊的属性,访问它时会执行一段功能(函数)然后返回值(就是一个装饰器)

    注意:被property装饰的属性会优先于对象的属性被使用,而被propery装饰的属性,分成三种:property、被装饰的函数名.setter、被装饰的函数名.deleter(都是以装饰器的形式)。

    class room: #定义一个房间的类
        def __init__(self,length,width,high):
            self.length = length #房间的长
            self.width = width #房间的宽
            self.high = high #房间的高
        @property
        def area(self): #求房间的平方的功能
            return self.length * self.width #房间的面积就是:长x宽
        @property
        def perimeter(self): #求房间的周长的功能
            return 2 * (self.length + self.width) #公式为:(长 + 宽)x 2
        @property
        def volume(self): #求房间的体积的功能
            return self.length * self.width * self.high #公式为:长 x 宽 x 高
     
    r1 = room(2,3,4) #实例化一个对象r1
    print("r1.area:",r1.area) #可以像访问数据属性一样去访问area,会触发一个函数的执行,动态计算出一个值
    print("r1.perimeter:",r1.perimeter) #同上,就不用像调用绑定方法一样,还得加括号,才能运行
    print("r1.volume:",r1.volume) #同上,就像是把运算过程封装到一个函数内部,我们不管过程,只要有结果就行
    ------------输出结果---------------
    r1.area: 6
    r1.perimeter: 10
    r1.volume: 24
    

    注意:此时的特性arear、perimeter和volume不能被赋值。

    r1.area = 8 #为特性area赋值
    r1.perimeter = 14 #为特性perimeter赋值
    r1.volume = 24 #为特性volume赋值
    '''
    抛出异常:
        r1.area = 8 #第一个就抛异常了,后面的也一样
    AttributeError: can't set attribute
    '''
    

    2、为什么要用property

      将一个类的函数定义成特性以后,对象再去使用的时候obj.name,根本无法察觉自己的name是执行了一个函数然后计算出来的,这种特性的使用方式遵循了统一访问的原则。

    class people: #定义一个人的类
        def __init__(self,name,sex):
            self.name = name
            self.sex = sex #p1.sex = "male",遇到property,优先用property
     
        @property #查看sex的值
        def sex(self):
            return self.__sex #返回正真存值的地方
     
        @sex.setter #修改sex的值
        def sex(self,value):
            if not isinstance(value,str): #在设定值之前进行类型检查
                raise TypeError("性别必须是字符串类型") #不是str类型时,主动抛出异常
            self.__sex = value #类型正确的时候,直接修改__sex的值,这是值正真存放的地方
                #这里sex前加"__",对sex变形,隐藏。
     
        @sex.deleter #删除sex
        def sex(self):
            del self.__sex
     
    p1 = people("egon","male") #实例化对象p1
    print(p1.sex) #查看p1的sex,此时要注意self.sex的优先级
    p1.sex = "female" #修改sex的值
    print(p1.sex) #查看修改后p1的sex
    print(p1.__dict__) #查看p1的名称空间,此时里面有sex
    del p1.sex #删除p1的sex
    print(p1.__dict__) #查看p1的名称空间,此时发现里面已经没有sex了
    -------------------输出结果--------------------
    male
    female
    {'name': 'egon', '_people__sex': 'female'}
    {'name': 'egon'}
    

      python并没有在语法上把它们三个内建到自己的class机制中,在C++里一般会将所有的所有的数据都设置为私有的,然后提供set和get方法(接口)去设置和获取,在python中通过property方法可以实现。

    五、封装与扩展性

      封装在于明确区分内外,使得类实现者可以修改封装内的东西而不影响外部调用者的代码;而外部使用用者只知道一个接口(函数),只要接口(函数)名、参数不变,使用者的代码永远无需改变。这就提供一个良好的合作基础——或者说,只要接口这个基础约定不变,则代码改变不足为虑。

    #类的设计者
    class room: #定义一个房间的类
        def __init__(self,name,owner,length,width,high):
            self.name = name
            self.owner = owner
            self.__length = length #房间的长
            self.__width = width #房间的宽
            self.__high = high #房间的高
        @property
        def area(self): #求房间的平方的功能
            return self.__length * self.__width #对外提供的接口,隐藏了内部的实现细节,\
                                                # 此时我们想求的是房间的面积就是:长x宽
    

    实例化对象通过接口,调用相关属性得到想要的值:

    #类的使用者
    r1 = room("客厅","michael",20,30,9) #实例化一个对象r1
    print(r1.area) #通过接口使用(area),使用者得到了客厅的面积
    -------------输出结果--------------
    600 #得到了客厅的面积
    

    扩展原有的代码,使功能增加:

    #类的设计者,轻松的扩展了功能,而类的使用者完全不需要改变自己的代码
    class room: #定义一个房间的类
        def __init__(self,name,owner,length,width,high):
            self.name = name #房间名
            self.owner = owner #房子的主人
            self.__length = length #房间的长
            self.__width = width #房间的宽
            self.__high = high #房间的高
        @property
        def area(self): #对外提供的接口,隐藏内部实现
            return self.__length * self.__width,\
                   self.__length * self.__width * self.__high #此时我们增加了求体积,
            # 内部逻辑变了,只需增加这行代码就能简单实现,而且外部调用感知不到,仍然使
            # 用该方法,但是功能已经增加了
    

    对于类的使用者,仍然在调用area接口的人来说,根本无需改动自己的代码,就可以用上新功能:

    #类的使用者
    r1 = room("客厅","michael",20,30,9) #实例化一个对象r1
    print(r1.area) #通过接口使用(area),使用者得到了客厅的面积
    --------------输出结果---------------
    (600, 5400) #得到了新增的功能的值
    
    展开全文
  • python封装

    2019-12-19 19:55:09
    封装特性 什么是封装? 在日常中封装指的是将我们的物品包裹起来,不让看到其内部,具有保护的功 能。在程序设计中,封装(Encapsulation)是将类中的某些部分(某些属性或者方 法)隐藏起来,对象不能直接使用隐藏...

    其他面向对象正菜:
    面向对象之继承
    面向对象之多态

    封装特性

    什么是封装?
    在日常中封装指的是将我们的物品包裹起来,不让看到其内部,具有保护的功能。在程序设计中,封装(Encapsulation)是将类中的某些部分(某些属性或者方法)隐藏起来,对象不能直接使用隐藏起来的属性或者方法,具有保护功能。
    总结:隐藏对象的属性和方法实现细节,仅对外提供公共访问方式。
    封装格式?
    封装格式: __属性或者方法名称。(我们也叫做私有属性或者方法)
    封装的目的?
    封装的目的:保护隐私
    比如你的银行卡号跟密码都必须设成私有属性,因为这是隐私。

    私有属性

    私有属性定义的格式:
    __属性名=值

    私有属性有什么特性?
    在类的外部不能使用(对象不能调用私有属性)
    代码示例:
    在类中定义私有属性并在类的外面访问私有属性:

    class Student:
        def __init__(self,pet_name,account,password):
            self.pet_name=pet_name
            self.__account=account
            self.__password=password
    student=Student("小飞","xxxxxx","123456")
    print(student.pet_name)
    print(student.account)
    print(student.password)
    
    '''
    运行结果:
    小飞
    AttributeError: 'Student' object has no attribute '__account'
    AttributeError: 'Student' object has no attribute '__password'
    '''
    

    结论:私有属性访问失败了,那要如何访问私有属性呢?

    在类中访问私有属性代码示例:

    class Student:
        def __init__(self,pet_name,account,password):
            self.pet_name=pet_name
            self.__account=account
            self.__password=password
        def print(self):
            return "昵称:{},账号:{},密码:{}".format(self.pet_name,self.__account,self.__password)
    student=Student("小飞","xxxxxx","123456")
    student.print()
    
    '''
    运行结果:
    
    昵称:小飞,账号:xxxxxx,密码:123456
    '''
    

    结论:不能在类的外面访问类的私有属性,这正是封装的意义。

    私有方法

    定义私有方法定义格式:
    __方法名()
    私有方法的作用?
    就是在开发过程保护核心代码
    定义私有方法,并在类的外面访问私有方法与普通方法、
    代码示例:

    class A:
        def test(self):
            print("test")
        def __test1(self):
            print("test1")
            
    a=A()
    a.test()
    a.__test1()
    
    '''
    运行结果:
    test
    AttributeError: 'A' object has no attribute '__test1'
    '''
    

    结论:在类的外面访问类中私有方法失败了,那需要怎么访问类中的私有方法

    class A:
        def test(self):
            print("test")
    
        def __test1(self):
            print("test1")
    
        def print(self):
            self.test()
            self.__test1()
            
    a = A()
    a.print()
    
    '''
    运行结果:
    
    test
    test1
    '''
    

    结论:不能在类的外面访问类中的私有方法,这正是封装的意义。

    注意事项:
    1.在python中实现的封装操作,不是通过权限限制而是通过改名(name mangling 改名策略)实现的,名字变了找不到而已。
    2.可以使用 dict可以查看属性(包括私有属性)的值 在类的内部使用私有属性,python内部会自动进行转换成 _类名__属性名。 在类的外部不能给对象添加私有属性因为不能转换成_类名__属性名类型。
    3.可以通过 对象名.类名__方法或类名.类名__方法名访问到(但禁止这么干) 可以使用 _类名__私有属性名来获取值。但是一般情况下不要使用,了解即可

    展开全文
  • Python 封装

    2020-04-08 21:49:10
    1. 封装介绍 封装是面向对象三大特性最核心的一个特性 封装 ←→ 整合 2. 将封装的属性进行隐藏操作 2.1如何隐藏:在属性名前加__前缀,就会实现一个对外隐藏属性效果 该隐藏需要注意的问题: 在类外部无法直接访问...

    1. 封装介绍

    封装是面向对象三大特性最核心的一个特性
    封装 ←→ 整合

    2. 将封装的属性进行隐藏操作

    2.1如何隐藏:在属性名前加__前缀,就会实现一个对外隐藏属性效果

    该隐藏需要注意的问题:

    1. 在类外部无法直接访问双下滑线开头的属性,但知道了类名和属性名就可以拼出名字:_类名__属性,然后就可以访问了,如Foo._A__N,
      所以说这种操作并没有严格意义上地限制外部访问,仅仅只是一种语法意义上的变形。
    class Foo:
        __x = 1  # _Foo__x
    
        def __f1(self):  # _Foo__f1
            print('from test')
    
    # print(Foo.__dict__)
    # print(Foo._Foo__x)
    # print(Foo._Foo__f1)
    
    1. 这种隐藏对外不对内,因为__开头的属性会在检查类体代码语法时统一发生变形
    class Foo:
        __x = 1  # _Foo__x = 1
    
        def __f1(self):  # _Foo__f1
            print('from test')
    
        def f2(self):
            print(self.__x) # print(self._Foo__x)
            print(self.__f1) # print(self._Foo__f1)
    
    print(Foo.__x)
    print(Foo.__f1)
    obj=Foo()
    obj.f2()
    
    1. 这种变形操作只在检查类体语法的时候发生一次,之后定义的__开头的属性都不会变形
    class Foo:
        __x = 1  # _Foo__x = 1
    
        def __f1(self):  # _Foo__f1
            print('from test')
    
        def f2(self):
            print(self.__x) # print(self._Foo__x)
            print(self.__f1) # print(self._Foo__f1)
    
    Foo.__y=3
    print(Foo.__dict__)
    print(Foo.__y)
    
    class Foo:
        __x = 1  # _Foo__x = 1
    
        def __init__(self,name,age):
            self.__name=name
            self.__age=age
    
    obj=Foo('egon',18)
    print(obj.__dict__)
    print(obj.name,obj.age)
    

    3. 为何要隐藏?

    1. 隐藏数据属性"将数据隐藏起来就限制了类外部对数据的直接操作,然后类内应该提供相应的接口来允许类外部间接地操作数据,接口之上可以附加额外的逻辑来对数据的操作进行严格地控制:
    # 设计者
    class People:
        def __init__(self, name):
            self.__name = name
    
        def get_name(self):
            # 通过该接口就可以间接地访问到名字属性
            # print('小垃圾,不让看')
            print(self.__name)
    
        def set_name(self,val):
            if type(val) is not str:
                print('小垃圾,必须传字符串类型')
                return
            self.__name=val
    
    # 使用者
    obj = People('egon')
    # print(obj.name) # 无法直接用名字属性
    # obj.set_name('EGON')
    obj.set_name(123123123)
    obj.get_name()
    
    1. 隐藏函数/方法属性:目的的是为了隔离复杂度
    展开全文
  • python 封装

    2018-08-21 20:31:00
    二、封装 特点:单继承 多继承 多层次 特点:先实例化 父类 再实例化子类 现实:现有 爷爷 父亲 你 class B: def __init__(self): print("B的构造") pass class C(B): def __init__(self): ...

    二、封装

    特点:单继承  多继承   多层次  

    特点:先实例化 父类  再实例化子类

    现实:现有 爷爷  父亲   你

    class B:
        def __init__(self):
            print("B的构造")
        pass
    
    class C(B):
        def __init__(self):
            print("A的构造")
        pass
    
    # 实例化子类
    
    c=C( );
    

    1.先实例化父类再实例化子类

    2.Super关键字

    特派员

      生存:在子类  代表父类对象   A  B:super  C:super

     语法:

    构造:

    super().__init(self)

    方法:

    super().方法名()

    属性:

    suuper().属性

    3.题目

    给父类加一个属性

    父类有参数构造方法,子类必须定义一个有参数构造,给父类传递参数

    完整代码:

    class B:
        def __init__(self,name):
            print("B的构造")
            self.name=name
        pass
    class C(B):
        def __init__(self,name):
            super().__init__(name)
            print("A的构造")
        pass
    # 先实例化父类后实例化子类    输出:B构造  A构造
    c=C("张三丰" );
    print(c.name)
    # B的构造
    # A的构造
    # 张三丰
    

    简易代码: python帮助你赋值

    子类可以不写构造方法,创建子类对象,默认调用父类构造方法

    注意:

    1. 如果父类有,有参数构造 ,子类可以不写构造
    2. 如果父类有,有参数构造,子类的定义有参数构造必须调用父类有参数构造,进行赋值
    3. 如果父类是无参数构造(不写默认),子类有没有构造方法都可以
    4. 子类有没有构造  和 对父类没有关系
    class B:
        def __init__(self,name):
            print("B的构造")
            self.name=name
        pass
    class C(B):
        pass
    # 先实例化父类后实例化子类    输出:B构造  A构造
    c=C("张三丰" );
    print(c.name)

    题目:

       父类:Teacher

       子类:htmlTeacher  JavaTeacher

       属性:名字   学校

       方法:授课  自我介绍

    from day0810.Teacher import  *
    class JavaTeacher(Teacher):
    
        def giveLession(self):
            print("打开eclipse")
            super().giveLession()
    
    class HtmlTeacher(Teacher):
    
        def giveLession(self):
            print("打开Dreamweaver")
            super().giveLession()
    
    
    java=JavaTeacher("张三","北京分校")
    java.info()
    java.giveLession()
    
    html=HtmlTeacher("李四","山西分校")
    html.info()
    html.giveLession()
    
    
    class Teacher:
        def __init__(self, name, school):
            self.name = name
            self.school = school
    
        def giveLession(self):
            print("教学授课")
            print("总结布置作业")
    
        def info(self):
            print("我是",self.school,"的",self.name)

    练习;把HtmlTeacher中添加 编号属性, 输出:我的编号是:1001 我是北京分校的张三

     

    多继承

    class A:
        def test1(self):
            print("AAAAA")
    class B:
        def test1(self):
            print("BBBBB")
    class C(B,A):
        pass
    c=C()
    c.test1()
    print(C.__mro__)
    # BBBBB
    # (<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>)
    

    总结:

      语法:class  子类(父类1,父类2)

      方法名相同:先子类   父类1   父类2

      方法名不同:子类全部继承

     

    展开全文
  • bluepy 一款python封装的BLE利器
  • python封装exe+exe封装服务

    千次阅读 2018-08-18 18:46:38
    python封装exe+exe封装服务 python封装exe+exe封装服务 一、python封装exe 安装pyinstaller: 打包 二、exe封装为服务 使用SC指令封装服务 使用nssm封装服务 一、python封装exe 本来使用的python...
  • 主要介绍了Python封装原理与实现方法,结合实例形式较为详细的分析了Python封装的概念、原理、实现方法及相关操作注意事项,需要的朋友可以参考下
  • 主要介绍了Python封装shell命令,实例分析了Python将各种常用shell命令封装进一个类中以便调用的方法,非常具有实用价值,需要的朋友可以参考下
  • python封装成exe

    万次阅读 多人点赞 2018-10-17 14:45:15
    最近写了一个小小的程序,需要进行封装exe,为了简单,就直接用了pyinstaller这个模块,对于python3.6版本的童鞋来说,简直方便的不要。下面就给大家介绍一下如何用pyinstaller去封装程序为exe程序。 首先,需要安装...
  • rabbitmq-python-wrap rabiitmq服务器连接的python封装 支持多台Rabbitmq服务器负载 (避免单点故障) 支持检查连接心跳
  • python封装实例

    2020-02-15 10:30:39
    python封装实例 封装是面向对象的三大特性之一 封装指的是隐藏对象中一些不希望被外部所访问到的属性或方法 如何隐藏一个对象中的属性? - 将对象的属性名,修改为一个外部不知道的名字 如何获取(修改)对象中的...
  • python封装继承多态笔记,python封装继承多态笔记,python封装继承多态笔记适合初学者学习!
  • 大漠插件python封装

    2017-01-23 20:48:24
    对大漠插件的python封装,用于windows环境鼠标、键盘操作,图像比较、文字识别等,基本以直接调用大漠接口为主。需要用到大漠插件及大漠综合工具 大漠插件调用库 MoveClick 移动并左键单击 SayString 发送文本,有x...
  • Python封装excel操作

    2021-01-27 21:55:59
    Python封装excel操作结构说明代码解析 openpyxl 是 python 中操作 excel 表格比较常用的一个库,可以读取和写入excel文件,支持【.xlsx / .xlsm / .xltx / .xltm】格式的文件,处理excel数据、公式、样式,且可以在...
  • MQTT客户端(python封装的类),类的方法包括连接、订阅和发布。
  • python封装日志类

    2020-08-15 15:16:28
    日志在编写代码的时候会要经常遇到的,做自动化测试的时候也需要查看日志,所以需要了解python封装日志的方式。 python的日志等级是:CRITICAL>ERROR>WARNING>INFO>DEBUG 默认的等级是WARNING,设置了...
  • 今天小编就为大家分享一篇钉钉群自定义机器人消息Python封装的实例,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 对大漠插件的python封装,用于windows环境鼠标、键盘操作,图像比较、文字识别等,基本以直接调用大漠接口为主。需要用到大漠插件及大漠综合工具 大漠插件调用库 MoveClick 移动并左键单击 SayString 发送文本,有x,...
  • python封装和解构

    2018-03-31 17:21:23
    python封装和解构封装多个值 , 分割封装成元组== 内容的一致性判断例子t1 = (1,2)#定义为元组t2 = 1,2 #将1和2封装成元组a,b=b,a 相当于b给a,a给b解构把线性结构的元素解开,并顺序的赋给其他变量左边接纳的要与...
  • modbus的python封装包MinimalModbus,是window客户端,很好用
  • python封装 (pyinstaller)

    千次阅读 2018-03-19 18:16:46
    windows 下编写控制台程序后,会生成exe的可执行程序,创建工程最后都会生成可执行程序,python工程都是python调用各种模块,执行起来也不方便,所以这里讲一下python封装exe文件过程!windows 系统(按照我自己环境...
  • google推出了一版word2vec,词的向量化技术极大改变了文本分析的传统方法。这种是深度学习的方法,在nlp领域的全新应用。...现在提供python封装版本,方便nlp的工程师们在自己熟悉的python领域进行应用。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 26,587
精华内容 10,634
关键字:

python封装

python 订阅