Python基础-列表、元组、字典、字符串（精简解析），全网最齐全。

当前位置:

首页 > Python基础教程 >

Python基础-列表、元组、字典、字符串（精简解析），全网最齐全。

一.列表

=====================================================
1.列表的定义及格式：

列表是个有序的，可修改的，元素用逗号隔开，用中括号包围的序列。

格式：变量名 = [ 元素1，元素2，元素3...]

作用：存储多个数据

列表推导式:重点

 1 '''列表推导式'''
 2 list_t = [i for i in range(10)]
 3 print(list_t)  # [0,1,2,3,4,5,6,7,8,9]
 4 
 5 '''实例'''
 6 print('实例：')
 7 for i in range(101):
 8     if i % 2 == 0:
 9         print(i)
10 
11 print("等同于实例")
12 listDouble = [i for i in range(101) if i % 2 == 0]
13 print(listDouble)

2.列表的索引：

通过索引获取表中的书记，索引从0开始

注意：不要索引越界

s = [ 'hello',a,b,c ]

print(s[1])

输出结果：a

用for循环遍历列表：

name = [ 'zs','ls','ww' ]

for i in name:

print( i )

输出结果：zs

3.列表的添加：append(), insert(), extend() 方法。

 1 # append 
 2 lst = ['悟空','八戒','唐僧']       
 3  
 4 lst.append('白骨精')      # append   向列表末尾增加指定元素
 5  
 6 print(lst)
 7  
 8 # 输出结果：   ['悟空', '八戒', '唐僧', '白骨精']
 9  
10 -------------------------------------------------------------------------------------------
11  # insert 
12 lst = ['悟空','八戒','唐僧']
13  
14 lst.insert(1,'白骨精')     # insert  往列表制定位置添加制定元素，负索引倒叙插入。超过索引插入末尾
15  
16 print(lst)
17  
18 # 输出结果： ['悟空', '白骨精', '八戒', '唐僧']
19 ------------------------------------------------------------------------------------------
20 #extend
21  
22 lst = ['悟空','八戒','唐僧']
23  
24 lst1 = ['悟空','八戒','唐僧','悟空']
25  
26 lst.extend(lst1)                # 将一个列表中的元素添加到另一个列表的尾部合并，不会去重。
27  
28 print(lst)
29  
30 # 输出结果： ['悟空', '八戒', '唐僧', '悟空', '八戒', '唐僧', '悟空']

4.列表的删除：pop()，remove()，clear()，del 方法。

 1 # pop  删除指定索引位上的元素，默认删除-1的数据
 2  
 3 lst = ['悟空','八戒','唐僧']
 4  
 5 lst.pop(1)
 6  
 7 print(lst)
 8  
 9 输出结果：['悟空', '唐僧']
10  
11 lst = ['悟空','八戒','唐僧']
12  
13 lst.pop()
14  
15 print(lst)
16  
17 输出结果：['悟空', '八戒']
18 -----------------------------------------------------------------------------------------
19 # remove 从左往右删除指定的元素，
20  
21 lst = ['悟空','八戒','唐僧']
22  
23 lst.remove('八戒')
24  
25 print(lst)
26  
27 # 输出结果：['悟空', '唐僧']
28 -----------------------------------------------------------------------------------------
29 # clear   清空列表中所有的元素，返回一个空列表
30  
31 lst = ['悟空', '八戒', '唐僧']
32  
33  
34  
35 lst.clear()
36  
37  
38  
39 print(lst)
40  
41 输出结果：[ ]
42 -----------------------------------------------------------------------------------------
43 # del    删除整个列表或列表的数据，del是python内置功能，不是列表独有的
44  
45  
46 lst = ['悟空', '八戒', '唐僧']
47  
48 del lst           
49  
50 print(lst)
51  
52 输出结果：NameError: name 'lst' is not defined   （报错）因为不存在，所有报错
=============================
del 还能指定删除某位置的数据
=============================

1 newL = [5, 8, 6, 5, 74, 5, 5, 46, 1]
2 del newL[8]  # # 删除指定索引值为8的数据，这里删除最后一个数据1
3 print(newL)  # [5, 8, 6, 5, 74, 5, 5, 46]

5.列表的查询：count()，index() 方法。

1 # count 返回指定元素在列表的个数
2  
3 lst  = ['hello','world','hello','python']
4  
5 print(lst.count('hello'))  # 输出2

1 lst = ['悟空', '八戒', '唐僧', '悟空']
2 num1 = lst.index('悟空')  # index 查看指定数据在列表的索引位置
3 print("悟空在", num1)  # 这里输出0

6.列表的修改：直接修改，方式如下：list[要修改的数据的索引值]=新的数据

1 lst = ['悟空', '八戒', '唐僧']  
2  
3 lst[0] = '白龙马'   # 将列表第一位数值为替换为‘白龙马’
4  
5 print(lst)
6  
7 输出结果：['白龙马', '八戒', '唐僧']

7.列表的切片：

 1 '''列表的切片'''
 2 listCut = [i for i in range(20) if i % 2 != 0]  # 生成0-20所有单数的列表
 3 print("例子列表", listCut)  # 输出：例子列表 [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
 4 # 输出：例子列表 [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
 5 print(listCut[0: 6])  # 0到5左边开始索引的数据 左闭右开（左边0是包含索引值，右边6是6之前的索引值）
 6 # 输出[1, 3, 5, 7, 9, 11]
 7 print(listCut[::2])  # 每隔2个数字取一个值
 8 # 输出[1, 5, 9, 13, 17]
 9 print(listCut[::-1])  # 逆序/反序排序 等同于List.reverse()
