python內置函數及匿名函數

locals  本地做用域/局部做用域 會隨着位置的改變而改變
globals 全局做用域           永遠不變 永遠是全局

a = 1
b = 2
print(locals())
print(globals())
def func():
    c = 3
    d = 4
    print(locals())
def func2():
    l1 = []
    d1 = {}
    print(locals())     #不管在哪裏打印 獲得的都是全局做用域中的名字
func()
func2()
# 結果
# {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001CE3C83A470>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'E:/PyPractise/day11.py', '__cached__': None, 'a': 1, 'b': 2}
# {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001CE3C83A470>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'E:/PyPractise/day11.py', '__cached__': None, 'a': 1, 'b': 2}
# {'d': 4, 'c': 3}
# {'d1': {}, 'l1': []}

range(起始位置,終止位置,步長)
range(終止位置)
range(起始,終止位置)

range(5)  # 0,1,2,3,4
range(5, 0, -1)  # 5,4,3,2,1
range(1, 10, 2)  # 1,3,5,7,9

print(要打印的內容1,要打印的內容2,sep = '分隔符',end = '結束符',file=file.txt, flush=False)
file:  默認是輸出到屏幕,若是設置爲文件句柄,輸出到文件
sep:   打印多個值之間的分隔符,默認爲空格
end:   每一次打印的結尾,默認爲換行符
flush: 當即把內容輸出到流文件,不做緩存(默認緩存)
#print的本質,就是寫文件,這個文件是pycharm的屏幕

print(123,'abc',sep='|',end='@')
print('www')
結果：
123|abc@www

事例二
f = open('file','w')
print(123,'abc',file=f,flush=True)
f.close()

案例:打印進度條
import time   #導入別人寫好的代碼
def func():
    for i in range(0,101,2):
        time.sleep(0.1)     #每一次在這個地方阻塞0.1s
        char_num = i//2     #控制輸出長度
        if i == 100:
            per_str = '\r%s%% : %s\n' % (i, '*' * char_num)     # %% 轉義%，\n換行符
        else:
            per_str = '\r%s%% : %s' % (i, '*' * char_num)
        print(per_str,end = '')     #per_str,end = ''格式化輸出去除print末尾的默認換行符\n,不換行打印
func()
print('下載完成')

callable() 判斷某一個變量是否可調用(True/False)

def call(arg):
    if callable(arg):
        arg()
    else:
        print('參數不符合規定')
def func():
    print('in func')
    return 1
func2 = 1234
call(func)
call(func2)
print(callable(func))
print(callable(func2))
結果
in func
參數不符合規定
True
False

round(小數,保留幾位小數)  小數精確
整數是奇數 -> 正常四捨五入
整數是偶數 -> 五舍六入

2.x(徹底的四捨五入)和3.x(更精準的計算方式)不一樣
print(round(2.3258358))
print(round(2.3253358,2))
print(round(2.3254358,3))
print(round(1.5))
print(round(2.5))
print(round(2.6))
結果
2
2.33
2.325
2
2
3

pow(x,y,z=1) 冪運算/冪餘運算 x的y次方%z

print(pow(2,3))
print(pow(3,2))
print(pow(5,3,2))
print(pow(4,2,2))
print(pow(4,3,2))
結果
8
9
1
0
0

list
tuple

reversed  返回一個迭代器,節省內存
reversed 不修改原基礎: 不直接返回列表而返回迭代器,爲了避免佔用更多的內存
reverse 是在原基礎上修改: 2000項的列表,不會產生額外的內存佔用

l = [1,2]
l.reverse()
print(l)
結果：
[2, 1]

ret = reversed([1,2,3])  # iterator可迭代的
print(ret)
print(list(ret))
結果：
<list_reverseiterator object at 0x0000024B9ECEEC88>
[3, 2, 1]

lst = ["河南", "四川", "東北", "山東", "上海"]
r = reversed(lst)
print(list(r))
結果
['上海', '山東', '東北', '四川', '河南']

s= "不是上海自來水來自海上"
print(s[::-1])
it = reversed(s)
s2 = ''
for i in it:
    s2 += i
print(s2)
結果：
上海自來水來自海上是不
上海自來水來自海上是不

slice  切片

l = [1,2,3,4,5,]
ret = slice(1,4)   # [1:4]
print(l[ret])
等於
print(l[1:4])
結果：
[2, 3, 4]
[2, 3, 4]

