Python 字符串操作详细举例

最新推荐文章于 2023-01-04 01:09:45 发布
SHADOW_DIUDIU
最新推荐文章于 2023-01-04 01:09:45 发布
阅读量922
点赞数
分类专栏： python 文章标签：闭包 python eclipse string
本文链接：https://blog.csdn.net/jsagnoy/article/details/39549073
版权
python 专栏收录该内容
1 篇文章 0 订阅
订阅专栏
# -*- coding: utf-8 -*-
'''
Created on 2014-9-25
Python 字符串操作详细 举例
Python version: 3.4
@author: jingshuai
'''

#单引号
str_single_quotes = 'blog: http://blog.csdn.net/jsagnoy'
#双引号
str_double_quotes = "blog: http://blog.csdn.net/jsagnoy"

print ("## 单引号: " + str_single_quotes)
print ("## 双引号: " + str_double_quotes)

#用\分行
str_multi_line = "blog:\
http://blog.csdn.net/jsagnoy"

print ("## 使用\\分行: " + str_multi_line)

#用\n换行显示
str_n = "blog:\nhttp://www.csdn.net/jsagnoy"

print ("## 使用\\n换行: " + str_n)

#三引号"""显示多行
str_more_quotes = """
my 
name
is
jingshuai
"""

print ("## 使用三引号\"\"\"n显示多行: " + str_more_quotes)

#用r或R显示原貌
str_r = r"我是\
jingshuai"

str_R = R"我是\njingshuai"

print ("## 用r显示原貌: " + str_r)
print ("## 用R显示原貌: " + str_R)

#使用u或U使之成为Unicode字符串
str_u = u'景\u0020帅'

print ("## 使用u或U使之成为Unicode字符串: " + str_u)

#注意: 字符串是无法改变的，无论你对它做什么操作，你总是创建了一个新的字符串对象，而不是改变了原有的字符串
#
#字符串是字符的序列，所以也可以通过索引的方法访问单个字符

test_str_index = "我是景帅"

print ("## index 0: " + test_str_index[0])
print ("## index -1: " + test_str_index[-1])

#使用切片访问字任串的一部分
print ("## [0:3]: " + test_str_index[0:3])
print ("## [2:]: " + test_str_index[2:])
print ("## [-1:]: " + test_str_index[-1:])


print ("## 遍历整个字符串: ")
for t in test_str_index:print (t)

#构建另一个序列
str_list = list(test_str_index) #['我', '是', '景', '帅']

#字符串拼接
str_add = test_str_index + '哈哈'
print ("## 字符串拼接" + str_add)

print("## 使用乘法对字符串多次重复: " + '景帅' * 3)

#使用s.isdigit()来判断字符串是否全为数字 
test_isdigit_true = '782670627'
test_isdigit_false =  'abcd123'
test_isdigit_empty = ''

if test_isdigit_true.isdigit():
    print (test_isdigit_true + " 字符串都是数字")

if not test_isdigit_false.isdigit():
    print (test_isdigit_false + " 字符串不都是数字")

if not test_isdigit_empty.isdigit():
    print ("字符串为空")

if len(test_isdigit_empty) == 0:
    print ("字符串为空")

#将字符串转换成大写
test_upper = test_isdigit_false.upper()
print(test_upper)

#将字符串转换成小写
test_lower = test_upper.lower()
print(test_lower)

#测试某个字符在字符串中出现的次数
test_count = "my name is my name"
print ("## 测试某个字符在字符串中出现的次数: "+ str(test_count.count("name")))

#使用s.splitlines()将一个有多行文本的字符串分隔成多行字符串并入一个列表中
one_large_str = "chu he ri dang wu, \n han di he xia tu"
list_lines = one_large_str.splitlines() #['chu he ri dang wu, ', ' han di he xia tu']
print (list_lines)

#使用'\n'.join()重新生成一个庞大的单字符串
one_large_str2 = '\n'.join(list_lines)
print (one_large_str2)


js_str = "jingshuai"
#循环输出   for
for x in js_str:
    print(x)
#循环输出 for 2
for x in range(0,len(js_str)):
    print(js_str[x])
#遍历list 1
js_list = list(js_str)
print(js_list)
#遍历list 2
for x in js_list:
    print(x)
    
"""
字符串参数化操作
"""
import string

info = """姓名: $name,
年龄: $age,
博客: $blog,
http://${weibo}
"""
#string.Template(template)
info_template = string.Template(info)

#以字典的方式一一赋值
info_dic={'name':'小明','age':25,'blog':'http://blog.csdn.net/jsagnoy','weibo':"http://weibo.com/u/3928537909"}

