初進python世界之數據類型

時間 2019-11-06

標籤初進 python 世界數據類型欄目 Python 简体版

原文原文鏈接

文章來源： https://www.cnblogs.com/seagullunix/articles/7297946.html

基本運算符

經常使用數據類型：

字符串（Str）html

數字（Digit）python

列表（List）linux

元組（Tuple）git

集合（Set）shell

字典（Dict）api

布爾（bool）bash

Python文件處理

基本運算符

固然，在講數據類型以前，先了解一下Python的基本運算符：app

運算按種類可分爲算數運算、比較運算、邏輯運算、賦值運算、成員運算、身份運算和位運算。如下分別學習每一個運算符：ide

1、算數運算：


運算符	描述	實例
+	普通的加法運算	10+2=12
-	普通的減法運算	10-2=8
*	普通的乘法運算	10*2=20
/	普通的除法運算	10/2=5
%	取模運算，兩數相除，取餘數	10%2=0；10%3=1
//	取整除，兩數相除，不管是否整除，只取商的整數部分，（沒有四捨五入之說）	10.0//2.0=5.0；10//3=3；18//3=6
**	求冪運算，取一個數的冪次方	10**2=100

2、比較運算

說明：如下比較的是兩個對象的值。函數

運算符	描述	實例
==	等於，比較兩個對象是否相等,返回True或者False	若是a=10,b=10,那麼a==b,返回True
!=	不等於，比較兩個對象是否不相等,返回True或者False	若是a=10,b=10,那麼a!=b,返回False
<>	不等於，比較兩個對象是否不相等,返回True或者False，不經常使用	若是a=10,b=10,那麼a<>b,返回False
>	大於，比較a對象是否大於b對象,返回True或者False	若是a=10,b=10,那麼a>b,返回False
<	小於，比較比較a對象是否小於b對象,返回True或者False	若是a=10,b=10,那麼a<b,返回False
>=	大於等於，比較a對象是否大於等於b對象,返回True或者False	若是a=10,b=10,那麼a=>b,返回True
<=	小於等於，比較a對象是否小於等於b對象,返回True或者False	若是a=10,b=10,那麼a<=b,返回True

3、賦值運算

運算符	描述	實例
=	簡單的賦值運算符，元素1賦值給元素2	c=a+b,c=10+b等這些都屬於簡單的賦值運算
+=	加法賦值運算符，先相加，再賦值，多用於循環語句中元素的自加	c+=a至關於c=c+a
-=	減法賦值運算符，先相減，再賦值，多用於循環語句中元素的自減	c-=a至關於c=c-a
*=	乘法賦值運算符，先相乘，再賦值，多用於循環語句中元素的自乘	c=a至關於c=ca
/=	除法賦值運算符，先相除，再賦值，多用於循環語句中元素的自除	c/=a至關於c=c/a
%=	取模賦值運算符，先取模，再賦值	c%=a至關於c=c%a
**=	取冪賦值運算符，先取冪，再賦值	c=a至關於c=ca
//=	取整除賦值運算符，先取整除，再賦值	c//=a至關於c=c//a

4、邏輯運算

運算符	描述	實例
and	‘與’，而且的意思，兩邊的元素都爲真即返回真	a and b：a爲真，b爲假，返回False，a爲真，b爲真，返回True
or	‘或’，或者的意思，兩邊的元素只要有一個爲真，即返回真	a or b：a爲真，b爲假，返回True，a爲假，b爲假，返回False
not	‘非’，相反的意思，若是是真的，返回假，若是是假的，返回真	not a：a爲真，返回False，a爲假，返回True

5、成員運算

運算符	描述	實例
in	在：若是對象a能在對象b中找到，則返回True，不然，返回False	x in y ;若是x在y中，則會返回True，不然爲False
not in	不在：若是對象a能在對象b中找不到，則返回True，不然，返回False	x not in y ;若是x不在y中，則會返回True，不然爲False

6、身份運算

說明只列出兩個比較經常使用的，身份運算比較的是對象的name、id、value，如下比較的是兩個對象的id（id相同，即type相同，值相同）

運算符	描述	實例
is	是：若是對象a和對象b的id相同，則返回True，不然，返回False	x is y ;若是x和y的id相同，則會返回True，不然爲False
is not	不是：若是對象a和對象b的id不相同，則返回True，不然，返回False	x is not y ;若是x和y的id不相同，則會返回True，不然爲False

7、位運算

比較二進制位，例如a=30,b=11 ，（轉換二進制函數bin()）二進制表示就是a=11110,b=1011。位運算比較複雜，能夠僅做了解。