10 # 输出[19, 17, 15, 13, 11, 9, 7, 5, 3, 1]
11 print(listCut[-4:])  # 取后四位，负数是右边开始取
12 # 输出[13, 15, 17, 19]
13 print(listCut[-4:-1])  # 右边开始取，取后4位到后2位值，左闭右闭，（-4包括，-1包括）
14 # 输出[13, 15, 17]

8.列表的排序和翻转:sort()，reverse() 方法。

 1 sort（） 按照ascii码表顺序进行排序
 2  
 3 lst = ['tom', 'james', 'jerry', 'zs', 'ls']
 4  
 5 lst.sort()
 6  
 7 print(lst)  # 从小到大排序
 8  
 9 输出结果：['james', 'jerry', 'ls', 'tom', 'zs']
10  
11  
12 lst.sort(reverse=True)  # 有大到小排序
13  
14  
15 print(lst)
16  
17 输出结果：['zs', 'tom', 'ls', 'jerry', 'james']
18 ------------------------------------------------------------------------------------
19 reverse()  将列表翻转（逆序）
20  
21 lst = ['tom', 'james', 'jerry', 'zs', 'ls']
22  
23 lst.reverse()
24  
25 print(lst)
26  
27 输出结果：['ls', 'zs', 'jerry', 'james', 'tom']

9.列表的拷贝：copy()方法。

 1 浅拷贝：
 2  
 3 lst1 = ['西施','貂蝉',['悟空','八戒']
 4  
 5 lst2 = lst1.copy()   #将lst1 的内容拷贝一份给lst2,  两者的id 不一样
 6  
 7 print(lst2)
 8  
 9 lst2[0] = '杨贵妃'   #lst2 中的西施改成杨贵妃
10  
11 print(lst2)
12  
13 输出结果：['西施', '貂蝉', ['悟空', '八戒']
14          ['杨贵妃', '貂蝉', ['悟空', '八戒']
15  
16 ------------------------------------------------------------------------------------
17  
18 深拷贝：
19  
20 import copy
21  
22 lst1 = ['西施','貂蝉',['悟空','八戒']
23  
24 lst2 = copy.deepcopy(lst1)
25  
26 print(lst2)
27  
28 lst2[0] = '杨贵妃'
29  
30 print(lst2)
31  
32 输出结果：['西施', '貂蝉', ['悟空', '八戒']
33          ['杨贵妃', '貂蝉', ['悟空', '八戒']

二.元祖

=====================================================
1.元组的定义及特点:

定义：

通过()来定义：变量名=(1,2,3,4,) 。以逗号分割的，以小括号包围的序列。

通过tuple函数定义: lst=[1,2,3,4] 变量名=tuple(lst)

特点：

元组是有序的，不能更改的，由于元组不可变，所以遍历元组要比列表快。

2.元组的访问：

通过索引，默认从0开始

 1 通过索引，默认从0开始
 2  
 3 tup = (1,2.2,True,'hello')  #  获得2.2的值，一定要注意索引越界的问题
 4  
 5  
 6 print(tup[1])
 7  
 8 # 输出结果：2.2
 9 -------------------------------------------------------------------------------------------
10 通过切片：
11  
12 tup = (1,2.2,True,'hello')
13  
14 print(tup[0:4:2])
15  
16 # 输出结果：(1,True)
17 -----------------------------------------------------------------------------------------
18 访问多维元组：
19  
20 tup = (('zs',10),('ls',11),('ww',12))
21  
22 print(tup[1][0])
23  
24 # 输出结果：ls

3.使用多个变量来接受元组的值：

 1 tup = (('zs',10),('ls',11),('ww',12))
 2  
 3 name,age,height,weight = ('zs',18,1.64,150)
 4  
 5 print(name)
 6  
 7 print(age)
 8  
 9 print(height)
10  
11 print(weight)
12  
13 for name, age in tup:     #for 循环遍历多重元组，注意变量的数目一致性
14  
15     print(name,age)
16  
17  
18  
19 输出结果：          zs
20                    18
21                    1.64
22                    150
23                    zs 10
24                    ls 11
25                    ww 12

4.元组的方法：index()，count()，len() 方法。

 1 tup = ('a','b','c','c','b','a','x')
 2  
 3  
 4  
 5 print(tup.index('b'))  # index() 获取数据在元组的索引值
 6  
 7  
 8  
 9 print(tup.index('a',2,len(tup)))   # len()获取元组的长度值
10  
11  
12  
13 print(tup.count('a'))  # count() 获取数据在元组的总个数
14  
15  
16  
17  
18 输出结果： 1
19           
20          5
21              
22          2

5.一个逗号的魅力：

1 tup = (1,)
2  
3 print(tup)  # 输出结果（1，）
4  
5 tup1 = (1)
6  
7 print(tup1)  # 输出结果 1

三.字典

=====================================================

1.字典的定义及格式：

定义：字典是一个无序的，可以修改的，元素呈键对值的形式，以逗号分隔，大括号包围的序列。

格式：变量名={key：value，key：value}

注意：字典中的key是不可变的类型，value是可变类型的

定义如下：

 1 # 字典是无序的数据集合
 2 # 键（key）值（value）对
 3 # 键只能使用字符串，元组 ，数字（不可变），值可以是任何的数据类型
 4 tony = {
 5     "name": "TONY",
 6     "age": 27,
 7     "height": 1.73,
 8     "weight": 55,
 9       6: (6,),
10       (7,): ()
11 }
12 print(tony)
13 # 输出为：{'name': 'TONY', 'age': 27, 'height': 1.73, 'weight': 55, 6: (6,), (7,): ()}

取值如下：

1 tony_dic = {"name": 'tony', "height": 1.73, (6,): (7,)}
2 # 字典的取值
3 print(tony_dic["

栏目列表