python数据类型

1，python字典和json的区别

• 字典是一种数据结构，json是一种数据的表现形式，字典的key值只要是能hash的就行，json的必须是字符串

2，什么是可变、不可变类型

• 可变不可变指的是内存中值是否可以被改变
• 不可变类型指的是对象所在的内存区域里面的值不可以改变，有数值、字符串、元组；
• 可变类型是可以改变值，只要有列表、字典

3，复杂元素排序

from operator import attrgetter, itemgetter


class Student(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def __repr__(self):
        return repr((self.name, self.age))

stu1 = Student('tom', 20)
stu2 = Student('rose', 18)
stu3 = Student('jack', 22)
# 列表元素是实例对象
list1 = [stu1, stu2, stu3]
# 按照对象里面的属性值排序
list1.sort(key=attrgetter('age'))
print(list1)

# 列表中的字典元素排序
list2 = [{'name':'a', 'age':18},
        {'name':'b', 'age':20},
        {'name':'c', 'age':12},]

list2 = sorted(list2,key=itemgetter('age'))
print(list2)
# output：
[('rose', 18), ('tom', 20), ('jack', 22)]
[{'name': 'c', 'age': 12}, {'name': 'a', 'age': 18}, {'name': 'b', 'age': 20}]

4，使用list列表实现栈和队列

• 1.栈(stacks)是一种只能通过访问其一端来实现数据存储与检索的线性数据结构，具有后进先出(last in first out，LIFO)的特征

• 2.队列(queue)是一种具有先进先出特征的线性数据结构，元素的增加只能在一端进行，元素的删除只能在另一端进行。能够增加元素的队列一端称为队尾，可以删除元素的队列一端则称为队首。

class Stacks(object):
    '''栈添加删除实现'''
    def __init__(self):
        self.data = []

    def push(self, val):
        self.data.append(val)

    def pop(self):
        # 如果栈内不为空，删除最后一位元素
        if len(self.data):
            return self.data.pop()
        else:
            return None

class Queue(object):
    '''队列的添加删除实现'''
    def __init__(self):
        self.data = []

    def is_empty(self):
        return len(self.data)  == 0

    def push(self, val):
        self.data.append(val)

    def pop(self):
        # 删除之前现在判断，队列是否为空
        # pop(0)用索引删除若队列为空会报错
        if self.is_empty():
            return None
        # 从前往后删除
        return self.data.pop(0)

# 栈
print('栈')
stacks = Stacks()
stacks.push(1)
stacks.push(2)
stacks.push(3)
print(stacks.data)
stacks.pop()
print(stacks.data)

# 队列
print('队列')
queue = Queue()
queue.push(1)
queue.push(2)
queue.push(3)
print(queue.data)
queue.pop()
print(queue.data)

# output
栈
[1, 2, 3]
[1, 2]
队列
[1, 2, 3]
[2, 3]

5，给定两个listA、B，找出A、B中相同元素，以及不同元素

• set集合处理
  
  • A、B中相同元素：set(A)&set(B)
  • A、B中不同元素：set(A)^set(B)

6，列举列表、字符串和字典的常用方法

• list.append()、insert(index)、list.extend(list1)
• list.pop(index)
• list.index(item)
• list.find(item)
• str.find(“ab”) # 找不到返回-1
• str.index(“ab”) # 找不到报错

7，对一下list，按照字典的值进行排序

list1 = [{"a": 3},{"b": 2},{"c": 1}]

• 思路：将列表中的字典放入一个大的字典中，对大字典的items()进行排序，将结果再转为列表

from operator import itemgetter

list1 = [{"a": 12},
         {"b": 18},
         {"c": 6}]


dict1 = {key: value for x in list1 for key, value in x.items()}
# dict1.items() 取出字典中的key,value，组成元组，用元组第二个元素排序
# 结果是列表中元组排序
list2 = sorted(dict1.items(), key=itemgetter(1))
print(list2)
# 在将列表中的元组重新组合成字典
list3 = [{x[0]: x[1]} for x in list2]
print(list3)

# output
[('c', 6), ('a', 12), ('b', 18)]
[{'c': 6}, {'a': 12}, {'b': 18}]

8，二维数组转为一维数组

• 列表推导式双层for循环，
• 第一次遍历外出列表，遍历出内部列表
• 第二次遍历内部列表，遍历内部列表的每一个元素

list1 = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
list2 = [y for x in list1 for y in x]
print(list2)
# output
[1, 2, 3, 4, 5, 6, 7, 8, 9]

9，生成如下一个二维数组

[[1, 2, 3], [2, 4, 6], [3, 6, 9]]

matrix = [[i * j for i in range(1, 4)] for j in range(1, 4)]
print(matrix)