Python基础第四课

Posted 2021-01-02 账号

github博客传送门
csdn博客传送门

面向对象

对新手来说这块比较难,建议大家快速阅读一下概念,然后无论会不会先抄几道题(注意:必须手打)建议3道简单的题刷三遍一共九遍之后再看概念容易懂一些.
说的高深点,面向对象就是对内存指针的指向的改写,不过今天我们不讨论那么深.还是来点简单的.照顾一下新手.

类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例.
(自我形象化理解(帮助新手理解):一个人背了个空包,什么也没有装,我们就可以把这个空包比喻为:类.)

类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
(自我形象化理解(帮助新手理解):一个人背了个包,包上有很多属性,比如包容量,所有往包里放的东西都可以使用这个容器.每放一个东西这个容量就会减少,每拿出一个东西这个容量就会增加.我们称这个 包容量/包的属性 为这个 空包/类 的:类变量.)

方法：类中定义的函数。
(自我形象化理解(帮助新手理解):假如这个空包里装了一些工具 比如 锤子,帕子,手机,钱包等等能装的东西 然后锤子能用来敲东西,帕子能用来洗脸擦汗等等 那么我们就称这些工具为:方法.)

实例化：创建一个类的实例，类的具体对象。
(自我形象化理解(帮助新手理解):一个人背了个包,包里的 工具/方法 需要人来使用才有意义吧.这个人就相当于可以将这个包里工具拿来使用了.这个人就相当于 实例化/类的实例化 唯一和平时不一样的是 每实例化一个对象 也就是多一个人使用这个包 就是将这个包复制了一份 大家可以共同并且同时使用同一个 工具)

实例变量：定义在方法中的变量，只作用于当前实例的类.
(自我形象化理解(帮助新手理解):定义在每个方法内的变量.每当实例化一个变量,每个人用 工具/方法 的方式不同,也就是说这个工具的使用方式 就是当前使用这个人的 特有变量/实例变量)

继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（Dog是一个Animal）
(自我形象化理解(帮助新手理解):一个人背了个包,包里有很多工具,当他将这个包给他儿子,他儿子既可以使用包里的工具,也可以自己添加一些新的工具并使用 这个就可以称为:继承.)

方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
(自我形象化理解(帮助新手理解):当儿子从父亲那里继承了包之后 他觉得现在这个锤子不太好用,决定重新换个锤子头或者锤子把 这就称之为:方法的重写.)

数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据.
(自行理解,这块用的少.)

对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法.
(自行理解,这块用的少.)

定义一个类的格式

class 类名:                        # 创建一个类必写
    类变量名 = 类变量的值            # 非必需
    def 方法名1:                   # 基本必需 不然创建这个类就没有意义了
        实例变量名 = 实例变量的值    # 非必需
        方法块
    .
    .
    .
    def 方法名N:
        方法块

# 实例化这个类
变量名People = 类名()    # 这样就实例化了一个对象 相当于我们之前说的创建了一个人使用这个包.
变量名People.方法名1()   # 这样就可以调用 实例化对象的方法了.

初始化方式

class Fun:
    # __init__这个方法会在你创建实例的时候自动执行
    def __init__(self,name): # 新手可能会对self这个词有所疑惑,我只能建议你,每个方法都要写self,并且是写在第一个参数位置的,新手直接无视 也就是当作没有self这个词就可以了.
        print(‘初始化这个实例对象的人是:{}‘.format(name))

# 我们实例化一下这个类
fun = Fun(‘Mrzhang‘)

# 然后就会自动打印
初始化这个实例对象的人是:Mrzhang    #就将Mrzhang传给这个方法了.

继承的格式

class Animal:   # 创建了一个动物animal类 动物都可以吃
    def eat(self):
        print(‘Animal is eat‘)

class Dog(Animal):    # 创建了一个dog类 继承animal
    def run(self):
        print(‘Dog is run‘) # 也就是说 dog 类既有 run方法 也有 eat吃 方法

dog = Dog()
dog.eat()
dog.run()

# 输出
Animal is eat
Dog is run

基本的就讲这么多 后面给三道我当初学习的时候练的题练三遍.不管看懂没看懂先照着敲三遍 再回头来看概念就清晰了.

第一题

# coding=utf-8
"""
一：定义一个学生类。有下面的类属性：
1 姓名
2 年龄
3 成绩（语文，数学，英语)[每课成绩的类型为整数]
类方法：
1 获取学生的姓名：get_name() 返回类型:str
2 获取学生的年龄：get_age() 返回类型:int
3 返回3门科目中最高的分数。get_course() 返回类型:int
写好类以后，可以定义2个同学测试下:
zm = Student(‘zhangming‘,20,[69,88,100])
返回结果：
zhangming
20
100
"""
class Student(object):
    def __init__(self, name, age, scores):
        self.name = name
        self.age = age
        self.scores = scores

    def get_name(self):
        return self.name

    def get_age(self):
        return self.age

    def get_course(self):
        return max(self.scores)


