问题一：
Python3.5.X中的数据类型有哪些？
答：包括整型、布尔型、字符串型、浮点型、复数、列表、字典、集合、元组。
细化来说：
1、整型包括短整型和长整型，不过我们不必过度操心细节，因为短整型和长整型之间是隐式切换的，Py自己会根据数值大小自行选择适合的整型。
2、字符串型，需要用成对的引号标识，它的内置函方法的使用如下：
a = "test for data type"
# 首字母大写
a = a.capitalize()
print(a) a = "TEST FOR DATA TYPE"
# 测试发现是忽略大小写的意思
# Return a version of S suitable for caseless comparisons.
# 返回一个字符串，适用于忽视大小写的字符串对比
a = a.casefold() print(a) # 居中格式化输出的小工具
a = a.center(50, "+")
print(a) # 返回字符串中包含的子串的个数（可以设定起止位置） a = "test for data type"
print(a.count('t', 0, -5)) # 对a进行编码后再解码默认是UTF-8
b = a.encode(encoding='gb2312')
a = b.decode()
print("after coding change a='", a, "'") # 判断是否以某个子串结尾或是开头
print(a.endswith('ype'))
print(a.startswith('te')) # 设置tab所对应的空格数，便于输出的美化
a = 't\te\ts\tt\t'
print(a.expandtabs(20)) # 返回子串的索引值(可以设定起止位置)
print(a.find('t', 0, -1))
# 反向查找（获取的索引还是正常的序）
print(a.rfind('t')) # 字符串的格式化输出，这里不再赘述
# a.format() # 获取子串的索引值，这和find()的区别是什么？？？
print(a.index('t', 0, -1))
# 反向获取子串的索引值（索引还是正常的序）
print(a.rindex('t')) # 判断字符串是否仅由字母和数字构成
a = 'aBc123'
print(a.isalnum()) # 判断是否全是字母构成
a = 'aBc'
print(a.isalpha()) # 判断是否为十进制的
a = '0x11'
b = ''
c = '0b1100011'
d = ''
print('isdecimal', a.isdecimal(), b.isdecimal(), c.isdecimal(), d.isdecimal()) # 判断是否为纯数字的,这和isdecimal()有什么区别？
# a = '0123'
print('isdigit', a.isdigit(), b.isdigit(), c.isdigit(), d.isdigit()) # 判断是否为纯数字的,这和isdecimal()有什么区别？这三个函数是不是有重叠的嫌疑？
print('isnumeric', a.isnumeric(), b.isnumeric(), c.isnumeric(), d.isnumeric()) # 判断是否符合变量的命名规范！
print("__Aa123__".isidentifier()) # 判断字符串中的字母（忽略其他字符）是否全部为大写字母或是小写字母
a = 'a\tac12 c '
print(a.islower())
a = 'A\tAC12 C '
print(a.isupper()) # 可打印显示出来的字符
a = '@*%&$^'
print(a.isprintable()) # 是不是空格，不解释
a = ' '
print(a.isspace()) a = 'never give up!'
print(a)
a = a.title()
print(a)
print(a.istitle()) a = 'never\ngive up\tyounger!'
# 按指定的分隔符把字符串拆分成列表，默认的分隔符任何空白字符
b = a.split(None, 1)
print(b) # 按指定的连接符把列表合成字符串，与split()互反
print("\t".join(b)) # 查找分隔符的方向是从右到左
print(a.rsplit(None, 1)) # 按换行符号进行分隔
print(a.splitlines()) # 左对齐，总长固定，空位用单个字符补齐
print(a.ljust(50, "t")) # 右对齐，总长固定，空位用单个字符补齐
print(a.rjust(50, "t"))
# 右对齐，总长固定，空位用'0'补齐
print(a.zfill(50)) # 剥离边界上的子串
a = "!tree!"
print(a.strip("e!"))
print(a.lstrip("!"))
print(a.rstrip("!")) a = ""
# 生成对字符串的字符转换表
trans1 = "".maketrans("123456abcdefg", "fedcba7654321")
# 利用转换表对字符串进行转换
print(a.translate(trans1)) # 字符串替换旧、新、多少个,这里到结尾
print(a.replace('', 'abc', -1)) a = 'aA123bBccc456DDD123ddd'
# 字母大小写调换，小写变大写，大写变小写
print(a.swapcase()) # 个人感觉用途不大,只分成三段的情况下适用
# 就是按某个分隔符将字符串分为三部分，分别是分隔符前的、分隔符、分隔符后的
print(a.partition(''))
# 优先从高位遇到的第一个分隔符截
print(a.rpartition(''))
3、浮点型：需要注意科学计数法的表示：
如：1.2345E+1表示：1.2345*（10**1）=12.345
1.2345E-1表示：1.2345*（10**-1）=0.12345
4、复数：表示方法参照 4+8j，注意其中使用虚数部分用 j 标识而不是数学书上的 i，因为这里采用的是工程标准
5、列表：列表内置方法简介：
# 追加一个元素
.append("something")
# 在指定的索引位置上插入新元素，原位置以及之后元素依次自动后移
.insert()
# # 通过添加迭代器中的元素实现列表扩展
.extend() # 统计某个元素出现的次数
.count("re") # 按ASCII码表顺序排
.sort()
# 列表内元素倒序输出
.reverse() # 浅拷贝
.copy() # 按索引号弹出，默认-1即最后一个元素
.pop()
# 移除指定元素
.remove("re")
# 清空
.clear()
6、字典：字典是无序的，是通过key值找到对应的value，所以key是唯一的！
# ------------------------------增增增改改改--------------------------------
# 字典的创建：
d_test = {"a": "", "b": ""} # 字典新增元素，如果key存在则更新，不存在则增加新记录
d_test["b"] = ""
d_test["c"] = "" # 字典新增元素，如果key存在则pass，不存在则增加新记录
d_test.setdefault("c", "")
d_test.setdefault("d", "")
print(d_test) # 实现了两个字典的合并，key存在的，更新value，key不存在则新增记录
d_test1 = {"a": "", "d": "", "f": 100}
d_test.update(d_test1)
print(d_test) # 根据key创建一个新字典,第一个参数必须是迭代器类型，第二个参数是给每个key赋的统一值
# Returns a new dict with keys from iterable and values equal to value.
d_test2 = d_test.fromkeys(["x", "y", "z", "u"], [1, 2, 3, 4])
print(d_test2) # ---------------------------查查查------------------------------
# 根据key获取value的两种方法
print(d_test["b"], d_test.get("a")) # 判断字典中是否存在某个key
print("c" in d_test) # 分别输出'dict_keys dict_values dict_items三个类
print(type(d_test.keys()), type(d_test.values()), type(d_test.items()))
# 都可以通过循环遍历的方式获取值
for i in d_test.keys():
print(i) # 对比下列两种获取字典中key value信息的方法
# 第一种更高效，因为第二种需要将字典先转换为元组后才分别赋值给i,j
for i in d_test:
print(i, d_test[i]) for i, j in d_test.items():
print(i, j) # ------------------------------删删删---------------------------------
# 根据key删除字典中的记录
d_test.pop("c") # 调用通用方法删除
del d_test["a"] # 随机弹出一条记录
d_test.popitem()
print(d_test) # -------------------------------嵌套------------------------------------
# 多级嵌套字典的使用，获取数据其实就是从外到内层层打开
multi_level_dict_test = {
"a": {
"a1": ["a11", "a12"]
},
"b": {
"b1": ["b11", "b12"]
},
"c": {
"c1": ["c11", "c12"]
}
} print(multi_level_dict_test["b"]["b1"][1]) """
字典对象的内置方法：
d_test.copy()
d_test.get() d_test.keys()
d_test.values()
d_test.items() d_test.pop()
d_test.popitem()
d_test.clear() d_test.setdefault()
d_test.update()
d_test.fromkeys()
"""
7、集合：暂略
8、元组：与列表的区别是，不可以更改，只包含两个方法：分别是count（）统计某个元素的个数，index（）获取某个元素的索引。
问题二：
Python模块是什么？怎么分类，如何调用？
1、Python的模块是什么？
按我我的理解就是一些供其他开发人员使用的.py文件集合而成的目录，实现了代码的重用，缩减开发成本，再简单而言就是前人写好的代码，而且通过import可以拿来即用。
2、怎么分类：
最简单的分类无非就是：标准库和第三方库，标准库包含的更多的是通用型的代码，第三方库是包含着某一个细化领域的深入实现；
3、如何调用这些库？
无非就是使用import或from...import...来实现，两种导入方式的区别？我是这么理解的，import需要将整个模块目录下全部的文件加载，这样如果该模块包含的内容较多的时候不仅会影响效率，也不符合精益理论思想，所以在这种情况下完全可以导入此模块目录下的某一个具体的文件，这样就可以有针对性的加载，from模块目录import Py文件。
问题三：
什么叫切片？怎么使用？
切片是获取一个对象子元素集的方法，比如字符串是由一个个的字符按序构成，列表中的元素也是按序存放，所以对于这种子元素之间有明显顺序关系的对象，就可以通过切片来实现获取它子元素集，说的有点抽象，但举几个例子就清楚了：
a="Str is String!" # 从头到尾
print(a[:])
>>>Str is String! # 从头到最后一个元素之前（不包含最后一个），-1表示最后一个元素
print(a[:-1])
>>>Str is String # 从第一个元素到尾，说明切片获取的是一个左闭右开的区间
print(a[0:])
>>>Str is String! # 从倒数第五个元素截取到倒数第二个（当然不包含倒数第二个）
print(a[-5:-2])
>>>rin # 这里有意思的来了，截取还可以设定步长，步长step>0 则每隔|step|-1截取一个元素
# start和end标识了子串的起止，step决定了截取的间隔。
print(a[3:-1:2])
>>> sSrn # 如果步长为负数，则表示从右向左截取，同时start和end也要使用反向来排列
# 此时的子串为左开右闭，正好和之前讲的相反，间隔同样是|step|-1
print(a[-1:-7:-2])
>>> !nr
问题四：
操作符与优先级：（参考自：http://www.yiibai.com/python/python_basic_operators.html）
操作符
| 描述符 | 例子 | |
|---|---|---|
| + | 加法 - 对操作符的两侧增加值 | a + b = 30 |
| - | 减法 - 减去从左侧操作数右侧操作数 | a - b = -10 |
| * | 乘法 - 相乘的运算符两侧的值 | a * b = 200 |
| / | 除 - 由右侧操作数除以左侧操作数 | b / a = 2 |
| % | 模 - 由右侧操作数和余返回除以左侧操作数 | b % a = 0 |
| ** | 指数- 执行对操作指数（幂）的计算 | a**b = 10 的幂 20 |
| // | 地板除 - 操作数的除法，其中结果是将小数点后的位数被除去的商。 | 9//2 = 4 而 9.0//2.0 = 4.0 |
Python的比较操作符：
假设变量a持有10和变量b持有20，则：
| 运算符 | 描述 | 示例 |
|---|---|---|
| == | 检查，两个操作数的值是否相等，如果是则条件变为真。 | (a == b) 不为 true. |
| != | 检查两个操作数的值是否相等，如果值不相等，则条件变为真。 | (a != b) 为 true. |
| <> | 检查两个操作数的值是否相等，如果值不相等，则条件变为真。 | (a <> b) 为 true。这个类似于 != 运算符 |
| > | 检查左操作数的值是否大于右操作数的值，如果是，则条件成立。 | (a > b) 不为 true. |
| < | 检查左操作数的值是否小于右操作数的值，如果是，则条件成立。 | (a < b) 为 true. |
| >= | 检查左操作数的值是否大于或等于右操作数的值，如果是，则条件成立。 | (a >= b) 不为 true. |
| <= | 检查左操作数的值是否小于或等于右操作数的值，如果是，则条件成立。 | (a <= b) 为 true. |
Python赋值运算符：
假设变量持有10和变量b持有20，则：
| 运算符 | 描述 | 示例 |
|---|---|---|
| = | 简单的赋值运算符，赋值从右侧操作数左侧操作数 | c = a + b将指定的值 a + b 到 c |
| += | 加法AND赋值操作符，它增加了右操作数左操作数和结果赋给左操作数 | c += a 相当于 c = c + a |
| -= | 减AND赋值操作符，它减去右边的操作数从左边操作数，并将结果赋给左操作数 | c -= a 相当于 c = c - a |
| *= | 乘法AND赋值操作符，它乘以右边的操作数与左操作数，并将结果赋给左操作数 | c *= a 相当于 c = c * a |
| /= | 除法AND赋值操作符，它把左操作数与正确的操作数，并将结果赋给左操作数 | c /= a 相当于= c / a |
| %= | 模量AND赋值操作符，它需要使用两个操作数的模量和分配结果左操作数 | c %= a is equivalent to c = c % a |
| **= | 指数AND赋值运算符，执行指数（功率）计算操作符和赋值给左操作数 | c **= a 相当于 c = c ** a |
| //= | 地板除，并分配一个值，执行地板除对操作和赋值给左操作数 | c //= a 相当于 c = c // a |
Python位运算符：
位运算符作用于位和位操作执行位。假设，如果a =60;且b =13;现在以二进制格式它们将如下：
a = 0011 1100
b = 0000 1101
-----------------
a&b = 0000 1100
a|b = 0011 1101
a^b = 0011 0001
~a = 1100 0011
Python语言支持下位运算符
| 操作符 | 描述 | 示例 |
|---|---|---|
| & | 二进制和复制操作了一下，结果，如果它存在于两个操作数。 | (a & b) = 12 即 0000 1100 |
| | | 二进制或复制操作了一个比特，如果它存在一个操作数中。 | (a | b) = 61 即 0011 1101 |
| ^ | 二进制异或运算符的副本，如果它被设置在一个操作数而不是两个比特。 | (a ^ b) = 49 即 0011 0001 |
| ~ | 二进制的补运算符是一元的，并有“翻转”位的效果。 | (~a ) = -61 即 1100 0011以2的补码形式由于带符号二进制数。 |
| << | 二进位向左移位运算符。左操作数的值左移由右操作数指定的位数。 | a << 2 = 240 即 1111 0000 |
| >> | 二进位向右移位运算符。左操作数的值是由右操作数指定的位数向右移动。 | a >> 2 = 15 即 0000 1111 |
Python逻辑运算符：
Python语言支持以下逻辑运算符。假设变量a持有10和变量b持有20则：
| 运算符 | 描述 | 示例 |
|---|---|---|
| and | 所谓逻辑与运算符。如果两个操作数都是真的，那么则条件成立。 | (a and b) 为 true. |
| or | 所谓逻辑OR运算符。如果有两个操作数都是非零然后再条件变为真。 | (a or b) 为 true. |
| not | 所谓逻辑非运算符。用于反转操作数的逻辑状态。如果一个条件为真，则逻辑非运算符将返回false。 | not(a and b) 为 false. |
Python成员运算符：
除了前面讨论的运算符，Python成员运算符，在一个序列中成员资格的测试，如字符串，列表或元组。有两个成员运算符解释如下：
| 操作符 | 描述 | 示例 |
|---|---|---|
| in | 计算结果为true，如果它在指定找到变量的顺序，否则false。 | x在y中，在这里产生一个1，如果x是序列y的成员。 |
| not in | 计算结果为true，如果它不找到在指定的变量顺序，否则为false。 | x不在y中，这里产生结果不为1，如果x不是序列y的成员。 |
Python标识运算符：
标识符比较两个对象的内存位置。两个运算符标识解释如下：
| 运算符 | 描述 | 例子 |
|---|---|---|
| is | 计算结果为true，如果操作符两侧的变量指向相同的对象，否则为false。 | x是y，这里结果是1，如果id（x）的值为id（y）。 |
| is not | 计算结果为false，如果两侧的变量操作符指向相同的对象，否则为true。 | x不为y，这里结果不是1，当id（x）不等于id（y）。 |
Python运算符优先级
下表列出了所有运算符从最高优先级到最低。
| 运算符 | 描述 |
|---|---|
| ** | 幂（提高到指数） |
| ~ + - | 补码，一元加号和减号（方法名的最后两个+@和 - @） |
| * / % // | 乘，除，取模和地板除 |
| + - | 加法和减法 |
| >> << | 左，右按位转移 |
| & | 位'AND' |
| ^ | | 按位异'或`'和定期`或' |
| <= < > >= | 比较运算符 |
| <> == != | 等式运算符 |
| = %= /= //= -= += *= **= | 赋值运算符 |
| is is not | 标识运算符 |
| in not in | 成员运算符 |
| not or and | 逻辑运算符 |