python字符串

字符串是一个有序的字符的集合，用于存储和表示基本的文本信息，’ ‘或’’ ‘’或’’’ ‘’’中间包含的内容称之为字符串

创建：

1. s = 'Hello,Eva！How are you?'

特性：

 

1. 按照从左到右的顺序定义字符集合，下标从0开始顺序访问，有序

 

1. 

 

1. 可以进行切片操作

 

1. 不可变，字符串是不可变的，不能像列表一样修改其中某个元素，所有对字符串的修改操作其实都是相当于生成了一份新数据。

 

补充：

1.字符串的单引号和双引号都无法取消特殊字符的含义，如果想让引号内所有字符均取消特殊意义，在引号前面加r，如name＝r’l\thf’

 

字符串的常用操作

字符串操作方法有非常多，但有些不常用 ，我们只讲重要的一些给大家，其它100年都用不上的有兴趣可以自己研究

1. def capitalize(self):
2. 首字母大写
4. def casefold(self):
5. 把字符串全变小写
6. >> > c = 'Alex Li'
7. >> > c.casefold()
8. 'alex li'
10. def center(self, width, fillchar=None):
11. >> > c.center(50, "-")
12. '---------------------Alex Li----------------------'
14. def count(self, sub, start=None, end=None):
15. """
16. S.count(sub[, start[, end]]) -> int
18. >>> s = "welcome to apeland"
19. >>> s.count('e')
20. 3
21. >>> s.count('e',3)
22. 2
23. >>> s.count('e',3,-1)
24. 2
27. def encode(self, encoding='utf-8', errors='strict'):
28. """
29. 编码，日后讲
32. def endswith(self, suffix, start=None, end=None):
33. >> > s = "welcome to apeland"
34. >> > s.endswith("land") 判断以什么结尾
35. True
39. def find(self, sub, start=None, end=None):
40. """
41. S.find(sub[, start[, end]]) -> int
43. Return the lowest index in S where substring sub is found,
44. such that sub is contained within S[start:end]. Optional
45. arguments start and end are interpreted as in slice notation.
47. Return -1 on failure.
48. """
49. return 0
52. def format(self, *args, **kwargs): # known special case of str.format
53. >> > s = "Welcome {0} to Apeland,you are No.{1} user."
54. >> > s.format("Eva", 9999)
55. 'Welcome Eva to Apeland,you are No.9999 user.'
57. >> > s1 = "Welcome {name} to Apeland,you are No.{user_num} user."
58. >> > s1.format(name="Alex", user_num=999)
59. 'Welcome Alex to Apeland,you are No.999 user.'
62. def format_map(self, mapping):
63. """
64. S.format_map(mapping) -> str
66. Return a formatted version of S, using substitutions from mapping.
67. The substitutions are identified by braces ('{' and '}').
68. """
69. 讲完dict再讲这个
72. def index(self, sub, start=None, end=None):
73. """
74. S.index(sub[, start[, end]]) -> int
76. Return the lowest index in S where substring sub is found,
77. such that sub is contained within S[start:end]. Optional
78. arguments start and end are interpreted as in slice notation.
80. Raises ValueError when the substring is not found.
81. """
85. def isdigit(self):
86. """
87. S.isdigit() -> bool
89. Return True if all characters in S are digits
90. and there is at least one character in S, False otherwise.
91. """
92. return False
96. def islower(self):
97. """
98. S.islower() -> bool
100. Return True if all cased characters in S are lowercase and there is
101. at least one cased character in S, False otherwise.
102. """
104. def isspace(self):
105. """
106. S.isspace() -> bool
108. Return True if all characters in S are whitespace
109. and there is at least one character in S, False otherwise.
110. """
113. def isupper(self):
114. """
115. S.isupper() -> bool
117. Return True if all cased characters in S are uppercase and there is
118. at least one cased character in S, False otherwise.
119. """
121. def join(self, iterable):
122. """
123. S.join(iterable) -> str
125. Return a string which is the concatenation of the strings in the
126. iterable. The separator between elements is S.
127. """
128. >>> n = ['alex','jack','rain']
129. >>> '|'.join(n)
130. 'alex|jack|rain'
133. def ljust(self, width, fillchar=None):
134. """
135. S.ljust(width[, fillchar]) -> str
137. Return S left-justified in a Unicode string of length width. Padding is
138. done using the specified fill character (default is a space).
139. """
140. return ""
143. def lower(self):
144. """
145. S.lower() -> str
147. Return a copy of the string S converted to lowercase.
148. """
149. return ""
152. def lstrip(self, chars=None):
153. """
154. S.lstrip([chars]) -> str
156. Return a copy of the string S with leading whitespace removed.
157. If chars is given and not None, remove characters in chars instead.
158. """
159. return ""
164. def replace(self, old, new, count=None):
165. """
166. S.replace(old, new[, count]) -> str
168. Return a copy of S with all occurrences of substring
169. old replaced by new. If the optional argument count is
170. given, only the first count occurrences are replaced.
171. """
172. return ""
177. def rjust(self, width, fillchar=None):
178. """
179. S.rjust(width[, fillchar]) -> str
181. Return S right-justified in a string of length width. Padding is
182. done using the specified fill character (default is a space).
183. """
184. return ""
187. def rsplit(self, sep=None, maxsplit=-1):
188. """
189. S.rsplit(sep=None, maxsplit=-1) -> list of strings
191. Return a list of the words in S, using sep as the
192. delimiter string, starting at the end of the string and
193. working to the front. If maxsplit is given, at most maxsplit
194. splits are done. If sep is not specified, any whitespace string
195. is a separator.
196. """
197. return []
200. def rstrip(self, chars=None):
201. """
202. S.rstrip([chars]) -> str
204. Return a copy of the string S with trailing whitespace removed.
205. If chars is given and not None, remove characters in chars instead.
206. """
207. return ""
210. def split(self, sep=None, maxsplit=-1):
211. """
212. S.split(sep=None, maxsplit=-1) -> list of strings
214. Return a list of the words in S, using sep as the
215. delimiter string. If maxsplit is given, at most maxsplit
216. splits are done. If sep is not specified or is None, any
217. whitespace string is a separator and empty strings are
218. removed from the result.
219. """
220. return []
223. def startswith(self, prefix, start=None, end=None):
224. """
225. S.startswith(prefix[, start[, end]]) -> bool
227. Return True if S starts with the specified prefix, False otherwise.
228. With optional start, test S beginning at that position.
229. With optional end, stop comparing S at that position.
230. prefix can also be a tuple of strings to try.
231. """
232. return False
235. def strip(self, chars=None):
236. """
237. S.strip([chars]) -> str
239. Return a copy of the string S with leading and trailing
240. whitespace removed.
241. If chars is given and not None, remove characters in chars instead.
242. """
243. return ""
246. def swapcase(self):
247. """
248. S.swapcase() -> str
250. Return a copy of S with uppercase characters converted to lowercase
251. and vice versa.
252. """
253. return ""
256. def upper(self):
257. """
258. S.upper() -> str
260. Return a copy of S converted to uppercase.
261. """
262. return ""
265. def zfill(self, width):
266. """
267. S.zfill(width) -> str
269. Pad a numeric string S with zeros on the left, to fill a field
270. of the specified width. The string S is never truncated.
271. """
272. return ""