1、字符串格式化

1.1、使用format()函数格式化字符串

str.format(args)

args要填充的项，多项用逗号分隔

str  字符串模板，格式为'xxxxxx{ [index][:各种选项+格式化占位符] }xxxxxx'

1) { }里是要替换的内容，所有选项都可以不填，这时按顺序填充args中的项

2){ index }指定每个{}里用args里的哪一项，使用索引，从0开始

3){:s}指定选项时，使用:和索引隔开，即使索引省略

4) {{xxx} }  要在字符串中保留大括号的话，要用双大括号{{}} ,表示这不是要替换内容

 

例如：

(1)通过位置来填充字符串

'abc{}'.format('efg')
'abc{1},cde{0}'.format('123','456')
'abc{0:.2f}'.format(2)   # .f表示填充浮点数，2表示保留2位小数
'abc{:.2%}'.format(0.1159) # .%表示百分数,2表示保留2位小数
foramt会把参数按位置顺序来填充到字符串中，第一个参数是0，然后1 ……

也可以不输入数字，这样也会按顺序来填充

同一个参数可以填充多次，这个是format比%先进的地方

(2)通过key来填充

obj = 'world'
name = 'python'
print('hello, {obj} ,i am {name}'.format(obj = obj,name = name))
# 输入结果：hello, world ,i am python

(3)通过列表填充

list=['world','python']
print('hello {names[0]}  i am {names[1]}'.format(names=list))
# 输出结果：hello world  i am python
print('hello {0[0]}  i am {0[1]}'.format(list))
#输出结果：hello world  i am python

(4)通过字典填充

dict={‘obj’:’world’,’name’:’python’}
print(‘hello {names[obj]} i am {names[name]}’.format(names=dict))
# hello world i am python

注意访问字典的key，不用引号的

(5)通过类的属性填充

class Names():
    obj='world'
    name='python'
print('hello {names.obj} i am {names.name}'.format(names=Names))

#输出结果hello world i am python

(6)通过魔法参数填充

args = [‘,’,’inx’]
kwargs = {‘obj’: ‘world’, ‘name’: ‘python’}
print(‘hello {obj} {} i am {name}’.format(*args, **kwargs))
# 输入结果：hello world , i am python

注意：魔法参数跟你函数中使用的性质是一样的：这里format(*args, **kwargs)) 等价于：

format(‘,’,’inx’,obj = ‘world’,name = ‘python’)
(7) 转义“{}”
print('{{hello}} {{{0}}}'.format('world')) #输出结果：{hello} {world}

跟%中%%转义%一样，format中用 { 来转义{ ，用 } 来转义 }

(8) format作为函数变量

name = 'InX'
hello = 'hello,{} welcome to python world!!!'.format #定义一个format格式填充函数
hello(name)  #输入填充变量
# 输入结果：hello,inx welcome to python world!!!

(9) 格式化datetime

from datetime import datetime
now=datetime.now()
print '{:%Y-%m-%d %X}'.format(now)
# 输出结果：2017-07-24 16:51:42

(10) 叹号的用法

print(‘{0!s}国,{1:}’.format(‘中’,’你好’))
# 输出结果：中国

print(‘{0!a}国’.format(‘中’))
# 输出结果：’\u4e2d’国

print(‘{0!r}国’.format(‘中’))
# 输出结果:’中’国

 

！后面可以加s r a 分别对应str() repr() ascii() ，作用是在填充前先用对应的函数来处理参数 。差别就是repr带有引号，str()是面向用户的，目的是可读性，repr()是面向Python解析器的，返回值表示在python内部的含义,ascii ()返回ascii编码。叹号前面的数字是format参数索引。

1.2、使用%格式化字符串

'xxxxxx%dxxxxxx%sxxxxx'%(a,b,c)，元组中元素和字符串中的格式化字符一一对应。
格式化字符格式：%[-/+/0][m][.n][d/s/f/o/c/r]   
- 左对齐，正数无符号，负数加负号
+ 右对齐，正数加正号，负数加负号
0 右对齐，正数无符号，负数加负号，用0填充空白
m-占有宽度
.n  保留小数位数
r 调用格式化对象的repr()方法，返回的字符串带引号
‘%s’%datetime.now()  显示日期时间样式：2019-11-13 08:19:23.070320

