一、list 串列
1、串列的特点
有序的，元素可以重复，串列中的元素可以进行增上改查，可以存放不同的资料型别
2、创建串列
-
中括号创建并填充 --->[]
-
通过建构式创建 list()
-
串列推导式 --->
[x for x in li if x ...]
"""创建串列""" # 1、通过建构式创建 list() li = list() print(li, type(li)) li1 = list('helloworld') print(li1, type(li1)) # 2、中括号创建并填充 [] li2 = [1, 2, 3, 4, 4] li3 = ['helloworld', 'apple'] li4 = [1, 3.4, True, 'tea', [1, 2, 3]] print(li2, type(li2)) print(li3, type(li3)) print(li4, type(li4)) # 3、串列推导式 li5 = [i for i in range(1, 10) if i % 2 == 0] print(li5, type(li5))
3、串列索引
-
默认正向索引，编号从 0 开始，
-
支持反向索引，编号从-1 开始，
"串列索引" list1 = [1, 3, 5, 6, 8, 10] # 默认正向索引，编号从 0 开始， print(list1[0]) print(list1[3]) # 支持反向索引，编号从-1 开始， print(list1[-6]) print(list1[-3])
4、串列切片 [start:stop:step]
-
start 值: 指示开始索引值，如果没有指定，则默认开始值为 0；
-
stop 值: 指示到哪个索引值结束，但不包括这个结束索引值，如果没有指定，则取串列允许的最大索引值；
-
step 值: 步长值指示每一步大小，如果没有指定，则默认步长值为 1，
-
三个值都是可选的，非必填
li = ['h', 'o', 'g', 'w', 'a', 'r', 't', 's'] print(li[2:4]) print(li[3:6]) print(li[2:7]) print(li[2:]) print(li[3:6:2]) print(li[2:8:4]) print(li[2:8:]) print(li[2::]) print(li[:2]) print(li[::3]) print(li[::-1]) # 逆序列印
5、串列运算子
-
重复
-
使用
*运算子可以重复生成串列元素，
-
-
合并
-
使用
+加号运算子，可以将两个串列合二为一
li1 = [1, 2] * 5 li2 = [1, 2, 3] li3 = [1, 2, 4, 5] # 重复 使用 `*` 运算子可以重复生成串列元素， print(li1) # 合并 使用 `+` 加号运算子，可以将两个串列合二为一， print(li2 + li3)
6、串列成员检测
-
in：检查一个物件是否在串列中，如果在则回传 True，否则回传 False，
-
not in：检查一个串列是否不包含某个元素，如果不在回传 True，否则回传 False，
li3 = [1, 2, 4, 5] print(1 in li3) print(6 not in li3) print(8 is li3)
7、串列方法
-
append()
append(item)：将一个物件 item 添加到串列的末尾， |
|---|
| 入参：物件 item |
| 回传：None |
# append() list1 = [] print(list1) list1.append(1) list1.append(3.14) list1.append("apple") print(list1)
- extend()
extend(iterable)：将一个可迭代物件的所有元素，添加到串列末尾， |
|---|
| 入参：可迭代物件 iterable |
| 回传：None |
# extend() list1 = [1, 2, 3, 4, 'apple'] print(list1) list1.extend('HelloWorld') # 添加的是字符串的所有字母 list1.extend([8, 89, 185]) # 接收串列的所有元素 list1.extend((1, 5)) # 接收元组的所有元素 list1.extend({"a": 1}) # 接收字典的所有key值 print(list1)
- insert()
insert(index, item)：将一个物件插入到指定的索引位置 |
|---|
| 入参：索引值 index ，一个物件 item |
| 回传：None |
| 原索引位置及后面的元素后移一位 |
# insert() lis1 = [1, 2, 4, 6, 9] print(lis1) lis1.insert(0, 3) print(lis1) lis1.insert(4, "apple") print(lis1)
- pop()
pop(index) 或 pop() |
|---|
| 弹出并回传所指定索引的元素， |
| 入参：索引值 index，可不传 |
| 回传：指定索引的元素 |
| 回传：未指定索引则回传末尾元素 |
| 如果索引值不正确，或者串列已经为空，则引发 IndexError 错误 |
# pop() letters = ['h', 'o', 'g', 'w', 'a', 'r', 't', 's'] print(letters, len(letters)) # letters.pop(8) # 报错：IndexError: pop index out of range letters.pop(0) print(letters, len(letters)) letters.pop() print(letters, len(letters)) letters.pop() print(letters, len(letters)) letters.pop(3) print(letters, len(letters))
- remove()
remove(item) |
|---|
| 移除串列中第一个等于 item 的元素 |
| 入参：指定元素 item |
| 回传：None |
| 目标元素必须已存在，否则会报 ValueError |
# remove() letters = ['h', 'o', 'g', 'w', 'a', 'r', 't', 's'] print(letters, len(letters)) # letters.remove('p') # 报错，不存在 ValueError: list.remove(x): x not in list letters.remove('t') print(letters, len(letters))
- sort()
sort(key=None, reverse=False) |
|---|
| 对串列进行原地排序，只使用 < 来进行各项间比较， |
| 入参：支持 2 个关键字自变量： |
key：指定带有一个自变量的函式，用于从每个串列元素中提取比较键， |
reverse：默认值为 False 表示升序，为 True 表示降序 |
| 回传：None |
# sort() nums = [2, 4, 3, 1, 5] print(nums) # 不传自变量，默认升序，数字从小到大排列 nums.sort() print(nums) # 指定key=len，按元素的长度排序 words = ['Python', 'Java', 'R', 'Go'] print(words) words.sort(key=len) print(words) # 指定reverse=True，降序 lis1 = [1, 2, 4, 6, 9] print(lis1) lis1.sort(reverse=True) print(lis1)
- reverse()
reverse()：将串列中的元素顺序反转 |
|---|
| 自变量：无 |
| 回传：None |
| 反转只是针对索引值，元素之间不相互比较， |
# reverse() nums = [8, 1, 5, 2, 77] print(nums) nums.reverse() print(nums)
8、串列嵌套
-
创建嵌套串列
-
访问嵌套串列的元素
"""串列嵌套""" # 创建嵌套串列 num = [[1, 2, 3], [3, 8, 98]] print(num, len(num)) # 访问嵌套串列的元素 print(num[0][1]) print(num[1][2]) num[1].append("李梓杰") print(num)
9、串列推导式
| 串列推导式是指回圈创建串列，相当于 for 回圈创建串列的简化版 |
|---|
语法：[x for x in li if x ...] |
"""串列推导式""" # 语法：[x for x in li if x ...] # 实体1：将 1-10 中的所有偶数平方后组成新的串列 # 普通的 result = [] for a in range(1, 11): if a % 2 == 0: result.append(a ** 2) print(result) # 串列推导式 res = [b ** 2 for b in range(1, 11) if b % 2 == 0] print(res) # 实体2：将 20-30 中的所有基阵列成新的串列 # 普通 d = [] for c in range(20, 31): if c % 2 != 0: d.append(c) print(d) # 串列推导式 f = [v for v in range(20, 31) if v % 2 != 0] print(f)
二、tuple 元组
1、元组的特点
有序，元素可以重复，元组中的元素是不可以修改的，可以存放不同的资料型别
2、创建元组
-
使用逗号分隔
-
通过小括号填充元素
-
通过构造方法 tuple(iterable)
"""创建元组""" # 1、使用逗号分隔 tup1 = 1, 2, 3 print(tup1, type(tup1)) # 2、过小括号填充元素 tup2 = (1, 2, 3, 4, 5) tup3 = (1, 2, 4.5, True, "TTTT", (1, 2, 3), [1, 99, 555]) print(tup2, type(tup3)) print(tup3, type(tup3)) # 3、通过构造方法 tuple(iterable) a = tuple() print(a, type(a)) a1 = tuple((1, 2, 3)) # 添加组，单个无法添加 print(a1, type(a1)) a2 = tuple([1, 2, 4]) print(a2, type(a2))
3、元组索引
-
正向索引，默认编号从 0 开始
-
反向索引，默认编号从-1 开始
"""元组索引""" # 正向索引，默认编号从 0 开始 tup2 = (1, 2, 3, 4, 5) print(tup2[2]) tup1 = (range(1, 9)) print(tup1[3]) # 反向索引，默认编号从-1 开始 print(tup2[-3]) print(tup1[-3])
4、元组切片[start: stop: step]
"""元组切片""" tup2 = (1, 2, 3, 4, 5, 8, 9) print(tup2[:]) # 打印整个元素 print(tup2[:-2]) print(tup2[2:4]) print(tup2[2:7:2])
5、元组常用方法
-
index()
index(item) |
|---|
| 回传与目标元素相匹配的首个元素的索引， |
| 目标必须在元组中存在的，否则会报错ValueError |
# 1、index() # 查看元组中元素的索引值 tup2 = (1, 2, 3, 4, 5, 8, 9) print(tup2.index(3)) print(tup2.index(9)) # print(tup2.index(20)) # 目标必须在元组中存在的，否则会报错 ValueError: tuple.index(x): x not in tuple tup3 = ('H', 'e', 'l', 'l
标签:
0 评论