文章目录
 
1. 字符串基础
1.1 定义字符串
1.2 转义字符
1.3 原始字符串
1.4 Unicode 字符串
1.5 字符编码类型
1.6 字节串
1.7 字符编码和解码
1.8 字符串的长度
1.9 访问字符串
1.10 遍历字符串
1.10.1 使用 for 语句
1.10.2 使用 range()
1.10.3 使用 enumerate()
1.10.4 使用 iter()
1.10.5 逆序遍历
   
1.11 案例：判断两个字符串是否为变形词
1.12 案例：字节串的应用
1.12.1 计算md5
1.12.2 二进制读写文件
1.12.3 socket编程
  
 

 
在 Python 中，字符串就是一串字符的组合，它是不可变的、有限字符序列，包括可见字符、不可见字符（如空格符等）和转义字符。Python 通过 str 类型提供大量方法来操作字符串，如字符串的替换、删除、截取、复制、连接、比较、查找、分隔等。本篇博文将详细介绍操作字符串的一般方法。因为字符串在开发过程中，是非常常见的一种数据类型，在爬虫中经常都是对字符串进行操作，包括 URL 拼接、格式化、数据处理(替换、去除空白、截取等)，所以读者需要对其常规操作进行熟练掌握，读者将本文收藏当作文档查阅工具使用也可。学习重点如下：
 
1. 如何定义字符串。
 2. 字符串长度的计算和编码。
 3. 字符串连接和截取。
 4. 字符串查找和替换。
 5. 熟悉字符串的其他常规操作。
 
1. 字符串基础
 
1.1 定义字符串
 
在 Python 中，可以使用很多种方式来进行字符串的定义。下面对各种定义方式进行详细地介绍与说明。注意：Python 不支持字符类型，单个字符也算是一个字符串。
 
(1) 单行字符串
 在 Python 中，使用单引号（'）和 双引号（"）可以定义字符串，注意是成对出现。语法格式如下：
 
'单行字符串'
"单行字符串"
 
单引号和双引号常用于表示单行字符串，也可以在字符串中添加换行符（\n）间接定义多行字符串。在使用单引号定义的字符串中，可以直接包含双引号，而不必进行转义，而在使用双引号定义的字符串中，可以直接包含单引号，而不必进行转义。一句话讲：外双内单、外单内双。
 
示例：定义两个字符串，分别包含单引号和双引号，为了避免使用转义字符，则分别使用单引号和双引号定义字符串。
 
 (2) 多行字符串
 单引号、双引号定义多行字符串时，需要添加换行符 \n，而三引号不需要添加换行符，语法格式如下：
 
'''多行
字符串'''
"""多行
字符串"""
 
同时字符串中可以包含单引号、双引号、换行符、制表符，以及其他特殊字符，对于这些特殊字符不需要使用反斜杠（\）进行转义。另外，三引号中还可以包含注释信息。
 
三引号可以帮助开发人员从引号和转义字符的泥潭里面解脱出来，确保字符串的原始格式。但是平时我们使用得最多的还是单行字符串，三引号一般用于函数注释、类注释、定义 SQL 语句等，读者可以在 源码中看到大量三引号的应用，如下：
 
 本示例使用三引号定义一个 SQL 字符串。如下：
 
str3 = """
CREATE TABLE users(  # 表名
name VARCHAR(8),  # 姓名字段
id INTEGER,  # 编号字段
password INTEGER)  # 密码字段
"""
print(str3)
 
(3) 使用 str() 函数
 使用 str() 函数可以创建空字符串，也可以将任意类型的对象转换为字符串。下面示例演示使用 str() 函数创建字符串的不同形式。
 
 注意：str() 函数的返回值由类型的 __str__ 魔法方法决定。 下面示例自定义一个 list 类型，定义 __str__ 魔法方法的返回值为 list 字符串表示，同时去掉左右两侧的中括号分隔符。
 
class MyList(list):  # 自定义 list类型，继承于list
    def __init__(self, value):  # 类型初始化函数
        self.value = list(value)  # 把接收的参数转换为列表并存储起来

    def __str__(self):  # 类型字符串表示函数
        # 把传入的值转换为字符串，并去掉左右两侧的中括号分隔符
        return str(self.value).replace("[", "").replace("]", "")


s = str(MyList([1, 2, 3]))  # 把自定义类型实例对象转换为字符串
print(s)  # 默认为"[1, 2, 3]" 实际输出结果为："1, 2, 3"
 
1.2 转义字符
 
在 Python 字符串中如果显示特殊字符，必须经过转义才能够显示。例如，换行符需要使用 \n 表示，制表符需要使用 \t 表示，单引号需要使用 \' ，双引号需要使用 \" 表示，等等。Python 可用的字符转义序列说明如下表所示：
 
转 义 序 列
含 义
\newline（下一行）
忽略反斜杠和换行
\\
反斜杠（\）
\’
单引号（’）
\"
双引号（"）
\a
ASCII 响铃（BEL）
\b
ASCII 退格（BS）
\f
ASCII 换页（FF）
\n
ASCII 换行（LF）
\r
ASCII 回车（CR）
\t
ASCII 水平制表（TAB）
\v
ASCII 垂直制表（VT）
\ooo
八进制的 ooo 的字符。与标准C中一样，最多可接收3个八进制数字
\xhh
十六进制值 hh 的字符。与标准C不同，只需要2个十六进制数字
\N{name}
Unicode 数据库中名称为 name 的字符。【提示】：只在字符串字面值中识别的转义序列
\uxxxx
16 位的十六进制值为 xxxx 的字符。4个十六进制数字是必需的。【提示】：只在字符串字面值中识别的转义序列
\Uxxxxxxxx
32 位的十六进制值为 xxxxxxxx 的字符，任何 Unicode 字符可以这种方式被编码。8个十六进制数字是必需的。【提示】：只在字符串字面值中识别的转义序列
【示例1】本示例分别使用转义字符、八进制数字、十六进制数字表示换行符。
 
 【示例2】如果八进制数字不满3位，则首位自动补充0。如果八进制数字超出3位，十六进制数字超出2位，超出数字将视为普通字符显示。
 
 
1.3 原始字符串
 
在 Python3 中，字符串常见有 3 种形式：普通字符串（str）、Unicode 字符串（unicode）和原始字符串（也称为原义字符串）。
 
