python基础——2.字符串，列表，元组，字典，集合，深浅拷贝

一.字符串
1.字符串的索引和切片
[0::1]
[::-1]
[-1::]
2.字符串的部分方法
s.capitelize() #首字母大写
s.title() #中间用空格或者特殊字符隔开的首字母都大写
s.lower() #a-z全部小写
s.casefold() #非英文也可以小写,python3引入
s.upper() #全大写
s.swapcase() #大小写反转
s.ljust(int,任意字符) #左对齐 rjust右对齐
s.center(int,任意字符) #中间对齐
s.expandtabs() #中间有\t置换成8位空格
len(s) #计算长度
s.count("x") #计算元素次数
s.find("x") #是否有x元素,默认返回第一个的索引,找不到返回-1;有rfind
s.endswith("x") #是否以什么结尾,可("xx",初始下标,结束下标)
s.startswith("x") #遵循顾头不顾尾,否则报错
s.index("x") #通过元素找索引,找不到报错
s.strip() #去掉元素前后的空格,括号里可以加元素.有空格,元素去不掉
s.split() #切割;什么都不加,直接转单一元素表;加空字符串报错
s.splitlines() #按行(\r\rn\n)分割.如果参数keepends为False,不包含换行符
s.replace() #(old,new,count)不写次数默认全替换,替换的元素不能是Int
s.isspace() #是否空格
s.isalnum() #是否数字字母
s.isalpha() #是否字母
s.isdigit() #是否数字
s.isdecimal() #是否十进制字符,只存在于unicode对象.(定义十进制字符串,需在字符串前加'u')
s.isnumeric() #是否数字组成,只针对unicode对象.

3.字符串是不可变数据类型

二.列表
1.列表是可变数据类型
2.列表不仅可存放不同类型数据,还可存放大量数据.32位5亿,64位1152921504606846975
3.创建列表的几种方式
lis = list() # 只能创建空列表
lis = list([])
lis = []
lis = list(range())
lis = list("abcdefg")

4.列表的增删改查
    lis.append()                 # 将元素添加到列表尾部
    lis.extend()                 # 将所有元素迭代追加到列表中
    lis.insert(index,object)     # 将元素插入指定下标
    以上打印返回none;打印元列表有变;append效率高于insert

    lis.pop(index)               # 删除给定位置元素,返回删掉元素;默认删最后一个
    lis.remove(object)           # 删除列表中第一次出现的给定元素;不存在默认
    lis.clear()                  # 清空
    del lis[index]               # 可以切片删

    lis[index] = object          # 替换元素,可以切片,迭代的替换

    lis.index(object)            # 返回元素出现第一个下标
    lis.count(object)            # 元素出现次数

5.列表的切片和排序(列表里同时有str和int不能排序)
    lis.reverse()                   # 将元素中列表倒序
    lis.sort()                      # 升序排序
    lis.sort(reverse=True)          # 降序排序

    lis = sorted(lis, key=object)     # 创建排序后的列表
       # def func(name):
            return len(name)
         lis = sorted(lis, key=func)
       # lis = sorted(lis, key=lambda name:(len(name)))

    # 注意：sort和sorted都可以加参数key
           sort和reverse是list自带的方法
           sorted和reversed是内建函数
           sorted返回的是新列表,reversed返回的是迭代器
           sort和reverse是作用在旧列表上

6.列表的三元表达式和列表推导式
    lis1 = [1, 2, 3, 4, 5]
    for i in lis1:
        lis2.append(i)
    lis2 = [i for i in lis1]
    # 列表直接赋值给新表的结果是修改原列表,新列表也会变
    lis = [i for i in range(30) if i % 3 == 0]
    lis3 = [j for i in lis for j in i if j.count("e") == 2]
    # 列表推导式的结果是一个generator 不加括号报错,加中括号是将转list,加小括号就是generator
    # 目前测试生成器generator可以直接加中括号强转,iterator不能加中括号强转
    # generator == []   iterator == list()

7.列表的复制
    1. lis2 = lis1 + []
    2. lis2 = [x for x in lis1]
8.将列表传递给函数时,由于列表是可变数据类型,所以列表的内容可能会在函数调用后改变

三.字典
1.字典是可变数据类型
2.字典是python中唯一映射数据类型
3.字典的特点是查询效率高;存储大量的关系型数据
4.通过Key查找value,内部使用Key来计算一个内存地址
5.key是不可变数据类型 元组、bool、int、str
6.python3.5以前字典是无序的
7.创建字典的几种方式以及zip用法
information_dic = {"name": "wg", "age": 33}
information_dic = dict([("name", "wg"), ("age", 33)])
information_dic = dict("name"=”wg“, age=33)
information_dic = dict(zip(lis1, lis2))
8.字典的增删改查
information_dic["high"] = 185 # 有key修改value,没有增加
information_dic.setdefault("weight", 122) # 有key不修改value,没有增加
information_dic.update(information1) # 有key修改value,没有增加
information_dic = {键: 值,}

    information_dic.get(key)                        # 是否有键,没有返回none;括号中可以设置0,返回0
    information_dic.setdefault("键")                # 没有返回None
    information_dic["键"]                           # 没有就报错
    information_dic.keys()                          # 查键,返回列表
    information_dic.values()                        # 查值,返回列表
    informaiton_dic.items()                         # 查键值对,返回元组
    for i in information (.keys,.values,.items)     # 什么都不加返回键

    information_dic.pop(key, 设置返回值)              # 可以测试是否有键
    information_dic.popitem()                       # 随机删;3.6以后默认删最后一个;返回键值对元组
    del information_dic[key]
    information.clear()                             # 清空

