数据类型的操作¶

可下标类型特有的操作¶

索引¶

索引，即下标，从0计起。

# 获取索引对应的元素
x[1]

# 获取元素对应的索引，如果有重复元素则返回第一个的索引
x.index(item)

切片¶

比循环更简洁

# 从头到尾，相当于浅拷贝
_sub[:]
_sub[x:]  # x~尾
_sub[:y]  # 头~y

# 从x到y，不包含y（前闭后开）
_sub[x:y]
_sub[x:y:n]  # 每隔n步取一次，比如取奇数：_sub[1::2]

反转¶

# 列表自带方法(原对象改变)
_list.reverse()

# 内置函数reversed()反转，反转后得到一个迭代器(原对象不变)
reversed(x)

# 切片方式反转(原对象不变)
x[::-1]

可迭代类型的操作¶

统计¶

# 序列自带方法，统计某元素出现的次数
_str.count("1")
_tuple.count(1)
_list.count(1)

# 统计iterable元素的个数
len(iterable)

# 统计iterable中值最大的
max(iterable)

# 统计iterable中值最小的
min(iterable)

遍历¶

list

for i in _list:
    print(i)

dict

# 遍历键值对
for k, v in _dict.items():
    print('key: {}, value: {}'.format(k, v))

# 遍历键
# for k in _dict.keys():
for k in _dict  # 可以不加.keys()，而且这样更高效
    print(k)

# 遍历值
for v in _dict.values():
    print(v)

在迭代字典时不能改变size大小，因为字典的索引是键的哈希表，改变之后将会变成新的对象，迭代器将抛出异常：dictionary changed size during iteration

Py3的解决方式

# 把字典转换为二元列表，然后循环列表来改变字典则不会报错了
for k,v in list(_dict.items()):
    pass

数据类型的转换¶

根据不同类型间做运算时会不会自动改变类型，可以分为：

弱类型：会，比如：JS
强类型：不会（报错），比如：Java、Python

强类型语言可以使用函数做类型转换

数值型之间互转

int(1.2)  # 1
int(False)  # 0

float(1)  # 1.0
float(True)  # 1.0

bool(0)  # False
bool(1.2)  # True

int(x)  # 转成十进制

bin(x)  # 转成二进制
oct(x)  # 转成八进制
hex(x)  # 转成十六进制

数值型与Str互转

int("123")  # 123
float("123")  # 123.0
bool("123")  # True

str(123)  # "123"
str(1.2)  # "1.2"
str(True)  # "True"

Str与ASCII码互转

# max()和min()就是据此返回可迭代对象中元素谁大谁小的
chr(77)  # M
ord("a") # 97

Str与Bytes互转

_str = "中文"
_bytes = b'\xe4\xb8\xad\xe6\x96\x87'

# 编码，str => bytes
_str.encode('utf-8')  # b'\xe4\xb8\xad\xe6\x96\x87'
# 或者
bytes(_str)  # 默认encoding='utf-8'，可以指定其它

# 解码，bytes => str
_bytes.decode()  # 默认解码格式：'utf-8'，可以指定其它

iterable 互转

# iterable如果是字典只取key
_tuple = tuple(iterable)  # ("a", "b", "c")
_list = list(iterable)  # ["a", "b", "c"]
_set = set(iterable)  # {"a", "b", "c"} 会自动去重
_set = frozenset(iterable)  # frozenset({"a", "b", "c"}) 不可重复且不可变

# 如果是'{"key": "value"}'这种字典，可以使用json.loads()反序列化
_dict = dict.fromkeys(iterable)  # {'a': None, 'b': None, 'c': None}
_dict = dict.fromkeys(iterable, 10)  # {'a': 10, 'b': 10, 'c': 10}

数据类型的拼接¶

# 拼接两个字符串
'a' + 'b'  # 'ab'
"+".join("abc")  # "a+b+c"
"".join(_list)  # 将一个列表中的每个元素拼接为一个字符串

# 拼接两个元组
(1,2) + (3,4)  # (1,2,3,4)

# 拼接两个列表
[1,2] + [3,4]  # [1,2,3,4]，生成一个新列表
[1,2].extend([3,4])  # 在原列表中增加

# 拼接两个集合
# 参数可以是任意 iterable，如果是字典只会把key拼接到集合中
_set.update(_iter)

# 拼接两个字典
# 参数只能是字典
_dic.update(_dict2)

_dict = {**dict1, **dict2}

数据类型的复制¶

对于字符串都是引用
对于元组，只有深拷贝才不是引用，否则都是引用

以下x为可变数据类型

引用¶

# id(y) == id(x)
# x赋值给y，y只是x的一个引用，会跟着x的改变而改变
y = x

浅拷贝¶

工厂函数.copy()

# id(y) != id(x)
# 只能拷贝父级元素，即改变x的父级元素，y的父级元素不会变
# 子级元素仍为引用，即改变x的子级元素，y的子级元素也会变
y = x.copy()

copy.copy()函数

import copy
y = copy.copy(x)

列表的切片操作也是浅拷贝：_list[:]

深拷贝¶

# id(y) != id(x)
# 父级与子级元素都会被拷贝，即改变x任意元素，都不会影响y的元素改变
import copy
y = copy.deepcopy(x)

列表¶

# 去除列表中空字符串、"\n"，以及元素两边的空格等
_list = ["aaa", "", "bbb", "\n", "  cc\n"]

[i.strip() for i in _list if i.strip() != ""]  # 完美实现 ['aaa', 'bbb', 'cc']

[i.strip() for i in _list_]  # 未去除空字符串 ['aaa', '', 'bbb', '', 'cc']
[i for i in _list_ if i.strip() != ""]  # 未去除字符两边的空格等 ['aaa', 'bbb', '  cc\n']

list(filter(None, _list))  # 只能去除空字符串 ['aaa', 'bbb', '\n', '  cc\n']
# 等同于：[x for x in _list if x]

最后更新: 2022-02-26