Python基础之:Python中的内部对象

约定不等于承诺〃 2022-11-16 01:59 122阅读 0赞

### 文章目录 ###

*  简介
 *  内置函数
 *  内置常量
 *  内置类型
 *   *  逻辑值检测
     *   *  逻辑值的布尔运算
         *  比较运算
     *  数字类型
     *   *  整数类型的位运算
         *  整数类型的附加方法
         *  浮点类型的附加方法
     *  迭代器
     *  序列类型
     *  集合类型
     *  映射类型
     *   *  字典视图对象
 *  内置异常

# 简介 #

Python中内置了很多非常有用的对象，本文将会介绍Python中的内置函数，内置常量，内置类型和内置异常。

# 内置函数 #

Python 解释器内置了很多函数和类型，您可以在任何时候使用它们。

<table> 
 <thead> 
 <tr> 
 <th align="left"></th> 
 <th align="left"></th> 
 <th align="left">内置函数</th> 
 <th align="left"></th> 
 <th align="left"></th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td align="left">abs()</td> 
 <td align="left">delattr()</td> 
 <td align="left">hash()</td> 
 <td align="left">memoryview()</td> 
 <td align="left">set()</td> 
 </tr> 
 <tr> 
 <td align="left">all()</td> 
 <td align="left">dict()</td> 
 <td align="left">help()</td> 
 <td align="left">min()</td> 
 <td align="left">setattr()</td> 
 </tr> 
 <tr> 
 <td align="left">any()</td> 
 <td align="left">dir()</td> 
 <td align="left">hex()</td> 
 <td align="left">next()</td> 
 <td align="left">slice()</td> 
 </tr> 
 <tr> 
 <td align="left">ascii()</td> 
 <td align="left">divmod()</td> 
 <td align="left">id()</td> 
 <td align="left">object()</td> 
 <td align="left">sorted()</td> 
 </tr> 
 <tr> 
 <td align="left">bin()</td> 
 <td align="left">enumerate()</td> 
 <td align="left">input()</td> 
 <td align="left">oct()</td> 
 <td align="left">staticmethod()</td> 
 </tr> 
 <tr> 
 <td align="left">bool()</td> 
 <td align="left">eval()</td> 
 <td align="left">int()</td> 
 <td align="left">open()</td> 
 <td align="left">str()</td> 
 </tr> 
 <tr> 
 <td align="left">breakpoint()</td> 
 <td align="left">exec()</td> 
 <td align="left">isinstance()</td> 
 <td align="left">ord()</td> 
 <td align="left">sum()</td> 
 </tr> 
 <tr> 
 <td align="left">bytearray()</td> 
 <td align="left">filter()</td> 
 <td align="left">issubclass()</td> 
 <td align="left">pow()</td> 
 <td align="left">super()</td> 
 </tr> 
 <tr> 
 <td align="left">bytes()</td> 
 <td align="left">float()</td> 
 <td align="left">iter()</td> 
 <td align="left">print()</td> 
 <td align="left">tuple()</td> 
 </tr> 
 <tr> 
 <td align="left">callable()</td> 
 <td align="left">format()</td> 
 <td align="left">len()</td> 
 <td align="left">property()</td> 
 <td align="left">type()</td> 
 </tr> 
 <tr> 
 <td align="left">chr()</td> 
 <td align="left">frozenset()</td> 
 <td align="left">list()</td> 
 <td align="left">range()</td> 
 <td align="left">vars()</td> 
 </tr> 
 <tr> 
 <td align="left">classmethod()</td> 
 <td align="left">getattr()</td> 
 <td align="left">locals()</td> 
 <td align="left">repr()</td> 
 <td align="left">zip()</td> 
 </tr> 
 <tr> 
 <td align="left">compile()</td> 
 <td align="left">globals()</td> 
 <td align="left">map()</td> 
 <td align="left">reversed()</td> 
 <td align="left"><code>__import__()</code></td> 
 </tr> 
 <tr> 
 <td align="left">complex()</td> 
 <td align="left">hasattr()</td> 
 <td align="left">max()</td> 
 <td align="left">round()</td> 
 <td align="left"></td> 
 </tr> 
 </tbody> 
</table>

# 内置常量 #

Python中内置了少量的常量，我们可以直接在代码中使用他们。

*  **False**

表示的是bool类型的假值。

*  **True**

表示的是bool类型的真值。

*  **None**

是NoneType类型的唯一值。None表示缺少值。

*  **NotImplemented**

是`__eq__()`, `__lt__()`, `__add__()`, `__rsub__()`的特殊返回值，表示会在假值的时候返回**NotImplemented**。

*  **Ellipsis**

等同于字面值 `…` ，主要与用户定义的容器数据类型的扩展切片语法结合使用。

*  **`__debug__`**

编译器内部的变量，用来表示是否开启debug模式。

# 内置类型 #

python中的主要内置类型有数字、序列、映射、类、实例和异常。

## 逻辑值检测 ##

在python中，任何对象都可以做逻辑值的检测。

一个对象在默认情况下均被视为真值，除非当该对象被调用时其所属类定义了 `__bool__()`方法且返回 `False` 或是定义了 `__len__()` 方法且返回零。

下面是集中被认为是false值的对象：

*  被定义为假值的常量: `None` 和 `False`。
 *  任何数值类型的零: `0`, `0.0`, `0j`, `Decimal(0)`, `Fraction(0, 1)`
 *  空的序列和多项集: `''`, `()`, `[]`, `{}`, `set()`, `range(0)`

### 逻辑值的布尔运算 ###

布尔运算主要有 or, not和and：

<table> 
 <thead> 
 <tr> 
 <th align="left">运算</th> 
 <th align="left">结果</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td align="left"><code>x or y</code></td> 
 <td align="left">if x is false, then y, else x</td> 
 </tr> 
 <tr> 
 <td align="left"><code>x and y</code></td> 
 <td align="left">if x is false, then x, else y</td> 
 </tr> 
 <tr> 
 <td align="left"><code>not x</code></td> 
 <td align="left">if x is false, then <code>True</code>, else <code>False</code></td> 
 </tr> 
 </tbody> 
</table>

### 比较运算 ###

