python字典、元组、列表、set集合、序列

字典

字典的创建

"""
创建字典的方式
"""
# 第一种方式
dict1 = {"zs": "张三", "ls": "李四", "ww": "王五"}
print(dict1["zs"])
# 可以通过给不存在的建赋值动态添加字典元素
dict1["zl"] = "赵六"
print(dict1)

# 第二种方式 通过 dict() 创建，以 键 = 值 的形式传入参数，其中键不能加引号
dict2 = dict(zs="张三", ls="李四", ww="王五")
print(dict2)

dict3 = dict({("zs", "张三"), ("ls", "李四"), ("ww", "王五")})
print(dict3)

dict4 = dict({"zs": "张三", "ls": "李四", "ww": "王五"})
print(dict4)

dict5 = dict({"zs": "张三", "ls": "李四"}, ww="王五")
print(dict5)

dict6 = dict(zip({"zs", "ls", "ww"}, {"张三", "李四", "王五"}))
print(dict6)

字典的增删改查

"""
字典的增删改查
增 ：
    fromkeys(iterable[ ,values])
        适用于从无到有创建一个字典，可以快速初始化一个字典
删 ：
    pop(key[ ,default])
        删除字典中指定的元素，返回被删除的元素
        如果删除的元素不存在，会抛出异常，但如果传入 default 参数，就会返回 default
    popitem()
        python3.7 前是随机删除字典中的一个键值对
        3.7后是删除字典中最后一个加入的键值对
        返回被删除的键值对
    del 运算符、 clear() 函数都可以使用
改 ：
    可以直接通过 字典[键] = 值 的方式修改单个元素
    update([other])
        给该函数传入多个键值对，或传入另外一个字典，或一个包含键值对的可迭代对象
        实现一键修改多个键值对的值
查 ：
    可以直接通过 字典[键] 查找，但是如果字典中没有该键就会报错
    get(key[ ,default]) 
        传入 default 参数，当键不存在时返回 default
    setdefault(key[ ,default])
        当找不到 key 时，向字典中添加 字典[key] = default ，然后返回 default
    items()
        获取字典的所有键值对
    keys()
        获取字典的所有键
    values()
        获取字典的所有值
"""
# 增
d = dict.fromkeys("python", 1)
print(d)  # {'p': 1, 'y': 1, 't': 1, 'h': 1, 'o': 1, 'n': 1}
# 修改某个键的值，如果该键不存在，就会创建一个新的
d['p'] = 10
print(d)

# 删 pop()
print(d.pop('y'))  # 1
# print(dict.pop('4')) # 抛出异常
print(d.pop('4', "没有该元素"))  # 没有该元素
# popitem()
print(d.popitem())  # ('n', 1)

# 改 update()
d = dict.fromkeys("pyth")
print(d)  # {'p': None, 'y': None, 't': None, 'h': None}
d.update({"p": 1, "y": 2})
print(d)  # {'p': 1, 'y': 2, 't': None, 'h': None}
d.update(t=3, h=4)  # 键不能加引号
print(d)  # {'p': 1, 'y': 2, 't': 3, 'h': 4}

# 查
# get()
print(d.get("p"))  # 1
print(d.get("a", "不存在"))  # 不存在
# setdefault()
print(d.setdefault("p", "11"))  # 1
print(d.setdefault("a", "aaa"))  # aaa
print(d)  # {'p': 1, 'y': 2, 't': 3, 'h': 4, 'a': 'aaa'}

# items() keys() values()
items = d.items()
keys = d.keys()
values = d.values()
print(items)
print(keys)
print(values)

字典的浅拷贝

"""
字典的浅拷贝
    copy()
"""
d = dict.fromkeys("python", 1)
d1 = d.copy()
print(d1)  # {'p': 1, 'y': 2, 't': 3, 'h': 4, 'a': 'aaa'}

字典嵌套

"""
字典嵌套
"""
# 字典中嵌套字典
d = {"zs": {"语文": 90, "数学": 87}}
# 访问字典中的字典
print(d["zs"]["语文"])  # 90
# 字典中嵌套列表
d = {"zs": [10, 20, 30]}
print(d["zs"][0])  # 10

