上关于列表操作被访问最多的10个问答,数据之间

作者: 编程  发布:2019-09-21

2019-02-26

一、概述:Python中两种基本的数据结构是序列和映射,序列包含:可变的列表和不可变的元组;而当序列不够用时就出现了映射:字典。列表中的元素是可以变化的,元组里面的元素一旦初始化后就不可更改。列表和元组只是一类元数据的集合体,还不能满足通过名字引用值的数据,故字典就充当了这个功能角色。

列表是最常用的数据类型之一,本文整理了 StackOverflow 上关于列表操作被访问最多的10个问答,如果你在开发过程中遇到这些问题,不妨先思考一下如何解决。

1、列表

数组:元素数据类型必须一致
列表:不要求数据类型一致,可以是整型、浮点型,也可以是字符串等

列表:
①创建方法:用‘[ ]’,将数据包括起来,数据之间用逗号隔开。
②空列表:empty = []
③增删改查:
  1)增加:
    a.append()方法——将元素添加到列表的末尾。

二、列表(list):

1、迭代列表时如何访问列表下标索引

1.1、创建列表

(1)、普通列表

>>>number = [1,2,3,4,5]

(2)、混合列表

>>> mix = [1,'python',[1,2,3]]

(3)、空列表

>>> empty = []

  测试代码:

1.写法示例:x=[1,2,3,4,5] y=['1','2','3','4','5']

普通版:

1.2、向列表添加元素

(1)、向末尾添加元素

单个元素 list.append()
多个元素 list.extend([])
>>> list = [1,2,3]
>>> list.append(4)
>>> list
[1, 2, 3, 4]
>>> list.extend([5,6])   #extend()方法是使用一个列表拓展另一个列表,所以其参数是列表
>>> list
[1, 2, 3, 4, 5, 6]

(2)、任意位置添加元素

list.insert(a, b)    #参数a:要插入的列表的位置,参数b:要插入的元素

>>> list = [1,2,3,4]
>>> list.insert(1, 'python')    #1为索引号
>>> list
[1, 'python', 2, 3, 4]
list = ["My","Name","Is"]list.append("PegasusK")

2.索引:

items = [8, 23, 45]

1.3、从列表中获取元素

(1)、获取单个元素
通过索引值获取单个元素,索引号从0开始

>>> color = ['blue', 'white', 'red']
>>> color[1]
'white'

>>> color[0], color[2] = color[2], color[0]
>>> color
['red', 'white', 'blue']    #元素对换位置

(2)、列表分片(获取多个元素)

list[a:b]    #参数a、b为索引值,a为开始位置,b是结束位置,不包括结束位置
>>> color = ['blue', 'white', 'red']
>>> color[0:2]   
['blue', 'white']

>>> color[:2]      #获取索引值2以前的元素,不包括2的元素
['blue', 'white']

>>> color[1:]       #获取索引值为1以后的元素,包括1的元素
['white', 'red']

>>> color[:]          #对原列表进行拷贝
['blue', 'white', 'red']

>>> list = [1,2,3,4,5,6,7,8,9]
>>> list[0:9:2]    # 列表分片第三个参数表示步进,默认为1
[1, 3, 5, 7, 9]

>>> list[::2]
[1, 3, 5, 7, 9]

>>> list[::-1]        # 第三个参数为复数则表示原列表原地翻转
[9, 8, 7, 6, 5, 4, 3, 2, 1]

>>> list[::-2]
[9, 7, 5, 3, 1]

  运行结果:

x[0]
=>1

for index in range(len(items)):

1.4、从列表删除元素

(1)、remove()方法
不需要知道元素所在列表的位置,参数为将要删除的元素

>>> num = [1,2,3]
>>> num.remove(2)
>>> num
[1, 3]

(2)、del[]语句
参数:所删除元素的索引值

>>> num1 = [1,2,3]
>>> del num1[1]
>>> num1
[1, 3]

>>> del num1                #删除整个列表

(3)pop()方法
默认弹出列表最后一个元素,其参数也可以接收索引值,进行弹出对应元素

>>> list = [1,2,3,4,5,6]
>>> list.pop()         # 默认弹出最后一个,并返回
6
>>> list
[1, 2, 3, 4, 5]
>>> list.pop(3)     # 指定索引值
4
['My', 'Name', 'Is', 'PegasusK']

y[0]
=>'1'

   print(index, "-->", items[index])

1.5、列表的常用操作符

