Po学校Python第四课（循环+文件操作+字典+函数）

登陆系统

登陆三次

count =0

while count <3:

count+=1

name=inpu("请输入用户名")

if name="root":

password=input("请输入密码")

if password=="root":

print("登陆成功")

break

else:

print("密码错误")

else:

print("用户名错误")

作业：提示已经输入了三次

count=0

while count<3:

count+=1

name=input("请输入用户名")

if name=="root":

password=input("请输入密码")

if password=="root":

print("登陆成功")

break

else:

print("密码错误")

else:

print("用户名错误")

else:

print("已经输入错误三次")

FILE文件

f=open("demo.txt")

f.readline()

123

f.readline()

456

readline()这句是逐行读取，一次读一行

f.readlines()

123 456

readlines()这句是一下全部读取出来

close()是关闭

s=f.readline()

则s.      这个点之后也会有很多的方法。比对啥的

fp = open("test.txt",w)     直接打开一个文件，如果文件不存在则创建文件

关于open 模式：

w     以写方式打开，
a     以追加模式打开 (从 EOF 开始, 必要时创建新文件)
r+     以读写模式打开
w+     以读写模式打开 (参见 w )
a+     以读写模式打开 (参见 a )
rb     以二进制读模式打开
wb     以二进制写模式打开 (参见 w )
ab     以二进制追加模式打开 (参见 a )
rb+    以二进制读写模式打开 (参见 r+ )
wb+    以二进制读写模式打开 (参见 w+ )
ab+    以二进制读写模式打开 (参见 a+ )

fp.read([size])                     #size为读取的长度，以byte为单位

fp.readline([size])                 #读一行，如果定义了size，有可能返回的只是一行的一部分

fp.readlines([size])                #把文件每一行作为一个list的一个成员，并返回这个list。其实它的内部是通过循环调用readline()来实现的。如果提供size参数，size是表示读取内容的总长，也就是说可能只读到文件的一部分。

fp.write(str)                      #把str写到文件中，write()并不会在str后加上一个换行符

fp.writelines(seq)            #把seq的内容全部写到文件中(多行一次性写入)。这个函数也只是忠实地写入，不会在每行后面加上任何东西。

fp.close()                        #关闭文件。python会在一个文件不用后自动关闭文件，不过这一功能没有保证，最好还是养成自己关闭的习惯。  如果一个文件在关闭后还对其进行操作会产生ValueError

fp.flush()                                      #把缓冲区的内容写入硬盘

fp.fileno()                                      #返回一个长整型的”文件标签“

fp.isatty()                                      #文件是否是一个终端设备文件（unix系统中的）

fp.tell()                                         #返回文件操作标记的当前位置，以文件的开头为原点

fp.next()                                       #返回下一行，并将文件操作标记位移到下一行。把一个file用于for … in file这样的语句时，就是调用next()函数来实现遍历的。

fp.seek(offset[,whence])              #将文件打操作标记移到offset的位置。这个offset一般是相对于文件的开头来计算的，一般为正数。但如果提供了whence参数就不一定了，whence可以为0表示从头开始计算，1表示以当前位置为原点计算。2表示以文件末尾为原点进行计算。需要注意，如果文件以a或a+的模式打开，每次进行写操作时，文件操作标记会自动返回到文件末尾。

fp.truncate([size])                       #把文件裁成规定的大小，默认的是裁到当前文件操作标记的位置。如果size比文件的大小还要大，依据系统的不同可能是不改变文件，也可能是用0把文件补到相应的大小，也可能是以一些随机的内容加上去。

最基本的文件操作当然就是在文件中读写数据。这也是很容易掌握的。现在打开一个文件以进行写操作： 

1. fileHandle = open ( 'test.txt', 'w' )  

fileHandle = open ( 'test.txt', 'w' ) 

‘w'是指文件将被写入数据，语句的其它部分很好理解。下一步就是将数据写入文件： 

1. fileHandle.write ( 'This is a test.\nReally, it is.' )  

fileHandle.write ( 'This is a test.\nReally, it is.' ) 

这个语句将“This is a test.”写入文件的第一行，“Really, it is.”写入文件的第二行。最后，我们需要做清理工作，并且关闭文件： 

1. fileHandle.close()  

fileHandle.close() 

正如你所见，在Python的面向对象机制下，这确实非常简单。需要注意的是，当你再次使用“w”方式在文件中写数据，所有原来的内容都会被删除。如果想保留原来的内容，可以使用“a”方式在文件中结尾附加数据： 

