1 切片操作

某字符串需要依据不同的分隔符来进行切分，例如
s = ‘abad:dasdfadf|asd|ddd\tasd;asdf,asdf;das,dedd,asdf|dd’ 其中 , ; \t | 都是分割符号
下面使用两种方法，建议使用方法2，但若只是按照一个切割，建议还是使用方法1.

方法1

  1. res1 = [ss.split('|') for ss in s.split(';')]
  2. #结果 [['abad:dasdfadf', 'asd', 'ddd\tasd'], ['asdf,asdf'], ['das,dedd,asdf', 'dd']]
  3. res2 = list(map(lambda ss: ss.split('|'), s.split(';')))
  4. #结果 同res1

对上面的结果展开

  1. t = []
  2. list(map(t.extend, res1))  # 注意：不加list，将不会执行。
  3. t  #['abad:dasdfadf', 'asd', 'ddd\tasd', 'asdf,asdf', 'das,dedd,asdf', 'dd']
  5. sum(res1, []) #结果同 t

写一个切割函数

  1. #正真的函数出来了
  2. def mySplit1(s, seps):
  3.     res = [s]
  4.     for sep in seps:
  5.         t = []
  6.         list(map(lambda ss: t.extend(ss.split(sep)), res))
  7.         res = t
  8.     return res
  9. mySplit1(s, ',;|\t')
  11. # ['abad:dasdfadf',
  12. #  'asd',
  13. #  'ddd',
  14. #  'asd',
  15. #  'asdf',
  16. #  'asdf',
  17. #  'das',
  18. #  'dedd',
  19. #  'asdf',
  20. #  'dd']

也可以这样，但是阅读性不好：

  1. from functools import reduce
  2. reduce(lambda l,sep:sum(map(lambda ss: ss.split(sep),l),[]), ',:|\t',[s])
  3. 或：
  4. mySplit2 = lambda s, seps: reduce(lambda l,sep:sum(map(lambda ss: ss.split(sep),l),[]), seps,[s])
  5. mySplit2(s, ',:|\t')

说明：

  1. lambda就是一个匿名函数，其实可以替换成一个函数就OK，冒号前面是参数，后面是函数返回值；
  2. map：map(function_to_apply, list_of_inputs)，将后面列表逐个作用于前面的函数，参数和前面函数一致，返回的是一个迭代式，需要通过list生成返回。
  3. reduce：reduce(function, iterable[, initializer])，reduce的工作过程是 ：在迭代sequence(tuple ，list ，dictionary， string等可迭代物)的过程中，首先把 前两个元素传给 函数参数，函数加工后，然后把得到的结果和第三个元素作为两个参数传给函数参数， 函数加工后得到的结果又和第四个元素作为两个参数传给函数参数，依次类推。 如果传入了 initial 值， 那么首先传的就不是 sequence 的第一个和第二个元素，而是 initial值和 第一个元素。经过这样的累计计算之后合并序列到一个单一返回值（可能是数，也可能是list，和初始化的值一致）。深入了解见下面代码或后面链接：https://www.cnblogs.com/lonkiss/p/understanding-python-reduce-function.html
    1. from functools import reduce
    2. scientists =({'name':'Alan Turing', 'age':105, 'gender':'male'},
    3.           {'name':'Dennis Ritchie', 'age':76, 'gender':'male'},
    4.           {'name':'Ada Lovelace', 'age':202, 'gender':'female'},
    5.           {'name':'Frances E. Allen', 'age':84, 'gender':'female'})
    6. def group_by_gender(accumulator , value):
    7.  accumulator[value['gender']].append(value['name'])
    8.  return accumulator
    9. grouped = reduce(group_by_gender, scientists, {'male':[], 'female':[]})
    10. print(grouped)           #  {'male': ['Alan Turing', 'Dennis Ritchie'], 'female': ['Ada Lovelace', 'Frances E. Allen']}

    方法2：使用正则表达式 re.split() — 推荐

    1. import re
    2. re.split('[,:|\t]+', s)  #结果和上面一样

    2 修改特定文件的权限

    主要使用str.startswith和str.endswith方法
    1. import os
    2. s = os.stat('test.py')
    3. s   # os.stat_result(st_mode=33188, st_ino=6586153450, st_dev=192, st_nlink=1, st_uid=0, st_gid=0, st_size=0, st_atime=1634441371, st_mtime=1634441371, st_ctime=1634441385)
    1. oct(s.st_mode)     #'0o100644'   33188十进制转换后为100644 ，644 分别是用户，组和其他的权限系数
    2. ! ls -lh test.py   #-rw-r--r-- 1 root root 0 Oct 17 03:29 test.py
    3. oct(s.st_mode | 0o100) # '0o100744'  添加用户的执行权限
    1. import stat
    2. stat.S_IXUSR  #XUSR 第一个字母是RWX之一，第二个可是 USR，GRP，OTH，对应：用户，组和其他
    3. oct(stat.S_IXUSR)  # '0o100' 所以也可以用这个
    实例 修改所有.py和.sh结尾的用户执行权限
    1. for fn in os.listdir():
    2.  if fn.endswith(('.py','.sh')):
    3.      fs = os.stat(fn)
    4.      os.chmod(fn, fs.st_mode | stat.S_IXUSR)

    3 大量替换操作

    比如log日志的日期由 ‘yyyy-mm-dd’修改为 ‘mm/dd/yyyy’的形式
    方案：使用正则表达式re.sub方法操纵替换字符串，用正则表达式捕获组，捕获每个部分内容，再替换并调整顺序。
    1. f = open('t.txt')
    2. log = f.read()
    3. log  #'2020-12-18\n2020-12-18\n2020-12-18\n2020-12-18\n2020-12-18\n2020-12-18\n'
    1. import re
    2. re.sub(r'(\d{4})-(\d{2})-(\d{2})',r'\2/\3/\1' , log) #'12/18/2020\n12/18/2020\n12/18/2020\n12/18/2020\n12/18/2020\n12/18/2020\n'
    1. import re
    2. re.sub(r'(?P<y>\d{4})-(?P<m>\d{2})-(?P<d>\d{2})',r'\g<m>/\g<d>/\g<y>' , log)  # 结果和上面一样
    ```python

    注意 转移字符的一些坑

    ‘\2’ #’\x02’ len(‘\2’) # 1 ‘\2’ # ‘\2’ r’\2’ # ‘\2’ len(‘\2’) # 1

ord(‘a’) # 97 oct(ord(‘a’)) #’0o141’ ‘\141’ # ‘a’

  1. <a name="XkJYO"></a>
  2. # 4 拼接字符串
  3. <a name="tf7qO"></a>
  4. ## 方法一：'+' 号 或 迭代列表
  5. ```python
  6. l = ['aaa','bbb','ccc','ddd']
  7. s = ''
  8. for x in l:
  9.     s += x
  10. s  # 'aaabbbcccddd'
  12. from functools import reduce
  13. reduce(str.__add__, l)  #'aaabbbcccddd'

