6-1 面向过程与面向对象
1. 面向过程
面向过程，核心在过程二字，面向过程设计思维，就好比精心设计一条流水线，考虑周全，相应时候处理相应问题。
优点：将复杂问题流程化，进而简单化。
缺点：扩展性差。若更改需求，可能整个代码都需要重写，牵一发而动全身。
若解决不需要经常迭代更新的程序时，面向过程是比较好的，当解决需要频繁迭代更新维护的，使用面向对象比较好。
2. 面向对象
面向对象，是对现实世界的模拟。
面向对象编程的特点：可以编写表示真实世界中事务和情景的类，并基于这些类来创建对象。这可以使程序的维护和扩展变得简单，可大大提高开发效率。
面向对象三大特点：
封装性：使对象的特征与行为保存起来。
继承性：通过继承，子类可快速获取父类的特征与行为。
多态性：不同的子类对象，调用相同的父类方法，产生不同的执行结果。
6-2 创建一个简单的类
类：是描述具有相同特征和行为的对象的集合。格式如下
class 类名():
变量 #刻画类的特征
def 相关方法(self, 相关参数): #描述类的行为
pass
定义一个简单类：
class Man():
gender = 'male'
avg_height = 1.7
def think(self): #实例方法
print('thinking')
def sleep(self):
prnt('sleeping')
6-3 self 与实例方法
1. 实例方法
man = Man() #实例化一个对象
2. self
self名称是约定成俗的(虽然也可以传其它名字字符串)；self是指向类实例化的对象本身；self只会在类的方法中才会有，函数是不必带有self的；self在定义类的方法(实例方法)时是必须的；self在调用时不必传入相应的参数，python会为我们自动传入。
例子：
class Man():
gender = 'male'
avg_height = 1.7
def think(self):
print('thinking')
def sleep(self):
print('sleeping')
man = Man()
man.sleep()
print(man.gender)
-----------------------
sleeping
male
6-4 __init__ 构造函数
使用构造函数，可以让模板生成不同特征的对象。
构造函数格式：
def __init__(self):
pass
例子：
class Man():
gender = 'male' #类变量（描述类的通俗特征，只与类有关）######
avg_height = 1.7
def __init__(self, name, age):
print('this is __init__()')
self.name = name #实例变量（保存对象的具体特征）
self.age = age #成员变量也不需要事先定义
def think(self):
print('thinking')
def sleep(self):
print('sleeping')
man = Man('xiaohei', 18)
man.sleep()
print(man.gender)
print(man.name)
print(man.age)
-----------------------
this is __init__()
sleeping
male
xiaohei
18
查看对象：
man.__dict__ #{'name': 'xiaohei', 'age': 18} 查看对象，对象以字典的形式展示，只显示实例变量，不显示类变量
Man.__dict__ #类也可以使用 __dict__方法，会展示很多东西
6-5 通过实例方法访问实例变量与类变量
例子
class Man():
gender = 'male'
avg_height = 1.7
def __init__(self, name, age):
print('this is __init__()')
self.name = name
self.age = age
def think(self):
print('thinking')
def sleep(self):
print('sleeping')
def find(self):
print('this is ' + str(self.name)) #访问实例变量
print(self.__class__.gender) #访问类变量，法一
print(Man.gender) #访问类变量，法二
print(self.gender) #访问类变量，法三 它会先在构造方法中找，若找不到向上找
man = Man('xiaohei', 18)
man.sleep()
man.find()
print(man.name)
-----------------------
this is __init__()
sleeping
this is xiaohei
male
male
male
xiaohei
6-6 类方法
1. 开闭原则：对于扩展是开放的，对于修改是关闭的。
比如要将上面的 avg_height 改为 1.75
man.avg_height = 1.75 #相当于在构造函数中加了一个 self.avg_height = 1.75, 类的 avg_height 还是1.7
man.__dict__
-----------------------
{'name': 'xiaohei', 'age': 18, 'gender': 'renyao', 'avg_height': 1.75}
2. 可以使用类方法来操作类的特征
例子：
class Man():
gender = 'male'
avg_height = 1.7
def __init__(self, name, age):
print('this is __init__()')
self.name = name
self.age = age
def think(self):
print('thinking')
def sleep(self):
print('sleeping')
@classmethod #声明定义的是类方法
def modify_height(cls, height): #cls类似self，为了区分写成cls, 表示当前类，也不用传参
cls.avg_height += height
print('Now the avg_height is ' + str(cls.avg_height))
Man.modify_height(0.05)
Man.__dict__
-----------------------
Now the avg_height is 1.75
...
'avg_height': 1.75, #类属性已经改过来了
6-7 静态方法
静态方法与普通函数基本上没有什么区别。静态方法与类、对象没有太大关系的时候可以使用该方法。
例子：
class Man():
gender = 'male'
avg_height = 1.7
def __init__(self, name, age):
print('this is __init__()')
self.name = name
self.age = age
def think(self):
print('thinking')
def sleep(self):
print('sleeping')
@classmethod
def modify_height(cls, height): #cls类似self，为了区分写成cls, 表示当前类，也不用传参
cls.avg_height += height
print('Now the avg_height is ' + str(cls.avg_height))
@staticmethod #声明类的静态方法
def plus_num(x, y):
print(str(x) + ' + ' + str(y) + ' = ' + str(x+y)) #注意这个打印
return x+y
Man.plus_num(2, 3)
man = Man('xiaohei', 12)
man.plus_num(4, 5)
-----------------------
2 + 3 = 5
this is __init__()
4 + 5 = 9
9
6-8 成员可见性
public: 公开性，外部可以访问相关变量和方法
private：私有性，外部不可以访问相关变量和方法
设置成private的：成员变量或成员方法名前加'__'
例子：
class Man():
gender = 'male'
avg_height = 1.7
def __init__(self, name, age):
self.__name = name #私有成员变量__name
self.age = age
def __sleep(self): #私有方法
print('sleeping')
def get_message(self):
print('name= ' + self.__name) #私有成员变量还可以爱成员方法中访问
#__sleep() 加这个也报错，私有成员方法在成员方法内也无法访问吗？ TODO:
man = Man('xiaohei', 10)
# man.__name 私有变量，对外部不可见，包没有属性__name
# man.__sleep() 私有方法，对外部不可见
man.get_message()
-----------------------
name= xiaohei
6-9 python 没有什么是不能访问的
例子：
man.__dict__ #{'_Man__name': 'xiaohei', 'age': 10} 可以看到多出来了 _Man__name 成员变量，外部可以通过它来访问私有成员变量
man._Man__name #'xiaohei' 外部访问私有成员变量
man._Man__sleep() #sleeping 外部访问私有成员方法
python私有机制做的不是很好，但为了代码规范性，最好还是遵从，Python没有任何机制阻止你访问其私有成员变量和私有成员方法。
6-10 继承
例子：
class Man():
gender = 'male'
avg_height = 1.7
def __init__(self, name, age):
self.name = name
self.age = age
def think(self):
print('thinking')
def sleep(self):
print('sleeping')
class ChinesMan(Man): #继承，ChinesMan 继承 Man
pass
cman = ChinesMan('xiaobai', 24)
cman.think()
继承后重写成员函数：
class Man():
gender = 'male'
avg_height = 1.7
def __init__(self, name, age):
self.name = name
self.age = age
def think(self):
print('thinking')
def sleep(self):
print('sleeping')
class ChinesMan(Man):
def __init__(self, name, age, height):
self.name = name # 这两行也可以改为调用父类的，使用 Man.__init__(self, name, age); 调用父类方法需要手动传入self
self.age = age
self.height = height
def think(self): # 这里也可以通过 Man.think(self) 调用父类的think()
print(self.name + ' is thinking')
cman = ChinesMan('xiaobai', 24, 1.8)
cman.think()
-----------------------
xiaobai is thinking
cman.__dict__ # {'name': 'xiaobai', 'age': 24, 'height': 1.8} 可以看到类成员已经变化了
但是 类.构造方法 的调用格式来调用父类的构造方法并不好。其次若这样调用若父类名变了，子类都要进行修改。
6-11 super关键字调用父类方法
super 不仅可以调用父类的构造函数，也可以调用父类的成员方法，可以解决父类名变化带来的影响。
例子：
class Man():
gender = 'male'
avg_height = 1.7
def __init__(self, name, age):
self.name = name
self.age = age
def think(self):
print('thinking')
def sleep(self):
print('sleeping')
class ChinesMan(Man):
def __init__(self, name, age, height):
super(ChinesMan, self).__init__(name, age); # super(子类名, self).父类构造方法 调用父类构造方法
self.height = height
def think(self):
super(ChinesMan, self).think() #使用super后就不需要再传self参数了 调用父类成员函数
print(self.name + ' is thinking')
cman = ChinesMan('xiaobai', 24, 1.8)
cman.think()
-----------------------
thinking
xiaobai is thinking
注意：父类必须在子类前面定义，子类可继承一个或多个父类(那此时super调用的是哪个父类的？）
标签：__,name,Python,self,height,面向对象,print,def From： https://www.cnblogs.com/hellokitty2/p/17596566.html