Python基础语法（三：序列、列表、元组及字典、集合）

内存：一个大的仓库
变量：仓库里面的盲盒

---

前言

提示：

---

一、序列

序列是指它的成员都是有序排列的，并且可以通过偏移量访问它的成员。序列不是Python中指定的数据类型，仅仅是多种类型所支持的统一操作。
- 序列由字符串、列表、元组等

1.通过索引获取指定位置上的元素（[]）

序列[index_no]

2.切片操作（[1:]）

序列[数字:数字]

3.成员关系操作符（in或not in）

对象 [not] in 序列

4.连接操作符（+）

序列 + 序列

5.重复操作符（*）

序列*数字

6.支持遍历（for、list）

• 从头到尾 依次 从 序列中获取数据
• 在 循环体内部 针对 每一个元素，执行相同的操作

for item in 序列：
	pass

7.能求长度（len）

len(序列)

8.支持的内置函数

函数	描述
all()	如果序列的所以元素都为True，则为True，否则为False。(空序列为True)
any()	序列只要有一个元素为True，则为True，否则为False(或者序列为None)。
enumerate()	返回一个enumerate对象，返回一个包含序列每个元素索引和值的元组。It contains the index and value of all the items of list as a tuple.
len()	返回序列中元素的个数。Return the length (the number of items) in the list.
list()	将一个可迭代对象转换为一个列表。Convert an iterable (tuple, string, set, dictionary) to a list.
max()	返回序列中最大的元素（能比较大小）。Return the largest item in the list.
min()	返回序列中最小的元素（能比较大小。Return the smallest item in the list
sorted()	返回一个排序之后的新序列（源序列不会改变）。Return a new sorted list (does not sort the list itself).
sum()	返回序列中所有元素之和。（元素为数字）Return the sum of all elements in the list.

二、列表

1.列表(list)中的定义

• 一串 数据

• 用 [] 定义，数据 之间使用 , 分隔

• 为序列类型，支持序列的所有操作

• 使用 最频繁 的数据类型，在其他语言中通常叫做 数组

定义一个列表
格式: 列表名 = [元素1, 元素2, 元素3,....]

# my_list = ["xiaoming", "xiaohong"]
# # -> 支持下标索引
#
# my_name = my_list[0]
# print(my_name)

# 定义一个列表
# my_list = [10, 3.14, "hello", True]
# print(my_list)
# 需求 我想打印hello (从左到右) 0, 1, 2,....
# 也可以从右到左 -1, -2, -3, ....
# ret1 = my_list[-2]
# print(ret1)


# 定义一个空列表
# my_list = []  或者 list()
# my_list = list()
# # 打印下元素个数
# l = len(my_list)
# print(l)


 可以定义空的列表 只要是列表那么久应该有[];
 也支持下标索引获取元素;
 保存数据的元素 可以是任意类;

         列表的常用操作

- 在 `ipython3` 中定义一个 **列表**，例如：`one_list = []`

- 输入 `one_list.` 按下 `TAB` 键


- 列表.clear()  清空列表
- max(列表)   返回列表中最大的元素
- min(列表)   返回列表中最小的元素

2.列表(list)中的循环

 列表和字符串一样 是有序的
#"abcd"
 ["a", "b", "c", "d"]

 for循环
	# 字符串
name = "hello"
for c in name:
     print(c)

	# for循环
	# 定义一个列表
 my_list = [1, 3, "hello", "哈哈"]
	# 遍历列表的元素
 for value in my_list:
     print(value)

	#	 while循环
	# 	定义一个列表
my_list = [1, 3, "hello", "哈哈"]
#定义一个变量 -> 下标索引
index = 0
#定义一个变量 保存列表中的元素个数
l = len(my_list)
while index < l:
    # 通过下标索引获取列表中的元素
    value = my_list[index]
    print(value)
    index += 1
    

3.列表(list)中的增删改查

	# 	添加元素(append, extend, insert)
# 列表是可变的(如果对当前列表的操作 是在原有的列表上进行更改)
# 定义一个列表
my_list = [1, 3, 5, 8]
# append 添加一个整体(一个对象)
# my_list.append([4, 5])
# print(my_list)
# [1, 3, [4, 5]]

