标签:扩展性 操作 学生 tin 对象 hid 分类 lex __init__
一、面向过程:
核心是过程二字,过程指的是解决问题的步骤,设计一条流水线,机械式的思维方式
优点: 复杂的问题流程化,进而简单化
缺点:扩展性差
适用场景:需求固定的情况
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)
标签:扩展性 操作 学生 tin 对象 hid 分类 lex __init__
原文地址:https://www.cnblogs.com/beallaliu/p/9101769.html