python基础数据类型列表、元祖、字典、集合

列表

列表是有序的，可被修改的，可迭代的，用中括号括起来，用，分割每个元素，列表中的元素可以是任意类型。

列表中可以嵌套任何类型

for循环列表下标时

l = ['a', 'b','c','d']
for i in l:
    print(i)
for i,item in enumerate(l): #需要循环输出列表下标时
    print(i,item)

列表的常见方法

1.添加元素 insert  apppend  extend

>>> li = [1,2,3]
>>> li.append(4)
>>> li
[1, 2, 3, 4]
>>> li.insert(0,0)
>>> li
[0, 1, 2, 3, 4]
>>> li.extend([5,6,7]) #extend需要添加一个可迭代对象
>>> li
[0, 1, 2, 3, 4, 5, 6, 7]
>>>

 

2.删除元素 del  clear pop  remove

>>> li = [0, 1, 2, 3, 4, 5, 6, 7]
>>> li.pop()  #删除最后一个元素
7
>>> li
[0, 1, 2, 3, 4, 5, 6]
>>> li.remove(3) #根据元素的值进行删除
>>> li
[0, 1, 2, 4, 5, 6]
>>> del li[2:4] #根据下标进行删除
>>> li
[0, 1, 5, 6]
>>> li.clear()  #清空列表元素
>>> li
[]
>>>

 

3.修改元素 下标

>>> li = [0, 1, 2, 3, 4, 5, 6, 7]
>>> li[3] = 'a'
>>> li
[0, 1, 2, 'a', 4, 5, 6, 7]
>>>

 

4.查找元素 in  not in  index  count

>>> li = [0, 1, 2, 3, 4, 5, 6, 7]
>>> 3 in li  #（存在）,如果存在那么结果为true，否则为false
True
>>> 4 not in li  #not in（不存在），如果不存在那么结果为true，否则false
False
>>> li.index(4)  #如果存在返回列表中下标的位置，不存在则报错
4
>>> li.count(5)  #统计出现的次数
1
>>> li.index(9)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: 9 is not in list
>>> li.count(9)
0
>>>

 

5.复制 copy 

>>> li = [0, 1, 2, 3, 4, 5, 6, 7]
>>> m = li.copy()
>>> m
[0, 1, 2, 3, 4, 5, 6, 7]
>>>

 

6.排序 sort   reverse

>>> li = [4,7,2,9,1,0,44]
>>> li.sort()   # sort(reverse=True)从大到小排序
>>> li
[0, 1, 2, 4, 7, 9, 44]
>>> li.reverse()
>>> li
[44, 9, 7, 4, 2, 1, 0]
>>>

 

元祖

Python的元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号，列表使用方括号。

元组的一级元素不可修改/删除/增加

>>> tu1 = (1,2,['a','b','c'],3,4)
>>> tu1[2][0] = 'd'
>>> tu1
(1, 2, ['d', 'b', 'c'], 3, 4)
>>>

元祖的常用操作

元素查找

>>> tu = (1,2,['a','b','c'],3,4)
>>> 1 in tu
True
>>> 2 not in tu
False
>>> tu.index(4)
4
>>> tu.count(3)
1
>>>

 

字典

 

• 字典是无序的，可修改的；每个元素由2部分组成，键:值。例如 'name':'班长' ,'name'为键，'班长'为值
• 字典中找某个元素时，是根据'名字'（就是冒号:前面的那个值，例如上面代码中的'name'、'id'、'sex'）
• 字典的value可以是任何数据类型的值；字典的键可以是 ‘数字’，‘字符串’，‘元祖’，‘布尔值’，

 

字典的常用操作

1.查找 键，get  items  keys  values

 

>>> dic = {'name':'fwl','age':29,'sex':'man'}
>>> dic['name']  #通过键获取值，如果值不存在则会报错
'fwl'
>>> dic['name1']
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'name1'
>>> dic.get('name') #通过键获取值，如果值不存在，不会报错，同时可以指定默认值，不存在会返回默认值
'fwl'
>>> dic.get('name1')
>>> dic.get('name1','aaa')
'aaa'
>>>
>>> dic.keys()  #获取字典的所有键
dict_keys(['name', 'age', 'sex'])
>>> dic.values()
dict_values(['fwl', 29, 'man']) #获取字典的值
>>> dic.items()
dict_items([('name', 'fwl'), ('age', 29), ('sex', 'man')]) #获取字典的键值
>>>

 

2.复制

>>> dic
{'name': 'fwl', 'age': 29, 'sex': 'man'}
>>> m_dic = dic.copy()
>>> m_dic
{'name': 'fwl', 'age': 29, 'sex': 'man'}
>>>

3.设置/更新  fromkeys setdefault   update

>>> d_dic = dict.fromkeys(['a1','a2']) #根据序列，创建字典，并指定统一的值
>>> d_dic
{'a1': None, 'a2': None}
>>> d_dic = dict.fromkeys(['a1','a2'],33)
>>> d_dic
{'a1': 33, 'a2': 33}
>>> d_dic.setdefault('a1') # 已存在，不设置，获取当前key对应的值；不存在，设置，获取当前key对应的值
33
>>> d_dic
{'a1': 33, 'a2': 33}
>>> d_dic.setdefault('a1','mmmm')
33
>>> d_dic
{'a1': 33, 'a2': 33}
>>> d_dic.setdefault('a122','mmmm')
'mmmm'
>>> d_dic
{'a1': 33, 'a2': 33, 'a122': 'mmmm'}
>>> d_dic.update({'a122':'ddd'})  #更新
>>> d_dic
{'a1': 33, 'a2': 33, 'a122': 'ddd'}
>>>

