pythonlist清空

⑴ python list=[[],[],[],[1],[2],[3]]是怎么删除空直

因为对原列表删改的时候，len(list)是实时变化的，且remove、pop那些函数只能删除第一个遇到的符合条件的元素，且你的要求是只删除空元素，而对其他如果有重复的元素不进行修改，所以也不能用元组set.
那我有两个方法，第一个是记录list中[]出现的位置，之后按照反向的顺序依次remove掉，这样就不会因为列表长度在变化而删错元素；
第二个是直接删除空元素，但记录list长度的实时变化，当list长度不再变化，则list中的空元素都已经删完了。

⑵ Python中list的实现

原文链接
这篇文章介绍了Python中list是如何实现的。
在Python中list特别有用。让我们来看下list的内部是如何实现的。
来看下面简单的程序，在list中添加一些整数并将他们打印出来。

正如你所看到的，list是可以迭代的。

Python中list是用下边的C语言的结构来表示的。 ob_item 是用来保存元素的指针数组，allocated是 ob_item 预先分配的内存总容量

让我们来看下当初始化一个空list的时候发生了什么 L = []

非常重要的是知道list申请内存空间的大小（后文用allocated代替）的大小和list实际存储元素所占空间的大小( ob_size )之间的关系， ob_size 的大小和 len(L) 是一样的，而allocated的大小是在内存中已经申请空间大小。通常你会看到allocated的值要比 ob_size 的值要大。这是为了避免每次有新元素加入list时都要调用realloc进行内存分配。接下来我们会看到更多关于这些的内容。

我们在list中追加一个整数:L.append(1)。发生了什么？调用了内部的C函数app1()

来让我们看下 list_resize() , list_resize() 会申请多余的空间以避免调用多次 list_resize() 函数，list增长的模型是:0, 4, 8, 16, 25, 35, 46, 58, 72, 88, …

开辟了四个内存空间来存放list中的元素，存放的第一个元素是1。你可以从下图中看到L[0]指向了我们刚刚加进去的元素。虚线的框代表了申请了但是还没有使用(存储元素)的内存空间

现在我们在列表的第一个位置插入一个整数5:L.insert(1, 5),看看内部发生了什么。调用了ins1()

当你弹出list的最后一个元素：L.pop()。调用listpop()， list_resize 在函数listpop()内部被调用，如果这时 ob_size （译者注：弹出元素后）小于allocated（译者注：已经申请的内存空间）的一半。这时申请的内存空间将会缩小。

Pop的时间复杂度是O(1)

Python list对象有一个方法可以移除一个指定的元素。调用listremove()。

切开list和删除元素，调用了 list_ass_slice() （译者注：在上文slice list between element's slot and element's slot + 1被调用），来看下 list_ass_slice() 是如何工作的。在这里，低位为1 高位为2（译者注：传入的参数），我们移除在1号内存空间存储的数据5

Remove的时间复杂度为O(n)

文中list的sort部分没有进行翻译
核心部分

⑶ python常见数据类型

一,python整数类型所表示的数据。

1,一般用以表示一类数值:所有正整数,0和负整数;

2,整型作为最常用的,频繁参与计算的数据类型，在python3.5中解释器会自动在内存中创建-5-3000之间的（包含5，不包含3000）整型对象，也就是说在该范围内,相等都是同一个已经创建好的整型对象。范围之外的即使相等也表示不同对象，该特性随python版本而改变，不要过于依赖。

3,bool型继承了int型，他是int的子类。

4,Python2中有长整型long，数值范围更大，在python3中已取消，所有整型统一由int表示。

5,参与所有数值计算，数学运算，科学计算。这也是所有编程语言都有的数据类型，因为编程语言生而需要模拟人的思维，借助数学方式，自动计算、更好的解决大量重复性的事务，因此数值类型、整数类型在编程语言中不可或缺。

6,支持二进制(0b\0B开头),十进制,八进制(0o\0O),十六进制(0x\0X)

二，python整数和浮点型支持常规的数值运算

整数和浮点数都可参与的运算：+ - * / %（取余） //（整除） **（幂）

Python字符型：

