技術標籤：python基礎複習python

列表

列表的資料操作

我們對於可變資料（例如，列表，資料庫等）的操作，一般包含增、刪、改、查四個方面。

一、新增元素

新增元素有一下幾個方法:

• append 在末尾新增元素
• insert 在指定位置插入元素
• extend 合併兩個列表
• 對原列表造成影響，方法本身返回的是None

append

append會把新元素新增到列表末尾

    #定義變數A，預設有3個元素
    A = ['xiaoWang','xiaoZhang','xiaoHua']

    print("-----新增之前，列表A的資料-----A=%s" %
 
 A)

    #提示、並新增元素
    temp = input('請輸入要新增的學生姓名:')
    A.append(temp)

    print("-----新增之後，列表A的資料-----A=%s" % A)
Copy

insert

insert(index, object) 在指定位置index前插入元素object

strs = ['a','b','m','s']
strs.insert(3,'h')
print(strs)  # ['a', 'b', 'm', 'h', 's']
Copy

extend

通過extend可以將另一個集合中的元素逐一新增到列表中

必須是可迭代的元素

a = ['a','b','c']
b = ['d','e','f']
a.extend(b)
print(a)  # ['a', 'b', 'c', 'd', 'e', 'f'] 將 b 新增到 a 裡
print(b) # ['d','e','f'] b的內容不變
Copy

二、修改元素

我們是通過指定下標來訪問列表元素，因此修改元素的時候，為指定的列表下標賦值即可。

    #定義變數A，預設有3個元素
    A = ['xiaoWang','xiaoZhang','xiaoHua']

    print("-----修改之前，列表A的資料-----A=%s"
 
 % A)

    #修改元素
    A[1] = 'xiaoLu'

    print("-----修改之後，列表A的資料-----A=%s" % A)
Copy

三、查詢元素

所謂的查詢，就是看看指定的元素是否存在，以及檢視元素所在的位置，主要包含一下幾個方法：

• in 和 not in
• index 和 count

in, not in

python中查詢的常用方法為：

• in（存在）,如果存在那麼結果為true，否則為false
• not in（不存在），如果不存在那麼結果為true，否則false

    #待查詢的列表
    nameList = ['xiaoWang','xiaoZhang','xiaoHua']

    #獲取使用者要查詢的名字
    findName = input('請輸入要查詢的姓名:')

    #查詢是否存在
    if findName in nameList:
        print('在列表中找到了相同的名字')
    else:
        print('沒有找到')
Copy

結果1：(找到)

結果2：(沒有找到)

說明：

in的方法只要會用了，那麼not in也是同樣的用法，只不過not in判斷的是不存在

index, count

index用來查詢元素所在的位置，如果未找到則會報錯；count用來計算某個元素出現的次數。它們的使用和字串裡的使用效果一致。

>>> a = ['a', 'b', 'c', 'a', 'b']
>>> a.index('a', 1, 3) # 注意是左閉右開區間
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: 'a' is not in list
>>> a.index('a', 1, 4)
3
>>> a.count('b')
2
>>> a.count('d')
0
Copy

四、刪除元素

類比現實生活中，如果某位同學調班了，那麼就應該把這個條走後的學生的姓名刪除掉；在開發中經常會用到刪除這種功能。

列表元素的常用刪除方法有：

• del：根據下標進行刪除
• pop：刪除最後一個元素
• remove：根據元素的值進行刪除

del

movieName = ['加勒比海盜','駭客帝國','第一滴血','指環王','霍位元人','速度與激情']
print('------刪除之前------movieName=%s' % movieName)
del movieName[2]
print('------刪除之後------movieName=%s' % movieName)
Copy

pop

movieName = ['加勒比海盜','駭客帝國','第一滴血','指環王','霍位元人','速度與激情']
print('------刪除之前------movieName=%s' % movieName)
movieName.pop()
print('------刪除之後------movieName=%s' % movieName)
Copy

remove