1. fileHandle = open ( 'test.txt', 'a' )  
2. fileHandle.write ( '\n\nBottom line.' )  
3. fileHandle.close()  

fileHandle = open ( 'test.txt', 'a' ) 
fileHandle.write ( '\n\nBottom line.' ) 
fileHandle.close() 

然后，我们读取test.txt，并将内容显示出来： 

1. fileHandle = open ( 'test.txt' )  
2. print fileHandle.read()  
3. fileHandle.close()  

fileHandle = open ( 'test.txt' ) 
print fileHandle.read() 
fileHandle.close() 

以上语句将读取整个文件并显示其中的数据。我们也可以读取文件中的一行： 

1. fileHandle = open ( 'test.txt' )  
2. print fileHandle.readline() # "This is a test."  
3. fileHandle.close()  

fileHandle = open ( 'test.txt' ) 
print fileHandle.readline() # "This is a test." 
fileHandle.close() 


同时，也可以将文件内容保存到一个list中： 

1. fileHandle = open ( 'test.txt' )  
2. fileList = fileHandle.readlines()<div></div>  
3. for fileLine in fileList:  
4.     print '>>', fileLine  
5. fileHandle.close()  

fileHandle = open ( 'test.txt' ) 
fileList = fileHandle.readlines() 
for fileLine in fileList: 
print '>>', fileLine 
fileHandle.close() 

Python在读取一个文件时，会记住其在文件中的位置，如下所示： 

1. fileHandle = open ( 'test.txt' )  
2. garbage = fileHandle.readline()  
3. fileHandle.readline() # "Really, it is."fileHandle.close()  

fileHandle = open ( 'test.txt' ) 
garbage = fileHandle.readline() 
fileHandle.readline() # "Really, it is."fileHandle.close() 

可以看到，只有第二行显示出来。然而，我们可以让Python从头开始读来解决这个问题： 

1. fileHandle = open ( 'test.txt' )  
2. garbage = fileHandle.readline()  
3. fileHandle.seek ( 0 )  
4. print fileHandle.readline() # "This is a test."  
5. fileHandle.close()  

fileHandle = open ( 'test.txt' ) 
garbage = fileHandle.readline() 
fileHandle.seek ( 0 ) 
print fileHandle.readline() # "This is a test." 
fileHandle.close() 

在上面这个例子中，我们让Python从文件第一个字节开始读取数据。所以，第一行文字显示了出来。当然，我们也可以获取Python在文件中的位置： 

1. fileHandle = open ( 'test.txt' )  
2. print fileHandle.readline() # "This is a test."  
3. print fileHandle.tell() # "17"  
4. print fileHandle.readline() # "Really, it is."  

fileHandle = open ( 'test.txt' ) 
print fileHandle.readline() # "This is a test." 
print fileHandle.tell() # "17" 
print fileHandle.readline() # "Really, it is." 

或者在文件中一次读取几个字节的内容： 

1. fileHandle = open ( 'test.txt' )  
2. print fileHandle.read ( 1 ) # "T"  
3. fileHandle.seek ( 4 )  
4. print FileHandle.read ( 1 ) # " "(原文有错)  

fileHandle = open ( 'test.txt' ) 
print fileHandle.read ( 1 ) # "T" 
fileHandle.seek ( 4 ) 
print FileHandle.read ( 1 ) # " "(原文有错) 

在Windows和Macintosh环境下，有时可能需要以二进制方式读写文件，比如图片和可执行文件。此时，只要在打开文件的方式参数中增加一个“b”即可： 

1. fileHandle = open ( 'testBinary.txt', 'wb' )  
2. fileHandle.write ( 'There is no spoon.' )  
3. fileHandle.close()  

fileHandle = open ( 'testBinary.txt', 'wb' ) 
fileHandle.write ( 'There is no spoon.' ) 
fileHandle.close() 

1. fileHandle = open ( 'testBinary.txt', 'rb' )  
2. print fileHandle.read()  
3. fileHandle.close()  

fileHandle = open ( 'testBinary.txt', 'rb' ) 
print fileHandle.read() 
fileHandle.close() 



前一节中介绍的模块，可以实现在文件中对字符串的读写。 
然而，有的时候，你可能需要传递其它类型的数据，如list、tuple、dictionary和其它对象。在Python中，你可以使用Pickling来完成。你可以使用Python标准库中的“pickle”模块完成数据编组。 
下面，我们来编组一个包含字符串和数字的list： 

1. import pickle  
2.   
3. fileHandle = open ( 'pickleFile.txt', 'w' )  
4. testList = [ 'This', 2, 'is', 1, 'a', 0, 'test.' ]  
5. pickle.dump ( testList, fileHandle )  
6. fileHandle.close()  

