显示标签为“python”的博文。显示所有博文
显示标签为“python”的博文。显示所有博文

2020-04-13

Python-Version 


1. Python版本
 1.1 python --version
 1.2 Python 2 vs 3 comparison
 1.3 python 2 to 3 converter
2. Python 手册
 2.1 最新官方中文手册
 2.2 learn python
 2.3 Python 风格指南 - 内容目录
3. Python软件
 3.1 Python软件清单
 3.2 Python开发环境
 3.3 Python IDE对比
4. see also

1. Python版本

1.1 python --version

$ python --version
Python 3.8.2
https://en.wikipedia.org/wiki/History_of_Python#Table_of_versions

1.2 Python 2 vs 3 comparison

ComparisonPython 3Python 2
最早发行版本V3.0 2008V2.0 2000
最新发行版V3.8.2 2020V2.7 2010, 2020已停止更新
printprint (“hello”)print “hello”
整数除法 Division得到浮点数总是整数
Unicode 支持字符串默认Unicode要存储Unicode字符串，需使用”u”定义
语法 Syntax语法简单易懂语法相对难以理解
排序比较规则简化了排序比较规则非常复杂
迭代 Iteration新的range()函数来执行迭代xrange()用于迭代
例外情况应将其括在括号中包含在符号中
变量泄漏变量的值永远不变在for循环中使用全局变量时，其值会更改。
兼容 Compatibility将python 2移植到python 3并不难，不过不太可靠Python版本3与Python 2向后不兼容。
库 Library越来越多...很多已经不再更新，淘汰中...
不等运算符!=!= 和 <>
True, FalseTrue, False 变为2个关键字。
不允许重新赋值。修正了版本2的缺陷		True, False是2个全局变量，数值对应0,1;
变量可以指向其他对象: True = False
nonlocal新增关键字 nonlcoal，使得非局部变量成为可能。

ComparisonPython 3Python 2备注
编码>>> import sys
>>> sys.getdefaultencoding()
'utf-8'
# 默认使用 utf-8, 所以如下是合法的
>>> 中国 = 'china'
>>>print(中国)
china		>>> import sys
>>> sys.getdefaultencoding()
'ascii'
# 默认ascii, 代码顶部包含 # coding=utf-8
>>> str = u"中国"
>>> str
u'\u4e2d\u56fd'		>>> import sys
>>> sys.getdefaultencoding()
'ascii'
>>> reload(sys)
<module 'sys' (built-in)>
>>> sys.setdefaultencoding("utf-8")
>>> sys.getdefaultencoding()
'utf-8'
字符串str, 字符串；byte, 字节序列。
任何需要写入文本或者网络传输的数据都只接收字节序列，这就从源头上阻止了编码错误的问题。		unicode, 文本字符串；srt, 字节序列。
不过两者并没有明显的界限		=转换= ; =作用=
=字节=bytestrencode ; 存储, 传输
=字符=strunicodedecode ; 展示
reference:
https://www.guru99.com/python-2-vs-python-3.html#7

Python2.x与3​​.x版本区别:
https://www.runoob.com/python/python-2x-3x.html
Python的3​​.0版本，常被称为Python 3000，或简称Py3k。相对于Python的早期版本，这是一个较大的升级。为了不带入过多的累赘，Python 3.0在设计的时候没有考虑向下相容。

Python 2 和 Python 3 有哪些主要区别？
https://www.zhihu.com/question/19698598

1.3 python 2 to 3 converter

2to3 - Automated Python 2 to 3 code translation
https://docs.python.org/2/library/2to3.html

2to3 - 自动将 Python 2 代码转为 Python 3 代码
https://docs.python.org/zh-cn/3/library/2to3.html

https://www.pythonconverter.com/

2. Python 手册

2.1 最新官方中文手册

https://docs.python.org/zh-cn/3/tutorial/classes.html v3.8.2 (2020)

历史版本:
https://www.runoob.com/python3/python3-tutorial.html v3.3.2 (2013)
https://www.runoob.com/manual/pythontutorial3/docs/html/ v3.6.3 (2017)
https://www.runoob.com/python/python-tutorial.html v2.7 (2010)

