python基础(3)

我真想猛犸魔晶跳拱下面8到小天鹅
226 阅读5分钟

封装和解构

  • 封装：=右侧出现逗号分隔的值的时候，会封装成元祖
t=1,2 # 输出(1,2)
  • 解构：=右侧是可迭代对象时，左侧有多个标识符表示时，会将可迭代对象的值一一赋给变量
a,b=(1,2) # a=1 ,b=2
  • 解构时，左右2边的数量需要相等
a,b="123" # 错误，因为a=1，b=2，而"3"没有赋给标识符
a,b,c=(1,2,3)

剩余变量解构

a,*rest,c="12345" # a="1",c="5",而rest变量会把"234"封装成列表，不一定要叫rest，可以是任意标识符
a,b,*reset,c="12345" # a="1",b="2",c="5",rest="34"
a,*r1,*r2,b="12345" # 错误写法，只能有一个剩余变量解构
_, *b, _ = [1, 2, 3]

剩余变量是把没有解构的值封装成一个列表

集合set

任意数据类型的集合，是无序、不可重复、可变的元素集合

初始化

  • set()：空集合

  • set(iterable)

a = set()
print(a)
b = set("123456")
print(b)
c = {"123", "abc"}
print(c)
d = set(range(5))
print(d)

set中的数据必须是可hash的，可以理解为不可变类型的数据，像set、bytearray、set都是可变类型，因此不能放进set集合

增加

  • add():如果存在，就不加入

  • update(*othoners):othoners必须是可迭代的对象

a={1,2}
a.update([1,2,3,("a","b")])
print(a)

删除

  • remove(item):从set中删除，如果没有会报KeyError

  • discard(item):从set中删除，如果没有什么都不做

  • pop():任意删除一个元素，set空集会KeyError报错

  • clear():删除所有元素

a={1,2}
a.update([1,2,3,("a","b")])
print(a)
print(a.pop())
print(a.pop())
print(a.pop())
print(a.pop())
print(a.pop())

修改

  • 只能刪除后重新添加

遍历

a={1,3,4,5,6}

for i in a:
    print(i)

set中可加入的类型

  • 数值型：int、float、complex

  • 布尔型：True、False

  • 字符串：string、bytes

  • tuple

  • None

set中不可加入的类型

  • list

  • bytearray

集合概念

  • 全集：所有元素集合

  • 子集和超集：集合A在集合B中，A是B的子集，B是A的超集

  • 真子集和真超集：A是B的子集且A!=B，就是说A完全落在B中

  • 并集：多个集合合并的结果

  • 交集：集合的公共部分

  • 差集：去除公共部分的和

并集

image.png

  • union(*others)：返回多个集合合并后的集合，等价于|
  • update(*others)：等价于|=
a={1,2,3}
b={2,3,4}
c=a.union(b) # union()返回新的set
print(c)
a.update(b) # update()就地修改
print(a)

交集

image.png

  • intersection(*others):等级于&
  • intersection_update(*others):等于于&=
a={1,2,3}
b={2,3,4}
c=a.intersection(b) # 返回新的set
print(c)
a.intersection_update(b) # 修改a set中的值
print(a)

差集

image.png

  • difference(*others):等价于-
  • difference_update(*others):等价于-=
a={1,2,3}
b={2,3,4}
c=a.difference(b)
print(c)
a.difference_update(b)
print(a)

对称差集

image.png

  • symmetric_differece(*others)

  • symmetric_differece_update(*others)

a={1,2,3}
b={2,3,4}
c=a.symmetric_difference(b)
print(c)
a.symmetric_difference_update(b)
print(a)

其他运算

  • issubset(*others):判断当前集合是否是另一个集合的子集

  • issuperset(*others):判断当前集合是否是另一个集合超集

  • isdisjoint(*others):判断当前集合和另一个是否有交集

字典

字典是由key-value对组成的集合，每一个kv对成为entry或item。是无序、不可重复、可变的

