威尼斯人线上娱乐

【威尼斯人线上娱乐】面向对象,python类和指标

30 3月 , 2019  

成员和嵌套(组合)

面向对象 Object Oriented Programing


类的成员可分为三大类:字段丶方法和品质

在面向对象的章程中,能够根据有个别事物恐怕情景创制类,并依照那些类来创设对象。编写类时,定义一大类对象都有通用行为,基于类成立的靶子,每种对象都活动具备这几个类的通用行为。
据书上说类来成立对象被号称实例化。
在Python中编辑类的法门如下:

成员

【威尼斯人线上娱乐】面向对象,python类和指标。类的特征

  • 封装
  • ① 、防止数据被随意改动
  • 贰 、使表面程序不需求灌注对象内部的构造,只供给通过此目的对外提供的接口举办直接访问即可

  • 继承

  • 一 、类能够派生出子类
  • 二 、父类里定义的本性、方法自动被子类继承
  • ③ 、通过父类=>子类的办法以细小代码量的办法达成不一致角色的共同点和差别点同时设有

  • 多态

  • 1个接口,种种贯彻;父类派生出分化的子类,子类在继承父类的均等格局同时又对父类的格局做了差别的完成,那也正是同样种东西表现出的有余形态。
  • 例:人类是一个父类,派生出中华夏族、德国人、英国人等子类,子类继承使用talk()方法,但分歧人所说语言不相同,talk()方法依照差别人变现出差异的攀谈语言(普通话、英文…)。
  • 即对差异目的发出的新闻将会有例外的一举一动。例如:CEO只要发生新闻(工作),不相同的职员和工人对象将会按本人的效力实行区别的办事。

一丶字段

class Dog():
    '''创建小狗的类'''
    def __init__(self,name,age):
        self.name = name
        self.age = age

    '''动作方法 蹲下'''
    def sit(self):
        print(self.name+'蹲下了'+self.age)

1.类的分子:变量,方法,属性

变量:

  实例变量(字段)

    公有实例变量(字段)

1 class Foo:
2     def __init__(self,name):
3         self.name = name#公有实例变量
4     
5      def func(self):
6         return self.name

 

    私有实例变量(字段)

1 class Foo:
2     def __init__(self):
3         pass
4     def __func(self):
5         print("私有实例变量")
6 
7 obj = Foo()
8 obj.func()#此处无法调用

 

  类变量(静态字段)

    公有类变量(静态字段)

 1 class Foo:
 2     a = 1#公有类变量
 3     def __init__(self):
 4         pass
 5     def func(self):
 6         return self.a
 7 
 8 obj = Foo()
 9 print(obj.a)
10 print(Foo.a)

 

    私有类变量(静态字段)

1 class Foo:
2     __a = 1
3     def __init__(self):
4         pass
5     def func(self):
6         print(self.a)#不能引用,错
7 
8 obj = Foo()
9 obj.func()

总结:

  公有实例变量能够在类的章程中运用,也足以用实例化的靶子调用

  私有实例变量不可能在对象调用,只可以在类中用别样格局调用后,再利用对象调用

  公有类变量能够在类中调用,也得以用对象调用

  私有类变量只能在类中利用其它艺术调用,无法采用对象调用,子类也不可能调用(借使需求求用,先在父类中运用情势来调用这几个私有类变量,再在子类中调用那几个艺术)

 

方法:

  实例方法

  

1 class Foo:
2     def __init__(self,name):
3         self.name = name
4     def func(self):#实例方法
5         print(self.name)
6 
7 obj = Foo("abc")
8 obj.func()

 

  静态方法

1 class Foo:
2     def __init__(self,name)
3         self.name = name
4     @staticmethod#静态方法
5     def display(a1,a2):
6         return a1 + a2
7 
8 Foo.display(1,2)
#如果无需使用对象中封装的值,就可以使用静态方法

 

  类方法

1 class Foo:
2     @classmethod
3     def show(cls,x1,x2):#默认第一个参数是类(cls)
4         print(cls,x1,x2)
5 
6 ret = Foo.show(1,2)
7 print(ret)

总结:

  实例方法:至少有一个参数,第3个参数必须是实例对象,暗许是self

  静态方法:能够没有参数,也无需利用对象中封装的值,方法方面须要加@staticmethod

  类方法:至少有多个参数,第一个参数必须是类,默许是cls,方法方面需求加@classmethod

 

属性(通过艺术改造出来):

  

 1 class Foo:
 2     def __init__(self):
 3         pass
 4     @property
 5     def start(self):
 6         return 1
 7     @property
 8     def end(self):
 9         return 2
10 
11 obj = Foo()
12 print(obj.start)
13 print(obj.end)

计算:属性编写时,方法方面写@property,方法中唯有2个参数self

  调用时,无需加括号,间接是对象.方法

  对于简易的方法,当无需传参且有再次回到值时,能够动用性质

 

类的定义

