Python | 函数、数据容器

标签：容器 函数 Python 元素 list 列表 字符串 print my

1.函数

函数：是组织好的，可重复使用的，用来实现特定功能的代码段。

1.1 简单案例

重复使用计算字符串的长度

str1 = "heystar"
str2 = "python"
str3 = "abcd"

count = 0
for _ in str1:
    count += 1
print(f"字符串{str1}的长度是：{count}")

count = 0
for _ in str2:
    count += 1
print(f"字符串{str2}的长度是：{count}")

count = 0
for _ in str3:
    count += 1
print(f"字符串{str3}的长度是：{count}")

使用函数计算字符串的长度

# 以下为优化：
str1 = "heystar"
str2 = "python"
str3 = "abcd"


def my_len(data):
    cnt = 0
    for _ in data:
        cnt += 1
    print(f"字符串{data}的长度是：{cnt}")


my_len(str1)
my_len(str2)
my_len(str3)

1.2 使用函数的好处：

为了得到一个针对特定需求、可供重复利用的代码段
提高程序的复用性，减少重复性代码，提高开发效率

1.3 函数的基本定义

函数的定义

def 函数名(传入参数)
	函数体
	return 返回值

函数的调用

函数名(参数)

注意事项

• 参数如不需要,可以省略
• 返回值如不需要，可以省略
• 函数必须先定义后使用

简单案例

# 定义一个函数，输出相关信息
def say_hi():
    print("Hi~ o(*￣▽￣*)ブ")


# 调用函数
say_hi()

1.4 函数的参数

传入参数的功能是：在函数进行计算的时候，接受外部（调用时）提供的数据

多个参数案例

def add(x, y):
    result = x + y
    print(f"{x}+{y}={x + y}")


add(5, 6)

语法解析

• 函数定义中，提供的x和y，称之为∶形式参数（形参)，表示函数声明将要使用2个参数

  • 参数之间使用逗号进行分隔

• 函数调用中，提供的5和6，称之为:实际参数（实参)，表示函数执行时真正使用的参数值

  • 传入的时候,按照顺序传入数据,使用逗号分隔

函数的传入参数

传入参数的数量是不受限制的。

• 可以不使用参数
• 也可以仅使用任意N个参数

以上代码增加参数：

def add(x, y, z):
    result = x + y + z
    print(f"{x}+{y}+{z}={x + y + z}")



add(1, 2, 3)

1.5 函数的返回值

返回值：就是程序中函数完成事情后，最后给调用者的结果
函数体在遇到retuen后就结束了，所以写在return后的代码不会执行

语法格式

def 函数(参数...)
	函数体
	return 返回值


变量 = 函数(参数)

简单案例

def add(x, y, z):
    result = x + y + z
    return result


Sum = add(1, 2, 3)
print(Sum)

None类型

Python中有一个特殊的字面量：None，其类型是：<class 'NoneType'>
无返回值的函数，实际上就是返回了：None这个字面量

None表示：空的、无实际意义的意思
函数返回的None，就表示，这个函数没有返回什么有意义的内容。
也就是返回了空的意思。

None类型的应用场景

None作为一个特殊的字面量，用于表示:空、无意义，其有非常多的应用场景。

• 用在函数无返回值上

• 用在if判断上

  • 在if判断中，None等同于False
  • 一般用于在函数中主动返回None，配合if判断做相关处理

• 用于声明无内容的变量上

  • 定义变量，但暂时不需要变量有具体值，可以用None来代替

# 暂不赋予变量具体值
name = None

1.6 函数的说明文档

需要给函数添加说明文档，辅助理解函数的作用。
通过多行注释的形式，对函数进行说明解释

• 内容应写在函数体之前

格式：

def 函数名(参数)
	"""
	函数说明
	:param x:形参x的说明
	:param y:形参y的说明
	:return: 返回值的说明
	"""
	函数体
	return 返回值

1.7 函数的嵌套调用

所谓函数嵌套调用是指：一个函数里面调用了另外一个函数

简单案例

def fun_b():
    print("2")


def fun_a():
    print("1")
    fun_b()
    print("3")



fun_a()

如果函数A中，调用了另外一个函数B，那么先把函数B中的任务都执行完毕之后才会回到上次函数A执行的位置.

1.8 函数的变量作用域

变量作用域指的是变量的作用范围（变量在哪里可用，在哪里不可用）
主要分为两类：局部变量和全局变量

1.8.1 局部变量

所谓局部变量是定义在函数体内部的变量，即只在函数体内部生效

