python-集合、字典

文件操作：

open()

read()

readline()

readlines()

write()

writelines()

flush()   #刷新缓冲区

seek()   修改文件读写指针

tell()    查看当前的读写指针位置

close()

r     只读

w    只写

a     追加写

r+    读写    文件读写指针的位置   头位置   在文件不存在的时候不会创建文件   文件内容不会在打开时清空

w+   读写    文件读写指针的位置   头位置    在文件不存在的时候会创建文件     文件内容会在打开时清空

a+    读写    文件读写指针的位置   尾位置    在文件不存在的时候会创建文件     文件内容不会在打开时清空

>>> mystr = 'abc:efg'

>>> mystr.split(':')

['abc', 'efg']

过滤空格回车制表删除隐藏字符

>>> mystr = ' a b c '

>>> mystr.strip()

'a b c'

不会处理中间的空格

>>> mystr.rstrip()

' a b c'

>>> mystr.lstrip()

'a b c '

>>> mystr.replace(" ","")

'abc'

-----------------------------------------------复习------------------------------------------------

字典：dict

字典首先是键值对形式

key : value

>>> mydict = {1:'a',2:'b'}

>>> mydict

{1: 'a', 2: 'b'}

工厂方法：

把数据类型当作函数来使用，那么就是工厂函数，可以起到一个数据之间互相转换的作用

>>> mydict1 = dict(([1,'a'],[2,'b']))

>>> mydict1

{1: 'a', 2: 'b'}

>>>

内建方法：

fromkeys

>>> mydict2 = dict.fromkeys((1,2,3),'a')

#首先你们把一个key值的序列传过来，然后第二个参数是你的value值

>>> mydict2

{1: 'a', 2: 'a', 3: 'a'}

>>> {key:value for key in mylist for value in mylist1}

{1: 'd', 2: 'd', 3: 'd', 4: 'd'}

字典是以key和value形式存在，key值经过hash算法，在内存映射一块保存value值得区域，

key值在经过hash算法之后，会生成一个唯一的值，任意两个数哪怕只有一位不同，生成出来的hash值也是截然不同的，因此我们得出，在字典中，key值唯一，一个字典中不可能出现两个一样的key，并且，因为做了hash，所以底层会维护一个hash表，也就是说字典的访问效率，要比列表和元组要高。

hash的值出来的结果是唯一的

可hash的数据是一个不可变的数据才可以进行hash

>>> mydict3 = {1:'a',1:'b'}

>>>

>>> mydict3

{1: 'b'}

>>> mydict4 = {1:'a',[1,2,3]:'b'}

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

TypeError: unhashable type: 'list'

>>> mydict4 = {1:'a',{2:'a'}:'b'}

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

TypeError: unhashable type: 'dict'

字典是可变数据？还是不可变的数据类型

可变所以不可以hash

能hash的都是什么？不可变的

序列：字符串，列表，元组 –》索引

访问字典中的值：无序

>>> mydict1

{1: 'a', 2: 'b'}

>>> mydict[0]

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

KeyError: 0

可以通过：

mydict[key]的方式来取出 value

>>> mydict[2]

'b'

为什么无序的也可以用for循环呢？

>>> mydict

{1: 'a', 2: 'b'}

>>> for var in mydict:

...     print(var)

...

1

2

迭代：可迭代的数据对象(数据集中的数据之间是否有位置关系的保存)

遍历：序列

更新：

添加：

>>> mydict

{1: 'b', 2: 'b'}

>>> mydict[1] = 'bbbb'

>>> mydict

{1: 'bbbb', 2: 'b'}

>>> mydict[3] = 'bbbb'

>>> mydict

{1: 'bbbb', 2: 'b', 3: 'bbbb'}

>>> mydict[3] = 'aaa'

>>> mydict

{1: 'bbbb', 2: 'b', 3: 'aaa'}

>>> mydict[4]

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

KeyError: 4

value 可以是任意有效数据对象，包括之前的函数对象，还有后面的类实例

初红包

删除字典中的内容

>>> res = mydict.pop(1)

>>> res

'a'

pop可以弹出一个key:value键值对

返回的是key对应的value

>>> mydict.clear()

>>> mydict

{}

clear函数还可以清空这个字典

>>> mydict = {1:'a',2:'b',3:'c'}

>>> del mydict[1]

>>> mydict

{2: 'b', 3: 'c'}

还可以使用del语句删除单个key:value键值对

>>> mydict

{2: 'b', 3: 'c'}

>>> del mydict

