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() 函数是用于调用父类(超类)的一个方法。(多继承问题)
- 对实例类进行调用