Chapter1 python中一切皆对象

*python中的对象

1、对象具有3个基本特征：1、本征值（身份，identity），可以使用id()方法返回；2、型式（类型,type），可以使用type()获取；3、值(value)。

2、python中的“一切皆对象”对比其他面向对象编程语言更为彻底，其变量、函数、类等也均为对象；

且有四个特点：（1）任意对象（包括函数和类）可以赋值给一个变量；（2）任意对象（包括函数和类）可以传递到集合对象中；

如下代码即说明上述（1）（2）特点

def print_name(name = "Tony"):
    print(name)

my_func = print_name     #将函数名赋值给变量
my_func()
my_func('大海')

class Person:
    def __init__(self):
        print("Henry")

my_class = Person   #将类名赋值给变量
my_class()

#也可以将对象传递给集合对象中
obj_list = []
obj_list.append(print_name)
obj_list.append(Person)

"""
输出：
Tony     为列表第一个元素print_name()运行输出值
None     为列表第一个元素print_name()的函数返回值，默认返回None
Henry    为列表第二个元素Person()的__init__方法输出值
<_main_.Person object at...        为列表第二个元素Person()实例化对象值
"""
for item in obj_list:
    print(item())

特点（3）对象（函数）也可以作为返回值，这也是装饰器实现的基础

def print_name(name = "Tony"):
    print(name)


#将函数当成返回值
def decorator_func():
    print("start...")
    return print_name

my_func_return = decorator_func()  #用变量接收函数返回值
my_func_return("小明")

特点（4）对象（函数）还可以作为参数传递给另外一个函数，这也是装饰器实现的基础之一

def a():
    print(1)

def b(func):
    return func

c = b(a)  #调用b()，返回值赋值给变量c
c()     #实例化，运行，输出1

3、type（类型）、class（类）、object（对象）三者的关系

type有两个作用，一种是通过type(对象)查看对象的类型；另一种是通过type()创建一个类，这属于元类编程的范畴。

type可以创建一个类，class用来声明一个类，object是所有类中的基类；

python中所有的类都是继承自object；type可以创建类，type本身也是类，也继承自object。（可以通过类名.__bases__去获取该类继承的父类）

那么，基类object是由谁来创建的呢？是由type创建的，而type又继承了object。

——————————————

这部分内容超出了我之前的理解，我的理解也就是相对比较浅显。看完视频后的几个疑惑：1、type在我印象里只有一个type()方法，用来获取某个对象/变量的所属类型，可视频里又说type可以创建一个类，是什么意思呢？创建类的方法不是class ClassName的声明形式吗？2、python中所有类都继承自object类，这个好理解。但又说type本身也是类，还可以创建类，又继承自object，而基类object又是由type创建的。这到底是怎么回事？

查阅了知乎上一篇文章(https://zhuanlan.zhihu.com/p/100885824?share_code=11mkkAKbep1Li&utm_psn=1981681425683064242)，看完后理解上稍有提升，部分概念梳理一下：

（1）若有class A,其实例对象a；有A类的子类class B，其实例对象b；那么通过type()方法可以获取对象的所属类别，如type(a)为A（class '__main__.A'），type(b)为B（class '__main__.B'），这个好理解，就是a的所属类型为A，b的所属类型为B。

那么如果查询type(A)/type(B)呢，即要查询类A/B的所属类型呢？type(A)/type(B)均为type类（class 'type'），即类A的类型为"type"，这里也就说明"type"本身也是一个类/类型。

通过__bases__方法继续查询A和B的父类，分别为class 'object'和class '__main__.A'。

再引申，如果创建变量i =2,那么type(i)返回"int"，继续type(int)则返回“type”。

针对上述实例对象a,b及变量i，是否可以通过.__bases__方法获取其父类呢？——答案是不行，系统会报错。

稍加总结：type可以理解为“基类型”，所有的类、实例对象、变量都是具备“类型”这个属性的，如上面实例对象a的类型就是A，而类A的类型则是type，实例对象b的类型是B，类B的类型也是type，对变量i来说，其类型是int，而int的类型还是type，这就是一切对象/变量的类型归根结底都是type，实际操作上type()方法会返回其关系最近的一个类型。

而object可以理解为“基类”，其对应的是类，只有类才会有类这个属性，像实例对象、变量都是类的实例化，这些都不属于类了。对于类来说，才有父类这个概念，才可以通过.__bases__方法获取父类，而实例化对象/变量不是类，所以谈不上父类这个概念，所以使用__bases__会报错。

（2）第二点其实文章里有结合python底层C语言实现的解释，记住：1、object类是所有类(class)的父类，包括type类，object类的父类为空；2、type类是所有类的类型，即为所有类(class)都可由type实例化而来，包括type类自己。type(object)返回<class 'type'>，type.__bases__返回<class 'object'>，object.__bases__返回()即无父类。

最后关于type/object/class三者稍加归纳的一点：当使用class声明一个类时，python内部会调用type()去创建这个类，同时这个类会继承object基类。

6、python中的常见类型

数值类型（int/float/complex/bool）、None（全局只有一个）、迭代类型、序列类型（list/range/tuple/str...）、映射（dict）、集合（set）、其他类型（模块类型、class和实例、函数类型、方法类型\object对象、type类型等）等。

Chapter2 魔法函数（魔术方法）

1、魔术方法是python中通过固定名称去定义实现的特定功能方法，类定义中增加魔术方法可以对类进行功能拓展

class Student:
    def __init__(self, student_list):
        self.student = student_list

    #魔术方法getitem
    def __getitem__(self, item):
        return self.student[item]

student =  Student(["古华", "夏洛特", "大海"])   #此时student是实例化对象
#如果类定义中不加魔术方法，该实例对象student无法被遍历
students = student.student     #此时student是实例化对象student的student属性
for stu in students:
    print(stu)

#类定义中增加了__getitem__魔术方法后，可以直接遍历实例对象
for item in student:
    print(item)

class Student:
    def __init__(self, student_list):
        self.student = student_list

    # 魔术方法getitem,可以使该类的实例对象可以被遍历
    def __getitem__(self, item):
        return self.student[item]

    # 魔术方法str,可以使对象可以通过print()方法显式化打印输出
    def __str__(self):
        return ','.join(self.student)

student = Student(['1', '22', '333'])

for item in student:
    print(item)

print(student)

#向量运算
class myVector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    #魔术方法add
    def __add__(self, other_instance):
        re_vector = myVector(self.x + other_instance.x, self.y + other_instance.y)
        return re_vector

    #魔术方法str
    def __str__(self):
        return f"x: {self.x}, y: {self.y}"

v1 = myVector(1, 2)
v2 = myVector(2, 3)

print(v1 + v2)