Python List 操作笔记 ∈ Python 编程笔记_np不知道个数 list

主博客：Python 编程笔记（本人出品，必属精品）

Part.I 常用操作

一些一句话就可以解决的比较难的功能

p=a.index(value)				# 查找列表a中，值等于value的元素的位置，仅仅是第一个位置
s = "%05d" % n					# 数字转字符串，位数不够补0
a=list(range(1,n+1))			# 构造一个list，其中元素从1到n
a=list(np.full(5,np.nan))		# 得到一个所有元素都是nan的长度为5的列表
bol=np.isnan(a)					# 判断a是否为nan
L=list(map(list, zip(*L)))		# 转置，二维及以上
a=list(reversed(a))				# 列表反转
if len(list_a) == 0				# 判断一个list是否为空
if list_a						# 不是空
p1 = np.polyfit(X, Y, 7)        # 利用7次多项式拟合，返回拟多项式系数，按照阶数从高到低排列
Y1 = np.polyval(p1,X)			# 根据拟合出的多项式系数和自变量X值得到拟合值
np.random.normal()				# 产生一个高斯白噪声
x = np.random.randint(0, rows)	# 生成指定范围内的随机整数
np.random.rand()				# 返回一个服从“0~1”均匀分布的随机样本值。随机样本取值范围是[0,1)，不包括1。
np.random.rand(a,b)				# 返回a行b列的array,其值取值范围为[0,1)
b = b[b != 0]					# 去掉数组中的 0
Gtmp=[[np.nan]*5 for i in range(33)]   # 构造一个33*5的list，每个元素都是nan
index_list=[i for i,x in enumerate(a) if x==3]	# 得到一个列表中元素等于某个值的元素的所有索引
mylist = [0 if math.isnan(x) else x for x in mylist]	# 用 0 替换数组中的 nan
sorted(boxTypes, key=(lambda x:x[1]), reverse=True)		# 将二维列表根据第二个元素的大小进行由大到小排序
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

Part.II 基础知识

对象赋值、浅深拷贝

对于二维列表

取元素

a[1][1]						#取出某一行某一列中的元素，返回一个数
a[1][1:3]					#取出某一行某几列的元素，返回一个列表
b=[i[0] for i in a[1:3]]	#取出某一列某几行的元素，返回一个列表
a[-1]						#取列表最后一个元素
a[1:-1]						#取从第二个元素到倒数第二个元素，注意，不含倒数第一元素
a[1:]						#取从第二个元素到最后一个元素
1
2
3
4
5
6

改元素

a[0][1]=120
a[1][1:3]=[220,230]
Data=setVecIn2Dlist(vec,Data,a=[],b=0)
1
2
3

Chap.I 集合运算

a = [0,1,2,3,4]
b = [0,2,6]
list(set(a) & set(b))   # 使用  "&"  运算求a与b的交集，输出：[0, 2]
list(set(a) | set(b))   # 使用  "|"  运算求a与b的并集，输出：[0, 1, 2, 3, 4, 6]
list(set(b) - set(a))   # 使用  "-"  运算求a与b的差(补)集： 求b中有而a中没有的元素，输出：[6]
list(set(a) - set(b))   # 使用  "-"  运算求a与b的差(补)集： 求a中有而b中没有的元素，输出：[1, 3, 4]
list(set(a) ^ set(b))   # 使用  "^"  运算求a与b的对称差集，输出：[1, 3, 4, 6]
1
2
3
4
5
6
7

参考：https://blog.csdn.net/Sniper_LA/article/details/86482942

值得注意的是，转成set集合运算后再转回来就会改变元素的顺序，所以可以通过c.sort(key=a.index)来限制其顺序

Chap.II 数据类型转换

array=numpy.array(list)				# list -> numpy.array
list=array.tolist()					# numpy.array -> list
dataframe_a = pd.DataFrame(list_a)	# list -> pands.dataframe
list_b=list(dataframe_a[0])			# pands.dataframe -> list
# 将一个一维列表reshape成二维列表
temp1=np.array(temp).reshape(p,l).tolist()
1
2
3
4
5
6

Chap.III 数学运算

对一个列表的数学运算——均值、方差、标准差、最值

mean_val=np.mean(a)						# 求均值
mean_val=np.average(a,weight=[])		# 求加权平均值，weight的长度需与a保持一致
var_val=np.var(a) 						# 计算总体方差,分母是N
var_val=np.var(a, ddof = 1)				# 计算方差，分母是N-1
var_val=np.var(b, axis = 0) 			# 计算矩阵每一列的方差
var_val=np.var(b, axis = 1) 			# 计算矩阵每一行的方差
std_val=np.std(a) 						# 计算总体标准差,用法和var一样
max_value = max(exp_list) 				# 求列表最大值
max_idx = exp_list.index(max_value) 	# 求最大值对应索引
min_value = min(exp_list) 				# 求列表最小值
min_idx = exp_list.index(min_value) 	# 求最小值对应索引
1
2
3
4
5
6
7
8
9
10
11

