Python入门学习笔记_5

格式化

使用%的旧版格式化

num = 43
f = 7.03
s = 'String'
print("%-10.4d %-10.4f %-10.4s" % (num, f, s))
print("%*.*d %*.*f %*.*s" % (10, 4, num, 10, 4, f, 10, 4, s))

0043       7.0300     Stri      
      0043     7.0300       Stri

使用{}和format新格式化

num = 43
f = 7.03
s = 'String'
print("{} {} {}".format(num, f, s))

43 7.03 String

• {}中的数字代表第几个变量

print("{2} {0} {1}".format(num, f, s))

String 43 7.03

• 利用字典

d = {
    'num':43,
    'f':7.03,
    's':'String'
}
print('{0[num]} {0[f]} {0[s]} {1}'.format(d, 'other'))

43 7.03 String other

• 指定参数格式

print('{0:d} {1:f} {2:s}'.format(num, f, s))
print('{num:d} {f:f} {s:s}'.format(num = 12, f = 1.2, s = 'Char'))

43 7.030000 String
12 1.200000 Char

• 对齐

print("{0:10d} {1:10f} {2:10s}".format(num, f, s))  #默认左对齐
print("{0:>10d} {1:>10f} {2:>10s}".format(num, f, s))
print("{0:<10d} {1:<10f} {2:<10s}".format(num, f, s))
print("{0:^10d} {1:^10f} {2:^10s}".format(num, f, s))

        43   7.030000 String    
        43   7.030000     String
43         7.030000   String    
    43      7.030000    String  

• 填充字符

print("{:!^20s}".format(s))

!!!!!!!String!!!!!!!

正则表达式

方法名	方法说明
search()	返回第一次成功匹配
findall()	返回所有不重叠的匹配
split()	根据pattern将source切分成若干段，返回由这些片段组成的列表
sub()	需要一个额外的参数replacement，它会把source中所有匹配的pattern改成replacement

1. 使用match()进行准确匹配

import re
source = 'Young Frankenstein'
m = re.match('You', source)  #从源字符的开头开始匹配
if m: #匹配成功则返回了对象
    print(m.group())
    
#使用其实锚点
m = re.match('^You', source)
if m:
    print(m.group())
    
#match只检测模式串开头的源字符串
m = re.match('Frank', source)
if m:
    print(m.group())

You
You

• . 表示任何单一字符
• * 表示任意一个它之前的字符，.*代表任意多个字符（包括0个）

m = re.match('.*Frank', source)
if m:
    print(m.group())

Young Frank

2. 使用search()寻找首次匹配

m = re.search('Frank', source)
if m :
    print(m.group())

Frank

3. 使用findall()寻找所有匹配

m = re.findall('n', source)
print(m)
print('Found', len(m), 'matches')

['n', 'n', 'n', 'n']
Found 4 matches

m = re.findall('n.', source)
m

['ng', 'nk', 'ns']

m = re.findall('n.?', source)
m

['ng', 'nk', 'ns', 'n']

4. 使用split()按匹配切分

m = re.split('n', source)
m

['You', 'g Fra', 'ke', 'stei', '']

5. sub()替换匹配

m = re.sub('n', '?', source)
m

'You?g Fra?ke?stei?'

6. 模式：特殊的字符（详细见下表）

import string
printable = string.printable
print(len(printable))

print(printable[: 50])
print(printable[50:])

100
0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMN
OPQRSTUVWXYZ!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~ 	

# 筛选数字
print(re.findall('\d', printable))
# 筛选空格符
print(re.findall('\s', printable))

