Python之旅的第19天（类的初识）

之前看的应该都算是基础知识，然后今天听到类这个说法，刚开始感觉还是非常高大上的，但是慢慢看来，其实用函数式编程也是能实现的，但最终来说class还是牛逼的，那么今天就记录一下自己在引入类过程的认识吧。

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

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

在程序中：务必保证先定义类，后产生对象

下面先记录一下定义一个狗类的过程吧

# 首先的思路是狗狗都有什么功能
# 然后是狗有哪些属性
# dog1 = {'name' : 'wangcai',
#        'xingbie' : 'gong',
#        'type' : 'tianyuan'
#         }
# 下面是狗的功能
# def jiao(dog):
#     print('%s %s正在汪汪叫'%(dog['type'],dog['name']))
#
# def chishi(dog):
#     print('%s %s正在吃屎'%(dog['type'],dog['name']))
# 此时有一个人乱入了
# person_1 = {'name':'xiaoming',
#             'xingbie':'nan',
#             'type':'human'}
# jiao(dog1)
# chishi(dog1)
# 这样看来狗的功能实现了，但是这个时候xiaoming乱入也能调用方法
# jiao(person_1)
# chishi(person_1)
# 所以这样其实并没有达到最终效果
# 接下来我们使用变量的作用域来实现避免xiaoming乱入的情况

def dog(name,xingbie,type):
    def init(name,xingbie,type):
        dog = {'name':name,
               'xingbie':xingbie,
               'type':type,
               'chishi':chishi,
               'jiao':jiao
               }
        return dog
#此时开始设置狗的功能
    def jiao(dog):
        print('%s %s正在汪汪叫'%(dog['type'],dog['name']))

    def chishi(dog):
        print('%s %s正在吃屎'%(dog['type'],dog['name']))

    return init(name,xingbie,type)

d1 = dog('wangcai','gong','tianyuan')
print(d1)
#{'chishi': <function dog.<locals>.chishi at 0x000001F1AA394510>,
# 'xingbie': 'gong', 'name': 'wangcai',
# 'jiao': <function dog.<locals>.jiao at 0x000001F1AA394488>, 'type': 'tianyuan'}
# 这个时候就得到了一个字典，那么如何开始调用呢
d1['jiao'](d1)
d1['chishi'](d1)
# 这样我们就通过了字典的形式条用了在一开始的init函数中最后两个键值对中对应的函数
# 这个时候你再用person1，好像就不行了吧，dog函数把狗特有的功能放在dog函数作用域里面了
# 你如果传输xiaoming就有问题了o

# 然后紧接着是一个函数编辑类的练习
def school(name,addr,type):
    def init(name, addr, type):
        sch = {
            'name': name,
            'addr': addr,
            'type': type,
            'kao_shi': kao_shi,
            'zhao_sheng': zhao_sheng,
        }
        return sch
    def kao_shi(school):
        print('%s 学校正在考试' %school['name'])
    def zhao_sheng(school):
        print('%s %s 正在招生' %(school['type'],school['name']))
    return  init(name,addr,type)

s1=school('oldboy','沙河','私立学校')
print(s1)
print(s1['name'])

s1['zhao_sheng'](s1)

s2=school('清华','北京','公立学校')

print(s2)
print(s2['name'],s2['addr'],s2['type'])
s2['zhao_sheng'](s2)

#下面就到了引入神奇的类的时候了，还是以刚才的狗子为例
class Dog:
    def __init__(self,name,gender,type):
        self.name=name
        self.gender=gender
        self.type=type

    def bark(self):
        print('一条名字为[%s]的[%s],狂吠不止' %(self.name,self.type))

    def yao_ren(self):
        print('[%s]正在咬人' %(self.name))

    def chi_shi(self):
        print('[%s]正在吃屎' %(self.type))


dog1=Dog('alex','female','京巴')
print(dog1.__dict__)
#这里需要注意，通过类调用的__dict__方法后，会得到一个关于类属性的字典
#这里我们调用法法时候就可以通过字典的形式调用

