内置函数

内置函数

print(abs(-1))    # 1 求绝对值
print(all([1,'aaa','1']))   # 可迭代对象所有元素的bool值都为True则为True
print(all([]))              # 或可迭代对象为空返回True

print(any([0,None,1]))   # 可迭代对象中任意一个元素的bool值为True则为True
print(any([]))           # 或可迭代对象为空返回False

print(bin(11))  #十进制转换成二进制
print(oct(11))	#十进制转换成八进制
print(hex(11))  #十进制转换成十六进制

print(bool('')) # 布尔值

def func():
    pass
class Foo:
    pass
print(callable(Foo)) # 判断某个对象是不是可以被调用

print(chr(65))  # 数字变ASCii  65-90大写字母，97-122小写字母
print(ord('A')) # ASCii变数字

s=frozenset({1,2,3})  #不可变集合 不能增 删 改

hash(不可变类型) # 哈希算法

print(round(1.5))  # 四舍五入
print(round(1.4))  # 四舍五入

print(pow(10,2,3))   #相当于10 ** 2 % 3

s=slice(1,4,2)  # 用来切片
l1=['a','b','c','d','e']
l2=['aaa','bbb','ccc','ddd',444]
print(l1[1:4:2]) # l1[s] s=slice(1,4,2)  # 用来切片
print(l2[1:4:2]) # l2[s] s=slice(1,4,2)  # 用来切片
-----------------------------zip----------------------------
# 拉链函数 #拼接成小元组
v1 = 'helloy'
v2 = [111, 222, 333, 444, 5555, 6666]
res = zip(v1, v2) 
print(dict(res))  # {'h': 111, 'e': 222, 'l': 444, 'o': 5555, 'y': 6666}
print(list(res))  # [('h', 111), ('e', 222), ('l', 333), ('l', 444), ('o', 5555), ('y', 6666)]
---------------------------divmod---------------------------
print(divmod(10000,33))  # (303, 1) #商和余数  算页数 
-----------------------------dir----------------------------
class Foo:
    pass
obj=Foo()
obj.xxx=1111
print(dir(obj)) # obj.哪些属性['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'xxx']
--------------------------enumerate-------------------------
for i,v in enumerate(['a','b','c']):    #  枚举
    print(i,v)
>>>0 a
>>>1 b
>>>3 c
-----------------------------eval---------------------------
res=eval('{"a":1}') # 执行字符串中的表达式
print(res,type(res))   #  {'a': 1} <class 'dict'>
-------------------------isinstance---------------------------
class Foo:
    pass
obj=Foo()
print(isinstance(obj,Foo))
print(isinstance([],list)) # 类型判断推荐使用isinstance
print(type([]) is list) # 不推荐使用
---------------------------__import__--------------------------
import 'time' # 错误  #import不能导入字符串
time=__import__('time')
time.sleep(3)

format

#字符串可以提供的参数 's' None
>>> format('some string','s')
'some string'
>>> format('some string')
'some string'

#整形数值可以提供的参数有 'b' 'c' 'd' 'o' 'x' 'X' 'n' None
>>> format(3,'b') #转换成二进制
'11'
>>> format(97,'c') #转换unicode成字符
'a'
>>> format(11,'d') #转换成10进制
'11'
>>> format(11,'o') #转换成8进制
'13'
>>> format(11,'x') #转换成16进制 小写字母表示
'b'
>>> format(11,'X') #转换成16进制 大写字母表示
'B'
>>> format(11,'n') #和d一样
'11'
>>> format(11) #默认和d一样
'11'

#浮点数可以提供的参数有 'e' 'E' 'f' 'F' 'g' 'G' 'n' '%' None
>>> format(314159267,'e') #科学计数法，默认保留6位小数
'3.141593e+08'
>>> format(314159267,'0.2e') #科学计数法，指定保留2位小数
'3.14e+08'
>>> format(314159267,'0.2E') #科学计数法，指定保留2位小数，采用大写E表示
'3.14E+08'
>>> format(314159267,'f') #小数点计数法，默认保留6位小数
'314159267.000000'
>>> format(3.14159267000,'f') #小数点计数法，默认保留6位小数
'3.141593'
>>> format(3.14159267000,'0.8f') #小数点计数法，指定保留8位小数
'3.14159267'
>>> format(3.14159267000,'0.10f') #小数点计数法，指定保留10位小数
'3.1415926700'
>>> format(3.14e+1000000,'F')  #小数点计数法，无穷大转换成大小字母
'INF'

#g的格式化比较特殊，假设p为格式中指定的保留小数位数，先尝试采用科学计数法格式化，得到幂指数exp，如果-4<=exp<p，则采用小数计数法，并保留p-1-exp位小数，否则按小数计数法计数，并按p-1保留小数位数
>>> format(0.00003141566,'.1g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留0位小数点
'3e-05'
>>> format(0.00003141566,'.2g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留1位小数点
'3.1e-05'
>>> format(0.00003141566,'.3g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留2位小数点
'3.14e-05'
>>> format(0.00003141566,'.3G') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留0位小数点，E使用大写
'3.14E-05'
>>> format(3.1415926777,'.1g') #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留0位小数点
'3'
>>> format(3.1415926777,'.2g') #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留1位小数点
'3.1'
>>> format(3.1415926777,'.3g') #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留2位小数点
'3.14'
>>> format(0.00003141566,'.1n') #和g相同
'3e-05'
>>> format(0.00003141566,'.3n') #和g相同
'3.14e-05'
>>> format(0.00003141566) #和g相同
'3.141566e-05'

lambda与内置函数结合使用

字典的运算：最小值，最大值，排序
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')

salaries_and_names是迭代器，因而只能访问一次
>>> min(salaries_and_names)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: min() arg is an empty sequence

sorted(iterable，key=None,reverse=False)

eval与exec

#1、语法
# eval(str,[,globasl[,locals]])
# exec(str,[,globasl[,locals]])

#2、区别
#示例一：
s='1+2+3'
print(eval(s)) #eval用来执行表达式，并返回表达式执行的结果
print(exec(s)) #exec用来执行语句，不会返回任何值
'''
None
'''

#示例二：
print(eval('1+2+x',{'x':3},{'x':30})) #返回33
print(exec('1+2+x',{'x':3},{'x':30})) #返回None

# print(eval('for i in range(10):print(i)')) #语法错误，eval不能执行表达式
print(exec('for i in range(10):print(i)'))

complie

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)

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

更多内置函数：https://docs.python.org/3/library/functions.html?highlight=built#ascii