Python之面向对象

　　面向过程

　　事例:两个人一天干以下几件事：

　　1. 张三: 起床---吃饭---工作---吃饭---工作---吃饭---工作---回家---睡觉

　　2. 李四: 起床---吃饭---学习---吃饭---学习---回家---玩耍---睡觉

#cat 面向过程.py
def get_up(name):
    print("{}起床".format(name))

def eat(name):
    print("{}吃饭".format(name))

def go_to_work(name):
    print("{}工作中".format(name))

def go_to_school(name):
    print("{}学习中".format(name))

def go_to_play(name):
    print("{}玩耍中".format(name))

def go_home(name):
    print("{}回家".format(name))

def go_to_bed(name):
    print("{}睡觉".format(name))

get_up("zhangsan")
eat("zhangsan")
go_to_work("zhangsan")
go_to_school("zhangsan")
go_to_play("zhangsan")
go_home("zhangsan")
go_to_bed("zhangsan")

　　类与对象

　　类是总结事物特征的抽象概念，是创建对象的模板。对象是安装类来具体出来的实物

　　举例说明

 　　玩具模型就是类

　　具体生产出来的玩具就是对象

　　类就是一个模板，对象是通过模板创建出来的具体的实物

　　类的构成

　　类的名称：类名

　　类的属性：一组参数数据

　　类的方法：操作的方式或行为

　　如：为人设计一个类

　　名称： People

　　属性：name,sex,age,weight,height等

　　方法：eat,drink,walk,run

　　类的创建

class People(object): # 创建类，使用驼峰式命名
    pass

　　创建对象 给对象附加属性

p1 = People()
p2 = People()
# 给对象加属性，不是给类加属性
 p1.name = "张三"
p1.sex = "男"

p2.name = "李四"
p2.sex = "女"

　　以上是直接给对象加属性，非给类加属性

　　给类加属性

class People(object): # 创建类，使用驼峰式命名
    def __init__(self, name, sex):  # 定义类的属性
        self.name = name
        self.sex = sex

p1 = People("张三", "男")   # 通过类创建对象，即类的实例化 p1 = self p1.name="张三" sex="男"
p2 = People("李四", "女")

　　给类加方法

class People(object): # 创建类，使用驼峰式命名
    def __init__(self, name, sex):  # 定义类的属性
        self.name = name
        self.sex = sex

    def info(self): # 定义类的方法
        print(self.name, self.sex)

p1 = People("张三", "男")   # 通过类创建对象，即类的实例化 p1 = self p1.name="张三" sex="男"
p2 = People("李四", "女")

print(id(p1))   # 两个对象的内存空间不一样，所以是两个不同的对象
print(id(p2))

# 给对象加属性，不是给类加属性
# p1.name = "张三"
# p1.sex = "男"
#
# p2.name = "李四"
# p2.sex = "女"

p1.info()   # 调用类的方法打印姓名和性别
p2.info()

　　类的变量

　　示例

#cat 类的变量.py
class People(object):
    name = "haha"    # 类变量

    def __init__(self, name, sex):
        self.name = name    # 示例变量
        self.sex = sex

    def info(self):
        print(self.name, self.sex)

p1 = People("zhangsan", "man")
print(People.name)   # 可以打印类变量的值为haha
print(p1.name)       # 类变量与实例变量同名，实例变量优先于类变量 值为zhangsan 

　　注意：类变量,实例1,实例2都是独立的内存空间，修改互不影响

　　示例

# cat 类的变量2.py
class People(object):
    abc = "haha"    # 类变量

    def __init__(self, name, sex):
        self.name = name    # 实例变量
        self.sex = sex

    def info(self):
        print(self.name, self.sex)

p1 = People("zhangsan", "man")
p2 = People("lisi", "women")

p1.abc = "hehe" # 对p1实例的类变量赋值hehe
print(p1.abc)   # 结果为赋值后的hehe
print(p2.abc)   # 结果仍然为haha说明修改p1不影响p2
print(People.abc)   # 结果仍然为haha,说明修改p1也不影响类变量本身

　　__str__和__del__

# cat 面向对象str和del.py
class Hero(object):
    def __init__(self, name):
        self.name = name

    def __str__(self):  # print对象时调用__str__
        return "我叫{}，我为自己代言".format(self.name)

    def __del__(self):
        print("......我{}还会回来的......".format(self.name))

hero1 = Hero("亚瑟")
hero2 = Hero("后羿")

print(hero1)    # 执行print调用__str__
# 我叫亚瑟，我为自己代言
print(hero2)
# 我叫后羿，我为自己代言

# 结束以后执行__del__输出以下
# ......我亚瑟还会回来的......
# ......我后羿还会回来的......
del hero1
del hero2

print("="*30)

　　小结

 　　对象销毁包括执行结束了或者是删除了对象

　　私有属性和私有方法

　　一般情况下私有属性和私有方法是不对外公开的，只能在类的内部调用，往往用来做内部的事情，起到安全的作用

# cat 私有属性和私有方法.py
class People(object):
    __country = "china"    # 前面加上__ 就成了私有类属性，不能被外部直接调用

    def __init__(self, name, sex):
        self.name = name
        self.__sex = sex    # 前面加上__就成了私有对象属性,不能被外部调用

    def __info(self):   # 前面加上__成了私有方法，不能被外部调用
        print(self.name, self.sex)

p1 = People("zhangsan", "man")

# print(p1.sex)
# print(p1.__sex)
# print(p1.country)
# print(p1.__country)
# p1.info()
# p1.__info()
# 以上取消注释执行均会报错 类似报错 'People' object has no attribute '__info'