運算符	描述	實例
&	按位與運算符：若是存在於兩個對象中，則複製位到結果中。例如參與運算的兩個值，從右到左進行比較，若是相應位都爲1，則結果爲1，只要有一個爲0，結果即爲0	a&b,從右到左進行比較，結果即爲1010，a比b多一位，a從左到右的第一位1在b的相應位置是空，即沒有，則結果也是沒有。
\|	按位或運算符：只要存在於其中一個對象中，則複製位到結果中。例如參與運算的兩個值，從右到左比較，若是相應位置中有一個是1，則結果爲1	a\|b,從右到左進行比較，結果即爲11111，一樣a從左到右的第一位1在b的相應位置是空，即沒有，可是結果仍然是1.
^	按位異或運算符：若是對象對應的的二進位相異時，複製位。例如參與運算的兩個值，從右到左進行比較，若是相應位不同，即一個爲0，一個爲1，則結果爲1。	a^b,從右到左進行比較，結果即爲10101，a比b多一位，a從左到右的第一位1在b的相應位置是空，結果相異，則爲1。
~	按位取反運算符：一元的，具備翻轉效果。例如參與運算的一個值，把相應位置的1變爲0,0變爲1	~a，結果即爲-31，二進制爲11111，在一個有符號二進制數的補碼形式
<<	左移動運算符：左操做數的值由右操做數指定的位數左移。例如參與運算的兩個值，左邊的數的各二進制位所有左移，左移位數由右邊的數值決定，高位丟棄，低位補0	a<<b,結果1111000000000000，由於b=11，因此左移了11位，低位補0
>>	右移動運算符：左操做數的值由右操做數指定的位數右移。例如參與運算的兩個值，左邊的數的各二進制位所有右移，右移爲數由右邊的數值決定，高位丟棄，低位補0	a>>b,結果0，由於b=11，因此右移了11位，高位丟棄，另若是 b=3，則結果爲11

經常使用數據類型

字符串（str）

字符串的聲明有三種方式：單引號，雙引號和三引號（三個單引號或者三個雙引號）。不可變（可hash）

例如：

 print('hello word!') hello word! print("hello word!") hello word! print('''hello word!''') hello word! print("""hello word!""") hello word!

字符串根據索引的一些切片操做：

 str = 'hello world!' print(str) # 輸出字符串 hello world! print(str[0:-1]) # 輸出第一個到倒數第二個的全部字符（字符串具備顧頭不顧尾的特性，因此不會取到最後一個字符） hello world print(str[0]) # 輸出字符串第一個字符 h print(str[2:5]) # 輸出從第三個開始到第五個的字符 llo print(str[2:]) # 輸出從第三個開始後的全部字符 llo world! print(str * 2) # 輸出字符串兩次 hello world!hello world! print(str + "TEST") # 鏈接字符串 hello world!TEST

移除空格 strip,lstrip,rstrip

 str=' hello world!' sea='hello world!***' print(str.strip()) #默認移除所有空格 hello world! print(sea.strip('*')) #移除指定特殊字符* hello world! print(str.lstrip()) #默認移除左邊空格 hello world! print(sea.rstrip('*')) #移除右邊指定特殊字符* hello world!

切分 split,rsplit

 str='root:x:0:0::/root:/bin/bash' print(str.split()) #默認以空格爲分隔符 ['root:x:0:0::/root:/bin/bash'] print(str.split(':',1)) #以冒號爲分隔符,只分割第一個冒號，默認分割全局 ['root', 'x:0:0::/root:/bin/bash'] print(str.rsplit(':',2,))#從右邊開始分割，分割從右邊數的前兩個冒號 ['root:x:0:0:', '/root', '/bin/bash']

取字符串長度 len

 str='hello world!' print(len(str)) #取字符串的長度，等價於print(str.__len__()) 12 print(str.__len__()) 12

判斷開頭和結尾字符 startswith,endswith

 str='seagull' print(str.endswith('l')) #判斷結尾，若是正確，則返回True，不然返回False True print(str.endswith('l',1,3)) #指定開頭和結尾 False print(str.startswith('s')) #判斷開頭，若是正確，則返回True，不然返回False True print(str.startswith('s',3,4)) ##指定開頭和結尾 False

字符串的替換操做 replace

 str='seagull' print(str.replace('l','9')) #字符串的替換，將字母l替換爲數字9，默認替換全局 seagu99 print(str.replace('l','9',1)) #字符串的替換，指定只將第一個找到的字母l替換爲9 seagu9l

