# 基操

# 如何对列表切片 ? | How to slice a list ?

# 切片是不包含最后一个元素的
>>> li = [0,3,3,6,7]
>>> li[0:1]
[0]
>>> li[2:3]
[3]
>>> li[0:4]
[0, 3, 3, 6]
1
2
3
4
5
6
7
8

# 如何遍历文件列表 ? | How to loop a file list ?

# 法1

for f in file_list:
    print(f)
1
2

# 法2

for i in range(len(file_list)):
    print(i,file_list[i])

1
2
3

# 如何使用迭代器?

Gang: 迭代器的特点就是 你调用时 它才给你传值

In [8]: a = [1,2,3]

In [9]: b = [4,5,6]

In [10]: c = zip(a,b)

In [11]: def test(li):
    ...:     res = []
    ...:     for i in zip(a,b):
    ...:         res.append(i)
    ...:     return res
    ...: 
    ...: 

In [12]: test(c)
Out[12]: [(1, 4), (2, 5), (3, 6)]

In [13]: test(c)
Out[13]: [(1, 4), (2, 5), (3, 6)]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# 如何控制浮点数的输出格式? | How to control the output format of a float number?

"{0:.2f}".format(13.949999999999999)
1

# 如何筛选一个列表中的特定元素?| How to select specific element in a list?

a = [1,2,2,3,4,5]
a = list(filter(lambda x: x!= 2, a))
1
2

结果是[1,3,4,5]

# 如何对列表求和?

li = [1,2,3]
sum(li)
1
2

# 如何对两列表同时遍历?

li1 = [1,2,3,4,5]
li2 = ['a','b','c','d','e']
for i,j in zip(li1,li2):
    print(i,j)
1
2
3
4

输出:

1 a
2 b
3 c
4 d
5 e
1
2
3
4
5

# 如何创建固定大小的空的列表?

长度为10的空列表

l = [None] * 10
1

# 如何运行系统命令?

 import os
 os.system('cat /proc/cupinfo')
1
2

# 如何获取命令行参数?

# 最简单的例子

#!/home/jack/anaconda3/bin/python
import os 
import sys

if len(sys.argv) < 2:
    print("Ooops. Usage:" + sys.argv[0] + ' times')
    exit()

cmd = 'python solve.py'
times = int(sys.argv[1])
for i in range(times):
    os.system(cmd)
1
2
3
4
5
6
7
8
9
10
11
12

# 使用argparse传入数字

import argparse
parser = argparse.ArgumentParser()
parser.add_argument('-N', nargs='?', const=-1, type=int, default=-1, \
                    help="choose the num(th) checkpoint to restore.")
args = parser.parse_args()
print(args.N)
1
2
3
4
5
6

参考

# 使用argparse传入字符

编辑python程序hello.py

import argparse
parser = argparse.ArgumentParser()

parser.add_argument('--path', help='The path.',default='./default_path/')
args = parser.parse_args()


print(args.path, type(args.path))
1
2
3
4
5
6
7
8

保存后,在命令行中输入:

python hello.py --path './hello/'
1

输出结果为:

./hello/ <class 'str'>
1

也就是说命令行的字符串参数顺利地传到了程序内部。

# 使用argparse传入boolean参数

编辑程序hello.py

import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--stochastic', dest='stochastic', action='store_true')
parser.add_argument('--no-stochastic', dest='stochastic', action='store_false')
parser.set_defaults(stochastic=True)
args = parser.parse_args()
print(args.stochastic)
1
2
3
4
5
6
7

使用:

python hello.py --stochastic
1

输出为True

使用:

python hello.py --no-stochastic
1

输出为False

非常方便

# 在-h信息中添加额外的信息?

import argparse
import textwrap
# 在这里添加了详细的使用说明
parser = argparse.ArgumentParser(
        prog='ProgramName',
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog=textwrap.dedent('''\
        Example:
         python 05_gail.py --episodes 36000 --mpath \'./model36000/\' --lpath \'./trainingLog36000/\'
        '''))
    
parser.add_argument('-E', '--episodes', nargs='?', const=24000, type=int, default=24000, \
                help='The maximum number of episode.')
parser.add_argument('-M', '--mpath', help='Path to save model.', default='./model/')
parser.add_argument('-L', '--lpath', help='Path to save log.', default='./trainingLog/')
args = parser.parse_args()
print(args.mpath, args.lpath,args.episodes)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

在运行命令时加入命令行参数-h就可以看到:

usage: ProgramName [-h] [-E [EPISODES]] [-M MPATH] [-L LPATH]

optional arguments:
  -h, --help            show this help message and exit
  -E [EPISODES], --episodes [EPISODES]
                        The maximum number of episode.
  -M MPATH, --mpath MPATH
                        Path to save model.
  -L LPATH, --lpath LPATH
                        Path to save log.

Example:
 python 05_gail.py --episodes 36000 --mpath './model36000/' --lpath './trainingLog36000/'

1
2
3
4
5
6
7
8
9
10
11
12
13
14

参考:Stackoverflow

# Python首行注释是什么?

#!/usr/bin/env python3
# -*- coding: utf-8 -*- 
1
2

传说第一句会帮你自动找到对应的Python解释器,特别是你有多个Python解释器(系统自带的Python或者Anaconda里的Python);

第二句在有中文或者其他特殊字符的时候可以避免报错, 很有用。

# Python可变参数(Variable Argument)怎么使用?

