那些年被我坑過的Python——不得不知（第二章）

問題一：

　　Python3.5.X中的數據類型有哪些？

　　答：包括整型、布爾型、字符串型、浮點型、複數、列表、字典、集合、元組。

　　細化來講：

　　　　一、整型包括短整型和長整型，不過咱們沒必要過分操心細節，由於短整型和長整型之間是隱式切換的，Py本身會根據數值大小自行選擇適合的整型。

　　　　二、字符串型，須要用成對的引號標識，它的內置函方法的使用以下：

  1 a = "test for data type"
  2 # 首字母大寫
  3 a = a.capitalize()
  4 print(a)
  5 
  6 a = "TEST FOR DATA TYPE"
  7 # 測試發現是忽略大小寫的意思
  8 # Return a version of S suitable for caseless comparisons.
  9 # 返回一個字符串，適用於忽視大小寫的字符串對比
 10 a = a.casefold()
 11 
 12 print(a)
 13 
 14 # 居中格式化輸出的小工具
 15 a = a.center(50, "+")
 16 print(a)
 17 
 18 # 返回字符串中包含的子串的個數（能夠設定起止位置）
 19 
 20 a = "test for data type"
 21 print(a.count('t', 0, -5))
 22 
 23 # 對a進行編碼後再解碼默認是UTF-8
 24 b = a.encode(encoding='gb2312')
 25 a = b.decode()
 26 print("after coding change a='", a, "'")
 27 
 28 # 判斷是否以某個子串結尾或是開頭
 29 print(a.endswith('ype'))
 30 print(a.startswith('te'))
 31 
 32 # 設置tab所對應的空格數，便於輸出的美化
 33 a = 't\te\ts\tt\t'
 34 print(a.expandtabs(20))
 35 
 36 # 返回子串的索引值(能夠設定起止位置)
 37 print(a.find('t', 0, -1))
 38 # 反向查找（獲取的索引仍是正常的序）
 39 print(a.rfind('t'))
 40 
 41 # 字符串的格式化輸出，這裏再也不贅述
 42 # a.format()
 43 
 44 # 獲取子串的索引值，這和find()的區別是什麼？？？
 45 print(a.index('t', 0, -1))
 46 # 反向獲取子串的索引值（索引仍是正常的序）
 47 print(a.rindex('t'))
 48 
 49 # 判斷字符串是否僅由字母和數字構成
 50 a = 'aBc123'
 51 print(a.isalnum())
 52 
 53 # 判斷是否全是字母構成
 54 a = 'aBc'
 55 print(a.isalpha())
 56 
 57 # 判斷是否爲十進制的
 58 a = '0x11'
 59 b = '011'
 60 c = '0b1100011'
 61 d = '110'
 62 print('isdecimal', a.isdecimal(), b.isdecimal(), c.isdecimal(), d.isdecimal())
 63 
 64 # 判斷是否爲純數字的,這和isdecimal()有什麼區別？
 65 # a = '0123'
 66 print('isdigit', a.isdigit(), b.isdigit(), c.isdigit(), d.isdigit())
 67 
 68 # 判斷是否爲純數字的,這和isdecimal()有什麼區別？這三個函數是否是有重疊的嫌疑？
 69 print('isnumeric', a.isnumeric(), b.isnumeric(), c.isnumeric(), d.isnumeric())
 70 
 71 # 判斷是否符合變量的命名規範！
 72 print("__Aa123__".isidentifier())
 73 
 74 # 判斷字符串中的字母（忽略其餘字符）是否所有爲大寫字母或是小寫字母
 75 a = 'a\tac12 c '
 76 print(a.islower())
 77 a = 'A\tAC12 C '
 78 print(a.isupper())
 79 
 80 # 可打印顯示出來的字符
 81 a = '@*%&$^'
 82 print(a.isprintable())
 83 
 84 # 是否是空格，不解釋
 85 a = ' '
 86 print(a.isspace())
 87 
 88 a = 'never give up!'
 89 print(a)
 90 a = a.title()
 91 print(a)
 92 print(a.istitle())
 93 
 94 a = 'never\ngive up\tyounger!'
 95 # 按指定的分隔符把字符串拆分紅列表，默認的分隔符任何空白字符
 96 b = a.split(None, 1)
 97 print(b)
 98 
 99 # 按指定的鏈接符把列表合成字符串，與split()互反
