精华内容
下载资源
问答
  • 详解 Python 字符串(一):字符串基础

    千次阅读 多人点赞 2021-01-16 20:59:45
    文章目录1.2. 在 Python 中,字符串就是一串字符的...Python 通过 str 类型提供大量方法来操作字符串,如字符串的替换、删除、截取、复制、连接、比较、查找、分隔等。本文将详细介绍操作字符串的一般方法。 1. 2. ...

    在 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(下一行)忽略反斜杠和换行
    \\反斜杠(\)
    \’单引号(’)
    \"双引号(")
    \aASCII 响铃(BEL)
    \bASCII 退格(BS)
    \fASCII 换页(FF)
    \nASCII 换行(LF)
    \rASCII 回车(CR)
    \tASCII 水平制表(TAB)
    \vASCII 垂直制表(VT)
    \ooo八进制的 ooo 的字符。与标准C中一样,最多可接收3个八进制数字
    \xhh十六进制值 hh 的字符。与标准C不同,只需要2个十六进制数字
    \N{name}Unicode 数据库中名称为 name 的字符。【提示】:只在字符串字面值中识别的转义序列
    \uxxxx16 位的十六进制值为 xxxx 的字符。4个十六进制数字是必需的。【提示】:只在字符串字面值中识别的转义序列
    \Uxxxxxxxx32 位的十六进制值为 xxxxxxxx 的字符,任何 Unicode 字符可以这种方式被编码。8个十六进制数字是必需的。【提示】:只在字符串字面值中识别的转义序列

    【示例1】本示例分别使用转义字符、八进制数字、十六进制数字表示换行符。
    在这里插入图片描述
    【示例2】如果八进制数字不满3位,则首位自动补充0。如果八进制数字超出3位,十六进制数字超出2位,超出数字将视为普通字符显示。
    在这里插入图片描述

    1.3 原始字符串

    在 Python3 中,字符串常见有 3 种形式:普通字符串(str)、Unicode 字符串(unicode)和原始字符串(也称为原义字符串)。

    原始字符串的出现目的:解决字符串中显示特殊字符。在原始字符串里,所有的字符都直接按照字面的意思来使用,不支持转义序列和非打印的字符。

    原始字符串的这个特性让一些工作变得非常方便。例如,在使用正则表达式的过程中,正则表达式字符串,通常是由代表字符、分组、匹配信息、变量名和字符类等特殊符号组成。当使用特殊字符时,\字符 格式的特殊字符容易被歧义,这时使用原始字符串就会派上用场。可以使用 rR 来定义原始字符串,这个操作符必须紧靠在第一个引号前面。语法格式如下:

    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 字符编码类型

    字符编码就是把字符集中的字符编码为指定集合中某一对象,以便文本在计算机中存储和传递。常用字符编码类型如下。

    1. ASCII:全称为美国国家信息交换标准码,是最早的标准编码,使用 7 个或8个二进制位进行编码,最多可以给 256 个字符分配数值,包括 26 个大写与小写字母、10 个数字、标点符号、控制字符以及其他符号。
    2. GB2312:一个简体中文字符集,由 6763 个常用汉字和 682 个全角的非汉字字符组成。GB2312 编码使用两个字节表示一个汉字,所以理论上最多可以表示 256×256 =65536 个汉字。这种编码方式仅在中国通行。
    3. GBK:该编码标准兼容 GB2312,并对其进行扩展,也采用双字节表示。其共收录汉字 21003个、符号 883 个,提供 1894 个造字码位,简、繁体字融于一库。
    4. Unicode:是为了解决传统字符编码方案的局限而产生的,它为每种语言中的每个字符设定了统一并且唯一的二进制编码,以满足跨语言、跨平台进行文本转换、处理的要求。Unicode 通常用两个字节表示一个字符,原有的英文编码从单字节变成双字节,只需要把高字节全部填为 0 即可。
    5. UTF-8:为了提高 Unicode 的编码效率,于是就出现了 UTF-8 编码。UTF-8 可以根据不同的符号自动选择编码的长短。比如英文字母可以只用1个字节就够了。

    读者想要详细了解可以点击 编码百度百科 进行学习。

    1.6 字节串

    在 Python 中,有两种常用的字符串类型,分别为 str 和 bytes。其中, str 表示 Unicode 字符(ASCII或者其他),bytes 表示二进制数据(包括编码的文本)。这两种类型的字符串不能拼接在一起使用。通常情况下,str 在内存中以 Unicode 表示,一个字符对应若干个字节。但是如果在网络上传输,或者存到磁盘上,就需要把 str 转换为字节类型,即 bytes 类型。

    字节串(bytes)也称字节序列,是不可变的序列,存储以字节为单位的数据。提示:bytes 类型是 Python3 新增的一种数据类型。字节串与字符串的比较:

    1. 字符串是由多个字符构成,以字符为单位进行操作。默认为 Unicode 字符,字符范围为 0~65535。字符串是字符序列,它是一种抽象的概念,不能直接存储在硬盘,用以显示供人阅读或操作。
    2. 字节串是由多个字节构成,以字节为单位进行操作。字节是整型值,取值范围 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 基础的读者少走一些弯路,节省时间,并不用做其他用途,如有侵权,联系博主删除即可。感谢您阅读本篇博文,希望本文能成为您编程路上的领航者。祝您阅读愉快!


    在这里插入图片描述

        好书不厌读百回,熟读课思子自知。而我想要成为全场最靓的仔,就必须坚持通过学习来获取更多知识,用知识改变命运,用博客见证成长,用行动证明我在努力。
        如果我的博客对你有帮助、如果你喜欢我的博客内容,请 点赞评论收藏 一键三连哦!听说点赞的人运气不会太差,每一天都会元气满满呦!如果实在要白嫖的话,那祝你开心每一天,欢迎常来我博客看看。
     编码不易,大家的支持就是我坚持下去的动力。点赞后不要忘了 关注 我哦!

    展开全文
  • python字符串追加字符Python string object is immutable. So every time we use + operator to concatenate two strings, a new string is created. Python字符串对象是不可变的。 因此,每次我们使用+运算符连接两...

    python字符串追加字符

    Python string object is immutable. So every time we use + operator to concatenate two strings, a new string is created.

    Python字符串对象是不可变的。 因此,每次我们使用+运算符连接两个字符串时,都会创建一个新字符串。

    If we have to append many strings, using + operator will unnecessarily create many temporary strings before we have the final result.

    如果我们必须追加许多字符串,则使用+运算符将不必要地创建许多临时字符串,直到获得最终结果。

    Python字符串追加 (Python String Append)

    Let’s look at a function to concatenate a string ‘n’ times.

    让我们看一下一个将字符串连接n次的函数。

    def str_append(s, n):
        output = ''
        i = 0
        while i < n:
            output += s
            i = i + 1
        return output
    timeit module to test the performance. If you simply want to concatenate a string 'n' times, you can do it easily using timeit模块测试性能。 如果只想将字符串连接'n'次,则可以使用 s = 'Hi' * 10. s = 'Hi' * 10轻松实现。

    Another way to perform string append operation is by creating a list and appending strings to the list. Then use string join() function to merge them together to get the result string.

    执行字符串追加操作的另一种方法是通过创建列表并将字符串追加到列表中。 然后使用字符串join()函数将它们合并在一起以获得结果字符串。

    def str_append_list_join(s, n):
        l1 = []
        i = 0
        while i < n:
            l1.append(s)
            i += 1
        return ''.join(l1)

    Let's test these methods to make sure they are working as expected.

    让我们测试这些方法,以确保它们按预期工作。

    if __name__ == "__main__":
        print('Append using + operator:', str_append('Hi', 10))
        print('Append using list and join():', str_append_list_join('Hi', 10))
        # use below for this case, above methods are created so that we can
        # check performance using timeit module
        print('Append using * operator:', 'Hi' * 10)

    Output:

    输出:

    Append using + operator: HiHiHiHiHiHiHiHiHiHi
    Append using list and join(): HiHiHiHiHiHiHiHiHiHi
    Append using * operator: HiHiHiHiHiHiHiHiHiHi

    在Python中附加字符串的最佳方法 (Best way to append strings in Python)

    I have both the methods defined in string_append.py file. Let's use timeit module to check their performance.

    我在string_append.py文件中定义了两种方法。 让我们使用timeit模块检查其性能。

    $ python3.7 -m timeit --number 1000 --unit usec 'import string_append' 'string_append.str_append("Hello", 1000)' 
    1000 loops, best of 5: 174 usec per loop
    $ python3.7 -m timeit --number 1000 --unit usec 'import string_append' 'string_append.str_append_list_join("Hello", 1000)'
    1000 loops, best of 5: 140 usec per loop
    
    $ python3.7 -m timeit --number 1000 --unit usec 'import string_append' 'string_append.str_append("Hi", 1000)' 
    1000 loops, best of 5: 165 usec per loop
    $ python3.7 -m timeit --number 1000 --unit usec 'import string_append' 'string_append.str_append_list_join("Hi", 1000)'
    1000 loops, best of 5: 139 usec per loop

    摘要 (Summary)

    If there are few strings, then you can use any method to append them. From a readability perspective, using + operator seems better for few strings. However, if you have to append a lot of string, then you should use the list and join() function.

    如果字符串很少,则可以使用任何方法附加它们。 从可读性的角度来看,对于少数几个字符串,使用+运算符似乎更好。 但是,如果必须附加很多字符串,则应使用list和join()函数。

    GitHub Repository. GitHub存储库中检出完整的python脚本和更多Python示例。

    翻译自: https://www.journaldev.com/23689/python-string-append

    python字符串追加字符

    展开全文
  • python字符串去掉空行 如何在python中删除字符串中的空格 (How to remove whitespaces in a string in python) str.lstrip() str.lstrip() str.rstrip() str.rstrip() str.strip() str.strip() str.replace() str....

    python字符串去掉空行

    如何在python中删除字符串中的空格 (How to remove whitespaces in a string in python)

    • str.lstrip()

      str.lstrip()
    • str.rstrip()

      str.rstrip()
    • str.strip()

      str.strip()
    • str.replace()

      str.replace()
    • str.split()

      str.split()
    • re.sub()

      re.sub()

    By using the above-mentioned methods, let's see how to remove whitespaces in a string.

    通过使用上述方法,让我们看看如何删除字符串中的空格。

    Topic covered in this story

    这个故事涉及的主题

    Image for post
    Photo by Author
    作者照片

    1.删​​除字符串中的前导空格 (1. Removing leading whitespaces in a string)

    Image for post

    1. str.lstrip()Return a copy of the string with leading whitespaces removed.

    1. str.lstrip()返回删除前导空格的字符串副本。

    s="   Hello   Python  "print (s.lstrip())#Output:Hello   Python

    2. re.sub()Using re.sub(), we can remove leading whitespaces.

    2. re.sub()使用re.sub(),我们可以删除前导空格。

    Syntax:

    句法:

    re.sub(pattern, repl, string, count=0, flags=0)

    re. sub ( pattern , repl , string , count=0 , flags=0 )

    pattern - specify the pattern to be replacedrepl - replacing the leftmost non-overlapping occurrences of pattern in string by the replacement repl. count - The optional argument count is the maximum number of pattern occurrences to be replaced. If omitted or zero, all occurrences will be replaced.

    图案 -指定图案被替换REPL -由替换REPL替换模式的最左边的非重叠出现在字符串count-可选参数count是要替换的最大模式出现次数。 如果省略或为零,将替换所有出现的事件。

    pattern= r”^\s+”

    pattern= r”^\s+”

    r Python’s raw string notation for regular expression\s matches whitespace characters.+ It will match one or more repetitions of whitespace character.^(Caret.) Matches the start of the string

    r Python的正则表达式\s的原始字符串表示法与空格字符匹配。 +它将匹配一个或多个空白字符的重复。 ^ (Caret。)匹配字符串的开头

    pattern mentioned is whitespace at the beginning of the string.s1=re.sub(pattern,””,s)

    提到的模式是字符串开头的空格。 s1=re.sub(pattern, ”” ,s)

    re.sub() will replace the pattern (whitespaces at the beginning of string) to empty string.

    re.sub()会将模式(字符串开头的空格)替换为空字符串。

    s="   Hello   Python  "
    import
    re
    pattern= r"^\s+"s1=re.sub(pattern,"",s)
    print (s1)#Output:Hello Python

    2.删除字符串中的尾随空格 (2. Removing trailing whitespace in a string)

    Image for post
    Photo by Author
    作者照片

    str.rstrip()

    str.rstrip()

    Return a copy of the string with trailing whitespaces removed.

    返回已删除尾随空格的字符串副本。

    s="   Hello   Python  "print (s.rstrip())#Output:   Hello   Python

    re.sub()Using re.sub(), we can remove trailing whitespaces.

    re.sub()使用re.sub(),我们可以删除结尾的空格。

    pattern= r"\s+$"

    r-Python’s raw string notation for regular expression\s — matches whitespace characters.+ It will match one or more repetitions of whitespace character.$ Matches the end of the string

    r正则表达式\s Python原始字符串表示法-匹配空白字符。 +它将匹配一个或多个空白字符的重复。 $匹配字符串的结尾

    pattern mentioned are whitespaces at the end of the string.s1=re.sub(pattern,””,s)

    提到的模式是字符串末尾的空格。 s1=re.sub(pattern, ”” ,s)

    re.sub() will replace the pattern (whitespaces at the end of the string) to empty string.

    re.sub()会将模式(字符串末尾的空格)替换为空字符串。

    s="   Hello   Python  "
    import
    re
    pattern= r"\s+$"s1=re.sub(pattern,"",s)
    print (s1)#Output:Hello Python

    3.删除字符串中的前导和尾随空格 (3. Removing leading and trailing whitespace in a string)

    Image for post
    Photo by Author
    作者照片

    str.strip()

    str.strip()

    Return the copy of the string with leading whitespaces and trailing whitespaces removed.

    返回删除前导空格和尾随空格的字符串副本。

    s="   Hello   Python  "print(s.strip())#Output:Hello   Python

    re.sub()

    re.sub()

    Using re.sub(), we can remove leading whitespaces and trailing whitespaces.pattern="^\s+|\s+$"

    使用re.sub(),我们可以删除前导空格和尾随空格。 pattern= "^\s+|\s+$"

    ^\s+ Matches one or more whitespaces at the beginning of the string

    ^\s+匹配字符串开头的一个或多个空格

    \s+$ Matches one or more whitespaces at the end of the string.

    \s+$匹配字符串末尾的一个或多个空格。

    | x|y matches either x or y

    | x | y匹配x或y

    s="   Hello   Python  "
    import
    re
    pattern="^\s+|\s+$"s1 = re.sub(pattern, "",s)
    print(s1)#Output:Hello Python

    4.删除字符串中的所有空格。 (4. Remove all whitespaces in a string.)

    Image for post
    Photo by Author
    作者照片

    str.replace()Return a copy of the string with all occurrences of substring old replaced by new.

    str.replace()返回该字符串的副本,其中所有出现的子字符串old都替换为new。

    Syntax:

    句法:

    str.replace(old,new,count)

    str.replace(old,new,count)

    print (s.replace(" ",""))

    It will replace all whitespace characters into an empty string.

    它将所有空白字符替换为空字符串。

    s="   Hello   Python   "print (s.replace(" ",""))#Output:HelloPython

    re.sub()Using re.sub(), we can remove all whitespaces in the string.

    re.sub()使用re.sub(),我们可以删除字符串中的所有空格。

    pattern=r"\s+"s1 = re.sub(pattern, "", s)

    pattern matches all whitespaces in the string. Then re.sub(), replacing pattern(whitespaces ) to empty string.

    pattern匹配字符串中的所有空格。 然后re.sub(),将pattern(whitespaces)替换为空字符串。

    s="   Hello   Python   "
    import
    re
    pattern=r"\s+"s1 = re.sub(pattern, "", s)
    print (s1)#Output:HelloPython

    str.split() Returns list of all words in the string separated using delimiter string. If the delimiter is not mentioned, by default whitespace is the delimiter.

    str.split()返回使用定界符字符串分隔的字符串中所有单词的列表。 如果未提及定界符,则默认情况下空白为定界符。

    join() — join () method takes all items in the iterable and combines them into a string using a separator

    join() — join()方法将所有可迭代项都包含在内,并使用分隔符将它们组合成字符串

    s1="".join(s.split())

    Splitting the string and joining the elements using an empty string

    分割字符串并使用空字符串连接元素

    s="   Hello   Python   "print (s.split())#Output:['Hello', 'Python']
    #joining the elements in the string using empty string.
    s1="".join(s.split())
    print (s1)#Output:HelloPython

    5.删除字符串中的重复空格 (5. Removing duplicate whitespaces in the string)

    Image for post
    • str.split() Returns list of all words in the string separated using delimiter string. If the delimiter is not mentioned, by default whitespace is the delimiter.

      str.split()返回使用定界符字符串分隔的字符串中所有单词的列表。 如果未提及定界符,则默认情况下空白为定界符。

    join() — join () method takes all items in the iterable and combines them into a string using a separator

    join() — join()方法将所有可迭代项都包含在内,并使用分隔符将它们组合成字符串

    s1=" ".join(s.split())

    Splitting the string and joining the elements using a single whitespace string

    使用单个空格字符串分割字符串并连接元素

    s="Hello      Python"print (s.split())#Output:['Hello', 'Python']
    #joining the elements in the string using single whitespace string.
    s1=" ".join(s.split())
    print (s1)#Output:Hello Python

    翻译自: https://levelup.gitconnected.com/remove-whitespaces-from-strings-in-python-c5ee612ee9dc

    python字符串去掉空行

    展开全文
  • Python字符串比较

    万次阅读 2020-09-15 23:43:13
    In this tutorial we are going to see different methods by which we can compare strings in Python. We will also see some tricky cases when the python string comparison can fail and golden rules to get ...

    In this tutorial we are going to see different methods by which we can compare strings in Python. We will also see some tricky cases when the python string comparison can fail and golden rules to get string comparison always right.

    在本教程中,我们将看到用于比较Python中字符串的不同方法。 我们还将看到一些棘手的情况,这时python字符串比较可能会失败,并且黄金规则总是可以正确进行字符串比较。

    Python strings are Immutable. 

    Python字符串是不可变的。

    This means that once you have created a string then it cannot be modified, if you do modify it then it will create a new python string. Example below will explain the fact.

    这意味着一旦创建了字符串,便无法对其进行修改,如果您进行了修改,则它将创建一个新的python字符串。 下面的示例将说明事实。

    str1 = 'TheCrazyProgrammer'
    str2 = 'TheCrazyProgrammer'
     
    print(id(str1))  # Prints 54154496
    print(id(str2))  # Prints 54154496
     
    str1 += '.com'
     
    print(id(str1))  # Prints 54154400

    Here when we make change in str1 then the id of the string changes that confirms that a new string object is created. Now one more question remains i.e. why str1 and str2 have the same id ? 

    在这里,当我们在str1中进行更改时,字符串的ID会更改,以确认创建了新的字符串对象。 现在还有一个问题,即为什么str1和str2具有相同的id?

    That is because python do memory optimizations and similar string object are stored as only one object in memory. This is also the case with small python integers. 

    这是因为python进行内存优化,并且类似的字符串对象仅作为一个对象存储在内存中。 小python整数也是如此。

    Now getting to string comparison there are two different methods by which we can compare strings as below.

    现在开始进行字符串比较,有两种不同的方法可以用来比较字符串,如下所示。

    Python字符串比较 (Python String Comparison)

    方法1:比较使用is运算符 (Method 1: Comparing Using is Operator)

    is and is not operator is used to compare two strings as below:

    is和not运算符用于比较两个字符串,如下所示:

    str1 = 'TheCrazyProgrammer'
     
    str2 = 'TheCrazyProgrammer'
     
    if str1 is str2 :
        print("Strings are equal")  # Prints String are equal 
    else :
        print("String are not equal")

    The two strings to be compared are written on either side of the is operator and the comparison is made. is operator compares string based on the memory location of the string and not based on the value stored in the string. 

    将要比较的两个字符串写在is运算符的任一侧,然后进行比较。 is运算符根据字符串的存储位置而不是基于字符串中存储的值来比较字符串。

    Similarly to check if the two values are not equal the is not operator is used. 

    类似地,检查两个值是否不相等,使用了 is not 运算符。

    方法2:使用==运算符进行比较 (Method 2: Comparing Using == Operator)

    The == operator is used to compare two strings based on the value stored in the strings. It’s use is similar to is operator.

    ==运算符用于根据字符串中存储的值比较两个字符串。 它的用法类似于is运算符。

    str1 = 'TheCrazyProgrammer'
     
    str2 = 'TheCrazyProgrammer'
     
    if str1 == str2 :
        print("Strings are equal")  # Prints String are equal 
    else :
        print("String are not equal")

    Similarly to check if the two strings are not equal the != is used. 

    类似地,检查两个字符串是否相等,使用 !=

    Why the python string being immutable is important?

    为什么python字符串不可更改很重要?

    Even the python strings weren’t immutable then a comparison based on the memory location would not be possible and therefore is and is not operator cannot be used. 

    即使python字符串也不是不可变的,那么基于内存位置的比较也是不可能的,因此不能使用,并且不能使用运算符。

    Both of the comparison methods above are case sensitive i.e. ‘Cat’ and ‘cat’ are treated differently. Function below can be used to first convert the string in some particular case and then use them.

    上面的两种比较方法都区分大小写,即“猫”和“猫”的区别对待。 下面的函数可用于在某些特定情况下首先转换字符串,然后再使用它们。

    • .lower() : makes the string lowercase 

      .lower():使字符串变为小写

    • .upper() : makes the string uppercase

      .upper():使字符串大写

    So if both strings are first converted into a similar case and then checked then it would make the comparison case insensitive indirectly. Example below will make things more clear. 

    因此,如果首先将两个字符串都转换为相似的大小写,然后再进行检查,则这将使比较大小写间接变得不敏感。 下面的示例将使事情更加清楚。

    str1 = 'TheCrazyProgrammer'
     
    str2 = 'tHecRazyprogrammer'
     
    if str1 == str2 :
        print("Strings are equal")
    else :
        print("String are not equal") # Prints String are not equal
     
    if str1.upper() == str2.upper() :
        print("Strings are equal")   # Prints String are equal
    else :
        print("String are not equal")

    The golden line to remember whenever using the == and is operator is 

    每当使用==和is运算符时要记住的金线是

    == used to compare values and is used to compare identities.

    ==用于比较值,并用来比较的身份。

    One more thing to remember here is:

    这里要记住的一件事是:

    if x is y is then x == y is true

    如果 x 是 y , 则 x == y 是 true

    It is easily understandable as x and y points to the same memory locations then they must have the same value at that memory location. But the converse is not true. Here is an example to support the same:

    这很容易理解,因为x和y指向相同的存储位置,然后它们在该存储位置必须具有相同的值。 但是反过来是不正确的。 这是一个支持相同示例的示例:

    a = {"a":1}
    c = a.copy()
     
    print(a is c)  # Prints False
    print(a == c) # Prints True

    In this example c is at a new memory location and that’s why a is c prints false.

    在此示例中,c位于新的内存位置,这就是为什么a是c的结果为false的原因。

    翻译自: https://www.thecrazyprogrammer.com/2019/11/python-string-comparison.html

    展开全文
  • python字符串替换replace函数

    万次阅读 多人点赞 2019-11-03 11:21:11
    python字符串替换replace函数 replace(old, new, count) old,旧字符或字符串 new,新字符或字符串 count,最大替换数量,从起始位置开始计数,默认替换所有 注意:replace函数替换字符串,不影响原字符串 示例1:...
  • python字符串find_Python字符串find()

    千次阅读 2020-07-10 21:34:52
    python字符串findPython String find() method is used to find the index of a substring in a string. Python String find()方法用于查找字符串中子字符串的索引。 Python字符串find() (Python String find...
  • Python字符串中删除特定字符的方法

    万次阅读 2020-02-25 09:59:36
    这篇文章主要介绍了Python字符串中删除特定字符的方法,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧 分析 在Python中,字符串是不可变...
  • python字符串去掉空行There are various ways to remove spaces from a string in Python. This tutorial is aimed to provide a short example of various functions we can use to remove whitespaces from a ...
  • python字符串反转方法Hello everyone, in this tutorial we’ll see different ways to reverse string in Python. 大家好,在本教程中,我们将看到在Python中反转字符串的不同方法。 As we know, we can reverse ...
  • python字符串反向输出Python String doesn’t have a built-in reverse() function. However, there are various ways to reverse a string in Python. Python String没有内置的reverse()函数。 但是,有多种方法...
  • python字符串相减

    千次阅读 2020-11-19 19:31:41
    我们都知道在Python中,两个字符串相加会自动拼接字符串,但遗憾的是两个字符串相减却抛出异常。现在定义一个Nstr类,支持字符串的相减操作:A-B,即从A中去除所有B的子字符串。请编写相应的程序。 思路 在Nstr类内...
  • Python字符串拆分

    千次阅读 2020-07-11 01:24:52
    Python string split() function is used to split a string into the ... Python字符串split()函数用于根据定界符将字符串拆分为字符串列表。 Python字符串拆分 (Python String split) Python string split()...
  • python 字符串转为十六进制字符串

    千次阅读 2020-07-07 11:27:06
    python 字符串转为十六进制字符串0x00 问题0x01 解决0x02 代码 0x00 问题 我们的字符串为:hexstring = "c0a80a010f27d21e3ee5d0ced4887056425b057fffdc9286194a0000" 我们想把它转为为十六进制的形式,即每两个字母...
  • Python字符串总结大全

    万次阅读 多人点赞 2021-05-03 21:42:59
    普通字符串转化为Unicode字符串 重复操作符(*) 只适用于字符串的操作符 格式化操作符(%) 字符串模板:更简单的替代品 原始字符串操作符(r/R) Unicode字符串操作符(u/U) 常见的转义字符 字符串索引 编解码 ...
  • python里面的数据是有类型的,虽然没有显示声明。在c++里面int afloat bchar c都是显然的,在源码里面就写的明白的。在python里面,不需要声明。但是,他也是区分了类型的。根据什么区分?根据他的值来区分x=1y="...
  • 字符串转换整数pythonUnlike many other programming languages out there, Python does not implicitly typecast integers (or floats) to strings when you concatenate them to strings. 与现有的许多其他编程...
  • python字符串大小写转换

    千次阅读 2020-11-26 20:29:50
    两个函数如直译一样,将指定字符串变更大小写后新生成字符串存储 注意:这里是生成新的字符串来存放,所以不能作为操作来使用 upper()负责将指定字符串变为大写,可以单独使用,也可以放到print函数中 lower()负责将...
  • python字符串的比较

    千次阅读 2020-11-10 19:01:17
    关于其中字符串类型id引用驻留机制见python中的字符串的驻留机制 字符串的比较操作: 运算符:>,>=,<,<=,==,!= 比较规则:首先比较两个字符串中的第- -个字符,如果相等则继续比较下一个字符,依次...
  • python 字符串转大写Python String capitalize() function returns the capitalized version of the string. The first character of the returned string is converted to uppercase and rest of the characters ...
  • python 字节字符串 Python字符串到字节 (Python String to bytes) Python String to bytes conversion can be done in two ways: Python字符串到字节的转换可以通过两种方式完成: Using bytes() constructor and ...
  • Python使用区域设置将字符串转换为日期时间 (Python Convert String to Datetime with locale) Let’s look at an example where a locale-specific string will be converted to datetime object. We will use ...
  • Python字符串join()方法

    千次阅读 2020-07-11 01:14:52
    Python string join() method creates a string from an iterable. It joins all the iterable ... Python字符串join()方法从可迭代对象创建一个字符串。 它将所有可迭代的元素与字符串作为分隔符相连并返回它...
  • Python字符串类型及操作

    千次阅读 2020-03-21 12:58:20
    字符串由一对单引号或一对双引号来表示,例如:"请输入带有符号的温度值","Python"这些都是字符串。 (当然我们也可以使用一对三单引号或三双引号来表示多行字符串。) 字符串是字符的有序序列,可以对其中的字符...
  • python字符串比较大小

    万次阅读 多人点赞 2019-06-23 20:33:58
    理解原理和相关知识 ...字符串按位比较,两个字符串第一位字符的ascii码谁大,字符串就大,不再比较后面的;第一个字符相同就比第二个字符串,以此类推,需要注意的是空格的ascii码是32,空(null)的ascii码是0 ...
  • python字符串常用方法及汇总

    万次阅读 多人点赞 2019-06-18 18:57:03
    字符串常用方法常用的查找方法去除首尾信息大小写转换格式排版其他方法字符串的格式化format()基本用法填充与对齐数字格式化其他格式,供大家参考:可变字符串 常用的查找方法 我们以一段文本作为测试: a=’’‘我...
  • Python字符串index()

    千次阅读 2020-07-10 18:04:52
    Python String index() function returns the lowest index where the specified substring is found. If the substring is not ... Python String index()函数返回找到指定子字符串的最低索引。 如果未找到子字...
  • python 字符串的输入和输出

    千次阅读 2020-04-30 11:07:18
    python 字符串的输入和输出 1、字符串的输入 python中提供了input()函数可以用于接收字符串的输入,默认的标准输入是键盘,并且会将输入内容转化为字符串类型,如需将其转化为整型等数据类型,可以使用数据类型转化...
  • python字符串逆序输出的6种方法

    万次阅读 2019-04-25 19:30:44
    对于一个给定的字符串,逆序输出,这个任务对于python来说是一种很简单的操作,毕竟强大的列表和字符串处理的一些列函数足以应付这些问题 了,今天总结了一下python中对于字符串的逆序输出的几种常用的方法,一共...
  • python字符串和字符串相关运算

    千次阅读 2018-12-30 21:51:03
    字符串中的每一个字符都会对应一个唯一的下标(索引)用来表示字符在字符串中的位置。 下标的范围: 下标是从0开始依次增加的,0对应的第一个字符 (0 ~ 字符串长度 - 1) 下标是从-1开始依次减少的,-1对应的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 826,393
精华内容 330,557
关键字:

python字符串

python 订阅