python基础：Python元组、列表

妖狐艹你老母 2022-04-01 03:14 295阅读 0赞

列表：  
概念：列表是一个有序的，可修改的，元素以逗号分割，以中括号包围的序列。  
列表的索引和字符串的索引类似，但不完全相同，因为列表可以修改，所以我们可以通过列表的索引来修改列表。  
一、列表的定义以及查看列表类型：  
name = \[“Eric”,“Mary”,“Tom”\]  
type(name)  
<class ‘list’>  
创建列表  
\# lst = \[1, 2.34, ‘hello’, False\]  
\# 查看列表中的数据  
\# print(lst)  
\# 查看列表的数据类型  
\# print(type(lst)) \# <class ‘list’>  
二、通过索引获取列表中的元素，索引从0开始  
\# lst = \[1, 2.34, ‘hello’, False\]  
\# num = lst\[1\]  
\# print(num) \# 2.34  
\# ret = lst\[4\]  
\# print(ret) \# 索引越界异常  
\# length = len(lst)  
\# print(length) \# 4 长度从1开始计算  
三、使用for循环取出每一个元素  
\# i=‘hello’  
\# for i in lst:  
\# print(i)  
\# h  
e  
l  
l  
o

四、列表的增删改查  
append（）：追加，在列表的尾部加入指定的元素  
insert（）：将指定的元素插入到对应的索引位上，注意负索引倒序插入，超过索引就会在末尾插入  
extend（）：将指定序列的元素依次追加到列表的尾部(合并),不会去重复内容  
\# lst = \[‘悟空’, ‘八戒’, ‘唐三藏’\]  
\# 1.向列表中添加数据 append(),insert(),+ ,extend()  
\# lst.append(‘白骨精’) \# 将数据追加到列表的后面  
\# print(lst)  
\# lst.insert(1, ‘白龙马’) \# 指定索引位置添加元素。  
\# print(lst)

# lst2 = ['宋江', '李逵', '悟空']
    #
    # # lst3 = lst + lst2  # 列表之间可以相加，将所有的内容放到一个新的列表中，并且不会自动去重
    # # print(lst3)
    #
    # lst.extend(lst2)
    # print(lst)
    
    # lst = ['悟空', '八戒', '唐三藏']
    # s='hello'
    # lst.extend(s)
    # print(lst)
    
    # s='hello'
    # s1="-".join(s)
    # print(s)
    # print(s1)
    5、删除操作

pop 弹出，返回并删除指定索引位上的数据，默认删除索引为-1的数据(从右向左删除)  
remove 从左往右删除一个指定的元素  
del 删除整个列表或列表的数据，删除后将不复存在，del是python内置功能，不是列表独有的  
clear 删除列表中所有元素，然后变成一个空列表  
\# lst = \[‘悟空’, ‘八戒’, ‘唐三藏’\]  
\# lst.pop(0) \# 指定索引删除数据，如果索引不存在则报错  
\# print(lst)  
\# lst.remove(‘八戒’) \# 根据内容删除  
\# print(lst)  
\# lst.clear() \# 清除所有内容，变成空列表\[\]  
\# print(lst)  
\# del lst \# 删除列表  
\# print(lst)  
六、修改操作

# lst = ['悟空', '八戒', '唐三藏']
    # lst[0] = '猴哥'  # 通过索引来修改内容
    # print(lst)

七、查询 操作  
count 计数，返回要计数的元素在列表当中的个数  
index 查找，从左往右返回查找到的第一个指定元素的索引，如果没有找到，报错  
\# lst = \[‘悟空’, ‘八戒’, ‘唐三藏’, ‘悟空’\]  
\# \# 1.通过索引获取元素  
\# \# ret = lst\[0\]  
\# \# print(ret)  
\# \# num = lst.count(‘八戒’) \# 根据内容统计个数  
\# \# print(num)  
\# \# index = lst.index(‘悟空’) \# 根据内容返回索引值  
\# \# print(index)  
\# length = len(lst)  
\# print(length)  
\# ret = lst.index(‘悟空’, 1, length) \# 指定位置查找  
\# print(ret)  
八、列表的切片

# lst = ['a', 'b', 'c', 'd', 'e']
    # ret = lst[0:4:2]
    # print(ret)
    # print(lst)

九、列表的排序  
reverse 顺序倒序  
sort 按照ascii码表顺序进行排序  
\# lst = \[‘tom’, ‘jerry’, ‘carl’, ‘zs’, ‘ls’\]  
\# print(lst)  
\# \# lst.sort() \# 升序排序  
\# \# print(lst)  
\# lst.sort(reverse=True) \# 降序排序  
\# print(lst)  
如果一个方法有返回值，就需要使用一个变量来接受，  
如果一个方法没有返回值，就不需要使用变量来接受。  
怎么看方法的返回值 快捷键 ctrl+Q

# lst = [1, 2, ['悟空', '八戒'], 3]
    # # 获取 八戒
    # ret = lst[2][1]  # 先找到内部列表，然后再找到内容
    # print(ret)

十一、列表的拷贝  
1、浅拷贝  
对于浅copy来说，第一层创建的是 存地址，所以，对于第二层以及更深的层数来说，保持一致性。

