python内置类型

冷不防 2023-05-28 12:51 1阅读 0赞

### python内置类型 ###

*   *   *  逻辑值
         *  布尔运算
         *  比较运算
         *  数字类型
         *  迭代器类型
         *  序列类型
         *  文本序列类型
         *  集合类型
         *  映射类型

### 逻辑值 ###

返回False的情况

*  被定义为假值的常量: None 和 False
 *  任何数值类型的零: 0, 0.0, 0j, Decimal(0), Fraction(0, 1)
 *  空的序列和多项集: ‘’, (), \[\], \{\}, set(), range(0)
 *  一个对象的定义了 \_\_bool\_\_() 方法且返回 False 或者 \_\_len\_\_() 方法且返回零。

### 布尔运算 ###

*  按优先级升序排列为and, or, not
 *  and和or 是短路运算符

### 比较运算 ###

*  优先级相同、比布尔运算的优先级高
 *  < , > ,<=,>=,==,!= ,is(对象标识),not is
 *  具有不同标识的类的实例比较结果通常为不相等，除非类定义了 \_\_eq\_\_() 方法。
 *  还可以自定义\_\_lt\_\_(), \_\_le\_\_(), \_\_gt\_\_() 以及 \_\_ge\_\_()

### 数字类型 ###

*  整数：具有无限的精度，布尔值属于整数的子类型。True=1,False=0 比如：a=True+1=2;
 *  浮点数: 通常使用double（8B)实现
 *  复数：包含实部real和虚部imag，分别以一个浮点数表示。
 *  对于可能为不同类型的数字 x 和 y，要求 x == y 时必定 hash(x) == hash(y)

### 迭代器类型 ###

*  container.\_\_iter\_\_():返回一个迭代器对象
 *  iterator.\_\_iter\_\_():返回迭代器对象本身
 *  iterator.\_\_next\_\_()从容器中返回下一项

### 序列类型 ###

*  通用操作

<table> 
 <thead> 
  <tr> 
   <th>运算</th> 
   <th>结果：</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>x in s</td> 
   <td>如果 s 中的某项等于 x 则结果为 True，否则为 False</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>x not in s</td> 
   <td>如果 s 中的某项等于 x 则结果为 False，否则为 True</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>s + t</td> 
   <td>s 与 t 相拼接</td> 
   <td>拼接不可变序列总是会生成新的对象。 range不支持序列拼接或重复。</td> 
  </tr> 
  <tr> 
   <td>s * n 或 n * s</td> 
   <td>相当于 s 与自身进行 n 次拼接</td> 
   <td>小于 0 的 n 值会被当作 0 来处理(生成一个与 s 同类型的空序列)</td> 
  </tr> 
  <tr> 
   <td>s[i]</td> 
   <td>s 的第 i 项，起始为 0</td> 
   <td>如果 i 或 j 为负值，则索引顺序是相对于序列 s 的末尾: 索引号会被替换为 len(s) + i 或 len(s) + j。 但要注意 -0 仍然为 0。</td> 
  </tr> 
  <tr> 
   <td>s[i:j]</td> 
   <td>s 从 i 到 j 的切片</td> 
   <td>s 从 i 到 j 的切片被定义为所有满足 i &lt;= k &lt; j 的索引号 k 的项组成的序列。 如果 i 或 j 大于 len(s)，则使用 len(s)。 如果 i 被省略或为 None，则使用 0。 如果 j 被省略或为 None，则使用 len(s)。 如果 i 大于等于 j，则切片为空。</td> 
  </tr> 
  <tr> 
   <td>s[i:j:k]</td> 
   <td>s 从 i 到 j 步长为 k 的切片</td> 
   <td>s 从 i 到 j 步长为 k 的切片被定义为所有满足 0 &lt;= n &lt; (j-i)/k 的索引号 x = i + n*k 的项组成的序列。 换句话说，索引号为 i, i+k, i+2*k, i+3*k，以此类推，当达到 j 时停止 (但一定不包括 j)。 当 k 为正值时，i 和 j 会被减至不大于 len(s)。 当 k 为负值时，i 和 j 会被减至不大于 len(s) - 1。 如果 i 或 j 被省略或为 None，它们会成为“终止”值 (是哪一端的终止值则取决于 k 的符号)。 请注意，k 不可为零。 如果 k 为 None，则当作 1 处理。</td> 
  </tr> 
  <tr> 
   <td>len(s)</td> 
   <td>s 的长度</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>min(s)</td> 
   <td>s 的最小项</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>max(s)</td> 
   <td>s 的最大项</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>s.index(x[, i[, j]])</td> 
   <td>x 在 s 中首次出现项的索引号（索引号在 i 或其后且在 j 之前）</td> 
   <td>当 x 在 s 中找不到时 index 会引发 ValueError。 不会复制任何数据，并且返回的索引是相对于序列的开头而非切片的开头。</td> 
  </tr> 
 </tbody> 
