Python基础知识学习-第10天

21_2.使用格式化文本

使用文本文件持久化存储对象，并导入程序生成表达式：

scores = [99, 88, 77, 66, 55]

def write():
    with open('data_list.txt', 'w', encoding = 'utf8') as f:
        f.write(str(scores))
        print('文件写入成功')

def read():
    with open('data_list.txt', 'r', encoding='utf8') as f:
        # 此时lst的类型是字符串，而不是列表，也就不支持列表的一系列操作
        lst = f.read()
        print('lst的内容是：{}'.format(lst))
        print('lst的类型是：{}'.format(type(lst)))

write()
read()

输出：

文件写入成功
lst的内容是：[99, 88, 77, 66, 55]
lst的类型是：<class 'str'>

如果想将read返回的内容转化为列表类型，可以使用eval（）函数：

scores = [99, 88, 77, 66, 55]

def write():
    with open('data_list.txt', 'w', encoding = 'utf8') as f:
        f.write(str(scores))
        print('文件写入成功')

def read():
    with open('data_list.txt', 'r', encoding='utf8') as f:
        # 此时lst的类型是字符串，而不是列表，也就不支持列表的一系列操作
        lst = eval(f.read())
        print('lst的内容是：{}'.format(lst))
        print('lst的类型是：{}'.format(type(lst)))

write()
read()

输出：

文件写入成功
lst的内容是：[99, 88, 77, 66, 55]
lst的类型是：<class 'list'>

注意不能list(f.read())。
eval() 函数
eval() 函数用来执行一个字符串表达式，并返回表达式的值。
语法
eval(expression[, globals[, locals]])
参数
expression – 表达式。
globals – 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
locals – 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。
返回值
返回表达式计算结果。
实例:

x = 4
y = 5
print(eval('3 * x'))
print(eval('pow(2, x)'))
print(eval('2 + 2'))
print(eval('y - 1'))

输出：

12
16
4
4

21_3.pickle应用

1 序列化为字符串

import pickle
d = {'name':'jack', 'age':'20'}
s = pickle.dumps(d)
print('s的内容是：{}'.format(s))
print('s的类型是：{}'.format(type(s)))
p = pickle.loads(s)
print('p的内容是：{}'.format(p))
print('p的类型是：{}'.format(type(p)))

输出：

s的内容是：b'\x80\x03}q\x00(X\x04\x00\x00\x00nameq\x01X\x04\x00\x00\x00jackq\x02X\x03\x00\x00\x00ageq\x03X\x02\x00\x00\x0020q\x04u.'
s的类型是：<class 'bytes'>
p的内容是：{'name': 'jack', 'age': '20'}
p的类型是：<class 'dict'>

2 序列化对象到文件：

import pickle
d = {'name':'jack', 'age':'20'}
pickle.dump(d, open('pickle_db', 'wb'))
p = pickle.load(open('pickle_db', 'rb'))
print('p的内容是：{}'.format(p))
print('p的类型是：{}'.format(type(p)))

输出：

p的内容是：{'name': 'jack', 'age': '20'}
p的类型是：<class 'dict'>

21_4.shelve应用

import shelve
scores = [99, 88, 77]
student = {'name':'Tom', 'age':'20'}
db = shelve.open('student_db', )
db['s'] = student
db['scores'] = scores
print('db的内容是：{}'.format(db))
print('db的类型是：{}'.format(type(db)))
print('db的长度是：{}'.format(len(db)))
temp_student = db['s']
print('temp_student的内容是：{}'.format(temp_student))
print('temp_student的类型是：{}'.format(type(temp_student)))
del db['s']
print('删除后，db的长度是：{}'.format(len(db)))

输出：

db的内容是：<shelve.DbfilenameShelf object at 0x00000027FA93FA90>
db的类型是：<class 'shelve.DbfilenameShelf'>
db的长度是：2
temp_student的内容是：{'name': 'Tom', 'age': '20'}
temp_student的类型是：<class 'dict'>
删除后，db的长度是：1

使用shelve存储和读取自定义内容：

import shelve
class Student():
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):
        return self.name

class write_shelve():
    s = Student('Tom', 20)
    db = shelve.open('shelve_student_db')
    db['s'] = s
    db.close()

class read_shelve():
    db = shelve.open('shelve_student_db')
    st = db['s']
    print('st的内容是：{}'.format(st))
    print('名字是：{}，年纪是：{}'.format(st.name, st.age))
    db.close()

if __name__ == '__main__':
    write_shelve()
    read_shelve()

输出：

st的内容是：Tom
名字是：Tom，年纪是：20

22_3.字节与文本的编码、解码

s1 = 'abcd'
# 将特定字符编码
print('s1编码后为：{}'.format(s1.encode('ASCII')))
>>>s1编码后为：b'abcd'

尝试执行一下代码时报错：

s1 = '优品课堂'
# 将特定字符编码
print('s1编码后为：{}'.format(s1.encode('ASCII')))

因为指定字符串不在ASCII中。可以将ASCII改为UTF-8:

s1 = '优品课堂'
# 将特定字符编码
print('s1编码后为：{}'.format(s1.encode('utf-8')))
>>>s1编码后为：b'\xe4\xbc\x98\xe5\x93\x81\xe8\xaf\xbe\xe5\xa0\x82'

如果将UTF-8改为UTF-16:

s1 = '优品课堂'
# 将特定字符编码
print('s1编码后为：{}'.format(s1.encode('utf-16')))
>>>s1编码后为：b'\xff\xfe\x18O\xc1T\xfe\x8b\x02X'

将上文编码后的结果再解码：

b1 = b'\xff\xfe\x18O\xc1T\xfe\x8b\x02X'
# 将特定字符解码
print('b1的类型是：{}'.format(type(b1)))
print('b1解码后为：{}'.format(b1.decode('utf-16')))
>>>b1的类型是：<class 'bytes'>
>>>b1解码后为：优品课堂

22_4.bytes,str,bytearray之间的相互转换

将字符串转化为字节：

s = 'abc'
s1 = '优品课堂'
b = bytes(s, 'ASCII')
b1 = bytes(s1, 'utf-8')
print('s转化后为：{}'.format(b))
print('s1转化后为：{}'.format(b1))

输出：

s转化后为：b'abc'
s1转化后为：b'\xe4\xbc\x98\xe5\x93\x81\xe8\xaf\xbe\xe5\xa0\x82'

b = bytes([97, 98, 99])
print(b)
>>>b'abc'

字节型不支持原位改变。
bytearray型：

s = 'abc'
b = bytearray(s, 'ASCII')
print('b的类型是：{}'.format(type(b)))
print('b的内容是：{}'.format(b))
# 往b里面追加元素
b.append(100)
print('修改后b的内容是：{}'.format(b))
# bytearray型可以原位改变
b[0] = 98
print('修改后b变成了：{}'.format(b))

输出：

b的类型是：<class 'bytearray'>
b的内容是：bytearray(b'abc')
修改后b的内容是：bytearray(b'abcd')
修改后b变成了：bytearray(b'bbcd')