8.类的概念、定义、属性、继承

8.类的概念、定义、属性、继承
1.⾯向对象(Object Oriented,OO)概念
⾯向对象，是我们编程的⼀种思维。

早期的计算机编程是基于⾯向过程的⽅法，例如实现算术运算1+1+2 = 4，通过设计⼀个算法就可以解决当时的问题。

随着计算机技术的不断提⾼，计算机被⽤于解决越来越复杂的问题。

通过⾯向对象的⽅式，将现实世界的事物抽象成对象，现实世界中的关系抽象成类、继承。

通过⾯向对象的⽅法，更利于⽤⼈理解的⽅式，对复杂系统进⾏分析、设计与编程。

同时也提⾼了系统的可维护性，可扩展性，可重⽤性。

（就是使编程的思维，更接近与⼈的思维和认知）
⾯向对象编程的关键，就是类的定义。

类是对现实⽣活中⼀类具有共同特征的事物的抽象。

2.类的定义
基本形式：
class ClassName(object):
Statement
1.class定义类的关键字
2.ClassName类名，类名的每个单词的⾸字母⼤写（驼峰规则）。

3.object是⽗类名，object是⼀切类的基类。

在python3中如果继承类是基类可以省略不写。

'''
重点：学会定义类，了解属性和⽅法，类的初始化和实例化。

定义类时，这种⽅法可以使类对象实例按某种特定的模式⽣产出来。

'''
#类⽅法：
'''
后⾯的参数中第⼀个参数我们约定俗成的为self参数名，
self代表的是在类实例化后这个实例对象本⾝。

初始化函数除了有self这个参数表⽰实例对象本⾝之外，
其他的参数的定义也遵循函数的必备参数和默认参数⼀样的原则，
必备参数就是在实例化是⼀定要传⼊的参数，
默认参数就是在定义时可以给这个参数⼀个初始值。

没有函数名的函数
'''
3.类的实例化
基本形式：实例对象名 = 类名（参数）
在实例化的过程中，self代表的就是这个实例对象⾃⼰。

实例化时会把类名后⾯接的参数传进去赋值给实例，
这样传进去的参数就成为了这个实例对象的属性。

实例化的过程遵循函数调⽤的原则。

在实例化时也必须个数和顺序与定义时相同（使⽤关键字参数可以改变传参的顺序）。

当初始化函数定义时使⽤了默认参数时，在实例化时默认参数可以不传参这时
这个实例对象就会使⽤默认的属性，如果传了参数进去则会改变这参数值，
使实例化对象的属性就为你传进来的这个参数。

isinstance(实例名，类名)
判断⼀个实例是不是这个类的实例。

#类类是对现实⽣活中，具有共同特征的事物的抽象。

class Animal(object):
pass
# object, 基类。

任何类都需要继承object
# 类 (模⼦)
class Animal: #python3 继承object，可写可不写
pass
dog = Animal() #⽣成⼀个实例 dog
cat = Animal() #⽣成实例cat
##构造⽅法 __init__() , self 参数
class Animal:
def__init__(self): # 构造⽅法,实例化对象时，必须要调⽤__init__
print('正在实例化⼀个类')
def test(self):
print('aaa')
#当我们没有写__init__() ,默认调⽤我们⽗类__init__
class Animal:
def test(self):
print('aaa')
###self, 实例化对象（本⾝）
#self 可以替换成别的参数名。

但是最好别改
class TestSelf: #⽅法：testSelf ⽅法的⾸字母⼩写类: TestSelf 类的⾸字母⼀般⼤写驼峰命名规则
def__init__(self): #在初始化的时候，默认往构造⽅法，传⼊⼀个值
print('正在实例化')
def test(self):
print('bbb')
def test2():
print('ccc')
4.类和实例的属性
类属性
.类属性是可以直接通过“类名.属性名”来访问和修改。

.类属性是这个类的所有实例对象所共有的属性，
任意⼀个实例对象都可以访问并修改这个属性（私有隐藏除外）。

.对类属性的修改，遵循基本数据类型的特性：列表可以直接修改，字符串不可以，
所以当类属性是⼀个列表时，通过任意⼀个实例对象对其进⾏修改。

但字符串类型的类属性不能通过实例对象对其进⾏修改。

当实例对不可变对象进⾏修改之后，会查找实例的类属性，不会查找类的属性，同时类的属性不会边
实例属性
.在属性前⾯加了self标识的属性为实例的属性。

.在定义的时候⽤的self加属性名字的形式，在查看实例的属性时
就是通过实例的名称+‘.’+属性名来访问实例属性。

⼀些说明：
.⼀般，⽅法第⼀个参数被命名为self,，这仅仅是⼀个约定，
self没有特殊含义，程序员遵循这个约定。

.查看类中的属性和实例属性可以调⽤__dict__⽅法返回属性组成的字典。

.Python中属性的获取是按照从下到上的顺序来查找属性
.Python中的类和实例是两个完全独⽴的对象
.Python中的属性设置是针对对象本⾝进⾏的
####属性，属性本质上就⼀个变量
'''
1.实例化属性
2.类属性（共有属性）
'''
# 1.实例化属性 ,
class Animal:
def__init__(self,name,food): #⾃⼰独有的，就放到实例化⾥⾯
print('正在实例化')
= name # 实例化属性：每个实例可能不同，但是都有
self.food = food
def get_name(self):
print()
#2.类属性（共有属性）
class Animal:
eye = 2
leg = 4 #共有的
def__init__(self,name,food):
print('正在实例化')
= name
self.food = food
def get_name(self):
print()
5.类的私有属性和⽅法
在Python中，通过单下划线”_”来实现模块级别的私有化，⼀般约定以单下划线”_”开头的变量、函数为模块私有的，也就是说”from moduleName import *”将不会引⼊以单下划线”_”开头的变量、函数对于Python中的类属性，可以通过双下划线”__”来实现⼀定程度的私有化。

