Python之字符串
string(字符串)：6个基本操作，join，split，find，
strip，upper，lower。
字符串一旦创建，不可修改，一但修改或者拼接，都会造成重新生成字符串
a：引号引起来的，就是字符串。
eg: name = “George”
name = ‘George’
name = “““George”””
name = ‘’’George’’’
b：加法
eg: n1 = “wang”
n2 = “George”
n3 = n1 + n2
c：乘法
eg：n1 = “George”
n2 = n1 * 10
print(n2) ===>结果是George打印十次
d：input接收的是字符串类型。
e：字符和子字符串，子序列
eg：name = “George”
“George” 字符串
“G” 字符
“Geo” 子字符串，子序列
******f：upper方法，转大写，isupper（）方法判断是否是大写。
eg：test = “Alex”
v1 = test.isupper()
v2 = test.upper()
print(v1,v2)
结果，v1是布尔值，v2是大写
g：capitalize方法，首字母大写
eg：test = “tesla”
v = test.capitalize（）
print( v )
h：casefold 和 lower 方法，变小写
eg：test = “TesLa”
v1 = test.casefold( )
v2 = test.lower( )
print( v1 )
print( v2 )
i：center( ) 方法，ljust（）方法，rjust（）方法，zfill（）方
法，使内容居中，括号中可以加参数。设置宽度。也可以设
置以什么来填充。r和L是左右对齐。
eg：test = “George”
v = test.center( 20,” * ” )
print（v）
结果是打印一个占有20个字符宽度的内容，
George居中，左右填充上 “ * ” 。“ * ” 的位置可
以不填，使其空白，填的话，只能填一个字符。
eg：test = “George”
v1 = test.ljust(“#”)
v2 = test.rjust(“%”)
v3 = test.zfill(20)
print(v1)
print(v2)
print（v3）
j：count（）方法是去字符串中，寻找子序列出现的个数。
（）括号中的参数有子序列，开始查询的
位置，和结束的位置。
eg：test = “George”
v = test.count( “ge”, 0,5 )
print( v )
意思是ge子序列在test字符串中，共有几个，从0
的位置开始找，找到第5位，停止。开始和结束的
位置可以不写，不写就就从头找到尾。
k：encode（）方法
L：decode（）方法
m：endswith( ) 方法，以什么结尾。
eg: test = “George”
v = test.endswith(“ge”)
print( v )
结果是布尔值，true
n：startswith（）方法，以什么开头。
eg: test = “George”
v = test.startswith(“Ge”)
print( v )
结果是布尔值，true
o：expandtabs（）方法，每6个字符一组，检查是否有tab
键，有tab键的，断开6个字符。如果一组
没有tab键，就继续找下一组，如果在一组
中，有tab键，就从“\t”标志前一个开始算空
格。
eg：test = “1234578\t9”
v = test.expandtabs( 6 )
print( v, len( v ) )
结果：123456为一组，78”四个空格位“9一组，
expandtab的参数是6个一组，参数可以自定义，
也就是说6个一组，有tab的组用tab补位。
******p：find( ) 方法，寻找。从前往后找，找到第一个，获取其索
引值。后面的就不找了
eg：test = “george”
v = test.find( “ge”，5，6 )
print( v )
意思：5和6的意思是开始点和结束点。但是5和6
是开区间，取头不取尾。
q：format（）方法，格式化，将一个字符串中的占位符替换
成指定的值。他是按照替换的出现顺序，进行替
换的。
eg：test = “I am { name }，age { a }”
print( test )
v = test.format( name=“george”，a=25 )
print( v )
结果是i am George，format方法将George赋予
name。25赋予a。
r：format_map（）方法，格式化，和format一样，只不过替
换的形似是字典。
eg：test = “I am { name }，age { a }”
print( test )
v1 = test.format( name=“george”，a=25 )
v2 = test.format( {“name”:“wang”,“a”“:25”} )
print( v1 )
print( v2 )
结果是i am George，format方法将George赋予
name。25赋予a。
s：index( )方法。索引值index找不到就报错。
eg：test = “George”
v = test.index(“ge”)
print(v)
结果是ge的索引值。
t：isalnum( )方法，判断字符串中是否只包含字母和数字。
eg: test = “george123”
v = test.isalnum( )
print( v )
结果是布尔值，true或false，v是字母和数字，
so，是true，如果有除字母或数字以外的，结果
就是false。
u：isalpha（）方法，判断字符串是否是字母，汉字。
eg：test = “george”
v = test.isalpha（）
print（v）
结果是布尔值，如果字符串是全字母或汉字，
true，否则就false。
v：isdecimal（）方法和isdigit（）方法，isnumeric（）。是
判断是否是数字，isdigit是判断十进制的，功能上比
isdecimal全。isnumeric( )更全。但都有各自的单独的
用法。
eg：test = “123”
v1 = test.isdecimal（）
v2 = test.isdigit（）
v3 = test.isnumeric( )
print（v1 ）
print ( v2 )
print ( v3 )
eg：test = “二”
v1 = test.isdecimal（）
v2 = test.isdigit（）
v3 = test.isnumeric( )
print（v1 ）
print ( v2 )
print（v3）
w：字母、数字、下划线：为标识符 def class
eg: a = “def”
v = a.isidentifier()
print（v）
结果是布尔值true，或false
x：swapcase（）方法，大小写转换
eg： test = “georGe”
v = test.swapcase()
print(v)
y：正则表达式，是否想要分割的元素
eg：test = “geography”
v = test.split( “e” ,2 )
print(v)
z：splitlines（）方法分割，只能根据，true，false：是否保
留换行
eg：test = “asdfsdf\ndfdfdsfdff\nfgfdgfgfdg”
v = test.splitlines(false) #显示\n
v2 = test.splitlines(true) #不显示\n
print(v)
print(v2)
******aa：islower（）方法，判断是否是小写，lower（）方法。转
换成小写。
eg：test = “Alex”
v1 = test.islower()
v2 = test.lower()
print(v1,v2)
结果，v1是布尔值，v2是小写
ab：isprinttable（）方法，是否存在不可显示的字符
\t 是制表符 \n 是换行符
eg：test = “dfdadf\tdfasd”
v = test.isprinttable()
print(v)
结果是布尔值。
ac：isspace（）方法。判断是否全部是空格
eg：test = “ ”
v = test.isspace（）
print（v）
结果是布尔值
ad：title（）方法。将字母转大写
eg：test = “george”
v = test.title（）
print(v)
结果，将首字母g转大写G
ae：istitle（）方法。判断是否是标题
eg：test = “Rewrite True if all Casdgf”
v1 = test.istitle( )
print(v1)
v2 = test.tiltle( )
print( )
v3 = v2.istitle()
print(v3)
******af：join( )方法。将字符串中的每个元素按照指定的分隔符进
行拼接。
eg：test = “你是风儿我是沙”
print（test）
t = “ ”
v = t.join(test)
print(v)
结果，每个字中间加一个空格。t就是空格。也可
以是别的任意东西。
******ag：strip（）方法。去空白。去除\t ,\n ，移除指定字符串，
有限最多匹配。
eg：test = “ alex ”
v1 = test.lstrip(“ 可填写左边要去除的东西”)
v2 = test.rstrip(“ 可填写左边要去除的东西”)
v3 = test.strip()
print(v1)
print(v2)
print(v3)
ah：maketrans（）方法和translate（）方法。 Maketrans
（）是将数据替换成另一组数据，translate（）方法就是结
合maketrans方法将被替换的数据进行翻译。
eg：v = “adfsdfsdfsdfsdfasdfasd”
m = str.maketrans(“adfadsfadf”.“1234567890”)
new_v = v.translate(m)
print(new_v)
******ai：字符串分割，partition，rpartiton，split，rsplit
eg： test = “dfadfsdfasfdf”
v1 = test.partiton(“s”) #按s进行分割,但只能分
三份，在第一个s
就分完就不分了
v2 = test.rpartition(“s”) #和上面的一样，只是从
右边开始。
v3 = test.split(“s”,2) #可以指定分割几次，但是分
割的元素是拿不到的。不
写次数的话，就全部分割。
v4 = test.rsplit(“s”) #和上面一样，就是从右边开
始。
aj：startswith（）方法。endswith（）方法。以什么开头，
以什么结尾。
eg：test = “adfasdf 1.1.1.1”
v = test.startswith(“a”)
v2 = test.endswith(“a”)
print(v，v2)
结果是布尔值
ah：索引获取下标。
eg：test = “George”
v = test[ “参数是下标索引值，返回的结果是对应
的数据”]
#获取字符串中的某一个字符。
###切片###
v2 = test[ 0:2 ]
v3 = test[ 0:-1 ]
#拿取索引范围，0到2，前取后不取，就是拿Ge
#v3是拿到倒数第一个，但前取后不取，就是
#Georg。
print(v)
print（v2）
print（v3）
ai：len（）方法，检测字符串的长度。 有多少个字符。
eg：test = “george”
v = len（test）
print（v）
注意：在py3中拿字符
在py2中拿字节，一个中文字符三个字节。
在py3中for循环len是字符。在py2中for循环len是字节
aj：replace（）方法。替换。
eg：test = “adfdfafafasfdfasdf”
v = test.replace(“ad” , “66666”)
#将ad都换成666666
v2= test.replace(“ad” , “66666”，1)
#只替换第一个出现的ad，数字1是指替换前几个
print（v2）
Python字符串操作：
字符串
转义符号
s=‘Let\‘s go‘
print(r"\fsdghlfjdk.")
字符串的格式化输出
%s:字符串 %d：整型 %f：浮点型
print("hello %s,%s"%("sb","egon"))
print("hello %s, his age is %d"%("sb",35))
print("hello %s, his age is %.4f"%("sb",35.53452345))
print("hello {0}, his age is {1}".format("alex",34))
print("hello {0}, his age is {1}".format(34,"alex"))
print("hello {name}, his age is {age}".format(age=30,name="wusir"))
print("hello {name}, his age is {age}".format_map({"name":"egon","age":1000}))
print("一".isdecimal())
print("一".isdigit())
print("壹".isnumeric())
print("hello world".capitalize())
print("hello world".title())
print("HELLO world".casefold())
print("HELLO world".lower())
print("HELLO\tworld")
print("HELLO world".expandtabs())
"HELLO world".rsplit()
print("HELLO\n wor\nld\n".splitlines())
print("HELLO\n wor\nld\n".split("\n"))
print("HELLo world".zfill(10))
操作的主要方法：
拼接：拼接次数多用“+”号效率不高。推荐用join方法。
# s="hello"+"world"+"I"+"am"+"python"
# print(s)
# print(" ".join(["I","am","world!"]))
string
分割split（）：括号中的参数是用什么来分割开字符串。
# s="hello world".split("l",1)
# ["he","lo world"]
# print(s)
strip（） 把字符串开头和结尾的空格及\n ()中可以加去除的条件，比如是“*”
s=“ hello\nworld\n”
s1=" hello\nworld\n".strip()
s2=" hello\nworld\n****".strip("*")
print(s)
print(s1)
print(s2)
center：居中显示
# print("hello world".center(50,"*")) 居中对齐
# print("hello world".ljust(50,"*")) 左对齐
count
find：查找字符
# print("hello world".find("a",4))
# print("hello world".rfind("l"))
# print("hello world".index("e")) index方法没有找到对应的索引值会报错。
lower
casefold
upper
join
split
endwith
startwith
replace：替换
完全匹配：print（“hello world”.replace("world","python")）
index
name = "george\tgeorge"
name2 = "GEORGE"
name3 = "my name is {0} , i am {1} year old"
name4 = "my name is {name} , i am {age} year old"
print(name.capitalize()) #首字母大写
print(name2.casefold()) #大写变小写 if choice == "Y" or choice == "y"
print(name.center(50,‘*‘)) 长度为多少，不过填充*
print(name.count(‘e‘,2,5)) 统计字符出现的次数。数字的意思是从第几位开始统计到哪里，是个区间。
print(name4.ljust(50,"-")) 左对齐，宽度为50 ，不足补齐补“-”。
print（name4.rjust(50,"\")）右对齐，道理和左对齐一样。
print(name.endswith("e")) 以什么结尾
print(name.expandtabs(3)) #设置\t的长度
print(name.find("e",3)) #返回找的的第一个值的索引，找不到就返回-1
print(name3.format("Alex",22))
print(name4.format(name="george",age=25)) #格式化输出
print(name4.format_map({‘name‘:‘Alex‘,‘age‘:23})) 也可以传字典进去。
print(name4.index("is")) 返回is的索引值。
join使用：把列表拼接成字符串，将字符串用任意指定的字符隔开。
print（ "\\\\\".join(["george","jack","rain"]) ）
print(name4.lstrip("My name")) 移除左边的元素，“my name”。 默认是换行和空格。
print(name4.swapcase()) #大小写互换
翻译：
IN = "abcde" 输入的内容
OUT = "!@#$%" 输出的内容
in和out 就是翻译表，in中的元素对应翻译成out中的元素，是索引值相对应。
trans_table = str.maketrans(IN,OUT) #translate =翻译
print(name4.translate(trans_table)) #字符翻译 一一对应后，将字符串做一个转换。
print(name4.zfill(50))
print(name4.replace(‘name‘,‘NAME‘,1)) 替换，将原来的值，替换成新的值，数字的意思是替换几次。
# s="hello world"
# print(s.replace("world","Python"))
# print(s)
print(name4.lower()) 大写变小写
print(name4.rfind(‘e‘)) 从右边开始查找，返回右边的的一个对应元素的索引值。
print(‘aA‘.isalpha()) #是不是字母
print(‘-a‘.isidentifier()) #identifier 关键字 ，是不是合法的关键字，是不是合法的变量名
print(‘A‘.islower()) 是不是小写
print(‘A‘.isupper()) 是不是大写
print(‘123.3‘.isnumeric()) 纯数字返回true，否则返false
print(‘a‘.isprintable()) 可否打印
print(‘ ‘.isspace()) 是不是空格
print(‘Today Headline‘.istitle()) #是不是英文标题
print(‘a1a‘.isalnum()) #a-z A-Z 0-9
print("12342342".isdecimal()) # 是不是一个正整数
