pythonsetget方法

1. 萬字干貨，python語法大合集，一篇文章帶你入門

這份資料非常純粹，只有Python的基礎語法，專門針對想要學習Python的小白。

Python中用#表示單行注釋，#之後的同行的內容都會被注釋掉。

使用三個連續的雙引號表示多行注釋，兩個多行注釋標識之間內容會被視作是注釋。

Python當中的數字定義和其他語言一樣：

我們分別使用+, -, *, /表示加減乘除四則運算符。

這里要注意的是，在Python2當中，10/3這個操作會得到3，而不是3.33333。因為除數和被除數都是整數，所以Python會自動執行整數的計算，幫我們把得到的商取整。如果是10.0 / 3，就會得到3.33333。目前Python2已經不再維護了，可以不用關心其中的細節。

但問題是Python是一個 弱類型 的語言，如果我們在一個函數當中得到兩個變數，是無法直接判斷它們的類型的。這就導致了同樣的計算符可能會得到不同的結果，這非常蛋疼。以至於程序員在運算除法的時候，往往都需要手工加上類型轉化符，將被除數轉成浮點數。

在Python3當中撥亂反正，修正了這個問題，即使是兩個整數相除，並且可以整除的情況下，得到的結果也一定是浮點數。

如果我們想要得到整數，我們可以這么操作：

兩個除號表示 取整除 ，Python會為我們保留去除余數的結果。

除了取整除操作之外還有取余數操作，數學上稱為取模，Python中用%表示。

Python中支持 乘方運算 ，我們可以不用調用額外的函數，而使用**符號來完成：

當運算比較復雜的時候，我們可以用括弧來強制改變運算順序。

Python中用首字母大寫的True和False表示真和假。

用and表示與操作，or表示或操作，not表示非操作。而不是C++或者是java當中的&&, || 和！。

在Python底層， True和False其實是1和0 ，所以如果我們執行以下操作，是不會報錯的，但是在邏輯上毫無意義。

我們用==判斷相等的操作，可以看出來True==1， False == 0.

我們要小心Python當中的bool()這個函數，它並不是轉成bool類型的意思。如果我們執行這個函數，那麼 只有0會被視作是False，其他所有數值都是True ：

Python中用==判斷相等，>表示大於，>=表示大於等於， <表示小於，<=表示小於等於，!=表示不等。

我們可以用and和or拼裝各個邏輯運算：

注意not，and，or之間的優先順序，其中not > and > or。如果分不清楚的話，可以用括弧強行改變運行順序。

關於list的判斷，我們常用的判斷有兩種，一種是剛才介紹的==，還有一種是is。我們有時候也會簡單實用is來判斷，那麼這兩者有什麼區別呢？我們來看下面的例子：

Python是全引用的語言，其中的對象都使用引用來表示。is判斷的就是 兩個引用是否指向同一個對象 ，而==則是判斷兩個引用指向的具體內容是否相等。舉個例子，如果我們把引用比喻成地址的話，is就是判斷兩個變數的是否指向同一個地址，比如說都是沿河東路XX號。而==則是判斷這兩個地址的收件人是否都叫張三。

顯然，住在同一個地址的人一定都叫張三，但是住在不同地址的兩個人也可以都叫張三，也可以叫不同的名字。所以如果a is b，那麼a == b一定成立，反之則不然。

Python當中對字元串的限制比較松， 雙引號和單引號都可以表示字元串 ，看個人喜好使用單引號或者是雙引號。我個人比較喜歡單引號，因為寫起來方便。

字元串也支持+操作，表示兩個字元串相連。除此之外，我們把兩個字元串寫在一起，即使沒有+，Python也會為我們拼接：

我們可以使用[]來查找字元串當中某個位置的字元，用 len 來計算字元串的長度。

我們可以在字元串前面 加上f表示格式操作 ，並且在格式操作當中也支持運算，比如可以嵌套上len函數等。不過要注意，只有Python3.6以上的版本支持f操作。

最後是None的判斷，在Python當中None也是一個對象， 所有為None的變數都會指向這個對象 。根據我們前面所說的，既然所有的None都指向同一個地址，我們需要判斷一個變數是否是None的時候，可以使用is來進行判斷，當然用==也是可以的，不過我們通常使用is。

理解了None之後，我們再回到之前介紹過的bool()函數，它的用途其實就是判斷值是否是空。所有類型的 默認空值會被返回False ，否則都是True。比如0，""，[], {}, ()等。

除了上面這些值以外的所有值傳入都會得到True。

Python當中的標准輸入輸出是 input和print 。

print會輸出一個字元串，如果傳入的不是字元串會自動調用__str__方法轉成字元串進行輸出。 默認輸出會自動換行 ，如果想要以不同的字元結尾代替換行，可以傳入end參數：

使用input時，Python會在命令行接收一行字元串作為輸入。可以在input當中傳入字元串，會被當成提示輸出：

Python支持 三元表達式 ，但是語法和C++不同，使用if else結構，寫成：

上段代碼等價於：

Python中用[]表示空的list，我們也可以直接在其中填充元素進行初始化：