局部变量的作用：在函数体内部，临时保存数据，即当函数调用完成后，则销毁局部变量

1.8.2 全局变量

所谓全局变量,指的是在函数体内、外都能生效的变量

1.8.3 global关键字

使用global关键字，可以在函数内部声明变量为全局变量

1.9 函数的基本案例

模拟ATM机

• 定义一个全局变量：money，用来记录银行卡余额(默认5000000)
• 定义一个全局变量：name，用来记录客户姓名
• 定义如下函数：
  • 查询余额函数
  • 存款函数
  • 取款函数
  • 主菜单函数
• 要求：
  • 查询余额、存款、取款后都会返回主菜单
  • 存款、取款后，都应显示一下当前余额
  • 客户选择退出或输入错误，程序会退出，否则一直运行

代码

# ATM
money = 5000000
name = "HeyStar"


def menu():
    print(f"-------------主菜单-------------")
    print(f"\t查询余额\t\t[输入1]")
    print(f"\t存    款\t[输入2]")
    print(f"\t取    款\t[输入3]")
    print(f"\t退    出\t[输入4]")
    opt = int(input(f"\t请输入您的选择："))
    return opt


# 查询余额
def check_balance(user_name):
    print(f"------------查询余额-------------")
    print(f"{user_name}，您好，您的余额剩余：{money}")


# 存款
def deposit(user_name, user_money):
    print(f"-------------存款--------------")
    print(f"{user_name},您好，您存款50000元成功")
    user_money += 50000
    print(f"{user_name}，您好，您的余额剩余：{user_money}")
    return user_money


# 取款
def withdraw_money(user_name, user_money):
    print(f"-------------取款--------------")
    print(f"{user_name},您好，您取款50000元成功")
    user_money -= 50000
    print(f"{user_name}，您好，您的余额剩余：{user_money}")
    return user_money


while 1:
    op = menu()
    if op == 1:
        check_balance(name)
    elif op == 2:
        money = deposit(name, money)
    elif op == 3:
        money = withdraw_money(name, money)
    elif op == 4:
        break
    else:
        print(f"您输入的序号有误，请重新输入")

输出结果

1.10 函数返回多个返回值

• 样例代码

  def test_return():
  	return 1, 2
  
  
  x, y = test_return()
  print(x)
  print(y)
  

• 输出结果：
  

• 按照返回值的顺序,写对应顺序的多个变量接收即可

• 变量之间用逗号隔开

• 支持不同类型的数据return

1.11 函数的多种传参方式

1.11.1 位置参数

调用函数时，根据函数定义的参数位置来传递参数
传递的参数和定义的参数的顺序及个数必须一致

def user_info(name, age, gender):
    print(f"您的姓名是{name},年龄是{age},性别是{gender}")

user_info('Tom', 20, '男')

1.11.2 关键字参数

关键字参数：函数调用时通过 “键=值” 形式传递参数.
作用：可以让函数更加清晰、容易使用，同时也清除了参数的顺序需求.
样例代码：

def user_info(name, age, gender):
    print(f"您的姓名是{name},年龄是{age},性别是{gender}")

# 关键字传参：
user_info(name='Tom', age=20, gender='男')
# 不按照固定顺序：
user_info(age=20, name='Tom', gender='男')
# 与位置参数混用，但位置参数必须在前
user_info('Tom', age=20, gender='男')

函数调用时，如果有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序

1.11.3 缺省参数（默认值）

def user_info(name, age, gender='男'):
    print(f"您的姓名是{name},年龄是{age},性别是{gender}")


user_info('Tom', 20)

user_info('Aim', 20, '女')

输出结果：

1.11.4 不定长参数

不定长参数:不定长参数也叫可变参数,用于不确定调用的时候会传递多少个参数(不传参也可以)的场景
作用:当调用函数时不确定参数个数时，可以使用不定长参数
不定长参数的类型：

• 位置传递

  • 样例代码：

  def user_info(*args):
  print(args)
  
  
  # ('Tom')
  user_info('Tom')
  
  # ('Tom',18)
  user_info('Tom',18)
  

  传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组(tuple)，args是元组类型，这就是位置传递

