精心整理了100+Python字符串常用操作，收藏备用！（上）

太过爱你忘了你带给我的痛 2023-10-10 14:18 19阅读 0赞

**简介：** 字符串作为平时使用最多的数据类型，其常用的操作我们还是很有必要熟记于心的，本文整理了多种字符串的操作的案例，还是非常用心，记得点赞收藏哦 文章很长，高低要忍一下，如果忍不了，那就收藏吧，总会用到的

*  字符串切片操作
 *  检查字符串是否为空
 *  计算字符串中字符出现次数的多种方法
 *  将 String 变量转换为 float、int 或 boolean
 *  向字符串填充或添加零的不同方法
 *  去掉字符串中的 space 字符
 *  生成N个字符的随机字符串
 *  以不同的方式反转字符串
 *  将 Camel Case 转换为 Snake Case 并更改给定字符串中特定字符的大小写
 *  检查给定的字符串是否是 Python 中的回文字符串
 *  检查字符串是否以列表中的一个字符串结尾
 *  在字符串中应用查找模式
 *  如果是 Python 中的反斜杠，则删除最后一个字符
 *  在Python中拆分字符串而不丢失拆分字符
 *  从字符串 Python 中提取大写和小写字符
 *  如何在 Python 中比较字符串的索引是否相等
 *  在每个第 4 个字符上添加空格
 *  在 Python 中以多行方式连接字符串
 *  在 Python 中将多个变量附加到列表中
 *  将字符串拆分为 Python 中的字符列表
 *  如何在 Python 中小写字符串
 *  通过多个标点符号分割字符串
 *  Python 字符串填充
 *  在 Python 中检查两个字符串是否包含相同的字符
 *  在 Python 中查找给定字符串中的整个单词
 *  查找所有出现的子字符串
 *  在 Python 中去除所有开头在Python中的正斜杠上拆分字符串和结尾标点符号
 *  用 Python 中的正斜杠上拆分字符串
 *  根据 Python 中的索引位置将字符串大写
 *  检查字符串中的所有字符是否都是Python中的数字
 *  为什么使用'=='或'is'比较字符串有时会产生不同的结果
 *  如何在 Python 中为字符串添加 X 个空格
 *  如何在Python中替换字符串中的特定字符串实例
 *  如何连接两个变量，一个是字符串，另一个是 Python 中的 int
 *  在 Python 中的反斜杠上拆分字符串
 *  在Python中随机大写字符串中的字母
 *  在单词处拆分字符串并且或不保留分隔符
 *  在 Python 中填充 n 个字符
 *  检查变量是否等于一个字符串或另一个字符串
 *  Python字符串格式化固定宽度
 *  在Python中查找字符串中字符的所有位置
 *  在Python中从左右修剪指定数量的空格
 *  在Python中按字符串中字符的位置拆分字符串
 *  将Python字符串中的第一个和最后一个字母大写
 *  检查字符串是否以Python中的给定字符串或字符结尾
 *  如何在 Python 中比较两个字符串
 *  在Python中将整数格式化为带有前导零的字符串
 *  在Python中替换字符串的多个子字符串
 *  Python字符串替换字符
 *  在Python中查找字符串中所有出现的单词的所有索引
 *  在 Python 中将字符串中每个单词的首字母大写
 *  仅在 Python 中的双引号后拆分字符串
 *  在 Python 中以字节为单位获取字符串的大小
 *  在 Python 中比较字符串中的字符
 *  在 Python 中的括号和字符串之间添加空格
 *  在 Python 中删除开头和结尾空格
 *  在 Python 中拆分字符串以获得第一个值
 *  在 Python 中检查字符串是大写、小写还是混合大小写
 *  Python计数字符串出现在给定字符串中
 *  在 Python3 中用前导零填充字符串
 *  在 Python 中检查两个字符串是否包含相同的字母和数字
 *  在Python中的字符串中的字符之间添加空格的有效方法
 *  在Python中查找字符串中最后一次出现的子字符串的索引
 *  在 Python 中将字符串大写
 *  拆分非字母数字并在 Python 中保留分隔符
 *  计算Python中字符串中大写和小写字符的数量
 *  在 Python 中将字符串与枚举进行比较
 *  Python中的段落格式
 *  从 Python 中的某个索引替换字符
 *  如何连接 str 和 int 对象
 *  仅在 Python 中将字符串拆分为两部分
 *  将大写字符串转换为句子大小写
 *  在标点符号上拆分字符串
 *  在 Python 中比较字符串
 *  用零填充数字字符串
 *  找到两个字符串之间的差异位置
 *  Python填充字符串到固定长度
 *  Python中的字符串查找示例
 *  删除字符串中的开头零和结尾零
 *  Python在换行符上拆分
 *  将字符串中的每个第二个字母大写
 *  在 Python 中查找一个月的最后一个营业日或工作日
 *  比较两个字符串中的单个字符
 *  在 Python 中多次显示字符串
 *  Python 从头开始替换字符串
 *  在 Python 中连接字符串和变量值
 *  在每个下划线处拆分字符串并在第 N 个位置后停止
 *  Python 中列表中第一个单词的首字母大写
 *  如何在 Python 字符串中找到第一次出现的子字符串
 *  不同长度的 Python 填充字符串
 *  Python 比较两个字符串保留一端的差异
 *  如何用 Python 中的一个字符替换字符串中的所有字符
 *  在字符串中查找子字符串并在 Python 中返回子字符串的索引
 *  从 Python 中的字符串中修剪特定的开头和结尾字符
 *  在 Python 中按长度将字符串拆分为字符串
 *  如何在 Python 中将字符串的第三个字母大写
 *  将制表符大小设置为指定的空格数
 *  将两个字符串与某些字符进行比较
 *  字符串格式化填充负数
 *  单独替换字符串中的第一个字符
 *  连接固定字符串和变量
 *  将字符串拆分为多个字符串
 *  在 Python 中将字符串大写
 *  将字节字符串拆分为单独的字节
 *  用空格填写 Python 字符串
 *  比较两个字符串并检查它们共有多少个字符
 *  在 Python 中的数字和字符串之间添加空格
 *  如何在 Python 中去除空格
 *  字符串中最后一次出现的分隔符处拆分字符串
 *  在Python中将字符串的最后一个字母大写
 *  使用指定字符居中对齐字符串
 *  格式字符串中动态计算的零填充
 *  在 Python 中使用 string.replace()
 *  在 Python 中获取字符的位置
 *  Python字符串替换多次出现
 *  在索引后找到第一次出现的字符
 *  在 Python 中将字符串更改为大写
 *  在 Python 中拆分具有多个分隔符的字符串
 *  在 Python 中获取字符串的大小
 *  Python中的字符串比较 is vs ==
 *  每当数字与非数字相邻时，Python 正则表达式都会添加空格
 *  在 Python 中仅按第一个空格拆分字符串
 *  在Python中将字符串中的一些小写字母更改为大写
 *  将字符串拆分为具有多个单词边界分隔符的单词
 *  检查一个字符串在 Python 中是否具有相同的字符
 *  在多个分隔符或指定字符上拆分字符串
 *  将一个字符串附加到另一个字符串
 *  在 Python 中遍历字符串
 *  从 Python 中的字符串中去除标点符号
 *  将列表转换为字符串
 *  将 JSON 转换为字符串
 *  对字符串列表进行排序
 *  在 Python 中检查字符串是否以 XXXX 开头
 *  在 Python 中将两个字符串网格或交错在一起的不同方法

