注释

单行注释:

1
2
# !/usr/bin/python       linux系统指定脚本使用的解释器
# -*- coding=utf-8 -*- 编码方式

多行注释:

1
2
3
4
5
6
"""
多行注释
"""
'''
多行注释
'''

输入

input():从控制台获取输入的值,该值传递给变量时为字符串

1
2
3
4
>>> str = input('请输入一个字符串:')
请输入一个字符串:123
>>> str
'123'

内置类型

对象分类

数字、字符串、列表、字典、元组、文件、集合

数字分类

常见数字常量:整数(int),浮点数(float),2/8/16进制,复数,集合,小数与分数,布尔(bool)和常量

常用进制转换函数:hex()(转16进制)、bin()(转2进制)、oct()(转8进制)

数学工具

表达式操作符:+、-、*/、//、%、<<、>>、&、|、!等等

1
2
3
4
5
6
7
8
9
10
# 2的3次方
>>> 2 ** 3
8
>>> 10 / 3
3.3333333333333335
# 运算符//是运算结果向下取整一位
>>> 10 // 3
3
>>> -10 // 3
-4

逻辑操作符:and、or、not、xx if result else yy等等

1
2
3
4
5
6
7
8
9
10
11
>>> 1 and -1 
-1
>>> 1 and 99
99
>>> -1 or 0
-1
>>> 0 or 22
22
# xx if result else xx #如果result的值为真,则执行xx语句,否则执行yy语句
>>> 99 if 1 else 0
99

内建数学函数:pow(x, y)(求数字x的y次方结果),abs(x)(求x的绝对值)等等

工具模块:random、math等等

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#生成0到1的随机数
>>> import random
>>> random.random()

#生成指定范围的随机数
>>> import random
>>> random.randint(1, 1001)

#随机选择
>>> import random
>>> random.choice(['广州', '上海', '北京', '深圳'])

#随机生成ip地址 str()函数作用是将对象转化为字符串
>>> import random
>>> str(random.randint(1, 255)) + '.' + str(random.randint(1, 255)) + '.' + str(random.randint(1, 255)) + '.' + str(random.randint(1, 255))

字符串

属性

1、不可变类型

2、有序

3、可通过索引找到相应的值

简单使用

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
#单引号
>>> 'sp"am'
'sp"am'

#双引号
>>> "tre's't"
"tre's't"

#三引号(保持原有格式)
>>> '''test
test'''

#转义符
>>> "s\tp\na\0m"
"s\tp\na\0m"

#原始字符串
>>> r"C:\new\test.php"
'C:\\new\\test.php'

#字节字符串(以某种形式打开)
>>> b'test' #二进制字符串
b'test'

#判断子字符串是否在字符串中
>>> test = 'hellomyboy'
>>> 'hello' in test #True #判断在
True
>>> 'ff' not in test #True #判断不在
False

#拼接
>>> 'welcome' + 'my' + 'world'
'welcomemyworld'

#字符串乘法(重复序列)
>>> print('abcd' * 30)

#字符串切片(上限取不到)
>>> file = 'go.txt'
>>> file[-3:]
txt
>>> file[1:4]
o.t

常用方法:

replace()、find()、upper()、lower()、strip()、list()(由字符串产生列表)、join()

方法并不改变字符串本身

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
>>> s = 'hello, world'
>>> s.replace('world', 'Python')
'hello, Python'

>>> s.find("P") #返回要查找的字符串第一个字母索引
-1 #表示找不到

>>> s.upper() #全大写
'HELLO, WORLD'

>>> s2 = s1.lower() #全小写
'hello, world'

>>> test = '\n\twelcome to my world\n\r\t'
>>> test.strip() #剥除字符串所有转义字符(空白字符)
'welcome to my world'

>>> test.lstrip() #剥除字符串左边的所有转义字符
'welcome to my world\n\r\t'

>>> test.rstrip() #剥除字符串右边的所有转义字符
'\n\twelcome to my world'

>>> '!'.join('hello') #用感叹号所在位置的字符分割字符串
h!e!l!l!o

