list操作总结. dict操作及文件操作

1: 列表的操作

help(list)                 # 列表的帮助，列出所有列表的用法
type(name)                 # type判断数据类型是列表还是字典或者元组 
isinstance("字符"， "数据类型")   # 判断数据类型，比type高效，返回布尔值. 

例： 
a = ["yangbin"]
print isinstance(a, list)  # True

shoplist = ['apple','mango','carrot','banana']              #  创建列表
shoplist.append('rice')                      # 增。列表尾添加一个项目
shoplist.insert(2,"c jk")                     # 增。 在列表的第三个位置插入一个元素，从0开始算起

del shoplist[0]                              # 删。根据索引删除列表中的项目
shoplist.remove('apple')                     # 删。根据内容删除元素
shoplist.pop()                              # 删。删除最后一个元素并输出
 
# shoplist["apple"] ="xigua"                  # 改。 通过内容修改
shoplist[0]="apple"                          # 改。 通过索引修改

len(shoplist)                                          # 查。查看列表的元素个数
max(shoplist)                                         # 查。列表中的最大值
min(shoplist)                                          # 查。列表中的最小值
shoplist.count('apple')                              # 查。输出列表中某个元素的个数
if  apple in shoplist                               # 查。搜索apple是否在列表中
shoplist.index("apple")                       # 查。 输出apple元素在列表中的位置

例：
  arr = ["java", "php", "python", "js","python", "js"]
  print arr.index("js",4)
     
shoplist[0]                                             # 分片查，输出索引为0的元素，即第一个元素
shoplist[0:2]                                          # 分片查，输出前三个元素
shoplist[:]                                              # 分片查。输出所有
shoplist[1:]                                            # 分片查。输出第二个和后面所有的
shoplist[0:-1]                                         # 分片查：除了最后一个都输出**

shoplist.sort()                 # 查。 将项目按首字母排序 ,数字>大写>小写，返回值为None，修改源文件
shoplist.reverse()              # 查。 项目顺序倒转。 返回值为None，修改源文件

print s.upper()  # HELLO PYTHON  全部转换成大写. 
print s.lower()  # hello python  全部转换成小写. 
print s.capitalize()  # Hello Python  首字母大写，其他都小写. 
print s.title()  # Hello Python  每个单词首字母大写，其他都小写. 
print "A".isupper()  # True  用于判断 
print "A".islower()  # False 
print "Python Is Good".istitle()  # True 

二: 列表的遍历——查

1： for x  in list
       print x

2:   for i, element in enumerate(list):  # for循环将列表中的元素及他们的下标打印出来.
        print i,element  

三：split vs join——字符串和列表直接的转化

1： split、 将字符串转为列表
格式：

字符串.split("字符串的分隔方式")      

举例：

ip = '192.168.1.11'
ip1=ip.split(".")         # split按要求将字符串转换为列表,以".”为分割符,分成不同的元素 
['192','168','1','11']  

In [1]: a = "192/168/1/2"
In [3]: a.split("/")         # 本例以/作为分隔符
Out[3]: ['192', '168', '1', '2']

2：join——讲列表转为字符串

In [10]: a = ['192', '168', '1', '2']

In [12]: " ".join(a)
Out[12]: '192 168 1 2'

In [13]: "#".join(a)
Out[13]: '192#168#1#2'

In [14]: ".".join(a)
Out[14]: '192.168.1.2'

四：列表生成式

格式：

[ x  for  x in 内容] 
[ x  for  x in 内容 if 条件] 

1：把要生成的元素 x 放到前面，执行的时候，先执行后面的for循环
2：后面跟上for循环，可以有多个for循环，也可以在for循环后面再加个if条件
3：for循环后面可以是任何方式的迭代器(元组,列表,生成器..),只要可迭代对象的元素中至少有一个值.

举例：

In [4]: [x for x in 'abcd']
Out[4]: ['a', 'b', 'c', 'd']

In [25]: res = [8, 9, 10, 11, 12, 13]
In [25]: [ x for x in res if x >10 ]
Out[25]: [11, 12, 13]

原生实现
In [30]: ssss = []
In [31]: for x in res:
   ....:     if x > 10:
   ....:         ssss.append(x)
   ....:         
In [32]: ssss
Out[32]: [11, 12, 13]

五：列表在线上环境上的小小应用——让sql语句更优雅

1：不优雅的sql

sql = "select  id, name,age,email,job  from user"
sql = "select  id, name,age,email,job  from user"