2.2 learn python

https://www.learnpython.org/
https://www.techbeamers.com/python-tutorial-step-by-step/

2.3 Python 风格指南 - 内容目录

https://zh-google-styleguide.readthedocs.io/en/latest/google-python-styleguide/contents/
https://github.com/zh-google-styleguide/zh-google-styleguide/tree/master/google-python-styleguide
https://github.com/google/styleguide
https://google.github.io/styleguide/pyguide.html

3. Python软件

3.1 Python软件清单

https://en.wikipedia.org/wiki/List_of_Python_software

3.2 Python开发环境

https://en.wikipedia.org/wiki/Python_(programming_language)#Development_environments
https://zh.wikipedia.org/wiki/Python#开发环境

3.3 Python IDE对比

https://en.wikipedia.org/wiki/Comparison_of_integrated_development_environments#Python
IDE 跨平台Written in小部件工具包LicensePython2x支持Python3x支持DebuggerGUI生成器集成工具链探查器代码覆盖率自动完成静态程序分析基于GUI的设计类浏览器代码重构版本控制系统支持Web框架支持
IDLEPythonTkinterPSFLYesYesYesYesUnknownNoNoYesNoYesYesUnknownNoNo
ericPythonPyQtGPLv3 "or later"YesYesYesYes: QtUnknownYesYesYesPylint viaYesYesYesGit, Mercurial, SVNDjango plug-in
PyCharmJavaSwingApache License 2.0YesYesYesUnknownYesYes .Yes .YesYes .YesYesYesYesYes
PyDev / LiClipseUnknownSWTEPLYesYesYesUnknownUnknownUnknownUnknownYesYesUnknownYesYesYesUnknown
Visual Studio CodeJavaScriptHTMLMIT LicenseYesYesYesNoUnknownYesUnknownYesUnknownUnknownUnknownUnknownYesYes
SpyderPythonPyQt, PySideMIT LicenseYes 2.7YesYesNoYesYesNoYesYesUnknownBetaPlannedPartialNo
ThonnyPythonTkinterMIT LicenseNoYesYesNoNoNoNoYesYesUnknownYesNoNoFlask
WingPythonQt5 with PyQtProprietaryYesYesYes .NoYesNoNoYesYesYesYesYesYesYes
KDevelopC, C++QtGPLUnknownYesYesUnknownUnknownUnknownUnknownYesUnknownUnknownYesYesGit, Mercurial, SVN
Bazaar, CVS		Unknown
GeanyCGTK+GPLUnknownYesNoUnknownUnknownUnknownUnknownYesUnknownUnknownUnknownUnknownUnknownUnknown

4. see also

https://wiki.archlinux.org/index.php/Python
https://wiki.gentoo.org/wiki/Python
https://wiki.postgresql.org/wiki/Python

时间： 没有评论:
标签：

2020-04-09

python-class01

[TOC]

# 1 类与对象概念
- 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
- 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
- 数据成员：类变量或者实例变量, 用于处理类及其实例对象的相关的数据。
- 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
- 局部变量：定义在方法中的变量，只作用于当前实例的类。
- 实例变量：在类的声明中，属性是用变量来表示的。这种变量就称为实例变量，是在类声明的内部但是在类的其他成员方法之外声明的。
- 继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
- 实例化：创建一个类的实例，类的具体对象。
- 方法：类中定义的函数。
- 对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

基本语法
# 2  class
https://docs.python.org/zh-cn/3/tutorial/classes.html
https://www.runoob.com/python/python-object.html

