python基础2

已于 2024-01-12 19:47:43 修改
阅读量837 收藏 18
点赞数 17
分类专栏： python 文章标签： python 开发语言
于 2024-01-12 00:02:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52497285/article/details/135540057
版权

python基础1

python基础

1 函数

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

使用函数的好处是：

  • 将功能封装在函数内，可供随时随地重复利用
  • 提高代码的复用性，减少重复代码，提高开发效率

1.1 定义

# 函数的定义
def 函数名(传入参数):
	""" 
	函数说明文档 
	######
	"""
	函数体
	return 返回值

# 函数的调用
函数名(参数值)

1)参数如不需要，可以省略
2)返回值如不需要，可以省略
3)函数必须先定义后使用

def sum_num(a, b, c):
    return a + b + c
​
result = sum_num(1, 2, 3)
print(result)  # 6

1.2 函数的参数

函数的参数：函数调用的时候可以传入真实数据，增大函数的使用的灵活性

形参：函数定义时书写的参数(非真实数据)
实参：函数调用时书写的参数(真实数据)
传入参数时，实参要与形参一一对应，逗号隔开

位置参数

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

关键字参数

关键字参数：函数调用时通过“键=值”形式传递参数
可以让函数更加清晰、容易使用，同时也清除了参数的顺序需求
函数调用时，如果有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序

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

#可以和位置参数混用，位置参数必须在前，且匹配参数顺序
user_info("小明"， age=20, gender="男")

缺省参数

缺省参数：缺省参数也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数的值（注意：所有位置参数必须出现在默认参数前，包括函数定义和调用）
调用函数时没有传递参数，就会使用默认是用缺省参数对应的值
函数调用时，如果为缺省参数传值则修改默认参数值，否则使用这个默认值

不定长参数

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

包括①位置传递②关键字传递

在这里插入图片描述
在这里插入图片描述

"""
演示多种传参的形式
"""
def user_info(name, age, gender):
    print(f"姓名是:{name}, 年龄是:{age}, 性别是:{gender}")
# 位置参数 - 默认使用形式
user_info('小明', 20, '男')

# 关键字参数
user_info(name='小王', age=11, gender='女')
user_info(age=10, gender='女', name='潇潇')    # 可以不按照参数的定义顺序传参
user_info('甜甜', gender='女', age=9)

# 缺省参数（默认值）
def user_info(name, age, gender):
    print(f"姓名是:{name}, 年龄是:{age}, 性别是:{gender}")

user_info('小天', 13, '男')


# 不定长 - 位置不定长, *号
# 不定长定义的形式参数会作为元组存在，接收不定长数量的参数传入
def user_info(*args):
    print(f"args参数的类型是：{type(args)}，内容是:{args}")

user_info(1, 2, 3, '小明', '男孩')

# 不定长 - 关键字不定长, **号
def user_info(**kwargs):
    print(f"args参数的类型是：{type(kwargs)}，内容是:{kwargs}")
user_info(name='小王', age=11, gender='男孩')
"""
姓名是:小明, 年龄是:20, 性别是:男
姓名是:小王, 年龄是:11, 性别是:女
姓名是:潇潇, 年龄是:10, 性别是:女
姓名是:甜甜, 年龄是:9, 性别是:女
姓名是:小天, 年龄是:13, 性别是:男
args参数的类型是：<class 'tuple'>，内容是:(1, 2, 3, '小明', '男孩')
args参数的类型是：<class 'dict'>，内容是:{'name': '小王', 'age': 11, 'gender': '男孩'}
"""

1.3 返回值

返回值：函数调用后，返回需要的计算结果

变量=函数（参数）

None类型返回值等同于无返回值

  • 类型为<class ‘NoneType’>
  • 用于无返回值函数
  • 用于if判断-----None等同于False
  • 用于声明暂时无内容的变量

多返回值

按照返回值的顺序，写对应顺序的多个变量接收即可
变量之间用逗号隔开
支持不同类型的数据return

# 演示使用多个变量，接收多个返回值
def test_return():
    return 1, "hello", True


x, y, z = test_return()
print(x)
print(y)
print(z)

1.4 变量作用域

局部变量：定义在函数体内部的变量，即只在函数体内部生效
全局变量：指的是在函数体内、外都能生效的变量
global关键字，可使在函数内声明变量为全局变量

# 在函数内修改全局变量
num = 200

def test_a():
    print(f"test_a: {num}")
    
def test_b():
    num = 500  # 局部变量
    print(f"test_b: {num}")

test_a()
test_b()
print(num)
"""
test_a: 200
test_b: 500
200
"""

