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 + 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) #
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 = ["","","张","a","","c","you","鈾","---","_","A","b","","你","王",]
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()