>>> list1 = [123]
>>> list2 = [456]
>>> list3 = ['abc']
>>> list4 = ['bcd']
>>> list5 = [123,456]
>>> list6 = [234,123]
>>> list7 = list1 + list2     #连接操作符
>>> list7
[123, 456]
>>> list8 = list3 + list4
>>> list8
['abc', 'bcd']
>>> list1 < list2             #比较操作符
True
>>> list3 > list4
False
>>> list5 > list6         #包含多个元素的列表比较时,默认从第一个元素开始比较,若真则整个列表赢了,字符串比较是第一个字符的ASCII码值对比
False
>>> (list1 < list2) and (list1 == list3)     #逻辑操作符
False

>>> list1 = [123]    
>>> list1*2                     #重复操作符
[123, 123]

>>> list = [1,2,3,[4,5]]
>>> 1 in list              #成员操作符in、not in
True
>>> 6 not in list
True
>>> 4 in list         #列表中的列表元素不能直接访问
False
>>> 4 in list[3]     #列表中的列表元素访问可以添加索引号
True

>>> list = [1,2,3,[4,5]]   
>>> list[3][0]   #获取列表的列表元素,第一个参数为第一个列表索引值,第二个参数为第二个列表索引值
4

    b.Insert方法——A表示你想把元素添加在什么位置,B表示你想插入的元素。

3.分片:x[:]

>>>

1.6、列表的其他方法

查看所有列表:dir(list)
(1)、count()方法
计算其参数在列表中出现的次数

>>> list1 = [1,1,2,3,4,5,8]
>>> list1.count(1)
2

(2)、index()方法
返回其参数在列表中的位置

>>> list1.index(1)   #列表中两个相同元素,返回的为第一个的位置
0
>>> list1.index(3)
3

>>> list1.index(1, start,stop)  #设定索引范围,可以查找第二个目标位置
1

(3)、reverse()方法
将整个列表原地翻转

>>> list1.reverse()
>>> list1
[8, 5, 4, 3, 2, 1, 1]

(4)、sort()方法
用指定的方式对列表元素排序,默认为从小到大排序
从大到小排序时,可以使用sort排序后再使用reverse()方法翻转
另外可以使用sort()方法的第三个参数sort(func, key, reverse)
默认sort(reverse = False),表示不颠倒顺序。

>>> list2 = [2,1,4,6,3,9,8]
>>> list2.sort()
>>> list2
[1, 2, 3, 4, 6, 8, 9]

>>> list2.sort(reverse = True)   #True时表示颠倒顺序
>>> list2
[9, 8, 6, 4, 3, 2, 1]

(5)、copy()方法
与切片一样,不与原列表变化
(6)、clear()方法
清空整个列表,变成空列表

  测试代码:

=>[1,2,3,4,5]
x[0:3]

0 --> 8

1.7、关于列表分片的补充

列表分片与拷贝不与原列表变化而变化,新赋值的列表相反

>>> list1 = [1,3,4,2,7,9]
>>> list2 = list1[:]
>>> list2
[1, 3, 4, 2, 7, 9]
>>> list3 = list1
>>> list3
[1, 3, 4, 2, 7, 9]
>>> list1.sort()      # 对原列表从小到大排序
>>> list1
[1, 2, 3, 4, 7, 9]
>>> list2
[1, 3, 4, 2, 7, 9]       #切片的列表不变化
>>> list3                 #赋值的列表变化
[1, 2, 3, 4, 7, 9]
list = ["My","Name","Is"]

list.insert(1,"good")

=>[1,2,3]
x[0:4:2]
=>[1,3]

1 --> 23

  运行结果:

可以看出,第一个数字表示起始元素的索引值,第二个数字表示结束元素的值,但不包含它,第三个是步长。注意:这三个数字都可以是负值。

2 --> 45

['My', 'good', 'Name', 'Is']

4.序列相加:x+y

优雅版:

    c.extend方法——使用一个列表扩展另一个列表,所以参数L应该是一个列表,使用这个方法是向列表末尾添加多个元素。

=>[1, 2, 3, 4, 5, '1', '2', '3', '4', '5']

for index, item in enumerate(items):

  测试代码:

5.乘法:x*5

   print(index, "-->", item)

list = ["My","Name","Is"]

list.extend(["哎嘿嘿","偶呵呵"])

=>[1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5]

>>>

  运行结果:

6.成员资格:

0 --> 8