format(填充)

print(format('test', '<20'),'alex')
print(format('test', '>20'),'alex')
print(format('test', '^20'),'alex')
結果：
test                 alex
                test alex
        test         alex

進制轉換
print(format(3, 'b'))   # 轉換成二進制  binary  0b11
print(format(65, 'c'))  # 轉換成unicode字符  ascii
print(format(11, 'o'))  # 轉換成八進制  0o    13
print(format(11, 'x'))  # 轉換成十六進制(小寫字母)
print(format(11, 'X'))  # 轉換成十六進制(大寫字母)
print(format(11, 'd'))  # 轉換成十進制
print(format(11, 'n'))  # 和d同樣
print(format(11))       # 和d同樣
結果
11
A
13
b
B
11
11
11

科學計數法
print(format(123456789, 'e'))   # 科學計數法,默認保留6位小數,表示大的數據
print(format(123456789, '.2e')) # 科學計數法,保留2位小數(小寫)
print(format(123456789, '0.2E'))# 科學計數法,保留2位小數(大寫)
結果
1.234568e+08
1.23e+08
1.23E+08

浮點計數法
print(format(1.23456789, 'f'))    # 浮點數計數法,保留6位小數
print(format(1.23456789, '0.2f')) # 小浮點數計數法,保留2位小數
print(format(1, '0.10f'))         # 小浮點數計數法,保留10位小數
print(format(1.23456789e+10000, 'F')) # 小浮點數計數法
結果
1.234568
1.23
1.0000000000
INF        #無窮大

repr() 還原字符串最官方的效果

轉義字符
\n 換行
\t tab 製表符
\r 回車
\"   雙引號
\'  單引號
\\    \
print('hello\\n world')
結果
hello\n world

還原字符串最官方的效果
print(repr('hello\\n world'))
結果
'hello\\n world'

原封不動的顯示字符串
print(r'hello\\n wo\trld')
結果
hello\\n wo\trld

zip 拉鍊函數,返回迭代器-節省內存,水桶效應

a = (1,2,3,4)
b = ('a','b','c')
c = ['111','222']
d = {'k1':'v1','k2':'v2'}
ret = zip(a,b,c,d)
print(ret)

for i in ret:
    print(i)
結果：
<zip object at 0x0000023ECB077108>
(1, 'a', '111', 'k1')
(2, 'b', '222', 'k2')

匿名函數
定義
匿名函數的內存地址 = lambda 參數1,參數2 : 返回值/返回值的表達式
調用
接收返回值 = 匿名函數的內存地址(參數)

def定義的函數: 都是有名字的,def後面寫的就是函數名
def qqxing():
    print('qqxing')
func = qqxing
func2 = qqxing
print(qqxing.__name__)
print(func.__name__)    #內置屬性,經過執行的函數名返回定義的函數名
print(func2.__name__)
結果
qqxing
qqxing
qqxing

事例2
def exe(func):
    func()
    print('執行%s函數了'%func.__name__)
def qqxing():
    print('qqxing')
def wahaha():
    print('wahaha')
exe(wahaha)
exe(qqxing)
結果
wahaha
執行wahaha函數了
qqxing
執行qqxing函數了


匿名函數沒有名字,統一的名字是:<lambda>,別稱: lambda表達式
定義一個很簡單的函數,複雜的函數不要用lambda
def func(a,b):
    return a + b
ret = func(1,2)
print(ret)

fn = lambda a,b:a + b
ret = fn(5,6)
print(ret)
print(fn)
結果
3
11
<function <lambda> at 0x0000027766AD98C8>
使用場景: 配合着sorted,map,filter一塊兒使用

事例2
qqxing = lambda n:n**2
print(qqxing.__name__)
ret = qqxing(8)
print(ret)
結果
<lambda>
64

事例3
f = lambda *args:sum(args)
ret = f(1,2,3)
print(ret)
執行結果
6

事例4
dic = {'k1':10,'k2':100,'k3':30}
m = max(dic,key=lambda k:dic[k])
print(m)
同等
def func(k):
    return dic[k]
m = max(dic,key=func)
print(m)
結果
k2

接收兩個參數,返回較大值(不用max內置函數)
f1 = lambda a,b : max(a,b)
f2 = lambda a,b : a if a>b else b

