python3–面向对象–类

老七Linux

发布于 2018-05-09 17:20:16

9210

发布于 2018-05-09 17:20:16

文章被收录于专栏：Laoqi's Linux运维专列Laoqi's Linux运维专列

类

用于定义表示用户定义对象的一组属性的原型。属性是通过点符号访问的数据成员(类变量和实例变量)和方法。

1.创建类

class A(object):
    pass

一、 A为类的名字：（首字母大写，多个单词拼接的时候首字母也是大写！）

二、类里面一般都是由多个函数组成，函数的第一个参数默认都是self。

三、如果需要全局变量，就在类的内部直接定义。

四、类的内部在调用函数或者调用变量的时候，必须使用 self.变量或 self.函数

五、类的实例化：

实例化类的首字母小写作为实例，然后类实例化
studentName =  StudentName();

六、构造器：

类在初始化的时候，首先，必须要执行的函数;

写一个简单的构造器程序：

class A(object):
    def __init__(self, name):
        self.name = name
        print("this is a test test!!")

    def hello(self):
        print("hello {0}".format(self.name))

a = A()     //如果A 里面不传参数是不会打印的

输出：
    a = A()
TypeError: __init__() missing 1 required positional argument: 'name'

我们需要给一个参数：

class A(object):
    def __init__(self, name):
        self.name = name
        print("this is a test test!!")

    def hello(self):
        print("hello {0}".format(self.name))

a = A(“zhdya”)

输出：
this is a test test!!

当然也是我的疑问，为什么没有输出hello的呢？

因为没有调用！！

class A(object):
    def __init__(self, name):
        self.name = name
        print("this is a test test!!")

    def hello(self):
        print("hello {0}".format(self.name))

a = A("zhdya")
a.hello()
输出：
this is a test test!!
hello zhdya

七、继承

class Animals(object):
    def __init__(self):
        print("初始化一个构造器")
    def run(self):      //定义一个函数
        print("Animal can run")

class Bird(Animals):        //继承Animals的函数
    def fly(self):
        print("Birds can flyyyy")

class Cat(Animals):         //继承Animals的函数
    def miao(self):
        print("miao miao miao ~~")

animals = Animals()

输出：
初始化一个构造器

当我们给定一个参数值：

class Animals(object):
    def __init__(self):
        print("初始化一个构造器")
    def run(self):
        print("Animal can run")

class Bird(Animals):
    def fly(self):
        print("Birds can flyyyy")

class Cat(Animals):
    def miao(self):
        print("miao miao miao ~~")

# animals = Animals()
cat = Cat()     //因为只是继承Animals，自己没有初始化函数，所还是依然会把Animals的整个给继承下来

输出：
初始化一个构造器

重写：

class Animals(object):
    def __init__(self):
        print("初始化一个构造器")
    def run(self):
        print("Animal can run")

class Bird(Animals):
    def fly(self):
        print("Birds can flyyyy")

class Cat(Animals):
    def __init__(self):
        print("I'm a cute cat!!")
    def miao(self):
        print("miao miao miao ~~")

# animals = Animals()
cat = Cat()

输出：
I'm a cute cat!!

由此可以看出：

重写先去找子类中的方法，如果子类中 class Cat(Animals) 找不到对应的方法，就去父类中找 class Animals(object)。

当cat()这个函数发现自己的子类中是有这个初始化函数的时候，就会直接输出，不再去父类中去找。

同理我们再次写一个cat的run函数：

当调用cat.run()的时候是执行父类的run还是它自己的呢？

class Animals(object):
    def __init__(self):
        print("初始化一个构造器")
    def run(self):
        print("Animal can run")

class Bird(Animals):
    def fly(self):
        print("Birds can flyyyy")

class Cat(Animals):
    def __init__(self):
        print("I'm a cute cat!!")
    def miao(self):
        print("miao miao miao ~~")
    def run(self):
        print("I'm a little cat and i can run...")

# animals = Animals()
cat = Cat()
cat.run()

输出：
I'm a cute cat!!
I'm a little cat and i can run...

这样就再次验证了，只要是自己有的函数，就直接输出自己的。没有的就会去调用父类的。

假如有个子类，同样继承了其他两个子类：多继承

class Animals(object):
    def __init__(self):
        print("初始化一个构造器")
    def run(self):
        print("Animal can run")

class Bird(Animals):
    def fly(self):
        print("Birds can flyyyy")

class Cat(Animals):
    def __init__(self):
        print("I'm a cute cat!!")
    def miao(self):
        print("miao miao miao ~~")
    def run(self):
        print("I'm a little cat and i can run...")

class NNBB(Bird, Cat):
    def nnnn(self):
        print("I'm so NB!!")


# animals = Animals()
cat = Cat()
cat.run()
nnbb = NNBB()

如上，NNBB()不仅继承了Bird还集成了Cat，当调用的时候，就也会去Bird和Cat这两个子类中去找初始化函数，如果两个中都没有，就回去父类中去找：

输出：
I'm a cute cat!!
I'm a little cat and i can run...
I'm a cute cat!!