movieName = ['加勒比海盜','駭客帝國','第一滴血','指環王','霍位元人','速度與激情']
print('------刪除之前------movieName=%s' % movieName)
movieName.remove('指環王')
print('------刪除之後------movieName=%s' % movieName)
Copy

五、排序(sort, reverse)

sort方法是將list按特定順序重新排列，預設為由小到大，引數reverse=True可改為倒序，由大到小。

sort 對原列表永久改變

sorted對原列表不造成影響，只是臨時改變

reverse方法是將list逆置。

>>> a = [1, 4, 2, 3]
>>> a
[1, 4, 2, 3]
>>> a.reverse()  # 逆置，不排序
>>> a
[3, 2, 4, 1]
>>> a.sort()  # 預設從小到大排序
>>> a
[1, 2, 3, 4]
>>> a.sort(reverse=True)  # 從大到小排序
>>> a
[4, 3, 2, 1]

列表的迴圈遍歷

1. 使用while迴圈

為了更有效率的輸出列表的每個資料，可以使用迴圈來完成

namesList = ['xiaoWang','xiaoZhang','xiaoHua']
length = len(namesList)  # 獲取列表長度
i = 0
while i<length:
    print(namesList[i])
    i+=1
Copy

結果:

xiaoWang
xiaoZhang
xiaoHua
Copy

2. 使用for迴圈

while 迴圈是一種基本的遍歷列表資料的方式，但是最常用也是最簡單的方式是使用 for 迴圈

namesList = ['xiaoWang','xiaoZhang','xiaoHua']
for name in namesList:
    print(name)
Copy

結果:

xiaoWang
xiaoZhang
xiaoHua
Copy

3. 交換2個變數的值

# 使用中間變數
a = 4
b = 5
c = 0

c = a
a = b
b = c

print(a)
print(b)

直接：
a = 1
b = 2
a,b = b,a

練習

手動實現氣泡排序(難)

nums = [5, 1, 7, 6, 8, 2, 4, 3]

for j in range(0, len(nums) - 1):
    for i in range(0, len(nums) - 1 - j):
        if nums[i] > nums[i + 1]:
            a = nums[i]
            nums[i] = nums[i+1]
            nums[i+1] = a

print(nums)

    print('辦公室%d的人數為:%d'%(i,len(tempNames)))
    i+=1
    for name in tempNames:
        print("%s"%name,end='')
    print("\n")
    print("-"*20)
Copy

列表的巢狀

1. 列表巢狀

類似while迴圈的巢狀，列表也是支援巢狀的

一個列表中的元素又是一個列表，那麼這就是列表的巢狀

此處重點掌握怎麼操作被巢狀的列表

>>> schoolNames = [
... [1, 2, 3],
... [11, 22, 33],
... [111, 222, 333]
... ]
>>> schoolNames[1][2]  # 獲取數字 33
33
>>> schoolNames[1][2] = 'abc'  # 把 33 修改為 'abc'
>>> schoolNames
[[1, 2, 3], [11, 22, 'abc'], [111, 222, 333]]
>>> schoolNames[1][2][2]  # 獲取 'abc' 裡的字元c
'c'
Copy

也就是說，操作巢狀列表，只要把要操作元素的下標當作變數名來使用即可。

2. 應用

一個學校，有3個辦公室，現在有8位老師等待工位的分配，請編寫程式，完成隨機的分配

import random

# 定義一個列表用來儲存3個辦公室
offices = [[],[],[]]

# 定義一個列表用來儲存8位老師的名字
names = ['A','B','C','D','E','F','G','H']

i = 0
for name in names:
    index = random.randint(0,2)    
    offices[index].append(name)

i = 1
for tempNames in offices:
    print('辦公室%d的人數為:%d'%(i,len(tempNames)))
    i+=1
    for name in tempNames:
        print("%s"%name,end='')
    print("\n")
    print("-"*20)

元組

Python的元組與列表類似，不同之處在於元組的元素不能修改。元組使用小括號，列表使用方括號。

>>> aTuple = ('et',77,99.9)
>>> aTuple
('et',77,99.9)
Copy

一、訪問元組

二、修改元組