### 字符串切片操作 ###

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

test = "Python Programming"
    print("String: ", test)
     
    # First one character
    first_character = test[:1]
    print("First Character: ", first_character)
     
    # Last one character
    last_character = test[-1:]
    print("Last Character: ", last_character)
     
    # Everything except the first one character
    except_first = test[1:]
    print("Except First Char.: ", except_first)
     
    # Everything except the last one character
    except_last = test[:-1]
    print("Except First Char.: ", except_last)
     
    # Everything between first and last two character
    between_two = test[2:-2]
    print("Between two character: ", between_two)
     
    # Skip one character
    skip_one = test[0:18:2]  # [start:stop:step]
    print("Skip one character: ", skip_one)
     
    # Reverse String
    reverse_str = test[::-1]
    print("Reverse String: ", reverse_str)

Output:

String:  Python Programming
    First Character:  P
    Last Character:  g
    Except First Char.:  ython Programming
    Except First Char.:  Python Programmin
    Between two character:  thon Programmi
    Skip one character:  Pto rgamn
    Reverse String:  gnimmargorP nohtyP

### 检查字符串是否为空 ###

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

import re
    from collections import Counter
     
    sentence = 'Canada is located in the northern part of North America'
    # Example I
    counter = len(re.findall("a", sentence))
    print(counter)
     
    # Example II
    counter = sentence.count('a')
    print(counter)
     
    # Example III
    counter = Counter(sentence)
    print(counter['a'])

