Python中实现对list做减法操作介绍,python减法

问题描述:假设我有这样两个list,

          一个是list1,list1 = [1, 2, 3, 4, 5]
          一个是list2,list2 = [1, 4, 5]
          我们如何得到一个新的list,list3,
          list3中包括所有不在list2中出现的list1中的元素。
          即:list3 = list1 – list2
         
解决方案:我们可以用set(集合)操作
          list3 = list(set(list1) – set(list2))
         
          set操作会将一个list转换成一个集合。
          假设:list_t = [1, 2, 3, 1]
          那么:list(set(list_t)) = [1, 2, 3]
          是的,重复的项会被删除。

其他方案:list3 = [i for i in list1 if i not in list2]      
#可用于list分片
          这样写也很直观。
          但是在list很大的时候,没有set方法快。

额外知识:a = [[i,j] for i in range(2) for j in range(3)]
          这个和“其他方案”非常相似,
          都是在[]里面进行判断和计算。
          感觉很方便,至少比下面这样要方便、要快:
          a = []
          for i in range(2):
              for j in range(3):
                  a.append([i,j])

某些问题:如果list_tmp = [[1,2],[2,3]]
          即list里面不是单独的元素组成,而是list,
          那么set(list_tmp)会出问题。

还要研究:hash函数

问题描述: 假设我有这样两个list, 一个是list1,list1 = [1, 2, 3, 4, 5]
一个是list2,list2 = [1, 4,…

python 中对list做减法操作,python减法

问题描述:假设我有这样两个list,
          一个是list1,list1 = [1, 2, 3, 4, 5]
          一个是list2,list2 = [1, 4, 5] 
          我们如何得到一个新的list,list3,
          list3中包括所有不在list2中出现的list1中的元素。
          即:list3 = list1 – list2
          
解决方案:我们可以用set(集合)操作
          list3 = list(set(list1) – set(list2))
          
          set操作会将一个list转换成一个集合。
          假设:list_t = [1, 2, 3, 1]
          那么:list(set(list_t)) = [1, 2, 3]
          是的,重复的项会被删除。

其他方案:list3 = [i for i in list1 if i not in list2]      
#可用于list分片
          这样写也很直观。
          但是在list很大的时候,没有set方法快。

额外知识:a = [[i,j] for i in range(2) for j in range(3)]
          这个和“其他方案”非常相似,
          都是在[]里面进行判断和计算。
          感觉很方便,至少比下面这样要方便、要快:
          a = []
          for i in range(2):
              for j in range(3):
                  a.append([i,j])

某些问题:如果list_tmp = [[1,2],[2,3]]
          即list里面不是单独的元素组成,而是list,
          那么set(list_tmp)会出问题。

还要研究:hash函数

Python 中 list 的各项操作技巧,python操作技巧

最近在学习 python 语言。大致学习了 python 的基础语法。觉得 python
在数据处理中的地位和它的 list 操作密不可分。

特学习了相关的基础操作并在这里做下笔记。

'''
Python --version Python 2.7.11
Quote : https://docs.python.org/2/tutorial/datastructures.html#more-on-lists
Add by camel97 2017-04
'''
list.append(x) #在列表的末端添加一个新的元素
Add an item to the end of the list; equivalent to a[len(a):] = [x].

list.extend(L)#将两个 list 中的元素合并到一起

Extend the list by appending all the items in the given list; equivalent
to a[len(a):] = L.

list.insert(i, x)#将元素插入到指定的位置(位置为索引为 i
的元素的前面一个)
Insert an item at a given position. The first argument is the index of
the element before which to insert, so a.insert(0, x) inserts at the
front of the list, and a.insert(len(a), x) is equivalent to a.append(x).

list.remove(x)#删除 list 中第一个值为 x 的元素(即如果 list 中有两个 x
, 只会删除第一个 x )

Remove the first item from the list whose value is x. It is an error if
there is no such item.

list.pop([i])#删除 list 中的第 i 个元素并且返回这个元素。如果不给参数
i ,将默认删除 list  中最后一个元素
Remove the item at the given position in the list, and return it. If no
index is specified, a.pop() removes and returns the last item in the
list. (The square brackets around the i in the method signature denote
that the parameter is optional, not that you should type square brackets
at that position. You will see this notation frequently in the Python
Library Reference.)

list.index(x)#返回 list 中 , 值为 X 的元素的索引

   Return the index in the list of the first item whose value is x.
It is an error if there is no such item.

list.count(x)#返回 list 中 , 值为 x 的元素的个数

Return the number of times x appears in the list.

demo:

