Python学习笔记

基础

创建：

test = {
    'a':'1',
    'b':'asdf'
}

遍历

遍历键 值

    for key, value in test.items():
        print(key+':'+value)        

只遍历 键名

    for key in test.keys():
        print(key)

只遍历 值

    for value in test.values():
        print(value)

输出控制

用空格字符结尾

print("and", end =" ")
print("c", end =" ")

Python 核心编程

关于各类括号

“()” ：
主要应用在限制多选结构的范围/分组/捕获文本/环视/特殊模式处理
示例：
1、(abc|bcd|cde)，表示这一段是abc、bcd、cde三者之一均可，顺序也必须一致
2、(abc)?，表示这一组要么一起出现，要么不出现，出现则按此组内的顺序出现
3、(?:abc)表示找到这样abc这样一组，但不记录，不保存到 变量中，否则可以通过 变 量 中 ， 否 则 可 以 通 过 x取第几个括号所匹配到的项，比如：(aaa)(bbb)(ccc)(?:ddd)(eee)，可以用 1获取(aaa)匹配到的内容，而 1 获 取 ( a a a ) 匹 配 到 的 内 容 ， 而 3则获取到了(ccc)匹配到的内容，而$4则获取的是由(eee)匹配到的内容，因为前一对括号没有保存变量
4、a(?=bbb) 顺序环视 表示a后面必须紧跟3个连续的b
5、(?i:xxxx) 不区分大小写 (?s:.*) 跨行匹配.可以匹配回车符
6、(.+)\n 表示重复出现(.+)中的内容n次。返回’NoneType’，因此不能调用其group()函数
“[]” ：
单个匹配，字符集/排除字符集/命名字符集
示例：
1、[0-3]，表示找到这一个位置上的字符只能是0到3这四个数字，与(abc|bcd|cde)的作用比较类似，但圆括号可以匹配多个连续的字符，而一对方括号只能匹配单个字符
2、[^0-3]，表示找到这一个位置上的字符只能是除了0到3之外的所有字符
3、[:digit:] 0-9 [:alnum:] A-Za-z0-9
“{}” ：
“9{i, j}” 表示在字符串中重复出现1到3次

关于re.match()

只能够从起始位置开始匹配，即使匹配规则中使用了$符号

关于元字符(metacharacters)

“ . ” 表示匹配非换行符的任何字符
“ ^ ” 表示字符串的起始位置
“ $ ” 表示字符串的结束位置

“[^A-Z]” 表示匹配除了A-Z的所有字符

通配符 关于转义字符

import re
str1 = "\bst"
str2 = r"\bst"

上述区别：
r 表示转义，也就是说
str1 中 \b 表示 backspace
str2 中 \b 表示 对有边界字符进行匹配的通配符

关于匹配处理

re.I 忽略大小写
re.M 输出所有行的尾字母

关于通配符方法的特殊返回值

findall()方法返回一个list对象
Exp:

import re
str1 = "car"
str2 = "bcaray is in the car of Carry's carbox"
m = re.findall(str1, str2)
print(type(m))
if m is not None:
    for i in m:
        print(i, end = ' ')

输出：

<class 'list'>
car car car 

finditer()方法返回一个可供迭代的对象）
Exp：

import re
str = "This and that"
m = re.finditer(r"(th\w+) and (th\w+)", str, re.I)
print(type(m))
if m is not None:
    for i in m:
        print(i.groups())

输出：

<class 'callable_iterator'>
('This', 'that')

sub()返回字符串
Exp
略

subn()返回元组

关于非捕获组

(?:...)

上述代码被称作非捕获组，作用为
(?:X) X，作为非捕获组
与捕获组 ( ) 的意思一样也是将其作为一组进行处理，与捕获组的区别在于不捕获匹配的文本，
仅仅作为分组。
比如：要匹配 123123 这个，就可以写为 (123)/1 使用反向引用，这时只能用捕获组，在匹配
123 后会保留在内存中，便于反向引用，而 (?:123) 在匹配完后则不会保留，区别仅在于此。
引用自CSDN
https://blog.csdn.net/zfq642773391/article/details/5555602

python 基础

关于Python 几种 itertools 的使用方法

count

for i in count(5):
    print(i)
    if i >= 12:
        break

output:
5
6
7
8
9
10
11
12

cycle

from itertools import cycle

for item in cycle("asdf"):
    print(item)
    if c >= 5:
        break

output：
a
s
d
f
a
s
d
f
a
s
d
…
按照字符串中字母排列顺序无限循环地输出字符串中的每个元素

repeat

from itertools import repeat

for item in repeat("asdf", 3):
    print(item)

output:
asdf
asdf
asdf
repeat(“字符串”, cycle_times)

accumulate

from itertools import repeat, accumulate

print(list(accumulate(range(5))))

accumulate(range(n)) 返回0~n项等差数列（步长为1）的和

takewhile

from itertools import takewhile

nums = [1,2,3,4,5,6,7,8]
print(list(takewhile(lambda x : x <= 3, nums)))

output:
[1, 2, 3]
takewhile 计算到条件不符合的那个数就会停止计算，返回所得到的数值

product

from itertools import product
letters = ("A", "B")
print(list(product(range(3), letters)))

