一.类和对象
1.理论定义:类就是拥有相同功能和相同属性的对象的集合(类是抽象的)
对象:类的实例(对象是具体的)
2.生活角度:如果说电脑是一个类，我桌上的这台电脑就是一个对象
如果说车是一个类，具体的一辆车才是它的对象
3.编程思想
面向过程编程：以算法为工具
函数式编程：以函数为工具
面向对象编程：以类和对象为工具（面向生活）
二.类的声明
类是对拥有相同功能(方法)和相同属性的封装,一个类可以对多个功能进行封装.
类的声明格式
class 类名(父类列表):
类的说明文档
类的内容
类中的方法就是声明在类的函数,分为:对象方法,类方法,静态方法
创建对象 构造方法:类名()-->创建类对应的对象
创建类的时候，系统会默认给我们创建这个类对应的构造方法
# 创建一个类
class Person:
"""人类"""
def eat(self):
print('人吃饭')
# 1.创建对象
p1 = Person() # 创建Person类的对象，并且将对象的地址存到p1中
# 一个类可以有多个对象
p2 = Person()
# 只有在调用构造方法的时候才会产生新的对象
# 2.调用对象方法
# 通过对象调用对象方法，默认参数self不需要传参。系统会自动传！
p1.eat()
三.构造方法和init方法
构造方法:系统自动创建,方法名和类名一样,用来创建对象的
init:init方法的功能是用来做初始化和添加对象属性的
当我们通过构造方法去创建对象的时候,系统会自动调用init方法去初始化类的属性(不用主动调用init方法)
创建对象的过程:调用构造方法在内存中开辟空间创建对象,然后用新建的对象去调用init方法来初始化对象的属性,最后才将对象返回
class Person:
# init方法可以添加参数
def __init__(self, name, age=18):
print(name, age)
print('人类的init方法')
# 如果类的init方法有参数，通过给构造方法传参类init方法传参
p1 = Person('小明')
p2 = Person('小红', 20)
p3 = Person(age=21, name='小花')
#小明 18 小红 20 小花 21
四.对象属性
类中的内容包括:属性和方法
属性是保存值的
属性分为对象的属性和类的属性,类的属性称为类的字段.属于类的,所有的对象对应的值是一样的.
对象的属性根据对象的不同,对应的值不同.对象属性是声明在init方法中的,声明格式为:self.属性名=初值,对象属性的使用:对象.属性名
#(1)没有参数,必须固定
class Student:
"""学生类"""
def __init__(self):
#声明对象属性name,age,id
self.name = '张三'
self.age = 22
self.id = '001'
#stu1就是Student类的对象
stu1=Student()
#通过对象去使用对象的属性
print(stu1.name,stu1.age,stu1.id)
#通过对象去修改对象的属性
stu1.name = '小雨'
print(stu1.name)
#(2)有参数
class Dog:
"""狗类"""
#创建Dog的对象时,必须传类型和颜色
def __init__(self,type1,color1):
self.type = type1
self.color = color1
dog1 = Dog('土狗','黄色')
print(dog1.type,dog1.color)
dog2 = Dog('斗狗','黑色')
print(dog2.type,dog2.color)
#(3)有参数,默认值,创建对象时,可以让属性使用默认值,也可以使用自己传的值
class Computer:
"""电脑类"""
def __init__(self,color='白色',memory=0):
self.color=color
self.memory=memory
comp1 = Computer()
print(comp1.color,comp1.memory)
comp2 = Computer('黑色',512)
print(comp2.color,comp2.memory)
五.对象属性的增删改查
python是动态语言，python中类的对象的属性可以进行增删的操作
class Person:
def __init__(self,name1='张三'):
self.name=name1
self.age=18
self.height=160
p1 = Person()
p2 = Person()
1.查(获取属性的值)
方法一: 对象.属性
print(p1.name)
# print(p1.name2) # 属性不存在会报错
方法二: def getattr(对象, 属性名, 默认值)
print(getattr(p1, 'age'))
# print(getattr(p1, 'age2')) # 属性不存在会报错print(getattr(p1, 'age2', 0)) # 属性不存在可以通过设置默认值，让程序不崩溃，并且返回默认值
方法三：对象.getattribute(属性名)
height = p1.__getattribute__('height')
print(height)
2.改(修改属性的值,属性值存在)
方法一：对象.属性 = 新值
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', 45)
print(p1.weight)
方法三: 对象.setattr(属性名, 值)
p1.__setattr__('color', '绿色')
print(p1.color)
4.删(删除对象属性)
注意:删除只针对指定的对象
方法一:del 对象.属性
del p1.name
方法二:def delattr(对象,属性名)
delattr(p1,'age')
方法三:对象.delattr(属性名)
p1.__delattr__('height')
print(p2.name,p2.age)
六.对象方法
1.对象方法
直接声明在类的函数默认就是对象方法,有一个默认参数self
调用:对象.对象方法()
对象方法中默认参数self,不需要传参。因为在调用这个方法的时候系统会自动将当前对象传给self。
哪个对象调用的方法，self就指向谁
练习1：写一个矩形类，有长和宽，有两个功能，分别是求周长和面积
class Rectangle:
def __init__(self, length1, width1):
self.length = length1
self.width = width1
# 对象方法是否需要额外参数，看实现函数的功能需不需要除了对象属性以外的其他的数据
def area(self):
return self.length * self.width
def perimeter(self):
return (self.length + self.width) * 2
练习2：写一个班级类，班级里面有多个学生的成绩(一门)，班级名, 可以获取班级成绩中的最高分
class Class:
"""班级类"""
def __init__(self, name):
self.scores = []
self.name = name
def highest_score(self):
if not self.scores:#判断是否为空
return 0
# max(序列) ---> 获取序列中元素的最大值
# min(序列) ---> 获取序列中元素的最小值
return max(self.scores)
class1 = Class('python1806')
class1.scores = [23, 45, 77, 54, 89, 90, 34]
print(class1.highest_score())
七.类的字段
类的属性叫类的字段
类的字段就是声明在类里面,方法外面的变量
属于类的，对于这个类的所有的对象来说其值是共有的,这样的属性声明成类的字段
使用:类.字段
练习：写一个球类，用一个属性来保存这个类的创建对象的个数
class Ball:
count = 0
def __init__(self):
Ball.count += 1
# 每次创建球的对象都会调用init方法，所以init方法调用的次数就是Ball创建的对象的个数
class Person:
# 这个number就是类的字段
number = 61
# 通过类获取类的字段的值
print(Person.number)
八.类的方法
类的方法分为三类:对象方法,类方法和静态方法
1.对象方法(实例方法)
声明的形式:直接声明在类里
特点:自带一个不需要主动传参的默认参数self,谁来调用指向谁
调用:通过对象来调用
class Class1:
# 类字段
number = 100
# 声明一个对象方法
def object_func(self):
print('对象方法')
c1 = Class1()
# 调用对象方法
c1.object_func()
#对象方法
2.类方法
声明的形式:声明方法前需使用@classmethod说明
特点:自带一个默认参数cls,这个参数在调用的时候不需要传值,系统自动传给他.谁调用就指向谁，始终指向当前类
调用:通过类来调用--->类.类方法()
class Class1:
# 类字段
number = 100
# 声明一个类方法
@classmethod
def class_func(cls):
# 通过cls去使用类的字段
print('cls:', cls.number)
# 通过cls去创建对象
tc = cls()
tc.object_func()
print('这是一个类方法')
# 调用类方法
Class1.class_func()
#cls: 100
#对象方法
#这是一个类方法
3.静态方法
声明的形式:声明方法前需要使用@staticmethod说明
特点:没有默认的参数
调用:通过类来调用---->类.静态方法()
class Class1:
# 类字段
number = 100
@staticmethod
def static_func():
print('这是一个静态方法')
# 调用静态方法
Class1.static_func()
#这是一个静态方法
4.4.遇到问题怎么来选择使用哪种方法：
a.只要实现方法的功能需要用到对象的属性，我们就使用对象方法
b.不使用对象方法的前提下，如果实现功能需要用到类的字段就使用类方法
c.实现功能既不需要对象的属性，又不需要类的字段就使用静态方法
注意：静态方法和类方法划分不用那么严格，静态方法能做的类方法可以做，反之亦然
