Python基础语法4

• 列表和元组->比较重要的内置类型–>这两个类型可以对标 c/c++/java 的数组
  • 元组不能被修改,列表可以
  • 变量就是内存空间,用来表示存储的数据
  • 列表和元组类型创建出来的一个变量就可以表示多个数据
  • 列表和元组大部分功能一样,不过二者有一样不太不同
    • 列表是可变的,创建好了随时改
    • 元组是不可变的，创建好了不可变
  • 列表
    • python 中列表中元素可以同时放任意类型的元素
    • 列表创建的两种方式
      1. 字面值创建:a=[]->[]就表示空列表
         • 在[]里指定创建的初始值,这些初始值用,分隔就可以创建非空列表
      2. 使用 list 创建:a=list()->list()表示创建的是空列表,注意这里的 list 方法也只能创建空列表
    • 下标访问列表元素:a[下标]即可访问->下标从 0 开始访问
      • python 中下标可以写成负数,下标-a代表倒数第 a 个下标->例:a=[1,2,3,4];print(a[-1])其含义是:print(len(a)-1)
      • 列表下标访问超出列表的下标会抛异常
• len 内建函数的参数有:字符串、列表、元组

列表的创建和下标访问

#创建空列表
#方式1
a=[]
print(type(a))#list类型
#方式2
b=list()
print(type(b))
#创建非空列表
c=[1,2,3,4]
print(a) #打印结果:[1,2,3,4]d=[1,'hello',True,[4,5,6]]e=[1,2,3,4]
print(a[0])#int类型f=[1,2,3,4]
f[3]=100
print(f)#[1,2,3,100]
#可以使用内建函数len()获取列表的长度
print(len(f))#长度为4
#负数下标演示
z=[1,2,3,4]
print(z[-1]) # 4

• 列表的切片:切出一个列表的一个子集,切片的返回值是切出来的对应子集列表
  • 列表名[[begin]:[end]]–> 把下标[begin,end)对应元素切出来
  • 列表名[[begin]:]–>把下标 begin 开始一直切到下标最后闭区间的位置
  • 列表名[:[end]]–> 从下标的 0 开始一直切到下标 end 开区间的位置
• 切片操作是一个比较高效的操作,进行切片时,只是取出了列表原有的一个部分,并不涉及数据拷贝,切片操作还可以指定步长
  • 切片指定步长演示:列表名[[begin]:[end]:[步长]]
    • 步长可以为负数代表从右往左取值–>内建函数 range 也是如此
    • 列表 begin/end 超出有限范围不会报错只会尽可能把满足要求的元素切出来

切片演示

a=[1,2,3,4]
print(a[1:3]) # 2,3
b=a[0:1]
print(b) #1print(a[0::1])#1,2,3,4

列表元素的遍历

#for循环遍历
a=[1,2,3,4,5]
for i in a:i+=10 #这里改动的是临时变量i,并不会改变列表a的元素print(i)for j in range(0,len(a)):a[j]+=10 #这里改动的就是列表a里的元素print(a[j])# while循环遍历
i:int=0
while i<len(a):print(a[i])

• 列表的插入
  • append(元素) 列表最后元素尾插函数
  • insert([指定下标位置],元素)->在指定下标位置头插
• 对象就是变量,但部分对象内部存在函数,这种函数又叫叫方法->使用[对象].[方法]

列表插入操作

#使用appand在列表插入元素
a=[1,2,3,4]
a.append(5)
a.append('success')
print(a) #1,2,3,4,5,success
a.insert(0,"OK")
print(a) #OK,1,2,3,4,5,success

• 列表查找
  • 列表中[]比 in/not in 查找元素高,而字典是[]和 in/not in 效率一样
  • 操作符 in:[元素]in[列表/元组]–>如果元素在列表里就返回 True 反之返回 False
  • 操作符 not in:[元素]not in[列表/元组]就是对 in 操作符返回的结果逻辑取反
  • index 方法可得到列表对应元素的下标,不存在就异常

列表查找演示

a=[1,2,3,4]
print(1 in a) #True
print(100 in a) #False
print(a.index(2))

列表删除演示

• 列表删除元素
  • pop() 函数默认无参会在列表最后元素的尾删,也可以给下标进行指定位置删除
  • remove()按照要删除的值删除

#pop函数演示
a=[1,2,3,4]
a.pop()
a.pop(0) #删除下标0对应元素
#remove演示
a=[1,2,3,4]
a.remove(4) # 删除值为4的元素

• 列表的拼接

  • 操作符+来进行拼接
  • extend 该方法函数是把后一个列表拼接到前一个列表里,拼接成功不返回(none 啥都没有的表示)
  • +=来进行拼接

• extend 方法不产生临时变量,+=产生临时变量,因此 extend 比+=高效一些

多个列表的拼接

# +来进行列表拼接
a=[1,2,3,4]
b=[5,6,7,8]
c=a+b #c=[1,2,3,4,5,6,7,8]
#extend
a=[1,2,3,4]
b=[5,6,7,8]
c=a.extend(b)
print(a)#[1,2,3,4,5,6,7,8]
print(c)#none
#+=操作
a=[1,2,3,4]
b=[5,6,7,8]
a+=b
print(a)#[1,2,3,4,5,6,7,8]

• 元组
  • 创建方式
    1. [元组名]=()
    2. [元组名]=tuple()–>使用tuple()函数这种方式只能创建空的元组
  • 元组内部的元素可以是任意类型组合的
  • 下标访问可以元组元素
    • 注意如果访问下标超出元组下标的最大值会报错
  • 元组也可以切片
  • 元组本身不可以被任何的修改
  • 元组可以用+拼接成一个新元组变量
  • 多元赋值的底层原理就是返回一个元组

元组演示

#创建元组
# 方式1
a=(1,2,3,4)
# 方式2
b=tuple()
#下标访问元组内部元素
print(a[0])
# for循环遍历元素
for element in a:print(element)# +两个元组拼接
a=(1,2)
b=(3,4)
c=a+b
print(c) #(1,2,3,4)
#多元赋值底层原理演示
def getPoint():return 10,20  # 返回值是元组类型 <class 'tuple'>x,y=getPoint()print(getPoint)

• 元组是不可变对象,不可变对象可以被哈希–>元组可以被哈希(可以作为字典内部存放的键(key值))

  • 列表就是可变对象所以不可被哈希

• 序列

  • 序列：内容连续且有序并可使用下标索引的一类数据容器
  • 序列容器有：列表、元组、字符串
  • 序列容器可被切片
    • 切片就是将老序列容器分割出一组新的子序列容器