Python 3 基础知识复习

目录

Python 3的知识

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 中正则表达

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 中的 位运算符

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

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

map() 函数：

• 函数形式：map(function(), iterable, ...)
• 解释：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
    <zip object at 0x103abc288>
    >>> 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 标志：

正则表达式模式

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

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

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

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

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

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

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