python面对对象
Posted 我是小旋风
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了python面对对象相关的知识，希望对你有一定的参考价值。
中间隔有python模块没有进行更新，是因为觉得模块的操作应用更应该记牢，再次先不更新
1,面对对象的作用: 能简化思路和代码
2,面对对象的思路：
不着急直接去计算/操作代码获取结果
从一个大的问题中，找到要描述的角色
将角色的属性和行为抽象出来
形成一个模子
后期用到角色的时候，都围绕这个模子来操作。
人狗大战
#人狗大战 #角色 #alex = {\'name\':\'alex\',\'sex\':None,\'hp\':10,\'ad\':1} #taibai = {\'name\':\'哮天犬\',\'kind\':\'teddy\',\'hp\':100,\'ad\':50} def Person(name,sex,hp,ad): #创造一个模子，约束一个人必须有的属性，规范属性的名字，简化了用户的操作 person = { \'name\':name, \'sex\':sex, \'hp\':hp, \'ad\':ad } def attack(dog): #攻击 print(\'%s攻击了%s\'%(person[\'name\'],dog[\'name\'])) dog[\'hp\'] -= person[\'ad\'] print(\'%s掉了%s点血，剩余血量%s\'%(dog[\'name\'],person[\'ad\'],dog[\'hp\'])) person[\'attack\']=attack return person #狗的特性及能力 def Dog(name,sex,hp,ad): dog = { \'name\':name, \'kind\':sex, \'hp\':hp, \'ad\':ad } def bite(person): print(\'%s咬了%s\'%(dog[\'name\'],person[\'name\'])) if person[\'hp\']<=dog[\'ad\']: person[\'hp\'] = 0 #疑问 这里更改变量 全局里的会发生改变吗 print(\'剩余血量以为零，GAMEOVER\') else: person[\'hp\'] -= dog[\'ad\'] print(\'%s掉了%s点血，剩余血量%s\'%(person[\'name\'],dog[\'ad\'],person[\'hp\'])) dog[\'bite\'] = bite return dog alex = Person(\'alex\',None,10,1) taibai = Dog(\'哮天犬\',\'teddy\',100,50) alex[\'attack\'](taibai) taibai[\'bite\'](alex)
#类: 一类抽象的事物,是描述了一类事物有哪些属性或者行为,但不并不具体
#实例: 就是一个依托于类的规范存在的,被赋予了具体属性值得实际存在的物体
#对象:对象就是实例 这两个是一个 只是不同的说法而已
#实例化: 有一个类产生一个对象/实例的过程
************************************************************************************************************************************************
函数式编程vs面向对象编程
# 函数式编程 # auth 认证相关 def login(): pass def regisgter(): pass # account 账户相关 def func1(): pass def func2(): pass # 购物车相关 def shopping(username,money): pass def check_paidgoods(username,money): pass def check_unpaidgoods(username,money): pass def save(username,money): pass 函数式编程
#面对对象编程
class LoginHandler: def login(self): pass def regisgter(self): pass class Account: def func1(self): pass def func2(self): pass class ShoppingCar: def shopping(username,money): pass def check_paidgoods(username,money): pass def check_unpaidgoods(username,money): pass def save(username,money): pass 面向对象式编程
面向对象编程：是一类相似功能函数的集合,使你的代码更清晰化，更合理化。
面向对象的程序设计的核心是对象（上帝式思维），要理解对象为何物，必须把自己当成上帝，上帝眼里世间存在的万物皆为对象，不存在的也可以创造出来。
那什么是类？什么是对象？
类：就是具有相同属性和功能的一类事物。
对象：就是类的具体表现。
具体一些：先解释解释什么是⻋? 有轱辘, 有方向盘, 有发动机, 会跑的是车。 好，在解释一个. 什么是人：有名字, 年龄, 爱好, 会唱歌跳舞思考的是人。那么广义上 车，人就是类：但是具体的我的车，你这个人这是一个对象。
猫，是一类，你们家养的 大橘。
狗，是一类，隔壁家养的那只二哈就是对象。
3,类 ：一类抽象的事物，是描述了一类事物有哪些属性或者行为，但是不具体。
类的结构：
class Human: """ 此类主要是构建人类 """ mind = \'有思想\' # 第一部分：静态属性 属性 静态变量 静态字段 就是一个变量 dic = {} l1 = [] def work(self): # 第二部分：方法 函数 动态属性 ---自带一个叫做self的形参，约定俗成的 print(\'人类会工作\')
print(Human.mind) #查看类里面的静态属性
print(Human.work(1)) #执行类里面的函数 这里要注意self 也是要传的参数
print(Human.__dict__)#将类里所有的属性存在这个字典里 class 是关键字与def用法相同，定义一个类。 Human是此类的类名，类名使用驼峰(CamelCase)命名风格，首字母大写，私有类可用一个下划线开头。 类的结构从大方向来说就分为两部分： 静态变量。 动态方法。
类名可以做两件事：
查看静态属性和动态属性
创造一个对象-->类名加（） 就是创造了一个对象
会自动的触发有__init__的方法
#类里面的传参是传到有 __init__的方法里 class Person: Country = \'China\' def __init__(self,name,sex,hp,ad): print(\'self\',self) obj = Person(\'alex\',None,100,50) print(\'obj\',obj) 这个obj的地址和self的地址一致，同一个地址
类的相关知识
类名操作静态属性
第一种，查看类中的所有内容：类名.__dict__方式。
class Human: """ 此类主要是构建人类 """ mind = \'有思想\' # 第一部分：静态属性 属性 静态变量 静态字段 dic = {} l1 = [] def work(self): # 第二部分：方法 函数 动态属性 # print(self) print(\'人类会工作\') print(Human.__dict__) print(Human.__dict__[\'mind\']) Human.__dict__[\'mind\'] = \'无脑\' print(Human.__dict__) # 错误 #通过这种方式只能查询，不能增删改. # 第一种方式只用户查询全部内容（一般不用单独属性查询）.
第二种：万能的点.
class Human: """ 此类主要是构建人类 """ mind = \'有思想\' # 第一部分：静态属性 属性 静态变量 静态字段 dic = {} l1 = [] def work(self): # 第二部分：方法 函数 动态属性 # print(self) print(\'人类会工作\') print(Human.mind) # 查 Human.mind = \'无脑\' # 改 print(Human.mind) del Human.mind # 删 Human.walk = \'直立行走\' print(Human.walk) # 通过万能的点 可以增删改查类中的单个属性
对以上两种做一个总结：如果想查询类中的所有内容，通过 第一种__dict__方法，如果只是操作单个属性则用万能的点的方式。
类名操作动态方法
class Human: """ 此类主要是构建人类 """ mind = \'有思想\' # 第一部分：静态属性 属性 静态变量 静态字段 dic = {} l1 = [] def work(self): # 第二部分：方法 函数 动态属性 # print(self) print(\'人类会工作\') def tools(self): print(\'人类会使用工具\') Human.work(111) Human.tools(111) 下面可以做，但不用。 Human.__dict__[\'work\'](111)
类有两种作用：属性引用和实例化
属性引用（类名.属性）
class Person: #定义一个人类 role = \'person\' #人的角色属性都是人 def walk(self): #人都可以走路，也就是有一个走路方法 print("person is walking...") print(Person.role) #查看人的role属性 print(Person.walk) #引用人的走路方法，注意，这里不是在调用
实例化：类名加括号就是实例化，会自动触发__init__函数的运行，可以用它来为每个实例定制自己的特征
class Person: #定义一个人类 role = \'person\' #人的角色属性都是人 def __init__(self,name): self.name = name # 每一个角色都有自己的昵称; def walk(self): #人都可以走路，也就是有一个走路方法 print("person is walking...") print(Person.role) #查看人的role属性 print(Person.walk) #引用人的走路方法，注意，这里不是在调用
实例化的过程就是类——>对象的过程
原本我们只有一个Person类，在这个过程中，产生了一个egg对象，有自己具体的名字、攻击力和生命值。
语法：对象名 = 类名(参数)
egg = Person(\'egon\') #类名()就等于在执行Person.__init__() #执行完__init__()就会返回一个对象。这个对象类似一个字典，存着属于这个人本身的一些属性和方法。
查看属性&调用方法
print(egg.name) #查看属性直接 对象名.属性名 print(egg.walk()) #调用方法，对象名.方法名()
类属性的补充
一：我们定义的类的属性到底存到哪里了？有两种方式查看 dir(类名)：查出的是一个名字列表 类名.__dict__:查出的是一个字典，key为属性名，value为属性值 二：特殊的类属性 类名.__name__# 类的名字(字符串) 类名.__doc__# 类的文档字符串 类名.__base__# 类的第一个父类(在讲继承时会讲)：只会查看从左到右第一个类 类名.__bases__# 类所有父类构成的元组(在讲继承时会讲) 类名.__dict__# 类的字典属性 类名.__module__# 类定义所在的模块 类名.__class__# 实例对应的类(仅新式类中) 类属性的补充
对象的相关知识
什么是对象
对象是从类中出来的，只要是类名加上（），这就是一个实例化过程，这个就会实例化一个对象。
class Human: mind = \'有思想\' def __init__(self): print(666) print(self) # <__main__.Human object at 0x00000191508AA828> def work(self): print(\'人类会工作\') def tools(self): print(\'人类会使用工具\') obj = Human() # 只要实例化对象，它会自动执行__init__方法 print(obj) # <__main__.Human object at 0x00000191508AA828> # 并且obj的地址与self的地址相同
其实实例化一个对象总共发生了三件事：
1，在内存中开辟了一个对象空间。
2，自动执行类中的__init__方法，并将这个对象空间（内存地址）传给了__init__方法的第一个位置参数self。
3，在__init__ 方法中通过self给对象空间添加属性。
class Human: mind = \'有思想\' language = \'使用语言\' def __init__(self,name,sex,age,hobby): # self 和 obj 指向的是同一个内存地址同一个空间，下面就是通过self给这个对象空间封装四个属性。 self.n = name self.s = sex self.a = age self.h = hobby obj = Human(\'barry\',\'男\',18,\'运动\')
通过函数来理解对象
def Person(*args,**kwargs): self = {} def attack(self,dog): dog[\'life_value\'] -= self[\'aggressivity\'] def __init__(name,aggressivity,life_value): self[\'name\'] = name self[\'aggressivity\'] = aggressivity self[\'life_value\'] = life_value self[\'attack\'] = attack __init__(*args,**kwargs) return self egg = Person(\'egon\',78,10) print(egg[\'name\'])
对象操作对象空间属性
1）对象查询对象中所有属性。 对象.__dict__
class Human: mind = \'有思想\' language = \'实用语言\' def __init__(self,name,sex,age,hobby): # self 和 obj 指向的是同一个内存地址同一个空间，下面就是通过self给这个对象空间封装四个属性。 self.n = name self.s = sex self.a = age self.h = hobby obj = Human(\'barry\',\'男\',18,\'运动\') print(obj.__dict__) # {\'n\': \'barry\', \'h\': \'运动\', \'s\': \'男\', \'a\': 18}
2）对象操作对象中的单个属性。 万能的点 .
class Human: mind = \'有思想\' language = \'实用语言\' def __init__(self,name,sex,age,hobby): # self 和 obj 指向的是同一个内存地址同一个空间，下面就是通过self给这个对象空间封装四个属性。 self.n = name self.s = sex self.a = age self.h = hobby obj = Human(\'barry\',\'男\',18,\'运动\') obj.job = \'IT\' # 增 del obj.n # 删 obj.s = \'女\' # 改 print(obj.s) # 查 print(obj.__dict__)
对象查看类中的属性
class Human: mind = \'有思想\' language = \'实用语言\' def __init__(self,name,sex,age,hobby): self.n = name self.s = sex self.a = age self.h = hobby obj = Human(\'barry\',\'男\',18,\'运动\') print(obj.mind) print(obj.language) obj.a = 666 print(obj.a)
对象操作类中的方法
class Human: mind = \'有思想\' language = \'实用语言\' def __init__(self,name,sex,age,hobby): self.n = name self.s = sex self.a = age self.h = hobby def work(self): print(self) print(\'人类会工作\') def tools(self): print(\'人类会使用工具\') obj = Human(\'barry\',\'男\',18,\'运动\') obj.work() obj.tools()
类中的方法一般都是通过对象执行的（除去类方法，静态方法外），并且对象执行这些方法都会自动将对象空间传给方法中的第一个参数self.
self 是什么？
self其实就是类中方法（函数）的第一个位置参数，只不过解释器会自动将调用这个函数的对象传给self。
所以咱们把类中的方法的第一个参数约定俗成设置成self, 代表这个就是对象。
********************************************************************************************************************************
实例化： 由一个类产生一个对象/实例的过程。 创建对象的过程 对象=类名（）
#1，创建一个对象 产生一些类对象指针
#2，调用init方法，将创造的对象传给self，执行init方法
#3，将self自动的返回给调用者及对象
创造一个函数：用def（开头用小写）
创造一个类：用class(一般开头要用大写)
class Person: 这个整体就是类 country = ‘China’#静态属性 def func(self): print(123) def aaa(self): Person 是一个类名
Person()#这就是对象
Person 中可以放两个东西（类中可以定义的）：
静态属性:就是变量--是所有的对象共享的一个属性
动态属性（方法）:就是函数 自带一个叫做self的形参 特殊的__init__方法
类中写的所有的静态属性和动态属性都是所有对象共享的。
在self空间中或者是在实例化之后的对象的空间中定义的变量都是属于某个对象的
类名可以做两件事情：
查看静态属性和动态属性
创造一个对象 也就是实例化
对象：调用方法 查看对象命名空间中的属性
class Person: Country = \'China\' def func(self): print(123) def __init__(self,name,sex,hp,ad): print() print(Person.Country) #通过.连接其中的元素 print(Person.func) Person.func(0) #使用Person调用方法的时候 self也是一个需要传的参数 print(Person.__dict__) #内置的一个字典 将变量和函数存进去 #创造一个对象的过程:对象 = 类名+（） #首先要创造一个对象 #会自动的触发__init__函数，将创造出来的对象的地址创给self（self和obj是同一个东西） #执行init中的代码 #将self指向的地址再返回给调用者 obj = Person（\'alex\',None,10,1） #会自动化执行 def __init__(self):
需要注意：
#这时候传的参数还没有传到self所指向的内存空间里，因为在内存空间里，self 与name，sex等参数还未有联系 class Person: Country = \'China\' def __init__(self,name,sex,hp,ad): pass obj = Person(\'alex\',None,100,50) class Person: Country = \'China\' def __init__(self,name,sex,hp,ad):#将参数与self关联-初始化方法 self.user = name #这里self.后面的名称可以起任意名 self.sex=sex self.hp = hp self.ad = ad print(self.__dict__)#{\'name\':\'alex\',\'sex\':None,\'hp\':100,\'ad\':50} #和人狗大战里面的dic很像，只是换了一种方法 obj = Person(\'alex\',None,100,50)#实例化 print(obj.user)
学过对象后，优化人狗大战代码：下面加了self.name=name...这样self和形参才关联起来
class Person: def __init__(self,name,sex,hp,ad): self.name=name self.sex=sex self.hp=hp self.ad=ad def attack(self,dog): #攻击 print(\'%s攻击了%s\'%(self.name,dog.name)) dog.hp -= self.ad print(\'%s掉了%s点血，剩余血量%s\'%(dog.name,self.ad,dog.hp)) class Dog: def __init__(self,name,kind,hp,ad): self.name=name self.kind=kind self.hp=hp self.ad=ad def bite(self,person): print(\'%s咬了%s\'%(self.name,person.name)) person.hp -= self.ad if person.hp>0: print(\'%s掉了%s点血，剩余血量%s\'%(person.name,self.ad,person.hp)) else: person.hp = 0 print(\'gameover\') alex = Person(\'alex\',None,10,1) #实例化 #print(alex.__dict__) taibai = Dog(\'哮天犬\',\'teddy\',100,50)#实例化 alex.attack(taibai) #相当于---->Person.attack(alex,taibai) 记住Alex就是self
对象的执行过程：为什么用类对象指针 节能内存，如果人特别多，不可能将方法存在每个用户内存里，先有类 后有对象
对象名可以调用静态属性--->类名空间与对象空间
class Person: Country = \'China\' def __init__(self,name): #这个叫初始化方法 self.name=name def attack(self): print(\'attack\') alex = Person(\'以上是关于python面对对象的主要内容，如果未能解决你的问题，请参考以下文章