无标题的心情说说(无标题什么意思)

Python（二） 前言一、序列

序列的一些函数 二、字典

1.定义2.增删改查3.其他一些函数4.字典的嵌套及推导式 三、集合

1.创建2.内置函数3.不可变集合4.可哈希

提示：这里可以添加本文要记录的大概内容：

python第二部分知识介绍

可变序列列表、字典
不可变序列元组、字符串
加法和乘法可以用于序列
对于可变序列，对序列进行拼接和增量赋值的时候唯一标识的整数值（id）不会变，但是对于不可变序列，id会改变

>>> s = [1,2,3]
>>> id(s)
1508583974720
>>> s *= 2
>>> s
[1, 2, 3, 1, 2, 3]
>>> id(s)
1508583974720
>>> t = (1,2,3)
>>> id(t)
1508584193728
>>> t *= 2
>>> id(t)
1508584436256

python提供is 和not is 检测对象的id是否相等，然后判断是否是同一个对象。
in 和 not in判断包含问题
del可以删除序列，也可以删除可变序列的某个元素，切片操作也可以完成这种操作
除此之外，del可以跳着清空元素

>>> x = [1,2,3,4,5]
>>> del x[1:4]
>>> x
[1, 5]
>>> y = [1,2,3,4,5]
>>> y[1:4] = []
>>> y
[1, 5]
>>> y = [1,2,3,4,5]
>>> del y[::2]
>>> y
[2, 4]

列表、元组、字符串相互转换list(),tuple(),str()
min()返回最小值，max()返回最大值
len()计算长度，sun()求和
sorted()排序，返回全新列表，原列表不会改变reversed()翻转
sorted()可以传入一个key参数，根据ket进行排序

>>> s = ["Apple","Banana","Canada","Fish","Pen"]
>>> sorted(s)
['Apple', 'Banana', 'Canada', 'Fish', 'Pen']
>>> sorted(s, key=len)
['Pen', 'Fish', 'Apple', 'Banana', 'Canada']

all() 函数和any()函数
all()判断是否可迭代对象中所有元素都为真
any()元素判断是否有一个元素为真
enumerate()函数用于返回已给枚举对象，他的功能是将可迭代对象中的每个元素及从0开始的序号共同构成一个二元组的列表，可以指定开始值

>>> seasons = ["Spring","Summer","Fall","Winter"]
>>> enumerate(seasons)

>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons,10))
[(10, 'Spring'), (11, 'Summer'), (12, 'Fall'), (13, 'Winter')]

zip()函数用于创建一个聚合多个可迭代对象的迭代器。它会将作为参数传入发每个可迭代对象的每个元素依次组合成为元组，即第i个元组包含来自每个参数的第i个元素。如果参数的长度不同，会取最短的长度
如果不想丢弃，可以使用itertools的zip_longest()函数，此处不再介绍-

>>> x = [1,2,3]
>>> y = [4,5,6]
>>> z= zip(x,y)
>>> list(z)
[(1, 4), (2, 5), (3, 6)]
>>> p = [7,8,9]
>>> z = zip(x,y,p)
>>> list(z)
[(1, 4, 7), (2, 5, 8), (3, 6, 9)]
>>> p = "happy"
>>> z = zip(x,y,p)
>>> list(z)
[(1, 4, 'h'), (2, 5, 'a'), (3, 6, 'p')]

map()会根据提供的函数对指定的可迭代对象的每个元素进行运算，并将返回运算结果的迭代器。

>>> c = map(ord,"Fishc")
>>> list(c)
[70, 105, 115, 104, 99]
>>> c = map(pow,[1,2,3],[4,5,6])
>>> list(c)
[1, 32, 729]

fliter()函数会根据提供的函数对指定的可迭代对象的每个元素进行运算，并将运算结果为真的元素，以迭代器的形式返回。

>>> list(filter(str.islower,"Fishc"))
['i', 's', 'h', 'c']

