前言
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
