python函數

模塊化編程

定義：把程序進行封裝

函數封裝
面向對象
面向文件

函數：封裝完不會執(zhí)行，調用來使用。

函數是什么：一個具有特定功能的代碼塊

函數的作用：封裝代碼，提高代碼的重用性秸谢；提高開發(fā)效率凛澎；降低后期維護成本。

函數的定義：
def func([參數列表])：
      當前函數的具體功能代碼
 當前函數的具體功能代碼
 估蹄。塑煎。。    
函數的調用：
func( )

函數的特征：

1元媚，先定義再調用

2轧叽，不調用不執(zhí)行

3，調用次數不限

4刊棕，命名遵守命名規(guī)范：字母炭晒，數字，下劃線甥角；不能以數字開頭网严；嚴格區(qū)分大小寫；不使用關鍵字嗤无，中文震束；有意義。

5当犯，函數名不能重復垢村，否則會覆蓋

函數的參數：

1)實參：普通實參在前，關鍵字參數在后

2)形參：關鍵字收集參數一定在最后嚎卫；收集參數推薦在普通參數的后面

3)推薦順序：普通形參嘉栓，收集參數，關鍵字收集參數

定義函數時：可以在參數列表的位置定義行參
如果函數有行參拓诸，在調用時必須傳遞參數（實參）

實參傳遞給行參的過程侵佃，本質上就是變量的賦值操作

a普通參數：

#定義帶有參數的函數
#在小括號內可以定義行參（形式上的參數）
def func1(w):
        print(f'hello{w}')
  
#調用得帶參數，不然報錯
func1('kris')#調用帶有行參的函數時奠支，需要傳遞參數（實參）
func1()#TyprError
func1(w='kris')#調用時可以指定

#函數里帶有多個參數的
def func2(x,y):
    print(f'hello: {x},hi: {y}')

        #調用普通函數
#方法一：定義了幾個參數馋辈，調用時必須按順序進行參數傳遞
func2('kris','sehun')#本質上x='kris',y='sehun'

#方法二：可以把普通參數按照關鍵字參數進行傳遞
func2(y='sehun',x='kris')

b默認參數：含有默認值的

c收集參數：在形參的位置加一個默認星號* args

d命名關鍵字參數：定義在在*args后面，調用的時候必須以形參的名字調用

def func3(a,b,c=3,*args,name):
     #name就是命名關鍵字參數倍谜，調用的時候必須給定name的值
    print(a,b,c)#a,b形參迈螟，c默認參數，
    print(*args)#收集參數
    print(name)#命名關鍵字參數
    
func3(1,2,4,5,6,7,8,9,name='sehun')
#1 2 4
#(5,6,7,8,9)
#sehun

func3(1,2,name='sehun') 
#1 2 3 c默認參數尔崔，沒有就默認為3
#sehun

func3(1,2,5井联，name='sehun') 
#1 2 5 c默認參數，有就默認為5
#sehun

e關鍵字參數收集：**kwargs

# Tips:注意行參聲明的位置：

#func4(普通參數您旁，默認參數烙常，收集參數，關鍵字參數，關鍵字收集參數)——極少出現

#一般情況：普通參數蚕脏，收集參數侦副，關鍵字收集參數

def func4(a,b,c=3,*args,name,age,**kwargs):
  print(a,b,c)
  print(args)#普通收集參數，把多余參數收集成——元祖
  print(name,age)
  print(kwargs)#關鍵字收集參數驼鞭，把多余關鍵字收集成——字典
 
func4(1,2,5,112,114,name='sehun',age=26,gender='男',height=184)
#1 2 5
#(112, 114)
#sehun 26
#{'gender': '男', 'height': 184}

函數返回值：按照需要返回一些內容秦驯，可返或可不返
使用return關鍵字來指定返回數據

可以返回任意類型的數據