使用append和pop可以在list的末尾插入或者刪除元素：

list可以通過[]加上下標訪問指定位置的元素，如果是負數，則表示 倒序訪問 。-1表示最後一個元素，-2表示倒數第二個，以此類推。如果訪問的元素超過數組長度，則會出發 IndexError 的錯誤。

list支持切片操作，所謂的切片則是從原list當中 拷貝 出指定的一段。我們用start: end的格式來獲取切片，注意，這是一個 左閉右開區間 。如果留空表示全部獲取，我們也可以額外再加入一個參數表示步長，比如[1:5:2]表示從1號位置開始，步長為2獲取元素。得到的結果為[1, 3]。如果步長設置成-1則代表反向遍歷。

如果我們要指定一段區間倒序，則前面的start和end也需要反過來，例如我想要獲取[3: 6]區間的倒序，應該寫成[6:3:-1]。

只寫一個:，表示全部拷貝，如果用is判斷拷貝前後的list會得到False。可以使用del刪除指定位置的元素，或者可以使用remove方法。

insert方法可以 指定位置插入元素 ，index方法可以查詢某個元素第一次出現的下標。

list可以進行加法運算，兩個list相加表示list當中的元素合並。 等價於使用extend 方法：

我們想要判斷元素是否在list中出現，可以使用 in關鍵字 ，通過使用len計算list的長度：

tuple和list非常接近，tuple通過()初始化。和list不同， tuple是不可變對象 。也就是說tuple一旦生成不可以改變。如果我們修改tuple，會引發TypeError異常。

由於小括弧是有改變優先順序的含義，所以我們定義單個元素的tuple， 末尾必須加上逗號 ，否則會被當成是單個元素：

tuple支持list當中絕大部分操作：

我們可以用多個變數來解壓一個tuple：

解釋一下這行代碼：

我們在b的前面加上了星號， 表示這是一個list 。所以Python會在將其他變數對應上值的情況下，將剩下的元素都賦值給b。

補充一點，tuple本身雖然是不可變的，但是 tuple當中的可變元素是可以改變的 。比如我們有這樣一個tuple：

我們雖然不能往a當中添加或者刪除元素，但是a當中含有一個list，我們可以改變這個list類型的元素，這並不會觸發tuple的異常：

dict也是Python當中經常使用的容器，它等價於C++當中的map，即 存儲key和value的鍵值對 。我們用{}表示一個dict，用:分隔key和value。

對 。我們用{}表示一個dict，用:分隔key和value。

dict的key必須為不可變對象，所以 list、set和dict不可以作為另一個dict的key ，否則會拋出異常：

我們同樣用[]查找dict當中的元素，我們傳入key，獲得value，等價於get方法。

我們可以call dict當中的keys和values方法，獲取dict當中的所有key和value的集合，會得到一個list。在Python3.7以下版本當中，返回的結果的順序可能和插入順序不同，在Python3.7及以上版本中，Python會保證返回的順序和插入順序一致：

我們也可以用in判斷一個key是否在dict當中，注意只能判斷key。

如果使用[]查找不存在的key，會引發KeyError的異常。如果使用 get方法則不會引起異常，只會得到一個None ：

setdefault方法可以 為不存在的key 插入一個value，如果key已經存在，則不會覆蓋它：

我們可以使用update方法用另外一個dict來更新當前dict，比如a.update(b)。對於a和b交集的key會被b覆蓋，a當中不存在的key會被插入進來：

我們一樣可以使用del刪除dict當中的元素，同樣只能傳入key。

Python3.5以上的版本支持使用**來解壓一個dict：

set是用來存儲 不重復元素 的容器，當中的元素都是不同的，相同的元素會被刪除。我們可以通過set()，或者通過{}來進行初始化。注意當我們使用{}的時候，必須要傳入數據，否則Python會將它和dict弄混。

set當中的元素也必須是不可變對象，因此list不能傳入set。

可以調用add方法為set插入元素：

set還可以被認為是集合，所以它還支持一些集合交叉並補的操作。

set還支持 超集和子集的判斷 ，我們可以用大於等於和小於等於號判斷一個set是不是另一個的超集或子集：

和dict一樣，我們可以使用in判斷元素在不在set當中。用可以拷貝一個set。

Python當中的判斷語句非常簡單，並且Python不支持switch，所以即使是多個條件，我們也只能 羅列if-else 。

我們可以用in來循環迭代一個list當中的內容，這也是Python當中基本的循環方式。

如果我們要循環一個范圍，可以使用range。range加上一個參數表示從0開始的序列，比如range(10)，表示[0, 10)區間內的所有整數：

如果我們傳入兩個參數，則 代表迭代區間的首尾 。

如果我們傳入第三個元素，表示每次 循環變數自增的步長 。

如果使用enumerate函數，可以 同時迭代一個list的下標和元素 ：

while循環和C++類似，當條件為True時執行，為false時退出。並且判斷條件不需要加上括弧：

