关于python:Python习题集

文章目录[隐藏]

求100万以内的所有素数个数
打印九九乘法表
求几何级数的第N项
求菲波那切数列的第101位
求杨辉三角第n行第k列的值
字符串转化为数值
移除一个列表中的反复元素，并放弃列表原来的程序
扁平化字典
实现base64编码解码算法
实现计数器，能够指定基数和步长
查找两个字符串的最长公共子串
实现命令散发器
实现ls命令
实现find命令
实现cp命令
实现LinkedList
实现优先队列
实现字典

求100万以内的所有素数个数

第一种办法

思路：以后数为i，则遍历比int(sqrt(i))+1小的所有数是是否都不能够整除，是，则是素数

实践：如果遍历所有比i小的除数j并且当除数j>int(sqrt(i))时，如果j能整出i，那么必然存在一个小于int(sqrt(i))的数能整出i，因而咱们只需只需遍历int(sqrt(i))+1以内的数即可

代码

cnt = 0
for i in range(2,1000000):
    for j in range(2, int(i ** 0.5) + 1):
        if i % j == 0:
            break
    else:
       cnt += 1 
print(cnt)

输入后果如下

第二种办法

实践

如果一个整数是合数，则肯定存在一个小于它的素数作为其因数。比方9是一个合数，而素数3就是它的一个因数。
如果咱们晓得了小于一个数的所有素数，则只需确定该数能不能被这些素数整除即可。如果不能被整除，则这个数肯定是个素数。反之，则不是。
也就是说当咱们取得一个素数时，能够将它所有的倍数都标记为非素数，这样当咱们遍历到一个数时，他没有被任何小于它的素数标记为非素数，则能够确定该数是个素数。
比方：从2开始，在初始化时2就是素数。3是相似。遍历到4时，4曾经被素数2给标记了，间接跳过

思路

初始化一个大范畴内的列表，初始时所有数都为素数，遍历时依照以上实践将所有的非素数标记进去即可

代码

cnt = 0
is_prime = [True]*1000000
is_prime[0] = False
is_prime[1] = False
for i in range(2, 1000000):
    if is_prime[i] is False:
        continue
    cnt += 1
    k = i
    while k * i < 1000000:
        is_prime[k * i] = False
        k += 1
print(cnt)

输入后果

<!–more–>

打印九九乘法表

思路：每一次内层循环j只有循环到外层循环i即可

代码

#!/usr/bin/env python 
#coding=utf-8

def multiplicationTable():
    for i in range(1,10):
        for j in range(1,i+1):
            r=i*j
            print("%d*%d=%-3d"%(i,j,r),sep='',end=' ')
        print('\n')
if __name__=='__main__':
    multiplicationTable()

输入后果如下

1*1=1   

2*1=2   2*2=4   

3*1=3   3*2=6   3*3=9   

4*1=4   4*2=8   4*3=12  4*4=16  

5*1=5   5*2=10  5*3=15  5*4=20  5*5=25  

6*1=6   6*2=12  6*3=18  6*4=24  6*5=30  6*6=36  

7*1=7   7*2=14  7*3=21  7*4=28  7*5=35  7*6=42  7*7=49  

8*1=8   8*2=16  8*3=24  8*4=32  8*5=40  8*6=48  8*7=56  8*8=64  

9*1=9   9*2=18  9*3=27  9*4=36  9*5=45  9*6=54  9*7=63  9*8=72  9*9=81

求几何级数的第N项

思路

几何级数的模式是：a+a*q+a*q^2+a*q^3+...+a*q^n
须要输出的项是：a,q,n

代码

# !/user/bin/env python
# coding = utf-8

a=int(input('请输出几何级数的a: '))
q=int(input('请输出几何级数的q: '))
n=int(input('请输出几何级数的n: '))
sum=0
for i in range(0,n+1):
    sum += a * q  ** i
print(sum)

输入输出后果如下

请输出几何级数的a: 3
请输出几何级数的q: 2
请输出几何级数的n: 4
93

求菲波那切数列的第101位

先写出递推公式再来写实现，递推公式如下

思路

fib[0]=1 当i=0
fib[1]=1 当i=1
fib[i]=fib[i-1]+fib[i-2] 当i>1
fib的第101位也就是fib[100]=fib[99]+fib[98]

代码

a = 0
b = 0
for i in range(0,101):
    if i == 0:
        a = 1
    elif i ==1:
        b = 1
    else:
        c = a + b
        a = b
        b = c
