Python Basic Knowledge

1
2
3
4
5
6

res = "1101"
## 使用 rjust 在 res 的前面补零直到其长度是 8 的倍数
## ((len(res) + 7) // 8) * 8: 得到下一个8的倍数
required_length = ((len(res) + 7) // 8) * 8
res = res.rjust(required_length, '0')
print(res)  ## 输出: 00001101

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

字符串前加u——表示unicode字符串
	可能是因为这段字符串中含有中文
字符串前加r——表示非转义的原始字符串
	去掉反斜杠的转义机制
字符串前加b——表示这是一个bytes类型的对象
	python2默认字符编码是ASCII
	python3默认的字符编码是Unicode
	在python3中bytes和str的互相转换方式是：
		str.encode('utf-8')
		bytes.decode('utf-8')
字符串前加f——表示在字符串内支持大括号包裹的Python表达式

1
2
3
4
5

name = "Li"
age = 16
## print("Hello " + name + " you are " + str(age) + " years old")
print("Hello %s ,you are %d years old" % (name, age))
print('%.3f' % 3.14159)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

your_name = input("please input your name:\n")
print(f"Hello,{your_name}")
print(f"Hello,{your_name}")
print("Hello", your_name)
print("Hello" + your_name)
'''
Hello,Tom
Hello,Tom
Hello Tom
HelloTom
'''

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

b = 1
a = 1.05555
## 第一种方式
print(f'b 的值为:{b}')
## float 类型输出
print(f'a 的值为:{a:f}')
## float 保留两位小数 五舍六入
print(f'a 的值为:{a:.4f}')
## 第二种方式
print('a 的值为:'+str(a))
## 第三种方式
print('a 的值为:{}'.format(a))

1
2
3

def add_lambda(a, b=1): return a+b
print(add_lambda(10, 20))
print(add_lambda(10))

1
2
3
4

#三项表达式
get_odd_even = lambda x:'even' if x%2==0 else 'odd'
print(get_odd_even(8))
print(get_odd_even(9))

1
2
3
4

#无参数表达式
import random
ran_lambda = lambda:random.random()
print(ran_lambda)

1
2
3

#map函数，将列表中的元素作为参数传入指定函数
mobj = map(lambda x:x**2,[1,2,3,4])
print(list(mobj))

1
2

for i, value in enumerate(some_list):
    print(f"At index {i}, the value is {value}")

1

open(file, mode=‘r’, buffering=None, encoding=None, errors=None, newline=None, closefd=True)

1
2

t：以文本格式打开文件（默认）。一般用于文本文件，如：txt。
b：以二进制格式打开文件。一般用于非文本文件，如：图片。

1
2
3
4

r：以只读方式打开文件（默认模式）。文件指针定位在文件头的位置。如果文件不存在会报错。
w：以只写方式打开文件。如果文件存在，则打开文件，清空文件内容，从文件头开始编辑；如果文件不存在，则创建新文件，打开编辑。
a：以追加方式打开文件，同样是只写，不允许进行读操作。如果文件存在，则打开文件，将文件指针定位到文件尾。因此，新的内容是追加在已有内容之后。如果文件不存在，则创建新文件进行写入。
+：打开一个文件进行更新（可读写）。注意：该模式不能单独使用，需要与r/w/a组合使用。打开文件后文件指针的位置取决于另一个组合参数。

1
2
3
4
5

r+：打开一个文件用于读写。如果文件存在，则打开文件，将文件指针定位在文件头，新写入的内容在原有内容的前面；如果文件不存在会报错。
w+：打开一个文件用于读写。如果文件存在，则打开文件，清空原有内容，进入编辑模式；如果文件不存在，则创建一个新文件进行读写操作。
a+：以追加模式打开一个文件用于读写。如果文件存在，则打开文件，将文件指针定位在文件尾，新写入的内容在原有内容的后面；如果文件不存在，则创建一个新文件用于读写。

所有上面这些模式默认都是t——文本模式，如果要以二进制模式打开，需要加上参数b，如：rb、rb+、wb、wb+、ab、ab+。

  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
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109

## -*- encoding: utf-8 -*-
'''
@File    :   try.py
@Time    :   2022/11/14 15:27:12
@Author  :   Lunatic 
@Version :   1.0
@Contact :   goodlunatic0@gmail.com
'''
import os
import traceback

## try:
##     <statements>        #运行try语句块，并试图捕获异常
## except <name1>:
##     <statements>        #如果name1异常发现，那么执行该语句块。
## except (name2, name3):
##     <statements>        #如果元组内的任意异常发生，那么捕获它
## except <name4> as <variable>:
##     <statements>        #如果name4异常发生，那么进入该语句块，并把异常实例命名为variable
## except:
##     <statements>        #发生了以上所有列出的异常之外的异常
## else:
## <statements>            #如果没有异常发生，那么执行该语句块
## finally:
##     <statement>         #无论是否有异常发生，均会执行该语句块。

## try:
##     num = int(input('请输入一个整数:'))
##     result = 8 / num
##     print(result)
## ## except ZeroDivisionError:
## ##     print('0不能做除数')
## except ValueError as r:
##     ## r 是前面 ValueError 类的一个实例,下面是打印报错的明细
##     print('输入的值不是合法的整数 %s' % (r))
## except Exception as r:
##     print('未知错误 %s' % (r))
## ## 没有预先判断到的错误怎么办?
## finally:
##     ## 无论是否有异常，都会执行的代码
##     print('%%%%%%%%%%%%%%%')

## def demo1():
##     return int(input('请输入整数:'))
## def demo2():
##     return demo1()
## ## 函数的错误：一级一级的去找，最终会将异常传递到主函数里
## try:
##     print(demo2())
## except Exception as r:
##     print('未知错误 %s' % r)
## print(demo2())

## def input_passwd():
##     ## 1.提示用户输入密码
##     pwd = input('请输入密码：')
##     ## 2.判断密码的长度
##     if len(pwd) >= 8:
##         return pwd
##     ## 3.如果<8就主动抛出异常
##     print('主动抛出异常')
##     #a.创建异常对象
##     ex = Exception('长度不够')
##     #b.主动抛出
##     raise ex
## ## 注意：只抛出异常而不捕获异常 代码会出错
## try:
##     print(input_passwd())
## except Exception as re:
##     print(re)

#-----------以下是断言(assert())的内容
## def func(num, div):
##     ## 断言，可以理解为提前预言，让人更清楚报错的原因
##     assert (div != 0), 'div不能为0'
##     return num / div

## print(func(10, 0))

## a = 1
## assert (a < 0), '出错了，a>=0'
## print("正常运行")

## a = 1
## try:
##     assert a < 0
## except AssertionError as er:  #明确抛出此异常
##     #抛出AssertionError 不含任何信息，所以无法通过er.__str__()获取异常描述
##     print('AssertionError', er, er.__str__())
##     ## 通过traceback打印详细异常信息
##     print('traceback 打印异常')
##     traceback.print_exc()
## except:  #不会命中其他异常
##     print('assert except')

## try:
##     raise AssertionError('测试 raise AssertionError')
## except AssertionError as er:
##     print('raise AssertionError 异常', er.__str__())


#函数调用异常
def foo(value, divide):
    assert divide != 0, 'divide 不能为0'
    return value / divide


print(foo(4, 2))
print(foo(4, 0))

 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
62
63
64
65
66
67

## 画太极图
from turtle import *


def rset():
    pensize(1)  ## 设置画笔大小为1px
    pencolor('black')  ## 设置画笔颜色为黑色
    penup()  ## 提起画笔
    home()  ## 将画笔移动到屏幕中心
    pendown()  ## 放下画笔


def offset(off_set, angle=0, mode='taiji'):
    ## 设置画笔偏移量。该函数用于设置画笔开始绘图的位置。
    ## off_set太极时为大圆半径，八卦时要大于半径，否则会与太极重合。
    ## angle：当画八卦时用于旋转特定角度。
    penup()
    home()  ## 回到原点，朝向东
    if mode == 'taiji':  ## 太极模式
        right(90)  ## 向右旋转90度，使画笔指向南方。
        fd(off_set)
        seth(0)  ## 朝向东
    pendown()


## 绘制太极函数
## radius：太极的大圆半径。
## pen_size：画笔大小，默认为2像素。
## color：画笔颜色，默认为黑色。
def taiji(radius, pen_size=2, color='black'):
    rset()  ## 初始化画笔
    pensize(pen_size)
    pencolor(color)
    offset(radius)  ## 画笔偏移至起始点
    fillcolor('black')  ## 填充颜色
    begin_fill()  ## 开始填充
    circle(radius, 180)  ## 画大圆的半圆
    circle(radius / 2, 180)  ## 画s型
    circle(-radius / 2, 180)  ## 反向画s型
    end_fill()  ## 结束填充
    circle(-radius, 180)  ## 画大圆的另一半圆，且不用填充
    ## 上面小圆
    begin_fill()
    fillcolor('white')
    penup()
    home()  ## 返回原点，默认朝东
    left(90)
    fd(radius * 0.7)  ## 初始化小圆画笔起始点
    right(90)
    pendown()
    circle(-radius * 0.2)  ## 画小圆
    end_fill()
    rset()
    penup()
    ## 下面的小圆
    begin_fill()
    fillcolor('black')
    right(90)
    fd(radius * 0.7)
    left(90)
    pendown()
    circle(radius * 0.2)
    end_fill()


taiji(200)
done()

 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

## 画奥运五环
from turtle import *


def draw_ring(radius, ring_color):
    pensize(5)          ## 设置线宽，使五环更显眼
    pendown()
    pencolor(ring_color)  ## 设置画笔颜色
    circle(radius)
    penup()


def draw_olympic_rings():
    speed(10)
    penup()

    ## 修改环的颜色
    colors = ["blue", "black", "red", "yellow", "green"]
    ## 上面三个环的间距是2*70，下面两个环相对于上面的环稍微向右移动了35
    positions = [(-3*35, 0), (-1*35, 0), (1*35, 0),
                 (-2*35, -60), (0, -60)]

    for i in range(5):
        goto(positions[i])  ## 使用预设的位置
        draw_ring(50, colors[i])


if __name__ == "__main__":
    draw_olympic_rings()
    done()

 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

import struct

def display_binary(data):
    #将字节数据转化为十六进制表示形式
    ## return ' '.join(['{:02x}'.format(byte) for byte in data])
    return ' '.join([f"{byte:02x}" for byte in data])

## 定义要打包的数据
int_data = 10240099
float_data = 123.456

## 使用默认端序（小端序）打包
packed_int_little = struct.pack('I', int_data)
packed_float_little = struct.pack('f', float_data)

## 使用大端序打包
packed_int_big = struct.pack('>I', int_data)
packed_float_big = struct.pack('>f', float_data)

## 打印打包的结果,display_binary()是以十六进制的形式显示
print("Packed data (Little Endian):")
print(packed_int_little)
print("Int:", display_binary(packed_int_little))
print(packed_float_little)
print("Float:", display_binary(packed_float_little))

print("\nPacked data (Big Endian):")
print(packed_int_big)
print("Int:", display_binary(packed_int_big))
print(packed_float_big)
print("Float:", display_binary(packed_float_big))

## 解包数据,由于返回的是一个元组，所以需要[0]
unpacked_int_little = struct.unpack('I', packed_int_little)[0]
unpacked_float_little = struct.unpack('f', packed_float_little)[0]

unpacked_int_big = struct.unpack('>I', packed_int_big)[0]
unpacked_float_big = struct.unpack('>f', packed_float_big)[0]

## 打印解包的结果
print("\nUnpacked data (Little Endian):")
print("Int:", unpacked_int_little)
print("Float:", unpacked_float_little)

print("\nUnpacked data (Big Endian):")
print("Int:", unpacked_int_big)
print("Float:", unpacked_float_big)

## 验证打包和解包是否保持数据的完整性(float类型的数据先打包再解包后可能会有误差)
assert int_data == unpacked_int_little
## assert float_data == unpacked_float_little

assert int_data == unpacked_int_big
## assert float_data == unpacked_float_big

print("\nData integrity maintained!")

 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

## -*- encoding: utf-8 -*-
'''
@File    :   time.py
@Time    :   2022/11/14 17:55:10
@Author  :   Lunatic 
@Version :   1.0
@Contact :   goodlunatic0@gmail.com
'''
import os
import time
## 通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。

print(time.time())
## 返回当前时间的时间戳,是一个浮点数
print(time.localtime())
## 将一个时间戳转换为当前时区的struct_time。secs参数未提供，则以当前时间为准
print(time.gmtime())
## gmtime()方法是将一个时间戳转换为UTC时区（0时区）的struct_time
print(time.mktime(time.localtime()))
#time.mktime()接收struct_time对象转化用秒数来表示时间的浮点数
time.sleep(1)
## 线程推迟指定的时间运行。单位为秒
## time.clock()
## time.clock()在不同的系统上含义不同。在UNIX系统上，它返回的是“进程时间”，它是用秒表示的浮点数（时间戳）。而在WINDOWS中，第一次调用，返回的是进程运行的实际时间。而第二次之后的调用是自第一次调用以后到现在的运行时间。（实际上是以WIN32上QueryPerformanceCounter()为基础，它比毫秒表示更为精确）

print(time.asctime())
#把一个表示时间的元组或者struct_time表示为这种形式：'Sun Jun 20 23:21:05 1993'
print(time.ctime())
## 把一个时间戳（按秒计算的浮点数）转化为time.asctime()的形式

## time.strptime(string[, format])：把一个格式化时间字符串转化为struct_time。实际上它和strftime()是逆操作
print(time.strptime('2011-05-05 16:37:06', '%Y-%m-%d %X'))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

import datetime

today_date = datetime.date.today()
## 今天的日期
print(today_date)
print(datetime.datetime(2012, 1, 1))
start_time = datetime.datetime(2012, 1, 1)
print(start_time + datetime.timedelta(0))
## datetime.timedelta()常用于日期的加减
print(start_time + datetime.timedelta(-1))
print(start_time.strftime("%Y-%m-%d"))
## .strftime()用于日期格式的转换
print(start_time.strftime("%Y%m%d"))

 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

## -*- encoding: utf-8 -*-

## *代表匹配零次或多次
## +代表匹配一次或多次
## ?代表匹配零次或一次
## $匹配输入字符串的结束位置
## \\.代表小数点
## \\s代表空格，则\\s*代表匹配多个空格
## \\d代表匹配一个数字字符，等价于[0-9]，则\\d+\\.\\d*可匹配1.或1.0等\\d*\\.\\d+可匹配.0或1.0等
## [+-]代表匹配包含的任一字符+或-，[+-]?则说明+或-可有可无

import re

str = 'aabbabaabbaa'
#一个"."就是匹配除 \n (换行符)以外的任意一个字符
print(re.findall(r'a.b', str))  #['aab', 'aab']
#*前面的字符出现0次或以上
print(re.findall(r'a*b', str))  #['aab', 'b', 'ab', 'aab', 'b']
#贪婪，匹配从.*前面为开始到后面为结束的所有内容
print(re.findall(r'a.*b', str))  #['aabbabaabb']
#非贪婪，遇到开始和结束就进行截取，因此截取多次符合的结果，中间没有字符也会被截取
print(re.findall(r'a.*?b', str))  #['aab', 'ab', 'aab']
#非贪婪，与上面一样，只是与上面的相比多了一个括号，只保留括号的内容
print(re.findall(r'a(.*?)b', str))  #['a', '', 'a']

str = '''aabbab
         aabbaa
         bb'''

#后面多加了2个b
#没有把最后一个换行的aab算进来
print(re.findall(r'a.*?b', str))  #['aab', 'ab', 'aab']
#re.S不会对\n进行中断
print(re.findall(r'a.*?b', str, re.S))  #['aab', 'ab', 'aab', 'aa\n         b']

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

import re

content = """苹果是绿色的
橙子是橙色的
香蕉是黄色的
乌鸦是黑色的"""
p = re.compile(r".色")
## 代表所有的单个字符，除了 \n \r
print(type(p))
for one in p.findall(content):
    ## 找出所有符合条件的文本
    print(type(one))
    print(one)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

import re

source = """王亚辉
tony
刘文武"""

## p = re.compile(r"\w{2,4}")
p = re.compile(r"\w{2,4}", re.A)
## 不匹配中文
print(p.findall(source))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

import re

content = """001-苹果价格-60
002-橙子价格-78
003-香蕉价格-88"""
## p = re.compile(r"^\d+")
p = re.compile(r"^\d+", re.M)
## ^可以表示每行开头
for one in p.findall(content):
    print(one)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

import re

content = """001-苹果价格-60
002-橙子价格-78
003-香蕉价格-88"""
## p = re.compile(r"^\d+")
p = re.compile(r"\d+$", re.M)
## ^可以表示每行开头
for one in p.findall(content):
    print(one)

1
2
3
4
5
6
7
8
9

import re

content = """张三，手机号码15945678901
李四，手机号码13945677701
王二，手机号码13845666901"""
p = re.compile(r"^(.+)，.+(\d{11})", re.M)
## ^可以表示每行开头
for one in p.findall(content):
    print(one)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

import re

content = """Python3高级开发工程师上海互教教育科技有限公司上海-浦东新区2万/月02-18满员
测试开发工程师(C+/python)上海墨鹍数码科技有限公司上海-浦东新区2.5万/每月02-18未满员
Python.3开发工程师上海德拓信息技术股份有限公司上海-徐汇区1.3万/每月02-18乘剩余11人
测试开发工程师(Python)赫里普（上海）信息科技有限公司上海-浦东新区1.1万/每月02-18剩余5人"""
p = re.compile(r"([\d.]+)万/每{0,1}月", re.M)
## p = re.compile(r"([\d.]+)万/每{0,1}月")
## ^可以表示每行开头
for one in p.findall(content):
    print(one)

1
2
3
4
5

import re

names = "关羽; 张飞, 赵云,马超, 黄忠  李逵"
namelist = re.split(r"[;,\s]\s*", names)
print(namelist)

 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

import re

## PhoneNumRegex = re.compile(r"\d{3}-\d{3}-\d{3}")
PhoneNumRegex = re.compile(r"(\d{3})-(\d{3}-\d{3})")
## 向 re.compile()传入一个字符串值，表示正则表达式，它将返回一个 Regex 模式对象
mo = PhoneNumRegex.search("My Phone number is 415-555-4242")
print(mo.group(0))
print(mo.group())
print(mo.group(1))
print(mo.group(2))
print(mo.groups())
areacode, mainNumber = mo.groups()
print(areacode)
print(mainNumber)
## print("Phone number founded:" + mo.group())
## Regex 对象的 search()方法查找传入的字符串，寻找该正则表达式的所有匹配。如
## 果字符串中没有找到该正则表达式模式，search()方法将返回 None。如果找到了该模式，
## search()方法将返回一个 Match 对象。Match 对象有一个 group()方法，它返回被查找字
## 符串中实际匹配的文本
PhoneNumRegex2 = re.compile(r"(\(\d{3}\))-(\d{3}-\d{3})")
mo2 = PhoneNumRegex2.search("My Phone number is (415)-555-4242")
print(mo2.groups())
print(mo2.group(1))
PhoneNumRegex3 = re.compile(r"(\d{3}-)?\d{3}-\d{4}")
mo3 = PhoneNumRegex3.search("My Phonenumber is 415-555-4224")
print(mo3.group())
mo4 = PhoneNumRegex3.search("My Phonenumber is 555-4224")
print(mo4.group())

1
2
3
4
5
6
7
8
9

import re

agentNamesRegex = re.compile(r"Agent (\w)\w*")
res = agentNamesRegex.sub(
    r"\1****",
    "Agent Alice told Agent Carol that Agent Eve knew Agent Bob was a double agent.",
)
print(res)
## 字符串中的\1 将由分组 1 匹配的文本所替代，也就是正则表达式的(\w)分组。

 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

## phoneAndEmail.py - Finds phone numbers and email addresses on the clipboard.
import pyperclip, re

phoneRegex = re.compile(
    r"""(
(\d{3}|\(\d{3}\))? ## area code
(\s|-|\.)? ## separator
(\d{3}) ## first 3 digits
(\s|-|\.) ## separator
(\d{4}) ## last 4 digits
(\s*(ext|x|ext.)\s*(\d{2,5}))? ## extension
)""",
    re.VERBOSE,
)

emailRegex = re.compile(
    r"""(
[a-zA-Z0-9._%+-]+ ## username
@ ## @ symbol
[a-zA-Z0-9.-]+ ## domain name
(\.[a-zA-Z]{2,4}) ## dot-something
)""",
    re.VERBOSE,
)

text = str(pyperclip.paste())
## 从剪切板获取内容
matches = []
for groups in phoneRegex.findall(text):
    phoneNum = "-".join([groups[1], groups[3], groups[5]])
    ## 用-连接各部分
if groups[8] != "":
    phoneNum += " x" + groups[8]
    matches.append(phoneNum)
for groups in emailRegex.findall(text):
    matches.append(groups[0])
    ## group[0]是匹配r''中的所有东西

if len(matches) > 0:
    pyperclip.copy("\n".join(matches))
    ## 以换行符为行分隔符复制到剪切板
    print("Copied to clipboard:")
    print("\n".join(matches))
else:
    print("No phone numbers or email addresses found.")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

from PIL import Image

image = Image.open('0.jpg')
#打开这张图片
image.show()
## 显示这张图片
image.save('1.jpg')
#保持打开的图片
print(image.mode, image.size, image.format)
## RGB (1920, 1080) JPEG
## mode代表图片的属性，RGB代表彩色图像，L代表光照图像即灰度图像等
## size属性为图片的大小（长度，宽度）
## format属性为图片的格式

1
2
3
4
5
6
7

from PIL import Image

image = Image.open('0.jpg')
## image.show()
grey_image=image.convert('L')
grey_image.show()
grey_image.save('grey.jpg')

1
2
3
4
5
6

from PIL import Image

image = Image.open('0.jpg')
r,g,b = image.split()
im = Image.merge('RGB',(b,g,r))
print(im)

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

from PIL import Image

img = Image.open('0.jpg')
## 获取图像尺寸
w,h = img.size
## 缩放50%
img.thumbnail((w//2,h//2))
img.show()
## 水平翻转图片
img1 = img.transpose(Image.FLIP_LEFT_RIGHT)
## 保存图片
img1.show()
img1.save('1.png')
#垂直翻转图片
img2 = img.rotate(180)
img2.show()
#水平+垂直翻转图片
img3 = img.transpose(Image.FLIP_LEFT_RIGHT).rotate(180)
img3.show()
#裁剪图片
#图片裁剪用到的方法是image.crop()，这个方法能从图像中提取出某个矩形大小的图像。它接收一个四元素的元组作为参数，各元素为（left, upper, right, lower），坐标系统的原点（0, 0）是左上角。
print(img.size)
imgcut = img.crop((100,200,500,600))
imgcut.show()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

from PIL import Image,ImageDraw,ImageFont

img = Image.open('0.jpg')
## 调用画图模块
draw = ImageDraw.Draw(img)
## 设置字体
tfont = ImageFont.truetype("arial.ttf",24)
## 添加文字
"""
    参数一：文字在图片的位置：(x, y)
    参数二：文字内容
    参数三：字体颜色，当然颜色也可以用RGB值指定
    参数四：字体类型
"""
draw.text((50,30),"eyes++",fill="red",font=tfont)
## 保存图片
img.save("addword.png")
img.show()

1
2
3
4
5
6

from PIL import Image,ImageFilter

img = Image.open('0.jpg')
img = img.filter(ImageFilter.CONTOUR)
img.save('filter.png')
img.show()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

mageFilter.BLUR			模糊滤镜
mageFilter.CONTOUR			轮廓
mageFilter.EDGE_ENHANCE			边界加强
mageFilter.EDGE_ENHANCE_MORE			边界加强（阀值更大）
mageFilter.EMBOSS			浮雕滤镜
mageFilter.FIND_EDGES			边界滤镜
mageFilter.SMOOTH			平滑滤镜
mageFilter.SMOOTH MORE			平滑滤镜（阀值更大）
mageFilter.SHARPEN			锐化滤镜
ImageFilter.DETAIL			细节滤镜

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

from PIL import Image

img1 = Image.open('0.jpg')
img2 = Image.open('1.jpg')
#先查看图片尺寸
print(img1.size)
print(img2.size)
## 新建空白图片,三个参数分别是模式(RGB/RGBA) 大小 颜色
newimg = Image.new(mode="RGB",size=(3840,2160),color=(255,100,50))
## 拼接图片 第一个参数是图片 第二个参数是图片的位置
newimg.paste(img1,(0,0))
newimg.paste(img1,(1920,0))
newimg.show()

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

from PIL import Image
import os

IMAGES_PATH = 'signal1\\'  ## 图片集（文件夹）地址
IMAGES_FORMAT = ['.png', '.PNG']  ## 图片格式
IMAGE_WIDTH = 100  ## 每张小图片的宽
IMAGE_HEIGHT = 100  ## 每张小图片的高
IMAGE_ROW = 25  ## 大图片一共有几行
IMAGE_COLUMN = 25  ## 大图片一共有几列
## IMAGE_SAVE_PATH = 'final.jpg'  ## 图片转换后的地址

newimg = Image.new('RGB',(IMAGE_COLUMN * IMAGE_HEIGHT, IMAGE_ROW * IMAGE_WIDTH))
## 新建一个2500x2500的图像
for y in range(25):
    for x in range(25):
        timg = Image.open(IMAGES_PATH + str(y*IMAGE_COLUMN + x) + '.png')
        ## 打开文件夹中的图片
        newimg.paste(timg, (x*IMAGE_WIDTH, y*IMAGE_HEIGHT))
        ## 将打开的图片粘贴到newimg的指定位置
newimg.save('new.png')
## 将图片保存new.png

 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

from urllib import request, parse
import ssl

import requests

## 使用ssl未经验证的上下文
context = ssl._create_unverified_context()
url = 'https://biihu.cc//account/ajax/login_process/'
headers = {
    ## 假装自己是浏览器
    'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/71.0.3578.98 '
                  'Safari/537.36',
}
dict = {
    ## 定义请求参数
    'return_url': 'https://biihu.cc/',
    'user_name': 'xiaoshuaib@gmail.com',
    'password': '123456789',
    '_post_type': 'ajax',
}
## 把请求参数转化为byte
data = bytes(parse.urlencode(dict), 'utf-8')
## response = urllib.request.urlopen('http://www.baidu.com')
## 封装request
req = requests.Request(url,data=data,headers=headers,method='POST')
#最后进行请求
response = request.urlopen(req,context=context)
print(response.read().decode('utf-8'))
"""urllib.request.urlopen(url, data=None, [timeout, ]*)
data是给post请求携带参数的，timeout是设置请求超时时间"""
## print(response.read().decode('utf-8'))
"""urllib.request.Request(url, data=None, headers={}, method=None)
## urlopen 默认是 Get 请求，当我们传入参数它就为 Post 请求了
## 而 Request 可以让我们自己定义请求的方式"""

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

#GET请求带参数使用params，POST请求带参数使用data
import requests
rep=requests.get("http://111.200.241.244:62607")
rep=requests.post("http://111.200.241.244:62607",params={"a":"1"},data={"b":"2"})
#获得响应包中的数据
print(rep.text)
#以byte类型返回响应包中的数据
print(rep.content)
#将byte类型的数据转换为字符串
print(rep.content.decode)
#获取HTTP状态码
print(rep.status_code)
#获取请求头和响应头
print(rep.headers)#获取请求头
print(rep.request.headers)#获取响应头
#获取请求url
print(r.url)
#获取Cookie
print(r.cookies)

 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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

#没有参数传递的GET请求
import requests
url = "https://www.baidu.com"
r = requests.get(url=url)
print(r.url)
print(r.status_code)

#有参数传递的GET请求
import requests
url = "http://127.0.0.1/index.php"
payload={'username':'admin','password':'admin','submit':'登录'}
r = requests.get(url,params=payload)
result = r.content
if str(result).find('succ'):
    #在返回报文中找到succ字符时：
    print("admin:admin"+'successful')
#但是实际情况下，一般都是通过读取字典文件来获取用户名和密码
 
#有参数传递的POST请求
import requests
url = "http://127.0.0.1/index.php"
data = {'username':'admin', 'password':'admin', 'submit':'登录'}
r = requests.post(url, data=data)
print(r.status_code)
if r.text.find('succ'):
    print('admin:admin' + 'successful')
 
#自定义请求头
import requests
url = "http://127.0.0.1/index.php"
headers = {"User-Agent":"HAHA"}
r1 = requests.get(url)
print(r1.request.headers)
r = requests.get(url, headers=headers)
print(r.request.headers)

#HTTP代理和BP截断
import requests
url = "https://www.baidu.com"
#kali的ip:192.168.1.101
proxies = {'http':'http://192.168.100.9:8080', 'https':'https://192.168.100.9:8080'}
r = requests.get(url, proxies=proxies, verify=False)
#verify=False不进行证书合法性的验证
print(r.status_code)  
 
#Python IIS PUT漏洞探测工具
import requests
url = "http://192.168.0.107"
r = requests.options(url)
## print(r.headers)       
## print(r.headers["Allow"])
## print(r.headers["Public"])
result = r.headers['Public']
## print(type(result))
if result.find("PUT") and result.find("MOVE"):
    print(result)
    print("exist IIS put vul")
else:
    print("not exist")
 
#获取HTTP服务器信息
import requests
url = "http://192.168.0.107"
r = requests.get(url)
print(r.headers)
print("服务器中间件为："+r.headers['Server'])
print("服务器脚本语言为："+r.headers['X-Powered-By'])
 
#Python漏洞检测工具
import requests
url = "http://192.168.0.107"
r = requests.get(url)
## print(r.headers)
## print(r.headers['Server'])
remote_server = r.headers['Server']
print(remote_server)
print(type(remote_server))
if remote_server.find("IIS/7.5") or remote_server("IIS/8.0"):
    payload = {}
    r1 = requests.get(url,headers=headers)
    print(r1.requests.headers)
    print(r1.content)
    if str(r1.content).find("Requested Range Not Satisfiable"):
        print(url+"exist vuln ms15-034")
    else:
        print(url+"not exist vuln ms15-034")
    #开始探测
else:
    print("Server not a iis 7.5 or iis 8.0")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

import requests
from fake_useragent import UserAgent

session = requests.session()
ua = UserAgent()
headers = {
    ## 使用随机的UA头
    'user-agent': ua.random
}
url = "http://www.baidu.com"
response = session.get(url=url,headers=headers)
print(response.status_code)
print(response.text)

 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

from requests_html import HTMLSession
from fake_useragent import UserAgent

random_UA = UserAgent().random
## print(random_UA)
headers = {
    'user-agent': random_UA
}
proxy = '127.0.0.1:7890'
port = proxy.split(':')[1]
proxy = proxy.split(':')[0]
## print(proxy,port)
proxies = {
    "http":f"http://{proxy}:{port}",
    "https":f"http://{proxy}:{port}"
}

if __name__ == "__main__":
    url = "https://www.baidu.com"
    ## 获取实例化session对象
    session = HTMLSession()
    responese = session.get(url=url,headers=headers,proxies=proxies)
    print(responese.status_code)
    ## 获取html页面
    ## html = responese.content.decode()
    ## 使用requests_html中的方法
    html = responese.html.html
    ## print(responese.text)
    ## print(html[:15])
    ## 获取相对链接
    ## print(responese.html.links)
    ## 获取拼接URL后的绝对链接
    ## print(responese.html.absolute_links)
    ## 使用xpath选择器
    ## print(responese.html.xpath('//li[@class="hotsearch-item odd"]/a'))
    ## print(responese.html.xpath('//li[@class="hotsearch-item odd"]/a', first=True).text)
    ## 使用CSS选择器(find方法)
    print(responese.html.find('a.mnav'))
    print(responese.html.find('a.mnav', first=True).text)

 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

from requests_html import HTMLSession
from fake_useragent import UserAgent

random_UA = UserAgent().random
## print(random_UA)
headers = {
    'user-agent': random_UA
}
proxy = '127.0.0.1:7890'
port = proxy.split(':')[1]
proxy = proxy.split(':')[0]
## print(proxy,port)
proxies = {
    "http":f"http://{proxy}:{port}",
    "https":f"http://{proxy}:{port}"
}

if __name__ == "__main__":
    url = "https://www.jianshu.com/u/7753478e1554"
    ## 获取实例化session对象
    session = HTMLSession()
    responese = session.get(url=url,headers=headers,proxies=proxies)
    responese.html.render(scrolldown=50,sleep=.2)
    titles = responese.html.find('a.title')
    for i ,title in enumerate(titles):
        print(f"[+]{i+1}[{title.text}](https://www.jianshu.com/u/7753478e1554{title.attrs['href']})")

 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

#optparse模块的使用
from email import parser
from email.parser import Parser
import optparse
 
parser = optparse.OptionParser()#初始化
parser.usage = "command_args.py -u user_file"
parser.add_option("-u", "--user_file", help="read username from file", action="store", type="string", metavar="FILE", dest="username_file")
(option, args)=parser.parse_args()
print(options.username_file)

#Web密码破解命令行读取模板编写（username password url threads）
from email import parser
from email.parser import Parser
from yaml import parse
import optparse

parser = optparse.OptionParser()
parser.usage = "web_brute_command.py -s url -u user_file -p -pass_file -t num"
parser.add_option("-s", "--site", dest="website", help="website to test", action="store", type="string", metavar="URL")
parser.add_option("-u", "--userfile", dest="userfile", help="username from file", action="store", type="string", metavar="USERFILE")
parser.add_option("-p", "--passfile", dest="passfile", help="password from file", action="store", type="string", metavar="PASSFILE")
parser.add_option("-t", "--threads", dest="threads", help="number of threads", actions="store", type="int", metavar="THREADS")
(option, args)=parser.parse_args()
print(options.website)
print(options.userfile)
print(options.passfile)
print(options.threads)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

import xlwt

## 1.创建Workbook
wb = xlwt.Workbook(encoding="utf-8")
## 2。创建worksheet
ws = wb.add_sheet("test_sheet")
## 3.写入第一行内容
## ws.write(a,b,c)    a:行 b:列 c:内容
ws.write(0, 0, "球队")
ws.write(0, 1, "号码")
ws.write(0, 2, "姓名")
ws.write(0, 3, "位置")

wb.save("myExcel.xls")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

import xlwt

data = [
    {"Team": "湖人", "Number": "34", "Name": "奥尼尔", "Positions": "中锋"},
    {"Team": "湖人", "Number": "24", "Name": "科比", "Positions": "后卫"},
    {"Team": "湖人", "Number": "23", "Name": "詹姆斯", "Positions": "前锋"},
]

wb = xlwt.Workbook()
ws = wb.add_sheet("test_sheet")
for i, item in enumerate(data):
    ## enumerate()函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在for 循环当中
    ws.write(i + 1, 0, item["Team"])
    ws.write(i + 1, 1, item["Number"])
    ws.write(i + 1, 2, item["Name"])
    ws.write(i + 1, 3, item["Positions"])

    wb.save("myExcel1.xls")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

def write2xlsx(data,filename):
    workbook = xw.Workbook(filename)
    worksheet1 = workbook.add_worksheet("sheet1")
    ## 激活子表
    worksheet1.activate()
    title = ['Url','Title']
    worksheet1.write_row('A1',title)
    i=2
    for j in range(len(data)):
        insertdata = [data[j]["url"],data[j]["title"]]
        row = 'A'+str(i)
        worksheet1.write_row(row,insertdata)
        i+=1
    workbook.close()

 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

import json

jsondata = """
{
"Uin":0,
"UserName":"@c482d142bc698bc3971d9f8c26335c5c",
"NickName":"小帅b",
"HeadImgUrl":"/cgi-bin/mmwebwx-bin/webwxgeticon?seq=500080&username=@c482d142bc698bc3971d9f8c26335c5c&skey=@crypt_b0f5e54e_b80a5e6dffebd14896dc9c72049712bf",
"ContactFlag":3,
"MemberCount":0,
"MemberList":[

],
"RemarkName":"",
"HideInputBarFlag":0,
"Sex":1,
"Signature":"",
"VerifyFlag":0,
"OwnerUin":0,
"PYInitial":"XSB",
"PYQuanPin":"xiaoshuaib",
"RemarkPYInitial":"",
"RemarkPYQuanPin":"",
"StarFriend":0,
"AppAccountFlag":0,
"Statues":0,
"AttrStatus":98491,
"Province":"广东",
"City":"广州",
"Alias":"",
"SnsFlag":48,
"UniFriend":0,
"DisplayName":"",
"ChatRoomId":0,
"KeyWord":"che",
"EncryChatRoomId":"",
"IsOwner":0
}
"""

myfriend = json.loads(jsondata)
## json.load() 和 json.loads() 区别：
## loads() 传的是json字符串，而 load() 传的是文件对象
## 使用 loads() 时需要先读取文件在使用，而 load() 则不用
print(myfriend)
NickName = myfriend.get("NickName")
print(NickName)

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

import json

jsondata = """{
"MemberList":[
{
"UserName":"小帅b",
"sex":"男"
},
{
"UserName":"小帅b的1号女朋友",
"sex":"女"
},
{
"UserName":"小帅b的2号女朋友",
"sex":"女"
}
]
}"""
myfriend = json.loads(jsondata)
## print(myfriend)
memberList = myfriend.get("MemberList")
print(memberList)