# dog2=Dog('wangcai','female','腊肠')
# dog3=Dog('dahuang','female','藏獒')
#比如这里的dog1.bark()
dog1.bark()
dog1.__dict__[bark]()

# dog2.yao_ren()
# dog3.chi_shi()

这几句没怎么看懂，放着继续理解一下，最近好像有点进入不求甚解的状态了

1. 站的角度不同，定义出的类是截然不同的

2. 现实中的类并不完全等于程序中的类，比如现实中的公司类，在程序中有时需要拆分成部门类，业务类...... 

3. 有时为了编程需求，程序中也可能会定义现实中不存在的类，比如策略类，现实中并不存在，但是在程序中却是一个很常见的类

下面是引用的别人测试，感觉不是很有难度，现在貌似进入新发修炼阶段，基本功虽然不怎么扎实，但是心法不学，没法突破

#方式一、为对象初始化自己独有的特征
class People:
    country='China'
    x=1
    def run(self):
        print('----->', self)

# 实例化出三个空对象
obj1=People()
obj2=People()
obj3=People()

# 为对象定制自己独有的特征
obj1.name='egon'
obj1.age=18
obj1.sex='male'

obj2.name='lxx'
obj2.age=38
obj2.sex='female'

obj3.name='alex'
obj3.age=38
obj3.sex='female'

# print(obj1.__dict__)
# print(obj2.__dict__)
# print(obj3.__dict__)
# print(People.__dict__)





#方式二、为对象初始化自己独有的特征
class People:
    country='China'
    x=1
    def run(self):
        print('----->', self)

# 实例化出三个空对象
obj1=People()
obj2=People()
obj3=People()

# 为对象定制自己独有的特征
def chu_shi_hua(obj, x, y, z): #obj=obj1,x='egon',y=18,z='male'
    obj.name = x
    obj.age = y
    obj.sex = z

chu_shi_hua(obj1,'egon',18,'male')
chu_shi_hua(obj2,'lxx',38,'female')
chu_shi_hua(obj3,'alex',38,'female')





#方式三、为对象初始化自己独有的特征
class People:
    country='China'
    x=1

    def chu_shi_hua(obj, x, y, z): #obj=obj1,x='egon',y=18,z='male'
        obj.name = x
        obj.age = y
        obj.sex = z

    def run(self):
        print('----->', self)


obj1=People()
# print(People.chu_shi_hua)
People.chu_shi_hua(obj1,'egon',18,'male')

obj2=People()
People.chu_shi_hua(obj2,'lxx',38,'female')

obj3=People()
People.chu_shi_hua(obj3,'alex',38,'female')




# 方式四、为对象初始化自己独有的特征
class People:
    country='China'
    x=1

    def __init__(obj, x, y, z): #obj=obj1,x='egon',y=18,z='male'
        obj.name = x
        obj.age = y
        obj.sex = z

    def run(self):
        print('----->', self)

obj1=People('egon',18,'male') #People.__init__(obj1,'egon',18,'male')
obj2=People('lxx',38,'female') #People.__init__(obj2,'lxx',38,'female')
obj3=People('alex',38,'female') #People.__init__(obj3,'alex',38,'female')


# __init__方法
# 强调：
#   1、该方法内可以有任意的python代码
#   2、一定不能有返回值
class People:
    country='China'
    x=1

    def __init__(obj, name, age, sex): #obj=obj1,x='egon',y=18,z='male'
        # if type(name) is not str:
        #     raise TypeError('名字必须是字符串类型')
        obj.name = name
        obj.age = age
        obj.sex = sex


    def run(self):
        print('----->', self)


# obj1=People('egon',18,'male')
obj1=People(3537,18,'male')

# print(obj1.run)
# obj1.run() #People.run(obj1)
# print(People.run)

关于类就是这些，确实是略叼，明天继续，迫不及待的感觉