format的三種玩法

 name='seagull' age=18 hobby='eat' print('我是%s，今年%s歲，愛好%s'%(name,age,hobby)) #%s的傳參法 我是seagull，今年18歲，愛好eat print('我是{}，今年{}歲，愛好{}'.format('seagull','18','eat')) #花括號傳參，和%s有點類似 我是seagull，今年18歲，愛好eat print('我是{}，今年{}歲，愛好'.format('seagull','18','eat')) #後面的傳參能夠比前面的花括號多，可是不能比前面的花括號少，不然會報錯 我是seagull，今年18歲，愛好 print('我是{1}，今年{0}歲，愛好{0}'.format('seagull','18','eat')) #花括號裏面寫數字傳參法，後面的參數默認指定了順序 ，花括號裏面能夠寫指定的數字鏡像傳參 我是18，今年seagull歲，愛好seagull print('我是{name}，今年{age}歲，愛好{hobby}'.format(name='seagull',age='18',hobby='eat')) #指定參數，用一個等於號賦 值 我是seagull，今年18歲，愛好eat

查找和統計：find,rfind,index,rindex,count

 str='seagull' print(str.find('l')) #查找字符l的下標 5 print(str.find('b')) #查找字符b的下標,找不到返回-1 -1 print(str.index('l')) #查找字符l的下標 5 print(str.index('b')) #查找字符d的下標,找不到會報錯 Traceback (most recent call last): File "<stdin>", line 1, in <module> ValueError: substring not found print(str.rfind('l')) #從右邊開始查找字符l的下標 6 print(str.rindex('l')) #從右邊查找字符l的下標 6

 print(str.count('l')) #統計字符串中包含字符的個數，能夠指定範圍查找 2 print(str.count('l',1,4)) #統計字符串中包含字符的個數 0

鏈接字符串 join （#可迭代對象必須都是字符串）

 str=' ' #給tag賦值爲空格 print(str.join(['seagull','is','looker'])) #插入字符，每一個字符串之間以空格分割 seagull is looker str='a' #給tag賦值爲a print(str.join(['seagull','is','looker'])) #插入字符，每一個字符串之間以a分割 seagullaisalooker str='9' print(str.join(['seagull','is','looker'])) #插入字符，每一個字符串之間以數字9分割 seagull9is9looker str='9' print(str.join(['seagull''is''looker'])) #插入字符，每一個字符串之間沒有分割 seagullislooker str='seagull' print(":".join(str)) #以冒號爲分隔符，將字符串分割 s:e:a:g:u:l:l

顯示打印 center,ljust,rjust,zfill

 str='seagull' print(str.center(30,'*')) #30個佔位符，居中顯示，字符不足時用*填充，默認是用空格填充 ***********seagull************ print(str.ljust(10,'1')) #10個佔位符，靠左顯示，字符不足用數字1填充，默認空格 seagull111 print(str.rjust(10)) #10個佔位符，靠右顯示，字符不足默認空格填充，也可指定  seagull print(str.zfill(10)) #10個佔位符，靠右顯示，字符不足用0填充,不能本身指定 000seagull

轉換tab鍵爲空格 expandtabs

 str='sea\tgull' print(str) sea gull print(str.expandtabs(1)) sea gull

字母大小寫轉換 lower ，upper ，captalize,swapcase,title

str='seaGULL' print(str.lower())#將包含的大寫字母轉換成小寫 print(str.upper())#將包含的小寫字母轉換成大寫

 str1='sea GULL' str2='sea_Gull' print(str1.capitalize()) #只首字母大寫，其餘的均小寫 Sea gull print(str2.capitalize()) Sea_gull print(str1.swapcase()) #大小寫翻轉，大寫變小寫，小寫變大寫 SEA gull print(str2.swapcase()) SEA_gULL print(str1.title()) #標題，每一個單詞的首字母大寫，其餘的小寫 Sea Gull print(str2.title()) Sea_Gull

is數字系列（Python3），正確返回True，不然返回False

 num1=b'4' #bytes num2=u'4' #unicode,python3中無需加u就是unicode num3='四' #中文數字 num4='Ⅳ' #羅馬數字 #isdigt:bytes,unicode，經常使用 ... print(num1.isdigit()) True print(num2.isdigit()) True print(num3.isdigit()) False print(num4.isdigit()) False #isdecimal:uncicode ... #bytes類型無isdecimal方法 ... print(num2.isdecimal()) True print(num3.isdecimal()) False print(num4.isdecimal()) False #isnumberic:unicode,中文數字,羅馬數字 ... #bytes類型無isnumberic方法 ... print(num2.isnumeric()) True print(num3.isnumeric()) True print(num4.isnumeric()) True #浮點型不能判斷 ... num5='4.3' num6='1/2' print(num5.isdigit()) False print(num5.isdecimal()) False print(num5.isnumeric()) False print(num6.isdigit()) False print(num6.isdecimal()) False print(num6.isnumeric()) False

