关于程序员:精心整理了100Python字符串常用操作备用

字符串作为平时应用最多的数据类型，其罕用的操作咱们还是很有必要熟记于心的，本文整顿了多种字符串的操作的案例，还是十分用心，记得点赞珍藏哦

文章很长，高下要忍一下，如果忍不了，那就珍藏吧，总会用到的

萝卜哥也贴心的做成了 PDF，在文末获取！

[TOC]

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

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:

6
6
6

# 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:

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

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

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

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 = len(nr) + 1
        else:
            regex.append('\\%d' % nr)
    return bool(re.match(''.join(regex) +'$', s))


print(match(s1, p))
print(match(s2, p))
print(match(s3, p))

Output:

True
False
True

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

Output:

Canada

import re
string = 'canada-japan-india'

print(re.split(r'(\-)', string))

Output:

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

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

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

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

Output:

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

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

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]

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

Output:

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

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

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

str1 = 'caars'
str2 = 'rats'
str3 = 'racs'

print(set(str1)==set(str2))
print(set(str1)==set(str3))

Output:

False
True

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)]

from string import punctuation
s = '.$958-5-Canada,#'

print(s.strip(punctuation))

Output:

958-5-Canada

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

Output:

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

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

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

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

Output:

True
False

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

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

Output:

canada    india               japan

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

int1 = 10
str1 = 'test'

print(str(int1) + str1)

Output:

10test

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

print(l)

Output:

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

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']


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

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

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

Output:

[6, 12]

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

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

Output:

canada
japan

string = "canada"

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

Output:

CanadA

txt = "Canada is a great country"

x = txt.endswith("country")

print(x)

Output:

True

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

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

Output:

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

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

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

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

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"

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

Output:

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

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

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

Output:

canada

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

string = 'canada-japan-australia'
print(string[:string.index('-')])

Output:

canada
canada

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']

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)

Output:

hour = 4
minute = 3

print("{:0>2}:{:0>2}".format(hour, minute))
print("{:0>3}:{:0>5}".format(hour, minute))
print("{:0<3}:{:0<5}".format(hour, minute))
print("{:$<3}:{:#<5}".format(hour, minute))

Output:

04:03
004:00003
400:30000
4$$:3####

from string import ascii_letters, digits


def compare_alphanumeric(first, second):
    for character in first:
        if character in ascii_letters + digits and character not in second:
            return False
    return True


str1 = 'ABCD'
str2 = 'ACDB'
print(compare_alphanumeric(str1, str2))

str1 = 'A45BCD'
str2 = 'ACD59894B'
print(compare_alphanumeric(str1, str2))

str1 = 'A45BCD'
str2 = 'XYZ9887'
print(compare_alphanumeric(str1, str2))

Output:

True
True
False

s = "CANADA"

print(" ".join(s))
print("-".join(s))
print(s.replace(""," ")[1: -1])

Output:

C A N A D A
C-A-N-A-D-A
C A N A D A

s = 'What is Canada famous for?'

print(s.find('f'))
print(s.index('f'))
print(s.rindex('f'))
print(s.rfind('f'))

Output:

x = 'canada'
x = x.capitalize()
 
print(x)

Output:

Canada

import re

s = "65&Can-Jap#Ind^UK"
l = re.split('([^a-zA-Z0-9])', s)
print(l)

Output:

['65', '&', 'Can', '-', 'Jap', '#', 'Ind', '^', 'UK']

string = "asdfHRbySFss"

uppers = [l for l in string if l.isupper()]
print(len(uppers))

lowers = [l for l in string if l.islower()]
print(len(lowers))

Output:

4
8

from enum import Enum, auto


class Signal(Enum):
     red = auto()
     green = auto()
     orange = auto()

     def equals(self, string):
          return self.name == string


brain_detected_colour = "red"
print(Signal.red.equals(brain_detected_colour))

brain_detected_colour = "pink"
print(Signal.red.equals(brain_detected_colour))

Output:

True
False

import textwrap

hamlet = '''\
Lorum ipsum is the traditional Latin placeholder text, used when a designer needs a chunk of text for dummying up a layout.
Journo Ipsum is like that, only using some of the most common catchphrases, buzzwords, and bon mots of the future-of-news crowd.
Hit reload for a new batch. For entertainment purposes only.'''wrapper = textwrap.TextWrapper(initial_indent='\t' * 1,
                               subsequent_indent='\t' * 2,
                               width=40)

for para in hamlet.splitlines():
    print(wrapper.fill(para))