['My', 'Name', 'Is', '哎嘿嘿', '偶呵呵']

1 in x
=> True

1 --> 23

  2)删除:
    a.remove()——不需要知道该元素在列表中的位置,只需要知道要删除的元素在列表中就可以了。

6 in x

2 --> 45

  测试代码:

=> False

enumerate 还可以指定元素的第一个元素从几开始,默认是0,也可以指定从1开始:

list = ["My","Name","Is"]

list.remove

7.min,max,len:

for index, item in enumerate(items, start=1):

  运行结果:

min(x)
=>1

   print(index, "-->", item)

['My', 'Is']

max(x)
=>5

>>>

    b.del——能够删除列表中指定位置的元素(del是一个语句,并不是一个方法,所以不用加‘。此方式也能够删除整个列表。

len(x)
=>5

1 --> 8

  测试代码:

8.list函数:list('Hello')

2 --> 23

list = ["My","Name","Is"]

del list[0]

=>['H','e','l','l','o']

3 --> 45

  运行结果:

9.元素赋值:x[0]=11

2、append 与 extend 方法有什么区别

['Name', 'Is']

=> x=[11,2,3,4,5]

append表示把某个数据当做新元素追加到列表的最后面,它的参数可以是任意对象

    c.pop()——“弹出”元素,该方法默认弹出列表中的最后一个元素,可以添加一个索引值作为参数,会弹出这个索引值对应的元素。

10.删除元素:del x[0]

x = [1, 2, 3]

  测试代码:

=> x=[2,3,4,5]

y = [4, 5]

list = ["My","Name","Is"]

list.pop

11.分片赋值:x[0:3]=[11,22,33]

x.append(y)

  运行结果:

=> x=[11,22,33,4,5]

print(x)

['My', 'Name']

12.append: x.append(6)

>>>

  3)更改:

=> x=[1,2,3,4,5,6]

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

  测试代码:

13.count: 查找x中元素1出现的次数: x.count(1)

extend 的参数必须是一个可迭代对象,表示把该对象里面的所有元素逐个地追加到列表的后面

list = [1,4,2,5]

list[2] = 1500
print

=> 1

x = [1, 2, 3]

  运行结果:

14.extend:将一个列表追加到列表末尾: x.extend([6,7,8])

y = [4, 5]

[1, 4, 1500, 5]

=> x=[1,2,3,4,5,6,7,8]

x.extend(y)

  4)查找:
    a.count()——计算它的参数在列表中出现的次数。

15.index:找出某个元素的索引位置:x.index(2)=1

print(x)

  测试代码:

16.insert:将元素插入到指定索引前:x.insert(2,10)

>>>

list = [12,132,254,365,12,12,254]
num = list.count
print

=> x=[1,2,10,3,4,5]

[1, 2, 3, 4, 5]

  运行结果:

17.pop:移除列表中的一个元素,并返回这个元素: x.pop()

# 等价于:

3

=>5
x.pop(0)

for i in y:

    b.Index()——返回它的参数在列表中的位置。

=>1

   x.append(i)

  测试代码:

18.remove:移除列表中某个值的第一个匹配项:x.remove(1)

3、检查列表是否为空

list = [12,132,254,365,12,12,254]

num = list.index
print

=>x=[2,3,4,5]

普通版:

  运行结果:

19.reverse:反向存放:x.reverse() => x=[5,4,3,2,1]

if len(items) == 0:

1

20.sort,sorted:将列表排序:x.reverse()

   print("空列表")

    c.In,not in——判断一个层次的成员关系,如果列表里面还有列表,通过索引值用和二维数组类似的方式访问列表里面的列表。

=> x=[5,4,3,2,1]

或者

  测试代码:

=> x.sort()

if items == []:

list = [12,132,254,365,12,12,254]

print(12 in list)
print(12 not in list)

=> x=[1,2,3,4,5]

   print("空列表")

  运行结果:

注意:sort并不返回任何值,即:

优雅版:

True
False

z=x.sort()

if not items:

④列表分片:
  1)格式:Lsit[1 :3]——左边索引值是开始位置,右边索引值是结束位置(结束位置上的元素是不包含的)。

=>z = None.

   print("空列表")

  测试代码:

如果你想对x排序,并且要保留x,有两种方法共选择:

4、如何理解切片

list = ["age","name","school","sd"]
list2 = list[1:3]
print

(1)z=x[:]

切片用于获取列表中指定范的子集,语法非常简单

  运行结果:

