Python 的题？

Posted 2023-05-04

这道题怎么做

a1,a2=0,0

a3=[]

for a in range(100,10000):

c=0

for b in range(1,a//2+1):

if a%b==0:

c+=b

if c==a:

a3.append(a)

elif c>a:

a1+=1

else:

a2+=1

print("完全数:")

print(a3)

print("丰沛数:")

print(a1)

print("不足数:")

print(a2)

参考技术A from selenium import webdriver # 用来驱动浏览器的from selenium.webdriver import ActionChains # 破解滑动验证码的时候用的 可以拖动图片import timefrom PIL import Image # pip3 install pillowimport random# 截图图片函数def cut_image(driver): # 获取整个页面图片，图片名字为'snap.png'
driver.save_screenshot('snap.png') # 获取滑动小画图
image = driver.find_element_by_class_name('geetest_canvas_img') print(image.location) print(image.size) # 获取小图片的左上右下的位置
left = image.location['x']
top = image.location['y']
right = left + image.size['width']
buttom = top + image.size['height'] print(left, top, right, buttom) # 调用open方法打开全屏图片并赋值给image_obj对象
image_obj = Image.open('snap.png') # 通过image_obj对象对小图片进行截取
# box: The crop rectangle, as a (left, upper, right, lower)-tuple.
img = image_obj.crop((left, top, right, buttom)) # 打开截取后的小图片
# img.show()
return img# 获取完整图片def get_image1(driver):
time.sleep(2) # 修改document文档树，把完整图片的display属性修改为block
js_code = '''
var x = document.getElementsByClassName("geetest_canvas_fullbg")[0].style.display = "block"; '''

# 执行js代码 driver.execute_script(js_code) # 截取图片
image = cut_image(driver) return image# 获取有缺口图片def get_image2(driver):
time.sleep(2) # 修改document文档树，把完整图片的display属性修改为block
js_code = '''
var x = document.getElementsByClassName("geetest_canvas_fullbg")[0].style.display = "none"; '''

# 执行js代码 driver.execute_script(js_code) # 截取图片
image = cut_image(driver) return image# 获取滑块滑动距离def get_distance(image1, image2): # 小滑块右侧位置
start = 60 # 像素差
num = 60 print(image1.size) for x in range(start, image1.size[0]): for y in range(image1.size[1]): # 获取image1完整图片每一个坐标的像素点
rgb1 = image1.load()[x, y] # 获取image2缺口图片每一个坐标的像素点
rgb2 = image2.load()[x, y] # (60, 86, 40) (60, 86, 40) rgb
print(rgb1, rgb2) # abs获取绝对值， 像素点比较的值
r = abs(rgb1[0] - rgb2[0])
g = abs(rgb1[1] - rgb2[1])
b = abs(rgb1[2] - rgb2[2]) # 如果条件成立，则找到缺口位置
if not (r < num and g < num and b < num): # 有误差 - 7像素
return x - 7# 模拟人的滑动轨迹def get_strck_move(distance):
distance += 20 '''
滑动行为轨迹
加速公式:
v = v0 + a * t

路程公式:
s = v0 * t + 0.5 * a * (t ** 2) '''

# 初速度
v0 = 0 # 时间
t = 0.2 # 位置
s = 0 # 滑动轨迹列表 向前滑动列表
move_list = [] # 中间值,作为加减速度的位置
mid = distance / 5 * 3 # 加减速度列表
v_list = [1, 2, 3, 4] # 循环位移
while s < distance: if s < mid: # 随机获取一个加速度
a = v_list[random.randint(0, len(v_list) - 1)] else: # 随机获取一个减速度
a = -v_list[random.randint(0, len(v_list) - 1)] '''
匀加速\减速运行
v = v0 + a * t

位移:
s = v * t + 0.5 * a * (t**2) '''
# 获取初始速度
v = v0 # 路程公式:
s1 = v * t + 0.5 * a * (t ** 2)
s1 = round(s1) # 取整

# 加速公式:
# v = v0 + a * t
m_v = v + a * t # 把当前加/减速度赋值给初始速度，以便下一次计算
v0 = m_v # 把位移添加到滑动列表中 move_list.append(s1) # 修改滑动初始距离
s += s1 # 后退列表, 自定义后退滑动轨迹,必须是负值
back_list = [-1, -1, -2, -3, -2, -1, -1, -2, -3, -2, -1, -1] return 'move_list': move_list, 'back_list': back_listdef main():
driver = webdriver.Chrome(r'F:\python学习\Scripts\chromedriver')
driver.implicitly_wait(10) try:
driver.get('https://account.cnblogs.com/signin?returnUrl=https%3A%2F%2Fwww.cnblogs.com%2F') # 1、输入用户名与密码，并点击登录
user_input = driver.find_element_by_id('LoginName')
user_input.send_keys('你的博客园账号')
time.sleep(0.2)

pwd_input = driver.find_element_by_id('Password')
pwd_input.send_keys('你的博客园密码')
time.sleep(2)

login_submit = driver.find_element_by_id('submitBtn')
login_submit.click() # 2、获取完整的图片
image1 = get_image1(driver) # 3、获取有缺口图片
image2 = get_image2(driver) # 4、比对两张图片，获取滑动距离
distance = get_distance(image1, image2) print(distance) # 5、模拟人的滑动轨迹
move_dict = get_strck_move(distance) # 获取前进滑动轨迹
move_list = move_dict['move_list'] # 获取后退滑动轨迹
back_list = move_dict['back_list'] # 6、开始滑动
move_tag = driver.find_element_by_class_name('geetest_slider_button') # 点击摁住滑动按钮 ActionChains(driver).click_and_hold(move_tag).perform() # 向前滑动
for move in move_list:
ActionChains(driver).move_by_offset(xoffset=move, yoffset=0).perform()
time.sleep(0.1)

time.sleep(0.1) # 向后滑动
for back in back_list:
ActionChains(driver).move_by_offset(xoffset=back, yoffset=0).perform()
time.sleep(0.1) # 制作微妙晃动
ActionChains(driver).move_by_offset(xoffset=3, yoffset=0).perform()
ActionChains(driver).move_by_offset(xoffset=-3, yoffset=0).perform()

time.sleep(0.1) # 释放滑动按钮 ActionChains(driver).release().perform()

time.sleep(100) finally:
driver.close()if __name__ == '__main__':
main() 参考技术B

def JudgeNumber(x):
prime = []
for i in range(1, x):
if x % i == 0:
prime.append(i)
if sum(prime) > x:
return 1
elif sum(prime) == x:
return 0
else:
return -1

numbers = [JudgeNumber(i) for i in range(100, 10000)]
PerfectNumberIndex = [i for i, x in enumerate(numbers) if x == 0]
PerfectNumber = [str(list(range(100, 10000))[i]) for i in PerfectNumberIndex]
print('[100, 10000) 之间的完全数个数有: %s 个, 分别是:[%s]; ' %
(numbers.count(0), ', '.join(PerfectNumber)))
print('[100, 10000) 之间的丰沛数个数有: %s 个;' % numbers.count(1))
print('[100, 10000) 之间的不足数个数有: %s 个;' % numbers.count(-1))

求 linux下 c++高手，命令行传参数的题，

求 linux下 c++高手，命令行传参数的题，

参考技术A GNU/Linux的命令行选项有两种类型：短选项和长选项，前者以 '-' 作为前导符，后者以 '--' 作为前导符

　　。比如有一个命令：

　　$ myprog -a vv --add -b --file a.txt b.txt - -- -e c.txt

　　在GNU/Linux系统，对这种情况的一种合理解释是：

　　a是短选项，带一个参数vv；

　　add是长选项，无参数；

　　b是短选项，无参数；

　　file是长选项，带一个参数a.txt；

　　b.txt是参数；

　　-是参数，通常表示标准输入，stdin；

　　--是一个指示符，表明停止扫描参数，其后所有部分都是参数，而不是选项；

　　-e是参数；

　　c.txt是参数

　　为了简化程序设计，有几个库函数可以优雅地分析命令行参数，原型如下：

　　#include <unistd.h>

　　int getopt(int argc, char * const argv[],

　　const char *optstring);

　　extern char *optarg;

　　extern int optind, opterr, optopt;

　　#define _GNU_SOURCE

　　#include <getopt.h>

　　int getopt_long(int argc, char * const argv[],

　　const char *optstring,

　　const struct option *longopts, int *longindex);

　　int getopt_long_only(int argc, char * const argv[],

　　const char *optstring,

　　const struct option *longopts, int *longindex);

　　我们先看看用于分析短参数的getopt函数。参数含义如下：

　　argc, argv是从main函数获取的参数，原样传给getopt；

　　optstring指示如何分析参数。

　　关于optstring，还有几点说明：

　　如果选项带参数，该选项后接冒号，比如上例中optstring为"a:b"，指示a带参数，b没有参数；

　　如果选项带可选参数，该选项后接两个冒号，比如"a::b"，表明a可能有参数，也可能没有；

　　如果optstring的开头字符为':'，表明如果指明选项带参数，而实际命令行没有参数时，getopt返回':'而不是'?'(默认情况下返回'?'，和无法识别的参数返回一样)；

　　如果optstring的开头字符为'+'，表明一但遇到一个无选项参数，马上停止扫描，随后的部分当作参数来解释；

　　如果optstring的开头字符为'-'，表明如果遇到无选项参数，则把它当作选项1（不是字符'1'）的参数

　　该函数每解析完一个选项，就返回该选项字符。

　　如果选项带参数，参数保存在optarg中。如果选项带可选参数，而实际无参数时，optarg为NULL。

　　当遇到一个不在optstring指明的选项时，返回字符‘?’。如果在optstring指明某选项带参数而实际没有参数时，返回字符‘?’或者字符‘:’，视optstring的第一个字符而定。这两种情况选项的实际值被保存在optopt中。

　　当解析错误时，如果opterr为1则自动打印一条错误消息（默认），否则不打印。

　　当解析完成时，返回-1。

　　每当解析完一个argv，optind就会递增。如果遇到无选项参数，getopt默认会把该参数调后一位，接着解析下一个参数。如果解析完成后还有无选项的参数，则optind指示的是第一个无选项参数在argv中的索引。

　　函数getopt_long()的工作方式类似于getopt()，不过它还能接收长选项。在接收长选项之前，我们必须定义个一个结构体数组变量longopts，指明我们希望获取的长选项。

　　struct option

　　const char *name;

　　int has_arg;

　　int *flag;

　　int val;

　　;

　　含义如下：

　　name指明长选项的名称；

　　has_arg指明该选项是否带参数，1为是，0为否，2为可选；

　　flag指明长选项如何返回，如果flag为NULL，则getopt_long返回val。否则返回0,flag指向一个值为val的变量。如果该长选项没有发现，flag保持不变；

　　val指明返回的值，或者需要加载到被flag所指示的变量中。

　　option数组的最后一个元素必须全部填充0.

　　getopt_long的最后一个参数longindex在函数返回时指向被搜索到的选项在longopts数组中的下标。longindex可以为NULL，表明不需要返回这个值。

　　getopt_long_only类似于getopt_long，但是它把'-'开头的选项当作长选项来处理。如果该选项与长选项不匹配，而与短选项匹配，则可以作为短选项解析。

　　在短选项找到的时候，getopt_long和getopt_long_only的表现和getopt一样。如果长选项找到了，如果flag为 NULL，返回val，否则返回0。错误情况的处理和getopt一样，只是返回'?'时还可能是别的情况引起的：选项含糊不明确或者无关参数。
我们拿Linux手册的一个例子来说事。

　　#include <stdio.h> /* for printf */

　　#include <stdlib.h> /* for exit */

　　#include <getopt.h>

　　int

　　main (int argc, char **argv)

　　int c;

　　int digit_optind = 0;

　　while (1)

　　int this_option_optind = optind ? optind : 1;

　　int option_index = 0;

　　static struct option long_options[] =

　　"add", 1, 0, 0,

　　"append", 0, 0, 0,

　　"delete", 1, 0, 0,

　　"verbose", 0, 0, 0,

　　"create", 1, 0, ’c’,

　　"file", 1, 0, 0,

　　0, 0, 0, 0

　　;

　　c = getopt_long (argc, argv, "abc:d:012",

　　long_options, &option_index);

　　if (c == -1)

　　break;

　　switch (c)

　　case 0:

　　printf ("option %s", long_options[option_index].name);

　　if (optarg)

　　printf (" with arg %s", optarg);

　　printf ("\n");

　　break;

　　case ’0’:

　　case ’1’:

　　case ’2’:

　　if (digit_optind != 0 && digit_optind != this_option_optind)

　　printf ("digits occur in two different argv-elements.\n");

　　digit_optind = this_option_optind;

　　printf ("option %c\n", c);

　　break;

　　case ’a’:

　　printf ("option a\n");

　　break;

　　case ’b’:

　　printf ("option b\n");

　　break;

　　case ’c’:

　　printf ("option c with value ‘%s’\n", optarg);

　　break;

　　case ’d’:

　　printf ("option d with value ‘%s’\n", optarg);

　　break;

　　case ’?’:

　　break;

　　default:

　　printf ("?? getopt returned character code 0%o ??\n", c);

　　

　　

　　if (optind < argc)

　　printf ("non-option ARGV-elements: ");

　　while (optind < argc)

　　printf ("%s ", argv[optind++]);

　　printf ("\n");

　　

　　exit (0);

　　

　　我们用digit_optind和this_option_optind来跟踪选项012是否在一起，比如选项 -012 和-0 -1 -2 的optind情况是不一样的，前者返回0、1、2时optind相同，而后者optind的值依次大1。

希望你能看懂。。。 参考技术B 这意味这程序是在DOS、或者linux等命令行界面执行，参数信息传到 main(int agrn, char* argv)两个参数中 参考技术C 能具体点吗。