Python-面向对象编程(一)详解编程语言

初识面向对象：

Python中一切皆对象，我自己，我的电脑，电脑桌，都称之为一个对象.对象是类的一个实体.

我们可以通过行为和特征(属性)来描述一个对象，比如小狗，它有四条腿，一个尾巴，两个虎牙，这就是它的特征，它会汪汪叫，会摇尾巴等这就是它的行为.所有一个真实的对象具备两方面的特征，行为和特征(属性)。

在python中，一个对象的特征也称为属性（attribute）。它所具有的行为也称为方法（method）

结论：对象=属性+方法

在python中，把具有相同属性和方法的对象归为一个类（class）,比如人类，动物，植物等等，这些都是类的概念。

类是对象的模板或蓝图，类是对象的抽象化，对象是类的实例化。类不代表具体的事物，而对象表示具体的事物.

一.创建类和对象:

 1 1.self 
 2 类的方法与普通的函数只有一个特别的区别--他们必须有一个额外的第一个参数名称，但是在调用这个方法的时候你不为这个参数赋值，Python会提供这个值。
 3　这个特别的变量指对象本身，按照惯例它的名字是self. 
 4 2.如果你有一个类称为MyClass和这个类的一个实例MyObject。当你调用这个对象的方法MyObject.method(arg1,arg2)的时候，这会由Python自动转为
 5　MyClass.method(MyObject,arg1,arg2) 
 6  
 7 #############################################创建类MyClass(object)################ 
 8 class MyClass(object):          　　　　　　 #定义MyClass类
 9     def method(self,arg1,arg2):         　 #定义method方法.其中self为特殊参数，必填.
10         print """ 
11         arg1 is %s 
12         arg2 is %s """ %(arg1,arg2) 
13  
14  
15 MyObject = MyClass()                     #创建MyObject对象(实例)
16  
17 MyObject.method("Saneri",29)          #<==>   MyClass.method(MyObject,"Saneri",29) #执行MyClass.method()方法

18 
19 #############################################

二.属性

　　在类中我们可以定义一些属性，比如：

1 class people:　　　　　　 
2     name = 'Saneri' 
3     age = 18 
4  
5 P = people() 
6 print P.name,P.age

定义了一个people类，里面定义了name和age属性，默认值分别为’Saneri’和18。在定义了类之后，就可以用来产生实例化对象了，这句P = people( )实例化了一个对象p，然后就可以通过P来读取属性了。这里的name和age都是公有的，可以直接在类外通过对象名访问，如果想定义成私有的，则需在前面加2个下划线 ‘ __’

class people: 
    __name = 'Saneri'　　#私有属性 
    __age = 18　　　　　　#私有属性   
 
p = people() 
print p.__name,p.__age   #会报错，私有属性不能再外部进行调用. 
 
################################## 
私有属性是不能够在类外通过对象名来进行访问的. 
私有属性只能通过类里面的方法去调用.

三.方法

　　在类中可以根据需要定义一些方法，定义方法采用def关键字，在类中定义的方法至少会有一个参数，，一般以名为’self’的变量作为该参数（用其他名称也可以），而且需要作为第一个参数。下面看个例子：

 1 class people(object): 
 2     def __init__(self,name,age):　　　　#构造方法 
 3         self.__name = name　　　　　　　　# 
 4         self.__age = age 
 5  
 6     def getName(self):　　　　　　　　　　#定义方法 
 7         print  self.__name 
 8     def getAge(self): 
 9         print  self.__age 
10  
11 P = people("Saneri",18) 
12 P.getName() 
13 P.getAge() 
14  
15 ##执行结果###################### 
16 Saneri 
17 18

四.类中内置的方法:

在Python中有一些内置的方法，这些方法以2个下划线开始然后以2个下划线结束的方式定义.

 1  __doc__                     　　　#表示类的描述信息 
 2 __init__(self,...)          　　　#初始化对象，在创建新对象时调用 
 3  
 4 __del__(self)      　　　　　　　　#释放对象，在对象被删除之前调用 
 5  
 6 __str__(self)      　　　　　　#在使用print语句时被调用 
 7  
 8 __call__(self,*args)      　　#把实例对象作为函数调用 
 9  
10 __getitem__(self,key)      　　#获取序列的索引key对应的值，等价于seq[key] 
11  
12 __module__         　　#表示当前操作的对象在那个模块 
13  
14 __class__         　　#表示当前操作的对象的类是什么 
15  
16 __dict__        　　#类或对象中的所有成员 
17  
18 __getattr__(s,name)      　　#获取属性的值 
19  
20 __setattr__(s,name,value)      　　#设置属性的值 
21  
22 __delattr__(s,name)      　　#删除name属性

#######################################################
其他的内置属性请参考链接：http://www.cnblogs.com/simayixin/archive/2011/05/04/2036295.html

面向对象的三大特性：

面向对象的三大特性是指：封装、继承和多态.

一、封装

封装，顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容。

class person:                          #定义了一个person类.
　　def info(self,name,age):            #定义了一个info方法        
　　　　print """ 
        name is %s 
        age is %s """ %(name,age) 
 
#person().info("saneri",29) 
P = person()                #实例化了一个对象P，将“saneri，29封装到name，age属性中.”
P.info("saneri",29)         #定义属性,应用info方法.
"""
　　上面代码中，我们定义一个person类，定义一个info方法，但没有定义属性，因为属性不属于类，而是属于各个类的实例。也就是说属于对象,因此我们可以给每个实例设置不同的属性。
　　　　"""
  
#__init__初始化  //对实体进行初始化 

