Python-面向对象（一）

谁借莪１个温暖的怀抱￠ 2022-05-17 08:37 232阅读 0赞

**目录**

定义

Python内置类属性

python对象销毁(垃圾回收)

类的继承

基础重载方法

类属性与方法

类的私有属性

类的方法

类的私有方法

单下划线、双下划线、头尾双下划线说明：

--------------------

# 定义 #

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

# Python内置类属性 #

*  \_\_dict\_\_ : 类的属性（包含一个字典，由类的数据属性组成）
 *  \_\_doc\_\_ :类的文档字符串
 *  \_\_name\_\_: 类名
 *  \_\_module\_\_: 类定义所在的模块（类的全名是'\_\_main\_\_.className'，如果类位于一个导入模块mymod中，那么className.\_\_module\_\_ 等于 mymod）
 *  \_\_bases\_\_ : 类的所有父类构成元素（包含了一个由所有父类组成的元组）

# python对象销毁(垃圾回收) #

Python 使用了引用计数这一简单技术来跟踪和回收垃圾。

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

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

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

a = 40      # 创建对象  <40>
    b = a       # 增加引用， <40> 的计数
    c = [b]     # 增加引用.  <40> 的计数
    
    del a       # 减少引用 <40> 的计数
    b = 100     # 减少引用 <40> 的计数
    c[0] = -1   # 减少引用 <40> 的计数

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

\_\_init\_\_()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法

函数 \_\_del\_\_ ，\_\_del\_\_在对象销毁的时候被调用，当对象不再被使用时，\_\_del\_\_方法运行：

# 类的继承 #

面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过继承机制。

通过继承创建的新类称为**子类**或**派生类**，被继承的类称为**基类**、**父类**或**超类**。

**继承语法**

class 派生类名(基类名)
        ...

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

*  1、如果在子类中需要父类的构造方法就需要显示的调用父类的构造方法，或者不重写父类的构造方法。
 *  2、在调用基类的方法时，需要加上基类的类名前缀，且需要带上 self 参数变量。区别在于类中调用普通函数时并不需要带上 self 参数
 *  3、Python 总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。（先在本类中查找调用的方法，找不到才去基类中找）。

如果在继承元组中列了一个以上的类，那么它就被称作"多重继承" 。如果父类不满足需要的功能，可在子类重写方法。

# 基础重载方法 #

下表列出了一些通用的功能，你可以在自己的类重写：（Python也支持运算符的重载）

<table> 
 <tbody> 
  <tr> 
   <th>序号</th> 
   <th>方法, 描述 &amp; 简单的调用</th> 
  </tr> 
  <tr> 
   <td>1</td> 
   <td><strong>__init__ ( self [,args...] )</strong><br> 构造函数<br> 简单的调用方法:&nbsp;<em>obj = className(args)</em></td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td><strong>__del__( self )</strong><br> 析构方法, 删除一个对象<br> 简单的调用方法 :&nbsp;<em>del obj</em></td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td><strong>__repr__( self )</strong><br> 转化为供解释器读取的形式<br> 简单的调用方法 :&nbsp;<em>repr(obj)</em></td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td><strong>__str__( self )</strong><br> 用于将值转化为适于人阅读的形式<br> 简单的调用方法 :&nbsp;<em>str(obj)</em></td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td><strong>__cmp__ ( self, x )</strong><br> 对象比较<br> 简单的调用方法 :&nbsp;<em>cmp(obj, x)</em></td> 
  </tr> 
 </tbody> 
</table>

# 类属性与方法 #

## 类的私有属性 ##

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

## 类的方法 ##

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

## 类的私有方法 ##

**\_\_private\_method**：两个下划线开头，声明该方法为私有方法，不能在类的外部调用。在类的内部调用 **self.\_\_private\_methods**

Python不允许实例化的类访问私有数据，但你可以使用** object.\_className\_\_attrName**（ **对象名.\_类名\_\_私有属性名** ）访问属性

# 单下划线、双下划线、头尾双下划线说明： #

