编程范式：
1 面向过程编程： 核心是“过程”，“过程”指的是解决问题的步骤；就相当于在设计一条流水线
优点：复杂问题流程化，进而简单化缺点：可扩展
编程范式：
1. 面向过程编程： 核心是“过程”，“过程”指的是解决问题的步骤；就相当于在设计一条流水线
优点：复杂问题流程化，进而简单化
缺点：可扩展性差，前一发动全身
2. 面向对象：核心是“对象”，对象就是特征与技能的结合体
优点： 可扩展性强
缺点： 编程复杂度高
应用场景： 用户需求经常变化，如：互联网应用、游戏、企业内部应用
类：
类就是一系列对象相似的特征与技能的结合体（相当于一个模板），特征用变量表示，技能用函数表示
强调： 站在不同的角度，得到的分类是不一样的
在程序中： 一定是先定义类，后调用类产生对象
定义类、产生对象的方法如下：
"""定义类""" class Student: # 类的首字母大写 school = "Luffycity" def learn(self): print("is learning") def eat(self): print("is eating") def sleep(self): print("is sleeping") """调用类产生对象""" stu1 = Student() # Student() 不是执行类体的代码，而是得到一个返回值，这个返回值就是产生的对象；这个过程也叫“实例化” stu2 = Student() # 类名调用一次就是实例化一次 stu3 = Student() print(stu1) print(stu2) print(stu3) # 输出结果： # <__main__.Student object at 0x0000001F205C6438> # <__main__.Student object at 0x0000001F205C66D8> # <__main__.Student object at 0x0000001F205C6668>
类的使用：
定义类时，在类定义阶段它内部的代码就能够运行，如下：
class Student: # 类的首字母大写 school = "Luffycity" # 特征 print("test") def learn(self): # 技能 print("is learning") def eat(self): print("is eating") def sleep(self): print("is sleeping") # 运行结果： # test
查看类里面的名称空间：
class Student: # 类的首字母大写 school = "Luffycity" # 类的数据属性 def learn(self): # 类的函数属性 print("is learning") def eat(self): print("is eating") def sleep(self): print("is sleeping") print(Student.__dict__) print(Student.__dict__["school"]) print(Student.__dict__["learn"])
"""查看""" print(Student.school) print(Student.learn) """类定义完后增加属性""" Student.country = "China" # 往Student这个类里面增加了 country = "China" print(Student.__dict__) print(Student.country) """删除""" del Student.country print(Student.__dict__) """修改""" Student.country = "Greater China" print(Student.country) # 打印结果： # {'__module__': '__main__', 'school': 'Luffycity', 'learn': <function Student.learn at 0x000000711C26B9D8>, 'eat': <function Student.eat at 0x000000711C26BA60>, 'sleep': <function Student.sleep at 0x000000711C26BD90>, '__dict__': <attribute '__dict__' of 'Student' objects>, '__weakref__': <attribute '__weakref__' of 'Student' objects>, '__doc__': None} # Luffycity # <function Student.learn at 0x000000711C26B9D8> # Luffycity # <function Student.learn at 0x000000711C26B9D8> # {'__module__': '__main__', 'school': 'Luffycity', 'learn': <function Student.learn at 0x000000711C26B9D8>, 'eat': <function Student.eat at 0x000000711C26BA60>, 'sleep': <function Student.sleep at 0x000000711C26BD90>, '__dict__': <attribute '__dict__' of 'Student' objects>, '__weakref__': <attribute '__weakref__' of 'Student' objects>, '__doc__': None, 'country': 'China'} # China # {'__module__': '__main__', 'school': 'Luffycity', 'learn': <function Student.learn at 0x000000711C26B9D8>, 'eat': <function Student.eat at 0x000000711C26BA60>, 'sleep': <function Student.sleep at 0x000000711C26BD90>, '__dict__': <attribute '__dict__' of 'Student' objects>, '__weakref__': <attribute '__weakref__' of 'Student' objects>, '__doc__': None} # Greater China
类内部定义的变量是类的数据属性 ，定义的函数是其函数属性
类的用途：
1. 对属性的操作
2. 实例化产生一个个对象 （利用 Student() 方法）
对象的使用方法：
利用 init 方法来为对象定制自己独有的特征
class Student: school = "Luffycity" def __init__(self,name,gender,age): # 实例化的时候就会自动调用 __init__函数 self.Name = name self.Gender = gender self.Age = age # 字典形式 """ stu1.Name = "苍老师" stu1.Gender = "女" stu1.Age = 18 """ def learn(self): print("is learning") def eat(self): print("is eating") def sleep(self): print("is sleeping") stu1 = Student("苍老师","女",18)
stu2 = Student("武藤兰","男",38) """ 有__init__函数时的实例化步骤： 1. 先产生一个空对象stu1（不带自己独特属性的对象） 2. 触发__init__函数，触发方式为：Student.__init__() , 这是一个函数，就需要按照函数的方式进行传参，即： Student.__init__(stu1,name,gender,age) (第一步生成的对象stu1传入self的位置) Student.__init__(stu1,name,gender,age) 产生的效果如__init__函数中的注释所示。 (添加独有属性后，对象的内存地址不变)
3. 返回 带自己独特属性的对象stu1 """ """ stu1 = Student("苍老师","女",18) 这是在给一个对象定制一个属性，与类添加属性一个道理，往对象里面添加属性也涉及到名称空间的变动，只不过这个名称空间是stu1的名称空间（因为是往stu1这个对象里面添加的新属性） """ print(stu1.__dict__) # 打印结果： # {'Name': '苍老师', 'Gender': '女', 'Age': 18} """ 通过__init__的方法, stu1这个对象不但拥有类共有的那些特征和技能，并且也有了自己独有的属性""" """查看""" print(stu1.Name) print(stu1.Gender) # 打印结果： # 苍老师 # 女 """改""" stu1.Name = "苍井空" print(stu1.__dict__) print(stu1.Name) # 打印结果： # {'Name': '苍井空', 'Gender': '女', 'Age': 18} # 苍井空 """增加""" stu1.job = "adult video" print(stu1.__dict__) print(stu1.job) # 打印结果： # {'Name': '苍井空', 'Gender': '女', 'Age': 18, 'job': 'adult video'} # adult video """删除""" del stu1.job print(stu1.__dict__) # 打印结果： # {'Name': '苍井空', 'Gender': '女', 'Age': 18}
类中的数据属性是所有对象共有的；
类中的函数属性：是绑定给对象使用的，而且绑定到不同的对象是不同的绑定方法
还以上面的代码为例：
print(Student.school,id(Student.school)) print(stu1.school,id(stu1.school)) # 打印结果： # Luffycity 586247585648 # Luffycity 586247585648 """类中的数据属性是所有对象共有的，用的都是同一块内存地址"""
"""类中的函数属性：是绑定给对象，而且绑定到不同的对象是不同的绑定方法"""
print(Student.learn)
print(stu1.learn)
print(stu2.learn)
# 打印结果： （函数的内存地址也不一样）
# <function Student.learn at 0x0000005FB155BA60> # 类名.功能名 是一个函数的内存地址，就是一个函数，那就按函数的方法去执行，而且函数不会自动传参的
# <bound method Student.learn of <__main__.Student object at 0x0000005FB15667B8>> # 对象.功能名是一种绑定方法，所以能够自动传参
# <bound method Student.learn of <__main__.Student object at 0x0000005FB15667F0>> # 功能跟不同对象的绑定方法不一样
把上述例子中类的代码稍微修改，如下：
class Student: school = "Luffycity" def __init__(self, name, gender, age): # 实例化的时候就会自动调用 __init__函数 self.Name = name self.Gender = gender self.Age = age # 字典形式 def learn(self): print("%s is learning" % self.Name) def eat(self): print("%s is eating" % self.Name) def sleep(self): print("%s is sleeping" % self.Name) stu1 = Student("苍老师", "女", 18) stu2 = Student("武藤兰","男",38)
调用 Student.learn() 函数的方法：（此函数需传入参数）
Student.learn(stu1) # Student.learn()就是一个普通的函数，所以可以利用函数的调用方式去执行它；函数的参数要传入上一步产生的stu1， 因为在类中定义learn()函数时，里面有参数self # 执行结果： # 苍老师 is learning
调用stu1.learn()函数的方法： （此函数无需传入参数，因为learn功能只需传入参数self，而stu1会自动传入self）
"""调用stu1.learn()函数""" stu1.learn() # 这个函数调用的是类Student下的learn的功能，stu1会作为参数自动传入到self这个形参中 # 执行结果： # 苍老师 is learning
即： 类中的函数属性是绑定给对象使用的，绑定到不同的对象是不同的绑定方法，对象调用绑定方式时，会把对象本身当做第一个参数，传入self
类中定义的功能（即 函数）是给对象使用的（绑定给对象使用的），而且是哪个对象来调用就把哪个对象作为参数自动传入到self中（这是 绑定关系），这样 哪个对象在调用就是哪个对象在执行类中的功能；类如果自己使用还需要自己传入对象（传入到self中），会比较笨拙
对象只存放自己独有的特征，相似的特征都放在类里面；这涉及到对象的属性查找问题，如果对象中的属性跟类中的属性重名，则以对象中的属性为准（类似于函数中变量的先局部后全局）（例外，属性不会去全局里面找，因为你是在调用类，或者说这是类的调用）
"""有重名""" stu1.x = "CN" Student.x = "中国" print(stu1.x) print(Student.x) # 打印结果： # CN # 中国 """无重名时，对象调用类中的""" Student.x = "中国" print(stu1.x) print(Student.x) # 打印结果： # 中国 # 中国
补充说明1：
1. 站在不同角度，定义出的类是不同的
2. 现实中的类并不完全等同于程序中的类，比如现实中的公司类，在程序中有时需拆分成部门类、业务类等
3. 有时为了变成需求，程序中可能会定义现实中不存在的类，比如策略类，现实中不存在，但在程序中是一个很常见的类
补充说明2：
Python中一切皆对象，并且在Python3中统一了类与类型的概念
class Student: school = "Luffycity" def __init__(self, name, gender, age): # 实例化的时候就会自动调用 __init__函数 self.Name = name self.Gender = gender self.Age = age # 字典形式 def learn(self): print("%s is learning" % self.Name) def eat(self): print("%s is eating" % self.Name) def sleep(self): print("%s is sleeping" % self.Name) print(type([1,2])) print(list) # [1,2] 和 list是Python中的列表这个数据类型 print(Student) # Student 是我们自己创建的类 # 打印结果： # <class 'list'> # <class 'list'> # <class '__main__.Student'> """ Python3中统一了类与类型的概念 """ # 站在类的角度考虑下面已学过的知识 list1 = [1,2,3] # 这种方法的本质是 list1 = list([1,2,3]) 即 调用list这个类并传入参数[1,2,3]，进而产生list1这个对象，并且[1,2,3]放入到了list1的命名空间中； list1中独有的特征就是[1,2,3] list2 = [] # 同理， list2 = list() list1.append(4) # 这行代码的含义是：list1这个对象调用了list这个类下面的 append() 这个功能（函数）。 print(list1) """ list1.append(4) 其实就相当于 list.append(list1,4) 即 list这个类调用其内部的append()函数，并把list1这个对象传入到self这个形参中 """ list.append(list1,5) print(list1) # 打印结果： # [1, 2, 3, 4] # [1, 2, 3, 4, 5] list2.append(1) # list2.append(1) ： 添加的1只能添加到list2中，不会添加到list1中，因为是list2这个对象在调用append(1)这个功能 print(list2) # 打印结果： # [1] """所以，在Python中一切皆对象"""
可扩展性：
使用类可以将数据与专门操作该数据的功能捆绑在一起
例题1：
编写一个学生类，产生多个学生对象
要求： 有一个计数器（属性），统计总共实例化了多少个对象
代码如下：
class Student: school = "luffycity" count = 0 def __init__(self,name,gender,age): self.name = name self.gender = gender self.age = age # self.count += 1 # 这种方式是不可行的，因为每次添加count时都添加到了对象的特有属性里面，再产生下一个对象时，新产生的对象并不知道上一个对象count的值是多少；而且由于 __init__ 里面没有对 count 这个变量赋值，所以 self.count 会向类的公共属性里面去寻找count 的值 """正确写法""" Student.count += 1 # 在 __init__函数里面对类Student的公共属性count进行处理；count变量并没有添加到对象命名空间中（没有添加到对象的独有属性中），count一直都是在类Student的命名空间里 def learn(self): print("%s is learning" %self.name) """ 分析要求： 每次实例化都会触发 __init__ 函数，所以可以考虑在 __init__ 上进行计数 首先在类的公共属性上添加一个 count = 0 """ stu1 = Student("neo","male",18) stu2 = Student("苍老师","female",16) stu3 = Student("美奈子","female",17) print(stu1.count) # 此时的 stu1.count 调用的是类 Student中的变量count，stu1中是没有count这个变量的 print(stu2.count) print(stu3.count) print(stu1.__dict__) print(stu2.__dict__) print(stu3.__dict__) print(Student.count) # 打印结果： # 3 # 3 # 3 # {'name': 'neo', 'gender': 'male', 'age': 18} # {'name': '苍老师', 'gender': 'female', 'age': 16} # {'name': '美奈子', 'gender': 'female', 'age': 17} # 3
例题二：
模仿LOL定义两个英雄类
要求：
英雄需要有昵称、攻击力、生命值等属性
实例化出两个英雄对象
英雄之间可以互殴，被打的一方掉血，血量小于0则判定为死亡
以下是自己写的：（只定义了一个英雄类）
class Hero: def __init__(self,name,attack,life): self.name = name self.attack = attack self.life = life def fighted(self,attacked = 0): self.life -= attacked if self.life <= 0: print("%s is dead" %self.name) else: print("%s is alive" %self.name) kasaa = Hero("卡萨丁",1000,2000) kayle = Hero("凯尔",1300,1500) kayle.fighted(kasaa.attack) kayle.fighted(kasaa.attack)
示例代码：
class Garen: camp = "Demacia" def __init__(self,nickname,attack,life): self.nickname = nickname self.attack = attack self.life = life def attacking(self,enemy): enemy.life -= self.attack class Riven: camp = "Noxus" def __init__(self,nickname,attack,life): self.nickname = nickname self.attack = attack self.life = life def attacking(self,enemy): enemy.life -= self.attack garen = Garen("草丛伦",30,100) riven = Riven("瑞雯雯",50,80) print(riven.life) garen.attacking(riven) # 英雄（对象）之间的交互 print(riven.life) # 运行结果 # 80 # 50
上述代码中有大量重复的代码，利用“继承”来解决。（转下篇文章）
