华为机试题：HJ80 整型数组合并（python）

---

描述：

题目标题：
将两个整型数组按照升序合并，并且过滤掉重复数组元素。
输出时相邻两数之间没有空格。

输入描述：
输入说明，按下列顺序输入：
1 输入第一个数组的个数
2 输入第一个数组的数值
3 输入第二个数组的个数
4 输入第二个数组的数值

输出描述：
输出合并之后的数组

示例1

输入：
3
1 2 5
4
-1 0 3 2

输出：
-101235

---

Python3

while True:
    try:
        a, b, c, d = input(), list(map(int,input().split())), input(), list(map(int,input().split()))
        print("".join(map(str, sorted(list(set(b+d))))))
    except:
        break

---

知识点详解

1、input()：获取控制台（任意形式）的输入。输出均为字符串类型。

str1 = input()
print(str1)
print('提示语句:', str1)
print(type(str1))

'''
asd123!#
提示语句: asd123!#
<class 'str'>
'''

  1.1、int(input()) 与 map(int, input().spilt()) 的区别

常用的强转类型	说明
int(input())	强转为整型（int类型只能输入一个整数字符串）
map(int, input().spilt())	强转为整型（map函数可以输入多个整数字符串）
list(input())	强转为列表（输入可以是任意类型）

  1.2、input() 与 list(input()) 的区别、及其相互转换方法

• 相同点：两个方法都可以进行for循环迭代提取字符，提取后都为字符串类型。
• 不同点：str = list(input()) 将输入字符串转换为list类型，可以进行相关操作。如： str.append()

• 将列表转换为字符串：str_list = ['A', 'aA', 2.0, '', 1]

• 方法一：print(''.join(str))
• 方法二：print(''.join(map(str, str_list)))

备注：若list中包含数字，则不能直接转化成字符串，否则系统报错。

• 方法一：print(''.join([str(ii) for ii in str_list]))
• 方法二：print(''.join(map(str, str_list)))
  map()：根据给定函数对指定序列进行映射。即把传入函数依次作用到序列的每一个元素，并返回新的序列。

（1） 举例说明：若list中包含数字，则不能直接转化成字符串，否则系统报错。

str = ['25', 'd', 19, 10]
print(' '.join(str))

'''
Traceback (most recent call last):
 File "C:/Users/Administrator/Desktop/test.py", line 188, in <module>
   print(' '.join(str))
TypeError: sequence item 3: expected str instance, int found
'''

（2）举例说明：若list中包含数字，将list中的所有元素转换为字符串。

str_list = ['A', 'aA', 2.0, '', 1]
print(''.join(str(ii) for ii in str_list))
print(''.join([str(ii) for ii in str_list]))
print(''.join(map(str, str_list))) 		# map()：根据给定函数对指定序列进行映射。即把传入函数依次作用到序列的每一个元素，并返回新的序列。

'''
AaA2.01
AaA2.01
AaA2.01
'''

2、print() ：打印输出。

【Python】print()函数的用法

x, y = 1, 9
print('{},{}' .format(x, y))	# 打印方法一
print('*'*10)					# 打印分割符
print(x, ',', y)				# 打印方法二

'''
1,9
**********
1 , 9
'''

3、list列表的常用操作（15+9函数）—— 列表是一个有序可变序列。

一般来说，有序序列类型都支持索引，切片，相加，相乘，成员操作。

• 不可变数据类型： 布尔类型（bool）、整型（int）、字符串（str）、元组（tuple）
• 可变数据类型： 列表（list）、集合（set）、字典（dict）

序号	函数	说明
0	list1 = []	创建空列表
0	list1 = list()	创建空列表
1	list2 = [元素]	创建列表。输入参数可以是任意类型
1	list2 = list(元素)	创建列表。输入参数可以是任意类型
——	——	——
2	list[index]	索引（负数表示倒叙）
3	list[start, end]	切片（获取指定范围元素）
4	list[::-1]	逆序输出（步长为1）
——	——	——
5	list.append(元素)	在列表末尾添加任意类型的一个元素
6	list.extend(元素)	添加可迭代序列
7	list.insert(index, 元素)	在指定位置插入一个元素
——	——	——
8	list.remove(元素)	删除指定元素。（1）若有多个相同元素，则只删除第一个元素。（2） 若不存在，则系统报错。
9	list.pop(index)	删除指定位置元素。默认删除最后一项。
10	del list(index)	删除指定位置元素
11	list.clear()	清空内容，返回空列表
——	——	——
12	list.index(元素)	索引元素位置。（1）若有多个相同元素，则只返回第一个元素的位置。（2）若不存在，则系统报错。
13	list.count(元素)	计算指定元素出现的次数
14	list.reverse()	逆序输出
15	list.sort(*, key=None, reverse=False)	（1）默认从小到大排列。（2）reverse=True 表示从大到小排序。
——	——	——
（1）	len(list)	元素个数
（2）	type(list)	查看数据类型
（3）	max(list)	返回最大值（不能有嵌套序列）
（4）	min(list)	返回最小值（不能有嵌套序列）
（5）	list(tuple)	将元组转换为列表
（6）	list1 + list2	+ 操作符（拼接）
（7）	list * 3	* 操作符（重复）
（8）	元素 in list	（in / not in）成员操作符（判断给定值是否在序列中）
（9）	for i in list:	遍历

4、set集合的常用操作（7+4函数）—— 集合是一个不重复元素的无序可变序列。

无序：赋值后，各元素位置将随机输出。
不重复：赋值变量时，若存在重复元素，系统会自动去除，只保留一个。

