类和对象（基础）
认识面向对象
1.什么是类：对拥有相同属性和功能的对象的封装
类是抽象
类中相同的属性的值是不确定的
2.什么是对象：对象就是类的实例
对象是具体
对象中的属性的值是确定的
如果说电脑是一个类，我桌上的这台MACHENIKE就是一个对象
如果说杯子是一个类，我桌上这个从白到青渐变的杯子就是一个对象
3.面向对象编程
面向过程编程：一步一步的写代码实现功能 -->工具：逻辑和算法
函数式编程：面对问题考虑有没有拥有某种功能的函数 -->工具：函数
面向对象编程：面对问题考虑有没有相应的对象来解决这个问题 -->工具：类和对象
类的声明
类的声明：
class 类名（父类）：
属性
方法
类名之后的括号可省略
class：Python中声明类的关键字
类名：标识符，类名的首字母大写，驼峰式命名
（父类）：类要继承自其它类，需要写括号，括号里面是父类的名字。可省略
属性：对象属性和类的字段 --- 保存数据
方法:实质就是声明在类中的函数 --- 实现功能
# 声明类Person
class Person:
"""
类的说明：人类
"""
# 声明两个对象方法，需要使用对象来调用
"""
对象方法默认都有一个参数self，在调用方法的时候，这个参数不用传参（系统会自动给self传参）
谁来调用这个方法，self就是谁
"""
def eat(self):
print('eating')
def sleep(self):
print('sleeping')
声明对象：
通过类的构造方法去创建对象（名字和类名同名的方法就是构造方法，自动生成）
对象名 = 类名（）
类对象可以通过点语法使用类中声明的对象的方法和属性
对象.方法名
对象.属性名
if __name__ == '__main__':
# 声明对象
p1 = Person() # 有括号输出：<__main__.Person object at 0x000002497D46D6D8>
print(p1) # 无括号输出：<class '__main__.Person'>
# 一个类可以有多个对象
p2 = Person()
print(p2)
# 需要调用函数的对象在声明的时候必须是Person()，也就是必须要有括号，否则报TypeError: sleep() missing 1 required positional argument: 'self
p1.eat()
p2.sleep()
对象的属性
对象属性的声明
class 类名：
def def __init__(self):
self.属性名 = 初值
self2.属性名 = 初值
1、init方法是系统自带的一个方法，这个方法不能直接调用，通过类创建对象的时候系统会自动调用这个方法。
init方法的作用是对对象的属性进行初始化
2、通过构造方法创建对象的时候，一定要保证，init方法中除了self以外，其它的每个参数都必须有值。
class Person:
"""人类"""
def __init__(self, name1='GHope', age1='18', sex='男'):
# 在这个地方声明对象的属性
print('===')
# print(name1)
# 在init方法中声明对象的属性
"""
name/age/sex就是Person这个类的对象属性。类的对象属性，需要通过对象来使用
"""
self.name = name1
self.age = age1
self.sex = sex
if __name__ == '__main__':
# 注意：构造方法中的参数，实质是传给init方法的参数的
p1 = Person('GHope', 18)
# 通过对象使用对象属性
print(p1.name, p1.age, p1.sex)
p2 = Person('尚书', 99)
print(p2.sex, p2.name)
"""通过不同的方式创建对象"""
# 创建对象的时候，不给属性赋值
p3 = Person
对象属性的增删改查
class Dog:
"""
犬类
"""
def __init__(self, age=2, color='yellow'):
self.age = age
self.color = color
if __name__ == '__main__':
dog1 = Dog(3, 'white')
# 1.查（获取属性）
"""
方法一：对象.属性（如果属性不存在，会报错AttributeError）
方法二：对象.__getattribute__('属性名')
方法三：getattr(对象, '属性名','默认值')(如果设置了default的值，那么当属性不存在的时候不会报错，并且返回默认值)
"""
print(dog1.age, dog1.color)
print(dog1.__getattribute__('age'))
print(getattr(dog1, 'age'))
# 2.改（修改属性的值）
"""
方法一：对象.属性 = 新值
方法二：对象.__setattr__('属性名','新值')
方法三：setattr(对象, '属性名','新值','默认值')
"""
dog1.age = 4
print(dog1.age)
dog1.__setattr__('color', 'black')
print(dog1.color)
setattr(dog1, 'color', 'green')
print(dog1.color)
# 3.增加（增加对象属性）
"""
对象.属性 = 值（属性不存在）
注意：属性是添加给对象的，而不是类的
"""
dog1.name = '大黄'
print(dog1.name)
dog1.__setattr__('type', '哈士奇')
print(dog1.type)
setattr(dog1, 'sex', '母')
print(dog1.sex)
# 4.删（删除对象属性）
"""
方法一：del 对象.属性
注意：删除属性也是删的具体某个对象的属性。不会影响这个类的其它对象。
"""
del dog1.age
# print(dog1.age) #AttributeError: 'Dog' object has no attribute 'age'
dog1.__delattr__('sex')
# print(dog1.sex)
delattr(dog1, 'color')
# print(dog1.color) # AttributeError: 'Dog' object has no attribute 'color'
练习：声明一个学生类，拥有属性：姓名、性别、年龄。方法：学习
1.声明学生类的对象，声明的时候就给姓名、性别和年龄赋值
2.通过三种方式分别获取姓名、年龄和性别，并且打印
3.给学生对象添加一个属性，电话
4.修改学生的年龄
5.删除学生的性别
class Student:
def __init__(self, name='GHope', sex='man', age=18):
self.name = name
self.sex = sex
self.age = age
def study(self):
print('%s is studying.' % self.name)
student1 = Student()
print(student1.name)
print(student1.__getattribute__('age'))
print(getattr(student1, 'sex'))
student1.tel = 15082383310
student1.age = 20
del student1.sex
student1.study()
slots魔法
slots的功能：约束类中对象的属性
class Person:
# __slots__的功能：约束类中对象的属性
__slots__ = ('name', 'age', 'sex')
def __init__(self, name='', age=18):
self.name = name
self.age = age
# 自定义对象的打印格式
"""
id():是python的内置函数，功能是获取变量的地址
"""
def __str__(self):
return self.name + ',' + str(self.age) + ',' + str(id(self))
if __name__ == '__main__':
p1 = Person('李白', 69)
# p1.names = '太白'
p1.sex = '男'
print(p1)
类中的方法
属性：对象的属性（属性）、类的属性（类的字段）.
对象属性：属于对象的，不同对象对应的值可能不一样.
类的属性：声明在类里面，函数外面。类的属性属于类（类的字段，通过类来使用）.
方法：对象方法（方法）、类方法、静态函数
对象方法：自带一个self参数，一般要通过对象去掉用.
类方法：1、使用@classmethod修饰，2、自带一个cls参数，并且这个参数不用传参，谁来调用这个方法，cls就指向谁，3、类方法通过类来调用.
静态函数：使用staticmethod修饰，没有默认参数，通过类来调用.
怎么选择用对象方法、类方法、静态方法？
if 如果实现函数的功能需要使用对象的属性，就声明成对象方法；
elif 如果实现函数的功能需要使用类的字段或者调用类的方法，就声明成类方法；
else 如果实现函数的功能即不需要使用对象的属性，也不需要使用类的字段或者调用类的方法，就声明成静态方法。
补充：
Ctrl + r :查找替换
Ctrl + f ：查找
class Person:
# number是类字段
number = 0
def __init__(self, name='GHope', age=18):
# name和age是对象属性
self.name = name
self.age = age
# eat是对象方法
def eat(self, food):
print('%s eating %s' % (self.name, food))
# hurt_earth就是一个类方法
@classmethod
def hurt_earth(cls):
# cls指向的是调用这个方法的类，cls可以当成类来使用
pt = cls('Tom') # 可以使用cls创建对象
print(pt.name)
print(cls.number) # 可以通过cls使用类的字段
print('人类破坏环境！')
# protect_earth
@staticmethod
def protect_earth():
print('人类保护地球！')
if __name__ == '__main__':
# 类的字段要用类来声明
print(Person.number)
# 对象的属性要通过对象来使用
p1 = Person()
print(p1.name)
# 对象方法使用对象调用
p1.eat('noolds')
p2 = Person('Lucy')
p2.eat('milk')
# 类方法通过类名来调用
Person.hurt_earth()
# 静态方法通过类来调用
Person.protect_earth()
练习 ：
写一个班级类，属性：班级名、学生；功能：添加学生。
"""
class Class:
className = 'py1805'#应设置为对象属性，因为各个班级的名称并不一样
class_stu = ['stu1', 'stu2']#设置为一个对象属性，并在该类之外重新声明一个学生类。才能各个班级和各个学生对到起
@classmethod
def add_stu(cls, add_stu):#应使用对象方法，单个班级添加学生。而非所有。
cls.class_stu.append(add_stu)
Class.add_stu('stu3')
print(Class.class_stu)
"""
class Student:
"""学生类"""
def __init__(self, name='', age=0):
self.name = name
self.age = age
def __str__(self):
return 'name；%s age:%d' % (self.name, self.age)
class ClassTeacher:
def __init__(self, name='', students=[]):
self.class_name = name
self.students = students
def add_student(self):
name = input('name\t')
age = int(input('age\t'))
# 根据输入的信息创建学生对象
stu = Student(name, age)
# 添加学生
self.students.append(stu)
# 创建班级类对象
cls1 = ClassTeacher('py1805')
cls1.add_student()
print(cls1.students[0])
