码迷,mamicode.com
首页 > 编程语言 > 详细

Python-面向对象

时间:2017-11-04 11:21:51      阅读:211      评论:0      收藏:0      [点我收藏+]

标签:--   import   agg   call   面向对象的思想   并且   目的   level   修改   

一、引入面向对象

#游戏
#人狗大战
#人 、 狗
#人角色:攻击力 生命值 名字 等级
#狗角色:攻击力 生命值 名字 品种
def person(attack,life_value,name,level):
    def atk(dog_d):
        print(%s 打了 %s % (name, dog_d[name]))
        dog_d[life_value] -= attack
    person_dic = {attack:attack,
              life_value:life_value,
              name:name,
              level:level,
                  atk:atk}
    return person_dic

def dog(attack,life_value,name,level):
    def bite(person_d):
        print(%s 咬了 %s % (name, person_d[name]))
        person_d[life_value] -=attack
    dog_dic = {attack:attack,
              life_value:life_value,
              name:name,
              level:level,
               bite:bite}
    return dog_dic

alex = person(100,1000,alex,2)
alex2 = person(1001,10000,alex2,2)
egg = dog(200,2000,egon,10)
alex[atk](egg)
print(egg[life_value])

# 面向对象编程
# 对象 - 角色
#   alex
#   egg
# 类 :具有相同属性和方法的一类事物就是类
#   person
#   dog
# 对象和类的关系
# 对象是一个实实在在存在的事物,是独一无二的
# 类 是一个抽象的大致规范了一类事物的范围

二、初识面向对象和类

#def
#面向过程编程
    #固定的目的 固定的结果
    #从头到尾把要执行的步骤堆积出来就好了
#面向对象编程
    #有一个抽象的过程
    #上帝视角:结果不能预测
‘‘‘
class Person:
    rol = ‘人‘         #数据属性、静态属性
    country = ‘中国‘
    def attack(self):  #函数属性、动态属性、方法
        pass

# person 类 Person也是类名
print(callable(Person))
print(Person())   #对象
#一个类名加上括号就会返回一个对象
print(Person.rol)  #.属性名
Person.rol = ‘人类‘ #修改属性的值
print(Person.__dict__)  #不可以平时直接用的
#类也有一个属于自己的名称空间:静态属性和动态属性
print(Person.attack)
# print(Person.attack())  报错:没有self参数
‘‘‘

#类的定义
# class 类名:
#     静态属性 = ‘值‘
#     def 方法(self):
#         pass
#
# 对象 = 类名()
# 对象.静态属性
# 对象.方法 #可以调用不能执行



class Person:
    rol =          #数据属性、静态属性、类属性
    country = 中国
    def __init__(self,name,age,life_value): #初始化方法
        # self.__dict__[‘name‘] = name
        self.name = name       #属性、对象属性
        self.theage = age
        self.life_value = life_value
        self.aggr = 200
    def attack(self):  #函数属性、动态属性、方法
        #self只是一个形式参数,可以叫其他名字,但正常没人会这样
        #self是水性杨花,那个对象调这个方法,self就是那个对象
        print(attack方法被%s执行了%self.name)

# alex = Person(‘alex‘,38,2000)  #alex 对象
# print(alex.name)
# print(alex.theage)
# print(alex.life_value)
#类加上括号的过程:  #实例化
    #1.先创建了一个对象 self = {}
    #2.才执行初始化方法__init__,同时把创建的对象扔到了__init__参数里
# Person.rol
# alex.name = ‘alex‘   #给alex对象创建一个属性
# print(alex.name)     #查看alex的name属性
# alex.name = ‘Alexander‘ #修改alex的name属性
# print(alex.name)     #查看alex的name属性
# print(alex.__dict__[‘name‘])
# alex.__dict__[‘name‘] = ‘alex‘  #对象可以使用dict来修改属性的值
# print(alex.name)
# alex.age = 38
# print(alex.age)
# print(alex.__dict__)
# egg = Person()
# egg.name = ‘egon‘
# print(egg.name)
# print(alex.name)

#类 对象(实例) 实例化
#类是我们自己抽象出来的
#实例化 对象 = 类名()
#类经过实例化就产生了对象/实例

