Python：面向对象初识

 面向对象初识

什么是类？

　　类即类别、种类，是面向对象设计最重要的概念，对象是特征与技能的结合体，而类则是一系列对象相似的特征与技能的结合体

那么问题来了，先有的一个个具体存在的对象（比如一个具体存在的人），还是先有的人类这个概念，这个问题需要分两种情况去看

在现实世界中：先有对象，再有类

　　世界上肯定是先出现各种各样的实际存在的物体，然后随着人类文明的发展，人类站在不同的角度总结出了不同的种类，如人类、

动物类、植物类等概念也就说，对象是具体的存在，而类仅仅只是一个概念，并不真实存在

 

 

什么是对象？
　　对象，就是基于类而创建的一个具体的存在事物

 

利用嵌套函数的方式实现面向对象

实例1：

def dog(name,sex,type):
    def init(name,sex,type):
        dog1={
            'name':name,
            'sex':sex,
            'type':type,
            'jiao':jiao,
            'chis':chis,
        }
        return dog1
    def jiao(dog):
        print('一只狗[%s],在叫汪汪汪' %dog['name'])
    def chis(dog):
        print('一只狗[%s],在吃屎' %dog['name'])
    return init(name,sex,type)
d1=dog('lala','man','tesla')
d2=dog('bobi','母','te1')
d1['jiao'](d1)
d2['chis'](d2)

 

实例2

def people(name,sex,age):
    def init(name,sex,age):
        human={
            'name':name,
            'sex':sex,
            'age':age,
            'say':say,
            'dead':dead,
        }
        return human
    def say(xxx):
        print('Human %s sex:%s 正在说话' %(xxx['name'],xxx['sex']))

    def dead(xxx):
        print('Human %s age:%s 已经死了' %(xxx['name'],xxx['age']))
    return  init(name,sex,age)
p1=people('亚瑟','男','40')
p2=people('大鸡','女','19')
p1['say'](p1)
p2['dead'](p2)

由上面两个实例可以看出,面向对象设计,并不仅仅是通过class定义一个类然后生成实例,才叫做面向对象。

 

Python中的类

实例1

class Person:  # class 关键字，定义了一个类
    '''
    类里面的所有内容
    '''
    animal = '高级动物'  # 静态变量
    soup = '有思想'     # 静态变量

    def __init__(self,name,sex,eye,high,weight,):  # 构造方法,每次实例一个对象都会执行构造方法

        self.eye = eye  # 属性
        self.name = name
        self.sex = sex
        self.high = high
        self.weight = weight
        print(666)

    def work(self):    #动态变量，动态方法，方法
        print(self)
        # self.job = 'IT'
        print('人会工作....')

我们就通过这个类的实例来学习下，Python中关于类的操作

 

 类如何调用查看静态变量，动态变量

类操作静态变量有两种方式：

1，类名.__dict__方法  只能查看,不能增删改。
print(Person.__dict__)
print(Person.__dict__['animal'])    
Person.__dict__['name'] = 'alex'       #这样是使用会报错

2，类名.变量名  可增删改查
print(Person.animal)
print(Person.soup)                      #查看
Person.kind = '有性格'                   #增加
Person.animal = '低等动物'               #修改
del Person.kind                         #删除

一般你想查询全部的静态变量时，用__dict__ 其他全部都用类名.变量名。

 

类操作方法(动态变量)有两种方式：

1，类名.__dict__[方法名]()
print(Person.__dict__['work'](11))

2，类名.方法名
Person.work(11)
类操作方法：类名.方法名()
只要创建一个类，里面的内容就已经加载到内存。

 

创建对象

类名() 实例化一个对象。实例化对象：类名()过程就叫做实例化。
p1 = Person() # p1 对象
p2 = Person()

只要实例化一个对象，自动触发__init___
内部进行三步：
　　1，实例化一个对象，在内存中产生一个对象空间。
　　2，自动执行init方法，并将这个空间对象。 <__main__.Person object at 0x0000000001F5ABE0> 传给self
　　3，通过构造方法里的代码给空间对象添加一些属性，并返回给对象。

 

对象如何调用查看静态变量，动态变量，属性

对象操作属性变量有三种方式：

1,对象.__dict__方法  只能查看,不能增删改。
print(p1.__dict__)

2,对象.变量名  可增删改查
print(p1.name)
print(p1.eye)
p1.color = '黄皮肤'
print(p1.color)
print(p1, type(p1))

3,可以访问类的静态变量
print(p1.__dict__)
print(p1.animal)
print(p1.soup)

# 一般你想查询全部的静态变量时，用__dict__ 其他全部都用类名.变量名。

 

对象操作方法有两种方式：

1,对象.方法名()
p1.work()
print(p1)
print(p1.__dict__)

2,类名.方法名(对象)
Person.work(111)
Person.work(p1)

 

关于类空间与对象空间

通过实例化对象查找属性，先从对象空间找，没有则通过类对象指针从 类空间找。

 

组合

组合：给一个类对象的属性 封装 另一个类的对象。

#!/usr/bin/env python
# -*- coding:utf-8 -*-
#组合：给一个类对象的属性 封装 另一个类的对象。

class Game_person:
    def __init__(self,nickname,sex,hp,ad):
        self.nickname = nickname
        self.sex = sex
        self.hp = hp
        self.ad = ad
    def attack(self,p):
        p.hp -= self.ad
        print('%s攻击了%s,%s还剩%s血量'%(self.nickname,p.nickname,p.nickname,p.hp))

    def weapon_attack(self,武器):
        self.武器 = 武器 #斧子对象

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

    def fight(self,p1,p2):
        p2.hp -= self.ad
        print('%s使用%s打了%s%s血,%s还剩%s滴血'\
              %(p1.nickname,self.name,p2.nickname,self.ad,p2.nickname,p2.hp))

ts = Game_person('泰森','男',200,50)
barry = Game_person('太白','男',100,10)
fuzi = Weapon('斧子',60)
# wea.fight(barry,ts) 这样写不好,主体应该是人
# ts.attack(barry)
# barry.attack(ts)
barry.weapon_attack(fuzi)    #将fuzi对象传给了weapon_attack方法
# barry对象调用weapon_attack方法，
# 方法执行的是将斧子对象wea封装到barry对象的属性中、
# barry.武器 相当于 wea
barry.武器.fight(barry,ts)

 

转载于:https://www.cnblogs.com/bailo/p/9193236.html