提示：本文代码完全来源于哔哩哔哩《10小时搞定Python面向对象（完整版）》，本文用途仅限于Python编程的学习。
网址：https://www.bilibili.com/video/BV1t34y197tv?spm_id_from=333.999.0.0&vd_source=3b0d75c3bc9e365b679882b6812cac6d

文章目录

前言
零、回顾面向过程的编程
一、通过字典的方式来实现类似于面向对象的功能
二、面向对象的编程范式OOP
三、类
四、类的公共属性
五、对象的交互
六、依赖关系以及关联关系
七、关联关系（方法2）
八、组合关系
九、继承
十、多继承
十一、封装
十二、类方法
十三、静态方法
十四、属性方法
十五、反射
十六、文件反射
十七、动态加载模块指令
十八、new方法
十九、动态创建方法
总结

前言

提示：这里简要介绍关于面向对象的知识

编程范式就是一个编程的套路、思维

编程范式：1、面向过程的编程范式（Procedure Programming）；2、面向对象的编程范式（Object-Oriented Programming）

1、面向过程的编程范式

程序从上到下一步步地执行，一步步从上到下，从头到尾的解决问题。基本设计思路就是程序一开始就是要着手解决一个大的问题，然后把一个大问题分解成很多个小问题
或者子过程，这些子过程再执行的过程再继续分解直到小问题足够简单到可以在一个小步骤范围内解决

2、面向对象的编程范式

面向对象的编程是利用类和对象来创建各种模型来实现对于真实世界的描述，使用对象对象的编程的原因：一方面是因为他可以使得程序的维护和扩展变得更加简单
并且可以大大的提高程序的开发效率，另外就是，基于面向对象的程序可以使它人更容易的理解你的代码逻辑。

提示：接下来是详细的代码实现

零、回顾面向过程的编程

创建一个字典类型的变量

# 1 整合日志def collect_log():print("log on server A , get access.log")print("log on server B , get access.log")print("log on server C , get access.log")print("combine logs in to one file")# 2 日志分析def log_analyze():print("pv、uv分析....")print("用户来源分析....")print("访问的设备来源分析....")print("页面停留时间分析....")print("入口页面分析....")# 3 生成报告并发送def send_report():print("connect email server....")print("send email....")def main():collect_log()log_analyze()send_report()if __name__ == '__main__':main()

一、通过字典的方式来实现类似于面向对象的功能

创建一个字典类型的变量

attack_vals = {"京巴":30,"藏獒":80}

定义一个类（功能方面的类，并不是实际的类，这是通过函数实现的），相当于dog是一个类，在内部定义的data相当于类的属性，而内部定义的函数dog_bite相当于类方法。

