python较为难懂 又较为常用的语法解释

１．

imgs = [os.path.join(root, img) for img in os.listdir(root)]

点１：在使用for循环遍历可迭代对象构造列表

点２：os.listdir返回参数制定的目录下所有的文件组成的列表  os.path.join(root, img)将两个字符串组合为文件目录的形式

 

2.

imgs = sorted(imgs, key=lambda x: int(x.split('.')[-2]))

点1：

sorted的用法：

sorted(iterable, /, *, key=None, reverse=False)

key参数的意义：key是一个函数，该函数接收一个元素，返回值表示该元素的权值，

key指定的函数将作用于list的每一个元素上，并根据key函数返回的结果进行排序

sorted的返回值时排序后的iterable的副本

详细参考：

https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/0014318230588782cac105d0d8a40c6b450a232748dc854000

该网址还讲解了 map(将函数作用于可迭代对象的每个元素后返回列表) reduce filter

点2：

split是字符串的方法，x.split('.')将x通过.分割后返回列表

 

 

3.python类

 

python类的属性可以在任何地方动态添加，随时随地，不需要事先在__init__函数中声明

python类的属性可以不在init函数中添加吗

可以通过if else等使得同一个类对象的属性不同吗

 

 

4.python的fire库的使用

为什么要使用fire库

使用fire库时，只能在命令行运行，这样无法用pycharm软件进行调试怎么办

想使用pycharm调试时，就不要用fire库，而是自己在源文件中构造参数和调用函数

 

5.python下的模块和包

一个python文件可以当成一个模块，可以通过import导入模块（把一个.py文件当成一个模块）

导入一个模块的方法：import xxx(文件名)

导入模块的作用：可以看到该模块定义、声明的变量、函数、类等（都是对象）

sys.path.append('路径'） 增加寻找模块的路径

包package是另一类模块（把含有__init__.py文件的目录当成一个包,包可以包含其他包或者模块）（包是一个目录，目录下有__init__.py的文件），它们能够包含其他模块（能够包含本目录下的其他包或者模块）

 import 包名：只能看到包目录下的__init__.py下定义声明的对象

import  包名、模块名或者from 包名 import 模块名：只能看到包的这个模块中定义声明的对象

import 包名后，可以通过包名.模块名等看到该模块下的定义声明的对象

 

研究其他模块的方法（以copy模块为例子）：dir(copy)         copy.__all__          help(copy)

 

 

6.python中if与and or not结合的判断

and、or连接两个表达式，用于判断多个表达式的真假

not用于对表达式取反

 

7.python使用import导包的讲解

首先，明白什么时模块，什么时包（见第5条）

使用import导包时，会执行包下面的__init___.py中的语句，包括导入其他包的语句，python命令等

如下图：执行了到包语句from xxx import xx和print函数，然后判断条件if xxx,发现不满足，所以不执行

而from xxximport xx则只会执行这一句，相当于import  xx.xx

如上图，如果想要系统找到相应的包，需要import sys           sys.path.append(包所在的路径)

import和from导入时的另一区别：import下的必须时包或者module,from可以直接导入属性

如果模块位于当前目录或者上一目录，可以使用.   ..来告诉编译器去当前目录或上一个目录找到该模块（绝对路径导入与相对路径导入）

参考https://www.cnblogs.com/zmlctt/p/4208938.html

 

9.python类

 

super函数：参考

http://www.runoob.com/python/python-func-super.html

super(类A,self对象) 首先找到 类A的父类，然后把self对象转换为A父类 的对象

 

10.python中的*args和**kwargs

参考：https://www.cnblogs.com/goodhacker/p/3360721.html

先来看一个例子：

 

 1 >>> def foo(*args, **kwargs):
 2     print 'args =', args
 3     print 'kwargs = ', kwargs
 4     print '-----------------------'
 5 
 6     
 7 >>> if __name__ == '__main__':
 8     foo(1, 2, 3, 4)
 9     foo(a=1, b=2, c=3)
10     foo(1,2,3,4, a=1, b=2, c=3)
11     foo('a', 1, None, a=1, b='2', c=3)

 

其输出结果如下：

 

 1 args = (1, 2, 3, 4)
 2 kwargs =  {}
 3 -----------------------
 4 args = ()
 5 kwargs =  {'a': 1, 'c': 3, 'b': 2}
 6 -----------------------
 7 args = (1, 2, 3, 4)
 8 kwargs =  {'a': 1, 'c': 3, 'b': 2}
 9 -----------------------
10 args = ('a', 1, None)
11 kwargs =  {'a': 1, 'c': 3, 'b': '2'}
12 -----------------------

从以上例子可以看出，这两个是python中的可变参数。*args表示任何多个无名参数，它是一个tuple；**kwargs表示关键字参数，它是一个 dict。并且同时使用*args和**kwargs时，*args参数列必须要在**kwargs前

 

11.pytorch经常用到detach

detach就是截断反向传播的梯度流。

它时什么作用，我暂时也没看懂

贴个链接：https://blog.csdn.net/qq_39709535/article/details/80804003

 

12.python装饰器

参考http://python.jobbole.com/85056/

从6开始看

装饰器其实就是一个以函数作为参数并返回一个替换函数的可执行函数。

摘自：https://blog.csdn.net/hzau_yang/article/details/53559483

比如：
@a
@b
def c():
…
python会按照自下而上的顺序把各自的函数结果作为下一个函数（上面的函数）的输入，也就是c=a(b(c))

注意，a(b(c))传入的时c这个函数，传入的是c这个可调用对象，而不是传入c的返回值。

定义函数
@logger
def foo1(x, y=1):
    return x * y

此时，执行了logger(foo1),foo1函数对象首先作为参数传入,打印了123，定义了inner函数对象，然后返回inner对象，foo1变量就变成返回的inner函数对象(foo1函数对象定以后就变为logger函数的返回值的对象)

当再次调用foo1函数对象时，如foo1(2)，就相当于调用inner()函数，inner()函数对象中会调用一开始传入的foo1()函数对象

假设inner函数对象不调用传入的参数foo1,logger(foo1)依然是foo1函数对象首先作为参数传入，然后作为变量变成logger函数的返回值

 

 

 

17.python中的上下文管理器，with语句

参考：https://www.cnblogs.com/huchong/p/8268765.html

 

 

17.@classmethos和@staticmethod

转载https://blog.csdn.net/polyhedronx/article/details/81911548

 

python的yield:

https://www.cnblogs.com/coder2012/p/4990834.html