list,tuple,dict,set的使用方法

2018-06-18 02:20:23来源:未知 阅读 ()

新老客户大回馈,云服务器低至5折

list
 
list是一种有序的集合,可以随时添加和删除其中的元素
classmates = ['Michael', 'Bob', 'Tracy']
len()函数可以获得list元素的个数。list长度比索引小1.
list的索引是从0开始的,-1做索引,获取最后一个元素。索引超出范围,会报IndexError的错误。
例:(切片)
>>>L=['Google', 'Runoob', 'Taobao'] 
>>> L[2] 'Taobao' 
>>> L[-2] 'Runoob' 
>>> L[1:] ['Runoob', 'Taobao']
 
append方法可以将元素追加到列表末尾
例:
 
>>> classmates.append('Adam')
>>> classmates
['Michael', 'Bob', 'Tracy', 'Adam']
 
也可以将元素插入到指定的位置insert()
例:
>>> classmates.insert(1, 'Jack')
>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy', 'Adam']
 
删除list末尾的元素,pop()方法
例:
classmates.pop()
'Adam'>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy']
 
删除指定位置的元素,pop(i)方法
例:
>>> classmates.pop(1)
'Jack'>>> classmates
['Michael', 'Bob', 'Tracy']
 
删除元素还有一个方法del
例:
>>> list = ['Google', 'Runoob', 1997, 2000]
>>> del list[2]
>>> print(list)
['Google', 'Runoob', 2000]
 
要把某个元素替换成别的元素,可以直接赋值给对应的索引位置:
例:
>>> classmates[1] = 'Sarah'>>> classmates
['Michael', 'Sarah', 'Tracy']
 
list里面的数据类型可以是不同的,list的元素也可以是另外一个list。
例:
>>> s = ['python', 'java', ['asp', 'php'], 'scheme']
>>> len(s)
4
 
例:
>>>a = ['a', 'b', 'c'] 
>>> n = [1, 2, 3] 
>>> x = [a, n] 
>>> x 
[['a', 'b', 'c'], [1, 2, 3]] 
>>> x[0] 
['a', 'b', 'c'] 
>>> x[0][1] 
'b'
 
空的list的长度为0
 
列表脚本操作符:
 
Python 表达式                              结果                                 描述
[1, 2, 3] + [4, 5, 6]                  [1, 2, 3, 4, 5, 6]                   组合,列表拼接
['Hi!'] * 4                            ['Hi!', 'Hi!', 'Hi!', 'Hi!']         重复
3 in [1, 2, 3]                         True                                 元素是否存在于列表中(not in相反)
for x in [1, 2, 3]: print(x, end=" ")  1 2 3                                迭代
 
列表的一些方法
max(list) 返回列表元素最大值
min(list) 返回列表元素最小值
list(seq) 将元组转化为列表
list.count(obj)     统计某个元素在列表中出现的次数
list.clear()           清空列表
list.sort([func])     对列表进行排序  func -- 可选参数, 如果指定了该参数会使用该参数的方法进行排序。
list.reverse() 反向列表中元素
list.remove(obj)移除列表中某个值的第一个匹配项
list.index(obj)  从列表中找出某个值第一个匹配项的索引位置
list.extend(seq)  在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)
 
tuple
 
另一种有序列表叫做元组。tuple一旦初始化就不能修改。不能被改变会更安全。
例:
>>> classmates = ('Michael', 'Bob', 'Tracy')
取classmates中的值 classmates[-1],classmates[1],通过下标
 
当tuple中只有一个元素时,要这样定义:t = (1,),多加一个逗号来消除歧义,不加逗号。t=(1)()相当于小括号,赋值。
“可变”的tuple:
例:
>>> t = ('a', 'b', ['A', 'B'])
>>> t[2][0] = 'X'>>> t[2][1] = 'Y'>>> t
('a', 'b', ['X', 'Y'])
表面上元素变了,但tuple一开始指向的list并没有改成别的list,对于tuple来说还是没变。指向不变。
 
# 创建一个新的元组
tup3 = tup1 + tup2
 
del tup3 #删除tup3
 
Python 表达式                              结果                                 描述
(1, 2, 3) + (4, 5, 6)                  (1, 2, 3, 4, 5, 6)                   组合,列表拼接
('Hi!') * 4                            ('Hi!', 'Hi!', 'Hi!', 'Hi!')         重复
3 in (1, 2, 3)                         True                                 元素是否存在于列表中(not in相反)
for x in (1, 2, 3]) print(x)   1 2 3                                迭代
 
内置函数
len(tuple)   计算元组元素个数。
max(tuple)   返回元组中元素最大值。
min(tuple)   返回元组中元素最小值。
tuple(seq)   将列表转换为元组。
 
dict
 
dict 字典,全称dictionary,使用键-值(key-value)存储。字典的每个键值对用冒号(:)分割,每个对之间用逗号(,)分割,整个字典包括在花括号({})中
例:
>>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
>>> d['Michael']
95
 
除了初始化时指定外,还可以通过key放入:
>>> d['Adam'] = 67
>>> d['Adam']
67
 
由于一个key只能对应一个value,所以,多次对一个key放入value,后面的值会把前面的值冲掉
 
key不存在,会报错。可以使用两种方法,一是通过in来判断key是否存在
例:
>>> 'Thomas' in d
False
二是通过get()方法,如果key不存在,返回None,或者自己指定的value
>>> d.get('Thomas') #None交互环境不显示结果
>>> d.get('Thomas', -1)
-1
 
要删除一个key,用po(key)方法,对应的value也会从dict中删除。
例:
>>> d.pop('Bob')
75
>>> d
{'Michael': 95, 'Tracy': 85}
 