```
#!/usr/bin/python
# -*- coding: UTF-8 -*-

class MyClass:    # [1. 定义类]，大写字母开头 __name__
    '描述文本'     # 描述文本， __doc__
    i = 123       # 定义类的变量，小写字母开头
    myCount = 0
    def __init__(self, name, page):
        self.name = name
        self.page = page
        MyClass.myCount += 1
    def displayCount(self):
        print ("Total myCount: ", MyClass.myCount)
    def displayName(self):
        print ("name: ", self.name, ", page: ", self.page)
    def f(self):   # 定义类的方法，小写字母开头
        return ('hi py!')
    def prt(self):
        print (self)
        print (self.__class__)

print ("-----内置类属性-----------")    # [2. 内置类属性]
print ("MyClass.__doc__: ", MyClass.__doc__)
print ("MyClass.__name__: ", MyClass.__name__)        # 实例没有这个属性
print ("MyClass.__module__: ", MyClass.__module__)
print ("MyClass.__bases__: ", MyClass.__bases__)      # 实例没有这个属性
print ("MyClass.__dict__: ", MyClass.__dict__)
print ("MyClass.__class__: ", MyClass.__class__)
print ("--------分-割-线--------\n")

x1 = MyClass("python",100)      # [3. 创建类的实例对象]
print ("访问属性:", x1.i)        # [4. 访问属性]，打印实例x1的属性
print ("访问方法:", x1.f())      # 打印实例x1的f方法
print ("total myCount %d" % MyClass.myCount)
print ("--------分-割-线--------\n")

print ('==== x1.prt begin====')
x1.prt()
print ('==== x1.prt end====')
print ("--------分-割-线--------\n")

x1.displayCount()
x1.displayName()
print ("--------分-割-线--------\n")

print ("----内置属性----")  # [5. 内置属性]
print (x1.__doc__)
print (x1.__module__)   # __main__
print (x1.__dict__)     # {}
print (x1.__class__)     # <class '__main__.MyClass'>
print ("--------分-割-线--------\n")

x2 = x1      # [6. ]
print ('x2 = x1')
print ('x1.displayCount():')
x1.displayCount()    # myCound = 1;
print ('x2.displayCount():')
x2.displayCount()    # myCound = 1;
print ("MyClass.myCount %d" % MyClass.myCount)    # myCound = 1;
print ("--------分-割-线--------\n")

x3 = MyClass("python2",200)      # [3. 创建类的实例对象]
print ('x3 = MyClass("python2",200)')
print ('x1.displayCount():')
x1.displayCount()    # myCound = 2;
print ('x3.displayCount():')
x3.displayCount()    # myCound = 2;
print ("MyClass.myCount %d" % MyClass.myCount)    # myCound = 2;
print ("--------分-割-线--------\n")

print (id(x1), id(x2), id(x3))    # 打印对象的id
del x1      # [7. 销毁实例]，回收资源
del x2
del x3
print ('x1,x2,x3已销毁')
print ("销毁后，继续使用实例x1，就会报错: NameError: name 'x1' is not defined")
```
# 3 执行结果
```
> python py01.py
-----内置类属性-----------
MyClass.__doc__:  描述文本
MyClass.__name__:  MyClass
MyClass.__module__:  __main__
MyClass.__bases__:  (<class 'object'>,)
MyClass.__dict__:  {'__module__': '__main__', '__doc__': '描述文本', 'i': 123, 'myCount': 0, '__init__': <function MyClass.__init__ at 0x7f499f92df70>, 'displayCount': <function MyClass.displayCount at 0x7f499f95f040>, 'displayName': <function MyClass.displayName at 0x7f499f95f0d0>, 'f': <function MyClass.f at 0x7f499f95f160>, 'prt': <function MyClass.prt at 0x7f499f95f1f0>, '__dict__': <attribute '__dict__' of 'MyClass' objects>, '__weakref__': <attribute '__weakref__' of 'MyClass' objects>}
MyClass.__class__:  <class 'type'>
--------分-割-线--------

访问属性: 123
访问方法: hi py!
total myCount 1
--------分-割-线--------

==== x1.prt begin====
<__main__.MyClass object at 0x7f499f9a3490>
<class '__main__.MyClass'>
==== x1.prt end====
--------分-割-线--------

Total myCount:  1
name:  python , page:  100
--------分-割-线--------

----内置属性----
描述文本
__main__
{'name': 'python', 'page': 100}
<class '__main__.MyClass'>
--------分-割-线--------

x2 = x1
x1.displayCount():
Total myCount:  1
x2.displayCount():
Total myCount:  1
MyClass.myCount 1
--------分-割-线--------

x3 = MyClass("python2",200)
x1.displayCount():
Total myCount:  2
x3.displayCount():
Total myCount:  2
MyClass.myCount 2
--------分-割-线--------

139954187023504 139954187023504 139954187023744
x1,x2,x3已销毁
销毁后，继续使用实例x1，就会报错: NameError: name 'x1' is not defined
```

