疫情环境下的网络学习笔记 python 3.12

3.12

上节课复习

1. 列表：list()，入参：可迭代类型，每次迭代产生的元素入列

   • 循环可以这样写

     for x,y,z in ['abc','bcd','cde']:
     	...
     

     只要x，y，z可以对应上，即迭代对象每个元素都有三个值，就可以运行

2. 元组：tuple()：如果元组中只有一个元素，在元素后一定要加逗号 ,

   只读不改，同样数据量元组比列表更省空间

3. 字典：dict()

   dict(x=1,y=2,z=3)

   dict([’k1’,1],(11,22))

   {}.fromkeys()

改变元组内的可变类型元素中的元素，元组中的内存地址不会变，所以可行

补充

dic.get(key，default)：两个参数，当key存在，返回value，当key不存在，返回第二个参数，第二个参数默认值是None

关于fromkeys初始化字典：{}.fromkeys([’k1’,’k2’],None)

• 创建一个字典，对第一个参数内所有的值作为字典的key，第二个参数作为第一个参数的子元素在字典中的值。
• 此时字典里所有的key指向的是同一个内存地址，因此fromkeys 创建字典时如果用可变类型作为value，那么，改变字典的一个value，别的值也改了

今日内容

1. 集合类型

   • 关系运算
   • 去重

2. 总结与分类

   • 有序 or 无序
   • 存一个值 or 多个值：原子类型 / 容器类型
   • 可变 or 不可变

3. 字符编码

   文本文件

4. 文件处理基础

   基本处理，打开文件，处理，关闭，with

   从此开始从操纵内存转为操纵硬盘

正课

集合

作用

关系运算

friends1 = {"zero","kevin","jason","egon"}
friends2 = {"Jy","ricky","jason","egon"}

需求：得到一个列表，里面存两人共同的朋友：可以用for：

l = []
for i in friends1:
    if i in friends2:
        l.append(i)
print(l)
# ['jason', 'egon']

麻烦，寻求更好的方法，于是引出集合

去重

去除重复的元素

1. 只能针对不可变类型去重

2. 去重后顺序打乱

   所以一般还是用for循环

定义

在花括号 {} 内用逗号 , 分隔开多个元素（不是key:value），多个元素满足以下三个条件：

1. 集合内元素必须为不可变类型

   若创建时元素为可变则报错

2. 集合内元素无序，打印时不会按照原来的顺序输出

3. 集合内元素没有重复，若重复，则自动去除重复的元素

   s = {1,1,1,1,'a'}
   print(s)
   # 输出{1, 'a'}
   

定义一个集合：s = {1,2,’aaa’}，其底层用的方法是 s = set({1,2})

定义一个空集合：s = set() 如果用空花括号，得到的是字典，必须用 set() 方法

类型转换

1. 多个不可变类型转成集合：

   s = set({1,2,3,'aaa'})
   print(s)
   # 输出{'aaa', 1, 2, 3}
   

2. 字典转成集合，放进集合的是key

   s = set({'key1':1,'key2':2})
   print(s)
   # 输出{'key2', 'key1'}
   

3. 字符串转成集合

   set({’hellolll’})：相当于底层调用一个for循环，把字符串每一个字符取出来，去除重复的，放进一个集合，返回一个无序的集合

如果放进去的参数是可变（列表），则报错

集合内置方法

friends1 = {"zero","kevin","jason","egon"}friends2 = {"Jy","ricky","jason","egon"}

运算，重要方法

1. ∩交集：求两人共同好友，取交集

   res = friends1 & friends2
   

2. ∪并集：求两者所有的好友，取并集

   res = friends1 | friends2
   

3. - 差集：集合相减，去除被减集合中交集部分，留下独立部分

   res = friends1 - friends2
   

4. ^ 对称差集：求每个集合独立的部分（A - B ∪ B - A）

   s1 = {1,0,3,'ss'}
   s2 = {1,2,3,5}
   print(s1 ^ s2)
   # {0, 2, 5, 'ss'}
   

5. 父子集 <,> ：返回包含关系

   对于非子集的集合，不存在包含关系， <,>运算都返回false， 对于子集，子集合 < 父集合

其他方法

需要掌握

1. 删除元素 ：set.discard(item)，如果item是集合成员，删除，如果不是集合成员，什么也不做
2. 指定删除元素：set.remve(item)，指定元素删除，不存在这个元素则报错
3. 更新集合：set.update({set}) ，将新集合加入老集合，再去重
4. 随机删除：s.pop()，无传入参数，随机删除一个元素，返回被删除的元素
5. 单独加一个元素：s.add(item)

其他方法

1. 成员运算

2. 长度len()

3. 循环for

4. 求差更新：s.difference_update({})，两个集合求差，结果赋值给s，只用difference则不会赋值

   同样有求交更新，堆成差集更新等等

5. 随机删除：s.pop()

6. 单独加一个元素：s.add()

7. 判断两个集合互相独立：s.disjoint()，判断两个集合无交集，是则返回True

所有数据类型总结

有序 无序

访问方式

可变 不可变

存值的个数

字符编码

非常重要

引入

文本文件是由字符组成的，数据类型中的字符串也是用字符编码的

基本知识：

1. 计算机三大核心硬件

2. 程序的运行方法：存在内存，读入内存，cpu执行。软件运行中产生的数据都存在内存当中

3. 文本编辑器读取文件内容的流程

   启动软件，由硬盘读入内存，显示

