Python: DataStructure

check if it is empty?¶

strings, lists, tuples

# Correct:
if not seq:
if seq:

# Wrong:
if len(seq):
if not len(seq):

debug¶

try:
    # sth
except Exception as e:
    pprint.pprint(list)
    raise e
finally:
    un_set()

for¶

step¶

调参需要测试间隔值

for i in range(1, 101, 3):
    print(i)

遍历修改值¶

使用 enumerate 函数结合 for 循环遍历 list，以修改 list 中的元素。
enumerate 函数返回一个包含元组的迭代器，其中每个元组包含当前遍历元素的索引和值。在 for 循环中，我们通过索引 i 修改了列表中的元素。

# 对于 二维list appDataDict
baseline = appDataDict[0][0] # CPU Total
for i, line in enumerate(appDataDict):
    for j, entry in enumerate(line):
        appDataDict[i][j] = round(entry/baseline, 7)

itertools¶

itertools --- 为高效循环而创建迭代器的函数

for a,b,c in permutations((a,b,c)):

String 字符串 ¶

%c  格式化字符及其ASCII码
%s  格式化字符串
%d  格式化整数
%u  格式化无符号整型
%o  格式化无符号八进制数
%x  格式化无符号十六进制数
%X  格式化无符号十六进制数（大写）
%f  格式化浮点数字，可指定小数点后的精度
%e  用科学计数法格式化浮点数
%E  作用同%e，用科学计数法格式化浮点数
%g  %f和%e的简写
%G  %F 和 %E 的简写
%p  用十六进制数格式化变量的地址

print("My name is %s and weight is %d kg!" % ('Zara', 21))

string <-> list¶

' '.join(pass_list) and pass_list.split(" ")

对齐"\n".join(["%-10s" % item for item in List_A])

字符串开头判断¶

text = "Hello, world!"

if text.startswith("Hello"):
    print("The string starts with 'Hello'")
else:
    print("The string does not start with 'Hello'")

format 格式化函数¶

Python2.6 开始，通过 {} 和 : 来代替以前的 %

>>>"{} {}".format("hello", "world")    # 不设置指定位置，按默认顺序
'hello world'

>>> "{1} {0} {1}".format("hello", "world")  # 设置指定位置
'world hello world'

# 字符串补齐100位，<表示左对齐
variable = "Hello"
padded_variable = "{:<100}".format(variable)

数字处理

print("{:.2f}".format(3.1415926)) # 保留小数点后两位

{:>10d} 右对齐 (默认, 宽度为10)
{:^10d} 中间对齐 (宽度为10)

小数位¶

x = round(x,3)# 保留小数点后三位

容器：List¶

https://www.runoob.com/python/python-lists.html

初始化以及访问¶

list = ['physics', 'chemistry', 1997, 2000]
list = []          ## 空列表
print(list[0])

切片¶

格式：[start_index:end_index:step]

不包括end_index的元素

二维数组¶

list_three = [[0 for i in range(3)] for j in range(3)]

//numpy 创建连续的，可自动向量化，线程并行
import numpy as np
# 创建一个 3x4 的数组且所有值全为 0
x3 = np.zeros((3, 4), dtype=int)
# 创建一个 3x4 的数组，然后将所有元素的值填充为 2
x5 = np.full((3, 4), 2, dtype=int)

size 大小¶

len(day)

排序¶

# take second element for sort
def takeSecond(elem):
    return elem[2]

LCData.sort(key=takeSecond)

# [1740, '黄业琦', 392, '第 196 场周赛'],
# [1565, '林坤贤', 458, '第 229 场周赛'],
# [1740, '黄业琦', 458, '第 229 场周赛'],
# [1509, '林坤贤', 460, '第 230 场周赛'],
# [1740, '黄业琦', 460, '第 230 场周赛'],
# [1779, '黄业琦', 558, '第 279 场周赛'],

对应元素相加到一个变量¶

tmp_list = [[],[],[],[]]
# 注意不需要右值赋值
[x.append(copy.deepcopy(entry)) for x,entry in zip(tmp_list, to_add)]

