1、map函数
#首先我们定义我们自己的map
def my_map(func,array): #定义的这个函数可以传入另一个指定的处理函数
ret = [] #定义一个空列表，可以将原来的值一个个经过处理后拿到这个新列表来
for i in array:
res=func(i) #将每一个值传入指定的处理函数后赋值给res
ret.append(res) #此时将一个个处理后的res添加到我们的空列表ret中
return ret #当所有值都处理完后，此时ret不再是空列表，而是一个个我们需要的值组成的列表
li = [1,2,10,5,3,7] #要求：将列表中每一个值+1得到一个新的列表
#此时我们调用属于自己创建的map函数
res = my_map(lambda x : x+1,li)
print(res)
#若直接使用真正的map函数则为
res = list(map(lambda x : x+1,li))
print(res)
#处理序列中的每个元素，得到的结果是一个‘列表’，该‘列表’元素个数及位置与原来一样
2、filter
#首先我们定义我们自己的filter
def my_filter(func,array): #定义的这个函数可以传入另一个指定的处理函数
ret = [] #定义一个空列表，可以将原来的值一个个经过处理后拿到这个新列表来
for i in array:
if func(i): #用指定函数处理列表中的每个值
ret.append(i) #此时将每个符合条件的i添加到我们的空列表ret中
return ret #当所有值都处理完后，此时ret不再是空列表，而是一个个我们需要的值组成的列表
li = ['a_man','b_man','c_woman','d_man'] #要求：将列表中的有'man'的元素去掉得到新列表
#此时我们调用属于自己创建的filter函数
res = my_filter(lambda x : endswith('woman'),li)
print(res)
#若直接使用真正的filter函数则为
res = list(map(lambda x : endswith('woman'),li))
print(res)
#遍历序列中的每个元素，判断每个元素得到布尔值，如果是True则留下来
3、reduce
#首先我们定义一个自己的reduce函数
def my_reduce(func,array,init): #可以传入函数、值和参数（默认None）
if init is None:
res = array.pop(0) #如果参数是默认，把列表的第一个值拿出来，此时res中没有第一个值
else:
res = init #如果有参数，把它赋值给res
for i in array:
res = func(res,i) #将每一个i和res放入处理函数中，得到res
return res
li = [1,2,100] #要求：将每个数相乘，并且再乘10
#此时我们调用自己的reduce函数
res = my_reduce(lambda x,y : x*y,li,10)
print(res)
#若直接使用真正的reduce函数
from functools import reduce
res = reduce(lambda x,y : x*y,li,10)
print(res)4、divmod
#设置页码和每页内容
#divmod('一共有多少内容','每页可以填多少内容')
例如：要求做网页内容，每页最多5条内容，一共21条内容
print(divmod(21,5))
输出：(4,1) #其中4表示4页填满，1表示还多出来一条内容，所以需要5页5、hash
#可hash的数据类型即不可变数据类型，不可hash的数据类型即可变数据类型
name='alex'
print(hash(name))
print(hash(name))
-7665267407493081588 #hash值
-7665267407493081588
可以用来检测下载下来的文件是否被改动或者传入木马之类，只要有改动hash值将会改变
6、zip（拉链函数）、sort 以及 max和min
print(list(zip(('a','n','c'),(1,2,3))))
print(list(zip(('a','n','c'),(1,2,3,4))))
print(list(zip(('a','n','c','d'),(1,2,3))))
输出：
[('a', 1), ('n', 2), ('c', 3)]
[('a', 1), ('n', 2), ('c', 3)]
[('a', 1), ('n', 2), ('c', 3)]
#所得值会一一对应产生新的元组，若剩下无另一半的值，将会被消除
p={'name':'alex','age':18,'gender':'none'} #传入字典
print(list(zip(p.keys(),p.values())))
print(list(p.keys()))
print(list(p.values()))
输出：
[('name', 'alex'), ('age', 18), ('gender', 'none')]
['name', 'age', 'gender']
['alex', 18, 'none']
print(list(zip(['a','b'],'12345')))
输出：[('a', '1'), ('b', '2')]l=[1,3,100,-1,2]
print(max(l))
print(min(l))
100
-1
#若是在字典自作比较
age_dic={'az_age':18,'bd_age':20,'xa_age':100,'hi_age':30}
print(max(age_dic))
xa_age #默认比较的是key，此时比较的是字母排序大小，从第一个开始比，若第一个出结果则直接比较完成，以此类推
print(max(age_dic.values())) #此时比较的是value，但并不能获取该value的key
#则用zip：
li = zip(age_dic.values(),age_dic.keys()) #将value放在前面，则可以同时得到最大vlaue的key值
print(list(max(li)))
[100, 'xa_age']
#min的用法相同不同类型之间不能进行比较
排序，本质上是比大小
l=[3,2,1,5,7]
l1=[3,2,'a',1,5,7]
print(sorted(l))
print(sorted(l1)) #报错
[1, 2, 3, 5, 7]
#按value排序
people=[
{'name':'a','age':1000},
{'name':'w','age':10000},
{'name':'y','age':9000},
{'name':'l','age':18},]
print(sorted(people,key = lambda dic :dic['age'] ))
name_dic={
'abyuanhao': 11900,
'alex':1200,
'wupei':300,
}
print(sorted(name_dic)) #默认用key排序
print(sorted(name_dic,key=lambda key:name_dic[key])) #可以通过value排序但只能得到对应key
print(sorted(zip(name_dic.values(),name_dic.keys()))) #用zip可以得到value与key
age_dic={'az_age':18,'bd_age':20,'xa_age':100,'hi_age':30}
print(max(age_dic))
li = zip(age_dic.values(),age_dic.keys())
print(list(max(li)))
people=[
{'name':'a','age':1000},
{'name':'w','age':10000},
{'name':'y','age':9000},
{'name':'l','age':18},]
max(people,key=lambda dic:dic['age'])
print(max(people,key=lambda dic:dic['age'])) #用了匿名函数取age的最大值
{'name': 'w', 'age': 10000}文件的读取和写入
f=open('sss',encoding='utf-8') #打开一个系统文件，并声明编码，否则会报错，windows默认gbk
data=f.read()
print(data)
f.close() #记得关闭
打开模式：
r只读，r+读写（先把文件读到内存里，才可以在内存里进行操作），不创建，a为添加到最后一行（访客列表）
w新建只写，w+新建读写，二者都会将文件内容清零
（以w方式打开，不能读出。w+可读写）
w+与r+区别：
r+：可读可写，若文件不存在，报错；w+: 可读可写，若文件不存在，创建
#test文件：asb
123
f=open('test','r',encoding='utf-8') #假设test是系统中的一个文件
data=f.read() #将他设置为只读
print(data) #此时就可以查看该文件了
f.readable() #判断文件是否为只读
print(f.readline()) #打印文件第一行
print(f.readline()) #打印文件第二行
print(f.readlines()) #打印每一行
f.close()
#readline是逐行打印，逐行跳转
#readlines是打印所有，即直接跳转到f.close()
f=open('test','w',encoding='utf8')
#f.read() #该行会报错，因为是w模式
f.write('11111111\n')) #记得要换行符
f.write('222222222\n')
f.write('333\n4444\n555\n')
f.writable()
f.writelines(['555\n','6666\n'])
#f.writelines(['555\n','6666\n',1]) #文件内容是字符串，所以应该用write
f.close()
#修改（不存在修改，全都是覆盖）
f1 = open('xxx','r',encoding='gbk') #此时文件只读
data = f1.readlines() #拿到data并存下来了，data是xxx文件的第一行
f1.close() #拿到data，即可关闭
f2 = open('xxx','w',encoding='gbk') #此时文件只写
f2.write(data[0]) #将data通过索引，字符串用write。此操作只保留第一项'asb'
dst_f.close()
write用于字符串，writelines用于列表
with
#可以不用手动close，自动关闭
with open(test,'w',encoding = 'utf8') as f:
f.write('...')
#打开多个
with open(test1,'r',encoding = 'gbk') as f1,\
open('test2','w',encoding='gbk') as f2:
data = f1.read()
f2.write(data)
f=open('a.txt')
print(f.encoding) #查看文件编码b模式下打开文件（读的就是原生二进制）
1、以b方式打开时，读取到的内容是字节类型，写入时也需要提供字节类型，不能指定编码
2、 读出来的结果说明：\r\n是windows下的“回车键”，而linux中的回车键是“\n”，读取时会多2个字节的光标
3、'字符串'——encode——bytes 称为编码（需要指定字符编码）x.encode('utf-8')，bytes——decode——'字符串' 称为解码
4、文件不仅仅有文本类型，还有图片、视频等，而图片、视频等都是使用二进制的方式进行处理的，因此需要使用b的方式去处理，可用于处理任何类型的文件，可以跨平台
5、f.flush()
对暂存在内容中的内容进行刷入硬盘内存保存
这个常见于pycharm、word等文档软件，每隔一定时间对文档的内容进行保存处理
6、f.tell()
读取光标当前位置，注意windows的换行符是/r/n
7、f=open('b.txt','r',encoding='utf-8',newline='') #读取文件中真正的换行符号
python会统一自动处理成/n
8、seek()
文件asd为：
你好
123
f = open('asd','r',encoding = 'utf-8',newline = '')
f.readline()
f.seek(1)
print(f.tell()) #会报错，以为汉字占三个字节，此时移动1一个字节，无法取‘部分你’
f.seek(3)
print(f.tell()) #此时光标在1
print(f.read()) #会读出‘你’以后的内容
##默认连续两次的seek不会叠加光标位置，每次都会返回到0的位置重新开始移动
##这两种模式必须以b模式打开
f.seek(3,1) #此时不会重新返回0开始，而是从上次的位置开始
f.seek(-3,2) #倒序，光标从最后一位倒着移动，此时必须###是负数#读取大文件的最后一行
f=open('d.txt','rb')
for i in f:
offs=-3 #偏移量，用于大概估算该文件的字节
n=0
while True:
f.seek(offs,2)
data=f.readlines()
if len(data) > 1:
print('最后一行',data[-1])
break
offs*=2
9、read()
只有它按字符不按字节走
文件asd为：
你好
123
data = f.read(4)
print(data)
输出：你好 （后面空的两个是/r/n）10、truncate()
首先是在写文件。
f.truncate(10) #截取到第10个字节处，之后的全删掉
扫一扫
5203
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