import pickle 

fileHandle = open ( 'pickleFile.txt', 'w' ) 
testList = [ 'This', 2, 'is', 1, 'a', 0, 'test.' ] 
pickle.dump ( testList, fileHandle ) 
fileHandle.close() 

拆分编组同样不难： 

1. import pickle  
2.   
3. fileHandle = open ( 'pickleFile.txt' )  
4. testList = pickle.load ( fileHandle )  
5. fileHandle.close()  

import pickle 

fileHandle = open ( 'pickleFile.txt' ) 
testList = pickle.load ( fileHandle ) 
fileHandle.close() 

现在试试存储更加复杂的数据： 

1. import pickle  
2.   
3. fileHandle = open ( 'pickleFile.txt', 'w' )  
4. testList = [ 123, { 'Calories' : 190 }, 'Mr. Anderson', [ 1, 2, 7 ] ]  
5. pickle.dump ( testList, fileHandle )  
6. fileHandle.close()  

import pickle 

fileHandle = open ( 'pickleFile.txt', 'w' ) 
testList = [ 123, { 'Calories' : 190 }, 'Mr. Anderson', [ 1, 2, 7 ] ] 
pickle.dump ( testList, fileHandle ) 
fileHandle.close() 

1. import pickle  
2.   
3. fileHandle = open ( 'pickleFile.txt' )  
4. testList = pickle.load ( fileHandle )  
5. fileHandle.close()  

import pickle 

fileHandle = open ( 'pickleFile.txt' ) 
testList = pickle.load ( fileHandle ) 
fileHandle.close() 

dict字典

>>>mydict={'key1':'value1','key2':123123}

>>>mydict['key1']

value1

>>>mydice['key2']#列出key2的内容

123123

>>>mydice['key3']=456     #往字典里加内容

>>>mydict

{'key1':'value1','key2':123123,'key3':456}

>>>mydict[123123]=111111#修改内容

{'key1':'value1','key2':111111,'key3':456}

2、常见的字典操作
可以查看库手册或者运行dir(dict)或者help(dict),类型名为dict。当写成常量表达式时，字典以一系列"键:值（key:value)”对形式写出的，用逗号隔开，用大括号括起来。可以和列表和元组嵌套
操作                        解释
D1={}                        空字典
D={'one':1}                    增加数据
D1[key]='class'                    增加数据：已经存在就是修改，没有存在就是增加数据
D2={'name':'diege','age':18}            两项目字典
D3={'name':{'first':'diege','last':'wang'},'age':18} 嵌套
D2['name']                    以键进行索引计算
D3['name']['last']                字典嵌套字典的键索引
D['three'][0]                    字典嵌套列表的键索引
D['six'][1]                    字典嵌套元组的键索引
D2.has_key('name')                 方法：判断字典是否有name键
D2.keys()                    方法：键列表
list(D)                        获取D这个字典的的KEY的 MS按字典顺序排序成一个列表
D2.values()                      方法：值列表
'name' in D2                    方法：成员测试：注意使用key来测试
D2.copy()                     方法：拷贝
D2.get(key,deault)                方法：默认 如果key存在就返回key的value,如果不存在就设置key的value为default。但是没有改变原对象的数据
D2.update(D1)                    方法：合并。D1合并到D2,D1没有变化，D2变化。注意和字符串，列表好的合并操作”+“不同
D2.pop('age')                    方法：删除 根据key删除,并返回删除的value
len(D2)                        方法：求长（存储元素的数目)
D1[key]='class'                    方法：增加：已经存在的数据就是修改，没有存在就是增加数据
D4=dict(name='diege',age=18)            其他构造技术
D5=dict.fromkeys(['a','b'])                 其他构造技术 dict.fromkeys 可以从一个列表读取字典的key 值默认为空，可指定初始值.两个参数一个是KEY列表，一个初始值
>>> D4
{'a': None, 'b': None}
>>> D5=dict.fromkeys(['a','b','c'],0)
>>> D5
{'a': 0, 'c': 0, 'b': 0}
D6=dict(zip(keyslist.valslist))             ？？？
>>> D={}     
>>> D={'one':1}
>>> D
{'one': 1}
列表不能通过这样的方法来增加数据，列表只能通过append方法，列表之能通过L[1]='A'这样的方法来修改已存在序列的数据。
二、实际应用中的字典
1、字典的基本操作
1）、创建字典的方法 和修改
全部数据一起添加
>>> D={'name':'diege','age':18}
>>> D
{'age': 18, 'name': 'diege'}