會把數據返回到調用處，可以使用變量結束或其他處理
return——意味著函數的結束挣棕，return之后的代碼不再執(zhí)行
#沒有返回值的函數 or 沒有指定返回內容译隘，默認返回None
def func5(a,b):
  print(f'{a} lalla ')

func5('kris','sehun')

#需要在函數中指定返回內容洛心，可以在函數體內用關鍵字return返回任意內容
def func5(a,b):
  res = f'{a} lalla 固耘'
  return res

func5('kris','sehun')#無結果：定義一個字符串
#改進： 
print(func5('kris','sehun'))#這里調用，這里輸出

函數的分類：

1词身，執(zhí)行過程函數：函數體內完成一定的功能即可厅目，沒有返回值。

2法严，具有返回值的函數：函數體內完成一定的功能损敷，并且返回一個結果到函數調用處。

#需求1:定義一個函數深啤，完成兩個數相加拗馒，并把結果輸出
def jia(n1,n2):
  res = n1 + n2
  print(res)
 
jia(3,5)

#需求2:定義一個函數，完成兩個結果的運算溯街，并把結果返回
def jia(n1,n2):
  re = n1 + n2
  return re #把運算的結果返回
r = jia(n1,n2)
print(r)

變量的作用域：當前起作用诱桂，可用的范圍區(qū)域。

即變量的有效范圍

分：

全局變量：1）在函數內使用global定義的苫幢，函數內外都可以使用

? 2）在函數外定義的變量访诱，在函數內使用global關鍵字進行聲明

globals()—— 在任何位置都獲取全局數據

局部變量：1）在函數內定義垫挨，在函數外不可以使用韩肝；

locals()—— 獲取當前作用域的數據

函數外定義的變量，函數可以訪問九榔，但不能更改
num = 10

def func6():
  print(num)#10# 在函數內部可以直接獲取函數外部的變量
func6()
num = 10
#可獲取但不可改變
def func6():
  num += 20#但是不可以更改或者使用函數外部的變量
  print(num)#報錯# 在函數內部可以直接獲取函數外部的變量
func6()
def func6():
  a = 20#函數內定義的變量
  a += 20
func6()

print(a)#報錯#在函數外不可以使用
def func6():
  a = 20#函數內定義的變量
  a += 20
  print(a)#在函數內可以使用

func6()#40
數據類型的分類：

可變數據類型：在函數外定義的變量哀峻，在函數內可以使用

? list ，dict

不可變數據類型：在函數外定義的變量哲泊，在函數內只能訪問剩蟀，不能使用其他操作

__name__:__main__
  
  #__name__表示當前腳本的名字；如果當前腳本作為主程序切威，那么值是__main__育特；如果當作一個模塊，在另外一個腳本中引用去使用
  #__main__表示指定當前腳本運行

__doc__#表示當前腳本的文檔說明'''注釋'''

不光變量有作用域，函數一樣也有相同的作用域

def outer():
  '''
  文檔說明
  '''
  print('outer function')
  def inner():#局部函數缰冤，在函數外無法使用
    print('inner function')
  
outer()#outer function
inner()#報錯

print(outer.__doc__)

改進：

def outer():
  print('outer function')
  def inner():#局部函數犬缨，在函數外無法使用
    print('inner function')
  
  inner()#inner function

outer()#outer function

區(qū)分：

def outer():
  print('outer function')
  abc = 123#外部普通全局變量
  def inner():#局部函數缔俄，在函數外無法使用
    print('inner function')
    abc += 1#內部改變
    print(abc)#報錯
  
  inner()#inner function

outer()#outer function

def outer():
  print('outer function')
  abc = 123#外部普通全局變量
  def inner():#局部函數吠架，在函數外無法使用
    print('inner function')
    
    print(abc)#123
  
  inner()#inner function

outer()#outer function

nonlocal關鍵字——用于在內函數中使用外層函數的變量

def outer():
print('outer function')
abc = 123#外部普通全局變量

