Python 基础知识

前言

本文章主要简单介绍 python 的基本语法，是笔者在自学的过程中慢慢总结的，如果这其中有什么错误，大家可以及时提出来。

列表、字典、元组、字符串

列表

列表是一个值，它包含多个字构成的序列

列表用左方括号开始，右方括号结束，即[]

表中的值称为表项，用逗号隔开

1.1 用下标取得列表中的单个值

列表中第一个下标是0，第2个是1，以此类推
>>> spam = ['cat','dog','pig']
>>> spam [1]
'dog'
>>> spam = [['cat','dog'],[1,2,3]]
>>> spam[0][1]
'dog'

1.2 负数下标

数值-1指的是列表中的最后一个下标，-2指的是列表中倒数第二个下标，以此类推
>>> spam = ['cat','bat','rat']
>>> spam[-1]
'rat'

1.3 利用切片取得子列表

在一个切片中，第一个整数是切片开始处的下标，第二个整数是切片结束处的下标。切片向上增长，直至第二个下标的值，但不包括它。

其中，省略第一个下标相当于使用 0，或列表的开始；省略第二个下标相当于使用列表的长度，意味着分片直至列表的末尾

>>> spam = ['cat','bat','rat']
>>> spam[0:2]
['cat', 'bat']

1.4 用 len()取得列表的长度

>>> spam = ['cat','bat','rat']
>>> len(spam)
3

1.5 用下标改变列表的值

>>> spam = ['cat','bat','rat']
>>> spam[0]='pig'
>>> spam
['pig', 'bat', 'rat']

1.6 列表链接和列表复制

>>> [1,2,3] + ['cat','rat','pig']
[1, 2, 3, 'cat', 'rat', 'pig']

>>> [1,2,3] * 3
[1, 2, 3, 1, 2, 3, 1, 2, 3]

1.7 用 del 语句从列表中删除值

>>> spam = ['cat','bat','rat']
>>> del spam[0]
>>> spam
['bat', 'rat']

字典

字典是许多值的集合，字典的索引可以使用许多不同数据类型，不只是整数。字典的索引被称为“键”，键及其关联的值称为“键-值”对。

字典输入时带花括号{}

字典中的表项是不排序的，所以不能像列表那样切片

spam = {'name': 'branda','age': 22}

新增 value 值

info = {
    "student001":"branda",
    "student002":"hzy",
    "student003":"wj"
}
info["student001"] = "sandy"
print(info)
运行结果：
{'student001': 'sandy', 'student002': 'hzy', 'student003': 'wj'}

新增一对键值

info = {
    "student001":"branda",
    "student002":"hzy",
    "student003":"wj"
}
info["student004"] = "candy"
print(info)
运行结果：
{'student001': 'branda', 'student002': 'hzy', 'student003': 'wj', 'student004': 'candy'}

删除操作

del info[student004]

元组

元组输入时用圆括号（）

元组不能让它们的值被修改、添加或删除

元组其实和列表差不多，也是存一组数，只是它一旦创建，就不能被修改

元组只有两种方法，一个是 count，一个是 index

如果元组中只有一个值，你可以在括号内该值的后面跟上一个逗号，告诉 python 这是一个元组；否则，python 将认为，你只是在一个普通括号内输入了一个值。

>>> type(('hello',))
<class 'tuple'>
>>> type(('hello'))
<class 'str'>

元组进行连接组合

>>> tup1 = (1,2,3)
>>> tup2 = ('cat','rat')
>>> tup3 = tup1 + tup2
>>> tup3
(1, 2, 3, 'cat', 'rat')

元组中的元素是不允许删除的，但可以使用 del 语句删除整个元组

元组之间可以使用 + 和*，即允许元组进行组合连接和重复复制

元组可以进行切片操作

>>> tup = (1,2,3,4,5)
>>> tup[0:3]
(1, 2, 3)

对元组进行操作的内建函数

cmp(tup1,tup2):比较两个元组元素

len（tup）：返回元组中元素的个数

max（tup）：返回元组中元素最大的值

min(tup):返回元组中元素最小的值

tuple(seq):将列表转化为元组

元组的方法（元组没有列表中的增、删、改的操作，只有查的操作）

tuple.index(obj)：从元组中找出某个值第一个匹配项的索引值

tuple.count(obj)： 统计某个元素在元组中出现的次数

字符串

字符串常用方法

