字典类型常用操作及内置方法
1、作用:存多个值，key-value存取，存取速度快
2、定义:在{}内用逗号分隔开多个key:value，key必须是不可变类型，通常是字符串类型，value可以是任意类型
info = {'name': 'egon','age': 18,'gender': 'male'} # 本质info=dict({...})
key不能重复,重复只会显示最后一个赋的值
3、数据类型转换
? info = dict(name='egon',age=18,gender='male')
? info = dict([['name','egon'],('gender',18)])
? res = {}.fromkeys(('name','age','gender'),None)
? print(res)
l = {}
print(l,type(l)) # 空花括号是字典
# ========================优先掌握的常用操作+内置方法===========
# 1、按key存取值：可存可取
# d = {"k1": 111,"k2": 222,"k3": 333}
# d["k1"] = 666
# print(d) # {'k1': 666,'k2': 222,'k3': 333}
# d["k4"] = 999
# print(d) # {'k1': 111,'k3': 333,'k4': 999}
# 2、长度len
# d = {"k1": 111,"k3": 333}
# print(len(d)) # 3
# 3、成员运算in和not in
# 字典依据key运算
# d = {"k1": 111,"k3": 333}
# print('k1' in d) #True
# print(111 in d) # False
# 4、删除
# d = {"k1": 111,"k3": 333}
# 方式一
# del d['k1']
# print(d) # {'k2': 222,'k3': 333}
# 方式二
# res = d.pop('k1')
# print(res) # 111 有返回值(随机删)
# print(d) # {'k2': 222,'k3': 333}
# 5、键keys(),值values(),键值对items()
# d = {"k1": 111,"k3": 333}
# 在python2中
# >>> d = {"k1": 111,"k3": 333}
# >>> d.keys(),type(d.keys())
# (['k3','k2','k1'],<type 'list'>)
# >>> d.values(),type(d.values())
# ([333,222,111],<type 'list'>)
# >>> d.items(),type(d.items())
# ([('k3',333),('k2',222),('k1',111)],<type 'list'>)
# 在python3中
# print(d.keys(),type(d.keys())) # dict_keys(['k1','k3']) <class 'dict_keys'>
# print(d.values(),type(d.values())) # dict_values([111,333]) <class 'dict_values'>
# print(d.items(),type(d.items())) # ('k2',('k3',333)]) <class 'dict_items'>
# 6、循环
# 只取key
# for i in d.keys():
# print(i)
# 只取value
# for i in d.values():
# print(i)
# value与key对应
# 方法一
# for i in d:
# print(i,d[i])
# 方法二
# for x,y in d.items():
# print(x,y)
# ========================需要掌握的常用操作+内置方法===========
# d = {"k1": 111,"k3": 333}
# dic = d.copy()
# print(dic) # {'k1': 111,'k3': 333}
# d.update({'k3': 4646,'k4': 6666})
# print(d) # {'k1': 111,'k3': 4646,'k4': 6666}
# res = d.popitem() # 删除最后一个值，LIFO后进先出
# print(res) # ('k3',333)
# print(d) # {'k1': 111,'k2': 222}
# d = {"k2": 222,"k3": 333}
# if 'k1' not in d:
# d['k1'] = 66666666666
# res = d.setdefault('k1',6666666666) # 两者都可以达成
# print(res) # 66666666666 k1不存在的情况下添加
# print(d) # {'k2': 222,'k1': 66666666666}
# ==========================总结
# 可以存多个值
# 无序
# 可变
# d = {"k1": 1111}
# print(id(d)) # 1844777596544
# d['k1'] = 2222
# print(id(d)) # 1844777596544
# =======================练习1
# # 有如下值集合 [11,22,33,44,55,66,77,88,99,90]
# # 将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中
# # 即： {'k1': 大于66的所有值,'k2': 小于66的所有值}
# nums = [11,99]
# d = {'k1': [],'k2': []}
# for num in nums:
# if num > 66:
# d['k1'].append(num)
# else:
# d['k2'].append(num)
# print(d) # {'k1': [77,99],'k2': [11,66]}
# =======================练习2
# 统计s='hello alex alex say hello sb sb'中每个单词的个数
# 结果如：{'hello': 2,'alex': 2,'say': 1,'sb': 2}
# s = 'hello alex alex say hello sb sb'
# words = s.split()
# d = {}
# for x in words:
# if x not in d:
# d[x] = 1
# else:
# d[x] += 1
# print(d) # {'hello': 2,'sb': 2}
集合常用操作及内置方法
1、作用:去重,关系运算
2、回顾:可变类型是不可hash类型,不可变类型是可hash类型
3、定义方式:在{}内用逗号分隔开多个不可变类型
3.1 集合:可以包含多个元素,用逗号分割
3.2 原则:
? Ⅰ 每个元素必须是不可变类型(可hash,可作为字典的key)
? Ⅱ 集合内元素唯一
? Ⅲ 集合内元素无序
? 集合的目的不是将不同的值存放到一起
? 不同的集合间用来做关系运算，无需纠结于集合中单个值
s = {111,111,3.3,"aaa",(111,222)} # s = set(...)
print(s) # {(111,'aaa',111}
4、数据类型转换
res = set("hello")
print(res,type(res)) # {'h','e','l','o'} <class 'set'>
# # ==========================练习1
# # 有如下列表，列表元素为不可hash类型，去重，得到新列表，
# # 且新列表一定要保持列表原来的顺序
# # l=[
# # {'name':'egon','age':18,'sex':'male'},# # {'name':'alex','age':73,# # {'name':'egon','age':20,'sex':'female'},# # ]
# l = [
# {'name': 'egon','sex': 'male'},# {'name': 'alex','age': 73,# {'name': 'tony','age': 20,'sex': 'female'},# {'name': 'egon',# ]
# res = []
# for item in l:
# if item not in res:
# res.append(item)
# print(res)
# # [{'name': 'egon',# # {'name': 'alex',# # {'name': 'tony','sex': 'female'}] # 同一行
# 优先掌握的操作：
# 1、长度len
# s = {111,333}
# print(len(s)) # 3
# 2、成员运算in和not in
# s = {111,333}
# print(111 in s) # True
# print(11 not in s) # True
# =====================关系运算
# pythons = {'alex','egon','yuanhao','wupeiqi','gangdan','biubiu'}
# linuxs = {'wupeiqi','oldboy','gangdan'}
# 3、|合集
# print(pythons | linuxs) # 方法一
# print(pythons.union(linuxs)) # 方法二
# # {'yuanhao','biubiu','alex'}
# 4、&交集:共同部分
# print(pythons & linuxs) # 方法一
# print(pythons.intersection(linuxs)) # 方法二
# # {'gangdan','wupeiqi'}
#
# # 将交集更新给pythons
# pythons = pythons & linuxs # 方法一
# pythons.intersection_update(linuxs) # 方法二
# print(pythons)
# # {'wupeiqi','gangdan'}
# 5、-差集
# # pythons有而linuxs没有
# print(pythons - linuxs) # 方法一
# print(pythons.difference(linuxs)) # 方法二
# # {'alex','egon'}
#
# # linuxs有而pythons没有
# print(linuxs - pythons) # 方法一
# print(linuxs.difference(pythons)) # 方法二
# # {'oldboy'}
# 6、^对称差集:取出pythons有或linuxs有的
# res = pythons ^ linuxs # 方法一
# print(res)
# res = pythons.symmetric_difference(linuxs) # 方法二
# print(res)
# res = (pythons - linuxs) | (linuxs - pythons) # 繁琐
# print(res)
# res = (pythons | linuxs) - (pythons & linuxs) # 繁琐
# print(res)
# # {'alex','oldboy'}
# 7、==
# s1 = {1,2,3}
# s2 = {3,1}
# print(s1 == s2) # True
# 8、父集：>,>=
# 9、子集：<,<=
# s1 = {1,3,4,5}
# s2 = {3,1}
# print(s1 >= s2) # True
# print(s1 <= s2) # False
# ====================需要了解的
# .update 更新
# s = {"aaa","bbb"}
# s.update({22,5})
# print(s) # {3.3,5,'bbb',22}
# .pop 随机删
# s = {"aaa","bbb"}
# res = s.pop()
# print(res) # 3.3 有输出结果,随机删
# print(s) # {'bbb',22}
# .remove 具体删掉某一个值
# s = {"aaa","bbb"}
# res = s.remove("bbb")
# print(res) # None 没有输出结果
# print(s) # {'aaa',22}
# .discard 删不存在的值会报错,remove不会
# s = {"aaa","bbb"}
# s.discard("ccc") # 没有该值会直接报错
# print(s)
# s.remove("ccc") # 没有该值不会报错，返回原值
# print(s) # {'aaa','bbb'}
# .add 添加值,位置随机,因为集合无序
# s = {"aaa","bbb"}
# s.add("ccc")
# print(s) # {3.3,'ccc','bbb'}
# isdisjoint 判断两个集合是否包含相同的元素
# s1 = {1,3}
# s2 = {4,6,3}
# print(s1.isdisjoint(s2)) # False
# =========================总结
# 存多个值
# 无序
# 可变
# s = {1,3}
# print(id(s)) # 2189058917984
# s.add(4)
# print(id(s)) # 2189058917984
文件处理基础
"""
1、什么是文件？
文件是操作系统提供给用户/应用程序存取硬盘的一种机制
2、为何要用文件？
永久保存数据
3、如何用文件？
应用程序 open()
操作系统 文件
计算机硬件(硬盘)
"""
# 1、操作文件的步骤
# rawstring原生路径
f = open(r'绝对路径或相对路径')
# f的值，文件对象/文件句柄
data = f.read()
print(data)
f.close() # 回收系统资源
# 2、with上下文管理
with open(r'绝对路径或相对路径') as f1,
open(r'绝对路径或相对路径') as f2:
f1.read()
f2.read()
（编辑：李大同）
【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!
|
