Python学习记——（7）元组、字典

元组 tuple

  元组的定义:元组是不可改变的序列，同list一样，元组是可以存放任意类型的容器

  元组的表示方法:用小括号() 括起来，单个元素括起来后加逗号(,)区分单个对象还是元组

  创建空元组的字面值：t = ()  # t绑定空元组

  创建非空元组

    t = 200,

    t = (20,)

    t = (1, 2, 3)

    t = 100, 200, 300

  type(x) 函数用来返回 x的类型

元组的错误示例:

  t = (20)  # t 绑定定整数，不是元组

  x, y, z = 100, 200, 300  # 序列赋值等同于如下

  x, y, z = (100, 200, 300)  # 序列赋值

  x, y, z = [100, 200, 300]  # 序列赋值

  x, y, z = "ABC"            # 序列赋值

元组的构造(创建)函数 tuple

    tuple() 生成一个空的元组,等同于()

    tuple(iterable)  用可迭代对象生成一个元组

  示例:

    t = tuple()

    t = tuple([2,3,5,7])

    t = tuple(range(10))

元组的运算:

   +  加号用于元组的拼接操作

   *  乘号 用于用原元组生成重复的元组

   +=

   *=

  示例:

    t = (1, 2, 3) + (4, 5, 6)  #t=(1,2,3,4,5,6)

    t = (1, 2) * 3  # t=(1,2,1,2,1,2)

    t = (1, 2, 3)

    t += (4, 5, 6)  # 等同于字符串规则

    t *= 2  

元组的比较运算:

  > >= < <= == !=规则与列表的比较规则完全相同

  示例

    (1, 2, 3) < (1, 3, 2)  # True

    (1, 2, 3) != (1, 3, 2)  # True

    ....

    (1, '二') < ('二', 1)

in / not in 运算符:

   与列表的in / not in 规则完全相同

   2 in (1, 2, 3, 4) # True

   '2' not in (1, 2, 3, 4)  # True

索引和切片

  索引:

    元组[整数]

  切片:

    元组[整数:整数]

    元组[整数:整数:整数]

  规则同字符串的切片规则

  元组不支持索引赋值和切片赋值

练习:

  生成一个 1~9的平方的元组，元组如下:(1, 4, 9, 16, ...., 81)

元组的方法：

  T.index(v[, begin[, end]])  返回对应元素的索引下标，begin为开始索引，end为结束索引，v不存在时触发ValueErorr错误

  T.count(x)  返回元组中对应元素的个数

序列的种类:

  字符串str, 列表list, 元组tuple,

  字节串bytes, 字节数组bytearray(后面再讲)

能用于序列的函数总结：

  len(x), max(x), min(x), sum(x), any(x),all(x)

  str(obj)  将对象转为字符串

  list(iterable) 将可迭代对象转为列表

  tuple(iterable) .........转为元组

  reversed(seq)  返回反向顺序的可迭代对象

  sorted(iteralbe, reverse=False)

字典 dict

  什么是字典

    1. 字典是一种可变的容器，可以存储任意类型的数据

    2. 字典中的每个数据都是用"键"(key) 进行索引，而不象序列可以用下标来进行索引

    3. 字典中的数据没有先后顺序关系，字典的存储是无序的

    4. 字典中的数据以键(key)-值(value)对形式进行映射存储

5. 字典的键不能重复，且只能用不可变类型作为字典的键

字典的字面值表示方式:

    {} 括起来，以冒号(:) 分隔键-值对, 各键-值对用逗号分隔开

创建空字典:d = {}  # 空字典

创建非空字典:

    d = {'name':'tarena', 'age': 15}

    d = {1:'星期一', 2:"星期二"}

    # 以下写法会出现问题（因为键不能重复)

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

字典的构造(创建)函数 dict

    dict()    # 创建空字典，等同于 {}

    dict(iterable)  用可迭代对象初始化一个字典

    dict(**kwargs)  关键字传参形式生成一个字典

  示例:

    d = dict()

    d = dict([('name', 'tarena'), ('age', 15)])

    d = dict(name='tarena', age=15)

字典的基本操作:

  字典的键索引：用[] 运算符可以获取和修改键所对应的值

  语法:字典[键]

  示例:

    d = {'name': 'tarena', 'age': 15}

    print('姓名:', d['name'], '年龄:', d['age'])

  添加/修改字典的元素

    字典[键] = 值

  示例:

    d = {}

    d['name'] = 'tarena'

  键索引赋值说明:

    当键不存在时，创建键并绑定键对应的值

    当键存在时，修改键绑定的对象

