问题一：

Python3.5.X中的数据类型有哪些？

答：包括整型、布尔型、字符串型、浮点型、复数、列表、字典、集合、元组。

细化来说：

1、整型包括短整型和长整型，不过我们不必过度操心细节，因为短整型和长整型之间是隐式切换的，Py自己会根据数值大小自行选择适合的整型。

2、字符串型，需要用成对的引号标识，它的内置函方法的使用如下：

1 a = "test for data type"

2 #首字母大写

3 a =a.capitalize()4 print(a)5

6 a = "TEST FOR DATA TYPE"

7 #测试发现是忽略大小写的意思

8 #Return a version of S suitable for caseless comparisons.

9 #返回一个字符串，适用于忽视大小写的字符串对比

10 a =a.casefold()11

12 print(a)13

14 #居中格式化输出的小工具

15 a = a.center(50, "+")16 print(a)17

18 #返回字符串中包含的子串的个数(可以设定起止位置)

19

20 a = "test for data type"

21 print(a.count('t', 0, -5))22

23 #对a进行编码后再解码默认是UTF-8

24 b = a.encode(encoding='gb2312')25 a =b.decode()26 print("after coding change a='", a, "'")27

28 #判断是否以某个子串结尾或是开头

29 print(a.endswith('ype'))30 print(a.startswith('te'))31

32 #设置tab所对应的空格数，便于输出的美化

33 a = 't\te\ts\tt\t'

34 print(a.expandtabs(20))35

36 #返回子串的索引值(可以设定起止位置)

37 print(a.find('t', 0, -1))38 #反向查找(获取的索引还是正常的序)

39 print(a.rfind('t'))40

41 #字符串的格式化输出，这里不再赘述

42 #a.format()

43

44 #获取子串的索引值，这和find()的区别是什么？？？

45 print(a.index('t', 0, -1))46 #反向获取子串的索引值(索引还是正常的序)

47 print(a.rindex('t'))48

49 #判断字符串是否仅由字母和数字构成

50 a = 'aBc123'

51 print(a.isalnum())52

53 #判断是否全是字母构成

54 a = 'aBc'

55 print(a.isalpha())56

57 #判断是否为十进制的

58 a = '0x11'

59 b = '011'

60 c = '0b1100011'

61 d = '110'

62 print('isdecimal', a.isdecimal(), b.isdecimal(), c.isdecimal(), d.isdecimal())63

64 #判断是否为纯数字的,这和isdecimal()有什么区别？

65 #a = '0123'

66 print('isdigit', a.isdigit(), b.isdigit(), c.isdigit(), d.isdigit())67

68 #判断是否为纯数字的,这和isdecimal()有什么区别？这三个函数是不是有重叠的嫌疑？

69 print('isnumeric', a.isnumeric(), b.isnumeric(), c.isnumeric(), d.isnumeric())70

71 #判断是否符合变量的命名规范！

72 print("__Aa123__".isidentifier())73

74 #判断字符串中的字母(忽略其他字符)是否全部为大写字母或是小写字母

75 a = 'a\tac12 c'

76 print(a.islower())77 a = 'A\tAC12 C'

78 print(a.isupper())79

80 #可打印显示出来的字符

81 a = '@*%&$^'

82 print(a.isprintable())83

84 #是不是空格，不解释

85 a = ' '

86 print(a.isspace())87

88 a = 'never give up!'

89 print(a)90 a =a.title()91 print(a)92 print(a.istitle())93

94 a = 'never\ngive up\tyounger!'

95 #按指定的分隔符把字符串拆分成列表，默认的分隔符任何空白字符

96 b = a.split(None, 1)97 print(b)98

99 #按指定的连接符把列表合成字符串，与split()互反

100 print("\t".join(b))101

102 #查找分隔符的方向是从右到左

103 print(a.rsplit(None, 1))104

105 #按换行符号进行分隔

106 print(a.splitlines())107

108 #左对齐，总长固定，空位用单个字符补齐

109 print(a.ljust(50, "t"))110

111 #右对齐，总长固定，空位用单个字符补齐

112 print(a.rjust(50, "t"))113 #右对齐，总长固定，空位用'0'补齐

114 print(a.zfill(50))115

116 #剥离边界上的子串

117 a = "!tree!"

118 print(a.strip("e!"))119 print(a.lstrip("!"))120 print(a.rstrip("!"))121

122 a = "13222334455"

123 #生成对字符串的字符转换表

124 trans1 = "".maketrans("123456abcdefg", "fedcba7654321")125 #利用转换表对字符串进行转换

126 print(a.translate(trans1))127

128 #字符串替换旧、新、多少个,这里到结尾

129 print(a.replace('222', 'abc', -1))130

131 a = 'aA123bBccc456DDD123ddd'

132 #字母大小写调换，小写变大写，大写变小写

133 print(a.swapcase())134

135

136 #个人感觉用途不大,只分成三段的情况下适用

137 #就是按某个分隔符将字符串分为三部分，分别是分隔符前的、分隔符、分隔符后的

138 print(a.partition('2'))139 #优先从高位遇到的第一个分隔符截

140 print(a.rpartition('2'))

View Code

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、列表：列表内置方法简介：

1 #追加一个元素

2 .append("something")3 #在指定的索引位置上插入新元素，原位置以及之后元素依次自动后移

4 .insert()5 ## 通过添加迭代器中的元素实现列表扩展

6 .extend()7

8 #统计某个元素出现的次数

9 .count("re")10

11 #按ASCII码表顺序排