转载自:团子的小窝: 理解 Python 中的 *args 和 **kwargs

Python是支持可变参数的,最简单的方法莫过于使用默认参数,例如:

def test_defargs(one, two = 2):
   print ('Required argument: ', one)
   print ('Optional argument: ', two)

test_defargs(1)
# result:
# Required argument: 1
# Optional argument: 2

test_defargs(1, 3)
# result:
# Required argument: 1
# Optional argument: 3
1
2
3
4
5
6
7
8
9
10
11
12
13

当然,本文章的主题并不是讲默认参数,而是另外一种达到可变参数 (Variable Argument) 的方法:使用*args和 **kwargs语法。其中,*args是可变的positional arguments列表,**kwargs是可变的keyword arguments列表。并且,*args必须位于**kwargs之前,因为positional arguments必须位于keyword arguments之前:

下面一个例子使用*args,同时包含一个必须的参数:

def test_args(first, *args):
    print('Required argument: ', first)
    for v in args:
        print('Optional argument: ',v)
test_args(1,2,3,4)

# result:
# Required argument: 1
# Optional argument:  2
# Optional argument:  3
# Optional argument:  4
1
2
3
4
5
6
7
8
9
10
11

下面一个例子使用kwargs, 同时包含一个必须的参数和args列表:

def test_kwargs(first, *args, **kwargs):
    print('Required argument: ', first)
    for v in args:
        print('Optional argument: ', v)
    for k, v in kwargs.items():
        print('Optional argument %s (*kwargs): %s' %(k,v))
test_kwargs(1,2,3,4,k1=5,k2=6)

# results:
# Required argument:  1
# Optional argument (*args):  2
# Optional argument (*args):  3
# Optional argument (*args):  4
# Optional argument k2 (*kwargs): 6
# Optional argument k1 (*kwargs): 5
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

*args和**kwargs语法不仅可以在函数定义中使用,同样可以在函数调用的时候使用。不同的是,如果说在函数定义的位置使用*args和**kwargs是一个将参数pack的过程,那么在函数调用的时候就是一个将参数unpack的过程了。下面使用一个例子来加深理解:

# 同样可以在函数调用使用
def test_args(first, second, third, fourth, fifth):
    print ('First argument: ', first)
    print ('Second argument: ', second)
    print ('Third argument: ', third)
    print ('Fourth argument: ', fourth)
    print ('Fifth argument: ', fifth)

args = [1,2,3,4,5]
test_args(*args)

# results:
# First argument:  1
# Second argument:  2
# Third argument:  3
# Fourth argument:  4
# Fifth argument:  5

# Use **kwargs
kwargs = {
    'first': 1,
    'second': 2,
    'third': 3,
    'fourth': 4,
    'fifth': 5
}
test_args(**kwargs)

# results:
# First argument:  1
# Second argument:  2
# Third argument:  3
# Fourth argument:  4
# Fifth argument:  5
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

使用*args和**kwargs可以非常方便的定义函数,同时可以加强扩展性,以便日后的代码维护。

# 如何使用Python里面的装饰器?

程序来自黄浩杰Python小技巧:装饰器(Decorator)。 感谢他的视频,讲得非常棒。

import time 

# # Part 2:
# def display_time(func):
#     def wrapper():
#         t1 = time.time()
#         func()
#         t2 = time.time()
#         print(t2 - t1)
#     return wrapper

# # Part 4:
# # 处理有返回值的情况
# # 在wrapper里面得到function的返回值
# def display_time(func):
#     def wrapper():
#         t1 = time.time()
#         result = func()
#         t2 = time.time()
#         print("Total time: {:.4} s".format(t2 - t1))
#         return result
#     return wrapper

# Part 5:
# 处理有函数有参数的情况
# 在wrapper里面加参数 *args:
# 表示可变参数原本有多少参数就传递多少个参数进去
def display_time(func):
    def wrapper(*args):
        t1 = time.time()
        result = func(*args)
        t2 = time.time()
        print("Total time: {:.4} s".format(t2 - t1))
        return result
    return wrapper

# Part 0:
def is_prime(num):
    if num < 2:
        return False
    elif num == 2:
        return True
    else:
        for i in range(2,num):
            if num % i == 0:
                return False
            return True

# # Part 1:
# # 有计时的部分,同时也有逻辑的部分
# # 可读性差,为了使得两个功能分离,我们就要用到装饰器
# def prime_nums():
#     t1 = time.time()
#     for i in range(2,10000):
#         if is_prime(i):
#             print(i)
#     t2 = time.time()
#     print(t2 - t1)

# # Part 3:
# # 1. 去掉原来计时的部分
# # 2. 然后使用@为函数prime_nums加上装饰器display_time
# # 这样运行函数prime_nums的时候其实就是运行的装饰器
# @display_time
# def prime_nums():
#     for i in range(2,10000):
#         if is_prime(i):
#             print(i)


# # Part 4:
# # 处理函数有返回值的情况
# @display_time
# def count_prime_nums():
#     count = 0 
#     for i in range(2,10000):
#         if is_prime(i):
#             count = count + 1
#     return count

# Part 5:
# 处理函数有参数的情况
@display_time
def count_prime_nums(maxnum):
    count = 0 
    for i in range(2,maxnum):
        if is_prime(i):
            count = count + 1
    return count

count = count_prime_nums(5000)
print(count)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

理解

装饰器就是一个更方便的函数。