一、三大编程范式：
面向过程：
面向函数：
面向对象：
二、程序的进化论：
1.编程最开始就是无组织无结构，从简单控制流中按步写指令
2.从上述的指令中提取重复的代码块或逻辑，组织到一起(比方说，你定义了一个函数)，便实现了代码重用，且代码由无结构走向了结构化，创建程序的过程变得更具逻辑性
3.我们定义函数都是独立于函数外定义变量，然后作为参数传递给函数，这意味着：数据与动作是分离的
4.如果我们把数据和动作内嵌到一个结构(函数或类)里面，那么我们就有了一个‘对象系统’（对象就是数据与函数整合到一起的产物）。
三、面向对象初见面：
3.1
#你是谁?【名字、属性、特征、。。】你在干什么【动作】?千年的哲学问题!
两者组合起来：实现了两者的交互：对象正在做什么事情!
#狗的属性特征
dog1={'name':'苑昊','gender':'母','type':'腊肠'}
dog2={'name':'alex', 'gender':'母','type':'津巴'} person={'name':'武sir', 'gender':'母','type':'人'}
#狗的动作
def jiao(dog):
print('一条狗[%s],汪汪汪'%dog['name'] ) def chi_shi(dog):
print('一条狗[%s]正在吃屎' %dog['type'])
jiao(dog1)
chi_shi(dog1)
chi_shi(dog2)
jiao(person)
3.2、实现狗只能执行狗的动作，人执行狗的动作。 解决方法：绑定一块
解决方式：在对象里面加入属性的字段，之后在调用过程中，进行if判断。显得太low！
比较好的办法：
def dog():
# 狗的动作
def jiao(dog):
print('一条狗[%s],汪汪汪' % dog['name'])
def chi_shi(dog):
print('一条狗[%s]正在吃屎' % dog['type'])
# 狗的属性特征+属性
dog1 = {'name': '苑昊',
'gender': '母',
'type': '腊肠',
'jiao': jiao,
'chi_shi':chi_shi
}
return dog1
d1=dog() #拿到一个字典,里面有函数的内存地址
print(d1)
d1['jiao'](d1)
>>>
{'jiao': <function dog.<locals>.jiao at 0x10207c9d8>, 'type': '腊肠', 'gender': '母', 'name': '苑昊', 'chi_shi': <function dog.<locals>.chi_shi at 0x10207ca60>}
一条狗[苑昊],汪汪汪
实现了：
字典dog1就是一个明确的对象：包含了狗的属性特征和动作（函数），内嵌动作的明确函数。有属性，有动作，就形成额一条完整的狗。
3.3、新的问题:狗的对象里面只有一条狗，被写死了。解决办法：作为参数传入。一个字典代表一一条狗的完整信息，批量生产字典
def dog(name,gender,type):
# 狗的动作
def jiao(dog):
print('一条狗[%s],汪汪汪' % dog['name'])
def chi_shi(dog):
print('一条狗[%s]正在吃屎' % dog['type'])
# 狗的属性特征+属性
dog1 = {'name': name,
'gender': gender,
'type': type,
'jiao': jiao,
'chi_shi':chi_shi
}
return dog1
d1=dog('袁浩','母','京巴') #拿到一个字典,里面有函数的内存地址:包含函数
d2=dog('alex','母','京巴') #一个字典就是一条丰满的对象。每执行一次就生产一条狗。
print(d1)
print(d2)
d1['jiao'](d1)
d2['chi_shi'](d2) >>>
{'name': '袁浩', 'type': '京巴', 'gender': '母', 'chi_shi': <function dog.<locals>.chi_shi at 0x10217cae8>, 'jiao': <function dog.<locals>.jiao at 0x10217ca60>}
{'name': 'alex', 'type': '京巴', 'gender': '母', 'chi_shi': <function dog.<locals>.chi_shi at 0x10217cbf8>, 'jiao': <function dog.<locals>.jiao at 0x10217cb70>}
一条狗[袁浩],汪汪汪
一条狗[京巴]正在吃屎
3.4、定义初始化函数：init（）完成初始化对象：一条狗函数最终一条活色生香的狗！————————————→ 明确的对象：一个独立的，完整的个体！是一个类具体的存在！
通过初始化函数把属性和正在进行的动作扎何在一块。
def dog(name,gender,type):
# 狗的动作
def jiao(dog):
print('一条狗[%s],汪汪汪' % dog['name'])
def chi_shi(dog):
print('一条狗[%s]正在吃屎' % dog['type'])
# 狗的属性特征+属性：初始化一条完整的狗！
def init(name,gender,type):
dog1 = {'name': name,
'gender': gender,
'type': type,
'jiao': jiao,
'chi_shi':chi_shi
}
return dog1
return init(name,gender,type)
d1=dog('袁浩','母','京巴') #拿到一个字典,里面有函数的内存地址:包含函数
d2=dog('alex','母','京巴') #一个字典就是一条丰满的对象。每执行一次就生产一条狗。
print(d1)
print(d2)
d1['jiao'](d1)
d2['chi_shi'](d2) >>>
{'chi_shi': <function dog.<locals>.chi_shi at 0x10333db70>, 'jiao': <function dog.<locals>.jiao at 0x10333d9d8>, 'name': '袁浩', 'type': '京巴', 'gender': '母'}
{'chi_shi': <function dog.<locals>.chi_shi at 0x10333dae8>, 'jiao': <function dog.<locals>.jiao at 0x10333da60>, 'name': 'alex', 'type': '京巴', 'gender': '母'}
一条狗[袁浩],汪汪汪
二、顺序调整
def school(name,hangye,type,):
def init(name, hangye, type, ):#初始化函数:该对象的属性特征和动作函数的集合,下面是所有动作函数的明细
dic_q = {
'name': name,
'hangye': hangye,
'类型': type,
'考试': kaoshi,
'招生': zhaoshen
}
return dic_q
def kaoshi(school2):
print('一所%s企业,名字是:%s, 正在进行一场考试' %(school2['类型'],school2['name']))
def zhaoshen(school2):
print('一所%s企业,名字是:%s, 正在进行招生' % (school2['类型'], school2['name']))
return init(name,hangye,type,)
school1=school('老男孩','教育培训','民营',)
print(school1)
school1['招生'](school1)
school1['考试'](school1) >>>>
{'hangye': '教育培训', '类型': '民营', '考试': <function school.<locals>.kaoshi at 0x10333eae8>, '招生': <function school.<locals>.zhaoshen at 0x10333e9d8>, 'name': '老男孩'}
一所民营企业,名字是:老男孩, 正在进行招生
一所民营企业,名字是:老男孩, 正在进行一场考试
3.5、类
对象：描述性特征+动作的结合。 针对类的一个明确的具体对象
类：一个种类，具有相同子对象的集合，来分区于其他的种类，共同特征+动作的集合。抽象的概念，抽象共同的特征，共同的动作！
3.6、面向对象设计和面向对象编程
1⃣️、面向对象设计：上面的用def函数的方法实现面向对象的过程就是
2⃣️、面向对象编程(object-oriented programming):用定义类+实例/对象的方式去实现面向对象的设计。用class独特的语法实现面向对象设计。
小结：
一门面向对象的语言不一定会强制你写 OO 方面的程序。例如 C++可以被认为“更好 的 C”;而 Java,则要求万物皆类,此外还规定,一个源文件对应一个类定义。
然而,在 Python 中, 类和 OOP 都不是日常编程所必需的。尽管它从一开始设计就是面向对象的,并且结构上支持 OOP,但 Python 没有限定或要求你在你的应用中写 OO 的代码
用面向对象语言写程序，和一个程序的设计是面向对象的，两者是八杆子打不着的两码事。
纯C写的linux kernel事实上比c++/java之类语言搞出来的大多数项目更加面向对象——只是绝大部分人都自以为自己到处瞎写class的面条代码才是面向对象的正统、而死脑筋的linus搞的泛文件抽象不过是过程式思维搞出来的老古董。
五 类和对象
1.什么叫类：类是一种数据结构，就好比一个模型，该模型用来表述一类事物(事物即数据和动作的结合体)，用它来生产真实的物体(实例)。
2.什么叫对象：睁开眼，你看到的一切的事物都是一个个的对象，你可以把对象理解为一个具体的事物(事物即数据和动作的结合体)
(铅笔是对象，人是对象，房子是对象，狗是对象，alex是对象，配齐是对象，元昊是对象)
3.类与对象的关系：对象都是由类产生的，上帝造人，上帝首先有一个造人的模板，这个模板即人的类，然后上帝根据类的定义来生产一个个的人
4.什么叫实例化：由类生产对象的过程叫实例化，类实例化的结果就是一个对象，或者叫做一个实例（实例=对象）
5.1、类的相关知识
5.1.1 初识类
在python中声明函数与声明类很相似
声明函数
1 def functionName(args):
2 '函数文档字符串'
3 函数体
声明类
'''
class 类名:
'类的文档字符串'
类体
''' #我们创建一个类
class Data:
pass #用类Data实例化出一个对象d1
d1=Data()
经典类与新式类
大前提：
1.只有在python2中才分新式类和经典类，python3中统一都是新式类
2.新式类和经典类声明的最大不同在于,所有新式类必须继承至少一个父类
3.所有类甭管是否显式声明父类，都有一个默认继承object父类（讲继承时会讲，先记住）
在python2中的区分
经典类：
class 类名:
pass 经典类：
class 类名(父类):
pass 在python3中，上述两种定义方式全都是新式类
5.1.2 属性
类是用来描述一类事物，类的对象指的是这一类事物中的一个个体
是事物就要有属性，属性分为
1：数据属性：就是变量
2：函数属性：就是函数，在面向对象里通常称为方法
注意：类和对象均用点来访问自己的属性
#类和对象的属性
'''
1、数据属性
2、函数属性
'''
class Chinese:
'这是一个中国人的类'
dang= '共产_党' #数据属性
def suiditutan():
print('朝着墙上就是一口痰')
def chadui(self):
print('查到了前面') print(Chinese.dang) #调用数据属性
Chinese.suiditutan() #调用函数属性
Chinese.chadui('yuanhao')
print(dir(Chinese))#查看该类下面的方法(列表类型,存放该类下所有属性名字,除了系统内置,还包含了:['chadui', 'dang', 'suiditutan'])自定义
print(Chinese.__dict__) #查看类的属性字典:(返回字典:如:{'suiditutan': <function Chinese.suiditutan at 0x10217c9d8>})
print(Chinese.__dict__['dang'])
print(Chinese.__dict__['suiditutan'])#内存地址
print(Chinese.__dict__['suiditutan']()) # 总结:[类名.方法]本质上是通过(类.__dict__sh)调用该方法
# p1=Chinese() #实例化的过程,相当于函数ruturn返回的结果
# print(p1)
共产_党
朝着墙上就是一口痰
查到了前面
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'chadui', 'dang', 'suiditutan']
{'suiditutan': <function Chinese.suiditutan at 0x10217c9d8>, '__doc__': '这是一个中国人的类', '__module__': '__main__', '__weakref__': <attribute '__weakref__' of 'Chinese' objects>, 'dang': '共产_党', '__dict__': <attribute '__dict__' of 'Chinese' objects>, 'chadui': <function Chinese.chadui at 0x10217ca60>}
共产_党
<function Chinese.suiditutan at 0x10217c9d8>
朝着墙上就是一口痰
None
总结：
峰式理论：数据属性即变量，类的定义与函数又极其类似，其实可以用函数的作用域来理解类的属性调用
类的数据属性
#定义一个中文人的类,然后在类中定义一个类的属性,*是共产_党,这样，只要是中文人他们的党永远都是共产_党
#类属性又称为静态变量,或者是静态数据。这些数据是与它们所属的类对象绑定的,不依赖于任何类实例。
#如果你是一位Java或C++程序员,这种类型的数据相当于在一个变量声明前加上static关键字。 class ChinesePeople:
government='共产_党' print(ChinesePeople.government)
类的函数属性(又称为方法)
class ChinesePeople:
government='共产_党'
def sui_di_tu_tan():
print('90%的中国人都喜欢随地吐痰') def cha_dui(self):
print('一个中国人-->%s<--插到了前面' %self) ChinesePeople.sui_di_tu_tan() person1_obj='alex'
ChinesePeople.cha_dui(person1_obj) #带参函数，所以调用时需要传入参数，将'alex'传给self
查看类属性
我们定义的类的属性到底存到哪里了？有两种方式查看
dir(类名)：查出的是一个名字列表
类名.__dict__:查出的是一个字典，key为属性名，value为属性值
特殊的类属性
class ChinesePeople:
'我们都是中国人,我们骄傲的活着,我们不服任何事和物'
government='共产_党'
def sui_di_tu_tan():
print('90%的中国人都喜欢随地吐痰') def cha_dui(self):
print('一个中国人-->%s<--插到了前面' %self) print(ChinesePeople.__name__)# 类C的名字(字符串)
print(ChinesePeople.__doc__)# 类C的文档字符串
print(ChinesePeople.__base__)# 类C的第一个父类(在讲继承时会讲)
print(ChinesePeople.__bases__)# 类C的所有父类构成的元组(在讲继承时会讲)
print(ChinesePeople.__dict__)# 类C的属性
print(ChinesePeople.__module__)# 类C定义所在的模块
print(ChinesePeople.__class__)# 实例C对应的类(仅新式类中)
5.2 对象相关知识
对象是由类实例化而来，类实例化的结果称为一个实例或者称作一个对象
5.2.1 实例化
class Chinese:
'这是一个中国人的类'
dang= '共产_党' #数据属性
# def __init__(self,name,age,gender): #初始化函数,__init__系统内置,自动把函数的参数传入来。最外层无需参数
# dic={
# 'name':name,
# 'age':age,
# 'gender':gender
# }
# return dic
def __init__(self,name,age,gender): #初始化函数定制每一个对象的属性(数据,函数) self就是实例本身
print('初始化函数开始运行了') #运行该类,就立即运行__init__函数
self.mingzi=name #p1.mingzi=name #运行类的时候会自动找到内置的__init__方法来运行:P1.mingzi=name
self.nianji=age #p1.mingzi=name #有一个默认的self参数,之后是数据属性。{'nianji':age,'xingbie':age}
self.xingbie=gender #p1.mingzi=name #定义数据属性;self.mingzi 赋予了一个mingzi的数据属性
print('我结束了') #最后把P1封装成为一个字典 #最后自动由class自动帮忙return: self的数据属性。返回的是一个字典属性P1''默认：return None
def suiditutan():
print('朝着墙上就是一口痰')
def chadui(self):
print('查到了前面')
# return init(name,age,gender) 无需return,自动运行
#实例化的过程,本质上调用init函数.self就是实例本身
p1=Chinese('袁浩','','female') #->>>__init__(self,name,age,gender)实例化过程中,P1会自动传给self
#相当于:p1=Chinese.__init__(p1 ,name,age,gender)
print(Chinese.__dict__)
print(p1)
print(p1.__dict__) #可以通过__dict__调用显示字典,解释见前面的过程
#p1=Chinese() #类的运行过程就是一个实例化。 >>>
初始化函数开始运行了
我结束了
{'dang': '共产_党', '__module__': '__main__', '__weakref__': <attribute '__weakref__' of 'Chinese' objects>, 'chadui': <function Chinese.chadui at 0x10217cae8>, '__dict__': <attribute '__dict__' of 'Chinese' objects>, '__doc__': '这是一个中国人的类', 'suiditutan': <function Chinese.suiditutan at 0x10217ca60>, '__init__': <function Chinese.__init__ at 0x10217c9d8>}
<__main__.Chinese object at 0x102180550>
{'xingbie': 'female', 'mingzi': '袁浩', 'nianji': ''}
5.2.2 构造函数
数据属性：
class Chinese:
'这是一个中国人的类'
dang= '
共产_党
' #数据属性 def __init__(self,name,age,gender): self.mingzi=name self.nianji=age self.xingbie=gender def suiditutan(): print('朝着墙上就是一口痰') def chadui(self): print('查到了前面') p1=Chinese('袁浩','','female') print(Chinese.__dict__) print(p1) print(p1.__dict__['mingzi']) #可以通过__dict__调用显示字典,解释见前面的过程 print(p1.mingzi) #直接通过 . 来调用 #P1这个人里面包含自己的数据属性。
实例的数据属性的作用域
class Chinese:
'这是一个中国人的类'
dang= '共产_党' #数据属性
def __init__(self,name,age,gender):
self.mingzi=name
self.nianji=age
self.xingbie=gender
def suiditutan():
print('朝着墙上就是一口痰')
def chadui(self):
print('查到了前面')
p1=Chinese('袁浩','','female')
#P1这个人里面包含自己的数据属性。
#由一个类产生的一个实例,那么这个实例应该具备这一类该有的数据属性和函数属性。可以通过.来获取数值
print(p1.__dict__) #里面是p1所有的数据集合
print(p1.mingzi)#到实例的属性字典里面去寻找数据
print(p1.dang)#??可以对于不在属性字典里面数据和函数也可以找到。可以用峰氏理论:作用域来解释!
#现在自己位置寻找,找不到的话,在上一级寻找。P1产生的字典是由chinese类帮忙产生的!【p1=Chinese('袁浩','18','female')】
#由Chinese类去触发运行__init__,所以P1的字典是由init产生的,所以作用域就在init函数里面。
#对于:p1.dang首先在init的作用域内找,没找打的情况下,去外一层找。直到找到类的最里一层。
上述的实例化过程，没有做任何事情，啥意思？
类是数据属性和函数属性的结合，描述的是一类事物
这类事物的一个具体表现就是一个实例/对象，比方说中国人是一个类，而你就是这个类的一个实例
你除了有中国人这个数据属性外，还应该有名字，年龄，性别等数据属性
如何为实例定制数据属性，可以使用类的一个内置方法__init__()该方法，在类()实例化是会自动执行
class ChinesePeople:
'我们都是中国人,我们骄傲的活着,我们不服任何事和物'
government='共产_党'
def __init__(self,name,age,gender): #实例化的过程可以简单理解为执行该函数的过程，实例本身会当作参数传递给self（这是默认的步骤）
self.name=name
self.age=age
self.gender=gender def sui_di_tu_tan():
print('90%的中国人都喜欢随地吐痰') def cha_dui(self):
print('一个中国人-->%s<--插到了前面' %self) # person1=ChinesePeople() #会报错
#自动执行__init__方法,而这个方法需要参数,
# 这些参数应该写在类名后面的括号里,然后由类传
#给__init__函数,也就说,传给类的参数就是传给__init__的参数 person1=ChinesePeople('alex',1000,'female')
person2=ChinesePeople('wupeiqi',10000,'female')
person3=ChinesePeople('yuanhao',9000,'female') print(person1.__dict__)
注意：在说实例化的时候说过，执行类()会自动返回一值，这个值就是实例，而类()会自动执行__init__，所以一定不要在该函数内定义返回值，会冲突（不怕死可以自己测试）
5.2.3、实例的属性：
class Chinese:
'这是一个中国人的类'
dang= '共产_党' #数据属性
def __init__(self,name,age,gender):
self.mingzi=name
self.nianji=age
self.xingbie=gender
def suiditutan():
print('朝着墙上就是一口痰')
def chadui(self):
print(self.__dict__)#就是实例化的
print('%s查到了前面'%self.mingzi)
p1=Chinese('袁浩','','female')
print(p1.__dict__) #只有实例的数据属性 谁来实例化,self就是谁!
print(Chinese.__dict__) #数据属性和函数属性都有
Chinese.suiditutan() #在作用域范围内,可以调用该函数。类调用
Chinese.chadui(p1) #可以通过参数传递,进行赋值和调用name。完成通过,类的调用,显然太low!
#通过实例调用
#p1.suiditutan() #首先会在p1的实例字典里面去找该字典,无法找到情况下,去外层找。
# 报错!默认会把p1参数传入。相当于:p1.suiditutan(p1)。传给第一个位置参数 可是函数设置的时候,没有参数传入。所以报错！ p1.chadui() #可以运行，
#一、谁来实例化,self就是谁,如上述:print(self.__dict__)#就是实例化的打印结果:
#{'mingzi': '袁浩', 'xingbie': 'female', 'nianji': '18'}
#二、 self做了一个统一。只要执行函数
#所以说实例只有数据属性。函数属性通过类查找
{'xingbie': 'female', 'nianji': '', 'mingzi': '袁浩'}
{'dang': '共产_党', '__weakref__': <attribute '__weakref__' of 'Chinese' objects>, '__module__': '__main__', '__init__': <function Chinese.__init__ at 0x10217c9d8>, 'suiditutan': <function Chinese.suiditutan at 0x10217ca60>, '__doc__': '这是一个中国人的类', 'chadui': <function Chinese.chadui at 0x10217cae8>, '__dict__': <attribute '__dict__' of 'Chinese' objects>}
朝着墙上就是一口痰
{'xingbie': 'female', 'nianji': '', 'mingzi': '袁浩'}
袁浩查到了前面
{'xingbie': 'female', 'nianji': '', 'mingzi': '袁浩'}
袁浩查到了前面
峰式理论：
1.实例只有数据属性（实例的函数属性严格来说是类的函数属性）
2.del 实例/对象，只是回收了实例的数据属性，函数属性是属于类的，是不会回收。
实例化的过程实际就是执行__init__的过程，这个函数内部只是为实例本身即self设定了一堆数据(变量)，所以实例只有数据属性
class ChinesePeople:
'我们都是中国人,我们骄傲的活着,我们不服任何事和物'
government='共产_党'
def __init__(self,name,age,gender):
self.name=name
self.age=age
self.gender=gender def sui_di_tu_tan():
print('90%的中国人都喜欢随地吐痰') def cha_dui(self):
print('一个中国人-->%s<--插到了前面' %self) person1=ChinesePeople('alex',1000,'female')
print(person1.__dict__) #查看实例的属性,发现里面确实只有数据属性
print(person1.name,person1.age,person1.gender) #访问实例的数据属性
那么我们想访问实例的函数属性（其实是类的函数属性），如何实现
class ChinesePeople:
'我们都是中国人,我们骄傲的活着,我们不服任何事和物'
government='共产_党'
def __init__(self,name,age,gender):
self.name=name
self.age=age
self.gender=gender def sui_di_tu_tan():
print('90%的中国人都喜欢随地吐痰') def cha_dui(self):
print('一个中国人-->%s<--插到了前面' %self) person1=ChinesePeople('alex',1000,'female')
print(person1.__dict__) #查看实例的属性,发现里面确实只有数据属性
print(ChinesePeople.__dict__)#函数属性只存在于类中
ChinesePeople.cha_dui(person1)#我们只能通过类去调用类的函数属性,然后把实例当做变量传递给self
一个小小的改进，就大不一样了
class ChinesePeople:
'我们都是中国人,我们骄傲的活着,我们不服任何事和物'
government='共产_党'
def __init__(self,name,age,gender):
self.name=name
self.age=age
self.gender=gender def sui_di_tu_tan():
print('90%的中国人都喜欢随地吐痰') # def cha_dui(self):
# print('一个中国人-->%s<--插到了前面' %self) def cha_dui(self):
print('一个中国人-->姓名:%s 年龄:%s 性别:%s<--插到了前面' %(self.name,self.age,self.gender)) def eat_food(self,food):
print('%s 正在吃 %s' %(self.name,food)) person1=ChinesePeople('alex',1000,'female')
print(person1.__dict__) #查看实例的属性,发现里面确实只有数据属性
print(ChinesePeople.__dict__)#函数属性只存在于类中
ChinesePeople.cha_dui(person1)#我们只能通过类去调用类的函数属性,然后把实例当做变量传递给self
ChinesePeople.eat_food(person1,'韭菜馅饼') person1.cha_dui()#其实就是ChinesePeople.cha_dui(person1)
person1.eat_food('飞禽走兽') #本质就是ChinesePeople.eat_food(person1,'飞禽走兽')
总结：
所以说实例只有数据属性。函数方法属性通过类去查找。
一、谁来实例化,self就是谁,如上述:print(self.__dict__)#就是实例化的打印结果:
#{'mingzi': '袁浩', 'xingbie': 'female', 'nianji': '18'}
二、 self做了一个统一。只要执行函数
三、实例调用的函数方法，都是到类里面去查找的。
通过数据属性和函数属性的分离，→init的数据属性可以快速生产多个实例，每个实例到类里面去要方法。和每个实例都分别定义数据属性和函数属性要更加的高效，同时省内存！
四、方式类当中定义的方法，默认都有一个参数self，放在函数的第一个位置。通过对象调用的时候，会自动把自己传递给self.
5.2.4 查看实例属性
同样是dir和内置__dict__两种方式
5.2.5 特殊实例属性
__class__
__dict__
class ChinesePeople:
'我们都是中国人,我们骄傲的活着,我们不服任何事和物'
government='共产_党'
def __init__(self,name,age,gender):
self.name=name
self.age=age
self.gender=gender def sui_di_tu_tan():
print('90%的中国人都喜欢随地吐痰') # def cha_dui(self):
# print('一个中国人-->%s<--插到了前面' %self) def cha_dui(self):
print('一个中国人-->姓名:%s 年龄:%s 性别:%s<--插到了前面' %(self.name,self.age,self.gender)) def eat_food(self,food):
print('%s 正在吃 %s' %(self.name,food))
person1=ChinesePeople('alex',1000,'female')
print(person1.__class__)
print(ChinesePeople)
person2=person1.__class__('xiaobai',900,'male')
print(person2.name,person2.age,person2.gender) 具体用法
警告：类和对象虽然调用__dict__返回的是一个字典结构，但是千万不要直接修改该字典，会导致你的oop不稳定
5.3 类属性与对象(实例)属性
#类属性又称为静态变量,或者是静态数据。这些数据是与它们所属的类对象绑定的,不依赖于任何类实例。
#如果你是一位Java或C++程序员,这种类型的数据相当于在一个变量声明前加上static关键字。
class ChinesePeople:
country='China'
def __init__(self,name):
self.name=name def play_ball(self,ball):
print('%s 正在打 %s' %(self.name)) def say_word(self,word):
print('%s 说 %s' %(self.name,word)) #查看类属性
print(ChinesePeople.country)
#修改类属性
ChinesePeople.country='CHINA'
print(ChinesePeople.country)
#删除类属性
del ChinesePeople.country
#增加类属性
ChinesePeople.Country='China'
ChinesePeople.location='Asia'
print(ChinesePeople.__dict__) #类的数据属性增删改查与函数属性是一样的
ChinesePeople.say_word=say_word
print(ChinesePeople.__dict__)
alex_obj=ChinesePeople('alex')
ChinesePeople.say_word(alex_obj,'我是一只来自北方的狼狗') 类属性使用
类的属性使用
class ChinesePeople:
country='China'
def __init__(self,name):
self.name=name def play_ball(self,ball):
print('%s 正在打 %s' %(self.name,ball)) p1=ChinesePeople('alex')
print(p1.__dict__) #查看实例属性
print(p1.name)
# print(p1.age)#不存在于p1的属性字典中,会报错 print(p1.country)#country也不存在于p1的属性字典中,为何可以取到呢? #删除
# del p1.country #报错,因为p1的属性字典里根本就没有country属性
del p1.name
print(p1.__dict__) #增加
p1.gender='man'
print(p1.__dict__) #修改
p1.gender='woman'
print(p1.__dict__) 实例属性的使用
实例的属性使用
1.其实你会发现，实例化就是 类名()，然后返回的结果是一个对象，加上括号是不是跟函数运行很像，函数运行完了有返回值，是不是很像，没错，就是一样的。
2.函数又作用域的概念，其实类也有作用域的概念，二者一样
3.你可以把class当做最外层的函数，是一个作用域
#定义一个类，只当一个作用域去用，类似于c语言中的结构体
class MyData:
pass x=10
y=20
MyData.x=1
MyData.y=2 print(x,y)
print(MyData.x,MyData.y)
print(MyData.x+MyData.y)
4.实例化会自动触发init函数的运行，最后返回一个值即实例，我们要找的实例属性就存放在init函数的局部作用域里
5.类有类的属性字典，就是类的作用域，实例有实例的属性字典，即实例的作用域
6.综上，一个点代表一层作用域，obj.x先从自己的作用域找，自己找不到去外层的类的字典中找，都找不到，就会报错
7.在类中没有使用点的调用，代表调用全局变量啊，这还tm用说，对，你就是不知道
age=1000
class ChinesePeople:
country='China'
age=10
def __init__(self,name):
self.name=name
print('初始化函数中调用age',age) #不加点调用就跟类没关系了,找的就是全局的
print('初始化函数中调用self.age',self.age) def play_ball(self,ball):
print('%s 正在打 %s' %(self.name,ball)) def say_word(self,word):
print('%s 说 %s' %(self.name,word)) p1=ChinesePeople('alex')
print(p1.age) #这属于在自己的作用域定义了一个age,类的age并不会变
p1.age=100000000
print(p1.age)
print(ChinesePeople.age) #不是说实例无函数属性吗,他都是调用的类的,那么我们就为实例添加一个函数属性好了
p1.haha=say_word
print(p1.__dict__)
p1.haha(p1,'英语')#我擦嘞,怎么会这么玩 我就不信玩不懵你
我就不信玩不懵你
age=10000000000
class ChinesePeople:
country='China'
age=10
def __init__(self,name):
self.name=name def play_ball(self,ball):
print('%s 正在打 %s' %(self.name,ball)) p1=ChinesePeople('alex')
p2=ChinesePeople('wupeiqi')
p3=ChinesePeople('yuanhao') p1.age=1000
p2.age=10000
p3.age=9000
print(p1.age,p2.age,p3.age)
print('全局变量',age)
print('类数据属性',ChinesePeople.age) #开始玩你了
age=10000000000
class ChinesePeople:
country='China'
age=10
l=[]
def __init__(self,name):
self.name=name def play_ball(self,ball):
print('%s 正在打 %s' %(self.name,ball)) p1=ChinesePeople('alex')
p2=ChinesePeople('wupeiqi')
p3=ChinesePeople('yuanhao') p1.l.append('p1')
p2.l.append('p2')
p3.l.append('p3') print(ChinesePeople.l)
print(p1.l,p2.l,p3.l) 换个姿势搞你
换个姿势搞你
峰式理论 ：类的作用域即函数作用域