</table>

*  可变序列类型操作方法

<table> 
 <thead> 
  <tr> 
   <th>运算</th> 
   <th>结果：</th> 
   <th>注释</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>s[i] = x</td> 
   <td>将 s 的第 i 项替换为 x</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>s[i:j] = t</td> 
   <td>将 s 从 i 到 j 的切片替换为可迭代对象 t 的内容</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>del s[i:j]</td> 
   <td>等同于 s[i:j] = []</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>s[i:j:k] = t</td> 
   <td>将 s[i:j:k] 的元素替换为 t 的元素</td> 
   <td>t 必须与它所替换的切片具有相同的长度。</td> 
  </tr> 
  <tr> 
   <td>del s[i:j:k]</td> 
   <td>从列表中移除 s[i:j:k] 的元素</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>s.append(x)</td> 
   <td>将 x 添加到序列的末尾 (等同于 s[len(s):len(s)] = [x])</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>s.clear()</td> 
   <td>从 s 中移除所有项 (等同于 del s[:])</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>s.copy()</td> 
   <td>创建 s 的浅拷贝 (等同于 s[:])</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>s.extend(t) 或 s += t</td> 
   <td>用 t 的内容扩展 s (基本上等同于 s[len(s):len(s)] = t)</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>s *= n</td> 
   <td>使用 s 的内容重复 n 次来对其进行更新</td> 
   <td>n 值为一个整数，或是一个实现了 __index__() 的对象。 n 值为零或负数将清空序列。</td> 
  </tr> 
  <tr> 
   <td>s.insert(i, x)</td> 
   <td>在由 i 给出的索引位置将 x 插入 s (等同于 s[i:i] = [x])</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>s.pop([i])</td> 
   <td>提取在 i 位置上的项，并将其从 s 中移除</td> 
   <td>可选参数 i 默认为 -1，因此在默认情况下会移除并返回最后一项。</td> 
  </tr> 
  <tr> 
   <td>s.remove(x)</td> 
   <td>删除 s 中第一个 s[i] 等于 x 的项目。</td> 
   <td>当在 s 中找不到 x 时 remove 操作会引发 ValueError。</td> 
  </tr> 
  <tr> 
   <td>s.reverse()</td> 
   <td>就地将列表中的元素逆序。</td> 
   <td>当反转大尺寸序列时 reverse() 方法会原地修改该序列以保证空间经济性。</td> 
  </tr> 
 </tbody> 
</table>

*  列表list是可变序列
    
     *  用一对方括号来表示空列表: \[\]
     *  使用方括号，其中的项以逗号分隔: \[a\], \[a, b, c\]
     *  使用列表推导式: \[x for x in iterable\]
     *  使用类型的构造器: list() 或 list(iterable)
 *  元组是不可变序列
    
     *  使用一对圆括号来表示空元组: ()
     *  使用一个后缀的逗号来表示单元组: a, 或 (a,)
     *  使用以逗号分隔的多个项: a, b, c or (a, b, c)
     *  使用内置的 tuple(): tuple() 或 tuple(iterable)
 *  range 类型表示不可变的数字序列，通常用于在 for 循环中循环指定的次数。

### 文本序列类型 ###

