day13 类和对象

编程思想

1.面向过程编程 - 逻辑、算法
遇到问题，直接吧逻辑思维转换成代码解决问题

2.函数式编程 - 面向对象
遇到问题，就考虑是否有这个功能的函数。

3.面向对象编程 - 类和对象
遇到问题，就考虑是否有一个对象能够帮我解决这个对象

类和对象概念

类：就是拥有相同属性和相同功能的对象的集合、（属性：数据）（类是抽象）
对象：类的实例（对象是具体的）

举例：

从生活角度考虑类的对象
如果是 “人” 是一个 余婷是一个对象，罗老师也是一个对象
如果电脑是一个类，我桌上的这台电脑就是对象

一、类

1.类的声明

1.语法：

class 类名（父类）：
    类的内容
说明：
class = 声明类的关键字。
类名 - 标识符，不能是关键字；驼峰式命名，并且首字母大写。
        见名知意
（父类列表） - 继承语法：可以省略，省略的时候相当于（object）
类的内容 - 主要包含属性和方法

2.类中的属性和方法

类中的属性 - 指的是在类中声明的变量：分为类的字段和对象属性
类中的方法 - 指的是在类中声明的函数，对象方法、类方法、静态方法

补：采用驼峰式命名：名字由多个单词组成，通过单词首字母大写来区分不同的单词。
studentName、userId
方法：声明在类中的函数（函数就是方法，方法就是函数）就是方法

# 声明了一个Person的类、
class Person:
    """人类"""
    #属性
    num = 61

    #方法
    def eat(self):
        print("人在吃饭")
# Person 是类（类就是类型）
print(Person)

3.对象

1.对象方法

直接声明在类中，并且自带self的参数的函数

2.对象方法的调用

对象方法通过对象来调用
对象.对象方法

3.self(当前对象)

通过对象调用对象方法的时候，对象方法中的第一个参数self不用传参
系统会自动将当前对象传给self
哪个对象调用的方法，self就指向谁。
p1 和 self是一样的
注意：当前类的对象能做的事情，self都能够做

class Person:
    """人类"""
    #声明了一个对象方法sleep
    def sleep(self,a):
        print("self",self)
        print("在睡觉",a)
        self.run()
    def run(self):
        #self = p1
        print("跑")
# 创建person对象p1
p1 = Person()
print("p1",p1)
p1.sleep(10)
# 创建person对象p2
p2 = Person
p2.name = "小明"
p2.sleep
# 创建person对象p3
p3 = Person
p3.name = "小花"

3.init方法和构造方法

1.魔法方法

python类中，用__开头并且是__结尾的方法，就是魔法方法。魔法方法不需要主动调用
都会自动调用

2.init方法

1.__init__方法

• a.对象方法
• b.不需要自己调用，会被自动调用
• c.专门用来对对象进行初始化

3.构造方法
概念：函数名和类名是一样的函数，就是构造方法。就是用来创建对象
当我们创建类的时候，系统会自动创建这个类的构造方法，用来创建对象。
注意：
当我们通过构造方法创建对象的时候，系统会自动调用init方法对创建好的对象进行初始化。
注意：当init方法中除了self以外如果需要别的参数，那么这些参数是通过构造方法来传的参
只要调用了构造方法，就会产生新的对象(想要对象，调用构造方法)

class Person:
    def __init__(self,name):
        print("self",self)
        print("init方法")
"""
def Person(*aygs,**kwargs):
    在堆中开辟空间创建对象
    对象.__init__()
    :return 对象
    (self和p1一样的)
"""
p1 = Person("abc")
print("p1",p1)
p2 = Person("abc")
print("p2",p2)

练习：模拟构造方法和init方法

def __init__(a,b):
    print("")
def Func1(*args,**kwargs):
    print("创建对象")
    __init__(*args,**kwargs)
    print("返回对象")
Func1(50,20)

4.对象属性

1.什么是对象属性

• a.声明在init方法中
• b.self.属性名 = 值
• c.通过对象使用：对象.属性

语法：
self.变量名 = 值
说明：变量名就是属性名，这个变量就是对象属性

2.什么样的属性应该声明称对象属性

如果属性的值会因为对象的不同而不同，那这样的属性就应该声明称对象属性，反之就声明成类的字段。

情况一：所有对象属性创建的时候都使用一个固定的值

class Person:
    def __init__(self):
        #这儿的name和age就是对象属性
        self.name = ""
        self.age = 0
p1 = Person
p1.name = "lorry"
print(p1.name)
# print(p1.age)
p2 = Person
p2.name = "lorrybz"
print(p2.name)

情况二：创建对象的时候，决定对象属性的值

class Person:
    def __init__(self,name1,age = 1):
        #这儿的name和age就是对象属性
        self.name = name1
        self.age = age
p1 = Person("二狗子",0)
p2 = Person("灵儿")
print(p1.name,p1.age)
print(p2.name,p2.age)
#修改
p1.name = "老王"
p1.age = 50
print(p1.name,p1.age)

练习：声明一个矩形类

