Python | 字典、列表、元组、集合、字符串

已于 2024-02-14 18:41:24 修改
阅读量2.2k 收藏 1
点赞数
分类专栏： Python 文章标签： python
于 2021-11-18 22:33:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MissMango0820/article/details/121408284
版权

本文总结对集合、列表、元组的一些基本操作知识 1’ 2，包括添加、删除、修改、类型转换，一些特定应用等。

Updated: 2024 / 02 / 14

Python | 集合、元组、列表的增添删改

字典

由于字典属于可变序列，所以我们可以任意操作字典中的键值对（key-value 对） 3。

Python 中，常见的字典操作有以下几种：

  1. 向现有字典中添加新的键值对。
  2. 修改现有字典中的键值对。
  3. 从现有字典中删除指定的键值对。
  4. 判断现有字典中是否存在指定的键值对。

初学者要牢记，字典中常常包含多个键值对，而 key 是字典的关键数据，字典的基本操作都是围绕 key 值实现的。随着 key 的增加越来越复杂，字典也需要占用较大的内存空间，换句话说，字典是以空间换速度。


单字典

参考 4, 以下面的示例来对下面的部分进行说明：

dict1 = {
    'A': 'Z',
    'B': 'Y',
    'C': 'X'
}

dict2 = {
    ('A', 'B'): 'Z',
    ('C', 'D'): 'Y',
    ('E', 'F'): 'X'
}

参考 5, 以下面的示例来对下面的部分进行说明：

dict3 = {
    'Name': 'Runoob',
    'num': {
        'first_num': '66',
        'second_num': '70'
            },
    'age': '15'
        }

dict4 = {
    'vakter': 'funnit',
    'rementre': "[{'name':'kelly', 'value':'', 'rownum':'NM'}, {}]"
}

选取

由键查值
get

参考这里 6


概念

get() 方法返回具有指定键的项目值。


用法

dict.get(keyname, value)

参数描述
keyname必需。您要从中返回值的项目的键名。
value可选。如果指定的键不存在，则返回一个值。默认值None。

get() 方法同 dict[key] 访问元素的区别在:

get(key) 方法在 key（键）不在字典中时，可以返回默认值 None 或者设置的默认值;

dict[key] 在 key（键）不在字典中时，会触发 KeyError 异常。


示例
  • 单纯字典
  1. 单键
dict1.get('A')
# Z

dict1.get('Z')
# None
  1. 多键值
dict2.get(('A', 'B'))
# Z

dict2.get(('C', 'X'))
# None
  • 嵌套字典
dict3.get('Name')
# Runoob

dict3.get('num').get('first_num')
# 66

dict3.get('num', {}).get('first_num')
# 66

dict3['num']['first_num']
# 66

dict4.get('rementre')
# [{'name':'kelly', 'value':'', 'rownum':'NM'}, {}]
# type, <class 'str'>

eval

参考这里 5。


概念

取出字符串得到最里层的字符串。


示例
  • 嵌套字典
eval(dict4['rementre'])
# [{'name': 'kelly', 'value': '', 'rownum': 'NM'}, {}]
# type, <class 'list'>

由值查键

由 key 查 value 可以调用 dict['key']，但如果此时我们想由 value 查 key，在字典中 key 值是唯一的切不可变但 value 可以随意取值且不唯一，可以利用以下方法 7：


index

充分利用 keys()、values() 和 index。


示例
key1 = list(dict1.keys())[list(dict1.values()).index('X')]
# C

key2 = list(dict2.keys())[list(dict2.values()).index('X')]
# ('E', 'F')

key3 = list(dict3.keys())[list(dict3.values()).index('Runoob')]
# Name

key4 = list(dict4.keys())[list(dict4.values()).index("[{'name':'kelly', 'value':'', 'rownum':'NM'}, {}]")]
# rementre

values = list(dict4.values())
# ['funnit', "[{'name':'kelly', 'value':'', 'rownum':'NM'}, {}]"]
key4 = list(dict4.keys())[list(dict4.values()).index("kelly")]
# Traceback (most recent call last):
#   File "DataAnalysis/test.py", line 49, in <module>
#     key4 = list(dict4.keys())[list(dict4.values()).index("kelly")]
# ValueError: 'kelly' is not in list

翻转字典

可以将原字典进行翻转得到新的字典，由原来的 K-V 存储形式，变成 V-K 存储形式。


示例
newdict1 = {v:k for k, v in dict1.items()}
# {'Z': 'A', 'Y': 'B', 'X': 'C'}
key1 = newdict1.get('X')
# C

newdict2 = {v:k for k, v in dict2.items()}
# {'Z': ('A', 'B'), 'Y': ('C', 'D'), 'X': ('E', 'F')}
key2 = newdict2.get('X')
# ('E', 'F')

newdict3 = {v:k for k, v in dict3.items()}
#  File "DataAnalysis/test.py", line 47, in <dictcomp>
#     newdict3 = {v:k for k, v in dict3.items()}
# TypeError: unhashable type: 'dict'

newdict4 = {v:k for k, v in dict4.items()}
# {'funnit': 'vakter', "[{'name':'kelly', 'value':'', 'rownum':'NM'}, {}]": 'rementre'}
key4 = newdict4.get('funnit')
# vakter
key4 = newdict4.get('rownum')
# None

删除

可以采用 pop, del, items() 等方法 8 删除字典的键值对。

pop
dict1.pop('B')
# {
#	'A': 'Z',
#	'C': 'X'
#	}

del

要删除字典中的键值对，还是可以使用 del 语句。

del dict1['C']
# {
#   'A': 'Z',
#   'B': 'Y'
# }

items()
newdict1 = {key:val for key, val in dict1.items() if key != 'A'}
# {
#   'B': 'Y',
#   'C': 'X'
#   }

添加

如果要为 dict 添加键值对，只需为不存在的 key 赋值即可。


赋值
示例
dict1['add'] = 'value'
# {
#   'A': 'Z',
#   'B': 'Y',
#   'C': 'X',
#   'add': 'value'
# }

修改

python 中字典是无序的，它们都是通过 hash 去对应的。
一般的如果我们需要修改字典的值，只需要直接覆盖即可。
而修改字典的键，则需要使用字典自带的 pop 函数。


值

“修改键值对” 并不是同时修改某一键值对的键和值，而只是修改某一键值对中的值。

由于在字典中，各元素的键必须是唯一的，因此，如果新添加元素的键与已存在元素的键相同，原来键所对应的值就会被新的值替换掉。

dict1['B'] = 'change'
# {
#   'A': 'Z',
#   'B': 'change',
#   'C': 'X'
# }

键
dict1['D'] = dict1.pop('C')
# {
#    'A': 'Z',
#    'B': 'Y',
#    'D': 'X'
# }

键-值对
update

参考这里 5


示例
dict1.update({'B': 'N'})
# {'A': 'Z', 'B': 'N', 'C': 'X'}

dict1.update({'X': 'Y'})
# {'A': 'Z', 'B': 'N', 'C': 'X', 'X': 'Y'}

dict1.update({('X', 'R'): 'Z'})
# {'A': 'Z', 'B': 'N', 'C': 'X', 'X': 'Y', ('X', 'R'): 'Z'}

dict2.update({('C', 'D'): 'Z'})
# {('A', 'B'): 'Z', ('C', 'D'): 'Z', ('E', 'F'): 'X'}

dict2.update({('R', 'T'): 'X'})
# {('A', 'B'): 'Z', ('C', 'D'): 'Z', ('E', 'F'): 'X', ('R', 'T'): 'X'}

dict2.update({'T': 'V'})
# {('A', 'B'): 'Z', ('C', 'D'): 'Z', ('E', 'F'): 'X', ('R', 'T'): 'X', 'T': 'V'}

dict3.update({'num': {'first_num': '', '': '70'}})
# {'Name': 'Runoob', 'num': {'first_num': '', '': '70'}, 'age': '15'}

dict3.update({'sex': 'female'})
# {'Name': 'Runoob', 'num': {'first_num': '', '': '70'}, 'age': '15', 'sex': 'female'}

dict4.update({'rementre': "whatever"})
# {'vakter': 'funnit', 'rementre': 'whatever'}

判断

如果要判断字典中是否存在指定键值对，首先应判断字典中是否有对应的键。判断字典是否包含指定键值对的键，可以使用 in 或 not in 运算符。

需要指出的是，对于 dict 而言，in 或 not in 运算符都是基于 key 来判断的。

