基础数据类型（内置方法2）
基础数据类型（内置方法2）
栈和队列
栈：
先进后出
队：
先进先出
#队列：
l = []
for i in range(3): # [1,2,3]
l.append(i)
res = l.pop(0)
print(res)
#堆栈：
l1 = []
for i in range(3):
l1.append(i)
res = l1.pop()
print(res)
字典
大括号括起来，内部是一个一个k:v这样的键值对，中间以逗号隔开，k是对v的描述性信息，一般是字符串，
k是不可变类型
整形，浮点型，字符串
v可以是任意类型
按k存取：可存可取
>>> d1 = {
... 'username': 'lyh',
... 'age': 18,
... 'hobbyes': ['eat', 'sleep'],
... }
>>> d1['username']
'lyh'
>>> d1['username'] = 'hrj'
>>> d1
{'username': 'hrj', 'age': 18, 'hobbyes': ['eat', 'sleep']}
>>> d1['level'] = 10
>>> d1
{'username': 'hrj', 'age': 18, 'hobbyes': ['eat', 'sleep'], 'level': 10}
'''
字典[key]取值，有就取出来，没有就新建一个键值对，有key后面重新赋值，就是改
'''
长度运算--len（）
>>> d1 = {
... 'username': 'lyh',
... 'age': 18,
... 'hobbyes': ['eat', 'sleep'],
... }
>>> len(d1)
3
身份运算 in not in
>>> d1 = {
... 'username': 'lyh',
... 'age': 18,
... 'hobbyes': ['eat', 'sleep'],
... }
>>> 'username' in d1
True
>>> 'level' not in d1
True
'''
参与字典成员运算的是字典的key
'''
删除 之 del
>>> d1 = {
... 'username': 'lyh',
... 'age': 18,
... 'hobbyes': ['eat', 'sleep'],
... }
>>>
>>> del d1['age']
>>> d1
{'username': 'lyh', 'hobbyes': ['eat', 'sleep']}
删除 之 pop
>>> d1 = {
... 'username': 'lyh',
... 'age': 18,
... 'hobbyes': ['eat', 'sleep'],
... }
>>> d1.pop('username')
'lyh'
>>> d1
{'age': 18, 'hobbyes': ['eat', 'sleep']
'''
同样，pop删除也是有返回值的
'''
三键： keys（） values() items（）
keys（） ----获取字典的所有k
>>> d1 = {
... 'username': 'lyh',
... 'age': 18,
... 'hobbyes': ['eat', 'sleep'],
... }
>>>
>>> d1.keys()
dict_keys(['username', 'age', 'hobbyes'])
values（）
>>> d1 = {
... 'username': 'lyh',
... 'age': 18,
... 'hobbyes': ['eat', 'sleep'],
... }
>>> d1.values()
dict_values(['lyh', 18, ['eat', 'sleep']])
items（）-------获取字典的所有value
>>> d1 = {
... 'username': 'lyh',
... 'age': 18,
... 'hobbyes': ['eat', 'sleep'],
... }
>>> d1.items()-------获取字典的所有键值对，，最后以一个列表套元组的形式
dict_items([('username', 'lyh'), ('age', 18), ('hobbyes', ['eat', 'sleep'])])
python2和python3的区别
'''
python3：
dict_keys(['username', 'age', 'hobbyes'])
dict_values(['lyh', 18, ['eat', 'sleep']])
dict_items([('username', 'lyh'), ('age', 18), ('hobbyes', ['eat', 'sleep'])])
python2：
>>> d1 = {
... 'username': 'lyh',
... 'age': 18,
... 'hobbyes': ['eat', 'sleep'],
... }
>>>
>>> d1.keys()
['username', 'age', 'hobbyes']
>>> d1.values()
['lyh', 18, ['eat', 'sleep']]
>>> d1.items()
[('username', 'lyh'), ('age', 18), ('hobbyes', ['eat', 'sleep'])]
python2中这些值都是直接打印出来，python3中生成这样一个一个小列表
'''
循环
>>> d1 = {
... 'username': 'lyh',
... 'age': 18,
... 'hobbyes': ['eat', 'sleep'],
... }
>>> for i in d1:
... print(i)
...
username
age
hobbyes
'''
参与字典循环的是key值
'''
>>> d1 = {
... 'username': 'lyh',
... 'age': 18,
... 'hobbyes': ['eat', 'sleep'],
... }
>>> for i in d1.values():
... print(i)
...
lyh
18
['eat', 'sleep']
'''
这样参与循环的只是字典的value值
'''
>>> d1 = {
... 'username': 'lyh',
... 'age': 18,
... 'hobbyes': ['eat', 'sleep'],
... }
>>> for i in d1.items():
... print(i)
...
('username', 'lyh')
('age', 18)
('hobbyes', ['eat', 'sleep'])
'''
这样参与循环的是字典的键值对，这里可以用前面学过的解压赋值的方法，用两个变量去做接收
'''
get() 方法：
>>> d1 = {
... 'username': 'lyh',
... 'age': 18,
... 'hobbyes': ['eat', 'sleep'],
... }
>>> d1.get('username')
'lyh'
>>> d1.get('sex')
>>> res = d1.get('sex')
>>> print(res)
None
>>> d1.get('username','hrj')
'lyh'
>>> d1.get('sex','男')
'男'
'''
字典的get()方法，直接字典点get('key'),如果有key则返回对应的value值，如果没有key则返回None，如果是直接按照key的方法取值，没有key则会报错。
get里面可以跟两个参数，如果key存在，不管后面跟什么只会返回字典中key对应的value值，如果key不存在，则会返回get括号里面的另外一个参数，默认其实就是None
'''
创建字典的方式
第一种：
dict({'k1':'v1','k2':'v2'})
'''
这种创建也就是解释器内部创建字典的方法
'''
第二种：
>>> dict(name = 'lyh', age = 18, sex = '男')
{'name': 'lyh', 'age': 18, 'sex': '男'}
第三种：
>>> l = [['name','lyh'],['age',18],['password',123]]
>>> dict(l)
{'name': 'lyh', 'age': 18, 'password': 123}
'''
这种方法可以通过for循环实现
d = {}
for i in l:
d[i[0]] = i[1]
d = {}
for k,v in l:
d[k] = v
'''
清空字典
>>> d1 = {
... 'username': 'lyh',
... 'age': 18,
... 'hobbyes': ['eat', 'sleep'],
... }
>>> d1.clear()
>>> d1
{}
快速生成一个字典：(fromkeys)
>>> l = ['name', 'sex', 'age',]
>>> dict.fromkeys(l,None)
{'name': None, 'sex': None, 'age': None}
popitem() --- 弹出一组键值对
>>> d1 = {
... 'username': 'lyh',
... 'age': 18,
... 'hobbyes': ['eat', 'sleep'],
... }
>>> d1.popitem()
('hobbyes', ['eat', 'sleep'])
>>> d1
{'username': 'lyh', 'age': 18}
'''
从尾部弹出一组键值对，以元组的形式返回
'''
setdefault() --- 健存在不修改，打印出字典中健对应的值，不存在则新建
>>> d1 = {
... 'username': 'lyh',
... 'age': 18,
... 'hobbyes': ['eat', 'sleep'],
... }
>>> d1.setdefault('age')
18
>>> d1.setdefault('sex','男')
'男'
>>> d1.setdefault('username','hrj')
'lyh'
>>>
'''
健存在不修改，打印出字典中健对应的值，不存在则新建
'''
updat()----更新
>>> d1 = {
... 'username': 'lyh',
... 'age': 18,
... 'hobbyes': ['eat', 'sleep'],
... }
>>> d1.update({'age':20})
>>> d1
{'username': 'lyh', 'age': 20, 'hobbyes': ['eat', 'sleep']}
>>> d1.update({'username' : 'hrj'})
>>> d1
{'username': 'hrj', 'age': 20, 'hobbyes': ['eat', 'sleep']}
'''
健存在则修改，不存在则创建
'''
元组
小括号括起来，可以存放多个任意类型的元素，用逗号隔开
元组不可变，主要是用来读
类型转换：
支持for循环的都可以转成元组(tuple)
>>> l = [1,2,3,4,]
>>> tuple(l)
(1, 2, 3, 4)
'''
元组的定义：
s1 = set()
'''
#特别注意：
>>> s1 = (1)
>>> type(s1)
<class 'int'>
>>> s1 = (1,)
>>> type(s1)
<class 'tuple'>
'''
在元组中如果只有一个值，后面必须跟逗号，负责就是其他类型，
由此得出，python中，任意容器类型定义完值后面最好跟一个逗号，以逗号结尾
'''
按索引取值：只能取，不能改，如果元组中有其他类型，则这个类型可以修改
>>> t1 = (1,2,34,5,)
>>> t1[0]
1
>>> t1[-1]
5
'''
注意：：：
>>> t1 = (1,2,3,[4,5,6],)
>>> t1[3].append(8)
>>> t1
(1, 2, 3, [4, 5, 6, 8]) # 这里可以修改，
>>> t1 = (1,2,3)
>>> t1.append(4)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'tuple' object has no attribute 'append'
>>>
'''
切片，循环，长度运算，成员运算，与列表一致
集合
大括号括起来，内部可以存放（不可变类型）的多个元素，逗号隔开
元素只能是不可变类型
适用：
关系运算
去重操作
定义： set()
>>> s1 = {}
>>> type(s1)
<class 'dict'>
>>> s1 = set()
>>> type(s1)
<class 'set'>
'''
定义一个空的集合需要用到set关键字
'''
去重操作
>>> l = [1,2,3,4,5,3,1,2,41,42,4,422,444,2,1,2,2,2,]
>>> set(l)
{1, 2, 3, 4, 5, 422, 41, 42, 444}
'''
集合可以用来去重，但是去重之后呢，顺序也就乱了，因为集合是无序的
上述操作，也可以用for循环的方式实现
'''
关系运算
>>> s1 = {1,2,3,4,0,9}
>>> s2 = {1,2,3,6,7,8}
>>> s1 & s2 交集
{1, 2, 3}
>>> s1 | s2 并集
{0, 1, 2, 3, 4, 6, 7, 8, 9}
>>> s1 - s2 差集
{0, 9, 4}
>>> s2 - s1 差集
{8, 6, 7}
>>> s1 ^ s2 并集-交集
{0, 4, 6, 7, 8, 9}
#如下所示，s2是s1的子集，s1是s2的父集
>>> s1 = {1,2,3,4,5}
>>> s2 = {1,2,3}
>>> s2 < s1
True
>>> s1 > s2
True
>>> s1 < s2
False
浙公网安备 33010602011771号