Python 刷题笔记

本文记录了我在使用python刷题的时候遇到的知识点。

Python 刷题笔记

选择、填空题

Python3 中，布尔型只有 True 和 False 两个值，但它们的值本质上是 1 和 0，因此它们可以和数字进行数学运算。正确 e.g. True+1 == 2
在Python 3.X版本中，整除运算符产生的结果的数据类型可能为浮点型正确 e.g. 33.2 // 3 == 11.2
要将3.1415926变成00003.14，如何进行格式化输出 "%08.2f"% 3.1415926
如果一句Python代码过长，可在行末写下符号"/"，然后换行继续写 错误分行是\或者()
字典的键可以是字符串常量也可以是整型常量，甚至还可以是列表错误列表不能作为字典的键
对于数字n，如果表达式 0 not in [n%d for d in range(2, n)]的值为True，则说明n是素数正确

列出了所有的 n% 2~n的数字值如果0不在就说明是素数
for循环结束后，循环变量i不存在，导致程序错误错误！

i变量会是最后的值
表达式(i**2 for i in range(100))的结果是个元组错误！这是一个生成器 e.g.

(i**2 for i in range(10))

> for i in a:

...     print(i)

0 1 4 9 16 25 ...

正则表达式'\d{5}'可用来检查字符串是否为5个数字字符组成的字符串错误

可匹配5个数字的模式但是一串可能有多个这样的子串？
下面不能严格匹配YYYY-MM-DD这样日期格式的正则表达式是

A.\d{4}-\d{2}-\d{2}

B.[0-9]-[0-9]-[0-9]

C.[0-9]{4}-[0-9]{2}-[0-9]{2}

D.[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]

如果递归函数没有递归结束的语句，将会导致无穷递归，从而执行时出现“死循环” 错误

解释：递归是不断有函数进入栈，就像翻不完的书，不是死循环。
write方法用于把字符串写入文本文件并在最后添加换行符。错误
如果首先以读模式打开一个文件，然后用seek方法把文件指针定位到文件的最后，再通过tell方法就可以得到一个文件的长度。 ** 正确**
异常 a undefined

def main():

    a,b=eval(input())

    try:

        s=a/b

        print(s)

    except: 

        print("Divide 0!")main()

基本输入输出

待消化sys.stdout

`sys.stdin` 与`input`

sys.stdin.readlines() or readline

前者一次读入多行，返回一个行列表，每个元素为输入的每行内容。

结束输入Linux: ctrl+d+enter, Windows: ctrl+z+enter

import sys

#实现和input一样的功能

print("please input something\n")

s = sys.stdin.readline()

print(s, end='')        #会读入\n, input不会

#文件作为整体的输入

for line in sys.stdin.readlines():

    if not line:

        break

    else:

        print (line)

C:\> python test.py < 123.txt

对输入结束的判断

sys.stdin

for lin in sys.stdin:

input()

try：

    ...

except EOFError:

    pass

运行脚本时传入参数

sys.argv

argv[0] 是被调用的脚本的文件全名或全路径，argv[1]和一会的就是传入的数据

python filename.py 1,2,3 10

import sys

arg1 = sys.argv[1]

arg2 = sys.argv[2]

print(arg1, type(arg1), type(arg2))

1,2,3  str  str

argparse



import argparse

parser = argparse.ArgumentParser(description='manual to this script')

parser.add_argument('--gpus', type=str, default = None)

parser.add_argument('--batch-size', type=int, default=32)

args = parser.parse_args()

print(args.gpus, type(args.gpus))

print(args.batch_size, type(args.batch_size))

D:\>python argv_test.py --gpus=0,1,2 --batch-size=20

0,1,2 <class 'str'>

20 <class 'int'>

Python语言基础

