python基础3(元祖、字典、深浅copy、集合、文件处理)

本次内容:


元祖

字典

浅copy和深copy

集合

文件处理

1.1元祖

元祖(tuple)与列表类似,不同之处在于元祖的元素不能修改,元祖使用小括号(),列表使用方括号[].元祖创建很简单,只需要在括号中添加元素,并使用逗号隔开即可。

创建元祖

 name = ('xiaojian','yangjian','while','yj')
name1 = ('xiaojian',) #元祖只有一个元素时,需要加逗号(,)
kong = () #创建一个空元祖

元祖与列表类似,下标索引从0开始,可以进行截取,组合。

删除元祖

#元祖的元素值是不允许删除的,但可以使用del语句删除整个元祖
del name

不可修改的元祖的意义:

因为tuple不可变,所以代码更安全。如果可能,能用tuple代替代替list就尽量用tuple。

1.2字典

字典(dictionary)是一种可变容器的类型,且可存储任意类型对象。

字典的每个(key:value)对用冒号(:),每个对之间用逗号(,)分隔

键(key)必须是唯一的,但键必须是不可变的,如字符串,数字,元祖

字典的特性:

  1. 不允许同一个键(key)出现两次,创建时如果同一个key被赋值两次,后一个值会被记住。
  2. 键(key)必须是可变的,所以用数字,字符串或元祖充当,列表不行。
  3. 字典是无序的

字典的意义:我们可以找出某个key对应的value;列表和元祖,都是一种容器,但是只是储存单一的元素。

举例说明:

一个班级,要找出“小明”相应的信息,如果这个班级可能两个人或多个人叫同一个名字,那么我们需要通过唯一(key)的学号, 来获取相应学号的姓名,年级,班级,性别等等

创建字典

 grade1 = {
'stu001':'xiaojian',
'stu002':'xiaoming',
'stu003':'xiaowang',
'stu004':'xiaoli',
'stu005':'xiaoyang',
} 或者 grade2 = {
'stu001': ['xiaojian',8,'female'],
'stu001': ['xiaojian',8,'male'], #这里我写了两个重复key,但是查看字典,会记住第二次赋值的key
'stu002': ['xiaomei',8,'female'],
'stu003': ['xiaoming',7,'male'],
'stu004': ['xiaoming',8,'female'],
'stu005': ['xiaoyang',8,'male'],
}

输入结果:

print(grade1)
print(grade2) {'stu003': 'xiaowang', 'stu001': 'xiaojian', 'stu004': 'xiaoli', 'stu005': 'xiaoyang', 'stu002': 'xiaoming'}
{'stu003': ['xiaoming', 7, 'male'], 'stu001': ['xiaojian', 8, 'female'], 'stu004': ['xiaoming', 8, 'female'], 'stu005': ['xiaoyang', 8, 'male'], 'stu002': ['xiaomei', 8, 'female']}

增加

grade1['stu006']='yangjian'

print(grade1)
{'stu005': 'xiaoyang', 'stu006': 'yangjian', 'stu002': 'xiaoming', 'stu004': 'xiaoli', 'stu003': 'xiaowang', 'stu001': 'xiaojian'}

删除

del grade1['stu001']  #删除特定key
grade1.pop('stu002') #删除特定key
grade1.popitem() #随机删除某一key
grade1.clear() #清空字典
del grade1 #删除字典

修改

grade1['stu001'] = '小贱'  #如果没有该key,则在字典创建新的的的key-value

print(grade1)
{'stu001': '小贱', 'stu002': 'xiaoming', 'stu003': 'xiaowang', 'stu005': 'xiaoyang', 'stu004': 'xiaoli'}

查询

print('stu005' in grade1)  #查询该key是否在字典里,返回  True  or  false
print(grade1.get('stu001')) #查询该key的值,如没有该key 则返回None
print(grade1['stu001']) #查询已知key,如没有该key。则会有语法错误KeyError

其他用法

 #dict.fromkeys()  创建一个新字典,以序列(seq)中元素做字典的key,value为字典所有键(key)对应的初始值
dict1 = dict.fromkeys([1,2,3,4],'a')
print(dict1)
{1: 'a', 2: 'a', 3: 'a', 4: 'a'} #grade1.get()返回指定键的值,如果只不在字典中返回None值
print(grade1.get('stu007')) #grade1.items() 以列表返回可遍历的(key,value)元祖数组
print(grade1.items())
#dict_items([('stu003', 'xiaowang'), ('stu005', 'xiaoyang'), ('stu002', 'xiaoming'), ('stu001', 'xiaojian'), ('stu004', 'xiaoli')]) # grade1.keys() 以列表形式,返回一个字典的所有键
print(grade1.keys())
# dict_keys(['stu002', 'stu001', 'stu003', 'stu004', 'stu005']) # grade1.setdefault(key,default=None)和get()类似,如果有该键,则获取该键的值,但如果键不存在字典中,将会添加键并将值设为default
print(grade1.setdefault('stu005','aaa')) #在字典中有该key
# xiaoyang print(grade1.setdefault('stu007','小王')) #在字典中没有该key
# 小王 # dict1.update(dict2) 把字典2的更新到字典一的值 #grade1.values() 以列表返回字典中的所有值
print(grade1.values())
dict_values(['xiaoming', 'xiaowang', 'xiaojian', 'xiaoyang', 'xiaoli'])