is其餘系列，正確返回True，不然爲False

 str1='seagull' str2='seagu123' print(str1.isalnum()) #判斷字符串是否由只由字母和數字或者二者共同組成，是返回True，不然返回False True print(str2.isalnum()) True print(str1.isalpha()) #判斷字符串是否只由字母組成，是返回True，不然返回False True print(str2.isalpha()) False str3='a' str4='1' print(str3.isidentifier())#判斷單詞是否爲字母，或者是否包含關鍵字（字母，下劃線），是就返回True True print(str4.isidentifier())#不能包含的有特殊字符（*，空格，=，數字等，） False str1='SEAGUll' str2='seagu123' print(str1.islower()) #判斷包含的字母是否所有爲小寫字母，是就返回True False print(str2.islower()) True str1='SEAGUll' str2='SEAGULL123' print(str1.isupper())#判斷包含字母是否所有是大寫，是就返回True False print(str2.isupper()) True str1=' ' str2='' print(str1.isspace())#判斷是否爲空格，是就返回True True print(str2.isspace()) False str1='SEAGUll' str2='Seagull123' print(str1.istitle())#判斷是否爲標題（首字母是否大寫，單詞的首字母大寫），若是是就返回True False print(str2.istitle()) True

字符串小練習

# 寫代碼,有以下變量,請按照要求實現每一個功能 （共6分，每小題各0.5分） name = " aleX" # 1) 移除 name 變量對應的值兩邊的空格,並輸出處理結果 print(name.strip()) # 2) 判斷 name 變量對應的值是否以 "al" 開頭,並輸出結果 print(name.startswith('al')) # 3) 判斷 name 變量對應的值是否以 "X" 結尾,並輸出結果 print(name.endswith('X')) # 4) 將 name 變量對應的值中的 「l」 替換爲 「p」,並輸出結果 print(name.replace('l','p')) # 5) 將 name 變量對應的值根據 「l」 分割,並輸出結果。 print(name.split('l')) # 6) 將 name 變量對應的值變大寫,並輸出結果 print(name.upper()) # 7) 將 name 變量對應的值變小寫,並輸出結果 print(name.lower()) # 8) 請輸出 name 變量對應的值的第 2 個字符? print(name[1]) # 9) 請輸出 name 變量對應的值的前 3 個字符? print(name[0:3]) # 10) 請輸出 name 變量對應的值的後 2 個字符? print(name[-2:]) # 11) 請輸出 name 變量對應的值中 「e」 所在索引位置? print(name.find('e')) print(name.index('e')) # 12) 獲取子序列,去掉最後一個字符。如: oldboy 則獲取 oldbo。 print(name[:-1]) print(name.rstrip('X')) print(name.replace('X','')) print(name.split('X')[0])

數字（Digit）

包括整數（int），浮點數（float），長整型（long），不可變（可hash）

刪除數字對象引用

 a=1
 b=2
 c=3
 print(a) 1 del a print(a) #被刪除後再次打印就好報錯 Traceback (most recent call last): File "<stdin>", line 1, in <module> NameError: name 'a' is not defined

數字類型轉換

int(x [,base]) #將x轉換爲一個整數 float(x ) # 將x轉換到一個浮點數 complex(real [,imag]) #建立一個複數 str(x) #將對象x轉換爲字符串 repr(x) #將對象x轉換爲表達式字符串 eval(str) #用來計算在字符串中的有效Python表達式,並返回一個對象 tuple(s) #將序列s轉換爲一個元組 list(s) #將序列s轉換爲一個列表 chr(x) #將一個整數轉換爲一個字符 unichr(x) #將一個整數轉換爲Unicode字符 ord(x) #將一個字符轉換爲它的整數值 hex(x) #將一個整數轉換爲一個十六進制字符串 oct(x) #將一個整數轉換爲一個八進制字符串

數字函數

abs(x)    #返回數字的絕對值，如abs(-10) 返回 10 ceil(x) # 返回數字的上入整數，如math.ceil(4.1) 返回 5 cmp(x, y) #若是 x < y 返回 -1, 若是 x == y 返回 0, 若是 x > y 返回 1 exp(x) #返回e的x次冪(ex),如math.exp(1) 返回2.718281828459045 fabs(x) #返回數字的絕對值，如math.fabs(-10) 返回10.0 floor(x) #返回數字的下舍整數，如math.floor(4.9)返回 4 log(x) #如math.log(math.e)返回1.0,math.log(100,10)返回2.0 log10(x) #返回以10爲基數的x的對數，如math.log10(100)返回 2.0 max(x1, x2,...) # 返回給定參數的最大值，參數能夠爲序列。 min(x1, x2,...) #返回給定參數的最小值，參數能夠爲序列。 modf(x) #返回x的整數部分與小數部分，兩部分的數值符號與x相同，整數部分以浮點型表示。 pow(x, y) x**y #運算後的值。 round(x [,n]) #返回浮點數x的四捨五入值，如給出n值，則表明舍入到小數點後的位數。 sqrt(x) #返回數字x的平方根，數字能夠爲負數，返回類型爲實數，如math.sqrt(4)返回 2+0j

