Python入门7

#20100817
#元组(tuple)、文件及其其它
#元组由简单的对象构成。元组与列表类似，只不过元组不能再原处修改（它们是不可变的），通常写成圆括号（而不是方括号）中的一系列项。
#元组不支持任何方法调用，但元组具有列表大多数属性：
#1、任意对象的有序集合：与字符串和列表类似。
#2、通过偏移存取：通字符串列表一样
#3、属于不可变类型：类似于字符串，元组是不可变的，不支持在原处修改操作。元组是序列
#4、固定长度、异构、任意嵌套：元组可以包含其它的复合对象（例如列表、字典和其它元组等）
#5、对象引用数组：与列表类似元组最好被认为是对象引用的数组。

'''
#常见元组实字和运算
    运算                          解释
  ()                            空元组
  t1 = (0,)                     单个元素的元组（非表达式）
  t2 = (0,'ni',1.2,45)          四个元素的元组
  t3 = ('abc',('def','gih'))    嵌套元组
  t1[i]                         索引
  t3[i][j]                      索引的索引
  t1[i:j]                       分片
  len(t1)                       长度
  t1 + t2                       合并
  t2 * 3                        重复
  for i in t                    迭代
  0 in t2                       成员关系
 
'''   
print (1,2)+(3,4)
print (1,2) * 5
t = (1,2,3,4,5)
print t[0],t[1:3]
#元组的特殊语法：逗号和圆括号
x = (40)
print x
y = (40,)
print y
#在不回引起语法冲突的情况下，Python允许忽略元组的圆括号。仅当元组作为文件传给函数调用（圆括号很重要）以及当元组在print语句中列出（逗号很重要）的特殊情况时，圆括号才是必不可少的。

#对元组排序，通常将它转换为列表才能获得使用排序方法调用的权限，并将它变为一个可变对象。
T = ('cc','gg','aa','jj')
tmp = list(T)
print tmp
tmp.sort()
print tmp

T = tuple(tmp)
print T

#列表解析，也可以用于元组的转换。
L = [x * 2 for x in T]
print L
#列表解析是名副其实的序列操作----他们总会创建新的列表，但也可以用于遍历包括元组、字符串以及其他列表在内的任何序列对象。


#元组的不可变性只适用于元组本身顶层而并非其内容
T = (1,[2,3],4)
#T[1] = 'spam'
#print T
T[1][0] = 'spam'
print T

#元组的不可变性提供了某种完整性。确保元组在程序中不会被另一个引用修改，而列表就没有这样的保证了。

#文件：
#打开文件
#首先调用内置open函数. 首先是外部名，接着是处理模式。模式典型地用字符串'r'代表为输入打开文件（默认值），'w'代表为输出生成并打开文件，'a'代表为在文件尾部追加内容而打开文件。

'''
    操作                                          解释
  output = open('/tmp/spam','w')                创建输出文件（'w'是指写入）
  input = open('data','r')                      创建输入文件（'r'是指读写）
  input = open('data')                          与上一行相同（'r'是默认值）
  sString = input.read()                        把整个文件读进单一字符串
  sString = input.read(N)                       读取之后的N个字节（一或多个）到一个字符串
  sString = input.readline()                    读取下一行（包括行末标示符）到一个字符串
  aList = input.readlines()                     读取整个文件到字符串列表
  output.write(aString)                         写入字节字符串到文件
  output.writelines(aList)                      把列表内所有的字符串写入文件
  output.close()                                手动关闭（当文件收集完成时会替你关闭文件）
  output.flush()                                把输出缓冲区刷到硬盘中，但不关闭文件
  anyFile.seek(N)                               修改文件位置到偏移量N处以便进行下一个操作
'''

#实际应用中的文件
f = open('myfile.txt','w')
f.write('Hello World/n')
f.close()

f = open('myfile.txt')
print f.readline()
#第二个readline调用返回的是一个空字符串。这是Python文件方法告诉我们已经到达文件底部了。
print f.readline()

#在文件中存储并解析Python对象:
#把多种Python对象占用多行写入文字文本。：注意：用转换工具把对象转换成字符串。
A,B,C = 34,36,35
S = 'sapm'
D = {'a':123,'b':'nihao'}
L = [1,2,3]

F = open('datafile.txt','w')
F.write(S + '/n')
F.write('%s,%s,%s/n' % (A,B,C))
F.write(str(L) + '$' + str(D) + '/n')
F.close()

bytes = open('datafile.txt').read()
print bytes

F = open('datafile.txt')
line = F.readline()
print line

#rstrip方法去掉多余的行终止符：
print line.rstrip()

line = F.readline()
print line

#eval:可以把字符串转换为对象，它是一个功能强大的工具

line = F.readline()
print line
parts = line.split('$')
print parts
print eval(parts[0])

#eval(str [,globals [,locals ]])函数将字符串str当成有效Python表达式来求值，并返回计算结果
#exec语句将字符串str当成有效Python代码来执行.提供给exec 的代码的名称空间和exec语句的名称空间相
#execfile(filename [,globals [,locals ]])函数可以用来执行一个文件

