Python学习-基础篇(三)

由于我现在暂时用不到面向对象程序设计，所以暂且先不学习Python的面向对象程序设计。
本篇包含：字符串及正则表达式、函数、模块

五、字符串及正则表达式

1、字符串

1.字符串常用操作

（1）拼接字符串

字符串1+字符串2 = 字符串1 字符串2

字符串不可以直接和数值类型相加
（2）计算字符串的长度
字符串的长度，即字符串所占字节数。
A-Z、a-z、0-9、._空格等占一个字节
中文汉字占2~4字节：UTF-8占3个；GBK(gb2312)占2个
1）计算字符串字符的个数

len(string)
#len()函数获取字符的个数，不管中文还是英文都按一个字符计算

2）计算字符串所占字节数

len(string.encode()) #计算UTF-8编码字符长度
len(string.encode("gbk")) #计算GBK编码字符长度

（3）截取字符串
字符串属于序列。所以：
1）获取字符可以使用索引

string[索引值]

2）截取字符串可以使用切片

string[start:end:step]

（4）分割、合并字符串
1）分割字符串：split()

listname = str.split(sep,maxsplit)
#sep指定分隔符，默认值是空白符，如：空格、\n、\t。
#maxsplit分隔次数，-1表示没有限制

>>> str1 = "你  有 多 自信,\n世界 就有 多 相信你"
>>> str1.split()
['你', '有', '多', '自信,', '世界', '就有', '多', '相信你']
>>> str1.split(" ")
['你', '', '有', '多', '自信,\n世界', '就有', '多', '相信你']
>>> str1.split(" ",5)
['你', '', '有', '多', '自信,\n世界', '就有 多 相信你']
>>> str1.split("\n")
['你  有 多 自信,', '世界 就有 多 相信你']

str1 = "@lemon @qwzf @未完成的歌 @chumen007"
list1 = str1.split(' ') #用空格分隔字符串
for item in list1:
    print(item[1:]) #输出好友，并去掉@

2）合并字符串：join()

strnew = string.join(iterable)
#string合并时的分隔符
#iterable可迭代对象

list1 = ["lemon","qwzf","未完成的歌","chumen007"] #好友列表
str1 = " @".join(list1) #用空格和@连接
str2 = "@" + str1
print("你要@的好友:",str2)

（5）检索字符串
检索一个字符串在另一个字符串出现的次数：count()
检索是否包含子字符串：find()、index()、in关键字
检索是否以指定字符串开头和结尾：startswith()、endswith()

str.count(sub[,start[,end]])
#sub指定要检索的子字符串
#start指定检索的起始位置
#end指定检索的结束位置

str.find(sub[,start[,end]])
#找到返回首次检索到子字符串的索引值；没找到返回-1
#find从左往右找，rfind从右往左找
str.index(sub[,start[,end]])
#找到返回首次检索到子字符串的索引值；没找到返回异常
#index从左往右找，rindex从右往左找

str.startswith(prefix[,start[,end]])
str.endswith(prefix[,start[,end]])
#prefix指定要检索的字符串
#是，返回True；否，返回False

（6）字母的大小写转换
1）大写转小写：str.lower()
2）小写转大写：str.upper()
（7）去除字符串中的空格和特殊字符
特殊字符：\t、\r、\n
去除字符串左右两端的空格和特殊字符：str.strip([chars])
去除字符串左侧和右侧的空格和特殊字符：str.lstrip([chars])、str.rstrip([chars])
（8）格式化字符串
1）使用%操作符

'%[-][+][0][m][.n]格式化字符'%exp
#[-]表示左对齐，正数前没有符号；负数的前加上负号
#[+]表示右对齐，正数前加上正号；负数的前加上负号
#[0]表示右对齐，正数前没有符号；负数的前有负号，填充空白处，一般和[m]一起使用
#[m]数值所占宽度
#[0][m]不够宽度前补0
#[.n]小数点后保留n位数
#格式化字符 格式化成字符串s 格式化成十进制整数d 格式化成浮点数f
#exp要转换的项

>>> template = '编号:%09d\t 公司名称:%s\t 官网:http://www.%s.com' #定义模板
>>> item = (6,"百度","baidu") #要转换内容
>>> print(template%item)
编号:000000006     公司名称:百度     官网:http://www.baidu.com