列表（List）

能夠定義多個變量，有序的，可變（不可hash）類型，

索引

 lis=['seagull',18,'eat'] print(lis[0]) seagull

 lis=['seagull',18,'eat'] print(lis.index(18)) 1

切片

 lis=['seagull',18,'eat'] print(lis[:-1]) ['seagull', 18]

追加

 str=['seagull',18] str.append('eat') print(str) ['seagull', 18, 'eat']

 str=['seagull',18] str.extend('eat') #extend將引號裏面的字符串分紅單個字符，逐個添加，而且只能添加字符串 print(str) ['seagull', 18, 'e', 'a', 't'] str.extend(['sea','dongdong']) #若是添加列表，須要代表添加的是一個列表 print(str) ['seagull', 18, 'e', 'a', 't', 'sea', 'dongdong'] str.extend({'hobby':'eat'}) #沒法添加字典,可是能夠將字典裏面的冒號換成逗號添加多個列表 print(str) ['seagull', 18, 'e', 'a', 't', 'sea', 'dongdong', 'hobby'] str.extend(('lele','honghong')) #小括號的形式添加列表 print(str) ['seagull', 18, 'e', 'a', 't', 'sea', 'dongdong', 'hobby', 'lele', 'honghong']

刪除

 str=['seagull', 18, 'e', 'a', 't', 'sea', 'dongdong', 'hobby', 'lele', 'honghong'] str.pop() #索引的方式刪除列表數據，不指定默認從右到左開始刪除 'honghong' print(str) ['seagull', 18, 'e', 'a', 't', 'sea', 'dongdong', 'hobby', 'lele'] str.pop(0) #指定索引，刪除指定刪除項 'seagull' print(str) [18, 'e', 'a', 't', 'sea', 'dongdong', 'hobby', 'lele'] str.remove('hobby') #經過指定字符串的方式刪除 print(str) [18, 'e', 'a', 't', 'sea', 'dongdong', 'lele'] str=[] #清空列表 print(str) [] del str #刪除列表 print(str) <class 'str'>

長度

 str=['seagull', 18, 'e', 'a', 't', 'sea', 'dongdong', 'hobby', 'lele', 'honghong'] print(len(str)) 10

循環

str=['seagull', 18, 'e', 'a', 't', 'sea', 'dongdong', 'hobby', 'lele', 'honghong'] for index in range(len(str)): #根據列表的長度進行循環。range，指定範圍循環 print(str[index]) # range(start,end,step) # 參數含義：start：計數從start開始，默認從0開始。 # end：計數到end計數，但不包括end。 # step：每次跳躍的間距，默認爲1 #循環輸出結果： seagull 18 e a t sea dongdong hobby lele honghong

str = ['seagull', 'dongdong', 'hobby', 'lele', 'honghong'] for key,v in enumerate(str): print(key,end='：') print(v) # enumerate()是python的內置函數 # enumerate在字典上是枚舉、列舉的意思 # 對於一個可迭代的（iterable）/可遍歷的對象（如列表、字符串），enumerate將其組成一個索引序列，利用它能夠同時得到索引和值 # enumerate多用於在for循環中獲得計數 #獲得的結果： 0：seagull 1：dongdong 2：hobby 3：lele 4：honghong

包含in

 str = ['seagull', 'dongdong', 'hobby', 'lele', 'honghong'] if 'seagull' in str: ... print('ok') ... ok

列表排序sort，sorted，reverse

#sort正向排序,直接修改源列表 a=[5,4,3,2,1]  a.sort() print(a) [1, 2, 3, 4, 5]

 #sorted正向排序，能夠保留源列表，生成新列表 ... a=[5,4,3,2,1] b=sorted(a) print(b) [1, 2, 3, 4, 5] #sorted能夠用在任何數據類型的序列中，返回的老是一個列表形式 ... b=sorted('iplaypython.com**') print(b) ['*', '*', '.', 'a', 'c', 'h', 'i', 'l', 'm', 'n', 'o', 'o', 'p', 'p', 't', 'y', 'y']

 #reverse反轉排序,直接修改源文件 ... a = [1, 2, 3, 4, 5, 6, 7, 8, 9]  a.reverse() print(a) [9, 8, 7, 6, 5, 4, 3, 2, 1]