z.sort()

items[start:end:step]

['name', 'school']

=> z=[5,4,3,2,1]

从 start 到 end-1 位置之间的元素。step 表示步长,默认为1,表示连续获取,如果 step 为 2 就表示每隔一个元素获取。

  2)注意:
    a.利用列表分片,得到原来一个列表的拷贝,而原来的列表并没有发生改变。
    b.没有开始位置,Python会默认开始位置是0,如果从指定位置到列表末尾,则可以省去结束位置。
    c.分片也可以接收第三个参数,其表示步长,默认情况下为1,如果步长设置为-1,则列表反转。

(2)z=sorted(x)

a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

  测试代码:

21.高级排序:如果你希望按照某种特定的方式排序,可以将函数、方法名作为参数传递给sort.

>>> a[3:8] # 第3到第8位置之间的元素

list = ["age","name","school","sd"]
list2 = list[::2]
list3 = list[::-1]
print
print

x.sort(key=cmp,reverse=True) ,其中key和reverse叫做关键字参数,所以您也可以这样写:x.sort(reverse=True,key=cmp),也就是关键字参数可以任意调整参数顺序。

[4, 5, 6, 7, 8]

  运行结果:

说明:函数cmp(a,b),a>b =>1 , a<b =>-1, a=b =>0

>>> a[3:8:2] # 第3到第8位置之间的元素,每隔一个元素获取

['age', 'school']
['sd', 'school', 'name', 'age']

任何适用于列表内元素的函数都可以作为key值传递进去,当然你也可以传递自定义的函数,个人感觉很像.net里面的委托。

[4, 6, 8]

⑤其他:
  1)列表的比较:当列表中存在较多个元素时,默认从第一个元素开始比较,第一个元素大,就算整个列表大。(字符串同样的道理,只不过字符串比较的是第一个字符对应的ASCII码值的大小。)

三、元组

>>> a[:5]   # 省略start表示从第0个元素开始

  测试代码:

元组不可修改,字符串也是不可修改的,这个.net中的字符串是一个意思,每次对字符使用+时,都是重新申请了一段新的地址空间,所以我们在处理字符串频繁修改型程序时一般都用StringBuilder.

[1, 2, 3, 4, 5]

list = ["age","name"]
list2 = ["school","work"]
print(list > list2)
print(list < list2)

由于元组和列表最大的不同就是不可修改,所以列表中的 9.元素赋值,10.删除元素,11.分片赋值,12.append,14.extend,16.insert,17.pop,18.remove,19.reverse,20.sort,21.高级排序任何妄图修改元组的函数都不支持。

>>> a[3:]  # 省略end表示到最后一个元素

  运行结果:

1.写法:x=1,2,3,4,5 或者 x=(1,2,3,4,5) 或者

[4, 5, 6, 7, 8, 9, 10]

False
True

x=1, =>x =(1)

>>> a[::]  # 都省略相当于拷贝一个列表,这种拷贝属于浅拷贝

  2)乘号也叫重复操作符,它也可以应用在列表中,相当于拷贝列表元素,多次写入列表中。

2.乘法:

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

  测试代码:

x=(1,2,3,4,5)

5、如何拷贝一个列表对象

list = ["age","name"]
print

x*3

第一种方法:

  运行结果:

=>(1,2,3,4,5,1,2,3,4,5,1,2,3,4,5)

new_list = old_list[:]

['age', 'name', 'age', 'name', 'age', 'name']

3.tuple:tuple函数和list函数基本一致:tuple('Hello')

第二种方法:

  3)reverse()——列表原地翻转。

=>('H','e','l','l','o')

new_list = list(old_list)

  测试代码:

4.索引:元组也是序列的一种,所以他也可以用索引来访问元素:

第三种方法:

list = ["age","name","school","sd"]
list.reverse()
print

x[0]

import copy

  运行结果:

=> 1

# 浅拷贝

['sd', 'school', 'name', 'age']

5.分片:元组也是序列的一种,所以他也可以用索引来分片:

new_list = copy.copy(old_list)

  4)sort()——指定的方式对列表的成员进行排序,默认不需要参数,从小到大排序。方法其实有三个参数,形式为sort(func,key,reverse),func默认使用归并排序的排序算法,key为关键字。)
  sort(reversr = False)表示不颠倒顺序,把False改为True,列表就相当于从大到小排序。

x[0:2]

# 深拷贝

  测试代码:

=>(1,2)

new_list = copy.deepcopy(old_list)

list = [5,7,3,9,1234]
list.sort()
print
list.sort(reverse=True)
print

6.成员资格: 1 in x

6、如何获取列表中的最后一个元素

  运行结果:

=> True

索引列表中的元素不仅支持正数还支持负数,正数表示从列表的左边开始索引,负数表示从列表的右边开始索引,获取最后一个元素有两种方法。

[3, 5, 7, 9, 1234]
[1234, 9, 7, 5, 3]

6 in x

>>> a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

⑥注意:
  为一个列表指定另一个名字的做法,相当于给同一个列表加上不同的标签,真正的拷贝要使用分片的方法。

=> False

>>> a[len(a)-1]

  测试代码:

7.min,max,len: min(x)

10

list = [1,4,2,5]list2 = list[:]list3 = listlist.sort()printprintprint

=>1

>>> a[-1]

  运行结果:

max(x)

10

[1, 2, 4, 5]
[1, 4, 2, 5]
[1, 2, 4, 5]

=>5

7、如何对列表进行排序

len(x)

列表排序有两种方式,一种是列表自带的方式 sort,一种是内建函数 sorted。复杂的数据类型可通过指定 key参数进行排序。由字典构成的列表,根据字典元素中的age字段进行排序:

=>5

items = [{'name': 'Homer', 'age': 39},

8.count: 查找x中元素1出现的次数: x.count(1)

        {'name': 'Bart', 'age': 10},

=> 1

        {"name": 'cater', 'age': 20}]

9.index:找出某个元素的索引位置:x.index(2)

items.sort(key=lambda item: item.get("age"))

=> 1

print(items)

四、字典

>>>

1.写法: d={'a':1,'b':2}

[{'age': 10, 'name': 'Bart'}, {'age': 20, 'name': 'cater'}, {'age': 39, 'name': 'Homer'}]

2.dict函数:将键值对转换成字典:

列表有 sort方法,用于对原列表进行重新排序,指定 key 参数,key 是匿名函数,item 是列表中的字典元素,我们根据字典中的age进行排序,默认是按升序排列,指定 reverse=True 按降序排列

items=[('a',1),('b',2)]

items.sort(key=lambda item: item.get("age"), reverse=True)

d=dict(itmes)

>>>

=> d={'a':1,'b':2}

[{'name': 'Homer', 'age': 39}, {'name': 'cater', 'age': 20}, {'name': 'Bart', 'age': 10}]

3.另一种创建方式:d=dict(a=1,b=2)

如果不希望改变原列表,而是生成一个新的有序列表对象,那么可以内置函数 sorted ,该函数返回新列表

=> {'a':1,'b':2}

items = [{'name': 'Homer', 'age': 39},

4.基本字典操作方法:

        {'name': 'Bart', 'age': 10},

(1)求元素个数:len(d) => 2

        {"name": 'cater', 'age': 20}]

(2)用键访问值:d['a'] => 1

new_items = sorted(items, key=lambda item: item.get("age"))

(3)修改值:d['a']=3

print(items)

(4)删除: del d['a']

>>>

(5)成员资格: 'a' in d

[{'name': 'Homer', 'age': 39}, {'name': 'Bart', 'age': 10}, {'name': 'cater', 'age': 20}]

5.很有用的方法:格式化字符串

print(new_items)

通常的字符串格式化:

>>>

'i am %s ' % 'vertor'

[{'name': 'Bart', 'age': 10}, {'name': 'cater', 'age': 20}, {'name': 'Homer', 'age': 39}]

=> 'i am vertor'

8、如何移除列表中的元素

而如果应字典格式化就可以实现类似.net中string.format()的功能了:

删除列表中的元素有三种方式

d={'name':'vertor','age'=20}

remove 移除某个元素,而且只能移除第一次出现的元素

'i am %(name)s, and %(age)s years old' % d

>>> a = [0, 2, 2, 3]

=> i am vertor, and 20 years old.

>>> a.remove(2)

6.clear:清除所有元素

>>> a

7.浅复制(shallow copy)copy函数:

[0, 2, 3]

d={'name':'verter',age:20,friends:['ali','qq','baidu']}

# 如果要移除的元素不在列表中,则抛出 ValueError 异常

d2=d.copy()

>>> a.remove(7)

d2['name']='smith' #用新的值替换原来的值

Traceback (most recent call last):