两个list对应元素相加¶

对于等长的

list1 = [1, 2, 3, 4, 5]
list2 = [6, 7, 8, 9, 10]

result = [x + y for x, y in zip(list1, list2)]
print(result)

如果两个列表的长度不同，你可以使用zip_longest()函数来处理它们。zip_longest()函数可以处理不等长的列表，并使用指定的填充值填充缺失的元素。

from itertools import zip_longest

list1 = [1, 2, 3, 4, 5]
list2 = [6, 7, 8]

result = [x + y for x, y in zip_longest(list1, list2, fillvalue=0)]
print(result)

如果是二维list

list1 = [[1, 2, 3],
         [4, 5, 6],
         [7, 8, 9]]

list2 = [[10, 11, 12],
         [13, 14, 15]]

rows = max(len(list1), len(list2))
cols = max(len(row) for row in list1 + list2)

result = [[0] * cols for _ in range(rows)]

for i in range(rows):
    for j in range(cols):
        if i < len(list1) and j < len(list1[i]):
            result[i][j] += list1[i][j]
        if i < len(list2) and j < len(list2[i]):
            result[i][j] += list2[i][j]

print(result)

# 将一个二维列表的所有元素除以一个数A
result = [[element / A for element in row] for row in list1]

直接赋值、浅拷贝和深度拷贝¶

Python append() 与深拷贝、浅拷贝

python赋值只是引用，别名

list.append('Google')   ## 使用 append() 添加元素
alist.append( num ) # 浅拷贝 ，之后修改num 会影响alist内的值

import copy
alist.append( copy.deepcopy( num ) ) # 深拷贝

# delete
del list[2]

for循环迭代的元素也是引用¶

original_list = [1, 2, 3]

for item in original_list:
    item *= 2 # 每个元素是不可变的

print(original_list) 

original_list = [[1,2,3], [2], [3]]

for item in original_list:
    item.append("xxx") # 每个元素是可变的

print(original_list) 

# [1, 2, 3]
# [[1, 2, 3, 'xxx'], [2, 'xxx'], [3, 'xxx']]

函数传参是引用，但是能通过切片来得到类似指针 ¶

参数的传递函数声明时的形参，使用时，等同于函数体内的局部变量。由于Python中一切皆为对象。因此，参数传递时直接传递对象的地址，但具体使用分两种类型： 1.传递不可变对象的引用（起到其他语言值传递的效果）数字，字符串，元组，function等 2.传递可变对象的引用（起到其他语言引用传递的效果）字典，列表，集合，自定义的对象等

def fun0(a):
    a = [0,0] # a在修改后，指向的地址发生改变，相当于新建了一个值为[0,0]

def fun(a):
    a[0] = [1,2]

def fun2(a):
    a[:] = [10,20]

b = [3,4]
fun0(b)
print(b)
fun(b)
print(b)
fun2(b)
print(b)

# [3, 4]
# [[1, 2], 4]
# [10, 20]

return 返回值¶

可变的也是引用

def fun1(l):
    l.append("0")
    return l 

def fun2(l):
    return l

if __name__=="__main__":
    l = [1,2,3,4,5]

    rel2 = fun2(l)
    print(rel2)   
    rel1 = fun1(l)
    print(rel1)   
    print(rel2)   
    l.append("xxx")
    print(rel1)   
    print(rel2)   
    del rel1[2]
    print(rel1)   
    print(rel2)  

# [1, 2, 3, 4, 5]
# [1, 2, 3, 4, 5, '0']
# [1, 2, 3, 4, 5, '0']
# [1, 2, 3, 4, 5, '0', 'xxx']
# [1, 2, 3, 4, 5, '0', 'xxx']
# [1, 2, 4, 5, '0', 'xxx']
# [1, 2, 4, 5, '0', 'xxx']

容器：元组Tuple¶

元组和列表类似，但是不同的是元组不能修改，但可以对元组进行连接组合，元组使用小括号。
元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用。

#创建元组
tup = (1, 2, 3, 4, 5)
tup1 = (23, 78);
tup2 = ('ab', 'cd')
tup3 = tup1 + tup2

