Python: 系统编程

# coding: utf-8

#打开2000个文件
lst = []
for _ in range(2000):
    lst.append(open('test'))
# OSError: [Error 24] Too many open files: 'test'

print(len(lst))

ps aux |grep python

lsof -p 9255|grep test| wc -l

ulimit -a
open file  1024 # 能打开的文件描述符数，默认1024

# coding: utf-8

f = open('d:/tmp/test')
try:  #尝试捕获try异常
    print(f.closed)
    f.write('abc')
    print(f.read())
finally:
    f.close()

print(f.closed)

with 对象 [as 标识符]:
    pass 

# coding: utf-8

with open('d:/tmp/test') as f: #在文件对象with它，as f，f 就是该文件对象 f = open('d:/tmp/test')
    print(f)
    print(f.closed) #是不关闭
    print(f.read())
    #with语句块结束了，自动调用该文件对象的close方法，出错时也会调用close方法

f = open('d:/tmp/test')
with f:
    print(f)
    print(f.closed)
    print(f.read())
    #哪怕出现异常，离开with时，依然调用with后文件对象的close方法

print(f.closed) #True

. #非多行和单行下，默认匹配除换行符之外任意一个字符
\w\w #匹配2个字符
\d #匹配1个数字
[abc ] #匹配abc和空格中任意一个字符
[abc\s] #匹配abc和空格字符中任意一个字符
\w\s\w #匹配c x和z换行1和3换行中
[\d\s\d] #相当于[\d\s] 匹配数字和空白字符中任意字符
\b\w\w\b #即作词首又作词尾，匹配中文

\w\w?  #匹配一个字符，后面可有可无一个字符
\w\w+  #匹配一个字符，后面至少有一个字符的字符串。可匹配abc, xyz, 123, 中文

#零宽断言
- (?=exp)  从左向右的顺序环视，又叫零宽度正预测先行断言。断言exp一定在匹配的右边出现，也就是说断言后面一定跟个exp
- (?<=exp) 从右向左的逆序环视，又叫零宽度正回顾后发断言。断言exp一定出现在匹配的左边出现，也就是说前面一定有个exp前缀

