python编程基础-4

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