Output:

    Lorum ipsum is the traditional Latin
        placeholder text, used when a designer
        needs a chunk of text for dummying up
        a layout.
    Journo Ipsum is like that, only using
        some of the most common catchphrases,
        buzzwords, and bon mots of the future-
        of-news crowd.
    Hit reload for a new batch. For
        entertainment purposes only.

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

i = 123
a = "foobar"
s = a + str(i)
print(s)

Output:

foobar123

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

Output:

['canada', 'japan australia']

text = ['CANADA', 'JAPAN']

text = [txt.capitalize() for txt in text]
print(text)

Output:

['Canada', 'Japan']

string = 'a,b,c d!e.f\ncanada\tjapan&germany'
identifiers = '!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~\n\t'

listitems = "".join((' ' if c in identifiers else c for c in string)).split()

for item in listitems:
    print(item)

Output:

a
b
c
d
e
f
canada
japan
germany

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

num = 123
print('{:<08d}'.format(num))
print('{:>08d}'.format(num))

string = '123'
print(string.ljust(8, '0'))
print(string.rjust(8, '0'))

print(string[::-1].zfill(8)[::-1])

Output:

def dif(a, b):
    return [i for i in range(len(a)) if a[i] != b[i]]

print(dif('stackoverflow', 'stacklavaflow'))

Output:

[5, 6, 7, 8]

number = 4

print(f'{number:05d}')  # (since Python 3.6), or
print('{:05d}'.format(number))  # or

print('{0:05d}'.format(number))
print('{n:05d}'.format(n=number))  # or (explicit `n` keyword arg. selection)
print(format(number, '05d'))

Output:

import re

text = 'This is sample text to test if this pythonic'\
       'program can serve as an indexing platform for'\
       'finding words in a paragraph. It can give'\
       'values as to where the word is located with the'\
       'different examples as stated'

find_the_word = re.finditer('as', text)

for match in find_the_word:
    print('start {}, end {}, search string \'{}\''.
          format(match.start(), match.end(), match.group()))

Output:

start 63, end 65, search string 'as'
start 140, end 142, search string 'as'
start 200, end 202, search string 'as'

list_num = ['000231512-n', '1209123100000-n00000',
             'alphanumeric0000', '000alphanumeric']
 
print([item.strip('0') for item in list_num])   # Remove leading + trailing '0'
print([item.lstrip('0') for item in list_num])  # Remove leading '0'
print([item.rstrip('0') for item in list_num])  # Remove trailing '0'

Output:

['231512-n', '1209123100000-n', 'alphanumeric', 'alphanumeric']
['231512-n', '1209123100000-n00000', 'alphanumeric0000', 'alphanumeric']
['000231512-n', '1209123100000-n', 'alphanumeric', '000alphanumeric']

s = 'line 1\nline 2\nline without newline'
l = s.splitlines(True)

print(l)

Output:

['line 1\n', 'line 2\n', 'line without newline']

s = 'canada'
s = "".join([x.upper() if i % 2 != 0 else x for i, x in enumerate(s)])

print(s)

Output:

cAnAdA

import calendar


def last_business_day_in_month(year: int, month: int) -> int:
    return max(calendar.monthcalendar(year, month)[-1:][0][:5])


print(last_business_day_in_month(2021, 1))
print(last_business_day_in_month(2021, 2))
print(last_business_day_in_month(2021, 3))
print(last_business_day_in_month(2021, 4))
print(last_business_day_in_month(2021, 5))

Output:

def compare_strings(a, b):
    result = True
    if len(a) != len(b):
        print('string lengths do not match!')
    for i, (x, y) in enumerate(zip(a, b)):
        if x != y:
            print(f'char miss-match {x, y} in element {i}')
            result = False
    if result:
        print('strings match!')
    return result



print(compare_strings("canada", "japan"))

Output:

string lengths do not match!
char miss-match ('c', 'j') in element 0
char miss-match ('n', 'p') in element 2
char miss-match ('d', 'n') in element 4
False

print('canada' * 3)
print(*3 * ('canada',), sep='-')

Output:

canadacanadacanada
canada-canada-canada

def nth_replace(s, old, new, occurrence):
    li = s.rsplit(old, occurrence)
    return new.join(li)


str1 = "caars caars caars caars caars"
str2 = nth_replace(str1, 'aa', 'a', 1)
print(str2)

str2 = nth_replace(str1, 'aa', 'a', 2)
print(str2)

str2 = nth_replace(str1, 'aa', 'a', 3)
print(str2)

