day6-基礎函數的學習（一）

時間  2019-11-17
標籤 day6 day 基礎 函數 學習 简体版
原文   原文鏈接

今日份目錄python

1.函數的定義linux

2.函數的返回值app

3.函數的參數函數

4.函數的局部變量與全局變量學習

5.名稱空間與做用域spa

6.global與nonlocal翻譯

7.高階函數code

 

繼續今日份總結！這個總結也晚了，哎，速度仍是太慢！blog

正文開始內存

隨着學習進度的逐漸的加深發現咱們的函數體越來重複化愈來愈嚴重，太多重複代碼，這會讓咱們的代碼的可讀性愈來愈差

1.函數的定義

定義：將一組語句集合經過一個名字（函數名）封裝起來，只須要執行，調用其函數名

print sayhi ---->返回內存地址

print sayhi()---->返回函數內的內容

特性：

  1. 減小重複代碼
  2. 使程序變得可擴展
  3. 使程序變得易維護

哎，跟着金老師開會兒車，雖然我也不懂怎麼用，不少人應該都用過探探或者陌陌這類型聊天交友軟件，如今寫一下大概的軟件的搭建

def tantan():
    print('打開手機！')
    print('打開軟件！')
    print('附件的人！找到附近的人！')
    print('左滑一下！')
    print('右滑一下！')
    print('鎖定目標，聯繫！')
    print('一塊兒大膽約會吧！相約。。。。。')

tantan()#函數的執行者（調用者）
#這大概就是使用探探的整個流程了，每次用都是在調用tantan這個函數，就不須要各類重複代碼了！

2.函數的返回值

咱們運行一個函數，函數外部的代碼若是須要獲取函數內的執行結果，就能夠用函數內的return語句把結果返回

return 默認返回這

def tantan():
    print('打開手機！')
    print('打開軟件！')
    print('附件的人！找到附近的人！')
    print('左滑一下！')
    print('右滑一下！')
    return
    print('鎖定目標，聯繫！')
    print('一塊兒大膽約會吧！')

tantan()
print(666)
#返回值
打開手機！
打開軟件！
附件的人！找到附近的人！
左滑一下！
右滑一下！
666

咱們會發現函數在碰到return就會推出函數的運行，跳出函數的運行，return默認值爲空

def tantan():
    print('打開手機！')
    print('打開軟件！')
    print('附件的人！找到附近的人！')
    print('左滑一下！')
    print('右滑一下！')
    print('鎖定目標，聯繫！')
    print('一塊兒大膽約會吧！')
    return ('金剛芭比！')
print(tantan(),type(tantan()))

print(666)
#結果
打開手機！
打開軟件！
附件的人！找到附近的人！
左滑一下！
右滑一下！
鎖定目標，聯繫！
一塊兒大膽約會吧！
金剛芭比！ <class 'str'>
666
def tantan():
    print('打開手機！')
    print('打開軟件！')
    print('附件的人！找到附近的人！')
    print('左滑一下！')
    print('右滑一下！')
    print('鎖定目標，聯繫！')
    print('一塊兒大膽約會吧！')
    # return ('金剛芭比！')
    return [1,100]
ret = tantan()
print(ret,type(ret))
print(666)
#結果
打開手機！
打開軟件！
附件的人！找到附近的人！
左滑一下！
右滑一下！
鎖定目標，聯繫！
一塊兒大膽約會吧！
[1, 100] <class 'list'>
666

從上面代碼能夠看出來，在返回單個值得時候，值是什麼類型，返回的就是什麼類型

def tantan():
    print('打開手機！')
    print('打開軟件！')
    print('附件的人！找到附近的人！')
    print('左滑一下！')
    print('右滑一下！')
    print('鎖定目標，聯繫！')
    print('一塊兒大膽約會吧！')
    return ('金剛芭比！','洛天依','初音')

ret = tantan()
print(ret,type(ret))
print(666)
#結果
打開手機！
打開軟件！
附件的人！找到附近的人！
左滑一下！
右滑一下！
鎖定目標，聯繫！
一塊兒大膽約會吧！
('金剛芭比！', '洛天依', '初音') <class 'tuple'>
666

根據上面三段代碼咱們總結出如下幾條

  1. 函數在碰到return就會結束函數，並將值返回函數執行者
  2. return默認返回值爲空
  3. return返回單個值得時候，值是什麼類型，返回值就是什麼類型
  4. return返回多個值得時候，會將多個值用逗號分隔，返回一個元祖
  5. 函數返回值永遠只能返回一個值

3.函數的參數

def tantan(a,b): #函數定義，形參：形式參數
    print(a,b)
    print('打開手機！')
    print('打開軟件！')
    print('附件的人！找到附近的人！')
    print('左滑一下！')
    print('右滑一下！')
    print('鎖定目標，聯繫！')
    print('一塊兒大膽約會吧！')
    return ('金剛芭比！','洛天依','初音')
