python（面向对象-类封装调用）

时间：2022-10-04 03:47:15
一、面对对象思想
（1）大家肯定听过 Python 中”一切皆对象“的说法，但可能并不了解它的具体含义，只是在学习的时候听说 Python 是面向对象的编程语言，本节将向大家详细介绍 Python 面向对象的含义。
  • 面向对象编程是在面向过程编程的基础上发展来的，它比面向过程编程具有更强的灵活性和扩展性。
  • 面向对象编程（Object-oriented Programming，简称 OOP），是一种封装代码的方法。其实，在前面章节的学习中，我们已经接触了封装
  • 代码封装，其实就是隐藏实现功能的具体代码，仅留给用户使用的接口，就好像使用计算机，用户只需要使用键盘、鼠标就可以实现一些功能，而根本不需要知道其内部是如何工作的。
  • 面向对象编程，也是一种封装的思想，它可以更好地模拟真实世界里的事物（将其视为对象），并把描述特征的数据和代码块（函数）封装到一起。

（2）为什么说”一切皆对象“

a = 2

print(id(a))

print(type(a))

b = 3

print(id(b))

print(type(b))

b = 2

print(id(b)

#输出结果如下

1441688672

<class 'int'>

1441688704

<class 'int'>

1441688672
  • 如上述代码中，实际上整形数据2、3其实都是 integer class（整形类的一个实例对象），而 a、b只不过是这些对象的一个标签，可以简单理解为2、3是两个人，而a、b分别是他们的名字。就算把3的名字给了2这个人，那2这个人也是不会变的。这里的变指的是他们在内存中的地址，也就是上面例子中的 id() 。
 
二、类的理解
  • 类：用来描述具有相同的属性和方法的对象的集合。可以理解是一个模板，通过它可以创建出无数个具体实例。
  • 对象：类并不能直接使用，通过类创建出的实例（又称对象）才能使用。这有点像汽车图纸和汽车的关系，图纸本身（类）并不能为人们使用，通过图纸创建出的一辆辆车（对象）才能使用。
  • 对象和类的关系：类和对象的关系就像模具和铸件的关系，类的实例化的结果就是对象，而对象的抽象体就是类。
  • 属性：类中的所有变量称为属性。例如下面的 Student 类中的 self.name 和 self.score
  • 方法：类中的所有函数通常称为方法。不过，和函数所有不同的是，类方法至少要包含一个 self 参数（后续会做详细介绍）。类方法无法单独使用，只能和类的对象一起使用。
类和实例
面向对象最重要的概念就是类（Class）和实例（Instance），必须牢记类是抽象的模板，比如 Student类，而实例是根据类创建出来的一个个具体的“对象”，每个对象都拥有相同的方法，但各自的数据可能不同。
 
仍以 Student 类为例，在 Python 中，定义类是通过 class 关键字：
class Student(object):

    pass

class 后面紧接着是类名，即 Student，类名通常是大写开头的单词，紧接着是(object)，表示该类是从哪个类继承下来的，继承的概念我们后面再讲，通常，如果没有合适的继承类，就使用 object类，这是所有类最终都会继承的类。

1.类定义：
  • class定义类
  • class 后面加 类名称 加 () 加 :

2.类名称定义规范：

  • 不要以纯数字命名
  • 不要以python中保留字符（关键字）来命名
  • 不要以文件名命名
  • 不能出现特殊字符
  • 要简短且见名知义
  • 当类名称中有多个单词时，应采用驼峰式（每个单词首字母大写） --> XinFangShuo()

定义好了 Student 类，就可以根据 Student 类创建出 Student 的实例，创建实例是通过类名+()实现的：

bart = Student()

可以看到，变量 bart 指向的就是一个 Student 的实例，而 Student 本身则是一个类。

由于类可以起到模板的作用，因此，可以在创建实例的时候，把一些我们认为必须绑定的属性强制填写进去。通过定义一个特殊的__init__方法，在创建实例的时候，就把 name，score 等属性绑上去：
class Student(object):

    def __init__(self, name, score):

        self.name = name

        self.score = score

注意：特殊方法“__init__”前后分别有两个下划线！！！

注意到__init__方法的第一个参数永远是 self，表示创建的实例本身，因此，在__init__方法内部，就可以把各种属性绑定到 self，因为 self 就指向创建的实例本身。
 
有了__init__方法，在创建实例的时候，就不能传入空的参数了，必须传入与__init__方法匹配的参数，但 self 不需要传，Python 解释器自己会把实例变量传进去：
 bart = Student('Bart Simpson', 59)

和普通的函数相比，在类中定义的函数只有一点不同，就是第一个参数永远是实例变量 self，并且调用时，不用传递该参数。除此之外，类的方法和普通函数没有什么区别，所以，你仍然可以用默认

参数、可变参数、关键字参数和命名关键字参数。
 
class Four():           #类的定义

    def sub(self,x,y):

        return x + y

"""

class Dog():

    def __init__(self,name,age):

        self.name = name

        self.age = age

    def sit(self):

        print (self.name.title() + ' ' + "is now sitting")

    def roll_over(self):

        print (self.name.title() + ' ' + "is now roll over")

my_dog = Dog('willie',6)    #参数实例化

# your_dog = Dog('lucy',3)

my_dog.sit()

my_dog.roll_over()

"""

"""

class Four_operations():

    def __init__(self,a,b):

        self.a = int(a)

        self.b = int(b)

    def add(self):

        return self.a + self.b

    def reduce(self):

        return self.a - self.b

    def ride(self):

        return self.a * self.b

    def Except(self):

        return self.a / self.b

operation = Four_operations('12','4')

print (operation.add())

print (operation.reduce())

print (operation.ride())

print (operation.Except())

"""
class ReadWrite():

    """

    txt文件读取类

    """

    def __init__(self,filepath):

        self.filepath = filepath

    def read(self,index=0):

        with open(self.filepath) as book:

            return book.read().splitlines()[index]

    def write(self,body):

        with open(self.filepath,"w") as book:

            book.write(body)

ReadWrite("d:\\test1.txt").write("大家好，我是郑迎！")

print (ReadWrite("d:\\test1.txt").read())
#coding=utf-8

mysql = {"zhangsan":"","lisi":"","wangwu":""}

class LoginRegister():

    """

    登录注册函数封装实现如下：

    1.登录mysql中的账号密码成功

    2.密码错误则重新输入密码

    3.账号错误调用注册方法进行注册，注册成功后调用登录方法登录已注册的账号

    """

    def login(self):

        user = input("username:")

        if user in mysql.keys():

            for i in range(3):

                pwd = input("password:")

                if pwd == mysql.get(user):

                    print ("Login ok")

                    break

                else:

                    print ("密码输错三次，将锁定账号！")

        else:

            print ("Please register first!")

            LoginRegister().register()

    def register(self):

        user = input("Input you username:")

        while True:

            pwd = input("Input you password:")

            repwd = input("Input you password again:")

            if repwd == pwd:

                mysql.setdefault(user,pwd)

                print ("Register ok,sign in now!")

                LoginRegister().login()

                break

            else:

                print ("两次密码不一致，请重新输入！")

LoginRegister().login()
 三、类的封装/调用
 调用类下的方法，必需通过类的的实例/类名（）进行调用
  • 当类中初始化方法__init__中存在参数时，则在实例化时，需要往实例括号中传入参数
  • 当类中无初始化方法或者__init__中不存在参数时，则在实例化时，不需要往实例括号中传入参数，而在调用方法时再进行传参
class Four():

    def sub(self,x,y):

        return x + y

print Four().sub(2,3)

class Four_operations():

    def __init__(self,a,b):

        self.a = int(a)

        self.b = int(b)

    def add(self):

        return self.a + self.b

    def reduce(self):

        return self.a - self.b

    def ride(self):

        return self.a * self.b

    def Except(self):

        return self.a / self.b

operation = Four_operations('','')        #实例化

print (operation.add())

print (operation.reduce())

print (operation.ride())

print (operation.Except())

四、面向对象和面向过程

  • 面向过程：吃(狗，屎)
    • 优点：流程化，分步骤实现，效率高，代码短小精悍
    • 缺点：思考难道大，代码复用率低，扩展差，难维护
def eat(dog,food):

        return "{} love to eat {}.".format(dog,food)

print(eat("XiaoHei","shit"))

#结果如下

XiaoHei love to eat shit.
  • 面向对象：狗.吃(屎)
    • 优点：结构化，模块化，易扩展，可继承，可覆盖，易维护
    • 缺点：程序臃肿，性能低
class Dog():

    def eat(self,food):

        return "Dogs love to eat {}.".format(food)

print(Dog().eat("shit"))

#结果如下

Dogs love to eat shit.

相关文章