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

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

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

本文目录

@

目录

• 容器类型的进阶使用（字符串）
  • • 本文目录
    • 字符串的拼接和重复
    • 字符串的跨行拼接
    • 字符串的索引
    • 字符串的切片
      • • 作用
        • 使用方法
    • 字符串的内置函数
      • • capitalize
        • title
        • upper
        • lower
        • swapcase
        • count
        • find和index
        • startswith和endswith
        • isupper和islower
        • isdecimal
        • ljust、rjust、center
        • strip、lstrip、rstrip
        • split和rsplit
        • join
        • replace
    • 字符串的转义
      • • 转义字符的使用
        • 主要的转义字符
    • 格式化字符串
      • • 占位符
        • 整型占位符
        • 浮点型占位符
        • 字符串占位符
    • 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	首字母大写
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

格式化字符串

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

占位符

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元的存款