使用模块

模块是为了用来下定义和重用的。
导入放在c:/python 下的hello.py 作为模块使用。模块导入只导入一次，第二次什么也不会发生，打破互相导入的死循环。如果一定要重新加载模块，使用importlib.reload()

>>> import sys
>>> sys.path.append('C:/python')
>>> import hello 
Hello, world!

查看系统查找的全部路径有什么，除了sys.path , 标准做法是将模块所在的目录包含在环境变量PYTHONPATH中。

>>> import sys, pprint 
>>> pprint.pprint(sys.path) 
['C:\\Python35\\Lib\\idlelib', 
 'C:\\Python35', 
 'C:\\Python35\\DLLs', 
 'C:\\Python35\\lib', 
 'C:\\Python35\\lib\\plat-win', 
 'C:\\Python35\\lib\\lib-tk', 
 'C:\\Python35\\lib\\site-packages']

包含测试代码的模块，应该将代码放入if 条件中

if __name__ == '__main__': test()

使用包

模块存储在扩展名为.py的文件中，而包则是一个目录。要被Python视为包，目录必须包含文件init.py。如果像普通模块一样导入包，文件init.py的内容就将是包的内容。

模块包含什么

dir

要查明模块包含哪些东西，可使用函数dir，它列出对象的所有属性（对于模块，它列出所有的函数、类、变量等）。

[i for i in dir(copy) if not i.startswith("_")]
['Error', 'copy', 'deepcopy', 'dispatch_table', 'error']

all

>>> copy.__all__ 
['Error', 'copy', 'deepcopy'] 

all 的设置是在模块copy 是定义的

__all__ =

文档字符串

除了# 注释，有另一种编写注释的方式，就是添加独立的字符串。在有些地方，如def语句后面（以及模块和类的开头，），添加这样的字符串很有用。放在函数开头的字符串称为文档字符串（docstring），将作为函数的一部分存储起来。下面的代码演示了如何给函数添加文档字符串：

def square(x): 
 'Calculates the square of the number x.' 
 return x * x 

可以像下面这样访问文档字符串：

>>> square.__doc__ 
'Calculates the square of the number x.'

收集参数

单星号 * （元组）
前面有星号的参数将被放在元组中。
因此星号意味着收集余下的位置参数。如果没有可供收集的参数，params将是一个空元组。

>>> print_params_2('Nothing:') 
Nothing: 
() 

与赋值时一样，带星号的参数也可放在其他位置（而不是最后），但不同的是，在这种情况下你需要做些额外的工作：使用名称来指定后续参数。单星号不会收集关键字参数。

>>> def in_the_middle(x, *y, z): 
... print(x, y, z) 
... 
>>> in_the_middle(1, 2, 3, 4, 5, z=7) 
1 (2, 3, 4, 5) 7

双星号 ** （字典）
要收集关键字参数，可使用两个星号。

>>> def print_params_3(**params): 
... print(params) 
... 
>>> print_params_3(x=1, y=2, z=3) 
{'z': 3, 'x': 1, 'y': 2} 

如你所见，这样得到的是一个字典而不是元组。可结合使用这些技术。

def print_params_4(x, y, z=3, *pospar, **keypar): 
 print(x, y, z) 
 print(pospar) 
 print(keypar) 

其效果与预期的相同。

