python之对象与类

1.类的定义

类是一个用户定义类型，类似与c语言中的结构体

class <ClassName>:
    "类的帮助信息"#类文档字符串
class_suite #类体

其中ClassName 是类的名字；类的信息可以通过ClassName.__doc__查看；class_suite由类成员，方法，数据属性组成

代码实例：

class number:
    "这是一个数字"
    number1  = 0
    def display(self):
        number.number1 += 1
        print(number.number1)

代码分析：

1.number1是一个类变量，它的值将在这个类中的所有实例共享

2.self代表类的实例，虽然它在调用时不用传入相应的参数，但在定义类的方法时是必须要有的

3.display（self）是此类的方法，属于方法对象

2.类的构造方法和内置属性

所谓构造方法，是指创建对象时其本身所运行的函数。Python使用__init_()函数作为对象的函数的构造方法。当用户要在对象内指向对象本身时，可以使用self关键字。Python中的self想当于c++中this关键字，都是代表对象本身。

创建类的构造方法实例：

class fruit:
    #定义基本属性
name = ""
city = ""
#定义私有属性
__price = 0
#定义构造方法
def __init__(self,n,c,p):
    self.name  = n
    self.city = c
    self.price = p
def display(self):
    print("%s%s%s" % (self.name,self.city,self.price))
#实例化类
f = fruit("1","2",,3)
f.display(

def __init__()函数定义类的构造方法，self是必须的参数，且必须为第一个参数

类实例

类实例是一个Python对象，它是使用类所创建的对象。每个Python对象都包含识别码，对象类型，属性，方法，数值等属性。

例如：

f = number()

1.使用id()内置函数，可以返回类的识别码

2.使用type()内置函数，可以返回类的对象类型

类的继承

所谓类的继承，就是新类继承旧类的属性和方法，，这种行为称为派生子类。继承的新类称为派生类，被继承的类称为基类。用户在创建派生类时，可以通过派生类来改变基类的任何方法。

派生类的语法如下：

class <类名称> [(基类1，基类2......)]：
    

注意：一个衍生类可以继承多个基类，基类之间用逗号隔开

派生类的构造方法

 #基类的定义
 class A:
     a = 0
     def __init__(self,number):
         self.a = number
     def display(self):
         print(self.a)
    #派生类的定义
class B(A):
    def __init__(self,number):
        A.__init__(self,number)

x = B(1)
X.display()

 需要注意的是派生类的构造方法必须调用基础类的构造方法，并使用完整的基类名称。

类的多继承

python同样的有限的支持多继承

多继承实例：

class people:
    #定义基本属性
    name = ""
    age = 0
    #定义构造方法
    def __init__(self,n,a):
        self.name = n
        self.age = a
    def speak(self):
        print("%s%d" % (self.name,self.age))

#单继承
class student(ppeople):
    grade = ""
    def __init__(self,n,a,g):
        #调用基类的构造函数
        people.__init__(self,n,a)
        self.grade = g
    #改写基类的方法
    def speak(self):
        print("%s%d%d" %(self.name,self.age,self.grade))
#定义类 speaer
class speaer:
    topic = ""
    name = ""
    def __init__(self,t,n)
        self.topic = t
        self.name = n
    def speak(self):
        print("%s%s "%(self.topic,self.name))

#多重继承
class sample(people,speaer):
    def __init__(self,n,a,g,t):
        #调用基类的构造函数
        people.__init__(self,n,a)
        speaer.__init__(self,t,n)    

这里需要注意的是：当所继承的基类中有相同的方法是，默认调用在括号中排在前面的基类

类的多态

所谓类的多态，就是指类可以有多个名称相同，参数类型类型却不同的函数。

多态实例

class people:
    def __init__(self):
        pass
    def func(self,x):
        print("1")
    def func(self,x,y):
        print("2")
    def func(self,x,y,z):
        print("3")

在上面的实例中，当调用people中的func()函数时，Python会默认使用带有三个参数的函数func（x,y,z)。因此，当只提供一个参数时，将会报错。

解决方法：

　　对所给函数的参数个数进行判断具体是调用哪一个函数

代码如下：

class people:        
    def __init__(self):
        pass
    def func1(self,x):
        print("1")
    def func2(self,x,y):
        print("2")
    def func3(self,x,y,z):
        print("3")
     def func(self,*arg):
        if len(arg) == 1:
            self.func1(*arg)
        elif len(*arg == 2):
            self.func2(*arg)
        elif len(*arg == 3):
            self.func3(*arg)
        else:
            print("Wrong Arguments")

类的封装

所谓类的封装，就是将类的属性封装在该类内，只有该类的成员才能使用该类的其他成员。这种被封装的变量与方法，称为该类的私有变量与私有方法。