一、编程的思想
1.面向过程编程(穷人) -- 算法和逻辑
2.函数式编程(小资) -- 函数
3.面向对象编程(富豪) -- 类和对象
二、类和对象
1.什么是类，什么是对象
类就是拥有相同功能和相同属性的对象的集合(重要) - 抽象的
对象就是类的实例 - 具体的
如果人是类，余婷就是对象，骆昊也是对象
如果车是类，具体的某一辆车才是对象
2.类的声明 - 用代码描述清楚这个类是哪些相同的功能和相同属性的集合
1)语法:
class 类名:
类的说明文档
类的内容
2)说明
class - 声明类的关键字，固定写法
类名 - 程序员自己命名
要求: 标识符，不能是关键字
规范: 见名知义；采用驼峰式命名；首字母大写
类的说明文档 - 用""""""引起来的说明性文字
类的内容 - 用来描述共同的功能和属性
主要包含方法(声明在类中函数)和属性(声明在类中的变量)
"""
student_name -> PEP8 studentName -> 驼峰式命名
class Person:
"""人类"""
def eat(self):
print('人类吃饭')
def sleep(self):
print('人类睡觉')
def thinking(self):
print('思考')
def opertion(self, char):
print()
3.创建对象
语法：
类() - 创建类的对象并且返回
p1 = Person()
同一个类的对象可以有对象
p2 = Person()
p3 = p2
print(id(p1), id(p2))
三、对象方法
1.类中的方法 - 指就是类中共同的功能
方法 - 声明在类中的函数
类中的方法分为三种: 对象方法、类方法、静态方法
2.对象方法
"""
1) 怎么声明: 直接声明在类中的函数就是对象方法
2) 怎么调用: 需要对象来调用; 以'对象.对象方法()'的形式来调用
3) 特点: 自带参数self, 参数self在通过对象调用的时候不用传参; 系统会自动将当前对象传给self传参；
当前对象 - 当前调用这个方法的对象
当前类的对象能做的事情，self都可以做
"""
class Dog:
# eat就是对象方法
def eat(self, food='骨头'):
# self=dog2; food='屎'
print('self:', self)
print('狗吃'+food)
# 对象能做的事情self都能做
self.run()
def run(self):
# self=dog2
print('狗跑步')
dog1 = Dog() # dog1就是Dog的对象
print('dog1:', dog1)
# dog1.eat()
dog2 = Dog()
print('dog2:', dog2)
dog2.eat('屎')
四、init方法和构造方法
1.init方法和构造方法
"""
1） 构造函数 - python中声明类的时候，系统会自动声明一个和类同名的函数(这个函数就是构造函数)；用来创建当前类的对象。
当我们调用构造函数创建对象的时候，系统会自动调用类中的init方法来初始化对象
2) init方法 - init是魔法方法；也是一个对象方法。声明的时候函数名必须是init,并且保证这个方法是对象方法;
声明后不用去调用，系统会自动调用
记住:
a.创建对象的时候系统自动调用init方法
b.创建对象的时候，构造函数需不需要参数，需要几个参数看init除了self以外有没参数，有几个参数
"""
class Person:
def __init__(self):
print('init方法')
p1 = Person()
p2 = Person()
class Student:
def __init__(self, name, age=10):
print('学生类的init', name, age)
# stu1 = Student() # TypeError: __init__() missing 2 required positional arguments: 'name' and 'age'
stu2 = Student('小明', 18)
stu3 = Student(age=20, name='小花')
stu4 = Student('Tom')
五、类中的属性
1.类中的属性 - 就是类中保存数据的变量
"""
类中的属性分为2种：字段、对象属性
"""
2.字段
"""
1）怎么声明: 直接声明在类里面函数外面的变量就是字段
2）怎么使用: 通过类使用； 以'类.字段'的形式去使用
3）什么时候用：不会因为对象不同而不一样的属性就声明成对象属性
"""
3.对象属性
"""
1）怎么声明：声明在init方法中；以 'self.属性名=值' 的形式来声明
2）怎么使用: 通过对象来使用； 以'对象.属性'的形式来使用
3）什么时候用: 会因为对象不同而不一样的属性就声明成对象属性
"""
class Person:
# a就是字段
a = 10
# name和age就是对象属性
def __init__(self):
self.name = '小明'
self.age = 18
# print(a) # NameError: name 'a' is not defined
print(Person.a)
p1 = Person()
print(p1.name, p1.age)
p2 = Person()
print(p2.name, p2.age)
p2.name = '小花'
class Student:
def __init__(self, n, s=0):
self.name = n
self.age = 18
self.score = s
stu1 = Student('小明')
print(stu1.name, stu1.age, stu1.score)
stu2 = Student('小花', 60)
print(stu2.name, stu2.age, stu2.score)
练习： 声明一个狗类，拥有属性：品种、名字、颜色、年龄、性别； 功能: 吃(xxx吃xxx)
class Dog:
def __init__(self, name, bread='土狗', color='黄色', age=1, gender='公狗'):
self.breed = bread
self.name = name
self.color = color
self.age = age
self.gender = gender
def eat(self, food: str):
# self=dog1; food='肉'
print('%s在吃%s' % (self.name, food)) # self.name->dog1.name
dog1 = Dog('大黄')
dog2 = Dog('财财', color='黑色')
dog1.eat('肉')
dog2.eat('骨头')
六、类中的方法
1.类中的方法
"""
类中的方法有3种: 对象方法、类方法、静态方法
1) 对象方法
a. 怎么声明：直接声明在类中的函数
b. 怎么调用：通过对象来调用
c. 特点：自带一个参数self；self在调用的时候不用传参，指向当前对象
self -> 当前对象
d. 什么时候用：如果实现函数的功能需要用到对象属性，这个函数就声明成对象方法
2)类方法
a. 怎么声明：在函数声明前加@classmethod
b. 怎么调用：通过类来调用
c. 特点：自带一个参数cls; cls在调用的时候不用传参，系统会自动将当前类传给cls
cls -> 当前类 (当前类能做的事情cls都可以做)
d. 什么时候用：实现函数的功能不需要对象属性的前提下，需要类
3) 静态方法
a.怎么声明：在函数声明前加@staticmethod
b.怎么调用：通过类来调用
c.特点：没有自带的参数
d.什么时候用：实现函数的功能不需要对象属性的前提下，也不需要类
class Student:
num = 100
def __init__(self, name, tel, age=18):
self.name = name
self.age = age
self.tel = tel
# study是对象方法
def study(self):
print('%s在学习' % self.name)
@classmethod
def func1(cls):
print('cls:', cls)
print('类方法func1')
# print(num) # NameError: name 'num' is not defined
print(Student.num)
# cls可以创建对象
stu2 = cls('小花', '112', 20)
print('stu2:', stu2)
# cls可以使用类的字段
print(cls.num)
@staticmethod
def func2():
print('静态方法func2')
stu = Student('小明', '110')
stu.study()
print('stu:', stu)
print('Student:', Student)
Student.func1()
Student.func2()
class Math:
pi = 3.1415926
@classmethod
def circle_area(cls, r):
return cls.pi * r * r
@staticmethod
def sum(num1, num2):
return num2 + num1
会出现的误区：
class Keng:
num = 100
def func1(self):
print('坑中的对象方法:', self)
@classmethod
def func2(cls):
print('坑中的类方法:', cls)
@staticmethod
def func3():
print('坑中的静态方法')
# 注意: 理论上类中所有方法都可以通过对象或者类调用
# 类调用对象方法
Keng.func1(100) # 用类调用对象方法self会失去意义
k = Keng()
k.func2() # 用对象调用类方法是多此一举，cls还是当前类
Keng.func2()
k.func3()
Keng.func3()
7.对象属性的增删改查
class Person:
def __init__(self, name, age=18, gender='女'):
self.name = name
self.age = age
self.gender = gender
p1 = Person('小明', gender='男')
p2 = Person('小红', 20)
1.获取属性值
- 对象.属性 - 获取对象指定属性的值
- getattr(对象, 属性名:str) - 获取对象指定属性的值
- getattr(对象, 属性名:str, 默认值) - 获取对象指定属性的值
print(p1.name)
# print(p1.name1) # AttributeError: 'Person' object has no attribute 'name1'
print(getattr(p1, 'name'))
# print(getattr(p1, 'name1')) # AttributeError: 'Person' object has no attribute 'name1'
print(getattr(p1, 'name', '无名氏'))
print(getattr(p1, 'name1', '无名氏')) # 无名氏
# attr = input('输入需要获取的属性:')
attr = 'name'
# print(p1.attr)
print(getattr(p1, attr))
2.修改属性和增加属性
"""
1）对象.属性 = 值 当属性存在的时候就是修改；属性不存在的时候是增加
2）setattr(对象, 属性名, 值) 当属性存在的时候就是修改；属性不存在的时候是增加
改
p1.age = 28
print(p1.age)
setattr(p1, 'age', 30)
print(p1.age)
增
p1.height = 180
print(p1.height, getattr(p1, 'height'))
setattr(p1, 'weight', 70)
print(p1.weight)
3.删除对象属性
- del 对象.属性 - 删除对象中指定的属性
- delattr(对象, 属性名) - 删除对象中指定的属性
del p1.name
# print(p1.name) # AttributeError: 'Person' object has no attribute 'name'
delattr(p1, 'age')
# print(p1.age) # AttributeError: 'Person' object has no attribute 'age'
# 注意: 属性的增删改查只针对指定对象有效，不会影响别的对象
print(p2.name)
# print(p2.height) # AttributeError: 'Person' object has no attribute 'height'
八、内置属性
内置类属性 - 声明类的时候系统提供的属性
class Dog:
"""狗类！"""
num = 100
# __slots__是用来约束当前类最多能够拥有的对象属性
__slots__ = ('name', 'age', 'gender', 'height', 'weight', '__dict__')
def __init__(self, name, age=3, gender='公狗'):
self.name = name
self.age = age
self.gender = gender
def func1(self):
print('对象方法', self.name)
@classmethod
def func2(cls):
print('类方法')
@staticmethod
def func3():
print('静态方法')
dog1 = Dog('大黄')
1. 类.name - 获取类的名字
print(Dog)
print(Dog.__name__)
2. 对象.class - 获取对象对应的类(和type(对象)功能一样)
print(type(dog1))
print(dog1.__class__)
3. 类.doc - 获取类的说明文档
print(Dog.__doc__)
print(int.__doc__)
4.dict
# 类.__dict__ - 获取类中所有的字段和字段对应的值，以字典的形式返回
print(Dog.__dict__)
(掌握！) 对象.dict - 获取对象所有的属性和对应的值，以字典的形式返回
注意: 如果设置了slots,对象的dict就不能用
print(dog1.dict)
dog1.height = 180
# dog1.nema = '财财'
# 5.类.__module__ - 获取当前这个类是哪个模块中声明的，返回的是模块名
print(Dog.__module__)
print(int.__module__)
# 6.类.__bases__ - 获取当前类的所有的父类
# object是python的基类
print(Dog.__bases__)
print(Dog.__base__)
