一、类和对象
1.什么是类、什么是对象
“”"
类就是拥有相同属性和相同功能的对象的集合(抽象)
对象就是类的实例(具体)
从生活的角度:
如果人是类, 余婷就是对象,骆老师是另一个对象
如果杯子是类,我桌上的这个杯子就是对象
“”"
2.定义类(说清楚共同属性和功能是哪些)
“”"
语法:
class 类名:
类的说明文档
类的内容(包含属性和方法)
说明:
class - 关键字
类名 - 程序员自己命名
要求:标识符,不能是关键字
规范:驼峰式命名,并且首字母大写;见名知义;不适用系统的函数名、类名、模块名
类的说明文档 - 用"""""“引起来的说明性文字,主要说清楚类提供了哪些属性和哪些功能
类的内容 - 主要包含属性和方法(定义在类中的函数叫方法)
“””
PEP8命名规范
student_name = '张三'
驼峰式命名
studentName = '李四'
定义一个人类
class Human:
"""人类"""
def eat(self):
print('人类在吃饭')
def sleep(self):
print('人类睡觉!')
class Servant:
"""佣人类"""
def wash(self):
print('洗衣服')
def cook(self, food):
print(f'做{food}')
3.定义对象(创建对象)
“”"
语法:
类名()
说明:
类名 - 是已经定义好的类的类名
“”"
p1 = Human() # 创建人类的对象p1
p2 = Human()
print(p1)
print(p2)
s1 = Servant() # 创建佣人类的对象s1
print(s1)
s2 = Servant()
s1.wash()
s2.wash()
s1.cook('面条')
s2.cook('包子')
二、方法
1.方法(定义在类中函数)
“”"
类中的方法分为三种:对象方法、类方法、静态方法
1)对象方法
怎么定义:直接定义在类中函数就是对象方法
特点:自带参数self(self在通过对象调用的时候不用传参, 系统会自动将当前对象传给self),谁调用指向谁
怎么调用:用对象去调用(对象.方法名())
2)类方法
怎么定义: 定义函数前加装饰器 @classmethod
特点:自带参数cls(cls在通过类调用的时候不用传参,系统会自动将当前类传给cls)
怎么调用:用类调用(类.方法名())
3)静态方法
怎么定义: 定义函数前加装饰器 @staticmethod
特点:没有默认参数
怎么调用:用类调用
4)对象方法、类方法和静态方法怎么选:
如果实现函数的功能需要用到对象的属性,就选对象方法
“”"
class Dog:
# eat是对象方法
def eat(self):
# self = dog1
print(f'self:{self}')
print('狗啃骨头')
# count是类方法
@classmethod
def count(cls):
# Dog能做的cls都能做
print(f'cls:{cls}')
dog2 = Dog()
dog3 = cls()
print(dog2, dog3)
print('狗的数量是: 100')
@classmethod
def func(cls):
print('类方法')
# func2是静态方法
@staticmethod
def func2():
print('静态方法')
创建对象
dog1 = Dog()
print(f'dog1:{dog1}')
用对象调用对象方法
dog1.eat()
用类调用类方法
Dog.count()
用类调用静态方法
Dog.func2()
print('=========================注意:======================')
#从本质上讲,类中的所有的方法都可以用对象和类调用,但是不能这么做
Dog.eat(12) # 如果用类调用对象方法,self就会变成普通的参数,没有存在的价值
dog1 = Dog()
dog1.count() # 用对象调用类方法的时候cls指向的还是类(不会指向对象)
dog1.func2()
Dog.func2()
三、_ _ init _ _ 方法
1.构造方法
“”"
构造方法: 函数名和类名是一样的,用来创建对象的方法就是构造方法(Python中的构造方法,在定义类的时候系统已经自动创建好了)
“”"
2.init方法
“”"
_ _ init _ _ 方法又叫初始化方法,用来在创建对象的是对对象进行初始化操作的。
当我们通过类创建对象的时候,系统会自动调用_ _ init _ _方法来对象创建出来的对象进行初始化。
调用构造方法创建对象的时候需不需要参数,需要几个,看被自动调用的_ _ init _ _
“”"
class Person:
def _ _ init _ _(self, a, b):
print('初始化方法:', a, b)
print(f'self:{self}')
p1 = Person(10, 20)
print(p1)
#p2 = Person(a=100, b=200)
#p2 = Person()
“”"
def Person(*args, **kwargs):
对象 = 申请空间创建对象
对象._ _ init _ _(*args, **kwargs)
return 对象
“”"
四、对象属性
1.属性: 对象属性和类属性
“”"
对象属性: 对象属性的值会因为对象不同而不一样
a.定义在init方法中
b.以 self.属性名 = 值
c.通过 对象.属性名 的方式使用属性
“”"
class Person:
def _ _ init _ _(self, name1, age1, gender1='男'):
self.name = name1
self.age = age1
self.gender = gender1
def eat(self):
print(f'{self.name}吃饭')
p1 = Person('小明', 1)
print(p1.name, p1.age, p1.gender)
p2 = Person('小花', 3, '女')
print(p2.name, p2.age, p2.gender)
p2.name = '大花'
print(p2.name)
p1.eat()
p2.eat()
五、类属性
类中的属性:对象属性、类属性(类的字段)
“”"
1)类属性
直接定义在类中的变量就是类属性
类属性的值不会因为对象不同而不一样
2)对象属性
通过 self.属性名 = 值 定义在init函数中的属性
对象属性的值会因为对象不同而不一样
“”"
class Person:
num = 61
x = 100
print(Person.num)
Person.num = 60
六、对象属性的增删改查
python中类的对象的属性支持增删改查
class Student:
def __init__(self, name, age=0, gender='男', score=0):
self.name = name
self.age = age
self.gender = gender
self.score = score
def __repr__(self):
return f'<{str(self.__dict__)[1:-1]}>'
stu1 = Student('小明')
stu2 = Student('小花', gender='女')
1.查(获取属性的值)
“”"
对象.属性 - 获取对象指定属性对应的值;属性不存在会报错
getattr(对象, 属性名) - 获取对象指定属性对应的值;属性不存在会报错
getattr(对象, 属性名, 默认值) - 获取对象指定属性对应的值; 属性不存在不会报错,并且返回默认值
“”"
print(stu1.name)
#print(stu1.name1) # AttributeError: 'Student' object has no attribute 'name1'
print(getattr(stu1, 'name')) # 小明
print(getattr(stu1, 'age')) # 0
#print(getattr(stu1, 'name1')) # AttributeError: 'Student' object has no attribute 'name1'
print(getattr(stu1, 'name', '无名氏')) # 小明
print(getattr(stu1, 'name1', '无名氏')) # 无名氏
#根据输入的内容获取对象属性的值
#name -> 小明
#age -> 0
#value = input('请选择(name,age,gender,score):')
#print(getattr(stu1, value))
2.改、增
“”"
对象.属性 = 值 - 当属性不存在就给对象添加属性,属性存在的时候就修改指定属性的值
setattr(对象, 属性名, 值) - 当属性不存在就给对象添加属性,属性存在的时候就修改指定属性的值
“”"
属性存在是修改
stu1.name = 'xiaoming'
print(stu1)
stu1.height = 180
print(stu1) # <'name': 'xiaoming', 'age': 0, 'gender': '男', 'score': 0, 'height': 180>
print(stu1.height)
setattr(stu1, 'age', 18)
print(stu1) # <'name': 'xiaoming', 'age': 18, 'gender': '男', 'score': 0, 'height': 180>
setattr(stu1, 'weight', 80)
print(stu1) # <'name': 'xiaoming', 'age': 18, 'gender': '男', 'score': 0, 'height': 180, 'weight': 80>
print(stu2) # <'name': '小花', 'age': 0, 'gender': '女', 'score': 0>
3.删
“”"
del 对象.属性 - 删除对象中指定的属性
delattr(对象, 属性名) - 删除对象中指定的属性
“”"
del stu2.age # <'name': '小花', 'gender': '女', 'score': 0>
print(stu2)
delattr(stu2, 'gender')
print(stu2) # <'name': '小花', 'score': 0>
七、内置属性
#python在定义类的时候系统自动添加的属性(从基类中继承下来的属性)就是内置属性
class Student:
def __init__(self, name, age=18, score=0):
self.name = name
self.age = age
self.score = score
class Dog:
# 类属性
num = 100
# 对象属性
def __init__(self, name, age=1, color='白色'):
self.name = name
self.age = age
self.color = color
# 方法
def eat(self, food):
print(f'{self.name}在吃{food}')
@classmethod
def show_num(cls):
print(f'狗的数量:{cls.num}')
@staticmethod
def bark():
print('狗嗷嗷叫~')
def __repr__(self):
c = self.__class__
m = c.__module__
return f'<{m}模块.{c.__name__}类的对象: name={self.name},age={self.age},color={self.color}>'
dog1 = Dog('大黄')
#print(dog1)
#1. __module__
"""
类属性;
类.__module__ - 获取定义的模块的模块名
"""
print(Dog.__module__)
print(int.__module__)
#2.__class__
"""
对象.__class__ - 获取对象对应的类
"""
c = dog1.__class__
print(c)
print(type(dog1))
print(Dog)
#3.__name__
"""
类.__name__ - 获取类名
"""
print(Dog.__name__) # 'Dog'
# 重写 repr 方法, 要求以: <xxx模块.xxx类的对象: 属性1=值1,属性2=值2>
# 4.__dict__
"""
类.__dict__ - 将类转换成字典(类的类属性名作为key,类属性的值作为值)
对象.__dict__ - 将对象转换成字典(对象属性名作为key,属性的值作为值)
"""
print(Dog.__dict__)
print(dog1.__dict__)
# 5. __doc__
"""
类.__doc__ - 获取类的说明文档
"""
print(list.__doc__)
# 6.__base__、__bases__
"""
类.__base__ - 获取当前类的父类
类.__bases__ - 获取当前类所有的父类
"""
print(Dog.__base__) # <class 'object'>
print(Dog.__bases__) # (<class 'object'>,)
# 7. __slots__
class Person:
# __slots__可以约束当前类的对象能够拥有哪些对象属性
__slots__ = ('name', 'age', 'height')
def __init__(self, name, age=10):
self.name = name
self.age = age
p1 = Person('小明')
# p1.name1 = 'xiaoming'
p1.height = 180
# 注意: 如果给类属性__slots__赋值了,那么这个类的对象不能再使用__dict__属性
# print(p1.__dict__)
八、私有化
1.访问权限(针对属性和方法)
“”"
公开的:在类的内部和外部都可以使用,也能被继承
保护的:在类的内部可以使用,类的外部不能使用,可以被继承
私有的:只能在类的内部使用,不能被继承
严格来说,python中所有的属性和方法都是公开的,这儿说的私有化其实是假的私有化
“”"
class Person:
num = 100
__num2 = 61
def __init__(self):
self.name = '小明'
self.age = 10
self.__gender = '男'
def eat(self):
print(f'{self.name}在吃饭')
print(self.__gender)
p1 = Person()
print(Person.num)
print(p1.name, p1.age)
p1.eat()
# print(p1.__gender)
# print(Person.__num2)
# 私有化的原理:
print(p1.__dict__) # {'name': '小明', 'age': 10, '_Person__gender': '男'}
print(p1._Person__gender)
九、getter和setter
#1.getter和setter的作用
“”"
getter作用:在获取某个属性值之前想要做别的事情,就给这个属性添加getter
setter作用:在给属性赋值之前想要做别的事情,就给这个属性添加setter
“”"
#2.怎么添加getter和setter
“”"
-
getter
第一步:在需要添加getter的属性名前加_
第二步:定义getter对应的函数(1.需要@property装饰器 2.函数名就是不带_的属性名 3.函数需要一个返回值)
第三步:获取属性值的通过: 对象.不带_属性名 (本质就是在调用getter对应的函数,取到属性值就是函数的返回值) -
setter
如果想要给属性添加setter必须先给属性添加getter
第一步:添加getter
第二步:定义setter对应的函数 (1.需要 @getter函数名.setter 装饰器 2.函数名就是不带_的属性名 3.需要一个参数不需要返回值,这个参数就是尝试给属性赋的值)
第三步:给属性赋值:对象.不带_属性名 = 值 (本质就是在调用setter对应的函数)
“”"
class Rect:
def __init__(self, length=0, width=0):
self.length = length
self.width = width
self._area = length*width
@property
def area(self):
print('area属性值被获取')
self._area = self.width * self.length
return self._area
@area.setter
def area(self, value):
# print(f'value:{value}')
# self._area = value
raise ValueError
r1 = Rect(4, 5)
print('==========')
print(r1.area)
print('++++++++')
# 不能让矩形直接修改面积属性值
# r1.area = 100
# print(r1.__dict__)
#
r1.width = 10
print(r1.area)
r1.length = 10
print(r1.area)
r1.area = 80