1、编程范式
- 编程是 程序 员 用特定的语法+数据结构+算法 组成的代码来告诉计算机如何执行任务的过程 。
- 两种最重要的编程范式分别是
- 面向过程编程
- 面向对象编程
2、面向过程编程(Procedural Programming)
"""实现一个用户注册功能""" # 1.用户输入 # 2.验证是否符合标准 # 3.注册 def enter(): username = input('>:').strip() password = input('>:').strip() return { 'username': username, 'password': password } def check(user_info): is_valid = True if len(user_info['username']) == 0: print('用户名不能为空') is_valid = False if len(user_info['password']) < 6: print('密码不能少于6个字符') is_valid = False return { 'is_valid': is_valid, 'user_info': user_info } def register(check_info): if check_info['is_valid']: import json with open('users.txt', 'w', encoding='utf-8') as f: json.dump(check_info['user_info'], f) print('注册成功') def main(): user_info = enter() check_info = check(user_info) register(check_info) if __name__ == '__main__': main()
如果添加一个新功能：邮箱验证
- 可扩展性差
3、面向对象编程
4.定义类与实例化出对象
""" 类就是一系列对象相似的特征与技能的结合体 强调：站在不同的角度，得到的分类是不一样的 在现实世界中：一定先有对象，后有类 在程序中，一定先定义类，后强调类来产生对象 站在路飞city的角度，大家都是学生 在现实世界中： 对象1：张三 特征： 学校='luffycity' 名字='张三' 性别='女' 年龄=18 技能： 学习 吃饭 睡觉 对象2：李四 特征： 学校='luffycity' 名字='李四' 性别='男' 年龄=28 技能： 学习 吃饭 睡觉 对象3：王五 特征： 学校='luffycity' 名字='王五' 性别='女' 年龄=38 技能： 学习 吃饭 睡觉 总结现实中路飞city的学生类 相似的特征： 学校=’luffycity‘ 相似的技能 学习 吃饭 睡觉 """
# 先定义类 class LuffyStudent: school = 'Luffycity' def learning(self): print('is learning') def eating(self): print('is eating') def sleep(self): print('is sleeping') # 后产生对象 stu1 = LuffyStudent() stu2 = LuffyStudent() stu3 = LuffyStudent() print(stu1) print(stu2) print(stu3)
4、如何使用类
（1）查看类的命名空间
# 查看类的命名空间 print(LuffyStudent.__dict__) print(LuffyStudent.__dict__['school']) print(LuffyStudent.__dict__['eating'])
运行结果 {'learning': <function LuffyStudent.learning at 0x02441738>, '__dict__': <attribute '__dict__' of 'LuffyStudent' objects>, '__weakref__': <attribute '__weakref__' of 'LuffyStudent' objects>, '__doc__': None, 'eating': <function LuffyStudent.eating at 0x02441810>,
'school': 'Luffycity', 'sleep': <function LuffyStudent.sleep at 0x024417C8>, '__module__': '__main__'} Luffycity <function LuffyStudent.eating at 0x02441810>
（2）查看类的属性
# 查 类的属性 print(LuffyStudent.school) # LuffyStudent.__dict__['school'] print(LuffyStudent.eating) # LuffyStudent.__dict__['eating'] # 运行结果 Luffycity <function LuffyStudent.eating at 0x01F71738>
（3）增加类的属性
# 增加 LuffyStudent.addr = 'xian' print(LuffyStudent.__dict__) print(LuffyStudent.addr) # 运行结果 {'eating': <function LuffyStudent.eating at 0x005A17C8>, 'addr': 'xian', '__dict__': <attribute '__dict__' of 'LuffyStudent' objects>, 'learning': <function LuffyStudent.learning at 0x005A1738>, '__weakref__': <attribute '__weakref__' of 'LuffyStudent' objects>, 'sleep': <function LuffyStudent.sleep at 0x005A1810>, '__doc__': None, '__module__': '__main__', 'school': 'Luffycity'} xian
（4）删除类的属性
# 删除 del LuffyStudent.addr print(LuffyStudent.__dict__) #>>> {'eating': <function LuffyStudent.eating at 0x005A17C8>, '__dict__': <attribute '__dict__' of 'LuffyStudent' objects>, 'learning': <function LuffyStudent.learning at 0x005A1738>, '__weakref__': <attribute '__weakref__' of 'LuffyStudent' objects>, 'sleep': <function LuffyStudent.sleep at 0x005A1810>, '__doc__': None, '__module__': '__main__', 'school': 'Luffycity'}
（5）修改类的属性
# 修改 LuffyStudent.school = 'OldBoy' print(LuffyStudent.school) #>>> OldBoy
5.如何使用对象?
# 1.先定义类 class LuffyStudent: school = 'Luffycity' def __init__(self, name, gender, age): self.name = name self.gender = gender self.age = age def eating(self): print('is eating') def learning(self): print('is learning') # 2.后产生对象 stu1 = LuffyStudent('张三', '女', 18)
（1）__init__分析
（2）查看stu1对象的命名空间、属性
# 查对象stu1的命名空间 print(stu1.__dict__) # >>> {'name': '张三', 'age': 18, 'gender': '女'}
# 查对象stu1的属性 print(stu1.name) print(stu1.gender) print(stu1.age) # >>> 张三 女 18
# 改 stu1.name = 'zhangsan' print(stu1.__dict__) # >>> {'name': 'zhangsan', 'gender': '女', 'age': 18}
# 增 stu1.addr = 'xian' print(stu1.__dict__) # 》》》 {'name': 'zhangsan', 'gender': '女', 'addr': 'xian', 'age': 18}
# 删除 del stu1.age print(stu1.__dict__) # >>> {'gender': '女', 'name': 'zhangsan'}
（3）对象stu2
stu2 = LuffyStudent('李四', '男', 28) # LuffyStudent.__init__(stu2,'李四', '男', 28) print(stu2.__dict__) print(stu2.name) print(stu2.gender) print(stu2.age)
# 运行结果 {'age': 28, 'gender': '男', 'name': '李四'} 李四 男 28
6、属性查找
# 先产生类 class LuffyStudent: school = 'Luffy' def __init__(self, name, gender, age): self.name = name self.gender = gender self.age = age def learning(self): print('is learning') def eating(self): print('is eating') def sleeping(self): print('is sleeping') # 后产生对象 stu1 = LuffyStudent('张三', '女', 18) stu2 = LuffyStudent('李四', '男', 28) stu3 = LuffyStudent('王五', '女', 38)
print(stu1.__dict__) print(stu2.__dict__) print(stu3.__dict__) # >>> {'name': '张三', 'gender': '女', 'age': 18} {'name': '李四', 'gender': '男', 'age': 28} {'name': '王五', 'gender': '女', 'age': 38}
（1）类的特征属性
# 类中的数据属性：是所有对象共有的 print(LuffyStudent.school, id(LuffyStudent.school)) print(stu1.school, id(stu1.school)) print(stu2.school, id(stu2.school)) print(stu3.school, id(stu3.school)) #>>> Luffy 43075776 Luffy 43075776 Luffy 43075776 Luffy 43075776
（2）类的技能函数
# 类中的技能函数:是绑定给对象，绑定到不同的对象是不同的绑定方法 print(LuffyStudent.learning) print(stu1.learning) print(stu2.learning) print(stu3.learning) #>>> <function LuffyStudent.learning at 0x02951780> <bound method LuffyStudent.learning of <__main__.LuffyStudent object at 0x0294FA90>> <bound method LuffyStudent.learning of <__main__.LuffyStudent object at 0x0294FAF0>> <bound method LuffyStudent.learning of <__main__.LuffyStudent object at 0x029621F0>>
（3）调用类的技能函数
def learning(self):
print('%s is learning'%self.name)
- 类调用
LuffyStudent.learning(stu1) LuffyStudent.learning(stu2) LuffyStudent.learning(stu3) # 》》》 张三 is learning 李四 is learning 王五 is learning
- 对象调用
stu1.learning() # LuffyStudent.learning(stu1) stu2.learning() stu3.learning() #》》》 张三 is learning 李四 is learning 王五 is learning
（4）多个类的属性调用
def learning(self, style):
print('%s is learning %s'%(self.name,style))
- 类调用
LuffyStudent.learning(stu1,'english') LuffyStudent.learning(stu2,'chines') LuffyStudent.learning(stu3,'math') #>>> 张三 is learning english 李四 is learning chines 王五 is learning math
- 对象调用
stu1.learning('english') # LuffyStudent.learning(stu1) stu2.learning('chinese') stu3.learning('math') #>>> 张三 is learning english 李四 is learning chinese 王五 is learning math
（5）全局变量，局部调用
- 局部变量调用
# 定义一个属性 style = ’from luffy class‘ LuffyStudent.style = 'from luffy class' print(stu1.__dict__) print(stu1.style) # 调用
- 只会到继承的父类查找，不会查找全局变量global
7、一切皆对象
（1）list和LuffyStudent都是类的不同表现形式
#普通方法# l1 = [1,2,3] l1.append(4) print(l1) # 通过类，对象，调用类的方法进行操作 l1 = list([1,2,3]) list.append(l1,4) print(l1)
8、代码级别看面向对象
（1）在没有学习类这个概念时，数据与功能是分离的
def exc1(host,port,db,charset):
conn=connect(host,port,db,charset)
conn.execute(sql)
return xxx
def exc2(host,port,db,charset,proc_name)
conn=connect(host,port,db,charset)
conn.call_proc(sql)
return xxx
#每次调用都需要重复传入一堆参数
exc1('127.0.0.1',3306,'db1','utf8','select * from tb1;')
exc2('127.0.0.1',3306,'db1','utf8','存储过程的名字')
（2）我们能想到的解决方法是，把这些变量都定义成全局变量
HOST=‘127.0.0.1’ PORT=3306 DB=‘db1’ CHARSET=‘utf8’ def exc1(host,port,db,charset): conn=connect(host,port,db,charset) conn.execute(sql) return xxx def exc2(host,port,db,charset,proc_name) conn=connect(host,port,db,charset) conn.call_proc(sql) return xxx exc1(HOST,PORT,DB,CHARSET,'select * from tb1;') exc2(HOST,PORT,DB,CHARSET,'存储过程的名字')
（4）总结
（5）可拓展性高
- 定义类并产生三个对象
class Chinese: country = 'China' def __init__(self, name, gender, age): self.name = name self.gender = gender self.age = age p1 = Chinese('alex', '女', 22) p2 = Chinese('jack', '男', 32) p3 = Chinese('tom', '女', 42) print(p1.country) print(p2.country) print(p3.country)
- 如果我们新增一个类属性，将会立刻反映给所有对象，而对象却无需修改
9、小节练习
练习1：编写一个学生类，产生一堆学生对象， (5分钟)
要求：
有一个计数器（属性），统计总共实例了多少个对象
练习2：模仿王者荣耀定义两个英雄类， (10分钟)
要求：
英雄需要有昵称、攻击力、生命值等属性；
实例化出两个英雄对象；
英雄之间可以互殴，被殴打的一方掉血，血量小于0则判定为死亡。
（1）我的代码
class Student: count = 0 def __init__(self): count += 1 stu1 = Student() stu2 = Student() stu3 = Student() stu4 = Student() print(Student.count)
# 练习2 class Hero: def __init__(self, name, attack, hp): self.name = name self.attack = attack self.hp = hp def attacked(self, anyone): self.hp -= anyone.attack def __del__(self): if self.hp <= 0 : print('%s is died'%self.name) hero1 = Hero('akl', 35, 100) hero2 = Hero('tom', 20, 200) print(hero1.__dict__) print(hero2.__dict__) hero1.attacked(hero2) print(hero1.__dict__) hero2.attacked(hero1) print(hero1.__dict__)
（2）老师代码
class Student: count = 0 def __init__(self, name, age, gender): self.name = name self.age = age self.gender = gender Student.count += 1 def learn(self): print('%s is learning'%self.name) print(Student.__dict__) stu1 = Student('张三', 18, '女') stu2 = Student('李四', 28, '女') stu3 = Student('王五', 38, '女') print(Student.__dict__) print(Student.count)
# 练习2 class Akl: city = 'Demacia' def __init__(self, nickname, life_value, aggresivity): self.nickname = nickname self.life_value = life_value self.aggresivity = aggresivity def attack(self, enemy): enemy.life_value -= self.aggresivity class Riven: city = 'Noxus' def __init__(self, nickname, life_value, aggresivity): self.nickname = nickname self.life_value = life_value self.aggresivity = aggresivity def attack(self, enemy): enemy.life_value -= self.aggresivity akl = Akl('暗影之拳', 100, 30) riven = Riven('锐萌萌', 100, 30) print(riven.__dict__) akl.attack(riven) print(riven.life_value) print(riven.__dict__)