Output:

Empty
    Empty
    Empty

### 计算字符串中字符出现次数的多种方法 ###

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

Output:

6
    6
    6

### 将 String 变量转换为 float、int 或 boolean ###

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

# String to Float
    float_string = "254.2511"
    print(type(float_string))
     
    string_to_float = float(float_string)
    print(type(string_to_float))
     
    # String to Integer
    int_string = "254"
    print(type(int_string))
     
    string_to_int = int(int_string)
    print(type(string_to_int))
     
     
    # String to Boolean
    bool_string = "True"
    print(type(bool_string))
     
    string_to_bool = bool(bool_string)
    print(type(string_to_bool))

Output:

class 'str'
    class 'float>
    class 'str'
    class 'int'
    class 'str'
    class 'bool'

### 向字符串填充或添加零的不同方法 ###

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

num = 7
     
    print('{0:0>5d}'.format(num))  # left
    print('{0:0<5d}'.format(num))  # right
     
    print('{:05d}'.format(num))
     
    print("%0*d" % (5, num))
    print(format(num, "05d"))
     
    temp = 'test'
    print(temp.rjust(10, '0'))
    print(temp.ljust(10, '0'))

Output:

00007
    70000
    00007
    00007
    00007
    000000test
    test000000

### 去掉字符串中的 space 字符 ###

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

string_var = "  \t a string example\n\t\r  "
    print(string_var)
     
    string_var = string_var.lstrip()  # trim white space from left
    print(string_var)
     
    string_var = "  \t a string example\t  "
    string_var = string_var.rstrip()  # trim white space from right
    print(string_var)
     
    string_var = "  \t a string example\t  "
    string_var = string_var.strip()  # trim white space from both side
    print(string_var)

Output:

a string example
     
     
    a string example
     
     
         a string example
    a string example

### 生成N个字符的随机字符串 ###

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

import string
    import random
     
     
    def string_generator(size):
        chars = string.ascii_uppercase + string.ascii_lowercase
        return ''.join(random.choice(chars) for _ in range(size))
     
     
    def string_num_generator(size):
        chars = string.ascii_lowercase + string.digits
        return ''.join(random.choice(chars) for _ in range(size))
     
     
    # Random String
    test = string_generator(10)
    print(test)
     
    # Random String and Number
    test = string_num_generator(15)
    print(test)

Output:

acpPTojXet
    qmpah72cjb83eqd

### 以不同的方式反转字符串 ###

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

test_string = 'Python Programming'
     
    string_reversed = test_string[-1::-1]
    print(string_reversed)
     
    string_reversed = test_string[::-1]
    print(string_reversed)
     
     
    # String reverse logically
    def string_reverse(text):
        r_text = ''
        index = len(text) - 1
     
        while index >= 0:
            r_text += text[index]
            index -= 1
     
        return r_text
     
    print(string_reverse(test_string))

Output:

gnimmargorP nohtyP
    gnimmargorP nohtyP
    gnimmargorP nohtyP

### 将 Camel Case 转换为 Snake Case 并更改给定字符串中特定字符的大小写 ###

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

