标签：get 新西兰 无法 运行 定义 data 需要 view 变量
1. 什么叫类：类是一种数据结构，就好比一个模型，该模型用来表述一类食物（食物即数据和动作的结合体），用它来生产真是的物体（实例）
2. 什么叫对象：睁开眼，你看到的一切事物都是一个个的对象，你可以把对象理解为一个具体的事物（事物即数据和动作的结合体）
（铅笔是对象，人是对象，房子是对象，狗是对象，你看到的都是类）
3.类与对象的关系：对象都是由类产生的，女娲造人，首先由一个造人的模板，这个模板就是人类，然后女娲根据类的定义来生产一个个的人
4. 什么叫实例化：由类生产对象的过程叫实例化，类实例化的结构就是一个对象，或者叫做一个实例（实例=对象）
实例：就是类生产的那个对象。是一个实实在在的存在。放到真实世界中，人类就是一个类，这人类是看不见，摸不着的，是人为给划分的；而人，比如，你，我，他，路人等就是一个个的实例，是真实存在，能看得见，摸得着的。
在Python中，声明函数和声明类很相似：
声明函数
def function(args): ‘‘‘文档字符串‘‘‘ 函数体
声明类
class 类名: ‘‘‘类的文档字符串‘‘‘ 类体
class Chinese: # 声明类,类名的规范：类名的首字母要大写 ‘‘‘这是一个中国人的类‘‘‘ pass print(Chinese) # <class ‘__main__.Chinese‘>
class Chinese: ‘‘‘这是一个中国人的类‘‘‘ pass # 实例化 #实例化,对类名加括号，加括号就代表运行，运行类也有返回值，这个返回值就是一个具体的示例了 p1=Chinese() print(p1) # <__main__.Chinese object at 0x00402EF0> #实例化到底干了什么？后面给你答案
经典类与新式类
经典类：上面的两个示例就是经典类，经典类的特点就是，类名后面直接就是冒号（Python2中）
新式类：都要在类名后面加个括号，括号里写上object
# 新式类：都要在类名后面加个括号，括号里写上object # 意思是Chinese这类继承与object class Chinese(object): pass
注意，Python3中统一都是新式类，没有区别了，类名后面是否加（object），都是新式类。
类是用来描述一类事物的，类的对象指的是这一类事物中的一个个体。
既然是事物，那就要有属性，属性分为：
1. 数据属性：就是变量 （就是第二十五篇里讲的特征）
2. 函数属性：就是函数，在面向对象里通常称为方法 （就是第二十五篇里讲的动作）
注意：
类和对象均用点来访问自己的属性
数据属性即变量，类的定义与函数又极其类似，其实可以用函数的作用域来理解类的属性调用。
class Chinese: ‘这是一个中国人的类‘ # 类的数据属性 party=‘渣滓洞‘ # 类的函数属性,就是方法 def huang_pi_fu(): print(‘中国人都是黄皮肤‘) def cha_dui(self): print(‘%s插到了前面‘ %self)
要访问类的属性，你首先得知道类的属性在哪里吧？就好比你要逛亲戚，你得知道亲戚家在哪里吧，然后才能选择用什么交通工具到你亲戚家。
那要去你亲戚家，你怎么知道路呢？可以问爸妈，也可以给亲戚打电话，还可以让亲戚发定位等等。
同理，定义了类的属性，也要知道存放在哪里了？有两种方式可以查看
#第一种： dir(类名): 得到的是一个名字列表，只放了属性的名字在列表里 print(dir(Chinese)) # [‘__class__‘, ‘__delattr__‘, ‘__dict__‘, ‘__dir__‘, ‘__doc__‘, ‘__eq__‘, ‘__format__‘, ‘__ge__‘, ‘__getattribute__‘, ‘__gt__‘, ‘__hash__‘, ‘__init__‘, ‘__init_subclass__‘, ‘__le__‘, ‘__lt__‘, ‘__module__‘, ‘__ne__‘, ‘__new__‘, ‘__reduce__‘, ‘__reduce_ex__‘, ‘__repr__‘, ‘__setattr__‘, ‘__sizeof__‘, ‘__str__‘, ‘__subclasshook__‘, ‘__weakref__‘, ‘cha_dui‘, ‘huang_pi_fu‘, ‘party‘] # 第二种： 类名.__dict__ :查出的是一个字典，key为属性名，value为属性值
__dict__: 查看类的属性字典
print(Chinese.__dict__) # {‘__module__‘: ‘__main__‘, ‘__doc__‘: ‘这是一个中国人的类‘, ‘party‘: ‘渣滓洞‘, ‘huang_pi_fu‘: <function Chinese.huang_pi_fu at 0x00C01AE0>, ‘cha_dui‘: <function Chinese.cha_dui at 0x00C01A50>, ‘__dict__‘: <attribute ‘__dict__‘ of ‘Chinese‘ objects>, ‘__weakref__‘: <attribute ‘__weakref__‘ of ‘Chinese‘ objects>}
知道了存放地点，就可以一级级查找下去，访问类的属性啦
print(Chinese.__dict__[‘party‘]) # 渣滓洞 print(Chinese.__dict__[‘huang_pi_fu‘]()) # 中国人都是黄皮肤 print(Chinese.__dict__[‘cha_dui‘](‘汪汪队‘)) # 汪汪队插到了前面
Python提供了更简单的方法：
类名.属性名：就可以访问到属性。（本质上就是在查询属性字典）
# 访问类的数据属性，通过点来访问 print(Chinese.party) # 渣滓洞 # 访问类的函数属性，通过点来访问 Chinese.huang_pi_fu() # 中国人都是黄皮肤 Chinese.cha_dui(‘dig‘) # dig插到了前面
#python为类内置的特殊属性 类名.__name__# 类的名字(字符串) 类名.__doc__# 类的文档字符串 类名.__base__# 类的第一个父类(在讲继承时会讲) 类名.__bases__# 类所有父类构成的元组(在讲继承时会讲) 类名.__dict__# 类的字典属性 类名.__module__# 类定义所在的模块 类名.__class__# 实例对应的类(仅新式类中) 类的特殊属性(了解即可)
print(Chinese.__name__) # Chinese print(Chinese.__doc__) # 这是一个中国人的类 print(Chinese.__base__) # <class ‘object‘> print(Chinese.__bases__) # (<class ‘object‘>,) print(Chinese.__dict__) # 上面已经有了 print(Chinese.__module__) #__main__ print(Chinese.__class__) #<class ‘type‘>
对象：是由类实例化而来的。
class Chinese: ‘这是一个中国人的类‘ party=‘渣滓洞‘ ‘‘‘ 首先，在类定义当中，要有一个初始化函数来帮我们定制每一个对象的属性 其次，类class的语法结构当中，提供了内置方法，只要你把初始化函数定义为__init__()这个名字，你在用类名()来运行你的类的时候，他就会自动的找到 __init__来帮你去运行 第三，__init__()必须要有一个self参数,然后再接着写其他数据属性（变量参数） 第四, 定义数据属性时，self.mingzi = name,代表给这个self这个实例赋予了一个mignzi属性，mingzi属性就是数据属性;name就是执行__init()函数传进来的参数 这样就把名字，年龄，性别统统都封装到了self这个实例自己里面了 最后，return返回了一个self实例，但是不用显示的return，而是class自动给你return了，最后返回的结果就是一个字典。 字典里封装了什么？封装了名字，年龄，性别这些数据属性 ‘‘‘
# 1. 初始化构造方法 def __init__(self,name,age,gender): print(‘我是初始化函数，我开始运行了‘) # self:就是实例自己 self.mingzi=name # 相当于 p1.mingzi=name self.nianji=age # 相当于 p1.nianji=age self.xingbie=gender # 相当于 p1.xingbie = gender print(‘我结束啦‘) # 上面已经构造好了初始化一个实例的方法，下面就来真真的生成一个实例对象 # 具体的实例化的过程： # 1. 实例化的过程，本质上就是调用并运行了一次__init__(self,name,age,gender)函数， # 2. 在调用__init__的过程中，self其实就是p1,在运行过程中，会自动的将p1传给self,然后‘元昊‘,18,‘female‘分别传给name,age,gender # 3. 其实就是Chinese.__init__(p1,name,age,gender)
# 2. 实例化：实际就是生成了一个真实存在的对象。
p1 = Chinese(‘小黄‘,18,‘female‘)
# 我是初始化函数，我开始运行了
# 我结束啦
# 上面初始化构造方法里面已经讲了，初始化构造返回的实例就是一个数据字典，那我们来看看到底是不是 print(p1) # <__main__.Chinese object at 0x00C39890> print(p1.__dict__) # {‘mingzi‘: ‘元昊‘, ‘nianji‘: 18, ‘xingbie‘: ‘female‘}
# 上面已经实例化了一个p1，p1就是真实存在的一个人 # 就可以查看p1这个人具备哪些属性？ # 首先，他具有这个类所共有的属性，还可以有他自己特有的属性 print(p1.mingzi) # 小黄 # p1.mingzi,作用域在__init__里，可以调用到，很正常 # 那p1.dang首先在__init__作用域里没找到，就会向外一层找，就有dang这个属性啦，所以可以调用了 print(p1.dang) # 渣滓洞 # 查看p1的属性 print(p1.__dict__) # {‘mingzi‘: ‘元昊‘, ‘nianji‘: 18, ‘xingbie‘: ‘female‘} # 查看类的属性 print(Chinese.__dict__) # {‘__module__‘: ‘__main__‘, ‘__doc__‘: ‘这是一个中国人的类‘, ‘dang‘: ‘渣滓洞‘, ‘__init__‘: <function Chinese.__init__ at 0x00AB1B70>, ‘sui_di_tu_tan‘: <function Chinese.sui_di_tu_tan at 0x00AB1B28>, ‘cha_dui‘: <function Chinese.cha_dui at 0x00AB1AE0>, ‘eat_food‘: <function Chinese.eat_food at 0x00AB1A50>, ‘__dict__‘: <attribute ‘__dict__‘ of ‘Chinese‘ objects>, ‘__weakref__‘: <attribute ‘__weakref__‘ of ‘Chinese‘ objects>}
小总结：
1. 实例是怎么产生的？
【答】实例的产生，就是执行了一个初始化方法__init__()产生的。__init__()返回的就是一个实例属性字典。实例属性字典里就是没有函数属性，并不包含函数属性
2. 函数属性是属于类的，从层级关系上也能看出来。
class Chinese: ‘这是一个中国人的类‘ dang=‘渣滓洞‘ # 构造了初始化函数 def __init__(self,name,age,gender): self.mingzi=name # 相当于 p1.mingzi=name self.nianji=age # 相当于 p1.nianji=age self.xingbie=gender # 相当于 p1.xingbie = gender # 构造函数属性 def sui_di_tu_tan(self): print(‘%s 朝着墙上就是一口痰‘ %self.mingzi) def cha_dui(self): print(self) print(‘%s 插到了前面‘ %self.mingzi) def eat_food(self,food): print(‘%s 正在吃%s‘ %(self.mingzi,food))
# 实例调方法的顺序 # 1. 先从自己的字典里找 p1自己的字典：{‘mingzi‘: ‘元昊‘, ‘nianji‘: 18, ‘xingbie‘: ‘female‘} # 2. 再到类的字典里面去找， 类的字典：Chinese.__dict__ # 能找到就可以运行 p1.sui_di_tu_tan() # 小黄 朝着墙上就是一口痰 # 问题:sui_di_tu_tan(self)定义的时候有个self参数，那为什么这里运行的时候,没有传参数,也能正常运行呢？
1、self 就代表自己，自己就是实例化的结果p1。谁来实例化，self就是谁。
2、为什么要有self？self就是来做统一的
3、只要定义了self,一执行函数，就会自动把p1传给函数的第一个参数。
4、所以,以后只要碰到self,就要知道self就是实例本身
来一张图
有人说，类有数据属性和函数属性，实例/对象 是由类产生的，所以实例也有数据属性和函数属性了------这是错的哇，记住啦。
因为：
实例化的过程实际就是执行__init__的过程，这个__init__函数内部只是为实例本身即self设定了一堆数据（变量），所以实例只有数据属性；它的所谓的函数属性是从类里找来的而已。
还有人说，实例是类产生的，所以实例肯定能访问到类属性，然后就没有说为什么了------这也是错的哇。
因为：
1. 首先你会发现，实例化就是 类名()，然后返回的结果是一个对象，加上括号是不是跟函数运行很像，函数运行完了有返回值，很像那
2. 函数有作用域的概念，其实类也有作用域的概念，二者一样
3. 你可以吧class当做最外层的函数，是一个作用域
# 定义一个类，只当一个作用域用 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. 在类中没有使用点的调用，代表调用全局变量。
所以，上面的说法犯了因果倒置的错误。不是因为实例是由类产生的，所以实例才能访问到类属性。
上面这个只是为了帮助理解，而不能真的这么说。
茅塞顿开，总结一句话就是：
类有个属性字典，实例也有个属性字典；
查的时候，实例/对象先从自己的属性字典里查，再到类的属性字典里去查
整理下上面的代码
class Chinese: ‘这是一个中国人的类‘ dang=‘渣滓洞‘ def __init__(self,name,age,gender): self.mingzi=name # 相当于 p1.mingzi=name self.nianji=age self.xingbie=gender def sui_di_tu_tan(self): print(‘%s 朝着墙上就是一口痰‘ %self.mingzi) def cha_dui(self): print(self) print(‘%s 插到了前面‘ %self.mingzi) def eat_food(self,food): print(‘%s 正在吃%s‘ %(self.mingzi,food)) # 实例化可以生成多个对象 p1=Chinese(‘小黄‘,18,‘female‘) # 对象调用吃的方法 p1.eat_food(‘包子‘) # 小黄 正在吃包子 p2=Chinese(‘武sir‘,23,‘姑娘‘) # 对象也可以调用吃的方法 p2.eat_food(‘韭菜馅饼‘) 武sir 正在吃韭菜馅饼
class Chinese: country=‘China‘ def __init__(self,name): self.name=name # 函数属性的定义原则：动词_名词。 干什么事 def play_ball(self,ball): print(‘%s 正在打 %s‘ %(self.name,ball))
# 下面的函数定义与类是同级的，与类没半毛钱关系。 def say_word(self,word): return "%s 说 %s" %(self.name, word) # 实例化一个实例 p1=Chinese(‘alex‘) # print(p1.__dict__) # {‘name‘: ‘alex‘}
#查看类的数据属性：用点的方式查。 print(Chinese.country) # China # 查看类的函数属性 print(Chinese.play_ball) # <function Chinese.play_ball at 0x009F1AE0>
#增加类的数据属性 Chinese.dang = ‘Gong Chandang‘ print(Chinese.dang) # Gong Chandang # 增加类的函数属性 # 首先，要在类的外部写一个函数 def say_word(self,word): return "%s 说 %s" %(self.name, word) # 其次，增加函数属性，将上面的函数赋值给类的函数属性Say_Language Chinese.Say_Language = say_word print(Chinese.__dict__) # {‘__module__‘: ‘__main__‘, ‘country‘: ‘China‘, ‘__init__‘: <function Chinese.__init__ at 0x00C01B28>, ‘play_ball‘: <function Chinese.play_ball at 0x00C01AE0>, ‘__dict__‘: <attribute ‘__dict__‘ of ‘Chinese‘ objects>, ‘__weakref__‘: <attribute ‘__weakref__‘ of ‘Chinese‘ objects>, ‘__doc__‘: None, ‘Say_Language‘: <function say_word at 0x00C01B70>}
#修改类的数据属性 Chinese.country="新西兰" print(Chinese.country) # 新西兰 # 类属性被修改了，那实例可以使用吗？可以用的 print(p1.country) # 新西兰 # 修改类的函数属性 # 首先要定义个要修改的目标函数 def play_what(self,what): return "%s 正在玩 %s" %(self.name, what) # 修改类的函数属性 Chinese.play_ball = play_what print(Chinese.__dict__) # 调用类的函数属性 print(p1.play_ball("钢琴")) # alex 正在玩 钢琴
# 删除类的数据属性 del Chinese.country print(p1.country) # AttributeError: ‘Chinese‘ object has no attribute ‘country‘ # 删除类的函数属性 del Chinese.play_ball print(Chinese.__dict__) # {‘__module__‘: ‘__main__‘, ‘country‘: ‘China‘, ‘__init__‘: <function Chinese.__init__ at 0x01331B28>, ‘__dict__‘: <attribute ‘__dict__‘ of ‘Chinese‘ objects>, ‘__weakref__‘: <attribute ‘__weakref__‘ of ‘Chinese‘ objects>, ‘__doc__‘: None} # 调用类函数属性 p1.play_ball("足球") # AttributeError: ‘Chinese‘ object has no attribute ‘play_ball‘ # 因为，已经被删除掉了
# 查看实例的数据属性 print(p1.name) # alex # 查看实例类属性（查看实例的函数属性，实际上是访问的类的函数属性） print(p1.play_ball) # <bound method Chinese.play_ball of <__main__.Chinese object at 0x00D22ED0>>
# 运行，函数属性后加（）就变成运行了。
print(p1.play_ball(‘篮球‘))
# 增加实例的数据属性 p1.age=18 print(p1.__dict__) # {‘name‘: ‘alex‘, ‘age‘: 18} print(p1.age) # 18 #备注，无法增加实例的函数属性哦，因为函数属性是通过类增加的 # 增加实例的函数属性（虽然可以增加，但是没有这么玩的，要知道可以增加，但要迅速忘记它，千万别这么用，纯属多余的） def shili_shuxing(self): return "我是来自实例的函数属性" p1.Shi_Li_De_Shu_Xing = shili_shuxing print(p1.__dict__) # {‘name‘: ‘alex‘, ‘Shi_Li_De_Shu_Xing‘: <function shili_shuxing at 0x00D61AE0>} print(p1.Shi_Li_De_Shu_Xing(p1)) # 我是来自实例的函数属性
# 修改实例的数据属性 p1.age=19 print(p1.__dict__) print(p1.age) # 结果 {‘name‘: ‘alex‘, ‘age‘: 19} 19
#删除实例的数据属性 del p1.age print(p1.__dict__)
那，换个姿势，实例和类混合着玩会怎么样？
# 示例代码 class Chinese: country=‘China‘ def __init__(self,name): self.name=name def play_ball(self,ball): print(‘%s 正在打 %s‘ %(self.name,ball)) p1=Chinese(‘alex‘) print(p1.country) # China 访问的是类的 # 在p1里新增了一个country p1.country=‘日本‘ print(‘类的--->‘,Chinese.country) # China print(‘实例的‘,p1.country) # 日本
# 作用域问题 class Chinese: def __init__(self,name): self.name=name def play_ball(self,ball): print(‘%s 正在打 %s‘ %(self.name,ball)) p1=Chinese(‘alex‘) print(p1.country) # AttributeError: ‘Chinese‘ object has no attribute ‘country‘ # 原因, 因为类里没有country属性 # 那如果把country定义到类外面那? country=‘中国‘ class Chinese: def __init__(self,name): self.name=name def play_ball(self,ball): print(‘%s 正在打 %s‘ %(self.name,ball)) p1=Chinese(‘alex‘) print(p1.country) # AttributeError: ‘Chinese‘ object has no attribute ‘country‘ # 原因：作用域只在类里面找，放到类外部照样找不到
class Chinese: def __init__(self): # 在实例化过程中接受输入参数 name = input("请输入用户名: ") self.name=name def play_ball(self,ball): print(‘%s 正在打 %s‘ %(self.name,ball)) p1=Chinese() print(p1.name) # 备注： ‘‘‘ 虽然这么做是可以的，但是千万别这么干。 因为一个函数就是实现一个功能，而这么干，还实现了接受用户输入的功能。 可读性差，也不利于维护 ‘‘‘ # 可以改进成如下方式，专门写一个函数来处理接受输入和实例化的过程,代码变为： class Chinese: def __init__(self, name): self.name=name def play_ball(self,ball): print(‘%s 正在打 %s‘ %(self.name,ball)) def shi_li_hua(): name=input(‘>>: ‘) # 接收输入 p1=Chinese(name) # 实例化 print(p1.country) # 调用 print(p1.name) # 调用 shi_li_hua() # 直接调用运行
在类中没有使用点的调用，代表调用全局变量。
country=‘中国‘ class Chinese: def __init__(self,name): self.name=name print(‘--->‘,country) def play_ball(self,ball): print(‘%s 正在打 %s‘ %(self.name,ball)) p1=Chinese(‘alex‘) # ---> 中国 # 为什么？ # 其实前面已经给了答案了。 所说的在类里面找属性，是通过点这种方式才表明这个属性是需要再类里面去找的，而此时，country并没有通过点的方式，所以它就是一个普通的变量名，即使这个变量在类的外面，照样也可以使用
country=‘-------------中国-------------‘ class Chinese: country=‘中国‘ def __init__(self,name): self.name=name print(‘--->‘,country) def play_ball(self,ball): print(‘%s 正在打 %s‘ %(self.name,ball)) p1 = Chinese("alex") # ---> -------------中国------------- # 原因： # 遵循在类中没有使用点的调用，代表调用全局变量。
class Chinese: country=‘China‘ def __init__(self,name): self.name=name def play_ball(self,ball): print(‘%s 正在打 %s‘ %(self.name,ball)) p1=Chinese(‘alex‘) print(p1.country) # China p1.country=‘Japan‘ # 改的只是p1自己的国家 print(Chinese.country) # China 类的数据属性还是没有被改掉的
class Chinese: country=‘China‘ l=[‘a‘,‘b‘] def __init__(self,name): self.name=name def play_ball(self,ball): print(‘%s 正在打 %s‘ %(self.name,ball)) p1=Chinese(‘alex‘) print(p1.l) # [‘a‘, ‘b‘] p1.l=[1,2,3] # 给p1新增了一个属性值，所以只会改p1自己的 print(p1.l) # [1, 2, 3] 改的仅仅是p1自己的 print(Chinese.l) # [‘a‘, ‘b‘] 类的属性l 是不会变的 print(p1.__dict__) # {‘name‘: ‘alex‘, ‘l‘: [1, 2, 3]} # 但是，这种方式就有问题了 # 首先，没有给p1新定义属性, # 其次, p1.l调的就是类的，这个l那的就是列表的引用，append操作的就是类 p1.l.append(‘c‘) print(p1.__dict__) # {‘name‘: ‘alex‘, ‘l‘: [1, 2, 3]} print(Chinese.l) # {‘name‘: ‘alex‘, ‘l‘: [1, 2, 3, ‘c‘]} # 这其实就是通过实力引用类的属性，并直接操作了类的属性
标签：get 新西兰 无法 运行 定义 data 需要 view 变量
原文地址：https://www.cnblogs.com/victorm/p/9310761.html
