共计 7966 个字符,预计需要花费 20 分钟才能阅读完成。
容器类型的进阶应用(字符串)
- 字符串的拼接与反复
- 字符串的跨行拼接
- 字符串的索引和切片
- 字符串的内置函数
- 字符串的本义
- 字符串和格式化和 format 内置函数的应用
本文目录
@[toc]
字符串的拼接和反复
# 1、能够应用 + 将多个字符串拼接起来
res = 'hello' + '' +'motherland'
print(res)
# 2、能够应用 * 将一个字符串反复
res = 'hello' * 3
print(res)
"""
后果:hello motherland
hello hello hello
"""
字符串的跨行拼接
接下来咱们要学习的是 python 中的一个符号,跨行拼接符\
。
这个符号的作用就是如果一行的代码过长,能够应用这个符号达到换行的作用,而本来语句的作用不变。
# 如果变量 char1 的定义没有 \ 就是语法错误。char = 'hello'
char1 = \
'hello'
# 字符串的跨行拼接
# 应用 \ 能够实现将在不同行的字符串拼接起来,就是说在换行的时候,能够应用 \ 代替 +
char = 'hello' + 'motherland'
char1 = 'hello' \
'motherland'
# 当然换行仍然能够应用 +
char2 = 'hello' + \
'motherland'
字符串的索引
咱们之前说过,字符串和列表、元组这三种容器的独特特点是,有序、可获取,且都存在正逆向下标索引。
var = 'hello'
print(var[1]) # e
字符串的切片
切片顾名思义,就是将字符串进行分截,依此来获取所须要的元素(切片 == 截取)。
语法:string[开始索引: 完结索引: 距离值]
作用
从开始索引所在的元素依照距离值截取至完结索引前一个的元素,完结索引对应的元素不会被获取。
应用办法
-
[开始索引:]:截取从开始索引至最初一个元素,距离值默认为 1
var = 'hello motherland' res = var[5:] print(repr(res)) # 'motherland'
-
[: 完结索引]:截取从第一个元素至完结索引前一个的元素,距离值默认为 1
var = 'hello motherland' res = var[:5] print(repr(res)) # 'hello'
-
[开始索引: 完结索引]:截取从开始索引至完结索引前一个元素,距离值默认为 1
var = 'hello motherland' res = var[3:8] print(repr(res)) # 'lo mo'
-
[开始: 完结: 距离]:和第三点雷同,然而依照指定的距离值截取
var = 'hello motherland' # 从指定地位截取 res = var[3:8:2] print(repr(res)) # 'l o' # 默认从 0 开始截取 res = var[:8:2] print(repr(res)) # 'hlom' # 倒序截取 res = var[::-1] print(repr(res)) # 'dnalrehtom olleh'
-
[::]、[:]:这两种为截取所有的字符串
# 截取所有的 var = 'hello motherland' # 从指定地位截取 res = var[:] print(repr(res)) # 'hello motherland' # 默认从 0 开始截取 res = var[::] print(repr(res)) # 'hello motherland'
字符串的内置函数
查看字符串的内置函数print(help(str))
函数 | 作用 |
---|---|
capitalize | 首字母大写 |
title | 每个单词的首字母大写 |
upper | 所有字母大写 |
lower | 所有字母小写 |
swapcase | 大小写调换 |
count | 计算某个字符的数量 |
find | 查找某个字符串首次呈现的索引地位,找不到返回 -1 |
index | 查找某个字符串首次呈现的索引地位,找不到报错 |
startswith | 判断是否以某个字符串结尾,返回布尔值 |
endswith | 判断是否以某个字符串结尾,返回布尔值 |
isupper | 判断字符串是否都是大写,返回布尔值 |
islower | 判断字符串是否都是小写,返回布尔值 |
istitle | 判断字符串是否每个单词都是首字母大写 |
isalnum | 判断字符串是否都是由数字、字母、汉字组成的 |
isspace | 判断字符串是否是只有空白符组成的 |
isdecimal | 判断字符串是否都是数字组成的,返回布尔值 |
ljust | 填充字符串,原字符串居左,返回新的字符串 |
rjust | 填充字符串,原字符串居右,返回新的字符串 |
center | 填充字符串,原字符串居中,返回新的字符串 |
strip | 去掉首尾两边的空白符,(默认为空白符,能够指定) |
lstrip | 去掉右边的空白符,(默认为空白符,能够指定) |
rstrip | 去掉左边的空白符,(默认为空白符,能够指定) |
split | 依照指定的字符将字符串分隔成列表 |
rsplit | 依照指定的字符将字符串从右往左分隔成列表 |
join | 依照某个字符串将容器转成字符串 |
replace | 将字符串中的字符替换成为其它的 |
format | 字符串的格式化 |
capitalize
var = 'hello motherland'
res = var.capitalize()
print(res) # Hello motherland
title
var = 'hello motherland'
res = var.title()
print(res) # Hello Motherland
upper
var = 'hello motherland'
res = var.upper()
print(res) # HELLO MOTHERLAND
lower
var = 'HELLO MOTHERLAND'
res = var.lower()
print(res) # hello motherland
swapcase
var = 'Hello Motherland'
res = var.swapcase()
print(res) # hELLO mOTHERLAND
count
语法:string.count(sub, [start,], [end])
string.count(字符串,[开始值索引],[完结值索引])
# 留神 count 辨别大小写
var = 'Hello Motherland'
res = var.count('h')
print(res) # 1
res = var.count('H', 3, 10)
print(res) # 1
find 和 index
语法:string.find(sub, [start,], [end])
语法:string.index(sub, [start,], [end])
# find 和 index 服务大小写
var = 'Hello Motherland'
res = var.find('h')
print(res) # 9
res = var.index('h')
print(res) # 9
# 如果该字符查找不到,find 返回 -1,index 报错
res = var.find('m', 3)
print(res) # -1
res = var.index('m', 3)
print(res) # error
# find 只会返回正向索引,所以不必放心如果查找的字符自身就是最初一个怎么办
var = 'Hello Motherland'
res = var.find('d')
print(res) # 15
print(len(var)) # 16
startswith 和 endswith
语法:startswith(prefix, [start], [end])
语法:endswith(suffix, [start], [end])
var = 'Hello Motherland'
# 查看整个字符串是否是以 Hello 结尾
res = var.startswith('Hello')
print(res) # True
# 查看这个字符串在索引 6 的地位是否是以 Mother 结尾的
res = var.startswith('Mother', 6)
print(res) # True
# 查看整个字符串是否是以 aad 结尾
res = var.endswith('aad')
print(res) # False
isupper 和 islower
var = 'Hello Motherland'
# 判断字符串是否都是大写
res = var.isupper()
print(res) # False
# 判断字符串是否都是小写
res = var.islower()
print(res) # False
isdecimal
var = '20666'
# 判断字符串是否都是数字组成
res = var.isdecimal()
print(res) # True
ljust、rjust、center
语法:string.ljust(width, [fillchar])
指定一个长度,如果字符串的长度不够,就依照指定的字符串补足,默认应用空格,补足用的自妇产长度不能超过 1。
var = 'Hello Motherland'
res = var.ljust(20)
print(repr(res)) # 'Hello Motherland'
res = var.rjust(30, 'm')
print(res) # mmmmmmmmmmmmmmHello Motherland
print(len(res)) # 30
res = var.center(30, '-')
print(res) # -------Hello Motherland-------
strip、lstrip、rstrip
var = 'Hello Motherland'
# 去掉首尾两边的字符串
res = var.strip()
print(repr(res)) # 'Hello Motherland'
var = 'mmmmmmmmHello Motherlandmmmmmm'
# 去掉右边的
res = var.lstrip('m')
print(repr(res)) # 'Hello Motherlandmmmmmm'
# 去掉左边的
res = var.rstrip('m')
print(repr(res)) # 'mmmmmmmmHello Motherlandmmmmmm'
# 最左边不是 m 结尾,所以不能去掉
split 和 rsplit
var = 'Hello my motherland'
# 默认依照空格分隔,全副分隔
res = var.split()
print(res) # ['Hello', 'my', 'motherland']
# 指定分隔的次数
res = var.split(' ', 1)
print(res) # ['Hello', 'my motherland']
# 指定分隔的字符
res = var.split('l')
print(res) # ['He', '','o my mother','and']
# rsplit 从右到左分隔
res = var.rsplit('l')
print(res) # ['He', '','o my mother','and']
# 咦?rsplit 的后果怎么和 rsplit 的一样?rspltd 的意思不是列表的元素的排列后果是从右往左的,而是从字符串的左边开始找一个字符,如果只是分隔一次咱们就能够看出后果的不同。# rsplit 从右到左分隔
res = var.rsplit('l', 1)
print(res) # ['Hello my mother', 'and']
# split 从左到右分隔
res = var.split('l', 1)
print(res) # ['He', 'lo my motherland']
# 看出之间的区别了吗?
join
lst = ['h', 'e', 'l', 'l', 'o']
res = '-'.join(lst)
print(res) # h-e-l-l-o
string = 'hello'
res = '-'.join(string)
print(res) # h-e-l-l-o
replace
语法:string.replace(old, new, [count])
var = 'hello hello my motherland'
# 替换其中的字符
res = var.replace('hello', '你好')
print(res) # 你好 你好 my motherland
# 替换其中的一个字符
res = var.replace('hello', 'hi', 1)
print(res) # hi hello my motherland
字符串的本义
转义字符的应用
python 中的转义字符指的是\
,它的作用是将本符号之后的字符有意义的变得无意义,无意义的变得有意义。
无意义的字符指的是单纯的就是一个字符串的字符;有意义的字符指的是不是外表上你看到的那个样子,而是另有一层非凡的含意的字符。
次要的转义字符
符号 | 作用 |
---|---|
\n | 换行(Unix or Linux) |
\r\n | 换行(windows) |
\t | 缩进 |
\r | 将本行前面的所有字符代替本行后面的所有字符 |
\b | 退格符,删除一个字符 |
var = 'hello\nmotherland'
print(var)
print()
var = 'hello\r\nmotherland'
print(var)
print()
var = 'hello\tmotherland'
print(var)
print()
var = 'hello\rmotherland'
print(var)
# 退格符用来删除一个字符
strvar = 'abcde\bfg'
print(strvar) # abcdfg
有一些非凡的门路地址当中会有一些转义字符,然而咱们并不心愿这些转义字符可能执行,就能够应用原型输入。
# 门路被本义,如何解决?var = 'C:\Windows\twain_32'
print(var) # C:\Windows wain_32
# 办法一:应用 \ 将转义字符变得没意义
var = 'C:\Windows\\twain_32'
print(var) # C:\Windows\twain_32
# 办法二:应用 repr 函数,原型化输入
var = 'C:\Windows\twain_32'
res = repr(var)
print(res) # 'C:\\Windows\twain_32'
# 办法三:应用元字符
'''在字符产前加上 r 示意这段字符串原型化输入,不再执行字符串内的任何转义字符。'''
var = r'C:\Windows\twain_32'
print(var) # C:\Windows\twain_32
格式化字符串
在字符串中应用占位符代替某个字符,这样该地位的字符能够随便的替换。
占位符
- %d 整型占位符
- %f 浮点型占位符
- %s 字符串占位符
整型占位符
能够填写整数、小数、布尔值
# 能够填写整数
var = '我有 %d 块钱' % (100)
print(var) # 我有 100 块钱
# 也能够填写小数,然而显示的成果是整数
var = '我有 %d 块钱' % (100.99)
print(var) # 我有 100 块钱
# 填写布尔值,转成对应的整数类型
var = '我有 %d 块钱' % (True)
print(var) # 我有 1 块钱
浮点型占位符
和整型一样,能够填写整数、小数、布尔值
# 能够填写小数
var = '我汽车的排量是 %fT' % (2.0)
print(var) # 我汽车的排量是 2.000000T
# 也能够填写整数,然而显示的成果是小数
var = '我汽车的排量是 %fT' % (2)
print(var) # 我汽车的排量是 2.000000T
# 能够看得出,小数点保留的太多了
字符串占位符
能够填写任何的 python 非法类型
# 能够填写小数
var = '我汽车的排量是 %sT' % (2.0)
print(var) # 我汽车的排量是 2.0T
# 也能够填写整数,然而显示的成果是小数
var = '我汽车的排量是 %sT' % (2)
print(var) # 我汽车的排量是 2T
# 也能够填写整数,然而显示的成果是小数
var = '我汽车的排量是 %sT' % (True)
print(var) # 我汽车的排量是 TrueT
# 多个占位符的应用
var = '我的汽车是 %s, 花了 %d 万,占我总资产的 %f%%' % ('比亚迪', 50, 0.000001)
print(var) # 我的汽车是比亚迪, 花了 50 万,占我总资产的 0.000001%
# 留神,在格式化字符串的时候,如果要独自的打印一个 %,就须要输出两个 %%,以打消 % 的占位符含意。
format 函数的应用
format 的作用也是格式化字符串,然而比上述的形式更加的弱小。
format 应用大括号代替占位符,将值作为本人的参数进行传参。
语法:’string{}{}’.format(value1,value2)
程序传参
依照占位符和值的程序一对一的进行传参
# 能够传递任何的数据类型,默认就是一个字符串占位符。var = '{} {}'.format('hello', 'motherland')
print(var) # hello motherland
索引传参
在中括号中填入 format 参数的索引值,进行传参
# 不反对逆向下标索引
var = '{1} {0}'.format('hello', 'motherland')
print(var) # motherland hello
关键字传参
给参数冠以关键字,而后在中括号中填写关键字的名称,关键字依据名称对应的传值。
var = '{msr} {world}'.format(msr='hello', world='motherland')
print(var) # hello motherland
容器类型传参
如果参数是一个容器类型的数据,能够在中括号中填入容器对应的索引值进行传参。
lst = ['hello', 'goodbye']
tup = ('my', 'your')
dit = {'one': 'motherland', 'two': 'world'}
# 不指定容器中的元素
var = '{} {} {}'.format(lst, tup, dit)
print(var)
# ['hello', 'goodbye'] ('my', 'your') {'one': 'motherland', 'two': 'world'}
# 指定元素
# 字典的键不须要增加引号
var = '{[0]} {[0]} {[one]}'.format(lst, tup, dit)
print(var) # hello my motherland
填充符号的应用
能够应用填充符号将长度不够的字符串补位
- ^ 原字符串居中
- \> 原字符串居右
- < 原字符串居左
语法:{[关键字参数]:[要填充的字符][原字符串地位]\< 总字符长度 >}
例:{who:*^10}
who : 关键字参数,或者是下标索引
* : 要填充的字符(默认填充空格)
^ : 原字符串的地位(默认靠左)10 : 总字符长度 = 原字符串长度 + 填充字符长度
var = '{price:-^20}'.format(price='价格')
print(var) # --------- 价格 ---------
# 留神,两头的 : 不可或缺
var = '{:*^10}'.format('价格')
print(var) # **** 价格 ****
进制转换符号的应用
- :d 整型占位符
- :f 浮点型占位符
- :s 字符串占位符
- :, 金钱占位符
# 整型占位符
# 要求数据类型必须是整型,不能兼容除了整型之外的任何数据类型
var = '我的汽车 {:d} 万'.format(100)
print(var) # 我的汽车 100 万
# 如果有位数要求,增加数字;如果有地位要求应用填充符号
strvar = '我有 {:^10d} 块钱'.format(100)
print(strvar) # 我有 100 块钱
# 浮点型占位符,要求数据类型必须是浮点型
var = '我用{:f}% 的资产用来泡妞。'.format(100.00)
print(var) # 我用 100.000000% 的资产用来泡妞。# 咱们须要保留两位小数,应用 .num
var = '我用{:.2f}% 的资产用来泡妞。'.format(100.00)
print(var) # 我用 100.00% 的资产用来泡妞。# 字符串占位符,要求数据类型必须是字符串
var = '我的房子在{:s}{:s}'.format('北京', '十八环')
print(var) # 我的房子在北京十八环
# 金钱占位符
#将一串数字依照每千位分隔
var = '我有 {:,} 元的贷款'.format(100000000)
print(var) # 我有 100,000,000 元的贷款