如果把Cat中的初始化函数，注释掉：

class Animals(object):
    def __init__(self):
        print("初始化一个构造器")
    def run(self):
        print("Animal can run")

class Bird(Animals):
    def fly(self):
        print("Birds can flyyyy")

class Cat(Animals):
    # def __init__(self):
    #     print("I'm a cute cat!!")
    def miao(self):
        print("miao miao miao ~~")
    def run(self):
        print("I'm a little cat and i can run...")

class NNBB(Bird, Cat):
    def nnnn(self):
        print("I'm so NB!!")


# animals = Animals()
cat = Cat()
cat.run()
nnbb = NNBB()

输出：
初始化一个构造器
I'm a little cat and i can run...
初始化一个构造器

这样就验证了，如果子类中没有，就会去父类中去找。

那我们就会用这样的需求，我们的需求就是先从父类中初始化，然后再次初始化子类，这样就需要一个 supper：

class Animals(object):
    def __init__(self):
        print("初始化一个构造器")
    def run(self):
        print("Animal can run")

class Bird(Animals):
    def fly(self):
        print("Birds can flyyyy")

class Cat(Animals):
    def __init__(self):
        super(Cat, self).__init__()
        print("I'm a cute cat!!")
    def miao(self):
        print("miao miao miao ~~")
    def run(self):
        print("I'm a little cat and i can run...")



# animals = Animals()
cat = Cat()
cat.run()

输出：
初始化一个构造器
I'm a cute cat!!
I'm a little cat and i can run...

这样我们就很清楚的看到先从父类取到了初始化函数，然后再去子类中去找。

类的私有和公有变量

'''
定义一个mysql的类：
host， port， username， password
'''
class MysqlArgs(object):
    ##如下的这些参数是MysqlArgs类的私有变量，外面的子类是不可以调用和修改的。
    __host = str("2.2.2.2")
    __port = str()
    __username = str()
    __passwd = str()

    ##如下这个是类似于公有变量，任何人可以调用
    name = "zhdya"

    ##只能实例自己调用
    __host = "私有的key·"
    def getHost(self):
        return self.__host
    def setHost(self):
        return self.__host

mysqlArgs = MysqlArgs()
print(mysqlArgs.getHost())

mysqlArgs.name = "传给你一个新的keyyyysss"
print(mysqlArgs.name)

输出：
私有的key·
传给你一个新的keyyyysss

使用类函数重新定义阶乘：

class JinCinCount(object):
    def __init__(self, n):
        self.n = n
    def jc(self, n):
        result = 1
        if n == 0:
            return result
        else:
            for i in range(1, n+1):
                result *= i
            return result
    def count(self):
        count = 0
        for i in range(0, int(self.n) + 1):
            count += self.jc(i)
        print("count = {0}".format(count))

def main():
    n = input("Please inpurt a number: ")
    jinCinCount = JinCinCount(int(n))
    jinCinCount.count()

if __name__ == "__main__":
    main()

需要时间琢磨：

'''
10学生

id
name
score
'''

# class Student(object):
#     __id = int()
#     __name = str()
#     __score = int()
#
#     def getId(self):
#         return self.__id
#     def setId(self, id):
#         self.__id = id
#
#     def getName(self):
#         return self.__name
#     def setName(self, name):
#         self.__name = name
#
#     def getScore(self):
#         return self.__score
#     def setScore(self, score):
#         self.__score = score
import codecs


class Student(object):
    def __init__(self, id, name, score):
        self.id = id
        self.name = name
        self.score = score



class InitStduents():
    def __init__(self):
        self.students = list()
        self.init()
    def init(self):
        self.students.append(Student(1001, "aaa", 59))
        self.students.append(Student(1002, "bbb", 96))
        self.students.append(Student(1003, "ccc", 87))
        self.students.append(Student(1004, "ddd", 89))
        self.students.append(Student(1005, "eee", 33))
        self.students.append(Student(1006, "fff", 85))
        self.students.append(Student(1007, "ggg", 78))
        self.students.append(Student(1008, "hhh", 97))
        self.students.append(Student(1009, "iii", 31))
        self.students.append(Student(1010, "jjj", 93))

    def sort(self):
        return sorted(self.students, key=lambda student: student.score)

    def writeFile(self, newStudents):
        with codecs.open("sortStudent.txt", "w")as f:
            for i in newStudents:
                f.write("id = {0}".format(i.id))
                f.write("\t")
                f.write("name = {0}".format(i.name))
                f.write("\t")
                f.write("score = {0}".format(i.score))
                f.write("\n")


def main():
    students = InitStduents()
    newStudents = students.sort()
    students.writeFile(newStudents)


if __name__ == "__main__":
    main()

本文参与腾讯云自媒体分享计划，分享自作者个人站点/博客。

原始发表：2017/04/21，如有侵权请联系 cloudcommunity@tencent.com 删除

其他

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体分享计划，欢迎热爱写作的你一起参与！

其他

登录后参与评论

0 条评论

热度