Day12 面向对象（中）

3、参数self
  在说属性与方法前，我们还要来捋清楚面向对象和面向过程的区别，这里为大家引用了Cheney老师举的例子：把大象装进冰箱里。

面向过程 执行者
1：打开冰箱门 xxxxxx
2：装大象 xxxxxx
3：关冰箱门 xxxxxx

面向对象 指挥者

1. 冰箱.开门
2. 冰箱.存储
3. 冰箱.关门
     面向对象里的冰箱就是一个对象，开门、存储、关门都是方法

3.1 属性和方法
类中定义的属性和方法都是公共的，任何该类实例都可以访问
属性和方法的查找流程
当我们调用一个对象的属性时，解析器会现在当前的对象中寻找是否还有该属性，如果有，则直接返回当前的对象的属性值。如果没有，则去当前对象的类对象中去寻找，如果有则返回类对象的属性值。如果没有就报错
类对象和实例对象中都可以保存属性(方法)
如果这个属性(方法)是所以的实例共享的，则应该将其保存到类对象中
如果这个属性(方法)是摸个实例独有的。则应该保存到实例对象中
一般情况下，属性保存到实例对象中 而方法需要保存到类对象中
用上次博客的一个例子来展示一下属性和方法
class Person():
name = ‘旺仔1’ # 数据 （属性）

def like(w):  # 能做什么事情 行为  （方法）
    print('python')

p1 = Person()
p1.name = ‘旺仔2’ # 这是给实例对象添加属性的方式
print(p1.name)
p1.like() # 方法的使用

p2 = Person()
print(p2.name)

可以看到，第二行就是我们定义的属性，4-5行是方法的定义，第11行就是方法的使用，不过这是刚开始学，将属性写的类里面方便理解，以后还需注意：

属性最好是携带在实例中比较好，也就是说创建实例属性
行为（方法）创建在类中
3.2 self
self在定义时需要定义，但是在调用时会自动传入。
self的名字并不是规定死的，但是最好还是按照约定是用self，比如self也可以用w代替
self总是指调用时的类的实例
我们先看一下self到底是啥，先看看它是怎么用的

class Person():

def like(self):  # 谁调用like方法，self就是那个对象本身
    print(self)

p1 = Person()
print(p1)
p1.like()
运行结果 》》》
<main.Person object at 0x0000020CF0F75940>
<main.Person object at 0x0000020CF0F75940>

p2 = Person()
print(p2)
p2.like()
运行结果 》》》
<main.Person object at 0x0000020CF0F7B358>
<main.Person object at 0x0000020CF0F7B358>
  我们创建2个实例p1和p2，可以发现如果我们方法中直接打印我们的self，在使用方法，将得到和打印p2一样的地址，说明这个self就是我们创建的实例，但是实例与实例之间又是不相同的喔！！

我们再看一个完整有的，包含方法调用的

class Person():

def like(self):  # 谁调用speak方法，w就是那个对象本身
    print(f'{self.name}喜欢python')

def run(self):
    print(self)

p1 = Person()
p1.name = ‘旺仔’
print(p1.name)
p1.like()
p1.run()

运行结果 》》》
旺仔
旺仔喜欢python
<main.Person object at 0x00000251E492B358>

p2 = Person()
p2.name = ‘忘仔’
print(p2.name)
p2.like()
p2.run()

运行结果 》》》
忘仔
忘仔喜欢python
<main.Person object at 0x00000251E492B3C8>

self其实相对来说不难，个人感觉与函数的传参有点像，毕竟所谓的方法，就是写在class里的def，还是相似的，可以理解写在类里面的函数就是方法，像我们之前学到的字符串的一些方法，如split（）方法就是这样，这就是别人定义好的，我们直接拿来用就可以了。然后创建一个字符串就相当于实例（对象）的创建。
查看源代码方法：选定要查看的方法，CTRL+B即可直接跳转。

4、 特殊方法
在类中可以定义一些特殊方法也称为魔术方法
特殊方法都是形如 xxx()这种形式
方法是需要调用执行的，特殊方法不需要我们调用，特殊方法会在特定时候自动调用
这里为大家整理了一个特殊用法表。（并为大家介绍几种）

分类	方法
字符串/字节类	repr，str，format ，bytes
数值转换	abs，bool，__ complex__，__ init__，__ float__，hash，index
仿集合类	len，getitem，__ setitem__，delitem，contains
迭代循环	iter，reversed，next
可调用模拟	call
上下文管理	enter，exit
实例创建与销毁	new，init，del
属性管理	getattr，getattribute，setattr，__delattr __，dir
属性描述	get，__ set__，delete
类服务	prepare,instancecheck,subclasscheck

运算符类相关的特殊方法

