python常用数据类型操作
列表
- 定义
有序的可变的元素集合 VS 字符串非可变
# 有序的可变的元素集合 VS 字符串非可变
name = "abc"
name[0] = "d"
# print(name[0]) 不可改
# 定义方式一 [xx,ss,...]
item = []
items = [12, 32, True, "skjdh"]
# 列表的嵌套 vs 数组 可以存放不同的数据类型
names = ["zhangsan", "yangliu", "wanghe", items]
# ['zhangsan', 'yangliu', 'wanghe', [12, 32, True, 'skjdh']] <class 'list'>
print(names, type(names))
# 定义方式二
# 列表生成式
# 0-99 列表
# python不会立即生成列表,只有当你使用才生成,防止浪费空间
# range(stop) [0,1,2,3...stop-1]
nums = range(101) # [0,1...100]
# range(start,stop,step) [start,start+step,start+2*step...<stop]
nums = range(1, 100, 1)
print(nums[7]) # 8
# 列表推导式
# 从一个list推导出另外一个list
# 映射解析(一对一变更) 和 过滤(从多到少)
resultList = []
nums = [1, 2, 3, 4, 5, 6]
for num in nums:
result = num ** 2
# print(result)
resultList.append(result)
print("列表元素平方", resultList) # 列表元素平方 [1, 4, 9, 16, 25, 36]
# 列表推导式
resultList = [num + 1 for num in nums]
print(resultList) # [2, 3, 4, 5, 6, 7]
resultList = [num ** 2 for num in nums]
print("列表元素平方", resultList)
resultList = [num ** 2 for num in nums if num % 2 != 0] # 过滤
print("列表元素平方", resultList)# 列表元素平方 [1, 9, 25]
- 常用操作-增删改查
- 增
# 增删改查
# 增加在列表后面 append,会改变原列表
nums = [1, 2, 3]
print(nums)
nums.append(5)
print(nums.append(5)) # none 方法没有返回值
print(nums) # [1, 2, 3, 5]
# insert 在指定索引前面增加元素
# 索引都是 0 1 2 3 4 ...
nums = [1, 2, 3]
print(nums)
nums.insert(1, 5)
print(nums) # [1, 5, 2, 3]
# extend 往列表中,扩展另一个可迭代序列
# 可迭代序列(可使用for循环进行遍历):字符串、列表、元组
nums = [1, 2, 3]
nums2 = ["a", "b", "c"]
print(nums.extend(nums2)) # none 只是修改原列表
print(nums) # [1, 2, 3, 'a', 'b', 'c']
nums = [1, 2, 3]
nums2 = "ajsdhgKUAY"
print(nums.extend(nums2))
print(nums) # [1, 2, 3, 'a', 'j', 's', 'd', 'h', 'g', 'K', 'U', 'A', 'Y']
# 乘法运算,复制列表几遍
nums = [1, 2, 3]
print(nums * 3) # [1, 2, 3, 1, 2, 3, 1, 2, 3]
# 加法运算,只能同类型相加
nums = [1, 2, 3]
nums2 = ["a", "b", "c"]
print(nums + nums2) # [1, 2, 3, 'a', 'b', 'c']
- 删
# 删除操作
# del 可以删除一个指定的元素(对象)
nums = [1, 2, 3]
del nums[1]
print(nums) # [1, 3]
num = 777
print(num)
del num # 删除变量
del nums # 删除整个列表
# pop 移除并且返回列表中指定索引值对应元素
# 默认删除-1,列表最后一个元素
nums = [1, 2, 3]
#result = nums.pop()
result = nums.pop(1)
print(result) # 2
print(nums) # [1,3]
# remove 移除列表指定元素
nums = [1, 2, 3]
result = nums.remove(2)
print(result) # 无返回值
print(nums) # [1, 3]
# 注意循环内删除列表所带来的坑 列表是有序的
nums = [1, 2, 3, 4, 2, 2, 2, 5, 9]
for num in nums:
print(num)
if num == 2:
nums.remove(2) # 删除第五个位置的2时候,后面元素往前移,后面第三个2往前移,循环不会判断删除
print(nums) # [1, 3, 4, 2, 5, 9]
- 改
# 列表修改操作
# 操作列表当中某个元素,通过索引
nums = [1, 2, 3]
nums[2] = 9
print(nums) # [1, 2, 9]
- 查
# 列表查询操作
# 获取单个元素
nums = range(10)
print(nums[5]) # 5
print(nums[-1]) # 9
print(nums[-2]) # 8
# 获取元素索引
# index(value,start,stop)
index = nums.index(7) # 从左到右查找
print(index)
# 获取指定元素个数
count = nums.count(5)
print(count) # 一个5
# 获取多个元素
# 切片 items[start:end:step]
pic = nums[1:5:2]
print(pic) # range(1, 5, 2)
# 列表遍历操作
# 方式一 根据元素进行遍历
# for item in list:
values = ["a", "b", "a", "d"]
currentIndex = 0
for v in values:
print(v)
print(values.index(v, currentIndex)) # 打印索引值 start参数=currentIndex
currentIndex += 1
# 方式二 动态遍历
# 根据索引进行遍历
# for index in range(len(list))
values = ["a", "b", "a", "d", "ds"]
# 手动打造一个索引列表,要遍历的索引列表
# indexs = [0, 1, 2, 3]
count = len(values)
indexs = range(count)
# 遍历整个索引列表,索引->指定元素
# 0 a
# 1 b
# 2 a
# 3 d
# 4 ds
for index in indexs:
print(index, values[index])
# 方式三 创建枚举对象
# 枚举对象 通过枚举函数生成一个新的对象 用于将一个可遍历的数据对象组合为一个索引序列(列出数据下标和数据)
# enumerate(sequence,[start,0])
# sequence 序列 start下标起始位置
# 先根据列表创建枚举对象
values = ["a", "b", "a", "d", "ds"]
# [(0, 'a'), (1, 'b'), (2, 'a'), (3, 'd'), (4, 'ds')]
print(list(enumerate(values))) # 元组格式 枚举对象转成列表
for tupleValue in enumerate(values): # 遍历整个枚举对象
print(tupleValue) # (1, 'b')
# print(tupleValue[0])
# print(tupleValue[1])
# 元组解包
# idx, val = (0, 'a')
# print(idx)
# print(val)
for idx, val in enumerate(values): # 遍历整个枚举对象
print(idx, val) # 1 b
# 方式四 使用迭代器进行遍历
# 迭代 按照某个顺序逐个访问集合中的每一项
# 迭代器从第一个元素开始,往后遍历next()函数,只能往后不能往前
# 判定对象是否可以迭代
nam = "cvd"
import collections
result = isinstance(nam, collections.Iterable)
print(result) # True
# 迭代器不一定是可迭代对象
# 迭代器是可以记录遍历位置的对象
# 判定依据 能作用于next()函数
# 判定方法
result2 = isinstance(nam, collections.Iterator) # 字符串是个可迭代对象,不是迭代器 False
print(result2)
i = iter(nam) # i迭代器
print(i)
result = isinstance(i, collections.Iterable)
print(result)
# 迭代器仅仅迭代到某个元素时才处理该元素,特别适合遍历一些巨大和无限的集合
# 在迭代到某个元素之前,元素可以不存在
# 在迭代到某个元素之后,元素可以被销毁
# 可以把所有的可迭代对象转换成迭代器进行使用
# 写一个统一的遍历代码
l = [1, 2, 3, 3, 4, 6]
# 创建一个迭代器对象,iter()函数
it = iter(l)
# next()函数
# 迭代器对象可以自动记录当前遍历位置
print(next(it)) # 1
print(next(it)) # 2
print(next(it)) # 3
print(next(it)) # 3
# 如果取出完毕,再继续取,则会报错
# 迭代器比较常用,直接作用于for-in
for c in it:
print(v)
print("----------")
for c in it: # 没有输出,因为迭代器对象不可以多次迭代
print(v)
- 判定与比较
# 列表的判定
s = [1, 2, 3, 4, 3, 2, 5]
print(5 in s)
print(5 not in s)
# 比较
# cmp()内建函数,python3不支持
# 直接使用比较运算符
result = [1, 2, 3] > [2, 3] # 列表是逐一比较 2大于1,返回False
print(result)
- 排序
# 列表排序
# 方式一 sorted(itreable,key=None,reverse=False)
# reverse控制升序降序,默认升序
# 返回值一个已排序好列表
# key值为一个函数,函数只有一个参数并且返回值用来进行比较
# 返回值:一个排好序的列表
str1 = "abdkhsd"
result = sorted(str1)
print(result) # ['a', 'b', 'd', 'd', 'h', 'k', 's']
str1 = "abdkhsd"
result = sorted(str1, reverse=True) # 降序
print(result) # ['s', 'k', 'h', 'd', 'd', 'b', 'a']
str1 = [1, 2, 3, 4, 3, 2, 5]
result = sorted(str1)
print(result) # [1, 2, 2, 3, 3, 4, 5]
s = [("sz", 12), ("sz", 22), ("sz", 19), ("1sz", 44)]
def getKey(x):
return x[1] # 返回元组第一位置对应元素,是12,按照第二个关键字进行排序
result = sorted(s, key = getKey, reverse = True) # 降序
print(result) # [('1sz', 44), ('sz', 22), ('sz', 19), ('sz', 12)]
# 列表排序方式二
# 列表对象方法
# list.sort(key=None,reverse=False)
# 列表本身改变了
l = [("sz", 12), ("sz", 22), ("sz", 19), ("1sz", 44)]
def getKey(x):
return x[1]
res = l.sort(key=getKey)
print(res, l) # None [('sz', 12), ('sz', 19), ('sz', 22), ('1sz', 44)]
- 乱序与反转
# 列表的乱序和反转
# 导入random模块
# 改变列表本身
import random
l = [1, 2, 3, 4, 3, 2, 5]
res = random.shuffle(l)
print(res, l) # None [1, 5, 3, 3, 4, 2, 2]
# 反转
# 改变l本身
res = l.reverse()
print(res, l) # None [2, 2, 4, 3, 3, 5, 1]
# 借助切片进行反转
# 不改变l本身
res = l[::-1] # 末尾开始取值
print(res, l) # [1, 5, 3, 3, 4, 2, 2] [2, 2, 4, 3, 3, 5, 1]
元组
列表:有序的可变的元素集合
元组是有序的不可变的集合。与列表的区别就是元组元素不可改变
- 定义
# 一个元组写法
t = (1)
print(type(t)) # int类型,小括号提升的运算优先级 <class 'int'>
t = (1,)
print(type(t)) # t为tuple类型 <class 'tuple'>
# 多个元素
t = (1, "dgfd", 5, [1, 2])
print(type(t)) # t为tuple类型
# 多个对象,以逗号隔开,默认为元组
t1 = 1, 2, 3, "yl"
print(t1, type(t1)) # (1, 2, 3, 'yl') <class 'tuple'>
# 从列表转换成元组
l = [1, 2, 3, 4, 3, 2, 5]
changetuple = tuple(l)
print(changetuple, type(changetuple)) # (1, 2, 3, 4, 3, 2, 5) <class 'tuple'>
# 内建函数,元组嵌套
t3 = (1, 2, 3,("a", "b"))
print(t3, type(t3)) # (1, 2, 3, ('a', 'b')) <class 'tuple'>
- 常用操作(不可变)-查询
# 元组不可改变,常用操作就是查询
t = (1, "dgfd", 5, [1, 2])
print(t[2]) # 5
print(t[-1]) # [1,2]
# 获取多个元素
# [start:end:step] 取不到end
print(t[0: 3: 1]) # (1, 'dgfd', 5)
# 反转整个元组
print(t[::-1]) # ([1, 2], 5, 'dgfd', 1)
# 获取操作
# 统计元组指定元素个数
t = (1, 2, 3, 6, 8, 4, 10)
c = t.count(2)
print(c) # 1
# 获取元组指定元素索引
idx = t.index(3)
# 元素个数
length = len(t)
print(length) # 7
# 元素中最大的数
maxNum = max(t)
print(maxNum) # 10
# 最小的数
minNum = min(t)
print(minNum) # 1
# 判定
print(1 in t) # ture
print(1 not in t) # false
# 比较
# 针对每个元素,从左到右逐一比较
result = (1, 2) > (3, 9)
print(result)
# 拼接
print((1, 5) * 3) # 三个元组 (1, 5, 1, 5, 1, 5)
print(('a', 'd', 'c') + (1, 34, 2)) # ('a', 'd', 'c', 1, 34, 2)
# 拆包
a = 12
b = 237
t = (a, b)
print(t[0], t[1]) # 12 237
a, b = (10, 12)
a, b = 10, 12 # 默认就是元组
print(a, b)
# 快速交换变量值
a = 12
b = 237
b, a = (a, b)
print(a, b) # 237 12