Python学生第五十二天—类和对象1：封装

一、其实，对象一直都在你的面前……
Object-Oriented Pregramming编程（面向对象编程）
面向对象也是一种代码封装的方法：把相关的数据和实现的函数封装到一起，对象=属性（静态特征）+方法（所能做的事情）
在对象诞生之前，需要先创建一个类（class），然后在通过类创建实际对象，先造出一个模具，然后再更加模具再批量生产。那么这个模具就是我们要学习的“类”，创建一个类我们要用到关键字class
编辑模式下：
class Turtle:       （创建一个乌龟的类，类名的首字母要大写）
    head = 1
    eyes = 2
    legs = 4
    shell = True            （所谓的属性就是类里面的变量）
    def crawl(self):                 （类里面的没有个函数都有一个self参数）
        print("人们总是抱怨我动作慢吞吞，殊不知不积跬步无以至千里。")
    def run(self):
        print("虽然我行动很慢，但遇到危险，我还是会夺命狂奔的T_T.")
    def bite(self):
        print("人善被人欺，龟善被人骑，我可是会咬人的！")
    def eat(self):
        print("谁知盘中餐粒粒皆辛苦，吃得好，不如吃得饱。")
    def sleep(self):    （所谓的方法就是写在类里面的函数）
        print("Zzzzz……")
点击保存save,保存为turtle.py，然后再点击Run Module，我们把这个程序运行起来，在互动模式下，我们就拥有了Turtle这个类，那我们就可以直接调用，像调用一个函数一样。
Python 3.12.1 (tags/v3.12.1:2305ca5, Dec  7 2023, 22:03:25) [MSC v.1937 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license()" for more information.

= RESTART: C:/Users/Administrator/AppData/Local/Programs/Python/Python312/turtle.py
在类的基础上，我们怎么创建对象呢？
t1=Turtle()    （运行后，就拥有了Turtle这个类，那么就直接调用，像调用函数一样，赋值到t1变量中）
t1.head                （一个头）  
1
t1.legs                  （四条腿）
4
t1.eyes
2
t1.shell
True
t1.crawl()
人们总是抱怨我动作慢吞吞，殊不知不积跬步无以至千里。
t1.run()
虽然我行动很慢，但遇到危险，我还是会夺命狂奔的T_T.
t1.bite()
人善被人欺，龟善被人骑，我可是会咬人的！
t1.eat()
谁知盘中餐粒粒皆辛苦，吃得好，不如吃得饱。
t1.sleep()
Zzzzz……
t2=Turtle()
t2.head
1
t2.legs
4
t2.eyes
2
t2.crawl()
人们总是抱怨我动作慢吞吞，殊不知不积跬步无以至千里。
t2.run()
虽然我行动很慢，但遇到危险，我还是会夺命狂奔的T_T.
t2.bite()
人善被人欺，龟善被人骑，我可是会咬人的！
t2.eat ()
谁知盘中餐粒粒皆辛苦，吃得好，不如吃得饱。
t2.sleep()
Zzzzz……
Python的对象都是一个样的吗？
当一个对象被创建出来之后，我们就可以随意去修改它的属性值。
t2.legs=3            （假设t2乌龟摔断了一条腿）
t2.legs
3
同一类创建的不同对象，它们之间是否共享数据呢？t2被修改，t1是否也跟着改变了呢？
t1.legs   
4
t1.mouth=1      （然后呢，我们也可以动态地创建一个属性，跟字典中添加一个键值对一样的）
t1.mouth
1
dir(t1)
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bite', 'crawl', 'eat', 'eyes', 'head', 'legs', 'mouth', 'run', 'shell', 'sleep']     （对比之下，t1比t2就多了一个mouth属性）
dir(t2)
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'bite', 'crawl', 'eat', 'eyes', 'head', 'legs', 'run', 'shell', 'sleep']

二、封装：封装是面向对象编辑的三个基本特征之一，另外两个是：继承和多态。
何以见得Python到处都是对象？
x=520
type(x)
<class 'int'>      （整数类的对象，有class，与普通的BIF不一样）
y="FishC"
type(y)
<class 'str'>
z=(1,2,3,4,5)
type(z)
<class 'tuple'>
m=[1,2,3,4,5]
type(m)
<class 'list'>                      （字符串、列表、元组、字典、集合，它们的构造函数，它们的原型里面都class，例如int的原型构造是class int；list也是class list，它们与普通的BIF是不一样的，普通的函数的原型定义是没有class的）
n={"one":1,"two":2,"three":3}
type(n)
<class 'dict'>

三、self是什么？为什么将一个函数放到“类”里面，必须要加上self参数才行呢？
class C:
    def hello():             （没有self参数）
        print("你好~")

        
c=C()       （但调用的时候却硬塞了一个参数给它，虽然看不见，但是硬朝里面塞，结果塞出异常了）
c.hello()
Traceback (most recent call last):
  File "<pyshell#41>", line 1, in <module>
    c.hello()
TypeError: C.hello() takes 0 positional arguments but 1 was given    （引出一个TypeError异常，提示hello这个方法定义的时候是不需要参数的，但调用的时候Python程序却硬塞了一个默认参数self给它，结果一塞就塞出错了，所以我们最好在定义hello函数的时候，提前把Python默认要硬塞的这个参数self给提前传进去，那么后面再调用hello函数时，Python就不会往里面硬塞self参数了）
class C:
    def get_self(self):        (self表示“类”创建实例对象的本身)
        print(self)

        
c=C()             （实例化一个对象小c）
c.get_self()
<__main__.C object at 0x0000025EAC696DB0>      （类C的实例对象小c）
c
<__main__.C object at 0x0000025EAC696DB0>       （看跟上面一模一样）
原来传递给方法的实例化对象本身，同一个类可以生成无数个对象的，当我们调用“类”里一个方法的时候，Python如何知道是哪一个“对象”在调用呢？就是通过这个self参数传递的信息，“类”中每一种方法默认的第一个参数都是self.
当一个对象的方法被调用，对象会将自身的引用作为第一个参数传递给该方法，那么Python就知道需要操作哪个对象的方法了。