print(b)

输入后果如下

573147844013817084101

求杨辉三角第n行第k列的值

#!/usr/bin/env python  
# encoding: utf-8  

"""
Created on 2/26/17 5:03 PM
@author: Flowsnow
@file: YangHuiTriangle.py
@function: 求杨辉三角第n行第k列的值
"""


def yang_hui_triangle(n, k):
    lst = []
    for i in range(n+1):
        row = [1]
        lst.append(row)
        if i == 0:
            continue
        for j in range(1, i):
            row.append(lst[i-1][j-1] + lst[i-1][j])
        row.append(1)
    print(lst[n][k])


if __name__ == '__main__':
    yang_hui_triangle(6, 4)

字符串转化为数值

形容：把字符串模式的整数或浮点数转化为int或float，不应用int和float函数

#!/usr/bin/env python  
# encoding: utf-8  

"""
Created on 2/26/17 5:52 PM
@author: Flowsnow
@file: str2num.py 
@function: 把字符串模式的整数或浮点数转化为int或float， 不应用int和float函数
"""


def str2num(s: str):
    mapping = {str(x): x for x in range(10)}
    i, _, f = s.partition('.')
    # print(i, f)
    ret = 0
    for idx, x in enumerate((i+f)[::-1]):
        ret += mapping[x] * 10 ** idx
    return ret / 10 ** len(f)

if __name__ == '__main__':
    s = '1230.0541640'
    print(str2num(s))

移除一个列表中的反复元素，并放弃列表原来的程序

#!/usr/bin/env python  
# encoding: utf-8  

"""
Created on 2/26/17 6:30 PM
@author: Flowsnow
@file: rm_elements.py 
@function: 移除一个列表中的反复元素，并放弃列表原来的程序
"""

def remove_elements(lst: str):
    ret = []
    for x in lst:
        if x not in ret:
            ret.append(x)
    return ret

if __name__ == '__main__':
    lst = [1, 2, 4, 5, 2, 3, 1, 2, 6, 7, 8, 3, 2, 3, 4]
    print(remove_elements(lst))

扁平化字典

例如：

{‘a’: {‘b’: 1}} 扁平化之后是 {‘a.b’: 1}
{‘a’: {‘b’: {‘c’: 1, ‘d’: 2}, ‘x’: 2}}扁平化之后是{‘a.x’: 2, ‘a.b.c’: 1, ‘a.b.d’: 2}

初始字典的特点：

字典的每个key都是可hash的，因而不会是字典
初始字典不为空字典
字典的value深度能够有限嵌套

思路：应用递归，每次递归深度都会变动，也就是说门路会变动，能够应用一个path变量记录门路

如果嵌套的v不是字典时，间接退出新元素: desDict[‘{}.{}’.format(path, k).lstrip(‘.’)] = v
如果嵌套的v为空字典时，间接用空字符串代替: desDict[‘{}.{}’.format(path, k).lstrip(‘.’)] = ”
如果嵌套的v不为空字典时，间接增长path，并将v进行下一次递归: flatten_dict(v, desDict, path)
每一次递归返回时，就阐明以后深度的字典曾经遍历结束，须要减短path
rstrip函数都不是原地批改，返回的都是正本

判断变量是否是字典

type()
isInstance()

代码

#!/usr/bin/env python  
# encoding: utf-8  

"""
Created on 2/26/17 8:26 PM
@author: Flowsnow
@file: flatten_dict.py 
@function: 扁平化字典
"""


def flatten_dict(srcDict: dict, desDict: dict,  path: str):
    for k, v in srcDict.items():
        if not isinstance(v, dict):
            desDict['{}.{}'.format(path, k).lstrip('.')] = v
        else:
            if v == {}:
                desDict['{}.{}'.format(path, k).lstrip('.')] = ''
            else:
                path = '{}.{}'.format(path, k).lstrip('.')
                flatten_dict(v, desDict, path)
                path = path.rstrip('.{}'.format(k))


if __name__ == '__main__':
    srcDict = {'a': {'b': {'c': 1, 'd': 2}, 'x': 2}}
    # srcDict = {'a': {'b': 1}}
    desDict = {}
    flatten_dict(srcDict, desDict, '')
    print(desDict)

实现base64编码解码算法

Base64编码的思维