*  **\_\_foo\_\_**: 定义的是特殊方法，一般是系统定义名字 ，类似 \_\_init\_\_() 之类的。
 *  **\_foo**: 以单下划线开头的表示的是 protected 类型的变量，即保护类型只能允许其本身与子类进行访问，不能用于 from module import \*
 *  **\_\_foo**: 双下划线的表示的是私有类型(private)的变量, 只能是允许这个类本身进行访问了。

# 正则表达式 #

## re.match函数 ##

re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。

re.match(pattern, string, flags=0)

flags: 正则表达式可以包含一些可选标志修饰符来控制匹配的模式。修饰符被指定为一个可选的标志。多个标志可以通过按位 OR(|) 它们来指定。如 re.I | re.M 被设置成 I 和 M 标志：

<table> 
 <tbody> 
  <tr> 
   <th>修饰符</th> 
   <th>描述</th> 
  </tr> 
  <tr> 
   <td>re.I</td> 
   <td>使匹配对大小写不敏感</td> 
  </tr> 
  <tr> 
   <td>re.L</td> 
   <td>做本地化识别（locale-aware）匹配</td> 
  </tr> 
  <tr> 
   <td>re.M</td> 
   <td>多行匹配，影响 ^ 和 $</td> 
  </tr> 
  <tr> 
   <td>re.S</td> 
   <td>使 . 匹配包括换行在内的所有字符</td> 
  </tr> 
  <tr> 
   <td>re.U</td> 
   <td>根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B.</td> 
  </tr> 
  <tr> 
   <td>re.X</td> 
   <td>该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。</td> 
  </tr> 
 </tbody> 
</table>

## re.search方法 ##

re.search 扫描整个字符串并返回第一个成功的匹配。

re.search(pattern, string, flags=0)

我们可以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。

<table> 
 <tbody> 
  <tr> 
   <th>匹配对象方法</th> 
   <th>描述</th> 
  </tr> 
  <tr> 
   <td>group(num=0)</td> 
   <td>匹配的整个表达式的字符串，group() 可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。</td> 
  </tr> 
  <tr> 
   <td>groups()</td> 
   <td>返回一个包含所有小组字符串的元组，从 1 到 所含的小组号。</td> 
  </tr> 
 </tbody> 
</table>

## 检索和替换 ##

Python 的 re 模块提供了re.sub用于替换字符串中的匹配项。

语法：

re.sub(pattern, repl, string, count=0, flags=0)

## re.compile 函数 ##

compile 函数用于编译正则表达式，生成一个正则表达式（ Pattern ）对象，供 match() 、search() 及findall()这两个函数使用。

**re.compile(pattern\[, flags\])**

注：当匹配成功时返回一个 Match 对象，其中，eg： pattern.match('123asd456qwertyuio', 3, 10).group()

*  `group([group1, …])` 方法用于获得一个或多个分组匹配的字符串，当要获得整个匹配的子串时，可直接使用 `group()` 或 `group(0)`；
 *  `start([group])` 方法用于获取分组匹配的子串在整个字符串中的起始位置（子串第一个字符的索引），参数默认值为 0；
 *  `end([group])` 方法用于获取分组匹配的子串在整个字符串中的结束位置（子串最后一个字符的索引+1），参数默认值为 0；
 *  `span([group])` 方法返回 `(start(group), end(group))`。

## re.finditer ##

和 findall 类似，在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回。

re.finditer(pattern, string, flags=0)

## re.split ##

split 方法按照能够匹配的子串将字符串分割后返回列表，它的使用形式如下：

re.split(pattern, string[, maxsplit=0, flags=0])  maxsplit分割次数，默认为0，不限制分割次数。

## 正则表达式对象 ##

### re.RegexObject ###

re.compile() 返回 RegexObject 对象。

### re.MatchObject ###

group() 返回被 RE 匹配的字符串。

*  start() 返回匹配开始的位置
 *  end() 返回匹配结束的位置
 *  span() 返回一个元组包含匹配 (开始,结束) 的位置