进击的Python【第六章】：Python的高级应用（三）面向对象编程

Python的高级应用（三）面向对象编程

本章学习要点：

  1. 面向对象编程介绍
  2. 面向对象与面向过程编程的区别
  3. 为什么要用面向对象编程思想
  4. 面向对象的相关概念

一、面向对象编程介绍

　　面向对象程序设计（英语：Object-oriented programming，缩写：OOP）是一种程序设计范型，同时也是一种程序开发的方法。对象指的是类的实例。

　　已经被证实的是，面向对象程序设计推广了程序的灵活性和可维护性，并且在大型项目设计中广为应用。 此外，支持者声称面向对象程序设计要比以往的做法更加便于学习，因为它能够让人们更简单地设计并维护程序，使得程序更加便于分析、设计、理解。反对者在某些领域对此予以否认。

　　当我们提到面向对象的时候，它不仅指一种程序设计方法。它更多意义上是一种程序开发方式。在这一方面，我们必须了解更多关于面向对象系统分析和面向对象设计（Object Oriented Design，简称OOD）方面的知识。

二、面向对象与面向过程编程的区别

　　面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了；面向对象是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。

　　可以拿生活中的实例来理解面向过程与面向对象，例如五子棋，面向过程的设计思路就是首先分析问题的步骤：1、开始游戏，2、黑子先走，3、绘制画面，4、判断输赢，5、轮到白子，6、绘制画面，7、判断输赢，8、返回步骤2，9、输出最后结果。把上面每个步骤用不同的方法来实现。

　　如果是面向对象的设计思想来解决问题。面向对象的设计则是从另外的思路来解决问题。整个五子棋可以分为1、黑白双方，这两方的行为是一模一样的，2、棋盘系统，负责绘制画面，3、规则系统，负责判定诸如犯规、输赢等。第一类对象（玩家对象）负责接受用户输入，并告知第二类对象（棋盘对象）棋子布局的变化，棋盘对象接收到了棋子的变化就要负责在屏幕上面显示出这种变化，同时利用第三类对象（规则系统）来对棋局进行判定。

　　可以明显地看出，面向对象是以功能来划分问题，而不是步骤。同样是绘制棋局，这样的行为在面向过程的设计中分散在了多个步骤中，很可能出现不同的绘制版本，因为通常设计人员会考虑到实际情况进行各种各样的简化。而面向对象的设计中，绘图只可能在棋盘对象中出现，从而保证了绘图的统一。

三、为什么要用面向对象编程思想

　　面向对象是为了解决系统的可维护性，可扩展性，可重用性，我们再进一步思考，面向对象为什么能解决系统的可维护性，可扩展性，可重用性？

　　面向对象产生的历史原因有下面两点：

　　1、 计算机是帮助人们解决问题的，然而计算机终究是个机器，他只会按照人所写的代码，一步一步的执行下去，最终得到了结果，因此无论程序多么的复杂，计算机总是能轻松应付。结构化编程，就是按照计算机的思维写出的代码，但是人看到这么复杂的逻辑，就无法维护和扩展了。

　　2、 结构化设计是以功能为目标来设计构造应用系统，这种做法导致我们设计程序时，不得不将客体所构成的现实世界映射到由功能模块组成的解空间中，这种转换过程，背离了人们观察和解决问题的基本思路。

　　可见结构化设计在设计系统的时候，无法解决重用、维护、扩展的问题，而且会导致逻辑过于复杂，代码晦涩难懂。于是人们就想，能不能让计算机直接模拟现实的环境，用人类解决问题的思路、习惯、步骤来设计相应的应用程序？这样的程序，人们在读它的时候，会更容易理解，也不需要再把现实世界和程序世界之间来回做转换。

　　与此同时，人们发现，在现实世界中存在的客体是问题域中的主角。所谓客体是指客观存在的对象实体和主观抽象的概念，这种客体具有属性和行为，而客体是稳定的，行为是不稳定的，同时客体之间具有各种联系，因此面向客体编程，比面向行为编程，系统会更稳定。在面对频繁的需求更改时，改变的往往是行为，而客体一般不需要改变，所以我们就把行为封装起来，这样改变时候只需要改变行为即可，主架构则保持了稳定。