# alex = Person(‘alex‘,38,2000)  #alex 对象
# egg = Person(‘egon‘,18,1000)  #alex 对象
#真正使用方法的不是类而是对象
# Person.attack(alex)
# Person.attack(egg)
# alex.attack()  #==Person.attack(alex)
# egg.attack()    #==Person.attack(egg)

#类:静态属性 动态属性
#类可以调用静态属性
#类可以查看动态属性 却必须要带上具体的对象参数才能调用动态属性

#对象:可以拥有自己的对象属性,并且可以调用类中的方法

# 对象可以调用类的方法么
class Person:
    rol =          #数据属性、静态属性、类属性
    country = 中国
    def __init__(self,name,age,life_value): #初始化方法
        # self.__dict__[‘name‘] = name
        self.name = name       #属性、对象属性
        self.theage = age
        self.life_value = life_value

    def attack(self):  #函数属性、动态属性、方法
        #self只是一个形式参数,可以叫其他名字,但正常没人会这样
        #self是水性杨花,那个对象调这个方法,self就是那个对象
        print(attack方法被%s执行了%self.name)

# egg = Person(‘egon‘,18,1000)
# alex = Person(‘alex‘,38,2000)
# print(alex.rol)
# print(alex.country)
# egg.aggr = 200
# alex.country = ‘印度‘
# print(alex.country)
# print(egg.country)

#类有属于自己的命名空间
#对象也是
#类不可以调用对象的属性
#但是对象在寻找属性的时候,是先找自己名称空间的,找不到就找类名称空间里的

class Dog:
    def __init__(self,name,type):
        self.name = name
        self.dog_type = type
        self.life_value = 2000

    def bite(self,name):
        print(%s咬了%s%(self.name,name))

旺财 = Dog(旺财,土狗)
#使用init去进行属性的初识化
#1.规范所有的对象都拥有一些基础的属性
#2.方便

# print(旺财.name)
# print(旺财.dog_type)
# print(旺财.life_value)
# 旺财.bite(‘alex‘)   #Dog.bite(旺财,‘alex‘)
#__init__再讲

#再讲类中的方法

#练习
#创建一个类,实例化对象,需要做一个计数器,这个类每实例化一次,计数器加一
#所有的对象共享这个计数个数
# class Dog:
#     counter = 0
#     def __init__(self,name,type):
#         self.name = name
#         self.dog_type = type
#         self.life_value = 2000
#         Dog.counter += 1
#
# 史努比 = Dog(‘史努比‘,‘大白狗‘)
# 史努比2 = Dog(‘史努比‘,‘大白狗‘)
# print(史努比.counter)
# print(史努比2.counter)

#练习2
#创建一个圆形类
#有一个属性:圆的半径
#提供两个方法:计算圆面积 、计算圆周长
from math import pi
class Circle:
    def __init__(self,r):
        self.r = r

    def area(self):
        return self.r**2*pi

    def perimeter(self):
        return 2*pi*self.r

c1 = Circle(5)
print(c1.area())
print(c1.perimeter())
c2 = Circle(20)
print(c2.area())
print(c2.perimeter())

# 在终端输出如下信息
#
# 小明,10岁,男,上山去砍柴
# 小明,10岁,男,开车去东北
# 小明,10岁,男,最爱大保健
# 老李,90岁,男,上山去砍柴
# 老李,90岁,男,开车去东北
# 老李,90岁,男,最爱大保健

#两个人物 --》 人类
#姓名 年龄 性别   ---》属性
#行为  --> 方法
class Person:
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex

    def shangshan(self):
        print(%s,%s岁,%s,上山去砍柴%(self.name,self.age,self.sex))

xiaoming = Person(小明,10,)
old_li = Person(老李,90,)
xiaoming.shangshan()
old_li.shangshan()

#面向过程和面向对象编程
#思路1 从只关心某一个对象变成抽象规范了一类对象
#思路2 当多个函数都需要传递同样的多个参数的时候,考虑面向对象的思想

#面向对象作业
#1.正方形类

三、面向对象之间的交互

#人狗大战
class Dog:
    def __init__(self,name,type,aggr):
        self.name = name
        self.dog_type = type
        self.aggr = aggr
        self.life_value = 2000

    def bite(self,person_obj):  #self==egg,person_obj=alex
        #属性的变化
        print(%s咬了%s%(self.name,person_obj.name))
        person_obj.life_value -= self.aggr

