Python 運算符

運算符用于執(zhí)行程序代碼運算,會針對一個以上操作數(shù)項目來進行運算,在Python中運算符大致可以分為7種類型:算術(shù)運算符、比較運算符、賦值運算符、邏輯運算符、位運算等,下面的例子將依次介紹這幾種運算符的使用技巧.

◆算數(shù)運算符◆

算術(shù)運算(arithmetic operators)符號,就是用來處理四則運算的符號,這是最簡單,也最常用的符號,尤其是數(shù)字的處理,幾乎都會使用到算術(shù)運算符號,Python支持以下運算符:

運算符

描述信息

例子

+

加號:兩個數(shù)相加

a=10,b=20 a+b結(jié)果30

-

減號:兩個數(shù)相減

a=20,b=10 a-b結(jié)果10

*

乘號:兩個數(shù)相乘

a=10,b=20 a*b結(jié)果200

/

除號:兩個數(shù)相除

a=10,b=20 b/a結(jié)果2

%

取模:返回除法的余數(shù)

a=10,b=20 b%a結(jié)果0

**

冪符:返回x的y次冪

a**b,a的b次方,返回

//

取整:返回商的整數(shù)部分

a=9,b=2 a//b結(jié)果4

加法運算(+):

>>> a=30

>>> b=20

>>> c=0

>>>

>>> c=a+b

>>> print("a+b=",c)

a+b= 50

減法運算(-):

>>> a=30

>>> b=20

>>> c=0

>>>

>>> c=a-b

>>> print("a-b=",c)

a-b= 10

乘法運算(x):

>>> a=30

>>> b=20

>>> c=0

>>>

>>> c=a*b

>>> print("a*b=",c)

a*b= 600

除法運算(/):

>>> a=30

>>> b=20

>>> c=0

>>>

>>> c=a/b

>>> print("a/b=",c)

a/b= 1.5

取余運算(%):

>>> a=30

>>> b=20

>>> c=0

>>>

>>> c=a%b

>>> print("a%b=",c)

a%b= 10

求冪運算(xx):

>>> a=20

>>> b=30

>>> c=0

>>>

>>> c=a**b

>>> print("a**b=",c)

a**b= 1073741824000000000000000000000000000000