在函数内部写的num变为局部变量，所以最后num值仍为200

global关键字，在函数内声明变量为全局变量

# global关键字，在函数内声明变量为全局变量
num = 200

def test_a():
    print(f"test_a: {num}")

def test_b():
    global num      # 设置内部定义的变量为全局变量
    num = 500
    print(f"test_b: {num}")

test_a()
test_b()
print(num)
"""
test_a: 200
test_b: 500
500
"""

"""
演示函数综合案例开发
"""

# 定义全局变量money name
money = 5000000
name = None
# 要求客户输入姓名
name = input("请输入您的姓名：")
# 定义查询函数
def query(show_header):
    if show_header:
        print("-------------查询余额------------")
    print(f"{name}，您好，您的余额剩余：{money}元")


# 定义存款函数
def saving(num):
    global money    # money在函数内部定义为全局变量
    money += num
    print("-------------存款------------")
    print(f"{name}，您好，您存款{num}元成功。")

    # 调用query函数查询余额
    query(False)

# 定义取款函数
def get_money(num):
    global money
    money -= num
    print("-------------取款------------")
    print(f"{name}，您好，您取款{num}元成功。")

    # 调用query函数查询余额
    query(False)
# 定义主菜单函数
def main():
    print("-------------主菜单------------")
    print(f"{name}，您好，欢迎来到黑马银行ATM。请选择操作：")
    print("查询余额\t[输入1]")
    print("存款\t\t[输入2]")
    print("取款\t\t[输入3]")    # 通过\t制表符对齐输出
    print("退出\t\t[输入4]")
    return input("请输入您的选择：")

# 设置无限循环，确保程序不退出
while True:
    keyboard_input = main()
    if keyboard_input == "1":
        query(True)
        continue    # 通过continue继续下一次循环，一进来就是回到了主菜单
    elif keyboard_input == "2":
        num = int(input("您想要存多少钱？请输入："))
        saving(num)
        continue
    elif keyboard_input == "3":
        num = int(input("您想要取多少钱？请输入："))
        get_money(num)
        continue
    else:
        print("程序退出啦")
        break       # 通过break退出循环

1.5 函数作为参数传递

在这里插入图片描述

1.函数本身是可以作为参数，传入另一个函数中进行使用的。
2.将函数传入的作用在于：传入计算逻辑，而非传入数据。

"""
演示函数作为参数传递
"""

# 定义一个函数，接收另一个函数作为传入参数
def test_func(compute):
    result = compute(1, 2)  # 确定compute是函数
    print(f"compute参数的类型是:{type(compute)}")
    print(f"计算结果：{result}")

# 定义一个函数，准备作为参数传入另一个函数
def compute(x, y):
    return x + y
# 调用，并传入函数
test_func(compute)
"""
compute参数的类型是:<class 'function'>
计算结果：3
"""

1.6 lambda匿名函数

在这里插入图片描述
在这里插入图片描述

  • 匿名函数用于临时构建一个函数，只用一次的场景
  • 匿名函数的定义中，函数体只能写一行代码，
  • 如果函数体要写多行代码或要重复使用，不可用lambda匿名函数，应使用def定义带名函数
# 定义一个函数，接受其它函数输入
def test_func(compute):
    result = compute(1, 2)
    print(f"结果是:{result}")


# 通过lambda匿名函数的形式，将匿名函数作为参数传入
def add(x, y):
    return x + y

test_func(add)
test_func(lambda x, y: x + y)

2 数据容器

数据容器：一种可以存储多个元素的Python数据类型
Python的数据容器有：list(列表)、tuple(元组)、str(字符串)、set(集合)、dict(字典)
在这里插入图片描述

2.1 list(列表)

2.1.1 定义

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

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

[数据1, 数据2, 数据3, 数据4......]

"""
演示数据容器之：list列表
语法：[元素，元素，....]
"""
# 定义一个列表 list
my_list = ["itheima", "itcast", "python"]
print(my_list)
print(type(my_list))

my_list = ["itheima", 666, True]
print(my_list)
print(type(my_list))

# 定义一个嵌套的列表
my_list = [ [1, 2, 3], [4, 5, 6]]
print(my_list)
print(type(my_list))

# 通过下标索引取出对应位置的数据
my_list = ["Tom", "Lily", "Rose"]
# 列表[下标索引], 从前向后从0开始，每次+1，  从后向前从-1开始，每次-1
print(my_list[0])
print(my_list[1])
print(my_list[2])
# 错误示范；通过下标索引取数据，一定不要超出范围
# print(my_list[3])

