Python的字符串和字节型

目录

• 字符串(str)
  • 字符串的定义
  • 字符串的常用操作
  • 字符串相关的函数
    • 常用函数
    • 其它函数
  • 字符串切片
  • 字符串拼接
    • 百分号方式
    • format方式
    • f-strings方式
• 字节型(bytes)
  • 回顾编码的发展史
  • bytes和str的异同
  • encode和decode

字符串(str)

字符串的定义

• 字符串 就是 一串字符，是编程语言中表示文本的数据类型
• 在 Python 中可以使用 一对双引号 " 或者 一对单引号 ' 定义一个字符串
• 可以使用 索引 获取一个字符串中 指定位置的字符，索引计数从 0 开始
• 也可以使用 for 循环遍历 字符串中每一个字符

#!/usr/bin/env python3
# -*-coding:utf-8-*-

"""
@author:fyh
@time:2019/5/31
"""

str1 = "hello python"

for c in str1:
    print(c, end='	')
    
# 运行结果：h    e    l    l    o         p    y    t    h    o    n

字符串的常用操作

#!/usr/bin/env python3
# -*-coding:utf-8-*-

"""
@author:fyh
@time:2019/5/31
"""

# 1   * 重复输出字符串
print('hello' * 2)

# 2 [] ,[:] 通过索引获取字符串中字符
print('helloworld'[2:])

# 3 in  成员运算符 - 如果字符串中包含给定的字符返回 True
print('el' in 'hello')

# 4 %   格式字符串
print('alex is a good teacher')
print('%s is a good teacher' % 'alex')

# 5 +   字符串拼接
a = '123'
b = 'abc'
c = '789'
d1 = a + b + c
print(d1)  # +效率低,该用join

# join效率高
d2 = ''.join([a, b, c])
print(d2)

字符串相关的函数

常用函数

# string.upper() 转换 string 中的小写字母为大写
# string.lower() 转换 string 中所有大写字符为小写
# string.startswith(obj, beg=0,end=len(string)) 检查字符串是否是以obj开头，是则返回True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查.
# string.endswith(obj, beg=0, end=len(string)) 检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.
# string.replace(str1, str2, num=string.count(str1)) 把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次.
# string.strip([obj]) 在 string 上执行 lstrip()和 rstrip() 去除空格
# string.split(str="", num=string.count(str)) 以 str 为分隔符切片 string，如果 num有指定值，则仅分隔 num 个子字符串
# string.find(str, beg=0, end=len(string)) 检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1
# string.encode(encoding='UTF-8', errors='strict') 以 encoding 指定的编码格式编码 string，如果出错默认报一个ValueError 的异常，除非 errors 指定的是ignore或者replace
# string.decode(encoding='UTF-8', errors='strict') 以 encoding 指定的编码格式解码 string，如果出错默认报一个ValueError的异常，除非errors指定的是'ignore'或 者'replace'
# string.join(seq) 以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
# string.format()  格式化输出

其它函数

# string.capitalize() 把字符串的第一个字符大写
# string.center(width) 返回一个原字符串居中,并使用空格填充至长度 width 的新字符串
# string.count(str, beg=0, end=len(string)) 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
# string.expandtabs(tabsize=8) 把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是8。
# string.index(str, beg=0, end=len(string)) 跟find()方法一样，只不过如果str不在 string中会报一个异常.
# string.isalnum() 如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False
# string.isalpha() 如果 string 至少有一个字符并且所有字符都是字母则返回 True,否则返回 False
# string.isdecimal() 如果 string 只包含十进制数字则返回 True 否则返回 False.
# string.isdigit() 如果 string 只包含数字则返回 True 否则返回 False.
# string.islower() 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
# string.isnumeric() 如果 string 中只包含数字字符，则返回 True，否则返回 False
# string.isspace() 如果 string 中只包含空格，则返回 True，否则返回 False.
# string.istitle() 如果 string 是标题化的(见 title())则返回 True，否则返回 False
# string.isupper() 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
# string.ljust(width) 返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串
# string.lstrip() 截掉 string 左边的空格
# string.maketrans(intab, outtab]) maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
# max(str) 返回字符串 str 中最大的字母。
# min(str) 返回字符串 str 中最小的字母。
# string.partition(str) 有点像 find()和 split()的结合体,从 str 出现的第一个位置起,把 字 符 串 string 分 成 一 个 3 元 素 的 元 组 (string_pre_str,str,string_post_str),如果 string 中不包含str 则 string_pre_str == string.
# string.rfind(str, beg=0,end=len(string) ) 类似于 find()函数，不过是从右边开始查找.
# string.rindex( str, beg=0,end=len(string)) 类似于 index()，不过是从右边开始.
# string.rjust(width) 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串
# string.rpartition(str) 类似于 partition()函数,不过是从右边开始查找.
# string.rstrip() 删除 string 字符串末尾的空格.
# string.splitlines(num=string.count('
')) 按照行分隔，返回一个包含各行作为元素的列表，如果 num 指定则仅切片 num 个行.
# string.swapcase() 翻转 string 中的大小写
# string.title() 返回"标题化"的 string,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())
# string.translate(str, del="") 根据 str 给出的表(包含 256 个字符)转换 string 的字符,要过滤掉的字符放到 del 参数中