Python當中使用 try和except捕獲異常 ，我們可以在except後面限制異常的類型。如果有多個類型可以寫多個except，還可以使用else語句表示其他所有的類型。finally語句內的語法 無論是否會觸發異常都必定執行 ：

在Python當中我們經常會使用資源，最常見的就是open打開一個文件。我們 打開了文件句柄就一定要關閉 ，但是如果我們手動來編碼，經常會忘記執行close操作。並且如果文件異常，還會觸發異常。這個時候我們可以使用with語句來代替這部分處理，使用with會 自動在with塊執行結束或者是觸發異常時關閉打開的資源 。

以下是with的幾種用法和功能：

凡是可以使用in語句來迭代的對象都叫做 可迭代對象 ，它和迭代器不是一個含義。這里只有可迭代對象的介紹，想要了解迭代器的具體內容，請移步傳送門：

Python——五分鍾帶你弄懂迭代器與生成器，夯實代碼能力

當我們調用dict當中的keys方法的時候，返回的結果就是一個可迭代對象。

我們 不能使用下標來訪問 可迭代對象，但我們可以用iter將它轉化成迭代器，使用next關鍵字來獲取下一個元素。也可以將它轉化成list類型，變成一個list。

使用def關鍵字來定義函數，我們在傳參的時候如果指定函數內的參數名， 可以不按照函數定義的順序 傳參：

可以在參數名之前加上*表示任意長度的參數，參數會被轉化成list：

也可以指定任意長度的關鍵字參數，在參數前加上**表示接受一個dict：

當然我們也可以兩個都用上，這樣可以接受任何參數：

傳入參數的時候我們也可以使用*和**來解壓list或者是dict：

Python中的參數 可以返回多個值 ：

函數內部定義的變數即使和全局變數重名，也 不會覆蓋全局變數的值 。想要在函數內部使用全局變數，需要加上 global 關鍵字，表示這是一個全局變數：

Python支持 函數式編程 ，我們可以在一個函數內部返回一個函數：

Python中可以使用lambda表示 匿名函數 ，使用:作為分隔，:前面表示匿名函數的參數，:後面的是函數的返回值：

我們還可以將函數作為參數使用map和filter，實現元素的批量處理和過濾。關於Python中map、rece和filter的使用，具體可以查看之前的文章：

五分鍾帶你了解map、rece和filter

我們還可以結合循環和判斷語來給list或者是dict進行初始化：

使用 import語句引入一個Python模塊 ，我們可以用.來訪問模塊中的函數或者是類。

我們也可以使用from import的語句，單獨引入模塊內的函數或者是類，而不再需要寫出完整路徑。使用from import *可以引入模塊內所有內容（不推薦這么干）

可以使用as給模塊內的方法或者類起別名：

我們可以使用dir查看我們用的模塊的路徑：

這么做的原因是如果我們當前的路徑下也有一個叫做math的Python文件，那麼 會覆蓋系統自帶的math的模塊 。這是尤其需要注意的，不小心會導致很多奇怪的bug。

我們來看一個完整的類，相關的介紹都在注釋當中

以上內容的詳細介紹之前也有過相關文章，可以查看：

Python—— slots ，property和對象命名規范

下面我們來看看Python當中類的使用：

這里解釋一下，實例和對象可以理解成一個概念，實例的英文是instance，對象的英文是object。都是指類經過實例化之後得到的對象。

繼承可以讓子類 繼承父類的變數以及方法 ，並且我們還可以在子類當中指定一些屬於自己的特性，並且還可以重寫父類的一些方法。一般我們會將不同的類放在不同的文件當中，使用import引入，一樣可以實現繼承。

我們創建一個蝙蝠類：

我們再創建一個蝙蝠俠的類，同時繼承Superhero和Bat：

執行這個類：

我們可以通過yield關鍵字創建一個生成器，每次我們調用的時候執行到yield關鍵字處則停止。下次再次調用則還是從yield處開始往下執行：

除了yield之外，我們還可以使用()小括弧來生成一個生成器：

關於生成器和迭代器更多的內容，可以查看下面這篇文章：

五分鍾帶你弄懂迭代器與生成器，夯實代碼能力

我們引入functools當中的wraps之後，可以創建一個裝飾器。裝飾器可以在不修改函數內部代碼的前提下，在外麵包裝一層其他的邏輯:

裝飾器之前也有專門的文章詳細介紹，可以移步下面的傳送門：

一文搞定Python裝飾器，看完面試不再慌

不知道有多少小夥伴可以看到結束，原作者的確非常厲害，把Python的基本操作基本上都囊括在裡面了。如果都能讀懂並且理解的話，那麼Python這門語言就算是入門了。

如果你之前就有其他語言的語言基礎，我想本文讀完應該不用30分鍾。當然在30分鍾內學會一門語言是不可能的，也不是我所提倡的。但至少通過本文我們可以做到熟悉Python的語法，知道大概有哪些操作，剩下的就要我們親自去寫代碼的時候去體會和運用了。

根據我的經驗，在學習一門新語言的前期，不停地查閱資料是免不了的。希望本文可以作為你在使用Python時候的查閱文檔。

