一、什麽是函數

　　函數是組織好的，可重復使用的，用來實現單一或相關功能的代碼段

　　函數能提高應用的模塊兒性和代碼的重復利用率。python提供了很多內置函數，比如print(),len()等等。我們也可以自己創建函數，這種函數叫做用戶自定義函數。

二、函數的定義和調用

　　讓我們來定義一個能計算字符串長度的，類似於len()的函數

# s = "我的團長我的團"   # 1
# def my_len(): # 定義/聲明一個函數 函數名的定義和變量名的規則一樣 #3

#     i = 0  #4
#     for k in s: #5
#         i += 1
#     print(i)
# my_len() # 調用函數  # 
 
2
# my_len()
# my_len()
# my_len()
# length = my_len()
# print(length)   # print: None  只是執行函數，並沒有把結果返回給my_len

定義：def關鍵字開頭，空格之後+函數名稱和（），最後加" :" 冒號。

　　 def是固定的寫法，他就是定義函數的關鍵字不能換其他關鍵字或者字符串

空格是為了將關鍵字def 和函數名分開，必須空，但是一般人只空一格。

函數名：函數名的命名規則和變量名的一樣，由數字，字母下劃線組成且不能以數字開頭。函數名的定義並沒有嚴格規定，但默認還是要盡量簡短，並能表達函數功能。

括號：括號是必不可少的部分裏面可以存放參數

註釋：每一個函數都應該對其功能和參數進行相應的說明，應該寫在函數下面的第一行，以增強代碼的可讀性。

調用： 很簡單就是 函數名（） 務必加上括號

三、函數的返回值

return關鍵字的作用

　　return是一個關鍵字，在pycharm裏，會自動變色。

　　很顯然return是“返回”的意思，我們管寫在return後面的值叫做“返回值”。

返回值有如下三種情況：

　　1.沒有返回值 默認返回None

#  不寫 return
#  只寫return  結束一個函數的繼續
#  return None  和不寫return是一樣的 都返回 None  最不常用
# def func
 
=():
#     l1 = [‘狗哥‘, ‘狗智‘]
#     for i in l1:
#         print(i)
#         if i == ‘狗哥‘:
#             return  # 找到狗哥之後後面的就不循環了
# r1 = func()
# print(r1)

　　2.返回一個值 可以是數字、列表、字典等

# 1.可以返回任何數據類型 2. 只要返回了就可以接收到
# 3.如果一個程序中有多個return的話只執行第一個
# def func():
#     return [1, 2, 3]
# print(func())

　　3.返回多個值

# def func2():
#     return 1, 2, 3  # 相當於返回了一個元組 return（1,2,3） python特性
# r1, r2, r3 = func2()
# print(r1, r2, r3)  #  1 2 3

# r1, r2 = func2()
# print(r1, r2) # 會報錯 兩個變量不能接收三個返回值 不能平均分配

# r1 = func2()
# print(r1)   #可以用一個變量接收，返回一個元組 --> (1, 2, 3) 不可變類型
# 多個返回值用多個變量接收，有多少返回值就用多少變量接收

四、函數的參數

形參與實參：

我們調用函數的時候就是傳參的過程，括號裏的內容就是實際參數，是實際要交給函數的內容，簡稱實參。

當以函數的時候就是接受函數的過程，括號裏的內容就是形式參數，在定義函數的時候他只是一個形式，表示這裏有一個參數，簡稱形參。

# s = "我的團長我的團"
# l1 = [1, ‘barry‘, ‘大鐵錘‘]
# def my_len(s):  # 接收參數 形式參數 形參
#     i = 0
#     for k in s:
#         i += 1
#     return i
# r1 = my_len(s) # 傳參  傳遞參數  實際參數 實參
# r2 = my_len([1,2,3])
# print(r1, r2)  # -->7 3

　站在實參的角度上　

1.按照位置傳參
　　2.按照關鍵字傳參
　　3.可以混著用，但是必須先按照位置傳參再按照關鍵字傳參
不能給同一個變量傳多個值

# def my_sum(a, b):
#     print(a, b)
#     res = a + b # result
#     return res
# ret = my_sum(1, 2)  # 按照位置傳 1-->a  2-->b
# ret = my_sum(b=2, a=1) # 按照關鍵字傳參
# ret = my_sum(1, b=2) # 位置傳參關鍵字傳參混著用
# print(ret)

站在形參的角度上;

