👏作者简介：大家好，我是爱敲代码的小王，CSDN博客博主,Python小白
📕系列专栏：python入门到实战、Python爬虫开发、Python办公自动化、Python数据分析、Python前后端开发
📧如果文章知识点有错误的地方，请指正！和大家一起学习，一起进步👀
🔥如果感觉博主的文章还不错的话，请👍三连支持👍一下博主哦
🍂博主正在努力完成2023计划中：以梦为马，扬帆起航，2023追梦人
🔥🔥🔥 python入门到实战专栏：从入门到实战
🔥🔥🔥 Python爬虫开发专栏：从入门到实战
🔥🔥🔥 Python办公自动化专栏：从入门到实战
🔥🔥🔥 Python数据分析专栏：从入门到实战
🔥🔥🔥 Python前后端开发专栏：从入门到实战
目录
私有属性和私有方法(实现封装)
Python对于类的成员没有严格的访问控制限制，这与其他面向对象语言有区别。关于私有属性和私有方法，有如下要点：
1 通常我们约定，两个下划线开头的属性是私有的(private)。其他为公共的(public)。
2 类内部可以访问私有属性(方法)
3 类外部不能直接访问私有属性(方法)
4 类外部可以通过 _类名__私有属性(方法)名 ”访问私有属性(方法)
⚠️【注】方法本质上也是属性！只不过是可以通过()执行而已。 所以，此处讲的私有属性和公有属性，也同时讲解了私有方法 和公有方法的用法。 如下测试中，同时也包含了私有方法和公有方法的例子。
【测试】私有属性和公有属性使用测试
#测试私有属性、私有方法
class Employee:
__company = "小王程序员" #私有.通过dir查到_Employee__company
def __init__(self,name,age):
self.name = name
self.__age = age #私有实例属性
def say_company(self):
print("我的公司是：",Employee.__company) #类内部可以直接访问私有属性
print(self.name,"的年龄是：",self.__age)
self.__work()
def __work(self): #私有实例方法，通过dir可查到_Employee__work
print("工作！好好工作，好好赚钱，娶个媳妇！")
p1 = Employee("小王",32)
print(p1.name)
print(dir(p1)) #
p1.say_company()
print(p1._Employee__age) #通过这种方式可以直接访问到私有属性 。通过dir可以查到属性：
_Employee__age
#print(p1.__age) #直接访问私有属性，报错
#p1.__sleep() #直接访问私有方法，报错执行结果：
小王
['_Person__age', '_Person__leg_num',
'_Person__sleep', '__class__', '__delattr__',
'__dict__', '__dir__', '__doc__', '__eq__',
'__format__', '__ge__', '__getattribute__',
'__gt__', '__hash__', '__init__',
'__init_subclass__', '__le__', '__lt__',
'__module__', '__ne__', '__new__',
'__reduce__', '__reduce_ex__', '__repr__',
'__setattr__', '__sizeof__', '__str__',
'__subclasshook__', '__weakref__', 'name','say_age']
腿的数目： 2
小王 的年龄是： 18
睡觉
18
从打印的 Person 对象所有属性我们可以看出。私有属性 __age 在实 际存储时是按照 _Person__age 这个属性来存储的。这也就是为什么 我们不能直接使用 __age 而可以使用 _Person__age 的根本原因。
@property 装饰器
@property 可以将一个方法的调用方式变成“属性调用”。
@property 主要用于帮助我们处理属性的读操作、写操作。
对于某一个 属性，我们可以直接通过：
emp1.salary = 30000
如上的操作读操作、写操作。但是，这种做法不安全。比如，我需要限制薪水必须为 1-10000 的数字。这时候，我们就需要通过使用装饰器 @property 来处理。
#测试@property
class Employee:
def __init__(self,name,salary):
self.name = name
self.__salary = salary
@property #相当于salary属性的getter方法
def salary(self):
print("月薪为{0},年薪为{1}".format(self.__salary,(12*self.__salary)))
return self.__salary;
@salary.setter
def salary(self,salary): #相当于salary属性的setter方法
if(0<salary<1000000):
self.__salary = salary
else:
print("薪水录入错误！只能在0-1000000之间")
emp1 = Employee("小王",100)
print(emp1.salary)
emp1.salary = -200
运行结果：
月薪为100,年薪为1200
100
月薪为100,年薪为1200
100
薪水录入错误！只能在0-1000000之间
属性和方法命名总结
1、_xxx ：保护成员，不能用 from module import * 导入，只有类对象和子类对象能访问这些成员。 （⚠️讲完模块再看）
2 、__xxx__ ：系统定义的特殊成员
3、__xxx ： 类中的私有成员，只有类对象自己能访问，子类对象也不能访问。（但，在类外部可以通过 对象名. _类名__xxx 这种特殊方式访问。Python不存在严格意义的私有成员）
⚠️再次强调，方法和属性都遵循上面的规则。
类编码风格
1 类名首字母大写，多个单词之间采用驼峰原则。
2 实例名、模块名采用小写，多个单词之间采用下划线隔开
3 每个类，应紧跟“文档字符串”，说明这个类的作用 可以用空行组织代码，但不能滥用。在类中，使用一个空行隔开方法；模块中，使用两个空行隔开多个类
关于None和判断的总结
None是什么？
1 与C和JAVA不同，python中是没有 NULL 的，取而代之的是 None 。
2 None 是一个特殊的常量，表示变量没有指向任何对象。
3 在Python中， None 本身实际上也是对象，有自己的类型 NoneType 。
4 你可以将 None 赋值给任何变量，但我们不能创建 NoneType 类型的对象
obj = None
obj2 = None
print(type(None))
print(id(None))
print(id(obj))
print(id(obj2))执行结果：
<class 'NoneType'> 140717958924280 140717958924280 140717958924280
⚠️None不是False，None不是0，None不是空字符串。None和任何其他的数据类型比较永远返回False。
None和其他类型的比较
- None和其他任何类型比较都会返回False
a = None
if a is None and a==None:
print("a是None") #会执行
if a==False or a==0:
print("None不等于False") #不会被打印
- 空列表、空字符串、0之间的比较
1 、if语句判断时,空列表[]、空字典{}、空元组()、0等一系列代表空和无的对象会被转换成False
a=[];b=();c={};d="";e=0;f=None
if (not a) and (not b) and (not c) and (not d) and (not e) and (not f):
print("if判断时，空列表[]、空字符串、0、None等代表空和无的对象会被转换成False")2、 == 和 is 判断时，空列表、空字符串不会自动转成 False
a=[];b=();c={};d="";e=0;
if (a==False or d==False):
print("==时，空列表、空字符串不是False！") #不会执行
if(e==False):
print("==时，0会转成False")面向对象三大特征介绍
Python是面向对象的语言，支持面向对象编程的三大特性：继承、 封装（隐藏）、多态。
封装（隐藏）
隐藏对象的属性和实现细节，只对外提供必要的方法。相当于将“细节封装起来”，只对外暴露“相关调用方法”。 通过前面学习的“私有属性、私有方法”的方式，实现“封装”。 Python追求简洁的语法，没有严格的语法级别的“访问控制符”，更多的是依靠程序员自觉实现。
继承
继承可以让子类具有父类的特性，提高了代码的重用性。 从设计上是一种增量进化，原有父类设计不变的情况下，可以增加新的功能，或者改进已有的算法。
多态
多态是指同一个方法调用由于对象不同会产生不同的行为。生 活中这样的例子比比皆是：同样是休息方法，人不同休息方法不同。张三休息是睡觉，李四休息是玩游戏，程序员休息是“敲 几行代码”。
继承
子类扩展父类
继承是面向对象编程的三大特征之一。继承让我们更加容易实现类的扩展。实现代码的重用，不用再重新发明轮子(don’t reinvent wheels)。
如果一个新类继承自一个设计好的类，就直接具备了已有类的特征，就大大降低了工作难度。已有的类，我们称为“父类或者基类”，新的类，我们称为“子类或者派生类”。
语法格式
Python支持多重继承，一个子类可以继承多个父类。继承的语法格式如下：
class 子类类名(父类1[，父类2，...])：
类体如果在类定义中没有指定父类，则默认父类是 object类 。也就是 说， object 是所有类的父类，里面定义了一些所有类共有的默认
实现，比如： __new__()
关于构造函数：
1、 子类不重写 __init__ ，实例化子类时，会自动调用父类定义的 __init__ 。
2、 子类重写了 __init__ 时，实例化子类，就不会调用父类已经定义的 __init__
3、如果重写了 __init__ 时，要使用父类的构造方法，可以使用 super 关键字，也可以使用如下格式 调用：
父类名.__init__(self, 参数列表)
class Person:
def __init__(self,name,age):
print("Person的构造方法")
self.name = name
self.age = age
def say_age(self):
print(self.name,"的年龄是：",self.age)
class Student(Person):
def __init__(self,name,age,score):
# 子类并不会自动调用父类的__init__()，我们必须显式的调用它。
# Person.__init__(self, name, age)
#super(Student,self).__init__(name,age)
print("Student的构造方法")
# self.name = name
# self.age = age
self.score = score
s1 = Student("张三",15,85)
#s1.say_age()
print(dir(s1))运行结果：
张三 的年龄是： 15
['_Person__age', '__class__', '__delattr__',
'__dict__', '__dir__', '__doc__', '__eq__',
'__format__', '__ge__', '__getattribute__',
'__gt__', '__hash__', '__init__',
'__init_subclass__', '__le__', '__lt__',
'__module__', '__ne__', '__new__',
'__reduce__', '__reduce_ex__', '__repr__',
'__setattr__', '__sizeof__', '__str__',
'__subclasshook__', '__weakref__', 'name',
'say_age', 'score']类成员的继承和重写
1、 成员继承：子类继承了父类除构造方法之外的所有成员。
⚠️(私有属性、私有方法也被继承)
2、 方法重写：子类可以重新定义父类中的方法，这样就会覆盖父类的方法，也称为“重写”
【操作】继承和重写的案例
class Person:
def __init__(self,name,age):
self.name = name
self.age = age
def say_age(self):
print(self.name,"的年龄是：",self.age)
def say_name(self):
print("我是",self.name)
class Student(Person):
def __init__(self,name,age,score):
Person.__init__(self,name,age)
self.score = score
def say_score(self):
print(self.name,"的分数是：",self.score)
def say_name(self): #重写父类的方法
print("报告老师，我是",self.name)
s1 = Student("张三",15,85)
s1.say_score()
s1.say_name()
s1.say_age()执行结果：
张三 的分数是： 85
报告老师，我是 张三
张三 的年龄是： 15
查看类的继承层次结构
通过类的方法 mro() 或者类的属性 __mro__ 可以输出这个类的继承层次结构。
【操作】 查看类的继承层次结构
class A:pass
class B(A):pass
class C(B):pass
print(C.mro())执行结果：
[<class '__main__.C'>, <class '__main__.B'>,
<class '__main__.A'>, <class 'object'>]