sorted() 排序,根據key對應的函數的返回值的大小來排序的
因爲必需要知道後面的值是誰,才能排出順序,因此結果就是排序後的結果而不是可迭代的
按照字符串長度排序
執行流程: 把可迭代對象中的每一項拿出來, 做爲參數傳遞給後面key函數,函數返回數字,根據數字進行排序

lst = ['關穀神奇','呂小布','諾蘭','山口美惠子','易']
def func(s):
    return len(s)
ret = sorted(lst,key=func)
print(ret)
同等
print(sorted(lst,key=lambda s:len(s)))
結果：
['易', '諾蘭', '呂小布', '關穀神奇', '山口美惠子']

事例2
lst = [
    {"name":"bob", "shengao":150, "tizhong":250},
    {"name":"jary", "shengao":158, "tizhong":150},
    {"name":"jack", "shengao":177, "tizhong":130},
    {"name":"pique", "shengao":165, "tizhong":130},
    {"name":"alice", "shengao":160, "tizhong":120},
    {"name":"athena", "shengao":183, "tizhong":190}
]
按照體重進行排序
按照身高進行排序
print(sorted(lst,key=lambda dic:dic['tizhong']))
print(sorted(lst,key=lambda dic:dic['shengao']))


事例3
l = [-3,1,2]
l.sort()
print(l)
def func(n):
    return abs(n)
l.sort(key = func)
print(l)
結果
[-3, 1, 2]
[1, 2, -3]

事例4
l = [1,-3,2]
new_l = sorted(l)   #在不改變原列表的狀況下 生成一個新列表
print(l)
print(new_l)
def func(n):
    return abs(n)
ret = sorted(l,key = func)
print(ret)
結果
[1, -3, 2]
[-3, 1, 2]
[1, 2, -3]

事例5
按照每個字典中商品的價格從高到低排列
l = [{'name':'電腦','price':1999},{'name':'鼠標','price':2000}]
def func(dic):
    return dic['price']
l.sort(key=func,reverse=True)
print(l)
同等
new_l = sorted(l,key = func,reverse= True)
print(new_l)
結果:
[{'name': '鼠標', 'price': 2000}, {'name': '電腦', 'price': 1999}]

filter 篩選

過濾掉名字結尾帶剛字的人
把可迭代對象打開,把內部元素一個一個的傳遞給前面的函數,由這個函數決定此項是否保留
lst = ['旭日陽剛','金毛獅王','李剛','張傑']
f = filter(lambda name:not name.endswith('剛'),lst)
print(f)
print(list(f))
結果：
<filter object at 0x00000206FCB37208>   #可迭代對象
['金毛獅王', '張傑']

事例2
lst = [
    {"name":"bob", "shengao":150, "tizhong":250},
    {"name":"jary", "shengao":158, "tizhong":150},
    {"name":"jack", "shengao":177, "tizhong":130},
    {"name":"pique", "shengao":165, "tizhong":130},
    {"name":"alice", "shengao":160, "tizhong":120},
    {"name":"athena", "shengao":183, "tizhong":190}
]
ret = filter(lambda a:a['tizhong'] < 180,lst)
print(list(ret))
結果：
[{'name': 'jary', 'shengao': 158, 'tizhong': 150}, {'name': 'jack', 'shengao': 177, 'tizhong': 130}, {'name': 'pique', 'shengao': 165, 'tizhong': 130}, {'name': 'alice', 'shengao': 160, 'tizhong': 120}]

事例3
ret = filter(None,[1,2,3,0,False])  #只保留真的
print(ret)
for i in ret:
    print(i)
結果：
<filter object at 0x000002BD91BCEBA8>
1
2
3

事例4
def func(i):
    if i % 2 != 0:
        return True
l = [1, 4, 6, 7, 9, 12, 17]
for i in filter(func,l):  # 迭代l,每個元素做爲參數傳給func,若是func的返回值爲True,那麼l中的這個元素就保留
    print(i)
結果：
1
7
9
17

事例5
def func(i):
    if type(i) is not dict:     #判斷i類型不是dict的就返回True
        return True
同等
def func(i):
    return type(i) is not dict

l = ['sjkdhf',[1,2,3],{},()]    #去掉列表中的字典,用filter
ret = filter(func,l)
print(list(ret))
結果：
    ['sjkdhf', [1, 2, 3], ()]

# filter 就像 帶着if條件的列表推導式
    l = ['sjkdhf',[1,2,3],{},()]
    print([i for i in l if type(i) is not dict])