lst = ['貂蝉', '西施']
    lst1 = ['悟空', '八戒', lst]
    lst2 = lst1.copy()  # 将 lst1的内容拷贝一份给lst2
    print(lst1)  # ['悟空', '八戒', ['貂蝉', '西施']]
    print(lst2)  # ['悟空', '八戒', ['貂蝉', '西施']]
    print(id(lst1[2]))  # 35502856
    print(id(lst2[2]))  # 35502856
    
    # print(lst1)
    # print(id(lst1))
    # print(lst2)
    # print(id(lst2))
    # lst2[0] = '猴哥'  # 将 lst2中的悟空改成 猴哥
    # print('lst2--->', lst2)
    # print('lst1--->', lst1)
    # lst2[2][0] = '杨贵妃'
    # print('lst2--->', lst2)
    # print(id(lst))
    # print('lst1--->', lst1)
    # print(id(lst))
    2、 深拷贝
    深拷贝后的变量的第二层以及更深的层数的内存地址发生了改变，与原有变量的深层地址不再保持一致，如果拷贝后的变量的深层地址发生了变化，那么原来的变量的深层地址将不会发生改变。
    # 导入copy模块
    import copy
    
    lst = ['貂蝉', '西施']
    lst1 = ['悟空', '八戒', lst]
    lst2 = copy.deepcopy(lst1)
    print(lst1)
    print(id(lst1))
    print(lst2)
    print(id(lst2))
    # 修改第一层的内容
    # lst2[0] = '猴哥'
    print('lst1--->', lst1)
    print('lst2--->', lst2)
    # 修改第二层的内容
    # lst2[2][0] = '贵妃'
    print('lst1--->', lst1)  # ['悟空', '八戒', ['貂蝉', '西施']]
    print('lst2--->', lst2)  # ['悟空', '八戒', ['貂蝉', '西施']]
    # print(id(lst1[2]))  # 39409992
    # print(id(lst2[2]))  # 39411400

元组：  
元组特点：元组是有序的，不能修改。  
元组的定义:  
(1).通过()来定义：变量名=(1,2,3,4,) 。以逗号分割的，以小括号包围的序列。  
(2).通过tuple函数定义: lst=\[1,2,3,4\] 变量名=tuple(lst)  
元组的优点:由于元组不可变，所以遍历元组比列表要快（较小的性能提升）。

一、元组的创建  
\# tup = (1, 2.2, True, ‘hello’)  
\# print(tup) \# 打印变量名就可以查看元组中的内容  
\# print(type(tup)) \# <class ‘tuple’>

二、访问元组  
元组的索引和字符串以及列表完全一致。  
1.通过索引，默认索引是从0开始的  
\# tup = (1, 2.2, True, ‘hello’)  
\# ret = tup\[4\] \# 获取 2.2 值,一定要注意索引越界问题。  
2.通过切片来获取内容  
\# tup = (1, 2.2, True, ‘hello’, ‘赵四’, ‘刘能’)  
\# tup1 = tup\[0:4:1\]  
\# print(tup1) \# (1, 2.2, True, ‘hello’)  
\# print(tup)  
三、访问多维元组

# tup = (('zs', 10), ('ls', 11), ('ww', 12))
    # ret = tup[1][0]  # 先找到内层元组，然后再获取里面对应的值。
    # print(ret)

四、使用多个变量来接受元组中的值  
注意:变量的个数和元组中的值的个数必须一一对应  
\# name, age, height, weight = (‘zs’, 32, 1.64, 150)  
\# print(name)  
\# print(age)  
\# print(height)  
\# print(weight)  
使a与b的值互换  
a=10  
b=20  
b,a=(a,b)  
print(a) 20  
print(b) 10

四、遍历 元组

# tup = (('zs', 10), ('ls', 11), ('ww', 12))
    # for tup1 in tup:
    #     print(tup1)
    #     for info in tup1:
    #         print(info)
    
    # for name, age in tup:
    #     print(name, age)

五、元组的修改  
说明：Python中不允许修改元组的数据，包括不能删除其中的元素。  
元组是不可变的，也就是说，元组中的元素在被赋值后不能改变。但是，如果元素本身是一个可变数据类型的列表，那么其嵌套项可以被改变。  
\# tup = (‘zs’, ‘ls’, ‘ww’, \[‘白骨精’, ‘糖三角’\])  
\# \# tup\[0\] = ‘赵四’ \# 不能修改  
\# tup\[3\].insert(1, ‘宋江’)  
\# print(tup)  
六、元组的一个逗号魅力

# tup1 = ('1')         如果没有逗号，就是元素本身类型。
    # print(type(tup1))      #int
    # tup2 = (1,)             如果有逗号，就是元组
    # print(type(tup2))     #tuple

七、tuple()函数和list()函数  
tuple函数的功能与list函数基本上一样的，以一个序列作为参数并把它转换为元组，如果参数是元组，那么该参数就会被原样返回。  
\# lst = \[1, 2, 3\]  
\# tup = tuple(lst)  
\# print(tup)  
\# tup = (‘a’, ‘b’, ‘c’)  
\# ret = list(tup)  
\# print(ret)  
八、元组中的方法  
index 从左往右返回第一个遇到的指定元素的索引，如果没有，报错  
count 返回元组当中指定元素的个数  
tup = (‘a’, ‘b’, ‘a’, ‘c’, ‘b’, ‘a’, ‘x’)  
\# ret = tup.index(‘b’) \# 根据内容返对应的索引。  
\# ret = tup.index(‘a’, 2, len(tup))  
\# print(ret) \# 5  
ret = tup.count(‘a’)  
print(ret)  
s = ‘abde123’