时间： 没有评论:
标签：

2020-04-08

python-note-001

[TOC]
1. 输入和输出
 1.1 print()
 1.2 input()
2. 变量和赋值
 2.1 变量的命名规范
 2.2 查看python的关键字
3. 条件判断
4. 常见的数据类型
 4.1 浮点数的运算误差
5. 数据的操作
 5.1 字符串的拼接
 5.2 四则运算
 5.3 数据转换
 5.4 type(),查询数据类型
 5.5 list列表语法
 5.6 dict字典语法
 5.7 bool()
6. 循环
 6.1 for循环
 6.2 while循环
 6.3 循环进阶
 6.4 补充: Python风格规范


1. 输入和输出

1.1 print()

打印括号里的内容
 - 无引号，打印数字，计算机阅读并理解括号里的内容，打印结果（数字间若有计算符号，会输出计算结果）；`` print(1+1) ``
 - 单/双引号，打印字符串，计算机不管引号中的内容（原样输出）；
 ``print("Let's go")`` ``print('Let\'s go') ``
 - 三引号，打印段落（原样输出）；
同html的``<pre>多行文本</pre>``标签

**单/双引号里适当使用 \n 换行，可实现与三引号相同效果；**

 转义字符列表
 | 转义字符 | 意义 |
 |

1.2 input()

收集从键盘输入的信息:
```
  name = input('请输入你的 ID: ')
  print(str(input('pls input\n')))
```
 **input()函数的输入值永远会被【强制性】地转换为【字符串】类型。(Python3固定规则)**

2. 变量和赋值

```
  name='xxx'
  print(name)
  xxx
```
 - =  **是赋值符号，将右边的内容赋值给左边的变量；**
 - == **是比较运算符号，表示两边相等；**

2.1 变量的命名规范

1. 只能是一个词；
2. 只能包含字母，数字和下划线；
3. 不能以数字开头；
4. 尽量描述包含的数据内容；
5. 不要使用Python函数名或关键字；
 - number = 34
 - name = 'forchange'
 - list_class = ['基础语法课程','爬虫分析初阶','爬虫分析进阶','自动化办公']
_以上number，name，list_class都是是变量名_

2.2 查看python的关键字

```
 import keyword
 keyword.kwlist
  ['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
```
False, None, True, and, or, not, def, del, import,
if, elif, else, for, while, break, continue, return, pass, try, except,
as, in, is, from, with,
assert, async, await, class, finally, global, lambda, nonlocal, raise, yield

判断是否为关键字:
```
  keyword.iskeyword('false')
  False
  keyword.iskeyword('False')
  True
```

3. 条件判断

 - if [条件0] : (缩进的内容)  \\ 单向判断
 - if [条件0] : (缩进的内容) else: (缩进的内容)  \\ 双向判断
 - if [条件0] : (缩进的内容) elif [条件1] : (缩进的内容) else: (缩进的内容)  \\ 多向判断
对于Python而言，冒号和缩进是一种语法。它会帮助Python区分代码之间的层次，理解条件执行的逻辑及先后顺序。
【注：缩进是四个空格或一个Tab键】
**IndentationError: expected an indented block(缩进错误：期望一个缩进块)**

if嵌套，就是在上面任何一个(缩进的内容)中添加一个if结构

4. 常见的数据类型

 - srt string字符串, 用引号括起来的文本;
 - int integer整数, 不带小数点的数字;
 - float 浮点数, 带小数点的数字，运算结果存在误差;
 - bool 布尔值, True or False;
 - dice dictionary字典, 使用键值对(key-value)作为存储方式. 标识是大括号{};
 - list 列表, 有序的集合，可以随时添加或删除其中的元素. 标识是中括号[];
 - tuple 元组, 类似列表的数据类型，但是不能被修改。

4.1 浮点数的运算误差

