前言
1python的创造者是“龟叔”Guido van Rossum
2python语言的缺点
3解释器
4命令行模式与交互模式
5如何执行python文件?
在命令模式下在hello.py目录learn下执行以下语句。在交互模式中直接输入代码执行
C:\learn> python hello.py
6python常用的库以及用法
基础语法
1输入与输出
输出:print()
print('hello,world')print('The quick brown fox', 'jumps over', 'the lazy dog')
注意,如果采用第二种方式,print()
会依次打印每个字符串,遇到逗号“,”会输出一个空格
输入:input()
#注意,是字符串输入name = input()#可以是有提示的输入name = input('please enter your name: ')print('hello,', name)#输入两个整数a,b=map(int,input().split())#输入两个字符串a,b=input().split()
2数据类型
总结:字符串和元组合是不可变的,字符串、元组、列表是有序的
print('\\\t\\')print(r'\\\t\\')print('''line1line2line3''')
3运算符号
结论://和%的结果一定是整数,因此其运算结果一定是精确的
优先级
4字符编码
内存:Unicode
外存/浏览器源码/传输数据:UTF-8
5字符串
使用Unicode进行编码
>>> len('中文')2>>> len('中文'.encode('utf-8'))6>>> len('ABC')3>>> len(b'ABC')3#大小写转换w = "100hello WORLD"w.upper()Out[72]: '100HELLO WORLD'w.lower()Out[73]: '100hello world'w.title()Out[74]: '100Hello World'w.capitalize()Out[75]: '100hello world'
注意:我们从网络或磁盘上读取了字节流,用的就是bytes,由于我们在操作字符串的时候经常遇到str和bytes的互相转化,为了避免乱码,应该坚持使用UTF-8来进行转化,就是encode和decode后面的参数是utf-8。
str是不可变对象
>>> a = 'abc'>>> a.replace('a', 'A')'Abc'#上面的实际是创建了一个新的对象>>> a'abc'
解释:对于不变对象来说,调用对象自身的任意方法,也不会改变该对象自身的内容。相反,这些方法会创建新的对象并返回,这样,就保证了不可变对象本身永远是不可变的。
python中的不变对象有:str None
取出特定字符之间的子字符串
#此处为取出[ ]之间的字符串 m=re.findall(r"\[(.+?)\]",L)
6格式化
和c语言的输出一样的
%x 十六进制整数
print('%s has %d dollars'%('Tom',100))print('%s'%(3))#这里的3有没有'都是可以的,因为s是可以自动转化整数为字符串#指定输出几位以及输出的几位前面需不需要补上0print('%2d-%02d' % (3, 1))#输出的小数点数量print('%.2f' % 3.1415926)#输出带%的时候print('%d %%' % (7))
#format()>>> 'Hello, {0}, 成绩提升了 {1:.1f}%'.format('小明', 17.125)'Hello, 小明, 成绩提升了 17.1%'#f-string>>> r = 2.5>>> s = 3.14 * r ** 2>>> print(f'The area of a circle with radius {r} is {s:.2f}')The area of a circle with radius 2.5 is 19.62
7特殊数据类型list
列表:一种集合
里面的元素数据类型可以不一样,而且可以套娃,例如
s = ['python', 'java', ['asp', 'php'], 'scheme']#即为p = ['asp', 'php']s = ['python', 'java', p, 'scheme']
实现二维数组
l1=[]i=0while i<5:l1.append([])i+=1l1.append('你好')
与random库结合使用
L=[3,4,1,3,4,5,1]#在列表中随机抽取一个对象random.choice(L)#列表打乱random.shuffle(L)
8特殊数据类型tuple
区别于list:初始化后不可修改
#没有元素时t = ()#1个元素t = (1,)#2个元素时候t = (1, 2)
注意:如果是1个元素,t=(1)是错误的,因为这样既可以表示tuple又可以表示数学计算的小括号,python默认是后者,因此上述式子相当于t=1
不变指的是指的对象不变,对象的内容有可能变的,那就是list,如下
>>> t = ('a', 'b', ['A', 'B'])>>> t[2][0] = 'X'>>> t[2][1] = 'Y'>>> t('a', 'b', ['X', 'Y'])
9特殊数据类型set
与list相比,只是内部不可以重复
一般是用来当作去重工具使用
>>> s = set([1, 1, 2, 2, 3, 3])>>> s{1, 2, 3} #print的结果也是{}
10特殊数据类型dict
字典:存储方式:键-值,方便快速查找。很类似一个二维数组或者指针数组
d={'Anne':96,'Bob':84,'Candy':87}print(d['Anne'])
区别:与list相比,其查找插入的速度快,不会随着元素的增加而变慢,但是需要占用大量的内存
11条件控制语句
age = 20if age >= 18:print('adult')elif age >= 6:print('teenager')else:print('kid')if <条件判断1>:<执行1>elif <条件判断2>:<执行2>elif <条件判断3>:<执行3>else:<执行4>
注意:python判断从上至下,一旦一个判断是True,下面的就不会执行了,比如上面的结果是adult
简写形式,类似于switch
if x:print('True')
12循环
for...in循环:一般用于遍历
names = ['Michael', 'Bob', 'Tracy']for name in names:print(name)
计算1+2+3+...+100
#range(n)是自动生成0~n的整数序列#range(101)是从0到100,总共101个数字sum = 0for x in range(101):sum = sum + xprint(sum)#配合list使用ls1=[i for i in range(1,101)]print(sum(ls1))#输出0~100的整数print(list(range(101)))
while循环
sum=0n=100while n>0:sum+=nn-=1print(sum)
当然,break和continue也同样适用
13数据类型转换
基本数据类型转化
>>> int('123')123>>> int(12.34)12>>> float('12.34')12.34>>> str(1.23)'1.23'>>> str(100)'100'>>> bool(1)True>>> bool('')False
str list dict 类型转化
#list-->strs = ''.join(l)#list-->dictl1 = ['a', 'b', 'c']l2 = [1, 2, 3]dict(zip(l1,l2))#str-->listl=s.split(',')适合都是逗号或者空格的或者l=list(s)#str-->dicts = '{"id": 1, "name": "li"}' d = eval(s)#dict-->listd = {'a': 1, 'b': 2, 'c': 3}list(d)## ['a', 'b', 'c']list(d.keys())## ['a', 'b', 'c']list(d.values())## [1, 2, 3]#dict-->strstr(d)
尤其注意list-->dict的时候
zip的底层原理是遍历赋值,如果l1有重复的字段那就赋l2最后一个值
l1 = ['a', 'b', 'a']l2 = [1, 2, 3]dict(zip(l1,l2))## {'a': 3, 'b': 2}dict(zip(l2,l1))## {1: 'a', 2: 'b', 3: 'a'}
字符串常见处理
#str类型头尾去掉符号str2.strip( ',' )
函数
1将一个函数名赋值到一个变量
>>> a = abs # 变量a指向abs函数>>> a(-1) # 所以也可以通过a调用abs函数1
2自定义函数
格式 def 函数名(参数):
函数体
def my_abs(x):if x >= 0:return xelse:return -x#使用三元表达式def my_abs(x):return x if x>=0 eles -x
注意:如果没有写return,实际也会有return的,也就是None
3空函数
pass:什么都不做,一般用作现在还没想好怎么写,但是先让程序跑起来
def nop():passif age >= 18:pass
4返回多个值
def hello(x,y):return x,yprint(hello(1,2))#结果为(1,2)a,b=hello(1,2)#获取返回值
由结果(1,2)可以知道其实际返回的就是一个tuple
5默认参数的函数
背景:如果我想用同一个函数的不同参数,系统会报错说参数不对。
做法:设置默认参数默认,必选参数在前,变化大的参数在后,例如下
def power(x, n=2):s = 1while n > 0:n = n - 1s = s * xreturn s
因此power(5)等价于power(5,2),而且不影响power(5,4)的使用
改变默认参数方法
power(6,n=8)
易错知识:默认参数必须指向不变对象
def add(L=[])L.append('END')return L#对象不是L的情况>>>add([1,2,4])[1,2,4,'END']>>>add([2,2,2])[2,2,2,'END']#对象是L的情况>>>add()['END']>>>add()['END','END']
但是这样每次add都会多一个END,我想每次只输出一个END该怎么办呢?
---使用None这个不变对象
def add(L=None)if L is None:L=[]L.append('END')return L
6可变参数函数*--可扩展变值
在变量前面加上*
比如要用 a^2+b^2+c^2+...def add(*numbers):sum=0for n in numbers:sum+=n*nreturn sum#不变参数的list和tuple也可以变成可变参数,只要在其前面加上*num=[1,2,3,4]add[*num]
7关键字参数**--可扩展变值和名称,选填
#name和sex是必选项,00是可选项,也可以进行扩充#一般用与可选项与必选项def person(name,sex,**oo):print('name:',name,'sex:',sex,'other',oo)person('a','b',city='北京',age='7')>>> name: a sex: b other {'city': '北京', 'age': '7'}#另外一种表现形式,就是将**oo单独拉出来ok={'city:':'Beijing','age:':'7'}person('a','b',city=ok['city'],age=ok['age'])
8命名关键字参数*--不可扩展值和名称,必填
//只接收city和job作为关键字参数。def person(name, age, *, city, job):print(name, age, city, job)person('Jack', 24, city='Beijing', job='Engineer')
实际应用类似于问卷调查中的是否有其他想法,而且要求是必填的
与关键字参数的不同在于它的关键字的不能扩展也不能修改名字
9小总结
*argc和**kw是python的习惯写法
10递归函数
n!def fact(n):if n==1:return 1else:return n*fact(n-1)
#汉诺塔问题def move(n,a,b,c):if n==1:print(a,'-->',c)else:move(n-1,a,c,b)#将A上面的n-1个移动到bmove(1,a,b,c)#将A底层的1个移动到cmove(n-1,b,a,c)#将b上面的n-1个移动到c
可能会发生栈溢出,可以使用尾递归优化来解决
11 Iterable
可迭代对象,看能否直接用for循环
isinstance(~,Iterable),结果如下
区别:生成器表达式和列表解析的区别
l=["a"for i in range(10)]
w=(“a” for i in range(10))
列表解析式的返回结果是一个list而生成器表达式的返回是一个generatorgenerator是每次读取部分数据,而list是一次性读取所有的数据,因此在数据量大的时候list会非常的浪费内容生成器最外层是(),列表最外层是[ ]生成器只能遍历一次,列表可以遍历无数次
12常用技巧
#切片实现去除字符串首尾的空格def trim(s):l=len(s)if s==l*(' '):return ''else:while s[0]==' ':s=s[1:]while s[-1]==' ':s=s[:-1]return #list表达式#100以内数字,奇数为负数,偶数为0[-x if x%2==1 else 0 for x in range(1,11)]#generator函数实现斐波那契数列def fib(max):n,a,b=0,0,1while n<max:yield ba,b=b,b+an+=1return 'done'print([x for x in fib(6)])#注意,如果直接输出fib(5)的话会返回一个generator对象#实际上,每次执行时遇到yield停止,然后下一次的执行送yield的下面开始的#有yield的标志都是generator函数#杨辉三角def triangles():l=[1]while(True):yield lx=[0]+ly=l+[0]l=[x[i]+y[i] for i in range(len(x))]n = 0results = []for t in triangles():results.append(t)n = n + 1if n == 10:breakfor t in results:print(t)
函数式编程
1高阶函数
变量既可以指向一个对象也可以指向一个函数,所以函数名可以看成指向一个函数的变量
如def add()m=add
高阶函数:函数的参数可以是另一个函数名
2 map函数
作用,将数值集进行函数计算返回数值集,返回一个generator对象
格式:map(f,l) :f为函数,l为Iterable可循环对象
def f(x):return x*xr=map(f,[1,2,3,4,5])l=list(r) #list()函数让Iterator对象变成listprint(l)#也可以实现与list列表生成器的功能list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
3 reduce函数
相当于一个递归函数,每次将前两个参数进行函数计算
#将数字字符串转化为数字from functools import reduced = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}def strtoint(s):def fn(x,y):return x*10+ydef charmnum(s):return d[s]return reduce(fn,map(charmnum,s))#首先将s遍历使用charmnum变成数字list,随后递归相加print(strtoint('123412'))
4 filter()函数
作用:过滤序列
格式:fileter(f,l)f为一个函数,l为Iterable
区别:map主要用于计算,filter主要用于过滤
底层逻辑:将每个Iterable进行计算,True留False丢
5 sorted()函数
实现排序
#正常排序sorted(L)#倒序sorted(L,reverse=True)#按照特定内容排序,特定内容可理解为函数,然后对数值有一个返回#如按照绝对值排序sorted(L,key=abs)#按照分数排序L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]def by_score(t):return t[1]L2 = sorted(L, key=by_score)print(L2)
L.sort()和sorted(L)函数的区别
L=[1,5,4,54,5]#sort必须要单独的一行进行排序,print(L.sort())的输出是NoneL.sort()print(L)print(sorted(L))
6匿名函数lambda
作用:表示是一个表达式,也可认为是不需要命名函数的名字,随时随用。如下
list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
这样我们就不需要单独的写一个函数出来
当然,既然是匿名函数,他本质上还是一个函数,所以也可以赋值给变量上,如下
f = lambda x: x * x
总结:可以拿来当做一个工具,和列表表达式一起结合使用
7库
注意:上述的几个函数在Python3中需要导入库functools
8装饰器Decorator
pass
9偏函数
pass
模块
一个.py文件就是一个模块
mycompany.web
也是一个模块,它的文件名叫做__init__.py。每个包下面都有这个模块,如果没有的话,python就会把它当做普通的目录而不是一个包。
常见的标准模块:string、os、sys、time、re、random(random、randint、uniform等)、math(sqrt、sin、cos、exp、log)
面向对象编程OOP
1 三大特性:封装+继承+多态
2类
#这里的Object指的是父类对象,如果没有继承的话还是要写Object的class Student(object):#注意,这里的__init__是初始化方法,第一个永远是self,实例化的时候不需要写上selfdef __init__(self, name, score):self.name = nameself.score = scoredef print_score(self):print('%s: %s' % (self.name, self.score))bart = Student('Bart Simpson', 59)
注意类的写法和初始化
3访问限制--封装
目的:为了安全性,或者说更方便的扩展类的属性一些操作,而使实例化对象不能使用如对象.Name或者对象.__Name的方式来直接访问
做法:就是在属性的前面加上__
如果需要访问,就建立一个set和get的方法如下
class Student(object):def __init__(self, name, score):self.__name = nameself.__score = scoredef get_name(self):return self.__namedef get_score(self):return self.__score
注意:如果你使用了如Student.__Name="大白菜",随后进行打印这个东西,结果是大白菜的,但是,实际上是没有对它内部的属性进行修改,底层逻辑是创建了一个新的对象
其实私有化的变量也是可以取到的,只要用如s1._Studeng__name
因此,Python中没有完全的私有,它只是制定了一个规则让你获取属性更加困难
4继承和多态
如类class Student(object):中将object修改为父类即可
class Timer(object):def run(self):print('Start...')
注意:由于python有动态变量的特征,所以它不管你有什么类,只要你这个类中有相同的名字的方法,你都可以作为超类,这种特性叫做鸭子类型(只要你长的像鸭子,可以游泳,可以走路,那你就是一个类鸭子)。
class Duck:def quack(self):print("嘎嘎嘎嘎。。。。。")class Bird:def quack(self):print("bird imitate duck....")class geese:def quack(self):print("doge imitate duck....")def in_the_forest(duck):duck.quack()duck = Duck()bird = Bird()doge = geese()for x in [duck, bird, doge]:in_the_forest(x)本来forest要求的对象只能是鸭子,但是其他类都有鸭子中quack的方法,所以也可以传入进来
5 获取用户对象信息
#type()>>> type('str')<class 'str'>#判断是函数类型怎么办?导入types包,用里面的函数>>> type(fn)==types.FunctionTypeTrue>>> type(abs)==types.BuiltinFunctionTypeTrue>>> isinstance(h, Dog)True#还可以用来判断是某些类中的一种>>> isinstance([1, 2, 3], (list, tuple))True>>> getattr(obj, 'z', 404) # 获取属性'z',如果不存在,返回默认值404404hasattr(obj, 'y') # 有属性'y'吗?同时,也包含有方法'y'吗?
注意:
1 能用type()判断的都可以用isinstance()进行判断
2 isinstance判断的是该类以及其父类(注意逻辑关系)
6 添加类属性和实例属性
#类属性class Teacher(object):name="teacher"实例属性t=Teacher()t.sex='男'
注意,类属性和属性的名称最好不要一样的。实例属性想要什么就加什么,动态性嘛
7 添加类方法和实例方法
#定义一个方法,导入MethodType方法,随后调用Method方法from types import MethodTypeclass Student(object):passs=Student()def set_age(self, age,name):self.age = ageself.name=names.set_age = MethodType(set_age, s)s.set_age = 25,'dudu'print(s.set_age)#类绑定方法Student.set_age=set_age
8 __slots__
作用:表示实例的属性和方法有哪些
#表示只能添加名字是name和set_age的属性或者方法class Student(object):__slots__ =('set_age','name')
注意:子类可以定义的属性是自身的__slots__和父类的__slots__
9 @property修饰器
目的:
1 可以直接用student1.score的方法,又可以对条件进行赋值
2 设置读写权限
3 使得私有变量的书写更加简洁
#注意,第一个@是可读,第二个@是可写,使用这个还是需要初始化的class Screen(object):def __init__(self, width):self._width = width@propertydef width(self):return self._width@width.setterdef width(self,values):self._width=values@propertydef height(self):return self._height@height.setterdef height(self,values):self._height=values@propertydef resolution(self):return self._width * self._heights = Screen(1024)s.height = 768print('resolution =', s.resolution)if s.resolution == 786432:print('测试通过!')else:print('测试失败!')
解释为什么在变量前面都要加_,因为这样表示的是私有属性,一般来说需要通过set和get方法来进行操作,但是这样实例化后进行操作比较复杂,我还是想用原来的student.name来进行操作,所以@propert可以实现这点
10 多重继承
做法:只要将object设置为多个父类对象如
class Dog(Mammal, Runnable):pass
11 枚举类
作用:除了简单的枚举之外,更重要的是可以当做常量
from enum import Enum, unique@uniqueclass Weekday(Enum):Sun = 0 # Sun的value被设定为0Mon = 1Tue = 2Wed = 3Thu = 4Fri = 5Sat = 6#这样可以访问该变量print(Weekday.Wed.value)#变量是不可改变的,以下内容是错误的Weekday.Wed.value=9
12 元类
除了使用常规的创建类外,使用type()也可以创建类
def fn(self):print("I'm an animal")Animal=type('Animal',(object,),dict(myself=fn))dog=Animal()dog.myself()
type()中的三个参数分别为
1 类名字
2 继承的父类,注意一个父类的时候tuple()的写法
3 方法
13 metaclass元类
作用:创建类的模板,也就是说根据metaclass创建类,根据类创建实例对象
pass(一般用不太到,太难了)
14 zip函数
作用:将n个列表合成一个n列的矩阵
a=[1,23,4,5]b=['e','y','r','d']for x,y in zip(a,b):print(x,y)
错误调试
1 错误处理
try:print('try...')r = 10 / int('2')print('result:', r)except ValueError as e:print('ValueError:', e)except ZeroDivisionError as e:print('ZeroDivisionError:', e)else:print('no error!')finally:print('finally...')print('END')
注意:错误是有继承关系的,所有的错误都继承自BaseException,当有多个错误抛出的时候,要注意后面的错误是不是上面错误的子类,因为,父类会抛出子类的错误。
def foo(s):return 10 / int(s)def bar(s):return foo(s) * 2def main():try:bar('0')except Exception as e:print('Error:', e)finally:print('finally...')
当然,当有多层嵌套的时候,我们不需要在每个模块都写上try catch,只要在关键的地方写上就可以了。如果说
2 错误抛出assert
def foo(s):n = int(s)assert n != 0, 'n is zero!'return 10 / n
其实和print或者return没有什么区别,实现的效率也不是很高
3 logging
import logginglogging.basicConfig(level=logging.INFO)s = '0'n = int(s)logging.info('n = %d' % n)print(10 / n)
第二行的意思是输出哪种级别的错误,错误有debug
,info
,warning
,error
logging还有一个好处在于可以指定文件夹用作你输出的地方
IO编程
1 文件读取
底层原理:现在的操作系统都不允许程序本身能够读取文件,python程序也是如此,它发了一个请求指令给OS,让OS去读取文件。随后python从OS那获取文件内容
#使用try finally,目的是就算读取错了也可以关闭文件try:f = open('/path/to/file', 'r')print(f.read())finally:if f:f.close()#使用with,比较推荐,也不需要写close()with open('/path/to/file', 'r') as f:print(f.read())#读取一行f.readline()#读取全部,返回列表形式,每个元素就是一行内容f.readlines()#读取5个字节f.read(5)#读取视频、图片等二进制文件,使用open(~,'rb')f = open('test.jpg', 'rb')#读取gbk文件和忽略错误f = open('gbk.txt', 'r', encoding='gbk', errors='ignore')#使用readline循环遍历一个文件with open('./t1.txt') as f:while (True):line = f.readline()if not line:breakprint(line)
2 文件写入
#重写或创建文件#w是写文本,wb是写二进制文件with open('test.txt', 'w') as f:f.write('\nHello, world!')#内容追加,使用'a'with open('test.txt', 'a') as f:f.write('\nHello, world!')
注意:只要加了'w'或'a',文件如果没有的话会自动创建
3 StringIO
不是以文件的形式存在,而是以字符串的形式存在
from io import StringIOf=StringIO()f.write("hello")f.write("world")print(f.getvalue())>>> helloworld#注意,直接使用f.read()是没有用的#只有当有初始化形式的时候才可以使用read()ff=StringIO("hello zjsu")print(ff.getvalue())
4 BytesIO
以字节的形式存在
from io import BytesIOf = BytesIO()#注意这里必须要加上encode,不加上就是一个str不符合标准f.write('中文'.encode('utf-8'))print(f.getvalue())
5 序列化,形成JSON格式
import jsond = dict(name='Bob', age=20, score=88)m=json.dumps(d)print(m)
对类进行JSON格式化
import jsonclass Student(object):def __init__(self, name, age, score):self.name = nameself.age = ageself.score = scores = Student('Bob', 20, 88)print(json.dumps(s, default=lambda obj: obj.__dict__))#核心思路是先将类实例化,随后将类的各个属性转化为dict类型,最后将其转化为JSON格式
常用内置模块
pickle
作用:实现对象序列化
import pickleclass Person:def __init__(self,n,a):self.name=nself.age=adef show(self):print self.name+"_"+str(self.age)aa = Person("JGood", 2)aa.show()f=open('d:\\p.txt','w')pickle.dump(aa,f,0)f.close()#del Personf=open('d:\\p.txt','r')bb=pickle.load(f)f.close()bb.show()
shutil
作用:文件的复制压缩等
path=os.getcwd()lst=os.listdir(path)l=[]for filename in lst:if filename.endswith('.py'):l.append(filename)#复制shutil.copy2(filename, "./question11package")#压缩shutil.make_archive("./question11package", "zip","./")
os
#遍历一个文件夹下的所有文件lst = os.listdir(dirname)for filename in lst#找出所有以.py结尾的文件if f1.endswith('.txt'):L.append(f1)#找出所有的后缀for filename in lst:listfile.append(os.path.splitext(filename)[1])
colections
作用:与集合相关
from collections import namedtuple#表示一个二维坐标Point = namedtuple('Point', ['x', 'y'])p=Point(1,2)print(p.x)#表示一个圆Circle=namedtuple('Circle',['x','y','r'])p=Circle(4,5,6)print(p.r)#实现队列或栈from collections import dequeq = deque(['a', 'b', 'c'])#往尾部添删元素,类似于一个栈q.append('x')q.pop()#也可以往头部添删元素,可以实现一个双向列表,也就是一个双向队列q.appendleft('y')q.popleft()
datetime
作用:与时间日期相关
from datetime import datetime# 获取当前datetimenow = datetime.now() #str转换为datetimecday = datetime.strptime('-6-1 18:19:59', '%Y-%m-%d %H:%M:%S')#日期转strnow = datetime.now()print(now.strftime('%a, %b %d %H:%M'))#获取时间戳(从1970年01月01日00时00分00秒到现在的时间)now=time.time()#时间的加减,如计算一个月前的时间prievetime=datetime.date.today()-datetime.timedelta(days=30)
正则表达式
简单匹配
#匹配一个字符串,以三个整数开头+至少一个字符+5到8个字符'\d{3}\s+\s{5,8}'
高级匹配
#匹配字母或者下划线开头,19个字符的字符串[a-zA-Z\_][0-9a-zA-Z\_]{0, 19}
re模块
方式一:使用compile得到regex正则表达式对象,后用regex.~(字符串)
方式二:直接re.~(正则表达式,字符串)
说白了就是字符串写一行还是写两行
re.match是从字符串开头开始匹配,如果成功返回对象,如果失败返回None
re.search是扫描整个字符串,返回第一个匹配的对象
re.findall是扫描整个字符串,返回所有匹配的对象
返回的对象都是_sre.SRE_Match,可以使用m.group()来获取具体值
re.match(r'^\d{3}\-\d{3,8}$', s)re.search(r'^\d{3}\-\d{3,8}$', s)re.findall(r'^\d{3}\-\d{3,8}$', s)
切分字符串
#对带空格的字符串进行去空格并逐词划分>>>re.split(r'\s+', 'a b c')['a', 'b', 'c']#对带空格或,或;的字符串进行分割>>> re.split(r'[\s\,\;]+', 'a,b;; c d')['a', 'b', 'c', 'd']
分组
功能:将一个字符串分割成好几个子字符串组
方式:()里面就是要分组的内容
>>> m = re.match(r'^(\d{3})-(\d{3,8})$', '010-12345')>>> m<_sre.SRE_Match object; span=(0, 9), match='010-12345'>>>> m.group(0)'010-12345'>>> m.group(1)'010'>>> m.group(2)'12345'
贪婪匹配
形式:~+ 作用:匹配尽可能多的字符
非贪婪匹配,就是在+后面加上?表示尽可能匹配少的字符
#贪婪匹配>>> re.match(r'^(\d+)(0*)$', '102300').groups()('102300', '')#非贪婪匹配>>> re.match(r'^(\d+?)(0*)$', '102300').groups()('1023', '00')
匹配所有符合条件的字符串
m=re.findall(r'\w+@\w+.\w+',s)
替换
#普通用法找到用A天替换所有的are.sub('a','A',s)#用匹配出来的组1替换整个匹配出来的东西re.sub(r'www\.(.*)\..{3}',r'\1',s)#使用pat将pat中的条件替换成colorpat=pile('(blue|red|white)')r=pat.sub('color',s)#自定义函数#?P<>是固定写法,表示定义了这个组叫什么import redef add212(matched):intStr=matched.group("number")intVal=int(intStr)addvalue=intVal+212return str(addvalue)s="hi69@, werksdf@, sdf@"m=re.sub("(?P<number>\d+)",add212,s)print(m)
其他内容
环境配置:配置清华镜像源
pip install pip -U
pip config set global.index-url https://pypi.tuna./simple
Pycharm中的快捷键
参考文档
Python教程 - 廖雪峰的官方网站 ()
/BeiCunNan/Dual_Contrastive_Learning.git