字典推导式 

"""
字典推导式（同列表推导式）
    {express for target in iterable}
    {express for target in iterable if condition}
"""
d = {"a": 1, "b": 2, "c": 3}
dd = {v: k for k, v in d.items()}
print(dd)  # {1: 'a', 2: 'b', 3: 'c'}

user = {"username": "user_exist", "password": "123456"}
user.update({"confire": "123"})
print(user)

列表

添加列表

"""
列表的添加
    append()
    extend()
"""
heros = [1, 2, "hangsan"]

# 向列表末尾添加元素
heros.append([1,2,3]) # 追加一个列表
print(heros)

# 一次性向列表添加多个元素
heros.extend(["a","b","c"]) # 参数为一个可迭代对象（列表、元组、字符串等）
heros.extend("1ds") # 参数为一个可迭代对象（列表、元组、字符串等）
print(heros)

# 也可以使用切片实现 append() 和 extend()方法
s = [1,2,3]
s[len(s):] = [4]
"""
以下写法均会报错
s[4:] = 5 
s[4] = [5]
s[4] = 5
"""
print(s)

# 在列表的任意位置插入元素： insert(待插入的位置，待插入的元素)
s = [1,3,4,5]
s.insert(1,2)
print(s)
# 在列表的最后一个位置插入元素，则相当于 append() 方法
s.insert(len(s),6)
print(s)

删除列表

"""
列表的删除
remove() 
    (1)当列表中有多个相同元素时，指挥删除第一个匹配到的
    (2)如果删除的元素列表中不存在，会报错
pop()：删除指定位置的元素
clear()：清空列表
"""
s = [1, 3, 4, 5]
s.append(2)
s.remove(2)
# s.remove(11) # ValueError: list.remove(x): x not in list
print(s)

# 删除某个位置上的元素： pop(要删除元素的下标)，返回被删除的元素
x = s.pop(0)
print(x)
print(s)

# 清空列表
s.clear()
print(s)

修改列表 

"""
列表的修改
"""

s = [1, 2, 3, 4, 5]
# 通过索引修改某一个位置的元素
s[2] = "str"
print(s)

# 利用切片一次性替换多个元素
# 将 = 左边指定的位置的内容清除
# 然后将 = 右边的可迭代对象中的片段插入左边被删除的位置
# 右边的内容可以比左边删除的内容多、少或等于
# 可以将切片位置后的所有元素替换为 = 右边的元素
s[3:] = ["s", "a", "b", "23"]
print(s)

列表排序和翻转

"""
列表排序 sort()
列表翻转 reverse()
上述两种方法均会改变原数组
"""
nums = [4, 3, 6, 47, 35, 9, 2, 5, 3]
nums.sort()  # 默认升序排序
print(nums)

# 实现降序排序：可以将升序排序的结果翻转
nums.reverse()
print(nums)
# 实现降序排序的第二种方法，传入一个reverse = True 的参数
nums = [4, 3, 6, 47, 35, 9, 2, 5, 3]
nums.sort(reverse=True)  # 降序排序
print(nums)

列表查找

"""
列表的查找
count(要查找的元素) ：查找元素在列表中出现的次数
index(要查找的元素) ：查找元素在列表中索引
    找不到元素时会报错
    当列表有多个相同元素时，返回查找到的第一个元素的索引
    还可以指定范围： index(要查找的元素，start，end)
        返回 start~end 范围的第一个元素，不包括 end 的位置
"""
nums = [3, 2, 5, 2, 3, 5, 3, 1, 8, 7]
# count(要查找的元素) ：查找元素在列表中出现的次数
count = nums.count(3)  # 查找元素 3 在列表中出现的次数
print(count)

# index(要查找的元素) ：查找元素在列表中索引
# 当列表有多个相同元素时，返回查找到的第一个元素的索引
index = nums.index(5)
print(index)
nums[nums.index(3)] = "变为字符串3"
print(nums)
# print(nums.index(78))  # 报错

 列表拷贝