运算符类	方法(括号中为代表的运算符)
一元运算符	neg(-)， pos (+)，abs(abs())
比较运算符	it（>）,le（<），eg(=)，ne(!=)，gt(>)，ge(>=)
算术运算符	add(+)，sub (-)，mul(*)，truediv(/)，floordiv（//），mod(%)，__ divmod__ (divmod())， pow （**）或pow()， round （round()）
反向算术运算符	radd， rsub， rmul， rtruediv， rfloordiv， rmod， rdivmod， rpow
增量赋值算术运算符	iadd， isub， imul ， itruediv， ifloordiv， imod， ipow
位运算符	invert （~）， lshift （<<）， rshift （>>）， and （&）， or （
反向位运算符	rlshift， rrshift， rand， rxor， ror
增量赋值位运算符	ilshift， irshift， iand， ixor， ior

__init__方法
  __ init__方法是类在创建实例的那一瞬间，就会默认调用的方法，而定义在这个方法里的属性，我们称它为初始化属性。

简单基础用法
class Person(object):
def init(self):
print(‘大家好，我是旺仔’)

p1 = Person()
运行结果 》》》
大家好，我是旺仔
当我们创建实例的时候就会默认调用，我们写了输出，他立马就会给我们输出

进阶用法
为什么要用__ init__方法呢，因为我们自己创建方法会出现以下问题：

name这个属性是必须的
name这个属性又各不相同
手动添加name属性容易遗忘，假使没有忘记，查看源码非常的麻烦
所以我们使用__ init__方法改写我们之前的代码

class Person():

def __init__(self, name):  # 对于init方法，实例创建的时候就被调用了
    self.name = name

def like(self):  # 谁调用speak方法，w就是那个对象本身
    print(f'{self.name}喜欢python')

p1 = Person(‘旺仔’)
p1.like()

当我们创建实例的时候，__ init__方法就会自动调用，这时就已经有获取了name属性的参数，因为self就是创建的实例，也就是p1，等于于p1.name=name，所以在调用like方法时就能得到参数。

new()方法
  new()方法在Python :类里面的构造方法__ init__方法负责将类的实例化，而在__ init__方法调用之前，new()方法决定是否要使用该__ init__方法。
  因为__new__()方法可以调用其他类的构造方法或者直接返回别的对象来作为本类 的实例。
  如果将类比喻为工厂，那么__ init__方法则是该工厂的生产工人，__ init__方法接受的初始化参 数则是生产所需原料，__ init__方法方法会按照方法中的语句负责将原料加工成实例以供工厂出货。而 new()方法则是生产部经理，new()方法可以决定是否将原料提供给该生产部工人，同时它还决定着出 货产品是否为该生产部的产品，因为这名经理可以借该工厂的名义向客户出售完全不是该工厂的产品。

new()方法的特性：
new()方法是在类准备将自身实例化时调用。
new()方法始终都是类的静态方法，即使没有被加上静态方法装饰器。
  类开始实例化时，new()方法会返回cls（cls指代当前类）的实例，然后该类的__ init__方法作为构造方法会接收这个实例（即self）作为自己的第一个参数，然后依次传入__new__()方法中接收的位置参数和命名参数。

class person(object):
def init(self, *args, **kwargs):
pass

def __new__(cls, *args, **kwargs):
    return object.__new__(people, *args, **kwargs)  # 返回Stranger类的实例

class people(object):
pass

p1 = person()
print(type(p1)) # 结果显示p1其实是Stranger类的实例
运行结果 》》》
<class ‘main.people’>

5、封装
出现封装的原因：我们需要一种方式来增强数据的安全性
1、属性不能随意修改
2、 属性不能改为任意的值
封装是面向对象的三大特性之一
封装是指隐藏对象中一些不希望被外部所访问到的属性或方法
5.1、封装引入
案例背景引入：
如下有一串代码
class Cat():

def __init__(self, name, color):
    self.name = name
    self.color = color

def run(self):
    print(f'{self.color}的{self.name}跑起来了')

def call(self):
    print('喵呜~~~~~')

cat1 = Cat(‘大橘’,‘橘黄色’)
cat1.run()
cat1.call()

cat1.name = ‘加菲’
cat1.run()
cat1.call()

运行结果 》》》
橘黄色的大橘跑起来了
喵呜~~~~~
橘黄色的加菲跑起来了
喵呜~~~~~
  众所周知，我们在工作的时候都是协同开发，所有互相使用代码是很常见的事情，如果不进行保护（警告）的话，可能同事也不是故意的，就将你不希望更改的代码改了，很是麻烦，所有要进行封装。
  如上例：我们正常运行是没有任何问题的，只要输入猫的名字和颜色即可，但是如果将名字改成以下结果，看上去就很怪了。