格式化:

传统:

‘…%s…%d…%f’ %(values, values, values)

%10d:占10个宽度,右对齐

%-10d:占10个宽度,左对齐

%010d:占10个宽度,右对齐,数据前面不够补0

%5.2f:占5个宽度,保留小数点后两位

%05.2f:占5个宽度,保留小数点后两位,数据前面不够补0

1
2
>>> 'There are %d %s' %(2, 'dogs')
'There are 2 dogs'

现代:

‘…{}…’.format(values)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 此处0,1,2仅占位
>>> '{0}, {1}, {2}'.format('Guangzhou', 'Shanghai', 'Beijing')
'Guangzhou, Shanghai, Beijing'

# 索引赋值可不按format后括号内数据的排列顺序
>>> '{Guangzhou}, {Shanghai}, {Beijing}'.format(Beijing = 1, Guangzhou = 22, Shanghai = 11)
'22, 11, 1'

>>> '{0:10d}, {1:010.3f}'.format(12, 5.123)
' 12, 000005.123'

# >表示右对齐,<表示左对齐
>>> import sys
>>> '{0.platform:>10}={1[kind]:<10}'.format(sys, dict(kind = 'laptop'))
' win32=laptop '

正则表达式

转义符

表达式 可匹配
\r,\n 代表回车和换行符
\t 制表符
\ \本身
^ ^本身
. .本身
$ $本身

多种字符

表达式 可匹配
\d 任意数字,0-9中任意一个
\w 任意一个字母或者数字或者下划线,a-z、A-Z、0-9、_中任意一个
\s 空格、制表符、换页符等空白字符中任意一个
. 可以匹配除开换行符(\n)的任意一个字符

自定义多种字符

表达式 可匹配
[a1!] 匹配a或者1或者!
[^ab] 匹配除开a,b的任意一个字符
[a-z] 匹配a到z之间的任意一个字符
[^a-e0-9] 匹配除开a到e之间的字符,0-9以外的任意一个字符

匹配次数

表达式 作用
{m} 表达式出现m次,m=x
{m,n} 表达式至少出现m次,至多出现n次,m<=x<=n
{m,} 表达式至少出现m次,m<=x
? 表达式出现0次或者1次
+ 表达式至少出现一次,x>=1
* 表达式出现0次或者出现任意次

代表抽象意义

表达式 作用
^ 与字符串开始的地方匹配
$ 与字符串结束的地方匹配
\b 匹配一个单词边界,即单词和空格之间的位置

表达式关系

表达式 作用
| 匹配左边或者右边
() 单独匹配括号的内容,可返回括号内容

正则匹配练习

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
>>> import re

>>> re.match('cmd\.exe', 'cmd.exe')
<re.Match object; span=(0, 7), match='cmd.exe'>

>>> ip = '123.11.122.222'
>>> re.match('\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}', ip)
<re.Match object; span=(0, 14), match='123.11.122.222'>

>>> test = '123 abc ffg\n 1211'
>>> re.match('\d{3}\s+\w{3}\s+\w{3}\s+\d{4}', test)
<re.Match object; span=(0, 28), match='123 abc ffg\n 1211'>

# .*基本全部匹配
>>> test = 'adfdgsfdghdasdsa'
>>> re.match('.*', test)

>>> re.match('\w{7}', 'abc1ddd')
<re.Match object; span=(0, 7), match='abc1ddd'>
>>> re.match('[a-z]{3}\d[a-g]{3}', 'abc1ddd')
<re.Match object; span=(0, 7), match='abc1ddd'>

>>> test = '00-50-56-C0-00-13'
>>> re.match('[0-9a-fA-F]{2}-[0-9a-fA-F]{2}-[0-9a-fA-F]{2}-[0-9a-fA-F]{2}-[0-9a-fA-F]{2}-[0-9a-fA-F]{2}', test)
>>> re.match('\w{2}-\w{2}-\w{2}-\w{2}-\w{2}-\w{2}', test)
<re.Match object; span=(0, 17), match='00-50-56-C0-00-13'>

