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；