编程思想
- 面向过程:事物比较简单,可以用线性的思维去解决
- 面向对象:事物比较复杂,使用简单的线性思想无法解决
- 共同点:面向过程和面向对象都是解决实际问题的一种思维方式;二者相辅相成,并不是对立的;解决复杂问题,通过面向对象方式便于我们从宏观上把握事物之间复杂的关系,方便我们分析
- 整个系统:具体到微观操作,仍然使用面向过程方式来处理
类和对象
- 类:多个类似事物组成的群体的统称。能够帮助我们快速理解和判断事物的性质
- 数据类型:不同的数据类型属于不同的类;使用内置函数查看类型
- 对象:100,99,520都是int类之下包含的相似的不同个例,这个个例专业数语称为实例或对象
python中一切皆对象
类的创建
class Student:
pass
类的组成
- 类属性
- 实例方法
- 静态方法
- 类方法
class Student: # Student为类的名称(类名)由一个或多个单词组成,每个单词的首字母大写,其余小写
pass
# python中的一切皆对象
print(id(Student)) # 2684548738128
print(type(Student)) # <class 'type'>
print(Student) # <class '__main__.Student'>
class Student: # Student为类的名称(类名)由一个或多个单词组成,每个单词的首字母大写,其余小写
native_pace = '武汉' # 直接写在类里的变量,称为类属性
def __init__(self,name,age):
self.name = name # self.name 称为实体属性,进行了一个赋值的操作,将局部变量的name的值赋给实体属性
self.age = age
# 实例方法
def eat(self):
print('学生在吃饭...')
# 静态方法(静态方法里面不能写self)
@staticmethod
def method():
print('我使用了statticmethod进行修饰,所以我是静态方法')
# 类方法
@classmethod
def cm(cls):
print('我是类方法,因为我使用了classmethod进行修饰')
# 在类之外定义的称为函数,在类之内定义的称为方法
def drink():
print('喝水')
类属性,类方法,静态方法
- 类属性:类中方法外的变量称为类属性,被该类的所有对象所共享
- 类方法:使用@classmethod修饰的方法,使用类名直接访问的方法
- 静态方法:使用@staticmethod修饰的主法,使用类名直接访问的方法
class Student: # Student为类的名称(类名)由一个或多个单词组成,每个单词的首字母大写,其余小写
native_pace = '武汉' # 直接写在类里的变量,称为类属性
def __init__(self, name, age):
self.name = name # self.name 称为实体属性,进行了一个赋值的操作,将局部变量的name的值赋给实体属性
self.age = age
# 实例方法
def eat(self):
print('学生在吃饭...')
# 静态方法(静态方法里面不能写self)
@staticmethod
def method():
print('我使用了statticmethod进行修饰,所以我是静态方法')
# 类方法
@classmethod
def cm(cls):
print('我是类方法,因为我使用了classmethod进行修饰')
# 类属性的使用方式
print(Student.native_pace)
stu1 = Student('张三', 20)
stu2 = Student('李四', 30)
print(stu1.native_pace)
print(stu2.native_pace)
Student.native_pace = '天津'
print(stu1.native_pace)
print(stu2.native_pace)
print('-------类方法的使用方式-------')
Student.cm()
print('-------静态方法的使用方法-------')
Student.method()
一个Student类可以创建N多个Student类的实例对象,每个实例对象的属性值不同
class Student:
def __init__(self, name, age):
self.name = name
self.age = age
def eat(self):
print(self.name+'在吃饭')
stu1 = Student('张三', 20)
stu2 = Student('李四', 30)
print(id(stu1)) # 2049758793680
print(id(stu2)) # 2049758793488
print('-------为stu2动态绑定性别属性-------')
stu1.gender = '男'
print(stu1.name, stu1.age, stu1.gender)
print(stu2.name, stu2.age)
# print(stu2.gender) # AttributeError: 'Student' object has no attribute 'gender'
print('-------')
stu1.eat() # eat()定义在类当中的
stu2.eat()
def show():
print('定义在类之外的,称函数')
stu1.show = show
stu1.show() # 定义在类之外的,称函数
# stu2.show() # 因为stu2并没有绑定show()方法
面向对象的三大特征
封装:提高程序的安全性
- 将数据(属性)和行为(方法)包装到类对象中。在方法内部对属性进行操作,在类对象的外部调用方法。这样,无需关心方法内部的具体实现细节,从而隔离了复杂度
- 在python中没有专门的修饰符用于属性的私有,如果该属性不希望在类对象外部被访问,前面使用两个“_”。
class Car:
def __init__(self, brand):
self.brand = brand
def start(self):
print('汽车已启动')
car = Car('宝马X5')
print(car.brand)
car.start()
class Student:
def __init__(self, name, age):
self.name = name
self.__age = age # 年龄不希望在类的外部被使用,所以加了两个
def get_age(self):
return self.__age
# def set_age(self):
# if 0<=age<=120:
# self.__age = age
# else:
# self.__age = 18
def show(self):
print(self.name, self.__age)
stu = Student('张三', 20)
stu.show()
# 在类的外部使用name和age
print(stu.name)
# print(stu.__age)
# print(dir(stu))
print(stu._Student__age)
继承:提高代码的复用性
- 如果一个类没有继承任何类,则默认继承object
- python支持多继承
- 定义子类时,必须在其构造函数中调用父类的构造函数
class Person(object):
def __init__(self, name, age):
self.name = name
self.age = age
def info(self):
print(self.name, self.age)
class Student(Person):
def __init__(self, name, age, stu_no):
super().__init__(name, age)
self.stu_no = stu_no
class Teacher(Person):
def __init__(self, name, age, teachofyear):
super().__init__(name, age)
self.teachofyear = teachofyear
stu = Student('张三', 20, '1001')
teacher = Teacher('李四', 34, 10)
stu.info() # 调用父类方法
teacher.info() # 调用父类方法
# python的多继承
class A(object):
pass
class B(object):
pass
class C(A,B): # C 继承 A和B
pass
方法重写
- 如果子类对继承自父类的某个属性或方法不满意,可以在子类中对其(方法体)进行重新编写
- 子类重写后的方法中可以通过 super().xxx() 调用父类中被重写的方法
class Person(object):
def __init__(self, name, age):
self.name = name
self.age = age
def info(self):
print(self.name, self.age)
class Student(Person):
def __init__(self, name, age, stu_no):
super().__init__(name, age)
self.stu_no = stu_no
def info(self):
super().info()
print(stu.stu_no)
class Teacher(Person):
def __init__(self, name, age, teachofyear):
super().__init__(name, age)
self.teachofyear = teachofyear
def info(self):
super().info()
print(teacher.teachofyear)
stu = Student('张三', 20, '1001')
teacher = Teacher('李四', 34, 10)
stu.info() # 调用父类方法
teacher.info() # 调用父类方法
object类
- object类是所有类的父类,因此所有类都有object类的属性和方法
- 内置函数dir()可以查看指定对象所有属性
- object有一个_str_()方法,用于返回一个对应“对象的描述”,对应于内置函数str()经常用于print()方法,帮我们查看对象的信息,所以我们经常会对_str_()进行重写
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)
print(dir(stu))
print(stu) # 改变对象输出方式
多态:提高代码的可扩展性和可维护性
简单来说,多态就是“具有多种形态”,它指的是:即便不知道一个变量所引用的对象到底是什么类型,仍然可以通过这个变量调用方法,在运行过程中根据变量所引用对象的类型,动态决定调用哪个对象中的方法
静态语言和动态语言关于多态的区别
静态语言实现多态的三个必要条件:
- 继承
- 方法重写
- 父类引用指向子类对象
动态语言的多态崇尚“鸭子类型”当看到一只鸟走起来像鸭子,游泳起来像鸭子,收起来也像鸭子,那么这只鸟就可以被称为鸭子。在鸭子类型中,不需要关心对象是什么类型,到底是不是鸭子,只关心对象的行为
class Animal(object):
def eat(self):
print('动物要吃东西')
class Dog(Animal):
def eat(self):
print('狗吃肉')
class Cat(Animal):
def eat(self):
print('猫吃鱼')
class Person():
def eat(self):
print('人吃五谷杂粮')
def fun(obj):
obj.eat()
fun(Animal()) # 动物要吃东西
fun(Dog()) # 狗吃肉
fun(Cat()) # 猫吃鱼
print('----------------------------')
fun(Person()) # 人吃五谷杂粮
特殊方法和特殊属性
特殊属性:
- dict:获得类对象或实例对象绑定的所有属性和方法的字典
特殊方法:
- len():通过重写__len__()方法,让内置函数len()的参数可以是自定义类型
- add():通过重写__add__()方法,可使用自定义对象具有“+”功能
- new():用于创建对象
- init():对创建的对象进行初始化
# print(dir(object))
class A:
pass
class B:
pass
class C(A, B):
def __init__(self, name):
self.name = name
class D(A):
pass
# 创建C类对象
x = C('Jack') # x是C类型的一个实例对象
print(x.__dict__) # {'name': 'Jack'} 实例对象的属性字典
print(C.__dict__)
print('------------------------------')
print(C.__class__) # <class 'type'> 输出对象所属的类
print(C.__bases__) # C类的父类类型的元素(多继承)
print(C.__base__) # 类的基类
print(C.__mro__) # 类的层次结构
print(A.__subclasses__()) # 子类的列表
特殊方法:
a = 20
b = 100
c = a + b # 两个整数类型的对象的相加操作
d = a.__add__(b)
print(c)
print(d)
class Student:
def __init__(self, name):
self.name = name
def __add__(self, other):
return self.name + other.name
def __len__(self):
return len(self.name)
stu1 = Student('张三')
stu2 = Student('李四')
s = stu1 + stu2 # 实现两个对象的加法运算(因为在Student类中 编写__add__()特殊的方法)
print(s)
s = stu1.__add__(stu2) # 如果没有Student类里面的__add__()构造方法,则会报错
print(s)
print('------------------------')
lst = [11, 22, 33, 44]
print(len(lst))
print(lst.__len__())
print(len(stu1))
当我们用类来实例化对象时,系统就会自动调用__new__创建对象,这个创建的对象就是self,然后才会执行__init__,去构造实例的属性;准确点说是__new__创建对象(实力本身),然后传递给init上self这个形参上,才会执行init来构造实例对象的基础属性;可如果你重写了方法__new__,但把super().new__(cls)省略了,那么后同init形参self就没有值,init就不会执行
class Person:
def __new__(cls, *args, **kwargs):
print('__new__被调用执行了,cls的id值为{0}'.format(id(cls))) # 6992
obj = super().__new__(cls)
print('创建的对象的id为:{0}'.format(id(obj))) # 2688
return obj
def __init__(self, name, age):
print('__init__被调用了,self的id值为:{0}'.format(id(self))) # 2688
self.name = name
self.age = age
print('object这个类对象的id为:{0}'.format(id(object))) # 5616
print('Person这个类对象的id为:{0}'.format(id(Person))) # 6992
# 创建Person类的实例对象
p1 = Person('张三', 20) # 先执行等号右边的代码,将Person传给cls
print('p1这个Person类的实例对象的id:{0}'.format(id(p1))) # 2688
"""
object这个类对象的id为:140732853935616
Person这个类对象的id为:2586884266992
__new__被调用执行了,cls的id值为2586884266992
创建的对象的id为:2586891132688
__init__被调用了,self的id值为:2586891132688
p1这个Person类的实例对象的id:2586891132688
"""
类的浅拷贝和深拷贝
变量的赋值操作
- 只是形成两个变量,实际上还是指向同一个对象
- 其实就是对象的引用(别名)
浅拷贝
- python拷贝一般都是浅拷贝,拷贝时,对象包含的子对象内容不拷贝,因此,源对象与拷贝对象会引用同一个子对象
- 拷贝父对象,不会拷贝对象的内部的子对象
深拷贝
- 使用copy模块的deepcopy函数,递归拷贝对象中包含的子对象,源对象和拷贝对象所有的子对象也不相同
- copy 模块的 deepcopy 方法,完全拷贝了父对象及其子对象
常使用的浅拷贝类型有:
(1)完全切片操作[:]
(2)利用工厂函数list(),dict()等
(3)使用copy模块的copy函数
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 0x000001FE13030FD0>
print(cpu2) # <__main__.CPU object at 0x000001FE13030FD0>
# 类的浅拷贝
disk = Disk() # 创建一个硬盘类的对象
computer = Computer(cpu1, disk) # 创建一个计算机类的对象
# 浅拷贝
import copy
computer2 = copy.copy(computer)
print(computer, computer.cpu, computer.disk) # <__main__.Computer object at 0x0000024A7E010F70> <__main__.CPU object at 0x0000024A7E010FD0> <__main__.Disk object at 0x0000024A7E010FA0>
print(computer2, computer2.cpu, computer2.disk) # <__main__.Computer object at 0x0000024A7E010D90> <__main__.CPU object at 0x0000024A7E010FD
print('-----------------------------')
# 深拷贝
computer3 = copy.deepcopy(computer)
print(computer, computer.cpu, computer.disk) # <__main__.Computer object at 0x000001D83B011F70> <__main__.CPU object at 0x000001D83B011FD0> <__main__.Disk object at 0x000001D83B011FA0>
print(computer3, computer3.cpu, computer3.disk) # <__main__.Computer object at 0x000001D83B011730> <__main__.CPU object at 0x000001D83B011400> <__main__.Disk object at 0x000001D83B02CD60>
浅拷贝
深拷贝