{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Python3入门到精通——面向对象\n", "\n", "作者： Daniel Meng\n", "\n", "GitHub： [LibertyDream](https://github.com/LibertyDream)\n", "\n", "博客：[明月轩](https://libertydream.github.io/)\n", "\n", "> 本系列教程采用[知识共享署名-非商业性使用-相同方式共享 2.5 中国大陆许可协议](http://creativecommons.org/licenses/by-nc-sa/2.5/cn/)\n", "\n", "编程就是和计算机对话，告诉计算机做什么、怎么做。而当代计算机的外貌或许不同，但其实质都差不多，因为他们都是按照**冯诺依曼架构**设计的，冯诺依曼架构设计计算机讲究**存储程序**，即程序和数据都存放在一起\n", "\n", "而对于怎么放，一开始人们**按照机器运行的思路**，需要数据就先准备好数据，处理数据所需的函数与算法也准备好，然后运行程序，按照一定顺序执行语句，以完成任务。这就是**面向过程**的编程\n", "\n", "当程序越来越复杂，简单的“顺序”堆放数据和程序给项目开发带来了巨大的效率瓶颈。于是人们开始**按照人类认识世界的方式**重新将程序和数据围绕着某个意义组织起来，这就是**面向对象**的编程\n", "\n", "面向对象编程有两个核心概念，一是**类**，一个是**对象**。类就是人类认识世界时所相信的那些意义，是对世界的抽象，比如教师，学生，国家，公司。而对象是类的实例化，比如孔子，颜回，中国，腾讯。\n", "\n", "**使用类和对象进行编程不代表就是面向对象，尽量编写有意义的面向对象代码**\n", "\n", "![outline](./img/basic/chapter_6_outline.png)\n", "\n", "## 类的定义\n", "\n", "Python中使用关键字`class`定义类，类的命名推荐**每个单词首字母大写**。类内可以像模块一样定义变量和方法。" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "class Student(): # 简单的类定义，但有错误\n", " age = 0\n", " name = ''\n", " \n", " def print_student_details():\n", " print(\"name: %s, age: %s\":(name, age))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "使用类要先将类实例化，通过`ClassName()`的方式进行，可以将实例化的结果赋值给一个变量。Python中类的实例化不必像 C++ 或者 Java 一样借助`new`关键字" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "student = Student()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "实例化后，使用`.`操作符访问类中的变量和方法" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "student.print_student_details()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "类中的方法当然能像函数定义一样不接收参数，但即使如此，类中方法也需要在定义时最少传入`self`作为参数" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "ename": "TypeError", "evalue": "print_student_details() takes 0 positional arguments but 1 was given", "output_type": "error", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 7\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 8\u001b[0m \u001b[0mstudent\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mStudent\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 9\u001b[1;33m \u001b[0mstudent\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mprint_student_details\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[1;31mTypeError\u001b[0m: print_student_details() takes 0 positional arguments but 1 was given" ] } ], "source": [ "class Student():\n", " age = 0\n", " name = ''\n", " \n", " def print_student_details(): # 最少要有self作为参数\n", " print('name: %s, age: %s' % (name, age))\n", " \n", "student = Student()\n", "student.print_student_details()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "其次，模块中的变量使用时按照`var_name`形式定义即可通过`var_name`调用，但类里的变量在使用时必须通过`self.var_name`的方式调用" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "ename": "NameError", "evalue": "name 'name' is not defined", "output_type": "error", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 7\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 8\u001b[0m \u001b[0mstudent\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mStudent\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 9\u001b[1;33m \u001b[0mstudent\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mprint_student_details\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[1;32m\u001b[0m in \u001b[0;36mprint_student_details\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m 4\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 5\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mprint_student_details\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 6\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'name: %s, age: %s'\u001b[0m \u001b[1;33m%\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mname\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mage\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 7\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 8\u001b[0m \u001b[0mstudent\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mStudent\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", "\u001b[1;31mNameError\u001b[0m: name 'name' is not defined" ] } ], "source": [ "class Student():\n", " age = 0\n", " name = ''\n", " \n", " def print_student_details(self):\n", " print('name: %s, age: %s' % (name, age)) # 调用类里的变量必须使用 self.var_name方式\n", " \n", "student = Student()\n", "student.print_student_details()" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "name: , age: 0\n" ] } ], "source": [ "class Student(): # 正确的类定义\n", " age = 0\n", " name = ''\n", " \n", " def print_student_details(self):\n", " print('name: %s, age: %s' % (self.name, self.age))\n", " \n", "student = Student()\n", "student.print_student_details()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "如此我们就将变量`name`，`age`和方法`print_student_details`装在了`Student`这个类中。这就体现了类最基本的功能——**封装**，每个类都有自己的一些变量和方法。\n", "\n", "注意，**类中只能定义方法而不能使用**" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "ename": "TypeError", "evalue": "print_student_details() missing 1 required positional argument: 'self'", "output_type": "error", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;32mclass\u001b[0m \u001b[0mStudent\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 2\u001b[0m \u001b[0mage\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m0\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 3\u001b[0m \u001b[0mname\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m''\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 4\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 5\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mprint_student_details\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", "\u001b[1;32m\u001b[0m in \u001b[0;36mStudent\u001b[1;34m()\u001b[0m\n\u001b[0;32m 6\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'name: %s, age: %s'\u001b[0m \u001b[1;33m%\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mname\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mage\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 7\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 8\u001b[1;33m \u001b[0mprint_student_details\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;31m# 类中不能调用方法\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[1;31mTypeError\u001b[0m: print_student_details() missing 1 required positional argument: 'self'" ] } ], "source": [ "class Student():\n", " age = 0\n", " name = ''\n", " \n", " def print_student_details(self):\n", " print('name: %s, age: %s' % (self.name, self.age))\n", " \n", " print_student_details() # 类中不能调用方法\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "在编程实践中，**类的定义和类的调用应该分属不同模块，避免在同一模块中即定义又使用**\n", "\n", "在一个模块定义好类后，可以在其他模块内通过`from module_name import class_name`的方式导入类，再实例化类进行使用\n", "\n", "> 方法和函数形式和功用都很类似，但方法的概念更偏向设计层面，讲究作为意义的一部分，而函数的概念更像是程序运行时的一种过程式的称谓。\n", "\n", "> 类里面的变量也叫做数据成员、属性，和方法一起构成了类。二者对应于意义的属性和行为，比如老师这一抽象具有教师编号等属性，还有留作业等行为\n", "\n", "### 类和对象\n", "\n", "通过上面的介绍和样例，应该已经知道怎么定义和使用类，但怎么理解类和对象呢？\n", "\n", "专业的定义中，类是现实世界或思维世界中的实体在计算机中的反应，它将数据及这些数据上的操作封装在一起。现实或认知里有的东西（概念、意义等）映射到计算机世界中就化身为一个类，比如学生，猫，狗。这些概念本身包含了一些独有的特征和行为，比如学生有学号、学历特征，要会做作业和考试，猫有叫声、花纹特征，要能捉老鼠、爬树。\n", "\n", "这些概念所蕴含的**独有特征**就是类里的数据，也叫做**数据成员或者属性**，概念本身所蕴含的**独有行为**就是类里的**方法**。\n", "\n", "**方法、属性和类所代表的概念(意义)要对应，这是类的设计原则，也是编程艺术的体现。**这时我们再来看一下上面`Student`类的设计：" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "class Student():\n", " age = 0\n", " name = ''\n", " \n", " def print_student_details(self):\n", " print('name: %s, age: %s' % (self.name, self.age))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "学生当然有年龄、姓名的属性，但是`print_student_details`这个打印学生档案的方法并不是学生自有的行为，学生的行为应该是做作业、考试、听课等。打印学生信息应该交给另一个类，比如打印类`Printer`" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "class Student():\n", " age = 0\n", " name = ''\n", " \n", " def do_homework(self):\n", " pass\n", " \n", "class Printer():\n", " \n", " def print_info(self):\n", " pass" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "类既然是一类事物的总称，那么这一类事物中的每一个独特的个体就是对象，所以也说**对象是类的实例化**。类告诉我们有什么属性和方法， 对象告诉我们属性具体是什么，也是具体行为的执行者，当想要使用类的时候请实例化一个对象去做吧，正如生活中老师下达任务给学生做，最后总要指明是给李蕾、韩梅梅或是其他人，一定落实在人上，而不是学生这样一个概念上。\n", "\n", "生活中学生可能拥有相同的年龄、名字，但每个学生都是独一无二的个体。计算机中也一样，对象属性可以相同，但每个对象都是独一无二的，可以通过`id`查看" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "class Student():\n", " name = 'Li Lei'\n", " age = 18\n", " \n", " def do_homework(self):\n", " print('I am doing homework')" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "student1 name: Li Lei, age: 18\n", "student2 name: Li Lei, age: 18\n" ] } ], "source": [ "student1 = Student()\n", "student2 = Student()\n", "\n", "print('student1 name: %s, age: %s' % (student1.name, student1.age)) # 两名学生姓名、年龄相同\n", "print('student2 name: %s, age: %s' % (student2.name, student2.age))" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "student1 id:2510290950128, student2 id: 2510290950464\n" ] } ], "source": [ "print('student1 id:%s, student2 id: %s' % (id(student1), id(student2))) # 内存位置并不相同" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 构造函数\n", "\n", "上面我们创建学生对象的时候都是使用`Student`类下数据成员的默认值，并不能自由“定制”属性。我们希望能像函数那样，自行决定参数值，来定制对象属性，类里面通过一个名为**构造函数**的方法实现这个功能——`__init__`,注意是双下划线，这也是构造函数唯一的名字。构造函数也和其他方法一样最少需要`self`作为参数。" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "class Student():\n", " \n", " name = ''\n", " age = 18\n", " \n", " def __init__(self):\n", " print('object is created.')\n", " \n", " def do_homework(self):\n", " print('I am doing homework!')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "构造函数的功能就是建构对象，按照我们希望的方式初始化对象属性，在实例化类的时候会自动运行。虽然能通过`.`操作符调用构造函数，但强烈建议不要这样做。" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "object is created.\n", "object is created.\n" ] } ], "source": [ "some_student = Student() # 自动执行构造函数，打印一遍\n", "some_student.__init__() # 手动调用，打印一遍。 强烈建议不要这样做" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "构造函数有且仅有唯一默认返回值`None` 。不能自定义返回其他值。" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "object is created.\n", "None\n" ] }, { "data": { "text/plain": [ "NoneType" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "rst = some_student.__init__()\n", "\n", "print(rst)\n", "type(rst)" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "object is created.\n" ] }, { "ename": "TypeError", "evalue": "__init__() should return None, not 'str'", "output_type": "error", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[0;32m 11\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'I am doing homework!'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 12\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 13\u001b[1;33m \u001b[0msome_student\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mStudent\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[1;31mTypeError\u001b[0m: __init__() should return None, not 'str'" ] } ], "source": [ "class Student():\n", " \n", " name = ''\n", " age = 18\n", " \n", " def __init__(self):\n", " print('object is created.')\n", " return 'create a object' # 构造函数返回值只能是 None\n", " \n", " def do_homework(self):\n", " print('I am doing homework!')\n", "\n", "some_student = Student()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 类变量和实例变量\n", "\n", "可以在`self`之后给出构建对象时外部要传入的参数列表，通常都是必须参数。但类中的赋值规则和模块里函数中的赋值规则不同，因为接收值的变量可能不是同一个。\n", "\n", "为作解释我们重新定义一下`Student`类" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [], "source": [ "class Student():\n", " \n", " name = 'Wu Ming'\n", " age = 18\n", " \n", " def __init__(self, name, age):\n", " name = name # Python能识别出这是为左边的 name 变量赋值， 形参是右边的 name\n", " age = age\n", " \n", " def do_homework(self):\n", " print('I am doing homework!')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "新的`Student`类在实例化的时候要指明姓名和年龄，类中属性的默认值是`Wu Ming`和`18`。我们构造两个对象并输出各自的姓名、年龄" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Student1 name: Wu Ming, age: 18\n", "Student2 name: Wu Ming, age: 18\n" ] } ], "source": [ "li_lei = Student('Li Lei', 21)\n", "han_mei_mei = Student('Han Meimei', 20)\n", "\n", "print('Student1 name: %s, age: %s' % (li_lei.name, li_lei.age))\n", "print('Student2 name: %s, age: %s' % (han_mei_mei.name, han_mei_mei.age))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "打印结果似乎有些奇怪，我们给出了两个对象的姓名与年纪，为什么打印值仍旧是默认值呢？这里涉及到了两个概念——类变量和实例变量\n", "\n", "顾名思义，**类变量**是指属于类的变量，**实例变量**是属于对象的变量。\n", "\n", "类变量就是在定义类后，定义方法前定义的变量，**注意，在 C, Java 等其他语言中这个位置定义的变量是实例变量，与 Python 不同**。实例变量是在构造函数里借助`self`,通过形如`self.var_name`的方式确定的。具体到这个例子中：" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [], "source": [ "class Student():\n", " \n", " name = 'Wu Ming' # 类变量\n", " age = 18 # 类变量\n", " \n", " def __init__(self, name, age):\n", " \n", " # name = name # 类似普通方法中定义的变量\n", " # age = age # 类似普通方法中定义的变量\n", " \n", " self.name = name # 实例变量\n", " self.age = age # 实例变量\n", " \n", " def do_homework(self):\n", " print('I am doing homework!')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "有了类变量和实例变量的概念后，再来看一下类的设计。既然类变量是类本身所拥有的，应该和具体对象无关，相应的，实例变量所代表的属性也是紧紧的和一个个具体对象绑定，和类代表的概念无关。那么本例中，学生姓名、年龄自然是学生个体所拥有的属性，和“学生”这一概念无关，应当作为实例变量，而学生在政治网络中的位置是“学生”这一身份本身确定的，并不因学生不同而不同。\n", "\n", "所以理想中的`Student`的类设计现阶段应该如下：" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "class Student():\n", " \n", " political_class = 0\n", " \n", " def __init__(self, name, age):\n", " self.name = name \n", " self.age = age\n", " \n", " def do_homework(self):\n", " print('I am doing homework!')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "话虽如此，我们依旧没有解释清楚为什么`li_lei`和`han_mei_mei`两个对象没有输出自身信息，却输出了默认值。除了类变量和实例变量的概念，还要知道 Python 中变量的访问顺序，面向对象编程中，解释器会**先找对象的实例变量，后找同名类变量**。\n", "\n", "为了确认对象所拥有的变量与变量值，可以使用`__dict__`这一 Python 内置变量来进行查看,类也有" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{}" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "li_lei.__dict__" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{}" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "han_mei_mei.__dict__" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "mappingproxy({'__dict__': ,\n", " '__doc__': None,\n", " '__init__': ,\n", " '__module__': '__main__',\n", " '__weakref__': ,\n", " 'age': 18,\n", " 'do_homework': ,\n", " 'name': 'Wu Ming'})" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "Student.__dict__" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "可以看到，`li_lei`和`han_mei_mei`两个对象中没有存储任何变量，而`Student`类中存有`name`和`age`两个字段。所以打印时自然输出的是默认值了。\n", "\n", "## self与实例方法\n", "\n", "有实例变量自然就有实例方法，即属于对象的方法，特点是必须传入一个`self`，目前我们所接触到的方法都是实例方法。`self`定义时必须给出，对象调用方法的时候自动隐去\n", "\n", "`self`实际上代表着调用方法的对象本身，比如，对于`Student`类中的实例方法来说，构造`li_lei`时，构造函数中的`self`就代表`li_lei`这个对象，构造`han_mei_mei`时就代表`han_mei_mei`。\n", "\n", "Python 中的`self`等价于 C，Java 中的 `this` 关键字，但`self`本身不是 Python 保留的关键字，可以是任意形式，只是必须第一个给出。" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [], "source": [ "class Student():\n", " \n", " political_class = 0\n", " \n", " def __init__(this, name, age): # 不必拘泥于 self，但 Python 建议是 self\n", " this.name = name \n", " this.age = age\n", " \n", " def do_homework(self):\n", " print('%s is doing homework!' % self.name)" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Li Lei is doing homework!\n" ] } ], "source": [ "li_lei = Student('Li Lei', 21)\n", "li_lei.do_homework()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 实例方法对类变量的访问\n", "\n", "在设计类的时候，实例方法内通过`self.var_name`的方式访问实例变量，如果不加`self`访问的是同名形参" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "奔波灞\n", "奔波灞\n" ] } ], "source": [ "class Student():\n", " \n", " political_class = 0\n", " \n", " def __init__(self, name, age):\n", " self.name = name \n", " self.age = age\n", " print(self.name)\n", " print(name) # 访问的是形参 name，不会访问到实例变量\n", " \n", " def do_homework(self):\n", " print('I am doing homework!')\n", " \n", "some_student = Student('奔波灞', 18)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "如果实例方法要访问类变量，可以通过`ClassName.var_name`和`self.__class__.var_name`两种方式。`__class__`也是Python内置变量之一" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0\n", "0\n" ] } ], "source": [ "class Student():\n", " \n", " political_class = 0\n", " \n", " def __init__(self, name, age):\n", " self.name = name \n", " self.age = age\n", " print(Student.political_class)\n", " print(self.__class__.political_class)\n", " \n", " def do_homework(self):\n", " print('I am doing homework!')\n", " \n", "some_student = Student('奔波灞', 18)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 类方法与静态方法\n", "\n", "有类变量相应的有类方法，类似于实例方法，类方法是专门用于操作类变量的函数，代表着类本身具有且和个体无关的行为。类方法的定义\n", "\n", "```python\n", " @classmethod\n", " def menthod_name(cls,...):\n", " pass\n", "```\n", "\n", "`@classmethod`一种特殊的标识，确切的名字是装饰器，日后会讲到。`cls`类似于`self`，是一个约定俗称的可变名字，代表着调用类方法的类本身。我们对`Student`类内添加一个表示学生数量的`nums`类变量和一个修改`nums`值的类方法" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "class Student():\n", " \n", " political_class = 0\n", " nums = 0 # 代表学生数量\n", " \n", " def __init__(self, name, age):\n", " self.name = name \n", " self.age = age\n", " \n", " def do_homework(self):\n", " print('I am doing homework!')\n", " \n", " @classmethod\n", " def plus_one(cls):\n", " cls.nums += 1" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "类方法通过`ClassName.method_name`的方式使用。Python支持对象访问类方法，这点与 C#, Java 不同，但是不建议这么做，因为逻辑不同。" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "some_student = Student('霸波奔', 18)" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1\n" ] } ], "source": [ "Student.plus_one()\n", "print(Student.nums)" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "2\n" ] } ], "source": [ "some_student.plus_one() # 不会报错，但不建议这么调用\n", "\n", "print(Student.nums)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "C#, Java 等语言中的静态方法更类似于 Python 中的类方法，但 Python 中也有静态方法的实现方式，其定义为：\n", "\n", "```python\n", " @staticmethod\n", " def func_name(...):\n", " pass\n", "```\n", "\n", "`@staticmethod`同样是装饰器，用于指明函数类型并赋予一定功能。注意静态方法不需要像类方法和实例方法一样传入指代参数`self`,`cls`。\n", "\n", "从静态方法的定义方式可以看出其本身和类与对象的关联较弱，所以不推荐使用。我们在`Student`里面实现一个名为`complain`的静态方法" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [], "source": [ "class Student():\n", " \n", " political_class = 0\n", " nums = 0 # 代表学生数量\n", " \n", " def __init__(self, name, age):\n", " self.name = name \n", " self.age = age\n", " \n", " def do_homework(self):\n", " print('I am doing homework!')\n", " \n", " @classmethod\n", " def plus_one(cls):\n", " cls.nums += 1\n", " \n", " @staticmethod\n", " def complain(mood):\n", " print(Student.political_class)\n", " print('Complain! Being %s' % (mood))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "类和对象都能访问静态方法，静态方法内部可以通过`ClassName.var_name`的方式调用类变量，但是和类方法一样不能访问实例变量" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0\n", "Complain! Being angry\n", "0\n", "Complain! Being nauty\n" ] } ], "source": [ "some_student = Student('王也', 20)\n", "\n", "some_student.complain('angry')\n", "Student.complain('nauty')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 成员可见性\n", "\n", "类有内外之分，定义类所在的区块属于内部，通过`self.`和`cls.`的访问与调用叫做**内部调用**。类定义区块之外属于外部，通过对象、类名进行访问和调用叫做**外部调用**\n", "\n", "类设计好后，进行外部调用时，常常希望一些敏感数据不为外界随意修改。这就涉及到成员可见性的概念，这也不是 Python 独有的概念。对于外部和内部都能随意访问修改的变量、方法我们称其是**公开**的，而只有内部能调用、访问而外部不能的，我们说它是**私有**的。\n", "\n", "**数据成员都应是私有的，只应通过方法来访问、修改是公共提倡的设计准则**。因为方法可以对值进行边界、安全检查以及其他一些操作。\n", "\n", "Python中通过`__name`（双下划线）的方式确认可见性。这里注意`__`只在前面，前后都有双下划线的通常代表 Python 内置方法、变量，虽然自己也能这么命名但不建议这么做。" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [], "source": [ "class Student():\n", " \n", " __political_class = 0\n", " \n", " def __init__(self, name, age):\n", " self.__name = name # 数据成员应该私有\n", " self.__age = age\n", " self.__score = 0\n", " \n", " def do_exercise(self):\n", " self.__plus_score() # 内部调用私有方法\n", " print('I am doing exercise! Score is going up!')\n", " \n", " def __plus_score(self):\n", " self.__score += 1\n", " \n", " def get_name(self): # 通过方法访问成员\n", " return self.__name\n", " \n", " def set_name(self, name): # 通过方法修改成员\n", " self.__name = name" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "I am doing exercise! Score is going up!\n" ] } ], "source": [ "some_student = Student('汤姆', 20)\n", "\n", "some_student.do_exercise()" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "ename": "AttributeError", "evalue": "'Student' object has no attribute '__plus_score'", "output_type": "error", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[1;31mAttributeError\u001b[0m Traceback (most recent call last)", "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0msome_student\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m__plus_score\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[1;31mAttributeError\u001b[0m: 'Student' object has no attribute '__plus_score'" ] } ], "source": [ "some_student.__plus_score() # 私有方法外部不可见" ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [ { "ename": "AttributeError", "evalue": "'Student' object has no attribute '__score'", "output_type": "error", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[1;31mAttributeError\u001b[0m Traceback (most recent call last)", "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0msome_student\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m__score\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[1;31mAttributeError\u001b[0m: 'Student' object has no attribute '__score'" ] } ], "source": [ "some_student.__score # 私有成员外部不可见" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "私有成员在外部是不能访问和修改的，但是可能会发生下面的事，既修改了，也访问到了" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "-1\n" ] } ], "source": [ "some_student.__score = -1\n", "print(some_student.__score)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "难道是 Python 的防护措施失效了吗？当然不是，因为 Python 是解释型语言，所以`some_student.__score = -1`实际上是给`some_student`添加了一个新的名为`__score`的实例变量。可以通过`__dict__`验证" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'_Student__age': 20,\n", " '_Student__name': '汤姆',\n", " '_Student__score': 1,\n", " '__score': -1}" ] }, "execution_count": 34, "metadata": {}, "output_type": "execute_result" } ], "source": [ "some_student.__dict__" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "可以看到`some_student`对象下的私有成员中真的多了一个，而更奇怪的是其他三个成员和我们代码中似乎没定义过。这就是 Python 私有保护机制的特点了，对于私有成员，Python 会通过`_ClassName__private_var_name`的形式进行存储，我们定义的变量实际变了样子。\n", "\n", "变相地说明，**Python中没有什么是不能访问的**，如果我们通过相同方式组装一个变量名进行访问，是能够访问的到私有成员的，当然强烈建议不要这么做" ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1\n" ] } ], "source": [ "print(some_student._Student__score) # 没有什么不能访问" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 类的继承\n", "\n", "类有两大组成部分——特征和行为，而在工程实践当中，难免会遇到有些特征、行为高度一致，为了避免重复开发相同的变量、方法就可以使用类的继承。\n", "\n", "上面是从语法和开发上讲，从实际意义上来看，因为类代表的是现实、认知世界实体在计算机中的映射，那么类的继承其实是对一些实体间存在的上下游、超集和子集等关联信息在计算机进行表达。比如说我们定义了学生类`Student`，但学生是人类，所以学生的特征、行为一定继承了人类类`Human`的一些内容。\n", "\n", "Python中类继承的语法是：\n", "\n", "```python\n", " class SampleClass(ParentClass):\n", " pass\n", "```\n", "\n", "一个良好的编码规范是，**如果一个类不继承自其它类, 就显式的从object继承**" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "class Human(object): # 没有继承其他类，就显式的从object继承\n", " \n", " __sums = 0\n", " \n", " def __init__(self, name, age):\n", " self.__name = name\n", " self.__age = age\n", " \n", " def get_name(self):\n", " return self.__name\n", " \n", " def get_age(self):\n", " return self.__age\n", " \n", " @classmethod\n", " def get_nums(cls):\n", " return cls.__sums\n" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "class Student(Human): # 继承自 Human 类\n", " \n", " def do_homeword(self):\n", " print('I am doing homeword')\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "这里我们展示了`Student`对`Human`的继承，如果是在工程中不同类可能处于不同包、模块内，可以使用`from ... import ...`语句导入后再继承使用。\n", "\n", "继承后`Student`虽然没有定义构造函数和一些方法，但实际有和`Human`一致的一套同名方法" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "ename": "TypeError", "evalue": "__init__() missing 2 required positional arguments: 'name' and 'age'", "output_type": "error", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mli_lei\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mStudent\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;31m# 不符合构造函数，报错\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[1;31mTypeError\u001b[0m: __init__() missing 2 required positional arguments: 'name' and 'age'" ] } ], "source": [ "li_lei = Student() # 不符合构造函数，报错" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "I am Li Lei and 20 years old\n" ] } ], "source": [ "li_lei = Student('Li Lei', 20)\n", "\n", "print('I am %s and %s years old' % (li_lei.get_name(), li_lei.get_age()))" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "Student.get_nums() # 类变量也继承" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "有了父类后就可以自由扩展成自己需要的子类，比如可以在`Human`类上继承出教师类、厨师类等等，有多少子类完全由个人决定。\n", "\n", "![继承](./img/basic/chapter_6_inherit.png)\n", "\n", "上图展示了最常见也是推荐的继承方式，每个子类都只有一个父类，也叫做**单继承**，Python 实际上支持**多继承**，即一个类可以同时继承自多个父类。但是为了保证继承关系清晰简洁，避免不必要的冲突，不建议使用多继承。\n", "\n", "`Student`作为子类总有自己独特的一些特征和方法，我们添加成绩`score`属性和其访问方法`get_score`。注意这时`Student`类的构造函数实际要接收的是三个参数，分别是父类的`name`和`age`，以及独有的`score`。构造函数的实现也要体现所有关系" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [], "source": [ "class Student(Human):\n", " \n", " def __init__(self, name, age, score): # 要接收三个参数\n", " Human.__init__(self, name, age) # 注意 self 也要传入\n", " self.__score = score\n", " \n", " def do_homework(self):\n", " print('I am doing homework!')\n", " \n", " def get_score(self):\n", " return self.__score\n" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "I am Li Lei and 20 years old. I scored 30 points.\n" ] } ], "source": [ "li_lei = Student('Li Lei', 20, 30)\n", "\n", "print('I am %s and %s years old. I scored %s points.' % (li_lei.get_name(), li_lei.get_age(), li_lei.get_score()))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "在类的继承中，**子类中的方法会覆盖父类中的同名方法**，而为了获取足够的实例变量往往需要在子类的构造函数内显式的调用父类构造函数，注意这里`self`这一指代参数也要被传入，这和原来我们展示的在外部显式调用构造函数不同，注意辨别。\n", "\n", "这时我们思考两个问题，如果我们的子类设计很复杂，每个方法中都要使用父类，如果我们都使用`Human`这样通过名字来显式指定父类的方式，每当继承关系改变，我们都要逐行去寻找哪些地方的`Human`样名称需要改变，这不仅繁琐且容易出错，同时触犯了一个很重要的设计原则——**开闭原则**。\n", "\n", "开闭原则讲究**类、模块和函数应该对扩展开放，对修改关闭**，简单理解就是可以添加新代码，但拒绝修改旧代码。我们实现变化的时候应该扩展实体行为，而不是修改旧有代码进行实现，对旧有代码能不动就不动。\n", "\n", "第二个问题是我们调用方法多是通过对象调用，例子中的构造函数实际也被我们当做一个普通的实例方法使用。那么我们通过类调用实例方法在逻辑上就不太讲的通了，毕竟类和对象有别。\n", "\n", "为了解决上述问题，Python 设计了`super`专门指代父类，且通过`super`关键字可以实例化一个父类对象来调用父类中的方法。" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [], "source": [ "class Student(Human):\n", " \n", " def __init__(self, name, age, score):\n", " super(Student, self).__init__(name, age) # 通过 super 实例化一个父类对象，调用父类的构造函数\n", " self.__score = score\n", " \n", " def do_homework(self):\n", " print('I am doing homework!')\n", " \n", " def get_score(self):\n", " return self.__score\n" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "I am Li Lei and 20 years old. I scored 30 points.\n" ] } ], "source": [ "li_lei = Student('Li Lei', 20, 30)\n", "\n", "print('I am %s and %s years old. I scored %s points.' % (li_lei.get_name(), li_lei.get_age(), li_lei.get_score()))" ] } ], "metadata": { "hide_input": false, "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.6.9" }, "toc": { "base_numbering": 1, "nav_menu": {}, "number_sections": true, "sideBar": true, "skip_h1_title": false, "title_cell": "Table of Contents", "title_sidebar": "Contents", "toc_cell": false, "toc_position": {}, "toc_section_display": true, "toc_window_display": false }, "varInspector": { "cols": { "lenName": 16, "lenType": 16, "lenVar": 40 }, "kernels_config": { "python": { "delete_cmd_postfix": "", "delete_cmd_prefix": "del ", "library": "var_list.py", "varRefreshCmd": "print(var_dic_list())" }, "r": { "delete_cmd_postfix": ") ", "delete_cmd_prefix": "rm(", "library": "var_list.r", "varRefreshCmd": "cat(var_dic_list()) " } }, "types_to_exclude": [ "module", "function", "builtin_function_or_method", "instance", "_Feature" ], "window_display": false } }, "nbformat": 4, "nbformat_minor": 2 }