那些年被我坑过的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	e	s	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 = '011'
c = '0b1100011'
d = '110'
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	ac12 c '
print(a.islower())
a = 'A	AC12 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
give up	younger!'
# 按指定的分隔符把字符串拆分成列表，默认的分隔符任何空白字符
b = a.split(None, 1)
print(b)

# 按指定的连接符把列表合成字符串，与split()互反
print("	".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 = "13222334455"
# 生成对字符串的字符转换表
trans1 = "".maketrans("123456abcdefg", "fedcba7654321")
# 利用转换表对字符串进行转换
print(a.translate(trans1))

# 字符串替换旧、新、多少个,这里到结尾
print(a.replace('222', 'abc', -1))

a = 'aA123bBccc456DDD123ddd'
# 字母大小写调换，小写变大写，大写变小写
print(a.swapcase())


# 个人感觉用途不大,只分成三段的情况下适用
# 就是按某个分隔符将字符串分为三部分，分别是分隔符前的、分隔符、分隔符后的
print(a.partition('2'))
# 优先从高位遇到的第一个分隔符截
print(a.rpartition('2'))

　　　　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": "1", "b": "1"}

# 字典新增元素，如果key存在则更新，不存在则增加新记录
d_test["b"] = "2"
d_test["c"] = "3"

# 字典新增元素，如果key存在则pass，不存在则增加新记录
d_test.setdefault("c", "4")
d_test.setdefault("d", "5")
print(d_test)

# 实现了两个字典的合并，key存在的，更新value，key不存在则新增记录
d_test1 = {"a": "10", "d": "4", "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	逻辑运算符