取整運算(//):

>>> a=10

>>> b=5

>>> c=0

>>>

>>> c=a//b

>>> print("a//b=",c)

a//b= 2

◆比較運算符◆

比較運算符是指可以使用如下運算符比較兩個值,當(dāng)用運算符比較兩個值時,結(jié)果是一個邏輯值,不是 TRUE(成立)就是FALSE(不成立)的運算符號,Python支持以下運算符:

運算符

描述信息

例子

==

等于:比較兩個對象是否相等

(a==b)返回false

!=

不等于:比較兩個對象是否不相等

(a!=b)返回true

<>

不等于:比較兩個對象是否不相等

(a<>b)返回true

>

大于:返回x是否大于y

(a>b)返回false

<

小于:返回x是否小于y

(a

>=

大于等于:返回x是否大于等于y

(a>=b)返回false

<=

小于等于:返回x是否小于等于y

(a<=b)返回true

等于(==):

>>> a=21

>>> b=10

>>> c=0

>>> if(a==b):

... print("a等于b")

... else:

... print("a不等于b")

...

a不等于b

不等于(!=):

>>> a=21

>>> b=10

>>> c=0

>>> if(a != b):

... print("a不等于b")

... else:

... print("a等于b")

...

a不等于b

大于(>):

>>> a=21

>>> b=10

>>> c=0

>>> if (a > b):

... print("a大于b")

... else:

... print("a小于b")

...

a大于b

小于等于(<=):

>>> a=5

>>> b=20

>>> c=0

>>> if(b >= a):

... print("b大于等于a")

... else:

... print("b小于a")

...

b大于等于a

◆賦值運算符◆

基本的賦值運算符是"=",這里不是等號,他的優(yōu)先級別低于其他的運算符,所以對該運算符往往最后讀取,Python支持以下運算符:

運算符

描述信息

例子

=

簡單的賦值運算符

c=a+b,將a+b結(jié)果給c

+=

加法賦值運算符

c+a等效于c=c+a

-=

減法賦值運算符

c-=a等效于c=c-a

x=

乘法賦值運算符

c=a等效于c=ca

/=

除法賦值運算符

c/=a等效于c=c/a

%=

取模賦值運算符

c%=a等效于c=c%a

**=

冪賦值運算符

c**=a等效于c=c**a

//=

取整除賦值運算符

c//=a等效于c=c//a

普通的賦值(=):

>>> a=21

>>> b=10

>>> c=0

>>> c=a+b

>>> print("a+b=",c)

a+b=31

加等于(+=):

>>> a=21

>>> c=10

>>> c+=a

>>> print("c+=a(c=c+a)=",c)

c+=a(c=c+a)= 31

◆位運算符號◆

程序中的所有數(shù)在計算機內(nèi)存中都是以二進制的形式儲存的,位運算就是直接對整數(shù)在內(nèi)存中的二進制位進行操作,按位運算符是把數(shù)字看作二進制來進行計算,以下實例默認假設(shè)變量a=60(0011 1100);b=13(0000 1101),Python支持以下運算符:

運算符

描述信息

例子

&

按位與運算

(a&b)輸出結(jié)果為12

豎線

按位或運算

(a豎線b)輸出結(jié)果為61

^

按位異或運算

(a^b)輸出結(jié)果為49

~

按位取反運算

(~a)輸出結(jié)果為-61

<<

按位左移

(a<<2)輸出結(jié)果為240

>>

按位右移

(a>>2)輸出結(jié)果為15

與運算(&):

>>> a=60 # 60 = 0011 1100

>>> b=13 # 13 = 0000 1101

>>> c=0

>>>

>>> c= a & b # 12 = 0000 1100

>>> print("a與b: ",c)

a與b: 12

或運算(|):

>>> c= a | b # 61 = 0011 1101

>>> print("a或b: ",c)

a或b: 61

異或運算(^):

>>> c=a^b # 49 = 0011 0001

>>> print("a異或b:",c)

a異或b: 49

非運算(~):

>>> c=~a # -61 = 1100 0011

>>> print("非a:",c)

非a: -61

左移運算(<

>>> c=a << 2 # 240 = 1111 0000

>>> print("a左移2",c)

a左移2 240

右移運算(>>):

>>> c=a >>2 # 15 = 0000 1111

>>> print("a右移2",c)

a右移2 15

◆邏輯運算符◆

在形式邏輯中,邏輯運算符或邏輯聯(lián)結(jié)詞把語句連接成更復(fù)雜的復(fù)雜語句,邏輯運算符通常用于Boolean型(邏輯)值,這種情況,它們返回一個布爾型值,以下假設(shè)變量a=1;b=1;c=0,Python支持以下運算符:

運算符

描述信息

說明

and

x and y

邏輯比較,只要有一處為0則返回0

or

x or y

邏輯比較,兩邊都為0則返回0

not

not x

邏輯比較,兩邊都不為0則返回false

and邏輯與: and只要一處為假則表達式就為假

>>> a=1

>>> b=1

>>> c=0

>>> a and b

1

>>> a and c

0

or邏輯或: or只要有一處為真咋表達式為真

>>> a=1

>>> b=1

>>> c=0

>>> a or b

1

>>> a or c

1

>>> c or c

0

◆成員運算符◆

Python里有成員運算符,可以判斷一個元素是否在某一個序列中,比如可以判斷一個字符是否屬于這個字符串,可以判斷某個對象是否在這個列表中等,Python支持以下運算符:

運算符

描述信息

說明

in

a in list

如果在指定序列中找到值返回true,否則返回false

not in

a not in

如果在指定序列中沒找到值返回true,否則返回false

in運算符:

>>> a=10

>>> b=20

>>> list =[1,2,3,4,5]

>>>

>>> if ( a in list):

... print("a在list列表中")

... else:

... print("a不在list列表中")

...

a不在list列表中

not in運算符:

>>> a=10

>>> b=20

>>> list =[1,2,3,4,5]

>>>

>>> if ( b not in list):

... print("b不在list列表中")

... else:

... print("b在list列表中")

...

b不在list列表中

◆身份運算符◆

身份運算符用于比較兩個對象的存儲單元是否一致,id()函數(shù)用于獲取對象內(nèi)存地址,Python支持以下運算符:

運算符

描述信息

說明

is

a is b

判斷兩個標識符是不是引用自一個對象

is not

a is not

判斷兩個標識符是不是引用自不同對象

is運算符:

>>> a=20

>>> b=20

>>> c=30

>>>

>>> a is b

True

>>> a is c

False

is not運算符:

>>> a=20

>>> b=20

>>> c=30

>>>

>>> a is not b

False

>>> a is not c

True

## Python 數(shù)據(jù)類型

數(shù)據(jù)類型在數(shù)據(jù)結(jié)構(gòu)中的定義是一個值的集合以及定義在這個值集上的一組操作,在Python當(dāng)中數(shù)據(jù)類型包括數(shù)值類型、字符類型組、列表、字典、元組、等類型,下面的例子將依次介紹這幾種運算符的使用技巧.

◆數(shù)值的類型◆

Python支持int、float、bool、complex(復(fù)數(shù)),在Python中只有一種整數(shù)類型int表示為長整型,像大多數(shù)語言一樣,數(shù)值類型的賦值和計算都是很直觀的,數(shù)值間的數(shù)據(jù)互換可以參考如下列表:

int(x) #將x轉(zhuǎn)換為一個整數(shù)

long(x) #將x轉(zhuǎn)換為一個長整數(shù)

float(x) #將x轉(zhuǎn)換到一個浮點數(shù)

complex() #創(chuàng)建一個復(fù)數(shù)

str(x) #將對象x轉(zhuǎn)換為字符串

repr(x) #將對象x轉(zhuǎn)換為表達式字符串

eval(str) #用來計算在字符串中的有效Python表達式,并返回一個對象

tuple(x) #將序列s轉(zhuǎn)換為一個元組

list(x) #將序列s轉(zhuǎn)換為一個列表

chr(x) #將一個整數(shù)轉(zhuǎn)換為一個字符

unichr(x) #將一個整數(shù)轉(zhuǎn)換為Unicode字符

ord(x) #將一個字符轉(zhuǎn)換為它的整數(shù)值

hex(x) #將一個整數(shù)轉(zhuǎn)換為一個十六進制字符串

oct(x) #將一個整數(shù)轉(zhuǎn)換為一個八進制字符串

整數(shù)轉(zhuǎn)其他數(shù)值: 使用轉(zhuǎn)換命令將一個整數(shù)轉(zhuǎn)換為其他數(shù)值.

>>> temp=100

>>>

>>> float(temp)

100.0

>>> complex(temp)

(100+0j)

>>> str(temp)

'100'

整數(shù)轉(zhuǎn)換字符: 使用轉(zhuǎn)換命令將一個整數(shù)轉(zhuǎn)換為字符.

>>> temp=100

>>>

>>> chr(temp)

'd'

>>> ord(chr(temp))

100

進制轉(zhuǎn)換: 使用轉(zhuǎn)換命令實現(xiàn)進制轉(zhuǎn)換.

>>> temp=100

>>>

>>> hex(temp)

'0x64'

>>> oct(temp)

'0o144'

◆字符串類型◆

所謂字符串就是字符的集合,Python支持字符串這種數(shù)據(jù)類型,且提供了一些豐富的字符串處理函數(shù),以下列表中就是Python所支持的字符串操作函數(shù),接下來我們將找出幾個比較常用的字符串函數(shù)來進行演示.

str.capitalize() #將字符串的首字母變大寫

str.title() #將字符串中的每個單詞的首字母大寫

str.upper() #將字符串變成大寫

str.lower() #將字符串變成小寫

str.index() #找出索引對應(yīng)的字符串

str.find() #找出索引對應(yīng)的字符串

str.count() #找出字符串中元素出現(xiàn)的次數(shù)

str.format() #也是格式化的一種

str.center() #以什么字符從字符串兩邊填充

str.join() #以str為分隔符連接字符串

str.split() #以什么為分隔符分隔字符串

str.strip() #將字符串兩邊中的空格去掉

str.replace() #查找替換

str.isupper() #判斷是否為大寫

str.islower() #判斷是否為小寫

str.isalnum() #判斷是否是字母數(shù)字

str.isalpha() #判斷是否是字母下劃線

str.isdigit() #判斷是否是數(shù)字

str.isspace() #判斷是否為空

str.startswith() #找出以什么為開頭的字符元素

str.endswith() #找出以什么為結(jié)尾的字符元素

首字母大寫: 使用capitalize()函數(shù),將一個指定字符串首字母變成大寫.

>>> str="hello lyshark"

>>>

>>> str.capitalize()

'Hello lyshark'

全部首字母大寫: 使用title()函數(shù),將字符串中的每一個單詞的首字母大寫.

>>> str="hello lyshark"

>>>

>>> str.title()

'Hello Lyshark'

查找字符串: 使用index()函數(shù),找出指定字符串的索引編號,不存在則報錯.

>>> str="hello lyshark"

>>>

>>> str.index("hello")

0

>>> str.index("lyshark")

6

>>> str.index("mk")

ValueError: substring not found

查找字符串: 使用find()函數(shù),找出指定字符串的索引編號,不存在則返回-1.

>>> str="hello lyshark"

>>>

>>> str.find("hello")

0

>>> str.find("lyshark")

6

>>> str.find("mk")

-1

統(tǒng)計字符串出現(xiàn)次數(shù): 使用count()函數(shù),統(tǒng)計指定字符串的出現(xiàn)次數(shù).

>>> str="hello lyshark"

>>>

>>> str.count("h")

2

>>> str.count("l")

3

>>> str.count("hello")

1

>>> str.count("mk")

0

格式化輸出(1): 使用format()函數(shù),格式化輸出指定的一段內(nèi)容.

>>> "{} {}".format("hello","lyshark") #不設(shè)置指定位置,按默認順序

'hello lyshark'

>>>

>>> "{0} {1}".format("hello","lyshark") #設(shè)置指定位置

'hello lyshark'

>>>

>>> "{1} {0} {1}".format("hello","lyshark") #設(shè)置指定位置

'lyshark hello lyshark'

格式化輸出(2): 使用format()函數(shù),格式化輸出指定的一段內(nèi)容.

>>> print("網(wǎng)站名稱:{name},地址:{url}".format(name="myblog",url="www.mkdirs.com"))

網(wǎng)站名稱:myblog,地址:www.mkdirs.com

>>>

>>> site={"name":"myblog","url":"www.mkdirs.com"}

>>> print("網(wǎng)站名稱:{name} 地址:{url}".format(**site))

網(wǎng)站名稱:myblog 地址:www.mkdirs.com

>>>

>>> my_list = ['myblog','www.mkdirs.com']

>>> print("網(wǎng)站名稱:{0[0]},地址:{0[1]}".format(my_list))

網(wǎng)站名稱:myblog,地址:www.mkdirs.com

字符串填充: 使用center()函數(shù),填充指定字符串兩邊的內(nèi)容.

>>> str="hello lyshark"

>>>

>>> str.center(20,'*')

'***hello lyshark****'

>>>

>>> print(str.center(50,'-'))

------------------hello lyshark-------------------

字符串連接: 使用join()函數(shù),將序列中以指定的字符連接生成一個新字符串

>>> str="-"

>>> seq=("hello","lyshark","welcome")

>>>

>>> print(str.join(seq))

hello-lyshark-welcome

>>> list =['1','2','3','4','5']

>>> print(''.join(list))

12345

>>> 'kill %s' % ' '.join(['1024','2234'])

切割字符串: 使用split()函數(shù),指定分割一個字符串,并保存成列表.

>>> str="hello-lyshark-welcome"

>>>

>>> str.split("-")

['hello', 'lyshark', 'welcome']

去除字符串兩邊空格: 使用trip()函數(shù),去除指定字符串兩邊空格.

>>> str=" hello lyshark "

>>> str

' hello lyshark '

>>>

>>> str.strip()

'hello lyshark'

字符串查找替換: 使用replace()函數(shù),查找并替換指定字符串.

>>> str="hello lyshark"

>>> str

'hello lyshark'

>>>

>>> str.replace("lyshark","mkdirs")

'hello mkdirs'

判斷是否為大寫: 使用isupper()函數(shù),判斷指定字符串是否為大寫.

>>> str="LYSHARK"

>>> str1="lyshark"

>>>

>>> str.isupper()

True

>>> str1.isupper()

False

查找開頭結(jié)尾: 使用startswith()函數(shù),找出指定字母開頭的字符元素.

>>> str="hello lyshark welcome"

>>>

>>> str.startswith("hello")

True

>>> str.startswith("lyshark")

False

>>>

>>> str.startswith("lyshark") or str.endswith("welcome")

True

>>> str.startswith("lyshark") and str.endswith("welcome")

False

◆列表的類型◆

列表是Python中最基本的數(shù)據(jù)結(jié)構(gòu),同時也是最常用的,列表中的每個元素都分配一個數(shù)字-它的位置或索引,第一個索引是0,第二個索引是1,依此類推,,接下來我們將找出幾個比較常用的列表操作函數(shù)來進行演示.

list.insert() #在列表中指定索引位置前插入元素

list.append() #在列表尾部插入

list.remove() #刪除指定的元素

list.pop() #沒有指定索引,則彈出最后一個元素,返回的結(jié)果是彈出的索引對應(yīng)的元素

list.copy() #淺復(fù)制,只復(fù)制第一層,如果有嵌套序列則不會復(fù)制,需要復(fù)制要導(dǎo)入copy模塊

list.extend() #把另外一個列表合并,并不是追加

list.index() 　　 #列表中元素出現(xiàn)的索引位置

list.count() #統(tǒng)計列表中元素的次數(shù)

list.reverse() #進行逆序

list.sort() #進行排序,無法把數(shù)字和字符串一起排序

list1 + list2 #合并兩個列表,返回一個新的列表,不會修改原列表

list * N #把list重復(fù)N次,返回一個新列表

向列表追加數(shù)據(jù): 使用append()函數(shù),追加寫入幾個數(shù)據(jù)到指定的列表里.

>>> list = [1,2,3]

>>> list

[1, 2, 3]

>>>

>>> list.append(4)

>>> list.append(5)

>>> list.append(6)

>>>

>>> list

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

向列表插入數(shù)據(jù): 使用insert()函數(shù),向指定的列表插入幾個數(shù)據(jù)到指定的位置.

>>> list = ["admin","lyshark"]

>>> list

['admin', 'lyshark']

>>>

>>> list.insert(1,"python")

>>> list

['admin', 'python', 'lyshark']

>>>

>>> list.insert(2,"ruby")

>>> list.insert(2,"ruby")

>>> list

['admin', 'python', 'ruby', 'ruby', 'lyshark']

修改指定數(shù)據(jù): 使用names[]變量賦值的方式,修改指定元素的字段值.

>>> list

['admin', 'python', 'ruby', 'ruby', 'lyshark']

>>> list[0]="mkdirs"

>>> list

['mkdirs', 'python', 'ruby', 'ruby', 'lyshark']

>>>

>>> list[3]="pip"

>>> list

['mkdirs', 'python', 'ruby', 'pip', 'lyshark']

刪除指定數(shù)據(jù): 使用remove()函數(shù),刪除指定數(shù)據(jù),或使用del()函數(shù)來刪除.

>>> list

['mkdirs', 'python', 'ruby', 'pip', 'lyshark']

>>>

>>> del list[2] #通過下標刪除元素

>>> list

['mkdirs', 'python', 'pip', 'lyshark']

>>>

>>> list.remove("python") #刪除指定的元素

>>> list

['mkdirs', 'pip', 'lyshark']

>>>

>>> list.pop() #刪除列表的最后一個元素

'lyshark'

>>> list.pop()

'pip'

>>> list

['mkdirs']

擴展一個列表: 使用extend()函數(shù),將一個列表追加到另一個列表的后面.

>>> list1 = ["admin","guest","lyshark"]

>>> list2 = [1,2,3]

>>>

>>> list1.extend(list2)

>>> list1

['admin', 'guest', 'lyshark', 1, 2, 3]

淺COPY列表: 使用copy()函數(shù),實現(xiàn)列表的淺Copy.

>>> list1

['admin', 'guest', 'lyshark', 1, 2, 3]

>>>

>>> list1_copy = list1.copy()

>>> list1_copy

['admin', 'guest', 'lyshark', 1, 2, 3]

統(tǒng)計元素次數(shù): 使用count()函數(shù),統(tǒng)計列表中元素出現(xiàn)的次數(shù).

>>> list = ["admin","admin","lyshark","mkdirs"]

>>>

>>> list.count("admin")

2

>>> list.count("mkdirs")

1

正反向排序: 使用sort(),reverse()函數(shù),給指定列表元素排序.

>>> list = ["admin","python","ruby","1","3","6","9"]

>>> list

['admin', 'python', 'ruby', '1', '3', '6', '9']

>>>

>>> list.sort() #正向排序,必須元素類型一致

>>> list

['1', '3', '6', '9', 'admin', 'python', 'ruby']

>>>

>>> list

['1', '3', '6', '9', 'admin', 'python', 'ruby']

>>> list.reverse() #反向排序,必須元素類型一致

>>> list

['ruby', 'python', 'admin', '9', '6', '3', '1']

獲取元素下標: 使用index()函數(shù),來獲取元素的下標.

>>> list

['ruby', 'python', 'admin', '9', '6', '3', '1']

>>>

>>> list.index("admin")

2

>>> list.index("1")

6

列表的切片: 使用[]實現(xiàn)列表的各種切片操作.

>>> list=[1,2,3,4,5,6,7,8,9,0]

>>>

>>> list[1:4] #取出下標1-4的元素,不包括4

[2, 3, 4]

>>>

>>> list[1:-1] #取出下標1至-1,不包括-1

[2, 3, 4, 5, 6, 7, 8, 9]

>>>

>>> list[1:] #取出下標從1到最后的數(shù)據(jù)

[2, 3, 4, 5, 6, 7, 8, 9, 0]

>>>

>>> list[:] #取出所有元素

[1, 2, 3, 4, 5, 6, 7, 8, 9]

>>>

>>> list[0::2] #取元素時每次格2格

[1, 3, 5, 7, 9]

通過分片刪除數(shù)據(jù): 通過使用分片來清除指定列表中的數(shù)據(jù).

>>> list

[123, 111, 111, 111, 8, 7, 6, 5, 4, 3, 2, 1]

>>> list[0:3]

[123, 111, 111]

>>>

>>> list[0:3]=[] #將下標0-3替換成空,不包括3

>>> print(list)

[111, 8, 7, 6, 5, 4, 3, 2, 1]

>>>

嵌套列表的實現(xiàn): 一次性聲明兩個列表,并于數(shù)據(jù)名稱相關(guān)聯(lián).

>>> list1,list2 = [[1,"a","b"],[2,"a","b"]]

>>>

>>> print(list1)

[1, 'a', 'b']

>>> print(list2)

[2, 'a', 'b']

查找元素并修改(1): 查找列表中的指定元素,并修改,只修改第一次發(fā)現(xiàn)的.

[root@localhost]# cat test.py

#!/usr/bin/python

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

if 1 in name:

num_of_ele = name.count(1)

position_of_ele = name.index(1)

name[position_of_ele] = 888

print(name)

[root@localhost]# python test.py

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

查找元素并修改(2): 查找列表中的指定元素,并批量修改,修改所有的.

[root@localhost]# cat test.py

#!/usr/bin/python

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

for i in range(name.count(1)):

ele_index = name.index(1)

name[ele_index] = 8888888

print(name)

[root@localhost]# python test.py

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

◆字典的類型◆

Python 中的字典是另一種可變?nèi)萜髂Ｐ?且可存儲任意類型對象,字典一種key-value 的數(shù)據(jù)類型,字典的每個鍵值(key=>value)對用冒號(:)分割,每個對之間用逗號(,)分割,整個字典包括在花括號{}中,且字典還有兩個特性,第一個就是字典是無序的,第二個是key必須是唯一的,所以天生去重,字典的兩種格式如下所示:

person = {"name": "lyshark", "age": 22}

person = dict({"name": "lyshark", "age": 22})

info = {

'stu1': "加藤鷹",

'stu2': "波多野結(jié)衣",

'stu3': "小澤瑪利亞",

}

接下開繼續(xù)看字典的常用函數(shù)方法,以及后續(xù)的小例子,方法如下:

dict.get(key) #取得某個key的value

dict.has_key(key) #判斷字典是否有這個key,在python3中已經(jīng)廢除,使用in判斷

dict.keys() #返回所有的key為一個列表

dict.values() #返回所有的value為一個列表

dict.items() #將字典的鍵值拆成元組,全部元組組成一個列表

dict.pop(key) #彈出某個key-value

dict.popitem() #隨機彈出key-value

dict.clear() #清除字典中所有元素

dict.copy() #字典復(fù)制,d2=d1.copy()是淺復(fù)制,如果深復(fù)制需要copy模塊

dict.fromkeys(s) #生成一個新字典

dict.update(key) #將一個字典合并到當(dāng)前字典中

dict.iteritems() #生成key-value迭代器,可以用next()取下個key-value

dict.iterkeys() #生成key迭代器

dict.itervalues() #生成values迭代器

增加字典: 在info字典的基礎(chǔ)上,增加一個字段info["stu4"] = "蒼老師".

>>> info

{'stu1': '加藤鷹', 'stu2': '波多野結(jié)衣', 'stu3': '小澤瑪利亞'}

>>> info["stu4"] = "蒼老師"

>>>

>>> info

{'stu1': '加藤鷹', 'stu2': '波多野結(jié)衣', 'stu3': '小澤瑪利亞', 'stu4': '蒼老師'}

修改字典: 在info字典的基礎(chǔ)上,修改將stu1:加藤鷹修改為stu1:金手指.

>>> info

{'stu1': '加藤鷹', 'stu2': '波多野結(jié)衣', 'stu3': '小澤瑪利亞', 'stu4': '蒼老師'}

>>>

>>> info["stu1"] = "金手指"

>>> info

{'stu1': '金手指', 'stu2': '波多野結(jié)衣', 'stu3': '小澤瑪利亞', 'stu4': '蒼老師'}

刪除字典: 在info字典的基礎(chǔ)上,刪除幾個字典,以下提供多種刪除方法.

>>> info

{'stu1': '金手指', 'stu2': '波多野結(jié)衣', 'stu3': '小澤瑪利亞', 'stu4': '蒼老師'}

>>>

>>> info.pop("stu1") #通過pop函數(shù)刪除

'金手指'

>>> info

{'stu2': '波多野結(jié)衣', 'stu3': '小澤瑪利亞', 'stu4': '蒼老師'}

>>>

>>> del info["stu4"] #通過del命令刪除

>>> info

{'stu2': '波多野結(jié)衣', 'stu3': '小澤瑪利亞'}

>>>

>>> info.popitem() #隨機刪除元素

('stu3', '小澤瑪利亞')

查找字典: 在info字典基礎(chǔ)上,完成幾個查詢?nèi)蝿?wù),這里提供幾種方法.

