今天学习关于字典和函数定义的内容。
先是对字典dict的定义进行了描述，还有增删改查，字典是由键值对组成的。
# 字典 dict ，使用{}定义，由键值对组成
# 变量 = {key1:value1，......}
# 一个键值对是一个元素，字典的key可以是字符串类型或者数字类（int float），不能是列表
# value可以是任何类型
# 1.定义空字典
my_dict = {}
my_dict1 = dict()
print(my_dict,type(my_dict))
print(my_dict1,type(my_dict1))
# 2.定义带数据的字典
my_dict2 = {'name':'txt','age':18,'like':['学习','购物'],1:[2,5]}
print(my_dict2)
# 3.访问value值，在字典中没有下标的概念，使用key值访问对应的value值
print(my_dict2['age'])
print(my_dict2['like'][1])
# 如果key值不存在.代码会报错
# print(my_dict2['gender'])
# 字典.get（key）
print(my_dict2.get('gender')) # 如果key不存在，返回none
# 补充：get的使用
# my_dict2.get(key,数据值)
# 如果key存在返回key对应的value值，如果不存在返回书写的数据值
print(my_dict2.get('gender','男')) # 男
print(my_dict2.get('age',1)) # 存在返回了18，否则返回1
# 计算字典长度
print(len(my_dict2))
# 字典的添加和修改,使用key值进行添加和修改
# 字典[key] = 数据值，key值存在就是修改，不存在就是添加
my_dict = {'name':'txt'}
print(my_dict)
my_dict['age'] = 18 # 添加数据
print(my_dict)
my_dict['age'] = 22 # 修改数据
print(my_dict)
# 注意点，key值 int的1 和 float的1.0 代表一个数据
my_dict[1] = 'int'
print(my_dict) # {'name': 'txt', 'age': 22, 1: 'int'}
my_dict[1.0] = 'float'
print(my_dict) # {'name': 'txt', 'age': 22, 1: 'float'}
my_dict = {'name': 'txt', 'age': 22, 1: 'float'}
print(my_dict)
# 字典中删除数据
# 根据key值删除数据 del 字典名[key]
del my_dict[1]
print(my_dict)
# 字典.pop（key） 根据key值删除，返回值是删除的key对应的value值
result = my_dict.pop('age')
print(my_dict)
print(result) # 返回的是对应的value值
# 字典.clear（），清空字典，删除所有的键值对
my_dict.clear()
print(my_dict)
# del 字典名，直接删除字典，不能再使用这个变量了，除非再次定义
del my_dict # 很少进行使用
print(my_dict) # 代码报错，变量未定义
my_dict = {'name': 'txt', 'age': 22, 1: 'float'}
# 字典中遍历数据
# for循环直接遍历字典,遍历的是key值
for i in my_dict:
print(i,my_dict[i])
# 字典.keys(),获取字典中所有的key值，得到的类型是dict_keys,特点是
# 1.可以使用list()进行类型转换，即将其转换为列表类型
# 2.可以使用for循环进行遍历
result = my_dict.keys()
print(result,type(result)) #
for key in result:
print(key)
# 字典.values()，获取所有的value值，类型是dict_values
# 1.可以使用list()进行类型转换，即将其转换为列表类型
# 2.可以使用for循环进行遍历
result1 = my_dict.values()
print(result1,type(result1))
for value in result1:
print(value)
# 字典.itmes()，获取所有的键值对，类型是dict_items
# key，value组成元组类型
# 1.可以使用list()进行类型转换，即将其转换为列表类型
# 2.可以使用for循环进行遍历
result2 = my_dict.items()
print(result2,type(result2))
for item in result2:
print(item[0],item[1])
for k,v in my_dict.items(): # k是元组中的第一个数据，v是元组中的第二个数据
print(k,v)
my_list = ['a','b','c','d','e']
for i in my_list:
print(i)
for i in my_list:
print(my_list.index(i),i) # 下标，数据值
# enumerate(),与列表结合,将可迭代序列中元素所在的下标和具体元素数据组合在一块，变成元组
for j in enumerate(my_list):
print(j)
# 公共方法
# +，合并，字符串，列表，元组，得到新的容器
# * 整数，复制，字符串，列表，元组
# in/not in 判断存不存在，字符串，列表，元组，字典（key值是否存在）
# len,max,min,del
# max,min对于字典来说，比较的是key值大小
# 示例：my_dict = {'a':80,'b':20,'c':10}
# max(my_dict)
# 'c'
my_dict2 = {'name':'txt','age':18,'like':['学习','购物'],1:[2,5],
'aa':{'a':1,'b':2}}
print(my_dict2)
print(my_dict2['aa']['b'])
my_list = [{},{},{},my_dict2] # 套娃感
print(my_list) 下面是关于函数的笔记内容。
# 函数：print,len,input
# 函数可以实现一个具体的功能，是多行代码的整合
# 定义函数： def 函数名(): 代码（函数体），只有调用才会执行
# 函数名要遵循标识符的规则，见名知意
# 函数的好处：重复的代码不需要多次进行书写，减少代码冗余
print('函数定义前：')
def func():
print('好好学习')
print('good good study')
print('认真听讲哦')
# 函数调用，
print('函数定义后')
print('函数调用前')
func() # 代码跳转到函数定义处
print('调用后')
func()
func()
'''
# 函数的文档说明本质就是注释，告诉别人这个函数的使用方法以及用处
# 只不过这个注释有特定的位置书写要求，要卸载函数名字的下方
# def func():
# '''
# 打印输出一个love
# '''
# print('love')
# func()
# 查看函数的文档注释使用help（函数名）
# help(func)
# 定义一个带参数的函数
# 好处：可以使函数代码更加通用，适用更多的场景
# s实现两数之和
def add(a,b): # 形参,函数定义时的参数
# a = 10
# b = 20
c = a + b
print(f'求和结果是{c}')
# 若函数有形参，调用时要传递参数，
# 这里的参数称为实参，函数调用时的参数，形参个数与实参个数需相同
# 会将实参传递给形参
add(20,13)
add(1,2)
# 局部变量，就是在函数内部定义的变量
# 局部变量的生存周期就是当调用时被创建，调用结束后就销毁
# 只能在函数内部使用，不能在函数外部或者其他函数中使用
def func():
#定义局部变量
num = 100
print(num)
def func1():
num = 200 # 这里和func中的num没有关系
print(num)
func()
func1()
# print(num)代码报错，name 'num' is not defined
# 全局变量：在函数外部定义的变量
g_num = 100
# 1.能在函数内部访问全局变量
def func():
print(g_num)
# 2.不能直接修改全局变量的值，需要使用global关键字
def func1():
# g_num = 200 这里是定义一个局部变量，只是名字相同
# 想要在函数内部修改全局变量的值，需要使用global
global g_num
g_num = 20
func()
func1() # none
func()
# 函数返回值
# 在函数中定义的局部变量或者通过计算得出的局部变量，
# 想要在函数外部访问和使用，此时就可以使用return关键字，将这个返回值返回
# return 作用：将return后面的数据值进行访问，程序代码遇到return，会终止执行
# return 必须写在函数中
def add(a,b):
c = a + b
# 想要将求和结果返回c，在函数外部使用求和的结果
return c # 遇到return就结束，不会执行return后面的代码
print(f'={c}')
result = add(1,2) # 使用变量接收
print(result)
# return 返回多个数据值
# 程序代码遇到一个return之后，后续的代码不再执行，所以只能出现一个return
def func(a,b):
c = a + b
d = a - b
# 需求是将c，d都返回
# 容器可以保存多个数据组织，可以放入容器中返回
#return [c,d]
# 也可以返回一个元组（），字典也行{0:c,1:d}
return c,d # 默认是组成元组进行返回的
result = func(1,2)
print(f'求和结果是{result[0]},差结果是{result[1]}')
# return 关键字后边可以不写数据值，默认返回none，终止函数的运行
# 函数可以不写return，返回默认值是none
# 函数的嵌套调用
def func1():
print('func1 start')
print('函数其他代码')
print('func1 end')
def func2():
print('func2...')
func1() # 调用func1，调用其他的函数
print('func2 end...')
# func1()
func2()
# 应用
# 1.定义一个函数，打印一条横线
def func():
print('-'*30)
# 2.定义一个函数打印任意条数的横线
def print1(n):
for i in range(n):
func()
print1(5)
# 2.求三个数的和
def sum(a,b,c):
return a + b + c
print(sum(1,2,3)) # 6
# 3.求三个数的平均数
def avg(a,b,c):
res = sum(a,b,c)
return res/3 # /除法运算得到的数据是float类型
print(avg(1,2,3)) # 2.0
下面是两道测试题，今天还没得很多测试题。
# 1. 下面的代码输出结果是什么
num = 10
def anum():
num = 20 # 对于在函数内部的变量，如果改变没有global声明的变量，那么相当于是重新定义了一个与全局变量同名的局部变量
print(num) # 10，所以这里输出的是全局变量，没有去调用到函数内部的num
# 2.现在要调用abnum函数，但是怕在调用的时候将参数的位置传错，如何避免这个情况？
# def abnum(big, small, middle):
# .....#此处省略一千行代码
# 可以直接在函数定义下数据，这样子就不会混乱了
# 在填写个人资料时，如果选了女性，那么性别是女；如果不选性别，那就是默认是男，那么这个功能用函数怎么实现？
# 要求如下：定义一个函数gender，并在函数中将“所选性别为*”，并可以成功调用运行。
def gender(g = '男'): # 默认值是男的，如果用户不输入则返回男，输入为女则返回女
print("您的性别是:" + g)
gender()下面是这几天来的小小总结笔记：（直接跟着老师总结的）
1.标识符规则: 由字母,数字和下划线组成,不能以数字开头
2.变量名不能和关键字重名.
3.关键字是系统定义好的标识符,具有特殊的作用.
4.数据类型: int(整型) float(浮点型) str(字符串类型) bool(布尔类型, True False) list(列表) tuple(元组) dict(字典)
5.type() 函数可以查看变量的数据类型
6.输入: input() --> str 类型转换
输出: print() %s--字符串 %d -- int %f--float %--%%
7.f-string {变量}
8.逻辑运算符
and 逻辑与 一假为假
or 逻辑或 一真为真
not 逻辑非 取反
9.比较运算符
== （判等） != （不等）
10.判断 if elif else
11.循环 while
12.for xx in 容器/range():
pass
13.range(a, b, step) [a, b) 之间的整数
14.break 终止循环
continue 跳过本次循环,继续下次循环
循环 else 结构: 循环不是被 break 终止的时候会执行 else 中的代码
15.str: 下标 切片
16.list: insert append extend ...
17.tuple: 元组中的数据不能修改 查询的方法 index()
18.dict: key:value 键值对的形式
19.函数:
定义: 使用 def 关键字,
def 函数名(形参列表):
函数代码
return 数据
pass
20.只有调用该函数才会执行函数中的代码
函数名(实参列表) # 调用的格式
21.局部变量: 在函数内部定义的变量,只能在当前函数内部使用, 如果想要将这个变量在函数外部使用, ①可以 return 将这个变量返回 ② 使用 global,将其变为全局变量
22.全局变量: 在任意地方可以访问,想要在函数内部修改全局变量的值,使用 global 声明
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）