• set(str) 对字符串去重
• set(tuple)对元组去重
• set(list)对列表去重。
  备注：字符串、元祖、列表是有序序列。
  备注：无法对无序序列进行去重。

序号	函数	说明
0	set1 = set()	创建空集合
1	set2 = {元素1, 元素2}	创建集合
1	set2 = set({元素1, 元素2})	创建集合。输入参数可以是任意类型
——	——	——
2	set.add(元素)	（只能添加一个元素）将元素添加到集合中。若元素存在，则不进行任何操作。
3	set.update(元素)	（添加多个元素）将元素添加到集合中。（1）参数可以是列表，元组，字典等。（2）若是字符串，将按字符拆分后再添加。
4	set.copy()	浅拷贝
——	——	——
4	set.remove(元素)	删除指定元素。若元素不存在，则系统报错。
5	set.discard(元素)	删除指定元素。若元素不存在，则不进行任何操作。
6	set.pop()	随机删除一个元素。（1）对集合进行无序排列，然后删除第一个元素。（2）若指定元素，则系统报错。
7	set.clear()	清空内容，返回空集合
——	——	——
（1）	len(set)	元素个数
（2）	type(set)	查看数据类型
（3）	元素 in set	（in / not in）成员操作符（判断给定值是否在序列中）
（4）	for i in set:	遍历

5、sorted() ：对所有可迭代类型进行排序，不改变原始序列。按照ASCII的大小进行排序（数字 >> 大写字母 >> 小写字母）。

函数说明：sorted(iterable, key=None, reverse=False)
输入参数：

• iterable：可迭代的对象（如：字典、列表）。
• key：可迭代类型中某个属性，对指定函数进行排序。默认=None
• reverse：默认升序（reverse=False）、降序（reverse=Ture）。

备注：字符串按照ASCII的大小进行排序。默认先排序数字（0 ~ 9），再排序大写字母（A ~ Z），后排序小写字母（a ~ z）。

lst1 = (5, 4, 3, -2, 1)
L1 = sorted(lst1)                       
L2 = sorted(lst1, key=abs)              
L3 = sorted(lst1, reverse=True)         
print(L1)			# 【输出结果】[-2, 1, 3, 4, 5]
print(L2)			# 【输出结果】[1, -2, 3, 4, 5]				
print(L3)			# 【输出结果】[5, 4, 3, 1, -2]
###################################################################################
lst2 = ('F', 'D', 'Y', 'e', 'a', 'v', '9', '6')
L4 = sorted(lst2)                       
L5 = sorted(lst2, key=str.lower)		# 对指定函数进行排序（将所有字母转换为小写，然后排序。不改变原字符串。）
print(L4)			# 【输出结果】['6', '9', 'D', 'F', 'Y', 'a', 'e', 'v']
print(L5)			# 【输出结果】['6', '9', 'e', 'F', 'v', 'Y']

6、map()：将指定函数依次作用于序列中的每一个元素 —— 返回一个迭代器，结果需指定数据结构进行转换后输出。

函数说明：map(function, iterable)
输入参数：

• function：指定函数。
• iterable：可迭代对象

print('返回一个迭代器: ', map(int, (1, 2, 3)))
# 返回一个迭代器:  <map object at 0x0000018507A34130>

结果需指定数据结构进行转换后输出

• 数据结构：list、tuple、set。可转换后输出结果
• 数据结构：str。返回一个迭代器
• 数据结构：dict。ValueError，需输入两个参数

print('将元组转换为list: ', list(map(int, (1, 2, 3))))
print('将字符串转换为list: ', tuple(map(int, '1234')))
print('将字典中的key转换为list: ', set(map(int, {1: 2, 2: 3, 3: 4})))

'''
将元组转换为list:  [1, 2, 3]
将字符串转换为list:  (1, 2, 3)
将字典中的key转换为list:  {1, 2, 3}
'''

################################################################################
dict_a = [{'name': 'python', 'points': 10}, {'name': 'java', 'points': 8}]
print(list(map(lambda x : x['name'] == 'python', dict_a)))
print(dict(map(lambda x : x['name'] == 'python', dict_a)))

"""
[True, False]
TypeError: cannot convert dictionary update sequence element #0 to a sequence
"""

7、str.join()：将序列（字符串、元组、列表、字典）中的元素以指定字符连接，并返回一个新的字符串。

函数说明：'Separator'.join(Sequence)
功能说明：以Separator为分隔符，对Sequence所有元素进行逐个分割，并返回一个新的字符串。
输入参数：

• Separator：代表分隔符。 可以是单个字符（如：''、','、'.'、'-'、'*'等），也可以是字符串（如: 'abc'）。
• Sequence：代表要连接的元素序列。可以是字符串、元组、列表、字典。
  备注1：Separator和Sequence都只能是string型，不能是int型和float型，否则系统报错。
  备注2：字典的读取是随机的。

a1 = 'I Love China !'
print('字符串: ', ' '.join(a1))

a11 = 'I Love China !'
print('字符串: ', ''.join(a11))

a2 = ['I', 'Love', 'China', '!']
print('列表: ', ' '.join(a2))

a3 = ('I', 'Love', 'China', '!')
print('元祖: ', ' '.join(a3))

a4 = {'I': 1, 'Love': 2, 'China': 3, '!': 4}
print('字典: ', ' '.join(a4))

'''
字符串:  I   L o v e   C h i n a   !
字符串:  I Love China !
列表:  I Love China !
元祖:  I Love China !
字典:  I Love China !
'''

import os     	# 导入路径模块
os.getcwd()   	# 获取当前路径
data_save = os.path.join(os.getcwd(), 'data_save')  # 获取当前路径并组合新的路径
print(data_save)