Python的浮点数常量也有十进制、二进制、八进制和十六进制等表示方式 X 十进制，科学计数法
pow(x,y,z) -> x**y%z
type(1+8.0//4) == float 整除的结果取决于被除数和除数的类型

序列

列表

只能通过切片访问列表中的元素，不能使用切片修改列表中的元素错误
两个列表相加 newlist = [x+y, for x,y in zip(list1, list2)]
现有列表 k = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]，那么Python3解释器执行 k.insert(-2, 'b')后执行k[-2]的结果是 9 b插入在9的位置 9 0 向后移动

元组

创建只包含一个元素的元组时，必须在元素后面加一个逗号，例如 a = (3,)正确

如果是a = (3) 或者a = ('a') 类型分别为int和str，只有一个元素的元组一定要加上,
列表可以是元组内的元素，可以改变元组内列表的值

字典

合并两个字典

a={'a':1,'b':2}

b={'a':3,'c':4}

a.update(b)

c = dict(a,**b)

字典中的“键”必须是可哈希对象，不能是列表，可以是元组，字符串，数值

集合

集合中的元素必须是不可变类型，即列表不可以是集合内的元素

选择与循环

a = range(100) 哪些操作合法：a[-3]，a[2:13], a[::3]
- a[a️c] range(a, b, c)
s

字符串与正则表达式

字符串

要一次去掉字符串中的 , . 等符号，可以使用maketrans和translate方法
'GUN's Not %s %%' % 'UNIX' >> "GUN's Not UNIX %"
表达式'a' + 1 的值为 'b' 错误

chr(ord('a') + 1)
s

正则

假设re模块已成功导入，并且有pattern = re.compile('^'+'\.'.join([r'\d{1,3}' for i in range(4)]) + '$')，那么表达式pattern.match('192.168.1.103')的值为None
'back' match 'backup'√ match 'text.back' X

函数

在函数中修改传入参数的值

整数，浮点数等不会因函数内变化而变
列表对象在id不变的时候会影响到外部的

输出结果 F f C ls是全局变量

ls = ["F", "f"]

def fun(a):

    ls.append(a)

    return

fun("C")

print(ls)

输出结果10 None ss比函数迟声明函数内的ss为局部变量

def hub(ss, x=2.0, y=2.0):

    ss += x*y

ss = 10

print(ss, hub(ss, 3))

对于组合数据类型的全局变量，如果在函数内部没有被真实创建的同名变量，则函数内部不可以直接使用并修改全局变量的值错误类似上述1 的情况
Python函数支持可变数量的参数，实参用“ *参数名 ”表示错误形参用*参数名表示

面向对象

文件

参数encoding是指明对文件编码，仅适用于文本文件。如果不明编码方式，默认是使用locale.getpreferredencoding()函数返回的编码方式。

seek(offset, from)方法

offset 文件指针偏移量， from: 0 文件开头 1当前位置 2文件末尾默认为0 可以通过seek(0,2)定位到文件末尾

用python删除文件和用linux命令删除文件

os.remove(path) rm file_path

异常

Python中，对于代码中的每个try，必须至少有一个except与它匹配错误可以只有try finally
是

未分类

常见数学

3.5题目※

因数 i%n ==0 且n!=i n!=1 n是i的因数
素数大于1的自然数中，除了1和它本身以外不再有其他因数的自然数。
完全数
真因子
完全平方数： 2 * 2 = 4 8 * 8 =64
互质：互质是公约数只有1的两个整数，叫做互质整数。公约数只有1的两个自然数，叫做互质自然数，后者是前者的特殊情形。
完数
水仙花数

欧几里得（辗转相除法）求两个正整数a, b的最大公约数

