基础数据类型 二

Posted 2022-01-04 banshannongchang

列表 list

list [ ] 多个元素,每个元素用逗号隔开

1.定义形式

#定义方式一  常用方式
list_1 = [1,2,'a','b','c',"asdasawsd",汉字,[12,'now',端午]]    #[a]也是列表
#定义方式二 
list_2 = list("ab13")
print(list_2)        #底层使用的for循环    "ab13"为可迭代字符串类型  
# 得到列表['a','b',1,3] 

2.特点

可存储大量数据,字符串自能存储少量数据,列表中存储类型是多样的,任意数据类型都可存放.

有序 即可以索引和切片

可变的 对列表的操作可改变原列表,而字符串不可变

3 列表的索引 切片

列表内以逗号为区分为每一个元素,从左至右索引为0,1,2,3....,从右至左索引为-1,-2,-3,-4....

切片

L1 = [1,2,3,'a','b','edx']
print(L1[1:5:2])  #列表切片后还是列表,[1:5:2]第一个数位置为起始索引位置,第二个为终止索引位置,第三个为间隔
# 得到结果 [2, 'a']

4 列表的增删改

增

1.append 追加 添加在末尾

L1 = [1,2,3,'a','b']
L1.append('c')   #注意这里对L1的操作不会有返回值,只是改变的L1  因此直接print(L1.append('c'))是空值
print(L1)

2.insert(,) 插入 括号前半部分为要插入位置的索引号 后边为插入内容

L1 = [1,2,3,'a','b']
L1.insert(2,'A')    # 效率较低   插入索引为记号,插入的内容就位于记号索引位
print(L1)

3.extend 扩展 迭代添加 可迭代对象都可加入

L1 = [1,2,3,'a','b']
L1.extend('cde')      #迭代添加本质添加了如下过程:   for i in 'cde'
print(L1)             #                             L1.append(i)
#结果  [1, 2, 3, 'a', 'b', 'c', 'd', 'e']

4.列表合并

L2 = [1,2,3]
L3 = ["a","b","c"]
L4 = L2+L3
print(L4)

删

1.pop() 弹出 默认删除最后一个也可指定索引位 有返回值 返回被删除内容(对列表的操作唯一有返回值的)

li = [1,2,3,"abc",True]   
print(li.pop(3))   # 输出 abc   返回值
print(li)          # 输出  [1, 2, 3, True]  操作后li结果

2.clear 清空

li = [1,2,3,"abc",True] 
li.clear()
print(li)

3.remove 按元素名删除

li = [1,2,3,"abc",True] 
li.remove(2)
print(li)   >>>  [1, 3, 'abc', True]  #按元素名从左到右删一个

4.del

 li = [1,2,3,"abc",True] 
 del li      #删除整个列表
 del li[2]   #删除指定元素 按索引
 del li[1:3] #删除区间
 del li[1:5:2]  #删除间隔的内容

改

1.通过索引改

li = [1,2,3,"abc",True] 
li[-1] = 'fg'  # 换什么就是什么且位于输入的索引号位置

2.通过切片改

li = [1,2,3,"abc",True] 
li[1:3] = "qwo" ==>>  #迭代  输出 [1, 'q', 'w', 'o', 'abc', True]
li[1:3] = "1"           #  [1, '1', 'abc', True]        
li[1:3] = []               # 切片的时候可以多,可以少,可以指定空值

3.通过间隔切片改

li = [1,2,3,"abc",True]    #去几个放几个
li[1:4:2] = '今天'   ==>>  #  迭代 
li[1:4:2] = 1,21     #可以自己指定,元素之间由逗号隔开

查

索引,切片,for循环

a,b = [1,23],[3,45]
print(a,b)  ==>>>[1, 23] [3, 45]

列表的嵌套

li = [1,2,3,"abc",True,[5,6,['ss'],7]] 
print(li[5][2][0])   #嵌套下的查找"ss"

元组 tuple

    2.1 定义 ()内每个元素都已逗号隔开      tuple  
 tu = (1,2,34) # 元组类型

 tu = ()       #元组类型

 tu = (1)      #括号中元素本身类型   

 tu = (1,)     #元组类型

特点

元组有序 可索引 可切片

元组不可改变数据类型,元组只能查看不能修改

可存储任意数据类型,一般存储一些不修改的数据,用于配置文件,防误修改等

查看

for循环也可查询

index 通过元素找索引,找到第一个符合值就返回结果,没有就报错.

tu = ('太白', [1, 2, 3, ], 'WuSir', '女神')
print(tu.index('太白'))  #  0 

字典

列表的缺点:

1.列表可存储大量数据类型,但数据量大后查询慢