<table> 
 <thead> 
 <tr> 
 <th align="left">运算</th> 
 <th align="left">含义</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td align="left"><code>&lt;</code></td> 
 <td align="left">严格小于</td> 
 </tr> 
 <tr> 
 <td align="left"><code>&lt;=</code></td> 
 <td align="left">小于或等于</td> 
 </tr> 
 <tr> 
 <td align="left"><code>&gt;</code></td> 
 <td align="left">严格大于</td> 
 </tr> 
 <tr> 
 <td align="left"><code>&gt;=</code></td> 
 <td align="left">大于或等于</td> 
 </tr> 
 <tr> 
 <td align="left"><code>==</code></td> 
 <td align="left">等于</td> 
 </tr> 
 <tr> 
 <td align="left"><code>!=</code></td> 
 <td align="left">不等于</td> 
 </tr> 
 <tr> 
 <td align="left"><code>is</code></td> 
 <td align="left">对象标识</td> 
 </tr> 
 <tr> 
 <td align="left"><code>is not</code></td> 
 <td align="left">否定的对象标识</td> 
 </tr> 
 </tbody> 
</table>

具有不同标识的类的实例比较结果通常为不相等，除非类定义了 `__eq__()`方法。

## 数字类型 ##

Python中有三种不同的数据类型：*整数*, *浮点数* 和 *复数*。

所有数字类型（复数除外）都支持下列运算：

<table> 
 <thead> 
 <tr> 
 <th align="left">运算</th> 
 <th align="left">结果</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td align="left"><code>x + y</code></td> 
 <td align="left">x 和 y 的和</td> 
 </tr> 
 <tr> 
 <td align="left"><code>x - y</code></td> 
 <td align="left">x 和 y 的差</td> 
 </tr> 
 <tr> 
 <td align="left"><code>x * y</code></td> 
 <td align="left">x 和 y 的乘积</td> 
 </tr> 
 <tr> 
 <td align="left"><code>x / y</code></td> 
 <td align="left">x 和 y 的商</td> 
 </tr> 
 <tr> 
 <td align="left"><code>x // y</code></td> 
 <td align="left">x 和 y 的商数</td> 
 </tr> 
 <tr> 
 <td align="left"><code>x % y</code></td> 
 <td align="left"><code>x / y</code> 的余数</td> 
 </tr> 
 <tr> 
 <td align="left"><code>-x</code></td> 
 <td align="left">x 取反</td> 
 </tr> 
 <tr> 
 <td align="left"><code>+x</code></td> 
 <td align="left">x 不变</td> 
 </tr> 
 <tr> 
 <td align="left"><code>abs(x)</code></td> 
 <td align="left">x 的绝对值或大小</td> 
 </tr> 
 </tbody> 
</table>

对于int 和 float 还支持下面的运算：

<table> 
 <thead> 
 <tr> 
 <th align="left">运算</th> 
 <th align="left">结果</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td align="left"><code>math.trunc(x)</code></td> 
 <td align="left">x 截断为 <code>Integral</code></td> 
 </tr> 
 <tr> 
 <td align="left"><code>Round(x[, n])</code></td> 
 <td align="left">x 舍入到 n 位小数，半数值会舍入到偶数。 如果省略 n，则默认为 0。</td> 
 </tr> 
 <tr> 
 <td align="left"><code>math.floor(x)</code></td> 
 <td align="left">&lt;= x 的最大 <code>Integral</code></td> 
 </tr> 
 <tr> 
 <td align="left"><code>math.ceil(x)</code></td> 
 <td align="left">&gt;= x 的最小 <code>Integral</code></td> 
 </tr> 
 </tbody> 
</table>

### 整数类型的位运算 ###

对于整数来说，还支持位运算：

### 整数类型的附加方法 ###

int 还有一些额外的方法：

`int.bit_length`()

返回以二进制表示一个整数所需要的位数，不包括符号位和前面的零:

>>> n = -37
    >>> bin(n)
    '-0b100101'
    >>> n.bit_length()
    6

`int.to_bytes`(*length*, *byteorder*, \*, *signed=False*)

返回表示一个整数的字节数组。

(1024).to_bytes(2, byteorder='big')
    b'\x04\x00'
    (1024).to_bytes(10, byteorder='big')
    b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
    (-1024).to_bytes(10, byteorder='big', signed=True)
    b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
    x = 1000
    x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
    b'\xe8\x03'

*byteorder* 参数确定用于表示整数的字节顺序。 如果 *byteorder* 为 `"big"`，则最高位字节放在字节数组的开头。 如果 *byteorder* 为 `"little"`，则最高位字节放在字节数组的末尾。

*signed* 参数确定是否使用二的补码来表示整数。

### 浮点类型的附加方法 ###

`float.is_integer`()

如果 float 实例可用有限位整数表示则返回 `True`，否则返回 `False`:

>>> (-2.0).is_integer()
    True
    >>> (3.2).is_integer()
    False

`float.hex`()

以十六进制字符串的形式返回一个浮点数表示。

## 迭代器 ##

迭代器主要用在容器的遍历中。

如果容器需要提供迭代支持，必须定义下面的方法：

`container.__iter__`()

这个方法返回一个迭代器对象。这个迭代器对象需要提供下面的两个方法：

`iterator.__iter__`()

返回迭代器对象本身。

`iterator.__next__`()

从容器中返回下一项。

## 序列类型 ##

有三种基本序列类型：list, tuple 和 range 对象。

下面是通用的序列操作：