class Person:
    rol =          #数据属性、静态属性、类属性
    country = 中国
    def __init__(self,name,age,life_value): #初始化方法
        self.name = name       #属性、对象属性
        self.theage = age
        self.life_value = life_value
        self.aggr = 1

    def attack(self,dog_obj):  #函数属性、动态属性、方法
        print(%s攻击了%s%(self.name,dog_obj.name))
        dog_obj.life_value -= self.aggr

alex = Person(alex,38,500)
egg = Dog(egon,二哈,20)
print(alex.life_value)
egg.bite(alex)   #Dog.bite(egg,alex)
print(alex.life_value)
print(egg.life_value)
alex.attack(egg)
print(egg.life_value)

#类的定义
#对象
#实例化
#交互

四、组合

#组合 —— 面向对象的一种功能
#什么有什么的关系
#每个人都有生日,生日是由年月日组成
class Birthday:
    def __init__(self,year,month,day):
        self.year = year
        self.month = month
        self.day = day

class Person:
    def __init__(self,name):
        self.name = name
        # self.birthday = birth

alex_birth = Birthday(1968,1,1)
print(alex_birth.year)
alex = Person(alex)
alex.birth = alex_birth   #Birthday类的对象是Alex的birth属性
print(alex.birth.year)
#组合 - 两个类之间的事儿
#描述的是一种所属关系

#组合例二:
#人狗大战
#
#武器:伤害、属性
class Weapon:
    def __init__(self,aggr,name,money):
        self.aggr = aggr
        self.name = name
        self.money = money

    def kill(self,dog_obj):
        print(%s武器暴击%s,伤害%s%(self.name,dog_obj.name,self.aggr))
        dog_obj.life_value -= self.aggr

class Dog:
    def __init__(self, name, type, aggr):
        self.name = name
        self.dog_type = type
        self.aggr = aggr
        self.life_value = 2000

    def bite(self, person_obj):  # self==egg,person_obj=alex
        # 属性的变化
        print(%s咬了%s % (self.name, person_obj.name))
        person_obj.life_value -= self.aggr

class Person:
    rol =   # 数据属性、静态属性、类属性
    country = 中国

    def __init__(self, name, age, life_value):  # 初始化方法
        self.name = name  # 属性、对象属性
        self.theage = age
        self.life_value = life_value
        self.aggr = 1

    def attack(self, dog_obj):  # 函数属性、动态属性、方法
        print(%s攻击了%s % (self.name, dog_obj.name))
        dog_obj.life_value -= self.aggr

alex = Person(alex, 38, 500)
egg = Dog(egon, 二哈, 20)
alex.money = 2000
knife = Weapon(200,杀猪刀,1900)
if alex.money > knife.money:
    alex.money -= knife.money
    alex.weapon = knife

print(egg.life_value)
alex.weapon.kill(egg)
print(egg.life_value)

五、继承

#继承 —— 面向对象的三大特性之一
#想产生继承关系,必然是两个类以上
#继承表达的是一种 什么 是 什么的关系
# class Animal:
#     def __init__(self,name,aggr,life_value):
#         self.name = name
#         self.aggr = aggr
#         self.life_value = life_value
#
#     def func(self):
#         print(self.name)
#
# class Foo:
#     def func(self):
#         print(self.name)
#
# class Dog(Animal,Foo):
#     def __init__(self,name,aggr,life_value,type):
#         #Animal.__init__(self,name,aggr,life_value)
#         super().__init__(name,aggr,life_value)
#         self.dogtype = type    #派生属性
#
#     def bite(self):
#         #派生方法
#         Animal.func(self)
#         super().func()
#
# class Person(Animal):
#     def __init__(self,name,aggr,life_value,money):
#         Animal.__init__(self,name,aggr,life_value)
#         self.money = money
#
#     def attack(self):pass

# egg = Dog(‘egon‘,100,2000,‘金毛‘)
# egg.bite()
# alex = Person(‘alex‘,100,2000,2000)
# # print(egg.__dict__)
# print(alex.__dict__)
# alex.func()
#Dog继承了Animal
#父类 :Animal
#子类 :Dog