class class_name(object):
    attr_name = value #类的公有属性,静态字段
    def __init(self,参数1,参数2...):#构造函数,初始化实例时执行
        self.name = 参数1
        ...#类的属性,成员属性,普通字段

    def func(self,参数1,参数2...):#类的方法
        pass

    def __del__(self):#析构函数,实例销毁时执行
        pass

  字段包蕴:普通字段和静态字段,他们在概念和平运动用中有所差异,而最本质的差距是内部存款和储蓄器中保存的岗位不一致.

方法init()

init()是贰个例外的点子,每当依据类成立类的实例时,Python都会自行运维这些主意。在这么些措施中伊始和最后各有五个下划线。那是一种约定。防止Python默许方法与一般方法爆发名称冲突。
init()定义中我们传递了八个参数:self、name和age。这一个开首化方法中self是必须的。而且还非得放在别的的形参前边。各个与类相关联的措施调用都自动传递实参self,它是三个针对性实例本人的引用。让实例能够访问类中的属性和办法
init()方法中定义的七个变量都有前缀self。以self为前缀的变量都可供类中的全数办法运用。
init()没有并不曾显式地含有return语句,但Python自动重临类对象的实例。

嵌套(组合):

 1 class Student(object):
 2     def __init__(self,name,age)
 3         self.name = name
 4         self.age = age
 5 #创建三个人
 6 obj1= Student("a",18)
 7 obj2= Student("b",20)
 8 obj3= Student("c",21)
 9 
10 class School(object):
11     def __init__(self,name,address)
12         self.name = name
13         self.address = address
14 
15 #创建三个学校
16 s1 = School("学校1","北京")
17 s2 = School("学校2","上海")
18 s3 = School("学校3","深圳")
19 
20 
21 #给每个学生分配学校
22 obj1.school = s1
23 obj2.school = s2
24 obj3.school = s3
25 
26 print(obj1.school.name)
27 print(obj2.school.name)
28 print(obj3.school.name)

 

类的实例化

var1 = class_name(参数1,参数2...)#这里传入构造函数中形参的实参

  普通字段属于对象

Python2.7创制类的点子

  • 在Python2.7中创制类

class ClassName(Object):
...

类的村办属性

self.__attrname用多少个下划线伊始定义为私有品质,只在类的内部能够访问

  静态字段属于类

class Foo:    #类变量    country = "你好"    def __init__(self,name):        # 实例变量        self.name = name    def too:        print("===========")#直接访问普通字段obj = Foo("李白")obj.too()#直接访问静态字段print(Foo.country)

基于类创制实例

my_dog = Dog('dog1',22)
my_dog.sit()

只读访问私有属性

  • 在类中定义3个方法重回此属性,对外表提供只读访问接口

    def get_attrname(self)
    return self.__attrname
    
  • 强制访问(不要那样做)
    实例后跟‘.’,接二个下划线,接类名,接三个下划线的私有属性

    var1 = class_name()
    var1._class_name__attrname
    

  由上述代码能够看到[常备字段必要通过对象来拜访] [静态字段通过类访问],在选择上可以看来普通字段和静态字段的归属是见仁见智的,其在剧情的存款和储蓄情势也不平等,静态字段在内部存款和储蓄器中只保留一份,普通字段在各个对象中都要封存一份

走访属性

能够根据实例访问实例的脾性。在实施时,Python会先找到实例,再找找与这几个实例相关联的属性name.

print(my_dog.name)

类的国有属性

var1 = class_name(参数1,参数2)
var2 = class_name(参数1,参数2)
#上文定义类中,var1.name和var2.name是根据实例化时传入的参数1而不同,因此叫做成员属性
#上文中在__init__前定义的attr_name则是公有属性,由每个实例共享

#更改类的公有属性
var1.attr_name = new_value#通过实例去修改,修改的是实例自己的公有属性
#此时print(var1.attr_name)  值发生改变,print(var2.attr_name)  值未改变

class_name.attr_name = new_value#通过类更改,修改的是所有以这个类实例化的对象的公有属性
#此时print(var1.attr_name)  ,print(var2.attr_name)  值均已改变,且均为new_value

  上面大家看来的三种字段都以公有字段,下边为私有字段

class Foo:    #类变量    country = "你好"    #私有类变量    __ctorens = "再见"    def __init__(self,name,phone):        # 实例变量        self.name = name        #私有示例变量        self.__phone = phone    def too:        print(Foo.__ctorens)#直接访问普通字段obj = Foo("李白","165136851546")obj.too()#直接访问静态字段print(Foo.country)#在类外面是没法访问类中的私有字段的,所以这里会报错print(Foo.ctorens)

威尼斯人线上娱乐 1

为属性钦定暗中认可值

类中的各类属性都必须有初步值,大家能够为类的性质钦定暗中同意值。

class Car():
    def __init__(self, name, year, price):
        self.name = name
        self.year = year
        self.price = price
        self.owner = 'dos auto'
    def get_car_name(self):
        return self.name
    def get_car_woner(self):
        return self.owner
