Python第五课(数据类型2)

Python第五课(数据类型2)    >>>转到思维导图>>>转到中二青年

列表list

count()用来统计列表某个元素的个数

>>> l = [1,2,3,4,5,6,7]
>>> res = l.count(8)
>>> print(res)
0

clear()用来清除列表元素

>>> res = l.clear()
>>> print(res)
None
>>> print(l)
[]

reverse()用来将列表反转

>>> l = [1,2,3,4,5,6,7]
>>> print(id(l))
2271674158920
>>> l.reverse()
>>> print(l)
[7, 6, 5, 4, 3, 2, 1]
>>> print(id(l))
2271674158920

sort()按升序将列表元素排序

>>> l.sort()
>>> print(l)
[1, 2, 3, 4, 5, 6, 7]
>>> print(id(l))
2271674158920

队列：先进先出

堆栈：先进后出

能存多个值，有序，可变

元组tuple

作用：能够存储多个元素，元素与元素之间逗号隔开，元素可以是任意类型，元组不能被修改

定义：在()内用逗号分隔开多个任意类型的值。与列表类型比，只不过吧[ ]换成了( )

在定义容器类型的时候，哪怕内部只有一个元素，也要用逗号隔开区分一下

list[0]按索引取值

>>> t = (1, 2, 3, 'a', 'b', [1, 2, 3])
>>> print(t[0])
1
>>> print(t[1])
2
>>> print(t[-1])
[1, 2, 3]
>>> print(t[-1][0])
1
>>> t[-1][0] = '我改了'
>>> print(t)
(1, 2, 3, 'a', 'b', ['我改了', 2, 3])

list[::2]切片(顾头不顾尾，步长)

>>> print(t[::2])
(1, 3, 'b')

len()长度

>>> print(len(t))
6

in和not in成员运算

>>> print('a' in t)
True

循环

for i in t:
    print(i)

能存多个值，有序，不可变

字典dict

作用：记录多个值，每一个值都对应的key用来描述value的作用。

定义：在{}内用逗号分隔开多 个key:value，其中value可以是任意类型，而key必须是不可变的类型，通常情况下应该str类型

d = {'name':'jason','password':123}  # d = dict( {'name':'jason','password':123})

字典的key是不能重复的。要唯一表示一条数据。如果重复了，只会按照最后一组城府的键值对存储

dict['key']='value'安key存取值：可存可取。当key不存在的情况下，会自动新增一个键值对

>>> d3 = {'name':'jason','password':'123'}
>>> print(id(d3))
2052650650072
>>> print(d3['name'])
jason
>>> d3['age'] = 18
>>> print(d3,id(d3))
{'name': 'jason', 'password': '123', 'age': 18} 2052650650072

len()统计键值对的个数

>>> print(len(d3))
3

in和not in成员运算，对于字典来说只能判断key值

>>> d3 = {'name':'jason','password':'123'}
>>> print('123' in d3)
False
>>> print('name' in d3)
True

del dict['key']删除键值对

>>> d3 = {'name':'jason','password':'123'}
>>> del d3['name']
>>> print(d3)
{'password': '123'}

dict.pop('key')弹出的仅仅是value。当键不存在的时候直接报错

>>> d3 = {'name':'jason','password':'123'}
>>> res = d3.pop('name')
>>> res = d3.pop('age')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'age'
>>> print(res)
jason
>>> print(d3)
{'password': '123'}
>>> d3.clear()
>>> print(d3)
{}

print(dict.keys())  # dict_keys(['key1', 'key2'])

>>> d1 = {'name':'jason','password':123}
>>> print(d1.keys())
dict_keys(['name', 'password'])
>>> for k in d1.keys():
...     print(k)
...
name
password

print(dict.values())  # dict_values(['value1', 'value2'])现在看做一个列表即可

>>> print(d1.values())
dict_values(['jason', 123])

print(dict.items())  # dict_items([('key1', 'key2'), ('value1', 'value2')])把他看做是列表套元组，元组的第一个元素是字典的key，第二个元素是字典的value

>>> print(d1.items())
dict_items([('name', 'jason'), ('password', 123)])

dict.get('key','自定义返回值')根据key获取value。当key在字典中时返回对应的value；当key不在字典中时，不报错，默认返回none，也可自定义返回值。

>>> d1 = {'name':'jason','pwd':123}
>>> print(d1['name'])
jason
>>> print(d1['age'])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'age'
>>> print(d1.get('name','你给我的name在字典的key中'))
jason
>>> res = d1.get('age')
>>> res1 = d1.get('xxx','你给我的age在字典的key中')
>>> print(res1)
你给我的age在字典的key中
>>> print(d1.get('xxx','asdsad'))
asdsad

