Python 第七节课

列表

常见操作

• li. append（在list最后添加元素）
  li_01 = [1, 2, 3]
  li.append(4)
  print(li_01) --> [1, 2, 3, 4]
  li.append([5, 5])
  print(li_02) --> [1, 2, 3, [5, 5]]
• li.extend（适用于迭代，将列表元素直接扩展到li后面）
  li_03 = [1, 2, 3]
  li.extend([5, 5])
  print(li_03) --> [1, 2, 3, 5, 5]
• li.count（统计某元素出现的次数，返回整数）
  li_04 = [1, 2, 3, [3, 3]]
  print(li_04.count(3)) --> 1
• li.index（返回元素所在索引位置（小的那个））
  li_05 = [1, 2, 3, 2, 3]
  print(li_05.index(3)) --> 2
• li.insert（在index前面插入obj）
  li_06 = [“happy”, “year”]
  li_06.insert(1, “new”)
  print(li_06) --> [“happy”, “new”, “year”]
• li.clear（清空列表）
  li_07 = [1, 2, 3]
  del li_07（直接把li_07给删除）
  li_07.clear()
  print(li_07) --> []
• li.copy （复制）
  li_08 = [1, 2, 3]
  print(li_08.copu()) --> [1, 2, 3]

元组（tuple）

元组介绍

• 元组也是序列结构，但是是一种不可变序列，即内容不可变的列表。（除内部元素不可修改外，元组和列表的用法差不多）
• 元组所消耗的内存比较少
• 当元素不需要改变的时候，推荐使用元组
• 当元素需要改变的时候，推荐使用列表

元组的创建

• 元组使用小括号创建，只要把逗号分隔开即可，除此以外还可以通过tuple()进行元组创建
• 元组类型
  tu = ()
  print(type(tu)) --> <class ‘tuple’>
• iterable
  tu2 = tuple(“123”)
  print(tu2) --> (‘1’, ‘2’, ‘3’)
• 一定为可迭代对象，所以整数不可做为参数，会报错
  tu3 = tuple(123,)
  print(tu3) --> 报错
• 以(,)这种方式创建，只有一个元素时，记得跟上英文状态下逗号，否则会觉得是普通小括号
  tu4 = (123,)
  print(tu4) --> (‘1’, ‘2’, ‘3’, ‘,’)

元组的与列表相同的操作

• 使用方括号加下标访问元素
  tu = tuple(“12345”)
  print(tu[1]) --> 2（字符串）
• 切片（形成新元组对象）
  tu1 = tuple(“12345”)
  print(tu1[2:4]) --> ‘3’, ‘4’
• tuple.count() | tuple.index()
  tu2 = (1, 2, 3, 4, 5, 5, 5, 4)
  pritn(tu2.count(5)) --> 3 （‘5’出现了三次）
  tu3 = (1, 2, 3, 4, 5, 5, 5, 4)
  print(tu2.index(5)) --> 4 （‘5’排序在第四，由零开始）
• tuple类型只有以上两种方法，如果想实现反转和排序，就使用python内置函数：reversed()（内置的反转类）, sorted()（内置的排序类）
  tu4 = (3, 4, 5)
  print(tuple(reversed(tu4))) --> (5, 4, 3)（强转为元组）
  tu5 = (3, 2, 5)
  print(sorted(tu4)) --> [2, 3, 5] （返回为列表）
• 加法及乘法
  tu6 = (1, 2, 3)
  tu7 = (2, 2, 3)
  print(tu6 + tu7) --> (1, 2, 3, 2, 2, 3)（拼接）
  print(tu6 * 2) --> (1, 2, 3, 1, 2, 3)（扩展）
  print(tu6 * tu7) --> 报错（不能元组与元组相乘）

元组中不允许的操作

• 不允许修改、新增元素（一级）
  tu = (1, 2, 3)
  tu[1] = 5
  print(tu) --> TypeError：‘tuple’ object does not support item assignment（tuple不可进行元素修改）
  tu1 = (1, 2, 3, [“amy”, 5])
  tu1[3][0] = 4
  print(tu1) --> (1, 2, 3, [4, 5])（不许修改仅在一级元素是元组）
• 不允许删除某个元素（但可以删除整个元组）
• 实际上，元组没有任何会对内部元素发生修改动作的方法。例如，元组没有remove，append，pop等方法。

元组与列表之间的转换

• list（列表） 转为 tuple（元组）
  li = [4, 5, 6]
  print(tuple(li)) --> (4, 5, 6)
• tuple（元组） 转为 list（列表）
  tu = (4, 5, 6)
  print(list(tu)) --> [4, 5, 6]

字典

字典介绍