def inner():#局部函數，在函數外無法使用
 print('inner function')
 
 nonlocal abc#可以引用上一層函數中定義的局部變量钓丰，但依然不能提升為全局變量
 abc += 1#內部改變
 print(abc)#124

inner()#inner function

outer()#outer function

函數的封裝

#定義函數迷郑，打印九九乘法表
def jiujiu(n=0):
    '''
    當前函數的功能就是 打印 九九乘法表
    n=0; 控制 正向輸出 和 反向輸出 九九乘法表 枝恋，0為正向 默認，1為反向
    '''
    if n == 0:
        rs = range(1,10)
    else:
        rs = range(9,0,-1)
    for x in rs:
        for y in range(1,x+1):
            print(f'{x}x{y}={x*y}',end=" ")
        print()

jiujiu(1)

# 封裝打印矩形的函數 juxing(x=10,y=10)
def juxing(n,x,y):
    for i in range(x):
        for j in range(y):
            if n ==1:
                if i == 0 or i == x-1 or j == 0 or j == y-1:
                    print('*',end = ' ')
                else:
                    print(' ',end = ' ')
            else:
                print('*',end = ' ')
        print()

一：遞歸函數

1.定義一個函數嗡害，在函數內自己調用自己

例題：斐波那契數列：1焚碌，1，2就漾，3呐能，5，8抑堡，21摆出，，首妖，偎漫，

? 實現一個階乘：1 * 2 * 3 * 4* 5

#實現一個遞歸：3，2有缆，1象踊，0
def func1(n):
  print(n)
  #檢測當前的值是否到0
  if n > 0:
    func1(n-1)#調用自己
   
func1(3)

2.遞歸函數內必須要有結束，不然就會一直調用下去棚壁，直到調用的層數越來越多杯矩，棧溢出

3.遞歸函數是一層一層的進入，再一層一層的返回

#實現斐波那契數列
def func1(n):
    if n == 1 or n == 2:
         return 1
    else:
         #print(n-1,n-2)
         return func1(n-1) + func1(n-2)
        
        
#實現階乘

def func2(n):
    if n == 1:
        return 1
    else:
        return n * func2(n-1)

4.遞歸函數的效率不高袖外，盡量不要用

5.一個函數如果調用后沒有結束史隆，那么在棧空間就一直存在曼验，知道這個函數運算結束在銷毀泌射。

二：回調函數—把一個函數作為行參

定義：在一個函數中要求傳遞的參數是一個函數作為參數，并且在函數中使用了傳遞進來的函數

#帶有回調參數的函數
def func3(f):
    #print(f,type(f))
    #在函數中調用了傳遞進來的函數
    f()
    
#回調函數
def func4():
    print('exo')

    
func3(func4)#exo

def func5(x,y,f):
  '''
  當這個函數接受兩個數值鬓照，并把兩個數值傳遞給第三個參數進行計算
  x,y,int
  f   function
  return 
  '''

  print(f(x,y))
  
 def func5(x,y,pow):
  print(pow(x,y))
  
  func5(2,3,pow)
  
#都要求傳遞一個函數進去
map(),sorted(),filter(),reduce()

三：閉包函數—在一個函數中返回一個函數

定義：在一個函數內返回一個內函數熔酷，并且這個返回的內函數還使用了外函數中的局部變量

def person():
    money = 0#在外函數中定義了局部變量，并且在內部函數中使用了這個局部變量
    #工作：在外函數中定義的內函數
    def work():
        nonlocal money#在內函數中使用了外函數的臨時變量
        money += 100
        print(money)
    #加班
    def overtime():
        nonlocal money
        money += 200
    #購物
    def buy():
        nonlocal money
        money -= 50
        
    #在外函數中返回內函數豺裆，這個內函數就是閉包函數
    return work
res = person()#接收一下,res = work
res()#res() == work()


#檢測一個函數是否為閉包函數
print(res.__closure__)#(<cell at 0x11083bf48: int object at 0x10b94b790>,)