<table> 
 <thead> 
 <tr> 
 <th align="left">运算</th> 
 <th align="left">结果</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td align="left"><code>x in s</code></td> 
 <td align="left">如果 s 中的某项等于 x 则结果为 <code>True</code>，否则为 <code>False</code></td> 
 </tr> 
 <tr> 
 <td align="left"><code>x not in s</code></td> 
 <td align="left">如果 s 中的某项等于 x 则结果为 <code>False</code>，否则为 <code>True</code></td> 
 </tr> 
 <tr> 
 <td align="left"><code>s + t</code></td> 
 <td align="left">s 与 t 相拼接</td> 
 </tr> 
 <tr> 
 <td align="left"><code>s * n</code> 或 <code>n * s</code></td> 
 <td align="left">相当于 s 与自身进行 n 次拼接</td> 
 </tr> 
 <tr> 
 <td align="left"><code>s[i]</code></td> 
 <td align="left">s 的第 i 项，起始为 0</td> 
 </tr> 
 <tr> 
 <td align="left"><code>s[i:j]</code></td> 
 <td align="left">s 从 i 到 j 的切片</td> 
 </tr> 
 <tr> 
 <td align="left"><code>s[i:j:k]</code></td> 
 <td align="left">s 从 i 到 j 步长为 k 的切片</td> 
 </tr> 
 <tr> 
 <td align="left"><code>len(s)</code></td> 
 <td align="left">s 的长度</td> 
 </tr> 
 <tr> 
 <td align="left"><code>min(s)</code></td> 
 <td align="left">s 的最小项</td> 
 </tr> 
 <tr> 
 <td align="left"><code>max(s)</code></td> 
 <td align="left">s 的最大项</td> 
 </tr> 
 <tr> 
 <td align="left"><code>s.index(x[, i[, j]])</code></td> 
 <td align="left">x 在 s 中首次出现项的索引号（索引号在 i 或其后且在 j 之前）</td> 
 </tr> 
 <tr> 
 <td align="left"><code>s.count(x)</code></td> 
 <td align="left">x 在 s 中出现的总次数</td> 
 </tr> 
 </tbody> 
</table>

可变序列类型的操作：

<table> 
 <thead> 
 <tr> 
 <th align="left">运算</th> 
 <th align="left">结果</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td align="left"><code>s[i] = x</code></td> 
 <td align="left">将 s 的第 i 项替换为 x</td> 
 </tr> 
 <tr> 
 <td align="left"><code>s[i:j] = t</code></td> 
 <td align="left">将 s 从 i 到 j 的切片替换为可迭代对象 t 的内容</td> 
 </tr> 
 <tr> 
 <td align="left"><code>del s[i:j]</code></td> 
 <td align="left">等同于 <code>s[i:j] = []</code></td> 
 </tr> 
 <tr> 
 <td align="left"><code>s[i:j:k] = t</code></td> 
 <td align="left">将 <code>s[i:j:k]</code> 的元素替换为 t 的元素</td> 
 </tr> 
 <tr> 
 <td align="left"><code>del s[i:j:k]</code></td> 
 <td align="left">从列表中移除 <code>s[i:j:k]</code> 的元素</td> 
 </tr> 
 <tr> 
 <td align="left"><code>s.append(x)</code></td> 
 <td align="left">将 x 添加到序列的末尾 (等同于 <code>s[len(s):len(s)] = [x]</code>)</td> 
 </tr> 
 <tr> 
 <td align="left"><code>s.clear()</code></td> 
 <td align="left">从 s 中移除所有项 (等同于 <code>del s[:]</code>)</td> 
 </tr> 
 <tr> 
 <td align="left"><code>s.copy()</code></td> 
 <td align="left">创建 s 的浅拷贝 (等同于 <code>s[:]</code>)</td> 
 </tr> 
 <tr> 
 <td align="left"><code>s.extend(t)</code> 或 <code>s += t</code></td> 
 <td align="left">用 t 的内容扩展 s (基本上等同于 <code>s[len(s):len(s)] = t</code>)</td> 
 </tr> 
 <tr> 
 <td align="left"><code>s *= n</code></td> 
 <td align="left">使用 s 的内容重复 n 次来对其进行更新</td> 
 </tr> 
 <tr> 
 <td align="left"><code>s.insert(i, x)</code></td> 
 <td align="left">在由 i 给出的索引位置将 x 插入 s (等同于 <code>s[i:i] = [x]</code>)</td> 
 </tr> 
 <tr> 
 <td align="left"><code>s.pop([i])</code></td> 
 <td align="left">提取在 i 位置上的项，并将其从 s 中移除</td> 
 </tr> 
 <tr> 
 <td align="left"><code>s.remove(x)</code></td> 
 <td align="left">删除 s 中第一个 <code>s[i]</code> 等于 x 的项目。</td> 
 </tr> 
 <tr> 
 <td align="left"><code>s.reverse()</code></td> 
 <td align="left">就地将列表中的元素逆序。</td> 
 </tr> 
 </tbody> 
</table>

序列类型包括列表，元组，range对象和文本序列str。

这里重点看下str的方法：