>>> D={}
>>> D['name']='diege'
>>> D['age']=18         
>>> D
{'age': 18, 'name': 'diege'}
>>> D1['age']=19
>>> D1
{'age': 19, 'name': 'diege'}
同样键不存在是新添加数据，键存在就是修改数据

>>> D1=dict(name='diege',age=18)
>>> D1
{'age': 18, 'name': 'diege'}
将数据按按key=value作为参数传递给dict()
dict(mapping) -> new dictionary initialized from a mapping object's (key, value) pairs
>>> D=dict.fromkeys(['name','age'])  
>>> D
{'age': None, 'name': None}
创建只有key没有value的字典。

>>> D=dict.fromkeys(['name','age'],0)  
>>> D
{'age': 0, 'name': 0}
2）、索引
>>> D['age']
18
3）、取长
>>> len(D)
2
4）、键存在判断-参数使用key
>>> D.has_key('name')
True
5)、成员判断 使用key
>>> 'age' in D
True
6）、字典的键查看 返回键的列表
>>> D.keys()         
['age', 'name']
7）、字典的值查看 返回值的列表
>>> D.values()
[18, 'diege']
8)、拷贝
D2.copy()     
2、原处修改字典
1）增加数据
>>> D['age']=18         
>>> D
{'age': 18, 'name': 'diege'}
>>> D1['age']=19
>>> D1
{'age': 19, 'name': 'diege'}
同样键不存在是新添加数据，键存在就是修改数据

2）删除数据
根据键删除
pop方法是从字典中删除一个键并返回它的值  
>>> D.pop('age')  
18
方法是从字典中删除一个键并返回它的值  
>>> del D['age']
18
从字典前面一对K:V的方式删除，并返回K,V合成的元组
>>> D3.popitem() 
('age', 18)
清空字典所有数据
D1.clear()
3）合并数据
D2.update(D1)                    方法：合并。D1合并到D2,D1没有变化，D2变化。注意和字符串，列表好的合并操作”+“不同
>>> D1
{'name': 'diege'}
>>> D2
{'class': 2, 'level': 2012}
>>> D2.update(D1)
>>> D1
{'name': 'diege'}
>>> D2
{'class': 2, 'name': 'diege', 'level': 2012}

3、其他字典方法
字典方法提供很多工具，例如 字典keys,valuse和items方法分别返回字典的键列表,值列表和(key,value)对元组
key列表
>>> D2.keys()
['class', 'name', 'level']
value列表
>>> D2.values()    
[2, 'diege', 2012]
K,V元组的列表
>>> D2.items()      
[('class', 2), ('name', 'diege'), ('level', 2012)]
>>> D2.viewkeys()       
dict_keys(['class', 'name', 'level'])
>>> D2.viewvalues()    
dict_values([2, 'diege', 2012])
>>> D2.viewitems()      
dict_items([('class', 2), ('name', 'diege'), ('level', 2012)])

4、语言表
>>> table={'Python':'Guido',
... 'Perl':'Larry',
... 'Tcl':'John'}