　　位置參數：必須傳，且有幾個參數就傳幾個值
　　默認參數：可以不傳，如果不傳就用默認參數，如果傳了就用傳的

def classmate(name, sex=‘男‘):
    print(‘%s : %s‘ %(name,sex))
classmate(‘二爺‘)
classmate(‘小五‘)
classmate(‘騷鑫‘)
classmate(‘馬哥‘, ‘女‘)
classmate(‘coco‘, ‘女‘)

調用 函數時候：

　　按照位置傳：直接寫參數的值
　　按照關鍵字傳: 關鍵字 = 值

定義參數的時候：

　　位置參數：直接定義參數
　　默認參數：默認參數：參數名=默認的值
　　動態參數 可以接收任意多個參數
　　參數名之前加* 習慣用args /參數的意思
　　參數名之前加** 習慣用kwargs
　　順序：先定義位置參數，*args，默認參數,**kwargs

# 定義的時候使用按位置傳參，傳參的時候既可以用位置傳參，又可以用關鍵字傳參
def classmate(name, sex):
    print(‘%s : %s‘%(name, sex))
classmate(‘狗哥‘, ‘男‘)
classmate(sex=‘男‘, name=‘雞哥‘)

def classmate(name, sex=‘男‘):
    print(‘%s : %s‘%(name, sex))
classmate(‘狗哥‘)
classmate(‘雞哥‘, sex=‘女‘)
# 定義參數類型和傳遞參數類型之間沒有必然聯系

動態參數　　　　

動態參數 可以接收任意多個參數 參數名之前加* 習慣用args /參數的意思

# def sum(*args): #args僅僅是參數名
#     n = 0
#     for i in args:
#         n += i
#     return n
# print(sum(1, 2))
# print(sum(1, 2, 3))
# print(sum(1, 2, 3, 4))

# 接收動態參數
# def func(*args): #只能接收到按位置傳遞的參數，不能接收關鍵字傳參
#     print(args)
# func(1, 2, [‘jack‘, 5,], {‘name‘:‘barry‘}) #-->(1, 2, [‘jack‘, 5], {‘name‘: ‘barry‘})

# def func(*args, l1=[]):
#     print(args, l1)
# func(1, 2, [‘rose‘, ‘marry‘])
# func(3, 4,‘coco‘, l1=[‘jack ma ‘, ‘lucy‘])

# 按照關鍵字傳多個參數
# def func(**kwargs):
#     print(kwargs)
# func(a=1, b=2, c=3)
# func(a=1, b=2)
# func(a=1)
# func(a=1, b=2, c=3)
# 動態參數有兩種：可接收任意多個參數
    #*args : 接受的是按位置傳參的值，組成一個元組
    #**kwargs : 接收的是按照關鍵字傳參的值，組成一個字典
    #args必須在kwargs之前
# 雙劍合璧 天下無敵

# def func(*args, **kwargs):
#     print(args, kwargs)
#  func(1, 2, a=3, b=‘sb‘) #-->(1, 2) {‘a‘: 3, ‘b‘: ‘sb‘}
                            # 只要在傳參的時候符合先按位置再按關鍵字就OK

# def func(a, b,*args, default=1, **kwargs): #這幾種參數少了誰都可以，但順序必須牢記
#    print(a, b, args, default, kwargs)
# func(1, 2, default=2, a=3, b=‘sb‘)

# 動態參數的另一種傳輸方式
# def func(*args): #站在形參的角度，給變量加上* 就是組合所有傳來的值
#     print(args)
# func(1,2, 3, 4)
# l1 = [1, 2, 3, 4]
# func(*l1) #站在實參的角度上，給序列加上* ，就是將序列按順序打散

# def func(**kwargs):
# #     print(kwargs)
# # func(a=1, b=2)
# # dic1 = {‘a‘: 1, ‘b‘: 2}
# # func(**dic1)

五、函數的註釋

def func():
    ‘‘‘
    這個函數實現了什麽功能
    參數1：
    參數2：
    。
    。
    。
    :return:  是字符串或列表的長度
    ‘‘‘
    pass

　　作業：

