python-日志-day14-2019-08-8

day14-面向对象基础

一.编程思想

编程思想：面向过程编程，函数式编程，面向对象编程
面向过程编程 - 算法和逻辑
函数式编程 - 函数
面向对象编程 - 类和对象

# ====面向过程===
# 1. 求1+2+3+...+100
sum1 = 0
for x in range(101):
    sum1 += x
print(sum1)

# 1. 求1+2+3+...+888
sum1 = 0
for x in range(889):
    sum1 += x
print(sum1)


# ====函数式编程===
# 1. 求1+2+3+...+100
# print(sum(range(101)))
def sum1(n):
    sum = 0
    for x in range(n+1):
        sum += x
    return sum


print(sum1(100))

# 1. 求1+2+3+...+888
# print(sum(range(889)))
print(sum1(888))
print(sum1(10000))


# =======面向对象=======
# 1. 求1+2+3+...+100
class Math:
    def sum(self, n):
        sum1 = 0
        for x in range(n+1):
            sum1 += x
        return sum1

    def product(self, n):
        sum1 = 1
        for x in range(1, n+1):
            sum1 *= x
        return sum1


ma = Math()
print(ma.sum(100))
print(ma.product(10))

二.类和对象

1.什么是类，什么是对象

类就是拥有相同属性，相同功能的对象的集合（抽象的）
对象就是类的实例（具体的）
如果人是类，乔布斯就是人的对象，小明也是人的对象
如果水杯是类，我桌子上的这个黑色杯子就是对象
如果车是类，具体的某一辆车就是对象

2.类的声明 - 确定这个类共同的属性和功能是什么

(1)语法:
class 类名：
类的说明文档
类的内容
(2)说明
class - 关键字
类名 - 要求: 标识符, 不能是关键字
规范: a.首字母大写，采用驼峰式命名规范 b.见名知义 c.不能使用系统提供的函数名或者类名
类的说明文档 - 和函数说明文档一样
类的内容 - 主要包含属性和方法(方法就是声明在类中函数)

3.声明对象

(1)语法
对象 = 类()

class Person:
    """人类:
    属性 -
    方法 -
    """
    def func0(self):
        pass

    def eat(self, food):
        print('人吃%s' % food)

    @classmethod
    def func1(cls):
        pass

    @staticmethod
    def func2():
        pass
p1 = Person()     # p1中存储的就是Person类的对象
p2 = Person()     # 同一个类可以创建多个对象
p3 = p1           # p1和p3指向同一个对象

三.对象方法

1.对象方法

类中方法分为：对象方法，类方法和静态方法
1）对象方法
a.怎么声明：直接声明（声明前不需要加装饰器）在类中的函数就是对象方法
b.特点：自带self参数，用对象调用对象方法的时候self不用传参，系统会自动将当前对象传给self，self可以做到谁调用指向谁
c.怎么调用：以'对象.对象方法()'的形式来调用 - 通过对象来调用对象方法'

class Person:
    def eat(self, food='米饭'):
        print('self:', self)
        print('人在吃{}!'.format(food))


p1 = Person()
p2 = Person()
print('p1:', p1)
print('p2:', p2)
p2.eat()
p1.eat('包子')

四.构造方法

1.构造函数

函数名和类名一样，用来创建类的对象的函数
python中声明类的时候，系统会自动为这个类创建一个构造函数，函数的作用是创建对象
构造方法的执行过程:
a.在内存中开辟空间创建对象
b.用创建好的对象去调用init方法
c.返回对象在内存中的地址

1.init方法

声明在类中用来对对象进行初始化的方法；（当对象一创建出来，这个方法就会被自动调用）
注意:创建对象的时候构造方法需不需要传参，需要传几个参数，看这个类的init方法

class Dog:
    def __init__(self, name='', age=0):
        print('init:', self)
        print('初始化方法', name, age)


dog1 = Dog('大黄', 20)
print(dog1)

# dog2 = Dog('财财', 18)
dog3 = Dog(name='a', age=10)

