前往小程序，Get更优阅读体验！
立即前往
文档建议反馈控制台
首页
学习
活动
专区
工具
TVP
腾讯云架构师技术同盟
文章/答案/技术大牛
发布
首页
学习
活动
专区
工具
TVP腾讯云架构师技术同盟
返回腾讯云官网
社区首页 >专栏 >python3–面向对象–类

python3–面向对象–类

作者头像
老七Linux
发布于 2018-05-09 17:20:16
发布于 2018-05-09 17:20:16
95400
代码可运行
举报
文章被收录于专栏：Laoqi's Linux运维专列Laoqi's Linux运维专列
运行总次数：0
代码可运行

类

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

1.创建类
代码语言：javascript
代码运行次数：0
复制
class A(object):
    pass
一、 A为类的名字：（首字母大写，多个单词拼接的时候首字母也是大写！）
二、 类里面一般都是由多个函数组成，函数的第一个参数默认都是self。
三、 如果需要全局变量，就在类的内部直接定义。
四、 类的内部在调用函数或者调用变量的时候，必须使用 self.变量 或 self.函数
五、 类的实例化：
代码语言：javascript
代码运行次数：0
复制
实例化类的首字母小写作为实例，然后类实例化
studentName =  StudentName();
六、构造器：

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

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

代码语言：javascript
代码运行次数：0
复制
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'

我们需要给一个参数：

代码语言：javascript
代码运行次数：0
复制
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的呢？

因为没有调用！！

代码语言：javascript
代码运行次数：0
复制
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
七、继承
代码语言：javascript
代码运行次数：0
复制
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()

输出：
初始化一个构造器

当我们给定一个参数值：

代码语言：javascript
代码运行次数：0
复制
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的整个给继承下来

输出：
初始化一个构造器
重写：
代码语言：javascript
代码运行次数：0
复制
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还是它自己的呢？

代码语言：javascript
代码运行次数：0
复制
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...

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

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

代码语言：javascript
代码运行次数：0
复制
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这两个子类中去找初始化函数，如果两个中都没有，就回去父类中去找：

代码语言：javascript
代码运行次数：0
复制
输出：
I'm a cute cat!!
I'm a little cat and i can run...
I'm a cute cat!!

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

代码语言：javascript
代码运行次数：0
复制
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：

代码语言：javascript
代码运行次数：0
复制
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...

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

类的私有和公有变量

代码语言：javascript
代码运行次数：0
复制
'''
定义一个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

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

代码语言：javascript
代码运行次数：0
复制
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()

需要时间琢磨：

代码语言：javascript
代码运行次数：0
复制
'''
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 条评论
热度
最新
登录 后参与评论
推荐阅读
目录
  • 类
    • 1.创建类
    • 一、 A为类的名字：（首字母大写，多个单词拼接的时候首字母也是大写！）
    • 二、 类里面一般都是由多个函数组成，函数的第一个参数默认都是self。
    • 三、 如果需要全局变量，就在类的内部直接定义。
    • 四、 类的内部在调用函数或者调用变量的时候，必须使用 self.变量 或 self.函数
    • 五、 类的实例化：
    • 六、构造器：
    • 七、继承
      • 重写：
  • 类的私有和公有变量
领券

腾讯云开发者

扫码关注腾讯云开发者

扫码关注腾讯云开发者

领取腾讯云代金券

热门产品

热门推荐

更多推荐

Copyright © 2013 - 2025 Tencent Cloud. All Rights Reserved. 腾讯云 版权所有 

深圳市腾讯计算机系统有限公司 ICP备案/许可证号：粤B2-20090059 深公网安备号 44030502008569

腾讯云计算（北京）有限责任公司 京ICP证150476号 |  京ICP备11018762号 | 京公网安备号11010802020287

问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档

Copyright © 2013 - 2025 Tencent Cloud.

All Rights Reserved. 腾讯云 版权所有

登录 后参与评论