技術標籤：基本功

今天進入訓練營的第5天，今天的主要內容是：字串、字典。

字串

1. 字串的定義
2. 字串的切片與拼接
3. 字串的常用內建方法
4. 字串格式化

字典

1. 可變型別與不可變型別
2. 字典的定義
3. 建立和訪問字典
4. 字典的內建方法

字串

1.字串的定義

字串使用雙引號或者單引號包圍

常見轉義字元

print("C:\\Program Files\\Intel\\Wifi\\Help")
# C:\Program Files\Intel\Wifi\Help

#原始字串只需要在字串前邊加一個英文字母 r 即可。
 

print(r'C:\Program Files\Intel\Wifi\Help')  
# C:\Program Files\Intel\Wifi\Help

#三引號允許一個字串跨多行，字串中可以包含換行符、製表符以及其他特殊字元。
para_str = """這是一個多行字串的例項
多行字串可以使用製表符
TAB ( \t )。
也可以使用換行符 [ \n ]。
"""
print(para_str)
# 這是一個多行字串的例項
# 多行字串可以使用製表符
# TAB (    )。
# 也可以使用換行符 [
#  ]。

2.字串的切片與拼接

• 類似於元組具有不可修改性
• 從 0 開始 (和 Java 一樣)
• 切片通常寫成 start:end 這種形式，包括「start 索引」對應的元素，不包括「end索引」對應的元素。
• 索引值可正可負，正索引從 0 開始，從左往右；負索引從 -1
• 開始，從右往左。使用負數索引時，會從最後一個元素開始計數。最後一個元素的位置編號是 -1。
• [start：end：step] step 如果是負數則是逆序，如果是逆序，首先逆序之後在按步長取值

str1 = 'I Love LsgoGroup'
print(str1[:6])  # I Love
print(str1[5])  # e
print(str1[
 
:6] + " 插入的字串 " + str1[6:])  
# I Love 插入的字串  LsgoGroup

s = 'Python'
print(s)  # Python
print(s[2:4])  # th
print(s[-5:-2])  # yth
print(s[2])  # t
print(s[-1])  # n

s2='123456789abcdef'
print(s2[::-1])  #nohtyP
print(s2[::-2])  #nhy
print('a:',s2[1:-1:1]) #23456789abcde
print('b:',s2[1:-1:2]) #2468ace
print('c:',s2[0:10:-1]) #空，好像不讓這麼幹

3.字串的常用內建方法

capitalize() 將字串的第一個字元轉換為大寫
lower() 轉換字串中所有大寫字元為小寫。
upper() 轉換字串中的小寫字母為大寫。
swapcase() 將字串中大寫轉換為小寫，小寫轉換為大寫。
count(str, beg= 0,end=len(string)) 返回str在 string 裡面出現的次數，如果beg或者end指定則返回指定範圍內str出現的次數。

str2 = "DAXIExiaoxie"
print(str2.count('xi'))  # 2

endswith(suffix, beg=0, end=len(string)) 檢查字串是否以指定子字串 suffix 結束，如果是，返回 True，否則返回 False。如果 beg 和 end 指定值，則在指定範圍內檢查。
startswith(substr, beg=0,end=len(string)) 檢查字串是否以指定子字串 substr 開頭，如果是，返回 True，否則返回 False。如果 beg 和 end 指定值，則在指定範圍內檢查。
find(str, beg=0, end=len(string)) 檢測 str 是否包含在字串中，如果指定範圍 beg 和 end，則檢查是否包含在指定範圍內，如果包含，返回開始的索引值，否則返回 -1。
rfind(str, beg=0,end=len(string)) 類似於 find() 函式，不過是從右邊開始查詢。
isnumeric() 如果字串中只包含數字字元，則返回 True，否則返回 False。

str3 = '12345'
print(str3.isnumeric())  # True
str3 += 'a'
print(str3.isnumeric())  # False

**ljust(width[, fillchar])**返回一個原字串左對齊，並使用fillchar（預設空格）填充至長度width的新字串。
**rjust(width[, fillchar])**返回一個原字串右對齊，並使用fillchar（預設空格）填充至長度width的新字串。
類似oracle中的lpad，rpad