#reversed a=[5,4,3,2,1] for i in reversed(a): print(i)

切片方式的逆轉

 mystring="54321" mytuple=(5,4,3,2,1) mylist=[5,4,3,2,1] mystring[::-1] '12345' mytuple[::-1] (1, 2, 3, 4, 5) mylist[::-1] [1, 2, 3, 4, 5]

小練習

# 有列表data=['alex',49,[1900,3,18]]，分別取出列表中的名字，年齡，出生的年，月，日賦值給不一樣的變量 # 模擬隊列 # 模擬堆棧  data=['alex',49,[1900,3,18]] sea={'name':data[0],'age':data[1],'data':data[2]} print(sea)

元組（Tuple）

用來存儲多個值，有序的，不可變（可哈希）類型，能夠當作字典的key值。

索引

 sea=('seagull',18,'eat') print(sea[0]) seagull print(sea.index('seagull')) 0

切片

sea = ('seagull', 18, 'eat') print(sea[:-1])

循環

sea = ('seagull', 18, 'eat') for tuple in sea: print(tuple)

長度

 sea = ('seagull', 18, 'eat') print(len(sea)) 3

包含in

sea = ('seagull', 18, 'eat') if 'seagull' in sea: print('ok')

小練習

#簡單購物車：實現打印商品詳細信息，用戶輸入商品名和購買個數，則將商品名，價格，購買個數加入購物列表，若是輸入爲空或其餘非法輸入則要求用戶從新輸入　　 #升級要求 # 要求用戶輸入總資產，例如：2000 # 顯示商品列表，讓用戶根據序號選擇商品，加入購物車 # 購買，若是商品總額大於總資產，提示帳戶餘額不足，不然，購買成功。 # 附加：可充值、某商品移除購物車  msg_dic={ 'apple':10, 'tesla':100000, 'mac':3000, 'lenovo':30000, 'chicken':10, }

View Code

集合（Set）

去重，關係運算。無序，不可變（可hash）類型，能夠做爲字典的key，主要是不一樣的集合直接作關係運算。

存儲 | 移除除

sea={'seagull','lele'} sea.add('dongdong') print(sea) sea.pop() #任意刪除 print(sea) sea.remove('lele') #指定刪除 print(sea)

in 和 not in

sea={'seagull','lele',18,'eat'} if 'lele' in sea: print('ok') if 'dong' not in sea: print('ok')

| 合集（union）

 a={1,2,4,5,10}
 b={3,4,7,8,10} print(a|b) {1, 2, 3, 4, 5, 7, 8, 10} print(a.union(b)) {1, 2, 3, 4, 5, 7, 8, 10}

& 交集（intersection）

 a={1,2,4,5,10}
 b={3,4,7,8,10} print(a&b) {10, 4} print(a.intersection(b)) {10, 4}

- 差集

 a={1,2,4,5,10}
 b={3,4,7,8,10} print(a-b) {1, 2, 5} print(a.difference(b)) {1, 2, 5}

^ 對稱差集

 a={1,2,4,5,10}
 b={3,4,7,8,10} print(a^b) {1, 2, 3, 5, 7, 8} print(a.symmetric_difference(b)) {1, 2, 3, 5, 7, 8}

== 判斷兩個集合是否相等，返回布爾值

 a={1,2,4,5,10}
 b={3,4,7,8,10} print(a==b) False

>，>= ，<,<= 父集，子集（判斷其中一個集合的元素是否均包含於另外一個元素，返回布爾值）

 a={1,2,3,4,5}
 b={4,5} print(a>b) True print(a>=b) True print(a.issuperset(b))#a是否包含於b True print(a<b) False print(a<=b) False print(a.issubset(b)) False

小練習：

# 　一.關係運算 # 　　有以下兩個集合，pythons是報名python課程的學員名字集合，linuxs是報名linux課程的學員名字集合 pythons={'alex','egon','yuanhao','wupeiqi','gangdan','biubiu'} linuxs={'wupeiqi','oldboy','gangdan'} # 　　1. 求出即報名python又報名linux課程的學員名字集合 print(pythons&linuxs) print(pythons.intersection(linuxs)) # 　　2. 求出全部報名的學生名字集合 print(pythons|linuxs) print(pythons.union(linuxs)) # 　　3. 求出只報名python課程的學員名字 print(pythons-linuxs) print(pythons.difference(linuxs)) # 　　4. 求出沒有同時這兩門課程的學員名字集合 print(pythons^linuxs) print(pythons.symmetric_difference(linuxs))

