目录
1、编程的两大思想,面向过程 VS 面向对象
1)面向过程和面向对象的区别:
- 面向过程,事物比较简单,可以用线性的思维去解决;
- 面向对象,事物比较复杂,使用简单的线性思维无法解决;
2)面向过程和面向对象的共同点:
- 都是解决实际问题的一种思维方式;
3)二者之间的关系:
- 解决复杂问题,通过面向对象方式,便于从宏观把握事物之间复杂的关系,方便分析整个系统;
- 具体到微观操作,仍然使用面向过程方式来处理;
- 如:想吃西红柿炒蛋,自己购买材料去做是面向过程;外卖下单购买,厨房接单制作,是面向对象;
2、类与对象
1)类
- 类别,多个类似事物组成的群体的统称,如人类,鸟类,动物类等;
2)数据类型
- 不同的数据类型属于不同的类;
- 使用内置函数查看数据类型;
# 不同的数据类型属于不同的类
print(type(100)) # <class 'int'>
print(type(50)) # <class 'int'>
print(type(10)) # <class 'int'>
3)对象
- 100,50,10都是int类之下包含的相似的不同个例,这个个例称为实例或对象;
- python中,一切皆对象;如字符串对象‘hello’,整数对象520,字典对象{'key':value},元组对象(10,20),列表对象[10,20]等;
3、类的创建
语法:
class Student:
pass
1)创建类
- Student为类的名称,由一个或多个单词组成,每个单词的首字母大写,其余小写;
- 类也占用内存空间,也有类型,也有value值;
# 创建类对象
class Student:
pass
print(id(Student)) # 占用了内存空间,1972126470016
print(type(Student)) # class类型,<class 'type'>
print(Student) # value值是<class '__main__.Student'>
2)类的组成
- 类属性,直接写在类里面的变量;
- 实例方法,在类外定义的是函数,在类内定义的是方法;
- 静态方法
- 类方法
创建学生类
# 创建学生类
class Student:
native_place = '吉林' # 类属性
def __init__(self, name, age): # 初始化方法
self.name = name # self.name是实例属性
self.age = age # 将局部变量age的值,赋值给self.age实例属性
# 实例方法
def info(self): # 传递的是类的对象self
print('我的名字叫:', self.name, '年龄是:', self.age)
# 类方法
@classmethod
def cm(cls): # 传递的是class
print('这是类方法')
# 静态方法
@staticmethod
def sm(): # 静态方法不允许传递值
print('这是静态方法')
在类外定义的是函数,在类内定义的是方法
# 类的方法和函数
# 类的方法
class Student:
def eat(self):
print('这是类的方法')
# 函数
def drink():
print('这是函数')
4、对象的创建
- 对象的创建,又称为类的实例化,类的实例创建;
- 有了实例,就可以调用类中的内容;
语法:
实例名 = 类名()
参考学生类
stu = Student('张三', 20)
print(id(stu)) # id = 1413659559584
print(type(stu)) # 对象的类型,<class '__main__.Student'>
print(stu) # 对象的id对应的16进制的地址,<__main__.Student object at 0x0000014924AD06A0>
print('-----------------')
print(id(Student)) # 2445954439664
print(type(Student)) # <class 'type'>
print(Student) # <class '__main__.Student'>
输出结果:
2443846615488
<class '__main__.Student'>
<__main__.Student object at 0x00000239009C01C0>
-----------------
2445954439664
<class 'type'>
<class '__main__.Student'>
Student是类对象,stu是实例对象;
调用方法的2种写法:
- 对象名.方法名(),如:stu.info()
- 类名.方法名(类的对象),实际就是方法定义处的self,如:Student.info(stu)
# 创建学生类
class Student:
native_place = '吉林' # 类属性
def __init__(self, name, age): # 初始化方法
self.name = name # self.name是实例属性
self.age = age # 将局部变量age的值,赋值给self.age实例属性
# 实例方法
def info(self): # 传递的是类的对象self
print('我的名字叫:', self.name, '年龄是:', self.age)
# 类方法
@classmethod
def cm(cls): # 传递的是class
print('这是类方法')
# 静态方法
@staticmethod
def sm(): # 静态方法不允许传递值
print('这是静态方法')
# 创建Student类的实例对象
stu = Student('jack', 20)
print(stu.name) # 实例属性
print(stu.age) # 实例属性
stu.info() # 调用实例方法
print('-------------------')
Student.info(stu) # 调用实例方法,另外一种写法
输出结果:
jack
20
我的名字叫: jack 年龄是: 20
-------------------
我的名字叫: jack 年龄是: 20
5、类属性,类方法,静态方法
- 类属性:类中方法外的变量称为类属性,被该类的所有对象所共享;
- 类方法:使用@classmethod修饰的方法,使用类名直接访问的方法;
- 静态方法:使用@staticmethod修饰的方法,使用类名直接访问的方法;
# 创建Student类的实例对象
print(Student.native_place) # 访问类属性
Student.cm() # 调用类方法
Student.sm() # 调用静态方法
输出结果:
吉林
这是类方法
这是静态方法
类属性的使用方法
# 类属性的使用方法
print(Student.native_place)
stu1 = Student('张三', 10)
stu2 = Student('李四', 20)
print(stu1.native_place)
print(stu2.native_place)
print('-----修改类属性的值---------')
Student.native_place = '天津'
print(Student.native_place)
print(stu1.native_place)
print(stu2.native_place)
输出结果:
吉林
吉林
吉林
-----修改类属性的值---------
天津
天津
天津
6、动态绑定属性和方法
- python是动态语言,在创建对象之后,可以动态的绑定属性和方法;
- 一个Student类,可以创建N多个Student类的实例对象,每个实例对象的属性值不同;即stu1,stu2
- 一个Student类,只有一个类对象,即Student类对象
需求:只为stu1动态绑定性别属性,指向女;
- 创建对象stu1后,单独给这个对象stu1绑定一个属性gender;所以stu2是没有这个属性的;
1)动态绑定属性
# 动态绑定属性
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('---------只为stu1动态绑定性别属性,指向女----------')
stu1.gender = '女'
print(stu1.name, stu1.age, stu1.gender)
print(stu2.name, stu2.age)
# print(stu2.gender) # stu2没有绑定属性gender,会报错,AttributeError: 'Student' object has no attribute 'gender'
输出结果:
张三 20 女
李四 30
2)动态绑定方法
# 动态绑定方法
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)
stu1.eat()
stu2.eat()
print('---------只为stu1动态绑定show()方法----------')
def show_stu1():
print('定义在类之外的,是函数')
stu1.show = show_stu1
stu1.show()
# stu2.show() # stu2没有绑定show()方法,所以调用show()会报错,AttributeError: 'Student' object has no attribute 'show'
输出结果:
张三在吃饭
李四在吃饭
---------只为stu1动态绑定show()方法----------
定义在类之外的,是函数
为stu1动态绑定属性和方法的示意图:
7、总结
二、面向对象的三大特征
1、封装
- 提高程序的安全性;
- 将数据(属性)和行为(方法)包装到类对象中;
- 在方法内部对属性进行操作,在