python
规范
内嵌函数
无需import就能之间使用的函数
map(<函数名>,<迭代类型>) #将第一个参数的功能作用于第二个参数的每一个元素。 对组合数据类型的每个元素都执行一次第一个函数
python小细节
- 因为Python的诞生比Unicode标准发布的时间还要早，所以最早的Python只支持ASCII编码，普通的字符串’ABC’在Python内部都是ASCII编码的。但是在Unicode标准发布以后 新版的Python，就开始逐渐基于Unicode码了，但是Unicode码的0-127和ASCII码还是一样的。
pip命令
安装第三方库
pip install XXX //原版
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple XXX //清华源下载
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple XXX --ignore-installed six //错误时重新下载
pip download <第三方库名> //下载但不安装
http://pypi.douban.com/simple/ //豆瓣源地址
更新库
pip list --outdated //查看可更新的库
pip install --upgrade XXX //对准备更新的库进行更新
pip insatll -U
卸载库
pip uninstall XXX //卸载库
其他
pip show <第三方库名> //列出某个库的详细信息
pip search <关键词> //根据关键词在名称和介绍中搜索库
pip list //查看已安装库
引用库
import <库名> #一般导入库
<库名>.<函数名>(<函数参数>)
----------------------------------
from <库名> import <函数名>#省去库名. 可能会有函数重名问题
from <库名> import * #导入全部函数，省去库名.
<函数名>(<函数参数>)
-----------------------------------
import <库名> as <库别名> #起一个小名
<库别名>.<函数名>(<函数参数>)
关于开头coding=utf-8
开头的coding=utf-8和coding:utf-8的作用是一样的。
作用是声明python代码的文本格式是utf-8，python按照utf-8的方式来读取程序。
如果不加这个声明，无论代码中还是注释中有中文都会报错。
注意事项
IDLE自动屏蔽了\r的光标回到行首的功能
txt文件字体编码转换
直接拿txt打开，然后文件>另存为>编码 进行更改
Python基本方法
-
#单行注释 -
'''多行注释，多行字符串 -
not true = false -
type(target)返回target的类型 -
open("a.txt","r",encoding="utf-8").read()（r.可读）打开文件 -
print(x,end="")end=""表示不换行，无end则默认为换行，最后加信息在end=“信息”
-
;一行显示多行代码，之间用;分隔 -
\一行代码分成多行，之间用\分隔 -
r"\String"字符串前加r，反转义
turtle库
import turtle as t
t.title("画画程序") #设置窗口标题栏的信息
t.setup(800,600,100,100)#设置窗体800*600，位置在(100,100)
t.penup() #起笔
t.pendown() #落笔
t.fd(100) #向前移动100单位
t.seth(30) #绝对角度30度，逆时针
t.right(90) #向右转90度
t.left(90) #向左转90度
t.write('秒',font=('Arial',18,'normal'))#绘制文字(设置字体)
t.goto(-50,100) #画笔到(-50,100)的位置
t.pensize(2) #笔的大小为2
t.pencolor('blue') #设置笔的颜色为blue
t.speed(10) #设置画笔速度(1慢~10快)
t.hideturtle() #隐藏海龟
t.done() #绘制结束不退出窗口
基本数据类型
数字类型及操作
-
整数
可正可负，无取值范围限制
-
4种进制表示形式
-
十进制
1010,99,-217 -
二进制
以
0b/0B（零b）开头：0b010,-0B101 -
八进制
以
0o/0O开头：0o123,-0O456 -
十六进制
以
0x/0X开头：0x9a,-0X89
-
-
函数（可嵌套）
pow(x,y) x的y次方，x**y
-
-
浮点数
带有小数点，取值约±10**308，基本无限制
精度数量级为10**-16，存在不确定尾数
-
科学计数法：使用
e/E为幂的符号<a>e<b>表示a*10**b4.3e-3 值为0.0043 9.6E5 值为960000.0
-
函数
round(x,d) 对x四舍五入，保留d位小数
-
-
复数
-a+bj为复数，a是实部，b是虚部-
函数
z.real 获得实部 z.imag 获得虚部
-
-
操作符
类型间可进行混合运算，生成结果为"最宽"类型
整数->浮点数->复数 123+4.0=127.0
x+y x-y x*y x/y 除，10/3结果为3.3333333333333335 x//y 整数除，向下取整，10/3结果为3 +x x本身 -y y的负值 x%y 求余，为整数，-7%3=2 x**y x的y次方（y为小数即开方） -
运算函数
abs(x) 返回x的绝对值 divmod(x,y) 返回商和余数(x//y,x%y)的二元数 #divmod(10,3) -> (3,1) pow(x,y[,z]) 计算x的y次方，如果z在存在，则再对结果进行取模，其结果等效于pow(x,y) %z。 #让范围在余数范围内，加快运行速度 round(x[,d]) 四舍五入，d是保留小数位，默认为0取整 max(a,b,c..) 返回序列最大值 min(a,b,c..) 返回序列最小值 ------------------------------------------ int(x) 变为整数，舍弃小数部分，x可以是字符串 float(x) 变为浮点数，增加小数部分，x可以是字符串 #float(1)->1.0;float('1.2')->1.2 complex(x) 变为复数，增加虚数部分 #complex(4) -> 4+0j
字符串类型及操作
-
表示方式
单行字符串：
'字符串'/"字符串"（为了字符串中可以出现引号）多行字符串：
'''多行\n字符串'''/"""多行\n字符串"""（单双都能出现） -
序号
-
表示
-
索引
<字符串>[M]返回单个字符 -
切片
<字符串>[M:N]返回一段字符子串[M:N) -
切片高级用法
<字符串>[M:N:K]M缺失表示至开头，N缺失表示至结尾 K为步长，加K取一个
“〇一二三四五六七八九十”[1:8:2] -> “一三五七”
[::-1]字符串逆序“〇一二三四五六七八九十”[::-1] -> “十九八七六五四三二一〇”
-
转义符
\\b回退\n换行（到下行首）\r回车（光标到本行首)
-
-
操作符
x+y 连接两个字符串x和y n*x或x*n 复制n次字符串x x in s 判断x是否为s的子串，返回T/F -
处理函数
len(x) 返回字符串长度，字符的个数 str(x) 变成字符串类型，加引号，对应eval() #str(1.23)->"1.23";str([1,2])->"[1,2]" hex(x)/oct(x) 整数x变为十六进制/八进制小写类型字符串 #hex(425)->"0x1a9" chr(u) Unicode编码 -> 字符（有引号''） ord(x) 字符 -> Unicode编码(万国码)（无引号''） #0~1114111(0x10FFFF)空间，几乎有全世界字符 -
方法
str.lower()/str.upper()#返回全小写/大写的字符串副本 str.split(sep=None) #返回一个列表，由str根据sep被分隔的部分组成 #"A,B,C".split(",") -> ['A','B','C'] str.count(sbu) #返回子串sub出现的次数，计数 str.replace(old,new) #返回所有old子串替换为new str.center(width[,fillchar]) #返回str根据宽度width居中，其余部分用fillchar填充 #'a'.center(5,'=') -> '==a==' str.strip(chars) #在str去除左右两侧chars列出的字符 str.join(iter) #在iter中每个元素之间加一个str #格式化字符串输出，",".join("123")->'1,2,3' -
格式化
<模板字符串>.format(<逗号分隔的参数>)槽
{ }{0}对应.format后参数的序号{<参数序号>:<格式控制标记>}槽内部对格式化的配置方式：
<,>#输出数字是字符串的情况下，表示是否要千位分隔符>>>"{0:=^20}".format("YALY") #0是槽的序号，可以重复 '========YALY========' >>>"{0:*>15}".format("滑稽") '*************滑稽' >>>"{:10}".format("爬") '爬 ' #默认填充空格 >>>'{:.1f}'.format(3.16) #四舍五入，保留一位小数 '3.2' #b二进制、c字符Unicode形式、d十进制、o八进制、x十六进制、X大写的十六进制 >>>'{0:b},{0:c},{0:d},{0:o},{0:x},{0:X}'.format(425) '110101001,Ʃ,425,651,1a9,1A9' #e/E是e/E形式科学计数法、f是通常非科学计数法、%百分号表示 '{0:e},{0:E},{0:f},{0:%}'.format(3.14) '3.140000e+00,3.140000E+00,3.140000,314.000000%'
程序的控制结构
分支结构
-
单分支
if <条件>: <语句块> -
二分支
if <条件/True>: <语句块1> else : <语句块2> #紧凑形式：适用于简单表达式的二分支结构 <表达式1> if <条件> else <表达式2> #表达式!=语句 不支持赋值 guess = eval(input()) print('猜{}看'.format('对' if gusee==99 else '错')) -
多分支
if <条件>: <语句块1> elif <条件>: #True执行 <语句块2> ...... else: <语句块2> -
条件判断和组合
x and y //逻辑与 x or y //逻辑或 not x //逻辑非 -
异常处理
try: <语句块1> except: <语句块2> ------------------------------------------ try: <语句块1> except:<异常类型> #异常提醒里的名称 <语句块2> try: num = eval(input('请输入一个整数：')) print(num**2) #平方 except NameError: print('输入的不是整数') #标注异常类型后，仅响应该异常，异常类型名字等同于变量 -
异常处理的高级用法
try: #先执行语句块1 <语句块1> except: #发生异常后执行语句块2 <语句块2> else: #不发生异常时执行语句块3，奖励语句块 <语句块3> finally: #最后再执行语句块4 <语句块4>
循环结构
-
遍历循环
for <循环变量> in <遍历结构>: <语句块> #计数循环（N次） 默认从0开始，执行N次 #遍历range()函数产生的数字序列，从[M开始到N)，K为步长 for i in range([M,]N[,K]): <语句块> #字符串遍历循环 for <每个字符> in <字符串>: <语句块> for c in '鸭梨亚': print(c,end=',') >>>鸭,梨,亚, #列表遍历循环 for tiem in ls: <语句块> #文件遍历循环 for line in fi: #fi文件标识符，遍历fi文件每行，产生循环 <语句块> -
无限循环（条件控制）
while <条件>: <语句块> #直到条件不满足 -
循环控制保留字
break #跳出并结束当前整个循环，执行循环后的语句 #一个break只能跳出一层循环 continue #结束档次循环，继续执行后续次数循环 -
循环的高级用法
for <遍历变量> in <遍历结构>: <语句块1> else: #没有被break退出时，执行else后的语句块 <语句块2> #奖励语句块 ----------------------------------------- while <条件>: <语句块1> else: #没有被break退出时，执行else后的语句块 <语句块2> #奖励语句块 可以判断是否执行break
函数和代码复用
函数的定义与使用
-
作用：降低编程难度和代码复用
-
定义：
一般用
def定义函数，而不用lambda，一般是固定搭配def <函数名>(<参数(0或多个)>): #参数可以没有 <函数体> return <返回值> #参数是一种占位符，形参 #不经过调用，就不会执行 #参数是函数的输入，函数体是处理，return是输出 #函数是IPO的实现 def fact(): print('hello world') -
调用：
def fact(n): #函数的定义 s = 1 for i in range(1,n+1): s *= i return s a = fact(10) #调用函数，给予实参替换形参 print(a) -
可选参数传递：
#定义函数时可以为某些参数指定默认值，构成可选参数 #可选参数必须在非可选参数后 def <函数名>(<必选参数>,<可选参数>): <函数体> return <返回值> #n!//m n的阶乘整除m def fact(n,m=1): s = 1 for i in range(1,n+1): s *= i return s//m fact(10) >>>3628800 fact(10,5) >>>725760 -
可变参数传递：
#定义时可以设计可变数量的函数，既不确定参数总数量 def <函数名>(<参数>,*b): #*b可以没有，也可以多个 <函数体> return <返回值> #计算n的阶乘，结果乘b def fact(n,*b): s = 1 for i in range(i,n+1): s *=i for item in b: #b是个组合数据类型，一个或多个数 s *= item return s fact(10,3) >>>10886400 fact(10,3,5,7) >>>381024000 -
参数的传递的两种方式
-
按照形参的前后位置
fact(10,5) -
形参的名称传递
fact(m=5,n=10)
-
返回值
-
return保留字来传递返回值
可以有return，也可以没有return，也可以有多个返回值（元组）
return后可以有返回值，也可以没有返回值
局部变量和全局变量
-
局部变量
局部变量是函数内部的占位符，可能与全局变量名字相同，但不一样
函数结束后，局部变量被释放
局部变量为组合数据类型且未被创建，等同于全局变量
如果在函数内部真实创建，则为局部变量
-
全局变量
函数外面的是全局变量
可以用
global保留字在函数内部使用全局变量，会被函数修改
n,s = 10,100 #n,s是全局变量
def fact(n):
s = 1 #s是局部变量
for i in range(1,n+1):
s *= i
return s #s=3628800
print(fact(n),s) #(3628800,100)
>>>3628800 100
----------------------------------------------------
n,s = 10,100 #n,s是全局变量
def fact(n):
global s #s是全句变量
for i in range(1,n+1):
s *= i
return s #s=3628800
print(fact(n),s) #(362880000,362880000) s被函数修改
>>>362880000 362880000
---------------------------------------------------
ls = ['F','f'] #通过[]真实创建了个全局变量列表ls
def func(a):
ls.append(a) #ls是列表类型，未真实创建，则等同于全局变量
return
func('C') #在ls里增加一个'C'
print(ls)
>>>['F','f','C']
--------------------------------------------------
ls = ['F','f'] #通过[]真实创建了个全局变量列表ls
def func(a):
ls = [] #在函数里创建一个列表ls
ls.append(a) #ls为局部变量
return
func('C') #在ls里增加一个'C'
print(ls)
>>>['F','f']
lambda函数
lambda函数是一种匿名函数，即没有名字的函数
lambda保留字定义，函数名是返回结果
用于定义简单，能在一行内表示的函数
主要是用作一些特定函数或方法的参数（特殊情况采用）
<函数名> = lambda <参数>:<表达式> #只能用表达式，不能用函数体
# 等同于↓↓↓↓↓↓↓↓↓
def <函数名>(<参数>):
<函数体>
return <返回值>
f = lambda x,y :x + y #函数名是f
f(10,15)
>>>25
-------------------------
f = lambda : 'lambda是个函数'
print(f())
>>>lambda是个函数
代码复用
函数和对象是代码复用的两种主要形式
-
函数：将代码命名，在代码层面建立了初步抽象
对象：属性和方法，在函数之上进一步抽象
<a>.<b>和<a>.<b>() -
紧耦合：两个部分之间交流很多，无法独立存在
模块内部紧耦合
松耦合：两个部分之间交流较少，可以独立存在
模块之间松耦合
函数递归
函数中调用函数自身的方式
-
链条：计算过程存在递归链条 n!和n(n-1)!构成链条
-
基例：存在一个或多个不需要再次递归的基例 当n=0，为1，是基例
-
递归的调用方法：函数+分支语句
函数+分支语句 def fact(n): #根据数学函数写 if: 基例 else： 链条 #反复调用 ------------------------------------------- def fact(n): #n的阶乘n! if n == 0: return 1 else: return n*fact(n-1)#调用自身代码不同的复制版本 ------------------------------------------- #汉诺塔 def hanoi(n,src,dst,mid): #圆盘数，原柱子，目的柱子，中间柱子， global count #使用全局变量 if n == 1: print('{}:{}->{}'.format(1,src,dst)) count += 1 else: hanoi(n-1,src,mid,dst)#n为对第n个圆盘操作 print("{}:{}->{}".format(n,src,dst)) #n表示第n个圆盘 count += 1 hanoi(n-1,mid,dst,src) #借助中间柱子，将原柱子的最后一个搬到目的柱子 count = 0 #必须给全局变量赋初值 hanoi(10,'A','C','B') #一共10个圆盘 print(count)
Pyinstaller库
第三方库
Python利用pyinstaller打包为可执行文件（各个系统文件）
#在命令行中执行
#路径>pyinstaller -F -w 文件名.py
G:\Python\workspace>pyinstaller -F -w pig.py
路径>pyinstaller -i curve.ico -F pig.py
-
-F ，--onefile是用于将所有的支持文件全部都打包在一起，不显示其他的依赖文件，独立文件（如果没有这个属性，你会发现所有生成的、所需支持的依赖文件会全部在文件夹下） -
-w在程序运行的过程中隐藏后台控制的黑窗口 -
-h查看帮助 -
--clean清理打包过程中的临时文件 -
-D , --onedir默认值，生成dist文件夹，和-F相反 -
-i <图标文件名.ico>指定打包程序使用的图标.icon文件 -
input('Press Enter to exit...') #防止出来结果直接关闭窗口
组合数据类型
集合类型
-
多个元素的无序组合、
和数学集合一致、无序唯一、不可修改 -
用{}表示，元素间用逗号分隔
建立集合类型用{}或set() #空集合必须用set() A={1,2,('lalala',b)} #用{}之间建立 >>>{1,2,('lalala',b)} B=set('ppp123') #用set()建立，相同被去掉 >>>{'p','3','1','0'} #元素无序 -
集合运算：六个操作符（并|，差-，交&，补^，=<>关系操作符）
-
更新集合：四个增强操作符（修改前面集合S）
-
十个方法
S.add(x) #添加 S.discard(x) #移除（丢弃），无不异常 S.remove(x) #移除，无则异常 S.clear() #清空全部 S.pop() #随机返回S的一个元素，更新S，空则异常 S.copy() #返回S副本 len(S) #返回元素个数 x in S #判断在T/F x not in S #判断不在T/F set(x) #其他转变为集合类型 set() #生成空集合 -
#方法一：利用异常判断 遍历 >>> try: while True: print(B.pop(),end='') except: pass 312 #B.pop()取完之后B为空 >>> B #B=print(B) set() #B为空 #方法二：利用for in遍历 >>> for i in B: print(i,end='') 123 -
关系比较
-
数据去重
#由有重复元素的列表变为无重复元素的列表 >>> ls=[1,1,2,2,'py'] >>> S=set(ls) >>> S {'py', 1, 2} #列表->集合 >>>lt=list(S) >>>lt ['py',1,2] #集合->列表
序列类型：
-
有先后关系，可以相同，是一维元素向量
-
类似数学的序列，有下标，可通过下标访问
-
序号：正向递增序号0->4…
反向递减序号…-5<-1
-
六个操作符
x in s #判断有T/F x not in s #判断无T/F s+t #连接 s*n或n*s #复制n次 s[i] #索引，返回第i个元素 s[i:j]或s[i:j:k] #切片，返回第i到j以k为步长的元素子序列 #[0:5]取[0:5) #步长，从i开始每隔k-1取一下 -
#ls[::-1] 取反 >>> a="鸭梨亚是王" >>> a[::-1] '王是亚梨鸭' -
五个函数和方法
len(s) #列表长度 总个数 min(s) #最小元素 max(s) #最大元素 字母则按字母序比较 s.index(x) #返回第一个x的位置 s.index(x,i,j) #返回从i到j,第一个x的位置 s.count(x) #返回出现x的总次数
-
字符串类型
-
元组类型
-
元组是序列类型的一种扩展
-
创建不能被修改，因此没有特殊操作
-
使用()或tuple()创建，元素间用,分隔
-
可以不使用()
def func(): return 1,2 #返回的1,2是个元组类型 -
继承序列的全部通用操作
-
-
>>>animal="cat","dog","tiger","human" >>> animal ('cat', 'dog', 'tiger', 'human') #可以套娃 >>>color=(0x001100,"blue",animal) >>>color[-1][2] 'tiger'#[]索引的二重操作
-
-
列表类型
-
列表是序列类型的一种扩展
-
可以被随意修改
-
用[]或list()创建，元素用,分隔
>>>ls=[""cat","dog","tiger","human""] >>>ls ["cat","dog","tiger","human"] >>>lt=ls #赋值并不生成新列表 -
元素类型可以不同，无长度限制
-
-
操作函数和方法
ls[i] = x#替换列表ls第i元素为x ls[i:j:k] = lt#用lt替换ls切片后的子列表 del ls[i]#删除ls中的i元素 del ls[i:j:k]#删除ls中i到j以k为步长的元素 ls += lt#更新ls=ls+lt ls *=n#更新ls=ls重复n次实例
>>> ls=['a', 'b', 'c', 'd'] >>> ls[1:2] #切片[1,2) ['b'] >>>ls[1:2]=[1,2,3,4] ['a', 1, 2, 3, 4, 'c', 'd'] #替换 >>> del ls[::3] #从0每隔3步长（k-1）删除 [1, 2, 4, 'c'] >>> ls*=2 [1, 2, 4, 'c', 1, 2, 4, 'c'] -
其他方法
ls.append(x)#ls最后加元素x ls.clear()#删除全部元素 ls.copy()#生成一个新列表,并赋值 ls.insert(i,x)#在第i位置加x ls.pop(i)#删除第i位置元素 ls.remove(x)#删除第一个出现的x ls.reverse()#反转全部元素 sorted(ls)#可对列表进行排序 升序
-
-
序列的应用场景
- 元组用于元素不改变的场景，固定搭配场景
- 列表更加灵活，最常用
- 最主要作用：表达一组有序数据
- 数据保护用元组 #用tuple()转换
-
基本统计值
字典类型
-
映射：键keys(索引)->值values(数据)
-
字典是键值对的集合，键值对之间无序
-
采用
{}和dict()创建，键值对用:表示，元素之间用,分隔 -
用
[key]索引或增加元素（每个键值对） -
生成空字典
de = {}>>>d={"山西":"太原","山东":"济南"} >>>d {"山西":"太原","山东":"济南"} >>>d["山西"] #索引 '太原' >>>d["山西"]="朔州" #改变元素 >>>d["2"]="b";d["1"]="a" #用;隔开，增加元素 >>>d {"山西":"朔州","山东":"济南","2":"b","1":"a"} -
方法
del d[k] #删除字典d中k对应的值 k in d #判断k是否在d中，在Trun,不在False d.keys() #返回d的所有键 d.values() #返回d的所有值 d.items() #返回d的所有键值对 >>>dict_items([('a', '1'), ('b', '2')]) #返回的不是列表类型，需要拿for in来遍历 d.get(k,<default>)#键k存在，则返回对应值，不在则返回默认值<default> d.pop(k,<default>)#键k存在，则取出对应值，不在则返回默认值<default> d.popitem()#随机取出一个键值对，以元组形式返回 d.clear() #清除所有键值对 len(d) #返回元素（键值对）个数>>> d.get("山西","莫得")#返回对应值 '太原' >>> d.get("河南","莫得")#返回默认值 '莫得' >>> d.popitem() #随机取出一个键值对 ('山东', '济南') >>> d #删去取出来的键值对 {'河北': '石家庄', '山西': '太原'}
文件和数据格式化
文件的使用
文件是数据存储的一种形式（本质上是二进制形式存储）
以文本文件和二进制文件展示
-
文件的两种展示类型
-
文本文件
由单一特定编码组成，如 UTF-8
存在编码，也被看成存储着的长字符串，如 .txt文件、.py文件
-
二进制文件
直接由比特0/1组成，没有统一字符编码，如 .png文件、.avi文件
bf = open('china.txt','rt',encoding='UTF-8') print(bf.readline()) bf.close() >>>中国是个伟大的国家！ br = open('china.txt','rb') print(br.readline()) br.close() >>>b'\xe4\xb8\xad\xe5\x9b\xbd\xe6\x98\xaf\xe4\xb8\xaa\xe4\xbc\x9f\xe5\xa4\xa7\xe7\x9a\x84\xe5\x9b\xbd\xe5\xae\xb6!'
-
-
文件的打开和关闭
文件处理的步骤：打开->操作->关闭
存储状态
a = open( , )<->a.close()占用状态变量名（文件句柄）
打开文件:
<变量名> = open(<文件名(路径和名称)>,<打开模式>)
绝对路径：斜杠"D:/PYE/f.txt"或反斜杠"D:\\PYE\\f.txt"
相对路径："./PYE/f.txt"或"f.txt"打开模式：
"r"只读模式，默认值，不存在返回FileNotFoundError"w"覆盖写模式，不存在则创建，存在则完全覆盖"x"创建写模式，不存在则创建，存在返回FileExistsError"a"追加写模式，不存在则创建，存在则在文件后追加内容"b"二进制打开模式"t"文本打开模式，默认值"+"与r/w/x/a一同使用，在原功能基础上增加同时读写功能*“w+”*为读和覆盖写 文本打开模式
文件关闭：
<变量名>.close()不关闭则一直打开，直到程序退出
-
文件的读取
<f>.read(size=-1)读入全部内容，如果给出参数，读入前size长度<f>.readline(size=-1)读入一行内容，如果给出参数，读入该行前size长度<f>.readlines(hint=-1)读入文件所有行，以每行为元素形成列表，如果给出参数，读入前hint行>>>s = f.read(2) 中国 >>>s = f.readline() 中国是个伟大的国家！ >>>s = f.readlines() ["中国是一个伟大的国家！"]遍历全文本
#方法一 fo = open(fname,"r") txt = fo.read() #一次读入，统一处理 fo.close() #方法二 fo = open(fname,"r") txt = fo.read() while txt != "": #处理大文件 txt = fo.read(2) #按数量读入，逐步处理 fo.close()逐行遍历文本
#方法一 fo = open(fname,"r") for line in fo.readlines():#列表里每个元素是一行 print(line) #一次读入，分行处理 fo.close() #方法二 fo = open(fname,"r") #处理大文件 for line in fo: #分行读入，逐行处理 print(line) fo.close() -
数据的文件写入
<f>.write(s)向文件写入一个字符串或字节流<f>.writelines(lines)向一个元素全为字符串的列表写入文件<f>.seek(offset)改变当前文件操作指针(光标)的位置，offset含义如下：0-文件开头(默认)；1-当前位置；2-文件结尾；123456-到第123456为
>>>f.write("中国是个伟大的国家！") >>>ls = ["中国","法国","美国"] >>>f.writelines(ls) #列表中元素拼接写入，无换行空格 中国法国美国 >>>f.seek(0) #回到文件开头 ------------------------------------------------- fo = open("output.txt","w+") #w+覆盖写+读取+文本 ls = ["中国","法国","美国"] fo.writelines(ls) #写入 fo.seek(0) #不加seek的话，则无输出，因为指针在最后 for line in fo: #遍历全文的每一行 print(line) #逐行输出 fo.close() >>>中国法国美国
自动化脚本
- 定义数据文件格式（接口），程序和数据之间的一种规范
- 编写程序，根据文件接口解析参数绘制图形
- 编制数据文件
自动化思维：数据和功能分离，数据驱动的自动运行
接口化设计：格式化设计接口，清晰明了
二维数据应用：应用维度组织数据，二维数据最常用
一维数据的格式化和处理
一维数据：有序或无序数据构成，采用线性方式组织
对应列表、数组和集合等概念
二维数据：由多个一维数据构成，是一维数据的组合形式
表格是典型的二维数据
多维数据：由一维或二维数据在新维度上扩展形成
时间不同的多个表格
高维数据：利用最基本的二元关系展示数据间的复杂结构
键值对
-
数据的操作周期
存储（格式）<->表示（类型）<->操作（方式）
-
一维数据的表示：有序（列表），无序（集合）
-
一维数据的存储：空格分隔，逗号分隔，其他方式（推荐用特殊符号）
-
一维数据的处理：
file.split()<->str.join()#空格分隔 文件->列表 #中国 美国 日本 德国 法国 英国 意大利 txt = open(fname).read() ls = txt.split() #分割 f.close() >>>ls ['中国','美国','日本','德国','法国','英国','意大利'] #列表->文件 ls = ['中国','美国','日本'] txt = open(fname,"w") txt.write(" ".join(ls)) #str.join()每元素之间加空格 f.close()
二维数据的格式化和处理
使用列表类型表达二维数据，二维列表，[[a],[b]]
遍历每个元素：两层for循环
外层列表中每个元素对应行/列，一般索引习惯：ls[row][column]先行后列
-
CSV数据存储格式：Comma-Separataed Values以逗号分割值，国家通用
.csv扩展名 Excel软件可读入输出元素缺失，逗号仍要保留
表头可以作为数据存储，也可以另行存储
-
二维数据的处理：
#从CSV格式文件->列表 fo = open(fname) ls = [] for line in fo: linr = line.replace("\n","") #换行->空格 ls.append(line.split(","))#ls后加用,分隔的line fo.close() #列表->文件 ls = [[],[],[]] #二维列表 f = open(fname,"w") for item in ls: #行内元素加逗号，行的最后加个换行，w覆盖 f.write(",".join(item)+"\n") f.close() #遍历每个元素 二层循环 ls = [[],[],[]] #二维列表 for row in ls: for column in row: print(ls[row][column]) #二维索引方式
wordcloud库
词云展示第三方库
wordcloud.WordCloud()代表一个文本对应的词云对象
w = wordcloud.WordCloud() #以WordCloud对象为基础
#两个常规方法
w.generate(txt)#向WordCloud对象w中加载文本txt
>>>w.generate("Python and WordCloud")
w.to_file(filename)
>>>w.to_file("outfile.png")#将词云输出为图像文件，.png/.jpg
#默认400*200
- 绘制词云三步走：
- 配置对象参数
- 加载词云文本
- 输出词云文件
以空格分割，单词出现多则尺寸大，单词短则可能被过滤
import wordcloud #c是词云对象
c = wordcloud.WordCloud() #配置对象参数
c.generate("wordcloud by Python") #加载词云文本
c.to_file("wc.png") #输出文件
-
配置对象参数
w = wordcloud.WordCloud(<参数>)width生成图片的宽度，默认400pxheight生成图片的高度，默认200pxmin_font_size字体的最小字号，默认4号max_font_size字体的最大字号根据高度自动调节font_step字体字号的步进间隔，默认为1font_path指定字体文件的路径（文件名），默认None，.ttc字体文件格式max_words最大单词数量，默认200stop_words排除词列表，一般通过集合类型{}background_color指定词云图片的背景颜色，默认为黑色mask词云遮罩，默认为长方形，需要引用imread()函数，白色蒙版from imageio import imread #import scipy.misc mk = imread("pic.png") ...... w = wordcloud.WordCloud(mask=mk)#配置的时候加mask -
利用jieba库对中文绘制词云
import jieba import wordcloud txt = "程序设计语言是计算机能够理解和\ 识别用户操作意图的一种交互体系，它按照\ 特定规则组织计算机指令，使计算机能够自\ 动进行各种运算处理。" w = wordcloud.WordCloud(width=1000,\#微软雅黑.ttc font_path="msyh.ttc",\ height=700)#必须要加字体 w.generate(" ".join(jieba.lcut(txt))) w.to_file("chinesewordcloud.png")
#阿里旺旺的皮囊 import jieba import wordcloud from imageio import imread mk = imread("阿里旺旺.jpg") #必须是jpg，白色遮罩 f = open("皮囊.txt",encoding="UTF-8") essay = f.read() f.close() ls = jieba.lcut(essay) txt = " ".join(ls) w = wordcloud.WordCloud( height=800, width=800, background_color="white", font_path="msyh.ttc", mask=mk ) w.generate(txt) w.to_file("阿里旺旺的皮囊.png")
程序设计方法学
自顶向下（设计）：总问题->若干小问题 分而治之
自底向上（执行）：分单元测试，逐步组装 模块化集成
体育竞技分析 main()
-
打印程序的介绍性信息式 -printInfo()
-
获得程序运行参数：proA,proB,n - getInputs()
-
利用球员A和B的能力值pro，模拟n局比赛 -simNGames()
模拟一局比赛，循环n次 -simOneGame()
一局比赛结束的判断标准 -gameOver()
-
输出球员A和B获胜比赛的场次及概率 -printSummary()
程序设计思维
计算思维：抽象问题的计算过程，利用计算机自动化求解
计算生态：开源思想的深入演化和发展，形成了计算生态
用户体验：实现功能->关注体验，编程只是手段，不是目的
软件程序->软件产品 关键环节就是用户体验
- 进度展示
- 可能产生等待，请增加进度展示
- 若有若干步骤，需要提醒用户，请增加进度展示
- 可能存在大量循环，请增加进度展示
- 异常处理
- 获得用户输入，对合规性需要检查，需要异常处理
- 当读写文件时，对结果进行判断，需要异常处理
- 当进行输入输出时，对运算结果进行判断，需要异常处理
- 其他类方法
- 打印输出：特定位置，输出程序运行的过程信息
- 日志文件：对程序异常及用户使用进行定期记录
- 帮助信息：给用户多种方式提供帮助信息
基本程序设计模式
- IPO：Input-Process-Output
- 模块化设计：通过函数或对象封装程序，高内聚，低耦合
- 配置化设计：将数据（配置）和程序（引擎）分离，将可选参数配置化，不修改程序，关键在接口设计。
应用开发
- 产品定义
- 系统架构
- 设计与实现
- 用户体验
第三方库的安装
Python社区：https://pypi.org/
PyPI：Python Package Index
Anaconda：集成安装800个第三方库，多个主流工具，适合数据计算领域开发
-
文件安装方法：某些库pip下载后，但无法安装，需要编译再安装
-
UCI页面：http://www.lfd.uci.edu/~gonhlke/pythonlibs/
在wins下直接编译后的版本
pip install <文件名>进行安装
OS库
标准库
os库提供通用的。基本的操作系统交互功能
-
路径操作：
os.path子库，处理文件路径及信息#以path为入口，用户操作和处理文件路径 import os.path import os.path as op #op为别名 os.path.abspath(path)#返回path在当前系统中的绝对路径 os.path.onormpath(path)#归一化path的表示形式，统一用\\分隔路径，//变成\\ >>>op.onormpath("D://PYE//file.txt") "D:\\PYE\\file.txt" os.path.relpath(path)#返回当前程序与文件之间的相对路径（relative path） os.path.dirname(path)#返回path中的目录名称 os.path.basename(path)#返回path中最后的文件名称 os.path.join(path,*paths)#组合path与paths，返回一个路径字符串 >>>op.join("D://"，"PYE/file.txt") "D:/PYE/file.txt" os.path.exists(path)#判断path对应文件或目录是否存在，返回True或Flase os.path.isflie(path)#判断path对应是否为已存在的文件，返回True或False os.path.isdir(path)#判断path对应是否为已存在的目录,返回True或False >>>op.isdir("D://PYE//file.txt") False #file.txt不是目录，则返回False os.path.getatime(path)#返回上一次访问时间access os.path.getmtime(path)#返回修改时间modify os.path.getctime(paeh)#返回创建时间creat >>>time.ctime(op.getctime("D:/file.txt")) "Sum Fel 11 21:43:53 2018" os.path.getsize(path)#返回path对应文件的大小，字节单位 >>>op.getsize(D:/PYE/file.txt) 180768 -
进程管理：启动系统中其他程序
os.system(command)#执行程序或命令command，wins中返回值为cmd的调用返回信息 >>>os.system("C:\\Windows\\System32\\calc.exe") 0 #返回一个0，表示正确运行 >>>os.system("C:\\Windows\\System32\\mspaint.exe \ D:\\PYECourse\\grwordcloud.png") 0 #用画图软件打开grwordclouod.png文件，空格隔开 -
环境参数：获得系统软硬件信息等环境参数
os.chdir(path)#修改当前程序操作的路径 >>>os.chdir("D:") os.getcwd()#返回程序的当前路径 >>>os.getcwd() "E:\\" os.getlogin()#返回当前系统登录用户名称 os.cpu_count()#返回当前系统的CPU数量 os.urandom(n)#获得n个字节长度的随机字符串，通常用于加解密
第三方库自动安装脚本
import os
libs = {"sklearn","wheel","networkx","sympy","django",\
"flask","werobot","pandas","docopt","docopt"}
try:
for lib in libs:
os.system("pip install "+lib)
print("Successful")
except:
print("Failed Somehow")
random库
使用随机数的Python标准库
- 伪随机数（梅森选择算法）
- 基本随机数函数：
seed(),random() - 扩展随机数函数：
import random as r #需要再现，可以设置种子
r.seed(a=None) #初始化给定随机数种子，默认为当前系统时间
r.random() #产生一个[0.0,1.0)之间的随机小数
----------------------------------------------
r.randint(a,b) #生成一个[a,b]之间的整数
r.randrange(m,n[,k])#生成一个[m,n)之间以k为步长的随机整数
r.getrandbits(k) #生成一个k比特长的随机整数 [0,2^k]
r.uniform(a,b) #生成一个[a,b]之间的随机小数
r.choice(seq) #从序列seq中随机选择一个元素
r.shuffle(seq) #对序列seq中元素随机排列，返回打乱后的序列
jieba库分词
- 精确模式：无冗余，常用
jieba.lcut(String,) - 全模式：冗余
jieba.lcut(String,cut_all=True) - 搜索引擎模式：冗余，长词切短词
jieba.lcut_for_search(String,) - 向分词词典增加新词w：
jieba.add_word("李泽亚")
time库
时间获取 time(),ctime(),gmtime()
import time as t #1970/1/1/0:0:0开始 以秒s为单位的数值
t.time() #获取当前时间戳，计算机内部时间值，浮点数
>>>1583941082.6089659
t.ctime() #获取当前时间并以易读方式表示，返回字符串
>>>'Wed Mar 11 23:38:24 2020'
t.gmtime() #获取当前时间，计算机可处理的格式
#世界标准时间（即格林尼治时间），中国晚8小时
t.localtime() #获取本地时间
>>>time.struct_time(tm_year=2020, tm_mon=3, tm_mday=11, tm_hour=15, tm_min=40, tm_sec=58, tm_wday=2, tm_yday=71, tm_isdst=0)
时间格式化 strftime(),strptime()
import time as t #gmyime格式↓
t.strftime(tpl,ts) #tpl格式化模板字符串，ts是内部时间类型变量
#返回字符串
t.strptime(str,tpl) #str是字符串形式的时间值，tpl是模板字符串
#返回时间类型
# %Y年份1900, %m月份01, %B月份名称April,
# %b月份名称缩写Apr, %d日期02, %A星期Monday,
# %a星期缩写Mon, %H二十四小时制22, %h十二小时制06,
# %p上/下午PM, %M分钟38, %S秒26
>>>a=t.gmtime()
>>>t.strftime("%Y-%m-%d %H:%M:%S",a) #格式化
'2020-03-11 15:47:12'
>>>timeStr = '2020-03-11 15:47:12'
>>>t.strptime(timeStr,"%Y-%m-%d %H:%M:%S") #解析
time.struct_time(tm_year=2020, tm_mon=3, tm_mday=11, tm_hour=15, tm_min=47, tm_sec=12, tm_wday=2, tm_yday=71, tm_isdst=-1)
程序计时 sleep(),perf_counter()
from time import perf_counter,sleep #单位为秒，精确到纳秒
perf_counter() #测量时间
sleep(s) #拟休眠的时间，单位是秒，可以是浮点数
#对程序运行进行计时
>>>start = perf_counter() #记录开始时间
>>>time = per_counter() - start#开始时间-结束时间=所用时间
#程序等待3.3秒再退出
>>>def wait():
time.sleep(3.3)
>>>wait()
计算生态概述
数据分析
- numpy：表达N维数组的最基础库
- Pandas：数据分析高层次应用库
- SciPy：数学、科学和工程计算功能库（类似Matlab）
数据可视化
- Matplotlib：高质量的二维数据可视化功能库
- Seaborn：统计类数据可视化功能库
- Mayavi：三维科学数据可视化功能库
文本处理
- PyPDF2：处理PDF文件的工具集
- NLTK：自然语言文本处理第三方库
- Python-docx：创建或更新Microsoft Word文件的第三方库
机器学习
- Scikit-learn：机器学习方法工具集
- TensorFlow：AlphaGo背后的机器学习技术框架
- MXNet：基于神经网络的深度学习计算框架
Web解析
- Requests：最友好的网络爬虫功能库
- Scrapy：优秀的网络爬虫框架，数据分析高层次应用库
- pyspider：强大的Web页面爬取系统
Web信息提取
- Beautiful Soup：HTML和XML的解析库
- Re：regular expression正则表达式解析和处理功能库，标准库之一
- Python-Goose：提取文章类型Web页面的功能库
Web网站开发
- Django：最流行的Web应用框架，略辅助
- Pyramid：规模适中的Web应用框架
- Flask：Web应用开发微框架
网络应用开发
- WeRoBot：微信公众号开发框架，微信消息反馈，微信机器人
- aip：百度AI开放平台接口
- MyQR：二维码生成第三方库
图形用户界面GUI
- PyQt5：Qt开发框架的Python接口，推荐，跨平台
- wxPython：跨平台GUI开发框架
- PyGObject：使用GTK+开发GUI的功能库
游戏开发
- PyGame：简单的游戏开发功能库，最主要
- Panda3D：开源、跨平台的3D渲染和游戏开发库，3D游戏引擎
- cocos2d：构建2D游戏和图形界面交互式应用的框架
虚拟现实
- VR Zero：在树莓派上开发VR应用的Python库，初学者
- pyovr：Oculus Rift的Python开发接口
- Vizard：基于Python的通用VR开发引擎
图形艺术
- Quads：迭代的艺术，四分迭代，像素风
- ascii_art：ASCII艺术库
- turtle：海龟绘图体系
字符串转换，去""
#功能形式1表现
#列表字符串
s = '[[1,2],[3,4]]'
b = eval(s) #eval()去''
print(b) #[[1, 2], [3, 4]]
print(type(eval(s))) #<class ‘list’>
print(type(s)) #<class ‘str’>
#功能形式2表现
a = 10
b = 20
c = eval( "a+b")
print(c) #运行了‘a+b’ 输出：30
功能形式：
- b = eval(s),去掉字符串 str 类型外套，恢复里面内容类型赋给 b，但不改变s的类型
- 将字符串 str 当成有效的表达式来求值并返回计算结果
split() 方法
#str.split(str="", num=string.count(str)).
i="1,2,3"
a=i.split(",",1)
print(a)
#输出['1', '2,3']
- str – 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。
- num – 分割次数。默认为 -1, 即分隔所有。
Flask框架-python里的Web框架
- Django,Flask
openCV
认识图像
-
图片格式
-
.bmp无损、老格式、体积大
-
.jpg(jpeg)用最少的磁盘空间得到较好的图片质量
-
.png无损压缩的位图片行格式（首选）
-
-
图片类型
- 黑白
- 彩色
-
图片本质
- 由像素点组成，就是一个矩阵
- 每个元素（像素点）都是在[0,255]
黑白图像
-
位图模式（黑白图像）
仅仅只有1位深度的图像 用0,1表示 一个像素点一位，非0即1
0->纯黑色
1->纯白色
-
灰度图像[0,255]
有八位深度的图像 一个像素点八位
(0,0,0,0,0,0,0,0)->2^0=1->(纯黑色)
(1,1,1,1,1,1,1,1)->2^8=256(纯白色)
Python从0开始计数
[1,256]->[0,255]
彩色图像
-
三个通道RGB
- R->red
- G->green
- B->blue
-
每个通道8个深度
256^3个颜色
读取图像
- 所有路径必须是英文路径，中文报错
- 储存类型：uint8->无符号8位整型(0,1,0,1,0,1,0,1)
CV2.imshow()
cv2.imshow('image2',img) #（'打开窗口的名字'，引用文件）
#图片未响应时的解决方案
cv2.waitKey()
cv2.destroyAllWindows()
用numpy进行拼接
import numpy as np
new_w = img_white[:100,:100]
new_b = img_black[:100,:100]
#垂直拼接 Vertival
new_v = np.vstack((new_w,new_b))#白上黑下
cv2.imshow('垂直拼接',new_v)
#水平拼接 Horizontal
new_h = np.hstack((new_w,new_b))#白左黑右
cv2.imshow('水平拼接',new_h)
cv2读取和保存图像
- 读取
cv2.imread(path,0) # path路径 0代表灰度图 1代表彩色图
- 保存
cv2.imwrite(path,target) #path包含[文件名.png/.jpg]
输出图片的形状
print img.shape
>>>(774, 1200, 3) #H-W*3 三通道
python 执行终端/控制台命令
import os
os.system()
os.popen().read().strip()
#上面2种方法 是python 执行终端/控制台 命令的常见方法
#os.system('ping www.baidu.com') 执行成功 返回 0
#ping = os.popen('pint www.baidu.com').read().strip() 返回输出结果
#注：os.system() 执行完成 会关闭 所以当执行后续 命令需要依赖前面的命令时，请将多条命令写到一个 os.system() 内
#但 这个方法执行的时候 是无法交互的 比如说 命令权限不够 需要输入登陆密码 可使用下面这种方法
import pexpect
ch = pepect.spwn('命令')
ch.expect('Password:')
ch.sendline('密码')
selenium库
Selenium是一个用于Web应用程序测试的工具，直接运行在浏览器中,就像真正的用户在操作一样
不同浏览器需要下载不同的驱动文件driver.exe
from selenium import webdriver
#打开驱动
driver = webdriver.Chrome(r'G:\Python\stuff\chromedriver.exe')
#打开淘宝网
driver.get('https://www.taobao.com')
#根据xpath找到标签，点击
driver.find_element_by_xpath('/html/body').click()
#根据文字找到标签，点击
driver.find_element_by_link_text('结 算').click()
easygui库
import easygui as g
--------------------'按钮选择框'-----------------------
#消息框，一个按钮
g.msgbox("我一定要学会编程!", ok_button="加油!")
#单选框，两个按钮，返回布尔型
if g.ccbox('要再来一次吗？', choices=('要啊要啊^_^', '算了吧T_T')):
g.msgbox('不给玩了，再玩就玩坏了......')
#单选框，多个按钮
buttonbox(msg='', title=' ', choices=('Button1', 'Button2', 'Button3'), image=None, root=None)
--------------------'列表选项框'-----------------------
#单选列表型，提供一系列选项
g.choicebox('你的性别？',choices = ['男','女'])
#多选列表型,提供一系列选项
g.multchoicebox(msg='选择你爱吃的，可多选', title='选择食物', choices=['梨','橙','杏'])
----------------------'输入框'------------------------
#一个显式文本输入框，返回值为用户输入的字符串。默认返回的值会自动去除首尾的空格，如果需要保留首尾空格的话请设置参数 strip=False。
g.enterbox(msg='Enter something.', title=' ', default='', strip=True, image=None, root=None)
#多个显式文本输入框，返回值列表，feilds条目名，values是默认值
g.multenterbox(msg=' ', title=' ', fields=['用户名','密码','验证码'], values=())
#一个隐式*文本输入框，返回输入文本
g.passwordbox(msg=' ', title=' ', default=' ', image=None, root=None)
#多个显式文本输入框，最后一个隐式文本输入框
g.multpasswordbox()
-------------------'展示文本框'------------------------
g.textbox(msg='', title=' ', text= open('E:\\TheThreeKingdom.txt','r'), codebox=0)#1为等宽
-------------------'目录与文件'------------------------
#选择一个目录，返回目录路径，选择"Cancel"则返回 None
g.diropenbox(msg=None, title=None, default=None)
#选择一个文件，返回文件路径，default 参数指定一个默认路径
g.fileopenbox(msg=None, title=None, default=None,filetypes=None)
#保存一个文件
g.filesavebox(msg=None, title=None, default='', filetypes=None)
#如果设置了 default 参数，fileopenbox() 显示默认的文件路径和格式。
#default="c:/fishc/*.py" 即显示 C:\fishc 文件夹下所有的 Python 文件。
#default="c:/fishc/test*.py" 即显示 C:\fishc 文件夹下所有的名字以 test 开头的 Python 文件。
#filetypes = ["*.txt"]列表的最后一项字符串是文件类型的描述，例如：filetypes = ["*.css", ["*.htm", "*.html", "HTML files"]]
---------------------'异常捕获'------------------------
#出现异常，弹出异常框，里面显示异常的信息
g.exceptionbox()
例子 try:
print('I Love FishC.com!')
int('FISHC') # 这里会产生异常
except:
exceptionbox()
#msg='输入一个数' 显示消息
#title='记事本' 定义弹出框名字
#image='a.jpg' 框内图片
#root=None 主窗口
'''
使用tkinter.Tk() 生成主窗口（root=tkinter.Tk()）；
root.title('标题名') 修改框体的名字,也可在创建时使用className参数来命名；
root.resizable(0,0) 框体大小可调性，分别表示x,y方向的可变性
root.geometry('250x150') 指定主框体大小；
root.quit() 退出；
root.update_idletasks()
root.update() 刷新页面；
root.iconbitmap('小鸡.ico') 窗口图标
'''
main主函数
__name__是Python的内置变量，用于指代当前模块。- 当我们把模块A中的代码在模块B中进行import A时，只要B模块代码运行到该import语句，模块A的代码会被执行。
if __name__==’__main__:可以避免导入模块而直接执行。 - 当运行
if __name__=='__main__':语句时，如果当前模块时被直接执行，name__的值就是__main，条件判断的结果为True，if __name__=='__main__':下面的代码块就会被执行。
# 模块A
print('你好，我是模块A……')
print('模块A中__name__的值：{}'.format(__name__))
print('-------------------------')
# 模块B
from package01 import A
print('你好，我是模块B……')
print('模块B中__name__的值：{}'.format(__name__))
------------------------------------------------------
执行A模块时，输出结果：
你好，我是模块A……
模块A中__name__的值：__main__
-------------------------
执行B模块时，输出结果：
你好，我是模块A……
模块A中__name__的值：package01.A
-------------------------
你好，我是模块B……
模块B中__name__的值：__main__
正则表达式
规则
字符类别（量词）
\w 匹配单词
\d 一个数字
\D 一个非数字字符
\d+ = \d\d\d\d\d…\d 匹配1位数字
\d* 匹配0个或者多个数字
\d? 匹配0位或者1位数字
\d{4} 出现4位的数字
\d{3,4} 出现3位或4位的数字
\d{3,} 出现3位以上的数字
\d{,4} 出现4位以下的数字‘
1\d{10} 提取1开头的11位数字
| 或者、多选
^ 只在字符串的开头匹配，位置信息
(?<=密码) 只在“密码”之后匹配，位置信息
(?<=密码.) 只在“密码”之后匹配，位置信息
re模块
查找
search 只返回一个match迭代器
match 只返回一个match迭代器，从头开始匹配
findall 返回字符串
finditer 返回match迭代器
group 分组
替换
sub
subn
分割
split
爬虫
类的定义
class Person
4265
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