# 二.去重 # # 　　 1. 有列表l=['a','b',1,'a','a']，列表元素均爲可hash類型，去重，獲得新列表,且新列表無需保持列表原來的順序 l=['a','b',1,'a','a'] print(set(l)) # 　　 2.在上題的基礎上，保存列表原來的順序 l=['a','b',1,'a','a'] sea=[] for list in l: if list not in sea: sea.append(list) print(sea) #或者 l=['a','b',1,'a','a'] sea=[] sea1=set() for list in l: if list not in sea: sea1.add(list) sea.append(list) print(sea) # 　　 3.去除文件中重複的行，確定要保持文件內容的順序不變 import os with open('sea.txt','r',encoding='utf-8') as read_f,\ open('.sea.txt.swap','w',encoding='utf-8') as write_f: s=set() for line in read_f: if line not in s: s.add(line) write_f.write(line) os.remove('sea.txt') os.rename('.sea.txt.swap','sea.txt') # 　　 4.有以下列表，列表元素爲不可hash類型，去重，獲得新列表，且新列表必定要保持列表原來的順序  l=[ {'name':'egon','age':18,'sex':'male'}, {'name':'alex','age':73,'sex':'male'}, {'name':'egon','age':20,'sex':'female'}, {'name':'egon','age':18,'sex':'male'}, {'name':'egon','age':18,'sex':'male'}, ] sea=[] for list in l: if list not in sea: sea.append(list) print(sea) #或者 s=set() l1=[] for item in l: val=(item['name'],item['age'],item['sex']) if val not in s: s.add(val) l1.append(item) print(l1)

字典（Dict）

存儲多個值，存在key值和value值，可變（不可hash）類型，須要注意的是，字典的key值是不可變的。

存/取

sea={}
sea['name']='seagull' print(sea) print(sea['name'])

刪除

 sea={'name':'seagull','age':18,'hobby':'eat'} sea.pop('name') 'seagull' print(sea) {'age': 18, 'hobby': 'eat'}

長度

 sea={'name':'seagull','age':18,'hobby':'eat'} print(len(sea)) 3

循環

sea={'name':'seagull','age':18,'hobby':'eat'} for key in sea: print(key) for values in sea.values(): print(values) for item in sea.items(): print(item)

小練習

# 1 有以下值集合 [11,22,33,44,55,66,77,88,99,90...]，將全部大於 66 的值保存至字典的第一個key中，將小於 66 的值保存至第二個key的值中。（2分） # # 　　即： {'k1': 大於66的全部值, 'k2': 小於66的全部值} sea1=[11,22,33,44,55,66,77,88,99,90] sea2={'key1':[],'key2':[]} for list in sea1: if list > 66: sea2['key1'].append(list) elif list < 66: sea2['key2'].append(list) else: continue print(sea2)

# 　2 統計s='hello alex alex say hello sb sb'中每一個單詞的個數 # # 　　結果如：{'hello': 2, 'alex': 2, 'say': 1, 'sb': 2}  s='hello alex alex say hello sb sb' sea={} for dic in s.split(): if dic in sea: sea[dic]+=1 else: sea[dic]=1 print(sea)

布爾（bool）

布爾型只有兩個值，True或者False

你可以將Ture和False看做是預約義的設置爲整數1和整數0的變量

 True +4
5
 a=True
 a True True == 1 True False == 0 True

Python文件處理

python中對文件、文件夾（文件操做函數）的操做須要涉及到os模塊和shutil模塊。

獲得當前工做目錄，即當前Python腳本工做的目錄路徑: os.getcwd()

返回指定目錄下的全部文件和目錄名:os.listdir()

函數用來刪除一個文件:os.remove()

刪除多個目錄：os.removedirs（r「c：\python」）

檢驗給出的路徑是不是一個文件：os.path.isfile()

檢驗給出的路徑是不是一個目錄：os.path.isdir()

判斷是不是絕對路徑：os.path.isabs()

檢驗給出的路徑是否真地存:os.path.exists()

返回一個路徑的目錄名和文件名:os.path.split()     eg os.path.split('/home/swaroop/byte/code/poem.txt') 結果：('/home/swaroop/byte/code', 'poem.txt') 

分離擴展名：os.path.splitext()

獲取路徑名：os.path.dirname()

獲取文件名：os.path.basename()

運行shell命令: os.system()

讀取和設置環境變量:os.getenv() 與os.putenv()

給出當前平臺使用的行終止符:os.linesep    Windows使用'\r\n'，Linux使用'\n'而Mac使用'\r'

指示你正在使用的平臺：os.name       對於Windows，它是'nt'，而對於Linux/Unix用戶，它是'posix'

