1.编程思想：
1.面向过程编程
- 遇到问题，考虑直接把逻辑思维转换成代码，解决问题
2.函数式编程
- 遇到问题，考虑是否有一个这种功能的函数，解决问题
3.面向对象编程 - 类和对象
- 遇到问题，考虑是否有一个对象能帮我解决这个问题
2.类和对象
- 类就是拥有相同属性和相同功能的对象的集合（抽象）
- 对象就是类的实例（具体）
2.1.类的声明
语法：
class 类名（父类列表）：
类的内容
- class - 关键字，用来声明类的关键字
- 类名 - 自定义，满足标识符，不能是关键字，采用驼峰式命名，并且类名的首字母大写 见名知意
驼峰式命名：名字由多个单词组成时，通过单词首字母大写来区分不同的单词 userName
（父类列表） - 继承语句：可以省略，省略的时候相当于（objct） - 类的内容：主要包含属性和方法
方法：声明在类中的函数
2.2.属性和方法
- 类中的属性 -指的是在类中声明的变量：分为类的字段和对象属性
- 类中的方法 - 指的是在类中声明的函数：分为对象方法，类方法和静态方法。
#声明了一个Person类
class Person:
'''人类 '''
#属性
num = 61 #类的字段
#方法
def eat(self):
print('人在吃饭！')
#Person是类，类就是类型
print(Person) #
2.3.创建对象
- 类名（） -- 创建类对应的对象
#创建Person类的对象xiaoming
xiaoming = Person()
print(xiaoming) #<__main__.Person object at 0x0000005109799470>
3对象方法
3.1.什么是对象方法
- 直接声明在类中并且自带一个self的参数的函数。
2.对象方法的调用 - 通过对象来调用对象方法
- 对象.对象方法()
3.self(当前对象)
通过对象调用对象方法的时候，对象方法中第一个参数self不用传参，系统会自动将当前对象传给self
当前对象 - 哪个对象调用的，self就是谁注意：当前类的对象能做的事情，self都能做
class Person:
'''
人类
'''
#声明了一个对象方法sleep
def sleep(self):
#self = p1
print('睡觉')
self.run()
def run(self):
'''self = p1'''
print('跑')
#创建Person的对象p1
p1 = Person()
p1.sleep()
4.init方法和构造方法
0.魔法方法
- python的类中 由
__开头并且是__结尾的方法，就是魔法方法，魔法方法不需要主动调用，系统会自动调用
1.__init__方法：
a.是对象方法
b.不需要自己调用，会被自动调用
c.创建对象之后专门用来对对象进行初始化
2.构造方法：
- 概念：函数名和类名是一样的，就是构造方法，
- 当我们创建类的时候，系统会自动创建这个类的构造方法，用来创建对象
- 当我们通过构造方法创建对象的时候，系统会自动调用init方法来对创建好的对象进行初始化
注意：当init方法中除了self以外，如果需要别的参数，那么这些参数是通过构造方法来传的参
只要调用了构造方法，就会产生新的对象（）
class Person:
def __init__(self):
print('init方法')
#创建对象
p1 = Person() #调用系统自动创建的构造方法 在这里传参
'''
5.对象属性
1.什么是对象属性
a.声明在init方法里面的变量
b.self.属性名 = 值
c.通过对象来使用：对象.属性
d.不同的对象 属性的值可能不一样
语法
self.变量名 = 值
说明：变量名就是属性名，这儿的变量就是对象属性
2.什么样的属性应该声明成对象属性
- 如果属性的值会因为对象不同而不一样，那这样的属性就应该声明成对象属性，反之就声明成类的字段
#情况1：所有对象属性创建的时候都使用一个固定默认值
#声明一个Person类
class Person:
def __init__(self):
#这儿的name和age就是Person的对象属性
self.name = ''
self.age = 0
#创建对象
p1 = Person()
#使用对象属性
print(p1.name)
p1.name = '张三'
print(p1.name)#张三
p2 = Person()
p2.name = '小红'
print(p2.name) #小红
#情况2： 创建对象的时候，决定对象属性值
#声明一个Person类
class Person:
def __init__(self,name,age):
#这儿的name和age就是Person的对象属性
self.name = name
self.age = age
#创建对象
p1 = Person('李毅',20)
p2 = Person('三十四',11)
#使用对象属性
print(p1.name,p1.age,p2.name)#李毅 20 三十四
#修改对象属性的值
p1.name = '小毅'
print(p1.name,p1.age,p2.name)#小毅 20 三十四
#练习 声明一个矩形类
class JuXing():
def __init__(self,long,wide):
self.long = long
self.wide = wide
#一个对象方法需不需要除了self以外的其他参数，
# 看实现这个函数功能需不需要除了属性以外的其他数据
def area(self):
#self = p1/p2
return self.long * self.wide
def zhou_chang(self):
return 2*(self.long + self.wide)
p1 = JuXing(20,20)
print(p1.area())#400
print(p1.zhou_chang())#80
p2 = JuXing(10,20)
print(p2.area())#200
print(p2.zhou_chang())#60
#声明一个 point类，拥有x坐标 和y坐标,功能 求一个点到另一个点的距离
class Point():
def __init__(self,x,y):
self.x = x
self.y = y
def ju_li(self,x1,y1):
return ((self.x-x1)**2 + (y1-self.y)**2)**0.5
p1 = Point(10,20)
print(p1.ju_li(10,30))
class Point():
def __init__(self,x,y):
self.x = x
self.y = y
#求当前带你到另一个点的距离
def ju_li(self,other):
return ((self.x-other.x)**2 + (other.y-self.y)**2)**0.5
p1 = Point(0,0)
p2 = Point(3,4)
print(p1.ju_li(p2))
6.对象属性的增删改查
class Dog:
def __init__(self,name,color,type):
self.name = name
self.color = color
self.type = type
dog1 = Dog('旺财','黄色','二哈')
1.查（获取对象属性的值）
- 获取指定对象指定属性值
a.对象.属性名 - 属性不存在时会报错
b.getattr(对象，属性名，默认值（当属性不存在时，如果设置了默认值，不会报错，而是返回默认值）)
print(dog1.name)# 旺财
print(getattr(dog1,'color')) # 黄色
print(getattr(dog1,'color1','黑色')) #黑色
2.增 改
a.对象.属性 = 值 - 当属性存在时修改属性的值，不存在时添加属性
b.setattr(对象，属性名，值) - 属性存在时修改属性的值，不存在时添加属性
dog1.name = '大黄' #修改
dog1.sex = '公' # 添加
setattr(dog1,'color','蓝色')#修改
print(dog1.color) #蓝色
setattr(dog1,'name2','肉鸡')#添加
print(dog1.name2)# 肉鸡
3.删除
a.del 对象.属性 --
b.delattr(对象，属性名)
del dog1.name2 #删除name2 肉鸡
print(dog1.name2)
delattr(dog1,'color')
print(dog1.color) #AttributeError: 'Dog' object has no attribute 'name2'
- 注意：对象属性的增删改查都是针对指定的一个对象，不会影响其他的对象
4.slots魔法
- __ slots __ = （）- 用来约束当前这个类有哪些对象属性。
class Student:
#Student类的对象只能有'name','study_id','age'属性
__slots__ = ('name','study_id','age')
def __init__(self,name,age):
self.name = name
self.study_id = '001'
self.age = age
stu1 = Student('小米',20)
7.类的字段和内置类属性
1.类的字段
声明在类里面，并且是在函数外面的变量就是类的字段
类的字段需要通过类来使用： 类.字段 - 不管是在类里面还是类外面都一样不会因为对象不同而不一样的数据就声明类的字段
class Person:
#声明一个类的字段number
number = 61 #类的字段
def show_number(self):
print('人类的数量：%d'%Person.number)
print(Person.number) #61
print(Person().show_number())
2.内置类属性
- 内置属性就是声明类的时候，类中已经声明好的属性（包含类的字段和对象属性）
class Dog:
'''说明文档：狗类'''
#类的字段
type = '犬科'
#对象属性
def __init__(self,name,color,age):
self.name = name
self.color = color
self.age = age
#对象方法
def eat(self,food):
print('%s在吃%s'%(self.name,food))
#类方法
@classmethod
def shout(cls):
print('汪汪汪~~~')
#静态方法
@staticmethod
def bite():
print('狗咬人')
dog1 = Dog('小黑',3,'黑色')
a. __name __
类.__ name__- 获取类的名字（字符串）
print(Person.__name__)#Person 类的名字
print(type(Person.__name__)) #
b.__ class__
对象.__ class __- 获取对象对应的类（结果是一个类，原来类能做的都能做）
print(Person.__class__)
print(dog1.__class__)#
aa = dog1.__class__ #aa就是dog1的类Dog
print(aa.type) #犬科
print(Dog.type) #犬科
c.__ dict__
- 类.__ dict__ - 获取当前类的所有类的字段及其对应的值（了解）
- （重点）对象.__dict __- 将当前对象所有的对象属性及其值转换成字典，key是属性名，value是属性的值
print(Dog.__dict__)#{'__module__': '__main__', 'type': '犬科', '__init__': , 'eat': , '__dict__': , '__weakref__': , '__doc__': None}
print(dog1.__dict__)#{'name': '小黑', 'color': 3, 'age': '黑色'}
d.__ base__
- 类.__ bases__ - 获取当前类的父类（以元祖的形式返回，元祖中的元素就是类的父类）
print(Dog.__bases__) #(,)
e.__ module__
- 类.__module __ - 获取当前类所在模块的模块名
print(Dog.__module__) #__main__
f.__ doc__
- 类.__doc __ - 获取当前类的说明文档
print(Dog.__doc__) #说明文档：狗类