python学习day7笔记

Posted 2021-06-10 麋鹿的麋

利用列表实现队列与堆栈的特征

1.队列(先进先出)
l = []

l.append(111)
l.append(222)
l.append(333)

print(l.pop(0))
print(l.pop(0))
print(l.pop(0))

2.堆栈(先进后出)
l = []

l.append(111)
l.append(222)
l.append(333)

print(l.pop())
print(l.pop())
print(l.pop())

字典以及它的内置方法

大括号括起来，内部可以存放多个元素
元素的表现形式是以K:V键值对形式
    K是对V的描述性信息，一般都是字符串
    	K不可变类型，且不能重复
        	整型，浮点型，字符串
        V可以是任意类型

d1 = {
    \'username\':\'jason\',
    \'password\':123,
    \'hobby\':[\'read\',\'run\']
}

K只要是不可变类型即可，同一个字典内可以混用

1.按key存取值：可存可取
d1[\'username\'] = \'tony\'
print(d1[\'age\'])  # 键不存在 直接报错！！！
d1[\'age\'] = 18  # 键存在则修改 不存在则新建

2.长度len，统计字典中键值对的个数
print(len(d1))  # 3

3.成员运算in和not in
print(\'jason\' in d1)  # Flase
字典默认只暴露key，value不暴露，如果想取，一般只能通过key

4.删除
del d1[\'password\']  # 键值对一起删除
d1.pop(\'password\')  # 字典不能用索引
res = d1.pop(\'password\')  # 123  pop弹出value

5.键keys(),值values(),键值对items()
print(d1.keys())  # 获取字典中所有的key，输出的可以看成是列表
print(d1.values())  # 获取字典中所有的value，输出的可以看成是列表
print(d1.items())  # 将items()的结果可以直接看成列表[]套小列表()

for k,v in d1.items():  # 解压赋值，结合for循环
    print(k,v)
    
6.循环
\'\'\'字典for循环只能获取到key\'\'\'
for i in d1:
    print(i)

字典常用的操作方法

第一种创建字典的方式
d2 = {\'k1\':\'v1\',\'k2\':\'v2\'}  # dict({\'k1\':\'v1\',\'k2\':\'v2\'})

第二种创建方式
res = dict(name=\'jason\',pwd=123,hobby=[\'read\',\'run\'])
print(res)  # 输出 {\'name\':\'jason\',\'pwd\':123,\'hobby\':[\'read\',\'run\']}

第三种创建方式
l = [
    [\'username\',\'jason\'],
    [\'password\',123],
    [\'hobby\',[\'read\',\'run\']]
]
d = {}  # 先创建一个空字典
for i in l:  # for循环输出每个列表
    d[i[0]] = i[1]  # d[\'username\'] = \'jason\'
# 用 键存在则修改，键不存在则新建 的理论，直接全部套进字典

# 换一种用法
d = {}  
for k,v in l:  
    d[k] = v
    
# 再换一种 最精简方法
res = dict(l)



d1 = {
    \'username\':\'jason\',
    \'password\':123,
    \'hobby\':[\'read\',\'run\']
}

1.dict.get()  # 使用频率最为广泛
print(d1.get(\'key值\'))  返回value值
# 好处：get方法不存在也不会报错 返回None(什么都没有)
print(d1.get(\'username\',\'嘿嘿嘿\'))  # 输出 jason
print(d1.get(\'age\',\'嘿嘿嘿\'))  # 输出 嘿嘿嘿
\'\'\'get方法还可以给第二个参数 键存在则不使用 键不存在则返回第二个参数\'\'\'

2.dict.clear()
d1.clear()  # 清空列表

3.dict.fromkeys()  # 快速生成一个字典
l = [\'username\', \'age\', \'hobby\']
res = dict.fromkeys(l,123)
print(res)  # 输出 {\'username\': 123, \'age\': 123, \'hobby\': 123}

4.dict.popitem()  # 弹出一组键值对
d1.popitem()
print(d1)  # 输出 {\'username\': \'jason\', \'password\': 123}

res = d1.popitem()
print(res)  # 输出 (\'hobby\', [\'read\', \'run\'])

5.dict.setdefault()  # 重点
dd = {\'name\': \'jason\', \'pwd\': 123}
dd.setdefault(\'age\', 18)  # 键不存在，则新建
res = dd.setdefault(\'name\', \'egon\')  # 键存在不修改，而是获取到键对应的值
print(dd,res)  # 输出 {\'name\': \'jason\', \'pwd\': 123, \'age\': 18} jason

6.dict.update()  # 可有可无
dd = {\'name\': \'jason\', \'pwd\': 123}
dd.update({\'age\': 18})  # 键不存在，则新建
dd.update({\'name\': \'egon\'})  # 键存在，则修改
print(dd)  # 输出 {\'name\': \'egon\', \'pwd\': 123, \'age\': 18}

# 完全等于↓ 
dd[\'age\'] = 18
dd[\'name\'] = \'egon\'

元组及元组内置方法

\'\'\'
元组  tuple
小括号括起来 括号内可以存放多个元素
元素与元素之间逗号隔开 元素可以是任意类型
	元组也可以简单地理解为是列表
	
	元组属于不可变类型
\'\'\'
# 类型转换与list一致，支持for循环的都可以

# 元组当内部只有一个元素的时候，逗号不能省略
t1 = (1)
print(type(t1))  # 输出 int
t2 = (\'a\')
print(type(t2))  # 输出 str

t1 = (1,)
print(type(t1))  # 输出 tuple
t2 = (\'a\',)
print(type(t2))  # 输出 tuple

元组优先要掌握的操作

1.按索引取值(正向取+反向取)：只能取
t1 = (11, 22, 33)
t1[0] = 666
print(t1)  # 报错，因为元组内存地址不能修改

t1 = (11, 22, [11, 22])
t1[2].append(33)
print(t1)  # 输出t1 = (11, 22, [11, 22, 33]) 
# 如果元素是可变类型，那么元素值可以改

2.切片(顾头不顾尾，步长)
# 与字符串，列表一致

3.长度
len()

4.成员运算in和not in
# 与列表一致

5.循环
for i in(11, 22, 33):
    print(i)

集合（用的不多）

\'\'\'
集合 set
大括号括起来，内部可以存放多个元素
元素与元素之间逗号隔开(不是k:v键值对)，元素只能是不可变类型

只有两种情况才会考虑使用集合，其他情况不要使用
	1.关系运算
		两个群体之间判断 交叉并集
	2.去重操作  # 集合天生去重，不保留顺序
		去除重复的元素
\'\'\'
# 定义空集合，需要使用关键字set
se = set()

集合操作方法

# 关系运算
a = {1,2,3,4,5,6,7,8}
b = {2,4,6,8,10}

如何求交集
>>> a.intersection(b)
>>> a & b  # a和b共同拥有的
如何求差集
>>> a.difference(b)
>>> a - b  # a相对b独有的
>>> b - a  # b相对a独有的
如何求并集
>>> a.union(b)
>>> a | b  # a和b所有拥有的
如何求对称差集
>>> a.symmetric.(b)
>>> a ^ b  # a和b都相对独有的

# 父集，子集
\'\'\'
a包含b
a是b的父集，b是a的子集
\'\'\'