容器型別的進階使用（字串）

字串的拼接與重復
字串的跨行拼接
字串的索引和切片
字串的內置函式
字串的轉義
字串和格式化和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
```
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 浮點型占位符
?? 字串占位符
:, 金錢占位符

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

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/297470.html

標籤：其他

上一篇：并發編程之：AQS原始碼決議

下一篇：os用法總結：python中必須掌握的內置模塊os，實作與計算機作業系統的常規互動！