zm = Student(‘zhangming‘, 20, [69, 88, 100])
print(zm.get_name())
print(zm.get_age())
print(zm.get_course())

# 输出下面这些数值就是没有问题了
zhangming
20
100

第二题

"""
二：定义一个字典类：dictclass。完成下面的功能：
dict = dictclass({你需要操作的字典对象})
1 删除某个key
del_dict(key)
2 判断某个键是否在字典里，如果在返回键对应的值，不存在则返回"not found"
get_dict(key)
3 返回键组成的列表：返回类型;(list)
get_key()
4 合并字典，并且返回合并后字典的values组成的列表。返回类型:(list)
update_dict({要合并的字典})
"""


class dictclass(object):
    def __init__(self, dict):
        self.dict = dict

    def get_dict(self, key):
        if key in self.dict:
            return self.dict[key]
        return ‘not found‘

    def del_dict(self, key):
        if key in self.dict:
            self.dict.pop(key)
        else:
            return ‘no that key‘

    def get_key(self):
        return self.dict.keys()

    def updata_dict(self, dict2):
        self.dict = dict(self.dict, **dict2)
        return self.dict.values()


A = dictclass({‘a‘: 1, ‘b‘: 2})
print(A.get_dict(‘c‘))
print(A.del_dict(‘c‘))
print(A.get_key())
print(A.updata_dict({‘c‘: 3, ‘d‘: 4}))

# 关于删除字典中的元素
# pop 删除并返回对应的value值
B = {‘a‘: 1, ‘b‘: 2}
print(B.pop(‘b‘))
print(B)
# del void不返回值
C = {‘a‘: 1, ‘b‘: 2}
del C[‘a‘]
print(C)
# del dict 删除字典，不存在这个字典
# dict.clear()删除字典内所有元素但字典还是存在只是没有元素
D = {‘a‘: 1, ‘b‘: 2, ‘c‘: 3}
D.clear()

# 关于合并字典
A = {‘a‘: 1, ‘b‘: 2, ‘c‘: 3}
B = {‘d‘: 4, ‘e‘: 5, ‘f‘: 6}
C = A.update(B)
D = dict(A, **B)  # 这种合并方法会比上一种快很多对于重复的key，B会覆盖A

# 输出下列值就没有问题:
not found
no that key
dict_keys([‘a‘, ‘b‘])
dict_values([1, 2, 3, 4])
2
{‘a‘: 1}
{‘b‘: 2}

第三题

"""
定义一个列表的操作类：Listinfo
包括的方法:
1 列表元素添加: add_key(keyname)  [keyname:字符串或者整数类型]
2 列表元素取值：get_key(num) [num:整数类型]
3 列表合并：update_list(list)      [list:列表类型]
4 删除并且返回最后一个元素：del_key()
list_info = Listinfo([44,222,111,333,454,‘sss‘,‘333‘])
"""


class Listinfo(object):
    def __init__(self, list_val):
        self.varlist = list_val

    def add_key(self, key_name):
        if isinstance(key_name, (str, int)):
            self.varlist.append(key_name)
            return self.varlist
        else:
            return ‘error‘

    def get_key(self, num):
        if num >= 0 and num < len(self.varlist):
            return self.varlist[num]
        else:
            return ‘error‘

    def update_list(self, List_et):
        self.varlist.extend(List_et)
        return self.varlist

    def del_key(self):
        if len(self.varlist) >= 0:
            return self.varlist.pop(-1)
        else:
            return ‘error‘


list_info = Listinfo([44, 222, 111, 333, 454, ‘sss‘, ‘333‘])
print(list_info.add_key(‘1111‘))
print(list_info.get_key(4))
print(list_info.update_list([‘1‘, ‘2‘, ‘3‘]))
print(list_info.del_key())

# 输出下列数据就没有问题:
[44, 222, 111, 333, 454, ‘sss‘, ‘333‘, ‘1111‘]
454
[44, 222, 111, 333, 454, ‘sss‘, ‘333‘, ‘1111‘, ‘1‘, ‘2‘, ‘3‘]
3

如果大家练完了 三遍这三道题 我相信 大家对面向对象的基本操作有了一定的了解了. 建议大家再回头看看面向对象的概念.剩下的 小问题就在实战中去解决吧.