2）使用字符串对象的format()方法(推荐)

str.format(args)
#str模板
#{[index][:[[fill]align][sign][#][width][.precision][type]}
#index设置索引位置
#fill指定空白处填充字符
#align对齐方式:<内容左对齐；>右对齐；=内容左对齐,符号放填充内容的最右侧；^内容居中
#sign指定有无符号数
##指定2、8、16进制是否加前缀
#width指定所占宽度
#.precision指定保留小数位数
#type要格式化字符的类型：s、d、f

#args要转换的项

>>> template = '编号:{:0>9d}\t 公司名称:{:s}\t 官网:http://www.{:s}.com' #定义模板
>>> print(template.format(7,"百度","baidu"))
编号:000000007     公司名称:百度     官网:http://www.baidu.com

（9）String模块中的常量：
string.digits：数字0~9
string.ascii_letters：所有字母（大小写）
string.lowercase：所有小写字母
string.printable：可打印字符的字符串
string.punctuation：所有标点
string.uppercase：所有大写字母

2.字符串编码转换

ASCII、GBK/GB2312、UTF-8
str：Unicode字符 如：”拼搏到感动自己”
bytes：二进制数据 如：b’\xd2\xb0’和b’mr’
（1）使用encode()方法编码
将字符串转换成二进制数据，即str->bytes

str.encode([encoding="utf-8"][,errors="strict"])
#strict遇到非法参数抛出异常
#ignore忽略非法字符
#replace用?替换非法字符
#xmlcharrefreplace使用xml的字符引用

（2）使用decode()方法解码
bytes->str

str.decode([encoding="utf-8"][,errors="strict"])

str1 = "拼搏到感动自己"
byte1 = str1.encode("GBK")
byte2 = str1.encode("utf-8")
str01 = byte1.decode("GBK")
str02 = byte2.decode("utf-8")
print("原字符串：",str1)
print("GBK编码：",byte1)
print("UTF-8编码：",byte2)
print("GBK解码：",str01)
print("UTF-8解码：",str02)

2、正则表达式

1.正则表达式

（1）行定位符
^表示开始
$表示结束
（2）元字符
常用的除^、$外，还有：

（3）限定符（4）字符类[]
如：匹配元音字母[aeiou]、匹配汉字[\u4e00-\u9fa5]
（5）排除字符^
^放到[]中表示排除，如[^a-zA-Z]
（6）选择字符|
如：[a-z]|[0-9]匹配a-z或0-9
（7）转义字符\
（8）分组()
如：(\.[0-9]{1,3}){3}对分组匹配3次
补充：原生字符串，如：'\\bm\\w*\\b'写成原生字符串r'\bm\w*\b'

2.使用re模块实现正则表达式操作

（1）匹配字符串
1）re.match 只是从头开始匹配

re.match(pattern,string,[flags])
#pattern模式字符串
#string要进行匹配的字符串
#flags指定标志位
#标志位控制匹配方式：re.I:不区分字母大小写，re.A:让\w不匹配汉字

import re
pattern = r'qw_\w*' #模式字符串
string = 'QW_PYTHON qw_python' #要匹配的字符串
match = re.match(pattern,string,re.I) #匹配字符串
print(match)
print("起始位置：",match.start())
print("结束位置：",match.end())
print("匹配数据：",match.group())

2）re.search 匹配包含

re.search(pattern,string,[flags])

import re
pattern = r'qw_\w*' #模式字符串
string = '项目QW_PYTHON qw_python' #要匹配的字符串
match = re.search(pattern,string,re.I) #匹配字符串
print(match)
print("起始位置：",match.start())
print("结束位置：",match.end())
print("匹配数据：",match.group())

3）re.findall 把所有匹配到的字符放到以列表中的元素返回

re.findall(pattern,string,[flags])

import re
pattern = r'qw_\w*' #模式字符串
string = '项目QW_PYTHON qw_python' #要匹配的字符串
match = re.findall(pattern,string,re.I) #匹配字符串
print("匹配到字符串列表：",match)
print("匹配到的字符串：")
for item in match:
    print(item)

（2）替换字符串
re.sub 匹配字符并替换

re.sub(pattern,repl,string,count,flags)
#repl用来进行替换的字符串
#count替换的最大次数，默认值0替换所有