原始字符串的出现目的：解决字符串中显示特殊字符。在原始字符串里，所有的字符都直接按照字面的意思来使用，不支持转义序列和非打印的字符。
 
原始字符串的这个特性让一些工作变得非常方便。例如，在使用正则表达式的过程中，正则表达式字符串，通常是由代表字符、分组、匹配信息、变量名和字符类等特殊符号组成。当使用特殊字符时，\字符 格式的特殊字符容易被歧义，这时使用原始字符串就会派上用场。可以使用 r 或 R 来定义原始字符串，这个操作符必须紧靠在第一个引号前面。语法格式如下：
 
r"原始字符串"
R"原始字符串"
 
【示例】定义文件路径的字符串时，会使用很多反斜杠，如果每个反斜杠都用歧义字符串来表示会很麻烦，可以采用下面代码来表示。
 
 
1.4 Unicode 字符串
 
从 Python 1.6 开始支持 Unicode 字符串，用来表示双字节、多字节字符、实现与其他字符编码的格式转换。在 Python 中，定义 Unicode 字符串与定义普通字符串一样简单，语法格式如下：
 
u'Unicode 字符串'
U"Unicode 字符串"
 
引号前面的操作符 u 或 U 表示创建的是一个 Unicode 字符串。如果想加入特殊字符，可以使用 Unicode 编码。例如：
 
str1 = u"Hello\u0020World"
print(str1)  # 输出：Hello World
 
被替换的 \u0020 标识符表示在给定位置插入编码值为 0x0020 的 Unicode 字符（空格符）。Unicode 字符串的作用：u 操作符后面字符串将以 Unicode 格式进行编码，防止因为源码存储格式问题，导致再次使用时出现乱码。
 
unicode() 和 unichr() 函数可以作为 Unicode 版本的 str()和chr()。unicode()函数可以把任何 Python 的数据类型转换成一个 Unicode 字符串，如果对象定义了 __unicode__() 魔术方法，它还可以把该对象转换成相应的 Unicode 字符串。unichr() 函数和chr()函数功能基本一样，只不过返回 Unicode 的字符。
 
1.5 字符编码类型
 
字符编码就是把字符集中的字符编码为指定集合中某一对象，以便文本在计算机中存储和传递。常用字符编码类型如下。
 
ASCII：全称为美国国家信息交换标准码，是最早的标准编码，使用 7 个或8个二进制位进行编码，最多可以给 256 个字符分配数值，包括 26 个大写与小写字母、10 个数字、标点符号、控制字符以及其他符号。
GB2312：一个简体中文字符集，由 6763 个常用汉字和 682 个全角的非汉字字符组成。GB2312 编码使用两个字节表示一个汉字，所以理论上最多可以表示 256×256 =65536 个汉字。这种编码方式仅在中国通行。
GBK：该编码标准兼容 GB2312，并对其进行扩展，也采用双字节表示。其共收录汉字 21003个、符号 883 个，提供 1894 个造字码位，简、繁体字融于一库。
Unicode：是为了解决传统字符编码方案的局限而产生的，它为每种语言中的每个字符设定了统一并且唯一的二进制编码，以满足跨语言、跨平台进行文本转换、处理的要求。Unicode 通常用两个字节表示一个字符，原有的英文编码从单字节变成双字节，只需要把高字节全部填为 0 即可。
UTF-8：为了提高 Unicode 的编码效率，于是就出现了 UTF-8 编码。UTF-8 可以根据不同的符号自动选择编码的长短。比如英文字母可以只用1个字节就够了。
 
读者想要详细了解可以点击 编码百度百科 进行学习。
 
1.6 字节串
 
在 Python 中，有两种常用的字符串类型，分别为 str 和 bytes。其中， str 表示 Unicode 字符（ASCII或者其他），bytes 表示二进制数据（包括编码的文本）。这两种类型的字符串不能拼接在一起使用。通常情况下，str 在内存中以 Unicode 表示，一个字符对应若干个字节。但是如果在网络上传输，或者存到磁盘上，就需要把 str 转换为字节类型，即 bytes 类型。
 
字节串（bytes）也称字节序列，是不可变的序列，存储以字节为单位的数据。提示：bytes 类型是 Python3 新增的一种数据类型。字节串与字符串的比较：
 
字符串是由多个字符构成，以字符为单位进行操作。默认为 Unicode 字符，字符范围为 0~65535。字符串是字符序列，它是一种抽象的概念，不能直接存储在硬盘，用以显示供人阅读或操作。
字节串是由多个字节构成，以字节为单位进行操作。字节是整型值，取值范围 0~255。字节串是字节序列，因此可以直接存储在硬盘。
 
除了操作单元不同外，字节串与字符串的用法基本相同。它们之间的映射被称为解码或编码。定义字节串的方法如下：
 (1) 使用字面值
 以 b 操作符为前缀的 ASCII 字符串。语法格式如下：
 
b"ASCII 字符串"
b"转义序列"
 
字节是 0~255 之间的整数，而 ASCII 字符集范围为 0~255，因此它们之间可以直接映射。通过转义序列可以映射更大规模的字符集。
 
【示例1】下面示例使用字面值直接定义字符串。
 
 (2) 使用 bytes() 函数
 使用 bytes() 函数可以创建一个字节串对象，简明语法格式如下：
 
bytes()  # 生成一个空的字节串，等同于b''
bytes(整型可迭代对象)  # 用可迭代对象初始化一个字节串，元素必须为[0,255]中的整数
bytes(整数n)  # 生成n个值为零的字节串
bytes('字符串', encoding='编码类型')  # 使用字符串的转换编码生成一个字节串
 
【示例2】下面示例使用 bytes()函数创建多个字节串对象。
 
 字节串是不可变序列，使用 bytearray() 可以创建可变的字节序列，也称为字节数组（bytearray）。数组是每个元素类型完全相同的一组列表，因此可以使用操作列表的方法来操作数组。
 bytearray() 函数的简明语法格式如下：
 
bytearray()  # 生成一个空的可变字节串，等同于 bytearray(b'')
bytearray(整型可迭代对象)  # 用可迭代对象初始化一个可变字节串,元素必须为 [0, 255] 中的整数
bytearray(整数n)  # 生成 n 个值为零的可变字节串
bytearray(字符串, encoding='utf-8')  # 用字符串的转换编码生成一个可变字节串
 
1.7 字符编码和解码
 
