本篇博客為博主第一次學 Python 所做的筆記（希望讀者能夠少點浮躁，認真閱讀，平心靜氣學習！）

補充：

• 串列、元組和字串共同屬性：
  • 屬于有序序列，其中的元素有嚴格的先后順序
  • 都支持雙向索引，索引范圍 [ -L, L-1 ] ，L -- 表示串列、元組和字串的長度（分正向索引和反向索引），
    • 正向索引：0 表示第 1 個元素，1 表示第 2 個元素，2 表示第 3 個元素...
    • 反向索引：-1 表示最后 1 個元素，-2 表示倒數第 2 個元素，-3 表示倒數第 3 個元素...

一、串列（關于串列的所有內容）：

放在一對方括號中，相鄰元素之間使用逗號分隔，

• 同一個串列元素的資料型別可以各不相同，
• 串列包含：
  1. 整數、浮點數、復數、字串 等 基本型別元素，
  2. 串列、元組、字典、集合、函式 或 其他任意物件，

創建串列：

• 使用方括號直接創建
• list() 函式把元組、range 物件、字串、字典、集合，以及 map 物件、zip 物件、enumerate 物件或其他類似物件 轉換 為串列，
• 內置函式（ sorted() ）、標準庫函式（ random.sample() ）或擴展函式（ jieba.lcut() ）也會回傳串列

函式：

1. 訪問元素：

• 用戶可以使用整數作為下標來隨機訪問其中任意位置上的元素

  data = https://www.cnblogs.com/jombarry/archive/2020/10/16/list(range())
  # data = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  print(data[1])
  # 結果 1
  print(data[-1])
  # 結果 9
  ……
  

• 如果指定的下標不在有效范圍內，代碼會拋出例外提示下表越界

2. 其他常用方法：

lst - 表示串列物件

3. 推導式：

使用 非常簡潔 的方式對串列或其他可迭代物件的元素進行遍歷、過濾或再次計算，快速生成滿足特定需求的新串列，

# 格式：
[expression for expr1 in sequence1 if condition
			for expr2 in sequence2 if condition2
			for expr3 in sequence3 if condition3
			...
			for exprN in sequenceN if conditionN
]

# 例子：
data = https://www.cnblogs.com/jombarry/archive/2020/10/16/[num for num in range(20) if num%2==1]
# 等價于 =>
data = []
for num in range(20):
	if num%2 == 1:
		data.append(num)

二、元組（關于元組的所有內容）：

創建元組：

• 用圓括號放若干元素創建元組（如果只有一個元素，則需要多加一個逗號 (3,)）
• 用 tuple() 函式把 串列、字典、集合、字串 以及 range 物件、map 物件、zip 物件 或 其他類似物件轉換為元組

元組的好處（與串列對比）：

三、字典（關于字典的所有內容）：

• 屬于容器物件，其中包含若干元素，每個元素包含 “鍵” 和 “值” 兩部分，之間使用冒號分隔，表示一種對應關系，
• 不同元素之間使用逗號分隔，所有元素放在一對大括號中，
• “鍵”，可以是 Python 中任意不可變資料，例如整數、復數、字串、元組等型別；不能是串列、集合、字典或其他可變型別，包含串列等可變資料的元組也不能作為字典的 “鍵”

函式：

1. 訪問：

# 初始化
data = https://www.cnblogs.com/jombarry/archive/2020/10/16/dict(name ="張三"， age = 8, sex = 'M')

• 把 “鍵” 最為下標可以回傳對應的 “值”（不存在的話會拋出例外）

print(data('name'))
# 結果：張三

• get() 方法獲取指定的 “鍵” 對應的 “值”（不存在回傳空值或指定的值）

print(data.get('age'))
# 結果：18

• 支持元素迭代
  • 可以將其轉換為串列或元組

    print(list(data))
    # 結果：['name', 'age', 'sex']
    

  • 可以使用 for 回圈遍歷其中的元素，默認情況下是遍歷字典中的 “鍵”

    for key, value in data.items():
    	print(key, value, sep='\t')
    # 結果：name 張三
    # 結果：age 18
    # 結果：sex M
    

  • 遍歷字典元素，必須使用字典物件的 items() 方法明確說明

    print(list(data.items()))
    # 結果：[('name', '張三'), ('age', '18'), ('sex', 'M')]
    

  • 遍歷字典的 “值”，則必須使用字典物件的 values() 方法明確說明

    print(list(data.values()))
    # 結果：['張三', '18', 'M']
    

