Python3 学习

python3的list

1定义

#   列表概念：有序的可变的元素集合

#   定义
#   直接定义
nums = [1,2,3,4,5]

#   通过range函数构造，python2 和python3 版本之间的差异；
#   python3 用的时候才会去构造
nums = range(1,101)

#   列表嵌套
#   注意和C语言中数组的区别,是否可以存放不同的数据类型
nums = [1,2,"ab","1",True,["a","b","c"]]

#   列表赋值给另外一个列表
#   原始的方式
nums = [1,2,3,4,5]
resultList  =  []
for  num  in  nums:
    resultList.append(num  ** 2)
print(resultList)   #  [1, 4, 9, 16, 25]

#   列表推导式
nums = [1,2,3,4,5]
#   [表达式 for 变量 in 列表]
resultList = [num ** 2  for  num  in  nums]
print(resultList)   #  [1, 4, 9, 16, 25]

#   [表达式 for 变量 in 列表 if 条件]
resultList = [num ** 2  for  num  in  nums  if  num % 2 !=  0]
print(resultList)   #  [1, 9, 25]

2增

append（）方法在列表最后追加一个新元素，无返回值。

nums = [1, 2, 3, 4]
nums.append(5)  #  无返回值 none
print(nums)  #   [1, 2, 3, 4, 5]

insert（）方法是向指定位置插入元素，参数类型分别为int，object

nums = [1, 2, 3, 4]
nums.insert(2, 5)
print(nums)  #   [1, 2, 5, 3, 4]

函数extend(),是向一个List添加另外一个可迭代对象（可以为List，也可以为元组tuple），参数类型为iterable

nums = [1, 2, 3, 4]
nums2  = ["a",  "b",  "c"]
nums.extend(nums2)
print(nums)  #   [1, 2, 3, 4, 'a', 'b', 'c']

3删

del（）方法是删除指定元素，可以试一个元素也可以是一个列表

nums = [1, 2, 3, 4]
del  nums[1]
print(nums)  #   [1, 3, 4]
pop（）方法是移除并返回列表中指定索引的元素

nums = [1, 2, 3, 4]
nums.pop()  #默认-1
print(nums)

remove（）方法，移除列表中指定元素

nums  = [1, 2, 2, 3, 4]
nums.remove(2)  #则只会删除最左边一个
print(nums)  #[1, 2, 3, 4]

4改

5查

获取单个元素

nums = [1, 2, 3]
print(nums[-1])  #  3

获取元素索引

nums = [1, 2, 5, 3, 4]
print(nums.index(5))  #  2

获取指定元素个数

nums = [1, 2, 5, 2, 3, 4]
print(nums.count(2) ) #2
获取多个元素，以及迭代。

切片# items[start:end:step]

遍历

 方式1# 根据元素进行遍历#

                for item in list:

              print(item)

方式2# 根据索引进行遍历# 

               for index in range(len(list)):

            print(index, list[index])# 

方式3(了解)# 创建对应的枚举对象 #

               概念# 通过枚举函数, 生成的一个新的对象

            作用# 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列

                  # 同时列出数据下标和数据# 语法#

                         enumerate(sequence, [start=0])

                        # sequence -- 一个序列、迭代器或其他支持迭代对象。                             

                        # start -- 下标起始位置。

                        举例# l = ["a", "b", "c"]# enumerate(l, 1)# 一个待枚举的对象

         转换成为list之后, 具体数据如下# [(1, 'a'), (2, 'b'), (3, 'c')]

           # 遍历枚举对象#

                      for index, value in 枚举对象:

                           print(index, value)

# 方式4(了解)# 使用迭代器进行遍历#

                        iterL = iter(list)  for item in iterL:  print(item)


# 访问集合的方式-迭代器# 

   概念# 迭代# 是访问集合元素的一种方式， 按照某种顺序逐个访问集合中的每一项

       # 可迭代对象# 能够被迭代的对象, 称为可迭代对象

      # 判定依据# 能作用于for in

     # 判定方法# import collections# isinstance(obj, collections.Iterable)

  # 迭代器# 是可以记录遍历位置的对象，从第一个元素开始, 往后通过next()函数, 进行遍历，只能往后, 不能往前 。# 判定依据#能作用于next()函数

       # 判定方法 import collections  isinstance(obj, collections.Iterator)

      # 注意# 迭代器也是可迭代对象, 所以也可以作用于for in

     # 为什么会产生迭代器?

       1. 仅仅在迭代到某个元素时才处理该元素 ，在此之前, 元素可以不存在 ， 在此之后, 元素可以被销毁 。特别适合用于遍历一些巨大的或是无限的集合 。  例如 "菲波那切数列"

       2. 提供了一个统一的访问集合的接口# 可以把所有的可迭代对象, 转换成迭代器进行使用

         # iter(Iterable)# iter(str)# iter(list)# iter(tuple)# iter(dict)# ...

          # 迭代器简单使用， 使用next()函数, 从迭代器中取出下一个对象, 从第1个元素开始 ，因为迭代器比较常用, 所以在Python中, 可以直接作用于for in# 内部会自动调用迭代器对象的next() ，会自动处理迭代完毕的错误。

        # 注意事项 ：如果取出完毕,再继续取, 则会报错 StopIteration ， 迭代器一般不能多次迭代

import collections nums = [1, 2, 3] result = isinstance(nums, collections.Iterable) print(result)  # True
result = isinstance(nums, collections.Iterator) print(result)  # Flase

# 转为迭代器
it = iter(nums) for v in it: print(v) # 判定# 元素 in 列表# 元素 not in 列表


