天池 python 训练营 Task 02

@@ 天池python 训练营 Task 02

易忘知识点

1. 列表 – list【有序可修改】

创建
    1. x = [1, 2, 3]
    2. x= list(range(起始，终止， 步长))
    3. 推导式 -- x = [表达式 for i in range() if ]
    4. [a] * 3 只是创建3个指向list的引用，一旦a改变，x中的3个a也会改变
        a = [0] * 3
        x = [a] * 3
        x = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]
添加
    末尾 -- append【当作一个整体放在末尾的第一个位置】/  extend 【所有东西依次添加在末尾后】
        x = ['11']
        x.append([22, 33]) -- x = ['11', [22, 33]]
        x.extend([22, 33]) -- x = ['11', 22, 33]
    随即位置 -- insert(索引位置，值)
删除 
    pop(指定索引位置) -- 不填默认删最后一个 -- 删后还能用
    remove(指定删除的元素) -- 要填
    del x[起始删除：最后删除位置] -- 删后即焚【没了】
获取
    1. x[起始 : 终止 : 步长] -- 【所有的起始终止都是左闭右开】
    2. 浅拷贝 -- y = x[:] -- 对x排序等操作不会影响y
    3. 深拷贝 -- y = x -- 对x的操作都会影响到y一起变
        如果 x = [[1, 2, 3], [4, 5, 6]]
        x[0][0] = 66
        深拷贝和浅拷贝都会变！！！
常用操作符
    1.  == 一模一样为true
    2.  + 【拼接，相当于extend】【创建新list对象 消耗多余内存】【extend，append，insert 直接改变原数组中】
    3. * 复制 -- [1, 2] * 3 = [1, 2, 1, 2, 1, 2]
    4. in/ not in -- 在里面/不在里面 -- 成员关系
其他方法
    list.count(obj) -- 某数出现的次数
    list.index(obj, 起始位置，终止位置) -- 某数出现的索引位置
    list.reverse() -- 反向列表中的元素
    sort (key = 函数) -- 根据函数的返回值进行排序，比如是根据二维数组的第二位进行排序

2. 元组 – tuple 【有序不可修改】

基本操作同列表 -- 只有一个元素要加逗号，否则会被认为整型等 -- 【（1，）】
    EG：
        1. 创建
            直接赋值
            tuple(range())
            推导式
            乘
        1. 1 创建二维元组
            x = (1, 2, 3), (4, 5, 6)
            print(x) -- ((1, 2, 3), (4, 5, 6))
        2. 没有添加，删除
        2.1 更新和删除一个元组 -- 对元组内部的值进行操作
            1. 更新
                x = (1, 2, 3, 5)
                x1 = x(:2) + (4, ) + x(2: )
            2. 删除
                x = (1, 2, 3, [4, 5])
                x[3][0] = 6
        3.  获取 -- x [起始，终止，步长]
        4. 常用操作符 -- ==， + ，*， in/ not in
        5. 其他方法 -- 由于不可变，只有 count和index
解压
    一维数组
        t = (1, 2, 3)
        (a, b, c) = t
        print(a, b, c)
    二维数组
        t = (1, 2, 3, (4, 5))
        (a, b, c, (d, e)) = t
        print(a, b, c, (d, e))
通配符 -- 没懂，见问题记录！！

3. 字符串

定义
    单引号/双引号
    转义符
        \\ -- \
        \' -- '
        \" -- "
        \n -- 换行
        \r -- 回车
        \t -- 横向制表符
    原始字符串 -- r '内容'
    三引号 -- 多行字符串， 换行符制表符等起作用
操作
    切片 同列表元组的获取 -- x[起始 : 终止 : 步长]
    连接 +