Output:

caars caars caars caars cars
caars caars caars cars cars
caars caars cars cars cars

year = '2020'

print('test' + str(year))
print('test' + year.__str__())

Output:

test2020
test2020

s = 'canada_japan_australia_us_uk'
l = s.split('_', 0)
print(l)

l = s.split('_', 1)
print(l)

l = s.split('_', 2)
print(l)

Output:

['canada_japan_australia_us_uk']
['canada', 'japan_australia_us_uk']
['canada', 'japan', 'australia_us_uk']

text = ['johnny rotten', 'eddie vedder', 'kurt kobain',
           'chris cornell', 'micheal phillip jagger']

text = [txt.capitalize() for txt in text]
print(text)

Output:

['Johnny rotten', 'Eddie vedder', 'Kurt kobain', 'Chris cornell', 'Micheal phillip jagger']

test = 'Position of a character'
print(test.find('of'))
print(test.find('a'))

Output:

9
12

data = [1148, 39, 365, 6, 56524]

for element in data:
    print("{:>5}".format(element))

Output:

def after(s1, s2):
    index = s1.find(s2)
    if index != -1 and index + len(s2) < len(s1):
        return s1[index + len(s2):]
    else:
        return None

s1 = "canada"
s2 = "can"

print(after(s1, s2))

Output:

ada

test = 'canada'
print('$' * len(test))

Output:

$$$$$$

def find_str(s, char):
    index = 0

    if char in s:
        c = char[0]
        for ch in s:
            if ch == c:
                if s[index:index + len(char)] == char:
                    return index

            index += 1

    return -1


print(find_str("India Canada Japan", "Canada"))
print(find_str("India Canada Japan", "cana"))
print(find_str("India Canada Japan", "Uae"))

Output:

6
-1
-1

number = '+91 874854778'

print(number.strip('+'))
print(number.lstrip('+91'))

Output:

91 874854778
 874854778

string = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

x = 3
res = [string[y - x:y] for y in range(x, len(string) + x, x)]
print(res)

Output:

['ABC', 'DEF', 'GHI', 'JKL', 'MNO', 'PQR', 'STU', 'VWX', 'YZ']

s = "xxxyyyzzz"

# convert to list
a = list(s)

# change every third letter in place with a list comprehension
a[2::3] = [x.upper() for x in a[2::3]]

# back to a string
s = ''.join(a)

print(s)

Output:

xxXyyYzzZ

txt = "Canada\tis\ta\tgreat\tcountry"

print(txt)
print(txt.expandtabs())
print(txt.expandtabs(2))
print(txt.expandtabs(4))
print(txt.expandtabs(10))

Output:

Canada    is    a    great    country
Canada  is      a       great   country
Canada  is  a great country
Canada  is  a   great   country
Canada    is        a         great     country

str1 = "Can"
str2 = "Canada"
print(str1 in str2)
print(str1.startswith(str2))
print(str2.startswith(str1))

print(str1.endswith(str2))

str3 = "CAN"
print(str3 in str2)

Output:

True
False
True
False
False

n = [-2, -8, 1, -10, 40]

num = ["{1:0{0}d}".format(2 if x >= 0 else 3, x) for x in n]
print(num)

Output:

n = [-2, -8, 1, -10, 40]

num = ["{1:0{0}d}".format(2 if x >= 0 else 3, x) for x in n]
print(num)

str1 = "caars caars caars"
str2 = str1.replace('aa', 'a', 1)

print(str2)

Output:

cars caars caars

variable = 'Hello'
print('This is the Test File' + variable)

variable = '10'
print('This is the Test File' + str(variable))

Output:

This is the Test File Hello
This is the Test File 10

s = 'str1, str2, str3, str4'
l = s.split(',')
 
print(l)

Output:

['str1', 'str2', 'str3', 'str4']

x = "canada japan australia"

x = x[:1].upper() + x[1:]
print(x)

x= x.capitalize()
print(x)

x= x.title()
print(x)

Output:

Canada japan australia
Canada japan australia
Canada Japan Australia

data = b'\x00\x00\x00\x00\x00\x00'

info = [data[i:i + 2] for i in range(0, len(data), 2)]
print(info)

Output:

[b'\x00\x00', b'\x00\x00', b'\x00\x00']

string = 'Hi'.ljust(10)
print(string)

string = 'Hi'.rjust(10)
print(string)

string = '{0: ^20}'.format('Hi')
print(string)

string = '{message: >16}'.format(message='Hi')
print(string)

