Python学习 11 - 基本数据类型 （list、tuple、dictionary）及常用命令

个人学习总结笔记如有不足和错误欢迎指教谢谢

列表（list）：[ ] 例如：list = [ 1, 'a', 5, '我' ]

元祖（tuple）：( ) 例如：tuple = (1, 'a', 5, '我' )

字典（dictionary）：{ } 例如：dictionary = { aa : 1, ab : 'a', ac : 5,  ad : '我' }

一、列表（list）

列表是 有序的 而且 列表内的 元素是可以被修改的

列表使用 [ ] 中括号 把元素 括起来 并且 每个元素之间 用 ， 逗号隔开

例如

n = [ 1, 'ab', 5, '我' ]

        1, 'ab', 5, '我'  这些就是元素

元素可以是 字符串、数字、布尔值、变量、其他的列表都可以
 

x = 5

n2 = [1,9,5,'asd',['张三','李四',123],'adam',x]

1 、列表可以使用切片或索引来提取

切片的范围是 左边的位<= 切片 <右边的位

如

x = 5
n2 = [1,9,5,'asd',['张三','李四',123],'adam',x] 
print(n2[3:5]) #['asd', ['张三', '李四', 123]] （3<= print <5）
print(n2[2])    #5
print(n2[-2]) #adam

当索要提取的元素位于列表中嵌套的另一个列表内时只需要一次填入每个列表中要提取的元素的位置值

例如

x = 11
n2 = [1,9,5,'asd',['张三',['xy', '西沙', 999],123],'adam',x]
print(n2[4][1][2]) #999

2、表格和字符不同，表格再内存中创建之后里面的元素是可以修改的，但是字符不行，字符只能新建

例如：

通过索引的方式修改

x = 5
n2 = [1,9,5,'asd',['张三','李四',123],'adam',x]
print(n2[2]) #5
n2[2] = 105 #把列表n2中的2号位置的元素赋值位105
print(n2[2]) #105

也可以通过切片的方式进行修改

x = 5
n2 = [1,9,5,'asd',['张三','李四',123],'adam',x]
print(n2[2])  #5
n2[2] = 105  #把列表n2中的2号位置的元素赋值位105
print(n2[2])  #105
n2[3:6] = [7, 8, 9]  #把列表的3，4，5这三个位的元素赋值位7，8，9
print(n2)   #[1, 9, 105, 7, 8, 9, 5]

PS：在内存中，表格内的元素都会有后一位的元素在内存从的位置，这个机制叫做链表，修改的本质就是删除选中的内容再添加到原来删除的位置

3、删除列表内的元素 del

例如

可以使用索引和切片的方式对元素进行删除操作

x = 5
n2 = [1,9,5,'asd',['张三','李四',123],'adam',x]
del n2[2]  #删除索引位2号位置的元素
print(n2)  #[1, 9, 'asd', ['张三', '李四', 123], 'adam', 5]
del n2[3:6]   #把列表的3，4，5这三个位的元素删除
print(n2)   #[1, 9, 'asd']

3、in判断

可以用 in 这个命令判断 元素是否存在列表之中 他会返回一个 布尔值

例如

x = 11
n2 = [1,9,5,'asd',['张三','李四',123],'adam',x]
v1 = '李四' in n2
v2 = 11 in n2
v3 = 'adam' in n2
v4 = ['张三','李四',123] in n2
print(v1) #False
print(v2) #True
print(v3) #True
print(v4) #True

4、字符串类型转变可以使用 list 命令把字符串转换为列表

单独转换一个元素的时候，只有str的变量才能进行转换，在转换单独数字元素的时候，需要使用str命令把int类型的变量转换成str类型再转换，并且这个元素会被分割成每一位为一个元素从新组合成一个列表

PS：也可以理解位是用for循环了这个字符串 并使用append添加到了列表中（纯数字不能用for循环）

当转换的元素是元祖的时候，元祖内的字符串和数字数据类型并不会改变，也不会被切分成最小的位，看起来就好像只是把小括号( )换成了中括号[ ]

当转换的是字典的时候 只有keys会被保留

例如

x = 'adam'
x1 = ("adma", 456)
x2 = {'aa':1, 'ab':2}

n1 = list(x) #把变量x（字符串） 转换成表格
n2 = list(x1) #把元祖转换成表格
n3 = list(x2) #把字典转换成表格

print(n1) #['a', 'd', 'a', 'm']
print(n2,type(n2[1])) #['adma', 456] <class 'int'>
print(n3) #['aa', 'ab']

5、append 添加元素

在列表末尾原有基础上添加一个或多个新的元素,也可以插入变量函数

例如

