内置函数

内置函数有如下：

根据分类学习会容易些

与数据类型有关的

#这里不做解释  详情查看数据类型

int
#bool值为空 ：None 空  0 False
bool
str
tuple
complex
float
list
set
frozenset 也是个集合 不可变集合

在面向对象里讲的

##讲面向对象的时候 解释 还没讲

object
classmethod
staticmethod
property
delatter
hasatter
setatter
getatter
isinstance #用来判断一个变量的类型
issubclass
supper
__dict__

与生成器有关的

#18. vars
#无参数的时候  等同于 locals
#有参数的时候  等同于 __dict__
vars

locals和globals 前边讲得 等前边的笔记统一好了 加链接

与lambda结合使用的

max min sorted

filter map reduce

# max min
print(max(1,2,3))
print(min(1,2,3))
'''
3
1
'''

#需求  打印出 工资最高的人名  是人名
salaries={
    'egon':3000,
    'alex':100000000,
    'wupeiqi':10000,
    'yuanhao':2000
}

print(max(salaries)) #默认比较的是key
print(max(salaries.values())) #这样打印出来的是工资最高的工资
# #思路
# #既然默认比较的是key 那么就把value搞成key 反一下
max(salaries.values())
max(salaries.keys())
print(max((zip(salaries.values(),salaries.keys()))))
'''
看似实现了 但也不是想要的效果
(100000000, 'alex')
'''
#不在兜圈子 直奔主题
#max除了直接比较外，还可以指定key即指定通过什么比较

#根据以下这段代码，阐述max的工作原理
max(salaries,key=lambda name:salaries[name])
'''
max(salaries)，salaries是个字典，max不指定key的话，默认就会
用自己的一个参数 salaries做比较（也就是salaries的key）,然后打印
key值，现在手动给max指定了key即指定了用什么做比较，但是也不会改变最终
的打印效果，依然是max的第一个参数 salaries的key,这说明打印出来的肯定
还是个人名

控制的只能是拿什么比较  控制不了输出

max 首先读到salaries 会for循环salaries,拿到sallaries的key值，也就是
名字，然后赋值给后边的key也就是lambda,然后通过lambda得到的是字典的value
也就是薪资，那么max此时就会拿薪资做比较，拿到薪资最高的值，然后返回值对应
的名字

这样就达到了最初的效果

'''
print(max(salaries,key=lambda name:salaries[name]))
print(min(salaries,key=lambda name:salaries[name])) #min也是一样的原理
'''
alex
yuanhao
'''


#sorted
#需求：按照薪资从小到大排列人名
salaries={
    'egon':3000,
    'alex':100000000,
    'wupeiqi':10000,
    'yuanhao':2000
}
print(sorted(salaries, key=lambda name: salaries[name]))
'''
原理参照max
['yuanhao', 'egon', 'wupeiqi', 'alex']
'''
max min sorted
#map 映射

#需求 在每个人的名字后边加上  _sb
names=['alex','wupeiqi','yuanhao','yanglei','egon']
res=map(lambda x:x+'_sb',names)
#res.__next__()
#res.__init__()  是个迭代/生成器  所以用 list查看结果
print(list(res))
'''
原理 lambda放在前边，for 循环后边的names 赋值给lamba ，lamba的
返回值就是函数的返回值 和max min有一样的也有不一样的
返回值这里不一样  注意
'''
'''
打印结果
['alex_sb', 'wupeiqi_sb', 'yuanhao_sb', 'yanglei_sb', 'egon_sb']
'''
#三元表达式
# result = 值1 if 条件 else 值2
# 如果条件为真：result = 值1
# 如果条件为假：result = 值2

res=map(lambda x: x if x=='egon' else x+'_sb',names)
print(list(res))
'''
# ['alex_sb', 'wupeiqi_sb', 'yuanhao_sb', 'yanglei_sb', 'egon']
# '''

#reduce 合并
from functools import reduce

print(reduce(lambda x,y:x+y,range(101))) #求1-100的和
print(reduce(lambda x,y:x+y,range(101),1)) #默认初始值是0 可以手动指定 这里指定为了1
'''
5050
5051
'''