12 .sort()13 #列表内元素倒序输出

14 .reverse()15

16 #浅拷贝

17 .copy()18

19 #按索引号弹出，默认-1即最后一个元素

20 .pop()21 #移除指定元素

22 .remove("re")23 #清空

24 .clear()

View Code

6、字典：字典是无序的，是通过key值找到对应的value，所以key是唯一的！

1 #------------------------------增增增改改改--------------------------------

2 #字典的创建：

3 d_test = {"a": "1", "b": "1"}4

5 #字典新增元素，如果key存在则更新，不存在则增加新记录

6 d_test["b"] = "2"

7 d_test["c"] = "3"

8

9 #字典新增元素，如果key存在则pass，不存在则增加新记录

10 d_test.setdefault("c", "4")11 d_test.setdefault("d", "5")12 print(d_test)13

14 #实现了两个字典的合并，key存在的，更新value，key不存在则新增记录

15 d_test1 = {"a": "10", "d": "4", "f": 100}16 d_test.update(d_test1)17 print(d_test)18

19 #根据key创建一个新字典,第一个参数必须是迭代器类型，第二个参数是给每个key赋的统一值

20 #Returns a new dict with keys from iterable and values equal to value.

21 d_test2 = d_test.fromkeys(["x", "y", "z", "u"], [1, 2, 3, 4])22 print(d_test2)23

24 #---------------------------查查查------------------------------

25 #根据key获取value的两种方法

26 print(d_test["b"], d_test.get("a"))27

28 #判断字典中是否存在某个key

29 print("c" ind_test)30

31 #分别输出'dict_keys dict_values dict_items三个类

32 print(type(d_test.keys()), type(d_test.values()), type(d_test.items()))33 #都可以通过循环遍历的方式获取值

34 for i ind_test.keys():35 print(i)36

37 #对比下列两种获取字典中key value信息的方法

38 #第一种更高效，因为第二种需要将字典先转换为元组后才分别赋值给i,j

39 for i ind_test:40 print(i, d_test[i])41

42 for i, j ind_test.items():43 print(i, j)44

45 #------------------------------删删删---------------------------------

46 #根据key删除字典中的记录

47 d_test.pop("c")48

49 #调用通用方法删除

50 del d_test["a"]51

52 #随机弹出一条记录

53 d_test.popitem()54 print(d_test)55

56 #-------------------------------嵌套------------------------------------

57 #多级嵌套字典的使用，获取数据其实就是从外到内层层打开

58 multi_level_dict_test ={59 "a": {60 "a1": ["a11", "a12"]61 },62 "b": {63 "b1": ["b11", "b12"]64 },65 "c": {66 "c1": ["c11", "c12"]67 }68 }69

70 print(multi_level_dict_test["b"]["b1"][1])71

72

73

74 """

75 字典对象的内置方法：76 d_test.copy()77 d_test.get()78

79 d_test.keys()80 d_test.values()81 d_test.items()82

83 d_test.pop()84 d_test.popitem()85 d_test.clear()86

87 d_test.setdefault()88 d_test.update()89 d_test.fromkeys()90 """

View Code

7、集合：暂略

8、元组：与列表的区别是，不可以更改，只包含两个方法：分别是count()统计某个元素的个数，index()获取某个元素的索引。

问题二：

Python模块是什么？怎么分类，如何调用？

1、Python的模块是什么？

按我我的理解就是一些供其他开发人员使用的.py文件集合而成的目录，实现了代码的重用，缩减开发成本，再简单而言就是前人写好的代码，而且通过import可以拿来即用。

2、怎么分类：

最简单的分类无非就是：标准库和第三方库，标准库包含的更多的是通用型的代码，第三方库是包含着某一个细化领域的深入实现；

3、如何调用这些库？

无非就是使用import或from...import...来实现，两种导入方式的区别？我是这么理解的，import需要将整个模块目录下全部的文件加载，这样如果该模块包含的内容较多的时候不仅会影响效率，也不符合精益理论思想，所以在这种情况下完全可以导入此模块目录下的某一个具体的文件，这样就可以有针对性的加载，from模块目录import Py文件。

问题三：

什么叫切片？怎么使用？

切片是获取一个对象子元素集的方法，比如字符串是由一个个的字符按序构成，列表中的元素也是按序存放，所以对于这种子元素之间有明显顺序关系的对象，就可以通过切片来实现获取它子元素集，说的有点抽象，但举几个例子就清楚了：

1 a="Str is String!"

2

3 #从头到尾

4 print(a[:])5 >>>Str isString!6

7 #从头到最后一个元素之前(不包含最后一个)，-1表示最后一个元素

8 print(a[:-1])9 >>>Str isString10

11 #从第一个元素到尾，说明切片获取的是一个左闭右开的区间

12 print(a[0:])13 >>>Str isString!14

15 #从倒数第五个元素截取到倒数第二个(当然不包含倒数第二个)

16 print(a[-5:-2])17 >>>rin18

19 #这里有意思的来了，截取还可以设定步长，步长step>0 则每隔|step|-1截取一个元素

20 #start和end标识了子串的起止，step决定了截取的间隔。

21 print(a[3:-1:2])22 >>>sSrn23

24 #如果步长为负数，则表示从右向左截取，同时start和end也要使用反向来排列

25 #此时的子串为左开右闭，正好和之前讲的相反，间隔同样是|step|-1

26 print(a[-1:-7:-2])27 >>> !nr

View Code

问题四：

操作符与优先级：(参考自：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

逻辑运算符