　　于是面向对象就产生了。

　　然而人们追求的系统可维护性，可扩展性，可重用性又是怎么在面向对象中体现出来的呢？

　　首先看看面向对象的三大特征：

　　封装：找到变化并且把它封装起来，你就可以在不影响其它部分的情况下修改或扩展被封装的变化部分，这是所有设计模式的基础，就是封装变化，因此封装的作用，就解决了程序的可扩展性。

　　继承：子类继承父类，可以继承父类的方法及属性，实现了多态以及代码的重用，因此也解决了系统的重用性和扩展性。但是继承破坏了封装，因为他是对子类开放的，修改父类会导致所有子类的改变，因此继承一定程度上又破坏了系统的可扩展性，所以继承需要慎用。只有明确的IS-A关系才能使用，同时继承在在程序开发过程中重构得到的，而不是程序设计之初就使用继承，很多面向对象开发者滥用继承，结果造成后期的代码解决不了需求的变化了。因此优先使用组合，而不是继承，是面向对象开发中一个重要的经验。

　　多态：接口的多种不同的实现方式即为多态。接口是对行为的抽象，刚才在封装提到，找到变化部分并封装起来，但是封装起来后，怎么适应接下来的变化？这正是接口的作用，接口的主要目的是为不相关的类提供通用的处理服务，我们可以想象一下。比如鸟会飞，但是超人也会飞，通过飞这个接口，我们可以让鸟和超人，都实现这个接口，这就实现了系统的可维护性，可扩展性。

　　因此面向对象能实现人们追求的系统可维护性，可扩展性，可重用性。面向对象是一种编程思想，起初，“面向对象”是专指在程序设计中采用封装、继承、多态等设计方法，但面向对象的思想已经涉及到软件开发的各个方面，比如现在细分为了面向对象的分析(OOA)，面向对象的设计(OOD)，面向对象的编程实现(OOP)

四、面向对象的相关概念

  • 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
  • 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
  • 数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。
  • 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
  • 实例变量：定义在方法中的变量，只作用于当前实例的类。
  • 继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
  • 实例化：创建一个类的实例，类的具体对象。
  • 方法：类中定义的函数。
  • 对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

1、创建一个类

使用class语句来创建一个新类，class之后为类的名称并以冒号结尾，如下实例:

class ClassName:
   ‘类的帮助信息‘   #类文档字符串
   class_suite  #类体
  • 类的帮助信息可以通过ClassName.__doc__查看。
  • class_suite 由类成员，方法，数据属性组成。

以下是一个简单的Python类实例:

#!/usr/bin/python
# -*- coding: UTF-8 -*-

class Employee:
   ‘所有员工的基类‘
   empCount = 0

   def __init__(self, name, salary):
      self.name = name
      self.salary = salary
      Employee.empCount += 1

   def displayCount(self):
     print("Total Employee %d" % Employee.empCount)

   def displayEmployee(self):
      print("Name : ", self.name,  ", Salary: ", self.salary)
  • empCount变量是一个类变量，它的值将在这个类的所有实例之间共享。你可以在内部类或外部类使用Employee.empCount访问。
  • 第一种方法__init__()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法

2、创建实例对象

要创建一个类的实例，你可以使用类的名称，并通过__init__方法接受参数。

"创建 Employee 类的第一个对象"
emp1 = Employee("Zara", 2000)
"创建 Employee 类的第二个对象"
emp2 = Employee("Manni", 5000)

3、访问属性

您可以使用点(.)来访问对象的属性。使用如下类的名称访问类变量:

emp1.displayEmployee()
emp2.displayEmployee()
print("Total Employee %d" % Employee.empCount)

完整示例：

#!/usr/bin/python
# -*- coding: UTF-8 -*-

class Employee:
   ‘所有员工的基类‘
   empCount = 0

   def __init__(self, name, salary):
      self.name = name
      self.salary = salary
      Employee.empCount += 1

   def displayCount(self):
     print("Total Employee %d" % Employee.empCount)

   def displayEmployee(self):
      print("Name : ", self.name,  ", Salary: ", self.salary)

