匿名函數，映射函數。

　　1. lambda 匿名函數
　　語法:
　　　　lambda 參數:返回值
　　　　　　不能完成複雜的操做

 1 def func(n):
 2     return n * n
 3 
 4 print(func(3))
 5 a = func
 6 a(3)
 7 print(a.__name__)    # 查看函數的函數名
 8 # lambda 匿名函數
 9 # x 參數
10 #  : 後面是函數體(直接return的內容)
11 a = lambda x: x*x   # 一行搞定一個函數. 可是, 不能完成複雜的函數操做
12 print(a)
13 print(a(6))
14 print(a.__name__)
15 
16 b = lambda x, y: x+y
17 print(b(1,3))
18 print(b.__name__)
19 
20 # 語法: 變量 = lambda 參數: 返回值

 

2. sorted() 函數
　　排序.
　　　　1. 可迭代對象
　　　　2. key=函數. 排序規則
　　　　3. reverse. 是否倒序
　　　　3. filter() 函數
　　過濾
　　　　1. 函數, 返回True或False
　　　　2. 可迭代對象

# lst = [5,7,6,12,1,13,9,18,5]
# # lst.sort()  # sort是list裏面的一個方法
# # print(lst)
#
# ll = sorted(lst, reverse=True) # 內置函數. 返回給你一個新列表  新列表是被排序的
# print(ll)


# 給列表排序. 根據字符串的長度進行排序
lst = ["大陽哥a", "尼古拉斯aa", "趙四aaa", "劉能a", "廣坤aaaaaa", "謝大腳a"]
#
# def func(s):
#     return s.count('a') #  返回數字
#
# ll = sorted(lst, key=lambda s:s.count('a')) # 內部. 把可迭代對象中的每個元素傳遞給func
# print(ll)
#
# lst = [
#         {'id':1, 'name':'alex', 'age':18},
#         {'id':2, 'name':'taibai', 'age':58},
#         {'id':3, 'name':'wusir', 'age':38},
#         {'id':4, 'name':'ritian', 'age':48},
#         {'id':5, 'name':'女神', 'age':18}
#        ]
#
# ll = sorted(lst, key=lambda dic:dic['age'], reverse=True)
# print(ll)

 

# def func(i):    # 判斷奇數
#     return i % 2 == 1
lst = [1,2,3,4,5,6,7,8,9]

ll = filter(lambda i:i%2==1, lst)
#  第一個參數. 函數. 將第二個參數中的每個元素傳給函數. 函數若是返回True, 留下該元素.
# print("__iter__" in dir(ll))
# print("__next__" in dir(ll))
# print(list(ll))

# lst = [
#         {'id':1, 'name':'alex', 'age':18},
#         {'id':2, 'name':'taibai', 'age':58},
#         {'id':3, 'name':'wusir', 'age':38},
#         {'id':4, 'name':'ritian', 'age':48},
#         {'id':5, 'name':'女神', 'age':18}
#        ]
#
# print(list(filter(lambda dic: dic['age']>40, lst)))

 

4. map() 映射函數
　　　　1. 函數
　　　　2. 可迭代對象
　　　　5. 遞歸

# lst = [1,2,3,4,5,6,7,8,9,0,23,23,4,52,35,234,234,234,234,234,23,4]
# it = map(lambda i: i * i, lst) # 把可迭代對象中的每個元素傳遞給前面的函數進行處理. 處理的結果會返回成迭代器
# print(list(it))


# lst1 = [ 1, 2, 3, 4, 5]
# lst2 = [ 2, 4, 6, 8]
# print(list(map(lambda x, y:x+y, lst1, lst2))) # 若是函數中有多個參數. 後面對應的列表要一一對應

 

# import sys
# sys.setrecursionlimit(10000)    # 能夠調整遞歸深度. 可是不必定能跑到這裏
# def func(count):
#     print("我是誰,我在哪裏"+str(count))
#     func(count+1)
# func(1)

# while 1:
#     a = 10
#     print("哈哈")

# 遍歷樹形結構
# import  os
# filePath = "d:\sylar\python_workspace"
#
# def read(filePath, n):
#     it = os.listdir(filePath)   # 打開文件夾
#     for el in it:
#         #  拿到路徑
#         fp = os.path.join(filePath, el) # 獲取到絕對路徑
#         if os.path.isdir(fp):   # 判斷是不是文件夾
#             print("\t"*n,el)
#             read(fp, n+1)    # 又是文件夾. 繼續讀取內部的內容 遞納入口
#         else:
#             print("\t"*n,el)    # 遞歸出口
#
# read(filePath, 0)

本身調用本身.
　　　　def func():
　　　　func()
　　　　func()
　　難點:很差想.須要找規律. 很差讀

 

6. 二分法
　　掐頭結尾取中間. 不停的改變左和右. 間接改變中間. 查詢效率很是高

# lst = [11,22,33,44,55,66,77,88,99,123,234,345,456,567,678,789,1111]
# n = 567
# left = 0
# right = len(lst) - 1
# count = 1
# while left <= right:
#     middle = (left + right) // 2
#     if n > lst[middle]:
#         left = middle + 1
#     elif n < lst[middle]:
#         right = middle - 1
#     else:
#         print(count)
#         print("存在")
#         print(middle)
#         break
#     count = count + 1
# else:
#     print("不存在")
lst = [11,22,33,44,55,66,77,88,99,123,234,345,456,567,678,789,1111]

def binary_search(left, right, n):
    middle = (left + right)//2
    if left > right:
        return -1
    if n > lst[middle]:
        left = middle + 1
    elif n < lst[middle]:
        right = middle - 1
    else:
        return middle
    return binary_search(left, right, n)
print(binary_search(0, len(lst)-1, 65) )


def binary_search(lst, n):
    left = 0
    right = len(lst) - 1
    middle = (left + right) // 2
    if right <= 0:
        print("沒找到")
        return
    if n > lst[middle]:
        lst = lst[middle+1:]
    elif n < lst[middle]:
        lst = lst[:middle]
    else:
        print("找到了")
        return
    binary_search(lst, n)
binary_search(lst, 65)