說明： python中不允許修改元組的資料，包括不能刪除其中的元素。但是，tuple可以重新賦值

三、count, index

index和count與字串和列表中的用法相同

>>> a = ('a', 'b', 'c', 'a', 'b')
>>> a.index('a', 1, 3)    # 注意是左閉右開區間
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: tuple.index(x): x not in tuple
>>> a.index('a', 1, 4)
3
>>> a.count('b')
2
>>> a.count('d')
0
Copy

四、定義只有一個數據的元組

定義只有一個元素的元組，需要在唯一的元素後寫一個逗號

>>> a = (11)
>>> a
11
>>> type(a)
int
>>> a = (11,)  # 只有一個元素的元組，必須要在元素後寫一個逗號
>>> a
(11,)
>>> type(a)
tuple
Copy

五、交換兩個變數的值

# 第1種方式,使用中間變數
a = 4
b = 5
c = 0

c = a
a = b
b = c
print(a)
print(b)

# 第2種方式，直接交換。
a, b = 4, 5
a, b = b, a

print(a)
print(b)

字典

字典介紹

一、列表的缺點

當儲存的資料要動態新增、刪除的時候，我們一般使用列表，但是列表有時會遇到一些麻煩。

# 定義一個列表儲存，姓名、性別、職業
nameList = ['xiaoZhang', '男', '木匠'];

# 當修改職業的時候，需要記憶元素的下標
nameList[2] = '鐵匠'  

# 如果列表的順序發生了變化，新增年齡
nameList = ['xiaoWang', 18, '男',  '鐵匠']

# 此時就需要記憶新的下標，才能完成名字的修改
nameList[3] = 'xiaoxiaoWang'
Copy

有沒有方法，既能儲存多個數據，還能在訪問元素的很方便就能夠定位到需要的那個元素呢？

答：

字典

二、字典的使用

定義字典的格式：{鍵1:值1, 鍵2:值2, 鍵3:值3, …, 鍵n:值n}

變數info為字典型別：

info = {'name':'班長', 'id':100, 'sex':'f', 'address':'地球亞洲中國上海'}
info['name']  # 字典使用鍵來獲取對應的值
Copy

說明：

• 字典和列表一樣，也能夠儲存多個數據
• 列表中找某個元素時，是根據下標進行的；字典中找某個元素時，是根據’名字’（就是冒號:前面的那個值，例如上面程式碼中的’name’、‘id’、‘sex’）
• 字典的每個元素由2部分組成，鍵:值。例如 ‘name’:‘班長’ ,'name’為鍵，'班長’為值
• 鍵可以使用數字、布林值、布林值、元組，但是一般習慣使用字串
• 每個字典裡的key都是唯一的，如果出現了多個key,後面的value會覆蓋前一個key對應的value.

在習慣上：

• 列表更適合儲存多個商品、多個姓名、多個時間，這樣的相似資料
• 字典更適合儲存一個商品的不同資訊、一個人的不同資訊，這樣的不同資料

字典的增刪改查

一、檢視元素

除了使用key查詢資料，還可以使用get來獲取資料

info = {'name':'班長','age':18}

print(info['age']) # 獲取年齡
# print(info['sex']) # 獲取不存在的key，會發生異常

print(info.get('sex')) # 獲取不存在的key，獲取到空的內容，不會出現異常
print(info.get('sex'， '男'))  # 獲取不存在的key, 可以提供一個預設值。
Copy

注意，獲取預設值不會修改字典內容。

二、修改元素

字典的每個元素中的資料是可以修改的，只要通過key找到，即可修改

demo:

info = {'name':'班長', 'id':100}

print('修改之前的字典為 %s:' % info)

info['id'] = 200  # 為已存在的鍵賦值就是修改

print('修改之後的字典為 %s:' % info)
Copy

結果:

修改之前的字典為 {'name': '班長', 'id': 100}
修改之後的字典為 {'name': '班長', 'id': 200}
Copy

三、新增元素

