首页 Python基础

# 数据容器 list

# 列表的定义

# 基本语法

# 定义变量
变量名称 = [元素1,元素2,元素3, ...]
# 定义空列表
变量名称 = []
变量名称 = list()
  1. 列表中的每一个数据，称之为元素
  2. 以 [] 作为标识
  3. 列表内每一个元素之间用，逗号隔开

# 元素类型限制

元素的数据类型没有任何限制，甚至元素可以是列表，定义嵌套列表

# 列表的下标索引

# 介绍

列表中每一个元素，都有其位置对应的下标 1，从前往后，从 0 开始，依次递增

# 根据索引取出元素

my_list = [1,2,3,4]
print(my_list[0])

# 列表常用操作

# 列表的查询功能

# 查找某元素下标

my_list = [1,2,3,4]
print(my_list.index(0))

# 列表的修改功能

# 修改特定位置（索引）的元素值

my_list = [1,2,3,4]
my_list[0] = 5

# 插入元素

my_list = [1,2,3]
my_list.insert(1,"baozi")

# 追加元素 append

my_list = [1,2,3]
my_list.append([4,5,6])		# 结果 [1,2,3,[4,5,6]]

# 追加元素 extend

my_list = [1,2,3]
my_list.extend([4,5,6])	# 结果 [1,2,3,4,5,6]

# 删除元素

my_list = [1,2,3]
del my_list[0]		# 结果 [2,3]
my_list = [1,2,3]
my_list.pop(0)		# 结果 [2,3] 但是返回值为 0
my_list = [1,2,3]
my_list.remove(2)	# 结果 [1,3]

# 清空列表内容

my_list = [1,2,3]
my_list.clear()

# 统计某元素在列表内的数量

my_list = [1,2,3,1]
my_list.count(1)		# 返回值为 2

# 统计列表内总共多少元素

my_list = [1,2,3]
print(len(my_list))		# 打印结果 3

# 列表方法

编号 使用方式 使用
1 列表.append (元素) 向列表中追加一个元素
2 列表.extend (容器) 将数据容器的内容一次取出，追加到列表尾部
3 列表.insert (下标，元素) 在指定下标处，插入指定的元素
4 del 列表 [下标] 删除列表指定下标元素
5 列表.pop (下标) 删除列表指定下标元素，返回删除的元素
6 列表.remove (元素) 从前往后，删除此元素第一个匹配项
7 列表.clear () 清空列表
8 列表.count (元素) 统计此元素在列表中出现的次数
9 列表.index (元素) 查找指定元素在列表的下标，找不到报错
10 len (列表) 统计容器内有多少元素

# 特点

  1. 可以容纳多个元素
  2. 可以容纳不同类型元素
  3. 数据是有序存储的
  4. 允许重复数据存在
  5. 可以修改

# list（列表）遍历

# for 循环遍历 —— 遍历元素

my_list = [1,3,4,5]
for element in my_list:
    print(element)

# for 循环遍历 —— 遍历下标

my_list = [1,3,4,5]
for index in range(0,len(my_list)):
    print(my_list[index])

# 数据容器 tuple

# 元组定义

元组同列表一样，都可以封装多个、不同类型的元素在内，但是元组一旦完成，就不可以修改，只读

# 定义元组变量
my_tuple = (元素1,元素2,元素3,...)
# 定义空元组
变量名称 = ()
变量名称 = tuple()

# 元组相关操作

编号 方法 作用
1 index() 查找某个数据，如果数据存在返回对应下标，否则报错
2 count() 统计某个数据在当前元组出现的次数
3 len (元组) 统计元组内元素个数 
my_tuple = (1,2,"hello")
print(my_tuple.index("hello"))
print(my_tuple.count("hello"))
print(len(my_tuple))

# 元组遍历

# for 循环遍历

my_tuple = (1,2,3,4)
for i in my_tuple:
    print(i)

# 特点

  1. 可以容纳多个数据
  2. 可以容纳不同类型数据
  3. 数据是有序存储的
  4. 允许重复数据存在
  5. 不可以修改（增加或者删除元素等）
  6. 支持 for 循环

# 数据容器 str

# 定义

字符串是字符的容器，一个字符串可以存放任意数量的字符

my_str = "baozi"
print(my_str[0])	# 结果为 b

# 字符串常用操作

# 查找特定字符串的下标索引值

my_str = "baozi"
print(my_str.index("zi")) # 结果是 3

# 字符串的特换

my_str = "baozi"
new_my_str = my_str.replace("zi","baobao")
print(new_my_str)	# 结果 baobaobao

# 字符串分割

name = "baozi baobao"
name_list = name.split(" ")
print(name_list)	# 结果：['baozi','baobao']

# 字符串的规整操作（去前后空格）

name = " baozi "
print(name.strip())

# 字符串规整操作（去前后指定字符串）

name = "baozi and baobao"
print(name.strip("and"))	# 结果是 baozi  baobao

# 统计字符串中某个字符出现次数

name = "baozi baobao"
print(name.count("b"))	# 结果为 3

# 统计字符串长度

name = "baozi"
print(len(name))	# 结果为 5