#此時不能在全局中對money 這個局部變量進行任何操作

閉包的作用：

保護了函數中的變量不受外部的影響拒秘，但是又能夠不影響使用

閉包的特點：

1，在外函數中定義了局部變量，并且在內部函數中使用了這個局部變量

2躺酒，在外函數中返回了內函數咙轩，返回的內函數就是閉包函數

3，主要在于保護了外函數中的局部變量阴颖，既可以被使用活喊，又不會被破壞

如何檢測一個函數是否為閉包函數

函數名.closure 如果是閉包函數返回 cell

四：匿名函數 lambda 表達式：稱為一行代碼函數

定義：可以不使用def定義，并且這個函數也沒有名字

? 在python中可以使用lambda表達式來定義匿名函數

Tips：

lambda僅僅是一個表達式量愧，即一行代碼钾菊；不是一個代碼塊；

lambda表達式也有行參偎肃，并且不能訪問除了自己行參之外的任何數據包括全局變量

#lambda [參數列表]:返回值
res = lambda x,y:x+y#拿一個變量接受
print(res(2,3))

lambda是一個表達式煞烫，因為不能寫太復雜的邏輯，功能相對單一

lambda可以使用分支結構

#帶有分支結構
#lambda參數列表：真區(qū)間 if 表達式判斷 else 假區(qū)間
res = lambda sex:'man' if sex == '男' else 'woman'
print(res('女'))

五：迭代器

特點

是python中最具特色的功能之一累颂；

是訪問集合元素的一種方式滞详；

是一個可以記住訪問遍歷的位置的對象；

從集合的第一個元素開始訪問紊馏，知道集合中的所有元素被訪問完畢料饥；

只能從前往后一個一個遍歷，不能后退朱监；

能被next()函數調用岸啡，并不斷返回下一個值的對象稱為迭代器（iterator迭代對象）

# 定義一個列表，是一個可迭代的對象
f4 = ['趙','劉','小','海']
#提取數據出來
#可迭代對象：可以用for循環(huán)
# 可以使用for循環(huán)來遍歷數據
for i in f4:
    print(i)
# 可以把可迭代對象轉為迭代器使用
res = iter(f4)
print(res,type(res)) # <list_iterator object at 0x109063810> <class 'list_iterator'>

iter()

功能：把可迭代的對象赫编，轉為一個迭代器對象

參數：可迭代的對象（str巡蘸，list，tuple擂送，dict悦荒，set，range嘹吨。搬味。。）

return：迭代器對象

Tips ：迭代器一定是一個可以迭代的對象躺苦，但是可迭代對象不一定是迭代器

迭代器取值的方案

next() 調用一次獲取一次身腻，直到數據被取完

list() 使用list函數直接取出迭代器中的所有數據

使用for循環(huán)遍歷迭代器的數據

迭代器取值的特點：取出一個少一個产还，直到都取完匹厘，最后再獲取就會報錯

#1.使用next()函數去調用迭代器對象
print(next(res))
#print(next(res))


#2.使用list取值
r = list(res)
print(r)

#3.使用for循環(huán)
for i in res:
    print(i)

# print(next(res))  #當調用次數用完，超出可迭代的范圍脐区，報錯愈诚；StopIteration

檢測迭代器和可迭代對象的方法

from collections.abc import Iterator,Iterable

str1 = '123456'
res = iter(str1)

# 1 type() 函數返回當前數據的類型，
# 2 isinstance() 檢測一個數據是不是一個指定的類型
r1 = isinstance(str1,Iterable) # True 可迭代對象
r2 = isinstance(str1,Iterator) # False 不是一個迭代器
r3 = isinstance(res,Iterable) # True 可迭代對象
r4 = isinstance(res,Iterator) # True 是一個迭代器
print(r1,r2)
print(r3,r4)
# 迭代器一定是一個可迭代的對象，可迭代對象不一定是迭代器