通过 in（或 not in）运算符，我们可以很轻易地判断出现有字典中是否包含某个键，如果存在，由于通过键可以很轻易的获取对应的值，因此很容易就能判断出字典中是否有指定的键值对。

print('B' in dict1)
# True
print('E' in dict1)
# False

多字典

参考 9


合并

Chainmap
无重复键
from collections import ChainMap
# do not count duplicate keys

dicA = {'1':'A', '2': 'B', '3': 'C'}    # 3 keys
dicB = {'0':'X', '1': 'Y', '4': 'Z'}    # 3 keys but '1' was repeated
dicC = dict(ChainMap(dicA, dicB))       # 5 keys

# print(dicC)
# {'0': 'X', '1': 'A', '4': 'Z', '2': 'B', '3': 'C'}

重复键
dicA = {'1':'A', '2': 'B', '3': 'C'}     # 3 keys
dicB = {'4':'A', '5': 'B', '6': 'C'}     # 3 keys
dicC = dict(ChainMap(dicA, dicB))        # 6 keys

# print(dicC)
# {'4': 'A', '5': 'B', '6': 'C', '1': 'A', '2': 'B', '3': 'C'}

列表

单列表

单纯列表

删除

在列表中删除元素主要分为以下 3 种场景 10：

  1. 根据目标元素所在位置的索引进行删除，可以使用 del 关键字或者 pop() 方法；
  2. 根据元素本身的值进行删除，可使用列表提供的 remove() 方法；
  3. 将列表中所有元素全部删除，可使用列表提供的 clear() 方法。

remove

除了 del 关键字，Python 还提供了 remove() 方法，该方法会根据元素本身的值来进行删除操作，但是每次只能移除一个，按值删除。

需要注意的是，remove() 方法只会删除第一个和指定值相同的元素，而且必须保证该元素是存在的，否则会引发 ValueError 错误。

list = ['a', 'b', 'c', 'd']
# ['a', 'b', 'c', 'd']

list.remove('c')
# ['a', 'b', 'd']

list.remove('f')
# Traceback (most recent call last):
#   File "/Users/PycharmProjects/pythonProject/whatever.py", line 5, in <module>
#     list.remove('f')
# ValueError: list.remove(x): x not in list

pop

pop() 方法用来删除列表中指定索引处的元素，每次只能移除一个，具体格式如下：

listname.pop(index)
# listname 表示列表名称
# index 表示索引值。如果不写 index 参数，默认会删除列表中的最后一个元素，类似于数据结构中的“出栈”操作。

大部分编程语言都会提供和 pop() 相对应的方法，就是 push()，该方法用来将元素添加到列表的尾部，类似于数据结构中的“入栈”操作。但是 Python 是个例外，Python 并没有提供 push() 方法，因为完全可以使用 append() 来代替 push() 的功能。

比如，

list = ['a', 'b', 'c', 'd']
# ['a', 'b', 'c', 'd']

list.pop(3)                     # pop() + index of target elements
# ['a', 'b', 'c']

del

del 专门用来执行删除操作，它不仅可以删除整个列表，还可以删除列表中的某些元素。

del 可以删除列表中的单个元素，格式为：

del listname[index]
# listname 表示列表名称
# index 表示元素的索引值。

比如，

list = ['a', 'b', 'c', 'd']
# ['a', 'b', 'c', 'd']

del list[2]
# ['a', 'b', 'd']

del 也可以删除中间一段连续的元素，格式为：

del listname[start : end]
# start 表示起始索引
# end 表示结束索引。

del 会删除从索引 start 到 end 之间的元素，不包括 end 位置的元素。

注意：del是删除引用(变量)而不是删除对象(数据)，对象由自动垃圾回收机制（GC）删除。

del list[1:3]
# ['a', 'd']

clear

clear() 用来删除列表的所有元素，也即清空列表，使用方法如下：

list = ['a', 'b', 'c', 'd']

list.clear()
# []

类型转换
列表 >> 元组
list = ['a', 'b', 'c', 'd']
'''
<class 'list'>

['a', 'b', 'c', 'd']
'''

tuple = tuple(list)
'''
<class 'tuple'>

('a', 'b', 'c', 'd')
'''

列表 >> 字符串

命令 ''.join(list)，其中，引号中是字符之间的分割符，如 ,，;，\t 等等。

list = ['a', 'b', 'c', 'd']
# <class 'list'>
# ['a', 'b', 'c', 'd']

str1 = '.'.join(list)
# a.b.c.d

str2 = '/t'.join(list)
# a/tb/tc/td

str3 = ''.join(list)
# abcd

函数计算
def cal(i):
    return [i*4 + j for j in range(4)]

D = [1, 10, 31]

# 1. 4*i
d = [i*4 for i in D]
# [4, 40, 124]

# 2. 4*i+0, 4*i+1, 4*i+2, 4*i+3
d = [cal(i) for i in D]
# [[4, 5, 6, 7], [40, 41, 42, 43], [124, 125, 126, 127]]

排序

此处以下面的列表为例来说明如何对列表中的元素进行排序11。

lnum = [7, 4, 1, 11]
lstr = ['Emma', 'Selina', 'Mike', 'Anna']
ltuple = [
    ('Emma', 11),
    ('Mike', 1),
    ('Anna', 4),
    ('Selina', 7)
]

sorted

Python内置的全局 sorted() 方法来对可迭代的序列排序生成新的序列。
调用 sorted() 方法，它返回一个新的 list ，新的 list 的元素基于小于运算符(lt)来排序。
key 参数的值为一个函数，此函数只有一个参数且返回一个值用来进行比较。这个技术是快速的因为 key 指定的函数将准确地对每个元素调用。
更广泛的使用情况是用复杂对象的某些值来对复杂对象的序列排序。
接受一个参数 reverse（True or False）来表示升序或降序排序。


语法
sorted(list_name,reverse=...,key=...)
参数说明
sorted()是一个接受迭代的内置函数，然后它按升序或降序对其进行排序。sorted() 接受三个参数，一个参数是必需的，另外两个是可选的。
list_name是必需的参数。在这种情况下，参数是列表，但 sorted() 接受任何其他可迭代对象。
reverse, key还接受可选参数 reverse 和 key，这与 sort() 方法接受的可选参数相同。

sort() 和 sorted() 之间的主要区别在于 sorted() 函数接受一个列表并返回一个新的排序副本。

新副本按排序顺序包含原始列表的元素。原始列表中的元素不受影响，保持不变。


示例
sorted(lnum)
# ⬆️ [1, 4, 7, 11]
sorted(lnum, reverse=True)
# ⬆️ [11, 7, 4, 1]

sorted(lstr)
# ⬆️ ['Anna', 'Emma', 'Mike', 'Selina']
sorted(lstr, reverse=True)
# ⬆️ ['Selina', 'Mike', 'Emma', 'Anna']
  • lambda
sorted(ltuple, key=lambda all:all[0])
# ⬆️ [('Anna', 4), ('Emma', 11), ('Mike', 1), ('Selina', 7)]
sorted(ltuple, key=lambda all:all[0], reverse=True)
# ⬆️ [('Selina', 7), ('Mike', 1), ('Emma', 11), ('Anna', 4)]

sorted(ltuple, key=lambda all:all[1])
# ⬆️ [('Mike', 1), ('Anna', 4), ('Selina', 7), ('Emma', 11)]
sorted(ltuple, key=lambda all:all[1], reverse=True)
# ⬆️ [('Emma', 11), ('Selina', 7), ('Anna', 4), ('Mike', 1)]
  • itemgetter 12
sorted(ltuple, key=itemgetter(0))
# ⬆️ [('Anna', 4), ('Emma', 11), ('Mike', 1), ('Selina', 7)]
sorted(ltuple, key=itemgetter(0), reverse=True)
# ⬆️ [('Selina', 7), ('Mike', 1), ('Emma', 11), ('Anna', 4)]

sorted(ltuple, key=itemgetter(1))
# ⬆️ [('Mike', 1), ('Anna', 4), ('Selina', 7), ('Emma', 11)]
sorted(ltuple, key=itemgetter(1), reverse=True)
# ⬆️ [('Emma', 11), ('Selina', 7), ('Anna', 4), ('Mike', 1)]

sorted(ltuple, key=itemgetter(0, 1))
# ⬆️ [('Anna', 4), ('Emma', 11), ('Mike', 1), ('Selina', 7)]
sorted(ltuple, key=itemgetter(0, 1), reverse=True)
# ⬆️ [('Selina', 7), ('Mike', 1), ('Emma', 11), ('Anna', 4)]