python字符型表示的数据：
python3支持Unicode编码，由字母、数字和符号组成的形式就叫字符串，更接近或者相同与人们文字符号表示，因此在信息表示和传递时它也是最受认可的形式。在程序编写中也是非常常用，对应的可操作的方法也很多，很有意思。
字符串不可被修改，可以拼接等方法创建新字符串对象；
支持分片和下标操作；a[2:]
支持+拼接，*重复操作和成员关系in/not in；
表示形式：用单引号双引号包含起来的符号；a = str(‘sdfsdfsdf’) 或 r’\t\nabcd’ 原始字符，Bytes：b’abcd’；
6,字符串属于不可变数据类型，内部机制为了节省空间，相同的两个字符串表示相同的一个对象。a = ‘python’ b = ‘python’ a is b :True

二, 字符串支持的运算方法

1,capitalize() :首字母大写后边的字母小写 a = ‘abcd’ b = a.capitalize() b:Abcd

2,casefold() lower():字母转换为全小写

3,center(width,fillchar) :居中，width填补的长度；fillchar添加的字符

a = a.center(10,’_’) //’____abcd____’ 默认无fillchar填充空格

4,count(sub,star,end) :字母计数：sub要查询的字符

5,encode(encoding=’utf-8’,errors=’strict’) 设置编码

Errors :设置错误类型

6,endswith(suffix,star,end) : 若以suffix结尾返回True

7，expandtabs(8) :设置字符串中tab按键符的空格长度：’\tabcde’

8,find(sub,star,end) : 返回指定范围内的字符串下标，未找到返回-1

9，index(sub,star,end) :返回指定范围字符串下标未找到抛出异常

10，isalnum() :判断字符串是否是字母或数字，或字母和数字组合

11，isalpha() :判断是否全是字母

12，isdecimal() :判断字符串是否是十进制数值

13，isdigit() :判断字符串是否是数字

14，isidentifier() :判断字符串中是否包含关键字

15，islower() :判断是否全小写

16，isnumeric() :判断全是数字

17，isspace() :判断是否是空格

18，isupper() 判断是否大写

19，istitle() :判断是否首字母大写

20，join(iterable) :把可迭代对象用字符串进行分割：a.join(‘123’)

21,ljust(width,fillchar);rjust() :左对齐右对齐

22, upper() :将字符串改为大写

23，split(sep=None,maxsplit=-1) :分割一个字符串，被选中字符在字符串中删除

‘ab1cd1efg’.split(‘1’) :[‘ab’,’cd’,’efg’]

三，字符串格式化：按照规格输出字符串

format(*args,**kwargs) :args位置参数，kwargs关键字参数

‘{0:.1f}’.format(123.468) :格式化参数，小数点后保留1位四舍五入

四，字符串操作符%

1，%s :格式化字符串 ‘abcd%sdef’%’dddd’

2，%d:格式化整数

3，%o格式化无符号八进制

4，%x格式化无符号十六进制

5，%f格式化定点数

6, %e: 科学计数法格式化定点数

7，%g 根据值大小自动选%f,%e

8, %G E X :大写形式

五，格式化辅助命令：

m.n :m最小总宽度，n小数点后位数：’%12.4f’%23456.789

六，转义字符：字符串前r避免转义：r’\nhello\thi’

\n:换行符

\t:横向制表符

\':'

\":"

\b:退格符

\r:回车

\v:纵向制表符

\f:换页符

\o,\x:八进制和十六进制

\0:空字符串

Python列表list

一，Python的列表list类型表示的数据：

Python列表在cpython中被解释为长度可变的数组，用其他对象组成的连续数组。

列表中元素可以是相同或不同的数据类型；
当列表元素增加或删除时，列表对象自动进行扩展或收缩内存，保证元素之间没有缝隙，总是连续的。
Python中的列表是一个序列，也是一个容器类型
创建列表：a = []; b = [1,’python’]; c = list(); d = list((1,3,4,5))
支持切片操作list[start,stop,step]
python列表常用方法
1,append添加单个元素：list.append(object); //a.append(‘python’)

2,extend添加可迭代对象: list.extend(iterable); //a.extend(‘abcde’/[1,2,3])

3,insert 插入元素：list.insert(index,object): 在index下标前插入元素//a.insert(2,’python’)