迭代器和可迭代对象
迭代器是可迭代对象
可迭代对象可以重复使用
迭代器是一次性的
iter()可以把可迭代对象变为迭代器，next可以每次从迭代器中拿出一个元素

>>> x = [1,2,3,4,5]
>>> y = iter(x)
>>> type(x)

>>> type(y)

>>> next(y)
1
>>> next(y)
2
>>> next(y)
3
>>> next(y)
4
>>> next(y)
5
>>> next(y)
Traceback (most recent call last):
  File "", line 1, in 
    next(y)
StopIteration

如果不想抛出异常，可以在next后面加一个参数next(y,“没有啦”)
当迭代器中没有元素的时候，他就会输出“没有啦”

字典是映射关系，key和value一一对应
通过指定一个key可以创建字典的一个值
使用dict函数创建字典
使用列表作为参数
zip函数也可以创建dict

>>> a = {"one":"1","two":"2","three":"3"}
>>> b= dict(one = "1", two = "2", three="3")
>>> c = dict([("one","1"),("two","2"),("three","3")])
>>> d = dict(zip(["one","two","three"],["1","2","3"]))
>>> a == b == c ==d
True

增
fromkeys()方法可以创建一个新字典

>>> d = dict.fromkeys("fishc",70)
>>> d
{'f': 70, 'i': 70, 's': 70, 'h': 70, 'c': 70}
>>> d['f']=1
>>> d
{'f': 1, 'i': 70, 's': 70, 'h': 70, 'c': 70}
>>> d['g']=6
>>> d
{'f': 1, 'i': 70, 's': 70, 'h': 70, 'c': 70, 'g': 6}

序列中元素可以重复，但是字典key不会重复

删
pop(key)可以删除对应的key和value
popitem()在python3.7之后是删除最后一个加入字典键值对
del 也可以删除指定的关键字也可以删除整个字典
只想清除字典的内容，可以用clear，字典会变成空字典

  {'f': 1, 'i': 70, 's': 70, 'h': 70, 'c': 70, 'g': 6}
>>> d.pop('f')
1
>>> d
{'i': 70, 's': 70, 'h': 70, 'c': 70, 'g': 6}
>>> d.popitem()
('g', 6)
>>> d
{'i': 70, 's': 70, 'h': 70, 'c': 70}
>>> del d['i']
>>> d
{'s': 70, 'h': 70, 'c': 70}
>>> del d
>>> d
Traceback (most recent call last):
  File "", line 1, in 
    d
NameError: name 'd' is not defined

改
update()可以直接传入一个键值对，也可以传入包含键值对的可迭代对象

>>> d = dict.fromkeys("fishc",70)
>>> d.update({'i':105,'s':110})
>>> d
{'f': 70, 'i': 105, 's': 110, 'h': 70, 'c': 70}
>>> d.update(f = 60,c=66)
>>> d
{'f': 60, 'i': 105, 's': 110, 'h': 70, 'c': 66}

查
可以直接查找，也可以使用get函数，setdefault（）查找一个key，要是没有直接创建

>>> d
{'f': 60, 'i': 105, 's': 110, 'h': 70, 'c': 66}
>>> d.get('c',"没有啦")
66
>>> d.get('C',"没有啦")
'没有啦'
>>> d.setdefault('c','code')
66
>>> d.setdefault('C','code')
'code'
>>> d
{'f': 60, 'i': 105, 's': 110, 'h': 70, 'c': 66, 'C': 'code'}

items(),keys(),values()
上面三个函数的结果会跟随字典的值动态变化

