Python 基础语法 5（遍历 类型转换）

2.6 使用for循环遍历文件
2.7 使用while循环遍历文件
2.8 统计系统剩余的内存
2.9/3.0 数据类型转换(计算mac地址)/ 数据类型转换(列表与字典相互转换)

2.6 使用for循环遍历文件

内置函数 作用
open(name[, mode[, buffering]]) 打开文件并返回对象 mode表示打开的模式 默认是r buffering指定缓存
模式 作用
r 以读方式打开
w 以写方式打开 文件不存在会创建 存在会覆盖文件内容
a 以追加模式 文件不存在会创建 存在会在文件内容后追加
r+ 以读写模式打开
w+ 以读写模式打开 (参见 w )
a+ 以读写模式打开 (参见 a )
rb 以二进制读模式打开
wb 以二进制写模式打开 (参见 w )
ab 以二进制追加模式打开 (参见 a )
rb+ 以二进制读写模式打开 (参见 r+ )
wb+ 以二进制读写模式打开 (参见 w+ )
ab+ 以二进制读写模式打开 (参见 a+)
文件对象的方法 作用
close() 关闭文件
write(str) 向文件中写人字符串
read([size]) 读取整个文件内容 返回字符串 可以使用size指定读的字符个数
readline([size]) 读取一行的文件内容 返回字符串 可以使用size指定读的字符个数
readlines([size]) 读取多行的文件内容 返回列表 以使用size指定读的字符个数
next() 读取一行的文件内容 
1
2
3
4
5
In [2]: f = open('/tmp/test.txt')  ##打开文件并赋值文件对象给变量f

In [3]: type(f)
Out[3]: file
In [7]: f.close()  ##关闭文件 f变量没有赋值

write()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
cat /tmp/test.txt  ##现在test.txt内容
1
2
3
In [11]: f= open('/tmp/test.txt','w')  ##以w模式打开文件 覆盖了原来文件内容
In [12]: f.write('123\n')  ##写入'123\n'
In [13]: f.close()
cat /tmp/test.txt  ##文件内容只有123
123

In [14]: f= open('/tmp/test.txt','a')
In [15]: f.write('456\n')
In [16]: f.close()

cat /tmp/test.txt  ##在文件内容后面追加了456
123
456

read()

1
2
3
4
5
6
7
8
9
10
11
In [17]: f=open('/tmp/test.txt')
In [19]: f.read()   ##读取整个文件内存
Out[19]: '123\n456\n'

In [20]: f.read()  ##已经到文件尾部 无法再读取了
Out[20]: ''

In [23]: f.read(2)  ##两个字符为间距读取文件内容
Out[23]: '12'
In [24]: f.read(2)
Out[24]: '3\n'

readline()

1
2
3
4
5
6
7
8
In [31]: f.readline()  ##一行一行的读取文件内容
Out[31]: '123\n'

In [32]: f.readline()
Out[32]: '456\n'

In [33]: f.readline()
Out[33]: ''

readlines()

1
2
3
4
5
6
7
8
9
In [36]: f.readlines()  ##读取多行文件内存并返回列表
Out[36]: ['123\n', '456\n']

.next()
In [42]: f.next()
Out[42]: '123\n'

In [43]: f.next()
Out[43]: '456\n'

for循环脚本形式读取文件

1
2
3
4
5
6
#!/usr/bin/python

f=open('/tmp/test.txt')
for i in f:   ##遍历文件对象  for循环其实就是执行多次f.next(),直到文件结尾
    print i,
f.close()

2.7 使用while循环遍历文件

1
2
3
4
5
6
7
8
#!/usr/bin/python

f=open('/tmp/test.txt')  
while True:  ##因为是True 所以开始循环 
    i=f.readline() ##一行一行读取文件内容
    if not i:    ##  not ''等于True 到''就会跳出循环
        break
    print i,

打开文件可以使用with关键字 这样最后可以不需要使用close()文件

语法形式

1
2
with open(文件) as 变量:
    代码块

脚本形式

1
2
3
4
5
6
7
8
#!/usr/bin/python

with open('/tmp/test.txt') as f:
    while True:
        i=f.readline()
        if not i:
            break
        print i,

2.8 统计系统剩余的内存

字符串的方法 作用
S.startswith(prefix[, start[, end]]) 判断字符串开头是否是为prefix，并返回bool值
S.split([sep [,maxsplit]]) 分割字符串并返回列表 sep指定分隔符（默认是空格或tab） maxsplit分割次数

S.startswith(prefix[, start[, end]])

1
2
3
4
5
6
7
8
9
10
In [1]: s='abc'

In [7]: s.startswith('a')  ##判断变量s是否是'a'开头
Out[7]: True

In [8]: s.startswith('b')
Out[8]: False