# extend 添加一个可以遍历的对象(有序的字符序列)
# my_list.extend([4, 6, 9])
# print(my_list)
	# insert 插入到指定位置
my_list.insert(0, "hello")
print(my_list)

# 	修改元素就是根据索引 重新赋值
# 定义一个列表
my_list = ["ab", 11, 3.14]
# 获取11
# value = my_list[1]
# print(value)

# 把my_list中的11 改成"hello"
# my_list[1] = "hello"
# print(my_list)

# 3.14改成3000
# my_list[-1] = 3000
# print(my_list)

# 查找元素("查"in, not in, index, count)

# 定义一个字符串
my_list = ["老李", "老张", "小明", 400, 400]
# 判断老李是否存在列表中

# 使用in 判断一个元素是否存在列表中
 if "老李1" in my_list:
     print("存在在列表中")


# 使用not in 判断一个元素不存在列表中
 if "小红" not in my_list:
     print("小红不存在")

# index 通过index 获取某个元素在列表中的下标索引
 ret1 = my_list.index(400)
 print(ret1)

# count 查找某个元素的值在列表中出现的次数
 ret2 = my_list.count(400)
 print(ret2)

# 查询4000 如果有给我下标索引 如果没有 什么也不做

# 使用count 配合完成
 count = my_list.count(400)
 if count > 0:
     index = my_list.index(400)
     print(index)


# 使用in 配合完成
 if 400 in my_list:
     index = my_list.index(400)
     print(index)

# 删除元素 del, pop, remove
# 定义一个列表
my_list = ["小明", 20, "小红", 50]

# del 删除指定的元素 (通过下标索引)
# 格式: del 列表名[下标索引]
# del 这个函数 是python内置函数(len  del)
del my_list[1]
	print(my_list)


# pop是属于列表的方法
# pop 默认情况下 会从列表的后面开始删除
# .pop() 会有一个返回值 告知删除元素的值
print(my_list.pop())
print(my_list)

# pop(下标索引)
ret = my_list.pop(0)
print(ret)
print(my_list)

# remove 通过对象(数值)来删除列表中的元素
my_list.remove("小红")
print(my_list)


# del 第二种用法 了解
# 提前杀死对象 提前释放内存
del my_list


# clear 清空列表(列表中所有的元素全部删除)
my_list.clear()
 # 等价于 my_list = [] 或者 my_list = list()
print(my_list)

4.列表(list)中的排序

# 导入模块
import random
# 定义一个列表列表中有6个元素
# 六个元素每个数值范围 [-10, 50]

# 定义一个空的列表 用来保存数据
my_list = []
# 定义一个for循环
for i in range(6):
    # 获取随机数
    value = random.randint(-10, 50)
    # 把随机数添加到列表中
    my_list.append(value)
print(my_list)

# [6, -3, -8, 7, 9, -2] 进行排序 -> 升序 (从小到大)
# 列表名.sort() 等价于 列表名.sort(reverse=False)
# my_list.sort()
# print(my_list)

# 降序 (从大到小)
# my_list.sort(reverse=True)
# print(my_list)

			最大值、最小值练习
# 编程实现对一个元素全为数字的列表，求最大值、最小值

# 准备一个列表
# my_list = [-1, -5, -10, -200, -300, -40]

# 定义一个变量 记录最终的最大值
# 不是所有的默认值都要设置为0 考虑到语境
# my_max = my_list[0]
# # for循环
# for value in my_list:
#     #判断如果列表中的元素值大于最大值
#     if value > my_max:
#         # 赋值
#         my_max = value
#
# print(my_max)


my_list = [-1, -5, -10, -200, -300, -40]

# 定义一个变量 记录最小值
my_min = my_list[0]
# 遍历
for value in my_list:
    if value < my_min:
        my_min = value

print("最小值:%d" % my_min)

5.列表(list)中的嵌套

schoolNames = [['北京大学','清华大学'],
               ['南开大学','天津大学','天津师范大学'],
               ['山东大学',["新东方", "蓝翔"],'中国海洋大学']]

# 获取天津大学字符串
# my_list = schoolNames[1]
# print(my_list)
# name = my_list[1]
# print(name)

# 简写
# name = schoolNames[1][1]
# print(name)

