模块初识：
Python 模块(Module)，是一个 Python 文件，以 .py 结尾，包含了 Python 对象定义和Python语句。
模块让你能够有逻辑地组织你的 Python 代码段。
把相关的代码分配到一个模块里能让你的代码更好用，更易懂。
模块能定义函数，类和变量，模块里也能包含可执行的代码。
模块的引入
模块定义好后，我们可以使用 import 语句来引入模块，语法如下：
import module1[, module2[,... moduleN]
比如要引用模块 math，就可以在文件最开始的地方用 import math 来引入。在调用 math 模块中的函数时，必须这样引用：
模块名.函数名
模块分两种：
标准库，不需要安装，python自带的
第三方库，需要安装
标准库例：
sys模块用于提供对解释器相关的操作。
获取当前系统平台
Linux：
>>> sys.platform
'linuxWindows：
In [3]: import sys
In [4]: sys.platform
Out[4]: 'win32'
os模块：
python编程时，经常和文件、目录打交道，这是就离不了os模块。os模块包含普遍的操作系统功能，与具体的平台无关。
os.sep可以取代操作系统特定的路径分隔符。windows下为 “\\”
os.name字符串指示你正在使用的平台。比如对于Windows，它是'nt'，而对于Linux/Unix用户，它是'posix'。
os.getcwd()函数得到当前工作目录，即当前Python脚本工作的目录路径。
os.getenv()获取一个环境变量，如果没有返回none
os.putenv(key, value)设置一个环境变量值
os.listdir(path)返回指定目录下的所有文件和目录名。
os.remove(path)函数用来删除一个文件。
os.system(command)函数用来运行shell命令，直接输出到屏幕，不输出到内存，成功则返回0。
os.linesep字符串给出当前平台使用的行终止符。例如，Windows使用'\r\n'，Linux使用'\n'而Mac使用'\r'。
os.path.split(p)函数返回一个路径的目录名和文件名。
os.path.isfile()和os.path.isdir()函数分别检验给出的路径是一个文件还是目录。
os.path.existe()函数用来检验给出的路径是否真地存在
os.curdir:返回当前目录（'.')
os.chdir(dirname):改变工作目录到dirname
os.path.getsize(name):获得文件大小，如果name是目录返回0L
os.path.abspath(name):获得绝对路径
os.path.normpath(path):规范path字符串形式
os.path.splitext():分离文件名与扩展名
os.path.join(path,name):连接目录与文件名或目录
os.path.basename(path):返回文件名
os.path.dirname(path):返回文件路径
自己写模块
使用import 名称 即可（在同一目录下）默认先在本目录找再去path找
二、pyc是什么
Python的原始代码在运行前都会被先编译成字节码，并把编译的结果保存到一个一个的PyCodeObject中，
pyc 文件即是把PyCodeObject从内存中以marshal格式保存到文件后的结果。
pyc文件是py文件编译后生成的字节码文件(byte code)。pyc文件经过python解释器最终会生成机器码运行。
所以pyc文件是可以跨平台部署的，类似Java的.class文件。一般py文件改变后，都会重新生成pyc文件。
三、python数据类型
标准数据类型
Python3 中有六个标准的数据类型：
- Number（数字）
- String（字符串）
- List（列表）
- Tuple（元组）
- Sets（集合）
- Dictionary（字典）
Number（数字）
Python3 支持 int、float、bool、complex（复数）。
在Python 3里，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。
像大多数语言一样，数值类型的赋值和计算都是很直观的。
内置的 type() 函数可以用来查询变量所指的对象类型。
字符串
如何在Python中使用字符串
a、使用单引号(')
用单引号括起来表示字符串，例如：
str='this is string';
print str;
b、使用双引号(")
双引号中的字符串与单引号中的字符串用法完全相同，例如：
str="this is string";
print str;
c、使用三引号(''')
利用三引号，表示多行的字符串，可以在三引号中自由的使用单引号和双引号，例如：
str='''this is string
this is pythod string
this is string'''
print str;
数据类型转换：
1 int(x [,base]) 将x转换为一个整数 2 float(x ) 将x转换到一个浮点数 3 complex(real [,imag]) 创建一个复数 4 str(x) 将对象x转换为字符串 5 repr(x) 将对象x转换为表达式字符串 6 eval(str) 用来计算在字符串中的有效Python表达式,并返回一个对象 7 tuple(s) 将序列s转换为一个元组 8 list(s) 将序列s转换为一个列表 9 chr(x) 将一个整数转换为一个字符 10 unichr(x) 将一个整数转换为Unicode字符 11 ord(x) 将一个字符转换为它的整数值 12 hex(x) 将一个整数转换为一个十六进制字符串 13 oct(x) 将一个整数转换为一个八进制字符串
运算符类型
Python语言支持以下类型的运算符 -
- 1.算术运算符
- 2.比较(关系)运算符
- 3.赋值运算符
- 4.逻辑运算符
- 5.按位运算符
- 6.成员运算符
- 7.身份运算符
下面让我们依次来看看所有的运算符。
1.算术运算符
假设变量a的值是10，变量b的值是21，则 -
| 运算符 | 描述 | 示例 |
|---|---|---|
+ | 加法运算，将运算符两边的操作数增加。 | a + b = 31 |
- | 减法运算，将运算符左边的操作数减去右边的操作数。 | a – b = -11 |
* | 乘法运算，将运算符两边的操作数相乘 | a * b = 210 |
/ | 除法运算，用右操作数除左操作数 | b / a = 2.1 |
% | 模运算，用右操作数除数左操作数并返回余数 | b % a = 1 |
** | 对运算符进行指数(幂)计算 | a ** b，表示10的21次幂 |
// | 地板除 - 操作数的除法，其结果是删除小数点后的商数。 但如果其中一个操作数为负数，则结果将被保留，即从零(向负无穷大)舍去 | 9//2 = 4 ， 9.0//2.0 = 4.0, -11//3 = -4, -11.0//3 = -4.0 |
2.比较(关系)运算符
比较(关系)运算符比较它们两边的值，并确定它们之间的关系。它们也称为关系运算符。假设变量a的值10，变量b的值是20，则 -
| 运算符 | 描述 | 示例 |
|---|---|---|
== | 如果两个操作数的值相等，则条件为真。 | (a == b)求值结果为 false |
!= | 如果两个操作数的值不相等，则条件为真。 | (a != b)求值结果为 true |
> | 如果左操作数的值大于右操作数的值，则条件成为真。 | (a > b)求值结果为 false |
< | 如果左操作数的值小于右操作数的值，则条件成为真。 | (a < b)求值结果为 true |
>= | 如果左操作数的值大于或等于右操作数的值，则条件成为真。 | (a >= b)求值结果为 false |
<= | 如果左操作数的值小于或等于右操作数的值，则条件成为真。 | (a <= b)求值结果为 true |
3.赋值运算符
假设变量a的值10，变量b的值是20，则 -
| 运算符 | 描述 | 示例 |
|---|---|---|
= | 将右侧操作数的值分配给左侧操作数 | c = a + b表示将a + b的值分配给c |
+= | 将右操作数相加到左操作数，并将结果分配给左操作数 | c + = a等价于c = c + a |
-= | 从左操作数中减去右操作数，并将结果分配给左操作数 | c -= a 等价于 c = c - a |
*= | 将右操作数与左操作数相乘，并将结果分配给左操作数 | c *= a 等价于 c = c * a |
/= | 将左操作数除以右操作数，并将结果分配给左操作数 | c /= a 等价于 c = c / a |
%= | 将左操作数除以右操作数的模数，并将结果分配给左操作数 | c %= a 等价于 c = c % a |
**= | 执行指数(幂)计算，并将值分配给左操作数 | c **= a 等价于 c = c ** a |
//= | 运算符执行地板除运算，并将值分配给左操作数 | c //= a 等价于 c = c // a |
4.逻辑运算符
Python语言支持以下逻辑运算符。假设变量a的值为True，变量b的值为False，那么 -
| 运算符 | 描述 | 示例 |
|---|---|---|
and | 如果两个操作数都为真，则条件成立。 | (a and b)的结果为False |
or | 如果两个操作数中的任何一个非零，则条件成为真。 | (a or b)的结果为True |
not | 用于反转操作数的逻辑状态。 | not(a and b) 的结果为True。 |
5.按位运算符
按位运算符执行逐位运算。 假设变量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的内置函数bin()可用于获取整数的二进制表示形式。
以下是Python语言支持位运算操作符 -
| 运算符 | 描述 | 示例 |
|---|---|---|
& | 如果它存在于两个操作数中，则操作符复制位到结果中 | (a & b) 结果表示为 0000 1100 |
| | | 如果它存在于任一操作数，则复制位。 | (a|b) = 61 结果表示为 0011 1101 |
^ | 二进制异或。如果它是一个操作数集合，但不是同时是两个操作数则将复制位。 | (a ^ b) = 49 (结果表示为 0011 0001) |
~ | 二进制补码，它是一元的，具有“翻转”的效果。 | (~a ) = -61有符号的二进制数，表示为1100 0011的补码形式。 |
<< | 二进制左移，左操作数的值由右操作数指定的位数左移。 | a << 2 = 240 (结果表示为 1111 0000) |
>> | 二进制右移，左操作数的值由右操作数指定的位数右移。 | a >> 2 = 15(结果表示为0000 1111) |
6.成员运算符
Python成员运算符测试给定值是否为序列中的成员，例如字符串，列表或元组。 有两个成员运算符，如下所述 -
| 运算符 | 描述 | 示例 |
|---|---|---|
in | 如果在指定的序列中找到一个变量的值，则返回true，否则返回false。 | - |
not in | 如果在指定序列中找不到变量的值，则返回true，否则返回false。 | - |
7.身份运算符
身份运算符比较两个对象的内存位置。常用的有两个身份运算符，如下所述 -
| 运算符 | 描述 | 示例 |
|---|---|---|
is | 如果运算符任一侧的变量指向相同的对象，则返回True，否则返回False。 | |
is not | 如果运算符任一侧的变量指向相同的对象，则返回True，否则返回False。 | - |
8. 运算符优先级
下表列出了从最高优先级到最低优先级的所有运算符，如下所示 -
| 序号 | 运算符 | 描述 |
|---|---|---|
| 1 | ** | 指数(次幂)运算 |
| 2 | ~ + - | 补码，一元加减(最后两个的方法名称是+@和-@) |
| 3 | * / % // | 乘法，除法，模数和地板除 |
| 4 | + - | |
| 5 | >> << | 向右和向左位移 |
| 6 | & | 按位与 |
| 7 | ^ | 按位异或和常规的“OR” |
| 8 | <= < > >= | 比较运算符 |
| 9 | <> == != | 等于运算符 |
| 10 | = %= /= //= -= += *= **= | 赋值运算符 |
| 11 | is is not | 身份运算符 |
| 12 | in not in | 成员运算符 |
| 13 | not or and | 逻辑运算符 |
进制：
整数之间的进制转换:
- 10进制转16进制: hex(16) ==> 0x10
- 16进制转10进制: int('0x10', 16) ==> 16
类似的还有oct()， bin()
-------------------
字符串转整数:
- 10进制字符串: int('10') ==> 10
- 16进制字符串: int('10', 16) ==> 16
- 16进制字符串: int('0x10', 16) ==> 16
-------------------
字节串转整数:
- 转义为short型整数: struct.unpack('<hh', bytes(b'\x01\x00\x00\x00')) ==> (1, 0)
- 转义为long型整数: struct.unpack('<L', bytes(b'\x01\x00\x00\x00')) ==> (1,)
-------------------
整数转字节串:
- 转为两个字节: struct.pack('<HH', 1,2) ==> b'\x01\x00\x02\x00'
- 转为四个字节: struct.pack('<LL', 1,2) ==> b'\x01\x00\x00\x00\x02\x00\x00\x00'
-------------------
字符串转字节串:
- 字符串编码为字节码: '12abc'.encode('ascii') ==> b'12abc'
- 数字或字符数组: bytes([1,2, ord('1'),ord('2')]) ==> b'\x01\x0212'
- 16进制字符串: bytes().fromhex('010210') ==> b'\x01\x02\x10'
- 16进制字符串: bytes(map(ord, '\x01\x02\x31\x32')) ==> b'\x01\x0212'
- 16进制数组: bytes([0x01,0x02,0x31,0x32]) ==> b'\x01\x0212'
-------------------
字节串转字符串:
-
- 字节码解码为字符串: bytes(b'\x31\x32\x61\x62').decode('ascii') ==> 12ab
- 字节串转16进制表示,夹带ascii: str(bytes(b'\x01\x0212'))[2:-1] ==> \x01\x0212
- 字节串转16进制表示,固定两个字符表示: str(binascii.b2a_hex(b'\x01\x0212'))[2:-1] ==> 01023132
- 字节串转16进制数组: [hex(x) for x in bytes(b'\x01\x0212')] ==> ['0x1', '0x2', '0x31', '0x32']
列表
列表是Python中最基本的数据结构，列表是最常用的Python数据类型，列表的数据项不需要具有相同的类型。列表中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。
Python有6个序列的内置类型，但最常见的是列表和元组。序列都可以进行的操作包括索引，切片，加，乘，检查成员。此外，Python已经内置确定序列的长度以及确定最大和最小的元素的方法。
一、创建一个列表
只要把逗号分隔的不同的数据项使用方括号括起来即可。
与字符串的索引一样，列表索引从0开始。列表可以进行截取、组合等。
二、访问列表中的值
使用下标索引来访问列表中的值，同样你也可以使用方括号的形式截取字符。
三、更新列表
你可以对列表的数据项进行修改或更新，你也可以使用append()方法来添加列表项
四、删除列表元素
可以使用 del 语句来删除列表的的元素
del xxx[位置下标]
五、Python列表脚本操作符
列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表
六、Python列表截取
Python的列表截取与字符串操作类型，如下所示：
操作：
| Python 表达式 | 结果 | 描述 |
|---|---|---|
| L[2] | 'SPAM!' | 读取列表中第三个元素 |
| L[-2] | 'Spam' | 读取列表中倒数第二个元素 |
| L[1:] | ['Spam', 'SPAM!'] | 从第二个元素开始截取列表 |
七、Python列表操作的函数和方法
列表操作包含以下函数:
1、cmp(list1, list2)：比较两个列表的元素
2、len(list)：列表元素个数
3、max(list)：返回列表元素最大值
4、min(list)：返回列表元素最小值
5、list(seq)：将元组转换为列表
列表操作包含以下方法:
1、list.append(obj)：在列表末尾添加新的对象
2、list.count(obj)：统计某个元素在列表中出现的次数
3、list.extend(seq)：在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
4、list.index(obj)：从列表中找出某个值第一个匹配项的索引位置
5、list.insert(index, obj)：将对象插入列表
6、list.pop(obj=list[-1])：移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
7、list.remove(obj)：移除列表中某个值的第一个匹配项
8、list.reverse()：反向列表中元素
9、list.sort([func])：对原列表进行排序
10、list.copy() 浅copy，只复制第一层列表，第二层复制的是内存地址
三种浅copy
1 p1 = copy.copy(person) 2 p2 = person[:] 3 p3 = list(person)
要深入copy，需要导入copy模块
import copy copy.deepcopy() for i in names: print(i)
元组
Python的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号，列表使用方括号。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
Python元组包含了以下内置函数
1、cmp(tuple1, tuple2)：比较两个元组元素。
2、len(tuple)：计算元组元素个数。
3、max(tuple)：返回元组中元素最大值。
4、min(tuple)：返回元组中元素最小值。
5、tuple(seq)：将列表转换为元组。
字符串
字符串是 Python 中最常用的数据类型。我们可以使用引号('或")来创建字符串。
创建字符串很简单，只要为变量分配一个值即可。
Python不支持单字符类型，单字符也在Python也是作为一个字符串使用。
Python访问子字符串，可以使用方括号来截取字符串
在需要在字符中使用特殊字符时，python用反斜杠(\)转义字符。如下表：
| 转义字符 | 描述 |
|---|---|
| \(在行尾时) | 续行符 |
| \\ | 反斜杠符号 |
| \' | 单引号 |
| \" | 双引号 |
| \a | 响铃 |
| \b | 退格(Backspace) |
| \e | 转义 |
| \000 | 空 |
| \n | 换行 |
| \v | 纵向制表符 |
| \t | 横向制表符 |
| \r | 回车 |
| \f | 换页 |
| \oyy | 八进制数，yy代表的字符，例如：\o12代表换行 |
| \xyy | 十六进制数，yy代表的字符，例如：\x0a代表换行 |
| \other | 其它的字符以普通格式输出 |
下表实例变量 a 值为字符串 "Hello"，b 变量值为 "Python"：
| 操作符 | 描述 | 实例 |
|---|---|---|
| + | 字符串连接 |
>>>a + b 'HelloPython'
|
| * | 重复输出字符串 |
>>>a * 2 'HelloHello'
|
| [] | 通过索引获取字符串中字符 |
>>>a[1] 'e'
|
| [ : ] | 截取字符串中的一部分 |
>>>a[1:4] 'ell'
|
| in | 成员运算符 - 如果字符串中包含给定的字符返回 True |
>>>"H" in a True
|
| not in | 成员运算符 - 如果字符串中不包含给定的字符返回 True |
>>>"M" not in a True
|
| r/R | 原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母"r"（可以大小写）以外，与普通字符串有着几乎完全相同的语法。 |
>>>print r'\n' \n >>> print R'\n' \n
|
| % | 格式字符串 |
Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。
python字符串格式化符号:
<tbody| 符 号 | 描述 |
|---|---|
| %c | 格式化字符及其ASCII码 |
| %s | 格式化字符串 |
| %d | 格式化整数 |
| %u | 格式化无符号整型 |
| %o | 格式化无符号八进制数 |
| %x | 格式化无符号十六进制数 |
| %X | 格式化无符号十六进制数（大写） |
| %f | 格式化浮点数字，可指定小数点后的精度 |
| %e | 用科学计数法格式化浮点数 |
| %E | 作用同%e，用科学计数法格式化浮点数 |
| %g | %f和%e的简写 |
| %G | %f 和 %E 的简写 |
| %p | 用十六进制数格式化变量的地址 |
格式化操作符辅助指令:
| 符号 | 功能 |
|---|---|
| * | 定义宽度或者小数点精度 |
| - | 用做左对齐 |
| + | 在正数前面显示加号( + ) |
| <sp> | 在正数前面显示空格 |
| # | 在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X') |
| 0 | 显示的数字前面填充'0'而不是默认的空格 |
| % | '%%'输出一个单一的'%' |
| (var) | 映射变量(字典参数) |
| m.n. | m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话) |
Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。
Python三引号（triple quotes）
python中三引号可以将复杂的字符串进行复制:
python三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。
三引号的语法是一对连续的单引号或者双引号（通常都是成对的用）。
>>> hi = '''hi there''' >>> hi # repr() 'hi\nthere' >>> print hi # str() hi there
三引号让程序员从引号和特殊字符串的泥潭里面解脱出来，自始至终保持一小块字符串的格式是所谓的WYSIWYG（所见即所得）格式的。
一个典型的用例是，当你需要一块HTML或者SQL时，这时用字符串组合，特殊字符串转义将会非常的繁琐。
errHTML = '''
<HTML><HEAD><TITLE>
Friends CGI Demo</TITLE></HEAD>
<BODY><H3>ERROR</H3>
<B>%s</B><P>
<FORM><INPUT TYPE=button VALUE=Back
ONCLICK="window.history.back()"></FORM>
</BODY></HTML>
'''
cursor.execute(''' CREATE TABLE users ( login VARCHAR(8), uid INTEGER, prid INTEGER) ''')
Unicode 字符串
Python 中定义一个 Unicode 字符串和定义一个普通字符串一样简单：
>>> u'Hello World !'
u'Hello World !'
引号前小写的"u"表示这里创建的是一个 Unicode 字符串。如果你想加入一个特殊字符，可以使用 Python 的 Unicode-Escape 编码。如下例所示：
>>> u'Hello\u0020World !'
u'Hello World !'
被替换的 \u0020 标识表示在给定位置插入编码值为 0x0020 的 Unicode 字符（空格符）。
python的字符串内建函数
字符串方法是从python1.6到2.0慢慢加进来的——它们也被加到了Jython中。
这些方法实现了string模块的大部分方法，如下表所示列出了目前字符串内建支持的方法，所有的方法都包含了对Unicode的支持，有一些甚至是专门用于Unicode的。
| 方法 | 描述 |
|---|---|
| 把字符串的第一个字符大写 | |
| 返回一个原字符串居中,并使用空格填充至长度 width 的新字符串 | |
| 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数 | |
| 以 encoding 指定的编码格式解码 string，如果出错默认报一个 ValueError 的 异 常 ， 除 非 errors 指 定 的 是 'ignore' 或 者'replace' | |
| 以 encoding 指定的编码格式编码 string，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace' | |
| 检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False. | |
| 把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8。 | |
| 检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1 | |
| 格式化字符串 | |
| 跟find()方法一样，只不过如果str不在 string中会报一个异常. | |
| 如果 string 至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False | |
| 如果 string 至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False | |
| 如果 string 只包含十进制数字则返回 True 否则返回 False. | |
| 如果 string 只包含数字则返回 True 否则返回 False. | |
| 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False | |
| 如果 string 中只包含数字字符，则返回 True，否则返回 False | |
| 如果 string 中只包含空格，则返回 True，否则返回 False. | |
| 如果 string 是标题化的(见 title())则返回 True，否则返回 False | |
| 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False | |
| 以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串 | |
| 返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串 | |
| 转换 string 中所有大写字符为小写. | |
| 截掉 string 左边的空格 | |
| maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。 | |
| 返回字符串 str 中最大的字母。 | |
| 返回字符串 str 中最小的字母。 | |
| 有点像 find()和 split()的结合体,从 str 出现的第一个位置起,把 字 符 串 string 分 成 一 个 3 元 素 的 元 组 (string_pre_str,str,string_post_str),如果 string 中不包含str 则 string_pre_str == string. | |
| 把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次. | |
| 类似于 find()函数，不过是从右边开始查找. | |
| 类似于 index()，不过是从右边开始. | |
| 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串 | |
| string.rpartition(str) | 类似于 partition()函数,不过是从右边开始查找. |
| 删除 string 字符串末尾的空格. | |
| 以 str 为分隔符切片 string，如果 num有指定值，则仅分隔 num 个子字符串 | |
| 按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。 | |
| 检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查. | |
| 在 string 上执行 lstrip()和 rstrip() | |
| 翻转 string 中的大小写 | |
| 返回"标题化"的 string,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle()) | |
| 根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 del 参数中 | |
| 转换 string 中的小写字母为大写 | |
| 返回长度为 width 的字符串，原字符串 string 右对齐，前面填充0 | |
| isdecimal()方法检查字符串是否只包含十进制字符。这种方法只存在于unicode对象。 |
扫一扫
到【灌水乐园】发言
