一、面向过程：
核心是过程二字，过程指的是解决问题的步骤，设计一条流水线，机械式的思维方式
优点： 复杂的问题流程化，进而简单化
缺点：扩展性差
适用场景：需求固定的情况
1 import json 2 import re 3 def interactive(): 4 name=input('>>: ').strip() 5 pwd=input('>>: ').strip() 6 email=input('>> ').strip() 7 return { 8 'name':name, 9 'pwd':pwd, 10 'email':email 11 } 12 13 def check(user_info): 14 is_valid=True 15 16 if len(user_info['name']) == 0: 17 print('用户名不能为空') 18 is_valid=False 19 20 if len(user_info['pwd']) < 6: 21 print('密码不能少于6位') 22 is_valid=False 23 24 if not re.search(r'@.*?\.com$',user_info['email']): 25 print('邮箱格式不合法') 26 is_valid=False 27 28 return { 29 'is_valid':is_valid, 30 'user_info':user_info 31 } 32 33 def register(check_info): 34 if check_info['is_valid']: 35 with open('db.json','w',encoding='utf-8') as f: 36 json.dump(check_info['user_info'],f) 37 38 39 40 def main(): 41 user_info=interactive() 42 43 check_info=check(user_info) 44 45 register(check_info) 46 47 if __name__ == '__main__': 48 main()
二 、 面向对象
核心就是对象二字，对象就是特征与技能的结合
优点：可扩展性
缺点： 编程复杂度高
应用场景： 用户需求经常变化，互联网应用，游戏，企业内部应用（如：办公系统）
三、类的定义与实例化，以及类的使用
类就是一系列对象相似的特征与技能的结合体
强调：站在不同的角度，得到的分类是不一样的。
在现实世界中：一定先有对象，后有类
在程序中：一定得先定义类，后调用类来产生对象 类相当于模版
类在定义的时候就调用了。
特征：用变量定义
技能：用函数定义
查看类的名称空间
print(类名.__dict__)
print(类名.__dict__['school'])
类的用法：
1 # 先定义类 2 class LuffyStudent: 3 # 数据属性 4 school = 'luffycity' 5 6 # 函数属性 7 def learn(self): 8 print('is learning') 9 10 # 函数属性 11 def eat(self): 12 print('is eating') 13 14 15 #后产生对象 16 stu1 = LuffyStudent() 17 18 #查看类的名称空间 19 print(LuffyStudent.__dict__) 20 print(LuffyStudent.__dict__['school']) 21 22 # 查看类的属性 23 print(LuffyStudent.school) #等价于print(LuffyStudent.__dict__['school']) 24 25 # 增加类的属性 26 LuffyStudent.country = 'china' 27 #print(LuffyStudent.__dict__) 28 print(LuffyStudent.country) 29 30 # 删除类的属性 31 del LuffyStudent.country 32 33 # 改类的属性 34 LuffyStudent.school = 'Luffycity'
总结：
1. () 的作用
函数() : 执行函数体的代码
类(): 是实例化产生对象，在定义类的时候就已经执行了类体的代码
2. 类的作用
1） 对属性的操作，增删改查
2） 实例化产生一个个的对象
四、对象
（一）__init__
__init__方法为对象定制对象自己独有的特征
加上__init__方法后，实例化的步骤：
1. 先产生一个空对象
2. 自动触发__init__方法 ,第一参数self是对象自己，不需要传
1 class LuffyStudent: 2 school='luffycity' 3 4 # stu1, '王二丫', '女', 18 5 def __init__(self,name,sex,age): 6 self.Name=name 7 self.Sex=sex 8 self.Age=age 9 10 #stu1.Name='王二丫' 11 #stu1.Sex='女' 12 #stu1.Age=18 13 14 def learn(self): 15 print('is learning') 16 17 def eat(self): 18 print('is sleeping') 19 20 21 #后产生对象 22 stu1=LuffyStudent('王二丫','女',18) #LuffyStudent.__init__(stu1,'王二丫','女',18) 23 24 #加上__init__方法后，实例化的步骤 25 # 1、先产生一个空对象stu1 26 # 2、LuffyStudent.__init__(stu1,'王二丫','女',18) 27 28 29 #查 30 print(stu1.__dict__) 31 print(stu1.Name) 32 print(stu1.Sex) 33 print(stu1.Age) 34 35 # 改 36 stu1.Name='李二丫' 37 print(stu1.__dict__) 38 print(stu1.Name) 39 40 41 # 删除 42 del stu1.Name 43 print(stu1.__dict__) 44 45 #增 46 stu1.class_name='python开发' 47 print(stu1.__dict__) 48 49 50 stu2=LuffyStudent('李三炮','男',38) #Luffycity.__init__(stu2,'李三炮','男',38) 51 print(stu2.__dict__) 52 print(stu2.Name) 53 print(stu2.Age) 54 print(stu2.Sex)
(二 ) 对象调用类中的属性与方法
对象：特征与技能的结合体
类：类是一系列对象相似的特征与相似的技能的结合体
类中的数据属性：是所以对象共有的 , id 都是同一个
print(LuffyStudent.school,id(LuffyStudent.school)) print(stu1.school,id(stu1.school)) print(stu2.school,id(stu2.school)) print(stu3.school,id(stu3.school))
类中的函数属性:是绑定给对象使用的，绑定到不同的对象是不同的绑定方法，对象调用绑定方式时，会把对象本身当作第一个传入，传给self
print(LuffyStudent.learn) LuffyStudent.learn(stu1) #stu1.learn() LuffyStudent.learn(stu2) LuffyStudent.learn(stu3)
# 如果类中的函数有参数，则：
stu1.learn('python') # LuffyStudent.learn(stu1,'python')
类中定义的函数，没有经过任何附加处理的情况下，实际上是绑定给对象调用的。
谁来调就把谁当作第一个参数传入给self，谁来调就是谁来执行。
名称空间：
全局变量，类变量，对象变量同名
则，优化使用对象变量，
如果没有对象变量，则找类变量，
如果类变量没有，就到父类找，父类没有，再到父父类，不会到全局找。
stu1.x='from stu1' LuffyStudent.x='from Luffycity class' print(stu1.__dict__) print(stu1.x)
python一切皆对象，python3统一了类与类型的
l1=[1,2,3] #l=list([1,2,3]) l2=[] #l=list([1,2,3]) # l1.append(4) #list.append(l1,4) list.append(l1,4) print(l1)
面向对象的可扩展性:
class Chinese:
county='China'
def __init__(self,name,age,sex):
self.name=name
self.age=age
self.sex=sex
def eat(self):
print('%s is eating' %self.name)
p1=Chinese('egon',18,'male')
p2=Chinese('alex',38,'female')
p3=Chinese('wpq',48,'female')
# print(p1.county)
# print(p2.county)
# print(p3.county)
p1.eat()
p2.eat()
p3.eat()
五、练习
'''
练习1：编写一个学生类，产生一堆学生对象， (5分钟)
要求：
有一个计数器（属性），统计总共实例了多少个对象
'''
class Student:
school='luffycity'
count=0
def __init__(self,name,age,sex):
self.name=name
self.age=age
self.sex=sex
# self.count+=1 是对象自己独有的。 想要实现的是所有对象都能感应到。应该是共有的特征。
Student.count+=1
def learn(self):
print('%s is learing' %self.name)
stu1=Student('alex','male',38)
stu2=Student('jinxing','female',78)
stu3=Student('egon','male',18)
#对象.count 其实就是student.count ，值都相等
# print(Student.count)
# print(stu1.count) #自己没有count属性，就去类中找count
# print(stu2.count)
# print(stu3.count)
# print(stu1.__dict__)
# print(stu2.__dict__)
# print(stu3.__dict__)
对象交互：
'''
练习2：模仿LoL定义两个英雄类， (10分钟)
要求：
英雄需要有昵称、攻击力、生命值等属性；
实例化出两个英雄对象；
英雄之间可以互殴，被殴打的一方掉血，血量小于0则判定为死亡。
'''
class Garen:
camp='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
#r1.life_value-=g1.aggresivity
class Riven:
camp = '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
g1=Garen('草丛伦',100,30)
r1=Riven('可爱的锐雯雯',80,50)
print(r1.life_value)
g1.attack(r1)
print(r1.life_value)