1. 字典
定义：｛key1:value1,key2:value2｝,key-value结构，key必须可hash
特性：
1.可存放多个值
2.可修改指定key对应的值，可变
3.无序
1.1. 创建字典
person = {"name": "Jack", 'age': 18}
person = dict(name='Jack', age=18)
person = dict({"name": "Jack", 'age': 18})
person = dict((['name','Jack'],['age',18]))
{}.fromkeys
(seq,100) #不指定100默认为None
1.2. 内置函数及操作方法
1.2.1. get() #获取
>>> dic = {"name":"Jack","age":18}
>>> dic.get("name")
'Jack'
>>> print(dic.get("gender")) #如果keys不存在，会返回None而不会报错
None
>>> dic["name"]
'Jack'
>>> dict["gender"] #这样会报错
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'type' object is not subscriptable
1.2.2. items() #转换
>>> dic = {"name":"Jack","age":18}
>>> dic.items()
dict_items([('name', 'Jack'), ('age', 18)]) #转换为列表中套元组
不建议如下的遍历方法：
>>> for i,j in dic.items():
... print(i,j)
...
name Jack
age 18
由于存在数据转换过程，数据量大时会影响效率。
1.2.3. keys() #得到key
>>> dic.keys()
dict_keys(['name', 'age'])
1.2.4. update() #添加字典
>>> dic
{'name': 'Jack', 'age': 18}
>>> dic1 = {"sex":"male"}
>>> dic.update(dic1)
>>> dic
{'name': 'Jack', 'sex': 'male', 'age': 18}
1.2.5. values() #获取value
>>> dic
{'name': 'Jack', 'sex': 'male', 'age': 18}
>>> dic.values()
dict_values(['Jack', 'male', 18])
1.2.6. pop() #以key作为条件删除，并返回value
>>> dic.pop("sex")
'male'
>>> dic
{'name': 'Jack', 'age': 18}
1.2.7. popitem() #随机删除字典中的项并返回
>>> dic = {'name': 'Jack', 'sex': 'male', 'age': 18}
>>> dic.popitem()
('name', 'Jack')
1.2.8. clear() #清空字典
>>> dic
{'age': 18, 'sex': 'male'}
>>> dic.clear()
>>> dic
{}
1.2.9. setdefault() #增加项
>>> dic
{'age': 18, 'sex': 'male'}
>>> dic
{}
>>> dic.setdefault("name","Jack")
'Jack'
>>> dic
{'name': 'Jack'}
>>> dic.setdefault("age",18)
18
>>> dic.setdefault("age",18) #重复输入无影响
18
>>> dic
{'name': 'Jack', 'age': 18}
>>> dic.setdefault("age",19) #key一样，value不同还会保留原有状态
18
>>> dic
{'name': 'Jack', 'age': 18}
>>> dic.setdefault("sex",[]) #可增加列表
[]
>>> dic.setdefault("sex",[]).append("male")
>>> dic.setdefault("sex",[]).append("female")
>>> dic
{'name': 'Jack', 'sex': ['male', 'female'], 'age': 18}
1.2.10. dict.fromkeys() # 以现成序列中的每一个元素作为字典的key，可指定共同的value
>>> b = [1,2,3,4]
>>> a = dict.from(b,1)
>>> a = dict.fromkeys(b,1)
>>> a
{1: 1, 2: 1, 3: 1, 4: 1}
>>> a = dict.fromkeys(b,) #不指定value，则value为None
>>> a
{1: None, 2: None, 3: None, 4: None}
1.2.11. copy() # 拷贝字典
如果将字典a赋值给变量b，那么两个变量都指向一块内存地址，修改任意一个字典另一个都会跟着变，如下：
>>> a = {"name":"Jack","age":18}
>>> b = a
>>> a
{'name': 'Jack', 'age': 18}
>>> b
{'name': 'Jack', 'age': 18}
>>> b["name"]="Mike"
>>> b
{'name': 'Mike', 'age': 18}
>>> a
{'name': 'Mike', 'age': 18}
>>> id(a)
38612304
>>> id(b)
38612304
如果使用copy()复制出一个字典，则可以避免这种情况：
>>> a = {"name":"Jack","age":18}
>>> id(a)
38612504
>>> id(b)
6203792
>>> b["name"] = "Mike"
>>> b
{'name': 'Mike', 'age': 18}
>>> a
{'name': 'Jack', 'age': 18}
但这仅仅是浅层次的copy，如果是字典中套字典的深层次，就又会出现共用内存的情况：
>>> a = {"name":"Jack","age":18,"hobbies":{1:"song",2:"running"}}
>>> b = a.copy()
>>> b
{'hobbies': {1: 'song', 2: 'running'}, 'name': 'Jack', 'age': 18}
>>> id(a)
6203792
>>> id(b)
38580136
>>> id(a.get("hobbies"))
38612504
>>> id(b.get("hobbies"))
38612504
>>> b["hobbies"][1]="swimming"
>>> b
{'hobbies': {1: 'swimming', 2: 'running'}, 'name': 'Jack', 'age': 18}
>>> a
{'hobbies': {1: 'swimming', 2: 'running'}, 'name': 'Jack', 'age': 18}
为复制出一个完全独立的新字典，我们这里引入深copy的概念：
>>> import copy
>>> a = {"name":"Jack","age":18,"hobbies":{1:"song",2:"running"}}
>>> b = copy.deepcopy(a)
>>> id(a)
38612264
>>> id(b)
38892648
>>> id(a.get("hobbies"))
38612304
>>> id(b.get("hobbies"))
38893328
>>> b["hobbies"][1]="swimming"
>>> b
{'hobbies': {1: 'swimming', 2: 'running'}, 'name': 'Jack', 'age': 18}
>>> a
{'hobbies': {1: 'song', 2: 'running'}, 'name': 'Jack', 'age': 18}
2. 元组
定义：与列表类似，只不过［］改成（）
特性：
1.可存放多个值
2.不可变
3.按照从左到右的顺序定义元组元素，下标从0开始顺序访问，有序
2.1. 创建元组
tuple1 = ("Jack","James","Mike","Tom","Bob")
tuple1 = tuple(("Jack","James","Mike","Tom","Bob"))
2.2. 内置函数
2.2.1. count() #获取元素数量
>>> tuple1 = ("Jack","James","Mike","Tom","Bob")
>>>
>>> tuple1
('Jack', 'James', 'Mike', 'Tom', 'Bob')
>>> tuple1 = ("Jack","James","Mike","Tom","Bob","Tom")
>>> tuple1.count("James")
1
>>> tuple1.count("Tom")
2
>>> tuple1.count("123")
0
2.2.2. index() #获取元素下标，有重复元素只返回第一个下标
>>> tuple1.index("Jack")
0
>>> tuple1.index("Tom")
3
>>> tuple1.index("123") #不存在元素作为条件会报错
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: tuple.index(x): x not in tuple
3.集合
定义：由不同元素组成的集合，集合中是一组无序排列的可hash值，可以作为字典的key
特性：
1.集合的目的是将不同的值存放到一起，不同的集合间用来做关系运算，无需纠结于集合中单个值
3.1. 创建集合
{1,2,3,1}
或
定义可变集合set
>>> set_test=set('hello')
>>> set_test
{'l', 'o', 'e', 'h'}
改为不可变集合frozenset
>>> f_set_test=frozenset(set_test)
>>> f_set_test
frozenset({'l', 'e', 'h', 'o'})
3.2.工厂函数和关系运算
3.2.1. add() #添加元素
>>> set1 = {'James', 'Mike', 'Tom', 'Bob', 'Jack'}
>>> set1.add("Ewing")
>>> set1
{'Mike', 'Tom', 'Bob', 'Ewing', 'James', 'Jack'}
>>> set1.add("Tom") #集合中的元素没有重复
>>> set1
{'Mike', 'Tom', 'Bob', 'Ewing', 'James', 'Jack'}
3.2.2.intersection() #求交集
>>> set1
{'Mike', 'Tom', 'Bob', 'Ewing', 'James', 'Jack'}
>>> set2
{'Kobe', 'Bird', 'Jack'}
>>> set1&set2 #关系运算
{'Jack'}
>>> set1.intersection(set2)
{'Jack'}
3.2.3.union() #求并集
>>> set1
{'Mike', 'Tom', 'Bob', 'Ewing', 'James', 'Jack'}
>>> set2
{'Kobe', 'Bird', 'Jack'}
>>> set1|set2
{'Mike', 'Tom', 'Bob', 'Ewing', 'James', 'Kobe', 'Bird', 'Jack'}
>>> set1.union(set2)
{'Mike', 'Tom', 'Bob', 'Ewing', 'James', 'Kobe', 'Bird', 'Jack'}
3.2.4.difference() #求差集
>>> set1
{'Mike', 'Tom', 'Bob', 'Ewing', 'James', 'Jack'}
>>> set2
{'Kobe', 'Bird', 'Jack'}
>>> set1-set2
{'Mike', 'Tom', 'Bob', 'Ewing', 'James'}
>>> set1.difference(set2)
{'Mike', 'Tom', 'Bob', 'Ewing', 'James'}
>>> set2-set1
{'Kobe', 'Bird'}
>>> set2.difference(set1)
{'Kobe', 'Bird'}
3.2.5.symmetric_difference() #求对称差集
>>> set1^set2
{'Mike', 'Tom', 'Bob', 'Ewing', 'Kobe', 'Bird', 'James'}
>>> set1.symmetric_difference(set2)
{'Mike', 'Tom', 'Bob', 'Ewing', 'Kobe', 'Bird', 'James'}
3.2.6.pop() #删除元素
>>> set1
{'Mike', 'Tom', 'Bob', 'Ewing', 'James', 'Jack'}
>>> set1.pop()
'Mike'
>>> set1
{'Tom', 'Bob', 'Ewing', 'James', 'Jack'}
集合为空时执行此命令会报错：
>>> set1.pop()
Traceback (most recent call last):
File "<stdin>", line 1, in <module
KeyError: 'pop from an empty set'
3.2.7.remove() #删除元素
>>> set1
{'Mike', 'Tom', 'Ewing', 'Bob', 'James', 'Jack'}
>>> set1.remove("Mike")
>>> set1
{'Tom', 'Ewing', 'Bob', 'James', 'Jack'}
参数为不存在的项，执行会报错：
>>> set1.remove("123")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
3.2.8.discard() #删除元素
>>> set1.discard("Tom")
>>> set1
{'Ewing', 'Bob', 'James', 'Jack'}
参数为不存在的项，执行不会报错，会返回None：
>>> set1.discard("123")
>>> set1
{'Ewing', 'Bob', 'James', 'Jack'}
>>> print (set1.discard("123"))
None
3.2.9.issubset() #判断是否为子集
>>> set1
{'Ewing', 'Bob', 'James', 'Jack'}
>>> set2={"Ewing","Bob"}
>>> set2<set1
True
>>> set2<=set1
True
>>> set2.issubset(set1)
True
>>>
3.2.10.issuperset() #判断是否为父集
>>> set1
{'Ewing', 'Bob', 'James', 'Jack'}
>>> set2
{'Bob', 'Ewing'}
>>> set1.issuperset(set2)
True
4.文件操作
4.1.打开关闭文件
使用open函数：
f = open("a.txt")
f.close()
4.2.读文件
使用"r”参数或不加参数
f = open("a.txt","r") or f=open("a.txt","r")
将文件内容以字符串类型全部读出：
f.read()
将文件内容以列表类型全部读出：
f.readlines()
只读出文件一行：
f.readline()
for i in f:print (i)，可以不一次将文件内容全部加载到内存，一行一行读。
以下为“读--写”模式，可以先读取文件内容再写入，写入的内容追加到文件尾部：
f = open("a.txt","r+")
print (f.read())
f.wirte("123456")
f.close()
以下为“二进制读”模式，以二进制的方式读取文件：
f = open("a.txt","rb")
print (f.read())
f.close()
4.3.写文件
参数"w"为“创建-写”，参数"a"为“追加写”
f = open("a.txt","w")
f.write(str) #参数必须为字符串类型
f.close()
执行以上语句会重新生成一个空的a.txt文件，并将“str”内容写到文件。
f = open("a.txt","a")
f.write(str)
f.close()
执行以上语句会在a.txt原内容基础上，将“str”内容追加到文件内容末尾。
list = [...]
f.writelines(list)
writelines函数可以将列表、元组等容器中的内容全部写入到文件。
以下为“写--读”模式，会清空原文件并写入内容，同时可以进行读操作：
f = open("a.txt","w+")
print (f.read()) #此时文件被清空，读不出内容
f.write(str)
print (f.read()) #此时光标在文件尾部，同样读不出内容...
f.close()
以下为“追加写--读”模式，会追加写入文件末尾，同事可以进行读操作：
f = open("a.txt","a+")
print (f.read()) #此时文件没有被清空，但光标的位置在文件末尾，依然读不出内容
f.write(str) #无论是否指定光标位置，都会在文件尾部追加
print (f.read()) #此时光标在文件尾部，读不出内容...
f.close()
4.4.光标位置
seek() #指定光标位置
f.seek(0)、f.seek(10)...
tell() #记录光标位置
print (f.tell()) #可查看光标位置
浙公网安备 33010602011771号