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

list操作总结. dict操作及文件操作的更多相关文章

  1. python基础(六)dict字典和文件操作open

    字典dict 使用key来标注value的数据类型,key和value是一一对应的.在字典中key是唯一的,所以字典也是无序的. #定义一个字典 dict = { 'name' : 'sylar', ...

  2. Python档案袋( 命令行操作 及 Os与Shutil文件操作补充 )

    调用系统命令 import os #调用系统命令,输出只能输出到屏幕上,不能用变量接收 os.system("ipconfig") #调用系统命令,并把执行结果存到变量中 res= ...

  3. 浅谈无缓存I/O操作和标准I/O文件操作差别

    首先,先略微了解系统调用的概念:        系统调用,英文名system call,每一个操作系统都在内核里有一些内建的函数库,这些函数能够用来完毕一些系统系统调用把应用程序的请求传给内核,调用对 ...

  4. 无缓存I/O操作和标准I/O文件操作区别

    本文转载于:http://www.360doc.com/content/11/0521/11/5455634_118306098.shtml 首先,先稍微了解系统调用的概念:       系统调用,英 ...

  5. Python开发【第三章】:Python的文件操作

    一.文件操作模式概述 1.打开文件的模式: r, 只读模式[默认] w,只写模式[不可读:不存在则创建:存在则删除内容:] a, 追加模式[不可读:不存在则创建:存在则只追加内容:] 2." ...

  6. Python小白的发展之路之Python基础(二)【字符串、列表、集合、文件操作】

    列表.元组操作 字符串操作 字典操作 集合操作 文件操作 字符编码与转码 1.列表.元组操作 (1)列表 列表是可变的(mutable)——可以改变列表的内容,这不同于字符串和元组,字符串和元组都是不 ...

  7. Python开发【第三章】:文件操作

    一.文件操作模式概述 1.打开文件的模式: r, 只读模式[默认] w,只写模式[不可读:不存在则创建:存在则删除内容:] a, 追加模式[不可读:不存在则创建:存在则只追加内容:] 2." ...

  8. Python之路第一课Day3--随堂笔记(文件操作)

    一.集合的介绍 1.集合操作 集合是一个无序的,不重复的数据组合,它的主要作用如下: 去重,把一个列表变成集合,就自动去重了 关系测试,测试两组数据之前的交集.差集.并集等关系 常用操作 s = se ...

  9. 【Go语言】集合与文件操作

    本文目录 1.数据集合的主要操作 1_1.字典的声明 1_2.字典的初始化和创建 1_3.字典的访问和操作 1_4.其他类型的数据集 2.文件操作 2_1.文件操作概述os包和path包 2_2.文件 ...

  10. C/C++文件操作2

    一.流式文件操作 这种方式的文件操作有一个重要的结构FILE,FILE在stdio.h中定义如下: typedef struct { int level; /* fill/empty level of ...

随机推荐

  1. 2017中国大学生程序设计竞赛 - 女生专场B【DP】

    B HDU - 6024 [题意]:n个教室,选一些教室建造糖果商店. 每个教室,有一个坐标xi和在这个教室建造糖果商店的花费ci. 对于每一个教室,如果这个教室建造糖果商店,花费就是ci,否则就是与 ...

  2. Codeforces 702C Cellular Network(二分)

    题目链接:http://codeforces.com/problemset/problem/702/C 题意: 在数轴上有N个城市和M个信号塔,给你这N个城市以及M个塔在数轴上的位置,求M个塔可以覆盖 ...

  3. HDU 6313: Hack it

    Hack It Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)Total Sub ...

  4. Web应用渗透测试框架Arachni

    Web应用渗透测试框架Arachni   Arachni是一款Ruby语言编写的Web应用渗透测试框架.当用户指定目标后,该框架可以自动扫描网站页面,对页面中的链接.表单.Cookie.HTTP He ...

  5. (转)解析json xml

    JSON数据 {"videos":[{"id":1,"image":"resources/images/minion_01.png ...

  6. 浅谈Java中final,finalized,finally

    final: final可以让你控制你的成员.方法或者是一个类是否可被覆写或继承等功能,这些特点使final在Java中拥有了一个不可或缺的地位,也是学习Java时必须要知道和掌握的关键字之一. fi ...

  7. BZOJ 1529 [POI2005]ska Piggy banks(并查集)

    [题目链接] http://www.lydsy.com/JudgeOnline/problem.php?id=1529 [题目大意] 给出一张n个点n条边的有向图,问选取几个点为起点可以遍历全图 [题 ...

  8. python基础-协程函数、递归、模块、包等内容

    1. 协程函数 1.1 yield基本用法 yield作用 1.把函数的执行结果封装好,即封装__iter__和__next__,即得到一个迭代器 2.与return功能类似,都可以返回值,但不同的是 ...

  9. NSPredicate 谓词总结 数组过滤 模糊匹配

    NSPredicate 用于指定过滤条件,主要用于从集合中分拣出符合条件的对象,也可以用于字符串的正则匹配. NSPredicate常用方法介绍 1.创建NSPredicate(相当于创建一个过滤条件 ...

  10. Java杂谈2——引用与跟搜索算法

    Java中的引用 Java“引用”的概念源于C++,原本的定义相当有限:一个引用(Reference)代表的内存通常用于指向另一块内存区域的起始地址.通过引用类型保存的起始地址,可以找到这个引用所指向 ...