列表基本操作&内置方法
列表基本操作
列"表"来了
列表内一般都会存储相同数据类型的数据
- list的类型转换
数据类型关键字(需要转换的数据)
print(list(123)) # 报错
print(list(123.22)) # 报错
print(list('hello')) # ['h','e','l','l','o']
print(list({'username':'jason', 'pwd':123})) # ['username', 'pwd']
# 只有key在列表当中
print(list((11, 22, 33))) # [11,22,33]
print(list({11,22,33})) # [33,11,22] 无序
# list关键字可以将支持for循环的数据类型转换成列表
列表内置方法
name_list = ['jason', 'jack', 'tony', 'duke']
print(name_list[1:3]) # 切片 ['jack', 'tony']
print(name_list[0:4:2]) # 步长 ['jason', 'tony']
print(name_list[-1:-4:-1]) # 反向切片 ['duke', 'tony', 'jack']
# 统计列表中元素的个数
print(len(name_list)) # 4
必须掌握的
- 增、改
1.修改值
name_list[0] = 'alvin'
2.添加值
# 1. append尾部追加元素(括号内的数据当成一个整体追加到列表末尾，)
name_list.append('追加的')
# 2. insert插入元素(括号内的数据当成一个整体插入到指定位置，)
name_list.insert(0, '插入的')
# 3. extend扩展元素(底层相当于for循环+append)
name_list.extend([111,222,333,444])
- 删除
方式一：del通用的删除方式根据索引直接删除
name_list = ['jason', 'jack', 'tony', 'duke']
del name_list[1]
方式二：remove()括号内指定需要移除的元素
name_list.remove('jason')
方式三：pop()弹出的值可以取到。
del_word = name_list.pop(1) # 根据索引弹出，弹出的值可以取到
print(del_word) # jack
name_list.pop() # 不写参数默认弹出尾部参数
可变类型与不可变类型
可变类型：值改变 内存地址不变，修改的是原值
# 测试 集合
set1 = {1, 2, 3, 4}
print(id(set1), type(set1), set1)
set1.add(88)
print(id(set1), type(set1), set1)
"""
1637988509728 <class 'set'> {1, 2, 3, 4}
1637988509728 <class 'set'> {1, 2, 3, 4, 88}
"""
# 测试列表
lis1 = [1, 2, 3, 4]
print(id(lis1), type(lis1), lis1)
lis1.append(88)
print(id(lis1), type(lis1), lis1)
"""
2169931235008 <class 'list'> [1, 2, 3, 4]
2169931235008 <class 'list'> [1, 2, 3, 4, 88]
"""
以此类推，测试元组，
tup1 = (1, 2, 3, 4, [12, 34, 56])
print(id(tup1), type(tup1), tup1)
tup1[4].append(888)
print(id(tup1), type(tup1), tup1)
"""
2528056840816 <class 'tuple'> (1, 2, 3, 4, [12, 34, 56])
2528056840816 <class 'tuple'> (1, 2, 3, 4, [12, 34, 56, 888])
但是我们不能以此说明元组是可变类型，元组的定义就是不可变的，我们修改了元组中列表的值，
但是因为列表是可变数据类型，所以虽然在列表中更改了值，但是列表的地址没有改变，列表在元组中的地址的值也就没有改变，
所以也就意味着元组没有发生变化。我们就可以认为元组是不可变数据类型，因为元组是不可变的。
"""
# 测试字典时，也会发现
tuple = (1)
d = { tuple:1,'key2':'djx','key3':'li'}
print(d,type(d),id(d))
d['key4'] = 'haha'
print(d,type(d),id(d))
"""
{<class 'tuple'>: 1, 'key2': 'djx', 'key3': 'li'} <class 'dict'> 2322053173952
{<class 'tuple'>: 1, 'key2': 'djx', 'key3': 'li', 'key4': 'haha'} <class 'dict'> 2322053173952
"""
据此我们可以知道：列表，集合，字典，是可变数据类型
不可变类型：值改变 内存地址肯定变，产生了新值
字符串，整型，浮点型，元组，是不可变数据类型
队列与堆栈 作业！！
队列：FIFO 先进先出first in first out
堆栈：FILO 先进后出(叠衣服)
用列表及内置方法，模拟出上述两个数据结构的特性
放几个数，取几个数，模拟队列/堆栈的特性实现。
# 定义一个存放名字的空列表
name_list = []
while True:
name = input('请输入您的名字(q/Q退出)>>>:').strip()
if name.upper() == 'Q':
break
# 向列表中追加输入的名字
name_list.append(name)
# 队列取值，直接for循环实现，先进先出
for i in name_list:
print(i)
# 堆栈取值，用步长实现列表倒叙取值，实现先进后出
for j in range(len(name_list)-1, -1, -1):
print(name_list[j])
# 直接通过索引取值，实现列表翻转输出，先进后出
for k in name_list[::-1]:
print(k)
列表内置方法补充在这里
排序
# 1.sort
l1 = [44,22,88,42,99,11,33,66]
# l1.sort() # 列表排序，默认是升序
print(l1) # [11, 22, 33, 42, 44, 66, 88, 99]
# l1.sort(reverse=True) # 改为降序排列
print(l1) # [99, 88, 66, 44, 42, 33, 22, 11]
# 2.reverse
# l1.reverse() 将原列表顺序颠倒
print(l1) # [66, 33, 11, 99, 42, 88, 22, 44]
# l1.clear() 清空列表
比较运算
# 列表比较运算采用相同索引元素比较，只要有一个比出了结果，就直接得出结论
l1 = [99,33,11,44]
l2 = [11,22,33]
print(l1 > l2) # True
# 字符串比较大小也是按照索引位置内部转成ASCII码对应的数字比较
s1 = 'hello world'
s2 = 'abc'
print(s1 > s2) # True