#负向零宽断言
- (?!exp) 顺序环视的取反，又叫零宽度负预测先行断言。断言exp一定不会出现在右侧，也就是说断言后面一定不是exp
- (?<!exp) 逆序环视的取反，又叫零宽度负回顾后发断言。断言exp一定不能出现在左侧，也就是说断言前面一定不能是exp
- (?#comment) 注释

# 顺序环视
f(?=oo) #匹配f，但f后面一定有oo出现

# 逆序环视，这里能逆序匹配成功，靠的是锚定括号后面的ood\ook
(?<=f)ood #匹配ood，ook前一定有t出现
(?<=t)ook #匹配ook，ook前一定有t出现

# 顺序否定环视
foo(?!d) #匹配foo，但foo后面一定不是d
\d{3}(?!\d) #匹配3位数字，断言3位数字后面一定不能是数字

# 逆序否定环视
(?<!f)ood #匹配ood，但ood的左边一定不是f

#注释
f(?=oo)(?#这个后断言不捕获)

import re

a = 'wood took foot food'

findall = re.findall('f(?=oo)', a)
print(findall) # ['f', 'f']

代码 说明 举例
*? 匹配任意次，但尽可能少重复 
+? 匹配至少1次，，但尽可能少重复 
?? 匹配0次或1次，，但尽可能少重复 
{n,}? 匹配至少n次，但尽可能少重复 
{n,m}? 匹配至少n次，至多m次，但尽可能少重复 

very very happy 使用v.*y和v.*?y

#so very very vary vary sorry vys
v.*y #贪婪，尽可能多匹配。匹配very very vary vary sorry vy
v.*?y #非贪婪, 尽可能短。匹配very、 very、 vary、 vary、vy
v.+?y #非贪婪，尽可能短。匹配very、 very 、vary、vary
v.??y #非贪婪，匹配0次或1次。匹配vy
v.{2,}?y #非贪婪，匹配2次。匹配very、 very 、vary、vary

import re

a = 'java*&39android##@@python'
# 贪婪与非贪婪
re_findall = re.findall('[a-z]{4,7}?', a)
print(re_findall)

['java', 'andr', 'pyth']

# coding: utf-8
from pathlib import Path

p = Path() #当前目录，Path() Path('.') Path('')
p = Path('a', 'b', 'c/d') #当前目录下的 a/b/c/d
p = Path('/etc', Path('sysconfig'), 'network/ifcfg') #根下的etc目录

# coding: utf-8
from pathlib import Path

p1 = ('/a/b' / ('c/d' / Path('e/f')))
print(p1.parent) #取父路径 \a\b\c\d\e
print(p1.parent.joinpath('d1', 'd2/d3', Path('d4', 'd5'))) #路径拼接 \a\b\c\d\e\d1\d2\d3\d4\d5

# coding: utf-8
from pathlib import Path

p = Path('/a/b/c/d')
print(p.parts) #最左边的是/是根目录
#: ('\\', 'a', 'b', 'c', 'd')

from pathlib import Path
p = Path('/etc')
print(str(p), bytes(p)) #: \etc b'\\etc'

# coding: utf-8
from pathlib import Path
p = Path('/data/mysql/install/my.tar.gz')
print(p.parent) #: \data\mysql\install

for x in p.parents: #可迭代对象
    print(x)
#: \data\mysql\install
#: \data\mysql
#: \data
#: \


#相对路径
p = Path('data/mysql/install/my.tar.gz')  #路径系统当中，2特殊的目录
# . 引用，对当前目录自身的引用
# .. 对当前目录的父目录的引用
print(p.parent) #data\mysql\install

for x in p.parents: #可迭代对象
    print(x)
#data\mysql\install
#data\mysql
#data
#.

print(list(p.parents))
#[WindowsPath('data/mysql/install'), WindowsPath('data/mysql'), WindowsPath('data'), WindowsPath('.')]

# coding: utf-8
from pathlib import Path
p = Path('/data/mysql/my.tar.gz')
print(p.exists()) #: False

print(p.name, p.parent) #路径成分 基名 父目录 : my.tar.gz \data\mysql
print(p.suffix, p.suffixes, p.stem) #文件扩展名 : .gz ['.tar', '.gz'] my.tar

print(p.with_name('config')) #换基名 : \data\mysql\config
print(p.parent.with_name('config')) #换基名 : \data\config
print(p.parent.parent / 'redis') #换基名: \data\redis
print(p.with_suffix('.xz')) #换扩展名 : \data\mysql\my.tar.xz

# coding: utf-8
from pathlib import Path

p = 'd:/tmp'
print(Path(p).cwd(), Path.cwd())
# 当前工作路径不会随着你路径的变化而变化，相当于常量，通过任何路径都可以方便调用到当前工作路径
#家目录也是一样，相当于常量
print(Path('abc').home(), Path.home())

# coding: utf-8
from pathlib import Path

p1 = Path('/dev')
print((p1 / 'bus').is_dir())
print((p1 / 'console').is_char_device())
print((p1 / 'cdrom').is_symlink())
print((p1 / 'cdrom').is_file())
print((p1 / 'abcdea').is_file()) #不知道是谁，False. 内部调用了exits()目录或文件是否存在
print(p1.is_absolute())       

# coding: utf-8

from pathlib import Path

p1 = Path('/dev')
print((p1 / 'cdrom').is_symlink())
print((p1 / 'cdrom').absolute())
print((p1 / 'cdrom').resolve()) #如果是软链接返回真实路径
#True
#/dev/cdrom
#/dev/sr0   

# coding: utf-8
from pathlib import Path

p = Path('d:/tmp/mydir')
p.mkdir(parents=True, exist_ok=True)

print(p.is_file()) #返回False
print(p.exists()) #返回True
print(list(p.absolute().iterdir())) #返回[]  遍历目录，iterdir方法遍历，返回生成器对象，遍历目录不递归
(p / 'd1').mkdir(exist_ok=True) #创建目录
(p / 'c1/c2/c3').mkdir(parents=True, exist_ok=True) #创建目录，mkdir -p 
(p / 'c1/a.py').touch() #创建文件
(p / '../a.py').touch() #创建文件

#遍历父路径
for x in (p / 'd1').parent.iterdir():
    print(x)
#: d:\tmp\mydir\c1
#: d:\tmp\mydir\d1

# coding: utf-8
from pathlib import Path

p = Path('d:/tmp/c1/c2')

#可以用parents操作，也可以用parent操作
#print(list(p.parents))
#for x in p.parents[len(p.parents)-2].iterdir(): #不支持负索引
for x in p.parent.parent.iterdir():
    print(x, type(x))
    if x.is_dir():
        print('dir', x)
#        flag = False #不为空
#        for z in x.iterdir():
#            flag = True
#            break
#        print('Not empty' if flag else 'Empty')
        print('Not empty' if next(x.iterdir(), False) else 'Empty')  #next(迭代对象, False) 如果没有返回False
    elif x.is_file():
        print('file', x)
    else:
        print('other', x)

# coding: utf-8

from pathlib import Path

p1 = Path('/dev/')
print((p1 / 'cdrom').is_symlink())

print((p1 / 'cdrom'))
print((p1 / 'cdrom').stat()) #会跟踪软链接，是真实路径的状态                                                                                                                                                              
print((p1 / 'cdrom').resolve())
print((p1 / 'cdrom').resolve().stat())
#True
#/dev/cdrom
#os.stat_result(st_mode=25008, st_ino=160, st_dev=5, st_nlink=1, st_uid=0, st_gid=24, st_size=0, st_atime=1735647858, st_mtime=1735647858, st_ctime=1735647858)
#/dev/sr0
#os.stat_result(st_mode=25008, st_ino=160, st_dev=5, st_nlink=1, st_uid=0, st_gid=24, st_size=0, st_atime=1735647858, st_mtime=1735647858, st_ctime=1735647858)

# coding: utf-8
from pathlib import Path

#通配符，不是正则表达式
p1 = Path('d:/tmp')

print(p1.glob('*')) #当前目录下所有文件，返回可迭代对象: <generator object Path.glob at 0x0000027452864120>
print(p1.glob('*.py')) #当前目录下所有.py文件
print(p1.glob('*/*/*.py')) #当前目录下子目录下所有.py文件
print(p1.glob('**/*.py')) #当前目录下任意目录下所有.py文件
#? 一个
p1.glob('**/[a-z]*.??') #[a-z]*.?? 代表a到z任意一个字符后面跟任何字符，再接个.??
p1.rglob('**/[a-z]*.??') #递归glob，层级就不用写了

# coding: utf-8
from pathlib import Path

p = Path('d:/tmp/a.py')

with open(p, 'w+') as f: #open文件参数可以是 Path对象、字符串、文件对象
    f.write('abc')
    f.seek(0)
    print(f.read())

# coding: utf-8
from pathlib import Path

p = Path('d:/tmp/a.py')

p.write_text('abc') #内部用了open(mode='w')
p.write_bytes(b'abc') #内部用了open(mode='wb')
print(p.read_text()) #open(mode='rt')
print(p.read_bytes()) #open(mode='rb')
#: abc
#: b'abc'

with p.open() as f: #self.open(mode, ...) open(file, mode)
    print(f.read())

# coding: utf-8
from os import path
import shutil

base = 'd:/tmp'
src = 'test.txt'
dst = 'test1.txt'

src = path.join(base, src)
dst = path.join(base,dst)

with open(src, 'w', encoding='utf-8') as f:
    f.write('\n'.join(['123','abc', '你好']))

def copy(src, dst):
    length = 16 * 1024
    with open(src, 'rb', ) as f1:
        with open(dst, 'wb') as f2:
            while True:
                buffer = f1.read(length)
                if not buffer:
                    break
                f2.write(buffer)

copy(src, dst) 
#shutil.copyfile(src,dst) #shutil.copyfileobj(fsrc,fdst)                
#shutil.copy(src,dst)
#shutil.copy2(src,dst)

# coding: utf-8
#准备要用的目录

import shutil
from pathlib import Path

base = Path('d:/tmp')
sub  = Path('a/b/c/d')

#(base / sub).mkdir(parents=True, exist_ok=True) #路径，需要父路径。
#解一下parentes
#print(*sub.parents)  #: a\b\c a\b a .  相对路径有个点，要去掉
print(list(sub.parents)[:-1]) #: [WindowsPath('a/b/c'), WindowsPath('a/b'), WindowsPath('a')]

dirs = [sub] + list(sub.parents)[:-1]
print(dirs) #: [WindowsPath('a/b/c/d'), WindowsPath('a/b/c'), WindowsPath('a/b'), WindowsPath('a')]

# coding: utf-8
#随机文件

import shutil
from pathlib import Path
from string import ascii_lowercase
import random

base = Path('d:/tmp/mydir')
sub  = Path('a/b/c/d')

dirs = [sub] + list(sub.parents)[:-1]
#: [WindowsPath('a/b/c/d'), WindowsPath('a/b/c'), WindowsPath('a/b'), WindowsPath('a')]
#删除目录
if base.exists():
    shutil.rmtree(str(base))
#创建目录
(base / sub).mkdir(parents=True, exist_ok=True) #路径，需要父路径。

for i in range(20):
    name = "".join(random.choices(ascii_lowercase, k=4))
    #print(name)
    (base / random.choice(dirs) / name).touch()

#遍历所有文件
print(*list(base.rglob('*')), sep='\n')

# coding: utf-8
#复制目录

import shutil
from pathlib import Path
from string import ascii_lowercase
import random

base = Path('d:/tmp/mydir')
sub  = Path('a/b/c/d')

dirs = [sub] + list(sub.parents)[:-1]
#: [WindowsPath('a/b/c/d'), WindowsPath('a/b/c'), WindowsPath('a/b'), WindowsPath('a')]
#删除目录
if base.exists():
    shutil.rmtree(str(base))
#创建目录
(base / sub).mkdir(parents=True, exist_ok=True) #路径，需要父路径。

for i in range(20):
    name = "".join(random.choices(ascii_lowercase, k=4))
    #print(name)
    (base / random.choice(dirs) / name).touch()

#copy
headers = set('xyz')
def ignore_files(src, names):
    # return {name for name in names
    #         if name[0] not in headers and Path(src, name).is_file()}
    return set(filter(lambda name: name[0] not in headers and Path(src, name).is_file(), names))

shutil.copytree(str(base / 'a'), str(base / 'dst'), ignore=ignore_files)

#遍历所有文件
print(*(base / 'dst').rglob('*'), sep='\n')

import json
from configparser import ConfigParser

src = 'test.ini'
dst = 'test.json'

cfg = ConfigParser()
cfg.read(src)

d = {}

for section in cfg.sections(): #不带缺省值
    print(section, type(section))
    print(cfg.items(section))
    # ['mysql', 'mysqld']
    # mysql <class 'str'>
    # [('a', '100'), ('default-character-set', 'utf8')]
    # mysqld <class 'str'>
    # [('a', 'test'), ('datadir', '/dbserver/data'), ('port', '33060'), ('character-set-server', 'utf8'), ('sql_mode', 'NO_ENGINE_SUBSTITUTION,STRICT_TRANS_TABLES')]

    d[section] = dict(cfg.items(section))

print(d)
with open(dst, 'w', encoding='utf-8') as f:
    json.dump(d, f)

(.venv) PS D:\project\pyproj> python -m json.tool .\test.json
{
    "mysql": {
        "a": "100",
        "default-character-set": "utf8"
    },
    "mysqld": {
        "a": "test",
        "datadir": "/dbserver/data",
        "port": "33060",
        "character-set-server": "utf8",
        "sql_mode": "NO_ENGINE_SUBSTITUTION,STRICT_TRANS_TABLES"
    }
}

from collections import defaultdict
import re

filename = 'sample.txt'

d = {}
#d = defaultdict(lambda :0)

#处理os.path.commonpath(['/usr/lib'
#line = "os.path.commonpath(['/usr/lib'"
def make_key1(line:str):
    #line = line.lower()
    pattern = r"""[~`!@#$%^&*()-_=+|\{}\[\]:;"'<>?/,.\s]+"""
    ret = re.split(pattern, line)
    return ret

def make_key2(line:str):
    #line = line.lower()
    chars = set(r"""~`!@#$%^&*()-_=+|\{}[]:;"'<>?/,.""")
    ret = []
    for c in line:
        if c in chars:
            ret.append(' ')
        else:
            ret.append(c)
    return ''.join(ret).split()

with open(filename, encoding='utf-8') as f:
    for line in f: #逐行处理
        #不区分大小写
        # line = line.lower()
        # words = line.split()
        # for word in words:
        # for word in map(lambda x:x.lower(), make_key1(line)):
        for word in map(str.lower, make_key1(line)):
            # print(word)
            #d[word] += 1
            d[word] = d.get(word, 0) + 1

print(sorted(d.items(), key=lambda item:item[1], reverse=True) )

# for k in d.keys():
#     if k.find('path') > -1:
#         print(k)
print(*filter(lambda k: k.find('path') > -1, d.keys()), sep='\n')


def make_key3(line:str):
    #line = line.lower()
    chars = set("""~`!@#$%^&*()-_=+|\{}[]:;"'<>?/,.\n\r\t""")
    ret = []
    start = 0
    length  = len(line)
    for i,c in enumerate(line):
        if c in chars:
            if start == i:
                start = i + 1
                continue
            ret.append(line[start:i])
            start = i + 1 #假定下一个字符是OK的
    else:
        if start < length:
            ret.append(line[start:])
    return ret
line = "os.path.commonpath(['/usr/lib'"
print(make_key3(line))


def make_key4(line:str):
    #line = line.lower()
    chars = set("""~`!@#$%^&*()-_=+|\{}[]:;"'<>?/,.\n\r\t""")
    # ret = []
    start = 0
    length  = len(line)
    for i,c in enumerate(line):
        if c in chars:
            if start == i:
                start = i + 1
                continue
            # ret.append(line[start:i])
            yield line[start:i]
            start = i + 1 #假定下一个字符
    else:
        if start < length:
            # ret.append(line[start:])
            yield line[start:]

line = "os.path.commonpath(['/usr/lib'"
print(*make_key4(line))

from collections import defaultdict
import re

filename = 'sample.txt'


#d = defaultdict(lambda :0)

#处理os.path.commonpath(['/usr/lib'
#line = "os.path.commonpath(['/usr/lib'"
regex = re.compile(r"""[~`!@#$%^&*() -_=+|\{}\[\]:;"'<>?/,.\s]+""")
def make_key1(line:str):
    #line = line.lower()
    ret = regex.split(line)
    return ret

chars = set("""~`!@#$%^&*()-_=+|\{}[]:;"'<>?/,. \n\r\t""")

def make_key2(line:str):
    #line = line.lower()
    ret = []
    for c in line:
        if c in chars:
            ret.append(' ')
        else:
            ret.append(c)
    return ''.join(ret).split()

def make_key3(line:str):
    #line = line.lower()
    ret = []
    start = 0
    length  = len(line)
    for i,c in enumerate(line):
        if c in chars:
            if start == i:
                start = i + 1
                continue
            ret.append(line[start:i])
            start = i + 1 #假定下一个字符是OK的
    else:
        if start < length:
            ret.append(line[start:])
    return ret

def make_key4(line:str):
    start = 0
    length  = len(line)
    for i,c in enumerate(line):
        if c in chars:
            if start == i:
                start = i + 1
                continue
            yield line[start:i]
            start = i + 1 #假定下一个字符
    else:
        if start < length:
            yield line[start:]

def wordcount(filename, enconding='utf-8', ignore=None):
    d = {}
    with open(filename, encoding='utf-8') as f:
        for line in f: #逐行处理
            for word in map(str.lower, make_key4(line)):
                d[word] = d.get(word, 0) + 1
    return d

def topN(d:dict, n:int=10):
    return sorted(d.items(), key=lambda item:item[1], reverse=True)[:n]

t = topN(wordcount(filename))
print(t)

import re

filename = 'sample.txt'

#处理os.path.commonpath(['/usr/lib'
#line = "os.path.commonpath(['/usr/lib'"
regex = re.compile(r"""[~`!@#$%^&*()-_=+|\{}\[\]:;"'<>?/,.\s]+""")
def make_key1(line:str):
    #line = line.lower()
    ret = regex.split(line)
    return ret

chars = set("""~`!@#$%^&*()-_=+|\{}[]:;"'<>?/,. \n\r\t""")

def make_key2(line:str):
    #line = line.lower()
    ret = []
    for c in line:
        if c in chars:
            ret.append(' ')
        else:
            ret.append(c)
    return ''.join(ret).split()

def make_key3(line:str):
    #line = line.lower()
    ret = []
    start = 0
    length  = len(line)
    for i,c in enumerate(line):
        if c in chars:
            if start == i:
                start = i + 1
                continue
            ret.append(line[start:i])
            start = i + 1 #假定下一个字符是OK的
    else:
        if start < length:
            ret.append(line[start:])
    return ret

def make_key4(line:str):
    start = 0
    length  = len(line)
    for i,c in enumerate(line):
        if c in chars:
            if start == i:
                start = i + 1
                continue
            yield line[start:i]
            start = i + 1 #假定下一个字符
    else:
        if start < length:
            yield line[start:]

def wordcount(filename, enconding='utf-8', ignore=None):
    d = {}
    if ignore is None: #stopwords
        ignore = set()
    with open(filename, encoding='utf-8') as f:
        for line in f: #逐行处理
            for word in map(str.lower, make_key4(line)):
                if word not in ignore:
                    d[word] = d.get(word, 0) + 1
    return d

def topN(d:dict, n:int=10):
    # return sorted(d.items(), key=lambda item:item[1], reverse=True)[:n]
    yield  from sorted(d.items(), key=lambda item:item[1], reverse=True)[:n]
t = topN(wordcount(filename, ignore={'the', 'is', 'a'}))
print(*t)

import re

#预编译
re.compile('\s', re.S | re.M) #预编译，单行或者多行模式，得到一个正则表达式对象

import re

s = """bottle\nbag\nbig\napple"""
for i,c in enumerate(s, 1): #查看字符串索引对应关系
    print((i-1,c), end='\n' if i%10==0 else '')
# (0, 'b')(1, 'o')(2, 't')(3, 't')(4, 'l')(5, 'e')(6, '\n')(7, 'b')(8, 'a')(9, 'g')
# (10, '\n')(11, 'b')(12, 'i')(13, 'g')(14, '\n')(15, 'a')(16, 'p')(17, 'p')(18, 'l')(19, 'e')

#预编译
#re.compile('\s', re.S | re.M) #预编译，单行或者多行模式，得到一个正则表达式对象

#match 单次匹配, 并不做全文搜索，而且要求必须是从头匹配 索引0
r = re.match('a', s)
print(r) #None
r = re.match('^a', s)
print(r) #None 默认模式，一整行，没有a开头的
r = re.match('^a', s, re.M)
print(r) #None 从索引0开始匹配，所以匹配不上
r = re.match('a', s, re.M)
print(r) #None
#即便是 MULTILINE 多行模式， re.match() 也只匹配字符串的开始位置，而不匹配每行开始

r = re.match('b.+', s, re.S)
#匹配不上返回None；
#匹配上，得到match类型实例，span (start, end), math=xxx 匹配
print(type(r), r) #<class 're.Match'> <re.Match object; span=[0, 20), match='bottle\nbag\nbig\napple'>
print(r.start(), r.end()) #0 20 。匹配从头至尾
print(s[r.start():r.end()].encode()) #b'bottle\nbag\nbig\napple'
print(r.string.encode()) #原字符串内容，即s本身内容 b'bottle\nbag\nbig\napple'

r = re.match('b.+', s, re.M) #多行模式匹配，但match只做单次匹配，所以只拿到bottle
print(type(r), r) #<class 're.Match'> <re.Match object; span=(0, 6), match='bottle'>

#match内部用了编译，不需要反复做编译，那么我们可以先编译再match
#如果需要多次使用这个正则表达式的话，使用 re.compile() 和保存这个正则对象以便复用，可以让程序更加高效。
regex = re.compile('b.+', re.M)
print(regex.match(s)) # 单次匹配 <re.Match object; span=(0, 6), match='bottle'>
print(regex.match(s, pos=1)) #pos指定字符串索引位置。 从s的索引1位置即o开始匹配，没匹配到，返回None
print(regex.match(s, 7)) #从索引7位置开始匹配，能匹配到 <re.Match object; span=(7, 10), match='bag'>

regex = re.compile('b')
m = regex.match(s)
print(m) #默认模式，从索引0开始匹配，<re.Match object; span=(0, 1), match='b'>
regex = re.compile('^b')
print(regex.match(s)) #默认模式，从索引0开始匹配，<re.Match object; span=(0, 1), match='b'>
regex = re.compile('^a')
print(regex.match(s)) #默认模式，从索引0开始匹配，None
regex = re.compile('^a', re.M)
print(regex.match(s)) #多行模式，从索引0开始匹配，None
regex = re.compile('^a', re.M)
print(regex.match(s, 8)) #多行模式，从索引8开始匹配，但要求是行首，None
regex = re.compile('^a', re.M)
print(regex.match(s, 15)) #多行模式，从索引15开始匹配，是行首，<re.Match object; span=(15, 16), match='a'>
regex = re.compile('a', re.M)
print(regex.match(s, 8)) #多行模式，从索引8开始匹配，<re.Match object; span=(8, 9), match='a'>
regex = re.compile('^a',)
print(regex.match(s, 15)) #默认模式，从索引15开始匹配，但a不是行首，None

import re

s = """bottle\nbag\nbig\napple"""
for i,c in enumerate(s, 1): #查看字符串索引对应关系
    print((i-1,c), end='\n' if i%10==0 else '')
# (0, 'b')(1, 'o')(2, 't')(3, 't')(4, 'l')(5, 'e')(6, '\n')(7, 'b')(8, 'a')(9, 'g')
# (10, '\n')(11, 'b')(12, 'i')(13, 'g')(14, '\n')(15, 'a')(16, 'p')(17, 'p')(18, 'l')(19, 'e')

#预编译
#re.compile('\s', re.S | re.M) #预编译，单行或者多行模式，得到一个正则表达式对象
#match 单次匹配, 并不做全文搜索，而且要求必须是从头匹配 索引0
#search 是单次匹配，但是从index为0开始向后找，找到一次就算匹配到，找不到返回None。
r = re.search('b', s)
print(type(r), r) #<class 're.Match'> <re.Match object; span=(0, 1), match='b'>
r = re.search('a', s)
print(type(r), r) #<class 're.Match'> <re.Match object; span=(8, 9), match='a'>
r = re.search('a', s, re.M)
print(type(r), r) #<class 're.Match'> <re.Match object; span=(8, 9), match='a'>
r = re.search('^a', s, re.M)
print(type(r), r) #<class 're.Match'> <re.Match object; span=(15, 16), match='a'>
r = re.search('^a', s)
print(type(r), r) #默认模式，整个算一整行。<class 'NoneType'> None

#如果需要多次使用这个正则表达式的话，使用 re.compile() 和保存这个正则对象以便复用，可以让程序更加高效。
regex = re.compile('^a')
r = regex.search(s)
print(r) #None
print(regex.search(s, 15)) #默认模式，整个算一整行。不是a开头。并不是多行模式
regex = re.compile('^a', re.M)
print(regex.search(s, 15)) #多行模式，a是这一行的行首 <re.Match object; span=(15, 16), match='a'>

import re

s = """bottle\nbag\nbig\napple"""
for i,c in enumerate(s, 1): #查看字符串索引对应关系
    print((i-1,c), end='\n' if i%10==0 else '')
# (0, 'b')(1, 'o')(2, 't')(3, 't')(4, 'l')(5, 'e')(6, '\n')(7, 'b')(8, 'a')(9, 'g')
# (10, '\n')(11, 'b')(12, 'i')(13, 'g')(14, '\n')(15, 'a')(16, 'p')(17, 'p')(18, 'l')(19, 'e')

#预编译
#re.compile('\s', re.S | re.M) #预编译，单行或者多行模式，得到一个正则表达式对象
#match 单次匹配, 并不做全文搜索，而且要求必须是从头匹配 索引0
#search 是单次匹配，但是从index为0开始向后找，找到一次就算匹配到，找不到返回None。
#fullmatch 是单次匹配，要求指定区间全部匹配
r = re.fullmatch('b.+', s)
print(type(r), r) #<class 'NoneType'> None
r = re.fullmatch('bag', s)
print(type(r), r) #<class 'NoneType'> None
r = re.fullmatch('b.+', s, re.S)
print(type(r), r) #<class 're.Match'> <re.Match object; span=(0, 20), match='bottle\nbag\nbig\napple'>

#如果需要多次使用这个正则表达式的话，使用 re.compile() 和保存这个正则对象以便复用，可以让程序更加高效。
r = re.compile('bag')
print(r.fullmatch(s, 7)) #None
print(r.fullmatch(s, 7, 11)) #None  区间前包后不包 [7, 11)
print(r.fullmatch(s, 7, 10)) #<re.Match object; span=(7, 10), match='bag'>
print(r.fullmatch(s, 7, 9)) #None
r = re.compile('^bag')
print(r.fullmatch(s, 7, 10)) #默认模式，bag不是首行。None
r = re.compile('^bag', re.M)
print(r.fullmatch(s, 7, 10)) #多行模式，bag是行首，并且在指定区间内匹配<re.Match object; span=(7, 10), match='bag'>

import re

s = """bottle\nbag\nbig\napple"""
for i,c in enumerate(s, 1): #查看字符串索引对应关系
    print((i-1,c), end='\n' if i%10==0 else '')
# (0, 'b')(1, 'o')(2, 't')(3, 't')(4, 'l')(5, 'e')(6, '\n')(7, 'b')(8, 'a')(9, 'g')
# (10, '\n')(11, 'b')(12, 'i')(13, 'g')(14, '\n')(15, 'a')(16, 'p')(17, 'p')(18, 'l')(19, 'e')

#预编译
#re.compile('\s', re.S | re.M) #预编译，单行或者多行模式，得到一个正则表达式对象
#findall 返回列表，返回匹配的字符串。跟平常理解的正则是一样的
r = re.findall('b', s)
print(type(r), r) #<class 'list'> ['b', 'b', 'b']
r = re.findall(r'b\w+', s)
print(type(r), r) #<class 'list'> ['bottle', 'bag', 'big']

#如果需要多次使用这个正则表达式的话，使用 re.compile() 和保存这个正则对象以便复用，可以让程序更加高效。
regex = re.compile(r'b\w+')
print(regex.findall(s, 1)) #['bag', 'big']
regex = re.compile(r'^b\w+')
print(regex.findall(s, 0)) #['bottle']

#match 单次匹配, 并不做全文搜索，而且要求必须是从头匹配 索引0
#search 是单次匹配，但是从index为0开始向后找，找到一次就算匹配到，找不到返回None。
#fullmatch 是单次匹配，要求指定区间全部匹配

import re

s = """bottle\nbag\nbig\napple"""
for i,c in enumerate(s, 1): #查看字符串索引对应关系
    print((i-1,c), end='\n' if i%10==0 else '')
# (0, 'b')(1, 'o')(2, 't')(3, 't')(4, 'l')(5, 'e')(6, '\n')(7, 'b')(8, 'a')(9, 'g')
# (10, '\n')(11, 'b')(12, 'i')(13, 'g')(14, '\n')(15, 'a')(16, 'p')(17, 'p')(18, 'l')(19, 'e')

#预编译
#re.compile('\s', re.S | re.M) #预编译，单行或者多行模式，得到一个正则表达式对象
#findall 返回列表，返回匹配的字符串。跟平常理解的正则是一样的
#finditer 返回一个迭代器，每一个元素都是match实例
r = re.finditer(r'b\w+', s)
print(type(r), r) #<class 'callable_iterator'> <callable_iterator object at 0x00000249B4052B30>
for x in r:
    print(type(x), x)
#<class 're.Match'> <re.Match object; span=(0, 6), match='bottle'>
#<class 're.Match'> <re.Match object; span=(7, 10), match='bag'>
#<class 're.Match'> <re.Match object; span=(11, 14), match='big'>

r = re.finditer(r'^b', s)
print(type(r), r) #<class 'callable_iterator'> <callable_iterator object at 0x00000179427D27A0>
for x in r:
    print(type(x), x)
#<class 're.Match'> <re.Match object; span=(0, 1), match='b'>

r = re.finditer(r'^b', s, re.M)
print(type(r), r) #<class 'callable_iterator'> <callable_iterator object at 0x0000024685441FF0>
for x in r:
    print(type(x), x)
#<class 're.Match'> <re.Match object; span=(0, 1), match='b'>
#<class 're.Match'> <re.Match object; span=(7, 8), match='b'>
#<class 're.Match'> <re.Match object; span=(11, 12), match='b'>

#如果需要多次使用这个正则表达式的话，使用 re.compile() 和保存这个正则对象以便复用，可以让程序更加高效。

#match 单次匹配, 并不做全文搜索，而且要求必须是从头匹配 索引0
#search 是单次匹配，但是从index为0开始向后找，找到一次就算匹配到，找不到返回None。
#fullmatch 是单次匹配，要求指定区间全部匹配

import re

s = """bottle\nbag\nbig\napple"""
for i,c in enumerate(s, 1): #查看字符串索引对应关系
    print((i-1,c), end='\n' if i%10==0 else '')
# (0, 'b')(1, 'o')(2, 't')(3, 't')(4, 'l')(5, 'e')(6, '\n')(7, 'b')(8, 'a')(9, 'g')
# (10, '\n')(11, 'b')(12, 'i')(13, 'g')(14, '\n')(15, 'a')(16, 'p')(17, 'p')(18, 'l')(19, 'e')

#预编译
#re.compile('\s', re.S | re.M) #预编译，单行或者多行模式，得到一个正则表达式对象
#sub 模式替换，可以指定至多替换的次数，返回替换结果
r = re.sub(r'b\w+', 'abc', s)
print(type(r), r.encode()) #<class 'str'> b'abc\nabc\nabc\napple'
r = re.sub(r'b\w+', 'abc', s, count=1) #最多替换1次
print(type(r), r.encode()) #<class 'str'> b'abc\nbag\nbig\napple'
r = re.sub(r'b\w+', 'abc', s, count=10) #最多替换10次
print(type(r), r.encode()) #<class 'str'> b'abc\nabc\nabc\napple'

regex = re.compile(r'b\w+')
print(regex.sub('abc',s, 2).encode()) #b'abc\nabc\nbig\napple'

#subn 模式替换，可以指定至多替换的次数，返回元组(替换的结果, 替换的次数)
r = re.subn(r'b\w+', 'abc', s, count=10) #最多替换10次
print(type(r), r) #<class 'tuple'> ('abc\nabc\nabc\napple', 3) 返回元组，后面数字是替换的次数
r = re.subn(r'b\w+', 'abc', s, count=1) #最多替换1次
print(type(r), r) #<class 'tuple'> ('abc\nbag\nbig\napple', 1) 返回元组，后面数字是替换的次数

#findall 返回列表，返回匹配的字符串。跟平常理解的正则是一样的
#finditer 返回一个迭代器，每一个元素都是match实例

#match 单次匹配, 并不做全文搜索，而且要求必须是从头匹配 索引0
#search 是单次匹配，但是从index为0开始向后找，找到一次就算匹配到，找不到返回None。
#fullmatch 是单次匹配，要求指定区间全部匹配

import re

s = """bottle\n\t\t\t\t \nbag\nbig\napple"""
for i,c in enumerate(s, 1): #查看字符串索引对应关系
    print((i-1,c), end='\n' if i%10==0 else '')
#(0, 'b')(1, 'o')(2, 't')(3, 't')(4, 'l')(5, 'e')(6, '\n')(7, '\t')(8, '\t')(9, '\t')
#(10, '\t')(11, ' ')(12, '\n')(13, 'b')(14, 'a')(15, 'g')(16, '\n')(17, 'b')(18, 'i')(19, 'g')
#(20, '\n')(21, 'a')(22, 'p')(23, 'p')(24, 'l')(25, 'e')

#预编译
#re.compile('\s', re.S | re.M) #预编译，单行或者多行模式，得到一个正则表达式对象
#split 分割，指定分割符
print(s.split()) #默认使用 \s+ 分割 ['bottle', 'bag', 'big', 'apple']

print(re.split(r'\s+', s, maxsplit=1)) #['bottle', 'bag\nbig\napple']
print(re.split(r'\s+', s)) #['bottle', 'bag', 'big', 'apple']

s = """
os.path.abspath(path)
path. ([path)]
"""

print(re.split(r'\s', s)) #['', 'os.path.abspath(path)', 'path.', '([path)]', '']
print(re.split(r'[\s().\[\]{}]', s)) #['', 'os', 'path', 'abspath', 'path', '', 'path', '', '', '[path', ']', '']
print(re.split(r'[\s().\[\]{}]+', s)) #['', 'os', 'path', 'abspath', 'path', 'path', 'path', '']

#sub 模式替换，可以指定至多替换的次数，返回替换结果
#subn 模式替换，可以指定至多替换的次数，返回元组(替换的结果, 替换的次数)

#findall 返回列表，返回匹配的字符串。跟平常理解的正则是一样的
#finditer 返回一个迭代器，每一个元素都是match实例

#match 单次匹配, 并不做全文搜索，而且要求必须是从头匹配 索引0
#search 是单次匹配，但是从index为0开始向后找，找到一次就算匹配到，找不到返回None。
#fullmatch 是单次匹配，要求指定区间全部匹配

import re

s = """bottle\n\t\t\t\t \nbag\nbig\napple"""
for i,c in enumerate(s, 1): #查看字符串索引对应关系
    print((i-1,c), end='\n' if i%10==0 else '')
#(0, 'b')(1, 'o')(2, 't')(3, 't')(4, 'l')(5, 'e')(6, '\n')(7, '\t')(8, '\t')(9, '\t')
#(10, '\t')(11, ' ')(12, '\n')(13, 'b')(14, 'a')(15, 'g')(16, '\n')(17, 'b')(18, 'i')(19, 'g')
#(20, '\n')(21, 'a')(22, 'p')(23, 'p')(24, 'l')(25, 'e')
print()

#预编译
#re.compile('\s', re.S | re.M) #预编译，单行或者多行模式，得到一个正则表达式对象
#split 分割，指定分割符
#sub 模式替换，可以指定至多替换的次数，返回替换结果
#subn 模式替换，可以指定至多替换的次数，返回元组(替换的结果, 替换的次数)

#findall 返回列表，返回匹配的字符串。跟平常理解的正则是一样的
#finditer 返回一个迭代器，每一个元素都是match实例

#match 单次匹配, 并不做全文搜索，而且要求必须是从头匹配 索引0
#search 是单次匹配，但是从index为0开始向后找，找到一次就算匹配到，找不到返回None。
#fullmatch 是单次匹配，要求指定区间全部匹配
#分组 group
m = re.match(r'b\w+', s) #分不分组要看正则表达式中有没有括号
print(m) #<re.Match object; span=(0, 6), match='bottle'>
print(m.groups()) #()  取分组

m = re.match(r'(b)(\w+)', s) #分不分组要看正则表达式中有没有括号
print(m) #<re.Match object; span=(0, 6), match='bottle'>
print(m.groups()) #('b', 'ottle') 取分组

#m = re.search(r'^(a)(\w+)', s) #匹配不到，报错

m = re.search(r'^(a)(\w+)', s, re.M) #分不分组要看正则表达式中有没有括号
print(m) #<re.Match object; span=(21, 26), match='apple'>
print(m.groups()) #('a', 'pple') 取分组

m = re.search(r'(a)(\w+)', s, re.M) #分不分组要看正则表达式中有没有括号
print(m) #<re.Match object; span=(14, 16), match='ag'>
print(m.groups()) #('a', 'g') 取分组
print(m.group()) #ag 组，组号，从1开始
print(m.group(0)) #m.group() 等价，组0表示<re.Match object; span=(14, 16), match='ag'>中match

m = re.search(r'a(\w+)', s, re.M) #分不分组要看正则表达式中有没有括号
print(m) #<re.Match object; span=(14, 16), match='ag'>
print(m.groups()) #('g',) 取分组
print(m.group()) #ag 组，组号，从1开始
print(m.group(0)) #m.group() 等价，组0表示<re.Match object; span=(14, 16), match='ag'>中match
print(m.group(1)) #g 组，组号，从1开始

m = re.search(r'a\w+', s, re.M) #分不分组要看正则表达式中有没有括号
if m: #如果匹配成功
    print(m) #<re.Match object; span=(14, 16), match='ag'>
    print(m.groups()) #() 取分组
    print(m.group()) #ag 组，组号，从1开始
    print(m.group(0)) #m.group() 等价，组0表示<re.Match object; span=(14, 16), match='ag'>中match

import re

s = """bottle\n\t\t\t\t \nbag\nbig\napple"""
for i,c in enumerate(s, 1): #查看字符串索引对应关系
    print((i-1,c), end='\n' if i%10==0 else '')
#(0, 'b')(1, 'o')(2, 't')(3, 't')(4, 'l')(5, 'e')(6, '\n')(7, '\t')(8, '\t')(9, '\t')
#(10, '\t')(11, ' ')(12, '\n')(13, 'b')(14, 'a')(15, 'g')(16, '\n')(17, 'b')(18, 'i')(19, 'g')
#(20, '\n')(21, 'a')(22, 'p')(23, 'p')(24, 'l')(25, 'e')
print()

#预编译
#re.compile('\s', re.S | re.M) #预编译，单行或者多行模式，得到一个正则表达式对象
#split 分割，指定分割符
#sub 模式替换，可以指定至多替换的次数，返回替换结果
#subn 模式替换，可以指定至多替换的次数，返回元组(替换的结果, 替换的次数)

#findall 返回列表，返回匹配的字符串。跟平常理解的正则是一样的
#finditer 返回一个迭代器，每一个元素都是match实例

#match 单次匹配, 并不做全文搜索，而且要求必须是从头匹配 索引0
#search 是单次匹配，但是从index为0开始向后找，找到一次就算匹配到，找不到返回None。
#fullmatch 是单次匹配，要求指定区间全部匹配
#分组 group
m = re.search(r'a(?P<tail>\w+)', s, re.M) #分不分组要看正则表达式中有没有括号
if m: #如果匹配成功
    print(m) #<re.Match object; span=(14, 16), match='ag'>
    print(m.groups()) #('g',) 取分组
    print(m.group()) #ag 组，组号，从1开始
    print(m.group(0)) #m.group() 等价，组0表示<re.Match object; span=(14, 16), match='ag'>中match
    print()
    print(m.group(1))  # g 命名分组也有组号
    print(m.groupdict()) #{'tail': 'g'}
#分组 findall用法
m = re.findall(r'(b\w+)\s+(?P<name2>b\w+)\s+(?P<name3>b\w+)', s)
print(type(m), m) #m是什么类型 <class 'list'> [('bottle', 'bag', 'big')]
for x in m: #m有几项，能迭代几下？匹配了1下。
    print(type(x), x) #<class 'tuple'> ('bottle', 'bag', 'big')

m = re.findall(r'(b\w+)\s+\w+\s+b\w+', s)
print(type(m), m) #m是什么类型 <class 'list'> ['bottle']
for x in m: #m有几项，能迭代几下？匹配了1下。
    print(type(x), x) #<class 'str'> bottle

m = re.findall(r'(b\w+)\s+\w+\s+b(\w+)', s)
print(type(m), m) #m是什么类型<class 'list'> [('bottle', 'ig')]
for x in m: #m有几项，能迭代几下？匹配了1下。
    print(type(x), x) #<class 'tuple'> ('bottle', 'ig')

#取消分组看看
m = re.findall(r'b\w+\s+b\w+\s+b\w+', s)
print(type(m), m) #m是什么类型 <class 'list'> ['bottle\n\t\t\t\t \nbag\nbig']
for x in m: #m有几项，能迭代几下？匹配了1下。
    print(type(x), x.encode()) #<class 'str'> b'bottle\n\t\t\t\t \nbag\nbig'

import re

s = """bottle\n\t\t\t\t \nbag\nbig\napple"""
for i,c in enumerate(s, 1): #查看字符串索引对应关系
    print((i-1,c), end='\n' if i%10==0 else '')
#(0, 'b')(1, 'o')(2, 't')(3, 't')(4, 'l')(5, 'e')(6, '\n')(7, '\t')(8, '\t')(9, '\t')
#(10, '\t')(11, ' ')(12, '\n')(13, 'b')(14, 'a')(15, 'g')(16, '\n')(17, 'b')(18, 'i')(19, 'g')
#(20, '\n')(21, 'a')(22, 'p')(23, 'p')(24, 'l')(25, 'e')
print()

#预编译
#re.compile('\s', re.S | re.M) #预编译，单行或者多行模式，得到一个正则表达式对象
#split 分割，指定分割符
#sub 模式替换，可以指定至多替换的次数，返回替换结果
#subn 模式替换，可以指定至多替换的次数，返回元组(替换的结果, 替换的次数)

#findall 返回列表，返回匹配的字符串。跟平常理解的正则是一样的
#finditer 返回一个迭代器，每一个元素都是match实例

#match 单次匹配, 并不做全文搜索，而且要求必须是从头匹配 索引0
#search 是单次匹配，但是从index为0开始向后找，找到一次就算匹配到，找不到返回None。
#fullmatch 是单次匹配，要求指定区间全部匹配
#分组 group
#分组 findall用法
#分组 finditer用法
m = re.finditer(r'(b\w+)\s+(?P<name2>b\w+)\s+(?P<name3>b\w+)', s)
print(type(m), m) #m是什么类型 <class 'callable_iterator'> <callable_iterator object at 0x00000199F139DF90>
for x in m: #m有几项，能迭代几下？匹配了1下。
    print(type(x), x) #<class 're.Match'> <re.Match object; span=(0, 20), match='bottle\n\t\t\t\t \nbag\nbig'>
    print(x.group().encode()) #b'bottle\n\t\t\t\t \nbag\nbig'
    print(x.groups()) #('bottle', 'bag', 'big')
    print(x.groupdict()) #以命名方式提取分组 {'name2': 'bag', 'name3': 'big'}

m = re.match(r'(b\w+)\s+(?P<name2>b\w+)\s+(?P<name3>b\w+)', s)
print(type(m), m) #m是什么类型 <class 're.Match'> <re.Match object; span=(0, 20), match='bottle\n\t\t\t\t \nbag\nbig'>
print(m.group().encode()) #b'bottle\n\t\t\t\t \nbag\nbig'
print(m.groups()) #('bottle', 'bag', 'big')
print(m.groupdict()) #以命名方式提取分组 {'name2': 'bag', 'name3': 'big'}

from pathlib import Path

p1 = Path('d:/tmp/mydir/my.csv')
p1.parent.mkdir(parents=True, exist_ok=True)

# """\ 中\斜杠表示续行符，近接着后面字符
# ""双双引号代表一个双引号
csv_body = """\
id,name,age,comment
1,zs,20, I'm 20
2,ls,18,"test string""1223."
3,ww,30,"
python

你好
"
"""

# with p1.open('w', encoding='utf-8') as f: # newline = None \n 转换成 OS对应的换行符
#     f.write(csv_body)
print(csv_body.encode())
#b'id,name,age,comment\n1,zs,20, I\'m 20\n2,ls,18,"test string""1223."\n3,ww,30,"\npython\n\n\xe4\xbd\xa0\xe5\xa5\xbd\n"\n'

p1.write_text(csv_body, encoding='utf-8')

from pathlib import Path
import csv

p1 = Path('d:/tmp/mydir/my.csv')
p1.parent.mkdir(parents=True, exist_ok=True)

# """\ 中\斜杠表示续行符，近接着后面字符
# ""双双引号代表一个双引号
csv_body = """\
id,name,age,comment
1,zs,20, I'm 20
2,ls,18,"test string""1223."
3,ww,30,"
python

你好
"
"""

with p1.open(encoding='utf-8') as f: #在windows下默认使用gbk编码读取
    reader = csv.reader(f)
    print(next(reader)) #字段分开，返回列表，每一个字段项
    print(next(reader))
    print('-' * 30)
    for line in reader:
        print(line)

# ['id', 'name', 'age', 'comment']
# ['1', 'zs', '20', " I'm 20"]
# ------------------------------
# ['2', 'ls', '18', 'test string"1223.']
# ['3', 'ww', '30', '\npython\n\n你好\n']

from pathlib import Path
import csv

p1 = Path('d:/tmp/mydir/my.csv')
p1.parent.mkdir(parents=True, exist_ok=True)

# """\ 中\斜杠表示续行符，近接着后面字符
# ""双双引号代表一个双引号
csv_body = """\
id,name,age,comment
1,zs,20, I'm 20
2,ls,18,"test string""1223."
3,ww,30,"
python

你好
"
"""

#写csv文件
p2 = Path('d:/tmp/mydir/test.csv')
rows = [
    ['id', 'name', "age"],
    range(3),  #数字 -> 文本文件 -> 0 字符串
    'abcdefg',
    (1, 'tom', '20'),
    ((1,), (2,)),
    ([1], [2])
]

with p2.open('w', encoding='utf-8', newline='') as f: #写时，- '\n' 或''空串表示'\n' 不替换
    writer = csv.writer(f)
    writer.writerow(rows[0]) #写第一行
    writer.writerows(rows[1:]) #写多行

# id,name,age
# 0,1,2
# a,b,c,d,e,f,g
# 1,tom,20
# "(1,)","(2,)"
# [1],[2]

#读文件
with p2.open(encoding='utf-8', newline='') as f: #在windows下默认使用gbk编码读取.
    # newline='' 表示不会自动转换通用换行符，常见换行符都可以认为是换行
    reader = csv.reader(f)
    first = next(reader) #字段分开，返回列表，每一个字段项
    print(first)
    second = next(reader)
    print(second)
    print('-' * 30)
    for line in reader:
        print(line)
#读回来的都是字符串，类型没有
# ['id', 'name', 'age']
# ['0', '1', '2']
# ------------------------------
# ['a', 'b', 'c', 'd', 'e', 'f', 'g']
# ['1', 'tom', '20']
# ['(1,)', '(2,)']
# ['[1]', '[2]']

import configparser #配置文件解析器 ini

cfg = configparser.ConfigParser()
# 配置文件解析器对象
print(cfg) #<configparser.ConfigParser object at 0x0000014E8B2056A0>
r = cfg.read('mysql.ini')
#r = cfg.read(('mysql.ini', 'mysql.ini'))
print(r) #['mysql.ini']

#读取section
for x in cfg.sections(): #返回的是所有section，但不包含特殊的缺省section
    print(type(x), x)
# <class 'str'> mysql
# <class 'str'> mysqld
    print(cfg.options(x)) #每个section下的options，包含缺省
# ['default-character-set', 'a']
# ['datadir', 'port', 'character-set-server', 'sql_mode', 'a']

print(cfg.items()) #ItemsView(<configparser.ConfigParser object at 0x000002D346FE56A0>)
for y in cfg.items(): #items() 迭代时，包含了DEFAULT
    print(type(y), y)
# <class 'tuple'> ('DEFAULT', <Section: DEFAULT>)
# <class 'tuple'> ('mysql', <Section: mysql>)
# <class 'tuple'> ('mysqld', <Section: mysqld>)
print('-' * 30)
for k,v in cfg.items(): #items() 迭代时，包含了DEFAULT
    print(type(k), k) #k str
    print(type(v), v) #v section对象
    print(cfg.items(k)) #二元组可迭代对象，
    print('+' * 30)
# <class 'str'> DEFAULT
# <class 'configparser.SectionProxy'> <Section: DEFAULT>
# [('a', 'test')]
# ++++++++++++++++++++++++++++++
# <class 'str'> mysql
# <class 'configparser.SectionProxy'> <Section: mysql>
# [('a', 'test'), ('default-character-set', 'utf8')]
# ++++++++++++++++++++++++++++++
# <class 'str'> mysqld
# <class 'configparser.SectionProxy'> <Section: mysqld>
# [('a', 'test'), ('datadir', '/dbserver/data'), ('port', '33060'), ('character-set-server', 'utf8'), ('sql_mode', 'NO_ENGINE_SUBSTITUTION,STRICT_TRANS_TABLES')]
# ++++++++++++++++++++++++++++++

print(cfg.has_option('mysqld', 'a'))  #mysql下有没有a？ 有 返回True

#取值
t = cfg.get('mysqld', 'a')
print(type(t), t) #<class 'str'> test
t = cfg.get('mysqld', 'port', fallback=[]) #如果没有值，返回fallback的值
print(type(t), t) #<class 'str'> 33060
t = cfg.getint('mysqld', 'port', fallback=3306) #类型转换， int(get()) 如果没有值，返回fallback的值.
print(type(t), t) #<class 'int'> 33060

import configparser #配置文件解析器 ini

cfg = configparser.ConfigParser()
# 配置文件解析器对象
print(cfg) #<configparser.ConfigParser object at 0x0000014E8B2056A0>
r = cfg.read('mysql.ini')
#r = cfg.read(('mysql.ini', 'mysql.ini'))
print(r) #['mysql.ini']

#写入
cfg.set('mysqld', 'a', '100') #在内存中操作。 设置mysqld上a的值为100
with open('t.ini', 'w', encoding='utf-8') as f:
    cfg.write(f)

if cfg.has_section('test'):
    cfg.remove_section('test') #本section所有options全部删除

cfg.add_section('test')
print(cfg['mysql']) #<Section: mysql>

#字典操作更简单
cfg['test']['t1'] = '1000'
cfg['test']['t2'] = str([1,2,3])
t = cfg['test']['t2']
print(type(t), t) #<class 'str'> [1, 2, 3]
print(cfg.get('test', 't2')) #[1, 2, 3]

cfg['test'] = {'t3': 'abc'} #section存在，直接覆盖test中的内容
print(cfg.options('test')) #['t3', 'a']
cfg['test2'] = {'y': '1000'} #section不存在
print(cfg.options('test2')) #['y', 'a']

with open('t.ini', 'w', encoding='utf-8') as f:
    cfg.write(f)

#其他
print(cfg._sections)
#{'mysql': {'default-character-set': 'utf8'}, 'mysqld': {'datadir': '/dbserver/data', 'port': '33060', 'character-set-server': 'utf8', 'sql_mode': 'NO_ENGINE_SUBSTITUTION,STRICT_TRANS_TABLES', 'a': '100'}, 'test': {'t3': 'abc'}}
for k,v in cfg._sections.items():
    print(k,v)
# mysql {'default-character-set': 'utf8'}
# mysqld {'datadir': '/dbserver/data', 'port': '33060', 'character-set-server': 'utf8', 'sql_mode': 'NO_ENGINE_SUBSTITUTION,STRICT_TRANS_TABLES', 'a': '100'}
# test {'t3': 'abc'}

{
    "person":[
        {
            "name": "tom",
            "age": 18
        },
        {
            "name": "jerry",
            "age": 16
        }
    ],
    "total": 2
}      

import json

d = {
    'name':'Tom',
    'age':20,
    'insterest':('movie', 'music'),  # ?
    'class':['python'] #array
} #dict => object

#序列化json
s = json.dumps(d)  # 转成字符序列
print(type(s), len(s)) #<class 'str'> 80
print(s) #{"name": "Tom", "age": 20, "insterest": ["movie", "music"], "class": ["python"]}

#反序列化json
new = json.loads(s) # str => dict 实际上是 js:object => dict
print(type(new)) #<class 'dict'>
print(new) #{'name': 'Tom', 'age': 20, 'insterest': ['movie', 'music'], 'class': ['python']}

#尽量写成js支持的类型
d = {
    'name':'Tom',
    'age':20,
    'insterest':['movie', 'music'],
    'class':['python'] #array
} #dict => object

#序列化json
s = json.dumps(d)  # 转成字符序列
print(type(s), len(s)) #<class 'str'> 80
print(s) #{"name": "Tom", "age": 20, "insterest": ["movie", "music"], "class": ["python"]}

#反序列化json
new = json.loads(s) # str => dict 实际上是 js:object => dict
print(type(new)) #<class 'dict'>
print(new) #{'name': 'Tom', 'age': 20, 'insterest': ['movie', 'music'], 'class': ['python']}


print(d == new) # ? True 等号代表内容是否相同
print(d is new) # ? False is代表内存位置是否相同
print(id(d), id(new)) #2713103083392 2713101598528

pip install msgpack

import json
import pickle
import msgpack

d = {
    'Persons':[
        {'name':'tom', 'age':20}, #dict => object
        {'name':'jerry', 'age':18}
    ], #list => array
    'test':'aaaaaa',
    'total': 2
} # dict => object

#序列化
for i,module in enumerate((pickle, json, msgpack)): #元组， 三个元素
    # pickle.dumps(d) #99 bytes
    # json.dumps(d) #101 bytes 会有一些无效的空格
    # msgpack.dumps(d) #61 bytes
    data = module.dumps(d)
    print(module.__name__, "len={}".format(len(data)), type(data))
    print(i, data)
# pickle len=99 <class 'bytes'>
# 0 b'\x80\x04\x95X\x00\x00\x00\x00\x00\x00\x00}\x94(\x8c\x07Persons\x94]\x94(}\x94(\x8c\x04name\x94\x8c\x03tom\x94\x8c\x03age\x94K\x14u}\x94(h\x04\x8c\x05jerry\x94h\x06K\x12ue\x8c\x04test\x94\x8c\x06aaaaaa\x94\x8c\x05total\x94K\x02u.'
# json len=101 <class 'str'>
# 1 {"Persons": [{"name": "tom", "age": 20}, {"name": "jerry", "age": 18}], "test": "aaaaaa", "total": 2}
# msgpack len=61 <class 'bytes'>
# 2 b'\x83\xa7Persons\x92\x82\xa4name\xa3tom\xa3age\x14\x82\xa4name\xa5jerry\xa3age\x12\xa4test\xa6aaaaaa\xa5total\x02'

#反序列化
u = msgpack.loads(data) #utf-8
print(type(u), u)

u2 = msgpack.loads(data, raw=True) #新版 raw=True 用原始的，不转字符串了
print(type(u2), u2)
# <class 'dict'> {'Persons': [{'name': 'tom', 'age': 20}, {'name': 'jerry', 'age': 18}], 'test': 'aaaaaa', 'total': 2}
# <class 'dict'> {b'Persons': [{b'name': b'tom', b'age': 20}, {b'name': b'jerry', b'age': 18}], b'test': b'aaaaaa', b'total': 2}