判断某个字符出现的次数

Python中有几种方法可以统计字符串中的特定字符出现次数:

1. 使用count()函数:

string = "Hello World"
char = "o"
count = string.count(char)
print(count) # 2

2. 用for循环逐个匹配:

string = "Hello World"
char = "o"
count = 0
for c in string:
   if c == char:
       count += 1
print(count) # 2

3. 使用正则表达式:

import re
string = "Hello World"
char = "o"
count = len(re.findall(char, string))
print(count) # 2

4. 使用列表推导式:

string = "Hello World"  
char = "o"
count = sum([1 for c in string if c == char])
print(count) # 2

5. 使用collections.Counter计数:

from collections import Counter
string = "Hello World"
count = Counter(string)[char]
print(count) # 2

以上几种方式都是Python标准的统计字符出现次数的方法。选择哪一种主要看具体业务场景和个人习惯。

判断某个字符串中是否存在某个字符或者位置

in

string = "Hello World"
character = 'o'
if character in string:
    print("字符串中包含该字符")
else:
    print("字符串中不包含该字符")

find

find() 方法用于检索字符串中是否包含目标字符串，如果包含，则返回第一次出现该字符串的索引；反之，则返回 -1。

find() 方法的语法格式如下：

str.find(sub[,start[,end]])

此格式中各参数的含义如下：

• str：表示原字符串；
• sub：表示要检索的目标字符串；
• start：表示开始检索的起始位置。如果不指定，则默认从头开始检索；
• end：表示结束检索的结束位置。如果不指定，则默认一直检索到结尾。

index()

string.index(char)

示例：

string = "Hello, world!"
char = "o"
position = string.index(char)
print("Character '{}' found at position: {}".format(char, position))

find()和index()方法都会返回字符在字符串中第一次出现的位置。如果字符不存在于字符串中，find()方法会返回-1，而index()方法会引发一个ValueError异常。

字母大小写

字符串是否是字母，不区分大小写 isalpha()

def is_all_alpha(string):
    return string.isalpha()
    
# 测试样例
print(is_all_alpha("HELLO"))   # True
print(is_all_alpha("Hello"))   # True
print(is_all_alpha("1234567890"))   # False

isalpha() 方法是 Python 字符串对象的一个方法，用于检查字符串中是否只包含字母字符（即 A-Z 和 a-z）。

以下是一个示例：

pythonCopy code
s1 = "Hello"
s2 = "Hello123"
s3 = "123"

print(s1.isalpha())  # 输出 True
print(s2.isalpha())  # 输出 False，因为字符串中包含数字
print(s3.isalpha())  # 输出 False，因为字符串中包含数字

字符串是否全部大写 isupper()

def is_all_uppercase(string):
    return string.isupper()
    
# 测试样例
print(is_all_uppercase("HELLO"))   # True
print(is_all_uppercase("Hello"))   # False
print(is_all_uppercase("1234567890"))   # False

字符串是否全部小写 islower()

def is_all_lowercase(string):
    return string.islower()
    
# 测试样例
print(is_all_lowercase("hello"))   # True
print(is_all_lowercase("Hello"))   # False
print(is_all_lowercase("1234567890"))   # False

大写字母转小写字母

使用lower()方法来将字符串中的大写字母转换为小写字母。下面是一个简单的示例：

string = "Hello, World!"
lowercase_string = string.lower()
print(lowercase_string)

小写字母转大写字母 使用upper()方法将字符串中的小写字母转换为大写字母。下面是一个示例：

string = "hello, world!"
uppercase_string = string.upper()
print(uppercase_string)

字符串输出

str.join(iterable)

返回一个由 iterable 中的字符串拼接而成的字符串。 如果 iterable 中存在任何非字符串值包括 bytes 对象则会引发 TypeError。 调用该方法的字符串将作为元素之间的分隔。

join()函数

语法： 'str'.join(seq)

