从零开始的Python ACM Ch.1：数据类型及基本数据处理

1442 字

7 分钟

从零开始的Python ACM Ch.1：数据类型及基本数据处理

2022-10-15

Coding

/

Python

/

datatype

基本数据类型#

可迭代数据类型#

通用操作：

遍历
max
min
sum
len
成员测试 in、not in

序列数据类型#

通用操作：

索引
切片
index
count
同类型加法拼接
整数乘法重复

字符串#

不可变数据类型（对字符串的所有修改操作，都是返回一个新的字符串）

特有操作：

s.upper()
s.lower()
s.replace(sub1, sub2)
s.join(Iterable[str])
s.format()
s.split(c)

元组#

不可变数据类型，基本是拿来用索引，或者切片

列表#

可变数据类型

特有操作：

通过索引进行修改
通过切片进行修改
ls.append(x)
del ls[i] i为元素索引
ls.remove(x) x为元素值
ls.extend(lt2)
ls.insert(i, x)
ls.reverse()
ls.clear()
列表表达式

集合 & 字典#

集合中的元素、字典的键都必须为不可变数据类型，不能重复

如果直接对字典进行for循环的遍历，那么出来的是字典的键

集合的特有方法：

s.pop() 弹出集合s中的一个元素
s.add(x) 将x添加到集合s中
s.remove(x) 删除集合s中的元素x，x不存在则出错
s.discard(x) 删除集合s中的元素x，x不存在不出错
s.update(t) 将集合t合并到集合s中
s.clear() 清空集合s
s-t 差集
s&t 交集
s|t 并集
s^t 并集减去交集
s.isdisjoint(t) 判断是否相交比较操作判断包含关系

字典的特有方法：

通过键进行索引
d.keys() 所有键的迭代器
d.values() 所有值的迭代器
d.items() 所有键值对的迭代器
d.get(key, default) 如果key存在，返回d[key]，否则返回default
d.pop(key, default) 返回 d.get(key, default) 并不出错的删除key
d.popitem()
d.update(d2)

列表表达式#

一般我们使用的列表长这样

1
ls = [123,456,789,0]

但是Python里面有个东西叫做列表表达式，例如

1
ls1 = [i for i in range(0,100)]

这会生成一个带有0-99的int数据类型的列表，非常简洁

列表的排序#

一般来说，你自己在Python里面写的对列表进行排序的函数，都不如内置的list().sort(*, key=key, reverse=False)要快，谁让人家是C语言写的排序呢……

但是list().sort()有个坑，我前两天帮人数学建模的时候还是踩进了这个坑，就是：这个方法是直接作用于列表本身，没有返回值的，所以进行赋值的时候就会变成none

例题1#

下面的列表a是人物的名字，b是他们对应的年龄，请输出18岁以下的人物并根据他们的年龄进行升序排列

1
a = ['tom', 'iron man','jerry', 'donald', 'micky', 'spider man']
2
b = [3, 32, 1, 8, 2, 19]

我的做法是用多一个列表，往里面用元组的形式填他们的名字以及年龄信息

1
ls = []
2

3
for i in a:
4
    pos = a.index(i)
5
    age = b[pos]
6
    if age < 18:
7
        ls.append((i,age))

对ls进行打印，得出这样的一个列表

1
[('tom', 3), ('jerry', 1), ('donald', 8), ('micky', 2)]

再通过sort函数和lambda表达式进行排序，对所需要的东西进行打印

1
ls.sort(key=lambda x: x[1])
2
for i in ls:
3
    print(i[0])

输出为

1
jerry
2
micky
3
tom
4
donald

但是经过教员的提醒，还有个zip()函数可以直接把两个列表中的对应位置的元素合在一起变成元组

1
items = list(zip(a,b))

这样做的结果跟上面的ls的结果是一样的

然后再在列表表达式里面筛选，两步可以合在一起

1
items = [item for item in list(zip(a,b)) if item[1] < 18]
2
for i in items:
3
    print(i[0])

启示：少用字典，筛选放在后面去

例题2#

2089. 找出数组排序后的目标下标 - 力扣（LeetCode）

我的题解：

1
class Solution:
2
    def targetIndices(self, nums: List[int], target: int) -> List[int]:
3
        nums.sort()
4
        result = []
5
        for i in range(0,len(nums)):
6
            if nums[i] == target:
7
                result.append(i)
8
        return result

优化版（因为找到了以后，再往后就不存在要找的了，所以可以直接break掉）

1
class Solution:
2
    def targetIndices(self, nums: List[int], target: int) -> List[int]:
3
        nums.sort()
4
        result = []
5
        found = False
6
        for i in range(0,len(nums)):
7
            if nums[i] == target:
8
                result.append(i)
9
            if nums[i] != target and found:
10
                break
11
        return result

例题3#

2215. 找出两数组的不同 - 力扣（LeetCode）

我的题解：

1
class Solution:
2
    def findDifference(self, nums1: List[int], nums2: List[int]) -> List[List[int]]:
3
        answer = [[],[]]
4
        for i in nums1:
5
            if i not in nums2 and i not in answer[0]:
6
                answer[0].append(i)
7
        for i in nums2:
8
            if i not in nums1 and i not in answer[1]:
9
                answer[1].append(i)
10
        return answer

优化版（找不同的可以用集合去做）：

1
class Solution:
2
    def findDifference(self, nums1: List[int], nums2: List[int]) -> List[List[int]]:
3
        s1 = set(nums1)
4
        s2 = set(nums2)
5
        answer = [[],[]]
6
        answer[0] = list(s1-s2)
7
        answer[1] = list(s2-s1)
8
        return answer

例题4#

599. 两个列表的最小索引总和 - 力扣（LeetCode）

我的题解：

1
class Solution:
2
    def findRestaurant(self, list1: List[str], list2: List[str]) -> List[str]:
3
        lovedRest = []
4
        for i in list1:
5
            if i in list2:
6
                indexSum = list1.index(i) + list2.index(i)
7
                lovedRest.append((i,indexSum))
8
        lovedRest.sort(key=lambda x: x[1])
9
        result = []
10
        result.append(lovedRest[0][0])
11
        for i in range(1,len(lovedRest)):
12
            if lovedRest[i][1] == lovedRest[0][1]: result.append(lovedRest[i][0])
13
            else: break
14
        return result

enumerate(list)在遍历的过程中出现index, value的返回值，可以在for循环使用，例如

1
...(上面已经定义了ls为列表)
2
for i, value in enumerate(ls):
3
    pass

所以上面这一题也可以改一改，用这个方法可以免去用ls.index()的麻烦

例题5#

2200. 找出数组中的所有 K 近邻下标 - 力扣（LeetCode）

我的题解（OT了）：

1
class Solution:
2
    def abs(num):
3
        if num < 0:
4
            return num*-1
5
        else: return num
6
    def findKDistantIndices(self, nums: List[int], key: int, k: int) -> List[int]:
7
        keyPos = [i for i in range(0,len(nums)) if nums[i] == key]
8
        result = []
9
        for pos in keyPos:
10
            for i in range(0,len(nums)):
11
                if abs(i-pos)<=k and i not in result: result.append(i)
12
                else: pass
13
        result.sort()
14
        return result

优化版：

思路是从i所在位置往左往右k个位置是否有key，如果有的话就进行计算，没有就跳过，省去了很多遍历

1
class Solution:
2
    def findKDistantIndices(self, nums: List[int], key: int, k: int) -> List[int]:
3
        result = []
4
        for i in range(len(nums)):
5
            if key in nums[max(0,i-k):i+k+1]:
6
                result.append(i)
7
        return result