Python学习笔记列表、元组、字符串 DAY4

程序员文章站 2022-03-08 10:30:09

...

列表（list）

在学习列表前我觉得有必要先简述一下序列：

一.序列（sequence）

序列是Python中最基本的一种数据结构
数据结构指计算机中数据存储的方式
序列用于保存一组有序的数据，所有的数据在序列当中都有一个唯一的位置（索引），并且序列中的数据会按照添加的顺序来分配索引
序列的分类：
可变序列（序列中的元素可以改变）：
> 列表（list）
不可变序列（序列中的元素不能改变）：
> 字符串（str）
> 元组（tuple）

列表前述：

列表是Python中的一个对象
对象（object）就是内存中专门用来存储数据的一块区域
之前我们学习的对象，像数值，它只能保存一个单一的数据
列表中可以保存多个有序的数据
列表是用来存储对象的对象
列表的使用：
1.列表的创建
2.操作列表中的数据

二. 列表的定义

列表是有序集合，没有固定大小，能够保存任意数量任意类型的 Python 对象，语法为 [元素1, 元素2, ..., 元素n]。

关键点是「中括号 []」和「逗号 ,」
中括号把所有元素绑在一起
逗号将每个元素一一分开

三.创建列表

创建列表的方法：

直接创建一个普通列表
利用range()创建列表
利用推导式来创建列表

# 创建列表，通过[]来创建列表
my_list = [] # 创建了一个空列表
# print(my_list , type(my_list))

# 列表存储的数据，我们称为元素
# 一个列表中可以存储多个元素，也可以在创建列表时，来指定列表中的元素
my_list = [10] # 创建一个只包含一个元素的列表

# 当向列表中添加多个元素时，多个元素之间使用,隔开
my_list = [10,20,30,40,50] # 创建了一个保护有5个元素的列表

# 列表中可以保存任意的对象
my_list = [10,'hello',True,None,[1,2,3],print]

# 列表中的对象都会按照插入的顺序存储到列表中，
#   第一个插入的对象保存到第一个位置，第二个保存到第二个位置

注：由于list的元素可以是任何对象，因此列表中所保存的是对象的指针。即使保存一个简单的[1,2,3]，也有3个指针和3个整数对象。

x = [a] * 4操作中，只是创建4个指向list的引用，所以一旦a改变，x中4个a也会随之改变。

1.range()

range()是一个函数，可以用来生成一个自然数的序列（之前学习过，这里回顾一下）

# range()是一个函数，可以用来生成一个自然数的序列
r = range(5) # 生成一个这样的序列[0,1,2,3,4]
r = range(0,10,2)
r = range(10,0,-1)
# 该函数需要三个参数
#   1.起始位置（可以省略，默认是0）
#   2.结束位置
#   3.步长（可以省略，默认是1）

# print(list(r))

# 通过range()可以创建一个执行指定次数的for循环
# for()循环除了创建方式以外，其余的都和while一样，
#   包括else、包括break continue都可以在for循环中使用
#   并且for循环使用也更加简单
# 将之前使用while循环做的练习，再使用for循环完成一次！
for i in range(30):
    print(i)

# for s in 'hello':
#     print(s)

四.向列表中添加元素

list.append(obj) 在列表末尾添加新的对象，只接受一个参数，参数可以是任何数据类型，被追加的元素在 list 中保持着原结构类型。
list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
list.insert(index, obj) 在编号 index 位置插入 obj。

# 向列表中添加元素
stus = ['孙悟空','猪八戒','沙和尚','唐僧']
# print('原列表：',stus)

# append()
# 向列表的最后添加一个元素
stus.append('唐僧')
# ['孙悟空', '猪八戒', '沙和尚', '唐僧', '唐僧']

# insert()
# 向列表的指定位置插入一个元素
# 参数：
#   1.要插入的位置
#   2.要插入的元素
stus.insert(2,'唐僧')
# ['孙悟空', '猪八戒', '唐僧', '沙和尚', '唐僧']

# extend()
# 使用新的序列来扩展当前序列
# 需要一个序列作为参数，它会将该序列中的元素添加到当前列表中
stus.extend(['唐僧','白骨精'])
# ['孙悟空', '猪八戒', '沙和尚', '唐僧', '唐僧', '白骨精']
stus += ['唐僧','白骨精']
# ['孙悟空', '猪八戒', '沙和尚', '唐僧', '唐僧', '白骨精']
print(stus)

