Python

Python 系列文章目录

文章目录

系列文章目录前言一、参考资料二、不定参数*args 和 **kwargs三、生成器（Generators）四，Map，Filter 和 Reduce五，set(集合)数据结构六，装饰器七，列表,字典,集合推导式八，异常九，lambda表达式十，内置函数十一，特殊技巧十二，魔术方法十三，Bug求救总结

---

前言

这一部分是关python进阶，其实没什么，就是把别人家的敲了一遍，然后汇总了，怕以后会用的到(记忆力不太好)

---

一、参考资料

Python进阶

---

二、不定参数*args 和 **kwargs

*args 是用来发送一个非键值对的可变数量的参数列表或元组给一个函数**kwargs 允许你将不定长度的键值对, 作为参数传递给一个函数

def test(a, *arg):
    print(a)
    for arg in arg:
        print("*arg的参数:", arg)
test('a', 'b', 'c', 'd')

def test1(**kwargs):
    for key, value in kwargs.items():
        print("{0} == {1}".format(key, value))
test1(a=1,b=2,c=3)

def test3(f, *arg, **kwargs):
    print(f)
    for arg in arg:
        print("*arg的参数:", arg)
    for key, value in kwargs.items():
        print("{0} == {1}".format(key, value))
test3(1, 'b', 'c', 'd', a=1, b=2, c=3)

#使用 *args 和 **kwargs 来调用函数
def test4(a, b, c):
    print("第一个值:", a)
    print("第二个值:", b)
    print("第三个值:", c)
arg=[1,2,3]
kwarg={"b":2,"a":1,"c":3}#key为函数参数test3(a, b, c)
test4(*arg)
test4(**kwarg)

三、生成器（Generators）

可迭代对象(Iterable)
Python中任意的对象，只要它定义了可以返回一个迭代器的__iter__方法，或定义了可以支持下标索引的__getitem__方法，那么它就是一个可迭代对象。
简单说，可迭代对象就是能提供迭代器的任意对象迭代器(Iterator)
迭代器是一个让程序员可以遍历一个容器（特别是列表）的对象。任意对象，只要定义了next(Python2) 或者__next__方法，它就是一个迭代器。迭代(Iteration)
它就是从某个地方（比如一个列表）取出一个元素的过程。生成器(Generators)
生成器也是一种迭代器，但是你只能对其迭代一次。

---

5. next()
它允许我们获取一个序列的下一个元素。
6. iter()
它将根据一个可迭代对象返回一个迭代器对象

def test5():
    for i in range(10):
        yield i
#第一种方式
gen=test5()
print(next(gen))
print(next(gen))
print(next(gen))
for i in test5():#第二种方式
    print(f'这是迭代{i}')

#一个计算斐波那契数列的生成器：
def fibon(n):
    a = b = 1
    for i in range(n):
        yield a
        a, b = b, a + b
for x in fibon(100):
    print(x)
#普通方式更耗资源
# def fibon(n):
#     a = b = 1
#     result = []
#     for i in range(n):
#         result.append(a)
#         a, b = b, a + b
#     return result

#iter()应用
a1=[1,2,-4,5,6,7]
a=iter(a1)
print(next(a))
print(next(a))

a=iter(range(10))
print(next(a))
print(next(a))
print(next(a))

该处使用的url网络请求的数据。

---

四，Map，Filter 和 Reduce

Map会将一个函数映射到一个输入列表的所有元素上。filter过滤列表中的元素，并且返回一个由所有符合要求的元素所构成的列表.Reduce当需要对一个列表进行一些计算并返回结果,例子，当你需要计算一个整数列表的和时。

#Map例子1
#items = [1, 2, 3, 4, 5]
#squared = []
#for i in items:
#    squared.append(i**2)
items = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, items))

#Map例子2
def add(x,y):
    return x+y
def decrease(x,y):
    return x-y
func=[add,decrease]
for i in range(5):
    value=list(map(lambda x:x(i+3,i+2),func))
    print(value)

#Filter例子1
a=[1,2,3,-1,-2,-3,-4]
bb=filter(lambda x:x>0,a)
print(list(bb))

#Reduce 例子1
from functools import reduce
a=reduce(lambda x,y:x+y,[1,2,3,4])
print(a)

---

五，set(集合)数据结构

set不能包含重复的值。（最大特征）

#查看重复值
list1 = ['a', 'b', 'c', 'b', 'd', 'm', 'n', 'n']
test = set([x for x in list1 if list1.count(x) > 1])
print(test)
#交集差集
list1 = ['a', 'b', 'c', 'e', 'f']
list2 = ['a', 'b', 'c', 'g']
print(set(list2).intersection(set(list1)))
print(set(list2).difference(set(list1)))
#set1 = {'red', 'blue', 'green'}#创建

---

六，装饰器

增加函数的功能的函数，有助于让我们的代码更简洁。

a1=[1,2,-4,5,6,7]
for x in a1:
    if x > 0: a1.remove(x)
print(a1)

a1=[1,2,-4,5,6,7]
for x in a1[:]:
    if x > 0: a1.remove(x)
print(a1)

---

七，列表,字典,集合推导式

用起来，特别爽！通常和lambda表达式联用

列表(list)推导式字典(dict)推导式集合(set)推导式