# next(varstr) # TypeError: 'str' object is not an iterator

#Iterable:檢測是不是一個可迭代對象
#Iterator:檢測是不是一個迭代器

內置函數:python解釋器自帶的

range()函數

1.功能：能夠生成一個指定的數字序列,方便循環(huán)

2.參數：range(start, stop,[,step])

? start : 開始的值炕柔，默認值為0

? stop ：結束的值

[, step]：可選步進值,默認值為1

3.return：可迭代的對象酌泰，數字序列

# 獲取range函數返回的數字序列的方法
res = range(10,0,-2)#10,8,6,4,2
res = range(4,10,2)#4,6,8
res = range(6,10)#6,7,8,9
res = range(-10)#[ ]
res = range(10)#0,1,2,3,4,5,6,7,8,9

# 1.轉為list列表數據
print(list(res))

# 2.通過 for循環(huán) 進行遍歷
for i in res:
    print(i)

# 3.轉為迭代器，使用next函數調用

res = iter(res)
print(next(res))

zip()函數

功能：

? 可以接受多個可迭代的對象匕累，然后把每個可迭代對象中的第i個元素組合在一起陵刹，形成一個新的迭代器

參數：zip(*iterables)

? *iterables，任意個的可迭代對象

return：返回一個元組的迭代器

var1 = '1234'
var2 = ['a','b','c']
var3 = ('A','B','C','D')
# 調用zip函數欢嘿，組成新的元組迭代器
res = zip(var1,var2,var3)
print(res,type(res))#<zip object at 0x10d30b848> <class 'zip'>

# 提取迭代器數據的方法衰琐， next(),list(),for i in ...
print(list(res))

[
    ('1', 'a', 'A'), 
    ('2', 'b', 'B'), 
    ('3', 'c', 'C'), 
]

for i in res:
     print(i)

('1', 'a', 'A')
('2', 'b', 'B')
('3', 'c', 'C')


v1 = [1,2,3,4]
v2 = [22,33,44,55]
res = zip(v1,v2)
print(list(res))

[
    (1, 22), 
    (2, 33), 
    (3, 44), 
    (4, 55)
]

- #### zip() 與 * 運算符相結合可以用來拆解一個列表:

x = [1, 2, 3]
y = [4, 5, 6]
zipped = zip(x, y)
print(list(zipped))#[(1, 4), (2, 5), (3, 6)]
print(zipped) # 迭代器對象

# 組合好的多個元組數據
print(*zip(x, y))#(1,4)(2,5)(3,6)

x2, y2 = zip(*zip(x, y))
print(x2,y2)# (1, 2, 3) (4, 5, 6)

數據類型相關函數
- int() 將其它類型數據轉為整型
- float() 轉為浮點類型
- bool() 轉為布爾類型
- complex() 轉為復數
- str() 轉為字符串類型
- list 轉為列表類型
- tuple 轉為元組類型
- dict 轉為字典類型
- set 轉為集合類型
變量相關函數
- id() 獲取當前數據的ID標識
- type() 獲取當前數據的類型字符串
- print() 數據的打印
- input() 獲取輸入的數據
- isinstance() 檢測是否為指定的數據類型
和數學相關的函數

#獲取一個數的絕對值
print(abs(-99.99))

#求和——從 start 開始自左向右對 iterable 中的項求和并返回總計值
print(sum([1,2,3]))

#獲取——最大值
print(max([1,2,3]))
print(max(99,12,45))

#獲取——最小值
print(min([2,1,6,-9]))
print(min(6,7,1,0,-2))

#冪運算——返回 x 的 y 次冪
print(pow(2,3))#2**3=8

#四舍五入
r = round(3.1415926)#3
        # 小數點保留幾位
r = round(3.1415926,2) #3.14
        #奇進偶退
r = round(4.5) # 1.5 = 2 2.5=2,3.5=4,4.5=4
print(r)

進制相關的函數和字符串

? A - Z 65-90

