day005|python基础回顾5

字典类型常用操作及内置方法

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, 'k2': 222, 'k3': 333, 'k4': 999}

# 2、长度len
# d = {"k1": 111, "k2": 222, "k3": 333}
# print(len(d))         # 3

# 3、成员运算in和not in
# 字典依据key运算
# d = {"k1": 111, "k2": 222, "k3": 333}
# print('k1' in d)      #True
# print(111 in d)       # False

# 4、删除
# d = {"k1": 111, "k2": 222, "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, "k2": 222, "k3": 333}
# 在python2中
# >>> d = {"k1": 111, "k2": 222, "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', 'k2', 'k3']) <class 'dict_keys'>
# print(d.values(), type(d.values()))     # dict_values([111, 222, 333]) <class 'dict_values'>
# print(d.items(), type(d.items()))       # ('k2', 222), ('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, "k2": 222, "k3": 333}
# dic = d.copy()
# print(dic)          # {'k1': 111, 'k2': 222, 'k3': 333}

# d.update({'k3': 4646, 'k4': 6666})
# print(d)            # {'k1': 111, 'k2': 222, '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, 'k3': 333, '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, 22, 33, 44, 55, 66, 77, 88, 99]
# d = {'k1': [], 'k2': []}
# for num in nums:
#     if num > 66:
#         d['k1'].append(num)
#     else:
#         d['k2'].append(num)
# print(d)                # {'k1': [77, 88, 99], 'k2': [11, 22, 33, 44, 55, 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, 'alex': 2, 'say': 1, 'sb': 2}

集合常用操作及内置方法

1、作用:去重,关系运算

2、回顾:可变类型是不可hash类型,不可变类型是可hash类型

3、定义方式:在{}内用逗号分隔开多个不可变类型

3.1 集合:可以包含多个元素,用逗号分割

3.2 原则:

​ Ⅰ 每个元素必须是不可变类型(可hash,可作为字典的key)

​ Ⅱ 集合内元素唯一

​ Ⅲ 集合内元素无序

​ 集合的目的不是将不同的值存放到一起

​ 不同的集合间用来做关系运算，无需纠结于集合中单个值

s = {111, 111, 3.3, "aaa", 3.3, (111, 222)} # s = set(...)

print(s) # {(111, 222), 3.3, '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,'sex':'male'},
# #     {'name':'egon','age':20,'sex':'female'},
# #     {'name':'egon','age':18,'sex':'male'},
# #     {'name':'egon','age':18,'sex':'male'},
# # ]
# l = [
#     {'name': 'egon', 'age': 18, 'sex': 'male'},
#     {'name': 'alex', 'age': 73, 'sex': 'male'},
#     {'name': 'tony', 'age': 20, 'sex': 'female'},
#     {'name': 'egon', 'age': 18, 'sex': 'male'},
#     {'name': 'egon', 'age': 18, 'sex': 'male'},
# ]
# res = []
# for item in l:
#     if item not in res:
#         res.append(item)
# print(res)
# # [{'name': 'egon', 'age': 18, 'sex': 'male'},
# # {'name': 'alex', 'age': 73, 'sex': 'male'},
# # {'name': 'tony', 'age': 20, 'sex': 'female'}]  # 同一行

# 优先掌握的操作：
# 1、长度len
# s = {111, 222, 333}
# print(len(s))           # 3

# 2、成员运算in和not in
# s = {111, 222, 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', 'egon', 'wupeiqi', 'gangdan', 'biubiu', 'oldboy', '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', 'biubiu', 'yuanhao', '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', 'yuanhao', 'biubiu', 'egon', 'oldboy'}


# 7、==
# s1 = {1, 2, 3}
# s2 = {3, 2, 1}
# print(s1 == s2)         # True

# 8、父集：>,>=
# 9、子集：<,<=
# s1 = {1, 2, 3, 4, 5}
# s2 = {3, 2, 1}
# print(s1 >= s2)              # True
# print(s1 <= s2)              # False


# ====================需要了解的
# .update 更新
# s = {"aaa", 22, 3.3, "bbb"}
# s.update({22, 3, 4, 5})
# print(s)                    # {3.3, 3, 4, 5, 'aaa', 'bbb', 22}

# .pop 随机删
# s = {"aaa", 22, 3.3, "bbb"}
# res = s.pop()
# print(res)                  # 3.3 有输出结果,随机删
# print(s)                    # {'bbb', 'aaa', 22}

# .remove 具体删掉某一个值
# s = {"aaa", 22, 3.3, "bbb"}
# res = s.remove("bbb")
# print(res)                  # None 没有输出结果
# print(s)                    # {'aaa', 3.3, 22}

# .discard 删不存在的值会报错,remove不会
# s = {"aaa", 22, 3.3, "bbb"}
# s.discard("ccc")            # 没有该值会直接报错
# print(s)
# s.remove("ccc")             # 没有该值不会报错，返回原值
# print(s)                    # {'aaa', 3.3, 22, 'bbb'}

# .add 添加值,位置随机,因为集合无序
# s = {"aaa", 22, 3.3, "bbb"}
# s.add("ccc")
# print(s)                    # {3.3, 'aaa', 'ccc', 22, 'bbb'}

# isdisjoint 判断两个集合是否包含相同的元素
# s1 = {1, 2, 3}
# s2 = {4, 5, 6, 3}
# print(s1.isdisjoint(s2))    # False


# =========================总结
# 存多个值
# 无序
# 可变
# s = {1, 2, 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()