#substitute(mapping, **kwds)
print(info_template.substitute(info_dic))

#转成字典后再赋值
info_dic2=dict(name='小明',age=25,blog='http://blog.csdn.net/jsagnoy',weibo='http://weibo.com/u/3928537909')

print(info_template.substitute(info_dic2))

#safe_substitute(mapping, **kwds)
#当我们少一个键(weibo被拿掉了哦)时,查看结果如何
test_safe_substitute=dict(name='小明',age=25,blog='http://blog.csdn.net/jsagnoy')

try:
    print(info_template.substitute(test_safe_substitute))
except KeyError:
    print("error: 映射中没有weibo这个键")
#使用safe_substitute(mapping, **kwds)
print(info_template.safe_substitute(test_safe_substitute))

#locals()提供了基于字典的访问局部变量的方式
info = string.Template('姓名是$name,年龄$age')
name='小明'
age=18
print(info.substitute(locals()))

#使用关键字作为参数替换
info = string.Template('$name今年$age')
for i in range(18,39):
    print(info.substitute(name='小明',age=i))


#对齐方式
print ('|' + '左对齐'.ljust(20) + '|' + '右对齐'.rjust(20) + '|'+ '居中'.center(20) + '|')

#填充对齐
print ('|' + '左对齐'.ljust(20,'#') + '|' + '右对齐'.rjust(20,'#') + '|'+ '居中'.center(20,"#") + '|')

"""
删除空格
"""

test_del_space = '    jingshuai    '


print("#删除字符串左边的空格: |" + test_del_space.lstrip()+'|')
print("#删除字符串右边的空格: |" + test_del_space.rstrip()+'|')
print("#删除字符串两边的空格: |" + test_del_space.strip()+'|')


test_del_char = 'xyxxyy jingshuai yyx'
print('#移除其他字符: |'+test_del_char.strip('xy')+'|')  #移除其他字符: | hejyx |

"""
 合并字符串
"""

smal1 = 'aaa'
smal2 = 'bbb'
smal3 = 'ccc'

#强烈推荐使用，性能好,代码可读性好,可直接将其它格式转为字符串,还可以控制有效位数
print('#使用字符串格式化操作符%: ' + '%s%s连接%s' % (smal1,smal2,smal3)) 

print('#使用加号: ' + smal1 + smal2 + 'lianjie' + smal3)

largeString = ''
smallist = ['aaa','bbb','ccc','ddd']
for x in smallist:
    largeString += x

print ("#使用遍历: " + largeString)

import operator
from functools import reduce  
"""
知识拓展1:
reduce(...)
    reduce(function, sequence[, initial]) -> value
  对sequence中的item顺序迭代调用function，函数必须要有2个参数。要是有第3个参数，则表示初始值，可以继续调用初始值，返回一个值。

知识拓展2:
operator.add(a,b) 
    :return a + b
"""

lstr = reduce(operator.add,smallist,'') #注意:python2中reduce是全局的，不用import,但python3需要import
print ("## 字符串全部相加: "+lstr)

"""
将字符中逐字符或逐词反转
"""

initchars = "我是个好人"
revchars = initchars[::-1]
print ("##通过切片反转字符: " + revchars)

initwords = "字符串 分隔  成   列表 "
revwords = initwords.split( ) #字符串分隔成列表
revwords.reverse() #反转列表
revwords =' '.join(revwords) #重新组合
print("##反转单词: " + revwords)

#一行解决反转单词
revwords2 = ' '.join(initwords.split()[::-1])
print ("##一行解决: " + revwords2)

#反转不改变原先的空格
import re
revwords3 = re.split(r'(\s+)',initwords)
revwords3.reverse()
revwords3 = ''.join(revwords3)
print ("##反转不改变原先的空格: " + revwords3)

#使用反转内建函数reversed
revwords4 = ' '.join(reversed(initwords.split()))

print ("##使用反转内建函数reversed: "+revwords4)

revwords5 = ' '.join(reversed(re.split(r'(\s)+',initwords)))
print ("##使用反转内建函数reversed: "+revwords5)


"""
字符串集合
"""

#方法一:
def containsAny(allstr,childstr):
    for c in allstr:
        if c in childstr: return '包含'
    return '不包含'

allstr = "abcdefg"
childstr = "c"

print(containsAny(allstr,childstr))

#方法二:
def containsAny2(allstr,childstr):
    for item in filter(childstr.__contains__,allstr): #python3里直接使用filter
        return '包含'
    return '不包含'

print (containsAny2(allstr,childstr))

