您的位置: 首页  >  IT文章  >  那些年被我坑过的Python——不得不知（第二章）

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

分类: IT文章 • 2023-11-05 15:25:15

问题一：

　　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	e	s	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	ac12 c '
 76 print(a.islower())
 77 a = 'A	AC12 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
give up	younger!'
 95 # 按指定的分隔符把字符串拆分成列表，默认的分隔符任何空白字符
 96 b = a.split(None, 1)
 97 print(b)
 98 
 99 # 按指定的连接符把列表合成字符串，与split()互反
100 print("	".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" in d_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 in d_test.keys():
35     print(i)
36 
37 # 对比下列两种获取字典中key value信息的方法
38 # 第一种更高效，因为第二种需要将字典先转换为元组后才分别赋值给i,j
39 for i in d_test:
40     print(i, d_test[i])
41 
42 for i, j in d_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 is String!
 6 
 7 # 从头到最后一个元素之前（不包含最后一个），-1表示最后一个元素
 8 print(a[:-1])
 9 >>>Str is String
10 
11 # 从第一个元素到尾，说明切片获取的是一个左闭右开的区间
12 print(a[0:])
13 >>>Str is String!
14 
15 # 从倒数第五个元素截取到倒数第二个（当然不包含倒数第二个）
16 print(a[-5:-2])
17 >>>rin
18 
19 # 这里有意思的来了，截取还可以设定步长，步长step>0 则每隔|step|-1截取一个元素
20 # start和end标识了子串的起止，step决定了截取的间隔。
21 print(a[3:-1:2])
22 >>> sSrn
23 
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 逻辑运算符

相关推荐