1)	count()
name = 'branda hou'
print(name.count('a'))
运行结果：
2 
2）center()
name = 'branda hou'
print(name.center(50,'-'))
运行结果：
--------------------branda hou--------------------
3)find()   # 用法不太理解，后期添加说明
name = 'branda hou'
print(name.find('hou'))
运行结果：
7
4）index()  # 用法不太理解，后期添加说明
product = [
    ('sun','tester'),
    ('branda','leader'),
    ('hou','manager')
]
print(product.index(('hou','manager')))
运行结果：
2
5)isdigit()：判断是否是整数
print('hh'.isdigit())
运行结果：
False
print('2'.isdigit())
运行结果：
True
6)join()
print(''.join(['1','2','3']))
运行结果：
123
7)maketrans
p = str.maketrans("abcdef",'123456')
print("branda hou".translate(p))
运行结果：
2r1n41 hou
注释：abcdef分别对应123456，然后把p传给branda hou
8)splict()
print('1+2+3+4'.split('+'))
运行结果：
['1', '2', '3', '4']

文件操作

打开文件

f = open (“D:\\wangjing\\bigworld.py”)
data = f.read ()
print(data)

自动创建一个文件，并输入一段文字

f = open (“D:\\wangjing\\bigworld.py”,”w”)
f.write(“我爱北京天安门”)

在原文件的基础上追加内容，需要改变模式，变成追加模式“a”

f = open (“D:\\wangjing\\bigworld.py”,”a”)
f.write(“我很喜欢看星空”)

读前三行数据

f = open (“D:\\wangjing\\bigworld.py”,”r”, encoding = “utf-8”)
for i in range(3):
    print(f.readline())

遍历文件

f = open (“D:\\wangjing\\bigworld.py”,”r”, encoding = “utf-8”)
for line in f.readlines():
        print(line)

遍历文件，但不打印第 3 行

低效循环方法

方法是给每一行标下标，比如 0，1，2，3，4，5……,当下标是 2 的时候，把第 3 行内容替换成“我是分割线”

这种方法只适合读小文件，因为这种循环需要先把文件从硬盘中读到内存中，如果文件非常大，比如 20G，但一般内存只有 8G，就会造成内存不够，严重的时候造成崩盘

f = open (“D:\\wangjing\\bigworld.py”,”r”, encoding = “utf-8”)
for index,line in enumerate (f.readlines()):
           if index = 2:
              print(‘---我是分割线---’)
              continue
              print(line)

高效循环方法

此方法从硬盘中把文件内容一行一行读到内存中，每读一行，覆盖原来的一行，使得每次内存中只保留一行

f = open (“D:\\wangjing\\bigworld.py”,”r”, encoding = “utf-8”)
count = 0
for line in f:
   if count == 2:
      print(‘---我是分割线---’)
      count +=1
      continue
print(line)
conut += 1

文件修改

f = open("D:\\wangjing\\bigworld.py",'r',encoding="utf-8")
f_new = open("D:\\wangjing\\bigworld.bak.py",'w',encoding="utf-8")
for line in f:
    if "我来到了城市" in line:
        line = line.replace("我来到了城市","branda来到了城市")
    f_new.write(line)
f.close()
f_new.close()

通过脚本传参来进行文件内容的替换

Import sys
f = open("D:\\wangjing\\bigworld.py",'r',encoding="utf-8")
f_new = open("D:\\wangjing\\bigworld.bak.py",'w',encoding="utf-8")
find_str = sys.argv[1]
replace_str = sys.argv[2]
for line in f:
    if find_str in line:
        line = line.replace(find_str, replace_str)  f_new.write(line)
f.close()

with 语句

# with的作用就是帮我们自动关闭文件
with open("D:\\wangjing\\bigworld.py",'r',encoding="utf-8") as f:
    for line in f:
        print(line)

Sys 模块常见函数

sys.argv

sys.argv 实现从程序外部向程序传递参数
sys.argv 变量是一个包含了命令行参数的字符串列表, 利用命令行想程序传递参数. 其中,脚本的名称总是
sys.argv 列表的第一个参数。

sys.modules

sys.modules 是一个全局字典，该字典是 python 启动后就加载在内存中。每当程序员导入新的模块，sys.modules 将自动记录该模块。当第二次再导入该模块时，python 会直接到字典中查找，从而加快了程序运行的速度。它拥有字典所拥有的一切方法.