在编码转换时，通常以 Unicode 作为中间码，即先将一种类型的字符串解码（decode）成 Unicode，再从 Unicode 编码（encode）成另一种类型的字符串。
 
(1) 使用 encode()
 使用字符串对象的 encode()方法可以根据参数 encoding 指定的编码格式将字符串编码为二进制数据的字节串，语法格式如下：
 
str.encode(encoding='UTF-8', errors='strict')
 
str 表示字符串对象：参数 encoding 表示要使用得编码类型，默认为 UTF-8 ，参数 errors 设置不同错误的处理方案，默认为 strict，表示遇到非法字符就会抛出异常，其他取值包括 ignore（忽略非法字符）、replace（用 ? 替换非法字符）、xmlcharrefreplace （使用 XML 的字符引用）、backslashreplace ，以及通过 codecs.register_error() 注册的任何值。
 【示例1】本例使用 encode()方法对 中文 字符串进行编码。
 
u = "中文"
str1 = u.encode("gb2312")
print(str1)
str2 = u.encode("gbk")
print(str2)
str3 = u.encode("utf-8")
print(str3)
 
(2) 使用 decode()
 与 encode() 方法操作相反，使用 decode()方法可以解码字符串，即根据参数 encoding 指定的编码格式将二进制数据的字节串解码为字符串。语法格式如下：
 
str.decode(encoding='UTF-8', errors='strict')
 
str 表示被 decode()解码的字节串，该方法的参数与 encode()方法的参数用法相同。最后返回解码后的字符串。
 【示例2】针对示例1，可以使用下面代码对编码字符串进行解码。
 
u = "中文"
str1 = u.encode("gb2312")
u1 = str1.decode("gb2312")
print(u1)  # 输出：中文
u2 = str1.decode("utf-8")  # 报错，因为str1是gb2312编码的
"""
报错如下：
UnicodeDecodeError: 'utf-8' codec can't decode byte 0xd6 in position 0: invalid continuation byte
"""
 
encode()和decode()方法的参数编码格式必须一致，否则将抛出上面代码所示的异常。
 
1.8 字符串的长度
 
计算字符串的长度可以使用 len()函数。例如：
 
s1 = "中国China"  # 定义字符串
print(len(s1))  # 输出为7
 
从上面结果可以看出，在默认情况下，len()函数计算字符串的长度是区分字母、数字和汉字的，每个汉字视为一个字符。
 
但是，在实际开发中，有时候需要获取字符串的字节长度。在 UTF-8 编码中，每个汉字占用3个字节，而在 GBK 或 GB2312中，每个汉字占用 2 个字符。例如：
 
s1 = "中国China"  # 定义字符串
print(len(s1.encode()))  # 输出为11
print(len(s1.encode("gbk")))  # 输出为9
 
从上面代码可以看出，两行输出代码的结果并不相同，第 2 行 print(len(s1.encode())) 使用默认的 UTF-8 编码，则字节长度为11，即每个汉字占用 3 个字节，而第 3 行print(len(s1.encode(“gbk”))) 使用 GBK 编码，则字节长度为 9，即每个汉字占用 2 个字节。
 
因此，由于不同字符占用字节数不同，当计算字符串的字节长度时，需要考虑使用编码进行计算。在 Python 中，字母、数字、特殊字符一般占用 1 个字节，汉字一般占用 2~4 个字节。
 
1.9 访问字符串
 
Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。Python 访问字符串中的字符有两种方式。
 
(1) 索引访问
 在 Python 中，字符串是一种有序序列，字符串里的每一个字符都有一个数字编号标识其在字符串中的位置，从左至右依次是：0、1、2、…、n-1，从右至左依次是 -1、-2、-3、…、-n（其中 n 是字符串的长度）。
 【示例1】通过索引来访问字符串中的某个字符。
 
 (2) 切片访问
 使用切片可以获取字符中某个范围的子字符串。语法格式如下：
 
str[start:end:step]
 
参数 start 为起点，end 为终点，step 为步长，返回字符串由从 start 到 end-1 的字符组成。
 【示例2】下面示例演示一些字符串切片操作。
 
 提示：当切片的第 3 个参数为负数时，表示逆序输出，即输出顺序为从右到左，而不是从左到右。
 
1.10 遍历字符串
 
在字符串过滤、筛选和编码时，经常需要遍历字符串。遍历字符串的方法有多种，具体说明如下。
 
1.10.1 使用 for 语句
 
【示例1】使用 for 语句循环遍历字符串，然后把每个字符都转换为大写形式并输出。
 
s1 = "python"  # 定义字符串
L = []  # 定义临时备用列表
for i in s1:  # 迭代字符串
    L.append(i.upper())  # 把每个字符转换为大写形式
print("".join(L))  # 输出大写字符串 PYTHON
 
1.10.2 使用 range()
 
使用 range() 函数，然后把字符串长度作为参数传入。
 【示例2】针对示例1，也可以按照以下方式遍历字符串。
 
s1 = "python"  # 定义字符串
L = []  # 定义临时备用列表
for i in range(len(s1)):  # 根据字符串长度遍历字符串下标数字，
    # 从0开始，直到字符串长度
    L.append(s1[i].upper())  # 把每个字符转换为大写形式
print("".join(L))  # 输出大写字符串 PYTHON
 
1.10.3 使用 enumerate()
 
enumerate()函数将一个可迭代的对象组合为一个索引序列。
 【示例3】针对示例1，使用 enumerate() 函数将字符串转换为索引序列，然后再迭代操作。
 
s1 = "python"  # 定义字符串
L = []  # 定义临时备用列表
for i, char in enumerate(s1):  # 把字符串转换为索引序列，然后再遍历
    L.append(char.upper())  # 把每个字符转换为大写形式
print("".join(L))  # 输出大写字符串 PYTHON
 
1.10.4 使用 iter()
 
使用 iter()函数可以生成迭代器。语法格式如下：
 
iter(object[, sentinel])
 
参数 object 表示支持迭代的集合对象，sentinel 是一个可选参数，如果传递了第 2 个参数，则参数 object 必须是一个可调用的对象（如函数），此时，iter() 函数将创建一个迭代器对象，每次调用这个迭代器对象的 __next__() 方法时，都会调用 object。
 【示例4】针对示例1，使用 iter() 函数将字符串生成迭代器，然后再遍历操作。
 
