内置函数

Posted 2020-10-01 Lazyball

内置函数有如下：

根据分类学习会容易些

与数据类型有关的

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

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