my_car = Car('benz', 11, 2000000)
print(my_car.get_car_name())
print(my_car.get_car_woner())

面向对象编制程序(OOP)语言的多少个首要功用便是【继承】

  • 连续是指利用现有类的富有机能,无需编写原来的类而开始展览那几个成效的扩展
  • 经过持续创建的新类称为【子类】或【派生类】
  • 被接二连三的类称为【父类】、【基类】或【超类】
  • 继承能够因而【继承】(Inheritance)和【组合】(Composition)来落到实处
  • 在少数OOP语言中,1个子类能够连续八个基类。但一般意况下,多个子类只持续一个基类,要促成多重继承,能够通过一类别继承来达成。

二丶方法

类的三番九遍

在地方计算的类的定义的时候,我们表明类的时候是从空白伊始的,倘若我们要评释定义的类是持续某2个类可以在此钦定要三番五次的父类

  • 概念子类时,必须在括号内钦定父类的称号
  • 在创设子类的实例时,Python首先需求给父类的具备属性赋值。
  • 创办子类时,父类必须包蕴在眼下文件中,且位于子类前边。
  • 子类中得以行使super()代表父类的引用。

class Car():
    def __init__(self, name, year, price):
        self.name = name
        self.year = year
        self.price = price
        self.owner = 'dos auto'

    def get_car_name(self):
        return self.name

    def get_car_woner(self):
        return self.owner
'''子类,电动汽车'''
class ElectricCar(Car):
    def __init__(self, name, year, price):
        super().__init__(name, year, price)
my_tesla = ElectricCar('tesla', 2, 200000)
print(my_tesla.get_car_woner())
print(my_tesla.get_car_name())

接轨的落到实处情势有二种

  • 福寿齐天持续
  • 采取基类的习性方法无需额外编码
  • 接口继承
  • 仅使用基类的性质和情势名称,但子类必须重构基类方法

  方法包含普通方法丶静态方法和类措施,三种方法在内部存款和储蓄器中都归属于类,区别在于调用格局各异

涵盖的超类——object

每贰个python类都带有了二个超类:object,这一个类是二个相当简单的定义,那个类大约不做别的业务。对象生命周期的功底是创造、起先化和销毁。全部类的超类object都有三个暗中同意包罗pass的init()方法的贯彻。

在设想选拔持续时,必要留意三个类之间应该是【属于】关系


  1.平时方法:由对象调用,至少3个self参数,执行平日方法时,自动将调用该格局的对象赋值给self

持续中的init 方法

  • 子类能够不重写init措施,实例化子类时,会活动调用父类中已经定义的init
  • 一旦子类中定义了init,也正是说子类重写了init,则不会再去自动调用父类中已定义的init方法
  • 最佳显式调用超类的init方法

看多少个栗子

class father1:
    def say_something(self,args):
        print(args)

class father2:
    def say_something2(self,args):
        print(args)

class son:
    def __init__(self):
        print(self)

s = son()
>>>
<__main__.son object at 0x101a45908>

地方的主次中,在结构son的实例对象时会自动调用son的已定义的init方法

'''
继承中的__init__
'''
class father1:
    def say_something(self,args):
        print(args)

class father2:
    def __init__(self):
        print("father2 init")
    def say_something2(self,args):
        print(args)

class son(father2):
    def __init__(self):
        print(self)

s = son()

地点的法门中,父类定义了init格局,可是子类重写了父类的init主意,那样程序就不会再调用父类的init艺术了。除非显式调用父类的init方法:

class son(father2):
    def __init__(self):
        super(son,self).__init__()
        print(self)
s = son()

当子类中从未概念init措施,在布局子类实例的时候就会进行父类已经定义的init,注意:那里只会实施父类中早就定义的init措施,假如父类中尚无定义init或然说没有重写init主意,会延续查找父类中定义的init格局,向来到拥有的父类Object

class father1:
    def say_something(self,args):
        print(args)

class father2:
    def __init__(self):
        print("father2 init")
    def say_something2(self,args):
        print(args)

class son(father2):
    pass

s = son()

继承

class class_name(object):
    def __init__(self,name,age):
        pass

    pass

#子类
class sun_class_name(class_name):
    def __init__(self,name,age,参数1...)#先继承,再重构,
        class_name.__init__(self,name,age)#继承父类构造方法
        #super(sun_class_name,self).__init__(name,age) #新式类写法
    pass
  • 子类构造函数若是重构,则先三番五次父类构造函数,再重构
  • 子类继承父类的习性和办法,假诺重构方法,使用重构后措施

   2.类方法:由类调用,至少三个cls参数,执行类措施时,自动将调用该方式的类赋值给cls

多继承

Python帮忙多一而再,大家明白子类会继承父类中的属性和情势。python中要求继续八个类的时候,使用如下的格式

class 子类(父类1,父类2):
    pass

那么当四个父类都富含相同的方法,会怎么着履行呢?

class father1:
    def say(self,args):
        print(args+'father1')


class father2:
    def say(self,args):
        print(args+'father2')

