Python基础、判断、循环、列表、字典，day1

一、Python 简介

1、介绍

Python 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。

Python 的设计具有很强的可读性，相比其他语言经常使用英文关键字，其他语言的一些标点符号，它具有比其他语言更有特色语法结构。

• Python 是一种解释型语言： 这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。
  

• Python 是交互式语言： 这意味着，您可以在一个Python提示符，直接互动执行写你的程序。

• Python 是面向对象语言: 这意味着Python支持面向对象的风格或代码封装在对象的编程技术。

• Python 是初学者的语言：Python 对初级程序员而言，是一种伟大的语言，它支持广泛的应用程序开发，从简单的文字处理到 WWW 浏览器再到游戏。

2、Python发展历史

Python 是由 Guido van Rossum 在八十年代末和九十年代初，在荷兰国家数学和计算机科学研究所设计出来的。

Python 本身也是由诸多其他语言发展而来的,这包括 ABC、Modula-3、C、C++、Algol-68、SmallTalk、Unix shell 和其他的脚本语言等等。

像 Perl 语言一样，Python 源代码同样遵循 GPL(GNU General Public License)协议。

现在 Python 是由一个核心开发团队在维护，Guido van Rossum 仍然占据着至关重要的作用，指导其进展。

3、Python特点

• 1.易于学习：Python有相对较少的关键字，结构简单，和一个明确定义的语法，学习起来更加简单。

• 2.易于阅读：Python代码定义的更清晰。

• 3.易于维护：Python的成功在于它的源代码是相当容易维护的。

• 4.一个广泛的标准库：Python的最大的优势之一是丰富的库，跨平台的，在UNIX，Windows和Macintosh兼容很好。

• 5.互动模式：互动模式的支持，您可以从终端输入执行代码并获得结果的语言，互动的测试和调试代码片断。

• 6.可移植：基于其开放源代码的特性，Python已经被移植（也就是使其工作）到许多平台。

• 7.可扩展：如果你需要一段运行很快的关键代码，或者是想要编写一些不愿开放的算法，你可以使用C或C++完成那部分程序，然后从你的Python程序中调用。

• 8.数据库：Python提供所有主要的商业数据库的接口。

• 9.GUI编程：Python支持GUI可以创建和移植到许多系统调用。

• 10.可嵌入: 你可以将Python嵌入到C/C++程序，让你的程序的用户获得"脚本化"的能力。

4、Python2.x与3.x版本区别

• 1/2变成了0.5

• print "Hello World"变成了print("Hello World")

• raw_input()没了，变成了input()

• class Foo:写法不能用了，只能class Foo(object)

• 默认支持输入中文，不用在代码里输入# -*- coding: utf-8 -*-

二、环境准备

安装python

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

yum install readline-devel    解决方向键与退格键无法使用问题，要在安装python前安装，否则无法实现。   tar xvf Python-*.tgz   cd Python-*   ./configure --prefix=/usr/local/python*   make   make install   mv /usr/bin/python /usr/bin/python_old   ln -s /usr/local/python*/bin/python /usr/bin/   python          # 查看版本       解决YUM无法使用的问题   vim /usr/bin/yum   首行#!/usr/bin/python 替换为老版本python  #!/usr/bin/python2.4  注意可能为2.6       pip模块安装   yum install python-pip

三、Python IDE

PyCharm是由JetBrains打造的一款Python IDE。

PyCharm具备一般 Python IDE 的功能，比如：调试、语法高亮、项目管理、代码跳转、智能提示、自动完成、单元测试、版本控制等。

另外，PyCharm还提供了一些很好的功能用于Django开发，同时支持Google App Engine，更酷的是，PyCharm支持IronPython。

常用快捷键

Ctrl + /
注释(取消注释)选择的行

Shift + Enter
开始新行

Ctrl + Enter
智能换行

TAB Shift+TAB
缩进/取消缩进所选择的行

Ctrl + Alt + I
自动缩进行

Ctrl + Y
删除当前插入符所在的行