# 1. 寫函數，檢查獲取傳入列表或元組對應的所有奇數位索引對應的元素，並將其作為新列表返回給調用者
# def func(l1):
#     return l1[1::2] # 切片
# print(func([1, 2, 3, 4, 5, 6]))
# 2.寫函數，判斷用戶輸入的值（字符串，列表，元組）長度是否大於5
# def func(x):
#     return len(x) > 5
#
# print(func(‘everything i never told you!‘)) #返回的是布爾值
#
# if func(‘sad‘):
#     print(‘確實大於五‘)
# else:
#     print(‘小於五‘)
# 3.寫函數，檢查傳入列表的長度，如果>2,那麽僅保留前兩個長度的內容，並將新內容返回給調用者
# def func(l1):
#     if len(l1) > 2: # 這一步完全可以省略
#         return l1[:2]
# print(func([1, 2, 3, 4])) #-->[1, 2]

# 4. 寫函數 計算傳入字符串中，數字，字母，空格，以及其他 的個數，並返回結果
# def func(s):
#     dic = {‘num‘: 0, ‘alpha‘: 0, ‘space‘: 0, ‘other‘: 0 }
#     for i in s:
#         if i.isdigit():
#             dic[‘num‘] += 1
#         elif i.isalpha():
#             dic[‘alpha‘] += 1
#         elif i.isspace():
#             dic[‘space‘] += 1
#         else:
#             dic[‘other‘] += 1
#     return dic
# print(func(s = ‘+*da4=@5a s c d‘))

# 5. 寫函數，檢查用戶輸入的對象（字符串，列表，元組）的每一個元素是否含有空內容，並返回結果


# def func(x):
#     if type(x) is str and x:
#         for i in x:
#             if i == ‘ ‘:
#                 return True
#     elif x and type(x) is list or type(x) is tuple:
#         for i in x:
#             if not i:
#                 return True
#     elif not x:
#         return True
# print(func(‘dasd asd‘))
# print(func([1, 2, []]))
# print(func([]))
# print(func((1, 2, ())))

# 6.寫函數，檢查傳入字典的每一個value的長度，如果>2，那麽僅保留兩個長度的內容，並將新內容返回給調用者
# dic = {‘k1‘: ‘v1,v2,v3‘, ‘k2‘: 1246, ‘k3‘: [1, 2, 3]}
# ps 字典中的value只能是字符串或列表
# def func(dic):
# #     for k in dic:
# #         if len(dic[k]) > 2:
# #             dic[k] = dic[k][:2]
# #     return dic
# # dic = {‘k1‘: ‘v1,v2,v3‘, ‘k2‘: ‘1333324‘, ‘k3‘: [1, 2, 3]}
# # print(func(dic))

# 7. 寫函數，接收兩個數字參數，返回比較大的那個數字
# def func(a, b):
#     if a > b:
#         max = a
#     else:
#         max = b
#     return max
#
# print(func(2, 1))
# 三元運算
# 變量 = 條件返回true的結果 if 條件 else 條件返回false的結果
# 必須要有結果  必須要有 if 和 else   只能是簡單的情況
# def func(a, b):
#     max = a if a > b else b
#     return max  # 可以直接 return a if a > b
# print(func(10, 5))

# 8. 寫函數，用戶傳入修改的文件名兒，與要修改的內容
# 執行函數完成整個文件的批量修改操作
# def func(filename, old, new):
#     with open(filename, encoding=‘utf-8‘) as f1, #             open(‘%s.bak‘ % filename, ‘w‘, encoding=‘utf-8‘) as f2:
#         for line in f1:
#             if old in line:
#                 line = line.replace(old, new)
#             f2.write(line)
#     import os
#     os.remove(filename)
#     os.rename(‘%s.bak‘ % filename, filename)
#     return ‘修改完畢‘
#
# print(func(‘H:\python\大學生兼職.txt‘, ‘快遞小哥‘, ‘家政主婦‘))

# def func(l1=[]):
#     l1.append(1)
#     print(l1)
# func() # [1]
# func([]) #[1]
# func([‘a‘]) #[‘a‘,1]
# func() #[1,1]
# func() #[1,1,1]
# 如果默認參數是一個可變數據類型，
# 那麽每次調用函數的時候，
# 如果不傳值就公用這個數據類型的資源

# def func(k, dic={}):
#     dic[k] = ‘v‘
#     print(dic)
# func(1) # {1 :‘v‘}
# func(2) #{1 :‘v‘,2 :‘v‘}
# func(3) #{1 :‘v‘,2 :‘v‘,3 :‘v‘}
# func(4) #{1 :‘v‘,2 :‘v‘,3 :‘v‘,4: ‘v‘}

python 初始函數