4.删除 del pop  popitem  clear

>>> dic = {'a1': 33, 'a2': 33, 'a122': 'ddd'}
>>> dic.pop('a222')  #通过键删除，如果键不存在，则会报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'a222'
>>> dic.pop('a1')
33
>>> dic
{'a2': 33, 'a122': 'ddd'}
>>> del dic['a2']  #删除指定键的元素
>>> dic
{'a122': 'ddd'}
>>> dic = {'a1': 33, 'a2': 33, 'a122': 'ddd'}
>>> dic.popitem()  #随机删除某一对键值对
('a122', 'ddd')
>>> dic
{'a1': 33, 'a2': 33}
>>> dic.clear()  #清空
>>> dic
{}
>>>

 

集合

 定义：由不同元素组成的集合，集合中是一组无序排列的可hash值，可以作为字典的key特性：

集合的目的是将不同的值存放到一起，不同的集合间用来做关系运算，无需纠结于集合中单个值

集合的创建

定义可变集合set
>>> set_test=set('hello')
>>> set_test
{'l', 'o', 'e', 'h'}
改为不可变集合frozenset
>>> f_set_test=frozenset(set_test)
>>> f_set_test
frozenset({'l', 'e', 'h', 'o'})

可变集合的常见操作

1.添加 add update

>>> s = set('hello')
>>> s.add('m')
>>> s
{'e', 'h', 'm', 'l', 'o'}
>>> s.update('world')
>>> s
{'e', 'r', 'h', 'm', 'w', 'l', 'd', 'o'}
>>>

2.复制

>>> s
{'e', 'r', 'h', 'm', 'w', 'l', 'd', 'o'}
>>> m = s.copy()
>>> m
{'r', 'd', 'o', 'e', 'h', 'm', 'w', 'l'}
>>>

3.删除 pop clear remove discard

>>> s = set('hello')
>>> s
{'h', 'l', 'o', 'e'}
>>> s.pop()  #随机删除
'h'
>>> s
{'l', 'o', 'e'}
>>> s.remove('e')  ##删除元素不存在会报错
>>> s
{'l', 'o'}
>>> s.discard('dd') ##删除元素不存在不会报错
>>> s
{'l', 'o'}
>>> s.discard('o')
>>> s
{'l'}
>>> s.clear() #清空
>>> s
set()
>>>

4.交集、并集、差集、交叉补集 intersection union  difference symmetric_difference  difference_update intersection_update

#交集
>>> python_l=['lcg','szw','zjw','lcg']
>>> linux_l=['lcg','szw','sb']
>>> p_s=set(python_l)
>>> l_s=set(linux_l)
>>> print(p_s,l_s)
{'szw', 'lcg', 'zjw'} {'szw', 'sb', 'lcg'}
>>> p_s.intersection(l_s)  #两个集合的交集
{'lcg', 'szw'}
>>> p_s&l_s   #两个集合的交集简写
{'lcg', 'szw'}
>>> p_s.intersection_update(l_s)  #找到p_s在l_s中存在的元素并重新复制给ps
>>> p_s
{'lcg', 'szw'}
>>>
####并集
>>> python_l=['lcg','szw','zjw','lg']
>>> linux_l=['lcg','szw','sb']
>>> p_s=set(python_l)
>>> l_s=set(linux_l)
>>> p_s.union(l_s)
{'lg', 'sb', 'lcg', 'szw', 'zjw'}
>>> p_s|l_s  #并集的简写
{'lg', 'sb', 'lcg', 'szw', 'zjw'}
>>>
###差集
>>> python_l=['lcg','szw','zjw','lg']
>>> linux_l=['lcg','szw','sb']
>>> p_s=set(python_l)
>>> l_s=set(linux_l)
>>> p_s.difference(l_s)
{'lg', 'zjw'}
>>> p_s-l_s
{'lg', 'zjw'}
>>> p_s.difference_update(l_s)  #求p_s对l_s差集，并将结果赋值给p_s
>>> p_s
{'lg', 'zjw'}
>>>
###交叉补集
>>> python_l=['lcg','szw','zjw','lg']
>>> linux_l=['lcg','szw','sb']
>>> p_s=set(python_l)
>>> l_s=set(linux_l)
>>> p_s.symmetric_difference(l_s)
{'lg', 'sb', 'zjw'}
>>> p_s^l_s
{'lg', 'sb', 'zjw'}
>>>

 5.判断集合关系  issuperset issubset isdisjoint

>>> s1 = {1,2}
>>> s2 = {1,2,3}
>>> s1.isdisjoint(s2)
False
>>> s1.issubset(s2)  #s1是s2的子集
True
>>> s2.issubset(s1)
False
>>> s2.issuperset(s1)  #s2是s1的父集
True
>>> s1 = { 1,2}
>>> s2 = { 2,3,4 }
>>> s1.isdisjoint(s2)
False
>>> s3 = { 4,5,6 }
>>> s1.isdisjoint(s3)  ##s1和s3没有交集
True
>>>