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': 
     
      , '__dict__': 
      
       , '__weakref__': 
       
        , '__doc__': None, 'eating': 
        
         , 'school': 'Luffycity', 'sleep': 
         
          , '__module__': '__main__'}Luffycity
          
         
        
       
      
     

 

 

（2）查看类的属性

# 查  类的属性print(LuffyStudent.school)  # LuffyStudent.__dict__['school']print(LuffyStudent.eating)  # LuffyStudent.__dict__['eating']# 运行结果Luffycity
     

 

 

（3）增加类的属性

# 增加LuffyStudent.addr = 'xian'print(LuffyStudent.__dict__)print(LuffyStudent.addr)# 运行结果{
   'eating': 
     
      , 'addr': 'xian', '__dict__': 
      
       , 'learning': 
       
        , '__weakref__': 
        
         , 'sleep': 
         
          , '__doc__': None, '__module__': '__main__', 'school': 'Luffycity'}xian
         
        
       
      
     

 

 

（4）删除类的属性

# 删除del LuffyStudent.addrprint(LuffyStudent.__dict__)#>>>{
   'eating': 
     
      , '__dict__': 
      
       , 'learning': 
       
        , '__weakref__': 
        
         , 'sleep': 
         
          , '__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.ageprint(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 43075776Luffy 43075776Luffy 43075776Luffy 43075776

 

　　（2）类的技能函数

# 类中的技能函数:是绑定给对象，绑定到不同的对象是不同的绑定方法print(LuffyStudent.learning)print(stu1.learning)print(stu2.learning)print(stu3.learning)#>>>
     
      
       >
       
        >
        
         >
        
       
      
     

 

　　（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 xxxdef 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=3306DB=‘db1’CHARSET=‘utf8’def exc1(host,port,db,charset):    conn=connect(host,port,db,charset)    conn.execute(sql)    return xxxdef exc2(host,port,db,charset,proc_name)    conn=connect(host,port,db,charset)    conn.call_proc(sql)    return xxxexc1(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 = agep1 = 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 += 1stu1 = Student()stu2 = Student()stu3 = Student()stu4 = Student()print(Student.count)

　　 

# 练习2class 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)

 

 

# 练习2class 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.aggresivityclass 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.aggresivityakl = Akl('暗影之拳', 100, 30)riven = Riven('锐萌萌', 100, 30)print(riven.__dict__)akl.attack(riven)print(riven.life_value)print(riven.__dict__)