Python 数组操作_python中数组

一.列表，元祖，：

1.元祖：

（1）创建：

tuple01 = ()#创建空元组

tuple01 = (2，) #元组中只包含一个元素时，需要在元素后面添加逗号

tuple01 = (‘joe’,’susan’,’black’,’monika’)

（2）将元组转换为列表：

tup01 = list(tuple01)

（3）查看：

tuple01[0:2] #0-1的元素的切片，返回 (‘joe’,’susan’）

tuple01[ 0 ] #返回 ‘joe’

tuple01[ -2] #反向取第二个元素， ‘black’

tuple01[ 1：] #从第二个到最后一个的切片

tuple01[0：10：3] #从0到9，步长为3.，取0,3,6，9

tuple01[：：3] #从头到为尾，步长为3

（4）元组中的元素值是不允许修改的，禁止删除或添加元素，可以del删除整个元祖

（5）连接：

t = （1,2,3）+（4,5,6） #（1,2,3,4,5,6）

#可以使用切片再连接的方式修改元祖元素；或转化为列表

（6）内置函数：

len（t） #长度

max（t）#返回最大元素

min（t）

（7）复制：

tuple01*2 #所有元素复制两倍

（8）元素是否存在：

2 in tuple01 #返回bool

（9）迭代：

for x in tuple01 : print(x)

2.列表：

（1）创建：

list = [1,2,3,4]

（2）参考元祖（2）

（3）添加：

list.append(3)

（4）删除：

del list[1]

（5）操作符：

Python 表达式	结果	描述
len([1, 2, 3])	3	长度
[1, 2, 3] + [4, 5, 6]	[1, 2, 3, 4, 5, 6]	组合
[‘Hi!’] * 4	[‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’]	重复
3 in [1, 2, 3]	True	元素是否存在于列表中
for x in [1, 2, 3]: print x,	1 2 3	迭代

（6）转化为元祖：

tuple（[1,2,3]）

（7）函数：

序号	方法
1	list.append(obj)在列表末尾添加新的对象
2	list.count(obj)统计某个元素在列表中出现的次数
3	list.extend(seq)在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
4	list.index(obj)从列表中找出某个值第一个匹配项的索引位置
5	list.insert(index, obj)将对象插入列表
6	list.pop([index=-1])移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
7	list.remove(obj)移除列表中某个值的第一个匹配项
8	list.reverse()反向列表中元素
9	list.sort(cmp=None, key=None, reverse=False)对原列表进行排序

（8）创建一个有规律的二维列表

[[0 for col in range(cols)] for row in range(rows)]

（9）

[x for x in arr if x>5 ] #筛选

[x if x>5 else x+100 for x in arr ]

[x if z else y for x,y,z in zip(arr1,arr2,condition)] #和np.where函数一样的功能；

3.字典：

（1）创建：

dict01 = {‘name1′:’joe’,’name2′:’suan’,’name3′:’anne’}

#不可变类型可以做字典的下标，可变类型不可以，下标不能是列表

（2）访问：

dict01[‘name’]

（3）修改或添加：

dict01[‘address’] = ‘泰国’

#同一个键不能出现两次，否则后者覆盖前者；

（4）删除：

del dict01[‘sex’]

（5）方法：

Python字典包含了以下内置函数：

序号	函数及描述
1	cmp(dict1, dict2)比较两个字典元素。
2	len(dict)计算字典元素个数，即键的总数。
3	str(dict)输出字典可打印的字符串表示。
4	type(variable)返回输入的变量类型，如果变量是字典就返回字典类型。

Python字典包含了以下内置方法：

序号	函数及描述
1	dict.clear()删除字典内所有元素
2	dict.copy()返回一个字典的浅复制
3	dict.fromkeys(seq[, val])创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值
4	dict.get(key, default=None)返回指定键的值，如果值不在字典中返回default值
5	dict.has_key(key)如果键在字典dict里返回true，否则返回false
6	dict.items()以列表返回可遍历的(键, 值) 元组数组
7	dict.keys()以列表返回一个字典所有的键
8	dict.setdefault(key, default=None)和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
9	dict.update(dict2)把字典dict2的键/值对更新到dict里
10	dict.values()以列表返回字典中的所有值
11	pop(key[,default])删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。否则，返回default值。
12	popitem()随机返回并删除字典中的一对键和值。

二.numpy：