如果在使用 變數名[‘鍵’] = 資料 時，這個“鍵”在字典中，不存在，那麼就會新增這個元素

demo:新增新的元素

info = {'name':'班長'}

print('新增之前的字典為:%s' % info)

info['id'] = 100  # 為不存在的鍵賦值就是新增元素

print('新增之後的字典為:%s' % info)
Copy

結果:

新增之前的字典為:{'name': '班長'}
新增之後的字典為:{'name': '班長', 'id': 100}
Copy

四、刪除元素

對字典進行刪除操作，有一下幾種：

• del
• clear()

demo:del刪除指定的元素

info = {'name':'班長', 'id':100}

print('刪除前,%s' % info)

del info['name']  # del 可以通過鍵刪除字典裡的指定元素

print('刪除後,%s' % info)
Copy

結果

刪除前,{'name': '班長', 'id': 100}
刪除後,{'id': 100}
Copy

del刪除整個字典

• 完全刪除，渣都不剩

info = {'name':'monitor', 'id':100}

print('刪除前,%s'%info)

del info  # del 也可以直接刪除變數

print('刪除後,%s'%info)
Copy

結果

刪除前,{'name': 'monitor', 'id': 100}
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'info' is not defined
Copy

clear清空整個字典

• 清空字典，最後保留{}

info = {'name':'monitor', 'id':100}

print('清空前,%s'%info)

info.clear()

print('清空後,%s'%info)
Copy

結果

清空前,{'name': 'monitor', 'id': 100}
清空後,{}

集合（set）

集合（set）是一個無序的不重複元素序列，可以使用大括號 { } 或者 set() 函式建立集合。

注意：建立一個空集合必須用 set() 而不是 { }，因為 { } 是用來建立一個空字典。

建立格式：

parame = {value01,value02,...}
或者
set((alue1,value2,...))
set([value1,value2,...])
set({value1,value2,...})

一、新增元素

語法格式如下：

s.add(x)

• 將元素 x 新增到集合 s 中，如果元素已存在，則不進行任何操作。

• set()內新增的是列表，元組，字典。

>>>thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.add("Facebook")
>>> print(thisset)
{'Taobao', 'Facebook', 'Google', 'Runoob'}
Copy

• 還有一個方法，也可以新增元素，且引數可以是列表，元組，字典等，語法格式如下：

s.update( x )
Copy

x 可以有多個，用逗號分開。

>>>thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.update({1,3})
>>> print(thisset)
{1, 3, 'Google', 'Taobao', 'Runoob'}
>>> thisset.update([1,4],[5,6])  
>>> print(thisset)
{1, 3, 4, 5, 6, 'Google', 'Taobao', 'Runoob'}
Copy

二、移除元素

語法格式如下：

s.remove( x )

將元素 x 從集合 s 中移除，如果元素不存在，則會發生錯誤。

>>>thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.remove("Taobao")
>>> print(thisset)
{'Google', 'Runoob'}
>>> thisset.remove("Facebook")   # 不存在會發生錯誤
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'Facebook'
>>>
Copy

此外還有一個方法也是移除集合中的元素，且如果元素不存在，不會發生錯誤。格式如下所示：

s.discard( x )
Copy
>>>thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.discard("Facebook")  # 不存在不會發生錯誤
>>> print(thisset)
{'Taobao', 'Google', 'Runoob'}
Copy

我們也可以設定隨機刪除集合中的一個元素，語法格式如下：

s.pop()
Copy
thisset = set(("Google", "Runoob", "Taobao", "Facebook"))
x = thisset.pop()

print(x)
print(thisset)
Copy

三、set常見方法列表

遍歷

通過for … in … 我們可以遍歷字串、列表、元組、字典等

字串遍歷

>>> a_str = "hello itcast"
>>> for char in a_str:
...     print(char,end=' ')
...
h e l l o   i t c a s t
Copy

列表遍歷

>>> a_list = [1, 2, 3, 4, 5]
>>> for num in a_list:
...     print(num,end=' ')
...
1 2 3 4 5
Copy

元組遍歷

