数据类型之内置方法2

目录

• 字典相关操作
• 元组相关操作
• 集合相关操作
• 字符编码理论
• 字符编码实操
• 作业

字典相关操作

1. 类型转换
   dict()
   字典的转换一般不使用关键字 而是自己动手转
2. 字典必须要掌握的操作

user_dict = {
    'username': 'jason',
    'password': 123,
    'hobby': ['read', 'music', 'run']
}
# 1. 按k取值(不推荐使用)
print(user_dict['username'])  # jason
# print(user_dict['phone'])  # key不存在直接报错

# 2. 按内置方法get取值(推荐使用)
print(user_dict.get('username'))  # jason
print(user_dict.get('age'))  # None
print(user_dict.get('username', '没有哦'))  # jason 键存在的情况下获取对应的值
print(user_dict.get('phone','没有哦'))  # 没有哦  键不存在默认返回None 可以通过第二个参数自定义

# 3.修改值数据
print(id(user_dict))
user_dict['username'] = 'tony'  # 键存在则修改对应的值
print(id(user_dict))
print(user_dict)

# 4. 新增键值对
user_dict['age'] = 18  # 键不存在则新增键值对
print(user_dict)

# 5. 删除数据
del user_dict['username']
print(user_dict)  # {'password': 123, 'hobby': ['read', 'music', 'run']}
res = user_dict.pop('password')
print(user_dict)  # {'hobby': ['read', 'music', 'run']}
print(res)  # 123

# 6. 统计字典中键值对的个数
print(len(user_dict))  # 3

# 7. 字典三剑客
print(user_dict.keys())    # 一次性获取字典所有的键
print(user_dict.values())  # 一次性获取字典的所有的值
print(user_dict.items())   # 一次性获取字典的键值对数据

for i in user_dict.items():
    k, v = i
    print(k, v)

# 8. 补充说明
print(dict.fromkeys(['name', 'pwd', 'hobby'], 123))  # {'name': 123, 'pwd': 123, 'hobby': 123}
res = dict.fromkeys(['name', 'pwd', 'hobby'], [])
print(res)  # {'name': [], 'pwd': [], 'hobby': []}
res['name'].append('jason')
res['pwd'].append(123)
res['hobby'].append('study')
print(res)  # {'name': ['jason', 123, 'study'], 'pwd': ['jason', 123, 'study'], 'hobby': ['jason', 123, 'study']}
'''当第二个公共值是可变类型的时候 一定要注意 通过任何一个键修改都会影响所有'''

res = user_dict.setdefault('username', 'tony')
print(user_dict, res)  # 键存在则不修改 结果是键对应的值
res = user_dict.setdefault('age', 123)
print(user_dict, res)  # 若不存在则新增键值对 结果是新增的值
print(user_dict.popitem())  # 弹出键值对 后进先出

元组相关操作

1. 类型转换
tuple（ ） # 支持for循环的数据类型都可以转成元组
2. 元组必须掌握的方法
t1 = (11, 22, 33, 44, 55, 66)
# 1. 索引取值
print(t1[1])
# 2. 切片操作
print(t1[1:4])
# 3. 间隔、方向
print(t1[::-1])
# 4. 统计元祖内数据值的个数
print(len(t1))  # 6
# 5. 统计元组内某个数据值出现的次数
print(t1.count(11))  # 1
# 6. 统计元组内指定数据值的索引值
print(t1.index(22))  # 1
# 7. 元组内如果只有一个数据值那么逗号不能少
# 8. 元组内索引绑定的内存地址不能被修改（注意区分 可变与不可变）
# 9. 元组不能新增或删除数据

集合相关操作

1. 类型转换
   set()
   集合内数据必须是不可变类型（整型 浮点型 字符串 元组）
   集合内数据也是无序的 没有索引的概念

2. 集合需要掌握的方法
   去重
   关系运算
   ps：只有遇到上述两种需求的时候才应该考虑使用集合

3. 去重
s1 = {11, 22, 11, 22, 22, 11, 222, 11, 22, 33, 22}
l1 = [11, 22, 33, 22, 11, 22, 33, 22, 11, 22, 33, 22]
s1 = set(l1)
l1 = list(s1)
print(l1)
'''集合的去重无法保留原先数据的排列顺序'''

# 4. 关系运算
#群体之间做差异化校验
#eg：两个微信账号之间 有不同的好友 有相同的好友
f1 = {'jason', 'tony', 'jerry', 'oscar'}
f2 = {'jack', 'jason', 'tom', 'tony'}
# 1. 求两个人的共同好友（交集&（intersection））
print(f1 & f2)  # {'tony', 'jason'}

# 2. 求用户1独有的好友(差集-（subratction）)
print(f1 - f2)  # {'oscar', 'jerry'}

