澳门新萄京:python2和3中关于类世袭的,面向对象
分类:www.澳门新萄京赌场

下面举一个例子,同样的代码使用 python2 和 python3 写的,大家注意两段程序中红色加粗的部分:

@(python)

python 同时支持面向对象编程和函数式编程的语言
python面向对象的主题围绕 澳门新萄京:python2和3中关于类世袭的,面向对象的编制程序。类实例 两个主题。
面向对象三大特性:封装继承多态

      在面向对象的语言中,除了方法、对象,剩下的一大重点就是类了,从意义上来讲,类就是对具有相同行为对象的归纳。当一个或多个对象有相同属性、方法等共同特征的时候,我们就可以把它归纳到同一个类当中。在使用上来讲,类的存在,就是为了方便管理对象。python中定义一个类的代码如下:

python2的类继承使用super方法:

super(type, obj)

子类中定义了同父类同名的函数后,需要显示调用父类函数时,可以通过 super,也可以直接通过父类名,建议使用 super,比如在初始化函数中调用父类初始化方法,尤其在多重继承的情况下
看看例子:

#!/usr/bin/env python
# coding=utf-8

class A:
    def __init__(self):
        print("Enter A")
        super(A, self).__init__()
        print("Leave A")

class B:
    def __init__(self):
        print("Enter B")
        #super(B, self).__init__()
        print("Leave B")

class CA(A):
    def __init__(self):
        print("Enter CA")
        super(CA,self).__init__()
        print("Leave CA")


class CAA(CA, A):
    def __init__(self):
        print("Enter CAA")
        super(CAA,self).__init__()
        print("Leave CAA")

class CB(B):
    def __init__(self):
        print("Enter CB")
        B.__init__(self)
        print("Leave CB")


class CBB(CB, B):
    def __init__(self):
        print("Enter CBB")
        CB.__init__(self)
        B.__init__(self)
        print("Leave CBB")


if __name__ == "__main__":
    print("- New Object CAA")
    caa = CAA()
    print("- New Object CBB")
    cbb = CBB()

上述列子中,两组类关系:
CAA->CA->A 采用 super 调用父类函数
CBB->CB->B 直接通过父类名调用其行数

对比运行结果

lcd@ubuntu:~/learn/python$ python3 supper_class.py 
- New Object CAA
Enter CAA
Enter CA
Enter A
Leave A
Leave CA
Leave CAA
- New Object CBB
Enter CBB
Enter CB
Enter B   
Leave B
Leave CB
Enter B   -->重复调用了
Leave B
Leave CBB

可以看到,使用super, python 不止保证继承时按顺序调用父类初始化,而且保证每一个类不被重复调用。

概念

1.对象:类的实例。对象具有两个特征:状态与行为。
2.类:用来描述具有相同的属性和方法的对象的集合,类的组成=方法 行为
3.抽象:对现实世界问题和实体的本质表现,行为和特征建模,建立一个相关的子集,可以用于描述程序结构,从而实现这种模型。
4.封装:对属性和方法的载体类,只能通过其提供的接口(方法)来访问,而把实现细节隐藏起来.python的类属性都是公开的。
5.继承:描述了子类属性从祖先类继承这样一种方式。
6.多态:同一消息可以根据发送对象的不同而采用多种不同的行为方式。

class Simple_class(object):
#定义一个名为Simple_class的类,python3以后默认object做为类的基类,这里不讨论新式和旧式类的区别
    height = 1.58#定义一个类变量
    def __init__(self,name,age,):#重写类的初始化,
#使其在初始化的时候需要传入name,age两个参数。self为类方法的默认参数
        self.name = name #定义两个对象变量
        self.age = age
    def Print_details(self):#定义一个名为Print_details的对象方法
        print("Print_details方法调用:name is %s,age is %d"%(self.name,self.age))