4. python解释器执行文件的流程

什么是字符编码

计算机只能看懂二进制，人只能看懂人类字符。存数据的时候不存人类字符，只存二进制，因此其中一定发生了一个翻译过程：规定好什么字符对应什么数字，那么只要人输入数据，计算机就翻译成机器的字符存入内存，该人类字符与数字对应关系（规则）就是字符编码表

• 字符编码：字符与数字的一个对应关系表

字符编码表的发展史：一家独大，诸侯割据，归于统一

统一阶段：

ASCII表

1. 只支持英文字符串
2. 采用8位二进制数对应一个英文字符串，最大有2^8 种表达方法

分割阶段：

需要别的标准，以输入除英文以外的字符，且需要更多的表达方式

GBK表

1. 支持英文，中文字符
2. 采用16位（16bit = 2Bytes）二进制数对应一个中文字符，2^16，6万5千多种表达方法，99%的汉字能编码进去
3. 在发明的时候只建立了中文，英文与数字的对应关系

Shift_JIS：

1. 支持日文，英文字符

各国都建立自己的编码表，不利于流通。需要有一种能够兼容万国字符的编码表

统一阶段：

Unicode，内存中统一使用Unicode表：

1. 兼容万国字符
2. 妥协功能：与万国字符编码表都有对应关系
3. 采用16位（16bit = 2Bytes）二进制对应一个中文字符串，个别生僻会用4Bytes，8Bytes

Unicode

相当于建立了一个中转站，所有的字符都在内存中可以转成Unicode，可以直接用Unicode存入硬盘。对历史文件，不是使用Unicode编码储存的，因为Unicode有与其对应关系，所以也可以使用Unicode写这些历史文件

对于以前用GBK，Shift_JIS编码，都可以转化成Unicode进行读或写，但是不能通过Unicode再转成别的编码。所以如果希望硬盘里存的格式是GBK或着Shift-JIS，那么只能输入对应的文字，否则因为没有其对应的字符，会存乱

并且由于Unicode固定使用两个字节来存储一个字符，如果多国字符中包含大量的英文字符时，使用Unicode格式存放会额外占用一倍空间（英文字符其实只需要用一个字节存放即可），然而空间占用并不是最致命的问题，最致命地是当我们由内存写入硬盘时会额外耗费一倍的时间

utf-8

为了解决Unicode的问题，将内存中的unicode二进制写入硬盘或者基于网络传输时必须将其转换成一种精简的格式，这种格式即utf-8

utf-8：Unicode的一个转换方式，把英文字符和数字转成1Bytes，汉字转成3Bytes等等

结论

1. 内存固定使用Unicode，我们可以改变存入硬盘的格式

编码与解码

编码：由字符转换成内存中的unicode，以及由unicode转换成其他编码的过程

解码：由内存中的unicode转换成字符，以及由其他编码转换成unicode的过程

乱码的情况

1. 存乱了

   存入硬盘时，按照不适用的编码表编码，数据丢失，严重的问题

2. 取乱了

   从硬盘种读取数据时，按照不适用的编码表读取，无法被正常读取。这时换用解码方法可以解决：用什么方式存的，就用什么方式取

解决方法：使用utf-8进行编码

windows默认存是用GBK

下午

pycharm右下角标记的UTF-8，意思是往硬盘存的是utf-8格式的二进制

python解释器默认读文件的编码：python3默认为Unicode，python2默认用ASCII

文件头

指定文件头修改默认的编码，告诉python用这种方式读

在文件首行：# coding:

# coding:gbk

要保证执行python程序前两个阶段不乱码：指定文件头 #coding: ，与文本当初被存入硬盘时的编码方式一致

pycharm管你的程序用什么方式存，在右下角可以选择

保证程序执行第三个阶段不乱码

python3中字符串直接在内存中直接存成Unicode，所以不会乱码

python2诞生的年代比Unicode早，所以不会默认存成Unicode

保证str在python2中不乱码：在每一个字符串前面加个小写 u ，强制存成Unicode

str = u'字符串'

了解：

1. python2解释器中有两种字符串类型：str，Unicode

   • Unicode类型：
   • str类型：x = ’上’，字符串直接按照文件头的

2. GBK会拿每一组1个bytes中8个比特位的前一位，作为英文与中文的标识信息，用来判断怎么取。如果首位是1，表示是中文字符，取2个bytes，如果首位是0，表示是英文字符，取1个bytes。

   ‘上’ 在gbk中编码为494f，实际上存的是c9cf，因为每一个bytes头一位用于表示其是英文字符还是中文字符，所以发生了变化

python3编码转码方法，pycharm中

编码成gbk

x = '上'
res = x.encode('gbk')  # 将Unicode转成gbk
print(res,type(res))
# b'xc9xcf' <class 'bytes'>

怎么编码的，就应该怎么解码，如果不用gbk解码，则报错

print(res.decode('gbk'))
# 上

今日总结

1. 集合：关系运算，去重

2. 字符编码：哪些地方会涉及到乱码问题：三个阶段

3. 怎么保证python程序不乱码：

   • python3：不需要操作，pycharm默认用utf-8存

   • python2：加文件头：在文件首行加#coding utf-8: 指定运行读取的时候用的编码

   • python2中定义字符串：在字符串前面加小写的u，强制存为Unicode

     x = u'str'
     

   • 在python3中只要是Unicode，就会被解码成字符，而python2中在列表里，Unicode不会被解码