# 3. 求两个人所有的好友(并集|（union）)
print(f1 | f2)  # {'oscar', 'tom', 'tony', 'jack', 'jason', 'jerry'}

# 4. 求两个人各自独有的好友(交叉补集、对称差^（exclusive）)
print(f1 ^ f2)  # {'oscar', 'jack', 'jerry', 'tom'}

# 5. 父集 子集
print(f1 > f2)  # False
print(f1 < f2)  # False

字符编码理论

该知识点理论特别多 但是结论很少 代码使用也很短
1. 字符编码只针对文本数据
2. 回忆计算机内部存储数据的本质
3. 既然计算机内部只认识01 为什么我们却可以敲出人类各式各样的字符
   肯定存在一个数字跟字符的对应关系 存储该关系的地方称为>>>: 字符编码本
4. 字符编码发展史
  4.1 一家独大
     计算机是由美国人发明的 为了能够让计算机识别英文
     需要发明一个数字跟英文字母对应的关系
     ASCII码： 记录了英文字母跟数字的对应关系
              用8bit（1字节）来表示一个英文字符
  
   4.2 群雄割据
     中国人
     GBK码：记录了英文、中文与数字的对应关系
     用至少16bit（2字节）来表示一个中文字符
     很多生僻字需要使用更多的字节
     英文还是用8bit（1字节）来表示

     日本人
       shift_JIS码：记录了英文、日文与数字对应的关系
     韩国人
       Euc_kr码：记录了英文、韩文与数字的对应关系
     """
     每个国家的计算机使用的都是自己定制的编码本
     不同国家的文本数据无法直接交互 会出现“乱码”
     """
    4.3 天下一统
    unicode万国码
       兼容所有国家语言字符
       起步就是两个字节来表示字符
    utf系列：utf8 utf16 ...
       专门用于优化unicode存储问题
       英文还是采用一个字节 中文三个字节

字符编码实操

1. 针对乱码不要慌 切换编码慢慢试即可
2. 编码与解码
   编码：将人类的字符按照指定的编码编码成计算机能够读懂的数据
       字符串.encode()
   解码：将计算机能够读懂的数据按照指定的编码解码成人能够读懂
       bytes类型数据.decode()
3. python2与python3的差异
   python2默认的编码是ASCII
      1.文件头
           #encoding:utf8
      2.字符串前面加u
         u'你好啊'
   python3默认的编码是utf系列（unicode）

作业

# 1.优化员工管理系统
#   拔高: 是否可以换成字典或者数据的嵌套使用完成更加完善的员工管理而不是简简单单的一个用户名(能写就写不会没有关系)
# 定义一个空列表，用于接收用户的用户信息

#方法一 简洁版
user_list = []
while True:
    print("""
    1.添加员工
    2.更新员工
    3.查看员工
    4.删除员工
    """)
    choice = input('请输入编号：').strip()
    if choice == '1':
        username = input('请输入用户名:').strip()
        password = input('请输入密码:').strip()
        age = int(input('请输入年龄:').strip())
        userinfo={'username': username, 'password': password,'age': age}
        user_list.append(userinfo)
        print(f'{username}员工添加成功')
    elif choice == '2':
        user = input('请输入用户名:').strip()
        for i in user_list:
            if user == i['username']:
                i['username'] = input('请输入更新用户名:').strip()
                i['password'] = input('请更新密码').strip()
                i['age'] = int(input('请输入年龄:').strip())
                print(f"{i['username']}用户更新成功")
                break
        else:
            print(f'{user}用户名不存在')
    elif choice == '3':
        for i in user_list:
            print(f"""
            --------用户信息--------
            用户名: {i['username']}
            密码: {i['password']}
            年龄: {i['age']}
            -----------------------
            """)
    elif choice == '4':
        username = input('请输入删除的员工:').strip()
        for i in user_list:
            if username == i['username']:
                user_list.remove(i)
                print(f'{username}用户删除成功')
                break
        else:
            print(f'{username}用户不存在')