>>> print_params_4(1

字符串（以及数和元组）是不可变的（immutable），这意味着你不能修改它们（即只能替换为新值）。因此这些类型作为参数没什么可说的,不会影响 外部原来的值。但如果参数为可变的数据结构（如列表）呢？

>>> def change(n): 
... n[0] = 'Mr. Gumby' 
>>> names = ['Mrs. Entity', 'Mrs. Thing'] 
>>> change(names) 
>>> names 
['Mr. Gumby', 'Mrs. Thing'] 

在这个示例中，修改了变量关联到的列表。下面再这样做一次，但这次不使用函数调用。

>>> names = ['Mrs. Entity', 'Mrs. Thing'] 
>>> n = names # 再次假装传递名字作为参数
>>> n[0] = 'Mr. Gumby' # 修改列表
>>> names 
['Mr. Gumby', 'Mrs. Thing']

将同一个列表赋给两个变量时，这两个变量将同时指向这个列表。就这么简单。要避免这样的结果，必须创建列表的副本。对序列执行切片操作时，返回的切片都是副本。因此，如果你创建覆盖整个列表的切片，得到的将是列表的副本。

>>> names = ['Mrs. Entity', 'Mrs. Thing'] 
>>> n = names[:] 
现在n和names包含两个相等但不同的列表。
>>> n is names 
False 
>>> n == names 
True 
现在如果（像在函数change中那样）修改n，将不会影响names。
>>> n[0] = 'Mr. Gumby' 
>>> n 
['Mr. Gumby', 'Mrs. Thing'] 
>>> names 
['Mrs. Entity', 'Mrs. Thing'] 
下面来尝试结合使用这种技巧和函数change。
>>> change(names[:]) 
>>> names 
['Mrs. Entity', 'Mrs. Thing'] 

注意到参数n包含的是副本，因此原始列表是安全的。

append

方法append用于将一个对象附加到列表末尾。

>>> lst = [1, 2, 3] 
>>> lst.append(4) 
>>> lst 
[1, 2, 3, 4]

append也就地修改列表。这意味着它不会返回修
改后的新列表，而是直接修改旧列表。

# l 指向letterGirls['a'] , 然后 l 后面附加一串‘cc’  , letterGirls['a']的值也被修改，两者指向同一个列表，即原件相同，关联同一个列表
>>> l = letterGirls.setdefault('a', [])
>>> l
['alice', 'alice', 'aly', 'aa', 'bb']
>>> l.append('cc')
>>> l
['alice', 'alice', 'aly', 'aa', 'bb', 'cc']
>>> letterGirls
{'a': ['alice', 'alice', 'aly', 'aa', 'bb', 'cc'], 'b': ['bernice', 'bernice'], 'c': ['clarice', 'clarice']}
# 同理，引用同一个列表，其删作一个元素，另一个也修改
>>> b = l
>>> b
['alice', 'alice', 'aly', 'aa', 'bb', 'cc']
>>> del(b[3])
>>> l
['alice', 'alice', 'aly', 'bb', 'cc']
>>> b
['alice', 'alice', 'aly', 'bb', 'cc']

setdefault

方法setdefault有点像get，因为它也获取与指定键相关联的值，但除此之外，setdefault
还在字典不包含指定的键时，在字典中添加指定的键-值对。

>>> d = {} 
>>> d.setdefault('name', 'N/A') 
'N/A' 
>>> d 
{'name': 'N/A'} 
>>> d['name'] = 'Gumby' 
>>> d.setdefault('name', 'N/A') 
'Gumby' 
>>> d 
{'name': 'Gumby'}
# 如你所

推导并不是语句，而是表达式。它们看起来很像循环，通过列表推导，可从既有列表创建出新列表，这是通过对列表元素调用函数、剔除不想要的函数等实现的。推导功能强大，但在很多情况下，使用普通循环和条件语句也可完成任务，且代码的可读性可能更高。使用类似于列表推导的表达式可创建出字典。

列表推导：

括号 []

单个for

>>> [x * x for x in range(10)] 
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81] 

多个for

>>> [(x, y) for x in range(3) for y in range(3)] 
[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)] 

for + if

>>> girls = ['alice', 'bernice', 'clarice'] 
>>> boys = ['chris', 'arnold', 'bob'] 
>>> [b+'+'+g for b in boys for g in girls if b[0] == g[0]] 
['chris+clarice', 'arnold+alice', 'bob+bernice']

字典推导：

花括号 { }

>>> squares = {i:"{} squared is {}".format(i, i**2) for i in range(10)} 
>>> squares[8] 
'8 squared is 64'

在列表推导中，for前面只有一个表达式，而在字典推导中，for前面有两个用冒号分隔的表
达式。这两个表达式分别为键及其对应的值。

生成器推导：

圆括号 ( )
生成器推导（也叫生成器表达式）。其工作原理与列表推导相同，但不是创建一个列表（即不立即执行循环），而是返回一个生成器，让你能够逐步执行计算。

sum(i ** 2 for i in range(10))

python 中随机数

模块random中一些重要的函数

函 数 描 述
random() 返回一个0~1（含）的随机实数
getrandbits(n) 以长整数方式返回n个随机的二进制位
uniform(a, b) 返回一个a~b（含）的随机实数
randrange([start], stop, [step]) 从range(start, stop, step)中随机地选择一个数
choice(seq) 从序列seq中随机地选择一个元素
shuffle(seq[, random]) 就地打乱序列seq
sample(seq, n) 从序列seq中随机地选择n个值不同的元素

这里使用sample的一个例子

from random import sample
print('MY RED  : {}'.format(sample(list(range(1,34,1)), 6)))
print('MY BLUE : {}'.format(sample(list(range(1,17,1)), 1)))