_”和” __”的使⽤更多的是⼀种规范/约定，不没有真正达到限制的⽬的：
“_”：以单下划线开头只能允许其本⾝与⼦类进⾏访问，(起到⼀个保护的作⽤)
“__”：双下划线的表⽰的是私有类型的变量。

这类属性在运⾏时属性名会加上单下划线和类名。

“__foo__”：以双下划线开头和结尾的（__foo__）代表python⾥特殊⽅法专⽤的标识，如__init__（）
'''
在Python中，通过单下划线”_”来实现模块级别的私有化，
⼀般约定以单下划线”_”开头的变量、函数为模块私有的，
也就是说”from moduleName import *”
将不会引⼊以单下划线”_”开头的变量、函数
'''
import random #全部会导⼊
from random import* #_Set 不会倒⼊
class Animal:
_eye = 2
__leg = 4 #共有的
def__init__(self,name,food):
print('正在实例化')
= name
self.food = food
def get_name(self):
print()
#_”和” __”的使⽤更多的是⼀种规范/约定，并没有真正达到限制的⽬的：
dog._eye = 3
#dog._Animal__leg ##__ 默认加⼀个类名，⽤来警告
# “__foo__”：以双下划线开头和结尾的（__foo__）
#代表python⾥特殊⽅法专⽤的标识，如 __init__（）
6.数据封装
在类⾥⾯数据属性和⾏为函数的形式封装起来，
访问时直接调⽤，不需知道类⾥⾯具体的实现⽅法。

⽐如，list.append
7.继承
⽤法：
.在定义类时，可以从已有的类继承，
被继承的类称为基类（⽗类），新定义的类称为派⽣类（⼦类）。

.在类中找不到调⽤的属性时就搜索基类，
如果基类是从别的类派⽣⽽来，这个规则会递归的应⽤上去。

反过来不⾏。

.如果派⽣类中的属性与基类属性重名，那么派⽣类的属性会覆盖掉基类的属性。

包括初始化函数。

.派⽣类在初始化函数中需要继承和修改初始化过程，
使⽤’类名+__init__(arg)’来实现继承和私有特性,也可以使⽤super()函数。

issubclass(类名1，类名2)
判断类1是否继承了类2
作⽤：
⾯向对象的编程带来的主要好处之⼀是代码的重⽤，实现这种重⽤的⽅法之⼀是通过继承机制。

继承完全可以理解成类之间的类型和⼦类型关系。

⼦类在重写⽗类⽅法之后，如果要继承⽗类⽅法中的功能，要先调⽤⽗类的⽅法class.fun(self) 8.多态
当派⽣类重写了基类的⽅法时就实现了多态性。

(⼦类重写⽗类⽅法)
## ⾯向对象三个特征：封装，继承多态
# 封装
class Animal:
eye = 2
leg = 4 #共有的
def__init__(self,name,food):
print('正在实例化')
= name
self.food = food
def get_name(self):
print()
def get_food(self):
print(self.food)
# 继承
#⾯向对象的编程带来的主要好处之⼀是代码的重⽤
class People(Animal):
leg = 2
def__init__(self,name,food,sex):
= name
self.food = food
self.sex = sex
def get_sex(self):
print(self.sex)
def speak(self):
print('asdsdgfsagg')
def eat(self):
print('果⼦')
#多态, (⼦类重写⽗类⽅法) ,继承。

（同⼀个⽅法，有不同表形式）
class Chinse(People):
def speak(self):
print('你好')
def eat(self):
print('⽶饭')
class America(People):
def speak(self):
print('hello')
def eat(self):
print('⾯包')
class Thai(People):
def speak(self):
print('萨⽡迪卡')
def eat(self):
print('⾹蕉')
xiaoMing = Chinse('⼩明','⽶饭','男')
jeck = America('jeck','⾯包','男')
lala = Thai('lala','⾹蕉','未知')
'''
总结：
1.类的定义
2.__init__() 构造⽅法
3.self 参数。

实例对象本⾝
4.类属性（共有属性），实例化属性
5._ __ python 类的私有化。

6. ⾯向对象三⼤特征：封装继承多态
'''
9.作业
1.定义⼀个矩形的类：
要求：1.有长和宽的属性
2.有⼀个计算⾯积的⽅法
class Rectangle:
def__init__(self,length,width): #构造⽅法
if isinstance(length,(int,float)) and isinstance(width,(int,float)): self.length = length
self.width = width
def area(self):
return self.length * self.width
##isinstance
#如何判断self就是实例化对象
##class test(object):
## def __init__(self):
## if isinstance(self,test): #True
## print('⽼铁我真的是的')
## else:
## print('no')
##
## def isin(self):
## print(type(self))
## print(type(test)) #元类 metaclass
## if type(self) == type(test): #False
## print('⽼铁我还是得')
##
## else:
## print('扎⼼了')
View Code
2.写⼀个正⽅形的类，继承矩形类
要求：有⼀个判断是不是正⽅形的⽅法
class Square(Rectangle):
def judgement(self):
if self.length == self.width:
return'It is square'
else:
return'It is not square'
View Code。