引言

  • Java语言也是面向对象的语言，但是Python要更加彻底
  • Python的面向对象特性，是它使用起来灵活的根本所在

    对象的特点

    可以赋值给一个变量

    ```python

    函数也是对象

    def test(name): print(name)

my_func = test # 注意 只写函数名 和 函数名加括号 的区别 my_func(“MetaTian”) # 打印：MetaTian

  1. <a name="22f93e7a"></a>
  2. ## 可以添加到集合中去
  3. ```python
  4. def plus(a, b):
  5.     print(a+b)
  7. def minus(a, b):
  8.     print(a-b)
  10. fun_list = []
  11. fun_list.append(plus)
  12. fun_list.append(minus)
  13. for item in fun_list:
  14.     item(2, 1)
  16. # result:
  17. # 3
  18. # 1

可以作为参数传递给函数

  1. def plus(a, b):
  2.     print(a+b)
  4. def calculate(method, a, b):
  5.     method(a, b)
  7. calculate(plus, 1, 2)
  9. # result:
  10. # 3

可以当做函数的返回值

  1. # 这也是装饰器的原理
  2. def inner():
  3.     print("MetaTian")
  5. def deco():
  6.     print("decorating...")
  7.     return inner
  9. my_func = deco()
  10. my_func()
  12. # result:
  13. # decorating...
  14. # MetaTian

对象的3个属性

  • 身份：在内存中的地址是多少，可用id()函数查看
  • 类型：是什么类型的对象，可用type()函数查看
  • 值：对象中的内容是什么

    type object和class的关系

    type和class

    关系：type -> class -> obj，obj是我们平时使用的对象，它由class对象生成，可以是我们自定义的类，也可以是内建的类。上面说了，一切皆对象，class也是以type为模板，生成的对象。
    type()函数，当传入一个参数时，返回对象的类型。传入三个参数时，用来生成一个类。具体的参数情况和使用方式可以查阅官方文档：docs.python.org/3/library/functions.html#type ```python print(type(1)) print(type(int))

    result:

class Person: pass

student = Person() print(type(student)) print(type(Person))

result:

print(type(type))

result:

  1. `type`是以它自己为类生成的一个对象。如果熟悉静态语言，这似乎并不好理解，但是对动态语言来说就是这么自然。
  2. <a name="object"></a>
  3. ## object
  4. `object`是最根本的一个**基类**，如果自己定义的类没有显示地去继承某一个类，则它会自动继承`object`。上面讨论的是**类和对象**之间的关系，现在要讨论的是**类和类**之间的关系。
  5. ```python
  6. class Person:
  7.     pass
  9. class Student(Person):
  10.     pass
  12. print(Student.__bases__)
  13. print(Person.__bases__)
  14. print(int.__bases__)
  15. print(object.__bases__)
  17. # result:
  18. # (<class '__main__.Person'>,)
  19. # (<class 'object'>,)
  20. # (<class 'object'>,)
  21. # ()
  23. print(type.__bases__)
  24. print(type(object)
  25. # result:
  26. # (<class 'object'>,)
  27. # <class 'type'>

type是一个类，它继承的是object，object作为一个对象又是以type为类型生成的。

总结

Python中一切皆对象 - 图1

常见的内置类型

None

  • 全局只有一个

  • 就是内存中的某一块区域

    数值

  • int

  • float
  • complex

  • bool

    迭代类型

    序列类型

  • list

  • tuple
  • range

  • str

    映射类型

  • dict

    集合类型

  • set

  • frozenset

    上下文管理类型

  • with

    其他

  • 模块类型

  • class 和实例
  • 函数类型
  • 方法类型
  • 代码类型
  • object
  • type
  • …

    小结

    综合上面的几点讨论，可以看到Python和其他的静态语言是大不相同。一切皆对象的设计思想，让Python程序的编写异常灵活，但是相比静态语言，它也丢失了一定的严谨性，有很多错误，我们只能够在代码的运行过程中才能发现。但这些动态语言的通病并未影响我们开发效率的提升。