小练习

python 删除列表中特定元素前的所有元素，并放回新的列表

（1）若特定元素在元素列表中，则删除特定元前的所有元素后返回新的列表
（2）若原始列表为空，则也返回一个空列表
（3）如果特定元素不在列表中，就返回原始列表

def remove_all_before(items: list, border: int) -> Iterable:
    
    for i in items:   
        if i==border:
            return items[items.index(border):]   #切片
            break
        elif len(items)==0:
            return []
    if(border not in items):    #如果特定元素不在列表中
        return items

检查给定的字符串是否所有符号都大写。如果字符串为空或全是大写字母-函数应返回True

python使用ord(i)打印i的ASCII码值
大写字母的ASCII码（A-Z ）为65-90
小写字母的ASCII码（a-z ）为97-122
数字的ASCII码（0-9）为 48-57
空格的ASCII码为 32

def is_all_upper(text: str) -> bool:
    
    for i in range(len(text)):
        for j in text:
            if 97<=ord(j)<=122:    #证明是小写字母
                result = False
            else:
                result = True
        return result
             
    if len(text)==0:  #如果字符串为空的情况下
        return True

将列表中第一个挪到最后一个的位置，空列表或只有一个元素的列表则保持不变

def replace_first(items: list) -> Iterable:
   
    if 0<=len(items)<=1:
        return items
    else:
        #第一个挪到最后一个的位置
        items.insert(len(items),items[0])
        items.pop(0)
        return items

计算一个全是数字的字符串开头有几个0

def beginning_zeros(number: str) -> int:
    # 先判断number中是否全为数字
    if([0<=int(i)<=9 for i in number]):   
        sum = 0     #计数，0的个数
        for i in number:
            if i !='0':
                break
            else:
                sum+=1
    return sum

拆分原始字符串，每两个为一个元素放在列表中，若原始字符串为奇数个字符，则在最后一个元素后面加‘_’,若原始字符串为空，则返回空列表

def split_pairs(a):
    A = []   #放拆开的字符串
    if 0<=len(a)<=100:
        if(len(a)==0):
            return []
        elif(len(a)%2==0):   #偶数个字符
            # print(int(len(a)/2))
            for i in range(0,len(a),2):
                A.append(a[i:i+2])
        else:   #奇数个字符
            B = list(a)
            B.append('_')   #在最后加'_'
            # 将列表转成字符串
            B = ''.join([str(i) for i in B])   
            for j in range(0,len(B),2):
                A.append(B[j:j+2])
    return A

给一个全是数字的字符串，找到该字符串中的最大数字

def max_digit(number: int) -> int:
    num = []
    #将数字转成str型，循环装入列表中
    for i in str(number):
        num.append(i)
    #因为前面将数字转成了字符串，所以要转回int型
    return int(max(num))  #max()函数

给定一个原始字符串，要求以相反的顺序返回给定的字符串

def backward_string(val: str) -> str:
    stack=[]
    P_stack=[]
    if val=='':
        return ''
    else:
        for i in val:
            stack.append(i)
        for j in range(len(val)):
        # 删除是默认先从最后一个开始的
            P_stack.append(stack.pop())
        return ''.join(P_stack)

计算给定全是数字的字符串末尾有多少个零

def end_zeros(num: int) -> int:
    sum=0
    stack = []
  
    if len(str(num))==1:
        if num==0:
            return 1
        else:
            return 0
    else:
        for i in str(num):
            stack.append(i)
        for j in range(len(str(num))):
            if stack.pop()!='0':
                break
            sum+=1
        return sum

计算数字有几位数

def number_length(a: int) -> int:
    return len(str(a))

打印第一个单词

def first_word(text: str) -> str:  
    return text.split()[0]

一个可同时包含正数和负数的非空集合（都是整数），找到集合中最接近给定值的数字

对集合进行升序排序，从左到右最接近的数字，如果有两个数字离给定值的距离相同，则选择最小的那个

def nearest_value(values: set, one: int) -> int:
    #如果是整数,并且非空
    if([isinstance(i,int) for i in values] and len(values) != None):   
        #对集合进行排序--升序
        # 设置列表装与给定值的距离，该元素的索引与排序后的集合（此时是一个列表）中的一致
        #从而可以确定最接近给定值的元素，也解决了距离相同的问题
        distance = []
        for j in sorted(values):
            distance.append(abs(j-one))
        # 集合本身是不支持索引的
        return sorted(values)[distance.index(min(distance))]

一个字符串和两个标记（第一个和最后一个标记），找到两个标记之间的子字符串

两个标记，即初始和最终标记始终是不同的，1个字符大小。始终存在于字符串中，并且一个接一个。前提： 最终标记和初始标记不能超过一个。
解答1

def between_markers(text: str, begin: str, end: str) -> str:
    #如果起始与终止标识都在text中
    if(begin in text and end in text):
        result = text[text.index(begin)+1:text.index(end)]
        if len(result) == 0:   #如果起始与终止标识之间没有字符
            result = ""
    return result

解答2

def between_markers(text: str, begin: str, end: str) -> str:
    start = text.find(begin)
    finish = text.find(end)

    if start != -1 and finish != -1:
        start += len(begin)
   	return text[start:finish]

解答3

def between_markers(text: str, begin: str, end: str) -> str:
    return text[(lambda x,y: 0 if x == -1 else x + y)(text.find(begin), len(begin)):
                (lambda x,y: y if x == -1 else x)(text.find(end), len(text))]

解答4

def between_markers(text: str, begin: str, end: str) -> str:
    start = text.find(begin) + len(begin) if begin in text else None
    stop = text.find(end) if end in text else None
    return text[start:stop]

改正字符串的格式，将开头第一个字母变大写（若已经是大写的就不变），在最后加‘.’结尾（若已经 有’.'就 ‘.’就不变）

“hi”==> “Hi.”
解答1

def correct_sentence(text: str) -> str:
    #将开头第一个字母变大写
    text = text[0].upper()+text[1:]
    # 如果末尾没有‘.’，就追加
    #Python endswith() 方法用于判断字符串是否以指定后缀结尾，
    #如果以指定后缀结尾返回True，否则返回False
    if not text.endswith('.'):   
        text += '.'
    return text

解答2

def correct_sentence(text: str) -> str:
	#islower() 方法检测字符串是否由小写字母组成
    if text[0].islower():
       text = text[0].upper() + text[1:]
    if text[-1] != '.':
       text += '.'
    return text

解答3

return ((text[0].upper() + text[1:]) if (text[0].islower() == True) else text) + ("." if text[-1]!= "." else "")

检查给定的数字是否为偶数。如果数字为偶数，则函数应返回True，如果数字为奇数，则函数应返回False

def is_even(num: int) -> bool:
    # 是整数，且在 -1000到1000之间
    if(-1000<=num<=1000 and isinstance(num,int)):
        if(num%2)==0:
            return True
        else:
            return False

标题

标题

标题

标题

标题

标题

标题

标题