a = 3
b = 2
ret = tantan(a,b)#這個就是函數運行的主體   實參：這個裏面的a和b就是實際參數
print(ret,type(ret))
print(666)

3.1 實參：能夠是常量、變量、表達式、函數等，不管實參是何種類型的量，在進行函數調用時，它們都必須有肯定的值，以便把這些值傳送給形參。所以應預先用賦值，輸入等辦法使參數得到肯定值.

以一個學生註冊的函數來解釋實參

def stu_register(name,age,country,course):
    print("----註冊學生信息------")
    print("姓名:", name)
    print("age:", age)
    print("國籍:", country)
    print("課程:", course)

stu_register("王山炮",22,"CN","python_devops")
stu_register("張叫春",21,"CN","linux")
stu_register("劉老根",25,"CN","linux")

3.1.1位置參數：按照位置調用順序，一個一個的調用，傳入四個值則則會和下面的調用一一匹配，若是將傳入的值調換位置，雖不會報錯，顯示的內容並不會同樣

第一種結果
----註冊學生信息------
姓名: 王山炮
age: 22
國籍: CN
課程: python_devops
#調換姓名和年齡
----註冊學生信息------
姓名: 22
age: 王山炮
國籍: CN
課程: python_devops

3.1.2關鍵字參數：既然上面的位置參數更改位置會更改內容，那麼就有能夠變動位置的參數

stu_register(name="王山炮",age=22,course="python_devops",country="CN")
#結果
----註冊學生信息------
姓名: 王山炮
age: 22
國籍: CN
課程: python_devops
發現咱們把參數名稱變動位置，函數仍是會識別到傳入的參數，放在正確的位置

3.1.3混合參數：就是將位置參數和關鍵字參數混合的輸入

#按照關鍵字參數放在最前面
stu_register(name="王山炮",22,"python_devops","CN")
執行後報錯
SyntaxError: positional argument follows keyword argument
翻譯過來的意思就是關鍵字參數不能放在位置參數前面，應該放在位置參數後面

總結一下就是：

  • 位置參數，從左到右，一一對應
  • 關鍵字參數，一一對應，不過位置隨意
  • 混合參數，不過位置參數必定要在關鍵字參數前面

3.2 形參

形參：只有被調用時纔會分配內存單元，調用結束時，釋放分配的內存單元，形參只在函數內部有效，函數調用結束時返回主函數後不能再使用該形參

3.2.1位置參數：總體和實參的位置參數一致，默認一一對應

3.2.2默認參數：若是大量的數據都是默認值，則設定默認參數，若是須要更改在去更改

def stu_register(name,age,course,country='CN'):
    print("----註冊學生信息------")
    print("姓名:", name)
    print("age:", age)
    print("國籍:", country)
    print("課程:", course)

stu_register("王山炮",22,"python_devops",)
stu_register("張叫春",21,"linux")
stu_register("劉老根",25,"linux")
#結果
----註冊學生信息------
姓名: 王山炮
age: 22
國籍: CN
課程: python_devops
----註冊學生信息------
姓名: 張叫春
age: 21
國籍: CN
課程: linux
----註冊學生信息------
姓名: 劉老根
age: 25
國籍: CN
課程: linux

不過有個坑默認參數必須放在位置參數後，要否則也會報錯

3.2.2.1默認參數的陷阱

#默認參數指向的是一個容器型數據類型，那麼這個數據在內存中永遠是同一個

def func1(a,l=[]):
    l.append(a)
    return l
print(func1(666))  # [666]
print(func1(22))   # [666,22]
print(func1(33,[]))  # [33]
#結果
[666]
[666, 22]
[33]

3.2.3萬能參數：倆個形參接收全部實參傳遞過來的位置參數以及關鍵參數

在引入萬能參數以前，有如下需求

寫一個函數：能夠傳多個列表，把列表裏面的全部元素一個一個的添加到args裏面。在不使用萬能參數的使用前，咱們估計會一直用for循環分別添加到一個列表而後在打印

def func(*args):  # 在函數的定義時，* 表明聚合。
    print(args)  #(1,2,3,4,5,6,1,2,3)
func(*[1,2,3],*[3,4,5],*[6,7,8])#在函數執行時，*表明打散

#結果
(1, 2, 3, 3, 4, 5, 6, 7, 8)
#換其餘試一下
func(*[1,2,3],*(1,2,3),*'fdsaf') # 函數的執行（調用）時，*  打散。
#結果
(1, 2, 3, 1, 2, 3, 'f', 'd', 's', 'a', 'f')
# 動態參數 *args **kwargs
# def func(*args, **kwargs):  # 在函數的定義時，* 表明聚合。
#     print(args)
#     print(kwargs)
# func(1,2,3,4,5,'alex',name='taibai',sex='男')

# * 的魔性用法。
# 在函數的定義時，*  ** 表明聚合。
# 函數的執行（調用）時，* ** 表明打散。

