一、文件处理
1.文件处理模式
r 以读方式打开
w 以写方式打开，
a 以追加模式打开 (从 EOF 开始, 必要时创建新文件)
r+ 以读写模式打开
w+ 以读写模式打开 (参见 w )
a+ 以读写模式打开 (参见 a )
rb 以二进制读模式打开
wb 以二进制写模式打开 (参见 w )
ab 以二进制追加模式打开 (参见 a )
rb+ 以二进制读写模式打开 (参见 r+ )
wb+ 以二进制读写模式打开 (参见 w+ )
ab+ 以二进制读写模式打开 (参见 a+ )
2.创建文件对象格式
对象名 = open(文件名,模式)
只读： f = file(‘aaa.txt’,’r’) #只读模式打开
f.readline() #查看文件内容
f.close() #关闭文件
只写: f = file(‘aaa.txt’,’w’) #只写模式打开
f.write(‘new-line’) #写入内容，会覆盖
f.close()
追加: f = file(‘aaa.txt’,’a’\n) #追加模式打开,加换行符
f.write(‘www’) #写入内容
f.close()读取：
content = f.read(N) # 读取N bytes的数据
content = f.readline() # 读取一行
content = f.readlines() # 读取所有行，储存在列表中，每个元素是一行。写入：
f.write('I like apple!\n') # 将'I like apple'写入文件并换行关闭文件：
f.close()二、字符串
1.概念:字符串是不可变的
所有标准的序列操作(索引、分片、乘法、判断成员资格、求长度、取最小值、最大值)对字符串同样试用
2.字符串方法
·find:在一个字符串中查找子串.它返回子串最左端所在位置的索引,如果没有找到则返回-1
·join:它是split方法的逆方法,用来连接序列中的元素
·lower:不管一个字符串中是大写还是小写，它只返回小写的结果
·replace:把字符串中的某个元素替换并返回替换后的结果(所有匹配选项)
·split:它是join方法的逆方法,提供分隔符，将字符串分割成列表
·strip:返回去除两侧（不包括内部）空格的字符串
3.方法实例操作
(1)find:在一个字符串中查找子串.它返回子串最左端所在位置的索引,如果没有找到则返回-1
>>>a='Hello world'
>>>print a.find('world') #'w'的索引位置是6，所以是6
6(2)join:它是split方法的逆方法,用来连接序列中的元素
>>>seq = ['1','2','3','4','5']
>>>b = '+' #b为提供的分隔符，如果不提供分隔符就用空格作为分隔符
>>>print b.join(seq)
1+2+3+4+5(3)lower:不管一个字符串中是大写还是小写，它只返回小写的结果
>>>a = 'Hello,World!'
>>>print a.lower()
hello,world!(4)replace:把字符串中的某个元素替换并返回替换后的结果(所有匹配选项)
>>>a = 'This is a test'
>>>print a.replace('is','si')
Thsi si a test(5)split:它是join方法的逆方法,提供分隔符，将字符串分割成列表
>>>a = '1+2+3+4+5'
>>>print a.split('+')
['1', '2', '3', '4', '5'](6)strip:返回去除两侧（不包括内部）空格的字符串
>>>a = ' Hello,World! '
>>>print a.strip()
Hello,World!三、序列
1.概念：
序列是一组有顺序的元素的集合
序列有两种：tuple(元组)和list(列表)
2.1列表
概念：建立之后可以增删改查
列表方法:
·append:在列表末尾追加新的对象
insert:将对象插入到列表中
·remove:移除列表中某个值的第一个匹配项
·count:统计某个元素在列表中出现的次数
·index:在列表中找出某个值的索引位置
·extend:在列表末尾一次性追加另一个列表中的多个值
·reverse:将列表中的元素反向存放
·sort:在原始位置对列表进行排序
(1)列出
#列出列表中的第一个元素
>>> name_list = ['zhao','qian','sun']
>>> name_list
['zhao', 'qian', 'sun']
>>> name_list[0]
'zhao'(2)append:在列表末尾追加新的对象
在列表最后一个元素后面追加一个元素
>>> name_list
['zhao', 'qian', 'sun']
>>> name_list.append('li')
>>> name_list
['zhao', 'qian', 'sun', 'li'](3)insert:将对象插入到列表中
#插入到索引为1的元素后边
>>> name_list.insert(2,’110’)
>>> name_list
['zhao', 'qian', '110', 'sun', 'li'](4)remove:删除
>>>name_list
['qian', '110', 'sun', 'li']
>>>name_list.remove(‘zhao’)
>>> name_list
['qian', '110', 'sun', 'li'](5)count:统计某个元素出现的次数
>>>name_list
['zhao', 'qian', 'sun', 'li',’zhao’]
>>>name_list.count(‘zhao’)
2(6)index:在列表中找出某个值的索引位置
>>> name_list
['zhao', 'qian', 'sun', 'li',’zhao’]
>>> name_list.index(‘qian’)
1(7)在知道字符串位置的情况下，截取
>>> name_list
['zhao', 'qian','sun', 'li',’zhou’,’wu’,’zheng’,’wang’]
>>>name_list [0:5] #截取0-5行
['zhao', 'qian','sun', 'li',’zhou’,’wu’](8)在不知道字符串位置的情况下，截取
>>> name_list
['zhao', 'qian','sun', 'li',’zhou’,’wu’,’zheng’,’wang’]
>>>name_list[name_list.index(zhao):name_list.index(zhao)+4] #从zhao开始截取四个包括zhao
['zhao', 'qian', 'sun', 'li'](9)extend:在列表末尾一次性追加另一个列表中的多个值
>>>a=[1,2,3]
>>>b=[4,5,6]
>>>a.extend(b)
>>>print a
[1,2,3,4,5,6](10)reverse:将列表中的元素反向存放
>>>a=[1,2,3]
>>>a.reverse()
>>>print a
[3,2,1](11)sort:在原始位置对列表进行排序
>>>a=[1,3,2,5,4]
>>>a.sort()
>>>print a
[1,2,3,4,5]
2.2元组
概念：一旦建立，元组的各个元素不可修改，不能增删改是只读的
元组方法
· cmp(tuple1, tuple2)：比较两个元组元素
· len(tuple)：计算元组元素个数
· max(tuple)：返回元组中元素最大值
· min(tuple)：返回元组中元素最小值
· tuple(seq)：将列表转换为元组
(1)创建元组
>>>tuple = ('zhao','qian','sun')(2)查看元组
>>> print tuple
('1', '2', '3')(3)删除整个元组，元组中的某个元素是不能删除的
>>> del tuple注意：readlines 读所有行到数组中，xreadlines 也是，实现那种效果，但是前者比如数据量100万行，是不是返回100万的数组，后者会做些优化
2.3列表和元组的引用
(1)从开始打印到下标4 #不包括5
>>> name_list
['zhao', 'qian', 'sun', 'li', 'zhou', 'wu', 'zheng', 'wang']
>>> print name_list[:5]
['zhao', 'qian', 'sun', 'li', 'zhou'](2)从下标2开始打印到最后
>>> name_list
['zhao', 'qian', 'sun', 'li', 'zhou', 'wu', 'zheng', 'wang']
>>> print name_list[2:]
['sun', 'li', 'zhou', 'wu', 'zheng', 'wang'](3)打印从下标0到下标4，每隔2取一个元素 #不包括5
>>> name_list
['zhao', 'qian', 'sun', 'li', 'zhou', 'wu', 'zheng', 'wang']
>>> print name_list[0:5:2]
['zhao', 'sun', 'zhou']四、字典
1、概念：
·快速定位的想要查的那个值，就是key:value，key是索引，根据key找到对应value
·键可以是数字、字符串甚至是元组
2.特点:
·是无序的
·键类型:字典的键不一定是整数数据,键可以是任意的不可变类型比如:浮点、字符串、元组
·自动添加:即使键起初在字典中不存在，也可以为它赋值，这样字典就会建立新的项
3.字典的基本操作
·len(d):返回d中项(键-值对)的数量
·d[a]:返回键(key)a对应的值(value)
·del d[a]:删除键为a的项(键值对)
4.字典的方法
·clear:清除字典中所有的项
·copy:返回一个相同键值对的新字典（这个方法实现的是浅复制）
·fromkeys:使用给定的键建立新字典,每个键对应的值是None
·get:如果要访问的值字典中不存在也不会报错
·items:将字典中所有的项以列表的方式返回
·pop:指定一个键，然后把这个键-值对从字典中删除
·popitem:弹出一个字典中随机的项(键值对),如果想一个接一个的删除项，这个方法就有效了.
·update:利用一个字典的项更新另一个字典(后者会替代前者)
5.实例
(1)clear:清除字典中所有的项
代码:
people = {'zhangsan':25,'lisi':18}
print people
print people.clear()
结果:
{'lisi': 18, 'zhangsan': 25}
None(2)copy:返回一个相同键值对的新字典（这个方法实现的是浅复制）
代码：
people = {'zhangsan':25,'lisi':18}
print people
print people.copy()
结果:
{'lisi': 18, 'zhangsan': 25}
{'lisi': 18, 'zhangsan': 25}(3)fromkeys:使用给定的键建立新字典,每个键对应的值是None
代码:
print dict.fromkeys(['zhangsan','lisi'])
结果:
{'lisi': None, 'zhangsan': None}(4)get:如果要访问的值字典中不存在也不会报错
代码:
people = {'name':'zhangsan','age':'25'}
print people
print people.get('salary')
结果:
{'age': '25', 'name': 'zhangsan'}
None(5)items:将字典中所有的项以列表的方式返回
代码:
people = {'name':'zhangsan','age':'25'}
print people.items()
结果:
[('age', '25'), ('name', 'zhangsan')](6)pop:指定一个键，然后把这个键-值对从字典中删除
代码:
people = {'name':'zhangsan','age':'25'}
print people
print people.pop('name')
print people
结果：
{'age': '25', 'name': 'zhangsan'}
zhangsan
{'age': '25'}(7)popitem:弹出一个字典中随机的项(键值对),如果想一个接一个的删除项，这个方法就有效了
代码：
people = {'name':'zhangsan','age':'25'}
print people.popitem()
结果：
('age', '25')(8)利用一个字典的项更新另一个字典(后者替代前者)
代码：
people = {'name':'zhangsan','sarlay':6000}
people2 = {'name':'zhangsan','sarlay':12000}
print people
print people2
print people.update(people2)
print people
结果:
{'sarlay': 6000, 'name': 'zhangsan'}
{'sarlay': 12000, 'name': 'zhangsan'}
None
{'sarlay': 12000, 'name': 'zhangsan'}(9)通过key找到value
代码：
people = {'name':'zhangsan'}
print people['name']
结果:
zhangsan(10)循环打印name_info中的key_value
代码:
#!/bin/env python
name_info {
'name' : 'zhai', #逗号表示还有下一行
'age' : 18,
'job' : 'yunwei'
}
for i in name_info:
print i, name_info[i]
结果：
name zhai
age 18
job yunwei(11)插入项（键值对）
>>> name_info['salary'] = 3000
>>> name_info
{'job': 'IT', 'salary': 3000, 'age': 29, 'name': 'zhai'}(12)更改项(键值对)
>>> name_info['salary'] = 5000
>>> name_info
{'job': 'IT', 'salary': 5000, 'age': 29, 'name': 'zhai'}(13)指定一个键,超找有没有对应的项（键值对）
>>> name_info.has_key('job') #如果有返回True，如果没有返回False(9)返回字典中所有的key
代码
dic = {'tom':11,'sam':57,'lily':100}
print dic.keys()
结果
['lily', 'sam', 'tom'](14)返回字典中所有的value
代码
dic = {'tom':11,'sam':57,'lily':100}
print dic.values()
结果
[100, 57, 11]6.列表和字典的区别
·字典
- 查找和插入的速度极快，不会随着key的增加而增加
- 需要占用大量的内存，内存浪费多
- Key不可变
- 默认无序
·列表
- 查找和插入的时间随着元素的增加而增加
- 占用空间小，浪费内存很少
- 通过下标查询
- 有序
五、set集合
1.特点：
·无序
·元素不重复
2.功能：
·关系测试：测试两组数据的关系
·去重
3.举例
(1)
>>> name_set = {1,2,3,4,5}
>>> name_set
set({1,2,3,4,5})(2)添加
>>> name_set
set({1,2,3,4,5})
>>> a = name_set
>>> a
set({1,2,3,4,5})
>>> a.add(100)
>>> a
set({1,2,3,4,5,100})(3)取出交集 #取出x y里都有的
>>> x = {1,2,3,4}
>>> y = {3,4,5,6}
>>> x & y
set([3, 4])(4)并集 #合并，并且去重
>>> x = {1,2,3,4}
>>> y = {3,4,5,6}
>>> x | y
set([1, 2, 3, 4, 5, 6])（5）差集
>>> x = {1,2,3,4}
>>> y = {3,4,5,6}
>>> x -y
set([1, 2])（6）对称差集 #把两个互相都有的去掉，把两个互相都没有的合在一起
>>> x = {1,2,3,4}
>>> y = {3,4,5,6}
>>> x ^ y
set([1, 2, 5, 6])----------------------------------------------------------------------
练习：查询一个字符，如果文件中存在就打印出来，如果不存在则报错
[root@k8s-1 ~]# cat bbb.txt
a 1111
b 2222
c 3333
d 4444
e 5555
[root@k8s-1 ~]# cat 4.py
#!/bin/env python
#_*_ coding:utf-8 *_*
a = raw_input('输入查询的信息：')
f = file('bbb.txt','r')
for i in f.xreadlines():
if a in i:
print i
break
else:
print '不存在这个参数'
break
#f.close()
测试：
[root@k8s-1 ~]# python 4.py
输入查询的信息：1
a 1111
[root@k8s-1 ~]# python 4.py
输入查询的信息：y
不存在这个参数