1 返回值
def func(arg):
# ....
return 9 # 返回值爲9 默認：return None
val = func('adsfadsf')
# 1. 讓用戶輸入一段字符串，計算字符串中有多少A字符的個數。有多少個就在文件a.txt中寫多少個“李邵奇”。
def get_char_count(data):
sum_counter = 0
for i in data:
if i == 'A':
sum_counter += 1
return sum_counter
def write_file(line):
if len(line) == 0:
return False # 函數執行過程中，一旦遇到return，則停止函數的執行。
with open('a.txt',mode='w',encoding='utf-8') as f:
f.write(line)
return True
content = input('請輸入:')
counter = get_char_count(content)
write_data = "李邵奇" * counter
status = write_file(write_data)
if status:
print('寫入成功')
else:
print('寫入失敗')
函數沒有返回值時，默認返回None。
函數內部執行過程中遇到return就終止。
def func1():
return "完成" # 函數每次執行到此，就返回;所以下面代碼永遠不執行。
for i in range(10):
print(i)
func1()
def func2():
for i in range(10):
print(i)
return "完成"
print(666)
func2() # 只打印0
return可以返回任意值
特殊情況：return返回多個值時，返回的是元組，與返回值是元組時是一樣的
def func():
return (1,2,3)
v = func()
print(v)
# 特殊:返回元組
def func():
return 5,8,"alex"
v = func()
print(v)
return的作用：a. 返回值 b.終止函數的執行
練習題
# 1. 寫函數，計算一個列表中有多少個數字，打印： 列表中有%s個數字。
# 提示：type('x') == int 判斷是否是數字。
# 方式一：
def get_list_counter1(data_list):
count = 0
for item in data_list:
if type(item) == int:
count += 1
msg = "列表中有%s個數字" %(count,)
print(msg)
get_list_counter1([1,22,3,'alex',8])
# 方式二：
def get_list_counter2(data_list):
count = 0
for item in data_list:
if type(item) == int:
count += 1
return count
v = get_list_counter1([1,22,3,'alex',8])
msg = "列表中有%s個數字" %(v,)
print(msg)
# 2. 寫函數，計算一個列表中偶數索引位置的數據構造成另外一個列表，並返回。
# 方式一：
def get_data_list1(arg):
v = arg[::2]
return v
data = get_data_list1([11,22,33,44,55,66])
# 方式二：
def get_data_list2(arg):
v = []
for i in range(0,len(arg)):
if i % 2 == 0:
v.append(arg[i])
return v
data = get_data_list2([11,22,33,44,55,66])
# 3. 讀取文件，將文件的內容構造成指定格式的數據，並返回。
"""
a.log文件
alex|123|18
eric|uiuf|19
...
目標結構：
a. ["alex|123|18","eric|uiuf|19"] 並返回。
b. [['alex','123','18'],['eric','uiuf','19']]
c. [
{'name':'alex','pwd':'123','age':'18'},
{'name':'eric','pwd':'uiuf','age':'19'},
]
"""
with open('a.log.txt',mode = 'r',encoding = 'utf-8') as f:
data = f.read()
print(data)
def get_file(a):
date1 = []
for i in a.split('\n'):
date1.append(i)
return date1
v1 = get_file(data)
print(v1)
def get_file1(b):
date2 = []
d = []
for i1 in b.split('\n'):
i1 = i1.split('|')
d.append(i1)
date2 += d
return date2
v2 = get_file1(data)
print(v2)
def get_file2(c):
date3 = []
e = {}
for i2 in c.split('\n'):
i2 = i2.split('|')
e['name'] = i2[0]
e['pwd'] = i2[1]
e['age'] = i2[2]
date3.append(e)
return date3
v3 = get_file2(data)
print(v3)
數據類型中的方法到底有沒有返回值：
無返回值
v = [1,2,3,4]
v.append(55) # 無返回值時不用寫return了
list : append / insert / remove / clear / extend / reverse
dict : update
set : add / discard / update
僅有返回值
v = 'ddff2dd554cvc'
result = '-'.join(v)
return result
v = {'k1':12,'k2':'ased'}
result = v.get('k2')
result = v.keys()
str : upper / lower / replace / isdecimal / strip / split / startswith / endswith / encode / format / join
list : find / index
dict : keys / values / items / get
set : intersection / union / difference / symmitric_difference
有返回值 + 修改數據
pop
v = [11,22,33,44]
result = v.pop(22)
常用需要記住的
索引、切片都有返回值
str : split 返回列表
strip 返回字符串
replace 返回字符串
join 返回字符串
list : append 無
insert 無
remove 無
pop 返回要刪除的數據
find 返回索引的位置
index 返回索引的位置
dict : keys 獲取所有的鍵
values 獲取所有的值
items 獲取所有的鍵值對
get 索引存在：返回值 ，不存在：返回None
2 作用域
在python文件中：
py文件：全局作用域
函數：局部作用域
a = 1
def s1():
x1 = 666
print(x1)
print(a)
print(b)
b = 2
print(a)
s1()
a = 88888
def s2():
print(a,b)
s1()
s2()
每個作用域中的數據只有作用域自己可以調用，如果作用域中調用的數據沒有，可以調用全局作用域的
全局作用域只能調用全局的
在全局作用域中的函數可以互相調用(調用已經存在的)，但不可以直接調用作用域中的作用域
總結：
1.一個函數就是一個作用域
2.作用域中查找數據規則：優先在自己的作用域找數據，自己沒有就去“父級”-->“父級”-->直到全局，全局沒有就報錯。 (作用域的嵌套)
注意：父級作用域中的值到底是多少?
x = 10
def func():
x = 9
print(x)
func()
小練習
# 示例一
x = 10
def func():
x = 9
print(x)
def x1():
x = 999
print(x)
func()
# 示例二
x = 10
def func():
x = 9
print(x)
def x1():
x = 999
print(x)
x1()
func()
# 示例三
x = 10
def func():
x = 9
print(x)
def x1():
x = 999
print(x)
print(x)
x1()
func()
# 示例四
x = 10
def func():
x = 8
print(x)
def x1():
x = 999
print(x)
x1()
print(x)
func()
# 示例五
x = 10
def func():
x = 8
print(x)
def x1():
print(x)
x1()
print(x)
func()
# 示例六
x = 10
def func():
x = 8
print(x)
def x1():
print(x)
x = 9
x1()
x = 10
print(x)
func()
# 示例七
x = 10
def func():
x = 8
print(x)
def x1():
print(x)
x1()
x = 9
x1()
x = 10
print(x)
func()
3.子作用域中只能只能找到父級中的值，默認無法重新爲父級的變量進行賦值。
不能進行賦值，只能對可變類型進行內部修改
# #####################
name = 'oldboy'
def func():
name = 'alex' # 在自己作用域再創建一個這樣的值。
print(name)
func()
print(name)
# #####################
name = [1,2,43]
def func():
name.append(999)
print(name)
func()
print(name)
如果非要對全局的變量進行賦值需要加global(強制賦值)
#示例一
name = "老男孩“
def func():
global name
name = 'alex'
func()
print name
# 示例二
name = ["老男孩",'alex']
def func():
global name
name = '我'
func()
print(name)
# 示例三
name = "老男孩"
def func():
name = 'alex'
def inner():
global name
name = 999
inner()
print(name)
func()
print(name)
對父級的變量賦值用nonlocal，先找到父級的變量再進行賦值 (強制賦值)
name = "老男孩"
def func():
name = 'alex'
def inner():
nonlocal name # 找到上一級的name
name = 999
inner()
print(name)
func()
print(name)
補充：全局變量必須全部要大寫
USER_LIST = [11,22,3]
def func():
name = 'asdf'
USER_LIST.append(12)
USER_LIST.append(name)
func()
print(USER_LIST)
3 函數小高級
函數名可以當作變量來使用
def func():
print(123)
v1 = func # func代表函數的地址
func()
v1() # v1、func的函數地址相同，執行調用的函數也相同
def func():
print(123)
func_list = [func, func, func]
# func_list[0]() a
# func_list[1]() b
# func_list[2]() c
for item in func_list: # a/b/c的簡化形式
v = item()
print(v)
def func():
print(123)
def bar():
print(666)
info = {'k1': func, 'k2': bar}
info['k1']() # 函數也可以作爲字典的值(也可以做爲鍵，但是沒有意義)
info['k2']()
注意：函數是不可變的，可以做集合的元素，也可以作爲字典的鍵 (但是做鍵沒有太大意義)。
集合中可以放多個重複的函數，但只執行一次。(因爲集合的特性：不可重複的)
混淆你
def func():
return 123
func_list1 = [func,func,func]
func_list2 = [func(),func(),func()]
print(func_list1) # 打印的是func的函數地址
print(func_list2) # 打印的是func執行完返回的值
info = {
'k1':func, # 函數的地址
'k2':func(), # 函數執行完返回的值
}
print(info)
函數也可以當作參數來進行傳遞
def func(arg):
print(arg)
func(1)
func([1,2,3,4])
def show():
return 999
func(show) # 執行函數func，參數爲show,show沒有+()，表示show沒有執行只是代表該函數的地址。
def func(arg):
v1 = arg()
print(v1)
def show():
print(666)
func(show)
def func(arg):
v1 = arg()
print(v1)
def show():
print(666)
result = func(show)
print(result)
多個函數的調用
def func():
print('花費查詢')
def bar():
print('語音溝通')
def base():
print('xxx')
def show():
print('xxx')
def test():
print('xxx')
info = {
'f1': func,
'f2': bar,
'f3':base,
'f4':show,
'f5':test
}
choice = input('請選擇要選擇功能：')
function_name = info.get(choice)
if function_name:
function_name()
else:
print('輸入錯誤')
總結：函數當作一個變量：參數傳值 / 當作元素嵌套到字典、列表中
4 函數中高級
4.1 函數可以做返回值
# 示例一
def func():
print(123)
def bar():
return func
v = bar()
v()
# 示例二
name = 'oldboy'
def func():
print(name)
def bar():
return func
v = bar()
v()
# 示例三
def bar():
def inner():
print(123)
return inner
v = bar()
v()
# 示例四鄭州婦科醫院：http://mobile.tjyy120.com/
name = 'oldboy'
def bar():
name = 'alex'
def inner():
print(name)
return inner
v = bar()
v()
# 示例五
name = 'oldboy'
def bar(name):
def inner():
print(name)
return inner
v1 = bar('alex') # { name=alex, inner } # 閉包，爲函數創建一塊區域(內部變量供自己使用，存儲的代碼)，爲他以後執行提供數據。
v2 = bar('eric') # { name=eric, inner }
v1()
v2()
# 示例六
name = 'alex'
def base():
print(name)
def func():
name = 'eric'
base()
func() # {name=eric, }
# 示例七
name = 'alex'
def func():
name = 'eric'
def base():
print(name)
base()
func()
# 示例八
name = 'alex'
def func():
name = 'eric'
def base():
print(name)
return base
base = func()
base()
注意：函數在何時被誰創建?
函數是由誰創建的，執行函數就從哪裏開始找
# 練習題一
info = []
def func():
print(item)
for item in range(10):
info.append(func)
info[0]()
# 練習題二
info = []
def func(i):
def inner():
print(i)
return inner
for item in range(10):
info.append(func(item))
info[0]()
info[1]()
info[4]()
4.2 閉包
def func(name):
def inner():
print(name)
return inner
v1 = func('alex')
v1()
v2 = func('eric')
v2()
返回值——分析函數執行的內存。(閉包是內存其中的一種)
# 並不是閉包
def func(name)
def inner():
return 123
return inner
# 是閉包需要滿足兩個條件：1.封裝值 2.內層函數需要使用
def func(name)
def inner():
print(name)
return 123
return inner
4.3 高階函數
把函數當作參數傳遞
把函數當作返回值
注意：對函數進行賦值
4.4 小總結
1.函數執行流程的分析(函數到底是由誰創建的?)
2.閉包概念：爲函數創建一塊區域併爲其維護自己的數據以後執行時方便調用。(應用場景：裝飾器 / SQLAlchemy源碼)