python3 列表 元组 字典 集合 4大元帅

python3 列表 元组 字典 集合 4大元帅

一、Python3 列表

序列是 Python 中最基本的数据结构。

序列中的每个值都有对应的位置值，称之为索引，第一个索引是 0，第二个索引是 1，依此类推。

Python 有 6 个序列的内置类型，但最常见的是列表和元组。

列表都可以进行的操作包括索引，切片，加，乘，检查成员。

此外，Python 已经内置确定序列的长度以及确定最大和最小的元素的方法。

列表是最常用的 Python 数据类型，它可以作为一个方括号内的逗号分隔值出现。

列表的数据项不需要具有相同的类型

创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：

list1 = ['huang','liang',2021,2099]
list2 = [1,2,3,4,5,6]
list3 = ["a", "b", "c", "d", "e"]
list4 = ["安徽省","河南省", "河北省", "湖南省", "湖北省"]
print("list1=", list1)
print("list2=", list2)
print("list3=", list3)
print("list4=", list4)
# 长度
print("list1 的长度",len(list1))
print("list2 的长度",len(list2))
print("list3 的长度",len(list3))
print("list4 的长度",len(list4))

print(list1[0])
print(list2[0])
print(list3[0])
print(list4[0])
print(list4[-1])
print(list4[-2])
print(list4[-3])
print(list4[-4])
print(list4[-5])
# 组合
list5 = [10,20,30]
list6 = [40,50,60]
list7 = list5 + list6
print("list7 = " ,list7)
# 重复
list8 = ["hello"]
print("list8 = ", list8*4)
# 元素是否存在于列表中
print(3 in [1,2,3])
print(4 in [1,2,3])

# Python列表截取与拼接
province = ["an", "hui", "sheng"]
# 读取第三个元素
print(province[2])
# 从右侧开始读取倒数第二个元素: count from the right
print(province[-2])
# 输出从第二个元素开始后的所有元素
print(province[1:])

# Python列表函数&方法
list9 = [10,20,30,40]
# len(list)
# 列表元素个数
print(len(list9))
# max(list)
# 返回列表元素最大值
print(max(list9))
# min(list)
# 返回列表元素最小值
print(min(list9))

二、元组

图示二

# python3 列表 元组 字典 集合 4大元帅
# ==================== 元组 ====================
# Python 的元组与列表类似，不同之处在于元组的元素不能修改。
# 元组使用小括号 ( )，列表使用方括号 [ ]。
# 元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
# 图示
tuple1 = ("sunday", "monday","tuesday")
print(type(tuple1))
# 输出
# <class 'tuple'>

# 实例
tup1 = ("an", "hui", 2021, 2099)
tup2 = (1, 2, 3, 4, 5, 6)
tup3 = "a", "b", "c","d", "e" # 不需要括号也可以
print(type(tup3))
# 输出
# <class 'tuple'>

# 创建空元组
tup4 = ()

# 元组中只包含一个元素时，需要在元素后面添加逗号 , ，否则括号会被当作运算符使用：
tup5 = (5)
print(type(tup5))
# 输出
# <class 'int'>

tup5 = (5,)
print(type(tup5))
# 输出
# <class 'tuple'>

# 元组与字符串类似，下标索引从 0 开始，可以进行截取，组合等。
# 图示二

# 访问元组
# 元组可以使用下标索引来访问元组中的值，如下实例:
tup6 = ('Google', 'Runoob', 1997, 2000)
tup7 = (1, 2, 3, 4, 5, 6, 7, 8 )
print ("tup6[0]: ", tup6[0])
print ("tup7[1:5]: ", tup7[1:5])
# 以上实例输出结果：
# tup6[0]:  Google
# tup7[1:5]:  (2, 3, 4, 5)

# 修改元组
# 元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例:

tup8 = (12, 34.56)
tup9 = ('abc', 'xyz')
# 以下修改元组元素操作是非法的。
# tup8[0] = 100

# 创建一个新的元组
tup10 = tup8 + tup9
print ("tup10 = ", tup10)
# 以上实例输出结果：
# tup10 =  (12, 34.56, 'abc', 'xyz')

# 删除元组
# 元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，如下实例:
tup = ('Google', 'Runoob', 1997, 2000)

print(tup)
del tup
print("删除后的元组 tup : ")
# print(tup)
# 删除后的元组 tup :
# Traceback (most recent call last):
#   File "test.py", line 68, in <module>
#     print (tup)
# NameError: name 'tup' is not defined

# 元组运算符
# 与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。

print(len((1,2,3,4)))
# 计算元素个数
# 以上实例输出结果：4

print((1, 2, 3) + (4, 5, 6, 7))
# 连接
# 以上实例输出结果：(1, 2, 3, 4, 5, 6, 7)

print(('hello',)*4)
# 复制
# 以上实例输出结果：('hello', 'hello', 'hello', 'hello')

print(3 in (1, 2, 3))
print(4 in (1, 2, 3))
# 元素是否存在
# True
# False

for x in (1, 2, 3): print (x,)
# 迭代
# 1
# 2
# 3

# 元组索引，截取
# 因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以截取索引中的一段元素，如下所示：
# 元组：
tup11 = ('Google', 'Runoob', 'Taobao', 'Wiki', 'Weibo','Weixin')
print(tup11[1])
# 结果
# 'Runoob'
# 读取第二个元素

print(tup11[-2])
# 结果
# 'Weibo'
# 反向读取，读取倒数第二个元素

print(tup11[1:])
# 结果
# ('Runoob', 'Taobao', 'Wiki', 'Weibo', 'Weixin')
# 截取元素，从第二个开始后的所有元素。

print(tup11[1:4])
# 结果
# ('Runoob', 'Taobao', 'Wiki')
# 截取元素，从第二个开始到第四个元素（索引为 3）。

# 元组内置函数
# Python元组包含了以下内置函数
# 1.  len(tuple)
# 计算元组元素个数。

# 2. max(tuple)
# 返回元组中元素最大值。

# 3. min(tuple)
# 返回元组中元素最小值。

# 4. tuple(iterable)
# 将可迭代系列转换为元组。
list1= ['Google', 'Taobao', 'Runoob', 'Baidu']
tup12 = tuple(list1)
print(list1)
print(tup12)

# 关于元组是不可变的
# 所谓元组的不可变指的是元组所指向的内存中的内容不可变。

tup13 = ("hello", "world")
print(id(tup13))
# 2339448624456
tup13 = ("hello", "world", 123)
print(id(tup13))
# 2339448615200

三、字典

四、集合