高阶python(二) : type、object、类方法

一、 Python一切皆对象

一切皆对象的意思是在Python中，各种数据类型，函数，类都可以成为对象。

这种面向对象的特性就是为了追求简单，灵活，简洁，这也是Python的初衷。

面向对象语言的三大特性 : 封装、继承、多态

• 封装: 将数据或者功能隐藏起来形成一个整体(类或者函数的实现)
  作用：将数据或者功能保护起来，仅供外部调用

• 继承:创建一个新子类，它继承父类(超类，基类)
  作用 : 共享父类的功能，属性

• 多态 : 调用相同的函数名，因对象不同而得到不同的功能。
  作用:增加代码灵活性且不改变内部性能

# ----多态----
class A(object):
    def move(self):
        print("A moving")
class B(object):
    def move(self):
        print("B moving")
class C(object):
    def move(self):
        print("C moving")
'''
调用相同的方法，对象不同得到的结果不同这就是多态，
'''

def move(obj):
    obj.move()

move(A())
move(B())
move(C())
'''
A moving
B moving
C moving
'''

二、鸭子类型

“当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子。”
目的：增加代码的灵活性

举例：

这是 for 函数的用法，in后面添加的是可迭代对象
在python中可迭代对象的定义是，只要含有这个魔法方法便是可迭代对象

作用： 将对象变成一个容器

python中是可迭代对象有：list,str,tuple,dict,set，同时我们可以自己定义可迭代对象且可以在for循环中使用。

dict1 = {'a':1,'b':2,'c':3}
tuple1 = ('q','w','e')
list1 = [4,5,6]
str1 = 'iterator'
set1 = {1,1,1,'a','b','o'}

for i in dict1,tuple,list1,str1,set1:
    for _i in i:
        print(_i)

三、关于type的一点事

1. type()用法

str1 = 'abc'
int1 = 123
dict1 = {'a':1}
list1 = [1,2]

print(type(str1),type(int1),type(dict1),type(list1))
# <class 'str'> <class 'int'> <class 'dict'> <class 'list'>
print(type(str),type(int),type(dict),type(list))
# <class 'type'> <class 'type'> <class 'type'> <class 'type'>
print(type(object)) # <class 'type'>
print(type(type)) # <class 'type'>
print(type.__class__)  # <class 'type'> # 查看对象是谁创建的

type()的作用是查看数据类型的，但我们发现 str,int,dict,type,object的数据类型都是type。造成这个原因是因为在python中，所有的类型都是type创建的，而type自己也是type创建的，type被称为元类(能够创建类的类)。

平时我们创建一个实例的过程是 : type - > class -> str/int/list - > 实例

2. type() 和 isisinstance() 的区别

# ---- isinstance 和  type 的区别
class A(object):
    pass
class B(A):
    pass
b = B()
print(type(b) is B)
print(isinstance(b,B))
print(type(b) is A)    # 采用type 去判断类型时，不会直接向上寻找父类，存在一定的偏差
print(isinstance(b, A)) # isinstance 则会自动往上寻找

四、静态方法和类方法

1. 静态方法

# 静态方法是一类特殊的方法。有时，我们需要写属于一个类的方法，但是不需要用到对象本身
# 静态方法 跟 普通的def 差不多 但是进入到了类中，所以调用时要添加类名
class Test_static(object):
    def __init__(self,x,y):
        self.x = x
        self.y = y
    # 静态方法
    @staticmethod
    def add_stact(x,y):
       print(x+1,y+1)
    # 实例方法
    def add(self):
        return self.x,self.y
s = Test_static(1,2)
 
# 我们需要这么做才能+1
s.x = s.x+1
s.y = s.y+1
print(s.add())
# 采用了静态方法可以直接调用 不用每次实例化的时候都要写一次+1 才能完成步骤
s.add_stact(1,2)

2. 类方法

# 绑定在类上的方法 而非绑定在对象上
class Test_Classmethod(object):
    def __init__(self,x,y):
        self.x = x
        self.y = y
    @staticmethod   
    def add(x,y):
        return Test_Classmethod(x+1,y+1) # 如果类名改了 那么静态方法中的类名也要跟着修改 ，类方法就为我们改善了这一弊端
    @classmethod
    def add_c(cls,x,y):
        return cls(
            x = x+1,
            y = y+1
        )
    def __str__(self):
        return "{x},{y}".format(x = self.x,y = self.y)

c = Test_Classmethod(1,2)
print(c.add(1,2))
print(c.add_c(1,2))