li = [1,2,3,4]
li.append(5)
print(li) #[1, 2, 3, 4, 5]
li.append('我')
print(li) #[1, 2, 3, 4, 5, '我']
li.append([4,8,9])
print(li) #[1, 2, 3, 4, 5, '我', [4, 8, 9]]
x = [22,33,44]
li.append(x)
print(li)#[1, 2, 3, 4, 5, '我', [4, 8, 9],[22,33,44]]

6、clear 清空

清空列表

li = [1,2,3,4]
li.clear()
print(li) #[]

7、 copy 拷贝

浅拷贝命令

li = [1,2,3,4]
x = li.copy()
print(x) #[1, 2, 3, 4]

8、count   计数

计算元素出现的次数

（）括号中写的内容就是要计数的元素

li = [1,2,3,45,5,5,5,5,5,5] #有6个5
x = li.count(5) #计算li这个列表里面有几个5
print(x) #6

9、extend  扩展

把元素循环放入原有的列表中，它和append不同，append会把元素打包放在列表最后一个元素位，而extend会把每一个元素依次放入列表最后位

li = [1,2,3,4]
li.extend([555,'我们'])
print(li) #[1, 2, 3, 4, 555, '我们']

10、 index  索引

根据元素值获取当前索引位置

index是索引的意思，从左往右匹配，找到一个即退出

可以设置起始的搜索位置
 

li = [1,4,2,3,2,4]
x = 4
v = li.index(x)
v1 = li.index(4)
v2 = li.index(x,2) #从索引位置第2位开始想右搜索

print(v)    #1
print(v1) #1
print(v2) #5

11、insert  插入元素

第一个参数是插入位置 第二个参数是插入值 被插入后 其他元素会向后移动一位

li = [1,2,3,4]
li.insert(2, 6)
print(li) #[1, 2, 6, 3, 4]

12、pop  删除指定索引位置的值

删除指定索引位置的值 并获取 该值 默认删除最后一个值并获取这个被删除的值

li = [1,2,3,4]
li.pop()
print(li) #[1, 2, 3]
li = [1,2,3,4]
print(li.pop(1)) #2 #删除索引位置1的元素 并把它的值取回

13、  remove 删除列表中的指定值

左侧优先

li = [1,2,3,4,3]
li.remove(3) #删除3这个数值的元素
print(li) #[1, 2, 4, 3]

14、reverse 将当前列表元素进行反转

li = [1,2,3,4,5]
li.reverse()
print(li) #[5, 4, 3, 2, 1]

15、sort 排序

只能排序int数据和str数据 默认位递增排序 也可以反向排序

li = [5, 4, 3, 2, 1]
li.sort()
print(li) #[1, 2, 3, 4, 5]

 递减排序如下

li = ['e', 'a', 'c', 'd', 'b']
li.sort(reverse = True)
print(li) #['e', 'd', 'c', 'b', 'a']

二、元祖（tuple）

元祖其实就是对列表的二次加工

元祖是不能不修改的 也不能增加或删除

元祖是可迭代对象（可以用for循环）

元祖里面如果嵌套了列表 列表内的元素是可以被修改的

元祖可以索引和切片并且支持使用for循环

1、tuple转换位元祖

这个命令可以把字符串 列表 或者 字典 转化为 元祖 ，字符串会被 依次拆分为单个字节的元素 并顺序排列

只能转换 str 列表 和字典 不能转换 int

g = 'asdsadwa'
g1 = ['asd','asss','as']
g2 = [1234,'asd','asss','as']
g3 = {'asd':1,'asss':33,'as':4}

v = tuple(g)
v1 = tuple(g1)
v2 = tuple(g2)
v3 = tuple(g3)
print(v) #('a', 's', 'd', 's', 'a', 'd', 'w', 'a')
print(v1) #('asd', 'asss', 'as')
print(v2) #(1234, 'asd', 'asss', 'as')
print(v3) #('asd', 'asss', 'as')

2、count 统计指定元素在元祖中出现的次数

g = ('a', 's', 'd', 's', 'a', 'd', 'w', 'a')
print(g.count('a')) # a 出现了3次

3、index 左侧优先 找到指定值的索引位置   

可以设置起始位置 默认从0位开始搜索

如果不设置结束位置默认搜索值找到相符的值为止

g = ('a', 's', 'd', 's', 'a', 'd', 'w', 'a')
print(g.index('d')) # d 在第索引位置2出现
print(g.index('a',6)) #  a从第6位开始寻找索引位置7出现

三、字典（dictionary）

可变的值 是不能作为 key的 不能做哈希操作的都不能作为key

key不能是 布尔值 列表 和 字典 key的名字不能相同 如果相同则只能显示一个

字典是无序的 支持层层索引，索引使用key值进行，但是无法进行切片的方式进行找到里面的特定值

支持del删除的 使用方法跟索引差不多

for默认是循环所有的第一层的key

字典的结构

info = {

                'a1':'b1' #键值对 # a1是key，b1是值

                'a2':'b2'

        }