del可以把这个数据对象给删掉，删除一次引用计数

真正释放数据内存的时候是这个引用计数为0的时候

>>> mydict1.popitem()

(1, 'a')

返回一个键值对

>>> mydict1.items()

dict_items([(2, 'b'), (3, 'c')])

>>> mydict1.items()

dict_items([(2, 'b'), (3, 'c')])

>>> list(mydict1.items())

[(2, 'b'), (3, 'c')]

items内置函数用来返回字典中所有的键值对保存在dict_items 这个数据类型里

>>> list(mydict1.keys())

[2, 3]

返回字典中所有的key 包装在了一个列表中

>>> list(mydict1.values())

['b', 'c']

>>> mydict1.values()

dict_values(['b', 'c'])

返回字典中所有的value 包装在了一个列表中

判断是否在这个数据类型中

in  判断字典的时候，是判断是否存在于字典中的key值里

>>> 1 in mydict

True

not in 

在python2的老版本中，还有一个内建函数dict.has_keys()

异常抛出是从程序的最底层向上层抛出

try->except 捕获异常

>>> mydict = {1:func,2:func1}

>>> mydict[1]()

func

集合：set

集合(set)：把不同的元素组成一起形成集合，是python基本的数据类型。（无序不重复）

集合其实就是字典去掉value

key值组成了一个集合

1：数据元素唯一

2：无序

3：不可变

集合的应用场景：

如果说之后做爬虫的时候，首先你是不是获取到连接，(递归)，是不是同一个连接你不能重复去爬取下载

去重，我们就可以放到集合中

set （可变）

frozenset（不可变）元组和字符串也不可变

>>> myset1.add('abcdefg')

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

AttributeError: 'frozenset' object has no attribute 'add'

更新集合：

s.add()
s.update()    一个序列，那么会将序列集合里的数据拆分成单个元素）

>>> myset.update(5)

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

TypeError: 'int' object is not iterable

访问集合：

集合是无序的，无法通过索引和切片的方式去访问其中的值

可以通过循环迭代，

     >>> for var in myset:

...     print(var)

...

b

1

2

3

4

删除集合中的元素或者是这个集合：

clear  可变集合

clear(...) method of builtins.set instance

Remove all elements from this set.

把集合里的数据对象都删除掉

pop

pop(...) method of builtins.set instance

    Remove and return an arbitrary set element.

Raises KeyError if the set is empty.

从集合中删除并且返回一个任意元素

并且当集合是空的时候pop是会出一个KeyError的错误  集合是无序的

remove

remove(...) method of builtins.set instance

    Remove an element from a set; it must be a member

If the element is not a member, raise a KeyError.

#从集合中删除对象，必须是一个成员

#如果我们没有这个成员   会引发一个KeyError

discard

    discard(...) method of builtins.set instance

    Remove an element from a set if it is a member.

If the element is not a member, do nothing.

#删除一个数据对象，如果他是集合的成员

#如果说你这里没有这个成员，不会报错，什么都不做

not

in

使用in和not是效率很高的，因为凡是对hash表进行查找工作，要比普通序列查找要效率快的

 

--------------

字典和集合

1：无序

2：字典key唯一，集合中值唯一

3：字典做key值的这个数据必须是不可变的。必须是一个可hash的，集合里的可以是任意数据类型吗？

>>> myset = {1,1.5,True,[1,2,3,4],(1,2,3,4)}

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

TypeError: unhashable type: 'list'

集合里的数据类型必须是不可变的可hash的值

keys()

values()

items()

update()

pop()

remove()

del

clear()

集合：

交并补

联合：（|）（union()）

a | b a.union(b)   在a集合中和b集合去重数据元素，剩下的组合到一起返回一个新的集合

交集：（&）（intersection）

a &b  a.intersection(b)    在a集合和b集合中，共同含有的集合成员组成到一起返回一个新的集合

差补：（-）（difference）

a - b  a.difference(b)      在a集合中，去掉所有与b集合中相同的元素，只在a中保留b中没有的集合成员

对称差分：（^） (symmetric_difference)

找出两个集合中，只属于集合a或集合b的元素

input() 接受用户输入的

split() 分割字符串的

strip() 去掉隐藏字符

不会用的函数可以百度，逻辑不要百度

#阶段考核：

#功能1：

#可以实现多位数字混合四则运算 + - * /

# 2 + 11 - 23 * 17 / 32  和真正的计算器得出的结果一致

#并且是一行

不允许使用一切 eval 等直接实现的函数