华为机试题：HJ3 明明的随机数（python）

描述：明明生成了N个1到500之间的随机整数。请你删去其中重复的数字，即相同的数字只保留一个，把其余相同的数去掉，然后再把这些数从小到大排序，按照排好的顺序输出。

数据范围： 1≤n≤1000 ，输入的数字大小满足 1≤val≤500

输入描述：第一行先输入随机整数的个数 N 。 接下来的 N 行每行输入一个整数，代表明明生成的随机数。 具体格式可以参考下面的"示例"。

输出描述：输出多行，表示输入数据处理后的结果

示例1

输入：3
输入：2
输入：2
输入：1
说明：第一个数字是3，也即这个小样例的N=3，说明用计算机生成了3个1到500之间的随机整数，接下来每行一个随机数字，共3行。
输出：1
输出：2

Python3

while True:
    try:
        line_num, num = int(input()), set()
        for i in range(line_num):
            num.add(int(input()))
        for j in sorted(list(num)):
            print(j)
    except:
        break
        

• input()：用于获取控制台的输入。
• int() ：强制转换为整型（强转）。
• set() ：创建集合。其表示一个无序不重复元素的序列。
• range() ：输出指定范围内的所有值（前闭后开）。
• add() ：用于向集合中添加元素。
• list()：创建列表。将任何可迭代序列转换为列表类型，并返回转换后的列表。
• sorted() ：对所有可迭代类型进行排序。不改变原始序列，返回排序后的新序列。
• print() ：用于打印输出。

---

知识点详解

1、int() ：强制转换为整型（强转）。

【Python】int()用法详解

• 输入参数：不带参数直接 int()，返回整数 0。
• 输入参数：整数，返回：原来的整数。
• 输入参数：浮点数，返回浮点数的整数。
• 输入参数：字符串（整数），将字符串类型转换为int类型转换。
• 输入参数：字符串（浮点数），需先转换为float类型，再进行int转换，否则报错。

print(int())                    # 【输出结果】0
print(int(2))                   # 【输出结果】2
print(int(-2.9))                # 【输出结果】-2
print(int('-2'))                # 【输出结果】-2
print(int(float('-2.9')))       # 【输出结果】-2

2、set() ：创建集合。其表示一个无序不重复元素的序列。

【Python】集合set的使用详解

无序：无论序列中的元素在赋值给变量之前是什么顺序，赋值后各元素位置都将会随机显示。
不重复：对序列中的重复元素，赋值给变量后系统会自动去除重复元素，只保留一个。

• 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
• 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。
  备注1：不可变就是变量赋值 / 定义后不可改变，但可以通过拼接操作符等的方式改变。
  备注2：【列表、元组和字符串】都属于序列。

集合的创建方法：

• （1）创建空集：set()
• （2）创建集合：set((A,B))
• （3）创建集合：{}
• 备注1：创建空集合必须用 set() 而不能是 { }，因为 { } 是用来表示空字典类型的。
• 备注1：set() 对字符串也会去重，因为字符串属于序列。

# （1）创建空集：set()
person1 = set()         # 空集合
print(len(person1))     # 【输出结果】0
print(person1)          # 【输出结果】set()

# （2）创建集合：set((A,B))
person2 = set(("student", "teacher", "babe", 123, 321, 123))
print(len(person2))     # 【输出结果】5
print(person2)          # 【输出结果】{321, 'teacher', 'babe', 123, 'student'}

# （3）创建集合：{}
person = {"student", "teacher", "babe", 123, 321, 123}
print(len(person))      # 【输出结果】5
print(person)           # 【输出结果】{'student', 321, 'teacher', 123, 'babe'}

# 字符串去重
str1 = set("abcde")
str2 = set("abcd")
print(str1, str2)                                    	# 【输出结果】{'b', 'c', 'a', 'd', 'e'} {'b', 'c', 'd', 'a'}
print(str1 - str2)      # set()之间可以使用减号运算     	# 【输出结果】{'e'}
print(str2-str1)        # 空值                        	# 【输出结果】set()
# print(str1+str2)      # set()之间不能使用加号运算

3、add() ：用于向集合中添加元素。

集合名.add(添加的元素)

• （1）添加的元素只能是不可变数据类型，因此不能向集合中添加列表、元组、集合。
• （2）如果添加的元素已经存在集合中，则不执行添加操作，程序也不会报错。因为集合是一个无序不重复元素的序列。
• （3）每次只能添加一个元素，否则系统报错。