"""
创建类时，可以定义一个特定的方法，名为__init__(),只要创建这个类的一个实例,就会运行这个方法。可以向__init__()方法传递参数，这样创建对象时就可以把属性设置为你希望的值

__init__()这个方法会在创建对象时完成初始化.
　　　　　　　　　　　　　　　　　　"""
　　 
class person: 
    def __init__(self,nationality):　　　　#构造方法 
        self.country = nationality  　　#让下面的info函数可以调用 nationality,方法是将变量nationality赋值给这个类 
    def info(self,name,age): 
        print """ 
        name is %s 
        age is %s 
        nationality is %s""" %(name,age,self.country) 
 
 
#person().info("saneri",29) 
P = person("CN")                #绑定到一个实例 
P.info("saneri",29) 
 
#类的绑定 
 
class Person: 
    def __init__(self,name,nationality,age,sex,job):　　#构造方法 
        self.Name = name 
        self.Nationality = nationality 
        self.Age = age 
        self.Sex = sex 
        self.Job = job 
 
    def talk(self,msg=0): 
        self.msg = msg      #让其他变量可以调用. 
        if self.msg != 0: 
            print """ 
            name is %s 
            nationality is %s 
            age is %s 
            sex is %s 
            job is %s """ %(self.Name,self.Nationality,self.Age,self.Sex,self.Job) 
 
    def skill(self): 
        if self.Job == 'IT Engineer': 
            print """To be IT Engineer,you must need to below skiils: 
            1.Linux/Unix 
            2.databases 
            3.Shell,Python """ 
 
#Person("saneri","CN",29,"male","IT Engineer").talk(1) 
#Person("saneri","CN",29,"male","IT Engineer").skill() 
 
p = Person("saneri","CN",29,"male","IT Engineer") 
p.talk(1) 
p.skill()

二、类的继承：

对于面向对象的继承来说，其实就是将多个类共有的方法提取到父类中，子类仅需继承父类而不必一一实现每个方法

 1 #类的继承 
 2  
 3 class person(object):　　　　　　　　　　#基类 
 4     def __init__(self,Type,Sex,Age,Name): 
 5         self.type = Type 
 6         self.sex = Sex 
 7         self.age = Age 
 8         self.name = Name 
 9     def info(self,msg=0): 
10         self.Msg = msg 
11         if self.Msg != 0: 
12             print self.name,"Saying:",self.Msg 
13         else: 
14             print "hello,%s dengyu" %self.Msg 
15  
16 #P = person("It","male",29,"saneri") 
17 #P.info(1) 
18  
19 class person_info(person):      #派生类 
20     def __init__(self,Type,Sex,Age,Name,nation,work,salary):    #继承基类字段，并添加新的字段 
21         person.__init__(self,Type,Sex,Age,Name)         #将基类的初始化变量继承过来 
22         self.country = nation 
23         self.job = work 
24         self.salary = salary 
25     def tell(self,msg): 
26         input = raw_input("Plz input your name:") 
27         if input == self.name: 
28  
29             print """%s's personal information: 
30                 Name :%s 
31                 Age :%s 
32                 Nation :%s 
33                 Work :%s 
34                 Msg :%s 
35                 """ %(self.name,self.name,self.age,self.country,self.salary,msg) 
36  
37  
38 P = person_info("IT","male",29,"Saneri","ShanXi","job","13000") 
39 P.tell('[email protected]')

那是否可以继承多个类呢？答案是肯定的.但是不建议初学者这么做.

1、Python的类可以继承多个类，Java和C#中则只能继承一个类

2、Python的类如果继承了多个类，那么其寻找方法的方式有两种，分别是：深度优先和广度优先.

当类是经典类时，多继承情况下，会按照深度优先方式查找
当类是新式类时，多继承情况下，会按照广度优先方式查找

那么问题又来了，什么是经典类和新式类呢。好，请看下图.

经典类和新式类，从字面上可以看出一个老一个新，新的必然包含了跟多的功能，也是之后推荐的写法，从写法上区分的话，如果 当前类或者父类继承了object类，那么该类便是新式类，否则便是经典类。

 1 class D: 
 2  
 3     def bar(self): 
 4         print 'D.bar' 
 5  
 6  
 7 class C(D): 
 8  
 9     def bar(self): 
10         print 'C.bar' 
11  
12  
13 class B(D): 
14  
15     def bar(self): 
16         print 'B.bar' 
17  
18  
19 class A(B, C): 
20  
21     def bar(self): 
22         print 'A.bar' 
23  
24 a = A() 
25 # 执行bar方法时 
26 # 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去D类中找，如果D类中么有，则继续去C类中找，如果还是未找到，则报错 
27 # 所以，查找顺序：A --> B --> D --> C 
28 # 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了 
29 a.bar() 
30  
31 经典类多继承

经典类多继承

 1 class D(object): 
 2  
 3     def bar(self): 
 4         print 'D.bar' 
 5  
 6  
 7 class C(D): 
 8  
 9     def bar(self): 
10         print 'C.bar' 
11  
12  
13 class B(D): 
14  
15     def bar(self): 
16         print 'B.bar' 
17  
18  
19 class A(B, C): 
20  
21     def bar(self): 
22         print 'A.bar' 
23  
24 a = A() 
25 # 执行bar方法时 
26 # 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去C类中找，如果C类中么有，则继续去D类中找，如果还是未找到，则报错 
27 # 所以，查找顺序：A --> B --> C --> D 
28 # 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了 
29 a.bar()

新式类多继承

三、多态

Pyhon不支持多态并且也用不到多态，这里简单带过，不做过多介绍.

整理参考文件：http://www.cnblogs.com/wupeiqi/p/4493506.html

原创文章，作者：ItWorker，如若转载，请注明出处：https://blog.ytso.com/11673.html

Python-面向对象编程(一)详解编程语言

相关推荐

发表回复