>>> info

{'stu1': '加藤鷹', 'stu2': '波多野結(jié)衣', 'stu3': '小澤瑪利亞'}

>>>

>>> "stu1" in info #標準的查詢方式

True

>>>

>>> info.get("stu1") #使用get函數(shù)查詢

'加藤鷹'

>>>

>>> info["stu2"]

'波多野結(jié)衣'

更新字典: 在info字典的基礎(chǔ)上,更新字典內(nèi)容,將temp字典與info字典合并.

>>> info

{'stu1': '加藤鷹', 'stu2': '波多野結(jié)衣', 'stu3': '小澤瑪利亞'}

>>>

>>> temp = {1:2,"stu4":"蒼老師"}

>>>

>>> info.update(temp)

>>> info

{'stu1': '加藤鷹', 'stu2': '波多野結(jié)衣', 'stu3': '小澤瑪利亞', 1: 2, 'stu4': '蒼老師'}

字典遍歷(拓展): 這里提供兩種字典遍歷方法,建議使用第二種,因為其遍歷速度最快.

for keys,values in dict.items():

print(keys,values)

for keys in dict:

print(keys,dict[keys])

字典索引(拓展): 字典也支持索引的方式獲取,只不過key是他的索引了.

>>> dic={"x":100,"y":[1,2,3]}