1、索引

索引匹配的是 键值 也就是key

info = {
	'a1':'18',#键值对
	'a2':'b2',
	'a3':[1,2,3,4,{
					'aa1':'ff1',
					'aa2':'xx1',
					'agg':(
						55,
						66
						)
					}
		],
	'a4':(88,99,44,33)
}
print(info['a3'][4]['agg'][0])#55

2、del 删除

它的用法和索引基本一致 ，直接删除键值，没法针对值单独进行删除

info = {
	'a1':'18',#键值对
	'a2':'b2',
	'a3':[1,2,3,4,{
					'aa1':'ff1',
					'aa2':'xx1',
					'agg':(
						55,
						66
						)
					}
		],
	'a4':(88,99,44,33)
}
del info['a3'][4]['agg']
print(info)#{'a1': '18', 'a2': 'b2', 'a3': [1, 2, 3, 4, {'aa1': 'ff1', 'aa2': 'xx1'}], 'a4': (88, 99, 44, 33)}

3、for循环

只是循环第一层 默认循环key也就是键（默认加了 .keys()这个参数）

info = {
	'a1':'18',#键值对
	'a2':'b2',
	'a3':[1,2,3,4,{
					'aa1':'ff1',
					'aa2':'xx1',
					'agg':(
						55,
						66
						)
					}
		],
	'a4':(88,99,44,33)
}
for v in info:
	print(v) #
	#a1
	#a2
	#a3
	#a4

也可以通过添加参数 .values()这个函数 使其输出 值，只输出值

info = {
	'a1':'18',#键值对
	'a2':'b2',
	'a3':[1,2,3,4,{
					'aa1':'ff1',
					'aa2':'xx1',
					'agg':(
						55,
						66
						)
					}
		],
	'a4':(88,99,44,33)
}
for v in info.values():
	print(v)
	#18
	#b2
	#[1, 2, 3, 4, {'aa1': 'ff1', 'aa2': 'xx1', 'agg': (55, 66)}]
	#(88, 99, 44, 33)

还可以使用 .items 这个参数 使得for循环输出 keys 和 values 也就是键值都输出，但是需要定义两个变量名，也只是循环第一层

info = {
	'a1':'18',#键值对
	'a2':'b2',
	'a3':[1,2,3,4,{
					'aa1':'ff1',
					'aa2':'xx1',
					'agg':(
						55,
						66
						)
					}
		],
	'a4':(88,99,44,33)
}


for k,v in info.items():
	print(k,v)
#a1 18
#a2 b2
#a3 [1, 2, 3, 4, {'aa1': 'ff1', 'aa2': 'xx1', 'agg': (55, 66)}]
#a4 (88, 99, 44, 33)

4、fromkeys 创建字典

默认创建一个只有keys的字典

.fromkeys([key名称],key值)

也可以添加key值但是，添加之后所有的值都是一样的

v = dict.fromkeys(['x11',99,'五'])
print(v) #{'x11': None, 99: None, '五': None}
v1 = dict.fromkeys(['x11',99,'五'],123)
print(v1)#{'x11': 123, 99: 123, '五': 123}

5、get 找到一个key的值

去找一个key的值，如果没有找到默认返回的值是None，但是后面加了参数之后，返回的值就是该参数

abc = {

'kx':12,
'kt':22

}

v = abc.get('kt')
print(v) #22
v1 = abc.get('kk',1)
print(v1) #1

6、pop删除

找到并删除一个键值，key和值都删除，并且返回这个key的值

如果没找到程序直接报错

可以设置参数 如果没有找到这个key则返回这个设置的值

abc = {

'kx':12,
'kt':22

}
v2 = abc.pop('kt')
print(v) #22
print(abc) #{'kx': 12}
v3 = abc.pop('kk',0)
print(v3) #0

7、popitem

随机找到一个key,并且删除这个key还会取得这个key和它的值赋值给前面两个变量

abc = {

'kx':12,
'kt':22

}
v1,v2 = abc.popitem()
print(v1,v2) #kt 22
print(abc) #{'kx': 12}

8、setdefault

给字典设置一个 key和值 ，如果没有这个key、就直接添加，并返回设置的值，如果已经有这个key了就取回现有的这个key的值

abc = {

'kx':12,
'kt':22

}
v2 = abc.setdefault('kk',123)
print(abc) #{'kx': 12, 'kt': 22, 'kk': 123}
v = abc.setdefault('kk',456)
print(v) #123
print(abc) #{'kx': 12, 'kt': 22, 'kk': 123}
print(v2) #123

9、update

更新词典，更新现有的key的值，创建没有的key并赋值

abc = {

'kx':12,
'kt':22

}
abc.update({'kx':14,'kt':52,'ke':456})
print(abc) #{'kx': 14, 'kt': 52, 'ke': 456}