Python次日課程

時間 2019-11-12

標籤 python 次日課程欄目 Python 简体版

原文原文鏈接

建立列表的方式html

list= [XX,XX]python

或git

list1 = list（）使用list方法，將字符串或元祖建立爲列表json

列表名[其實位置：結束位置] 取列表中的特定元素api

>>> nameapp

['aa', 'cc', 'dd', 33, 4, 5, 6, 8]yii

>>> name[1:3]函數

['cc', 'dd']ui

若是從後向前取，則從-1開始spa

>>> name

['aa', 'cc', 'dd', 33, 4, 5, 6, 8]

>>> name[-5:-3]

[33, 4]

從一個位置取到列表結束

>>> name

['aa', 'cc', 'dd', 33, 4, 5, 6, 8]

>>> name[3:]

[33, 4, 5, 6, 8]

從開始取到一個位置

>>> name

['aa', 'cc', 'dd', 33, 4, 5, 6, 8]

>>> name[:3]

['aa', 'cc', 'dd']

默認狀況下，每次取值步長爲1，那麼若是要改變步長，也就是若是要隔1個取一個，則

>>> name

['aa', 'cc', 'dd', 33, 4, 5, 6, 8]

>>> name[::2]

['aa', 'dd', 4, 6]

上面步長爲2，則隔一個取一個，若是爲3則隔兩個取一個

列表名.copy //複製列表，可是若是是多維列表，則僅copy外層的列表，在層列表中內層列表的位置僅複製內存地址。所以若是新複製的列表中內層列表值變化，則新舊的表的內層列表值都會變化。

>>> name = [1,2,3,4,5,6]

>>> name1 = name.copy()

>>> name1

[1, 2, 3, 4, 5, 6]

>>> import copy

>>> name1 = name.copy()

>>> name

['aa', 'cc', 'dd', 33, 4, 5, 6, 8]

>>> name1.insert(1,["fs","dg",448])

>>>

>>> name

['aa', 'cc', 'dd', 33, 4, 5, 6, 8]

>>> name1

['aa', ['fs', 'dg', 448], 'cc', 'dd', 33, 4, 5, 6, 8]

>>> name2 = copy.deepcopy(name1)

>>> name2

['aa', ['fs', 'dg', 448], 'cc', 'dd', 33, 4, 5, 6, 8]

>>>

>>> name2[1][1]= "ss"

>>> name1

['aa', ['fs', 'dg', 448], 'cc', 'dd', 33, 4, 5, 6, 8]

>>> name2

['aa', ['fs', 'ss', 448], 'cc', 'dd', 33, 4, 5, 6, 8]

>>>

若是要將內層列表也複製，則應該是使用標準庫copy

import copy

name1 = copy.deepcopy(name),這樣name1的值就會徹底複製name列表，改變name1不會影響name列表

列表名.reverse （）翻轉列表內的元素，例如原來是 [1,2,3,4]，翻轉後變成[4,3,2,1]，會改變源列表

>>> name

[6, 5, 4, 3, 2, 1]

>>> name.reverse()

>>> name

[1, 2, 3, 4, 5, 6]