上面的脚本需要从命令行执行

1） win+R，打开命令行

2） 在命令行输入：python D:\wangjing\rep.py "我来到了城市" "branda 来到了城市"

3） 回车，如果没有报错，即运行成功

字符编码和转码

decode的作用是将其他编码的字符转换成unicode编码,如str1,decode('gb2312'),表示将gb2312编码的字符串str1转换成unicode编码。
encode的作用是将unicode编码转换成其他编码的字符串,如str2,encode('gb2312'),表示将unicode编码的字符串str2转换成gb2312编码。
 
因此,转码的时候一定要明白,字符串str是什么编码,然后decode成unicode编码,然后再encode成其他编码。
 
通常,在没有指定特定的编码方式时,都是使用的系统默认编码创建的代码文件

# 获取Python默认的编码方式
import sys
print(sys.getdefaultencoding())

运行结果：
utf-8

查看Windows默认的编码方式
在Windows平台下，进入DOS窗口，输入：chcp
可以得到操作系统的代码页信息，你可以从控制面板的语言选项中查看代码页对应的详细的字符集信息。
我的活动代码页为：936，它对于的编码格式为GBK。
下表列出了所有支持的代码页及其国家(地区)或者语言： 
代码页       国家(地区)或语言 
437          美国 
708          阿拉伯文(ASMO 708)
720          阿拉伯文(DOS)
850          多语言(拉丁文 I) 
852          中欧(DOS) - 斯拉夫语(拉丁文 II) 
855          西里尔文(俄语) 
857          土耳其语 
860          葡萄牙语 
861          冰岛语 
862          希伯来文(DOS)
863          加拿大 - 法语 
865          日耳曼语 
866          俄语 - 西里尔文(DOS) 
869          现代希腊语
874          泰文(Windows)
932          日文(Shift-JIS)
936          中国 - 简体中文(GB2312)
949          韩文
950          繁体中文(Big5)
1200         Unicode        
1201         Unicode (Big-Endian)
1250         中欧(Windows)
1251         西里尔文(Windows)
1252         西欧(Windows)
1253         希腊文(Windows)
1254         土耳其文(Windows)
1255         希伯来文(Windows)
1256         阿拉伯文(Windows)
1257         波罗的海文(Windows)
1258         越南文(Windows)
20866        西里尔文(KOI8-R)
21866        西里尔文(KOI8-U)
28592        中欧(ISO)
28593        拉丁文 3 (ISO)
28594        波罗的海文(ISO)
28595        西里尔文(ISO)
28596        阿拉伯文(ISO)
28597        希腊文(ISO)
28598        希伯来文(ISO-Visual)
38598        希伯来文(ISO-Logical)
50000        用户定义的
50001        自动选择
50220        日文(JIS)
50221        日文(JIS-允许一个字节的片假名)
50222        日文(JIS-允许一个字节的片假名 - SO/SI)
50225        韩文(ISO)
50932        日文(自动选择)
50949        韩文(自动选择)
51932        日文(EUC)
51949        韩文(EUC)
52936        简体中文(HZ)
65000        Unicode (UTF-7)
65001        Unicode (UTF-8)

1 unicode、utf-8、GBK之间的转换（unicode，即万国码，统一了世界上许多国家的编码，目前，在Unicode中，一个中文占3个字节，一个英文占1个字节）

2 utf-8先转到unicode，然后再转成gbk（python2）
s = “你好”
# utf-8先解码成unicode，然后再编码成gbk
s_to_unicode = s.decode(“utf-8”)
print(s_to_unicode)
s_to_gbk = s_to_unicode.encode(“gbk”)
print(s_to_gbk)

3 python3中转码（python3中编码默认Unicode）
a = "我很好"
# 1 Unicode转换成gb2312,因为python3中字符串编码默认是unicode编码，所以不需要decode，直接encode成想要转换的编码，而文件编码默认的是什么，需要看页面右下角的显示
通常默认utf-8(文件编码和字符串编码不一样)
unicode_gb2312 = a.encode('gb2312')
print('我的gb2312',unicode_gb2312)

# 2 gb2312转换成utf-8
# 当前字符为gb2312，所以要先decode成unicode(decode中传入的参数为当前字符的编码集)然后再encode成utf-8
gb2312_utf8=unicode_gb2312.decode('gb2312').encode('utf-8')
print('我是utf-8',gb2312_utf8)

