当前位置： 首页 > news >正文

Python 基础语法（3）【适合0基础】

news 2025/6/16 11:55:10

1. 列表和元组

1.1 列表和元组的定义

编程中，如果代码中需要表示的数据个数比较少, 我们直接创建多个变量即可

但有时, 代码中需要表示的数据特别多, 甚至也不知道要表示多少个数据. 这个时候, 就需要用到列表

Python 中列表是一种有序、可变的数据结构，可以批量存储不同类型的元素

而元组和列表相比, 是非常相似的, 只是列表中的元素可以修改调整, 元组中的元素是创建元组的时候就设定好的, 不能修改调整

1.2 创建列表和元组

创建列表和元组主要有两种方式：

# 创建列表
# 法一
# []表示一个空列表
alist = []
print(type(alist))
# 如果需要设置初始值，直接写在[]中
# 列表中存放的元素允许是不同的类型
alist = [1,'hello',True,4,5]
print(alist)# 法二
# list 本身是 Python 中的内建函数, 不宜再使用 list 作为变量名
alist = list()
print(type(alist))# 创建元组
# 法一
atuple = ()
print(atuple)# 法二
# tuple 本身是 Python 中的内建函数, 不宜再使用 tuple 作为变量名
atuple = tuple()
print(atuple)

1.3 访问下标

可以通过下标访问操作符 [ ] 来获取到列表中的任意元素，我们把 [ ] 中填写的数字, 称为 下标 或者 索引

alist = [1,2,3,4,5]
print(alist[1])
# 下标是从 0 开始计数的, 因此下标为 1 , 则对应着 2 这个元素# 下标的有效范围是 [0, 列表长度 - 1]. 使用 len 函数可以获取到列表的元素个数
alist = [1,2,3,4,5]
print(len(alist))# 通过下标可以读取元素内容, 还可以修改元素的值
alist = [1,2,3,4,5]
alist[1] = 10
print(alist)alist = [1,2,3,4,5]
# print(alist[10]) 如果下标超出列表的有效范围, 会抛出异常# 下标可以取负数,表示【倒数第几个元素】
alist = [1,2,3,4,5]
print(alist[-1])
# alist[-1] 相当于 alist[len(alist) - 1]

1.4 切片操作

如果说 下标 操作是一次取出里面的一个元素
那 切片 则是一次取出一组连续的元素, 相当于得到一个 子列表

# 使用 [ : ] 进行切片操作
alist = [1,2,3,4,5]
print(alist[1:3])
# alist[1:3] 中的 1:3 表示的是 [1, 3) 这样的由【下标】构成的【前闭后开】区间# 切片操作可以省略前后边界
alist = [1,2,3,4,5]
print(alist[1:]) # 省略后边界, 表示获取到列表末尾
print(alist[:-1]) # 省略前边界, 表示从列表开头获取,下标 -1 等同 下标 len(alist)-1
print(alist[:]) # 省略两个边界, 表示获取到整个列表 # 切片操作可以指定 "步长" , 也就是 "每访问一个元素后, 下标自增几步"
alist = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(alist[::1]) # 自增一步
print(alist[::3]) # 自增三步
print(alist[::5]) # 自增五步# 切片步长还可以是负数, 此时是【从后往前】取元素，表示 "每访问一个元素之后, 下标自减几步"
alist = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(alist[::1]) # 自减一步
print(alist[::3]) # 自减三步
print(alist[::5]) # 自减五步# 把步长和边界结合
alist = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(alist[1:6:2])
print(alist[8:2:-2])# 如果切片中的数字越界了, 不会有负面效果. 只会尽可能把满足条件的元素放入子列表
alist = [1, 2, 3, 4]
print(alist[100:200])

1.5 遍历列表元素

# 使用 for 循环生成元素
alist = [1,2,3,4,5]
for elem in alist:print(elem)# 使用 for 循环生成下标
alist = [1,2,3,4,5]
for i in range(0,len(alist)):print(alist[i])# 使用 while 循环
alist = [1,2,3,4,5]
while i < len(alist):print(alist[i])i += 1

1.6 添加元素

# 使用 append 方法, 向列表末尾插入一个元素
alist = [1, 2, 3, 4,5]
alist.append('world')
print(alist)# 使用 insert 方法, 向任意位置插入一个元素
# insert 第一个参数为要插入元素的下标
alist = [1, 2, 3, 4,5]
alist.insert(1, 'hello')
print(alist)

上述的 方法 其实就是函数，只不过函数是独立存在的, 而方法往往要依附于某个 "对象"。
像上述代码 alist.append , append 就是依附于 alist, 相当于是对 alist 这个列表, 进行尾插

1.7 查找元素

# 使用 in 操作符, 判定元素是否在列表中存在. 返回值是布尔类型
alist = [1, 2, 3, 4,5]
print(2 in alist)
print(7 in alist)# 使用 index 方法, 查找元素在列表中的下标. 返回值一个整数
alist = [1, 2, 3, 4,5]
print(alist.index(2))
# print(alist.index(6))  如果元素不存在, 则会抛异常