1.3、使用f格式化字符串

Python3.6新增功能，性能较高。格式为：

  1. 以 f 或 F 修饰符引领的字符串（f'xxx'或 F'xxx'）
  2. 以大括号 {} 标明被替换的字段

例如：f'Hello, my name is {name}'  #其中name是个变量

 

{}内的内容格式用法：

（1）填变量名 {变量名} ，直接输出变量值

（2）填表达式或函数，先完成计算或函数调用再输出值

例如：

f'Complex number {(2 + 2j) / (2 - 3j)}'
f'The answer is {math.log(math.pi)}'

（3）大括号内不允许出现引号或\，如果必须要用，可以先将该符号定义到一个变量中，再在大括号中引用

2、字符串常用函数

  

in 或 not in

返回True 或False

str.capitalize()

将字符串的第一个字母大写

str.count(substr[,startindex[,endindex]])

获得字符串中子字符substr数目,可指定起始索引

index=str.find(substr[,startindex[,endindex]])

获得字符串中某一子串的起始位置,可指定起始索引, 不存在时返回-1

index=str.index(substr[,startindex[,endindex]])

获得字符串中某一子串的起始位置,可指定起始索引，不存在时抛出异常

str.isalnum()/str.isalpha()/str.isdigit()

检测字符串是否仅包含0~9、A~Z、a~z/A~Z、a~z/0~9

str.islower()/str.isupper()

检测字符串是否均为小写字母或是否均为大写字母

str.isspace()

检测字符串的所有字符是否均为空白字符

str.istitle()

检测字符串中的单词是否为首字符大写

str.join(字符串或者字符串序列)

用str来连接字符串、字符串列表或元组

str.lower()/str.upper()

将字符串的全部字母转为小写/转为大写

str.split(sep[,maxsplit])

以sep分割字符串并返回列表，maxsplit指定分割前几个,参数sep一个或多个字符，可以不指定，默认为所有空白符(包括空格、换行符\n，制表符\t)

str.swapcase()

将字符串中的大写字母转换为小写字母，小写字母转换为大写字母

str.title()

将字符串中单词首字母大写

str.replace(old,new[,max])

字符串替换

str.contains(substr)

是否包含子串返回布尔值

len(str)

获取字符串长度，默认不区分英文和汉字等。

len(str1.encode())

计算UTF-8编码的字符串长度，此时汉字占3个字节。

len(str1.encode('gbk'))

计算GBK编码的字符串长度，此时汉字占2个字节

str.startswith(substr[,startindex[,endindex]])

是否以substr开头，可指定起始范围

str.endswith(substr[,startindex[,endindex]])

是否以substr结尾，可指定起始范围

str.strip(一个或多个字符的字符串)

省略表示默认删除前后所有空白字符。当指定为多个字符的字符串时，删除前后所有在该集合中的字符，直至遇到一个不在该集合中的字符

str.lstrip()

删除字符串前空白字符

str.rstrip()

删除字符串后空白字符

 

关于字符串连接：

字符串是不可变序列，“+”或“+=”连接字符串会创建不必要的临时变量。可以将要连接的字符串加入list，在循环结束后，调用str的join()函数，连接这个列表，例如 str1.join(list1)

str的join()函数可以用来连接字符串或字符串序列(列表或元组) 。

3、字符串编码

3.1、字符串转二进制流

str在内存中是以unicode格式表示的，一个字符对应若干个字节，如果要把字符串在网络上传输或保存到磁盘，就需要将str转变为以字节为单位的bytes。

mybytes=mystr.encode([encoding='utf-8'][,errors='strict'])

功能：将字符串转换为二进制流。

参数：

encoding：指出使用哪种方式进行编码，utf-8还是gb2312。utf8 和gbk里中文字符所占的字节数不同，GBK占2个，utf8占3个。

errors：当mystr中某个字符在目标编码中不支持编码时，的处理方式：

