Python基础 - 类和对象

作者: 莫名ypc | 来源:发表于2018-10-17 20:42 被阅读0次

面向对象编程

编程思想

1.面向过程编程 --> 算法，逻辑

2.函数式编程 --> 函数，模块

3.面向对象编程 --> 类和对象

类的声明

1.什么是类

类 - 是拥有相同属性和相同功能的对象的集合(抽象的)
对象 - 就是类的实例(具体的)

2.类的声明

格式：
class 类名(父类列表):
    类的说明文档
    类的内容

说明：
class --> python中声明类的关键字
类名 --> 标识符，不能是关键字；类名使用驼峰命名法，并且首字母大写;见名知义
驼峰式命名：如果一个名字有多个单词组成，第一个单词首字母小写，后面每个单词首字母大写
userName
PEP8命名规范：如果一个名字有多个单词组成，所有字母小写，多个单词之间用下划线隔开
user_name

(父类列表) --> 继承语法，让声明的类继承括号中的父类。这个结构可以省略，让当前类继承python的基类：object
**: ** --> 固定结构
类的说明文档 --> 注释，对类进行说明
类的内容 --> 包含属性(变量)和方法(函数)
方法：声明在类中的函数

# 声明Person类，吃饭和睡觉
class Person:
    """人类"""
    def eat(self):
        print('吃饭')

    def sleep(self):
        print('睡觉')

3.对象的声明

对象名 = 类名()

对面名 --> 变量名
类名 --> 必须是声明过的类

# 声明了Person类的对象p1
p1 = Person()
p2 = Person()

对象方法

1.
类的内容包含属性和方法，方法分为对象方法、类方法和静态方法

对象方法：直接声明在类中的函数就是对象方法。对象方法都有一个默认参数self，通过对象来调用

对象方法的调用：对象.方法名()。调用对象方法的时候，不需要给默认参数self传参。
系统会自动将当前对象传递给self
self: 谁调用当前的对象方法，self就指向谁。self就是当前类的对象，类的对象能做的事情，self都能做


class Person:
    """人类"""

    # 对象方法eat
    def eat(self, name):
        # self = p1, name = '小明'
        print('self:', self)
        print('吃饭！')
        self.sleep()

    def sleep(self):
        print('S_self:', self)
        print('睡觉')


# 声明对象
p1 = Person()
print('p1:', p1)
p1.eat('小明')

p2 = Person()
print('p2:', p2)
p2.eat('小红')

构造方法和init方法

1.构造方法

构造方法就是函数名和类名一样的方法，作用是用来创建对象的。
声明类的时候，系统会为这个类创建对应的构造方法

创建对象的过程：调用构造方法在内存中开辟空间创建对象，并且会自动调用__init__方法去对这个对象进行初始化,
最后将创建好的对象的地址返回

2.init方法

对象方法
不需要手动调用，创建完对象后，会被自动调用