s1 = "python"  # 定义字符串
L = []  # 定义临时备用列表
for item in iter(s1):  # 把字符串生成迭代器，然后再遍历
    L.append(item.upper())  # 把每个字符转换为大写形式
print("".join(L))  # 输出大写字符串 PYTHON
 
1.10.5 逆序遍历
 
逆序遍历就是从右到左反向迭代对象。
 【示例5】本示例演示了 3 种逆序遍历字符串的方法。
 
s1 = "Python"
print("1. 通过下标逆序遍历:")
for i in s1[::-1]:
    print(i, end="")

print("\n2. 通过下标逆序遍历:")
for i in range(len(s1) - 1, -1, -1):
    print(s1[i], end="")

print("\n3. 通过reversed()逆序遍历:")
for i in reversed(s1):
    print(i, end="")
 
1.11 案例：判断两个字符串是否为变形词
 
假设给定两个字符串 str1、str2，判断这两个字符串中出现的字符是否一致，字符数量是否一致，当两个字符串的字符和数量一致时，则称这两个字符串为变形词。例如：
 
str1 = "python", str2="thpyon", 返回True
str2 = "python", str2="thonp", 返回False
 
示例代码如下：
 
# -*- coding: UTF-8 -*-
"""
@author:AmoXiang
@file:2.判断两个字符串是否为变形词.py
@time:2021/01/16
"""


def is_deformation(str1, str2):  # 定义变形词函数
    if str1 is None or str2 is None or len(str1) != len(str2):  # 当条件不符合时
        return False  # 返回False
    if len(str1) == 0 and len(str2) == 0:  # 当两个字符串长度都为0时
        return True  # 返回True
    dic = dict()  # 定义一个空字典
    for char in str1:  # 循环遍历字符串str1
        if char not in dic:  # 判断字符是否在字典中
            dic[char] = 1  # 不存在时，赋值为1
        else:
            dic[char] = dic[char] + 1  # 存在时字符的值累加
    for char in str2:  # 循环遍历字符串str2
        if char not in dic:  # 当str2的字符不在字典中时 返回False
            return False
        else:
            dic[char] = dic[char] - 1  # 当str2和str1的字符种类一致时，字典中的字符值自减1
            # 字符的值小于0，即字符串的字符数量不一致 返回False 否则返回True
            if dic[char] < 0:
                return False
    return True


str1 = "python"
str2 = "thpyon"
str3 = "hello"
str4 = "helo"
# 输出：python thpyon is deformation: True
print(str1, str2, "is deformation:", is_deformation(str1, str2))
# 输出：hello helo is deformation: False
print(str3, str4, "is deformation:", is_deformation(str3, str4))
 
1.12 案例：字节串的应用
 
1.12.1 计算md5
 
在计算 md5 值的过程中，有一步要使用 update 方法，而该方法只接受 bytes 类型数据。
 
import hashlib

string = "123456"

m = hashlib.md5()  # 创建md5对象
str_bytes = string.encode(encoding='utf-8')
print(type(str_bytes))  # <class 'bytes'>
m.update(str_bytes)  # update方法只接收bytes类型数据作为参数
str_md5 = m.hexdigest()  # 得到散列后的字符串

print('MD5散列前为 ：' + string)  # MD5散列前为 ：123456
print('MD5散列后为 ：' + str_md5)  # MD5散列后为 ：e10adc3949ba59abbe56e057f20f883e
 
1.12.2 二进制读写文件
 
使用二进制方式读写文件时，均要用到 bytes 类型，二进制写文件时，write()方法只接受 bytes 类型数据，因此需要先将字符串转成 bytes 类型数据；读取二进制文件时，read()方法返回的是 bytes 类型数据，使用 decode()方法可将 bytes 类型转成字符串。
 
f = open('data.txt', 'wb')
text = '二进制写文件'
text_bytes = text.encode('utf-8')
f.write(text_bytes)
f.close()

f = open('data.txt', 'rb')
data = f.read()
print(data, type(data))
str_data = data.decode('utf-8')
print(str_data)
f.close()
 
1.12.3 socket编程
 
使用 socket 时，不论是发送还是接收数据，都需要使用 bytes 类型数据。关于网络编程，请点击 Python网络编程 进行学习。
 
至此今天的案例就到此结束了，笔者在这里声明，笔者写文章只是为了学习交流，以及让更多学习 Python 基础的读者少走一些弯路，节省时间，并不用做其他用途，如有侵权，联系博主删除即可。感谢您阅读本篇博文，希望本文能成为您编程路上的领航者。祝您阅读愉快！
 
 
 
 
 
    好书不厌读百回，熟读课思子自知。而我想要成为全场最靓的仔，就必须坚持通过学习来获取更多知识，用知识改变命运，用博客见证成长，用行动证明我在努力。
     如果我的博客对你有帮助、如果你喜欢我的博客内容，请 点赞、评论、收藏 一键三连哦！听说点赞的人运气不会太差，每一天都会元气满满呦！如果实在要白嫖的话，那祝你开心每一天，欢迎常来我博客看看。
  编码不易，大家的支持就是我坚持下去的动力。点赞后不要忘了 关注 我哦！
 

 
c++字符串与c风格字符串
 
1. C风格的字符串
2. 字符串字面量
3.C++ std::string 类
3.1 C风格字符串的优势和劣势
3.2 使用string类
3.2.1 std::string 字面量
3.2.2 c++字符串的数值转换
(1)字符串转数值
(2)数值转字符串
     
3.2.3 c++常用字符串函数
3.2.4 原始字符串字面量
   
  
 


 你编写的每个应用程序都会使用某种类型的字符串。使用老式C语言时，没有太多的选择，只

 能使用普通的以null结尾的字符数组来表示字符串。遗憾的是，这种表示方式会导致很多问题，例 如会导致安全攻击的缓冲区溢出。C++ STL包含了一个安全易用的std::string类，这个类没有这些 缺点。
 
1. C风格的字符串
 
在C语言中，字符串表示为字符的数组。字符串中的最后一个字符是空字符(\0’)
 C++包含一些来自C语言的字符串操作函数，它们在< cstring >头文件中定义。
 
函数名称
说明
strlen()
返回字符串长度，不包含空字符‘\0’的一字节,字符串长度不等于字符个数
strcpy()
字符串拷贝
C和C++中的sizeof操作符可用于获得给定数据类型或变量的大小。例如，sizeof(char)返回1,
 因为char的大小是1字节。但是，在C风格的字符串中，sizeof()和strlen()是不同的。绝对不要通过 sizeof()获得字符串的大小。如果C风格的字符串存储为char[],则sizeof()返回字符串使用的实际内存，包括‘\0’字符。例如：
 
