文章目录
- 一、列表
- 1. 什么是列表
- 2. 访问列表中的值
- 3. 列表的赋值
- 3.1 在列表中增加元素
- 3.2 在列表中查找元素
- 3.3 在列表中修改元素
- 3.4 在列表中删除元素
- 4. 列表的循环遍历
- 4.1 random 随机数
- 4.2 列表的循环遍历
- 5. 列表的排序操作
- 5.1 升序和降序排序
- 5.2 冒泡排序
- 5.3 选择排序
- 5.4 插入排序
- 6. 列表的嵌套
- 二、元组
- 1. 什么是元组
- 2. 元组的基本操作
- 3. 元组的内置函数
- 4. 元组的循环遍历
- 三、字典
- 1. 什么是字典
- 2. 字典的基本操作
- 2.1 根据键访问值
- 2.2 添加和修改字典的元素
- 2.3 删除字典的元素
- 2.4 获取字典的键视图
- 2.5 获取字典的值视图
- 2.6 获取字典的元素视图
- 3. 字典的遍历
- 3.1 遍历字典的键
- 3.2 遍历字典的值
- 3.3 遍历字典的元素
- 3.4 遍历字典的键值对
一、列表
1. 什么是列表
- 序列是 Python 中最基本的数据结构。序列中的每个值都有对应的位置值，称之为索引，第一个索引是 0，第二个索引是 1，依此类推；
- 列表是最常用的 Python 数据类型，它可以作为一个方括号内的逗号分隔值出现；
- 列表的数据项不需要具有相同的类型，创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。
- 如下所示：
list1 = ['Google', 'Runoob', 1997, 2000]
list2 = [1, 2, 3, 4, 5 ]
list3 = ["a", "b", "c", "d"]
list4 = ['red', 'green', 'blue', 'yellow', 'white', 'black']2. 访问列表中的值
- 与字符串的索引一样，列表索引从 0 开始，第二个索引是 1，依此类推；
通过索引列表可以进行截取、组合等操作。
- 示例
list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print( list[0] )
print( list[1] )
print( list[2] )
#输出结果
red
green
blue- 索引也可以从尾部开始，最后一个元素的索引为 -1，往前一位为 -2，以此类推。
- 示例
list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print( list[-1] )
print( list[-2] )
print( list[-3] )
#输出结果
black
white
yellow- 使用下标索引来访问列表中的值，同样你也可以使用方括号
[]的形式截取字符，如下所示：
nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]
print(nums[0:4])
#输出结果
[10, 20, 30, 40]- 使用负数索引值截取，如下
list = ['Google', 'Runoob', "Zhihu", "Taobao", "Wiki"]
print ("list[1]: ", list[1]) # 读取第二位
print ("list[1:-2]: ", list[1:-2]) # 从第二位开始（包含）截取到倒数第二位（不包含）
#输出结果
list[1]: Runoob
list[1:-2]: ['Runoob', 'Zhihu']3. 列表的赋值
#示例
lst=[1,2,3,4,5,6]
lst.append(10) #列表末尾追加10
lst.append(8) #列表末尾追加8
lst[0:2]=7,9 #把下标0和2的值1，2替换成7，9
print(lst)
#输出结果
[7, 9, 3, 4, 5, 6, 10, 8]
------------------------------------------------------------------------------------------------
list.append(元素) #在列表尾部追加元素
list[index]=元素 #把对应下标的值改为元素
list[index]=元素1,元素2 #默认变为元组插入该位置
list[index1,index2]=元素1,元素2 #会按位插入
list[index1,index2]=元素1,元素2,元素3... #会替换插入
list[index1,index2]=元素1 #值比位置少的情况下不能插入，会报错3.1 在列表中增加元素
- 在列表中增加元素的方式有多种，具体如下:
① 通过append可以向列表添加元素。
② 通过extend可以将另一个列表的元素添加到列表中
③ 通过insert可以在指定位置前插入元素。
PS：
insert消耗资源多，尽量避免使用
- 示例
lst=[1,2,3,4,5]
lst2=[50,90,80]
lst.extend(lst2) #在lst后面追加lst2的值
print(lst)
#输出结果
[1, 2, 3, 4, 5, 50, 90, 80]#add和extend的区别在于，extend是直接将值加入到lst当中了，而add会返回追加后的结果，并且原本的值是不变的
lst=[1,2,3,4,5]
lst2=[50,90,80]
a=lst.__add__(lst2) #用a来接收它返回的值
print(lst.__add__(lst2))
print(a)
#输出结果
[1, 2, 3, 4, 5, 50, 90, 80]
[1, 2, 3, 4, 5, 50, 90, 80]lst=[1,2,3,4,5]
lst.append(10)
lst.append(8)
print(lst)
lst.insert(0,66) #在下标为0的位置插入66
print(lst)
#输出结果
[1, 2, 3, 4, 5, 10, 8]
[66, 1, 2, 3, 4, 5, 10, 8]3.2 在列表中查找元素
在列表中查找元素的运算符包括：
-
in如果存在那么结果为True，否则为False -
not in如果不存在那么结果为True，否则为False
lst=[1,2,3,4,5]
print(5 in lst)
print(6 in lst)
print(5 not in lst)
print(6 not in lst)
print(lst.index(4)) #index也可以查找元素，并且可以查到在哪个位置
#输出结果
True
False
False
True
33.3 在列表中修改元素
列表元素的修改也是通过下标来实现的
- 示例
lst=[1,2,3,4,5]
lst[1],lst[3]=22,66
lst[0:5]=55,66 #多个元素替换多个位置的值
print(lst)
#输出结果
[1, 22, 3, 66, 5]
[55, 66]3.4 在列表中删除元素
删除列表元素的常用方法有三种，具体如下：
-
del：根据下标进行删除
lst=[1,2,3,4,5]
del lst[0]
print(lst)
del lst[0:3] #批量删除
print(lst)
#输出结果
[2, 3, 4, 5]
[5]-
pop：删除最后一个元素
lst=[1,2,3,4,5]
lst.pop() #也可以指定下标删除
print(lst)
#输出结果
[1, 2, 3, 4]-
remove：根据元素的值删除
lst=[1,2,3,4,5]
lst.remove(3) #根据指定的值来删除
print(lst)
#输出结果
[1, 2, 4, 5]4. 列表的循环遍历
4.1 random 随机数
random() 方法返回随机生成的一个实数，它在[0,1)范围内。
random() 的语法:
import random
random.random()- 示例
import random
lst=[]
for i in range(5):
lst.append(random.randint(0,100))
print(lst)
#输出结果
[0, 39, 99, 70, 30]4.2 列表的循环遍历
当随机数的范围过大的时候，不太便于查找使用，这时候就需要使用到遍历
- 使用 for 循环遍历列表
#生成随机列表
lst=[]
for i in range(5):
lst.append(random.randint(0,100))
print(lst)
#列表的遍历
for x in lst:
print(x)
#输出结果
[50, 54, 36, 23, 87]
50
54
36
23
87
---------------------------------------------------------------------------------------------
#使用长度遍历
for x in range(lst.__len__()): #lst.__len__()代表lst的长度，为5，也就是下标0到4的值
print(lst[x])
#输出结果
[50, 54, 36, 23, 87]
50
54
36
23
87- 使用 while 循环遍历列表
names_list=['xiaowang','xiaozhang','xiaohua']
length=len(names_list)
i=0
while i < length:
print(names_list)
i+=1
#输出结果
['xiaowang', 'xiaozhang', 'xiaohua']
['xiaowang', 'xiaozhang', 'xiaohua']
['xiaowang', 'xiaozhang', 'xiaohua']- 除了遍历我们还可以用来批量更改列表中的值
for x in range(lst.__len__()):
lst[x]+=1
for x in lst:
print(x)
#输出结果
[26, 81, 54, 22, 2]
27
82
55
23
3- 两种方式的区别
lst=[]
for i in range(5):
lst.append(random.randint(0,100))
print(lst)
------------------------------------------------------------------------------------------------
#type1:
for x in lst: #x是个临时变量，只是lst中每个元素的复制
print(x) #对复制的操作不能影响到元素本身
#但是如果传入的是地址，对其内容的改变是会传递到外部的
#type2:
for x in range(lst.__len__()):
print(lst[x]) #lst[x]操作的是lst元素本身
#输出结果 #可以看到返回的结果，值并没有发生变化
[17, 77, 67, 85, 40]
17
77
67
85
405. 列表的排序操作
5.1 升序和降序排序
列表的排序可以通过以下两个方式来实现：
① sort 方法：列表的元素按照特定的顺序排列
② reverse 方法：将列表逆置
- sort() 函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。
- 语法
list.sort(cmp=None, key=None, reverse=False)
#参数
cmp -- 可选参数, 如果指定了该参数会使用该参数的方法进行排序。
key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）。- 示例
#方法一：
lst=[24, 37, 91, 95, 71]
lst.sort(reverse=True) #降序排序
print(lst)
#输出结果
[95, 91, 71, 37, 24]
-------------------------------------------------------------------------------------------------
#方法二：
lst=[24, 37, 91, 95, 71]
lst.sort()
lst.reverse()
print(lst)
#输出结果
[95, 91, 71, 37, 24]5.2 冒泡排序
双重循环
外循环控制比较轮数
内层循环控制每轮比较次数
lst= [15, 24, 6, 52, 88]
for x in range(len(lst)-1): #最后一轮只剩一个元素，不需要比较，因此-1
for y in range(len(lst)-x-1):
#每轮都能确定一个最大值，所以每轮减少一次比较
if lst[y]>lst[y+1]:
tmp=lst[y]
lst[y]=lst[y+1]
lst[y+1]=tmp
print(lst)
#输出结果
[6, 15, 24, 52, 88]5.3 选择排序
选择排序：每次从前向后遍历，找到一个最小值，与该位置交换
import random
lst=[]
for x in range(10):
lst.append(random.randint(0,100))
print(lst)
for x in range(len(lst)-1): #最后一个位置不需要比较
tmp=lst[x] #每一轮定一个初始值，目的是为了和后面的值进行比较
idx=x
for y in range(x+1,len(lst)): #从初始值处向后遍历
if(tmp>lst[y]): #为了在一轮中找出最小值
tmp=lst[y] #最小值保存在tmp中
idx=y #下标保存在idx中
else:
lst[idx]=lst[x] #根据最小值下标，把初始值放进去
lst[x]=tmp #把最小值放入初始位置中
print(lst)
#输出结果
[60, 34, 83, 72, 96, 66, 3, 25, 57, 13]
[3, 13, 25, 34, 57, 60, 66, 72, 83, 96]5.4 插入排序
- 插入排序逻辑示例
#在一个有序数组中插入值并保持顺序
arr=[10,20,30,50,80]
a=int(input("请输入一个整数"))
arr.append(a)
idx=len(arr)-1
while idx>0:
#从后向前遍历
idx-=1
#遇到比自己小的，则在后方插入
if a>arr[idx]:
arr[idx+1]=a
break
#遇到比自己大的，大的值向后移动
else:
arr[idx+1]=arr[idx]
#如果到最后都没有插入，则插入在首位
if idx==0:
arr[0]=a
print(arr)
#输出结果
请输入一个整数5
[5, 10, 20, 30, 50, 80]
请输入一个整数888
[10, 20, 30, 50, 80, 888]- 插入排序示例
刚开始一个元素，即为有序，每次加入一个元素，形成新的序列，应用插入元素的逻辑，使其继续有序
import random
lst=[]
for x in range(10):
lst.append(random.randint(0,100))
print(lst)
for x in range(1,len(lst)):
idx=x
tmp=lst[x]
while x>0:
x-=1
if tmp>=lst[x]:
lst[x+1]=tmp
break
else:
lst[x+1]=lst[x]
if x==0:
lst[0]=tmp
print(lst)
#输出结果
[46, 38, 42, 57, 40, 37, 59, 57, 75, 35]
[35, 37, 38, 40, 42, 46, 57, 57, 59, 75]6. 列表的嵌套
列表的嵌套指的是一个列表的元素又是一个列表
- 示例
school_names = [['北京大学','清华大学'],['南开大学','天津大学','天津师范大学'],['山东大学','中国海洋大学']]
#嵌套列表的遍历
for x in school_names:
for y in range(len(x)):
print(x[y])
或
for x in range(len(school_names)):
for y in range(len(school_names[x])):
print(school_names[x][y])
或
for x in school_names:
for y in x:
print(y)
#输出结果
北京大学
清华大学
南开大学
天津大学
天津师范大学
山东大学
中国海洋大学二、元组
1. 什么是元组
Python的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号包裹元素，列表使用方括号包裹元素。
2. 元组的基本操作
- 示例
tpl=(1,2,3,4,5,6)
print(tpl[0])
print(tpl[0:3])
print(tpl[0:5:2])
#输出结果
1
(1, 2, 3)
(1, 3, 5)tpl=(1,2,3,4,5,6)
tpl[0]=5
print(tpl)
#输出结果我们发现报错，因为元组中的元素不能被修改
- 把元组改为列表
tpl=(1,2,3,4,5)
print(list(tpl))
#输出结果
[1, 2, 3, 4, 5]3. 元组的内置函数
方法 | 描述 |
len(tuple) | 计算元组元素个数 |
max(tuple) | 返回元组中元素最大值 |
min(tuple) | 返回元组中元素最小值 |
tuple(seq) | 将列表转为元组 |
- 示例
tpl=(1,2,3,4,5)
print(len(tpl))
print(max(tpl))
print(min(tpl))
#输出结果
5
5
14. 元组的循环遍历
tpl=(1,2,3,4,5)
for x in tpl:
print(x)
#输出结果
1
2
3
4
5三、字典
1. 什么是字典
字典是一种存储数据的容器，它和列表类似，都可以存储多个数据。
- 示例
info = {'name':'班长','sex':'f','address':'北京'}
字典的每个元素是由键和值组成的，例如，上面的’name’为键，‘班长为值’
注意：
dict 作为 Python 的关键字和内置函数，变量名不建议命名为 dict；
键一般是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一。
2. 字典的基本操作
2.1 根据键访问值
- 示例
info={'name':'班长','sex':'f','address':'北京'}
print(info['sex'])
print(info['address'])
#输出结果
f
北京- 当我们想获取某个键对应的值但又不确定该键是否存在时，可以使用get方法获取
d={"name":"大黄","age":5,"strain":"拉布拉多"} #json字符串
print(d.get("birthday"))
print(d.get("name"))
#输出结果
None
大黄2.2 添加和修改字典的元素
- 示例
d={"name":"大黄","age":5,"strain":"拉布拉多"}
d["name"]="川普" #修改元素
d["birthday"]="2021-1-17" #添加元素
print(d)
#输出结果
{'name': '川普', 'age': 5, 'strain': '拉布拉多', 'birthday': '2021-1-17'}d={"name":"大黄","age":5,"strain":"拉布拉多"}
print(d)
d.setdefault("abc","sorry") #如果key已经存在，则不做任何操作，如果key不存在，则以默认值插入
print(d)
#输出结果
{'name': '大黄', 'age': 5, 'strain': '拉布拉多'}
{'name': '大黄', 'age': 5, 'strain': '拉布拉多', 'abc': 'sorry'}2.3 删除字典的元素
del:删除字典。字典直接从内存中删除，无法再根据键访问值。clear:清空字典的元素。字典仍存在于内存中，但其中没有任何元素。
d={"name":"大黄","age":5,"strain":"拉布拉多"}
del d["strain"] #删除"strain"键和值
print(d)
d.clear() #清空字典的元素
print(d)
#输出结果
{'name': '大黄', 'age': 5, 'strain': '拉布拉多'}
{'name': '大黄', 'age': 5}
{}2.4 获取字典的键视图
keys() 方法可以获取字典的键视图，以实时反映字典中键的变化
- 示例
dct={"name":"zhangsan","age":18,"gender":"male","id":10}
keys=dct.keys()
print(keys)
dct.setdefault("birthday","2022-01") #添加一个键值
print(keys)
#输出结果
dict_keys(['name', 'age', 'gender', 'id'])
dict_keys(['name', 'age', 'gender', 'id', 'birthday'])- 遍历字典的键
dct={"name":"zhangsan","age":18,"gender":"male","id":10}
dct.setdefault("birthday","2022-01")
for k in keys:
print(k+":",dct[k])
#输出结果
name: zhangsan
age: 18
gender: male
id: 10
birthday: 2022-012.5 获取字典的值视图
values() 方法可以获取字典的值视图，以实时反映字典中值的变化。
dct={"name":"zhangsan","age":18,"gender":"male","id":10}
dct.setdefault("birthday","2022-01")
values=dct.values()
print(values)
#以列表的形式展现出来，只有值没有键
#输出结果
dict_values(['zhangsan', 18, 'male', 10, '2022-01'])- 动态实时的显示更改的结果
dct={"name":"zhangsan","age":18,"gender":"male","id":10}
keys=dct.keys()
dct.setdefault("birthday","2022-01")
values=dct.values()
dct.setdefault("now","2022-01")
print(values)
#输出结果
dict_values(['zhangsan', 18, 'male', 10, '2022-01', '2022-01'])2.6 获取字典的元素视图
items() 方法可以获取字典的元素视图，以实时地反映字典中键值对的变化。
- 示例
dct={"name":"zhangsan","age":18,"gender":"male","id":10}
keys=dct.keys()
dct.setdefault("birthday","2022-01")
itms=dct.items()
print(itms)
#输出结果
dict_items([('name', 'zhangsan'), ('age', 18), ('gender', 'male'), ('id', 10), ('birthday', '2022-01')])- 遍历字典的键值对
dct={"name":"zhangsan","age":18,"gender":"male","id":10}
keys=dct.keys()
dct.setdefault("birthday","2022-01")
itms=dct.items()
print(itms)
for x,y in itms:
print(x+":",y)
#输出结果
dict_items([('name', 'zhangsan'), ('age', 18), ('gender', 'male'), ('id', 10), ('birthday', '2022-01')])
name: zhangsan
age: 18
gender: male
id: 10
birthday: 2022-013. 字典的遍历
3.1 遍历字典的键
dict_demo={'Name':'Lisi','Age':18}
for key in dict_demo.keys():
print(keys)
#输出结果
dict_keys(['name', 'age', 'gender', 'id', 'birthday'])
dict_keys(['name', 'age', 'gender', 'id', 'birthday'])3.2 遍历字典的值
dict_demo={'Name':'Lisi','Age':18}
for value in dict_demo.values():
print(value)
#输出结果
Lisi
183.3 遍历字典的元素
dict_demo={'Name':'Lisi','Age':18}
for item in dict_demo.items():
print(item)
#输出结果
('Name', 'Lisi')
('Age', 18)3.4 遍历字典的键值对
dict_demo={'Name':'Lisi','Age':18}
for key,value in dict_demo.items():
print("key=%s,value=%s"%(key,value))
#输出结果
key=Name,value=Lisi
key=Age,value=18
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