>>> a_turple = (1, 2, 3, 4, 5)
>>> for num in a_turple:
...     print(num,end=" ")
1 2 3 4 5
Copy

字典遍歷

<1> 遍歷字典的key（鍵）

<2> 遍歷字典的value（值）

<3> 遍歷字典的項（元素）

<4> 遍歷字典的key-value（鍵值對）

想一想，如何實現帶下標索引的列表遍歷

>>> chars = ['a', 'b', 'c', 'd']
>>> i = 0
>>> for chr in chars:
...     print("%d %s"%(i, chr))
...     i += 1
...
0 a
1 b
2 c
3 d
Copy

enumerate()

enumerate() 函式用於將一個可遍歷的資料物件(如列表、元組或字串)組合為一個索引序列，同時列出資料和資料下標，一般用在 for 迴圈當中。

>>> chars = ['a', 'b', 'c', 'd']
>>> for i, chr in enumerate(chars):
...     print("%d %s"%(i, chr))
...
0 a
1 b
2 c
3 d

公共方法

一、運算子

+

>>> "hello " + "world"
'hello world'
>>> [1, 2] + [3, 4]
[1, 2, 3, 4]
>>> ('a', 'b') + ('c', 'd')
('a', 'b', 'c', 'd')
Copy

*

>>> 'ab' * 4
'ababab'
>>> [1, 2] * 4
[1, 2, 1, 2, 1, 2, 1, 2]
>>> ('a', 'b') * 4
('a', 'b', 'a', 'b', 'a', 'b', 'a', 'b')
Copy

in

>>> 'llo' in 'hello world'
True
>>> 3 in [1, 2]
False
>>> 4 in (1, 2, 3, 4)
True
>>> "name" in {"name":"chris", "age":18}
True
Copy

注意，in在對字典操作時，判斷的是字典的鍵

二、python內建函式

Python包含了以下內建函式

len

>>> len("hello itcast")
12
>>> len([1, 2, 3, 4])
4
>>> len((3,4))
2
>>> len({"a":1, "b":2})
2
Copy

注意：len在操作字典資料時，返回的是鍵值對個數。

del

del有兩種用法，一種是del加空格，另一種是del()

>>> a = 1
>>> a
1
>>> del a
>>> a
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'a' is not defined
>>> a = ['a', 'b']
>>> del a[0]
>>> a
['b']
>>> del(a)
>>> a
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'a' is not defined
Copy

max

>>> max("hello world")
'w'
>>> max([1,4,522,3,4])
522
>>> max({"a":1, "b":2})
'b'
>>> max({"a":10, "b":2})
'b'
>>> max({"c":10, "b":2})
'c'
Copy

range

>>> range(2, 10, 3)
[2, 5, 8]
>>> for x in range(2, 10, 3):
...     print(x)
...
2
5
8
Copy

注意：range 可以生成數字供 for 迴圈遍歷。三個數字分別為 起始、結束、步長

字串的format方法

1. 概念:

• str.format() 方法通過字串中的大括號{} 來識別替換欄位 replacement field，從而完成字串的格式化。
• 替換欄位 由欄位名 field name 和轉換欄位 conversion field 以及格式說明符 format specifier 組成，即一般形式為 {欄位名!轉換欄位:格式說明符}。
• 欄位名分為簡單欄位名 simple field name 和複合字段名 compound field name。而轉換欄位和格式說明符都是可選的。

2. 欄位名

form的完整格式是{欄位名!轉換字元:格式說明符}。其中欄位名師必須的，而且可以分為簡單欄位名和複合字段名。

2.1 簡單欄位名

簡單欄位名由三中寫法:

• 省略欄位名:{}
• 使用非負十進位制整數{0}
• 變數名{name}

2.1.1 省略欄位名

大括號內省略欄位名，傳遞位置引數。

• 替換欄位形式： {}
• 注意：大括號個數可以少於位置引數的個數，反之不然。

# 省略欄位名傳遞位置引數
print('我叫{}，今年{}歲。'.format('小明', 18))
"""
我叫小明，今年18歲。
"""