删除字典的元素

  del 语句 可以用来删除字典的键

  语法:del 字典[键]

  示例:

     d = {1:"星期一", 2:'星期二'}

     del d[2]

in 运算符(成员资格判断运算符)

  1. 可以用in运算符来判断一个键是否存在于字典中，如果存在则返回True,否则返回False

  2. not in 与 in 相反

  示例:

    d = {1: "One", 2: "Two", "三": 'Three'}

    1 in d  # True

    '二' in d  # False

    3 not in d  # True

    'One' in d  # False

字典的迭代访问:字典是可迭代对象，字典只能对键进行迭代访问

  示例:

    d = {1: "One", 2: "Two", "三": 'Three'}

    for k in d:

        print(k, '对应的值是:', d[k])

练习:

  写程序，实现以下要求:

    1. 将如下数据形成一个字典 seasons

        键     值

        1      '春季有1,2,3月'

        2      '夏季有4,5,6月'

        3      '秋季有7,8,9月'

        4      '冬季有10,11,12月'

    2. 让用户输入一个整数代表季度,打印这个季度的信息。如果用户输入的信息不在字典中，则提示'信息不存在' 可以用于字典的内建(built-in)函数

  len(x)  返回字典的键值对的个数

  max(x)  返回字典的键的最大值

  min(x)  返回字典的键的最小值

  sum(x)  返回字典的键的和

  any(x)  真值测试，如果字典中的一个键为真，则结果为真

  all(x)  真值测试，字典中所有键为真，则结果才为真字典的方法:

  

函数	说明
D代表字典对象
D.clear()	清空字典
D.pop(key)	移除键，同时返回此键所对应的值
D.copy()	返回字典D的副本,只复制一层(浅拷贝)
D.update(D2)	将字典 D2 合并到D中，如果键相同，则此键的值取D2的值作为新值
D.get(key, default)	返回键key所对应的值,如果没有此键，则返回default
D.keys()	返回可迭代的 dict_keys 集合对象
D.values()	返回可迭代的 dict_values 值对象
D.items()	返回可迭代的 dict_items 对象

 

 

  示例:

    d = {1:'One', 2:'Two', 3:'Three'}

    for k, v in d.items():

        print("字典的键是:", k, '值是:', v)

练习:

  输入一段字符串，打印出这个字符串中出现过的字符及字符出现过的次数如:输入:  abcdabcaba

    输出:

      a: 4次

      b: 3次

      d: 1次

      c: 2次

    (不要求打印的顺序)

字典推导式

  字典推导式是用可迭代的对象依次生成字典的表达式

  语法:

    { 键表达式: 值表达式 for 变量 in 可迭代对象 [if 真值表达式]}

    注: [] 及其中的内容代表可省略

  说明:

    1. 先从可迭代对象中取值

    2. 用变量绑定

    3. 用if 进行条件判断，如果为真值则执行下一步

    4. 执行'键表达式'和 '值表达式' 然后加入到新字典中

  示例:

    生成一个字典，键为1~9的整数,值为键的平方

    d = {x: x **2 for x in range(1, 10)}

练习:

  有如下字符串：L = ['tarena', 'china', 'beijing']生成如下字典:D = {'tarena': 6, 'china':5, 'beijing':7}答:D = {x: len(x) for x in L}

练习2:

  No = [1001, 1002, 1005, 1008]

  names = ['Tom', 'Jerry', 'Spike', 'Tyke']

  用上面No列表中的数据作为键，用names中的数据作为值，生成相应的字典:

    如:d = {1001: 'Tom', 1002: 'Jerry', ....}

  方法1:

    d = {No[i]: names[i] for i in range(len(No))}

  方法2:

    d = {n: names[No.index(n)] for n in No}

字典推导式可以嵌套，语法同列表推导式

字典 vs 列表

  1. 都是可变对象

  2. 索引方式不同,列表用整数索引，字典用键索引

  3. 字典的查找速度可能会快于列表(重要)

  4. 列表的存储是有序的，字典的存储是无序的列表 和字典 的内部存储原理 列表，顺序存储 字典，映射存储

练习:

  1. 输入一些单词和解释，将单词作为键，将解释作为值，将这些数据输入到字典中,当输入空的单词时结束输入然后，输入查询的单词，给出单词对应的解释