for lang in table.keys():
...  print lang,'\t',table[lang]
... 
Python  Guido
Tcl     John
Perl    Larry
因为字典并非序列，无法像字符串和列表那样直接通过一个for语句迭代他们。但如果要遍历字典的键列表很容易。调用字典的keys()方法，返回经过排序之后所有键的列表。再用for循环进行迭代。
实际上，Python也能然给你遍历字典的键的列表，而并不用在多数for循环中调用keys方法.就任何字典D而言，写成for key in D:和写成完整的for key in D.keys()：效果是一样的
>>> for key in table:
...  print key
... 
Python
Tcl
Perl
>>> for key in table.keys():
...  print key
... 
Python
Tcl
Perl
>>> for key in table.values():
...  print key                
... 
Guido
John
Larry
三、字典用法注意事项
*序列运算无效。无法有序合并和分片
*对新索引赋值会增加项。
*键不一定总是字符串。任何不可变对象都可以（也就是不是列表）
1、使用字典模拟灵活的列表
当使用列表的时，对在列表末尾外的偏移赋值是非法的。
>>> L=[]
>>> L[99]='diege'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list assignment index out of range
虽然可以使用重复预先分配足够的大的列表（例如 [0]*100）。但也可以使用字典来坐类似的事。这样就不需要这样的空间分配了。
使用整数键时，字典可以效仿列表再偏移赋值时增长
>>> [0]*100>>> L=[0]*100      
>>> L[99]='diege
>>> D={}
>>> D[99]='diege'
>>> D[99]
'diege
这样的不用将来可能会用到的会被赋值的所有位置都分配空间。这样字典很像更具灵活性的列表。
2、字典用于稀疏数据结构
例如多维数组中只有少数位置上有存储的值
>>> M={}
>>> M[(2,3,4)]=88
>>> M[(7,8,9)]=99   
>>> X=2;Y=3;Z=4 
>>> M[(X,Y,Z)]
88
>>> M
{(2, 3, 4): 88, (7, 8, 9): 99}
这个数组中只有两个位置(2,3,4),(7,8,9)有值，其他位置都未空。键是元组，他们记录非空元素的坐标。我们并不是分配一个庞大而几乎为空的三维矩阵，而是使用一个简单的两个元素的字典。通过这一方式读取空元素的时，会触发键不存在的异常。因为这些元素实质上并没有被存储。
>>> M[(5,6,7)]     
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: (5, 6, 7)
3、避免missing-key错误
读取不存在的键的错误在稀疏矩阵中很常见。然而可能并不希望程序因为这一次错误而被关闭。这里有三种方式可以让我们填入默认值而不会出现这样
的错误提示，
1、）使用if语句预先对键进行测试。
>>> if M.has_key((5,6,7)): 
...  print M[(5,6,7)]
... else:
...  print 0
... 
0
2)、使用try语句明确地捕获并修复这一异常。
>>> try:
...  print M[(5,6,7)]
... except KeyError:
...  print 0
... 
0
3）、使用get方法为不存在的键提供一个默认值
>>> M.get((2,3,4),0)   
88
>>> M.get((5,6,7),0)
0
从编程的需要方面来说，get方法是三者中最简捷的。
4、使用字典作为“记录”
一般说来，字典可以取代搜索数据结构（因为用键进行索引是一种搜索操作），并且可以表示多种结构化信息的类型。例如，字典是在程序范围中多种描述某一项
属性的方法之一。也就是说，它们能偶扮演其他语言中的“记录”和结构相同的角色。随时间通过向新键赋值来填写字典的列子
>>> rec={}
>>> rec['name']='diege'
>>> rec['age']=28         
>>> rec['job']='sa/db'
>>> print rec['name']
diege
特别是在嵌套的时候，Python的内建数据类型可以很轻松地表达结构化信息。使用字典来捕获对象的属性，但是它是一次性写好的，而且嵌套了一个列表和一个字典来表达结构化属性的值。
>>> offer={'name':'diege','jobs':['sa','dba'],'web':'www.skylog.cn/~diege','home':{'state':'SH','zip':8088}}
当去读嵌套对象的元素时，只要简单地吧索引操作串起来就可以了
>>> offer['name']
'diege'
>>> offer['jobs'][1] 
'dba'
>>> offer['home']['state']
'SH
5、创建字典的其他方法
1）
>>> {'name':'diege','age':45}
{'age': 45, 'name': 'diege'}
2）
>>> D={}
>>> D['name']='lily'
>>> D['age']=18        
>>> D
{'age': 18, 'name': 'lily'}
3）
>>> dict(name='kelly',age=19)    
{'age': 19, 'name': 'kelly'}
注意这里name,age没有 ’‘括起来，因为这里是变量。
4)
>>> dict([('name','tom'),('age',23)])
{'age': 23, 'name': 'tom'}
这里将每一个数据(属性），做为元组放到一个列表里传递给dict函数

4种方法的选择技巧
*如果可以事先拼除整个字典，那么第一种是很方便的。
*如果需要一次动态地建立字典的一个字段，第二种比较合适
*第三种关键字形式所需的代码比常量少，【但是键必须是都是字符串才可行】
*如果需要在程序运行时把键和值逐步建成序列。第四中比较有用。
zip函数把程序运行动态获得的键和值列表合并在一起（例如分析数据文件字段）
如果所有键的值都相同，可以使用特殊形式对字典进行初始化。简单传入一个键列表，以及所有键的初始值（默认为空）
>>> dict.fromkeys(['a','b','c'],0)
{'a': 0, 'c': 0, 'b': 0}

作业

使用dict结构体完成班级花名册

通过名称查找到指定的人

myset=set（[1,1,1,2,2,2,3,3,3,4,4,4,]）

myset

{1,2,3,4}

myset.add(5)

myset

{1,2,3,4,5}

myset(1)

myset

{1,2,3,4,5,}

myset.remove(1)

myset

{2,3,4,5}

函数

>>>def myfunc（x，y）：

print （x，y）

>>>myfunc（10,20）

10 20

>>>myfunc("i love",111)

l love 111