# 字符串遍历

my_str = "baozi"
for i in my_str:
    print(i)

# 特点

  1. 只可以存储字符串
  2. 长度任意（取决于内存大小）
  3. 支持下标索引
  4. 允许重复字符串存在
  5. 不可以修改（增加或删除元素等）
  6. 支持 for 循环

# 数据容器（序列）的切片

# 序列

序列是指：内容连续、有序，可使用下标索引的一类数据容器

# 序列常用操作 —— 切片

# 切片

  1. 切片：从一个序列中，取出一个子序列
  2. 语法：序列 [起始下标：结束下标：步长]

# 代码

my_list = [1,2,3,4]
new_list = my_list[1:3]	# 结果 [2,3,4]
my_list = [1,2,3,4]
new_list = my_list[1:3:2] # 结果 [2,4]

# 数据容器 set

# 集合的定义

# 定义集合变量
集合名称 = {元素,元素,元素,...}
# 定义空集合
集合名称 = set()

set 集合中，会自动去重，并且遍历结果无序

# 集合的常用操作 —— 修改

# 添加新元素

my_set = {"baozi","baobao"}
my_set.add("xiaobaozi")

# 移除元素

my_set = {"baozi","baobao"}
my_set.remove("baozi")

# 随机取出元素

my_set = {"baozi","baobao"}
element = my_set.pop()

# 清空集合

my_set = {"baozi","baobao"}
my_set.clear()

# 取出两个集合的差集

set1 = {1,2,3}
set2 = {1,5,6}
set3 = set1..difference(set2) # set3 结果 [2,3]

# 消除两个集合的差集

set1 = {1,2,3}
set2 = {1,5,6}
set1..difference_update(set2)	# set1 结果 [2,3],set2 结果 [1,5,6]

# 两个集合合并

set1 = {1,2,3}
set2 = {1,5,6}
set3 = set1.union(set2)		# set3 结果 [1,2,3,5,6]

# 集合长度

set1 = {1,2,3}
print(len(set1))

# for 循环遍历集合

set1 = {1,2,3}
for i in set1:
    print(i)

# 特点

  1. 可以容纳多个数据
  2. 可以容纳不同类型的数据（混装）
  3. 数据是无序存储的（不支持下标索引）
  4. 不允许重复数据存在
  5. 可以修改（增加或删除元素等）
  6. 支持 for 循环

# 数据容器 dict

# 字典的定义

# 定义字典变量
my_dict = {key: value, key: value,...}
# 定义空字典
my_dict = {}
my_dict = dict()
  1. 使用 {} 存储原始，每一个元素是一个键值对
  2. 每一个键值对包含 Key 和 Value（用冒号分隔）
  3. 键值对之间使用逗号分隔
  4. Key 和 Value 可以是任意类型的数据（key 不可为字典）
  5. Key 不可重复，重复会对原有数据覆盖

# 字典数据的获取

my_dict = {"baozi": 99, "baobao": 95}
print(my_dict["baozi"])		# 结果为 99

# 字典常规操作

# 新增元素

my_dict = {"baozi": 99, "baobao": 95}
my_dict["baoziya"] = 100

# 更新元素

my_dict = {"baozi": 99, "baobao": 95}
my_dict["baozi"] = 100

# 删除元素

my_dict = {"baozi": 99, "baobao": 95}
my_dict.pop("baozi")

# 清空字典

my_dict = {"baozi": 99, "baobao": 95}
my_dict.clear()

# 获取全部 key

my_dict = {"baozi": 99, "baobao": 95}
keys = my_dict.keys()

# 遍历字典

my_dict = {"baozi": 99, "baobao": 95}
keys = my_dict.keys()
for key in keys:
    print(my_dict[key])
my_dict = {"baozi": 99, "baobao": 95}
for key in my_dict:
    print(my_dict[key])

# 特点

  1. 可以容纳多个数据
  2. 可以容纳不同类型的数据
  3. 每一份数据是 KeyValue 键值对
  4. 可以通过 Key 获取到 Value，Key 不可重复（重复会覆盖）
  5. 不支持下标索引
  6. 可以修改（增加或删除更新元素等）
  7. 支持 for 循环，不支持 while 循环

# 数据容器通用操作

# 遍历

都支持 for 循环遍历

# 统计功能

  1. len (容器)： len(list)
  2. max (容器)： max(list)
  3. min (容器)： min(list)

# 容器相互转换功能

  1. list (容器)
  2. str (容器)
  3. tuple (容器)
  4. set (容器)

# 排序功能

给指定容器排序： sorted(容器,[reverse=True])

# 常用函数

功能 描述
通用 for 循环 遍历容器（字典是遍历 key）
max() 容器内最大元素
min() 容器内最小元素
len() 容器元素个数
list() 转换成列表
tuple() 转换成元组
str() 转换成字符串
set() 转成成集合
sorted (序列，[reverse=True]) 排序，reverse=True 表示降序，得到一个排好序的列表
更新于 阅读次数 次

请我喝[茶]~(￣▽￣)~*

Baozi 微信支付

微信支付

Baozi 支付宝

支付宝

Baozi 微信

微信