lambda表达式、Python 内置函数、进制转换、随机验证码

 

简单的函数可以用lambda表达式

def f1():
    return  123
f2 = lambda : 123
 
 
def f3(a1,a2):
    return a1 +a2

f4 = lambda al,a2 : al+a2
    

py3的内置函数：

 

　　

#bool ， 判断真假，把一个对象转换成布尔值，
#bytes  字节
#bytearrary  字节列表{字节}
 # bytes ('sssfs',encoding='utf-8')

i=chr(66)  #ascii码
j=ord('a')  #ascii码
print(i)
print(j)

 

#abs绝对值
i = abs(-123)
print(i)

#all，循环参数，如果每个元素都是真，那么all的返回值为真
r = all([True,True])
print(r)
#每个元素都为True
r = all([True,True,False])
print(r)
#假 0 None ''  []  () {}   空值
print(bool({}))

#any只要有个真的 ，则为真。
i = any ([None,1])
print(i)

#ascii  ascil（对象） ，对象的类中找__repr__ ，获取其返回值。
class Foo:
    def __repr__(self):
        return  'Holle'

bin() #二进制
hex() # 十六进制
oct() #八进制
int() # 十进制

随机验证码实验

#生成一个随机数 65-90
#一个数字转换成字母，chr（数字）

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)

 dir(): 打印详细功能    help(list)

li = []
print(dir(li))

divmod

a = 10/3
print(a)
#相当于取余
r =  divmod(10,3)
print(r)

#eval直接计算出字符串'1+3' 的和，eval 可以执行一个字符形式的表达式。

ret = eval('1+3')

print(ret)

#eval可以在括号里后面加字典。意思是a=99.

ret = eval('a+3',{'a':99})
print(ret)
#exec 可以执行for，它没有返回值，会直接输出结果。
exec("for i in range(10):print(i)")

 

filter（函数，可迭代的对象）

#循环可迭代的对象，获取每一个参数，函数（参数）
def f1(x):
    if x > 22:
        return  True
    else:
        return False
ret = filter(f1,[11,22,33,44])
for i in ret:
    print(i)

#循环可迭代的对象，获取每一个参数，函数（参数）
def f1(x):
    if x > 22:
        return  True
    else:
        return False
ret = filter(f1,[11,22,33,44])
for i in ret:
    print(i)


#循环可迭代的对象，获取每一个参数，函数（参数）
def f1(x):
    if x > 22:
        return  True
    else:
        return False
ret = filter(lambda x: x>22 ,[11,22,33,44])
for i in ret:
    print(i)

map(函数，可迭代的对象)

ef f1(x):
    return x +100
ret = map(f1, [1,2,3,4,5])
for i in ret:
    print(i)


#map(函数，可迭代的对象)
def f1(x):
    return x +100
ret = map(lambda x : x+100, [1,2,3,4,5])
for i in ret:
    print(i)

#map(函数，可迭代的对象)
def f1(x):
    if x % 2 == 1:
        return x +100
    else:
        return x
ret = map(lambda x : x+100 if x % 2 == 1  else x, [1,2,3,4,5])
for i in ret:
    print(i)

globals()获取全局变量   locals（）获取全部局部变量

hash ()哈希  储存节省内存，给hash一个值，它会转换成一个值。

li = [11,22]

isinstance(li,list) # 判断某个对象是否是某个类创建的。

iter() #迭代器

 max（）取最大值

pow 求幂  pow(2,100)----->2的100次方

i = pow(2,100)
print(i)
round  四舍五入

i=round(3.3)
print(i)

sum 求和

zip

li =[11,22,33,44]
li2 = ['a','BB','C','E']
r = zip(li,li2)
for i in r:
    print(i)

 sorted()

li = [1,211,22,3,4]
print(li)
#给列表排序，列表里不能同时存在字符串和数字，否则自会报错
li.sort()
print(li)
#给列表排序，没有直接更改原来的列表，需要变量接收。列表里不能同时存在字符串和数字，否则会报错、
ret = sorted(li)
print(ret)

open 文件操作 ------>基本的打开方式

a ，追加模式不可读，上图有错误。

f = open('ha.log', 'r')#’r‘表示只读模式，默认是只读模式。
data = f.read()
f.close()
print(data)


f = open('ha1.log', 'w')#w，只写模式，[不可读；文件不存在则创建；存在则清空内容；]
data = f.write('123')
f.close()
print(data)



f = open('ha1.log', 'x')#x，只写模式，[不可读；文件不存在则创建；存在则报错；]
data = f.write('123')
f.close()
print(data)


f = open('ha1.log', 'a')#a，追加模式，[不可读；文件不存在则创建；存在则追加内容；]
data = f.write('123')
f.close()
print(data)

open  以字节的方式打开

#1、只读，rb

f = open('ha1.log', 'rb')
data = f.read()
f.close()
print(data)

#2、只写 ，wb  需要把需要写入的字符串，转换成字节。
f = open('ha1.log', 'wb')
f.write(bytes('中国', encoding='utf-8'))
f.close()

普通打开模式：Python默认有转换器把二进制转换成字符。

以字节方式打开：写入的时候，需要自己手动把字符串转换成字节

# r+,w+,x+,a+
#r+ ，读写【可读  可写】
f = open('ha.log', 'r+', encoding='utf-8')
#指针为0，起始位置
print(f.tell())

data = f.read(1)
print(type(data),data)

# f.seek(3) #调整指针
print(f.tell())

f.write('SB')

print(f.tell())

f.close()

#w+,先清空，在写的之后，就可以读了。先清空，之后写的才能读，写，指针到最后。
f = open('ha.log', 'w+', encoding='utf-8')
f.write('何莉莉')
f.seek(0)
data = f.read()
f.close()
print(data)

#x+,如果文件存在，会报错。先清空，之后写的才能读，写，指针到最后。
f = open('ha.log', 'x+', encoding='utf-8')
f.write('何莉莉')
f.seek(0)
data = f.read()
f.close()
print(data)

#a+  打开的同时指针已近到最后。
#a+ 写时，追加，放到最后。
f = open('ha.log', 'a+', encoding='utf-8')
data = f.read()
print(data)
f.seek(0) #调整指针位置
data = f.read()
print(data)
f.close()
f.tell() # 查看指针位置

f1.flush()  #把内存的内容写进硬盘。

close

flush #把内存的内容写进硬盘

read

readline 读取一行

seek

truncate 截取一行

write

with open('ha.log','r') as f: #不用手写关闭文件（f.close()），自动关闭
    f.read()
with 在Python2.7之后支持同时打开两个文件

with  open('log1','r') as obj1, open( 'log2', 'r' )  as obj2:

 with  open('log1','r') as obj1, open( 'log2', 'w' )  as obj2: #把log1 写入log2
     for line  in obj1:
         obj2.write(line)