import re
     
     
    def convert(oldstring):
        s1 = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', oldstring)
        return re.sub('([a-z0-9])([A-Z])', r'\1_\2', s1).lower()
     
     
    # Camel Case to Snake Case
    print(convert('CamelCase'))
    print(convert('CamelCamelCase'))
    print(convert('getHTTPResponseCode'))
    print(convert('get2HTTPResponseCode'))
     
    # Change Case of a particular character
    text = "python programming"
    result = text[:1].upper() + text[1:7].lower() \
        + text[7:8].upper() + text[8:].lower()
    print(result)
     
    text = "Kilometer"
    print(text.lower())
     
    old_string = "hello python"
    new_string = old_string.capitalize()
    print(new_string)
     
    old_string = "Hello Python"
    new_string = old_string.swapcase()
    print(new_string)

Output:

camel_case
    camel_camel_case
    get_http_response_code
    get2_http_response_code
    Python Programming
    kilometer
    Hello python
    hELLO pYTHON

### 检查给定的字符串是否是 Python 中的回文字符串 ###

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

import re
     
     
    Continue = 1
    Quit = 2
     
     
    def main():
        choice = 0
     
        while choice != Quit:
            # Display the menu.
            display_menu()
            # Constant to assume string is Palindrome
            is_palindrome = True
     
            # Get the user's choice.
            choice = int(input('\nEnter your choice: '))
     
            # Perform the selected action.
            if choice == Continue:
                line = input("\nEnter a string: ")
                str_lower = re.sub("[^a-z0-9]", "", line.lower())
                for i in range(0, len(str_lower)//2):
                    if str_lower[i] != str_lower[len(str_lower) - i - 1]:
                        is_palindrome = False
     
                if is_palindrome:
                    print(line, "is a palindrome")
                else:
                    print(line, "is not a palindrome")
            else:
                print('Thank You.')
     
     
    def display_menu():
        print('\n*******MENU*******')
        print('1) Continue')
        print('2) Quit')
     
     
    main()

Output:

*******MENU*******
    1) Continue
    2) Quit
     
    Enter your choice: 1
     
    Enter a string: A dog! A panic in a pagoda!
    A dog! A panic in a pagoda! is a palindrome
     
    *******MENU*******
    1) Continue
    2) Quit
     
    Enter your choice: 1
     
    Enter a string: Civic
    Civic is a palindrome
     
    *******MENU*******
    1) Continue
    2) Quit
     
    Enter your choice: 1
     
    Enter a string: Python vs Java
    Python vs Java is not a palindrome
     
    *******MENU*******
    1) Continue
    2) Quit
     
    Enter your choice: 2
    Thank You.

### 检查字符串是否以列表中的一个字符串结尾 ###

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

str_list = ['aaa', 'bbb', 'ccc', 'ddd']  # list of items
    str_test = 'testccc'  # string need to test
     
    for str_item in str_list:
        if str_test.endswith(str_item):
            print("found")
            break   # loop ends when result found
        else:
            print("not found")

Output:

not found
    not found
    found

### 在字符串中应用查找模式 ###

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

import re
    s1 = 'abccba'
    s2 = 'abcabc'
    s3 = 'canadajapanuaeuaejapancanada'
    p = '123321'
    def match(s, p):
        nr = {}
        regex = []
        for c in p:
            if c not in nr:
                regex.append('(.+)')
                nr[c] = len(nr) + 1
            else:
                regex.append('\\%d' % nr[c])
        return bool(re.match(''.join(regex) + '$', s))
    print(match(s1, p))
    print(match(s2, p))
    print(match(s3, p))

Output:

True
    False
    True

### 如果是 Python 中的反斜杠，则删除最后一个字符 ###

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

x = 'Canada\\'
    print(x.rstrip('\\'))

Output:

Canada

### 在Python中拆分字符串而不丢失拆分字符 ###

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

import re
    string = 'canada-japan-india'
    print(re.split(r'(\-)', string))

Output:

['canada', '-', 'japan', '-', 'india']

### 从字符串 Python 中提取大写和小写字符 ###

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

string = "asdfHRbySFss"
    uppers = [l for l in string if l.isupper()]
    print (''.join(uppers))
    lowers = [l for l in string if l.islower()]
    print (''.join(lowers))

Output:

HRSF
    asdfbyss

### 如何在 Python 中比较字符串的索引是否相等 ###

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

myString = 'AAABBB'
    for idx, char in enumerate(myString, ):
        if idx + 1 == len(myString):
            break
        if char == myString[idx + 1]:
            print(idx, char, myString[idx + 1])

