Python入门
Python开发工具的使用：Pycharm的配置使用
第一章：Python入门学习(一)Print函数、Input函数、基本数据类型、运算符、流程控制语句、循环语句
第二章：Python入门学习(二) 列表的增删改查
第三章：Python入门学习(三) 字典的增删改查
第四章：Python入门学习(四)元组与集合
第五章：Python入门学习(五)字符串的操作
第六章：Python入门学习(六)函数学习
第七章：Python入门学习(七)Python异常处理机制
第八章：Python入门学习(八)Python中的类和对象
第九章：Python入门学习(九)Python面向对象的三大特征封装、继承和多态
第十章：Python入门学习(十)Python模块化编程
第十一章：Python入门学习(十一)Python的IO操作
代码仓库地址：Python入门项目
面向对象的三大特征
封装
将数据（属性）和行为（方法）包装到类对象中，在方法内部对属性进行操作，在类对象的外部方法调用方法，这样无需关心方法内部的具体实现细节，从而隔离了复杂度。
在Python中没有专门的修饰符用于属性的私有，如果该属性不希望在类对象外部被访问，前面使用两个下划线。
继承
提高代码的复用性。
多态
提高程序的可扩展性和可维护性。
封装
# author: LiuShihao
# data: 2020/11/28 3:39 上午
# youknow: 各位老铁,我的这套代码曾经有人出价三个亿我没有卖,如今拿出来和大家分享,不求别的,只求大家免费的小红心帮忙点一点,这里谢过了。
# desc: 类的私有属性
class Student:
def __init__(self,name,age):
self.name = name
self.__age = age # 年龄不希望被外部使用 ，所以可以加上两个下划线
def show(self):
print(self.name,self.__age)
stu = Student('zs',20)
stu.show()
print(stu.name)
#print(stu.__age) # 报错 ：因为age被__修饰，所以外部无法访问，AttributeError: 'Student' object has no attribute '__age'
print(dir(stu))
# 但是可以通过 _Student__age 来访问
print(stu._Student__age) # 20
继承
class 子类类名（父类1，父类2...）:
pass
- 如果一个类没有继承任何类，则默认继承object。
- Python支持多继承。
- 定义子类时，必须在其构造函数中调用父类的构造函数。
# author: LiuShihao
# data: 2020/11/28 3:54 上午
# youknow: 各位老铁,我的这套代码曾经有人出价三个亿我没有卖,如今拿出来和大家分享,不求别的,只求大家免费的小红心帮忙点一点,这里谢过了。
# desc: 继承
# 定义父类
class Person(object): # 不写也默认继承object
def __init__(self,name,age):
self.name = name
self.age = age
def info(self):
print("姓名：{0},年龄：{1}岁".format(self.name,self.age))
# 定义子类学生类
class Student(Person):
def __init__(self,name,age,score): #在子类的构造函数中调用父类的构造函数
super().__init__(name,age)
self.score = score
# 定义子类老师类
class Teacher(Person):
def __init__(self,name,age,teachOfYear):
super().__init__(name,age)
self.teachOfYear = teachOfYear
stu = Student('zs',19,99)
tea = Teacher('ls',30,5)
print('------------')
stu.info()
tea.info()
print("子类学生类的属性_分数：",stu.score)
print("子类老师类的属性_教龄：",tea.teachOfYear)
print('------类的多继承------')
类的多继承
# 多继承
class A(object):
pass
class B(object):
pass
class C(A,B): # C类 继承了A和B两个类
pass
方法的重写
在父类中有info方法
但是如果子类觉得父类中的方法不合适，可以进行重写，方法名与父类中要重写的方法的方法名一样，使用super().方法名，就可以对父类的方法进行重写。
重写完之后会发现在父类的该方法前和子类重写的该方法前会有箭头指示。
# author: LiuShihao
# data: 2020/11/28 3:54 上午
# youknow: 各位老铁,我的这套代码曾经有人出价三个亿我没有卖,如今拿出来和大家分享,不求别的,只求大家免费的小红心帮忙点一点,这里谢过了。
# desc: 继承
# 定义父类
class Person(object): # 不写也默认继承object
def __init__(self,name,age):
self.name = name
self.age = age
def info(self):
print("姓名：{0},年龄：{1}岁".format(self.name,self.age))
# 定义子类学生类
class Student(Person):
def __init__(self,name,age,score): #在子类的构造函数中调用父类的构造函数
super().__init__(name,age)
self.score = score
def info(self): # 从写父类中的info方法，需要使用super().info
super().info()
print("学生类重写父类方法",self.score)
# 定义子类老师类
class Teacher(Person):
def __init__(self,name,age,teachOfYear):
super().__init__(name,age)
self.teachOfYear = teachOfYear
def info(self):
super().info()
print("老师类重写父类方法",self.teachOfYear)
stu = Student('zs',19,99)
tea = Teacher('ls',30,5)
print('------------')
stu.info()
tea.info()
print("子类学生类的属性_分数：",stu.score)
print("子类老师类的属性_教龄：",tea.teachOfYear)
object类
object类是所有类的父类，因此所有类都有object类的属性和方法。- 内置函数
dir()可以查看自己指定对象的所有属性 - object类有一个
__str__（）方法，用于返回一个对于”对象的描述“，对应于内置函数str()经常用于print()方法，帮我们查看对象的信息，所以我们经常会对__str__（）进行重写
# author: LiuShihao
# data: 2020/11/28 12:58 下午
# youknow: 各位老铁,我的这套代码曾经有人出价三个亿我没有卖,如今拿出来和大家分享,不求别的,只求大家免费的小红心帮忙点一点,这里谢过了。
# desc:
class Student:
def __init__(self,name,age):
self.name = name
self.age = age
def __str__(self):
return "名字：{0},年龄：{1}".format(self.name,self.age)
stu = Student('张三',20) # 内置函数dir()可以查看自己指定对象的所有属性
print(dir(stu))
print(stu) # 使用print(stu) 输出的该对象的内存地址
多态
简单地说：多态就是具有多种形态，它指的是：即便不知道一个变量所引用的对象到底是什么类型。仍然可以通过这个变量调用方法，在运行过程中根据变量所引用对象的类型，动态决定调用哪个对象中的方法。
# author: LiuShihao
# data: 2020/11/28 1:10 下午
# youknow: 各位老铁,我的这套代码曾经有人出价三个亿我没有卖,如今拿出来和大家分享,不求别的,只求大家免费的小红心帮忙点一点,这里谢过了。
# desc: 多态
# 定义Animal类 继承 object类
class Animal(object):
def eat(self):
print("动物要吃东西")
# 定义Dog类 继承 Animal类
class Dog(Animal):
def eat(self):
print("狗要吃骨头")
# 定义Cat类 继承 Animal类
class Cat(Animal):
def eat(self):
print("猫要吃鱼")
# 定义Person类 继承 object类
class Person(object):
def eat(self):
print("人吃五谷杂粮")
# 定义一个函数
def fun(obj):
obj.eat()
# 调用函数
fun(Animal())
fun(Dog())
fun(Cat())
fun(Person())
静态语言和动态语言关于多态的区别
静态语言实现多态的三个必要条件：
- 继承
- 方法重写
- 父类引用指向子类对象
动态语言的多态崇尚鸭子类型，当看到一只鸟走起来像鸭子、游泳起来像鸭子、收起来也像鸭子，那么这只鸟就可以被称为鸭子。在鸭子类型中，不需要关心对象是什么类型，到底是不是鸭子，只关心对象的行为。
特殊方法和特殊属性
dict（）方法
获得类对象或者类实例化对象的所有属性和方法的字典
len（）方法
add（）方法
new（）和__init__（）方法
__new__ 方法是创建对象；
__init__方法是对创建的对象进行初始化
在我们进行实例化对象的时候 例如：Person(‘zs’,18)
首先执行的是Person类中的__new__ 方法
然后是__init__方法
# author: LiuShihao
# data: 2020/11/28 2:54 下午
# youknow: 各位老铁,我的这套代码曾经有人出价三个亿我没有卖,如今拿出来和大家分享,不求别的,只求大家免费的小红心帮忙点一点,这里谢过了。
# desc: 类的特殊方法
a = 10
b = 20
c = a+b # a+b底层实际上是调用了__add__()方法
d = a.__add__(b) # __add__()方法
print(c)
print(d)
class Student:
def __init__(self,name,age):
self.name = name
self.age = age
def __add__(self, other):
return self.name+other.name
def __len__(self):
return len(self.name)
stu1 = Student('zs',19)
stu2 = Student('ls',22)
s = stu1+stu2 # 如果类中没有定义__add__特殊方法，直接使用+，则无法实现两个对象的相加 会报错
print(s)
s = stu1.__add__(stu2)
print(s)
lst = [11,22,33,44,55,]
print(len(lst))
print(lst.__len__())
print(s.__len__())
class Person:
def __init__(self,name,age):
self.name = name
self.age = age
print("__init__方法被调用了,self的id值为{0}".format(id(self)))
def __new__(cls, *args, **kwargs):
print("__new__方法被调用了，cls的id值为{0}".format(id(cls)))
obj = super().__new__(cls)
print("创建的对象的id是{0}".format(id(obj)))
return obj
print("object这个类对象的id为{0}".format(id(object)))
print("Person这个类对象的id为{0}".format(id(Person)))
# 创建Person的实例对象
p1 = Person('zs',18)
print("p1这个Person类的实例对象的id为{}".format(id(p1)))
# 通过以上可以发现 在new中创建出的对象就是self和p1
"""
在我们进行实例化对象的时候 例如：Person('zs',18)
首先执行的是Person类中的__new__ 方法
然后是__init__方法
"""
类的深拷贝和浅拷贝
变量的赋值操作
只是形成两个变量，实际上还是指向同一个对象
# author: LiuShihao
# data: 2020/11/28 3:48 下午
# youknow: 各位老铁,我的这套代码曾经有人出价三个亿我没有卖,如今拿出来和大家分享,不求别的,只求大家免费的小红心帮忙点一点,这里谢过了。
# desc: 深拷贝与浅拷贝
class CPU:
pass
class Disk:
pass
class Computer:
def __init__(self,cpu,disk):
self.cpu = cpu
self.disk = disk
# 变量的赋值
cpu1 = CPU()
cpu2 = cpu1
print(cpu1) # <__main__.CPU object at 0x10a502898>
print(cpu2) # <__main__.CPU object at 0x10a502898>
# cpu1与cpu2的内存地址相同 实际上是一个对象放到了两个变量中
浅拷贝
Python拷贝一般都是浅拷贝，拷贝时，对象包含的子对象内容不拷贝，因此源对象与拷贝对象会引用同一个子对象
cpu = CPU()
disk = Disk()
computer = Computer(cpu,disk)
import copy
computer_copy = copy.copy(computer) # 浅拷贝
print(computer,computer.disk,computer.cpu)
print(computer_copy,computer_copy.disk,computer_copy.cpu)
# 可以看到 两个computer对象不是一个对象，但是其中的子对象CUP和Disk类还是同一个对象
深拷贝
使用copy模块的deepcopy函数，递归拷贝对象中包含的子对象，源对象和拷贝对象所有的子对象也不相同。
# 深拷贝
computer_copy2 = copy.deepcopy(computer)
print(computer,computer.disk,computer.cpu)# <__main__.Computer object at 0x109a2fe10> <__main__.Disk object at 0x1099dd1d0> <__main__.CPU object at 0x1099c2898>
print(computer_copy2,computer_copy2.disk,computer_copy2.cpu) #<__main__.Computer object at 0x109a3b198> <__main__.Disk object at 0x109acd198> <__main__.CPU object at 0x109ab4390>
# 看到无论computer还是拷贝的computer_copy2 还是他们的子对象都不是一个对象
总结
505
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
