python学习笔记（四）

• 数据容器:dict(字典、映射)

使用字典，实现用key取出value的操作

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

#定义字典字面量

{key:value,key:value,…..,key:value}

#定义字典变量

My_dict={key:value,key:value,……,key:value}

#定义空字典

my_dict={}      #空字典定义方式1

my_dict=dict()   #空字典定义方式2

字典的key不可以重复，如果重复新的key的value会覆盖旧的key的value

字典的嵌套

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

例如：score = {

    "灵梦": {

        "语文": 90,

        "数学": 100

    },

    "塔兹米": {

        "语文": 80,

        "数学": 80

    }

}

print(score["灵梦"]["语文"])

输出结果为：90

字典不可以使用下标索引

·字典的常用操作

·新增元素

语法：字典[Key]=Value,结果：字典被修改，新增了元素

kk={"li":66,"kami":{"teng","shan"}}

kk["feng"]="qi"

print(kk)

·更新元素

语法：字典[Key]=Value,结果：字典被修改，元素被更新

注意：字典Key不可以重复，所以对已存在的Key执行上述操作，就是更新Value值

kk={"li":66,"kami":{"teng","shan"}}

kk["li"]="meng"

print(kk)

输出结果为：{'li': 'meng', 'kami': {'shan', 'teng'}}

·删除元素

语法：字典pop(Key),结果:获得指定Key的Value，同时字典被修改，指定Key的数据被删除

kk={"li":66,"kami":{"teng","shan"}}

ee=kk.pop("li")

print(ee,kk)

输出结果为：66  {'kami': {'teng', 'shan'}}

·清空字典

语法：字典.clear()，结果：字典被修改，元素被清空

kk={"li":66,"kami":{"teng","shan"}}

kk.clear()

print(kk)

输出结果为：{}

·获取全部的key

语法：字典.keys(),

结果：得到字典中的全部Key

kk = {"li": 66, "kami": {"teng", "shan"}}

print(kk.keys())

输出结果为：dict_keys(['li', 'kami'])

·遍历字典

方式一：通过获取到全部的key来完成遍历

kk = {"li": 66, "kami": {"teng", "shan"}}

aa = kk.keys()

for e in aa:

    print(e, kk[e])

输出结果为：

li 66

kami {'shan', 'teng'}

方法二：直接对字典进行for循环，每次循环都是直接得到key

kk = {"li": 66, "kami": {"teng", "shan"}}

for e in kk:

    print(e, kk[e])

输出结果为：

li 66

kami {'shan', 'teng'}

·统计字典内的元素数量，len()函数

kk = {"li": 66, "kami": {"teng", "shan"}}

print(len(kk))

输出结果为：2

字典的特点

·可以容纳多个数据

·可以容纳不同类型的数据

·每一份数据是KeyValue键值对

·可以通过Key获取到Value，Key不可重复（重复会覆盖）

·不支持下标索引

·可以修改（增加或删除更新元素）

·支持for循环，不支持while循环

二、数据容器对比总结

数据容器可以从以下视角进行简单分类：

·是否支持下标索引

·支持：列表、元组、字符串——序列类型  [],(),’’

·不支持：集合、字典——非序列类型      {}

·是否支持重复元素：

   ·支持：列表、元组、字符串——序列类型

   ·不支持：集合、字典——非序列类型

·是否可以修改

   ·支持：列表、集合、字典

   ·不支持：元组、字符串

基于各类数据容器的特点，它们的应用场景如下：

·列表(list)：一批数据，可修改，可重复的存储场景

·元组(tuple)：一批数据，不可修改、可重复的存储场景

·字符串(str)：一串字符串的存储场景

·集合(set)：一批数据，去重的存储场景

·字典(dict)：一批数据，可以Key检索Value的存储场景

三、数据容器的通用操作-遍历

·5类数据容器都支持for循环遍历

·列表、元组、字符串支持while循环，集合、字典不支持（无法下标索引）

数据容器通用方法：（5类都可以用）

len(容器)

统计容器的元素个数

max(容器)

统计容器最大的元素

min(容器)

统计容器的最小元素

例如：

my_list=[1,2,3]

my_tuple=(1,2,3,4,5)

my_str='itiheima'

print(f'数量{len(my_list)}，最大元素{max(my_list)}，最小元素{min(my_list)}')

print(f'数量{len(my_tuple)}，最大元素{max(my_tuple)}，最小元素{min(my_tuple)}')

print(f'数量{len(my_str)}，最大元素{max(my_str)}，最小元素{min(my_str)}')

输出结果为：

数量3，最大元素3，最小元素1

数量5，最大元素5，最小元素1

数量8，最大元素t，最小元素a

·容器的通用转换功能

list(容器)将给定的容器转换为列表

str(容器)将给定的容器转换为字符串

tuple(容器)将给定的容器转换为元组

set(容器)将给定的容器转换为集合

字典只有转换成字符串才会保留value值，转换成其他的都只会保留key，丢失value

·容器通用排序功能

sorted(容器,[reverse=True])（添加reverse=True是反向排序，不加为正向）

将给定容器进行排序

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

kk=sorted(my_list)

print(my_list)

print(kk)

结果为：

[1, 2, 3, 6, 5, 8, 2, 3]

[1, 2, 2, 3, 3, 5, 6, 8]

四、字符串大小比较

在程序中，字符串所用的所有字符如：

·大小写英文单词

·数字

·特殊符号（!、\、|、@、#、空格等）

都有其对应的ASCII码表值

每一个字符都能对应上一个：数字的码值

字符串进行比较就是基于数字的码值大小进行比较