>>>

>>> dic["x"]

100

>>> dic["y"]

[1, 2, 3]

>>>

>>> dic["y"][2:]

[3]

>>>

>>> len(dic)

2

變量解包(拓展1): 分別分解字典變成元組后賦值給t1,t2.

>>> dic

{'x': 100, 'y': [1, 2, 3]}

>>>

>>> dic.items()

dict_items([('x', 100), ('y', [1, 2, 3])])

>>>

>>> t1,t2=dic.items()

>>>

>>> print(t1)

('x', 100)

>>> print(t2)

('y', [1, 2, 3])

變量解包(拓展2): 取出所有key復(fù)制給k1,k2.

>>> k1,k2 = {"x":10,"y":20}

>>>

>>> print(k1)

x

>>> print(k2)

y

列表合并(拓展): 將兩個列表合成一個字典,其中l(wèi)ist1是key,list2是values.

>>> list1=[1,2,3,4]

>>> list2=["a","b","c","d"]

>>> dic={}

>>>

>>> for (x,y) in zip(list1,list2):

... dic[x]=y

...

>>> dic

{1: 'a', 2: 'b', 3: 'c', 4: 'd'}

>>>

字典合并(拓展): 合并字典,但是在有相同的key時會覆蓋原有的key的值.

>>> dic1={"x":1,"y":2}