string = '{message: <16}'.format(message='Hi')
print(string)

string = '{message: <{width}}'.format(message='Hi', width=20)
print(string)

Output:

from collections import Counter

def shared_chars(s1, s2):
    return sum((Counter(s1) & Counter(s2)).values())

print(shared_chars('car', 'carts'))

Output:

import re

s = "ABC24.00XYZ58.28PQR"
s = re.sub("[A-Za-z]+", lambda group: "" + group[0] +" ", s)
print(s.strip())

Output:

ABC 24.00 XYZ 58.28 PQR

s = 'canada'
print(s.rstrip())  # For whitespace on the right side use rstrip.
print(s.lstrip())  # For whitespace on the left side lstrip.
print(s.strip())  # For whitespace from both side.
 
 
s = '\t  canada'
print(s.strip('\t'))  # This will strip any space, \t, \n, or \r characters from the left-hand side, right-hand side, or both sides of the string.

Output:

   canada
canada  
canada
          canada

s = 'canada-japan-australia-uae-india'
l = s.rsplit('-', 1)[1]
print(l)

Output:

india

string = "canada"

result = string[:-1] + string[-1].upper()
print(result)

result = string[::-1].title()[::-1]
print(result)

Output:

canadA
canadA

txt = "canada"

x = txt.center(20)

print(x)

Output:

       canada

x = 4
w = 5
print('{number:0{width}d}'.format(width=w, number=x))

Output:

a = "This is the island of istanbul"
print (a.replace("is" , "was", 1))
print (a.replace("is" , "was", 2))
print (a.replace("is" , "was"))

Output:

Thwas is the island of istanbul
Thwas was the island of istanbul
Thwas was the wasland of wastanbul

test = 'Position of a character'
print(test.find('of'))
print(test.find('a'))

Output:

9
12

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

string = 'This + is + a + string'
x = string.find('+', 4)
print(x)

x = string.find('+', 10)
print(x)

Output:

5
10

x = 'canada'
x = x.upper()

print(x)

Output:

CANADA

import re

l = re.split(r'[$-]+', 'canada$-india$-japan$-uae')
print(l)

Output:

['canada', 'india', 'japan', 'uae']

string1 = "Canada"
print(len(string1))

string2 = "Canada"
print(len(string2))

string3 = "Canada"
print(len(string3))

Output:

6
8
8


x = 'canada'
y = ''.join(['ca','na','da'])
print(x == y)
print(x is y)
 
x = [1, 2, 3]
y = [1, 2, 3]
print(x == y)
print(x is y)
 
z = y
print(z is y)

Output:

True
False
True
False
True

import re

text = ['123', 'abc', '4x5x6', '7.2volt', '60BTU',
        '20v', '4*5', '24in', 'google.com-1.2', '1.2.3']

pattern = r'(-?[0-9]+\.?[0-9]*)'
for data in text:
    print(repr(data), repr(' '.join(segment for segment in re.split(pattern, data) if segment)))

Output:

'123' '123'
'abc' 'abc'
'4x5x6' '4 x 5 x 6'
'7.2volt' '7.2 volt'
'60BTU' '60 BTU'
'20v' '20 v'
'4*5' '4 * 5'
'24in' '24 in'
'google.com-1.2' 'google.com -1.2'
'1.2.3' '1.2 . 3'

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

Output:

['canada', 'japan australia']

indices = set([0, 7, 14, 18])

s = "i love canada and japan"
print("".join(c.upper() if i in indices else c for i, c in enumerate(s)))

Output:

I love Canada And Japan

import re

thestring = "a,b,c d!e.f\ncanada\tjapan&germany"
listitems = re.findall('\w+', thestring)

for item in listitems:
    print(item)

Output:

a
b
c
d
e
f
canada
japan
germany

str1 = 'caars'
str2 = 'rats'
str3 = 'racs'

print(set(str1)==set(str2))
print(set(str1)==set(str3))

Output:

False
True

import re
 
 
string_test = "Ethnic (279), Responses (3), 2016 Census - 25% Sample"
print(re.findall(r"[\w']+", string_test))
 
def split_by_char(s, seps):
    res = [s]
    for sep in seps:
        s, res = res, []
        for seq in s:
            res += seq.split(sep)
    return res
 
print(split_by_char(string_test, ['','(',')',',']))

Output:

['Ethnic', '279', 'Responses', '3', '2016', 'Census', '25', 'Sample']

['Ethnic', '','279','', '','Responses','', '3', '','', '2016', 'Census', '-', '25%', 'Sample']

