【python】数组字符串等实用_python 字符串数组-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_39797176/article/details/121702888

python系列文章目录

前言

例如：随着人工智能的不断发展，python这门技术也越来越重要，很多人都开启了学习python，本文简单介绍如何使用python进行简单数组字符串处理。

1. 数组

1.1 数组排序

#75. 颜色分类
'''
class Solution:
    def sortColors(self, nums: List[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        nums.sort()
        return nums
'''
#python自带排序
nums.sort()

1.2 数组索引

#1005. K 次取反后最大化的数组和
'''
class Solution:
    def largestSumAfterKNegations(self, nums: List[int], k: int) -> int:
        while(k>0):
            i_dex = nums.index(min(nums))
            nums[i_dex] = - nums[i_dex]
            k = k - 1
        return sum(nums)
'''
#获取num在nums中的首次索引
nums.index(num)

1.3 数组删除

#383.赎金信
'''
class Solution:
    def canConstruct(self, ransomNote: str, magazine: str) -> bool:
        #利用python.remove
        #将字符串转为数组
        ransomNote = list(ransomNote)
        magazine = list(magazine)
        while (ransomNote):
            s = ransomNote.pop()
            if s in magazine:
                magazine.remove(s)
            else:
                return False
        return True
'''
#根据索引删除，默认索引为-1
ransomNote.pop()
#如果s在magazine中则删除，如果存在多个s，只删除一个
magazine.remove(s)

2.字符串

2.1 字符串分割

#1816. 截断句子
'''
class Solution:
    def truncateSentence(self, s: str, k: int) -> str:
        tmp = s.split(' ')
        result = ''
        for i in range(k):
            result = result + tmp[i] + ' '
        return result[:-1]
'''
#字符串s以空格分割' '
tmp = s.split(' ')

2.2 字符串中获取字母

#748. 最短补全词
'''
class Solution:
    def shortestCompletingWord(self, licensePlate: str, words: List[str]) -> str:
        #获取字母并转化为小写
        tmp = ''.join(re.findall(r'[A-Za-z]', licensePlate)).lower()
        #初始化输出结果、字符长度对比
        count = float("inf")
        result = ''
        #定义一个函数，判断自否是否在另外一个字符中
        def con(tmp, ex):
            tmp = list(tmp)
            ex = list(ex)
            if len(tmp)>len(ex):
                return False
            for i in tmp:
                if i in ex:
                    ex.remove(i)
                else:
                    return False
            return True
        #遍历
        for i in words:
            ex = i[:]
            #如果字符包含且长度较小，则更新result、count
            if con(tmp, ex) and len(i)<count:
                result = i
                count = len(i)
        return result
'''
#获取字母并转化为小写
tmp = ''.join(re.findall(r'[A-Za-z]', licensePlate)).lower()

2.3 获取大小写字母

import string
#26个大写英文字母
list(string.ascii_uppercase)
#26个小写英文字母 
list(string.ascii_lowercase)
#26个小写英文字母和26个大写英文字母
list(string.ascii_letters)
print(words3)

3. * 用途

参考: Python中 * 的用途.

3.1 实参传递

#作为实参，将1、2分别作为a、b
def div(a,b):
    print(a/b)
div(*(1,2))
0.5

3.2 形参接收

def div(*a):
    print(a)
    print(a[0]/a[1])
div(1,2,3,4)
0.5

3.3 用例

#形参使用
a = 1,2,3
print([*a])
[1, 2 ,3]

4. 堆

4.1 基本使用

#导入模块
import heapq
heap = []
#插入元素
heappush(heap, 6)
#删除最小元素
heappop(heap)
#1705. 吃苹果的最大数目
'''
class Solution:
    def eatenApples(self, apples: List[int], days: List[int]) -> int:
        ans = 0
        pq = []
        i = 0
        while i < len(apples):
            while pq and pq[0][0] <= i:
                heappop(pq)
            if apples[i]:
                heappush(pq, [i + days[i], apples[i]])
            if pq:
                pq[0][1] -= 1
                if pq[0][1] == 0:
                    heappop(pq)
                ans += 1
            i += 1
        while pq:
            while pq and pq[0][0] <= i:
                heappop(pq)
            if len(pq) == 0:
                break
            p = heappop(pq)
            num = min(p[0] - i, p[1])
            ans += num
            i += num
        return ans
'''
#导入模块
import heapq
heap = []
#插入元素，按照从小到大顺序
heapq.heappush(heap, (a, b))
#输出元素，默认输出首个元素
heapq.heappop(heap)

5. 队列、栈

5.1 队列

队列为先入先出的数据结构，插入（insert）操作也称作入队（enqueue），新元素始终被添加在队列的末尾。删除（delete）操作也被称为出队（dequeue)。你只能移除第一个元素。

5.2 栈

栈与队列不同，栈是一个 LIFO 数据结构。通常，插入操作在栈中被称作入栈 push 。与队列类似，总是在堆栈的末尾添加一个新元素。但是，删除操作，退栈 pop ，将始终删除队列中相对于它的最后一个元素。

5.3 利用deque实现队列、栈

import collections
test = collections.deque('123456789')
#查看长度
len(test)
#插入元素#队列、栈插入尾部
test.append('10')
#左侧插入元素
test.appendleft('11')
#删除元素，栈删除栈顶元素
test.pop()
#删除左边元素，队列删除index为0的元素
test.popleft()
'''
155. 最小栈
# Your MinStack object will be instantiated and called as such:
# obj = MinStack()
# obj.push(val)
# obj.pop()
# param_3 = obj.top()
# param_4 = obj.getMin()

class MinStack:
    def __init__(self):
        self.nums = list()
    def push(self, val: int) -> None:
        nums = self.nums
        nums.append(val)
    def pop(self) -> None:
        nums = self.nums
        #栈顶元素为最后一个
        nums.pop()
    def top(self) -> int:
        nums = self.nums
        return nums[-1]
    def getMin(self) -> int:
        nums = self.nums
        return min(nums)
'''

6. 集合

6.1 集合创建

test = set()
#查看长度
len(test)
#插入元素
test.add('10')

#判断元素是否被访问过，set比list快
#279.完全平方数
'''
class Solution:
    def numSquares(self, n: int) -> int:
        step = 0
        #queue = deque([n])
        queue = [n]
        visited = set()
        if n == 0:
            return step
        #while queue:
        while queue != []:
            step += 1
            l = len(queue)
            for i in range(l):
                #tmp = queue.pop()
                tmp = queue.pop(0)
                for j in range(int(tmp**0.5) + 1):
                    x = tmp - j**2
                    if x == 0:
                        return step
                    if x not in visited:
                        visited.add(x)
                        #queue.appendleft(x)
                        queue.append(x)
        return step

'''
#python自带排序
nums.sort()

参考汇总:
[1] Python中 * 的用途.
[2] deque.