>>> dic2={"a":3,"b":4}

>>>

>>> dic1.update(dic2)

>>>

>>> print(dic1)

{'x': 1, 'y': 2, 'a': 3, 'b': 4}

>>>

◆元組的類型◆

元組是Python中常用的一種數(shù)據(jù)結(jié)構(gòu),元組由不同的元素組成,每個元素可以存儲不同類型的數(shù)據(jù),如字符串、數(shù)字甚至元組,元組是"寫保護"的,即元組創(chuàng)建后不能再做任何修改操作,元組通常代表一行數(shù)據(jù),而元組中的元素代表不同的數(shù)據(jù)項,元組一旦創(chuàng)建,便不能再修改,所以又叫只讀列表,元組使用小括號,列表使用方括號,元組創(chuàng)建很簡單,只需要在括號中添加元素,并使用逗號隔開即可.

創(chuàng)建元組: 同個幾個實例看一下元組是如何被創(chuàng)建的.

>>> tup1 = ("google","baidu",1997,1998)

>>> tup2 = (1,2,3,4,5,6,7)

>>> tup3 = "a","b","c","d"

>>>

>>> tup1

('google', 'baidu', 1997, 1998)

>>> tup2

(1, 2, 3, 4, 5, 6, 7)

>>> tup3

('a', 'b', 'c', 'd')