最後，我這里有各種免費的編程類資料，有需要的及時私聊我，回復"學習"，分享給大家，正在發放中............

2. python常見數據類型

一,python整數類型所表示的數據。

1,一般用以表示一類數值:所有正整數,0和負整數;

2,整型作為最常用的,頻繁參與計算的數據類型，在python3.5中解釋器會自動在內存中創建-5-3000之間的（包含5，不包含3000）整型對象，也就是說在該范圍內,相等都是同一個已經創建好的整型對象。范圍之外的即使相等也表示不同對象，該特性隨python版本而改變，不要過於依賴。

3,bool型繼承了int型，他是int的子類。

4,Python2中有長整型long，數值范圍更大，在python3中已取消，所有整型統一由int表示。

5,參與所有數值計算，數學運算，科學計算。這也是所有編程語言都有的數據類型，因為編程語言生而需要模擬人的思維，藉助數學方式，自動計算、更好的解決大量重復性的事務，因此數值類型、整數類型在編程語言中不可或缺。

6,支持二進制(0b\0B開頭),十進制,八進制(0o\0O),十六進制(0x\0X)

二，python整數和浮點型支持常規的數值運算

整數和浮點數都可參與的運算：+ - * / %（取余） //（整除） **（冪）

Python字元型：

python字元型表示的數據：
python3支持Unicode編碼，由字母、數字和符號組成的形式就叫字元串，更接近或者相同與人們文字元號表示，因此在信息表示和傳遞時它也是最受認可的形式。在程序編寫中也是非常常用，對應的可操作的方法也很多，很有意思。
字元串不可被修改，可以拼接等方法創建新字元串對象；
支持分片和下標操作；a[2:]
支持+拼接，*重復操作和成員關系in/not in；
表示形式：用單引號雙引號包含起來的符號；a = str(『sdfsdfsdf』) 或 r』\t\nabcd』 原始字元，Bytes：b』abcd』；
6,字元串屬於不可變數據類型，內部機制為了節省空間，相同的兩個字元串表示相同的一個對象。a = 『python』 b = 『python』 a is b :True

二, 字元串支持的運算方法

1,capitalize() :首字母大寫後邊的字母小寫 a = 『abcd』 b = a.capitalize() b:Abcd

2,casefold() lower():字母轉換為全小寫

3,center(width,fillchar) :居中，width填補的長度；fillchar添加的字元

a = a.center(10,』_』) //』____abcd____』 默認無fillchar填充空格

4,count(sub,star,end) :字母計數：sub要查詢的字元

5,encode(encoding=』utf-8』,errors=』strict』) 設置編碼

Errors :設置錯誤類型

6,endswith(suffix,star,end) : 若以suffix結尾返回True

7，expandtabs(8) :設置字元串中tab按鍵符的空格長度：』\tabcde』

8,find(sub,star,end) : 返回指定范圍內的字元串下標，未找到返回-1

9，index(sub,star,end) :返回指定范圍字元串下標未找到拋出異常

10，isalnum() :判斷字元串是否是字母或數字，或字母和數字組合

11，isalpha() :判斷是否全是字母

12，isdecimal() :判斷字元串是否是十進制數值

13，isdigit() :判斷字元串是否是數字

14，isidentifier() :判斷字元串中是否包含關鍵字

15，islower() :判斷是否全小寫

16，isnumeric() :判斷全是數字

17，isspace() :判斷是否是空格

18，isupper() 判斷是否大寫

19，istitle() :判斷是否首字母大寫

20，join(iterable) :把可迭代對象用字元串進行分割：a.join(『123』)

21,ljust(width,fillchar);rjust() :左對齊右對齊

22, upper() :將字元串改為大寫

23，split(sep=None,maxsplit=-1) :分割一個字元串，被選中字元在字元串中刪除

『ab1cd1efg』.split(『1』) :[『ab』,』cd』,』efg』]

三，字元串格式化：按照規格輸出字元串

format(*args,**kwargs) :args位置參數，kwargs關鍵字參數

『{0:.1f}』.format(123.468) :格式化參數，小數點後保留1位四捨五入

四，字元串操作符%

1，%s :格式化字元串 『abcd%sdef』%』dddd』

2，%d:格式化整數

3，%o格式化無符號八進制

4，%x格式化無符號十六進制

5，%f格式化定點數

6, %e: 科學計數法格式化定點數

7，%g 根據值大小自動選%f,%e

8, %G E X :大寫形式

五，格式化輔助命令：

m.n :m最小總寬度，n小數點後位數：』%12.4f』%23456.789

六，轉義字元：字元串前r避免轉義：r』\nhello\thi』

\n:換行符

\t:橫向製表符

\':'

\":"

\b:退格符

\r:回車

\v:縱向製表符

\f:換頁符

\o,\x:八進制和十六進制

\0:空字元串

Python列表list

一，Python的列表list類型表示的數據：

Python列表在cpython中被解釋為長度可變的數組，用其他對象組成的連續數組。

