之前看的应该都算是基础知识, 然后今天听到类这个说法, 刚开始感觉还是非常高大上的, 但是慢慢看来, 其实用函数式编程也是能实现的, 但最终来说 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)
关于类就是这些, 确实是略叼, 明天继续, 迫不及待的感觉
Python 之旅的第 19 天(类的初识)
来源: http://www.bubuko.com/infodetail-3458862.html