print("未初始化访问类变量:height = ",Simple_class.height)# 访问类变量
try:
    print(Simple_class.name) #访问实例变量 因为会报错,为了程序代码执行 给了一个异常处理
except AttributeError as error:
    print("未初始化之前访问实例变量的异常信息:",error)
obj = Simple_class("object",115) #生成一个类的实例对象
obj.height = 1.88
print("初始化之后赋值给实例的类变量 height = ",obj.height)
print("初始化之后的原始类变量:height = ",Simple_class.height)
print("初始化之后访问实例变量:name is ",obj.name)#访问实例变量
obj.Print_details()#调用对象方法
# /////输出结果如下 ///////
/Library/Frameworks/Python.framework/Versions/3.5/bin/python3.5 /Users/penglong/Documents/python/s10/day4/blog.py
未初始化访问类变量:height =  1.58
未初始化之前访问实例变量的异常信息: type object 'Simple_class' has no attribute 'name'
初始化之后赋值给实例的类变量 height =  1.88
初始化之后的原始类变量:height =  1.58
初始化之后访问实例变量:name is  object
Print_details方法调用:name is object,age is 115
 1 #-*-  coding:utf-8 -*-
 2 '''
 3 Created on 2018年8月27日
 4 
 5 @author: anyd
 6 '''
 7 import random as r
 8 
 9 class Fish(object):
10     def __init__(self):
11         self.x = r.randint(0, 10)
12         self.y = r.randint(0, 10)
13             
14     def move(self):
15         #这里主要演示类的继承机制,就不考虑检查场景边界和移动方向的问题
16         #假设所有鱼都是一路向西游
17         self.x -= 1
18         print "我的位置是:", self.x, self.y
19 
20 class Goldfish(Fish):
21     pass
22 
23 class Carp(Fish):
24     pass
25 
26 class Salmon(Fish):
27     pass
28 
29 #上边几个都是食物,食物不需要有个性,所以直接继承Fish类的全部属性和方法即可
30 #下边定义鲨鱼类,这个是吃货,除了继承Fish类的属性和方法,还要添加一个吃的方法
31 
32 class Shark(Fish):
33     def __init__(self):
34         super(Shark,self).__init__()       
35         self.hungry = True
36 
37     def eat(self):
38         if self.hungry:
39             print "吃货的梦想就是天天有的吃^_^"
40             self.hungry = False
41         else:
42             print "太撑了,吃不下了!"
43             
44 aa = Shark()
45 aa.move()

classsmethod

python 有三种方式定义类方法:
如下面例子类 A 定义的三个方法,

  • 常规方式定义了 foo,同对象实例绑定,通过对象调用的时候,会通过隐式 self 参数传递类对象实例子;如果直接通过类调用,需要显示传递类实例;
  • @classmethod 方式定义了 class_foo 方法,同类绑定,可以直接通过类名可以直接调用,调用时通过 cls 隐式参数传递类对象。
  • @staticmethod 方式定义的方法和普通函数一样,没有绑定对象,没有传递隐式参,可以通过类实例或者类调用。(属于类的函数,但是不需要访问类,通过后续子类覆盖,更好地组织代码)
#!/usr/bin/env python
# coding=utf-8
# by orientlu

class A(object):
    def __init__(self):
        print("A init")
        super().__init__()

    def foo(self, x):
        '''绑定对象'''
        print("A exec foo (%s, %d)" %(self, x))

    @classmethod
    def class_foo(cls, x):
        '''绑定类'''
        print("exec class_foo (%s, %d)" %(cls, x))

    @staticmethod
    def static_foo(x):
        '''没有绑定类,对象'''
        print("exec static_foo (%d)" %(x))

class B(object):
    def foo(self, x):
        '''绑定对象'''
        print("exec foo (%s, %d)" %(self, x))

    @classmethod
    def test_class_foo(cls, x):
        '''绑定类'''
        print("exec test_class_foo -2- (%s, %d)" %(cls, x))

    def test_class_foo(self, x):
        '''后面方法覆盖前面的同名方法'''
        print("exec test_class_foo -1- (%s, %d)" %(self, x))


