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") # 支持所有的换行符号 值
主要用到四步：增 删 改 查.
文件操作：
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() # 每一行结尾处的"
"(换行符)也算一个字符.
print nam.tell() # 查询指针所在位置.
nam.seek(0) # 将指针移动到文件开头第一个字节的位置.
print nam.tell() # 再次查询指针位置，确认指针在未见开头的位置.
print nam.readlines() # 将文件所有行读取到列表中
print nam.tell() # 此时指针在文件末尾处.
运行结果：
xiaoming:123456
17
0
['xiaoming:123456
', 'xiaoqiang:234567
', '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