<table> 
 <thead> 
 <tr> 
 <th>运算</th> 
 <th>结果</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td><code>str.capitalize</code>()</td> 
 <td>返回原字符串的副本，其首个字符大写，其余为小写。</td> 
 </tr> 
 <tr> 
 <td><code>str.casefold</code>()</td> 
 <td>返回原字符串消除大小写的副本。 消除大小写的字符串可用于忽略大小写的匹配。</td> 
 </tr> 
 <tr> 
 <td>str.center(width[, fillchar])</td> 
 <td>返回长度为 width 的字符串，原字符串在其正中。 使用指定的 fillchar 填充两边的空位（默认使用 ASCII 空格符）。 如果 width 小于等于 <code>len(s)</code> 则返回原字符串的副本。</td> 
 </tr> 
 <tr> 
 <td><code>str.count</code>(sub[, start[, end]])</td> 
 <td>反回子字符串 sub 在 [start, end] 范围内非重叠出现的次数。 可选参数 start 与 end 会被解读为切片表示法。</td> 
 </tr> 
 <tr> 
 <td><code>str.encode</code>(encoding=“utf-8”, errors=“strict”)</td> 
 <td>返回原字符串编码为字节串对象的版本。 默认编码为 ‘utf-8’。errors 的默认值为 ‘strict’，表示编码错误会引发 UnicodeError。 其他可用的值为 ‘ignore’, ‘replace’, ‘xmlcharrefreplace’, ‘backslashreplace’ 以及任何其他通过 codecs.register_error() 注册的值</td> 
 </tr> 
 <tr> 
 <td><code>str.endswith</code>(suffix[, start[, end]])</td> 
 <td>如果字符串以指定的 suffix 结束返回 <code>True</code>，否则返回 <code>False</code>。 suffix 也可以为由多个供查找的后缀构成的元组。</td> 
 </tr> 
 <tr> 
 <td><code>str.expandtabs</code>(tabsize=8)</td> 
 <td>返回字符串的副本，其中所有的制表符会由一个或多个空格替换，具体取决于当前列位置和给定的制表符宽度。</td> 
 </tr> 
 <tr> 
 <td>str.find(sub[, start[, end]])</td> 
 <td>返回子字符串 sub 在 <code>s[start:end]</code> 切片内被找到的最小索引。</td> 
 </tr> 
 <tr> 
 <td>str.format(args*, kwargs)</td> 
 <td>执行字符串格式化操作。</td> 
 </tr> 
 <tr> 
 <td><code>str.format_map</code>(mapping)</td> 
 <td>类似于 str.format(**mapping)，不同之处在于 mapping 会被直接使用而不是复制到一个 dict。</td> 
 </tr> 
 <tr> 
 <td><code>str.index</code>(sub[, start[, end]])</td> 
 <td>类似于 find()，但在找不到子类时会引发 ValueError。</td> 
 </tr> 
 <tr> 
 <td><code>str.isalnum</code>()</td> 
 <td>如果字符串中的所有字符都是字母或数字且至少有一个字符，则返回 <code>True</code> ， 否则返回 <code>False</code> 。</td> 
 </tr> 
 <tr> 
 <td>str.isalpha()</td> 
 <td>如果字符串中的所有字符都是字母，并且至少有一个字符，返回 <code>True</code> ，否则返回 <code>False</code> 。</td> 
 </tr> 
 <tr> 
 <td>str.isascii()</td> 
 <td>如果字符串为空或字符串中的所有字符都是 ASCII ，返回 <code>True</code> ，否则返回 <code>False</code> 。</td> 
 </tr> 
 <tr> 
 <td>str.isdecimal()</td> 
 <td>如果字符串中的所有字符都是十进制字符且该字符串至少有一个字符，则返回 <code>True</code> ， 否则返回 <code>False</code> 。</td> 
 </tr> 
 <tr> 
 <td><code>str.isdigit</code>()</td> 
 <td>如果字符串中的所有字符都是数字，并且至少有一个字符，返回 <code>True</code> ，否则返回 <code>False</code> 。</td> 
 </tr> 
 <tr> 
 <td><code>str.isidentifier</code>()</td> 
 <td>如果字符串是有效的标识符，返回 <code>True</code></td> 
 </tr> 
 <tr> 
 <td><code>str.islower</code>()</td> 
 <td>如果字符串中至少有一个区分大小写的字符 且此类字符均为小写则返回 True ，否则返回 False 。</td> 
 </tr> 
 <tr> 
 <td><code>str.isnumeric</code>()</td> 
 <td>如果字符串中至少有一个字符且所有字符均为数值字符则返回 <code>True</code> ，否则返回 <code>False</code> 。</td> 
 </tr> 
 <tr> 
 <td>str.isprintable()</td> 
 <td>如果字符串中所有字符均为可打印字符或字符串为空则返回 <code>True</code> ，否则返回 <code>False</code> 。</td> 
 </tr> 
 <tr> 
 <td>str.isspace()</td> 
 <td>如果字符串中只有空白字符且至少有一个字符则返回 <code>True</code> ，否则返回 <code>False</code> 。</td> 
 </tr> 
 <tr> 
 <td><code>str.istitle</code>()</td> 
 <td>如果字符串中至少有一个字符且为标题字符串则返回 True ，例如大写字符之后只能带非大写字符而小写字符必须有大写字符打头。 否则返回 False 。</td> 
 </tr> 
 <tr> 
 <td>str.isupper()</td> 
 <td>如果字符串中至少有一个区分大小写的字符 4 且此类字符均为大写则返回 True ，否则返回 False 。</td> 
 </tr> 
 <tr> 
 <td>str.join(iterable)</td> 
 <td>返回一个由 iterable 中的字符串拼接而成的字符串。</td> 
 </tr> 
 <tr> 
 <td><code>str.ljust</code>(width[, fillchar])</td> 
 <td>返回长度为 width 的字符串，原字符串在其中靠左对齐。</td> 
 </tr> 
 <tr> 
 <td><code>str.lower</code>()</td> 
 <td>返回原字符串的副本，其所有区分大小写的字符 均转换为小写。</td> 
 </tr> 
 <tr> 
 <td><code>str.lstrip</code>([chars])</td> 
 <td>返回原字符串的副本，移除其中的前导字符。</td> 
 </tr> 
 <tr> 
 <td><code>str.partition</code>(sep)</td> 
 <td>在 sep 首次出现的位置拆分字符串，返回一个 3 元组，其中包含分隔符之前的部分、分隔符本身，以及分隔符之后的部分。</td> 
 </tr> 
 <tr> 
 <td>str.removeprefix(prefix, /)</td> 
 <td>如果字符串以 前缀 字符串开头，返回 <code>string[len(prefix):]</code> 。否则，返回原始字符串的副本</td> 
 </tr> 
 <tr> 
 <td><code>str.removesuffix</code>(suffix, /)</td> 
 <td>如果字符串以 后缀 字符串结尾，并且 后缀 非空，返回 <code>string[:-len(suffix)]</code> 。否则，返回原始字符串的副本</td> 
 </tr> 
 <tr> 
 <td>str.replace(old, new[, count])</td> 
 <td>返回字符串的副本，其中出现的所有子字符串 old 都将被替换为 new。 如果给出了可选参数 count，则只替换前 count 次出现。</td> 
 </tr> 
 <tr> 
 <td><code>str.rfind</code>(sub[, start[, end]])</td> 
 <td>返回子字符串 sub 在字符串内被找到的最大（最右）索引，这样 sub 将包含在 <code>s[start:end]</code> 当中。</td> 
 </tr> 
 <tr> 
 <td><code>str.rindex</code>(sub[, start[, end]])</td> 
 <td>类似于 rfind()，但在子字符串 sub 未找到时会引发 ValueError。</td> 
 </tr> 
 <tr> 
 <td>str.rjust(width[, fillchar])</td> 
 <td>返回长度为 width 的字符串，原字符串在其中靠右对齐。</td> 
 </tr> 
 <tr> 
 <td>str.rpartition(sep)</td> 
 <td>在 sep 最后一次出现的位置拆分字符串，返回一个 3 元组，其中包含分隔符之前的部分、分隔符本身，以及分隔符之后的部分。 如果分隔符未找到，则返回的 3 元组中包含两个空字符串以及字符串本身。</td> 
 </tr> 
 <tr> 
 <td><code>str.rsplit</code>(sep=None, maxsplit=-1)</td> 
 <td>返回一个由字符串内单词组成的列表，使用 sep 作为分隔字符串。 如果给出了 maxsplit，则最多进行 maxsplit 次拆分，从 最右边 开始。</td> 
 </tr> 
 <tr> 
 <td><code>str.rstrip</code>([chars])</td> 
 <td>返回原字符串的副本，移除其中的末尾字符。</td> 
 </tr> 
 <tr> 
 <td>str.split(sep=None, maxsplit=-1)</td> 
 <td>返回一个由字符串内单词组成的列表，使用 sep 作为分隔字符串。 如果给出了 maxsplit，则最多进行 maxsplit 次拆分（因此，列表最多会有 <code>maxsplit+1</code> 个元素）。 如果 maxsplit 未指定或为 <code>-1</code>，则不限制拆分次数（进行所有可能的拆分）。</td> 
 </tr> 
 <tr> 
 <td>str.splitlines([keepends])</td> 
 <td>返回由原字符串中各行组成的列表，在行边界的位置拆分。 结果列表中不包含行边界，除非给出了 keepends 且为真值。</td> 
 </tr> 
 <tr> 
 <td>str.startswith(prefix[, start[, end]])</td> 
 <td>如果字符串以指定的 prefix 开始则返回 <code>True</code>，否则返回 <code>False</code>。 prefix 也可以为由多个供查找的前缀构成的元组。 如果有可选项 start，将从所指定位置开始检查。 如果有可选项 end，将在所指定位置停止比较。</td> 
 </tr> 
 <tr> 
 <td><code>str.strip</code>([chars])</td> 
 <td>返回原字符串的副本，移除其中的前导和末尾字符。 chars 参数为指定要移除字符的字符串。 如果省略或为 <code>None</code>，则 chars 参数默认移除空格符。 实际上 chars 参数并非指定单个前缀或后缀；而是会移除参数值的所有组合:</td> 
 </tr> 
 <tr> 
 <td>str.swapcase()</td> 
 <td>返回原字符串的副本，其中大写字符转换为小写，反之亦然。</td> 
 </tr> 
 <tr> 
 <td><code>str.title</code>()</td> 
 <td>返回原字符串的标题版本，其中每个单词第一个字母为大写，其余字母为小写。</td> 
 </tr> 
 <tr> 
 <td><code>str.upper</code>()</td> 
 <td>返回原字符串的副本，其中所有区分大小写的字符均转换为大写。</td> 
 </tr> 
 <tr> 
 <td><code>str.zfill</code>(width)</td> 
 <td>返回原字符串的副本，在左边填充 ASCII <code>'0'</code> 数码使其长度变为 width。 正负值前缀 (<code>'+'</code>/<code>'-'</code>) 的处理方式是在正负符号 之后 填充而非在之前。 如果 width 小于等于 <code>len(s)</code> 则返回原字符串的副本。</td> 
 </tr> 
 </tbody> 