1.8 删除元素

# 使用 pop 方法删除末尾元素(默认尾删)
alist = [1, 2, 3, 4,5]
alist.pop()
print(alist)
# 使用 pop 按照下标删除元素
alist = [1, 2, 3, 4,5]
alist.pop(2)
print(alist)# 使用 remove 方法, 按照值删除元素
alist = [1, 2, 3, 4,5]
alist.remove(2)
print(alist)

1.9 连接列表

# 使用 + 能够把两个列表拼接在一起,生成一个新的列表. 不会影响到旧列表
alist = [1, 2, 3, 4, 5]
blist = [6, 7, 8, 9, 10]
print(alist + blist)# 使用 extend 方法, 把一个列表拼接到另一个列表的后面
# a.extend(b) , 把 b 中的内容拼接到 a 的末尾. 不会修改 b, 但是会修改 a
alist = [1, 2, 3, 4, 5]
blist = [6, 7, 8, 9, 10]
alist.extend(blist)
print(alist)
print(blist)

 1.10 名字绑定

person1 = ['10','a','11','b']
person2 = person1
person2[1] = 'c'
print(person1)
print(person2)# print(person1)结果为 ['10', 'c', '11', 'b']
# print(person2)结果为 ['10', 'c', '11', 'b']

我们将 person1 的值赋给 person2 ,修改 person2 后，person1 的值也被修改了，看起来 person1 和 person2 指向同一个列表对象,这是事实

由于列表通常较大，考虑到效率，Python 将列表从一个变量赋值到另一个变量时，并不会复制列表，而是将列表关联到另一个变量/名字上 

1.11 排序

names = ['left','right','middle','pet','average']
names.sort(key=len)
print(names)
# ['pet', 'left', 'right', 'middle', 'average']scores = [1,2,5,4,6,8,9,10]
scores.sort(reverse=True)
print(scores)
# [10, 9, 8, 6, 5, 4, 2, 1]

1. sort() 方法将列表的元素按递增排序，如果加上参数 reverse=True，按递减排序

2. 字符串比较按字典序， key=len 参数指示应用 len 函数对列表每个元素生成一个 key，按 key 的大小比较结果对元素进行排序，key 参数也可以指向一个自定义函数

3. sort() 方法会改变原列表，如果我们不希望改变原列表，可以使用sorted() 函数，sorted() 函数也可以使用 reverse 和 key 参数

names = ['left','right','middle','pet','average']
namesSorted = sorted(names)
print(namesSorted)
# ['average', 'left', 'middle', 'pet', 'right']

1.12 元组的操作

元组的功能和列表相比, 基本一致

但，元组不能修改里面的元素，列表可以修改里面的元素

比如：

读操作：访问下标, 切片, 遍历, in, index, + 等, 元组也是一样支持的
写操作：修改元素, 新增元素, 删除元素, extend 等, 元组则不能支持'

除此之外，元组很多时候是默认的集合类型，例如, 当一个函数返回多个值的时候，返回元组

def get():return 1,2
ret = get()
print(type(ret))

元组的意义：

1. 你不想你的数据被弄乱更改， 那么这时候使用元组就很安全

2. 对于字典：元组可以作为字典的键, 但列表不行

2. 字典

2.1 概念

首先要引入 键值对  的概念：把 键(key) 和 值(value) 进行一对一的映射, 然后就可以根据键,快速找到值

字典就是一种存储 键值对 的结构

2.2 创建字典

# 使用 {} 或 dict 创建一个字典
# 创建了一个空字典
a = {} 
b = dict()
print(type(a))
print(type(b))# 创建字典同时指定初始值
# 键值对之间使用 , 分割, 键和值之间使用 : 分割
# 最后一个键值对后面的 , 可写可不写
# 为了代码规范美观, 往往会把多个键值对, 分成多行来书写
adict = { 'key1': '1','key2': 1
}
print(adict)

2.3 查找 key

# 使用 in 判定 key 是否在字典中，返回布尔值
adict = {'key1': 1,'key2': '111'
}print('key1' in adict)
print('key3' in adict)# 使用 [] ,获取到元素的值,此处的 "下标" 是 key
adict = {'key1': 1,'key2': '111'
}print(adict['key1'])
print(adict['key2'])
# print(adict['key3']) 如果 key 在字典中不存在, 则会抛异常# 使用 get() 方法以参数中给定键查询字典中值对象
# 第二个参数为默认返回值,不存在第二个参数则返回None
adict = {'key1': 1,'key2': '111'
}
print(adict.get('key1'))
print(adict.get('key3'))

2.4 添加/修改元素

# 使用 [] 根据 key 来新增/修改 value
# 如果 key 不存在, 即为新增键值对
adict = {'key1': 1,'key2': '111'
}
adict['key3'] = 3
print(adict)
# 如果 key 已经存在,即为修改键值对的值
adict = {'key1': 1,'key2': '111'
}
adict['key1'] = 2
print(adict)

2.5 删除元素