char text[]= "abcdef";
size_t s1= sizeof(text); // is 7
size_t s2 = strlen(text); // is 6
 
但是，如果C风格的字符串存储为char*, sizeof()就返回指针的大小！例如：
 
const char* text2 = "abcdef";
size_t s3 = sizeof(text2); // is platform-dependent
size_t s4 = strlen(text2); // is 6
 
在32位模式编译时，s3的值为4,而在64位编译时，s3的值为8,因为这返回的是指针const char*
 的大小。可在＜cstring＞头文件中找到操作字符串的C函数的完整列表。
 
在Microsoft Visual Studio中使用C风格的字符串函数时，编译器可能会给 出安全相关的警告甚或错误，说明这些函数已经被废弃了。使用其他C标准库函数可以避免这些警告，例如
 strcpy_s()和strcat_s()，这些函数是“安全C库” (ISO/IEC TR 24731)标准的一部分。然而，最好的解决方案是切换到C++的 string 类。
 
2. 字符串字面量
 
注意，C++程序中编写的字符串要用引号包围。例如，下面的代码输出字符串"hello",这段代码
 包含这个字符串本身，而不是一个包含这个字符串的变量:
 
cout <<"hello" << endl;
 
在上面的代码中，"hello”是一个字符串字面量（string literal),因为这个字符串以值的形式写出，
 而不是一个变量。与字符串字面量关联的真正内存在内存的只读部分中。通过这种方式，编译器可 以重用等价字符串字面量的引用，来优化内存的使用。也就是说，即使一个程序使用了 500次"hello"字符串字面量，编译器也只在内存中创建一个hello实例。这种技术称为字面量池
 (literal pooling)。
 字符串字面量可以赋值给变量，但因为字符串字面量位于内存的只读部分，且使用了字面量池,
 所以这样做会产生风险。C++标准正式指出：字符串字面量的类型为“n个const char的数组”，然而为了向后兼容较老的不支持const的代码，大部分编译器不会强制程序将字符串字面量赋值给 const char类型的变量。这些编译器允许将字符串赋值给不带有const的char，而且整个程序可以 正常运行，除非试图修改字符串。一般情况下，试图修改字符串的行为是没有定义的。它可能会导 致程序崩溃；可能使程序继续执行，看起来没有什么莫名其妙的副作用；可能不加通告地忽略修改 行为；可能修改行为是有效的，这完全取决于编译器。例如，下面的代码展示了未定义的行为：
 
char* ptr = "hello"; // Assign the string literal to a variable.
ptr[1] = 'a ';       // Undefined behavior!
 
一种更安全的编码方法是在引用字符串常量时，使用指向 const 字符的指针。下面的代码包含
 同样的 bug,但由于这段代码将字符串字面量赋值给 const char* 所以编译器会捕捉到任何写入只 读内存的企图。
 
const char* ptr = "hello";  // Assign the string literal to a variable.
ptr[ 1] = 'a';              // Error! Attempts to write to read-only memory
 
还可以将字符串字面量用作字符数组（char®的初始值。这种情况下，编译器会创建一个足以放 下这个字符串的数组，然后将字符串复制到这个数组。因此，编译器不会将字面量放在只读的内存中，也不会进行字面量的池操作。
 
char arr [] = "hello"; // Compiler takes care of creating appropriate sized 
					   // character array arr.
arr[ 1] = 'a ';        // The contents can be modified.
 
3.C++ std::string 类
 
C++提供了一个得到极大改善的字符串概念，并作为标准库的一部分提供了这个字符串的实现。 在C++中，std::string是一个类（实际上是basic string模板类的一个实例），这个类支持
 ＜cstring >中提 供的许多功能，还能自动管理内存分配。string类在std名称空间的< string >头文件中定义。
 
3.1 C风格字符串的优势和劣势
 
优势
劣势
很简单，底层使用了基本的字符类型和数组结构
为了模拟一等字符串数据类型，需要付出很多努力
量级轻，如果使用得当，只会占用所需的内存
使用难度大，而且很容易产生难以找到的内存bug
很低级，因此可以按操作原始内存的方式轻松操作和复制字符串
没有利用C++的面向对象特性
能够很好地被C语言程序员理解
要求程序员了解底层的表示方式
3.2 使用string类
 
尽管string是一个类，但是几乎总是可以把string当做内建类型使用。事实上，把string想象为
 简单类型更容易发挥string的作用。通过运算符重载的神奇作用，C++的string使用起来比C字符串容易得多。
 
3.2.1 std::string 字面量
 
源代码中的字符串字面量通常解释为const char*。使用用户定义的标准字面量”s”可以把字符串
 字面量解释为std::string。例如:
 
auto stringl = "Hello World"; // stringl will be a const char*
auto string2 = "Hello World"s; // string2 will be an std::string
 
3.2.2 c++字符串的数值转换
 
数值转字符串
字符串转数值
to_string(int val)
int stoi(const string& str, size_t *idx=0， int base=10)
to_string(unsigned val)
long stol(const string& str, size_t *idx=0, int base=10)
to_string(long val)
unsigned long stoul(const string& str, size_t *idx=0, int base=10)
(1)字符串转数值
 
int stoi(const string& str, size_t *idx=0， int base=10)
 
stoi将n进制字符串转为十进制，第二个参数是字符串起始位置，第三个参数表示n进制
 
也可以直接用重载的 int stoi(const string& str),默认字符串为十进制，起始位置为0,制
 
#include<string>
#include <iostream>
#include <exception>
using namespace std;
int main()
{
	int i=0;
	try
	{
		i = stoi("FEEF", 0, 16);
		//int i = stoi("我的"); 输入非法时，可以捕获异常"invalid stoi argument"
	}
	catch (exception e)
	{
		cout << e.what() << endl;
	}
	system("pause");
	return 0;
}
 
输出结果：
 
 
(2)数值转字符串
 
转十进制可以用to_string,但是低版本的编译器可能不支持
 
转多进制可以用_itoa_s，但似乎没有安全机制，导致无法捕获异常
 
	char cstr[20];
	_itoa_s(100,cstr,2);
	cout << cstr << endl;
 
转多进制还可以用 stringstream
 