str4 = '1101'
print(str4.ljust(8, '0'))  # 11010000
print(str4.rjust(8, '0'))  # 00001101

partition(sub) 找到子字串sub，把字串分為一個三元組(pre_sub,sub,fol_sub)，如果字串中不包含sub則返回(‘原字串’,’’,’’)。
**rpartition(sub)**類似於partition()方法，不過是從右邊開始查詢。

str5 = ' I Love LsgoGroup '
print(str5.strip().partition('o'))  # ('I L', 'o', 've LsgoGroup')
print(str5.strip().partition('m'))  # ('I Love LsgoGroup', '', '')
print(str5.strip().rpartition('o'))  # ('I Love LsgoGr', 'o', 'up')

replace(old, new [, max]) 把 將字串中的old替換成new，如果max指定，則替換不超過max次。

str5 = ' I Love LsgoGroup '
print(str5.strip().replace('I', 'We'))  # We Love LsgoGroup

split(str="", num) 不帶引數預設是以空格為分隔符切片字串，如果num引數有設定，則僅分隔num個子字串，返回切片後的子字串拼接的列表。

u = "www.baidu.com.cn"
# 使用預設分隔符
print(u.split())  # ['www.baidu.com.cn']

# 以"."為分隔符
print((u.split('.')))  # ['www', 'baidu', 'com', 'cn']

# 分割0次
print((u.split(".", 0)))  # ['www.baidu.com.cn']

# 分割一次
print((u.split(".", 1)))  # ['www', 'baidu.com.cn']

# 分割兩次
print(u.split(".", 2))  # ['www', 'baidu', 'com.cn']

# 分割兩次，並取序列為1的項
print((u.split(".", 2)[1]))  # baidu

# 分割兩次，並把分割後的三個部分儲存到三個變數
u1, u2, u3 = u.split(".", 2)
print(u1)  # www
print(u2)  # baidu
print(u3)  # com.cn

去掉換行符

c = '''say
hello
baby'''

print(c)
# say
# hello
# baby

print(c.split('\n'))  # ['say', 'hello', 'baby']

splitlines([keepends]) 按照行(’\r’, ‘\r\n’, \n’)分隔，返回一個包含各行作為元素的列表，如果引數keepends為 False，不包含換行符，如果為 True，則保留換行符。

str6 = 'I \n Love \n LsgoGroup'
print(str6.splitlines())  # ['I ', ' Love ', ' LsgoGroup']
print(str6.splitlines(True))  # ['I \n', ' Love \n', ' LsgoGroup']

maketrans(intab, outtab) 建立字元對映的轉換表，第一個引數是字串，表示需要轉換的字元，第二個引數也是字串表示轉換的目標。
translate(table, deletechars="") 根據引數table給出的表，轉換字串的字元，要過濾掉的字元放到deletechars引數中。

str7 = 'this is string example....wow!!!'
str7 = 'this is string example....wow!!!'
intab = 'aeiou'
outtab = '12345'
trantab = str7.maketrans(intab, outtab)
print(chr(97)) #a
print(chr(49)) #1
#trantab是ascii碼值得對應關係
print(trantab)  # {97: 49, 111: 52, 117: 53, 101: 50, 105: 51}
print(str7.translate(trantab))  # th3s 3s str3ng 2x1mpl2....w4w!!!

4.字串格式化

format 格式化函式

str8 = "{0} Love {1}".format('I', 'Lsgogroup')  # 位置引數
print(str8)  # I Love Lsgogroup

str8 = "{a} Love {b}".format(a='I', b='Lsgogroup')  # 關鍵字引數
print(str8)  # I Love Lsgogroup

str8 = "{0} Love {b}".format('I', b='Lsgogroup')  # 位置引數要在關鍵字引數之前
print(str8)  # I Love Lsgogroup

str8 = '{0:.2f}{1}'.format(27.658, 'GB')  # 保留小數點後兩位
print(str8)  # 27.66GB

Python 字串格式化符號