优点：

• 简单容易读

缺点：

• 如果列比较多，sql会很长，很不优雅
• 如果显示的列有变动，如果有多条sql语句修改会比较麻烦

2：优雅的方式

fields = ["id","name","age","email"]  # 将要输出列定义到列表中，每次变动只需要修改列表就行
sql = "select %s from user" % ",".join(fields)

结果：
sql = "select  id, name,age,email from user" 

字典三种格式：

字典，字典里面套字典，字典里面套列表. 
删除字典时指定key就OK. 
删除时使用pop()函数，原地修改，字典没有remove()函数. 

字典赋值&修改：

info = {"name": "yangbin", "age": 20, "hobby": {"sport": "basketball"}, "gramm": ["java", "python"]}
print info  # {'hobby': {'sport': 'basketball'}, 'age': 20, 'gramm': ['java', 'python'], 'name': 'yangbin'}

info["name"] = "yangguo"  # 更改key对应的value.  
print info  # {'hobby': {'sport': 'basketball'}, 'age': 20, 'gramm': ['java', 'python'], 'name': 'yangguo'}

info.pop("age")  # 删除key为"age"的这个字典； pop()函数的删除是对源文件删除，默认返回被删除的值.  
print info  # {'hobby': {'sport': 'basketball'}, 'gramm': ['java', 'python'], 'name': 'yangguo'}

info["gramm"][0] = "js"  # 更改字典里面value为list的值；字典是无序的，因此不能使用索引. 
print info  # {'hobby': {'sport': 'basketball'}, 'gramm': ['js', 'python'], 'name': 'yangguo'}

info["hobby"]["sport"] = "football"  # 更改字典里面key对应的值为字典的value的值.
print info  # {'hobby': {'sport': 'football'}, 'gramm': ['js', 'python'], 'name': 'yangguo'}

info["year"] = 2017  # 当字典中没有该key时，就会字典添加到字典中去. 
print info

查询：以list形式返回.

info = {"name": "yangbin", "age": 20, "hobby": {"sport": "basketball"}, "gramm": ["java", "python"]}
print info.keys()  # ['hobby', 'age', 'gramm', 'name']
print info.values()  # [{'sport': 'basketball'}, 20, ['java', 'python'], 'yangbin']
print info.items()  # [('hobby', {'sport': 'basketball'}), ('age', 20), ('gramm', ['java', 'python']), ('name', 'yangbin')]

get()函数：

info = {"name": "yangbin", "age": 20, "hobby": {"sport": "basketball"}, "gramm": ["java", "python"]}
print info["name"]  # yangbin
print info["nameee"]  # 报错: KeyError: 'nameee',该步错误会导致整个程序挂掉！

解决该问题的办法: 使用get()函数.

print info.get("name")  # yangbin
print info.get("nameee")  # 返回空值 None
print info.get("nameee", "not exist")  # 返回指定的值"not exist". 
print info.get("name", "NO")  # yangbin  如果查询的key存在，则返回该key对应的value.  

判断key是否存在：

info = {"name": "yangbin", "age": 20, "hobby": {"sport": "basketball"}, "gramm": ["java", "python"]}
res = info.get("nameeee", "None")
print res  # None
if res :
    print "OK"
else:
    print "NO"
返回结果为 OK.

res = info.get("nameee", "")
print res  # 返回空，即返回一个空格. 
if res: 
    print "OK"
else:
    print "ON"
返回结果为 NO.

以上方法可用于判断key是否存在.

使用has_key()判断key是否存在.

info = {"name": "yangbin", "age": 20, "hobby": {"sport": "basketball"}, "gramm": ["java", "python"]}
print info.has_key("name")  # True    

if "name" in info:
    print "True"
else:
    print "False"
返回结果为 True.

遍历key与对应的value：

第一种

info = {"name": "yangbin", "age": 20, "hobby": {"sport": "basketball"}, "gramm": ["java", "python"]}
for k,v in info.items():
print k,v

运行结果为： 
hobby {'sport': 'basketball'}
age 20
gramm ['java', 'python']
name yangbin

第二种：不推荐

for i in [x for x in info]:
    print i, info[i] 

运行结果为：
hobby {'sport': 'basketball'}
age 20
gramm ['java', 'python']
name yangbin

注意代码的效率高低问题.

该示例中，如不指定key或value，则默认索引的是key.

info = {"name": "yangbin", "age": 20, "hobby": {"sport": "basketball"}, "gramm": ["java", "python"]}
print [x for x in info]  # ['hobby', 'age', 'gramm', 'name']

