1.面向对象编程
编程思想：
1.面向过程编程 ---> 算法，逻辑(数学逻辑)
2.函数式编程 ---> 函数，模块
3.面向对象编程 ---> 类和对象 (生活)
n = 100
sum1 = 0
for x in range(n+1):
sum1 += x
def add_student():
pass
class Student_Manager:
def add_student(self):
pass
value = input('数字')
if value == '1':
# add_student()
Student_Manager().add_student()
2.类的声明
1.什么是类和对象
类 - 是拥有相同属性和相同功能的对象的集合（抽象的）
对象 - 就是类的实例（具体的）
从生活的角度来看类和对象
如果说人是一个类， 余婷就是一个对象，骆昊也是一个对象
如果说电脑是一个类，我桌上的这台mac就是一个对象
如果水杯是一个类，具体的某个水杯才是这个类的对象
如果车是一个类，汽车、自行车、摩托车等这些是这个类的子类， 具体的某一辆车才是对象
2.类的声明
格式：
class 类名(父类列表):
类的说明文档
类的内容
说明:
class -> python中声明类的关键字
类名 -> 标识符,不能是关键字;类名使用驼峰式命名，并且首字母大写;见名知义
驼峰式命名：如果一个名字由多个单词组成，第一个单词首字母小写，后面每个单词首字母大写userName
PEP8命名规范：如果一个名字由多个单词组成，所有字母小写，多个单词之间用下划线隔开user_name
(父类列表) -> 继承语法，让声明的类继承括号中的父类。这个结构可以省略，让当前类继承python的基类:object
: -> 固定结构
类的说明文档 -> 注释，对类进行说明。
类的内容 -> 包含属性(变量)和方法(函数)
方法：声明在类中的函数
"""
声明Person类，吃饭和睡觉
class Person:
"""人类"""
def eat(self):
print('吃饭！')
def sleep(self):
print('睡觉！')
3.对象的声明
格式：
对象名 = 类名()
对象名 -> 变量名
类名 -> 必须是声明过的类
声明了Perosn类的对象p1
p1 = Person()
p2 = Person()
3.对象方法
1.类的内容包含属性和方法, 方法分为对象方法、类方法和静态方法
对象方法：直接声明在类中的函数就是对象方法。对象方法都有一个默认参数self, 通过对象来调用
对象方法的调用: 对象.方法名()。调用对象方法的时候，不需要给默认参数self传参。
系统会自动将当前对象传递给self 。
self: 谁调用当前的对象方法，self就指向谁。self就是当前类的对象，类的对象能做的事情，self都能做
声明类
class Person:
"""人类"""
# 对象方法eat
def eat(self, name):
# self = p1, name = '小明'
print('self:',self)
print('吃饭！')
self.sleep()
def sleep(self):
print('s_self', self)
print('睡觉')
# 声明对象
p1 = Person()
print('p1:', p1)
p1.eat('小明')
# p1.sleep()
p2 = Person()
print('p2:', p2)
p2.eat('小红')
4.构造方法和init方法
1.构造方法
构造方法就是函数名和类名一样的方法，作用是用来创建对象的。
声明类的时候，系统会自动为这个类创建对应构造方法
创建对象的过程：调用构造方法在内存中开辟空间创建对象，并且会自动调用init方法去对这个对象进行初始化,最后将创建好的对象的地址返回
2.init方法
对象方法
不需要手动调用，创建完对象后，会被自动调用
class Dog:
"""类"""
def __init__(self):
print(self)
print('init方法')
dog1 = Dog()
print(dog1)
dog2 = Dog()
3.带参其他参数的init方法
init方法的参数要通过构造方法来传。（构造方法的实参，会传递给init方法的形参）
class Person:
def __init__(self, name='', age=0):
print(name, age)
p1 = Person('小红', 20)
p2 = Person('小明')
p3 = Person(age=10)
if __name__ == '__main__':
pass
5.对象的属性
类的内容包含属性和方法，属性又分为对象属性和类的字段
属性：用来在类中去保存数据的变量。
对象属性：属性的值会因为对象不同而不同，这种属性就需要声明成对象属性，例如：人的名字，人的年龄等对象属性要通过对象来使用
1.对象属性的声明(重点！)
a.必须声明在init方法中
b.声明格式：self.属性 = 初值
2.使用对象属性: 对象.属性
声明一个人类，要求有名字，年龄和性别属性
class Person:
def __init__(self):
self.name = '张三'
self.age = 18
self.sex = '男'
p1 = Person()
print(p1.name)
p2 = Person()
print(p2.name)
3.创建对象的时候可以给对象属性赋值
声明一个人类，有名字、年龄、性别三个属性。要求创建不同对象的时候就可以直接确定不同属性值
class Person2:
def __init__(self, name1, age1=0, sex1='girl'):
self.name = name1
self.age = age1
self.sex = sex1
self.id = '0001'
def func1(self):
# self = p3
self.name = '路飞'
print(self.name)
def func2(self):
# self = p3
print('func2', self.name)
p1 = Person2('小明', 30, '女')
print(p1.name)
p1.name = 'XiaoMing' # 可以修改属性的值
print(p1.name)
p1.id = 'p0001'
print(p1.id)
p2 = Person2('小红', 18, '男')
print(p2.name)
p3 = Person2('小花')
print(p3.name)
p3.func1()
p3.func2()
if __name__ == '__main__':
pass
6.对象属性的增删改查
class Student:
def __init__(self, name='', age=0, study_id='001'):
self.name = name
self.age = age
self.study_id = study_id
创建对象
stu1 = Student('小明')
stu2 = Student('小红', 18)
1.查(获取对象属性的值)
方法1: 对象.属性 ---> 获取指定对象的指定属性的值，属性不存在会报错
方法2: getattr(对象, 属性名, 默认值) ---> 获取指定属性的值，属性名为字符串，当属性不存在时，设置了默认值就不会报错，返回默认值,如果没设置默认值会报错
方法3: 对象.getattribute(属性名) ---> 获取指定属性的值，属性不存在会报错，只有一个参数
print(stu1.name)
# print(stu1.name2) 报错:'Student' object has no attribute 'name2'
print(getattr(stu1, 'name'))
print(getattr(stu1, 'name2', '张三'))
print(stu1.__getattribute__('study_id'))
2.增/改(给对象添加属性)
注意: 给对象添加属性，只能添加到当前对象中，不会影响到当前类的其他对象
方法1: 对象.属性 = 值 属性不存在时增加，存在时修改
方法2: setattr(对象, 属性名, 属性值)
方法3: 对象.setattr (属性名, 属性值)
stu1.sex = '男'
print(stu1.sex)
# print(stu2.sex) 'Student' object has no attribute 'sex'
stu1.name = '李四'
print(stu1.name)
setattr(stu2, 'name', '小花')
print(stu2.name)
setattr(stu2, 'height', '163')
print(stu2.height)
3.删(删除对象属性)
注意: 只针对当前对象有效，只删除当前对象的属性
方法1: del 对象.属性
方法2: delattr(对象, 属性名)
方法3: 对象.delattr(属性名)
del stu1.age
# print(stu1.age) 报错
delattr(stu1, 'sex')
# print(stu1.sex) 报错
stu2.__delattr__('height')
# print(stu2.height) 报错
7.对象的使用
python中所有的数据都是对象,所有的变量都是存的对象的地址
C 语言
10 -> 4字节 -> 32bits
1000 -> 32bits
python语言
10 -> 4bits
1000 -> 10 bits
"""
import copy
class Student:
def __init__(self, name, age, score):
self.name = name
self.age = age
self.score = score
# 定制当前类的对象的打印格式
def __str__(self):
return 'name ' + self.name + ' age ' + str(self.age) + ' score ' + str(self.score)
# 1.将对象给别的变量赋值
stu1 = Student('xiaohua', 18, 90)
stu2 = stu1 # 赋的对象地址
stu3 = copy.copy(stu1) # 产生新的对象
stu1.name = '张三'
print(stu2.name, stu3.name )
# 2.将对象作为列表的元素
student = [Student('小明', 23, 89), Student('小花', 20, 100)]
print(student[0], student[1])
# 找到列表中成绩最好的人的名字
max1 = student[0].score
name1 = student[0].name
for i in student:
if i.score > max1:
max1 = i.score
name1 = i.name
print(max1, name1)
# 对列表中的学生按照年龄从小到大排序
student.sort(key=lambda item: getattr(item, 'age'))
for stu in student:
print(stu)
max2 = max(student, key=lambda item: item.score)
print(max2)
# 根据姓名查找指定学生的信息,根据姓名修改学生的年龄为指定年龄
def seek(student):
name = input("输入名字")
for stu in student:
if stu.name == name:
print(stu)
stu.age = 18
print(stu)
seek(student)
8.slots魔法
类的字段
属性: 对象属性，类的字段
类的字段: 就是声明在类里面函数外面的变量,使用的时候通过类来使用
使用: 类.字段slots: 用来约束当前类的对象的属性有哪些
class Dog:
# num 就是类的字段
num = 10
__slots__ = ('color', 'name', 'type')
def __init__(self, color, name, type):
self.color = color
self.name = name
self. type = type
print(Dog.num)
Dog.num = 100
print(Dog.num)
dog1 = Dog('黄色', '大黄', '中华田园犬')
9.内置类属性
class Person:
"""人类"""
# 类的字段
num = 61
# 对象属性
def __init__(self, name, age, sex):
self.name = name
self.age = age
self.sex = sex
# 对象方法
def run(self):
print('%s在跑' % self.name)
p1 = Person('小明', 18, '男')
# 1.__name__
"""
类.__name__ ---> 获取当前类的名字
"""
print(Person.__name__, type(Person.__name__), sep='\n')
# 2.__doc__
"""
类.__doc__ ---> 获取当前类的说明文档
"""
print(Person.__doc__, type(Person.__doc__), sep='\n')
# 3.__class__
"""
对象.__class__ ---> 获取对象的类,可以把它赋给一个变量,类能做的事，它都能做
"""
my_class = p1.__class__ # my_class 现在就等于Person这个类
print(p1.__class__)
p2 = my_class("小花", 17, '女')
print(p2.sex)
print(my_class.num)
# 4. __dict__
"""
类.__dict__ ---> 获取当前类的所有字段和其对应的值,以字典的形式返回
对象.__dict__ ---> 获取当前对象的所有属性和对应的值，以字典形式返回
"""
print(Person.__dict__)
print(p1.__dict__)
# 5.__module__
"""
类.__module__ ---> 获取当前类所在的模块
对象.__module__ ---> 获取当前对象所在的模块
"""
print(Person.__module__)
print(p1.__module__)
# 6.__bases__
"""
类.__bases__ ---> 获取当前类的父类,返回的是一个元组，里面元素为父类
"""
print(Person.__bases__)
print(p1)