</table>

还包括几个二进制序列类型： `bytes`, `bytearray`, `memoryview`。

bytes 对象是由单个字节构成的不可变序列。

表示 bytes 字面值的语法与字符串字面值的大致相同，只是添加了一个 `b` 前缀。

bytearray 对象是 `bytes` 对象的可变对应物。bytearray 对象没有专属的字面值语法，它们总是通过调用构造器来创建。

我们看下bytes和bytearray的基本操作：

<table> 
 <thead> 
 <tr> 
 <th>运算</th> 
 <th>描述</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td>bytearray.count(sub[, start[, end]])</td> 
 <td>返回子序列 sub 在 [start, end] 范围内非重叠出现的次数。 可选参数 start 与 end 会被解读为切片表示法。</td> 
 </tr> 
 <tr> 
 <td>bytearray.removeprefix(prefix, /)</td> 
 <td>如果二进制数据以 前缀 字符串开头，返回 <code>bytes[len(prefix):]</code> 。否则，返回原始二进制数据的副本</td> 
 </tr> 
 <tr> 
 <td>bytearray.removesuffix(suffix, /)</td> 
 <td>如果二进制数据以 后缀 字符串结尾，并且 后缀 非空，返回 <code>bytes[:-len(suffix)]</code> 。否则，返回原始二进制数据的副本</td> 
 </tr> 
 <tr> 
 <td>bytearray.decode(encoding=“utf-8”, errors=“strict”)</td> 
 <td>返回从给定 bytes 解码出来的字符串。 默认编码为 <code>'utf-8'</code>。</td> 
 </tr> 
 <tr> 
 <td>bytearray.endswith(suffix[, start[, end]])</td> 
 <td>如果二进制数据以指定的 suffix 结束则返回 <code>True</code>，否则返回 <code>False</code>。</td> 
 </tr> 
 <tr> 
 <td>bytearray.find(sub[, start[, end]])</td> 
 <td>返回子序列 sub 在数据中被找到的最小索引，sub 包含于切片 <code>s[start:end]</code> 之内。</td> 
 </tr> 
 <tr> 
 <td>bytearray.index(sub[, start[, end]])</td> 
 <td>类似于 find()，但在找不到子序列时会引发 ValueError。</td> 
 </tr> 
 <tr> 
 <td>bytearray.join(iterable)</td> 
 <td>返回一个由 iterable 中的二进制数据序列拼接而成的 bytes 或 bytearray 对象。</td> 
 </tr> 
 <tr> 
 <td>bytearray.maketrans(from, to)</td> 
 <td>返回一个可用于 bytes.translate() 的转换对照表，它将把 from 中的每个字符映射为 to 中相同位置上的字符；from 与 to 必须都是 字节类对象 并且具有相同的长度。</td> 
 </tr> 
 <tr> 
 <td>bytearray.partition(sep)</td> 
 <td>在 sep 首次出现的位置拆分序列，返回一个 3 元组，其中包含分隔符之前的部分、分隔符本身或其 bytearray 副本，以及分隔符之后的部分。</td> 
 </tr> 
 <tr> 
 <td>bytearray.replace(old, new[, count])</td> 
 <td>返回序列的副本，其中出现的所有子序列 old 都将被替换为 new。 如果给出了可选参数 count，则只替换前 count 次出现。</td> 
 </tr> 
 <tr> 
 <td>bytearray.rfind(sub[, start[, end]])</td> 
 <td>返回子序列 sub 在序列内被找到的最大（最右）索引，这样 sub 将包含在 <code>s[start:end]</code> 当中。 可选参数 start 与 end 会被解读为切片表示法。 如果未找到则返回 <code>-1</code>。</td> 
 </tr> 
 <tr> 
 <td>bytearray.rindex(sub[, start[, end]])</td> 
 <td>类似于 rfind()，但在子序列 sub 未找到时会引发 ValueError。</td> 
 </tr> 
 <tr> 
 <td>bytearray.rpartition(sep)</td> 
 <td>在 sep 最后一次出现的位置拆分序列，返回一个 3 元组，其中包含分隔符之前的部分，分隔符本身或其 bytearray 副本，以及分隔符之后的部分。</td> 
 </tr> 
 <tr> 
 <td>bytearray.startswith(prefix[, start[, end]])</td> 
 <td>如果二进制数据以指定的 prefix 开头则返回 <code>True</code>，否则返回 <code>False</code>。</td> 
 </tr> 
 <tr> 
 <td>bytearray.translate(table, /, delete=b’’)</td> 
 <td>返回原 bytes 或 bytearray 对象的副本，移除其中所有在可选参数 delete 中出现的 bytes，其余 bytes 将通过给定的转换表进行映射，该转换表必须是长度为 256 的 bytes 对象。</td> 
 </tr> 
 <tr> 
 <td>bytearray.center(width[, fillbyte])</td> 
 <td>返回原对象的副本，在长度为 width 的序列内居中，使用指定的 fillbyte 填充两边的空位（默认使用 ASCII 空格符）。 对于 bytes 对象，如果 width 小于等于 len(s) 则返回原序列的副本。</td> 
 </tr> 
 <tr> 
 <td>bytearray.ljust(width[, fillbyte])</td> 
 <td>返回原对象的副本，在长度为 width 的序列中靠左对齐。</td> 
 </tr> 
 <tr> 
 <td>bytearray.lstrip([chars])</td> 
 <td>返回原序列的副本，移除指定的前导字节。</td> 
 </tr> 
 <tr> 
 <td>bytearray.rjust(width[, fillbyte])</td> 
 <td>返回原对象的副本，在长度为 width 的序列中靠右对齐。</td> 
 </tr> 
 <tr> 
 <td>bytearray.rsplit(sep=None, maxsplit=-1)</td> 
 <td>将二进制序列拆分为相同类型的子序列，使用 sep 作为分隔符。</td> 
 </tr> 
 <tr> 
 <td>bytearray.rstrip([chars])</td> 
 <td>返回原序列的副本，移除指定的末尾字节。</td> 
 </tr> 
 <tr> 
 <td>bytearray.split(sep=None, maxsplit=-1)</td> 
 <td>将二进制序列拆分为相同类型的子序列，使用 sep 作为分隔符。</td> 
 </tr> 
 <tr> 
 <td>bytearray.strip([chars])</td> 
 <td>返回原序列的副本，移除指定的开头和末尾字节。</td> 
 </tr> 
 <tr> 
 <td>bytearray.capitalize()</td> 
 <td>返回原序列的副本，其中每个字节将都将被解读为一个 ASCII 字符，并且第一个字节的字符大写而其余的小写。 非 ASCII 字节值将保持原样不变。</td> 
 </tr> 
 <tr> 
 <td>bytearray.expandtabs(tabsize=8)</td> 
 <td>返回序列的副本，其中所有的 ASCII 制表符会由一个或多个 ASCII 空格替换，具体取决于当前列位置和给定的制表符宽度。</td> 
 </tr> 
 <tr> 
 <td>bytearray.isalnum()</td> 
 <td>如果序列中所有字节都是字母类 ASCII 字符或 ASCII 十进制数码并且序列非空则返回 <code>True</code> ，否则返回 <code>False</code> 。</td> 
 </tr> 
 <tr> 
 <td>bytearray.isalpha()</td> 
 <td>如果序列中所有字节都是字母类 ASCII 字符并且序列不非空则返回 <code>True</code> ，否则返回 <code>False</code> 。</td> 
 </tr> 
 <tr> 
 <td>bytearray.isascii()</td> 
 <td>如果序列为空或序列中所有字节都是 ASCII 字节则返回 <code>True</code> ，否则返回 <code>False</code> 。</td> 
 </tr> 
 <tr> 
 <td>bytearray.isdigit()</td> 
 <td>如果序列中所有字节都是 ASCII 十进制数码并且序列非空则返回 <code>True</code> ，否则返回 <code>False</code> 。</td> 
 </tr> 
 <tr> 
 <td>bytearray.islower()</td> 
 <td>如果序列中至少有一个小写的 ASCII 字符并且没有大写的 ASCII 字符则返回 <code>True</code> ，否则返回 <code>False</code> 。</td> 
 </tr> 
 <tr> 
 <td><code>bytearray.isspace</code>()</td> 
 <td>如果序列中所有字节都是 ASCII 空白符并且序列非空则返回 <code>True</code> ，否则返回 <code>False</code> 。</td> 
 </tr> 
 <tr> 
 <td>bytearray.istitle()</td> 
 <td>如果序列为 ASCII 标题大小写形式并且序列非空则返回 <code>True</code> ，否则返回 <code>False</code> 。</td> 
 </tr> 
 <tr> 
 <td>bytearray.isupper()</td> 
 <td>如果序列中至少有一个大写字母 ASCII 字符并且没有小写 ASCII 字符则返回 <code>True</code> ，否则返回 <code>False</code> 。</td> 
 </tr> 
 <tr> 
 <td>bytearray.lower()</td> 
 <td>返回原序列的副本，其所有大写 ASCII 字符均转换为对应的小写形式。</td> 
 </tr> 
 <tr> 
 <td>bytearray.splitlines(keepends=False)</td> 
 <td>返回由原二进制序列中各行组成的列表，在 ASCII 行边界符的位置拆分。</td> 
 </tr> 
 <tr> 
 <td>bytearray.swapcase()</td> 
 <td>返回原序列的副本，其所有小写 ASCII 字符均转换为对应的大写形式，反之亦反。</td> 
 </tr> 
 <tr> 
 <td>bytearray.title()</td> 
 <td>返回原二进制序列的标题版本，其中每个单词以一个大写 ASCII 字符为开头，其余字母为小写。 不区别大小写的字节值将保持原样不变。</td> 
 </tr> 
 <tr> 
 <td>bytearray.upper()</td> 
 <td>返回原序列的副本，其所有小写 ASCII 字符均转换为对应的大写形式。</td> 
 </tr> 
 <tr> 
 <td>bytearray.zfill(width)</td> 
 <td>返回原序列的副本，在左边填充 <code>b'0'</code> 数码使序列长度为 width。 正负值前缀 (<code>b'+'</code>/ <code>b'-'</code>) 的处理方式是在正负符号 之后 填充而非在之前。</td> 
 </tr> 
 <tr> 
 <td></td> 
 <td></td> 
 </tr> 
 </tbody> 
