lambda表达式
简单函数可用lambda表达式
1.
def f1() return(123) r1=f1() print()
2.
f2=lambda:123 r2=f2() print()
以上两个的功能是一样的
1.
def f1(a1,a2) return(a1+a2)
2.
f2=lambda a1,a2:a1+a2
以上两个的功能是一样
python的内置函数
abs（）
i=abs(-123) print(i) 结果为123
abs（）的作用是绝对值
all()
循环参数，如果每个元素都为真，那么all的返回值为真
0、None、空字符串（有空格不算）、空列表、空字典、空元组==>0、None、空值这些为假
i=all（1,0）
any()
循环参数，只要有一个为真，就为真
i=any（1,0）
ascii()
去对象的类（列表list，字典dict）中找__repr__,获取期返回值
ascii(对象)
例如
1、
class foo：#创建了一种新的数据类型（？） def __repr__(self): return "hello" obj=foo()#创建了一个foo类的变量（就像list，dict一样） r=ascii(obj)执行ascii()这个函数以后就去它的类中寻找__repr__,并获取其返回值 print(r)#在这里输出的是hello
2、
li=list() r=ascii(li) print(r) #结果是：[]
进制
bin()#二进制 r=bin(11) print(r) #0b1011 oct()#八进制 r = oct(11) print(r) #0o13 int()#十进制 hex()#十六进制 r = hex(20) print(r) #0x14
进制转换
二进制转十进制
i=int("0b111",base=2) print(i) #结果是：7
八进制转十进制
i=int("0o120",base=8) print(i) #结果是：80
十六进制转十进制
i=int("0x100",base=16) print(i) #结果是：256
bool()
判断换真假，把一个对象转换成布尔值(之前说的空值，None)假的False，真的True
bytes 字节
字节和字符转的转换
bytes(“xxxx”,encoding=”utf-8″)
bytearray 字节列表（字节数组）
chr()
接收一个数字，找到这个数字对应ascii的元素
x=chr(66) print(x)#输出ascii值为66对应的字符 结果为 B
ord()
接收一个字符找到这个字符所对应的ascii码
i=ord("B") print(i)#输出这个字符所对应的ascii码 #ascii码 一个字节 8位 2**8 256个
生成随机数
import random i=random.randrange(65,9)#生成一个在65到90之间（65<=x<90）的随机数 print(i) c=chr(i) print(c)
随机数生成一个6位的验证码
1、
temp="" for i in range(6) 0<= <6 num=random.randrange(0,4) if num==3 or num==1: rad2 = random.randrange(0,10) temp=temp+str(rad2)#把数字类型转换为字符类型然后再用"+" #添加到temp字符串里 else rad1 = random.randrange(65,91) c1=chr(rad1) temp=temp+c1
2、
import random temp = "" for i in range(6): num = random.randrange(0, 4) if num == 3 or num == 1: rad2 = random.randrange(0, 10) temp = temp + str(rad2) else: rad1 = random.randrange(65, 91) c1 = chr(rad1) temp = temp + c1 print(temp)
callable()
对象是否可以被执行
def f1(): return 123 f1() r=callable(f1) print(r) #结果为 True
classmethod()
#暂无解释
compile
接收一个字符串把这个字符串编译成python可以执行的代码
complex() #！
complex() 函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。
如果第一个参数为字符串，则不需要指定第二个参数。
#复数？？
#网上实例
>>>complex(1, 2) (1 + 2j) >>> complex(1) # 数字 (1 + 0j) >>> complex("1") # 当做字符串处理 (1 + 0j) # 注意：这个地方在"+"号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，否则会报错 >>> complex("1+2j") (1 + 2j)
delattr()
getattr()
hasattr()
setattr()
反射
dict（）
字典
dir()
查询某个类提供了什么功能
li=[] print(dir(li))
结果：[‘__add__’, ‘__class__’, ‘__contains__’等很多
查看详细功能信息
help
help(dict)
divmod()
r=divmod(10,3) print(r)#结果为(3, 1)
元组形式显示商和余数
eval()
eval() 函数用来执行一个字符串表达式，并返回表达式的值，有返回值
a="1+3" print(a) ret=eval("1+3")#把字符串转换为表达式 print(ret) #结果为 4
实例
>>>x = 7 >>> eval( '3 * x' ) 21 >>> eval('pow(2,2)') 4 >>> eval('2 + 2') 4 >>> eval("n + 4") 85
exec
执行一个字符串内的代码,无返回值(返回值为None)
exec("print(123)")
comple
编译py代码
filter() 150 11.20
循环可迭代的对象，获取每一个参数，在函数里执行参数
函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。
该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，
然后返回 True 或 False，最后将返回 True 的元素放到新列表中。
filter(函数，可迭代的对象)
实例
1、
def f1(x): if x>22: return True else: return False ret = filter(f1,[11,22,33,44]) #把返回True的放到ret中 for i in ret: #用循环输出ret print(i)
2、
def f1(x): return x>22 #当着个为真就返回True，由于该函数可以在简单化所以看 3、 ret = filter(f1,[11,22,33,44]) for i in ret: print(i)
3、
ret=filter(lambda x: x>22,[11,22,33,44]) for i in ret : print(i)
结果为 33 44
4、filter()函数详情
def myfilter(func,seq): #func函数名 result = [] for i in seq: #func = f1 #func(x)执行f1函数，并获取返回值，将其赋给ret ret = func(i) if ret: result.append(i) return result def f1(x) if x>22: return True else: return False r = myfilter(f1,[11,22,33,44]) print(r)
map()
map() 会根据提供的函数对指定序列做映射。
第一个参数 function 以参数序列中的每一个元素调用 function 函数，
返回包含每次 function 函数返回值的新列表。
map(函数，可迭代的对象)
def f1(x): return x+100 ret = map(f1, [1,2,3,4,5]) for i in ret: print(i)
结果为101
102
103
104
105
ret = map(lambda x:x+100, [1,2,3,4,5]) for i in ret: print(i)
#lambda是用于简单函数的所以可以用于上面的函数，尽管lambda只
能用于简单函数但其可使用三元运算
ret = map(lambda x:x+100 if x%2 == 1 else x, [1,2,3,4,5]) for i in ret: print(i)
mymap()函数详解
def mymap(fun,arg): #fun=>x函数 #arg=>li列表 result = [] for i in arg: ret = fun(i) result.append(ret) return result #这个只能说和map类似
format()
字符串格式化
frozenset
不能添加元素的set格式
globals()
获取当前代码里的所有的全局变量
local()
获取当前代码里的所有的局部变量
hash()
hash() 用于获取取一个对象（字符串或者数值等）的哈希值
一般用于字典key的优化
id()
内存地址
isinstance()
判断某个对象是否由某一个类创建的
li=[11,22,33] t=isinstance(li,list) print(t) 结果 True a=isinstance(li,dict) print(a) 结果 False
如果某个类是当前类的父类也是支持的
issubclass()
看看是不是子类
iter()
创建一个可以迭代的对象
next()
上面那个可迭代的对象运行一个next就去一个值，取下一个值
a=iter([11,22,33,44]) print(a) r1=next(a) print(r1) #结果 11 r2=next(a) print(r2) #结果 22
max()
找到最大值
min()
找到最小值
li=[11,22,33,44] t=max(li) print(t) #结果 44 z=max(li) print(z)# 结果 11
memoryview()
根据索引判断某个对象的的地址是多少
函数返回给定参数的内存查看对象(Momory view)。
所谓内存查看对象，是指对支持缓冲区协议的数据进行包装，在不需要
复制对象基础上允许Python代码访问。
object()
open()
文件操作
pow()
i=pow(2,10) #2的10次方 print(i) #结果 1024
property()
repr()
返回__repr__的值
repr() 函数将对象转化为供解释器读取的形式
reversed()
反转 倒置
round()
四舍五入
e=round(3.6) #4
slice()
slice() 函数实现切片对象，主要用在切片操作函数里的参数传递
li[0:2]==>特殊的方法 __sliceitem__
sorted()
排序
li = [1, 22, 33, 222, 3, 1] print(li) le = sorted(li)# 生成新的值，不对原来的变量进行改变 print(le) #这个只能对同一个类型的进行排序 print(li) li.sort() # 不生成新的值，对原来的变量进行改变 print(li)
结果
[1, 22, 33, 222, 3, 1]
[1, 1, 3, 22, 33, 222]
[1, 22, 33, 222, 3, 1]
[1, 1, 3, 22, 33, 222]
实例
li = ["123","1","张","a","99","c","you","鈾","---","_","A","b","0","你","王",] print(li) le = sorted(li)# 生成新的值，不对原来的变量进行改变 print(le) for i in le: print(bytes(i,encoding="utf-8"))
结果：
[‘123’, ‘1’, ‘张’, ‘a’, ’99’, ‘c’, ‘you’, ‘鈾’, ‘—‘, ‘_’, ‘A’, ‘b’, ‘0’, ‘你’, ‘王’]
[‘—‘, ‘0’, ‘1’, ‘123’, ’99’, ‘A’, ‘_’, ‘a’, ‘b’, ‘c’, ‘you’, ‘你’, ‘张’, ‘王’, ‘鈾’]
b’—‘
b’0′
b’1′
b’123’#数字是先比较第一个元素，谁小谁在前面，第一个样就比第二个
b’99’
b’A’
b’_’ #字母比较ascii码，先比较第一个元素，谁小谁在前面，第一个
b’a’ #一样就比第二个
b’b’
b’c’
b’you’
b’/xe4/xbd/xa0’#汉字比十六进制的大小
b’/xe5/xbc/xa0′
b’/xe7/x8e/x8b’
b’/xe9/x88/xbe’
staticmethod()
sum()
t=sum([11,22,33])
print()
super()
找到父类
tuple()
查看类型
vars()
查看当前对象有多少变量
zip()
li=[11,22,33,44] li2=["a","VV","c","aa"] r=zip(li,li2) print(r) for i in r : print(i)
结果为 ：
<zip object at 0x00000059C0191748>
(11, ‘a’)
(22, ‘VV’)
(33, ‘c’)
(44, ‘aa’)
__import__
导入一个模块
import random
random.randrange()
下面那个相当于做了一个别名
r=__import__(random)
r.randrange()
原创文章，作者：ItWorker，如若转载，请注明出处：https://blog.ytso.com/tech/pnotes/12374.html