class son(father1,father2):
    pass
s = son()
s.say('it say something')

>>>
it say somethingfather1

能够看到,python会执行第②个父类中的相关方法
咱俩用图解来解释一下执行各种

威尼斯人线上娱乐 2

duojicheng.jpg

在有八个父类的景况下,会先去继承的首先个父类寻找 然后再去第一个寻找
那正是说,在有多重继承的情况下,并且有国有的基类的情景下啊?

class base:
    def say_base(self, args):
        print(args + 'base')


class father1(base):
    def say(self, args):
        print(args + 'father1')

    def say_base(self, args):
        print(args + 'father1')


class father2(base):
    def say(self, args):
        print(args + 'father2')
    def say_base(self, args):
        print(args + 'father2')
class son(father1, father2):
    pass
s = son()
s.say_base('it say something')

大家依照实施结果,能够见见程序会今后子类中查找要履行的方式和函数,然后会在首先个父类中检索倘若没有找到,会在第3个父类中寻找。如若也没有找到会去父类的共用基类找。图示

威尼斯人线上娱乐 3

gonggongjilei.jpg

先后的进行各种是 1 2 3

新式类和经典类

  • 新式类和经典类在python3中都以广度查找来持续
  • 接轨写法

    class_name.init(self,name,age)#继承父类构造方法
    #super(sun_class_name,self).init(name,age) #新式类写法

   3.静态方法:由类调用,无默许参数

# 实例方法class Foo:    def __init__(self,name):        self.name = name    #实例方法    def tom:        passobj = Foo("XX")obj.tom()#静态方法#在方法前面加@staticmethod,方法名中的self也不用写了,可以写任何参数,调用直接用  类名.方法名 调用class Foo:    def __init__(self,name):        self.name = name    #静态方法,如果方法无需使用对象中封装的值,那么就可以使用静态方法    @staticmethod    def tom:        printFoo.tom(1,2)# 类方法#在方法前面加上@classmethod,方法名中参数必须有cls,cls是指类class Foo:    def __init__(self,name):        self.name = name    def show1:        print    # 类方法    @classmethod    def show:        print  #<class '__main__.Foo'> 1 2Foo.show

类成员

封装

  • 类中封装了字段(属性)和方法
  • 对象(实例)中封装了:普通字段的值

  方法跟字段一样,也分为私有跟国有,私有正是在章程名前边加上__,调用是无法在类外面平素调用,必要调用类中的一个国有方法,再在国有方法里调用私有方法

class Foo:    def __init__(self,name):        self.name = name    def show1:        Foo.__show(1,2)    # 私有类方法    @classmethod    def __show:        print  #<class '__main__.Foo'> 1 2obj = Foo("XX")obj.show1()

类成员修饰符

an example(组合包装)

class F1(object):
    def __init__(self,n):
        self.N = n
        print("F1")

class F2(object):
    def __init__(self,arg1):
        self.a =arg1
        print("F2")

class F3(object):
    def __init__(self,arg2):
        self.b =arg3
        print("F3")

#实例化
o1 = F1("lmc")
o2 = F2(o1)
o3 = F3(o2)

#s输出'lmc'
o1.b.a.N

三丶属性

共有成员

  • 共有成员包涵静态字段,普通字段,普通对象方法,静态方法,类措施

继承

class F1:
    def __init__(self):
        pring("F1")
    def a1(self):
        print("F1a1")

class F2(F1):
    def __init__(self):
        pring("F2")
    def a1(self):
        print("F2a1")

class F3(F2):
    def __init__(self):
        pring("F3")
    def a1(self):
        print("F3a1")

#实例化
obj = F3()
#当执行obj.a1()时,因F3重构了a1()方法,此时调用F3.a1()
obj.a1()->>"F3a1"

class F1:
    def __init__(self):
        pring("F1")
    def a1(self):
        print("F1a1")
    def a2(self):
        print("F1a2")

class F2(F1):
    def __init__(self):
        pring("F2")
    def a1(self):
        self.a2()
        print("F2a1")
    def a2(self):
        print("F2a2")

class F3(F2):
    def __init__(self):
        pring("F3")
    def a2(self):
        print("F3a2")

#实例化
obj = F3()
#当执行obj.a1()时,因F3未重构了a1()方法;F2重构了a1(),此时调用F2.a1(),
#此时F2.a1()中第一句调用self.a2(),self即调用方法本身的对象F3,所以执行本身的F3.a2()
#在父类里的self是当前调用方法对象,因obj->F3实例化后的指向是F3,所以为最底层的F3
obj.a1()--->>"F3a2" [换行] "F2a1"

  属性的概念时便是在常常方法的根基上添加@property装饰器,属性仅有三个self参数,调用时无需括号

class Foo:    def __init__:        pass    #属性在方法名前面加上@property    @property      def start:        return 1obj = Foo()print(obj.start)    #无需加括号,直接调用

