Python学习-字符串操作

字符串的常用操作包括但不限于以下操作：

字符串的替换、删除、截取、复制、连接、比较、查找、分割等

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# @Time    : 2018/5/2 16:41
# @Author  : yang
# @File    : str.py
# @Software: PyCharm
#字符串操作
name = 'my \tname is {name},and i am {year} old'
print(name.capitalize())    #capitalize：将字符串的首字母大写：My     name is {name},and i am {year} old
print(name.count('a'))     #5
print(name.center(50,'*'))      #将字符串居中，并在两端填充'*'：******my     name is {name},and i am {year} old******
print(name.endswith('ex'))       #判断以什么结尾，若正确，则打印输出'True'，否则'False'
print(name.expandtabs(tabsize=30))     #my                            name is {name},and i am {year} old
print(name.expandtabs(30))     #my                            name is {name},and i am {year} old
print(name.find('name'))     #查找'name'
print(name.format(name='alex',year=26))     #格式化输出:my name is alex,and i am 26 old
print(name.format_map({'name':'alex','year':26}))     #格式化输出
print(name.isalnum())    #False
#isalnum:包含所有的英文字符和0-9
print(name.isalpha())    #是否为纯英文字符
print('12'.isdecimal())      #是否为十进制
print('28'.isdigit())     #是否为整数
print('123'.isidentifier())     #判断是不是一个合法的标识符（变量名）：False，变量名不能以数字开头
print('a123'.isidentifier())     #判断是不是一个合法的标识符（变量名）：True，变量名以英文字母开头
print('a 123'.isidentifier())     #判断是不是一个合法的标识符（变量名）：False，变量名中间不能有空格
print('我123'.isidentifier())     #判断是不是一个合法的标识符（变量名）：True，变量名可以采用中文
print('a Bc'.islower())       #判断一个字符串是否全部为小写
print('1.23'.isnumeric())       #判断是否为数字（只有数字）：False
print('333'.isnumeric())       #判断是否为数字（只有数字）：True
print('my name is'.istitle())    #False
print('My Name Is'.istitle())    #True:判断字符串中各元素首字母是否都大写
print('My Name Is'.isprintable())   #True
#判断一个字符串是否为可以打印的，在字符串中没意义，字符串都是可以打印的，当为tty file时，
print('My Name Is'.isupper())   #False
print('MY NAME IS'.isupper())   #True
#join
print(''.join(['1','2','3']))    #str:123
print(''.join(('1','2','3')))     #str:123
print(','.join(['1','2','3']))    #1,2,3
print('+'.join(['1','2','3']))    #1+2+3
print(type(''.join(('1','2','3'))))
print(type(''.join(['1','2','3'])))
print(name.ljust(50,'*'))     #my     name is {name},and i am {year} old************
print(name.rjust(50,'*'))     #************my     name is {name},and i am {year} old
print('------')
print('\nalex\n'.lstrip())     #从左边去掉回车和空格
print('------')
print('\nalex\n'.rstrip())     #从右边去掉回车和空格
print('\nalex\n'.strip())     #去掉两边的回车和空格
print('----')

p = str.maketrans('abcdefli','123456$@')    #maketrans:用于创建字符映射的转换表
print('alex li'.translate(p))    #1$5x $@

print('alex li'.replace('l','L'))   #aLex li
print('alex li'.rfind('l'))   #从左往右数，最右边的那个对应字符的下标，'alex li'中'l'最有边的下标为5
print('alex li yang'.split())     #['alex', 'li', 'yang']，默认分隔符为空格
print('alex li'.split('l'))     #['a', 'ex ', 'i']，此时'l'被当做了分隔符
print('1+2+3+4'.split('+'))   #['1', '2', '3', '4']
print('1+2\n+3+4'.splitlines())   #分隔符为换行符：['1+2', '+3+4']
print('Alex Li'.swapcase())   #aLEX lI，将字符串中的大写变为小写，小写变为大写
print('alex li'.zfill(50))    #指定宽度，不够的用'0'填充：0000000000000000000000000000000000000000000alex li

#capitalize：字符串首字母大写：capitalize-将字符串的首字母大写，其他字母小写
name = 'swhthaitun'
name.capitalize()
print(name.capitalize())

#casefold：字符串所有字母小写：casefold-将字符串中所有的大写字符转换成小写字符
name = 'HelloWorld'
name.casefold()    #将所有语言的字符转换为小写
name.lower()     #lower只对ASCII有效，对其他语言无效
print(name.casefold())
print(name.lower())

#center：字符串宽度填充，使用原有字符串+填充字符构成指定长度的新的字符串
name = 'swhthaitun'
#在原有字符串两端填充相同数目的字符
print(name.center(15))
print(name.center(16,'*'))
name2 = 'HelloWorld'
print(name.center(20,'*'))

#count：统计某个字符在字符串中出现的次数，或者是在字符串的指定区间内完成上述操作
name = 'swhthaitun'
result = name.count('h')    
print(result)     #2
result2 = name.count('h',0,3)
print(result2)    #1
name2 = 'HelloWorld'
result3 = name2.count('W')    #不能换成'w'，Python对大小写敏感
print(result3)    #1

#encode：对字符串进行编码操作
name = 'swhthaitun'
name.encode()
print(name.encode())    #b'swhthaitun'

#endwith：判断字符串是否以某个字符或字符串结尾，返回值为布尔值
name = 'swhthaitun'
result1 = name.endswith('s')
print(result1)   #False
result2 = name.endswith('n')
print(result2)   #True
result3 = name.endswith('tun')
print(result3)   #True