sort

Python list内置 sort() 方法用来排序。
使用 list.sort() 方法来排序，此时 list 本身将被修改。通常此方法不如sorted() 方便，但是如果你不需要保留原来的 list ，此方法将更有效。
接受一个参数 reverse（True or False）来表示升序或降序排序。


语法

sort() 方法的一般语法如下所示：

list_name.sort(reverse=..., key=... )
参数说明
list_name是你正在使用的列表的名称。
sort()是 Python 的列表方法之一，用于对列表进行排序和更改。它按升序或降序对列表元素进行排序。接受两个可选参数。
reverse是第一个可选参数。它指定列表是按升序还是降序排序。它需要一个布尔值，这意味着该值为 True 或 False。默认值为 False，表示列表按升序排序。将其设置为 True 会按降序对列表进行降序排序。
key是第二个可选参数。它需要一个函数或方法，用于指定你可能有的任何详细排序标准。

sort() 方法返回 None，这意味着没有返回值，因为它只是修改了原始列表。它不会返回新列表。

默认情况下，sort() 按升序对列表项进行排序。升序（或升序）意味着项目从最低值到最高值排列。最低值在左侧，最高值在右侧。列表中包含的每个字符串都按字母顺序排序。


示例
lnum.sort()
# ⬆️ [1, 4, 7, 11]
lnum.sort(reverse=True)
# ⬆️ [11, 7, 4, 1]

lstr.sort()
# ⬆️ ['Anna', 'Emma', 'Mike', 'Selina']

natsort

参考这里 13

from natsort import natsorted

lstr_ordered = natsorted(lstr)
# ['Anna', 'Emma', 'Mike', 'Selina']

何时使用 sort() 和 sorted() ? 14

  • 考虑你正在使用的数据类型：
    如果你从一开始就严格使用列表，那么你将需要使用 sort() 方法，因为 sort() 仅在列表上调用。
    另一方面，如果你想要更大的灵活性并且还没有使用列表，那么你可以使用 sorted()。sorted() 函数接受并排序任何可迭代对象（如字典、元组和集合），而不仅仅是列表。
  • 其次，保留正在使用的列表的原始顺序是否重要：
    调用 sort() 时，原来的列表会被改变，原来的顺序会丢失。你将无法检索列表元素的原始位置。当你确定要更改你正在使用的列表并且确定你不想保留它的顺序时，请使用 sort()。
    另一方面，当你想创建一个新列表但仍想保留正在使用的列表时， sorted() 很有用。sorted() 函数将创建一个新的排序列表，其中列表元素按所需顺序排序。
  • 最后，在处理更大的数据集时可能需要考虑的另一件事是时间和内存效率：
    sort() 方法占用并消耗更少的内存，因为它只是对列表进行就地排序并且不会产生你不需要的新列表。出于同样的原因，它也稍微快一些，因为它不创建副本。当你使用包含更多元素的较大列表时，这会很有帮助。

倒序

参考这里 15


切片
lnum_rev = lnum[::-1]
# [11, 1, 4, 7]

lstr_rev = lstr[::-1]
# ['Anna', 'Mike', 'Selina', 'Emma']

ltuple_rev = ltuple[::-1]
# [('Selina', 7), ('Anna', 4), ('Mike', 1), ('Emma', 11)]

reverse
lnum.reverse()
# [11, 1, 4, 7]

lstr.reverse()
# ['Anna', 'Mike', 'Selina', 'Emma']

ltuple.reverse()
# [('Selina', 7), ('Anna', 4), ('Mike', 1), ('Emma', 11)]

频数
count

count() 方法用于统计某个元素在列表中出现的次数 16。
这里有一点要注意，区分大小写。


str.count(sub, start=0, end=len(string))
参数说明
string待检测的字符串，如 s='this is a new technology,and I want to learn this.'
可以为串可以为字母但是要用引号包裹如 str='this' 或 str='i'。
sub搜索的子字符串
start字符串开始搜索的位置。默认为第一个字符,第一个字符索引值为 0。
end字符串中结束搜索的位置。字符中第一个字符的索引为 0。默认为字符串的最后一个位置。

以下面的示例为例，

list = [123, 'xyz', 'zara', 'abc', 123]

list.count(123)
# 2

Counter

使用 Collections 模块中过的 Counter，可以统计给定列表中的元素及其各自出现的频数 17。

以下面的示例为例，

list = [123, 'xyz', 'zara', 'abc', 123]

count = Counter(list)
# Counter({123: 2, 'xyz': 1, 'zara': 1, 'abc': 1})

查询索引

参考这里 18


index

可以使用列表内建方法 index() 方法查询列表的索引，该方法接受一个表示要在现有列表中搜寻的值的引数。该函式将返回从索引 0 开始找到的第一次出现的索引，而不管它在列表中出现了多少次 19。

例如，宣告一个含有重复值 20 的列表，并呼叫方法 index(20) 并列印返回的內容。

lst = [13, 4, 20, 15, 6, 20, 20]

lst.index(20)
# 2

第一次出现的 20 值是在索引 2 上，这是函式呼叫的结果。具有相同值的其他元素将被忽略，因为它已在列表中找到匹配项。

如果给定列表中不存在某个值，而我们将传递不存在的值称为 index()，如下所示：

lst = [13, 4, 20, 15, 6, 20, 20]

lst.index(21)
# Traceback (most recent call last):
#   File "/Users/PycharmProjects/pythonProject0312/test.py", line 26, in <module>
#     print (lst.index(21))
# ValueError: 21 is not in list

如果在列表中找不到索引，则该函数将引发错误。在某些情况下，这可能不利于调用错误。为避免这种情况，请使用 try...except 捕获错误，并进行处理，以使如果列表中不存在索引，则将其分配为 -1。

lst = [13, 4, 20, 15, 6, 20, 20]

try:
  ndx = lst.index(21)
except:
  ndx = -1

这样，就不必调用显式错误，并且程序可以在操作后继续运行。

此外，如果尝试获得 list 中最大元素的索引，

a = [1, 2, 3, 4, 5]

print(max(a)) 			# 获取a列表中最大元素的值
# 5

print(a.index(max(a)))	# 获取a列表中最大元素的值的索引
# 4

enumerate
lst = [13, 4, 20, 15, 6, 20, 20]

print([i for i, x in enumerate(lst) if x == 20])
# [2, 5, 6]

enumerate 的输出类型是 tuple，可以将 list（当然，也包含其它类型）中的元素元组化，然后可以利用循环方法获取相应的匹配的结果。


bisect

bisect 是 python 内置模块，用于有序序列的插入和查找 20。

用法函数
查找bisect.bisect(array, item)
bisect.bisect_left(array, item)
和不带 left 的用法区别是：当查找的元素和序列中的某一个元素相同时，返回该元素的位置还是该元素之后的位置。
插入bisect.insort(array, item)
bisect.insort_left(array, item)
和不带 left 的用法区别是：当插入的元素和序列中的某一个元素相同时，该插入到该元素的前面（left） 还是后面（right）。

查找
import bisect

a = [1, 4, 6, 8, 12, 15, 20]

pos = bisect.bisect(a, 6)
# 3
num = a[pos]
# 8

pos_left = bisect.bisect_left(a, 6)
# 2
num_left=a[pos_left]
# 6

插入

使用 bisect.insort，会比使用 bisect 先查找该插入哪个位置、再使用insert 方法插入更快速。

a = [1, 4, 6, 8, 12, 15, 20]
bisect.insort(a, 9.3)
# [1, 4, 6, 8, 9.3, 12, 15, 20]

a = [1, 4, 6, 8, 12, 15, 20]
bisect.insort_left(a, 12)
# [1, 4, 6, 8, 12, 12, 15, 20]

分割

参考这里 21

以下面的列表为例进行说明：

l = [i for i in range(1, 61)]
# [1, 2, 3, 4, 5, ... 56, 57, 58, 59, 60]

固定步长
list
step = 10
l_fixstep = [l[i:i+step] for i in range(0, len(l), step)]
# [[1, 2, 3, 4, 5, 6, 7, 8, 9, 10], ..., [51, 52, 53, 54, 55, 56, 57, 58, 59, 60]]

以 10 为步长，每 10 个整数元素分割为一个二级列表。将总共 60 个整数元素分割为 6 个二级列表。


np.array_split
step = 6
npl = np.array(l)
npl_fixstep = np.array_split(npl, step)
# [array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10]), ..., array([51, 52, 53, 54, 55, 56, 57, 58, 59, 60])]
# type, <class 'list'>