Ctrl + D
复制当前行、或者选择的块

Ctrl + Shift + J
合并行

Ctrl + Shift + V
从最近的缓存区里粘贴

Ctrl + Delete
删除到字符结尾

Ctrl + Backspace
删除到字符的开始

Ctrl + NumPad+/-
展开或者收缩代码块

Ctrl + Shift + NumPad+
展开所有的代码块

Ctrl + Shift + NumPad+
收缩所有的代码块

四、Python 的变量及数据类型 

数据类型 一个程序要运行，就要先描述其算法。描述一个算法应先说明算法中要用的数据，数据以变量或 常量的形式来描述。每个变量或常量都有数据类型。Python 的基本数据类型有 5 种：整型(int), 浮点型(float), 字符型(string), 布尔型（bool）,空值(None).

1.整数

Python 可处理任意大小的整数，在程序中的表示方法和数学上的写法完全一样。

2.浮点数

浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的，比如，1.23x109 和 12.3x108  是相等的。浮点数可以用数学写法，如  1.23 ，3.14 ， -9.01 ，等等。但是对于很大或很小的浮点数，就必须用科学计数法表示，把 10用 e 替代，1.23x109 就是 1.23e9 ，或者 12.3e8 ，0.000012 可以写成 1.2e-5 ，等等。整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的（除法难道也是精确的？是的！），而浮点数运算则可能会有四舍五入的误差。

3.字符串

字符串是以''或""括起来的任意文本，比如 'abc' ， "xyz" 等等。请注意，''或""本身只是一种表示方式，不是字符串的一部分，因此，字符串 'abc' 只有 a ， b ， c  这 3 个字符。如果 ' 本身也是一个字符，那就可以用""括起来，比如 "I'm OK" 包含的字符是 I ， ' ， m ，空格， O ， K 这 6 个字符。'''...''' 的格式表示多行内容print '''line1 line2 line3'''。

4.布尔值

布尔值和布尔代数的表示完全一致，一个布尔值只有 True 、False 两种值，要么是 True ，要么是 False ，在 Python 中，可以直接用 True 、 False 表示布尔值（请注意大小写），也可以通过布尔运算计算出来：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

>>>  True True >>>  False False >>>  3  >  2  True >>>  3  >  5  False   布尔值可以用 and 、 or 和 not 运算。   and  运算是与运算，只有所有都为 True ， and  运算结果才是 True ：   >>>  True and  True True >>>  True and  False False >>>  False and  False False   or 运算是或运算，只要其中有一个为 True ， or 运算结果就是 True ：   >>>  True or True True >>>  True or False True >>>  False or False False   not 运算是非运算，它是一个单目运算符，把  True 变成 False ， False 变成 True ：   >>>  not True False >>>  not False True   布尔值经常用在条件判断中，比如：   if age  >=  18:       print 'adult'   else:       print 'teenager'

5.空值

空值是 Python 里一个特殊的值，用 None  表示。 None  不能理解为 0 ，因为 0  是有意义的，而 None  是一个特殊的空值

 

五、条件判断

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