# 3 utf-8转换成gbk
# 当前字符集编码为utf-8要想转换成gbk先decode成unicode字符集再encode成gbk字符集
utf8_gbk=gb2312_utf8.decode('utf-8').encode('gbk')
print("我是gbk",utf8_gbk)

# utf-8转换成unicode
# 注意当转换成unicode时 并不需要encode()
utf8_unicode=utf8_gbk.decode('gbk')
print('我是unicode',utf8_unicode)

函数介绍

函数定义

编程语言中的函数定义：函数是逻辑结构化和过程化的一种编程方法

python 中函数定义方法

def test():
    “the function definitions”
     x + = 1
     return x
详解：
def:定义函数的关键字
test：函数名
（）：内可定义形参
“”：文档描述（非必要，建议填写）
x+ = 1:泛指代码块或程序处理逻辑
return ：定义返回值

函数的类型

# 函数--面向对象
def funct1():
    "testing1"
    print('in the funct1')
    return 0

# 面向过程
def funct2():
    "testing2"
    print('in the funct2')

x = funct1()
y = funct2()

文件 a.txt 中已有内容，运行下面的程序后，a.txt 后面会追加上内容（a.txt 已创建）（追加时间）

import  time
def logger():
   time_fomat = '%Y-%m-%d %X'
   time_current= time.strftime(time_fomat)
   with open('a.txt','a+') as f:
    f.write('%s end action\n' %time_current)

def test1():
    print('in the test1')
    logger()

def test2():
    print('in the test2')
    logger()

def test3():
    print('in the test3')
    logger()


test1()
test2()
test3()

运行结果：
in the test1
in the test2
in the test3
打开a.txt,页面显示的结果：
aaa
222
333
2018-07-27 15:03:01 end action
2018-07-27 15:03:01 end action
2018-07-27 15:03:01 end action

函数返回值

# return:返回值可以返回哪些值，有以下三种情况
def test1():
    print('in the test1')

def test2():
    print('in the test2')
    return 0

def test3():
    print('in the test3')
    return1,'hello',['branda','alex'],{'name':'branda'}

x=test1()
y=test2()
z=test3()
print(x)
print(y)
print(z)



运行结果：
in the test1
in the test2
in the test3
None
0
(1, 'hello', ['branda', 'alex'], {'name': 'branda'})
总结：
1 返回值数=0：返回None
2 返回值数=1：返回object（return一个值，就返回所定义的值）
3 返回值数=2：返回tuple（return多个值，就返回元组）
为什么要有返回值？
返回值会返回程序的执行结果，后面的程序逻辑需要根据执行结果进行不同的操作

函数调用

调用方法
1）	test（）执行，（）表示调用函数（），（）内可以有参数，也可以没有
参数：
1）	形参和实参
形参：形式参数，不是实际存在，是虚拟变量。在定义函数和函数体的时候使用形参，目的是在函数调用时接受实参
实参：实际参数，调用函数时参给函数的参数，可以是常量、变量、表达式、函数，用来传给形参
注意：形参与实参必须一一对应，否做运行会报错
区别：形参是虚拟的，不占用内存，形参变量只有在分配时才分配内存单元；实参是一个变量，占用内存空间，数据传向单向，只能实参传给形参，不能形参传给实参
举例说明1：位置参数调用，与形参顺序一一对应
def test(x,y):
    print(x)
    print(y)
test(1,2) # 位置参数调用
此处，形参是x和y，实参是1和2
举例说明2：关键字参数调用，与形参顺序无关
def test(x,y):
    print(x)
    print(y)
test(x=1,y=2) # 关键字参数调用


举例说明3：
def test(x,y):
    print(x)
    print(y)
test(3,y=2) # 3直接传参给x，可以成功运行
举例说明4：
def test(x,y):
    print(x)
    print(y)
test(3,x=2) # 会报错，因为3传参给了x，后面的2也传给了x，x有多个值
举例说明5：关键字参数是不能写在位置参数前面
def test(x,y,z):
    print(x)
    print(y)
print(z)
test(3,y=2,6) # 运行会报错，因为y=2 是关键字参数，后面的6是位置参数，关键字参数是不能写在位置参数前面

函数的非固定参数

（1）默认参数
def test(x,y=2):
    print(x)
    print(y)