列表名.remove(列表中的元素），刪除列表中出現的第一個元素內容，會改變源列表

>>> name

['aa', 'cc', 'dd', 33, 4, 8, 5, 6, 8]

>>> name.remove(8)

>>> name

['aa', 'cc', 'dd', 33, 4, 5, 6, 8]

列表名.insert（插入位置，插入內容），在插入位置中插入內容，會改變源列表

>>> name

[1, 2, 4, 5, 6]

>>> name.insert(2,5)

>>> name

[1, 2, 5, 4, 5, 6]

列表名.append（插入內容），在最後追加插入內容，會改變源列表

>>> name

['aa', 'cc', 'dd', 33, 4, 8, 5, 6]

>>> name.append(8)

>>> name

['aa', 'cc', 'dd', 33, 4, 8, 5, 6, 8]

列表名.pop（列表位置），刪除列表爲止的元素，按角標刪除，並顯示刪除的內容，會改變源列表

>>> name1

['aa', ['fs', 'dg', 448], 'cc', 'dd', 33, 4, 5, 6, 8]

>>> name1.pop(1)

['fs', 'dg', 448]

>>> name1

['aa', 'cc', 'dd', 33, 4, 5, 6, 8]

列表名.extend（另外一個列表名），將另外一個列表追加到當前列表的後面，會改變源列表

>>> list1

[3, 4, 5, 6]

>>> list2

[88, 99, 10]

>>> list2.extend(list1)

>>> list2

[88, 99, 10, 3, 4, 5, 6]

列表名.index（內容），查詢內容在列表中出現的第一個位置，全部此類查詢都只是以元素查詢，即若是查詢9則99 999都不會被查到，也就是並不能查到一個元素中包含9的數量，而是精確查找9

>>> list1

[3, 4, 5, 6]

>>> print(list1.index(3))

>>>

列表名.sort（），將當前列表排序，在python 2中能夠將字符串和數字一塊兒排列，可是在python3中則不能一塊兒排列，會改變源列表

>>> list3

['aa', 'bb', 'cc']

>>> list3[1]="dd"

>>> list3.sort()

>>> list3

['aa', 'cc', 'dd']

>>> list3

['aa', 'cc', 'dd', 44]

>>> list3.sort()

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

TypeError: unorderable types: int() < str()

列表名.count（內容），查詢內容在列表中出現的次數，精確匹配

>>> list4

['aa', 'cc', 4, 5, 4, 66, 99]

>>> list4.count(4)

>>> list4.count(6)

del 列表[1] 刪除列表中1角標的元素，del能夠用來刪除全部的內容，包括變量，列表，元素

判斷內容是否在列表中

if "F0B2.E58F.F162" in MACLIST:

print("True")

else:

print("false")

元組的定義

元組是指不能被更改的列表，一旦列表被定義爲元組，則元組內的元素將不能被修改

元組的定義方法 list = （），列表使用[]定義，元組使用（）定義

在元組的操做中，只有index和count可用

將元組列表話，元組名.list()

字符串操做

strip（），用來去掉字符串中的字符，默認爲空格，若是要去掉特別的字符在括號中代表，會改變源字符串

>>> name

'liubo]'

>>> name1 = name.strip("]")

>>> name1

'liubo'

split（），分離將字符串按照具體的符號分離爲列表，具體符號在括號中定義，不會改變源字符串

>>> maclist

'F0B2.E58F.F162,F0B2.E58F.88C9,F0B2.E58F.EE46,F0B2.E58F.F1A6,F0B2.E58F.EC50,F0B2.E58F.F1A7,F0B2.E58F.F17E,F0B2.E58F.F089,F0B2.E58F.F026,F0B2.F58F.F15D,F0B2.F58F.F056,F0B2.E58F.EE1E,F0B2.F58F.EFFF,F0B2.E58F.F17A,F0B2.E58F.F16C,F0B2.E58F.ECD4,F0B2.E58F.F19C,F0B2.E58F.F170,F0B2.E58F.ECC5,F0B2.E58F.EC5D,F0B2.E58F.ECC3,F0B2.E58F.8792,F0B2.E58F.F198,F0B2.E58F.ECDA,F0B2.E58F.F0EA,F0B2.E58F.F147,F0B2.E58F.F195,F0B2.E58F.F08C,F0B2.E58F.F19B,F0B2.E58F.F06A'

>>> MACLIST = maclist.split(",")

>>> MACLIST

['F0B2.E58F.F162', 'F0B2.E58F.88C9', 'F0B2.E58F.EE46', 'F0B2.E58F.F1A6', 'F0B2.E58F.EC50', 'F0B2.E58F.F1A7', 'F0B2.E58F.F17E', 'F0B2.E58F.F089', 'F0B2.E58F.F026', 'F0B2.F58F.F15D', 'F0B2.F58F.F056', 'F0B2.E58F.EE1E', 'F0B2.F58F.EFFF', 'F0B2.E58F.F17A', 'F0B2.E58F.F16C', 'F0B2.E58F.ECD4', 'F0B2.E58F.F19C', 'F0B2.E58F.F170', 'F0B2.E58F.ECC5', 'F0B2.E58F.EC5D', 'F0B2.E58F.ECC3', 'F0B2.E58F.8792', 'F0B2.E58F.F198', 'F0B2.E58F.ECDA', 'F0B2.E58F.F0EA', 'F0B2.E58F.F147', 'F0B2.E58F.F195', 'F0B2.E58F.F08C', 'F0B2.E58F.F19B', 'F0B2.E58F.F06A']

"".join()，合併列表爲字符串，""中定義了合併後原來列表元素的分隔符，要合併的列表名寫在括號內，不會改變源列表

>>> MACLIST

>>> newlist = "|".join(MACLIST)

>>> newlist

判斷字符串中是否存在特定字符

print（「」 in name）判斷那麼字符串中是否存在空格，「」表明空格，若是須要查其餘的在「」內輸入

字符串名.capitalize（）字符串首字母大寫

字符串名.format（）格式化輸出

>>> msg = "hello,{name} your age is {age}?"

>>> print(msg.format(name = "liubo",age=30))

hello,liubo your age is 30?

>>> msg2 = "hahahah{0},dddd{1}"

>>> print(msg2.format("aaa",333))

hahahahaaa,dddd333

第二種方法中的序號必須按順序不能跳

字符串切片，同列表切片

字符串名.center()，將字符串取中，兩邊用具體字符填充，其中40表明總填充的值，字符串將在40中間的位置也就是兩邊各20的位置顯示

>>> name = "liubo"

>>> name.center(40,"-")

'-----------------liubo------------------'

字符串名.find（）查找字符串中是否有具體的值，值填入括號中，並將值所在的第一個位置的索引顯示出來，若是沒有則爲-1

>>> name = "iulbo"

>>> name.find("l")

>>> name.find("x")

-1

字符串名.isdigit() 判斷字符串是否爲數字

age=input("yourage:")

if age.isdigit():

age = int(age)

else:

print("invalid data type")

同理，isalnum()判斷字符串中是否包含阿拉伯數字

字符串名.endswith("xx") 判斷字符串是否以xx結尾

字符串名.startswith("xx") 判斷字符串是否以xx開始

字符串名.upper()，字符串改大寫

字符串名.lower()，字符串改小寫

操做符	描述符	例子
+	加法 - 對操做符的兩側增長值	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

源文檔 <http://www.yiibai.com/python/python_basic_operators.html>

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

源文檔 <http://www.yiibai.com/python/python_basic_operators.html>

運算符	描述	示例
=	簡單的賦值運算符，賦值從右側操做數左側操做數	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

源文檔 <http://www.yiibai.com/python/python_basic_operators.html>

操做符	描述	示例
&	二進制和複製操做了一下，結果，若是它存在於兩個操做數。	(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

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

源文檔 <http://www.yiibai.com/python/python_basic_operators.html>

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

源文檔 <http://www.yiibai.com/python/python_basic_operators.html>

運算符

描述

例子

計算結果爲true，若是操做符兩側的變量指向相同的對象，不然爲false。

x是y，這裏結果是1，若是id（x）的值爲id（y）。

a = "sss"

type(a) is str

true

is not

計算結果爲false，若是兩側的變量操做符指向相同的對象，不然爲true。

x不爲y，這裏結果不是1，當id（x）不等於id（y）。

源文檔 <http://www.yiibai.com/python/python_basic_operators.html>

Python運算符優先級

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

[ 查看示例 ]

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

源文檔 <http://www.yiibai.com/python/python_basic_operators.html>

二進制左移 > > 開根

右移，2次方

循環

while true：爲真就循環，爲了不出現死循環，應該設置一個退出條件

例如

count = 0

while true：

count +=1

print（「test」）

if count == 100 ：

print（「end」）

break

當須要在循環中的一個區間單獨設置，也就是終端當前循環，直接開始下一個循環，使用continue

continue，終端當前循環，繼續下一個循環

下例子中當count在50到60之間時，執行continue，所以不會打印test

count = 0

while true：

count +=1

if count > 50 and count < 60: /

continue

print（「test」）

if count == 100 ：

print（「end」）

break

break，直接終止循環

字典

字典格式的定義使用{}，列表爲[]，元組是（）

字典中能夠嵌套字典

字典的第一個字段是key字段，字典會基於key字段去重複

下例中的1,2就是第一個字段

>>> dict_db = {

... 1:{

... "liubo":{

... "age":30,

... "addr":"beijing"

... },

... "liubo2":{

... "age":33,

... "addr":"ganshu"

... },

... 2:{

... "zhangsan":{

... "age":20,

... "addr":"guangdong"

...

... }

...

... }

>>>

>>> print(dict_db)

{1: {'liubo': {'addr': 'beijing', 'age': 30}, 'liubo2': {'addr': 'ganshu', 'age': 33}}, 2: {'zhangsan': {'addr': 'guangdong', 'age': 20}}}

字典的元素的定義格式是key：value的模式，例如上面的「age」：30

下列操做字典名後面[]內的層級依據實際狀況

字典名[字典key字段的值] 取字典中的值

>>> dict_db[2] //[2]是字典中的key字段的值，上例中是1 和2 本例取2

{'zhangsan': {'addr': 'guangdong', 'age': 20}}

字典名[字典key字段的值] [內部字段名] = XXX 改變字典中特定字段內特別變量的值

>>> dict_db[2]["zhangsan"]["addr"] = "USA"

>>> dict_db[2]["zhangsan"]

{'addr': 'USA', 'age': 20}

字典名[字典key字段的值] [新的內部字段名] = XXX 在字典中增長字段

>>> dict_db[2]["zhangsan"]["QQ"]=2222222

>>> dict_db[2]

{'zhangsan': {'addr': 'USA', 'QQ': 2222222, 'age': 20}}

>>>

del 字典名[字典key字段的值] [指定的字段名]

或

字典名[字典key字段的值].pop（「字段名」）刪除特定字段

>>> del dict_db[2]["zhangsan"]["QQ"]

>>> dict_db[2]

{'zhangsan': {'addr': 'USA', 'age': 20}}

或

>>> dict_db[2]

{'zhangsan': {'addr': 'USA', 'age': 20}}

>>> dict_db[2]["zhangsan"].pop("age")

>>> dict_db[2]

{'zhangsan': {'addr': 'USA'}}

>>>

字典.copy()，複製同列表爲淺copy

>>> id_db = dict_db[2].copy() //將dict_db第二個子字典複製給id_db

>>> id_db

{'zhangsan': {'addr': 'USA'}}

>>>

>>> dict_db[2]["zhangsan"]["addr"] = "UK" //修改dict_db中的值

>>> id_db

{'zhangsan': {'addr': 'UK'}} //id_db也被修改了

字典.get()，獲取 get方法和直接賦值是同樣的，可是使用get方法若是獲取一個不存在的值會返回NONE，可是直接賦值則會報錯

>>> v = id_db[3] //直接賦值形成報錯，中斷程序

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

KeyError: 3

>>> v = id_db.get(3) 使用get方法不會形成程序中斷

>>> print(v)

None

舊字典.update（「新字典」）使用新字典的內容去更新舊字典，若是舊字典中有對應的key則用新字典中的key覆蓋，若是麼有則將新字典中的key新增在舊字典中

>>> dict_db //舊字典

{1: {'liubo': {'addr': 'beijing', 'age': 30}, 'liwei': {'addr': 'ganshu', 'age': 33}}, 2: {'zhangsan': {'addr': 'UK'}}}

>>>

>>> new = { 2:{"name":"lisi","age":4444,"ip":"aaa"},5:{"test":334}

... }

>>> new //新字典

{2: {'ip': 'aaa', 'age': 4444, 'name': 'lisi'}, 5: {'test': 334}}

>>> dict_db.update(new)

>>> dict_db

{1: {'liubo': {'addr': 'beijing', 'age': 30}, 'liubo2': {'addr': 'ganshu', 'age': 33}}, 2: {'ip': 'aaa', 'age': 4444, 'name': 'lisi'}, 5: {'test': 334}}

>>>

print（字典.items（）），將字典轉化爲列表或元祖，這個動做很是耗時，所以儘可能不要使用

>>> print(id_db.items())

dict_items([('zhangsan', {'addr': 'UK'})])

print（字典.values（）），打印字典中全部的值

>>> print(dict_db)

{1: {'liubo': {'addr': 'beijing', 'age': 30}, 'liubo2': {'addr': 'ganshu', 'age': 33}}, 2: {'ip': 'aaa', 'age': 4444, 'name': 'lisi'}, 5: {'test': 334}}

>>> print(dict_db.values())

dict_values([{'liubo': {'addr': 'beijing', 'age': 30}, 'liwei': {'addr': 'ganshu', 'age': 33}}, {'ip': 'aaa', 'age': 4444, 'name': 'lisi'}, {'test': 334}]) //沒有1和2了

print(字典.keys())，打印字典中全部的key

>>> print(dict_db.keys())

dict_keys([1, 2, 5])

字典.has_key（特定的key）在python 2.0中的方法，判斷字典中是否存在特定的key

特定的key in 字典在python 3.0中，判斷字典中是否存在特定的key

>>> 1 in id_db

False

>>> 1 in dict_db

True

print(字典.setdefault(key，值)) 若是key在這個字典中存在，則返回值，若是不存在則在字典中追加這個key，並指定默認值，若是沒有指定則爲None

>>> id_db

{222: {'name': 'zhangsan', 'age': 33}, 1111: {'name': 'liubo', 'age': 30}}

>>> print(id_db.setdefault(111))

None

>>> id_db

{111: None, 222: {'name': 'zhangsan', 'age': 33}, 1111: {'name': 'liubo', 'age': 30}}

>>> print(id_db.setdefault(222))

{'name': 'zhangsan', 'age': 33}

>>> print(id_db.setdefault(2222,"test"))

test

>>> id_db

{111: None, 2222: 'test', 222: {'name': 'zhangsan', 'age': 33}, 1111: {'name': 'liubo', 'age': 30}}

print(id_db.fromkeys([字典的key]，默認值）），按照字典的key列表的接口輸入爲字典的key，key的值爲默認值，不改變元字典

>>> id_db

{111: None, 2222: 'test', 222: {'name': 'zhangsan', 'age': 33}, 1111: {'name': 'liubo', 'age': 30}}

>>> print(id_db.fromkeys([111,333,555],"aaaa"))

{555: 'aaaa', 333: 'aaaa', 111: 'aaaa'}

>>> id_db

{111: None, 2222: 'test', 222: {'name': 'zhangsan', 'age': 33}, 1111: {'name': 'liubo', 'age': 30}}

>>>

print(id_db.popitem()) 隨機刪除字典中的key

遍歷字典

>>> for x in id_db:

... print(x,id_db[x])

...

111 None

2222 test

222 {'name': 'zhangsan', 'age': 33}

1111 {'name': 'liubo', 'age': 30}

遍歷字典時輸出序列號，枚舉函數

使用字典、元祖或列表

for index.i in list:

print(index.i)

上面的方法會將列表從新輸出成爲元祖，其第一個元素就是這個元素在原來列表中的角標

list=["北京","天津","湖北","湖南"]

for Index in enumerate(list):

print(Index)

(0, '北京')

(1, '天津')

(2, '湖北')

(3, '湖南')

以元組的形式輸出，這時就能夠獲取元組的標號和內容了

list_num=Index[0]

list_name=Index[1]

print(list_num,"$",list_name)

0 $ 北京

1 $ 天津

2 $ 湖北

3 $ 湖南

集合

是無序、去重複的一種數據類型

集合的建立

s1 = {11,22}

s2 = set{} #建立一個空集合

s3 = set（[11,22,33]） #將一個列表轉換爲集合，相似list

集合的操做

集合.add() 給集合中增長一個元素

s=set()

print(s)

s.add(123)

print(s)

輸出

set()

{123}

集合.update（），批量更新，括號內的內容能夠是列表、元組、字符串

update的執行過程就是經過for循環，循環add命令

集合.clear（）清除集合中全部的內容

集合.copy() 複製集合，淺複製，僅複製第一層

查看差集

集合A.difference（新集合B） A中存在，b中不存在的內容，不改變原集合

集合A.symmetric_difference(新集合B) 比較A和B之間都不存在的值，不改變原集合

更新集合

集合A.difference_update(新集合B），將A中存在，B中不存在的內容替換到集合A中，

s1={11,22,33}

s2={22,33,44}

print(s1)

s1.difference_update(s2)

print(s1)

輸出

{33, 11, 22}

{11}

集合A.symmetric_difference_update(集合B），將集合A B中都沒有的數據替換到集合A中

s1={11,22,33}

s2={22,33,44}

print(s1)

s1.symmetric_difference_update(s2)

print(s1)

輸出

{33, 11, 22}

{11, 44}

集合.discard(特定元素) 移除特定的元素，不存在不報錯

s1={11,22,33}

s1.discard(11)

print(s1)

輸出

{33, 22}

集合.remove(特定元素) 移除特定的元素，不存在會報錯

集合.pop() 隨機移除元素移除元素，並把移除的元素返回，能夠將其賦給一個變量

s1={111,222,333}

s=s1.pop()

print(s)

集合.intersection（新集合），取兩個集合的交集，須要賦值

集合A.intersection_update（新集合B），取兩個集合的交集，並將其替換到集合A中

集合A.isdisjoint(集合B），判斷兩個集合之間是否有交集，有就是True沒有就是False

集合A.issubset(集合B），判斷集合A是不是集合B的字集

集合A.issuperset（集合B），判斷集合A是不是集合B的超集

集合.union（集合B），將兩個集合合併，去重複。並集

關於集合的聯繫

當兩個字典，一個字典時原先的狀態記錄，另外一個字典時最新的狀態記錄，咱們應該使用什麼方法來肯定：

什麼條目應該被刪除

什麼條目應該被更新

什麼條目應該被增長

old_status={

"1#":4,

"2#":8,

"4#":16

}

new_status={

"1#":8,

"2#":8,

"3#":16

}

#首先須要將原先字典中的key轉化爲集合

old_set=set(old_status.keys())

new_set=set(new_status.keys())

#須要刪除的內容是：老的狀態中存在，可是在新狀態中卻沒有的

status_remove=old_set.difference(new_set)

print("status_remove：%s"%status_remove)

#須要新增的內容是：新的狀態中存在，可是在老狀態中沒有的

status_add=new_set.difference(old_set)

print("status_add：%s"%status_add)

#須要被更新的內容是：新舊狀態都存在的

status_update=old_set.intersection(new_set)

print("status_update:%s"%status_update)

輸出

status_remove：{'4#'}

status_add：{'3#'}

status_update:{'1#', '2#'}

python上加顏色

\033[31;1m內容\033[0m 爲紅色

\033[32;1m內容\033[0m 爲綠色

salary=input("\033[31;1mInputyoursalary:\033[0m")

購物車程序做業需求：

一、容許用戶選擇購買了多少件

二、容許多用戶登陸，而且下次登陸後，繼續按上次的餘額購買，容許充值

三、容許用戶查看以前的購買記錄，並顯示購買時間

四、商品列表分級展現

五、重複商品在一行內顯示總量，很少行展現

新知識，會用到文件，datetime模塊，序列化json

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。