Python2和Python3的区别

冷不防 2022-05-22 12:15 253阅读 0赞

*  **编码**
 *  `Python3`的效率略低于`Python2`,但是优化空间很大;
 *  `Python3`默认使用的是`UTF-8`编码,命名空间更加广阔;
 *  **语法**
 *  `Python2`使用`<>`表示不等于,`Python3`使用的是`!=`表示不等于;
 *  `Python3`加入了`as`和`with`以及`True False None`等关键字;
 *  对于整除需要使用`//`;
 *  `Python3`去除了`print`语句,加入了`print()`函数;
 *  `Python3`去除了`row_input`语句,加入了`input()`函数;
 *  添加了新的`super()`,可以不进行参数传递;
 *  改变了顺序操作符的行为,在进行不同类型的数据比较时,不再进行数据类型的自动转换;
 *  对于`8`进制的转换,必须使用`0o`来进行引导;
 *  **数据类型**
 *  `Python2`使用的是`8-bit`字符串存储,`Python3`使用的是`16-bit`位进行存储,并且字符串只支持`str`一种类型;
 *  `Python3`去除了`long`只有一种整形,就是`long`,并且新增了`Bytes`类型,对应于`2.x`版本的八位串,并且支持`str<-->bytes`使用`.encode()`以及`.decode()`进行转换;
 *  面向对象上面引入了基类的概念;
 *  **异常**
 *  所有异常继承于`BaseException`,并且删除了`StardardError`
 *  `Python2`使用异常的格式是

try:
    	-----
    expect Exception,e:
    	-----

*  `Python3`使用的异常类型:

try:
    	------
    except Exception as e:
    	-------

*  **其他**
 *  `xrange()`更名为`range()`,如果需要使用`range()`获得一个`list`必须进行显示调用;
 *  `fie`类被废弃,打开文件使用`open()`;
 *  **高阶函数map和reduce**
 *  `map reduce`是一个分布式编程框架,对于`Python`来说内置了`map`以及`Reduce`函数;
 *  `map(fn, lsd)`:这个函数是将传入的函数依次作用于序列中的每一个元素,并且把结果作为新的`Iterator`进行返回;
    
     *  `fn`:表示函数;
     *  `lsd`:表示序列;
 *  `reduce(fn, lsd)`:将一个函数作用在序列上面,这个函数必须接受两个函数,`Reduce`把结果和序列的下一个元素进行累积运算;
    
     *  `fn`:表示是一个函数,
     *  `lsd`:表示是一个列表;
 *  这个函数的返回结果类似于`f(f(a,b),c),d)`;
 *  **高阶函数filter**
 *  `filter(fc, lsd)`:用于过滤序列,用于将传入的函数一次作用于序列中的每个元素,根据返回的结果,决定是否保留这个元素,并且不修改原始序列的数据;
    
     *  `fn`:表示传递一个函数;
     *  `lsd`:表示传递一个序列;
 *  可以用于去掉奇数,留下偶数;
 *  **高阶函数sorted**
 *  这个函数是用来排序的,常见的排序分为冒泡,选择; 快速,插入,计数器;
 *  普通排序:
 *  默认是升序排序

list2 = sorted(list1)
    print(list2)

*  按照绝对值大小排序,`key`:接收函数来实现自定义的排序规则;

list3 = sorted(list1, key=abs)
    print(list3)

*  进行降序排序

list4 = sorted(list1, reverse=True)
    print(list4)

*  同样也可以进行字符串排序

list6 = ['a123', 'b234', 'dsawsa', 'dasdw', 'fdeds']
    list7 = sorted(list6)
    print(list7)

*  支持按照字符串的长度进行排序,对于`len`支持使用自定的函数

list8 = ['a123', 'b234', 'dsawsa', 'dasdw', 'fdeds']
    list9 = sorted(list8, key=len)
    print(list9)

*  **单元测试**
 *  是用来对于一个函数或者一个类,或者一个模块进行正确性校验;
 *  单元测试
 *  测试文件
 *  结束测试时自动调用
 *  **正则表达式**
 *  `Python1.5`以后增加了`re`模块,提供了正则表达式,`re`模块使`Python`拥有了全部的正则表达式功能;
 *  `re.match()`函数:

def match(pattern, string, flags=0):
        """Try to apply the pattern at the start of the string, returning
        a match object, or None if no match was found."""
        return _compile(pattern, flags).match(string)

*  尝试从字符串的起始位置匹配一个模式,如果不是起始位置匹配成功,返回`None`
 *  `pattern`:表示进行模式匹配的正则表达式;
 *  `string`:表示需要进行匹配的字符串;
 *  `flag`:表示标志位,用于控制正则表达式的匹配方式,
    
     *  `re.I`:表示忽略大小写;
     *  `re.L`:表示用于进行本地化识别;
     *  `re.M`:表示进行多行匹配的,影响`^`以及`$`
     *  `re.S`:使用`.`匹配包括换行符在内的任何字符;
     *  `re.U`:表示`Unicode`字符集解析字符,影响`\w \W \b \B`
     *  `re.X`:使用更加灵活的格式来理解正则表达式;
 *  `re.search()`:函数