class AA(A):
    def __init__(self):
        print("AA Int")

    def foo(self, x):
        '''覆盖了父类函数'''
        print("AA exec foo (%s, %d)" %(self, x))


class C(AA):
    def __init__(self):
        '''子类定义了方法覆盖了父类,通过super调用到父类函数'''
        super().__init__()
        print("C init")

    def c_fun1(self):
        '''子类没有定义的函数,直接调用父类函数'''
        self.foo(1)

if __name__ == "__main__":

    print("***********************************")
    print("-------")
    a = A()
    a.foo(1)
    a.class_foo(1)
    a.static_foo(1)

    print("-------")
    A.foo(a, 1)
    A.class_foo(1)
    A.static_foo(1)

    print("***********************************")
    b = B()
    b.test_class_foo(1)
    # 以下调用出错,因为classmethod被后面的函数所覆盖了
    #B.test_class_foo(1)
    # 实际存在是后面定义的函数
    B.test_class_foo(b, 1)

    print("***********************************")
    c = C()
    c.c_fun1()

上述代码在 python3 环境下运行的输出 :

***********************************
-------
A init
A exec foo (<__main__.A object at 0x7f6af4c36ac8>, 1)
exec class_foo (<class '__main__.A'>, 1)
exec static_foo (1)
-------
A exec foo (<__main__.A object at 0x7f6af4c36ac8>, 1)
exec class_foo (<class '__main__.A'>, 1)
exec static_foo (1)
***********************************
exec test_class_foo -1- (<__main__.B object at 0x7f6af4c36b38>, 1)
exec test_class_foo -1- (<__main__.B object at 0x7f6af4c36b38>, 1)
***********************************
AA Int
C init
AA exec foo (<__main__.C object at 0x7f6af4c36b70>, 1)
创建类

python 类是使用class关键词来创建,即关键词 类名

class ClassName():
    class_suit 
  • 澳门新萄京:python2和3中关于类世袭的,面向对象的编制程序。class_suit(类实体由类成员、方法、数据属性组成)
  • 类中的函数第一个参数必须是self,
  • 类分为经典类和新式类(如果 当前类或者父类继承了object类,那么该类便是新式类,否则便是经典类。以后慢慢推荐用新式类写)