根据字典中value的类型提取：

info = {"name": "yangbin", "age": 20, "hobby": {"sport": "basketball"}, "gramm": ["java", "python"]}
for k, v in info.items():
    if type(v) == dict:
        for v2,v3 in v.items():
            print "%s的key and value：" % k
            print v2, v3
    elif type(v) == list:
        for v4 in v:
            print v4
    else:
        print k,v

运行结果：  
=======================
hobby的key and value：
sport basketball
age 20
java
python
name yangbin

判断数据类型的方式:

type

isinstance

>>> a = "python"
>>> type(a)
<class 'str'>
>>> isinstance(a, str)
True
>>>
>>>
>>> b = {"name": "yangbin"}
>>> type(b)
<class 'dict'>
>>> isinstance(b, dict)
True
>>>

统计每个单词出现的次数, 存储为字典的形式:

str_list = "Docker is transitioning all of its open source collaborations to the Moby project going forward.During the transition all open source activity should continue as usual."
str_list_new = str_list.split(" ")  # 以空格为分隔符，将字符进行分割.
str_dic = {}  # 创建空字典，用于存储最后统计的key及key出现的次数.
for i in str_list_new:
    # print i
    if i not in str_dic:
        str_dic[i] = 1
    elif i in str_dic:
        str_dic[i] += 1
print str_dic

对上一例题做操作，即字典翻转拼接为num:word的字典
因为很多单词都出现了一次，一旦k,v翻转，例如数字1作为key,那么这个key的value会一直被覆盖，直到最后一个.
方案是，把出现的数字作为key,所有出现次数一样的单词存为列表，列表允许重复.

res = {'forward.During': 1, 'the': 2, 'all': 2}
if res.has_key("aaaa"):
    res["aaaa"].append("aa")
else:
    res["aaaa"] = []
print res  # {'aaaa': [], 'forward.During': 1, 'the': 2, 'all': 2}

if res.has_key("aaaa"):
    res["aaaa"].append("aa")
else:
    res["aaaa"] = []
print res  # {'aaaa': ['aa'], 'forward.During': 1, 'the': 2, 'all': 2}

print res.setdefault("aaaa", [])  # ['aa']
print res  # {'aaaa': ['aa'], 'forward.During': 1, 'the': 2, 'all': 2}

print res.setdefault("bbbb", [])  # []
print res  # {'aaaa': ['aa'], 'forward.During': 1, 'bbbb': [], 'the': 2, 'all': 2}

# dict.setdefault("key", "value")
# 当key不存在时，默认将key和value插入;
# 当key存在时，则不管.

基于上一步“把单词存为字典”后，将单词与数字翻转拼接：

res = {}
for k,v in str_dic.items():
    res.setdefault(v, [])
    print res
    res[v].append(k)
    print res

字典生成式

格式：
1.在Python2.6或更早的版本，字典生成式可以接受迭代的键/值对：

d = dict((key, value) for (key, value) in iterable)   

# 第一个k,v的()必须写，第二个()可不写.  

2.从Python2.7或者3以后，可以直接用字典推导式语法：

d = {key:value for (key, value) in iterable} 

# for后的k,v的括号可以不写 

3.Python2.7以上兼容两种写法，Python2.6只能用第一种。
4.可以用任何方式的迭代器(list, tuple, 生成式...),只要可迭代对象的元素中有两个值.
示例：

dict1 = {1:2, 3:4, 5:6, 7:8, 9:10}
dict_new = dict((v,k) for k,v in dict1.items())  # 最外面的小括号旁的dict()表示dict函数.
print dict_new  # {8: 7, 2: 1, 4: 3, 10: 9, 6: 5}

dict1 = {1:2, 3:4, 5:6, 7:8, 9:10}
dict_new = {v:k for k,v in dict1.items()}
print dict_new  # {8: 7, 2: 1, 4: 3, 10: 9, 6: 5} 

字符串的格式化：

print "hello %s" % "Ames"  # C语言风格
print "hello {}".format("yangbin")  # C#风格
print "hello {} {}".format("yangbin", "Ames")
print "hello %s %s" % ("yangbin", "Ames") 

运行结果： 
hello Ames
hello yangbin
hello yangbin Ames
hello yangbin Ames

列表的格式化：

例1：

list = ["hello", "1", "7"]
print "%s %d-%d" % ("hello", 7, 1)
print "%s %s:%s" % (list[0], list[1], list[2])
print "%s" % ",".join(list)   

