python3-基礎10

###匿名函數與內置函數
'''
匿名函數與內置函數
經常使用模塊
面向對象

'''

'''

def func(x,y,z=1):
return x+y+z

# print(func)
# print(func(1,2,3))

#匿名函數:一、沒有名字 2：函數體自帶return
#函數體只有一行代碼能夠這樣寫

#匿名函數用一次就被釋放掉了
'''
lambda x,y,z = 1:x+y+z
'''
實際上就是：
lamdba x,y,z = 1:
return x+y+z
'''
zzz = lambda x,y,z = 1:x+y+z
print(zzz)

#匿名函數的應用場景：
#應用於一次性的場景，臨時使用

'''
#內置函數

'''

 

# print(abs(-1)) #絕對值
#
# print(all([1,2,'a',None]))
# print(all([]))

#bool值爲假的狀況：None，空，0，False

# # print(any([]))
# print(any([' ',None,False])) #True
# print(any(['',None,False])) #False
# print(any(['',None,False,1])) #True
#

#bin,oct,hex 二進制 八進制 十六進制
# print(bin(10)) #十進制轉二進制
# print(oct(10))
# print(hex(10))

#bytes 字節類型
#unicode----encode----->bytes
# print('hello'.encode('utf-8'))
# print(bytes('hello',encoding='utf-8'))

#callable 查詢是不是能夠被調用的
# print(callable(bytes))
# print(callable(abs))

#chr,ord 根據十進制數字對應ACISS碼錶中的值 ord相反
# print(chr(65))
# print(chr(90))
#
# print(ord('#'))

 

#內置函數，又被稱爲工廠函數，向工廠同樣，調用一次產生一個值
# int
# x=1 #x=int(1)
# print(type(x))
# x=int(2) #int 是個class（類），一直往外製造int值

 

complex
float

str
list
tuple
dict

set #可變集合
frozenset #不可變集合

# s={1,2,3,4} #s=set({1,2,3,4}) #集合 不可變類型
# print(type(s))
#
# s1=frozenset({1,2,3,4}) #集合 不可變集合
# print(type(s1))

 

#dir
# import sys
# # sys.path #.後指的是屬性，path是sys的屬性
# # sys.argv
# print(dir(sys)) sys下有哪些可執行的函數 sys.

#divmod 分頁展現目錄
# print(divmod(10,3)) # 10 除以 3 ， 的到的值和餘數放在一個組裏
# print(divmod(102,20)) #好比 102條記錄，每頁20頁，該分幾頁

#enumerate 每一個元素前面加一個索引，以元組的形式存儲。它是一個迭代器，要訪問裏面的值，就要next() 或 for循環
# l=['a','b','c']
# res=enumerate(l)
# for i in res:
# print(i)
# for index,item in enumerate(l):
# print(index,item) #索引 索引對應的值

 

#globals,locals #查看全局做用域和局部做用域
# print(globals()) 查看全局做用域裏面的名字，內置的和全局名稱空間

#hash #獲得hash值
# print(hash('abcdefg123'))
# print(hash('abcdefg123')) 內容同樣的到的值就同樣
# print(hash('abcdefg123'))
# print(hash('abcdefg123'))

#給函數加文檔解釋，用到單引號，雙引號，三引號
def func():
# '''
# test function
# :return:
# '''
pass

# print(help(func))

#id:是python解釋器實現的功能，只是反映了變量在內存的地址
#但並非真實的內存地址
# x=1
# print(id(x))

# def func():pass
# print(id(func))
# print(func)

#isinstance 能夠用賴判斷變量是什麼類型
# x=1
# print(type(x) is int)
# print(isinstance(x,int)) #x=int(1) X是int的一個實例

#迭代器
iter 可迭代對象變成迭代器對象
next

#len
#max
# print(max([1,2,3,10]))
# print(max(['a','b']))
# print(min([1,2,3,10]))

#pow
# print(pow(3,2,2)) #3**2%2 3的2次方在取2的餘數

#range

# #repr，str 兩個都是將解析對象轉換成字符串
# print(type(str(1)))
# print(type(repr(1)))

