1、初识面向对象编程 （核心--对象）
（1）面向过程编程与函数式编程比较
# 面向过程编程
s = "alexdsb"
count = 0
for i in s:
count += 1
print(count)
s = [1,2,7,3,4,5,]
count = 0
for i in s:
count += 1
print(count)
# 面向对象编程
def my_len(s):
count = 0
for i in s:
count += 1
print(count)
my_len([1,2,3,4,5])
可得出结论：
面向过程 vs 函数式编程
<1> 函数式编程 减少了重复代码
<1> 函数式编程 提高了代码的可读性高
（2）面向函数编程与面向对象编程比较
# 面向函数编程
def login():
pass
def check_buy_goods():
pass
def change_pwd():
pass
def shopping():
pass
def register():
pass
def check_unbuy_goods():
pass
# 面向对象编程
class Auth:
def login(self):
pass
def register(self):
pass
def change_pwd(self):
pass
class Shopping:
def shopping(self):
pass
def check_buy_goods(self):
pass
def check_unbuy_goods(self):
pass
可以得出结论：
函数式编程 vs 面向对象
<1> 面向对象 代码结构清晰，可读性高
<2> 面向对象使用 上帝思维
2、面向对象初识
类：对一些事物的统称和概括 (就是具有相同属性和功能的一类事物)
对象：实实在在存在的东西，具有特征和功能 (就是类的具体表现形式)
3、面向对象结构
class --- 关键字
class 类名： # 类名建议使用驼峰体 函数名建议使用下划线
静态属性（类变量，静态字段）
方法（类方法，动态属性，动态字段）
class People:
mind = "有思想" # 静态属性
def eat(self): # 方法
print("在吃饭")
def work(self):
print("在工作")
class Dog:
hair = "毛" # 静态属性
def eat(self):
print("吃食")
def lick(self):
print("添水")
4、类角度操作类
class People:
mind = "有思想" # 静态属性
def eat(self): # 方法
print("在吃饭")
def work(self):
print("在工作")
（1）__ dict__查看类下所有内容
print(People.__dict__) # __dict__ 只能查看当前空间下的内容
（2）. 万能的点 查看单个属性或方法
print(People.mind) # 类名.属性名
一般情况我们不使用类名去操作方法（类方法）
（3）增
People.emotion = "有情感"
（4）删
del People.mind
（5）改
People.mind = "无脑"
（6）查
print(People.mind) #类名.属性名 单独查一个
print(People.__dict__) # 查看类下所有的
5、对象角度操作类
class People:
mind = "有思想" # 静态属性
def eat(self): # 方法
print("self --->",self)
print("在吃饭")
def work(self):
print("在工作")
# 创建对象 -- 类名()
p = People() # 实例化对象
print(p.__dict__) # 对象的空间
print("p---->",p)
print(p.mind)
p.eat()
p.work()
class People:
mind = "有思想" # 静态属性
def __init__(self,name,age,sex): # 初始化
# self == p
self.name = name
self.age = age
self.sex = sex
def eat(self): # 方法
print(self.name)
print("在吃饭")
def work(self):
print("在工作")
p = People("marry",19,"男") # 实例化一个对象
p.eat()
可以在类的外部给对象创建属性，但不建议这样使用
p.mind = "无脑" # 给对象创了一个属性
print(People.__dict__)
print(p.__dict__) # 对象查询对象中所有属性
（1）对象只能使用类中的属性和方法，不能进行修改
（2）实例化一个对象总共发生了三件事：
<1> 实例化一个对象，给对象开辟空间
<2> 自动执行__ init__ 方法
<3> 自动将对象的地址隐性传递给了self
6、self 是什么
（1）就是函数的位置参数
（2）实例化对象的本身（对象和self指向同一内存地址）
class People:
mind = "有思想" # 静态属性
def __init__(self,name,age,sex,high=None): # 初始化(给创建的对象封装独有属性)
# self == p 地址相同
self.name = name
self.age = age
self.sex = sex
if high:
self.high = high
def eat(self): # 方法
print(f"{self.name}在吃饭")
def work(self):
print("在工作")
p1 = People("jim",19,"未知",170) # 实例化一个对象
p2 = People("kuqir",19,"未知",170) # 实例化一个对象
p3 = People("diva",19,"未知",170) # 实例化一个对象
p4 = People("李玲",19,"未知",170) # 实例化一个对象
p5 = People("好哥",19,"未知",170) # 实例化一个对象
p1.eat()
p2.eat()
7.类空间
（1）给对象空间添加属性：
对象的属性不仅可以在__ init__里面添加，还可以在类的其他方法或者类的外面添加
class A:
def __init__(self,name):
# 类里边给对象添加属性
self.name = name
def func(self,sex):
self.sex = sex
a = A("jim")
a.func("男")
# 类外边给对象添加属性
a.age = 18
print(a.__dict__)
# 总结:给对象空间添加属性可以在类的内部,类的外部,类中的方法
（2）给类空间添加属性：
类的静态属性不仅可以在内部添加，还可以在类的外部添加
class A:
def __init__(self,name):
# 类内部给类空间添加属性
A.name = name
def func(self,age):
# 类中的方法给类空间添加属性
A.age = age
类外部给类空间添加属性
A.name = "cai"
a = A('yong')
a.func(19)
print(A.__dict__)
# 总结:给类空间添加属性可以在类的内部,类的外部,类中的方法