• 关键字传递

  • 样例代码：

  def user_info(**kwargs):
      print(kwargs)
  
  
  # ('name'='Tom','age'=18,'id'=123)
  user_info(name='Tom', age=18, id=123)`
  

  参数是 “键=值” 形式的形式的情况下，所有的“键=值”都会被kwargs接受，同时会根据“键=值”组成字典

1.12 函数作为参数传递

样例代码：

def test_func(compute):
    result = compute(1, 2)
    print(result)


def compute(x, y):
    return x + y


test_func(compute)  # 结果：3

函数compute，作为参数，传入了test_func函数中使用。

• test_func需要一个函数作为参数传入，这个函数需要接收2个数字进行计算，计算逻辑由这个被传入函数决定
• compute函数接收2个数字对其进行计算，compute函数作为参数，传递给了test_func函数使用
• 最终，在test_func函数内部，由传入的compute函数，完成了对数字的计算操作
  所以，这是一种，计算逻辑的传递，而非数据的传递
  就像上述代码那样，不仅仅是相加，相见、相除、等任何逻辑都可以自行定义并作为函数传入。

1.13 lambda匿名函数

函数的定义中

• def关键字，可以定义带有名称的函数
• lambda关键字，可以定义匿名函数（无名称)
  有名称的函数，可以基于名称重复使用。
  无名称的匿名函数，只可临时使用一次。

定义语法：lambda 传入参数：函数体（一行代码）

• lambda是关键字，表示定义匿名函数
• 传入参数表示匿名函数的形式参数，如:x, y表示接收2个形式参数
• 函数体，就是函数的执行逻辑，要注意:只能写一行，无法写多行代码

样例代码：

def test_func(compute):
    result = compute(1, 2)
    print(result)


test_func(lambda x, y: x + y)  # 结果：3

注意事项：

• 匿名函数用于临时构建一个函数，只用一次的场景
• 匿名函数的定义中，函数体只能写一行代码，如果函数体要写多行代码，不可用lambda匿名函数，应使用def定义带名函数

2.数据容器

2.1 Python中的数据容器

一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素
每一个元素，可以是任意类型的数据，如字符串、数字、布尔等。

数据容器根据特点的不同：

• 是否支持重复元素
• 是否可以修改
• 是否有序
• 等
  分为5类：列表(list)、元组(tuple)、字符串(str)、集合(set)、字典(dict)

2.2 数据容器：List(列表)

2.2.1 列表的定义

基本语法：

# 字面量
[元素1，元素2，元素3，元素4，...]

# 定义变量
变量名称 = [元素1，元素2，元素3，元素4，...]

# 定义空列表
变量名称 = []
变量名称 = list() 

列表中的每一个数据，称之为元素

• 以[]作为标识
• 列表内每一个元素之间用，逗号隔开

列表可以一次存储多个数据，且可以为不同的数据类型，支持嵌套。

2.2.2 列表的下标索引

下标索引

可以从列表中取出特定位置的数据
列表中的每一个元素，都有其下标索引，从前往后，从0开始，依次递增

# 语法，列表[下标索引]

name_list = ['Tom', 'Lily', 'Rose']
print(name_list[0])
print(name_list[2])
print(name_list[1])

输出

Tom
Rose
Lily

反向索引

可以反向索引，也就是从右向左，从后向前：从-1开始，依次递减(-1、-2、-3......)

# 语法，列表[下标索引]

name_list = ['Tom', 'Lily', 'Rose']
print(name_list[-1])
print(name_list[-2])
print(name_list[-3])

输出

Rose
Lily
Tom

嵌套列表的下标

两层嵌套类似于二维列表

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

print(my_list[0][1])
print(my_list[1])
print(my_list[1][2])

输出

2
[4, 5, 6]
6

注意事项

• 要注意下标索引的取值范围，超出范围无法取出元素，并且会报错

2.2.3 列表的常用操作

列表除了可以:

• 定义
• 使用下标索引获取值
  以外，列表也提供了一系列功能:
• 插入元素
• 删除元素
• 清空列表
• 修改元素
• 统计元素个数
  等等功能，这些功能我们都称之为:列表的方法

2.2.3.1 列表的查询功能

• 查找某元素的下标
  • 功能：查找指定元素在列表的下标，如果找不到，报错ValueError
  • 语法：列表.index(元素)
    index 就是列表对象（变量）内置的方法（函数）
• 代码

my_list = ["hey", "hello", "star", "hi"]

# 下标存在
index = my_list.index("hello")
print(index)

# 下标不存在，会报错
index = my_list.index("he")
print(index)

输出结果

2.2.3.2 列表的修改功能

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

  • 语法：列表{下标} = 值
    可以使用如上的语法，直接对指定下标（正向、反向下标均可）的值进行：重新赋值（修改）

• 代码

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

# 正向下标
my_list[0] = 9
print(my_list)  # 当前列表为 [9, 2, 3, 4, 5]

# 反向下标
my_list[-2] = 8
print(my_list)  # 当前列表为 [9, 2, 3, 8, 5]

输出结果：

2.2.3.3 列表的修改功能

• 插入元素
  • 语法：列表.insert(下标，元素)，在指定的下标位置，插入指定的元素

代码：

my_list = [1, 2, 3]

my_list.insert(1,"HeyStar")
print(my_list)

输出结果：

2.2.3.4 列表的追加元素功能

• 语法：列表.append(元素)，将指定元素，追加到列表的尾部
• 或者：列表.extend(其他数据容器)，将其他数据容器的内容取出，一次追加到列表尾部

代码：

# 追加单个元素
my_list = [1, 2, 3]

my_list.append(4)
print(my_list)


# 追加一批元素
my_list = [1, 2, 3]

my_list.extend([4, 5, 6])
print(my_list)

输出结果：

2.2.3.5 列表的删除元素功能

• 语法1：del 列表[下标]
• 语法2：列表.pop(下标)
• 删除某元素在列表中的第一匹配项
  • 语法列表.remove(元素)

代码：

# 语法1
my_list = [1, 2, 3]

del my_list[0]
print(my_list)

# 语法2
my_list = [1, 2, 3]

my_list.pop(1)
print(my_list)

# 删除某元素在列表中的第一匹配项
my_list = [1, 2, 3, 2, 1]

my_list.remove(2)
print(my_list)

输出结果：

2.2.3.6 列表的清空功能

• 语法：列表.clear()

代码：

# 语法
my_list = [1, 2, 3]

my_list.clear()
print(my_list)

输出结果：

2.2.3.7 列表的统计元素功能

• 统计某元素在列表中的数量
• 语法：列表.count(元素)

代码：

# 语法
my_list = [1, 2, 3, 2, 1]

print(my_list.count(1))

输出结果

2.2.3.8 列表的统计全部元素功能

• 统计列表中全部的元素的数量
• 语法：len(列表)

代码：

# 语法
my_list = [1, 2, 3, 2, 1]

print(len(my_list))

输出结果：

2.2.3 列表的常用操作功能练习

有一个列表，内容是:[21,25,21,23,22,20]，记录的是一批学生的年龄
请通过列表的功能（方法)，对其进行

1．定义这个列表，并用变量接收它
2．追加一个数字31，到列表的尾部
3．追加一个新列表[29,33,30]，到列表的尾部
4．取出第一个元素（应是:21)
5．取出最后一个元素（应是:30)
6．查找元素31，在列表中的下标位置

代码：

students_age = [21, 25, 21, 23, 22, 20]

print(f"进行操作1后，目前列表内容为：{students_age}")

students_age.append(31)
print(f"进行操作2后，目前列表内容为：{students_age}")

students_age.extend([29, 33, 30])
print(f"进行操作3后，目前列表内容为：{students_age}")

print(f"操作4：")
print(students_age[0])

print(f"操作5：")
print(students_age[-1])

print(f"操作6：")
print(students_age.index(31))

输出结果：

2.2.4 列表的循环遍历

• 将容器内的元素依次取出进行处理的行为，称之为:遍历、迭代

2.2.4.1 如何遍历列表的元素

• 使用while循环

2.2.4.2 如何在循环中取出列表的元素

• 使用列表[下标]的方式取出

2.2.4.3 while循环条件的控制

• 定义一个变量表示下标，从0开始
• 循环条件为下标值 < 列表的元素数量

index = 0
while index < len(列表):
	元素 = 列表[index]
	对元素进行处理
	index += 1

2.2.4.4 for循环条件的控制

• 语法

for 临时变量 in 数据容器:
	对临时变量进行操作

表示，从容器内，依次取出元素并赋值到临时变量上。
在每一次的循环中，可以对临时变量（元素）进行处理。

2.2.4.5 代码练习

# while循环
def list_while_func():
    my_list = [1, 2, 3, 4, 5, 6]
    index = 0
    print("while循环操作：")
    print("列表的元素 { ", end='')

    while index < len(my_list):
        print(my_list[index], end='')
        index += 1

    print("}")


# for循环
def list_for_func():
    my_list = [1, 2, 3, 4, 5, 6]
    print("for循环操作：")
    print("列表的元素 { ", end='')
    for index in my_list:
        print(index,end=' ')

    print("}")


list_while_func()
list_for_func()

输出结果：

2.3 数据容器：tuple(元组)

元组和列表一样，都是可以封装多个、不同类型的元素在内。
不同点在于：元组一旦定义完成，就不可修改

2.3.1 元组的定义

定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型

# 定义元组字面量
(元素,元素,元素,......,元素)
# 定义元组变量
变量名称 = (元素,元素,元素,......,元素)
# 定义空元组
变量名称 = ()  			# 方法1
变量名称 = tuple()		# 方法2

代码练习：

# 定义元组
my_tuple1 = (1, 2, 3, "Hello", True)
my_tuple2 = ()
my_tuple3 = tuple()

print(f"my_tuple1的类型是：{type(my_tuple1)} , 内容是：{my_tuple1}")
print(f"my_tuple2的类型是：{type(my_tuple2)} , 内容是：{my_tuple2}")
print(f"my_tuple3的类型是：{type(my_tuple3)} , 内容是：{my_tuple3}")

输出结果：

注意事项
如果元组只有一个数据，这个数据后面需要添加逗号。
如：my_tuple1 = ("Hello",)

2.3.2 元组的嵌套

样例代码：

# 定义一个嵌套元组
my_tuple = ((1, 2, 3), (4, 5, 6))
print(f"my_tuple的类型是：{type(my_tuple)}，内容是：{my_tuple}")

输出结果：

2.3.3 元组的下标索引

样例代码：

# 下标索引取出内容
my_tuple = ((1, 2, 3), (4, 5, 6))
print(f"{my_tuple[1][2]}")

输出结果：

2.3.4 元组的相关操作

方法	作用
index()	查找某个数据，如果数据存在返回对应的下标，否则报错
count()	统计某个数据在当前元组出现的次数
len(元组)	统计元组内的元素个数

样例代码：

# 根据下标(索引)取出数据
t1 = (1, 2, 'hello')
print(t1[2])  # 结果：'hello'

# 根据index()，查找特定元素的第一个匹配项
t1 = (1, 2, 'hello', 3, 4, 'hello')
print(t1.index('hello'))  # 结果：2

# 统计某个数据在元组内出现的次数
t1 = (1, 2, 'hello', 3, 4, 'hello')
print(t1.count('hello'))  # 结果：2

# 统计元组内的元素个数
t1 = (1, 2, 3)
print(len(t1))  # 结果：3

输出结果：

2.3.5 元组的遍历

样例代码：

t1 = (1, 2, 3, 4, 5)
# 元组的遍历：while
index = 0
print(f"while循环遍历：", end='')
while index < len(t1):
    print(f"{t1[index]}", end=' ')
    index += 1

print()

# 元组的遍历：for
print(f"for循环遍历：", end='')
for element in t1:
    print(f"{element}", end=' ')

输出结果：

2.3.6 元组的注意事项

• 不可以修改元组的内容，否则会直接报错
• 可以修改元组内的List内容(修改元素、增加、删除、反转等)

2.3.7 元组的特点

• 可以容纳多个数据
• 可以容纳不同类型的教据（混装)
• 数据是有序存储的(下标索引)
• 允许重复数据存在
• 不可以修改（增加或删除元素等)
• 支持for循环

2.4 数据容器：str(字符串)

2.4.1 字符串的下标(索引)

与列表、元组一样，字符串也可以通过下标进行访问

• 从前往后，下标从0开始
• 从后向前，下标从-1开始
  样例代码：

# 通过下标获取特定位置字符
name = "HeyStar"
print(name[0])  # 输出：H
print(name[-1])  # 输出：r

同元组一样，字符串是一个：无法修改的数据容器。
所以：

• 修改指定下标的字符
• 移除特定下标的字符
• 追加字符等
  均无法完成。

2.4.2 字符串的常用操作

操作	说明
字符串[下标]	根据下标索引取出特定位置字符
字符串.index(字符串)	查找给定字符的第一个匹配项的下标
字符串.replace(字符串1,字符串2)	将字符串内的全部字符串1，替换为字符串2。不会修改原字符串，而是得到一个新的
字符串.split(字符串)	按照给定字符串，对字符串进行分隔不会修改原字符串，而是得到一个新的列表
字符串.strip()	移除首尾的空格和换行符或指定字符串
字符串.strip(字符串)	统计字符串内某字符串的出现次数
len(字符串)	统计字符串内某字符串的出现次数

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

  • 语法：字符串.index(字符串)
  • 样例代码：

  my_str = "it is HeyStar"
  print(my_str.index("is"))  # 结果：3
  

• 字符串的替换

  • 语法：字符串.replace(字符串1，字符串2)
  • 功能：将字符串内的全部:字符串1，替换为字符串2
  • 注意：不是修改字符串本身，而是得到了一个新字符串哦
  • 样例代码：

  my_str = "it is HeyStar"
  new_my_str = my_str.replace("it", "This")
  print(f"将字符串{my_str} ，进行替换后得到：{new_my_str}")
  

  • 输出结果：
    

• 字符串的分割

  • 语法：字符串.split(分隔符字符串)
  • 功能：按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中
  • 注意：字符串本身不变，而是得到了一个列表对象
  • 样例代码：

  my_str = "it is HeyStar"
  my_list = my_str.split(" ")
  print(f"将字符串{my_str}进行split切分后得到：{my_list}")
  

  • 输出结果：
    

• 字符串的规整操作(去前后空格)

  • 语法：字符串.strip()
  • 样例代码：

  my_str = "     it   is   HeyStar   "
  print(f"将字符串\"{my_str}\"进行strip规整后得到：\"{my_str.strip()}\"")
  

  • 输出结果：
    

• 字符串的规整操作(去前后指定字符串)

  • 语法：字符串.strip(字符串)
  • 样例代码：

  my_str = "12it is HeyStar21"
  print(f"将字符串\"{my_str}\"进行strip规整后得到：\"{ my_str.strip('12') }\" ")
  

  • 输出结果：
    
  • 注意：
    传入的是"12"，其实就是"1"和"2"都会移除，是按照单个字符

• 统计字符串中某字符串出现次数count

  • 语法：字符串.count(字符串)
  • 样例代码：

  my_str = "it is HeySitar"
  count = my_str.count("it")
  print(f"字符串\"{my_str}\"中it出现的次数是：{count}")
  

  • 输出结果：
    

• 统计字符串长度len

  • 语法：len(字符串)
  • 样例代码：

  my_str = "it is HeySitar"
  print(f"字符串\"{my_str}\"的长度{len(my_str)}")
  

  • 输出结果：
    

2.4.3 字符串的遍历

与列表、元组一样，字符串支持while循环和for循环进行遍历

• while循环

  my_str = "it is HeySitar"
  index = 0
  while index < len(my_str):
  	print(my_str[index])
  	index += 1
  

• for循环

  my_str = "it is HeySitar"
  for element in my_str:
  	print(element)
  

• 输出结果相同：
  

2.4.4 字符串的特点

作为数据容器，字符串有如下特点:

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

2.5 数据容器(序列)的切片

2.5.1 序列

序列是指：内容连续、有序，可使用下标索引的一类数据容器
列表、元组、字符串，均可以可以视为序列。

2.5.2 序列的常用操作 - 切片

语法：序列[起始下标:结束下标:步长]
表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列：

• 起始下标表示从何处开始，可以留空，留空视作从头开始
• 结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾
• 步长表示，依次取元素的间隔
  • 步长1表示，一个个取元素
  • 步长2表示，每次跳过1个元素取
  • 步长N表示，每次跳过N-1个元素取
• 步长为负数表示，反向取（注意，起始下标和结束下标也要反向标记)

本操作，不会影响序列本身，而是会得到一个新的序列

样例代码：

# 对list进行切片，从1开始，4结束，步长1
my_list = [0, 1, 2, 3, 4, 5, 6]
result1 = my_list[1:4:1]  # 步长默认为1,可省略
print(f"结果1：{result1}")

# 对tuple进行切片，从头开始，到最后结束，步长1
my_tuple = (0, 1, 2, 3, 4, 5, 6)
result2 = my_tuple[::]
print(f"结果2：{result2}")

# 对str进行切片,从头开始，到最后结束，步长2
my_str = "01234567"
result3 = my_str[::2]
print(f"结果3：{result3}")

# 对str进行切片，从头开始，到最后结束，步长-1
my_str = "01234567"
result4 = my_str[::-1]
print(f"结果4：{result4}")

# 对列表进行切片,从3开始，到结束,步长-1
my_list = [0, 1, 2, 3, 4, 5, 6]
result5 = my_list[3::-1]
print(f"结果5：{result5}")

# 对元组进行切片,从头开始，到尾结束，步长-2
my_tuple = (0, 1, 2, 3, 4, 5, 6)
result6 = my_tuple[::-2]
print(f"结果6：{result6}")

输出结果：

2.6 数据容器：set(集合)

2.6.1 集合的定义

内容无序

基本语法：

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

样例代码：

# 定义集合
my_set = {1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5}
my_set_empty = set()
print(f"my_set的内容是：{my_set}，类型是：{type(my_set)}")
print(f"my_set_empty的内容是：{my_set_empty}，类型是：{type(my_set_empty)}")

输出结果：

2.6.2 集合的常用操作

集合是无序的，所以集合不支持：下标索引访问

操作	说明
集合.add(元素)	集合内添加一个元素
集合.remove(元素)	移除集合内指定的元素
集合.pop()	从集合中随机取出一个元素
集合.clear()	将集合清空
集合1.difference(集合2)	得到一个新集合，内含2个集合的差集,原有的2个集合内容不变
集合1.difference_update(集合2)	在集合1中，删除集合2中存在的元素,集合1被修改，集合2不变
集合1.union(集合2)	得到1个新集合，内含2个集合的全部元素,原有的2个集合内容不变
len(集合)	得到一个整数，记录了集合的元素数量

• 添加新元素

  • 语法：集合.add(元素)。将指定元素，添加到集合内
  • 结果：集合本身被修改，添加了新元素
  • 样例代码：

  my_set = {"hello", "world"}
  my_set.add("HeyStar")
  print(my_set)
  

  • 输出结果：
    

• 移除元素

  • 语法：集合.remove(元素)。将指定元素，从集合内移除
  • 结果：集合本身被修改，移除了新元素
  • 样例代码：

  my_set = {"hello", "world", "HeyStar"}
  my_set.remove("HeyStar")
  print(my_set)
  

  • 输出结果：
    

• 从集合中随机取出元素

  • 语法：集合.pop(元素)。从集合中随机取出元素
  • 结果：会得到一个元素的结果。同时集合本身被修改，元素被移除
  • 样例代码：

  my_set = {"hello", "world", "HeyStar"}
  element = my_set.pop()
  print(my_set)
  print(element)
  

  • 输出结果：
    

• 清空集合

  • 语法：集合.clear()。清空集合
  • 结果：集合本身被清空
  • 样例代码：

  my_set = {"hello", "world", "HeyStar"}
  my_set.clear()
  print(my_set)
  

  • 输出结果：
    

• 取两个集合的差集

  • 语法：集合1.difference(集合2)。取出集合1和集合2的差集(集合1有而集合2没有的)
  • 结果：得到一个新集合，集合1和集合2不变
  • 样例代码：

  set1 = {1, 2, 3}
  set2 = {1, 4, 5}
  set3 = set1.difference(set2)
  print(set3)
  print(set1)
  print(set2)
  

  • 输出结果：
    

• 消除两个集合的差集

  • 语法：集合1.difference_update(集合2)。
  • 功能：对比集合1和集合2，在集合1内，删除和集合2相同的元素。
  • 结果：集合1被修改，集合2不变
  • 样例代码：

  set1 = {1, 2, 3}
  set2 = {1, 4, 5}
  set1.difference_update(set2)
  print(set1)
  print(set2)
  

  • 输出结果：
    

• 合并两个集合

  • 语法：集合1.union(集合2)。
  • 功能：将集合1和集合2合并成新集合
  • 结果：得到新集合，集合1和集合2不变
  • 样例代码：

  set1 = {1, 2, 3}
  set2 = {1, 4, 5}
  set3 = set1.union(set2)
  print(set3)
  print(set1)
  print(set2)
  

  • 输出结果：
    

• 统计集合元素数量

  • 语法：len(集合)。
  • 功能：统计一个集合里元素的数量
  • 样例代码：

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

  • 输出结果：
    

• 集合的遍历
  由于集合不支持下标索引，所以不能使用while循环

  • 样例代码：

  set1 = {1, 2, 3, 4, 5}
  for element in set1:
  	print(f"集合的元素有：{element}")
  

  • 输出结果：
    

2.7 数据容器：dict(字典、映射)

2.7.1 字典的定义

Key:Value

可以按照Key找出Value

字典的定义，使用{}，不过存储的元素是一个个的键值对：

# 定义字典字面量
{Key:value, Key:value, Key:value, ..., Key:value}
# 定义字典变量
my_dict = {Key:value, Key:value, Key:value, ..., Key:value}
# 定义空字典
my_dict = {} 			# 方式1
my_dict = dict()		# 方式2

如果一个字典内出现重复的Key，则这个Key的Value使用最新的Value

2.7.2 字典数据的获取

不可以使用下标索引！
只可以通过Key来取得相对应的Value

• 样例代码：

  my_dict = {"it": 90, "is": 80,"HeyStar": 70}
  print(my_dict["it"])
  print(my_dict["is"])
  print(my_dict["HeyStar"])
  

• 输出结果：
  

2.7.3 定义嵌套字典

字典的Key和Value可以是任意数据类型(Key不可为字典)

变量1 = {
	Key1:{
		Key2:Value,
		Key2:Value,
		Key2:Value,
	},
	Key1:{
		Key2:Value,
		Key2:Value,
		Key2:Value,
	}
}

• 样例代码：

  stu_score_dict = {
  	"Aim": {
  		"语文": 77,
  		"数学": 66,
  		"英语": 60
  	},
  	"Bob": {
  		"语文": 99,
  		"数学": 88,
  		"英语": 77
  	},
  	"Cao": {
  		"语文": 99,
  		"数学": 99,
  		"英语": 99
  	}
  }
  
  score = stu_score_dict["Aim"]["语文"]
  print(f"Aim的语文成绩：{score}")
  

• 结果输出：
  

2.7.4 字典的常用操作：

操作	说明
字典[Key]	获取指定Key对应的Value值
字典[Key] = value	添加或更新键值对
字典.pop(Key)	取出Key对应的Value并在字典内删除此Key的键值对
字典.clear()	清空字典
字典.keys()	获取字典的全部Key，可用于for循环遍历字典
len(字典)	计算字典内的元素数量

• 新增元素

  • 语法：字典[Key]=Value
  • 结果：字典被修改，新增了元素
  • 样例代码：

  stu_score_dict = {
  	"Aim": 66,
  	"Bob": 77,
  	"Cao": 99
  }
  stu_score_dict['Did'] = 88
  print(f"{stu_score_dict}")
  

  • 输出结果：
    

• 更新元素

  • 语法：字典[Key]=Value
  • 结果：字典被修改，元素被更新
  • 样例代码：

  stu_score_dict = {
  	"Aim": 66,
  	"Bob": 77,
  	"Cao": 99
  }
  stu_score_dict['Cao'] = 88
  print(f"{stu_score_dict}")
  

  • 输出结果：
    

• 删除元素

  • 语法：字典.pop(Key)
  • 结果：获得指定Key的Value，同时字典被修改，指定Key的数据被删除
  • 样例代码：

  stu_score_dict = {
  	"Aim": 66,
  	"Bob": 77,
  	"Cao": 99
  }
  stu_score_dict.pop("Bob")
  print(f"{stu_score_dict}")
  

  • 输出结果：
    

• 清空字典

  • 语法：字典.clear()
  • 结果：字典被修改，元素被清空
  • 样例代码：

  stu_score_dict = {
  	"Aim": 66,
  	"Bob": 77,
  	"Cao": 99
  }
  stu_score_dict.clear()
  print(f"{stu_score_dict}")
  

  • 输出结果：
    

• 获取全部的Key

  • 语法：字典.keys()
  • 结果：得到字典中的全部Key
  • 样例代码：

  stu_score_dict = {
  	"Aim": 66,
  	"Bob": 77,
  	"Cao": 99
  }
  keys = stu_score_dict.keys()
  print(f"{keys}")
  

  • 输出结果：
    

• 遍历字典

  • 样例代码：

  stu_score_dict = {
  	"Aim": 66,
  	"Bob": 77,
  	"Cao": 99
  }
  # 方式1：通过获取到全部的Key来遍历
  keys = stu_score_dict.keys()
  for key in keys:
  	print(f"字典的key是：{key}   对应的Value是：{stu_score_dict[key]}")
  
  # 方式2：直接对字典进行for循环，每次循环都得到key
  for key in stu_score_dict:
  	print(f"字典2的key是：{key}   对应的Value是：{stu_score_dict[key]}")
  

  • 输出结果：
    

• 统计字典内的元素数量

  • 语法：len(字典)
  • 样例代码：

  stu_score_dict = {
  	"Aim": 66,
  	"Bob": 77,
  	"Cao": 99
  }
  print(len(stu_score_dict))
  

  • 输出结果：
    

2.8 数据容器汇总

2.8.1 数据容器的分类

• 是否支持下标索引
  • 支持:列表、元组、字符串 – 序列类型
  • 不支持:集合、字典 – 非序列类型
• 是否支持重复元素:
  • 支持:列表、光组、字符串 – 序列类型
  • 不支持:集合、字典 – 非序列类型
• 是否可以修改
  • 支持:列表、集合、字典
  • 不支持:元组、字符串

2.8.2 数据容器的特点对比

来源@黑马程序员

2.8.3 数据容器的通用功能

• len(容器)
  统计容器的元素个数
• max(容器)
  统计容器的最大元素
• min(容器)
  统计容器的最小元素
• {sorted(容器)}
  对容器进行排序
• {sorted(容器),reverse=True}
  对容器进行反向排序

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

标签：容器,函数,Python,元素,list,列表,字符串,print,my
From： https://www.cnblogs.com/heystar/p/17605818.html