函數基礎

定義函數:   def 函數名():
           縮進 函數體(代碼塊)


調用函數:   函數名 + () 小括號


執行順序:   def func(): 1
              print(‘這大佬黑‘) 3
           func()調用  2
           
函數的返回值:
           def func(): 1
              print(‘這大佬黑‘) 3
              return ‘今晚不濺不散‘
           func()調用  2
    
    返回一個參數的時候是它本身,返回多個就是元組形式顯示
    當函數體執行到return的時候就結束函數
    不寫return的時候  默認返回None  寫了return不寫返回值的時候  返回的也是None


函數的參數:
    
    參數:
        
        形參 :  在函數定義的時候括號裏的變量就是咱們的形參

            位置參數:

                按照實參的位置對應把值賦值給形參中變量

            默認參數(關鍵字參數):

                    在函數定義的時候,直接給變量賦值
                    默認參數不傳參是否可以????   可以
                    默認參數可以傳值嗎????       可以  將默認參數的值覆蓋

            混合參數:

                    位置參數在默認參數前面
                    例如:
                        def f(a,b,c = 8):
                            pass
        
        實參 :  在函數調用的時候括號裏放入的值就是實參

            位置參數:

                f(1,2,3)

            默認參數(關鍵字參數):

                f(a=1,b=2,c=3)

            混合參數:

                f(1,2,c=3)

        傳參:   將實參傳遞給形參的過程 

三元運算:

    a if a>b else b
    結果   條件   結果
    結果 如果條件成立使用前面的 否則就使用後邊的

函數進階
1. 函數的參數:

        動態:

            動態位置參數  *args

            動態關鍵字參數 **kwargs

        位置 > 動態位置參數 > 默認(關鍵字)參數 > 動態關鍵字參數


2. 名稱空間:

    局部命名空間
    全局命名空間
    內置命名空間


    加載順序:

        內置 > 全局 > 局部

    取值順序:

        局部 > 全局  > 內置

    作用域:

        全局作用域:

            內置 + 全局

        局部作用域:

            函數局部


    # print(globals())   # 查看全局作用域中的變量和函數名
    # print(locals())    # 查看局部作用域中的變量和函數名


3. 函數的嵌套:

    def f():
        print(11)
        def f1():
            print(22)
            def f2():
                print(33)             **********重要
            f2()

        f1()
    f()


4. 函數的註釋:

    def func():
        #     ‘‘‘
        #     這是打印的函數
        #     :param a: 沒啥用1
        #     :param b: 沒啥用1
        #     :param c: 沒啥用1
        #     :param d: 沒啥用1
        #     :return:  返回的None
        #     ‘‘‘
        #     print(a,b,c,d)

5.   global|

    # print(id(lst))
    # def func():
    #     # a = 15      # 在函數的局部中
    #     # global se     #
    #     lst[0] = 11
    #     # print(a)    # 使用的是局部
    # func()
    # print(lst)
    # print(id(lst))

    # 可變數據類型在函數中可以直接操作,不可變數據類型才需要使用global


    # a = 10
    # def f():
    #     a = 1 # a = 2
    #     def f1():
    #         # a = 4  # a = 2
    #         def f2():
    #             # nonlocal a
    #             # a = 2
    #             print(a)   # 2
    #         f2()
    #         print(a)       # 2
    #     f1()
    #     print(a)           # 2
    # f()

    # nonlocal 改變最近的父級變量, 如果上級沒有能夠改變的就繼續向上走,直到最外層函數就停止了.


##### 函數: 將一個需求封裝後調用,優點:除去重復代碼.

閉包
# 閉包: 內部函數使用了外部函數的變量,內部函數就是一個閉包
# def outer():
#     a = 1
#     b = ‘123‘
#     c = [1,2,3]
#     def inner():
#         print(1234)
#     print(inner.__closure__)  # inner不是一個閉包
# outer()
#
# def outer():
#     a = 1
#     b = ‘123‘
#     c = [1,2,3]
#     def inner():
#         print(a,b,c)
#     print(inner.__closure__)  # inner是一個閉包
# outer()

# def outer(a):
#     def inner():
#         print(a)
#     print(inner.__closure__)   # inner是一個閉包

