持久化有多种方式：主要有存储为扁平文件（文本文件）、pickle模块、shelve模块、数据库、ORM。
之后我们学习了字符串的实质，字符串编码之间的关系，以及Python中将字符串编码到字节和字节解码为字符串操作的过程。

一、对象持久化

持久化类:就是一个实体类 与 数据库表建立了映射.
Hibernate为了方便管理持久化类,将持久化类分成了三种状态.
瞬时态 transient :(临时态)特点：持久化对象没有唯一标识OID.没有纳入Session的管理
持久态persistent : 特点：持久化对象有唯一标识OID.已经纳入到Session的管理
脱管态 detached:(离线态)特点：持久化对象有唯一标识OID,没有纳入到Session管理

01存储为扁平文件（文件格式）

用open打开文件，并写入单词

>>>with open('date.txt','w',encoding='utf8') as f:
>>>    f.write('富佑多科技\n')
>>>    f.write('codeclassroom.com')
>>>     #自动会保存到对应的目录下，有个date，txt

运行结果

python hid操作 python hibernate_python hid操作


存储为扁平文件不好还原对象的格式，如下图将一个列表对象存储为字符串存入文档中，在读取时将文件变为列表，对列表原位改变

scores = [88,99,77,55]     #创建一个列表

def write_scores():        #创建函数，把scores存到文本文件
    with open('date_list.txt','w',encoding='utf8') as f:   
         f.write(str(scores))                               
    print('文件写入完成...')


if __name__ =='__main__':   #调用刚刚
    write_scores()

程序运行结果：

文件写入完成...

python hid操作 python hibernate_持久化_02


可以使用eval（)函数——可将字符串还原成表达式

scores = [88,99,77,55]     #创建一个列表

def write_scores():        #创建函数，把scores存到文本文件
    with open('date_list.txt','w',encoding='utf8') as f:   
         f.write(str(scores))                               
    print('文件写入完成...')


def read_scores():        #创建函数，把scores存到文本文件
    with open('date_list.txt','w',encoding='utf8') as f:   
         lst = eval（f.read(str())    #把文本文件改成Python语句                           
    lst[0] = 99                #把列表第一个字符改成99
    print(lst)

if __name__ =='__main__':   #调用刚刚
    read_scores()

程序运行结果：

[99,99,77,55]

02、pickle模块

pickle模块可以保持对象的格式
pickle序列化为字符串：pickle.dumps(obj) : 将对象序列为字符串 、 pickle.loads(s) ：从字符串反序列化对象

>>>import picket 
>>>person = {'name':'Tom','age':20}
>>>s = pickle.dumps(person)
>>>s
b'\x80\x03}q\x00(X\x04\x00\x00\x00nameq\x01X\x03\x00\x00\x00Tomq\x02X\x03\x00\x00\x00ageq\x03K\x14u.'
>>>p = pickle.loads(s)
>>>p
>>>Out[11]: {'name': 'Tom', 'age': 20}
>>>type(p)
 dict
>>>person
{'name': 'Tom', 'age': 20}

pickle序列化对象到文件：
pickle.dump(obj,file)
pickle.load(file)

03、shelve模块

pickle模块可以将对象类型保持，但是同时存储多个对象时容易发生错误，shelve模块可以同时持久化多个不同类型的对象

db = shelve.open('dbfile')  
db.close()
db['key'] = obj    #以字典表的形式将对象传入
len(db)
del db['key']
>>>import shelve
>>>scores = [99,98,77]
>>>student = {'name': 'Tom', 'age': 20}
>>>db = shelve.open('shelve_student')
>>>db['s'] = student
>>>db['scores'] = scores
>>>len(db)             #存在几个对象
Out[23]: 2
>>>temp_student=db['s']             #怎么访问
>>>temp_student
Out[26]: {'name': 'Tom', 'age': 20}
class Student:
     def __init__(self,name,age):
          self.name = name
          self.age = age
     def __str__(self):
         return self.name


if __name__ == '__main__':
     s = Student('Tom',20)
     print(s.name)
     print(s.age)

运行结果

Tom
20

创建文件

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