100 print("\t".join(b))
101 
102 # 查找分隔符的方向是從右到左
103 print(a.rsplit(None, 1))
104 
105 # 按換行符號進行分隔
106 print(a.splitlines())
107 
108 # 左對齊，總長固定，空位用單個字符補齊
109 print(a.ljust(50, "t"))
110 
111 # 右對齊，總長固定，空位用單個字符補齊
112 print(a.rjust(50, "t"))
113 # 右對齊，總長固定，空位用'0'補齊
114 print(a.zfill(50))
115 
116 # 剝離邊界上的子串
117 a = "!tree!"
118 print(a.strip("e!"))
119 print(a.lstrip("!"))
120 print(a.rstrip("!"))
121 
122 a = "13222334455"
123 # 生成對字符串的字符轉換表
124 trans1 = "".maketrans("123456abcdefg", "fedcba7654321")
125 # 利用轉換表對字符串進行轉換
126 print(a.translate(trans1))
127 
128 # 字符串替換舊、新、多少個,這裏到結尾
129 print(a.replace('222', 'abc', -1))
130 
131 a = 'aA123bBccc456DDD123ddd'
132 # 字母大小寫調換，小寫變大寫，大寫變小寫
133 print(a.swapcase())
134 
135 
136 # 我的感受用途不大,只分紅三段的狀況下適用
137 # 就是按某個分隔符將字符串分爲三部分，分別是分隔符前的、分隔符、分隔符後的
138 print(a.partition('2'))
139 # 優先從高位遇到的第一個分隔符截
140 print(a.rpartition('2'))

View Code

　　　　三、浮點型：須要注意科學計數法的表示：

　　　　　　如：1.2345E+1表示：1.2345*（10**1）=12.345

　　　　　　　　1.2345E-1表示：1.2345*（10**-1）=0.12345

　　　　四、複數：表示方法參照 4+8j，注意其中使用虛數部分用 j 標識而不是數學書上的 i，由於這裏採用的是工程標準

　　　　五、列表：列表內置方法簡介：

 1 # 追加一個元素
 2 .append("something")
 3 # 在指定的索引位置上插入新元素，原位置以及以後元素依次自動後移
 4 .insert()
 5 # # 經過添加迭代器中的元素實現列表擴展
 6 .extend()
 7 
 8 # 統計某個元素出現的次數
 9 .count("re")
10 
11 # 按ASCII碼錶順序排
12 .sort()
13 # 列表內元素倒序輸出
14 .reverse()
15 
16 # 淺拷貝
17 .copy()
18 
19 # 按索引號彈出，默認-1即最後一個元素
20 .pop()
21 # 移除指定元素
22 .remove("re")
23 # 清空
24 .clear()

View Code

　　　　六、字典：字典是無序的，是經過key值找到對應的value，因此key是惟一的！

 1 # ------------------------------增增增改改改--------------------------------
 2 # 字典的建立：
 3 d_test = {"a": "1", "b": "1"}
 4 
 5 # 字典新增元素，若是key存在則更新，不存在則增長新記錄
 6 d_test["b"] = "2"
 7 d_test["c"] = "3"
 8 
 9 # 字典新增元素，若是key存在則pass，不存在則增長新記錄
10 d_test.setdefault("c", "4")
11 d_test.setdefault("d", "5")
12 print(d_test)
13 
14 # 實現了兩個字典的合併，key存在的，更新value，key不存在則新增記錄
15 d_test1 = {"a": "10", "d": "4", "f": 100}
16 d_test.update(d_test1)
17 print(d_test)
18 
19 # 根據key建立一個新字典,第一個參數必須是迭代器類型，第二個參數是給每一個key賦的統一值
20 # Returns a new dict with keys from iterable and values equal to value.
21 d_test2 = d_test.fromkeys(["x", "y", "z", "u"], [1, 2, 3, 4])
22 print(d_test2)
23 
24 # ---------------------------查查查------------------------------
25 # 根據key獲取value的兩種方法
26 print(d_test["b"], d_test.get("a"))
27 
28 # 判斷字典中是否存在某個key
29 print("c" in d_test)
30 
31 # 分別輸出'dict_keys dict_values dict_items三個類
32 print(type(d_test.keys()), type(d_test.values()), type(d_test.items()))
33 # 均可以經過循環遍歷的方式獲取值
34 for i in d_test.keys():
35     print(i)
36 
37 # 對比下列兩種獲取字典中key value信息的方法
38 # 第一種更高效，由於第二種須要將字典先轉換爲元組後才分別賦值給i,j
39 for i in d_test:
40     print(i, d_test[i])
41 
42 for i, j in d_test.items():
43     print(i, j)
44 
45 # ------------------------------刪刪刪---------------------------------
46 # 根據key刪除字典中的記錄
47 d_test.pop("c")
48 
49 # 調用通用方法刪除
50 del d_test["a"]
51 
52 # 隨機彈出一條記錄
53 d_test.popitem()
54 print(d_test)
55 
56 # -------------------------------嵌套------------------------------------
57 # 多級嵌套字典的使用，獲取數據其實就是從外到內層層打開
58 multi_level_dict_test = {
59     "a": {
60         "a1": ["a11", "a12"]
61     },
62     "b": {
63         "b1": ["b11", "b12"]
64     },
65     "c": {
66         "c1": ["c11", "c12"]
67     }
68 }
69 
70 print(multi_level_dict_test["b"]["b1"][1])
71 
72 
73 
74 """
75 字典對象的內置方法：
76 d_test.copy()
77 d_test.get()
78 
79 d_test.keys()
80 d_test.values()
81 d_test.items()
82 
83 d_test.pop()
84 d_test.popitem()
85 d_test.clear()
86 
87 d_test.setdefault()
88 d_test.update()
89 d_test.fromkeys()
90 """