方法二：str.join() —推荐

''.join(l)  # 'aaabbbcccddd'
','.join(l)  # 'aaa,bbb,ccc,ddd'

时间比较

timeit ''.join(l)                # 107 ns ± 0.916 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
timeit reduce(str.__add__, l)    #353 ns ± 4.6 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

5 对其问题

如何输出对其的形式：比例{‘aaa’:100,’bbbbbb’:20,’ccccccc’:200}，输出为：

aaa     : 100
bbbbbb  : 20
ccccccc : 200

方法1：使用ljust,rjust,center方法

s = 'abc'
s.ljust(10)         #'abc       '
len(s.ljust(10))    #10
s.ljust(10, '*')    #'abc*******'
s.rjust(10, "^")    #'^^^^^^^abc'
s.center(10, '@')   #'@@@abc@@@@'

方法2：使用format方法

format(s, '<10')  #同s.ljust(10)   'abc       '
format(s, '*>10')  #'*******abc'
format(s, '^10')   #'   abc    '
#直接调用
n=5
n.__format__('>10')  # '         5'

format(-123, '=+10')  #'-      123'
format(123, '=+10')   #'+      123'
format(-123, '0=+10') #'-000000123'
format(123, '0=+10') #'+000000123'

d = {'aaa':100,'bbbbbb':20,'ccccccc':200}
w = max(map(len, d.keys()))  # 上述key的最大长度
for k,v in d.items():
    print(k.ljust(w), ':', v)

# aaa     : 100
# bbbbbb  : 20
# ccccccc : 200

6 删除和替换字符串

不同的方法适应不同的应用

方法1：字符串strip,lstrip,rstrip去掉两端的

s = ' \t   sunwukong@126.com...  \t'
s.strip()  'sunwukong@126.com...'  # \t和空格默认删除
s.lstrip() # 'sunwukong@126.com...  \t'

方法2：删除固定位置的，使用切片加拼接

s2 = 'sunwukong:123' 
s2[:-4] + s2[-3:]       # 'sunwukong123'
''.join(s2.split(':'))  #'sunwukong123'

方法3：使用replace或正则表达式删除任意字符串

s2.replace(':','')  #'sunwukong123'
s3 = '\t sun wu kong : 123 \n' # 要去掉 \t, ,:,\n
import re
re.sub('[ \t:\n]+','',s3)  #'sunwukong123'

方法4：字符串translate()，可以删除多种不同字符

s4 = 'abc123' #将abc换成XYZ
s4.translate({ord('a'):'X',ord('b'):'Y',ord('c'):'Z'})  #'XYZ123'
s4.translate(s4.maketrans('abc','XYZ'))                 #'XYZ123'   maketrans内两参数注意对其 可见下输出
s4.maketrans('abc','XYZ')                               # {97: 88, 98: 89, 99: 90}

s4 = 'abc123  \t '
s4.translate({ord(' '):'', ord('\t'):''})   #'abc123'