</table>

memoryview 对象允许 Python 代码访问一个对象的内部数据，只要该对象支持 缓冲区协议 而无需进行拷贝。

obj 必须支持缓冲区协议。 支持缓冲区协议的内置对象包括 bytes 和 bytearray。

## 集合类型 ##

集合中存放的是不重复的数据。主要有set 和 frozenset两种。

set 类型是可变的 — 其内容可以使用 add() 和 remove() 这样的方法来改变。 由于是可变类型，它没有哈希值，且不能被用作字典的键或其他集合的元素。

frozenset 类型是不可变并且为 hashable — 其内容在被创建后不能再改变；因此它可以被用作字典的键或其他集合的元素。

看下集合的基本操作：

<table> 
 <thead> 
 <tr> 
 <th>运算</th> 
 <th>描述</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td>len(s)</td> 
 <td>返回集合 s 中的元素数量（即 s 的基数）。</td> 
 </tr> 
 <tr> 
 <td>x in s</td> 
 <td>检测 x 是否为 s 中的成员。</td> 
 </tr> 
 <tr> 
 <td>x not in s</td> 
 <td>检测 x 是否非 s 中的成员。</td> 
 </tr> 
 <tr> 
 <td>isdisjoint(other)</td> 
 <td>如果集合中没有与 other 共有的元素则返回 <code>True</code>。 当且仅当两个集合的交集为空集合时，两者为不相交集合。</td> 
 </tr> 
 <tr> 
 <td>issubset(other) 或者 set &lt;= other</td> 
 <td>检测是否集合中的每个元素都在 other 之中。</td> 
 </tr> 
 <tr> 
 <td>set &lt; other</td> 
 <td>检测集合是否为 other 的真子集，即 <code>set &lt;= other and set != other</code>。</td> 
 </tr> 
 <tr> 
 <td>issuperset(other) 或者 set &gt;= other</td> 
 <td>检测是否 other 中的每个元素都在集合之中。</td> 
 </tr> 
 <tr> 
 <td>set &gt; other</td> 
 <td>检测集合是否为 other 的真超集，即 <code>set &gt;= other and set != other</code>。</td> 
 </tr> 
 <tr> 
 <td>union(*others) 或者 set | other | …</td> 
 <td>返回一个新集合，其中包含来自原集合以及 others 指定的所有集合中的元素。</td> 
 </tr> 
 <tr> 
 <td>intersection(*others) 或者set &amp; other &amp; …</td> 
 <td>返回一个新集合，其中包含原集合以及 others 指定的所有集合中共有的元素。</td> 
 </tr> 
 <tr> 
 <td>difference(*others) 或者 set - other - …</td> 
 <td>返回一个新集合，其中包含原集合中在 others 指定的其他集合中不存在的元素。</td> 
 </tr> 
 <tr> 
 <td>symmetric_difference(other) 或者 set ^ other</td> 
 <td>返回一个新集合，其中的元素或属于原集合或属于 other 指定的其他集合，但不能同时属于两者。</td> 
 </tr> 
 <tr> 
 <td>copy()</td> 
 <td>返回原集合的浅拷贝。</td> 
 </tr> 
 </tbody> 