"""
列表的拷贝
    (1)方式一： copy()
    (2)方式二： 切片
    (3)方式三：导入 copy 模块，调用模块中的copy():copy.copy(要拷贝的列表)
    (4)方式四：深拷贝，调用 copy 模块中的 deepcopy():copy.deepcopy(要拷贝的列表)
    上述(1)(2)(3)三种拷贝都是浅拷贝
"""
nums = [3, 2, 5, 2, 3, 5, 3, 1, 8, 7]
# copy() 方法
copy_nums1 = nums.copy()
print(copy_nums1)
# 切片方式
copy_nums2 = nums[:]
print(copy_nums2)

nums = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
copy_nums = nums.copy()
nums[0][0] = 11
# 修改列表元素nums[0][0]， copy_nums也受到了影响，所以copy()是浅拷贝
print("copy_nums:", copy_nums)
# 深拷贝
import copy

nums = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
copy_nums = copy.deepcopy(nums)
nums[0][0] = 11
# 修改列表元素nums[0][0]， copy_nums也受到了影响，所以copy()是浅拷贝
print("copy_nums 深拷贝:", copy_nums)

列表的加法和乘法

"""
列表的加法和乘法
    加法：即列表的拼接，要求加号两边都是列表
    乘法：重复列表内的所有元素若干次
"""
list1 = [1, 2, 3]
list2 = [4, 56]
# list2 = 4 # 报错，加号的两边要是列表
# 列表的加法
print(list1 + list2)
# 列表的乘法
print(list1 * 2)

嵌套列表

"""
嵌套列表
"""
# 嵌套列表的两种写法
list1 = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
list2 = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]
print(list1)
print(list2)

# 嵌套列表的访问
for i in list1:
    for j in i:
        print(j, end=" ")
    print()

print(list1[0][0])

# 创建二维列表
a = [0] * 3
# print(a)
for i in range(len(a)):
    a[i] = [0] * 3
print(a)

# [[0,0,0]]
# 以下这种创建二维列表的方式看起来是正确的，但实际上会存在问题
b = [[0] * 3] * 3  # [[0, 0, 0], [0, 0, 0], [0, 0, 0]]
# 存在的问题
# 只修改第一个列表中的第一个元素，
# 但实际上却是: b = [[1, 0, 0], [1, 0, 0], [1, 0, 0]]
b[0][0] = 1
print(b)
# 问题的原因：
# 正常情况下，不同的列表指向不同的地址，所以当某个元素修改时不会影响其他元素
print(a[0] is a[1] is a[2])  # False
# 但乘号重复列表中的元素只是把原有的内容引用了多次，实际上并没有开辟新的内存空间
# 所以出现了问题
print(b[0] is b[1] is b[2])  # True

"""
is 和 is not 称为同一性运算符，用于检测对象的 id 值是否相等，即判断两个变量是不是同一对象
在 python 中，每一个对象都有三个属性， 唯一标示（id）、类型和值
id 值：在对象创建的时候就有，不可以被修改，也不会有重复值

in 和 not in 判断的是包含问题
in 运算符用于判断某个元素是否包含在序列中
not in 运算符用于判断某个元素是否不包含在序列中
"""
# is 运算符： 检验两个变量是否指向同一个对象
str1 = "zhangsan"
str2 = "zhangsan"
print(str1 is str2)  # True
list1 = [1, 2, 3]
list2 = [1, 2, 3]
print(list1 is list2)  # False

列表推导式

"""
列表推导式
    基本语法：[express for target in iterable]
        列表推导式的结果一定是一个列表，所以需要中括号[]
    列表推导式的效率比 for 循环的效率要高
"""
# 用列表推导式实现将列表中的每一个元素都乘以2
list = [1, 2, 3, 4, 5]
list = [i * 2 for i in list]
print(list)

list = [i for i in range(5)]
print(list)

list = [i + 1 for i in range(5)]
print(list)

