python基础3

Posted 2020-08-16

本次内容：

元祖

字典

浅copy和深copy

集合

文件处理

1.1元祖

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

创建元祖

1 name = (‘xiaojian‘,‘yangjian‘,‘while‘,‘yj‘)
2 name1 = (‘xiaojian‘,) #元祖只有一个元素时，需要加逗号（,）
3 kong = () #创建一个空元祖

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

删除元祖

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

不可修改的元祖的意义：

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

1.2字典

字典（dictionary）是一种可变容器的类型，且可存储任意类型对象。

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

键（key）必须是唯一的，但键必须是不可变的，如字符串，数字，元祖

 

字典的特性：

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

 

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

举例说明：

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

 

创建字典

 1 grade1 = {
 2     ‘stu001‘:‘xiaojian‘,
 3     ‘stu002‘:‘xiaoming‘,
 4     ‘stu003‘:‘xiaowang‘,
 5     ‘stu004‘:‘xiaoli‘,
 6     ‘stu005‘:‘xiaoyang‘,
 7 }
 8 
 9 或者
10 
11 grade2 = {
12     ‘stu001‘: [‘xiaojian‘,8,‘female‘],
13     ‘stu001‘: [‘xiaojian‘,8,‘male‘],  #这里我写了两个重复key，但是查看字典，会记住第二次赋值的key
14     ‘stu002‘: [‘xiaomei‘,8,‘female‘],
15     ‘stu003‘: [‘xiaoming‘,7,‘male‘],
16     ‘stu004‘: [‘xiaoming‘,8,‘female‘],
17     ‘stu005‘: [‘xiaoyang‘,8,‘male‘],
18 }

输入结果：

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

其他用法

 1 #dict.fromkeys()  创建一个新字典，以序列（seq）中元素做字典的key，value为字典所有键（key）对应的初始值
 2 dict1 = dict.fromkeys([1,2,3,4],‘a‘)
 3 print(dict1)
 4 {1: ‘a‘, 2: ‘a‘, 3: ‘a‘, 4: ‘a‘}
 5 
 6 #grade1.get()返回指定键的值，如果只不在字典中返回None值
 7 print(grade1.get(‘stu007‘))
 8 
 9 #grade1.items() 以列表返回可遍历的（key，value）元祖数组
10 print(grade1.items())
11 #dict_items([(‘stu003‘, ‘xiaowang‘), (‘stu005‘, ‘xiaoyang‘), (‘stu002‘, ‘xiaoming‘), (‘stu001‘, ‘xiaojian‘), (‘stu004‘, ‘xiaoli‘)])
12 
13 # grade1.keys() 以列表形式，返回一个字典的所有键
14 print(grade1.keys())
15 # dict_keys([‘stu002‘, ‘stu001‘, ‘stu003‘, ‘stu004‘, ‘stu005‘])
16 
17 
18 # grade1.setdefault(key,default=None)和get()类似，如果有该键，则获取该键的值，但如果键不存在字典中，将会添加键并将值设为default
19 print(grade1.setdefault(‘stu005‘,‘aaa‘)) #在字典中有该key
20 # xiaoyang
21 
22 print(grade1.setdefault(‘stu007‘,‘小王‘)) #在字典中没有该key
23 # 小王
24 
25 # dict1.update(dict2) 把字典2的更新到字典一的值
26 
27 #grade1.values() 以列表返回字典中的所有值
28 print(grade1.values())
29 dict_values([‘xiaoming‘, ‘xiaowang‘, ‘xiaojian‘, ‘xiaoyang‘, ‘xiaoli‘])

View Code

1.2浅copy和深copy

字典只有顶级对象

 1 >>> import copy  #导入copy模块
 2 >>> info = {‘name‘:‘xiaojian‘,‘age‘:18}  #原始字典
 3 >>> info_copy = copy.copy(info) #浅拷贝
 4 >>> info_deep = copy.deepcopy(info) #深拷贝
 5 >>> info;info_copy;info_deep
 6 {‘age‘: 18, ‘name‘: ‘xiaojian‘}
 7 {‘age‘: 18, ‘name‘: ‘xiaojian‘}
 8 {‘age‘: 18, ‘name‘: ‘xiaojian‘}
 9 >>> id(info);id(info_copy);id(info_deep)  #3个不同的对象
