容器类型的进阶使用（字符串）

1. 字符串的拼接与重复
2. 字符串的跨行拼接
3. 字符串的索引和切片
4. 字符串的内置函数
5. 字符串的转义
6. 字符串和格式化和format内置函数的使用

本文目录

@

字符串的拼接和重复

# 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. [开始索引:] ：截取从开始索引至最后一个元素，间隔值默认为1

   var = ‘hello motherland‘
   res = var[5:]
   print(repr(res))  # ‘ motherland‘
   

2. [:结束索引]：截取从第一个元素至结束索引前一个的元素，间隔值默认为1

   var = ‘hello motherland‘
   res = var[:5]
   print(repr(res))  # ‘hello‘
   

3. [开始索引:结束索引]：截取从开始索引至结束索引前一个元素，间隔值默认为1

   var = ‘hello motherland‘
   res = var[3:8]
   print(repr(res))  # ‘lo mo‘
   

4. [开始:结束:间隔]：和第三点相同，但是按照指定的间隔值截取

   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‘
   

5. [::]、[:]：这两种为截取所有的字符串

   # 截取所有的
   var = ‘hello motherland‘
   # 从指定位置截取
   res = var[:]
   print(repr(res))  # ‘hello motherland‘
   # 默认从0开始截取
   res = var[::]
   print(repr(res))  # ‘hello motherland‘
   
   

字符串的内置函数

查看字符串的内置函数print(help(str))

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中的转义字符指的是\，它的作用是将本符号之后的字符有意义的变得无意义，无意义的变得有意义。

无意义的字符指的是单纯的就是一个字符串的字符；有意义的字符指的是不是表面上你看到的那个样子，而是另有一层特殊的含义的字符。

主要的转义字符

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

格式化字符串

在字符串中使用占位符替代某个字符，这样该位置的字符可以随意的替换。

占位符

1. %d 整型占位符
2. %f 浮点型占位符
3. %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 浮点型占位符
• ?? 字符串占位符
• :, 金钱占位符

# 整型占位符
# 要求数据类型必须是整型，不能兼容除了整型之外的任何数据类型
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元的存款

容器类型的进阶使用（字符串）