精华内容
下载资源
问答
  • 计算机二级python 知识点篇(组合数据类型)集合、列表、字符串、元组、字典集合类型 : 集合 (无序、无相同元素)序列类型 :列表、字符串、元组 (有序、元素之间不排他)映射类型 :字典集合集合概述集合中元素不...

    计算机二级python 知识点篇(组合数据类型)

    集合、列表、字符串、元组、字典

    集合类型 : 集合 (无序、无相同元素)

    序列类型 :列表、字符串、元组 (有序、元素之间不排他)

    映射类型 :字典

    集合

    集合概述

    集合中元素不可重复, 元素类型只能是固定数据类型,例如: 整数、 浮点数、 字符串、 元组等, 列表、 字典和集合类型本身都是可变数据类型, 不能作为集合的元素出现

    >>>S = {1010, "1010", 78.9}

    >>>type(S)

    >>>len(S)

    3

    >>>print(S)

    {78.9, 1010, '1010'}

    集合操作符

    集合类型有4个操作符, 交集(&) 、 并集(|) 、 差集(-) 、 补集(^) ,操作逻辑与数学定义相同

    操作符的运算

    描述

    S – T 返回一个新集合,

    包括在集合S中但不在集合T中的元素

    S & T 返回一个新集合,

    包括同时在集合S和T中的元素

    S^T 返回一个新集合,

    包括集合S和T中非共同元素

    S|T 返回一个新集合,

    包括集合S和T中所有元素

    >>>S = {1010, "1010", 78.9}

    >>>T = {1010, "1010", 12.3, 1010, 1010}

    >>>S - T

    {78.9}

    >>>T – S

    {12.3}

    >>>S & T

    {1010, '1010'}

    >>>T & S

    {1010, '1010'}

    >>>S ^ T

    {78.9, 12.3}

    >>>T ^ S

    {78.9, 12.3}

    >>>S | T

    {78.9, 1010, 12.3, '1010'}

    >>>T | S

    {1010, 12.3, 78.9, '1010'}

    集合操作函数和方法

    函数或方法

    描述

    S.add(x)

    如果数据项x不在集合S中, 将x增加到s

    S.remove(x)

    如果x在集合S中, 移除该元素; 不在产生KeyError异常

    S.clear()

    移除S中所有数据项

    len(S)

    返回集合S元素个数

    x in S

    如果x是S的元素, 返回True, 否则返回False

    x not in S

    如果x不是S的元素, 返回True, 否则返回False

    集合类型主要用于元素去重, 适合于任何组合数据类型

    序列类型

    序列类型包括 列表、字符串、元组 (有序、元素之间不排他)

    序列类型操作符和函数

    操作符

    描述

    x in s

    如果x是s的元素, 返回True, 否则返回False

    x not in s

    如果x不是s的元素, 返回True, 否则返回False

    s + t

    连接s和t

    s * n 或 n * s

    将序列s复制n次

    s[i]

    索引, 返回序列的第i个元素

    s[i: j]

    切片, 返回包含序列s第i到j个元素的子序列(不包含第j个元素)

    s[i: j: k]

    步骤切片, 返回包含序列s第i到j个元素以k为步数的子序列

    len(s)

    序列s的元素个数(长度)

    min(s)

    序列s中的最小元素

    max(s)

    序列s中的最大元素

    s.index(x)

    序列s中第一次出现元素x的位置

    s.count(x)

    序列s中出现x的总次数

    列表

    列表类型用中括号([]) 表示, 也可以通过list(x)函数将集合或字符串类型转换成列表类型

    >>>ls = [1010, "1010", [1010, "1010"], 1010]

    >>>ls

    [1010, '1010', [1010, '1010'], 1010]

    >>>list('列表可以由字符串生成')

    ['列', '表', '可', '以', '由', '字', '符', '串', '生', '成']

    >>>list()

    []

    # 索引

    >>>ls = [1010, "1010", [1010, "1010"], 1010]

    >>>ls[3]

    1010

    >>>ls[-2]

    [1010, '1010']

    # 遍历

    >>>ls = [1010, "1010", [1010, "1010"], 1010]

    >>>for i in ls:

    print(i*2)

    2020

    10101010

    [1010, '1010', 1010, '1010']

    2020

    # 切片

    >>>ls = [1010, "1010", [1010, "1010"], 1010]

    >>>ls[1:4]

    ['1010', [1010, '1010'], 1010]

    >>>ls[-1:-3]

    []

    >>>ls[-3:-1]

    ['1010', [1010, '1010']]

    >>>ls[0:4:2]

    [1010, [1010, '1010']]

    列表的操作函数

    操作函数

    描述

    len(ls)

    列表ls的元素个数(长度)

    min(ls)

    列表ls中的最小元素

    max(ls)

    列表ls中的最大元素

    list(x)

    将x转变成列表类型

    列表的操作方法

    方法

    描述

    ls.append(x)

    在列表ls最后增加一个元素x

    ls.insert(i, x)

    在列表ls第i位置增加元素x

    ls.clear()

    删除ls中所有元素

    ls.pop(i)

    将列表ls中第i项元素取出并删除该元素

    ls.remove(x)

    将列表中出现的第一个元素x删除

    ls.reverse()

    列表ls中元素反转

    ls.copy()

    生成一个新列表, 复制ls中所有元素

    关于删除,还可以用Python保留字del对列表元素或片段进行删除, 使用方法如下:

    del <列表变量>[<索引序号>] 或

    del <列表变量>[<索引起始>: <索引结束>]

    >>>lt = ["1010", "10.10", "Python"]

    >>>del lt[1]

    >>>print(lt)

    ["1010", "Python"]

    >>>lt = ["1010", "10.10", "Python"]

    >>>del lt[1:]

    >>>print(lt)

    ["1010"]

    关于 浅拷贝和深拷贝

    深拷贝:.copy()方法复制后赋值给变量ls, 将lt元素清空不影响新生成的变量ls

    浅拷贝:ls = lt语句并不是拷贝lt中元素给变量ls, 而是新关联了一个引用, 即ls和lt所指向的是同一套内容

    字典类型

    Python语言中的字典使用大括号{}建立, 每个元素是一个键值对, 使用方式如下:

    {<键1>:<值1>, <键2>:<值2>, … , <键n>:<值n>}

    字典的索引

    列表类型采用元素顺序的位置进行索引。由于字典元素"键值对” 中键是值的索引,因此,可以直接利用键值对关系索引元素。

    字典中键值对的索引模式如下, 采用中括号格式:

    <值> = <字典变量>[<键>]

    >>>d = {"201801":"小明", "201802":"小红", "201803":"小白"}

    >>>print(d["201802"])

    小红

    # 利用索引和赋值(=) 配合, 可以对字典中每个元素进行修改。

    >>>d["201802"] = '新小红'

    >>>print(d)

    {'201801': '小明', '201803': '小白', '201802': '新小红'}

    # 使用大括号可以创建字典。 通过索引和赋值配合,可以向字典中增加元素。

    >>>t = {}

    >>>t["201804"] = "小新"

    >>>print(d)

    {'201804': '小新'}

    字典的操作函数

    操作函数

    描述

    len(d)

    字典d的元素个数(长度)

    min(d)

    字典d中键的最小值

    max(d)

    字典d中键的最大值

    dict()

    生成一个空字典

    字典的操作方法

    操作方法

    描述

    d.keys()

    返回所有的键信息

    d.values()

    返回所有的值信息

    d.items()

    返回所有的键值对

    d.get(key, default)

    键存在则返回相应值, 否则返回默认值

    d.pop(key, default)

    键存在则返回相应值, 同时删除键值对, 否则返回默认值

    d.popitem()

    随机从字典中取出一个键值对, 以元组(key, value)形式返回取出后从字典中删除这个键值对

    d.clear()

    删除所有的键值对

    d.keys()返回字典中的所有键信息, 返回结果是Python的一种内部数据类型dict_keys, 专用于表示字典的键。如果希望更好的使用返回结果, 可以将其转换为列表类型

    d.values()返回字典中的所有值信息, 返回结果是Python的一种内部数据类型dict_values。 如果希望更好的使用返回结果, 可以将其转换为列表类型。

    d.items()返回字典中的所有键值对信息, 返回结果是Python的一种内部数据类型dict_items。

    >>>d = {"201801":"小明", "201802":"小红", "201803":"小白"}

    >>>d.keys()

    dict_keys(['201801', '201802', '201803'])

    >>>type(d.keys())

    >>>list(d.keys())

    ['201801', '201802', '201803']

    >>>d = {"201801":"小明", "201802":"小红", "201803":"小白"}

    >>>d.values()

    dict_values(['小明', '小红', '小白'])

    >>>type(d.values())

    >>>list(d.values())

    ['小明', '小红', '小白']

    >>>d = {"201801":"小明", "201802":"小红", "201803":"小白"}

    >>>d.items()

    dict_items([('201801', '小明'), ('201802', '小红'),

    ('201803', '小白')])

    >>>type(d.items())

    >>>list(d.items())

    [('201801', '小明'), ('201802', '小红'), ('201803', '小白')]

    >>>d = {"201801":"小明", "201802":"小红", "201803":"小白"}

    >>>d.get('201802')

    '小红'

    >>>d.get('201804')

    >>>d.get('201804', '不存在')

    '不存在

    字典类型也支持保留字in, 用来判断一个键是否在字典中。 如果在则返回True, 否则返回False

    >>>d = {"201801":"小明", "201802":"小红", "201803":"小白"}

    >>>"201801" in d

    True

    >>>"201804" in d

    False

    遍历

    与其他组合类型一样, 字典可以遍历循环对其元素进行遍历, 基本语法结构如下:

    for <变量名> in <字典名>

    <语句块>

    for循环返回的变量名是字典的索引值。 如果需要获得键对应的值, 可以在语句块中通过get()方法获得

    >>>d = {"201801":"小明", "201802":"小红", "201803":"小白"}

    >>>for k in d:

    print("字典的键和值分别是: {}和{}".format(k, d.get(k)))

    字典的键和值分别是: 201801和小明

    字典的键和值分别是: 201802和小红

    字典的键和值分别是: 201803和小白

    展开全文
  • 计算机二级python 知识点篇(程序的控制结构)程序的基本结构程序由三种基本结构组成: 顺序结构、 分支结构和循环结构分支结构单分支结构 ifand 表示多个条件“与” 的关系, or 表示多个条件“或” 的关系# 判断用户...

    计算机二级python 知识点篇(程序的控制结构)

    程序的基本结构

    程序由三种基本结构组成: 顺序结构、 分支结构和循环结构

    分支结构

    单分支结构 if

    and 表示多个条件“与” 的关系, or 表示多个条件“或” 的关系

    # 判断用户输入数字的特定

    s = eval(input("请输出一个整数: "))

    if s % 3 == 0 and s % 5 == 0:

    print("这个数字既能被3整除, 又能被5整除")

    print("输入数字是:", s)

    二分支结构 if -else

    简洁的表达方式:

    ` if else `

    # 判断用户输入数字的某个属性

    s = eval(input("请输出一个整数: "))

    token = "" if s % 3 == 0 and s % 5 == 0 else "不"

    print("这个数字{}能够同时被3和5整除".format(token))

    多分支结构

    判断条件及组合:

    操作符

    含义

    >

    .

    <

    .

    >=

    .

    <=

    .

    ==

    .

    !=

    .

    Python语言使用保留字not、 and和or对条件进行逻辑运算或组着。

    保留字not表示单个条件的“否” 关系, and表示多个条件之间的“与” 关系, 保留字or表示多个条件之间的“或” 关系

    循环结构

    循环结构

    Python语言的循环结构包括两种: 遍历循环和无限循环。

    遍历循环使用保留字for依次提取遍历结构各元素进行处理;

    无限循环使用保留字while根据判断条件执行程序

    遍历 for

    for in :

    遍历结构可以是字符串、 文件、 range()函数或组合数据类型等

    遍历循环还有一种扩展模式, 使用方法如下:

    for in :

    else:

    当for循环正常执行之后, 程序会继续执行else语句中内容。 else语句只在循环正常执行之后才执行并结束, 因此, 可以在中放置判断循环执行情况的语句。

    for s in "PY":

    print("循环执行中: " + s)

    else:

    s = "循环正常结束"

    print(s)

    >>>

    循环执行中: P

    循环执行中: Y

    循环正常结束

    循环 while

    无限循环也有一种使用保留字else的扩展模式, 使用方法如下:

    while :

    else:

    在这种扩展模式中, 当while循环正常执行之后, 程序会继续执行else语句中内容。 else语句只在循环正常执行后才执行, 因此, 可以在语句块2中放置判断循环执行情况的语句。

    s, idx = "PY", 0

    while idx < len(s):

    print("循环执行中: " + s[idx])

    idx += 1

    else:

    s = "循环正常结束"

    print(s)

    >>>

    循环执行中: P

    循环执行中: Y

    循环正常结束

    循环控制: break和continue

    循环结构有两个辅助循环控制的保留字: break和continue。 break用来跳出最内层for或while循环, 脱离该循环后程序从循环后代码继续执行

    如果有2层或多层循环, break退出最内层循环

    continue用来结束当前当次循环, 即跳出循环体中下面尚未执行的语句, 但不跳出当前循环。

    程序的异常处理

    Python语言使用保留字try和except进行异常处理, 基本的语法格式如下:

    try:

    except:

    语句块1是正常执行的程序内容, 当执行这个语句块发生异常时, 则执行except保留字后面的语句块2.

    try:

    n = eval(input("请输入一个数字: "))

    print("输入数字的3次方值为: ", n**3)

    except:

    print("输入错误, 请输入一个数字!")

    >>>

    请输入一个数字: 1010

    输入数字的3次方值为: 103

    >>>

    请输入一个数字: python

    输入错误, 请输入一个数字!

    展开全文
  • 计算机二级Python知识点速记手册 前言 最近整理了一些计算机二级Python的知识点,涵盖二级考纲90%以上内容,方便备考的同学复习和记忆。 开始学习时,请配合IDLE进行实际练习,不要死板背诵。除此之外,在这里提出...

    计算机二级Python知识点速记手册

    前言

    最近整理了一些计算机二级Python的知识点,涵盖二级考纲90%以上内容,方便备考的同学复习和记忆。
    开始学习时,请配合IDLE进行实际练习,不要死板背诵。除此之外,在这里提出几点临场救命法宝:
    1.Turtle库Demo,在IDLE的HELP选项里。能够提供Turtle实例代码(考试时也可参考),非常救命!
    2.IDLE输入基本函数,比如print(),打出pr后按TAB键即可显示基本函数中含pr的函数(仅限基本函数),库函数不支持。
    3.保持良好心态,平时的努力一定会得到回报。

    正文

    转义符

    \n 换行
    \t 制表符
    \r 回到行首
    \b 回退
    " 双引号
    ’ 单引号

    运算函数

    abs(num) 求绝对值
    power(x,y[,z]) x**y (并除以z求其余数)
    divmod(x,y) 求x/y 商和余数
    round(x[,y]) 四舍五入(到小数点后几位)
    max(x1,x2,x3…,xn) 一组数最大值
    min(x1,x2,x3…,xn) 一组数最小值
    num.real 复数实数部分(num=a+bj->a)
    num.imag 复数虚数部分(num=a+bj->b)
    int(x) 强制转换为整数
    float(x) 强制转换为浮点数
    complex(x) 强制转换为复数

    字符串

    str[m:n:k] (开头:结尾:步长)小技巧 str[::-1]倒排字符串

    字符串函数

    len(str) 获取str长度
    str(x) 强制转换字符串
    hex(x) oct(x) 整数x的十六进制/八进制的字符串形式
    chr(u) u为Unicode编码,返回对应的字符
    ord(x) x为字符,返回Unicode编码

    字符串的方法

    str.upper() 转大写
    str.lower() 转小写
    str.capitalize()
    str.count(sub) 返回sub在str中出现的次数
    str.split(‘item’) 分割字符串
    str.replace(old,new) 返回新字符串,old全部替换为new
    str.strip(chars) str中去掉左右侧的chars
    chr.join(list) 给str增加分隔符

    格式化字符串

    {:填充 对齐 宽度 千位分隔符, .精度 类型}
    {0:=^20}.format(“python”) python
    {0:*>20}.format(‘bit’) ************************bit
    {0:,.2f}.format(12345.6789) 12,345.68

    组合数据类型

    集合

    set(x) 创建集合
    s.add(x) 添加元素
    s.discard(x) 移除x
    s.remove(x) 移除x
    s.clear() 清空列表
    s.pop() 随机删除
    s.copy() 复制
    len(s) 列表元素个数
    x in s x是否在s中
    x not in s

    序列类型

    序列通用

    len(s) 长度
    min(s)
    max(s)
    s.index(x)
    s.index(x,i,j) 返回序列s从i开始到j中第一次出现元素x的位置
    s.count(x) 返回序列s出现的x的总次数

    元组

    tuple()

    集合

    ls[i]=x 替换列表第i个元素为x
    ls[i:j:k]=lt 用列表lt替换ls切片后对应的子列表
    del ls[i] 删除列表的第i个元素
    del ls[i:j:k] 删除列表i到j以k为步长的元素
    ls+=lt 更新列表ls,将lt元素增加到ls中
    ls*=n 更新ls,重复n次
    ls.append(x) ls中添加最后一个元素x
    ls.clear() 删除ls所有元素
    ls.copy() 生成新列表,赋值ls内元素
    ls.insert(i,x) 在列表位置i添加元素x
    ls.pop(i) 删除列表第i个位置的元素
    ls.remove(x) 删除列表中出现的第一个x
    ls.reverse() 反转列表

    字典

    del d[k] 删除字典key是k的数据值
    k in d
    d.keys()
    d.values()
    d.items() 返回字典中所有键值对的信息(元组)
    d.get(k,) k存在,返回相应值,否则返回默认值
    d.pop(k,default) k存在,取出相应值,否则返回默认值
    d.popitem() 随机从字典中取出一个键值对,以元组的方式返回

    文件操作

    f=open(,) 打开文件
    f.close() 关闭文件

    读取文件 r/[+]模式

    f.read([size]) 读取文件全部内容或只读前size个长度
    f.readline([size]) 读取文件一行
    f.readlines([hint]) 读取文件所有行或读入前hint行

    写入文件 w/a/x/[+]模式

    f.write(s) 向文件写入字符串
    f.writelines(lines) 将元素全为字符串列表写入文件
    f.seek(offset[,when]) 改变当前文件 偏移多少字符 [0-开头 1-当前 2-结尾]

    time 库

    time.time() 获取时间戳
    time.ctime() 获取字符串时间
    time.gmtime() 获取可用于程序的时间
    time.strftime("%Y-%m-%d %H:%M:%S",time.gmtime())
    time.sleep(x) 模拟休眠时间
    time.perf_counter() 通过差值进行程序的计时

    turtle 库

    fd(x) 沿着箭头走x距离
    bk(x) 后退x距离
    setup(x,y[,z1,z2]) 画布大小(以及出现在屏幕的位置)
    penup() 抬起画笔
    pendown() 放下画笔
    pencolor(color) 调整画笔颜色
    pensize(x) / penwidth(x) 调整画笔宽度
    seth(angle) 调整箭头角度
    left(angle) 左转angle度
    right(angle) 右转angle度
    circle(radius[,angle]) 画圆,圆心距离箭头左侧(radius<0则为右侧),(圆心角为angle的圆弧)

    random库

    random.seed() 初始化种子,默认为系统时间
    random() 生成0-1之间的随机小数
    扩展随机数
    randint(a,b) 生成一个a-b的整数
    randrange(m,n[,k]) 生成一个m-n,步长为k的随机整数
    getrandbits(k) 生成一个kbit的整数
    uniform(a,b) 生成a-b的随机小数
    choice(seq) 从列表随机选择一个元素
    shuffle(seq) 列表随机排列

    jieba库

    *lcut(s) 精确模式,返回一个列表类型的分词结果
    lcut(s,cut_all=True) 全模式,返回一个列表类型的分词结果,有冗余
    lcut_for_search(s) 搜索引擎模式,返回一个列表类型的分词结果,存在冗余

    展开全文
  • 计算机二级python 知识点篇(程序的控制结构)程序的基本结构程序由三种基本结构组成: 顺序结构、 分支结构和循环结构分支结构单分支结构 ifand 表示多个条件"与” 的关系, or 表示多个条件"或” 的关系...

    计算机二级python 知识点篇(程序的控制结构)

    程序的基本结构

    程序由三种基本结构组成: 顺序结构、 分支结构和循环结构

    分支结构

    单分支结构 if

    and 表示多个条件"与” 的关系, or 表示多个条件"或” 的关系

    # 判断用户输入数字的特定

    s = eval(input("请输出一个整数: "))

    if s % 3 == 0 and s % 5 == 0:

    print("这个数字既能被3整除, 又能被5整除")

    print("输入数字是:", s)

    二分支结构 if -else

    简洁的表达方式:

    `<表达式1> if <条件> else <表达式2>`

    # 判断用户输入数字的某个属性

    s = eval(input("请输出一个整数: "))

    token = "" if s % 3 == 0 and s % 5 == 0 else "不"

    print("这个数字{}能够同时被3和5整除".format(token))

    多分支结构

    判断条件及组合:

    操作符

    含义

    >

    .

    <

    .

    >=

    .

    <=

    .

    ==

    .

    !=

    .

    Python语言使用保留字not、 and和or对条件进行逻辑运算或组着。

    保留字not表示单个条件的"否” 关系, and表示多个条件之间的"与” 关系, 保留字or表示多个条件之间的"或” 关系

    循环结构

    循环结构

    Python语言的循环结构包括两种: 遍历循环和无限循环。

    遍历循环使用保留字for依次提取遍历结构各元素进行处理;

    无限循环使用保留字while根据判断条件执行程序

    遍历 for

    for <循环变量> in <遍历结构>:

    <语句块>

    遍历结构可以是字符串、 文件、 range()函数或组合数据类型等

    遍历循环还有一种扩展模式, 使用方法如下:

    for <循环变量> in <遍历结构>:

    <语句块1>

    else:

    <语句块2>

    当for循环正常执行之后, 程序会继续执行else语句中内容。 else语句只在循环正常执行之后才执行并结束, 因此, 可以在<语句块2>中放置判断循环执行情况的语句。

    for s in "PY":

    print("循环执行中: " + s)

    else:

    s = "循环正常结束"

    print(s)

    >>>

    循环执行中: P

    循环执行中: Y

    循环正常结束

    循环 while

    无限循环也有一种使用保留字else的扩展模式, 使用方法如下:

    while <条件>:

    <语句块1>

    else:

    <语句块2>

    在这种扩展模式中, 当while循环正常执行之后, 程序会继续执行else语句中内容。 else语句只在循环正常执行后才执行, 因此, 可以在语句块2中放置判断循环执行情况的语句。

    s, idx = "PY", 0

    while idx < len(s):

    print("循环执行中: " + s[idx])

    idx += 1

    else:

    s = "循环正常结束"

    print(s)

    >>>

    循环执行中: P

    循环执行中: Y

    循环正常结束

    循环控制: break和continue

    循环结构有两个辅助循环控制的保留字: break和continue。 break用来跳出最内层for或while循环, 脱离该循环后程序从循环后代码继续执行

    如果有2层或多层循环, break退出最内层循环

    continue用来结束当前当次循环, 即跳出循环体中下面尚未执行的语句, 但不跳出当前循环。

    程序的异常处理

    Python语言使用保留字try和except进行异常处理, 基本的语法格式如下:

    try:

    <语句块1>

    except:

    <语句块2>

    语句块1是正常执行的程序内容, 当执行这个语句块发生异常时, 则执行except保留字后面的语句块2.

    try:

    n = eval(input("请输入一个数字: "))

    print("输入数字的3次方值为: ", n**3)

    except:

    print("输入错误, 请输入一个数字!")

    >>>

    请输入一个数字: 1010

    输入数字的3次方值为: 103

    >>>

    请输入一个数字: python

    输入错误, 请输入一个数字!

    展开全文
  • 参加是的2020.12月份第59次计算机二级python考试,一月份出成绩,成绩为优秀,来和大家分享当时备战自己准备的题型和知识点,希望能够帮助更多的学子得到理想的成绩。如有任何疑问请私信,看到的会回~ 详情参见博客...
  • 计算机二级python 知识点篇(python标准库) 标准库: turtle库(必选) 标准库: random库(必选)、 time库(可选) turtle库 窗体函数 turtle.setup(width, height, startx, starty) width : 窗口宽度, 如果值是整数,...
  • 计算机二级python 知识点篇(数据类型) 基本数据类型 数字类型 Python语言提供3种数字类型: 整数类型、 浮点数类型和复数类型, 分别对应数学中的整数、 实数和复数。 整数类型 进制种类 引导符号 描述 十...
  • 计算机二级python 知识点篇(内置函数整理) Python解释器提供了68个内置函数(下面介绍32个) 函数名称 函数说明 abs(x) x的绝对值如果x是复数, 返回复数的模 all(x) 组合类型变量x中所有元素都为真时...
  • 计算机二级python 知识点篇(组合数据类型) 集合、列表、字符串、元组、字典 集合类型 : 集合 (无序、无相同元素) 序列类型 :列表、字符串、元组 (有序、元素之间不排他) 映射类型 :字典 集合 集合概述 ...
  • 计算机二级python 知识点篇(第三方库) 考点考纲 脚 本 程 序 转 变 为 可 执 行 程 序 的 第 三 方 库 :PyInstaller库(必选) 第三方库: jieba库(必选)、 wordcloud库(可选) PyInstaller库与程序打包 ...
  • 计算机二级python 知识点篇(函数与代码复用) 全局变量 全局变量指在函数之外定义的变量, 在程序执行全过程有效。 全部变量在函数内部使用时, 需要提前使用保留字global声明, 语法形式如下: global <全局...
  • 计算机二级python 知识点篇(程序的控制结构) 程序的基本结构 程序由三种基本结构组成: 顺序结构、 分支结构和循环结构 分支结构 单分支结构 if and 表示多个条件“与” 的关系, or 表示多个条件“或” 的关系 ...
  • 计算机二级python 知识点篇(文件和数据格式化) 考纲考点 文件的使用: 文件打开、 关闭和读写 数据组织的维度: 一维数据和二维数据 一维数据的处理: 表示、 存储和处理 二维数据的处理: 表示、 存储和处理 采用...

空空如也

空空如也

1 2 3 4 5 ... 11
收藏数 201
精华内容 80
关键字:

计算机二级python知识点

python 订阅