9月2日课后笔记
遍历字典
遍历字典的键key；2. 遍历字典的值value；3. 遍历字典的项；4. 遍历字典的key-value
d
={'list':[1, 2, 3],1:123,'111':'python3','tuple':(4, 5, 6)}
for key
,value in d
.items():
print(key
,value
)
"F:\python exerciese\venv\Scripts\python.exe" "F:/python exerciese/83.py"
list
[1, 2, 3]
1 123
111 python3
tuple
(4, 5, 6)
# keys()该方法返回字典所有的key
# values()该方法返回一个序列 序列中保存有字典的值
# items()该方法会返回字典中所有的项
d
= {'name':'葫芦娃','age':7,'gender':'男'}
print(d
.keys())
# dict_keys(['name', 'age', 'gender'])
d
= {'name':'葫芦娃','age':7,'gender':'男'}
for k in d
.keys():
print(d
[k
])
#
"F:\python exerciese\venv\Scripts\python.exe" "F:/python exerciese/251.py"
# 葫芦娃
#
7
# 男
d
= {'name':'葫芦娃','age':7,'gender':'男'}
for v in d
.values():
print(v
)
#
"F:\python exerciese\venv\Scripts\python.exe" "F:/python exerciese/251.py"
# 葫芦娃
#
7
# 男
d
= {'name':'葫芦娃','age':7,'gender':'男'}
print(d
.items())
# dict_items([('name', '葫芦娃'), ('age', 7), ('gender', '男')])
d
= {'name':'葫芦娃','age':7,'gender':'男'}
for k
,v in d
.items():
print(k
)
print(v
)
# 结果：
# name
# 葫芦娃
# age
#
7
# gender
# 男
集合的快速入门
集合是无序可变，元素不能重复。集合的所有元素都是字典中的“键对象”，因此是不能重复的且唯一的。使用{}创建集合对象，并使用 add()方法添加元素， remove()删除指定元素；clear()清空整个集合。
# 创建集合的
2种方式
# 一、｛｝；二、
set()
# s = {[1,2,3],[4,5,6]}
# print(s,type(s))
# TypeError: unhashable type: 'list'
# 因为集合存储的是不可变对象，而列表是可变对象，所以会报错，这是用大括号创建集合时所产生的错误
# s = {}# 这个空的{}代表的是空的字典
# print(s,type(s))
# 在这个
{}里添加点值，那就是集合
# s = {1,2}
# print(s,type(s))
# 创建空的集合
# s = set()
# print(s,type(s))
# set() <class 'set'>
# 向空集合里添加元素
# s = set(1,2,3)
# print(s,type(s))
# TypeError: set expected at most 1 argument, got 3
# s = set(1)
# print(s,type(s))
# TypeError: 'int' object is not iterable
# s = set([1,2,3,4,5])
# print(s,type(s))
#
{1, 2, 3, 4, 5} <class
'set'>
# s = set('hello')
# print(s,type(s))
#
{'l', 'h', 'e', 'o'} <class
'set'>
# 获取集合中的元素
# s = {'a','b',1,2,3}
# print(s,type(s))
# print(s[0])
# TypeError: 'set' object is not subscriptable
# print(list(s)[0])
# 结果：
1，实在想找可以通过
print(list(s
)[0])这种方式获取集合的元素f
# t = {1,2,3}
# print(t,type(t))
# print(list(t)[2])
# 结果：
1
# s = {'a','b',1,2,3}
# add()这个方法是向集合中添加元素
# s.add(4)
# s.add(5)
# s.add('c')
# print(s)
# update()将一个集合中的元素添加到另一个集合中
# s = set(['a','b',1,2,3])
# s2 = {'hello'}
# s.update(s2)
# print(s)
# print(s2)
# 结果：
#
{'b', 1, 2, 3, 'a', 'hello'}
#
{'hello'}
# s = set(['a','b',1,2,3])
# s2 = set(['hello'])
# 注意s2
= set('hello')这一行，
'hello'没有
[]，s的结果是
{1, 2, 3, 'h', 'a', 'b', 'e', 'o', 'l'}
#
'hello'有
[]，s的结果是
{1, 2, 3, 'b', 'a', 'hello'}
# s.update(s2)
# print(s)
# print(s2)
# pop()随机删除集合中的一个元素，pop有返回值
# s = {1, 2, 3, 'b', 'a','c','d',4,5,6,'hello'}
# r = s.pop()
# print(r)
# print(s)
#
1
#
{2, 3, 'd', 4, 5, 6, 'hello', 'a', 'b', 'c'}
# remove删除集合中指定的元素，remove没有返回值
# s = {1,2,4,'hello',7,3,'b','a','c','d',12,5,6}
# s.remove(list(s)[2])疑问
# s.remove('b')
# s.remove('hello')
# print(s)
#
{'c', 1, 2, 3, 4, 5, 6, 7, 12, 'a', 'd'}
# clear()清空集合
s
= {1,2,4,'hello',7,3,'b','a','c','d',12,5,6}
s
.clear()
print(s
)
集合的运算
#
& 交集运算
#
| 并集运算
#
- 差集运算
#
^ 亦或集
#
<= 检查一个集合是否是另一个集合的子集
#
< 检查一个集合是否是另一个集合的真子集
#
>=检查一个集合是否是另一个集合的超集
#
>检查一个集合是否是另一个集合的真超集
s
= {1,2,3,4,5}
s2
= {3,4,5,6,7}
#
& 交集运算
# r = s & s2
#
| 并集运算
# r = s | s2
#
- 差集运算
# r = s - s2
# r = s2 - s
#
^ 亦或集
# r = s2 ^ s
# print(s,s2,r)
a
= {1,2,3}
b
= {1,2,3,4,5}
r
= b
<= a
print(r
)
函数
# 函数也是一个对象
# 对象是内存中专门用来存储数据的一块区域
# print('哈哈哈')
# print('嘿嘿嘿')
# print('呵呵呵')
# 定义一个函数
def
fn():
print('这是我的第一个函数！！！')
print('哈哈哈')
print('嘿嘿嘿')
# fn() <function fn at 0x000002292F085730>
# print(fn)
# fn()
# fn()
# fn()
# fn是函数对象 fn()调用函数
# print是函数对象 print()调用函数
函数的参数
# 定义一个函数 任意两个数的和
# 函数的参数
# 在定义函数的时候，可以在函数后面的括号中定义数量不等的形参
# 多个形参之间要用
,隔开
# 简单来说你有几个形参就要赋值几个实参
def
s(a
,b
):
# print(4 + 5)
# a = None
# b = None
# print(a + b)
print(a
,'+',b
,'=',a
+b
)
s(8,6)
# TypeError: s() missing 2 required positional arguments: 'a' and 'b'
函数参数的传递方式
定义形参时,可以为形参指定默认值。指定了默认值以后，如果用户传递了参数则默认值不会生效。如果用户没有传递，则默认值就会生效。位置参数：位置参数就是将对应位置的实参赋值给对应位置的形参。关键字参数 : 关键字参数可以不按照形参定义的顺序去传递，根据参数名进行传递。混合使用位置参数和关键字参数的时候必须将位置参数写到关键字参数前面去。 关键字传参： # 在定义函数的形参的时候，可以指定一个默认值
# def fn(a,b,c = 20):
#
# print('a =',a)
# print('b =',b)
# print('c =',c)
# fn(1,2,3)
# fn(1,2)
# 函数的传递方式
# 位置传参
# 关键字传参
# 关键字传参可以不按照定义的顺序来传递，它是根据参数的名字来传递
# def fn(b=1,c=2,a=3):
#
# print('a =',a)
# print('b =',b)
# print('c =',c)
# fn()
# def fn(c=2,a):
# print('a =', a)
# print('c =', c)
# print(1)
# SyntaxError: non-default argument follows default argument
# import requests
#
# headers = {}
# r = requests.get(headers=headers,'xxxxx')
可变对象
# 对象在内存中都保存了三个数据
# id(标识)
# type(类型)
# value(值)
'''
a
= [1,2,3]
a
Out
[3]: [1, 2, 3]
a
[0] = 10
a
Out
[5]: [10, 2, 3]
a
= [4,5,6]
a
Out
[7]: [4, 5, 6]
列表是一个可变对象
a
= [1,2,3]
a
[0] = 10（改对象里面的value）
这个操作是在通过变量去修改对象的值
这个操作不会改变变量所指向的对象
a
= [4,5,6](改变量 改对象里面的value 同时还有id
)
这个操作是在给变量重新赋值
这个操作会改变量所指向的对象
'''
a
= [1,2,3]
b
= a
# b[0] = 10
b
= [10,2,3]
print('a',a
,id(a
))
print('b',b
,id(b
))
实参的类型
# def fn(a,b,c = 20):
#
# print('a =',a)
# print('b =',b)
# print('c =',c)
# def fn2(a):
#
# print('a =',a)
#
# b = 123
# b = True
# b = 'hello'
# b = None
#
#
# fn2(fn)
# def fn3(a,b):
#
# print(a + b)
# # TypeError
: unsupported operand
type(s
) for +: 'int' and
'str'
# fn3(123,'456')
```c
def
fn4(a
):
# 在函数中对形参重新赋值，不会影响其他的变量
# a = 20
a
[0] = 30
print('a =', a
,id(a
))
# c = 10
c
= [1,2,3]
# fn4(c.copy())
fn4(c
[:])
print('c =',c
,id(c
))
def
f1(x
):
# 当形参为不可变对象时，在函数中对形参重新赋值，不会影响其他的变量，所以在结果中x
=20
x
= 20
print('x=',x
,id(x
))
y
= 10
f1(y
)
print('y=',y
,id(y
))
结果：
x
= 20 1685768416
y
= 10 1685768256
c
= [1,2,3]
def
a(b
):
# 当形参为可变对象时，在函数中对形参重新赋值时，会影响其他的变量，所以b和c的值一样
b
[0] = 20
print('b=',b
,id(b
))
a(c
)
print('c=',c
,id(c
))
结果：
b
= [20, 2, 3] 7244936
c
= [20, 2, 3] 7244936
```c
c
= [1,2,3]
def
a(b
):
b
[0] = 20
print('b=',b
,id(b
))
a(c
.copy())
print('c=',c
,id(c
))
结果：
b
= [20, 2, 3] 6370216
c
= [1, 2, 3] 6196360
c
= [1,2,3]
def
a(b
):
b
[0] = 20
print('b=',b
,id(b
))
a(c
[:])
print('c=',c
,id(c
))
结果：
b
= [20, 2, 3] 4993928
c
= [1, 2, 3] 4820104