def dog(name, d_type): data = {                   # 定义一个字典类型的变量，最终该函数将把这个字典变量返回"name"    : name,"d_type"  : d_type,"life_val": 100   }if d_type in attack_vals:data["attack_val"] = attack_vals[d_type]  else: data["attack_val"] = 15def dog_bite(person_obj): # 定义一个方法（函数），这个函数名可以通过字典变量进行调用person_obj["life_val"] -= data["attack_val"] # 执行咬人减血动作print("狗[%s]咬了人[%s]一口，人掉血[%s]，还有血量[%s]..."%(data["name"],person_obj["name"],data["attack_val"],person_obj["life_val"]))data["bite"] = dog_bite # 注意这个地方给字典中的键赋值时，是函数名不带括号，调用时要带括号return data

同样的道理，创建另外一个类

def person(name, age): data = {"name"    : name,"age"     : age,"life_val": 100   }if age < 18:data["attack_val"] = 30else: data["attack_val"] = 50def hit(dog_obj): # 定义一个方法（函数），这个函数名可以通过字典变量进行调用dog_obj["life_val"] -= data["attack_val"] # 执行咬人减血动作print("人[%s]打了狗[%s]一棍，狗掉血[%s]，还有血量[%s]..."%(data["name"],dog_obj["name"],data["attack_val"],dog_obj["life_val"]))data["hit"] = hit # 注意这个地方给字典中的键赋值时，是函数名不带括号，调用时要带括号return data

实例化

dog1 = dog( "XXX", "京巴") # 实体dog2 = dog( "YYY", "藏獒") person1 = person( "ZZZ", 22) # 调用实体本身具有的方法person1["hit"](dog1)dog1["bite"](person1)

二、面向对象的编程范式OOP

创建一个字典类型的变量

'''1、Class 类一个类就是对于一类拥有相同属性的对象的“抽象”、蓝图、原型。在类中定义了这些对象的都具有的属性（variables(data)）、共同的方法（functions）。类：人2、Object 对象一个对象就是一个类的实例化，一个类必须经过实例化后方可在程序中调用一个类可以实例化多个对象，每个对象亦可以有不同的属性（variables）对象：某个人3、 Encapsulatation 封装在类中对于数据的赋值、内部调用对外部用户是透明的，这使类变成了一个胶囊或容器，里边包含着类的数据和方法4、 Inheritance 继承一个类可以派生出子类，在父类里定义的属性、方法自动被子类继承5、 Polymorphsim 多态'''

三、类

创建一个字典类型的变量

class Dog: # 在python官方规范里，类名首字母要大写。# 1、公有的属性是类定义体内定义的。实例化的对象（所有的对象都共享类定义体的公共属性空间（类在声明后是占用内存空间的））# 公有属性可以在类定义体以外进行修改，但是所有实例化的对象都跟着变（共享同一内存空间）# 公共属性又叫做类属性d_type = "京巴" # 类属性，类变量1(公有的属性)home   = "中国" # 类属性，类变量2(公有的属性)# 2、初始化方法，构造方法，构造函数，实例化时自动执行(无需调用)，进行一些初始化的工作# 一些私有属性要通过初始化函数传入进来# 私有属性在初始化函数中定义，初始化函数执行完了内存空间释放，所以在类定义体中的其他函数中无法调用私有属性# 私有属性又叫做实例属性、成员变量'''def __init__(self) -> None:pass  ''''''def __init__(self, name, age): # 这样传入时，内存释放，实例化后的对象并没有name, age这两个属性print("哈哈哈....", name, age)'''# 要想保存私有属性，那就要将私有属性和实例绑定。self代表实例本身def __init__(self, name, age):self.name = nameself.age  = agedef sayhi(self): # self 代表实例本身，类定义中的方法，第一个参数必须是selfprint("hello, I am a dog! My type is [%s],and my age is [%s]."%(self.d_type,self.age)) # 调用类属性需要self.#实例化D1 = Dog("XXX",2) # 创建一个Dog类的对象，叫做D1,传入参数就是私有属性（变量）,这些参数将传入到__init__(self, name, age)函数中去。
D2 = Dog("ZZZ",3)   # 创建一个Dog类的对象，叫做D2,传入参数就是私有属性（变量）,这些参数将传入到__init__(self, name, age)函数中去。D1.sayhi() # 调用这个对象（属于类）的方法print("[%s],[%s]"%(D1.d_type,D1.home)) # 调用这个对象（属于类）的属性（变量）print("上述两个实例的公共属性所在的地址空间都是",id(D1.d_type),id(D2.d_type))# 上述两个实例的公共属性所在的地址空间都是 4317187696 4317187696Dog.d_type = "藏獒" # 在类定义体以外修改公共属性（所有类都变）print("[%s],[%s]"%(D1.d_type,D2.d_type))D1.d_type = "二哈" # 在类定义体以外修改实例化后的对象的公共属性（只有该对象的公共属性变）print("[%s],[%s]"%(D1.d_type,D2.d_type)) # def __init__(self, name, age): # 这样传入时，内存释放，实例化后的对象并没有name, age这两个属性
# print("[%s],[%s]"%(D1.name(),D2.name))  会报错

四、类的公共属性

创建一个字典类型的变量

class People:# 1、公有属性（可以在类定义体外整体的修改）nationlity = "Chinese"# 2、类初始化函数，定义实例属性（可以每个实例化后的对象单独修改）def __init__(self, name, age, sex):self.name = nameself.age = ageself.sex = sex# 实例化类，创建对象P1 = People("XXX",22,"W")
P2 = People("ZZZ",23,"M")# 理论上讲，公共属性是所有实例共享类定义体的同一块内存，公共属性只能通过[类.公共属性]这样去整体修改
# 但是实际上，是允许每个实例对象单独去修改自己的公共属性的，这样时，相当于给这个实例的公共属性开辟一个内存空间，而原来类定义体的公共属性并没有改变People.nationlity = "England" # 通过[类.公共属性]去修改，结果是所有实例的公共属性都变化
print(P1.nationlity,P2.nationlity)P1.nationlity = "Chinese" # 通过[实例.公共属性]去修改，结果是只有该实例的公共属性变化
print(P1.nationlity,P2.nationlity)

五、对象的交互

创建一个字典类型的变量

class Dog: # 定义一个类：狗类role = "dog" # 每个狗（实例化后）都是狗类（角色）# 私有属性def __init__(self, name, breed, attack_val):self.name = nameself.breed = breedself.attack_val = attack_valself.life_val = 100def bite(self, person): # 这里传入的person也是一个对象person.life_val -= self.attack_valprint("狗[%s]咬了人[%s]一口，人掉血[%s]，还有血量[%s]..."%(self.name,person.name,self.attack_val,person.life_val))class Person:role = "person"def __init__(self, name, sex, attack_val):self.name = nameself.sex = sexself.attack_val = attack_valself.life_val = 100def hit(self, dog):dog.life_val -= self.attack_valprint("人[%s]打了狗[%s]一棍，狗掉血[%s]，还有血量[%s]..."%(self.name,dog.name,self.attack_val,dog.life_val))Dog1 = Dog("XXX","二哈",10)
Per1 = Person("ZZZ","男",90)Per1.hit(Dog1)

六、依赖关系以及关联关系

# 依赖关系是不同的实例属于不同的类，但是存在依赖的关系class Dog:def __init__(self, name, age, breed, master):self.name = nameself.age = ageself.breed = breedself.master = master # 是一个对象self.sayhi() # 在初始化的时候调用自己的方法def sayhi(self):print("Hi, I'm %s, a %s dog, my master is %s."%(self.name, self.breed, self.master.name))class Person:def __init__(self, name, age, sex):self.name = nameself.age = ageself.sex = sexdef walk_dog(self, dog):print("主人[%s]带着狗狗[%s]去溜溜"%(self.name,dog.name))per1 = Person("ZZZ",23,"男")
dog1 = Dog("XXX",22,"二哈",per1) # noticed:传入的是一个对象#------------------------------------------------------------------------------------------------------------------------------------'''关联关系'''# 关联关系是不同的实例属于同一个类，但是存在关联的关系class People:def __init__(self, name, age, sex):self.name = nameself.age = ageself.sex = sexself.parter = None # 应该是一个对象， 代表 另一半def do_some_thing(self):passp1 = People("XXX",22,"Woman")
p2 = People("ZZZ",23,"Man")# 方法一：p1.parter = p2
p2.parter = p1print("%s的男朋友是%s"%(p1.name,p1.parter.name))# 方法二：
# 在7中

七、关联关系（方法2）

创建一个字典类型的变量

class Relationship:def __init__(self):# 字典类型,里边放了两个对象self.couple  = {"Woman":None,"Man":None}def make_couple(self,Woman,Man): # 传入的是对象self.couple["Woman"] = Womanself.couple["Man"] = Manprint("%s和%s确定了男女关系"%(Woman.name,Man.name))def Get_Parter(self,People):if People.sex == "Woman":return self.couple["Man"] # 返回的是一个对象elif People.sex == "Man":return self.couple["Woman"] # 返回的是一个对象else:print("傻逼你没有对象")def Break_up(self):print("%s和%s正式分手了,江湖再见..."%(self.couple["Man"].name,self.couple["Woman"].name))self.couple["Woman"] = Noneself.couple["Man"] = Noneclass People:def __init__(self, name, age, sex, Relationship):self.name = nameself.age = ageself.sex = sexself.Relationship = Relationship # 应该是一个对象， 代表 另一半def do_some_thing(self):passrelation = Relationship() # 实例化一个关系（对象）p1 = People("XXX",22,"Woman",relation)
p2 = People("ZZZ",23,"Man",relation)relation.make_couple(p1,p2)print("%s的男朋友是%s"%(p1.name,p1.Relationship.Get_Parter(p1).name))p1.Relationship.Break_up()print("%s的男朋友是%s"%(p1.name,p1.Relationship.Get_Parter(p1)))

八、组合关系

由一堆组件构成一个完整的整体，组件本身相互独立，但是又不能自己运行，必须和宿主组合在一起，运行


class Dog:role = "dog" # 每个狗（实例化后）都是狗类（角色）def __init__(self, name, breed, attack_val):self.name = nameself.breed = breedself.attack_val = attack_valself.life_val = 100def bite(self, person): # 这里传入的person也是一个对象person.life_val -= self.attack_valprint("狗[%s]咬了人[%s]一口，人掉血[%s]，还有血量[%s]..."%(self.name,person.name,self.attack_val,person.life_val))
class Weapon:# 定义几个方法：def stick(self, obj):"""打狗棒"""self.name = "打狗棒"self.attack_val = 40obj.life_val -= self.attack_valself.print_log(obj) # 调用类方法def knife(self, obj):"""屠龙刀"""self.name = "屠龙刀"self.attack_val = 80obj.life_val -= self.attack_valself.print_log(obj) # 调用类方法def gun(self, obj):"""AK47"""self.name = "AK47"self.attack_val = 100obj.life_val -= self.attack_valself.print_log(obj) # 调用类方法def print_log(self,obj):print("[%s]被[%s]攻击了，掉血[%s]，还剩血量[%s]..."%(obj.name,self.name,self.attack_val,obj.life_val))class Person:role = "person"def __init__(self, name, sex):self.name = nameself.sex = sexself.Weapon = Weapon() # 在Person这个类中直接对于Weapon这个类进行实例化self.life_val = 100def hit(self, dog):dog.life_val -= self.attack_valprint("人[%s]打了狗[%s]一棍，狗掉血[%s]，还有血量[%s]..."%(self.name,dog.name,self.attack_val,dog.life_val))per1 = Person("ZZZ","M")
dog1 = Dog("XXX","二哈",30)dog1.bite(per1)per1.Weapon.stick(dog1)

九、继承

# 父类：class Animal:a_type = "哺乳动物"def __init__(self, name, age, sex):self.name = nameself.age = ageself.sex = sexdef Eatting(self):print("%s is eatting..."%(self.name))# 子类 :子类将继承父类所有的属性和方法class Person(Animal): # 继承Animal父类a_type = "哺乳高等动物"def __init__(self, name, age, sex, hobbie):# Animal.__init__(self, name, age, sex) # 作用同上# super(Person, self).__init__(name, age, sex) # 作用同上# super().__init__(name, age, sex) # 作用同上# 表示继承父类属性super(Person, self).__init__(name, age, sex)self.hobbie = hobbiedef Talking(self):print("%s is Talking...."%(self.name))# 重写父类的方法def Eatting(self):print("%s正在优雅的吃东西"%(self.name))p1 = Person("张辉",22,"男","女人")p1.Talking()
p1.Eatting()

十、多继承

# 多继承Multiple Inheritanceclass ShenXian:'''神仙类'''def fly(self):print("神仙会飞....")def fight(self):print("神仙在打架....")class Monkey:def eat_peach(self):print("猴子都喜欢吃桃子....")def fight(self):print("猴子在打架....")class MonkeyKing(ShenXian, Monkey): # 相同的方法时，继承第一继承人的方法ShenXiandef Play_Goden_Stick(self):print("孙悟空玩金箍棒....")# 实例化sxz = MonkeyKing()sxz.eat_peach()
sxz.fly()
sxz.Play_Goden_Stick()
sxz.fight()

十一、封装


# 封装：把一些重要的实例的数据（不想被外部访问或者修改的数据）通过一些方法进行封装起来，但是这个数据还存在
# 把它变成私有变量,加两个下划线
# 私有变量只读from time import clock_settimeclass Person():def __init__(self, name, age):self.name = name # 实例变量、实例属性self.age = age   # 实例变量、实例属性self.__life_vel = 100 # 私有属性、私有变量 这样就实现了封装# 为了可以访问私有属性，我们可以从实例所在的类内部进行访问def Get_life_val(self):'''这是对于私有属性的封装（方法）'''return self.__life_vel# 私有方法def __breath(self):print("%s正在呼吸呢..."%(self.name))# 如果想访问私有方法，只能在类内部进行访问def Quick_Breath(self):self.__breath()p = Person("ZZZ",23)# print(p.__life_vel) 这样会报错，因为私有属性外部无法访问print(p.Get_life_val())# p.__breath() 这样也是会报错的，因为私有方法外部无法访问p.Quick_Breath() # 这样就可以进行访问了# 私有方法在实际上也是可以访问的： 实例名._类名+方法名（带着__）p._Person__breath()# 一般不推荐这样用# 私有属性在实际上也是可以访问的： 实例名._类名+属性名（带着__）p._Person__life_val = 80print(p.Get_life_val())#  多态class Dog(object):def __init__(self) -> None:passdef sound(self):print("汪汪汪...")class Cat(object):def __init__(self) -> None:passdef sound(self):print("喵喵喵...")def make_sound(animal_obj):"统一调用接口"animal_obj.sound()d = Dog()
c = Cat()make_sound(d)
make_sound(c)# ----->class Document: # 父类def __init__(self, name):self.name = namedef show(self): # 主动报错，要求子类必须重新该方法raise NotImplementedError("Subclass must implement abstrat method!")class Word(Document):pass# 并没有重写show方法class Pdf(Document):def show(self):return 'Show pdf contents1'pdf = Pdf("000.pdf")
print(pdf.show())word = Word("000.word")# word.show() 这样会报错

十二、类方法


# 1、类方法
# 类方法通过@classmethod装饰器实现，类方法和普通方法的区别是，类方法只能访问类变量，不能访问实例变量class Dog(object):age = 10 # 类变量、公共变量def __init__(self, name):self.name = name # 实例变量@classmethoddef eatting(self): # classmethod的self传进来的是类本身，而不是实例本身print("dog %s is eatting..."%self.name) # 看看类方法可不可以访问实例变量@classmethoddef looking(self):print("dog %s is looking..."%self.age) # 看看类方法可不可以访问类变量d = Dog("asd")# d.eatting() 报错d.looking()#---------->class Student(object):stu_num = 0 # 类变量类似于静态变量，在访问类空间时，可以看到类变量（公共变量的值）def __init__(self, name):self.name = name # 实例变量# self.stu_num += 1 # 一定要主要在这里其实相当于又创建了一个与stu_num公共变量重名的实例变量# 如果要实现计数（多少次实例化）那应该写着一行代码Student.stu_num += 1 # 这样，每一次实例化（初始化的过程中）便可以实现对于类变量（公共变量）的改变print("刚刚生成了一个学生（对象）,叫做%s"%self.name,self.stu_num) # 查看现在一共几个学生s1 = Student("A") # A 1
s2 = Student("B") # B 2
s3 = Student("C") # C 3
print(Student.stu_num) # 从外部访问类变量stu_num = 3

十三、静态方法

# 静态方法 @staticmethod# 不能访问类变量，也不能访问实例变量class Student(object):role = "Student"def __init__(self, name):self.name = namedef fly(self):print(self.name,"is flying...")@staticmethod   def look(self): # 静态方法隔离了他跟类或者实例的任何关系，其实这个self并没有传进来，self代表的是实例本身print(self.name,"is looking...")s = Student("张辉")s.fly()# s.look() # 这样会报错 说是缺少一个变量 'self'
s.look(s) # 这样手动的进行传（实例变量进入到静态方法中是可以的）

十四、属性方法

把一个方法变成一个静态的属性

class Student(object):role = "Student"def __init__(self, name):self.name = name@property   def fly(self): # 把方法变成一个属性print(self.name,"is flying...")s = Student("ZZZ")# s.fly() 这样会报错s.fly # 要知道fly（）方法已经被变成了一个属性，所以在调用的时候也要按照属性的格式进行调用

十五、反射


# 反射：# 程序可以访问、检测和修改他本身状态或者行为的一种能力（自省）# python中面向对象的反射：
# 通过字符串的形式操作对象相关的属性。python中的一切事物都是对象（都可以使用反射）
## 四个可以实行自省的函数class Person(object):role = "Person"def __init__(self, name, age):self.name = nameself.age = agedef walk(self):print("Walking....")p = Person("张辉",22)if hasattr(p,"name2"): # hasattr去检测在实例p中有没有一个叫做name2的属性attributeprint("yes")
else:print("No")if hasattr(p,"name"): # hasattr去检测在实例p中有没有一个叫做name2的属性attributeprint("yes")
else:print("No")# ！！！从外部获取指令，判断有没有，然后再调用类或者实例的方法# 四种方法用于反射（自省）实例的属性或者方法,# getattr 获取
# hasattr 判断
# setattr 赋值
# delattr 删除# getattr & hasattra = getattr(p,"age")
print(a)user_command = input(">>:").strip()if hasattr(p,user_command):func = getattr(p,user_command)func()# setattrsetattr(p,"sex","female") # 新建一个属性，叫sex，并且赋值叫做"female"
print(hasattr(p,"sex")) # return : Ture
print(p.sex) # return : female# 给实例新增一个方法def speak(self):print(self.name,"is Speaking....")setattr(p,"speak",speak)
p.speak(p)# delattr
print(p.age)
delattr(p,"age")
print(p.age)

十六、文件反射

class Person(object):role = "Person"def __init__(self, name, age):self.name = nameself.age = agedef walk(self):print("Walking....")p = Person("张辉",22)# 如何反射一个文件下指定字符串对象的属性或者方法print(__name__) # 结果是__main__if __name__ == "__main__": # 只有在被别的模块（文件.py）导入的时候这个判断才有意义print("yes,执行程序")# 本模块（文件.py）在被别的模块（文件.py）导入的时候，__name__等于模块名，也就是"17"import sys# for k,v in sys.modules.items():# print(k,v)print(sys.modules["__main__"]) # 这个玩意就是本模块（文件.py）#在本模块之前已经定义了一个p对象mod = sys.modules["__main__"]if hasattr(mod,"p"):o = getattr(mod,"p") #此时o就是p这个对象print(o)o.walk()# 上述操作也可以在不同模块间进行，导入方法也可以，并不是只限于类对象实例啥的

十七、动态加载模块指令


# 动态加载模块指令（热加载，在运行的过程中加载进来）# 就是有一个字符串，然后我们将这个字符串对应的模块名导入进来__import__("15") # 这个一般是解释器用的，导入15.py这个模块并执行# python官方建议这样使用：import importlibimportlib.import_module("15")# ----->class User(object):def login(self):print("欢迎来到登陆界面...")def register(self):print("欢迎来到注册页面...")def save(self):print("欢迎来到存储页面...")u = User()while True:user_cmd = input(">>:").strip()if hasattr(u, user_cmd):func = getattr(u,user_cmd)func()

十八、new方法

# new方法# 注意：__new__会在__init__之前执行# __new__是用来调用__init__的
# 如果重写了__new__那么需要手动调用__init__class Student(object):def __init__(self, name): # self代表实例或者类本身self.name = nameprint("hhhhh")def __new__(cls, *args, **kwargs): # cls代表类本身# __new__是负责执行__init__的print(cls, *args, **kwargs)# <class '__main__.Student'> XXX# 继承一下之前的__new__(),否则无法调用__init__（）return object.__new__(cls)p = Student("XXX")

十九、动态创建方法

class Person(object):def __init__(self, name, age):self.name = nameself.age = age p = Person("ZZZ",22)print(type(p))
# <class '__main__.Person'>print(type(Person))
# <class 'type'>def __init__(self, name, age):self.name = nameself.age = agedog_class = type("Dog",(object,),{"role":"dag","__init__":__init__}) #  Dog是类名字，(object,)表示继承的父类，{"role":"dag","__init__":__init__}是属性和方法，采用健值对的方式
# dog_class类的变量名print(dog_class)
# <class '__main__.dog'>d = dog_class("mjj",22)
print(d.role) # dag

总结

提示：没有总结，哈哈哈哈。

Python面向对象的编程相关推荐

【Python进阶】实战Python面向对象基本编程
欢迎来到专栏<Python进阶>.在这个专栏中,我们会讲述Python的各种进阶操作,包括Python对文件.数据的处理,Python各种好用的库如NumPy.Scipy.Matplotl ...
python面向对象的编程_python面向对象的编程
创建类和对象面向对象编程是一种编程方式,此编程方式的落地需要使用 "类" 和 "对象" 来实现,所以,面向对象编程其实就是对 "类" 和 ...
神经网络与深度学习——TensorFlow2.0实战(笔记)(四)(Python面向对象的编程)
面向对象的程序设计(OOP) 对象(object): 将属性和方法封装在一起. 类(class): 具有相同的属性和方法的对象集合. 对象是类的实例子类继承了父类的全部属性和方法, 并且也有自己特 ...
Python 面向对象高级编程——定制类
1.1 定制类 1.1.1 __str__ >>> class Student(object): ... def __init__(self, name): ... ...
Python面向对象高级编程
1.__slots__ 通过Types包中的MethodType将外部方法与类对象进行绑定(该方法只能对绑定的对象生效) """a test module"&q ...
python面向对象OOP编程（三）-- 同类不同实例之间的关联关系
当一个类有多个实例,但是在实例之间有着相互的关联关系,此时,不建议在实例中新增一个成员属性来描述这种关联关系据一个实际场景来帮助理解:People类有两个实例:AA和BB,AA是男的,BB 是女的, ...
python笔记2（函数面向对象文件编程上下文管理器）
记录python听课笔记文章目录记录python听课笔记一,函数 1.介绍python里的函数 2.用户自定义函数 3.变量的作用域 4.参数的传递 5.参数的默认值 6.向函数内部批量传递数据 ...
Python学习笔记：面向对象高级编程（完）
前言最近在学习深度学习,已经跑出了几个模型,但Pyhton的基础不够扎实,因此,开始补习Python了,大家都推荐廖雪峰的课程,因此,开始了学习,但光学有没有用,还要和大家讨论一下,因此,写下这些帖 ...
Python学习笔记：面向对象高级编程（中下）
前言最近在学习深度学习,已经跑出了几个模型,但Pyhton的基础不够扎实,因此,开始补习Python了,大家都推荐廖雪峰的课程,因此,开始了学习,但光学有没有用,还要和大家讨论一下,因此,写下这些帖 ...

Python面向对象的编程