列表中元素可以是相同或不同的數據類型；
當列表元素增加或刪除時，列表對象自動進行擴展或收縮內存，保證元素之間沒有縫隙，總是連續的。
Python中的列表是一個序列，也是一個容器類型
創建列表：a = []; b = [1,』python』]; c = list(); d = list((1,3,4,5))
支持切片操作list[start,stop,step]
python列表常用方法
1,append添加單個元素：list.append(object); //a.append(『python』)

2,extend添加可迭代對象: list.extend(iterable); //a.extend(『abcde』/[1,2,3])

3,insert 插入元素：list.insert(index,object): 在index下標前插入元素//a.insert(2,』python』)

4,clear 清空所有元素：list.clear() //a.clear()

5,pop 刪除並返回一個元素：list.pop(index) //默認刪除默認一個元素

remove 刪除指定元素：list.remove(v) ,v元素不存在報錯 //a.remove(『c』)
7，count 返回這個值在列表中數量：list.count(value)

8, 淺拷貝一個新列表：list.()

9,sort:排序list.sort(reverse=False/True) :默認升序

排序函數：sorted(list)

10，reverse: 原地翻轉：list.reverse()

11，index(value,star,stop) :指定范圍內該值下標：list.index(2,0,5)

列表元素訪問：
下標訪問：list[1]
For循環遍歷
通過下標修改元素：list[2 ] = 『hello』
列表常用運算符：
1,比較運算符：從第一個元素開始對比

2，+ 拼接一個新列表：l1+ l2

3, 重復操作符：* ,多個列表拼接

成員關系操作符：in/ not in
邏輯運算符：and not or
列表常用的排序方法：
冒泡排序；選擇排序；快速排序；歸並排序

Python元組tuple

一，Python元組tuple數據類型表示的數據：

元組是受到限制的、不可改變的列表；
可以是同構也可以是異構；
元組是序列類型、是可迭代對象，是容器類型。
元組的創建: a = (1,2,3)或a=1,2,3; b = tuple(); c = tuple(iterable)
支持切片操作tuple[start,stop,step]

二，python元組常用方法

1,index(value,star,stop) :指定范圍內該值下標：tuple.index(2,0,5)

2,count(value) ：值出現次數

三，支持運算：

1,比較運算符：從第一個元素開始對比

2，+ 拼接一個新元組：l1+ l2

3, 重復操作符：* ,多個元組拼接

4成員關系操作符：in/ not in

邏輯運算符：and not or
四，元組的訪問

下標操作；
For循環遍歷訪問。

Python字典類型

一,Python字典dict表示的數據：{key:value}

可根據關鍵字：鍵快速索引到對應的值；
字典是映射類型，鍵值對一一對應關系，不是序列；
字典元素是無序的；
字典是可迭代對象，是容器類型；
字典的創建：k = {}; k1={『keyword』:object}; k2 = dict();
K3 = dict(mapping); dict=(iterable)

二，字典的訪問：

通過key：k[『key』]

修改key對應的值：K[『key』] = value

For循環遍歷出來的是key；

For循環鍵值對：for I in d.items():

For 循環enumerate: for k,v in enumerate(k1):

In/not in 成員關系查詢鍵不支持查值

三，字典常用方法

get(key,de):獲取值：k.get(key,de) //若不存在則默認輸出de
pop(k,de):刪除一個鍵值對，不存在輸出de，未設置報錯；
keys() :返回字典所有key組成的序列：list(k.keys()) [1,2,3];
values():返回字典所有value組成的序列：list(k.values())
items():返回鍵值對組成的元組為元素的序列：（類set）list(k.items())
update(e):更新字典：e可是字典或兩元素組成的單位元素序列：e=[(5,6),(7,8)];
k.update(e)

clear():清空字典；
popitem()刪除某個鍵值對，若字典為空則報錯
() :淺拷貝
10, fromkeys(iterable,value=None):從可迭代對象創建字典

{}.fromkeys([1,2,3]) -----{1:None,2:None,3:None}

11,setdefault(k,d=None) :若key不存在則生成一個鍵值對

k.setdefault(『keyword』)

Python 集合set

集合表示的數據：
多個元素的無序組合，集合是無序的，集合元素是唯一的；
字典的鍵是由集合實現的；
集合是可迭代對象
集合創建：s = {1,2}; s1 = set(); s2 = set(iterable)
集合元素的訪問：
For 循環將集合所有元素全部訪問一遍，不重復

常用方法：
add(object):s.add(『hi』) 向集合添加一個元素
pop() :彈棧，集合為空則報錯：刪除任意一個元素；
clear():清空集合，返回一個空集合對象；
remove(object):刪除一個元素，不存在和報錯：s.remove(『hi』)
update(集合)：更新另一個集合，元素不存在則不更新；
() :淺拷貝
集合的運算：
交集：s1&s2;
差集,補集：s1-s2;
並集：s1|s2;
Issubset():判斷是否是子集：s1.issubset(s2) s1是否s2的集合子集
Issuperset():判斷是否是父集：s1.issuperset()
不可變集合：
Frozenset():返回一個空的不可變集合對象

Frozenset(iterable):

S = frozenset(iterable)

Python序列類型共同特性