# def outer(url):
#     def inner():
#         print(a)
#     print(inner.__closure__)

# from urllib import request  # 別人寫好了python代碼的文件
# ret = request.urlopen(‘http://www.cnblogs.com/Eva-J/articles/7213953.html‘)
# print(ret.read().decode(‘utf-8‘))

# 訪問一個網頁
# 會被頻繁的訪問
# import time
# from urllib import request
# def func2(url):
#     ret = request.urlopen(url)
#     content = ret.read().decode(‘utf-8‘)
#     return content
#
# start = time.time()
# for i in range(10):
#     func2(‘http://www.cnblogs.com/Eva-J/articles/7213953.html‘)
# print(time.time() - start)
#
# from urllib import request       # 導入別人寫好的python代碼,urllib是專門負責訪問url的
# def func(url):
#     ret = request.urlopen(url)   # 利用urlopen函數打開一個url得到結果ret
#     content = ret.read().decode(‘utf-8‘)  #使用ret的read方法得到bytes類型的網頁源碼,然後轉碼成str
#     def inner():
#         return content
#     return inner
#
# ret = func(‘http://www.cnblogs.com/Eva-J/articles/7213953.html‘)
# # 相當於將url對應的內容存在了url中,每一次調用ret就是獲取內容的過程
# for i in range(10):
#     ret()
# print(time.time() - start)

# 閉包的應用
    # 緩存
    # 裝飾器


# def func(*args):
#     sum_num = 0
#     for num in args:
#         sum_num += num
#     def inner():
#         return sum_num
#     return inner
#
# inner = func(1,2,3,4)
# inner()

叠代器

# 什麽是叠代器?
# l = [1,2,3,4]
# res = l.__iter__()
# print(res)
# list_iterator   iterator叠代器
# dir(l)
# print(dir(res))
# res中 但是不在l中的所有方法
# print(set(dir(res))-set(dir(l)))
# {‘__next__‘, ‘__setstate__‘, ‘__length_hint__‘}
# 叠代器中特有的方法,l中沒有
# print(res.__length_hint__())  # 叠代器中有多少個元素
# for i in res:
#     print(i)
# res.__setstate__(2)   # 控制叠代器從哪兒開始叠代
# for i in res:
#     print(i)
# print(res.__next__())   # 從叠代器中取下一個值
# print(res.__next__())
# print(res.__next__())
# print(res.__next__())
# print(res.__next__())
#
# for循環一個列表的時候必須用的
#     __next__取下一個值
#
# 叠代器協議 : 含有__next__和__iter__方法的變量/值都是叠代器
#
# 叠代器的特點:
#     具有next和iter方法
#     通過一個next多次執行就可以獲得所有這個容器中的值
#     叠代器中的值只能取一次
#     不取的時候值不出現
#
# for循環取值
#     for循環內部的機制就是叠代器取值的機制
#     在for循環執行的過程中 : 先把可叠代的變成一個叠代器,然後再從中一個一個的取值
#
# range生成的就是一個叠代器,創建這個叠代器並不會真的把叠代器中的所有數據一次性生成
# 什麽時候生成呢? 只有通過next取值的時候才會生成
# 記住你要多少個值 ,當前該給你什麽,並且記住我下一個該給你什麽,下一個和當前這個數的關系
#
# f文件句柄
# f記住 當前讀到哪個位置了
#
# a = list(range(1000000000))
# print(a)
#
# 叠代器的作用就是節省內存,for循環就是利用了叠代器節省內存的特點來對python當中的變量來進行操作的

生成器

# python語言自帶的
# 生成器 : 程序員通過簡單的函數就可以實現的
# def func():
#     print(‘hello‘)
#     yield 1
#
# g = func()   # 調用"生成器函數"
# print(g)     # g generator(生成器)
# 調用就不會執行這個函數,而是返回一個生成器
# print(dir(g))  # g是一個叠代器
# 所有的生成器都是叠代器
#
# a = g.__next__()
# print(a)
#
# def func():
#     print(‘hello‘)
#     yield 1
#     print(‘world‘)
#     yield 2
#
# g = func()
# a = g.__next__()
# print(a)
# b = g.__next__()
# print(b)
# yield關鍵字的特點: 可以記錄當前函數中執行的位置,下一次繼續執行
# next和yield是一對搭檔 : next開始函數的執行 yield停止函數的執行

