python第六篇——面向对象的程序设计

一、类对象和对象实例

对象 =属性 + 方法

对象三大特征：封装，继承，多态

 

<一>、类和对象的关系

#对象是根据类创建的，一个类可以对应多个对象。

# 类是由3部分组成的：

# •类的名称：类的名称，首字母必须大写，比如Person。

# •属性：描述事物的静态特征。

# •方法：描述事物的行为

class Example:

    body='强壮'

    #方法

    def effect(self):

        print("示范作用")

 

<二>、实例对象的创建

#1,格式：实例对象名 = 类名(参数列表)

liuyang=Example()

#2,实例对象归属类的判定（isinstance）

print(isinstance(liuyang,Example))

##True

 

<三>、实例对象成员的访问

#类的实例称为实例对象，在创建之后可以使用“.”运算符来调用其成员，成员主要有：

print(liuyang.body ) #访问实例对象属性

##强壮

liuyang.effect() # 访问实例对象方法

##示范作用

<四>、参数self的使用

#在方法的列表中，第1个参数永远都是self。当某个实例对象调用方法的时候，Python解释器会把这个实例对象作为第1个参数传给self，开发者只需传递后面的参数。

<五>、方法与函数的区别

# 1、函数要手动传self；方法不用传。

# 2、函数使用函数名去调用；方法使用对象名去调用

class Example:

    #属性

    body='强壮'

#方法

    def effect (self):

        print("田径运动员的典范")

##方法调用

obj=Example()

obj.effect()   #田径运动员的典范

##函数调用

def effect (self):

    print("职业为游泳运动员")

obj=1

effect(obj) ##职业为游泳运动员

 

<六>、函数转换为方法

def setSpeed(self, s):

    self.speed = s

import types

#动态增加成员方法

car1.setSpeed = types.MethodType(setSpeed, car1) car1.setSpeed(50)

#调用成员方法

print(car1.speed)

 

二、对象的属性

#属性实际上是在类中定义的变量。

#1、构造方法

class Car:

    # 带参构造方法

    def __init__(self, color):

        self.color = color

     # 鸣笛

    def toot(self):

        print("{}颜色的车在鸣笛...".format(self.color))

        # 创建一个对象并用变量bmw保存它的引用

bmw = Car("雪山白")

bmw.toot()

 # 创建一个对象并用变量ferrari保存它的引用

ferrari = Car("红")

 # 汽车鸣笛

ferrari.toot()

 

#2、实例对象属性

# 实例对象属性：在构造方法(__init__)中通过“self.变量名”定义的属性。

# 在类内部通过self访问，在类外通过实例对象访问。

class Person2:

    def _init_(self,age,name):#预先定义实例对象属性

        self.name=name ##初始化self.name

        self.age=age

    def say_hi(self):

        print('你好，我叫',self.name) #类内: self.变量名

laowang = Person2(25,'老王')

laowang.age #类外: 实例.变量名

 

#3，类对象属性

##类对象属性：声明属于类本身的变量

class Person3:

    age = 20 #定义属性age

    name = "Person" #定义属性name

Person3.age += 1 #类调用，类名.类变量名

print(Person3.age)  #21

p1 = Person3()  #实例对象调用,实例对象名.类变量名

print(p1.age)

#4，注意事项：

#类对无法直接访问实例对象属性

class Example(): #榜样

    # body=’强壮’ #方法

    def __init__(self):

        self.careers='swimmer'

        print("示范作用")

#Example.careers  ##error,类对无法直接访问实例对象属性

Example().careers

##示范作用

 

#5,属性的动态修改

#在Python中可以动态地为类和对象增加或修改属性。

#对象名.属性名称

#6、私有属性

# 通常约定以两个下划线“__”开头但不以两个下划线为结束的属性成为私有属性，其他的成为公有属性。

# 不能直接访问私有属性，但可在方法中访问。

class A:

    __name='class A' #私有属性

    def get_name():

        print(A.__name) #在类方法中访问私有类属性

#A.__name,错误

A.get_name()

##class A

 

 

三、对象的方法

