Python基础知识考题一

什么是Python?

Python是一种解释型、面向对象、动态数据类型的高级语言；

Python在编写时无须定义变量类型，在运行时变量类型强制固定，属于强类型语言；

Python无需编译，可以在解释器环境直接运行；

如何查看Python中关键字？

Python的保留关键字，不能把它们用作任何标识符名称，关键字区分大小写。Python的标准库提供了一个keyword模块，用于输出当前版本的所有关键字。

import keyword
print(keyword.kwlist)

输出：
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 
'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 
'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 
'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

Python中有哪些常见运算符？

算术运算符、比较运算符、赋值运算符、逻辑运算符、成员运算符、身份运算符...

练习题：

# 真题1
print(1 or 2)  # 1
print(1 and 2)  # 2
print(1 < (2 == 2))  # False
print(1 < 2 == 2)  # (1<2) and (2==2) # True
print(True == True == False)  # (True == True) and (True==False) # False
# 真题2
value = "B" and "A" or "C"  # A
print(value)  # A

# 真题3
# 用4,9,2,7四个数字，可以用+、-、*、/每个数字使用一次，使表达式的结果24，表达式是什么？
print((9 + 7 - 4) * 2)
# 真题4
# any()和all()方法有什么区别？
# any()只要迭代器中有一个元素为真结果就为真。all()迭代器中所有元素都为真结果才是真。
# 真题5 三目运算符
# a, b = 2, 3
# print("早啊" if a < b else "您好")
# 真题6 如何声明多个变量并赋值
# 两种方式
# 方式1 ：
a, b, c = 3, 4, 5
# 方式2 ：
a = b = c = 3

运算符is与==有什么区别 ？

Python中对象包含三要素：id、type、value。其中，id用来唯一标识一个对象，type标识对象的类型，value是对象的值。

is判断a对象是否就是b对象，用于判断两个变量引用对象是否为同一个，是通过id来判断。

==判断a对象的值是否和b对象的值相等，是通过value来判断的。

示例：
a = [1, 2, 3]
b = a
print(b is a)  # True
print(b == a)  # True
b = a[:]
print(b is a)  # False
print(b == a)  # True

 数据类型

Python都有哪些自带的数据类型？可变类型和不可变类型分别包括哪些？

Python自带的数据类型分为【可变】和【不可变】的类型。

【可变数据类型】表示允许变量的值发生变化，如果改变了数据类型对应变量的值，那么不会重新分配内存空间。即如果对变量进行append 或 +=等操作后，只是改变了变量的值，而不会新建一个对象，变量引用对象的内存地址也不会变化。对于相同值不同对象，在内存中则会存在不同的对象，即每个对象都有自己的地址，相当于内存中对于相同值的对象保存了多份，这里不存在引用计数，是实实在在的对象。

【可变数据类型】包括：列表(list)、集合（set)、字典（dict)。

【不可数据类型】表示不允许变量的值发生变化，如果改变了该数据类型对应变量的值，那么将重新分配内存空间，相当于新建了一个对象，不可变数据类型包含：字符串（str)、元祖(tuple)、数值(number)。

对于内存中相同值的对象，在内存中只有一个对象，内部会有一个引用计数记录有多少个变量引用这个对象。不可变数据类型对应变量的值更改后其内存地址发生变化；可变数据类型对应变量的值更改后其内存地址不会发生改变；

 示例：

 整型
a = 1
print(id(a), type(a))
a = 2
print(id(a),type(a))
# 输出:
#  140707893588816 <class 'int'>
# 140707893588848 <class 'int'>
# 结论：数据发生改变后，变量内存地址发生了改变，整型就是不可变数据类型

# 字符串
b = "Hello"
print(id(b),type(b))
b = "赛兔子"
print(id(b),type(b))
# 结论：数据发生改变后，变量内存地址发生了改变，字符串就是不可变数据类型


