内置函数(max,min,zip)及文件处理

Posted 2021-02-16 lishuaing

几个有意思的内置函数

max ， min最基本用法

l=[1,3,100,-1,2]
print(max(l))
print(min(l))

zip

 1 print(list(zip((‘a‘,‘n‘,‘c‘),(1,2,3))))
 2 print(list(zip((‘a‘,‘n‘,‘c‘),(1,2,3,4))))
 3 print(list(zip((‘a‘,‘n‘,‘c‘,‘d‘),(1,2,3))))
 4 
 5 p={‘name‘:‘alex‘,‘age‘:18,‘gender‘:‘none‘}
 6 print(list(zip(p.keys(),p.values())))
 7 print(list(p.keys()))
 8 print(list(p.values()))
 9 
10 print(list(zip([‘a‘,‘b‘],‘12345‘)))

[(‘a‘, 1), (‘n‘, 2), (‘c‘, 3)]
[(‘a‘, 1), (‘n‘, 2), (‘c‘, 3)]
[(‘a‘, 1), (‘n‘, 2), (‘c‘, 3)]
[(‘name‘, ‘alex‘), (‘age‘, 18), (‘gender‘, ‘none‘)]
[‘name‘, ‘age‘, ‘gender‘]
[‘alex‘, 18, ‘none‘]
[(‘a‘, ‘1‘), (‘b‘, ‘2‘)]　　

三者结合（）

 1 age_dic={‘alex_age‘:18,‘wupei_age‘:20,‘zsc_age‘:100,‘lhf_age‘:30}
 2 
 3 print(max(age_dic.values()))
 4 
 5 #默认比较的是字典的key
 6 print(max(age_dic))
 7 
 8 for item in zip(age_dic.values(),age_dic.keys()): #[(18,‘alex_age‘)  (20,‘wupeiqi_age‘) () () ()]
 9     print(item)
10 
11 print(‘=======>‘,list(max(zip(age_dic.values(),age_dic.keys()))))
12 
13 l=[
14     (5,‘a‘),
15     (1,‘b‘),
16     (3,‘e‘),
17     (4,‘d‘),
18 ]
19 # l1=[‘a10‘,‘b12‘,‘c10‘,100] #不同类型之间不能进行比较
20 l1=[‘a11‘,‘a2‘,‘a10‘] #不同类型之间不能进行比较
21 print(list(max(l)))
22 print(‘--->‘,list(max(l1)))

100
zsc_age
(18, ‘alex_age‘)
(20, ‘wupei_age‘)
(100, ‘zsc_age‘)
(30, ‘lhf_age‘)
=======> [100, ‘zsc_age‘]
[5, ‘a‘]
---> [‘a‘, ‘2‘]              #一位一位的比　　

三者结合（2）

 1 l=[1,3,100,-1,2]
 2 print(max(l))
 3 dic={‘age1‘:18,‘age2‘:10}
 4 print(max(dic)) #比较的是key
 5 print(max(dic.values())) #比较的是key，但是不知道是那个key对应的
 6 
 7 print(max(zip(dic.values(),dic.keys()))) #结合zip使用
 8 
 9 
10 people=[
11     {‘name‘:‘alex‘,‘age‘:1000},
12     {‘name‘:‘wupei‘,‘age‘:10000},
13     {‘name‘:‘yuanhao‘,‘age‘:9000},
14     {‘name‘:‘linhaifeng‘,‘age‘:18},
15 ]
16 # max(people,key=lambda dic:dic[‘age‘])
17 print(‘周绍陈取出来没有‘,max(people,key=lambda dic:dic[‘age‘]))
18 
19 ret=[]
20 for item in people:
21     ret.append(item[‘age‘])
22 print(ret)
23 max(ret)

100
age2
18
(18, ‘age1‘)
周绍陈取出来没有 {‘name‘: ‘wupei‘, ‘age‘: 10000}
[1000, 10000, 9000, 18]　

 

文件处理

###################################################################################

无论是gbk/utf-8，它们都只是一种编码规则，一种把Unicode数据编码成字节数据的规则

内存中是Unicode编码的
open()编码方式默认是操作系统的

Python3.x，默认编码、编码方式均为 encoding=”utf-8

py2默认ASCII

内存中                            编码                    硬盘
字符串(Unicode)---------->encode----------->二进制bytes

硬盘                       解码                        读取后
二进制bytes-------->decode-------------->字符串(Unicode)