方法二：
# 定义空字典，用于存放账号及账号密码
data_dict = {}
# 定义一个用于判断是否登录，如果is_user['username']有值，说明已经登录过，否则就是没有登录，需要去验证登录才能去操作更新，删除和查看操作
is_user = {'username': None}
while True:
    print("""
    1.添加
    2.删除
    3.更新
    4.查看
    5.登录
    """)
    choice = input("请输入编号：").strip()
    # 如果输入的是q/Q，表示退出当前操作
    if choice.lower() == 'q':
        break
    # 如果用户输入的是非数字及不在列表数字1-5之外，都提示并重新打印
    if not choice.isdigit() or (choice not in ['1','2','3','4','5']):
        print('请输入正确数字')
        continue
    if choice == '1':
        # 进入死循环，只有当用户输入q才退出当前循环并返回上一级，否则就一直账号和密码添加
        while True:
            username = input('请输入用户名：').strip()
            if username.lower() == 'q':
                break
            password = input('请输入密码：').strip()
            data_dict[username] = {'pwd':password}
            print(f'用户{username}添加成功')
            print(data_dict)
            continue

    elif choice == '2':
        # 进入删除操作前先判断用户是否有权限操作（即先登录验证通过了才能操作）
        if is_user['username']:
            while True:
                username=input('请输入删除的用户:').strip()
                if username.lower() == 'q':
                    break
                # 判断用户是否存在，如果存在则删除用户输入的账号并退出当前操作返回用户删除的界面
                for i in data_dict.keys():
                    if username == i:
                        del data_dict[username]
                        print(f'用户{username}删除成功')
                        # 必须加break，否则会走到else那里，因为删除用户后表示顺利完成for循环了
                        break
                else:
                    print('用户名不存在，请重新输入')
                    continue
        else:
            print('请登录在操作')
            continue
    elif choice == '3':
        # 进入更新操作前先判断用户是否有权限操作（即先登录验证通过了才能操作）
        if is_user['username']:
            while True:
                username=input('请输入要更新的用户：').strip()
                if username.lower() == 'q':
                    break
                # 判断用户输入的账号和字典里的key是否对应的上
                for i in data_dict.keys():
                    if username == i:
                        user = input('请输入更新后的用户名：').strip()
                        password=input('请输入更新后的密码:').strip()
                        data_dict[user] = {'pwd':password}
                        print(f'{user}用户更新成功')
                        break
                # 必须加break，否则会走到else那里，因为更新用户后表示顺利完成for循环了
                else:
                    print('输入更新的用户不存在，请重新输入')
                    break
        else:
            print('请登录在操作')
            continue
    elif choice == '4':
        # 进入查看操作前先判断用户是否有权限操作（即先登录验证通过了才能操作),否则就无法进行while条件处
        if is_user['username']:
            while True:
                username = input('请输入查看的用户:').strip()
                if username.lower() == 'q':
                    break
                # 如果用户名对应的上字典里的key，则打印用户输入的账号及所对应账号的密码
                if username in data_dict.keys():
                    print(f'用户名:{username} 密码：{data_dict[username]}')
                else:
                    print(f'{username}用户不存在，请重新输入')
                    continue
        else:
            print('请登录在操作')
            continue
    elif choice == '5':
        username = input('请输入登录账号').strip()
        if username.lower() == 'q':
            break
        password = input('请输入登录密码').strip()
        # 判断用户名和密码是否对应字典的key及value值，对应的上就给权限操作（删除，更新和查看账号）
        for k, v in data_dict.items():
            if username == k and password == v['pwd']:
                is_user['username'] = username
                print(f'{username}登录账号输入成功')
                break
        else:
            print('请输入正确账号或密码')
            continue

# 2.去重下列列表并保留数据值原来的顺序
# 	eg: [1,2,3,2,1] 去重之后 [1,2,3]
l1 = [2,3,2,1,2,3,2,3,4,3,4,3,2,3,5,6,5]
l2 = []
#解题思路：
#1.循环遍历列表
#2.对遍历的列表数据值放置到一个空列表里
#3.放空列表之前先判断数字是否存在空列表。
#4.如果存在空列表，则忽略添加
#5.如果不存在空列表，则添加列表
#6.最后打印这个空列表
for i in l1:
    if i not in l2:
        l2.append(i)
print(l2)

# 3.有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合
pythons={'jason','oscar','kevin','ricky','gangdan','biubiu'}
linuxs={'kermit','tony','gangdan'}
# 1. 求出即报名python又报名linux课程的学员名字集合
print(pythons & linuxs)
# 2. 求出所有报名的学生名字集合
print(pythons | linuxs)
# 3. 求出只报名python课程的学员名字
print(pythons - linuxs)
# 4. 求出没有同时这两门课程的学员名字集合
print(pythons ^ linuxs)

4.统计列表中每个数据值出现的次数并组织成字典战士
  eg: l1 = ['jason','jason','kevin','oscar']
       结果:{'jason':2,'kevin':1,'oscar':1}
# 真实数据
l1 = ['jason','jason','kevin','oscar','kevin','tony'
# 1. 对该列表进行格式转换，转换成一个新的集合
s1 = set(l1)
#2. 定义个空字典，方便后面统计好数据值放到字典里
d1 = {}
# 3. 对转换好集合进行循环遍历，每个值统计出在列表出现的次数
for i in s1:
# 4.然后把对应的值和统计次数加到一个新的字典里
    d1.update({i:l1.count(i)})
# 5. 最后打印出这个字典的key(值):value(次数)
print(d1)