# 通过下标索引取出数据（倒序取出）
print(my_list[-1])
print(my_list[-2])
print(my_list[-3])


# 取出嵌套列表的元素
my_list = [ [1, 2, 3], [4, 5, 6]]
print(my_list[1][1])

2.1.2 下标索引

在这里插入图片描述

表中的每一个元素，都有其位置下标索引，从前向后的方向，从0开始，依次递增

在这里插入图片描述

也可以反向索引l，也就是从后向前：从-1开始，依次递减（-1、-2、-3…)
从后向前，下标索引为：-1、-2、-3，依次递减

在这里插入图片描述

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

# 通过下标索引取出对应位置的数据
my_list = ["Tom", "Lily", "Rose"]
# 列表[下标索引], 从前向后从0开始，每次+1，  从后向前从-1开始，每次-1
print(my_list[0])
print(my_list[1])
print(my_list[2])
# 错误示范；通过下标索引取数据，一定不要超出范围
# print(my_list[3])

# 通过下标索引取出数据（倒序取出）
print(my_list[-1])
print(my_list[-2])
print(my_list[-3])


# 取出嵌套列表的元素
my_list = [ [1, 2, 3], [4, 5, 6]]
print(my_list[1][1])

2.1.3 常用操作

编号使用方式作用
1列表.append(元素)向列表中追加一个元素
2列表.extend(容器)将数据容器的内容依次取出，追加到列表尾部
3列表.insert(下标, 元素)在指定下标处，插入指定的元素
4del 列表[下标]删除列表指定下标元素
5列表.pop(下标)删除列表指定下标元素
6列表.remove(元素)从前向后，删除此元素第一个匹配项
7列表.clear()清空列表
8列表.count(元素)统计此元素在列表中出现的次数
9列表.index(元素)查找指定元素在列表中的下标，找不到报错ValueError
10len(列表)统计容器内有多少元素
11元素 in 列表判断指定数据在某个列表序列，如果在返回True，否则返回False
12元素 not in 列表判断指定数据不在某个列表序列，如果不在返回True，否则返回False
13列表序列.sort( key=None, reverse=False)reverse表示排序规则，reverse = True 降序， reverse = False 升序（默认）
14list.copy()复制

列表有如下特点：

  • 可以容纳多个元素（上限为2**63-1、9223372036854775807个）
  • 可以容纳不同类型的元素 (混装)
  • 数据是有序存储的 (有下标序号)
  • 允许重复数据存在
  • 可以修改 (增加或删除元素等)
"""
演示数据容器之：list列表的常用操作
"""
mylist = ["itcast", "itheima", "python"]
# 1.1 查找某元素在列表内的下标索引
index = mylist.index("itheima")
print(f"itheima在列表中的下标索引值是：{index}")
# 1.2如果被查找的元素不存在，会报错
# index = mylist.index("hello")
# print(f"hello在列表中的下标索引值是：{index}")

# 2. 修改特定下标索引的值
mylist[0] = "传智教育"
print(f"列表被修改元素值后，结果是：{mylist}")
# 3. 在指定下标位置插入新元素
mylist.insert(1, "best")
print(f"列表插入元素后，结果是：{mylist}")
# 4. 在列表的尾部追加```单个```新元素
mylist.append("黑马程序员")
print(f"列表在追加了元素后，结果是：{mylist}")
# 5. 在列表的尾部追加```一批```新元素
mylist2 = [1, 2, 3]
mylist.extend(mylist2)
print(f"列表在追加了一个新的列表后，结果是：{mylist}")
# 6. 删除指定下标索引的元素（2种方式）
mylist = ["itcast", "itheima", "python"]

# 6.1 方式1：del 列表[下标]
del mylist[2]
print(f"列表删除元素后结果是：{mylist}")
# 6.2 方式2：列表.pop(下标)
mylist = ["itcast", "itheima", "python"]
element = mylist.pop(2)
print(f"通过pop方法取出元素后列表内容：{mylist}, 取出的元素是：{element}")
# 7. 删除某元素在列表中的第一个匹配项
mylist = ["itcast", "itheima", "itcast", "itheima", "python"]
mylist.remove("itheima")
print(f"通过remove方法移除元素后，列表的结果是：{mylist}")

# 8. 清空列表
mylist.clear()
print(f"列表被清空了，结果是：{mylist}")
# 9. 统计列表内某元素的数量
mylist = ["itcast", "itheima", "itcast", "itheima", "python"]
count = mylist.count("itheima")
print(f"列表中itheima的数量是：{count}")

