print("\"大家好\"")
#\\表示一个斜杠\
#\n表示换行

c2 = 'It is a "dog"!'
c2= "It's a dog!"

c1="""he
she
my
you are
hello"""

s1 = u'Hello, 你好！'  # unicode 编码。等价于u省略掉 s1 = 'Hello, 你好！'

s2 = r'hello\n你\好！'  # 斜杠 \ 不再是转义符，而是斜杠本身

s3 = b'Hello, \xe4\xbd\xa0\xe5\xa5\xbd\xef\xbc\x81'  # bytes 类型，显示出来时英文正常，中文变成 \x 开头.
s3.decode('utf-8')  # 转 str 类型

len('abc')

'aaabc'.count('aa')
'aaabc'.endswith('bc'),'aaabc'.startswith('bc')  #bool类型,是否以指定字符串开头/结尾
'aaabc'.index('bc')  #找到则返回序号，找不到则引发ValueError
'aaabc'.find('bc')  #找到则返回第一个的序号，找不到则返回-1，'aaabc'.find('a',1)数字表示从第几个开始找
'aaabc'.replace('bc','x')  #替换指定字符

'aaabc'.upper(),'aaabC'.lower()  #转大写/转小写
a.swapcase() # 返回一个字符串，大写转为小写，同时小写转为大写
'aaabc'.capitalize()  # 返回首字母大写的字符串

','.join(list('abc'))  #前面的字符也可以为空，这时相当于对字符串做加号
'a,b,c'.split(',')    #按','分割，并返回<list>。如果后面的参数为空，按照空格分割

'  \n a,b, c '.strip()   #去两边的空格与换行,strip,lstrip,rstrip
'abc! '.strip('a') #去掉指定字符

'abc'.ljust(5) , 'abc'.rjust(5) ,'abc'.center(10)  # 填充空格使其达到指定长度

for <var> in <string>

len()  返回字符串的长度
str()  返回数字对应的字符串

isprintable # 含\t,\n 时为 False，否则为 True. 另外空格是 True
isspace # 纯\t,\n,空格，或者他们的组合，为 True. 如果混进了字母等，就是 False
islower, isupper # 先剔除\t,\n,空格,数字，然后如果全是小写/大写，返回True。如果剔除空格后没了，返回False
istitle # 先用\t,\n,空格,标点分割，剔除数字，得到单词。如果每个单词的首字母为大写，并且其余字母为小写，则返回True

isidentifier # 是否可以作为Python的变量名，不多说

isalpha # 全字母返回True。如果出现标点、数字、空格，都返回False。另外，中文返回True

isalnum # 如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False.如果出现标点、空格等，都返回 False

'123'.isdecimal() # 如果字符串只包含数字则返回 True 否则返回 False。有小数点也返回 False。有空格也返回False
'²'.isnumeric();'⅓'.isdigit()

'进程{1}占用了CPU {0} 秒。'.format(0.05,10)

# bytes -> 16进制（字符串格式）:
s_hex = bs.hex()
# 结果："e4b8ade69687e5ad97e7aca6e4b8b268656c6c6f"

# 16 进制 -> bytes
bytes.fromhex("e4b8ade69687e5ad97e7aca6e4b8b268656c6c6f")

# (不常用) bytes -> 16进制 -> int -> 2进制
s_bin = bin(int(s_hex, 16))
# 不常用的原因是，这里面 int 有可能很大。这对于 python 是可以的，但在别的语言中没有这个

a = 255000
# int -> bytes
b = a.to_bytes(length=4, byteorder='big') 
# length 指定输出为多少个字节
# byteorder 可以是 big 或者 little
# big：二进制高位在前，低位在后。符合阅读习惯
# little：低位在前，高位在后。历史上某些运算带来效率提升。

# bytes -> int
int.from_bytes(b, byteorder='big')
# 255000

s = '中文字符串hello'

# 字符串 -> 16进制
s_hex = s.encode('utf-8').hex()
# >'e8bf99e698afe4b880e4b8aae5ad97e7aca6e4b8b2'

# 16进制 -> 字符串
bytes.fromhex(s_hex).decode('utf-8')
# >'这是一个字符串'

s = '中文字符串hello'

# str -> 二进制
s_bin = ''.join([format(i, '08b') for i in s.encode('utf-8')])