print eval('3+4')
n = '100'
print eval(n) + 1
'''
from  math import  *
user_func = raw_input("type a function: y = ")
for  x in range(1,10):
    print "x = ", x , ", y = ", eval(user_func)
'''
#pickle  存储Python的原生对象
#pickle模块是能够让我们直接在文件中存储几乎任何Python对象的高级工具，它就像是超级通用的数据格式化和解析工具。

F = open('datafile.txt','w')
import pickle
pickle.dump(D, F)
F.close()

F = open('datafile.txt')
E = pickle.load(F)
print E


#文件中打包二进制数据的存储于解析
#struct模块能够构造并解析打包的二进制数据。，能把文件中的字符串解读为二进制数据

#生成一个打包的二进制数据文件，用'wb'（写入二进制）模式打开它，并将一个格式化字符串和几个Python对象传给struct。

F = open('data.bin','wb')
import struct
bytes = struct.pack('>i47sh',7,'spam',8)
print bytes
F.write(bytes)
F.close

F = open('data.bin','rb')
data = F.read()
print data
values = struct.unpack('>i47sh', data)
print values

#seek函数 能够复位你在文件中的当前位置
#flush函数，能够强制性地将缓存输出写入磁盘（文件总会默认进行缓存）等。


'''
对象分类
    对象类型            分类            是否可变
    数字                数值            否
    字符串              序列            否
    列表                序列            是
    字典                序列            是
    元组                序列            否
    文件                扩展            N/A
'''
#对象灵活性：
#列表、字典和元组可以包含任何种类的对象
#列表、字典和元组可以任意嵌套
#列表和字典可以动态地扩大和缩小

#共享引用对象
X = [1,2,3]
L = ['a',X,'b']
D = {'x':X,'y':2}
#因为变量X引用的列表也在被L和D引用的对象内引用，修改X的共享列表与L和D的看起来也有所不同。
#引用是其他语言中指针的更高级模拟；
X[1] = 'surprise'
print L
print D

#如果需要拷贝：那么首先可以明确要求
#1、没有限制条件的分片表达式（L[:]）能够复制序列
#2、字典copy方法（D.copy()）能够复制字典
#3、有些内置函数（例如：list）能够生成拷贝（list(L))。
#4、copy标准库模块能够生成完整拷贝.

#例如有一个字典和列表，不想凭借其他变量来修改它们的值
L  = [1,2,3]
D = {'a':1,'b':2}
#可以把简单地把拷贝赋值为其他变量，而不是相同对象的引用
A = L[:]
B = D.copy()
#这样一来，由其它变量产生的改变将会修改拷贝，而不是原对象
A[1]='ni'
B['c'] = 'spam'

print L,D
print A,B

#拷贝需要注意的：无条件值的分片以及字典copy方法只能做顶层复制，也就是说不能够复制嵌套的数据结构。



#比较、相等性和真值
L1 = [1,2,('a',3)]
L2 = [1,2,('a',3)]
print L1 == L2,L1 is L2

# "==" 操作测试值的相等性
# "is" 表达式测试对象的一致性。

# is 应该为假，这里却是ture，这是因为Python内部暂时存储并重复使用短字符串作为最佳化，所以is比较最好用作更长的字符串中：
S1 = 'spam'
S2 = 'spam'
print S1 == S2,S1 is S2


#相对大小比较也能够递归地应用于
L1 = [1,2,('a',3)]
L2 = [1,2,('a',2)]
print L1 < L2, L1 == L2,L1 > L2

#Python中不同的类型的比较方法如下：
#1、数字通过相对大小进行比较
#2、字符串是按照字典顺序，一个字符接一个字符地对比进行比较（'abc' < 'ac')
#3、列表和元组从左到右对每部分的内容进行比较
#4、字典通过排序之后的（键，指）列表进行比较

#Python中真喝假的含义
'''
    对象            值
  'spam'        Ture
  ''            False
  []            False
  {}            False
  1             Ture
  0.0           False
  None          False
'''

#调用内置函数type(X)能够返回对象X的类型对象
print type(98)


#Python读取和写入数据     r只读，w可写，a追加

#创建一个文件，并写入Hello World
F = open('C://Python25//myfile.txt','w')
F.write("Hello World/n")
F.close()
#调用刚已经创建的文件：
Y = open(r'C://Python25//myfile.txt').read()
print Y
#向刚创建的文件中追加内容
X = open('myfile.txt','a')
X.write("Wo jiu Kao Le/n")
X.close()
Y = open(r'C://Python25//myfile.txt').read()
print Y

#文件内容追加，内容是从0到9的整数, 每个数字占一行：
M = open('myfile.txt','a')
for i in range(0,10):
    M.write(str(i)+'/n')
M.close()
N = open(r'C://Python25//myfile.txt').read()
print N

#文件内容追加，从0到9的10个随机整数,每个数字一行：
import random
f=open('myfile.txt','a')
for i in range(0,10):
    f.write(str(random.randint(0,9)))
    f.write('/n')
f.close()
Y = open(r'C://Python25//myfile.txt').read()
print Y