? a - z 97-122

? 0 - 9 48-57

Ascii 共計 128個字符，更新于 1986年炼蹦，主要用于顯示現代英語和其他西歐語言羡宙。

GB2312-80 是 1980 年制定的中國漢字編碼國家標準，共收錄 7445 個字符掐隐，其中漢字 6763 個狗热。

GBK 于1995年制定收錄了 21003 個漢字，與 GB 2312 編碼兼容虑省，

GBK18030 2001年的1月正式強制執(zhí)行匿刮，是我國制訂的以漢字為主并包含多種我國少數民族文字（如藏、蒙古探颈、傣僻焚、彝、朝鮮膝擂、維吾爾文等）的超大型中文編碼字符集強制性標準虑啤，其中收入漢字7萬余個

Unicode（統(tǒng)一碼、萬國碼架馋、單一碼）是計算機科學領域里的一項業(yè)界標準狞山，包括字符集、編碼方案等叉寂。為每種語言中的每個字符設定了統(tǒng)一并且唯一的二進制編碼萍启，以滿足跨語言、跨平臺進行文本轉換屏鳍、處理的要求勘纯。1990年開始研發(fā)，1994年正式公布钓瞭。

UTF-8以字節(jié)為單位對Unicode進行編碼的一種方案驳遵。

bin() #將數值類型轉為二進制
print(bin(123)) # 0b1111011

int() #將二進制轉為整型
print(int(0b1111011)) #123

oct() #轉為八進制數 01234567
print(oct(123)) # 0o173

hex() #轉為十六進制數,用于顏色 0123456789abcdef
print(hex(123)) # 0x7b
print(int(0x7b))#123

# 將字符轉為 ascii
r = ord('a')
print(r)

# 將ascii轉為字符
r = chr(65)
print(r)

sorted( )

原理：

? 把可迭代數據里面的元素，一個一個的取出來山涡，放到key這個函數中進行處理堤结，

? 并按照函數中return的結果進行排序唆迁，返回一個新的列表

功能：排序

參數：

? iterable 可迭代的數據（容器類型數據，range數據序列竞穷，迭代器）

? reverse 可選唐责，是否反轉，默認為False瘾带，不反轉鼠哥； True反轉

key 可選，函數看政，可以是自定義函數肴盏，也可以是內置函數

return：排序后的結果

arr = [3,7,1,-9,20,10]
# 默認按照從小到大的方式進行排序
res1 = sorted(arr)  # [-9, 1, 3, 7, 10, 20]
print(res1)#[-9, 1, 3, 7, 10, 20]

# 可以按照從大到小的方式進行排序
res2 = sorted(arr,reverse=True)  # [20, 10, 7, 3, 1, -9]
print(res2)#[20, 10, 7, 3, 1, -9]

# 使用abs這個函數(求絕對值）作為sorted的key關鍵字參數使用
res3 = sorted(arr,key=abs)#按照出處理結果排序
print(res3)#[1, 3, 7, -9, 10, 20]



#使用自定義函數對數據進行處理
def func(num):
    #print(num,num % 2)
    return num % 2

arr = [3,2,4,6,5,7,9]
# 在sorted函數中使用自定義函數對數據進行處理
res = sorted(arr,key=func)
print(res)


# 優(yōu)化版
arr = [3,2,4,6,5,7,9]
res = sorted(arr,key=lambda x:x%2)
print(res)

map( )

map(func, *iterables)

功能：

?對傳入的可迭代數據中的每個元素放入到函數中進行處理，返回一個新的迭代器

參數：

func 函數自定義函數|內置函數

? iterables：可迭代的數據

return：迭代器

#1.字符串數字的列表轉為整型的數字列表
#['1','2','3','4'] 轉為 [1, 2, 3, 4]

#普通方法
varlist = ['1','2','3','4']
newlist = []
for i in varlist:
    newlist.append(int(i))
print(newlist)

