python&&文件处理&&学习笔记1

文件处理示例

文件名称：fileHandler.py

#!/usr/bin/env python
f = file('password.txt','r')
#默认的文件打开模式也是'r'
for i in f.readlines():
    print i.strip('\n').split(':')[0]
#"f.readline":读取一行
#"f.readlines":读取全部行
#"strip('\n')":脱掉换行符,仅能脱行首与行尾，默认脱掉空格、换行符、Tab

命令行示例

#python
>>>import tab
>>>f = file('passwd.txt')
#输入"f."并敲击Tab键可以看到"f"可用的方法，其中"__*__"双下划线内的为私有方法，仅能命令行内使用。
>>>f.closed
False
#若"f.closed"值为False,代表当前文件已经被打开。通过检测该值可以避免多个程序同时对一个文件进行写操作。
>>>print f.encoding
None
#显示字符集,"None"默认是以ASSIC的形式存储
>>>f.isatty()
#测试是否是一个终端
>>>f.mode
'r'
#查看当前file文件的模式
>>>f.name
'passwd.txt'
>>>f.next()
#功能与'f.readline()'类似，区别在于'f.readline()'读到文件末尾时不报错，'f.next()'读到文件末尾时会报'stopIteration'的错误。'f.readline()'通过'f.next()'实现。
>>>f.read()
#"f.readlines()"是以列表的形式读出，"f.read()"是以字符串的形式读出
#"f.readlines()"一次性读取文件的全部内容加载到内存中，不适合读取大文件！
>>>f.tell()
2103L
#查看我在文件的位置，此处为2103个字符的位置
>>>f.seek(0)
#跳到文件的开头，0表示文件的开始位置
#"f.seek()"常用于对大容量文件的分段读取，提高读取效率。 
>>>f.seek(64)
>>>f.readline()
'in/sh\n'
#此时会打印从当前字符到行末尾的内容
>>>f.truncate(100)
#从文件开头字符位置开始截取一个长度为100的字符串
>>>help(f.truncate)
#参看帮助手册
>>>a = range(10)
#定义一个列表a
>>>a
[0,1,2,3,4,5,6,7,8,9]
>>>a = [ str(i) for i in a ]
>>>a
['0','1','2','3','4','5','6','7','8','9']
#将列表a转换为字符串a
>>>f.writelins(a)
#"f.writelines()"仅支持传入字符串
>>>f.xreadlines()
#逐行读，适用于读取几个G的大文件！
>>>f.close()
#关闭打开的文件
>>>f = file('testCoding.txt','w')
#指定只写文件'testCoding.txt'，若不存在则创建该文件
>>>f.write(u'this is a dog'.encode('utf-8'))
#以'utf-8'的方式编码
>>>f.flush()
#将数据由内存写入硬盘
>>>f.close()

注：当对文件进行读处理时，文件内的数据才开始载入内存，因此，有效的使用"f.seek()"跳转到目标位置开始读文件可以提高读取效率

文件处理示例2

文件名称：fileHandler2.py

#!/usr/bin/env python
#_*_coding:utf-8_*_
f = file('encode.txt','w')
f.write(u'this is a cat'.encode('utf-8'))
f.close()

命令行操作如下

#python
>>>f = file('encode.txt')
>>>import tab
>

文件处理模式

r 以只读模式打开文件
w 以只写模式打开文件
a 以追加模式打开文件
r+b 以读写模式打开
w+b 以写读模式打开
a+b 以追加及读模式打开

'b’代表以二进制的模式对文件进行处理，主要用于兼容windows系统（windows格式转linux格式）

字符串处理

$.find(substring,[start[end]]) #可指范围查找子串，返回索引值，否则返回-1

$.rfind(substring,[start[,end]]) #反向查找

$.index(substring,[start[,end]]) #同find,只是找不到产生ValueError异常

$.rindex(substring,[start[,end]]) #同上反向查找

$.count(substring,[start[,end]]) #返回找到子串的个数

$.capitalize() #首字母大写

$.lower() #转小写

$.upper() #转大写

$.swapcase() #大小写互换

