01-类和对象
1.理论上的定义
类：就是拥有相同功能和相同属性的对象的集合 （类是抽象）
对象：类的实例（对象是具体的）
2.从生活的角度
如果说人是一个类，马云就是一个对象
如果说电脑是一个类，我桌上的这台电脑就是一个对象
如果说车是一个类，具体的一辆车就是一个对象
3.编程思想
面向过程编程：以算法为工具
函数式编程:以函数为工具
面向对象编程：以类和对象为工具（面向生活）
02-类的声明
类：对拥有相同功能（方法）和相同属性（属性）的封装
封装效果：一个类中可以对多个功能进行封装（多个函数），对多个属性进行封装
1.类的声明格式
class 类名（父类列表）：
——类的说明文档
——类的内容
2说明：
class：声明类的关键字
类名：标识符，不能是关键字。驼峰式命名（第一个单词首字母小写，其它的单词首字母大写），首字母大写！！！，见名知义
例如：Person、StudentSystem
(父类列表)：括号与括号里的内容可以省略，这个是继承语法
冒号：固定的
类的内容：包括类的方法和类的属性
3.类中的方法
方法：声明在类中的函数
a.对象方法：对象方法需要对象来调用，对象，函数名（）
直接写在类中的方法，自带一个self参数
b.类方法
c.静态方法
4.创建对象
创建类的时候，系统会默认给我们创建这个类对应的构造方法
构造方法：类名（）--》创建类对应的对象
# 创建一个类
class Person:
'''人类'''
def eat(self):
print('人吃饭')
if __name__ == '__main__':
# 创建对象
p1 = Person() # 创建Person类的对象，并且将对象地址存到p1中
# 一个类可以有多个对象
p2 = Person()
# 只有在调用构造方法的时候才会产生新的对象
p3 = p2
print(id(p1),id(p2),id(p3))
# 2.调用对象
# 通过对象调用对象方法，默认参数self不需要传参，系统自动传参
p1.eat()
03-构造方法和init方法
1.构造方法：系统自动创建，方法名和类名一样，用来创建对象
2.init:init方法的功能是用来做初始化和添加对象属性的
当我们通过构造方法去创建对象的时候，系统会自动调用init方法(不用主动调用init方法)
class Dog:
def __init__(self):
print('init方法')
class Person:
# init方法可以添加参数
def __init__(self,name,age = 18):
print(name,age)
print('人类的init方法')
if __name__ == '__main__':
# 创建对象的过程：调用构造方法在内存中开辟空间创造一个对象，然后用新建的这个对象去调用init方法，
# 来初始化对象的属性，最后才将对象返回
dog1 = Dog()
dog2 = Dog()
# 如果类的init方法有参数，通过给构造方法传参类init方法传参
p1 = Person('小明')
p2 = Person('小红',20)
p3 = Person(age = 20,name = '东东')
04-对象属性
类中的内容：属性和方法
1.属性:(保存值的)
a.对象的属性：不同的对象，对应的值可能不一样，这样的属性就是对象属性属于对象
类中的对象属性是声明在init方法中的，并且声明格式：self.属性名 = 初值
对象属性的使用:对象，属性名
b.类的字段：属于类的，所有的对象对应的值是一样的
2.方法：(保存功能的)
a.对象方法
b.类方法
c.静态方法
class Student:
'''学生类'''
def __init__(self):
# 声明对象属性name,age,id
self.name = '李青'
self.age = 0
self.id = '001'
class Dog:
'''狗类'''
# 创建Dog的对象的时候，必须传类型和颜色
def __init__(self,type1,color1):
self.type = type1
self.color = color1
class Computer:
'''电脑类'''
# 创建对象的时候可以使用默认值，也可以使用自己传的值
def __init__(self,color= '白色',memory= 0):
self.color = ''
self.memory = 1000
class rectangle:
def __init__(self,long= 100,width= 50):
self.long = long
self.width = width
if __name__ == '__main__':
# stu1就是Student类的对象
stu1 = Student()
# 通过对象去使用对象的属性
print(stu1.name,stu1.age,stu1.id)
# 通过对象去修改对象的属性
stu1.name = 'SB'
print(stu1.name)
dog1 = Dog('土狗','黄色')
print(dog1.type,dog1.color)
dog2 =Dog('斗狗','黑色')
print(dog2.type,dog2.color)
comp1 = Computer()
print(comp1.color,comp1.memory)
comp2 = Computer('黑色',512)
print(comp2.color,comp2.memory)
sq = rectangle()
print(sq.long,sq.width)
sq = rectangle(10,5)
print(sq.long,sq.width)
05-对象属性的增删改查
Python是动态语言，Python中类的对象的属性可以进行增删的操作
class Person:
'''人类'''
def __init__(self):
self.name = '李四'
self.age = 18
self.height = 160
1.查
方法一：对象.属性
方法二：def getattr(对象，属性名，default=None)
方法三：对象._ getattribute _('height')
print(p1.name)
# print(p1.nmae2) # 属性不存在会报错
print(getattr(p1,'age2',0)) # 属性不存在可以通过设置默认值，让程序不崩溃，并且返回默认值
height = p1.__getattribute__('height')
print(height)
2.改（修改属性的值，属性存在）
方法一：对象.属性 = 新值
p1.name = '张三'
print(p1.name)
方法二：def setattr(对象，属性名，新值）
setattr(p1,'age',20)
print(p1.age)
方法三：对象._ setattr _(属性名，新值）
p1.__setattr__('height',170)
print(p1.height)
3.增（增加属性）
注意：添加只能给某一个对象添加对应的属性
方法一：对象.属性 = 新值
p1.sex = '女'
print(p1.sex)
方法二：def setattr(对象，属性名，新值)
setattr(p1,'weight',55)
print(p1.weight)
方法三：对象.setattr(属性名，新值)
p1.__setattr__('color', '绿色')
print(p1.color)
# print(p2.sex) # 添加只影响一个对象
4.删（删除对象属性）
注意：删除只针对指定的对象
方法一：del 对象.属性
del p1.name
# print(p1.name) 可行
方法二：delattr(对象，属性名)
delattr(p1,'age')
# print(p1.age) 可行
方法三：对象._ delattr _(属性名）
p1.__delattr__('height')
# print(p1.height) 可行
print(p2.name,p2.age)
06-对象方法
1.对象方法：
a.什么样的方法是对象方法：直接声明在类里面的函数默认是对象方法，有一个默认参数self
b.对象方法要通过对象来调用：对象.对象方法（）
c.对象方法中的默认参数self不需要传参，因为在调用这个方法的时候，
系统会自动将当前对象传给self，那个对象调用方法，self就指向谁
import math
class Circle:
'''圆类'''
def __init__(self,radius1):
self.radius = radius1
# 声明了一个对象方法area
# 在这，self就是调用area方法的对象，对象能做的事情，self都可以做
def area(self):
# print(id(self))
# print('求圆的面积')
return math.pi * self.radius **2
- 练习1：写一个矩形类，有属性长和宽,有两个功能，分别是求周长和面积
class Rectangle:
'''矩形类'''
def __init__(self,long,width):
self.long = long
self.width =width
# 对象方法是否需要额外参数，看实现函数的功能需不需要除了对象属性以外的其他数据
def area(self):
return self.long * self.width
def perimeter(self):
return (self.width + self.long) *2
- 练习2：写一个班级类，班级里面有多个学生的一门成绩，班级名，可以获取班级成绩中的最高分
class Grade:
'''班级类'''
def __init__(self,class_name,*grade):
self.class_name = class_name
self.grade = grade
# self.grade = []
def top_score(self):
# if not self.grade:
# return None
# max（序列）----》获取序列中元素的最大值
# min (序列）----》获取序列中元素的最小值
return max(self.grade)
if __name__ == '__main__':
c1 = Circle(3)
print(id(c1))
print('c1的面积',c1.area())
c2 = Circle(5)
print('c2的面积', c2.area())
g1 = Grade('python1806',90,80,70)
print(g1.class_name)
print(g1.top_score())
g2 = Rectangle(10,5)
print(g2.area())
print(g2.perimeter())
07-类的字段
1.类的属性叫类的字段
a.什么是类的字段
类的字段就是声明在类的里面，方法的外面的变量
b.什么样的属性声明成类的字段：
属于类的，对于这个类的所有的对象来说，其值是一样的
c.怎么使用
通过类使用：类.字段
class Person:
# number就是类的字段
number = 10
练习：写一个球类，用一个属性来保存这个类的创建对象的个数
class Ball:
count = 0
# 每次创建球的对象都会调用init方法，所以调用init方法的次数就是Ball创建的对象的个数
def __init__(self):
Ball.count += 1
ball1 = Ball()
ball2 = Ball()
print(Ball.count)
if __name__ == '__main__':
# 通过类获取类的字段的值
print(Person.number)
Person.number = 70
print(Person.number)
08-类的方法
类中的方法
- 1.对象方法（实例方法）
声明的形式：直接声明在类中
特点：自带一个不需要主动传参的默认参数self，谁来调用指向谁 - 2.类方法
声明形式：声明方法前需要使用@classmethod
特点：自带一个参数cls,这个参数调用的时候不需要传值，系统自动传值，谁调用，传给谁！始终指向当前类
调用：通过类调用---》类.类方法（） - 3.静态方法
声明的形式：声明方法前需要使用@staticmethod说明
特点：没有默认参数
调用：通过类来调用--》类.静态方法（）
class Class1:
# 类字段
number = 10
# 声明一个对象方法
def object_func(self):
print('对象方法')
# 声明一个类方法
@classmethod
def class_func(cls):
# 通过cls去使用类的字段
print('cls:',cls.number)
# 通过cls去创建对象
tc =cls()
tc.object_func()
print('这是一个类方法')
@staticmethod
def static_func():
print('这是一个静态方法')
c1 = Class1()
# 调用对象方法
c1.object_func()
print(Class1.number)
# 调用类方法
Class1.class_func()
# 调用静态方法
Class1.static_func()
4.遇到问题怎么来选择使用那种方法：
- a.大前提：只要实现方法的功能需要用到对象的属性，我们就使用对象方法，否则就使用静态方法或者类方法
- b.不使用对象方法的前提下，如果实现功能需要类的字段就使用类方法
- c.实现功能既不需要对象的属性，又不需要类的字段就使用静态方法
注意：静态方法和类方法划分不严格，静态方法能做的，类方法可以做，反之成立
class Person:
# 类的字段，存储人类数量
number = 61
@classmethod
def show_number1(cls):
print('人类的数量是：%d亿'% cls.number)
@staticmethod
def show_number2():
print('人类的数量是：%d亿'% Person.number)
Person.show_number1()
Person.show_number2()