Output:

0 A A
    1 A A
    3 B B
    4 B B

### 在每个第 4 个字符上添加空格 ###

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

string = 'Test5412Test8745Test'
    print([string[i:i + 4] for i in range(0, len(string), 4)])

Output:

['Test', '5412', 'Test', '8745', 'Test']

### 在 Python 中以多行方式连接字符串 ###

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

str1 = "This is a demo string"
    str2 = "This is another  demo string"
    strz = ("This is a line\n" +
           str1 + "\n" +
           "This is line 2\n" +
           str2 + "\n" +
           "This is line 3\n")
    print(strz)

Output:

This is a line
    This is a demo string
    This is line 2
    This is another  demo string
    This is line 3

### 在 Python 中将多个变量附加到列表中 ###

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

volumeA = 100
    volumeB = 20
    volumeC = 10
    vol1 = []
    vol2 = []
    vol1.extend((volumeA, volumeB, volumeC))
    vol2 += [val for name, val in globals().items() if name.startswith('volume')]
    print(vol1)
    print(vol2)

Output:

[100, 20, 10]
    [100, 20, 10]

### 将字符串拆分为 Python 中的字符列表 ###

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

s = 'canada'
    l = list(s)
    print(l)

Output:

['c', 'a', 'n', 'a', 'd', 'a']

### 如何在 Python 中小写字符串 ###

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

text = ['Canada', 'JAPAN']
    text = [txt.lower() for txt in text]
    print(text)

Output:

['canada', 'japan']

### 通过多个标点符号分割字符串 ###

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

import re
    s = 'a,b,c d!e.f\ncanada\tjapan&germany'
     
    l = re.split('[?.,\n\t&! ]', s)
     
    for i in l:
        print(i)

Output:

a
    b
    c
    d
    e
    f
    canada
    japan
    germany

### Python 字符串填充 ###

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

lines_of_text = [
        (123, 5487, 'Testing', 'Billy', 'Jones'),
        (12345, 100, 'Test', 'John M', 'Smith')
    ]
    for mytuple in lines_of_text:
        name = '{}, {}'.format(mytuple[4], mytuple[3])
        value = '$' + str(mytuple[1])
        print('{name:<20} {id:>8} {test:<12} {value:>8}'.format(
            name=name, id=mytuple[0], test=mytuple[2], value=value)
        )

Output:

Jones, Billy              123 Testing         $5487
    Smith, John M           12345 Test             $100

### 在 Python 中检查两个字符串是否包含相同的字符 ###

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

str1 = 'caars'
    str2 = 'rats'
    str3 = 'racs'
    print(set(str1)==set(str2))
    print(set(str1)==set(str3))

Output:

False
    True

### 在 Python 中查找给定字符串中的整个单词 ###

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

def contains_word(s, w):
        return (' ' + w + ' ') in (' ' + s + ' ')
    result = contains_word('those who seek shall find', 'find')
    print(result)
    result = contains_word('those who seek shall find', 'finds')
    print(result)

Output:

True
    False

### 查找所有出现的子字符串 ###

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

import re
    aString = 'this is a string where the substring "is" is repeated several times'
    print([(a.start(), a.end()) for a in list(re.finditer('is', aString))])

Output:

[(2, 4), (5, 7), (38, 40), (42, 44)]

### 在 Python 中去除所有开头在Python中的正斜杠上拆分字符串和结尾标点符号 ###

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

from string import punctuation
    s = '.$958-5-Canada,#'
    print(s.strip(punctuation))

Output:

958-5-Canada

### 用 Python 中的正斜杠上拆分字符串 ###

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

s = 'canada/japan/australia'
    l = s.split('/')
     
    print(l)

Output:

['canada', 'japan', 'australia']

### 根据 Python 中的索引位置将字符串大写 ###

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

def capitalize(s, ind):
        split_s = list(s)
        for i in ind:
            try:
                split_s[i] = split_s[i].upper()
            except IndexError:
                print('Index out of range : ', i)
        return "".join(split_s)
    print(capitalize("abracadabra", [2, 6, 9, 10, 50]))

Output:

Index out of range :  50
    abRacaDabRA