def write_shelve():
    s = Student('Tom', 20)
    db = shelve.open('shelve_student_db')   #创建shelve_student_db文件
    db['s'] = s
    db.close()


if __name__ == '__main__':
    write_shelve()

读取文件

import shelve

class Student:
     def __init__(self,name,age):
          self.name = name
          self.age = age
     def __str__(self):
         return self.name


def write_shelve():
    s = Student('Tom', 20)
    db = shelve.open('shelve_student_db')   #创建shelve_student_db文件
    db['s'] = s
    db.close()


def read_shelve():
    db = shelve.open('shelve_student_db')
    st = db['s']
    print(st)
    print(st.name)
    print(st.age)
    db.close()

if __name__ == '__main__':
    read_shelve()

运行结果

Tom
Tom
20

二、字符串操作

类型

：str字符串、bytes字节、bytearray字节数组

字符编码架构：

python hid操作 python hibernate_python_03


字符集：赋值一个编码到某个字符，以便在内存中表示，常用的字符集有utf-8、ASCII、gbk……

编码encoding：转换字符到原始的字节形式，编码只适用于文件存储或中间媒介转换时

解码 Decoding：依据编码名称转换原始字节到字符的过程，内存中总是存储解码以后的文本

字符串存储

编码只作用于文件存储或中间媒介转换时
内存中总是存储解码以后的文本

字符编码（字符集）

ASCII：存储在Byte 0-127 存储数字，字母，常用标点
latin-1：存储在一个Bytes 128-255 存储拉丁字母等
UTF-8：是可变字节的编码格式，也是最常用的编码格式，其中0-127使用单字节，128-2047双字节，>2047三到四字节，
UTF-16：2 字节存储字符 （另加2Byte作为标识）
UTF-32：4字节

内置函数

ord() 获取字符代码点
chr() 获取代码对应字符
str.encode(‘ASCII/UTF-8’) 将特定字符编码
bytes.decode('编码‘） 将字符串解码为字符文本
注：encode() decode()在不指定字符集时是utf8编码 ，文件操作在不指定读写操作时是gbk编码

类型转换

将字符串转换为字节
手动声明 b’’
字符串编码 str.encode()
构造函数 bytes()
将字符串转换为字节数组bytearray，字节数组虽然是字节但可以使用列表的操作方法，如+,append
bytearray(‘字符’,‘编码’)
.decode() 解码为字符串

BOM处理

读取别人的文档时有时会发现字符串前面出现\ufeff而后面却没有问题，这是由于在存储时加入了字节存储顺序，不是由于解码与编码格式不同造成的仔解码时加上-sig可以解决这个问题
自己存储文档时也可以加上字节存储顺序，只要加上-sig标识

正则表达式

正则表达式：正则表达式是一种文本模式，描述在搜索文本时要匹配一个或多个字符串
典型场景：数据验证、文本扫描、文本提取、文本替换、文本分割
模式语法：字面值（普通字符、需转义字符符号\ ^ $ . | * + () [] {}）、具有特殊含义的元字符
匹配规则：
单字，预定义元字符

  • . 匹配除\n以外的所有字符
  • \d 匹配数字，等同于[0-9]
  • \D 匹配非数字，等同于[^0-9]
  • \s 匹配空白字符 \t\n\r\f\v
  • \S 匹配非空字符串[^\t\n\r\f\v]
  • \w 匹配数字、字母、字符[a-zA-Z0-9_]
  • \W 匹配非字母数字下划线[^a-zA-Z0-9_]
    匹配备选
  • | yes|no
    匹配多字
  • ？ 0次或1次
  • *0次或多次
  • +1次或多次
  • {n,m} 匹配n~m次任意
  • {n} 匹配n次
  • {n,} 匹配至少n次
  • {,m} 匹配最多m次
    贪婪与非贪婪
    默认贪婪：尽量匹配最大范围的结果
    非贪婪：尽量匹配最小范围的结果、使用量词后面使用?标注
    边界匹配
  • ^ 行首
  • $ 行尾
  • \b 单词边界
  • \B 非单词边界
  • \A 输入开头
  • \Z 输入结尾

三、总结

python hid操作 python hibernate_文本文件_04