面向对象编程
编程思想
1.面向过程编程 --> 算法，逻辑
2.函数式编程 --> 函数，模块
3.面向对象编程 --> 类和对象
类的声明
1.什么是类
类 - 是拥有相同属性和相同功能的对象的集合(抽象的)
对象 - 就是类的实例(具体的)
2.类的声明
格式：
class 类名(父类列表):
类的说明文档
类的内容
说明：
class --> python中声明类的关键字
类名 --> 标识符，不能是关键字；类名使用驼峰命名法，并且首字母大写;见名知义
驼峰式命名：如果一个名字有多个单词组成，第一个单词首字母小写，后面每个单词首字母大写
userName
PEP8命名规范：如果一个名字有多个单词组成，所有字母小写，多个单词之间用下划线隔开
user_name
(父类列表) --> 继承语法，让声明的类继承括号中的父类。这个结构可以省略，让当前类继承python的基类：object
**: ** --> 固定结构
类的说明文档 --> 注释，对类进行说明
类的内容 --> 包含属性(变量)和方法(函数)
方法：声明在类中的函数
# 声明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:
"""人类"""
# 对象方法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('小明')
p2 = Person()
print('p2:', p2)
p2.eat('小红')
构造方法和init方法
1.构造方法
构造方法就是函数名和类名一样的方法，作用是用来创建对象的。
声明类的时候，系统会为这个类创建对应的构造方法
创建对象的过程：调用构造方法在内存中开辟空间创建对象，并且会自动调用__init__方法去对这个对象进行初始化,
最后将创建好的对象的地址返回
2.__init__方法
对象方法
不需要手动调用，创建完对象后，会被自动调用
class Dog:
"""狗"""
def __init__(self):
print(self)
print('init方法')
dog1 = Dog()
print(dog1)
3.带参其他参数的init方法
__init__方法的参数要通过构造方法来传。（构造方法的实参，会传递给init方法的形参）
class Person:
def __init__(self, name='', age=0):
print(name, age)
p1 = Person('小红', '20')
p2 = Person('小明')
p3 = Person(age=20)
对象的属性
类的内容包含属性和方法，属性又分为对象属性和类的字段
属性：用来在类中去保存数据的变量。
对象属性：属性的值会因为对象不同而不一样，这种属性就需要声明成对象属性，例如：人的名字，人的年龄等
对象属性要通过对象来使用
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)
# 声明一个人类，有名字、年龄、性别三个属性。要求创建不同的对象的时候就可以直接确定不同的属性值
class Person2:
def __init__(self, name, age=0, sex='girl'):
self.name = name
self.age = age
self.sex = sex
self.id = '0001'
p1 = Person2('小明', 20, '女')
print(p1.name)
p1.name = 'xiaoming'
print(p1.name)
p1.id = 'p10001'
print(p1.id)
p2 = Person2('小红')
print(p2.name)
对象属性的增删改
class Student:
def __init__(self, name='', age=0, stu_id='001'):
self.name = name
self.age = age
self.stu_id = stu_id
stu1 = Student('小明')
stu2 = Student('小红', 18)
1.查(获取对象属性的值)
方法1:对象.属性 --> 获取指属性的值
print(stu1.name)
# print(stu1.name2) # AttributeError
方法2：getattr(对象, 属性名， 默认值) --> 获取指定属性值，如果设置了默认值当属性不存在的时候不会报错，并且会将默认值作为结果。（如果没有设置默认值，属性不存在还是会报错）
print(getattr(stu1, 'name'))
print(getattr(stu1, 'name2', '张三'))
方法3：对象.__getattribute__(属性名) --> 获取指定属性,属性不存在会报错
print(stu1.__getattribute__('stu_id'))
# print(stu1.__getattribute__('stu_id2'))
2.增/改(给对象添加属性)
注意：给对象添加属性，只能添加到当钱对象中。不会影响当前类的其他对象
方法1：对象.属性 = 值（属性不存在的时候增加，存在的就是修改）
方法2：setattr(对象， 属性名， 属性值)
# 添加
stu1.sex = '男'
print(stu1.sex)
# print(stu2.sex) # AttributeError: 'Student' object has no attribute 'sex'
# 修改
stu1.name = '李四'
print(stu1.name)
# 修改
setattr(stu1, 'name', '娜美')
print(stu1.name)
# 添加
setattr(stu1, 'name2', '宝儿姐')
print(stu1.name2)
3.删(删除对象属性)
注意:删除只删除当前对象的属性，对当前类的其他对象没有影响
方法一：del 对象.属性
方法二：delattr(对象，属性名)
方法三：对象.__delattr__(属性名)
del stu1.age
# print(stu1.age) # AttributeError: 'Student' object has no attribute 'age'
print(stu2.age)
print(stu1.sex)
delattr(stu1, 'sex')
# print(stu1.sex)
stu1.__delattr__('name')
对象的使用
python中所有的数据都是对象，所有的变量存储的都是对象的地址
import copy
num = int(10)
print(num.bit_length())
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.age) + 'score:' + 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('小明', 22, 90), stu3, Student('小红', 10, 98)]
# 找出成绩最好的学生
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)
max2 = max(students, key=lambda item: item.score)
print('max:', max2)
1.根据姓名查找指定学生的信息。2.根据姓名修改指定学生的年龄
name = input('姓名：')
for stu in students:
if stu.name == name:
print(stu)
new_age = input('新年龄：')
stu.age = new_age
print(stu)
break
slot魔法
1.类的字段
属性：对象属性，类的字段
类的字段：声明在类里面，函数外面的变量就是类的字段。
使用的时候通过类来使用：类.字段
2.__slots__:用来约束当前类的对象的属性有哪些
class Dog:
# num就是类的字段
num = 10
__slots__ = ('color', 'name', 'type', 'sex', 'age', 'price')
def __init__(self, color, name, type):
self.color = color
self.name = name
self.type = type
self.sex = 'boy'
print(Dog.num)
Dog.num = 100
print(Dog.num)
dog1 = Dog('黄色', '大黄', '土狗')
dog1.price = 200
# dog1.height = 50
内置类属性
class Person:
"""人类"""
# 类的字段
num = 60
def __init__(self, name, age, sex):
self.name = name
self.age = age
self.sex = sex
def run(self):
print('%s在跑' % self.name)
def __str__(self):
return '{' + self.__class__.__module__ + '.' + self.__class__.__name__ + \
'object at' + hex(id(self)) + '}'
p1 = Person('小明', 18, '男')
1.__name__
类.name --> 获取当前类的名字
print(Person.__name__, type(Person.__name__))
2.doc
类.doc --> 获取类的说明文档
print(Person.__doc__)
print(int.__doc__)
3.__class__
对象.class --> 获取当前对象所对应的类
my_class = p1.__class__
p2 = my_class('小花', 20, '女')
print(p2.name)
print(my_class.num)
4.dict
类.__dict__ --> 获取当前类的所有的字段和其对应的值，以字典的形式返回(了解)
对象.dict --> 获取当前对象所有的属性和其对于的值，以字典的形式返回
print(Person.__dict__)
print(p1.__dict__)
5.__module__
类.__module__ --> 获取当前类所在的模块名
print(Person.__module__)
6.base
类.__base__ --> 获取当前类的父类，返回的是一个元组，元组的元素是类
print(Person.__bases__)
print(p1)
作业
1. 声明一个电脑类
属性：品牌、颜色、内存大小
方法：打游戏、写代码、看视频
a.创建电脑类的对象，然后通过对象点的方式获取、修改、添加和删除它的属性
b.通过attr相关方法去获取、修改、添加和删除它的属性
class Computer:
def __init__(self, brand, color, RAM):
self.brand = brand
self.color = color
self.RAM = RAM
def play_game(self):
print('用%s电脑打游戏' % self.brand)
def write_code(self):
print('用%s电脑写代码' % self.brand)
def watch_video(self):
print('用%s电脑看视频' % self.brand)
# 创建对象
computer1 = Computer('ASUS', 'black', '4G')
computer2 = Computer('DELL', 'white', '8G')
# .方式
print(computer1.brand, '电脑')
computer1.color = 'white'
print('颜色', computer1.color)
computer1.memory = '1T'
print('硬盘：', computer1.memory)
del computer1.color
# attr方式
print(getattr(computer2, 'brand'))
print(getattr(computer2, 'name', '未知属性'))
print(computer2.__getattribute__('RAM'))
setattr(computer2, 'color', 'red')
print(computer2.color)
setattr(computer2, 'memory', '1T')
print(computer2.memory)
delattr(computer2, 'RAM')
computer2.__delattr__('color')
结果：
2.声明一个人的类和狗的类:
狗的属性:名字、颜色、年龄
狗的 法:叫唤
人的属性:名字、 年龄、狗
人的方法:遛狗
a.创建人的对象名字叫小明，让他拥有一条狗 ，然后让小明去遛狗
class Person:
def __init__(self, name, age, dog=''):
self.name = name
self.age = age
self.dog = dog
def walk_the_dog(self):
print('%s 遛他的狗 %s' % (self.name, self.dog.name))
class Dog:
def __init__(self, name, color, age):
self.name = name
self.color = color
self.age = age
def bark(self):
print('汪汪汪')
p1 = Person('小明', 20)
dog = Dog('二哈', 'black_white', 2)
p1.dog = dog
p1.walk_the_dog()
结果：
3.声明一个矩形类:
属性: 长、宽
方法:计算周长和面积
a.创建不同的矩形，并且打印其周长和面积
class Rectangle:
def __init__(self, length, wide):
self.length = length
self.wide = wide
def perimeter(self):
perimeter = 2 * self.length + 2 * self.wide
print('该矩形周长：', perimeter)
return perimeter
def area(self):
area = self.length * self.wide
print('该矩形面积：', area)
return area
rec1 = Rectangle(10, 20)
rec2 = Rectangle(100, 200)
print('矩形1：')
rec1.perimeter()
rec1.area()
print('矩形2')
rec2.perimeter()
rec2.area()
结果：
4.创建一个学生类:
属性:姓名，年龄，学号，成绩
方法:答到，展示学生信息
创建一个班级类: 属性:学生，班级名
方法:添加学生，删除学生，点名, 获取班级中所有学生的平均值， 获取班级中成绩最好的学生
class Student:
def __init__(self, name, age, stu_id, score):
self.name = name
self.age = age
self.stu_id = stu_id
self.score = score
def answer(self):
print('%s答到' % self.name)
def show_information(self):
print('姓名：%s 年龄：%d 学号：%s 成绩：%d' % \
(self.name, self.age, self.stu_id, self.score))
def __str__(self):
return str(self.__dict__)
class Grade:
def __init__(self, grade_name, student=[]):
self.student = student
self.name = grade_name
def add_student(self, *student):
self.student = student
print('添加成功！现有学生信息：')
for student in self.student:
print('姓名:%s 年龄：%d 学号：%s 成绩：%d' % \
(student.name, student.age, student.stu_id, student.score))
def del_studen(self):
del self.student
print('删除成功！')
def checkroll(self):
print('班级点名：')
for stu in self.student:
stu.answer()
def average(self):
print('平均值')
sum1 = 0
index = 0
for stu in self.student:
sum1 += stu.score
index += 1
print(sum1 / index)
def top_score(self):
print('最高分')
max1 = self.student[0].score
for stu in self.student:
if stu.score > max1:
max1 = stu.score
print(stu.score)
def __str__(self):
return str(self.__dict__)
#学生对象
stu1 = Student('小明', 20, '0001', 90)
stu2 = Student('小红', 22, '0002', 85)
stu3 = Student('小花', 23, '0003', 95)
stu1.show_information()
stu2.answer()
#创建班级
grade1 = Grade('py1807')
print(grade1.name)
#添加学生
grade1.add_student(stu1, stu2, stu3)
#点名
grade1.checkroll()
#平均值
grade1.average()
#最高分
grade1.top_score()
#删除学生
grade1.del_studen()
结果：