采纳64个根本的ASCII码字符对数据进行从新编码。它将须要编码的数据拆分成字节数组。以3个字节为一组。按顺序排列24 位数据，再把这24位数据分成4组，即每组6位。再在每组的的最高位前补两个0凑足一个字节。这样就把一个3字节为一组的数据从新编码成了4个字节。当所要编码的数据的字节数不是3的整倍数，也就是说在分组时最初一组不够3个字节。这时在最初一组填充1到2个0字节。并在最初编码实现后在结尾增加1到2个 “=”。

base64编码示例：将对ABC进行BASE64编码

首先取ABC对应的ASCII码值。A（65）B（66）C（67）；
再取二进制值A（01000001）B（01000010）C（01000011）；
而后把这三个字节的二进制码接起来（010000010100001001000011）；
再以6位为单位分成4个数据块,并在最高位填充两个0后造成4个字节的编码后的值，（00010000）（00010100）（00001001）（00000011）
再把这四个字节数据转化成10进制数得（16）（20）（9）（3）；
最初依据BASE64给出的64个根本字符表，查出对应的ASCII码字符（Q）（U）（J）（D），这里的值理论就是数据在字符表中的索引。

base64字符表：最多六个字节，因而最范畴是0~63，所以总共64个字符

ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/

字符和ascii码之间的转换：单个字符

ord 字符转换成ascii
chr ascii转换成字符

字符串和ascii码之间的转换：字符串

map(ord, “a test String: 123456”)

加密示例

CBdaF3FV的编码后果是Q0JkYUYzRlY=
CBdaF34FV的编码后果是Q0JkYUYzNEZW
CdaF3FV的编码后果是Q2RhRjNGVg==
ABC的编码后果是QUJD

作用

次要用做把二进制转换成字符串

代码1：作为字符串解决

# base64编码
def base64Encode(s):
    base64StrList = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
    ret = ''
    bList = list(map(ord, s))
    bStr = ''
    #print(bList)
    for x in bList:
        tmpS = str(bin(x))
        bStr += '0' * (10 - len(tmpS)) + tmpS.lstrip('0b')
    print(bStr)
    i = 0
    while i + 6 < len(bStr):
        tmpX = bStr[i: i+6]
        #print(tmpX)
        ret += base64StrList[int(tmpX, 2)]
        i += 6
    rest = bStr[i:]
    if len(rest) == 2:
        ret += base64StrList[int(rest + '0000', 2)]
        ret += '=='
    elif len(rest) == 4:
        ret += base64StrList[int(rest + '00', 2)]
        ret += '='
    else:
        ret += base64StrList[int(rest, 2)] # 在while局部解决之后剩下一个残缺的6位
    print(ret)


# base64解码
def base64Decode(s):
    base64StrList = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
    bStr = ''
    ret = ''
    for x in s:
        if x == '=':
            continue
        i = base64StrList.find(x)
        s1 = str(bin(i))
        bStr += '0'*(10-len(s1)-2) + s1.lstrip('0b')

    cnt = s.count('=')
    bStr = bStr[: -2 * cnt + len(bStr)]

    i = 0
    while i < len(bStr):
        b = bStr[i: i + 8]
        ret += chr(int(bStr[i: i + 8], 2))
        i += 8

    print(ret)

代码2：作为字节数组解决

长处：字节数组+位运算，进步处理速度，缩小内存占用。

#!/usr/bin/env python  
# encoding: utf-8  

"""
Created on 2/26/17 9:11 PM
@author: Flowsnow
@file: base64.py 
@function: 实现base64编码解码算法:字节数组+位运算
"""


# base64编码
def b64encode(data: bytes) -> str:
    table = b'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
    encoded = bytearray()
    c = 0
    for x in range(3, len(data)+1, 3):
        i = int.from_bytes(data[c: x], 'big')   # bytes to int
        for j in range(1, 5):
            encoded.append(table[i >> (24 - j*6) & 0x3f])
        c += 3
    r = len(data) - c
    if r > 0:
        i = int.from_bytes(data[c:], 'big') << (3-r) * 8
        for j in range(1, 5-(3-r)):
            encoded.append(table[i >> (24 - j*6) & 0x3f])
        for _ in range(3-r):
            encoded.append(int.from_bytes(b'=', 'big'))
    return encoded.decode()


