python旋转向量 python列表转向量

一.列表的反转
如：

a=["a",'b','c','d']
#将列表反转
a[::-1]

二、列表的基本操作

2.1 列表的生成

（1）直接通过list函数生成

#直接生成一个1-10000的列表
list(range(10000))

（2）通过遍历生成

[i for i in range(10000)]

2.2 列表的更新
（1）、列表元素的修改
<1>、根据索引修改
直接修改

list1[0] = 'D'   # 修改列表中索引为0的值为D

(2)列表元素的添加
<1>在列表末尾添加元素
list.append()

list1.append('E')   # 在list1列表中添加“E”

<2>按照索引添加元素

list1.insert(0 , 'F')    　　　　　　      # 在list1列表中的第0处插入元素“F”

2.2、列表的删除
1、删除列表的指定元素
(1)remove删除列表中的某个元素，但是只删除第一（这个第一是指从前至后）个出现的。

In [11]: a=[0,2,3,2]   
  In [12]: a 
  Out[12]: [0, 2, 3, 2]   
          
  In [13]: a.remove(2)   
  In [14]: a 
  Out[14]: [0, 3, 2]

2、根据索引删除元素
（1）del
根据元素的索引删除元素

In [21]: a=[0, 2, 3, 2]
    In [22]: del a[1]
    In [23]: a
    Out[23]: [0, 3, 2]

(2)、pop
根据索引删除元素，并打印要删除的元素
不传入参数的时候，删除列表中的最后一个元素，并返回删除的元素值，传入参数时代表删除列表的指定索引元素

In [15]: a=[0,2,3,2]
     
    In [16]: a.pop()
    Out[16]: 2
     
    In [17]: a
    Out[17]: [0, 2, 3]

根据元素的索引删除元素，并返回该值

In [18]: a=[0,2,3,2]
     
    In [19]: a.pop(2)
    Out[19]: 3
     
    In [20]: a
    Out[20]: [0, 2, 2]

3.列表元素快速交换

我们在编程中经常会用到两个list元素互相交换，如我想将a的元素交换给b,b的元素交换给a，可以采取如下操作：

三、列表的去重及元素的重复统计操作

1、列表的去重

列表的去重可以通过set函数进行，如：

set是进行集合的意思，里面的元素都是唯一的，可以看出数字去重后会进行由小到大的排序。

2、列表元素的重复元素统计

（1）列表元素的重复统计可以通过函数直接获取

其函数尾collections包中的Counter函数，如：

from collections import Counter   #引入Counter
a = [29,36,57,12,79,43,23,56,28,11,14,15,16,37,24,35,17,24,33,15,39,46,52,13]
b = dict(Counter(a))
print ([key for key,value in b.items()if value > 1])  #只展示重复元素
print ({key:value for key,value in b.items()if value > 1})  #展现重复元素和重复次数

（2）通过自己编写函数获取

a = [29,36,57,12,79,43,23,56,28,11,14,15,16,37,24,35,17,24,33,15,39,46,52,13]
uni_a=set(a)
a_count={}
for i in uni_a:
    num=a.count(i)
    if num>=2:
        a_count[i]=num
print(a_count)

3、列表中的元素个数统计

count( )函数

count( i )

list.count（元素），表示对list中的元素进行个数的统计，但是

在用count()函数时，其表示对整个列表进行扫面并统计，其时间复杂度为o(n)

这点在进行算运算时一定要注意。

四、列表中各个操作的效率分析
列表中有append、insert、+、直接形成列表。那么在生成列表的过程中，哪些效率高，哪些效率低呢。我们现在生成一个1-10000的list，并比较时间.

def t1():
    li = []
    for i in range(10000):
        li.append(i)
def t2():
    li = []
    for i in range(10000):
        li = li + [i]
        # li += [i]
def t3():
    li = [i for i in range(10000)]
def t4():
    li = list(range(10000))
def t5():
    li = []
    for i in range(10000):
        li.extend([i])
def t6():
    li = []
    for i in range(10000):
        li.insert(0, i)

timer1 = Timer("t1()", "from __main__ import t1")
print("append:", timer1.timeit(1000))   #对这个函数调用1000次
timer2 = Timer("t2()", "from __main__ import t2")
print("+:", timer2.timeit(1000))
timer3 = Timer("t3()", "from __main__ import t3")
print("[i for i in range]:", timer3.timeit(1000))
timer4 = Timer("t4()", "from __main__ import t4")
print("list(range()):", timer4.timeit(1000))
timer5 = Timer("t5()", "from __main__ import t5")
print("extend:", timer5.timeit(1000))
timer6 = Timer("t6()", "from __main__ import t6")
print("insert", timer6.timeit(1000))
![在这里插入图片描述]()
可以看出：在list尾部添加元素（append）要比头部添加元素(insert())慢的多,通过+号扩充列表也要比extend慢的多，直接生成列表和自生成列表相比，直接生成的速度更快。

list的各个操作的时间复杂度

index[],index assignment：根据索引替换查找元素

iteration:迭代

contains:看某个元素是否在list中

get slice：获得切片

set slice:将切片进行去重，注：如果是对整个数组进行去重则时间复杂度为o(n)

concatenate:将列表拼接等于（extend）

multiply:相乘

对比dict的时间复杂度

四、list与if-else的应用

列表解析总共有两种形式：

1. [i for i in range(k) if condition]：此时if起条件判断作用，满足条件的，将被返回成为最终生成的列表的一员。
2. [i if condition else exp for exp]：此时if…else被用来赋值，满足条件的i以及else被用来生成最终的列表。

以上情况对多个for仍然成立。

print([i for i in range(10) if i%2 == 0])
print([i if i == 0 else 100 for i in range(10)])
 
[0, 2, 4, 6, 8]
[0, 100, 100, 100, 100, 100, 100, 100, 100, 100]

五、列表的拼接

1、extend（）:在一个列表后面追加另一个列表
该方法没有返回值，但会在已存在的列表中添加新的列表内容。
a=[1,2,3]
b=[2]
c=[4,5,6]
a.extend(b)
>>[1, 2, 3, 2]
2、+
a=[1,2,3]
b=[2]
c=[4,5,6]
a+b+c
>>[1, 2, 3, 2, 2, 4, 5, 6]