# 二进制 -> str
s_out = bytes([int(s_bin[i * 8:i * 8 + 8], base=2) for i in range(len(s_bin) // 8)])
s_out.decode('utf-8')

# 解释：
s_bin = [format(i, '08b') for i in s.encode('utf-8')]  # 8位2进制格式
# ['11100100', '10111000', '10101101' ... ]
s_out = bytes([int(i, base=2) for i in s_bin])
# 先转化为 [228, 184, 173, ... ] 这种形式，然后转为 bytes

# bytearray 是可变类型，bytes 是不可变类型
bytearray([int(i, base=2) for i in s_bin]).decode('utf-8')

s_out = b''.join([struct.pack('>B', int(s_bin[i * 8:i * 8 + 8], base=2)) for i in range(len(s_bin) // 8)])
s_out.decode('utf-8')


# 解释：
s_bin = [format(i, '08b') for i in s.encode('utf-8')]  # 8位2进制格式
# ['11100100', '10111000', '10101101' ... ]

s_out = b''.join([struct.pack('>B', int(i, base=2)) for i in s_bin])
# struct.pack('>B', n) 可以把一个 0～255 的数字转为一个比特的 Bytes 类型

import struct
import numpy as np

s = '中文字符串hello'

# 转二进制
seq = np.array(list(s.encode('utf-8')), dtype=np.uint8)  # 0~255 的数列
content_bits = np.unpackbits(seq)  # 0-1 的数列
# 或者：np.unpackbits(np.frombuffer(s.encode('utf=8'), dtype='>B'))

# 二进制转字符串
nums = np.packbits(content_bits)# 0～255 的数列
content_decode = bytes(nums)
content_decode.decode('utf-8')

[i for i in s] # 这里面的 i 是字符
# ['中', '文', '字', '符', '串', 'h', 'e', 'l', 'l', 'o']

[ord(i) for i in s] # unicode 编码，关于 unicode 的解释参考前面
# [20013, 25991, 23383, 31526, 20018, 104, 101, 108, 108, 111]

[bin(i) for i in s.encode('utf-8')]  # 得到二进制list，但是长短不齐，['0b11100100', '0b1101']
[format(i, 'b') for i in s.encode('utf-8')]  # 同样长短不齐 ['11100100', '1101']

[i for i in s.encode('utf-8')] #  0-255 组成的列表
# [228, 184, 173, ... ]

# 转2进制
s_bin = bin(int(s.encode('utf-8').hex(), base=16))[2:]
# 开头的0会被略去，某些其操作导致错位而出错，用这个补救：
s_bin = (8 - len(s_bin) % 8) * '0' + s_bin
s_out = bytes.fromhex(hex(int(s_bin, base=2))[2:]).decode('utf-8', errors='replace')

s = '中文字符串hello'

# 字符串转10进制列表
s_dec = [ord(c) for c in s]

# 字符串转2进制列表(不带 0x )
s_bin = [bin(ord(c))[2:] for c in s]  # 字符串转二进制

# 字符串转16进制列表
[hex(ord(c)) for c in s]

import zlib
import sys

s = '''
zlib.compress 可以压缩字符串。
它输入 byte 类型，输出也是 byte 类型。

有些系统（例如某些数据库） 不支持 byte 类型，所以往往把压缩后的  byte 类型转为十六进制；
后果是有可能转为十六进制后的文本反而变大。

zlib 对于有很多重复/空格的字符串效果很好，例如：
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc
'''

# 压缩
zlib_str = zlib.compress(s.encode('utf-8'))
# 转回
s_new = zlib.decompress(zlib_str).decode('utf-8')

# 压缩 + 转16进制
hex_str = zlib.compress(s.encode('utf-8')).hex()
# 转回
s_new2 = zlib.decompress(bytes.fromhex(hex_str)).decode('utf-8')

print("原始字符串大小 = ", sys.getsizeof(s))
print("压缩后的字符串大小 = ", sys.getsizeof(zlib_str))
print("压缩+转十六进制后的大小 = ", sys.getsizeof(hex_str))

# !pip install chardet
import chardet
chardet.detect(b'\xc8\xcb\xc9\xfa\xbf\xe0\xb6\xcc\xa3\xac\xce\xd2\xd3\xc3Python')
# {'encoding': 'GB2312', 'confidence': 0.99, 'language': 'Chinese'}

str1 ='hello world'
for index,letter in enumerate(str1):
    print(index,letter)
for i in enumerate(str1)
    print(i) #i是tuple类型

# 1. 可用于可迭代对象
# 2. enumerate(str1, start=2) 可以指定从第几个开始

import string  #string模块，处理字符比较方便
string.punctuation
string.digits
string.whitespace

regex = re.compile('(\w+) had a ((\w+) \w+)')
text = 'I had a nice day，I had a nice day'
regex.findall(text)
# [('I', 'nice day', 'nice'), ('I', 'nice day', 'nice')]
# 每个括号里面都匹配出来。整体没加括号，所以不匹配

[m.group(0) for m in regex.finditer(text)]
# 等价于 [m.group() for m in regex.finditer(text)]
# ['I had a nice day', 'I had a nice day']
# 0 指的是把整体匹配出来

# 分别把括号里面的内容匹配出来
[m.group(1) for m in regex.finditer(text)]
# ['I', 'I']
[m.group(2) for m in regex.finditer(text)]
# ['nice day', 'nice day']
[m.group(3) for m in regex.finditer(text)]
# ['nice', 'nice']


[m.groups() for m in regex.finditer(text)]
# 与 group 的区别
# 括号里面的全部匹配出来，而不是
# [('I', 'nice day', 'nice'), ('I', 'nice day', 'nice')]

# 可以用 \+数字来指定序号，序号从1开始
regex1 = re.compile(r'I have a (\w+) and a (\w+)')
replace_str = r'There is \2 and \1, Good!'
sentence = 'I have a book and a pen. You May use those.'
regex1.sub(replace_str, sentence)
# 上面的语句返回 'There is pen and book, Good!. You May use those.'
# 解释：
# step1：按照正则，从 sentence 中提取 1: book, 2: pen
# step2：分别填入 replace_str 中的 \2 \1


# 一个sub的实用案例：
regex1 = re.compile(r'min=(\w{2}), hour=(\w{2})')
regex1.sub(r'\2:\1', 'Now time is min=15, hour=20')
# 返回：'Now time is 20:15'

# 可以用 \+数字来指定序号，序号从1开始
regex1 = re.compile(r'(\w+) is (\1)')
regex1.findall('one is one, two is two, one is two')

[m.group(0) for m in regex1.finditer('one is one, two is two, one is two')]
# ['one is one', 'two is two']
# 意味着 one is two 不会被匹配出来


# 另外，分组引用符也可以外加括号变成分组：
#
re.compile(r'(\w+) is (\1)')