```
print(0.55+0.3)
0.8500000000000001
```
为什么不是【0.85】，而尾巴多了一个【1】呢？这是因为，Python计算浮点数时，会先把0.55和0.3转化成二进制数. **[注：二进制数由0和1表示，逢二进一]**，如下:

进制转换:
```
0.55(十进制) = 0.1000110011001100110011001100110011001100110011001101(二进制)
0.3 (十进制) = 0.0100110011001100110011001100110011001100110011001101(二进制)
```
而在这个转化过程中存在误差，这样，就造成了我们与程序计算结果的差异。


5. 数据的操作

5.1 字符串的拼接

 - '+' print(hero+action+organization+identity+ID) //字符串拼接, 不是字符串需要转换为字符串
 - '%' print ('print%dnam%s'%(number,name)) ///不同类型的拼接

5.2 四则运算

 - +
 - -
 - *
 - /
 - % 取模-返回除法的余数；5%2，返回1
 - // 取整除-返回商的整数部分；5//2, 返回2
 - ** 幂-返回x的y次幂；2**3, 2的3次方

**与平时运算优先级一样：从左到右顺着来，括号里的优先算，乘除排在加减前。**

5.3 数据转换

 - str() 强制转换为字符串
 - int() 将整数形式的字符串转换为整数，(文本和浮点数不能转换为整数)
   - print(int(3.3)) 浮点数直接抹零取整数
 - float() 将整数和数字形式的字符串转换为浮点数，(文字类字符串无法转转)
 - list() 将数据转换为列表类型
```
>>> name = 'python'
>>> print(list(name))
['p', 'y', 't', 'h', 'o', 'n']
```
 - len() 返回数据长度
 ```
>>> namelist=list(name)
>>> list2= ['py','th','on']
>>> len(name)
6
>>> len(namelist)
6
>>> len(list2)
3
```

5.4 type(),查询数据类型

```
  print(type(who))
  <class 'str'>
```

5.5 list列表语法

- 偏移量: 列表元素的位置编号, 从0开始
- 对列表元素的处理: 增, 删, 改, 查(提取)
  - 提取: list[0] 取出位置0的元素; list[a:b] 取出位置a到b, 但不包括b的所有元素(a<=X小于b); list[:]全部;
  - 修改: list[0]='tree0'
  - 增加: list.append('tree3') 添加到列表末尾，注意append()函数后面是小括号,不是方括号
  - 删除: del list[0]
- 对列表的处理: 增, 删, 改, 查(提取)
  - 提取: list[1:2] 列表的切片(子列表, 列表片段)，一次提取多个元素
  - 删除: del list[1:2] 删除切片(子列表, 列表片段)，一次删除多个元素
  - 增加(合并): list = list1 + list2 列表的合并
  - 修改(赋值): list = ['0','1','2']; list[:] = ['xx'] 对列表赋值
- 嵌套列表的提取
```
>>> list = [['0','0a'],['1','1b'],['2','2c']]
>>> print(list[0][1])
  0a
```

5.6 dict字典语法

group={'k1':'v1','k2':'v2','k3':'k3'}
- 增加: group['k4']=v4 ;
- 删除: del group['k4'] ;
- 修改: group['k1']=v11 ;
- 提取: group['k1'] 取出v1 ; 列表使用偏移量来提取，字典使用键来提取
- dict.deys() 提取字典中所有键
  -  group.keys() 元组的形式
  -  list(group.keys()) 将元组转换为列表
- dict.valus() 提取字典中所有的值
  -  group.values()
- dict.items() 提取字典中所有键值对
  -  group.items()

5.7 bool()

检查数值的真假
```
>>> print(bool(1))
  True
```
值本身作为条件

| Type   | 假值  | 其他都是真值     |
| ------ | ----- | ---------------- |
| bool   | False | True             |
| number | 0     | 非0数值(int, fl) |
| srt    | '’    | 非空字符串       |
| list   | []    | 非空列表         |
| dict   | {}    | 非空字典         |
|        | None  |                  |

比较运算符产生布尔值

| 运算符 | 释义     |
| ------ | -------- |
| '==    | 等于     |
| !=     | 不等于   |
| >      | 大于     |
| <      | 小于     |
| >=     | 大于等于 |
| <=     | 小于等于 |