1.numpy创建的数组类型为: numpy.ndarray

2.创建方式：

（1）array方法：

np.array( [1,2,4,5,6] )

np.array( [ [1,2,3] , [3,4,5] ] ) #2*3二维数组

np.array( (1,2,3) ) #传入元祖

np.array( （(1,2,3), (4,5,6) )） #2*3

np.array( [ (1,3,3) , (1,2,3) ] )

（2）zeros,ones,empty方法:

zeros返回全0数组

ones返回全1数组

empty返回全0数组

np.zeros( 6 ) #返回1*6

np.zeros( (2,4) ) #传入元祖，返回2*4数组

np.zeros( (2,4,5) ) #2*4*5

# ones,empty方法使用方式类似

（3）arange方法：

np.arange(5) #默认从0开始，到4的整数数组，默认步长为1

np.array(1,5) #从1开始到4

np.array(1,10,3) #从1到9，步长为3

np.array(10,3,-2) #从10到2，步长为2

（4）linespace，logspace方法：

np.linespace(1,10,5) #从1到10的等差数列，5个数

np.logspace(1,2,5,base=10) #从10**1到10**2的等比数列，5个数，不设base默认以e为底

（5）random模块：

np.random.random( (2,3) ) #传入元祖，2*3数组，元素是0-1随机浮点数，返回类型是列表；

np.random.rand（2,3） #不传元祖,元素是0-1随机浮点数，2*3，

np.random.randn( 2,3 ) #不传元祖 ,元素是服从标准正态分布的随机样本，大部分在[-2,2]之间，2*3

np.random.randint(1,10,(2,3)) #1到9之间的随机整数，2*3

2.ndarray的属性：

arr = np.array(np.random.randint(1,9,(2,3,4)))

arr.ndim #ndarray维度，3

arr.shape #形状（2,3,4）

arr.size #元素个数，24

arr.itemsize #每个元素占字节数，4

arr01 = np.array([1,2,3,4,5],dtype = np.float32) #dtype 指定元素类型有int,float32,float64,double多种类型

arr02 = arr01.astype(np.int) #修改元素类型

arr02.dtype #返回元素类型

3.修改形状：

（1）

arr01 = np.random.randint(1,9,(3,4))

arr04.shape = (4,3) #先把3*4数组变成一维列表，再排成4*3数组；数组元素总数不变的；

例：

修改前：

            [[1, 5, 6, 3],

            [4, 4, 6, 4],

            [1, 1, 7, 6]]

修改后：

            [[1, 5, 6],

            [3, 4, 4],

            [6, 4, 1],

            [1, 7, 6]]

arr01.shape = (12) # [1, 5, 6, 3, 4, 4, 6, 4, 1, 1, 7, 6]

（2）reshape：

arr01.reshape(2,6)

降维操作：

arr01 = np.random.randint(1,9,(3,4,5))

arr07.reshape(5,-1) #3*4*5维数组变成5*n；n=12

（3）升维操作：

arr1 = np.random.randint(1,9,(2,2))
arr1[:,np.newaxis，:] #把2*2变成2*1*2

4.数组的运算：

（1）数组与标量的运算：

arr01+10
arr01-10
arr01*10
arr01/10
arr01**2

10**arr01 #每个数组元素与标量运算

（2）数组与数组的运算

arr02+arr03
arr02-arr03
arr02*arr03
arr02/arr03

arr02**arr03 #数组与数组形状一致

#特殊情况：

例：A：2*3*4 与 B：2*1*4可以运算，A的每个2*1*4与B运算；这样的要求就是B有一维是1，其他维和A一致；

或 A：2*3*4 与 B：3*4可以运算，A的每个3*4和B运算；但B：2*4则不能；要求B和A低的维度形状相同；

（3）矩阵积：

arr01.dot(arr02)

4.索引：

（1）

arr09 = np.random.randint(1,9,(3,3,4))

        [[[3, 2, 4, 5],

        [3, 2, 4, 2],

        [2, 1, 8, 8]],



       [[8, 1, 8, 8],

        [6, 1, 6, 2],

        [7, 7, 8, 5]],



       [[7, 6, 8, 6],

        [8, 7, 4, 4],

        [1, 6, 5, 5]]]

arr09[:,:,:] #全部，和arr09一样

arr09[1] #第二个3*4数组；

[[8 1 8 8]

      [6 1 6 2]

      [7 7 8 5]]