以 6 为二级列表的总数要求，每 10 个整数元素分割为一个二级列表。将总共 60 个整数元素分割为 6 个二级列表。


非固定步长
list
step = [3, 6, 9, 12, 15, 19, 22, 25, 28]
s = 0
e = step[0]
l_randomstep = []
for i in step[1:]:
    l_randomstep.append(l[s:e])
    s, e = e, e+i
    if s > len(l):
        break
# [[1, 2, 3], [4, 5, 6, 7, 8, 9], [10, 11, 12, 13, 14, 15, 16, 17, 18], ..., [31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 
# 41, 42, 43, 44, 45], [46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60]]

去重

参考这里 22

以下面的列表为例对去重的方法进行说明，

l = ['b','c','d','b','c','a','a']

不考虑顺序

祛除重复元素后排序可能会发生变化：

new = list(set(l))
# ['c', 'a', 'd', 'b']

new = {}.fromkeys(l).keys()
# dict_keys(['b', 'c', 'd', 'a'])

考虑顺序
new = sorted(set(l), key=l.index)
# ['b', 'c', 'd', 'a']

嵌套列表

以下面的嵌套列表为例对相应子章节的内容进行说明：

A = [[13, 17, 18, 21], [7, 11, 13, 14]]

降维

参考这里 23’ 24


for 循环
plain_list = [j for i in A for j in i]
# [13, 17, 18, 21, 7, 11, 13, 14]
# <class 'list'>

上式等价于以下脚本：

plain_list = []               
for i in A:             	  	# 对于A中的i (是可迭代的)
    for j in i:               	# 对于i中的j (是可迭代的)
        plain_list.append(j)  	# 向plain_list添加j

相当于将嵌套列表展平为一维列表。


sum

将 list 列表与一个空列表相加，就能把嵌套列表合并成一个

plain_list = sum(A, [])
# [13, 17, 18, 21, 7, 11, 13, 14]

itertools

itertools.chain() 与 itertools.chain.from_iterable() 函数都可以拼接可迭代对象中的所有元素，将元素串联后创建一个新的迭代器。区别是前者可用于拼接多个嵌套列表，后者拼接单个嵌套列表，示例如下。

使用 itertools.chain()：

import itertools

merge = itertools.chain(A[0], A[1])
# type, <class 'itertools.chain'>
result = list(merge)
# [13, 17, 18, 21, 7, 11, 13, 14]

a='abc'
b='def'
merge = itertools.chain(a, b)
# type, <class 'itertools.chain'>
result = list(merge)
# ['a', 'b', 'c', 'd', 'e', 'f']


import itertools

merge = itertools.chain.from_iterable(A)
# type, <class 'itertools.chain'>
result = list(merge)
# [13, 17, 18, 21, 7, 11, 13, 14]

迭代判断条件

遍历 list 内的每一个元素，如果该元素不是列表或元组就加到生成器里，如果是可迭代对象就继续递归调用，直到把所有子列表都打散，最终返回一个大列表。

def flat(l):
    for k in l:
        if not isinstance(k, (list, tuple)):
            yield k
        else:
            yield from flat(k)
plain_list = list(flat(A))
# [13, 17, 18, 21, 7, 11, 13, 14]

对于 isinstance 检测 NoneType，可参考这里 25。


去重

参考这里 26

import numpy as np
plain_list = [j for i in A for j in i]
res = np.unique(plain_list)
# [ 7 11 13 14 17 18 21]       
# <class 'numpy.ndarray'>

相当于将嵌套列表展平为一维列表，再在一维列表中寻找不可重复值。


多列表

在这里插入图片描述

单纯列表

关于单纯列表部分，以下面2个列表为例:

A = ['x', '7', 10, 'z', '6', 5]
B = ['x', '5', 10, 'x', '6', 8]
C = [('A', 'B', 'C'), ('D', 'E', 'F'), ('G', 'H', 'I')]
OR
res = list(set(A).union(set(B)))
# ['6', 5, 8, 10, '5', '7', 'z', 'x']

AND
1.
res = [i for i in A if i in B]
# ['x', 10, '6']
2.
res = list(set(A) & set(B))
# ['6', 10, 'x']
3.
res = list(set(B).intersection(A))
# [10, 'x', '6']
4.
from collections import Counter
res = list((Counter(A) & Counter(B)).elements())
# ['x', 10, '6']

XOR
  • A & B
res = list(set(A) ^ set(B))
# ['5', '7', 5, 'z', 8]
  • A
res = [i for i in A if i not in B]
# ['7', 'z', 5]
res = list(set(A).difference(set(B)))
# ['7', 'z', 5]
  • B
res = [i for i in B if i not in A]
# ['5', 8]
res = list(set(B).difference(set(A)))
# ['5', 8]

合并

合并列表是非常常见的操作，这里提供6种方法实现列表的拼接 27：

  • 通过 + 运算直接拼接
  • 通过循环调用 list.append() 进行拼接
  • 通过列表表达式拼接
  • 通过 * 解构方式实现拼接
  • 通过内置的 extend 方法实现拼接
  • 通过 itertools.chain() 实现拼接

以上六种方法各有优劣。

从效率角度看，直接使用操作符 + 和 * 的方式效率最好，但此种方式不适合做大数据处理。如果需要做一定列表元素处理，然后再合并，可以采用 2、3 两种方式。
如果数据量很大，都存在外部存储器或数据库里，采用 6 的方式更加合适。
如果需要修改原始列表，则可以使用 5 中的 extend 方式。


+ 运算
comb = A + B + C
# ['x', '7', 10, 'z', '6', 5, 'x', '5', 10, 'x', '6', 8, ('A', 'B', 'C'), ('D', 'E', 'F'), ('G', 'H', 'I')]

list.append()
comb = []
for element in A:
    comb.append(element)
for element in B:
    comb.append(element)
for element in C:
    comb.append(element)
print(comb)
# ['x', '7', 10, 'z', '6', 5, 'x', '5', 10, 'x', '6', 8, ('A', 'B', 'C'), ('D', 'E', 'F'), ('G', 'H', 'I')]

for loop
comb = [element for l in [A, B, C] for element in l]
# ['x', '7', 10, 'z', '6', 5, 'x', '5', 10, 'x', '6', 8, ('A', 'B', 'C'), ('D', 'E', 'F'), ('G', 'H', 'I')]

*
comb1 = [*A, *B, *C]
# ['x', '7', 10, 'z', '6', 5, 'x', '5', 10, 'x', '6', 8, ('A', 'B', 'C'), ('D', 'E', 'F'), ('G', 'H', 'I')]

comb2 = [*C, *C]
# [('A', 'B', 'C'), ('D', 'E', 'F'), ('G', 'H', 'I'), ('A', 'B', 'C'), ('D', 'E', 'F'), ('G', 'H', 'I')]

extend
comb = []
comb.extend(A)
comb.extend(B)
comb.extend(C)
print(comb)
# ['x', '7', 10, 'z', '6', 5, 'x', '5', 10, 'x', '6', 8, ('A', 'B', 'C'), ('D', 'E', 'F'), ('G', 'H', 'I')]

itertools.chain
import itertools

comb = list(itertools.chain(A, B, C))
print(comb)
# ['x', '7', 10, 'z', '6', 5, 'x', '5', 10, 'x', '6', 8, ('A', 'B', 'C'), ('D', 'E', 'F'), ('G', 'H', 'I')]

排序

一个列表中的元素参考另外一个列表中的元素进行顺序排序 28’ 29。
以下面的几个列表为例，对排序方法进行说明，

A = ['早餐', '上午茶', '中餐', '下午茶', '晚餐', '夜宵']
B = ['晚餐', '上午茶', '中餐', '夜宵']
C = ['早餐', '上午茶', '烧烤', '甜点', '晚餐', '夜宵', '下午茶', '中餐']
D = ['晚餐', '披萨', '中餐', '夜宵']
E = [3,   1,   2,    0,   1,   2,   2,   0,   1]

sorted

以下的几个示例均采用 sorted 来对列表中的元素进行排序。唯一不同的是记录一个列表中的元素出现在另外一个列表中的索引顺序的方法。


