实现类似 { key1: [{}, {}], key2: [{}, {}] }的嵌套
import hashlib
'''md5加密'''
def Md5encode(param):
MD5str = hashlib.md5()
MD5str.update(str(param).encode(encoding='utf-8'))
MD5res = MD5str.hexdigest()
return MD5res
obj = {}
for i in range(100,200):
i_Md5 = Md5encode(i)
pre = i_Md5[0:2]
temp = {"id": str(i), "i_Md5": i_Md5}
if obj == {}:
obj = {pre:[temp]}
else:
if pre in obj.keys():
obj[pre].append(temp)
else:
obj.update({pre: [temp]})
print(obj)
菜鸟教程：https://www.runoob.com/python3/python3-list.html
1、 列表
列表索引从0开始
list1 = ['a', 'b', 'a',1, 2];
list2 = [1, 2, 3, 4, 5 ];
list3 = ["a", "b", "c", "d"];
列表运算
以列表list1为例
| 操作符 |
表示 |
| del list1[2] |
删除列表中某一个元素 |
| list1 + list2 |
列表合并 |
| list1 * 2 |
列表元素重复2次组成新的列表 |
| list1[-1] |
从右边取列表的第一个元素 |
| [list1,list2] |
列表嵌套，相当于一个二维数组 |
| 函数 |
表示 |
| len(list1) |
列表长度 |
| max(list1) |
取列表的最大元素 |
| min(list1) |
取列表的最小元素 |
| list(元组) |
将元组转化为list列表 |
| list方法 |
表示 |
| list1.append(list2) |
在列表末尾添加新的对象 |
| list1.count('a') |
统计某个元素在列表中出现的次数 |
| list1.clear() |
清空列表 |
| list1.copy() |
列表复制 |
| list1.reverse() |
用于反向列表中元素，没有返回值，但是会对列表的元素进行反向排序。 |
| list1.sort( key=None, reverse=False) |
reverse = True 降序， reverse = False 升序（默认）key ，主要是用来进行比较的元素，只有一个参数 |
| list1.remove('a') |
用于移除列表中某个值的第一个匹配项 |
| list1.insert(index, obj) |
用于将指定对象插入列表的指定位置，index位置索引。 |
| list1.pop(index) |
用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。index为位置索引值 |
| list1.extend(seq) |
在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表），seq可以为列表、元组、集合、字典，若为字典，则仅会将键(key)作为元素依次添加至原列表的末尾 |
| list1.index(obj) |
用于从列表中找出某个值第一个匹配项的索引位置，查找的对象。 |
str = ['qb','abc','abkd','akakal','a']
print(str) # ['qb', 'abc', 'abkd', 'akakal', 'a']
b = sorted(str, key=lambda x: len(x), reverse=True)
print(b) # ['akakal', 'abkd', 'abc', 'qb', 'a'] 降序
c = sorted(str, key=lambda x: len(x), reverse=False)
print(c) # ['a', 'qb', 'abc', 'abkd', 'akakal'] 升序
str.sort(key=len)
print(str) # ['a', 'qb', 'abc', 'abkd', 'akakal'] 升序
str.sort(key=len,reverse=True)
print(str) # ['akakal', 'abkd', 'abc', 'qb', 'a'] 降序
list2 = [1,2,9,3,5,4]
list2.sort()
print(list2) # [1, 2, 3, 4, 5, 9]
dic = {"name": 20, "age": 18, "city": 31, "lel": "1362626627"}
# 按key 排序
lis = sorted(dic.items(),key=lambda i:i[0],reverse=False)
print(dict(lis)) # {'age': 18, 'city': 31, 'lel': '1362626627', 'name': 20}
2、 元组
tuple1 = (1,2,3,4)
- Python 的元组与列表类似，不同之处在于元组的元素不能修改。
- 元组使用小括号()，列表使用方括号[]。
- 元组只需在括号中添加元素，并使用逗号隔开即可。
- 元组中只包含一个元素时，需要加逗号
- 元组下标从0开始
元组运算符
| 运算符 |
表示 |
| + |
元组合并 |
| * |
元组复制 |
| x in (1,2,3) |
元素是否存在在元组中，返回true或false |
| for x in (1,2,3)： |
迭代 |
元组内置函数
| 函数 |
表示 |
| len(tuple1) |
元组元素个数 |
| max(tuple1) |
返回元组中元素最大值 |
| min(tuple1) |
返回元组中元素最小值 |
| tuple(seq) |
将列表转化成元组，seq为列表 |
3、 字典
dict = {'key1': 'value1', 'key2': 'value2', 'key3': 'value2'}
- 键必须是唯一的，可以用数字，字符串或元组充当，而用列表就不行
- 同一个键出现两次,最后出现的会更新前一个的值
| 函数&方法 |
表示 |
| len(dict) |
字典元素个数 |
| str(dict) |
以可打印的字符串表示 |
| type(dict) |
返回变量类型 |
| dict.clear() |
函数用于删除字典内所有元素, 无返回值 |
| dict.copy() |
返回一个字典的浅复制 |
| dict.fromkeys(seq, value) |
用于创建一个新字典，以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值 |
| dict.get(key, default=None) |
get() 函数返回指定键的值，如果值不在字典中返回默认值。 |
| key in dict |
字典 in 操作符用于判断键是否存在于字典中，如果键在字典 dict 里返回 true，否则返回 false。 not in 操作符刚好相反 |
| dict.items() |
items() 方法以列表返回可遍历的(键, 值) 元组数组。 |
| dict.keys() |
字典 keys() 方法返回一个可迭代对象，可以使用 list(dict.keys()) 来转换为列表。Python2.x 是直接返回列表 |
| dict.update(dict2) |
字典 update() 函数把字典参数 dict2 的 key/value(键/值) 对更新到字典 dict 里。 |
| dict.setdefault(key, default=None) |
字典 setdefault() 方法和 get()方法 类似, 如果键不存在于字典中，将会添加键并将值设为默认值。 |
| dict.values() |
字典 values() 方法返回一个迭代器，可以使用 list(dict.values()) 来转换为列表，列表为字典中的所有值。 |
| dict.pop(key) |
pop() 方法删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。 |
obj1 = {"key1":"hhh","key2":10}
obj2 = {"key2": 2, "key4": "ccc"}
obj1.update(obj2)
print(obj1) # {'key1': 'hhh', 'key2': 2, 'key4': 'ccc'}
obj1 = {"key1":"hhh","key2":10}
obj2 = {"key2": 2, "key4": "ccc"}
final_obj = dict(obj1, **obj2)
print(final_obj) # {'key1': 'hhh', 'key2': 2, 'key4': 'ccc'}
obj1 = {"key1":"hhh","key2":10}
obj2 = {"key2": 2, "key4": "ccc"}
res = {**obj1, **obj2}
print(res) # {'key1': 'hhh', 'key2': 2, 'key4': 'ccc'}
4、 集合
- 集合（set）是一个无序的不重复元素序列。
- 可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
| 方法 |
表示 |
| set.add(elmnt) |
用于给集合添加元素，如果添加的元素在集合中已存在，则不执行任何操作。 |
| set.clear() |
用于移除集合中的所有元素,无返回值 |
| set.copy() |
用于拷贝一个集合 |
| set1.difference(set2) |
用于返回集合的差集，即返回的集合元素包含在第一个集合中，但不包含在第二个集合(方法的参数)中 |
| set1.difference_update(set2) |
用于移除两个集合中都存在的元素。difference_update() 方法与 difference() 方法的区别在于 difference() 方法返回一个移除相同元素的新集合，而 difference_update() 方法是直接在原来的集合中移除元素，没有返回值。 |
| set1.isdisjoint(set2) |
用于判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。 |
| set1.issubset(set2) |
用于判断集合的所有元素是否都包含在指定集合中，如果是则返回True，否则返回 False。 |
| set.issuperset(set) |
用于判断指定集合的所有元素是否都包含在原始的集合中，如果是则返回 True，否则返回 False。 |
| set.union(set1, set2...) |
返回两个集合的并集，即包含了所有集合的元素，重复的元素只会出现一次。 |
| set.update(set) |
用于修改当前集合，可以添加新的元素或集合到当前集合中，如果添加的元素在集合中已存在，则该元素只会出现一次，重复的会忽略。 |
| set.pop() |
用于随机移除一个元素 |
| set.remove(item) |
用于移除集合中的指定元素，该方法不同于 discard() 方法，因为 remove() 方法在移除一个不存在的元素时会发生错误，而 discard() 方法不会。 |
| set.discard(value) |
用于移除指定的集合元素。 |
| set.intersection(set1, set2 ... etc) |
返回两个或更多集合中都包含的元素，即交集 |
| set.intersection_update(set1, set2 ... etc) |
用于获取两个或更多集合中都重叠的元素，即计算交集。 intersection_update() 方法不同于 intersection() 方法，因为 intersection() 方法是返回一个新的集合，而 intersection_update() 方法是在原始的集合上移除不重叠的元素。 |
a = [1,2,4,5]
b = [4,5,6,7]
c = [i for i in a if i in b]
print(c) # [4,5]
d = list(set(a).intersection(set(b)))
print(d) # [4,5]
e = list(set(a).union(set(b)))
print(e) # [1,2,4,5,6,7]
f = list(set(a).difference(set(b)))
print(f) # [1,2]
g = list(set(b).difference(set(a)))
print(g) # [6,7]