村办成员

  • 类的成员,假若选拔__filename
    作为定义,那么那些成员是个人的,非常小概透过外部对象直接待上访问,私有成员能够修饰字段、方法
  • 利用民用成员修饰的力不从心被持续,只好通过直接来做客私有的成员

class F:
    # 静态成员变量
    staticvar = 'static var'
    # 私有静态成员变量
    __privatevar = 'private var'

    def __init__(self, name, value):
        self.__objprivatevalue = name
        self.normalvalue = value

    def __privateMethod(self):
        print('private method')

    def visitPrivateFile(self):
        print(self.__objprivatevalue)

    @staticmethod
    def visitStaticFile():
        print(F.__privatevar)


# 直接通过对象访问普通字段
f = F('F class', 'normalValue')
print(f.normalvalue)  # 正常访问
# 直接访问静态字段
print(F.staticvar)  # 正常访问
# 直接访问普通私有字段
# print(f.__objprivatevalue) 无法访问
# 直接访问静态私有字段
# print(F.__privatevar) 无法访问
# 间接访问普通私有字段
print(f.visitPrivateFile())
# 间接访问静态私有字段
print(F.visitStaticFile())
  • 在后续中的私有字段

class s(F):
    def __init__(self):
        # 构造父类
        super(s, self).__init__('s of father', 'father value')
        self.s_name = 'son_name'

    def visitParent(self):
        # 访问子类普通字段
        print(self.s_name)
        # 访问父类普通字段
        print(self.normalvalue)
        # 访问父类私有普通字段
        # print(self.__objprivatevalue) 无法访问
        # 访问父类私有静态字段
        # print(F.__privatevar) 无法访问



# 直接通过对象访问普通字段
s = s()
s.visitParent()
# 调用继承的父类普通方法
s.visitPrivateFile()
# 调用继承的父类私有普通方法
# s.__privateMethod() 无法调用

静态方法

  • 字段
  • 常常字段/普通属性(保存在实例化的对象中)
  • 静态字段/静态方法(保存在类中)

  • 方法

  • 普普通通方法(保存在类中,实例化的对象开始展览调用,至少有一个self参数)
  • 静态方法(保存在类中,调用者-》类(无需创制对象),能够有自由参数):

    class F1:

    @staticmethod
    def a1(self):#静态方法self参数不是必须
        print("F1A1")
    

    F1.a1()直接调用,不必实例化。


四丶面向对象的嵌套

字段 属性

类的办法

  八个类中的变量互相建立关系就叫嵌套

class School:    def __init__(self,name):        self.name = nameobj = School("舞蹈教室")obj1 = School("音乐教室")obj2 = School("美术教室")class Teacher:    def __init__(self,name):        self.name = namet = Teacher("舞蹈老师")t1 = Teacher("音乐老师")t2 = Teacher("美术老师")#############为老师分配教室t.School = objt1.School = obj1t2.School = obj2############查看t1老师所在的教室print(t1.School.name)

一般说来字段

构造方法

def __init__(self,arg1,arg2...)
    pass
  • 类实例化时直接调用,如有参数,实例化时索要同时传入参数
概念子类的性质和章程(普通字段 普通方法)

不足为奇字段属于对象,保存在对象中,惟有在创设对象的时候才会创立,每四个指标都会蕴藏一份

  • 一般说来字段的创办
    增加产量子类的习性使用self代表针对当前目的的引用,使用self定义的属性创立的装有实例都将富含这么些脾气。但有所父类都不分包子类定义的习性和方法

class ElectricCar(Car):
    def __init__(self, name, year, price):
        super().__init__(name, year, price)
        self.battery = 70
    def get_currentbattery(self):
        print('current barrery is' + str(self.battery))
my_tesla = ElectricCar('tesla', 2, 200000)
my_tesla.get_currentbattery()
'''创建父类的对象'''
my_car = Car('farrire', 1, 50000)
  • 一般性字段的走访
    • 一般而言对象只好透过对象访问,每一个目的都有谈得来的字段

析构方法

def __del__(self):
    pass
  • 去除对象时(del class_name)或程序退出时调用

静态字段

静态字段属于类,在内部存款和储蓄器中只保留一份
Python解释器是从上到下解释代码的,静态字段在解释类的时候会创立并且创办到类中。

  • 静态字段的创造

class class_file:
    name = '静态字段'

    def __init__(self,name):
        self.objname = name
  • 静态字段的拜会
    • 因此类访问

print('静态字段'+class_file.name)
# print(class_file.objname)  报错,实例成员变量无法通过类访问

* 通过对象访问

能够透过对象访问静态的字段,通过对象更改静态字段的话,由于静态字段唯有一份,所以通过对象更改静态字段会改变全体的

# 通过类对象访问
clf = class_file('类对象')
print(clf.name)

收获类的习性字典

查看类或对象中的全部成员

  • 类.__dict__,重返类的性质,以字典方式
  • self.__dict__