del dict['Name'] # 删除键 'Name'
dict.clear() # 清空字典
del dict # 删除字典
 
 
请务必注意,dict内部存放的顺序和key放入的顺序是没有关系的。
和list比较,dict有以下几个特点:
  1. 查找和插入的速度极快,不会随着key的增加而变慢;
  2. 需要占用大量的内存,内存浪费多。
而list相反:
  1. 查找和插入的时间随着元素的增加而增加;
  2. 占用空间小,浪费内存很少。
所以,dict是用空间来换取时间的一种方法。
 
dict的key必须是不可变对象,通过key计算位置的算法称为哈希算法
键必须不可变,所以可以用数字,字符串或元组充当,而用列表就不行
 
 
内置函数
len(dict)       计算字典元素个数,即键的总数。
str(dict)       输出字典,以可打印的字符串表示。
type(variable)  返回输入的变量类型,如果变量是字典就返回字典类型。
 
内置方法
序号 函数及描述
1 radiansdict.clear() 删除字典内所有元素
2 radiansdict.copy() 返回一个字典的浅复制
3 radiansdict.fromkeys() 创建一个新字典,以序列seq中元素做字典的键,val为字典所有键对应的初始值
4 radiansdict.get(key, default=None) 返回指定键的值,如果值不在字典中返回default值
5 key in dict 如果键在字典dict里返回true,否则返回false
6 radiansdict.items() 以列表返回可遍历的(键, 值) 元组数组
7 radiansdict.keys() 以列表返回一个字典所有的键
8 radiansdict.setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中,将会添加键并将值设为default
9 radiansdict.update(dict2) 把字典dict2的键/值对更新到dict里
10 radiansdict.values() 以列表返回字典中的所有值
11 pop(key[,default]) 删除字典给定键 key 所对应的值,返回值为被删除的值。key值必须给出。 否则,返回default值。
12 popitem() 随机返回并删除字典中的一对键和值(一般删除末尾对)。
 
set
 
set是一组key的集合,key不能重复。
要创建一个set,需要提供一个list作为输入集合
例:
>>> s = set([1, 2, 3])
>>> s
{1, 2, 3}
set不是有序的
重复元素在set中自动过滤
add(key)方法添加元素到set中,可以重复添加,但不会有效果。
例:
>>> s.add(4)
>>> s
{1, 2, 3, 4}
>>> s.add(4)
>>> s
{1, 2, 3, 4}
 
通过remove(key)可以删除元素
例:
>>> s.remove(4)
>>> s
{1, 2, 3}
 
set可以看成数学意义上的无序和无重复元素的集合,因此,两个set可以做数学意义上的交集、并集等操作:
>>> s1 = set([1, 2, 3])
>>> s2 = set([2, 3, 4])
>>> s1 & s2
{2, 3}
>>> s1 | s2
{1, 2, 3, 4}
 
set中不能放入可变对象。
 
#关系测试
#交集(两个列表里面都有的值,这里是4、6):
print(list_1.intersection(list_2))
 
#并集(把两个列别合并起来,然后去重):
print(list_1.union(list_2))
 
#差集(把list_1里面有的而list_2里面没有的取出来):
print(list_1.difference(list_2))
 
#对称差集(两个列表里面,互相没有的取出来,也就是只去掉那些互相都有的值)
print(list_1.symmetric_difference(list_2))
 
#子集(判断list_1是否包含了list_3里面的所有值)
print(list_3.issubset(list_1))
 
#父集(判断list_1是否为list_3的父集)
print(list_1.issuperset(list_3))
 
#无交集(判断list_3和list_4是否完全没有任何交集)
list_4 = set([5,6,8])
print(list_3.isdisjoint(list_4))
 
#-----------------------关系测试的另一种写法:
'''
s = set([3,5,9,10]) #创建一个数值集合
 
t = set("Hello") #创建一个唯一字符的集合
 
 
a = t | s # t 和 s的并集
 
b = t & s # t 和 s的交集
 
c = t – s # 求差集(项在t中,但不在s中)
 
d = t ^ s # 对称差集(项在t或s中,但不会同时出现在二者中)
 
基本操作:
 
t.add('x') # 添加一项
 
s.update([10,37,42]) # 在s中添加多项
 
 
 
使用remove()可以删除一项:
 
t.remove('H') #有就删除,没有就报错
t.pop() #随机弹出一个
t.discard('H') #有就删除,没有也不会报错
 
len(s)
set 的长度
 
x in s
测试 x 是否是 s 的成员
 
x not in s
测试 x 是否不是 s 的成员
 
s.issubset(t)
s <= t
测试是否 s 中的每一个元素都在 t 中
 
s.issuperset(t)
s >= t
测试是否 t 中的每一个元素都在 s 中
 
s.union(t)
s | t
返回一个新的 set 包含 s 和 t 中的每一个元素
 
s.intersection(t)
s & t
返回一个新的 set 包含 s 和 t 中的公共元素
 
s.difference(t)
s - t
返回一个新的 set 包含 s 中有但是 t 中没有的元素
 
s.symmetric_difference(t)
s ^ t
返回一个新的 set 包含 s 和 t 中不重复的元素
 
s.copy()
返回 set “s”的一个浅复制
 
 
 参考:https://www.liaoxuefeng.com
            http://www.runoob.com
 
 
 
 
 

标签:

版权申明:本站文章部分自网络,如有侵权,请联系:west999com@outlook.com
特别注意:本站所有转载文章言论不代表本站观点,本站所提供的摄影照片,插画,设计作品,如需使用,请与原作者联系,版权归原作者所有

上一篇:Python入门之ATM+购物车代码版思维导图

下一篇:tensorflow