python基础-数据类型

Posted 2021-02-01 Sandy

4.列表(list)

结构:lst = [1,2,‘a‘,True]   有序,可变数据

列表的增删改查:

增:

 append()    追加,在列表的最末尾添加

lst = [1,2,3,‘aa‘,4,5,‘bb‘]
lst.append(6)
print(lst)

结果:
[1, 2, 3, ‘aa‘, 4, 5, ‘bb‘, 6]

 insert()       插入,指定下标进行插入添加

lst = [1,2,3,‘aa‘,4,5,‘bb‘]
lst.insert(3,‘cc‘)
print(lst)

结果:
[1, 2, 3, ‘cc‘, ‘aa‘, 4, 5, ‘bb‘]

 extend()     扩展,迭代添加

lst = [1,2,3,‘aa‘,4,5,‘bb‘]
lst.extend([6,‘cc‘])
print(lst)

结果:
[1, 2, 3, ‘aa‘, 4, 5, ‘bb‘, 6, ‘cc‘]

 lst1 + lst 2

lst1 = [1,2,3]
lst2 = [‘aa‘,‘bb‘,‘cc‘]
print(lst1 + lst2)

结果:
[1, 2, 3, ‘aa‘, ‘bb‘, ‘cc‘]

 

 删:

del  lst          删除整个列表

del lst[2]      通过下标进行删除

lst = [1,2,3,‘aa‘,‘bb‘]
del lst[2]
print(lst)

结果:
[1, 2, ‘aa‘, ‘bb‘]

 

del lst[0:3]   通过切片进行删除

lst = [1,2,3,‘aa‘,‘bb‘]
del lst[0:2]
print(lst)

结果:
[3, ‘aa‘, ‘bb‘]

 

remove  指定内容删除

lst = [1,2,3,‘aa‘,‘bb‘]
lst.remove(‘aa‘)
print(lst)

结果:
[1, 2, 3, ‘bb‘]

 

pop   没有指定的情况下,默认删除最后一个,和del一样,可以通过下标,切片进行删除

lst = [1,2,3,‘aa‘,‘bb‘]
lst.pop()
print(lst)

结果:
[1, 2, 3, ‘aa‘]
#默认删除

lst = [1,2,3,‘aa‘,‘bb‘]
lst.pop(2)
print(lst)


结果:
[1, 2, ‘aa‘, ‘bb‘]
#通过索引

 

clear    清空

lst = [1,2,3,‘aa‘,‘bb‘]
lst.clear()
print(lst)

结果:
[]

 

改:

通过下标.切片,步长进行修改

lst = [‘杨紫‘,‘高圆圆‘,‘刘亦菲‘,‘关晓彤‘]
lst[0] = ‘杨幂‘
print(lst)

结果:
[‘杨幂‘, ‘高圆圆‘, ‘刘亦菲‘, ‘关晓彤‘]
#通过下标

 

lst = [‘杨紫‘,‘高圆圆‘,‘刘亦菲‘,‘关晓彤‘]
lst[0:3] = ‘123456‘
print(lst)

结果:
[‘1‘, ‘2‘, ‘3‘, ‘4‘, ‘5‘, ‘6‘, ‘关晓彤‘]

#通过切片,长度可以不一样,都会替换到列表当中

lst = [‘杨紫‘,‘高圆圆‘,‘刘亦菲‘,‘关晓彤‘]
lst[0:3:2] = ‘ns‘
print(lst)

结果:
[‘n‘, ‘高圆圆‘, ‘s‘, ‘关晓彤‘]
#通过步长,要注意替换的内容必须和步长内容长度相等,不然那会报错

 

查:

for循环

lst = [‘杨紫‘,‘高圆圆‘,‘刘亦菲‘,‘关晓彤‘]
for i in lst:
    print(i)

结果:
杨紫
高圆圆
刘亦菲
关晓彤

 其他操作:

 sort        排序,默认升序

 reverse   翻转       sort(reverse = True)     降序

lst = [1,4,6,77,742,23,8]
lst.sort(reverse=True)
print(lst)

结果:
[742, 77, 23, 8, 6, 4, 1]

 count     统计

 index     通过内容获取下标

 

列表嵌套:

lst = [1,2,34,[45,5,[‘hello‘]]]
print(lst[3][2][0])

结果:
hello

 5.元祖(tuple):

基本结构:  tu = (1,‘2‘,‘我‘) 

一个不可变的列表. 有序  不可变数据

可以使用下标,切片和循环,但是不能进行修改

要注意的是,如果元祖中只有一个元素,要添加一个逗号,不然数据类型就不是元祖

