集合、字符编码

一、集合

# pythoners=[‘王大炮‘,‘李二丫‘,‘陈独秀‘,‘艾里克斯‘,‘wxx‘,‘欧德博爱‘]
# linuxers=[‘陈独秀‘,‘wxx‘,‘egon‘,‘张全蛋‘]
#
# l1=[]
# for stu in pythoners:       #将列表中的元素循环取出
#     if stu in linuxers:     #通过in判断stu是否在linuxers列表中
#         # print(stu)
#         l1.append(stu)      #如果pythoners列表中的元素在列表linuxers中，将stu添加到空列表中
#
# print(l1)
#
# l2=[]
# for stu in pythoners:      #stu在pythoners中，不在linuxers中就将其添加到空列表中
#     if stu not in linuxers:
#         # print(stu)
#         l2.append(stu)
#
# print(l2)

#一：基本使用
# 1 用途: 关系运算、通过关系运算进行去重
#
# 2 定义方式:{}内用逗号分隔开多个元素，每一个元素都必须是不可变（即可hash）类型
#强调：
#2.1 集合内元素都必须是不可变（即可hash）类型
#2.2 集合内的元素无序
#2.3 集合内的元素不能重复

# s={1,2,‘a‘} #s=set({1,2,‘a‘})     #集合内的元素都为不可变类型
# print(type(s))

# s={1.1,1,‘aa‘,(1,2,3),{‘a‘:1}}      #放入可变类型会报错TypeError: unhashable type: ‘dict‘
#
# s={1,‘a‘,‘hello‘,(1,2,3),4}         #元组为不可变类型，所以不会报错
# for item in s:                        #用for循环取出集合中的元素
#     print(item)

# s={1,1,1,1,1,1,1,1,1,‘a‘,‘b‘,‘a‘}
# s={(1,2,3),(1,2,3),‘a‘,‘b‘,‘a‘}     # #集合中的元素有重复的
# print(s)                     #打印结果会自动帮我们去重{‘a‘, ‘b‘, (1, 2, 3)}
# s=set(‘hello‘)           #set会将字符串转换成集合{‘e‘, ‘o‘, ‘l‘, ‘h‘}
# print(s)

# 单纯的用集合去重，需要注意的问题是
#1、去重的目标所包含的值必须都为不可变类型（集合中放可变类型为报错）
#2、去重的结果会打乱原来的顺序      （因为集合是无序的）
# names=[‘asb‘,‘asb‘,‘asb‘,‘wsb‘,‘wsb‘,‘egon_nb‘]      #该列表可以成功转为集合{‘wsb‘, ‘asb‘, ‘egon_nb‘}
# names=[‘asb‘,‘asb‘,‘asb‘,‘wsb‘,‘wsb‘,‘egon_nb‘,[1,2,3]]
# s=set(names)         #不能将列表转为集合，因为列表中放入的元素含有可变类型的列表
# print(s)
# names=list(s)         #可以将集合再转换成列表，list的底层原理就是循环集合中的元素，然后将其添加到列表中
# print(names)          #[‘egon_nb‘, ‘wsb‘, ‘asb‘]

#
# 3 常用操作+内置的方法
#优先掌握的操作：
#1、长度len
# pythoners={‘王大炮‘,‘李二丫‘,‘陈独秀‘,‘艾里克斯‘,‘wxx‘,‘欧德博爱‘}
# print(len(pythoners))

#2、成员运算in和not in
# print(‘李二丫‘ in pythoners)          #通过in判断元素是否在集合中

pythoners={‘王大炮‘,‘李二丫‘,‘陈独秀‘,‘艾里克斯‘,‘wxx‘,‘欧德博爱‘}
linuxers={‘陈独秀‘,‘wxx‘,‘egon‘,‘张全蛋‘}
#3、|并集
# print(pythoners | linuxers)
# print(pythoners.union(linuxers))

#4、&交集
# print(pythoners & linuxers)    #两者调换顺序不影响交集的结果
# print(pythoners.intersection(linuxers))   #点intersection取交集
# print(linuxers & pythoners)
#5、-差集
# print(pythoners - linuxers)
# print(pythoners.difference(linuxers))
# print(linuxers - pythoners)
# print(linuxers.difference(pythoners))
#6、^对称差集
# print(pythoners ^ linuxers)    #上尖号取两个集合的补集
# print(pythoners.symmetric_difference(linuxers))

# print(linuxers ^ pythoners)
#7、==
# s1={1,2,3}
# s2={1,2,3}
# print(s1 == s2)

#8、父集(包含关系)：>,>=
s1={1,2,3,4,5}
# s2={1,2,3}
# print(s1 > s2) # s1包含s2   #该条件成立则说明s1包含s2
# print(s1.issuperset(s2))    #True   s1是s2的父集
# print(s2.issubset(s1))      #True   s2是s1的子集

# s3={1,2,10}
# print(s1 > s3)      #s1与s3没有包含关系，所以结果为False

# s1={1,2,3,4,5}
# s2={1,2,3,4,5}
# print(s1 >= s2)

#9、子集(被包含的关系)：<,<=

# s1={1,2,3,4,5}
# s1.add(6)         #用点add向集合中添加元素
# print(s1)

