week6-pytho之内置函数

注意：内置函数id()可以返回一个对象的身份，返回值为整数。这个整数通常对应与该对象在内存中的位置，但这与python的具体实现有关，不应该作为对身份的定义，即不够精准，最精准的还是以内存地址为准。is运算符用于比较两个对象的身份，等号比较两个对象的值，内置函数type()则返回一个对象的类型

字典的运算：最小值，最大值，排序
salaries={
    'egon':3000,
    'alex':100000000,
    'wupeiqi':10000,
    'yuanhao':2000
}
迭代字典，取得是key，因而比较的是key的最大和最小值
>>> max(salaries)
'yuanhao'
>>> min(salaries)
'alex'
可以取values，来比较
>>> max(salaries.values())
>>> min(salaries.values())
但通常我们都是想取出，工资最高的那个人名，即比较的是salaries的值，得到的是键
>>> max(salaries,key=lambda k:salary[k])
'alex'
>>> min(salaries,key=lambda k:salary[k])
'yuanhao'

也可以通过zip的方式实现
salaries_and_names=zip(salaries.values(),salaries.keys()) 

先比较值，值相同则比较键
>>> max(salaries_and_names)
(100000000, 'alex')

eval与compile

eval(str,[,globasl[,locals]])
eval('1+2+max(3,9,100)+1.3')

my_globals={'x':1}
my_locals={'x':2}
eval('1+x',my_globals,my_locals)

exec('for i in range(10):print("i")')
同样可以指定自己的名称空间

compile(str,filename,kind)
filename:用于追踪str来自于哪个文件，如果不想追踪就可以不定义
kind可以是：single代表一条语句，exec代表一组语句，eval代表一个表达式

s='for i in range(10):print(i)'
code=compile(s,'','exec')
exec(code)


s='1+2+3'
code=compile(s,'','eval')
eval(code)

 

# 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(func,seq):
    for item in seq:
        yield func(item)

res1=my_map(lambda x:x+'_SB',names)
print(next(res1))
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)))
##################
names=['alex_SB','wupeiqi_SB','yuanhao_SB','yanglei_SB','egon']
print(list(filter(lambda name:name.endswith('SB'),names)))

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 （字符编码和数字的对应关系）
print(chr(65))
print(chr(90))
#
print(ord('#'))

#内置函数，又被称为工厂函数
int
x=1 #x=int(1)
print(type(x))
x=int(2)

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
sys.argv
print(dir(sys))

#divmod

print(divmod(10,3))
print(divmod(102,20))

#enumerate
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
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)

#迭代器
iter
next
#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
# repr，str
print(type(str(1)))
print(type(repr(1)))

#slice
l=[1,2,3,4,5,6]
print(l[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)))

#vars
import m1
print(vars(m1) == m1.__dict__)

#zip:拉链
s='hellosssssssssssssssss'
l=[1,2,3,4,5]
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))

#lambda

匿名函数的应用场景：
#应用于一次性的场景，临时使用

def func(x,y,z=1):
    return x+y+z
print(func)
print(func(1,2,3))
#匿名函数:1. 没有名字 2：函数体自带return
print(lambda x,y,z=1:x+y+z)
f=lambda x,y,z=1:x+y+z
print(f)
print(f(1,2,3))
x=1
1
print(x)
print(1)