#方法三:
#集合的intersection得到交集
#bool(something),转成布尔型,除了为空返回False,其它只要有值都返回True
def containsAny3(allstr,childstr):
    return bool(set(childstr).intersection(allstr))

print (containsAny3(allstr,childstr))

print (containsAny3(allstr,"h"))


#===========================集合拓展:===========================
print ("## 集合联合union: " )
print (set(childstr).union(set(allstr))) #{'a', 'b', 'c', 'd', 'e'}

print ("## 集合差difference: ")
print (set(allstr).difference(set(childstr))) #{'a', 'b', 'c', 'd'}

print("## 集合交集inetersection: ")
print (set(allstr).intersection(set(childstr))) #{'c'}
print ("## 返回集合中包含的所有属于一个集合且不属于另外一个的元素: ")
print (set(allstr).symmetric_difference(set(childstr))) #{'a', 'e', 'c', 'b'}



#===========================函数拓展:===========================

"""
1. makestrans()字符串映射转换表

语法: str.maketrans(intab, outtab]);

Python maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，
第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
注：两个字符串的长度必须相同，为一一对应的关系。

Python3.4已经没有string.maketrans()了，取而代之的是内建函数:
bytearray.maketrans()、bytes.maketrans()、str.maketrans()
"""

intab = "abcd"
outtab = "1234"
str_trantab = str.maketrans(intab,outtab)

test_str = "csdn blog: http://blog.csdn.net/jsagnoy"

print (test_str.translate(str_trantab)) #



"""

2. translate() 用法

根据参数table给出的表(包含 256 个字符)转换字符串的字符, 要过滤掉的字符放到 del 参数中。

语法:
str.translate(table[, deletechars]);
bytes.translate(table[, delete])   
bytearray.translate(table[, delete])

若给出了delete参数，则将原来的bytes中的属于delete的字符删除，剩下的字符要按照table中给出的映射来进行映射  
"""

# 若table参数为None，则只删除不映射
print(b'http://www.csdn.net/jsagnoy'.translate(None, b'ts'))

# 若table参数不为NONE，则先删除再映射
bytes_tabtrans = bytes.maketrans(b'abcdefghijklmnopqrstuvwxyz', b'ABCDEFGHIJKLMNOPQRSTUVWXYZ') 
print(b'http://www.csdn.net/jsagnoy'.translate(bytes_tabtrans, b'ts'))


"""
3. 闭包: 它是个内层函数,由一个变量来指代,而这个变量对于外层包含它的函数来说是本地变量

"""
def make_adder(addend):  
    def adder(augend):  #adder为内层函数
        return augend + addend  
    return adder  

a = make_adder(1)  #产生一个闭包,addend为1,注意return的是adder
b = make_adder(2)  #产生另一个闭包,addend为2,注意return的是adder
print (a(100), b(100))  #a(100)就相当于adder(100),adden之前为1,因此返回100+1

"""
4. 对translate方法的简单封装,使用起来更加方便
frm : intab
to : outtab
delete : 指定删除字符
keep: 指定保留字符
delete和keep有重叠时，delete优先  
"""
def my_translator(frm = b'', to = b'', delete = b'', keep = None):  

    if len(to) == 1: 
        to = to * len(frm) #如果to只有一个字符,将字符的数量跟frm相等,这样才能一一对应
          
    #构建一个映射表  
    print(frm)
    print(to)
    trans = bytes.maketrans(frm, to)  
      
    if keep is not None: #如果有保留字
        allchars = bytes.maketrans(b'', b'')  # 获取空映射表的所有字符
        keep = keep.translate(allchars, delete)  # 从keep中去除delete中包含的字符，即keep与delete有重合时，优先考虑delete  
        delete = allchars.translate(allchars, keep)  # delete为从全体字符中除去keep，即不在keep的都删掉  
        
          
    # 闭包  
    def my_translate(s):  
        return s.translate(trans, delete)  
      
    return my_translate  
  
  
# 测试my_tranlator
  
# 只保留数字  
digits_only = my_translator(keep = b'0123456789')  
print(digits_only(b'http://www.csdn.net/jsagnoy 520520'))
  
# 删除所有数字  
no_digits = my_translator(delete = b'0123456789')  
print(no_digits(b'http://www.csdn.net/jsagnoy 520520'))
  
# 用*替换数字  
digits_to_hash = my_translator(frm = b'0123456789', to = b'*')  
print(digits_to_hash(b'http://www.csdn.net/jsagnoy 520520'))
  
# delete与keep有重合时的情况  
trans = my_translator(delete = b'20', keep = b'0123456789')  
print(trans(b'http://www.csdn.net/jsagnoy 520520'))