一,序列類型共同特性

python序列類型有:str字元串,list列表,tuple元組
都支持下標索引，切片操作；
下標都是從0開始，都可通過下標進行訪問；
擁有相同的操作符
二，支持的函數：

len(obj):返回對象長度；
list(iterable):將可迭代對象轉為列表；
tuple(iterable):將可迭代對象轉為元組；
str(ojb):將任何對象轉為字元串形式；
max(iterable): python3中元素要是同類型，python2中元素可異構：max([『a』,1])
min(iterable):和max類似；
sum(iterable,star=0),求可迭代對象和，默認star為0，元素不能為字元串
sorted(iterable,key=None,reverse=False)
s=[(『a』,3),(『b』,2),(『c』,9)]

sorted(s,key=lambda s:s[1]) //按照數字排序

reversed(sequence):翻轉序列，返回迭代器
enumerate(iterable):返回enumerate對象,其元素都是一個元組（下標，值）
zip（iter1,iter2）: zip([1,2],[3,4]) ----[(1,3),(2,4)]

序列類型的切片操作：

Slice:

L[index]; 訪問某個元素；

L[1:4]; 區間

L[star:stop:step]; 設置步長取區間元素

3. python中set()函數的用法

使用PYTHON里的SET。

軟體：Python的3.0版本

電腦：WIN10

系統：3.2免費

1、set集合中沒有重復的值。set集合的形式為：｛item1，item2...}，創建set：s = {1，2，3}或者s= set()或者s= set((1,2,3))，重復元素在set中自動被過濾。

4. python中set()函數的用法

python中set()函數的用法如下：

工具／原料：台式電腦、Win10、Python3.6.5。

1、首先按下「Win+R」組合鍵，打開運行窗口，如下圖所示。

5. Python中內置數據類型list，tuple，dict，set的區別和用法

這篇文章主要給大家介紹了Python中內置數據類型list,tuple,dict,set的區別和用法，都是非常基礎的知識，十分的細致全面，有需要的小夥伴可以參考下。

Python語言簡潔明了，可以用較少的代碼實現同樣的功能。這其中Python的四個內置數據類型功不可沒，他們即是list, tuple, dict, set。這里對他們進行一個簡明的總結。
List
字面意思就是一個集合，在Python中List中的元素用中括弧[]來表示，可以這樣定義一個List:
L = [12, 'China', 19.998]

可以看到並不要求元素的類型都是一樣的。當然也可以定義一個空的List:
L = []

Python中的List是有序的，所以要訪問List的話顯然要通過序號來訪問，就像是數組的下標一樣，一樣是下標從0開始：
>>> print L[0]
12

千萬不要越界，否則會報錯
>>> print L[3]
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
IndexError: list index out of range

List也可以倒序訪問，通過「倒數第x個」這樣的下標來表示序號，比如-1這個下標就表示倒數第一個元素：
>>> L = [12, 'China', 19.998]
>>> print L[-1]
19.998

-4的話顯然就越界了
>>> print L[-4]

Traceback (most recent call last):
File "<pyshell#2>", line 1, in <mole>
print L[-4]
IndexError: list index out of range
>>>

List通過內置的append()方法來添加到尾部，通過insert()方法添加到指定位置（下標從0開始）：
>>> L = [12, 'China', 19.998]
>>> L.append('Jack')
>>> print L
[12, 'China', 19.998, 'Jack']
>>> L.insert(1, 3.14)
>>> print L
[12, 3.14, 'China', 19.998, 'Jack']
>>>

通過pop()刪除最後尾部元素，也可以指定一參數刪除指定位置：
>>> L.pop()
'Jack'
>>> print L
[12, 3.14, 'China', 19.998]
>>> L.pop(0)
12
>>> print L
[3.14, 'China', 19.998]

也可以通過下標進行復制替換
>>> L[1] = 'America'
>>> print L
[3.14, 'America', 19.998]

Tuple
Tuple可以看做是一種「不變」的List，訪問也是通過下標，用小括弧（）表示：
>>> t = (3.14, 'China', 'Jason')
>>> print t
(3.14, 'China', 'Jason')

但是不能重新賦值替換：
>>> t[1] = 'America'

Traceback (most recent call last):
File "<pyshell#21>", line 1, in <mole>
t[1] = 'America'
TypeError: 'tuple' object does not support item assignment

也沒有pop和insert、append方法。
可以創建空元素的tuple:
t = ()
或者單元素tuple (比如加一個逗號防止和聲明一個整形歧義):
t = (3.14,)
那麼tuple這個類型到底有什麼用處呢？要知道如果你希望一個函數返回多個返回值，其實只要返回一個tuple就可以了，因為tuple裡面的含有多個值，而且是不可變的（就像是java裡面的final）。當然，tuple也是可變的，比如:
>>> t = (3.14, 'China', 'Jason', ['A', 'B'])
>>> print t
(3.14, 'China', 'Jason', ['A', 'B'])
>>> L = t[3]
>>> L[0] = 122
>>> L[1] = 233
>>> print t
(3.14, 'China', 'Jason', [122, 233])