# 10. 统计列表中全部的元素数量
mylist = ["itcast", "itheima", "itcast", "itheima", "python"]
count = len(mylist)
print(f"列表的元素数量总共有：{count}个")

2.1.4 遍历

index=0
while index < Len（列表）:
	元素 = 列表[index]
	对元素进行处理
	index+=1

for 临时变量 in 数据容器:
	对临时变量进行处理

在这里插入图片描述

2.2 tuple(元组)

2.2.1 定义

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

定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型。
元组只有一个数据，这个数据后面要添加逗号，否则不是元组类型
元组也支持嵌套

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

# 定义3个元素的元组
t1 = (1,'Hello', True)
# 定义1个元素的元组
t2=（'Hello',) 	#注意，必须带有逗号，否则不是元组类型

2.2.2 常用操作

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

在这里插入图片描述

元组有如下特点：

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

多数特性和list一致，不同点在于不可修改的特性。

2.3 str(字符串)

在这里插入图片描述

和其它容器如列表、元组一样，字符串也可以通过下标进行访问
从前向后，下标从0开始
从后向前，下标从-1开始

在这里插入图片描述

编号操作说明
1字符串[下标]根据下标索引取出特定位置字符
2字符串.index(字符串)查找给定字符的第一个匹配项的下标
3字符串.replace(字符串1,字符串2)将字符串内的全部字符串1，替换为字符串2，但不会修改原字符串，而是得到一个新的字符串
4字符串.split(字符串)按照给定字符串，对字符串进行分隔，不会修改原字符串，而是得到一个新的列表
5字符串.strip() 或 字符串.strip(字符串)移除首尾的空格和换行符或指定字符串
6字符串.count(字符串)统计字符串内某字符串的出现次数
7len(字符串)统计字符串的字符个数
8join()用一个字符或子串合并字符串，即是将多个字符串合并为一个新的字符串
9capitalize()将字符串第一个字符转换成大写
10title()将字符串每个单词首字母转换成大写
11lower()将字符串中大写转小写
12upper()将字符串中小写转大写

字符串有如下特点：

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

字符串容器可以容纳的类型是单一的，只能是字符串类型，且字符串不可修改

2.4 切片

序列是指内容连续、有序，可使用下标索引I的一类数据容器列表、元组、字符串，均可以可以视为序列。
切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。
在这里插入图片描述

序列[开始位置下标:结束位置下标:步长]

"""
演示对序列进行切片操作
"""

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

# 对tuple进行切片，从头开始，到最后结束，步长1
my_tuple = (0, 1, 2, 3, 4, 5, 6)
result2 = my_tuple[:]     # 起始和结束不写表示从头到尾，步长为1可以省略
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结束，步长-1
my_list = [0, 1, 2, 3, 4, 5, 6]
result5 = my_list[3:1:-1]
print(f"结果5：{result5}")


# 对元组进行切片，从头开始，到尾结束，步长-2
my_tuple = (0, 1, 2, 3, 4, 5, 6)
result6 = my_tuple[::-2]
print(f"结果6：{result6}")
  • 不包含结束位置下标对应的数据， 正负整数均可；
  • 步长是选取间隔，正负整数均可，默认步长为1。
  • 起始可以省略，省略从头开始
  • 结束可以省略，省略到尾结束
  • 步长可以省略，省略步长为1 (可以为负数，表示倒序执行)
"""
演示序列的切片的课后练习
"万过薪月，员序程马黑来，nohtyP学"
"""
my_str = "万过薪月，员序程马黑来，nohtyP学"
# 倒序字符串，切片取出
result1 = my_str[::-1][9:14]
print(f"方式1结果：{result1}")
# 切片取出，然后倒序
result2 = my_str[5:10][::-1]
print(f"方式2结果：{result2}")

# split分隔"，"  replace替换"来"为空，倒序字符串
result3 = my_str.split("，")[1].replace("来", "")[::-1]
print(f"方式3结果：{result3}")

"""
方式1结果：黑马程序员
方式2结果：黑马程序员
方式3结果：黑马程序员
"""

2.5 set(集合)

不支持元素的重复（自带去重功能）、并且内容无序

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

创建集合使用{}或set()，但是如果要创建空集合只能使用set()，因为{}用来创建空字典。
因为要对元素做去重处理，所以无法保证顺序和创建的时候一致，不支持下标索引访问

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