View Code

　　　　七、集合：暫略

　　　　八、元組：與列表的區別是，不能夠更改，只包含兩個方法：分別是count（）統計某個元素的個數，index（）獲取某個元素的索引。

問題二：

　　Python模塊是什麼？怎麼分類，如何調用？

　　　　一、Python的模塊是什麼？

　　　　　　按我個人理解就是一些供其餘開發人員使用的.py文件集合而成的目錄，實現了代碼的重用，縮減開發成本，再簡單而言就是前人寫好的代碼，並且經過import能夠拿來即用。

　　　　二、怎麼分類：

　　　　　　最簡單的分類無非就是：標準庫和第三方庫，標準庫包含的更多的是通用型的代碼，第三方庫是包含着某一個細化領域的深刻實現；

　　　　三、如何調用這些庫？

　　　　　　無非就是使用import或from...import...來實現，兩種導入方式的區別？我是這麼理解的，import須要將整個模塊目錄下所有的文件加載，這樣若是該模塊包含的內容較多的時候不只會影響效率，也不符合精益理論思想，因此在這種狀況下徹底能夠導入此模塊目錄下的某一個具體的文件，這樣就能夠有針對性的加載，from模塊目錄import Py文件。

問題三：

　　什麼叫切片？怎麼使用？

　　切片是獲取一個對象子元素集的方法，好比字符串是由一個個的字符按序構成，列表中的元素也是按序存放，因此對於這種子元素之間有明顯順序關係的對象，就能夠經過切片來實現獲取它子元素集，說的有點抽象，但舉幾個例子就清楚了：

　　

 1 a="Str is String!"
 2 
 3 # 從頭至尾
 4 print(a[:])
 5 >>>Str is String!
 6 
 7 # 從頭到最後一個元素以前（不包含最後一個），-1表示最後一個元素
 8 print(a[:-1])
 9 >>>Str is String
10 
11 # 從第一個元素到尾，說明切片獲取的是一個左閉右開的區間
12 print(a[0:])
13 >>>Str is String!
14 
15 # 從倒數第五個元素截取到倒數第二個（固然不包含倒數第二個）
16 print(a[-5:-2])
17 >>>rin
18 
19 # 這裏有意思的來了，截取還能夠設定步長，步長step>0 則每隔|step|-1截取一個元素
20 # start和end標識了子串的起止，step決定了截取的間隔。
21 print(a[3:-1:2])
22 >>> sSrn
23 
24 # 若是步長爲負數，則表示從右向左截取，同時start和end也要使用反向來排列
25 # 此時的子串爲左開右閉，正好和以前講的相反，間隔一樣是|step|-1
26 print(a[-1:-7:-2])
27 >>> !nr

View Code

 

問題四：

　　操做符與優先級：（參考自：http://www.yiibai.com/python/python_basic_operators.html）

　　　　操做符

	描述符	例子
+	加法 - 對操做符的兩側增長值	a + b = 30
-	減法 - 減去從左側操做數右側操做數	a - b = -10
*	乘法 - 相乘的運算符兩側的值	a * b = 200
/	除 - 由右側操做數除以左側操做數	b / a = 2
%	模 - 由右側操做數和餘返回除以左側操做數	b % a = 0
**	指數- 執行對操做指數（冪）的計算	a**b = 10 的冪 20
//	地板除 - 操做數的除法，其中結果是將小數點後的位數被除去的商。	9//2 =  4 而 9.0//2.0 = 4.0

Python的比較操做符：

假設變量a持有10和變量b持有20，則：

運算符	描述	示例
==	檢查，兩個操做數的值是否相等，若是是則條件變爲真。	(a == b) 不爲 true.
!=	檢查兩個操做數的值是否相等，若是值不相等，則條件變爲真。	(a != b) 爲 true.
<>	檢查兩個操做數的值是否相等，若是值不相等，則條件變爲真。	(a <> b) 爲 true。這個相似於 != 運算符
>	檢查左操做數的值是否大於右操做數的值，若是是，則條件成立。	(a > b) 不爲 true.
<	檢查左操做數的值是否小於右操做數的值，若是是，則條件成立。	(a < b) 爲 true.
>=	檢查左操做數的值是否大於或等於右操做數的值，若是是，則條件成立。	(a >= b) 不爲 true.
<=	檢查左操做數的值是否小於或等於右操做數的值，若是是，則條件成立。	(a <= b) 爲 true.

