python基础学习（二）——基础2
1. 列表、元组操作
列表：类似于Java中的数组；
元组：类似于Java中的集合。
列表是我们最以后最常用的数据类型之一，通过列表可以对数据实现最方便的存储、修改等操作。
定义列表
1 |
names = ['Alex',"Tenglan",'Eric'] |
通过下标访问列表中的元素，下标从0开始计数
1 2 3 4 5 6 7 8 |
>>> names[0] 'Alex' >>> names[2] 'Eric' >>> names[-1] 'Eric' >>> names[-2] #还可以倒着取 'Tenglan' |
切片:取多个元素
>>> names= ["Alex","Tenglan","Eric","Rain","Tom","Amy"]
>>>names[1:4] #取下标1至下标4之间的数字，包括1，不包括4
['Tenglan', 'Eric', 'Rain']
>>>names[1:-1] #取下标1至-1的值，不包括-1
['Tenglan', 'Eric', 'Rain', 'Tom']
>>>names[0:3]
['Alex', 'Tenglan', 'Eric']
>>>names[:3] #如果是从头开始取，0可以忽略，跟上句效果一样
['Alex', 'Tenglan', 'Eric']
>>>names[3:] #如果想取最后一个，必须不能写-1，只能这么写
['Rain', 'Tom', 'Amy']
>>>names[3:-1] #这样-1就不会被包含了
['Rain', 'Tom']
>>>names[0::2] #后面的2是代表，每隔一个元素，就取一个（0到-1，步长为2）
['Alex', 'Eric', 'Tom']
>>>names[::2] #和上句效果一样
['Alex', 'Eric', 'Tom']
>>> names
['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy']
>>>names.append("我是新来的")
>>> names
['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy', '我是新来的']
插入
['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy', '我是新来的']
>>>names.insert(2,"强行从Eric前面插入")
>>> names
['Alex', 'Tenglan', '强行从Eric前面插入', 'Eric', 'Rain', 'Tom', 'Amy', '我是新来的']
>>>names.insert(5,"从eric后面插入试试新姿势")
>>> names
['Alex', 'Tenglan', '强行从Eric前面插入', 'Eric', 'Rain', '从eric后面插入试试新姿势', 'Tom', 'Amy', '我是新来的']
>>> names
['Alex', 'Tenglan', '强行从Eric前面插入', 'Eric', 'Rain', '从eric后面插入试试新姿势', 'Tom', 'Amy', '我是新来的']
>>>names[2] = "该换人了"
>>> names
['Alex', 'Tenglan', '该换人了', 'Eric', 'Rain', '从eric后面插入试试新姿势', 'Tom', 'Amy', '我是新来的']
删除
>>> names
['Alex', 'Tenglan', 'Eric', 'Rain', '从eric后面插入试试新姿势', 'Tom', 'Amy', '我是新来的']
>>> del names[4]
>>> names
['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy', '我是新来的']
>>>names.remove("Eric") #删除指定元素
>>> names
['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy', '我是新来的']
>>>names.pop() #删除列表最后一个值
'我是新来的'
>>> names
['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy']
['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy']
>>> b =[1,2,3]
>>>names.extend(b)
>>> names
['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy', 1, 2, 3]
Names.index(“Xiedi”);可以返回xiedi所在的位置。
Names.clear(); 清空；
Names.reverse();翻转；
Names.sort();排序；以首字母顺序排序。
拷贝
['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy', 1, 2, 3]
>>>name_copy = names.copy()
>>>name_copy
['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy', 1, 2, 3]
此时，Name2=name：此时只是地址复制，一改全改，与字符串不一致。
copy真的这么简单么？那我还讲个屁。。。
深复制还是浅复制：
name_copy =names.copy()：是浅复制。
如果[]中还有一个[]，即[a,[]],则用上面方法，子[]中的值会相互关联，改其中一个，另一个也会发生变化，此为浅复制。
如果要实现深复制，则：
Import copy
Name2=copy.deepcopy(names);#此时实现深copy。
复制的三种方式：
1）names=name；主要是复制地址，内容同步；
2）names=name.copy（）；浅复制，列表中有列表时，子列表的内容只复制地址；
3）Import copy
Name2=copy.deepcopy(names);#此时实现深copy。
浅copy可以作为联合账号的使用。
统计
>>> names
['Alex', 'Tenglan', 'Amy', 'Tom', 'Amy', 1, 2, 3]
>>>names.count("Amy")
2
排序&翻转
['Alex', 'Tenglan', 'Amy', 'Tom', 'Amy', 1, 2, 3]
>>>names.sort() #排序
Traceback (mostrecent call last):
File "<stdin>", line 1, in <module>
TypeError:unorderable types: int() < str() #3.0里不同数据类型不能放在一起排序了，擦
>>>names[-3] = '1'
>>>names[-2] = '2'
>>>names[-1] = '3'
>>> names
['Alex', 'Amy', 'Amy', 'Tenglan', 'Tom', '1', '2', '3']
>>>names.sort()
>>> names
['1', '2', '3', 'Alex', 'Amy', 'Amy', 'Tenglan', 'Tom']
>>>names.reverse() #反转
>>> names
['Tom', 'Tenglan', 'Amy', 'Amy', 'Alex', '3', '2', '1']
>>> names
['Tom', 'Tenglan', 'Amy', 'Amy', 'Alex', '3', '2', '1']
>>>names.index("Amy")
2 #只返回找到的第一个下标
元组
元组其实跟列表差不多，也是存一组数，只是它一旦创建，便不能再修改，所以又叫只读列表
语法
1 |
names = ("alex","jack","eric") |
它只有2个方法，一个是count,一个是index，完毕。
程序练习
请闭眼写出以下程序。
程序：购物车程序
需求:
1. 启动程序后，让用户输入工资，然后打印商品列表
2. 允许用户根据商品编号购买商品
3. 用户选择商品后，检测余额是否够，够就直接扣款，不够就提醒
4. 可随时退出，退出时，打印已购买商品和余额
优化购物车：
用户入口：
1、商品信息存在文件中；
2、已购商品，余额记录，长时间留存。
商家入口：
3、可以添加商品，修改商品价格；
伪代码：
Goods_tuple = [[1, bike, 800],[2, drink,20],[3, shoes, 500],[4, cloth, 800]]
Salary = Input（请输入工资：）
#列出能购买的商品：
For(i=0,i<=length(goods_tuple),i++):
If(salary>=goods_tuple[i][2]):
Print(goods_tyuple[i])
#客户根据商品编号购买商品：
num=input（请输入商品编号：）
good = goods_tuple[num-1]
if（salary>=good[2]）:
balance = salary-good[2]
else:
print(“哥，钱不够，别乱买！！！”)
#显示可以购买的商品：
For(i=0,i<=length(goods_tuple),i++):
If(balance >=goods_tuple[i][2]):
Print(goods_tyuple[i])
#可随时退出:
Print（已购买商品+余额）
代码：
#!/usr/bin/env python
# _*_ UTF-8 _*_
product_list=[
('Iphone', 5800),
('Mac Pro', 9800),
('Bike', 800),
('Watch', 10600),
('coffee', 31),
('Alex Python', 120)
]
shopping_list=null
salary = input("Input your salary:")
if salary.isdigit():
salary=int(salary)
while True:
for item in enumerate(product_list):
#enumerate:取出下标，
#print(product_list.index(item),item)
print(index, item)
user_choice = input("选择要买吗？》》》：")
if user_choice.isdigit():
user_choice=int(user_choice)
if user_choice<len(product_list) and user_choice>=0:
p_item=product_list[user_choice]
if p_item[1]<=salary: #买得起
shopping_list.append(p_item)
salary-=p_item[1]
print("Added %s intoshopping cart, your current balance is \033[31;1m%s\033[0m" %(p_item, salary))
else:
print("\033[41;1m你的余额只剩[%s]啦\033[0m" % salary)
else:
print("prodcutcode[%s] is not exist!" % user_choice)
elif user_choice=='q':
print("-------------shoppinglist-------------")
for p in shopping_list:
print(p)
print("Your currentbalance:", salary)
exit()
else:
print("invalideoption")
Enumerate的用法：
- 对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值
- enumerate多用于在for循环中得到计数，能同时取出index和value。
- 对于列表，会将其每一个元素加索引，然后取其index和value；
- 对于字符串，会将其每一个字母加索引，然后取其index和value。
例如：
importstring
s =string.ascii_lowercase
e =enumerate(s)
prints
printlist(e)
在同时需要index和value值的时候可以使用 enumerate。
2. 字符串操作
特性：不可修改
name.capitalize() 首字母大写
name.casefold() 大写全部变小写
name.center(50,"-") 输出 '---------------------AlexLi----------------------'
name.count('lex') 统计lex出现次数
name.encode() 将字符串编码成bytes格式
name.endswith("Li") 判断字符串是否以 Li结尾,返回TRUE或者FALSE。
"Alex\tLi".expandtabs(10) 输出'Alex Li'， 将\t转换成多长的空格
name.find('A') 查找A,找到返回其索引， 找不到返回-1
format :（格式化使用，主要进行多个值得传值。）
>>> msg = "my name is {}, and age is {}"
>>> msg.format("alex",22)
'my name is alex, and age is 22'
>>> msg = "my name is {1}, and age is {0}"
>>> msg.format("alex",22)
'my name is 22, and age is alex'
>>> msg = "my name is {name}, and age is {age}"
>>> msg.format(age=22,name="ale")
'my name is ale, and age is 22'
format_map：
>>> msg.format_map({'name':'alex','age':22})
'my name is alex, and age is 22'
msg.index('a') 返回a所在字符串的索引
'9aA'.isalnum() 是否阿拉伯数字或字符，True
‘9ad’.isalpha() 是否纯英文字符
‘ead’.isdecimal() 是否十进制
'9'.isdigit() 是否整数
name.isnumeric 是否合法的标识符
name.isprintable 是否可以打印
name.isspace 是否空格
name.istitle 是否每个字符大写
name.isupper 是否大写
"|".join(['alex','jack','rain']) join：连接各字符串。
'alex|jack|rain'
Name.ljust(50,’*’) 在末尾加上*
Name.rjust(50,’_’) 在开始加上_
Name.lower() 把大写变成小写
Name.upper() 把小写变成大写
Name.lstrip() 去除左边的空格
Name.rstrip() 去除右边的空格
Name.strip() 取出两边的空格
maketrans
>>> intab = "aeiou" #This is the string having actual characters.
>>> outtab = "12345"#Thisis the string having corresponding mapping character
>>> trantab = str.maketrans(intab,outtab) #把字符串转成对应的后面的值，即建立一个对应关系。然后再用这个对应关系去加密其他的字符串。
>>>
>>> str = "this is string example....wow!!!"
>>> str.translate(trantab)
'th3s 3s str3ng 2x1mpl2....w4w!!!'
Name.rfind(‘l’):找到最右边的值得下标。
msg.partition('is') 输出 ('my name ', 'is', ' {name}, and age is {age}')
>>> "alex li, chinese name is lijie".replace("li","LI",1)
'alex LI, chinese name is lijie'
msg.swapcase 大小写互换
msg.split(‘l’) : 将字符串按照规则分开。
>>> msg.zfill(40) 不足的用0填充。
'00000my name is{name}, and age is {age}'
>>>n4.ljust(40,"-")
'Hello2orld-----------------------------'
>>> n4.rjust(40,"-")
'-----------------------------Hello2orld'
>>> b="ddefdsdff_哈哈"
>>>b.isidentifier() #检测一段字符串可否被当作标志符，即是否符合变量命名规则
True
3. 字典操作
字典一种key - value 的数据类型，使用就像我们上学用的字典，通过笔划、字母来查对应页的详细内容。
语法:
info = {
'stu1101': "TengLan Wu",
'stu1102': "LongZe Luola",
'stu1103': "XiaoZe Maliya",
}
字典的特性：
· dict是无序的，打印时会随机显示，因为他没有下标，所以显示乱序。
· key必须是唯一的,so 天生去重
增加
>>> info["stu1104"] = "苍井空"
>>> info
{'stu1102': 'LongZeLuola', 'stu1104': '苍井空', 'stu1103': 'XiaoZe Maliya', 'stu1101': 'TengLanWu'}
修改
>>> info['stu1101'] = "武藤兰"
>>> info
{'stu1102': 'LongZeLuola', 'stu1103': 'XiaoZeMaliya', 'stu1101': '武藤兰'}
删除
{'stu1102': 'LongZeLuola', 'stu1103': 'XiaoZeMaliya', 'stu1101': '武藤兰'}
>>>info.pop("stu1101") #标准删除姿势
'武藤兰'
>>> info
{'stu1102': 'LongZeLuola', 'stu1103': 'XiaoZeMaliya'}
>>> del info['stu1103'] #换个姿势删除
>>> info
{'stu1102': 'LongZeLuola'}
>>> info= {'stu1102': 'LongZeLuola', 'stu1103': 'XiaoZeMaliya'}
>>> info
{'stu1102': 'LongZeLuola', 'stu1103': 'XiaoZeMaliya'} #随机删除
>>>info.popitem()
('stu1102', 'LongZeLuola')
>>> info
{'stu1103': 'XiaoZeMaliya'}
>>> info= {'stu1102': 'LongZeLuola', 'stu1103': 'XiaoZeMaliya'}
>>> "stu1102"in info #标准用法
True
>>>info.get("stu1102") #获取
'LongZe Luola'
>>> info["stu1102"] #同上，但是看下面
'LongZe Luola'
>>> info["stu1105"] #如果一个key不存在，就报错，get不会，不存在只返回None
Traceback (mostrecent call last):
File "<stdin>", line 1, in <module>
KeyError: 'stu1105'
有子字典的结构。
字典中套用字典。
"欧美":{
"www.EEEEE.com": ["很多免费的,世界最大的","质量一般"],
"www.pWWWW.com": ["很多免费的,也很大","质量比wewen高点"],
"lwerwerewrw.com": ["多是自拍,高质量图片很多","资源不多,更新慢"],
"werwer.com":["质量很高,真的很高","全部收费,屌比请绕过"]
},
"日韩":{
"tokerwerw":["质量怎样不清楚,个人已经不喜欢日韩范了","听说是收费的"]
},
"大陆":{
"10wwwww":["全部免费,真好,好人一生平安","服务器在国外,慢"]
}
}
av_catalog["大陆"]["1024"][1] += ",可以用爬虫爬下来"
print(av_catalog["大陆"]["1024"])
#ouput
['全部免费,真好,好人一生平安', '服务器在国外,慢,可以用爬虫爬下来']
其它姿势
>>>info.values()
dict_values(['LongZe Luola', 'XiaoZeMaliya'])
#keys
>>>info.keys()
dict_keys(['stu1102', 'stu1103'])
#setdefault：字典setdefault() 函数和get() 方法类似, 如果键不存在于字典中，将会添加键并将值设为默认值。
>>>info.setdefault("stu1106","Alex")
'Alex'
>>> info
{'stu1102': 'LongZeLuola', 'stu1103': 'XiaoZeMaliya', 'stu1106': 'Alex'}
>>>info.setdefault("stu1102","龙泽萝拉")
'LongZe Luola'
>>> info
{'stu1102': 'LongZeLuola', 'stu1103': 'XiaoZeMaliya', 'st u1106': 'Alex'}
#update
>>> info
{'stu1102': 'LongZeLuola', 'stu1103': 'XiaoZeMaliya', 'stu1106': 'Alex'}
>>> b ={1:2,3:4, "stu1102":"龙泽萝拉"}
>>>info.update(b) 将两个字典合并，中间有交叉的value就会覆盖，没有交叉就更新。
>>> info
{'stu1102': '龙泽萝拉', 1: 2, 3: 4, 'stu1103': 'XiaoZe Maliya', 'stu1106': 'Alex'}
#items：返回可遍历的(键, 值) 元组数组。
info.items()
dict_items([('stu1102', '龙泽萝拉'), (1, 2), (3, 4), ('stu1103', 'XiaoZe Maliya'), ('stu1106', 'Alex')])
#通过一个列表生成默认dict,有个没办法解释的坑，少用吧这个
>>> dict.fromkeys([1,2,3],'testd') #初始化一个新的字典。
{1: 'testd', 2: 'testd', 3: 'testd'}
有个报错：
Dict.fromkeys([6,7,8],[1,{“name”:“alex”},444])
此时打印会显示(信息不准确)：
{6：[1,{“name”:“alex”},444], 7：[1,{“name”:“alex”},444],8：[1,{“name”:“alex”},444]}
循环dict
for key in info:
print(key,info[key])
#方法2
for k,v ininfo.items(): #会先把dict转成list,数据里大时莫用
print(k,v)
程序: 三级菜单
要求:
1. 打印省、市、县三级菜单
2. 可返回上一级
3. 可随时退出程序
menu = {
'北京':{
'海淀':{
'五道口':{
'soho':{},
'网易':{},
'google':{}
},
'中关村':{
'爱奇艺':{},
'汽车之家':{},
'youku':{},
},
'上地':{
'百度':{},
},
},
'昌平':{
'沙河':{
'老男孩':{},
'北航':{},
},
'天通苑':{},
'回龙观':{},
},
'朝阳':{},
'东城':{},
},
'上海':{
'闵行':{
"人民广场":{
'炸鸡店':{}
}
},
'闸北':{
'火车战':{
'携程':{}
}
},
'浦东':{},
},
'山东':{},
}
exit_flag = False
current_layer =menu
layers = [menu]
whilenot exit_flag:
for k in current_layer:
print(k)
choice = input(">>:").strip()
if choice == "b":
current_layer = layers[-1]
#print("change to laster", current_layer)
layers.pop()
elif choice notin current_layer:continue
else:
layers.append(current_layer)
current_layer = current_layer[choice]
用户入口：
4、商品信息存在文件中；
5、已购商品，余额记录，长时间留存。
商家入口：
6、可以添加商品，修改商品价格；
4.集合操作
集合是一个无序的，不重复的数据组合，它的主要作用如下：
· 去重，把一个列表变成集合，就自动去重了
· 关系测试，测试两组数据之前的交集、差集、并集等关系
常用操作
s = set(S) #创建一个数值集合
t = set("Hello") #创建一个唯一字符的集合
a = t | s # t 和s的并集
s.union(t) 取并集
b = t & s # t 和s的交集
s.intersection(t) 取交集。
c = t – s # 求差集（项在t中，但不在s中）
s.difference(t) #取差集
d = t ^ s # 对称差集（项在t或s中，但不会同时出现在二者中）
s.symmetric_difference(t)
s.issubset(t) s是t的子集；
s.issuperset(t) s是t的父集。
基本操作：
t.add('x') # 添加一项
s.update([10,37,42]) # 在s中添加多项
s.isdisjoin(t) 两者是否有交集。
使用remove()可以删除一项：
t.remove('H') 如果没有值会报错
t.pop() 随机删除。
t.discard(“a”) 删除，如果没有值不会报错
len(s)
set 的长度
x in s
测试 x 是否是 s 的成员
x notin s
测试 x 是否不是 s 的成员
s.issubset(t)
s <= t
测试是否 s 中的每一个元素都在 t 中
s.issuperset(t)
s >= t
测试是否 t 中的每一个元素都在 s 中
s.union(t)
s | t
返回一个新的 set 包含 s 和 t 中的每一个元素
s.intersection(t)
s & t
返回一个新的 set 包含 s 和 t 中的公共元素
s.difference(t)
s - t
返回一个新的 set 包含 s 中有但是 t 中没有的元素
s.symmetric_difference(t)
s ^ t
返回一个新的 set 包含 s 和 t 中不重复的元素
s.copy()
返回 set “s”的一个浅复制
5. 文件操作
对文件操作流程
1. 打开文件，得到文件句柄并赋值给一个变量
2. 通过句柄对文件进行操作
3. 关闭文件
现有文件如下
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 |
Somehow, it seems the love I knew was always the most destructive kind 不知为何，我经历的爱情总是最具毁灭性的的那种 Yesterday when I was young 昨日当我年少轻狂 The taste of life was sweet 生命的滋味是甜的 As rain upon my tongue 就如舌尖上的雨露 I teased at life as if it were a foolish game 我戏弄生命 视其为愚蠢的游戏 The way the evening breeze 就如夜晚的微风 May tease the candle flame 逗弄蜡烛的火苗 The thousand dreams I dreamed 我曾千万次梦见 The splendid things I planned 那些我计划的绚丽蓝图 I always built to last on weak and shifting sand 但我总是将之建筑在易逝的流沙上 I lived by night and shunned the naked light of day 我夜夜笙歌 逃避白昼赤裸的阳光 And only now I see how the time ran away 事到如今我才看清岁月是如何匆匆流逝 Yesterday when I was young 昨日当我年少轻狂 So many lovely songs were waiting to be sung 有那么多甜美的曲儿等我歌唱 So many wild pleasures lay in store for me 有那么多肆意的快乐等我享受 And so much pain my eyes refused to see 还有那么多痛苦 我的双眼却视而不见 I ran so fast that time and youth at last ran out 我飞快地奔走 最终时光与青春消逝殆尽 I never stopped to think what life was all about 我从未停下脚步去思考生命的意义 And every conversation that I can now recall 如今回想起的所有对话 Concerned itself with me and nothing else at all 除了和我相关的 什么都记不得了 The game of love I played with arrogance and pride 我用自负和傲慢玩着爱情的游戏 And every flame I lit too quickly, quickly died 所有我点燃的火焰都熄灭得太快 The friends I made all somehow seemed to slip away 所有我交的朋友似乎都不知不觉地离开了 And only now I'm left alone to end the play, yeah 只剩我一个人在台上来结束这场闹剧 Oh, yesterday when I was young 噢 昨日当我年少轻狂 So many, many songs were waiting to be sung 有那么那么多甜美的曲儿等我歌唱 So many wild pleasures lay in store for me 有那么多肆意的快乐等我享受 And so much pain my eyes refused to see 还有那么多痛苦 我的双眼却视而不见 There are so many songs in me that won't be sung 我有太多歌曲永远不会被唱起 I feel the bitter taste of tears upon my tongue 我尝到了舌尖泪水的苦涩滋味 The time has come for me to pay for yesterday 终于到了付出代价的时间 为了昨日 When I was young 当我年少轻狂 |
基本操作
1 2 3 4 5 6 7 8 9 10 11 12 |
f = open('lyrics'，encoding=”utf-8”) #打开文件句柄（文件的内存对象） first_line = f.readline() print('first line:',first_line) #读一行 print('我是分隔线'.center(50,'-')) data = f.read()# 读取剩下的所有内容,文件大时不要用，只read一次，对于文件 读第二次时则为空。 print(data) #打印文件 f.close() #关闭文件 如果想写文档： f = open('lyrics'，’r+’,encoding=”utf-8”) f.write(“我爱北京田安民”) f.close() |
打开文件的模式有：
· r，只读模式（默认）。
· w，只写模式。【不可读；不存在则创建；存在则删除内容；】
· a，追加模式。【可读； 不存在则创建；存在则只追加内容；】
"+" 表示可以同时读写某个文件
· r+，可读写文件。【可读；可写；可追加】
· w+，写读，与r+的区别是，写读先创建文件，然后再往里写，用处不大；
· a+，同a
"U"表示在读取时，可以将 \r \n \r\n自动转换成 \n （与 r 或 r+ 模式同使用）
· rU
· r+U
"b"表示处理二进制文件（如：FTP发送上传ISO镜像文件，linux可忽略，windows处理二进制文件时需标注）
· rb
· wb
· ab
如果想只打印前五行，怎么处理：
f.readline(); 即读下一行。
For i in range(5):
Print(f.readline();) 读前五行。
f.readlines(); 读取整个文件，每行为一个元素。
For i in f.readlines():
Print(i) 整个文件遍历。
取5到10行：
For index， line in enumerate（f.readlines()）:
If index==9:
Print(‘-------------------------’)
Continue
Print(line.strip())
如果想处理20g的文件，有一个策略;
读一行，处理一行，删除一行。
Count = 0
For line in f:
Ifcount==9：
Print(‘--------------’)
Count+=1
Continue
Print（line）
此时就完成了一行行读，一行行处理，一行行删除。
F中内含了迭代器。
其它语法
def close(self): # real signature unknown; restored from __doc__
"""
Close the file.
pass
def fileno(self, *args, **kwargs): # 打开了多少文件
pass
def isatty(self, *args, **kwargs): # 判断是否为终端设备。
""" True if the file is connected to a TTYdevice. """
pass
def read(self, size=-1): # known case of _io.FileIO.read
注意，不一定能全读回来
return""
def readable(self, *args, **kwargs): # real signature unknown
pass
def readall(self, *args, **kwargs): # real signature unknown
pass
def readinto(self): # real signature unknown; restored from __doc__
pass#不要用,没人知道它是干嘛用的
def seek(self, *args, **kwargs): # seek(0),回到句子开始的位置。
pass
def seekable(self, *args, **kwargs): # tty文件，即终端设备文件，文件光标如果能移动则返回TRUE。
pass
def tell(self, *args, **kwargs): # real signature unknown
"""
Current file position.把光标所在的位置打印出来，tell的计数是按照字符的个数，一个字符显示加一。
pass
def truncate(self, *args, **kwargs): # real signature unknown
没有参数时会清空文件；
F=open(“filename”,’a’,encoding=”utf-8”)
F=truncate(10)
会将前十个字符截断，后面的删除。
pass
def writable(self, *args, **kwargs): # 文件是否可写。
pass
def write(self, *args, **kwargs): # real signature unknown
pass
f.flush(): 内存中有个一缓存区，缓存区一旦存满，就会刷到硬盘里。此时的flush（）即为强制刷新到硬盘上，不用存到缓存区。
进度条的开发时方法为：
Import sys, time
For I inrange(50):
Sys.stdout.write(“#”) #标准输出，即往屏幕上输出#
Sys.stdout.flush()
Time.sleep(0.1)
为了避免打开文件后忘记关闭，可以通过管理上下文，即：
1 2 |
with open('log','r') as f: ... |
如此方式，当with代码块执行完毕时，内部会自动关闭并释放文件资源。
在Python 2.7 后，with又支持同时对多个文件的上下文进行管理，即：
1 2 |
with open('log1') as obj1, open('log2') as obj2: pass |
文件的修改：
1、 将文件全部加载到内存中，然后修改完成后再放回去。
2、 打开一个文件，修改完成后写在一个新的文件中。
Import sys
With open(“yesterday2”,”r”,encoding=”utf-8”) as f, \
open(“yesterday2.bak”,”w”,encoding=”utf-8”)as f_new:
Find_str = sys.argv[1]
Replace_str =sys.argv[2]
For line in f:
If “Find_str” in line:
Line=line.replace(“Find_str”，” Replace_str”)
F_new.write(line)
Else:
F_new.write(line)
程序练习
程序1: 实现简单的shell sed替换功能
程序2:修改haproxy配置文件
需求：
输入：www.oldboy.org
获取当前backend下的所有记录
2、新建
输入：
arg = {
'bakend': 'www.oldboy.org',
'record':{
'server': '100.1.7.9',
'weight': 20,
'maxconn': 30
}
}
3、删除
输入：
arg = {
'bakend': 'www.oldboy.org',
'record':{
'server': '100.1.7.9',
'weight': 20,
'maxconn': 30
}
}
global
log 127.0.0.1 local2
daemon
maxconn 256
log 127.0.0.1 local2 info
defaults
log global
mode http
timeout connect 5000ms
timeout client 50000ms
timeout server 50000ms
option dontlognull
listen stats :8888
stats enable
stats uri /admin
stats auth admin:1234
frontendoldboy.org
bind 0.0.0.0:80
option httplog
option httpclose
option forwardfor
log global
acl www hdr_reg(host) -i www.oldboy.org
use_backend www.oldboy.org if www
backendwww.oldboy.org
server 100.1.7.9 100.1.7.9 weight 20maxconn 3000
6. 字符编码与转码
详细文章:
http://www.cnblogs.com/yuanchenqi/articles/5956943.html
http://www.diveintopython3.net/strings.html
需知:
1.在python2默认编码是ASCII, python3里默认是unicode
2.unicode 分为 utf-32(占4个字节),utf-16(占两个字节)，utf-8(占1-4个字节)， so utf-16就是现在最常用的unicode版本，不过在文件里存的还是utf-8，因为utf8省空间
3.在py3中encode,在转码的同时还会把string 变成bytes类型，decode在解码的同时还会把bytes变回string
上图仅适用于py2
#-*-coding:utf-8-*- #此处为文件以utf-8的形式编码，不影响后面的Python编码。
__author__ = 'Alex Li'
import sys
print(sys.getdefaultencoding())
msg = "我爱北京天安门" #在Python3中，此时编码依然是Unicode。
msg_gb2312 =msg.decode("utf-8").encode("gb2312")
gb2312_to_gbk =msg_gb2312.decode("gbk").encode("gbk")
print(msg)
print(msg_gb2312)
print(gb2312_to_gbk)
#-*-coding:gb2312-*- #这个也可以去掉
__author__ = 'Alex Li'
import sys
print(sys.getdefaultencoding())
msg = "我爱北京天安门"
#msg_gb2312 =msg.decode("utf-8").encode("gb2312")
msg_gb2312 =msg.encode("gb2312") #默认就是unicode,不用再decode,喜大普奔
gb2312_to_unicode= msg_gb2312.decode("gb2312")
gb2312_to_utf8 =msg_gb2312.decode("gb2312").encode("utf-8")
print(msg)
print(msg_gb2312)
print(gb2312_to_unicode)
print(gb2312_to_utf8)
如果在前面加u：S=u”你好”，表示此字符串是Unicode，当然，utf-8是Unicode的扩展集，因此可以打印中文。
当字符串前面加u之后，下面的文件就可以成立了，不需要解码，可以直接编码。
S_to_gbk=s.encode(“gbk”)
Print(S_to_gbk)
会报错，因为默认编码是ascii,而S=”你好”是utf-8，s会以ascii的方式解码成Unicode，然后再编码成gbk，编码不一致，所以会报错。
类似于：S_to_gbk=s.decode().encode(“gbk”)
确认默认编码的方式为：
Import sys
Print(sys.getdefaultencoding())
所以，应该改为：
S_to_gbk=s.decode(“utf-8”).encode(“gbk”)
s.decode(“utf-8”):将S (utf-8)格式以utf-8的方式转换成unicode，
encode(“gbk”)：将Unicode转换成gbk格式。
Python3会将utf-8自动转换成Unicode编码
#-*-coding:utf-8-*- #此处为文件以utf-8的形式编码，不影响后面的Python编码。
__author__ = 'Alex Li'
import sys
print(sys.getdefaultencoding())