字符串如何比较：

从头到尾，一位位进行比较，其中一位大，后面就无需比较了

五、python函数进阶

如果一个函数要有多个返回值，该如何书写代码？

def func():

    return 1,2

x,y=func()

print(x)

print(y)

输出值为：

1

2

按照返回值的顺序，写对应顺序的多个变量接受即可

变量之间用逗号隔开

支持不同类型的数据return

六、函数的多种传参方式

1.位置参数：调用函数时根据函数定义的参数位置来传递参数

【注意：传递的参数和定义的参数的顺序及个数必须一致】

def func(name, age, gender):

    print(f'您的名字{name}，年龄{age}，性别{gender}')





func('无常', '17', '男')

输出结果为：您的名字无常，年龄17，性别男

2.关键字参数：函数调用时通过”键=值”形式传递参数

作用：可以让函数更加清晰、容易使用，同时也清除了参数的顺序需求

def user_info(name,age,gender):

     print(f”您的名字是：{name},年龄是：{age},性别是:{gender}”)

#关键字传参

user_info(name=”小明”,age=20,gender=”男”)

#可以不按照固定顺序

user_info(age=20,gender=”男”, name=”小明”)

#可以和位置参数混用，位置参数必须在前，且匹配参数顺序

user_info(”小明”,age=20,gender=”男”)

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

3.缺省参数：缺省参数也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数的值（注意：所有位置参数必须出现默认参数前，包括参数定义和调用）

作用：当调用函数时没有传递参数，就会使用默认是用缺省参数对应的值

def user_info(name,age,gender=’男’):

    print(f”您的名字是：{name},年龄是：{age},性别是:{gender}”)

user_info(‘TOM’,20)

user_info(‘Rose’,18,’女’)

【注意;函数调用时，如果缺省参数传值则修改默认参数值，否则使用这个默认值】

4.不定长参数

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

作用：当调用函数时不确定参数个数时，可以使用不定长参数

不定长参数的类型：

• 位置传递
• 关键字传递

位置传递

【注意：传进的所有参数都会被args变量收集，它会根据传进参数的位置合并一个元组（tuple），args是元组类型，这就是位置传递】

例如：

def func(*args):

    print(args)





func(17, 'kami', '男')

输出结果为：(17, 'kami', '男')

关键字传递

【注意：参数是“键=值”形式的情况下，所有的“键=值”都会被kwargs接受

，同时会根据“键=值”组成字典】

例如;

def func(**kwargs):

    print(kwargs)





func(name="tazimi",age=17,wife="aisidesi")

输出结果为：{'name': 'tazimi', 'age': 17, 'wife': 'aisidesi'}

七、匿名函数

1.将函数作为参数传递

这其实是一种计算逻辑的传递，而非数据的传递，任何逻辑都可以自行定义并作为函数传入

2.lambda匿名函数

函数的定义中

·def关键字，可以定义带有名称的函数

·lambda关键字，可以定义匿名函数（无名称）

有名称的函数，可以基于名称重复使用

无名称的匿名函数，只可临时使用一次

匿名函数定义语法：

lambda 传入参数: 函数体(一行代码)

·lambda是关键字，表示定义匿名函数

·传入参数表示匿名函数的形式参数，如：x,y表示接收2个形式参数

·函数体，就是函数的执行逻辑，要注意：只能写一行，无法写多行代码

例如：

(lambda x, y: print(x + y))(1, 2)

输出结果为：3

八、文件的编码

最常用的UTF-8编码

九、文件的读取

内存中存放的数据在计算机关机后就会消失。要长久保存数据，就要使用硬盘、光盘、U盘等设备。为了便于数据的管理和检索，引入了”文件”的概念

文件的操作步骤：

大概可以分为三步：

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

【注意;可以只打开和关闭文件，不进行任何读写】

1.open()打开函数

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

open(name,mode,encoding)

name:是要打开的目标文件名的字符串（可以包含文件所在的具体路径）

mode:设置打开文件的模式（访问模式）：只读、写入、追加等

encoding:编码格式（推荐使用UTF-8）

示例代码：

f=open(‘python.txt’,’r’,encoding=”UTF-8”)

【注意：encoding的顺序不是第三位，所以不能用位置参数，用关键字参数直接指定】

【注意：此时的’f’是’open’函数的文件对象，对象是python中一种特殊的数据类型，拥有属性和方法，可以使用对象.属性或者对象.方法对其进行访问】

mode常用的三种基础访问模式

模式	描述
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式
w	打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，原有内容会被删除
a	打开一个文件用于追加。如果文件已存在，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入

2.读操作相关方法

read()方法：

文件对象.read(num)

num表示要从文件中读取的数据的长度（单位：字节），如果没有传入num，那么就表示读取文件中所有的数据

readlines()方法：

readlines可以按照行的方式把整个文件中的内容进行一次性读取，并且返回的是一个列表，其中每一行的数据为一个元素

readline()方法：一次读取一行内容

例如：

f=open(‘D:/测试.txt’,’r’,encoding=’UTF-8’)

#print(f.read())

print(f.readlines())

【注：\n是换行的意思】

也可以使用for循环，例如：

for line in f:

   print(f’每一行数据是：{line}’)

1. 关闭文件

#time.sleep(500000)#睡眠

f.close()

解除程序对文件的占用，不关闭会使文件处于占用状态，一定要记得关闭

5.with open 语法

with open(‘python.txt’,’r’) as f

f.readlines()

#通过在with open的语句块中对文件进行操作

#可以在操作完成后自动关闭close文件，避免遗忘掉close方法