>>> re.match('abc[^a-z]bbb', 'abc1bbb')
<re.Match object; span=(0, 7), match='abc1bbb'>

>>> re.match('^hello', 'helloworld')
<re.Match object; span=(0, 5), match='hello'>

>>> re.match('$world', 'helloworld')
>>> re.match('.*hello$', 'helloworldhello')
<re.Match object; span=(0, 15), match='helloworldhello'>

>>> re.match('ba(na)?', 'bana')
<re.Match object; span=(0, 4), match='bana'>
>>> re.match('ba(na)?', 'banana')
<re.Match object; span=(0, 4), match='bana'>

>>> re.split('---', 'aaa---bbb---ccc') #分割
['aaa', 'bbb', 'ccc']
>>> re.split('---|===', 'aaa---bbb===ccc')
['aaa', 'bbb', 'ccc']

>>> re.sub('--', '...', 'aaa--bbb--ccc') #替换
'aaa...bbb...ccc'

# groups()方法将结果转化为元组
>>> str1 = 'China/Guangdong/Guangzhou'
>>> re.match('(.*)/(.*)/(.*)', str1).groups()
('China', 'Guangdong', 'Guangzhou')

>>> str2 = 'hello Python world'
>>> str2.split()
['hello', 'Python', 'world']

>>> re.match('hello\s+(\w+)\s+(\w+)\s*', str2).groups()
('Python', 'world')

正则匹配小案例

1
2
3
4
5
6
7
8
9
10
11
12
13
#RE匹配ip地址,并格式化打印结果
#!/usr/bin/python
# -*- coding=utf-8 -*-

import re

test = 'Port-channel1.189 192.168.189.254 YES CONFIG up up'

result = re.match('(\w.*\d)\s+(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})\s+YES\s+CONFIG\s+(\w+)\s+(\w+)\s*', test).groups()

print('%-10s : %s' %('接口', result[0]))
print('%-10s : %s' %('ip', result[1]))
print('%-10s : %s' %('状态', result[2]))

image.png

1
2
3
4
5
6
7
8
9
10
11
12
#!/usr/bin/python
# -*- coding=utf-8 -*-
python
import re

test = '166 54a2.74f7.0326 DYNAMIC Gil/0/11'

result = re.match('(\d+)\s+(\w.*\w+)\s+\w+\s+(\w+/\w+/\w+)\s*', test).groups()

print('%-10s : %s' %('VLAN ID', result[0]))
print('%-10s : %s' %('MAC地址', result[1]))
print('%-10s : %s' %('接口', result[2]))

image.png

Linux平台下脚本执行

1
2
#!/usr/bin/python           python解释器路径,可通过which python指令寻找
# -*- coding=utf-8 -*- 编码形式为utf-8

1.转化格式

windows平台下换行为\t\n,linux平台下换行为\n,格式不统一进行转换会报错

指令:dos2unix xxx.py

2.提升文件权限(增加可执行文件权限)

指令:chmod +x xxx.py

3.执行程序

指令:./ xxx.py

列表与字典

列表

属性

1.任意对象的有序集合

2.通过偏移获取

3.可变长度,异构以及任意嵌套

4.属于可变序列的分类

5.对象引用数组

基本操作:

方法汇总——append()、sort()、reverse()、index(x)、insert(i,x)、count(x)、remove(x)、pop(i)

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
L = [] #空列表
L = [12, 'abx', 1.21, {}] #支持任何类型
L = ['aa', 11, ['dev', 'cdr']] #支持任意嵌套
L = list('span') #可迭代对象转换为列表
L[i], L[i][j] #索引取值
L[i:j] #切片
len(L) #计算长度
L1 + L2 #支持连接,重复

#添加元素的方法append insert extend
name = ['aa', 'bb', 'cc', 'dd', 'ee']
>>> name.append('ff') #尾部追加
['aa', 'bb', 'cc', 'dd', 'ee', 'ff']
>>> name.insert(1, 'gg') #1表示位置
['aa', 'gg', 'bb', 'cc', 'dd', 'ee', 'ff']
>>> name.extend('zz') #将可迭代对象添加到name中
['aa', 'gg', 'bb', 'cc', 'dd', 'ee', 'ff', 'z', 'z']