#reversed 翻轉，產生新值，是一個迭代器
# l=[1,'a',2,'c']
# print(list(reversed(l)))
# print(l)

#round 保留n位小數，四捨五入
#peinr(round(3.478,2)
#peinr(round(3.478,1)

 

#slice #切片
# l=[1,2,3,4,5,6]
# print(l[0:4:2]) 從0開始，到4結束，步長爲2
#
# s=slice(0,4,2)
# print(l[s])

#sorted 從小到大排序，只能同類型之間排序
# l=[1,10,4,3,-1]
# print(sorted(l,reverse=True))

#sum 求和
# print(sum([1, 2,3]))
#
# print(sum(i for i in range(10))) 0 到 9 10個數求和

 

#vars #若是沒參數，就至關於local，若是有參數，至關於字典
# import m1
# print(vars(m1) == m1.__dict__)

#zip:拉鍊 一一對應，組成一個小元組
# s='hellosssssssssssssssss'
# l=[1,2,3,4,5]
# res=zip(s,l)
# print(list(zip(s,l)))

#__import__
import sys

# m_name=input('module>>: ')
# if m_name == 'sys':
# m=__import__(m_name) 一個函數，調用字符串，負責字符串不能直接被訪問
# print(m)
# print(m.path)
#
# sys=__import__('sys')
# print(sys)

 

#round
print(round(3.565,2))
print(round(3.555,2))

 

 

#################3

 

#與匿名函數結合使用
#max,min,sorted

salaries={
'egon':3000,
'alex':100000000,
'wupeiqi':10000,
'yuanhao':2000
}

# print(max(salaries))
# print(max(salaries.values()))

# t1=(1,'h',3,4,5,6)
# t2=(1,'y',3)
# print(t1 > t2)

# t1=(10000000,'alex')
# t2=(3000,'egon')
# print(t1 > t2)

# print(max(zip(salaries.values(),salaries.keys()))[1])
# def get_value(name):
# return salaries[name]

 

# print(max(salaries,key=get_value))
# l=[]
# for name in salaries:
# res=get_value(name)
# l.append(res)
# print(max(l))

# lambda name:salaries[name]

# print(max(salaries,key=lambda name:salaries[name]))
# print(min(salaries,key=lambda name:salaries[name]))

# salaries={
# 'egon':3000,
# 'alex':100000000,
# 'wupeiqi':10000,
# 'yuanhao':2000
# }
# def get_value(name):
# return salaries[name]
# print(sorted(salaries))
# print(sorted(salaries,key=get_value))
# print(sorted(salaries,key=get_value,reverse=True))

 

#filter,map(映射),reduce
# names=['alex','wupeiqi','yuanhao','yanglei','egon']
#
#把列表每一個元素映射後，生成新的列表
# res=map(lambda x:x if x == 'egon' else x+'SB',names) #映射規則，映射名稱
# print(res)
# print(list(res))

#def my_map(seq):
# res=[]
# for item in seq:
# item = item + '_SB'
# res.append(item)
# return res
#print(my_map(names))

##生成器就是迭代器，省內存
# def my_map(func,seq):
# for item in seq:
# yield func(item)
#
# res1=my_map(lambda x:x+'_SB',names)
# print(next(res1)) #經過next取值
# print(next(res1))
# print(next(res1))

# from functools import reduce
# print(reduce(lambda x,y:x+y,range(101),100))
# print(reduce(lambda x,y:x+y,range(101)))
#
# l=[1,2,'a','b',3,'c','d']

 

 

names=['alex_SB','wupeiqi_SB','yuanhao_SB','yanglei_SB','egon']
print(list(filter(lambda name:name.endswith('SB'),names))) #過濾SB

 

 

############33

# cmd='print(x)'
#
#
# x=1
# # eval(cmd,{'x':0},{'x':10000000}) 後者爲局部做用域，前者爲全局做用域
# # eval(cmd,{'x':0},{'y':10000000})

#eval能夠本身制定做用域
#有兩個參數
#能夠直接執行代碼

# s='for i in range(10):print(i,x)'
# code=compile(s,'','exec')
# # print(code)
# exec(code,{},{'x':1111})

#exec須要先編譯再執行