运行结果： 
hello 7-1
hello 1:7
hello,1,7

例2：

lis = ["hello", "1", "7"]
print "{0} {1}:{2}".format("hello", "1", "9")
print "{0} {1}:{2}".format(*lis)
print "{} {}:{}".format("hello", "1", "8")
print "%s %d:%d" % ("hello", 7, 1)
print "%s %s:%s" % (lis[0], lis[1], lis[2])
print "%s" % ",".join(lis)
print '{0} {1}:{2}'.format(*lis)
print "{} {}:{}".format("hello", "1", "7") 

运行结果： 
hello 1:9
hello 1:7
hello 1:8
hello 7:1
hello 1:7
hello,1,7
hello 1:7
hello 1:7 

字典的格式化：

dic = {"name":"yangbin", "age":18}
print "I am %(name)s, my age is %(age)d." % (dic)
print "I am {name}, my age is {age}.".format(**dic)  # 推荐用法.
print "I am {name}, my age is {age}.".format(name="yangbin", age=18)

运行结果： 
I am yangbin, my age is 18.
I am yangbin, my age is 18.
I am yangbin, my age is 18.

文件操作：

w: 并不是写文件时才清空文件，而是在打开文件时就会清空文件，然后等待新文件写入.
a: 意思是读的时候，文件指针在文件开头，写时指针在文件结尾.

open("path")   # 默认只读打开         
open("path", "r+")   # 读写打开，如果有内容，就会从头到尾覆盖相应字符串的内容
open("path", "w")   # 写入，先删除源文件再重新写入，没有文件自己创建 
open("path", "w+")   # 读写，同上 
open("path", "a")   # 写入，在文件末尾追加新内容，文件不存在则创建 
open("path", "a+")   # 读写，同上，最常用。 
open("path", "b")   # 打开二进制文件，要上述模式结合使用，读取图片 
open("path", "U")   # 支持所有的换行符号 值\r \n \r\n

主要用到四步：增 删 改 查.

文件操作：

read(NUM)  # NUM等于1时就是读取一个字节；NUM等于10时就是读取十个字节 
read()  # 不加参数时，就是读取整个文件.  
radline()  # 读取一行. 
readlines()  # 将文件所有行读取到列表中，列表中每项代表一行.    
readlines()和read()一样，将文件内容全部读取出来，当文件特别大时，会将内存占满. 

文件指针： 文件读到什么位置，指针就跟着移动到该位置.

文件指针的方法：

tell():  查询指针所在位置.
seek():  移动指针到指定位置.

file.seek()方法标准格式是：seek(offset,whence=0)
offset：开始的偏移量，也就是代表需要移动偏移的字节数
whence：给offset参数一个定义，表示要从哪个位置开始偏移；0代表从文件开头开始算起，1代表从当前位置开始算起，2代表从文件末尾算起。

示例1：

"red.txt"文件内容如下： 
xiaoming:123456
xiaoqiang:234567
xiaowang:345678 

nam = open("red.txt", "a+")
print nam.readline()  # 每一行结尾处的"\n"(换行符)也算一个字符.
print nam.tell()  # 查询指针所在位置.
nam.seek(0)  # 将指针移动到文件开头第一个字节的位置.
print nam.tell()  # 再次查询指针位置，确认指针在未见开头的位置.
print nam.readlines()  # 将文件所有行读取到列表中
print nam.tell()  # 此时指针在文件末尾处.

运行结果： 
xiaoming:123456

17
0
['xiaoming:123456\n', 'xiaoqiang:234567\n', 'xiaowang:345678']
50

示例2：

file.seek()操作方法示例：
>>> x = file('a.txt','r')
>>> x.tell()      #显示当前游标位置在文件开头
0
>>> x.seek(3)     #移动3个字节，whence没有设置默认为从文件开头开始
>>> x.tell()
3
>>> x.seek(5,1)   #移动5个字节，1代表从当前位置开始
>>> x.tell()
8
>>> x.seek(1,2)
>>> x.tell()
57
>>> x.seek(-2,2)       #表示从文件尾部开始移动指针，向后移动2个字节 
>

当读完文件后需要关闭该文件，但是close()经常容易忘记。
所以推荐使用with：

with open("文件名") as "要赋值的变量名"：  

例：　

with open("red.txt", "a+") as f:
print f.read() 

运行结果：
xiaoming:123456
xiaoqiang:234567
xiaowang:345678