mirror of
https://github.com/apachecn/ailearning.git
synced 2026-02-09 05:15:28 +08:00
709 lines
7.1 KiB
Markdown
709 lines
7.1 KiB
Markdown
# 字符串
|
||
|
||
## 生成字符串
|
||
|
||
**Python**中可以使用一对单引号''或者双引号""生成字符串。
|
||
|
||
In [1]:
|
||
|
||
```py
|
||
s = "hello, world"
|
||
print s
|
||
|
||
```
|
||
|
||
```py
|
||
hello, world
|
||
|
||
```
|
||
|
||
In [2]:
|
||
|
||
```py
|
||
s = 'hello world'
|
||
print s
|
||
|
||
```
|
||
|
||
```py
|
||
hello world
|
||
|
||
```
|
||
|
||
## 简单操作
|
||
|
||
加法：
|
||
|
||
In [3]:
|
||
|
||
```py
|
||
s = 'hello ' + 'world'
|
||
s
|
||
|
||
```
|
||
|
||
Out[3]:
|
||
|
||
```py
|
||
'hello world'
|
||
```
|
||
|
||
字符串与数字相乘：
|
||
|
||
In [4]:
|
||
|
||
```py
|
||
"echo" * 3
|
||
|
||
```
|
||
|
||
Out[4]:
|
||
|
||
```py
|
||
'echoechoecho'
|
||
```
|
||
|
||
字符串长度：
|
||
|
||
In [5]:
|
||
|
||
```py
|
||
len(s)
|
||
|
||
```
|
||
|
||
Out[5]:
|
||
|
||
```py
|
||
11
|
||
```
|
||
|
||
## 字符串方法
|
||
|
||
**Python**是一种面向对象的语言，面向对象的语言中一个必不可少的元素就是方法，而字符串是对象的一种，所以有很多可用的方法。
|
||
|
||
跟很多语言一样，**Python**使用以下形式来调用方法：
|
||
|
||
```py
|
||
对象.方法(参数)
|
||
```
|
||
|
||
### 分割
|
||
|
||
s.split()将s按照空格（包括多个空格，制表符`\t`，换行符`\n`等）分割，并返回所有分割得到的字符串。
|
||
|
||
In [6]:
|
||
|
||
```py
|
||
line = "1 2 3 4 5"
|
||
numbers = line.split()
|
||
print numbers
|
||
|
||
```
|
||
|
||
```py
|
||
['1', '2', '3', '4', '5']
|
||
|
||
```
|
||
|
||
s.split(sep)以给定的sep为分隔符对s进行分割。
|
||
|
||
In [7]:
|
||
|
||
```py
|
||
line = "1,2,3,4,5"
|
||
numbers = line.split(',')
|
||
print numbers
|
||
|
||
```
|
||
|
||
```py
|
||
['1', '2', '3', '4', '5']
|
||
|
||
```
|
||
|
||
### 连接
|
||
|
||
与分割相反，s.join(str_sequence)的作用是以s为连接符将字符串序列str_sequence中的元素连接起来，并返回连接后得到的新字符串：
|
||
|
||
In [8]:
|
||
|
||
```py
|
||
s = ' '
|
||
s.join(numbers)
|
||
|
||
```
|
||
|
||
Out[8]:
|
||
|
||
```py
|
||
'1 2 3 4 5'
|
||
```
|
||
|
||
In [9]:
|
||
|
||
```py
|
||
s = ','
|
||
s.join(numbers)
|
||
|
||
```
|
||
|
||
Out[9]:
|
||
|
||
```py
|
||
'1,2,3,4,5'
|
||
```
|
||
|
||
### 替换
|
||
|
||
s.replace(part1, part2)将字符串s中指定的部分part1替换成想要的部分part2，并返回新的字符串。
|
||
|
||
In [10]:
|
||
|
||
```py
|
||
s = "hello world"
|
||
s.replace('world', 'python')
|
||
|
||
```
|
||
|
||
Out[10]:
|
||
|
||
```py
|
||
'hello python'
|
||
```
|
||
|
||
此时，s的值并没有变化，替换方法只是生成了一个新的字符串。
|
||
|
||
In [11]:
|
||
|
||
```py
|
||
s
|
||
|
||
```
|
||
|
||
Out[11]:
|
||
|
||
```py
|
||
'hello world'
|
||
```
|
||
|
||
### 大小写转换
|
||
|
||
s.upper()方法返回一个将s中的字母全部大写的新字符串。
|
||
|
||
s.lower()方法返回一个将s中的字母全部小写的新字符串。
|
||
|
||
In [12]:
|
||
|
||
```py
|
||
"hello world".upper()
|
||
|
||
```
|
||
|
||
Out[12]:
|
||
|
||
```py
|
||
'HELLO WORLD'
|
||
```
|
||
|
||
这两种方法也不会改变原来s的值：
|
||
|
||
In [13]:
|
||
|
||
```py
|
||
s = "HELLO WORLD"
|
||
print s.lower()
|
||
print s
|
||
|
||
```
|
||
|
||
```py
|
||
hello world
|
||
HELLO WORLD
|
||
|
||
```
|
||
|
||
### 去除多余空格
|
||
|
||
s.strip()返回一个将s两端的多余空格除去的新字符串。
|
||
|
||
s.lstrip()返回一个将s开头的多余空格除去的新字符串。
|
||
|
||
s.rstrip()返回一个将s结尾的多余空格除去的新字符串。
|
||
|
||
In [14]:
|
||
|
||
```py
|
||
s = " hello world "
|
||
s.strip()
|
||
|
||
```
|
||
|
||
Out[14]:
|
||
|
||
```py
|
||
'hello world'
|
||
```
|
||
|
||
s的值依然不会变化：
|
||
|
||
In [15]:
|
||
|
||
```py
|
||
s
|
||
|
||
```
|
||
|
||
Out[15]:
|
||
|
||
```py
|
||
' hello world '
|
||
```
|
||
|
||
In [16]:
|
||
|
||
```py
|
||
s.lstrip()
|
||
|
||
```
|
||
|
||
Out[16]:
|
||
|
||
```py
|
||
'hello world '
|
||
```
|
||
|
||
In [17]:
|
||
|
||
```py
|
||
s.rstrip()
|
||
|
||
```
|
||
|
||
Out[17]:
|
||
|
||
```py
|
||
' hello world'
|
||
```
|
||
|
||
## 更多方法
|
||
|
||
可以使用dir函数查看所有可以使用的方法：
|
||
|
||
In [18]:
|
||
|
||
```py
|
||
dir(s)
|
||
|
||
```
|
||
|
||
Out[18]:
|
||
|
||
```py
|
||
['__add__',
|
||
'__class__',
|
||
'__contains__',
|
||
'__delattr__',
|
||
'__doc__',
|
||
'__eq__',
|
||
'__format__',
|
||
'__ge__',
|
||
'__getattribute__',
|
||
'__getitem__',
|
||
'__getnewargs__',
|
||
'__getslice__',
|
||
'__gt__',
|
||
'__hash__',
|
||
'__init__',
|
||
'__le__',
|
||
'__len__',
|
||
'__lt__',
|
||
'__mod__',
|
||
'__mul__',
|
||
'__ne__',
|
||
'__new__',
|
||
'__reduce__',
|
||
'__reduce_ex__',
|
||
'__repr__',
|
||
'__rmod__',
|
||
'__rmul__',
|
||
'__setattr__',
|
||
'__sizeof__',
|
||
'__str__',
|
||
'__subclasshook__',
|
||
'_formatter_field_name_split',
|
||
'_formatter_parser',
|
||
'capitalize',
|
||
'center',
|
||
'count',
|
||
'decode',
|
||
'encode',
|
||
'endswith',
|
||
'expandtabs',
|
||
'find',
|
||
'format',
|
||
'index',
|
||
'isalnum',
|
||
'isalpha',
|
||
'isdigit',
|
||
'islower',
|
||
'isspace',
|
||
'istitle',
|
||
'isupper',
|
||
'join',
|
||
'ljust',
|
||
'lower',
|
||
'lstrip',
|
||
'partition',
|
||
'replace',
|
||
'rfind',
|
||
'rindex',
|
||
'rjust',
|
||
'rpartition',
|
||
'rsplit',
|
||
'rstrip',
|
||
'split',
|
||
'splitlines',
|
||
'startswith',
|
||
'strip',
|
||
'swapcase',
|
||
'title',
|
||
'translate',
|
||
'upper',
|
||
'zfill']
|
||
```
|
||
|
||
## 多行字符串
|
||
|
||
Python 用一对 `"""` 或者 `'''` 来生成多行字符串：
|
||
|
||
In [19]:
|
||
|
||
```py
|
||
a = """hello world.
|
||
it is a nice day."""
|
||
print a
|
||
|
||
```
|
||
|
||
```py
|
||
hello world.
|
||
it is a nice day.
|
||
|
||
```
|
||
|
||
在储存时，我们在两行字符间加上一个换行符 `'\n'`
|
||
|
||
In [20]:
|
||
|
||
```py
|
||
a
|
||
|
||
```
|
||
|
||
Out[20]:
|
||
|
||
```py
|
||
'hello world.\nit is a nice day.'
|
||
```
|
||
|
||
## 使用 `()` 或者 `\` 来换行
|
||
|
||
当代码太长或者为了美观起见时，我们可以使用两种方法来将一行代码转为多行代码：
|
||
|
||
* ()
|
||
* \
|
||
|
||
In [21]:
|
||
|
||
```py
|
||
a = ("hello, world. "
|
||
"it's a nice day. "
|
||
"my name is xxx")
|
||
a
|
||
|
||
```
|
||
|
||
Out[21]:
|
||
|
||
```py
|
||
"hello, world. it's a nice day. my name is xxx"
|
||
```
|
||
|
||
In [22]:
|
||
|
||
```py
|
||
a = "hello, world. " \
|
||
"it's a nice day. " \
|
||
"my name is xxx"
|
||
a
|
||
|
||
```
|
||
|
||
Out[22]:
|
||
|
||
```py
|
||
"hello, world. it's a nice day. my name is xxx"
|
||
```
|
||
|
||
## 强制转换为字符串
|
||
|
||
* `str(ob)`强制将`ob`转化成字符串。
|
||
* `repr(ob)`也是强制将`ob`转化成字符串。
|
||
|
||
不同点如下：
|
||
|
||
In [23]:
|
||
|
||
```py
|
||
str(1.1 + 2.2)
|
||
|
||
```
|
||
|
||
Out[23]:
|
||
|
||
```py
|
||
'3.3'
|
||
```
|
||
|
||
In [24]:
|
||
|
||
```py
|
||
repr(1.1 + 2.2)
|
||
|
||
```
|
||
|
||
Out[24]:
|
||
|
||
```py
|
||
'3.3000000000000003'
|
||
```
|
||
|
||
## 整数与不同进制的字符串的转化
|
||
|
||
可以将整数按照不同进制转化为不同类型的字符串。
|
||
|
||
十六进制：
|
||
|
||
In [25]:
|
||
|
||
```py
|
||
hex(255)
|
||
|
||
```
|
||
|
||
Out[25]:
|
||
|
||
```py
|
||
'0xff'
|
||
```
|
||
|
||
八进制：
|
||
|
||
In [26]:
|
||
|
||
```py
|
||
oct(255)
|
||
|
||
```
|
||
|
||
Out[26]:
|
||
|
||
```py
|
||
'0377'
|
||
```
|
||
|
||
二进制：
|
||
|
||
In [27]:
|
||
|
||
```py
|
||
bin(255)
|
||
|
||
```
|
||
|
||
Out[27]:
|
||
|
||
```py
|
||
'0b11111111'
|
||
```
|
||
|
||
可以使用 `int` 将字符串转为整数：
|
||
|
||
In [28]:
|
||
|
||
```py
|
||
int('23')
|
||
|
||
```
|
||
|
||
Out[28]:
|
||
|
||
```py
|
||
23
|
||
```
|
||
|
||
还可以指定按照多少进制来进行转换，最后返回十进制表达的整数：
|
||
|
||
In [29]:
|
||
|
||
```py
|
||
int('FF', 16)
|
||
|
||
```
|
||
|
||
Out[29]:
|
||
|
||
```py
|
||
255
|
||
```
|
||
|
||
In [30]:
|
||
|
||
```py
|
||
int('377', 8)
|
||
|
||
```
|
||
|
||
Out[30]:
|
||
|
||
```py
|
||
255
|
||
```
|
||
|
||
In [31]:
|
||
|
||
```py
|
||
int('11111111', 2)
|
||
|
||
```
|
||
|
||
Out[31]:
|
||
|
||
```py
|
||
255
|
||
```
|
||
|
||
`float` 可以将字符串转换为浮点数：
|
||
|
||
In [32]:
|
||
|
||
```py
|
||
float('3.5')
|
||
|
||
```
|
||
|
||
Out[32]:
|
||
|
||
```py
|
||
3.5
|
||
```
|
||
|
||
## 格式化字符串
|
||
|
||
**Python**用字符串的`format()`方法来格式化字符串。
|
||
|
||
具体用法如下，字符串中花括号 `{}` 的部分会被format传入的参数替代，传入的值可以是字符串，也可以是数字或者别的对象。
|
||
|
||
In [33]:
|
||
|
||
```py
|
||
'{} {} {}'.format('a', 'b', 'c')
|
||
|
||
```
|
||
|
||
Out[33]:
|
||
|
||
```py
|
||
'a b c'
|
||
```
|
||
|
||
可以用数字指定传入参数的相对位置：
|
||
|
||
In [34]:
|
||
|
||
```py
|
||
'{2} {1} {0}'.format('a', 'b', 'c')
|
||
|
||
```
|
||
|
||
Out[34]:
|
||
|
||
```py
|
||
'c b a'
|
||
```
|
||
|
||
还可以指定传入参数的名称：
|
||
|
||
In [35]:
|
||
|
||
```py
|
||
'{color} {n} {x}'.format(n=10, x=1.5, color='blue')
|
||
|
||
```
|
||
|
||
Out[35]:
|
||
|
||
```py
|
||
'blue 10 1.5'
|
||
```
|
||
|
||
可以在一起混用：
|
||
|
||
In [36]:
|
||
|
||
```py
|
||
'{color} {0} {x} {1}'.format(10, 'foo', x = 1.5, color='blue')
|
||
|
||
```
|
||
|
||
Out[36]:
|
||
|
||
```py
|
||
'blue 10 1.5 foo'
|
||
```
|
||
|
||
可以用`{<field name>:<format>}`指定格式：
|
||
|
||
In [37]:
|
||
|
||
```py
|
||
from math import pi
|
||
|
||
'{0:10} {1:10d} {2:10.2f}'.format('foo', 5, 2 * pi)
|
||
|
||
```
|
||
|
||
Out[37]:
|
||
|
||
```py
|
||
'foo 5 6.28'
|
||
```
|
||
|
||
具体规则与C中相同。
|
||
|
||
也可以使用旧式的 `%` 方法进行格式化：
|
||
|
||
In [38]:
|
||
|
||
```py
|
||
s = "some numbers:"
|
||
x = 1.34
|
||
y = 2
|
||
# 用百分号隔开，括号括起来
|
||
t = "%s %f, %d" % (s, x, y)
|
||
|
||
```
|
||
|
||
In [39]:
|
||
|
||
```py
|
||
t
|
||
|
||
```
|
||
|
||
Out[39]:
|
||
|
||
```py
|
||
'some numbers: 1.340000, 2'
|
||
``` |