1.2浅copy和深copy

字典只有*对象

 >>> import copy  #导入copy模块
>>> info = {'name':'xiaojian','age':18} #原始字典
>>> info_copy = copy.copy(info) #浅拷贝
>>> info_deep = copy.deepcopy(info) #深拷贝
>>> info;info_copy;info_deep
{'age': 18, 'name': 'xiaojian'}
{'age': 18, 'name': 'xiaojian'}
{'age': 18, 'name': 'xiaojian'}
>>> id(info);id(info_copy);id(info_deep) #3个不同的对象
3070319084
3070120364
3070120268
>>> info['age'] = 19 #改变了源
>>> info;info_copy;info_deep #源变了,深浅copy没变
{'age': 19, 'name': 'xiaojian'}
{'age': 18, 'name': 'xiaojian'}
{'age': 18, 'name': 'xiaojian'}

字典嵌套对象

 >>> import copy
>>> work = {'name':'xiaojian','jobs':['it','cameramen']} #定义一个嵌套(子结构 )的字典
>>> work_copy = copy.copy(work) #浅拷贝对象work_copy
>>> work_deep = copy.deepcopy(work) #深拷贝对象work_deep
>>> work;work_copy;work_deep #未做任何改动时,值都是一样的
{'jobs': ['it', 'cameramen'], 'name': 'xiaojian'}
{'jobs': ['it', 'cameramen'], 'name': 'xiaojian'}
{'jobs': ['it', 'cameramen'], 'name': 'xiaojian'}
>>> id(work);id(work_copy);id(work_deep) #可以看出内存空间的对象不一样
3070921196
3070722540
3070722380
>>> work['jobs'][0] = 'boss' #改变job值得子对象'it'->'boss'
>>> work;work_copy;work_deep #work和work_copy都发生改变,work_deep不变
{'jobs': ['boss', 'cameramen'], 'name': 'xiaojian'}
{'jobs': ['boss', 'cameramen'], 'name': 'xiaojian'}
{'jobs': ['it', 'cameramen'], 'name': 'xiaojian'}

总结:

  1. 深浅copy都是对源对象的复制,占用不同的内存空间。
  2. 如果源对象只有一级目录的话,源做任何改动,不影响深浅拷贝对象
  3. 如果对象不止一级目录,源做任何改动,都要影响浅拷贝,但不影响深 拷贝

1.3集合

集合(set)是一个无序的,不重复的数据组合。

主要作用如下:

  1. 去重。把一个列表变成集合,就自动去重了。
  2. 关系测试,测试两组数据之前的交集,差集,并集等关系

常用操作:

a = set(['a','b','c','d','e','f'])
b = set(['b','c','d'])
 #添加
a.add('g') #a添加一项
print(a)
# {'g', 'a', 'e', 'd', 'b', 'f', 'c'}
b.update([1,2,3,4]) #在b中添加多项
print(b)
# {1, 2, 3, 4, 'd', 'b', 'c'} #删除
a.remove('f')
a.discard('h') #不会报错的删除
print(a)
# {'e', 'b', 'd', 'a', 'c'} #查询 (in 和 not in )
print('a' in a) #测试‘a’是否是a的成员 返回True or false
print('we' not in a) #测试'we'是否不是a的成员 返回True or false #子集 (subset) 返回True or false b.issubset(a) #测试b的元素是否都在a中
b <= a
print(b.issubset(a))
print(b <= a) #父集 (superset)
a.issuperset(b) #测试a的元素是否在b中
a >= b #并集
a.union(b)
a | b
#返回一个新的集合包含a和b的所有元素 #交集
a.intersection(b)
#返回一个新的集合包含a和b的公共元素 #差集
a.difference(b)
#返回一个新的集合,包含a中的元素,但是没有b中的元素 #对称差集
a.symmetric_difference(b)
print(a ^ b)
#返回一个新的集合包含 a和b中不重复的元素
aa = {1,2,3,4,5,6,7,8,9}
bb = {1,3,9,10,11}
#判断两个对象是不是有交集 ,没有交集则返回True 有交集则返回False
print(aa.isdisjoint(bb)) #差集更新
print(aa.difference(bb)) #显示出两个对象的差集
aa.difference_update(bb) #name得到的更新差集,
print(aa) #对称差集更新
print(aa.symmetric_difference(bb)) #显示出两个对象的对称差集
aa.symmetric_difference_update(bb) #name得到的更新的对称差集 ,
print(aa)