# s1.update({4,7,8,9})   #通过update更新原集合即s1中的元素，有则不加，无责加上{1, 2, 3, 4, 5, 7, 8, 9}
# print(s1)

# res=s1.pop()     #随机删除集合中的一个元素，可以把集合中的元素换成一个字母就可以看到每次删除的结果是不一样的
# print(res)

# res=s1.remove(4)     #remove删除集合中指点的元素，但是其没有返回值,当移除的元素不存在的时候会报错
# print(res)        #返回值为None
# print(s1)

# s1={1,2,3,4,5}
# s2={2,3,7,8}
# s1=s1 - s2      #集合做差，去掉两者的共有部分，留下被减集合中的元素{1, 4, 5}
# print(s1)
# s1.difference_update(s2) # s1=s1 - s2
# print(s1)

# s1={1,2,3,4,5}
# s1.pop()
# s1.remove(7)     #删除不存在的元素会报错 KeyError: 7
# s1.discard(7) # 即便要删除的元素不存在也不会报错

# s1={1,2,3,4,5}
# s2={5,6,7,8}
# s2={6,7,8}                  #两者交集为空，则返回为True
# print(s1.isdisjoint(s2))      #两个集合交集不为空，则返回Flase

#
# #二：该类型总结
# 1 存一个值or存多个值
#     可以存多个值，值都必须为不可变类型
#
# 2 有序or无序
# 无序
#
# 3 可变or不可变
# set集合是可变类型
# s={1,2,3}
# print(id(s))
# s.add(4)
# print(s)
# print(id(s))        #集合可变类型添加前后，集合的id不变

#=====================集合的去重==========================
# 单纯的用集合去重，需要注意的问题是
#1、去重的目标所包含的值必须都为不可变类型
#2、去重的结果会打乱原来的顺序
# names=[‘asb‘,‘asb‘,‘asb‘,‘wsb‘,‘wsb‘,‘egon_nb‘,[1,2,3]]
# s=set(names)

# names=list(s)
# print(names)

stu_info=[
    {‘name‘:‘egon‘,‘age‘:18,‘sex‘:‘male‘},
    {‘name‘:‘egon‘,‘age‘:18,‘sex‘:‘male‘},
    {‘name‘:‘egon‘,‘age‘:18,‘sex‘:‘male‘},
    {‘name‘:‘alex‘,‘age‘:73,‘sex‘:‘male‘},
    {‘name‘:‘oldboy‘,‘age‘:84,‘sex‘:‘female‘},
]
#列表中的集合本质就是列表中的一个元素
# new_info=[]
# for info in stu_info:          #循环取出列表中的集合，即列表的元素
#     if info not in new_info:   #如果列表中没有info这个元素，即没有info这个集合，就将其加入到列表中，即将一个元素加入到列表中
#         new_info.append(info)
#
# print(new_info)

二、字符编码

1 字符编码
    将人类的字符编码/转换成计算机能识别的数字
    这种转换必须遵循一套固定的标准，该标准无非是
    人类字符与数字的对应关系，称之为字符编码表

00
01
10
11

A---->0000 0000
B---->0000 0001
c---->0000 0002
d---->0000 0003

bit：二进制位
Bytes：字节

ASCII码表：用1Bytes表示一个英文字符
1英文字符=8bit=1Bytes

GBK：用2Bytes表示一个中文字符，1Bytes去表示英文字符

unicode:内存中使用的是unicode编码，unicode把全世界的字符都建立好对应关系
    用2Bytes去表示一个字符

    0000 0000 0000 0000

    utf-8 #unicode tranform format-8
        utf-8 用1Bytes表示英文，用3Bytes表示中文

#字符编码需要记住的概念
#01 内存中固定使用unicode编码，==========我们唯一可以改变的存储到硬盘时使用的编码===========
#02 要想保证存取文件不乱乱码，应该保证文档当初是以什么编码格式存的，就应该以什么编码格式去读取

#03 python3解释器默认编码是UTF-8
    python2解释器默认编码是ASCII

    在python2中有两种字符串编码格式
        1、unicode：
            x=u‘上‘
        2、unicode编码后的结果
            x=‘上‘ #如果文件头为coding:utf-8,那么"上"被存成utf-8格式的二进制

    在python3只有一种字符串编码格式：
        1、unicode
            x=‘上’

#04  编码与解码
    unicode-------编码encode-------->gbk
    unicode<-------解码decode--------gbk

    #***
    #coding:gbk
    x=‘上’
    x.decode(‘gbk‘)

    #coding:gbk
    x=u‘上‘
    x.encode(‘gbk‘)
    x.encode(‘utf-8‘)

    #在python3中（*****）
    x=‘上‘
    x只能进行编码
    x.encode(‘gbk‘)

    总结python2与python3：
        (***)
        在python2中的字符粗类型str都是unicode按照文件头的指定的编码，编码之后的结果
        在python2中也可以制造unicode编码的字符串。需要在字符串前加u

        (*****)
        在python3中的字符串类型str都是unicode编码的
        所以python3中的字符串类型可以编码成其他字符编码格式，编码的结果
        是bytes类型

原文地址：https://www.cnblogs.com/sui776265233/p/9122854.html