# Example 1
str1 = "Can"
str2 = "ada"
str3 = str1 + str2
print(str3)
 
# Example 2
str4 = 'Ca'
str4 += 'na'
str4 += 'da'
print(str4)
 
# Example 3
join_str = "".join((str1, str2))
print(join_str)
 
# Example 4
str_add = str1.__add__(str2)
print(str_add)

Output:

Canada

Canada

Canada

Canada

# Example 1
test_str = "Canada"
for i, c in enumerate(test_str):
        print(i, c)
 
print("------------------------")
 
# Example 2
indx = 0
while indx < len(test_str):
        print(indx, test_str[indx])
        indx += 1
 
print("------------------------")
# Example 3
for char in test_str:
        print(char)

Output:

0 C

1 a

2 n

.......

d

a

import string
import re
 
# Example 1
s = "Ethnic (279), Responses (3), 2016 Census - 25% Sample"
out = re.sub(r'[^\w\s]', '', s)
print(out)
 
# Example 2
s = "Ethnic (279), Responses (3), 2016 Census - 25% Sample"
for p in string.punctuation:
        s = s.replace(p, "")
print(s)
 
# Example 3
s = "Ethnic (279), Responses (3), 2016 Census - 25% Sample"
out = re.sub('[%s]' % re.escape(string.punctuation), '', s)
print(out)

Output:

Ethnic 279 Responses 3 2016 Census  25 Sample

Ethnic 279 Responses 3 2016 Census  25 Sample

Ethnic 279 Responses 3 2016 Census  25 Sample

list_exp = ['Ca', 'na', 'da']
print(type(list_exp))
 
# Example 1
str_exp1 = ''.join(list_exp)
print(type(str_exp1))
print(str_exp1)
 
# Example 2
str_exp2 = ''.join(str(e) for e in list_exp)
print(type(str_exp2))
print(str_exp2)
 
# Example 3
str_exp3 = ''.join(map(str, list_exp))
print(type(str_exp2))
print(str_exp2)

Output:

class 'list'

class 'str'

Canada

class 'str'

Canada

class 'str'

Canada

import json
 
 
# list with dict a simple Json format
json_exp = \
    [{"id": "12", "name": "Mark"}, {"id": "13", "name": "Rock", "date": None}]
print(type(json_exp))
 
str_conv = json.dumps(json_exp)  # string
print(type(str_conv))
print(str_conv)

Output:

class 'list'

class 'str'

[{"id": "12", "name": "Mark"}, {"id": "13", "name": "Rock", "date": null}]

# Example 1
str_list = ["Japan", "Canada", "Australia"]
print(str_list)
str_list.sort()
print(str_list)
 
# Example 2
str_list = ["Japan", "Canada", "Australia"]
for x in sorted(str_list):
    print(x)
 
# Example 3
str_var = "Canada"
strlist = sorted(str_var)
print(strlist)

Output:

['Japan', 'Canada', 'Australia']

['Australia', 'Canada', 'Japan']

Australia

Canada

Japan

['C', 'a', 'a', 'a', 'd', 'n']

import re
 
 
exp_str = "Python Programming"
 
# Example 1
if re.match(r'^Python', exp_str):
    print(True)
else:
    print(False)
 
# Example 2
result = exp_str.startswith("Python")
print(result)

Output:

True

True

str1 = "AAAA"
str2 = "BBBBBBBBB"
 
# Example 1
mesh = "".join(i + j for i, j in zip(str1, str2))
print("Example 1:", mesh)
 
# Example 2
min_len = min(len(str1), len(str2))
mesh = [''] * min_len * 2
mesh[::2] = str1[:min_len]
mesh[1::2] = str2[:min_len]
print("Example 2:", ''.join(mesh))
 
# Example 3
mesh = ''.join(''.join(item) for item in zip(str1, str2))
print("Example 3:", mesh)
 
# Example 4
min_len = min(len(str1), len(str2))
mesh = [''] * min_len * 2
mesh[::2] = str1[:min_len]
mesh[1::2] = str2[:min_len]
mesh += str1[min_len:] + str2[min_len:]
print("Example 4:", ''.join(mesh))

Output:

Example 1: ABABABAB

Example 2: ABABABAB

Example 3: ABABABAB

Example 4: ABABABABBBBBB

本文由 mdnice 多平台公布

字符串切片操作

查看字符串是否为空

计算字符串中字符呈现次数的多种办法

将 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 在换行符上拆分