python刷题技巧

pythonGET

目录

• pythonGET
  • • 1.ord(str)
    • 2.chr(str)
    • 3.finditer
    • 4. re.sub()
    • 5.find(),index()
    • 6.map()
    • 7.filter()
    • 8.sort()与sorted()
  • SkillGet
    • 闭包
    • 装饰器
    • 生成器
    • 函数注释，类型注释，默认参数，内省
  • 异常捕获
  • 类
    • 面向对象三大特征：继承、封装、多态
    • self
    • 当前对象
    • 类的重用
    • 多态
    • 私有变量与私有方法
    • property
    • slots属性
    • new和del
  • python中位运算
    • bin
    • 按位与 &
    • 按位或 |
    • 按位非 ~
    • 按位异或
    • 左移
    • 右移

1.ord(str)

str='A'
print(ord(str))
>>>65

2.chr(str)

ascll=69
print(chr(ascll))
>>>'E'

3.finditer

import re
string='o1234.exe'
pattern='_1234.exe'
result=re.finditer(pattern,string)
#可以通过for循环打印迭代器
for i in result:
  print(i.span())
  print(i)

4. re.sub()

经过测试发现，字符串中的replace并不适合使用正则表达式，因此如果想要通过通过正则匹配到的内容替换为指定内容，可以使用 re.sub()函数。参数一般只用前三个pattern,new_str,str,count,flag）分别是正则表达式，替换的内容，需要匹配的原字符串。

 str_test='it is so 666 really 6666 what else can I say 6666666666'
  result = re.sub('6[6]{2,7}6', '9', re.sub('6[6]{8,}6', '27', string_test))
  print(result)
  >>>it is so 666 really 9 what else can I say 27

直接进行了两次替换，得到了我们需要的结果。题目要求为：将连续出现的三个以上十个以下的连续的6替换为9，将九个以上的连续出现的6替换为27。通过正则代码量大大的缩短了，但是正则的使用还需要多多提高。

5.find(),index()

str='i love Python'
index=str.find('o')
index2=str.index('n')

find()函数不会报错，若匹配到则返回索引，否则返回-1；而index如果没有匹配到则会报错。而且若有多个同时出现他们都只会返回第一个索引

6.map()

map是python中内置的高阶函数，它会对整个传入的内容进行处理，并返回一个可迭代对象，不过一般都是在对数组处理时配合lambda函数使用,并将其强制转换为列表类型：

#对数组中的每一个元素乘以-1
a=[1,2,3,-1,3,-23,-5]
b=list(map(lambda x:x*-1,a))
>>>[-1, -2, -3, 1, -3, 23, 5]

这样就可以快速的对数据元素进行操作，传入的参数也可以时字符串或者是其他序列。再举个例子，比如给定一个字符串，我们需要让其中所有的字母向后移动一位，我们可以这样做：

str='iloveyou'
str2=''.join(list(map(lambda x:chr(ord(x)+1),str)))
>>>str2
'jmpwfzpv'

虽然代码看着很复杂，但是相对来说代码量就少了很多。

7.filter()

filter()也是python中的内置函数，使用方法与刚才的map方法一致，但是它主要是用于过滤，一般我们再对数组进行过滤时为了选出符合条件的元素就可以这样去做，filter配合lambda使用起来十分方便，我们在使用时可以这样：

#比如我们要选出所有的负数
a=[-1,2,3,-4,-33,6,9]
b=list(filter(lambda x:x*-1,a))
>>>b
[-1,-4,-33]

8.sort()与sorted()

sort函数是基于list的，也就是对已经存在数组进行操作，并且它没有返回值，它属于列表的成员方法。而sorted函数可以理解为sort的升级版，sorted（）可以对搜有的可迭代对象序列进行排序操作

list1=[-1,2,3,-2,54,-43,63,3]
list1.sort()
[-43,-2,-1,2,3,3,54,63]
students = [('sqz', 'A', 15), ('ljl', 'B', 12), ('zzb', 'B', 10)]
>>> sorted(students, key=lambda s: s[2])            # 按年龄排序
[('zzb', 'boy', 10), ('ljl', 'girl', 12), ('sqz', 'boy', 15)]

sorted函数中的可迭代对象不要用字典d，那样只能迭代出的字典d的键。要用d.items()才可迭代出字典的键值对。

 d_order=sorted(d,key=lambda x:x[1],reverse=False)

 #要用 d_order=sorted(d.items(),key=lambda x:x[1],reverse=False)