2. 修改：

當以指定 “鍵” 為下標為字典元素賦值時：

• 若該 “鍵” 存在，表示修改該 “鍵” 對應的值：

soct = {'IP': '127.0.0.1', 'port': 80}
soct['port'] = 8080
print(soct)
# 結果：{'IP': '127.0.0.1', 'port': 8080}

• 若 “鍵” 不存在，表示添加一個新元素：

soct = {'IP': '127.0.0.1', 'port': 80}
soct['protocol'] = 'TCP'
print(soct)
# 結果：{'IP': '127.0.0.1', 'port': 80, 'protocol': 'TCP'}

3. 添加：

update() 方法可以將另一個字典的元素一次性全部添加到當前字典中，如果兩個字典中存在相同的 “鍵”，則以另一個字典中的 “值” 為準對當前字典進行更新：

sock = {'IP': '127.0.0.1', 'port': 80}
sock.update({'IP': '192.168.9.62', 'protocol': 'TCP'})
print(sock)
# {'IP': '192.168.9.62', 'protocol': 'TCP', 'port': 80}

4. 洗掉：

sock = {'IP': '192.168.9.62', 'port': 80, 'protocol': 'TCP'}

• pop() 方法可以洗掉指定 “鍵” 對應的元素，同時回傳對應的 “值”，

print(sock.pop('IP'))
# 結果：192.168.9.62

• popitem() 方法用于洗掉并回傳一個包含兩個元素的元組，其中的兩個元素分別是字典元素的 “鍵” 和 “值”，

print(sock.popitem())
# 結果：('protocol', 'TCP')

• del 洗掉指定的 “鍵” 對應的元素，

del sock['port']
print(sock)
# 結果：{'IP': '192.168.9.62', 'protocol': 'TCP'}

四、集合（關于集合的所有內容）：

無序、可變的容器物件，所有元素放在一對大括號中，元素之間使用逗號分隔，同一個集合內的每個元素都是唯一的，不允許重復，

0. 創建：

• 所有元素放在一對大括號中，創建集合

data = https://www.cnblogs.com/jombarry/archive/2020/10/16/{30, 40, 50}

• 使用 set() 函式將串列、元組、字串、range 物件等其他可迭代物件轉換為集合，
• 使用集合推導式生成特定的集合，如果原來的資料中存在重復元素，在轉換為集合的時候重復的元素只保留一個，自動除去重復元素，
• 如果原序列或迭代物件中有可變型別的資料，則無法轉換成為集合，拋出例外，

特點：

• 集合內資料要求：
  • 集合中只能包含數字、字串、元組等不可變型別的資料
  • 不包含串列、字典、集合等可變型別的資料，包含串列等可變型別資料的元組也不能作為集合的元素，
• 元素是無序的，元素儲存順序和添加順序并不一致，

1. 訪問：

• 集合不支持使用下標直接訪問特定位置上的元素，也不支持使用 random 中的 choice() 函式從集合中隨機選取元素
• 支持使用 random 模塊中的 sample() 函式隨機選取部分元素，

2. 修改：

data = https://www.cnblogs.com/jombarry/archive/2020/10/16/{30, 40, 50}
data.add(20)
print(data)
# 結果：{40, 50, 20, 30}

data = {30, 40, 50}
data.update({40, 60})
print(data)
# 結果：{50, 40, 60, 30}

3. 洗掉：

data = https://www.cnblogs.com/jombarry/archive/2020/10/16/{30, 40, 50}
data.remove(30)
print(data)
# 結果：{40, 50}

data = {30, 40, 50}
data.discard(30)
print(data)
# 結果：{40, 50}

data = {30, 40, 50}
data.pop()
print(data)
# 結果：{50, 30}

五、字串（關于字串的所有內容）：

