python基础之一_集合数据类型

python集合数据类型包括：列表list、字典dict、集合set、枚举enumerate

一 列表

1.1 列表生成式：创建list

ls=[i for i in range(10)]
for i in ls:
    print(i)

ls2=[ for i in range(0,10,2) if i!=2]
for i in ls2:
    print(i)

输出1：
0
1
2
3
4
5
6
7
8
9
输出2：
0
16
36
64

注意：
range(start=0,end,[step])，若只有一个参数时则start为默认值0、该参数为end；若有两个参数，则第一个表示start、第二个为end；若想表示step，必须使用三个参数。不存在有两个参数，start为默认值0，第一个参数为end，第二个参数为step的情况。

1.2 列表切片：访问list

https://www.cnblogs.com/wang-mengmeng/p/11662518.html

语法：List[start:stop:step]
1.切片区间[start,strop)，左闭右开；start默认值为0，stop默认值为list长度；
2.start、stop值为正数表示正向索引，为负数表示逆向索引；正向第一个元素索引为0，逆向第一个元素索引为-1；
3.切片步长step，默认值为1；step负数表示从后往前切片；

ls=[0,1,2,3,4,5,6,7] # 索引：0~7 或 -1~-8
# 输出一
print(ls[:])
print(ls[::])
print(ls[::-1])
# 输出二
print(ls[3:7:-1])
print(ls[7:3:-1])
print(ls[-1:-5:-1])
# 输出三
print(ls[3:7])
print(ls[7:3])
print(ls[-5:-1])


输出一：
[0, 1, 2, 3, 4, 5, 6, 7]
[0, 1, 2, 3, 4, 5, 6, 7]
[7, 6, 5, 4, 3, 2, 1, 0]

输出二：
[]
[7, 6, 5, 4]
[7, 6, 5, 4]

输出三：
[3, 4, 5, 6]
[]
[3, 4, 5, 6]

结果分析：
1.由输出一可知：步长可省略，默认值为1；步长为负数时，从后往前进行切片；
2.由输出二和输出三可知：步长为正从前往后进行切片时，切片范围必须也是从前往后的，否则返回空列表；同理，步长为负从后往前切片时，切片范围必须是从后往前的。
3.由输出二和输出三可知：元素正向索引+元素逆向索引的绝对值=列表长度，如：列表长度为8，ls[5]和ls[-3]为同一个元素5.

1.3 列表排序

https://www.cnblogs.com/harrymore/p/9460532.html

python中有内建函数sorted()、列表类的内建方法list.sort()用于排序；
二者的区别：
1.内建函数不改变原对象，内建方法改变原对象；
2.sorted()可用于任意可迭代对象排序，list.sort()只是列表排序。

简单排序：

ls=['1','3','2']

print(sorted(ls))
print(ls)

print(ls.sort())
print(ls)

test={'b':1,'a':2}
print(sorted(test))

输出一：
['1', '2', '3']
['1', '3', '2']

输出二：
None
['1', '2', '3']

输出三：
['a', 'b']

结果分析：
1.由输出一和输出二可知：sorted函数不改变原对象，返回新的对象；list.sort()改变原对象，返回None；
2.由输出三可知：sorted()可以对其他可迭代对象排序，字典排序返回的是key的列表；

自定义 排序：
python 2.X中使用cmp函数参数自定义比较方式，python3中使用key函数代替cmp函数。
二者区别：cmp函数和C++中一样，接收两个值作为输入，返回1或-1用于排序；key函数接收可迭代对象的元素作为输入，返回元素中要用于排序的键。

test=[('a',1),('b',0)]
print(sorted(test,key=lambda x_y:x_y[1]))

test2={'a':1,'b':0}
print(sorted(test2,key=lambda x_y:x_y[1]))

test3={'a_1':1,'b_0':0}
print(sorted(test3,key=lambda x_y:x_y[2]))

输出一：
[('b', 0), ('a', 1)]

输出二：
IndexError: string index out of range

输出三：
['b_0', 'a_1']

结果分析：
1.由输出一可知：key函数可用lambda表达式；
2.由输出二可知：字典在sorted()排序时传入的只有一个参数，key；
3.由输出三可知：key函数的返回值并不要求是元素中的键，只要是可比较对象即可；

1.4 列表查找：查找list

https://www.icode9.com/content-1-637740.html

1.返回第一个目标值的索引：使用index方法
2.返回所有目标值的索引：遍历整个list【感觉上有点蠢，但没看到其他算法】

ls1=[1,2,3,4,1]

print(ls1.index(1))

ls2=[i for i in range(len(ls1)) if ls1[i]==1]
print(ls3)