>>> keys = d.keys()
>>> values = d.values()
>>> items = d.items()
>>> keys
dict_keys(['f', 'i', 's', 'h', 'c', 'C'])
>>> values
dict_values([60, 105, 110, 70, 66, 'code'])
>>> items
dict_items([('f', 60), ('i', 105), ('s', 110), ('h', 70), ('c', 66), ('C', 'code')])
>>> d.pop('C')
'code'
>>> keys
dict_keys(['f', 'i', 's', 'h', 'c'])
>>> values
dict_values([60, 105, 110, 70, 66])
>>> items
dict_items([('f', 60), ('i', 105), ('s', 110), ('h', 70), ('c', 66)]

字典也提供copy()函数实现对字典浅拷贝

list可以把字典的key或者value变为列表
iter也可以应用在字典上
reversed可以对字典内部的键值对进行逆向操作

>>> list(d)
['f', 'i', 's', 'h', 'c']
>>> list(d.values())
[60, 105, 110, 70, 66]
>>> e = iter(d)
>>> next(e)
'f'
>>> next(e)
'i'
>>> next(e)
's'
>>> next(e)
'h'
>>> next(e)
'c'
>>> next(e)
Traceback (most recent call last):
  File "", line 1, in 
    next(e)
StopIteration

字典可以嵌套字典，也可以嵌套列表

>>> d = {"A":{"语文":70,"数学":80},"B":{"语文":90,"数学":90}}
>>> d['A']['语文']
70
>>> d = {"A":[70,80],"B":[90,90]}
>>> d['A'][0]
70

推导式也可以加入筛选条件
没有元组推导式，生成的最后是一个生成器
如果想要把两个列表生成字典，必须使用zip函数或者range函数对列表进行迭代，不然会出现意想不到的效果。

>>> d = {'f': 60, 'i': 105, 's': 110, 'h': 70, 'c': 66, 'C': 'code'}
>>>> b = {v:k for k,v in d.items()}
>>> b
{60: 'f', 105: 'i', 110: 's', 70: 'h', 66: 'c', 'code': 'C'}
>>> [(x,y) for x in [1,2,3] for y in [4,5,6]]
[(1, 4), (1, 5), (1, 6), (2, 4), (2, 5), (2, 6), (3, 4), (3, 5), (3, 6)]
>>> {x:y for x in [1,2,3] for y in [4,5,6]}
{1: 6, 2: 6, 3: 6}

三种方法
花括号、集合推导式、类型构造器

>>> {"FishC","Python"}
{'Python', 'FishC'}
>>> { s for s in "FishC"}
{'h', 's', 'C', 'F', '
>>> set("FishC")
{'h', 's', 'C', 'F', 'i'}

不可以使用下标的方式访问集合中的元素
但是可以判断集合中是不是存在这个元素
可以使用迭代的方法访问集合中的元素
最重要的是：集合中的元素是无序且唯一的

copy()函数可以实现集合的浅拷贝
isdisjoint()可以判断两个集合是不是毫不相干
issubset()可以判断某个集合是不是另一个集合的子集
issuperset()可以判断某个集合是不是另一个集合的超集

>>> s = set("FishC")
>>> s.isdisjoint(set(":Python"))
False
>>> s.issubset(set("Fish.com"))
False
>>> s.issubset(set("FishC.com"))
True

除此之外，python还提供多个集合的交集，并集，差集的函数
使用<,<=可以判断是否是真子集和子集
使用>,>=可以判断是否是真超集和超集
并集用| 交集用& 差集用- 对称差集是^

frozenset()是不可变集合

>>> t = frozenset("FishC")
>>> t
frozenset({'h', 's', 'C', 'F', 'i'})

使用update对set进行更新
add可以将整个字符串加入集合中
remove()删除元素，元素不存在，报错
discard()删除元素，元素不存在静默处理

>>> s = set("FishC")
>>> s.update([1,1],"23")
>>> s
{1, 'h', 's', '3', 'C', 'F', 'i', '2'}
>>> s.add("45")
>>> s
{1, 'h', '45', 's', '3', 'C', 'F', 'i', '2'}
>>> s.remove(1)
>>> s
{'h', '45', 's', '3', 'C', 'F', 'i', '2'}
>>> s.remove(1)
Traceback (most recent call last):
  File "", line 1, in 
    s.remove(1)
KeyError: 1
>>> s.discard(1)

python大多数不可变类型都是可哈希的，可变对象都是不可哈希的
只有可哈希的对象才有资格作为字典的键和集合的元素
想要实现集合的嵌套可以借用frozenset