内置方法
    capitalize() -- 字符串第一个字母转换成大写,其他全小写
    lower() -- 全小写， upper() -- 全大写， swapcase() -- 大写变小写，小写变大写
    count(查找的字符， 起始位置，终止位置) -- 查找出现的次数
    startswith(某字符，beg, end) -- 查找是否以该字符开头
        endswith(某字符， beg, end) -- 查找是否以该字符结尾
    find(某字符，beg, end) -- 查找是否在字符串内以及在的位置
        rfind(某字符，beg, end) -- 从右往左找，返回的还是正数的索引位置
    isnumeric() -- 是否全部由数字组成
    ljust(宽度， 填充字符) - 左对齐，不足该宽度的用填充字符填充 
        rjust -- 右对齐，同上
    strip(字符) -- 左右均截掉该字符
        lstrip() -- 左侧截掉该字符
        rstrip() -- 右侧截掉该字符
    partition(字符) -- 找到该字符将字符串切割成三份
        rpartition(字符) -- 从右开找
    replace(之前的字符，新的字符，最大替换的次数）
    split(分割的字符， 分割的次数)
    splitlines(True) -- 按 \r, \n, \r\n, 为True会留下\n, \r, \r\n
    maketrans(需要转换的字符， 转换的字符目标)
    translate(table)-- 根据这个table表来转换字符
格式化
    格式化函数 -- 字符串中大括号，后面format
        str1 = "{0} Danke {1}". format("蛋壳"， "真可爱")
    格式化符号
        %r -- 格式化字符串，用rper()方法处理对象, 返回值会带引号
        %s -- 格式化字符串，用str()方法处理对象， 返回值只有值
    格式化操作符

4. 字典 – dict 【键+值】【无序可修改】

可变类型与不可变类型
    判断方法
        1. id(x), 对x进行操作 看id是否变 -- 变【不可变类型】
        2. hash(x), hash不报错 -- 【不可变类型】
    可变类型
        列表、集合、字典
    不可变类型
        字符、元组、数值
字典的定义
    查找插入速度极快，极占内存
创建和访问字典
    dict1 = {键： 值}
    元组创建 --dict2 = {(1, 2, 3): 1, 4: [5, 6, 7]}
    dict创建1  -- dict3 = dict([(1, 2), (3, 4), (5, 6)]) / dict4 = dict(((1, 2), (3, 4), (5, 6))) -- 【输出都是{1：2， 3: 4, 5: 6}】
    dict 创建2 -- dict5 = dict(name='Tom', age = 10) --【输出是{name: Tom, age: 10}】【键必须是字符串且不加引号】
字典的内置方法
    fromkeys -- 创建新字典
        dict7 = dict.fromkeys(('蛋壳'， '粉粉'，'太极')， (1, 2, 3)) -- {'蛋壳': ('1', '2', '3'), '粉粉': ('1', '2', '3'), '太极':('1', '2', '3')}
    取字典中的所有键 -- dict.keys() -- 转换成列表 list(dict.keys())
    取字典中的所有值 -- dict.value() -- 转换成列表 list(dict.values())
    取字典中的键值 列表元组数组形式 - dict.items() -- 转换成列表 list(dict.items())
    返回指定键的值 -- dic1.get('键'， '找不到的默认值') -- 同 dic1.setdefault('键'， '找不到的默认值')
    key in/not in 字典 -- 判断键是否在字典内
    pop(键， 找不到的默认值) -- 删除该键对应的值
    popitem() -- 随即删除一对
    clear() -- 清空
    浅拷贝（copy()）VS 深拷贝 (赋值）
        修改值浅拷贝不变，有嵌套，嵌套值变浅拷贝会变
    dic1.update(dic2) -- dic2中的键值放到dic1中

5. 集合 – set【键】【无序不可修改】

集合的创建 
    1. set() + add (键)
    2.  =  {键1， 键2}
    3. set(其他类型) -- 用于去除重复值
访问集合中的值
    长度 -- len()
    在不在里面 -- in / not in 
集合的内置方法
    1.  add -- 添加元素
    2.  update -- 复制到自己里面【删除重复元素】
    3. remove/ discard -- 删除某元素 【不在集合中discard不报错】
    4. pop -- 随机移除一个【我看到是第一个】
    集合操作
        5. 交集 -- 
            intersection(s1, s2) 
            s1 & s2 
             instersection_update(s1, s2)【使得原始集合上移除不重叠元素 改变原值】
        6.  并集 --
            union(s1, s2)
            s1  | s2
        7. 差集 -- 
            difference()
            s1 - s2
            difference_update(s1, s2) -- 参照交集
        8. 异或 --  s1中移除与s2中相同的元素，将s2中的不同元素插入
            s1.symmetric_difference(s2)
            s1 ^ s2
            s1.symmetric_difference_update(s2)
        9. 是否被其他集合包含
            s1.issubset(s2)
            s1 <= s2
        10. 是不是包含其他集合
            s1.issuperset(s2)
            s1 >= s2
        10. 是不是不相交 - 不相交 True / 相交 False
            s1.isdisjoint(s2)
    集合的转换
        set() --将其他类型转换成集合 
不可变集合
    frozenset() -- 冻结集合，不能做添加/删除操作【可进行集合操作，除带有update的方法】

6. 序列

针对序列的内置函数
    1. list() -- 转换成列表
    2. tuple() -- 转换成元组
    3. str() -- 转换成字符串
    4. len() -- 返回对象的长度
    5. max() -- 最大值
    6. min() -- 最小值
    7. sum(序列, 可选参数) --  序列，可选参数总和
    8. sorted(这个对象， key = 比较的元素， reverse =  True 降序 / False 升序) 
    9. reversed(序列) -- 反转
    10. enumerate(序列，起始序列值)  -- 同时有数据和数据下标
    11. zip() -- 对应打包成元组
    12. zip(* 元组 ) -- 元组解压成列表