"创建 Employee 类的第一个对象"
emp1 = Employee("Zara", 2000)
"创建 Employee 类的第二个对象"
emp2 = Employee("Manni", 5000)
emp1.displayEmployee()
emp2.displayEmployee()
print("Total Employee %d" % Employee.empCount)

执行以上代码输出结果如下：

Name :  Zara ,Salary:  2000
Name :  Manni ,Salary:  5000
Total Employee 2

你可以添加，删除，修改类的属性，如下所示：

emp1.age = 7  # 添加一个 ‘age‘ 属性
emp1.age = 8  # 修改 ‘age‘ 属性
del emp1.age  # 删除 ‘age‘ 属性

你也可以使用以下函数的方式来访问属性：

  • getattr(obj, name[, default]) : 访问对象的属性。
  • hasattr(obj,name) : 检查是否存在一个属性。
  • setattr(obj,name,value) : 设置一个属性。如果属性不存在，会创建一个新属性。
  • delattr(obj, name) : 删除属性。
hasattr(emp1, ‘age‘)    # 如果存在 ‘age‘ 属性返回 True。
getattr(emp1, ‘age‘)    # 返回 ‘age‘ 属性的值
setattr(emp1, ‘age‘, 8) # 添加属性 ‘age‘ 值为 8
delattr(empl, ‘age‘)    # 删除属性 ‘age‘

4、Python内置类属性

  • __dict__ : 类的属性（包含一个字典，由类的数据属性组成）
  • __doc__ :类的文档字符串
  • __name__: 类名
  • __module__: 类定义所在的模块（类的全名是‘__main__.className‘，如果类位于一个导入模块mymod中，那么className.__module__ 等于 mymod）
  • __bases__ : 类的所有父类构成元素（包含了一个由所有父类组成的元组）

Python内置类属性调用实例如下：

#!/usr/bin/python
# -*- coding: UTF-8 -*-

class Employee:
   ‘所有员工的基类‘
   empCount = 0

   def __init__(self, name, salary):
      self.name = name
      self.salary = salary
      Employee.empCount += 1

   def displayCount(self):
     print("Total Employee %d" % Employee.empCount)

   def displayEmployee(self):
      print("Name : ", self.name,  ", Salary: ", self.salary)

print("Employee.__doc__:", Employee.__doc__)
print("Employee.__name__:", Employee.__name__)
print("Employee.__module__:", Employee.__module__)
print("Employee.__bases__:", Employee.__bases__)
print("Employee.__dict__:", Employee.__dict__)

执行以上代码输出结果如下：

Employee.__doc__: 所有员工的基类
Employee.__name__: Employee
Employee.__module__: __main__
Employee.__bases__: ()
Employee.__dict__: {‘__module__‘: ‘__main__‘, ‘displayCount‘: <function displayCount at 0x10a939c80>, ‘empCount‘: 0, ‘displayEmployee‘: <function displayEmployee at 0x10a93caa0>, ‘__doc__‘: ‘\xe6\x89\x80\xe6\x9c\x89\xe5\x91\x98\xe5\xb7\xa5\xe7\x9a\x84\xe5\x9f\xba\xe7\xb1\xbb‘, ‘__init__‘: <function __init__ at 0x10a939578>}

5、析构函数------python对象销毁

同Java语言一样，Python使用了引用计数这一简单技术来追踪内存中的对象。

在Python内部记录着所有使用中的对象各有多少引用。

一个内部跟踪变量，称为一个引用计数器。

当对象被创建时， 就创建了一个引用计数， 当这个对象不再需要时， 也就是说， 这个对象的引用计数变为0 时， 它被垃圾回收。但是回收不是"立即"的， 由解释器在适当的时机，将垃圾对象占用的内存空间回收。

a = 40      # 创建对象  <40>
b = a       # 增加引用， <40> 的计数
c = [b]     # 增加引用.  <40> 的计数

del a       # 减少引用 <40> 的计数
b = 100     # 减少引用 <40> 的计数
c[0] = -1   # 减少引用 <40> 的计数