index
if set(B).issubset(set(A)):
    B_reorder = sorted(B, key=A.index
# ['上午茶', '中餐', '晚餐', '夜宵']

如果列表 B 属于列表 A 的子集，将列表 B 中的元素根据其出现在列表 A 中的顺序进行重新排序。

又或者，

if set(B).issubset(set(C)):
    B_reorder = sorted(B, key=C.index)
# ['上午茶', '晚餐', '夜宵', '中餐']

如果列表 B 属于列表 C 的子集，将列表 B 中的元素根据其出现在列表 C 中的顺序进行重新排序。


itertools.count
from itertools import count

index_dict = dict(zip(A, count()))
B_ordered = sorted(B, key=lambda x: index_dict[x])
# ['上午茶', '中餐', '晚餐', '夜宵']

将列表 B 中的元素根据其出现在列表 A 中的顺序进行重新排序。

又或者，

from itertools import count

index_dict = dict(zip(C, count()))
B_ordered = sorted(B, key=lambda x: index_dict[x])
# ['上午茶', '晚餐', '夜宵', '中餐']

将列表 B 中的元素根据其出现在列表 C 中的顺序进行重新排序。

又或者，

from itertools import count

index_dict = dict(zip(C, count()))
D_ordered = sorted(D, key=lambda x: index_dict[x])
# Traceback (most recent call last):
#   File "/Users/xueshanzhang/PycharmProjects/tkinterEXAMPLE/test.py", line 311, in <module>
#     D_ordered = sorted(D, key=lambda x: index_dict[x])
#   File "/Users/xueshanzhang/PycharmProjects/tkinterEXAMPLE/test.py", line 311, in <lambda>
#     D_ordered = sorted(D, key=lambda x: index_dict[x])
# KeyError: '披萨'

将列表 D 中的元素根据其出现在列表 C 中的顺序进行重新排序，但是由于列表 D 中存在并不在 C 中的元素，所以报错。因此需要改进一下方法，

index_dict = dict(zip(C, range(len(C))))
D_ordered = sorted(D, key=lambda elem: index_dict.get(elem, len(C) + D.index(elem)))
# ['晚餐', '夜宵', '中餐', '披萨']

enumerate
index_dict = {k: i for i, k in enumerate(A)}
B_ordered = sorted(B, key=lambda x: index_dict[x])
# ['上午茶', '中餐', '晚餐', '夜宵']

将列表 B 中的元素根据其出现在列表 A 中的顺序进行重新排序。


index_dict = {k: i for i, k in enumerate(D)}
B_ordered = sorted(B, key=lambda x: index_dict[x])
# Traceback (most recent call last):
#   File "/Users/xueshanzhang/PycharmProjects/tkinterEXAMPLE/test.py", line 313, in <module>
#     B_ordered = sorted(B, key=lambda x: index_dict[x])
#   File "/Users/xueshanzhang/PycharmProjects/tkinterEXAMPLE/test.py", line 313, in <lambda>
#     B_ordered = sorted(B, key=lambda x: index_dict[x])
# KeyError: '上午茶'

将列表 D 中的元素根据其出现在列表 C 中的顺序进行重新排序，但是由于列表 D 中存在并不在 C 中的元素，所以报错。


zip
B_ordered = [i for _, i in sorted(zip(E, B))]
# ['夜宵', '上午茶', '中餐', '晚餐']

C_ordered = [i for _, i in sorted(zip(E, C))]
# ['中餐', '甜点', '上午茶', '晚餐', '下午茶', '夜宵', '烧烤', '早餐']

D_ordered = [i for _, i in sorted(zip(E, D))]
# ['夜宵', '披萨', '中餐', '晚餐']

列表 E 中的数字作为索引顺序列表，指导其他列表中的元素的排序。
需要注意地是，一旦列表 E 中出现重复的索引，可能会导致非预期的排序。

当然了，还有其他的方法。详情参考这里


嵌套列表

AND
1.

可以使用filter(set(c1).__contains__, sublist)来提高效率。其优点是filter()保留字符串和元组类型。

  • 1.
A = [1, 3, 4, 5, 8, 13]
B = [[1, 17, 10, 21], [7, 11, 13, 14], [1, 5, 6, 8], [5, 4, 1, 8]]

res = [list(filter(lambda x: x in A, b)) for b in B]
# [[1], [13], [1, 5, 8], [5, 4, 1, 8]]
  • 2.
A = [[13, 17, 18, 21], [7, 11, 13, 14], [1, 5, 6, 8], [5, 10, 2, 8]]
B = [[1, 17, 10, 21], [7, 11, 13, 14], [1, 5, 6, 8], [5, 4, 1, 8]]

res = [list(filter(lambda x: x in A, B))]
# [[[7, 11, 13, 14], [1, 5, 6, 8]]]
XOR

关于XOR部分，以下面2个列表为例:

A = [(13, 17, 18, 21), (7, 11, 13, 14), (1, 5, 6, 8), (5, 10, 2, 8)]
B = [(1, 17, 10, 21), (7, 11, 13, 14), (1, 5, 6, 8), (5, 4, 1, 8)]
  • A & B
res = list(set(A) ^ set(B))
# [(5, 4, 1, 8), (5, 10, 2, 8), (1, 17, 10, 21), (13, 17, 18, 21)]
  • A
res = list(set(A).difference(set(B)))
# [(5, 10, 2, 8), (13, 17, 18, 21)]

元组

集合

此处可参考 30

先以下面的集合为例，对集合的相关用法进行说明：

A = ['早餐', '上午茶', '中餐', '下午茶', '晚餐', '夜宵']
B = ['晚餐', '上午茶', '中餐', '夜宵']
C = ['早餐', '上午茶', '烧烤', '甜点', '晚餐', '夜宵', '下午茶', '中餐']

子集

可以使用 setA.issubset(setB) 来判断集合 setA 是否为 setB 的子集 31。

flag = set(B).issubset(set(A))
# True
# 集合B为集合A的子集

flag = set(B).issubset(set(C))
# True
# 集合B为集合C的子集

flag = set(C).issubset(set(B))
# False
# 集合C不是集合B的子集

字符串

以下面的字符串 str1, str2 和 str3 为例来对相关的字符串的方法进行使用说明 32：

str1 = ''''''
str2 = ' Hongkong_x000D_   Shanghai_x000D_   Beijing_x000D_   Hangzhou_x000D_   Nanjing_x000D_   Dalian_x000D_ Xinjiang'
str3 = 'This is a test string from Andrew.'
str4 = 'ab c\n\nde fg\rkl\r\n'
str5 = ('a', 'b', 'c')
str6 = ['d', 'e', 'f']

方法

内建函数

方法描述
string.capitalize()把字符串的第一个字符大写
string.center(width)返回一个原字符串居中,并使用空格填充至长度 width 的新字符串
string.count(str, beg=0, end=len(string))返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
string.decode(encoding='UTF-8', errors='strict')以 encoding 指定的编码格式解码 string，如果出错默认报一个 ValueError 的异常，除非 errors 指定的是 ignore 或者 replace
string.encode(encoding='UTF-8', errors='strict')以 encoding 指定的编码格式编码 string，如果出错默认报一个 ValueError 的异常，除非 errors 指定的是 ignore 或者 replace
string.endswith(obj, beg=0, end=len(string))检查字符串是否以 obj 结束，如果 beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True, 否则返回 False。
string.expandtabs(tabsize=8)把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8。
string.find(str, beg=0, end=len(string))检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回 -1
string.format()格式化字符串
string.index(str, beg=0, end=len(string))跟 find() 方法一样，只不过如果 str 不在 string 中会报一个异常。
string.isalnum()如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True, 否则返回 False
string.isalpha()如果 string 至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False
string.isdecimal()如果 string 只包含十进制数字则返回 True 否则返回 False。
string.isdigit()如果 string 只包含数字则返回 True 否则返回 False。
string.islower()如果 string 中包含至少一个区分大小写的字符，并且所有这些 (区分大小写的) 字符都是小写，则返回 True，否则返回 False
string.isnumeric()如果 string 中只包含数字字符，则返回 True，否则返回 False
string.isspace()如果 string 中只包含空格，则返回 True，否则返回 False。
string.istitle()如果 string 是标题化的 (见 title()) 则返回 True，否则返回 False
string.isupper()如果 string 中包含至少一个区分大小写的字符，并且所有这些 (区分大小写的) 字符都是大写，则返回 True，否则返回 False。
string.join(seq)以 string 作为分隔符，将 seq 中所有的元素 (的字符串表示) 合并为一个新的字符串
string.ljust(width)返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串
string.lower()转换 string 中所有大写字符为小写。
string.lstrip()截掉 string 左边的空格
string.maketrans(intab, outtab)maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
max(str)返回字符串 str 中最大的字母。
min(str)返回字符串 str 中最小的字母。
string.partition(str)有点像 find() 和 split() 的结合体,从 str 出现的第一个位置起, 把字符 串 string 分成一个 3 元素的元组 (string_pre_str, str,string_post_str), 如果 string 中不包含str 则 string_pre_str == string。
string.replace(str1, str2, num=string.count(str1))把 string 中的 str1 替换成 str2, 如果 num 指定，则替换不超过 num 次。
string.rfind(str, beg=0,end=len(string) )类似于 find() 函数，返回字符串最后一次出现的位置，如果没有匹配项则返回 -1。
string.rindex( str, beg=0,end=len(string))类似于 index()，不过是返回最后一个匹配到的子字符串的索引号。
string.rjust(width)返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串
string.rpartition(str)类似于 partition() 函数,不过是从右边开始查找
string.rstrip()删除 string 字符串末尾的空格。
string.split(str="", num=string.count(str))以 str 为分隔符切片 string，如果 num 有指定值，则仅分隔 num+1 个子字符串
string.splitlines([keepends])按照行 ('\r', '\r\n', '\n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
string.startswith(obj, beg=0,end=len(string))检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果 beg 和 end 指定值，则在指定范围内检查。
string.strip([obj])在 string 上执行 lstrip() 和 rstrip()
string.swapcase()翻转 string 中的大小写
string.title()返回"标题化"的 string ,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())
string.translate(str, del="")根据 str 给出的表(包含 256 个字符) 转换 string 的字符, 要过滤掉的字符放到 del 参数中
string.upper()转换 string 中的小写字母为大写
string.zfill(width)返回长度为 width 的字符串，原字符串 string 右对齐，前面填充 0

添加

  • str += newstr
str1 += "1.0 \t x \n"
str1 += "2.0 \t y \n"
'''
1.0 	 x 
2.0 	 y 
'''

替换

  • str.replace(old, new)
    将字符串中指定的字符串⽤其它字符串进⾏替换
    Return a copy of the string with leading and trailing whitespace removed
str2.replace("#", " ")
'''
 Hongkong_x000D_   Shanghai_x000D_   Beijing_x000D_   Hangzhou_x000D_   Nanjing_x000D_   Dalian_x000D_ Xinjiang
'''

去空格

参考这里 33


首尾

概念

可用于去除字符串开头或者结尾的空格


方法
  • str.strip()

示例
str2.strip()
# Hongkong_x000D_   Shanghai_x000D_   Beijing_x000D_   Hangzhou_x000D_   Nanjing_x000D_   Dalian_x000D_ Xinjiang

首 / 尾

概念

去除字符串开头 / 结尾的空格。


方法
  • str.lstrip()
  • str.rstrip()

示例
str2.lstrip()
# Hongkong_x000D_   Shanghai_x000D_   Beijing_x000D_   Hangzhou_x000D_   Nanjing_x000D_   Dalian_x000D_ Xinjiang

str2.rstrip()
#  Hongkong_x000D_   Shanghai_x000D_   Beijing_x000D_   Hangzhou_x000D_   Nanjing_x000D_   Dalian_x000D_ Xinjiang

全部

概念

可以去除全部空格


方法
  • str.replace(old, new, count)
  • "".join(str.split())

示例
str2.replace(' ', '')
# Hongkong_x000D_Shanghai_x000D_Beijing_x000D_Hangzhou_x000D_Nanjing_x000D_Dalian_x000D_Xinjiang

"".join(str2.split(" "))
# Hongkong_x000D_Shanghai_x000D_Beijing_x000D_Hangzhou_x000D_Nanjing_x000D_Dalian_x000D_Xinjiang

计算

频率

  • str.count()
    返回字符串在⽬标字符串中出现的次数
str2.count('_x000D_')
'''
6
'''

正则表达式

此处可参考 34’ 35’ 34’ 36

配合 re 使用的常用的特殊字符如下：

字符说明
\Used to drop the special meaning of character，following it (discussed below)
[]Represent a character class
^匹配字符串的开始。
$匹配字符串的结尾。
.通常意味着 匹配任意单字符
x?匹配一个可选的 x 字符 (换言之，它匹配 1 次或者 0 次 x 字符)。
｜Means OR (Matches with any of the characters separated by it.
x*匹配 0 次或者多次 x 字符。
x+匹配1次或者多次 x 字符。
{}Indicate number of occurrences of a preceding RE to match.
()Enclose a group of REs
\b匹配一个单词的边界。
\d匹配任意数字。
\D匹配任意非数字字符。
x{n,m}匹配 x 字符，至少 n 次，至多 m 次。
(a / b / c)要么匹配 a，要么匹配 b，要么匹配 c。
(x)一般情况下表示一个记忆组 ( remembered group)。你可以利用 re.search 函数返回对象的 groups() 函数获取它的值。

方法

方法说明
re.sub
re.search

示例

re.sub
re.sub(r"_x000D_", "\n", str2)
'''
#Hongkong
 # Shanghai
 # Beijing
 # Hangzhou
 # Nanjing
 # Dalian
 Xinjiang
'''

re.search
import re 
    
# Lets use a regular expression to match a date string 
# in the form of Month name followed by day number 
regex = r"([a-zA-Z]+) (\d+)"
    
match = re.search(regex, "I was born on June 24") 
    
if match != None: 
    
    # We reach here when the expression "([a-zA-Z]+) (\d+)" 
    # matches the date string. 
    
    # This will print [14, 21), since it matches at index 14 
    # and ends at 21.  
    print("Match at index % s, % s" % (match.start(), match.end()))
    
    # We us group() method to get all the matches and 
    # captured groups. The groups contain the matched values. 
    # In particular: 
    # match.group(0) always returns the fully matched string 
    # match.group(1) match.group(2), ... return the capture 
    # groups in order from left to right in the input string 
    # match.group() is equivalent to match.group(0) 
    
    # So this will print "June 24" 
    print("Full match: % s" % (match.group(0)))
    
    # So this will print "June" 
    print("Month: % s" % (match.group(1)))
    
    # So this will print "24" 
    print("Day: % s" % (match.group(2)))
    
else: 
    print("The regex pattern does not match.")

re.findall
数字

若要检索数字，数字的形式一般是：整数，小数，整数加小数；
所以一般是形如 ----.----- ；
根据上述正则表达式的含义，可写出如下的表达式 \d+\.?\d*；

  • \d+ 匹配 1 次或者多次数字，注意这里不要写成 *，因为即便是小数，小数点之前也得有一个数字；
  • \.? 这个是匹配小数点的，可能有，也可能没有；
  • \d* 这个是匹配小数点之后的数字的，所以是 0 个或者多个；
# A sample text string where regular expression  
# is searched. 
string = """Hello my Number is 123456789 and 
             my friend's number is 987654321"""
    
# A sample regular expression to find digits. 
regex = '\d+'             
    
match = re.findall(regex, string) 
# ['123456789', '987654321']

re.complier
数字
string = 'tensorflow:Final best valid 0 loss=0.20478513836860657 norm_loss=0.767241849151384 roc=0.8262403011322021 ' \
      'pr=0.39401692152023315 calibration=0.9863265752792358 rate=0.0'

pattern = re.compile(r'(?<=calibration=)\d+\.?\d*')
print(pattern.findall(string))
# ['0.9863265752792358']

pattern = re.compile(r'(?<=norm_loss=)\d+\.?\d*')
print(pattern.findall(string))
# ['0.767241849151384']

pattern = re.compile(r'(?:loss=)\d+\.?\d*')
print(pattern.findall(string))
# ['loss=0.20478513836860657', 'loss=0.767241849151384']

时间
string = "WARNING:tensorflow: 20181011 15:28:39 Initialize training"
pattern = re.compile(r'\d{4}\d{2}\d{2}\s\d{2}:\d{2}:\d{2}')
pattern.findall(string)
# ['20181011 15:28:39']

排序

参考11

sorted

list.sort() 和 list.sorted() 函数增加了 key 参数来指定一个函数，此函数将在每个元素比较前被调用。 例如通过 key 指定的函数来忽略字符串的大小写, key参数的值为一个函数，此函数只有一个参数且返回一个值用来进行比较。这个技术是快速的因为 key 指定的函数将准确地对每个元素调用。
接受一个参数 reverse（ True or False ）来表示升序或降序排序。

sorted(str3.split(), key=str.lower)
# ⬆️ ['a', 'Andrew', 'from', 'is', 'string', 'test', 'This']

sorted(str3.split(), key=str.lower, reverse=True)
# ⬆️ ['This', 'test', 'string', 'is', 'from', 'Andrew', 'a']

大小写转换

以下代码演示了如何将字符串转换为大写字母，或者将字符串转为小写字母等 37：

小写字母转换大写字母

  • str.upper()
str3.upper()
# THIS IS A TEST STRING FROM ANDREW.

大写字母转换成小写字母

  • str.lower()
str3.lower()
# this is a test string from andrew.

首字母大写，其余小写

  • str.capitalize()
str3.capitalize()
# This is a test string from andrew.
  • str.title()
str3.title()
# This Is A Test String From Andrew.

查找

  • str.find(str, beg=0, end=len(string))
    find() 方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，如果包含子字符串返回开始的索引值，否则返回 -1。32’ 38
  • str – 指定检索的字符串
  • beg – 开始索引，默认为0。
  • end – 结束索引，默认为字符串的长度。
str3.find('a')
# 8

str3.find('is')
# 2

str3.find('i')
# 2

检查

检查字符串是否是有效标识符, 可以使用 isidentifier() 方法 39。

  • str.identifier()
    如果字符串是有效标识符，则 isidentifier() 方法返回 True，否则返回 False。
    如果字符串仅包含字母数字字母 a-z 和 0-9 或下划线 _，则该字符串被视为有效标识符。有效的标识符不能以数字开头或包含任何空格。
a = "MyFolder"
b = "Demo002"
c = "2bring"
d = "my demo"

a.isidentifier()
# True
b.isidentifier()
# True
c.isidentifier()
# False
d.isidentifier()
# False

类型转变

参考这里 40


字符串 >> 字节
  • bytes(str, encoding)
bytes(str3, encoding='utf-8')
# b'This is a test string from Andrew.'
# type, <class 'bytes'>
# from string to bytes
  • bytes.decode(str)
bytes.decode(b)
# example
# type, <class 'str'>

字符串 >> 列表

list 是列表，其特点是不定长，所以可以 list.append 随时增加，也可以 insert 插入。

str = 'abcde'

list(str)
# ['a', 'b', 'c', 'd', 'e']

str = "Hello.I am qiwsir.Welcome you."

str.split(".")   #以英文的句点为分隔符，得到list
# ['Hello', 'I am qiwsir', 'Welcome you', '']
 
str.split(".",1) 
# 这个1,就是表达了上文中的：If maxsplit is given, at most maxsplit splits are done.
# ['Hello', 'I am qiwsir.Welcome you.']    

arr = ['22','44','66','88']
 
arr = list(map(int,arr))
# [22, 44, 66, 88]

前缀

参考这里 41

  • str.startswith(str, beg=0,end=len(string))
str3.startswith('this')
# False

str3.startswith('is', 2, 4)
# True

str3.startswith('this', 2, 4)
# False

分割

分行

参考这里 42


概念

splitlines() 按照行('\r', '\r\n', '\n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。


用法
  • str.splitlines([keepends])
    keepends，在输出结果里是否保留换行符('\r', '\r\n', '\n')，默认为 False，不包含换行符，如果为 True，则保留换行符。
    返回一个包含各行作为元素的列表。

示例
str4.splitlines()
# ['ab c', '', 'de fg', 'kl']

str4.splitlines(True)
# ['ab c\n', '\n', 'de fg\r', 'kl\r\n']

指定分隔符

参考这里 43


概念

split() 通过指定分隔符对字符串进行切片，如果第二个参数 num 有指定值，则分割为 num+1 个子字符串。


用法
  • str.split(str="", num=string.count(str))
    str，分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。
    num，分割次数。默认为 -1, 即分隔所有。
    返回分割后的字符串列表。

示例
str2.split(sep='_x000D_')
# [' Hongkong', '   Shanghai', '   Beijing', '   Hangzhou', '   Nanjing', '   Dalian', ' Xinjiang']

str3.split(sep=' ')
# ['This', 'is', 'a', 'test', 'string', 'from', 'Andrew.']

连接

  • str.join(sequence)
    sequence，要连接的元素序列。
    返回通过指定字符连接序列中元素后生成的新字符串。
    序列中的元素应当为字符串，否则会报错。
sep = '-'

str5 = ('a', 'b', 'c')
print(sep.join(str5))
# a-b-c

str6 = ['d', 'e', 'f']
print(sep.join(str6))
# d-e-f

dict = {'hello':'nihao','good':2,'boy':3,'doiido':4}
print(sep.join(dict))
# hello-good-boy-doiido

示例

参考这里 44

  1. 实际应用开发时，获取应用的所有进程 ID，然后杀掉所有进程，可以使用 join 拼接出 kill 命令。
'kill %s' % ' '.join(['111','22'])
# 'kill 111 22'

subprocess.run('kill  %s' % ' '.join(pids), shell=True)
# 可以杀掉进程 111 和 22
  1. 待连接的序列中的元素应当是字符串，而非其他类型。
print(''.join([1,2,3,4]))
# Traceback (most recent call last):
#   File "script.py", line 5, in <module>
#    print(''.join([1,2,3,4]))
# TypeError: sequence item 0: expected str instance, int found
#
# Process finished with exit code 1

print(''.join(['1', '2', '3', '4']))
# 1234
  1. 实例扩展，将给定的字符串倒序后输出（虽然 python 自带方法可以搞定），.join 方法的确是程序中字符串与列表相互转换的很好用的工具。

str3 = 'This is a test string from Andrew.'
len1 = len(str3) - 1
str_list = []
while(len1 >= 0):
    str_list.append(str3[len1])
    len1 = len1 - 1
print(''.join(str_list))
# .werdnA morf gnirts tset a si sihT

字节

以以下字节为例，对下面的方法进行说明：

b = b'example'

类型转变

参考这里 40

  • str(byte, encoding)
str(b, encoding='utf-8')
# example
# type, <class 'str'>
  • bytes.decode(byte)
bytes.decode(b)
# example
# type, <class 'bytes'>

参考链接

  1. python3字典列表混合嵌套 ↩︎

  2. Python编程基础 ↩︎

  3. 如何修改python中字典的键和值 ↩︎

  4. Python dict字典基本操作（包括添加、修改、删除键值对 ↩︎

  5. python中如何从字典嵌套列表嵌套字典中取值，并且进行赋值 ↩︎ ↩︎ ↩︎

  6. Python 字典(Dictionary) get()方法 ↩︎

  7. Python基础——字典中由value查key的几点说明 ↩︎

  8. Python 移除字典点键值(key/value)对 ↩︎

  9. Python合并两个字典成一个新字典的几种方法分析比较

    python-----删除列表中某个元素的3种方法
    Python 列表中多元素的删除(移除)
    python列表(list)和元组(tuple)之间的转换
    列表转化为元组(python)
    python对list中的每个元素进行某种操作
    Python List sort()方法
    Python3学习（十二）：求两个list的差集、并集与交集
    关于python：查找两个嵌套列表的交集？ ↩︎

  10. Python list列表删除元素（4种方法） ↩︎

  11. python 列表排序方法sort、sorted技巧篇 ↩︎ ↩︎

  12. 1.13 通过某个关键字排序一个字典列表 ↩︎

  13. 对一个列表中的元素子列表进行排序，其余元素不作任何处理 ↩︎

  14. Python .sort()——如何在 Python 中对列表进行排序 ↩︎

  15. python倒序排列方法梳理 ↩︎

  16. Python List count()方法 ↩︎

  17. python怎么统计列表中元素的个数？ ↩︎

  18. python 获取list特定元素下标 ↩︎

  19. 在 Python 中找到列表中元素的索引 ↩︎

  20. Python中bisect的用法及示例详解 ↩︎

  21. python将一组数分成每3个一组 ↩︎

  22. Python 去除列表中重复的元素 ↩︎

  23. list iteration with ‘i for j in’ that I never saw [duplicate] ↩︎

  24. python 中如何把嵌套的列表合并成一个列表? ↩︎

  25. How to “test” NoneType in python? ↩︎

  26. python 列表嵌套 取出每个子列表内的所有值 并去重 ↩︎

  27. Python3 - 6种方法拼接合并列表（list） ↩︎

  28. Python 如何用一个列表的顺序去排另一个列表? ↩︎

  29. 在 Python 中按另一个列表对列表进行排序 ↩︎

  30. Python set集合基本操作（添加、删除、交集、并集、差集） ↩︎

  31. Python判断某个列表是否是另一个列表的子列表 ↩︎

  32. python获取字符串首字母_Python字符串常用操作命令 ↩︎ ↩︎

  33. Python 字符串去除空格的方法 ↩︎

  34. Python Regex: re.search() VS re.findall() ↩︎ ↩︎

  35. Python 正则去除字符串中的指定元素 ↩︎

  36. python正则表达式从字符串中提取数字 ↩︎

  37. Python 字符串大小写转换 ↩︎

  38. Python find()方法 ↩︎

  39. Python 字符串 isidentifier() 方法 ↩︎

  40. python str与bytes之间的转换 ↩︎ ↩︎

  41. Python startswith()方法 ↩︎

  42. Python splitlines()方法 ↩︎

  43. Python3 split()方法 ↩︎

  44. Python join()方法 ↩︎

MissMango0820
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
（Python）组合数据：Python中的列表、元组、集合
weixin_41032720的博客
07-06 4339
实验内容 1、使用2种方法将两个列表中的数据合并。 2、列表list1 = [3, 8, 11, 26, 47]，接受从键盘输入一个新的元素key，将新的元素key插入到列表list1中，保持列表list1中的元素有序。编程实现上述功能。 3、使用Python编程删除列表中的重复元素。 4、使用Python语言创建一个元组grade = (68, 87, 83, 91, 93, 79, 68, 8...
Python字符串、列表、元组、字典、集合的补充实例详解
09-18
主要介绍了Python字符串、列表、元组、字典、集合,结合实例形式详细分析了Python字符串、列表、元组、字典、集合常见函数使用方法及相关操作注意事项,需要的朋友可以参考下
python_列表_元组_集合
qq_46075726的博客
09-12 371
list 列表：一个规则的可变数据的集合，数据不唯一 元组：（tuple）一个规则的不可变数据的集合，数据不唯一 set：不规则的无序数据的集合，但是可以添加新的项和数据。数据唯一（不允许重复） 字典：无序的键值对数据集合。数据唯一 列表可以存放不同类型的数据 lst = list() # 声明一个空的列表 lst = [] # 简化的声明列表的方式 lst = ['HTML', 'CSS', 'JS', 'React','Redux', 'Node', 'MongDB'] # 列表可以存放不同类型
python列表、元组、集合
GENIUSROAD的博客
09-28 176
list tuple set 特点 有序，可重复，内容可变，可通过下标获取元素 有序，可重复，内容可变，可通过下标获取元素 定义 ["张三","李四","王五"] ("张三","李四","王五") 添加 原样添加：append(元素)或insert(index,元素)组合生成新的列表：+拆包添加：extend() 删除 通过下标：del list[index]或pop(index) #index默认为-1即从列表最后一个元素删除删除指定的第一个元素：remove(元素)； ...
python元组列表集合_Python 列表，元组，集合，字典，字符实例介绍
weixin_39805195的博客
03-02 193
1.Python中最常见的序列类型为:列表，元组，字符类型特点:①所有序列都支持迭代②序列表示索引为非负整数的有序对象集合③字符和元组属于不可变序列，列表为可变序列2.python中常见的容器类型为:列表，元祖Tuple，字典，和集合容器:是可以存放数据项集合的数据结构3.Python中的可变与不可变类型可变类型:列表、字典是可变的举个例子说明：往列表list里增添数据，list = [1,2,3...
python元组列表集合_python学习笔记3：列表、元组和集合
weixin_39778218的博客
12-08 156
一、列表 list总结：列表是可变变量，可以通过下标修改元素的值1、定义列表 -- 中括号[ ]name=['Lily','Lucy','meimei']2、下标取值 --正负数均可3、在列表中添加值1)append() 方法，在列表末尾添加一个值2)insert()方法，在列表指定位置添加一个值3)extend()方法，把一个列表追加到一个列表的末尾 　　　　　　　4、从列表中...
python字符串,元组,列表,字典互转代码实例详解
09-17
主要介绍了python字符串,元组,列表,字典互转代码实例详解,需要的朋友可以参考下
python列表、字典、元组、集合精讲
01-05
列表可以包含任何类型的对象，包括数字、字符串、列表、字典、元组等。列表是可变对象，支持原处修改的操作。 列表的操作和字符串大部分都相同，例如合并、重复、索引、切片等。列表也支持一些特殊的操作，例如插入...
在Python中字符串、列表、元组、字典之间的相互转换
09-18
- 更安全的方法是使用`json.loads()`，它将JSON格式的字符串解析为Python字典： ```python import json str_1 = '{"name":"xiaoming","age":18}' dict_1 = json.loads(str_1) ``` 7. 字典转换为其他类型 - ...
Python字符串、元组、列表、字典互相转换的方法
09-21
以下是关于字符串、元组、列表和字典互相转换的详细说明： 1. 字典转字符串： 使用内置函数`str()`可以将字典转换为字符串形式，输出结果为`<type 'str'>`，内容为字典的表示形式。例如： ```python dict = {'...
Python元组、列表和集合
winycg的博客
10-02 755
元组类型3个特点： 1.元组中元素可以是不同类型 t=123,456,”er” 2.存在先后关系，t[0] 3.元组定义以后不能更改，也不能删除 列表类型：a=[1,2,3,4] print(a) 每个元素类型可以不同，大小没有限制 实例： （1）v=[1,2,3,4] （2）v*2 输出：[1,2,3,4,1,2,3
Python 列表、元组和集合
m0_54616917的博客
08-14 293
Python列表、元组、集合
Python 学习笔记 -- 变量、元组、列表、字典和集合
Byron's notebook
03-16 2499
2013年3月16日，Python征程第四天 渐入佳境。 变量、元组、列表、字典和集合简介： 1、变量的命名规则：   1)避免使用Python保留字,保留字有：and,as,assert,break,class,continue,def,del,elif,else,expect,exec,False,finally,for,from,global,if,import,in is,lam
python中列表、字典、元组与集合的特点以及差异
jane_6091的博客
05-15 1万+
1.列表（List） 列表的特点 1. 数据按顺序存储 2. 列表有正序、倒序两种索引 3. 列表可存储任意类型的数据，并且允许重复。 列表的遍历： lst = [1,2,3] for i in range(len(lst)): print(lst[i]) 列表的增删改操作 列表的缺点： 在表达结构化数据时语义不明确（结构化数据是指有明确属性的数据） 例如： ["张三"，“经理”，“2000-4-24”，39，21000] 像上述的结构无法解析2000-4-24到底是什么含义，21000也不明确
Python 集合（列表 ，元组，集合， 字典）
最新发布
2201_75376496的博客
02-06 4224
Python 集合（列表 ，元组，集合， 字典）
Python -- 列表、元组、字典、集合
享你所想
10-09 7216
列表是 Python 中最常用的组合数据类型之一。从数据结构角度看，列表是一个 可变 长度的 顺序序列 存储结构。在 Python 中，使用 list 表示列表类型。元组也是序列结构，但是是一种 不可变 序列。在 Python 中，使用 tuple 表示元组类型。字典是 可变无序 数据结构，主要由键 (key) 和对应值 (value) 成对组成，根据键 (key) 计算对 应值 (value) 的地址，以至于字典具有非常快的查询与插入速度。在 Python 中，使用 dict 表 示字典类型。
python中的列表、元组、字典、集合
qq_45897677的博客
07-12 5814
列表、元组、字典、集合
python中列表、元组、字典、集合的异同
孤狼北望
10-19 2万+
转载地址 &nbsp; &nbsp;http://blog.csdn.net/weixin_37720172/article/details/78769301 一.前言 一直想写写这四种类型的相同点，与不同点在哪里，以及在什么情况下应该使用哪种类型。无奈水平不够，怕写出来不够深刻，所以一直拖着。今天想了想还是写出来吧，如果以后还有新的见解或者技巧我会继续更上去的。 二.列表（list...
Python列表、元组、集合、字典的区别和相互转换
热门推荐
小龙在线
04-28 4万+
列表、元组、集合、字典的区别 列表 元组 集合 字典 英文 list tuple set dict 可否读写 读写 只读 读写 读写 可否重复 是 是 否 是 存储方式 值 值 值 键值对 是否有序 有序 有序 无序 有序 初始化 [1,’a’] (‘a’, 1)
Python基础数据结构详解：列表、元组、字符串等
本课程名为"Python的基本数据结构（课件）"，主要介绍了Python语言中几种核心的数据结构，包括列表（list）、元组（tuple）、字符串（string）、集合（set）和字典（dict）。这些数据结构在Python编程中扮演着关键...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值