print('%c' % 97)  # a
print('%c %c %c' % (97, 98, 99))  # a b c
print('%d + %d = %d' % (4, 5, 9))  # 4 + 5 = 9
print("我叫 %s 今年 %d 歲!" % ('小明', 10))  # 我叫 小明 今年 10 歲!
print('%o' % 10)  # 12
print('%x' % 10)  # a
print('%X' % 10)  # A
print('%f' % 27.658)  # 27.658000
print('%e' % 27.658)  # 2.765800e+01
print('%E' % 27.658)  # 2.765800E+01
print('%g' % 27.658)  # 27.658
text = "I am %d years old." % 22
print("I said: %s." % text)  # I said: I am 22 years old..
print("I said: %r." % text)  # I said: 'I am 22 years old.'

格式化操作符輔助指令

print('%5.1f' % 27.658)  # ' 27.7'
print('%.2e' % 27.658)  # 2.77e+01
print('%10d' % 10)  # '        10'
print('%-10d' % 10)  # '10        '
print('%+d' % 10)  # +10
print('%#o' % 10)  # 0o12
print('%#x' % 108)  # 0x6c
print('%010d' % 5)  # 0000000005

字典

1. 可變型別與不可變型別

• 序列是以連續的整數為索引，與此不同的是，字典以"關鍵字"為索引，關鍵字可以是任意不可變型別，通常用字串或數值。
• 字典是 Python 唯一的一個對映型別，字串、元組、列表屬於序列型別。

那麼如何快速判斷一個數據型別 X 是不是可變型別的呢？兩種方法：

• 麻煩方法：用 id(X) 函式，對 X 進行某種操作，比較操作前後的 id，如果不一樣，則 X 不可變，如果一樣，則 X 可變。
• 便捷方法：用 hash(X)，只要不報錯，證明 X 可被雜湊，即不可變，反過來不可被雜湊，即可變。

i = 1
print(id(i))  # 140732167000896
i = i + 2
print(id(i))  # 140732167000960

l = [1, 2]
print(id(l))  # 4300825160
l.append('Python')
print(id(l))  # 4300825160

整數 i 在加 1 之後的 id 和之前不一樣，因此加完之後的這個 i (雖然名字沒變)，但不是加之前的那個 i 了，因此整數是不可變型別。
列表 l 在附加 ‘Python’ 之後的 id 和之前一樣，因此列表是可變型別。

print(hash('Name'))  # 7047218704141848153

print(hash((1, 2, 'Python')))  # 1704535747474881831

print(hash([1, 2, 'Python']))
# TypeError: unhashable type: 'list'

print(hash({1, 2, 3}))
# TypeError: unhashable type: 'set'

數值、字元和元組 都能被雜湊，因此它們是不可變型別。 列表、集合、字典不能被雜湊，因此它是可變型別。

2. 字典的定義

字典 是無序的 鍵:值（key:value）對集合，鍵必須是互不相同的（在同一個字典之內）。

• dict 內部存放的順序和 key 放入的順序是沒有關係的。
• dict 查詢和插入的速度極快，不會隨著 key 的增加而增加，但是需要佔用大量的記憶體。

字典 定義語法為 {元素1, 元素2, ..., 元素n}

• 其中每一個元素是一個「鍵值對」-- 鍵:值 (key:value)
• 關鍵點是「大括號 {}」,「逗號 ,」和「冒號 :」
• 大括號 – 把所有元素綁在一起
• 逗號 – 將每個鍵值對分開
• 冒號 – 將鍵和值分開

3. 建立和訪問字典

通過元組作為key來建立字典，但一般不這樣使用。

dic = {(1, 2, 3): "Tom", "Age": 12, 3: [3, 5, 7]}
print(dic)  # {(1, 2, 3): 'Tom', 'Age': 12, 3: [3, 5, 7]}
print(type(dic))  # <class 'dict'>

通過建構函式dict來建立字典。

• dict() 建立一個空的字典。
• dict(mapping) new dictionary initialized from a mapping object’s (key, value) pairs

dic = dict()
dic['a'] = 1
dic['b'] = 2
dic['c'] = 3

print(dic)
# {'a': 1, 'b': 2, 'c': 3}

dic['a'] = 11
print(dic)
# {'a': 11, 'b': 2, 'c': 3}

dic['d'] = 4
print(dic)
# {'a': 11, 'b': 2, 'c': 3, 'd': 4}