cat1.name = ‘阿拉斯加’
cat1.run()
cat1.call()

运行结果 》》》
橘黄色的阿拉斯加跑起来了
喵呜~~~~~

是吧，什么鬼！！！阿拉斯加还喵呜！！！
当然，这只是举个例子，但是还是反映出了，需要对代码进行封装，也就是保护数据的安全性。

5.2、封装
讲述了为什么封装的背景，我们了解到我们的需求就是要告诉我们的同事（猪队友）我们写的哪些东西不要更改，所以我们这里用到了封装的几个用法

我们提供给一个getter()和setter()方法是外部可以访问到属性
getter() 获取对象中指定的属性
setter() 用来设置对象指定的属性
使用封装，确实增加了类的定义的复杂程度，但是它也确保了数据的安全
1、 隐藏属性名，使调用者无法随意的修改对象中的属性
2、 增加了getter()和setter()方法，很好控制属性是否是只读的
3、使用setter()设置属性，可以在做一个数据的验证
4、使用getter()方法获取属性，使用setter()方法设置属性可以在读取属性和修改属性的同时做一些其他的处理
可以为对象的属性使用双下划线开头 __xxx。双下划线开头的属性，是对象的隐藏属性，隐藏属性只能在类的内部访问，无法通过对象访问
其实隐藏属性只不过是Python自动为属性改了一个名字 --> _类名__属性名
例如 __name --> _Person__name
封装一（不正式，可以辅助理解）
hidden_name的引入
class Cat():

def __init__(self, name):
    self.hidden_name = name

cat1 = Cat(‘大橘’)
cat1.name = ‘加菲猫’ # 相当于重新赋值一个属性
print(cat1.hidden_name)
print(cat1.name)

cat1.hidden_name = ‘加菲猫’ # 这里是重新给dog这个对象赋予一个属性值name
print(cat1.hidden_name)

运行结果 》》》
大橘
加菲猫
加菲猫

引入一个hidden的用法，我们这个写，他改我们的名字就没有任何效果，但是还是可以真正的修改掉，例如12行的代码

class Cat():

def __init__(self, name):
    self.hidden_name = name

# 创建一个getter（）方法  给调用者一个查询数据的方法
def get_name(self):
    print('get方法被调用了')
    return self.hidden_name

# 创建一个setter（）方法  给调用者一个修改数据的方法
def set_name(self, name):
    print('set方法被调用了')
    self.hidden_name = name
    print(f'{self.hidden_name}')

cat1 = Cat(‘大橘’)
print(cat1.hidden_name)

cat1.get_name()
cat1.set_name(‘折耳猫’)

运行结果 》》》
大橘
get方法被调用了
set方法被调用了
折耳猫

如果我们不希望数据被修改，可以使用getter（）方法与setter（）方法，当然自己创建的方法名称可以自定义，只要里面的参数和返回的是一样的就可以了。
同理，当我们看见同时的代码里有提供这个方法的时候，就要按照提供的方法去使用，不能擅自修改属性，就算觉得存在一些bug，也要争取同事的意见后再修改！！
还有当只提供了getter（）方法没有提供setter（）方法，那么属性就是一个只读属性。

封装二
使用 hidden是比较低级的用法，就是比较low，一般都是直接使用下划线_，效果也是一样的，直接上代码！！

单下划线的使用
class Cat():

def __init__(self, name):
    self._name = name

# 创建一个方法  getter（）方法  给调用者一个查询数据的方法
def get_name(self):
    print('get方法被调用了')
    return self._name

# 创建一个setter（）方法  给调用者一个修改数据的方法
def set_name(self, name):
    print('set方法被调用了')
    self._name = name

cat1 = Cat(‘大橘’)
cat1._name = ‘折耳猫’
print(cat1.get_name())

运行结果 》》》
get方法被调用了
折耳猫

双下划线的使用
class Cat():

def __init__(self, name):
    self.__name = name

# 创建一个方法  getter（）方法  给调用者一个查询数据的方法
def get_name(self):
    print('get方法被调用了')
    return self.__name

# 创建一个setter（）方法  给调用者一个修改数据的方法
def set_name(self, name):
    print('set方法被调用了')
    self.__name = name

cat1 = Cat(‘大橘’)
cat1.__name = ‘折耳猫’
print(cat1.get_name())

运行结果 》》》
get方法被调用了
大橘

我们发现双下划线好像不能更改属性值，因为它是私有属性，当然一定要改也可以，但是不建议使用，此处也给出了代码，就是在双下划线前在加上一个下划线和类的名称即可。

接上述代码

cat1._Cat__name = ‘折耳猫’
print(cat1.get_name())

运行结果 》》》
get方法被调用了
折耳猫