d2['friends'].remove('qq') #修改原来的值

 File "<stdin>", line 1, in <module>

=>d2

ValueError: list.remove(x): x not in list·

=>{'name':'smith',age:20,friends:['ali','baidu']}

del 根据指定的位置移除某元素

=>d

>>> a = [3, 2, 2, 1]

=>{'name':'verter',age:20,friends:['ali','baidu']}

# 移除第一个元素

可以看到,在副本中替换值不会影响到原始字典;而如果修改了副本,原始字典也会被修改。

>>> del a[1]

如果要避免这种情况就需要用到深复制:deepcopy

[3, 2, 1]

8.深复制(deepcopy):deepcopy函数

# 当超出列表的下表索引时,抛出IndexError的异常

9.fromkeys:使用给定的键建立新的字典

>>> del a[7]

{}.fromkeys(['name','age'])

Traceback (most recent call last):

=>{'name':None,'age':None}

 File "<stdin>", line 1, in <module>

dict.fromkeys(['name','age'])

IndexError: list assignment index out of range

=>{'name':None,'age':None}

pop 与del 类似,但是 pop 方法可以返回移除的元素

dict.fromkeys(['name','age'],'verter')

>>> a = [4, 3, 5]

=>{'name':'verter','age':'verter'}

>>> a.pop(1)

10.get:另一种用键访问元素值的方法

3

d={'name':'verter','age':20}

>>> a

=>d.get('name')

[4, 5]

=>'verter'

# 同样,当超出列表的下表索引时,抛出IndexError的异常

=>d.get('friends')

>>> a.pop(7)

=>None

Traceback (most recent call last):

注意:get与d['friends']的区别是后者会抛出KeyError异常,而get不会,他只是返回None.

 File "<stdin>", line 1, in <module>

11.has_key:

IndexError: pop index out of range

d={'name':'verter','age':20}

9、如何连接两个列表

=>d.has_key('name')

listone = [1, 2, 3]

=>True

listtwo = [4, 5, 6]

注意:python3抛弃了这个API.

mergedlist = listone + listtwo

12.items和iteritems

print(mergelist)

(1)items将字典所有以<strong>列表</strong>的形式返回。

>>>

d={'name':'verter','age':20}

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

=>d.items()

列表实现了 + 的运算符重载,使得 + 不仅支持数值相加,还支持两个列表相加,只要你实现了 对象的 __add__操作,任何对象都可以实现 + 操作,例如:

=>[('name', 'verter'), ('age', 20)]

class User(object):

(2)iteritems作用大致相同,不过它是返回一个迭代器对象而不是列表

   def __init__(self, age):

d={'name':'verter','age':20}

       self.age = age

=>it=d.iteritems()

   def __repr__(self):

=>list(it)

       return 'User(%d)' % self.age

=>[('name', 'verter'), ('age', 20)]

   def __add__(self, other):

注意:在python3.0中将iteritems私有化了,变成了iter(),不知何故,难道这个功能太蛋疼,被抛弃了?

       age = self.age + other.age

13.keys和iterkeys

       return User(age)

d={'name':'verter','age':20}

user_a = User(10)

=>for k in x.keys(): print(k)

user_b = User(20)

=>'name'

c = user_a + user_b

=>'age'

print(c)

同理:iterkeys返回迭代器,并且也被python3.0抛弃了,不再提供此方法了。

>>>

14.pop:返回对应键,并将他从字典中移除

User(30)

d.pop('name')

10、如何随机获取列表中的某个元素

=>'verter'

import random

=>d

items = [8, 23, 45, 12, 78]

=>{'age':20}

>>> random.choice(items)

15.popitem:不带参数,弹出一个随机元素。

78

d.popitem()

>>> random.choice(items)

=>{'name','verter'}

45

这个对事先不知道键的情况下很有用。

>>> random.choice(items)

16.setdefault:设置默认值。

12

17.update:利用一个字段更新另外一个字典,当然是更新对应键的值

i

d={'name':'verter','age':20}

=>d2={'name':'verter2'}

=>d.update(d2)

=>d

=>{'name':'verter2','age':20}

18.values和itevalues

(1)values:已列表形式返回字典中的值

(2)itervalues:返回值的迭代器

注意:python3.0还是抛弃了这个API.

本文由9159.com发布于编程,转载请注明出处:上关于列表操作被访问最多的10个问答,数据之间

关键词:

上一篇:没有了
下一篇:没有了