def search(pattern, string, flags=0):
        """Scan through string looking for a match to the pattern, returning
        a match object, or None if no match was found."""
        return _compile(pattern, flags).search(string)

*  函数原型和上面的基本相同,函数名不同;
 *  `pattern`:表示进行模式匹配的正则表达式;
 *  `string`:表示需要进行匹配的字符串;
 *  `flag`:表示标志位,用于控制正则表达式的匹配方式;
 *  功能:用于扫面整个字符串,返回第一个成功的匹配;
 *  `re.findall()`:

def findall(pattern, string, flags=0):
        """Return a list of all non-overlapping matches in the string.
    
        If one or more capturing groups are present in the pattern, return
        a list of groups; this will be a list of tuples if the pattern
        has more than one group.
    
        Empty matches are included in the result."""
        return _compile(pattern, flags).findall(string)

*  `pattern`:表示进行模式匹配的正则表达式;
 *  `string`:表示需要进行匹配的字符串;
 *  `flag`:表示标志位,用于控制正则表达式的匹配方式,
    
     *  `re.I`:表示忽略大小写;
     *  `re.L`:表示用于进行本地化识别;
     *  `re.M`:表示进行多行匹配的,影响`^`以及`$`
     *  `re.S`:使用`.`匹配包括换行符在内的任何字符;
     *  `re.U`:表示`Unicode`字符集解析字符,影响`\w \W \b \B`
     *  `re.X`:使用更加灵活的格式来理解正则表达式;
 *  扫描整个字符串,并且返回结果列表
 *  **关于正则表达式**
 *  **匹配单个字符和数字:**
 *  `.`:用于匹配除了换行符之外的任意字符;
 *  `[0123456789]`:用于匹配任意单个数字;
 *  `[like]`:表示用于匹配`l i k e`中的任意单个字符
 *  `[a-z]`:表示用于匹配`a-z`中的字符,也就是任意的小写字符,同样也支持`[A-Z]`;
 *  `[0-9a-zA-Z]`:表示任意的数字以及大小写字母;
 *  `[0-9a-zA-Z_]`:表示任意的数字以及大小写字母以及下划线;
 *  `[^today]`:表示是用于匹配除了这几个字母之外的所有字符,`^`表示托字符,表示不匹配里面的字符;
 *  `[^0-9]`:表示匹配所有的非数字字符;
 *  `\d`:表示匹配所有的数字,效果类似于`[0-9]`
 *  `\D`:表示匹配所有的非数字字符,效果同`[^0-9]`;
 *  `\w`:表示匹配数字,字母和下划线,效果和`[0-9a-zA-Z_]`;
 *  `\W`:表示匹配非数字,字母和下划线,效果和`[^0-9a-zA-Z_]`;
 *  `\s`:表示匹配任意的空白字符,换行,换页,制表,回车,效果类似于`[ \f\n\r\t]`
 *  `\S`:匹配任意的非空白字符,效果类似于`[^ \f\n\r\t]`;
 *  **边界定位符**
 *  `^`:不在`[]`里面时,表示的含义是行首匹配,用于表示是否是某个字符开头的;
 *  `$`:表示行尾匹配;
 *  `\A`:匹配字符串的开始,和`^`的区别是`\A`只匹配整个字符串的开头,即使在`re.M`模式下,也不会匹配其它行的行首;
 *  `\Z`:匹配字符串的结束,和`^`的区别是`\A`只匹配整个字符串的开头,即使在`re.M`模式下,也不会匹配其它行的结尾;
 *  `\b`:表示用于匹配一个单词的边界,也就是单词和空格的位置;
 *  `\B`:用于匹配非单词的边界
 *  **匹配多个字符**
 *  `(xyz)`:以下的`x, y, z`均为假设的普通字符,不是正则表达式的元字符,`(xyz)`表示的含义是将小括号内的`xyz`作为一个整体去进行匹配;
 *  `x?`:表示匹配`0`个或者`1`个`x`;
 *  `x*`:表示匹配`0`个或者任意多个`x`.字符,换行符除外;
 *  `x+`:表示匹配至少一个`x`;
 *  `x{n}`:表示匹配确定的`n`个`x`,`n`是一个非负整数;
 *  `x{n,}`:表示匹配至少`n`个`x`
 *  `x{n,m}`:表示匹配至少`n`个,至多`m`个`x`
 *  `((t|T)oday)`:表示匹配的是大写或者是小写字母开头的`today`
 *  在进行匹配的过程中,默认执行的是贪婪匹配;
 *  `*? +? x?`:表示的是最小匹配原则;

print(re.findall(r"\/*.*?\/*/", r"/* part1 */  /* part2 */"))

*  `(?:x)`:类似于`(xyz)`,但是不表示一个组;
 *  几个练手题:

QQ: 一般是6--->10位的纯数字
    mai *******@163.com
    Phone 010-85832376
    user 6-->12位,
    IP 
    url

*  **`re`模块深入**
 *  `re.split()`:函数用于进行切割

str1 = "today    is  a  good  day"
    
    print(str1.split(" "))  
    print(re.split(r" +", str1))  //表示按照至少一个空格进行切割

*  `re.finditer()`函数:

def finditer(pattern, string, flags=0):
        """Return an iterator over all non-overlapping matches in the
        string.  For each match, the iterator returns a match object.
    
        Empty matches are included in the result."""
        return _compile(pattern, flags).finditer(string)

*   *  `pattern`:表示进行模式匹配的正则表达式;
 *  `string`:表示需要进行匹配的字符串;
 *  `flag`:表示标志位,用于控制正则表达式的匹配方式,
    
     *  `re.I`:表示忽略大小写;
     *  `re.L`:表示用于进行本地化识别;
     *  `re.M`:表示进行多行匹配的,影响`^`以及`$`
     *  `re.S`:使用`.`匹配包括换行符在内的任何字符;
     *  `re.U`:表示`Unicode`字符集解析字符,影响`\w \W \b \B`
     *  `re.X`:使用更加灵活的格式来理解正则表达式;
 *  这个函数和`findAll`类似,用于扫描整个字符串,返回的是一个迭代器;

str3 = "today is a good day today is a nice day today is  a great day"
    itera = re.finditer(r"(today)", str3)
    while True:
        try:
            l = next(itera)
            print(l)
        except StopIteration as e:
            break

*  字符串的替换和修改
 *  包括两个函数
 *  `re.sub()`

def sub(pattern, repl, string, count=0, flags=0):
        """Return the string obtained by replacing the leftmost
        non-overlapping occurrences of the pattern in string by the
        replacement repl.  repl can be either a string or a callable;
        if a string, backslash escapes in it are processed.  If it is
        a callable, it's passed the match object and must return
        a replacement string to be used."""
        return _compile(pattern, flags).sub(repl, string, count)

*  以及函数`re.subn()`

def subn(pattern, repl, string, count=0, flags=0):
        """Return a 2-tuple containing (new_string, number).
        new_string is the string obtained by replacing the leftmost
        non-overlapping occurrences of the pattern in the source
        string by the replacement repl.  number is the number of
        substitutions that were made. repl can be either a string or a
        callable; if a string, backslash escapes in it are processed.
        If it is a callable, it's passed the match object and must
        return a replacement string to be used."""
        return _compile(pattern, flags).subn(repl, string, count)

*  参数以及含义:
 *  `pattern`:表示的是正则表达式
 *  `repl`:表示替换成的内容;
 *  `string`:表示需要进行处理的字符串
 *  `count`:最多替换次数
 *  `flags`:和之前的`flags`是一样的;
 *  功能:用于在目标字符串中,使用正则表达式的规则,匹配字符串,然后替换成为指定的字符串,可以指定替换的次数,默认是替换所有匹配字符串;
 *  这两个函数的返回值类型是不同的;

//返回的是一个被替换的字符串
    print(re.sub(r"(today)", "tomorrow", str3, count=2))
    print(type(re.sub(r"(today)", "tomorrow", str3, count=2)))
    
    //返回值是一个元组,第一个是字符串,后面的是被替换的次数
    print(re.subn(r"(today)", "tomorrow", str3, count=2))
    print(type(re.subn(r"(today)", "tomorrow", str3, count=2)))

*  **分组**
 *  概念:除了简单的判断是否匹配之外,正则表达式还可以用提取子串的功能,使用`()`表示分组,使用`()`括起来的就是一组;
 *  `group(0)`代表的是原始的字符串

print("------------------------")
    str4 = "010-52347654"
    m = re.match(r"(?P<first>\d{3})-(?P<last>\d{8})", str4)
    print(m)
    # 使用序号获取对应组的信息,`group(0)`代表的是原始的字符串
    print(m.group(0))
    print(m.group(1))
    print(m.group(2))
    # 查看匹配的各组的情况
    print(m.groups())

*  支持给各个组进行重命名

print(m.groups("first"))
    print(m.group("last"))

*  **编译**
 *  在使用正则表达式时,`re`模块需要完成两件事
 *  1.首先编译正则表达式,如果正则表达式本身不合法,会提示错误
 *  2.使用编译后的正则表达式匹配对象
 *  这里的编译一般是将经常使用的正则表达式编译成为对象,方便使用
 *  编译使用函数`re.compele(parttetn, flags)`来完成

pat = r"1(([3578]\d)|(47))\d{8}$"
    
    re_telephone = re.compile(pat)
    re_telephone.match("13700000000")

*  编译后的对象在使用时,支持上面的方法,但是参数类型可能存在变化;这个需要注意,使用对象来调用对应的方法,一般都是缺少正则表达式这个参数;