valid_user = 'jack'   valid_passwd = 'jack111'   user_input = input("Your username:")   passwd = input("Your password:")   if user_input == valid_user and  passwd == valid_passwd:       print(Welcome %s login  to our  system!" % user_input)   elif  user_input == 'guest':       print(Welcome %s login  our system,but you only  have  read-only access,enjoy!)　　   else:   print  "invalid username! Byebye!"

这里我们用到了 elif,意思就是，如果不满足第一个 if 条件，那程序就会继续往下走，再判断 是否满足 elif 条件，如果不满足，就再继续走（这里你可以加多个 elif 判断），只要遇到有 满足的 elif 就停下来执行它后面的代码，然后结束，如果最终没有碰到满足的条件，就最终执 行 else 语法。另外真的可以写多行噢，如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

if <条件判断 1>:   <执行 1>   elif <条件判断 2>:   <执行 2>   elif <条件判断 3>:   <执行 3>   else:   <执行 4>

 

for循环

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

valid_user = 'jack'   valid_passwd = 'jack111'   for i in range(3):       user_input = raw_input("Your username:")       passwd = raw_input("Your password:")       if user_input == valid_user and  passwd == valid_passwd:           print （"Welcome %s login  to our  system!" % user_inpu)           break       elif  user_input == 'guest':           print ("Welcome %s login  our  system,but you  only  have read-only access,enjoy!" % user_inpu   　　  break       else:           print ("invalid username!")

这个代码实现了，如果用户名密码错误后，最多让用户尝试 3 次，注意这里用到了 break,它是用来帮助跳出整个循环的，就是现在你的程序要循环 3 次，但是用 户再尝试了第 2  次时，就验证成功了，这时候你还需要让他再进行一次验证吗？当然不需要， 这时候需要让程序在验证成功后直接跳出整个循环，不再需要进行下一次循环操作。

while循环

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

import time  #导入time模块   count  = 0    #设置一个计数器，每循环一次加一次，这样就知道循环多少次了。   while  True:   #只要为真，就执行下面代码，每循环一次就判断一次       count  += 1 #每循环一次就自加1       print （"Loop  ", count）       time.sleep(10) #每循环一次就 sleep  10s 再继续运行   输出：   Loop 1   Loop 2   Loop 3   ...

上面的程序就是死循环了，只要进程没被杀死，就会一直运行下去

continue VS break

跟 break 相对应的还有一个负责循环跳出的语法就是 continue，它跟 break 有什 么区别呢？我们都知道了 break 是负责跳出整个循环，但 continue 是跳出本次 循环，继续下一次循环。就是说，循环过程中，如果遇到 continue,那这一次循 环本应该执行的后面的代码就不执行了，直接跳过了，直接进行下一次循环了。

注意：当遇到多层嵌套循环时，break只跳出当前嵌套里的循环，不会跳出所有嵌套循环。

 

六、列表、元组和字典

列表(List)

列表是在编程中经常用到的一种数据类型，它跟其它语言中所指的数组基本是一 样的，列表是指一组有序的数据集合，可以将各种各样的数据有序的存放在列表 中，并且可以对其进行增删改查，以及遍历。列表的存在是为了通过一个变量存 储更多的信息，比如我想在一个变量里存储一张购物清单，然后程序只需要通过 我定义的这个变量就可以找到购物清单中的任意一个或多个商品。如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79

>>> shopping_list = ['Iphone', 'Mac',  'Bike','Coffee','Car','Clothes','Food','Gift']   >>> shopping_list   ['Iphone', 'Mac',  'Bike', 'Coffee', 'Car',  'Clothes', 'Food', 'Gift']   通过 len()内置函数可查看列表中元素的个数   >>> len(shopping_list)   8   你可以通过索引来找到列表中每个元素的位置，记住索引是从 0 开始的   >>> shopping_list[2] #找Bike   'Bike'   >>> shopping_list[0] #第一个元素取出来   'Iphone'   >>> shopping_list[-1] #-1代表取列表中最后一个元素   'Gift'   >>> shopping_list[-3] #取倒数第3位元素   'Clothes'   >>> shopping_list[-4] #取倒数第4个元素   'Car'   >>> shopping_list[8] #取索引为8的元素   Traceback (most  recent  call last):   File "<stdin>", line 1, in <module> IndexError: list index  out of range   #最后一个shopping_list[8]报错了，原因是引用超出了索引范围，不是有8 个元素吗？取第8个怎么会出错呢？这里要注意了，列表的索引是从0开始的， 你这里写的8其实是取了列表中的第9个位置，但你列表中一共有8个元素，所以 肯定取不到喽。   切片(Slice)   你还可以从列表中取出指定多个元素，这种操作叫做切片   >>> shopping_list   ['Iphone', 'Mac',  'Bike', 'Coffee', 'Car',  'Clothes', 'Food', 'Gift']   >>>   >>> shopping_list[0:3] #取0到第3个元素，不包括第4个   ['Iphone', 'Mac',  'Bike']   >>> shopping_list[:3] #同上，取0到第3个元素，不包括第4个，0可以不写   ['Iphone', 'Mac',  'Bike']   >>> shopping_list[2:5] #取第3至第5个元素   ['Bike', 'Coffee', 'Car']   >>> shopping_list[:-3] #取从0至倒数第3个元素   ['Iphone', 'Mac',  'Bike', 'Coffee', 'Car']   >>> shopping_list[-3:] #取最后3个元素   ['Clothes', 'Food', 'Gift']   >>> shopping_list[1:8:2]    #从1至8隔一个取一个，后面的2是步长，即每隔几个元素取一个   ['Mac', 'Coffee', 'Clothes', 'Gift']   >>> shopping_list[::2] #从头到位每隔一个取一个   ['Iphone', 'Bike', 'Car',  'Food']

 

增删改查

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75

>>> shopping_list.append('MovieTicket') #向列表后面追加一个元素   >>> shopping_list   ['Iphone', 'Mac',  'Bike', 'Coffee', 'Car',  'Clothes', 'Food', 'Gift', 'MovieTicket']   >>> shopping_list.pop() #删除最后一个元素   'MovieTicket'   >>> shopping_list.remove('Mac') #删除叫’Mac’的元素，如果有多个’Mac’,那会删除从左边数找到的第一 个   >>> shopping_list[2]   'Coffee'   >>> shopping_list[2] = 'COFFEE' #将索引为2的元素改为”COFFEE”，原来是小写   >>> shopping_list.insert(3,"Toy") #插入一个新元素，索引为3   >>> shopping_list        ['Iphone', 'Bike', 'COFFEE', 'Toy',  'Car',  'Clothes', 'Food', 'Gift']   >>> shopping_list.index('Toy') #返回’Toy’元素的索引值，如果有多个相同元素，则返回匹配的第一个   3   >>> shopping_list.append('Food')   >>> shopping_list.count('Food') #统计’Food’的元素的个数，刚添加了一个，所以现在是2个   2   >>> shopping_list   ['Iphone', 'Bike', 'COFFEE', 'Toy',  'Car',  'Clothes', 'Food', 'Gift', 'Food']   >>> list2=  ['Banana','Apple'] #创建一个新列表   >>> shopping_list.extend(list2) #把上面的新列表合并到shopping_list中   >>> shopping_list   ['Iphone', 'Bike', 'COFFEE', 'Toy',  'Car',  'Clothes', 'Food', 'Gift', 'Food', 'Banana',   'Apple']   >>> shopping_list.sort() #将列表排序   >>> shopping_list   ['Apple', 'Banana', 'Bike', 'COFFEE', 'Car', 'Clothes', 'Food', 'Food', 'Gift', 'Iphone',   'Toy']   >>> shopping_list.reverse() #将列表反转   >>> shopping_list   ['Toy', 'Iphone', 'Gift', 'Food', 'Food', 'Clothes', 'Car',  'COFFEE', 'Bike', 'Banana',   'Apple']   >>> del shopping_list[3:8] #删除索引3至8的元素，不包括8   >>> shopping_list   ['Toy', 'Iphone', 'Gift', 'Bike', 'Banana', 'Apple']   >>> for i in shopping_list: #遍历列表   ...    print  i

元组（Tuple）

另一种有序列表叫元组：tuple。tuple 和 list 非常类似，但是 tuple 一旦初始化就不能修改

字典（Dict）

列表允许你通过一个变量存储大量的信息，但试想以下场景，用列表实现就可能 效率较低了：

1. 存储的信息量越来越多，有的时候找一个数据可能要循环整个列表，耗时较 长。

2. 单个元素包含的信息量变多时，比如，之前只是存储姓名列表，现在是要存 储姓名、年龄、身份证号、地址、工作等这个人的很多信息，用列表去存储 很费劲

3. 要求存储的数据是不重复，我们知道列表是允许的重复值的，当然想存储时 就让我的数据默认就是唯一的话，用列表就不可以了

以上这些是列表不擅长的地方，却恰恰是dict 所擅长的， dict 使用 key-­‐value 的形式存储数据，dict 的 key  是唯一的，所以你可以通过 key 来唯一的定位到你的数据。之所以叫字典(在其它语言中称为 map)，是因为 dict 的数据结构跟我们生活中用的字典是一样的，查英文字典时，输入单词，就可以 定位到这个单词意思的详细解释，其中这个单词就是 key,对应的词义解释就是 value.字典有如下特点：

1.   key-­‐value 格式，key 是唯一的

2. 无序，与列表有序的特点不同，字典是无序的，列表只所以有序是因为你需 要通过索引来定位相应元素，而字典已经可以通过 key 来定位相应 value,因 此为了避免浪费存储空间，字典不会对数据的位置进行纪录，当然如果你想 让其变成有序的，也是有方法的，这个我们以后再讲。

3.   查询速度很快，dict 是基于 hash 表的原理实现的，是根据关键字（Key value） 而直接访问在内存存储位置的数据结构。也就是说，它通过把键值通过一个 函数的计算，映射到表中一个位置来访问记录，这加快了查找速度。这个映 射函数称做散列函数，存放记录的数组称做散列表。由于通过一个 key 的索 引表就直接定位到了内存地址，所以查询一个只有 100 条数据的字典和一个

100 万条数据的字典的速度是查不多的。

 

好了，来看看 dict 的语法：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131

>>> info = {'name':'alex',   'job':'engineer',   'age':  29,   'company':'AUTOHOME'   }   >>> info   {'age': 29, 'job':  'engineer', 'company': 'AUTOHOME', 'name': 'alex'}   增删改查   >>> info['name'] #查看key为’name’的value   'alex'   >>> info['job'] = 'Boss'  #将key 的value 改为’Boss’   >>> info   {'age': 29, 'job':  'Boss', 'company': 'AUTOHOME', 'name': 'alex'}   >>> info['city'] = 'BJ' #如果dict中有key为’city’,就将其值改为’BJ’,如果没有这个key,就创建一条新 纪录   >>> info   {'age': 29, 'job':  'Boss', 'company': 'AUTOHOME', 'name': 'alex', 'city': 'BJ'}   >>> info.pop('age') #删除key为’age’的数据，跟del info[‘age’] 一样   29   >>> info   {'job': 'Boss', 'company': 'AUTOHOME', 'name': 'alex', 'city': 'BJ'}   >>> info.popitem() #随机删除一条数据，dict为空时用此语法会报错        ('job', 'Boss')   >>> info.items() #将dict的key,value转换成列表的形式显示   [('company', 'AUTOHOME'), ('name', 'alex'), ('city', 'BJ')]   >>> info.has_key('name') #判断字典中是否有个叫’name’的key   True　　   >>> info['age'] #查找一个不存在的key报错，因为’age’刚才已经删除了，所以报错   Traceback (most  recent  call last): File "<stdin>", line 1, in <module>   KeyError: 'age'   >>> info.get('age') #查找key,如果存在则返回其value,否则则返回None   >>> info.get('name')   'alex'   >>> info.clear() #清空dict   >>> info   {}   >>> info.fromkeys(['a','b','c'],'Test') #根据列表[‘a’,’b’,’c’]来创建dict里的key,后面 的’Test’是默认value,如果不指定的话则为None   {'a':  'Test', 'c': 'Test', 'b': 'Test'}   >>> info   {}   >>> info =info.fromkeys(['a','b','c'],'Test')   >>> info   {'a':  'Test', 'c': 'Test', 'b': 'Test'}   >>> info.setdefault('d','Alex') #找一个key为’d’的纪录，如果这个key不存在，那就创建一个叫’d’的key,   并且将其value设置为’Alex’， 如果这个key存在，就直接返回这个key的value，见下一条   'Alex'   >>> info.setdefault('c','Alex')   'Test'   >>> info   {'a':  'Test', 'c': 'Test', 'b': 'Test', 'd': 'Alex'}   >>> dict2  = {'e':'fromDict2','a':'fromDict2'} #创建一个新字典   >>> info.update(dict2) #拿这个新字典去更新info,注意dict2中有一个key值’a’与dict info相冲突，这 时dict2的值会覆盖info中的a,如果dict2的key在info中不存在，则创建相应的纪录   >>> info   {'a':  'fromDict2', 'c': 'Test', 'b': 'Test', 'e': 'fromDict2', 'd': 'Alex'}   遍历 dict 与遍历列表差不多，只不过要记得 dict 是 key-­‐value 的结构，要想在遍 历时同时打印这 key  和 value，需要这样写：   info = {   'name': 'Alex Li',   'age': 29,   'job': 'Engineer',   'phone': 1493335345   }   for item in info:   print(item, info[item]) #print item 只会打印 key,如果想同时打印 value,需要再通过 item 去取   还有一种遍历的方式：   for key,val in info.items():       print(key,val)

字符串、列表、元组、字典互转

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48

#-*-coding:utf-8-*-   #1、字典 dict = {'name': 'Zara', 'age': 7, 'class': 'First'}   #字典转为字符串，返回：<type 'str'> {'age': 7, 'name': 'Zara', 'class': 'First'} print type(str(dict)), str(dict)   #字典可以转为元组，返回：('age', 'name', 'class') print tuple(dict) #字典可以转为元组，返回：(7, 'Zara', 'First') print tuple(dict.values())   #字典转为列表，返回：['age', 'name', 'class'] print list(dict) #字典转为列表 print dict.values   #2、元组 tup=(1, 2, 3, 4, 5)   #元组转为字符串，返回：(1, 2, 3, 4, 5) print tup.__str__()   #元组转为列表，返回：[1, 2, 3, 4, 5] print list(tup)   #元组不可以转为字典   #3、列表 nums=[1, 3, 5, 7, 8, 13, 20];   #列表转为字符串，返回：[1, 3, 5, 7, 8, 13, 20] print str(nums)   #列表转为元组，返回：(1, 3, 5, 7, 8, 13, 20) print tuple(nums)   #列表不可以转为字典   #4、字符串   #字符串转为元组，返回：(1, 2, 3) print tuple(eval("(1,2,3)")) #字符串转为列表，返回：[1, 2, 3] print list(eval("(1,2,3)")) #字符串转为字典，返回：<type 'dict'> print type(eval("{'name':'ljq', 'age':24}"))

python 将嵌套列表转为字典的方法

1 2 3

new_list= [['key1','value1'],['key2','value2'],['key3','value3']]   print(dict(new_list))

简单的一些文件操作

1 2 3 4 5 6 7 8 9 10 11 12 13 14

file_list = open('filename.txt','r')   or   file_list = file('filename.txt','r')   for line in file_list.read():    print line  # 全量读   for line in file_list.readlines():     print line  # 读取所有行，（列表）   for line in file_list.xreadlines():     print line # 一行一行读（每次只读一行）

例子，将用户每登陆一次，记录一次登陆次数（通过操作文件实现）

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

file_obj = file('log.txt','r+')  line_list = file_obj.readlines    my_list = []  #my_list = ['allen;123;1','yyh';123;2]  for ele in line_list:     #"allen;123;1\n"     line = line.strip()     #"allen;123;1"     value_list = lines.split(';')     #["allen","123","1"]     last_value = int(values_list[-1])     #最后一个数，转换成整型     last_value += 1     #1 += 1 --> last_value +1     value_list[-1] = str(last_value)     #更新后的列表     #["allen","123","2"]     value_str = ';'.join(value_list)     #"allen;123;2     #"yyh;123;3"     my_list.append(value_str)     #my_list = ["allen;123;2","yyh;123;3"]  file_obj.seek(0)  my_str = '\n'.join(my_list)  file_obj.write(my_str)  file_dbj.close()

来自为知笔记(Wiz)