list = [c * 2 for c in "zhangsan"]
print(list)

# ord() 将单个字符串转换为对应的编码
list = [ord(c) for c in "zhangsan"]
print(list)

matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]
# 将二维列表里的每一行的第二列元素提取出来
list = [i[1] for i in matrix]
print(list)
# 提取二维列表的副对角线元素
list = [matrix[i][2 - i] for i in range(3)]
print(list)

# 用列表推导式创建二维列表
list = [[0] * 3, [0] * 3, [0] * 3]
print(list)
list[0][0] = 1
print(list)
# 用列表推导式代替上述代码
list1 = [[0] * 3 for i in range(3)]
print(list1)
list1[0][0] = 1
print(list1)

"""
进阶版列表推导式(添加条件判断)
    基本语法：[express for target in iterable if condition]
    每一次执行完 for 语句的迭代之后，会先执行 if 条件判断，最后执行左侧的表达式
    即顺序为：for 语句迭代 ——> if 条件判断 ——> 左侧的表达式
"""
list = [i for i in range(10) if i % 2 == 0]
print(list)  # [0, 2, 4, 6, 8]
list = [i + 1 for i in range(10) if i % 2 == 0]
# 变成了奇数，证明最后执行的是左侧的表达式
print(list)  # [1, 3, 5, 7, 9]

"""
嵌套列表推导式
    基本语法：[express for target1 in iterable1
                     for target2 in iterable2
                           .....
                     for targetN in iterableN]
"""
# 将一个二维列表降级为一维列表
list = [col for row in matrix for col in row]
print(list)
# 对应的 for 循环语句
list = []
for row in matrix:
    for col in row:
        list.append(col)
print(list)

"""
进阶版嵌套列表推导式
    基本语法：[express for target1 in iterable1 if condition1
                     for target2 in iterable2 if condition2
                           .....
                     for targetN in iterableN if conditionN]
"""
list = [[x, y] for x in range(5) if x % 2 == 0 for y in range(5) if y % 2 != 0]
print(list)
# 对应的 for 循环写法
_ = []  # 下划线表示一个临时变量
for x in range(5):
    if x % 2 == 0:
        for y in range(5):
            if y % 2 != 0:
                _.append([x, y])
print(_)

 元组

"""
元组，也是一个序列
元组使用小括号表示
但实际上没有小括号也行，但是要有逗号隔开
元组是不可变的，所以增删改查中只有查，其他操作不可以进行
其他的操作基本和列表一致（包括切片）
"""

 元组的常用操作

# 元组定义
tuple = (1, 2, 3)
print(tuple)
tuple = 4, 5, 6
print(tuple)

# 生成只有一个元素的元组（重点是要加逗号）
singleTuple = (1,)
print("单个元素的元组：", singleTuple)

# 用下标获取元组元素
print(tuple[0])
# 元组切片
_ = tuple[:]
print(_)
print(_[::-1])

print("count 方法", tuple.count(5))
print("index 方法", tuple.index(5))

# 元组加号和乘号的使用
t1 = (1, 2, 3)
t2 = (4, 5, 6)
print("加号：", t1 + t2)
print("乘号：", t1 * 2)

# 元组嵌套
t = t1, t2
print(t)  # ((1, 2, 3), (4, 5, 6))
t = 1, 2, 3, (4, 5, 9)
print(t)  # (1, 2, 3, (4, 5, 9))

# 元组的迭代省略，同列表

# 元组使用列表推导式（注意：结果还是一个列表）
tuple = (1, 2, 3, 4)
list = [each * 2 for each in tuple]
print(list)  # [2, 4, 6, 8]

打包和解包

"""
打包和解包
    打包：生成一个元组称为元组的打包
    解包：将元组的所有元素一次性分别赋值给别的变量，称为解包
        变量的个数要和元组的元素个数相对应，否则会报错
打包和解包不仅适用于元组，还适用于任何的序列类型
"""

# 元组的打包和解包
tuple = (1, 2, 3)  # 打包
print(tuple)
a, b, c = tuple  # 解包
print("a=", a, "b=", b, "c=", c)