set_city = {'北京', '上海', '广州'}
print('添加前的集合：', set_city)      # 【输出结果】添加前的集合： {'上海', '北京', '广州'}

set_city.add('重庆')
print('添加后的集合：', set_city)      # 【输出结果】添加后的集合： {'上海', '北京', '重庆', '广州'}

set_city.add('上海')
print('添加后的集合：', set_city)      # 【输出结果】添加后的集合： {'上海', '北京', '重庆', '广州'}

4、range() ：输出指定范围内的所有值（前闭后开）。

range(start=0，stop，step=1)
参数说明：

• （1）start：序列的起始点，默认值0。
• （2）stop：序列的终止点。
• （3）step：滑动步长，默认为1。正数表示迭代上升，负数表示迭代下降。

备注：前闭后开[A，B)，即可以取到A值，但取不到B值。

# （1）指定stop=9, start默认为0，step默认为1
for i in range(9):
    print('A =', i)
'''
A = 0
A = 1
A = 2
A = 3
A = 4
A = 5
A = 6
A = 7
A = 8
'''
# （2）指定start=2, stop=9, step默认为1
for i in range(2, 9):
    print('B =', i)
'''
B = 2
B = 3
B = 4
B = 5
B = 6
B = 7
B = 8
'''
# （3）指定start=2, stop=9, step=-2
for i in range(9, 2, -2):
    print('C =', i)
'''
C = 9
C = 7
C = 5
C = 3
'''

5、list()：创建列表。将任何可迭代序列转换为列表类型，并返回转换后的列表。

list(object)

• object：待转换为列表的数据类型。object可省略，若参数为空，则创建一个空列表。

备注1：参数必须是可迭代序列对象，否则系统报错。
备注2：将字典转换为列表时，默认只输出key，而舍去value。若想将字典的值转换为列表，可以使用dict.values()、默认dict.keys()

# （1）创建一个空列表
test1 = list()
print(test1)                            # 【输出结果】[]
#################################################################
# （2）将字符串转换为列表
test2 = list('cat')
print(test2)                            # 【输出结果】['c', 'a', 't']
#################################################################
# （3）将元组转换为列表
test3 = list(('I love Python.', 'I also love HTML.'))
print(test3)                            # 【输出结果】['I love Python.', 'I also love HTML.']
#################################################################
# （4）将字典转换为列表
test4 = list({'China': 'Beijing', 'Russia': 'Moscow'})
test44 = list({'China': 'Beijing', 'Russia': 'Moscow'}.keys())      
test444 = list({'China': 'Beijing', 'Russia': 'Moscow'}.values())
print(test4)                            # 【输出结果】['China', 'Russia']
print(test44)                           # 【输出结果】['China', 'Russia']
print(test444)                          # 【输出结果】['Beijing', 'Moscow']
#################################################################
# （5）将集合转换为列表
test5 = list({1, 4, 'sdf'})
print(test5)                            # 【输出结果】[1, 4, 'sdf']
#################################################################
# （6）将列表转换为列表
test6 = list(["a", "b", "c", "d"])
print(test6)                            # 【输出结果】['a', 'b', 'c', 'd']
#################################################################
# （7）将可迭代序列（range类型）转换为列表
test7 = list(range(10))
print(test7)                            # 【输出结果】[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
#################################################################
# （8）将可迭代序列（map类型）转换为列表
test8 = list(map(int, [23.2, 33.1]))
print(test8)                            # 【输出结果】[23, 33]

6、sorted() ：对所有可迭代类型进行排序。不改变原始序列，返回排序后的新序列。

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

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

备注：字符串按照ASCII的大小进行排序。默认先排序大写字母，后排序小写字母。

lst1 = (5, 4, 3, -2, 1)
L1 = sorted(lst1)                       # 【输出结果】[-2, 1, 3, 4, 5]
L2 = sorted(lst1, key=abs)              # 【输出结果】[1, -2, 3, 4, 5]
L3 = sorted(lst1, reverse=True)         # 【输出结果】[5, 4, 3, 1, -2]
print(L1)
print(L2)
print(L3)
###################################################################################
lst2 = ('F', 'D', 'Y', 'e', 'a', 'v')
L4 = sorted(lst2)                       # 【输出结果】['D', 'F', 'Y', 'a', 'e', 'v']
L5 = sorted(lst2, key=str.lower)        # 【输出结果】['a', 'D', 'e', 'F', 'v', 'Y']
print(L4)
print(L5)