案例：

#!/usr/bin/env python3
# -*-coding:utf-8-*-

"""
@author:fyh
@time:2019/5/31
"""

name = "hello world"
# 小写字母变为大写
print(name.upper())    # HELLO WORLD
print(name)            # hello world

# 把大写字母变小写
name2 = "HELLO WORLD"
print(name2.lower())    # hello world
print(name2)            # HELLO WORLD

# 判断是否以。。。开头
name3 = "hello"
print(name3.startswith("he"))   # True
# 检查字符串是否以。。结尾
print(name3.endswith("lo"))     # True

# replace   替换
name4 = "python"
print(name4.replace('th', 'aa'))    # pyaaon

# 去除空格
name5 = "  bbcc  "
print(name5.strip())    # bbcc

# 分割
str1 = "aa|bb|cc|dd"
print(str1.split('|'))  # ['aa', 'bb', 'cc', 'dd']

# 查找  返回开始的索引值
str2 = "we are family"
print(str2.find("are"))     # 3

# join  拼接
lst1 = ['aa', 'bb', 'cc', 'dd']
print("-".join(lst1))       # aa-bb-cc-dd

字符串切片

• 切片 使用 索引值 来限定范围，根据 步长 从原序列中 取出一部分 元素组成新序列
• 切片 方法适用于 字符串、列表、元组
• 切片的语法表达式为：[start_index : end_index : step]，其中：
  • start_index：起始索引
  • end_index：结束索引
  • step：步长

切片操作是指按照步长，截取从起始索引到结束索引，但不包含结束索引（也就是结束索引减1）的所有元素。

切片不会改变原对象，而是重新生成了一个新的对象

#!/usr/bin/env python3
# -*-coding:utf-8-*-

"""
@author:fyh
@time:2019/5/31
"""

str1 = "hello world"


print(str1[1:6])
# 结果是ello

print(str1[1:6:2])
# 结果是el

print(str1[2:])
# 结果是llo world
# 保留start_index，但省略end_index，这样会从起始索引开始，切到最后一个元素为止

print(str1[:5])
# 结果是hello
# 省略start_index，保留end_index，这样会从第一个元素开始，切到end_index - 1的元素为止

print(str1[-1:-6:-1])
# 结果是dlrow

print(str1[1:6:-1])
# 结果为空
# 切片时,一定要保证start_index到end_index的方向与步长step的方向同向，否则会切出空的序列

字符串拼接

Python的字符串格式化有三种方式: 百分号方式、format方式、f-strings方式

百分号方式

格式：%[(name)][flags][width].[precision]typecode

• (name) 可选，用于选择指定的key

• flags 可选，可供选择的值有:

• • + 右对齐；正数前加正好，负数前加负号；
  • - 左对齐；正数前无符号，负数前加负号；
  • 空格 右对齐；正数前加空格，负数前加负号；
  • 0 右对齐；正数前无符号，负数前加负号；用0填充空白处

• width 可选，占有宽度

• precision 可选，小数点后保留的位数

• typecode 必选

• • s，获取传入对象的__str__方法的返回值，并将其格式化到指定位置
  • r，获取传入对象的__repr__方法的返回值，并将其格式化到指定位置
  • c，整数：将数字转换成其unicode对应的值，10进制范围为 0 <= i <= 1114111（py27则只支持0-255）；字符：将字符添加到指定位置
  • o，将整数转换成 八进制表示，并将其格式化到指定位置
  • x，将整数转换成十六进制表示，并将其格式化到指定位置
  • d，将整数、浮点数转换成 十 进制表示，并将其格式化到指定位置
  • e，将整数、浮点数转换成科学计数法，并将其格式化到指定位置（小写e）
  • E，将整数、浮点数转换成科学计数法，并将其格式化到指定位置（大写E）
  • f， 将整数、浮点数转换成浮点数表示，并将其格式化到指定位置（默认保留小数点后6位）
  • F，同上
  • g，自动调整将整数、浮点数转换成 浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是e；）
  • G，自动调整将整数、浮点数转换成浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是E；）
  • %，当字符串中存在格式化标志时，需要用 %%表示一个百分号