# my_list = schoolNames[1]
# # ['南开大学', '天津大学', '天津师范大学', ['哈哈']]
# print(my_list)
# new_list = my_list[3]
# # ['哈哈']
# print(new_list)
# name = new_list[0]
# print(name)

# name = schoolNames[1][3][0]
# print(name)

		# 列表嵌套练习
import random
# 一个学校，有3个办公室，现在有8位老师等待工位的分配，请编写程序，完成随机的分配

# 定义一个学校
school = [[], [], []]

# index = random.randint(0, 2)
# # 随机安排到哪个办公室
# school[index].append("A")
#
# index = random.randint(0, 2)
# school[index].append("B")
#
# index = random.randint(0, 2)
# school[index].append("F")
# print(school)


# 定义一个变量保存8名老师
# 让八名老师站好等待随机分配办公室
my_str = "ABCDEFGH"
for c in my_str:
    # 产生随机数
    index = random.randint(0, 2)
    #
    school[index].append(c)


print(school)

三、元组

1.元组的定义

• 不可修改的序列

• 由于元组是序列类型，支持所有序列类型的操作

• Tuple（元组）与列表类似，不同之处在于元组的 元素不能修改

• 表示多个元素组成的序列

• 一般在数据不需要修改的场景下使用

• 用于存储 一串信息，数据 之间使用 , 分隔

• 元组用 () 定义

• 元组为序列类型，支持序列的所有操作

• 元组的 索引 从 0 开始

• 索引 就是数据在 元组 中的位置编号

	# 创建元组
# 元组语法很简单，只要将一些值用逗号分隔，就能自动创建一个元组
my_tuple = "hello", "lemon"
#查看数据类型<class 'tuple'>
print(type(my_tuple))

# 元组还可用圆括号括起（这也是通常采用的做法）
my_tuple = ("hello", "lemon")  
print(type(my_tuple))

			创建空元组
# 第一种方法
# 空元组用两个不包含任何内容的圆括号表示。
>>> ()
()
>>> type(())

# 第二种方法
>>> tuple()

	只包含一个元素时，需要在元素后面添加逗号
# third_tuple = ("Python", )
>>> 250
250
>>> 250,
(250,)

>>> (250, )
(250,)

# 1 个元素的元组
# TODO: 1 个元素的元组，一定要在元素后面加逗号
# 如果不加逗号，数据类型这个元素的数据类型
names = ('yuz')  == 'yuz'

names = ('yuz', )
print(len(names))   # 1
print(type(names))   # tuple, str, 0

元组中尽量不要保存可变类型的数据

# 虽然不会报错，但是不推荐
my_tuple = (4, 2, 3, [6, 5])

2.元组的常用操作及应用场景

• 元组.count(x) 返回元组中x出现的次数

• 元组.index(x) 返回第一次出现x的索引

  my_tuple = ('a','p','p','l','e', )
  
  # Count
  # Output: 2
  print(my_tuple.count('p'))
  
  # Index
  # Output: 3
  print(my_tuple.index('l'))
	#元组：解包。 拆包
   a, b, c = ('哦呦', '呵呵哒', '土豆')
   print(a)
   print(b)
   print(c)

• 在开发中，更多的应用场景是：
  函数的 参数 和 返回值，一个函数可以接收 任意多个参数，或者 一次返回多个数据
• 格式字符串，格式化字符串后面的 () 本质上就是一个元组
• 让列表不可以被修改，以保护数据安全

myself = ("可优", 18)

print("%s 的年龄是 %d" % myself)

3.元组 VS 列表

• 列表中最好保存，数据类型相似的数据。元组中保存不同类型的数据

• 由于元组为不可变类型，在遍历的时候，速度更快

• 可以作为dict字典的key，列表不可以

• 由于元组为不可变类型，可以进行写保护（保证数据不会修改）

# 定义一个字符串 "" 或者 ''
# 定义一个列表 []
# 定义一个元组 ()

• 使用 list 函数可以把元组转换成列表

list(元组) 

• 使用 tuple 函数可以把列表转换成元组

tuple(列表)

4.通过下标查看元组的元素

# 因为元组是不可变的 不可以修改元素 或者删除元素
# 只能查看元素 或者遍历元组中的元素
# my_tuple = (1, 3.14, True, "HELLO")
# my_tuple[3] = 666


