字典，元组是可以作为建，列表只能作为值
d = {("name",):"jack", "age":"18", "sex":"male"}
print(d)
print(d"age")
print(d.keys())
print(d.values())
print(type(d.values()))
isinstance(d.values(), list)
isinstance(d.values(), object)
print(d.items()) #返回键值元组list
print(d.get("sex"))
print(d.get("se"))
print(d.popitem())
print(d)
print(d.pop("age"))
print(d)
代码语言：txt复制 {('name',): 'jack', 'age': ['18'], 'sex': 'male'}
['18']
dict_keys([('name',), 'age', 'sex'])
dict_values(['jack', ['18'], 'male'])
<class 'dict_values'>
dict_items([(('name',), 'jack'), ('age', ['18']), ('sex', 'male')])
male
None
('sex', 'male')
{('name',): 'jack', 'age': ['18']}
['18']
{('name',): 'jack'}
# 第五课 集合
1. 集合元数不可重复，类似数学中的集合
2. 元数类型不可变类型
3. 集合元数没有顺序，不能比较和排序，没有索引和位置的概念
4. 用花括号{}表示
5. 可用set()创建
```python集合
s = {101, "python", 23.3}
print(type(s))
s = set((1, 2, 3, 4))
s.add(5)
s.add(5)#重复元数不再添加
print(s)
s.add(6)
print(s)
s.remove(1)#移除集合中的1，如若不存在就会报错 keyError
print(s.pop()) #随机删除一个
print(s)
s.update({"hh"})
print(s)
print("hh" in s)
s.discard("hh")
print(s)
print("hh" not in s)
代码语言：txt复制 <class 'set'>
{1, 2, 3, 4, 5}
{1, 2, 3, 4, 5, 6}
2
{3, 4, 5, 6}
{3, 4, 5, 6, 'hh'}
True
{3, 4, 5, 6}
True
```python集合运算符
s = {1, 2, 3, 4, 6}
t = {1, 2, 6}
print(s-t) #差集 {3, 4}
print(t-s) #差集 set()
print(s&t) #交集
print(s^t) #对称差集，s、t的非共同元数
print(s|t) #并集，s、t的所有元数
代码语言：txt复制 {3, 4}
set()
{1, 2, 6}
{3, 4}
{1, 2, 3, 4, 6}
# 第六课 文件中的数据处理
```python文件数据操作
f = open("work/shell.txt", "w ")
print(f.writelines("hello n shell!"))
f.close();
f = open("work/shell.txt", "ab ")
f.readline()
f.tell() #查询光标位置
f.seek(1) #移动光标位置
f.close();
代码语言：txt复制 None
12
```python一维数据
ls = "天安门", "故宫", "天坛", "长城"
fo = open("/Users/easy/Desktop/data.csv", "w ")
fo.write(",".join(ls))
fo.close()
fo = open("/Users/easy/Desktop/data.csv", "r")
list = fo.read().strip("n").split(",") #strip 去掉行两边的换行符，用逗号分割
fo.close()
print(list)
代码语言：txt复制```python二维数组
ls = ["景区", "票价", "天安门", "15", "故宫", "20", "天坛", "100", "长城", "60"]
fo = open("/Users/easy/Desktop/data.csv", "w")
for row in ls:
代码语言：txt复制# 以逗号分割作为行写入，末尾添加换行fo.write(",".join(row) "n") #写只能是字符串 str，否则报错fo.close()
读取数据
list = []
fi = open("/Users/easy/Desktop/data.csv", "r")
for line in fi:
代码语言：txt复制list.append(line.strip("n").split(","))print(list)
fi.close()
代码语言：txt复制# 第七课 NumPy
#### ndarray 为了优化批量运算而生，与list不同，ndarray的元数类型一致，数据地址连续，批量操作会更快。而list的元数类型可能不一致，需通过寻址方式找到下一个元数。ndarray 还支持广播机制，矩阵运算时不需写for循环
```pythona1 = 1, 2, 3, 4, 6
a2 = 1, 2, 6, 2, 1
合并添加元数
print(a1 a2)
for i in range(0, len(a1)):
代码语言：txt复制a1[i] = a1[i] a2[i]print(a1)
元数加1
for num in a1:
代码语言：txt复制num = 1print(a1)
import numpy as np
s = np.array(1, 2, 3, 4, 6)
t = np.array(1, 2, 6, 2, 1)
两数组相加，批量处理
c = s t
print(c)
元数加1, 批量处理
print(s 1)
代码语言：txt复制 [1, 2, 3, 4, 6, 1, 2, 6, 2, 1]
[2, 4, 9, 6, 7]
[2, 4, 9, 6, 7]
[2 4 9 6 7]
[2 3 4 5 7]
```pythonndarray 广播机制
import numpy as np
s = np.array([1, 2, 3, 4, 6, 2, 2, 6, 2, 1])
t = np.array(3, 2, 6, 2, 5) # 相加时，自动广播扩展为二维进行运算 [3, 2, 6, 2, 5, 3, 2, 6, 2, 5]
c = s t
print(c)
代码语言：txt复制 [[ 4 4 9 6 11]
[ 5 4 12 4 6]]
```pythonndarray 的创建
import numpy as np
a = 1, 2, 6, 2, 1
print(id(a))
b = np.ndarray(a) #将a转化为nd
print(id(b))
c = np.ndarray(1, 2, 6, 2, 1) #直接创建nd
print(id(c))
d = np.arange(10, 20, 2) #通过指定起始start、终止stop、间隔（步长）interval, 来生成数组
print(d)
e = np.zeros(5) #5列数组
print(e)
#2行4列二维数组
print(np.zeros(2,4))
f = np.ones(2,4)
print(a, "数据类型dtype:{}, 形状shape:{}, 元素个数size:{}, 数组维度ndim:{}".format(f.dtype, f.shape, f.size, f.ndim))
代码语言：txt复制 140284688014224
140284692440288
140284687888432
[10 12 14 16 18]
[0. 0. 0. 0. 0.]
[[0. 0. 0. 0.]
[0. 0. 0. 0.]]
[1, 2, 6, 2, 1] 数据类型dtype:float64, 形状shape:(2, 4), 元素个数size:8, 数组维度ndim:2
```pythonimport numpy as np
随机产生数组，random.rand产生的值范围[0, 1)
b = np.random.rand(2)
print(b)
c = np.random.rand(2, 3) #2行3列二维数组
print(c)
转换数据类型
e = c.astype(np.int64)
print(e)
print(e.dtype)
改变形状，f和e的元数个数要一致
f = c.reshape(1, 6)
print(f)
代码语言：txt复制 [0.51336787 0.64459987]
[[0.39897641 0.0609749 0.20308816]
[0.87602365 0.63098506 0.73744827]]
[[0 0 0]
[0 0 0]]
int64
[[0.39897641 0.0609749 0.20308816 0.87602365 0.63098506 0.73744827]]
```pythona = np.array([4, 4, 9, 6, 11, 5, 4, 12, 4, 6])
print(a 1)
print(a * 2)
print(a / 2)
print(a ** 0.5) #开根号
代码语言：txt复制 [[ 5 5 10 7 12]
[ 6 5 13 5 7]]
[[ 8 8 18 12 22]
[10 8 24 8 12]]
[[2. 2. 4.5 3. 5.5]
[2.5 2. 6. 2. 3. ]]
[[2. 2. 3. 2.44948974 3.31662479]
[2.23606798 2. 3.46410162 2. 2.44948974]]
**ndarray切片数组上的任何修改，都会直接反映到元数组上。ndarray的切片出新数组和原数组的内存都是同一块**
```pythonndarray 索引和切片
arange随机生成(0, 30],间隔步长为2的数组
a = np.arange(0, 30, 2)
print("a=",a)
print("a10=",a10)
b = np.arange(30)
print("b=",b)
切片出新数组, 还是指向原来的内存区域，数据不会被赋值
c = b4:7
print("c=",c)
切片数组上的任何修改，都会直接反映到元数组上。ndarray的切片出新数组和原数组的内存都是同一块
c0 = 100
print("b=",b)
整段切片赋值
b4:7 = 10
print("b=",b)
代码语言：txt复制 a= [ 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28]
a[10]= 20
b= [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
24 25 26 27 28 29]
c= [4 5 6]
b= [ 0 1 2 3 100 5 6 7 8 9 10 11 12 13 14 15 16 17
18 19 20 21 22 23 24 25 26 27 28 29]
b= [ 0 1 2 3 10 10 10 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
24 25 26 27 28 29]
```python通过copy给切片新数组创建不同的内存空间
a = np.arange(30)
a_slice = a4:7
a_slice = np.copy(a_slice) #创建不同的内存空间
a_slice0 = 1000
print("a=",a)
print("a_slice=",a_slice)
代码语言：txt复制 a= [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
24 25 26 27 28 29]
a_slice= [1000 5 6]
```python创建多维数组
a = np.arange(30)
print(a)
arr3d = a.reshape(5, 3, 2)#5个3行2列
print(arr3d)
第0维上索引, 后面维度不变
print("第0维上索引：", arr3d0)
两个索引指标 arr3d0 等同于 arr3d0, 0
print("索引：", arr3d0)
print("索引：", arr3d0, 0, 1)
代码语言：txt复制 [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
24 25 26 27 28 29]
[[[ 0 1]
[ 2 3]
[ 4 5]]
[[ 6 7]
[ 8 9]
[10 11]]
[[12 13]
[14 15]
[16 17]]
[[18 19]
[20 21]
[22 23]]
[[24 25]
[26 27]
[28 29]]]
第0维上索引： [[0 1]
[2 3]
[4 5]]
索引： [0 1]
索引： 1
```python多维数组的切片, 利用for 遍历切片
a = np.arange(24)
b = a.reshape(6, 4)
print(b)
s = []
for i in range(0, 6, 2): #0 2 4
代码语言：txt复制s.append(b[i:i 2])print(s)
代码语言：txt复制 [[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]
[16 17 18 19]
[20 21 22 23]]
[array([[0, 1, 2, 3],
[4, 5, 6, 7]]), array([[ 8, 9, 10, 11],
[12, 13, 14, 15]]), array([[16, 17, 18, 19],
[20, 21, 22, 23]])]
# 函数
```pythondef data(name, age=18):
代码语言：txt复制print(name str(age) "岁")data("浩辰",20)
关键字传参
data(age=18, name="唐三")
代码语言：txt复制 浩辰20岁
唐三18岁
(1, 2, 3)
[30, 40]
[56, 89]
{'a': 1, 'b': 2, 'c': 3}
```python可变长度参数
*param 接收任意多个参数放入一个元组中
**param 接收任意多个关键字参数放入字典中
def demo(*param):
代码语言：txt复制print(param)demo(1, 2, 3)
*mean 接收任意多个参数放入一个元组中
first, *mean, last = 20, 30, 40, 50
print(mean)
一个变量多个可变参数
*mean, = 56, 89
print(mean)
高级用法
l = ("第一", 100, "很好"), ("第二", 90, "好"), ("第三", 80, "一般"), ("第四", 60, "合格")
for d, f, p in l:
代码语言：txt复制print(d, f, p)for d, *p in l:
代码语言：txt复制print(d, p)def demo1(**p):
代码语言：txt复制print(p)demo1(a=1, b=2, c=3)
代码语言：txt复制 (1, 2, 3)
[30, 40]
[56, 89]
第一 100 很好
第二 90 好
第三 80 一般
第四 60 合格
第一 [100, '很好']
第二 [90, '好']
第三 [80, '一般']
第四 [60, '合格']
{'a': 1, 'b': 2, 'c': 3}
### 传递参数时的序列解包
```python对列表、元组解包
*p解包
def demo(a, b, c):
代码语言：txt复制print(a b c)list = 2, 3, 4
demo(*list)
tup = (3, 5, 7)
demo(*tup)
#集合
s = {7, 8, 9}
demo(*s)
对字典解包
*p解包解包的是键key
**p解包的是值value
def demo2(a, b, c):
代码语言：txt复制print(a b c)dic = {"a":1, "b":2, "c":3}
demo2(*dic)
demo2(**dic)
dic 键与Demo2的形参要对应，否则报错
dic = {"a":1, "b":2, "d":3}
dic(**dic) # 报错
代码语言：txt复制 9
15
24
abc
6
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
/tmp/ipykernel_93/2067124093.py in <module>
28 # dic 键与Demo2的形参要对应，否则报错
29 dic = {"a":1, "b":2, "d":3}
---> 30 dic(**dic)
TypeError: 'dict' object is not callable
```python函数返回值，返回0个或者多个，多个以元组形式返回
def cal(x,y):
代码语言：txt复制return x y, x-ya, b = cal(5,2)
print(a)
print(a,b)
代码语言：txt复制 7
7 3
```python变量、全局变量global
def cal():
代码语言：txt复制global a a = 10print(id(a))print(a)cal()
a = 99
print(id(a))
print(a)
代码语言：txt复制 94798584353856
10
94798584356704
99
```pythonlambda 函数（匿名函数）
def func(x, y):
代码语言：txt复制return x*y等同于
func1 = lambda x,y:x*y
print(func(1,2))
print(func1(1,2))
fun = lambda x,y:x if x>y else y
fun(2,3)
代码语言：txt复制
