Python 知识点复习

最近在做LeetCode的算法题，本来把知识点写在一起了。但是很不直观，所以单独拿出来写了。

---

知识点复习

1. LeetCode 中的 Python 3 函数说明：

2. Python 3 函数

3. Python 中的 set 无序不重复集合

4. Python 中的 位运算符

5. Python 3 中的 map() 函数与 reduce() 函数

6. Python 3 中内置函数函数

7. Python 3 中的解包

8 Python 3 中正则表达

---

知识点复习

1. LeetCode 中的 Python 3 函数说明：

def removeDuplicates(self, nums: List[int]) -> int:

• nums: List[int]：形参名字为 nums，参数类型为 List （列表）
• -> int：返回参数类型为 int

2. Python 3 函数

2.1 函数参数为对象

在 python 中，strings, tuples, 和 numbers 是不可更改（immutable）的对象，而 list,dict 等则是可以修改（mutable）的对象。

• 不可变对象：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。

• 可变对象：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

2.2 函数参数传递

在 python 中，类型属于对象，变量是没有类型的，仅仅是一个对象的引用（一个指针）。可分为不可变类型和可变类型。

• 不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。

• 可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响。

2.3 函数参数类型

• 必须参数：必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。

def function(para1, para2):  # 参数没有限制，但是调用时顺序不能错。
    print(para1)
    print(para2)

function("PARAMETER", 10010)  # 如果调用时参数个数不对会报错

• 关键字参数：关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。

def function(para1, para2):  # 参数没有限制，调用时加上参数名字，顺序可以不同。
    print(para1)
    print(para2)

function(para2="PARAMETER", para1=10010)  # 如果调用时参数个数不对会报错

• 默认参数：调用函数时，如果没有传递参数，则会使用默认参数。

def function(para1, para2=10086):  # 默认参数类型已定，若要改变默认参数值，类型要一致。
    print(para1)
    print(para2)

function("PARAMETER1")  # 可以不调用默认参数

• 不定长度参数：一个函数能处理比当初声明时更多的参数。

def function1(para1, para2=10086, *var_args):  # 一个“*”的参数形式为元组。
    print(para1)
    print(para2)
    if len(var_args) != 0:
        for item in var_args:
            print(item)

def function2(para1, para2=10086, **var_args):  # 两个“*”的参数形式为字典
    print(para1)
    print(para2)
    print(var_args)

def function3(para1, para2=10086, *, para3):  # 函数声明时，可以只写“*”，但是后面的参数必需以关键词参数形式写入。
    print(para1)
    print(para2)
    print(var_args)

function1("PARAMETER1")  # 至少保证必需参数要在

function2("PARAMETER1", a=100, b=10)  # 字典形式写参数

function1("PARAMETER1", a=100, para3=10086)  # “*”后的以关键字形式写入

• 匿名函数：使用 lambda 来创建匿名函数。
  • lambda 只是一个表达式，函数体比 def 简单很多。
  • lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
  • lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
  • 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

multiply = lambda para1, para2: para1 * para2  # lambda形式->参数：表达式

print(multiply(10086, 10010))  # 调用时直接写就行

• Python3.8 新增了一个函数形参语法“/”用来指明函数形参必须使用指定位置参数，不能使用关键字参数的形式。

def function(a, b, /, c, d, *, e, f):  
# 形参 a 和 b 必须使用指定位置参数，c 或 d 可以是位置形参或关键字形参，而 e 或 f 要求为关键字形参
    print(a, b, c, d, e, f)

function(10, 20, 30, d=40, e=50, f=60)

3. Python 中的 set 无序不重复集合

集合（set）是一个无序的不重复元素序列。

可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

创建格式：

parame = {value01,value02,...}

或者

set(value)

4. Python 中的 位运算符

Python中的位运算符