10 3070319084
11 3070120364
12 3070120268
13 >>> info[‘age‘] = 19  #改变了源
14 >>> info;info_copy;info_deep   #源变了，深浅copy没变
15 {‘age‘: 19, ‘name‘: ‘xiaojian‘}
16 {‘age‘: 18, ‘name‘: ‘xiaojian‘}
17 {‘age‘: 18, ‘name‘: ‘xiaojian‘}

字典嵌套对象

 1 >>> import copy
 2 >>> work  = {‘name‘:‘xiaojian‘,‘jobs‘:[‘it‘,‘cameramen‘]} #定义一个嵌套（子结构 ）的字典
 3 >>> work_copy = copy.copy(work)  #浅拷贝对象work_copy
 4 >>> work_deep = copy.deepcopy(work) #深拷贝对象work_deep
 5 >>> work;work_copy;work_deep #未做任何改动时，值都是一样的
 6 {‘jobs‘: [‘it‘, ‘cameramen‘], ‘name‘: ‘xiaojian‘}
 7 {‘jobs‘: [‘it‘, ‘cameramen‘], ‘name‘: ‘xiaojian‘}
 8 {‘jobs‘: [‘it‘, ‘cameramen‘], ‘name‘: ‘xiaojian‘}
 9 >>> id(work);id(work_copy);id(work_deep)  #可以看出内存空间的对象不一样
10 3070921196
11 3070722540
12 3070722380
13 >>> work[‘jobs‘][0] = ‘boss‘ #改变job值得子对象‘it‘->‘boss‘
14 >>> work;work_copy;work_deep #work和work_copy都发生改变，work_deep不变
15 {‘jobs‘: [‘boss‘, ‘cameramen‘], ‘name‘: ‘xiaojian‘}
16 {‘jobs‘: [‘boss‘, ‘cameramen‘], ‘name‘: ‘xiaojian‘}
17 {‘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‘])

 1 #添加
 2 a.add(‘g‘)   #a添加一项
 3 print(a)
 4 # {‘g‘, ‘a‘, ‘e‘, ‘d‘, ‘b‘, ‘f‘, ‘c‘}
 5 b.update([1,2,3,4])   #在b中添加多项
 6 print(b)
 7 # {1, 2, 3, 4, ‘d‘, ‘b‘, ‘c‘}
 8 
 9 #删除
10 a.remove(‘f‘)
11 a.discard(‘h‘) #不会报错的删除
12 print(a)
13 # {‘e‘, ‘b‘, ‘d‘, ‘a‘, ‘c‘}
14 
15 #查询 （in  和 not in ）
16 print(‘a‘ in a)  #测试‘a’是否是a的成员  返回True or false
17 print(‘we‘ not in a) #测试‘we‘是否不是a的成员  返回True or false
18 
19 
20 #子集 （subset）  返回True or false
21 
22 b.issubset(a) #测试b的元素是否都在a中
23 b <= a
24 print(b.issubset(a))
25 print(b <= a)
26 
27 #父集 (superset)
28 a.issuperset(b) #测试a的元素是否在b中
29 a >= b
30 
31 #并集
32 a.union(b)
33 a | b
34 #返回一个新的集合包含a和b的所有元素
35 
36 #交集
37 a.intersection(b)
38 #返回一个新的集合包含a和b的公共元素
39 
40 #差集
41 a.difference(b)
42 #返回一个新的集合，包含a中的元素，但是没有b中的元素
43 
44 #对称差集
45 a.symmetric_difference(b)
46 print(a ^ b)
47 #返回一个新的集合包含 a和b中不重复的元素

View Code

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，将文件内容写入到文件

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

看到如下内容

#cat  file2
hard on 
go on

read()方法

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

语法：

fileObject.read([count])

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

例：

打开已有的file1文件

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

打印结果：

读取的内容: i can

文件定位

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

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

例：用上面的文件file1

 1 #!/usr/bin/env python
 2 #-*- coding:utf-8 -*-
 3 
 4 #打开一个文件，采用utf-8的编码格式
 5 test = open(‘file1‘,‘r‘,encoding=‘utf-8‘)
 6 
 7 str1 = test.read(5)
 8 print("读取的内容:",str1)
 9 
10 #获取当前在第几个字节
11 position = test.tell()
12 print("当前文件位置:",position)
13 
14 #从第6个字节开始读取
15 aa = test.seek(6)
16 print("重新读取的文件位置:",test.read())
17 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指定，默认为当前文件位置。

View Code