import re
pattern = r'1[3-8]\d{9}' #模式字符串
string = '中奖号码：888999 联系电话：13866666611' #要匹配的字符串
result = re.sub(pattern,"1xxxxxxxxxx",string) #替换字符串
print(result)

（3）分割字符串
re.split 以匹配到的字符当做列表分隔符

re.split(pattern,string,[maxsplit],[flags])
#maxsplit最大拆分次数

import re
pattern = r'[?|&]' #分隔符
string = "http://www.xxx.com/login.php?user='qwzf'&pwd='qwzf'" #要匹配的字符串
result = re.split(pattern,string) #分割字符串
print(result)

补充：re.fullmatch 全部匹配

1、函数的创建和调用

#创建函数
def functionname([参数]):
    '''函数说明'''
    函数体

#调用函数
functionname([参数])

2、参数传递

1.了解形式参数和实际参数
值传递和引用传递
值传递->不可变对象->不改变形式参数的值
引用传递->可变对象->改变形式参数的值

2.位置参数
位置参数是必须按照定义时的个数和顺序进行参数传递，也称必备参数。
3.关键字参数
关键字参数是指使用形式参数的名字来确定输入的参数值。

def functionname(p1,p2,p3):
    函数体
functionname(p1=v1,p2=v2,p3=v3)
functionname(p1=v1,p3=v3,p2=v2)

4.为参数设置默认值

def functionname(...,[参数名=默认值]):
    函数体
#默认值参数必须放在所有参数的最后
如：
def functionname(p2,p3,p1=v1):
    函数体

#查看默认值
print(functionname,__defaults__)

为参数设置默认值时，参数必须指向不可变对象。遇到可变对象，参数默认值可以设置为None。
5.可变参数
个数不固定的参数->0、1、2…n个参数
（1）*parameter
接收任意多个实参，并把它们放到元组中
也可接收列表

def coffee(*name):
    print("\n咖啡有：")
    for item in name:
        print(item) #输出咖啡名称
coffee("卡布奇诺","蓝山","拿铁")
list1 = ["卡布奇诺","蓝山","拿铁"]
coffee(*list1)

（2）**parameter
接收任意多个类似关键字参数一样显式赋值的实参，并将其放到一个字典中
也可接收字典

def sign(**sign):
    print()
    for key,value in sign.items(): #遍历字典
        print(key,"的汉字是",value)
sign(chi='吃',kan='看')
dict1 = {'zi':'字','dian':'典'}
sign(**dict1)

3、返回值

return [value]
#不指定return或没有value，返回None

def functionname(p1,p2,p3):
    函数体
    return r1,r2......
result = functionname(v1,v2,v3)
#只有一个返回值result保存的是返回值
#有多个返回值result保存的是元组

4、变量的作用域

变量的作用域是指程序代码能够访问该变量的区域，如果超出该区域，再访问时就会出现错误。
根据变量有效范围：局部变量和全局变量
函数体内修改全局变量：
在函数体内定义一个全局变量，使用global关键字将局部变量变成全局变量

string = "我学Python"
def demo():
    global string #定义全局变量
    string = "我被修改了！" #修改全局变量
    print("函数内全局变量",string)
demo()
print("函数外全局变量",string)

5、匿名函数(lambda)

Python中使用lambda表达式来实现匿名函数。

result = lambda [arg1[,arg2,...,argn]]:expression
#arg1参数
#expression实现具体功能的表达式，不能出现for或while等

import math
r = 10 #半径
result = lambda r:math.pi*r*r
print("半径为",r,"的圆面积为:",result(r))

1、模块概述

模块是Python程序
模块->*.py
把能够实现某一特定功能的代码放置在一个文件中作为一个模块，从而方便其他程序和脚本导入并使用。
使用模块的四点好处：
（1）可以避免函数名和变量名冲突
（2）更容易查找代码
（3）提高代码的可重用性
（4）有选择的使用

2、自定义模块

模块可包含：函数、变量、类、可执行代码
1.创建模块
模块名.py->文件名
模块名不能是Python自带的标准模块名称。

#calculate.py
def add(a,b): #加法
    return round(a+b,1)

#demo.py
import calculate #导入模块
x = 0.2
y = 0.3
print(calculate.add(x,y))

