1. 编写函数，求1+2+3+…N的和
def sum_n(n: int):
"""
编写函数，求1+2+3+…N的和
:param n: 累加的最大值
:return: 1~n的累加和
"""
# 1.
# return sum(n for n in range(1, n + 1))
# 2.
sum1 = 0
for num in range(1, n + 1):
sum1 += num
return sum1
2. 编写一个函数，求多个数中的最大值
def max_n(*nums: int):
"""
求多个数中的最大值
:param nums: 任意个数
:return:最大值
"""
if not nums:
return 0
# 1.
# return max(nums)
# 2.
max_num = nums[0]
for num in nums[1:]:
if max_num < num:
max_num = num
return max_num
3. 编写一个函数，实现摇骰子的功能，打印N个骰子的点数和
def sum_dice(n: int):
"""
实现摇骰子的功能，打印N个骰子的点数和
:param n: 骰子个数
:return: 所有骰子的点数和
"""
from random import randint
# 1.
# return sum(randint(1, 6) for _ in range(n))
# 2.
sum1 = 0
for _ in range(n):
sum1 += randint(1, 6)
return sum1
4. 编写一个函数，交换指定字典的key和value。
例如:dict1={'a':1, 'b':2, 'c':3} --> dict1={1:'a', 2:'b', 3:'c'}
def change_dict(dicts: dict):
"""
交换指定字典的key和value
:param dicts: 待交换字典
:return: 交换键值后的字典
"""
# 1.
# return dict(zip(dicts.values(), dicts.keys()))
# 2.
# return {dicts[key]: key for key in dicts}
# 3.
new_dict = {}
for key in dicts:
new_dict[dicts[key]] = key
return new_dict
5. 编写一个函数，提取指定字符串中所有的字母，然后拼接在一起产生一个新的字符串
例如: 传入'12a&bc12d-+' --> 'abcd'
def get_alpha(strs: str):
"""
提取指定字符串中所有的字母，然后拼接在一起产生一个新的字符串
:param strs: 指定字符串
:return: 所有字母拼接产生的字符串
"""
# 1.
# return ''.join(char for char in strs if 'A' <= char <= 'Z' or 'a' <= char <= 'z')
# 2.
new_str = ''
for char in strs:
if 'A' <= char <= 'Z' or 'a' <= char <= 'z':
new_str += char
return new_str
6. 写一个函数，求多个数的平均值
def get_avg(*nums: int):
"""
求多个数的平均值
:param nums: 多个数
:return: 平均值
"""
# 1.
# return sum(n for n in nums) / len(nums)
# 2.
sum1 = 0
for num in nums:
sum1 += num
return sum1 / len(nums)
7. 写一个函数，默认求10的阶乘，也可以求其他数字的阶乘
def get_factor(n=10):
"""
默认求10的阶乘，也可以求其他数字的阶乘
:param n: 阶乘数
:return: n的阶乘
"""
if n < 0:
return -1
if n < 2:
return 1
# 1.
# return n * get_factor(n - 1)
# 2.
fac = 1
for i in range(2, n + 1):
fac *= i
return fac
注意：以下方法不能使用系统提供的方法和函数，全部自己写逻辑
8. 写一个自己的capitalize函数，能够将指定字符串的首字母变成大写字母
例如: 'abc' -> 'Abc' '12asd' --> '12asd'
def my_capitalize(strs: str):
"""
写一个自己的capitalize函数，能够将指定字符串的首字母变成大写字母
:param strs: 指定字符串
:return: 首字母大写的字符串
"""
if not (strs and 'a' <= strs[0] <= 'z'):
return strs
return chr(ord(strs[0]) - 32) + strs[1:]
9. 写一个自己的endswith函数，判断一个字符串是否已指定的字符串结束
例如: 字符串1:'abc231ab' 字符串2:'ab' 函数结果为: True
字符串1:'abc231ab' 字符串2:'ab1' 函数结果为: False
def my_endswith(strs: str, suffix: str, start=0, end=0):
"""
写一个自己的endswith函数，判断一个字符串是否已指定的字符串结束
:param strs: 需判断字符串
:param suffix: 指定的字符串
:param start: 字符串开始位置
:param end: 字符串结束位置
:return: True/False 是/否
"""
if not end:
end = len(strs)
sx_len = len(suffix)
return True if strs[start:end][-sx_len:] == suffix else False
10. 写一个自己的isdigit函数，判断一个字符串是否是纯数字字符串
例如: '1234921' 结果: True
'23函数' 结果: False
'a2390' 结果: False
def my_isdigit(strs: str):
"""
写一个自己的isdigit函数，判断一个字符串是否是纯数字字符串
:param strs: 需判断字符串
:return: True/False 是/否
"""
for char in strs:
if not ('0' <= char <= '9'):
return False
return True
11. 写一个自己的upper函数，将一个字符串中所有的小写字母变成大写字母
```python
例如: 'abH23好rp1' 结果: 'ABH23好RP1'
```
def my_upper(strs: str):
"""
写一个自己的upper函数，将一个字符串中所有的小写字母变成大写字母
:param strs: 字符串
:return: 全部字母大写的字符串
"""
# 1.
# return ''.join(chr(ord(char) - 32) if 'a' <= char <= 'z' else char for char in strs)
# 2.
new_str = ''
for char in strs:
if 'a' <= char <= 'z':
new_str += chr(ord(char) - 32)
else:
new_str += char
return new_str
12. 写一个自己的rjust函数，创建一个字符串的长度是指定长度，原字符串在新字符串中右对齐，剩下的部分用指定的字符填充
例如: 原字符:'abc' 宽度: 7 字符:'^' 结果: '^^^^abc'
原字符:'你好吗' 宽度: 5 字符:'0' 结果: '00你好吗'
def my_rjust(strs: str, width: int, fill_char: str):
"""
写一个自己的rjust函数，创建一个字符串的长度是指定长度，原字符串在新字符串中右对齐，剩下的部分用指定的字符填充
:param strs: 原字符串
:param width: 新字符串长度
:param fill_char: 填充字符
:return: 右对齐填充的新字符串
"""
if len(fill_char) != 1:
print('填充字符应为1个字符！')
return -1
s_len = len(strs)
return fill_char * (width - s_len) + strs if width > s_len else strs
13. 写一个自己的index函数，统计指定列表中指定元素的所有下标，如果列表中没有指定元素返回-1
```python
例如: 列表: [1, 2, 45, 'abc', 1, '你好', 1, 0] 元素: 1 结果: 0,4,6
列表: ['赵云', '郭嘉', '诸葛亮', '曹操', '赵云', '孙权'] 元素: '赵云' 结果: 0,4
列表: ['赵云', '郭嘉', '诸葛亮', '曹操', '赵云', '孙权'] 元素: '关羽' 结果: -1
```
def my_index(list1: list, x, start=0, end=0):
"""
写一个自己的index函数，统计指定列表中指定元素的所有下标，如果列表中没有指定元素返回-1
:param list1:待查找列表
:param x:目标元素
:param start:开始位置
:param end:结束位置
:return:指定元素位置
"""
if not end:
end = len(list1)
pos = []
for index in range(start, end - start + 1):
if list1[index] == x:
pos.append(index)
return pos if pos else -1
14. 写一个自己的len函数，统计指定序列中元素的个数
```python
例如: 序列:[1, 3, 5, 6] 结果: 4
序列:(1, 34, 'a', 45, 'bbb') 结果: 5
序列:'hello w' 结果: 7
```
def my_len(args):
"""
写一个自己的len函数，统计指定序列中元素的个数
:param args: 序列
:return: 元素个数
"""
# 1.
# return sum(1 for _ in args)
# 2.
count = 0
for _ in args:
count += 1
return count
15. 写一个自己的max函数，获取指定序列中元素的最大值。如果序列是字典，取字典值的最大值
```python
例如: 序列:[-7, -12, -1, -9] 结果: -1
序列:'abcdpzasdz' 结果: 'z'
序列:{'小明':90, '张三': 76, '路飞':30, '小花': 98} 结果: 98
```
def my_max(args):
"""
写一个自己的max函数，获取指定序列中元素的最大值。如果序列是字典，取字典值的最大值
:param args: 指定序列
:return: 最大值
"""
values = args
if isinstance(args, dict):
values = list(args.values())
max_value = values[0]
for value in values[1:]:
if max_value < value:
max_value = value
return max_value
16. 写一个函数实现自己in操作，判断指定序列中，指定的元素是否存在
```python
例如: 序列: (12, 90, 'abc') 元素: '90' 结果: False
序列: [12, 90, 'abc'] 元素: 90 结果: True
```
def my_in(args, x):
"""
写一个函数实现自己in操作，判断指定序列中，指定的元素是否存在
:param args: 序列
:param x: 指定元素
:return: True/False 是/否
"""
for item in args:
if item == x:
return True
return False
17. 写一个自己的replace函数，将指定字符串中指定的旧字符串转换成指定的新字符串
```python
例如: 原字符串: 'how are you? and you?' 旧字符串: 'you' 新字符串:'me' 结果: 'how are me? and me?'
```
import sys
def my_replace(strs: str, old: str, new: str, max_time=sys.maxsize):
"""
写一个自己的replace函数，将指定字符串中指定的旧字符串转换成指定的新字符串
:param strs: 指定字符串
:param old: 旧字符串
:param new: 替换的新字符串
:param max_time: 最大转换次数
:return: 转换后的新字符串
"""
if not new or not max_time:
return strs
# s_len = len(strs)
# old_len = len(old)
# # 1. 递归
# for index in range(s_len):
# if strs[index:index + old_len] == old:
# max_time -= 1
# return strs[:index] + new + my_replace(strs[index + old_len:], old, new, max_time)
# return strs
# # 2.分裂字符串
# str_list = []
# index = 0
# pre_index = 0
# while True:
# if index >= s_len - old_len + 1:
# str_list.append(strs[pre_index:])
# break
# if strs[index:index + old_len] == old:
# str_list.append(strs[pre_index:index])
# index += old_len
# pre_index = index
# continue
# index += 1
str_list = strs.split(old)
# return new.join(str_list)
# 添加新串
new_str = ''
for s in str_list[:-1]:
if max_time:
new_str += s + new
max_time -= 1
else:
new_str += s + old
return new_str + str_list[-1]
18. 写四个函数，分别实现求两个列表的交集、并集、差集、补集的功能
def set_intersection(list1: list, list2: list):
"""
求两个列表的交集
:param list1:列表1
:param list2:列表2
:return: 交集列表
"""
# return list(set(list1) & set(list2))
new_list = []
for i in list1:
for j in list2:
if i == j:
new_list.append(i)
return new_list
def set_union(list1: list, list2: list):
"""
求两个列表的并集
:param list1:列表1
:param list2:列表2
:return: 并集列表
"""
# return list(set(list1) | set(list2))
tmp_set = set()
for i in list1:
tmp_set.add(i)
for j in list2:
tmp_set.add(j)
return list(tmp_set)
def set_diff_set(list1: list, list2: list):
"""
求两个列表的差集
:param list1:列表1
:param list2:列表2
:return: 列表1对列表2的差集列表
"""
# return list(set(list1) - set(list2))
new_list = list1[:]
for i in list1:
for j in list2:
if i == j:
new_list.remove(j)
return new_list
def set_complementary(list1: list, list2: list):
"""
求两个列表的补集
:param list1:列表1
:param list2:列表2
:return: 列表2对列表1的相对补集列表
"""
# 如果列表2的集合不包含于列表1的集合，则不能求补集
tmp_list1 = list1
tmp_list2 = list2
for item in list2[:]:
tmp_list2.remove(item)
try:
tmp_list1.remove(item)
except ValueError:
return []
new_list = list1[:]
for i in list1:
for j in list2:
if i == j:
new_list.remove(j)
return new_list
# if set(list1) > set(list2):
# return list(set(list1) - set(list2))
# else:
# return []
