字典（包含CRUD），函数（初步）与enumerate

一、字典

 

1、定义与访问

'''
字典 dict 定义使用{}  定义，是由键值对组成(key_value)
变量 = {key1: value, key2: value2,...}  一个key:value  键值对是一个元素
字典中的key 可以是字符串类型和数字类型(int ,float) 不能是 列表类型的
value 值是可以存放任意类型的
'''

# 1、定义空字典
my_dict = {}
my_dict1 = dict()
print(my_dict)  # {}
print(my_dict1)  # {}

# 2、定义带数据的字典
my_dict2 = {'name':'名之以父', 'age':18,'hobby':['Python','骑行','游戏'],1:{2,4,6}}
print(my_dict2)  # {'name': '名之以父', 'age': 18, 'hobby': 'Python’，‘骑行‘，’游戏', 1: {2, 4, 6}}

# 3、访问value值，在字典中没有下标的概念，使用key值访问对应的value值
print(my_dict2['age'])  # 18
print(my_dict2['hobby'][1])  # 骑行

两种定义字典方式，与列表，元组的方式一致

访问时必须要用key值去访问value值，在这里key充当了下标的作用

1. 在字典中可以包含列表，列表中能包含字典吗？
可以的， 列表 元组可以存放任意类型的数据，同样，字典中的 valu也可以是任意的类型，字典也可以作为字典的 value 值。

2、CRUD

（1）增加数据与修改数据

my_dict = {'name':'mingzi'}
print(my_dict)  # {'name': 'mingzi'}

'''

'''
my_dict['age'] = 18
print(my_dict)  # {'name': 'mingzi', 'age': 18}

my_dict['age'] = 19
print(my_dict)  # {'name': 'mingzi', 'age': 19}

# 注意：
my_dict[1] = 'int'
print(my_dict )  # {'name': 'mingzi', 'age': 19, 1: 'int'}

（2）删除数据

有pop方法和del方法，同样都是根据key值来找的

慎用del 

my_dict = {'name': 'mingzi', 'age': 19, 1: 'float',2:'aa'}

# 根据key值删除数据  del 字典名[key]
del my_dict[1]  # 这里的1不是下标，是key名
print(my_dict)  # {'name': 'mingzi', 'age': 19, 2: 'aa'}

# 字典.pop(key)  根据key值删除，返回值是删除的key对应的value值
result = my_dict.pop('age')
print(result)  # 19
print(my_dict)  # {'name': 'mingzi', 2: 'aa'}


# del 字典名   直接将这个字典删除了，不能再使用这个字典了
my_dict.clear()
print(my_dict)  # {}

# del字典名  直接将这个字典删除了，不能使用这个字典了
# del my_dict   #后面的代码不能再直接使用这个变量了，除非再次定义

# print(my_dict)   代码报错，未定义变量

（3）遍历（查数据）

.key()

.value()

.items()

for遍历直接遍历两个值，k，v，作为一个元组整体

my_dict = {'name': 'mingzi', 'age': [13,19], 'gender': '男'}

# for循环体直接遍历字典, 遍历的字典的key值
for key in my_dict:
    print(key, my_dict[key])
'''
# 字典.keys() 获取字典中所有的key值, 得到的类型是 dict_keys, 该类型具有的特点是
# 1. 可以使用list() 进行类型转换,即将其转换为列表类型
# 2. 可以使用for循环进行遍历
'''
result = my_dict.keys()
print(result, type(result))
for key in result:
    print(key)
print('=' * 30)

'''
# 字典.values() 获取所有的value值, 类型是 dict_values
# 1. 可以使用list() 进行类型转换,即将其转换为列表类型
# 2. 可以使用for循环进行遍历
'''
result = my_dict.values()
print(result, type(result))
for value in my_dict.values():
    print(value)

print('=' * 30)

'''
# 字典.items()  获取所有的键值对, 类型是 dict_items, key,value 组成元组类型
# 1. 可以使用list() 进行类型转换,即将其转换为列表类型
# 2. 可以使用for循环进行遍历
'''
result = my_dict.items()
print(result, type(result))
for item in my_dict.items():
    print(item[0], item[1])

print('=' * 30)

for k, v in my_dict.items():  # k 是元组中的第一个数据, v 是元组中的第二个数据
    print(k, v)

'''
name mingzi
age [13, 19]
gender 男
'''

最终的结果都一样的

二、enumerate

自动生成一个整体 ，把列表的下标和元素值作为一个元组整体

my_list = ['a', 'b', 'c', 'd', 'e']

for i in my_list :
    print(i)
'''
a
b
c
d
e
'''

for i in my_list :
    print(my_list.index(i), i)  # 得到的是下标和数据值
'''
0 a
1 b
2 c
3 d
4 e
'''


# enumerate 将可迭代序列中的元素所在的下标和具体元素数据组合在一起，变成元组
for j in enumerate(my_list):
    print(j)

'''
(0, 'a')
(1, 'b')
(2, 'c')
(3, 'd')
(4, 'e')
'''

三、函数

1、函数的定义和调用

函数是实现一个具体的功能

'''
函数：能实现一个具体的功能，是多行代码的整合
函数的定义：使用关键字def()
def 函数名():   # 函数名要遵循标识符的规则, 见名知意
    函数代码(函数体)
函数定义,函数中的代码不会执行,在函数调用的时候,才会执行
函数的好处: 重复的代码不需要多次书写, 减少代码冗余
'''