Python賦值運算符：

假設變量持有10和變量b持有20，則：

運算符	描述	示例
=	簡單的賦值運算符，賦值從右側操做數左側操做數	c = a + b將指定的值 a + b 到  c
+=	加法AND賦值操做符，它增長了右操做數左操做數和結果賦給左操做數	c += a 至關於 c = c + a
-=	減AND賦值操做符，它減去右邊的操做數從左邊操做數，並將結果賦給左操做數	c -= a 至關於 c = c - a
*=	乘法AND賦值操做符，它乘以右邊的操做數與左操做數，並將結果賦給左操做數	c *= a 至關於 c = c * a
/=	除法AND賦值操做符，它把左操做數與正確的操做數，並將結果賦給左操做數	c /= a 至關於= c / a
%=	模量AND賦值操做符，它須要使用兩個操做數的模量和分配結果左操做數	c %= a is equivalent to c = c % a
**=	指數AND賦值運算符，執行指數（功率）計算操做符和賦值給左操做數	c **= a 至關於 c = c ** a
//=	地板除，並分配一個值，執行地板除對操做和賦值給左操做數	c //= a 至關於 c = c // a

Python位運算符：

位運算符做用於位和位操做執行位。假設，若是a =60;且b =13;如今以二進制格式它們將以下：

a = 0011 1100

b = 0000 1101

-----------------

a&b = 0000 1100

a|b = 0011 1101

a^b = 0011 0001

~a  = 1100 0011

Python語言支持下位運算符

操做符	描述	示例
&	二進制和複製操做了一下，結果，若是它存在於兩個操做數。	(a & b) = 12 即 0000 1100
|	二進制或複製操做了一個比特，若是它存在一個操做數中。	(a | b) = 61 即 0011 1101
^	二進制異或運算符的副本，若是它被設置在一個操做數而不是兩個比特。	(a ^ b) =  49 即  0011 0001
~	二進制的補運算符是一元的，並有「翻轉」位的效果。	(~a ) =  -61 即 1100 0011以2的補碼形式因爲帶符號二進制數。
<<	二進位向左移位運算符。左操做數的值左移由右操做數指定的位數。	a << 2 = 240 即 1111 0000
>>	二進位向右移位運算符。左操做數的值是由右操做數指定的位數向右移動。	a >> 2 = 15 即 0000 1111

Python邏輯運算符：

Python語言支持如下邏輯運算符。假設變量a持有10和變量b持有20則：

運算符	描述	示例
and	所謂邏輯與運算符。若是兩個操做數都是真的，那麼則條件成立。	(a and b) 爲 true.
or	所謂邏輯OR運算符。若是有兩個操做數都是非零而後再條件變爲真。	(a or b) 爲 true.
not	所謂邏輯非運算符。用於反轉操做數的邏輯狀態。若是一個條件爲真，則邏輯非運算符將返回false。	not(a and b) 爲 false.

Python成員運算符：

除了前面討論的運算符，Python成員運算符，在一個序列中成員資格的測試，如字符串，列表或元組。有兩個成員運算符解釋以下：

操做符	描述	示例
in	計算結果爲true，若是它在指定找到變量的順序，不然false。	x在y中，在這裏產生一個1，若是x是序列y的成員。
not in	計算結果爲true，若是它不找到在指定的變量順序，不然爲false。	x不在y中，這裏產生結果不爲1，若是x不是序列y的成員。

Python標識運算符：

標識符比較兩個對象的內存位置。兩個運算符標識解釋以下：

運算符	描述	例子
is	計算結果爲true，若是操做符兩側的變量指向相同的對象，不然爲false。	x是y，這裏結果是1，若是id（x）的值爲id（y）。
is not	計算結果爲false，若是兩側的變量操做符指向相同的對象，不然爲true。	x不爲y，這裏結果不是1，當id（x）不等於id（y）。

Python運算符優先級

下表列出了全部運算符從最高優先級到最低。

運算符	描述
**	冪（提升到指數）
~ + -	補碼，一元加號和減號（方法名的最後兩個+@和 - @）
* / % //	乘，除，取模和地板除
+ -	加法和減法
>> <<	左，右按位轉移
&	位'AND'
^ |	按位異'或`'和按期`或'
<= < > >=	比較運算符
<> == !=	等式運算符
= %= /= //= -= += *= **=	賦值運算符
is is not	標識運算符
in not in	成員運算符
not or and	邏輯運算符