同样的也可以指定多个排序规则。

all_competition=[(1, 3), (4, 6), (2, 8), (3, 4), (2, 6)]
all_competition.sort(key=lambda x:(x[0],x[1]))

这里会先按照指定的第一个参数去排序，如果第一个数据都相等，则按照第二个数据去排序。

SkillGet

闭包

装饰器

装饰器就是在函数的上面以@声明一个装饰器，装饰器下面写到的函数会以参数的形式传递到装饰其中。装饰器也是一个函数，接收函数参数

生成器

iterator类型的数据，可以使用yield来替代return。比如函数的返回值返回多个，可以使用生成器。会返回可迭代类型，也就是可以使用for循环来遍历生成的内容。该类型的数据无法回头，不能通过索引访问。支持next（iterator）的形式

函数注释，类型注释，默认参数，内省

使用三个双引号 将函数注释写在开头，后面可以使用help(函数名)的注释打印出来 。

类型注释可以声明函数传入参数的类型以及返回值的类型

def test(a:list[int],b:str = 'hello') -> str:
def test2(b:dict[str,int]) -> dict:

但是注释的类型不会进行类型检查，如果想要进行检查的话可以使用第三方模块MyPy。

自省即就是查看函数本身的属性，但使用时前后要使用两个下划线才可以，比如函数名称为test。我们可以使用

test.__name__  #查看当前的函数名字
test.__annotation__ #查看当前的函数的类型注释 ，包括了参数类型以及返回值
test.__doc__ #查看函数文档

异常捕获

try：尝试去做的内容

except：

else:

finally:

类

面向对象三大特征：继承、封装、多态

class B(A):
    #则说明B类是继承自A类的 

判断某个对象是否属于某个类，可以使用isinstance

isinstance(B,A)

issubclass(a，A) 检测某一个类是否继承自另一个类

多继承，python中支持多继承，可以继承多个类，访问顺序从左到右。

class C(A,B):   

组合，也就是将其它类的实例同时放到哦同一个类中

self

self相当于js中的this，绑定当前对象。

当前对象

可以使用

test.__dict__ #来查看当前类中绑定的属性  

类的重用

可以直接使用另一个类中的方法以及属性进行重写。

多态

同一个类，传入不同的对象，会有不同的表现

在python中，我们传入的对象可以是其它类的实例对象，以此来达到多态的目的 。

私有变量与私有方法

python中的私有变量使用，在名字前面使用两个下划线，想要获得私有变量的值必须通过提供的几口来获取相对应的值。私有方法也是同样的，在函数名前加上两个下划线。

class C:
    def __init__(self,x,y):
        self.name = x
        self.__age = y
    def set_age(self,b):
        self.__age = b
    def get_age(self):
        print(self.__age)

property

property()函数中的三个函数分别对应的是获取属性的方法、设置属性的方法以及删除属性的方法，这样一来，外部的对象就可以通过访问x的方式，来达到获取、设置或删除属性的目的。当需要更改上例中的getSize、setSize或delSize函数的名称时，如果这些方法是作为接口让用户调用的，那么对用户而言就要修改自己调用的方法名，很麻烦，使用了proprty()后，用户就不需担心这种问题了。

class A:
    def __init__(self,x):
        self.x = x
    def getX(self):
        return self.x
  	def setX(self,x):
        self.x = x
    def delX(self):
        del self.x
    p = property(getX,setX,delX)

slots属性

slots属性可以限制类当前实例化对象只能使用的属性

class C:
    __slots__ = ["x","y"]
    def __init__(self,x):
        self.x = x

此时只能使用x以及y属性，不能出现之外的属性

new和del

可以返回self，在创建之前进行返回，类似于拦截器。这里就类似于axios中的请求拦截器和响应拦截器

python中位运算

bin

bin()可以将十进制转换为二进制，

按位与 &

1&2 ，必须都为1时才为1， 比如3&4==0

按位或 |

只要有一位为1 ，则为1

按位非 ~

将每一位取反，补码运算

按位异或

当位相同时为0，不同时为1

3^2==1 3^4 ==7 3为0011，2为0010，按位异或则是，0001

左移

移动之前都是需要先转化成二进制再移动。左移是扩大，移动几位即扩大2的幂次方。右移则是数据减小2的幂次

<< 左移，

1<<2 ==4

右移

>>右移

8>>2==2