python数据类型二

list 列表，可变的数据类型

列表和字符串一样也拥有索引

lst = ['动态','1','静态','编译','脚本']
获取列表中元素索引位置
s = lst.index('编译')
print(s)
结果
3

根据列表索引取元素
print(lst[0])
结果
动态

列表切片
print(lst[0:3])         #打印第0到第3个元素
print(lst[:4:2])        #打印第0到第4个元素,步长为2
print(lst[:-5:-1])      #-1倒序打印
结果
['动态', '1', '静态']
['动态', '静态']
['脚本', '编译', '静态', '1']

增

.append(要追加的元素) 追加
lst = ['a','b','c']
lst.append(8)
print(lst)
结果
['a', 'b', 'c', 8]

.insert('要插入的位置(索引)',要插入的内容) 插入
lst.insert(2,True)
print(lst)
结果
['a', 'b', True, 'c']

.extend() 扩展,迭代添加(把传递进去的参数进行迭代)
lst.extend('bob')
print(lst)
结果
['a', 'b', 'c', 'b', 'o', 'b']
去除迭代添加
lst = ['a','b','c']
lst.extend(['bob'])
print(lst)
结果
['a', 'b', 'c', 'bob']

删

lst = ['bob',1,2,'bob',3,4,True,'bob']

.remove() 移除(删除指定的元素,只能指定一个删除,一次只能删除一个)
lst.remove('bob')
print(lst)
结果
[1, 2, 'bob', 3, 4, True, 'bob']

.pop() 弹出,默认删除最后一个,可以指定下标删除元素
.pop() 有返回值,返回的就是被删除的元素
s = lst.pop()
print(s)
print(lst)
结果
bob
['bob', 1, 2, 'bob', 3, 4, True]
事例二
lst = ['bob',1,2,'bob',3,4,True,'bob']
s = lst.pop(1)
print(s)
print(lst)
结果
1
['bob', 2, 'bob', 3, 4, True, 'bob']

.clear() 清空
lst.clear()
print(lst)
结果
[]

del 通过下标删除对应的元素
del lst[-2]
print(lst)
结果
['bob', 1, 2, 'bob', 3, 4, 'bob']

删除整个列表(报错,因为列表被删除,找不到此列表)
del lst
print(lst)

改

通过指定列表元素下标更改元素
lst = ['bob',1,2,'jrey',3,4,True,'alex']
lst[3] = 'tom'  
print(lst)

列表切片修改元素
lst = ['bob',1,2,'jrey',3,4,True,'alex']
lst[0:5] = 'tom','jk'
print(lst)
结果
['tom', 'jk', 4, True, 'alex']
或
lst[0:5] = ['tom']
print(lst)
结果
['tom', 4, True, 'alex']

如果步长不是1,元素的个数必须要和切片的个数一致(坑)
lst = ['bob',1,2,'jrey',3,4,True,'alex']
lst[1:5:2] = ['tom','jack'] #如果这里是一个元素就会报错
print(lst)

事例
lst = ['bob',1,2,'jrey',3,4,True,'alex']
lst[3] = lst[3].upper()
print(lst)
结果
['bob', 1, 2, 'JREY', 3, 4, True, 'alex']

查

通过元素下标查询
print(lst[3])

for循环查询
for i in lst:
    print(i)

列表嵌套
一层列表叫做一维列表
二层列表叫做二维列表
三层列表叫做三维列表

lst = [1,2,3,'alex','wusir',True,False,[5,6,7,'jack',[18,'山谷','爱好',['可口可乐']]]]
lst1 = lst[7] 等于 [5,6,7,'jack',[18,'山谷','爱好',['可口可乐']]]
lst2 = lst1[-1] 等于 [18,'山谷','爱好',['可口可乐']]
lst3 = lst2[-1] 等于 ['可口可乐']
lst4 = lst3[0] 等于 可口可乐
lst[7][-1][-1] 等于 ['可口可乐']
print(lst[7][-1][-1][0]) 等于 可口可乐
print(lst[7][4][-3:-1]) 等于 ['山谷','爱好']

追加列表中的元素
lst = [1,'大白','jack',['麻花疼',['可口可乐'],'王健林']]
lst[-1][-2].append('雪碧')
print(lst)
结果
[1, '大白', 'jack', ['麻花疼', ['可口可乐', '雪碧'], '王健林']]

练习题：

lis = [2, 4, "k", ["qwe", 20, ["k1", ["tt", 3, "1"]], 89], "ab", "adv"]
将列表lis中的"tt"变成大写（用两种方式）
lis[3][2][1][0] = lis[3][2][1][0].upper()       #方法一，找到tt,用字符串操作符upper来改变列表中值的大小
lis[3][2][1][0] = 'TT'                          #方法二改变列表中的值
print(lis)
将列表中的数字3变成字符串"100"（用两种方式）
lis[3][2][1][1] = '100'                         #方法一，直接找到列表中的值,将其改变
lis[3][2][1][1] = str(lis[3][2][1][1] + 97)     #方法二，用运算方法改变列表中的值
print(lis)
将列表中的字符串"1"变成数字101（用两种方式）
lis[3][2][1][-1] = int(lis[3][2][1][-1]) + 100  #方法一
print(lis)

