python自学第四周（20201126） 元组tuple、文件运算等笔记

python自学第四周（20201126） 元组tuple、文件运算等笔记
将来继续翻一翻看一看加强印象和练习。
啦啦啦啦，告别非常枯燥的基础课程，努力努力！

print('=======元组tuple、文件运算==========')
print('=======1、元组tuple==========')
"""
特点：由简单的对象组构成，与列表非常类似，不能在原处修改，他们是不可变的，并且通常写成圆括号，，而不是方括号；
不支持任何方法调用，但元组具有列祖的大多数属性。
为什么有了列表还要元组呢？ 元组的不可变性提供了某种完整性。

常见元组常量和运算
运算                           解释
()                            空元组
T=(0,)                       单个元素的元组(非表达式)
T=(0,'Ni',1.2,3)             四个元素的元组
T=0,'Ni',1.2,3               另一个四元素的元组(与前列相同)
T=(abc',('def','ghi'))        嵌套元组
T= tuple('spam')              一个可迭代对象的项的元组
 T[i]                         索引、索引的索引、分片、长度
 T[i][j]
 T[i:j]
 len(T)
T1+T2                          合并、重复
T*3
 for x in T: print(x)          迭代、成员关系
 'spam' in T
 [x * 2 for x in T]
"""
t1=(1,2)+(3,4)
print(t1,t1.index(4),t1.count(4))  #index(i) 数值定位； count(i)统计
print((1,2)*4)
print(t1[0],t1[1:3])

print('=======元组tuple特殊用法==========')
x=(40)
y=(40,)
print('x,y分别为：',x,y)

print('=======2、文件运算==========')
""" 
以下说明来源于：《python学习手册》page244
 output=open(r'C:\spam','w') 创建输出文件(w是指写入)
 input=open('data','r') 创建输入文件(r是指读写)
 input=open('data') 与上一行相同(r是默认值)
 aString= input.read() 把整个文件读进单一字符串
 aString= input.read(N) 读取之后的N个字节(一或多个)到一个字符串
 aString= input. readline()读取下一行(包括行末标识符)到一个字符串
 aList= input. readlines() 读取整个文件到字符串列表
 output. write(aString) 写入字节字符串到文件
 output. writelines(alist) 把列表内所有字符串写入文件
 output. close() 手动关闭(当文件收集完成时会替你关闭文件)
 output. flush() 把输出缓冲区刷到硬盘中,但不关闭文件
 anyFile.seek(N) 修改文件位置到偏移量N处以便进行下一个操作
 for line in open('data'): use line文件迭代器一行一行地读取
 open('f.txt', encoding='latin--1') Python3.0 Unicode文本文件(str字符串)
 open('f. bin', 'rb') Python3.0二进制byte文件(bytes字符串)
 尾巴‘a’ 代表为文件尾部追加内容而打开文件。
"""
print('=======2、文件运算，由此开始，办公半自动化或者自动化旅程开始==========')
p2_file = open('p2_file.txt','w') #创建输出文件p2_file,默认路径，建议修改路径。
p2_file.write('hello text file!\n')
p2_file.write('goodby text file!\n')
p2_file.close()

myfile = open('p2_file.txt')
print(myfile.readline(),myfile.readline(),myfile.readline()) #打印顺序下来,尽量不要这种方式，下一行会出现空格

myfile = open('p2_file.txt')
s1 = open('p2_file.txt').read() #用read方法读入到字符串中，并打印。
print(s1)

myfile = open('p2_file.txt')
print(myfile.read())

#如果要一行一行扫描文本文件，文件迭代器往往是最佳选择
for line in open('p2_file.txt'):
    print(line,end='')

print('=======2、文件中存储并解析python对象==========')
x,y,z = 43,44,45
s ='spam'
d ={'a':1,'b':2}
l=[1,2,3]

F =open('p2_file1.txt','w')
F.write(s+'\n')
F.write('%s,%s,%s\n'%(x,y,z))
F.write(str(l)+'$'+str(d)+'\n')
F.close()

chars = open('p2_file1.txt').read()
print(chars)

#现在我们不得不使用其他转换工具，将文本文件中的字符串转换成真正的python对象
#数据处理
F= open('p2_file1.txt')
line = F.readline()
line1= line.rstrip()
# print(line)
print(line.rstrip())  #rstrip去除多余的行终止符
line = F.readline()
parts = line.split(',')
numbers = [int(p) for p in parts] #不一定非要运行rstrip来删除最后‘\n’，int 和一些其他转换方法会忽略数字旁边的空白
print(numbers)
line = F.readline()
parts = line.split('$')
objects = [eval(p) for p in parts] #  eval内置函数，能够将字符串当做可执行程序代码
print(objects)