['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
[' ', '\t', '\n', '\r', '\x0b', '\x0c']

7. 模式：使用标识符（详细看下表）

source = '''I wish I may, I wish I might
Have a dish of fish tonight.'''

# 检索wish
print(re.findall('wish', source))

# 对源字符串任意位置查询wish或者fish
print(re.findall('wish | fish', source))

# 从字符串开头开始匹配fish
print(re.findall('^wish', source))

# 从字符串开头开始匹配 I wish
print(re.findall('^I wish', source))

# 从字符串结尾开始匹配fish
print(re.findall('fish$', source))

# 从字符串结尾开始匹配fish tonight.
print(re.findall('fish tonight\.$', source)) 

# 查询以w或f开头，后面紧接着ish的匹配
print(re.findall('[wf]ish', source))

# 查询以若干个w、s或h组合的匹配
print(re.findall('[wsh]+', source))

#查询以ght为开头，后面紧跟一个非数字非字母字符的匹配
print(re.findall('ght\W', source))

# 查询以I开头，后面跟着wish的匹配（wish出现次数尽量少）
print(re.findall('I (?=wish)', source))

# 查询以wish结尾，前面为I的匹配（I出现的次数尽量少）
print(re.findall('(?<=I) wish', source))

# 转义字符如果无法识别，使用r开头进行默认
print(re.findall(r'\bfish', source))

['wish', 'wish']
['wish ', 'wish ', ' fish']
[]
['I wish']
[]
['fish tonight.']
['wish', 'wish', 'fish']
['w', 'sh', 'w', 'sh', 'h', 'sh', 'sh', 'h']
['ght\n', 'ght.']
['I ', 'I ']
[' wish', ' wish']
['fish']

• 模式： 定义匹配的输出

m = re.search(r'(.dish\b).*(\bfish)', source)
print(m.group())
print(m.groups())

 dish of fish
(' dish', 'fish')

m = re.search(r'(?P<DISH>. dish\b).*(?P<FISH>\bfish)', source)
print(m.group())
print(m.groups())
print(m.group('DISH'))
print(m.group('FISH'))

a dish of fish
('a dish', 'fish')
a dish
fish

二进制数据

字节和字节数组

blist = [1, 2, 3, 255]
the_bytes = bytes(blist)
print(the_bytes)
the_byte_array = bytearray(blist)
print(the_byte_array)

b'\x01\x02\x03\xff'
bytearray(b'\x01\x02\x03\xff')

• bytes类型不可修改，类似元组
• bytearray类型可更改里面的数据

the_byte_array[1] = 127
the_byte_array

bytearray(b'\x01\x7f\x03\xff')

使用struct转换二进制数据

import struct
valid_png_header = b'\x89PNG\r\n\x1a\n'
data = b'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x9a\x00\x00\x00\x8d\x08\x02\x00\x00\x00\xc0'
if data[:8] == valid_png_header:
    width, height = struct.unpack('>LL', data[16:24])
    print("width = ", width, "Height = ", height)
else:
    print('Not a valid PNG')
    
# width值位于第16-20字节，height值这位于第21-24字节
print(data[16:20])
print(data[20:24])
print(0x9a)
print(0x8d)

width =  154 Height =  141
b'\x00\x00\x00\x9a'
b'\x00\x00\x00\x8d'
154
141

1. pack() 将数据转为字节

import struct
print(struct.pack('>L', 154))
print(struct.pack('>L', 141))

b'\x00\x00\x00\x9a'
b'\x00\x00\x00\x8d'

2. unpack()将字节转为转为数据

print(struct.unpack('>2L', data[16:24]))
print(struct.unpack('>16x2L6x', data))

(154, 141)
(154, 141)

其他二进制数据工具

from construct import Struct, magic, UBInt32, Const, String
fmt = Struct('png',
    Magic(b'\x89PNG\r\n\x1a\n'),
    UBInt32('length'),
    Const(String('type', 4), b'IHDR'),
    UBInt32('width'),
    UBInt32('heigth')
)
data = b'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x9a\x00\x00\x00\x8d\x08\x02\x00\x00\x00\xc0'
result = fmt.parse(data)
print(result)

---------------------------------------------------------------------------

ImportError                               Traceback (most recent call last)

<ipython-input-48-6b4b9128cd1c> in <module>()
----> 1 from construct import Struct, magic, UBInt32, Const, String
      2 fmt = Struct('png',
      3     Magic(b'\x89PNG\r\n\x1a\n'),
      4     UBInt32('length'),
      5     Const(String('type', 4), b'IHDR'),


ImportError: cannot import name 'magic'

使用bonascii()转换字节/字符串

import binascii
valid_png_header = b'\x89PNG\r\n\x1a\n'
print(binascii.hexlify(valid_png_header))

# 反转
print(binascii.unhexlify(b'89504e470d0a1a0a'))

b'89504e470d0a1a0a'
b'\x89PNG\r\n\x1a\n'

附录表

特殊字符

模式	匹配
\d	一个数字字符
\D	一个非数字字符
\w	一个字母或数字字符
\W	一个非字母非数字字符
\s	空白符
\S	非空白符
\b	单词边界（一个\w与\W之间的范围，顺序可逆）
\B	非单词边界

模式标识符

模式	匹配
abc	文本值abc
(expr)	expr
expr1|expr2	expr1或expr2
.	除\n外的任何字符
^	源字符串的开头
$	源字符串的结尾
prev?	0个或1个prev
prev*	0个或多个prev，尽可能多的匹配
prev*?	0个或多个prev，尽可能少的匹配
prev+	1个或多个prev，尽可能多的匹配
prev+?	1个或多个prev，尽可能少的匹配
prev{m}	m个连续的prev
prev{m, n}	m到n个连续的prev，尽可能多的匹配
prev{m, n}?	m到n个连续的prev，尽可能少的匹配
[abc]	a或b或c（和a|b|c）一样
[^abc]	非（a或b或c）
prev(?=next)	如果后面为next，返回prev
prev(?!next)	如果后面非next，返回prev
(?<=prev)next	如果前面为next，返回prev
(?<!prev)next	如果前面非next，返回prev

字节序标识符

标识符	字节序
<	小端方案
>	大端方案

格式标识符

标识符	描述	字节
x	跳过一个字节	1
b	有符号字节	1
B	无符号字节	1
h	有符号短整数	2
H	无符号短整数	2
i	有符号整数	4
I	无符号整数	4
l	有符号长整数	4
L	无符号长整数	4
Q	无符号long long型整数	8
f	单精度浮点数	4
d	双精度浮点数	8
p	数量和字符	1 + 数量
s	字符	数量

比特级整数运算符

运算符	描述	实例	十进制结果	二进制结果
&	与	a&b	1	0b0001
|	或	a|b	5	0b0101
^	异或	a^b	4	0b0100
~	翻转	~a	-6	取决于int类型的大小
<<	左位移	a<<1	10	0b1010
>>	右位移	a>>1	2	0b0010