分外成员

  • Python中有三个新鲜的分子 威尼斯人线上娱乐,str 能够将3个对象转换为字符串,方便大家打字与印刷对象的连带新闻,有点类似Java中的toString
  • 其余的不一样平日成员还包涵
    • init 构造类对象的时候会自行执行
    • call 对象() 类名()() 会自动调用
    • int int(对象名)会活动调用
    • del 析构方法 会在对象被灭绝时调用

class SpecialMembers:
    def __init__(self):
        self.arg1 = '123'
        self.arg2 = 'abc'
        self.arg3 = True
    '''
    在对象销毁的时候调用
    '''
    def __del__(self):
        print('obj destory')
sm = SpecialMembers()
print(sm.__dict__)
del sm
>>> 
obj destory
  • dict 将目的中封装的具有的内容通过字典的样式重临

class SpecialMembers:
    def __init__(self):
        self.arg1 = '123'
        self.arg2 = 'abc'
        self.arg3 = True
sm = SpecialMembers()
print(sm.__dict__)
>>> {'arg1': '123', 'arg2': 'abc', 'arg3': True}
  • str str() 重返字符串格局描述

class to_string:
    def __init__(self):
        self.__private_name =  'toString'
        self.name = 'toString_name'
    def __str__(self):
        return "%s:%s" % (self.__private_name,self.name)
# 创建 to_string 对象
ts = to_string()
print(ts)
  • getitem 获取item
  • setitem 为指定item设置值
  • delitem 删除某项

Python
中的特殊情势能够为普通对象给予类似列表之类的效果,能够设置或获得某个项的值

class SpecialMembers:
    def __init__(self):
        self.arg1 = '123'
        self.arg2 = 'abc'
        self.arg3 = True

    def __getitem__(self, item):
        return item

    def __setitem__(self, key, value):
        print(key,value)

    def __delitem__(self, key):
        print(key)


sm = SpecialMembers()
# 此处会调用 __getitem__
print(sm[20])
# 调用__setitem__
sm[22] = 222
# 调用__delitem__
del sm[50]
  • iter

python中大家循环1个可迭代对象的进度是:执行对象的类中的iter方法,并获得再次回到值,然后循环上一步中回到的对象
万一贰个类中有iter主意,那么这一个类正是可迭代对象
循环时,可迭代对象会调用对象.iter()方法,然后再实践next方法举行下一遍的迭代

class SpeciaIter:
    def __iter__(self):
        return iter(['a','b','c','d'])


si = SpeciaIter()
# 迭代这个可迭代对象
for i in si:
    print(i)

@staticmethod静态方法

  • 一定于把这么些符号下的章程断开和类的接连,和类没什么关系
  • 调用时间接class_name.func_name,能够不要实例化
  • 和类的绝无仅有涉嫌是调用时必须采取类名作为前缀,名义上归类管
  • self参数不须要

方法

@classmethod类方法

  • 类格局只可以访问类变量,不可能访问实例变量
    “`python
    class A(object):
    name = ‘alex’
    def __init_(self):
    self.name = ‘wusir’

    @classmethod
    def test(self):
    print(self.name)

a=A()
a.test()
结果:alex
“`

  • 因而类方法一般用来禁止访问类的村办属性(实例化后的变量)
  • 当类的公有属性名和村办属性名相同时,类情势只可以访问类的公有属性(类级变量)

常见方法

在类的定义中,以self作为作为第二个参数的主意都以实例方法。实例方法的第六个参数是self,当那一个办法被调用时,Python会把调用该方式的靶子作为self参数字传送入

  • 概念普通方法

class func_obj:
    def bar(self):
        print('bar func')
  • 调用普通方法
    • 由对象调用

obj = func_obj()
obj.bar()

* 由类调用

由类调用时必要传入对象self

obj = func_obj()
# obj.bar()
func_obj.bar(obj)

@property属性方法

  • 把二个类的艺术成为2个静态属性

    class A(object):

    def __init__(self):
        self.name = 'alex'
    
    @property
    def eat(self):
        print('%s is eating...'%self.name)
    

    a = A()
    a.eat#无法加括号调用

  • 带参数的样式

    class A(object):

    def __init__(self):
        self.name = 'alex'
    
    @property
    def eat(self,food):
        print('%s is eating %s'%(self.name,food))
    
    @eat.setter
    def eat(self,food):
        print('set to food:',food)
    
a = A()
a.eat = 'baozi'
  • 能够将设置的参数用一个民用属性保存下去

  • 属性方法暗中认可不能像一般属性一样删除,能够用删除存款和储蓄的私有属性来做二个去除

    @eat.deleter
    def eat(self):
        del self.__food
    

好吧,把三个办法成为静态属性有啥样卵用呢?既然想要静态变量,这直接定义成二个静态变量不就得了么?well,
以后你会需到很多现象是无法简单通过 定义 静态属性来落到实处的, 比如
,你想了然三个航班当前的情状,是到达了、延迟了、撤销了、依然一度飞走了,
想知道那种状态你不能够不经历以下几步:

  1. 接连航空集团API查询

  2. 对查询结果进行剖析

  3. 重返结果给你的用户