• 参数说明

  • str：分隔符。可以为空

  • seq：要连接的元素序列、字符串、元组、字典 上面的语法即：以str作为分隔符，将seq所有的元素合并成一个新的字符串

• 返回值：返回一个以分隔符sep连接各个元素后生成的字符串

os.path.join()函数

语法： os.path.join(path1[,path2[,......]])

• 返回值：将多个路径组合后返回

注：第一个绝对路径之前的参数将被忽略

#对序列进行操作（分别使用' '与':'作为分隔符）

>>> seq1 = ['hello','good','boy','doiido']
>>> print ' '.join(seq1)
hello good boy doiido
>>> print ':'.join(seq1)
hello:good:boy:doiido


#对字符串进行操作

>>> seq2 = "hello good boy doiido"
>>> print ':'.join(seq2)
h:e:l:l:o: :g:o:o:d: :b:o:y: :d:o:i:i:d:o


#对元组进行操作

>>> seq3 = ('hello','good','boy','doiido')
>>> print ':'.join(seq3)
hello:good:boy:doiido


#对字典进行操作

>>> seq4 = {'hello':1,'good':2,'boy':3,'doiido':4}
>>> print ':'.join(seq4)
boy:good:doiido:hello


#合并目录

>>> import os
>>> os.path.join('/hello/','good/boy/','doiido')
'/hello/good/boy/doiido'

字符串替换

replace

# 原始字符串
original_string = "Hello, world! Hello, Python!"

# 将 "Hello" 替换为 "Hi"
new_string = original_string.replace("Hello", "Hi")

# 输出替换后的字符串
print(new_string)

利用正则sub方法也能起到替换效果：

import re

def replace_non_alphabetic_chars(string):
    return re.sub(r'[^a-zA-Z]', ' ', string)

# 测试
string = "Hello, World! 123"
result = replace_non_alphabetic_chars(string)
print(result)  # 输出 "Hello  World   "

在这个示例中，我们定义了一个函数 replace_non_alphabetic_chars()，它接受一个字符串作为参数，并使用正则表达式 r'[^a-zA-Z]' 来匹配所有非字母字符。然后，我们使用 re.sub() 函数将匹配到的非字母字符替换为空格。最后，我们返回替换后的字符串。

字符串补位

zfill()

zfill() 方法是一个字符串方法，它可以将字符串的左侧用零填充至指定的宽度，以达到指定长度。

s = "123"
padded_s = s.zfill(5)
print(padded_s)  # 输出 "00123"

在这个示例中，我们使用 zfill() 方法将字符串 "123" 左侧填充零，使其长度达到 5。由于原始字符串的长度不足 5，因此在字符串左侧填充了两个零，最终得到了 "00123"。多用于二进制补0。

rjust()和ljust()

zfill() 方法只能填充零。如果你想要填充其他字符，你可以使用字符串的 rjust() 或 ljust() 方法。

• rjust() 方法用指定字符（默认为空格）填充字符串的左侧，使其达到指定长度。
• ljust() 方法用指定字符（默认为空格）填充字符串的右侧，使其达到指定长度。

s = "123"
padded_s = s.rjust(5, '0')  # 使用 '0' 填充字符串左侧，使其长度达到 5
print(padded_s)  # 输出 "00123"

padded_s = s.rjust(5, '*')  # 使用 '*' 填充字符串左侧，使其长度达到 5
print(padded_s)  # 输出 "**123"

format

使用字符串的格式化方法。

s = "123"
padded_s = "{:<5}".format(s)
print(padded_s)  # 输出 "123  "

在这个示例中，我们使用字符串的格式化方法将字符串 "123" 左对齐并填充空格，使其长度达到 5。因为原始字符串长度为 3，所以在字符串右侧填充了两个空格，最终得到了 "123 "。

示例2：

s = "123"
padded_s = "{:0>5}".format(s)
print(padded_s)  # 输出 "00123"