"""author = Zard"""
1.编程思想
1)面向过程编程：算法和逻辑
2)面向对象编程：类和对象 -- 面向生活编程
3)函数式编程：
2.类和对象
1.什么是类，什么是对象
类就是拥有相同功能和相同属性的对象的集合 -- 类是抽象的
对象就是类的实例 -- 对象是具体的
如果说人是一个类，骆昊就是一个对象，小明是另一个对象
如果说整数是一个类，100是一个对象，3是另外一个对象
2.类的声明
1)语法
class 类名：
类的内容
2)说明
class -- 关键字
类名 -- 程序员自己命名：是标识符但不能是关键字（要求）：
采用驼峰式命名。并且首字母大写
类的内容 - 包含类的说明文档、类中的函数（相同的功能）、类中的属性（相同的属性）
3.创建对象
1)语法
对象 = 类()
class Person:
"""类的说明文档:人类"""
def eat(self):
print('吃饭')
# 创建Person类的对象
p1 = Person()
# 同一个类可以有多个对象
p2 = Person()
3.对象方法
1.类中的函数
声明在类中的函数又叫 方法，类中的方法分为3种：对象方法、类方法、静态方法
1)对象方法
直接声明在类中的函数，自带一个self参数。
对象方法需要通过 '对象.函数名' 的方式来调用
通过对象调用对象方法的时候，self不需要传参；系统会自动将当前对象传给self（谁调用指向谁）
强调：对象方法就用对象去调用，不要用类去调用对象方法
class Person:
"""类的说明文档:人类"""
def eat(self):
print('吃饭')
p1 = Person()
p1.eat()
# Person.eat(100) 没意义
4.init方法
1.什么是 init 方法
是类中的一个魔法方法，也是对象方法；在创建对象时会被自动调用
2.构造方法（了解）
-- 开辟空间创建对象
-- 使用创建好的对象调用init方法（做一些初始化操作）
-- 返回对象
注意：如果init方法中出了self以外还有其他的参数，需要通过构造方法来给init方法传参
这儿person1()就是在调用构造方法
class Person1:
def __init__(self,x,y):
print('init方法被调用',x,y)
# 当然也可以用关键字参数传参
5.类中的属性
1.类中的属性：对象属性、字段
1）字段
a.怎么声明：声明在类的里面函数的外面的变量，就是类的字段
b.怎么使用：通过 "类.字段" 的方式去使用
c.什么时候用：属性值不会因为对象不同而不一样，这样的属性就声明成类的字段
2）对象属性（重点） --
a.怎么声明：以"self.属性名 = 值" 的方式声明在init方法中
b.怎么使用：通过"对象.属性名"的方式去使用
c.什么时候用：属性值会因为对象不同而不一样，这样的属性就声明成对象属性
三种赋值：1、直接设置参数，传参，2、直接设置初始值，不用传参，3、设置参数默认值
class Person:
# num就是类的字段
num = 61
def __init__(self):
# 这儿的name、age、gender就是Person类的对象属性
self.name = ''
self.age = 0
self.gender = '男'
print(Person.num) # 61
Person.num = 100
print(Person.num) # 100
p1 = Person()
p1.name = '小明'
p2 = Person()
p2.name = '小花'
class Dog:
def __init__(self,name1,age1,color1,breed1):
self.name = name1
self.age = age1
self.color = color1
self.breed = breed1
# 返回值必须是字符串
def __repr__(self):
return str(self.__dict__)
dog1 = Dog('大黄',3,'黄色','小狼狗')
dog2 = Dog('小花',1,'黑色','金毛')
print(dog1.name,dog2.name) # 大黄 小花
print(dog1) # <main.Dog object at 0x00000253F1640B38> 打印的是地址
需要重写repr方法，来定制对象的打印格式（默认对象地址）
重写后：
{'name': '大黄', 'age': 3, 'color': '黄色', 'breed': '小狼狗'}
练习：声明一个矩形类，有属性：长和宽，功能：计算矩形的面积和周长
class Rect_wyk:
"""矩形类"""
def __init__(self,x,y):
self.x = x
self.y = y
def area(self):
return 2 * self.y + 2 * self.x
def perim(self):
return self.x * self.y
a = Rect_wyk(2,3)
print(a.area())
print(a.perim())
6.对象属性的增删改查
===1.对象属性===
python中对象的属性支持增删改查操作
===2.查 -- 获取对象属性的值===
- 对象.属性 - 获取对象指定属性的值，如果属性不存在，报错！
- getattr(对象,属性名) - 获取对象指定属性的值，如果属性不存在，报错！
getattr(对象,属性名str,默认值) - 获取对象指定属性的值，如果属性不存在，不会报错而是返回默认值。
（当属性名通过别的方式得到时，增删改查要用attr方法）
===3.增、改 - 给对象添加属性/修改对象属性的值=== - 对象.属性 = 值 --- 当属性不存在就给对象添加属性，如果属性存在就修改属性的值
- setattr(对象，属性名str，值) - 功能同上
===4.删 --- 删除对象属性===
- del 对象.属性
- delattr(对象，属性名)
=========注意：属性的增删改查只针对当前对象有效，不会作用于其他对象==========
"""
class Person:
# 可以通过类的__slots__字段赋值，来约束当前类的对象最多有哪些属性值
__slots__ = ('name','age','gender')
def __init__(self,name,age=0,gender='男'):
self.name = name
self.age = age
self.gender = gender
p1 = Person('小明',18)
p2 = Person('小花',20,'女')
print(p1.name)
print(getattr(p1,'name'))
7.内置类属性
1.什么是内置类属性
创建类的时候，系统自动为这个类提供的属性
class Person:
"""说明文档：人类"""
num = 61
def __init__(self,name,age=0,gender='女'):
self.name = name
self.age = age
self.gender = gender
def eat(self,food):
print('%s在吃%s' % (self.name,food))
# 定制对象的打印
def __repr__(self):
return '<%s>' % str(self.__dict__)[1:-1] # 一般用__repr__
# return
# 定制对象的打印
# def __str__(self):
# return '<%s>' % str(self.__dict__)[1:-1] # 打印对象为序列时，仍打印为地址，不常用
p1 = Person('Tom',18,'男')
1.name
类的字段，获取类的名字
print(Person.name) # Person
print(Person) # <class 'main.Person'>
2.doc
类的字段，获取类的说明文档
print(Person.doc) # 说明文档：人类
3.class
对象属性，获取对象对应的
c1 = p1.class
print(c1) # <class 'main.Person'> 现在c1作用等同于Person
4.dict
1）类的字段，获取类中的字段（用得少）
2）对象属性，获取对象的所有属性和其对应的值，以字典的形式返回（用得多）
注意：如果给类的slots的属性赋了值，那么类的对象就不能使用
dict去获取所有的属性 （较多用dict）
print(Person.dict) # {'module': 'main', 'doc': '说明文档：人类', 'num': 61, 'init': <function Person.init at 0x000002242F943730>, 'eat': <function Person.eat at 0x000002242F9437B8>, 'dict': <attribute 'dict' of 'Person' objects>, 'weakref': <attribute 'weakref' of 'Person' objects>}
print(p1.dict) # {'name': 'Tom', 'age': 18, 'gender': '男'}
5.module
类的字段，获取类所在的模块（类是再哪个py文件中声明的）返回的是模块名
print(Person.module) # main
print(int.module) # builtins
6.bases
类的字段，获取当前类的父类
print(Person.bases) # (<class 'object'>,)
