# 面向过程编程vs函数
# 普通函数
s1 = "1234355"
count = 0
for i in s1:
count +=1
print(count)
# 函数，减少重复代码，增强可读性
s1 = "1234355"
l1 = [i for i in range(10)]
def my_len(argv):
count = 0
for i in argv:
count += 1
print(count)
# 面形对象编程
"""
学习面向对象站在一个上帝的角度去分析考虑问题
类：具有相同属性和功能的一类事物
对象：某个类的具体体现，具体到某一个
面向对象
优点1： 将相似功能的函数，同一个业务下的函数进行归类，分类
优点2：在上帝的角度构建代码，类就是一个公共的模版，对象就是某个版本实例化出来的
得到对象就得到了一切
"""
# 面向对象优点 将相似功能的函数，同一个业务下的函数进行归类，分类
class Auth:
# self 位置参数
# 放登录，注册，密码 等相似功能
def login(self):
pass
def register(self):
pass
def change_pwd(self):
pass
class Shopping:
def shopping_car(self):
pass
def check_paid_goods(self):
pass
def check_unpaid_goods(self):
pass
# 类的具体结构
class Human:
"""
类的具体结构
"""
# 第一部分：静态属性\静态字段
mind = '思想' # 类的属性
language = "使用语言"
# 第二部分：动态方法
# 类里面的函数是方法
def work(self):
print("工作")
def eat(self):
print("吃饭")
# 实例化的具体结构
class Human:
"""
实例化的具体结构
"""
# 第一部分：静态属性\静态字段
mind = '思想' # 类的属性
language = "使用语言"
# 开辟一个新的对象空间
def __init__(self):
# print(f'{self}') # 自动执行__init__方法，并将对象地址传给self
self.name = 'zhangsan' #self.属性名 = '' 可直接赋值
# 运行__init__方法中的代码，给对象空间封装属性
#
# 第二部分：动态方法
# 类里面的函数是方法
def work(self):
print("工作")
def eat(self):
print("吃饭")
obj = Human() # 类名()实例化过程
# print(f'obj--->{obj}')
# 得到一个返回值，这个返回值就是对象实例
print(obj.__dict__)
"""
obJ=类名+()实例化过程 开辟一个对象空间
得到一个返回值，这个返回值就是对象
实例化对象发生了三件事：
1、开辟一个对象空间
2、自动执行__init__方法，并将对象的地址传给self
3、运行__init__方法内的代码，给对象空间封装属性
"""
# 实例化的具体结构2
class Human:
"""
实例化的具体结构
"""
# 第一部分：静态属性\静态字段
mind = '思想' # 类的属性
language = "使用语言"
# 开辟一个新的对象空间
def __init__(self,name):# self 默认参数 name参数
# print(f'{self}') # 自动执行__init__方法，并将对象地址传给self
self.n = name #self.属性名 = 属性值
# 运行__init__方法中的代码，给对象空间封装属性
#
# 第二部分：动态方法
# 类里面的函数是方法
def work(self):
print(f'{self.n}工作') # 格式化 得到name的值
def eat(self):
print("吃饭")
obj = Human('zhangsan') # 类名()实例化过程 将zhangshan的值传给name
print(obj.__dict__)
obj.work() # 调用work函数
# print(f'obj--->{obj}')
# 得到一个返回值，这个返回值就是对象实例
"""
代码
"""
"""
class 就是一个类，类名是驼峰体构建
类的具体结构
属性和方法
"""
class Human:
"""
类的结构
"""
# 第一部分：静态属性\静态字段
mind = '思想' # 类的属性
language = "使用语言"
# 第二部分：动态方法
# 类里面的函数是方法
def work(self):
print("工作")
def eat(self):
print("吃饭")
"""
1、类名操作类中的属性 万能的点.
1.查看所有：类名.__dict__ 查看类中所有的内容
2.增：类名.属性 = '' 类名操作类中的静态属性
3.删：del 类名.属性
4.改：类名.属性 = ''
5.查：类名.属性
"""
# 查看：类名.__dict__ 查看类中所有的内容
print(Human.__dict__)
# 增：类名.属性 = '' 类名操作类中的静态属性
Human.body = '头四肢'
print(Human.__dict__)
# 删：del 类名.属性
del Human.mind
print(Human.__dict__)
# 改：类名.属性 = ''
Human.language = '使用语言为中文'
print(Human.__dict__)
# 查：类名.属性
print(Human.language)
"""
2、类名调用 类中的方法（一般类中的（静态方法和类方法）方法不会通过类名调用）
一般类名就是操作类中的静态属性
"""
class Human:
mind = '1'
body = '2'
def __init__(self,name,age): # 讲对象空间（内存地址）传给了__init__方法的第一个位置参数self
# __init__特殊的方法 自动通过self 给对象空间添加属性
self.n = name # self.n属性名 添加name属性值
self.a = age # self.a 添加age属性
# 增加键值对，输出的类型为{'name' = 'zhangshan'}
print(self) # __init__的内存地址
print(f'self-->{self}')
def work(self):
print("3")
def eat(self):
print("4")
obj = Human("zhangsan",18) # 实例化对象 类名+(赋值给__init__) 只要实例化对象，自动执行__init__方法
print(obj.n) # 打印n
print(obj.a) # 打印a
print(obj.__dict__) # 查看全部属性
"""
self是什么
1、self 本身就是类中的方法的第一个位置参数 ，可以是任意名
2、自动的接受对象的内存地址
"""
# 1、对象查看对象的空间的所有属性
obj = Human('zhangsan',18)
print(obj)
# 增 对象名 = 类名(属性)
obj = Human('lisi',18)
# 删 del 对象名.属性
del obj.a
# 改 对象名.属性 = 值
obj.a = 1000
# 查 对象名.属性
print(obj.n)
print(obj.__dict__)
# 2、 对象查看类中的属性,只能查看
print(obj.mind)
print(Human.mind)
# 3、 对象调用类中的方法 谁调用这个方法，就把属性传给谁
obj = Human("zhangzhang",19)
print(f'obj-->{obj}')
obj.work()
obj.eat()
# 4、 一个类可以实例化多个对象
obj1 = Human('1',2)
obj2 = Human('2',3)
obj3 = Human('3',4)
# 函数传参，类传参
# 隐式传参，显式传参