range:

范围.

range(1,6,2)

第一个1为起始位置,第二个6为终止位置,第三个2为步长

但是range本身是一个范围,想要达到切片和步长的效果,可以利用list进行转换使用:

print(range(0,5,2))

结果::
range(0, 5, 2)    #表示范围


print(list(range(0,5,2)))

结果:
[0, 2, 4]       #返回列表,与之前学的切片作用一致

 6.字典(dict)

基础结构: dic = {‘键‘:值}  以键值对出现   

存储一些大量数据,查找快     无序,是可变数据

在给字典赋值的时候,要注意 ‘键‘必须是不可变数据类型且不能重复,值则没有要求,可以使任何数据类型.

字典的操作:

增:

dic[‘键‘] = ‘值‘    如果‘键‘没有重复就添加,重复的话就覆盖原数据修改

dic.setdefault(‘键‘:‘值‘)     会先用‘键‘进行查找,没有重复的话(返回值是None)就添加,重复的话则不添加.

dic.fromkeys(‘可迭代对象‘,值)    不写值,默认是None,写值的时候,注意是不是可变数据类型,如果是,在进行可变数据类型的操作的时候,要注意看其他‘键‘对应的值的变化.

删:

dic.pop(‘键‘,找不到时的提示语句)     通过‘键‘删除值,可以在键后边写上提示语句,找不到对应的键时,会返回提示.

dic.popitem()      随机删除(python3.6中默认删除最后一个),删除的是键值对,且有返回值,返回值以元祖的形式的呈现.

del dic     删除整个字典

del dic[‘键‘]     通过‘键‘删除值

dic.clear       清空字典

注:字典中没有remove的用法

改:

dic[‘键‘] = ‘值‘    如果‘键‘没有重复就添加,重复的话就覆盖原数据修改    

dic.update()    在括号里面的级别大于update前面的    如果‘键‘有重复就覆盖修改,如果没有,就增加到原字典中合并

查:

dic[‘键‘]      通过键查找,找不到时报错

dic.get(‘键‘,找不到时的提示语句)  通过键查找,可以在键后边写上提示语句,找不到对应的键时,会返回提示.

dic.setdefault(‘键‘)     通过键查找

其他操作:

keys      所有的键            返回的是高仿列表(只支持for循环)

dic = {‘k1‘: "v1", "k2": "v2", "k3": "v3"}
for i in dic.keys():
    print(i)

结果:
k1
k2
k3

 

values   所有的值            返回的是高仿列表(只支持for循环)

dic = {‘k1‘: "v1", "k2": "v2", "k3": "v3"}
for i in dic.values():
    print(i)

结果:
v1
v2
v3

 

items     所有的键值        存放在高仿列表里,以元祖的形式返回

dic = {‘k1‘: "v1", "k2": "v2", "k3": "v3"}
for i in dic.items():
    print(i)

结果:
(‘k1‘, ‘v1‘)
(‘k2‘, ‘v2‘)
(‘k3‘, ‘v3‘)

 

 

解构:

a,b = 1,2
a,b = ‘12‘
a,b = [1,2]

打印a,b,返回的结果都是:1  2

 

a = 10
b = 20
a,b = b,a
print(a,b)


结果:
20  10

#一行代码交换数值

字典嵌套:

dic = {‘k1‘: "v1", "k2": "v2", "k3": [11,22,33]}
dic[‘k3‘].append(44)
print(dic)

结果:
{‘k1‘: ‘v1‘, ‘k2‘: ‘v2‘, ‘k3‘: [11, 22, 33, 44]}

#字典内嵌套列表,在列表中添加数据

 

7.集合(set):

基本结构: se = {1,2,‘我‘,(3,4)}     可变数据类型,无序,天然去重

需要注意的是集合的元素必须是不可变数据类型.

增:

se.add(‘内容‘)

se.update(‘可迭代对象‘)

删:

se.remove()    通过内容删除

se.pop()    默认删除第一个

del se    删除整个集合

改:

先删除,再增加

查:

for循环

其他操作:

交集  &　　两个集合都有的元素

并集  |　　 两个集合相加,重复的部分天然去重

差集  -　　得到第一个集合中单独存在的元素

反交集  ^　两个集合中单独存在的数据合并

子集  <　　判断第一个集合是不是第二个集合的子集,返回布尔值

超集  >　　判断第二个集合是不是第一个集合的子集,返回布尔值

 

冻结集合

frozenset([])   将可变的集合变成不可变数据类型,冻结后可以当做字典的键