# index count
# my_tuple = (1, 3.14, True, "HELLO", 3.14)

# 元组中元素的位置
# index = my_tuple.index(3.14)
# print(index)

# 获取某个元素在 元组中出现的次数
# count = my_tuple.count(3.14)
# print(count)

# 通过下标获取元组中的元素
# my_tuple = (1, 3.14, True, "HELLO")
# 获取3.14
# value = my_tuple[1]
# print(value)

5.元组的循环

		for循环遍历

# my_tuple = (1, 3.14, True, "HELLO", 3.14)

# for value in my_tuple:
#     print(value)


# while循环遍历
# index = 0
# while index < len(my_tuple):
#     # 通过下标获取指定的元素
#     value = my_tuple[index]
#     print(value)
#     index += 1

# 元组是不可变的  列表是可变的?
# 有时候我们需要保存一些数据 而这些数据不会改变 那么久应该使用元组进行保存
# 元组的不可变 是为了数据安全考虑
# my_tuple = ("hello", 3.14)
# my_tuple[0]
# my_tuple[1] = 3.1415926

# 定义一个空的元组 只要定义完成 就已经决定了数值 是不能改变的 -> 不可变的
my_tuple = ()


# 问题讲解
# True 为 1  False 为 0
# my_tuple = (3.14, True, "HELLO", 3.14)
#
# ret = my_tuple.index(True)
# print(ret)

三、字典

1.字典的定义

• 除列表外最灵活的数据类型

• 可以用来 存储多个数据

  • 以键值对（key：value）的形式

  • 用于存储描述一个 物体 的相关信息

• 用 {} 定义

• 使用 键值对 存储数据，键值对之间使用 , 分隔

  • 键 key 是索引
  • 值 value 是数据
  • 键 和 值 之间使用 : 分隔
  • 键必须是唯一的
  • 值 可以取任意数据类型，但 键 只能使用 不可变类型（字符串、数字或 元组）

2.字典的常用操作及应用场景

# 保存一个人的信息 (名字, 年龄 , 学号)
# my_list = ["小明", 22, "007"]
# 获取小明 0 代表是名字 1代表是年龄 2代表是学号
# 可读性不强
# print(my_list[0])
# print(my_list[1])
# print(my_list[2])

# 使用字典保存
# 格式: 字典名 = {键值1: 实值1, 键值2: 实值2, .....}
# 键值1: 实值1 统称为 键值对  key value 也称之为元素
# 键值数据类型的选择: 必须是不可变的
# 键值 的名字不能重复(才能完成1对1 通过一个key 获取key 的value)
# 字典的key 一般都是使用字符串
# 字典的value 没有规定 (可以重复的)
my_dict = {"name": "小明", "age": 22, "no": "007"}
# 三个元素(键值对)
print(len(my_dict))

# 定义一个特殊 (空字典)
my_dict1 = {}
print(len(my_dict1))
# <class 'dict'>
print(type(my_dict1))
my_dict2 = dict()
print(type(my_dict2))


- 在开发中的应用场景：
  - 使用 **多个键值对**，存储 **描述一个 `物体` 的相关信息** —— 描述更复杂的数据信息

• 字典是无序的 可变的

# 定义一个字典 名字 年龄 学号
# my_dict = {"name": "小红", "age": 22, "no": "009"}

	# <1>修改元素
# 字典的每个元素中的数据是可以修改的，只要通过key找到，即可修改
# 通过key 获取对应key的value的值
# print(my_dict["age"])
# # 通过key 修该对应key的value的值
# my_dict["age"] = 220
# print(my_dict)

	# <2>添加元素
# title - "哈哈"
# 格式: 字典名[key] = value
# 如果使用上面的格式 如果这个key不存在 添加一组键值对
#如果使用上面的格式 如果这个key存在 会吧key原来的value的值进行覆盖
# my_dict["title"] = "哈哈"
# print(my_dict)

	# <3>删除元素
# 对字典进行删除操作，有一下几种：
#
# del (python内置函数)
# clear()
my_dict = {"name": "小红", "age": 22, "no": "009"}
# 删除no 009
# 删除键值对 格式: del 字典名[key]
# del my_dict["no"]
# print(my_dict)