# base64解码
def b64decode(data:str) -> bytes:
    table = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
    decoded = bytearray()
    s = 0
    for e in range(4, len(data)+1, 4):
        tmp = 0
        for i, c in enumerate(data[s:e]):
            if c != '=':
                tmp += table.index(c) << 24 - (i+1) * 6
            else:
                tmp += 0 << 24 - (i+1) * 6
        decoded.extend(tmp.to_bytes(3, 'big'))
        s += 4
    return bytes(decoded.rstrip(b'\x00'))


if __name__ == '__main__':
    print(b64encode(b'abc'))
    print(b64decode('YWJj'))

实现计数器，能够指定基数和步长

生成器和匿名函数的应用

#!/usr/bin/env python  
# encoding: utf-8  

"""
Created on 2/27/17 9:30 AM
@author: Flowsnow
@file: make_inc.py 
@function: 实现计数器，能够指定基数和步长
"""


def make_inc(base, step):
    def counter():
        nonlocal base
        nonlocal step
        x = base
        while True:
            x += step
            yield x
    c = counter()
    return lambda : next(c)

if __name__ == '__main__':
    # inc这个函数封装了一个生成器c，并且每次调用inc的时候都是在执行next(c)
    inc = make_inc(2, 3)
    print(inc())
    print(inc())
    print(inc())
    print(inc())

查找两个字符串的最长公共子串

暴力法：找出两个字符串各自所有的子串，而后一一比拟，更新最长的值
动静布局：
1. 两个字符串别离为s1和s2
2. s1[i]和s2[j]别离示意其第i和第j个字符(字符程序从0开始)
3. 令L[i, j]示意以s1[i]和s2[j]为结尾的雷同子串的最大长度。
4. L[i, j] = L[i-1, j-1] + 1 如果s1[i] == s2[j]
5. L[i, j] = 0 如果s1[i] != s2[j]

#!/usr/bin/env python  
# encoding: utf-8  

"""
Created on 2/27/17 9:48 AM
@author: Flowsnow
@file: longest_common_substring.py 
@function: 
"""


def longest_common_substring(s1: str,s2:str):
    s = ''
    dp = []
    maxL = 0    # 记录子串的最长长度
    maxI = 0    # 记录子串最长的下标
    for i, x in enumerate(s1):
        dp.append([])
        for j, y in enumerate(s2):
            if x == y:
                if i > 0 and j > 0:
                    dp[i].append(dp[i - 1][j - 1] + 1)
                else:
                    dp[i].append(1)
                if dp[i][j] > maxL:
                    maxI = i
                    maxL = dp[i][j]
            else:
                dp[i].append(0)
    s = s1[maxI + 1 - maxL: maxI + 1]    # maxI是下标
    for i in dp:
        print(i)
    return s
if __name__ == '__main__':
    s1 = 'I-love-Python'
    s2 = 'snow-love-other'
    s = longest_common_substring(s1, s2)
    print(s)

输入后果

[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 1, 0]
[0, 0, 0, 0, 1, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0]
[0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0]
[0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
'-love-'

实现命令散发器

实现函数可带任意参数(可变参数除外)，解析参数并要求用户输出

实现ls命令

实现 -l -a -h 选项

实现find命令

实现 -name -type -ctime -mtime -cnewer -executable -newer -gid -uid 测试

实现cp命令

实现 -r -p选项

实现LinkedList

函数实现

类实现

实现优先队列

函数实现

类实现

实现字典

函数实现

类实现

记得帮我点赞哦！

精心整顿了计算机各个方向的从入门、进阶、实战的视频课程和电子书，依照目录正当分类，总能找到你须要的学习材料，还在等什么？快去关注下载吧！！！

朝思暮想，必有回响，小伙伴们帮我点个赞吧，非常感谢。

我是职场亮哥，YY高级软件工程师、四年工作教训，回绝咸鱼争当龙头的斜杠程序员。

听我说，提高多，程序人生一把梭

如果有幸能帮到你，请帮我点个【赞】，给个关注，如果能顺带评论给个激励，将不胜感激。

职场亮哥文章列表：更多文章

自己所有文章、答复都与版权保护平台有单干，著作权归职场亮哥所有，未经受权，转载必究！

搞代码网（gaodaima.com）提供的所有资源部分来自互联网，如果有侵犯您的版权或其他权益，请说明详细缘由并提供版权或权益证明然后发送到邮箱[email protected]‍，我们会在看到邮件的第一时间内为您处理，或直接联系QQ：872152909。本网站采用BY-NC-SA协议进行授权
转载请注明原文链接：关于python:Python习题集