文章目录
每日测验
1、用列表模拟队列的入队与出队操作,FIFO
2、用列表模拟堆栈的入队与出队操作,LIFO
3、有列表l=['egon','alex_sb','lxx']从列表中取走/剪切走傻逼，并赋值给新变量
res=l.pop(1)
4、什么是元组？它用在何处
5、元组不可变指的是元组内的什么不可改变
6、t=(1,2,['AA']) # 针对改元组能够把'aa'改成'AA'，这与元组不可变是否冲突
7、在我无法确定key是否存在的情况下，如何从字典中取值才能保持程序不会出错
>>> res=d.get('name',None)
>>> print(res)
None
8、列表能否通过不存在索引增加元素，字典能否通过不存在key增加元素，
9、简述python3中dict.keys()、dict.values()、dict.items()包含的内容及
与python2的区别
10、用代码分别示范：for循环遍历我们所学过的所有可遍历的类型
昨日内容回顾
一：列表类型
list(可以被for循环遍历的类型)
#优先掌握的操作：
#1、按索引存取值(正向存取+反向存取)：即可改也可以取
l=[111,222]
# 超过索引范围就会报错
l[2]
l[2]=333
#2、切片(顾头不顾尾，步长)
#3、长度
#4、成员运算in和not in
#5、追加
#6、删除
#7、循环
for x,y,z in ['abc','def','hba']: # x,y,z=1
...
for x,y,z in [('a',1,2),'def',['bbb',12,3]]: # x,y,z=('a',1,2)
...
二：元组类型
tuple()
如果元组中只有一个元素,记住加逗号:t=(1,)
#优先掌握的操作：
#1、按索引取值(正向取+反向取)：只能取
#2、切片(顾头不顾尾，步长)
#3、长度
#4、成员运算in和not in
#5、循环
三：字典类型
注意：字典key必须是不可变的，而且不能重复
dict(x=1,y=2,z=3)
dict([('k1',1),('k2',2)])
{}.fromkeys(['k1','k2'],None)
#优先掌握的操作：
#1、按key存取值：可存可取
d={'k1':1}
d['k2']=2
#2、长度len
#3、成员运算in和not in
#4、删除
#5、键keys()，值values()，键值对items() # [('k1',111)]
for
list(dic.keys())
tuple(dic.values())
#6、循环
今日内容概要
1、集合类型
关系运算
去重（有局限性）
2、总结与分类
有序or无序：有序又称之为序列类型
存一个值or多个值：存一个值称为原子类型，存多个值称为容器类型
可变or不可变
3、字符编码（理论多，结论少）
文本文件
x='上'
4、文件处理基本基础
今日内容详细
集合
作用
关系运算
friends1 = ["zero", "kevin", "jason", "egon"]
friends2 = ["Jy", "ricky", "jason", "egon"]
l = []
for x in friends1:
if x in friends2:
l.append(x)
print(l)
去重
1、只能针对不可变类型去重
print(set([1, 1, 1, 1, 2]))
2、无法保证原来的顺序
l=[1, 'a', 'b', 'z', 1, 1, 1, 2]
l=list(set(l))
print(l)
l=[
{'name': 'lili', 'age': 18, 'sex': 'male'},
{'name': 'jack', 'age': 73, 'sex': 'male'},
{'name': 'tom', 'age': 20, 'sex': 'female'},
{'name': 'lili', 'age': 18, 'sex': 'male'},
{'name': 'lili', 'age': 18, 'sex': 'male'},
]
new_l=[]
for dic in l:
if dic not in new_l:
new_l.append(dic)
print(new_l)
定义
在{}内用逗号分隔开多个元素，多个元素满足以下三个条件:
1. 集合内元素必须为不可变类型
2. 集合内元素无序
3. 集合内元素没有重复
s = {1, 2} # s=set({1,2})
s = {1, [1, 2]} # 集合内元素必须为不可变类型
s = {1, 'a', 'z', 'b', 4, 7} # 集合内元素无序
s = {1, 1, 1, 1, 1, 1, 'a', 'b'} # 集合内元素没有重复
print(s)
# 了解
s = {} # 默认是空字典
print(type(s))
# 定义空集合
s = set()
print(s, type(s))
类型转换
set({1, 2, 3})
res = set('hellolllll')
print(res)
print(set([1, 1, 1, 1, 1, 1]))
print(set([1, 1, 1, 1, 1, 1, [11, 222]]) # 报错
print(set({'k1': 1, 'k2': 2})) # {'k1', 'k2'}
内置方法
关系运算符
friends1={"zero", "kevin", "jason", "egon"}
friends2={"Jy", "ricky", "jason", "egon"}
取交集：两者共同的好友
res=friends1 & friends2
print(res)
print(friends1.intersection(friends2))
取并集/合集：两者所有的好友
print(friends1 | friends2)
print(friends1.union(friends2))
取差集：取friends1独有的好友
print(friends1 - friends2)
print(friends1.difference(friends2))
取friends2独有的好友
print(friends2 - friends1)
print(friends2.difference(friends1))
对称差集: 求两个用户独有的好友们（即去掉共有的好友）
print(friends1 ^ friends2)
print(friends1.symmetric_difference(friends2))
父子集：包含的关系
s1={1, 2, 3}
s2={1, 2, 4}
# 不存在包含关系，下面比较均为False
print(s1 > s2)
print(s1 < s2)
s1={1, 2, 3}
s2={1, 2}
print(s1 > s2) # 当s1大于或等于s2时，才能说是s1是s2他爹
print(s1.issuperset(s2))
print(s2.issubset(s1)) # s2 < s2 =>True
s1={1, 2, 3}
s2={1, 2, 3}
print(s1 == s2) # s1与s2互为父子
print(s1.issuperset(s2))
print(s2.issuperset(s1))
其他操作
长度
>>> s={'a','b','c'}
>>> len(s)
3
成员运算
>>> 'c' in s
True
循环
>>> for item in s:
... print(item)
...
c
a
b
'''
其他内置方法
s={1, 2, 3}
discard
不同于remove删除元素
s.discard(4) # 如果删除元素不存在 do nothing
print(s)
s.remove(4) # 删除元素不存在则报错
update
添加不同的元素
s.update({1, 3, 5})
print(s)
pop
res=s.pop()
print(res)
add
s.add(4)
print(s)
了解的方法
isdisjoint
isdisjoint() 方法用于判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。。
res=s.isdisjoint({3, 4, 5, 6}) # 两个集合完全独立、没有共同部分，返回True
print(res)
difference_update
difference_update() 方法与 difference() 方法不同，因为 difference() 方法返回一个新集合，其中没有不需要的项目，而 difference_update() 方法从原始集中删除了不需要的项目。
s.difference_update({3, 4, 5}) # s=s.difference({3,4,5})
print(s)
字符编码
分析过程
x="上"
内存
上-------翻译-----》0101010
上《----翻译《-----0101010
字符编码表就是一张字符与数字对应关系的表
a-00
b-01
c-10
d-11
ASCII表：
1、只支持英文字符串
2、采用8位二进制数对应一个英文字符串
GBK表：
1、支持英文字符、中文字符
2、
采用8位（8bit=1Bytes）二进制数对应一个英文字符串
采用16位（16bit=2Bytes）二进制数对应一个中文字符串
unicode（内存中统一使用unicode）：
1、
兼容万国字符
与万国字符都有对应关系
2、
采用16位（16bit=2Bytes）二进制数对应一个中文字符串
个别生僻会采用4Bytes、8Bytes
unicode表：
内存
人类的字符---------unicode格式的数字----------
| |
| |
|
硬盘 |
|
| |
| |
GBK格式的二进制 Shift-JIS格式的二进制
老的字符编码都可以转换成unicode，但是不能通过unicode互转
utf-8：
英文->1Bytes
汉字->3Bytes
结论
1、内存固定使用unicode，我们可以改变的是存入硬盘采用格式
英文+汉字-》unicode-》gbk
英文+日文-》unicode-》shift-jis
万国字符》-unicode-》utf-8
2、文本文件存取乱码问题
存乱了：解决方法是，编码格式应该设置成支持文件内字符串的格式
取乱了：解决方法是，文件是以什么编码格式存如硬盘的，就应该以什么编码格式读入内存
3、python解释器默认读文件的编码
python3默认：utf-8
python2默认：ASCII
指定文件头修改默认的编码：
在py文件的首行写：
#coding:gbk
4、保证运行python程序前两个阶段不乱码的核心法则：
指定文件头
# coding:文件当初存入硬盘时所采用的编码格式
5、
python3的str类型默认直接存成unicode格式，无论如何都不会乱码
保证python2的str类型不乱码
x=u'上'
6、了解
python2解释器有两种字符串类型：str、unicode
# str类型
x='上' # 字符串值会按照文件头指定的编码格式存入变量值的内存空间
# unicode类型
x=u'上' # 强制存成unicode
# coding:utf-8
x='上'
res=x.encode('gbk') # unicode--->gbk
# print(res,type(res))
print(res.decode('gbk'))
作业
一.关系运算
有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合
pythons={'alex','egon','yuanhao','wupeiqi','gangdan','biubiu'}
linuxs={'wupeiqi','oldboy','gangdan'}
1. 求出即报名python又报名linux课程的学员名字集合
2. 求出所有报名的学生名字集合
3. 求出只报名python课程的学员名字
4. 求出没有同时这两门课程的学员名字集合
二.去重
1. 有列表l=['a','b',1,'a','a']，列表元素均为可hash类型，去重，得到新列表,且新列表无需保持列表原来的顺序
2.在上题的基础上，保存列表原来的顺序
3.去除文件中重复的行，肯定要保持文件内容的顺序不变
4.有如下列表，列表元素为不可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'},
]