ls3=[i for i,val in enumerate(ls1) if val==1]
print(ls2)

输出一：
0
输出二：
[0, 4]
输出三：
[0, 4]

结果分析：
1.由输出一可知，index只能查找一个；
2.输出二和三都是遍历全部后得到索引；输出三的enumerate是由可迭代对象返回包含索引的枚举对象。

1.5 列表拼接：修改list

https://www.cnblogs.com/lifangzheng/p/11379172.html

三种方法： 直接用’+'运算；切片赋值；extend方法

ls1=[1,2]
ls2=[3,4]
ls3=[5,6]

print(ls1+ls2)

ls1[2:5]=ls2
print(ls1)

ls2.extend(ls3)
print(ls2)

输出一：
[1, 2, 3, 4]
输出二：
[1, 2, 3, 4]
输出三：
[3, 4, 5, 6]

结果分析：
1.由输出一可知，’+'运算返回的是一个新的list；
2.由输出二可知，切片赋值改变的是原list；而且看来数组越界只会发生在读取list的时候，赋值的时候不会报错越界；
3.由输出三可知，extend改变的是原list。

备注：
'+'运算为python的内建函数，list.extend()为list类的内建方法；内建函数不改变原对象，内建方法改变原对象。

补充： extend和append的区别
extend是遍历list的元素，加到另一个list中；注意：不会递归遍历
append是直接将list作为一个元素，加到另一个list中；

ls1=[1,2]
ls2=[[3],[4]]
ls1.extend(ls2)
print(ls1)

输出：
[1, 2, [3], [4]]
结果分析：
可见，extend不会递归执行

ls1=[1,2]
ls2=[[3],[4]]
ls1.append(ls2)
print(ls1)
输出：
[1, 2, [[3], [4]]]
结果分析：
可见，append是直接将参数作为元素加入原list

1.6 列表翻转

三种方式：List类的内建方法list.reverse()、内建函数reversed()、列表倒序切片；
区别：
内建函数不改变原对象，返回反转迭代器list_reverseiterator，可再转为List对象；切片不改变原对象，返回List对象；List类的内建方法改变原对象，返回None；

ls=[1,2,3]
# 测试一
print(reversed(ls))
for i in reversed(ls):
    print(i)
print(list(reversed(ls)))
# 测试二
print(ls[::-1])
# 测试三
print(ls.reverse())
print(ls)

输出一：
<list_reverseiterator object at 0x0151FFD0>
3
2
1
[3, 2, 1]
输出二：
[3, 2, 1]
输出三：
None
[3, 2, 1]

结果分析：
1.由输出一可知：list_reverseiterator可直接迭代访问；

1.7 列表删除元素

list.pop(index)
pop是可以指定删除元素的索引的，并不是只能删除最后一个；只不过默认是删除最后一个

二 字典

2.1 字典生成式

https://blog.youkuaiyun.com/qq_41891803/article/details/81515739

test={key:ord(key) for key in ['a','b','c']}
print(test)

输出：
{'a': 97, 'b': 98, 'c': 99}

注意：
dict和set的定义都是使用{}；dict元素为键值对，set元素为单个值；注意与下面的集合生成式区分。

2.2 字典遍历

包括遍历键、遍历值、遍历 键值对，三种情况：

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

# 遍历键
for key in test:
    print(key)

for key in test.keys():
    print(key)

# 遍历值
for val in test.values():
    print(val)

# 遍历键值对
for key_val in test.items():
    print(key_val)

for key,val in test.items():
    print(f'{key}:{val}')


输出一：--------------------------------------------
a
b
c
输出二：--------------------------------------------
a
b
c
输出三：--------------------------------------------
1
2
3
输出四：--------------------------------------------
('a', 1)
('b', 2)
('c', 3)
输出五：--------------------------------------------
a:1
b:2
c:3

结果分析：
1.由输出1和输出2可知：直接遍历就是遍历键；
2.由输出4和输出5可知：items返回的迭代器，元素是元组类型；而输出5是对输出4的解包。

三 集合

3.1 集合生成式

test={(key,ord(key)) for key in ['a','b','c']}
print(test)

输出：
{('b', 98), ('c', 99), ('a', 97)}

四 枚举对象

https://www.runoob.com/python/python-func-enumerate.html

内建函数enumerate()返回可迭代对象元素及其索引组成的枚举对象

ls=[1,2]
print(list(enumerate(ls)))
dict1={'a':1,'b':2}
print(list(enumerate(dict1)))

输出一：
[(0, 1), (1, 2)]
输出二：
[(0, 'a'), (1, 'b')]