print('函数定义前')
# 函数的定义,函数的定义不会执行函数中的代码
def func():
    print("好好学习，天天向上")
    print('good good study,day day up')
    print('上课认真听讲')
    print("*"*30)


print('函数定义后')
# 函数调用的时候，才会执行函数中的代码   函数名()
print('函数调用前')
func()  # 代码会跳转到函数定义的地方去执行
print('函数调用后')
func()
func()

2、文档注释

# 函数的文档说明本质就是注释,告诉别人,这个函数怎么使用的,是干什么事的
# 只不过这个注释，有特定的位置书写要求，要写在函数名字的下方

def func():
    """
    打印输出一个hello world,
    """
    # aaa
    print('hello wold')


func()
# 查看函数的文档注释可以使用help(函数名)
# help(print)

help(func)  # 会得到解释，能看到文档注释，写在函数里面的注释通过这个方法就可以在控制台中看到了
'''
Help on function func in module __main__:

func()
    打印输出一个hello world,
'''

3、带参数的函数

'''
函数调用，如果函数在定义的时候有形参，那么在函数调用的时候，必须传递参数值
这个参数称为 实际参数,简称实参
在函数调用的时候,会将实参的值传递给形参
形参的个数需要与实参的个数相同，不多不少 
'''

# 定义一个函数，实现两个数的和
def add(a, b):  # a 和 b 称为形式参数，简称形参（函数定义时的参数）
    c = a + b
    print(f"求和的结果是{c}")


add(1, 2)
add(100, 200)

4、局部变量

"""
局部变量, 就是在函数内部定义的变量,就是局部变量
局部变量,只能在函数内部使用,不能在函数外部和其他函数中使用
"""
 

def func():
    # 定义局部变量
    num = 100
    print(num)


def func1():
    # 定义局部变量
    num = 200  # 两个num是没有任何关系的
    print(num)


# 函数调用
func()
func1()

# 探究:局部变量能否在函数外部使用
# print(num)  # 代码报错,局部变量不能在函数外部访问

5、全局变量 （globe）

globe方法：可以让局部变量在全局变量中使用，放在修改之前，（类似定义）

globe 变量名

# 全局变量： 就是在函数外部定义的变量。

# 定义全局变量
g_num = 100


# 1. 能否在函数内部访问全局变量?   ====> 可以直接访问全局变量的值
def func1():
    print(g_num)


# 2. 能否在函数内部修改全局变量的值?  ===> 不能直接修改全局变量的值
def func2():
    # g_num = 200  # 这里不是修改全局变量的值,是定义一个局部变量,和全局变量的名字一样而已
    # 想要在函数内部修改全局变量的值,需要使用 global 关键字声明这个变量为全局变量
    global g_num  # 之后g_num 可以被修改了
    g_num = 300
    print(g_num)


func1()  # 100
func2()  # 300
func1()  # 300

6、函数的返回值 

"""
函数想要返回一个数据值,给调用的地方,需要使用关键字 return
return 关键字的作用: ①, 将return 后边的数据值进行返回 ②,程序代码遇到return, 会终止(结束)执行
注意点: return 关键字必须写在函数中
"""

def add(a, b):
    c = a + b
    # 想要将求和的结果 c, 返回,即函数外部使用求和的结果, 不在函数内部打印结果
    return c
    print(f'求和的结果是{c}')   # 函数遇到return就结束了,不会执行return之后的代码


result = add(100, 200)
print(f'函数外部获得了求和的结果{result}')

print(add(10, 30))

 7、函数的多个返回值 

def func(a, b):
    c = a + b
    d = a - b
    # 需求: 想要将 c 和 d 都进行返回
    # 思考: 容器可以保存多个数据值, 那就可以将 c  和 d 放到容器中进行返回
    # return [c, d]
    # return (c, d)
    # return {'c': c, 'd': d}
    # return {0: c, 1: d}
    return c, d  # 默认是组成元组进行返回的


result = func(10, 20)
print(f"a+b的结果是{result[0]}, a-b的结果是{result[1]}")

8、函数的嵌套作用

def func1():
    print('func1 start ... ')
    print('函数的其他代码')
    print('func1 end ...')


def func2():
    print('func2 start ....')
    func1()  # 函数调用
    print('func2 end....')


# 调用func1()
# func1()


# 调用func2()
func2()
'''
func2 start ....
func1 start ... 
函数的其他代码
func1 end ...
func2 end....
'''

'''
禁止套娃！，否则会内存溢出(OOM)
'''

进阶： 

def func1(a):
    print('func1 start ... ')
    print('函数的其他代码', a)
    print('func1 end ...')


def func2(a):
    print('func2 start ....')
    a = a * a
    func1(a)  # 函数调用  此时a的值已经发生变化，变成100了
    print('func2 end....')


# 调用func1()
# func1()


# 调用func2()
func2(10)

'''
func2 start ....
func1 start ... 
函数的其他代码 100
func1 end ...
func2 end....
'''

9、函数的应用

# 1. 定义一个函数,打印一条横线
def print_line():
    print('-' * 30)


# 2. 定义一个函数,打印任意条数的横线
def print_lines(n):
    for i in range(n):
        print_line()


# print_line()
# print_lines(4)
print_lines(5)

四、公共方法