map 映射函數
一個迭代器中的每個元素都須要去作同一個操做並返回一個結果組成一個新列表的時候map來處理

lst = ['關穀神奇','呂小布','諾蘭','山口美惠子','易']
m = map(lambda s:'姓名:'+s,lst)
print(m)
for i in m:
    print(i)
結果：
<map object at 0x000001B76BAA7208>
姓名:關穀神奇
姓名:呂小布
姓名:諾蘭
姓名:山口美惠子
姓名:易

事例2
列表中的每個值的平方組成的新列表
lst = [1,5,78,12,16]
m = map(lambda i:i**2,lst)
print(list(m))
同等
print([i**2 for i in lst])
同等
lst = [1,5,78,12,16]
def func(num):
    return num**2
ret = map(func,lst)
print(list(ret))
結果：
[1, 25, 6084, 144, 256]

事例3
def func(i):
    return i*'*'
ret = map(func,[1,2,3])
print(ret)
for i in ret:
    print(i)
結果：
<map object at 0x0000024AEBB4ECC0>
*
**
***

eval() 有返回值,能夠將字符串數據類型的python代碼執行,經過拼接字符串的方式來執行不一樣的代碼--簡化代碼
eval\exec這個函數,不能直接操做文件當中讀進來的,從網絡上傳進來,用戶輸入的

eval('print(1+2+3+4)')  #返回10
ret = eval('1+2/3*4')
print(ret)              #有返回值
結果：
10
3.6666666666666665

事例2
code = input("請輸入你要執行的代碼:")
ret = eval(code)
print(ret)

事例3
把字符串類型的代碼還原回字典, 列表, 元組
s = "{'name':'bob', 'age':18, 'isMan':False}"   #字符串
ret = eval(s)   #側重的有返回值
print(ret)
print(type(ret))
結果：
{'name': 'bob', 'age': 18, 'isMan': False}
<class 'dict'>

事例4
with open('測試文件.txt','r',encoding='utf=8')as f:
    content=f.read()
    print(content,type(content))
    print(eval(content),type(eval(content)))
    print(eval(content)[0])
結果：
[{'id':1},{'name':'alex'}] <class 'str'>
[{'id': 1}, {'name': 'alex'}] <class 'list'>
{'id': 1}

將普通字符串'<'轉換成<小於
def func(f):
    if eval('33 %s 20'%f):
        print('符合條件')
    else:
        print('不符合條件')
if '>':
    func('>')
if '<':
    func('<')

exec() 沒有返回值,執行字符串類型的代碼,不能太長,不能太亂

code = input("請輸入你要執行的代碼")
exec(code)  # 沒有返回值. 想要返回值用eval
print(a)    # pycharm報錯不必定準
結果：
請輸入你要執行的代碼a=3+4+9
16

事例2
exec('print(1+2+3+4)')  # 沒有返回值,想要返回值用eval
ret = exec('1+2/3*4')
print(ret)              #沒有返回值None
exec('for i in range(3):print(i)')
執行結果
10
None
0
1
2

compile編譯  
把要執行的代碼先預編譯,可以節省時間工具,經過exec和eval能夠執行咱們的代碼
參數說明:
resource 要執行的代碼,動態代碼⽚片斷
文件名,代碼存放的文件名,當傳入了第一個參數的時候,這個參數給空就能夠了
模式,取值有3個
    exec: 通常放一些流程語句句的時候
    eval: resource只存放一個求值表達式.
    single: resource存放的代碼有交互的時候,mode應爲single

先編譯 python -編譯-> 字節碼(bytes) -解釋-> 機器碼 0101010100101
先總體編譯
code1 = 'for i in range(0,3): print (i)'   #這是一個字符串代碼

事例1
流程語句使用exec
compile1 = compile(code1,'','exec')     #預編譯 python-> 字節碼
exec (compile1)  #解釋
exec (compile1)
exec(code1)     #編譯+解釋
結果：
0
1
2
0
1
2
0
1
2

事例2
簡單求值表達式用eval
code2 = '1 + 2 + 3 + 4'
compile2 = compile(code2,'','eval')
print(eval(compile2))
結果：
10

事例3
交互語句用single
code3 = 'name = input("please input your name:")'
compile3 = compile(code3,'','single')
exec(compile3)
print(name)
結果：
please input your name:linux
linux