class Matrian:
    def __init__(self,length,width):
        self.length = length
        self.width = width
# 一个对象方法需不需要除了self以外的其他参数
# 看这个函数的功能需不需要除了属性以外的其他数据
    def area(self):
        return self.length * self.width
    def perimeter(self):
        return (self.length+self.width)*2
mat1 = Matrian(50,20)
print(mat1.area())
mat2 = Matrian(50,20)
print(mat2.perimeter())

练习 声明一个Point类，拥有属性X坐标和y坐标，求两个点之间的距离。

class Point:
    def __init__(self,x,y):
        self.x = x
        self.y = y

    def distance(self,other):
        return  ((self.x - other.x)**2 + (self.y-other.y)**2)**0.5

pt1 = Point(1,1)
pt2 = Point(0,10)
print(pt1.distance(pt2))

5.对象属性的增删改查

注意：对象属性的增删改查，都是针对指定的一个对象，不会影响其他

1.查（获取对象属性的值）

• a.对象.属性
• b.getattr（对象。属性名，默认值） - 当属性不存在的时候，如果设置了默认值，程序不会崩溃，而是返回默认值。

class Dog:
    def __init__(self,name,color,type):
        self.name = name
        self.color = color
        self.type = type
dog1 = Dog("旺财","yellow","肉狗")
dog2 = Dog("lalla","yellow","hmp")

class Dog:
    def __init__(self,name,color,type):
        self.name = name
        self.color = color
        self.type = type
dog1 = Dog("旺财","yellow","肉狗")
dog2 = Dog("lalla","yellow","hmp")

2.增加和修改

• a.对象.属性 = 值
• b. setattr(对象，属性名，值)
  注意：属性存在的时候，对应的功能是修改属性的值，当属性不存在的时候是添加属性。

class Dog:
    def __init__(self,name,color,type):
        self.name = name
        self.color = color
        self.type = type
dog1 = Dog("旺财","yellow","肉狗")
dog2 = Dog("lalla","yellow","hmp")

dog1.name = "来福"
print(dog1.name)
dog1.leg = 4
print(dog1.leg)
setattr(dog1,"name","热狗")
print("***",dog1.name)
setattr(dog1,"name1","肉狗")
print("name1：",dog1.name1)
setattr(dog1,"sex","公")
print(dog1.sex)

3.删除

a del 对象.属性
b.delattr(对象，属性名)

class Dog:
    def __init__(self,name,color,type):
        self.name = name
        self.color = color
        self.type = type
dog1 = Dog("旺财","yellow","肉狗")
dog2 = Dog("lalla","yellow","hmp")

del dog1.name1
# print(dog1.name1)
delattr(dog1,"color")
# print(dog1.color)

4.slots是用来约束当前这个类有哪些对象属性

class Student:
    # 学生对象只能有name，age，study_id和sex
    __slots__ = ("name","age","study_id","sex")
    def __init__(self,name,age):
        self.name = name
        self.age = age
        self.study_id = "001"
stu1 = Student("小明",18)

5.类的字段

• a.直接声明在类里面，函数的外面的变量就是类的字段
• b.类的字段需要通过类来使用

不会因为对象不同而不一样的数据就声明成类的字段
调用方法：类名.类的字段名，不管在类的里面还是类的外部都一样

class Person:
    number = 61   #这就是一个类的字段
    def show_number(self):
        print("人类的数量%s"%Person.number)
print(Person.number)
Person().show_number()

6.内置类属性

内置属性就是声明类的时候：类中已经声明好的属性（包含类的字段和对象属性）

class Dog:
    """说明文档：狗类"""
    #类的字段
    type = "犬科"
    #对象属性
    def __init__(self,name ,age,color = "yellow"):
        self.age = age
        self.name = name
        self.color = color
    #对象方法
    def eat(self,food):
        print("%s在吃%s"%(self.name,food))
    #类方法
    @classmethod
    def shout(cls):
        print("汪汪汪。。")
    #静态方法
    @staticmethod
    def bite():
        print("狗咬人")
dog1 = Dog("小黑",50)


a.- a .__name__
class_name = print(Person.__name__)
print(class_name,type(class_name))


b.__class__

对象.__class__获取对象对应的类（结果是一个类，原来类能做的事情他都可以做）

print(Dog.__class__)
print(dog1.__class__)
aa = dog1.__class__
d1 = Dog
d2 = aa
print("****",d1,d2)
print(Dog.type)
print(aa.type)
print(dog1.__class__.__name__)  #获取对象对应的类的性子


c..__dict__
类.__dict__   获取当前类的所有类的字段，及其对应的值
重点  对象.__dict__  将当前对象所有的对象属性及其值转换成字典，key是属性名，value是属性的值。
print(Dog.__dict__)
print(dog1.__dict__)


d. __base__
类.__base__   _获取当前类的父类，元组中元素就是类的父类
print(Dog.__bases__)

e.类.__module__  获取当前类所在模块的模块名
print(Dog.__module__)
print(int.__module__)


f. 类.__doc__获取当前类的说明文档
print(Dog.__doc__)
print(int.__doc__)