注：注意append()和extend()的区别；在append()中，此元素如果是一个 list，那么这个 list 将作为一个整体进行追加；严格来说 append 是追加，把一个东西整体添加在列表后，而 extend 是扩展，把一个东西里的所有元素添加在列表后。

# append()和extand()的区别
stus = ['孙悟空','猪八戒','沙和尚','唐僧']
stus.extend(['唐僧','白骨精'])
# 将新列表的元素合并到原列表中
# ['孙悟空', '猪八戒', '沙和尚', '唐僧', '唐僧', '白骨精']

stus.append(['唐僧','白骨精'])
# 将新列表作为一个整体追加到原列表中
# ['孙悟空', '猪八戒', '沙和尚', '唐僧', ['唐僧', '白骨精']]
print(stus)

五.删除列表中的元素

list.remove(obj) 移除列表中某个值的第一个匹配项
list.pop([index=-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
del var1[, var2 ……] 删除单个或多个对象。
list.clear() 清空列表

##删除列表中的元素
stus = ['孙悟空','猪八戒','沙和尚','唐僧']
# clear()
# 清空序列
stus.clear()
# []

# del stus[val1:val2]
del stus[0:2]
# ['沙和尚', '唐僧']

# pop()
# 根据索引删除并返回被删除的元素
result = stus.pop(2) # 删除索引为2的元素
result = stus.pop() # 删除最后一个
print('result =',result)
# result = 唐僧

# remove()
# 删除指定值得元素，如果相同值得元素有多个，只会删除第一个
stus.remove('猪八戒')
# ['孙悟空', '沙和尚', '唐僧']
print(stus)

**注：**如果你要从列表中删除一个元素，且不再以任何方式使用它，就使用del语句；如果你要在删除元素后还能继续使用它，就使用方法pop()。

六. 获取列表中的元素

通过元素的索引值，从列表获取单个元素，注意，列表索引值是从0开始的。
通过将索引指定为-1，可让Python返回最后一个列表元素，索引 -2 返回倒数第二个列表元素，以此类推。

1.切片

切片指从现有列表中，获取一个子列表；

# 切片
# 创建一个列表，一般创建列表时，变量的名字会使用复数
stus = ['孙悟空','猪八戒','沙和尚','唐僧','蜘蛛精','白骨精']

# 列表的索引可以是负数
# 如果索引是负数，则从后向前获取元素，-1表示倒数第一个，-2表示倒数第二个 以此类推
print(stus[-2]) # 蜘蛛精

# 通过切片来获取指定的元素
# 语法：列表[起始:结束]
#   通过切片获取元素时，会包括起始位置的元素，不会包括结束位置的元素
#   做切片操作时，总会返回一个新的列表，不会影响原来的列表
#   起始和结束位置的索引都可以省略不写
#   如果省略结束位置，则会一直截取到最后
#   如果省略起始位置，则会从第一个元素开始截取
#   如果起始位置和结束位置全部省略，则相当于创建了一个列表的副本
print(stus[1:]) # ['猪八戒', '沙和尚', '唐僧', '蜘蛛精', '白骨精']
print(stus[:3]) # ['孙悟空', '猪八戒', '沙和尚']
print(stus[:]) # ['孙悟空', '猪八戒', '沙和尚', '唐僧', '蜘蛛精', '白骨精']
print(stus) #['孙悟空', '猪八戒', '沙和尚', '唐僧', '蜘蛛精', '白骨精']

# 语法：列表[起始:结束:步长]
# 步长表示，每次获取元素的间隔，默认值是1
print(stus[0:5:3]) # ['孙悟空', '唐僧']
# 步长不能是0，但是可以是负数
print(stus[::0]) # ValueError: slice step cannot be zero
# 如果是负数，则会从列表的后部向前边取元素
print(stus[::-1]) # ['白骨精', '蜘蛛精', '唐僧', '沙和尚', '猪八戒', '孙悟空']

情况 1 - “start :”

以 step 为 1 (默认) 从编号 start 往列表尾部切片。
情况 2 - “: stop”

以 step 为 1 (默认) 从列表头部往编号 stop 切片。
情况 3 - “start : stop”

以 step 为 1 (默认) 从编号 start 往编号 stop 切片。
情况 4 - “start : stop : step”

以具体的 step 从编号 start 往编号 stop 切片。注意最后把 step 设为 -1，相当于将列表反向排列。
情况 5 - " : "

复制列表中的所有元素（浅拷贝）。

也可通过切片来修改和删除元素：

stus = ['孙悟空','猪八戒','沙和尚','唐僧','蜘蛛精','白骨精']
print("修改前：",stus)

# 通过切片来修改列表
# 在给切片进行赋值时，只能使用序列
stus[0:2] = ['牛魔王','红孩儿']  # 使用新的元素替换旧元素
stus[0:2] = ['牛魔王','红孩儿','二郎神']
stus[0:0] = ['牛魔王'] # 向索引为0的位置插入元素
# 当设置了步长时，序列中元素的个数必须和切片中元素的个数一致
stus[::2] = ['牛魔王','红孩儿','二郎神']

# 通过切片来删除元素
del stus[0:2]
del stus[::2]
stus[1:3] = []

print('修改后：',stus)

# 以上操作，只适用于可变序列

2.浅拷贝和深拷贝

将一个列表的数据复制到另一个列表中。使用列表[:]，可以调用copy模块。

import copy

A = [21,22,23,24,['a','b','c','d'],25,26]
B = A                                       #直接赋值
C = A[:]                                    #浅拷贝
D = copy.copy(A)                            #浅拷贝
E = copy.deepcopy(A)                        #深拷贝

# 看看深拷贝与浅拷贝的区别
# 在A数组的最尾处加一个数
A.append(99)
#在A数组里面的数组最尾处加一个数
A[4].append(66)

print("起始列表A------------>",A)
print("直接把A列表赋值给B---->",B)
print("直接浅拷贝A列表给C---->",C)
print("直接浅拷贝A列表给D---->",D)
print("直接深拷贝A列表给E---->",E)

'''
输出结果：
起始列表A------------> [21, 22, 23, 24, ['a', 'b', 'c', 'd', 66], 25, 26, 99]
直接把A列表赋值给B----> [21, 22, 23, 24, ['a', 'b', 'c', 'd', 66], 25, 26, 99]
直接浅拷贝A列表给C----> [21, 22, 23, 24, ['a', 'b', 'c', 'd', 66], 25, 26]
直接浅拷贝A列表给D----> [21, 22, 23, 24, ['a', 'b', 'c', 'd', 66], 25, 26]
直接深拷贝A列表给E----> [21, 22, 23, 24, ['a', 'b', 'c', 'd'], 25, 26]
'''

浅拷贝和深拷贝的区别：

1、直接赋值,其实就是默认浅拷贝传递对象的引用而已,原始列表改变，被赋值的B也会做相同的改变；

2、浅拷贝，没有拷贝子对象，所以原始数据改变，子对象也会改变；

3、深拷贝，包含对象里面的子对象的拷贝，所以原始对象的改变不会造成深拷贝里任何子元素的改变。

七. 列表的常用操作符

等号操作符：==
连接操作符 +
重复操作符 *
成员关系操作符 in、not in

「等号 ==」，只有成员、成员位置都相同时才返回True。

列表拼接有两种方式，用「加号 +」和「乘号 *」，前者首尾拼接，后者复制拼接。

# + 和 *
# +可以将两个列表拼接为一个列表
my_list = [1,2,3] + [4,5,6]  # [1, 2, 3, 4, 5, 6]

# * 可以将列表重复指定的次数
my_list = [1,2,3] * 5  # [1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]
print(my_list)

# 创建一个列表
stus = ['孙悟空','猪八戒','沙和尚','唐僧','蜘蛛精','白骨精','沙和尚','沙和尚']

# in 和 not in
# in用来检查指定元素是否存在于列表中
#   如果存在，返回True，否则返回False
# not in用来检查指定元素是否不在列表中
#   如果不在，返回True，否则返回False
print('牛魔王' not in stus) # True
print('牛魔王' in stus) # False

# len()获取列表中的元素的个数

# min() 获取列表中的最小值
# max() 获取列表中的最大值
arr = [10,1,2,5,100,77]
print(min(arr) , max(arr)) # 1 100

八.列表的其它方法

list.count(obj) 统计某个元素在列表中出现的次数
list.index(x[, start[, end]]) 从列表中找出某个值第一个匹配项的索引位置
list.reverse() 反向列表中元素
list.sort(key=None, reverse=False) 对原列表进行排序。
- key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
- reverse – 排序规则，reverse = True 降序， reverse = False 升序（默认）。
- 该方法没有返回值，但是会对列表的对象进行排序。

# 创建一个列表
stus = ['孙悟空','猪八戒','沙和尚','唐僧','蜘蛛精','白骨精','沙和尚','沙和尚']

# 两个方法（method），方法和函数基本上是一样，只不过方法必须通过 对象.方法() 的形式调用
# xxx.print() 方法实际上就是和对象关系紧密的函数
# s.index() 获取指定元素在列表中的第一次出现时索引
print(stus.index('沙和尚')) # 2

# index()的第二个参数，表示查找的起始位置 ， 第三个参数，表示查找的结束位置
print(stus.index('沙和尚',3,7)) # 6

# 如果要获取列表中没有的元素，会抛出异常
print(stus.index('牛魔王'))  # ValueError: '牛魔王' is not in list

# s.count() 统计指定元素在列表中出现的次数
print(stus.count('牛魔王')) # 0

stus = ['孙悟空','猪八戒','沙和尚','唐僧']
# print('原列表：',stus)

# reverse()
# 用来反转列表
# stus.reverse()

# sort()
# 用来对列表中的元素进行排序，默认是升序排列
# 如果需要降序排列，则需要传递一个reverse=True作为参数
my_list = list('asnbdnbasdabd')
my_list = [10,1,20,3,4,5,0,-2]

print('修改前',my_list)

my_list.sort(reverse=True)
print('修改后',my_list)
print('修改后：',stus)

'''
原列表： ['孙悟空', '猪八戒', '沙和尚', '唐僧']
修改前 [10, 1, 20, 3, 4, 5, 0, -2]
修改后 [20, 10, 5, 4, 3, 1, 0, -2]
修改后： ['唐僧', '沙和尚', '猪八戒', '孙悟空']
'''

x = [123, 456, 789, 213]
x.sort()
print(x)
# [123, 213, 456, 789]

x.sort(reverse=True)
print(x)
# [789, 456, 213, 123]

# 获取列表的第二个元素
def takeSecond(elem):
    return elem[1]

x = [(2, 2), (3, 4), (4, 1), (1, 3)]
x.sort(key=takeSecond)
print(x)
# [(4, 1), (2, 2), (1, 3), (3, 4)]

x.sort(key=lambda a: a[0])
print(x)
# [(1, 3), (2, 2), (3, 4), (4, 1)]

九.练习题

1、列表操作练习

列表lst 内容如下

lst = [2, 5, 6, 7, 8, 9, 2, 9, 9]

请写程序完成下列操作：

在列表的末尾增加元素15
在列表的中间位置插入元素20
将列表[2, 5, 6]合并到lst中
移除列表中索引为3的元素
翻转列表里的所有元素
对列表里的元素进行排序，从小到大一次，从大到小一次

答：

lst = [2, 5, 6, 7, 8, 9, 2, 9, 9]
# 在列表的末尾增加元素15
lst.append(15)
print(lst) # 
# 在列表的中间位置插入元素20
lst.insert(len(lst) // 2,20)
print(lst) # 
# 将列表[2, 5, 6]合并到lst中
newLst = [2, 5, 6]
lst.extend(newLst)
print(lst) # 
# 移除列表中索引为3的元素
lst.pop(3)
print(lst) # 
# 翻转列表里的所有元素
lst.reverse()
print(lst) # 
# 对列表里的元素进行排序，从小到大一次，从大到小一次
lst.sort()
print(lst)
lst.sort(reverse=True)
print(lst)
'''
输出结果：
[2, 5, 6, 7, 8, 9, 2, 9, 9, 15]
[2, 5, 6, 7, 8, 20, 9, 2, 9, 9, 15]
[2, 5, 6, 7, 8, 20, 9, 2, 9, 9, 15, 2, 5, 6]
[2, 5, 6, 8, 20, 9, 2, 9, 9, 15, 2, 5, 6]
[6, 5, 2, 15, 9, 9, 2, 9, 20, 8, 6, 5, 2]
[2, 2, 2, 5, 5, 6, 6, 8, 9, 9, 9, 15, 20]
[20, 15, 9, 9, 9, 8, 6, 6, 5, 5, 2, 2, 2]
'''

2、修改列表

问题描述：

lst = [1, [4, 6], True]

请将列表里所有数字修改成原来的两倍

答：

def DoubleNum(lst):
    for index, value in enumerate(lst):
        if isinstance(value, bool):
            pass
        elif isinstance(value, (int, float)):
            lst[index] *= 2
        elif isinstance(value, list):
            DoubleNum(value)
        else:
            pass


lst = [1, [4, 6], True]
DoubleNum(lst)
print(lst)
'''
结果为：
[2, [8, 12], True]
'''

3、leetcode 852题山脉数组的峰顶索引

如果一个数组k符合下面两个属性，则称之为山脉数组

数组的长度大于等于3

存在 $i$ ， $i$ >0 且 $i<\operatorname{len}(k)-1$ ，使得 $\mathrm{k}[0]<\mathrm{k}[1]<\ldots<\mathrm{k}[\mathrm{i}-1]<\mathrm{k}[\mathrm{j}]>\mathrm{k}[\mathrm{i}+1] \ldots>\mathrm{k}[\operatorname{len}(\mathrm{k})-1]$

这个 $i$ 就是顶峰索引。

现在，给定一个山脉数组，求顶峰索引。

示例:

输入：[1, 3, 4, 5, 3]

输出：True

输入：[1, 2, 4, 6, 4, 5]

输出：False

答：

# 山脉数组
def MountainList(lst):
    left = 0
    right = len(lst) - 1
    while left <= right:  # 二分法找顶峰索引
        mid = (left + right) // 2
        if lst[mid] > lst[mid + 1] and lst[mid] > lst[mid - 1]:  # 找到顶峰索引
            midToMin = mid
            midToMax = mid
            while midToMin > 0:
                if lst[midToMin] > lst[midToMin - 1]:
                    midToMin -= 1
                else:
                    return False
            while midToMax < len(lst) - 1:
                if lst[midToMax] > lst[midToMax + 1]:
                    midToMax += 1
                else:
                    return False
            return True  # 遍历结束，是山脉数组
        elif lst[mid] < lst[mid - 1]:
            right = mid - 1
        elif lst[mid] < lst[mid + 1]:
            left = mid + 1


lst1 = [1, 3, 4, 5, 3]
result = MountainList(lst1)
print(result)
lst2 = [1, 2, 4, 6, 4, 5]
result = MountainList(lst2)
print(result)
'''
输出结果：
True
False
'''

元组（tuple)

元组 tuple
元组是一个不可变的序列
它的操作的方式基本上和列表是一致的
所以你在操作元组时，就把元组当成是一个不可变的列表就ok了
一般当我们希望数据不改变时，就使用元组，其余情况都使用列表

一.创建和访问一个元组

Python 的元组与列表类似，不同之处在于tuple被创建后就不能对其进行修改，类似字符串。
元组使用小括号，列表使用方括号。
元组与列表类似，也用整数来对它进行索引 (indexing) 和切片 (slicing)。

# 创建元组
# 使用()来创建元组
my_tuple = () # 创建了一个空元组
print(my_tuple,type(my_tuple)) # <class 'tuple'>

my_tuple = (1,2,3,4,5) # 创建了一个5个元素的元组
# 元组是不可变对象，不能尝试为元组中的元素重新赋值
my_tuple[3] = 10 # TypeError: 'tuple' object does not support item assignment
print(my_tuple[3]) # 4

# 当元组不是空元组时，括号可以省略
# 如果元组不是空元组，它里边至少要有一个,
my_tuple = 10,20,30,40
my_tuple = 40,
print(my_tuple , type(my_tuple)) # (40,) <class 'tuple'>

注：创建元组可以用小括号 ()，也可以什么都不用，为了可读性，建议还是用 ()。

元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用。

x = (1)
print(type(x))  # <class 'int'>
x = 2, 3, 4, 5
print(type(x))  # <class 'tuple'>
x = []
print(type(x))  # <class 'list'>
x = ()
print(type(x))  # <class 'tuple'>
x = (1,)
print(type(x))  # <class 'tuple'>

# 创建一个二维数组
x = (1, 10.31, 'python'), ('data', 11)
print(x)
# ((1, 10.31, 'python'), ('data', 11))
print(x[0])
# (1, 10.31, 'python')
print(x[0][0], x[0][1], x[0][2])
# 1 10.31 python
print(x[0][0:2])
# (1, 10.31)

二.更新和删除一个数组

元组有不可更改 (immutable) 的性质，因此不能直接给元组的元素赋值，但是只要元组中的元素可更改 (mutable)，那么我们可以直接更改其元素，注意这跟赋值其元素不同。

week = ('Monday', 'Tuesday', 'Thursday', 'Friday')
week = week[:2] + ('Wednesday',) + week[2:]
print(week)  # ('Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday')

# 元组中的元素可更改
t1 = (1, 2, 3, [4, 5, 6])
print(t1)  # (1, 2, 3, [4, 5, 6])

t1[1] = 10
print(t1) # TypeError: 'tuple' object does not support item assignment

t1[3][0] = 9
print(t1)  # (1, 2, 3, [9, 5, 6])

三. 元组相关的操作符

等号操作符：==
连接操作符 +
重复操作符 *
成员关系操作符 in、not in

# == 只有成员、成员位置都相同时才返回True
t1 = (123, 456)
t2 = (456, 123)
t3 = (123, 456)

print(t1 == t2)  # False
print(t1 == t3)  # True

# 元组拼接有两种方式，用「加号 +」和「乘号 *」，前者首尾拼接，后者复制拼接。
t4 = t1 + t2
print(t4)  # (123, 456, 456, 123)

t5 = t3 * 3
print(t5)  # (123, 456, 123, 456, 123, 456)

t3 *= 3
print(t3)  # (123, 456, 123, 456, 123, 456)

print(123 in t3)  # True
print(456 not in t3)  # False

四. 内置方法

count()

count(self,__value) 是记录在元组中value出现的次数

index()

index(self,__value: Any,start: int = ...,__stop: int = ...) 是找到value在元组的索引start、stop指的是查询元组的起始位置。

# 内置方法
t1 = (1, 2, 3, [4, 5, 6],4,6,3,2,1)
print(t1.count(3)) # 2
# index()是在元组中顺序查询，且查询到第一个符合条件元素的位置时即停止
print(t1.index(3)) # 2
print(t1.index(3,3)) # 6

index()是在元组中顺序查询，且查询到第一个符合条件元素的位置时即停止，所以才需start和stop两个参数来划清查询的范围。

五. 解压元组

一般我们也称之为元组的解包或者解构：

解包指就是将元组当中每一个元素都赋值给一个变量
解压（unpack）一维元组（有几个元素左边括号定义几个变量）
解压二维元组（按照元组里的元组结构来定义变量）
如果你只想要元组其中几个元素，用通配符「*」，英文叫 wildcard，在计算机语言中代表一个或多个元素。
如果你根本不在乎通配符标识的变量，那么就用通配符「*」加上下划线「_」。

# 元组的解包（解构）
# 解包指就是将元组当中每一个元素都赋值给一个变量
my_tuple = 10 , 20 , 30 , 40
a,b,c,d = my_tuple

print("a =",a)
print("b =",b)
print("c =",c)
print("d =",d)
'''
a = 10
b = 20
c = 30
d = 40
'''

a = 100
b = 300
print(a , b) # 100 300

# 交互a 和 b的值，这时我们就可以利用元组的解包
a , b = b , a

print(a , b) # 300 100
my_tuple = 10 , 20 , 30 , 40

# 在对一个元组进行解包时，变量的数量必须和元组中的元素的数量一致
# 也可以在变量前边添加一个*，这样变量将会获取元组中所有剩余的元素
a , b , *c = my_tuple
a , *b , c = my_tuple
'''
a = 10
b = [20, 30]
c = 40
'''
*a , b , c = my_tuple
'''
a = [10, 20]
b = 30
c = 40
'''
a , b , *c = [1,2,3,4,5,6,7]
'''
a = 1
b = 2
c = [3, 4, 5, 6, 7]
'''
a , b , *c = 'hello world'
a , b , *_ = 'hello world'
'''
a = h
b = e
c = ['l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']
'''
# 不能同时出现两个或以上的*变量
# *a , *b , c = my_tuple SyntaxError: two starred expressions in assignment
print('a =',a)
print('b =',b)
print('c =',c)

练习题

1、元组概念

写出下面代码的执行结果和最终结果的类型

(1, 2)*2
(1, )*2
(1)*2

分析为什么会出现这样的结果.

a = (1, 2)*2 # (1, 2, 1, 2) <class 'tuple'>
a = (1, )*2 # (1, 1) <class 'tuple'>
a = (1)*2 # 2 <class 'int'>
print(a,type(a))

答： 1.（1，2）是一个元组，*为元组的重复操作符，即为将元组重复两次，输出结果仍为一个元组；

2.（1，）也是一个元组，且该元组中只有一个元素，*为元组的重复操作符，即为将元组重复两次，输出结果仍为一个元组；

3.（1）元素后无逗号隔开，不会当作是一个元组，（）被当作是运算符使用，即1*2，输出结果为一个整型数字。

2、拆包过程是什么？

a, b = 1, 2

上述过程属于拆包吗？

可迭代对象拆包时，怎么赋值给占位符？

答：拆包过程是指利用一句赋值语句将元组当中每一个元素都赋值给一个变量。

上述过程属于拆包，1, 2已经定义了一个元组，与左边结构相对应，可以算作解压元组。

在可迭代对象拆包时，使用_(单个元素)，*_(连续多个元素)进行占位。

上一篇：让用户自己控制网页字体的大小的css书写方法_经验交流

下一篇： GUI编程

Python学习笔记列表、元组、字符串 DAY4

列表（list）

一.序列（sequence）

二. 列表的定义

三.创建列表

1.range()

四.向列表中添加元素

五.删除列表中的元素

六. 获取列表中的元素

1.切片

2.浅拷贝和深拷贝

七. 列表的常用操作符

八.列表的其它方法

九.练习题

元组（tuple)

一.创建和访问一个元组

二.更新和删除一个数组

三. 元组相关的操作符

四. 内置方法

count()

index()

五. 解压元组

练习题

Python3.4学习笔记之列表、数组操作示例

Python字符串、元组、列表、字典互相转换的方法

python学习第三天-元组、列表及字典

在Python中反向遍历序列(列表、字符串、元组等)的五种方式

python学习之列表和元组

Python字符串(Python学习笔记02)

python入门学习笔记之操作列表

Python语法基础学习_列表元组

Python基础总结之第七天开始【总结字符串、列表、元组的常用方法】（新手可相互督促）

Python 学习笔记（九）Python元组和字典（二）

Python学习笔记 列表、元组、字符串 DAY4

列表（list）

一.序列（sequence）

二. 列表的定义

三.创建列表

1.range()

四.向列表中添加元素

五.删除列表中的元素

六. 获取列表中的元素

1.切片

2.浅拷贝和深拷贝

七. 列表的常用操作符

八.列表的其它方法

九.练习题

元组（tuple)

一.创建和访问一个元组

二.更新和删除一个数组

三. 元组相关的操作符

四. 内置方法

count()

index()

五. 解压元组

练习题

Python3.4学习笔记之列表、数组操作示例

Python字符串、元组、列表、字典互相转换的方法

python学习第三天-元组、列表及字典

在Python中反向遍历序列(列表、字符串、元组等)的五种方式

python学习之列表和元组

Python字符串(Python学习笔记02)

python入门学习笔记之操作列表

Python语法基础学习_列表 元组

Python基础总结之第七天开始【总结字符串、列表、元组的常用方法】（新手可相互督促）

Python 学习笔记（九）Python元组和字典（二）

Python学习笔记列表、元组、字符串 DAY4

Python语法基础学习_列表元组