故而那几个status属性的值是一比比皆是动作后才获得的结果,所以你每一次调用时,其实它都要因而一文山会海的动作才再次回到您结果,但这么些动作进程不必要用户关注,
用户只必要调用这特性情就足以,精通 了么?

class Flight(object):

    def __init__(self,name):

        self.flight_name = name





    def checking_status(self):

        print("checking flight %s status " % self.flight_name)

        return  1



    @property

    def flight_status(self):

        status = self.checking_status()

        if status == 0 :

            print("flight got canceled...")

        elif status == 1 :

            print("flight is arrived...")

        elif status == 2:

            print("flight has departured already...")

        else:

            print("cannot confirm the flight status...,please check later")





f = Flight("CA980")

f.flight_status



航班查询

静态方法

  • 静态方法的定义
    并发在类中既不会潜移默化类也不会影响类的靶子。那体系型的格局被称之为静态方法。静态方法用@staticmethod修饰,当方法被@staticmethod修饰时,方法中的self参数就不是必须的。

class staticdemo():
    @staticmethod
    def show():
        print("it's staticdemo")
staticdemo.show()
  • 静态方法的调用
    静态方法能够应用类名调用

func_obj.static_bar()

类的奇异成员方法

类方法

  • 类措施的概念
    类方法会成效于任何类,在类定义内部,用前缀修饰符@classmethod钦定的法门都以类措施,类措施的首先个参数是类自己。在Python中,这几个参数常被协写作cls,class为保留字不可能利用。

class A():
    count = 0
    @classmethod
    def kids(cls):
        print("Class A is call" + str(cls.count))
  • 类措施的调用
    类措施是效果域整个类的点子,能够接纳类调用

func_obj.class_bar()

__doc__ 表示类的讲述音信

class Foo:
    """ 描述类信息,这是用于看片的神奇 """

    def func(self):
        pass

print Foo.__doc__
#输出:类的描述信息

属性

质量定义时和方式类似,能够有参数能够有再次来到值,调用时和字段类似,可以使得方法的调用和做客字段同等服从,某种意义上可以简化代码结构

  • 质量的概念

    '''定义属性'''
    @property
    def propert(self):
        print('propert')
        return 111;
  • 属性的调用

obj = func_obj()
print(obj.propert)

采纳属性模拟四个简单易行分页的栗子

class pageinfo:
    def __init__(self, current_page):
        self.page = int(current_page)

    @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('请输入要查看的页码')
    obj = pageinfo(p)
    print(li[obj.start:obj.end])

__module____class__

  • __module__ 表示近期操作的对象在很是模块
  • __class__ 表示近来操作的对象的类是怎样

    class C:

    def init(self): 
    
    self.name = 'wupeiqi'
    

    #—————————-
    from lib.aa import C
    obj = C()
    print obj.module # 输出 lib.aa,即:输出模块
    print obj.class # 输出 lib.aa.C,即:输出类

重写父类的不二法门

对此父类的法子,只要它不符合子类模拟的东西的作为,都足以对其重写。
在car类中大家定义了3个重返该车拥有者的措施
get_car_woner,可是每辆车的拥有者是不同的,所以我们能够运用子类重写父类的方法

class ElectricCar(Car):
    def __init__(self, name, year, price):
        super().__init__(name, year, price)
        self.battery = 70
    def get_currentbattery(self):
        print('current barrery is' + str(self.battery))
    def get_car_woner(self):
        print('this is tesla')
my_tesla = ElectricCar('buggadi', 1, 200000)
'''调用重写后的父类的方法'''
my_tesla.get_car_woner()

__call__对象后边加括号,触发执行

class Foo:

    def __init__(self):
        pass
    def __call__(self, *args, **kwargs):
        print '__call__'

obj = Foo() # 执行 __init__
obj()       # 执行 __call__

Python中的 metaclass 超类对象

  • Python中全体事物都是目的
  • Python中的类也是一个对象,是Type类的靶子。Python在编写翻译器编写翻译class的时候也会被编写翻译为贰个指标

print(type(SpeciaIter))
>>> <class 'type'>

__str__ 即使3个类中定义了__str__办法,那么在打字与印刷 对象 时,私下认可输出该方法的再次回到值

class Foo:

    def __str__(self):
        return 'alex li'


obj = Foo()
print obj
# 输出:alex li

metaclass

  • mateclass能够钦点自定义的Type类,由自定义的Type类来创制类

咱俩早就清楚,Python中的类都以Type类的目的,也正是说Python中的类都是由Type成立的,那么只要大家分甘共苦创办3个类继承Type
那么这些类也得以拓展创办类。

class MyTpe(type):
    def __init__(self,*args,**kwargs):
        print(123)
class Foo(object, metaclass=MyTpe):
    def __init__(self):
        pass
f = Foo()
>>> 123
  • 创建对象的流水生产线
