什么是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