#-*-coding:utf-8-*-
L = [1,2,3]   #创建 list 
L2 = [4,5,6]
print L
L.append(6)   #添加
print L
L.extend(L2) #合并
print L
L.insert(0,0) #插入
print L
L.remove(6)   #删除
print L
L.pop()     #删除
print L
print L.index(2)#索引
print L.count(2)#计数
L.reverse()   #倒序
print L

result:

[1, 2, 3]
[1, 2, 3, 6]
[1, 2, 3, 6, 4, 5, 6]
[0, 1, 2, 3, 6, 4, 5, 6]
[0, 1, 2, 3, 4, 5, 6]
[0, 1, 2, 3, 4, 5]
2
1
[5, 4, 3, 2, 1, 0]

list.sort(cmp=None, key=None, reverse=False)

  Sort the items of the list in place (the arguments can be used for
sort customization, see sorted() for their explanation).

1.对一个 list 进行排序。默认按照从小到大的顺序排序

L = [2,5,3,7,1]
L.sort()
print L
==>[1, 2, 3, 5, 7]
L = ['a','j','g','b']
L.sort()
print L
==>['a', 'b', 'g', 'j']

2.reverse 是一个 bool 值. 默认为 False , 如果把它设置为 True, 那么这个
list 中的元素将会被按照相反的比较结果(倒序)排列.

#  reverse is a boolean value. If set to True, then the list elements
are sorted as if each comparison were reversed.

L = [2,5,3,7,1]
L.sort(reverse = True)
print L
==>[7, 5, 3, 2, 1]
L = ['a','j','g','b']
L.sort(reverse = True)
print L
==>['j', 'g', 'b', 'a']

3.key 是一个函数 , 它指定了排序的关键字 , 通常是一个 lambda 表达式
或者 是一个指定的函数

#key specifies a function of one argument that is used to extract a
comparison key from each list element: key=str.lower. The default value
is None (compare the elements directly).

#-*-coding:utf-8-*-
#创建一个包含 tuple 的 list 其中tuple 中的三个元素代表名字 , 身高 , 年龄
students = [('John', 170, 15), ('Tom', 160, 12), ('Dave', 180, 10)]
print students
==>[('John', 170, 15), ('Tom', 160, 12), ('Dave', 180, 10)]
students.sort(key = lambda student:student[0])
print students
==>[('Dave', 180, 10), ('John', 170, 15), ('Tom', 160, 12)]#按名字(首字母)排序
students.sort(key = lambda student:student[1])
print students
==>[('Tom', 160, 12), ('John', 170, 15), ('Dave', 180, 10)]#按身高排序
students.sort(key = lambda student:student[2])
print students
==>[('Dave', 180, 10), ('Tom', 160, 12), ('John', 170, 15)]#按年龄排序

4.cmp 是一个指定了两个参数的函数。它决定了排序的方法。

#cmp specifies a custom comparison function of two arguments (iterable
elements) which should return a negative, zero or positive number
depending on whether the first #argument is considered smaller than,
equal to, or larger than the second argument: cmp=lambda x,y:
cmp(x.lower(), y.lower()). The default value is None.

#-*-coding:utf-8-*-
students = [('John', 170, 15), ('Tom', 160, 12), ('Dave', 180, 10)]
print students
==>[('John', 170, 15), ('Tom', 160, 12), ('Dave', 180, 10)]
#指定 用第一个字母的大写(ascii码)和第二个字母的小写(ascii码)比较
students.sort(cmp=lambda x,y: cmp(x.upper(), y.lower()),key = lambda student:student[0])
print students
==>[('Dave', 180, 10), ('Tom', 160, 12), ('John', 170, 15)]
#指定 比较两个字母的小写的 ascii 码值
students.sort(cmp=lambda x,y: cmp(x.lower(), y.lower()),key = lambda student:student[0])
print students
==>[('Dave', 180, 10), ('John', 170, 15), ('Tom', 160, 12)]
#cmp(x,y) 是python内建立函数,用于比较2个对象,如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1

cmp 可以让用户自定义大小关系。平时我们认为 1 < 2 , 认为 a < b。

现在我们可以自定义函数,通过自定义大小关系(例如 2 < a < 1 <
b) 来对 list 进行指定规则的排序。

当我们在处理某些特殊问题时,这往往很有用。

以上所述是小编给大家介绍的Python 中 list
的各项操作技巧,希望对大家有所帮助,如果大家有任何疑问请给我留言,小编会及时回复大家的。在此也非常感谢大家对帮客之家网站的支持!

中 list 的各项操作技巧,python操作技巧
最近在学习 python 语言。大致学习了 python 的基础语法。觉得 python
在数据处理中的地位和它的…

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

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