![](https://upload-images.jianshu.io/upload_images/6052465-cde0b9901c594ce3.png)

创建过程.png

__getitem____setitem____delitem__

用于索引操作,如字典。以上分别代表收获、设置、删除数据

class Foo(object):

    def __getitem__(self, key):
        print('__getitem__',key)

    def __setitem__(self, key, value):
        print('__setitem__',key,value)

    def __delitem__(self, key):
        print('__delitem__',key)

 obj = Foo()

result = obj['k1']      # 自动触发执行 __getitem__
obj['k2'] = 'alex'   # 自动触发执行 __setitem__
del obj['k1']  

取名元组

命名元组时元组的子类,既能够因此名称(使用.name)来走访个中的值,也足以通过岗位进行走访(使用[offset])

__new__详解:

参考文书档案

将三个类的实例用作另一个类的性质

在我们采用代码模拟实物时,可以打包一些类的性质细节,大家得以将类的一某些作为二个单独的类提取出来,那样大家得以将重型类拆分成多个体协会同工作的小类。
譬如上述的demo中,对于电轻轨,有许多针对于小车电瓶的属性和艺术,我们能够成立3个Battery的类,来描述那一个类的性质。并将Battery的实例用作ElectricCar类的3个属性

class Battery():
    def __init__(self, size=70):
        '''初始化电池容量'''
        self.size = size

    def get_battery_size(self):
        print('当前电池容量' + str(self.size))
  • 在调用ElectricCar的Battery属性

my_tesla = ElectricCar('buggadi', 1, 200000)
my_tesla.battery.get_battery_size()

Python会在实例my_tesla中找寻属性battery,并对存款和储蓄在该属性中的Battery实例调用get_battery_size()方法

导入类

小编们得以将类封装成模块,在别的类中选拔,那样就须要动用导入类的职能

导入单个类

from part2.classdemo.car import Car

import会让Python打开模块car并导入其中的Car类

  • 在八个模块中蕴藏四个类
  • 从三个模块导入四个类
    可遵照供给在先后文件中程导弹入任意数量的类。从二个模块中程导弹入五个类时,用逗号分隔导入的个种种。导入须求的类后,就能够依照须求成立每一种类的肆意数量的实例

from part2.classdemo.car import Car, ElectricCar
  • 导入整个模块
    笔者们还足以导入整个模块,再用句点表示法访问须求的类

import car
  • 导入模块中的全数类

from module_name import *

类编码风格

  • 类名应选拔驼峰命名法,将类名中的每种单词的首字母都大写,而不使用下划线。实例名和下划线都应用小写格式,并在单词之间加下划线
  • 对于种种类,都应紧跟在类定义前面包罗三个文书档案字符串,那么些字符串要不难的叙述类的意义
  • 在类中可使用三个空行来分隔方法,在模块中,使用八个空行来分隔类
  • 早先入标准库,再导入自身编辑的模块

使用品质对特色开始展览走访和安装

有一部分面向对象的言语帮忙个体性格。这几个特色不也许从指标外部直接访问。要求编写制定getter和setter
python不必要getter和setter方法,Python中享有天性都以精通的。假如急需一贯访问对象的表征,能够为对象编排setter和getter方法。不过正如好的措施时行使质量property
举个例子,我们定义一个Duck类,仅包括3个hidden_name本性,大家不希望外人直接待上访问这脾特性,因而必要定义两个章程
getter和setter方法。

class duck():
    def __init__(self, inputname):
        self.hiddenname = inputname

    '''getter & setter'''


    def get_name(self):
        print('get_name')
        return self.hiddenname

    def set_name(self, name):
        print('set_name')
        self.hiddenname = name

    name = property(get_name, set_name)

在最终一行中,大家选拔property()方法将get_name和set_name定义为了name属性。当尝试访问duck类对象的name特性时,get_name()会被电动调用:

test = duck('test123')
print(test.name)
>>> get_name
>>> test123

显式调用get_name()方法:

test = duck('test123')
print(test.get_name())
  • 还是能够运用修饰符
    • @property 用于提示 getter方法
    • @function.setter 用于提醒setter方法

    @property
    def get_name(self):
        print('get_name')
        return self.hiddenname

    @get_name.setter
    def set_name(self, name):
        print('set_name')
        self.hiddenname = name
  • 调用get方法

test = duck('test123')
print(test.get_name)
  • 调用setter方法

test = duck('test123')
test.set_name = '123test'
print(test.get_name)

利用名称重新整建爱戴个体个性

在后面包车型大巴Duck例子中,假使直白访问hidden_name依旧得以见见相应属性的值。Python对那三个须求可以隐藏在类内部的特点有友好的命名规范:由连接的八个下划线开端(__)

 def __init__(self, inputname):
        self.__hiddenname = inputname

    '''getter & setter'''

    @property
    def get_name(self):
        print('get_name')
        return self.__hiddenname

    @get_name.setter
    def set_name(self, name):
        print('set_name')
        self.__hiddenname = name

如此那般大家就十分小概在外表访问__name特性了
那种命名规范本质上并不曾把特色变成私有。Python其实是将它的名字重新整建了,让外部的代码无法利用


相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图