#一个类可以有多个子类
#子类调用方法;先调自己的,自己没有就调用父类的
#写继承的过程:是先抽象,后继承
#派生:父类没有的属性和方法在子类中就是派生出来的


#多继承
#一个类可以拥有多个父类
# class A:
#     pass
#
# class B:
#     pass
#
# class C(A,B):
#     pass
#
# print(A.__base__)

#object  类祖宗
#如果一个类有指定的父类,那么他的父类就是被指定的那个
#如果一个类没有指定的父类,那么他的父类就是object
#凡是继承了object类的类都是新式类
#python3里所有的类都是新式类
#新式类调用父类的方法:
    # 指名道姓:父类名.方法名(self,aggr1...);   ---->经典类
    # super关键字:super().方法名(aggr1,...)    ----> 只适用于新式类


#教授类
    #属性 年龄 姓名
    #行为 讲课 写专利
#教师类:
    #属性 年龄 姓名
    #行为 讲课
#教授是教师
#教师是父类/基类
#教授是子类

# class Teacher:
#     def __init__(self,name,age,salary):
#         self.name = name
#         self.age = age
#         self.salary = salary
#
#     def teach(self):
#         print(‘%s正在讲课‘%self.name)
#
# class Professor(Teacher):
#     def print_write(self):
#         print(‘%s正在写专利‘%self.name)
#
# egon = Professor(‘egon‘,18,20000)
# print(egon.__dict__)
# print(egon.salary)
# egon.teach()
# egon.print_write()

#
# class Teacher:
#     def __init__(self,name,age,salary):
#         self.name = name
#         self.age = age
#         self.salary = salary
#         self.teach()
#
#     def teach(self):
#         print(‘%s正在讲课‘%self.name)
#
# class Professor(Teacher):
#     def print_write(self):
#         print(‘%s正在写专利‘%self.name)
#
#     def teach(self):
#         # super().teach()
#         print(‘教授%s正在讲课‘%self.name)
#
# egon = Professor(‘egon‘,18,20000)
# egon.teach()
# print(egon.__dict__)
# print(egon.salary)
# egon.teach()
# egon.print_write()

#新式类多继承, 执行父类的方法是 广度优先
class A:
    def func(self):
        print(A)

class B(A):pass
    # def func(self):
    #     print(‘B‘)

class C(A):
    def func(self):
        print(C)

class D(B):pass
    # def func(self):
    #     print(‘D‘)

class E(C):
    def func(self):
        print(E)

class F(D,E):pass
    # def func(self):
    #     print(‘F‘)

# f = F()
# f.func()

# 广度优先
print(F.mro())

#经典类和新式类的区别
#1、关于基类 : 新式类默认继承object
#2、关于在子类中执行父类的方法:新式类有super,经典类只能用指名道姓
#3、关于多继承:新式类 广度优先(mro),经典类:深度优先
#在py3没有经典类;在py2里经典类和新式类共存

#关于继承:
#子类继承父类
#子类的对象调用方法,优先在子类中找,如果子类中有,就执行子类中的
#                                 如果子类中没有,就执行父类的
                                    #多个父类以广度优先为准

#关注self到底是哪个类的实例化

六、pickle

class Person:
    rol =   # 数据属性、静态属性、类属性
    country = 中国

    def __init__(self, name, age, life_value):  # 初始化方法
        self.name = name  # 属性、对象属性
        self.theage = age
        self.life_value = life_value
        self.aggr = 1

    def attack(self, dog_obj):  # 函数属性、动态属性、方法
        print(%s攻击了%s % (self.name, dog_obj.name))
        dog_obj.life_value -= self.aggr

class Weapon:
    def __init__(self,aggr,name,money):
        self.aggr = aggr
        self.name = name
        self.money = money

    def kill(self,dog_obj):
        print(%s武器暴击%s,伤害%s%(self.name,dog_obj.name,self.aggr))
        dog_obj.life_value -= self.aggr
alex = Person(alex, 38, 500)
knife = Weapon(200,杀猪刀,1900)
alex.weapon = knife
import pickle
ret = pickle.dumps(alex)
print(ret)

pickle.loads

 

Python-面向对象

标签:--   import   agg   call   面向对象的思想   并且   目的   level   修改   

原文地址:http://www.cnblogs.com/guoxiangqian/p/7782293.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!