第五弹笔记，最近工作繁忙，加油加油

wangchoujuan

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

#支持下标索引
my_str=”it is a cat”
valu=my_str[2]
“t”

#字符串是不可修改的数据容器，如果必须要做修改只能得到新的字符串

#特定值的下标索引
语法：my_str.index(“element”)

#字符串的替换
语法：my_str.replace(“str1,str2”)
将字符串内的全部st1替换为str2
不是修改而是得到一个新的字符串

#字符串的分割
语法：my_str.split(“分隔字符串”)
按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中
字符串本身不变而是得到一个列表对象[“str1”,”str2”,”str3”......]

#字符串的规整操作
语法：my_str.strip()
去掉前后的空格
my_str.strip(字符串)
去掉前后指定字符串
# my_str.strip(“12”)实际去掉的是所有”1””2”两个

#统计字符串中某个字符串出现的次数
语法：my_str.count(字符串)

#统计字符串的长度
语法：len(my_str)

#支持while，for循环

19、数据容器的切片
序列:内容连续、有序、可使用下标索引的一类数据容器
列表、元组、字符串、均可以视为序列

切片：从一个序列中取出一个子序列
语法：序列[起始下标：结束下标：步长]
起始下标表示从何开始，留空视作从头开始
结束下标（不含）表示何处结束，留空表示截取到结尾
步长表示依次取得元素的间隔，默认为1，步长为负数表示反向取得，
此时起始下标和结束下标也需要反向标记
my_str[::-1]可实现字符串的倒序

#切片不会影响序列本身，实际是生成新的序列

19、集合
无序且不支持重复元素，可去重，不支持下标索引，允许修改
#定义
{元素1，元素2，元素3........}
变量名称={元素，元素，元素..........}
变量名称=set()

#添加新元素
语法：my_set.add(“element”)

#移除元素
语法：语法：my_set.remove(“element”)

#随机取出元素
语法：my_set.pop()

#清空集合
语法：my_set.clear()

# 取出两个集合的差集
语法：集合1.difference（集合2）
取出集合1和集合2的差集（集合1有而集合2没有的）
结果：得到一个新集合，集合1和集合2不变

#消除2个集合的差集
语法：集合1.difference_update（集合2）
功能：对比集合1和集合2，在集合1内，删除和集合2相同的元素
结果：集合1被修改，集合2不变

#2个集合合并
语法：集合1.union（集合2）
功能：将集合1和集合2组合成新集合
结果：得到新集合，集合1和集合2不变

# 统计集合的元素数量
len(set1)

# 集合的遍历
集合不支持下标索引不能用while循环，但可使用for循环
#21、字典
通过key找到其对应的Value

#定义
同样使用{}，但其存储的元素是一个个的：键值对
{key:value,key:value,key:value............}
my_dict={key:value,key:value,key:value............}
my_dict={}
my_dict=dict{}

#字典中的key不可重复，重复的key只会保留最后一个key对应的值

#通过key找到其对应的Value
my_dict[“key”]

#字典中的key与value可以为任意的数据类型（key不可为字典）
字典是可以嵌套的
my_dict={student1:{语文：100，数学：50}，studengt2:{语文：90，数学：80}}

my_dict={
student1:
{语文：100，数学：50}，
studengt2:
{语文：90，数学：80}
}
#通过换行使得格式更清晰，回车键无影响

#从嵌套字典里获取信息
my_dict[“student1”][“语文”]
100

# 新增元素
语法：字典[key]=value
如果已存在key执行后更新对应的value
原本没有则新增元素

#删除元素
语法：字典.pop(key)
获得指定的key对应的value，同时字典被修改，指定的key的数据被删除

#清空元素
语法：字典.clear()
将字典内的内容全部清空

#获取全部的key
语法：字典.keys()
得到字典的全部key,
#遍历字典
方式一：先取全部的key，再对keys遍历
for key in keys:
方式二：直接对字典for循环，每一次循环都是直接得到key
for key in my_dict():