　　示例: 如果类的外部需要调用到私有属性的值，可以对私有属性单独定义一个类的方法，让实例通过调用此方法来调用私有属性(私有方法同理)

　　示例如下

# cat 私有属性和私有方法2.py
class People(object):
    __country = "china"    # 前面加上__ 就成了私有类属性，不能被外部直接调用

    def __init__(self, name, sex):
        self.name = name
        self.__sex = sex    # 前面加上__就成了私有对象属性,不能被外部调用

    def __info(self):   # 前面加上__成了私有方法，不能被外部调用
        print(self.name, self.__sex)

    def show_country(self): # 内部调用私有类属性
        print(self.__country)

    def show_sex(self): # 内部调用私有对象属性
        print(self.__sex)

    def show_info(self):
        return People.__info(self)

p1 = People("zhangsan", "man")
p1.show_country()   # 调用非私有方法即相当于在类内部调用私有属性
p1.show_sex()
p1.show_info()

　　继承

　　继承的作用: 减少代码的冗余,便于功能的升级（原有的功能进行完善）与扩展（原没有的功能进行添加）

　　继承示例

# cat 继承.py
class People(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def eat(self):
        print("come to eat,{}".format(self.name))

    def drink(self):
        print("come to drink,{}".format(self.name))

class Man(People):  # 表示Man类继承父类 People
    def work(self): # 类Man自定义的方法，Woman不能调用此方法
        print("come to work，{}".format(self.name))

class Woman(People): # 表示Woman类继承父类 People
    pass

m1 = Man("zhansan", 16)
m1.eat()    # 继承了父类，可以调用父类的方法
m1.drink()
m1.work()

m2 = Woman("lisi", 18)
m2.eat()
m2.drink()

　　方法重写

# cat 在子类重写父类方法.py
class People(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def eat(self):
        print("come to eat,{}".format(self.name))

    def drink(self):
        print("come to drink,{}".format(self.name))

class Man(People):  # 表示Man类继承父类 People
    def drink(self):
        if self.age >= 18:
            print("you can drink")
        else:
            print("you can't drink")

class Woman(People): # 表示Woman类继承父类 People
    pass

m1 = Man("zhansan", 18)
m1.eat()
m1.drink()  # 优先调用子类的方法 所以会根据输入的年龄大小分别输出you can drink或者you can't drink不会调用父类People的方法

　　子类重新创建属性

# cat 子类重新构造属性.py
class People(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def eat(self):
        print("come to eat,{}".format(self.name))

    def drink(self):
        print("come to drink,{}".format(self.name))


class Woman(People): # 表示Woman类继承父类 People
    def __init__(self, name, age, bra_size):    # 子类新加一个属性，需要和原父类属性对应
        People.__init__(self, name, age)    # 经典写法;换成super(Woman,self).__init__(name, age)也一样（新式类写法）
        # super(Woman, self).__init__(name, age)
        self.bra_size = bra_size

    def info(self):
        print("姓名 {} 年龄 {} 罩杯 {}".format(self.name, self.age, self.bra_size))

w1 = Woman("lisi", 18, "D")
w1.eat()
w1.info()

　　多层继承

　　类可以多层继承，下一级子类拥有上一层父类的属性和方法

　　示例

# cat 多层继承一.py
class Grandfather():
    def house(self):
        print("a big hose!")

class Father(Grandfather):
    def car(self):
        print("a cool car!")

class Child(Father):
    pass

p1 = Child()    # Child继承了Father Father继承了Grandfather 所以Child也有了Grandfather里的方法
p1.house()

　　示例二

# cat 多层继承二.py
class People():
    def __init__(self, name, sex):
        self.name = name
        self.sex = sex
class Love(People):
    def fall_in_love(self,obj):
        if self.sex == "男":
            print("{}向{}求婚".format(self.name,obj.name))
        elif self.sex == "女":
            print("{}要给{}生猴子".format(self.name,obj.name))
        else:
            print("性别输入有误")
class Man(Love):
    pass
class Woman(Love):
    pass
m1=Man("张三","男")
w1=Woman("李四","女")
m1.fall_in_love(w1)
w1.fall_in_love(m1)

　　多继承

　　一个子类可以继承多个父类

　　示例

# cat 多继承一.py
class Father(object):
    def sing(self):
        print("can sing")

class Mother(object):
    def dance(self):
        print("can dance")

class Child(Father, Mother):    # 子类继承了两个父类
    pass

p1 = Child()
p1.sing()   # 同时拥有两个父类的方法
p1.dance()

　　多态

 　　多态：一类事物有多种形态。例如水有水蒸气，液态水，冰等多种状态

　　python变量本身是没有类型的，变量类型是由赋值觉得的。可以是int，也可以是str，这其实就是一种多态。

 　　示例

# cat 多态1.py
class Animal(object):
    def jiao(self):
       pass

class Dog(Animal):
    def jiao(self):
        print("wang wang ...")

class Cat(Animal):
    def jiao(self):
        print("miao miao ...")

d1 = Dog()
c1 = Cat()

d1.jiao()   # 对象接类的方法调用，结果是狗叫
c1.jiao()   # 对象接类的方法调用，结果是猫叫

　　统一调用方法

# cat 多态二.py
class Animal(object):
    def jiao(self):
        pass

class Dog(Animal):
    def jiao(self):
        print("wang wang ...")

class Cat(Animal):
    def jiao(self):
        print("miao miao ...")

def jiao(obj):
    obj.jiao()

d1 = Dog()
c1 = Cat()

jiao(d1)    # 统一调用方法，不管对象是狗还是猫，调用方法是一致的
jiao(c1)