# 使用map函數處理這個數據
varlist = ['1','2','3','4']
res = map(int,varlist)
print(list(res))


#2.[1, 2, 3, 4] 轉為 [1, 4, 9, 16]
#普通方法
varlist = [1,2,3,4]
newlist = []
for i in varlist:
    j = i ** 2
    newlist.append(j)
    
print(newlist)

# 使用map函數處理這個數據
varlist = [1,2,3,4]
def func(x):
  return x **2
res = map(func,varlist)
print(list(res))


#優(yōu)化版
res = map(lambda x:x**2,varlist)
print(list(res))


#3.['a','b','c','d'] 轉為 [65,66,67,68]
list1 = ['a','b','c','d']
res = map(lambda x:ord(x.upper()),list1)
print(list(res))

reduce( )

需要導入 from functools import reduce

reduce(func,*iterable)

功能：

? 每一次從 iterable 拿出兩個元素帽衙，放入到func函數中進行處理菜皂，得出一個計算結果，

? 然后把這個計算結果和iterable中的第三個元素厉萝，放入到func函數中繼續(xù)運算恍飘，

? 得出的結果和之后的第四個元素，加入到func函數中進行處理谴垫，以此類推章母，直到最后的元素都參與了運算

參數：

? func：內置函數或自定義函數

? iterable：可迭代的數據(邏輯類型，range類型翩剪，可迭代對象)

return：最終的運算處理結果

from functools import reduce
# 1. [5,2,1,1] 轉為 5211
#方法一：普通方法
varlist = [5,2,1,1]
res = ''
for i in varlist:
    res += str(i)
res = int(res)
print(res,type(res))

#方法二
'''
5 2 1 1
5 * 10 + 2 == 52
52 * 10 + 1 == 521
521 * 10 + 1 == 5211
'''
def myfunc(x,y):
    return x*10+y
varlist = [5,2,1,1]
# 調用函數
res = reduce(myfunc,varlist)
print(res,type(res))

#2.字符串 '456' 轉為 int的 456
#  不能使用int方法進行類型的轉換時乳怎，如何解決上面的問題？

# 定義函數前弯，給定一個字符串的數字蚪缀，返回一個整型的數字
def myfunc(s):
    vardict = {'0':0,'1':1,'2':2,'3':3,'4':4,'5':5,'6':6,'7':7,'8':8,'9':9}
    return vardict[s]
  
print(myfunc('4'))#4
print(myfunc('5'))#5
print(myfunc('6'))#6

# 1.先使用 map函數，把數字字符串恕出，轉為整型的數字
iter1 = map(myfunc,'456')
# 調用一下：print(list(iter1))#[4,5,6]

# 2. 把數字列表中的值询枚，使用lambda進行二次處理
iter2 = reduce(lambda x,y:x*10+y,iter1)
print(iter2)#456

filter( )—過濾器

filter(func,iterable)

功能：過濾數據，把 iterable 中的每個元素拿到 func 函數中進行處理浙巫，

? 如果函數返回True則保留這個數據金蜀，返回False則丟棄這個數據

參數：

? func 自定義函數

? itereble：可迭代的數據

return：保留下來的數據組成的迭代器

varlist = [1,2,3,4,5,6,7,8,9]
# 保留所有的偶數，丟棄所有的奇數
#普通方法
newlist = []
for i in varlist:
    if i % 2 == 0:
        newlist.append(i)
print(newlist)

# 使用 filter 進行處理
#定義一個函數的畴，判斷當前這個函數是否為偶數渊抄，偶數返回True，奇數返回False
def myfunc(n):
    if n % 2 == 0:
        return True
    else:
        return False

# 調用 過濾器 函數進行處理
it = filter(myfunc,varlist)
print(it,list(it))#<filter object at 0x10d2c1400> [2, 4, 6, 8]

# 優(yōu)化版
it = filter(lambda n:True if n % 2 == 0 else False,varlist)
print(it,list(it))