#include<string>
#include <iostream>
#include <sstream>
#include <bitset>
using namespace std;
int main()
{

   int num = 1234;
   stringstream stream;

   //转二进制
   stream << bitset<16>(num);
   cout << stream.str() <<endl;
   stream.str(""); //清空缓存，如果注释掉，那么会输出所有的历史结果
   //转8进制
   stream << oct << num;
   cout << stream.str() << endl;
   stream.str("");
   //转十六进制
   stream << hex << num;
   cout << stream.str() << endl;
   stream.str("");
   system("pause");
   return 0;
}
 
结果：
 
 
 
 
如果需要把格式化后的字符串通过>>输出到字符串, 必须每次都调用clear()方法
 
 
3.2.3 c++常用字符串函数
 
函数
功能
append
将字符添加到字符串的末尾
at
返回字符串中的指定位置处的元素的引用
c_str
将字符串的内容转换为 C 样式空终止字符串
data
转换为字符数组的字符串的内容
empty
测试是否该字符串包含的字符
erase
从指定位置字符串中移除元素或某个范围的元素
find
与指定的字符序列匹配的子字符串的第一个匹配项的向前搜索字符串
find_first_not_of
搜索与指定任何的字符串元素相匹配的第一个字符的字符串
find_first_of
搜索与指定任何的字符串元素相匹配的第一个字符的字符串
rfind
向后方向中的首次出现的与指定的字符序列匹配的子字符串搜索字符串
pop_back
清除该字符串的最后一个元素
push_back
该字符串的末尾添加一个元素
insert
将某个元素的数目或某个范围的元素插入到指定位置的字符串
length
返回字符串中的元素的当前数目
replace
替换指定的字符或从其他区域或字符串或 C 字符串复制的字符在字符串中位于指定位置处的元素
substr
从指定位置的字符串开头的复制的子字符串的最大字符数
3.2.4 原始字符串字面量
 
原始字符串字面量(raw string literal)是可以横跨多行代码的字符串字面量，不需要转义嵌入的双引号，像\t和\1!这种转义序列不按照转义序列的方式处理，而是按照普通文本的方式处理。如果像下面这样编写普通的字符串字面量，那么会收到一个编译器错误，因为 字符串包含了未转义的引号：
 
string str = "Hello "World"!// Error!
 
对于普通的字符串，必须转义双引号，如下所示：
 
string str = "Hello \"World\"！"；
 
对于原始字符串字面量，就不需要转义引号了。
 原始字符串字面量的写法:
 
string str = R"(Hello "World"!)";
 
原始字符串字面量可以跨越多行代码。例如，如果像下面这样编写普通的字符串字面量，那么会收到一个编译器错误，因为普通的字符串字面量不能跨越多行：
 
string str = "Line 1
Line 2 with \t"; // Error!
 
可使用如下原始字符串字面量来替代：
 
string str = R"(Line 1
Line 2 with \t)";
 
这也说明，使用原始字符串字面量时，\t转义字符没有替换为实际的制表符字符，而是按照字面形式保存。将str写入控制台得到的输出如下所示：
 Line 1
 Line 2 with \t
 因为原始字符串字面量以)“结尾，所以使用这个语法时，不能在字符串中嵌入)”。例如，下面的 字符串是不合法的，因为在这个字符串中间包含了一个)”：
 
string str = R"(The characters )"n are embedded in this string)" // Error!
 
如果需要嵌入)",则需要使用扩展的原始字符串字面量语法，如下所示：
 
R"d-char-sequence(r-char-sequence)d-char-sequence"
 
r-char-sequence是实际的原始字符串。d-char-sequence是可选的分隔符序列，原始字符串首尾的分隔符序列应该一致。分隔符序列最多能有16个字符。应选择未出现在原始字符串字面量中的序列作为分隔符序列。上面的例子可以改用唯一的分隔符序列：
 
string str = R"-(The characters )" are embedded in this string)-";
 
在操作数据库查询字符串和正则表达式等字符串时，原始字符串字面量可以令程序的编写更加方便。

 
字符串是所有编程语言中都经常需要处理的问题之一，字符串指的是什么呢?下面是学习啦小编整理字符串变量的内容，欢迎阅读。
 
字符串的简介
 
字符串主要用于编程，概念说明、函数解释、用法详述见正文，这里补充一点：字符串在存储上类似字符数组，所以它每一位的单个元素都是可以提取的，如s=“abcdefghij”，则s[0]=“a”，s[9]="j"，而字符串的零位正是它的长度，如s[0]=10(※上述功能Ansistring没有。)，这可以给我们提供很多方便，如高精度运算时每一位都可以转化为数字存入数组。
 
什么是变量
 
变量来源于数学，是计算机语言中能储存计算结果或能表示值抽象概念。变量可以通过变量名访问。在指令式语言中，变量通常是可变的;但在纯函数式语言(如Haskell)中，变量可能是不可变(immutable)的。在一些语言中，变量可能被明确为是能表示可变状态、具有存储空间的抽象(如在Java和Visual Basic中);但另外一些语言可能使用其它概念(如C的对象)来指称这种抽象，而不严格地定义“变量”的准确外延。
 
变量介绍
 
由于变量让你能够把程序中准备使用的每一段数据都赋给一个简短、易于记忆的名字，因此它们十分有用。变量可以保存程序运行时用户输入的数据(如使用InputBox函数在屏幕上显示一个对话框，然后把用户键入的文本保存到变量中)、特定运算的结果以及要在窗体上显示的一段数据等。简而言之，变量是用于跟踪几乎所有类型信息的简单工具。
 
变量声明后没有赋值的话 编译器会自动提示并赋予默认值
 
变量是一种使用方便的占位符，用于引用计算机内存地址，该地址可以存储Script运行时可更改的程序信息。例如，可以创建一个名为Click Count的变量来存储用户单击Web页面上某个对象的次数。使用变量并不需要了解变量在计算机内存中的地址，只要通过变量名引用变量就可以查看或更改变量的值。在VB Script中只有一个基本数据类型，即Variant，因此所有变量的数据类型都是Variant。
 
变量简介
 
字符串或串(String)是由数字、字母、下划线组成的一串字符。一般记为 s=“a1a2···an”(n>=0)。它是编程语言中表示文本的数据类型。在程序设计中，字符串(string)为符号或数值的一个连续序列，如符号串(一串字符)或二进制数字串(一串二进制数字)。
 
