python map(fun，[arg]+)函數最少有兩個參數，第一參數為一個函數名，第二個參數是對應的這個函數的參數（一般為一個或多個list）。

enumerate() 函數

語法 以下是 enumerate() 方法的語法:
enumerate(sequence, [start=0])
參數 sequence – 一個序列、迭代器或其他支持迭代對象。
start – 下標起始位置

            
              seq = ['one', 'two', 'three']
 for i, element in enumerate(seq):
	 print( i, element)
0 one
1 two
2 three

seasons = ['Spring', 'Summer', 'Fall', 'Winter']
print( list(enumerate(seasons)))
##[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
print(  list(enumerate(seasons, start=1)) )      # 下標從 1 開始
##[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

            
          

map()

            
              def fun(x):
	  return x+1
print(list(map(fun,[1,2,3])))
#[2,3,4]

            
          

            
               def p(x):
	 return x**2
 a = [1,2,3,4]
map(p,a)

              
            
            

lambda表達式：有人說類似于一種匿名函數，通常是在需要一個函數，但是又不想費神去命名一個函數的場合下使用。

            
              s = [1,2,3]
print(list(map(lambda x:x+1,s)))
#[2,3,4]

            
          

這里的 lambda x:x+1 相當于 上面的fun()函數, lambda和（冒號）: 之間相當于 fun()函數的參數, :(冒號)之后 x+1 相當于fun()函數的return x+1

            
              s = [1,2,3]
print(list(map(lambda x,y,z:x*y*z ,s,s,s)))
#[1,8,27]

            
          

map和lambda表達式聯合使用

            
               a = [2,5,6]
 print(list(map(lambda x:x*10,a)))
#[20, 50, 60]
 print(a)
 #[2, 5, 6]

            
          

內置函數列表
https://www.runoob.com/python/python-built-in-functions.html

open()

            
              f = open('test.txt')
f.read()

            
          

zip(a,b)

            
              a = [1,2,3]
b = [4,5,6]
zipped = zip(a,b)     # 打包為元組的列表
 #[(1, 4), (2, 5), (3, 6)]

            
          

filter() 函數用于過濾序列，過濾掉不符合條件的元素，返回由符合條件元素組成的新列表。

            
              def is_odd(n):
   return n % 2 == 1
newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
print(newlist)

            
          

.str.format

            
              print("網站名：{name}, 地址 {url}".format(name="菜鳥教程", url="www.runoob.com"))
 "{1} {0} {1}".format("hello", "world")  # 設置指定位置
 print("網站名：{0[0]}, 地址 {0[1]}".format(my_list))  # "0" 是必須的

            
          

enumerate

enumerate()函數用于將一個可遍歷的數據對象(如列表、元組或字符串)組合轉換為一個索引序列，一般用于for循環中，同時列出元素和元素的索引號。

            
              my_list = ['a', 'b', 'c', 'd']
for i, x in enumerate(my_list):
   print i, x
   
my_list = ['a', 'b', 'c', 'd']
for item in enumerate(my_list):
   print item

            
          

eval

eval(source, globals=None, locals=None)
eval() 函數用來執行一個字符串表達式，并返回表達式的值。

            
              x = 3
result = eval('4*x')
print(result)  # 12

result = eval('x**3')
print(result)  # 27

result = eval('3+3')
print(result)  # 6

result = eval('x*x')
print(result)  

            
          

sorted

sorted（）函數，接收任何可迭代對象，返回一個排序后的新對象。

            
              l1 = [2, 4, 3, 1, "6", "a", 5, 9, 7]
new_l1 = sorted(l1)
print(new_l1)
#[1, 2, 3, 4, 5, 7, 9, '6', 'a']

            
          

sorted()函數可對任意可迭代對象進行排序

            
              l3 = ['a', 'A', 'b', 'B', 'c', 'C']
new_l3 = sorted(l3)
print(new_l3)
#['A', 'B', 'C', 'a', 'b', 'c']

            
          

key參數的值是一個函數，他對list中的每個原始執行操作后作為排序依據。

            
              new_list1 = sorted(l1, key=lambda x: x * -1)
print(new_list1)

l4 = [['aa', 2], ['bb', 1], ['cc', 3]]
new_l4 = sorted(l4, key=lambda x: x[1])
print(new_l4)
#[['bb', 1], ['aa', 2], ['cc', 3]]


            
          

1.lambda lambda其實就是一條語句，lambda(x):body。x是lambda函數的參數，參數可以有任意多個(包括可選參數);body是函數體，只能是一個表達式，并且直接返回該表達式的值。

f=lambda x:x+1
f(2) #3
(lambda x,y:x+y)(2,3) #5

2.filter filter(func, list)接受兩個參數：一個函數func和一個列表list，返回一個列表。函數func只能有一個參數。filter的功能：列表中所有元素作為參數傳遞給函數，返回可以另func返回真的元素的列表

l=[‘abc’,‘acd’,‘1245’,‘ddad’,‘aaa’]
func(s)
return s.startswith(‘a’)
filter(func, l)
#[‘abc’,‘acd’,‘aaa’]

filter為過濾list,并返回list,綁定的函數為一個返回bool值的函數
filter(lambda item:item>2,[1,2,3,4])
#[3,4]

def fun(x):
return x>2 and x<6
list=[1,2,3,4,5,6,7]
filter(fun,list)
#[3,4,5]

3.zip zip函數接受任意多個序列作為參數，將所有序列按相同的索引組合成一個元素是各個序列合并成的tuple的新序列，新的序列的長度以參數中最短的序列為準。另外(*)操作符與zip函數配合可以實現與zip相反的功能，即將合并的序列拆成多個tuple

x=[1,2,3],y=[‘a’,‘b’,‘c’]
zip(x,y)
[(1,‘a’),(2,‘b’),(3,‘c’)]
zip(*zip(x,y))
[(1,2,3),(‘a’,‘b’,‘c’)]
.
x=[1,2,3],y=[‘a’,‘b’,‘c’]
for a,b in zip(x,y)
print(a,b)

4.map為操作list,返回list,綁定的函數為修改list中每一個值的函數

list=[1,2,3]
map(lambda x : x*2,list)
#[2, 4, 6]

5.reduce為逐次操作list里的每項，接收的參數為 2個,最后返回的為一個結果

def myadd(x,y):
return x+y
sum=reduce(myadd,(1,2,3))
#6

def add(x, y) : # 兩數相加
return x + y
reduce(add, [1,2,3,4,5]) # 計算列表和：1+2+3+4+5
15
reduce(lambda x, y: x+y, [1,2,3,4,5]) # 使用 lambda 匿名函數