目录
一、面向对象编程
Object Oriented Programming (OOP)
二、面向过程，面向对象的比较
| 生活中 | 程序中 | |||
| 面向过程 | 亲力亲为（自己干） 自己做饭吃 |
函数之间的相互调用 以函数为基本结构使用 |
函数 | 变量 |
| 面向对象 | 坐享其成（让别人去干，享受成果） 点外卖吃 |
以对象为基本结构 | 方法 | 属性 |
三、类，对象
1.概念
| 概念 | 能不能直接使用 | ||
| 类 | 是一群具有相同特征或者行为的事物的统称 | 抽象 | 不能直接实用 |
| 描述一个类： 行为，特征 | |||
| 对象 | 是由类创造出来的具体的实体 | 具体 | 不能直接使用 |
（1）类
类是一群具有相同特征或者行为的事物的统称，是抽象的，不能直接使用
描述一个类：行为，特征
类：可以理解为一种事物的模板
（2）对象
是由类创造出来的具体的实体，可以直接使用的
2.创建
（1）创建类：大驼峰命名法
格式：
class 类名：
类的属性
类的方法
....
# 创建类：大驼峰命名法
class Dog:
def eat(self):
print('吃骨头...')
def sleep(self):
print('睡觉了...')
（2）创建对象
格式：
对象名=类名（）
# 创建对象
# 格式：对象名称=类名()
# 一条狗
dog = Dog()
# 调用
dog.sleep()
dog.eat()
print(id(dog))
# 又一条狗
dog1 = dog
print(id(dog))
print(id(dog1))
3.self变量
哪个对象在调用方法或属性，self就是哪个对象
4.在类的外部添加属性
可以这样用，但是不推荐使用
格式：
对象名.属性名=值
5.__init__() 初始化方法
我们可以在此方法中，做一些初始化的操作
创建对象的时候就会自动调用__init__()
class Cat:
def __init__(self, name):
print('init方法在创建对象的时候执行')
self.name = name
def eat(self):
print('猫吃老鼠')
print(self.name)
# 创建对象的时候自动调用__init__(),
bule_cat = Cat('蓝猫')
bule_cat.eat()
black_cat = Cat('黑猫')
black_cat.eat()
# 类的方法里面传的是形参，创建对象传的是实参
6.__str__方法
在没有写__str__()方法的时候，打印对象，会输出对象的地址
class Cat:
def __init__(self, name, age):
print('init方法在创建对象的时候执行')
self.name = name
self.age = age
def eat(self):
print('猫吃老鼠')
print(self.name)
# def __str__(self):
# msg = 'name的属性值是{},age的属性值是{}'.format(self.name, self.age)
# return msg
cat = Cat('蓝猫', 10)
print(cat) # <__main__.Cat object at 0x0000000001E8D358>在写了__str__()方法的时候，打印对象，就会输出__str__()里面的内容
class Cat:
def __init__(self, name, age):
print('init方法在创建对象的时候执行')
self.name = name
self.age = age
def eat(self):
print('猫吃老鼠')
print(self.name)
def __str__(self):
msg = 'name的属性值是{},age的属性值是{}'.format(self.name, self.age)
return msg
cat = Cat('蓝猫', 10)
print(cat)
# name的属性值是蓝猫, age的属性值是10四、类属性和实例属性
| 数据类型 | 操作 | 类属性和实例属性的变化情况 | |
| 不可变数据类型 | int float str tuple..... | 类属性变化 | 都变 |
| 实例属性发生变化 | 只有该实例属性变化，其他的都不变 | ||
| 可变数据类型 | list dict set..... | 实例属性调用自己的方法 | 全都变 |
| 实例属性重新赋值 | 只有实例属性变 重新开辟了一块内存空间 |
1.类属性是不可变数据类型（静态属性）
2.类属性是可变数据类型
五、类的封装
1.介绍
不让别人看到自己的某些代码，起到保护作用，（不让别人动你的代码）
在开发过程中，保护核心代码，不让外部使用
2.封装的体现
正常代码：
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def __str__(self):
msg = '{}的年龄是{}'.format(self.name, self.age)
return msg
person = Person('zs', 10)
person.age = -10
print(person)
# zs的年龄是-10（1）属性私有化：
给类的属性前面加两个下划线： __
class Person:
def __init__(self, name, age):
self.__name = name
self.__age = age
def __str__(self):
msg = '{}的年龄是{}'.format(self.__name, self.__age)
return msg
person = Person('zs', 20)
person.__name = '张三' # 在类的外面不能修改name的值
print(person) # zs的年龄是20私有化之后，类内部可以使用，类外不可以使用，正常修改的方法：
- 使用 setter,getter,方法
class Person:
def __init__(self, name, age):
self.__name = name
self.__age = age
def set_age(self, age):
if age < 0 or age > 150:
print('输入的年龄不合法...')
return
self.__age = age
def get_age(self):
return self.__age
def __str__(self):
msg = '{}的年龄是{}'.format(self.__name, self.__age)
return msg
person = Person('zs', 20)
person.set_age(-10) # 输入的年龄不合法...
ret = person.get_age()
print(ret) # 20
print(person) # zs的年龄是20- 对象名._类名__属性名=值
（2）方法私有化：
给类的方法前面加两个下划线： __
# 方法私有化之后，类外面的不能调用，但是类里面可以调用
class CallPhone:
def __tell(self):
print('正在通话中...')
def tell_one(self, money):
if money > 0:
self.__tell() # 在类内部，调用私有化后的方法
else:
print('欠费了啊...')
return
c1 = CallPhone()
c1.tell_one(-1) # 欠费了啊...
c1.tell_one(10) # 正在通话中...3.私有化封装后的限制
| 位置 | 可不可以使用 |
| 类内部 | 可以 |
| 类外，对象外 | 不可以 |
| 子类，子类对象 | 不可以 |