# 删除元素 pop()、remove()、clear()
>>> name.pop() #删除末尾元素,返回值为末尾元素
'z'
>>> name
['aa', 'gg', 'bb', 'cc', 'dd', 'ee', 'ff', 'z']
>>> name.remove('aa') #删除指定元素
>>> name
['gg', 'bb', 'cc', 'dd', 'ee', 'ff', 'z']
>>> name.clear() #清空列表
>>> name
[]

#排序方法sort
>>> nums = [11, 44, 6, 456, 2]
>>> nums.sort()
>>> nums
[2, 6, 11, 44, 456]

#翻转方法reverse
>>> nums = [11, 44, 6, 456, 2]
>>> nums.reverse()
>>> nums
[2, 456, 6, 44, 11]

#删除列表中第一次出现的元素x remove
>>> nums = [11, 44, 6, 11, 456, 2]
>>> nums.remove(11)
>>> nums
[44, 6, 11, 456, 2]

字典

属性:

1、可变无序类型

2、任意对象的无序集合

3、通过键值获取(以键值对的形式存储,键值相同会被后者对应的值覆盖

4、可变长度,异构以及任意嵌套

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
#查找
>>> name = {'aa': 1, 'bb':2}
>>> name['aa']
1

#修改元素,如果key不存在,则会添加key、value
>>> name['aa'] = 22
>>> name
{'aa': 22, 'bb': 2}

#删除元素的方法pop、popitem、clear
>>> name.pop('aa') #删除指定key
>>> name
{'bb': 2}
>>> result = name.popitem() #删除末尾元素
>>> result
('bb', 2)
>>> name.clear() #清空字典

#合并字典update
>>> person1 = {'name': 'zhangsan', 'age':16}
>>> person2 = {'address': 'China', 'weight':'60'}
>>> person1.update(person2)
>>> person1
{'name': 'zhangsan', 'age': 16, 'address': 'China', 'weight': '60'}

#统计长度
>>> len(person1)
4

元组与文件

元组

属性:

1、不可变序列类型

2、任意对象的有序集合

3、通过偏移获取

4、固定长度,异构,任何嵌套

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
>>> name = (1, 234, "ada", [1, 2], {"aa": 1, "bb": 2})
>>> name
(1, 234, 'ada', [1, 2], {'aa': 1, 'bb': 2})

#元组排序: 转化为列表排序
>>> num = (1, 55, 22, 45, 33)
>>> num2 = list(num)
>>> num2.sort()
>>> num2
[1, 22, 33, 45, 55]
>>> num = tuple(num2)
>>> num
(1, 22, 33, 45, 55)

#元组解析
>>> T = (1, 2, 3, 4, 5)
>>> L = [x + 20 for x in T]
>>> L
[21, 22, 23, 24, 25]

#索引操作
>>> T = (1, 2, 3, 2, 4, 2)
>>> T.index(2) #查找元素索引
1
>>> T.index(2, 3) #偏移量2后面出现3的位置,列表也适用
>>> T.count(2) #记录2的个数
3

注意事项:

1、序列运算无效

2、对新索引赋值会添加项

3、键不一定总是字符串(任何不可变对象都可以)

4、元组顶层不可以修改,嵌套的元素可以修改

文件

打开文件:

rb 二进制形式读取文件
wb 二进制形式写入文件若文件存在,则覆盖;若不存在,则创建
r 读取文件
w 写入文件,若文件存在,则覆盖;若不存在,则创建
a 追加
1
str = open("D:/test.txt", "r")

读写文件:

1、文件迭代器是最好的读取行工具

2、内容是字符串,不是对象

3、Close是通常选项

4、文件是缓存的并且是可查找的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 读取整个文件
content = str.read()
print(content)

# 一行一行读取文件
content = str.readline()
print(content)

# 最优:文件迭代器
content = str.read()
for line in content:
print(line)

# 写入文件
myfile = open("D:/a.txt", "w")
myfile.write("Python")

实践案例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import os
import re

file_list = []

root = '/usr/lib/python3.8'
# 遍历路径
for dirpath, dirnames, filenames in os.walk(root):
for filepath in filenames:
file_list.append(os.path.join(dirpath, filepath))

file_output = []

for file in file_list:
flag = 0
file_open = open(file, 'rb')
for line in file_open:
if re.match(b'.*class.*', line):
flag = 1

if flag == 1:
file_output.append(line)

关闭文件:

1
str.close()

对象存储:

1
2
3
4
5
6
7
8
>>> import pickle
>>> alist = {'C': 1, 'C++': 2, 'Python': 3}
>>> pikle_file = open('pikle_test.txt', 'wb')
>>> pickle.dump(alist, pikle_file)
>>> pikle_file.close()
>>> pikle_file_1 = open('pikle_test.txt', 'rb')
>>> D1 = pickle.load(pikle_file_1)
>>> D1

赋值

属性:

1、赋值语句建立对象引用

2、变量名在首次赋值时会被创建

3、变量名在引用前必须先赋值

4、隐式赋值(例如:导入模块,函数和类)

基本操作:

1
2
3
4
5
6
7
8
>>> a = 12
>>> a, b = 1, 2
#迭代赋值
>>> [a, b] = [1, 2]
>>> a, b, c, d = 'spam'
>>> a, *b = 'spam'
>>> a = b = 1
>>> a += 12

打印

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
a = 11
print(a)

# 变量分隔
>>> a, b, c = 1, 2, 3
>>> print(a, b, c, sep="!")
1!2!3

# 变量结尾
a, b = 1, 2
print(a, end="!")
print(b)
1!2

# 打印内容写入文件
print(a, b, c, end='', file=open("data.txt", "w"))

IF语句

1
2
3
4
5
6
7
8
x = 'python'

if x == 'python':
print('x is python')
elif x == 'C++':
print('x is C++')
else:
print('x is Java')

循环语句

while循环:

一般格式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 循环正常退出会执行else语句,通过break退出不会执行else语句,一般不使用else
while xxx:
aaa
else:
bbb


a = 5
while a < 10:
print(a)
a += 1
else:
print("while loop")

# pass什么也不做,用于占位
whiel True:pass

for循环:

一般格式

1
2
3
4
# 循环正常退出会执行else语句,通过break退出不会执行else语句,一般不使用else
for xxx in xxx:
xxx
else:

函数

一般格式:

1
2
3
def func(arg1, arg2, arg3……, argN):
xxx
return value

作用域:

1、函数外定义的变量称为全局变量

2、函数内的局部变量不受全局变量影响

3、通常情况下,函数内使用全局变量只可读,不可修改

4、函数内修改全局变量需要使用global xxx

参数传递:

1、参数的传递是通过自动将对象赋值给本地变量名来实现的

2、函数内部的参数名的赋值不会影响调用者

3、改变函数的可变对象参数的值也许会对调用者有影响

4、不可变参数通过‘值’进行传递

5、可变对象的通过‘指针’进行传递

1
2
3
4
5
6
7
8
9
10
func(value)
func(name=value)
func(*iterable)
func(**dict)
def func(name)
def func(name=value)
def func(*name)
def func(**name)
def func(*other, name)
def func(*, name=value)

模块

属性:

1、代码重用

2、系统命名空间的划分

3、实现共享服务和数据

搜索路径:

1、当前程序主目录

2、PYTHONPATH目录

3、标准链接库目录

4、任何.pth文件的内容

导入模块:

1
2
3
4
5
# 直接导入模块
import re

# 导入函数,可能会遇到函数名相同冲突
from random import randint

重载模块:

当模块数据更新时,想要使用更新后的数据,需要重载模块

1
2
from imp import reload
reload(random.randint)

内置属性:

1、当py文件当作模块使用,___name__的值为模块文件名,不包含路径或者扩展名

2、当py文件自己使用时,__name__的值为”__main__“