>>>

>>> type(tup1)

訪問元組: 元組可以使用下標索引來訪問元組中的值.

>>> tup1

('google', 'baidu', 1997, 1998)

>>>

>>> print("tup1[0:]",tup1[0])

tup1[0:] google

>>> print("tup1[1:2]",tup1[1:2])

tup1[1:2] ('baidu',)

連接元組: 元組中的元素值是不允許修改的,但我們可以對元組進行連接組合.

>>> tup1 = (1,2,3,4)

>>> tup2 = ("abc","xyz")

>>>

>>> tup3 = tup1+tup2

>>> print(tup3)

(1, 2, 3, 4, 'abc', 'xyz')

刪除元組: 元組中的元素值是不允許刪除的,但我們可以使用del語句來刪除整個元組.

>>> tup = ("admin","lyshark", 1997, 2000)

>>>

>>> print(tup)

('admin', 'lyshark', 1997, 2000)

>>> del tup;

>>> print(tup)

列表轉(zhuǎn)元組: 將一個列表,強制轉(zhuǎn)換成元祖.

>>> list = ["admin","lyshark","guest"]

>>>

>>> tuple = tuple(list)

>>>

>>> tuple

('admin', 'lyshark', 'guest')

數(shù)據(jù)統(tǒng)計: 通過使用count(),index()函數(shù)統(tǒng)計元組中的其他數(shù)據(jù).

>>> tuple

('admin', 'lyshark', 'guest')

>>>

>>> tuple.count("lyshark") #統(tǒng)計lyshark出現(xiàn)次數(shù)

1

>>> tuple.index("lyshark") #統(tǒng)計lyshark索引位置

1

元素修改(拓展): 在沒有嵌套的情況,元組是不可變對象,但是元組內(nèi)的列表是可變的.

>>> tup=("lyshark",[1,2,3,4,5])

>>> tup

('lyshark', [1, 2, 3, 4, 5])

>>>

>>> tup[1].pop()

5

>>> tup

('lyshark', [1, 2, 3, 4])

元組解包(拓展): 將兩個元組,查分開,分別存儲在兩個變量中.

>>> tup1,tup2=((1,2,3),("a","b","c"))

>>> print(tup1)

(1, 2, 3)

>>>

>>> print(tup2)

('a', 'b', 'c')

◆集合的類型◆

集合是一個無序的,不重復(fù)的數(shù)據(jù)組合,集合天生去重,把一個列表變成集合,就自動去重了,集合不支持：索引、元素獲取、切片,且沒有特定語法格式,只能通過工廠函數(shù)創(chuàng)建set,像字符串則直接創(chuàng)建即可,set集合中的元素必須是可迭代對象,所有元素不會重復(fù),不像list列表是可以重復(fù).

set.add(item) #將item添加到set中,如果item已經(jīng)在set中,則無任何效果

set.remove(item) #從set中刪除item,如果item不是set的成員,則引發(fā)KeyError異常

set.discard(item) #從set中刪除item.如果item不是set的成員,則無任何效果

set.pop() #隨機刪除一個集合元素,并從set刪除,有變量接收則會接收刪除到的元素

set.clear() #刪除set中的所有元素

set.copy() #淺復(fù)制

set.update(t) #將t中的所有元素添加到set中,t可以是另一個集合、一個序列

set.union(t) #求并集,返回所有在set和t中的元素

set.intersection(t) #求交集,返回所有同時在set和t中的都有的元素

set.intersection_update(t) #計算set與t的交集,并將結(jié)果放入set

set.difference(t) #求差集,返回所有在set中,但不在t中的元素

set.difference_update(t) #從set中刪除同時也在t中的所有元素

set.symmetric_difference(t) #求對稱差集,返回所有set中沒有t中的元素和t中沒有set中的元素組成的集合

set.sysmmetric_difference_update(t) #計算set與t的對稱差集,并將結(jié)果放入set

set.isdisjoint(t) #如果set和t沒有相同項,則返回True

set.issubset(t) #如果s是t的一個子集,則返回True

set.issuperset(t) #如果s是t的一個超集,則返回True

創(chuàng)建集合: 使用兩種方式分別創(chuàng)建一個集合元素.

>>> s = {"tom","cat","name","lyshark"}

>>> s = set({"tom","cat","name","lyshark"})

>>>

>>> s

{'tom', 'cat', 'name', 'lyshark'}

>>> type(s)

定義可變集合: 定義一個可變集合,集合中的元素不可重復(fù),都是不同的.

>>> set_test = set("hello")

>>> set_test

{'o', 'e', 'l', 'h'}

定義不可變集合: 定義一個不可變集合,集合中的元素不可重復(fù),都是不同的.

>>> set_test = set("hello")

>>> set_test

{'o', 'e', 'l', 'h'}

>>>

>>> no_set_test = frozenset(set_test)

>>> no_set_test

frozenset({'o', 'e', 'l', 'h'})

求子集: 子集為某個集合中一部分的集合,故亦稱部分集合.