#filter 过滤
names=['alex_sb', 'wupeiqi_sb', 'yuanhao_sb', 'yanglei_sb', 'egon']
print(list(filter(lambda name:name.endswith('sb'),names)))
'''
['alex_sb', 'wupeiqi_sb', 'yuanhao_sb', 'yanglei_sb']
'''
map reduce filter

其他常用的

 更常用的：

open print type  next  iter len input #这几个不讲  一路走来都说过了 熟悉了
bytes sum 待补充
# 将元素对应的索引也打印出来
li = ['eric','alex','tony']
for i,ele in enumerate(li,1):
    print(i,ele)
'''
1 eric
2 alex
3 tony
'''
enumerate






for i in range(0,11):
    print(i)
print('==============>')
for j in range(11): #这两种情况打印结果一样
    print(j)
'''
0
1
2
3
4
5
6
7
8
9
10
==============>
0
1
2
3
4
5
6
7
8
9
10
'''
for v in range(1,11,2): #第三个参数有点像步长
    print(v)
'''
1
3
5
7
9
'''



range






n=[1,2,3,4]
s='hello'
e=zip(n,s)
for i in e:
    print(i)
'''
(1, 'h')
(2, 'e')
(3, 'l')
(4, 'l')
'''



zip






#divmod 返回两个数值相除的商和余数  做分页功能
print(divmod(200,3))
'''
(66, 2)
'''



divmod






# reversed 反过来
# l=[1,3,'v']
# # r=reversed(l) #得到的是一个迭代器
# # for i in r: #然后用for  值就都反过来了
# #     print(i)



reversed 






# bin 十进制转二进制
#print(bin(3))
# print(hex(3)) #十进制转16进制
# print(oct(3))#十进制转八进制



bin






#__import__  导入模块
# import  time #time不是一个字符串
# __import__('time') # 以字符串的形式导入模块



__import__ 






#id  判断对象的身份
# x=2
# y=2
# print(id(x),id(y))
# is 是身份判断
# == 判断的是值
# = 赋值



id






# chr 按照ascii码  把数字转换成字符
# print(chr(68))
# print(ord('D')) #按照ascii码  把字符转换成数字



chr


常用里不太常用的








#abs 绝对值
print(abs(-1))

# all 迭代所有对象判断是否是布尔值
print(all([1,2,3]))
print(all([]))  #空的可迭代对象也是返回true

# any 迭代所有对象，只要有一个是布尔值，就是true
print(any([0,2,3]))
print(any([])) ##空的可迭代对象也是返回False

#callable 判断是否是可调用对象
def func():
    print(callable(func))
func()

#dir 查看一个对象下边的属性
l=[]
print(dir(l))

# pow
Equivalent to x**y (with two arguments) or x**y % z (with three arguments)
print(pow(20,2)) #两个数就相乘
print(pow(20,2,3)) # 三个数就 x**y % z

#round  默认 四舍五入 取整数
print(round(3.94154335))
print(round(3.94154335,3)) #后边的参数 表示保留几位小数  四舍五入

#slice 让切片重复利用
l=['a','b','c','d']
s=slice(1,4,2) #开始位置，结束位置，步长
print(l[s])



abs all any callable dir pow round slice 


了解的


compile
eval
exec
format 和字符串的format 不一样 没什么用 不讲


hash 不怎么用






#evel  可以自己指定作用域
x=1
cmd='print(x)'
eval(cmd) #本来字符串是不可以执行的 eval可以解决
'''
1
'''

#exec compile
s='for i in range(10):print(i)'
code=compile(s,'','exec') #编译成可执行的结果
exec(code) #执行
'''
0
1
2
3
4
5
6
7
8
9

'''



exec compile eval






#hash 得到一个hash值  hash不可逆
print(hash('dkfhdkhfkdhf'))



hash




        

	      

	    

	  

	  

	    
      
        【推广】
        免费学中医，健康全家人
      
	  

    

    

          原文地址：https://www.cnblogs.com/lazyball/p/7298375.html