4,clear 清空所有元素：list.clear() //a.clear()

5,pop 删除并返回一个元素：list.pop(index) //默认删除默认一个元素

remove 删除指定元素：list.remove(v) ,v元素不存在报错 //a.remove(‘c’)
7，count 返回这个值在列表中数量：list.count(value)

8, 浅拷贝一个新列表：list.()

9,sort:排序list.sort(reverse=False/True) :默认升序

排序函数：sorted(list)

10，reverse: 原地翻转：list.reverse()

11，index(value,star,stop) :指定范围内该值下标：list.index(2,0,5)

列表元素访问：
下标访问：list[1]
For循环遍历
通过下标修改元素：list[2 ] = ‘hello’
列表常用运算符：
1,比较运算符：从第一个元素开始对比

2，+ 拼接一个新列表：l1+ l2

3, 重复操作符：* ,多个列表拼接

成员关系操作符：in/ not in
逻辑运算符：and not or
列表常用的排序方法：
冒泡排序；选择排序；快速排序；归并排序

Python元组tuple

一，Python元组tuple数据类型表示的数据：

元组是受到限制的、不可改变的列表；
可以是同构也可以是异构；
元组是序列类型、是可迭代对象，是容器类型。
元组的创建: a = (1,2,3)或a=1,2,3; b = tuple(); c = tuple(iterable)
支持切片操作tuple[start,stop,step]

二，python元组常用方法

1,index(value,star,stop) :指定范围内该值下标：tuple.index(2,0,5)

2,count(value) ：值出现次数

三，支持运算：

1,比较运算符：从第一个元素开始对比

2，+ 拼接一个新元组：l1+ l2

3, 重复操作符：* ,多个元组拼接

4成员关系操作符：in/ not in

逻辑运算符：and not or
四，元组的访问

下标操作；
For循环遍历访问。

Python字典类型

一,Python字典dict表示的数据：{key:value}

可根据关键字：键快速索引到对应的值；
字典是映射类型，键值对一一对应关系，不是序列；
字典元素是无序的；
字典是可迭代对象，是容器类型；
字典的创建：k = {}; k1={‘keyword’:object}; k2 = dict();
K3 = dict(mapping); dict=(iterable)

二，字典的访问：

通过key：k[‘key’]

修改key对应的值：K[‘key’] = value

For循环遍历出来的是key；

For循环键值对：for I in d.items():

For 循环enumerate: for k,v in enumerate(k1):

In/not in 成员关系查询键不支持查值

三，字典常用方法

get(key,de):获取值：k.get(key,de) //若不存在则默认输出de
pop(k,de):删除一个键值对，不存在输出de，未设置报错；
keys() :返回字典所有key组成的序列：list(k.keys()) [1,2,3];
values():返回字典所有value组成的序列：list(k.values())
items():返回键值对组成的元组为元素的序列：（类set）list(k.items())
update(e):更新字典：e可是字典或两元素组成的单位元素序列：e=[(5,6),(7,8)];
k.update(e)

clear():清空字典；
popitem()删除某个键值对，若字典为空则报错
() :浅拷贝
10, fromkeys(iterable,value=None):从可迭代对象创建字典

{}.fromkeys([1,2,3]) -----{1:None,2:None,3:None}

11,setdefault(k,d=None) :若key不存在则生成一个键值对

k.setdefault(‘keyword’)

Python 集合set

集合表示的数据：
多个元素的无序组合，集合是无序的，集合元素是唯一的；
字典的键是由集合实现的；
集合是可迭代对象
集合创建：s = {1,2}; s1 = set(); s2 = set(iterable)
集合元素的访问：
For 循环将集合所有元素全部访问一遍，不重复

常用方法：
add(object):s.add(‘hi’) 向集合添加一个元素
pop() :弹栈，集合为空则报错：删除任意一个元素；
clear():清空集合，返回一个空集合对象；
remove(object):删除一个元素，不存在和报错：s.remove(‘hi’)
update(集合)：更新另一个集合，元素不存在则不更新；
() :浅拷贝
集合的运算：
交集：s1&s2;
差集,补集：s1-s2;
并集：s1|s2;
Issubset():判断是否是子集：s1.issubset(s2) s1是否s2的集合子集
Issuperset():判断是否是父集：s1.issuperset()
不可变集合：
Frozenset():返回一个空的不可变集合对象

