python之对象与类

1.类的定义

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

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

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

代码实例：

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

代码分析：

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

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

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

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

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

创建类的构造方法实例：

 1 class fruit:
 2     #定义基本属性
 3 name = ""
 4 city = ""
 5 #定义私有属性
 6 __price = 0
 7 #定义构造方法
 8 def __init__(self,n,c,p):
 9     self.name  = n
10     self.city = c
11     self.price = p
12 def display(self):
13     print("%s%s%s" % (self.name,self.city,self.price))
14 #实例化类
15 f = fruit("1","2",,3)
16 f.display(

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

类实例

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

例如：

f = number()

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

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

类的继承

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

派生类的语法如下：

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

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

派生类的构造方法

 1  #基类的定义
 2  class A:
 3      a = 0
 4      def __init__(self,number):
 5          self.a = number
 6      def display(self):
 7          print(self.a)
 8     #派生类的定义
 9 class B(A):
10     def __init__(self,number):
11         A.__init__(self,number)
12
13 x = B(1)
14 X.display()

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

类的多继承

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

多继承实例：

 1 class people:
 2     #定义基本属性
 3     name = ""
 4     age = 0
 5     #定义构造方法
 6     def __init__(self,n,a):
 7         self.name = n
 8         self.age = a
 9     def speak(self):
10         print("%s%d" % (self.name,self.age))
11
12 #单继承
13 class student(ppeople):
14     grade = ""
15     def __init__(self,n,a,g):
16         #调用基类的构造函数
17         people.__init__(self,n,a)
18         self.grade = g
19     #改写基类的方法
20     def speak(self):
21         print("%s%d%d" %(self.name,self.age,self.grade))
22 #定义类 speaer
23 class speaer:
24     topic = ""
25     name = ""
26     def __init__(self,t,n)
27         self.topic = t
28         self.name = n
29     def speak(self):
30         print("%s%s "%(self.topic,self.name))
31
32 #多重继承
33 class sample(people,speaer):
34     def __init__(self,n,a,g,t):
35         #调用基类的构造函数
36         people.__init__(self,n,a)
37         speaer.__init__(self,t,n)    

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

类的多态

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

多态实例

1 class people:
2     def __init__(self):
3         pass
4     def func(self,x):
5         print("1")
6     def func(self,x,y):
7         print("2")
8     def func(self,x,y,z):
9         print("3")

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

解决方法：

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

代码如下：

 1 class people:
 2     def __init__(self):
 3         pass
 4     def func1(self,x):
 5         print("1")
 6     def func2(self,x,y):
 7         print("2")
 8     def func3(self,x,y,z):
 9         print("3")
10      def func(self,*arg):
11         if len(arg) == 1:
12             self.func1(*arg)
13         elif len(*arg == 2):
14             self.func2(*arg)
15         elif len(*arg == 3):
16             self.func3(*arg)
17         else:
18             print("Wrong Arguments")

类的封装

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