這是因為Tuple所謂的不可變指的是指向的位置不可變，因為本例子中第四個元素並不是基本類型，而是一個List類型，所以t指向的該List的位置是不變的，但是List本身的內容是可以變化的，因為List本身在內存中的分配並不是連續的。
Dict
Dict是Python中非常重要的數據類型，就像它的字面意思一樣，它是個活字典，其實就是Key-Value鍵值對，類似於HashMap，可以用花括弧{}通過類似於定義一個C語言的結構體那樣去定義它：
>>> d = {
'Adam': 95,
'Lisa': 85,
'Bart': 59,
'Paul': 75
}
>>> print d
{'Lisa': 85, 'Paul': 75, 'Adam': 95, 'Bart': 59}

可以看到列印出來的結果都是Key:Value的格式，可以通過len函數計算它的長度（List，tuple也可以）：
>>> len(d)
4
可以直接通過鍵值對方式添加dict中的元素：
>>> print d
{'Lisa': 85, 'Paul': 75, 'Adam': 95, 'Bart': 59}
>>> d['Jone'] = 99
>>> print d
{'Lisa': 85, 'Paul': 75, 'Adam': 95, 'Jone': 99, 'Bart': 59}

List和Tuple用下標來訪問內容，而Dict用Key來訪問： (字元串、整型、浮點型和元組tuple都可以作為dict的key)
>>> print d['Adam']
95

如果Key不存在，會報錯：
>>> print d['Jack']

Traceback (most recent call last):
File "<pyshell#40>", line 1, in <mole>
print d['Jack']
KeyError: 'Jack'

所以訪問之前最好先查詢下key是否存在：
>>> if 'Adam' in d : print 'exist key'

exist key

或者直接用保險的get方法：
>>> print d.get('Adam')
95
>>> print d.get('Jason')
None

至於遍歷一個dict，實際上是在遍歷它的所有的Key的集合，然後用這個Key來獲得對應的Value:
>>> for key in d : print key, ':', d.get(key)

Lisa : 85
Paul : 75
Adam : 95
Bart : 59

Dict具有一些特點：
查找速度快。無論是10個還是10萬個，速度都是一樣的，但是代價是耗費的內存大。List相反，佔用內存小，但是查找速度慢。這就好比是數組和鏈表的區別，數組並不知道要開辟多少空間，所以往往開始就會開辟一個大空間，但是直接通過下標查找速度快；而鏈表佔用的空間小，但是查找的時候必須順序的遍歷導致速度很慢
沒有順序。Dict是無順序的，而List是有序的集合，所以不能用Dict來存儲有序集合
Key不可變，Value可變。一旦一個鍵值對加入dict後，它對應的key就不能再變了，但是Value是可以變化的。所以List不可以當做Dict的Key，但是可以作為Value:

>>> print d
{'Lisa': 85, 'Paul': 75, 'Adam': 95, 'Jone': 99, 'Bart': 59}
>>> d['NewList'] = [12, 23, 'Jack']
>>> print d
{'Bart': 59, 'NewList': [12, 23, 'Jack'], 'Adam': 95, 'Jone': 99, 'Lisa': 85, 'Paul': 75}

Key不可重復。（下面例子中添加了一個'Jone':0，但是實際上原來已經有'Jone'這個Key了，所以僅僅是改了原來的value）

>>> print d
{'Bart': 59, 'NewList': [12, 23, 'Jack'], 'Adam': 95, 'Jone': 99, 'Lisa': 85, 'Paul': 75}
>>> d['Jone'] = 0
>>> print d
{'Bart': 59, 'NewList': [12, 23, 'Jack'], 'Adam': 95, 'Jone': 0, 'Lisa': 85, 'Paul': 75}

Dict的合並，如何將兩個Dict合並為一個，可以用dict函數：
>>> d1 = {'mike':12, 'jack':19}
>>> d2 = {'jone':22, 'ivy':17}
>>> dMerge = dict(d1.items() + d2.items())
>>> print dMerge
{'mike': 12, 'jack': 19, 'jone': 22, 'ivy': 17}

或者
>>> dMerge2 = dict(d1, **d2)
>>> print dMerge2
{'mike': 12, 'jack': 19, 'jone': 22, 'ivy': 17}

方法2比方法1速度快很多，方法2等同於：
>>> dMerge3 = dict(d1)
>>> dMerge3.update(d2)
>>> print dMerge
{'mike': 12, 'jack': 19, 'jone': 22, 'ivy': 17}

set
set就像是把Dict中的key抽出來了一樣，類似於一個List，但是內容又不能重復，通過調用set()方法創建：
>>> s = set(['A', 'B', 'C'])
就像dict是無序的一樣，set也是無序的，也不能包含重復的元素。
對於訪問一個set的意義就僅僅在於查看某個元素是否在這個集合裡面：
>>> print 'A' in s
True
>>> print 'D' in s
False

大小寫是敏感的。
也通過for來遍歷：
s = set([('Adam', 95), ('Lisa', 85), ('Bart', 59)])
#tuple
for x in s:
print x[0],':',x[1]

