python 3 学习笔记 (三)

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)与for i in f.readline()功能类似，可以不一次将文件内容全部加载到内存，一行一行读。

以下为“读--写”模式，可以先读取文件内容再写入，写入的内容追加到文件尾部：

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()) #可查看光标位置