集合有如下特点：

  • 可以容纳多个数据
  • 可以容纳不同类型的数据 (混装)
  • 数据是无序存储的 (不支持下标索引)
  • 不允许重复数据存在
  • 可以修改(增加或删除元素等）
  • 支持for循环，不支持while循环，因为不支持下标索引
"""
演示数据容器集合的使用
"""

# 定义集合
my_set = {"传智教育", "黑马程序员", "itheima", "传智教育", "黑马程序员", "itheima", "传智教育", "黑马程序员", "itheima"}
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)}")

# 添加新元素
my_set.add("Python")
my_set.add("传智教育")      #
print(f"my_set添加元素后结果是：{my_set}")
# 移除元素
my_set.remove("黑马程序员")
print(f"my_set移除黑马程序员后，结果是：{my_set}")
# 随机取出一个元素
my_set = {"传智教育", "黑马程序员", "itheima"}
element = my_set.pop()
print(f"集合被取出元素是：{element}, 取出元素后：{my_set}")

# 清空集合, clear
my_set.clear()
print(f"集合被清空啦，结果是：{my_set}")

# 取2个集合的差集
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.difference(set2)
print(f"取出差集后的结果是：{set3}")
print(f"取差集后，原有set1的内容：{set1}")
print(f"取差集后，原有set2的内容：{set2}")


# 消除2个集合的差集
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set1.difference_update(set2)
print(f"消除差集后，集合1结果：{set1}")
print(f"消除差集后，集合2结果：{set2}")

# 2个集合合并为1个
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.union(set2)
print(f"2集合合并结果：{set3}")
print(f"合并后集合1：{set1}")
print(f"合并后集合2：{set2}")

# 统计集合元素数量len()
set1 = {1, 2, 3, 4, 5, 1, 2, 3, 4, 5}
num = len(set1)
print(f"集合内的元素数量有：{num}个")

# 集合的遍历
# 集合不支持下标索引，不能用while循环
# 可以用for循环
set1 = {1, 2, 3, 4, 5}
for element in set1:
    print(f"集合的元素有：{element}")

"""
my_set的内容是：{'黑马程序员', 'itheima', '传智教育'}, 类型是：<class 'set'>
my_set_empty的内容是：set(), 类型是：<class 'set'>
my_set添加元素后结果是：{'黑马程序员', 'itheima', '传智教育', 'Python'}
my_set移除黑马程序员后，结果是：{'itheima', '传智教育', 'Python'}
集合被取出元素是：黑马程序员, 取出元素后：{'itheima', '传智教育'}
集合被清空啦，结果是：set()
取出差集后的结果是：{2, 3}
取差集后，原有set1的内容：{1, 2, 3}
取差集后，原有set2的内容：{1, 5, 6}
消除差集后，集合1结果：{2, 3}
消除差集后，集合2结果：{1, 5, 6}
2集合合并结果：{1, 2, 3, 5, 6}
合并后集合1：{1, 2, 3}
合并后集合2：{1, 5, 6}
集合内的元素数量有：5个
集合的元素有：1
集合的元素有：2
集合的元素有：3
集合的元素有：4
集合的元素有：5
"""

dict(字典、映射)

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

一般称冒号前面的为键(key)，简称k；冒号后面的为值(value)，简称v。