#统计字典内的元素数量（键值对个数）
len(my_dict)

案例：
有如下员工信息用字典记录数据
通过for循环对所有级别为1的员工，级别上升1级，薪水增加1000元
info_dict={
"牛马1":{
"部门":"市场部",
"工资":5000,
"级别":2
},
"牛马2":{
"部门":"采购部",
"工资":4500,
"级别":1
},
"牛马3":{
"部门":"采购部",
"工资":4500,
"级别":2
}
}
for key in info_dict:
    if info_dict[key]["级别"]==1:
        info_dict[key]["工资"]+=1000
        print(f"{key}")
    else:
        continue
print(f"对员工进行升职加薪后的结果：{info_dict}")
结果：
牛马2
对员工进行升职加薪后的结果：{'牛马1': {'部门': '市场部', '工资': 5000, '级别': 2}, '牛马2': {'部门': '采购部', '工资': 5500, '级别': 1}, '牛马3': {'部门': '采购部', '工资': 4500, '级别': 2}}



对字典的修改若key对应的Value为一个序列，可直接对此序列内的特定值进行修改
如info_dict[key]["工资"]+=1000只修改了工资所对应的值

22、数据容器的其他操作
max(容器) 统计容器的最大元素
min(容器) 统计容器的最小元素


# 类型转换：容器转列表
list(容器)
# 类型转换：容器转元组
tuple(容器)
# 类型转换：容器转字符串
str(容器)
#类型转换：容器转集合
set(容器)

# 字典转换为字符串键值对中的值会保留，转换为其他类型键值对的值会丢失

# 容器通用排序功能
通用排序功能
sorted(容器,reverse=True)
reverse=True 降序，默认升序
排序的结果统统变为列表对象，字典排序丢失Value
例如：
my_list=[3,1,2,5,4]
my_tuple=[3,1,2,5,4]
my_str="bdcefg"
my_set={3,1,2,5,4}
my_dict={"key1":1,"key2":2,"key3":3,"key4":4,"key5":5}
print(f"列表对象的排序结果是：{sorted(my_list)}")
print(f"元组对象的排序结果是：{sorted(my_tuple)}")
print(f"字符串对象的排序结果是：{sorted(my_str)}")
print(f"集合对象的排序结果是：{sorted(my_set)}")
print(f"字典对象的排序结果是：{sorted(my_dict)}")

结果：
列表对象的排序结果是：[1, 2, 3, 4, 5]
元组对象的排序结果是：[1, 2, 3, 4, 5]
字符串对象的排序结果是：['b', 'c', 'd', 'e', 'f', 'g']
集合对象的排序结果是：[1, 2, 3, 4, 5]
字典对象的排序结果是：['key1', 'key2', 'key3', 'key4', 'key5']
23、字符串比较大小
在程序中，字符串所用的所有字符，如：
大小写英文单词
数字
特殊符号（@/）等都有其对应的ASCII码表值
每个字符都能对应上一个：数字的码值
字符串进行比较就是给予数字的码值大小的比较

比较方式：
字符串是按位比较，也就是一位位进行对比，只要有一位大，那么整体大

24、函数的多返回值
# 如果一个函数写两个return,程序只执行第一个

如果一个函数要有多个返回值：
按照返回值的顺序，写对应顺序的多个变量进行接收
变量之间用逗号隔开
支持不同类型的数据return

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

结果：
1
2

# 如果有n个返回值必须有n个变量与之对应进行接收，否则会报错
返回值的类型不受限制

25、函数的多种参数使用方式
位置参数：
调用函数时根据函数定义的参数位置来传递参数
传递的参数和定义的参数的顺序和个数必须一致
def user_info(name,age,gender):
    print(f"你的名字是{name},年龄是：{age},性别是：{gender}")

user_info("BOB",18,"man")
你的名字是BOB,年龄是：18,性别是：man