test(1)
运行结果：
1
2
默认参数特点：调用函数的时候，默认参数非必须传递，比如上面调用test（）的函数的时候，y默认值为2；用途，比如默认安装等
（2）参数组
提问：如果实参不固定，如何定义形参?
形参以*开头，以args命名的一个变量名，它可以接受多个实参，并把多个实参放在一个元组里（此处命令可以随意设置，比如可以写成*alex,但规范的写法就是*args，建议按规范写法来）
def test(*args):
    print(args)
test(1,2,3,4,5)
运行结果：
（1，2，3，4，5）
或者：
def test(*args):
    print(args)
test(*[1,2,3,4,5])
运行结果：
（1，2，3，4，5）

位置参数和参数组联合使用:
*args：接收N个位置参数，转换成元组形式
def test(x,*args):
print(x)
    print(args)
test(1,2,4,6,5)
运行结果：
1
(2,4,6,5)
（3）如果调用函数的时候，传的是字典值，函数应该如何设计尼？
**kwargs：接收N个关键字参数，转换成字典的形式 
def test2(**kwargs):
    print(kwargs)

test2(name='branda',age=20)
运行结果：
{'name': 'branda', 'age': 20}
完善版：
def test2(**kwargs):
    print(kwargs)
    print(kwargs['name'])
    print(kwargs['age'])

test2(**{'name':'branda','age':20})
运行结果：
{'name': 'branda', 'age': 20}
branda
20
（4）位置参数和**kwargs联合使用
def test3(name,**kwargs):
    print(name)
    print(kwargs)
test3('branda',age=21,sex='F')


运行结果：
branda
{'age': 21, 'sex': 'F'}

（5）默认参数和**kwargs联合使用
def test4(name,age=10,**kwargs):
    print(name)
    print(age)
    print(kwargs)

test4('branda',sex='m',hobby='swimming')
运行结果：
branda
10
{'sex': 'm', 'hobby': 'swimming'}

（6）默认参数、*args、**kwargs联合使用
def test4(name,age=10,*args,**kwargs):
    print(name)
    print(age)
    print(args)
    print(kwargs)
test4('branda',age=21,sex='m',hobby='swimming')
运行结果：
branda
21
()
{'sex': 'm', 'hobby': 'swimming'}

作用域、局部与全局变量

（1）	局部变量
 在被调用函数内赋值的变元和变量，处于该函数的“局部作用域”
def change_name(name):
    print("before change",name)
    name = 'branda'
    print("after change",name)
name = 'wj'
change_name(name)
print(name)
运行结果：
before change wj
after change branda
wj
全局变量
 在所有函数之外赋值的变量，属于“全局作用域”，处于全局作用域的变量，被称为“全局变量”
案例1
school = 'oldboy'
def change_name(name):
    print("before change",name,school)
    name = 'branda'
    print("after change",name)
name = 'wj'
change_name(name)
print(name)
print(school)
运行结果：
after change branda
wj
oldboy
案例2
a = 4
def b():
    a = 8
    print(a)
print (a)
b()
运行结果：
4
8
有4条法则，可以用来区分一个变量是处于局部作用域还是全局作用域
1 如果变量在全局作用域中使用（即在所有函数之外），它就总是全局变量
2 如果在一个函数中，有针对该变量的global语句，它就是全局变量
3 否则，如果该变量没有用在赋值语句中，它就是全局变量
4 但是，如果该变量没有用在赋值语句中，它就是全局变量
def spam():
    global eggs
    eggs = 'spam' # 全局变量，有针对eggs变量的global语句
def bacon():
    eggs = 'bacon' # 局部变量，有针对它的赋值语句
def ham():
    print(eggs) # 全局变量，既没有针对它的赋值语句
也没有针对它的global语句
eggs = 42 # 全局变量
spam()
print(eggs)
运行结果：
spam

递归

在函数内部，如果一个函数在内部调用自身本身，这个函数就是递归函数
递归特性：
1 必须有一个明确的结束条件，递归最多可以调999层
2 每次进入更深一层递归时，问题规模相比上一次递归都应有所减少
3 递归效率不高，递归层次过多会导致栈溢出
def calc(n):
    print(n)
    if int(n/2) >0:
        return calc( int(n/2))
calc(10)

高阶函数

定义:变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数据称为高阶函数。
例子：
def add(a,b,f):
    return f(a) + f(b)
res = add(3,-6,abs)
print(res)
ps：abs()函数返回数字的绝对值

模块初识

标准库

