威尼斯wns.9778官网活动_vnsc威尼斯城官网

热门关键词: 威尼斯wns.9778官网活动,vnsc威尼斯城官网
当前位置:威尼斯wns.9778官网活动 > 计算机教程 > 12.Python编程之面向对象【威尼斯wns.9778官网活动】

12.Python编程之面向对象【威尼斯wns.9778官网活动】

文章作者:计算机教程 上传时间:2019-05-10

面向对象学习目录

面向对象的程序设计

  • 真实世界的对象
 特征:状态和行为
 比如:猫
     状态:名字,颜色,品种
     行为:喵叫,摇尾巴,捉老鼠
 真实世界对象
     这个对象有怎样的状态
     这个对象具有什么行为
 台灯
     状态:开,关
     行为:打开,关闭
 台式收音机
    状态:开,关,当前音量,当前频道
    行为:打开,关闭,增加音量,减少音量,搜索,扫描和调音
  • 类:某种类型集合的描述,举例:人
 属性
     类本身的一些特征,如名字,身高和体重等属性
 方法:
     类所能实现的行为,如吃饭,走路和睡觉等方法
  • 类定义解析:
class ClassName:  
    block     

注意类名后面有个冒号,并且类名第一个字母要大写,在block块里面就可以定义属性和方法了。当一个类定义完之后,就产生了一个类对象。类对象支持两种操作:引用和实例化。引用操作是通过类对象去调用类中的属性或者方法,而实例化是产生出一个类对象的实例,称作实例对象。比如定义了一个people类:

class   People:  
    #定义一个属性  
    name = 'jack'       
    #定义一个方法  
    def printName(self):  
        print(self.name)  

1.People类定义完成之后就产生了一个全局的类对象,可以通过类对象来访问类中的属性和方法了。
2.当通过People.name(至于为什么可以直接这样访问属性后面再解释,这里只要理解类对象这个概念就行了)来访问时,people.name中的people称为类对象,这点和C  中的有所不同。
3.当然还可以进行实例化操作,方法为p=People(),这样就产生了一个People的实例对象,此时也可以通过实例对象p来访问属性或者方法了(p.name).
  • 理解了类、类对象和实例对象的区别之后,我们来了解一下Python中属性、方法和函数的区别。

1.在上面代码中注释的很清楚了,name是一个属性,printName()是一个方法,与某个对象进行绑定的函数称作为方法。

2.一般在类里面定义的函数与类对象或者实例对象绑定了,所以称作为方法;而在类外定义的函数一般没有同对象进行绑定,就称为函数。

  • 类中内置的方法

在Python中有一些内置的方法,这些方法命名都有比较特殊的地方(其方法名以2个下划线开始然后以2个下划线结束)。类中最常用的就是构造方法和析构方法。

class classname[(父类]名)]:[成员函数及成员变量]
 __init__构造函数:初始化对象的各属性
     在生成对象时调用,可以用来进行一些初始化操作,不需要显示去调用,系统会默认去执行。构造方法支持重载,如果用户自己没有重新定义构造方法,系统就自动执行默认的构造方法。
 __del__析构函数:销毁对象
     在释放对象时调用,支持重载,可以在里面进行一些释放资源的操作,不需要显示调用。
  • 还有其他的一些内置方法,比如 cmp( ), len( )等。下面是常用的内置方法:
内置方法 说明
init(self,...) 初始化对象,在创建新对象时调用
del(self) 释放对象,在对象被删除之前调用
new(cls,args,*kwd) 实例的生成操作
str(self) 在使用print语句时被调用
getitem(self,key) 获取序列的索引key对应的值,等价于seq[key]
len(self) 在调用内联函数len()时被调用
cmp(stc,dst) 比较两个对象src和dst
getattr(s,name) 获取属性的值
setattr(s,name,value) 设置属性的值
delattr(s,name) 删除name属性
getattribute() getattribute()功能与getattr()类似
gt(self,other) 判断self对象是否大于other对象
lt(slef,other) 判断self对象是否小于other对象
ge(slef,other) 判断self对象是否大于或者等于other对象
le(slef,other) 判断self对象是否小于或者等于other对象
eq(slef,other) 判断self对象是否等于other对象
call(self,*args) 把实例对象作为函数调用
__init__():__init__方法在类的一个对象被建立时,马上运行。这个方法可以用来对你的对象做一些你希望的初始化

注意,这个名称的开始和结尾都是双下划线。

  • 代码例子1:
# Filename: class_init.py  
class Person:  
    def __init__(self, name):  
        self.name = name  
    def sayHi(self):  
        print('Hello, my name is', self.name)