### 检查字符串中的所有字符是否都是Python中的数字 ###

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

a = "1000"
    x = a.isdigit()
    print(x)
    b = "A1000"
    x = b.isdigit()
    print(x)

Output:

True
    False

### 为什么使用'=='或'is'比较字符串有时会产生不同的结果 ###

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

a = 'canada'
    b = ''.join(['ca', 'na', 'da'])
    print(a == b)
    print(a is b)
    a = [1, 2, 3]
    b = [1, 2, 3]
    print(a == b)
    print(a is b)
    c = b
    print(c is b)

Output:

True
    False
    True
    False
    True

### 如何在 Python 中为字符串添加 X 个空格 ###

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

print('canada'.ljust(10) + 'india'.ljust(20) + 'japan')

Output:

canada    india               japan

### 如何在Python中替换字符串中的特定字符串实例 ###

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

def nth_replace(str,search,repl,index):
        split = str.split(search,index+1)
        if len(split)<=index+1:
            return str
        return search.join(split[:-1])+repl+split[-1]
    str1 = "caars caars caars"
    str2 = nth_replace(str1, 'aa', 'a', 1)
    print(str2)

Output:

caars cars caars

### 如何连接两个变量，一个是字符串，另一个是 Python 中的 int ###

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

int1 = 10
    str1 = 'test'
    print(str(int1) + str1)

Output:

10test

### 在 Python 中的反斜杠上拆分字符串 ###

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

s = r'canada\japan\australia'
    l = s.split('\\')
    print(l)

Output:

['canada', 'japan', 'australia']

### 在Python中随机大写字符串中的字母 ###

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

from random import choice
    x = "canada japan australia"
    print(''.join(choice((str.upper, str.lower))(c) for c in x))

Output:

CANaDA JaPan auStRALIa

### 在单词处拆分字符串并且或不保留分隔符 ###

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

import re
    string = "Canada AND Japan NOT Audi OR BMW"
    l = re.split(r'(AND|OR|NOT)', string)
    print(l)

Output:

['Canada ', 'AND', ' Japan ', 'NOT', ' Audi ', 'OR', ' BMW']

### 在 Python 中填充 n 个字符 ###

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

def header(txt: str, width=30, filler='*', align='c'):
        assert align in 'lcr'
        return {'l': txt.ljust, 'c': txt.center, 'r': txt.rjust}[align](width, filler)
     
     
    print(header("Canada"))
    print(header("Canada", align='l'))
    print(header("Canada", align='r'))

Output:

************Canada************
    Canada************************
    ************************Canada

### 检查变量是否等于一个字符串或另一个字符串 ###

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

x = 'canada'
    if x in ['canada', 'japan', 'germany', 'australia']:
        print("Yes")

Output:

true

### Python字符串格式化固定宽度 ###

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

num1 = 0.04154721841
    num2 = 10.04154721841
    num3 = 1002.04154721841
    print "{0:<12.11g}".format(num1)[:12]
    print "{0:<12.11g}".format(num2)[:12]
    print "{0:<12.11g}".format(num3)[:12]

Output:

100.041549
    0.04159874
    12.8878877

### 在Python中查找字符串中字符的所有位置 ###

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

test = 'canada#japan#uae'
    c = '#'
    print([pos for pos, char in enumerate(test) if char == c])

Output:

[6, 12]

### 在Python中从左右修剪指定数量的空格 ###

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

def trim(text, num_of_leading, num_of_trailing):
        text = list(text)
        for i in range(num_of_leading):
            if text[i] == " ":
                text[i] = ""
            else:
                break
        for i in range(1, num_of_trailing+1):
            if text[-i] == " ":
                text[-i] = ""
            else:
                break
        return ''.join(text)
    txt1 = "   Candada     "
    print(trim(txt1, 1, 1))
    print(trim(txt1, 2, 3))
    print(trim(txt1, 6, 8))

Output:

Candada    
     Candada  
    Candada

### 在Python中按字符串中字符的位置拆分字符串 ###

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

str = 'canadajapan'
    splitat = 6
    l, r = str[:splitat], str[splitat:]
    print(l)
    print(r)

Output:

canada
    japan