1.4文件处理

对文件的操作流程

  1. 打开文件
  2. 操作文件

1.4.1打开文件

  • 文件句柄 = open('文件路径','模式')

打开文件时,需要指定文件路径和以什么方式打开文件,打开后,即可获取该文件句柄,通过此文件句柄对该文件操作。

打开文件模式有:

  • r,只读模式【默认】
  • w,只写模式【不可读;不存在则创建;存在则清空内容】
  • a,追加模式【可读;   不存在则创建;存在则只追加内容】

“+”表示可以同时读写某个文件

  • r+,读写【可读,可写】写入的文件内容会放在原文件内容的开头
  • w+,写读【可读,可写】如果该文件已存在则将其覆盖。如果该文件不存在,创建新文件
  • a+,追加读【可读,可写】打开一个文件读写。如果该文件已存在,文件指针将会放在文件结尾。文件打开是追加模式。如果该文件不存在创建新文件读写。

“b”表示已字节方式操作

  • rb或r+b
  • wb 或 w+b
  • ab或a+b

注:以b方式打开是读取到的内容是字节类型,写入时也需要提供字节类型

1.4.2操作文件

现有文件file1,内容如下:

i can smile a little more
better me

write()方法

write()可将任何字符串写入一个打开的文件。python的字符串可以是二进制数据,而不仅仅只是文字。

write()不在在字符串结尾中加换行符('\n')

语法:

fileObject.write(string)

在这里,是要新创建file2,将文件内容写入到文件

 #!/usr/bin/env python
#-*- coding:utf-8 -*- #打开一个文件,采用utf-8的编码格式
test = open('file2','w+',encoding='utf-8')
test.write("hard on \ngo on")
test.close() #关闭已打开的文件

看到如下内容

#cat  file2
hard on
go on

read()方法


read()方法,从一个已打开的文件读取字符串,需注意的是,python字符串可以是二进制数据,也可以是文件。

语法:

fileObject.read([count])

在这里,被传递的参数是从一打开的文件中读取文字个数,该方法是从文件开始从头开始读取,如果没有加上count,它会读取文件的全部内容。

例:

打开已有的file1文件

 #!/usr/bin/env python
#-*- coding:utf-8 -*- #打开一个文件,采用utf-8的编码格式
test = open('file1','r',encoding='utf-8')
str = test.read(5)
print("读取的内容:",str)
test.close() #关闭已打开的文件

打印结果:

读取的内容: i can

文件定位

提示:在utf-8的编码,中文的一个字符是3个字节
tell()文件方法告诉你文件内的当前位置:换句话说,下一次的读写会发生在文件开头的多么字节之后。

seek(number)改变当前文件的位置。改变到几个字节之后。

例:用上面的文件file1

 #!/usr/bin/env python
#-*- coding:utf-8 -*- #打开一个文件,采用utf-8的编码格式
test = open('file1','r',encoding='utf-8') str1 = test.read(5)
print("读取的内容:",str1) #获取当前在第几个字节
position = test.tell()
print("当前文件位置:",position) #从第6个字节开始读取
aa = test.seek(6)
print("重新读取的文件位置:",test.read())
test.close()

输出结果:

读取的内容: i can
当前文件位置: 5
重新读取的文件位置: smile a little more
better me

常用方法及描述:

file.close()
关闭文件。关闭后文件不能再进行读写操作。 file.flush()
刷新文件内部缓冲,直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。 file.isatty()
如果文件连接到一个终端设备返回 True,否则返回 False。 file.read()#字符个数
从文件读取指定的字符的个数,如果未给定或为负则读取所有。 file.readline()#字符个数
读取整行,包括 "\n" 字符。 file.readlines()
读取所有行并返回列表 file.tell([size])
返回文件当前位置。 file.seek([size])
设置文件当前位置 file.write(str)
将字符串写入文件,没有返回值。 file.truncate([size])
截取文件,截取的字节通过size指定,默认为当前文件位置。

 with打开文件

with open("文件名1",'模式') as f1 ,open("文件名2",'模式') as f2:
....
f1 和 f2就相当于临时变量名,打开文件的内容赋值给f1和f2

with好处:

1.可同时打开多个文件,并且自动关闭

2.用普通open()打开文件,需要手动关闭,每次都需要写file.close(),这样显得有些麻烦

上一篇:Add Binary Leetcode java


下一篇:第十二届湖南省赛G - Parenthesis (树状数组维护)