生成器函數

 int 整數
# float 浮點數
# 1.2
# 2.3333344
# 256.789  = 2.56789*10**2
# 為什麽要叫浮點數 : 因為小數點是浮動的
# 浮點數能表示的數學上的數字 : 有理數(有限小數 無限循環小數)
# 浮點數的小數點是不準確的 : 小數的小數位是轉換成二進制存儲
# a = 1.7265923649689710283508127969
# a = 1.111111111188818181818111624
# print(a)
#
# 轉換成字符串存儲
# ‘1.71264864975975073507505‘

# 如果你創建的變量本身帶小數點,那麽這個變量的數據類型直接就是浮點數
# 所有的除法(除了//)得到的都是小數
#
# 除法
# python2.x 整數除以整數就會取整(向下取整),有一個數浮點數,就按照浮點數計算
# python3.x 所有的除(除了//)的結果都是小數


# 生成器函數中
# send/__next__  生成器函數之外用的
# yield/yield from 生成器函數之內用的
#
# next+send == yield
# 如果函數中的yield要接收參數,那麽應該使用send傳值
# 如果函數中的yield不需要接收參數,那麽應該使用next即可
#
# 生成器和叠代器是一樣的,內部的值都只能取一次
# 從生成器中取值的方式也和叠代器是一樣的:
#     for
#     next/send
#     數據類型的強制轉換(list)

# def gener():
#     print(‘草莓味‘)
#     yield 1
#     print(‘香蕉味‘)
#     yield 2
#     print(‘榴蓮味‘)
#     yield 3
#
# g = gener()
# num = g.__next__()
# num = g.__next__()
# num = g.__next__()
# print(num)
# for num in g:
#     print(‘*‘* num)

# def gener():
#     print(‘草莓味‘)
#     yield 1
#     # smell = yield 1
#     # print(smell)
#     print(‘可樂味‘)
#     smell2 = yield 2
#     print(smell2)
#     yield 3
#
# g = gener()
# print(g.__next__())
# ret = g.send(‘香蕉味‘)     # g.__next__只不過傳了一個值進去
# print(ret)
# ret2 = g.send(‘榴蓮味‘)
# print(ret2)

列表推導式

# 和循環/列表相關的知識點
# l = [1,2,3,4,5,6]
# # [1,4,9,16,25,36]
# new_l = []
# for i in l:
#     new_l.append(i*i)
# print(new_l)
#
# new_l2 = [i*i for i in l]
# print(new_l2)

# l = [1,2,3,4,5,6]
# print([i*i for i in l])   # 列表推導式
# 當已經有了一個列表,從這個列表中的每一個元素都需要做某個操作
# 並且需要將操作的結果放在一個新的列表中
# 適合使用列表推導式
# 新的列表 = [每一個元素要做的操作 for 列表中的每一個元素 in 列表]
# range(2,20)  # 把每一個元素整除3的結果放到一個新的列表中
# new_lst = []
# for num in range(2,20):
#     new_lst.append(num//3)

# lst = [num//3 for num in range(2,20)]
# print(lst)

# 請計算0-100內能被3整除的所有數字
# new_lst = []
# for i in range(0,101):
#     if i%3 == 0:
#         new_lst.append(i)
#
#
# new_lst2 = [i for i in range(0,101) if i%3 == 0]
# print(new_lst2)

生成器表達式

# 生成器表達式
# 1.想要一個生成器/叠代器 , 簡單的邏輯可以不寫函數而是直接用表達式實現
# 2.生成器表達式本身就是一個生成器/叠代器
# 3.惰性運算(列表推導式在執行完的那一刻,已經存在一個列表了) 只能取一次
    # 生成器 只有 for next list才開始從生成器中取值 列表推導式
# 4.更加簡潔

# 生成器
# def func():
#     for i in range(1000001):
#         if i%3 == 0:
#             yield i
#
# g1 = func()
# g1.__next__()

# g = (i for i in range(0,101) if i%3 == 0)
# print(g.__next__())
# print(g.__next__())

python中的關鍵字---2（函數基礎類）