</table>

## 映射类型 ##

python中的映射类型是dict。只要是hashable的对象都可以作为dict的key。

字典可用多种方式来创建:

*  使用花括号内以逗号分隔 `键: 值` 对的方式: `{'jack': 4098, 'sjoerd': 4127}` or `{4098: 'jack', 4127: 'sjoerd'}`
 *  使用字典推导式: `{}`, `{x: x ** 2 for x in range(10)}`
 *  使用类型构造器: `dict()`, `dict([('foo', 100), ('bar', 200)])`, `dict(foo=100, bar=200)`

如果没有给出位置参数，将创建一个空字典。

字典的操作：

<table> 
 <thead> 
 <tr> 
 <th>运算</th> 
 <th>描述</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td>list(d)</td> 
 <td>返回字典 d 中使用的所有键的列表。</td> 
 </tr> 
 <tr> 
 <td>len(d)</td> 
 <td>返回字典 d 中的项数。</td> 
 </tr> 
 <tr> 
 <td>d[key]</td> 
 <td>返回 d 中以 key 为键的项。</td> 
 </tr> 
 <tr> 
 <td>d[key] = value</td> 
 <td>将 <code>d[key]</code> 设为 value。</td> 
 </tr> 
 <tr> 
 <td>del d[key]</td> 
 <td>将 <code>d[key]</code> 从 d 中移除。</td> 
 </tr> 
 <tr> 
 <td>key in d</td> 
 <td>如果 d 中存在键 key 则返回 <code>True</code>，否则返回 <code>False</code>。</td> 
 </tr> 
 <tr> 
 <td>key not in d</td> 
 <td>等价于 <code>not key in d</code>。</td> 
 </tr> 
 <tr> 
 <td>iter(d)</td> 
 <td>返回以字典的键为元素的迭代器。 这是 <code>iter(d.keys())</code> 的快捷方式。</td> 
 </tr> 
 <tr> 
 <td><code>clear</code>()</td> 
 <td>移除字典中的所有元素。</td> 
 </tr> 
 <tr> 
 <td><code>copy</code>()</td> 
 <td>返回原字典的浅拷贝。</td> 
 </tr> 
 <tr> 
 <td><code>get</code>(key[, default])</td> 
 <td>如果 key 存在于字典中则返回 key 的值，否则返回 default。 如果 default 未给出则默认为 <code>None</code></td> 
 </tr> 
 <tr> 
 <td><code>items</code>()</td> 
 <td>返回由字典键组成的一个新视图。</td> 
 </tr> 
 <tr> 
 <td><code>pop</code>(key[, default])</td> 
 <td>如果 key 存在于字典中则将其移除并返回其值，否则返回 default。</td> 
 </tr> 
 <tr> 
 <td><code>popitem</code>()</td> 
 <td>从字典中移除并返回一个 <code>(键, 值)</code> 对。 键值对会按 LIFO 的顺序被返回。</td> 
 </tr> 
 <tr> 
 <td>reversed(d)</td> 
 <td>返回一个逆序获取字典键的迭代器。 这是 <code>reversed(d.keys())</code> 的快捷方式。</td> 
 </tr> 
 <tr> 
 <td><code>setdefault</code>(key[, default])</td> 
 <td>如果字典存在键 key ，返回它的值。如果不存在，插入值为 default 的键 key ，并返回 default 。 default 默认为 <code>None</code>。</td> 
 </tr> 
 <tr> 
 <td><code>update</code>([other])</td> 
 <td>使用来自 other 的键/值对更新字典，覆盖原有的键。 返回 <code>None</code>。</td> 
 </tr> 
 <tr> 
 <td><code>values</code>()</td> 
 <td>返回由字典值组成的一个新视图。</td> 
 </tr> 
 <tr> 
 <td>d | other</td> 
 <td>合并 d 和 other 中的键和值来创建一个新的字典，两者必须都是字典。当 d 和 other 有相同键时， other 的值优先。</td> 
 </tr> 
 <tr> 
 <td>d |= other</td> 
 <td>用 other 的键和值更新字典 d ，other 可以是 mapping 或 iterable 的键值对。当 d 和 other 有相同键时， other 的值优先。</td> 
 </tr> 
 </tbody> 
