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 | 函数、数据容器的更多相关文章

  1. 零基础学Python:数据容器

    1.常用操作 列表常用操作 在 ipython 中定义一个 列表,例如: l= list() 输入 l. 按下 TAB 键, ipython 会提示 字典 能够使用的函数如下: 可以到官方网址查询使用 ...

  2. python函数当容器

    def func(): pass func2 = func func2() i = [func,func2] for a in i: a() 函数名就是内存地址,加()代表执行

  3. python第三十四课——2.匿名函数配合容器函数的使用

    匿名函数配合容器函数的使用(了解) 1.匿名函数配合列表对象使用 lt=[lambda x:x**2,lambda x:x**3,lambda x:x**4] for i in lt: print(i ...

  4. python基础学习——数据容器

    1.数据容器相当于C的数组 有list,tuple(元组),str,set(集合),dict五种数据容器 2.list(列表) 列表中可存在不同的数据类型,可嵌套 #反向索引 name_list = ...

  5. 【Python】【容器 | 迭代对象 | 迭代器 | 生成器 | 生成器表达式 | 协程 | 期物 | 任务】

    Python 的 asyncio 类似于 C++ 的 Boost.Asio. 所谓「异步 IO」,就是你发起一个 IO 操作,却不用等它结束,你可以继续做其他事情,当它结束时,你会得到通知. Asyn ...

  6. 第三篇:python函数

    1.python函数 函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码段. 函数能提高应用的模块性,和代码的重复利用率.你已经知道Python提供了许多内建函数,比如print().但你 ...

  7. python基础6 ----python函数

    python函数 一.函数的参数 1.函数的参数从调用的角度来讲可以分为形式参数和实际参数,也可叫形参和实参.     形参:变量只有在被调用时才分配内存单元,在调用结束时,即刻释放所分配的内存单元. ...

  8. python 小数据池,代码块, is == 深入剖析

    python小数据池,代码块的最详细.深入剖析   一. id is == 二. 代码块 三. 小数据池 四. 总结 一,id,is,== 在Python中,id是什么?id是内存地址,那就有人问了, ...

  9. python函数-函数进阶

    python函数-函数进阶 一.命名空间和作用域 1.命名空间 内置命名空间 —— python解释器 就是python解释器一启动就可以使用的名字存储在内置命名空间中 内置的名字在启动解释器的时候被 ...

  10. Python函数03/函数名的第一类对象及使用/f 格式化/迭代器/递归

    Python函数03/函数名的第一类对象及使用/f 格式化/迭代器/递归 目录 Python函数03/函数名的第一类对象及使用/f 格式化/迭代器/递归 内容纲要 1.函数名的第一类对象及使用 2.f ...

随机推荐

  1. 2021-02-08:给定一个字符串str,请问这个字符串的最长回文子序列长度是多少?

    2021-02-08:给定一个字符串str,请问这个字符串的最长回文子序列长度是多少? 福哥答案2021-02-08: 自然智慧即可.1.原序列和反序列求公共子序列.无代码.2.递归.有代码.3.动态 ...

  2. 2021-02-26:一个数组arr是二叉树的中序遍历结果,每条边的开销是父节点和子节点的乘积,总开销是所有边的开销之和。请问最小总开销是多少?

    2021-02-26:一个数组arr是二叉树的中序遍历结果,每条边的开销是父节点和子节点的乘积,总开销是所有边的开销之和.请问最小总开销是多少? 链接:https://www.nowcoder.com ...

  3. status能否设置为布尔值类型,前端采用复选框形式

    是的,可以将status设置为布尔类型,这样可以在前端使用复选框形式展示.在模型中的定义可以如下: class Acceptance(models.Model): # ... status = mod ...

  4. Java 泛型:理解和应用

    概述 泛型是一种将类型参数化的动态机制,使用得到的话,可以从以下的方面提升的你的程序: 安全性:使用泛型可以使代码更加安全可靠,因为泛型提供了编译时的类型检查,使得编译器能够在编译阶段捕捉到类型错误. ...

  5. 百度飞桨(PaddlePaddle) - PP-OCRv3 文字检测识别系统 预测部署简介与总览

    百度飞桨(PaddlePaddle) - PP-OCRv3 文字检测识别系统 预测部署简介与总览 百度飞桨(PaddlePaddle) - PP-OCRv3 文字检测识别系统 Paddle Infer ...

  6. 新版idea快捷键总结学习----(用于java开发模式)

    选择代码区 ctrl w 如果放到以if开头的语句,可以选择if判断条件所在的代码片段 游标在单个单词下时 选择单词 在选中多个单词时,选择整个字符串 三次点击时,如果不在字符串单词下,用于选择{}内 ...

  7. C#使用HtmlAgilityPack解析Html 爬取图片和视频

    HtmlAgilityPack简介 HtmlAgilityPack是.net下的一个HTML解析类库.支持用XPath来解析HTML. 问题来了,有人就会问为什么要使用能XPath呢? 小编答:因为对 ...

  8. Pytorch-PyG图神经网络依赖环境安装(Anaconda)

    1.默认用户在Anaconda的虚拟环境中已安装Pytorch 2.打开anaconda prompt命令窗, activate "你的虚拟环境名称" 3.在激活后的虚拟环境下输入 ...

  9. 新建maven项目的时候idea的一些设置

    1.统一字符编码 2.开启注解生效激活 3.选择编译编码格式 4.设置忽略文件

  10. Redis基础(二)——列表操作、redis管道、Django中使用redis

    Redis列表操作 ''' lpush(name,values) rpush(name, values) 表示从右向左操作 lpushx(name,value) rpushx(name, value) ...