arr09[:,1] #3*4

[[3 2 4 2]

      [6 1 6 2]

      [8 7 4 4]]

arr09[:,:,1] #3*3

[[2 2 1]

      [1 1 7]

      [6 7 6]]

arr09[0,0,0]

# 3

（2）arr10[:,:] = 100 #直接修改arr10数组元素的值；

（3）切片：

arr11 = np.ones((2,6)) #

[[ 1. 1. 1. 1. 1. 1.]

             [ 1.  1.  1.  1.  1.  1.]]

arr11[:1] #

[[ 1. 1. 1. 1. 1. 1.]]

（4）花式索引：

arr12 = np.arange(32).reshape(8,4)

[[ 0, 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],

           [28, 29, 30, 31]]

arr12[0,3] #标准索引，返回3

arr12[ [0,3,5] ] #返回第0，3,5行

[[ 0 1 2 3]

             [12 13 14 15]

             [20 21 22 23]]

arr12[[0,3,5],[0,1,2]] #返回第0行第0列，第3行第1列，第5行第2列的那个数组成的数组；

[ 0 13 22]

arr12[np.ix_( [0,3,5] , [0,1,2] ) ] #有索引器，返回3*3，第0行第0列，第3行第1列，第5行第2列

[[ 0, 1, 2],

           [12, 13, 14],

           [20, 21, 22]]

（5）布尔索引：

第一种：

arr12 = np.random.randint(1,9,(3,4))

[[6, 6, 5, 6],

           [6, 1, 7, 7],

           [5, 1, 1, 8]]

arr12<5

[[False, False, False, False],

           [False,  True, False, False],

           [False,  True,  True, False]]

arr12[arr12<5]

[1, 1, 1]

#索引（arr1<5）和原数组形状相同，返回一维

第二种：

arr1[ [true,false,false] ]

[[6, 6, 5, 6]]

#注意：返回的二维数组；

5.常用的一元函数：

np.abs(arr) #abs,fabs 计算整数、浮点数或者复数的绝对值，对于非复数，可以使用更快的fabs

np.sqrt(arr) #计算各个元素的平方根

np.square(arr) #计算各个元素的平方

np.exp(arr) #计算各个元素的指数e的x次方

np.log(arr)
np.log2(arr)

np.log1p(arr) #分别计算自然对数、底数为2的log以及底数为e的log(1+x)

np.sign(arr) #计算各个元素的正负号: 1 正数，0：零，-1：负数

np.ceil(arr) #向上取整
np.floor(arr) #向下取整

np.rint(arr) #四舍五入

np.var( arr ) #求该arr方差，所有元素

6.ndarray的其他操作：

（1）转置

arr13.T #矩阵转置操作

#多维数组转置不常用，所以不讲了；

（2）拉伸：

arr = np.random.randint(1,9,(2,2))

[[5, 7],

               [4, 1]]

np.tile(arr,3) #横向拉伸3次

[[5 7 5 7 5 7]

             [4 1 4 1 4 1]]

np.tile(arr,(3,3)) #横向拉伸3次，纵向拉伸3次

[[5 7 5 7 5 7]

             [4 1 4 1 4 1]

             [5 7 5 7 5 7]

             [4 1 4 1 4 1]

             [5 7 5 7 5 7]

             [4 1 4 1 4 1]]

（3）聚合：

arr = np.random.randint(1,9,(2,3))

#arr可以调用的聚合函数有mean，sum，max，min，std，var，axis=1对每一列聚合，axis=0对每一行聚合

#std标准差

arr.mean(axis = 1) #1*3

arr.mean(axis = 0) #2*1

（4）where:

np.where([[True, False], [True, True]] , [[1, 2], [3, 4]] , [[9, 8], [7, 6]])

#三个数组形状相同，第一个数组元素是true，选第二个数组元素，否则选第三个数组元素；

（5）去重：

np.unique(arr)

#去除重复元素，如果arr是多维的，返回一维的；

三.dataFrame:

dataFrame是比ndarray多了行标，列标的数组；

创建方式为：

import pandas as pd
df = pd.DataFrame(index=[1,2,3],columns=[4,5,6])

在机器学习算法中，ndarray比dataFrame好操作，所以：

可以接收dataFrame类型，然后转化为dnarray类型：

df.values；

Python 数组操作_python中数组

（6）转化为元祖：

相关推荐