dic1 = dict([('apple', 4139), ('peach', 4127), ('cherry', 4098)])
print(dic1)  # {'cherry': 4098, 'apple': 4139, 'peach': 4127}

dic2 = dict((('apple', 4139), ('peach', 4127), ('cherry', 4098)))
print(dic2)  # {'peach': 4127, 'cherry': 4098, 'apple': 4139}

這種情況下，鍵只能為字串型別，並且建立的時候字串不能加引號，加上就會直接報語法錯誤。

dic = dict(name='Tom', age=10)
print(dic)  # {'name': 'Tom', 'age': 10}
print(type(dic))  # <class 'dict'>

4. 字典的內建方法

dict.fromkeys(seq[, value]) 用於建立一個新字典，以序列 seq 中元素做字典的鍵，value 為字典所有鍵對應的初始值。

seq = ('name', 'age', 'sex')
dic1 = dict.fromkeys(seq)
print(dic1)
# {'name': None, 'age': None, 'sex': None}

dic2 = dict.fromkeys(seq, 10)
print(dic2)
# {'name': 10, 'age': 10, 'sex': 10}

dic3 = dict.fromkeys(seq, ('小馬', '8', '男'))
print(dic3)
# {'name': ('小馬', '8', '男'), 'age': ('小馬', '8', '男'), 'sex': ('小馬', '8', '男')}

**dict.keys()**返回一個可迭代物件，可以使用 list() 來轉換為列表，列表為字典中的所有鍵。

dic = {'Name': 'lsgogroup', 'Age': 7}
print(dic.keys())  # dict_keys(['Name', 'Age'])
lst = list(dic.keys())  # 轉換為列表
print(lst)  # ['Name', 'Age']

**dict.values()**返回一個迭代器，可以使用 list() 來轉換為列表，列表為字典中的所有值。

dic = {'Sex': 'female', 'Age': 7, 'Name': 'Zara'}
print(dic.values())
# dict_values(['female', 7, 'Zara'])

print(list(dic.values()))
# [7, 'female', 'Zara']

**dict.items()**以列表返回可遍歷的 (鍵, 值) 元組陣列。

dic = {'Name': 'Lsgogroup', 'Age': 7}
print(dic.items())
# dict_items([('Name', 'Lsgogroup'), ('Age', 7)])

print(tuple(dic.items()))
# (('Name', 'Lsgogroup'), ('Age', 7))

print(list(dic.items()))
# [('Name', 'Lsgogroup'), ('Age', 7)]

dict.get(key, default=None) 返回指定鍵的值，如果值不在字典中返回預設值。

dic = {'Name': 'Lsgogroup', 'Age': 7}
print("Age 鍵的值為 : %s" % dic.setdefault('Age', None))  # Age 鍵的值為 : 7
print("Sex 鍵的值為 : %s" % dic.setdefault('Sex', None))  # Sex 鍵的值為 : None
print(dic)  
# {'Age': 7, 'Name': 'Lsgogroup', 'Sex': None}

key in dict in 操作符用於判斷鍵是否存在於字典中，如果鍵在字典 dict 裡返回true，否則返回false。而not in操作符剛好相反，如果鍵在字典 dict 裡返回false，否則返回true。

**dict.pop(key[,default])**刪除字典給定鍵 key 所對應的值，返回值為被刪除的值。key 值必須給出。若key不存在，則返回 default 值。
del dict[key] 刪除字典給定鍵 key 所對應的值。

dic1 = {1: "a", 2: [1, 2]}
print(dic1.pop(1), dic1)  # a {2: [1, 2]}

# 設定預設值，必須新增，否則報錯
print(dic1.pop(3, "nokey"), dic1)  # nokey {2: [1, 2]}

del dic1[2]
print(dic1)  # {}

**dict.popitem()**隨機返回並刪除字典中的一對鍵和值，如果字典已經為空，卻呼叫了此方法，就報出KeyError異常。
**dict.clear()**用於刪除字典內所有元素。
**dict.copy()**返回一個字典的淺複製。
**dict.update(dict2)**把字典引數 dict2 的 key:value對 更新到字典 dict 裡。