重命名：os.rename（old， new）

建立多級目錄：os.makedirs（r「c：\python\test」）

建立單個目錄：os.mkdir（「test」）

獲取文件屬性：os.stat（file）

修改文件權限與時間戳：os.chmod（file）

終止當前進程：os.exit（）

獲取文件大小：os.path.getsize（filename）

文件操做

os.mknod("test.txt")        建立空文件
fp = open("test.txt",w)     直接打開一個文件，若是文件不存在則建立文件

關於open 模式：

w     以寫方式打開，
a     以追加模式打開 (從 EOF 開始, 必要時建立新文件)
r+     以讀寫模式打開
w+     以讀寫模式打開 (參見 w )
a+     以讀寫模式打開 (參見 a )
rb     以二進制讀模式打開
wb     以二進制寫模式打開 (參見 w )
ab     以二進制追加模式打開 (參見 a )
rb+    以二進制讀寫模式打開 (參見 r+ )
wb+    以二進制讀寫模式打開 (參見 w+ )
ab+    以二進制讀寫模式打開 (參見 a+ )

fp.read([size])                     #size爲讀取的長度，以byte爲單位  fp.readline([size]) #讀一行，若是定義了size，有可能返回的只是一行的一部分  fp.readlines([size]) #把文件每一行做爲一個list的一個成員，並返回這個list。其實它的內部是經過循環調用readline()來實現的。若是提供size參數，size是表示讀取內容的總長，也就是說可能只讀到文件的一部分。  fp.write(str) #把str寫到文件中，write()並不會在str後加上一個換行符  fp.writelines(seq) #把seq的內容所有寫到文件中(多行一次性寫入)。這個函數也只是忠實地寫入，不會在每行後面加上任何東西。  fp.close() #關閉文件。python會在一個文件不用後自動關閉文件，不過這一功能沒有保證，最好仍是養成本身關閉的習慣。 若是一個文件在關閉後還對其進行操做會產生ValueError  fp.flush() #把緩衝區的內容寫入硬盤  fp.fileno() #返回一個長整型的」文件標籤「  fp.isatty() #文件是不是一個終端設備文件（unix系統中的）  fp.tell() #返回文件操做標記的當前位置，以文件的開頭爲原點  fp.next() #返回下一行，並將文件操做標記位移到下一行。把一個file用於for … in file這樣的語句時，就是調用next()函數來實現遍歷的。  fp.seek(offset[,whence]) #將文件打操做標記移到offset的位置。這個offset通常是相對於文件的開頭來計算的，通常爲正數。但若是提供了whence參數就不必定了，whence能夠爲0表示從頭開始計算，1表示以當前位置爲原點計算。2表示以文件末尾爲原點進行計算。須要注意，若是文件以a或a+的模式打開，每次進行寫操做時，文件操做標記會自動返回到文件末尾。  fp.truncate([size]) #把文件裁成規定的大小，默認的是裁到當前文件操做標記的位置。若是size比文件的大小還要大，依據系統的不一樣多是不改變文件，也多是用0把文件補到相應的大小，也多是以一些隨機的內容加上去。

目錄操做

os.mkdir("file") 建立目錄 複製文件： shutil.copyfile("oldfile","newfile") oldfile和newfile都只能是文件 shutil.copy("oldfile","newfile") oldfile只能是文件夾，newfile能夠是文件，也能夠是目標目錄 複製文件夾： shutil.copytree("olddir","newdir") olddir和newdir都只能是目錄，且newdir必須不存在 重命名文件（目錄） os.rename("oldname","newname") 文件或目錄都是使用這條命令 移動文件（目錄） shutil.move("oldpos","newpos") 刪除文件 os.remove("file") 刪除目錄 os.rmdir("dir")只能刪除空目錄 shutil.rmtree("dir") 空目錄、有內容的目錄均可以刪 轉換目錄 os.chdir("path") 換路徑

實例小練習

# 文件a.txt內容：每一行內容分別爲商品名字，價錢，個數，求出本次購物花費的總錢數 # apple 10 3 # tesla 100000 1 # mac 3000 2 # lenovo 30000 3 # chicken 10 3 import fileinput count=0 file=fileinput.input('sea.txt') print('本次購買的商品信息：') for content in file: print(content,end="") content=list(content.split()) count=int(content[1]) * int(content[2])+count price=count print('\n商品總額是：{}'.format(price))

# 修改文件內容，把文件中的alex都替換成SB # i am seagull, # seagull is a looker. # and alex is a killer.  with open('sea.txt','r') as r: lines=r.readlines() #按行讀取文件 with open('sea.txt','w') as w: for l in lines: w.write(l.replace('alex','sb'))