</table>

### 字典视图对象 ###

由 dict.keys(), dict.values() 和 dict.items() 所返回的对象是 视图对象。 该对象提供字典条目的一个动态视图，这意味着当字典改变时，视图也会相应改变。

字典视图可以被迭代以产生与其对应的数据，并支持成员检测：

<table> 
 <thead> 
 <tr> 
 <th>运算</th> 
 <th>描述</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td>len(dictview)</td> 
 <td>返回字典中的条目数。</td> 
 </tr> 
 <tr> 
 <td>iter(dictview)</td> 
 <td>返回字典中的键、值或项（以 <code>(键, 值)</code> 为元素的元组表示）的迭代器。</td> 
 </tr> 
 <tr> 
 <td>x in dictview</td> 
 <td>如果 x 是对应字典中存在的键、值或项（在最后一种情况下 x 应为一个 <code>(键, 值)</code> 元组） 则返回 <code>True</code>。</td> 
 </tr> 
 <tr> 
 <td>reversed(dictview)</td> 
 <td>返回一个逆序获取字典键、值或项的迭代器。 视图将按与插入时相反的顺序进行迭代。</td> 
 </tr> 
 </tbody> 
</table>

# 内置异常 #

Python中所有的异常都来自BaseException ，我们看下内置异常的层级结构：

BaseException
     +-- SystemExit
     +-- KeyboardInterrupt
     +-- GeneratorExit
     +-- Exception
          +-- StopIteration
          +-- StopAsyncIteration
          +-- ArithmeticError
          |    +-- FloatingPointError
          |    +-- OverflowError
          |    +-- ZeroDivisionError
          +-- AssertionError
          +-- AttributeError
          +-- BufferError
          +-- EOFError
          +-- ImportError
          |    +-- ModuleNotFoundError
          +-- LookupError
          |    +-- IndexError
          |    +-- KeyError
          +-- MemoryError
          +-- NameError
          |    +-- UnboundLocalError
          +-- OSError
          |    +-- BlockingIOError
          |    +-- ChildProcessError
          |    +-- ConnectionError
          |    |    +-- BrokenPipeError
          |    |    +-- ConnectionAbortedError
          |    |    +-- ConnectionRefusedError
          |    |    +-- ConnectionResetError
          |    +-- FileExistsError
          |    +-- FileNotFoundError
          |    +-- InterruptedError
          |    +-- IsADirectoryError
          |    +-- NotADirectoryError
          |    +-- PermissionError
          |    +-- ProcessLookupError
          |    +-- TimeoutError
          +-- ReferenceError
          +-- RuntimeError
          |    +-- NotImplementedError
          |    +-- RecursionError
          +-- SyntaxError
          |    +-- IndentationError
          |         +-- TabError
          +-- SystemError
          +-- TypeError
          +-- ValueError
          |    +-- UnicodeError
          |         +-- UnicodeDecodeError
          |         +-- UnicodeEncodeError
          |         +-- UnicodeTranslateError
          +-- Warning
               +-- DeprecationWarning
               +-- PendingDeprecationWarning
               +-- RuntimeWarning
               +-- SyntaxWarning
               +-- UserWarning
               +-- FutureWarning
               +-- ImportWarning
               +-- UnicodeWarning
               +-- BytesWarning
               +-- ResourceWarning

> 本文已收录于 [http://www.flydean.com/11-python-inner-obj/][http_www.flydean.com_11-python-inner-obj]
> 
> 最通俗的解读，最深刻的干货，最简洁的教程，众多你不知道的小技巧等你来发现！
> 
> 欢迎关注我的公众号:「程序那些事」,懂技术，更懂你！

[http_www.flydean.com_11-python-inner-obj]: http://www.flydean.com/11-python-inner-obj/