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不可变(重点)
可变