**运算符之间不用空格，不可以写成= =、> =**

成员运算符产生布尔值

| 运算符 | 释义   |
| ------ | ------ |
| in     | 属于   |
| not in | 不属于 |

逻辑运算符产生布尔值

| 运算符 | 释义 |
| ------ | ---- |
| and    | 与   |
| or     | 或   |
| not    | 非   |

6. 循环

6.1 for循环

for 条件 : (缩进的内容)

 - 遍历字符串
 ```
# py01.py文件内容:
for i in 'code':
    print(i)
# bash下执行:
> python py01.py
c
o
d
e
```

- 遍历列表
```
# py01.py文件内容:
for i in ['code','py']:
    print(i)
# bash下执行:
> python py01.py
code
py
```
- 遍历字典的键
```
# py01.py文件内容:
list = {1:'a',2:'b',3:'c'}
for i in list:
    print(i)
# bash下执行:
> python py01.py
1
2
3
```

- 遍历字典的值
```
# py01.py文件内容:
list = {1:'a',2:'b',3:'c'}
for i in list.values():
    print(i)
# bash下执行:
> python py01.py
a
b
c
```

- 遍历字典的键值对
```
# py01.py文件内容:
list = {1:'a',2:'b',3:'c'}
for k, v in list.items():
    print(k)
    print(v)
# bash下执行:
> python py01.py
1
a
2
b
3
c
```

### range()函数
range()有最基本的三种用法：range(a)， range(a,b)，range(a,b,c)。
* a：计数从a开始。不填时，从0开始；b：计数到b结束，但不包括b；c：计数的间隔，不填时默认为1。
```
range(5)
# 计数依次为0，1，2，3，4
range(1,5)
# 计数依次为1，2，3，4
range(2,8,2)
# 计数依次为2，4，6
```

### for…in range()
处理指定次数的循环
```
for i in range(3):
    print('第%d行' %i)
```

6.2 while循环

只要条件为真，便会一直循环
```
count = 3
while count > 1:
    print('happy coding')
    count = count -1
happy coding
happy coding
```
while循环和for循环的区别:
- for擅长处理固定次，自动遍历各序列
- while处理不定次数的循环，条件为False便停止

6.3 循环进阶

- continue, 跳过当前循环的剩余语句, 直接开始下一轮循环
- else, 无论是否进入循环, 最后都会执行esle语句, 除非执行break语句跳出循环
```
while True:
    print('happy coding')
    break
```
循环嵌套
```
>for i in ['qw','ert']:    #首先遍历列表元素
...    for t in i:         #然后遍历元素(字符串)
...        print(t)
```

6.4 补充: Python风格规范

- break, 结束循环
Docs » Python 风格指南 - 内容目录 » Python风格规范

https://zh-google-styleguide.readthedocs.io/en/latest/google-python-styleguide/python_style_rules/

时间： 没有评论:
标签：

2020-04-06

Python

Python 基础语法
时间： 没有评论:
标签：
订阅： 博文 (Atom)

Sound

导航 (返回顶部) 1. Sound 1.1 声-音 1.2 声波的性质及特性 2. 声音频率 2.1 听力范围 2.2 VF-语音频率 2.3 人声基本频率 2.4 8度音阶表 2.5 综合表 3. 声波 3.1 Compression and she...

  • aide
    导航 (返回顶部) 1. aide(AUR) 1.1 Source & Homepage 1.2 About AIDE 1.3 Features 特征 2. Use AIDE(aur) on Arch 3. 几种主机/文件完整性监视程序的比较(2006...
  • Wireshark-Tools
    导航 (返回顶部) 1. Internal 2. Scripts 3. Wrappers封装器 4. External Links 4.1 Dedicated capture tools 专用捕获工具 4.2 Monitoring/tracing tools 监...
  • linux-clamav
    导航 (返回顶部) 1. clamav 1.1 安装-更新-启用-测试 1.2 扫描 1.3 clamscan --help 2. Rkhunter 2.1 安装-更新 2.2 系统检查-验证配置文件 2.3 配置文件,日志文件 2.4 rkhunter...