# 元组
li = [3, 4]
t = (1, 2, li)
print(t, id(t), type(t))
li[1] = "hello"
print(t,id(t),type(t))
# 输出
#  (1, 2, [3, 4]) 2179154624160 <class 'tuple'>
#  (1, 2, [3, 'hello']) 2179154624160 <class 'tuple'>
# 结论：虽然元组数据发生改变，但是内存地址没有发生改变。因为：修改了元组中列表的值，列表是可变数据类型。

序列

习题1：求两个列表(list)交集、差集、并集。

方法1：使用for循环

lia = [1, 2, 3, 4, 5]
lib = [2, 4, 5, 6, 7]
# 交集 两个列表中都有的元素
print([i for i in lia if i in lib])
# 差集 lia中有lib没有
print([j for j in lia if j not in lib])
# 并集 合并lia和lib去重
rest_lia = lia
for k in lib:
    if k not in rest_lia:
        rest_lia.append(k)
print(rest_lia)

输出结果：

[2, 4, 5]
[1, 3]
[1, 2, 3, 4, 5, 6, 7]

方法2：集合（set）

lia = [1, 2, 3, 4, 5]
lib = [2, 4, 5, 6, 7]

# 交集
print(list(set(lia) & set(lib)))
# 差集
print(list(set(lia) - set(lib)))
# 并集
print(list(set(lia)|set(lib)))

输出结果：

[2, 4, 5]
[1, 3]
[1, 2, 3, 4, 5, 6, 7]

习题2：请用简洁方法合并两个list，并且list里面的元素不能重复，最终结果需要排序

方法1：使用set集合

lia = ["a","b","c","d","e","f"]
lib = ["x","y","z","d","e","f"]
rest_list = list(set(lia)|set(lib))
rest_list.sort()
print(rest_list)

输出结果：

['a', 'b', 'c', 'd', 'e', 'f', 'x', 'y', 'z']

方法2：+合并

lia = ["a","b","c","d","e","f"]
lib = ["x","y","z","d","e","f"]

lic = lia + lib
lic.sort()
print(lic)

输出结果：

['a', 'b', 'c', 'd', 'd', 'e', 'e', 'f', 'f', 'x', 'y', 'z']

如何反序迭代序列

Python中常用序列str/list/tuple/dict/set，使用下列方法反序迭代序列元素：

1、使用内置函数reversed()，它的参数可以是str/list/tuple/等序列；

2、利用range()方法获取反向索引，然后从最后元素遍历到最开始元素，实现反序；

3、使用切片[::-1]

4、list列表可以使用内置reverse()方法实现

习题：字符串实现反序

seq = "Hello world"
# 方法1：reversed()
for i in reversed(seq):
    print(i,end="")
print()
# 方法2：切片
print(seq[::-1])
# 方法3：range()
for j in range(len(seq)-1,-1,-1):
    rest = seq[j]
    print(rest,end="")
print()
# 方法4：转换list
seq = list(seq)
seq.reverse()
print("".join(seq))

 排序（正序/反序）

 

Python对序列排序提供了两种方法，一种自带的sort(),另一种内置函数sorted();
sort方法和内置函数sorted()都有key和reverse参数，key参数接收一个函数来实现自定义排序，reverse默认值是False，表示不需要反向排序，如果需要那么将reverse的值设置为True。
sort是列表方法，只能用来对列表进行排序，是在原列表上修改，不会产生新的序列。
sorted()方法可以用于任何可迭代对象（字符串、列表、元组、字典等），它会产生一个新的序列，旧的对象依然存在。

 

 

# 1、list的sort()方法对列表排序
li = [1,5,4,2,6]
li.sort()
print(li)
# 2、内置sorted()方法对列表排序
rest_list = sorted(li)
print(rest_list)
# 3、内置sorted()方法对字符串排序
seq_str = "135426"
rest_str = sorted(seq_str)
print("".join(rest_str))

 

输出结果：

[1, 2, 4, 5, 6]
[1, 2, 4, 5, 6]
123456