垃圾回收机制不仅针对引用计数为0的对象，同样也可以处理循环引用的情况。循环引用指的是，两个对象相互引用，但是没有其他变量引用他们。这种情况下，仅使用引用计数是不够的。Python 的垃圾收集器实际上是一个引用计数器和一个循环垃圾收集器。作为引用计数的补充， 垃圾收集器也会留心被分配的总量很大（及未通过引用计数销毁的那些）的对象。 在这种情况下， 解释器会暂停下来， 试图清理所有未引用的循环。

实例

#!/usr/bin/python
# -*- coding: UTF-8 -*-

class Point:
   def __init__( self, x=0, y=0):
      self.x = x
      self.y = y
   def __del__(self):
      class_name = self.__class__.__name__
      print(class_name, "销毁")

pt1 = Point()
pt2 = pt1
pt3 = pt1
print(id(pt1), id(pt2), id(pt3)) # 打印对象的id
del pt1
del pt2
del pt3

以上实例运行结果如下：

3083401324 3083401324 3083401324
Point 销毁

注意：通常你需要在单独的文件中定义一个类

6、类的继承

面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过继承机制。继承完全可以理解成类之间的类型和子类型关系。

需要注意的地方：继承语法 class 派生类名（基类名）：//... 基类名写作括号里，基本类是在类定义的时候，在元组之中指明的。

在python中继承中的一些特点：

  • 1：在继承中基类的构造（__init__()方法）不会被自动调用，它需要在其派生类的构造中亲自专门调用。
  • 2：在调用基类的方法时，需要加上基类的类名前缀，且需要带上self参数变量。区别于在类中调用普通函数时并不需要带上self参数
  • 3：Python总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。（先在本类中查找调用的方法，找不到才去基类中找）。

如果在继承元组中列了一个以上的类，那么它就被称作"多重继承" 。

语法：

派生类的声明，与他们的父类类似，继承的基类列表跟在类名之后，如下所示：

#!_*_coding:utf-8_*_
#__author__:"Alex Li"

class SchoolMember(object):
    members = 0 #初始学校人数为0
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def  tell(self):
        pass

    def enroll(self):
        ‘‘‘注册‘‘‘
        SchoolMember.members +=1
        print("\033[32;1mnew member [%s] is enrolled,now there are [%s] members.\033[0m " %(self.name,SchoolMember.members))

    def __del__(self):
        ‘‘‘析构方法‘‘‘
        print("\033[31;1mmember [%s] is dead!\033[0m" %self.name)
class Teacher(SchoolMember):
    def __init__(self,name,age,course,salary):
        super(Teacher,self).__init__(name,age)
        self.course = course
        self.salary = salary
        self.enroll()

    def teaching(self):
        ‘‘‘讲课方法‘‘‘
        print("Teacher [%s] is teaching [%s] for class [%s]" %(self.name,self.course,‘s12‘))

    def tell(self):
        ‘‘‘自我介绍方法‘‘‘
        msg = ‘‘‘Hi, my name is [%s], works for [%s] as a [%s] teacher !‘‘‘ %(self.name,‘Oldboy‘, self.course)
        print(msg)

class Student(SchoolMember):
    def __init__(self, name,age,grade,sid):
        super(Student,self).__init__(name,age)
        self.grade = grade
        self.sid = sid
        self.enroll()

    def tell(self):
        ‘‘‘自我介绍方法‘‘‘
        msg = ‘‘‘Hi, my name is [%s], I‘m studying [%s] in [%s]!‘‘‘ %(self.name, self.grade,‘Oldboy‘)
        print(msg)

if __name__ == ‘__main__‘:
    t1 = Teacher("Alex",22,‘Python‘,20000)
    t2 = Teacher("TengLan",29,‘Linux‘,3000)

    s1 = Student("Qinghua", 24,"Python S12",1483)
    s2 = Student("SanJiang", 26,"Python S12",1484)

    t1.teaching()
    t2.teaching()
    t1.tell()

7、类属性与方法

类的私有属性

__private_attrs：两个下划线开头，声明该属性为私有，不能在类地外部被使用或直接访问。在类内部的方法中使用时self.__private_attrs。

类的方法

在类地内部，使用def关键字可以为类定义一个方法，与一般函数定义不同，类方法必须包含参数self,且为第一个参数

