那些年被我坑过的Python——不得不知（第二章）

问题一：

　　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	逻辑运算符