1.编程思想

• 1.编程思想

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

2.函数式编程 - 函数
遇到问题，直接考虑是否有一个这种功能的函数

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

• 2.类和对象

1.定义
类：就是拥有相同属性和相同功能的对象的集合（类是抽象的）
对象:类的实例（对象是具体的）

2.从生活的角度来看对象
如果电脑是一个类，每一台具体的电脑就是一个对象
如果学生是一个类，每一名具体的学生就是一个对象

2.类的声明

1.类的声明
语法：
class 类名(父类列表):
类的内容

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

驼峰式命名：名字有多个单词组成通过单词首字母大写来区分不同的单词
studentName,userName...
方法：声明在类中的函数就是方法

2.类中的属性和方法
属性 - 类中声明的变量；分为类的字段和对象属性
方法 - 类中声明的函数；分为对象方法、类方法和静态方法

class Person:
    """人类"""
    # 属性
    num = 61

    # 方法
    def eat(self):
        print('人在吃饭')


print(Person)

3.创建对象
类名（） - 创建类对应的对象

• 创建Person类的对象xiao_ming

xiao_ming = Person()
print(xiao_ming)

3.对象方法

1.什么是对象方法
直接声明在类中，并且自带self的参数

2.对象方法的调用 - 通过对象调用对象方法
对象.对象方法()
（可以通过类来调用对象方法，但是需要给self传参，一般不用）

3.self(当前对象)
对象方法的第一个参数self不用传参，系统会自动的将当前对象传给self
哪个对象调用的，self就是谁。当前对象能做的self都能做

class Person:
    """人类"""

    # 声明了一个对象方法
    def sleep(self, a):
        # self = p1, a = 10
        print('睡觉', a, self)
        self.run()

    def run(self):
        print('跑')


p1 = Person()
p1.sleep(10)
print(p1)

4.init方法和构造方法

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

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

2.构造方法
函数名和类名一样的函数就是构造方法
当我们创建类的时候系统会自动创建这个类的构造方法，用来创建对象
当我们通过构造方法创建对象的时候，系统会自动调用init方法来对创建好的对象进行初始化

注意：当init方法中除了self以外如果需要别的参数，那么这些参数是通过构造方法来传参的
只要调用了构造方法，就会产生新的对象。（想要对象，调用构造方法）

class Person:
    def __init__(self, name):
        print('init方法', name)

    def run(self):
        print('跑')
"""
def Person(*args, **kwargs):
    在堆中开辟空间创建对象
    对象.__init__()
    return 对象
"""
p1 = Person('小明')
p1.run()

• 模拟构造方法和init方法

def __init__(a, b):
    print('自己实现：', a, b)


def Func1(*args, **kwargs):
    print('创建对象')
    __init__(*args)
    print('返回对象')


Func1(10, 20)

5.对象属性

1.什么是对象属性
a.声明在__ init __方法中
b.self.属性名 = 值
c.通过对象来使用： 对象.属性

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

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

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

class Person:
    def __init__(self):
        # 这里的name和age就是Person类的对象属性
        self.name = ''
        self.age = 18


# 创建对象
p1 = Person()
p1.name = '张三'
print(p1.name, p1.age)

p2 = Person()
p2.name = '小红'
print(p2.name, p1.name)

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

class Person:
    def __init__(self, name, age=0):
        # 这里的name和age就是Person类的对象属性
        self.name = name
        self.age = age


p3 = Person('李四', 20)
print(p3.name, p3.age)
# 修改对象属性的值
p3.age = 18
print(p3.age)

• 练习：声明一个矩形类

class Rect:
    def __init__(self, length, width):
        self.angie1 = '90°'
        self.angie2 = '90°'
        self.angie3 = '90°'
        self.angie4 = '90°'
        self.sidenum = 4
        self.length = length
        self.width = width
    # 一个对象方法需不需要除了self以外的其他参数，
    # 看实现这个函数的功能需不需要除了属性外的其他数据
    def area(self):
        area = self.length * self.width
        return '面积是%.2f' % area

    def peri(self):
        peri = (self.length + self.width) * 2
        return '周长是%.2f' % peri


r1 = Rect(10, 20)
print(r1.area(), r1.peri())

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

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

    def distance(self, other):
        distance = ((self.x - other.x) ** 2 + (self.y - other.y) ** 2) ** 0.5
        return '两点之间的距离是%.2f' % distance


d1 = Point(1, 2)
d2 = Point(-5, 6)
print(d1.distance(d2))

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', '黑色'))

• 2.增、改
  """
  a.对象.属性 = 值 - 当属性存在，修改；不存在，添加
  b.setattr(对象, 属性名, 值)

dog1.name = '小白'
setattr(dog1, 'name', '大黄')

• 3.删除

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

del dog1.name
delattr(dog1, 'color')

注意：对象属性的增删改查,都是针对指定的那一个对象

• 4.__ slots __魔法

__ slots __是用来约束当前这个类有哪些对象属性
如果给类的slots赋了值，那么这个类的对象的dict属性就不能用了

class Student:
    __slots__ = ('name', 'id', 'age')

    def __init__(self, name, age):
        self.name = name
        self.id = '001'
        self.age = age


stu1 = Student('小明', 18)
# stu1.neme = '小红'

7.类的字段和内置类属性

1.类的字段
a.直接声明 在类里面，函数的外面 的变量 就是类的字段
b.类的字段需要通过类来使用:类.字段 - 不管在类的里面还是类的外面都是一样的

不会因为对象不同而不一样的数据就声明成类的字段

class Person:
    # 声明了一个字段number
    number = 61

    def show_number(self):
        print('人类的数量%d' % Person.number)


print(Person.number)

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

class Dog:
    """说明文档：狗类"""
    # 类的字段
    type = '犬科'

    # 对象的属性
    def __init__(self, name='', age=0, color=''):
        self.name = name
        self.age = age
        self.color = color

    # 对象方法
    def eat(self, food):
        print('%s在吃%s' % (self.name, food))

    # 类方法
    @classmethod
    def shout(cls):
        print('汪汪汪...')

    # 静态方法
    @staticmethod
    def bite():
        print('狗咬人！!!')


dog1 = Dog('小黑', 6, '黑色')

• a.__ name __

类.__ name __ - 获取类的名字(字符串)

class_name = Dog.__name__
print(Dog.__name__, type(class_name))

• b.__class __

对象.__ class __ - 获取对象对应的类(结果是一个类，原来类能做的他都能做)

a = dog1.__class__
print(Dog.__class__)
print(dog1.__class__)
d1 = Dog()
d2 = a()
print(d1, d2)

print(Dog.type)
print(a.type)

print(dog1.__class__.__name__)   
# 获取对象对应的类的名字

• c.__ dict __

（了解）类.__ dict __ - 获取当前类的所有类的字段及其对应的值，以字典的形式返回
（重点）对象.__ dict __ - 将当前所有的对象属性及其值转换成字典，key是属性名,value是属性的值

print(Dog.__dict__)
print(dog1.__dict__)

• d. __ bases __

类.__base __ - 获取当前类的父类(以元组的形式返回，元组中的元素就是类的父类)

print(Dog.__bases__)

• e.__ module __

类.module - 获取当前类所在的模块的模块名

print(Dog.__module__)

• f.__doc __

类.__ doc __ - 获取当前类的说明文档

print(Dog.__doc__)