errors='strict'，出错时抛出UnicodeEncodeError异常，默认设置；

errors= "ignore"， 忽略错误；

errors="replace"， 用?代替。

3.2、二进制流转字符串

mystr=mybytes.decode([encoding='utf-8'][,errors='strict'])

功能：将二进制流转换为字符串，

参数：

encoding：解码方式，utf-8还是gbk。需要与encode时的编码方式相同。

errors：用来指定当转换过程中出现错误时的处理方式，默认为errors='strict'，即出错时抛

      出异常。还可指定为errors= "ignore" 或 errors="replace"进行忽略或用?代替

3.3、bytes函数

mybytes =bytes(mystr,encoding='utf-8')    

将str转换为二进制流,encoding选项不可省略，和str.encode()函数功能一致。

3.4、str函数

mystr   =str(mybytes,[ encoding='utf-8'])    

encoding选项省略时，不会进行解码，bytes类型还是bytes类型。

携带encoding选项时，功能和decode()函数相同。

3.5、识别txt或csv文件的编码格式

python标准库chardet可以根据编码的规律对文件的编码格式进行试探，目前支持30多种编码格式，这种识别方式并不能保证百分之百的正确。

输出格式：{'encoding': 'GB2312', 'confidence': 0.99, 'language': 'Chinese'}

  1. 识别小文件的编码，全部读取后判断
with open('test1.txt', 'rb') as f:   
    result = chardet.detect(f.read()) 
print(result['encoding'])
  1. 识别大文件的编码，读取到chardet能识别后即可
from chardet.universaldetector import  UniversalDetector

def checkFileCode(file):
    detector = UniversalDetector()   #创建识别器对象
    with open(file,mode='rb') as fp:
        for line in fp:
            detector.feed(line)   #将行数据输送给识别器
            if detector.done:     #判断识别器是否识别完毕
                break
    detector.close()              #关闭识别器
    print(detector.result)        #获得识别结果
    return detector.result['encoding']

3.6、特殊字符串

对特殊字符串，python有两种表示规范，一种是压缩规范，即正常字符+特殊符号组成特殊字符，例如é  ,另一种是基字符+单独的复合字符，例如e\u0301 ，这两种字符表示方式表示的是同一个字符，但python会认为两者是不同的。

对于特殊字符的比较，可以使用unicodedata.normalize 函数提供的Unicode 规范化。这个函数的第一个参数是这 4 个字符串中的一个：'NFC'、'NFD'、'NFKC' 和 'NFKD'。下面先说明前两个。unicodedata.normalize(type,str)

NFC（Normalization Form C）使用最少的码位构成等价的字符串。

NFD 把组合字符分解成基字符和单独的组合字符。

例如：

（1）特殊字符的比较

>>> from unicodedata import normalize
>>> s1 = 'café' # 把"e"和重音符组合在一起
>>> s2 = 'cafe\u0301' # 分解成"e"和重音符
>>> len(s1), len(s2)
(4, 5)
>>> len(normalize('NFC', s1)), len(normalize('NFC', s2))
(4, 4)
>>> len(normalize('NFD', s1)), len(normalize('NFD', s2))
(5, 5)
>>> normalize('NFC', s1) == normalize('NFC', s2)
True
>>> normalize('NFD', s1) == normalize('NFD', s2)
True

（2）去掉特殊字符中的组合字符

norm_txt = unicodedata.normalize('NFD', txt)  #将str规范变为NFD模式
shaved = ''.join([c for c in norm_txt if not unicodedata.combining(c)])  #过滤掉其中的组合字符
txt= unicodedata.normalize('NFC', shaved)  #将str的范式再变为NFC模式

（3）识别特殊字符的数字floatnum = unicodedata.numeric(char)

Unicode 标准提供了一个完整的数据库unicodedata，不仅包括码位与字符名称之间的映射，还有各个字符的元数据，以及字符之间的关系。unicodedata 模块中有几个函数用于获取字符的元数据。例如，符号对应的人类可读数值 unicodedata.numeric(char) 函数。

import unicodedata
unicodedata.numeric(char)   #特殊符号对应的阿拉伯数字(浮点数)