#  clear 删除字典中的所有的元素
my_dict.clear()
# 等价于 my_dict = {} 或者 my_dict = dict()
print(my_dict)

3.字典的遍历

# 可以遍历的 字符串 列表 元组 字典 -> for循环

# 自定义一个字符串
# my_name = "hello"
# for c in my_name:
#     print(c)


# 自定义一个列表 快速创建一个有规律的列表
# my_list = list("abcd")
# for value in my_list:
#     print(value)


# 自定义一个元组
# my_tuple = tuple("123456")
# for value in my_tuple:
#     print(value)


# 定义一个字典
# my_dict = {"name": "小红", "age": 22, "no": "009"}
#
# 遍历-key
# for key in my_dict.keys():
#     print(key)

# 遍历value
# for value in my_dict.values():
#     print(value)

# 遍历items
# for item in my_dict.items():
#     print(item[0])
#     print(item[1])


# 通过设置两个临时变量
# for key, value in my_dict.items():
#     print("key:", key)
#     print("value:", value)



# 如果想使用元素和下标索引 请使用enumerate(列表名)
# 定义一个列表
# my_list = list("abcd")
# 不仅要获取列表中的元素 而且需要知道这个元素下标索引
# for i, value in enumerate(my_list):
#     print(i,value)

四、集合

• 集合表示方法： {}
• 除 和字典相比，是没有 key 的

my_set = {“Coco”, ‘李三’, ‘马六’}
print(my_set)
print(len(my_set))

• 可变 ==》 不可变？？
• 添加，删除
• 没有顺序的

# print(my_set[1])
# print(my_set)

my_set = {"coco", 'caroline', 'coco', coco', 'caroline'}
print(my_set)

五、公共练习

import random
# 开区间闭区间

# 随机数
# [x, y]
# random.randint(x, y)

# 范围
# [x, y)
# range(x, y)

# 切片 -> 字符串中
# [x, y)
# "a"[x:y:步长]


# 数据类型 是可变 还是不可变

# 不可变的
# int float bool str 元组

# 可变的
# 列表 字典



# 公共方法--------------
# 运算符 +
# 列表
# 注意顺序
# my_list1 = [1, 2]
# my_list2 = [3, 5]
# ret1 = my_list2 + my_list1
# print(ret1)
# 字符串
# name = "小明"
# 占位符
# print("我叫%s" % name)
# ret = "我叫" + name
# ret1 = "我叫%s" % name
# print(ret1)

# 类型不统一 使用str()转类型
# name = "小明"
# age = 18
# ret2 = "我叫" + name + "年龄" + str(age)
# print(ret2)


# 元组
# ret3 = (1, 4) + (6, 9)
# print(ret3)


# 运算符 *
# 字符串
# my_str = "=="*20
# print(my_str)

# 列表
# my_list = ["hello", "world"]*10
# print(my_list)

# 元组
# my_tuple = (11,)*5
# print(my_tuple)



# in

# my_name = "world"
#
# if "l" in my_name:
#     print("存在")

# 元组
# my_tuple = (1, 3, 5)
# if 1 in my_tuple:
#     print("存在")

# 字典
# my_dict = {"name": "小红", "age": 22, "no": "009"}
# 使用in 在字典中其实是判断的是key存不存在
# if "name" in my_dict:
#     print("存在")

# print("测试")
# 就是想查看值到底有没有
# if "小红" in my_dict.values():
#     print("存在")



# del用法总结
# 可以配合列表使用
# my_list = [1, 2, 3]
# del my_list[1]

# 可以配合字典
# my_dict = {"name": "小红", "age": 22, "no": "009"}
# del my_dict["age"]

# 可以提前销毁一个对象
# num = 10
# 在程序没有结束的时候 程序员提前杀死了这个对象 提前释放内存
# NameError: name 'num' is not defined
# del num
# print(num)
#
# input()

# 监听当程序结束后 python会执行一个方法 del num 告知系统回收内存

总结

1.有时候我们需要保存一些数据 而这些数据不会改变 那么久应该使用元组进行保存
2.列表是可变的；元组是不可变的！元组（不可以修改的情况下。）元组性能要强于列表