基本数据类型及部分内置方法二

基本数据类型及内置方法二

一、列表补充

• count：统计当前列表内指定元素的个数

• index：获取当前指定元素的索引值并返回，还可以指定查查找范围

l1 = ['a','b','c','d']
print(l1.index('b',0,2)

• sort:排序,在原列表进行排序操作, 排序时列表元素之间必须是相同数据类型，不可混搭，否则报错

l1 = [2,3]
l2 = [2, 1, 4, 6, 8, 3, 5, 6]
print(id(l2))
l2.sort()     # 内置参数reverse=False 表示正向排序,等于True表示反向排序
print(l2)
l2.sort(reverse=True)
print(l2)
print(id(l2))
print(l2.sort())  # 返回的是个None
print(id(l2.sort())) 
print(id(l1.sort()))
​
输出结果:
2448274641992
[1, 2, 3, 4, 5, 6, 6, 8]
[8, 6, 6, 5, 4, 3, 2, 1]
2448274641992
None
140715659705568
140715659705568
​

• sorted:python的内置函数,在排序是生成了一个新的列表,原数据不变

l2 = [2, 1, 4, 6, 8, 3, 5, 6]
l3 = sorted(l2)   # 生成的新列表,reverse依然可用
print(l2)  
print(l3)
print(id(l2))
print(id(l3))
​
​
[2, 1, 4, 6, 8, 3, 5, 6]
[1, 2, 3, 4, 5, 6, 6, 8]
2103521530440
2103521530952

注意:sort是列表的内置方法,sorted是python的内置函数

• clear():清空列表数据

l2 = [2, 1, 4, 6, 8, 3, 5, 6]
l2.clear()  #　清空列表数据．返回一个空列表
print(l2)  
​
输出结果：[]

 

补充:

队列:先进先出

l1.append(1)
l1.append(2)
l1.append(3)
l1.append(4)
print(l1)
l1.pop(0)
print(l1)
l1.pop(0)
print(l1)
l1.pop(0)
print(l1)
​
​
输出结果:
[1, 2, 3, 4]
[2, 3, 4]
[3, 4]
[4]

堆栈:先进后出

l1 = []
l1.append(1)
l1.append(2)
l1.append(3)
l1.append(4)
print(l1)
l1.pop()
print(l1)
l1.pop()
print(l1)
l1.pop()
print(l1)
​
输出结果:
[1, 2, 3, 4]
[1, 2, 3]
[1, 2]
[1]
​

==================================总结=====================================

有序，可变，存多个值

==========================================================================

二、元组

用途：元组与列表类似，也是可以存多个任意类型的元素，不同之处在于元组的元素不能修改，即元组相当于不可变的列表，用于记录多个固定不允许修改的值，单纯用于取

定义方式： 在()内用逗号分隔开多个任意类型的值 例如： countries = ("中国"，"美国"，"英国") ，本质:countries = tuple("中国"，"美国"，"英国") ，强调：如果元组内只有一个值，则必须加一个逗号，否则()就只是包含的意思而非定义元组 countries = ("中国"，) ，本质:countries = tuple("中国")

• 常用方法：

  1、索引取值（正取，反取）

  2、索引切片：print(t1[0:2])

  3、成员运算in ，not in

  4、len()

• conunt:统计指定元素出现的次数

  print(t1.count('a'))

• index:指定元素的索引位置并返回索引值

  `print(t1.index('a',0,2))

====================================总结===================================

有索引，有序、不可变、存多个值

==========================================================================

三、字典

定义：在{}内用逗号分隔开多元素，每一个元素都是key:value的形式，其中value可以是任意类型，而key则必须是不可变类型，通常key应该是str类型，因为str类型会对value有描述性的功能 。

定义方式：

• 第一种：直接定义

  d1 = {'name':'egon','age':84}

• 第二种:通过字典本质dict

d2 = dict(name = 'egon',age = 18)
​
d3 = dict([['name','egon'],('age',18)])  #　这两种dict都一样,里面的[]可以随意跟换,只要保证key和value是一一对应的关系就可以
​
​
print(d2)
print(d3)
​
​
输出结果:
{'name': 'egon', 'age': 18}
{'name': 'egon', 'age': 18}

• 第三种:通过zip(了解即可)

l1 = ['name',"age"]
l2 = ['egon',18]
z1 = zip(l1,l2)
print(type(z1))
print(z1)
print(dict(z1))
​
输出结果:
<class 'zip'>
<zip object at 0x000001A92FD513C8>
{'name': 'egon', 'age': 18}

优先掌握的:

1、按照key:value映射关系取值（可存可取）

d1 = {'name':'egon','age':84}
​
print(d1['name'])     

2、成员运算in，not in # 默认判断key ,返回值是True或False

d1 = {'name':'egon','age':84}
print('name' in d1)
​
输出结果:
    true

 

3、len() # 获取当前字典中键值对的个数

d1 = {'name':'egon','age':84}
print(len(d1))
​
输出结果:2
​

*内置方法:

• get:获取指定key的值,如果key不存在,默认返回None,可以通过第二个参数来修改返回的内容

d1 = {'name':'sean','age' : 18}
print(d1.get('name'))
print(d1.get('gender'))  #　默认返回None
print(d1.get('gender','***'))
# 修改默认返回值为***
输出结果:
sean
None
***

• setdefault:指定key不存在则将此key和值作为新增键值对添加到字典里,有返回值,返回新增的值,指定key如果存在则返回对应的value

d1 = {'name':'egon', 'age': 73,'gender':'male','a':"1"}
​
print(d1.setdefault('b',333))  # 表示指定的key和新增的值
print(d1)  
​
​
输出的结果:
    333  # 返回新增的值  
{'name': 'egon', 'age': 73, 'gender': 'male', 'a': '1', 'b': 333}  # 将新增的键值对添加进去
​
​
d1 = {'name':'egon', 'age': 73,'gender':'male','a':"1"}
​
print(d1.setdefault('name',333))# 表示指定key和新增的值
print(d1)
​
​
输出的结果:
    egon   # 有此key则返回此key原来对应的值
{'name': 'egon', 'age': 73, 'gender': 'male', 'a': '1'} # 字典不变
​
​

 

• keys:返回所有的key

d1 = {'name':'sean','age' : 18,'gender':'male'}
print(d1.keys())
print(type(d1.keys()))
​
输出结果:
dict_keys(['name', 'age','gender'])
<class 'dict_keys'>

可以通过for循环将key全部拿出来

for i   in d1.keys()
print(i)

• valus:返回所有的value

d1 = {'name':'sean','age' : 18,'gender':'male'}
print(d1.values())
print(type(d1.values()))
​
输出结果:
dict_values(['sean', 18, 'male'])
<class 'dict_values'>

• items:返回所有的键值对

d1 = {'name':'sean','age' : 18,'gender':'male'}
​
print(d1.items())
print(type(d1.items()))
​
输出结果:
    dict_items([('name', 'sean'), ('age', 18), ('gender', 'male')])
<class 'dict_items'>

• pop():删除指定key值对应的键值对,并可以返回所删除的键值对里面的值

d1 = {'name':'egon', 'age': 73}
a = d1.pop('age')
print(d1)
print(a)
​
输出结果:{'name': 'egon'}
        73
​

• popitem() :随机删除一个键值对，并且将键值对返回成元组

d1 = {'name':'egon', 'age': 73,'gender':'male','a':"1"}
d2 = d1.popitem()
print(d1)
print(d2)
print(type(d2))
​
输出结果:
{'name': 'egon', 'age': 73,'gender': 'male'}
('a', '1')
<class 'tuple'>
    

• update:用新字典替换旧字典,有则修改,无则添加

d1 = {'name':'egon', 'age': 73,'gender':'male','a':"1"}
d1.update({"b":'2'})
print(d1)   #　没有则添加这一对键值对
print(id(d1))
d1.update({'name':'tank'})
print(d1)　　　# 有则修改此键值对
print(id(d1))
​
输出结果:
{'name': 'egon', 'age': 73, 'gender': 'male', 'a': '1', 'b': '2'}
2517832581016
{'name': 'tank', 'age': 73, 'gender': 'male', 'a': '1', 'b': '2'}
2517832581016
​

• fromkeys:生成一个新字典,第一个参数为列表或者元组,因为列表中的元素会成为新字典中的key,第二个参数整体为值,值是都一样的

d1 = dict.fromkeys(('key1','key2'),[3,4])
print(type(d1))
print(d1)
​
​
输出结果:
<class 'dict'>
{'key1': [3, 4], 'key2': [3, 4]}

=============================总结====================================

无序,可变,存多个值

====================================================================

四、集合

用途：去重，关系运算

定义：在{}内用逗号分隔开多个元素，集合具备以下三个特点：

1：每个元素必须是不可变类型

2：集合内没有重复的元素

3：集合内元素无序

s = {1,2,3,4} # 本质 s = set({1,2,3,4})

空集合：用set{}定义

注意1：列表类型是索引对应值，字典是key对应值，均可以取得单个指定的值，而集合类型既没有索引也没有key与值对应，所以无法取得单个的值，而且对于集合来说，主要用于去重与关系元素，根本没有取出单个指定值这种需求。

注意:但凡能被for循环的遍历的数据类型（强调：遍历出的每一个值都必须为不可变类型）都可以传给set()转换成集合类型

print(set([1, 2, 3, 4]))
​
print(set((1, 2, 3, 4)))
​
print(set({'name':'jason',}))
​
print(set('egon'))
​
输出结果:
{1, 2, 3, 4}
{1, 2, 3, 4}
{'name'}
{'n', 'o', 'g', 'e'}
​

 

关系运算:

friends1 = {"zero","kevin","jason","egon"} # 用户1的好友们

friends2 = {"Jy","ricky","jason","egon"} # 用户2的好友们

1.合集(|)：求两个用户所有的好友（重复好友只留一个）

print(friends1 | friends2 )

{'kevin', 'ricky', 'zero', 'jason', 'Jy', 'egon'}

2.交集(&)：求两个用户的共同好友

print( friends1 & friends2 )

{'jason', 'egon'}

3.差集(-)：

print(friends1 - friends2 ) # 求用户1独有的好友

{'kevin', 'zero'}

print(friends2 - friends1) # 求用户2独有的好友

{'ricky', 'Jy'}

4.对称差集(^) # 求两个用户独有的好友们（即去掉共有的好友）

print(friends1 ^ friends2 )

{'kevin', 'zero', 'ricky', 'Jy'}

5.值是否相等(==)

print(friends1 == friends2 )

False

6.父集：一个集合是否包含另外一个集合

6.1 包含则返回True

print({1,2,3} > {1,2} )

True

print({1,2,3} >= {1,2} )

True

6.2 不存在包含关系，则返回True

print({1,2,3} > {1,3,4,5} )

False

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

False

7.子集

print({1,2} < {1,2,3} )

True

print({1,2} <= {1,2,3})

True

去重:

集合去重复有局限性

# 1. 只能针对不可变类型
# 2. 集合本身是无序的，去重之后无法保留原来的顺序

l=['a','b',1,'a','a']  
​
s=set(l)  
​
print(s)   # 将列表转成了集合 
​
{'b', 'a', 1}  
​
l_new=list(s) # 再将集合转回列表
​
print( l_new )
​
['b', 'a', 1]    # 去除了重复，但是打乱了顺序 
​
# 针对不可变类型，并且保证顺序则需要我们自己写代码实现，例如 
​
l=[{'name':'lili','age':18,'sex':'male'}, {'name':'jack','age':73,'sex':'male'},   {'name':'tom','age':20,'sex':'female'}, {'name':'lili','age':18,'sex':'male'},   {'name':'lili','age':18,'sex':'male'}, ] 
​
new_l=[] 
for dic in l:   
    if dic not in new_l:        
        new_l.append(dic) 
print(new_l)   # 结果：既去除了重复，又保证了顺序，而且是针对不可变类型的去重 
[{'age': 18, 'sex': 'male', 'name': 'lili'},{'age': 73, 'sex': 'male', 'name': 'jack'}, {'age': 20, 'sex': 'female', 'name': 'tom'} ] 

其他操作

# 1.长度
>>> s={'a','b','c'}
>>> len(s)
3
​
# 2.成员运算
>>> 'c' in s
True
​
# 3.循环
>>> for item in s:
...     print(item)

总结:无序,可变,存多个值