#expandtabs：将制表符'\t'转换成制定宽度的tab键分割，默认的tabsize=8
li = 'sw\tht'
li.expandtabs(4)
print(li.expandtabs(4))     #sw  ht
print(li.expandtabs())     #sw      ht

#find：在字符串中查找指定字符串，找不到事返回-1
name = 'swht'
name.find('s')
name.find('h')
name.find('a')
print(name.find('s'),name.find('h'),name.find('a'))   #0 2 -1

#format：格式化输出字符串
li = "I'm {},{}"    #其中{}为占位符
result = li.format('swht','欢迎来中国')
print(result)    #I'm swht,欢迎来中国

#__contains__：判断字符串中是否包含某段字符，返回值为布尔值
name = 'swhtkkskjj'
result = name.__contains__('swht')
print(result)    #True

#index：在字符串中查找指定的字符串，找不到时直接报错
name = 'swhthaitun'
result1 = name.index('h')
#result2 = name.index('m')
print(result1)    #2
#print(result2)     #字符串中没有'm'，异常报错

#join：字符串拼接
name = 'swhthaitun'
'*'.join(name)
name.join('ab')
print(name.join('ab'))    #aswhthaitunb
print('*'.join(name))     #s*w*h*t*h*a*i*t*u*n

#isalnum：检查判断字符串是否包含字母或数字
name1 = 'swhthaitun'
name2 = '12345'
result1 = name1.isalnum()
result2 = name2.isalnum()
print(result1)    #True
print(result2)    #True

#isalpha：检测判断字符串是否完全由字母组成
name = 'swhthaitun'
result = name.isalpha()
print(result)    #True

#isdecimal：检查字符串是否只包含十进制字符
name = '123456'
result = name.isdecimal()
print(result)     #True

# isdecimal()
# True: Unicode数字，，全角数字（双字节）
# False: 罗马数字，汉字数字
# Error: byte数字（单字节）

#isdigit：检测字符串是否只有数字组成
name = '12345'
result = name.isdigit()
print(result)    #True

# isdigit()
# True: Unicode数字，byte数字（单字节），全角数字（双字节），罗马数字
# False: 汉字数字
# Error: 无

#isidentifier：检测字符串是否以字母开头
name = 'swhthaitun'
result = name.isidentifier()
print(result)   #True

name2 = '2swhthaitun'
result2 = name2.isidentifier()
print(result2)     #False 

#isnumeric：检测字符串是否只有数字组成，这种方法只针对于unicode对象
name = 'swhthaitun'
result = name.isnumeric()
print(result)     #False

name2 = '123545'
result2 = name2.isnumeric()
print(result2)    #True  

#isprintable：判断字符串中所有字符是否都属于可见字符
name = '\tPuppy'
result = name.isprintable()
print(result)      #False

name2 = 'swhthaitun'
result2 = name2.isprintable()
print(result2)      #True   

#isspace：检测字符串是否全部为空格
#istitle：检测字符串中每一个连续的字符串的的首字母是否大写
#name = 'Puppy'    #True
#name = 'Puppy Abc'    #True
#name = '   Puppy'    #True
# name = 'a Puppy'    #False
# print(name.istitle())

#isupper：判断字符串中所有的字母是否都是大写字母
#lower：将所有字母转换为小写字母
#lstrip：去除字符串左边开头的空格
#rstrip：去除字符串右边结尾的空格
#strip：去除字符串两边的空格

#maketrans：用于创建字符映射的转换表，对于接收两个参数的调用方式，第一个参数是字符串，表示需要转换的字符
#第二个参数表示字符串需要转换的目标（没怎么看懂）
intab = 'swhtr'
outtab = '12345'
name = 'swhtr hjjksknsnjmk'
print(name.maketrans(intab,outtab))   #{115: 49, 119: 50, 104: 51, 116: 52, 114: 53}

#partition：根据指定的分隔符对字符串进行分割
name = 'ls'
li = 'hhsslswhtolljm'
result = li.partition(name)
print(result)     #('hhss', 'ls', 'whtolljm')

#replace：将字符串中的old（旧字符串）替换成new（新字符串），如果指定第三个参数max，则替换不超过max次
'''语法：str.replace(old, new[, max])
参数：old -- 将被替换的子字符串。
      new -- 新字符串，用于替换old子字符串。
      max -- 可选字符串, 替换不超过 max 次'''
str = 'this is string example.....wow!!! this is really string'
str_new = str.replace('is','was')
str_new2 = str.replace('is','was',3)
print(str_new)    #thwas was string example.....wow!!! thwas was really string
print(str_new2)   #thwas was string example.....wow!!! thwas is really string  

#split：字符串分割，默认是空格，
#语法：str.split(str="", num=string.count(str)).
#str -- 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。num--分割次数
name = 'swhthaitun'
result = name.split('h')
result2 = name.split('h',1)
print(result)   #['sw', 't', 'aitun']
print(result2)  #['sw', 'thaitun']

#__add__：在字符串后面增加指定的字符或者字符串
name = 'swht'
result = name.__add__('e')
print(result)     #swhte
li = 'hjh'
result2 = name.__add__(li)
print(result2)     #swhthjh

#__eq__：判断字符串是否相等，返回值为布尔
name = 'swht'
li = 'test'
result = name.__eq__(li)
print(result)    #False