<一>，实例对象方法

class Person4: #定义类Person

    def say_hi(self, name): #定义方法say_hi

        self.name = name #参数name赋值给self.name

        print('您好, 我叫', self.name)

p4 = Person4()

p4.say_hi('Alice')

##您好, 我叫 Alice

 

<二>、静态方法

# Python允许声明与类的实例对象无关的方法，称之为静态方法

# 静态方法不能使用实例对象的属性。

# 使用修饰器@staticmethod来标识静态方法。

 

class 类名:

    @staticmethod

    def 静态方法名([形参列表]):

    #方法体

 

class Test:

    num=0

    def __init__(self,age):

        self.age=age

    @staticmethod

    def setNum(a,b):

        num=a+b

        print("静态方法结果{}".format(num))

Test.setNum(2,3) #类对象调用方法

<三>、类方法

# Python声明属于类本身的方法，即类方法。不对特定的实例对象进行操作，且不能访问实例对象的属性。

# 使用修饰器@classmethod来标识类方法

class 类名:

    @classmethod

    def 类方法名(cls[,形参列表]): #第一个形式参数为cls，类对象本身

        方法体



class Test:

    num=0

    def __init__(self,age):

        self.age=age

    @classmethod

    def setNum(cls,newNum):

        cls.num=newNum

        print("类方法结果{}".format(newNum))

Test.setNum(40) #类对象调用方法

##类方法结果40

Test(20).setNum(40) #实例对象调用方法

##方法结果40

 

<四>、私有方法

在方法名字的前边加两个下划线，不可以直接访问！

class 类名:

    def __类方法名(self):

        方法体

??????????????????????????

class Mess:

    def __send_msg(self):

        print("----正在发送短信-----")

    def send_msg(self,new_money):

        if new_money>=10:

            self.__send_msg()

        else:

            print("余额不足，请充值")

mess=Mess()

mess.__send_msg()

Mess._send_msg()

四、运算符重载

 

索引和分片重载

与索引相关的重载方法包括如下3个：

 __getitem__：索引、分片；

   def __setitem__(self, index, value):

    self.data[index] = value

 __setitem__：索引赋值；

  def __setitem__(self, index, value):

   self.data[index] = value

 __delitem__：索引和分片删除。

  def __delitem__(self, index):

   del self.data[index]

 

 五、Python面向对象编程的特征

 

<一>、封装

# 通常把隐藏的属性、方法与方法实现细节的过程称为封装。

#    属性定义为私有属性，即在属性名前加两个下划线。

#   添加供外界调用的两个方法，分别用于设置或获得属性值



class Person:

    def __init__(self, name, age):

        self.name = name # 姓名定义私有属性

        self.__age = age # 年龄

 # 给私有属性赋值

    def set_age(self, new_age): #私有属性赋值

 # 判断传入的参数是否符合要求

        if new_age >0 and new_age <=120:

            self.__age = new_age

 # 获取私有属性的值

    def get_age(self): #获取私有属性值

        return self.__age

# 创建对象

laowang = Person("老王", 30)

print(laowang.get_age())

 

<二>、继承

# #class 子类名(父类名)：

# #单继承，一个子类只能有一个父类，被称为单继承。

class Animal(object):

    def __init__(self, color="白色"):

        self.__color = color # 颜色

    def __test(self): # 私有方法

        print(self.__color)

    def test(self): # 测试方法

        print(self.__color)

# 定义一个动物的子类狗

class Dog(Animal):

    def dogTest1(self):

        print(self.__color) # 访问父类的私有属性

    def dogTest2(self):

        self.__test()# 访问父类的私有方法

        self.test()# 访问父类的公有方法

dog = Dog("深棕色")

dog.dogTest1()

dog.dogTest2()



# #多继承，多继承就是子类拥有多个父类，并且具有它们共同的特征，即子类继承了父类的方法和属性

# ##class 子类名(父类1，父类2…)：

 

<三>、多态性

#Python的多态性是指具有不同功能的函数可以使用相同的函数名，这样就可以用一个函数名调用不同内容的函数

 

###可迭代对象