>>> 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]
空的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) 返回元组中元素最小值。
dict 字典,全称dictionary,使用键-值(key-value)存储。字典的每个键值对用冒号(:)分割,每个对之间用逗号(,)分割,整个字典包括在花括号({})中
例:
>>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
>>> d['Michael']
95
>>> 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有以下几个特点:
- 查找和插入的速度极快,不会随着key的增加而变慢;
- 需要占用大量的内存,内存浪费多。
而list相反:
- 查找和插入的时间随着元素的增加而增加;
- 占用空间小,浪费内存很少。
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是一组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