TensorFlow2 Part2：基础知识回顾

python面向对象编程回顾

基础概念：
- 面向对象的编程简称OOP，它把对象作为程序的基本单元，一个对象包含了数据和操作数据的函数。
- 面向对象的设计思想是抽象出Class，根据Class(类)创建Instance(实例对象)，这也是面向对象的最重要的概念。类是抽象出来的模板，而实例是根据模板创建出来的一个个具体的“对象”，每个对象都有相同的方法，但是各自的数据可能不同。
- python中所有的数据类型都可以看作是类，同时也可以自定义一个Class
- 面向对象的抽象程度又比函数要高，因为一个Class既包含数据，又包含操作数据的方法。
- 面向对象的程序设计把计算机程序视为一组对象的集合，而每个对象都可以接收其他对象发过来的消息，并处理这些消息，计算机程序的执行就是一系列消息在各个对象之间传递。
- 数据封装、继承和多态是面向对象的三大特点
类的定义：

//定义类的一般形式

class Student(object):

	<statement 1>

	...

	<statement n >

//class声明这是一个类，类名一般都用大写字母开头，括号里面表示该类从哪里继承来的（父类），如果没有

合适的继承类，就使用object类，这是所有类最终都会继承的类。缩进语句块里面用来声明该类的各种数据和

functions

//实例代码

>>> class Student(object):

... Readline internal error

Traceback (most recent call last):

...

    ^

IndentationError: expected an indented block	//报错？缩进用个Tab不行吗？

>>> class Student(object):

...  pass										//要一个空格缩进？

...

创建类的实例

>>> Student()							//通过类名+()就创建出了一个类实例对象

<__main__.Student object at 0x0000024713B0AF60>

>>> instance = Student()

>>> instance							//可以发现它是一个Student 类的 object

<__main__.Student object at 0x0000024713B0AE10>

>>> Student								//但Student才并且仍是Student类

<class '__main__.Student'>

属性

>>> instance.name = 'yo'		//此时我们就可以给实例变量自由的添加属性

>>> instance.name				//但是添加的属性不会对类产生任何影响

'yo'

//但是我们可以在创建类的时候，提前定义好一些该类的每一个实例对象都该拥有的属性。

//通过定义一个特殊的__init__方法，在创建实例的时候，把name，age等属性绑上去：

>>> class Student(object):

...  def __init__(self,name,age):

...   self.name = name

...   self.age = age			//我python的缩进是不是弄错了。。

...

//进入虚拟环境再用python缩进就正常了，代码好看多了。

>>> class Student(object):

...     def __init__(self,name,age): //__init__方法的第一个参数永远是self，表示创建的实例本身

...             self.name = name	 //下面的就表示类自身（Student）的一些属性

...             self.age = age

...

>>> instance = Student()			//重新定义的类如果还不传参数就会报错

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

TypeError: __init__() missing 2 required positional arguments: 'name' and 'age'