>>> A = set('abcd')

>>> B = set("cdef")

>>> C = set("ab")

>>>

>>> C

True

>>> C.issubset(A) #C是A的子集

True

>>> C

False

求并集: 一組集合的并集是這些集合的所有元素構(gòu)成的集合,而不包含其他元素.

>>> A

{'d', 'a', 'c', 'b'}

>>> B

{'f', 'd', 'e', 'c'}

>>>

>>> A | B

{'f', 'b', 'c', 'a', 'e', 'd'}

>>> A.union(B)

{'f', 'b', 'c', 'a', 'e', 'd'}

求交集: 兩個集合A和B的交集是含有所有既屬于A又屬于B的元素,而沒有其他元素的集合.

>>> A

{'d', 'a', 'c', 'b'}

>>> B

{'f', 'd', 'e', 'c'}

>>>

>>> A & B

{'c', 'd'}

>>> A.intersection(B)

{'c', 'd'}

求差集: A與B的差集是,所有屬于A且不屬于B的元素構(gòu)成的集合.

>>> A

{'d', 'a', 'c', 'b'}

>>> B

{'f', 'd', 'e', 'c'}

>>>

>>> A - B

{'a', 'b'}

>>> A.difference(B)

{'a', 'b'}

對稱差: 兩個集合的對稱差是只屬于其中一個集合,而不屬于另一個集合的元素組成的集合.

>>> A

{'d', 'a', 'c', 'b'}

>>> B

{'f', 'd', 'e', 'c'}

>>>

>>> A ^ B

{'f', 'b', 'a', 'e'}

>>> A.symmetric_difference(B)

{'f', 'b', 'a', 'e'}

添加元素: 使用add()函數(shù),向一個現(xiàn)有的集合添加一個元素.

>>> s = {1,2,3,4,5,6}

>>> s

{1, 2, 3, 4, 5, 6}

>>> s.add("s")

>>> s.add("e")

>>> s.add("t")

>>>

>>> s

{1, 2, 3, 4, 5, 6, 't', 's', 'e'}

清空集合: 使用clear()函數(shù),清空一個集合中的所有元素.

>>> s

{1, 2, 3, 4, 5, 6, 't', 's', 'e'}

>>>

>>> s.clear()

>>>

>>> s

set()

刪除指定元素: 使用remove,discard函數(shù),刪除集合中的指定元素.

>>> s = {1,2,3,4,5}

>>> s

{1, 2, 3, 4, 5}

>>>

>>> s.remove(3)

>>> s

{1, 2, 4, 5}

批量更新元素: 使用update()函數(shù),用自己和另一個的并集來更新這個集合.

>>> s ={"p","y"}

>>> s

{'p', 'y'}

>>>

>>> s.update(["H","e"],{"1","2","3"})

>>> s

{'H', '1', 'y', 'p', '2', 'e', '3'}

拓展知識(1): 在多條數(shù)據(jù)中尋找差異.

# 數(shù)據(jù)庫中原有

old_dict = {

"#1":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 },

"#2":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 },

"#3":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 }

}

# cmdb 新匯報的數(shù)據(jù)

new_dict = {

"#1":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 800 },

"#3":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 },

"#4":{ 'hostname':'c2', 'cpu_count': 2, 'mem_capicity': 80 }

}

old_set=set(old_dict)

new_set=set(new_dict)

del_set=old_set.difference(new_set)

add_set=new_set.difference(old_set)

flush_set=old_set.intersection(new_set)

for i in del_set:

old_dict.pop(i)

for i in add_set:

old_dict[i]=new_dict[i]

for i in flush_set:

old_dict[i] = new_dict[i]

print(old_dict)

拓展知識(2): 在多條數(shù)據(jù)中尋找差異.

# 數(shù)據(jù)庫中原有

old_dict = {

"#1":8,

"#2":4,

"#3":2,

}

# cmdb 新匯報的數(shù)據(jù)

new_dict = {

"#1":4,

"#3":4,

"#4":2,

}

old_set = set(old_dict.keys())

print(old_set)

new_set = set(new_dict.keys())

print(new_set)

remove_set = old_set.difference(new_set)

print(remove_set)

add_set = new_set.difference(old_set)

print(add_set)

update_set = old_set.intersection(new_set)

print(update_set)

◆序列的補充◆

序列類型表示索引為非負整數(shù)的有序?qū)ο蠹?包括字符串、列表、元組、字符串是字符的,列表和元組是任意python對象的序列,字符和元組屬于不可變序列,而列表則支持插入、刪除和替換元素等.所有序列都支持迭代,當(dāng)然元組是不可變對象,對元素的操作是不支持的,當(dāng)然了有嵌套列表字典是可以操作的,以下是幾個常用的序列操作函數(shù):

s + r #連接字符串,與數(shù)據(jù)

s * n #重復(fù)s的n次復(fù)制

v1,v2...vn = s #變量解包(unpack)

s[i] #索引

s[i:j] #切片

s[i:j:stride] #擴展切片

x in s,x not in s #成員關(guān)系

for x in s: #迭代

all(s) #如果s中的所有項都為True,則返回True

any(s) #如果s中的任意項為True,則返回True

len(s) #長度,元素個數(shù)

min(s) #s中的最小項

max(s) #s中的最大項

sum(s [,initial]) #具有可選初始值的項的和

all判斷: 如果temp中的所有項都為True,則返回True.

>>> temp = [1,1,1,1,1,1]

>>> temp1 = [1,1,1,1,0,1]

>>>

>>> all(temp)

True

>>> all(temp1)

False

any判斷: 如果temp中的任意項為True,則返回True.

>>> temp = [1,1,1,1,1,1]

>>> temp1 = [1,1,1,1,0,1]

>>>

>>> any(temp)

True

>>> any(temp1)

True

len計算元素個數(shù): 計算列表或字典等相關(guān)的元素個數(shù).

>>> temp = [1,1,1,1,1,1]

>>> len(temp)

6

min返回最小: 返回列表中最小的數(shù)值.

>>> temp = [1,2,3,4,5,6,7,8,9]

>>>

>>> min(temp)

1