1.在文本编辑器（如word/txt/Sublime text3/IDEL/各种解释器等等）编辑文字（中文/英文）时，计算机是
不认识这些的。在我们保存这份文件数据之前，数据是以Unicode形式存在内存中的。
2.保存了的存到磁盘上的数据 是通过某种编码方式（如utf-8/gbk等）进行编码（encode） 过的bytes字节串。
（在保存操作时编辑软件默默地作了编码工作，有它们默认保存文件的编码方式）
3.再次打开文件 时，软件又默默地（从磁盘）做了解码（decode）工作，即将数据从byte解码成Unicode（到内
存）。然后以明文呈现给用户。Unicode是离用户更近的数据，byte是离计算机更近的数据

Pyhon运行.py文件过程：打开文件，解码存磁盘的bytes数据成Unicode数据；接着，解释器将Unicode数据翻译
成C代码，再转成二进制的数据流；最后，通过控制操作系统调用CPU执行二进制数据，得出结果。整个过程结束。

###################################################################################

open(path, flag[, encoding][, errors])
path:要打开文件的路径
flag:打开方式
r 以只读的方式打开文件，文件的描述符放在文件的开头
rb 以二进制格式打开一个文件用于只读，文件的描述符放在文件的开头
r+ 打开一个文件用于读写，文件的描述符放在文件的开头
w 打开一个文件只用于写入，如果该文件已经存在会覆盖，如果不存在则创建新文件
wb 打开一个文件值用于写入二进制，如果该文件已经存在会覆盖，如果不存在则创建新文件
w+ 打开一个文件用于读写
a 打开一个文件用于追加，如果文件存在，文件描述符将会放到文件末尾
a+
encoding:编码方式
errors:错误处理

读操作

1 f=open(‘xxx‘,‘r‘,encoding=‘xxx‘)# ‘xxx‘：路径+文件名  ‘r‘打开方式  encoding=‘xxx‘以什么编码打开文件
2 data=f.read()
3 print(data)
4 f.close()

 1 f=open(‘xxx‘,‘r‘,encoding=‘xxx‘)
 2 #一行行读
 3 print(f.readable())
 4 print(‘第1行‘,f.readline(),end=‘‘)如果打印中间隔了两行，就用end=‘‘
 5 print(‘第2行‘,f.readline())
 6 print(‘第3行‘,f.readline())
 7 
 8 data=f.readlines()
 9 print(data)
10 f.close()

写操作

f=open(‘陈粒1‘,‘w‘,encoding=‘utf8‘)
# f.read()
f.write(‘11111111
‘)
f.write(‘222222222
‘)
f.write(‘333
4444
555
‘)
# f.writable()
f.writelines([‘555
‘,‘6666
‘])
#f.writelines([‘555
‘,‘6666
‘,1]) # 文件内容只能是字符串，只能写字符串,1不是“1”
f.close()

 

追加操作

f=open(‘陈粒1‘,‘a‘,encoding=‘utf-8‘)
f.write(‘写到文件最后‘)

注意：用w+打开的已存在的文件会让文件直接没内容了

 

with 自动close()

 1 文件修改
 2 src_f=open(‘xxx‘,‘r‘,encoding=‘gbk‘) #先读出来，放到data
 3 data=src_f.readlines()
 4 src_f.close()
 5 
 6 # for i in data:
 7 #     print(i)
 8 print(data)
 9 dst_f=open(‘xxx‘,‘w‘,encoding=‘gbk‘) #把data写到新文件
10 # dst_f.writelines(data)
11 dst_f.write(data[0])
12 dst_f.close()
13 
14 with open(‘a.txt‘,‘w‘) as f:  #不用自己关掉文件，自动关
15     f.write(‘1111
‘)
16 
17 
18 src_f=open(‘xxx‘,‘r‘,encoding=‘gbk‘)
19 dst_f=open(‘xxx‘,‘w‘,encoding=‘gbk‘)
20 with open(‘xxx‘,‘r‘,encoding=‘gbk‘) as src_f,        #从A读出来，写到B中
21         open(‘xxx_new‘,‘w‘,encoding=‘gbk‘) as dst_f:  #这种写法美观
22     data=src_f.read()
23     dst_f.write(data)
24 
25 f=open(‘a.txt‘)
26 print(f.encoding) #查看文件编码

 