# 大括號個數可以少於位置引數的個數
print('我愛吃{}和{}。'.format('香蕉', '蘋果', '大鴨梨'))
"""
我愛吃香蕉和蘋果。
"""

# 大括號個數多於位置引數的個數則會報錯
# print('我還吃{}和{}。'.format('西紅柿'))
"""
IndexError: tuple index out of range
"""
Copy

2.1.2 數字欄位名

可以通過數字形式的簡單欄位名傳遞位置引數。

• 數字必須是大於等於 0 的整數。
• 帶數字的替換欄位可以重複使用。
• 數字形式的簡單欄位名相當於把 format 中的所有位置引數整體當作一個元組，通過欄位名中的數字進行取值。即 {0} 等價於 tuple[0]，所以大括號內的數字不能越界。

# 通過數字形式的簡單欄位名傳遞位置引數
print('身高{0}，家住{1}。'.format(1.8, '銅鑼灣'))
"""
身高1.8，家住銅鑼灣
"""

# 數字形式的簡單欄位名可以重複使用。
print('我愛{0}。\n她今年{1}。\n我也愛{0}。'.format('阿香', 17))
"""
我愛阿香。
她今年17。
我也愛阿香。
"""

# 體會把所有位置引數整體當成元組來取值
print('阿香愛吃{1}、{3}和{0}。'.format(
    '榴蓮', '臭豆腐', '皮蛋', '鯡魚罐頭', '螺獅粉'))
"""
阿香愛吃臭豆腐、鯡魚罐頭和榴蓮。
"""

# 嘗試一下越界錯誤
# print('{1}'.format('錯誤用法'))
"""
IndexError: tuple index out of range
"""
Copy

2.1.3 變數欄位名

使用變數名形式的簡單欄位名傳遞關鍵字引數。

• 關鍵字引數的位置可以隨意調換。

# 使用變數名形式的簡單欄位名傳遞關鍵字引數
print('我大哥是{name}，今年{age}歲。'.format(name='阿飛', age=20))
"""
我大哥是阿飛，今年20歲。
"""

# 關鍵字引數的順序可以隨意調換
print('我大哥是{name}，今年{age}歲。'.format(age=20, name='阿飛'))
"""
我大哥是阿飛，今年20歲。
"""
Copy

2.1.4 簡單欄位名的混合使用

• 混合使用數字形式和變數名形式的欄位名，可以同時傳遞位置引數和關鍵字引數。
• 關鍵字引數必須位於位置引數之後。
• 混合使用時可以省略數字。
• 省略欄位名 {} 不能和數字形式的欄位名 {非負整數} 同時使用。

# 混合使用數字形式和變數名形式的欄位名
# 可以同時傳遞位置引數和關鍵字引數
print('這是一個關於{0}、{1}和{girl}的故事。'.format(
    '小明', '阿飛', girl='阿香'))
"""
這是一個關於小明、阿飛和阿香的故事。
"""

# 但是關鍵字引數必須位於位置引數之後
# print('這是一個關於{0}、{1}和{girl}的故事。'.format(
    # '小明', girl='阿香' , '阿飛'))
"""
SyntaxError: positional argument follows keyword argument
"""

# 數字也可以省略
print('這是一個關於{}、{}和{girl}的故事。'.format(
    '小明', '阿飛', girl='阿香'))

# 但是省略欄位名不能和數字形式的欄位名同時出現
# print('這是一個關於{}、{1}和{girl}的故事。'.format(
#     '小明', '阿飛', girl='阿香'))
"""
ValueError: cannot switch from automatic field numbering to manual field specification
"""
Copy

2.1.5 使用元組和字典傳參

str.format() 方法還可以使用 *元組 和 **字典 的形式傳參，兩者可以混合使用。 位置引數、關鍵字引數、*元組 和 **字典 也可以同時使用，但是要注意，位置引數要在關鍵字引數前面，*元組 要在 **字典 前面。

