一、列表类型内置方法
有序
可变
s ='dhakoia'
s_list =list(s)
print(s_list)
['d', 'h', 'a', 'k', 'o', 'i', 'a']
按索引取值
food_list = ['甜甜圈','抹茶蛋糕','焦糖布丁','冰激淋','玉米甜饼']
print(food_list[1])
抹茶蛋糕
切片
food_list = ['甜甜圈','抹茶蛋糕','焦糖布丁','冰激淋','玉米甜饼']
print(food_list[0:4:2])
['甜甜圈', '焦糖布丁']
长度len(list)
food_list = ['甜甜圈','抹茶蛋糕','焦糖布丁','冰激淋','玉米甜饼']
print(len(food_list))
5
in & not in
food_list = ['甜甜圈','抹茶蛋糕','焦糖布丁','冰激淋','玉米甜饼']
print('奶茶' in food_list)
print('甜甜圈' in food_list)
False
True
追加值append(新元素)
food_list = ['甜甜圈','抹茶蛋糕','焦糖布丁','冰激淋','玉米甜饼']
food_list.append('奶茶')
print(food_list)
['甜甜圈', '抹茶蛋糕', '焦糖布丁', '冰激淋', '玉米甜饼', '奶茶']
删除del(要删除元素的索引)
food_list = ['甜甜圈','抹茶蛋糕','焦糖布丁','冰激淋','玉米甜饼']
del food_list[2]
print(food_list)
['甜甜圈', '抹茶蛋糕', '冰激淋', '玉米甜饼']
food_list = ['甜甜圈','抹茶蛋糕','焦糖布丁','冰激淋','玉米甜饼']
for i in food_list:
print(i)
甜甜圈
抹茶蛋糕
焦糖布丁
冰激淋
玉米甜饼
添加元素insert(添加后新元素的索引，新元素)
food_list = ['甜甜圈','抹茶蛋糕','焦糖布丁','冰激淋','玉米甜饼']
food_list.insert(1,'奶茶')#添加的元素位置在1
print(food_list)
['甜甜圈', '奶茶', '抹茶蛋糕', '焦糖布丁', '冰激淋', '玉米甜饼']
删除（有返回值）pop(要删除元素的索引)#默认尾
food_list = ['甜甜圈','抹茶蛋糕','焦糖布丁','冰激淋','玉米甜饼']
deli = food_list.pop(1)
print(deli)
print(food_list)
抹茶蛋糕
['甜甜圈', '焦糖布丁', '冰激淋', '玉米甜饼']
移除 remove(要移除的元素)
food_list = ['甜甜圈','抹茶蛋糕','焦糖布丁','冰激淋','玉米甜饼']
food_list.remove('甜甜圈')
print(food_list)
['抹茶蛋糕', '焦糖布丁', '冰激淋', '玉米甜饼']
数元素个数count(要数个数的元素)
food_list = ['甜甜圈','抹茶蛋糕','焦糖布丁','冰激淋','玉米甜饼','冰激淋']
print(food_list.count('冰激淋'))
2
元素的索引index(元素名)
food_list = ['甜甜圈','抹茶蛋糕','焦糖布丁','冰激淋','玉米甜饼']
print(food_list.index('甜甜圈'),food_list.index('焦糖布丁'))
0 2
清除所有元素clear()
food_list = ['甜甜圈','抹茶蛋糕','焦糖布丁','冰激淋','玉米甜饼']
food_list.clear()
print(food_list)
[]
复制列表copy()
food_list = ['甜甜圈','抹茶蛋糕','焦糖布丁','冰激淋','玉米甜饼']
print(food_list.copy())
['甜甜圈', '抹茶蛋糕', '焦糖布丁', '冰激淋', '玉米甜饼']
扩展extend(list1)
food_list = ['甜甜圈','抹茶蛋糕','焦糖布丁']
food_list1 =['冰激淋','玉米甜饼']
food_list.extend(food_list1)
print(food_list)
['甜甜圈', '抹茶蛋糕', '焦糖布丁', '冰激淋', '玉米甜饼']
逆序reverse()
food_list = ['甜甜圈','抹茶蛋糕','焦糖布丁','冰激淋','玉米甜饼']
food_list.reverse()
print(food_list)
['玉米甜饼', '冰激淋', '焦糖布丁', '抹茶蛋糕', '甜甜圈']
按首字符ASCII码排序sort()&sort(reverse=True)
words_list = ['0moa','c','bi','da','a']
print(words_list.sort())
print(words_list)
words_list.sort(reverse = True)
print(words_list)
None
['0moa', 'a', 'bi', 'c', 'da']
['da', 'c', 'bi', 'a', '0moa']
二、元组（值不可更改、只存不取）类型内置方法
有序
不可变
索引取值
fod_tuple = ('甜甜圈','抹茶蛋糕','焦糖布丁','冰激淋','玉米甜饼')
print(fod_tuple[0])
甜甜圈
切片[首:尾（取不到）:步长]
fod_tuple = ('甜甜圈','抹茶蛋糕','焦糖布丁','冰激淋','玉米甜饼')
print(fod_tuple[::2])
('甜甜圈', '焦糖布丁', '玉米甜饼')
len()
fod_tuple = ('甜甜圈','抹茶蛋糕','焦糖布丁','冰激淋','玉米甜饼')
print(len(fod_tuple))
5
in & not in
fod_tuple = ('甜甜圈','抹茶蛋糕','焦糖布丁','冰激淋','玉米甜饼')
print('甜甜圈' in fod_tuple)
True
循环
fod_tuple = ('甜甜圈','抹茶蛋糕','焦糖布丁','冰激淋','玉米甜饼')
for i in fod_tuple:
print(i)
甜甜圈
抹茶蛋糕
焦糖布丁
冰激淋
玉米甜饼
数元素个数count(要数个数的元素)
fod_tuple = ('甜甜圈','抹茶蛋糕','焦糖布丁','冰激淋','玉米甜饼')
print(fod_tuple.count('冰激淋'))
1
元素的索引index(元素名)
fod_tuple = ('甜甜圈','抹茶蛋糕','焦糖布丁','冰激淋','玉米甜饼')
print(fod_tuple.index('抹茶蛋糕'))
1
三、字典类型内置方法
无序
可变
按key存取值
zidian = {'吃的': '烤面包', '喝的': '奶茶', '玩的': '数独'}
print(zidian['吃的'])
zidian['吃的'] = '大葱卷饼'
print(zidian['吃的'])
烤面包
大葱卷饼
len()
zidian = {'吃的':'烤面包','喝的':'奶茶','玩的':'数独'}
print(len(zidian))
3
in & not in
zidian = {'吃的':'烤面包','喝的':'奶茶','玩的':'UNO'}
print('玩的' in zidian)
True
删除del&pop()
zidian = {'吃的':'烤面包','喝的':'奶茶','玩的':'数独'}
del zidian['吃的']
zidian.pop('喝的')
print(zidian)
{'玩的': '数独'}
随机删除popitem()
zidian = {'吃的':'烤面包','喝的':'奶茶','玩的':'数独'}
zidian.popitem()
print(zidian)
{'吃的': '烤面包', '喝的': '奶茶'}
键keys()、值value()、键值对items()
zidian = {'吃的':'烤面包','喝的':'奶茶','玩的':'数独'}
print(zidian.keys())
print(zidian.values())
print(zidian.items())
dict_keys(['吃的', '喝的', '玩的'])
dict_values(['烤面包', '奶茶', '数独'])
dict_items([('吃的', '烤面包'), ('喝的', '奶茶'), ('玩的', '数独')])
循环
zidian = {'吃的':'烤面包','喝的':'奶茶','玩的':'数独'}
for i in zidian:
print(i)
吃的
喝的
玩的
取值 get()
zidian = {'吃的':'烤面包','喝的':'奶茶','玩的':'数独'}
print(zidian.get('吃的'))
print(zidian.get('玩的'))
烤面包
数独
拼接 update()
zidian = {'吃的':'烤面包','喝的':'奶茶','玩的':'UNO'}
zidian1 = {'学的':'python'}
zidian.update(zidian1)
print(zidian)
{'吃的': '烤面包', '喝的': '奶茶', '玩的': 'UNO', '学的': 'python'}
从可迭代对象创建新字典fromkeys()
keys = ['吃的','喝的','玩的']
keys1 = ('吃的','喝的','玩的')
keys2 = '吃喝玩'
zidian = dict.fromkeys(keys)
zidian1 = dict.fromkeys(keys1,0)
zidian2 = dict.fromkeys(keys2,[])#此列表为共享列表
zidian['吃的']='jfio'
zidian2['吃'].append('ndao')
print(zidian)
print(zidian1)
print(zidian2)
{'吃的': 'jfio', '喝的': None, '玩的': None}
{'吃的': 0, '喝的': 0, '玩的': 0}
{'吃': ['ndao'], '喝': ['ndao'], '玩': ['ndao']}
检查键是否存在 setdefault()
zidian = {'吃的':'烤面包','喝的':'奶茶','玩的':'UNO'}
print(zidian.setdefault('吃的'))#如果键存在：返回对应的值（不修改字典）
print(zidian.setdefault('学的'))#如果键不存在：将键添加到字典中为其设置默认值（若提供）或 None返回这个默认值
print(zidian)
烤面包
None
{'吃的': '烤面包', '喝的': '奶茶', '玩的': 'UNO', '学的': None}
s='hello tank tank say hello sb sb'
sp = s.split()
lis = []
for i in sp:
if i not in lis:
lis.append(i)
dic = dict.fromkeys(lis)
for i in dic:
dic[i]= sp.count(i)
print(dic)
{'hello': 2, 'tank': 2, 'say': 1, 'sb': 2}
四、集合类型内置方法
无序
可变
值不可变
{}内用逗号分隔开多个元素，每个元素必须是不可变类型。（集合不会记录元素的插入顺序。）
len()
s = {2233,'ikun',1145,'yuan'}
print(len(s))
4
in & not in
s = {2233,'ikun',1145,'yuan'}
print(2233 in s)
True
并|交&差-
a = {'a','b','c'}
b = {'b','d','e'}
print(a|b)
print(a&b)
print(a-b)
{'d', 'b', 'a', 'c', 'e'}
{'b'}
{'a', 'c'}
对称差集^
a = {'a','b','c'}
b = {'b','d','e'}
#即a|b-(a&b)
print(a^b)
{'d', 'e', 'a', 'c'}
相同==
a = {1,2,3}
b = {3,2,1}
c = {3,4,5}
print(a == b)
print(a == c)
True
False
父集子集
a = {1,2,3}
b = {1,2,3}
c = {1,2,3,4}
print(a>b)
print(a<=b)
print(a<c)
False
True
True
添加元素add()
a = {1,2,3}
a.add(4)
print(a)
{1, 2, 3, 4}
移除元素remove()
a = {1,2,3}
a.remove(2)
print(a)
{1, 3}
就地移除与其他集合共有的元素difference_update(集合1)
a = {1,2,3}
b = {3,4,5}
a.difference_update(b)
print(a)
{1, 2}
移除元素remove()#遇到没有的元素不会报错
a = {1,2,3}
a.discard(4)
print(a)
{1, 2, 3}
是否没有公共部分isdisjoint()
a = {1,2,3}
b = {3,4,5}
c = {4,5,6}
print(a.isdisjoint(b))
print(a.isdisjoint(c))
False
True
stu_info_list = [
{'name':'nick','age':19,'sex':'male'},
{'name':'egon','age':18,'sex':'male'},
{'name':'tank','age':20,'sex':'female'},
{'name':'tank','age':20,'sex':'female'},
{'name':'egon','age':18,'sex':'male'},
]
lis = []
for i in stu_info_list:
if i not in lis:
lis.append(i)
for j in lis:
print (j)
{'name': 'nick', 'age': 19, 'sex': 'male'}
{'name': 'egon', 'age': 18, 'sex': 'male'}
{'name': 'tank', 'age': 20, 'sex': 'female'}
五、拷贝
可变赋值后改变给予方会影响被给予方
lis = [1,2,3,[4,5,6]]
lis1= lis
lis.append(5)
lis[3].append(7)
print(lis)
print(lis1)
[1, 2, 3, [4, 5, 6, 7], 5]
[1, 2, 3, [4, 5, 6, 7], 5]
zidian = {1:'a', 2:'b', 3:'c'}
zidan1 = {4:'d'}
zidian1= zidian
zidian.update(zidan1)
print(zidian)
print(zidian1)
{1: 'a', 2: 'b', 3: 'c', 4: 'd'}
{1: 'a', 2: 'b', 3: 'c', 4: 'd'}
txt = '1234'
txt1 = txt
txt = txt.replace('1','abc')
print(txt)
print(txt1)
abc234
1234
1、浅拷贝#可变元素变化会跟着变化，反之不然
copy()
lis = [1,2,3,[4,5,6]]
lis1 = lis.copy()
lis[0]+=1
lis.append(7)
lis[3].append(7)
print(lis)
print(lis1)#lis1开辟的内存为lis的索引,因lis为不可变元素，改变lis的值会拓展新的内存空间
[2, 2, 3, [4, 5, 6, 7], 7]
[1, 2, 3, [4, 5, 6, 7]]
import copy
lis = [1,2,3,[4,5,6]]
lis1 = copy.copy(lis)
lis.append(7)
lis[0] += 1
lis[3].append(7)
print(lis)
print(lis1)
[2, 2, 3, [4, 5, 6, 7], 7]
[1, 2, 3, [4, 5, 6, 7]]
1、深拷贝#完全不受影响
import copy
lis = [1,2,3,[4,5,6]]
lis1 = copy.deepcopy(lis)
lis[0] += 1
lis[3].append(7)
print(lis)
print(lis1)
[2, 2, 3, [4, 5, 6, 7]]
[1, 2, 3, [4, 5, 6]]
import sys
sys.getdefaultencoding()
'utf-8'
浙公网安备 33010602011771号