类的私有方法

__private_method：两个下划线开头，声明该方法为私有方法，不能在类地外部调用。在类的内部调用 self.__private_methods

实例

#!/usr/bin/python
# -*- coding: UTF-8 -*-

class JustCounter:
	__secretCount = 0  # 私有变量
	publicCount = 0    # 公开变量

	def count(self):
		self.__secretCount += 1
		self.publicCount += 1
		print(self.__secretCount)

counter = JustCounter()
counter.count()
counter.count()
print(counter.publicCount)
print(counter.__secretCount)  # 报错，实例不能访问私有变量

Python 通过改变名称来包含类名:

1
2
2
Traceback (most recent call last):
  File "test.py", line 17, in <module>
    print counter.__secretCount  # 报错，实例不能访问私有变量
AttributeError: JustCounter instance has no attribute ‘__secretCount‘

Python不允许实例化的类访问私有数据，但你可以使用 object._className__attrName 访问属性，将如下代码替换以上代码的最后一行代码：

.........................
print counter._JustCounter__secretCount

执行以上代码，执行结果如下：

1
2
2
2

8、多态

再讲多态前，先上一段代码：

class Person(object):
    def __init__(self,name,sex):
        self.name = name
        self.sex = sex

    def print_title(self):
        if self.sex == "male":
            print("man")
        elif self.sex == "female":
            print("woman")

class Child(Person):                # Child 继承 Person
    def print_title(self):
        if self.sex == "male":
            print("boy")
        elif self.sex == "female":
            print("girl")

May = Child("May","female")
Peter = Person("Peter","male")

print(May.name,May.sex,Peter.name,Peter.sex)
May.print_title()
Peter.print_title()

当子类和父类都存在相同的 print_title()方法时，子类的 print_title() 覆盖了父类的 print_title()，在代码运行时，会调用子类的 print_title()

　　　　这样，我们就获得了继承的另一个好处：多态。

　　　　多态的好处就是，当我们需要传入更多的子类，例如新增 Teenagers、Grownups 等时，我们只需要继承 Person 类型就可以了，而print_title()方法既可以直不重写（即使用Person的），也可以重写一个特有的。这就是多态的意思。调用方只管调用，不管细节，而当我们新增一种Person的子类时，只要确保新方法编写正确，而不用管原来的代码。这就是著名的“开闭”原则：

  • 对扩展开放（Open for extension）：允许子类重写方法函数
  • 对修改封闭（Closed for modification）：不重写，直接继承父类方法函数
时间： 2024-11-25 04:57:32

进击的Python【第六章】：Python的高级应用（三）面向对象编程的相关文章

十三、Python高级功能之面向对象编程

Python高级功能之面向对象编程(类和对象) 一.类和对象: 面向过程和面向对象的编程 面向过程的编程:函数式编程,C程序等 面向对象的编程:C++,Java,Python等 类和对象:是面向对象中的两个重要概念 类:是对事物的抽象,比如:汽车模型 对象:是类的一个实例,比如:QQ轿车.大客车 范例说明: 汽车模型可以对汽车的特征和行为进行抽象,然后可以实例话为一台真实的汽车实体出来 二.Python类定义 Python类的定义: 使用class关键字定义一个类,并且类名的首字母要大写: 当程

Python之路【第五篇】：面向对象编程

面向对象编程思维导向图 http://naotu.baidu.com/file/03516c91377d6cad0ded041aa4ce4433?token=ccaba09527261666 密码: Tim 面向:过程.函数.对象 面向过程:根据业务逻辑从上到下写垒代码! 面向过程的编程弊:每次调用的时候都的重写,代码特别长,代码重用性没有,每次增加新功能所有的代码都的修改!那有什么办法解决上面出现的弊端呢?函数就出现了. 面向函数:将某功能代码封装到函数中,日后便无需重复编写,仅调用函数即可!

第六章 python高级功能