# def func(**kwargs):
#     print(kwargs)
# func(**{"name":'alex'}, **{'age': 46})
def func(*args,**kwargs):
    print(args)
    print(kwargs)
func(*[1,2,3], *'abfc', **{'name':'alex'}, **{'age': 46})
#結果
(1, 2, 3, 'a', 'b', 'f', 'c')
{'name': 'alex', 'age': 46}

關於*的魔性用法在python3.5版本後對於range也開始支持，例子

a,b,*args = [i for i in range(20)]
print(a, b, args)
#結果
0 1 [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

3.2.4 形參的傳值順序

對於形參的傳值順序爲（位置參數，*args，默認參數，**kwargs）

def func(a,b,*args,sex='男',**kwargs,):
    print(a)
    print(b)
    print(args)
    print(sex)
    print(kwargs)
func(1,2,3,4,5,name='alex')
#結果
1
2
(3, 4, 5)
男
{'name': 'alex'}

若是位置參數與**kwargs變動位置就會發現，**kwargs包含了全部實參的關鍵字參數，位置參數也被包含進去了。

總結一下

  • 位置參數，從左到右，一一對應
  • 默認參數，放在位置參數後面
  • 萬能參數，能接受實參角度全部的位置參數以及關鍵字參數
  • 形參的順序，位置參數 *args 關鍵字參數 **kwargs

4.局部變量與全局變量

函數內外同一個名稱的變量，倆個是不同的，看例子

name = '1A'
def change_name():
    name ='2b'  #函數內的name變動爲2b,函數外定義的變量仍沒有變動，倆者的內存地址不同
    print('裏',name)
change_name()
print(name)#在函數內部定義的變量稱之爲局部變量
#結果
裏 2b
1A

這樣就能夠引出全局和局部變量定義

局部變量：在函數結束後，局部變量從內存中清除，倆個函數的局部變量不能互相調用

全局變量：定義在函數外部一級代碼的變量，叫全局變量，全局有效

函數內調用變量，優先爲局部變量，無則調用全局變量

5.名稱空間與做用域

5.1 名稱空間

名稱空間主要有全局名稱空間，局部名稱空間，內置名稱空間

全局名稱空間：存放的是py文件中變量與值的對應關係

局部名稱空間：臨時存放的是函數體內裏面變量與值的對應關係

內置名稱空間：內置函數與關鍵字等等。例如print(), input() break continue

5.2 做用域

全局做用域：內置名稱空間，全局名稱空間

局部做用域：局部名稱空間

加載順序：加載到內存的順序

##內置名稱空間 ----->全局名稱空間 ------>(當函數執行時)局部名稱空間

5.3 取值順序

取值順序採用就近原則

LEGB原則（局部空間---->父級空間---->全局空間---->內置名稱空間）

局部名稱空間---->全局名稱空間---->內置名稱空間

5.4 globals() 與locals()

是倆個python中的內置函數

name = 'alex'
age = 46

def func():
    name1 = 'barry'
    age1 = 18
    def inner():
        print(name1,age1)
        print(globals())  # 返回一個字典:包含全局做用域全部的內容
        print(locals()) # 返回一個字典:當前做用域的全部內容
    inner()
func()
print(globals())  # 返回一個字典:包含全局做用域全部的內容
print(locals())  # 返回一個字典:當前做用域的全部內容

6.global與nonlock的使用

6.1 global : 能夠局部聲明一個全局變量

age = 46
name = 'xxx'
def func():
    global name
    name = 'alex'
    name = 'barry'
func()
name = 'qqq'
print(name)

# 局部做用域不能對全局做用域的變量進行修改，只能引用。
count = 1
def func():
    global count
    count += 1
func()
print(count)

總結：global :

  • 能夠局部做用域聲明一個全局變量
  • 局部做用域不能對全局做用域的變量進行修改，只能引用，經過設置global能夠修改。

6.2 nonlock

# nonlocal : 只在python3x中 存在。
# 1，不能操控全局變量。
# name = 'alex'
# def func():
#     nonlocal name
#     print(name)
# func()

# 內層函數不能對外層函數的變量進行修改，只能引用。
# 在局部做用域中，對父級做用域（或者更外層做用域非全局做用域）的變量進行引用和修改，
# 而且引用的哪層，從那層及如下此變量所有發生改變。
def wrapper():
    name = 'alex'
    def inner():
        nonlocal name
        name += 'b'
        # print(name)
    print('1', name)
    inner()
    print('2', name)
wrapper()

7.嵌套函數與高階函數

7.1嵌套函數

  • 函數內部能夠再次定義函數，執行須要被調用
  • 同名字的變量會一層一層的向上查找變量
  • 注意執行順序以及變量內外

7.2 高階函數

定義：變量能夠指向函數，函數的參數能接收變量，那麼一個函數就能夠接收另外一個函數做爲參數，這種函數被稱之爲高階函數

  • 接收一個或者多個函數做爲參數
  • return返回另一個函數

 

 

要抓緊速度了，速度太慢了，加油！

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程