文件操作的其他方法

  1 f=open(‘a.txt‘,‘r+‘,encoding=‘gb2312‘)
  2 # data=f.read()
  3 # print(data)
  4 f.write(‘你好‘)
  5 
  6 f=open(‘b.txt‘,‘r+‘,encoding=‘latin-1‘)
  7 data=f.read()
  8 print(data)
  9 f.write(‘aaaaaaaaaaa‘)
 10 
 11 f=open(‘b.txt‘,‘r‘,encoding=‘utf-8‘,newline=‘‘) #读取文件中真正的换行符号
 12 f=open(‘b.txt‘,‘r+‘,encoding=‘utf-8‘,newline=‘‘) #读取文件中真正的换行符号
 13 
 14 print(f.closed)
 15 print(f.encoding)
 16 f.flush()  #刷新,自动保存
 17 print(f.readlines())
 18 
 19 print(f.tell())
 20 f.readline()
 21 print(f.tell())
 22 
 23 f.seek(1)
 24 print(f.tell())
 25 print(f.readlines())
 26 f.seek(3)
 27 print(f.tell())
 28 print(f.read())
 29 
 30 data=f.read(1)
 31 print(data)
 32 
 33 f.truncate(10)
 34 
 35 
 36 f.flush() #讲文件内容从内存刷到硬盘
 37 
 38 f.closed #文件如果关闭则返回True
 39 
 40 f.encoding #查看使用open打开文件的编码
 41 f.tell() #查看文件处理当前的光标位置
 42 
 43 f.seek(3) #从开头开始算，将光标移动到第三个字节
 44 f.truncate(10) #从开头开始算，将文件只保留从0-10个字节的内容，文件必须以写方式打开，但是w和w+除外
 45 
 46 f=open(‘d.txt‘,‘r‘,newline=‘‘)
 47 
 48 data=f.readline().encode(‘utf-8‘)
 49 print(data)
 50 print(f.tell())
 51 
 52 
 53 
 54 #除了read是对字符的操作,其他都是对字节的操作
 55 f=open(‘seek.txt‘,‘r‘,encoding=‘utf-8‘)
 56 print(f.tell())
 57 f.seek(10)
 58 print(f.tell())
 59 f.seek(3)
 60 print(f.tell())
 61 
 62 f=open(‘seek.txt‘,‘rb‘)
 63 print(f.tell())
 64 f.seek(10,1)
 65 print(f.tell())
 66 f.seek(3,1)
 67 print(f.tell())
 68 
 69 
 70 f=open(‘seek.txt‘,‘rb‘)
 71 print(f.tell())
 72 f.seek(-5,2)
 73 print(f.read())
 74 print(f.tell())
 75 f.seek(3,1)
 76 print(f.tell())
 77 
 78 
 79 f=open(‘日志文件‘,‘rb‘)
 80 data=f.readlines()
 81 print(data[-1].decode(‘utf-8‘))
 82 
 83 f=open(‘日志文件‘,‘rb‘)
 84 
 85 # for i in f.readlines():
 86 #     print(i)
 87 
 88 #循环文件的推荐方式
 89 # for i in f:
 90 #     print(i)
 91 
 92 #如果
 93 for i in f:
 94     offs=-10
 95     while True:
 96         f.seek(offs,2)
 97         data=f.readlines()
 98         if len(data) > 1:
 99             print(‘文件的最后一行是%s‘ %(data[-1].decode(‘utf-8‘)))
100             break
101         offs*=2

文件处理模式b模式

 1 f=open(‘test11.py‘,‘rb‘,encoding=‘utf-8‘) #b的方式不能指定编码
 2 f=open(‘test11.py‘,‘rb‘) #b的方式不能指定编码
 3 data=f.read()
 4 #‘字符串‘---------encode---------》bytes
 5 #bytes---------decode---------》‘字符串‘
 6 print(data)
 7 print(data.decode(‘utf-8‘))
 8 f.close()
 9 
10 
11 f=open(‘test22.py‘,‘wb‘) #b的方式不能指定编码
12 f.write(bytes(‘1111
‘,encoding=‘utf-8‘))
13 f.write(‘杨件‘.encode(‘utf-8‘))
14 
15 #f=open(‘test22.py‘,‘ab‘) #b的方式不能指定编码
16 # f.write(‘杨件‘.encode(‘utf-8‘))
17 
18 # open(‘a;ltxt‘,‘wt‘)