精华内容
下载资源
问答
  • 科学计算和可视化图形;本章内容;9.1 Matplotlib实现数据可视化;直接用pip安装进入cmd输入pip install Matplotlib 即可若提示没有适合版本可能以前安装过numpy模块把numpy模块卸载了再直接安装Matplotlib模块即可 如...
  • Python语言程序设计课件
  • 1. 这本书对Python的知识点的描述很详细,而且排版看的很舒服. 2. 几个例题:假装自己从零开始学,将一些有代表性、有意思的例题抽取出来. 3. 还有自己对一部分课后复习题,全部课后上机实践题的解题思路

    (还在更新中…) 这篇博客花费了我的大量时间和精力,从创作到维护;若认可本篇博客,希望给一个点赞、收藏

    并且,遇到了什么问题,请在评论区留言,我会及时回复的


    这本书对Python的知识点的描述很详细,而且排版看的很舒服

    1. 几个例题: 假装自己从零开始学,将一些有代表性、有意思的例题抽取出来
    2. 部分复习题: 遇到有意思的复习题,我会拿出来,并且进行分析
    3. 上机实践: 全部上机实践题的解题思路

    文章目录

    第一章 Python概述


    几个例题

    一:Python3.7.4下载

    python3.7.4下载地址:https://www.python.org/downloads/release/python-374/
    页面最下面:

    下载,安装完python后:出现的四个玩意:Python 3.7 Module Docs,IDLE,Python 3.7 Manuals,Python 3.7(64-bit)

    1. Python 3.7 Module Docs(64-bit)
      点击之后,会出现一个网页(将我下载的Python3.7.4文件夹中包含的模块都列了出来,页面不止这么点,还可以往下拉)

    2. IDLE(Python 3.7 64-bit)
      一个Python编辑器,Python内置的集成开发工具

    3. Python 3.7 Manuals(64-bit)
      Python 3.7 开发手册

    4. Python 3.7(64-bit)
      控制台中运行Python

    二:更新pip和setuptools包,安装NumPy包,安装Matplotlib包

    以下三个命令都是在控制台(windows中的cmd)中运行

    更新pip和setuptools包

    1. pip用于安装和管理Python扩展包
    2. setuptools用于发布Python包
    python -m pip install -U pip setuptools
    

    安装NumPy

    Python扩展模块NumPy提供了数组和矩阵处理,以及傅立叶变换等高效的数值处理功能

     python -m pip install NumPy
    

    安装Matplotlib包

    Matplotlib是Python最著名的绘图库之一,提供了一整套和MATLAB相似的命令API,既适合交互式地进行制图,也可以作为绘图控件方便地嵌入到GUI应用程序中

    python -m pip install Matplotlib
    

    三:使用IDLE打开和执行Python源文件程序

    首先:
    有一个.py文件test.py
    在这里插入图片描述

    使用IDLE打开.py文件的两种方式:

    1. 右键test.py---->Edit With IDLE---->Edit With IDLE 3.7(64-bit)
    2. 打开IDLE,然后File---->Open(或者ctrl+O)选择.py文件

    运行

    Run---->Run Module(或者F5
    就会出现这个界面,执行结果显示在这个界面中

    补充一点:
    如果在IDLE中编辑.py文件,记得修改后要保存(ctrl+s),再运行(F5

    四:使用资源管理器运行hello.py

    hello.py文件在桌面

    import random
    
    print("hello,Python")
    print("你今天的随机数字是:",random.choice(range(10)))#输出在0-9之间随机选择的整数
    input()
    
    1. 在桌面打开PowerShell(还有两种输入方式:python hello.py或者.\hello.py
    2. 或者在桌面打开cmd, 就输入hello.py或者python hello.py

    补充:上述两种命令中的hello.py都是相对路径,因为文件在桌面,而且我是在桌面打开cmd,所以文件路劲可以这么简简单单的写。如果文件存储位置和cmd打开位置不一样,请使用绝对路径

    五:命令行参数示例hello_argv.py

    hello_argv.py文件在桌面

    import sys
    
    print("Hello,",sys.argv[1])
    #这样写也行:
    #print("Hello,"+sys.argv[1])
    
    1. 在桌面打开PowerShell(还有两种输入方式:python hello_argv.py 任意输入或者./hello_argv.py 任意输入
    2. 或者在桌面打开cmd,就输入hello_argv.py 任意输入或者python hello_argv.py 任意输入

    补充:以图中第一个命令举例,hello_argv.pysys.argv[0]Pythonsys.argv[1]

    第二章 Python语言基础


    选择题:1、3、7、8

    1. 在Python中,以下标识符合法的是

    A. _B. 3CC. it’sB. str

    答案:A

    1. 标识符的第一个字符必须是字母,下划线(_);其后的字符可以是字母、下划线或数字。
    2. 一些特殊的名称,作为python语言的保留关键字,不能作为标识符
    3. 以双下划线开始和结束的名称通常具有特殊的含义。例如__init__为类的构造函数,一般应避免使用

    B:以数字开头,错误
    C:使用了',不是字母、下划线或数字
    D:str是保留关键字

    3. 在下列Python语句中非法的是

    A. x = y =1B. x = (y =1)C. x,y = y,xB. x=1;y=1

    答案:B,C

    7. 为了给整型变量x,y,z赋初值10,下面Python赋值语句正确的是

    A. xyz=10B. x=10 y=10 z=10C. x=y=z=10B. x=10,y=10,z=10

    答案:C

    1. 分号;用于在一行书写多个语句
    2. python支持链式赋值

    A:赋值对象是xyz
    B:分号;用于在一行书写多个语句,而不是' '(即空格)
    D:分号;用于在一行书写多个语句,而不是,

    8. 为了给整型变量x,y,z赋初值5,下面Python赋值语句正确的是

    A. x=5;y=5;z=5B. xyz=5C. x,y,z=10B. x=10,y=10,z=10

    答案:A

    Pytho能支持序列解包赋值,但是变量的个数必须与序列的元素个数一致,否则会报错

    B:赋值对象是xyz
    C:序列解包赋值,变量的个数必须与序列的元素个数一致,否则会报错
    D:分号;用于在一行书写多个语句,而不是,

    思考题:9

    9.下列Python语句的输出结果是

    def f():pass
    print(type(f()))
    

    结果:<class 'NoneType'>

    NoneType数据类型包含唯一值None,主要用于表示空值,如没有返回值的函数的结果

    上机实践:2~6

    2. 编写程序,输入本金、年利率和年数,计算复利(结果保留两位小数)

    money = int(input("请输入本金:"))
    rate = float(input("请输入年利率:"))
    years = int(input("请输入年数:"))
    amount = money*((1+rate/100)**years)
    print(str.format("本金利率和为:{0:2.2f}",amount))
    

    运行:

    请输入本金:1000
    请输入年利率:6.6
    请输入年数:10
    本金利率和为:1894.84
    

    3. 编写程序,输入球的半径,计算球的表面积和体积(结果保留两位小数)

    import math
    r = float(input("请输入球的半径:"))
    area = 4 * math.pi * r**2
    volume = 4/3*math.pi*r**3
    print(str.format("球的表面积为:{0:2.2f},体积为:{1:2.2f}",area,volume))
    

    运行:

    请输入球的半径:666
    球的表面积为:5573889.08,体积为:1237403376.70
    

    4. 编写程序,声明函数getValue(b,r,n),根据本金b,年利率r和年数n计算最终收益v

    money = int(input("请输入本金:"))
    rate = float(input("请输入年利率(<1):"))
    years = int(input("请输入年数:"))
    
    def getValue(b,r,n):
        return b*(1+r)**n
    
    print(str.format("本金利率和为:{0:2.2f}",getValue(money,rate,years)))
    

    运行:

    请输入本金:10000
    请输入年利率(<1):0.6
    请输入年数:6
    本金利率和为:167772.16
    

    5. 编写程序,求解一元二次方程x2-10x+16=0

    from math import sqrt 
    x = (10+sqrt(10*10-4*16))/2
    y = (10-sqrt(10*10-4*16))/2
    print(str.format("x*x-10*x+16=0的解为:{0:2.2f},{1:2.2f}",x,y))
    

    运行:

    x*x-10*x+16=0的解为:8.00,2.00
    

    6. 编写程序,提示输入姓名和出生年份,输出姓名和年龄

    import datetime
    sName = str(input("请输入您的姓名:"))
    birthday = int(input("请输入您的出生年份:"))
    age = datetime.date.today().year - birthday
    print("您好!{0}。您{1}岁。".format(sName,age))
    

    运行:

    请输入您的姓名:zgh
    请输入您的出生年份:1999
    您好!zgh。您20岁。
    

    案例研究:使用Pillow库处理图像文件

    https://blog.csdn.net/Zhangguohao666/article/details/102060722

    通过此案例,进一步了解Python的基本概念:模块、对象、方法和函数的使用

    第三章 程序流程控制


    几个例题

    一:编程判断某一年是否为闰年

    闰年:年份能被4整除但不能被100整除,或者可以被400整除。
    口诀:四年一闰,百年不闰,四百必闰

    代码一:

    y = int(input("请输入要判断的年份:"))
    if((y % 4 == 0 and y % 100 != 0) or y % 400 == 0):
        print("是闰年")
    else:
        print("不是闰年")
    

    代码二(使用calendar模块的isleap()函数来判断):

    from calendar import isleap
    
    y = int(input("请输入要判断的年份:"))
    if(isleap(y)):print("闰年")
    else:print("不是闰年")
    

    二:利用嵌套循环打印九九乘法表

    九九乘法表:

    for i in range(1,10):
        s = ""
        for j in range(1,10):
            s += str.format("%d * %d = %02d  " %(i, j, i*j))
        print(s)
    

    下三角:

    for i in range(1,10):
        s = ""
        for j in range(1,i+1):
            s += str.format("%d * %d = %02d  " %(i, j, i*j))
        print(s)
    

    上三角:

    for i in range(1,10):
        s = ""
        for k in range(1,i):
            s += "                   "
        for j in range(i,10):
            s += str.format("%d * %d = %02d  " %(i, j, i*j))
        print(s)
    

    三:enumerate()函数和下标元素循环示例

    Python语言中的for循环直接迭代对象集合中的元素,如果需要在循环中使用索引下标访问集合元素,则可以使用内置的enumerate()函数

    enumerate()函数用于将一个可遍历的数据对象(例如列表、元组或字符串)组合为一个索引序列,并返回一个可迭代对象,故在for循环当中可直接迭代下标和元素

    seasons = ["Spring","Summer","Autumn","Winter"]
    for i,s in enumerate(seasons,start=1):    #start默认从0开始
        print("第{0}个季节:{1}".format(i,s))
    

    运行:

    第1个季节:Spring
    第2个季节:Summer
    第3个季节:Autumn
    第4个季节:Winter
    

    四:zip()函数和并行循环示例

    如果需要并行遍历多个可迭代对象,则可以使用Python的内置函数zip()

    zip()函数将多个可迭代对象中对应的元素打包成一个个元组,然后返回一个可迭代对象。如果元素的个数不一致,则返回列表的长度与最短的对象相同。

    利用运算符*还可以实现将元组解压为列表

    evens = [0,2,4,6,8]
    odds = [1,3,5,7,9]
    for e,o in zip(evens,odds):
        print("{0} * {1} = {2}".format(e,o,e*o))
    

    运行:

    0 * 1 = 0
    2 * 3 = 6
    4 * 5 = 20
    6 * 7 = 42
    8 * 9 = 72
    

    五:map()函数和循环示例

    如果需要遍历可迭代对象,并使用指定函数处理对应的元素,则可以使用Python的内置函数map()

    map(func,seq1[,seq2,...])
    
    • func作用于seq中的每一个元素,并将所有的调用结果作为可迭代对象返回。
    • 如果func为None,该函数的作用等同于zip()函数

    计算绝对值:

    >>> list(map(abs, [-1, 0, 7, -8]))
    [1, 0, 7, 8]
    

    计算乘幂:

    >>> list(map(pow, range(5), range(5)))
    [1, 1, 4, 27, 256]
    

    计算ASCII码:

    >>> list(map(ord, 'zgh'))
    [122, 103, 104]
    

    字符串拼接(使用了匿名函数lambda):

    >>> list(map(lambda x, y: x+y, 'zgh', '666'))
    ['z6', 'g6', 'h6']
    

    选择题:1、2、3

    1. 下面的Python循环体的执行次数与其他不同的是

    A.

    i = 0						
    while(i <= 10):
    	print(i)
    	i = i + 1
    

    B.

    i = 10
    while(i > 0):
    	print(i)
    	i = i - 1
    

    C.

    for i in range(10):
    	print(i)
    

    D.

    for i in range(10,0,-1):
    	print(i)
    

    答案:A

    A:[0,10] 执行11次
    B:[10,1] 执行10次
    C:[0,9) 执行10次
    D:[10,0) 执行10次

    2. 执行下列Python语句将产生的结果是

    x = 2; y = 2.0
    if(x == y): print("Equal")
    else: print("Not Equal")
    
    A. EqualB. Not EqualC. 编译错误D. 运行时错误

    答案:A

    Python中的自动类型转换:

    1. 自动类型转换注意针对Number数据类型来说的
    2. 当2个不同类型的数据进行运算的时候,默认向更高精度转换
    3. 数据类型精度从低到高:bool int float complex
    4. 关于bool类型的两个值:True 转化成整型是1;False 转化成整型是0

    int类型的2转化为float类型的2.0

    3. 执行下列Python语句将产生的结果是

    i= 1 	
    if(i): print(True) 	
    else: print(False)
    
    A. 输出1B. 输出TrueC. 输出FalseD. 编译错误

    答案:B

    在Python中,条件表达式最后被评价为bool值True或False。

    如果表达式的结果为数值类型(0),空字符串(""),空元组(()),空列表([]),空字典({}),其bool值为False,否则其bool值为True

    填空题:6

    6. 要使语句for i in range(_,-4,-2)循环执行15次,则循环变量i的初值应当为

    答案:26或者25

    一开始我给的答案是26,经过评论区 的提醒:
    在这里插入图片描述

    >>> a = 0
    >>> for i in range(26, -4, -2): a+=1
    
    >>> print(a)
    15
    
    >>> a = 0
    >>> for i in range(25, -4, -2): a+=1
    
    >>> print(a)
    15
    

    这种题目有一个规律:for i in range(x,y,z):
    若循环中没有break或者continue语句,
    执行次数的绝对值:result = (x-y)÷z

    但实际上没有这么简单:

    • 如果步长为 -1或者1,那么答案只有一个
    • 如果步长为 -2或者2,那么答案有两个
    • 如果步长为 -3或者3,那么答案有三个

    通过公式算出 x 之后,

    • 如果步长为2,还要计算 (x ± 1) - z × (result-1) 的值,然后再经过琐碎的判断即可
    • 如果步长为3,还要计算 (x ± 2) - z × (result-1) 的值,…

    虽然看着麻烦,但实际上是很好理解的

    思考题:3~6

    3. 阅读下面的Python程序,请问程序的功能是什么?

    from math import sqrt
    
    n = 0
    for m in range(101,201,2):
        k = int(sqrt(m))
        for i in range(2, k+2):
            if m % i == 0:break
        if i == k + 1:
            if n % 10 == 0:print()
            print('%d' % m,end = " ")
            n += 1
    

    输出101到200之间的素数
    每行输出10个,多余换行

    运行:

    101 103 107 109 113 127 131 137 139 149 
    151 157 163 167 173 179 181 191 193 197 
    199
    

    素数(质数)是指在大于1的自然数中,除了1和它本身以外不再有其他因数的自然数。

    4. 阅读下面的Python程序,请问输出的结果使什么?

    n = int(input("请输入图形的行数:"))
    for i in range(0, n):
        for j in range(0, 10 - i):print(" ", end=" ")
        for k in range(0, 2 * i + 1):print(" * ", end=" ")
        print("\n")
    

    输出的是一个金字塔

    运行:

    请输入图形的行数:4
                         *  
    
                       *   *   *  
    
                     *   *   *   *   *  
    
                   *   *   *   *   *   *   *  
    

    5. 阅读下面的Python程序,请问输出的结果使什么?程序的功能是什么?

    for i in range(100,1000):
        n1 = i // 100
        n2 = i // 10 % 10
        n3 = i % 10
        if(pow(n1, 3) + pow(n2, 3) + pow(n3, 3) == i):print(i, end=" ")
    

    输出三位数中所有的水仙花数

    运行:

    153 370 371 407 
    

    水仙花数 是指一个 3 位数,它的每个位上的数字的 3次幂之和等于它本身

    6. 阅读下面的Python程序,请问输出的结果使什么?程序的功能是什么?

    for n in range(1,1001):
        total = 0; factors = []
        for i in range(1, n):
            if(n % i == 0):
                factors.append(i)
                total += i
        if(total == n):print("{0} : {1}".format(n, factors))    
    

    输出1到1000的所有完数,并输出每个完数的所有因子

    运行:

    6 : [1, 2, 3]
    28 : [1, 2, 4, 7, 14]
    496 : [1, 2, 4, 8, 16, 31, 62, 124, 248]
    

    完数 所有的真因子(即除了自身以外的约数)的和(即因子函数),恰好等于它本身

    上机实践:2~14

    2. 编写程序,计算1=2+3+…+100之和

    1. 使用for循环(递增):
    total = 0
    for i in range(101):
        total += i
    print(total) 
    
    1. 使用求和公式:
    >>> (1 + 100) * 100 /2
    5050.0
    
    1. 使用累计迭代器itertools.accumulate
    >>> import itertools
    >>> list(itertools.accumulate(range(1, 101)))[99]
    5050
    

    3. 编写程序,计算10+9+8+…+1之和

    1. 使用for循环(递增):
    total = 0
    for i in range(11):
        total += i
    print(total) 
    
    1. 使用for循环(递减):
    total = 0
    for i in range(10,0,-1):
        total += i
    print(total)   
    
    1. 使用求和公式:
    >>> (1 + 10) * 10 / 2
    55.0
    
    1. 使用累计迭代器itertools.accumulate
    >>> import itertools
    >>> list(itertools.accumulate(range(1,11)))[9]
    55
    

    4. 编写程序,计算1+3+5+7+…+99之和

    1. 使用for循环(递增):
    total = 0
    for i in range(1,100,2):
        total += i
    print(total)     
    
    1. 使用求和公式:
    >>> (1 + 99) * 50 /2
    2500.0
    
    1. 使用累计迭代器itertools.accumulate
    >>> import itertools
    >>> list(itertools.accumulate(range(1,100,2)))[49]
    2500
    

    5. 编写程序,计算2+4+6+8+…+100之和

    1. 使用for循环(递增):
    total = 0
    for i in range(2,101,2):
        total += i
    print(total)     
    
    1. 使用求和公式:
    >>> (2 + 100) * 50 / 2
    2550.0
    
    1. 使用累计迭代器itertools.accumulate
    >>> import itertools
    >>> x = list(itertools.accumulate(range(2,101,2)))
    >>> x[len(x)-1]
    2550
    

    6. 编写程序,使用不同的实现方法输出2000~3000的所有闰年

    代码一:

    for y in range(2000,3001):
        if((y % 4 == 0 and y % 100 != 0) or y % 400 == 0):
            print(y,end = ' ')
    

    代码二(使用calendar模块的isleap()函数来判断):

    from calendar import isleap
    
    for y in range(2000,3001):
        if(isleap(y)):print(y,end = " ")
    

    运行:

    2000 2004 2008 2012 2016 2020 2024 2028 2032 2036 2040 2044 2048 2052 2056 2060 2064 2068 2072 2076 2080 2084 2088 2092 2096 2104 2108 2112 2116 2120 2124 2128 2132 2136 2140 2144 2148 2152 2156 2160 2164 2168 2172 2176 2180 2184 2188 2192 2196 2204 2208 2212 2216 2220 2224 2228 2232 2236 2240 2244 2248 2252 2256 2260 2264 2268 2272 2276 2280 2284 2288 2292 2296 2304 2308 2312 2316 2320 2324 2328 2332 2336 2340 2344 2348 2352 2356 2360 2364 2368 2372 2376 2380 2384 2388 2392 2396 2400 2404 2408 2412 2416 2420 2424 2428 2432 2436 2440 2444 2448 2452 2456 2460 2464 2468 2472 2476 2480 2484 2488 2492 2496 2504 2508 2512 2516 2520 2524 2528 2532 2536 2540 2544 2548 2552 2556 2560 2564 2568 2572 2576 2580 2584 2588 2592 2596 2604 2608 2612 2616 2620 2624 2628 2632 2636 2640 2644 2648 2652 2656 2660 2664 2668 2672 2676 2680 2684 2688 2692 2696 2704 2708 2712 2716 2720 2724 2728 2732 2736 2740 2744 2748 2752 2756 2760 2764 2768 2772 2776 2780 2784 2788 2792 2796 2800 2804 2808 2812 2816 2820 2824 2828 2832 2836 2840 2844 2848 2852 2856 2860 2864 2868 2872 2876 2880 2884 2888 2892 2896 2904 2908 2912 2916 2920 2924 2928 2932 2936 2940 2944 2948 2952 2956 2960 2964 2968 2972 2976 2980 2984 2988 2992 2996 
    

    7. 编写程序,计算Sn=1-3+5-7+9-11…

    代码一:

    n = int(input("项数:"))
    total = 0
    flag = True
    for i in range(1,2*n,2):
        if(flag):
            total += i
            flag = False
        else:
            total -= i
            flag = True
    print(total)
    

    代码二:

    n = int(input("项数:"))
    total = 0
    x = 2
    for i in range(1,2*n,2):
        total += pow(-1,x)*i
        x += 1 
    print(total)
    

    运行:

    项数:10
    -10
    

    8. 编写程序,计算Sn=1+1/2+1/3+…

    n = int(input("项数:"))
    total = 0.0
    for i in range(1,n+1):
        total += 1/i 
    print(total)
    

    运行:

    项数:10
    2.9289682539682538
    

    9. 编写程序,打印九九乘法表。要求输入九九乘法表的各种显示效果(上三角,下三角,矩形块等方式)

    矩形块:

    for i in range(1,10):
        s = ""
        for j in range(1,10):
            s += str.format("%d * %d = %02d  " %(i, j, i*j))
        print(s)
    

    下三角:

    for i in range(1,10):
        s = ""
        for j in range(1,i+1):
            s += str.format("%d * %d = %02d  " %(i, j, i*j))
        print(s)
    

    上三角:

    for i in range(1,10):
        s = ""
        for k in range(1,i):
            s += "                   "
        for j in range(i,10):
            s += str.format("%d * %d = %02d  " %(i, j, i*j))
        print(s)
    

    10. 编写程序,输入三角形的三条边,先判断是否可以构成三角形,如果可以,则进一步求三角形的周长和面积,否则报错“无法构成三角形!”

    from math import sqrt
    
    a = float(input("请输入三角形的边长a:"))
    b = float(input("请输入三角形的边长b:"))
    c = float(input("请输入三角形的边长c:"))
    
    if(a < b): a,b = b,a
    if(a < c): a,c = c,a
    if(b < c): b,c = c,b
    
    if(a < 0 or b < 0 or c < 0 or b+c <= a): print("无法构成三角形!")
    else:
        h = (a+b+c)/2
        area = sqrt(h*(h-a)*(h-b)*(h-c))
        print("周长:{0},面积:{1}".format(a+b+c,area))
    

    运行:

    请输入三角形的边长a:4
    请输入三角形的边长b:3
    请输入三角形的边长c:5
    周长:12.0,面积:6.0
    

    11. 编写程序,输入x,根据如下公式计算分段函数y的值。请分别用单分支语句,双分支语句结构以及条件运算语句等方法实现

    y = (x2-3x)/(x+1) + 2π + sinx (x≥0 )
    y = ln(-5x) + 6√(|x|+e4) - (x+1)3 (x<0)

    单分支语句:

    import math
    
    x = float(input("请输入x:"))
    if(x >= 0):
        y = (x*x - 3*x)/(x+1) + 2*math.pi + math.sin(x)
    if(x < 0):
        y = math.log(-5*x) + 6 * math.sqrt(abs(x) + math.exp(4)) - pow(x+1,3)
    
    print(y)
    
    
    

    双分支语句:

    import math
    
    x = float(input("请输入x:"))
    if(x >= 0):
        y = (x*x - 3*x)/(x+1) + 2*math.pi + math.sin(x)
    else:
        y = math.log(-5*x) + 6 * math.sqrt(abs(x) + math.exp(4)) - pow(x+1,3)
    
    print(y)
    

    条件运算语句:

    import math
    
    x = float(input("请输入x:"))
    y = ((x*x - 3*x)/(x+1) + 2*math.pi + math.sin(x)) if(x >= 0) \
    else (math.log(-5*x) + 6 * math.sqrt(abs(x) + math.exp(4)) - pow(x+1,3)) 
    
    print(y)
    

    运行一:

    请输入x:666
    668.2715406628656
    

    运行二:

    请输入x:-666
    294079794.1744833
    

    12. 编写程序,输入一元二次方程的3个系数a、b、c,求ax2+bx+c=0方程的解

    import math
    
    a = float(input("请输入系数a:"))
    b = float(input("请输入系数b:"))
    c = float(input("请输入系数c:"))
    
    delta = b*b -4*a*c
    
    if(a == 0):
        if(b == 0): print("无解")
        else: print("有一个实根:",-1*c/b)
    elif(delta == 0): print("有两个相等实根:x1 = x2 = ", (-1*b)/(2*a))
    elif(delta > 0): print("有两个不等实根:x1 = {0},x2 = {1}".format\
                           ((-1*b +math.sqrt(delta))/2*a,(-1*b -math.sqrt(delta))/2*a))
    elif(delta < 0): print("有两个共轭复根:x1 = {0},x2 = {1}".format\
                           (complex( (-1*b)/(2*a),math.sqrt(delta*-1)/(2*a)),complex( (-1*b)/(2*a),-1*math.sqrt(delta*-1)/(2*a))))
    

    运行一:

    请输入系数a:0
    请输入系数b:0
    请输入系数c:10
    无解
    

    运行二:

    请输入系数a:0
    请输入系数b:10
    请输入系数c:5
    有一个实根: -0.5
    

    运行三:

    请输入系数a:1
    请输入系数b:8
    请输入系数c:16
    有两个相等实根:x1 = x2 =  -4.0
    

    运行四:

    请输入系数a:1
    请输入系数b:-5
    请输入系数c:6
    有两个不等实根:x1 = 3.0,x2 = 2.0
    

    运行五:

    请输入系数a:5
    请输入系数b:2
    请输入系数c:1
    有两个共轭复根:x1 = (-0.2+0.4j),x2 = (-0.2-0.4j)
    

    13. 编写程序,输入整数n(n≥0),分别利用for循环和while循环求n!

    1. for循环
    n = int(input("请输入n:"))
    
    if(n == 0): total = 1
    if(n > 0):
        total = 1
        for i in range(n,0,-1):
            total *= i
    
    print(total)
    
    
    1. while循环
    n = int(input("请输入n:"))
    
    if(n == 0): total = 1
    if(n > 0):
        total = 1
        while(n >= 1):
            total *= n
            n -= 1
    
    print(total)
    
    1. 补充一个:使用累计迭代器itertools.accumulate
    >>> import itertools, operator
    >>> n = int(input('请输入n:'))
    请输入n:7
    >>> x = list(accumulate(range(1, n+1), operator.mul))
    >>> x[len(x)-1]
    5040
    

    14. 编写程序,产生两个0~100(包含0和100)的随机整数a和b,求这两个整数的最大公约数和最小公倍数

    1. 现有知识点解决方法
    
    import random
    
    a = random.randint(0,100)
    b = random.randint(0,100)
    sum = a*b
    
    print(a) #输出原来的a,b
    print(b)
    
    if(a < b): a,b = b,a
    
    while(a%b != 0):
        a,b = b,a%b
    
    print("最大公约数:{0},最小公倍数:{1}".format(b,sum/b))
    
    
    1. 补充:使用生成器(generate)函数:yield
    >>> def func(a, b):
    	if(a < b): a,b = b,a
    	while(a%b != 0):
    		a,b = b,a%b
    		yield b
    
    		
    >>> import random
    >>> if __name__ == '__main__':
    	a = random.randint(0,100)
    	b = random.randint(0,100)
    	sum = a*b
    	print(a,b)
    	t = list(iter(func(a, b)))
    	gcd = t[len(t)-1]
    	print("gcd = {0}, mcm = {1}".format(gcd, sum/gcd))
    
    	
    29 65
    gcd = 1, mcm = 1885.0
    
    1. 补充:使用math模块中的gcd(x,y)函数
    >>> import random
    >>> import math
    >>> if __name__ == '__main__':
    	a = random.randint(0,100)
    	b = random.randint(0,100)
    	sum = a*b
    	print(a,b)
    	gcd = math.gcd(a,b)
    	print("gcd = {0}, mcm = {1}".format(gcd, sum/gcd))
    
    	
    29 48
    gcd = 1, mcm = 1392.0
    

    案例研究:使用嵌套循环实现图像处理算法

    https://blog.csdn.net/Zhangguohao666/article/details/103935185

    通过图像处理算法案例,深入了解Python数据结构和基本算法流程

    第四章 常用内置数据类型


    几个例题

    一:Python内置数据类型概述

    Python中一切皆为对象,而每个对象属于某个数据类型

    Python的数据类型包括:

    1. 内置的数据类型
    2. 模块中定义的数据类型
    3. 用户自定义的类型

    四种内置的数值类型:int,float,bool,complex

    1. int
      与其他计算机语言有精度限制不同,Python中的整数位数可以为任意长度(只受限于计算机内存)。
      整型对象是不可变对象。
    2. float
      与其他计算机语言中的double和float对应
      Python的浮点类型的精度和系统相关
    3. bool
    4. complex
      当数值字符串中包含虚部j(或J)时即复数字面量

    序列数据类型:str,tuple,bytes,list,bytearray

    序列数据类型表示若干有序数据.

    不可变序列数据类型:

    1. str(字符串)
      表示Unicode字符序列,例如:“zgh666”
      在Python中没有独立的字符数据类型,字符即长度为1的字符串
    2. tuple(元组)
      表示任意数据类型的序列,例如:(“z”,“g”,“h”,6,6,6)
    3. bytes(字节序列)
      表示字节(8位)序列数据

    可变序列数据类型:

    1. list(列表)
      表示可以修改的任意类型数据的序列,比如:[‘z’,‘g’,‘h’,6,6,6]
    2. bytearray(字节数组)
      表示可以修改的字节(8位)数组

    集合数据类型:set,frozenset

    集合数据类型表示若干数据的集合,数据项目没有顺序,且不重复

    1. set(集)
      例如:{1,2,3}
    2. frozenset(不可变集)

    字典数据类型:dict

    字典数据类型用于表示键值对的字典
    例如:{1:"zgh", 2:666}

    NoneType,NotImplementedType,EllipsisType

    1. NoneType数据类型包含唯一值None,主要用于表示空值,如没有返回值的函数的结果
    2. NotImplementedType数据类型包含唯一值NotImplemented,在进行数值运算和比较运算时,如果对象不支持,则可能返回该值
    3. EllipsisType数据类型包含唯一值Ellipsis,表示省略字符串符号...

    其他数据类型

    Python中一切对象都有一个数据类型,模块、类、对象、函数都属于某种数据类型
    Python解释器包含内置类型,
    例如:
    代码对象Code objects
    框架对象Frame objects
    跟踪对象Traceback objects
    切片对象Slice objects
    静态方法对象Static method objects
    类方法对象Class method objects

    二:整型字面量示例

    Python3.7支持使用下划线作为整数或者浮点数的千分位标记,以增强大数值的可阅读性。
    二进制、八进制、十六进制则使用下划线区分4位标记

    1_000_000_000  #输出1000000000
    
    0xff_ff_ff_ff  #输出4294967295
    0x_FF_FF_FF_FF  #输出4294967295
    

    三:字符串字面量示例

    两个紧邻的字符串,如果中间只有空格分隔,则自动拼接位一个字符串

    'zgh' '666'  #输出'zgh666'
    'zgh' + "666"   #输出'zgh666'
    

    四:转义字符示例

    转义字符后跟Unicode编码也可以表示字符

    1. \ooo八进制Unicode码对应的字符
    2. \xhh十六进制Unicode码对应的字符
    '\101'  #输出'A'
    '\x41'  #输出'A'
    

    使用r’‘或者R’'的字符串称为原始字符串,其中包含的任何字符都不进行转义

    s = r'换\t行\t符\n'
    s  		  #输出:'换\\t行\\t符\\n'
    print(s)  #输出:换\\t行\\t符\\n
    

    五:字符串的格式化

    一:

    "student number:{0},score_average:{1}".format(2,100)
    #输出:'student number:2,score_average:100'
    

    二:

    str.format("student number:{0},score_average:{1}",2,100)
    #输出:'student number:2,score_average:100'
    

    三(兼容Python2的格式,不推荐使用):

     "student number:%4d,score_average:%2.1f" %(2,100)
     #输出:'student number:   2,score_average:100.0'
    

    六:字符串示例,格式化输出字符串堆积的三角形

    1. str.center()方法用于字符串两边填充
    2. str.rjust()方法用于字符串右填充
    print("1".center(20))		#一行20个字符,居中对齐
    print(format("121","^20"))	#一行20个字符,居中对齐
    print("1".rjust(20,"*"))	#一行20个字符,右对齐,加*
    print(format("121","*>20"))	#一行20个字符,右对齐,加*
    

    运行:

             1          
            121         
    *******************1
    *****************121
    

    选择题:11

    11. 关于Python字符串,下列说法错误的是

    A. 字符即长度为1的字符串
    B. 字符串以/0标识字符串的结束
    C. 用户既可以用单引号,也可以用双引号创建字符串
    D. 用三引号字符串中可以包含换行回车等特殊字符

    答案:B

    Python中字符串不是用\0来判断字符串结尾,
    每个字符串都存有字符串的长度,通过计数来判断是否到达结尾。

    虽然在c语言中\0就是来判断字符串的结尾;

    填空题:4、7、8、9、10、13、21

    4. Python表达式3 ** 2 ** 3的值为

    答案:6561

    表达式中,相同优先级的运算,从右往左

    7. Python语句print(pow(-3,2),round(18.67,1),round(18.67,-1))的输出结果是

    答案:9 18.7 20.0

    pow()幂运算
    round()四舍六入,五留双

    8. Python语句print(round(123.84,0),round(123.84,-2),floor(15.5))的输出结果是

    答案:124.0 100.0 15

    补充:floor()是math模块中的方法,向下取整

    9. Python语句print(int(‘20’,16),int(‘101’,2))的输出结果是

    答案:32 5

    注意:int(x,y)是指将y进制的数值x转化为10进制数

    10. Python语句print(hex(16),bin(10))的输出结果是

    答案:0x10 0b1010

    hex(x)将十进制数x转化为十六进制,以字符串形式输出
    bin(x)将十进制数x转化为二进制,以字符串形式输出

    13. Python语句print(gcd(12,16),divmod(7,3))的输出结果是

    答案:4 (2,1)

    gcd()是math模块中的函数,求最大公约数
    divmod()是内置函数,返回商和余数

    21. Python语句序列 x=True;y=False;z=False;print(x or y and z) 的运行结果是

    答案:True

    and优先级比or高

    思考题:5

    5. 阅读下面的Python程序,请问输出结果是什么?

    from decimal import *
    
    ctx = getcontext()
    ctx.prec = 2
    print(Decimal('1.78'))#1.78
    print(Decimal('1.78') + 0)#1.8
    ctx.rounding = ROUND_UP
    print(Decimal('1.65') + 0)#1.7
    print(Decimal('1.62') + 0)#1.7
    print(Decimal('-1.45') + 0)#-1.5
    print(Decimal('-1.42') + 0)#-1.5
    ctx.rounding = ROUND_HALF_UP
    print(Decimal('1.65') + 0)#1.7
    print(Decimal('1.62') + 0)#1.6
    print(Decimal('-1.45') + 0)#-1.5
    ctx.rounding = ROUND_HALF_DOWN
    print(Decimal('1.65') + 0)#1.6
    print(Decimal('-1.45') + 0)#-1.4
    

    上机实践:2~14

    2. 编写程序,格式化输出杨辉三角

    杨辉三角即二项式定理的系数表,各元素满足如下条件:第一列及对角线上的元素均为1;其余每个元素等于它上一行同一列元素与前一列元素之和

    我使用了一个更加精妙的规律
    比如第一行为1
    第二行:01 + 10 = 11
    第三行:011 + 110 = 121
    第四行:0121 + 1210 = 1331
    。。。

    def generate(numRows):
        l1 = [1]
        n = 0
        while n < numRows:
            print(str(l1).center(66))
            l1 = [sum(t) for t in zip([0] + l1, l1 + [0])]  #利用zip函数算出每一行 如第二行 zip([0,1],[1,0])=[1,1],以此类推
            n += 1
    a=int(input("请输入行数"))
    generate(a)
    

    运行:

    请输入行数4
                                   [1]                                
                                  [1, 1]                              
                                [1, 2, 1]                             
                               [1, 3, 3, 1]  
    

    3. 输入直角三角形的两个直角边,求三角形的周长和面积,以及两个锐角的度数。结果保留一位小数

    import math
    
    a = float(input("请输入直角三角形的直角边a:"))
    b = float(input("请输入直角三角形的直角边b:"))
    c = math.sqrt(a*a+b*b)
    
    p = a + b + c
    area = 0.5*a*b
    print("三角形的周长:{0:1.1f},面积:{1:1.1f}".format(p,area))
    
    sina = a/c
    sinb = b/c
    
    a_degree = round(math.asin(sina) * 180 / math.pi,0)
    b_degree = round(math.asin(sinb) * 180 / math.pi,0)
    
    print("三角形直角边a的度数:{0},b的度数:{1}".format(a_degree,b_degree))
    

    运行:

    请输入直角三角形的直角边a:3
    请输入直角三角形的直角边b:4
    三角形的周长:12.0,面积:6.0
    三角形直角边a的度数:37.0,b的度数:53.0
    

    4. 编程产生0~100(包含0和100)的三个随机数a、b、c,要求至少使用两种不同的方法,将三个数按从小到大的顺序排序

    方法一:

    import random
    
    a = random.randint(0, 100)
    b = random.randint(0, 100)
    c = random.randint(0, 100)
    
    print(str.format("原始值:{0},{1},{2}", a, b, c))
    
    if(a > b): a,b = b,a
    if(a > c): a,c = c,a
    if(b > c): b,c = c,b
    
    print(str.format("增序:{0},{1},{2}", a, b, c))
    

    方法二(使用内置函数max、min、sum):

    import random
    
    a = random.randint(0, 100)
    b = random.randint(0, 100)
    c = random.randint(0, 100)
    
    print(str.format("原始值:{0},{1},{2}", a, b, c))
    
    maxx = max(a, b, c)
    minx = min(a, b, c)
    median = sum([a, b, c]) - minx - maxx
    
    print(str.format("增序:{0},{1},{2}", minx, median, maxx))
    

    方法三(使用内置函数sorted):

    >>> import random
    >>> a = random.randint(0,100)
    >>> b = random.randint(0,100)
    >>> c = random.randint(0,100)
    >>> print("init value: {0} , {1} , {2}".format(a,b,c))
    init value: 17 , 6 , 59
    >>> sorted([a,b,c])
    [6, 17, 59]
    

    5. 编程计算有固定工资收入的党员每月所缴纳的党费。

    工资基数3000元及以下者,交纳工资基数的0.5%
    工资基数3000~5000元者,交纳工资基数的1%
    工资基数在5000~10000元者,交纳工资基数的1.5%
    工资基数超过10000元者,交纳工资基数的2%

    salary = float(input("请输入有固定工资收入的党员的月工资:"))
    if salary <= 3000: dues = salary*0.005
    elif salary <= 5000: dues = salary*0.01
    elif salary <= 10000: dues = salary*0.15
    else: dues = salary*0.02
    
    print("交纳党费:",dues)
    

    运行:

    请输入有固定工资收入的党员的月工资:10001
    交纳党费: 200.02
    

    6. 编程实现袖珍计算器,要求输入两个操作数和一个操作符(+、-、*、/、%),根据操作符输出运算结果。注意/和%运算符的零异常问题

    a = float(input("请输入操作数(左):"))
    b = float(input("请输入操作数(右):"))
    operator = input("请输入操作符(+、-、*、/、%):")
    
    if(b == 0 and (operator == '/' or operator == '%')):
        print("分母为零,异常!")
    else:
        if operator == '+': result = a+b
        elif operator == '-': result = a-b
        elif operator == '*': result = a*b
        elif operator == '/': result = a/b
        elif operator == '%': result = a%b
        print("{0} {1} {2}= {3}:".format(a,operator,b,result))
    

    运行:

    请输入操作数(左):10
    请输入操作数(右):5
    请输入操作符(+、-、*、/、%):+
    10.0 + 5.0= 15.0:
    

    7. 输入三角形的3条边a、b、c,判断此3边是否可以构成三角形。若能,进一步判断三角形的性质,即为等边、等腰、直角或其他三角形

    a = float(input("请输入三角形的边a:"))
    b = float(input("请输入三角形的边b:"))
    c = float(input("请输入三角形的边c:"))
    
    if(a > b): a,b = b,a
    if(a > c): a,c = c,a
    if(b > c): b,c = c,b
    
    result = "三角形"
    if(not(a>0 and b>0 and c>0 and a+b>c)):
        result = '此三边无法构成三角形'
    else:
        if a == b == c: result = '等边三角形'
        elif(a==b or a==c or b==c): result = '等腰三角形'
        elif(a*a+b*b == c*c): result = '直角三角形'
    
    print(result)
    

    运行:

    请输入三角形的边a:3
    请输入三角形的边b:4
    请输入三角形的边c:5
    直角三角形
    

    8. 编程实现鸡兔同笼问题

    已知在同一个笼子里共有h只鸡和兔,鸡和兔的总脚数为f,其中h和f由用户输入,求鸡和兔各有多少只?要求使用两种方法:一是求解方程;二是利用循环进行枚举测试

    h = int(input("请输入总头数:"))
    f = int(input("请输入总脚数:"))
    
    def fun1(h,f):
        rabbits = f/2-h
        chicken = h-rabbits
        if(chicken < 0 or rabbits < 0): return '无解'
        return chicken,rabbits
    
    def fun2(h,f):
        for i in range(0,h+1):
            if(2*i + 4*(h-i) == f):return i,h-i
        return '无解'
    
    if(h>0 and f>0 and f % 2 == 0):
        if fun1(h,f)=='无解':
            print("无解")
        else:
            print("方法一:鸡:{0},兔:{1}".format(fun1(h,f)[0],fun1(h,f)[1]))
            print("方法二:鸡:{0},兔:{1}".format(fun2(h,f)[0],fun2(h,f)[1]))
    else:
        print('输入的数据无意义')    
    

    运行:

    请输入总头数:100
    请输入总脚数:100
    无解
    

    9. 输入任意实数x,计算ex的近似值,直到最后一项的绝对值小于10-6为止

    ex = 1 + x + x2/2 + x3/3! + x4/4! + … + xn/n!

    x = int(input("请输入任意实数:"))
    
    e = 1
    i = 1
    t = 1
    a = 1
    while(a >= 10e-6):
        t *= i
        a = pow(x,i)/t
        e += a
        i += 1
    
    print(e)
    

    运行:

    请输入任意实数:1
    2.7182815255731922
    

    我发现了在Python中10e-6pow(10,-6)是有差别的,将上述代码中的10e-6改为pow(10,-6),输出结果会有细微的差别

    运行:

    请输入任意实数:1
    2.7182818011463845
    

    10. 输入任意实数a(a>=0),用迭代法求x=√a,要求计算的相对偏差小于10-6

    求平方根的公式:

    Xn+1 = 0.5(Xn + a/Xn)

    import math
    
    a = int(input("请输入任意实数a(>=0):"))
    
    x = a / 2
    y = (x + a/x) / 2
    
    while(abs(y-x) >= pow(10,-6)):
        x = y
        y = (x + a/x) / 2
    
    print(y)
    

    运行:

    请输入任意实数a(>=0):2
    1.414213562373095
    

    11. 即有一个数,用3除余2,用5除余3,用7除余2,请问0~1000中这样的数有哪些?

    我国古代有位大将,名叫韩信。他每次集合部队,只要求部下先后按1-3,1-5,1-7报数,然后再报告一下各队每次报数的余数,他就知道到了多少人。他的这种巧妙算法被人们称作“鬼谷算”,也叫“隔墙算”,或称为“韩信点兵”,外国人还称它为“中国余数定理”。

    for i in range(0,1001):
        if((i % 3 == 2 )and (i % 5 == 3) and (i % 7 == 2)): print(i, end="  ")
    

    运行:

    23  128  233  338  443  548  653  758  863  968
    

    12. 一球从100米的高度自由下落,每次落地后反弹回原高度的一半,再落下。求小球在第10次落地时共经过多少米?第10次反弹多高

    规律:
    第一次下落时的高度:100
    第二次下落时的高度(第一次反弹的高度):50
    第三次下落时的高度(第二次反弹的高度):25

    n = 10
    
    h_down = 100
    h_up = 0
    sum = 0
    for i in range(1,n+1):
        sum += h_down+h_up
        h_down = h_up = h_down/2
    
    print("小球在第十次落地时共经过:{0}米,第十次反弹高度:{1}米".format(sum,h_up))    
    

    运行:

    小球在第十次落地时共经过:299.609375米,第十次反弹高度:0.09765625米
    

    13. 猴子吃桃问题

    猴子第一天摘下若干个桃子,当天吃掉一半多一个;第二天接着吃了剩下的桃子的一半多一个;以后每天都吃了前一天剩下的桃子的一半多一个。到第八天发现只剩一个桃子了。请问猴子第一天共摘了多少个桃子?

    这是一个递推问题

    某天所剩桃子数x
    后一天所剩桃子数y = x - (x/2+1) = x/2-1

    则x = 2(y+1)

    result = 1
    for i in range(8,0,-1):
        print("第{0}天桃子数:{1}".format(i,result))
        result = 2*(result+1)
    

    运行:

    第8天桃子数:1
    第7天桃子数:4
    第6天桃子数:10
    第5天桃子数:22
    第4天桃子数:46
    第3天桃子数:94
    第2天桃子数:190
    第1天桃子数:382
    

    14. 计算Sn = 1+11+111+…+111…111(最后一项是n个1)。n是一个随机产生的1~10(包括1和10)中的正整数

    import random
    
    n = random.randint(1,10)
    
    x = 1
    s = 0
    for i in range(1,n+1):
        s += x
        x = 10*x+1
    
    print("n = {0},sn = {1}".format(n,s))
    

    运行:

    n = 6,sn = 123456
    

    random.randint(a, b)

    • 生成指定范围内的整数
    • 范围:[a, b]

    案例研究:科学计算和数据分析

    https://blog.csdn.net/Zhangguohao666/article/details/103941448

    通过Python科学计算和数据分析库的安装和基本使用,了解使用Python进行科学计算的基本方法

    第五章 序列数据类型


    几个例题

    一:Python中内置的序列数据类型

    • 元组也称为定值表,用于存储固定不变的表
    • 列表也称为表,用于存储其值可变的表
    • 字符串是包括若干字符的序列数据,支持序列数据的基本操作
    • 字节序列数据是包括若干字节的序列。Python抓取网页时返回的页面通常为utf-8编码的字节序列。

    字节序列和字符串可以直接相互转换(字节编码和解码):

    >>> s1 = b'abc'
    >>> s1
    b'abc'
    >>> s1.decode("utf-8")
    abc
    
    >>> s2 = "中国"
    >>> s2.encode("utf-8")
    b'\xe4\xb8\xad\xe5\x9b\xbd'
    

    二:序列的切片操作示例

    >>> s = 'zgh666'
    >>> s[0]
    'z'
    >>> s[2]
    'h'
    >>> s[:3]
    'zgh'
    >>> s[1:3]
    'gh'
    >>> s[3:6]
    '666'
    >>> s[3:55]
    '666'
    >>> s[::-1]
    '666hgz'
    >>> s[3:2]
    ''
    >>> s[:]
    'zgh666'
    >>> s[::2]
    'zh6'
    

    三:序列的连接和重复操作

    • 通过连接操作符+可以连接两个序列,形成一个新的序列对象
    • 通过重复操作符*可以重复一个序列n次
    • 连接操作符和重复操作符也支持复合赋值运算,即:+=*=
    >>> x = 'zgh'
    >>> y = '666'
    >>> x + y
    'zgh666'
    >>> x *2
    'zghzgh'
    >>> x += y
    >>> x
    'zgh666'
    >>> y *= 3
    >>> y
    '666666666'
    

    四:序列的成员关系操作

    • in
    • not in
    • s.count(x)
      x在s中出现的次数
    • s.index(x)
      x在s中第一次出现的下标
    >>> s = "zgh666"
    >>> 'z' in s
    True
    >>> 'g' not in s
    False
    >>> s.count('6')
    3
    >>> s.index('6')
    3
    

    五:序列的排序操作

    sorted(iterable,key=None,reverse=False)

    >>> sorted(s)
    [1, 3, 5, 9]
    >>> sorted(s,reverse=True)
    [9, 5, 3, 1]
    
    >>> s = 'zGhZgH'
    >>> sorted(s)
    ['G', 'H', 'Z', 'g', 'h', 'z']
    >>> sorted(s,key=str.lower)
    ['G', 'g', 'h', 'H', 'z', 'Z']
    >>> sorted(s,key=str.lower,reverse=True)
    ['z', 'Z', 'h', 'H', 'G', 'g']
    

    六:序列的拆分

    1. 变量个数与序列长度相等
      若变量个数与序列的元素个数不一致,将导致ValueError
    >>> data = (118,'zgh',(100,100,100))
    >>> sid,name,(chinese,english,math) = data
    >>> sid
    118
    >>> name
    'zgh'
    >>> chinese
    100
    >>> english
    100
    >>> math
    100
    
    1. 变量个数与序列长度不等
      如果序列长度未知,可以使用*元组变量,将多个值作为元组赋值给元组变量。在一个赋值语句中,*元组变量只允许出现一次,否则将导致SyntaxError
    >>> first,second,third,*middles,last = range(10)
    >>> first
    0
    >>> second
    1
    >>> third
    2
    >>> middles
    [3, 4, 5, 6, 7, 8]
    >>> last
    9
    
    >>> first,*middles,last = sorted([58,60,60,100,70,70])
    >>> sum(middles)/len(middles)
    65.0
    
    1. 使用临时变量_
      如果只需要部分数据,序列的其它位置可以使用临时变量_
    >>> record = ['zgh','858990471@qq.com','17354364147','15272502101']
    >>> name,_,*phone = record
    >>> name
    'zgh'
    >>> phone
    ['17354364147', '15272502101']
    

    七:使用元组字面量,tuple创建元组实例对象的实例

    >>> t1 = 1,2,3
    >>> t1
    (1, 2, 3)
    
    >>> t2 = (4,5,6)
    >>> t2
    (4, 5, 6)
    
    >>> t3 = (9,)
    >>> t3
    (9,)
    

    如果元组中只有一个项目,后面的逗号不能省略。

    Python解释器把(1)解释为整数1,将(1,)解释为元组

    >>> t1 = tuple()
    >>> t1
    ()
    
    >>> t2 = tuple("zgh666")
    >>> t2
    ('z', 'g', 'h', '6', '6', '6')
    
    >>> t3 = tuple(['z','g','h'])
    >>> t3
    ('z', 'g', 'h')
    

    八:使用列表字面量,list创建列表实例对象的实例

    >>> l1 = []
    >>> l1
    []
    
    >>> l2 = ['zgh666']
    >>> l2
    ['zgh666']
    
    >>> l3 = [(1,2,3)]
    >>> l3
    [(1, 2, 3)]
    
    >>> l1 = list()
    >>> l1
    []
    
    >>> l2 = list(b'zgh666')
    >>> l2
    [122, 103, 104, 54, 54, 54]
    
    >>> l3 = list(b'aAbBcC')
    >>> l3
    [97, 65, 98, 66, 99, 67]
    

    补充:列表是可变对象,故用户可以改变列表对象中元素的值,也可以通过del删除某元素

    九:列表解析表达式示例

    使用列表解析表达式可以简单,高效地处理一个可迭代对象,并生成结果列表

    >>> [(i,i**2) for i in range(10)]
    [(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25), (6, 36), (7, 49), (8, 64), (9, 81)]
    
    >>> [i for i in range(10) if i%2==0]
    [0, 2, 4, 6, 8]
    
    >>> [(x,y,x*y) for x in range(1,4) for y in range(1,4) if x>=y]
    [(1, 1, 1), (2, 1, 2), (2, 2, 4), (3, 1, 3), (3, 2, 6), (3, 3, 9)]
    

    选择题:4、5、7、11、12

    4. Python语句序列“a = (1,2,3,None,(),[]);print(len(a))”的运行结果是

    >>> a = (1,2,3,None,(),[])
    >>> len(a)
    6
    

    5. Python语句序列“nums = set([1,2,2,3,3,3,4]);print(len(nums))”的运行结果是

    >>> nums = set([1,2,2,3,3,3,4])
    >>> nums
    {1, 2, 3, 4}
    >>> len(nums)
    4
    

    7. Python语句序列“s1=[4,5,6];s2=s1;s1[1]=0;print(s2)”的运行结果是

    Python中变量(如s1,s2)存储在栈中,存放的是地址
    [4,5,6]存储在堆中

    s1 = [4,5,6]即s1存储指向堆中[4,5,6]的地址
    s2 = s1地址赋值,即s2和s1都指向同一个地址
    所以对列表进行修改,两者的显示都会发生变化

    >>> s1 = [4,5,6]
    >>> s2 = s1
    >>> s1[1] = 0
    >>> s1
    [4, 0, 6]
    >>> s2
    [4, 0, 6]
    

    11. Python语句序列“s={‘a’,1,‘b’,2};print(s[‘b’])”的运行结果是

    A. 语法错B. ‘b’C. 1D. 2

    答案:A

    通过值访问集合是没有意义的,语法也不支持

    >>> s ={'a',1,'b',2}
    >>> print(s['b'])
    Traceback (most recent call last):
      File "<pyshell#29>", line 1, in <module>
        print(s['b'])
    TypeError: 'set' object is not subscriptable
    

    补充:集合set是无序不重复的,是无法通过下标访问的

    12. Python语句print(r"\nGood")的运行结果是

    A. 新行和字符串GoodB. r"\nGood"C. \nGoodD. 字符r、新行和字符串Good

    答案:C

    >>> print(r"\nGood")
    \nGood
    

    r""声明原始字符串

    填空题:1、5、6、12、13、14

    1. Python语句序列“fruits = [‘apple’,‘banana’,‘bear’];print(fruits[-1][-1])”的运行结果是

    注意:fruit[-1]是字符串’bear’
    所以:fruit[-1][-1]'bear[-1]'

    >>> fruits = ['apple','banana','pear']
    >>> fruits[-1]
    'pear'
    >>> fruits[-1][-1]
    'r'
    

    5. Python语句 print(’%d%%%d’%(3/2,3%2)) 的运行结果是

    >>> print('%d%%%d'%(3/2,3%2))
    1%1
    

    6. Python语句序列“s = [1,2,3,4];s.append([5,6]);print(len(s))”的运行结果是

    答案:5

    注意append()和extend()函数的区别
    s.append(x)将对象x追加到s尾部
    s.extend(x)将序列x追加到s尾部

    append

    >>> s = [1,2,3,4]
    >>> s.append([5,6])
    >>> s
    [1, 2, 3, 4, [5, 6]]
    >>> len(s)
    5
    

    extend

    >>> s = [1,2,3,4]
    >>> s.extend([5,6])
    >>> s
    [1, 2, 3, 4, 5, 6]
    >>> len(s)
    6
    

    12

    >>> s =('a','b','c','d','e')
    >>> s[2]
    'c'
    >>> s[2:3]
    ('c',)
    >>> s[2:4]
    ('c', 'd')
    >>> s[1::2]
    ('b', 'd')
    >>> s[-2]
    'd'
    >>> s[::-1]
    ('e', 'd', 'c', 'b', 'a')
    >>> s[-2:-1]
    ('d',)
    >>> s[-99:-5]
    ()
    >>> s[-99:-3]
    ('a', 'b')
    >>> s[::]
    ('a', 'b', 'c', 'd', 'e')
    >>> s[1:-1]
    ('b', 'c', 'd')
    

    13

    >>> s = [1,2,3,4,5,6]
    >>> s[:1] = []
    >>> s
    [2, 3, 4, 5, 6]
    
    >>> s[:2] = 'a'
    >>> s
    ['a', 4, 5, 6]
    
    >>> s[2:] = 'b'
    >>> s
    ['a', 4, 'b']
    
    >>> s[2:3] = ['x','y']
    >>> s
    ['a', 4, 'x', 'y']
    
    >>> del s[:1]
    >>> s
    [4, 'x', 'y']
    

    14

    >>> s = ['a','b']
    >>> s.append([1,2])
    >>> s
    ['a', 'b', [1, 2]]
    >>> s.extend('34')
    >>> s
    ['a', 'b', [1, 2], '3', '4']
    >>> s.extend([5,6])
    >>> s
    ['a', 'b', [1, 2], '3', '4', 5, 6]
    >>> s.insert(1,7)
    >>> s
    ['a', 7, 'b', [1, 2], '3', '4', 5, 6]
    >>> s.insert(10,8)
    >>> s
    ['a', 7, 'b', [1, 2], '3', '4', 5, 6, 8]
    >>> s
    ['a', 7, 'b', [1, 2], '3', '4', 5, 6]
    >>> s.remove('b')
    >>> s
    ['a', 7, [1, 2], '3', '4', 5, 6]
    >>> s[3:] =[]
    >>> s
    ['a', 7, [1, 2]]
    >>> s.reverse()
    >>> s
    [[1, 2], 7, 'a']
    >>> 
    

    思考题:2、3、5

    2. 阅读下面的Python语句,请问输出结果是什么?

    n = int(input('请输入图形的行数:'))
    
    for i in range(n,0,-1):
        print(" ".rjust(20-i),end=' ')
        for j in range(2*i-1):print(" * ",end=' ')
        print('\n')
    
    for i in range(1,n):
        print(" ".rjust(19-i),end=' ')
        for j in range(2*i+1):print(" * ",end=' ')
        print('\n')          
    

    运行一:

    请输入图形的行数:1
                         *  
    

    运行二:

    请输入图形的行数:2
                        *   *   *  
    
                         *  
    
                        *   *   *  
    

    运行三:

    请输入图形的行数:3
                       *   *   *   *   *  
    
                        *   *   *  
    
                         *  
    
                        *   *   *  
    
                       *   *   *   *   *  
    

    3. 阅读下面的Python语句,请问输出结果是什么?

    n = int(input('请输入上(或下)三角行数:'))
    
    for i in range(0,n):
        print(" ".rjust(19-i),end=' ')
        for j in range(2*i+1):print(" * ",end=' ')
        print('\n')
    
    for i in range(n-1,0,-1):
        print(" ".rjust(20-i),end=' ')
        for j in range(2*i-1):print(" * ",end=' ')
        print('\n')          
    

    运行:

    请输入上(或下)三角行数:4
                         *  
    
                        *   *   *  
    
                       *   *   *   *   *  
    
                      *   *   *   *   *   *   *  
    
                       *   *   *   *   *  
    
                        *   *   *  
    
                         *  
    

    5. 阅读下面的Python语句,请问输出结果是什么?

    先看这三句:

    >>> names1 = ['Amy','Bob','Charlie','Daling']
    >>> names2 = names1
    >>> names3 = names1[:]
    

    毫无疑问,此时names1,names2,names3的值都是[‘Amy’,‘Bob’,‘Charlie’,‘Daling’]
    但是

    >>> id(names1)
    2338529391368
    >>> id(names2)
    2338529391368
    >>> id(names3)
    2338529391560
    

    names1和names2指向同一个地址
    而names3指向另一个地址

    然后:

    >>> names2[0] = 'Alice'
    >>> names3[1] = 'Ben'
    >>> names1
    ['Alice', 'Bob', 'Charlie', 'Daling']
    >>> names2
    ['Alice', 'Bob', 'Charlie', 'Daling']
    >>> names3
    ['Amy', 'Ben', 'Charlie', 'Daling']
    

    最后:

    >>> sum = 0
    >>> for ls in(names1,names2,names3):
    	if ls[0] == 'Alice': sum+=1
    	if ls[1] == 'Ben':sum+=2
    
    	
    >>> print(sum)
    4
    

    上机实践:2~6

    2. 统计所输入字符串中单词的个数,单词之间用空格分隔

    s = input("请输入字符串:")
    
    num = 0
    for i in s:
        if((i >= 'a' and i <= 'z') or (i >= 'A' and i <= 'Z')):
            num += 1
    
    print("其中的单词总数:",num) 
    

    运行:

    请输入字符串:zgh666 ZGH6
    其中的单词总数: 6
    

    3. 编写程序,删除一个list里面重复元素

    方法一:利用set集合不重复的性质(但结果不能保证原来的顺序)

    l = [1,2,2,3,3,3,4,5,6,6,6]
    s = set(l)
    l = list(s)
    print(l)
    

    运行:

    [1, 2, 3, 4, 5, 6]
    

    方法二:既可以去除重复项,又可以保证原来的顺序

    def unique(items):
        items_existed = set()
        for item in items:
            if item not in items_existed:
                yield item
                items_existed.add(item)
    
    if __name__ == '__main__':
        a = [1, 8, 5, 1, 9, 2, 1, 10]
        a1 = unique(a)
        print(list(a1))
    
    

    运行结果:

    [1, 8, 5, 9, 2, 10]
    

    对代码的分析:

    • 可以看出,unique()函数返回的并不是items_existed,而是利用了yield

    在函数定义中,如果使用yield语句代替return返回一个值,则定义了一个生成器函数(generator)
    生成器函数是一个迭代器,是可迭代对象,支持迭代

    • a1 = unique(a) 这个函数返回的实际上是一个可迭代对象
      print(a1)得到的会是:<generator object unique at 0x0000016E23AF4F48>
    • 所以,要得到去掉重复后的列表的样子,需要将可迭代对象a1放在list()中
      运行:

    4. 编写程序,求列表[9,7,8,3,2,1,55,6]中的元素个数、最大值、最小值,以及元素之和、平均值。请思考有几种实现方法?

    内置函数:

    s = [9,7,8,3,2,1,55,6]
    
    print("元素个数:{0},最大值:{1},最小值:{2},和:{3},平均值:{4}".\
          format(len(s),max(s),min(s),sum(s),sum(s)/len(s)))
    

    直接访问元素列表(for i in s…):

    s = [9,7,8,3,2,1,55,6]
    
    sum = 0
    max = s[0]
    min = s[0]
    length = 0
    for i in s:
        sum += i
        length += 1
        if(i > max): max = i
        if(i < min): min = i
    
    print("元素个数:{0},最大值:{1},最小值:{2},和:{3},平均值:{4}".\
          format(length,max,min,sum,sum/length))
    
    

    间接访问列表元素(for i in range(0,len(s))…):

    s = [9,7,8,3,2,1,55,6]
    
    sum = 0
    max = s[0]
    min = s[0]
    length = len(s)
    for i in range(0,length):
        sum += s[i]
        if(s[i] > max): max = s[i]
        if(s[i] < min): min = s[i]
    
    print("元素个数:{0},最大值:{1},最小值:{2},和:{3},平均值:{4}".\
          format(length,max,min,sum,sum/length))
    
    

    正序访问(i=0;while i<len(s)…):

    s = [9,7,8,3,2,1,55,6]
    
    sum = 0
    max = s[0]
    min = s[0]
    length = len(s)
    
    i = 0
    while(i < length):
        sum += s[i]
        if(s[i] > max): max = s[i]
        if(s[i] < min): min = s[i]
        i += 1
    
    print("元素个数:{0},最大值:{1},最小值:{2},和:{3},平均值:{4}".\
          format(length,max,min,sum,sum/length))
    
    

    反序访问(i=len(s)-1;while i>=0…):

    s = [9,7,8,3,2,1,55,6]
    
    sum = 0
    max = s[0]
    min = s[0]
    length = len(s)
    
    i = length-1
    while(i >= 0):
        sum += s[i]
        if(s[i] > max): max = s[i]
        if(s[i] < min): min = s[i]
        i -= 1
    
    print("元素个数:{0},最大值:{1},最小值:{2},和:{3},平均值:{4}".\
          format(length,max,min,sum,sum/length))
    
    

    while True:…break

    s = [9,7,8,3,2,1,55,6]
    
    sum = 0
    max = s[0]
    min = s[0]
    length = len(s)
    
    i = 0
    while(True):
        if(i > length-1): break
        sum += s[i]
        if(s[i] > max): max = s[i]
        if(s[i] < min): min = s[i]
        i += 1
    
    print("元素个数:{0},最大值:{1},最小值:{2},和:{3},平均值:{4}".\
          format(length,max,min,sum,sum/length))
    

    运行:

    元素个数:8,最大值:55,最小值:1,和:91,平均值:11.375
    

    5. 编写程序,将列表[9,7,8,3,2,1,5,6]中的偶数变成它的平方,奇数保持不变

    l = [9,7,8,3,2,1,5,6]
    
    for i,value in enumerate(l):
        if(value % 2 == 0):l[i] = value**2
    
    print(l)
    

    运行:

    [9, 7, 64, 3, 4, 1, 5, 36]
    

    6. 编写程序,输入字符串,将其每个字符的ASCII码形成列表并输出

    s = input("请输入一个字符串:")
    l = list()
    for i in s:
        l.append(ord(i))
    
    print(l)
    

    运行:

    请输入一个字符串:zgh666
    [122, 103, 104, 54, 54, 54]
    

    案例研究:猜单词游戏

    https://blog.csdn.net/Zhangguohao666/article/details/103948234

    通过猜单词游戏的设计和实现,帮助读者了解使用Python系列数据类型和控制流程

    第六章 输入和输出


    几个例题

    一:运行时提示输入密码

    输入密码时,一般需要不明显,则可以使用模块getpass,以保证用户输入的密码在控制台中不回显

    import getpass
    
    username = input("user:")
    password = getpass.getpass("password:")
    if(username == 'zgh' and password == '666'):
        print('logined!')
    else:
        print('failed!')
    
    input()#为了看到输出结果。因为执行完毕后,控制台会立马关闭
    

    注意:上面这个代码,如果使用IDLE执行,会因为安全问题而执行失败

    但是,在控制台中执行就没问题,看输出结果(可以看到,输入的密码不会显示出来):

    user:zgh
    password:
    logined!
    

    二:重定向标准输出到一个文件的示例

    这种重定向由控制台完成,而与Python本身无关。

    格式:
    程序 > 输出文件

    其目的是将显示屏从标准输出中分离,并将输出文件与标准输出关联,即程序的执行结果将写入输出文件,而不是发送到显示屏中显示

    首先准备一个test.py文件(代码如下)

    import sys,random
    
    n = int(sys.argv[1])
    for i in range(n):
        print(random.randrange(0,100))
    

    然后在PowerShell中:python test.py 100 > scores.txt
    记住,切记,一定要注意:千万能省略python,这样写./test.py 100 > scores.txt会出现问题,生成的scores文件中会没有任何内容!!!(原因未知)

    然后在当前目录下,100个[0,100)范围内的的整数生成在scores.txt文件中了

    三:重定向文件到标准输入

    格式:
    程序 < 输入文件

    其目的是将控制台键盘从标准输入中分离,并将输入文件与标准输入关联,即程序从输入文件中读取输入数据,而不是从键盘中读取输入数据

    准备一个average.py文件(代码如下)

    import sys
    
    total =0.0
    count = 0
    for line in sys.stdin:
        count += 1
        total += float(line)
    
    avg = total/count
    print("average:",avg)
    

    然后问题总是不期而至,
    在PowerShell中:python average.py < scores.txt,会报错,PowerShell会提示你:“<”运算符是为将来使用而保留的
    很无奈,我只能使用cmd了,然后得出结果

    四:管道

    格式:
    程序1 | 程序2 | 程序3 | … | 程序4

    其目的是将程序1的标准输出连接到程序2的标准输入,
    将程序2的标准输出连接到程序3的标准输入,以此类推

    例如:
    打开cmd,输入python test.py 100 | average.py,其执行结果等同于上面两个例子中的命令

    使用管道更加简洁,且不用创建中间文件,从而消除了输入流和输出流可以处理的数据大小的限制,执行效率更高

    五:过滤器

    1. 使用操作系统实用程序more逐屏显示数据

    2. 使用操作系统实用程序sort排序输出数据

    more和sort都可以在一个语句中使用

    填空题:1、2

    print(value, ..., sep = ' ', end = '\n', file = sys.stdout, flush = False)

    1. sep(分隔符,默认为空格)
    2. end(换行符,即输入的末尾是个啥)
    3. file(写入到指定文件流,默认为控制台sys.stdout)
    4. flush(指定是否强制写入到流)

    1

    >>> print(1,2,3,4,5,sep='-',end='!')
    1-2-3-4-5!
    

    2

    >>> for i in range(10):
    	print(i,end=' ')
    
    	
    0 1 2 3 4 5 6 7 8 9 
    

    例题及上机实践:2~5

    2. 尝试修改例6.2编写的命令行参数解析的程序,解析命令行参数所输入边长的值,计算并输出正方形的周长和面积

    argparse模块用于解析命名的命令行参数,生成帮助信息的Python标准模块

    例6.2:解析命令行参数所输入的长和宽的值,计算并输出长方形的面积

    import argparse
    
    parser = argparse.ArgumentParser()
    parser.add_argument('--length', default = 10, type = int, help = '长度')
    parser.add_argument('--width', default = 5, type = int, help = '宽度')
    
    args = parser.parse_args()
    area = args.length * args.width
    print('面积 = ', area)
    
    input()#加这一句是为了可以看到输出结果
    

    输出:面积 = 50

    如果在执行这个模块时,加入两个命令行参数

    输出:面积 = 36

    基本上看了上面这个例子后,就可以理解argparse的用法了

    本题代码:

    import argparse
    
    parser = argparse.ArgumentParser()
    parser.add_argument('--length', default = 10, type = int, help = '长度')
    
    args = parser.parse_args()
    area = args.length ** 2
    perimeter = 4 * args.length
    print('面积 = {0},周长 = {1}'.format(area,perimeter))
    
    input()#加这一句是为了可以看到输出结果
    
    

    在PowerShell中输入.\test.py
    不给命令行参数,输出是以默认值来计算的
    输出:面积 = 100,周长 = 40

    给命令行参数:.\test.py --length 1
    输出:面积 = 1,周长 = 4

    3. 尝试修改例6.8编写读取并输出文本文件的程序,由命令行第一个参数确认所需输出的文本文件名

    f = open(file, mode = 'r' , buffering = -1, encoding = None)

    1. file是要打开或创建的文件名,如果文件不在当前路径,需指出具体路径
    2. mode是打开文件的模式,模式有:
      ‘r’(只读)
      ‘w’(写入,写入前删除就内容)
      ‘x’(创建新文件,如果文件存在,则导致FileExistsError)
      ‘a’(追加)
      ‘b’(二进制文件)
      ‘t’(文本文件,默认值)
      ‘+’(更新,读写)
    3. buffering表示是否使用缓存(缓存为-1,表示使用系统默认的缓冲区大小)
    4. encoding是文件的编码

    例6.8:读取并输出文本文件

    import sys
    
    filename = sys.argv[0]#就读取本文件,骚的呀皮
    f = open(filename, 'r', encoding = 'utf-8')
    
    line_no = 0
    while True:
        line_no += 1
        line = f.readline()
        if line:
            print(line_no, ":", line)
        else:
            break
    f.close()       
    

    输出(代码输出的就是本python文件):

    1 : import sys
    
    2 : 
    
    3 : filename = sys.argv[0]#就读取本文件,骚的呀皮
    
    4 : f = open(filename, 'r', encoding = 'utf-8')
    
    5 : 
    
    6 : line_no = 0
    
    7 : while True:
    
    8 :     line_no += 1
    
    9 :     line = f.readline()
    
    10 :     if line:
    
    11 :         print(line_no, ":", line)
    
    12 :     else:
    
    13 :         break
    
    14 : f.close()
    
    15 :         
    
    

    本题代码:

    对例题代码进行些许修改就可以了,首先将上例中的第二个语句改为:filename = sys.argv[0],再考虑下面怎么进行

    准备一个用来测试的文件test.txt:

    对于这个文件要注意一点(你们很可能回出现这个问题!!!),win10默认创建的文本文件的字符编码是ANSI

    代码怎么写,有两种:

    1. 将test.txt文本文件的编码修改为utf-8,代码如上所说
      记事本方式打开test.txt文件,点击文件,点击另存为,看到下方的编码(修改为utf-8)
    2. test.txt就用默认的ANSI编码方式,再将上例代码的第三个语句修改为f = open(filename, 'r', encoding = 'ANSI')

    在PowerShell中输入:./test.py test.txt
    输出:

    1 : 大家好
    
    2 : 我是Zhangguohao666
    
    3 : 如果本文章对大家有帮助,请点赞支持一下
    
    4 : 还有:
    
    5 : 如果发现了什么问题,请在评论区指出,我会积极改进
    

    4. 尝试修改例6.9编写利用with语句读取并输出文本文件的程序,由命令行第一个参数确认所需输出的文本文件名

    为了简化操作,Python语言中与资源相关的对象可以实现上下文管理协议,可以使用with语句,确保释放资源。
    with open(file,mode) as f:

    例6.9:利用with语句读取并输出文本文件

    import sys
    
    filename = sys.argv[0]
    
    line_no = 0
    with open(filename, 'r', encoding = 'utf-8') as f:
        for line in f:
            line_no += 1
            print(line_no, ":", line)
    f.close()
    

    基本上,看这个例子,就可以上手with语句了

    本题代码:

    还是上一题准备的文本文件,
    代码一(文本文件的编码为默认的ANSI):

    import sys
    
    filename = sys.argv[1]
    
    line_no = 0
    with open(filename, 'r', encoding = 'ANSI') as f:
        for line in f:
            line_no += 1
            print(line_no, ":", line)
    f.close()
          
    

    代码二(将文本文件的编码修改为utf-8):

    import sys
    
    filename = sys.argv[1]
    
    line_no = 0
    with open(filename, 'r', encoding = 'utf-8') as f:
        for line in f:
            line_no += 1
            print(line_no, ":", line)
    f.close()
          
    
    

    本题的输出,我再不要脸的放一次吧:

    1 : 大家好
    
    2 : 我是Zhangguohao666
    
    3 : 如果本文章对大家有帮助,请点赞支持一下
    
    4 : 还有:
    
    5 : 如果发现了什么问题,请在评论区指出,我会积极改进
    

    5. 尝试修改例6.12编写标准输出流重定向的程序,从命令行第一个参数中获取n的值,然后将0-n,0-n的2倍值,2的0-n次幂的列表打印输出到out.log文件中

    例6.12:从命令行第一个参数中获取n的值,然后将0-n,2的0-n次幂的列表打印输出到out.log文件中

    1. 标准输入流文件对象:sys.stdin,
      默认值为sys.__stdin__
    2. 标准输出流文件对象:sys.stdout,
      默认值为sys.__stdout__
    3. 错误输出流文件对象(标准错误流文件对象):sys.stderr
      默认值为sys.__stderr__

    书中给的代码是这样的:

    import sys
    
    n = int(sys.argv[1])
    power = 1
    i = 0
    
    f = open('out.log', 'w')
    sys.stdout = f
    
    while i <= n:
        print(str(i), ' ', str(power))
        power = 2*power
        i += 1
    sys.stdout = sys.__stdout__
    

    如果使用的编辑器是PyCharm(现在大多数编辑器会帮你对代码进行优化和处理一些隐患),运行书中的这个代码没有问题。

    但是:
    若使用的编辑器是python自带的IDLE,运行这个代码有问题!

    第一:out.log文件会生成,但是没有东西
    (发现文件关闭不了(就是×不掉),
    确定是文件没关闭(f.close())的原因)

    第二:控制台没有输出’done’语句(估计是IDLE编辑器处理不了__stdout__这个值)

    经过研究后,发现(基于IDLE编辑器):
    如果在上面的代码中加入f.close()后,该输入的东西都成功输入进out.log文件了,
    但是,
    还有一个问题
    控制台依旧没有输出’done’语句
    经过一步步的断点调试(就是手动写print)
    发现sys.stdout = sys.__stdout__不会执行

    然后进行改动后,就可以了,代码如下:
    (既然__stdout__不好使,就使用中间变量)

    import sys
    
    n = int(sys.argv[1])
    power = 1
    i = 0
    
    output = sys.stdout
    f = open('out.log', 'w')
    sys.stdout = f
    
    while i <= n:
        print(str(i), ' ', str(power))
        power = 2*power
        i += 1
    
    f.close()
    sys.stdout = output
    print('done!')#这一句是用来检测上面的代码是否成功执行
    
    

    问题虽然解决,但是原因没有彻底弄清楚,求助。。。。。。

    本题代码:

    import sys
    
    n = int(sys.argv[1])
    power = 1
    i = 0
    
    output = sys.stdout
    f = open('out.log', 'w')
    sys.stdout = f
    
    while i <= n:
        print(str(i), ' ',  str(2*i),  ' ', str(power))
        power = 2*power
        i += 1
    
    f.close()
    sys.stdout = output
    print('done!')#这一句是用来检测上面的代码是否成功执行
    
    

    比如时输入的命令行参数是6
    输出:

    案例研究:21点扑克牌游戏

    https://blog.csdn.net/Zhangguohao666/article/details/103948545

    通过21点扑克牌游戏的设计和实现,了解使用Python数据类型、控制流程和输入输出

    第七章 错误和异常处理


    Python语言采用结构化的异常处理机制捕获和处理异常

    而我感觉,Python在这方面的知识点其实和Java的差不多

    几个例题

    一:程序的错误和异常处理

    1. 语法错误

    指源代码中的拼写错误,这些错误导致Python编译器无法把Python源代码转换为字节码,故也称之为编译错误

    1. 运行时错误

    在解释执行过程中产生的错误

    例如:

    • 程序中没有导入相关的模块,NameError
    • 程序中包括零除运算,ZeroDivisionError
    • 程序中试图打开不存在的文件,FileNotFoundError
    1. 逻辑错误

    程序可以执行(程序运行本身不报错),但执行结果不正确。
    对于逻辑错误,Python解释器无能为力,需要用户根据结果来调试判断

    大部分由程序错误而产生的错误和异常一般由Python虚拟机自动抛出。另外,在程序中如果判断某种错误情况,可以创建相应的异常类的对象,并通过raise语句抛出

    >>> a = -1
    >>> if(a < 0): raise ValueError("数值不能为负数")
    
    Traceback (most recent call last):
      File "<pyshell#9>", line 1, in <module>
        if(a < 0): raise ValueError("数值不能为负数")
    ValueError: 数值不能为负数
    >>> 
    

    在程序中的某个方法抛出异常后,Python虚拟机通过调用堆栈查找相应的异常捕获程序。如果找到匹配的异常捕获程序(即调用堆栈中的某函数使用try…except语句捕获处理),则执行相应的处理程序(try…except语句中匹配的except语句块)

    如果堆栈中没有匹配的异常捕获程序,则Python虚拟机捕获处理异常,在控制台打印出异常的错误信息和调用堆栈,并中止程序的执行

    二:try …except…else…finally

    try:
    	可能产生异常的语句
    except Exception1:
    	发生Exception1时执行的语句
    except (Exception2,Exception3):
    	发生Exception2或Exception3时执行的语句
    except Exception4 as e:
    	发生Exception4时执行的语句,Exception4的实例是e
    except:
    	捕获其他所有异常
    else:
    	无异常时执行的语句
    finally:
    	不管异常发生与否都保证执行的语句			
    

    except语句可以写多个,但是要注意一点:系统是自上而下匹配发生的异常,所以用户需要将带有最具体的(即派生类程度最高的)异常类的except写在前面

    三:创建自定义异常,处理应用程序中出现的负数参数的异常

    自定义异常类一般继承于Exception或其子类。自定义异常类的名称一般以Error或Exception为后缀

    >>> class NumberError(Exception):
        def __init__(self,data):
            Exception.__init__
            (self,data)
            self.data = data
        def __str__(self):
            return self.data + ':非法数值(<0)'
    
    >>> 
    >>> def total(data):
        total = 0
        for i in data:
            if i < 0: raise NumberError(str(i))
            total += 1
        return total
    
    >>> 
    >>> data1 = (44, 78, 90, 80, 55)
    >>> print("sum: ",total(data1))
    sum:  5
    >>> 
    >>> data2 = (44, 78, 90, 80, -1)
    >>> print("sum: ",total(data2))
    Traceback (most recent call last):
      File "<pyshell#24>", line 1, in <module>
        print("sum: ",total(data2))
      File "<pyshell#18>", line 4, in total
        if i < 0: raise NumberError(str(i))
    NumberError: -1:非法数值(<0>>> 
    

    四:断言处理

    用户在编写程序时,在调试阶段往往需要判断代码执行过程中变量的值等信息:

    1. 用户可以使用print()函数打印输出结果
    2. 也可以通过断点跟踪调试查看变量
    3. 但使用断言更加灵活

    assert语句和AssertionError

    断言的声明:

    • assert <布尔表达式>
      即:if __debug__: if not testexpression: raise AssertionError
    • assert <布尔表达式>,<字符串表达式>
      即:if __debug__: if not testexpression: raise AssertionError(data)
      字符串表达式(即data)是断言失败时输出的失败消息

    __debug__也是布尔值,Python解释器有两种:调试模式和优化模式

    • 调试模式:__debug__ == True
    • 优化模式:__debug__ == False

    在学习中,对于执行一个py模块(比如test.py)我们通常在cmd中这么输入python test.py,而这默认是调试模式。
    如果我们要使用优化模式来禁用断言来提高程序效率,我们可以加一个运行选项-O,在控制台中这么输入python -O test.py

    看一下断言的示例吧,理解一下用法:

    a =int(input("a: "))
    b =int(input("b: "))
    assert b != 0, '除数不能为零'
    c = a/b
    print("a/b = ", c)
    

    cmd出场:
    输入正确数值时:

    输入错误数值时:

    禁用断言,并且输入错误数值时:

    案例研究:使用调试器调试Python程序

    https://blog.csdn.net/Zhangguohao666/article/details/103948568

    了解使用Python调试器调试程序的方法

    第八章 函数和函数式编程


    一些知识点总结和几个例题

    Python中函数的分类:

    1. 内置函数
      在程序中可以直接使用
    2. 标准库函数
      Python语言安装程序同时会安装若干标准库,例如math、random等
    3. 第三方库函数
      Python社区提供了许多其它高质量的库,在下载、安装这些库后,通过import语句可以导入库
    4. 用户自定义函数
    • 函数名为有效的标识符(命名规则为全小写字母,可以使用下划线增加可阅读性,例如my_func()
    • 函数可以使用return返回值
      如果函数体中包含return语句,则返回值
      否则不返回,即返回值为空(None),无返回值的函数相当于其它编程语言中的过程

    调用函数之前程序必须先执行def语句,创建函数对象

    • 内置函数对象会自动创建
    • import导入模块时会执行模块中的def语句,创建模块中定义的函数
    • Python程序结构顺序通常为import语句>函数定义>全局代码

    一:产生副作用的函数,纯函数

    打印等腰三角形

    n = int(input("行数:"))
    
    def print_star(n):
        print((" * " * n).center(50))
    
    for i in range(1, 2*n, 2):
        print_star(i)
    

    输出:

    行数:5
                            *                         
                         *  *  *                      
                      *  *  *  *  *                   
                   *  *  *  *  *  *  *                
                *  *  *  *  *  *  *  *  *             
    

    上面代码中的print_star()是一个产生副作用的函数,其副作用是向标准输出写入若干星号

    • 副作用:例如读取键盘输入,产生输出,改变系统的状态等
    • 在一般情况下,产生副作用的函数相当于其它程序设计语言中的过程,可以省略return语句

    定义计算并返回第n阶调和数(1+1/2+1/3+…+1/n)的函数,输出前n个调和数

    def harmonic(n):
        total = 0.0
        for i in range(1, n+1):
            total += 1.0/i
        return total
    
    n = int(input("n:"))
    
    print("输出前n个调和数的值:")
    for i in range(1, n+1):
        print(harmonic(i))
    

    输出:

     n:8
    输出前n个调和数的值:
    1.0
    1.5
    1.8333333333333333
    2.083333333333333
    2.283333333333333
    2.4499999999999997
    2.5928571428571425
    2.7178571428571425         
    

    上面代码中的harmonic()是纯函数

    纯函数:给定同样的实际参数,其返回值唯一,且不会产生其它的可观察到的副作用

    注意:编写同时产生副作用和返回值的函数通常被认为是不良编程风格,但有一个例外,即读取函数。例如,input()函数既可以返回一个值,又可以产生副作用(从标准输入中读取并消耗一个字符串)

    二:传递不可变对象、可变对象的引用

    • 实际参数值默认按位置顺序依次传递给形式参数。如果参数个数不对,将会产生错误

    在调用函数时:

    1. 若传递的是不可变对象(例如:int、float、bool、str对象)的引用,则如果函数体中修改对象的值,其结果实际上是创建了一个新的对象
    i = 1
    
    def func(i,n):
        i += n
        return i
    
    print(i)#1
    func(i,10)
    print(i)#1
    

    执行函数func()后,i依旧为1,而不是11

    1. 若传递的是可变对象(例如:list对象)的引用,则在函数体中可以直接修改对象的值
    import random
    
    def shuffle(a):
        n = len(a)
        for i in range(n):
            r = random.randrange(i,n)
            a[i],a[r] = a[r],a[i]
    
    a = [1,2,3,4,5]
    print("初始:",a)
    shuffle(a)
    print("调用函数后:",a)
    

    输出:

    初始: [1, 2, 3, 4, 5]
    调用函数后: [1, 5, 4, 3, 2]
    

    三:可选参数,命名参数,可变参数,强制命名参数

    可选参数

    • 在声明函数时,如果希望函数的一些参数是可选的,可以在声明函数时为这些参数指定默认值
    >>> def babbles(words, times=1):
    	print(words * times)
    
    	
    >>> babbles('Hello')
    Hello
    >>> 
    >>> babbles("Hello", 2)
    HelloHello
    >>> 
    

    注意到一点:必须先声明没有默认值的形参,然后再声明有默认值的形参,否则报错。 这是因为在函数调用时默认是按位置传递实际参数的。

    怎么理解上面那句话呢?

    默认是按位置传递实际参数(如果有默认值的形参在左边,无默认值的形参在右,那么在调用函数时,你的实参该怎么传递呢?)

    命名参数

    • 位置参数:当函数调用时,实参默认按位置顺序传递形参
    • 命名参数(关键字参数):按名称指定传入的参数
      参数按名称意义明确
      传递的参数与顺序无关
      如果有多个可选参数,则可以选择指定某个参数值

    基于期中成绩和期末成绩,按照指定的权重计算总评成绩

    >>> def my_sum(mid_score, end_score, mid_rate = 0.4):
    	score = mid_score*mid_rate + end_score*(1-mid_rate)
    	print(format(score,'.2f'))
    
    	
    >>> my_sum(80,90)
    86.00
    >>> my_sum(mid_score = 80,end_score = 90)
    86.00
    >>> my_sum(end_score = 90,mid_score = 80)
    86.00
    >>> 
    

    可变参数

    • 在声明函数时,可以通过带星号的参数(例如:def func(* param))向函数传递可变数量的实参,调用函数时,从那一点后所有的参数被收集为一个元组
    • 在声明函数时,可以通过带双星号的参数(例如:def func(** param))向函数传递可变数量的实参,调用函数时,从那一点后所有的参数被收集为一个字典

    利用带星的参数计算各数字的累加和

    >>> def my_sum(a,b,*c):
        total = a+b
        for i in c:
            total += i
        return total
    
    >>> print(my_sum(1,2))
    3
    >>> print(my_sum(1,2,3,4,5,6))
    21
    

    利用带星和带双星的参数计算各数字的累加和

    >>> def my_sum(a,b,*c,**d):
        total = a+b
        for i in c:
            total += i
        for key in d:
            total += d[key]
        return total
    
    >>> print(my_sum(1,2))
    3
    >>> print(my_sum(1,2,3,4))
    10
    >>> print(my_sum(1,2,3,4,male=1,female=2))
    13
    

    强制命名参数

    • 在带星号的参数后面声明参数会导致强制命名参数(Keyword-only),然后在调用时必须显式使用命名参数传递值
    • 因为按位置传递的参数默认收集为一个元组,传递给前面带星号的可变参数
    >>> def my_sum(*, mid_score, end_score, mid_rate = 0.4):
        score = mid_score*mid_rate + end_score*(1-mid_rate)
        print(format(score,'.2f'))
    
    >>> my_sum(mid_score=80,end_score=90)
    86.00
    >>> my_sum(end_score=90,mid_score=80)
    86.00
    >>> my_sum(80,90)
    Traceback (most recent call last):
      File "<pyshell#47>", line 1, in <module>
        my_sum(80,90)
    TypeError: my_sum() takes 0 positional arguments but 2 were given
    >>> 
    

    四:全局语句global示例,非局部语句nonlocal示例,输出局部变量和全局变量

    • 在函数体中可以引用全局变量,但是要为定义在函数外的全局变量赋值,需要使用global语句
    pi = 2.1415926
    e = 2.7182818
    
    def my_func():
        global pi
        pi = 3.14
        print("global pi = ", pi)
        e = 2.718
        print("local e = ", e)
    
    print('module pi = ', pi)
    print('module e = ', e)
    my_func()
    print('module pi = ', pi)
    print('module e = ', e)
    

    输出:

    module pi =  2.1415926
    module e =  2.7182818
    global pi =  3.14
    local e =  2.718
    module pi =  3.14
    module e =  2.7182818
    
    • 在函数体中可以定义嵌套函数,在嵌套函数中如果要为定义在上级函数体的局部变量赋值,可以使用nonlocal
    def outer_func():
        tax_rate = 0.17
        print('outer function tax rate is ',tax_rate)
        def inner_func():
            nonlocal tax_rate
            tax_rate = 0.01
            print('inner function tax rate is ',tax_rate)
        inner_func()
        print('outer function tax rate is ',tax_rate)
    
    outer_func()
    

    输出:

    outer function tax rate is  0.17
    inner function tax rate is  0.01
    outer function tax rate is  0.01
    
    • 输出局部变量和全局变量
    1. 内置函数locals(),局部变量列表
    2. 内置函数globals(),全局变量列表

    五:获取和设置最大递归数

    在sys模块中,函数getrecursionlimit()setrecursionlimit()用于获取和设置最大递归次数

    >>> import sys
    >>> sys.getrecursionlimit()
    1000
    >>> sys.setrecursionlimit(666)
    >>> sys.getrecursionlimit()
    666
    >>> 
    

    六:三个有趣的内置函数:eval()、exec()、compile()

    eval

    • 对动态表达式进行求值,返回值
    • eval(expression, globals=None, locals=None)
      expression是动态表达式的字符串
      globals和locals是求值时使用的上下文环境的全局变量和局部变量,如果不指定,则使用当前运行上下文
    >>> x = 2
    >>> str_func = input("请输入表达式:")
    请输入表达式:x**2+2*x+1
    >>> eval(str_func)
    9
    >>> 
    

    exec

    • 可以执行动态表达式,不返回值
    • exec(str, globals=None, locals=None)
    >>> exec("for i in range(10): print(i, end=' ')")
    0 1 2 3 4 5 6 7 8 9 
    >>> 
    

    compile

    • 编译代码为代码对象,可以提高效率
    • compile(source, filename, mode)
      source为代码语句的字符串;如果是多行语句,则每一行的结尾必须有换行符\n
      filename为包含代码的文件
      mode为编码方式,可以为'exec'(用于语句序列的执行),可以为'eval'(用于表达式求值),可以为'single'(用于单个交互语句)
    >>> co = compile("for i in range(10): print(i, end=' ')", '', 'exec')
    >>> exec(co)
    0 1 2 3 4 5 6 7 8 9 
    >>> 
    

    七:map(),filter()

    • map(f, iterable,…),将函数f应用于可迭代对象,返回结果为可迭代对象

    示例1:

    >>> def is_odd(x):
    	return x%2 == 1
    
    >>> list(map(is_odd,range(5)))
    [False, True, False, True, False]
    >>> 
    

    示例2:

    >>> list(map(abs,[1,-2,3,-4,5,-6]))
    [1, 2, 3, 4, 5, 6]
    >>> 
    

    示例3:

    >>> list(map(str,[1,2,3,4,5]))
    ['1', '2', '3', '4', '5']
    >>
    

    示例4:

    >>> def greater(x,y):
    	return x>y
    
    >>> list(map(greater,[1,5,7,3,9],[2,8,4,6,0]))
    [False, False, True, False, True]
    >>> 
    
    • filter(f, iterable),将函数f应用于每个元素,然后根据返回值是True还是False决定保留还是丢弃该元素,返回结果为可迭代对象

    示例1(返回个位数的奇数):

    >>> def is_odd(x):
    	return x%2 == 1
    
    >>> list(filter(is_odd, range(10)))
    [1, 3, 5, 7, 9]
    >>> 
    

    示例2(返回三位数的回文):

    >>> list(filter(is_palindrome, range(100, 1000)))
    [101, 111, 121, 131, 141, 151, 161, 171, 181, 191, 202, 212, 222, 232, 242, 252, 262, 272, 282, 292, 303, 313, 323, 333, 343, 353, 363, 373, 383, 393, 404, 414, 424, 434, 444, 454, 464, 474, 484, 494, 505, 515, 525, 535, 545, 555, 565, 575, 585, 595, 606, 616, 626, 636, 646, 656, 666, 676, 686, 696, 707, 717, 727, 737, 747, 757, 767, 777, 787, 797, 808, 818, 828, 838, 848, 858, 868, 878, 888, 898, 909, 919, 929, 939, 949, 959, 969, 979, 989, 999]
    >>> 
    

    八:Lambda表达式和匿名函数

    匿名函数广泛应用于需要函数对象作为参数、函数比较简单并且只使用一次的场合

    格式:

    lambda arg1,arg2... : <expression>
    

    其中,arg1、arg2等为函数的参数,<expression>为函数的语句,其结果为函数的返回值

    示例1(计算两数之和):

    >>> f = lambda x,y : x+y
    >>> type(f)
    <class 'function'>
    >>> f(1,1)
    2
    >>> 
    

    示例2(返回奇数):

    >>> list(filter(lambda x:x%2==1, range(10)))
    [1, 3, 5, 7, 9]
    >>> 
    

    示例3(返回非空元素):

    >>> list(filter(lambda s:s and s.strip(), ['A', '', 'B', None, 'C', ' ']))
    ['A', 'B', 'C']
    >>> 
    

    补充:

    • strip()用来去除头尾字符、空白符(\n,\r,\t,’’,即换行、回车、制表、空格)
    • lstrip()用来去除开头字符、空白符
    • rstrip()用来去除结尾字符、空白符

    再补充一点:

    • \n到下一行的开头
    • \r回到这一行的开头

    示例4(返回大于0的元素):

    >>> list(filter(lambda x:x>0, [1,0,-2,8,5]))
    [1, 8, 5]
    >>> 
    

    示例5(返回元素的平方):

    >>> list(map(lambda x:x*x, range(10)))
    [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
    >>> 
    

    九:operator模块和操作符函数

    Python内置操作符的函数接口,它定义了对应算术和比较等操作的函数,用于map()、filter()等需要传递函数对象作为参数的场合,可以直接使用而不需要使用函数定义或者Lambda表达式,使得代码更加简洁

    示例1(concat(x,y)对应于x+y):

    >>> import operator
    >>> a = 'hello'
    >>>> operator.concat(a, ' world')
    'hello world'
    

    实例2(operator.gt对应于操作符>):

    >>> import operator
    >>> list(map(operator.gt, [1,5,7,3,9],[2,8,4,6,0]))
    [False, False, True, False, True]
    >>> 
    

    十:functools.reduce(),偏函数functools.partial(),sorted()

    functools.reduce()

    functools.reduce(func, iterable[, iterable[, initializer]])

    • 使用指定的带两个参数的函数func对一个数据集合的所有数据进行下列操作:
    • 使用第一个和第二个数据作为参数用func()函数运算,得到的结果再与第三个数据作为参数用func()函数运算,依此类推,最后得到一个结果
    • 可选的initialzer为初始值

    示例:

    >>> import functools,operator
    >>> functools.reduce(operator.add, [1,2,3,4,5])
    15
    >>> functools.reduce(operator.add, [1,2,3,4,5], 10)
    25
    >>> functools.reduce(operator.add, range(1,101))
    5050
    >>> 
    >>> functools.reduce(operator.mul, range(1,11))
    3628800
    

    偏函数functools.partial()

    functools.partial(func, *arg, **keywords)

    • 通过把一个函数的部分参数设置为默认值的方式返回一个新的可调用(callable)的partial对象
    • 主要用于设置预先已知的参数,从而减少调用时传递参数的个数

    示例(2的n次方):

    >>> import functools,math
    >>> pow2 = functools.partial(math.pow, 2)
    >>> list(map(pow2, range(11)))
    [1.0, 2.0, 4.0, 8.0, 16.0, 32.0, 64.0, 128.0, 256.0, 512.0, 1024.0]
    >>> 
    

    十一:sorted()

    sorted(iterable, *, key=None, reverse=False)

    • iterable是待排序的可迭代对象
    • key是比较函数(默认为None,按自然顺序排序)
    • reverse用于指定是否逆序排序

    示例1(数值。默认自然排序):

    >>> sorted([1,6,4,-2,9])
    [-2, 1, 4, 6, 9]
    >>> sorted([1,6,4,-2,9], reverse=True)
    [9, 6, 4, 1, -2]
    >>> sorted([1,6,4,-2,9], key=abs)
    [1, -2, 4, 6, 9]
    

    示例2(字符串,默认按字符串字典序排序):

    >>> sorted(['Dod', 'cat', 'Rabbit'])
    ['Dod', 'Rabbit', 'cat']
    >>> sorted(['Dod', 'cat', 'Rabbit'], key=str.lower)
    ['cat', 'Dod', 'Rabbit']
    >>> sorted(['Dod', 'cat', 'Rabbit'], key=len)
    ['Dod', 'cat', 'Rabbit']
    

    示例3(元组,默认按元组的第一个元素排序):

    >>> sorted([('Bob', 75), ('Adam', 92), ('Lisa', 88)])
    [('Adam', 92), ('Bob', 75), ('Lisa', 88)]
    >>> sorted([('Bob', 75), ('Adam', 92), ('Lisa', 88)], key=lambda t:t[1])
    [('Bob', 75), ('Lisa', 88), ('Adam', 92)]
    

    十二:函数装饰器

    这玩意就很有意思了,很Java语言中的注解是很相像的

    示例1:

    import time,functools
    
    def timeit(func):
        def wrapper(*s):
            start = time.perf_counter()
            func(*s)
            end = time.perf_counter()
            print('运行时间:', end - start)
        return wrapper
    
    @timeit
    def my_sum(n):
        sum = 0
        for i in range(n): sum += i
        print(sum)
    
    if __name__ == '__main__':
        my_sum(10_0000)
    

    结果:

    4999950000
    运行时间: 0.013929100000000028
    

    怎么理解上面的代码呢?

    • 首先,timeit()返回的是wrapper,而不是执行(没有小括号)
    • @timeit相当于,在调用my_sum()的前一刻,会执行这么个语句:my_sum = timeit(my_sum)

    示例2:

    def makebold(fn):
        def wrapper(*s):
            return "<b>" + fn(*s) + "</b>"
        return wrapper
    
    def makeitalic(fn):
        def wrapper(*s):
            return "<i>" + fn(*s) + "</i>"
        return wrapper
    
    @makebold
    @makeitalic
    def htmltags(str1):
        return str1
    
    print(htmltags('Hello'))
    
    

    输出:

    <b><i>Hello</i></b>
    

    选择题:1~5

    1

    >>> print(type(lambda:None))
    <class 'function'>
    

    2

    >>> f = lambda x,y:x*y
    >>> f(12, 34)
    408
    

    3

    >>> f1 = lambda x:x*2
    >>> f2 = lambda x:x**2
    >>> print(f1(f2(2)))
    8
    

    4

    >>> def f1(p, **p2):
    	print(type(p2))
    
    	
    >>> f1(1, a=2)
    <class 'dict'>
    

    5

    >>> def f1(a,b,c):
    	print(a+b)
    
    	
    >>> nums = (1,2,3)
    >>> f1(*nums)
    3
    

    思考题:4~11

    4

    >>> d = lambda p:p*2
    >>> t = lambda p:p*3
    >>> x = 2
    >>> x = d(x)
    >>> x = t(x)
    >>> x = d(x)
    >>> print(x)
    24
    

    5

    >>> i = map(lambda x:x**2, (1,2,3))
    >>> for t in i:
    	print(t, end=' ')
    
    	
    1 4 9 
    

    6

    >>> def f1():
    	"simple function"
    	pass
    
    >>> print(f1.__doc__)
    simple function
    

    7

    >>> counter = 1
    >>> num = 0
    >>> def TestVariable():
    	global counter
    	for i in (1, 2, 3) : counter += 1
    	num = 10
    
    	
    >>> TestVariable()
    >>> print(counter, num)
    4 0
    

    8

    >>> def f(a,b):
    	if b==0 : print(a)
    	else : f(b, a%b)
    
    	
    >>> print(f(9,6))
    3
    None
    

    求最大公约数

    9

    >>> def aFunction():
    	"The quick brown fox"
    	return 1
    
    >>> print(aFunction.__doc__[4:9])
    quick
    

    10

    >>> def judge(param1, *param2):
    	print(type(param2))
    	print(param2)
    
    	
    >>> judge(1, 2, 3, 4, 5)
    <class 'tuple'>
    (2, 3, 4, 5)
    

    11

    >>> def judge(param1, **param2):
    	print(type(param2))
    	print(param2)
    
    	
    >>> judge(1, a=2, b=3, c=4, d=5)
    <class 'dict'>
    {'a': 2, 'b': 3, 'c': 4, 'd': 5}
    

    上机实践:2~5

    2. 编写程序,定义一个求阶乘的函数fact(n),并编写测试代码,要求输入整数n(n>=0)。请分别使用递归和非递归方式实现

    递归方式:

    def fact(n):
        if n == 0 :
            return 1
        return n*fact(n-1)
    
    n = int(input("请输入整数n(n>=0):"))
    print(str(n)+" ! =  " + str(fact(n)))
    
    

    非递归方式:

    def fact(n):
        t = 1
        for i in range(1,n+1):
            t *= i
        return t
    
    n = int(input("请输入整数n(n>=0):"))
    print(str(n)+" ! =  " + str(fact(n)))
    
    

    输出:

    请输入整数n(n>=0):5
    5 ! =  120
    

    3. 编写程序,定义一个求Fibonacci数列的函数fib(n),并编写测试代码,输出前20项(每项宽度5个字符位置,右对齐),每行输出10个。请分别使用递归和非递归方式实现

    递归方式:

    def fib(n):
        if (n == 1 or n == 2):
            return 1
        return fib(n-1)+fib(n-2)
    
    for i in range(1,21):
        print(str(fib(i)).rjust(5,' '),end = ' ')
        if i %10 == 0:
            print()
    

    非递归方式:

    def fib(n):
        if (n == 1 or n == 2):
            return 1
        n1 = n2 = 1
        for i  in range(3,n+1):
            n3 = n1+n2
            n1 = n2
            n2 = n3
        return n3
    
    for i in range(1,21):
        print(str(fib(i)).rjust(5,' '),end = ' ')
        if i %10 == 0:
            print()
    

    输出:

        1     1     2     3     5     8    13    21    34    55
       89   144   233   377   610   987  1597  2584  4181  6765
    

    4. 编写程序,利用可变参数定义一个求任意个数数值的最小值的函数min_n(a,b,*c),并编写测试代码。例如对于“print(min_n(8, 2))”以及“print(min_n(16, 1, 7, 4, 15))”的测试代码

    def min_n(a,b,*c):
        min_number = a if(a < b) else b
        for n in c:
            if n < min_number:
                min_number = n
        return min_number
    
    print(min_n(8, 2))
    print(min_n(16, 1, 7, 4, 15))
    

    输出:

    2
    1
    

    5. 编写程序,利用元组作为函数的返回值,求序列类型中的最大值、最小值和元素个数,并编写测试代码,假设测试代码数据分别为s1=[9, 7, 8, 3, 2, 1, 55, 6]、s2=[“apple”, “pear”, “melon”, “kiwi”]和s3="TheQuickBrownFox"

    def func(n):
        return (max(n),min(n),len(n))
        
    s1=[9, 7, 8, 3, 2, 1, 55, 6]
    s2=["apple", "pear", "melon", "kiwi"]
    s3="TheQuickBrownFox"
    
    for i in (s1,s2,s3):
        print("list = ", i)
        t = func(i)
        print("最大值 = {0},最小值 = {1},元素个数 = {2}".format(t[0], t[1], t[2]))
    

    输出:

    list =  [9, 7, 8, 3, 2, 1, 55, 6]
    最大值 = 55,最小值 = 1,元素个数 = 8
    list =  ['apple', 'pear', 'melon', 'kiwi']
    最大值 = pear,最小值 = apple,元素个数 = 4
    list =  TheQuickBrownFox
    最大值 = x,最小值 = B,元素个数 = 16
    

    案例研究:井字棋游戏

    https://blog.csdn.net/Zhangguohao666/article/details/103280740

    了解Python函数的定义和使用


    由于本文的内容太多了,导致了两个很不好的结果,
    一是:在网页中打开本篇博客的加载时间太长了,明显的卡顿很影响阅读体验;
    二是:本人在对本篇文章进行更新或者修改内容时,卡的要死。
    遂,
    将本文第八章后面的很多内容拆分到新的文章中,望大家理解


    第九章 面向对象的程序设计


    第十章 模块和客户端


    第十一章 算法与数据结构基础


    第十二章 图形用户界面


    我对图形用户界面基本无兴趣,无特殊情况,基本不打算碰这方面内容

    案例研究:简易图形用户界面计算器

    第十三章 图形绘制


    与上一章相同,我对于图形绘制的兴趣也基本没有,尝试做了2-7题,就完全没兴趣做下去了

    图形绘制模块:tkinter

    2. 参考例13.2利用Canvas组件创建绘制矩形的程序,尝试改变矩形边框颜色以及填充颜色

    from tkinter import *
    
    root = Tk()
    c = Canvas(root, bg = 'white', width = 130, height = 70)
    c.pack()
    
    c.create_rectangle(10, 10, 60, 60, fill = 'red')
    c.create_rectangle(70, 10, 120, 60, fill = 'green', outline = 'blue', width = 5)
    
    

    创建画布对象:

    • root = Tk()
      创建一个Tk根窗口组件root
    • c = Canvas(root, bg = 'white', width = 130, height = 70)
      创建大小为200 * 100、背景颜色为白色的画布
    • c.pack()
      调用组件pack()方法,调整其显示位置和大小

    绘制矩形:

    c.create_rectangle(x0, y0, x1, y1, option, ...)
    
    • (x0,y0)是左上角的坐标
    • (x1,y1)是右下角的坐标
    • c.create_rectangle(70, 10, 120, 60, fill = 'green', outline = 'blue', width = 5)
      用蓝色边框、绿色填充矩形,边框宽度为5

    3. 参考例13.3利用Canvas组件创建绘制椭圆的程序,尝试修改椭圆边框样式、边框颜色以及填充颜色

    from tkinter import *
    
    root = Tk()
    c = Canvas(root, bg = 'white', width = 280, height = 70)
    c.pack()
    
    c.create_oval(10, 10, 60, 60, fill = 'green')
    c.create_oval(70, 10, 120, 60, fill = 'green', outline = 'red', width = 5)
    c.create_oval(130, 25, 180, 45, dash = (10,))
    c.create_oval(190, 10, 270, 50, dash = (1,), width = 2)
    
    

    绘制椭圆

    c.create_oval(x0, y0, x1, y1, option, ...)
    
    • (x0,y0)是左上角的坐标
    • (x1,y1)是右下角的坐标
    • c.create_oval(70, 10, 120, 60, fill = 'green', outline = 'red', width = 5)
      绿色填充、红色边框,宽度为5
    • c.create_oval(130, 25, 180, 45, dash = (10,))
      虚线椭圆

    4. 参考例13.4利用Canvas组件创建绘制圆弧的程序,尝试修改圆弧样式、边框颜色以及填充颜色

    from tkinter import *
    
    root = Tk()
    c = Canvas(root, bg = 'white', width = 250, height = 70)
    c.pack()
    
    c.create_arc(10, 10, 60, 60, style = ARC)
    c.create_arc(70, 10, 120, 60, style = CHORD)
    c.create_arc(130, 10, 180, 60, style = PIESLICE)
    for i in range(0, 360, 60):
        c.create_arc(190, 10, 240, 60, fill = 'green', outline = 'red', start = i, extent = 30)
    
    

    绘制圆弧:

    c.create_arc(x0, y0, x1, y1, option, ...)
    
    • (x0,y0)是左上角的坐标
    • (x1,y1)是右下角的坐标
    • 选项start(开始角度,默认为0)和extend(圆弧角度,从start开始逆时针旋转,默认为90度)决定圆弧的角度范围
    • 选项start用于设置圆弧的样式

    5. 参考例13.5利用Canvas组件创建绘制线条的程序,尝试修改线条样式和颜色

    from tkinter import *
    
    root = Tk()
    c = Canvas(root, bg = 'white', width = 250, height = 70)
    c.pack()
    
    c.create_line(10, 10, 60, 60, arrow = BOTH, arrowshape = (3, 4, 5))
    c.create_line(70, 10, 95, 10, 120, 60, fill = 'red')
    c.create_line(130, 10, 180, 10, 130, 60, 180, 60, fill = 'green', width = 10, arrow = BOTH, joinstyle = MITER)
    c.create_line(190, 10, 240, 10, 190, 60, 240, 60, width = 10)
    
    

    绘制线条:

    c.create_line(x0, y0, x1, y1, ..., xn, yn, option, ...)
    
    • (x0,y0),(x1,y1),…,(xn,yn)是线条上各个点的坐标

    6. 参考例13.6利用Canvas组件创建绘制多边形的程序,尝试修改多边形的形状、线条样式和填充颜色

    from tkinter import *
    
    root = Tk()
    c = Canvas(root, bg = 'white', width = 250, height = 70)
    c.pack()
    
    c.create_polygon(35, 10, 10, 60, 60, 60, fill = 'red', outline = 'green')
    c.create_polygon(70, 10, 120, 10, 120, 60, fill = 'white', outline = 'blue')
    c.create_polygon(130, 10, 180, 10, 180, 60, 130, 60, outline = 'blue')
    c.create_polygon(190, 10, 240, 10, 190, 60, 240, 60, fill = 'white', outline = 'black')
    
    

    绘制多边形:

    c.create_polygon(x0, y0, x1, y1, ..., option, ...)
    
    • (x0,y0),(x1,y1),…,(xn,yn)是多边形上各个顶点的坐标

    7. 参考例13.7利用Canvas组件创建绘制字符串和图形的程序,绘制y = cos(x) 的图形

    绘制字符串:

    c.create_text(x, y, option, ...)
    
    • (x,y)是字符串放置的中心位置

    y = sin(x)

    from tkinter import *
    import math
    
    WIDTH, HEIGHT = 510, 210
    ORIGIN_X, ORIGIN_Y = 2, HEIGHT/2 #原点
    
    SCALE_X, SCALE_Y = 40, 100 #x轴、y轴缩放倍数
    ox, oy = 0, 0
    x, y = 0, 0
    arc = 0 #弧度
    END_ARC = 360 * 2 #函数图形画两个周期
    
    root = Tk()
    c = Canvas(root, bg = 'white', width = WIDTH, height = HEIGHT)
    c.pack()
    
    c.create_text(200, 20, text = 'y = sin(x)')
    c.create_line(0, ORIGIN_Y, WIDTH, ORIGIN_Y) 
    c.create_line(ORIGIN_X, 0, ORIGIN_X, HEIGHT) #绘制x轴,y轴
    for i in range(0, END_ARC+1, 10):
        arc = math.pi * i / 180
        x = ORIGIN_X + arc * SCALE_X
        y = ORIGIN_Y - math.sin(arc) * SCALE_Y
        c.create_line(ox, oy, x, y)
        ox, oy = x, y
    

    y = cos(x)

    from tkinter import *
    import math
    
    WIDTH, HEIGHT = 510, 210
    ORIGIN_X, ORIGIN_Y = 2, HEIGHT/2 #原点 
    
    SCALE_X, SCALE_Y = 40, 100 #x轴、y轴缩放倍数
    ox, oy = 0, 0
    x, y = 0, 0
    arc = 0 #弧度
    END_ARC = 360 * 2 #函数图形画两个周期
    
    root = Tk()
    c = Canvas(root, bg = 'white', width = WIDTH, height = HEIGHT)
    c.pack()
    
    c.create_text(200, 20, text = 'y = cos(x)')
    c.create_line(0, ORIGIN_Y, WIDTH, ORIGIN_Y) 
    c.create_line(ORIGIN_X, 0, ORIGIN_X, HEIGHT) 
    for i in range(0, END_ARC+1, 10):
        arc = math.pi * i / 180 
        x = ORIGIN_X + arc * SCALE_X
        y = ORIGIN_Y - math.cos(arc) * SCALE_Y
        c.create_line(ox, oy, x, y)
        ox, oy = x, y
    
    
    

    图形绘制模块:turtle


    后面章节内容:未完待续…

    第十四章 数值日期和时间处理


    第十五章 字符串和文本处理


    第十六章 文件和数据交换


    第十七章 数据访问


    第十八章 网络编程和通信


    第十九章 并行计算:进程、线程和协程


    第二十章 系统管理

    展开全文
  • Python程序设计题库

    万次阅读 多人点赞 2020-03-28 17:39:40
    Python程序设计》题库 一、 填空题 1、 Python安装扩展库常用的是_工具。(pip) 2、 Python标准库math中用来计算平方根的函数是____。(sqrt) 3、 Python程序文件扩展名主要有__和两种,其中后者常用于GUI程序...

    《Python程序设计》题库

    一、 填空题 
    1、 Python安装扩展库常用的是_工具。(pip) 
    2、 Python标准库math中用来计算平方根的函数是____。(sqrt) 
    3、 Python程序文件扩展名主要有__和两种,其中后者常用于GUI程序。(py、pyw) 
    4、 Python源代码程序编译后的文件扩展名为___。(pyc) 
    5、 使用pip工具升级科学计算扩展库numpy的完整命令是_______。(pip install –upgrade numpy) 
    6、 使用pip工具查看当前已安装的Python扩展库的完整命令是___。(pip list) 
    7、 在IDLE交互模式中浏览上一条语句的快捷键是____。(Alt+P) 
    8、 使用pip工具查看当前已安装Python扩展库列表的完整命令是___。(pip list) 
    9、 在Python中____表示空类型。(None) 
    10、 列表、元组、字符串是Python的___(有序?无序)序列。(有序) 
    11、 查看变量类型的Python内置函数是______。(type()) 
    12、 查看变量内存地址的Python内置函数是_______。(id()) 
    13、 以3为实部4为虚部,Python复数的表达形式为_或__。(3+4j、3+4J) 
    14、 Python运算符中用来计算整商的是___。(//) 
    15、 Python运算符中用来计算集合并集的是_。(|) 
    16、 使用运算符测试集合包含集合A是否为集合B的真子集的表达式可以写作_。(A < B ) 
    17、 表达式[1, 2, 3]*3的执行结果为____________。([1, 2, 3, 1, 2, 3, 1, 2, 3]) 
    18、 list(map(str, [1, 2, 3]))的执行结果为___________。([‘1’, ‘2’, ‘3’]) 
    19、 语句`x = 3==3, 5`执行结束后,变量x的值为___。((True, 5)) 
    20、 已知 x = 3,那么执行语句 x += 6 之后,x的值为_____。(9) 
    21、 已知 x = 3,并且id(x)的返回值为 496103280,那么执行语句 x += 6 之后,表达式 id(x) == 496103280 的值为_。(False) 
    22、 已知 x = 3,那么执行语句 x *= 6 之后,x的值为______。(18) 
    23、 为了提高Python代码运行速度和进行适当的保密,可以将Python程序文件编译为扩展名____的文件。(pyc) 
    24、 表达式“[3] in [1, 2, 3, 4]”的值为______。(False) 
    25、 列表对象的sort()方法用来对列表元素进行原地排序,该函数返回值为 。(None) 
    26、 假设列表对象aList的值为[3, 4, 5, 6, 7, 9, 11, 13, 15, 17],那么切片aList[3:7]得到的值是____________。([6, 7, 9, 11]) 
    27、 使用列表推导式生成包含10个数字5的列表,语句可以写为_____。([5 for i in range(10)]) 
    28、 假设有列表a = [‘name’, ‘age’, ‘sex’]和b = [‘Dong’, 38, ‘Male’],请使用一个语句将这两个列表的内容转换为字典,并且以列表a中的元素为“键”,以列表b中的元素为“值”,这个语句可以写为___________。(c = dict(zip(a, b))) 
    29、 任意长度的Python列表、元组和字符串中最后一个元素的下标为__。(-1) 
    30、 Python语句”.join(list(‘hello world!’))执行的结果是__________。(’hello world!’) 
    31、 转义字符’\n’的含义是_________。(回车换行) 
    32、 Python语句list(range(1,10,3))执行结果为_________。([1, 4, 7]) 
    33、 表达式 list(range(5)) 的值为______。([0, 1, 2, 3, 4]) 
    34、 ____命令既可以删除列表中的一个元素,也可以删除整个列表。(del)  
    35、 已知a = [1, 2, 3]和b = [1, 2, 4],那么id(a[1])==id(b[1])的执行结果为_。(True) 
    36、 表达式 int(‘123’, 16) 的值为___。(291) 
    37、 表达式 int(‘123’, 8) 的值为___。(83) 
    38、 表达式 int(‘123’) 的值为___。(123) 
    39、 表达式 int(‘101’,2) 的值为____。(5) 
    40、 表达式 abs(-3) 的值为_。(3) 
    41、 切片操作list(range(6))[::2]执行结果为______。([0, 2, 4]) 
    42、 使用切片操作在列表对象x的开始处增加一个元素3的代码为___。(x[0:0] = [3]) 
    43、 语句sorted([1, 2, 3], reverse=True) == reversed([1, 2, 3])执行结果为___。(False) 
    44、 表达式 ‘ab’ in ‘acbed’ 的值为__。(False) 
    45、 Python 3.x语句 print(1, 2, 3, sep=’:’) 的输出结果为__。(1:2:3) 
    46、 表达式 sorted([111, 2, 33], key=lambda x: len(str(x))) 的值为______。([2, 33, 111]) 
    47、 假设n为整数,那么表达式 n&1 == n%2 的值为___。(True) 
    48、 表达式 int(4**0.5) 的值为__。(2) 
    49、 达式 sorted([111, 2, 33], key=lambda x: -len(str(x))) 的值为__。([111, 33, 2]) 
    50、 Python内置函数___可以返回列表、元组、字典、集合、字符串以及range对象中元素个数。(len()) 
    51、 Python内置函数__用来返回序列中的最大元素。(max()) 
    52、 Python内置函数__用来返回序列中的最小元素。(min()) 
    53、 Python内置函数______用来返回数值型序列中所有元素之和。(sum()) 
    54、 已知列表对象x = [‘11’, ‘2’, ‘3’],则表达式 max(x) 的值为_。(’3’) 
    55、 表达式 min([‘11’, ‘2’, ‘3’]) 的值为_______。(’11’) 
    56、 已知列表对象x = [‘11’, ‘2’, ‘3’],则表达式max(x, key=len) 的值为_。(’11’) 
    57、 语句 x = (3,) 执行后x的值为_____。((3,)) 
    58、 语句 x = (3) 执行后x的值为______。(3) 
    59、 已知x=3和y=5,执行语句 x, y = y, x 后x的值是__。(5) 
    60、 可以使用内置函数_____查看包含当前作用域内所有全局变量和值的字典。(globals()) 
    61、 可以使用内置函数_________查看包含当前作用域内所有局部变量和值的字典。(locals()() 
    62、 字典中多个元素之间使用__分隔开,每个元素的“键”与“值”之间使用__分隔开。(逗号、冒号) 
    63、 字典对象的_方法可以获取指定“键”对应的“值”,并且可以在指定“键”不存在的时候返回指定值,如果不指定则返回None。(get()) 
    64、 字典对象的___方法返回字典中的“键-值对”列表。(items()) 
    65、 字典对象的__方法返回字典的“键”列表。(keys()) 
    66、 字典对象的____方法返回字典的“值”列表。(values()) 
    67、 已知 x = {1:2},那么执行语句 x[2] = 3之后,x的值为______。({1: 2, 2: 3}) 
    68、 表达式 {1, 2, 3, 4} - {3, 4, 5, 6}的值为________。({1, 2}) 
    69、 表达式set([1, 1, 2, 3])的值为__________。({1, 2, 3}) 
    70、 关键字____用于测试一个对象是否是一个可迭代对象的元素。(in) 
    71、 使用列表推导式得到100以内所有能被13整除的数的代码可以写作_________________________。([i for i in range(100) if i%13==0]) 
    72、 表达式 3<5>2 的值为_____。(True) 
    73、 已知 x = {‘a’:’b’, ‘c’:’d’},那么表达式 ‘a’ in x 的值为____。(True) 
    74、 已知 x = {‘a’:’b’, ‘c’:’d’},那么表达式 ‘b’ in x 的值为____。(False) 
    75、 已知 x = {‘a’:’b’, ‘c’:’d’},那么表达式 ‘b’ in x.values() 的值为____。(True) 
    76、 表达式 1<2<3 的值为___。(True) 
    77、 表达式 3 or 5 的值为__(3) 
    78、 表达式 0 or 5 的值为___(5) 
    79、 表达式 3 and 5 的值为__。(5) 
    80、 表达式 3 and not 5 的值为____。(False) 
    81、 表达式 3 | 5 的值为____。(7) 
    82、 表达式 3 & 6 的值为___。(2) 
    83、 表达式 3 ** 2 的值为___。(9) 
    84、 表达式 3 * 2的值为_。(6) 
    85、 已知 x = [3, 5, 7],那么表达式 x[10:]的值为__。([]) 
    86、 已知 x = [3, 5, 7],那么执行语句 x[len(x):] = [1, 2]之后,x的值为____。([3, 5, 7, 1, 2]) 
    87、 已知 x = [3, 7, 5],那么执行语句 x.sort(reverse=True)之后,x的值为_______。([7, 5, 3]) 
    88、 已知 x = [3, 7, 5],那么执行语句 x = x.sort(reverse=True)之后,x的值为___。(None) 
    89、 已知 x = [1, 11, 111],那么执行语句 x.sort(key=lambda x: len(str(x)), reverse=True) 之后,x的值为________。([111, 11, 1]) 
    90、 表达式 list(zip([1,2], [3,4])) 的值为______________。([(1, 3), (2, 4)]) 
    91、 已知 x = [1, 2, 3, 2, 3],执行语句 x.pop() 之后,x的值为___。([1, 2, 3, 2]) 
    92、 表达式 list(map(list,zip(*[[1, 2, 3], [4, 5, 6]]))) 的值为______。([[1, 4], [2, 5], [3, 6]]) 
    93、 表达式 [x for x in [1,2,3,4,5] if x<3] 的值为___________。([1, 2]) 
    94、 表达式 [index for index, value in enumerate([3,5,7,3,7]) if value == max([3,5,7,3,7])] 的值为________。([2, 4]) 
    95、 已知 x = [3,5,3,7],那么表达式 [x.index(i) for i in x if i==3] 的值为____。([0, 0]) 
    96、 已知列表 x = [1, 2],那么表达式 list(enumerate(x)) 的值为_____。([(0, 1), (1, 2)]) 
    97、 已知 vec = [[1,2], [3,4]],则表达式 [col for row in vec for col in row] 的值为________________。([1, 2, 3, 4]) 
    98、 已知 vec = [[1,2], [3,4]],则表达式 [[row[i] for row in vec] for i in range(len(vec[0]))] 的值为_______________。([[1, 3], [2, 4]]) 
    99、 已知 x = list(range(10)),则表达式 x[-4:] 的值为____。([6, 7, 8, 9]) 
    100、 已知 path = r’c:\test.html’,那么表达式 path[:-4]+’htm’ 的值为____。(’c:\test.htm’) 
    101、 已知 x = [3, 5, 7],那么执行语句 x[1:] = [2]之后,x的值为______。([3, 2]) 
    102、 已知 x = [3, 5, 7],那么执行语句 x[:3] = [2]之后,x的值为______。([ 2]) 
    103、 已知x为非空列表,那么执行语句y = x[:]之后,id(x[0]) == id(y[0])的值为____。(True) 
    104、 已知 x = [1, 2, 3, 2, 3],执行语句 x.remove(2) 之后,x的值为__。([1, 3, 2, 3]) 
    105、 表达式 3<<2 的值为_____。(12) 
    106、 表达式 65 >> 1 的值为___。(32) 
    107、 表达式 chr(ord(‘a’)^32) 的值为_。(’A’) 
    108、 表达式 chr(ord(‘a’)-32) 的值为_。(’A’) 
    109、 表达式 abs(3+4j) 的值为__。(5.0) 
    110、 表达式 callable(int) 的值为_。(True) 
    111、 表达式 list(str([1,2,3])) == [1,2,3] 的值为____。(False) 
    112、 表达式 str([1, 2, 3]) 的值为________。(’[1, 2, 3]’) 
    113、 表达式 str((1, 2, 3)) 的值为________。(’(1, 2, 3)’) 
    114、 Python中用于表示逻辑与、逻辑或、逻辑非运算的关键字分别是_、___、___。(and、or、not) 
    115、 Python 3.x语句 for i in range(3):print(i, end=’,’) 的输出结果为___________。(0,1,2,) 
    116、 Python 3.x语句 print(1, 2, 3, sep=’,’) 的输出结果为______。(1,2,3) 
    117、 对于带有else子句的for循环和while循环,当循环因循环条件不成立而自然结束时__(会?不会?)执行else中的代码。(会) 
    118、 在循环语句中,____语句的作用是提前结束本层循环。(break) 
    119、 在循环语句中,_语句的作用是提前进入下一次循环。(continue) 
    120、 表达式 sum(range(1, 10, 2)) 的值为__。(25) 
    121、 表达式 sum(range(1, 10)) 的值为___。(45) 
    122、 表达式 ‘%c’%65 的值为___。(’A’) 
    123、 表达式 ‘%s’%65 的值为____。(’65’) 
    124、 表达式 ‘%d,%c’ % (65, 65) 的值为__。(’65,A’) 
    125、 表达式 ‘The first:{1}, the second is {0}’.format(65,97) 的值为____________________。(’The first:97, the second is 65’) 
    126、 表达式 ‘{0:#d},{0:#x},{0:#o}’.format(65) 的值为___。(’65,0x41,0o101’) 
    127、 表达式 isinstance(‘abcdefg’, str) 的值为__。(True) 
    128、 表达式 isinstance(‘abcdefg’, object) 的值为___。(True) 
    129、 表达式 isinstance(3, object) 的值为___。(True) 
    130、 表达式 ‘abcabcabc’.rindex(‘abc’) 的值为__。(6) 
    131、 表达式 ‘:’.join(‘abcdefg’.split(‘cd’)) 的值为____。(’ab:efg’) 
    132、 表达式 ‘Hello world. I like Python.’.rfind(‘python’) 的值为__。(-1) 
    133、 表达式 ‘abcabcabc’.count(‘abc’) 的值为___。(3) 
    134、 表达式 ‘apple.peach,banana,pear’.find(‘p’) 的值为____。(1) 
    135、 表达式 ‘apple.peach,banana,pear’.find(‘ppp’) 的值为__。(-1) 
    136、 表达式 ‘abcdefg’.split(‘d’) 的值为________。([‘abc’, ‘efg’]) 
    137、 表达式 ‘:’.join(‘1,2,3,4,5’.split(‘,’)) 的值为________。(’1:2:3:4:5’) 
    138、 表达式 ‘,’.join(‘a b ccc\n\n\nddd ‘.split()) 的值为____。(’a,b,ccc,ddd’) 
    139、 表达式 ‘Hello world’.upper() 的值为_。(’HELLO WORLD’) 
    140、 表达式 ‘Hello world’.lower() 的值为___。(’hello world’) 
    141、 表达式 ‘Hello world’.lower().upper() 的值为_。(’HELLO WORLD’) 
    142、 表达式 ‘Hello world’.swapcase().swapcase() 的值为____。(’Hello world’) 
    143、 表达式 r’c:\windows\notepad.exe’.endswith(‘.exe’) 的值为___。(True) 
    144、 表达式 r’c:\windows\notepad.exe’.endswith((‘.jpg’, ‘.exe’)) 的值为_。(True) 
    145、 表达式 ‘C:\Windows\notepad.exe’.startswith(‘C:’) 的值为___。(True) 
    146、 表达式 len(‘Hello world!’.ljust(20)) 的值为___。(20) 
    147、 表达式 len(‘abcdefg’.ljust(3)) 的值为___。(7) 
    148、 表达式 len([i for i in range(10)]) 的值为____。(10) 
    149、 表达式 len(range(1,10)) 的值为___。(9) 
    150、 表达式 range(10)[-1] 的值为__。(9) 
    151、 表达式 range(10,20)[4] 的值为____。(14) 
    152、 表达式 round(3.4) 的值为_。(3) 
    153、 表达式 round(3.7) 的值为___。(4) 
    154、 表达式 ‘a’ + ‘b’ 的值为___。(’ab’) 
    155、 已知 x = ‘123’ 和 y = ‘456’,那么表达式 x + y 的值为____。(’123456’) 
    156、 表达式 ‘a’.join(‘abc’.partition(‘a’)) 的值为______。(’aaabc’) 
    157、 表达式 re.split(‘.+’, ‘alpha.beta…gamma..delta’) 的值为_____________。([‘alpha’, ‘beta’, ‘gamma’, ‘delta’]) 
    158、 已知 x = ‘a234b123c’,并且re模块已导入,则表达式 re.split(‘\d+’, x) 的值为_______。([‘a’, ‘b’, ‘c’]) 
    159、 表达式 ”.join(‘asdssfff’.split(‘sd’)) 的值为__。(’assfff’) 
    160、 表达式 ”.join(re.split(‘[sd]’,’asdssfff’)) 的值为_____。(’afff’) 
    161、 假设re模块已导入,那么表达式 re.findall(‘(\d)\1+’, ‘33abcd112’) 的值为_________。([‘3’, ‘1’]) 
    162、 语句 print(re.match(‘abc’, ‘defg’)) 输出结果为___。(None) 
    163、 表达式 ‘Hello world!’[-4] 的值为______。(’r’) 
    164、 表达式 ‘Hello world!’[-4:] 的值为______。(’rld!’) 
    165、 表达式 ‘test.py’.endswith((‘.py’, ‘.pyw’)) 的值为____。(True) 
    166、 已知 x = (3), 那么表达式 x * 3 的值为____。(9) 
    167、 已知 x = (3,),那么表达式 x * 3 的值为___。((3, 3, 3)) 
    168、 表达式 len(‘abc’.ljust(20)) 的值为____。(20) 
    169、 代码 print(re.match(‘^[a-zA-Z]+$’,’abcDEFG000’)) 的输出结果为___。(None) 
    170、 当在字符串前加上小写字母或大写字母表示原始字符串,不对其中的任何字符进行转义。(r、R) 
    171、 在设计正则表达式时,字符_紧随任何其他限定符(*、+、?、{n}、{n,}、{n,m})之后时,匹配模式是“非贪心的”,匹配搜索到的、尽可能短的字符串。(?) 
    172、 假设正则表达式模块re已导入,那么表达式 re.sub(‘\d+’, ‘1’, ‘a12345bbbb67c890d0e’) 的值为___________。(’a1bbbb1c1d1e’) 
    173、 假设列表对象x = [1, 1, 1],那么表达式id(x[0]) == id(x[2])的值为___。(True) 
    174、 已知列表 x = list(range(10)),那么执行语句 del x[::2]之后,x的值为___。([1, 3, 5, 7, 9]) 
    175、 已知列表 x = [1, 2, 3, 4],那么执行语句 del x[1] 之后x的值为__。([1, 3, 4]) 
    176、 表达式 [1] * 2 的值为_______。([1, 1]) 
    177、 表达式 [1, 2] * 2 的值为____。([1, 2, 1, 2]) 
    178、 已知列表 x = [1, 2, 3],那么执行语句 x.insert(1, 4) 只有,x的值为_。([1, 4, 2, 3]) 
    179、 已知列表 x = [1, 2, 3],那么执行语句 x.insert(0, 4) 只有,x的值为_。([4, 1, 2, 3]) 
    180、 已知列表 x = [1, 2, 3],那么执行语句 x.pop(0) 之后,x的值为___。([2, 3]) 
    181、 已知 x = [[1]] * 3,那么执行语句 x[0][0] = 5之后,变量x的值为______。([[5], [5], [5]]) 
    182、 表达式 list(map(lambda x: x+5, [1, 2, 3, 4, 5])) 的值为____________。([6, 7, 8, 9, 10]) 
    183、 表达式 {1, 2, 3, 4, 5} ^ {4, 5, 6, 7} 的值为_______________。({1, 2, 3, 6, 7}) 
    184、 表达式 5 if 5>6 else (6 if 3>2 else 5) 的值为___。(6) 
    185、 已知 x = [1, 2, 3],那么执行语句 x[len(x)-1:] = [4, 5, 6]之后,变量x的值为_______________________。([1, 2, 4, 5, 6]) 
    186、 表达式 len(range(1, 10)) 的值为_。(9) 
    187、 表达式 len(‘中国’.encode(‘utf-8’)) 的值为_。(6) 
    188、 表达式 len(‘中国’.encode(‘gbk’)) 的值为__。(4) 
    189、 表达式 chr(ord(‘A’)+2) 的值为____。(’C’) 
    190、 已知x是一个列表对象,那么执行语句 y = x[:] 之后表达式 id(x) == id(y) 的值为_。(False) 
    191、 表达式 sorted([13, 1, 237, 89, 100], key=lambda x: len(str(x))) 的值为_________________________。([1, 13, 89, 237, 100]) 
    192、 Python中定义函数的关键字是_______。(def) 
    193、 在函数内部可以通过关键字______来定义全局变量。(global) 
    194、 如果函数中没有return语句或者return语句不带任何返回值,那么该函数的返回值为_______。(None) 
    195、 表达式 sum(range(10)) 的值为______。(45) 
    196、 表达式 sum(range(1, 10, 2)) 的值为__。(25) 
    197、 表达式 ‘abcab’.replace(‘a’,’yy’) 的值为_。(’yybcyyb’) 
    198、 已知 table = ”.maketrans(‘abcw’, ‘xyzc’),那么表达式 ‘Hellow world’.translate(table) 的值为____________。(’Helloc corld’) 
    199、 表达式 ‘hello world, hellow every one’.replace(‘hello’, ‘hi’) 的值为______________。(’hi world, hiw every one’) 
    200、 已知字符串 x = ‘hello world’,那么执行语句 x.replace(‘hello’, ‘hi’) 之后,x的值为__。(’hello world’) 
    201、 正则表达式元字符__用来表示该符号前面的字符或子模式1次或多次出现。(+) 
    202、 已知 x = ‘a b c d’,那么表达式 ‘,’.join(x.split()) 的值为_。(’a,b,c,d’) 
    203、 正则表达式元字符__用来表示该符号前面的字符或子模式0次或多次出现。(*) 
    204、 表达式 ‘abcab’.strip(‘ab’) 的值为____。(’c’) 
    205、 表达式 [str(i) for i in range(3)] 的值为__。([‘0’, ‘1’, ‘2’]) 
    206、 表达式 ‘abc.txt’.endswith((‘.txt’, ‘.doc’, ‘.jpg’)) 的值为_。(True) 
    207、 表达式 list(filter(None, [0,1,2,3,0,0])) 的值为_________。([1, 2, 3]) 
    208、 表达式 list(filter(lambda x:x>2, [0,1,2,3,0,0])) 的值为___。([3]) 
    209、 表达式 list(range(50, 60, 3)) 的值为_____________。([50, 53, 56, 59]) 
    210、 表达式 list(filter(lambda x: x%2==0, range(10))) 的值为________________。([0, 2, 4, 6, 8]) 
    211、 表达式 list(filter(lambda x: len(x)>3, [‘a’, ‘b’, ‘abcd’])) 的值为_。([‘abcd’]) 
    212、 Python使用_______关键字来定义类。(class) 
    213、 表达式 isinstance(‘abc’, str) 的值为______。(True) 
    214、 表达式 isinstance(‘abc’, int) 的值为_____。(False) 
    215、 表达式 isinstance(4j, (int, float, complex)) 的值为___。(True) 
    216、 表达式 isinstance(‘4’, (int, float, complex)) 的值为___。(False) 
    217、 表达式 type(3) in (int, float, complex) 的值为__。(True) 
    218、 表达式 type(3.0) in (int, float, complex) 的值为__。(True) 
    219、 表达式 type(3+4j) in (int, float, complex) 的值为__。(True) 
    220、 表达式 type(‘3’) in (int, float, complex) 的值为__。(False) 
    221、 表达式 type(3) == int 的值为____。(True) 
    222、 代码 print(1,2,3,sep=’:’) 的执行结果为________。(1:2:3) 
    223、 代码 for i in range(3):print(i, end=’,’) 的执行结果为_______。(0,1,2,) 
    224、 表达式 eval(”’import(‘math’).sqrt(9)”’) 的值为____。(3.0) 
    225、 表达式 eval(”’import(‘math’).sqrt(3**2+4**2)”’) 的值为___。(5.0) 
    226、 表达式 eval(‘3+5’) 的值为_______。(8) 
    227、 表达式 eval(‘[1, 2, 3]’) 的值为________。([1, 2, 3]) 
    228、 假设math标准库已导入,那么表达式 eval(‘math.sqrt(4)’) 的值为___。(2.0) 
    229、 已知x为非空列表,那么表达式 random.choice(x) in x 的值为_。(True) 
    230、 表达式 ‘abc10’.isalnum() 的值为____。(True) 
    231、 表达式 ‘abc10’.isalpha() 的值为______。(False) 
    232、 表达式 ‘abc10’.isdigit() 的值为________。(False) 
    233、 表达式 [1,2,3].count(4) 的值为_____。(0) 
    234、 Python标准库random中的_方法作用是从序列中随机选择1个元素。(choice()) 
    235、 表达式 ‘C:\windows\notepad.exe’.endswith(‘.exe’) 的值为__。(True) 
    236、 Python标准库random中的sample(seq, k)方法作用是从序列中选择__(重复?不重复?)的k个元素。(不重复) 
    237、 random模块中___方法的作用是将列表中的元素随机乱序。(shuffle()) 
    238、 Python关键字elif表示__和___两个单词的缩写。(else、if) 
    239、 执行代码 x, y, z = sorted([1, 3, 2]) 之后,变量y的值为__。(2) 
    240、 已知 x = {1:2, 2:3},那么表达式 x.get(3, 4) 的值为__。(4) 
    241、 已知 x = {1:2, 2:3},那么表达式 x.get(2, 4) 的值为__。(3) 
    242、 表达式 {1, 2, 3} | {3, 4, 5} 的值为___________。({1, 2, 3, 4, 5}) 
    243、 表达式 {1, 2, 3} | {2, 3, 4} 的值为____________。({1, 2, 3, 4}) 
    244、 表达式 {1, 2, 3} & {3, 4, 5} 的值为____。({3}) 
    245、 表达式 {1, 2, 3} & {2, 3, 4} 的值为_。({2, 3}) 
    246、 表达式 {1, 2, 3} - {3, 4, 5} 的值为___。({1, 2}) 
    247、 表达式 {1, 2, 3} < {3, 4, 5} 的值为___。(False) 
    248、 表达式 {1, 2, 3} < {1, 2, 4} 的值为_。(False) 
    249、 表达式 ‘%s’%[1,2,3] 的值为___。(’[1, 2, 3]’) 
    250、 在Python定义类时,与运算符“**”对应的特殊方法名为 ___。(pow()) 
    251、 在Python中定义类时,与运算符“//”对应的特殊方法名为_____。(floordiv()) 
    252、 对文件进行写入操作之后,_____方法用来在不关闭文件对象的情况下将缓冲区内容写入文件。(flush()) 
    253、 Python内置函数___用来打开或创建文件并返回文件对象。(open()) 
    254、 使用上下文管理关键字____可以自动管理文件对象,不论何种原因结束该关键字中的语句块,都能保证文件被正确关闭。(with) 
    255、 Python标准库os中用来列出指定文件夹中的文件和子文件夹列表的方式是__。(listdir()) 
    256、 Python标准库os.path中用来判断指定文件是否存在的方法是____。(exists()) 
    257、 Python标准库os.path中用来判断指定路径是否为文件的方法是_____。(isfile()) 
    258、 Python标准库os.path中用来判断指定路径是否为文件夹的方法是____。(isdir()) 
    259、 Python标准库os.path中用来分割指定路径中的文件扩展名的方法是____。(splitext()) 
    260、 Python内建异常类的基类是______。(BaseException) 
    261、 Python扩展库___支持Excel 2007或更高版本文件的读写操作。(openpyxl) 
    262、 Python标准库__中提供了计算MD5摘要的方法md5()。(hashlib) 
    263、 表达式 len(‘SDIBT’) 的值为____。(5) 
    264、 表达式 ‘Hello world!’.count(‘l’) 的值为_。(3) 
    265、 表达式 (1, 2, 3)+(4, 5) 的值为________。((1, 2, 3, 4, 5)) 
    266、 表达式 dict(zip([1, 2], [3, 4])) 的值为_______________________。({1: 3, 2: 4}) 
    267、 已知 x = ‘abcdefg’,则表达式 x[3:] + x[:3] 的值为_________。(’defgabc’) 
    268、 一直 g = lambda x, y=3, z=5: x*y*z,则语句 print(g(1)) 的输出结果为_。(15) 
    269、 表达式 list(map(lambda x: len(x), [‘a’, ‘bb’, ‘ccc’])) 的值为____。([1, 2, 3]) 
    270、 语句 x, y, z = [1, 2, 3] 执行后,变量y的值为____。(2) 
    271、 Python标准库____对Socket进行了二次封装,支持Socket接口的访问,大幅度简化了网络程序的开发。(socket) 
    272、 Python扩展库____中封装了Windows底层几乎所有API函数。(pywin32) 
    273、 线程对象的_方法用来阻塞当前线程,指定线程运行结束或超时后继续运行当前线程。(join()) 
    274、 Python用来访问和操作内置数据库SQLite的标准库是___。(sqlite3) 
    275、 用于删除数据库表test中所有name字段值为’10001’的记录的SQL语句为____________________。(delete from test where name=’10001’) 
    276、 Python扩展库______完美封装了图形库OpenGL的功能。(pyopengl) 
    277、 Python扩展库____和____提供了图像处理功能。(PIL、pillow) 
    278、 已知 x = [[1,3,3], [2,3,1]],那么表达式 sorted(x, key=lambda item:item[0]+item[2]) 的值为____________________________。([[2, 3, 1], [1, 3, 3]]) 
    279、 已知 x = [[1,3,3], [2,3,1]],那么表达式 sorted(x, key=lambda item:(item[1],item[2])) 的值为__________________________。([[2, 3, 1], [1, 3, 3]]) 
    280、 已知 x = [[1,3,3], [2,3,1]],那么表达式 sorted(x, key=lambda item:(item[1], -item[2])) 的值为__________________________。([[1, 3, 3], [2, 3, 1]]) 
    281、 已知 x = {1, 2, 3},那么执行语句 x.add(3) 之后,x的值为____。({1, 2, 3}) 
    282、 已知 x = {1:1},那么执行语句 x[2] = 2之后,len(x)的值为__。(2) 
    283、 已知 x = {1:1, 2:2},那么执行语句 x[2] = 4之后,len(x)的值为__。(2) 
    284、 假设已从标准库functools导入reduce()函数,那么表达式 reduce(lambda x, y: x-y, [1, 2, 3]) 的值为__。(-4) 
    285、 假设已从标准库functools导入reduce()函数,那么表达式 reduce(lambda x, y: x+y, [1, 2, 3]) 的值为__。(6) 
    286、 已知有函数定义 def demo(*p):return sum(p),那么表达式 demo(1, 2, 3) 的值为_、表达式 demo(1, 2, 3, 4) 的值为____。(6、10) 
    287、 已知列表 x = [1, 2],那么连续执行命令 y = x和 y.append(3) 之后,x的值为__。([1, 2, 3]) 
    288、 已知列表 x = [1, 2],那么连续执行命令 y = x[:] 和 y.append(3) 之后,x的值为__。([1, 2]) 
    289、 已知列表 x = [1, 2],执行语句 y = x[:] 后,表达式 id(x) == id(y) 的值为_。(False) 
    290、 已知列表 x = [1, 2],执行语句 y = x 后,表达式 id(x) == id(y) 的值为_。(True) 
    291、 已知列表 x = [1, 2],执行语句 y = x 后,表达式 x is y 的值为_。(True) 
    292、 已知列表 x = [1, 2],执行语句 y = x[:] 后,表达式 x is not y 的值为_。(True) 
    293、 表达式 sorted(random.sample(range(5), 5)) 的值为_______________。([0, 1, 2, 3, 4]) 
    294、 表达式 [i for i in range(10) if i>8] 的值为______。([9]) 
    295、 已知有列表 x = [[1, 2, 3], [4, 5, 6]],那么表达式 [[row[i] for row in x] for i in range(len(x[0]))] 的值为_________________。([[1, 4], [2, 5], [3, 6]]) 
    296、 执行语句 x,y,z = map(str, range(3)) 之后,变量y的值为_。(’1’) 
    297、 已知列表 x = [1, 2],那么执行语句 x.extend([3]) 之后, x的值为__。([1, 2, 3]) 
    298、 已知列表 x = [1, 2],那么执行语句 x.append([3]) 之后,x的值为___。([1, 2, [3]]) 
    299、 表达式 ‘aaasdf’.lstrip(‘as’) 的值为______。(’df’) 
    300、 表达式 ‘aaasdf’.lstrip(‘af’) 的值为______。(’sdf’) 
    301、 表达式 ‘aaasdf’.strip(‘af’) 的值为____。(’sd’) 
    302、 表达式 ‘aaasdf’.rstrip(‘af’) 的值为_____。(’aaasd’) 
    303、 已知 f = lambda x: x+5,那么表达式 f(3) 的值为__。(8) 
    304、 表达式 print(0b10101) 的值为__。(21) 
    305、 表达式 ‘\x41’ == ‘A’ 的值为___。(True) 
    306、 已知 x = [1, 2, 3, 4, 5],那么执行语句 del x[:3] 之后,x的值为____。([4, 5]) 
    307、 表达式 sorted([‘abc’, ‘acd’, ‘ade’], key=lambda x:(x[0],x[2])) 的值为___。([‘abc’, ‘acd’, ‘ade’]) 
    308、 已知 x = range(1,4) 和 y = range(4,7),那么表达式 sum([i*j for i,j in zip(x,y)]) 的值为____。(32) 
    309、 表达式 [5 for i in range(3)] 的值为_____。([5, 5, 5]) 
    310、 表达式 {1, 2, 3} == {1, 3, 2} 的值为_。(True) 
    311、 表达式 [1, 2, 3] == [1, 3, 2] 的值为__。(False) 
    312、 已知 x = [1, 2, 1],那么表达式 id(x[0]) == id(x[2]) 的值为_____。(True) 
    313、 表达式 3 not in [1, 2, 3]的值为____。(False) 
    314、 已知 x = [1, 2],那么执行语句 x[0:0] = [3, 3]之后,x的值为_。([3, 3, 1, 2]) 
    315、 已知 x = [1, 2],那么执行语句 x[0:1] = [3, 3]之后,x的值为_。([3, 3, 2]) 
    316、 已知 x = [1, 2, 3, 4, 5],那么执行语句 del x[1:3] 之后,x的值为__。([1, 4, 5]) 
    317、 已知 x = [[1, 2, 3,], [4, 5, 6]],那么表达式 sum([i*j for i,j in zip(*x)]) 的值为__。(32) 
    318、 已知列表 x = [1, 2, 3] 和 y = [4, 5, 6],那么表达式 [(i,j) for i, j in zip(x,y) if i==3] 的值为__。([(3, 6)]) 
    319、 已知列表 x = [1.0, 2.0, 3.0],那么表达式 sum(x)/len(x) 的值为_。(2.0) 
    320、 表达式 ‘abc’ in (‘abcdefg’) 的值为____。(True) 
    321、 表达式 ‘abc’ in [‘abcdefg’] 的值为____。(False) 
    322、 已知 x = {1:2, 2:3, 3:4},那么表达式 sum(x) 的值为_。(6) 
    323、 已知 x = {1:2, 2:3, 3:4},那么表达式 sum(x.values()) 的值为___。(9) 
    324、 已知 x = [3, 2, 3, 3, 4],那么表达式 [index for index, value in enumerate(x) if value==3] 的值为__。([0, 2, 3]) 
    325、 表达式 1234%1000//100 的值为_。(2) 
    326、 正则表达式模块re的____方法用来编译正则表达式对象。(compile()) 
    327、 正则表达式模块re的____方法用来在字符串开始处进行指定模式的匹配。(match()) 
    328、 正则表达式模块re的____方法用来在整个字符串中进行指定模式的匹配。(search()) 
    329、 表达式 re.search(r’\w*?(?P\b\w+\b)\s+(?P=f)\w*?’, ‘Beautiful is is better than ugly.’).group(0) 的值为_。(’is is’) 
    330、 已知 g = lambda x, y=3, z=5: x+y+z,那么表达式 g(2) 的值为__。(10) 
    331、 假设有Python程序文件abc.py,其中只有一条语句print(name),那么直接运行该程序时得到的结果为___。(main) 
    332、 表达式 3 in {1, 2, 3} 的值为___。(True) 
    333、 表达式 ‘ac’ in ‘abce’ 的值为___。(False) 
    334、 表达式 not 3 的值为______。(False) 
    335、 表达式 3 // 5 的值为_____。(0) 
    336、 表达式 [1, 2] + [3] 的值为________。([1, 2, 3]) 
    337、 表达式 (1,) + (2,) 的值为___。((1, 2)) 
    338、 表达式 (1) + (2) 的值为__。(3) 
    339、 已知 x, y = map(int, [‘1’, ‘2’]),那么表达式 x + y 的值为_。(3) 
    340、 已知列表 x = list(range(5)),那么执行语句 x.remove(3) 之后,表达式 x.index(4) 的值为__。(3) 
    341、 已知列表 x = [1, 3, 2],那么执行语句 x.reverse() 之后,x的值为__。([2, 3, 1]) 
    342、 已知列表 x = [1, 3, 2],那么执行语句 x = x.reverse() 之后,x的值为__。(None) 
    343、 已知x为非空列表,那么表达式 x.reverse() == list(reversed(x)) 的值为____。(False) 
    344、 已知x为非空列表,那么表达式 x.sort() == sorted(x) 的值为____。(False) 
    345、 已知列表 x = [1, 3, 2],那么执行语句 y = list(reversed(x)) 之后,x的值为____。([1, 3, 2]) 
    346、 已知列表 x = [1, 3, 2],那么执行语句 y = list(reversed(x)) 之后,y的值为____。([2, 3, 1]) 
    347、 表达式 ‘Beautiful is better than ugly.’.startswith(‘Be’, 5) 的值为___。(False) 
    348、 已知列表x中包含超过5个以上的元素,那么表达式 x == x[:5]+x[5:] 的值为__。(True) 
    349、 已知字典 x = {i:str(i+3) for i in range(3)},那么表达式 sum(x) 的值为__。(3) 
    350、 已知字典 x = {i:str(i+3) for i in range(3)},那么表达式 ”.join(x.values()) 的值为__。(’345’) 
    351、 已知字典 x = {i:str(i+3) for i in range(3)},那么表达式 sum(item[0] for item in x.items()) 的值为_。(3) 
    352、 已知字典 x = {i:str(i+3) for i in range(3)},那么表达式 ”.join([item[1] for item in x.items()]) 的值为___。(’345’) 
    353、 已知列表 x = [1, 3, 2],那么表达式 [value for index, value in enumerate(x) if index==2] 的值为_____。([2]) 
    354、 已知列表 x = [1, 3, 2],那么执行语句 a, b, c = sorted(x) 之后,b的值为__。(2) 
    355、 已知列表 x = [1, 3, 2],那么执行语句 a, b, c = map(str,sorted(x)) 之后,c的值为__。(’3’) 
    356、 表达式 set([1,2,3]) == {1, 2, 3} 的值为__。(True) 
    357、 表达式 set([1,2, 2,3]) == {1, 2, 3} 的值为__。(True) 
    358、 表达式 ‘%c’%65 == str(65) 的值为_。(False) 
    359、 表达式 ‘%s’%65 == str(65) 的值为___。(True) 
    360、 表达式 chr(ord(‘b’)^32) 的值为___。(’B’) 
    361、 表达式 ‘abc’ in ‘abdcefg’ 的值为___。(False) 
    362、 已知函数定义 def func(*p):return sum(p),那么表达式 func(1,2,3) 的值为__。(6) 
    363、 已知函数定义 def func(*p):return sum(p),那么表达式 func(1,2,3, 4) 的值为__。(10) 
    364、 已知函数定义 def func(**p):return sum(p.values()),那么表达式 func(x=1, y=2, z=3) 的值为__。(6) 
    365、 已知函数定义 def func(**p):return ”.join(sorted(p)),那么表达式 func(x=1, y=2, z=3)的值为____。(’xyz’) 
    366、 已知x为整数变量,那么表达式 int(hex(x), 16) == x 的值为___。(True) 
    367、 已知 f = lambda x: 5,那么表达式 f(3)的值为___。(5) 
    368、 已知 x, y = 3, 5,那么执行x, y = y, x 之后,x的值为____。(5) 
    369、 已知 x = ‘abcd’ 和 y = ‘abcde’,那么表达式 [i==j for i,j in zip(x,y)] 的值为______。([True, True, True, True]) 
    370、 表达式16**0.5的值为__________。(4.0) 
    371、 表达式type({3})的值为__________。(set) 
    372、 表达式isinstance(‘Hello world’, str)的值为__________。(True) 
    373、 已知x = list(range(20)),那么表达式x[-1]的值为__________。(19) 
    374、 已知x = 3+4j和y = 5+6j,那么表达式x+y的值为__________。(8+10j) 
    375、 已知x = [3],那么执行x += [5]之后x的值为__________。([3, 5]) 
    376、 已知x = [3, 3, 4],那么表达式id(x[0])==id(x[1])的值为________。(True) 
    377、 表达式int(‘11’, 2)的值为____________。(3) 
    378、 表达式int(‘11’, 8)的值为_____________。(9) 
    379、 表达式int(bin(54321), 2)的值为_____________。(54321) 
    380、 表达式chr(ord(‘A’)+1)的值为__________。(’B’) 
    381、 表达式int(str(34)) == 34的值为_________。(True) 
    382、 表达式list(str([3, 4])) == [3, 4]的值为_______。(False) 
    383、 表达式{1, 2, 3, 4, 5, 6} ^ {5, 6, 7, 8}的值为________。({1, 2, 3, 4, 7, 8}) 
    384、 表达式15 // 4的值为________。(3) 
    385、 表达式sorted({‘a’:3, ‘b’:9, ‘c’:78})的值为_______。([‘a’, ‘b’, ‘c’]) 
    386、 表达式sorted({‘a’:3, ‘b’:9, ‘c’:78}.values())的值为___。([3, 9, 78]) 
    387、 已知x = [3, 2, 4, 1],那么执行语句x = x.sort()之后,x的值为__。(None) 
    388、 表达式list(filter(lambda x: x>5, range(10)))的值为_______。([6, 7, 8, 9]) 
    389、 已知x = list(range(20)),那么语句print(x[100:200])的输出结果为_____。([]) 
    390、 已知x = list(range(20)),那么执行语句x[:18] = []后列表x的值为____。([18, 19]) 
    391、 已知x = [1, 2, 3],那么连续执行y = x[:]和y.append(4)这两条语句之后,x的值为__________。([1, 2, 3]) 
    392、 已知x = [1, 2, 3],那么连续执行y = x和y.append(4)这两条语句之后,x的值为__________。([1, 2, 3, 4]) 
    393、 已知x = [1, 2, 3],那么连续执行y = [1, 2, 3]和y.append(4)这两条语句之后,x的值为__________。([1, 2, 3]) 
    394、 已知x = [[]] * 3,那么执行语句x[0].append(1)之后,x的值为__________。([[1], [1], [1]]) 
    395、 已知x = [[] for i in range(3)],那么执行语句x[0].append(1)之后,x的值为_______。([[1], [], []]) 
    396、 已知x = ([1], [2]),那么执行语句x[0].append(3)后x的值为______。(([1, 3], [2])) 
    397、 已知x = {1:1, 2:2},那么执行语句x.update({2:3, 3:3})之后,表达式sorted(x.items())的值为__________。([(1, 1), (2, 3), (3, 3)]) 
    398、 已知x = {1:1, 2:2},那么执行语句x[3] = 3之后,表达式sorted(x.items())的值为__________。([(1, 1), (2, 2), (3, 3)]) 
    399、 表达式type({}) == dict的值为_______。(True) 
    400、 表达式type({}) == set的值为_____。(False) 
    401、 已知x = [1, 2, 3],那么表达式not (set(x*100)-set(x))的值为______。(True) 
    402、 已知x = [1, 2, 3],那么表达式not (set(x*100)&set(x))的值为______。(False) 
    403、 表达式{‘x’: 1, **{‘y’: 2}}的值为_________。({‘x’: 1, ‘y’: 2}) 
    404、 表达式{range(4), 4, (5, 6, 7)}的值为________。({0, 1, 2, 3, 4, 5, 6, 7}) 
    405、 在Python中,不论类的名字是什么,构造方法的名字都是______。(init) 
    406、 如果在设计一个类时实现了contains ()方法,那么该类的对象会自动支持___运算符。(in) 
    407、 已知函数定义def demo(x, y, op):return eval(str(x)+op+str(y)),那么表达式demo(3, 5, ‘+’)的值为____________。(8) 
    408、 已知函数定义def demo(x, y, op):return eval(str(x)+op+str(y)),那么表达式demo(3, 5, ‘*’)的值为____________。(15) 
    409、 已知函数定义def demo(x, y, op):return eval(str(x)+op+str(y)),那么表达式demo(3, 5, ‘-‘)的值为____________。(-2) 
    410、 字符串编码格式UTF8使用__________个字节表示一个汉字。(3) 
    411、 字符串编码格式GBK使用________个字节表示一个汉字。(2) 
    412、 已知字符串编码格式utf8使用3个字节表示一个汉字、1个字节表示英语字母,那么表达式len(‘abc你好’)的值为_____。(5) 
    413、 已知字符串编码格式utf8使用3个字节表示一个汉字、1个字节表示英语字母,那么表达式len(‘abc你好’.encode())的值为_____。(9) 
    414、 已知字符串编码格式gbk使用2个字节表示一个汉字、1个字节表示英语字母,那么表达式len(‘abc你好’.encode(‘gbk’))的值为_____。(7) 
    415、 已知ord(‘A’)的值为65并且hex(65)的值为’0x41’,那么表达式’\x41b’的值为______。(’Ab’) 
    416、 已知formatter = ‘good {0}’.format,那么表达式list(map(formatter, [‘morning’]))的值为________。([‘good morning’]) 
    417、 已知x = ‘hello world.’,那么表达式x.find(‘x’)和x.rfind(‘x’)的值都为___。(-1) 
    418、 表达式’:’.join(‘hello world.’.split())的值为_________。(’hello:world.’) 
    419、 表达式’:’.join(‘a b c d’.split(maxsplit=2))的值为_______。(’a:b:c d’) 
    420、 已知x = ‘hello world’,那么表达式x.replace(‘l’, ‘g’)的值为_____。(’heggo worgd’) 
    421、 假设已成功导入Python标准库string,那么表达式len(string.digits)的值为_____。(10) 
    422、 表达式’aaaassddf’.strip(‘af’)的值为________。(’ssdd’) 
    423、 表达式len(‘aaaassddf’.strip(‘afds’))的值为______。(0) 
    424、 表达式len(‘hello world’[100:])的值为________。(0) 
    425、 表达式chr(ord(‘a’)^32^32)的值为_______。(’a’) 
    426、 表达式chr(ord(‘a’)^32)的值为_______。(’A’) 
    427、 已知x = ‘aa b ccc dddd’,那么表达式”.join([v for i,v in enumerate(x[:-1]) if v==x[i+1]])的值为_______。(’accddd’) 
    428、 已知当前文件夹中有纯英文文本文件readme.txt,请填空完成功能把readme.txt文件中的所有内容复制到dst.txt中,with open(‘readme.txt’) as src, open(‘dst.txt’, __) as dst:dst.write(src.read())。(’w’) 
    429、 假设正则表达式模块re已正确导入,那么表达式”.join(re.findall(‘\d+’, ‘abcd1234’))的值为___________。(’1234’) 
    430、 假设正则表达式模块re已正确导入,那么表达式re.findall(‘\d+?’, ‘abcd1234’)的值为___________。([‘1’, ‘2’, ‘3’, ‘4’]) 
    431、 假设正则表达式模块re已正确导入,那么表达式re.sub(‘(.\s)\1+’, ‘\1’,’a a a a a bb’)的值为______________。(’a bb’) 
    432、 Python标准库___________提供了对SQLite数据库的访问接口。(sqlite3) 
    433、 
    二、 判断题 
    1、 Python是一种跨平台、开源、免费的高级动态编程语言。(对) 
    2、 Python 3.x完全兼容Python 2.x。(错) 
    3、 Python 3.x和Python 2.x唯一的区别就是:print在Python 2.x中是输出语句,而在Python 3.x中是输出函数。(错) 
    4、 在Windows平台上编写的Python程序无法在Unix平台运行。(错) 
    5、 不可以在同一台计算机上安装多个Python版本。(错) 
    6、 已知 x = 3,那么赋值语句 x = ‘abcedfg’ 是无法正常执行的。(错) 
    7、 继承自threading.Thread类的派生类中不能有普通的成员方法。(错) 
    8、 扩展库os中的方法remove()可以删除带有只读属性的文件。(错) 
    9、 使用内置函数open()且以”w”模式打开的文件,文件指针默认指向文件尾。(错) 
    10、 使用内置函数open()打开文件时,只要文件路径正确就总是可以正确打开的。(错) 
    11、 Python变量使用前必须先声明,并且一旦声明就不能再当前作用域内改变其类型。(错) 
    12、 Python采用的是基于值得自动内存管理方式。(对) 
    13、 在任何时刻相同的值在内存中都只保留一份(错) 
    14、 Python不允许使用关键字作为变量名,允许使用内置函数名作为变量名,但这会改变函数名的含义。(对) 
    15、 在Python中可以使用if作为变量名。(错) 
    16、 在Python 3.x中可以使用中文作为变量名。(对) 
    17、 Python变量名必须以字母或下划线开头,并且区分字母大小写。(对) 
    18、 加法运算符可以用来连接字符串并生成新字符串。(对) 
    19、 9999**9999这样的命令在Python中无法运行。(错) 
    20、 3+4j不是合法的Python表达式。(错) 
    21、 0o12f是合法的八进制数字。(错) 
    22、 Python 2.x和Python 3.x中input()函数的返回值都是字符串。(错) 
    23、 pip命令也支持扩展名为.whl的文件直接安装Python扩展库。(对) 
    24、 只有Python扩展库才需要导入以后才能使用其中的对象,Python标准库不需要导入即可使用其中的所有对象和方法。(错) 
    25、 在Python中0xad是合法的十六进制数字表示形式。(对) 
    26、 3+4j 是合法Python数字类型。(对) 
    27、 在Python中0oa1是合法的八进制数字表示形式。(错) 
    28、 Python使用缩进来体现代码之间的逻辑关系。(对) 
    29、 Python代码的注释只有一种方式,那就是使用#符号。(错) 
    30、 调用函数时,在实参前面加一个型号*表示序列解包。(对) 
    31、 放在一对三引号之间的任何内容将被认为是注释。(错) 
    32、 Python支持使用字典的“键”作为下标来访问字典中的值。(对) 
    33、 列表可以作为字典的“键”。(错) 
    34、 元组可以作为字典的“键”。(对) 
    35、 字典的“键”必须是不可变的。(对) 
    36、 尽管可以使用import语句一次导入任意多个标准库或扩展库,但是仍建议每次只导入一个标准库或扩展库。(对) 
    37、 为了让代码更加紧凑,编写Python程序时应尽量避免加入空格和空行。(错) 
    38、 在Python 3.5中运算符+不仅可以实现数值的相加、字符串连接,还可以实现列表、元组的合并和集合的并集运算。(错) 
    39、 已知x为非空列表,那么表达式 sorted(x, reverse=True) == list(reversed(x)) 的值一定是True。(错) 
    40、 已知x为非空列表,那么x.sort(reverse=True)和x.reverse()的作用是等价的。(错) 
    41、 生成器推导式比列表推导式具有更高的效率,推荐使用。(对) 
    42、 Python集合中的元素不允许重复。(对) 
    43、 Python集合可以包含相同的元素。(错) 
    44、 Python字典中的“键”不允许重复。(对) 
    45、 Python字典中的“值”不允许重复。(错) 
    46、 Python集合中的元素可以是元组。(对) 
    47、 Python集合中的元素可以是列表。(错) 
    48、 Python字典中的“键”可以是列表。(错) 
    49、 Python字典中的“键”可以是元组。(对) 
    50、 Python列表中所有元素必须为相同类型的数据。(错) 
    51、 Python列表、元组、字符串都属于有序序列。(对) 
    52、 在Python 3.x中语句 print(*[1,2,3]) 不能正确执行。(错) 
    53、 已知A和B是两个集合,并且表达式A < B的值为False,那么表达式A > B的值一定为True。(错) 
    54、 列表对象的append()方法属于原地操作,用于在列表尾部追加一个元素。(对) 
    55、 对于列表而言,在尾部追加元素比在中间位置插入元素速度更快一些,尤其是对于包含大量元素的列表。(对) 
    56、 假设有非空列表x,那么x.append(3)、x = x+[3]与x.insert(0,3)在执行时间上基本没有太大区别。(错) 
    57、 使用Python列表的方法insert()为列表插入元素时会改变列表中插入位置之后元素的索引。(对) 
    58、 假设x为列表对象,那么x.pop()和x.pop(-1)的作用是一样的。(对) 
    59、 使用del命令或者列表对象的remove()方法删除列表中元素时会影响列表中部分元素的索引。(对) 
    60、 带有else子句的循环如果因为执行了break语句而退出的话,则会执行else子句中的代码。(错) 
    61、 对于带有else子句的循环语句,如果是因为循环条件表达式不成立而自然结束循环,则执行else子句中的代码。(对) 
    62、 已知列表 x = [1, 2, 3],那么执行语句 x = 3 之后,变量x的地址不变。(错) 
    63、 在UTF-8编码中一个汉字需要占用3个字节。(对) 
    64、 在GBK和CP936编码中一个汉字需要2个字节。(对) 
    65、 如果仅仅是用于控制循环次数,那么使用for i in range(20)和for i in range(20, 40)的作用是等价的。(对) 
    66、 使用列表对象的remove()方法可以删除列表中首次出现的指定元素,如果列中不存在要删除的指定元素则抛出异常。(对) 
    67、 元组是不可变的,不支持列表对象的inset()、remove()等方法,也不支持del命令删除其中的元素,但可以使用del命令删除整个元组对象。(对) 
    68、 Python字典和集合属于无序序列。(对) 
    69、 无法删除集合中指定位置的元素,只能删除特定值的元素。(对) 
    70、 元组的访问速度比列表要快一些,如果定义了一系列常量值,并且主要用途仅仅是对其进行遍历二不需要进行任何修改,建议使用元组而不使用列表。(对) 
    71、 当以指定“键”为下标给字典对象赋值时,若该“键”存在则表示修改该“键”对应的“值”,若不存在则表示为字典对象添加一个新的“键-值对”。(对) 
    72、 假设x是含有5个元素的列表,那么切片操作x[10:]是无法执行的,会抛出异常。(错) 
    73、 只能对列表进行切片操作,不能对元组和字符串进行切片操作。(错) 
    74、 只能通过切片访问列表中的元素,不能使用切片修改列表中的元素。(错) 
    75、 只能通过切片访问元组中的元素,不能使用切片修改元组中的元素。(对) 
    76、 字符串属于Python有序序列,和列表、元组一样都支持双向索引。(对) 
    77、 Python字典和集合支持双向索引。(错) 
    78、 使用print()函数无法将信息写入文件。(错) 
    79、 Python集合不支持使用下标访问其中的元素。(对) 
    80、 相同内容的字符串使用不同的编码格式进行编码得到的结果并不完全相同。(对) 
    81、 删除列表中重复元素最简单的方法是将其转换为集合后再重新转换为列表。(对) 
    82、 已知列表x中包含超过5个以上的元素,那么语句 x = x[:5]+x[5:] 的作用是将列表x中的元素循环左移5位。(错) 
    83、 对于生成器对象x = (3 for i in range(5)),连续两次执行list(x)的结果是一样的。(错) 
    84、 在循环中continue语句的作用是跳出当前循环。(错) 
    85、 在编写多层循环时,为了提高运行效率,应尽量减少内循环中不必要的计算。(对) 
    86、 在Python中,任意长的字符串都遵守驻留机制。(错) 
    87、 Python运算符%不仅可以用来求余数,还可以用来格式化字符串。(对) 
    88、 Python字符串方法replace()对字符串进行原地修改。(错) 
    89、 如果需要连接大量字符串成为一个字符串,那么使用字符串对象的join()方法比运算符+具有更高的效率。(对) 
    90、 对于大量列表的连接,extend()方法比运算符+具有更高的效率。(对) 
    91、 表达式 {1, 3, 2} > {1, 2, 3} 的值为True。(错) 
    92、 列表对象的extend()方法属于原地操作,调用前后列表对象的地址不变。(对) 
    93、 正则表达式模块re的match()方法是从字符串的开始匹配特定模式,而search()方法是在整个字符串中寻找模式,这两个方法如果匹配成功则返回match对象,匹配失败则返回空值None。(对) 
    94、 函数是代码复用的一种方式。(对) 
    95、 定义函数时,即使该函数不需要接收任何参数,也必须保留一对空的圆括号来表示这是一个函数。(对) 
    96、 编写函数时,一般建议先对参数进行合法性检查,然后再编写正常的功能代码。(对) 
    97、 一个函数如果带有默认值参数,那么必须所有参数都设置默认值。(错) 
    98、 定义Python函数时必须指定函数返回值类型。(错) 
    99、 定义Python函数时,如果函数中没有return语句,则默认返回空值None。(对) 
    100、 如果在函数中有语句 return 3,那么该函数一定会返回整数3。(错) 
    101、 函数中必须包含return语句。(错) 
    102、 函数中的return语句一定能够得到执行。(错) 
    103、 不同作用域中的同名变量之间互相不影响,也就是说,在不同的作用域内可以定义同名的变量。(对) 
    104、 全局变量会增加不同函数之间的隐式耦合度,从而降低代码可读性,因此应尽量避免过多使用全局变量。(对) 
    105、 函数内部定义的局部变量当函数调用结束后被自动删除。(对) 
    106、 在函数内部,既可以使用global来声明使用外部全局变量,也可以使用global直接定义全局变量。(对) 
    107、 在函数内部没有办法定义全局变量。(错) 
    108、 对于数字n,如果表达式 0 not in [n%d for d in range(2, n)] 的值为True则说明n是素数。(对) 
    109、 表达式 ‘a’+1的值为’b’。(错) 
    110、 在函数内部直接修改形参的值并不影响外部实参的值。(对) 
    111、 在函数内部没有任何方法可以影响实参的值。(错) 
    112、 调用带有默认值参数的函数时,不能为默认值参数传递任何值,必须使用函数定义时设置的默认值。(错) 
    113、 创建只包含一个元素的元组时,必须在元素后面加一个逗号,例如(3,)。(对) 
    114、 在同一个作用域内,局部变量会隐藏同名的全局变量。(对) 
    115、 形参可以看做是函数内部的局部变量,函数运行结束之后形参就不可访问了。(对) 
    116、 假设已导入random标准库,那么表达式 max([random.randint(1, 10) for i in range(10)]) 的值一定是10。(错) 
    117、 Python标准库random的方法randint(m,n)用来生成一个[m,n]区间上的随机整数。(对) 
    118、 Python中一切内容都可以称为对象。(对) 
    119、 栈和队列的都具有先入后出的特点。(错) 
    120、 在一个软件的设计与开发中,所有类名、函数名、变量名都应该遵循统一的风格和规范。(对) 
    121、 定义类时所有实例方法的第一个参数用来表示对象本身,在类的外部通过对象名来调用实例方法时不需要为该参数传值。(对) 
    122、 在面向对象程序设计中,函数和方法是完全一样的,都必须为所有参数进行传值。(错) 
    123、 Python中没有严格意义上的私有成员。(对) 
    124、 在Python中定义类时,运算符重载是通过重写特殊方法实现的。例如,在类中实现了mul()方法即可支持该类对象的**运算符。(对) 
    125、 在IDLE交互模式下,一个下划线“_”表示解释器中最后一次显示的内容或最后一次语句正确执行的输出结果。(对) 
    126、 对于Python类中的私有成员,可以通过“对象名.类名_私有成员名”的方式来访问。(对) 
    127、 运算符 / 在Python 2.x和Python 3.x中具有相同的功能。(错) 
    128、 运算符“-”可以用于集合的差集运算。(对) 
    129、 如果定义类时没有编写析构函数,Python将提供一个默认的析构函数进行必要的资源清理工作。(对) 
    130、 已知seq为长度大于10的列表,并且已导入random模块,那么[random.choice(seq) for i in range(10)]和random.sample(seq,10)等价。(错) 
    131、 在派生类中可以通过“基类名.方法名()”的方式来调用基类中的方法。(对) 
    132、 Python支持多继承,如果父类中有相同的方法名,而在子类中调用时没有指定父类名,则Python解释器将从左向右按顺序进行搜索。(对) 
    133、 对文件进行读写操作之后必须显式关闭文件以确保所有内容都得到保存。(对) 
    134、 Python标准库os中的方法startfile()可以启动任何已关联应用程序的文件,并自动调用关联的程序。(对) 
    135、 程序中异常处理结构在大多数情况下是没必要的。(错) 
    136、 在try…except…else结构中,如果try块的语句引发了异常则会执行else块中的代码。(错) 
    137、 Python标准库threading中的Lock、RLock、Condition、Event、Semaphore对象都可以用来实现线程同步。(对) 
    138、 异常处理结构中的finally块中代码仍然有可能出错从而再次引发异常。(对) 
    139、 在GUI设计中,复选框往往用来实现非互斥多选的功能,多个复选框之间的选择互不影响。(对) 
    140、 在GUI设计中,单选按钮用来实现用户在多个选项中的互斥选择,在同一组内多个选项中只能选择一个,当选择发生变化之后,之前选中的选项自动失效。(对) 
    141、 在Python中定义类时实例方法的第一个参数名称必须是self。(错) 
    142、 在Python中定义类时实例方法的第一个参数名称不管是什么,都表示对象自身。(对) 
    143、 Python代码可以内嵌在asp文件中。(对) 
    144、 无法配置IIS来支持Python程序的运行。(错) 
    145、 Python标准库os中的方法startfile()可以用来打开外部程序或文件,系统会自动关联相应的程序来打开或执行指定的文件。(对) 
    146、 在编写应用程序时,应合理控制线程数量,线程并不是越多越好。(对) 
    147、 在多线程编程时,当某子线程的daemon属性为False时,主线程结束时会检测该子线程是否结束,如果该子线程尚未运行结束,则主线程会等待它完成后再退出。(对) 
    148、 Python只能使用内置数据库SQLite,无法访问MS SQLServer、ACCESS或Oracle、MySQL等数据库。(错) 
    149、 使用OpenGL画图时,画点是最基本的操作,具体生成的图形由glBegin()函数指定的mode来决定。例如,mode值为GL_TRIANGLES时表示将要绘制三角形。(对) 
    150、 OpenGL采用的“状态机”工作方式,一旦设置了某种状态以后,除非显式修改该状态,否则该状态将一直保持。(对) 
    151、 假设os模块已导入,那么列表推导式 [filename for filename in os.listdir(‘C:\Windows’) if filename.endswith(‘.exe’)] 的作用是列出C:\Windows文件夹中所有扩展名为.exe的文件。(对) 
    152、 表达式 list(‘[1, 2, 3]’) 的值是[1, 2, 3]。(错) 
    153、 在函数内部没有任何声明的情况下直接为某个变量赋值,这个变量一定是函数内部的局部变量。(对) 
    154、 定义类时如果实现了contains()方法,该类对象即可支持成员测试运算in。(对) 
    155、 定义类时如果实现了len()方法,该类对象即可支持内置函数len()。(对) 
    156、 定义类时实现了eq()方法,该类对象即可支持运算符==。(对) 
    157、 定义类时实现了pow()方法,该类对象即可支持运算符**。(对) 
    158、 二进制文件不能使用记事本程序打开。(错) 
    159、 使用普通文本编辑器软件也可以正常查看二进制文件的内容。(错) 
    160、 二进制文件也可以使用记事本或其他文本编辑器打开,但是一般来说无法正常查看其中的内容。(对) 
    161、 Python标准库os中的方法isfile()可以用来测试给定的路径是否为文件。(对) 
    162、 Python标准库os中的方法exists()可以用来测试给定路径的文件是否存在。(对) 
    163、 Python标准库os中的方法isdir()可以用来测试给定的路径是否为文件夹。(对) 
    164、 Python标准库os中的方法listdir()返回包含指定路径中所有文件和文件夹名称的列表。(对) 
    165、 Python扩展库xlwt支持对Excel 2003或更低版本的Excel文件进行写操作。(对) 
    166、 Python扩展库xlrd支持对Excel 2003或更低版本的Excel文件进行读操作。(对) 
    167、 带有else子句的异常处理结构,如果不发生异常则执行else子句中的代码。(对) 
    168、 异常处理结构也不是万能的,处理异常的代码也有引发异常的可能。(对) 
    169、 在异常处理结构中,不论是否发生异常,finally子句中的代码总是会执行的。(对) 
    170、 在Python中定义函数时不需要声明函数参数的类型。(对) 
    171、 在Python中定义函数时不需要声明函数的返回值类型。(对) 
    172、 在函数中没有任何办法可以通过形参来影响实参的值。(错) 
    173、 已知 x = 3,那么执行语句 x+=6 之后,x的内存地址不变。(错) 
    174、 已知x为非空字符串,那么表达式 ”.join(x.split()) == x 的值一定为True。(错) 
    175、 已知x为非空字符串,那么表达式 ‘,’.join(x.split(‘,’)) == x 的值一定为True。(对) 
    176、 在Python中可以使用 for 作为变量名。(错) 
    177、 在Python中可以使用 id 作为变量名,尽管不建议这样做。(对) 
    178、 Python关键字不可以作为变量名。(对) 
    179、 一个数字5也是合法的Python表达式。(对) 
    180、 同一个列表对象中的元素类型可以各不相同。(对) 
    181、 同一个列表对象中所有元素必须为相同类型。(错) 
    182、 已知x为非空列表,那么执行语句x[0] = 3之后,列表对象x的内存地址不变。(对) 
    183、 列表可以作为集合的元素。(错) 
    184、 集合可以作为列表的元素。(对) 
    185、 元组可以作为集合的元素。(对) 
    186、 集合可以作为元组的元素。(对) 
    187、 字典可以作为集合的元素。(错) 
    188、 集合可以作为字典的键。(错) 
    189、 集合可以作为字典的值。(对) 
    190、 可以使用del删除集合中的部分元素。(错) 
    191、 标准库os的rename()方法可以实现文件移动操作。(对) 
    192、 标准库os的listdir()方法默认只能列出指定文件夹中当前层级的文件和文件夹列表,而不能列出其子文件夹中的文件。(对) 
    193、 当作为条件表达式时,[]与None等价。(对) 
    194、 表达式 [] == None 的值为True。(错) 
    195、 当作为条件表达式时,{}与None等价。(对) 
    196、 表达式 {}==None 的值为True。(错) 
    197、 表达式 pow(3,2) == 3**2 的值为True。(对) 
    198、 当作为条件表达式时,空值、空字符串、空列表、空元组、空字典、空集合、空迭代对象以及任意形式的数字0都等价于False。(对) 
    199、 在定义函数时,某个参数名字前面带有一个*符号表示可变长度参数,可以接收任意多个普通实参并存放于一个元组之中。(对) 
    200、 在定义函数时,某个参数名字前面带有两个*符号表示可变长度参数,可以接收任意多个关键参数并将其存放于一个字典之中。(对) 
    201、 定义函数时,带有默认值的参数必须出现在参数列表的最右端,任何一个带有默认值的参数右边不允许出现没有默认值的参数。(对) 
    202、 在调用函数时,可以通过关键参数的形式进行传值,从而避免必须记住函数形参顺序的麻烦。(对) 
    203、 在调用函数时,必须牢记函数形参顺序才能正确传值。(错) 
    204、 调用函数时传递的实参个数必须与函数形参个数相等才行。(错) 
    205、 正则表达式对象的match()方法可以在字符串的指定位置开始进行指定模式的匹配。(对) 
    206、 使用正则表达式对字符串进行分割时,可以指定多个分隔符,而字符串对象的split()方法无法做到这一点。(对) 
    207、 在编写函数时,建议首先对形参进行类型检查和数值范围检查之后再编写功能代码,或者使用异常处理结构,尽量避免代码抛出异常而导致程序崩溃。(对) 
    208、 执行语句 from math import sin 之后,可以直接使用 sin() 函数,例如 sin(3)。(对) 
    209、 列表对象的pop()方法默认删除并返回最后一个元素,如果列表已空则抛出异常。(对) 
    210、 在Python中定义类时,如果某个成员名称前有2个下划线则表示是私有成员。(对) 
    211、 在类定义的外部没有任何办法可以访问对象的私有成员。(错) 
    212、 可以使用py2exe或pyinstaller等扩展库把Python源程序打包成为exe文件,从而脱离Python环境在Windows平台上运行。(对) 
    213、 Python程序只能在安装了Python环境的计算机上以源代码形式运行。(错) 
    214、 不同版本的Python不能安装到同一台计算机上。(错) 
    215、 一般来说,Python扩展库没有通用于所有版本Python的,安装时应选择与已安装Python的版本对应的扩展库。 
    216、 表达式 {1, 2} * 2 的值为 {1, 2, 1, 2}。(错) 
    217、 Python变量名区分大小写,所以student和Student不是同一个变量。(对) 
    218、 正则表达式元字符“^”一般用来表示从字符串开始处进行匹配,用在一对方括号中的时候则表示反向匹配,不匹配方括号中的字符。(对) 
    219、 正则表达式元字符“\s”用来匹配任意空白字符。(对) 
    220、 正则表达式 元字符“\d”用来匹配任意数字字符。(对) 
    221、 lambda表达式中可以使用任意复杂的表达式,但是必须只编写一个表达式。(对) 
    222、 Python类的构造函数是init()。(对) 
    223、 定义类时,在一个方法前面使用@classmethod进行修饰,则该方法属于类方法。(对) 
    224、 定义类时,在一个方法前面使用@staticmethod进行休息,则该方法属于静态方法。(对) 
    225、 通过对象不能调用类方法和静态方法。(错) 
    226、 在Python中可以为自定义类的对象动态增加新成员。(对) 
    227、 Python类不支持多继承。(错) 
    228、 属性可以像数据成员一样进行访问,但赋值时具有方法的优点,可以对新值进行检查。(对) 
    229、 文件对象是可以迭代的。(对) 
    230、 文件对象的tell()方法用来返回文件指针的当前位置。(对) 
    231、 以写模式打开的文件无法进读操作。(对) 
    232、 假设已成功导入os和sys标准库,那么表达式 os.path.dirname(sys.executable) 的值为Python安装目录。(对) 
    233、 只可以动态为对象增加数据成员,而不能为对象动态增加成员方法。(错) 
    234、 Python字典支持双向索引。(错) 
    235、 Python集合支持双向索引。(错) 
    236、 Python元组支持双向索引。(对) 
    237、 假设re模块已成功导入,并且有 pattern = re.compile(‘^’+’.’.join([r’\d{1,3}’ for i in range(4)])+’$’),那么表达式 pattern.match(‘192.168.1.103’) 的值为None。(错) 
    238、 假设random模块已导入,那么表达式 random.sample(range(10), 20) 的作用是生成20个不重复的整数。(错) 
    239、 假设random模块已导入,那么表达式 random.sample(range(10), 7) 的作用是生成7个不重复的整数。(对) 
    240、 在Python 3.x中reduce()是内置函数。(错) 
    241、 以读模式打开文件时,文件指针指向文件开始处。(对) 
    242、 以追加模式打开文件时,文件指针指向文件尾。(对) 
    243、 已知x = (1, 2, 3, 4),那么执行x[0] = 5之后,x的值为(5, 2, 3, 4)。(错) 
    244、 已知x = 3,那么执行x += 6语句前后x的内存地址是不变的。(错) 
    245、 成员测试运算符in作用于集合时比作用于列表快得多。(对) 
    246、 在Python 3.x中,使用内置函数input()接收用户输入时,不论用户输入的什么格式,一律按字符串进行返回。(对) 
    247、 安装Python扩展库时只能使用pip工具在线安装,如果安装不成功就没有别的办法了。(错) 
    248、 使用random模块的函数randint(1, 100)获取随机数时,有可能会得到100。(对) 
    249、 如果只需要math模块中的sin()函数,建议使用from math import sin来导入,而不要使用import math导入整个模块。(对) 
    250、 已知列表x = [1, 2, 3, 4],那么表达式x.find(5)的值应为-1。(错) 
    251、 列表对象的排序方法sort()只能按元素从小到大排列,不支持别的排序方式。(错) 
    252、 g = lambda x: 3不是一个合法的赋值表达式。(错) 
    253、 内置函数len()返回指定序列的元素个数,适用于列表、元组、字符串、字典、集合以及range、zip等迭代对象。(对) 
    254、 已知x和y是两个等长的整数列表,那么表达式sum((i*j for i, j in zip(x, y)))的作用是计算这两个列表所表示的向量的内积。(对) 
    255、 已知x和y是两个等长的整数列表,那么表达式[i+j for i,j in zip(x,y)]的作用时计算这两个列表所表示的向量的和。(对) 
    256、 表达式int(‘1’*64, 2)与sum(2**i for i in range(64))的计算结果是一样的,但是前者更快一些。(对) 
    257、 已知x = list(range(20)),那么语句del x[::2]可以正常执行。(对) 
    258、 已知x = list(range(20)),那么语句x[::2] = []可以正常执行。(错) 
    259、 已知x = list(range(20)),那么语句print(x[100:200])无法正常执行。(错) 
    260、 已知x是个列表对象,那么执行语句y = x之后,对y所做的任何操作都会同样作用到x上。(对) 
    261、 已知x是个列表对象,那么执行语句y = x[:]之后,对y所做的任何操作都会同样作用到x上。(错) 
    262、 在Python中,变量不直接存储值,而是存储值的引用,也就是值在内存中的地址。(对) 
    263、 表达式(i**2 for i in range(100))的结果是个元组。(错) 
    264、 在Python中元组的值是不可变的,因此,已知x = ([1], [2]),那么语句x[0].append(3)是无法正常执行的。(错) 
    265、 包含yield语句的函数一般成为生成器函数,可以用来创建生成器对象。(对) 
    266、 在函数中yield语句的作用和return完全一样。(错) 
    267、 Python内置的字典dict中元素是按添加的顺序依次进行存储的。(错) 
    268、 Python内置的集合set中元素顺序是按元素的哈希值进行存储的,并不是按先后顺序。(对) 
    269、 已知x = {1:1, 2:2},那么语句x[3] =3无法正常执行。(错) 
    270、 Python内置字典是无序的,如果需要一个可以记住元素插入顺序的字典,可以使用collections.OrderedDict。(对) 
    271、 语句pass仅起到占位符的作用,并不会做任何操作。(对) 
    272、 在条件表达式中不允许使用赋值运算符“=”,会提示语法错误。(对) 
    273、 任何包含call()方法的类的对象都是可调用的。(对) 
    274、 在Python中函数和类都属于可调用对象。(对) 
    275、 无法使用lambda表达式定义有名字的函数。(错) 
    276、 已知x是一个列表,那么x = x[3:] + x[:3]可以实现把列表x中的所有元素循环左移3位。(对) 
    277、 已知x和y是两个字符串,那么表达式sum((1 for i,j in zip(x,y) if i==j))可以用来计算两个字符串中对应位置字符相等的个数。(对) 
    278、 函数和对象方法是一样的,内部实现和外部调用都没有任何区别。(错) 
    279、 在设计派生类时,基类的私有成员默认是不会继承的。(对) 
    280、 如果在设计一个类时实现类len()方法,那么该类的对象会自动支持Python内置函数len()。(对) 
    281、 Python 3.x中字符串对象的encode()方法默认使用utf8作为编码方式。(对) 
    282、 已知x = ‘hellow world.’.encode(),那么表达式x.decode(‘gbk’)的值为’hellow world.’。(对) 
    283、 已知x = ‘Python是一种非常好的编程语言’.encode(),那么表达式x.decode(‘gbk’)的值为’Python是一种非常好的编程语言’。(错) 
    284、 正则表达式’^http’只能匹配所有以’http’开头的字符串。(对) 
    285、 正则表达式’^\d{18}|\d{15}$’只能检查给定字符串是否为18位或15位数字字符,并不能保证一定是合法的身份证号。(对) 
    286、 二进制文件也可以使用记事本程序打开,只是无法正确阅读和理解其中的内容。(对) 
    287、 正则表达式’[^abc]’可以一个匹配任意除’a’、’b’、’c’之外的字符。(对) 
    288、 正则表达式’python|perl’或’p(ython|erl)’都可以匹配’python’或’perl’。(对) 
    289、 文本文件是可以迭代的,可以使用for line in fp类似的语句遍历文件对象fp中的每一行。(对) 
    290、 Python的主程序文件python.exe属于二进制文件。(对) 
    291、 使用记事本程序也可以打开二进制文件,只不过无法正确识别其中的内容。(对) 
    292、 对字符串信息进行编码以后,必须使用同样的或者兼容的编码格式进行解码才能还原本来的信息。(对) 
    293、 使用pickle进行序列化得到的二进制文件使用struct也可以正确地进行反序列化。(错) 
    294、 已知当前文件夹中有一个文件readme.txt具有只读属性,假设标准库os已正确导入,那么可以通过语句os.chmod(‘readme.txt’, 0o777)来删除该文件的只读属性。(对) 
    295、 Python标准库os的函数remove()不能删除具有只读属性的文件。(对) 
    296、 字节串b’hello world’和b’hello world.’的MD5值相差很小。(错) 
    297、 由于异常处理结构try…except…finally…中finally里的语句块总是被执行的,所以把关闭文件的代码放到finally块里肯定是万无一失,一定能保证文件被正确关闭并且不会引发任何异常。(错) 
    298、 使用TCP协议进行通信时,必须首先建立连接,然后进行数据传输,最后再关闭连接。(对) 
    299、 TCP是可以提供良好服务质量的传输层协议,所以在任何场合都应该优先考虑使用。(错) 
    300、 在4核CPU平台上使用多线程编程技术可以很轻易地获得400%的处理速度提升。(错) 
    301、 多线程编程技术主要目的是为了提高计算机硬件的利用率,没有别的作用了。(错) 
    302、 
    三、 简答题 
    1、 简单解释Python基于值的自动内存管理方式?(Python采用的是基于值得内存管理方式,在Python中可以为不同变量赋值为相同值,这个值在内存中只有一份,多个变量指向同一个内存地址;Python具有自动内存管理功能,会自动跟踪内存中所有的值,对于没有任何变量指向的值,Python自动将其删除。) 
    2、 写出Python运算符&的两种功能?(1)数字位运算;2)集合交集运算。) 
    3、 在Python中导入模块中的对象有哪几种方式?(1)import 模块名 [as 别名];2)from 模块名 import 对象名[ as 别名];3)from math import *) 
    4、 解释Python脚本程序的“name”变量及其作用?(每个Python脚本在运行时都有一个“name”属性。如果脚本作为模块被导入,则其“name”属性的值被自动设置为模块名;如果脚本独立运行,则其“name”属性值被自动设置为“main”。利用“name”属性即可控制Python程序的运行方式。) 
    5、 为什么应尽量从列表的尾部进行元素的增加与删除操作?(当列表增加或删除元素时,列表对象自动进行内存扩展或收缩,从而保证元素之间没有缝隙,但这涉及到列表元素的移动,效率较低,应尽量从列表尾部进行元素的增加与删除操作以提高处理速度。) 
    6、 分析逻辑运算符“or”的短路求值特性?(假设有表达式“表达式1 or 表达式2”,如果表达式1的值等价于True,那么无论表达式2的值是什么,整个表达式的值总是等价于True。因此,不需要再计算表达式2的值。) 
    7、 简单解释Python中短字符串驻留机制?(对于短字符串,将其赋值给多个不同的对象时,内存中只有一个副本,多个对象共享改副本。) 
    8、 异常和错误有什么区别?(异常是指因为程序执行过程中出错而在正常控制流以外采取的行为。严格来说,语法错误和逻辑错误不属于异常,但有些语法错误往往会导致异常,例如由于大小写拼写错误而访问不存在的对象,或者试图访问不存在的文件,等等。) 
    9、 使用pdb模块进行Python程序调试主要有哪几种用法?(1)在交互模式下使用pdb模块提供的功能可以直接调试语句块、表达式、函数等多种脚本。2)在程序中嵌入断点来实现调试功能。在程序中首先导入pdb模块,然后使用pdb.set_trace()在需要的位置设置断点。如果程序中存在通过该方法调用显式插入的断点,那么在命令提示符环境下执行该程序或双击执行程序时将自动打开pdb调试环境,即使该程序当前不处于调试状态。3)使用命令行调试程序。在命令行提示符下执行“python –m pdb 脚本文件名”,则直接进入调试环境;当调试结束或程序正常结束以后,pdb将重启该程序。) 
    10、 阅读下面的代码,并分析假设文件“D:\test.txt”不存在的情况下两段代码可能发生的问题。 
    代码1:

    try: 
    fp = open(r’d:\test.txt’) 
    print(‘Hello world!’, file=fp) 
    finally: 
    fp.close() 
    代码2: 
    try: 
    fp = open(r’d:\test.txt’, ‘a+’) 
    print(‘Hello world!’, file=fp) 
    finally: 
    fp.close() 
    答: 
    假设文件“D:\test.txt”不存在,那么第一段代码会抛出异常,提示fp没有定义;第二段代码执行正常。原因是第二段代码使用内置函数open()打开指定文件时如果不存在则会创建该文件,从而不会抛出异常。 
    11、 
    四、 编程题 
    1、编写程序,在D盘根目录下创建一个文本文件test.txt,并向其中写入字符串hello world。 
    答: 
    fp = open(r’D:\test.txt’, ‘a+’) 
    print(‘hello world’, file=fp) 
    fp.close() 
    2、写出下面代码的优化版本,提高运行效率。 
    x = list(range(500)) 
    for item in x: 
    t = 5**5 
    print(item+t) 
    答: 
    x = list(range(500)) 
    t = 5**5 
    for item in x: 
    print(item+t) 
    3、编写程序,生成一个包含20个随机整数的列表,然后对其中偶数下标的元素进行降序排列,奇数下标的元素不变。(提示:使用切片。) 
    答: 
    import random 
    x = [random.randint(0,100) for i in range(20)] 
    print(x) 
    y = x[::2] 
    y.sort(reverse=True) 
    x[::2] = y 
    print(x) 
    4、写出下面代码的执行结果。 
    def Join(List, sep=None): 
    return (sep or ‘,’).join(List) 
    print(Join([‘a’, ‘b’, ‘c’])) 
    print(Join([‘a’, ‘b’, ‘c’],’:’)) 
    答: 

    ```python
    a,b,c 
    a:b:c 
    ```

    5、写出下面代码的运行结果。 
    def Sum(a, b=3, c=5): 
    return sum([a, b, c]) 
    print(Sum(a=8, c=2)) 
    print(Sum(8)) 
    print(Sum(8,2)) 
    答: 
    13 
    16 
    15 
    6、写出下面代码的运行结果。 
    def Sum(*p): 
    return sum(p) 
    print(Sum(3, 5, 8)) 
    print(Sum(8)) 
    print(Sum(8, 2, 10)) 
    答: 
    16 

    20 
    7、编写函数,判断一个数字是否为素数,是则返回字符串YES,否则返回字符串NO。 
    答: 

    ```python
    import math 
    def IsPrime(v): 
    n = int(math.sqrt(v)+1) 
    for i in range(2,n): 
    if v%i==0: 
    return ‘No’ 
    else: 
    return ‘Yes’ 
    ```

    8、编写函数,模拟Python内置函数sorted()。 
    答: 
    def Sorted(v): 
    t = v[::] 
    r = [] 
    while t: 
    tt = min(t) 
    r.append(tt) 
    t.remove(tt) 
    return r 
    9、编写程序,生成包含20个随机数的列表,然后将前10个元素升序排列,后10个元素降序排列,并输出结果。 
    答: 
    import random 
    x = [random.randint(0,100) for i in range(20)] 
    print(x) 
    y = x[0:10] 
    y.sort() 
    x[0:10] = y 
    y = x[10:20] 
    y.sort(reverse=True) 
    x[10:20] = y 
    print(x) 
    10、编写程序,运行后用户输入4位整数作为年份,判断其是否为闰年。如果年份能被400整除,则为闰年;如果年份能被4整除但不能被100整除也为闰年。 
    答: 
    x = input(‘Please input an integer of 4 digits meaning the year:’) 
    x = eval(x) 
    if x%400==0 or (x%4==0 and not x%100==0): 
    print(‘Yes’) 
    else: 
    print(‘No’) 
    11、编写程序,实现分段函数计算,如下表所示。 
    x y 
    x<0 0 
    0<=x<5 x 
    5<=x<10 3x-5 
    10<=x<20 0.5x-2 
    20<=x 0

    答: 
    x = input(‘Please input x:’) 
    x = eval(x) 
    if x<0 or x>=20: 
    print(0) 
    elif 0<=x<5: 
    print(x) 
    elif 5<=x<10: 
    print(3*x-5) 
    elif 10<=x<20: 
    print(0.5*x-2) 
    12、阅读下面的程序,判断其是否可以正常运行,如果可以运行则写出执行结果,如果不能运行则写出理由。 
    class Test: 
    def init(self, value): 
    self.__value = value 
    @property 
    def value(self): 
    return self.__value

    t = Test(3) 
    t.value = 5 
    print(t.value) 
    答: 
    不能运行。程序中定义的是只读属性,不能修改属性的值。 
    13、下面代码的功能是,随机生成50个介于[1,20]之间的整数,然后统计每个整数出现频率。请把缺少的代码补全。 
    import random 
    x = [random.__(1,20) for i in range(_)] 
    r = dict() 
    for i in x: 
    r[i] = r.get(i, _)+1 
    for k, v in r.items(): 
    print(k, v) 
    答: 
    分别填写randint、50、0 
    14、假设有Python程序文件demo.py,代码如下: 
    def main(): 
    if name == ‘main‘: 
    print(1) 
    else: 
    print(2)

    main() 
    将该程序文件直接运行时输出结果为_,作为模块导入时得到结果___-。(1、2) 
    15、下面程序的执行结果是________。(1) 
    s = 0 
    for i in range(1,101): 
    s += i 
    else: 
    print(1) 
    16、下面程序的执行结果是____。(1275) 
    s = 0 
    for i in range(1,101): 
    s += i 
    if i == 50: 
    print(s) 
    break 
    else: 
    print(1) 
    17、下面的程序是否能够正常执行,若不能,请解释原因;若能,请分析其执行结果。 
    from random import randint

    result = set() 
    while True: 
    result.add(randint(1,10)) 
    if len(result)==20: 
    break 
    print(result) 
    答:无法正确执行,因为该程序的功能是从[1,10]区间中选择20个不同的随机整数,而该区间并没有这么多整数,所以程序死循环。 
    18、下面的代码是否能够正确运行,若不能请解释原因;若能,请分析其执行结果。

    x = list(range(20)) 
    for i in range(len(x)): 
    del x[i] 
    答:无法正确执行,因为删除列表元素时会影响其他元素在列表中的索引,上面的代码会抛出下标越界的异常。 
    19、阅读下面的代码,解释其功能。 
    x = list(range(20)) 
    for index, value in enumerate(x): 
    if value == 3: 
    x[index] = 5 
    答:将列表x中值为3的元素修改为5。 
    20、阅读下面的代码,解释其功能。 
    x = [range(3*i, 3*i+5) for i in range(2)] 
    x = list(map(list, x)) 
    x = list(map(list, zip(*x))) 
    答:首先生成一个包含列表的列表,然后模拟矩阵转置。 
    21、阅读下面的代码,解释其功能。 
    import string 
    x = string.ascii_letters + string.digits 
    import random 
    print(”.join(random.sample(x, 10))) 
    答:输出由英文字母大小写或数字组成的长度为10且不重复的随机字符串。 
    22、阅读下面的代码,分析其执行结果。 
    def demo(*p): 
    return sum(p) 
    print(demo(1,2,3,4,5)) 
    print(demo(1,2,3)) 
    答:输出结果为 
    15 

    23、阅读下面的代码,分析其执行结果。 
    def demo(a, b, c=3, d=100): 
    return sum((a,b,c,d)) 
    print(demo(1, 2, 3, 4)) 
    print(demo(1, 2, d=3)) 
    答:输出结果为 
    10 

    24、下面的代码输出结果为___。(3) 


    def demo(): 
    x = 5 
    x = 3 
    demo() 
    print(x) 
     

    25、下面函数的功能为_____。(将序列循环左移k位,得到新序列并返回) 
    def demo(lst, k): 
    if k


     

    展开全文
  • Python程序设计

    千次阅读 2019-05-28 19:18:02
    Python程序设计 第3版》是面向大学计算机科学专业的教材。本书以Python语言为工具,采用相当传统的方法,强调解决问题、设计和编程是计算机科学的核心技能。 全书共13章,此外,还包含两个附录。第 1章到第5章介绍...

    内容简介

    《Python程序设计 第3版》是面向大学计算机科学专业的教材。本书以Python语言为工具,采用相当传统的方法,强调解决问题、设计和编程是计算机科学的核心技能。

    全书共13章,此外,还包含两个附录。第 1章到第5章介绍计算机与程序、编写简单程序、数字计算、对象和图形、字符串处理等基础知识。第6章到第8章介绍函数、判断结构、循环结构和布尔值等话题。第9章到第 13章着重介绍一些较为高档的程序设计方法,包括模拟与设计、类、数据集合、面向对象设计、算法设计与递归等。附录部分给出了Python快速参考和术语表。每一章的末尾配有丰富的练习,包括复习问题、讨论和编程联系等多种形式,帮助读者巩固该章的知识和技能。

    《Python程序设计 第3版》特色鲜明、示例生动有趣、内容易读易学,适合Python入门程序员阅读,也适合高校计算机专业的教师和学生参考。

    目录

    版权声明
    内容提要

    前言
    第1章 计算机和程序
    第2章 编写简单程序
    第3章 数字计算
    第4章 对象和图形
    第5章 序列:字符串、列表和文件
    第6章 定义函数
    第7章 判断结构
    第8章 循环结构和布尔值
    第9章 模拟与设计
    第10章 定义类
    第11章 数据集合
    第12章 面向对象设计
    第13章 算法设计与递归
    附录A Python快速参考
    附录B 术语表

    下载

    https://pan.baidu.com/s/1t9TtZ7nOpPPEtiEv88tVDg

    展开全文
  • Python程序设计.rar

    2021-05-11 17:27:36
    Python程序设计课程的详细ppt课件,包含了20个章节,共21个ppt,未压缩前58M。该资源在每一章节都有相关示例、可行的Python代码,这些代码可以直接复制粘贴到Python编辑器中。这些示例和代码来源于一些好书,也有...
  • 您所在位置:网站首页 > 海量文档 > 计算机 > Python《PYTHON程序设计》习题答案.pdf43页本文档一共被下载:次,您可全文免费在线阅读后下载本文档。 下载提示1.本站不保证该用户上传的文档完整...

    您所在位置:网站首页 > 海量文档

    &nbsp>&nbsp计算机&nbsp>&nbspPython

    productView-pdf_46x35.gif

    《PYTHON程序设计》习题与答案.pdf43页

    本文档一共被下载:load.gif次,您可全文免费在线阅读后下载本文档。

    donwloaddoc.png

    favdoc.png

    baiduyixia.png

    edit.png

    full.png

    下载提示

    1.本站不保证该用户上传的文档完整性,不预览、不比对内容而直接下载产生的反悔问题本站不予受理。

    2.该文档所得收入(下载+内容+预览三)归上传者、原创者。

    3.登录后可充值,立即自动返金币,充值渠道很便利

    《Python 程序设计》习题与参考答案

    1

    第 章 基础知识

    1.1 简单说明如何选择正确的Python 版本。

    答:

    在选择Python 的时候,一定要先考虑清楚自己学习Python 的目的是什么,打算做哪方

    面的开发,有哪些扩展库可用,这些扩展库最高支持哪个版本的Python,是Python 2.x 还是

    Python 3.x,最高支持到Python 2.7.6还是Python 2.7.9。这些问题都确定以后,再做出自己

    的选择,这样才能事半功倍,而不至于把大量时间浪费在Python 的反复安装和卸载上。同

    时还应该注意,当更新的Python 版本推出之后,不要急于更新,而是应该等确定自己所必

    须使用的扩展库也推出了较新版本之后再进行更新。

    尽管如此,Python 3 毕竟是大势所趋,如果您暂时还没想到要做什么行业领域的应用开

    发,或者仅仅是为了尝试一种新的、好玩的语言,那么请毫不犹豫地选择Python 3.x 系列的

    最高版本 (目前是Python 3.4.3)。

    1.2 为什么说Python 采用的是基于值的内存管理模式?

    答:

    Python 采用的是基于值的内存管理方式,如果为不同变量赋值相同值,则在内存中只

    有一份该值,多个变量指向同一块内存地址,例如下面的代码。

    >>>x 3

    >>> id(x)

    >>>y 3

    >>> id(y)

    >>>y 5

    >>> id(y)

    >>> id(x)

    1.3 在Python 中导入模块中的对象有哪几种方式?

    答:常用的有三种方式,分别为

    ? import 模块名 [as 别名]

    ? from 模块名 import 对象名[as 别名]

    ? frommath import *

    1.4 使用pip 命令安装numpy、scipy 模块。

    答:在命令提示符环境下执行下面的命令:

    pip installnumpy

    pip install scipy

    1.5 编写程序,用户输入一个三位以上的整数,输出其百位以上的数字。例如用户输入

    1234,则程序输出12。(提示:使用整除运算。)

    答:

    1)Python 3.4.2 代码:

    x input('Pleaseinput an integer ofmorethan 3digits:')

    try:

    x int(x)

    x x//100

    ifx 0:

    print('Youmust input an integer ofmorethan 3digits.')

    else:

    print(x)

    exceptBaseException:

    print('Youmust input an integer.')

    2)Python 2.7.8代码:

    importtypes

    x input('Pleaseinput an integer ofmorethan 3digits:')

    iftype(x) ! types.IntType:

    print 'Youmust input an integer.'

    eliflen(str(x)) ! 4:

    print 'Youmust input an integer ofmorethan 3digits.'

    else:

    printx//100

    2 Python

    第 章 数据结构

    2.1 为什么应尽量从列表的尾部进行元素的增加与删除操作?

    答:

    当列表增加或删除元素时,列表对象自动进行内存扩展或收缩,从而保证元素之间没有

    缝隙,但这涉及到列表元素的移动,效率较低,应尽量从列表尾部进行元素的增加与删除操

    作以提高处理速度。

    2.2 编写程序,生成包含 1000个0 到100 之间的随机整数,并统计每个元素的出现次

    数。(提示:使用集合。)

    答:

    1)P

    发表评论

    请自觉遵守互联网相关的政策法规,严禁发布色情、暴力、反动的言论。

    用户名:

    验证码:

    detail-code.png

    匿名?

    发表评论

    展开全文
  • python科学计算

    2018-06-12 17:02:01
    本书介绍如何用Python开发科学计算的应用程序,除了介绍数值计算之外,还着重介绍如何制作交 互式的2D、 3D图像,如何设计精巧的程序界面, 如何C语言编写的高速计算程序结合,如何编写声音、 图像处理算法等内容...
  • Python 科学计算

    2018-05-08 20:28:57
    python科学计算》介绍如何用python开发科学计算的应用程序,除了介绍数值计算之外,还着重介绍如何制作交互式的2d、3d图像,如何设计精巧的程序界面,如何c语言编写的高速计算程序结合,如何编写声音、图像处理...
  • Python程序设计课后习题答案-第一单元习题1一、选择题1.Python语言属于()。CA.机器语言 B.汇编语言 C.高级语言 D.科学计算语言2.下列选项中,不属于Python特点的是()。BA.面向对象 B.运行效率高 C....
  • python程序设计是国外一本知名的Python大学教材,作者是美国Watsburg大学的教授,他使用自己的图书作为Python程序设计课程的授课教材,取得了很好的效果。本书采用较为传统的方式进行教学,强调问题解决、设计和编程...
  • 在工作中尝试了一次,不过是在c++中调用python,项目开始一翻风顺,“享受编程的乐趣”,但涉及到在QT的多线程中嵌套python的多线程,开始无助,更别提之间通讯。最终放弃了。原因:个人水平,项目时间有限,没有...
  • Python 程序设计题库 一填空题 第一章 基础知识 1 Python 安装扩展库常用的是 _工具 pip 2 Python 标准库 math 中用来计算平方根的函数是 _ sqrt 3 Python 程序文件扩展名主要有 _ 和 _两种其中后者常用于 GUI 程序 ...
  • Python程序设计题库.doc

    2020-08-30 14:58:20
    Python程序设计题库 一填空题 第一章 基础知识 1 Python安装扩展库常用的是_工具pip 2 Python标准库math中用来计算平方根的函数是_sqrt 3 Python程序文件扩展名主要有_和_两种其中后者常用于GUI程序pypyw 4 Python源...
  • 本书向计算机专业和非计算机专业的学生介绍计算机科学的基本概念、思想和方法,目 的是使学生理解计算机科学家的思维特点和方式,并最终能够利用计算机解决自己专业领域的问题。
  • python程序设计第三版

    2018-10-14 02:35:05
    https://www.jb51.net/books/606001.htmlpython程序设计是国外一本知名的Python大学教材,作者是美国Watsburg大学的教授,他使用自己的图书作为Python程序设计课程的授课教材,取得了很好的效果。本书采用较为传统的...
  • 董付国《Python程序设计基础 第2版》PDF首页 >计算机类字号:小中大评论:0 条评论:0 条Python程序设计基础 第2版【作 者】董付国编著【丛书名】计算机系列教材【形态项】 297【出版项】 北京:清华大学出版社 , ...
  • Python语言程序设计;第10 章 科学计算和可视化;计算不再关乎计算机它生活处处相关 Computing is not about computers any more. It is about living. 尼古拉斯尼葛洛庞帝(Nicholas Negroponte) 麻省理工学院媒体...
  • Python科学计算

    2017-02-14 09:03:35
    与科学计算领域最流行的商业软件MATLAB相比,Python是一门真正的通用程序设计语言,比MATLAB所采用的脚本语言的应用范围更广泛,有更多程序库的支持,适用于Windows和Linux等多种平台,完全免费并且开放源码。...
  • Python 程序设计题库 一填空题 第一章 基础知识 1Python 安装扩展库常用的是_工具pip 2 Python 标准库math 中用来计算平方根的函数是_ sqrt 3Python 程序文件扩展名主要有_和_两种其中后者常用于GUI 程序 py pyw 4 ...
  • Python 程序设计题库 一填空题 第一章 基础知识 1 Python 安装扩展库常用的是 _工具 pip 2 Python 标准库 math 中用来计算平方根的函数是 _sqrt 3 Python 程序文件扩展名主要有 _和_两种其中后者常用于 GUI 程序 py ...
  • 信息与计算科学专业的Python教学分析与设计.pdf
  • python科学计算

    2018-12-03 17:27:42
    本书介绍如何用 Python 开发科学计算的应用程序,除了介绍数值计算之外,还着重介绍了如何制作交互式二维、三维图像,如何设计精巧的程序界面,如何 C 语言编写的高速计算程序结合,如何编写声音、图像处理算法等...
  • Python 专题四 python 科学计算

    千次阅读 2013-10-24 21:16:27
    Python 科学计算 目 录 351 中值滤波 97 352 滤波器设计 98 36 图像处理——ndimage 100 361 膨胀和腐蚀 101 362 Hit和Miss 102 37 统计——stats 105 371 连续和离散概率分布 105 372 二项、...
  • Python 程序设计题库 一填空题 第一章 基础知识 1 Python 安装扩展库常用的是 _ 工具 pip 2 Python 标准库 math 中用来计算平方根的函数是 _ sqrt 3 Python 程序文件扩展名主要有 _ 和_ 两种其中后者常用于 GUI 程序...
  • Python 程序设计题库 一填空题 第一章 基础知识 1 Python 安装扩展库常用的是 _工具 pip 2 Python 标准库 math 中用来计算平方根的函数是 _ sqrt 3 Python 程序文件扩展名主要有 _ 和_两种其中后者常用于 GUI 程序 ...
  • Python程序设计题库 一填空题 第一章 基础知识 1 Python安装扩展库常用的是_工具pip 2 Python标准库math中用来计算平方根的函数是_sqrt 3 Python程序文件扩展名主要有_和_两种其中后者常用于GUI程序pypyw 4 Python...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 45,899
精华内容 18,359
关键字:

python程序设计与科学计算

python 订阅