python字符串

字符串（不可变）

不可变性质

str1[1:4] = "ds"
print(str1)
#Traceback (most recent call last):
#  File "/Users/admin/Downloads/python/test.py", #line 5, in <module>
#    str1[1:4] = "ds"
#TypeError: 'str' object does not support item #assignment
以上结果说明str是不可变类型

str1="ni hao"
str1="wo hao"
print(str1)
#输出
i h
wo hao
以上的结果是因为，str又开辟了另一个空间而不是，在原有的空间进行修改str1指向的是不同空间

字符串初始化

s2=r"hello \n world"
print(s1)
print(s2)
#输出
hello 
world
hello \n world
以上说明r是取消转义效果

有序表

print (str1[1:4])
#输出
i h
以上结果可以说明字符串是左闭右开的，也说明他是一个有序表，可以通过下标访问;

#可迭代
s1="asdadsa"
print(list(s1))
print(set(s1)) #丢进去有去重的效果
print(tuple(s1))
#输出
['a', 's', 'd', 'a', 'd', 's', 'a']
{'d', 'a', 's'}
('a', 's', 'd', 'a', 'd', 's', 'a')

字符串元素访问

索引访问

str="andiam"
print(str[4])
#输出
a

str="andiam"
str[4]='b'
print(str)
#输出
TypeError: 'str' object does not support item assignment

说明str不可变，要改某一个字符，只能重新开辟空间

是个有序的字符序列，可迭代

for i in "dsada":
    print(i,end="")
#输出
dsada

字符串格式化

类C语法

print("I am %03d"%(2))
print("i like %10s."%'python')
print("i am %-5d"%(20,))
#输出
I am 002
i like     python.
i am 20   
以上说明d为数字，s为字符串，-左对齐，ds前面的是有效位数，-/+是左对齐还是右对齐

format函数（主要使用）

位置参数(按顺序占位)
print("{}:{}".format('192.168.1.123',80))
#输出
192.168.1.123:80

命名参数和位置参数
print("{server}{1}:{0}".format(80,'192.168.1.123',server='httpd    '))
#输出
httpd    192.168.1.123:80

访问元素
print("{0[0]}:{1[3]}".format('hello','world'))
#输出
h:l

对象属性访问
from collections import namedtuple
Point=namedtuple('Point','x y')
p=Point(4,5)
print("{0.x},{0.y}".format(p))
#输出
4,5

对齐

print('{}*{}={:<2}'.format(3,2,2*322))
print('{}*{}={:>2}'.format(3,2,2*3))
print('{}*{}={:*<2}'.format(3,2,2*3))
print('{}*{}={:^>2}'.format(3,2,2*3))
print('{:^30}'.format('centered'))
print('{:*^30}'.format('centered'))
#输出
3*2=644
3*2= 6
3*2=6*
3*2=^6
           centered           
***********centered***********
以上结果说明<左对齐，>右对齐，^中间对齐，2指有效2位，如果大于2位也不会舍弃，右对齐是会填充空格来达到有效位数，有效位数前面是填充符号,符号前面指定填充符;

内置方法

.capitalize

将字符串的第一个字符转换为大写

print("wuyanzu".capitalize())
#输出
Wuyanzu

.casefold

将字符串转换成小写，Unicode编码中凡是有对应的小写形式的，都会强制转换。

print("ß".casefold())
print("ß".lower())
#输出
ss
ß

.center

返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。

print("wuyanzu".center(20,'*'))
#输出
******wuyanzu*******

.count

返回 str 在 string 里面出现的次数
用法：count(str, beg= 0,end=len(string))

s='wuyanzudsaddaqwqasf4q2sxc21e'
print("wuyanzudsaddaqwqasf4q2sxc21e".count('u',1,6))
print("wuyanzudsaddaqwqasf4q2sxc21e".count('u',1,7))
#输出
1
2
以上结果说明，去值是[,)

.startswith

如果一个字符串以指定的前缀（字符串）开始，startswith（）方法返回True。如果不是，则返回False。

s='wu yan zu ds ad da'
print(s.startswith("wuyanzu"))
print(s.startswith("wu "))
print(s.startswith("wu yan"))
#输出
False
True
True

.endswith

检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.

s='wu yan zu ds ad da'
print(s.endswith(" da"))
print(s.endswith("adda"))
#输出
True
False

.expandtabs

把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8

s='wu\tyan\tzu'
print(s.expandtabs())
#输出
wu      yan     zu

.find

检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1
用法：find(str, beg=0 end=len(string))

s='wu yan  zuddasd'
print(s.find("d"))
#输出
10
说明他是从左往右依次查找，输入是单词也是返回第一个下标索引

.rfind

