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

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

本文目录

@[toc]

字符串的拼接和反复

# 1、能够应用 + 将多个字符串拼接起来res = 'hello' + ' ' + 'motherland'print(res)# 2、能够应用 * 将一个字符串反复res = 'hello ' * 3print(res)"""后果：hello motherlandhello 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)        # 1res = 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)      # 9res = var.index('h')print(res)        # 9# 如果该字符查找不到，find返回-1，index报错res = var.find('m', 3)print(res)      # -1res = var.index('m', 3)print(res)      # error# find只会返回正向索引，所以不必放心如果查找的字符自身就是最初一个怎么办var = 'Hello Motherland'res = var.find('d')print(res)      # 15print(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 Motherlandprint(len(res))     # 30res = 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-ostring = '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 浮点型占位符
  • :s 字符串占位符
  • :, 金钱占位符
# 整型占位符# 要求数据类型必须是整型，不能兼容除了整型之外的任何数据类型var = '我的汽车{:d}万'.format(100)print(var)  # 我的汽车100万# 如果有位数要求，增加数字；如果有地位要求应用填充符号strvar = '我有{:^10d}块钱'.format(100)print(strvar)   # 我有   100    块钱# 浮点型占位符，要求数据类型必须是浮点型var = '我用{:f}%的资产用来泡妞。'.format(100.00)print(var)  # 我用100.000000%的资产用来泡妞。# 咱们须要保留两位小数，应用 .numvar = '我用{:.2f}%的资产用来泡妞。'.format(100.00)print(var)  # 我用100.00%的资产用来泡妞。# 字符串占位符，要求数据类型必须是字符串var = '我的房子在{:s}{:s}'.format('北京', '十八环')print(var)  # 我的房子在北京十八环# 金钱占位符#将一串数字依照每千位分隔var = '我有{:,}元的贷款'.format(100000000)print(var)  # 我有100,000,000元的贷款