# 定义字典字面量
{key: value, key: value, ..., key: value}
# 定义字典变量
my_dict = {key: value, key: value,..., key: value}
# 定义空字典
my_dict = {}		# 空字典定义方式1
my_dict = dict()	# 空字典定义方式2
  • 使用{}存储原始，每一个元素是一个键值对
  • 每一个键值对包含Key和Value（用冒号分隔）
  • 键值对之间使用逗号分隔
  • Key和Value可以是任意类型的数据(key不可为字典）
  • Key不可重复，重复会对原有数据覆盖
  • 不可使用下标索引，可以通过Key值来取得对应的Value
# 从字典中基于Key获取Value
my_dict1 = {"王力鸿": 99, "周杰轮": 88, "林俊节": 77}
score = my_dict1["王力鸿"]
print(f"王力鸿的考试分数是：{score}")
score = my_dict1["周杰轮"]
print(f"周杰轮的考试分数是：{score}")
# 定义嵌套字典
stu_score_dict = {
    "王力鸿": {
        "语文": 77,
        "数学": 66,
        "英语": 33
    }, "周杰轮": {
        "语文": 88,
        "数学": 86,
        "英语": 55
    }, "林俊节": {
        "语文": 99,
        "数学": 96,
        "英语": 66
    }
}
print(f"学生的考试信息是：{stu_score_dict}")

# 从嵌套字典中获取数据
# 看一下周杰轮的语文信息
score = stu_score_dict["周杰轮"]["语文"]
print(f"周杰轮的语文分数是：{score}")
score = stu_score_dict["林俊节"]["英语"]
print(f"林俊节的英语分数是：{score}")
编号操作说明
1字典[Key]获取指定Key对应的Value值
2字典[Key] = Value添加或更新键值对
3字典.pop(Key)取出Key对应的Value，并在字典内删除此Key的键值对
4字典.clear()清空字典
5字典.keys()获取字典的全部Key，可用于for循环遍历字典
6len(字典)计算字典内的元素数量

字典有如下特点：

  • 可以容纳多个数据
  • 可以容纳不同类型的数据
  • 每一份数据是Key-Value键值对
  • 可以通过Key获取到Value，Key不可重复夏(重复会覆盖）
  • 不支持下标索引
  • 可以修改 (增加或删除更新元素等)
  • 支持for循环，不支持while循环
"""
演示字典的常用操作
"""
my_dict = {"周杰轮": 99, "林俊节": 88, "张学油": 77}
# 新增元素
my_dict["张信哲"] = 66
print(f"字典经过新增元素后，结果：{my_dict}")
# 更新元素
my_dict["周杰轮"] = 33
print(f"字典经过更新后，结果：{my_dict}")
# 删除元素
score = my_dict.pop("周杰轮")
print(f"字典中被移除了一个元素，结果：{my_dict}, 周杰轮的考试分数是：{score}")

# 清空元素, clear
my_dict.clear()
print(f"字典被清空了，内容是：{my_dict}")

# 获取全部的key
my_dict = {"周杰轮": 99, "林俊节": 88, "张学油": 77}
keys = my_dict.keys()
print(f"字典的全部keys是：{keys}")
# 遍历字典
# 方式1：通过获取到全部的key来完成遍历
for key in keys:
    print(f"字典的key是:{key}")
    print(f"字典的value是：{my_dict[key]}")

# 方式2：直接对字典进行for循环，每一次循环都是直接得到key
for key in my_dict:
    print(f"2字典的key是:{key}")
    print(f"2字典的value是：{my_dict[key]}")

# 统计字典内的元素数量, len()函数
num = len(my_dict)
print(f"字典中的元素数量有：{num}个")

2.6 通用功能

功能描述
通用for循环遍历容器 (字典是遍历key)
max()容器内最大元素
min()容器内最小元素
len()容器元素个数
list()转换为列表
tuple()转换为元组
str()转换为字符串
set()转换为集合
sorted(序列, [reverse=True])排序，reverse=True表示降序，得到一个排好序的列表
range(start, end, step)生成从start到end的数字，步长为 step，供for循环使用
enumerate()函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

推导式

作用：用一个表达式创建一个有规律的列表或控制一个有规律列表。
列表推导式又叫列表生成式。

# 列表推导式
[xx for xx in range()]
​
# 字典推导式
{xx1: xx2 for ... in ...}
​
# 集合推导式
{xx for xx in ...}


# 需求：创建一个0-10的列表
list1 = [i for i in range(10)]
print(list1)
# 0-10的偶数列表
list1 = [i for i in range(0, 10, 2)]
print(list1)

# 0-10的偶数列表
list1 = [i for i in range(10) if i % 2 == 0]
print(list1)

#多个for循环
list1 = [(i, j) for i in range(1, 3) for j in range(3)]
print(list1)
"""
[(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
"""


list1 = ['name', 'age', 'gender']
list2 = ['Tom', 20, 'man']
​# 合并为一个字典
dict1 = {list1[i]: list2[i] for i in range(len(list1))}
print(dict1)

counts = {'MBP': 268, 'HP': 125, 'DELL': 201, 'Lenovo': 199, 'acer': 99}
# 需求：提取上述电脑数量大于等于200的字典数据
count1 = {key: value for key, value in counts.items() if value >= 200}
print(count1)  # {'MBP': 268, 'DELL': 201}

3 文件操作

  1. 打开文件
  2. 读写文件
  3. 关闭文件

3.1 文件编码

编码就是一种规则集合，记录了内容和二进制间进行相互转换的逻辑。编码有许多中，我们最常用的是UTF-8编码。

3.2 文件读取

在python，使用open函数，可以打开一个已经存在的文件，或者创建一个新文件，语法如下：

open(name, mode, encoding)

name：是要打开的目标文件名的字符串(可以包含文件所在的具体路径)。
mode：设置打开文件的模式(访问模式)：只读、写入、追加等。
encoding:编码格式（推荐使用UTF-8）
encoding的顺序不是第三位，所以不能用位置参数，用关键字参数直接指定

模式描述
r以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
r+打开一个文件用于读写。文件指针将会放在文件的开头。
rb+以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
w打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
w+打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
a打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。
f = open('test.txt', 'w')  # 写文件打开
f.close()

# with open 语法操作文件 不需要关闭文件
with open("D:/测试.txt", "r", encoding="UTF-8") as f:
    for line in f:
        print(f"每一行数据是：{line}")
操作功能
文件对象 = open(file, mode, encoding)打开文件获得文件对象
文件对象.read(num)读取指定长度字节，不指定num读取文件全部
文件对象.readline()读取一行
文件对象.readlines()读取全部行，得到列表
for line in 文件对象for循环文件行，一次循环得到一行数据
文件对象.close()关闭文件对象
with open() as f通过with open语法打开文件，可以自动关闭
文件对象.seek(偏移量, 起始位置)用来移动文件指针，0-文件开头，1-当前位置，2-文件结尾

3.3 写入

f = open("D:/test.txt", "w", encoding="UTF-8")
# write写入
f.write("Hello World!!!")       # 内容写入到内存中
# flush刷新
f.flush()                       # 将内存中积攒的内容，写入到硬盘的文件中
# close关闭
f.close()                       # close方法，内置了flush的功能的
  • 直接调用write，内容并未真正写入文件，而是会积攒在程序的内存中，称之为缓冲区
  • 当调用flush的时候，内容会真正写入文件
  • 这样做是避免频繁的操作硬盘，导致效率下降 (赞一堆，一次性写磁盘)
  • close(方法，带有flush(方法的功能

文件如果不存在，使用”w”模式，会创建新文件文件
如果存在，使用”w”模式，会将原有内容清空

3.4 追加

# 打开文件，不存在的文件
f = open("D:/test.txt", "a", encoding="UTF-8")
# write写入
f.write("黑马程序员")
# flush刷新
f.flush()
# close关闭
f.close()

a模式，文件不存在，会创建文件
a模式，文件存在，会在最后，追加写入文件
可使用 " \n " 写换行符

3.5 文件与文件夹操作

在Python中文件和文件夹的操作要借助os模块里面的相关功能，具体步骤如下：

  1. 导入os模块
import os
  1. 使用os模块相关功能
os.函数名()
方法功能
os.rename(目标文件名, 新文件名)文件重命名
os.remove(目标文件名)删除文件
os.mkdir(文件夹名字)创建文件夹
os.rmdir(文件夹名字)删除文件夹
os.getcwd()获取当前目录
os.chdir(目录)改变默认目录
os.listdir(目录)获取目录列表
"""
需求：批量修改文件名，既可添加指定字符串，又能删除指定字符串。

步骤
	设置添加删除字符串的的标识
	获取指定目录的所有文件
	将原有文件名添加/删除指定字符串，构造新名字
	os.rename()重命名
"""
import os
​
# 设置重命名标识：如果为1则添加指定字符，flag取值为2则删除指定字符
flag = 1
​
# 获取指定目录
dir_name = './'
​
# 获取指定目录的文件列表
file_list = os.listdir(dir_name)
# print(file_list)
​
​
# 遍历文件列表内的文件
for name in file_list:
​
    # 添加指定字符
    if flag == 1:
        new_name = 'Python-' + name
    # 删除指定字符
    elif flag == 2:
        num = len('Python-')
        new_name = name[num:]
​
    # 打印新文件名，测试程序正确性
    print(new_name)
    
    # 重命名
    os.rename(dir_name+name, dir_name+new_name)
SkyChen_
关注
  • 17
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
《Python基础教程》专栏总结篇
weixin_43178406的博客
10-11 13万+
今天给大家带来的文章是《Python基础教程》专栏总结篇，希望能对同学们有所帮助。 文章目录 1. 背景 2. 专栏亮点 3. 你的收获 4. 详细目录
Python基础-基本语法
Gwais的博客
04-27 1万+
什么是编程语言 是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算 机发送指令，让计算机完成对应的工作。 简单来说，编程语言就是人类和计算机进行交流的语言 一、python的简介 1.1：python发展的背景 Python的作者，Guido von Rossum（吉多·范·罗苏姆，中国Python程序员都叫他 龟叔），荷兰人。Python 本身也是由诸多其他语言发展而来的，Python目前有两个版本，Python2.x和Python3.x 1
Python 基础（一）：入门必备知识
热门推荐
Python小二
10-30 111万+
Python 入门必备知识，你都掌握了吗？
Python数学基础2
qq_32649321的博客
11-04 8857
无
Python基础知识梳理
心皿月的博客
04-19 9913
一、Python语言编程特征 二、基本数据类型（5个） 变量： 常量 类型转换问题 三、输入、输出函数 四、运算符 1、算法运算符 2、逻辑运算符 3、成员运算符 五、随机值获取、重命名 1、获取随机值 2、重命名 六、if语句 七、for循环 八、while循环 java→面向对象 ，c →面向过程；而python介于java和c 之间，既面向对象，又面向过程。 一、Python语言编程特征 Python源文件通常用.py作为扩展名 Python.........
python语法基础
m0_52177571的博客
03-04 1万+
一、注释 分为两类：单⾏注释 和 多⾏注释。 单⾏注释 只能注释⼀⾏内容，语法如下： 多⾏注释 可以注释多⾏内容，⼀般⽤在注释⼀段代码的情况 单⾏： # 注释内容 ，快捷键ctrl+/ 多⾏： """ 注释内容 """ 或 ''' 注释内容 ''' 二、定义变量 变量名 = 值 变量名⾃定义，要满⾜标识符命名规则。 标识符 标识符命名规则是Python中定义各种名字的时候的统⼀规范，具体如下： 由数字、字⺟、下划线组成 不能数字开头 不能
python基础语法大全
yihouwen的博客
06-27 1万+
在学习机器学习和机器视觉初学过程中我们难免会忘记一些python的基础语法，此博客的目的是帮助大家回忆起一些python的基础简单语法结构，方便大家查阅。 输出： 1 yi i'm i'm ab math 举一个平方的例子 8 输出：0 1 2 1 2 3 4 function 函数定义格式 输出：7函数默认参数的定义 输出：5默认参数右边不......
面试-python基础知识
qq_38224014的博客
03-22 5011
python基础知识1.python的常用的数据结构有哪些？2.python的常用的数据类型？3.python生成随机数 random(0,10)可以生成包含0～10的随机数吗？4.python反转列表，reverse5.python中有没有用过装饰器、用装饰器的场景，理解装饰器中的逻辑吗？插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML
Python基础教程目录
老猿Python
03-23 6888
老猿Python博文目录 专栏：使用PyQt开发图形界面Python应用 老猿Python部分代码样例 老猿Python重难点知识博文汇总 老猿Python博客地址 第1章 Python学习环境构建目录 第2章 Python编程基础知识目录 第3章 Python的数据类型目录 第4章 基础知识进阶目录 第5章函数进阶目录 第6章 Python中的动态可执行方法目录 第7章 Python类型、类...
python的基础语法
HaoChaop的博客
04-06 1万+
1.运行python： 方式一：python交互模式 打开命令提示符： 输入python+回车 输入命令：print("hello world") 方式二：集成开发环境 先安装PyCharm 在pychar中输入：print("hello world"),右击点击Run“文件名” 方式三：命令行脚本 首先把PyCharm中要运行的文件保存到本地 然后打开命令提示符： 输入命令：python+文件的地址 例如：python+‪D:\Desktop\day1.py ..
人工智能python基础2
03-24
人工智能python基础2
python 基础.md
07-29
python零基础整理文档，包含测试代码
python语言基础2
08-11
python语言基础2，包含列表 List、元组 tuple、集合 Set、字典 Dictionary、if-else 语句、while 循环语句、break、continue等
Python入门基础教程全套.ppt下载
12-30
Python 入门基础教程全套 Python 是一种广泛应用的高级编程语言，开发环境的配置、程序执行原理是初学者必须掌握的知识点。本教程将带领读者了解 Python 的发展历程、特点、应用领域，并指导读者掌握 PyCharm 编写...
python基础知识汇总
01-02
python入门级别基础知识汇总讲解，适合刚入门，亦或是有一定编程基础的参考
python基础教程第二版答案-Python基础教程（第2版）.pdf
最新发布
06-12
《Python基础教程（第2版）》是一本全面介绍Python编程的指南，适合初学者入门。Python作为一种解释型、面向对象、动态数据类型的高级程序设计语言，因其简洁的语法和强大的功能而广受欢迎。该书分为基础篇和高级篇...
python基础教程.pdf
08-21
python基础教程
Python基础.xmind
09-01
资源是本人学习廖雪峰python时自己做的Xmind脑图！方便理解记忆。个人感觉有这个脑图，基本上1天python基础就可以搞定了！
Python基础教程2：全面学习资源指南
Python基础教程2是一份针对初学者和进阶者的综合性教程，旨在帮助读者掌握Python这门强大的编程语言。它不仅包含了电子书的学习资源，还提供视频教程，以便于理论知识和实践操作的结合。这份教程涵盖了Python语言的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值