python list操作

就是用类型转换啊

for i in list:
list2[int(float(i[0])*10)]=i
print list2
 

>>> L = []
>>> L.append(1)
>>> L.append(2)
>>> L.append(3)
>>> L
[1, 2, 3]
>>> for e in L:
...   print e
... 
1   
2   
3   
>>> L = []
>>> L.append(1)
>>> L.append(2)
>>> L.append(3)
>>> L
[1, 2, 3]
>>> for e in L:
...   print e
... 
1   
2   
3   

python list 操作

我来回答吧

for index in range(len(list)):
list[index]=int(10*list[index])
print list

#你现在就可以看到你满意的结果了啊。我试验了一下,没有问题的
 

中对list做减法操作,python减法
问题描述:假设我有这样两个list, 一个是list1,list1 = [1, 2, 3, 4, 5]
一个是list2,list2 = [1, 4, 5] 我们如何…

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

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

List对象的C结构

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

typedef struct {
    PyObject_VAR_HEAD
    PyObject **ob_item;
    Py_ssize_t allocated;
} PyListObject;

List对象的C结构

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

typedef struct {
    PyObject_VAR_HEAD
    PyObject **ob_item;
    Py_ssize_t allocated;
} PyListObject;

List的初始化

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

arguments: size of the list = 0
returns: list object = []
PyListNew:
    nbytes = size * size of global Python object = 0
    allocate new list object
    allocate list of pointers (ob_item) of size nbytes = 0
    clear ob_item
    set list's allocated var to 0 = 0 slots
    return list object 

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

List的初始化

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

arguments: size of the list = 0
returns: list object = []
PyListNew:
    nbytes = size * size of global Python object = 0
    allocate new list object
    allocate list of pointers (ob_item) of size nbytes = 0
    clear ob_item
    set list's allocated var to 0 = 0 slots
    return list object 

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

Append

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

arguments: list object, new element
returns: 0 if OK, -1 if not
app1:
    n = size of list
    call list_resize() to resize the list to size n+1 = 0 + 1 = 1
    list[n] = list[0] = new element
    return 0

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

arguments: list object, new size
returns: 0 if OK, -1 if not
list_resize:
    new_allocated = (newsize >> 3) + (newsize < 9 ? 3 : 6) = 3
    new_allocated += newsize = 3 + 1 = 4
    resize ob_item (list of pointers) to size new_allocated
    return 0

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

图片 1

我们继续加入一个元素:L.append(2)。调用list_resize,同时n+1=2。但是因为allocated(译者注:已经申请的空间大小)是4。所以没有必要去申请新的内存空间。相同的事情发生在再次在list中添加两个元素的时候:
L.append(3),L.append(4)。下图展示了到目前为止我们做了什么。

图片 2

Append

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

arguments: list object, new element
returns: 0 if OK, -1 if not
app1:
    n = size of list
    call list_resize() to resize the list to size n+1 = 0 + 1 = 1
    list[n] = list[0] = new element
    return 0

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

arguments: list object, new size
returns: 0 if OK, -1 if not
list_resize:
    new_allocated = (newsize >> 3) + (newsize < 9 ? 3 : 6) = 3
    new_allocated += newsize = 3 + 1 = 4
    resize ob_item (list of pointers) to size new_allocated
    return 0

开辟了四个内存空间来存放list中的元素,存放的第一个元素是1。你可以从下图中看到L[0]指向了我们刚刚加进去的元素。虚线的框代表了申请了但是还没有使用(存储元素)的内存空间
图片 3
我们继续加入一个元素:L.append(2)。调用list_resize,同时n+1=2。但是因为allocated(译者注:已经申请的空间大小)是4。所以没有必要去申请新的内存空间。相同的事情发生在再次在list中添加两个元素的时候:
L.append(3),L.append(4)。下图展示了到目前为止我们做了什么。
图片 4

Insert

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

arguments: list object, where, new element
returns: 0 if OK, -1 if not
ins1:
    resize list to size n+1 = 5 -> 4 more slots will be allocated
    starting at the last element up to the offset where, right shift each element 
    set new element at offset where
    return 0  

图片 5

虚线框表示已经申请但是没有使用的内存。申请了8个内存空间但是list实际用来存储元素只使用了其中5个内存空间
insert的时间复杂度是O(n)

Insert

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

arguments: list object, where, new element
returns: 0 if OK, -1 if not
ins1:
    resize list to size n+1 = 5 -> 4 more slots will be allocated
    starting at the last element up to the offset where, right shift each element 
    set new element at offset where
    return 0  

