目录
⭐一、元组
🔥元组总结
⭐二、字典
🔥字典的添加修改删除
🔥字典的删除
🔥在列表中放多个字典 然后进行删除
🔥字典的遍历和查询
🔥update()函数
🔥fromkeys函数
🔥dict
⭐三、集合
🔥集合思路
🔥添加元素
🔥集合的合并update
🔥集合中移除方法
⭐四、公共方法
🔥内置方法
⭐五、函数
🔥函数基础知识
🔥带参数的函数
🔥多个参数的函数
🔥默认参数值
🔥基础知识2
🔥 可变参数与拆包装包
🔥函数的返回值
🔥全局变量和局部变量
⭐六、函数的嵌套与闭包
🔥 全是重点
⭐一、元组
🔥元组总结
# 元组中的元素是不可以修改的
# 元组是使用的()小括号
# tuple 就是元组的意思
# 定义的方法
# 名称 = ()
# 元组需要注意的地方 （当元组里面存一个元素的时候 需要在后面加一个 ,）
# 举例
a1 = ('aa')
print(type(a1))
# 输出结果是 <class 'str'> 表示的是 字符串
a2 = ('aa',)
print(type(a2))
# 输出结果是 <class 'tuple'> 就表示的是 元组
# list(tuple) 这个是元组转成列表
# tuple(list) 这个是列表转成元组
⭐二、字典
🔥字典的添加修改删除
dict1 = {'age':10}
# 键是唯一的 值可以重复
# 字典的添加
dict1['name'] = '张三'
print(dict1)
# 输出结果是 {'age': 10, 'name': '张三'}
# 字典的修改
dict1['age'] = 12
print(dict1)
# 输出结果是 {'age': 12, 'name': '张三'} 这样原本的字典的值就被修改了
🔥字典的删除
# clear清空字典
dict1.clear()
print(dict1)
# pop删除 （根据键值删除 删除一对键值对）
dict1.pop('name')
print(dict1)
# 输出结果是 {'age': 12}
# popitem删除 （默认从后往前删除）
dict1.popitem()
print(dict1)
# 输出结果是 {'age': 12} 把name删除了
# del删除
del dict1['name']
print(dict1)
# 输出结果是 {'age': 12} 删除选择的键值的键值对
🔥在列表中放多个字典 然后进行删除
a = [{'age':10,'name':'张三','sex':'男'},{'age':10,'name':'张三','sex':'男'}]
for i in a:
i.pop('sex')
print(a)
# 这样使用for循环就可以进行 多个字典的删除了
🔥字典的遍历和查询
# 查询
a = {'age':10,'name':'张三','sex':'男'}
value = a.get('age')
print(value)
# 输出结果是 10 查询的时候 查的是键 取出的是键值
# 然后注意 get函数 查询不到键的时候 默认返回none 你也可以自己设置返回什么
value = a.get('age1','返回')
print(value)
# 输出结果是返回 这个就是你自己设置的值
# 遍历
for i in a:
print(i)
# 结果是
# age
# name
# sex
# 也就是说 直接for 遍历取出的是键
# 要拿键值就如下:
for i in a.values():
print(i)
# 结果是
# 10
# 张三
# 男
# 因为 values()代表的就是 取出里面的键值
# 那么相反 keys() 就是拿所有的键
# items() 拿一对键值对
print(a.items())
# 输出结果是 dict_items([('age', 10), ('name', '张三'), ('sex', '男')])
# 他会把 字典中的键值对 放到元组里面
for i in a.items():
print(i)
# 输出结果是('age', 10)
# ('name', '张三')
# ('sex', '男')
# 那么取出来 并且不要元组只要 里面的值就用这个方法
for i,m in a.items():
print(i,m)
# 输出结果是age 10
# name 张三
# sex 男
🔥update()函数
dict2 = {'a':1,'b':2}
a.update(dict2)
print(a)
# 输出结果是 {'age': 10, 'name': '张三', 'sex': '男', 'a': 1, 'b': 2}
# 相当于是合并2个字典
🔥fromkeys函数
c = dict.fromkeys(['c','d'],2)
print(c)
# 结果是{'c': 2, 'd': 2} 相当于创建一个新的字典
🔥dict
values = ['a','b','c']
keys = [1,2,3]
di = dict(zip(keys,values))
print(di)
⭐三、集合
🔥集合思路
# 然后集合就是没有键值对的
set1 = {'a'}
print(type(set1))
# 结果是 <class 'set'> 说明是集合
# 这里提供一个思路关于去重的
# 其实 去重列表可以使用强转 set也就是强转集合的方法去重
# 比如：
list1 = [1,2,3,4,1,2]
set2 = set(list1)
print(set2)
# 结果就是 {1, 2, 3, 4}
# 定义空集合需要这样定义
set3 = set()
🔥添加元素
set3.add('a')
print(set3)
# 结果是{'a'}
🔥集合的合并update
set4 = {'b'}
set5 = {'c'}
set4.update(set5)
print(set4)
# 结果是 {'b', 'c'} 所以意思就是 把set5合并到set4里面去
# 集合是没有下标的
🔥集合中移除方法
# 集合中移除方法
set6 = {'a','b','c','d'}
set6.remove('a')
print(set6)
# 结果就是 {'d', 'c', 'b'} 这样就删除了元素
# del删除方法的话 会把整个集合删除掉
del set6
# 这样就把整个集合删除了
# pop在集合中就是随机删除
# 集合： 交集 intersection 并集 union 差集 difference
set2 = {1,2,3,4,5}
set3 = {3,4,5,6,7,8}
res = set2.intersection(set3)
print(res)
# 结果就是 {3, 4, 5} 就求出了交集
res = set2.union(set3)
print(res)
# 结果是 {1, 2, 3, 4, 5, 6, 7, 8}
res = set2.difference(set3)
print(res)
# 结果是{1, 2}
# 然后有更简便的方法 就是
# &表示交集 直接运算
print(set2&set3)
# 结果{3, 4, 5}
# |表示 并集 - 表示差集
⭐四、公共方法
🔥内置方法
# 绝对值 abs
res = abs(-1)
print(res)
# 结果是1
# 内置函数 sorted 是可以直接排序的
# sorted是会排序 但是都会转成列表的形式
a = (1,4,2,5,8,3)
res = sorted(a,reverse=True)
print(res)
# 结果是[1, 2, 3, 4, 5, 8] 加参数 结果是 [8, 5, 4, 3, 2, 1]
⭐五、函数
🔥函数基础知识
import random
def a():
s = 'qwertyuiopasdfghjklzxcvbnm1234567890'
code = ''
for i in range(4):
# 用random.randint的话 就是用下标表示了 看代码
# b = random.randint(0,len(s)-1)
# 用这个也可以
b = random.choice(s)
code += b
print(code)
# 记住 写完以后要输出 不用print 直接 a() 调用函数即可
a()
🔥带参数的函数
def p(n):
s = 'qwertyuiopasdfghjklzxcvbnm1234567890'
code = ''
for i in range(n):
b = random.choice(s)
code += b
print(code)
p(5)
# 结果是6r8bp 这样就生成了5个 随机字符 参数n就是 5
🔥多个参数的函数
def a_sum(a, b):
s = a + b
print(s)
a_sum(2, 3)
# 结果是5
# 内置函数 isinstance判断类型的 isinstance(变量,类型) 返回的是布尔类型
def b_sum(a, b):
if isinstance(a, int) and isinstance(b, int):
print('类型一致')
else:
print('类型不一致')
b_sum(1, 2)
# 结果是类型一致
🔥默认参数值
# 默认参数值 就是在定义函数的时候 有一个或多个参数已经赋值
def people(name, age=10):
print('人名是：{},年龄是:{}岁'.format(name, age))
people('张三')
# 结果是人名是：张三,年龄是:10岁 如果不给age赋值 就默认是10
people('李四', 20)
# 赋值 就会覆盖默认值 结果是人名是：李四,年龄是:20岁
# 注意 普通参数在定义函数的时候 必须在默认参数的前面
def people_s(name, age=10, school='清华'):
print('人名是：{},年龄是:{}岁,{}学校'.format(name, age, school))
people_s('张三')
# 结果是人名是：张三,年龄是:10岁,清华学校
# 如果想改学校 但是不改年龄 可以这样
people_s('李四', school='北大')
# 结果是人名是：李四,年龄是:10岁,北大学校
# 这个默认值参数设定了以后 调用函数的时候 就必须按参数的顺序来
# 也就是 people_s(name,age,school) 得按这个顺序赋值
🔥基础知识2
book = ['三体', 'python', '西游记', 'java']
def ad_book(bookname):
book.append(bookname)
print('已增加')
def show_book(books):
for book in books:
print(book)
# 调用
ad_book('c++')
show_book(book)
# 结果是
# 已增加
# 三体
# python
# 西游记
# java
# c++
# 这样就添加成功了
🔥 可变参数与拆包装包
# 可变参数
# 先讲一些知识点
a, *b, c = 1, 2, 3, 4, 5
print(a)
print(b)
print(c)
# 结果是下面这个 在赋值的时候 加上*这个符号 会自动赋值多个数据
# 1
# [2, 3, 4]
# 5
# 然后注意 在这种情况下 会把多个值 用列表放在一起
# 在函数中使用这个 会用元组来放多个值
# 比如
def t_(*x):
print(x)
t_(1, 2)
t_(2, 3, 4)
# 结果是(1, 2)
# (2, 3, 4)
# 还有一个知识点
# 拆包和装包
a, b, c = (1, 2, 3)
print(a)
print(b)
print(c)
# 结果是下面这个 本来是一个元组 但是这样赋值会拆包 把元组拆开
# 1
# 2
# 3
a, b, *c = (1, 2, 3, 4, 5)
print(a)
print(b)
print(c)
# 结果是下面这个 这样就是 装包 先把元组拆开 拆包以后 c是带*的 所以给他装包
# 1
# 2
# [3, 4, 5]
# 在函数中 定义函数的时候 加* 是装包 调用函数的时候 加*是拆包
# def t_sum(*x):
# print(x)
# n = 0
# for i in x:
# n += i
#
#
# list2 = [1, 2, 3]
# t_sum(list2)
# 如果是这样 输出结果是 这说明 在定义函数的时候加* 只是装包 因为把整个列表放到元组里 进行装包
# ([1, 2, 3],)
# 然后会报错
# 如果是这样
def t_sum(*x):
print(x)
n = 0
for i in x:
n += i
print(n)
list2 = [1, 2, 3]
t_sum(*list2)
# 这样输出结果就是 这样就有了拆包和装包的过程
# (1, 2, 3)
# 6
# 可变参数中2个**的问题
def x_a(**x):
print(x)
# 看拆包的过程
for a, b in x.items():
print(a, b)
# items()就是看 键 和 值的
# 这个可变是可以随意赋值 但是要按下面这个格式
x_a(name='张三')
x_a(name='李四', age=10)
# 结果是
# {'name': '张三'}
# {'name': '李四', 'age': 10}
# 这里一个知识点
# 一个*是拆的列表和元组的包
# 2个*是拆的字典的包
c = {'name': '张三', 'age': 20, 'school': '清华'}
x_a(**c)
# 这样就看到拆包的过程
# name 张三
# age 20
# school 清华
# 一个*的 就是输出的元组 2个*输出的是 字典
# 2个不一样的也可以 一个是1个* 一个是2个*
# 1个*的赋值方式是 元组 2个*的赋值方式是字典
def x_s(*x, **y):
print(x)
print(y)
c = {'name': '张三', 'age': 20, 'school': '清华'}
x_s('张三', '李四', **c)
# 结果是
# ('张三', '李四')
# {'name': '张三', 'age': 20, 'school': '清华'}
🔥函数的返回值
# 函数的返回值
def getsum(*x):
a = 0
for i in x:
a += i
return a
# 这里返回了a 如果不返回a 外面是使用不了里面的这个a的值的
# 外面使用这个函数里面的值 要给一个变量去使用 让b等于函数调用 然后赋值
b = getsum(1, 2, 3)
print(b)
# 结果是 6 说明已经使用到了里面a的值
# 返回值的注意事项 返回值如果是返回2个值 返回的就是元组
# 比如 return a,b 接收以后 输出 就会是(a,b)
# 看例题
def maxmin(x):
for i in range(0, len(x) - 1):
for j in range(0, len(x) - 1 - i):
if x[j] > x[j + 1]:
x[j], x[j + 1] = x[j + 1], x[j]
max = x[-1]
min = x[0]
return max, min
list1 = [1, 8, 4, 6, 7, 2]
z = maxmin(list1)
print(z)
# 结果就是 (8, 1) 就会返回元组
# 但是我们可以这样
m, n = maxmin(list1)
print(m, n)
# 结果是8 1 利用元组特性来赋值
🔥全局变量和局部变量
# 全局变量和局部变量
# global
# 不可变类型才要添加global
# 可变类型不用加
# 不可变的定义就是 改变值的时候 存储地址改变的时候 就是不可变
# 可变的定义就是 值发生改变 但是地址没有发生改变
# 注意事项:
# 使用global的时候
"""
a = 300
global a
a -= 50
这样会报错 自己已经有值a的时候 就不能使用global
"""
# 比如
a = 10
b = 20
print(id(a))
# 2262448472592这个是结果
print(id(b))
# 2262448472912这个是结果
# 不可变类型有： int str float bool tuple
# 可变类型有： list dict set
list1 = [1, 2, 3]
print(id(list1))
# 结果是2686496952960
list1.append(4)
print(id(list1))
# 结果也是 2686496952960
# 全局与局部 是针对函数来说的
a = 10 # 这个是全局变量
def x():
a = 0 # 这个是局部变量
print(a)
def x2():
print(a)
def x3():
# 改变全局的a
global a
a -= 1
print(a)
x()
# 这个结果是 0 输出的是自己的局部变量
x2()
# 这个结果是 10 输出的是全局变量
x3()
# 结果是9
print(a)
# 这样输出 结果是9 说明已经改变了全局变量a的值
print()
# 局部变量要注意的事情
def x4():
a = 0
print(a)
a += 1
print(a)
x4()
x4()
# 结果是
# 0
# 1
# 0
# 1
# 也就是说局部变量 执行一次 局部变量的值其实是没有变的 不像全局变量
# 这个函数会再次从头到尾走一遍 所以执行多少次 输出a都是 0 1
⭐六、函数的嵌套与闭包
🔥 全是重点
# 函数的嵌套
def l():
a = 10
def i():
b = 20
print('内')
result = locals() # locals表示 查看函数中的局部变量,以字典的形式去返回
print(result)
l()
# 结果是{'a': 10, 'i': <function l.<locals>.i at 0x0000012205B470A0>}
def z():
a = 10
def h():
b = 20
print('内')
print(a)
h()
z()
# 结果是
# 10
# 内
# 内部函数 也需要在嵌套的函数中去调用才能执行
# 然后在嵌套语句的时候 想修改外层函数的变量需要用nonlocal 建议不使用global
def x_1():
a = 10
def x_2():
# 修改a的值
nonlocal a
a -= 1
print("内部:{}".format(a))
print(a)
x_2()
x_1()
# 结果是
# 10
# 内部:9
# 但是内部的函数 改变了以后 外部函数本质的值是不会改变的
# 闭包!!
# 需要符合3个条件
# 1. 嵌套函数 2. 内部函数引用了外部函数的变量 3. 返回值是内部函数
def y_1(n):
a = 10
def y_2():
# 修改a的值
b = a + n # 这个a 引用了外部函数的变量
print("内部:{}".format(b))
return y_2 # 返回值是内部函数
o = y_1(2)
print(o)
# 结果是<function y_1.<locals>.y_2 at 0x0000021BFC62C550>
# 有返回值 要有变量接收
# 然后这样可以调用y_2
o()
# 结果是 内部:12
本文详细介绍了Python中的元组、字典、集合及其操作，如添加、删除、遍历和查询。还讲解了字典的update()和fromkeys()函数，以及集合的合并与删除方法。此外，探讨了函数的基础知识，包括带参数、多个参数、默认参数值、返回值和全局变量与局部变量的概念。最后，提到了函数的嵌套与闭包的重要性。
扫一扫
1702
到【灌水乐园】发言