#列表(list)推导式
#variable = [out_exp for out_exp in input_list if out_exp == 2]
test= [i for i in range(30) if i % 3 is 0]
print(test)
squared = [x**2 for x in range(10)]
#字典(dict)推导式
my_dict = {'a': 'av', 'b': 'bv', 'c': 'cv'}
test={v: k for k, v in my_dict.items()}
print(test)
#集合(set)推导式
squared = {x**2 for x in [1, 1, 2]}
print(squared)

---

八，异常

#处理多个异常
try:
    file = open('test.txt', 'rb')
except EOFError as e:
    print("An EOF error occurred.")
    raise e
except IOError as e:
    print("An error occurred.")
    raise e
#捕获所有异常
try:
    file = open('test.txt', 'rb')
except Exception:
    # 打印一些异常日志，如果你想要的话
    print('exception')
else:
    # 这里的代码正常时运行, 但是这里的异常将不会 被捕获
    print('正常时打印.')
finally:
    print("总会打印")

---

九，lambda表达式

lambda表达式是一行函数。被称为匿名函数

#相加
add = lambda x, y: x + y
print(add(3, 5))

#列表排序
a=[(1,2),(3,4),(2,1)]
a.sort(key=lambda x:x[1],reverse=True)
print(a)

---

十，内置函数

zip()round()dir（）

#zip()
list1 = [1, 2, 3, 4]
list2 = [1, 2, 3, 4]
data = zip(list1,list2)
print(list(data))
#round()
print(round(1.2242,2))

十一，特殊技巧

列表的碾平构造器
避免类初始化时大量重复的赋值语句For - Else上下文管理器Hash注释深拷贝和浅拷贝
深拷贝指的是复制内容，单独开辟一个内存，浅拷贝指的是两个变量同时指向一个内存ID;
当拷贝内容是可变类型时，那么就会进行深拷贝，如果是不可变类型时，那么就会进行浅拷贝。GET和SET,@property装饰器

#列表的碾平
import itertools
a=([1,2],[3,4],[5,6])
b=itertools.chain.from_iterable(a)
print(list(b))
# c=itertools.chain(*a)#第二种方式
# print(list(c))

#避免类初始化时大量重复的赋值语句
class A(object):
    def __init__(self, a, b, c, d, e, f):
        self.__dict__.update({k: v for k, v in locals().items() if k != 'self'})

    def printA(self):
        print(self.a,self.b,self.c,self.d,self.e,self.f)

A(1,2,3,4,5,6).printA()

#For - Else
for n in range(2, 10):
    for x in range(2, n):
        if n % x == 0:
            print( n, '=', x, '*', n/x)
            break
    else:
        print(n, '是质数')

#上下文管理器
with open('some_file', 'w') as opened_file:
    opened_file.write('Hola!')

#hash
a='11'
print(hash(a))
# aa={1,2,'we',[1,2,3]}#TypeError: unhashable type: 'list'

#注释
def Text(a:3,b:int=5)-> "我是注释":
    print(Text.__annotations__)
    print(Text.__annotations__['return'])
    print(a,b)
    print(Text.__name__)
    print(Text.__str__)
# Text(1,2)
Text(1)

#深拷贝和浅拷贝
import copy
list1 = [1,2,3,4,5]
list2 = list1   #浅拷贝
list3 = copy.deepcopy(list1) #深拷贝
list4 =list1[:] #深拷贝。


#普通的get,set
class Test:
    def __init__(self, name):
        self.__name = name  # 私有属性
    def get_name(self):
        return self.__name
    def set_name(self, name):
        self.__name = name
t = Test('lzl')
print(t.get_name())
t.set_name('zhouyi')
print(t.get_name())

#@property装饰器
class Test:
    def __init__(self, name):
        self.__name = name  # 私有属性
    @property
    def name1(self):
        return self.__name

    @name1.setter
    def set_name1(self, name):
        self.__name = name
t = Test('lzl')
print(t.name1)
t.set_name1 = 'zhouyi'
print(t.name1)

十二，魔术方法

1.__call__#类比于函数的行为,
2.__str__#字符串显示
3.__repr__#如果找不到__str__()就会找__repr__()方法
4.__new__#实例化
5.__del__#当一个对象在内存中被销毁的时候自动执行

#__call__
class Person(object):
    def __call__(self, *args, **kwargs):
        print('call...')
person = Person()  # 将Person()的内存地址赋值给person
person(1 ,2 ,3 ,45)  # 内存地址()

#__str__,__repr__
class Person(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):
        msg = 'name:%s,age:%s' % (self.name, self.age)
        return msg
    # 如果没有__str__的时候，就会执行__repr__方法
    # 如果有就不执行__repr__方法。
    def __repr__(self):
        msg = f'name----》{self.name},age----》{self.age}'
        return msg
person = Person('lzl', 21)
print(str(person))
print(repr(person))

#__new__
class Person(object):  
    def __init__(self):# 初始化
        print('init...')
    # 实例化方法（构造方法）---》创建对象
    def __new__(cls, *args, **kwargs):
        print('new...')
        ret = super().__new__(cls) # 调用父类的__new__()方法创建对象，并用接收返回值
        return ret # 将对象返回给person
person = Person()
print(person)

十三，Bug求救

a1=[1,2,-4,5,6,7]
for x in a1:
    if x > 0: a1.remove(x)
print(a1)

a1=[1,2,-4,5,6,7]
for x in a1[:]:
    if x > 0: a1.remove(x)
print(a1)

总结

还需要好好钻研！！