### 将Python字符串中的第一个和最后一个字母大写 ###

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

string = "canada"
    result = string[0:1].upper() + string[1:-1].lower() + string[-1:].upper()
    print(result)

Output:

CanadA

### 检查字符串是否以Python中的给定字符串或字符结尾 ###

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

txt = "Canada is a great country"
    x = txt.endswith("country")
    print(x)

Output:

True

### 如何在 Python 中比较两个字符串 ###

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

str1 = "Canada"
    str2 = "Canada"
    print(str1 is str2)  # True
    print(str1 == str2)  # True
     
    string1 = ''.join(['Ca', 'na', 'da'])
    string2 = ''.join(['Can', 'ada'])
    print(string1 is string2)  # False
    print(string1 == string2)  # True

Output:

True
    True
    False
    True

### 在Python中将整数格式化为带有前导零的字符串 ###

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

x = 4
    x = str(x).zfill(5)
    print(x)

Output:

00004

### 在Python中替换字符串的多个子字符串 ###

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

s = "The quick brown fox jumps over the lazy dog"
    for r in (("brown", "red"), ("lazy", "quick")):
        s = s.replace(*r)
    print(s)

Output:

The quick red fox jumps over the quick dog

### Python字符串替换字符 ###

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

s = "The quick brown fox jumps over the lazy dog"
    for r in (("brown", "red"), ("lazy", "quick")):
        s = s.replace(*r)
    print(s)

Output:

The quick red fox jumps over the quick dog

### 在Python中查找字符串中所有出现的单词的所有索引 ###

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

import re
    sentence = 'this is a sentence this this'
    word = 'this'
    for match in re.finditer(word, sentence):
        print(match.start(), match.end())

Output:

0 4
    19 23
    24 28

### 在 Python 中将字符串中每个单词的首字母大写 ###

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

import string
    x = "they're bill's friends from the UK"
    x = string.capwords(x)
    print(x)
    x = x.title()
    print(x)

Output:

They're Bill's Friends From The Uk
    They'Re Bill'S Friends From The Uk

### 仅在 Python 中的双引号后拆分字符串 ###

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

s = '"Canada", "Japan", "Germany", "Russia"'
    l = ['"{}"'.format(s) for s in s.split('"') if s not in ('', ', ')]
    for item in l:
        print(item)

Output:

"Canada"
    "Japan"
    "Germany"
    "Russia"

### 在 Python 中以字节为单位获取字符串的大小 ###

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

string1 = "Canada"
    print(len(string1.encode('utf-16')))

Output:

### 在 Python 中比较字符串中的字符 ###

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

Output:

0 A A
    1 A A
    3 B B
    4 B B

### 在 Python 中的括号和字符串之间添加空格 ###

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

import re
    test = "example(test)"
    test2 = "example(test)example"
    test3 = "(test)example"
    test4 = "example (test) example"
    for i in [test, test2, test3, test4]:
        print(re.sub(r"[^\S]?($.*?$)[^\S]?", r" \1 ", i).strip())

Output:

example (test)
    example (test) example
    (test) example
    example (test) example

### 在 Python 中删除开头和结尾空格 ###

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

s = '   canada   '
    print(s.strip())

Output:

canada

### 在 Python 中拆分字符串以获得第一个值 ###

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

s = 'canada-japan-australia'
    l = s.split('-')[0]
    print(l)
    string = 'canada-japan-australia'
    print(string[:string.index('-')])

Output:

canada
    canada

### 在 Python 中检查字符串是大写、小写还是混合大小写 ###

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

words = ['The', 'quick', 'BROWN', 'Fox',
             'jumped', 'OVER', 'the', 'Lazy', 'DOG']
    print([word for word in words if word.islower()])
    print([word for word in words if word.isupper()])
    print([word for word in words if not word.islower() and not word.isupper()])

Output:

['quick', 'jumped', 'the']
    ['BROWN', 'OVER', 'DOG']
    ['The', 'Fox', 'Lazy']

### Python计数字符串出现在给定字符串中 ###

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

txt = "I love Canada, Canada is one of the most impressive countries in the world. Canada is a great country."
     
    x = txt.count("Canada")
     
    print(x)