class Dog:
    """狗"""
    def __init__(self):
        print(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')
p2 = Person('小明')
p3 = Person(age=20)

对象的属性

类的内容包含属性和方法，属性又分为对象属性和类的字段

属性：用来在类中去保存数据的变量。
对象属性：属性的值会因为对象不同而不一样，这种属性就需要声明成对象属性，例如：人的名字，人的年龄等
对象属性要通过对象来使用

1.对象属性的声明(重点)

a.必须声明在__init__方法中
b.声明的格式：self.属性名 = 初值

2.使用对象属性

对象.属性

# 声明一个人类，要求有名字，年龄和性别属性
class Person:
    def __init__(self):
        self.name = '张三'
        self.age = 18
        self.sex = '男'


p1 = Person()
print(p1.name)

p2 = Person()
print(p2.name)

# 声明一个人类，有名字、年龄、性别三个属性。要求创建不同的对象的时候就可以直接确定不同的属性值
class Person2:
    def __init__(self, name, age=0, sex='girl'):
        self.name = name
        self.age = age
        self.sex = sex
        self.id = '0001'


p1 = Person2('小明', 20, '女')
print(p1.name)
p1.name = 'xiaoming'
print(p1.name)
p1.id = 'p10001'
print(p1.id)

p2 = Person2('小红')
print(p2.name)

对象属性的增删改

class Student:
    def __init__(self, name='', age=0, stu_id='001'):
        self.name = name
        self.age = age
        self.stu_id = stu_id


stu1 = Student('小明')
stu2 = Student('小红', 18)

1.查(获取对象属性的值)

方法1:对象.属性 --> 获取指属性的值

print(stu1.name)
# print(stu1.name2)   # AttributeError

方法2：getattr(对象, 属性名，默认值) --> 获取指定属性值，如果设置了默认值当属性不存在的时候不会报错，并且会将默认值作为结果。（如果没有设置默认值，属性不存在还是会报错）

print(getattr(stu1, 'name'))
print(getattr(stu1, 'name2', '张三'))

方法3：对象.__getattribute__(属性名) --> 获取指定属性,属性不存在会报错

print(stu1.__getattribute__('stu_id'))
# print(stu1.__getattribute__('stu_id2'))

2.增/改(给对象添加属性)

注意：给对象添加属性，只能添加到当钱对象中。不会影响当前类的其他对象
方法1：对象.属性 = 值（属性不存在的时候增加，存在的就是修改）
方法2：setattr(对象，属性名，属性值)

#  添加
stu1.sex = '男'
print(stu1.sex)
# print(stu2.sex)    # AttributeError: 'Student' object has no attribute 'sex'

# 修改
stu1.name = '李四'
print(stu1.name)
# 修改
setattr(stu1, 'name', '娜美')
print(stu1.name)
# 添加
setattr(stu1, 'name2', '宝儿姐')
print(stu1.name2)

3.删(删除对象属性)

注意:删除只删除当前对象的属性，对当前类的其他对象没有影响
方法一：del 对象.属性
方法二：delattr(对象，属性名)
方法三：对象.__delattr__(属性名)

del stu1.age
# print(stu1.age) # AttributeError: 'Student' object has no attribute 'age'
print(stu2.age)

print(stu1.sex)
delattr(stu1, 'sex')
# print(stu1.sex)

stu1.__delattr__('name')

对象的使用

python中所有的数据都是对象，所有的变量存储的都是对象的地址

import copy

num = int(10)
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__)
        # return 'name:' + self.name + 'age:' + str(self.age) + 'score:' + self.score

1.将对象给别的变量赋值

stu1 = Student('xiaoHua', 18, 90)
stu2 = stu1
stu3 = copy.copy(stu1)  # 产生新的对象，将新的地址赋值

stu1.name = '张三'
print(stu2.name)
print(stu3.name)

2.将对象作为列表的元素

students = [Student('小明', 22, 90), stu3, Student('小红', 10, 98)]
# 找出成绩最好的学生
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)

max2 = max(students, key=lambda item: item.score)
print('max:', max2)

1.根据姓名查找指定学生的信息。2.根据姓名修改指定学生的年龄

name = input('姓名：')
for stu in students:
    if stu.name == name:
        print(stu)
        new_age = input('新年龄：')
        stu.age = new_age
        print(stu)
        break

slot魔法

1.类的字段

属性：对象属性，类的字段
类的字段：声明在类里面，函数外面的变量就是类的字段。
使用的时候通过类来使用：类.字段

2.slots:用来约束当前类的对象的属性有哪些

class Dog:
    # num就是类的字段
    num = 10

    __slots__ = ('color', 'name', 'type', 'sex', 'age', 'price')

    def __init__(self, color, name, type):
        self.color = color
        self.name = name
        self.type = type
        self.sex = 'boy'
        print(Dog.num)


Dog.num = 100
print(Dog.num)

dog1 = Dog('黄色', '大黄', '土狗')

dog1.price = 200

# dog1.height = 50

内置类属性

class Person:
    """人类"""
    # 类的字段
    num = 60

    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__)

3.class

对象.class --> 获取当前对象所对应的类

my_class = p1.__class__
p2 = my_class('小花', 20, '女')
print(p2.name)

print(my_class.num)

4.dict

类.__dict__ --> 获取当前类的所有的字段和其对应的值，以字典的形式返回(了解)
对象.dict --> 获取当前对象所有的属性和其对于的值，以字典的形式返回

print(Person.__dict__)
print(p1.__dict__)

5.module

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

print(Person.__module__)

6.base

类.__base__ --> 获取当前类的父类，返回的是一个元组，元组的元素是类

print(Person.__bases__)

print(p1)

作业

1. 声明一个电脑类
属性：品牌、颜色、内存大小
方法：打游戏、写代码、看视频
a.创建电脑类的对象，然后通过对象点的方式获取、修改、添加和删除它的属性
b.通过attr相关方法去获取、修改、添加和删除它的属性