注：Python中百分号格式化是不存在自动将整数转换成二进制表示的方式

案例：

tpl = "i am %s" % "alex"
  
tpl = "i am %s age %d" % ("alex", 18)
  
tpl = "i am %(name)s age %(age)d" % {"name": "alex", "age": 18}
  
tpl = "percent %.2f" % 99.97623
  
tpl = "i am %(pp).2f" % {"pp": 123.425556, }
  
tpl = "i am %.2f %%" % 123.425556

format方式

格式：[[fill]align][sign][#][0][width][,][.precision][type]

• • fill 【可选】空白处填充的字符

  • align 【可选】对齐方式（需配合width使用）

  • • <，内容左对齐
    • >，内容右对齐(默认)
    • ＝，内容右对齐，将符号放置在填充字符的左侧，且只对数字类型有效。 即使：符号+填充物+数字
    • ^，内容居中

  • sign 【可选】有无符号数字

  • • +，正号加正，负号加负；
    • -，正号不变，负号加负；
    • 空格 ，正号空格，负号加负；

  • # 【可选】对于二进制、八进制、十六进制，如果加上#，会显示 0b/0o/0x，否则不显示

  • ， 【可选】为数字添加分隔符，如：1,000,000

  • width 【可选】格式化位所占宽度

  • .precision 【可选】小数位保留精度

  • type 【可选】格式化类型

  • • 传入” 字符串类型 “的参数

    • • s，格式化字符串类型数据
      • 空白，未指定类型，则默认是None，同s

    • 传入“ 整数类型 ”的参数

    • • b，将10进制整数自动转换成2进制表示然后格式化
      • c，将10进制整数自动转换为其对应的unicode字符
      • d，十进制整数
      • o，将10进制整数自动转换成8进制表示然后格式化；
      • x，将10进制整数自动转换成16进制表示然后格式化（小写x）
      • X，将10进制整数自动转换成16进制表示然后格式化（大写X）
• • • 传入“ 浮点型或小数类型 ”的参数
• • • • e， 转换为科学计数法（小写e）表示，然后格式化；
      • E， 转换为科学计数法（大写E）表示，然后格式化;
      • f ， 转换为浮点型（默认小数点后保留6位）表示，然后格式化；
      • F， 转换为浮点型（默认小数点后保留6位）表示，然后格式化；
      • g， 自动在e和f中切换
      • G， 自动在E和F中切换
      • %，显示百分比（默认显示小数点后6位）

案例：

tpl = "i am {}, age {}, {}".format("seven", 18, 'alex')
   
tpl = "i am {}, age {}, {}".format(*["seven", 18, 'alex'])
   
tpl = "i am {0}, age {1}, really {0}".format("seven", 18)
   
tpl = "i am {0}, age {1}, really {0}".format(*["seven", 18])
   
tpl = "i am {name}, age {age}, really {name}".format(name="seven", age=18)
   
tpl = "i am {name}, age {age}, really {name}".format(**{"name": "seven", "age": 18})
   
tpl = "i am {0[0]}, age {0[1]}, really {0[2]}".format([1, 2, 3], [11, 22, 33])
   
tpl = "i am {:s}, age {:d}, money {:f}".format("seven", 18, 88888.1)
   
tpl = "i am {:s}, age {:d}".format(*["seven", 18])
   
tpl = "i am {name:s}, age {age:d}".format(name="seven", age=18)
   
tpl = "i am {name:s}, age {age:d}".format(**{"name": "seven", "age": 18})
  
tpl = "numbers: {:b},{:o},{:d},{:x},{:X}, {:%}".format(15, 15, 15, 15, 15, 15.87623, 2)
  
tpl = "numbers: {:b},{:o},{:d},{:x},{:X}, {:%}".format(15, 15, 15, 15, 15, 15.87623, 2)
  
tpl = "numbers: {0:b},{0:o},{0:d},{0:x},{0:X}, {0:%}".format(15)
  
tpl = "numbers: {num:b},{num:o},{num:d},{num:x},{num:X}, {num:%}".format(num=15)

f-strings方式

f-strings 提供一种简洁易读的方式, 可以在字符串中包含 Python 表达式. f-strings 以字母 'f' 或 'F' 为前缀, 格式化字符串使用一对单引号、双引号、三单引号、三双引号. 格式化字符串中。

#!/usr/bin/env python
# -*-coding:utf-8-*-

"""
@author:fyh
@time:2019/6/5
"""
name = '豪仔'
age = 26
format_string1 = f'我的名字是 {name}, 我的年龄是 {age}'
print(format_string1)  # 我的名字是 豪仔, 我的年龄是 26

format_string2 = f"我的名字是 {name}, 我的年龄是 {age}"
print(format_string2)   # 我的名字是 豪仔, 我的年龄是 26

format_string3 = F'''我的名字是 {name}, 我的年龄是 {age}'''
print(format_string3)  # 我的名字是 豪仔, 我的年龄是 26

format_string4 = F"""我的名字是 {name}, 我的年龄是 {age}"""
print(format_string4)   # 我的名字是 豪仔, 我的年龄是 26

# 花括号中的数字会先运算
format_string5 = f'3 + 5 = {3 + 5}'
print(format_string5)   # 3 + 5 = 8

a = 10
b = 20
format_string6 = f'3 + 5 = {a + b}'
print(format_string6)   # 3 + 5 = 30

# 两个花括号会被替换为一个花括号, 注意{{}} 不表示表达式
format_string7 = F'我的名字是 {{name}}, 我的年龄是 {{age}}'
print(format_string7)

字节型(bytes)

Python3最重要的新特性之一是对字符串和二进制数据流做了明确的区分。文本总是Unicode，由str类型表示，二进制数据则由bytes类型表示。Python3不会以任意隐式的方式混用str和bytes，你不能拼接字符串和字节流，也无法在字节流里搜索字符串（反之亦然），也不能将字符串传入参数为字节流的函数（反之亦然）。

回顾编码的发展史

在计算机历史的早期，美国为代表的英语系国家主导了整个计算机行业，26个英文字母组成了多样的英语单词、语句、文章。因此，最早的字符编码规范是ASCII码，一种8位即1个字节的编码规范，它可以涵盖整个英语系的编码需要。

编码是什么？编码就是把一个字符用一个二进制来表示。我们都知道，所有的东西，不管是英文、中文还是符号等等，最终存储在磁盘上都是01010101这类东西。在计算机内部，读取和存储数据归根结底，处理的都是0和1组成的比特流。问题来了，人类看不懂这些比特流，如何让这些010101对人类变得可读呢？于是出现了字符编码，它是个翻译机，在计算机内部某个地方，透明的帮我们将比特流翻译成人类可以直接理解的文字。对于一般用户，不需要知道这个过程是什么原理，是怎么执行的。但是对于程序员却是个必须搞清楚的问题。

以ASCII编码为例，它规定1个字节8个比特位代表1个字符的编码，也就是“00000000”这么宽，一个一个字节的解读。例如：01000001表示大写字母A，有时我们会“偷懒"的用65这个十进制来表示A在ASCII中的编码。8个比特位，可以没有重复的最多表示2的8次方(255)个字符。

后来，计算机得到普及，中文、日文、韩文等等国家的文字需要在计算机内表示，ASCII的255位远远不够，于是标准组织制定出了叫做UNICODE的万国码，它规定任何一个字符（不管哪国的）至少以2个字节表示，可以更多。其中，英文字母就是用2个字节，而汉字是3个字节。这个编码虽然很好，满足了所有人的要求，但是它不兼容ASCII，同时还占用较多的空间和内存。因为，在计算机世界更多的字符是英文字母，明明可以1个字节就能够表示，非要用2个。

于是UTF-8编码应运而生，它规定英文字母系列用1个字节表示，汉字用3个字节表示等等。因此，它兼容ASCII，可以解码早期的文档。UTF-8很快就得到了广泛的应用。

在编码的发展历程中，我国还创造了自己的编码方式，例如GBK，GB2312，BIG5。他们只局限于在国内使用，不被国外认可。在GBK编码中，中文汉字占2个字节。

bytes和str的异同

回到bytes和str的身上。bytes是一种比特流，它的存在形式是01010001110这种。我们无论是在写代码，还是阅读文章的过程中，肯定不会有人直接阅读这种比特流，它必须有一个编码方式，使得它变成有意义的比特流，而不是一堆晦涩难懂的01组合。因为编码方式的不同，对这个比特流的解读也会不同，对实际使用造成了很大的困扰。下面让我们看看Python是如何处理这一系列编码问题的：

>>> s = "中文"
>>> s
'中文'
>>> type(s)
<class 'str'>
>>> b = bytes(s, encoding='utf-8')
>>> b
b'xe4xb8xadxe6x96x87'
>>> type(b)
<class 'bytes'>

从例子可以看出，s是个字符串类型。Python有个内置函数bytes()可以将字符串str类型转换成bytes类型，b实际上是一串01的组合，但为了在ide环境中让我们相对直观的观察，它被表现成了b'xe4xb8xadxe6x96x87'这种形式，开头的b表示这是一个bytes类型。xe4是十六进制的表示方式，它占用1个字节的长度，因此”中文“被编码成utf-8后，我们可以数得出一共用了6个字节，每个汉字占用3个，这印证了上面的论述。在使用内置函数bytes()的时候，必须明确encoding的参数，不可省略。

我们都知道，字符串类str里有一个encode()方法，它是从字符串向比特流的编码过程。而bytes类型恰好有个decode()方法，它是从比特流向字符串解码的过程。除此之外，我们查看Python源码会发现bytes和str拥有几乎一模一样的方法列表，最大的区别就是encode和decode。

从实质上来说，字符串在磁盘上的保存形式也是01的组合，也需要编码解码。

如果，上面的阐述还不能让你搞清楚两者的区别，那么记住下面两几句话：

1. 在将字符串存入磁盘和从磁盘读取字符串的过程中，Python自动地帮你完成了编码和解码的工作，你不需要关心它的过程。
2. 使用bytes类型，实质上是告诉Python，不需要它帮你自动地完成编码和解码的工作，而是用户自己手动进行，并指定编码格式。
3. Python已经严格区分了bytes和str两种数据类型，你不能在需要bytes类型参数的时候使用str参数，反之亦然。这点在读写磁盘文件时容易碰到。

在bytes和str的互相转换过程中，实际就是编码解码的过程，必须显式地指定编码格式。

#!/usr/bin/env python3
# -*-coding:utf-8-*-

"""
@author:fyh
@time:2019/5/31
"""
# gbk编码的bytes
b = bytes('中国', encoding='gbk')
print(b)        # b'xd6xd0xb9xfa'
print(type(b))  # <class 'bytes'>

str1 = str(b)
print(str1)     # b'xd6xd0xb9xfa'
print(type(str1))   # <class 'str'>

# 指定编码格式
str2 = str(b, encoding='gbk')
print(str2)     # 中国
print(type(str2))   # <class 'str'>

# 再把字符串str2转换为utf8编码格式的bytes类型:
b2 = bytes(str2, encoding='utf8')
print(b2)       # b'xe4xb8xadxe5x9bxbd'
print(type(b2))     # <class 'bytes'>

encode和decode

上面说过了，python3默认的编码时Unicode，用字符串表示，二进制数据由bytes类型表示。

• encode：将str转换为bytes，是一个编码的过程
• decode：将bytes转换为str，是一个解码的过程

#!/usr/bin/env python3
# -*-coding:utf-8-*-

"""
@author:fyh
@time:2019/5/31
"""

"""
其中decode()与encode()方法可以接受参数， 其声明分别为:
    bytes.decode(encoding="utf-8", errors="strict")
    str.encode(encoding="utf-8", errors="strict")

        其中 encoding是指在解码/编码(动词)过程中使用的字符编码(名词)
        
        errors是指错误的处理方案,errrors参数默认值是strict(严格的)意味着如果编解码出错将会抛出UnicodeError

        如果想忽略编解码错误 可以将errors设置为ignore
"""


# 编码 encode
str1 = "中国"
 
str1_utf8 = str1.encode(encoding='utf8')
print(str1_utf8)        # b'xe4xb8xadxe5x9bxbd'
print(type(str1_utf8))  # <class 'bytes'>

str1_gbk = str1.encode(encoding="gbk")
print(str1_gbk)         # b'xd6xd0xb9xfa'
print(type(str1_gbk))   # <class 'bytes'>
 

# 解码 decode
str2 = str1_utf8.decode(encoding="utf8")
print(str2)     # 中国
print(type(str2))   # <class 'str'>

str3 = str1_gbk.decode(encoding="gbk")
print(str3)         # 中国
print(type(str3))   # <class 'str'>

编码和解码时，对应的编码方式要一致

对数据的编码解码工作是通过返回值查看到最终结果的，前面的数据对象并不受影响