9.关于fromkeys的坑
    information_dic = dict.fromkeys()     # 新字典通过第1个参数迭代做k,第2个参数做值
        dict.fromkeys([], "")
    # 只改变一个值
    information_dic[key] = ""
    # 全改变
    dict.fromkeys([], [])
    information_dic[].append("")          # 所有键值对的id一样
    # 这里我们说是受是否可变数据类型影响应该

10.解构和解包
    a, b = 10, 20 == (10, 20) == [10, 20]     # 元组和列表都有这功能
    for item in dic.items():
        k,v = item
        print(k)
        print(v)
    #json长的就是字典样式

11.字典推导式
    dic1 = {dic[k]: k for k in dic}

    dic = {"a": 1, "b": 2, "A": 3, "D": 4}
    # dic1 = {}
    # for k in dic:
    #     # dic1[k.lower()] = dic.get(k.upper(), 0) + dic.get(k.lower(), 0)
    #     dic1.setdefault(k.lower(), dic.get(k.upper(), 0) + dic.get(k.lower(), 0))
    # print(dic1)
    dic2 = {k.lower(): dic.get(k.upper(), 0) + dic.get(k.lower(), 0) for k in dic}
    print(dic2)

12.提取单一元素字典key,value的方法
    # d = {'name':'haohao'}
    # (k, v), = d.items()
    # print(k)
    #
    # d = {'name':'haohao'}
    # k = list(d)[0]
    # v = list(d.values())[0]
    # print(k)
    #
    # d = {'name':'haohao'}
    # k, = d
    # v, = d.values()
    # print(k)

四.元组
1.元组不可变数据类型;元组的元素可变(孙子),根据数据类型决定;
2.元组是不可变的列表,只读列表,有索引,可查询,可循环,可切片
3.元组只有一个元素的时候要加逗号,否则type不是元组;空元组用tuple()表示
4.元组的增删改查
tup = tup1 + tup2 # 元组不支持修改,可以连接组合方式增加
tup = tup * x
del tup # 元组不支持删除单个元素,可以删整个
tup = tup[0], tup[1] # 元组不能修改元组元素,可以通过拼接构造一个新元组
tup[index]
tup[index1:index2] # 可查询可切片

五.集合
1.集合是可变数据类型;它里边的元素必须是不可变数据类型
2.set就是不存value的字典,只存key
3.set中的元素是不能重复的,无序的,可哈希的;因为无序,所以没有索引
4.哈希的特点就是散列,所以set内部是无序的.
5.s = set() 空集合
6.创建set的几种方式
set = ({})
set = {}
set = set({})

7.set的增删改查
    set.add()       # 正常增加
    set.update()    # 迭代添加,如果加的是字符串,则拆分字符串
    for i in set    # 随机刷数据
    set.pop()       # 随机删,不要添加元素
    set.remove()    # 按元素删 如果元素不存在,报错
    set.clear()     # 清空集合  打印集合得到的结果是set()

8.交集并集反交集...
    set1&set2                       # 得到交集
    set1.intersection(set2)         # 同样的到交集
    set1^set2                       # 得到差集
    set1.symmetric_difference(set2) # 同上
    set1-set2                       # 得到set1独有差集
    set.difference(set2)            # 同上
    set1 < set2                     # 说明set1是set2子集
    set1.issubset(set2)

9.frozenset冻结集合,它是不可变的,存在哈希值,好处是可以作为字典的Key,也可作为其他集合的元素.缺点是创建不能修改,没有add,remove方法.
    s = frozenset("barry")
    print(s, type(s))

10.操作小技巧
    set1 -= set2("")                # 直接删掉字符串拆分后的内容
    set("posh") == set("shop")
    set1 | set2                     # 合并集合
    set.discard(obj)                # 这个方法删除,如果元素不存在不报错,返回none

11.集合推导式
    s = {x**2 for x in [1, -1, 2]}

六.总结
1.不可变数据类型：元组、bool、int、str
可变数据类型：列表、字典、集合
当该数据类型的对应变量值发生改变,那么它对应的内存地址也会改变,不可变数据类型

2.元组是只读列表;集合是不存value的字典;元组的元素是可变的,集合的元素是不可变的;

七.深浅拷贝
浅拷贝就是修改其中一个数据,必然影响另一个数据
深拷贝需要用copy模块