# 列表的打包和解包
list = ["a", "b", "c"]
x, y, z = list
print(x, y, z)

# 字符串的打包和解包
str = "123"
x, y, z = str
print(x, y, z)

# python 的多重赋值，
# 实现原理就是通过元组打包再解包
# _ = (10,20)
# x,y = _
x, y = 10, 20  # x = 10,y = 20
print(x)
print(y)

 set 集合

简单介绍

"""
集合
    集合中所有元素都是独一无二的，并且也是无序的
    不能用索引的方式访问
    集合中的元素只能是不可变的对象（如字符串、元组），不能是可变的（如列表）
"""
# 空 {} 表示一个字典
print(type({})) # <class 'dict'>
# {} 只有一个元素且没有冒号时表示一个集合
print(type({1})) # <class 'set'>
# {} 有元素并且有冒号表示一个字典
print(type({1:2})) # <class 'dict'>

 set 集合创建

"""
集合的创建
"""
# 使用 {}
set1 = {1,2,3}
print(set1) # {1, 2, 3}
# 使用集合推导式
set2 = {k for k in "python"}
# 显示和传入的字符顺序可能不一致
print(set2) # {'p', 'y', 't', 'o', 'n', 'h'}
set3 = set("hello")
# 不重复且无序
print(set3) # {'l', 'h', 'e', 'o'}

 set 集合内置方法

"""
集合内置方法
    copy() ：浅拷贝方法
    isdisjoint() ：
        检测两个集合之间是否没有关系，如果没有关系则返回 True
        如果集合之间有一部分相同，也视为有关系，该方法就会返回 False
    issubset(参数) ：
        判断集合是否是参数集合的子集
    issuperset(参数) ：
        判断集合是否是参数集合的超集
    计算当前集合和其他对象共同构建的并集、交集、差集、对称差集
"""
s = {"a", "b", "c"}
print(s.isdisjoint(set("aDWE")))  # False
print(s.isdisjoint("oython"))  # True

# abc 是 abcdef 的子集
print(s.issubset("abcdef"))  # True
print(s.issuperset("ab"))  # True

# 并集 支持多参数
print(s.union({1, 2, 3}))
print(s.union({1, 2, 3}, "hello"))

# 交集 支持多参数
print(s.intersection({1, 2, "a"}))

# 差集 支持多参数
print(s.difference({1, 2, 3}))

# 对称差集 不支持多参数
print(s.symmetric_difference("ab123"))

# 可以用运算符代替函数
# 使用运算符时，运算符两边必须是集合类型
# 使用函数参数可以是集合，也可以是可迭代对象
# <= 检测子集  >= 检测超集
print(s <= set("abcdfr"))
# < 检测真子集  > 检测真超集
print(s < set("abcde"))
# |：并集   &：交集   -：差集   ^：对称差集

set 集合增删改操作

"""
集合分为可变集合和不可变集合
    可变集合： set
    不可变集合： frozenset
    上述方法都不会改变集合内容，所以 set 和 frozenset 都适用
"""

"""
只适用于 set 集合的方法
更新集合：
    update(*others)
    intersection_update(*others) # 交集
    difference_update(*others) # 差集
    symmetric_difference_update(*others) # 对称差集
添加元素：
    add(要添加的元素)
删除元素：
    remove(要删除的元素) 如果元素不存在抛出异常
    discard(要删除的元素) 如果元素不存在不会抛出异常
    pop() 随机从集合中弹出一个元素
    clear() 清空集合
"""
print("---------------")
s = {1, 2, 3}
print(s)
s.update(["a", "b"], "py")  # 实际上就是 union_update() 方法，因为使用较多所以省略 union
print(s)  # {1, 2, 3, 'a', 'y', 'p', 'b'}
s.intersection_update("123abc")  # 交集
print(s)  # {'b', 'a'}
s.difference_update("123a")  # 差集
print(s)  # {'b'}
s.symmetric_difference_update("12b")  # 对称差集
print(s)  # {'2', '1'}