# 比较# cmp()# 内建函数# 如果比较的是列表, 则针对每个元素, 从左到右逐一比较# 左 > 右# 1# 左 == 右# 0# 左 < 右# -1# Python3.x不支持# 比较运算符# ==# ># <</span># ...# 针对每个元素, 从左到右逐一比较

# 排序# 方式1# 内建函数# 可以对所有可迭代对象进行排序# 语法# sorted(itrearble, key=None, reverse=False)# 参数# itrearble# 可迭代对象# key# 排序关键字# 值为一个函数，此函数只有一个参数且返回一个值用来进行比较# reverse# 控制升序降序# 默认False# 升序# 返回值# 一个已经排好序的列表# 列表类型
s = "cdefga"result = sorted(s); print(result)  #['a', 'c', 'd', 'e', 'f', 'g']
s = [2,3,1,4,5] result = sorted(s, reverse = True) print(result)  #[5, 4, 3, 2, 1]
s = [("a", 16), ("a1",13), ("a2", 14)] result = sorted(s) print(result) #[('a', 16), ('a1', 13), ('a2', 14)]

#按元组的第一个元素来排序
def getKey(x): return x[1] result = sorted(s, key=getKey) print(result)  #[('a1', 13), ('a2', 14), ('a', 16)]

# 方式2# 列表对象方法# 语法# list.sort(key=None, reverse=False)# 参数# key# 排序关键字# 值为一个函数，此函数只有一个参数且返回一个值用来进行比较# reverse# 控制升序降序# 默认False# 升序
s = [2,3,1,4,5] res = s.sort() print(res, s) # None [1, 2, 3, 4, 5] 注意和内建函数的方法不同点；

# 乱序# 可以随机打乱一个列表# 导入random模块# import random# random.shuffle(list)

import random list = [1, 2, 3, 4, 5] res = random.shuffle(list) print(res, list)   #None [4, 3, 5, 2, 1] 后面序列随机，修改原序列的本身

# 反转# l.reverse()
list = [1, 2, 3, 4, 5] res = list.reverse() print(res, list)   #None [5, 4, 3, 2, 1]

# 切片反转# l[::-1]
list = [1, 2, 3, 4, 5] res = list[::-1] print(res, list) #[5, 4, 3, 2, 1] [1, 2, 3, 4, 5]

正则表达式

这么多detail的信息，能不用则不用吧。很偏的知识点。摘自：

https://www.cnblogs.com/wholj/p/8073740.html

精确匹配：

   \d: 匹配一个数字
    \w: 匹配一个字母或数字
    . : 匹配任意一个字符
    \s: 匹配一个空格(包括tab等空白符)
匹配变长的字符：
    * : 匹配任意个字符，包括0个
    + : 匹配至少一个字符
    ? : 匹配0个或一个字符
    {n} : 匹配n个字符
    {n,m} : 匹配n~m个字符

eg: 说明“\d{3}\s+\d{2,5}”的含义
    \d{3}: 表示匹配3个数字，例如'028'
    \s+:   表示匹配至少一个空格
    \d{2,5}: 表示匹配2~5个数字，例如'1245'

   比如可以匹配以任意个空格隔开区号的电话号码。例如'028 57652'

[] :用来表示范围
    [0-9a-zA-Z\_]: 可以匹配一个数字、大小写字母或者下划线
    [0-9a-zA-Z\_]+: 可以匹配至少由一个数字、大小写字母或者下划线组成的字符串
        eg: 'a54', 'fasd', 'who_lj123'...
    [a-zA-Z\_][0-9a-zA-Z\_]*: 可以匹配由字母或下划线开头，后边任意个有数字、字母或者下划线组成的字符串，即python的合法变量名
    [a-zA-Z\_][0-9a-zA-Z\_]{0, 19}: 更精确地限制了变量的长度是1-20个字符

a|b: 匹配a或者b
    eg: (P|p)ython: 可以匹配'Python'或者'python'

^: 匹配行首
    eg: ^\d: 表示行必须以数字开头
$: 匹配行尾
    eg: $\d: 表示行必须以数字结尾
^SOME_STR$: 匹配只包含SOME_STR的行

python中的正则表达式模块是re

match()方法判断是否匹配，如果匹配成功，返回一个Match对象，否则返回None。常见的判断方法就是：
test = '用户输入的字符串'
if re.match(r'正则表达式', test):
    print('ok')
else:
    print('failed')
切分字符串：
    re.split(r'\s+', 'TEST_STR'): 指定分隔符为空格
    re.split(r'[\s\,\;]+', 'TEST_STR'): 指定分隔符为空格、逗号或者分号

字符串匹配

首先，说明字符串的定义：

正则表达式不适用于运算符，以及其他转义字符，unicode字符串。

匹配方法小结：摘自https://www.jb51.net/article/142823.htm

1.re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。

import re

line="this hdr-biz 123 model server 456"

pattern=r"123"

matchObj = re.match(pattern,line)

2. re.search 扫描整个字符串并返回第一个成功的匹配。

import re

line="this hdr-biz model server"

pattern=r"hdr-biz"

m= re.search(pattern,line)

3. Python 的re模块提供了re.sub用于替换字符串中的匹配项。

import re

line="this hdr-biz model args= server"

pattern=r'args='

name = re.sub(patt,"",line)

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

import re

pattern = re.compile(r'\d+')

5. re.findall 在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果没有找到匹配的，则返回空列表。

import re

line = "this hdr-biz model args= server"

patt=r'server'

pattern = re.compile(patt)

result = pattern.findall(line)

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

import re

it = re.finditer(r"\d+","12a32bc43jf3")

for match in it:

print(match.group())