![](https://upload-images.jianshu.io/upload_images/994436-2e4347e91097c500.png)

QQ20170709-223954@2x.png

  

输出如下:

类的成员、成员修饰符、类的特殊成员

澳门新萄京 1

Paste_Image.png

class Province:
    country = '中国'                     # 静态字段
    def __init__(self, name):
        self.name = name                 # 普通字段

obj = Province('河北省')                 # 直接访问普通字段
print obj.name
Province.country                        # 直接访问静态字段

澳门新萄京 2

Paste_Image.png

由上图可是:
静态字段在内存中只保存一份
普通字段在每个对象中都要保存一份
应用场景: 通过类创建对象时,如果每个对象都具有相同的字段,那么就使用静态字段

方法:普通方法、静态方法和类方法,三种方法在内存中都归属于类,区别在于调用方式不同。

class E():
    i=1
    def run(self):
         E.i  =1
         print('{0} is run ordinary method'.format(E.i))
    @staticmethod
    def eat():
        E.i  =1
        print('{0} is eat static method'.format(E.i))
    @classmethod
    def fool(cls):
        E.i  =1
        print('{0} is fool class method '.format(E.i))

e = E()
e.run()
E.eat()
E.fool()

输出

2 is run ordinary method
3 is eat static method
4 is fool class method 

属性:相当一个bean里面的方法,做比较好的封装一层,创建属性有2中方式,一种是修饰器,一种是静态字段,装饰器方式针对经典类和新式类又有所不同,下面例子针对新式类(图中-今天方式创建 改为 静态方式创建)

澳门新萄京 3

Paste_Image.png

  以上,我们定义了一个类,类中包括一个重写的初始化方法,一个普通类方法。一个类变量,两个实例变量。从输出内容上我们来分析一下类变量和实例变量的区别,在实例化对象之前,是可以直接访问类变量并且取出赋值给别的变量,而实例变量则是在实例化之后,只能通过实例对象访问的变量,如果在有具体的实例对象之前直接通过类去访问,则程序会报错。这是二者的区别。从使用意义上来讲,个人认为,类变量更像是实例的默认变量,他是每一个实例对象带有的默认变量且有值,这个值在实例化对象之后可以进行修改,不影响其他实例对象。而实例变量则是各个实例的特有变量,必须要进行赋值之后才能使用。再说初始化方法和我们定义的方法,初始化方法属于类方法,可以直接调用。而对象方法需要通过实例调用。

我的位置是: 8 2
self

引用地址:http://m.blog.csdn.net/happyjxt/article/details/50760467

澳门新萄京 4

QQ20170709-223954@2x.png

class Foo:
    def __init__(self, name, age):
        self.name = name
        self.age = age  
    def detail(self):
        print self.name
        print self.age  
obj1 = Foo('wupeiqi', 18)
obj1.detail()  # Python默认会将obj1传给self参数,即:obj1.detail(obj1),所以,此时方法内部的 self = obj1,即:self.name 是 wupeiqi ;self.age 是 18
obj2 = Foo('alex', 73)
obj2.detail()  # Python默认会将obj2传给self参数,即:obj1.detail(obj2),所以,此时方法内部的 self = obj2,即:self.name 是 alex ; self.age 是 78

      在上一段代码中有一个关于基类的概念,实际上也就是继承。在编写代码的时候,我们想对一个类进行一些额外的扩充,而又不影响它本身的状态,那就可以写一个子类来满足,这里先从单重继承说起,代码如下:

  

继承

· python是支持多继承的语言
· python主要继承的多个类时,寻找的继承的方法主要2种,分别是:深度优先广度优先
1、当类是经典类时,多继承情况下,会按照深度优先方式查找
2、当类是新式类时,多继承情况下,会按照广度优先方式查找

澳门新萄京 5

澳门新萄京,QQ20170709-223954@2x.png

eg1、

class A():
    def __init__(self):
        print('A start')
        print('A level')
class B(A):
    def __init__(self):
        print('B start')
        print('B level')
class C(A):
    def __init__(self):
        print('C start')
        print('C level')
class D(B,C):
    def __init__(self):
        print('D start')
        print('D level')
d=D();

以上程序输入

D start
D level

假设把D类改造如下,其他没有变化:

class D(B,C):
    pass

程序输入

B start
B level

原因:程序首先在D类寻找init方法,程序发现没有该方法后则寻找第一个父类的init的方法。

class father_class(object):
 #定义一个名为father_class的类,他既是子类的父类,又是子类的子类的基类
    name  = "父类" #定义一个类变量
    def log(self):
#定义一个log方法 输出类名,这里不用self.__class取,是为了在子类调用时self会指向子类自身,不方便日志分辨。
        print("father_class")
    def public_func(self):#定义一个public_func方法,输出此方法是否被子类修改过
        print("未修改")
class son_class(father_class): #定义一个子类,直接继承父类
    son_name = "子类"#定义一个类变量
    def son_log(self): #定义自身的log
        print("son_class")
    def public_func(self):#修改父类提供的公共方法
        print("子类修改父类方法")
class grandson_class(son_class):
#定义一个名为grandson_class的类继承自son_class由于son_calss也是别人的子类
#所以son_class的父类是本类的基类
    grandson_name = "子类的子类"
    def grandson_log(self):#定义自身log
        print("grandson_class")
    def public_func(self):#对基类方法进行修改
        print("子类修改基类方法")
########父类的实例对象##########
father = father_class() #生成一个父类的实例对象
name = father.name
#获取类变量的值并打印,类变量本身不用实例化也可以获取,但下文需要实例调用方法,所以就先生成了
print("父类访问自身类变量:",name)
father.log()#父类调用自身的方法
father.public_func()
#######子类的实例对象###########
son = son_class()#实例化一个子类对象
name = son.name #子类去获取父类的类变量并这打印。输出结果无误,说明子类可以继承父类所有的类变量。
#同理也可以继承父类所有实例变量,代码未举例,但原理一样
print("子类访问父类变量:",name)
son.log()#子类调用父类的方法,输出结果无误,说明子类可以继承父类所有的方法
name = son.son_name#子类访问自身类变量的值并打印,结果无误,说明子类可以增加类变量
print("子类访问自己的类变量:",name)#
son.son_log()#子类调用自己的log方法,说明子类可以扩充自己的方法
son.public_func()#子类调用父类的方法,但输出结果不同 ,因为我们在子类中进行过修改,说明子类可以修改父类方法
#########子类的子类的实例对象
grandson = grandson_class()#生成一个子类的子类的实例对象
name = grandson.name#子类直接去访问父类的父类的类变量并打印,
#结果无误,说明,我们除了继承父类的变量,还继承所有父类的父类,链条式。
print("子类访问基类变量:",name)
grandson.log()#子类调用父类的父类的方法,同理可得,子类也继承父类的父类的所有方法
grandson.public_func()#子类可以直接修改父类的父类也就是基类的方法
########输出结果如下###############
父类访问自身类变量: 父类
father_class
未修改
子类访问父类变量: 父类
father_class
子类访问自己的类变量: 子类
son_class
子类修改父类方法
子类访问基类变量: 父类
father_class
子类修改基类方法

python3的类继承使用super方法:

经典类寻找

再次把B类改造如下,其他的没有变化

class B(A):
   pass

程序输入

A start
A  level

原因:查找顺序:D --> B --> A --> C

    以上代码是一个简单的单继承概括,从代码中,可以看到,当一个类继承自另一个类,那么它将拥有父类的一切数据,包括父类变量,父类的实例变量,以及父类方法,这个方法包括类方法和实例方法。同时,子类的作用就是对父类的扩充,也就是说它可以对父类的所有数据增加、更改。python是一个多继承语言,有时候我们想同时拥有两个类的方法,那直接继承两个类就可以。简单构造代码如下:

 1 #-*-  coding:utf-8 -*-
 2 '''
 3 Created on 2018年8月27日
 4 
 5 @author: anyd
 6 '''
 7 import random as r
 8 
 9 class Fish(object):
10     def __init__(self):
11         self.x = r.randint(0, 10)
12         self.y = r.randint(0, 10)
13             
14     def move(self):
15         #这里主要演示类的继承机制,就不考虑检查场景边界和移动方向的问题
16         #假设所有鱼都是一路向西游
17         self.x -= 1
18         print ("我的位置是:", self.x, self.y)
19 
20 class Goldfish(Fish):
21     pass
22 
23 class Carp(Fish):
24     pass
25 
26 class Salmon(Fish):
27     pass
28 
29 #上边几个都是食物,食物不需要有个性,所以直接继承Fish类的全部属性和方法即可
30 #下边定义鲨鱼类,这个是吃货,除了继承Fish类的属性和方法,还要添加一个吃的方法
31 
32 class Shark(Fish):
33     def __init__(self):
34         super().__init__()       
35         self.hungry = True
36 
37     def eat(self):
38         if self.hungry:
39             print ("吃货的梦想就是天天有的吃^_^")
40             self.hungry = False
41         else:
42             print ("太撑了,吃不下了!")
43             
44 aa = Shark()
45 aa.move()
新式类寻找

再次把A类改造成新式类,其他没有变化

class A(object):
    def __init__(self):
        print('A start')
        print('A level')

程序输入

C start
C  level

原因:查找顺序:D --> B --> C --> A
备注:python3.0后多继承来讲,类都是新式类,所以继承顺序统一是广式优先进行 

对于父类和子类重名时,又想使用父类的名字,这时可以使用关键词super-只适合用于新式类
'''
class C(B):
def meth(self, arg):
super(C, self).meth(arg)
'''
1、super只能用于新式类
2、super不是父类,而是继承顺序的下一个类
3、 Python的多继承类是通过mro的方式来保证各个父类的函数被逐一调用,而且保证每个父类函数
只调用一次(如果每个类都使用super)

class A(object):
    def __init__(self):
        print('A start')
        print('A level')
class B(A):
    def __init__(self):
        print('B start')
        print('B level')
        super(B, self).__init__()
class C(A):
    def __init__(self):
        print('C start')
        print('C level')
        super(C, self).__init__()
class D(C,B):
    def __init__(self):
        print('D start')
        print('D level')
        super(D, self).__init__()
d=D();

输出结果

D start
D level
C start
C level
B start
B level
A start
A level

原因:新式类的寻找顺序是D --> B --> C --> A,那么程序执行D类的init方法中触发super关键词,D的继承关系中的下一个类是B,那么把super.init转化为B.init执行。在执行过程中触发了super关键词,D的继承关系中B的下一个类是C,那么super.init转化为C.init执行

class A(object):
    def a(self):
        pass
class B(object):
    def b(self):
        pass
class C(A,B):
    pass
c_test = C()
c_test.a()
c_test.b()

输出如下:

封装

封装:你钱包的有多少钱
封装主要的原因:保护隐私隔离复杂度
在python中用双下划线的方式实现隐藏属性,还有用property方式

每一个类的成员而言都有两种形式,
1、公有成员,在任何地方都能访问,类内部可以访问;派生类中可以访问
2、私有成员,只有在类的内部才能方法
私有成员命名时,前两个字符是下划线。(特殊成员除外,例如:initcalldict等)

class C:
    def __init__(self):
        self.name = '公有字段'
        self.__foo = "私有字段"

备注:本文由部分引用。此文章只是用来学习

  从上面代码中可以看出,C类继承自A,B两个类,所以它既可以调用A的方法,又可以调用B的方法。(ios只能通过协议实现。。差评!!!),多继承的特性和单继承差不多是一样的,但值得注意的是,多继承会涉及到方法重复。那么,这里衍生出一个问题。普通继承与super继承。首先来看一段代码:

我的位置是: 7 4
class A(object):#这么简单的代码。。我就不解释了
    def __init__(self):
        print("A")
class B(object):
    def __init__(self):
        print("B")
class C(A):
    def __init__(self):
        print("C")
        A.__init__(self)
class D(A):
    def __init__(self):
        print("D")
        A.__init__(self)
class E(B,C):
    def __init__(self):
        print("E")
        B.__init__(self)
        C.__init__(self)
class F(D,E):
    def __init__(self):
        print("F")
        E.__init__(self)
        D.__init__(self)
a = E()
print("---------")
b = F()
######看一下输出记录,为了省地儿,我合成了两行行########
# 初始化E类得到的输出结果 E B C A
#---------
# 初始化F类得到的输出结果 F E B C A D A

  

    分析一下上面的代码,A,B都直接继承于基类,分别有自己的初始化方法,在初始化的时候输出自己的类名。C,D皆继承自A,改写它们的初始化方法,使其在初始化的时候不仅输出自己类名,同时调用一下自己父类的初始化方法即同时输出自己的父类名.E,F两个类为多重继承。来查看一下初始化E类的结果,没有异常,它初始化了自己,也调用了父类的初始化方法,同时调用了父类的父类的初始化方法。再看一下F类的初始化结果。问题来了。它输出了两个A。由此可以分析出。它调用了两次A类的初始化方法,这是代码中极为不愿意看到的。让我们来分析一下代码,看这个问题是如何出现的。首先F继承自D,E两个类。而D继承自A,E继承自B,C。再往上分析,B继承自基类。而C继承自A。问题在这,每继承一个类,我们都对其进行了初始化方法调用。也就是说在F中我们调用了两次A的初始化方法,所以输出了两次。在实际运用中,我们也会遇到这个问题。那就是在多重继承中,常常由于类的关系复杂而使某些父类方法被其子类或者其子类的子类或者在子类重复调用。所以,我们要用到一个关键字super来解决这个问题,代码如下:

super方法具体使用注意事项可以参考官方的指导文档,里面有详细的使用例子,但个人觉得这种super方法不太容易让人看得舒服,个人比较偏好采用未绑定的方法来写,这样就不管是python2 还是 python3,都是没有问题的。如下:

class A(object):#代码都差不多。。这个也不解释了。。
    def __init__(self):
        print("A")
        super(A,self).__init__()
class B(object):
    def __init__(self):
        print("B")
        super(B, self).__init__()
class C(A):
    def __init__(self):
        print("C")
        super(C, self).__init__()
class D(A):
    def __init__(self):
        print("D")
        super(D, self).__init__()
class E(B,C):
    def __init__(self):
        print("E")
        super(E, self).__init__()
class F(D,E):
    def __init__(self):
        print("F")
        super(F, self).__init__()
a = E()
print("---------")
b = F()
######看一下输出记录,为了省地儿,我合成了两行行########
# 初始化E类得到的输出结果 E B C A
#---------
# 初始化F类得到的输出结果 F D E B C A
1 class Shark(Fish):
2     def __init__(self):
3         Fish.__init__(self)     
4         self.hungry = True

  如上,对比一下两份代码,不难看出super的作用,首先它自动查找父类的初始化方法并调用,同时保证只被调用一次,而且严格按照类继承路线走,关于最后一点可以对比一下两次代码的输出顺序,这个顺序涉及到python的多继承顺序算法,别管它了。除了初始化方法,对于其他方法,super也有同样的作用,需要注意的是,super只针对新式类。在单继承中,super大概被用于偷懒扩充父类构造方法。但是!混用super类和普通继承类比较危险,所以单继承个人很少使用。

 

    以上,继承的问题基本谈完,最后说一下装饰器在类方法中的使用代码如下:

class test(object):#定义一个类。。不要管名字了
    name = "test"#类变量
    def __init__(self,age):#初始方法,传个参数
        self.age = age#定义一个实例变量,把传进来的参数直接赋值给它
    def say(self):# 未加装饰器的普通方法,输出个test,ps:只能实例化之后通过实例调用
        print("test")
    @staticmethod#加装饰器@staticmethod之后的方法,
   #即静态方法 不无需实例化调用 ,无法传参数。当一个类只有静态方法的时候,从意义上讲就单纯是一个类的工具包
    def say2():
        print("say hi 2") 
    @classmethod
   # 类方法 ,不需要实例化即可调用,可以使用类参数,无法使用实例参数,这里没有传个参数做例子。。抱歉
    def say3(self):
        print("say hi 3")。
    @property #加@property的方法
   #可以返回数据,使用意义上来讲,就是把经过类方法处理后的数据传递出去
    def say4(self):
         # print("this is 4")
         return  "test"

  以上是python中类的一些简单注意事项,做为面向对象的一大重点,类这一概念还有很多值得深究的东西。例如参数类型等等,这些都需要自己去慢慢探究。

本文由澳门新萄京发布于www.澳门新萄京赌场,转载请注明出处:澳门新萄京:python2和3中关于类世袭的,面向对象

上一篇:Tornado简单聊天室,原理探究 下一篇:没有了
猜你喜欢
热门排行
精彩图文