1)如果a<b,交换a,b的值2）r=a mod b(即r是a÷b的余数），若 r = 0，算法结束，b即为答案3）否则，互换：a ← b,b←r,并返回第一步。

快速判断是否是素数

原理：所有自然数可以用集合A = { 6n, 6n+1, 6n+2, 6n+3, 6n+4, 6n+5 }表示，其中 n >= 0，显然，子集B = {6n, 6n+2, 6n+3, 6n+4}内的元素都不是素数，所以只有6n+1和6n+5可能是素数，素数一定可以用6n+1和6n+5其中的一个形式表示，即大于等于5的素数与6的倍数相邻

判断一个数num是否是素数时，需要判断num是否有除1和自身之外的因子。这时只需要判断x是否是num的因子，其中1 < x <= int(sqrt(num))，而x的范围又可以用集合{ 6i, 6i+1, 6i+2, 6i+3, 6i+4, 6i+5 }表示。当num与6的倍数相邻时，num才可能是素数，因为num（奇数）和{6i, 6i+2, 6i+3, 6i+4}（偶数）互素，也就是{6i, 6i+2, 6i+3, 6i+4}不可能是num的因子，此时只需判断x = 6i+1和x = 6i+5是否是num的因子即可，如果都不是，则num是素数。

————————————————

原文链接：https://blog.csdn.net/qq_36963214/article/details/90490364



def is_prime_fast(num):

    if num <= 1:

        return False

    elif num == 2 or num == 3:

        return True

    elif num % 6 in (0, 2, 3, 4):

        return False

    else:

        half = int(sqrt(num)) + 1

        for i in range(5, half, 6):

            # 只需判断6i+1 和6i+5是不是num的因子即可

            if num % i == 0 or num % (i+2) == 0:

                return False

        else:

            return True

性能评估

from time import perf_counter

start = perf_counter()

print(perf_counter()-start)

numpy

import numpy as np

a = np.repeat(np.arange(5).reshape([1,-1]),10,axis = 0)+10.0 b = np.random.randint(5, size= a.shape)

c = np.argmin(a*b, axis=1)

b = np.zeros(a.shape)

b[np.arange(b.shape[0]), c] = 1

print b

random

random()不需要参数返回0~1随机小数

random.sample(pop, k) 从pop类型中随机宣区k各元素构成的列表

is 和 ==的区别前者比较对象的id 后者比较对象的value
列举几个你用过的第三方库 简单介绍一下用途
函数的可变长度参数 有什么形式（*arg, *kwarg）
- 前者接收任意个实参并放到一个元组中
- 后者类似关键参数一样显示赋值多个实参并放入字典中
列表对象的复制非拷贝方法（直接赋值）拷贝方法（浅拷贝深拷贝）

https://www.cnblogs.com/Black-rainbow/p/9577029.html
能否举出几个 Python2 和 3不同的地方
- print语法 print "xxx" -> print("xxx")
- 2的字符串是ascii类型 unicode是单独的 3中有字符串类（unicode）以及字节类byte和bytearrays 且源码默认utf-8
- 除法运算 3中的/是真除法 (整数之间的相除，结果也会是浮点数) //是整除 2的/是整除
- 2中有xrange()和range() 前者像生成器惰性求值后者返回整个列表 3中只有range类似2的xrange
- 3 bin() 整数转二进制
- x进制数写法 0?111 e.g. 二0b111 八0o777
- 不等运算符 2有 != 和 <> 3只有前者
python的垃圾回收机制 https://www.cnblogs.com/ajianbeyourself/p/11151498.html
- 引用计数每个对象含一个ob_ref字段计算被引用次数清0立刻回收
- 标记清除解决对象的循环引用问题 e.g. AB 相互引用但是AB都del了；阶段1给活动对象打标记阶段2 回收非活动对象
- 分代回收将内存根据对象的存活时间划分为不同的集合，每个集合称为一个代；垃圾收集频率与对象的存活时间的增大而减小
函数和方法有什么区别如何判断一个对象是函数还是方法 https://www.cnblogs.com/xcsg/p/10551114.html
- 函数：FunctionType 直接def的是函数类中的函数通过类的方式调用也是函数 <function Work.show at 0x000001CC55BC5268>
- 方法：MethodType 类中的函数通过实例化对象调用为方法 <bound method Work.show of <__main__.Work object at 0x000001CC55C2F240>>
- 判别方式 1.直接print会得到上面的描述 2. isinstance(对象, FunctionType) isinstance(对象, MethodType)