max返回最大: 返回列表中最大的數(shù)值.

>>> temp = [1,2,3,4,5,6,7,8,9]

>>>

>>> max(temp)

9

## Python 拓展知識

◆文件操作◆

open: open函數(shù)用來打開一個文件,并返回一個句柄.

>>> f=open("./test.txt","r")

>>>

popen: 使用popen存儲命令執(zhí)行結(jié)果,并打印執(zhí)行結(jié)果.

>>> temp=os.popen("ifconfig").readlines()

>>> temp

['eth0: flags=4163 mtu 1500\n']

read: 此函數(shù)一次性讀取文件所有內(nèi)容.

>>> f=open("./test.txt","r")

>>> f.read()

readline: 此函數(shù)每次讀取一行數(shù)據(jù),直到全部讀取完畢.

>>> f=open("./test.txt","r")

>>> f.readline()

'root:x:0:0:root:/root:/bin/bash\n'

>>> f.readline()

'bin:x:1:1:bin:/bin:/sbin/nologin\n'

>>> f.readline()

'daemon:x:2:2:daemon:/sbin:/sbin/nologin\n'

readlines: 使用readlines一次性讀取全部內(nèi)容,相當(dāng)于全部加載.

>>> f=open("./test.txt","r")

>>> f.readlines()

seek: 使用seek移動光標位置,tell獲取當(dāng)前光標位置.

>>> f=open("./test.txt","r")

>>> f.tell() #查詢當(dāng)前光標所在位置

0

>>> f.readline() #讀取一行后

'root:x:0:0:root:/root:/bin/bash\n'

>>>

>>> f.tell() #再次查詢光標所在位置

32

>>>

>>> f.read() #完全讀取后，光標此時在文件最后面..

'bin:x:1:1:bin:/bin:/sbin/nologin\ndaemon:x:2:2:daemon:/sbin:/sbin/nologin\n'

>>>

>>> f.seek(32) #移動光標到32

>>>

>>> f.read() #重新讀取數(shù)據(jù)

'bin:x:1:1:bin:/bin:/sbin/nologin\ndaemon:x:2:2:daemon:/sbin:/sbin/nologin\n'

flush: 強制刷新內(nèi)存中的數(shù)據(jù),將其寫入磁盤.

>>> import sys

>>> import time

>>>

>>> for i in range(40):

... sys.stdout.write("#")

... sys.stdout.flush() #強制將內(nèi)存中的數(shù)據(jù)寫入硬盤

... time.sleep(0.1)

close: 使用close關(guān)閉文件句柄,每次打開文件用完后記得關(guān)閉.

>>> f=open("./test.txt","r")

>>> f.readlines()

>>> f.close()

next: 每次讀取一行數(shù)據(jù),可以使用next函數(shù)加載下一行.

>>> f = open("./test.txt", "r")

>>> print ("文件名為: ", f.name)

>>> for index in range(5):

... line = next(f)

... print ("第 %d 行 - %s" % (index,line))

>>> f.close()

truncate: 截取數(shù)據(jù),可指定每次截取的字節(jié)數(shù).

>>> f = open("./test.txt", "r+")

>>> print ("文件名為: ", f.name)

>>> f.truncate(10) #截取10個字節(jié)

>>> str = f.read()

>>> print ("讀取數(shù)據(jù): %s" % (str))

>>> f.close()

with: 自動打開文件,并在執(zhí)行完后自動的釋放文件句柄.

>>> with open('test.txt') as f:

... print(f.read())

◆其他拓展◆

淺COPY: 淺拷貝值拷貝數(shù)據(jù)的第一層.

>>> import copy

>>> a=[1001,["a","b"]]

>>> print(a)

[1001, ['a', 'b']]

>>>

>>> b=copy.copy(a)

>>> b

[1001, ['a', 'b']]

>>>

>>> a[1][0]="lyshark"

>>> b

[1001, ['lyshark', 'b']] #看,只拷貝了第一層(此時,a第二層發(fā)生變化后b也變了)

>>>

深COPY: 深度拷貝,會將所有數(shù)據(jù)復(fù)制一份.

>>> import copy

>>>

>>> a=[1001,["a","b"]]

>>>

>>> print(a)

[1001, ['a', 'b']]

>>>

>>> b=copy.deepcopy(a)

>>>

>>> print(b)

[1001, ['a', 'b']]

>>>

>>> a[1][0]="lyshark"

>>>

>>> print(a)

[1001, ['lyshark', 'b']]

>>> print(b)

[1001, ['a', 'b']] #對于深copy由于是完全拷貝所以,對b沒有影響

>>>

Copy與deepcopy對比: 以下小例子來對比一下其中的變化.

import copy

n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]}

n2=copy.copy(n1)　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 # 淺拷貝

n3=copy.deepcopy(n1)　　　　　　　　　　　　　　　　　　　　　　　　　　　　# 深拷貝

print(n1,id(n1),id(n1['k1']),id(n1['k3']))

print(n2,id(n2),id(n2['k1']),id(n2['k3']))

print(n3,id(n3),id(n3['k1']),id(n3['k3']))

# 從下面打印的值結(jié)合上面的圖就可以很好的理解

# {'k3': ['alex', 456], 'k2': 123, 'k1': 'wu'} 2713748822024 2713753080528 2713755115656

# {'k3': ['alex', 456], 'k2': 123, 'k1': 'wu'} 2713755121416 2713753080528 2713755115656

# {'k3': ['alex', 456], 'k2': 123, 'k1': 'wu'} 2713753267656 2713753080528 2713754905800

enumrate: 給一個可迭代的對象添加序號,默認是編號是從0開始,可以設(shè)置從1開始.

>>> list=["蒼井空","小澤瑪利亞","吉澤明步"]

>>> for (x,y) in enumerate(list,1):

print(x,y)

1 蒼井空

2 小澤瑪利亞

3 吉澤明步

range: range用來指定范圍,生成指定的數(shù)字.

>>> for i in range(1,10):

print(i)

>>> for i in range(1,10,2):

print(i)

總結(jié)

以上是生活随笔為你收集整理的python中find函数运算结果类型_Python 运算符与数据类型的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。