跳转至

数据类型的操作

可下标类型特有的操作

索引

索引,即下标,从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"
  • StrASCII码互转
# max()和min()就是据此返回可迭代对象中元素谁大谁小的
chr(77)  # M
ord("a") # 97
  • StrBytes互转
_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