list=['key1','key2'] # print(dict.fromkeys(list,'value')) # {'key1':'value','key2':'value'} # 快速创建一个字典

>>> l1 = ['name','password','age','hobby']
>>> print(dict.fromkeys(l1,123))
{'name': 123, 'password': 123, 'age': 123, 'hobby': 123}

dict.popitem()尾部以元组的形式弹出键值对

>>> print(d1.popitem())
('age', 18)

dict.setdefault('key1','value2') # 当键存在的情况下，返回对应值'value1'；当键不存在的情况下，新增键值对'key1','value2',并且将新增的键值对的值'value2'返回给你。

>>> d1 = {'name':'jason','pwd':123}
>>> res1 = d1.setdefault('name','xxoo')
>>> print(d1,res1)
{'name': 'jason', 'pwd': 123} jason
>>> res2 = d1.setdefault('age',18)
>>> print(d1,res2)
{'name': 'jason', 'pwd': 123, 'age': 18} 18

dict.update()

>>> d1 = {'name':'jason','pwd':123}
>>> d2 = {"age":18}
>>> d1.update(d2)
>>> print(d1)
{'name': 'jason', 'pwd': 123, 'age': 18}
>>> d1['age'] = 19
>>> print(d1)
{'name': 'jason', 'pwd': 123, 'age': 19}
>>> d1.update(age=666)
>>> print(d1)
{'name': 'jason', 'pwd': 123, 'age': 666}

存多个值，无序，可变

集合set

作用：去重，关系运算

定义：在{ }内用逗号分开的多个值，在定义空集合的时候只能用关键字set(),如果只写了一个大括号，python默认将他当做字典类型

>>> s = {1,2,3,4,5,6}
>>> print(type(s))
<class 'set'>
>>> s1 = set()
>>> print(type(s1))
<class 'set'>
>>> x = {}
>>> print(type(x))
<class 'dict'>
>>> t = ()
>>> print(type(t))
<class 'tuple'>
>>> d = {[1,2]:'name'}
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

集合三大特性：1.每个值都必须是不可变类型；2.元素不能重复；3.集合内元素无序

# s = {1,2,3,4,5,6,'a',(1,2),[1,2]}  # 报错
# s = {1,2,3,4,5,6,'a',(1,2),{"name":'jason'}}  # 报错
>>> s = {1,2,2,2,2,2,2,2,2,2,3,4,4,4,4,4,5}
>>> print(s)  # 自动将重复的元素 去除
{1, 2, 3, 4, 5}
>>> s = {1, 2, 3, 4, 5, 6}
>>> print(s[1])
# 注意集合的目的是将不同的值存放到一起，不同的集合间用来做关系运算，无需纠结于集合中单个值

|合集

&交集

-差集

^对称差集

==是否相等

>=父集：一个集合是包含另外一个集合

<=子集

pythons = {'jason', 'nick', 'tank', 'egon', 'kevin', 'owen', 'alex'}
linux = {'frank', 'jerry', 'tank', 'egon', 'alex'}
# 既报名python也报名linux的学生姓名
print(pythons & linux)  # 交集
 
# 只报名python的学生姓名
print(pythons - linux)
 
# 只报名linux的学生姓名
print(linux - pythons)
 
# 没有同时报名两门课程的学生姓名
print(pythons ^ linux)  # 对称差集
 
# 取出所有报了名的学生姓名
print(pythons | linux)

set.update({1,2,3})将集合并入得到合集

>>> s1={1,2,3}
>>> s1.update({3,4,5})
>>> print(s1)
{1, 2, 3, 4, 5}

set.pop()随机弹出一个元素

>>> s1={1,2,3}
>>> res=s1.pop()
>>> print(res)
1
>>> print(s1)
{2, 3}

set.remove(3) # 单纯的删除,返回值为None

>>> s1={1,2,3}
>>> res=s1.remove(3)
>>> print(res)
None
>>> print(s1)
{1, 2}

set.discard(4) # 删除的元素不存在会报错

>>> s1={1,2,3}
>>> res=s1.discard(3)
>>> print(s1)
{1, 2}
>>> print(res) ##单纯的删除,返回值为None
None
>>> s1.remove(444444) #删除的元素不存在则报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 444444
>>> s1.discard(444444) #删除的元素不存在不会报错

set.add(('tuple',))将容器类型也当成一个元素传入

>>> s1={1,2,3}
>>> s1.add(4)
>>> print(s1)
{1, 2, 3, 4}

END