rfind（）方法从右侧开始查找返回子字符串的最高索引（如果找到）。如果未找到，则返回-1。

s='wu yan  zuddasd'
print(s.rfind("d"))
print(s.rfind("asd"))
#输出
14
12

.index/rindex

跟find()方法一样，检测是否包含字串，包含则返回索引位置，如果str不在字符串中会报一个异常。

用法：index(str, beg=0, end=len(string))
跟find类似，只是find未找到的提示更加温和，这里是直接报错

.isalnum

判断是否只包含数字、字母

s='wu yan  zuddasd'
print(s.isalnum())
s="wuyanzu231"
print(s.isalnum())
s="dasdsa"
print(s.isalnum())
#输出
False
True
True
以上说明除了数字、字母以为一旦有就为false

.isalpha

是否只是字母

s='wu yan  zuddasd'
print(s.isalpha())
s="wuyanzu231"
print(s.isalpha())
s="dasdsa"
print(s.isalpha())
#输出
False
False
True

.isdigit

是否只是数字

.islower

是否包含的字母都是小写的

.isupper

是否包含的字母都是大写的

.isnumeric

是否只包含数字字符

.isspace

是否包含空白

.istitle

只有字符之间没有任何除字母外的任何字符，都为真；

s='Wuyanzu d231  '
print(s.istitle())
s='Wuyanzud    231  '
print(s.istitle())
s='Wuyanzu9sdds'
print(s.istitle())
s="Wuyanzu231"
print(s.istitle())
#输出
False
True
False
True

.join

join()是一个字符串方法，它返回一个与迭代元素相连的字符串。

ls=['1','2','3','4','5']
print("-".join(ls))
#输出
1-2-3-4-5
注意:列表的数一定要是字符串;否则报错

.ljust/rjust

字符串ljust()方法返回给定最小宽度的左/右对齐字符串。

s="wuyanzu"
print(s.ljust(20))
print(s.rjust(20))
#输出
wuyanzu             
             wuyanzu

.split

split()方法，指定分隔符将字符串并返回一个字符串形式列表，默认分割是空白字符。

用法：.split(分隔符，最大分割数)

s="wu yan zu"
print(s.split())
s="wu*yan*zu"
print(s.split('*'))
#输出
['wu', 'yan', 'zu']
['wu', 'yan', 'zu']

.rsplit

rsplit（）方法从指定分隔符的右侧分割字符串并返回字符串列表。

用法：.split(分隔符，最大分割数)

s="wu*yan*zu"
print(s.rsplit('*',1))
#输出
['wu*yan', 'zu']

.strip/.lstrip/.rstrip

从两端匹配，删除开头的空格，和括号内每个单个字符，注意：开头和结尾匹配到的单个字符都将被删除，但不是就地修改。

s="wu yan zuc"
print(s.strip('uwc'))

s="wu yan zu wu"
print(s.lstrip('wu'))

s="wu yan zu wu"
print(s.rstrip('wu'))
#输出
 yan z
 yan zu wu
wu yan zu 

.partition/rpartition

从左至右，遇到分隔符就把字符串分割成两部分，返回头、分隔符、尾三部分的三元组；如果没有找到分隔符，就返回头、2个空元素的三元组。

s="wu yan zu"
print(s.partition('yan'))
print(s.partition("y"))
print(s.partition("0"))
print(s.partition('zu'))
#输出
('wu ', 'yan', ' zu')
('wu ', 'y', 'an zu')
('wu yan zu', '', '')
('wu yan ', 'zu', '')

.replace

replace（）方法返回所有出现的子字符串被另一个子字符串替换的字符串的副本。

用法：str.replace（old，new [，count]）

s="wu yan zu"
print(s.replace('w','W'))
print(s.replace('u','U'))
print(s.replace('u','U',1))
#输出
Wu yan zu
wU yan zU
wU yan zu

.splitlines

splitlines（）方法在换行符处拆分字符串并返回字符串中的行列表。

keepends=True 换行符号也将被包含到返回的列表元素

s="wu\nyan\nzu"
print(s.splitlines())
print(s.splitlines(keepends=True))
#输出
['wu', 'yan', 'zu']
['wu\n', 'yan\n', 'zu']

.swapcase

swapcase（）方法返回所有大写字符都转换为小写字母并将小写字符转换为大写字符串的字符串。

s="wu yaN Zu"
print(s.swapcase())
#输出
WU YAn zU

.title

title（）方法返回一个字母大写的每个单词的首字母; 标题字符串。

s="wu yaN Zu"
print(s.title())
#输出
Wu Yan Zu
从以上结果看并把，不应该大写的N改为了小写

.upper/lower（同理）

字符串upper()方法将字符串中的所有小写字符转换为大写字符并将其返回