python常用内置方法

常用内建函数
# 如何在遍历一个列表的同时获取当前下标？

# 普通人的做法
list = [1, 2, 3, 4, 5, 6]
index = 0
for i in list:
    print('下标%s' % index, i)
    index += 1

# 大佬的做法
list = [1, 2, 3, 4, 5, 6]
for i, j in enumerate(list):
    print('下标%s' % i, j)

# 如何使用函数修饰被迭代对象来优化循环

# 普通人的做法
list1 = [1, 2, 3, 4, 5, 6]
list2 = [2, 3, 4, 5, 6, 7]
list3 = [3, 4, 5, 6, 7, 8]
for i in list1:
    for j in list2:
        for k in list3:
            if i + j + k == 10:
                print(i, j, k)

# 大佬的做法
from itertools import product
for i, j, k in product(list1, list2, list3):
    if i + j + k == 10:
        print(i, j, k)

#无限迭代器的使用

#普通人的做法
na = 2
while True:
    print(na)
    na +=1

#大佬的做法
from itertools import count
for i in count(2):#参数:表示从几开始
    print(i)

#无限重复之迭代器的使用

#普通人都做法
res = 'ABC'
while True:
    for i in res:
        print(i)

#大佬的做法
from itertools import cycle
for i in cycle('ABC'):
    print(i)

#如何找到列表中的元素进行无限重复,并可用控制重复的次数

#普通人都做法
list = [1,2,3,4,5,6]
for i in list:
    if i==list[2]:
        for j in range(10):
            print('1',list[2])

#大佬的做法
from itertools import repeat
list = [1,2,3,4,5,6]
res = repeat(list[2],10)#参数一:表示从几开始,参数二:表示重复次数
for i in res:
    print('2',i)

# 如何使用 islice 实现循环内隔行处理
需要把a.txt文件中的'---'去掉

1234
---
aadd
---
sadsad
---
asdasdad

# 普通人的做法
def test():
    with open('a.txt', 'r') as fp:
        for i, line in enumerate(fp):
            # 跳过无意义的 '---' 分隔符
            if i % 2 == 0:
                yield line.strip()
for i in test():
    print(i)

# 大佬的做法
from itertools import islice
# islice(seq, start, end, step) 函数和数组切片操作*（ list[start:stop:step] ）有着几乎一模一样的参数。
# 如果需要在循环内部进行隔行处理的话，只要设置第三个递进步长参数 step 值为 2 即可（默认为 1 ）*。
def parse_titles_v2():
    with open('a.txt', 'r') as fp:
        # 设置 step=2，跳过无意义的 '---' 分隔符
        for line in islice(fp, 0, None, 2):
            yield line.strip()
for i in parse_titles_v2():
    print(i)

# 使用 takewhile 替代 break 语句

# 普通人的做法
list = [1, 2, 3, 4, 5, 6]
for i in list:
    if i == 4:
        break
    else:
        print(i)

# 大佬的做法
from itertools import takewhile
list = [1, 2, 3, 4, 5, 6]
for i in takewhile(lambda x: x != 4, list):#参数一:限制条件函数,list表
    print(i)

#如何使用列表链(将一组迭代对象串起来,形成一个更大的迭代器)

#普通人的做法
v1 = [11,22,33]
v2 = [44,55,66]
all = v1+v2
for c in all:
    print(c)

#大佬的做法
from itertools import chain
v1 = [11,22,33]
v2 = [44,55,66]
new_list = chain(v1,v2)
for c in new_list:
    print(c)

#偏函数的使用

from functools import partial
def fuc1(a1,a2):#一个函数有两个参数
    print('fuc1',a1,a2)
    return a1-a2
def fuc2(a3,a4):
    print('fuc2',a3,a4)
    return a3+a4
new_fuc = partial(fuc1,fuc2(1,2))#functools.partial可以传函数名和fuc的第一个参数
res = new_fuc(3)
print(res)
#----------结果
#fuc2 1 2
#fuc1 3 3
#0
# 这样理解执行函数先执行fuc2,打印fuc2 1 2
# fuc2的返回值和fuc1函数存放在new_fuc对象中
# new_fuc(3),把3传入fuc1函数的a1,把fuc2返回值放入a2,打印fuc2 3 3
# res打印0

累加

from  itertools import accumulate
_list = [1,2,3,4,5,6]
print(list(accumulate(_list)))#[1, 3, 6, 10, 15, 21]
#实现累加的函数

importlib内置模块

　　文件目录

#a.py
class A(object):
    def public(self):
        print('aaa')

#b.py
class B(object):
    def public(self):
        print('bbb')

#c.py
class C(object):
    def public(self):
        print('ccc')

#co.py
from importlib import import_module
M = [
    'util.a.A',
    'util.b.B',
    'util.c.C',
]
for m in M:
    import_class,method_class = m.rsplit('.',maxsplit=1) #按最后右边的'.'分割,获取文件路径对象名称和成员对象名称,maxsplit=1表示最大分割一次
    r = import_module(import_class) #自动导入文件
    oo =getattr(r,method_class) #获取导入文件中的成员对象,此时oo就是每个class对象
    res = oo()  #实例化
    res.public() #执行公共方法
#借鉴了jdango中使用字符串导入模块的功能,好处是减少耦合,功能模块可以自如开关

# 普通人的做法
class Api1:
    def __init__(self, b: tuple):
        self.a: tuple = (1, 2, 3, 4,)
        self.b: b = self.a + b


res1 = Api1((5, 6,))
print(res1.a)  # (1, 2, 3, 4)
print(res1.b)  # (1, 2, 3, 4, 5, 6)


# 大佬的做法
class Api2:
    def __init__(self, b: tuple):
        self.a = (1, 2, 3, 4,)
        self.b = self.a + b


res2 = Api2((5, 6,))
print(res2.a)  # (1, 2, 3, 4)
print(res2.b)  # (1, 2, 3, 4, 5, 6)