运算符	描述	实例
&	按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0	(a & b) 输出结果 12 ，二进制解释： 0000 1100
|	按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。	(a | b) 输出结果 61 ，二进制解释： 0011 1101
~	按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。~x 类似于 -x-1	(~a ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式
^	按位异或运算符：当两对应的二进位相异时，结果为1	(a ^ b) 输出结果 49 ，二进制解释： 0011 0001
<<	左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。	a << 2 输出结果 240 ，二进制解释： 1111 0000
>>	右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数	a >> 2 输出结果 15 ，二进制解释： 0000 1111

其中a=60=0011 1100，b=13=0000 1101。

5. Python 3 中的 map() 函数与 reduce() 函数

map() 函数：

• 函数形式：map(function(), iterable, ...)
• 解释：map相当于映射，针对迭代器中的每一个元素分别操作，逐一映射，最终得到长度不变的结果。

reduce() 函数示意图 map() 函数示意图

 

reduce() 函数：

• 函数形式：reduce(function(), iterable[,  initializer])
• 解释：reduce相当于归于，序列中相邻两个元素逐次进入函数计算，最后得到一个返回值。
• Python 3 中把 reduce() 放入 functools包中

6. Python 3 中内置函数函数

• zip([iterable,...]) 函数：
  • 说明：将参数迭代器，按照最短的那个迭代器的长度，对应的索引形成元组，并返回这些元组的对象。可以用过list()来改为列表查看。
  • 举例:

    # 来源：菜鸟教程
    >>>a = [1,2,3]
    >>> b = [4,5,6]
    >>> c = [4,5,6,7,8]
    >>> zipped = zip(a,b)     # 返回一个对象
    >>> zipped
    
    >>> list(zipped)  # list() 转换为列表
    [(1, 4), (2, 5), (3, 6)]
    >>> list(zip(a,c))              # 元素个数与最短的列表一致
    [(1, 4), (2, 5), (3, 6)]
     
    >>> a1, a2 = zip(*zip(a,b))          # 与 zip 相反，zip(*) 可理解为解压，返回二维矩阵式
    >>> list(a1)
    [1, 2, 3]
    >>> list(a2)
    [4, 5, 6]
     
    

    • 这里要注意的是zip()函数可以和解包操作一起执行，相当于在形成一个个元组后，通过解包把每个元组都拿了出来。然后在zip()就会把原来同一个迭代器的元素又通过元组集合了起来。
• filter(function, iterable) 过滤器
  • 说明：正如函数名一样，filter会将迭代器中的元素逐一放入function中判断，这里的function是判断函数。函数返回True和False，然后fileter会把返回True 的元素输出，形成一个对象，如果要查看可以用list()。
  • 举例：

    def is_odd(n):
        return n % 2 == 1
     
    tmplist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
    newlist = list(tmplist)
    print(newlist)

     

字符串操作时所需要的函数：

• python 3 中字符转ASCII码函数：ord(char)
• python 3 中ASCII码转字符函数：chr(int)
• 从左到右读读取字符串寻找对应字符str：find(str, begin=0, end=len(s))
• 从右到左读读取字符串寻找对应字符str：rfind(str, begin=0, end=len(s))
• 截掉字符串左边的空格或指定字符：lstrip()
• 删除字符串字符串末尾的空格：rstrip()

7. Python 3 中的解包

解包在英文里叫做 Unpacking，是将容器里面的元素逐个取出来赋值给其他变量。Python 中的解包是自动完成的。要注意的是，解包时赋值的变量个数应该和容器内的元素的个数一致。

>>> a, b, c = [1, 2, 3]  
>>> a
1
>>> b
2
>>> c
3

容器可以是 list, dictionary, set, truple, string。但对于dictionary，取出来的只有key，value并没有。

其实多变量的赋值，以及常用的变量交换都是解包的操作。

当解包的变量个数与容器中的元素个数不同时，可以这么写

>>> a, b, *c = [1,2,3,4]
>>> a
1
>>> b
2
>>> c
[3, 4]
# ******************************
>>> a, *b, c = [1,2,3,4]
>>> a
1
>>> b
[2, 3]
>>> c
4

函数被调用的时候，使用星号 * 解包一个可迭代对象作为函数的参数。

字典对象，可以使用 **星号，解包之后将作为关键字参数传递给函数。

举例：

>>> def func(a,b,c):
...     print(a,b,c)
...
>>> func(1,2,3)
1 2 3

>>> func(*[1,2,3])
1 2 3
>>> func(*(1,2,3))
1 2 3
>>> func(*"abc")
a b c
>>> func(*{"a":1,"b":2,"c":3})  
a b c
>>> func(**{"a":1,"b":2,"c":3})  
1 2 3

一个*符号只是将字典当作一般的容器，只取除了key，而不考虑value。

两个**时作用的对象是字典对象，它会自动解包成关键字参数 key=value 的格式，比如 a=1, b=2, c=3。而函数的形参就是a, b, c。倘若字典的key不是a, b, c则会报错，说输入不是期望的参数。

在 Python 3.5 之后可以允许多个解包操作同时在一个函数中。

>>> func(*[1, 2], **{'c':5}) 
1 2 5
>>> func(*[1, 2], 3)
1 2 3

解包还有用于生成list等快捷操作。

>>> *range(0, 5), 5  # 生成truple
(0, 1, 2, 3, 4, 5)
>>> [*range(0, 5), 5, 6]  # 生成list
[0, 1, 2, 3, 4, 5, 6]
>>> {*range(0, 5), 5, 6, 7}  # 生成set
{0, 1, 2, 3, 4, 5, 6, 7}
>>> {'x': 1, **{'y': 2}}  # 生成dictionary
{'x': 1, 'y': 2}

>>> list1 = [1,2,3]  
>>> list2 = range(3,6)  # range 与 list 不能直接相加
>>> [*list1, *list2]
[1, 2, 3, 3, 4, 5]

8 Python 3 中正则表达

这部分内容比较多，可以直接参看 Python3 正则表达式

大概写一下需要用到的函数

re.match函数

• re.match(pattern, string, flags=0)；
  • flags：标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。
• 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。

re.searc函数

• re.search(pattern, string, flags=0)，同re.match函数
• 扫描整个字符串并返回第一个成功的匹配。

在匹配成功后，上面的两个函数都会返回一个对象，我们可以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。

import re
 
line = "Cats are smarter than dogs"
# .* 表示任意匹配除换行符（\n、\r）之外的任何单个或多个字符
matchObj = re.match( r'(.*) are (.*?) .*', line, re.M|re.I)
 
if matchObj:
   print ("matchObj.group() : ", matchObj.group())
   print ("matchObj.group(1) : ", matchObj.group(1))
   print ("matchObj.group(2) : ", matchObj.group(2))
else:
   print ("No match!!")

# 输出如下
matchObj.group() :  Cats are smarter than dogs
matchObj.group(1) :  Cats
matchObj.group(2) :  smarter

re.match 与 re.search 的区别

re.match 只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回 None，而 re.search 匹配整个字符串，直到找到一个匹配。

re.sub 函数

• re.sub(pattern, repl, string, count=0, flags=0)；
  • repl : 替换的字符串，也可为一个函数。
  • count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。
• 用于替换字符串中的匹配项。

re.compile 函数

• re.compile(pattern[, flags])
• compile 函数用于编译正则表达式，生成一个正则表达式（ Pattern ）对象，供 match() 和 search() 这两个函数使用。

re.findall 函数

• re.findall(string[, pos[, endpos]])
  • pos 可选参数，指定字符串的起始位置，默认为 0。
  • endpos 可选参数，指定字符串的结束位置，默认为字符串的长度。
• 在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果没有找到匹配的，则返回空列表。

re.finditer 函数

• re.finditer(pattern, string, flags=0)
• 和 findall 类似，在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回。

re.split 函数

• re.split(pattern, string[, maxsplit=0, flags=0])
  • 分隔次数，maxsplit=1 分隔一次，默认为 0，不限制次数。
• split 方法按照能够匹配的子串将字符串分割后返回列表。

正则表达式修饰符 - 可选标志

多个标志可以通过按位 OR(|) 它们来指定。如 re.I | re.M 被设置成 I 和 M 标志：

修饰符	描述
re.I	使匹配对大小写不敏感
re.L	做本地化识别（locale-aware）匹配
re.M	多行匹配，影响 ^ 和 $
re.S	使 . 匹配包括换行在内的所有字符
re.U	根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B.
re.X	该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。

正则表达式模式

模式字符串使用特殊的语法来表示一个正则表达式：

字母和数字表示他们自身。一个正则表达式模式中的字母和数字匹配同样的字符串。

多数字母和数字前加一个反斜杠时会拥有不同的含义。

标点符号只有被转义时才匹配自身，否则它们表示特殊的含义。

反斜杠本身需要使用反斜杠转义。

由于正则表达式通常都包含反斜杠，所以你最好使用原始字符串来表示它们。模式元素(如 r'\t'，等价于 \\t )匹配相应的特殊字符。

下表列出了正则表达式模式语法中的特殊元素。如果你使用模式的同时提供了可选的标志参数，某些模式元素的含义会改变。

模式	描述
^	匹配字符串的开头
$	匹配字符串的末尾。
.	匹配任意字符，除了换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符。
[...]	用来表示一组字符,单独列出：[amk] 匹配 'a'，'m'或'k'
[^...]	不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符。
re*	匹配0个或多个的表达式。
re+	匹配1个或多个的表达式。
re?	匹配0个或1个由前面的正则表达式定义的片段，非贪婪方式
re{ n}	匹配n个前面表达式。例如，"o{2}"不能匹配"Bob"中的"o"，但是能匹配"food"中的两个o。
re{ n,}	精确匹配n个前面表达式。例如，"o{2,}"不能匹配"Bob"中的"o"，但能匹配"foooood"中的所有o。"o{1,}"等价于"o+"。"o{0,}"则等价于"o*"。
re{ n, m}	匹配 n 到 m 次由前面的正则表达式定义的片段，贪婪方式
a| b	匹配a或b
(re)	匹配括号内的表达式，也表示一个组
(?imx)	正则表达式包含三种可选标志：i, m, 或 x 。只影响括号中的区域。
(?-imx)	正则表达式关闭 i, m, 或 x 可选标志。只影响括号中的区域。
(?: re)	类似 (...), 但是不表示一个组
(?imx: re)	在括号中使用i, m, 或 x 可选标志
(?-imx: re)	在括号中不使用i, m, 或 x 可选标志
(?#...)	注释.
(?= re)	前向肯定界定符。如果所含正则表达式，以 ... 表示，在当前位置成功匹配时成功，否则失败。但一旦所含表达式已经尝试，匹配引擎根本没有提高；模式的剩余部分还要尝试界定符的右边。
(?! re)	前向否定界定符。与肯定界定符相反；当所含表达式不能在字符串当前位置匹配时成功。
(?> re)	匹配的独立模式，省去回溯。
\w	匹配数字字母下划线
\W	匹配非数字字母下划线
\s	匹配任意空白字符，等价于 [\t\n\r\f]。
\S	匹配任意非空字符
\d	匹配任意数字，等价于 [0-9]。
\D	匹配任意非数字
\A	匹配字符串开始
\Z	匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串。
\z	匹配字符串结束
\G	匹配最后匹配完成的位置。
\b	匹配一个单词边界，也就是指单词和空格间的位置。例如， 'er\b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。
\B	匹配非单词边界。'er\B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。
\n, \t, 等。	匹配一个换行符。匹配一个制表符, 等
\1...\9	匹配第n个分组的内容。
\10	匹配第n个分组的内容，如果它经匹配。否则指的是八进制字符码的表达式。