2.列表只能按顺序存储,数据之间关联性不强

为解决这些缺点,引入字典(dict)数据类型

不可变（可哈希）的数据类型：int，str，bool，tuple。

可变（不可哈希）的数据类型：list，dict，set。

字典是python中的映射类型,它以括起来,里边的内容以键值对形式存储."key":"value" 即"键":"值"

key(键):不可变(可哈希)的数据类型.并且是唯一的,不重复的

value(值): 任意数据

字典特点:

无序的(在python3.5及之前版本,字典是无序的,随机显示.在3.6版本之后.字典会按初建字典时的顺序排列.

查询速度快,内存消耗大.

存储大量数据

能将数据关联

字典创建方式:

dic = dict((('one', 1),('two', 2),('three', 3)))
dic = dict([('one', 1),('two', 2),('three', 3)])
print(dic)  # 'one': 1, 'two': 2, 'three': 3

dic = dict(one=1,two=2,three=3)
print(dic) # 'one': 1, 'two': 2, 'three': 3

dic = dict('one':1,'two':2,'three':3)
print(dic)  #'one':1,'two':2,'three':3

字典的常用操作

增

1.通过键值直接增加 dic["键"] = "值"

dic = 'name': '太白', 'age': 18
dic['weight'] = 108  #没有weight这个键,就增加键值 如有键则改值
print(dic)  #'name': '太白', 'age': 18, 'weight': 108

2.setdefault(‘键‘,值)

dic = 'name': '太白', 'age': 18
dic.setdefault('height',175)  #没有键则添加,**有键则不变**
print(dic)  # 'name': '太白', 'age': 18, 'height': 175
#它有返回值
dic = 'name': '太白', 'age': 18
ret = dic.setdefault('weight',108)
print(ret)         # 108

删

1.pop 通过key删除字典的键值对,有返回值,可设置返回值

dic = 'name': '太白', 'age': 18
ret = dic.pop('name')
print(ret,dic)  #太白 'age':18
ret = dic.pop('n',None)  # None  为找不到键时的返回值
print(ret,dic)   #None 'name': '太白', 'age': 18  

2.del

dic = 'name': '太白', 'age': 18
del dic  #删除整个字典
del dic['name'] #删除指定键值对

3.clear 清空字典

dic = 'name': '太白', 'age': 18
dic.clear()
print(dic)   # 

4.popitem 3.5版本及之前,popitem为随机删除,3.6及之后为删除最后一个,有返回值

dic = 'name': '太白', 'age': 18
ret = dic.popitem()
print(ret,dic)  #('age', 18) 'name': '太白'

改

1.通过键值改

dic = 'name': '太白', 'age': 18
dic['name'] = '大木'
print(dic)    # 'name': '大木', 'age': 18

2.update() (update括号里的字典级别高,会覆盖同键的)

dic = 'name': '太白', 'age': 18
dic.update('name':'大木','weight':108)
# dic.update(name='大木',weight=108)  **注意此时的key不叫''
# dic.update([('name','大木'),('weight',108)])
print(dic)   #  'name': '大木', 'age': 18, 'weight': 108

查

字典的查询只能通过键获取值,不能通过值获取键

1.通过键查看和通过get查看

dic = 1:2,"a":"a1"
print(dic[1])  # 如果有键在就返回键对应的值,弱国不在就报错
print(dic.get(1,'没有此键')) #有键返回对应键值,没有返回指定内容,不会报错

2.dic.setdefault(‘键‘) 也是通过键查看

其他

dic = 1:2,"a":"a1"
for i in dic:     # for循环字典的时候打印的时字典的键 
    print(i,dic[i],end=' ') # 1 2 a a1 

dic = 1:2,"a":"a1",3:4,5:6
key_list = dic.keys()
print(key_list)    #dict_keys([1, 'a', 3, 5])  一个高仿列表,存放的都是字典的key(键).它无序但可fo循环打印
print(list(key_list))   # 这个高仿列表可转换为列表 

dic = 1:2,"a":"a1",3:4,5:6
values_list = dic.values() #dict_values([2, 'a1', 4, 6]) 一个高仿列表,存放的都是字典的value(值).它无序但可fo循环打印
print(values_list)
print(list(values_list)) #可转换为列表

dic = 1:2,"a":"a1",3:4,5:6
key_volues_list = dic.items()
print(key_volues_list) # dict_items([(1, 2), ('a', 'a1'), (3, 4), (5, 6)])  
# 一个高仿列表,存放是多个元祖,元祖中第一个是字典中的键,第二个是字典中的值  无序可for循环打印
print(list(key_volues_list))  #并且这个高仿的列表可以转化成列表

分别赋值 拆包

a,b = 1,2
print(a,b)   #1 2
a,b = ('你好','世界')  # 这个用专业名词就叫做元组的拆包
print(a,b)   #你好 世界
a,b = ['你好','大飞哥']
print(a,b)   #  你好 大飞哥
a,b = '汪峰':'北京北京','王菲':'天后'
print(a,b)  # 汪峰 王菲
dic = "1":1,"2":2,"3":3,"4":4
for k,v in dic.items():
     print(k,v)    # 结果  1 1 2 2 3 3 4 4 

解构

a = 1 
b = 2 
print("is a",id(a)) #  显示a在内存中的id
print("is b",id(b)) #  显示b在内存中的id
a,b = b,a
print("is a",id(a)) #  显示a在内存中的id    
print("is b",id(b)) #  显示b在内存中的id  
print(a,b)      # 结果 2 1    通过观察变量id的变换可知转换本质时交换了内存地址的指向
a,_,c = '你好啊'
print(a,c)  # 你 啊   

字典嵌套

dic = 
    'name':'汪峰',
    'age':48,
    'wife':['name':'国际章','age':38],
    'children':'girl_first':'小苹果','girl_second':'小怡','girl_three':'顶顶'

name = dic['name']
print(name)   #1. 获取汪峰的名字。
di = dic['wife'][0]['name']
print(di)    #3. 获取汪峰妻子的名字。
name = dic['children']['girl_three']
print(name)  #获取第三个孩子的名字.

enumerate：

枚举，对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值。

li = ['name','李白','age',18,'sex','man']
for i in enumerate(li):
    print(i)
for index,name in enumerate(li,1):
    print(index,name)
for index, name in enumerate(li, 100):  # 起始位置默认是0，可更改
    print(index, name)　　

集合

set

集合特点:集合中的元素可哈希(不可变)且不重复的

? 集合本身时不可哈希的(可变),集合是无序的

?

集合常用于去重复,如把一个列表变为集合就自动去重了

li = [1,2,3,4,2,11,3,5,6,3,4,8,3,2,1,5,6]
l2 = list(set(li))    
print(l2)       #  [1, 2, 3, 4, 5, 6, 8, 11]
 

集合的操作

增

update 迭代添加

s = 1,2,3,"123",False,(1,2,3,4)
s.update('123')
print(s)   #False, 1, 2, 3, (1, 2, 3, 4), '123', '2', '3', '1'

add

s = 1,2,3,"123",False,(1,2,3,4)
s.add("abc")
print(s)   #False, 1, 2, 3, (1, 2, 3, 4), '123', 'abc'

删

remove 指定元素删除

s = 1,2,3,"123",False,(1,2,3,4)
s.remove('123')
print(s)   #  False, 1, 2, 3, (1, 2, 3, 4)

pop 随机删除一个

s = 1,2,3,"123",False,(1,2,3,4)
s.pop()
print(s)

clear 清空

s = 1,2,3,"123",False,(1,2,3,4)
s.clear()
print(s)   #set()

del 删除集合

s = 1,2,3,"123",False,(1,2,3,4)
del s       #  直接删除集合

其他操作

交集。（& 或者 intersection）

set1 = 1,2,3,4,5
set2 = 4,5,6,7,8
print(set1 & set2)  # 4, 5
print(set1.intersection(set2))  # 4, 5

并集。（| 或者 union）

set1 = 1,2,3,4,5
set2 = 4,5,6,7,8
print(set1 | set2)  # 1, 2, 3, 4, 5, 6, 7,8

print(set2.union(set1))  # 1, 2, 3, 4, 5, 6, 7,8

差集。（- 或者 difference）

set1 = 1,2,3,4,5
set2 = 4,5,6,7,8
print(set1 - set2)  # 1, 2, 3
print(set1.difference(set2))  # 1, 2, 3

反交集。 （^ 或者 symmetric_difference）

set1 = 1,2,3,4,5
set2 = 4,5,6,7,8
print(set1 ^ set2)  # 1, 2, 3, 6, 7, 8
print(set1.symmetric_difference(set2))  # 1, 2, 3, 6, 7, 8

子集与超集

set1 = 1,2,3
set2 = 1,2,3,4,5,6

print(set1 < set2)
print(set1.issubset(set2))  # 这两个相同，都是说明set1是set2子集。

print(set2 > set1)
print(set2.issuperset(set1))  # 这两个相同，都是说明set2是set1超集。

frozenset不可变集合，让集合变成不可变类型。

s = frozenset('barry')
print(s,type(s))  # frozenset('a', 'y', 'b', 'r') <class 'frozenset'>