<07day>_面向对象

一、类对象

类对象支持两种操作：属性引用-和-实例化。

属性引用使用和 Python 中所有的属性引用一样的标准语法：obj.name。

类对象创建后，类命名空间中所有的命名都是有效属性名。所以如果类定义是这样:

#!/usr/bin/python
# -*- coding:utf-8 -*-
# Author:zhaosj
class Chinses:
    """一个简单的类实例"""
    i = 12345
    def f(self):
        return ‘hello world‘

# 实例化类
x = Chinses()
# 访问类的属性和方法
print("Chinses类的属性 i 为：", x.i)
print("Chinses类的方法 f 输出为：", x.f())

运行结果：

很多类都倾向于将对象创建为有初始状态的。

因此类可能会定义一个名为 __init__() 的特殊方法（构造方法），像下面这样：

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

二、类的继承

Python 同样支持类的继承，如果一种语言不支持继承，类就没有什么意义;

python从左至右搜索 即方法在子类中未找到时，从左到右查找基类中是否包含方法。

示列：

#!/usr/bin/python
# -*- coding:utf-8 -*-
# Author:zhaosj
# 定义一个人的父类
class people:
# 定义基本属性
    name = ‘‘
    age = 0
# 定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
# 定义构造方法
    def __init__(self, n, a, w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" % (self.name, self.age))
# 学生类继承父类方法
class student(people):
    grade = ‘‘
    def __init__(self, n, a, w, g):
# 调用父类的构函
        people.__init__(self, n, a, w)
        self.grade = g
# 覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级" % (self.name, self.age, self.grade))

s = student(‘小明明‘, 10, 60, 3)
s.speak()

运行结果：

三、类的专有方法

四、类的多态性

#!/usr/bin/python
# -*- coding:utf-8 -*-
# Author:zhaosj
#多态是同一种事物的多种形态
#第一：定义了一个动物(dongwu)的一个父类
class dongwu:
    def talk(self):
        print(‘正在叫‘)
class People(dongwu): #继承父类
    def talk(self):
        print(‘say hello‘)
class Pig(dongwu):    #继承父类
    def talk(self):
        print(‘哼哼哼‘)
class Dog(dongwu):    #继承父类
    def talk(self):
        print(‘汪汪汪‘)

#多态性
peol=People()
pigl=Pig()
dogl=Dog()

def func(x):
    x.talk()

func(peol)
func(pigl)
func(dogl)

运行结果：

第五、类的封装属性

类封装--后的属性方法调用方式

#!/usr/bin/python
# -*- coding:utf-8 -*-
# Author:zhaosj
#类的封装属性
class People:
    def __init__(self,name,age,sex):
        self.__name=name  #__name代表封装了name
        self.__age=age
        self.__sex=sex

 #封装后的类方法的调用
    def tell_info(self):#次函数作用是通过开放一个接口形式对外开放进行调用
        print(‘人的名字是：%s，人的性别是：%s,人的年龄是：%s‘%(
            self.__name,#p.__name
            self.__sex,
            self.__age
        ))

#实列化
p=People(‘zhaosj‘,25,‘male‘)
print(p.__dict__)
p.tell_info()

运行结果：

类封装--后的属性方法设置以及修改方式

#!/usr/bin/python
# -*- coding:utf-8 -*-
# Author:zhaosj
#类的封装属性
class People:
    def __init__(self,name,age):
        self.__name=name  #__name代表封装了name
        self.__age=age

    #调取属性
    def tell_info(self): #次函数作用是通过开放一个接口形式对外开放进行调用
        print(‘人的名字是：%s，人的年龄是：%s‘%(
            self.__name,#p.__name
            self.__age
        ))
    #修改属性
    def set_info(self,x,y):
            self.__name=x
            self.__age=y

###########实列化###################
####修改前
p=People(‘zhaosj‘,25)
p.tell_info()
####修改后
p.set_info(‘jiangchao‘,23)
p.tell_info()

运行结果：

类封装--后的属性方法设置以及修改--if..判断修改的数据类型

isinstance：是不是

raise TabError：数据类型错误

#!/usr/bin/python
# -*- coding:utf-8 -*-
# Author:zhaosj
#类的封装属性
class People:
    def __init__(self,name,age):
        self.__name=name  #__name代表封装了name
        self.__age=age

    #调取属性
    def tell_info(self): #次函数作用是通过开放一个接口形式对外开放进行调用
        print(‘人的名字是：%s，人的年龄是：%s‘%(
            self.__name,#p.__name
            self.__age
        ))
    #修改属性
    def set_info(self,x,y):
        if not isinstance(x,str): #判断下，名字x是不是字符串类型
            raise TypeError(‘名字必须是字符串类型‘)#报错，类型错误
        if not isinstance(y,int): #判断下，年龄y是不是整形类型
            raise TabError(‘年龄必须是整数类型‘)

        self.__name=x
        self.__age=y

####实列化######
##修改前
p=People(‘zhaosj‘,25)
p.tell_info()
##修改后
p.set_info(‘jiangchao‘,23)
p.set_info(‘jiangchao‘,‘23‘)#设置年龄不是整型是字符串
p.tell_info()

运行结果：

类-封装--property（特殊函数）的使用

不是使用property

#!/usr/bin/python
# -*- coding:utf-8 -*-
# Author:zhaosj
class Foo:
    def test(self):
        print(‘from foo‘)

#实列化
f=Foo()
f.test()#加括号进行调用

运行结果：

使用property

#!/usr/bin/python
# -*- coding:utf-8 -*-
# Author:zhaosj
#property的使用
class Foo:
    @property
    def test(self):
        print(‘from foo‘)

f=Foo()
f.test

运行结果：