注意：构造方法返回的是对象在内存总的地址，而一般的函数如果没有return，那就返回None

# 构造方法的伪方法
"""
def Dog():
    对象 = 开辟空间创建对象
    对象.__init__()
    return 对象
"""

五.属性

1.类中的属性

属性就是声明在类中的变量
类中的属性分为：字段，对象属性
1）字段
a.怎么声明：声明在类的里面的，函数的外面的变量就是字段
b.怎么使用：通过类去使用（以‘类.字段’的形式使用）
c.什么时候用：属性的值不会因为对象不同而不同，这样的属性就声明成类的字段

class Person:
    # num就是字段
    num = 100

    def func1(self):
        a = 10
        print(Person.num)
        pass

    def func2(self):
        pass
        
        
# 使用类的字段
print(Person.num)
Person.num = 200
print(Person.num)

p1 = Person()
p1.func1()

2）对象属性（重要）
a.怎么声明：以'self.属性名=值'的形式声明在init_方法中
b.怎么使用：通过对象去使用
c.什么时候用：属性的值可能会因为对象不同而不一样，这样的属性就声明成对象属性

class Student:
    def __init__(self):
        # 这儿的name、age、gender、study_id就是对象属性
        self.name = '张三'
        self.age = 0
        self.gender = '男'
        self.study_id = 'stu001'


stu1 = Student()
# stu1.age = 18
print(stu1.name, stu1.age, stu1.gender, stu1.study_id)

stu2 = Student()
# stu2.name = '小明'
print(stu2.name, stu2.age, stu2.gender, stu2.study_id)


class Student2:
    def __init__(self, name1, study_id, gender='男'):
        # 这儿的name、age、gender、study_id就是对象属性
        self.name = name1
        self.age = 18
        self.gender = gender
        self.study_id = study_id


stu3 = Student2('小明', '001')
print(stu3.name, stu3.age, stu3.study_id, stu3.gender)

stu4 = Student2('小花', '002', '女')
print(stu4.name, stu4.age, stu4.study_id, stu4.gender)

class Dog:
    def __init__(self, name, breed, age=3, gender='公狗'):
        self.name = name
        self.age = age
        self.gender = gender
        self.breed = breed

    def print_message(self):
        print(self.name, self.age, self.gender, self.breed)

    def call_out(self):
        print('%s: 汪汪汪！' % self.name)


dog1 = Dog('大黄', '土狗')
dog2 = Dog('旺财', '中华田园犬', gender='母狗')

dog2.print_message()
dog1.call_out()
dog2.call_out()

六.对象属性的增删改查

python中类的对象的对象属性支持增删改查

class Person:
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender


p1 = Person('小明', 18, '男')
p2 = Person('小红', 20, '女')

# 1.查(获取属性的值)
"""
方法一: 对象.属性
方法二: getattr(对象, 属性名:str) / getattr(对象, 属性名:str, 默认值)
方法三: 对象.__getattribute__(属性名)
"""
print(p1.name)
print(getattr(p1, 'name'))
print(p1.__getattribute__('name'))

# value = input('属性名:')
# print(getattr(p1, value))

# print(p1.height)    # AttributeError: 'Person' object has no attribute 'height'
print(getattr(p1, 'height', 180))

# 2.增/改
"""
方法一: 对象.属性 = 值
方法二: setattr(对象,属性名,值)
"""
# 属性存在是修改
p1.name = '明明'
print(p1.name)

setattr(p1, 'age', 38)
print(p1.age)


# 属性不存在就添加
p1.weight = 190
print(p1.weight)

setattr(p1, 'face', 60)
print(p1.face)


# 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'


# 4.__slots__魔法
# 通过给__slots__字段赋值来约束当前类的对象有哪些对象属性
class Dog:
    __slots__ = ('name', 'age', 'gender', 'height', 'weight')

    def __init__(self, name, age):
        self.name = name
        self.age = age


dog1 = Dog('大黄', 3)
# dog1.namee = '黄黄'
dog1.gender = '公'
print(dog1.gender)