通常以串的整体作为操作对象，如：在串中查找某个子串、求取一个子串、在串的某个位置上插入一个子串以及删除一个子串等。两个字符串相等的充要条件是：长度相等，并且各个对应位置上的字符都相等。设p、q是两个串，求q在p中首次出现的位置的运算叫做模式匹配。串的两种最基本的存储方式是顺序存储方式和链接存储方式。
 
c语言字符型常量与变量
 
字符常量：一个字符常量代表ASCII字符集中的一个字符，在程序中用单引号把一个字符括起来作为字符常量。例如’A’ ‘b’等都是合法的字符常量。
 
注意： 1、C语言区分大小写：单引号中的大小写字母代表不同的字符常量，例如’A’与’a’是不同的字符常量;2、单引号中的空格符也是一个字符常量3、字符常量只能包括一个字符，所以’ab’是非法的;4、字符常量只能用单引号括起来，不能用双引号。比如”a”不是一个字符常量而是一个字符串。
 
转义字符常量：转义字符又称反斜线字符，这些字符常量总是以一个反斜线开头后跟一个特定的字符，用来代表某一个特定的ASCII字符，这些字符常量也必须扩在一对单引号内。
 
注意：1:转义字符常量只代表一个字符，例如’\n’、’\101’; 2:反斜线后的八进制数可以不用0开头;
 
3:反斜线后的十六进制数只可由小写字母x开头，不能以大写字母X或0X开头。
 
字符串常量：字符串常量是由双引号括起来的一串字符。在C语言中，字符串是用字符型一维数组来存放的。系统在每个字符串的末尾自动加上一个字符’\0’作为字符串结束标志，’\0’在这里占用存储空间但不计入字符串的实际长度。两个连续的双引号(” ”)也是一个字符串常量：称为空串，占一个字节，该字节用来存放’\0’。
 
在C语言中，字符常量可以参与任何整数运算以及关系运算。
 
字符变量：C语言中，字符变量是用关键字char来定义的，例如：char a=’b’,字符变量在内存中占一个字节，当把一个字符放入字符变量中时，字符变量的值就是该字符的ASCII码值，所以字符变量可以作为整型变量来处理，可以参与任何整形变量的运算。
 
看过“什么是字符串变量”的人还看了：

 
r语言字符串转换为字符串
 
 弦乐 (Strings)
 
 
The strings are defined as a group of characters. In the R language, the strings are commonly written in between either single or double-quotes. 
 
 
 字符串定义为一组字符。 在R语言中，字符串通常写在单引号或双引号之间。 
 
 
The programmer who works with R needs to get acquainted with the rules while declaring and working with the concept of the strings. Therefore the below is the short description of the rules that are needed to be followed while using strings in the R language. One must make sure that strings are surrounded either with single quotes or double quotes on both sides. The string which starts with the single quotes can have double quotes in the middle of them and vice versa.
 
 
 使用R的程序员在声明和使用字符串的概念时需要熟悉规则。 因此，以下是使用R语言的字符串时需要遵循的规则的简短描述。 必须确保字符串的两端都用单引号或双引号引起来。 以单引号开头的字符串可以在中间加上双引号，反之亦然。 
 
 
Examples for the valid strings:
 
 
 有效字符串的示例： 
 
 
str1 <- 'String that starts with single quote and ends with single quote too'
print(str1)

str2 <- "String that starts with double quotes and ends with double quotes too"
print(str2)

str3 <- "String that has single quote marks ' inside double quotes"
print(str3)

str4 <- 'String that has Double quotes marks " inside single quote'
print(str4)


 
Output
 
 
 输出量 
 
 
[1] "String that starts with single quote and ends with single quote too"
[1] "String that starts with double quotes and ends with double quotes too"
[1] "String that has single quote marks ' inside double quotes"
[1] "String that has Double quotes marks \" inside single quote"


 
Now as we all know that when we have one part for anything then we always have the counterpart for the same thing and failing to do this will be treated as an invalid string. The following examples help the programmers in acknowledging the difference between the valid and invalid string syntax in the R language.
 
 
 现在我们都知道，当我们为任何事物分配一部分时，我们总是拥有同一事物的对应部分，如果不这样做，将被视为无效字符串。 下面的示例帮助程序员确认R语言中有效和无效字符串语法之间的区别。 
 
 
# The str1's string will not end until the second single quote is found...

str1 <- 'String that starts with single quote and ends with double quotes"
print(str1)

str2 <- 'string that has a Single quote marks ' inside single quote'
print(str2)

str3 <- "Double quotes marks " inside double quotes"
print(str3)


 
Output
 
 
 输出量 
 
 
Error: unexpected symbol in:
"
str2 
Explanation:
All the initializations were done in the wrong way that does not match the quotes properly. This Throws error and code does not execute properly.
String Manipulation
Concatenating strings using paste() function
In the R language, the programmer can combine two strings using the paste() function. The paste() function will support any number of arguments into it for the combining purpose.
Syntax:
Parameters:

 
Error: unexpected symbol in:
"
str2 
 Explanation: 
All the initializations were done in the wrong way that does not match the quotes properly. This Throws error and code does not execute properly.
String Manipulation
Concatenating strings using paste() function
In the R language, the programmer can combine two strings using the paste() function. The paste() function will support any number of arguments into it for the combining purpose.
 Syntax: 
 Parameters: 


 
... : This exemplifies any emblems of arguments that can be integrated using the paste() function
 ... ：这示例了可以使用paste()函数集成的参数的任何符号 
sep : the separator between the arguments considered. However, the usage of a separate is always optional and it mainly depends on the user who works with this particular syntax.
 sep ：所考虑参数之间的分隔符。 但是，分隔符的使用始终是可选的，并且主要取决于使用此特定语法的用户。 
collapse : the keyword used for the purpose of elimination of the spaces that prevail between the considered number of strings. One should clearly note that space whatever is mentioned here is between the strings but not amid the two words of a string. The usage of collapse is also optional.
 塌陷 ：用于消除考虑的字符串数之间占优势的空格的关键字。 一个人应该清楚地注意到，这里提到的任何空间都在字符串之间，但不在字符串的两个词之间。 折叠的用法也是可选的。 
 
Given below is the example code for the demonstration of the above topic:
 
 
 下面给出的是用于演示上述主题的示例代码： 
 
 
part1 <- "Welcome"
part2 <- 'to'
part3 <- "includehelp.com"