# 使用 pop 方法根据 key 删除对应的键值对
adict = {'key1': 1,'key2': '111'
}
adict.pop('key1')
print(adict)

2.6 遍历元素

# 用 for 循环获取字典中的所有的 key
adict = {'key1': 1,'ky2': '111','key3': 10
}
for key in adict:print(key,adict[key])# 取出所有 key 和 value
# 使用 keys 方法获取到字典中的所有的 key
adict = {'key1': 1,'ky2': '111','key3': 10
}
print(adict.keys())
# 使用 values 方法获取字典中的所有 value
adict = {'key1': 1,'ky2': '111','key3': 10
}
print(adict.values())
# 使用 items 方法获取到字典中所有的键值对
adict = {'key1': 1,'ky2': '111','key3': 10
}
print(adict.items())

 此处 dict_keys 、dict_values、dict_items 是特殊的类型，大部分元组支持的操作对于它们同样适用

2.7 合法 key

不是所有类型都可以作为字典的 key
字典本质上是一个 哈希表, 哈希表的 key 要求是 "可哈希的", 也就是可以计算出一个哈希值

# 使用 hash 函数计算某个对象的哈希值,能够计算出哈希值的类型, 都可以作为字典的 key
print(hash(0))
print(hash('hello'))
print(hash(True))
print(hash(()))  # ()是一个元组# print(hash[1,2]) 列表无法计算哈希值
# print(hash({'key': 1})) 字典无法计算哈希值

3. 字符串进阶

前文已经介绍了字符串的占位符替换和 format() 方法

接下来会有更多常见的字符串处理方法

# find() 方法
# find() 方法用于在字符串中查找指定子串位置,返回子字符串开始下标
# 语法格式 find(sub,beg,end)
# sub 表示指定检索的字符串
# beg 表示开始索引的下标,默认为0
# end 表示结束索引的下标,默认为字符串的长度
# beg,end 可以省略s = "hello world hello Python"
print(s.find("Python",0,len(s)))# s.find("Python",0,len(s)) 表示从下标 0 开始 ，到 len(s)（不含len(s)) 结束，查找"Python"# join() 方法
# join() 方法将序列里多个字符串用指定间隔字符串拼接
# 语法格式 s.join(seq)
# s 为指定的间隔字符串
# seq 表示要连接的元素序列,可以是元组或列表，但其中元素必须是字符串
numbers = ["1","2","3"]
print("+".join(numbers))# replace 方法
# replace() 方法将字符串内指定子串全部替换为另一个子串
# 语法格式 replace(old,new,count==-1)
# old 表示被替换的子字符串
# new 表示用于替换的新字符串
# count 表示替换的次数，默认-1，表示不作限制，全部替换
s = "hello world hello Python"
sNew = s.replace("hello","wowo")
print(s)
print(sNew)# split() 方法
# split() 方法用于把一个字符串用指定的间隔符拆开成多个字符串，并放入列表返回
# 语法格式 split(sep=None,maxsplit=-1)
# sep 默认为 None,表示使用空白字符作为分隔符
# maxsplit为最大拆分次数，默认为-1,表示不限制
print("1+2+3+4+5".split("+"))

http://www.xdnf.cn/news/1056133.html

相关文章：

  • 你听过网关支付吗？它是什么？
  • 2.7 获取激光雷达数据与避障
  • 重复文件检测提取（C#编写的winform项目源码）
  • 柬埔寨 - 高棉语 点阵方式详解
  • 华晨宇火星演唱会郑州开唱 中西乐交融编曲再升级
  • linux 下 Doris 单点部署
  • 2.4.2 ASPICE的集成与系统测试
  • 1688 API 接口接入说明与文档
  • 键盘效率提升实战，快速训练指法与速度
  • PLC基础知识整理(三菱) - 扩展
  • Pico rp2040开发之Vscode插件+ c/c++独立环境搭建
  • 端侧大模型：边缘智能的破局之战——资源约束下的技术突围
  • cocos2 使用 Layout 组件后，子节点 Label 高度变化后，抖动问题
  • 第一章 绪论
  • Java事务隔离问题详解：脏读、不可重复读与幻读（含解决方案）
  • SpringCloud框架全面学习指南
  • strcpy 和 memcpy
  • Java的抽象类
  • Database Client：一款流行的VS Code数据库客户端插件
  • 修改Rocky Linux文件夹颜色
  • LangGraph-example 学习
  • Flask蓝图
  • 统信UOS 操作系统源码制作openssh 10.0p2 rpm包——筑梦之路
  • 去噪扩散概率模型（DDPM）全解：从数学基础到实现细节
  • 基于机器学习的逐巷充填开采岩层运动地表沉降预测
  • 将扩展的DuckDB自定义函数整合到一个程序
  • 三极管综述
  • Thinkless：基于RL让LLM自适应选择长/短推理模式，显著提升推理效率和准确性！！
  • 爆肝整理，python接口自动化测试整理，基础进阶一套打通...
  • 数据治理域——数据应用设计