2.使用import语句导入模块

import modulename [as alias]
#alias别名
#使用as关键字为模块指定别名
#指定别名之后，可以通过别名引用模块

import语句导入模块->命名空间
3.使用from…import语句导入模块

from modulename import member
#member变量、函数、类
#导入模块全部定义，使用*
#dir()函数打印模块的全部定义

#calculate.py
def add(a,b): #加法
    return round(a+b,1)
def sub(a,b): #减法
    return round(a-b,1)
def mul(a,b): #乘法
    return round(a*b,1)

#demo.py
from calculate import add #导入模块中add()函数
x = 0.2
y = 0.3
print(add(x,y))

注：导入两个包括同名函数的模块，使用import语句导入。
4.模块搜索目录
导入模块时查找模块的顺序是：
1）先从内存中，已经存在的模块中查找
2）内置的模块
3）自定义模块
4）环境变量sys.path中找
（1）临时添加
临时目录只在当前执行的窗口有效

#F:\Python\temp\calculate.py
def add(a,b): #加法
    return round(a+b,1)

#F:\Python\demo\demo.py
import sys       #导入内置模块
sys.path.append('F:/Python/temp') #添加临时目录
import calculate #导入自定义模块
print(sys.path)
x = 0.2
y = 0.3
print(calculate.add(x,y))

（2）增加.pth文件(推荐)
只在当前Python版本有效

#F:\Python\demo\demo.py
import sys       #导入内置模块
import calculate #导入自定义模块
print(sys.path)
x = 0.2
y = 0.3
print(calculate.add(x,y))

（3）在PYTHONPATH环境变量中添加
在多个Python版本有效

3、以主程序的形式执行

由于Python没有统一的程序入口，从第一行开始执行。会出现一些问题。解决方法：以主程序的形式执行

if __name__ == '__main__'
#__name__记录模块名称的变量。
#当程序在顶级模块运行时，返回的值就是__main__；被导入其他文件时，返回的值是模块名称

#calculate.py
str1 = "我学Python"
def string():
    str2 = "没有什么不可能"
    return str2
print("__name__运行测试：",__name__)
if __name__ == '__main__':
    print("以主程序的形式执行")
    print(str1)

#main.py
import calculate #导入模块
print("导入模块后输出:",calculate.str1)

4、Python中的包

包->文件夹->__init__.py
规范代码
模块：避免函数名和变量名重名引发的冲突
包：避免模块名重名引发的冲突
1.Python程序的包结构
文件夹下包含__init__.py，则这个文件夹就是个包
2.创建和使用包
（1）创建包
1）创建文件夹
2）在文件夹下，创建__init__.py
3）在文件夹下，创建模块
（2）使用包
1）import + 完整包名 + 模块名
如：

import settings.size
print(settings.size.width)

2）from + 完整包名 + import + 模块名
如：

from settings import size
print(size.width)

3）from + 完整包名 + .模块名 + import + 定义名
如：

from settings.size import width
print(width)

5、引用其他模块

1.标准模块
标准模块可查看官方说明文档：python37/Doc/python373.chm：The Python Standard Library
中文版参考：Python3.x标准模块库目录
2.第三方模块的下载与安装
（1）下载网站：

https://pypi.org/
http://pypi.python.org/pypi

（2）pip

pip <command> [modulename]
#command包括：install、uninstall、list
#install安装第三方模块
#uninstall卸载第三方模块
#list显示已经安装的第三方模块

导入模块顺序：标准模块->第三方模块->自定义模块
常用pip命令：
1）不同Python版本使用pip：

python3 -m pip <command> [modulename]

2）pip源临时更换到国内镜像：

pip install -i https://pypi.tuna.tsinghua.edu.cn/simple [modulename]

将pip源更换到国内镜像
（3）通过setup.py安装

打开cmd 到达安装目录
python setup.py build
python setup.py install

学习完字符串及正则表达式、函数、模块后，掌握了字符串的操作、正则表达式模式串的编写、函数相关知识和模块的使用。继续学习@_@

---

转载请注明来源，欢迎对文章中的引用来源进行考证，欢迎指出任何有错误或不够清晰的表达。可以在下面评论区评论，也可以邮件至 [email protected]