>>> instance = Student(name='ocean',age=19）	//实例化的时候self不需要传入

>>> instance = Student('ocean',19)				//传入参数的方法和用函数一样，有多种方式

>>> instance.name

'ocean'

>>> instance.age

19

>>> instance.score = 99.9			//此时，除了必须的，同样可以添加“个性化属性"

>>> class Student(object):

...     def __init__(self):	// __init__() 特殊方法（构造方法），该方法在类实例化时会自动调用

...             print(666)

...

>>> yo = Student()

666

>>> class Student(object):

...     def __init__(self):

...             print(self)		//一直不知道这个self表示的是什么，不如看看。

...

>>> yo = Student()

<__main__.Student object at 0x000001E1E2C9F188>

>>> Student						//可以看出，self表示的是类实例化后的yo，而不是Student类

<class '__main__.Student'>

OMG，我居然也可以，温柔。 --19.8.17

数据封装

//在Student类的内部定义访问数据的函数，这样，就把“数据”给封装起来了。

//这些封装数据的函数是和Student类本身是关联起来的，我们称之为类的方法：

>>> class Student(object):

...     def __init__(self,name,age):

...             self.name = name

...             self.age = age

...     def print(self,score):			//封装数据的函数，self是必要的一个参数！

...             print("name:%s age:%s"%(self.name,self.age))

...             print("score = %s"%(score))

...

>>> instance = Student('ocean',19)

>>> instance.print(99.9)

name:ocean age:19

score = 99.9

//事实上，封装做的就是在类的内部定义函数，从而能够在类的内部对数据进行

处理，我们在外部只需要传入必要的参数，类在内部加工数据，传出我们想要的

结果，而不需要再外部设置函数如此以来使得类变得powerful

继承

//在定义一个class的时候，我们可以从现有的某个已经存在了的类继承，被继承的类被称为父类或者基类（还

是很形象的），产生新的class被称为子类。（之前一直用的object被称为根类）

//上代码

>>> class Animal():

...     def printf(self):

...             print("This is a Animal")

...

>>> ins0 = Animal()

>>> ins0.printf()

This is a Animal

>>> class Dog(Animal):				//定义一个Dog类，继承自Animal类

...     pass

...

>>> ins1 = Dog()

>>> ins1.printf()							//调用继承自父类方法，看来只是原封不动的搬了过来

This is a Animal

>>> class Cat(Animal):				//定义一个 Cat 类，继承自Animal类

...     def printf(self):			//在子类中重写printf()方法

...             print("This is a cat.")

...

>>> ins2 = Cat()

>>> ins2.printf()			//调用继承自父类方法，可以发现子类重写的方法成功的将原方法覆盖掉

This is a cat.

调用父类构造函数

//上代码

>>> class Student():

...     def __init__(self,age):

...             self.age = age

...             print(age)

...

>>> yo = Student(19)

19

>>> class Colleage_stu(Student):

...     def __init__(self,age,score):

...             print(age)

...             print(score)

...

>>> ocean = Colleage_stu(19,99)		//成功的覆盖掉了构造方法（__init__）

19

99

>>> class Colleage_stu(Student):

...     def __init__(self,age,score):

...             Student.__init__(self,age)		//继承Student类的self和age方法

...             self.score = score				//添加

自己的方法score

...             print(score)

...

>>> ocean = Colleage_stu(19,99)					//成功习得自己的方法score

19

99

>>> class Colleage_stu(Student):

...     def __init__(self,age,score):

...             print(score)

...             Student.__init__(self,age)

...             print(age)

...

>>> ocean = Colleage_stu(19,99)					//基本上可以为所欲为

99

19

19

>>> class Colleage_stu(Student):

...     def __init__(self,age,score):

...             Student.__init__(self,age,score)	//只要不缺心眼的继承一个父类没有的属性

...             print(score)

...

>>> ocean = Colleage_stu(19,99)

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

  File "<stdin>", line 3, in __init__

TypeError: __init__() takes 2 positional arguments but 3 were given

多继承

//所谓多继承，就是继承自多个父类白，啧啧啧~

>>> class Teacher():

...     def __init__(self,class):		//敲了好几遍才意识到这个class还不能用。讲究~

  File "<stdin>", line 2

    def __init__(self,class):

                          ^

SyntaxError: invalid syntax

>>> class Teacher():

...     def __init__(self,grade):			//换了grade就ok了

...             print(grade)

...

>>> class Student():

...     def __init__(self,age):

...             print(age)

...

>>> stu = Student(19)

19

>>> tec = Teacher(10)						//验证了一下没毛病

>>> class School(Teacher,Student):

...     def __init__(self,grade,age,name):

...             print(name)

...             Student.__init__(self,age)

...             print(age*10)

...             Teacher.__init__(self,grade)

...             print(grade*10)

...

>>> Tsinghua = School(10,19,"ocean")			//还是只要别继承父类没有的属性就可以为所欲为

ocean

19

190

10

100

多态

//上代码

>>> type(Cat)

<class 'type'>

>>> type(ins2)

<class '__main__.Cat'>			//ins2是Cat类型的数据

>>> type(ins0)

<class '__main__.Animal'>		//ins0是Animal类型的数据

>>> isinstance(ins2,Cat)			//ins2属于Cat类，of course

True

>>> isinstance(ins0,Animal)			//ins0属于Animal类，of course

True

>>> isinstance(ins2,Animal)			//ins2同样属于Animal类！它继承自父类。

True								//这就是所谓的多态

多态的好处

>>> def run_twice(animal):	//此函数接受一个Animal类型的变量

...     animal.printf()

...     animal.printf()

...

>>> run_twice(Animal())			//运行成功，但是为什么定义的时候接受的类名是小写？

This is a Animal

This is a Animal

>>> def run_twice(Animal):		//大写是可以的

...     Animal.printf()

...     Animal.printf()

...

>>> run_twice(Animal())

This is a Animal

This is a Animal

>>> run_twice(Dog())		//我们定义的时候没有定义Dog类，但是他是继承自Animal的，具有多态

This is a Animal

This is a Animal

>>> run_twice(Cat())

This is a cat.

This is a cat.

//由于Animal类型有run()方法，因此，传入的任意类型，只要是Animal类或者子类，就会自动调用实际类型的

run()方法，这就是多态的意思：

//对于一个变量，我们只需要知道它的父类，而不需要确切的知道子类的内部结果，就可以通过调用父类的方法

来调用子类的相对应的方法。

//这就是多态真正的威力：调用方只管调用，不管细节，而当我们新增一种Animal的子类时，只要确保run()方

法编写正确，不用管原来的代码是如何调用的。

Questions：

>>> class Animal():

...     def printf(self):

...             print("This is a animal.")

...

>>> class Dog(Animal):

...     pass

...

>>> class Cat(Animal):

...     def printf(self):

...             print("This is a cat.")

...

>>> def run(Cat):

...     Cat.printf()

...

>>> run(Cat())

This is a cat.

>>> run(Animal())

This is a animal.

>>> run(Dog())			//我都凌乱了，run函数定义的是Cat类，怎么会和Dog类还有父类产生关系？

This is a animal.

>>> ins0 = Animal()

>>> ins2 = Cat()

>>> isinstance(ins0,Cat)

False

python super()函数回顾

super() 函数是用于调用父类(超类)的一个方法。（多继承问题）

对实例类进行调用

巴特西

TensorFlow2 Part2：基础知识回顾

最新文章

热门文章