*  str对象，也称为字符串。 字符串是由Unicode码位构成的不可变序列。
 *  字符串字面值写法
    
     *  单引号: ‘允许包含有 “双” 引号’
     *  双引号: “允许包含有 ‘单’ 引号”。
     *  三重引号: ‘’‘三重单引号’’’, “”“三重双引号”""（可以跨越多行 —— 其中所有的空白字符都将包含在该字符串字面值中）

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>capitalize()</td> 
   <td>返回原字符串的副本，其首个字符大写，其余为小写。</td> 
  </tr> 
  <tr> 
   <td>casefold()</td> 
   <td>回原字符串消除大小写的副本。 消除大小写的字符串可用于忽略大小写的匹配。</td> 
  </tr> 
  <tr> 
   <td>center(width[, fillchar])</td> 
   <td>返回长度为 width 的字符串，原字符串在其正中。 使用指定的 fillchar 填充两边的空位（默认使用 ASCII 空格符）。 如果 width 小于等于 len(s) 则返回原字符串的副本。</td> 
  </tr> 
  <tr> 
   <td>count(sub[, start[, end]])</td> 
   <td>反回子字符串 sub 在 [start, end] 范围内非重叠出现的次数。 可选参数 start 与 end 会被解读为切片表示法。</td> 
  </tr> 
  <tr> 
   <td>encode(encoding=“utf-8”, errors=“strict”)</td> 
   <td>返回原字符串编码为字节串对象的版本。 errors为 ‘strict’，‘ignore’, ‘replace’, ‘xmlcharrefreplace’, ‘backslashreplace’</td> 
  </tr> 
  <tr> 
   <td>endswith(suffix[, start[, end]])</td> 
   <td>如果字符串以指定的 suffix 结束返回 True，否则返回 False。</td> 
  </tr> 
  <tr> 
   <td>expandtabs(tabsize=8)</td> 
   <td>返回字符串的副本，其中所有的制表符会由一个或多个空格替换</td> 
  </tr> 
  <tr> 
   <td>find(sub[, start[, end]])</td> 
   <td>返回子字符串 sub 在 s[start:end] 切片内被找到的最小索引。 可选参数 start 与 end 会被解读为切片表示法。 如果 sub 未被找到则返回 -1。应该只在你需要知道 sub 所在位置时使用，检查子串使用 in 操作符</td> 
  </tr> 
  <tr> 
   <td>format(*args, **kwargs)</td> 
   <td>执行字符串格式化操作。“The sum of 1 + 2 is {0}”.format(1+2)</td> 
  </tr> 
  <tr> 
   <td>join(iterable)</td> 
   <td>返回一个由 iterable 中的字符串拼接而成的字符串</td> 
  </tr> 
  <tr> 
   <td>ljust(width[, fillchar])</td> 
   <td>返回长度为 width 的字符串，原字符串在其中靠左对齐。 使用指定的 fillchar 填充空位</td> 
  </tr> 
  <tr> 
   <td>lower()</td> 
   <td>返回原字符串的副本，其所有区分大小写的字符均转换为小写。</td> 
  </tr> 
  <tr> 
   <td>lstrip([chars])</td> 
   <td>返回原字符串的副本，移除其中的前导字符。</td> 
  </tr> 
  <tr> 
   <td>replace(old, new[, count])</td> 
   <td>返回字符串的副本，其中出现的所有子字符串 old 都将被替换为 new。 如果给出了可选参数 count，则只替换前 count 次出现。</td> 
  </tr> 
  <tr> 
   <td>rsplit(sep=None, maxsplit=-1)</td> 
   <td>返回一个由字符串内单词组成的列表，使用 sep 作为分隔字符串。 如果给出了 maxsplit，则最多进行 maxsplit 次拆分，从 最右边 开始。</td> 
  </tr> 
  <tr> 
   <td>split(sep=None, maxsplit=-1)</td> 
   <td>返回一个由字符串内单词组成的列表，使用 sep 作为分隔字符串。 如果给出了 maxsplit，则最多进行 maxsplit 次拆分，如果 maxsplit 未指定或为 -1，则不限制拆分次数</td> 
  </tr> 
  <tr> 
   <td>startswith(prefix[, start[, end]])</td> 
   <td>果字符串以指定的 prefix 开始则返回 True，否则返回 False</td> 
  </tr> 
  <tr> 
   <td>strip([chars])</td> 
   <td>返回原字符串的副本，移除其中的前导和末尾字符。 chars 参数为指定要移除字符的字符串。 如果省略或为 None，则 chars 参数默认移除空格符。</td> 
  </tr> 
 </tbody> 
</table>

### 集合类型 ###