str1 <- paste(part1, part2, part3)
print(str1)

str1 <- paste(part1, part2, part3, sep = "", collapse = "")
print(str1)

str1 <- paste(part1, part2, part3, sep = "-")
print(str1)


 
Output
 
 
 输出量 
 
 
[1] "Welcome to includehelp.com"
[1] "Welcometoincludehelp.com"
[1] "Welcome-to-includehelp.com"


 
 使用format()函数格式化数字和字符串 (Formatting numbers and strings using format() function)
 
 
In the R, the numbers and strings can be formatted into the specific style with the help of format() function.
 
 
 在R中，可以借助format()函数将数字和字符串格式化为特定样式。 
 
 
Syntax:
 
 
 句法： 
 
 
    format(x, digits, nsmall, scientific, width, justify = c("left", "right", "centre", "none"))


 
Parameters:
 
 
 参数： 
 
 
x is the vector input which depends on the user input.
 x是矢量输入，取决于用户输入。 
digits is the total number of the digits that will be displayed.
 digits是将显示的数字总数。 
nsmall, this is the parameter which is nothing but the minimum number of digits after the decimal point to the right side.
 nsmall ，这是参数，不过是右边小数点后的最小位数。 
scientific is generally set to TRUE with the main intention to display the scientific notations.
 通常将科学型设置为TRUE，主要目的是显示科学符号。 
width demonstrates the minimum number of characters or numbers to be displayed by padding the blanks in the initial stages.
 width表示通过在初始阶段填充空格来显示的最小字符数或数字。 
justify is the display option that displays the string on left, center or in the right positions of the screen. 
 justify是一种显示选项，可在屏幕的左，中或右位置显示字符串。 
 
Example 1:
 
 
 范例1： 
 
 
# We are formatting the total number of digits to be 
# considered as less than the total number of digits 
# in the value...

value <- 2345.12541132
result <- format(value, digits = 8)
print(result)


 
Output
 
 
 输出量 
 
 
[1] "2345.1254"


 
Example 2:
 
 
 范例2： 
 
 
# We will format the number to its scientific notation...

number <- 87106.912310
result <- format(number, scientific = TRUE)
print(result)


 
Output
 
 
 输出量 
 
 
[1] "8.710691e+04"


 
Example 3:
 
 
 范例3： 
 
 
# Using nsmall we will set the minimum number 
# of digits after the decimal point.

number <- 98.831
result <- format(number, nsmall = 7)
print(result)


 
Output
 
 
 输出量 
 
 
[1] "98.8310000"


 
Example 4:
 
 
 范例4： 
 
 
# Width added some blank spaces to the number...

number <- 89.1223
result <- format(number, width = 12)
print(result)


 
Output
 
 
 输出量 
 
 
[1] "     89.1223"


 
Example 5:
 
 
 范例5： 
 
 
# The justify along with width is used to add the black spaces 
# in the given direction = left(end of string) and 
# center(middle of the string)...

str = "includeHelp.com"

formatedString <- format(str , width = 34, justify = "l")
print(formatedString )
formatedString <- format(str , width = 34, justify = "c")
print(formatedString)


 
Output
 
 
 输出量 
 
 
[1] "includeHelp.com                   "
[1] "         includeHelp.com          "


 
 在toupper()和tolower()的帮助下更改大小写 (Changing the case with the help of the toupper() and the tolower())
 
 
The toupper() and tolower() functions generally contribute to the program when there is a grave need of changing the case of the considered string. In that case, the programmers make use of these basic functions to make the code more comfortable for a user who uses it.
 
 
 当迫切需要更改所考虑字符串的大小写时， toupper()和tolower()函数通常有助于程序。 在那种情况下，程序员利用这些基本功能使代码对于使用它的用户来说更加舒适。 
 
 
Syntax:
 
 
 句法： 
 
 
    toupper(x)
    tolower(x)


 
Parameters:
 
 
 参数： 
 
 
x is considered vector input.
 x被视为向量输入。 
 
Example:
 
 
 例： 
 
 
str <- "Welcome to Includehelp.com"

# We will convert the string to uppercase 
# using toupper() method...
upperCase <- toupper(str)
print(upperCase)

# We will convert the string to lowercase 
# using tolower() method...
lowerCase <- tolower(str)
print(lowerCase)


 
Output
 
 
 输出量 
 
 
[1] "WELCOME TO INCLUDEHELP.COM"
[1] "welcome to includehelp.com"


 
 使用nchar()函数计算字符串中的字符数 (Counting the number of characters in a string using the nchar() function)
 
 
nchar() function calculates the total number of characters encompassing spaces in the string considered for the purpose of counting the strings.
 
 
 nchar()函数计算为计算字符串而考虑的字符串中包含空格的字符总数。 
 
 
Syntax:
 
 
 句法： 
 
 
    nchar(x)


 
x: the parameter which is used in the above syntax is nothing but a vector output.
 
 
 x ：以上语法中使用的参数不过是向量输出。 
 
 
Example:
 
 
 例： 
 
 
# We will count the number of characters using nchar...

str = "Welcome to Includehelp.com"
print(str)
charCount <- nchar(str)
print(charCount)


 
Output
 
 
 输出量 
 
 
[1] "Welcome to Includehelp.com"
[1] 26


 
 使用substring()属性从考虑的字符串中提取部分 (Extracting the parts from the considered string using the substring() attribute)
 
 
The main purpose of making use of substring() function in the R is that it extracts a particular part of the string.
 
 
 在R中使用substring()函数的主要目的是提取字符串的特定部分。 
 
 
Syntax:
 
 
 句法： 
 
 
    Substring(x, first, last);


 
Parameters:
 
 
 参数： 
 
 
x is nothing but the string considered itself.
 x只是字符串本身。 
first is the parameter that points to the position of the first character that needs to be extracted.
 first是指向需要提取的第一个字符的位置的参数。 
last is the position that corresponds to the last character that is to be extracted from the considered string.
 last是与要从所考虑的字符串中提取的最后一个字符相对应的位置。 
 
Example:
 
 
 例： 
 
 
# We will extract substring.

string <- "Learn programming at includehelp.com"
result <- substring(string, 22, 36)
print(result)


 
Output
 
 
 输出量 
 
 
[1] "includehelp.com"



 

  
翻译自: https://www.includehelp.com/r/strings.aspx
 
 
r语言字符串转换为字符串