>>>
Lisa : 85
Adam : 95
Bart : 59

通過add和remove來添加、刪除元素（保持不重復），添加元素時，用set的add()方法：
>>> s = set([1, 2, 3])
>>> s.add(4)
>>> print s
set([1, 2, 3, 4])

如果添加的元素已經存在於set中，add()不會報錯，但是不會加進去了：
>>> s = set([1, 2, 3])
>>> s.add(3)
>>> print s
set([1, 2, 3])

刪除set中的元素時，用set的remove()方法：
>>> s = set([1, 2, 3, 4])
>>> s.remove(4)
>>> print s
set([1, 2, 3])

如果刪除的元素不存在set中，remove()會報錯：
>>> s = set([1, 2, 3])
>>> s.remove(4)
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
KeyError: 4

所以如果我們要判斷一個元素是否在一些不同的條件內符合，用set是最好的選擇，下面例子：
months = set(['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec',])
x1 = 'Feb'
x2 = 'Sun'

if x1 in months:
print 'x1: ok'
else:
print 'x1: error'

if x2 in months:
print 'x2: ok'
else:
print 'x2: error'

>>>
x1: ok
x2: error

6. 關於Python：get語句的問題

r.get(i,0) 就是,取i鍵的值，如果鍵不存在返回0。

r.setdefault(i,0) 則是,取i鍵的值，如果鍵不存在返回0，並且創建一個i:0的鍵值對。

所以，你的這個例子，兩種寫法，效果是一樣的。沒有區別，你看下面的例子，就很明顯。

get完，字典沒有變化，setdefault則新增了一個鍵值對

7. set在python中是什麼意思

在Python set是基本數據類型的一種集合類型，它有可變集合(set())和不可變集合(frozenset)兩種。

創建集合set、集合set添加、集合刪除、交集、並集、差集的操作都是非常實用的方法。set是一個無序的元素集合，支持並、交、差及對稱差等數學運算，但由於set不記錄元素位置，因此不支持索引、分片等類序列的操作。

python 中list，tuple，dict，set是最常用的集合類型。

list列表，相當於一個數組，不過list的長度是自動變化的而且列表元素自由的，不必每個元素都是同一種類型。它的簡潔的定義方式是a=[]。有序組合

tuple也是一個組合。不過tuple在定義好之後就不能再變化。它的簡潔的定義方式是a=1,3也可以是a=(1,3).有序組合。

dict是字典類型。也就是鍵值對類型。鍵名不可以重復，並且不可以變化（字元串就符合這個要求，常用字元串作為鍵名）。它的簡潔的定義方式是a={}.無序組合（意思就是你無法按照添加的順序對他進行遍歷）。

set是set類型（不好翻譯，用的也少）。也是一個無序的組合，元素是互斥的，也就不會出現相同的元素。可以把一個序列轉換成無重復元素的set.無序組合。

8. python實現跨文件全局變數的方法

python實現跨文件全局變數的方法
在使用Python編寫的應用的過程中，有時候會遇到多個文件之間傳遞同一個全局變數的情況。本文就此給出了如下的解決方法供大家參考。
文件1：globalvar.py
#!/usr/bin/env python2.7
class GlobalVar:
db_handle = None
mq_client = None
def set_db_handle(db):
GlobalVar.db_handle = db
def get_db_handle():
return GlobalVar.db_handle
def set_mq_client(mq_cli):
GlobalVar.mq_client = mq_cli
def get_mq_client():
return GlobalVar.mq_client

文件2：set.py
import globalvar as GlobalVar
def set():
GlobalVar.set_mq_client(10)
print "------set mq_client in set.py------mq_client: " + str(GlobalVar.get_mq_client())

文件3：get.py
#!/usr/bin/env python2.7
import globalvar as GlobalVar
def get():
print "------get mq_client in get.py------mq_client: " + str(GlobalVar.get_mq_client())

文件4：main.py
#!/usr/bin/env python2.7
import set
import get
set.set()
get.get()

其中globalvar.py中定義了兩個全局變數，在set.py中的set函數中對其進行賦值，在get.py文件中的get函數取值並列印。main.py函數作為應用入口，調用set和get。
這樣就可以看到一個完整的應用中，全局變數的跨文件使用。

9. python中set是什麼意思

在Python set是基本數據類型的一種集合類型，它有可變集合(set())和不可變集合(frozenset)兩種。

創建集合set、集合set添加、集合刪除、交集、並集、差集的操作都是非常實用的方法。set是一個無序的元素集合，支持並、交、差及對稱差等數學運算，但由於set不記錄元素位置，因此不支持索引、分片等類序列的操作。

tuple算是list和str的雜合（雜交的都有自己的優勢，上一節的末後已經顯示了）,那麼set則可以堪稱是list和dict的雜合。

set擁有類似dict的特點：可以用｛}花括弧來定義；其中的元素沒有序列，也就是是非序列類型的數據；而且，set中的元素不可重復，這就類似dict的鍵，set也有一點list的特點：有一種集合可以原處修改。

以上內容參考網路-Python