*  set 对象是由具有唯一性的 hashable 对象所组成的无序多项集。
 *  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>isdisjoint(other)</td> 
   <td>如果集合中没有与 other 共有的元素则返回 True。 当且仅当两个集合的交集为空集合时，两者为不相交集合。</td> 
  </tr> 
  <tr> 
   <td>issubset(other)<br> set &lt;= other</td> 
   <td>检测是否集合中的每个元素都在 other 之中。</td> 
  </tr> 
  <tr> 
   <td>set &lt; other</td> 
   <td>检测集合是否为 other 的真子集</td> 
  </tr> 
  <tr> 
   <td>issuperset(other)<br> set &gt;= other</td> 
   <td>检测是否 other 中的每个元素都在集合之中。</td> 
  </tr> 
  <tr> 
   <td>set &gt; other</td> 
   <td>检测集合是否为 other 的真超集</td> 
  </tr> 
  <tr> 
   <td>union(*others)<br>set | other | …</td> 
   <td>返回一个新集合，其中包含来自原集合以及 others 指定的所有集合中的元素。</td> 
  </tr> 
  <tr> 
   <td>intersection(*others)<br> set &amp; other &amp; …</td> 
   <td>返回一个新集合，其中包含原集合以及 others 指定的所有集合中共有的元素。</td> 
  </tr> 
  <tr> 
   <td>difference(*others)<br>set - other - …</td> 
   <td>返回一个新集合，其中包含原集合中在 others 指定的其他集合中不存在的元素。</td> 
  </tr> 
  <tr> 
   <td>symmetric_difference(other)<br> set ^ other</td> 
   <td>返回一个新集合，其中的元素或属于原集合或属于 other 指定的其他集合，但不能同时属于两者。</td> 
  </tr> 
  <tr> 
   <td>update(*others)<br>set |= other |…</td> 
   <td>更新集合，添加来自 others 中的所有元素。 update()可接受接受任意可迭代对象作为参数。</td> 
  </tr> 
  <tr> 
   <td>intersection_update(*others)<br>set &amp;= other &amp; …</td> 
   <td>更新集合，只保留其中在所有 others 中也存在的元素。</td> 
  </tr> 
  <tr> 
   <td>difference_update(*others)<br>set -= other | …</td> 
   <td>更新集合，移除其中也存在于 others 中的元素。</td> 
  </tr> 
  <tr> 
   <td>symmetric_difference_update(other)<br>set ^= other</td> 
   <td>更新集合，只保留存在于集合的一方而非共同存在的元素。</td> 
  </tr> 
  <tr> 
   <td>add(elem)</td> 
   <td>将元素 elem 添加到集合中。</td> 
  </tr> 
  <tr> 
   <td>remove(elem)</td> 
   <td>从集合中移除元素 elem。 如果 elem 不存在于集合中则会引发 KeyError。elem 参数可以是一个 set</td> 
  </tr> 
  <tr> 
   <td>discard(elem)</td> 
   <td>如果元素 elem 存在于集合中则将其移除</td> 
  </tr> 
  <tr> 
   <td>pop()</td> 
   <td>从集合中移除并返回任意一个元素。 如果集合为空则会引发 KeyError。</td> 
  </tr> 
  <tr> 
   <td>clear()</td> 
   <td>从集合中移除所有元素。</td> 
  </tr> 
 </tbody> 
</table>

### 映射类型 ###

*  字典的键 不能使用 非 hashable 的值，即包含列表、字典或其他可变类型的值（此类对象基于值而非对象标识进行比较）不可用作键。
 *  数字类型用作键时遵循数字比较的一般规则：如果两个数值相等 (例如 1 和 1.0) 则两者可以被用来索引同一字典条目。
 *  字典可以通过将以逗号分隔的 键: 值 对列表包含于花括号之内来创建

<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]返回 d 中</td> 
   <td>返回 d 中以 key 为键的项。 如果映射中不存在 key 则会引发 KeyError。</td> 
  </tr> 
  <tr> 
   <td>d[key]</td> 
   <td>将 d[key] 设为 value。</td> 
  </tr> 
  <tr> 
   <td>del d[key]</td> 
   <td>将 d[key] 从 d 中移除。 如果映射中不存在 key 则会引发 KeyError。</td> 
  </tr> 
  <tr> 
   <td>key in d</td> 
   <td>如果 d 中存在键 key 则返回 True，否则返回 False。</td> 
  </tr> 
  <tr> 
   <td>iter(d)</td> 
   <td>返回以字典的键为元素的迭代器。 这是 iter(d.keys()) 的快捷方式。</td> 
  </tr> 
  <tr> 
   <td>clear()</td> 
   <td>移除字典中的所有元素。</td> 
  </tr> 
  <tr> 
   <td>get(key[, default])</td> 
   <td>如果 key 存在于字典中则返回 key 的值，否则返回 default。 如果 default 未给出则默认为 None，因而此方法绝不会引发 KeyError。</td> 
  </tr> 
  <tr> 
   <td>items()</td> 
   <td>返回由字典项 ((键, 值) 对) 组成的一个新视图。</td> 
  </tr> 
  <tr> 
   <td>keys()</td> 
   <td>返回由字典键组成的一个新视图。</td> 
  </tr> 
  <tr> 
   <td>pop(key[, default])</td> 
   <td>如果 key 存在于字典中则将其移除并返回其值，否则返回 default。 如果 default 未给出且 key 不存在于字典中，则会引发 KeyError。</td> 
  </tr> 
  <tr> 
   <td>popitem()</td> 
   <td>从字典中移除并返回一个 (键, 值) 对。 键值对会按 LIFO 的顺序被返回。 如果字典为空，调用 popitem() 将引发 KeyError。3.7前会返回一个任意的键/值对。</td> 
  </tr> 
  <tr> 
   <td>setdefault(key[, default])</td> 
   <td>如果字典存在键 key ，返回它的值。如果不存在，插入值为 default 的键 key ，并返回 default 。 default 默认为 None。</td> 
  </tr> 
  <tr> 
   <td>update([other])</td> 
   <td>使用来自 other 的键/值对更新字典，覆盖原有的键。 返回 None。</td> 
  </tr> 
  <tr> 
   <td>values()</td> 
   <td>返回由字典值组成的一个新视图。</td> 
  </tr> 
 </tbody> 
</table>