(venv) C:\Users\LTE-LCFeng\PycharmProjects\ssq\venv>python ssq.py
MY RED  : [9, 1, 24, 26, 3, 6]
MY BLUE : [6]

Shell 中随机数

shell的RANDOM函数

范围 0~32767

echo $RANDOM

取小范围内随机数，对随机结果取模N ， 可取到0~（N-）1 内的随机数
取1~ 6 的随机数，只需加1

echo $[$RANDOM%6+1]

一个范例

在1-33 中取6个不重复的随机数，在1-16中取1随机数

#!/bin/bash
RED_D=33
BLUE_D=16
RED_MAX=6
count=0
touch RED.txt
while [ $count -lt ${RED_MAX} ]
do
  flag=$(expr 6 - $count)
  while [ $flag -gt 0 ]
  do
    flag=$(expr $flag - 1)
    RED=$[$RANDOM%

相关命令：
执行并放置后台执行 ： command &
将后台程序拉回屏幕输出： fg
将当前屏幕执行程序再丢到后台执行：Ctrl Z

执行程序并丢到后台执行 &

[lcf@nut ~]$ acgui&
[1] 14087

把当前后台执行的程序拉回当前屏幕执行 fg

[lcf@nut ~]$ fg
acgui

把已经在当前屏幕执行中的程序丢到后台继续执行 Ctrl Z

[lcf@nut ~]$ fg
acgui
^Z
[1]+  Stopped                 acgui

Shell seq用法

seq --help

Usage: seq [OPTION]... LAST
  or:  seq [OPTION]... FIRST LAST
  or:  seq [OPTION]... FIRST INCREMENT LAST
Print numbers from FIRST to LAST, in steps of INCREMENT.
Mandatory arguments to long options are mandatory for short options too.
  -f, --format=FORMAT      use printf style floating-point FORMAT
  -s, --separator=STRING   use STRING to separate numbers (default: \n)
  -w, --equal-width        equalize width by padding with leading zeroes
      --help     display this help and exit
      --version  output version information and exit

注意事项

seq 选项[-s " "][-w] FIRST INCREMENT LAST
注意 选项紧跟seq, 位于序列数字FIRST INCREMENT LAST之前，FIRST INCREMENT LAST放在最后
比如

seq -s " " -w   2  100  1000

常用命令

• 生成一个1 到 10 的序列 ，不指定分隔符s时，默认是换行符。

root@gua-vm1:/vob# seq 10
1
2
3
4
5
6
7
8
9
10

• 生成一个1 到 10 的序列 ，指定分隔符为空格 ，在seq 后面加上选项 -s " "

root@gua-vm1:/vob# seq -s " " 10
1 2 3 4 5 6 7 8 9 10

• 生成一个3 到 10 的序列 ，只指定头尾时，默认递增量为1

r

打印全部列

awk '{print $0}'

打印指定列

awk '{print $2，$4}'

打印指定列并拼接字符串

awk '{print $1,"hhah",$2}'
awk '{print $1"hahah"$2}'

按指定分隔符取列

awk -F: '{ print $1 }' 

打印某一列及后面所有列的内容

awk '{out=""; for(i=2;i<=NF;i++){out=out" "$i}; print out}'

打印最后一列，最后一列的前一列，NF表示最后一列的列号

awk '{print $NF, $(NF-1)}'

打印指定一行，NR表示行号

awk  'NR==6 {print $0}'

打印第六行，以 ：分隔开的第一列

awk -F ":" 'NR==6 {print $1}'

打印第4行以后的行

git log --pretty=format:"%H-%h:%h" -n 15 |cat -n | awk 'NR>4 {print $0}'
     5  1f021028e22d92119fa5a0821273596e0c37be87-1f02102:1f02102
     6  f36b0ad5a376edf485979b357af4ac1df87cc443-f36b0ad:f36b0ad
     7  e3776955f8f3592051603d2299b93d3b55cbc52a-e377695:e377695
     8  94c50a1fd810d5c1e62535fac8f6db3c01c4c476-94c50a1:94c50a1
git log --pretty=format:"%H-%h:%h" -n 15 |cat -n | awk 'NR<4 {print $0}'
git log --pretty=format:"%H-%h:%h" -n 15 |cat -n | awk 'NR<=4 {print $0}'

条件用法
打印包含 Merge branch 的行 用/strings/

git log --pretty=format:"%

p2top3命令批量转化语法之后，还有一些 版本2和3之间用法的差异需要手动调整：

1. if
2. browser 抓取值
3. 下载链接