Frozenset(iterable):

S = frozenset(iterable)

Python序列类型共同特性

一,序列类型共同特性

python序列类型有:str字符串,list列表,tuple元组
都支持下标索引，切片操作；
下标都是从0开始，都可通过下标进行访问；
拥有相同的操作符
二，支持的函数：

len(obj):返回对象长度；
list(iterable):将可迭代对象转为列表；
tuple(iterable):将可迭代对象转为元组；
str(ojb):将任何对象转为字符串形式；
max(iterable): python3中元素要是同类型，python2中元素可异构：max([‘a’,1])
min(iterable):和max类似；
sum(iterable,star=0),求可迭代对象和，默认star为0，元素不能为字符串
sorted(iterable,key=None,reverse=False)
s=[(‘a’,3),(‘b’,2),(‘c’,9)]

sorted(s,key=lambda s:s[1]) //按照数字排序

reversed(sequence):翻转序列，返回迭代器
enumerate(iterable):返回enumerate对象,其元素都是一个元组（下标，值）
zip（iter1,iter2）: zip([1,2],[3,4]) ----[(1,3),(2,4)]

序列类型的切片操作：

Slice:

L[index]; 访问某个元素；

L[1:4]; 区间

L[star:stop:step]; 设置步长取区间元素

⑷ java中如何将list集合清空

java中将集合清空可以用clear方法。

下面演示用法，代码如下

public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
System.out.println(list);
list.clear();
System.out.println(list);
}

(4)pythonlist清空扩展阅读，集合的方法

boolean add(Object o)添加对象到集合

boolean remove(Object o)删除指定的对象

int size()返回当前集合中元素的数量

boolean contains(Object o)查找集合中是否有指定的对象

boolean isEmpty()判断集合是否为空

Iterator iterator()返回一个迭代器

boolean containsAll(Collection c)查找集合中是否有集合c中的元素

boolean addAll(Collection c)将集合c中所有的元素添加给该集合

void clear()删除集合中所有元素

void removeAll(Collection c)从集合中删除c集合中也有的元素

void retainAll(Collection c)从集合中删除集合c中不包含的元素

⑸ python删除列表list中所有的零0元素

本来以为实现这个东西还不是小菜一碟，结果发现这个小东西竟然有坑，哼！

这个方法一是没坑的方法，亲测有效：

方法一：

list=[1,0,0,2]

lis=[]

for i  in list:

    if i!=0:

        lis.append(i)

print(lis)

注意：千万不要用下面方法二和方法三这两个方法！是个坑人的坑！（生气）

方法二：

list=[1,0,0,2]

for i  in list:

    if i==0:

        list.remove(i)

print(list)

方法三：

list=[1,0,0,2]

list.remove(0)

print(list)

⑹ python字典转换为list后选中最后一个值

设为星标，第一时间获取更多干货

在python中，数据类型主要由以下几类组成：

列表(list): [a, b]

元组(tuple)：(a, b, )

集合(set)： {a, b}

字典(Dictonary): {a: ‘aaa’, b: ‘bbb’}

1. 列表

列表(List)

列表是Python中使用最频繁的数据类型，专门用于存储一串信息

列表是一种有序和可更改的集合。允许重复的元素

列表使用[]定义，元素之间使用，分隔。例：[1,2, ...]

列表的索引从位置0开始

索引就是元素在列表中的位置编号，索引又可以被称为下标

注意：从列表中取值时，如果超过索引范围，程序会报错

虽然列表可以存储不同类型元素，但是曰常中一般存储相同类型的元素

如何使用列表

列表[索引]: 从列表中取值，获取指定索引的元素

列表[开始索引:结束索引:步长]:

返回从开始索引到结束索引-1的列表，如果设置步长，按步长跳过元素

len(列表): 获取列表的长度

元素 in 列表: 判断元素是否在列表中

列表.count(元素): 返回指定元素在列表中的个数

列表.index(元素): 返回指定元素在列表中第一次出现的索引，查找失败时报错