序列的内置函数

列表、元组和字符串的相互转换

"""
列表、元组和字符串的相互转换
    -- list()  tuple()  str()
"""
print(list("python"))  # ['p', 'y', 't', 'h', 'o', 'n']
print(list((1, 2, 3, 4)))  # [1, 2, 3, 4]

print(tuple("python"))  # ('p', 'y', 't', 'h', 'o', 'n')
print(tuple([1, 2, 3, 4]))  # (1, 2, 3, 4)

print(str(["python", "java"]))  # ['python', 'java']
print(str((1, 2, 3, 4)))  # (1, 2, 3, 4)

all()、any()方法

"""
max()  min()  sum()  len()  sorted()  reversed()
sorted() 排序后返回一个全新的列表，并不会改变原列表
reversed() 返回一个迭代器对象
这些函数见名知意，不再举例

all() ：
    判断可迭代对象中是否所有元素的值都为真
any() ：
    判断可迭代对象中是否存在某个元素的值为真
"""
x = (1, 2, 0)
y = (1, 2, 3)
print(all(x))  # False
print(all(y))  # True

print(any(x))  # True
y = (0, 0, 0)
print(any(y))  # False

 enumerate()方法

"""
enumerate([start]) ：
    该函数用于返回一个枚举对象
    将该枚举对象转换为列表后就是一个二元组列表
    将可迭代对象中的每个元素及从 0 开始的序号共同构成一个二元组
    start : 自定义序号开始的值
"""
seasons = ["Spring", "Summer", "Fall", "Winter"]
print(enumerate(seasons))  # <enumerate object at 0x000002DC8528FD38>
# [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
print(list(enumerate(seasons)))
# [(10, 'Spring'), (11, 'Summer'), (12, 'Fall'), (13, 'Winter')]
print(list(enumerate(seasons, 10))

zip()方法

"""
zip()
    用于创建一个聚合多个可迭代对象的迭代器
    它会将参数传入的每个可迭代对象的每个元素依次组合成元组
    即第 i 个元组包含来自每个可迭代对象的第 i 个元素
    如果可迭代对象的元素个数不一致，则以元素个数最少的为准
"""
x = [1, 2, 3]
y = [4, 5, 6, 7]
z = [7, 8, 9, 10]
print(zip(x, y))  # <zip object at 0x000001D58CFD75C8>
print(list(zip(x, y)))  # [(1, 4), (2, 5), (3, 6)]
# 参数个数多的部分会被丢弃
print(list(zip(x, y, z)))  # [(1, 4, 7), (2, 5, 8), (3, 6, 9)]

# 若不想被丢弃，使用 itertools 模块中的 zip_longest()
import itertools

print(list(itertools.zip_longest(x, y, z)))  # [(1, 4, 7), (2, 5, 8), (3, 6, 9), (None, 7, 10)]

map()方法

"""
map()
    会根据提供的函数对指定的可迭代对象的每个元素进行运算
    并将运算结果返回
    返回的是一个迭代器
"""
# ord() 返回字符对应的 Unicode 编码
print(ord("a"))  # 97
print(map(ord, "abc"))  # <map object at 0x000002049F5237F0>
# ord() 函数需要一个参数，所以值提供一个可迭代对象 "abc"
print(list(map(ord, "abc")))  # [97, 98, 99]
# 当提供的函数需要多个参数时，对应的传入相应数量的可迭代对象
# 如 pow 函数需要两个参数，则传入两个可迭代对象
# 实际上相等于求 2²，3³，4²
# 如果两个可迭代对象元素个数不一致，则同样以少的为准
print(list(map(pow, [2, 3, 4], [2, 3, 2])))  # [4, 27, 16]

filter()方法

"""
filter()
    会根据提供的函数对指定的可迭代对象的每个元素进行运算
    并将运算结果为真的元素以迭代器的形式返回
"""
print(list(filter(str.islower, "Python")))  # ['y', 't', 'h', 'o', 'n']