$.split(str,’ ') #将string转list,以空格切分

$.join(list,’ ') #将list转string,以空格连接

len(str) #串长度

cmp(“my friend”,str) #字符串比较。第一个大，返回1

max(‘abcd’) #寻找字符串中最大的字符

min(‘abcd’) #寻找字符串最小的字符

命令行示例2

>>>msg = "this is my home"
>>>msg.upper()
>>>msg.split("'")
>>>msg_list = msg.split("'")
>>>'|'.join(msg_list)
>>>x = "Abc"
>>>x.startswith('Ab')
True
#匹配以*开头的
>>>x.endswith('bc')
#匹配以*结尾的

列表

L.append(var) #追加元素
L.insert(index.var)
L.pop(var) #返回最后一个元素，并从list中删除
L.remove(var) #删除第一次出现的该元素
L.count(var) #该元素在列表中出现的个数
L.index(var) #该元素的位置，无则抛异常
L.extend(var) #追加list,即合并list到L上
L.sort() #排序
L.reverse() #倒序
a[1:] #片段操作符，用于子list的提取
[1,2] + [3,4] #为[1,2,3,4]，同L.extend()
[2]*4 #为[2,2,2,2]
delL[1:] #删除指定下标的元素
delL[1:3] #删除指定下标范围的元素
注：列表类似于数组

命令行示例3

>>>import tab
>>>name_list = ['alex','jack','old Dog']
>>>name_list[2]
'old Dog'
#取列表中第三个位置的值
>>>name_list.append('Eric')
>>>name_list
 ['alex','jack','old Dog','Eric']
 #在列表末尾追加一个元素
 >>>name_list.insert(2,'110')
 >>>name_list
  ['alex','jack','110','old Dog','Eric']
 #在列表中的指定位置插入元素
 >>>name_list.remove('old Dog')
 >>>name_list
 ['alex','jack','110','Eric']
 #从列表中移除目标元素
 >>>name_list.append('jack')
 >>>name_list
 ['alex','jack','110','Eric','jack']
 >>>name_list.count('jack')
 2
 #统计列表中目标元素出现的次数
 >>>name_list.index('jack')
1
#找出目标元素在列表中首次出现的索引的位置
>>>del name_list[2]
>>>name_list
['alex','jack','Eric','jack']
#删除列表中目标索引号的对应元素
>>>name_list.reverse()
>>>name_list
['jack','Eric','jack','alex']
#将列表内的全部元素反转
>>>name_list.sort()
>name_list
['Eric','alex','jack','jack']
#对列表中的全部元素按ASSIC值排序
>>>name_list.extend('abcd')
>>>name_list
['Eric','alex','jack','jack','a','b','c','d']
>>>infos = [1,2,3,4]
>>>name_list.extend(infos)
>>>name_list
['Eric','alex','jack','jack','a','b','c','d',1,2,3,4]
#把一个列表合并到另一个列表
#等同于 name_list += infos
>>>name_list[2:5]
['jack','jack','a']
#对列表进行切片处理
>>>name_list[-2:]
[3,4]
>>>name_list[name_list.index(2):name_list.index(2)+2]
[2,3]
>>>name_list.count('jack')
2
>>>position = 0
...for i in range(name_list.count('jack')):
...newName_list = name_list[position:]
...newPosition +=  newName_list.index('jack') + 1
...print 'positionis : ' position + newName_list.index('jack')
...position +=  newPosition
>>>name_list[1::2]
['alex','jack','b','d',2,4]
#从固定索引号开始，以固定间隔切割列表

元组

tuple:元组（即常量数组），即一旦形成，内部内容不可改变。且只读
tuple = (‘a’,‘b’,‘c’,‘d’,‘e’)
可以用list的[],:操作符提取元素。就是直接修改元素

>>>a
(1,2,3,4)
>>>type(a)
<type 'tuple'>
>>>list(a)
[1,2,3,4]
#将元组转换为列表
>>>a = list(a)
>>>type(a)
<type 'list'>
>>>tuple(a)
(1,2,3,4)
#将列表转元组

开发文件替换小程序

使用方法：
./file_replace.py ‘ALEX L1 12’ ‘3714’ accounts.txt
./file_replace.py ‘ALEX L1 12’ ‘3714’ accounts.txt --bak new_file.txt

#_*_ coding:utf-8 _*_
import sys,os
if len(sys.argv) <=4:
    print "usage:./file_replace.py old_text new_text filename"
old_text,new_text = sys.argv[1],sys.argv[2]
file_name = sys.argv[3]

f = file(file_name,'rb')
new_file = file('.$s.bak' % file_name ,'wb') 
for line in f.xreadlines():
    new_file.write(line.replace(old_text,new_text) )
f.close()
new_file.close()

if '--bak' in sys.argv:
    os.rename(file_name,'%s.bak' % file_name)
    os.rename('.%s.bak' % file_name,file_name)
else:
    os.rename('.%s.bak' % file_name,file_name)

购物车程序

• 要求用户输入工资，然后打印购物菜单
• 用户可以不断的购买商品，直到钱不够为止
• 退出时格式化打印用户已购买的商品和剩余金额

字典Dict

D.get(key,0) #同dict[key]依据key获取值。多了个没有则返回缺省值"0"。dict[key]没有则抛异常
D.has_key(key) #有该键返回TRUE,否则FALSE
D.keys() #返回字典键的列表
D.values() #以列表的形式返回字典中的值，返回值的列表中可包含重复元素
D.items() #将所有的字典项以列表方式返回，这些列表中的每一项都来自于（键，值），但是项在返回时并没有特殊的顺序
D.update(dict2) #增加合并字典
D.popitem() #得到一个pair,并从字典中删除它。已空则抛异常
D.clear() #清空指点，同del dict
D.copy() #拷贝字典
D.cmp(dict1,dict2) #比较字典，（优先级为元素个数、键大小、键值大小），第一个大返回1，小返回-1，相同返回0
dict1 = dict #复制、别名
dict2 = dict.copy() #克隆，即另一个拷贝

字典：可用于在超大的列表、组中查到需要找的值。部分情况下，比索引号查找要快

文件处理示例3

文件名称：dict_ex.py

name_info = {
     'name':'jack',
     'age':29,
     'job':'Engineer'
}
for i in name_info:
#遍历字典
    print i,name_info[i]
#较下效率高
for k,v in name_info.items():
    print k,v
#较上效率低，因为需要先把字典转换为列表，字典的数据量越大，转换的就越慢

命令行示例4

>>>import tab
>>>name_info = {
...    'name':'Jacky'
...    'age':29
...    'job':'Enginner'
...}
>>>name_info['salary'] = 3000
#向字典中添加新的键值
>>>name_info
{'job':'Enginner','salary':3000,'age':'29','name':'Jacky'}
>>>name_info['job'] = 'IT'
#更改字典中某个键的值
{'job':'IT','salary':3000,'age':'29','name':'Jacky'}
>>>name_info.pop('job')
{'salary':3000,'age':'29','name':'Jacky'}
#删除字典中指定的键值对
#字典默认是不排序的，不指定键值对时，随机删除其中一个
>>>print name_info.items()
[('salary':3000),('age':29),('name':'Jacky')]
#字典转列表
>>>name_info.has_key('job')
False
#检查字典中是否存在目标key
>>>name_info.iteritems()
<dictionary-itemiterator object at 0x96f1694>
#生成一个生成器
>>>name_info.keys()
['salary','age','name']
#仅显示key
>>>name_info.values()
[3000,29,'Jacky']
#仅显示值
>>>name_info.viewitems()
dict_items([('salary':3000),('age':29),('name':'Jacky')])
>>>name_info.setdefault('stuID',1123)
1123
#为字典中stuId赋默认值为1123，若stuID之前不存在，则赋值为1123，若stuID已经存在，则赋值不成功
>>>name_info
{'salary':3000,'age':'29','stuID':1123,'name':'Jacky'}
>>>name_info.setdefault('stuID',''2233)
1123
#因为字典中stuID已经有值，所以赋值不成功，并返回已有值
>>>name_info
{'salary':3000,'age':'29','stuID':1123,'name':'Jacky'}
>>>a = {'name':'alex','addr':'Beijing'}
>>>name_info.update(a)
>>>name_info
{'salary':3000,'age':'29','stuID':1123,'name':'alex','addr':'Beijing'}
#合并字典，已经存在的key更新其key的值，不存在的key则添加新的键值对
#因为字典中所有的key都是唯一的
>>>name_info2 = name_info
#为了节省内存空间，此处赋值不会开辟新的内存空间，因此'name_info2'和'name_info'均指向同一个内存空间，即一个变化，另一个跟着变化，两个字典数据保持完全一致
>>>name_info3 = name_info.copy()
#浅复制：对字典的进行克隆，此时两个字典各自指向不同的内存空间，两个字典数据部分独立（字典中的列表仍然保持一致）。 
>>>name_info['ex.list'] = ['Coral','Erion']
#像字典中添加列表
>>>import copy
#为深复制导入copy模块
>>>name_info4 = copy.deepcopy(name_info)
#深复制：对字典进行克隆，此时两个字典数据完全独立

浅复制与深复制的区别：浅复制时，两个字典部分独立（字典中的列表仍然保持一致）；深复制时，
字典中每一个键值对都指向一个各自的内存地址。

列表与字典的区别

• dict
  查找和插入的速度极快，不会随着key的增加而增加
  需要占用大量的内存，内存浪费多
  key不可变
  默认无序
• list
  查找和插入的时间随着元素的增加而增加
  占用空间小，浪费内存很少
  通过下标查询
  有序

SET集合

特点
- 无序
- 元素不重复
功能
- 关系测试
测试两组数据之间的关系
- 去重
将列表转换为集合实现去重

命令行实例5

>>>name_set = {1,2,4,5}
>>>name_set
set([1,2,3,4])
>>>>name_set = {1,2,4,5,2}
>>>name_set
set([1,2,4,5])
#重复的值会自动去重仅保留一个唯一元素
>>>a = range(100)
#定义一个列表a
>>>a = set(a)
#将列表a转换为集合a,此时可以看到元素从有序变为无序，即集合是无序的
 >>>a.add(100)
 #向集合添加数据
 >>>a.pop()
 #从集合删除数据
 >>>x = {1,2,3,4}
 >>>y = {3,4,5,6}
 #判断x与y的关系
 >>>x & y
 set([3,4])
 #取交集,或 x.intersection(y)
 >>>x | y
 set([1,2,3,4,5,6])
 #取并集,或 x.union(y)
 >>>x - y
 set([1,2])
 #取差集,或 x.difference(y)
 >>>x ^ y
set([1,2,5,6])
#取对称差集,或 x.symmetric_difference(y)
>>>a = {1,2,4}
>>>a.issubset(x)
True
# #a是x的子集
>>>a.issuperset(x)
False
##a没有包含x

作业：员工信息表

• 用户可以模糊查询员工信息
• 显示匹配了多少条，匹配字符需要高亮显示