1.面向对象编程
编程思想：
1.面向过程编程-->算法，逻辑(数学逻辑)
2.函数式编程-->函数，模块
3.面象对象编程-->类和对象（生活逻辑）
2.类的声明
1.什么是类
类-->是拥有相同属性和相同功能的对象的集合（抽象的）
对象--> 就是类的实例（具体的）
从生活的角度来但类和对象
如果说电脑是一个类，我桌上的这台mac就是类
如果水杯是一个类，具体的某个水杯才是这个类的对象
如果车是一个类，汽车，自行车，摩托车等这些是这个类子类，具体某一辆车才是对象
2.类的声明
格式：
class 类名（父类列表）：
类的说明文档
类的内容
说明：
class-->python中声明类的关键字
类名-->标识符，不能是关键字；类名使用驼峰式命名，并且首字母大写,见名之义
驼峰式命名：如果一个名字由多个单词组成，第一个单词首字母小写，后面每个单词首字母都要大写
UserName
PEP8命名规范：如果一个名字由多个单词组成，所有字母小写，多个单词用下划线隔开
user_name
（父类列表）-->继承语法，让声明的类继承括号中的父类，这个结构可以省略，让当前类继承Python的基类（object）
:-->固定结构
类的说明文档-->注释，对类进行说明
类的内容--> 包含属性（变量）和方法（函数）
方法：声明在类中的函数
声明人person类，吃饭和睡觉
class Person:
"""人类"""
def eat(self):
print('吃饭')
def sleep(self):
print('睡觉')
3.对象的声明
格式：
对象名 = 类名（）
对象名-->变量名
类名-->必须是声明过的类
声明了perosn类的对象p1
p1 = (Person)
3.对象方法
类的内容包含属性和方法，方法分为对象方法，类方法和静态方法
对象方法：直接声明在类中的函数就是对象方法，对象方法都有一个默认参数self，通过对象来调用
对象调用：对象，方法名（）。调用对象方法的时候不需要给默认参数self传参，
系统会自动将当前对象传递给self
self:谁调用当前对象方法，self就指向谁,self就是当前类的对象，类的对象能做的事情self都能做
class Person:
def eat(self,name):
print('self':self)
print('吃饭')
self.sleep()
def sleep(self):
print('s_self'.self)
print('睡觉')
声明对象
p1 = （Person）
print('p1:'p1)
p1.eat=('小明')
4.构造方法和init方法
1.构造方法
构造方法就是函数名和类名一样的方法，作用是用来创建对象的。
声明类的时候，系统会自动为这个类创建对应构造方法
创建对象的过程：调用构造方法在内存中开辟空间创建对象，并且会自动调用init方法去对这个对象进行初始化,
最后将创建好的对象的地址返回
2.init方法
对象方法
不需要手动调用，创建完对象后，会被自动调用
class Dog:
"""狗类"""
def __init__(self):
def __init__(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)
5.对象的属性
类的内容包含属性和方法，属性又分为对象属性和类的字段
属性：用来在类中去保存数据的变量。
对象属性：属性的值会因为对象不同而不同，这种属性就需要声明成对象属性，例如：人的名字，人的年龄等
对象属性要通过对象来使用
1.对象属性的声明
a.必须声明在init方法中
b.声明格式：self.属性 = 初值
2.使用对象属性: 对象.属性
声明一个人类，要求有名字，年龄和性别属性
class Person:
"""人类"""
def __init__(self):
self.name = '小王'
self.age = 18
self.sex = '男'
p1 = Person()
print(p1.name)
3.创建对象的时候可以给对象属性赋值
声明一个人类，有名字、年龄、性别三个属性。要求创建不同对象的时候就可以直接确定不同属性值
class Person:
def __init__(self, name, age, sex):
self.name = name
self.age = age
self.sex = sex
p1 = Person('小明', 20, '男')
print(p1.name)
p1.name = '小红' #修改属性的值
print(p1.name)
p2 = Person('小花', 18, '女')
print(p2.name)
6.对象属性的增删改查
方法1：对象.属性 --> 获取指定属性值，属性不存在会报错
方法2：getattr(对象, 属性名, 默认值) -> 获取指定属性值，如果设置了默认值当属性不存在的时候不会报错，
并且会将默认值作为结果。(如果没有设置默认值，属性不存在还是会报错)
方法3：对象.getattribute(属性名) -> 获取指定属性值.属性不存在会报错
class Student:
def __init__(self, name = '', age = 0, sex = '男'):
self.name = name
self.age = age
self.sex = sex
stu1 = student('小明')
stu2 = student(('小花', 18, '女'))
print(stu.name)
print(getattr(stu1,'name'))
print(getattr(stu1,'name1','小明'))
print(stu1.__getattribute__('sex'))
2.增/改(给对象添加属性)
注意：给对象添加属性，只能添加到当前对象中。不会影响当前类的其他对象
方法1：对象.属性 = 值 (属性不存在的时候增加,存在的是就是修改)
方法2：setattr(对象,属性名,属性值)
方法3：对象.setattr(属性名,属性值)
class Student:
def __init__(self, name, age, sex):
self.name = name
self.age = age
self.sex = sex
stu1 = student('小明')
stu2 = student(('小花', 18, '女'))
stu1.score = 90 #添加
print(stu1.score)
stu1.name = '小红' #修改
print(stu1.name)
setattr(stu1,'name','小吴') #修改
print(stu1.name)
setattr(stu1,'name1', '张三') #添加
print(stu1.name1)
3.删(删除对象属性)
注意：删除只删除当前对象的属性，对当前类的其他对象没有影响
方法一：del 对象.属性
方法二：delattr(对象, 属性名)
方法三: 对象.delattr(属性名)
class Student:
def __init__(self, name, age, sex):
self.name = name
self.age = age
self.sex = sex
stu1 = student('小明')
stu2 = student(('小花', 18, '女'))
del stu1.age
print(stu1.age)
delattr(stu1,'name')
print(stu1.name)
stu1.__delattr__('sex')
print(stu1.sex)
7.对象的使用
import copy
python中所有的数据都是对象，所有的变量存储的都是对象的地址
num = int(1000)
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__
1.将对象给别的变量赋值
stu1 = Student('xiaoHua', 18, 90)
stu2 = stu1 # 赋对象地址
stu3 = copy.copy(stu1) # 产生新的对象，将新的地址赋值
stu1.name = '张三'
print(stu2.name)
print(stu3.name)
2.将对象作为列表的元素
找到列表students中成绩最好的学生的名字
students = [Student('小明', 23, 89), stu3, Student('小红', 10, 67)]
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)
max1 = max(students, key=lambda item: item.score)
print('max:',max1)
1.根据姓名查找指定学生的信息。2.根据姓名修改执行的学生的年龄
name = input('请输入学生的名字:')
for stu in students:
if stu.name == name:
stu.age = 18
print(stu)
8.slots魔法
1.类的字段
属性：对象属性，类的字段
类的字段: 声明在类里面，函数外面的变量就是类的字段。使用的时候要通过类来使用：类.字段
2.slots: 用来约束当前类的对象的属性有哪些
class Dog:
# num就是类的字段
num = 10
__slots__ = ('color', 'name', 'type', 'sex', 'price', 'age')
def __init__(self, color, name, type):
self.color = color
self.name = name
self.type = type
self.sex = '公的'
print(Dog.num)
Dog.num = 100
print(Dog.num)
dog1 = Dog('黄色', '大黄', '土狗')
dog1.neme = '财财'
print(dog1.name)
dog1.age = 3
9.内置类函数
class Person:
"""人类"""
类的字段
num = 61
对象属性
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__)
print(dict.__doc__)
~~
3.__class__
对象.__class__ -> 获取对象的类, 类能做的事情，他都可以做
my_class = p1.class
p2 = Person('小花', 10, '女')
p2 = my_class('小花', 10, '女')
print(p2.name)
print(Person.num)
print(my_class.num)
4.__dict__
类.__dict__ --> 获取当前类的所有类的字段和其对应的值，以字典的形式返回（了解）
对象.__dict__ --> 获取当前对象所有的属性和其对应的值，以字典的形式返回
print(Person.dict)
print(p1.dict)
5.__module__
类.__module__ -> 获取当前类所在的模块名
print(Person.module)
from datetime import datetime
print(datetime.module)
6.__bases__
类.__bases__ -> 获取当前类的父类, 返回的是一个元祖，元祖的元素是类
print(Person.__bases__)
print(p1)