容器：Dict¶

empty dict¶

a= {}
a=dict()

key 支持tuple元组¶

类似c++ 的 pair<int,int>

bblHashDict[(tmpHigherHash,tmpLowerHash)]=tmpBBL

但是这样就不支持json.dump， json.dump() 无法序列化 Python 中元组(tuple)作为字典的 key，这会导致 json.dump() 函数在写入此类字典数据时会进入死循环或陷入卡住状态

初始化以及访问¶

>>> tinydict = {'a': 1, 'b': 2, 'b': '3'}
>>> tinydict['b']
'3'

a_dict = {'color': 'blue'}
for key in a_dict:
 print(key)
# color
for key in a_dict:
    print(key, '->', a_dict[key])
# color -> blue
for item in a_dict.items():
    print(item)
# ('color', 'blue')
for key, value in a_dict.items():
 print(key, '->', value)
# color -> blue

判断key 是否存在¶

以下是两种常用的方法：

方法一：使用in操作符: in操作符返回一个布尔值，True表示存在，False表示不存在。

Copy code
my_dict = {"key1": "value1", "key2": "value2", "key3": "value3"}

# 判断是否存在指定的键
if "key2" in my_dict:
    print("Key 'key2' exists in the dictionary.")
else:
    print("Key 'key2' does not exist in the dictionary.")

方法二：使用dict.get()方法: dict.get()方法在键存在时返回对应的值，不存在时返回None。根据需要选择适合的方法进行判断。

Copy code
my_dict = {"key1": "value1", "key2": "value2", "key3": "value3"}

# 判断是否存在指定的键
if my_dict.get("key2") is not None:
    print("Key 'key2' exists in the dictionary.")
else:
    print("Key 'key2' does not exist in the dictionary.")

这两种方法都可以用来判断字典中是否存在指定的键。

size 大小¶

len(day)

修改以及添加¶

tinydict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}

tinydict['Age'] = 8 # 更新
tinydict['School'] = "RUNOOB" # 添加

合并¶

dict1 = {'a': 10, 'b': 8} 
dict2 = {'d': 6, 'c': 4} 

# dict2保留了合并的结果
dict2.update(dict1)
print(dict2)
{'d': 6, 'c': 4, 'a': 10, 'b': 8}

删除¶

del tinydict['Name']  # 删除键是'Name'的条目
tinydict.clear()      # 清空字典所有条目
del tinydict          # 删除字典

print by key¶

from pprint import pprint
pprint

容器：set¶

无序不重复序列

初始化¶

a=  set() # 空set

thisset = set(("Google", "Runoob", "Taobao"))
>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket)                      # 这里演示的是去重功能

list2set¶

setL=set(listV)

set2list¶

my_set = {'Geeks', 'for', 'geeks'}

s = list(my_set)
print(s)
# ['Geeks', 'for', 'geeks']

添加¶

thisset.add("Facebook")

合并¶

x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "apple"}

z = x.union(y) 

print(z)
# {'cherry', 'runoob', 'google', 'banana', 'apple'}

删除与清空¶

s.remove( x )
a.clear()

修改原本的值¶

修改传入参数¶

在Python中,函数的参数是按值传递的,也就是说在函数内部修改参数不会影响到函数外部的变量。

但是有几种方法可以实现类似修改参数的效果:

返回修改后的值,在函数外部重新赋值

def func(x):
    x = x + 1 
    return x

a = 10
a = func(a) 
print(a) # 11

使用可变对象作为参数,修改可变对象的内部值

def func(lst):
    lst.append(1)

lst = [1,2,3]
func(lst)
print(lst) # [1,2,3,1]

这里lst是列表,在func内部修改了lst,由于lst是可变的,所以函数外部的lst也被修改了。

使用全局变量

count = 0
def func():
    global count
    count += 1

func()
print(count) # 1

通过global关键字声明count为全局变量,这样就可以在函数内部修改全局变量count了。

所以要修改传入参数的值,主要的方法是:

返回修改后的值并重新赋值
传入一个可变对象并修改可变对象内部的值
使用全局变量

这些技巧可以实现模拟修改参数的效果。

修改for循环对象¶

在Python中,for循环遍历的是一个迭代器,每次循环会将迭代器的下一个元素赋值给循环变量。

如果想在for循环内部修改迭代器中的元素,可以使用以下方法:

将迭代器转换成列表,然后修改列表中的元素:

all_for_one = ['a', 'b', 'c']

for app_info in list(all_for_one):
    if app_info == 'b':
        all_for_one[1] = 'x' 

print(all_for_one) # ['a', 'x', 'c']

这里通过list()将迭代器转成列表,然后修改列表的元素。

使用循环的索引而不是直接使用元素:

all_for_one = ['a', 'b', 'c']

for i in range(len(all_for_one)):
    if i == 1:
        all_for_one[i] = 'x'

print(all_for_one) # ['a', 'x', 'c']

通过索引 i 来访问并修改元素。

使用enumerate()在循环中获取索引:

all_for_one = ['a', 'b', 'c']

for i, app_info in enumerate(all_for_one):
    if i == 1:
        all_for_one[i] = 'x'

print(all_for_one) # ['a', 'x', 'c']

enumerate()可以同时迭代索引和元素。

所以主要思路就是不直接修改循环变量,而是通过索引或临时列表来修改迭代器中的原始元素。

修改for循环的对象 set¶

对于 set 这样的不可变对象,不能直接通过索引或者 enumerate 来修改,因为 set 对象不支持索引和切片操作。

对于 set,可以使用以下方法在循环内部进行修改:

将 set 转换成 list,修改后再转换回 set

s = {'a', 'b', 'c'}

for item in list(s):
    if item == 'b':
        s = list(s)
        s[1] = 'x'
        s = set(s)

print(s) # {'a', 'x', 'c'}

创建一个新的 set,在循环中添加修改后的元素

s = {'a', 'b', 'c'}
new_s = set()

for item in s:
    if item == 'b':
        new_s.add('x')
    else:
        new_s.add(item)

s = new_s

print(s) # {'a', 'x', 'c'}

使用 set 的discard()和add()方法在循环中修改

s = {'a', 'b', 'c'}

for item in s:
    if item == 'b':
        s.discard(item)
        s.add('x')

print(s) # {'a', 'x', 'c'}

上面这些方法的关键思路都是:

将不可变对象设置转换成可变类型
在循环中针对可变类型进行修改
再转换回不可变 Set 对象

这样就可以实现循环中修改 Set 的效果。

需要进一步的研究学习¶

暂无

遇到的问题¶

暂无

开题缘由、总结、反思、吐槽~~¶

参考文献¶

https://blog.csdn.net/weixin_63719049/article/details/125680242

Python: DataStructure

check if it is empty?¶

debug¶

for¶

step¶

遍历修改值¶

itertools¶

String 字符串¶

string <-> list¶

字符串开头判断¶

format 格式化函数¶

小数位¶

容器：List¶

初始化以及访问¶

切片¶

二维数组¶

size 大小¶

排序¶

对应元素相加到一个变量¶

两个list对应元素相加¶

直接赋值、浅拷贝和深度拷贝¶

for循环迭代的元素 也是 引用¶

函数传参是引用，但是能通过切片来得到类似指针¶

return 返回值¶

容器：元组Tuple¶

容器：Dict¶

empty dict¶

key 支持tuple元组¶

初始化以及访问¶

判断key 是否存在¶

size 大小¶

修改以及添加¶

合并¶

删除¶

print by key¶

容器：set¶

初始化¶

list2set¶

set2list¶

添加¶

合并¶

删除与清空¶

修改原本的值¶

修改传入参数¶

修改for循环对象¶

修改for循环的对象 set¶

需要进一步的研究学习¶

遇到的问题¶

开题缘由、总结、反思、吐槽~~¶

参考文献¶

String 字符串 ¶

for循环迭代的元素也是引用¶

函数传参是引用，但是能通过切片来得到类似指针 ¶