列表.sort(): 从小到大排序，括号内增加reverse=True ,则是从大到小排序

列表_reverse(): 逆序(反转)列表

列表.clear(): 清空列表

Eg:

# 0 init listL = [1, 2, 3, 4, 5, 7, 6]# 1 index valueL[1] # --> 2# 2 stepL[2: 5: 2] # --> [3, 5]# 3 lengthlen(L) # --> 6# 4 in6 in L # ---> True8 in L # ---> False# 5 countL.count(1) # ---> 1# 6 indexL.index(2) # ---> 1# 7 sortL.sort() # ---> [1, 2, 3, 4, 5, 6, 7] 注意：会改变自己 返回None # 8 reverseL.reverse() # 由于第7步改变了自己， 这里变成[7, 6, 5, 4, 3, 2, 1] 会改变自己 返回None # 9. clearL.clear() # ---> []
列表特有的一些使用方法

L = [1, 2, 3, 4, 5]
列表[索引]=元素：修改指定索引的元素，索引不存在会报错

L[2] = 7 L # ---> [1, 2, 7, 4, 5]
列表 . append(元素)：在列表的末尾追加元素

L.append(6)L # ---> [1, 2, 7, 4, 5, 6]
列表 . insert(索引，元素)：在指定索引位置插入元素，索引不存在时在末尾追加

L.insert(3, 9)L # ---> [1, 2, 7, 4, 9, 5, 6]
列表.pop(索引)：

删除并返回指定索引的元素，未指定索引时删除最后一项，索引不存在时报错

L.pop(3) # 4, L 变成[1, 2, 7, 9, 5, 6]L.pop() # 6, L 变成[1, 2, 7, 9, 5]
列表 . remove(元素)：删除列表中第一个出现的指定元素，查找失败时报错

L.remove(2) # L 变成[1, 7, 9, 5]
del 列表[索引]: 删除指定索引位置的元素，索引不存在时报错

del L[3] # L 变成[1, 7, 9]
列表l.extend(列表2): 将列表2拼接在列表1后

L.extend([8, 9, 10]) L # L 变成[1, 7, 9, 8, 9, 10], 等价于 L = L + [8, 9, 10]
2. 元组

元组(Tuple)

元组是一种有序且不可更改的集合, 允许重复的成员

元组与列表的类似，不同之处在于元组元素不可修改

元组使用()定义，元素之间使用,分隔。例：(a, b, …)

元组中只包含一个元素时，可以省略()，只需要在元素后加逗号

init_tuple = 100,type(init_tuple) # ---> tuple# ---- 另外写法init_tuple = (100, ) # 逗号一定要加
注意：如果一个非元组类型的数据突然变成元组，检查是不是误加了逗号

集合与元组的通用方法

元组[索引]:从元组中取值，获取指定索弓丨的元素

元组[开始索引:结束索引:步长]:

返回从开始索引到结束索引-1的元组，如果设置步长，按步长跳过元素

len(元组)：获取元组的长度

元素in元组：判断元素是否在元组中

元组.count(元素)：返回指定元素在元组中的个数

元组.index(元素)：返回指定元素在元组中第一次出现的索引，查找失败会报错

元组和列表之间的转换

list(元组)：将元组转换成列表

tuple(列表): 将列表转换成元组

3. 集合

集合(Set)

集合是一种无序和无索引的序列。没有重复的元素

集合会自动删除重复的元素，一般应用于去重、交并差运算场景

集合使用{}定义，元素之间使用，分隔。例：{a, b, …}

集合与列表的通用方法

len(集合)：获取集合的长度

元素in集合：判断元素是否在集合中

集合.clear(): 清空集合

集合特有的使用方法

s = {1, 2, 3}

集合.add(元素)：将元素添加到集合中

s.add(5) # ---> {1, 2, 3, 5}
集合1.update(集合2): 添加新的元素或集合到当前集合中

s.add{4, 5, 6} # ---> {1, 2, 3, 5, 4, 6}
集合.remove(元素): 删除指定的元素，元素不存在时报错

s.remove(4) # ----> {1, 2, 3, 5, 6}
集合1&集合2 : 交集，获得由集合1和集合2中都存在的元素组成的新集合