class Computer:
    def __init__(self, brand, color, RAM):
        self.brand = brand
        self.color = color
        self.RAM = RAM

    def play_game(self):
        print('用%s电脑打游戏' % self.brand)

    def write_code(self):
        print('用%s电脑写代码' % self.brand)

    def watch_video(self):
        print('用%s电脑看视频' % self.brand)


# 创建对象
computer1 = Computer('ASUS', 'black', '4G')
computer2 = Computer('DELL', 'white', '8G')
# .方式
print(computer1.brand, '电脑')

computer1.color = 'white'

print('颜色', computer1.color)

computer1.memory = '1T'
print('硬盘：', computer1.memory)

del computer1.color

# attr方式
print(getattr(computer2, 'brand'))
print(getattr(computer2, 'name', '未知属性'))
print(computer2.__getattribute__('RAM'))

setattr(computer2, 'color', 'red')
print(computer2.color)

setattr(computer2, 'memory', '1T')
print(computer2.memory)

delattr(computer2, 'RAM')
computer2.__delattr__('color')

结果：

1.JPG

2.声明一个人的类和狗的类:
狗的属性:名字、颜色、年龄
狗的法:叫唤
人的属性:名字、年龄、狗
人的方法:遛狗
a.创建人的对象名字叫小明，让他拥有一条狗，然后让小明去遛狗

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

    def walk_the_dog(self):
        print('%s 遛他的狗 %s' % (self.name, self.dog.name))


class Dog:
    def __init__(self, name, color, age):
        self.name = name
        self.color = color
        self.age = age

    def bark(self):
        print('汪汪汪')


p1 = Person('小明', 20)

dog = Dog('二哈', 'black_white', 2)

p1.dog = dog

p1.walk_the_dog()

结果：

2.JPG

3.声明一个矩形类:
属性: 长、宽
方法:计算周长和面积
a.创建不同的矩形，并且打印其周长和面积

class Rectangle:
    def __init__(self, length, wide):
        self.length = length
        self.wide = wide

    def perimeter(self):
        perimeter = 2 * self.length + 2 * self.wide
        print('该矩形周长：', perimeter)
        return perimeter

    def area(self):
        area = self.length * self.wide
        print('该矩形面积：', area)
        return area


rec1 = Rectangle(10, 20)
rec2 = Rectangle(100, 200)

print('矩形1：')
rec1.perimeter()
rec1.area()

print('矩形2')
rec2.perimeter()
rec2.area()

结果：

3.JPG

4.创建一个学生类:
属性:姓名，年龄，学号，成绩
方法:答到，展示学生信息
创建一个班级类: 属性:学生，班级名
方法:添加学生，删除学生，点名, 获取班级中所有学生的平均值，获取班级中成绩最好的学生

class Student:
    def __init__(self, name, age, stu_id, score):
        self.name = name
        self.age = age
        self.stu_id = stu_id
        self.score = score

    def answer(self):
        print('%s答到' % self.name)

    def show_information(self):
        print('姓名：%s 年龄：%d 学号：%s 成绩：%d' % \
              (self.name, self.age, self.stu_id, self.score))

    def __str__(self):
        return str(self.__dict__)


class Grade:
    def __init__(self, grade_name, student=[]):
        self.student = student
        self.name = grade_name

    def add_student(self, *student):
        self.student = student
        print('添加成功！现有学生信息：')
        for student in self.student:
            print('姓名:%s 年龄：%d 学号：%s 成绩：%d' % \
                  (student.name, student.age, student.stu_id, student.score))

    def del_studen(self):
        del self.student
        print('删除成功！')

    def checkroll(self):
        print('班级点名：')
        for stu in self.student:
            stu.answer()

    def average(self):
        print('平均值')
        sum1 = 0
        index = 0
        for stu in self.student:
            sum1 += stu.score
            index += 1
        print(sum1 / index)

    def top_score(self):
        print('最高分')
        max1 = self.student[0].score
        for stu in self.student:
            if stu.score > max1:
                max1 = stu.score
        print(stu.score)

    def __str__(self):
        return str(self.__dict__)


#学生对象
stu1 = Student('小明', 20, '0001', 90)
stu2 = Student('小红', 22, '0002', 85)
stu3 = Student('小花', 23, '0003', 95)

stu1.show_information()
stu2.answer()

#创建班级
grade1 = Grade('py1807')

print(grade1.name)

#添加学生
grade1.add_student(stu1, stu2, stu3)

#点名
grade1.checkroll()

#平均值
grade1.average()

#最高分
grade1.top_score()

#删除学生
grade1.del_studen()

结果：

4.JPG