# 使用元組傳參
infos = '鋼鐵俠', 66, '小辣椒'
print('我是{}，身價{}億。'.format(*infos))
"""
我是鋼鐵俠，身家66億。
"""
print('我是{2}，身價{1}億。'.format(*infos))
"""
我是小辣椒，身家66億。
"""

# 使用字典傳參
venom = {'name': '毒液', 'weakness': '火'}
print('我是{name}，我怕{weakness}。'.format(**venom))
"""
我是毒液，我怕火。
"""

# 同時使用元組和字典傳參
hulk = '綠巨人', '拳頭'
captain = {'name': '美國隊長', 'weapon': '盾'}
print('我是{}, 我怕{weapon}。'.format(*hulk, **captain))
print('我是{name}, 我怕{1}。'.format(*hulk, **captain))

"""
我是綠巨人, 我怕盾。
我是美國隊長, 我怕拳頭。
"""

# 同時使用位置引數、元組、關鍵字引數、字典傳參
# 注意：
# 位置引數要在關鍵字引數前面
# *元組要在**字典前面
tup = '鷹眼',
dic = {'weapon': '箭'}
text = '我是{1}，我怕{weakness}。我是{0}，我用{weapon}。'
text = text.format(
    *tup, '黑寡婦', weakness='男人', **dic)
print(text)
"""
我是黑寡婦，我怕男人。我是鷹眼，我用箭。
"""
Copy

2.2 複合字段名

• 同時使用了數字和變數名兩種形式的欄位名就是複合字段名。

• 複合字段名

  支援兩種操作符：

  • . 點號
  • [] 中括號

2.2.1 使用. 點號

傳遞位置引數

• 替換欄位形式：{數字.屬性名}
• 只有一個替換欄位的時候可以省略數字

class Person(object):
  def __init__(self,name,age,gender):
    self.name = name
    self.age = age
    self.gender = gender
p = Person('zhangsan',18,'female')
print('姓名是{0.name},年齡是{0.age},性別是{0.gender}'.format(p))
print('姓名是{.name}'.format(p))  # 只有一個替換欄位時，可以省略數字
Copy

2.2. 使用[]中括號

• 用列表傳遞位置引數
• 用元組傳遞位置引數
• 用字典傳遞位置引數

# 中括號用法：用列表傳遞位置引數
infos = ['阿星', 9527]
food = ['霸王花', '爆米花']
print('我叫{0[0]}，警號{0[1]}，愛吃{1[0]}。'.format(
    infos, food))
"""
我叫阿星，警號9527，愛吃霸王花。
"""

# 中括號用法：用元組傳遞位置引數
food = ('殭屍', '腦子')
print('我叫{0[0]}，年齡{1}，愛吃{0[1]}。'.format(
    food, 66))
"""
我叫殭屍，年齡66，愛吃腦子。
"""

# 中括號用法：用字典傳遞位置引數
dic = dict(name='阿星', pid=9527)
print('我是{[name]}！'.format(
    dic))
# 多個替換欄位，不能省略數字
print('我是{0[name]}，警號{0[pid]}。'.format(
    dic))
"""
我是阿星！
我是阿星，警號9527。
"""
Copy

3. 轉換欄位

轉換欄位 conversion field 的取值有三種，前面要加 !：

• s：傳遞引數之前先對引數呼叫 str()
• r：傳遞引數之前先對引數呼叫 repr()
• a：傳遞引數之前先對引數呼叫 ascii()

ascii() 函式類似 repr() 函式，返回一個可以表示物件的字串。 但是對於非 ASCII 字元，使用 \x，\u 或者 \U 轉義。

# 轉換欄位
print('I am {!s}!'.format('Bruce Lee 李小龍'))
print('I am {!r}!'.format('Bruce Lee 李小龍'))
print('I am {!a}!'.format('Bruce Lee 李小龍'))
"""
I am Bruce Lee 李小龍!
I am 'Bruce Lee 李小龍'!
I am 'Bruce Lee \u674e\u5c0f\u9f99'!
"""
Copy

4. 格式說明符

格式說明符使用過於複雜，且實際使用場景不多，暫不討論。