一个元素与一个列表的数学运算：

b=[i*times for i in a] 			# .*
b=[i/times for i in a] 			# ./
b=[i+times for i in a] 			# .+
b=[i-times for i in a] 			# .-
1
2
3
4

两个长度相等的列表对应元素的数学运算：

c = [a[i]+b[i] for i in range(0,len(a))]	# +
c = [a[i]-b[i] for i in range(0,len(a))]	# -
c = [a[i]*b[i] for i in range(0,len(a))]	# *
c = [a[i]/b[i] for i in range(0,len(a))]	# /
1
2
3
4

其实对更高维度的列表采取这种操作就有点费劲了，可以先将list转化为array进行运算后再用a.tolist()转回来即可。下面以相乘为例：

c=np.array(a)*np.array(b)
d=c.tolist()
1
2

并且也支持一个数与一个array相乘。

Chap.IV 删除元素的几种姿势

Part.III 实用小函数

下面的一些功能写到子博客中了：

• 按区间分组统计各组个数：使用groupby()函数
• 删除三维列表特定行列页的元素
• 取三维列表特定行列页的元素

Chap.I 判断一个列表中是否所有元素都是NAN

""" Util: judge whether all the data is nan """
def mIsAllnan(data):
    n = len(data)
    state = False
    for i in range(n):
        if not (math.isnan(data[i])):
            break
    if i == n - 1 and math.isnan(data[i]):
        state = True
    return state
1
2
3
4
5
6
7
8
9
10

Chap.II 求一个列表的 RMSE

"""
get the rmse and the mean value of the data.

 
> @param[in] data:          the data list
> @param[in] mode:          mode=1: Eliminate noise
return: 
< @param[out] mean_val:     the mean value
< @param[out] std_val:      the std value
"""
def rmse(data=[], mode=0):
    mean_val = np.mean(data)
    error = [i - mean_val for i in data]
    std_val = np.std(error)
    while mode:
        a = 3
        data1 = []
        for i in range(len(error)):
            if error[i] < a * std_val:
                data1.append(data[i])
        mean_val = np.mean(data1)
        error = [i - mean_val for i in data1]
        std_val = np.std(error)
        if len(data1) == len(data):
            break
        data = data1
    return mean_val, std_val
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

Chap.III 更改二维列表某一列某几行元素

def setVecIn2Dlist(vec,Data,a=[],b=0):
    """
    set the specfic elements of specfic raw, cloum, page in 2D-list.
    
    > @param[in] vec:           a list 
    > @param[in] Data:          The 2D-list
    > @param[in] a:             The raw index list
    > @param[in] b:             The column indx
    return:     
    < @param[out] Data          the 2D-list after change the elements
    """
    nv=len(vec)
    nd=len(Data)
    if len(a)==0:
        a=list(range(0,nd))
    na=len(a)
    if nv!=nv:
        print('Error::len(vec)!=len(a)')
        return Data
    j=0
    for i in a:
        tmp=Data[i]
        tmp[b]=vec[j]
        j=j+1
    return copy.deepcopy(Data)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

附.X 一些小实验

Chap.I 二维列表实验

取元素，首先做个小实验。

比如我现在有个二维列表，它里面存储的内容为：

a=[[11,12,13,14],
[21,22,23,24],
[31,32,33,34]]
1
2
3

我现在想得到第二行第二列的元素，按照正常的思路，应该是a[1][1]，没错，a[1][1]确实得到了我想要的元素22。

我现在想得到第二行第二列和第三列的元素，按照正常的思路，应该是a[1][1:3]，没错，得到的结果为[22, 23]是我想要的

但是我现在想得到第1列，第二行和第三行的元素，尝试一下a[1:3][0]，得到结果为[21, 22, 23, 24]，之前的时候我觉得得到的结果很奇怪，现在看来很正常，首先a[1:3]得到的同样是一个二维列表（是原来二维列表第二行和第三行），然后[0]得到的是前一步得到的二维列表的第一行。如果想实现得到第一列，第二行和第三行的元素如何做？b=[i[0] for i in a[1:3]]，这样得到就是目标[21, 31]了。

---

如果现在我想改一下某个元素，比如

我想改第一行第二列的元素12为120，使用a[0][1]=120即可轻松实现

我想改第二行，第二列和第三列的元素22 23为220 230，使用a[1][1:3]=[220,230] 即可

我想改第一列，第一行和第二行的元素[11 21]为110 210，该如何去做？
可以先将二维列表转置一下，现在改列元素问题就变成了改行元素问题，使用上面的方法即可实现。

aT=list(map(list, zip(*a)))
aT[0][0:2]=[110,210]
a=list(map(list, zip(*aT)))
1
2
3

但是平常可能会对转置这堆操作不熟悉，所以编写了一个小函数，如上面实用小函数所示。