我们可以写一个小程序,由用户输入数据,将数据存入到列表当中,也可以将数据从列表中查询出来,但像这种操作只适合在缓冲区内进行操作,因为存储在列表中的数据,程序执行完之后,数据会立即消失,所以我们可以通过文件的操作将我们要保存的数据存到文件当中,当然这只是一种方法,实际要存储数据的话我们会选择数据库,这样更方便,那么文件与目录的操作会实现什么样的功能. 第一节    文件读写 目标: a.文件的打开和创建 b.文件读取 c.文件写入 d.内容查找和替换 e.文件删除,复制,重命名 f.目录操作 g.

第六章 Python类（面向对象编程）

什么是面向对象编程? 面向对象编程(Object Oriented Programming,OOP,面向对象程序设计)是一种计算机编程架构.Python就是这种编程语言. 面向对象程序设计中的概念主要包括:对象.类.继承.动态绑定.封装.多态性.消息传递.方法. 1)对象:类的实体,比如一个人. 2)类:一个共享相同结构和行为的对象的集合.通俗的讲就是分类,比如人是一类,动物是一类. 3)继承:类之间的关系,比如猫狗是一类,他们都有四条腿,狗继承了这个四条腿,拥有了这个属性. 4)动态绑定:在不

C Primer Plus （第五版） 第十六章 C预处理器和C库 编程练习

第十六章 C预处理器和C库 开发一个包含您需要使用的预处理器定义的头文件 //max.h  #ifndef _MAX_H_     #define _MAX_H_     #define MAX(X, Y) ((X)>(Y)?(X):(Y)) #endif 2.两个数的调和平均数可用如下方法得到:首先对两数的倒数取平均值,最后再取倒数.使用#define指令定义一个宏"函数"执行这个运算.编写一个简单的程序测试该宏. #include <stdio.h> #defin

python第六章

一.反射 cat = Cat('kitty') print cat.name # 访问实例属性 cat.sayHi() # 调用实例方法 print dir(cat) # 获取实例的属性名,以列表形式返回 if hasattr(cat, 'name'): # 检查实例是否有这个属性 setattr(cat, 'name', 'tiger') # same as: a.name = 'tiger' print getattr(cat, 'name') # same as: print a.name

第十六章 Python正则表达式

正则表达式在每种语言中都会有,目的就是匹配符合你预期要求的字符串. Python正则表达式主要由re库提供,拥有了基本所有的表达式. 16.1 Python正则表达式 符号 描述 示例 . 匹配除换行符(\n)之外的任意单个字符 字符串123\n456,匹配123:1.3 ^ 匹配字符串开头 abc\nxyz,匹配以abc开头的行:^abc $ 匹配字符串结尾 abc\nxyz,匹配以xyz结束的行:xyz$ * 匹配多个 hello\nword,匹配以w开头d结尾的单词:w*d + 匹配1个或

第十六章：创建高级联结

@author: Tobin @date: 2019/10/31 19:27:19 介绍如何实现表别名(被联结的表也可以重新命名,方便使用),以及聚集函数. # 自联结,也可以用子查询来实现 # 这里首先p2已经进行了行的筛选 SELECT p1.prod_id, p1.prod_name FROM products AS p1, products AS p2 WHERE p1.vend_id = p2.vend_id AND p2.prod_id ='DTNTR'; # 自然联结 # 只返回唯

PYTHON 之路 （二） 文件操作/函数/面向对象编程

文件操作 打开文件,得到文件句柄并赋值给一个变量 通过句柄对文件进行操作 关闭文件 打开文件的模式有: r,只读模式(默认). w,只写模式.[不可读:不存在则创建:存在则删除内容:] a,追加模式.[可读:   不存在则创建:存在则只追加内容:] "+" 表示可以同时读写某个文件 r+,可读写文件.[可读:可写:可追加] w+,写读 a+,同a "U"表示在读取时,可以将 \r \n \r\n自动转换成 \n (与 r 或 r+ 模式同使用) rU r+U &qu

Python之路【第五篇】：面向对象编程二

类成员 一.字段 字段包括:普通字段和静态字段,他们在定义和使用中有所区别,而最本质的区别是内存中保存的位置不同, 普通字段属于对象 静态字段属于类 #!/usr/bin/env python #-*- coding:utf-8 -*- class Dbcontrl(object): action = 'contrl' def __init__(self,hostname,port,username,password,dbname,arg): self.hostname = hostname s