python内置函数

《callable  ['kɔːləb(ə)l] 》

判断是否能被调用

print(callable(print))
a = 1
print(callable(a))

结果：
    True
    False

《help》《dir》

查看都有什么功能

print(help(str)) #详细
print(dir(str))  #不那么详细
结果：
class str(object)
 |  str(object='') -> str
 |  str(bytes_or_buffer[, encoding[, errors]]) -> str
 |  
 。。。。

['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

《import》

#某个方法属于某个数据类型的变量就用.调用
#如果某个方法不依赖于任何数据类型，就直接调用 -- 内置函数 和自定义函数

timea = __import__('time')
print(timea.time()) #一般都不这么写
import time
print(time.time())
结果：
1536909573.9048362
1536909573.904869
#结果是时间戳

《open》

打开文件

f = open()
print(f.writable()) #能不能写 是False 是不可写 True 可写
print(f.readable()) #能不能读 是False 是不可写 True 可写

《id》《hash》

id号和hash值

id() #内存id号
hash() #hash值
print(hash([])) #不可哈希 （字符串 数字 元祖 可哈希）
对于相同可hash的数据的 hash值在一次程序的执行过程中 总是不变的

《print》

打印

print('123\n',end='') #注意print end参数默认就是有'\n'
print(1,2,3,4,5,6,sep='|') #指定输出多个值之间的分隔符
f = open('file','w')
print('aaa',file=f) #输出定向 不输出屏幕了 直接输出到文件里面
#进度条
import time #因为Mac电脑执行快 自己修改sleep时间 自己测试
for i in range(0,101,2):
    time.sleep(0.5)
    char_num = i // 2
    res ='\r%s%% : %s\n' %(i,'*'*char_num) \
        if i == 100 else '\r%s%% : %s' %(i,'*'*char_num)
    print(res,end='',flush=True)

《compile [kəm'paɪl] 》

编译字符串执行

编译字符串执行
###流程类型exec
code1 = 'for i in range(0,10):print(i)'
compile1 = compile(code1,'','exec')
exec(compile1)
####简单计算类型eval
code2 = '1 + 2 + 3 + 4'
compile2 = compile(code2,'','eval')
print(eval(compile2))
#####single交互类型
code3 = 'name = input("please input your name:")'
compile3 = compile(code3,'','single')
exec(compile3)  #执行这段代码 会产生一个name的变量
print(name)  #name是存在的 字符串相关的代码 其实name是存在的

《exec [ɪg'zek; eg-] 》《eval  [ɪ'væl] 》

可以执行字符串代码类型的代码

exec('print(123)')
eval('print(123)')   #正常的python语句都可以执行

print(eval('1+2+3+3'))   #有返回值   ---有结果的简单计算
print(exec('1+2+3+3'))  #没有返回值   ----简单流程控制
exec和eval都可以执行字符串类型的代码 eval有返回值 exec没有返回值
eval只能用在你明确知道你要执行的代码是什么
例子：
code = '''for i  in range(10):
    print(i*'*')
'''
exec(code)

《bool》《int》《float》《complex ['kɒmpleks] 》

这个没什么可以说的 True False 数字 小数 复数

bool    #布尔值
int     #整数
float   #浮点 
complex #复数 不能比较大小 是由 实数 + 虚数 == 复数
##数据强制转换时候 用

《bin》《oct》《hex》

print(bin(10)) #转换成二进制      0b 代表二进制
print(oct(10)) #转换成八进制      0o 代表八进制
print(hex(10)) # 转换成十六进制    0x 代表十六进制

《abs》

绝对值

print(abs(-5))
结果：5
#求绝对值

《divmod》

返回一个元组 第一个值是除法得知 第二个值是除不尽剩余的数字

print(divmod(7,2))  #div除法  mod 取余 7➗2=3余1 结果是（3，1）
print(divmod(500,40))  #分页用的比较多 一共有五百条记录 每页我准备放四十条 我能放几页 最后一页放几条

《round [raʊnd] 》

控制小数点

print(round(3.13159,3)) #小数的精确  后面的保留2位

《pow》

幂运算

print(pow(2,3)) #求幂运算  完全等于2**3 2的3次幂
print(pow(2,3,3))  #2的3次方 8取余3 就是2
print(pow(3,2,1))
print(2**3)

《sum》

求和

sum(iterable=[1,2,3,4,5],start='')  #第二个参数不允许关键字传参
sum(可迭代，从几开始加可迭代序列)
sum([1,2,3,4,5])

《min》《max》

最小值 最大值

print(min([1,2,3,4,5]))
print(min(1,2,3,4,-1))
print(min(1,2,3,4,5,6,-4,key = abs)) #key 已绝对值判断最小值

print(max(1,2,3,4,5,6,7))
print(max(1,2,3,4,5,6,-10,key = abs)) #key 已绝对值判断最大值

#min max 函数计算大小 要等key对应的函数执行结果出来后，计算

 《list》《tuple》

列表 元组

list = [1,2,3,4,5] #可变类型
tuple = (1,2,3,4,5) #不可变类型
#强制转换用

#python有哪些数据类型 int bool 。。。
#python有哪些数据结构：dict list tuple set str 重点不能忘的 dict tuple 别的语言没有

《reversed  [rɪ'vɜ:st] 》

倒序

l = [1,2,3,4,5]
l.reverse()
print(l)  #修改原列表
l2 = reversed(l)
print(l2) #返回一个迭代器 (iter)迭代器的关键字
print(list(l2)) #可以强制转换成list
for i in l2:
    print(i)
#返回一个反序的迭代器 保留愿列表

《slice [slaɪs] 》

这个函数可以定制 切片的规则

l = (1,2,23,213,5612,342,43)
sli = slice(1,5,2) #这块拿到是切片规则
print(l[sli])  #这是开始切
print(l[1:5:2]) #效果一样

《format》

调整格式

print(format('test','<20')) #左对其
print(format('test','>20')) #右对其
print(format('test','^20')) #居中

《bytes》

转换成bytes
我拿到的是gbk编码的 我想转成utf-8编码

print(bytes('你好',encoding='gbk').decode('gbk')) #unicode 转换成gbk的bytes
print(bytes('你好',encoding='utf-8').decode('utf-8')) #unicode 转换成utf-8

网络编程 只能传二进制
文件存储
照片，视频也是二进制
html网页 我们爬去到的也是bytes编码
以上拿到的数据都是bytes类型

《bytearray》

修改字节，对于大数据变量修改，某一小部分。只能通过字符编码来修改

b_array = bytearray('你好',encoding='utf-8')
print(b_array)
print(b_array[0])
#一般都是修改字节，对于大数据变量修改，某一小部分。只能通过字符编码来修改

《 memoryview  ['mem(ə)rɪ]  [vjuː] 》

切片 bytes 

l = 'adsasdasdasd'
v= memoryview(bytearray(l,'utf-8'))
print(v)
#切片---字节类型的切片 不占内存 你能看到就是字节 你转换成字符串就占空间了

《ord》《chr》

print(ord('你'))  #打印ASCII值
print(ord('a'))
print(ord('1'))
print(chr(49))  #ASCII 数值对应的字符串
print(chr(97))
print(chr(20320))
#返回值是对应的十进制整数。按照unicode 

《ascii》

ascii表 对照信息 如果没有就转成\u

print(ascii('你'))
print(ascii('ni'))
print(ascii('1'))
print(ascii(10))
#只要是ascii码中的内容，就打印出来，不是就转换成\u

《 repr 》

保持原样

name = 'egg'
print('你好%r'%name)
print(repr('1'))
print(repr(1))
#让变量原封不动的输出出来 

《len》

字符串长度

print(Len('asdasdasdasd))

《enumerate  [ɪ'njuːməreɪt] 》 

索引跟列表 组合  返回值：（列表索引，列表的元素）

l = [1,2,3,4,5,'a','b',[10,11,12]]
print(list(enumerate(l)))
#组合 为一个索引值 和列表值 的序列

《all》《any》

all判断可迭代对象里面是否存在空值，0，None, 就是False

any 判断可迭代对象里面只要有一个不是空置，0，None 就是True

print(all(['1','',123]))  #接受一个可迭代的
print(all(['a','123',]))
print(all([0,'123']))
#任何一个空值或着0 都是false
print(any([1,' ',None]))

《zip》

拉链 把两个可迭代的 组合多个元组

l = [1,2,3,4,5,6,7,8,9]
l2 = ['a','b','c','b','e','f']
l3 = (1,2,3,4,5,6)
l4 = {1,2,3,4,5}
l5 = {'a':1,'b':2}

res = zip(l,l2,l3,l4,l5) #得到的是可迭代对象
print(list(res))

结果：
[(1, 'a', 1, 1, 'a'), (2, 'b', 2, 2, 'b')]
 

《filter》

遍历序列中的每个元素，判断每个元素得到布尔值，如果是True则留下来（组合为一个索引序列,可迭代对象）

#filter(函数名称,可迭代对象)
def is_odd(x):
    return x % 2 == 1 #如果等于1 就是True 不等于就是False
print(list(filter(is_odd,[1,2,3,4,5,6,7])))
#每次list里面出来取函数里面取计算，true留下 False 不要了
#判断列表中的空值
def is_none(x):
    return x and str(x).strip()
# return 是 print(bool(x))==True and print(bool(srt(x).strip()))==True 所有前后都是true的留下
print(list(filter(is_none,[1,2,3,'','asd d',None,'asd'])))

问题：请利用filter()过滤出1～100中平方根是整数的数

from math import sqrt #导入模块 sqrt 就是开平方
def func(x):
    res = sqrt(x) #进行开平方运算
    return res % 1 == 0
print(list(filter(func,range(0,101)))) 
结果：
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

《map》

处理序列中的每个元素，得到的结果是一个‘列表’，该‘列表’元素个数及位置与原来一样

print(list(map(abs,[1,-1,2,-4])))
#结果：
[1, 1, 2, 4]
#执行前后元素个数不变
    #值可能发生改变

《sorted》

排序，可以自己写函数规则进行可迭代序列的各种排序方法

#--------------------sort------------------
l = [1,-4,6,5,-10]
l.sort(key = abs) #在原来的列表基础上 进行排序
print(l)
#-------------------------------------------
#--------------------sorted------------------
print(sorted(l, reverse = True)) #从大到小排序
print(sorted(l, reverse = False)) #从小到大排序
print(l) #保留了原来的列表
#sorted 只有在数据小，想保存原列表时候在考虑在用
#--------------------------------------

问题：列表按照每一个元素的len排序

l = ['123123','asdqsda',[1,2,3,1,2,3,1,2,3],'找小四','0.111']
def func(x):
    return len(str(x))
print(sorted(l,key = func,reverse = True))
结果：[[1, 2, 3, 1, 2, 3, 1, 2, 3], 'asdqsda', '123123', '0.111', '找小四']
#可能有更好的办法此处不一一举例

 匿名函数lambda

lambda 参数，参数2:返回值表达式

和五个特殊的内置函数可以结合使用(max,min,filter,map,sorted)

calc = lambda x,y: x+y
print(calc(2,3))
结果：5
-------------------------------------------------------------------------------------------
#判断下列字典中values最大的
dic={'k1':10,'k2':100,'k3':30}
print(max(dic,key = lambda k:dic[k]))  #字典的key值 每次都会被带入lambda里面 dic[key] == values
-------------------------------------------------------------------------------------------
l = [1,2,3,4,11,22,33,445,2123,12315123]
print(min(list(filter(lambda x : x > 10,l))))  #结果是11
#先把l中的每个元素经过filter函数里面的lambda表达式比对出来，在进行min函数比对
-------------------------------------------------------------------------------------------
#.现有两元组(('a'),('b')),(('c'),('d')),请使用python中匿名函数生成列表[{'a':'c'},{'b':'d'}]
#考的知识点 zip map lambda 迭代器 匿名函数 内置函数
res = zip((('a'),('b')),(('c'),('d')))
ret = map(lambda x : {x[0]:x[1]},res)
print(list(ret))
print(list(map(lambda x : {x[0]:x[1]},zip((('a'),('b')),(('c'),('d'))))))