In [9]: s.startswith('b',1)  ##判断下标1是否是'b'
Out[9]: True

S.split([sep [,maxsplit]])

1
2
3
4
5
6
7
8
9
10
In [10]: s1='abc dfe   123'

In [12]: s1.split()
Out[12]: ['abc', 'dfe', '123']

In [13]: s1.split('2')  ##指定2为分隔符
Out[13]: ['abc dfe   1', '3']

In [14]: s1.split('2')[1]  ##取列表的下标为1的值
Out[14]: '3'

练习

统计系统剩余的内存

1
2
3
4
5
6
7
8
9
10
11
12
#!/usr/bin/python
# coding:utf-8

with open('/proc/meminfo') as fd:
    for i in fd:
        if i.startswith('MemTotal'): ##判断开头是否是memtotal
            total = i.split()[1]     ##分割字符串后返回列表 把列表中的下标1的值给变量tatal
        if i.startswith('MemFree'):
            free = i.split()[1]
    print '内存总共%.2fM' %(int(total)/1024.0)  ## %.2f把浮点格式化为两位小数点字符串
    print '内存还剩%.2fM' %(int(free)/1024.0)   ## free为字符串 int(free)为整型 int(free)/1024.0为浮点型
    print '内存可用的百分比为%.2f%%' %(float(free)/float(total)*100) ##%%输入一个%

2.9/3.0 数据类型转换(计算mac地址)/ 数据类型转换(列表与字典相互转换)

内置函数 作用
int() 转换为十进制的整型
hex() 十进制转换为十六进制 返回字符串
str() 转换为字符串 返回字符串
list() 转换为列表
tuple() 转换为元祖
dict() 转换为字典
字符串的方法 作用
S.join(iterable) 把迭代的数（ 元组、列表、字典、字符串）转换为字符串 S表示分隔符 一般用’’表示不分开
字典的方法 作用
D.items() 字典转列表 列表中每个元素都是元祖

int()

1
2
3
4
5
In [32]: int('123')
Out[32]: 123

In [30]: int('a',16)  ##‘a’是十六进制的
Out[30]: 10

hex()

1
2
In [35]: hex(10)
Out[35]: '0xa'  ##十六进制中 0xa就是a

str()

1
2
In [38]: str(123)
Out[38]: '123'

list()

1
2
3
4
In [5]: s='abc'

In [6]: list(s)
Out[6]: ['a', 'b', 'c']  ##字符串转列表

tuple()

1
2
In [21]: tuple(s)
Out[21]: ('a', 'b', 'c')  ##字符串转元祖

列表与元组互相转换

1
2
3
4
5
6
7
8
9
10
11
In [33]: l
Out[33]: ['a', 'b', 'c']

In [34]: tuple(l)
Out[34]: ('a', 'b', 'c')  ##列表转元祖

In [35]: t
Out[35]: ('a', 'b', 'c')

In [36]: list(t)
Out[36]: ['a', 'b', 'c']  ##元祖转列表

S.join(iterable)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
In [16]: l
Out[16]: ['a', 'b', 'c']

In [17]: ''.join(l)   ##列表转字符串 ''表示字符间没分隔符
Out[17]: 'abc'  

In [18]: '.'.join(l)   ##字符间用.作为分隔符
Out[18]: 'a.b.c'

In [24]: t
Out[24]: ('a', 'b', 'c')

In [25]: ''.join(t)   ##元祖换字符串
Out[25]: 'abc'

dict()

1
2
3
4
5
In [48]: l1
Out[48]: [('a', 1), ('b', 2)]

In [49]: dict(l1)   ##列表转字典
Out[49]: {'a': 1, 'b': 2}

D.items()

1
2
3
4
In [40]: d={'a':1,'b':2}

In [41]: d.items()   ##字典转列表
Out[41]: [('a', 1), ('b', 2)]

练习

计算当前mac地址的下一位

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#!/usr/bin/python
# coding:utf-8

macadd = '00:0C:29:D1:6F:E9'
last_add = macadd[-2:]
first_add = macadd[:-3]
plus_1 = hex(int(last_add,16)+1)
## 最后两位字符串先转十进制 +1后再转十六进制
plus_2 = plus_1[2:].upper()
## 去掉0x和变为大写
if len(plus_2) == 1:
##转十六进制时 结果是01或者0a 输出格式为0x1或者0xa,没有0  判断最后两位长度是否只有1位来补0
    plus_2 ='0'+ plus_2
    print first_add + ':' + plus_2
else:
    print first_add + ':' + plus_2
1
2
3
4
5
6
python mac.py
00:0C:29:D1:6F:EA
python mac.py
00:0C:29:D1:6F:02
python mac.py
00:0C:29:D1:6F:0C

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

欢迎光临<br><br>本博客是用来记录学习Linux Python Shell和Perl<br>谢谢大家