关键字参数：
函数调用时通过“键=值”形式传递参数
可以让函数更清晰，更容易使用，同时消除了参数的顺序要求
def user_info(name,age,gender):
    print(f"你的名字是{name},年龄是：{age},性别是：{gender}")

user_info(age=18,name="BOb",gender="man")
你的名字是BOb,年龄是：18,性别是：man

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

缺省参数：
又叫默认参数，用于定义函数时为参数提供默认值，调用时可不传该默认参数的值
所有的位置参数必须出现在默认参数之前，包括函数定义和调用）
当调用函数时没有传递参数就会使用默认是用缺省参数对应的值
def user_info(name,age,gender="man"):
    print(f"你的名字是{name},年龄是：{age},性别是：{gender}")
user_info("Bob",age=18)
你的名字是Bob,年龄是：18,性别是：man

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

不定长参数的类型：
1、位置传递
def user_info(*args):
print(args)
user_info(1,3,4)
(1, 3, 4)

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

2、关键字传递
def user_info(**kwargs):
    print(kwargs)
user_info(name="tom",age=18,ID=1514)
{'name': 'tom', 'age': 18, 'ID': 1514}
参数是键值对的形式，所有的键值对都会被接受，同时根据键值对组成字典

26、函数作为参数传递
函数本身也可作为参数传入另一个函数内
计算逻辑的传递而非数据的传递
def test_func(compute):
    result=compute(1,2)
    print(result)
def compute(x,y):
return x+y
test_func(compute)
3

27、lambda匿名函数语法：
lambda关键字可以定义匿名函数
有名称的函数可以基于名称重复使用
无名称的匿名函数只可临时使用一次

匿名函数定义语法：
lambda 传入参数：函数体（一行代码）
传入参数表示匿名函数的形式参数，如:x,y表示接收2个形式参数
函数体就是函数的执行逻辑，且只能写一行

FishC

你好，鱼油！你提到的关于字符串、数据容器的切片、集合的笔记总结得很全面。让我帮你进一步简化和强调关键点：

### 字符串

1. **定义**：字符串是字符的容器，可以存放任意数量的字符。

2. **支持下标索引**：

my_str = "it is a cat"
   val = my_str[1]  # "t"

3. **不可修改**：字符串不可变，修改需要创建新字符串。

4. **索引**某特定值：

index = my_str.index("i")  # 返回第一个"i"的索引

5. **替换**：

new_str = my_str.replace("cat", "dog")  # 替换为新字符串

6. **分割**：

list_str = my_str.split(" ")  # 按空格分割，生成列表 ['it', 'is', 'a', 'cat']

7. **去除空格**：

clean_str = my_str.strip()  # 去掉前后空格

8. **出现次数**：

count = my_str.count("i")  # 统计"i"出现的次数

9. **长度**：

str_len = len(my_str)  # 字符串长度

10. **支持循环**：`while`，`for`循环遍历。

### 数据容器的切片

1. **序列**：内容连续、有序、可下标索引（列表、元组、字符串）。
2. **切片**：

sub_seq = my_str[0:4:1]  # 从下标0到4，不包括4，步长为1
   reversed_str = my_str[::-1]  # 反向获取字符串，步长为-1

### 集合

1. **定义**：无序且不可重复，支持修改但不支持下标索引。

my_set = {1, 2, 3}
   empty_set = set()

2. **添加**：

my_set.add(4)

3. **移除**：

my_set.remove(2)

4. **随机取出**：

elem = my_set.pop()

5. **清空**：

my_set.clear()

6. **差集**：

diff_set = my_set.difference(another_set)  # 返回新集合

7. **消除差集**：

my_set.difference_update(another_set)  # 修改原集合

8. **合并**：

union_set = my_set.union(another_set)  # 返回新集合

9. **元素数量**：

len_count = len(my_set)

10. **遍历**：集合不支持下标索引。

for elem in my_set:
       print(elem)

希望这些总结对你有帮助，加油工作！

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。