4.1-面向对象初始
目录
面向对象
面向对象初始
面向过程变成 vs 函数式编程
# 面向过程编程，测量对象的元素个数
s = 'abcdefg'
count = 1
for i in s:
count += 1
l1 = [1, 2, 3, 4, 5]
count = 1
for i in l1:
count += 1
# 代码重复太多
# 函数式编程
def my_len(a):
count = 1
for i in a:
count += 1
my_len(s)
my_len(l1)
# 函数编程对比面向过程编程的明显特点：
# 减少代码的重复性；增强代码的可读性；
# 上面统称为面向过程式编程；
函数式编程 vs 面向对象编程
# 函数式编程
# auth认证相关
def login():
pass
def regisgter():
pass
# account账户相关
def func1():
pass
def func2():
pass
# 购物车相关
def shopping1(username, money):
pass
def shopping2(username, money):
pass
def save(username, money):
pass
# 面向对象式编程
class LoginHandler:
def login():
pass
def regisgter():
pass
class Account:
# account账户相关
def func1():
pass
def func2():
pass
class ShoppingCart:
# 购物车相关
def shopping1(username, money):
pass
def shopping2(username, money):
pass
def save(username, money):
pass
# 什么是面向对象：
# 面向对象的程序设计的核心是对象（上帝式思维），要理解对象为何物，必须把自己当成上帝，上帝眼里世间存的万物皆对象，不存在的也可以创造出来：
# 什么是类，什么是对象：
# 类：就是具有相同属性和功能的一类事物；
# 对象：就是类的具体表现；
# 举例：人就是类，你这个人就是一个对象；
# 面向对象思维，要自己建立对象，自己建立场景。你就是面向对象世界中的上帝；
# 通过对比，可以看出面向对象的优点：
面向对象编程：是一类相似功能函数的集合，使代码更清晰化，更合理化；
面向对象，要拥有上帝的视角看问题，类其实就是一个公共模板，对象就从具体的模板实例化出来；
类的结构
class Human:
'''
此类主要是构建人类
'''
mind = '思想' # 第一部分：静态属性 属性 静态变量 静态字段
dic = {}
l1 = {}
def work(self): # 第二部分：方法 函数 动态属性
print('人类要会工作')
'''
class是关键字，与def用法相同，定义一个类；
Human是此类的类名，类名使用驼峰体命名风格，首字母大写，私有类可用一个下划线开头；
类的结构大体分为两部分：
静态变量；
动态方法；
'''
从类名的角度研究类
类名操作静态属性
# 第一种：查看类中的所有内容：类名.__dict__方式
print(Human.__dict__)
print(Human.__dict__['mind'])
# 通过这种方式只能查询，不能增删改查
# 第一种方式只查询全部内容（一般不用单独属性查询）
# 第二种：万能的点.
print(Human.mind) # 查
Human.mind = '傻瓜' # 改
print(Human.mind)
del Human.mind # 删
Human.walk = '直立行走' # 增
print(Human.walk)
# 如果想要查询类中的所有内容，通过第一种__dict__方法，如果只是操作单个属性则用万能的点的方式
类名操作动态方法
除了两个特殊方法：静态方法，类方法之外；一般不会通过类名操作一个类中的方法；
class Human:
'''
此类主要是构建人类
'''
mind = '思想' # 第一部分：静态属性 属性 静态变量 静态字段
dic = {}
l1 = {}
def work(self): # 第二部分：方法 函数 动态属性
print('人类要会工作')
def tools(self):
print('人类会使用工具')
Human.work(666)
Human.tools(666)
Human.__dict__['work'](666) # 也可以，但是不用
从对象的角度研究类
什么是对象
对象是从类中出来的，只要是类名加上()， 这就是一个实例化的过程，这个过程就会实例化一个对象；
'''
实例化一个对象会发生三件事：
1：在内存中开辟了一个对象空间；
2：自动执行类中的__init__方法，并将这个对象空间（内存地址）传给了__init__方法的第一个位置参数self；
3：在__init__方法中通过self给对象空间添加属性；
'''
class Human:
mind = '思想'
language = '使用语言'
def __init__(self, name, sex, age, hobby):
# self 和 obj指向的是同一个内存地址，同一个空间；
# 下面通过self给这个对象空间封装四个属性
self.n = name
self.s = sex
self.a = age
self.h = hobby
obj = Human('hslm', '男', 25, 'book')
对象操作对象空间的属性
# 对象查询对象中所有属性: 对象.__dict__
class Human:
mind = '思想'
language = '使用语言'
def __init__(self, name, sex, age, hobby):
# self 和 obj指向的是同一个内存地址，同一个空间；
# 下面通过self给这个对象空间封装四个属性
self.n = name
self.s = sex
self.a = age
self.h = hobby
obj = Human('hslm', '男', 25, 'book')
print(obj.__dict__)
# {'n': 'hslm', 's': '男', 'a': 25, 'h': 'book'}
# 对象操作对象中的单个属性：万能的点.
obj = Human('hslm', '男', 25, 'book')
obj.job = 'OPS' # 增
del obj.n # 删
obj.s = '女' # 改
print(obj.s) # 查
print(obj.__dict__)
# {'s': '女', 'a': 25, 'h': 'book', 'job': 'OPS'}
对象查看类中的属性
obj = Human('hslm', '男', 25, 'book')
print(obj.mind)
print(obj.language)
obj.a = 777
print(obj.a)
对象操作类中的方法
class Human:
mind = '思想'
language = '使用语言'
def __init__(self, name, sex, age, hobby):
# self 和 obj指向的是同一个内存地址，同一个空间；
# 下面通过self给这个对象空间封装四个属性
self.n = name
self.s = sex
self.a = age
self.h = hobby
def work(self):
print(self)
print('人类会工作')
def tools(self):
print('人类会使用工具')
obj = Human('hslm', '男', 25, 'book')
obj.work() # 人类会工作
obj.tools() # 人类会使用工具
# 类中的方法一般都是通过对象执行的（除去类方法，静态方法外），并且对象执行这些方法都会自动将对象空间传给方法中的第一个参数self
# 什么是self
# self其实就是类中方法（函数）的第一个位置参数，只不过解释器会自动将调用这个函数的对象传给self，所以把类中的方法的第一个参数约定俗成设置成self，代表这个就是对象；
一个类可以实例化多个对象
class Human:
mind = '思想'
language = '使用语言'
def __init__(self, name, sex, age, hobby):
# self 和 obj指向的是同一个内存地址，同一个空间；
# 下面通过self给这个对象空间封装四个属性
self.n = name
self.s = sex
self.a = age
self.h = hobby
obj1 = Human('黑色利穆', '男', 25, '游戏')
obj2 = Human('白色利穆', '男', 30, '学习')
print(obj1, obj1.__dict__)
print(obj2, obj2.__dict__)
# <__main__.Human object at 0x00000212388675F8> {'n': '黑色利穆', 's': '男', 'a': 25, 'h': '游戏'}
# <__main__.Human object at 0x00000212388676A0> {'n': '白色利穆', 's': '男', 'a': 30, 'h': '学习'}
练习
'''
1.完成以下功能：
1.创建一个人类Person，在类中创建3个静态变量
animal = '高级动物'
soul = '灵魂'
language = '语言'
2.类中定义三个方法：吃饭，睡觉，工作；
3.在此类的__init__方法中，给对象封装5个属性：国家，姓名，性别，年龄，身高；
4.实例化四个人类对象：
第一个人类对象p1属性：中国，黑色利穆,男，25,175
第二个人类对象p2属性：美国，tom,女，21,160
第三个人类对象p3属性：韩国，欧巴,男，40,198
第四个人类对象p4属性：p1的国籍，p2的名字，p3的性别，p2的年龄，p3的身高
5.通过p1对象执行吃饭方法，方法里打印：黑色利穆在吃饭；
6.通过p2对象执行吃饭方法，方法里打印：tom在吃饭；
7.通过p3对象执行吃饭方法，方法里打印：欧巴在吃饭；
8.通过p1对象找到Person的静态变量 animal
9.通过p2对象找到Person的静态变量 soul
10.通过p3对象找到Person的静态变量 language
'''
class Person:
animal = '高级动物'
soul = '灵魂'
language = '语言'
def __init__(self, country, name, sex, age, height):
self.country = country
self.name = name
self.sex = sex
self.age = age
self.height = height
def eat(self):
print(f'{self.name}正在吃饭')
def sleep(self):
pass
def work(self):
pass
'''
第四个人类对象p4属性：p1的国籍，p2的名字，p3的性别，p2的年龄，p3的身高
8.通过p1对象找到Person的静态变量 animal
9.通过p2对象找到Person的静态变量 soul
10.通过p3对象找到Person的静态变量 language
'''
p1 = Person('中国', '黑色利穆', '男', 25, 175)
p2 = Person('美国', 'tom', '女', 21, 160)
p3 = Person('韩国', '欧巴', '男', 40, 198)
p4 = Person(p1.country, p2.name, p3.sex, p2.age, p3.height)
print(p1.__dict__) # {'country': '中国', 'name': '黑色利穆', 'sex': '男', 'age': 25, 'height': 175}
print(p2.__dict__) # {'country': '美国', 'name': 'tom', 'sex': '女', 'age': 21, 'height': 160}
print(p3.__dict__) # {'country': '韩国', 'name': '欧巴', 'sex': '男', 'age': 40, 'height': 198}
print(p4.__dict__) # {'country': '中国', 'name': 'tom', 'sex': '男', 'age': 21, 'height': 198}
p1.eat() # 黑色利穆正在吃饭
p2.eat() # tom正在吃饭
p3.eat() # 欧巴正在吃饭
print(p1.animal) # 高级动物
print(p2.soul) # 灵魂
print(p3.language) # 语言
'''
通过创建类，实例化对象，在终端输出如下信息
张三今年23早上起床吃煎饼
张三今年23中午出去吃烧饼
张三今年23晚上回来手抓饼
李四今年33早上起床吃煎饼
李四今年33中午出去吃烧饼
李四今年33晚上回来手抓饼
'''
class OneDay:
def __init__(self, name, age):
self.name = name
self.age = age
def morning(self):
print(f'{self.name}今年{self.age}早上起床吃煎饼')
def nooning(self):
print(f'{self.name}今年{self.age}中午出去吃烧饼')
def night(self):
print(f'{self.name}今年{self.age}晚上回来手抓饼')
p1 = OneDay('张三', 23)
p2 = OneDay('李四', 33)
def one_day(x):
x.morning()
x.nooning()
x.night()
one_day(p1)
one_day(p2)
