A. python容器如何管理元素
python容器主要介紹四部分內容，分別是列表、元組、字典和集合。最後再比較一下這幾種數據結構。這一部分內容在python中是非常重要的部分，掌握好了這幾種數據結構在處理數據的時候就會很方便，但是前提條件是對這幾種數據結構的特性要很了解。在實際編程中，最常見的工作就是將數據進行拆分和和合並，將其加工為特定的形式，而數據結構就是這種利器。
B. 優必傑Python編程之旅課程《數據容器》中介紹了哪些數據容器，如何根據創建格式來區分它們
三種數據容器，分別是列表、字典和元組。在Python中用方括弧表示列表，並用逗號分割其中的元素；字典是Python中唯一內建映射的類型，通過名字引用值的數據結構，每個鍵值用冒號分開，每個項之間用逗號分割，整個字典是包括在花括弧內的；元組大部分時候是用小括弧括起來的，用逗號分割元素。
C. 有哪些用 Python 語言講演算法和數據結構的書
Python常見數據結構整理
Python中常見的數據結構可以統稱為容器（container）。序列（如列表和元組）、映射（如字典）以及集合（set）是三類主要的容器。
一、序列（列表、元組和字元串）
序列中的每個元素都有自己的編號。Python中有6種內建的序列。其中列表和元組是最常見的類型。其他包括字元串、Unicode字元串、buffer對象和xrange對象。下面重點介紹下列表、元組和字元串。
1、列表
列表是可變的，這是它區別於字元串和元組的最重要的特點，一句話概括即：列表可以修改，而字元串和元組不能。
（1）、創建
通過下面的方式即可創建一個列表：
1
2
3
4
list1=['hello','world']
print list1
list2=[1,2,3]
print list2
輸出：
['hello', 'world']
[1, 2, 3]
可以看到，這中創建方式非常類似於javascript中的數組。
（2）、list函數
通過list函數（其實list是一種類型而不是函數）對字元串創建列表非常有效：
1
2
list3=list("hello")
print list3
輸出：
['h', 'e', 'l', 'l', 'o']
2、元組
元組與列表一樣，也是一種序列，唯一不同的是元組不能被修改（字元串其實也有這種特點）。
（1）、創建
1
2
3
4
5
6
t1=1,2,3
t2="jeffreyzhao","cnblogs"
t3=(1,2,3,4)
t4=()
t5=(1,)
print t1,t2,t3,t4,t5
輸出：
(1, 2, 3) ('jeffreyzhao', 'cnblogs') (1, 2, 3, 4) () (1,)
從上面我們可以分析得出：
a、逗號分隔一些值，元組自動創建完成；
b、元組大部分時候是通過圓括弧括起來的；
c、空元組可以用沒有包含內容的圓括弧來表示；
d、只含一個值的元組，必須加個逗號（,）；
（2）、tuple函數
tuple函數和序列的list函數幾乎一樣：以一個序列（注意是序列）作為參數並把它轉換為元組。如果參數就算元組，那麼該參數就會原樣返回：
1
2
3
4
5
6
7
8
t1=tuple([1,2,3])
t2=tuple("jeff")
t3=tuple((1,2,3))
print t1
print t2
print t3
t4=tuple(123)
print t45
輸出：
(1, 2, 3)
('j', 'e', 'f', 'f')
(1, 2, 3)
Traceback (most recent call last):
File "F:\Python\test.py", line 7, in <mole>
t4=tuple(123)
TypeError: 'int' object is not iterable
3、字元串
（1）創建
1
2
3
4
5
str1='Hello world'
print str1
print str1[0]
for c in str1:
print c
輸出：
Hello world
H
H
e
l
l
o
w
o
r
l
d
（2）格式化
字元串格式化使用字元串格式化操作符即百分號%來實現。
1
2
str1='Hello,%s' % 'world.'
print str1
格式化操作符的右操作數可以是任何東西，如果是元組或者映射類型（如字典），那麼字元串格式化將會有所不同。
1
2
3
4
5
6
strs=('Hello','world') #元組
str1='%s,%s' % strs
print str1
d={'h':'Hello','w':'World'} #字典
str1='%(h)s,%(w)s' % d
print str1
輸出：
Hello,world
Hello,World
注意：如果需要轉換的元組作為轉換表達式的一部分存在，那麼必須將它用圓括弧括起來：
1
2
str1='%s,%s' % 'Hello','world'
print str1
輸出：
Traceback (most recent call last):
File "F:\Python\test.py", line 2, in <mole>
str1='%s,%s' % 'Hello','world'
TypeError: not enough arguments for format string
如果需要輸出%這個特殊字元，毫無疑問，我們會想到轉義，但是Python中正確的處理方式如下：
1
2
str1='%s%%' % 100
print str1
輸出：100%
對數字進行格式化處理，通常需要控制輸出的寬度和精度：
1
2
3
4
5
6
7
from math import pi
str1='%.2f' % pi #精度2
print str1
str1='%10f' % pi #欄位寬10
print str1
str1='%10.2f' % pi #欄位寬10，精度2
print str1
輸出：
3.14
3.141593
3.14
字元串格式化還包含很多其他豐富的轉換類型，可參考官方文檔。
Python中在string模塊還提供另外一種格式化值的方法：模板字元串。它的工作方式類似於很多UNIX Shell里的變數替換，如下所示：
1
2
3
4
from string import Template
str1=Template('$x,$y!')
str1=str1.substitute(x='Hello',y='world')
print str1
輸出：
Hello,world!
如果替換欄位是單詞的一部分，那麼參數名稱就必須用括弧括起來，從而准確指明結尾：
1
2
3
4
from string import Template
str1=Template('Hello,w${x}d!')
str1=str1.substitute(x='orl')
print str1
輸出：
Hello,world!
如要輸出符，可以使用$輸出：
1
2
3
4
from string import Template
str1=Template('$x$$')
str1=str1.substitute(x='100')
print str1
輸出：100$
除了關鍵字參數之外，模板字元串還可以使用字典變數提供鍵值對進行格式化：
1
2
3
4
5
from string import Template
d={'h':'Hello','w':'world'}
str1=Template('$h,$w!')
str1=str1.substitute(d)
print str1
輸出：
Hello,world!
除了格式化之外，Python字元串還內置了很多實用方法，可參考官方文檔，這里不再列舉。
4、通用序列操作（方法）
從列表、元組以及字元串可以「抽象」出序列的一些公共通用方法（不是你想像中的CRUD），這些操作包括：索引（indexing）、分片（sliceing）、加（adding）、乘（multiplying）以及檢查某個元素是否屬於序列的成員。除此之外，還有計算序列長度、最大最小元素等內置函數。
（1）索引
1
2
3
4
5
6
str1='Hello'
nums=[1,2,3,4]
t1=(123,234,345)
print str1[0]
print nums[1]
print t1[2]
輸出
H
2
345
索引從0（從左向右）開始，所有序列可通過這種方式進行索引。神奇的是，索引可以從最後一個位置（從右向左）開始，編號是-1：
1
2
3
4
5
6
str1='Hello'
nums=[1,2,3,4]
t1=(123,234,345)
print str1[-1]
print nums[-2]
print t1[-3]
輸出：
o
3
123
（2）分片
分片操作用來訪問一定范圍內的元素。分片通過冒號相隔的兩個索引來實現：
1
2
3
4
5
6
7
8
nums=range(10)
print nums
print nums[1:5]
print nums[6:10]
print nums[1:]
print nums[-3:-1]
print nums[-3:] #包括序列結尾的元素，置空最後一個索引
print nums[:] #復制整個序列
輸出：
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 4]
[6, 7, 8, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[7, 8]
[7, 8, 9]
不同的步長，有不同的輸出：
1
2
3
4
5
6
7
8
nums=range(10)
print nums
print nums[0:10] #默認步長為1 等價於nums[1:5：1]
print nums[0:10:2] #步長為2
print nums[0:10:3] #步長為3
##print nums[0:10:0] #步長為0
print nums[0:10:-2] #步長為-2
輸出：
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 2, 4, 6, 8]
[0, 3, 6, 9]
[]
（3）序列相加
1
2
3
4
5
6
7
str1='Hello'
str2=' world'
print str1+str2
num1=[1,2,3]
num2=[2,3,4]
print num1+num2
print str1+num1
輸出：
Hello world
[1, 2, 3, 2, 3, 4]
Traceback (most recent call last):
File "F:\Python\test.py", line 7, in <mole>
print str1+num1
TypeError: cannot concatenate 'str' and 'list' objects
（4）乘法
1
2
3
4
5
6
print [None]*10
str1='Hello'
print str1*2
num1=[1,2]
print num1*2
print str1*num1
輸出：
[None, None, None, None, None, None, None, None, None, None]
HelloHello
[1, 2, 1, 2]
Traceback (most recent call last):
File "F:\Python\test.py", line 5, in <mole>
print str1*num1
TypeError: can't multiply sequence by non-int of type 'list'
（5）成員資格
in運算符會用來檢查一個對象是否為某個序列（或者其他類型）的成員（即元素）：
1
2
3
4
5
str1='Hello'
print 'h' in str1
print 'H' in str1
num1=[1,2]
print 1 in num1
輸出：
False
True
True
（6）長度、最大最小值
通過內建函數len、max和min可以返回序列中所包含元素的數量、最大和最小元素。
1
2
3
4
5
6
7
8
str1='Hello'
print len(str1)
print max(str1)
print min(str1)
num1=[1,2,1,4,123]
print len(num1)
print max(num1)
print min(num1)
輸出：
5
o
H
5
123
1
二、映射（字典）
映射中的每個元素都有一個名字，如你所知，這個名字專業的名稱叫鍵。字典（也叫散列表）是Python中唯一內建的映射類型。
1、鍵類型
字典的鍵可以是數字、字元串或者是元組，鍵必須唯一。在Python中，數字、字元串和元組都被設計成不可變類型，而常見的列表以及集合（set）都是可變的，所以列表和集合不能作為字典的鍵。鍵可以為任何不可變類型，這正是Python中的字典最強大的地方。
1
2
3
4
5
6
7
8
list1=["hello,world"]
set1=set([123])
d={}
d[1]=1
print d
d[list1]="Hello world."
d[set1]=123
print d
輸出：
{1: 1}
Traceback (most recent call last):
File "F:\Python\test.py", line 6, in <mole>
d[list1]="Hello world."
TypeError: unhashable type: 'list'
2、自動添加
即使鍵在字典中並不存在，也可以為它分配一個值，這樣字典就會建立新的項。
3、成員資格
表達式item in d（d為字典）查找的是鍵（containskey），而不是值（containsvalue）。
Python字典強大之處還包括內置了很多常用操作方法，可參考官方文檔，這里不再列舉。
思考：根據我們使用強類型語言的經驗，比如C#和Java，我們肯定會問Python中的字典是線程安全的嗎？
三、集合
集合（Set）在Python 2.3引入，通常使用較新版Python可直接創建，如下所示：
strs=set(['jeff','wong','cnblogs'])
nums=set(range(10))
看上去，集合就是由序列（或者其他可迭代的對象）構建的。集合的幾個重要特點和方法如下：
1、副本是被忽略的
集合主要用於檢查成員資格，因此副本是被忽略的，如下示例所示,輸出的集合內容是一樣的。
1
2
3
4
5
set1=set([0,1,2,3,0,1,2,3,4,5])
print set1
set2=set([0,1,2,3,4,5])
print set2
輸出如下：
set([0, 1, 2, 3, 4, 5])
set([0, 1, 2, 3, 4, 5])
2、集合元素的順序是隨意的
這一點和字典非常像，可以簡單理解集合為沒有value的字典。
1
2
strs=set(['jeff','wong','cnblogs'])
print strs
輸出如下：
set(['wong', 'cnblogs', 'jeff'])
D. python(pandas模塊)
Pandas是Python的一個數據分析包，最初由AQR Capital
Management於2008年4月開發，並於2009年底開源出來，目前由專注於Python數據包開發的Pydata開發team繼續開發和維護，屬於PyData項目的一部分，pandas最初被作為金融數據分析工具而開發出來，因此pandas為時間序列分析提供了很好的支持。
Pandas的名稱來自於面板數據和python數據分析。panel
data是經濟學中關於多維數據集的一個術語，在Pandas中也提供了panel的數據類型。
Pandas數據結構：
Series：一維數組，與numpy中的一維array類似。二者與Python基本的數據結構list相近，Series如今能保存不同種數據類型，字元串、boolean值、數字等都能保存在series中。
Time-series：以時間為索引的series。
DataFrame：二維的表格型數據結構，很多功能與R中的data.frame類似，可以將DataFrame理解為Series的容器。
Panel ：三維的數組，可以理解為DataFrame的容器。
Panel4D：是像Panel一樣的4維數據容器。
PanelND：擁有factory集合，可以創建像Panel4D一樣N維命名容器的模塊。
E. Python數據容器中,字典與列表,元組,字元串這三種容器有什麼本質區別
①.相同點: 字典像列表,元組,字元串一樣都是用來存儲多個數據的高級容器
②.不同點: 字典是無序的容器,其存儲數據的方式是鍵值對,不能使用索引下標訪問,要使用鍵key訪問數據
而列表,元組,字元串是有序的容器,容器中數據是有順序的,可以通過索引下標訪問數據
想要相關實現的操作和源碼，參考黑馬程序員的相關教程，官網都有配套資料，資料當中就含有課件+筆記+源碼了。總之非常適合小白學習，想要學習的可以去看看。
F. Python有哪些種類
Python有哪些種類？
1、數值型（Numbers）
2、布爾型（Booleans）
3、字元串（String）
4、Python容器
要快速學會Python，謹記『3個』『4類』『5大』『6種』這四個數字就可以了。
三個基本概念
1. 結構化（函數、模塊、包）
2. 面向對象（類及派生類、重載）
3. 虛擬環境（版本管理、環境隔離）
四類基本操作
1. 數據操作（各種數據類型的操作）
2. 文件操作（文件打開讀寫關閉等操作）
3. 模塊操作（導入使用、模塊查尋等操作）
4.並發操作（進程與線程、鎖/信號號/安全隊列等）
五大基本語句（5）
1. 賦值語句（變數、對象、賦值運算符）
2. 輸入輸出語句（print, input函數）
3. 條件判斷語句（if-elif-else語句）
4. 循環語句(遍歷循環for-in-else、條件循環while-else、break/continue)
5. 異常處理語句(try-except-else-finally)
六種數據類型（6）
1. 數字類型（int,bool,float,complex）
2. 字元串（str）
3. 列表（list）
4. 元組（tuple）
5. 字典（dict）
6. 集合（set）
如果你能夠把上面的幾個要點都掌握了，那麼就算是真正地入門了。
G. 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]; 設置步長取區間元素