字串屬于不可變物件，

1. 編碼與解碼

2. 將資料格式轉化為特定格式的字串

常用的格式：

• b（二進制格式）
• c（把整數轉換成 Unicode 字符）
• d（十進制格式）
• o（八進制格式）
• x（小寫十六進制格式）
• X（大寫十六進制格式）
• e/E（科學計數法格式）
• f/F（固定長度的浮點數格式）
• %（使用固定長度浮點數顯示百分數）

# 保留4位小數
# 0 表示引數下標，對應第一個引數
print('{0:.4f}'.format(10/3))
# 結果：3.3333
print('{0:.2%}'.format(1/3))
# 結果：33.33%

# 格式化為百分數字串，總寬度為10，保留2位小數，> 表示右對齊
print('{0:>10.2%}'.format(1/3))
# 結果：    33.33%

# 逗號表示在數字字串中插入逗號作為千分符，#x表示格式化為十六進制數
print("{0:,} in hex is: {0:#x}, in oct is {0:#o}".format(5555555))
# 結果：5,555,555 in hex is: 0x54c563, in oct is 0O25142543

# 可以先格式化下標為 1 的引數，再格式化下標為 0 的引數
print("{1} in hex is: {1: #x}, {0} in oct is {0:o}".format(6666, 66666))
# 結果：66666 in hex is: 0x1046a, 6666 in oct is 15012

# _表示在數字中插入下劃線來為千分符
print('{0:_}, {0:#_x}'.format(10000000))
# 結果：10_000_000, 0x98_9680

3. 單個字串在字串中的相關函式

4. 字串的編輯修改

text = "python 是一門非常棒的編程語言，"
print(text.replace('棒', '優雅').replace('編程', '程式設計'))
# 結果：python 是一門非常優雅的程式設計語言，

table = ''.maketrans('0123456789', '零壹貳叁肆伍陸柒捌玖')
print('Tel:30647359'.translate(table))
# 結果：Tel:叁零陸肆柒叁伍玖

5. 字串進行排版

print('居左'.ljust(20)+'結束')
# 結果：居左				結束
print('居右'.rjust(20, '#'))
# 結果：####################居右
print('居中'.center(20, '='))
# 結果：==========居中==========

6. 自定義分隔符對字串分隔

不指定默認為空格、換行符和制表符等空白字符）作為分隔符對原字串進行分隔

text = 'Beautiful is better than ugly.'
print(text.split())
# 結果：['Beautiful', 'is', 'better', 'than', 'ugly.']

print(text.split(maxsplit=1))
# 結果：['Beautiful', 'is better than ugly.']

print('1,2,3,4'.split(','))
# 結果：['1', '2', '3', '4']

print(','.join(['1', '2', '3', '4']))
# 結果：1,2,3,4

print(':'.join(map(str, range(1, 5))))
# 結果：1:2:3:4

7. 大小寫轉換

text = 'Explicit is better than implicit.'
print(text.lower())
# 結果：explicit is better than implicit.

print(text.upper())
# 結果：EXPLICIT IS BETTER THAN IMPLICIT.

print(text.capitalize())
# 結果：Explicit is better than implicit.

print(text.title())
# 結果：Explicit Is Better Than Implicit.

print(text.swapcase())
# 結果：eXPLICIT iS bETTER tHAN iMPLICIT.

8. 判斷字串開始與結束單詞

測驗字串是否以指定的一個或幾個字串（放在元組中）開始或結束

text = 'Simple is better than complex.'
print(text.startswith('simple'))
# 結果：False

print(text.startswith('Simple'))
# 結果：True

print(text.endswith(('.', '!', '?')))
# 結果：True

9. 洗掉字串指定字符

洗掉字串兩側、右側和左側的空白字符或指定的字符

text = '     ======test===#####     '
print(text.strip())
# 結果：======test===#####

print(text.strip('=# '))
# 結果：test

標籤：其他

上一篇：求助讀取hdfs時at org.apache.parquet.hadoop.InternalParquetRecordReader會產生大量的日志，怎么抑制

下一篇：C/C++編程筆記：Windows編程入門知識，帶你從C語言到Windows