day08 列表、元组、字典、集合内置方法

列表的内置方法:
1. 作用
描述多个值,比如爱好

2. 定义方式
hobby_list = ['play', 'swimming', 'dancing', '666']
lt = list('nick')

3. 内置方法

优先掌握:

   1) 索引取值

    hobby_list = ['play', 'swimming', 'dancing', '666']print(1, hobby_list[-1])

hobby_list[-1] = '233'  # 索引修改

2) 切片
print(hobby_list[:]) # ['play', 'swimming', 'dancing', '666']
print(hobby_list[::-1]) # 从右到左 # ['666', 'dancing', 'swimming', 'play']

3) 长度
print(len(hobby_list))

4) in/not in
hobby_list = ['play', 'swimming', 'dancing', '666']
print('play' in hobby_list) # True

5) for 循环
for hobby in hobby_list:
print(hobby)

6) del删除
del hobby_list[-1]

7) append() 追加
hobby_list.append('dapao-->piao')

需要掌握
hobby_list = ['play', 'swimming', 'dancing', '666', 666, '666']

print(hobby_list.count('666')) # 对列表内的某一个元素计数
hobby_list.extend([1, 2, 3, 4]) # 扩展列表

hobby_list.clear() # 清除

hobby_list2 = hobby_list.copy() # 复制列表

hobby_list.pop() # 删除,默认删除最后一个

print(hobby_list.index('play')) # 索引
print(hobby_list.index('play', 2, 4)) # 索引2-4内有没有该值

hobby_list.insert(0, '1') # 插入

hobby_list.remove('1') # 移除

hobby_list.reverse() # 反转


hobby_list = [['nick', 1000], ['jason', 500000], ['sean', 2000], ['tank', 10000]]
def func(i): # ['nick', 1000]
return i[1] # 1000,500000,2000,10000

hobby_list.sort(key=func) #
hobby_list.sort(key=lambda i: i[1], reverse=True) #


4. 存一个值还是多个值
多个值

5. 有序or无序
有序

6. 可变or不可变(重点)
可变



元组内置方法
1.作用
早期永远一般用于减小内存占用,现在毫无用处,以后只要定义列表就行了
2.定义方式
列表的中括号改成小括号
lis = [1,2,3,4]
tup = (1,2,3,4)
tup = tuple('lksjdkflj')

元祖和列表一模一样,但是元祖无法修改,元祖在定义那一刻他的元素个数以及元素的值全部固定了

lis[1] = 5
tup[1] = 5 #不可想列表一样,更改元素

3.内置方法
tup.index(1)
tup.count(1)


4. 存一个值还是多个值
多个值

5. 有序or无序
有序

6. 可变or不可变(重点)
不可变



字典内置方法
1. 作用
对于值添加描述信息

2. 定义方式
用{}以逗号隔开加入键值对key:value
info_dict = {'name': 'wangdapao', 'age': 18, 'height': 120, 'gender': 'female', 'hobby_list': ['dapao', '666', '233']}

3. 内置方法
优先掌握
1) 按key取值,即可取也可改变
print(info_dict['hobby_list'])
info_dict['age'] = 20
print(info_dict)

2) 长度len
print(len(info_dict))

3) in/not in
print('name' in info_dict)

4) for循环
for i in info_dict:
print(i)

5) keys/values/items(items用的最多,一般和解压缩一起用)
print(list(info_dict.keys())) # list
print(list(info_dict.values())) # list
print(list(info_dict.items())) # list

for i in info_dict.values():
print(i)
info_dict = {'name': 'wangdapao', 'age': 18, 'height': 120, 'gender': 'female', 'hobby_list': ['dapao', '666', '233']}
print(info_dict.items())

for i in info_dict.items():
print(i)

for k, v in info_dict.items():
print(k, v)

lt = [[1, 2, 3], [2, 3, 4], [5, 6, 7]]
for a, b, c in lt:
print(a, b, c)

需要掌握
info_dict = {'name': 'wangdapao', 'age': 18, 'height': 120, 'gender': 'female', 'hobby_list': ['dapao', '666', '233']}

print(info_dict.copy())

info_dict.pop('name') #必须属值

info_dict.popitem() #早期的时候字典是无序的,是随机删除的,但是由于python3底层优化了字典,让字典看的貌似有序了,所以默认删除最后一个

info_dict.clear()


print(info_dict.get('age'))

print(info_dict.get('name', 'nick')) # 如果有,就返回真正的值;如果没有,默认返回None,也可以指定返回

# if jiangpin_lan_dict.get(reward) is None:  # None和小整数池一样固定不变的id
# jiangpin_lan_dict[reward] = 1
# else:
# jiangpin_lan_dict[reward] += 1
#
# print(jiangpin_lan_dict)


info_dict.setdefault('gender', 123123) # 有则,返回真正的值,无则往里面追加了值

D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D

D = {'a': 1, 'b': 2}
# def setdefault(D,k,d):
# D.get(k, d) # 获取'gender',如果不存在gender那就返回123123
# if k not in D:
# D[k] = d
#
# setdefault(D,'a',3)
# print(D)

info_dict = {'name': 'wangdapao', 'age': 18, 'height': 120, 'gender': 'female', 'hobby_list': ['dapao', '666', '233']}

info_dict.update({'a':1}) # 增加键值对

fromkeys由dict.出来,快速造一个字典
print(dict.fromkeys(['a',2,3,4,5],'nick'))

4. 存一个值还是多个值
多个值

5. 有序or无序
无序

6. 可变or不可变(重点)
可变



集合的内置方法
1. 作用
就是存储一大堆元素的东西,容器数据类型,集合基本用不到

2. 定义方式
以{}用逗号隔开不可变数据类型

s = {1, 2, 1, 'a', 'a', 'c'}

# 去重
# 乱序
print(set(lis))
print(list(set(lis)))

s = {} # 空大括号是字典,不是集合,定义空集合必须得用set()

3. 内置方法
pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'} # 老刘

print(pythoners | linuxers) # 并集
print(pythoners.union(linuxers))

print(pythoners & linuxers) # 交集
print(pythoners.intersection(linuxers))

print(pythoners - linuxers) # 差集
print(pythoners.difference(linuxers))

print(pythoners ^ linuxers) # 交叉补集
print(pythoners.symmetric_difference(linuxers))

s = {1,2,3}
s.add(4)
print(s)

了解

pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'} # 老刘

pythoners.pop() # 随机删除
print(pythoners)

pythoners.update(linuxers)
print(pythoners)

pythoners.clear() # 清空
print(pythoners)

print(pythoners.copy()) # 复制

pythoners.remove('nickk') # 没有就报错
pythoners.discard('nickk') # 没有不报错

pythoners = {'jason', 'nick', 'tank', 'sean'}
pythoners2 = {'jason', 'nick', 'tank', 'sean','nick2'}
print(pythoners.issubset(pythoners2)) # 子集
print(pythoners.issuperset(pythoners2)) # 父集


pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'} # 老刘
pythoners.difference_update(linuxers)
print(pythoners)

pythoners.symmetric_difference_update(linuxers)
print(pythoners)

pythoners = {'jason', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'} # 老刘
res = pythoners.isdisjoint(linuxers)
print(res)


4. 存一个值还是多个值
多个值

5. 有序or无序
无序

6. 可变or不可变(重点)
可变



原文地址:https://www.cnblogs.com/wwei4332/p/11303684.html