图片 6
虚线框表示已经申请但是没有使用的内存。申请了8个内存空间但是list实际用来存储元素只使用了其中5个内存空间
insert的时间复杂度是O(n)

Pop

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

arguments: list object
returns: element popped
listpop:
    if list empty:
        return null
    resize list with size 5 - 1 = 4. 4 is not less than 8/2 so no shrinkage
    set list object size to 4
    return last element

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

图片 7

你可以发现4号内存空间指向还指向那个数值(译者注:弹出去的那个数值),但是很重要的是ob_size现在却成了4.
让我们再弹出一个元素。在list_resize内部,size – 1 = 4 – 1 = 3
比allocated(已经申请的空间)的一半还要小。所以list的申请空间缩小到
6个,list的实际使用空间现在是3个(译者注:根据(newsize >> 3) +
(newsize < 9 ? 3 : 6) = 3在文章最后有详述)
你可以发现(下图)3号和4号内存空间还存储着一些整数,但是list的实际使用(存储元素)空间却只有3个了。

图片 8

Pop

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

arguments: list object
returns: element popped
listpop:
    if list empty:
        return null
    resize list with size 5 - 1 = 4. 4 is not less than 8/2 so no shrinkage
    set list object size to 4
    return last element

Pop的时间复杂度是O(1)
图片 9
你可以发现4号内存空间指向还指向那个数值(译者注:弹出去的那个数值),但是很重要的是ob_size现在却成了4.
让我们再弹出一个元素。在list_resize内部,size – 1 = 4 – 1 = 3
比allocated(已经申请的空间)的一半还要小。所以list的申请空间缩小到
6个,list的实际使用空间现在是3个(译者注:根据(newsize >> 3) +
(newsize < 9 ? 3 : 6) = 3在文章最后有详述)
你可以发现(下图)3号和4号内存空间还存储着一些整数,但是list的实际使用(存储元素)空间却只有3个了。
图片 10

Remove

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

arguments: list object, element to remove
returns none if OK, null if not
listremove:
    loop through each list element:
    if correct element:
        slice list between element's slot and element's slot + 1
        return none
    return null

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

arguments: list object, low offset, high offset
returns: 0 if OK
list_ass_slice:
    copy integer 5 to recycle list to dereference it
    shift elements from slot 2 to slot 1
    resize list to 5 slots
    return 0

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

图片 11

Remove

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

arguments: list object, element to remove
returns none if OK, null if not
listremove:
    loop through each list element:
    if correct element:
        slice list between element's slot and element's slot + 1
        return none
    return null

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

arguments: list object, low offset, high offset
returns: 0 if OK
list_ass_slice:
    copy integer 5 to recycle list to dereference it
    shift elements from slot 2 to slot 1
    resize list to 5 slots
    return 0

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

译者注:

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

我们能看到 Python 设计者的苦心。在需要的时候扩容,但又不允许过度的浪费,适当的内存回收是非常必要的。
这个确定调整后的空间大小算法很有意思。
调整后大小 (new_allocated) = 新元素数量 (newsize) + 预留空间 (new_allocated)
调整后的空间肯定能存储 newsize 个元素。要关注的是预留空间的增长状况。
将预留算法改成 Python 版就更清楚了:(newsize // 8) + (newsize < 9 and 3 or 6)。
当 newsize >= allocated,自然按照这个新的长度 "扩容" 内存。
而如果 newsize < allocated,且利用率低于一半呢?
allocated    newsize       new_size + new_allocated
10           4             4 + 3
20           9             9 + 7
很显然,这个新长度小于原来的已分配空间长度,自然会导致 realloc 收缩内存。(不容易啊)
引自《深入Python编程》

译者注:

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

我们能看到 Python 设计者的苦心。在需要的时候扩容,但又不允许过度的浪费,适当的内存回收是非常必要的。
这个确定调整后的空间大小算法很有意思。
调整后大小 (new_allocated) = 新元素数量 (newsize) + 预留空间 (new_allocated)
调整后的空间肯定能存储 newsize 个元素。要关注的是预留空间的增长状况。
将预留算法改成 Python 版就更清楚了:(newsize // 8) + (newsize < 9 and 3 or 6)。
当 newsize >= allocated,自然按照这个新的长度 "扩容" 内存。
而如果 newsize < allocated,且利用率低于一半呢?
allocated    newsize       new_size + new_allocated
10           4             4 + 3
20           9             9 + 7
很显然,这个新长度小于原来的已分配空间长度,自然会导致 realloc 收缩内存。(不容易啊)

引自《深入Python编程》

 

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图