#实例化
p = Person('init')
#调用方法
p.sayHi() 
  • 输出: Hello, my name is init
  • 代码例子2:
class Movie(object):

def __init__(self,name,length):
    self.name = name
    self.length = length

def print_name(self):
    print '电影的名称是:%s' % (self.name,)

实例执行情况:

>>> movie = Movie('大圣归来',90)
大圣归来
>>> print(movie.length
90
  • class Movie(object): 是固定写法,class表明正在声明的是一个类,Movie是类名,(object)表示继承自那些父类,就像java一样,所有的类都是继承自object类的,所以如果你写的不继承自其他的类就将其写成继承自object,当继承自object,括号连同括号里的object都可以省略写成:class Movie:

  • 第一个方法init是构造方法,构造方法的第一个参数永远是self,表示这个类的对象本身,真正构造对象时,self这个参数不用写,python编译器会自己加上去,构造方法的作用就是对self对象进行赋值,如上面的将电影的名字和长度赋给self。

对于上面的Movie类我们可以用下面的代码来调用它:

#不继承任何类,就继承object类
class Movie:

def __init__(self,name,length):
    self.name = name
    self.length = length

def print_name(self):
    print ('电影的名称是:%s' % (self.name,))
  • 有了init方法,在创建实例的时候,就不能传入空的参数了,必须传入与init方法匹配的参数,但self不需要传,Python解释器自己会把实例变量传进去:
>>> movie = Movie('大圣归来',90)
大圣归来

>>> print(movie.length
90

和普通的函数相比,在类中定义的函数只有一点不同,就是第一个参数永远是实例变量self,并且,调用时,不用传递该参数。除此之外,类的方法和普通函数没有什么区别,所以,你仍然可以用默认参数、可变参数、关键字参数和命名关键字参数。


__new__():__new__()在__init__()之前被调用,用于生成实例对象。利用这个方法和类属性的特性可以实现设计模式中的单例模式。单例模式是指创建唯一对象吗,单例模式设计的类只能实例化一个对象。
  • 代码如下:
class Singleton(object):  
    __instance = None                       # 定义实例  

    def __init__(self):  
        pass  

    def __new__(cls, *args, **kwd):         # 在__init__之前调用  
        if Singleton.__instance is None:    # 生成唯一实例  
            Singleton.__instance = object.__new__(cls, *args, **kwd)  
        return Singleton.__instance  

__getattr__()、__setattr__()和__getattribute__():当读取对象的某个属性时,python会自动调用__getattr__()方法。例如,fruit.color将转换为fruit.__getattr__(color)。当使用赋值语句对属性进行设置时,python会自动调用__setattr__()方法。__getattribute__()的功能与__getattr__()类似,用于获取属性的值。但是__getattribute__()能提供更好的控制,代码更健壮。注意,python中并不存在__setattribute__()方法。

代码例子:

class Fruit(object):  
    def __init__(self, color="red", price=0):  
        self.__color = color  
        self.__price = price  

    def __getattribute__(self, item):              # 获取属性的方法  
        return object.__getattribute__(self, item)  

    def __setattr__(self, key, value):  
        self.__dict__[key] = value  

if __name__ == "__main__":  
    fruit = Fruit("blue", 10)  
    print fruit.__dict__.get("_Fruit__color")    # 获取color属性  
    fruit.__dict__["_Fruit__price"] = 5  
    print (fruit.__dict__.get("_Fruit__price") )   # 获取price属性 


#输出
blue
5

Python不允许实例化的类访问私有数据,但你可以使用object._className__attrName访问这些私有属性。

__getitem__():如果类把某个属性定义为序列,可以使用__getitem__()输出序列属性中的某个元素.假设水果店中销售多钟水果,可以通过__getitem__()方法获取水果店中的没种水果。
  • 代码例子:
class FruitShop:  
 def __getitem__(self, i):      # 获取水果店的水果  
     return self.fruits[i]        

if __name__ == "__main__":  
    shop = FruitShop()  
    shop.fruits = ["apple", "banana"]  
    print shop[1]  
    for item in shop:               # 输出水果店的水果  
        print(item),
#输出
banana
apple
banana

__str__():__str__()用于表示对象代表的含义,返回一个字符串.实现了__str__()方法后,可以直接使用print语句输出对象,也可以通过函数str()触发__str__()的执行。这样就把对象和字符串关联起来,便于某些程序的实现,可以用这个字符串来表示某个类。
  • 代码例子:
class Fruit:       
'''''Fruit类'''               #为Fruit类定义了文档字符串  
def __str__(self):          # 定义对象的字符串表示  
    return self.__doc__  

if __name__ == "__main__":  
    fruit = Fruit()  
    print (str(fruit) )          # 调用内置函数str()触发__str__()方法,输出结果为:Fruit类  
    print( fruit )                #直接输出对象fruit,返回__str__()方法的值,输出结果为:Fruit类 
#输出
''Fruit类
''Fruit类

__call__():在类中实现__call__()方法,可以在对象创建时直接返回__call__()的内容。使用该方法可以模拟静态方法。
  • 代码例子:
class Fruit:  
class Growth:        # 内部类  
    def __call__(self):  
        print ("grow ...")  

grow = Growth()      # 调用Growth(),此时将类Growth作为函数返回,即为外部类Fruit定义方法grow(),grow()将执行__call__()内的代码  
if __name__ == '__main__':  
    fruit = Fruit()  
    fruit.grow()         # 输出结果:grow ...  
    Fruit.grow()         # 输出结果:grow ...
#输出
grow ...
grow ...

1 面向对象介绍

举例1:GPA计算

 学生课程评估:学分和平均绩点GPA
 绩点计算以GPA 4分为准则
      一门课程3学分
      同学得了 “A”
      3*4=12量分数

GPA计算以4分为准则,学生的成绩是“A”(即4点),“B”(即3点),“C”(即2点),“D”(即1点),“E”(即0点),GPA的计算如下:

在申请入学时,很多学校有GPA规定。GPA的计算为:
1.每个科目点数乘以学分。比如微积分是4分的课,成绩是A(即4点),微积分一科可以得16点
2.如果一学期修了4门课,英文3学分(成绩4点),历史3学分(成绩2点)物理3学分(成绩3点),加上微积分。

GPA是16 4x3 3x2 3x3 = 43,43/13 = 3.31
  • GPA=(所有科目的总点数)/(总学分)。
    记录学生成绩的文件包含多个学生的记录,每个记录为一行,包括该学生的姓名,总学分和量分数(即所有科目的总点数),学生成绩表如下:
![](https://upload-images.jianshu.io/upload_images/8730384-614e108f9521bee9.png)

image.png

记录学生成绩文件students.txt.编写程序,通过读取文件找出平均绩点最高的学生,然后输出他的名字,学分和平均绩点。

  • 定义Student类
 class Student:
    def __init__(self,name,hours, qpoints):
        self.name = name
        self.hours = float(hours)
        self.qpoints = float(qpoints)

    def getName(self):
        return self.name

    def getHouse(self):
        return self.hours

    def getQPoints(self):
         return self.qpoints

    def gpa(self):
        return self.gpoints/self.hours
  • GPU算法描述为
获取文件名
打开文件
设置第一个学生为best
对文件中的每一个学生

    if s.gpa()>best.gpa()
        设置s为best

打印best学生的信息

代码执行:

#定义Student类
class Student:
    #初始化
    def __init__(self,name,hours, qpoints):
        self.name = name
        self.hours = float(hours)
        self.qpoints = float(qpoints)
    #方法1:返回名字   
    def getName(self):
        return self.name
    #方法2:返回分数
    def getHouse(self):
        return self.hours
    #方法3:返回   
    def getQPoints(self):
         return self.qpoints

    def gpa(self):
        return self.qpoints/self.hours

    def makeStudent(infoString):
            name,scores,qpoints=infoString.split()
            return Student(name,scores,qpoints)



# 主函数
def main():
    #打开输入文件
    fileName=input('Enter name of the grade file:')
    f=open(fileName,'r')
    #设置文件中第一个学生为best
    best= makeStudent(f.readline())
    #处理文件中剩余的行数据
    for line in f:
        #将文件中的每一行数据转换为一个学生对象
        s= makeStudent(line)
        #如果该学生是目前GPA最高的,则记录下来
        if s.gpa()>best.gpa():
            best=s
    f.close()
    #打印GPA成绩最高的学生信息
    print('The best student is:',best.getName())
    print('scores:',best.getHouse())
    print('GPA:',best.gpa())
if __name__ =="__main__":
    main()


# 执行结果:
Enter name of the grade file:C:UsersAdministratorDesktopexercisepython_learning面向对象students.txt
The best student is: 李四
scores: 100.0
GPA: 4.0

2 类、实例、属性、方法详解

举例2:铅球飞行轨迹计算

 铅球对象属性
     xpos
     ypos
     xvel
     Yvel
 构建投射体类Projectile
 创建和更新对象的变量
  • 主函数
def main():
    angle,vel,h0,time = getInputs()
    shot = Projectile(angle,vel,h0)
    while shot.getY() >=0:
        shot.updata(time)
    print("nDistance traveled:{0:0.1f}meters.".format(shot.getX()))







#Projectile类
from math import sin,cos,radians

class Projectile:

    def __init__(self, angle, velocity, height):
        #根据给定的发射角度,初始速度和位置创建一个投射体对象
        self.xpos = 0.0
        self.ypos = height
        theta = radians(angle)
        self.xvel = velocity * cos(theat)
        self.yvel = velocity * sin(theta)



    def getXYComponents(vel,angle):
        theta = radians(angle)
        xvel = vel * cos(theta)
        yvel = vel * sin(theta)
        return xvel, yvel

    def updatPosition(time, xpos,ypos,xvel,yvel):
        xpos = xpos   time * xvel
        yvell = yvel - time * 9.8
        ypos = ypos   time * (yvel   yvell) / 2.0
        yvel = yvell
        return xpos, ypos,yvel
  • 引入对象,程序模块化
from Projectile import *

def getInputs():
    angle = eval(input("Enter the launch angle (in degrees):"))
    vel = eval(input("Enter the initial velocity (in meters/sec):"))
    h0 = eval(input("Enter the initial height (in meters):"))
    time = eval(input("Enter the time interval:"))
    return angle,vel,h0,time

def main():
    angle,vel,h0,time = getInputs()
    shot = Projectile(angle,vel,h0)
    while ypos >= 0:
        xpos, ypos, yvel = updatPosition(time,xpos,ypos,xvel,yvel)
    print("nDistance traveled:{0:0.1f}meters.".format(xpos))

所用代码在jupyter notebook中:

from math import sin,cos,radians
class Projectile:
    def __init__(self,angle,velocity,height):
        #根据给定的发射角度,初始速度和位置创建一个投射体对象
        self.xpos=0.0
        self.ypos=height
        theta=radians(angle)
        self.xvel=velocity*cos(theta)
        self.yvel=velocity*sin(theta)


    def update(self,time):
        #更新投射体的状态
        self.xpos=self.xpos time*self.xvel
        yvel1=self.yvel-9.8*time
        self.ypos=self.ypos time*(self.yvel yvel1)/2.0
        self.yvel=yvel1


    def getY(self):
        #返回投射体的y轴坐标
        return self.ypos


    def getX(self):
        #返回投射体的x轴坐标(即水平距离)
        return self.xpos




def getInputs():
    a=eval(input('Enter the launch angle(in degrees):'))
    v=eval(input('Enter the initial velocity(in meters/sec):'))
    h=eval(input('Enter the initial height(in meters):'))
    t=eval(input('Enter the time interval:'))
    return a,v,h,t


def main():
    angle,vel,h0,time=getInputs()
    shot=Projectile(angle,vel,h0)
    while shot.getY()>=0:
        shot.update(time)
    print('nDistance traveled:{0:0.1f} meters.'.format(shot.getX()))

输出结果:
Enter the launch angle(in degrees):41
Enter the initial velocity(in meters/sec):14
Enter the initial height(in meters):1.8
Enter the time interval:0.8

Distance traveled:25.4 meters.

3 面向过程与面向对象进一步比较

面向对象的特点

  • 封装
 从业务逻辑中抽象对象时,赋予对象相关数据与操作,把一些数据和操作打包在一起的过程就是**封装**
对象的实现和使用是独立的
 支持代码复用
  • 举例:封装
 Projectile将投射体属性和方法封装在类的内部
 不必关心铅球内部如何实现
 Projectile类可以被多个程序,多个对象所使用
  • 多态
 对象怎么回应一个依赖于对象类型或种类的消息
 在不同情况下用一个函数启用不同的方法
 灵活性
  • 举例:多态

能够直接说明多态的两段示例代码如下:
  
  
  1、方法多态

  _metaclass_=type # 确定使用新式类  
    class calculator:  

        def count(self,args):  
            return 1  

    calc=calculator() #自定义类型  

    from random import choice  
    obj=choice(['hello,world',[1,2,3],calc]) #obj是随机返回的 类型不确定  
    print (type(obj) ) 
    print (obj.count('a')) #方法多态  

对于一个临时对象obj,它通过Python的随机函数取出来,不知道具体类型(是字符串、元组还是自定义类型),都可以调用count方法进行计算,至于count由谁(哪种类型)去做怎么去实现我们并不关心。

有一种称为”鸭子类型(duck typing)“的东西,讲的也是多态:

_metaclass_=type # 确定使用新式类  
class Duck:  
    def quack(self):   
        print ("Quaaaaaack!")  
    def feathers(self):   
        print ("The duck has white and gray feathers.")  

class Person:  
    def quack(self):  
        print ("The person imitates a duck." ) 
    def feathers(self):   
        print ("The person takes a feather from the ground and shows it." ) 

def in_the_forest(duck):  
    duck.quack()  
    duck.feathers()  

def game():  
    donald = Duck()  
    john = Person()  
    in_the_forest(donald)  
    in_the_forest(john)  

game() 

#输出
Quaaaaaack!
The duck has white and gray feathers.
The person imitates a duck.
The person takes a feather from the ground and shows it.

就in_the_forest函数而言,参数对象是一个鸭子类型,它实现了方法多态。但是实际上我们知道,从严格的抽象来讲,Person类型和Duck完全风马牛不相及。

2、运算符多态
def add(x,y):  
return x y  

print (add(1,2)) #输出3  

print (add("hello,","world")) #输出hello,world  

print (add(1,"abc")) #抛出异常 

TypeError: unsupported operand type(s) for  : 'int' and 'str'

上例中,显而易见,Python的加法运算符是”多态“的,理论上,我们实现的add方法支持任意支持加法的对象,但是我们不用关心两个参数x和y具体是什么类型。
  
Python同样支持运算符重载,实例如下:

class Vector:  
def __init__(self, a, b):  
  self.a = a  
  self.b = b  

def __str__(self):  
  return 'Vector (%d, %d)' % (self.a, self.b)  

def __add__(self,other):  
  return Vector(self.a   other.a, self.b   other.b)  

v1 = Vector(2,10)  
v2 = Vector(5,-2)  
print (v1   v2)  
#输出:
Vector (7, 8)

一两个示例代码当然不能从根本上说明多态。普遍认为面向对象最有价值最被低估的特征其实是多态。

  • 参考文献:

http://www.cnblogs.com/dolphin0520/archive/2013/03/29/2986924.html

http://www.cnblogs.com/jeffwongishandsome/archive/2012/10/06/2713258.html

  • 继承

    在C 和Java中,使用继承时,子类的构造函数会自动调用父类的构造函数,但在Python中,子类必须显式的在init()函数中再次调用父类中的init()函数。如下例:

 一个类(subclass)可以借用另一个类(superclass)的行为
 避免重复操作
 提升代码复用程度


- 举例:继承


 员工信息系统
 Employee类 #包含所有员工通用一般信息
     Employee类属性raisesalary() #返回员工工资信息
 Employee子类:work()
     共享raisesalary() 属性
     自己work()属性
class Employee(object):  
    def __init__(self, name, salary = 0):  
        self.name = name  
        self.salary = salary  
    def raisesalary(self, percent):  
        self.salary = self.salary  * (1   percent)  
    def work(self):  
        print (self.name, "writes computer code" ) 


子类Designer也可以使用super来进行初始化。

class Designer(Employee):  
    def __init__(self, name):  
        super(Designer, self).__init__(name, 5000)  
    def work(self):  
        print self.name, "writes design document"   

2.多继承

在C 中,使用虚继承来实现多继承,以避免子类在继承时多次调用基类的构造函数,而在Java中,则取消了多继承,使用接口来达到多继承的效果。在Python中的解决方案是MRO即Method Resolution Order,方法解析顺序。主要是通过super方法实现的。但如果用super方法来解决多继承问题,由于各个父类中的威尼斯wns.9778官网活动,init()函数中参数的数量可能不同,那应该怎么初始化呢?如下例。

class A(object):  
    def __init__(self, a):  
        print a  
class B(object):  
    def __init__(self, a, b):  
        print a b  
class C(A, B):  
    def __init__(self):  
        super(C,self).__init__(?)  

c = C()  

4 类与对象

5 属性查找与绑定方法

6 小结

7 继承与派生

8 组合

9 抽象类

10 多态

11 封装

12 绑定方法与非绑定方法

13 内置方法(上)

14 内置方法(中)之描述符

15 内置方法(下)

16 元类


类的语法

    定义一个人的类:

1 class Person(object):
2   def __init__(self, name, age):
3     self.name = name
4     self.age = age
5 
6 
7 p = Person("Alex", 22)
8 print(p.name, p.age)

 

本文由威尼斯wns.9778官网活动发布于计算机教程,转载请注明出处:12.Python编程之面向对象【威尼斯wns.9778官网活动】

关键词: