python 内置类型

基础数据类型

  • 真值校验
  • 数字类型 --int ，float，complex
  • 迭代器类型
  • 序列类型 --list，tuple，range
  • 文本序列类型 --str
  • 二进制类型 -- bytes，bytearray,memoryview
  • 集合类型 -- set ，frozenset
  • 映射类型 -- dict
  • 上下文管理器类型
  • 类型注释类型 Generic Alias ， Union
  • 其他内置类型
  • 特殊属性

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

真值校验

对象的 bool() ，和__len__() 来判断对象是否为真值

  • 定义为假的常量： None 和 False .
  • 任何数字类型的零： 0 ， 0.0 ， 0j ， Decimal(0) ， Fraction(0, 1)
  • 空序列和集合： '' ， () ， [] ， {} ， set() ， range(0)

具有布尔结果的操作和内置函数, 返回 0 或 False 代表假，返回 1 或 True 则为真，除非另有说明。（重要例外：布尔运算 or 和 and 总是返回其中一个操作数)

布尔运算

操作 结果 笔记
x or y 如果 x 是假的，那么 y ，否则 x (1)
x and y 如果 x 是假的，那么 x ，否则 y (2)
not x 如果 x 是假的，那么 True ，否则 False (3)

笔记：

  1. 这是一个短路运算符，因此仅当第一个参数为假时才计算第二个参数。
  2. 这是一个短路运算符，因此仅当第一个参数为真时才计算第二个参数。
  3. not 优先级低于非布尔运算符，因此 not a == b 被解释为 not (a == b) 和 a == not b 是语法错误。

比较运算

操作 意义 优先级
< 严格小于 0
<= 小于或等于 0
> 严格大于 0
>= 大于或等于 0
== 平等的 0
!= 不等 0
is 对象标识 0
is not 否定的对象标识 0
in 存在于 0
not in 存在于 0
  • 比较运算符优先级 大于 布尔运算

另外两个具有相同语法优先级的操作， in 和 not in ，由以下类型支持 iterable 或者执行 __contains__() 方法。

数字类型

  1. int - (integers)
  2. float - (floating point numbers)
  3. complex - (complex numbers )

常用的 数值运算

操作 结果 笔记
x//y 地板商 x 和 y
x%y 余下的 x / y
abs(x) x de 绝对值
divmod(x, y) 这对 (x // y, x % y)
x ** y x的幂y
pow(x, y) x的幂y （1）
round(x[, n]) x 四舍五入 n 数字，四舍五入到偶数。如果 n 省略，默认为0

笔记：

  1. Python定义 pow(0, 0) 和 0 ** 0 成为 1 和编程语言一样

整数类型的位运算

数字类型的方法

  • 目前开发程序中尚未使用到该类型方法且不做记录
  • 文档地址

迭代器类型

  • 迭代器对象本身需要支持以下两个方法，它们共同构成 iterator protocol(迭代器协议)
  • iterator.iter()
  • iterator.next()

生成器类型

  • Python 的 generator 为实现迭代器协议提供了一种方便的方法。如果容器对象的 iter() 方法被实现为一个生成器，它将自动返回一个迭代器对象（从技术上讲，是一个生成器对象），提供 iter() 和 next() 方法。有关生成器的更多信息，请参见 the documentation for the yield expression .

序列类型

  • 有三种基本序列类型：列表、元组和范围对象。为处理而定制的附加序列类型 binary data 和 text strings 在专用章节中描述。
  • 文档地址

公共序列操作

  • 在表格里， s 和 t 是同一类型的序列， n ， i ， j 和 k 是整数和 x 是满足任何类型和值限制的任意对象 s .
操作 结果 笔记
x in s (1)
x not in s (1)
s + t 连接 s 和 t (6)(7)
s * n or n * s 相当于添加 s 对自身 n 次 (2)(7)
s[i] i 第9项 s origin 0 (3)
s[i:j] 切片 s 从 i 到 j (3)(4)
s[i:j:k] 切片 s 从 i 到 j 随步 k (3)(5)
len(s) 长度 s
min(s) 最小项 s
max(s) 最大项目 s
s.index(x[, i[, j]]) 第一次出现的索引 x 在里面 s （在索引处或索引后） i 在索引之前 j ） (8)
s.count(x) x在s序列中出现的次数
  • 相同类型的序列也支持比较。尤其是，通过比较相应的元素，从词典的角度比较元组和列表。这意味着要比较相等，每个元素都必须比较相等，并且两个序列的类型和长度必须相同。（有关详细信息，请参阅 比较 在语言参考中。）

笔记：

  1. 而 in 和 not in 操作仅用于一般情况下的简单安全壳测试，一些专门的序列（例如 str ， bytes 和 bytearray ）也可将其用于后续测试：
    >>> "gg" in "eggs"
True
  2. 价值观 n 小于 0 被视为 0 （生成与相同类型的空序列 s ）注意顺序中的项目 s 不被复制；它们被多次引用。这经常困扰着新的Python程序员；请考虑：
    >>> lists = [[]] * 3
>>> lists
[[], [], []]
>>> lists[0].append(3)
>>> lists
[[3], [3], [3]]
    发生了什么事 [[]] 是一个包含空列表的元素列表，因此 [[]] * 3 是对此单个空列表的引用。修改的任何元素 lists 修改此单个列表。您可以通过以下方式创建不同列表的列表：
    >>> lists = [[] for i in range(3)]
>>> lists[0].append(3)
>>> lists[1].append(5)
>>> lists[2].append(7)
>>> lists
[[3], [5], [7]]
  3. 如果 i 或 j 为负，索引相对于序列结尾 s ： len(s) + i 或 len(s) + j 被替换。但请注意 -0 仍然是 0 .
  4. 切片 s 从 i 到 j 定义为具有索引的项序列 k 这样的话 i <= k < j . 如果 i 或 j 大于 len(s) 使用 len(s) . 如果 i 被省略或 None 使用 0 . 如果 j 被省略或 None 使用 len(s) . 如果 i 大于或等于 j ，切片为空。
  5. 切片 s 从 i 到 j 随步 k 定义为具有索引的项序列 x = i + nk 这样的话 0 <= n < (j-i)/k . 换句话说，指数是 i ， i+k ， i+2k ， i+3*k 等等，什么时候停车 j 已到达（但不包括 j ）什么时候？ k 是正的， i 和 j 被还原为 len(s) 如果它们更大。什么时候？ k 是否定的， i 和 j 被还原为 len(s) - 1 如果它们更大。如果 i 或 j 被省略或 None ，它们成为“结束”值（哪一个结束取决于 k ）注： k 不能为零。如果 k 是 None ，就像对待 1 .
  6. 连接不可变序列总是会产生一个新的对象。这意味着通过重复的连接构建序列将在总序列长度上具有二次运行时成本。要获得线性运行时成本，必须切换到以下选项之一：
    • 如果连接 str 对象，您可以构建一个列表并使用 str.join() 在结尾处，或者写信给 io.StringIO 实例并在完成时检索其值
    • 如果连接 bytes 对象，可以类似地使用 bytes.join() 或 io.BytesIO 或者您可以使用 bytearray 对象。 bytearray 对象是可变的，并且具有有效的过度分配机制
    • 如果连接 tuple 对象，扩展 list 相反
    • 对于其他类型，调查相关的类文档
  7. 一些序列类型（例如 range ）只支持遵循特定模式的项目序列，因此不支持序列串联或重复。
  8. index 引发 ValueError 什么时候？ x 在中未找到 s . 并非所有实现都支持传递附加参数 i 和 j . 这些参数允许有效地搜索序列的子部分。传递额外的参数大致等同于使用 s[i:j].index(x) 仅在不复制任何数据的情况下，并且返回的索引相对于序列的开始而不是切片的开始。

不可变序列类型

  • 不可变序列是 可以hash的 也就是可以执行 hash(x)
  • 不可变序列可以作为 字典的 key 或者 存储在 set实例 或 frozenset 实例中
  • 元祖实例就是不可变序列

可变序列类型

  • 在表格上 s 是可变序列类型的实例， t 是任何无法识别的对象 ，x 是满足任何类型和值限制的 s的任意对象 （例如， bytearray 只接受满足值限制的整数 0 <= x <= 255 ）
操作 结果 笔记
s[i] = x 项目 i 属于 s 被替换 x
s[i:j] = t 切片 s 从 i 到 j 替换为iterable的内容 t
del s[i:j] 等同于 s[i:j] = []
s[i:j:k] = t 元素 s[i:j:k] 替换为 t (1)
del s[i:j:k] 删除的元素 s[i:j:k] 从名单上
s.append(x) 追加 x 到序列的结尾（与 s[len(s):len(s)] = [x]）
s.clear() 从中删除所有项 s （同） del s[:] ） (5)
s.copy() 创建的浅副本 s （同） s[:] ） (5)
s.extend(t) or s += t 延伸 s 内容如下： t （大部分与 s[len(s):len(s)] = t ）
s *= n 更新 s 内容重复 n 次 (6)
s.insert(i, x) 插入物 x 进入之内 s 在给出的索引处 i （同） s[i:i] = [x] ）
s.pop([i]) 在处检索项 i 同时也将其从 s (2)
s.remove(x) 从中删除第一项 s 在哪里？ s[i] 等于 x (3)
s.reverse() 反转的项 s 就位 (4)

笔记：

  1. t 必须与要替换的切片的长度相同。
  2. 可选参数 i 默认为 -1 ，以便默认情况下删除并返回最后一个项。
  3. remove() 加薪 ValueError 什么时候？ x 在中未找到 s .
  4. 这个 reverse() 方法在反转大序列时，为节省空间，对序列进行适当的修改。为了提醒用户它是由副作用操作的，它不会返回相反的序列。
  5. clear() 和 copy() 为了与不支持切片操作的可变容器（例如 dict 和 set ） copy() 不是 collections.abc.MutableSequence 但是大多数具体的可变序列类都提供了它。
  6. 价值 n 是一个整数，或者是一个实现 index() . 的零值和负值 n 清除序列。序列中的项目不被复制；它们被多次引用，如 s * n 在下面 公共序列操作 .

列表list()

  • 创建方式

    • 使用一对方括号表示空列表： []
    • 使用方括号，用逗号分隔项目： [a] ， [a, b, c]
    • 使用列表理解： [x for x in iterable]
    • 使用类型构造函数： list() 或 list(iterable)

  • 方法

    点击查看代码 
    list.sort(self,key=key,reverse=False)  # reverse 为True 代表翻转列表
lst = [[3, 5], [2, 5], [1, 7]]
print(lst)
lst.sort()
print(lst)
lst.sort(key=lambda x: x)
print(lst)  
lst.sort(key=lambda x: x[0])
print(lst)  
lst.sort(key=lambda x: x[1])
print(lst)  
# 原列表   [[3, 5], [2, 5], [1, 7]]
# 不设置KEY  [[1, 7], [2, 5], [3, 5]]
# 以列表对象进行排序 [[1, 7], [2, 5], [3, 5]]
# 以第一个元素进行排序  [[1, 7], [2, 5], [3, 5]]
# 以第二个元素进行排序  [[2, 5], [3, 5], [1, 7]]

元组tuple()

  • 创建方式
    • 使用一对括号表示空元组： ()
    • 对单元组使用尾随逗号： a, 或 (a,)
    • 用逗号分隔项目： a, b, c 或 (a, b, c)
    • 使用 tuple() 内置的： tuple() 或 tuple(iterable)

范围range()

  • 这个 range 类型表示不可变的数字序列，通常用于在 for 循环。

  • 创建方式

    点击查看代码 
    print(list(range(10)))  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(list(range(1, 10)))  # [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(list(range(1, -10, -1)))  # [1, 0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
print(list(range(0, 10, 3)))  # [0, 3, 6, 9]
print(list(range(0, -10, -3)))  # [0, -3, -6, -9]
print(list(range(0)))  # []
print(list(range(10, 1)))  # []
print(list(range(1, 10, -3)))  # []
print(list(range(1, -10, 3)))  # []

  • 方法：

    点击查看代码 
    r = range(0, 10, 1)
print(r)  # range(0, 10)
# 切片操作
print(r[:5])  # range(0, 5)
# 成员运算
print(11 in r)  # False
print(9 in r)  # True
# 查找元素
print(r.index(9))  # 9
# 索引取值
print(r[5])  # 5
print(r[-1])  # 9
# 范围对比 以结果进行比较
print(range(0, 8, 4) == range(0, 6, 4))  # True
print(list(range(0, 8, 4)))  # [0, 4]
print(list(range(0, 6, 4)))  # [0, 4]

文本序列类型

str

  • str方法

    点击查看代码 
    string_txt = f'ABC={123},DEF={456}'  # 字符串变量替换
string_txt = u'ABC,DEF'     # 使用Unicode编码
string_txt = r'ABCDEF\tABC\nDEF'   # 防止\转义字符


# 去除前导后导字符串
print('121212ABC12'.strip('12'))  # ABC  ## 返回删除前导和尾随空格的字符串副本,不指定默认为 空格
print('aaABC'.lstrip('a'))  # ABC ## 返回删除前导空格的字符串副本。 如果给出了chars而不是None，则改为删除chars中的字符。
print('ABCBB'.rstrip('B'))  # ABC ## 返回一个删除了尾随空格的字符串副本

# 字符串替换
print('AaBaCa'.replace('a', 'B'))  # ABBBCB # 返回一个副本，将所有出现的子字符串old替换为new。
print('AaBaCa'.replace('a', 'B', 1))  # ABBaCa # 给定参数 指定替换几次，默认是-1 全部替换

# 字符串分割
print('AABBCCDD'.split('B', 1))  # ['AAB', 'CCDD'] #  这是分割一次
print('AABBCCDD'.split('B'))  # ['AA', '', 'CCDD'] #  这是分割多次 没有指定默认分割次数为-1 -1代表全部分割
print('AABBCCDD'.rsplit('B', 1))  # ['AAB', 'CCDD'] #  和split()一样
print('AABBCCDD'.rsplit('B'))  # ['AA', '', 'CCDD'] #  和split()一样

# 字符串格式化
print('ABC={A} DEF={B}'.format(A='123', B='345'))  # ABC=123 DEF=345  ## 方式一
print('ABC={1} DEF={0}'.format('123', '345'))  # ABC=345 DEF=123  ##  方式二
print('ABC={} DEF={}'.format('123', '345'))  # ABC=123 DEF=345  ##   方式三
print("My name is {name},I am {age} old".format_map({"name": "john", "age": 33}))  # My name is john,I am 33 old
# 字符串格式化方式二
print('ABC=%s,DEF=%s' % (123, 345))
print('姓名:%(name)s,年龄:%(age)s,电话:%(phone)s'%{'name':'jwd','age':18,'phone':'123456'})

# 查询子字符串
print('ABC DEF'.find('DE', 1, 6))  # 4  ## 返回S中子字符串sub所在位置的最低下标，使sub包含在S[start:end]中。 有则返回子字符串首字符出现的位置,没有则返回-1
print('ABC DEF'.index('DE', 1, 6))  # 4 ## 和find() 用法一样不过 没找到则抛出异常
print('ABC 1234 DEF 567'.rfind('23', 0, 20))  # 5 ## 和find使用方法一样
print('ABC 1234 DEF 567'.rindex('23', 0, 20))  # 5  ## 和index使用方法一样

# 字符串列表拼接
print('-'.join(['12', '34', '56']))  # 12-34-56   ## 用指定字符拼接可迭代列表。

# 字符串判断
print("ABC123_".isalnum())  # False   ## 如果字符串是字母-数字字符串则返回True，否则返回False。
print("ABC".isalpha())  # True   ## 如果字符串是字母字符串则返回True，否则返回False
print('ABC'.isascii())  # True  ## 如果字符串中的所有字符都是ASCII，则返回True，否则返回False。
print('123'.isdecimal())  # True ## 如果字符串中的所有字符都是十进制和，则该字符串为十进制字符串,字符串中至少有一个字符。
print('123'.isdigit())  # True ##  如果字符串中的所有字符都是数字，则字符串是数字字符串 至少是字符串中的一个字符。
print('def get(): return 1*2 '.isidentifier())  # False ## 如果字符串是有效的Python标识符，则返回True，否则返回False (不知道用法)
print('abc'.islower())  # True ## 如果字符串是小写字符串则返回True，否则返回False。
print('123'.isnumeric())  # True ## 如果字符串是数字字符串则返回True，否则返回False
print('abc'.isprintable())  # True ## 如果字符串是可打印的返回True，否则返回False。
print('   '.isspace())  # True ## 如果字符串是空白字符串则返回True，否则返回False。
print('Python Student'.istitle())  # True ## 如果字符串是标题大小写字符串，则返回True，否则返回False。
print('ABC '.isupper())  # True  ## 如果字符串是大写字串则返回True，否则返回False。

# 字符串前中后分
print('AABbCc'.partition('Bb'))  # ('AA', 'Bb', 'Cc')   ## 使用给定的分隔符将字符串分成三部分。
print('ABC'.rpartition('a'))  # ('', '', 'ABC')  ## 找到的
print('AABcBCC'.rpartition('B'))  # ('AAB', 'B', 'CC') ## 未找到

# 大小写转换
print('123abc'.upper())  # 123ABC  ## 返回一个转换为大写字母的字符串副本
print('ABC'.lower())  # abc  ##返回一个转换成小写字母的字符串副本
print('ABC def'.swapcase())  # abc DEF ## 将大写字符转换为小写字符，将小写字符转换为大写字符。

# 字符填充
print('ABC DEF'.center(12, 'c'))  # ccABC DEFccc    ## 返回长度为width的居中字符串。填充使用指定的填充字符(默认为空格)
print('ABC'.ljust(10, '-'))  # ABC-------   ##返回一个长度为width的左对齐字符串
print('ABC'.rjust(10, '-'))  # -------ABC  ## 返回一个长度为width的右对齐字符串。
print('ABC'.zfill(10))  # 0000000ABC  ## 填充数字字符串左侧的零，以填充给定宽度的字段。

# 标签转换
print('student python'.title())  # Student Python    ## 返回字符串的一个版本，其中每个单词都有标题。

# 判断开头和结尾
print('ABC123def456'.startswith('12', 3, 20))  # True ## 如果指定字符串以指定的前缀开始返回True，否则返回False。
print('ABC DEF'.endswith('C', 0, 3))  # True   ##  如果S以指定后缀结束返回True，否则返回False。

# 特殊用法
print('abc def'.capitalize())  # Abc def    ## 返回字符串的大写版本。更具体地说，使第一个字符大写，其余字符小写的情况。
print('ABC DEF'.casefold())  # abc def   ## 返回适合于无大小写比较的字符串版本。
print('ABCC DEFCGHCCCC'.count('CC', 0, 20))  # 3    ## 返回子字符串sub in不重叠出现的次数 字符串(开始:结束)。可选参数start和end为 解释为切片表示法。
print('ABC DEF'.encode(encoding='GBK'))  # b'ABC DEF'   ## 使用为编码注册的编解码器对字符串进行编码。
print('ABC\tDEF'.expandtabs(tabsize=5))  # ABC  DEF   ## 返回一个副本，其中所有制表符都使用空格展开。 如果没有给出tabsize，则假定制表符大小为8个字符。
print('abc123\nabc321'.splitlines())  # ['abc123', 'abc321'] ## 返回字符串中的行列表，在行边界处断行。
# 超级用法
print('ABC'.maketrans('ABC', '123'))  ## 不知道用法  映射表
print('ABCDEFG abcdefg aabbccddeeff'.translate(str.maketrans('abc', '123')))  # 对照映射表对字符串进行替换

  • str内置方法

    点击查看代码 
    print('ABC'.__str__())  # Return str(self)
print('ABC'.__repr__())  # Return repr(self)
print('ABC'.__sizeof__())  
print('ABC'.__iter__())  # Return iter(self)
print('ABC'.__hash__())  # Return hash(self)
print('ABC'.__format__('123'))  # 返回format_spec所描述的格式化版本的字符串。
print('ABC'.__getnewargs__())  # Return self>=value.
print('ABC'.__getitem__(1))  # Return self[key]
print('ABC'.__contains__('BC'))  # Return key in self. sub字符串是否在str中返回boolean值
print('ABC'.__len__())  # Return len(self).
print('ABC'.__add__('123'))  # Return self+value
print('ABC'.__ne__('ABC'))  # Return self!=value.
print('ABC'.__lt__('ABC'))  # Return self<value
print('ABC'.__le__('ABC'))  # Return self<=value
print('ABC'.__eq__('ABC'))  # Return self==value.
print('ABC'.__gt__('ABC'))  # Return self>value.
print('ABC'.__ge__('ABC'))  # Return self>=value.
print('ABC'.__rmul__(3))  # Return value*self.
print('ABC'.__mul__(3))  # Return self*value.
print('ABC'.__rmod__(3))  # Return value%self.
# print('ABC'.__mod__(3))  # Return self%value.  ## 用法不明
# print('ABC'.__getattribute__())  # Return getattr(self, name) # 用法不明

二进制序列类型

此种类型牵扯多，目前用不到暂且搁置

集合类型

set , frozenset

  • set 对象是distinct的无序集合 hashable 物体。常见的用途包括成员资格测试、从序列中删除重复项以及计算数学运算，如交集、并集、差分和对称差分

  • 与其他集合一样，集合支持 x in set ， len(set) 和 for x in set .作为无序集合，集合不记录元素位置或插入顺序。因此，集合不支持索引、切片或其他类似序列的行为。

  • 集合种类两种

    • 可变类型 set 这个 set 类型是可变的---可以使用如下方法更改内容 add() 和 remove() . 因为它是可变的，所以它没有hash值，不能用作字典键或另一个集合的元素。
    • 不可变类型 frozenset 这个 frozenset 类型不可变且 hashable ---其内容创建后不能更改，因此可以用作字典键或其他集合的元素。

  • 创建方式

    • 注意：集合内部的元素必须是 hashable
    • 在大括号内使用逗号分隔的元素列表： {'jack', 'sjoerd'}
    • 使用一种固定的理解： {c for c in 'abracadabra' if c not in 'abc'}
    • 使用类型构造函数： set() ， set('foobar') ， set(['a', 'b', 'foo'])

  • 方法

    点击查看代码 
    s = {1, 2, 3, 4, 5, 6}
other, other1, other2 = {1, 2}, {3, 4}, {11, 12}
others = {1, 2}, {3, 4}, {11, 12}
x = 1
print(len(s))  # 7  ## 返回集合中的元素数 s （基数） s ）
print(x in s)  # True ## 试验 x 会员资格 s .
print(x not in s)  # False ## 试验 x 对于非会员 s .
# 是否不相交？
print(s.isdisjoint(other))  # False  ## s集合与other集合是否不相交 , 当且仅当集合的交集为空集合时，集合才是不相交的。
# 是否是子集？
# print(s.issubset(other))  # False ## 测试集合中的每个元素是否都在 other .
print(s <= other) # False
print(s < other) # False
# 是否为父级？
# print(s.issuperset(other))  # True   ## 测试中的每个元素 other 在集合中。
print(s >= other)  # True
print(s > other)  # True
# 返回并集
print(s.union(*others))  # {1, 2, 3, 4, 5, 6, 11, 12}  ## 返回包含集合和所有其他元素的新集合。
print(s | other | other1 | other2)  # {1, 2, 3, 4, 5, 6, 11, 12}
# 返回交集
print(s.intersection(*others))  # set() ## 返回一个新集合，其中包含集合和所有其他集合的公共元素。
print(s & other & other1 & other2)  # set()
# 返回差集
print(s.difference(*others))  # {5, 6}  ## 返回一个新集合，集合中的元素不在其他集合中。
print(s - other - other1 - other2)  # {5, 6}
# 返回对称差集
print(s.symmetric_difference(other))  # {3, 4, 5, 6}  ## 返回包含集合或中元素的新集合 other 但并非两者兼而有之。
print(s ^ other) # {3, 4, 5, 6}
# 返回集合的浅拷贝
new_s = s.copy()  # 返回集合的浅拷贝

  • 可用于set 不可用于 frozenset()

  • set()方法

    点击查看代码 
    s = {1, 2, 3, 4, 5, 6}
other, other1, other2 = {1, 2}, {3, 4}, {11, 12}
others = {1, 2}, {3, 4}, {11, 12}

s.update(*others)
print(s) # {1, 2, 3, 4, 5, 6, 11, 12} ## 更新集合，添加所有其他元素。
s |= other | other1 | other2
print(s) # {1, 2, 3, 4, 5, 6, 11, 12}
s.intersection_update(*others)
print(s) # set()  # ## 更新集合，只保留其中的元素和所有其他元素。
s &= other & other1 & other2
print(s) # set()
s.difference_update(*others)
print(s) # {5, 6}  ## 更新集合，删除在其他集合中找到的元素。
s -= other | other1 | other2
print(s) # {5, 6}
s.symmetric_difference_update(other)
print(s)  # {3, 4, 5, 6} ## 更新集合，只保留在任一集合中找到的元素，而不同时保留在两者中。
s ^= other
print(s)  # {3, 4, 5, 6}

elem = '100'
s.add(elem)
print(s)  # {1, 2, 3, 4, 5, 6, '100'}  ## 添加元素 elem 到集合。
s.remove(elem)
print(s)  # {1, 2, 3, 4, 5, 6}  ## 移除元素 elem 从集合。如果elem不包含在集合中,引发KeyError。
s.discard(elem)
print(s)  # {1, 2, 3, 4, 5, 6}   ## 移除元素 elem如果存在的话。
result = s.pop()
print(result)  # 1 ## 从集合中移除并返回任意元素。引发KeyError如果集合为空。
s.clear()
print(s)  # set() ## 从集合中移除所有元素。

映射类型

dict

  • 创建方式

    • 使用逗号分隔的列表 key: value 大括号内的对： {'jack': 4098, 'sjoerd': 4127} 或 {4098: 'jack', 4127: 'sjoerd'}
    • 使用字典理解： {{}} ， {x: x ** 2 for x in range(10)}
    • 使用类型构造函数： dict() ， dict([('foo', 100), ('bar', 200)]) ， dict(foo=100, bar=200)
    • 这是常见创建方式：
      a = dict(one=1, two=2, three=3)
b = {'one': 1, 'two': 2, 'three': 3}
c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
d = dict([('two', 2), ('one', 1), ('three', 3)])
e = dict({'three': 3, 'one': 1, 'two': 2})
f = dict({'one': 1, 'three': 3}, two=2)
a == b == c == d == e == f

  • 方法

    点击查看代码 
    d = {'A': 1, 'B': 2, 'C': 3}

# 字典获取值
print(d['A'])
print(d.get('key'))  # None   ##返回的值 key 如果 key 在字典里，否则 default .如果 default 未给定，默认为 None ，以便此方法不会引发
# 字典添加值
d['key'] = 'value'
print(d)  # {'A': 1, 'B': 2, 'C': 3, 'key': 'value'}
print(d.setdefault('key', 'val'))  # val ## 如果 key 在字典中，返回其值。如果不是，插入 key 具有价值 default 然后返回 default . default 默认为 None .
print(d)  # {'A': 1, 'B': 2, 'C': 3, 'key': 'val'} ##  'key': 'val' 键值对存在！
# 字典的删除
del d['key']
print(d)  # {'A': 1, 'B': 2, 'C': 3} ## 删除的字典中的'key'键值对，如果key不存在则引发异常
print(d.pop('key', 'null'))  # null ##如果 key 在字典中，移除并返回其值，否则返回 default . 如果 default 没有给予和 key 不在字典中，a KeyError 提高了。
print(d.popitem())  # ('C', 3) ## 移除并返回 (key, value) 从字典中配对。成对返回 LIFO 秩序。

# 字典更新
d.update({'A': 11, 'B': '12', 'D': '32'})
print(d)  # {{'A': 11, 'B': '12', 'D': '32'} # 更新字典中的键值对的值
# 字典视图
print(d.items())  # dict_items([('A', 11), ('B', '12'), ('D', '32')])  ## 返回字典项的新视图 ((key, value) 对）
print(d.keys())  # dict_keys(['A', 'B', 'D']) ##  返回字典键的新视图。
print(d.values())  # dict_values([11, '12', '32']) ## 返回字典值的新视图
# 字典copy
print(d.copy())  # {'A': 11, 'B': '12', 'D': '32'}
# 字典其他
print(list(d))  # ['A', 'B', 'D']  ## 返回字典中使用的所有键的列表 d .
print(len(d))  # 3  ## 返回字典中的项数 d .
print('key' in d)  # False ## 返回 True 如果 d 有钥匙 key ，否则 False .
print('key' not in d)  # True ## 相当于 not key in d .
print(dict.fromkeys([1, 2, 3], 'val'))  # {1: 'val', 2: 'val', 3: 'val'} ## 快速创建字典
print(d.clear())  # None ## 从字典中删除所有项。
# 字典特殊
print(iter(d))  # <dict_keyiterator object at 0x022A9AE0> ##返回对字典键的迭代器。这是一个快捷方式 iter(d.keys()) .


# print(reversed(d))  ## 返回对字典键的反向迭代器。这是一个快捷方式 reversed(d.keys()) #解释器3.8新特性
# print(d | other  )  ## 使用合并的键和值创建新词典 d 和 其他 ，必须都是字典。价值观 其他 优先考虑 d 和 其他 共享密钥。#解释器3.9新特性
# print(d |= other)  ## 更新字典 d 键和值来自 其他 ，可以是 mapping 或 iterable 键/值对的。价值观 其他 优先考虑 d 和 其他 共享密钥。#解释器3.9新特性

class Counter(dict):
    def __missing__(self, key):
        return 0


c = Counter()  # 当c['key']字典键不存在的时候调用字典对象的__missing__()方法
print(c['red'])  # 0
c['red'] += 1
print(c['red'])  # 1
c['red'] += 1
print(c['red'])  # 2

  • 特殊注意：

    • 词典保留插入顺序。请注意，更新密钥不会影响顺序。删除后添加的键将插入到末尾。
    • 在 3.7 版更改: 字典顺序保证为插入顺序。这个行为是3.6中的cpython的一个实现细节。
    • 在 3.8 版更改: 字典现在是可逆的

字典视图对象

  • 目前重点就一个：
    • 返回的对象 dict.keys() ， dict.values() 和 dict.items() 是 查看对象 . 它们提供字典条目的动态视图，这意味着当字典更改时，视图会反映这些更改。
    • 其特性长出现在 3.8-3.9-3.10之中。

上下文管理器类型

  • 上下文管理器类型目前未全部了解暂不记录

类型注释类型

  • 目前仅仅理解一部分
  • 拓展
    isinstance(x, A_tuple) # 返回对象是类的实例还是类的子类的实例
x = [1, 2]
print(isinstance(x, int))  # False
print(isinstance(x, list))  # True
print(isinstance(x, (int, str, list)))  # True

issubclass(x,()) 返回'cls'是派生自另一个类还是同一个类
print(issubclass(int, int))  # True
print(issubclass(int, str))  # False
print(issubclass(int, object))  # True
print(issubclass(int, (str, int)))  # True

其他内置类型

模块

  • 模块上唯一的特殊操作是属性访问
  • 访问属性的方式：datetime.MINYEAR 或者 datetime.__dict__['MINYEAR']
  • 每个模块的一个特殊属性是 __dict__ . 这是包含模块符号表的字典。
  • module.__dict__ 显示模块的属性

类和类实例

  • 见 对象、值和类型 和 类定义 为了这些

功能

  • 函数对象由函数定义创建。对函数对象的唯一操作是调用它
  • 实际上有两种类型的函数对象：内置函数和用户定义函数。两者都支持相同的操作（调用函数），但实现不同。因此对象类型也不同。
  • 函数定义文档

方法

  • 方法是使用属性表示法调用的函数。有两种风格：内置方法（例如 append() 和类实例方法。使用支持它们的类型描述内置方法。

  • 如果通过实例访问方法（类命名空间中定义的函数，也是类实例方法），则会得到一个特殊的对象：a bound method （也称为 instance method 对象）

  • 点击查看代码 
    class C:
    def method(self):
        pass


# whoami 此属性在基础函数对象上面

# 给实例方法设置属性
c = C()
c.method.__func__.whoami = 'my name is method'
print(c.method.__func__.whoami)  # my name is method
# 给实例设置属性
c.name = '对象属性'
print(c.name)  # 对象属性
print(c.__dict__)  # {'name': '对象属性'}

# 创建新对象进行测试
d = C()
print(d.method.__func__.whoami)  # my name is method
print(d.name)  # 报错
print(d.__dict__)  # 空

  • 方法详细文档

代码对象

  • 代码对象被实现用来表示“伪编译”的可执行python代码，代码对象不包含对全局执行环境的引用

  • 代码对象的创建是使用内置 compile() 函数创建， excel() 有内置compile()方法，直接使用字符串也行

  • 创建的代码对象 交给excel() 或者 eval()执行

    点击查看代码 
    python_str = "print('你好！')"
exec(python_str)  # 你好！

python_str = """def get_sum(num1: int, num2: int) -> int:
    return num1 * num2
print(get_sum(7,3))  
"""
exec(python_str)   # 21

python_str = """def get_sum(num1: int, num2: int) -> int:
    return num1 * num2


while True:
    name = input('请输入名字:').strip()
    num1 = input('请输入num1:').strip()
    num2 = input('请输入num2:').strip()
    if not num1.isdigit() and not num1.isdigit():
        print('错误：请输入数字！')
    else:
        res = get_sum(int(num1), int(num2))
        print(f'成功：{name} 结果是{res}')"""
exec(python_str)   # 请输入名字:

# exec 与 eval 简单区别
print(eval('34+23'))  # 57
exec('a=123')  # None
print(a)  # 123
print(eval('a=123'))  # 报错 invalid syntax

类型对象

  • 类型对象表示各种对象类型。内置函数可以访问对象的类型 type() . 对类型没有特殊操作。标准模块 types 定义所有标准内置类型的名称。
  • 类型编写如下： <class 'int'> .
  • 类型对象 核心就是 内置方法:type()

空对象

  • python 空对象 就是None (内置名称)

省略号对象

  • ... 与 Ellipsis 都是python内置对象，...=Ellipsis
print(Ellipsis)  # Ellipsis
print(...)  # Ellipsis
print(type(Ellipsis))  # <class 'ellipsis'>

NotImplemented对象

  • NotImplemented 对象出现在，对不支持的类型进行操作时时候，
  • 比较和二进制操作返回此对象。

布尔值

  • False 和 True
  • 内置功能 bool() 可用于将任何值转换为布尔值

内部对象

  • 见 标准类型层次结构 关于这个信息。它描述堆栈帧对象、回溯对象和切片对象。
  • 目前不知道这个内部对象的意思

特殊属性

  • 实例
    • object.__dict__ # 用于存储对象（可写）属性的字典或其他映射对象。
    • instance.__class__ # 类实例所属的类。
  • 定义
    • definition.__name__ # 类、函数、方法、描述符或生成器实例的名称。
    • definition.__qualname__ #这个 qualified name 类、函数、方法、描述符或生成器实例的。
  • 类
    • class.__bases__ # 类对象的基类的元组。
    • class.__mro__ # 此属性是在方法解析期间查找基类时考虑的类的元组。 3.3 新版功能.
    • class.mro() # 此方法可以由元类重写，以自定义其实例的方法解析顺序。它在类实例化时调用，其结果存储在 __mro__ .
    • class.__subclasses__() # 每个类都保留对其直接子类的弱引用列表。此方法返回所有仍处于活动状态的引用的列表。该列表按定义顺序排列。示例：：
点击查看代码 

# 实例---------------------------------------------------------
class Person():
    name = '张三'
    age = '18'

    def __init__(self):
        self.phone = '110'
        self.address = '中国'


obj = Person()
# 对象的属性
print(Person.__dict__)  # 用于存储对象（可写）属性的字典或其他映射对象。
print(obj.__dict__)  # {'phone': '110', 'address': '中国'}  # 用来获取对象的 self.属性
# 对象的方法及其属性
print(dir(Person))
print(dir(obj))
# 对象所属类名
print(obj.__class__)
print('String'.__class__)


# 定义---------------------------------------------------------

class C:
    class D:
        def __init__(self):
            pass


# 类、函数、方法、描述符或生成器实例的名称。
print(C.__qualname__)  # C
print(C.D.__qualname__)  # C.D
print(C.D.__init__.__qualname__)  # C.D.__init__

# 类、函数、方法、描述符或生成器实例的名称
print(C.__name__)  # C


# 类---------------------------------------------------------
class A():
    pass


class B(A):
    pass


# 查找类对象 子类
print(A.__subclasses__())  # [<class '__main__.B'>] ## 显示该类的子类
# 查找类对象 父类
print(B.__bases__)  # 类对象的基类的元组
print(B.__mro__)  # [<class '__main__.B'>, <class '__main__.A'>, <class 'object'>] ## 显示类的父类 元祖形式
print(B.mro())  # [<class '__main__.B'>, <class '__main__.A'>, <class 'object'>] ## 显示类的父类 列表形式

引用文档地址

posted @ 2022-12-07 10:03  空白的时间  阅读(72)  评论(0)  编辑  收藏  举报