lis[3][2][1][-1] = 101                        #方法二
print(lis)

列表其他操作

列表相乘
lst = [1,2,3]
print(lst * 3)
结果
[1, 2, 3, 1, 2, 3, 1, 2, 3]

列表合并
lst = [1,2,3]
lst1 = [6,7,8,'a']
print(lst + lst1)
结果
[1, 2, 3, 6, 7, 8, 'a']

lst = [1,2,6,7,89,54,2,4,53,34,4,3]
查看列表中的元素个数
print(len(lst))
结果
12

统计指定字符串个数
s = lst.count(3)
print(s)
结果
2

排序,默认升序(从小到大)
lst.sort()
print(lst)
结果
[1, 2, 2, 3, 4, 4, 6, 7, 34, 53, 54, 89]

降序(从大到小)
lst.sort(reverse=True)
print(lst)

反转列表
lst.reverse()
print(lst)
结果
[3, 4, 34, 53, 4, 2, 54, 89, 7, 6, 2, 1]

按照ASCII字母排序
lst1 = ['abex','baobao','dj','6','gg','hg','admin','baobao']
lst1.sort()
print(lst1)
结果
['6', 'abex', 'admin', 'baobao', 'baobao', 'dj', 'gg', 'hg']

 tuple　　元组

不可变的数据类型,有序,是一个不可以修改的列表,只能查看,可以for循环,可以切片,可以嵌套

元组的方法:
    count  统计
    index  索引

元组索引和切片
tu = ('bob',4,'tom',8,'jack')
print(tu[2])
print(tu[2:4])
print(tu[::2])
结果
tom
('tom', 8)
('bob', 'tom', 'jack')

合并元组
tu = (1,2,3)
tu1 = (5,) + tu
print(tu*2)
print(tu1)
结果
(1, 2, 3, 1, 2, 3)
(5, 1, 2, 3)

元组索引
tu = (1,2,3,4,5,4,3,4,)
print(tu.index(3))      #第一个值的索引位置
print(tu.count(4))      #统计4在元组中有多少个
print(tu[:4])           #切片打印元组中前4个值
结果
2
3
(1, 2, 3, 4)

循环元组
for i in tu:
    print(i)
结果
1
2
3

生成元组
tu = 1,2,3
print(tu,type(tu))
结果
(1, 2, 3) <class 'tuple'>

列表转元组
l = ['a','b','c']
tu = tuple(l)
print(tu,type(tu))
结果
('a', 'b', 'c') <class 'tuple'>

反转元组
t = (1,2,1,3,4)
print(t[::-1])

获取元组长度
print(len(t))

获取元组中最大的元素
print(max(t))
获取元组中最小的元素
print(min(t))
结果
(4, 3, 1, 2, 1)
5
4
1

比较两个元组 ==\!=\>\<
print((1,2) < (3,4))
结果
True

判定某元素是否在这个元组中 in或not in
t = ('a','b','c')
print('a' not in t)
结果
False

拆包
a,b = (1,2)
print(a,b)
结果
1 2

a = 1
b = 2
a,b = (b,a)
print(a,b)
结果
2 1

元组嵌套
tu = (1,2,3,'a',False,[4,5,6],(8,7,9))
print(id(tu[-2]))
tu[-2].append(7)    #元组没改,改的是元素内部,没有改变元组的指向,不报错
print(tu)
print(id(tu[-2]))
print(tu[6][-3:-1])
结果
2498382337224
(1, 2, 3, 'a', False, [4, 5, 6, 7], (8, 7, 9))
2498382337224
(8, 7)
注意：由此得出元组只要定义，在元组中的任何操作都不改变元组创建的内存地址

元组面试题(坑)

空元组定义
tu = tuple()
print(type(tu))

tu = (1,)       #有逗号就是tuple类型
print(type(tu))
tu = (1)        #少一个逗号就是int类型
print(type(tu))
结果
<class 'tuple'>
<class 'int'>

只要是用[]都是列表list
lst = [1]
print(type(lst))
结果
<class 'list'>

id()　　查看数据类型内存地址

print(id(a))
#字符串和数字是不可变的数据类型

 range     #可以指定范围,类似于切片

切片与range格式对比：
[起始:终止:步长]      #切片这么写
range(起始位置,终止位置,步长)
区别：
# python2.x
    range()   列表
    xrange()  生成器
# python3.x
    range() 可迭代的,既不是生成器也不是迭代器

事例：

range(起始参数,终止参数,步长)

起始位置不写默认为0
print(range(5))
结果
range(0, 5)

打印10到0,-1为降序打印
print(list(range(10,0,-1)))
结果
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

range获取的这个区间是可迭代的
for i in range(6):
    print(i)
结果
0
1
2
3
4
5

使用for循环和range打印10到0之间的所有偶数(步长为2)
for i in range(10,-1,-2):
    print(i)
结果
10
8
6
4
2
0

lst = ['a','b','c']
for i in range(len(lst)): #i就是索引 lst[i]元素
    print(i, lst[i])
结果
0 a
1 b
2 c