初始化

  • dict(**kwargs):使用k-v对初始化
  • dict(iterable,**kwargs):iterable是二元组组成的
  • dict(dict,**kwargs):根据其他dict复制
  • dict.fromkeys(iterable)
a1=dict()
a2={}
a3=dict("a"=1,"b"=2)
a4=dict(a3,"c"=3,"d"=4)
a5=dict([("a",1),("b",2),("c",3)])
a=dict.fromkeys(range(5))
print(a)
b=dict.fromkeys(range(5),0)
print(b)

元素访问

  • d[key]:返回value，没有会报keyError

  • get(key,default):没有就返回default值，没有设置default就返回None

  • setdefault(key,default):没有就设置k-v对，没有设置default，value是None

a={"a":1,"b":2}
print(a.get("c"))
print(a.get("c","c"))
print(a.setdefault("C","cc"))
print(a)

新增和修改

  • d[key]=value

  • update(other):使用另一个字典的kv对更新本字典,key不存在，就添加,key存在，覆盖已经存在的key对应的值

a={"a":1,"b":2}
b={"b":3,"c":4,"d":5}
a["c"]=3
print(a)
a.update(b)
print(a)

删除

  • pop(key,default):default没有设置，key不存在则抛出KeyError异常

  • popitem():随机删除item，dict为空会报错

  • clear():清空字典

遍历

  • d.keys()

  • d.values()

  • d.items()

a={"a":1,"b":2,"c":3}

for i in a.keys():
    print(i)

for i in a.values():
    print(i)

for i in a.items():
    print(i)

遍历删除

# 错误的做法,遍历的时候不能删除dict元素
d = dict(a=1, b=2, c=3)
for k,v in d.items():
    print(d.pop(k))

while len(d):
    d.popitem()

# d.clear()更快点

# for 循环正确删除
d = dict(a=1, b=2, c=3)
keys = []
for k,v in d.items():
    keys.append(k)
for k in keys:
    d.pop(k)

字典的key可以理解成set，需要可hash对象，也就是说不可变的值

解析式和生成器表达式

列表解析式

  • [返回值 for 元素 in 可迭代对象 if 条件]
  • 使用中括号[]，内部是for循环，if条件语句可选
  • 返回一个新的列表
a = [x for x in range(5)]
print(a)
b = [(x,y) for x in range(5) if x > 3 for y in "abcd" if y > "b"]
print(b)
[(i,j) for i in range(7) if i>4 for j in range(20,25) if j>23] # 理论上讲比下面快点
# 等价于
for i in range(7):
    if i > 4:
        for j in range(20,25):
            if j > 23:
                pass
[(i,j) for i in range(7) for j in range(20,25) if i>4 if j>23]
# 等价于
for i in range(7):
    for j in range(20,25):
        if i >4:
            if j >23:
                pass
             
[(i,j) for i in range(7) for j in range(20,25) if i>4 and j>23]
for i in range(7):
    for j in range(20,25):
        if i >4 and j>23:
            pass
  • 同理，把[]换成{}可以生产集合
a={x for x in range(5)}
# 字典生成式
{x:(x,x+1) for x in range(10)}
{x:[x,x+1] for x in range(10)}
{(x,):[x,x+1] for x in range(10)}
{[x]:[x,x+1] for x in range(10)} #报错，因为列表是不可哈希的

生成器

  • (返回值 for 元素 in 可迭代对象 if 条件)
  • 生成器表达式是按需计算（或称惰性求值、延迟计算），需要的时候才计算值
  • 生成器可以用for遍历，但是只能遍历一次，也可以调用next()方法取值，没有会报StopIteration错误
a=(x for x in range(10))
for i in a:
    print(i)
for i in a: # 这次循环没有值
    print(i)
b = (y for y in range(3))
print(next(b))
print(next(b))
print(next(b))
print(next(b)) # 报StopIteration错误
avatar
文章
阅读
粉丝