Python3快速入门(三)——Pyth

发布时间:2019-09-27 07:10:47编辑:auto阅读(1692)

    Python3快速入门(三)——Python3标准数据类型

    一、Python3标准数据类型

    Python3 中有六种标准数据类型:
    A、Number(数字)
    B、String(字符串)
    C、List(列表)
    D、Tuple(元组)
    E、Set(集合)
    F、Dictionary(字典)
    Python3 的六种标准数据类型中,Number(数字)、String(字符串)、Tuple(元组)是不可变的,List(列表)、Dictionary(字典)、Set(集合)是可变的。

    二、数字类型

    1、数字类型

    Python 数字数据类型用于存储数值。
    数字数据类型是不允许改变的,如果改变数字数据类型的值,将重新分配内存空间。
    Python中Number有四种类型:bool、int、float、complex。bool类型表示真假,值为True、False;int类型表示长整数;float表示浮点数;complex表示复数。
    int (整数),只有一种整数类型 int。
    bool (布尔),如 True。
    float (浮点数),如 1.23、3E-2
    complex (复数),如 1 + 2j、1.1 + 2.2j

    2、数字类型转换

    如果需要对数据内置的类型进行转换,数据类型的转换,只需要将数据类型作为函数名即可。
    bool(x):将x转换为一个bool值,非空为True,空为Fasle。
    int(x) :将x转换为一个整数。
    float(x) :将x转换到一个浮点数。
    complex(x) :将x转换到一个复数,实数部分为 x,虚数部分为 0。
    complex(x, y) :将 x 和 y 转换到一个复数,实数部分为 x,虚数部分为 y。x 和 y 是数字表达式。

    #!/usr/bin/python3
    
    a = 3.14
    b = int(a)
    print(b)
    c = complex(a)
    print(c)
    d = complex(a,b)
    print(d)

    3、数字运算符

    Python 解释器可以解析输入的一个表达式,输出表达式的值。
    在整数除法中,除法 / 总是返回一个浮点数,如果只想得到整数的结果,丢弃可能的分数部分,可以使用运算符 //。在整数除法中,除法 / 总是返回一个浮点数,如果只想得到整数的结果,丢弃可能的分数部分,可以使用运算符 // 。// 得到的并不一定是整数类型的数,结果与分母分子的数据类型有关系。

    #!/usr/bin/python3
    
    a = 10
    b = 5
    
    c= a + b
    print(c)
    
    c = a - b
    print(c)
    
    c = a * b
    print(c)
    
    c = a / b
    print(c)
    
    c = 2 ** a
    print(c)
    
    c = 10 % 3
    print(c)
    
    c = 10 // 3
    print(c)
    
    c = 10.0 // 3
    print(c)
    
    c = 10 // 3.0
    print(c)

    在交互模式中,最后被输出的表达式结果被赋值给变量 _ 。

    >>> tax = 13/100
    >>> price = 100
    >>> price * tax
    13.0
    >>> _
    13.0
    >>> price + _
    113.0
    >>> _
    113.0

    4、数学函数

    abs(x):返回数字的绝对值
    ceil(x):返回数字的向上取整整数
    exp(x):返回e的x次幂,如math.exp(1) 返回2.718281828459045
    fabs(x):返回数字的绝对值,如math.fabs(-10) 返回10.0
    floor(x):返回数字的向下取整整数,如math.floor(4.9)返回 4
    log(x):返回x的自然对数,如math.log(math.e)返回1.0,math.log(100,10)返回2.0
    log10(x):返回以10为基数的x的对数,如math.log10(100)返回 2.0
    max(x1,x2,...,xn):返回给定参数的最大值,参数可以为序列
    min(x1,x2,...,xn):返回给定参数的最小值,参数可以为序列
    modf(x):返回x的整数部分与小数部分,两部分的数值符号与x相同,整数部分以浮点型表示
    pow(x,y):x**y 运算后的值
    round(x,[n]):返回浮点数x的四舍五入值,如给出n值,则代表舍入到小数点后的位数。
    sqrt(x):返回数字x的平方根。

    #!/usr/bin/python3
    import math
    c = abs(-10.9)
    print(c)
    
    c = math.ceil(4.1)
    print(c)
    
    c = math.exp(1)
    print(c)
    
    c = math.exp(3)
    print(c)
    
    c = math.fabs(-10.9)
    print(c)
    
    c = math.floor(4.9)
    print(c)
    
    c = math.log(math.e)
    print(c)    # 1.0
    c = math.log(100,10)
    print(c)    # 2.0
    
    c = math.log10(100)
    print(c)    # 2.0
    
    c = max([1,4,2])
    print(c)
    
    c = min([1,4,3])
    print(c)
    
    c = math.modf(4.8)
    print(c)    # (0.7999999999999998, 4.0)
    
    c = pow(10,2)
    print(c)
    
    c = round(3.1415,2)
    print(c)
    
    c = math.sqrt(3)
    print(c)

    5、随机函数

    choice(seq):从序列的元素中随机挑选一个元素,比如random.choice(range(10)),从0到9中随机挑选一个整数。
    randrange([start,] stop [,step]) :从指定范围内,按指定基数递增的集合中获取一个随机数,基数缺省值为1
    random():随机生成下一个实数,在[0,1)范围内。
    shuffle(seq):将序列的所有元素随机排序
    uniform(x,y):随机生成下一个实数,在[x,y]范围内。

    #!/usr/bin/python3
    import random
    
    c = random.choice([1,2,3,4,5,6])
    print(c)
    
    c = random.randrange(0,100,2)
    print(c)
    
    c = random.random()
    print(c)
    
    list1 = [1,2,3,4,5]
    random.shuffle(list1)
    print(list1)
    
    c = random.uniform(1,100)
    print(c)

    6、三角函数

    acos(x):返回x的反余弦弧度值
    asin(x):返回x的反正弦弧度值
    atan(x):返回x的反正切弧度值
    atan2(y,x):返回给定的 X 及 Y 坐标值的反正切值
    cos(x):返回x的弧度的余弦值
    hypot(x):返回欧几里德范数 sqrt(xx + yy)。
    sin(x):返回的x弧度的正弦值
    tan(x):返回x弧度的正切值。
    degrees(x):将弧度转换为角度,如degrees(math.pi/2) , 返回90.0
    radians(x):将角度转换为弧度

    #!/usr/bin/python3
    import math
    
    c = math.acos(0)
    print(c)
    c = math.acos(-1)
    print(c)
    c = math.acos(1)
    print(c)
    
    c = math.asin(0)
    print(c)
    c = math.asin(-1)
    print(c)
    c = math.asin(1)
    print(c)
    
    c = math.atan(0)
    print(c)
    c = math.atan(-1)
    print(c)
    c = math.atan(1)
    print(c)
    
    c = math.atan2(-0.5,-0.5)
    print(c)
    
    c = math.cos(math.pi)
    print(c)
    c = math.cos(0)
    print(c)
    c = math.cos(2*math.pi)
    print(c)
    
    c = math.hypot(3,2)
    print(c)
    
    c = math.sin(math.pi)
    print(c)
    c = math.sin(0)
    print(c)
    c = math.sin(math.pi / 2)
    print(c)
    
    c = math.tan(math.pi / 2)
    print(c)
    c = math.tan(math.pi / 4)
    print(c)
    c = math.tan(0)
    print(c)
    
    c = math.degrees(math.pi / 2)
    print(c)
    c = math.degrees(math.pi / 4)
    print(c)
    c = math.degrees(math.pi)
    print(c)
    
    c = math.radians(math.pi / 2)
    print(c)
    c = math.radians(math.pi / 4)
    print(c)
    c = math.radians(math.pi)
    print(c)

    7、数学常量

    pi:数学常量 pi(圆周率,一般以π来表示)。
    e:数学常量 e,e即自然常数(自然常数)。

    #!/usr/bin/python3
    import math
    
    print(math.pi)
    print(math.e)

    8、进制转换

    Python中,二进制、八进制、十六进制的表示如下:
    二进制表示:0bxxxx,如0b0101
    八进制表示:0oxxxx,如0o11
    十六进制表示:0xxxxx,如0x1FFF
    Python中不同进制数转换为二进制、八进制、十进制、十六进制的函数如下:
    bin()、oct()、int()、hex()。

    #!/usr/bin/python3
    # 二进制表示
    print(0b0101)
    # 八进制表示
    print(0o10)
    # 十六进制表示
    print(0xABC)
    # 二进制转换
    print(bin(1024))
    # 八进制转换
    print(oct(1024))
    # 十六进制转换
    print(hex(1024))
    # 十进制转换
    print(int(0b0101))

    三、字符串类型

    1、字符串

    字符串是 Python 中最常用的数据类型,可以使用引号( ' ,"或""")来创建字符串,其中"""用于创建多行字符串。
    Python不支持单字符类型,单字符在Python 中也是作为一个字符串使用。
    Python 访问子字符串,可以使用方括号来截取字符串。

    #!/usr/bin/python3
    
    a = 'Hello World!'
    print(a[0])
    print(a[1:5])

    在需要在字符中使用特殊字符时,python用反斜杠()转义字符。

    #!/usr/bin/python3
    
    print('This is Python')
    print("This's Python")
    print("""
            This is Go,
            Python,
            C++
            """
    )

    2、访问字符串

    Python 不支持单字符类型,单字符在 Python 中作为一个字符串使用。Python 访问子字符串,可以使用方括号来截取字符串。

    #!/usr/bin/python3
    
    a = "Hello world"
    print(a[0])
    print(a[0:5])
    print(a[-1])

    使用索引访问字符串中字符时,如果使用负数索引,表示从字符串右侧开始进行索引,-1表示字符串右侧开始的第一个字符。

    lang = "Java,C,C++,Go,Python"
    print(lang[-6:]) # Python
    print(lang[14:]) # Python
    print(lang[11:13]) # Go

    3、转义字符

    \(在行尾):续行符
    \:反斜杆符号
    \’:单引号
    \”:双引号
    \a:响铃
    \b:退格
    \e:转义
    \000:空
    \n:换行
    \v:纵向制表符
    \t:横向制表符
    \r:回车
    \f:换页
    \oyy:八进制数,yy代表字的字符
    \xyy:十六进制数,yy代表的字符
    \other:其它字符以普通格式还输出

    4、字符串运算符

    +:连接字符串
    *:重复输出字符串
    []:通过索引获取字符串中字符
    [:]:截取字符串的一部分,左闭右开
    in:如果字符串中包含给定的字符,返回True
    not in:如果字符串中不包含给定的字符,返回True
    %:格式字符串
    r/R:原始字符串,原始字符串除在字符串的第一个引号前加上字母 r(可以大小写)以外,字符串的字符不进行转义。

    #!/usr/bin/python3
    
    a = "Hello"
    b = "Python3"
    c = a + b
    
    print(c)
    
    c = 2 * a
    print(c)
    
    print(a[3])
    print(a[1:4])
    
    if "3" in b:
        print("3")
    print(r"Hello Go\n")
    print("Hello Python3"[-1]) 
    print("Hello Python3"[6:])  # Python3
    print("Hello Python3"[:5])  # Hello
    print("Hello Python3"[:-1])  # Hello Python

    对字符串进行截取时,需要指定起始索引和结束索引,如果给定的结束索引超出了字符串的实际结束位置,会截取从开始索引到结束的字符串部分。如果不指定开始索引或结束索引,表示从第0个元素开始或是到最后一个元素结束。

    5、字符串格式化

    Python 支持格式化字符串的输出 ,基本用法是将一个值插入到一个有字符串格式符 %s 的字符串中。字符串格式化符号如下:
    %c:格式化字符以及ASCII码
    %s:格式化字符串
    %d:格式化整数
    %u:格式化无符号整数
    %o:格式化无符号八进制数
    %x:格式化无符号十六进制数
    %X:格式化无符号十六进制数()大写
    %f:格式化浮点数,可指定精度
    %e:使用科学计数法格式化浮点数
    %E:使用科学计数法格式化浮点数
    %g:%f和%e的简写
    %G:%f和%E的简写
    %p:用十六进制数格式化变量的地址

    #!/usr/bin/python3
    
    print("姓名:%s 年龄:%d 岁" % ('×××', 20))

    6、字符串操作函数

    str.capitalize():将字符串的第一个字母变成大写,其他字母变小写。
    center(width[, fillchar]):返回一个指定的宽度 width 居中的字符串,fillchar 为填充的字符,默认为空格。
    str.count(sub, start= 0,end=len(string)):统计字符串里某个字符出现的次数。可选参数为在字符串搜索的开始与结束位置。
    str.encode(encoding='UTF-8',errors='strict'):以指定的编码格式编码字符串,errors参数可以指定不同的错误处理方案。
    bytes.decode(encoding="utf-8", errors="strict"):指定的编码格式解码 bytes 对象。默认编码为 'utf-8'。
    str.endswith(suffix[, start[, end]]):用于判断字符串是否以指定后缀结尾,如果以指定后缀结尾返回True,否则返回False。可选参数"start"与"end"为检索字符串的开始与结束位置。
    expandtabs(tabsize=8):把字符串中的 tab 符号('\t')转为空格,tab 符号('\t')默认的空格数是 8。
    find(str, beg=0, end=len(string)):检测字符串中是否包含子字符串 str ,如果指定 beg(开始) 和 end(结束) 范围,则检查是否包含在指定范围内,如果指定范围内如果包含指定索引值,返回的是索引值在字符串中的起始位置。如果不包含索引值,返回-1。
    index(str, beg=0, end=len(string)):如果包含子字符串返回开始的索引值,否则抛出异常。
    isalnum():检测字符串是否由字母和数字组成。如果 字符串至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False。
    isalpha():检测字符串是否只由字母组成。如果字符串至少有一个字符并且所有字符都是字母则返回 True,否则返回 False。
    isdigit():检测字符串是否只由数字组成。如果字符串只包含数字则返回 True ,否则返回 False。
    islower():检测字符串是否由小写字母组成。如果字符串中包含至少一个区分大小写的字符,并且所有区分大小写的字符都是小写,则返回 True,否则返回 False。
    isnumeric():检测字符串是否只由数字组成,只针对unicode对象。如果字符串中只包含数字字符,则返回 True,否则返回 False。
    isspace():检测字符串是否只由空白字符组成。如果字符串中只包含空格,则返回 True,否则返回 False。
    istitle():检测字符串中所有的单词拼写首字母是否为大写,且其它字母为小写。如果字符串中所有的单词拼写首字母是否为大写,且其它字母为小写则返回 True,否则返回 False。
    isupper():检测字符串中所有的字母是否都为大写。如果字符串中包含至少一个区分大小写的字符,并且所有区分大小写的字符都是大写,则返回 True,否则返回 False。
    join(sequence):用于将序列中的元素以指定的字符连接生成一个新的字符串。返回通过指定字符连接序列中元素后生成的新字符串。
    len(str):返回对象(字符、列表、元组等)长度或项目个数。
    ljust(width[, fillchar]):返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。
    lower():转换字符串中所有大写字符为小写。将字符串中所有大写字符转换为小写后返回。
    lstrip([chars]):用于截掉字符串左边的空格或指定字符。返回截掉字符串左边的空格或指定字符后生成的新字符串。
    str.maketrans(intab, outtab):用于创建字符映射的转换表,第一个参数是字符串,表示需要转换的字符,第二个参数是字符串表示转换的目标。两个字符串的长度必须相同,为一一对应的关系。
    translate(table[, delete]):根据参数table转换字符串的字符,要过滤掉的字符放到 deletechars 参数中。table翻译表是通过 maketrans() 方法转换而来,delete是字符串中要过滤的字符列表。返回翻译后的字符串,若给出了delete 参数,则将原来的bytes中的属于delete的字符删除,剩下的字符要按照table中给出的映射来进行映射 。
    max(str):返回字符串中最大的字母。
    min(str):返回字符串中最小的字母。
    replace(old, new[, max]):把字符串中的 old(旧字符串) 替换成 new(新字符串),如果指定第三个参数max,则替换不超过 max 次。
    rfind(str, beg=0 end=len(string)):返回字符串最后一次出现的位置,如果没有匹配项则返回-1。
    rindex(str, beg=0 end=len(string)):返回子字符串 str 在字符串中最后出现的位置,如果没有匹配的字符串会报异常,可以指定可选参数[beg:end]设置查找的区间。
    rjust(width[, fillchar]):返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串。如果指定的长度小于字符串的长度则返回原字符串。
    rstrip([chars]):删除 string 字符串末尾的指定字符(默认为空格)
    split(str="", num=string.count(str)):指定分隔符对字符串进行切片,如果参数 num 有指定值,则仅分隔 num+1 个子字符串。返回分割后的字符串列表。
    splitlines([keepends]): 按照行('\r', '\r\n', \n')分隔,返回一个包含各行作为元素的列表,如果参数 keepends 为 False,不包含换行符,如果为 True,则保留换行符。
    startswith(substr, beg=0,end=len(string)):用于检查字符串是否是以指定子字符串开头,如果是则返回 True,否则返回 False。如果参数 beg 和 end 指定值,则在指定范围内检查。如果检测到字符串则返回True,否则返回False。
    strip([chars]):用于移除字符串头尾指定的字符(默认为空格)或字符序列。
    返回移除字符串头尾指定的字符序列生成的新字符串。
    swapcase():用于对字符串的大小写字母进行转换。返回大小写字母转换后生成的新字符串。
    title():返回"标题化"的字符串,所有单词的首个字母转化为大写,其余字母均为小写。如果单词的第一个字符为非字母,非字母后的第一个字母将转换为大写字母。
    upper():将字符串中的小写字母转为大写字母。返回小写字母转为大写字母的字符串。
    zfill(width):返回指定长度的字符串,原字符串右对齐,前面填充0。返回指定长度的字符串。
    isdecimal():检查字符串是否只包含十进制字符,只存在于unicode对象。如果字符串是否只包含十进制字符返回True,否则返回False。
    ord(c):获取字符c的ASCII码编码值

    #!/usr/bin/python3
    
    a = str.capitalize("hello Python")
    print(a)  # Hello python
    
    a = "Hello Python3"
    print(a.center(40, "-"))  # ------------Hello Python3--------------
    
    print(a.count("l"))  # 2
    
    a_utf8 = a.encode("UTF-8")
    print(a_utf8)
    print(a_utf8.decode("UTF-8"))
    
    a = "hello.bin"
    if a.endswith("bin"):
        print("The file is bin file")
    
    a = "\tHello Python3"
    print(a.expandtabs(4))
    
    print(a[a.find("Hello"):])
    
    print(a.isalnum())
    
    a = "Hello python3"
    print(a.istitle())  # False
    a = "Hello Python3"
    print(a.istitle())  # True
    
    s1 = ","
    s2 = ""
    seq = ["C++","Go","Java","Python"]
    print(s1.join(seq))  # C++,Go,Java,Python
    print(s2.join(seq))  # C++GoJavaPython
    
    print(a.ljust(40,"-"))
    
    print(a.lower())
    a = "***Hello Python3"
    print(a.lstrip("*"))
    
    intab = "aeiou"
    outtab = "12345"
    c = "Hello Python3"
    trantab = str.maketrans(intab, outtab)
    print(c.translate(trantab))
    c = "hello world"
    trantab = str.maketrans('abcdefghijklmnopqrstuvwxyz', 'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
    print(c.translate(trantab))
    
    c = "Hello Python3"
    print(c.split(" "))

    四、列表

    1、列表简介

    序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字作为索引,第一个索引是0,第二个索引是1,依此类推。
    Python常见的序列是字符串、列表和元组。
    序列都可以进行的操作包括索引,切片,加,乘,检查成员。
    此外,Python已经内置确定序列的长度以及确定最大和最小的元素的方法。
    列表是最常用的Python数据类型,可以作为一个方括号内的逗号分隔值出现。
    列表的数据项不需要具有相同的类型。
    创建一个列表,只要把逗号分隔的不同的数据项使用方括号括起来即可。

    2、列表访问

    列表元素的访问可以使用索引进行,可以指定开始索引和结束索引进行切片操作。

    #!/usr/bin/python3
    
    list1 = ['Python3', True, 2019, 3.14];
    list2 = [1, 2, 3, 4, 5, 6, 7];
    
    print(list1[0])
    print(list2[1:5])

    对列表进行解包时,接收对象个数必须与列表的元素个数相匹配。

    #!/usr/bin/python3
    
    a, b, c = [1, "Hello Python", True] # a, b = [1,"Hello Python", True]错误
    print(a, b, c)

    3、更新列表

    #!/usr/bin/python3
    
    list1 = ['Go', 'Python3', "Java", 2019]
    
    print(list1[3])
    list1[3] = "C++"
    print(list1[3])

    4、删除列表元素

    del 语句可以用于删除列表的的元素。

    #!/usr/bin/python3
    
    list1 = ['Go', 'Python3', "Java", 2019]
    
    print(list1[3])
    del list1[3]
    print(list1)

    5、列表运算符

    +:组合,将两个列表进行组合后生成新的列表
    *:重复,将列表的元素重复多次,生成新的列表
    x in list:判断x是否在列表中,如果是返回True,否则返回False。
    for x in list: print(x, end=" "):对列表进行迭代

    #!/usr/bin/python3
    
    list1 = ["C++", "Java", "Python", "Go"]
    
    list2 = ["Lua", "NodeJS"]
    
    print(list1 + list2)
    print(2 * list1)
    if "C++" in list1:
        print("C++")
    for x in list1:
        print(x)

    6、列表操作函数

    len(list)
    列表元素个数
    max(list)
    返回列表元素最大值
    min(list)
    返回列表元素最小值
    list(seq)
    将序列转换为列表

    #! /usr/bin/python3
    
    list1 = [1, 1, 2, 3, 4, 5, 8]
    
    print(len(list1))
    print(max(list1))
    print(min(list1))
    
    list2 = list((1, 2, 3, 4, 5))
    print(list2)

    7、列表方法

    list.append(obj)
    在列表末尾添加新的对象
    list.count(obj)
    统计某个元素在列表内出现的次数
    list.extend(seq)
    在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)
    list.index(obj)
    从列表中找出某个值第一个匹配项的索引位置
    list.×××ert(index,obj)
    在列表的index位置插入对象obj
    list.pop(index=-1)
    移除列表中位置为index(默认为最后一个)的元素,并返回元素的值
    list.remove(obj)
    移除列表中某个值的第一个匹配项
    list.reverse()
    反向列表中的元素
    list.sort(key=None,reverse=False)
    对列表进行排序,较函数指定的比较函数。
    key 用来进行比较的元素,只有一个参数,具体的函数的参数就是取自于可迭代对象中,指定可迭代对象中的一个元素来进行排序;reverse 指定排序规则,reverse = True 降序, reverse = False 升序(默认)。
    list.clear()
    清空列表
    list.copy()
    复制列表

    #! /usr/bin/python3
    
    list1 = [1, 3.14, True]
    list1.append("Python")
    print(list1)
    print(list1.count(1))  # True也会被统计为1
    list1.extend(["C++", "Java", "Go"])
    print(list1)
    print(list1.index(1))
    list1.×××ert(1, "Hello")
    print(list1)
    print(list1.pop(1))
    list1.remove(True)    # 删除第一个1
    print(list1)
    list1.reverse()
    print(list1)
    
    list1 = [1, 13, 5, 9]
    list2 = list1.copy()
    print(list2)
    list1.clear()
    print(list1)
    
    list1 = [(2, 2), (3, 4), (4, 1), (1, 3)]
    
    def take(elem):
        return elem[1]
    
    list1.sort(key=take)
    print(list1)
    #  [(4, 1), (2, 2), (1, 3), (3, 4)]

    五、元组

    1、元组

    元组使用小括号创建,只需要在括号中添加元素,并使用逗号隔开,元素可以是不同类型。

    #! /usr/bin/python3
    
    tup1 = ("Go", "Python", 1, 3.14, True)  # 元组
    tup2 = 1, 2, 3.14, "Python"     # 元组
    tup3 = ()   # 空元组
    tup4 = (1,) # 一个元素的元组
    tup5 = (1)  # 整型数字
    
    print(type(tup1))
    print(type(tup2))
    print(type(tup3))
    print(type(tup4))
    print(type(tup5))

    2、访问元组

    元组可以使用下标索引来访问元组中的值。

    #! /usr/bin/python3
    
    tup1 = ('Go', 'C++', True, 3.14)
    tup2 = (1, 2, 3, 4, 5, 6, 7)
    
    print(tup1[1])
    print(tup2[1:5])

    对元组进行解包时,接收对象个数必须与元组的元素个数相匹配。

    #!/usr/bin/python3
    
    a, b, c = (1, "Hello Python", True)  # a, b = (1,"Hello Python", True) 错误
    print(a, b, c)

    3、修改元组

    元组中的元素值是不允许修改的,但可以对元组进行连接组合。

    #! /usr/bin/python3
    
    tup1 = (1, 2)
    tup2 = ('Go', 'Python')
    
    # tup1[0] = 100 # 不能修改
    
    tup3 = tup1 + tup2
    print(tup3)

    tuple元素不可变有一种特殊情况,当元素是可变对象时,对象内部属性是可以修改的。tuple的不可变限制只是在一个纬度上:元素的类型。tuple的元素所保存的内容(数值或内存地址)是不允许修改的,但地址映射的对象自身是可以修改的。

    #!/usr/bin/python3
    
    tup1 = ("Go", "Python", [1,2,True])
    tup1[2][2] = False
    print(tup1)

    4、删除元组

    元组中的元素值不允许删除,但可以使用del语句来删除整个元组。

    #! /usr/bin/python3
    
    tup2 = ('Go', 'Python')
    print(tup2)
    del tup2

    5、元组运算符

    +:连接两个元组,生成新的元组。
    *:重复多次元组
    x in tuple:判断x是否在元组中,如果存在返回True,否则返回False。
    for x in tuple:迭代元组

    #!/usr/bin/python3
    
    tup1 = ("Go", "Python", [1, 2, True])
    tup2 = (1, 2, 3)
    print(tup1 + tup2)
    print(2 * tup1)
    
    if "Python" in tup1:
        print("Python")
    for x in tup1:
        print(x)

    6、元组内置函数

    len(tuple)
    计算元组元素的个数
    max(tuple)
    返回元组中元素的最大值
    min(tuple)
    返回元组中元素的最小值
    tuple(seq)
    将序列转换为元组

    #! /usr/bin/python3
    
    tup1 = (1, 2, 3)
    print(len(tup1))
    print(max(tup1))
    print(min(tup1))
    tup2 = tuple([1, "Go", 3.14, True])
    print(tup2)

    六、字典

    1、字典

    字典是一种无序的数据结构,可存储任意类型对象。字典的每个键值(key:value)对用冒号(:)分割,键值对之间用逗号(,)分割,整个字典包括在花括号({})中 ,格式如下:
    d = {key1 : value1, key2 : value2 }
    键必须是唯一的,但值则不必唯一。值可以取任何数据类型,但键必须是不可变的,如字符串,数字或元组。
    字典值可以是标准的对象,也可以是用户定义的,但键不行。
    字典中不允许同一个键出现两次,创建时如果同一个键被赋值两次,后一个值会被记住。键必须不可变,可以用数字、字符串或元组作为键,列表不可以。

    2、访问字典

    #!/usr/bin/python3
    
    dict1 = {'Name': 'Lee', 'Age': 27}
    
    print(dict1['Name'])
    print(dict1['Age'])

    字典是无序的,因此不能使用索引访问字典的元素,可以使用key访问字典的相应key的值,如果用字典里没有的键访问数据,会输出错误。

    3、修改字典

    向字典添加新内容的方法是增加新的键/值对,修改或删除已有键值对。

    #!/usr/bin/python3
    
    dict1 = {'Name': 'Lee', 'Age': 17}
    
    print(dict1['Name'])
    print(dict1['Age'])
    
    dict1['Name'] = "Bauer"
    dict1['Age'] = 30
    dict1['School'] = "Python School"
    
    print(dict1['Name'])
    print(dict1['Age'])
    print(dict1['School'])

    4、删除字典元素

    可以删除字典元素,可以清空字典,也可以删除字典。

    #!/usr/bin/python3
    
    dict1 = {'Name': 'Lee', 'Age': 17}
    
    print(dict1)
    
    del dict1["Age"]
    dict1.clear()
    del dict1

    5、字典内置函数

    len(dict)
    计算字典元素个数,即键的总数。
    str(dict)
    输出字典

    6、字典内置方法

    dict.clear()
    删除字典内所有元素
    dict.copy()
    返回一个字典的浅复制
    dict.fromkeys(seq[,value])
    以序列 seq 中元素做字典的键,value 为字典所有键对应的初始值创建一个新字典。
    dict.get(key[,default=None])
    返回字典中指定键的值,如果值不存在,返回default值。
    key in dict
    如果key存在字典中,返回True,否则返回False。
    dict.items()
    以列表返回可遍历的(键, 值) 元组数组
    dict.keys()
    返回一个迭代器,可以使用list转换为列表
    dict.setdefault(key,default=None)
    修改key的值为default,如果键不存在于字典中,将会添加键并将值设为default。
    dict.update(dict2)
    将字典dict2的键值对更新到dict字典里
    dict.values()
    返回字典中所有值的迭代器,可以使用list转换为列表
    dict.pop(key[,default])
    删除字典给定键 key 所对应的值,返回值为被删除的值。key值必须给出。 否则,返回default值。
    dict.popitem()
    随机返回并删除字典中的一对键和值(一般删除末尾对)。

    七、集合

    1、集合

    集合(set)是一个无序的无重复元素序列,可以使用大括号 { } 或者 set() 函数创建集合。创建一个空集合必须用 set() 而不是 { },{ } 用来创建一个空字典。

    2、集合运算符

    集合是无序的序列,因此不能使用索引对集合元素进行访问。集合的运算包括差、并、交。

    #!/usr/bin/python3
    
    fruit = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
    print(fruit)
    print("apple" in fruit)
    
    a = set("Hello")
    b = set("world")
    print(a)
    print(b)
    print(a - b)
    print(a | b)
    print(a & b)
    print(a ^ b)
    c = {x for x in 'abracadabra' if x not in 'abc'}
    print(c)

    3、集合内置函数

    add(x):将元素 x 添加到集合 中,如果元素已存在,则不进行任何操作。
    update(x):将x添加到集合中,且x参数可以是列表,元组,字典等。
    remove(x):将元素 x 从集合中移除,如果元素不存在,则会发生错误。
    discard(x):将元素 x 从集合中移除,如果元素不存在,不会发生错误。
    pop():随机删除集合中的一个元素
    len(s):计算集合 s 元素个数。
    clear():清空集合。
    x in s:判断元素 x 是否在集合 s 中,存在返回 True,不存在返回 False。
    copy():返回一个集合的拷贝
    set.difference(set):返回集合的差集,即返回的集合元素包含在第一个集合中,但不包含在第二个集合(方法的参数)中。
    set.difference_update(set):在原始集合上移除指定集合中存在的元素,没有返回值。
    set.intersection(set1, set2 ... etc):返回两个或更多集合中都包含的元素,即交集。
    set.intersection_update(set1, set2 ... etc):在原始的集合上移除不重叠的元素,没有返回值。
    set.isdisjoint(set):判断两个集合中是否包含相同的元素,如果没有返回 True,否则返回 False。
    set.issubset(set):判断集合是否是指定集合的子集,如果是则返回 True,否则返回 False。
    set.issuperset(set):判断指定集合是否是集合的子集,如果是则返回 True,否则返回 False。
    set.symmetric_difference(set):将两个集合中不重复的元素作为一个集合返回。
    set.symmetric_difference_update(set):移除当前集合中在另外一个指定集合相同的元素,并将另外一个指定集合中不同的元素插入到当前集合中。无返回值。
    set.union(set1, set2...):返回两个集合的并集,即包含了所有集合的元素,重复的元素只会出现一次。

    #!/usr/bin/python3
    
    set1 = {"Go", "C++", "Java", "Python3"}
    set1.add("C")
    print(set1)
    
    set1.add("Go")
    print(set1)
    
    set1.update({"NodeJS", "Lua"})
    print(set1)
    
    set1.update([1, 2, 3], [4, 5])
    print(set1)
    
    set1 = {"C++", "C", "Go"}
    set2 = {"Python", "Lua", "NodeJS"}
    set3 = set1.union(set2)
    print(set3)
    
    print(set1.intersection(set3))
    
    print(set1.issubset(set3))
    
    print(set3.issuperset(set1))
    
    print(set3.difference(set1))
    
    print(set1.symmetric_difference(set3))
    
    set1.symmetric_difference_update(set3)
    
    set1.difference_update(set3)
    print(set1)

关键字