面向对象
编程思想：
- 1.面向过程的编程 --》 算法、逻辑（数学逻辑）
- 2.函数式编程 --》函数，模块
- 3.面向对象编程 --》类和对象（生活逻辑）
n = 100
sum1 = 0
for x in range(n+1):
sum1 += 1
def add_student():
pass
class Student_Manager:
def add_student(self):
pass
value = input('数字')
if value == '1':
add_student()
类的声明
1.什么是类和对象
- 类是拥有相同属性和相同功能的对象集合
对象 --》 就是类的实例（具体的）
从生活的角度来看类和对象
如果说人是一个类，yt就是一个对象。
如果车是一个类，汽车、自行车这些是这个类的子类，具体的这辆车才是类的对象
2.类的声明
- 格式：
class 类名 （父类列表）：
--------类的说明文档
--------类的内容
说明：
class -》 python中声明类的关键字
类名 -》标识符，不能是关键字；类名使用驼峰式命名，并且是首字母大写；见名知意
---------驼峰式命名：如果一个名字有多个单词组成，第一个首字母小写，后面每个首字母大写userName
----------PEP8命名规范：如果一个名字由多个单词组成所有字母小写，多个单词之间用下划线隔开 user_name
(父类列表) --》 继承语法，让声明的类继承括号中的父类。这个结构可以省略，让当前类继承python中的基类：object
： -》固定结构
类的说明文档 -》注释，对类进行说明
类的内容 -》包含属性（数据）和方法（函数）
------------------方法：声明在类中的函数
#1.声明Person类，吃饭和睡觉
class Person:
"""人类"""
def eat(self):
print('吃饭')
def sleep(self):
print('睡觉')
3.对象的声明
- 对象名 = 类名（）
对象名 -》 变量名
类名 -》必须是声明过的类
#声明了Person类的对象p1
p1 = Person()
p2 = Person()
对象方法
1.类的内容包含属性和方法，方法分为对象方法、类方法和静态方法
- 对象方法：直接声明在类中的函数就是对象方法。对象方法都有一个默认参数self，需要使用对象来调用
- 对象方法的调用：对象.方法名()。调用对象方法的时候，不需要给默认参数self 传参 系统会自动将当前对象传递给self。
- self谁调用当前的对象方法，self就指向谁.self就是当前类的对象，类的对象能做的事情，self都能做
class Person:
"""人类"""
def eat(self, name):
print('self:',self)
print('吃饭！')
self.sleep()
def sleep(self):
print('睡觉')
p1 = Person()
print('p1',p1)
p1.eat('小明')
p2 = Person()
print('p2:',p2)
p2.eat('小红')
构造方法和init方法
1.构造方法
- 构造方法就是函数名和类名一样的方法，作用是用来创建对象的。
- 声明类的时候，系统会自动为这个类创建对应的构造方法
- 创建对象的过程：调用构造方法在内存中开辟空间创造对象，并且会自动调用init方法去对这个对象进行初始化 最后将地址返回
2.init方法
- 对象手法
- 不需要手动调用会自动调用
class Dog:
"""dog类"""
def __init__(self):
print('init方法')
dog1 = Dog()
3.带参其他参数的init方法
- init方法的参数要通过构造方法来传，（构造方法的实参，会传递给init方法的形参）
class Person:
def __init__(self, name, age):
print(name, age)
p1 = Person('小红','18')
对象的属性
- 类的内容包含属性和方法，属性又分为对象属性和类的字段
- 属性：用来在类中保存数据的变量。
- 对象属性：属性的值会因为对象不同而不同，这种属性就需要声明成对象属性，例如：人的名字，人的年龄等 对象属性要通过对象来使用
1.对象属性的声明（重点！！）
- a.必须声明在init方法中，
- b.声明的格式:self.属性 = 初值
2.使用对象属性：对象.属性
class Person:
def __init__(self):
self.name = '张三'
self.age = 18
self.sex = '男'
p1 = Person()
print(p1.age)
class Person1:
def __init__(self, name, age=0, sex='girl'):
self.name = name
self.age = age
self.sex = sex
self.id = '0001'
p1= Person1('小明',30,'女')
p1.name = 'XiaoMing'
print(p1.name)
p1.id ='0001'
print(p1.id)
p2 =Person1('小红',30,'男')
print(p2.name)
p3 =Person1('小花')
print(p3.sex)
对象属性的增删改查
class Student:
def __init__(self, name='', age=0, study_id='001'):
self.name = name
self.age = age
self.study_id = study_id
stu1 = Student('小明')
#1.查（获取对象属性的值）
- 方法1：对象.属性 --》获取指定属性值，属性不存在会报错
print(stu1.name)
#print(stu1.name2)#AttributeError: 'Student' object has no attribute 'name2'
- 方法2.getattr（对象，属性名，默认值）--》获取指定默认值，如果设置默认值当属性不存在的时候不会报错，并且会将默认值作结果（如果没有设置默认值，属性不存在还是会报错）
print(getattr(stu1,'name',))
print(getattr(stu1,'name2','张三'))
- 方法3.对象.r__getattribute__（属性名）--》获取指定的属性值，属性不存在会报错
print(stu1.__getattribute__('study_id'))
#增、改
- 注意：给对象添加属性，只能添加到当前对象中。不会影响当前类的其他对象
- 方法1：对象.属性 == 值（属性不存在就是添加，存在就是修改）
- 方法2：setattr（对象，属性名，属性值）
- 方法3：对象.r__setattr__(属性名，属性值)
stu1.sex = '男'
print(stu1.sex)
#修改
stu1.name = '李四'
print(stu1.name)
#修改
setattr(stu1, 'name', '娜美')
print(stu1.name)
#增加
setattr(stu1, 'name2', 'Lisa')
print(stu1.name2)
＃3.删除
- 注意：删除只删除当前对象的属性，对当前类的其他对象没有影响
- 方法1：del 属性.对象
- 方法2：delattr（对象.属性名）
- 方法3：r__delattr__(属性名)
del stu1.age
# print(stu1.age)
print(stu1.sex)
delattr(stu1,'sex')
stu1.__delattr__('name')
7.对象的使用
- python中所有的数据都是对象，所有的变量存储的都是对象的地址
num = int()
print(num.bit_length())
list1 = ['a', 1]
list1.append('abc')
print(list1)
#定制当前类对象打印格式，函数的返回值必须是字符串
- def str(self):
return str(self.dict)
class Student:
def __init__(self, name, age, score):
self.name = name
self.age = age
self.score = score
#定制当前类对象的打印格式，函数的返回值必须是字符串
def __str__(self):
# return str(self.__dict__)
return 'name:' +self.name+'age:'+str(self.score)
#1.将对象给别的变量赋值
stu1 = Student('xiaoHua', 18, 90)
stu2 = stu1 #赋对象地址
stu3 = copy.copy(stu1) #产生新的对象，将新的地址赋值
stu1.name = '张三'
print(stu2.name)
print(stu3.name)
#2.将对象作为列表的元素
students = [Student('小明', 23, 89), stu3, Student('小红', 18, 67)]
#找到列表students中成绩最好的学生的名字
max1 = students[0].score
name = students[0].name
for stu in students:
if stu.score>max1:
max1 = stu.score
name = stu.name
print(name, max1)
#对列表中的学生按年龄从小到大排序
students.sort(key=lambda item:item.age)
for stu in students:
print(stu)
max1 = max(students, key=lambda item: item.score)
print('max:',max1)
#1.根据姓名查找指定学生的信息 2.根据姓名修改执行的学生的年龄
name = input('请输入学生的名字')
for stu in students:
if stu.name == name:
stu.age = 18
print(stu)
slots魔法
1.对象属性，类的字段
- 属性：对象属性，类的字段
- 类的字段：声明在类里面，函数外面的变量就是类的字段。使用的时候要通过类来使用
2.r__slots__:用来约束当前类的对象的属性有哪些
class Dog:
#num就是类的字段
num = 10
__slots__ = ('color', 'name', 'type','sex')
def __init__(self, color, name, type):
self.color = color
self.name = name
self.type = type
self.sex = '公的'
print(Dog.num)
Dog.num = 100
print(Dog.num)
dog1 = Dog(1, 1, 1)
#1.r__name__
- 类.r__name__ ->获取当前类的名字
print(Person.__name__,type(Person.__name__))
#2.r__doc__
-类.r__doc__ -》 获取类的说明文档
print(Person.__doc__)
print(int.__doc__)
print(dict.__doc__)
#3.r__class__
my_class = p1.__class__
p2 = my_class('小花', 10, '女')
p2 =Person('小花', 10, '女')
print('===================================')
print(p2.name)
print(Person.num)
print(my_class.num)
#4.dict
- 类.dict --> 获取当前类的所有类的字段和其对应的值，以字典的形式返回（了解）
- 对象.dict --> 获取当前对象所有的属性和其对应的值，以字典的形式返回
print(Person.__dict__)
print(p1.__dict__)
#5.module
- 类.module -> 获取当前类所在的模块
print(Person.__module__)
from datetime import datetime
print(datetime.__module__)
#6.bases
- 类.bases ->获取当前类的父类，返回的是一个元祖，元祖的元素是类
print(Person.__bases__)
print(p1)