Python拥有一个强大的标准库。Python语言的核心只包含数字、字符串、列表、字典、文件等常见类型和函数，而由Python标准库提供了系统管理、网络通信、文本处理、数据库接口、图形系统、XML处理等额外的功能
Python标准库的主要功能有：
1）文本处理，包含文本格式化、正则表达式匹配、文本差异计算与合并、Unicode支持，二进制数据处理等功能
2）文件处理，包含文件操作、创建临时文件、文件压缩与归档、操作配置文件等功能
3）操作系统功能，包含线程与进程支持、IO复用、日期与时间处理、调用系统函数、日志（logging）等功能
4）网络通信，包含网络套接字，SSL加密通信、异步网络通信等功能
5）网络协议，支持HTTP，FTP，SMTP，POP，IMAP，NNTP，XMLRPC等多种网络协议，并提供了编写网络服务器的框架
6）格式支持，包含HTML，SGML，XML的处理。
7）其它功能，包括国际化支持、数学运算、HASH、Tkinter等

常见模块

sys 模块

1） sys.argv

功能：在外部向程序内部传递参数

案例

第一步：

打开 pycharm，输入以下程序

import sys
a = sys.argv[1]
print(a)

然后保存，文件名为 sys_model.py

第二步：打开 cmd

此处有一个问题，就是需要获取脚本路径

选择 sys_model.py，右击，选择 copy path

打开 cmd，进入对应的脚本目录下，如下图：

运行脚本：如下图:

如果想在脚本后面传两个参数，需要修改程序，如下：

import sys
a = sys.argv[1]
b = sys.argv[2]
print(a,b)

OS 模块

Python os模块包含普遍的操作系统功能
1)	os.name
输出字符串指示正在使用的平台。如果是window 则用'nt'表示，对于Linux/Unix用户，它是'posix'
例：
import os
print(os.name)
2)	os.getcwd()
函数得到当前工作目录，即当前Python脚本工作的目录路径。
例：
import os
print(os.getcwd())
3)	os.listdir()
返回指定目录下的所有文件和目录名
例子：
import os
print(os.listdir())

pyc 文件是什么文件

Python 语言属于先编译后解释的语言
当python程序运行时，编译的结果是保存在位于内存中的PyCodeObject中，当python程序运行结束时，python解释器则将PyCodeObject写回到pyc文件中。当python程序第二次运行时，首先程序会在硬盘中寻找pyc文件，如果找到，则直接载入，否则就重复上面的过程。

python 中的浅 copy 和深 copy

简介

1）深 copy 新建一个对象重新分配内存地址，复制对象内容。
2）浅 copy 不重新分配内存地址，内容指向之前的内存地址。
3）浅 copy 如果对象中有引用其他的对象，如果对这个子对象进行修改，对象的内容就会发生更改

浅 copy 例子

import copy
person = ['name',['saving',1000]]
p1 = copy.copy(person)
p2 = copy.copy(person)
p1[0] = 'hzy'
p2[0] = 'branda'
p1[1][1] = 500
print(p1)
print(p2)
运行结果：
['hzy', ['saving', 500]]
['branda', ['saving', 500]]

深 copy 例子

xs = [[1,2,3],[4,5,6],[7,8,9]]
zs = copy.deepcopy(xs)
xs[0][0] = 0
print(xs)
print(zs)
运行结果：
[[0, 2, 3], [4, 5, 6], [7, 8, 9]]
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

split()函数

基本用法：
split()函数通过指定分隔符对字符串进行切片，运行的时候会生成列表
例1 通过|分隔符进行切片
a = '100100|天津|good'
print(a.split('|'))
运行结果：
['100100', '天津', 'good']

例2 切片后，取值（比如取good）
a = '100100|天津|good'
print(a.split('|')[2])
运行结果：good

strip()函数

基本用法：
该函数的作用是去除字符串开头和结尾处指定的字符，不会去除字符串中间对应的字符
当strip（）为空时，默认删除空白符（包括'\n', '\r',  '\t',  ' ')
例1：删除字符串ahh前面的空白符
a = '   ahh'
print(a.strip())
运行结果：
ahh

例2：删除字符串hhaah中前后的h
a = 'hhah'
print(a.strip('h'))
运行结果：
ha

免责申明： 以上内容大部分来自网络和选自 AL Sweigart 的《Python 编程快速上手--让繁琐工作自动化》，若有侵权，请及时告知