s & {3, 4, 5} # ---> {3, 5}
集合1|集合2: 并集，获得集合1和集合2中所有元素的新集合

s | {8, 9, 10} # ---> {1, 2, 3, 5, 6, 8, 9, 10}
集合1 - 集合2 : 差集，获得在集合1中存在但是在集合2中不存在的元素集合

s - {9, 10} # ---> {1, 2, 3, 5, 6, 8}
集合和列表之间的转换(也可以和元组进行转换，方式类似)

list(集合)：将集合转换成列表

set(列表)：将列表转换成集合

⑺ python语句list执行结果

Python语句list(range(1,10,3))执行结果为[1,4,7]。

语法是:range(start,stop[,step])

参数说明：

（1）start:计数从start开始，默认是从0开始。例如range(5)等价于range(0,5);

（2）stop:计数到stop结束，但不包括stop。例如：range(0,5)是[0,1,2,3,4]没有5;

（3）step：步长，默认为1。例如：range(0,5)等价于range(0,5,1)。

因此，range(1,10,3)的意思是1到10之间的tuple，间隔为3，所以结果是(1,4,7)。

列表(List)是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。

所以，list(range(1,10,3))执行结果为[1,4,7]。

(7)pythonlist清空扩展阅读

Python列表函数&方法

Python包含以下函数：

1、乱运cmp(list1, list2)：比较两个列表的元素；

2、len(list)：列表元素个数；

3、max(list)：返回列表元素最大值；

4、min(list)：返回列表元素最小值；

5、list(seq)：将元组转换为列表。

Python包含以下方法：

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)：对原列表进行排序。

⑻ 如何把列表外的列表移除python

python的列表list可以用for循环进行遍历，实际开发中发现一个问题，就是遍历的时候删除会出错，例如
l = [1,2,3,4]
for i in l:
if i != 4:
l.remove(i)
print l
这几句话本来意图是想清空列表l，只留元素4，但是实际跑起来并不是那个结果。再看下面，利用index来遍历删除列表l

l = [1, 2, 3, 4]
for i in range(len(l)):
if l[i] == 4:
del l[i]

print l
这样没问题，可以遍历删除，但是列表l如果变为 l = [1,2,3,4,5]
如果还是按照上面的方法，设想一下，range开始的范围是0-4，中间遍历的时候删除了一个元素4，这个时候列表变成了= [1,2,3,5],这时候就会报错了，提示下标超出了数组的表示，原因就是上面说的遍历的时候删除了元素

所以python的list在遍历的时候删除元素一定要小心

可以使用filter过滤返回新的list

l = [1,2,3,4]
l = filter(lambda x:x !=4,l)
print l

这样可以安全删除l中值为4的元素了，filter要求两个参数，第一个是规则函数，第二个参数要求输入序列，而lambda这个函数的作用就是产生一个函数，是一种紧凑小函数的写法，一般简单的函数可以这么些

或者可以这样
l = [1,2,3,4]
l = [ i for i in l if i !=4]//同样产生一个新序列，复值给l
print l

或者干脆建立新的list存放要删除的元素
l = [1,2,3,4]
dellist = []
for i in l:
if i == 4:
dellist.append(i)
for i in dellist:
l.remove(i)
这样也能安全删除元素
所以要遍历的时候删除元素一定要小心，特别是有些操作并不报错，但却没有达到预期的效果

上面说到产生新序列，赋值等等，用python的id()这个内置函数来看对象的id,可以理解为内存中的地址，所以有个简要说明
如果
l = [1,2,3,4]
ll = l
l.remove(1)
print l//肯定是[2,3,4]
print ll//这里会是什么？
如果用id函数查看的话就发现
print id(l),id(ll)
打印出相同的号码，说明他们其实是一个值，也就是说上面的print ll将和l打印的一样，所以python有这种性质，用的时候注意一下就行了

⑼ python删除list列表多个指定位置中的元素

li1=[12,3,4,5,2,34,5,6,7,3,5,6,66]
removelist=[1,2,4,5]
x=0
foryinremovelist:
	li1.pop(y-x)
	x+=1
printli1

这样有一个要求就是removelist里面的数字必须是从小到大的顺序排列的，