output：
[(0, ‘A’), (0, ‘B’), (1, ‘A’), (1, ‘B’), (2, ‘A’), (2, ‘B’)]
product 个人理解类似于组合
product(A, B)，它是将 A 中的所有元素当作x，与 B 中所有元素（当作y）进行组合
例如
A : [“x1”, “x2”, “x3”]
B : [“y1”, “y2”]
list(product(A, B)) : [(‘x1’, ‘y1’), (‘x1’, ‘y2’), (‘x2’, ‘y1’), (‘x2’, ‘y2’), (‘x3’, ‘y1’), (‘x3’, ‘y2’)]

permutations

from itertools import permutations
a = ["x1", "x2", "x3"]
print(list(permutations(a))

output:
[(‘x1’, ‘x2’, ‘x3’), (‘x1’, ‘x3’, ‘x2’), (‘x2’, ‘x1’, ‘x3’), (‘x2’, ‘x3’, ‘x1’), (‘x3’, ‘x1’, ‘x2’), (‘x3’, ‘x2’, ‘x1’)]
permutations 其功能如同其译名——排列
就是将某一变量中的所有数据进行排列

Magic Methonds

__sub__ for -
__mul__ for *
__truediv__ for /
__floordiv__ for //
__mod__ for %
__pow__ for **
__and__ for &
__xor__ for ^
__or__ for |
__lt__ for <
__le__ for <=
__eq__ for ==
__ne__ for !=
__gt__ for >
__ge__ for >=
__len__ for len()
__getitem__ for 相当于重载“[]”运算符
__setitem__ for 重载为已设定下标的数据赋值的函数
__delitem__ for 重载删除函数
__iter__ for iteration over objects (e.g., in for loops)
            (重载迭代器)
__contains__ for in

在python中，在类中重写上述方法能够达到重写运算符的作用
下面是重写方法and的例子

class Vector2D:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    def __add__(self, other):
        return Vector2D(self.x + other.x, self.y + other.y)

first = Vector2D(2, 4)
second = Vector2D(4, 6)
result = first + second
print("({0}, {1})".format(result.x, result.y))

上述代码中的other表示另外一个同类对象，如果非同类对象则会报错
如果你需要将该类对象加上一个非该类的对象，则在该类中重写方法radd，它意为右加。例如 B + A 中，A 没有重写add方法，则在 B 中重写radd方法，用

B().__radd__(A())

用这种方式，将两者加和

两种类私有属性

class Test:
    _pam = 12

t = Test()
print(_pam)    

output：
12
上面这种带有一个下划线的变量被称作弱私有变量，它能够直接在外部通过对象调用。

class Test:
    __pam = 24
    def print_pam(self):
        print(self.__pam)
t = Test()
t.print_pam()
print(t._Test__pam)
print(t.__pam)

output:
24
24
AttributeError: ‘Test’ object has no attribute ‘__pam’
上面这种带有两个下划线的被称作强私有变量，他不能使用对象直接在外部被调用，而是只能通过类中的方法，或者通过变量名.类名_强私有成员变量名这两种方式调用。

arg的作用

arg使得传入函数的参数数量固定，类型不固定，可以是多种数据类型

def check(arg):
    print(type(arg))

check(6)

输出：

<class 'int'>

*args的作用

*args使得传入函数的参数长度可变，如下例代码所示

def _function(*args):
    print(*args)

_function(1,2,3,4,5,6)
_function(2,3,4,2)

output:
1 2 3 4 5 6
2 3 4 2
其本质是元组

**keyword的作用

*keyword需要传入键值对这样的数据，如下例代码所示

def _function(**keywordss):
    print(keywordss)

_function(a="2", b="4")

output:
{‘a’: ‘2’, ‘b’: ‘4’}
其本质类型是字典

else 的特殊用法

当 else 跟在 while 或 for 等循环之后时，当循环正常退出的时候，才会执行else下的语句，如下例代码

for i in range(10):
    if i == 5:
        break
else:
    print("Normal Exit1")

for i in range(10):
    if i == 99:
        break
else:
    print("Normal Exit2")

output:
Normal Exit2

当 else 跟在 try/except 块之后时，当 try/except 块正常执行完之后，才能进入 else 中，如下例代码

try:
    print(1/2)
except ZeroDivisionError:
    print("Wrong1")
else:
    print("Correct1")

try:
    print(1/0)
except ZeroDivisionError:
    print("Wrong2")
else:
    print("Correct2")

使用 wraps 还原被装饰器修饰后函数的name属性

在使用装饰器修饰函数后，由于装饰器的写法中需要返回再装饰器内定义的函数，因此函数的name属性会相应改变，例子如下

def decorator_t(func):
    def wrapper(*args, **kwargs):
        print("wrappered")
        func()
    return wrapper

@decorator_t
def test():
    print("testing")

print("-" * 10)
print(test.__name__)
print("-" * 10)

这个时候控制台会输出：

----------
wrapper
----------

有时候这个会对程序的调试与修改造成一定的影响，因此我们需要函数的原有名称
这时候可以使用 wrag 装饰器，还原函数名称
例子如下

from functools import wraps
def decorator_t(func):
    @wraps(fucn)
    def wrapper(*args, **kwargs):
        print("wrappered")
        func()
    return wrapper

@decorator_t
def test():
    print("testing")

print("-" * 10)
print(test.__name__)
print("-" * 10)

再次运行程序，控制台输出如下

----------
test
----------