python的字典数据类型是基于*hash散列算法实现的，采用键值对(key:value)的形式，根据key的值，计算value的地址，具有非常快的查取和插入速度。它是一种可变对象*，所以支持修改、插入、删除等操作。

字典创建

• 创建空字典
  dic = {}
  print(dic)
  print(type(dic)) --> <class ‘dic’>
• 创建字典，元素不限，值可以为任意类型
  cgt_infor = {“addr” : “hunan”, “age” : 18, “hobbit” : [“study python”, “badminton”]}
  • 注意1：键只能是不可变数据类型
    cgt_infor = {[“addr”] : “human”} --> 报错，因为[]是可变类型
    cgt_infor = {(“addr”) : “human”} --> 可以，因为()是不可变类型
  • 注意2：键需要唯一，但是有重复键时，覆盖
    cgt_infor = {“addr” : “hunan”, “addr” : “深圳”}
    print(cgt_infor) --> {‘addr’: ‘深圳’}
• 创建字典
  dic2 = dict()
  print(dic2)
  print(type(dic2)) --> <class ‘dict’>
  • dict(**kwargs) 键值对
    dic3 = dict(name = ‘amy’, age =18)
    print(dic3) --> {‘name’: ‘amy’, ‘age’: 18}
  • dict(mapping)映射
    dic4 = dict([(“name”, “amy”), (“age”, 18)]) --> {‘name’: ‘amy’, ‘age’: 18}
• 字典创建（拓展）
  • 需求li(“1234”) --> [1, 2, 3, 4]（将li中的每个元素转为int类型）
    li = list(“1234”)
    print(list(map(int, li))) --> [1, 2, 3, 4]（将li当中的每个元素传到了int()当中，在返回）
  • 需求li_k = [‘name’, ‘age’] 与li_v = [‘amy’, 18]怎么组合成键值对的字典（zip对象：打ke包，将可迭代对象里面一一对应的元素打包元组进行返回）
    li_k = [“name”, “age”]
    li_v = [“winter”, 18]
    print(list(zip(li_k, li_v))) --> [(‘name’, ‘winter’), (‘age’, 18)]
    print(dict(list(zip(li_k, li_v)))) --> {‘name’: ‘winter’, ‘age’: 18}

访问字典

• 字典是集合类型
• 查询值（集合类型没有下标，当key值不存在时，访问报错）
  dict1 = {“name”: “amy”, “age”: 18}
  print(dic1[“name”]) --> amy

字典的增加与修改

dict1 = {“name”: “amy”, “age”: 18}

• 增加值，取出赋值
  dic1[“gender”] = “female”
  print(dic1) --> {‘name’: ‘amy’, ‘age’: 18, ‘gender’: ‘female’}
• 修改值，取出重新赋值
  dic1[“gender”] = “male”
  print(dic1) --> {‘name’: ‘amy’, ‘age’: 18, ‘gender’: ‘male’}

一系列删除

• 删除字典元素：del dic[exit_key] 或 dic.pop(exit_key)
  dict1 = {“name”: “amy”, “age”: 18}
  del dic1[“name”]
  print(dic1) --> {‘age’: 18}
  dic2 = {“name”: “amy”, “age”: 18}
  dic2.pop(“age”)
  print(dic2) --> {‘name’: ‘amy’}
• 删除整个字典：del dic
  dic3 = {“name”: “amy”, “age”: 18}
  del dic3
  print(dic3) -->
• 清空整个字典：dic.clear()
  dic4 = {“name”: “amy”, “age”: 18}
  dic4.clear()
  print(dic4) --> {}

字典常见操作

• D.get() --> 返回指定键的值，如果值不存在字典中，则返回default值
  dic1 = {“name”: “amy”, “age”: 18}
  print(dic1.get(“name”)) --> amy
  print(dic1.get(“gender”)) --> None （直接用方括号会报错，但使用get获取返回None）
• D.items() --> 以列表返回可遍历的（键，值）元组对
  dic2 = {“name”: “amy”, “age”: 18}
  print(dic2. items()) --> dict_items([(‘name’, ‘amy’), (‘age’, 18)])
• D.keys() --> 以列表返回字典所有的键
  dic3 = {“name”: “amy”, “age”: 18}
  print(dic3.keys()) --> dict_keys([‘name’, ‘age’])
• D.values() --> 以列表返回字典所有的值
  dic4 = {“name”: “amy”, “age”: 18}
  print(dic4.values()) --> dict_values([‘amy’, 18])

Python 大作业

作业1

作业2

作业4

• 字节与字符串转换
  • bytes(字节) 转为 str(字符串) （解码）
    bt_1 = b’world’
    print(bt_1, decode()) --> world
  • str(字符串) 转为 bytes(字节) （编码）
    s_2 = “world”
    print(s_2.encode()) --> b’world’