# with open (r'C:\misc\data.txt') as p2_file:
#     for line in myfile:
#     ...use line here...

# myfile = open(r'C:\misc\data.txt')
# try:
#     for line in myfile:
#         ...use line here
# finally:
#     myfile.close()

print('=======2、对象灵活性，循环嵌套==========')
l1= ['abc',[(1,2),([3],4)],5]
print(l1[1])
print(l1[1][1])
print(l1[1][1][0])
print(l1[1][1][0][0])

print('=======3、引用及拷贝==========')
"""
拷贝方式：
序列：没有限制条件的分片表达式(L[:])能够复制序列。
字典copy方法(X.copy())能够复制字典。
有些内置函数(例如,list)能够生成拷贝(list(L))。
copy标准库模块能够生成完整拷贝。
"""
#与下面例子做比较
X=[1,2,3]
L=['a',X,'b']
D={'x':X,'y':2}
X[1]='surprise'
print(L,D)

#假如你有列表和字典，不想通过其他变量来修改他们的值
l3=[1,2,3]
d1={'a':1,'b':2}
l4 = l3[:]
d2 = d1.copy()
l4[1]='Ni'
d2['c']= 'spam'
print(l3,d1) #不更改原有的
print(l4,d2) #在新的列表和字典更改

#注：无条件的分片和字典COPY方法智能做顶层复制。
#注：完全独立的拷贝： import copy  X=copy.deepcopy(Y) 复制嵌套结果所有X的组成部分

print('=======4、比较、相等与真值==========')
l5 = [1,('a',3)]
l6 = [1,('a',3)]
print('1:',l5==l6,l5 is l6) #  == 测试值是否相等； is 表达式测试对象的一致性，是否同一个内存地址中。

s1 ='spam'
s2= 'spam'
print('2:',s1==s2,s1 is s2)  #暂时储存的短字符串作为最佳化，分享给S1和S2用，唯一字符串

s3 = 'a longer string'
s4 = 'a longer string'
print('3:',s3==s4,s3 is s4) #

l7=[1,('a',3)]
l8=[1,('a',2)]
print('4:',l7<l8,l7==l8,l7>l8)

"""
一般来说, Python中不同的类型的比较方法如下:
♥ 数字通过相对大小进行比较。
♥ 字符串是按照字典顺序,一个字符接一个字符地对比进行比较("abc"<"ac")。列表和元组从左到右对每部分的内容进行比较。
♥ 字典通过排序之后的(键、值)列表进行比较。字典的相对大小比较在【Python3.0中不支持】,但是,它们在 Python2.及更早的版本中有效,
就像是比较排序的(键、值)列表一样。
♥ 数字混合类型比较(例如,1<spam')在 Python3.0中是错误的。 Python2.6中允许这样的比较,但是使用一种固定但任意的排序规则。
通过代理,这也适用于排序,它在内部使用比较:非数字的混合类型集合不能在 Python3.0中排序。
  一般来说,结构化对象的比较就好像是你把对象写成文字,并从左到右一次一个地比较所有部分。
"""

print('=======4、python真与假==========')
"""
数字如果非零,则为真。
其他对象如果非空,则为真。
Python中对象的真、假值的例子。
表9-4:对象真值的例子
对象          值
 "spam"     True
 ""          False
 []         False
{}          False
 1          True
0.0         False
None        False
"""
print(bool(1),bool('spam'),bool({}))

#赋值生成应用，而不是拷贝
l11=[1,2,3]
l12=['x',l11,'y']
print('l12为：',l12)
l11[1]=0
print('l12:',l12)

l13=[1,2,3]
l14=['x',l13[:],'y']  #拷贝区别
l13[1]= 0
print(l13,l14)

#下面这个例子中的l16赋值给重复四次的l15,而l17赋值给包含重复四次的l15的列表:
l15=[1,2,3]
l16=l15*4   #整个列表COPY,[1,2,3]+[1,2,3]+[1,2,3]+[1,2,3]
l17=[l15]*4 #[l17]+[l17]+[l17]+[l17]
print('l16,l17分别为：',l16,l17)

l15[1]=0
print('新的l16,l17分别为：',l16,l17)

l18 = ['hello']
l18.append(l18)  #不断引入自身值
print(l18)

#练习：把元组 （4，5，6）修改为 （1，5，6）
T=(4,5,6)
T=(1,)+T[1:]
print(T)

S='spam'
print(S[0][0][0][0][0])


print('=======下次开始学习语法了，啦啦啦啦，告别非常枯燥的基础课程==========')