python

 B站视频笔记

40.1.matplotlib简介&pyplot的API_哔哩哔哩_bilibili

2023.4.20

1.创建python文件

右键项目名->new directory->输入名称->new python file->输入名称->右击run

2.改语言

file->setting->plugins->marketplace->输出chinese（有汉的图标）->点击install->restar

不想用了->在plugins页面->已安装->点击卸载

字体大小

setting->font

3.找出该文件

右击项目->open in->explore

4.python关键字

输入语句

import keyword
print(keyword.kwlist)

5.python的缩进是有要求的，即有些地方没缩进会报错，直接用tab（4个空格）缩进即可，而且我发觉它没有分号，换行会加 \ ，小括号and中括号and大括号的换行不用加\

a = 1
b = 1
c = 1
d = a+ \
    b+ \
    c
e = (1,
     2
     ,3)
f = [1,
     2,3]
g = {1,2,
     3}

6.引号 ‘ ’          " "        """ """

注意单引号并不代表字符，可以表示字符串

a = "abcdefg"
b = "abc" \
  "defg"
c = 'abcdefg'
d = 'abc' \
    'defg'
e = """
abc
defg
"""

7.注释#

8.输入input 输出print

a = input("请输入内容:")
print(a)

9.转义符

\n换行

\t制表 补齐占位，并不是每次都是4个空格

\r覆盖 只输出后面部份的内容，覆盖前面的内容

\b删除 会把前面一个字符删除 backspace

想让转义字符失效，加r/R,        printf(r"字符\n串")

10.多个变量赋值 常量命名一般用大写命名

a,b,c=1,2,3

11.bool布尔类型的Ture跟False要首字母大写 2//4=0 向下取整 2**3=2^3=8

12.运算符与或非 and or not 不是符号& | ~ 空值None

13.切片[开始:结尾] 取左不取右，注意中间是 : ，不是逗号

a = "今天是个好天气"
print(a[0:3]) #今天是
print(a[ :3]) #今天是
print(a[:]) #今天是个好天气
print(a[-3:-1])#好天
print(a[-3:])#好天气

切片[开始:结尾:步长] 取左不取右 步长为1跟上面的式子是一样的

[::-1]其实就是逆序输出

a = "今天是个好天气"
print(a[0:5:2]) #跨2取值 原本应输出 今天是个好 今是好
#字符串反转
print(a[ : :-1]) #气天好个是天今

14.字符串索引

索引值能为负数，没有-0，-1代表最后一个字符。

2023.4.22

1.字符串拼接，直接相加

join()，注意里面多个参数，要用括号括起来。

a='1'
b='2'
c='3'
f=','.join((a,b,c))#注意里面两个括号
e=a+b+c
print(f)
print(e)

2.字符串格式化

将想格式化的内容用{}引起来

1.格式化小数长度（会四舍五入） :.2f

2.将小数按百分比的形式显示  :.2%  0.5869   会变成58.69%

num1=1
num2=2
num3=3
a="我是{}，性别{},年龄{}"
b="我是{}，性别{},年龄{}".format(1,2,3)
c=F"我是{num1}，性别{num2},年龄{num3}"//F表达式 用f也可以
print(a.format(1,2,3))
print(b)
print(c)
#字符串format进阶用法
s=3.6567
x=5.6567
print("今天的数字是：{:.2f}".format(s))#注意数据类型前还要冒号 今天的数字是：3.66 会四舍五入
print("今天的数字是：{0:.2f}".format(s,x))#今天的数字是：3.66
print("今天的数字是：{1:.2f}".format(s,x))#今天的数字是：5.66
print("百分比为：{:.3%}".format(0.565956))#百分比为：56.596%

传统的格式化输出方法:%

%s :为字符占位，任意类型都可以

%d:为数值类型占位

%f:为浮点数占位

s="我%s你"%(10)
print(s)
s1="我%s你"%([1,2])
print(s1)

括号区别

1.列表[]

列表是序列的一种，列表元素可以由任意类型的数据构成，不要求各元素具有相同的类型

2.字典{}

字典是python中唯一内置的映射类型，即通过键名来查找键值，元素集合无序，键名是任何不可修改类型的数据，如数值、字符串和元组等，而键值可以使任何类型的数据

通过list()函数可以将字典转化成列表，但是列表不能转化为字典

同理，通过tuple()函数可以将字典转化成元组，但是元组不能转化为字典

3.元组()

元组中的元素也可以由不同的数据类型组成，同列表一样是序列中的一种，可以利用序列操作对元组进行处理，但元组是不刻更改的，即元组创建之后不能修改、添加、删除成员

3.字符串查找

find:查找元素位置

找字符串片段在字符串中的下标位置，从前往后找，返回的是第一个被找到字符串片段起始位置第一个参数:要查找的字符串片段

第二个参数:要查找的起始点

第三个参数:要找到终止位置-1

如果查找的字符串存在多个，查找结果是第一个出现的字符串下标，找不到就返回-1

s="0123456"
print(s.find("6",0,7))#左闭右不闭 find(查找的字符,起始位置,结尾位置)结尾位置不包含

4.字符串计数

count()

count:统计字符串片段，在字符串中出现的次数找不到返回0

s="012345006"
print(s.count("0",1,7))

5.字符串替换

replace:替换指定的字符串片段

参数1:要替换的字符串片段

参数2:替换之后的字符串片段

参数3:替换的次数，从前往后替换（默认替换所有的)

s="hello"

print(s.replace("l","a",1))

6.字符串大小写

upper:将小写字母转为大写

lower:将大写字母转成小写

s="heLLo"
print(s.upper())
print(s.lower())

7.字符串分割

split:指定分割点对字符串进行分割

参数1:分割点

参数2:分割的次数（默认找到所有的分割点进行分割）

注意分割点在最后

s="bhygh1hhdju1dhndh1fj1"
print(s.split("1"))#['bhygh', 'hhdju', 'dhndh', 'fj', '']

8.字符串去除某个字符

strip(不带参):去除字符串首尾的空格=replace(" ","")

带参即去除含该参的字符。

s="bhygh1hhdju1dhndh1fj1"
print(s.strip("bj"))#hygh1hhdju1dhndh1fj1

4.24

1.字符串长度

len(字符串名称);返回字符串长度

2.列表定义

列表是写在方括号[]之间、用逗号分隔开的元素列表，列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表(所谓嵌套)，列表中的元素是可以改变。

(1)定义列表
(2)列表的下标 从0开始 
(3)列表取值

list1 = [1,2,3,4,"我爱你",[10,20,30,40]]
print(list1[0])#1
print(list1[5])#[10, 20, 30, 40]
print(list1[5][0])#10

3.列表长度and更新

list1 = [1,2,3,4,"我爱你",[10,20,30,40]]
print(len(list1))#6
list1[0]=6
print(list1)#[6, 2, 3, 4, '我爱你', [10, 20, 30, 40]]

4.列表的加乘

相加->拼接，乘法->输出多遍该内容

list1 = [10,20,30]
list2 = [1,2,3]
print(list1+list2)#[10, 20, 30, 1, 2, 3] 
print(list1*3)#[10, 20, 30, 10, 20, 30, 10, 20, 30]

4.25

1.列表切片

list1 = [10,20,30,2,1,3]
print(list1[0:3])#[10, 20, 30]
print(list1[-3:-1])#[2, 1]
print(list1[::-1])#[3, 1, 2, 30, 20, 10]
print(list1[-6:-1])#[10, 20, 30, 2, 1]
print(list1[-6:-1:2])#[10, 30, 1]

2.del、append

列表的操作方法:

(1).del关键字 删除

(2).append方法 append函数用于向列表末尾添加元素。但是如果是其他维的，并不一定是这样的。

list1 = [10,20,30,2,1,3]
#del list1
#print(list1)#会报错
del list1[0]
print(list1)#[20, 30, 2, 1, 3]

 3.insert、clear

列表的操作方法 :
(1)insert方法
insert函数用于向列表中插入元条。
insert函数的第一个参数是插入的位置，第二个参数是要插入的对象
(2)clear函数用于将列表清空

list1 = [10,20,30,2,1,3]
list1.insert(1,11)#[10, 11, 20, 30, 2, 1, 3]
print(list1)
list1.clear()
print(list1)#[]
print(len(list1))#0

4.remove、pop

(1)remove函数

remove函数用于从列表移除元素。

注意:〔若列表中有重复元素，remove函数只会移除匹配到的第一个)

(2)pop函数

pop函数用于移除列表中指定位置的元素，并返回要移除的元素

在默认情况下，移出列表中最后一个元素

list1 = [10,20,3,2,1,3]
#list1.remove(3)
#print(list1)#[10, 20, 2, 1, 3]
list1.pop(3)#注意它弹出的是下标 如果不填下标，默认弹出最后一个
print(list1)#[10, 20, 3, 1, 3]

5.index、reverse

index函数用于返回所匹配的元素的索引。该函数的第一个参数是待查找的对象，第二个参数是查找的起始范围，第三个参数是查找的结束范围

reverse函数用于将列表反向排列

list1 = [10,20,3,2,1,3]
print(list1.index(3))#2
#print(list1.index(5))#直接报错，不返回其他值
print(list1.index(3,3,6))#2 取左不取右
list1.reverse()
print(list1)#[3, 1, 2, 3, 20, 10]

6.extend

extend函数用于在列表的末尾添加另一个列表，跟append 函数相比，extend函数可以一次性添加多个元素。

注意：使用extend函数和列表加法的结果是一样的，但是extend函数会将另一个列表并入当前列表，而列表加法是返回新的列表，为节约内存空间，更推荐使用extend函数来实现大列表的连接操作。

list1 = [10,20,3,2,1,3]
list1.extend([6,7,8])
print(list1)#[10, 20, 3, 2, 1, 3, 6, 7, 8]
list1.append([6,7,8])
print(list1)#[10, 20, 3, 2, 1, 3, 6, 7, 8, [6, 7, 8]]

7.copy

copy函数用于创建列表的副本

list1 = [10,20,3,2,1,3]
#list2 = list1.copy()
#del list1[0]
#print(list)#[10,20, 3, 2, 1, 3]
list2 = list1
del list1[0]
print(list1)#[20, 3, 2, 1, 3]

8.sort

sort用于将列表进行排序，常见ASCII码的大小规则:0~9<A~Z<a~z

list1 = ['Hello','China','hello','welcome','我','1']
list1.sort()
print(list1)#['1', 'China', 'Hello', 'hello', 'welcome', '我']
#list2 = [1,2,3,'4']
#list2.sort()
#print(list2)#会报错，要同类型
list1.sort(reverse=True)
print(list1)#['我', 'welcome', 'hello', 'Hello', 'China', '1']

9.count

也有计数功能，用于统计某个元素在列表中出现的次数

10.元组

(1)元组也是一种数据容器，使用小括号”()"表示，其使用场景与列表相似，这意味着能使用列表的地方，基本上都能使用元组，包括列表推导式、切片等操作。元组与列表的唯一区别是元组不可变的。

(2)元组的元素类型可以不统一

t = ('a',1,2,3,[10,20,30])
t[0]='b'
print(t)#报错 元组不可变
list1 = ['Hello','China','hello','welcome','我','1']
list1[0]='sss'
print(list1)#['sss', 'China', 'hello', 'welcome', '我', '1']

4.26

1.元组的加法and赋值

t = ('a',1,2,3)
t1 = ([10,20,30],[1,2,3])#不能只写一个([10,20,30])，不然还是个列表，在后面加个逗号就是元组了
t2 = t + t1
print(t2)#('a', 1, 2, 3, [10, 20, 30], [1, 2, 3])
t2[4][2]= 33
print(t2)#('a', 1, 2, 3, [10, 20, 33], [1, 2, 3])

2.max、min、len方法（字符串、元组、列表都可以），以ASCII码进行对比。

参数直接传字符串/元组/列表

3.元组的相乘

元组可以不带括号，多个元素时，一个的话还是要带括号的。

t = (1,2,3)
a = 1,2,3
b =(10)
c = (10,)
print(t)#(1, 2, 3)
print(a)#(1, 2, 3)
print(b)#10
print(c)#(10,)
print(c*3)#(10, 10, 10)
print(t*3)#(1, 2, 3, 1, 2, 3, 1, 2, 3)

4.集合

集合是无序的(随机排列)，集合中的元素是唯一的，集合一般用于元组或者列表中的元素去重，集合中默认去重。

创建集合：

(1)变量名=set(元素)        字符串/列表/元祖/字典

(2)变量名={元素，元素，,,}元祖/字符串/数,不能用字典

(3)元素是唯一的,用于列表的去重

a = set("1234")
b = set([10,20,30])
c = set((1,2,3,4))
print(a)#{'1', '4', '3', '2'}
print(b)#{10, 20, 30}
print(c)#{1, 2, 3, 4}
d = {
    "年龄":1,
    "名字":"y"
}#字典
f = set(d)
print(f)#{'名字', '年龄'}
#e = {d}
#print(e)#报错，因为{}里面不能是字典
g = set((1,2,3,0,1,2))
print(g)#{0, 1, 2, 3}

5.add、update

add()往集合中添加元素数字/字符串/元祖

update（）将集合合并

a = set("1234")
b = set([10,20,30])
b.add(40)
print(b)#{40, 10, 20, 30}
a.update(b)
print(a)#{'2', '4', 40, 10, '3', 20, '1', 

6.集合删除元素

(1)remove：使用remove删除集合中的元素，如果有，直接删除，如果没有，程序报错。

(2)pop：使用pop 删除是随机删除集合中的元素，如果集合没有，元素程序报错。

(3)discard：使用discard 删除如果元素存在直接删除，如果元素不存在，不做任何操作。

a = set("1234")
a.remove("1")#不能只填1，会报错的
print(a)#{'4', '3', '2'}
a.pop()
print(a)#{'3', '4'}
a.discard("5")
print(a)#{'3', '4'}

7.集合的交集和并集

（1）交集

使用“&”符号连接多个集合，得到相同的元素

（2）并集

使用"|"符合连接多个集合，得到集合中的全部数据

a = set("1234")
b = {1,2,3,4,"1"}
c =a & b
d =a | b
print(c)#{'1'}
print(d)#{1, 2, 3, 4, '3', '1', '2', '4'}

2023.4.27

1.创建字典 (键值)

字典是一种映射类型，它的元素是键值对，字典的关键字必须为不可变类型，且不能重复。键可以是任意不可变类型(元祖/字符串/数字)。

字典的创建方式：

(1)直接使用“{}”

{2}使用dict()

a = {
    "姓名":"y",
    "年龄":18,#记得加逗号
    1:3,
    (1,2,3):"123"
}
print(a)#{'姓名': 'y', '年龄': 18, 1: 3, (1, 2, 3): '123'}
b = dict((["姓名","y"],["年龄",18],[1,3],[(1,2,3),"123"]))#注意中间是逗号，不是冒号，且有两个小括号
print(b)#{'姓名': 'y', '年龄': 18, 1: 3, (1, 2, 3): '123'}
c = {}#空字典
print(c)#{}
d = set()#表达空集合，用set()
print(d)#set()

2.字典的增删改查

a = {
    "姓名":"y",
    "年龄":18,#记得加逗号
    1:3,
    (1,2,3):"123"
}
a["键名"] = "键值"#增
print(a)#{'姓名': 'y', '年龄': 18, 1: 3, (1, 2, 3): '123', '键名': '键值'}
del a["键名"]#删
a[1] = 2#改
print(a[(1,2,3)])#查 123

2.get、keys

get函数用于从字典获取指定键的值。在get函数中可以设置默认值，当get函数没有获取到对应键时，get函数会将默认值返回None

keys函数将以列表的形式返回字典中的所有键

a = {
    "姓名":"y",
    "年龄":18,#记得加逗号
    1:3,
    (1,2,3):"123",
    "key1":{
        "key11":1,
        "key12":2
    }
}
print(a.get("姓名"))#y
print(a.get("姓"))#None
num = a.get("姓","ji")#不会进行添加且返回的只有值
print(num)
print(a)#{'姓名': 'y', '年龄': 18, 1: 3, (1, 2, 3): '123', 'key1': {'key11': 1, 'key12': 2}}
print(a.keys())#dict_keys(['姓名', '年龄', 1, (1, 2, 3), 'key1']) 注意key11、key12不会被输出

3.items、values

items 函数将以列表的形式返回字典中的所有键值对

values函数将以列表的形式返回字典中的所有值

a = {
    "姓名":"y",
    "年龄":18,#记得加逗号
    1:3,
    (1,2,3):"123",
    "key1":{
        "key11":1,
        "key12":2
    }
}
print(a.items())#dict_items([('姓名', 'y'), ('年龄', 18), (1, 3), ((1, 2, 3), '123'), ('key1', {'key11': 1, 'key12': 2})])
print(a.values())#dict_values(['y', 18, 3, '123', {'key11': 1, 'key12': 2}])

4.28

1.clear and copy

clear 函数用于将字典清空

copy函数用于创建字典的副本，修改原字典对象，不会影响其副本。

a = {
    "姓名":"y",
    "年龄":18,#记得加逗号
    1:3,
    (1,2,3):"123",
    "key1":{
        "key11":1,
        "key12":2
    }
}
b = a.copy()
#a.clear()
#print(a)#{} 不要直接输出a.clear() 返回的是None
#del b
#print(b)#直接报错，因为可能内存里面也删除了
del b[1]
print(a)#{'姓名': 'y', '年龄': 18, 1: 3, (1, 2, 3): '123', 'key1': {'key11': 1, 'key12': 2}}
print(b)#{'姓名': 'y', '年龄': 18, (1, 2, 3): '123', 'key1': {'key11': 1, 'key12': 2}}

2.fromkeys and pop

fromkeys函数用于创建一个新的字典，

第一个参数是一个序列(列表/元祖/集合)，用于作为字典的键。

第二个参数可以是任何数据类型，作为每个键的值。

pop函数用于从字典中移除指定键，并返回该键所对应的值。

a = {
    "姓名":"y"#一般不赋值

}
a1 = a.fromkeys("j1","zhi1")
a2 = a.fromkeys(("j1","zhi1"))
a3 = a.fromkeys(("j1","zhi1"),(1,2))
print(a1)#{'j': 'zhi1', '1': 'zhi1'}#注意j1被拆分了
print(a2)#{'j1': None, 'zhi1': None}
print(a3)#{'j1': (1, 2), 'zhi1': (1, 2)}
print(a)#{'姓名': 'y'}
print(a.pop("姓名"))#返回值 y
print(a){}

3..popitem and setdefault
popitem函数用于从字典中删除最后一项，并以元组形式返回该项所对应的键和值

setdefault函数用于设置键的默认值，
若在字典中该键已经存在，则忽略设置;若不存在，则添加该键和值
d.setsetdefault(键，值)

a = {
    "姓名":"y",
    "年龄":18,#记得加逗号
    1:3,
    (1,2,3):"123",
    "key1":{
        "key11":1,
        "key12":2
    }
}
r = a.popitem()
print(r)#('key1', {'key11': 1, 'key12': 2})
print(a)#{'姓名': 'y', '年龄': 18, 1: 3, (1, 2, 3): '123'}
a.setdefault("2","3")
print(a)#{'姓名': 'y', '年龄': 18, 1: 3, (1, 2, 3): '123', '2': '3'}
a.setdefault("姓名","x")
print(a)#{'姓名': 'y', '年龄': 18, 1: 3, (1, 2, 3): '123', '2': '3'}
b = {
    "姓名":"y",
    "姓名":"x"
}
print(b)#{'姓名': 'x'}

4.update

update函数用于将字典2的值更新到字典1。

若字典2的键在字典1 已经存在，则对字典1进行修改，若不存在，则对字典1进行添加。

a = {
    "姓名":"y",
    1:2
}
b = {
    "姓名":"x",
}
a.update(b)
print(a)#{'姓名': 'x'}
b.update(a)
print(b)#{'姓名': 'x', 1: 2}

5.成员检测与标识号检测

使用“in” 和“not in"运算符来判断某个对象是否为序列的成员

in : 判断对象是否在序列(列表/字符申/元祖/字典)中，如果是则返回True

not in: 判断对象是否不在序列中，如果是则返回True

print("1" in "1234" )
print(1 in (1,2,3,4))
print(1 in [1,2])
print("y" in {"y","x"})#以上都尉True
print(1 not in [2,3,4])#True
print(2 not in [2,3,4])#False

5.1

1.判断两个对象是否相同

判断某两个对象是否相同，则是用is 和not is运算符
is (是)判断对象是否相同
is not (不是)判断对象是否不相同

数字 /字符串 / 元祖 表面一样 完全一样（但是元组pycharm输出是False 有点不对，但是老师输出的是True）
列表 / 字典 / 集合表面一样 其实不一样 其实不是同一个对象，可能因为都是不可变元素，所以共用一个内存地址

a = "123"
b = "123"
print(a is b)#True
c = [1]
d = [1]
print(c is d)#False 可能是因为不指向相同的内存位置
e = {1,2,3}
f = {1,2,3}
print(e is f)#False
g = (1,2)
h = (1,2)
print(g is f)#False 理应当是True 因为元组不可变，共用一个内存地址

5.5

1.python的条件语句：

if...elif...else...分支语句，条件必须是真值，才能运行if里面的语句

 if 语句是可以单独存在的if elif(无数个)else or if else 不能单独写elif

2.输入时候如何将数据规范成自己要想的类型

在input函数之前，加数据类型，再将输入语句放到数据类型( )的括号里面

 3.python的数据类型转换

（1）检测数据类型的方法 :type()

（2）强制类型转换str( ): 可以把其他类型数据转化为字符串类型注意: 所有类型都可以转化为字符申类型。

 （3）int( ):可以把其他类型数据转化为整型，浮点型不遵守四舍五入

float( ):可以把其他类型数据转化为浮点型

注意：*数字类型之间可以相互转换

        *只有字符串可以转换为数字类型

        *并且字符串中的元素必须为纯数字，eg."-123","123.0"这些都不行 否则无法转换，

 （4）其他类型转数字类型中有一个特殊情况，就是其他类型转布尔类型bool( ) 可以把其他类型转为True或False
1.器类型转布尔类型:
容器类型数据:字符串，列表，元组，字典，集合
容器中为空 --> False
容器中有元素 --> True

非容器类型数据:数字类型，布尔类型
2.数字类型转布尔类型:
int类型中，0为False，其他为真
float类型中，0.0为False，其他为真

 

（5）list()

 1.数字类型是非容器类型，不能转换为列表

 2.字符串转列表时，会把字符串中的每一个字符当作列表的元素

3.元组转列表时，会把字符串中的每一个字符当作列表的元素

4.字典转列表时，只保留字典中的键

5.集合转列表时，结果是无序的，因为集合本身就是无序的

 （6）tuple(): 其他类型数据转元组类型与其他类型数据转列表类型的规则相同。

1.数字类型是非容器类型，不能转换为元祖
2.字符串转元组时，会把字符串中的每一个字符当作元祖的元素

3.列表转元祖时，会把元祖中的每一个元素当作元祖的元素

4.字典转元祖时，只保留字典中的键
5.集合转元祖时，结果是无序的，因为集合本身就是无序的

（7）set() 其他数据类型转集合类型

1.数字类型是非容器类型，不能转换为集合

2.字符串转集合时，结果是无序的

3.列表转集合时，结果是无序的

4.元组转集合时，结果是无序的

5.字典转集合时，只保字典中的键，结果是无序的

（8）dict() 其他转字典类型

1.数字类型是非容器类型，不能转换为字典
2.字符串不能转字典类型，因为字符串不能生成二级容器

3.列表类型转字典类型，列表必须为等长二级容器，于容器中的元素个数必须为2级
4.元组类型转字典类型，列表必须为等长二级容器，于容器中的元素个数必须为2级
5.集合不能转字典类型

5.6

1.isinstance()

用来判断一个对象是否是一个已知的类型

isinstance()函数的返回值是布尔型，若对象的类型是已知的类型，那么就返回True，否则返回False

语法如下：

isinstance(对象，对象类型) 对象类型可以有多个

int(整数)float(浮点数) bool(布尔值)str(字符串)list(列老) turple(元祖) set(集合) dict(字典)

2. for

for循环用来遍历序列，通过不使用下标的方式来实现对序列中每一个元素的访问

列表/元祖/字符串/字典/集合

遍历数字range() 取左不取右

（1）遍历字典的键和值 返回的是元组

（2）range函数的步长 

 （3）python的双层for循坏

 3.while循环

 

 break语句可以跳出for 和 while的循环体。

continue语句被用来跳过当前循环块中的剩余语句，然后继续进行下一轮循环。

 break语句可以跳出for和 while 的循环体。

continue语句被用来跳过当前循环块中的剩余语句，然后继续进行下一轮循环。

 pass 是空语句，是为了保持程序结构的完整性。

它用于那些语法上必须要有什么语句，但程序什么也不做的场合。

 4.函数的创建和调用

函数的定义和调用
创建函数的目的是封装业务逻辑，实现代码的重用。如何创建和调用函数
创建函数的关键字: def
函数的参数
创建函数，用到 def关键字+空格函数名字

 5.函数的参数
Python函数的参数具有灵活性，其定义的方法可以接受各种形式的参数也可以简化函数调用方法的代码。
5.1函数中的pass关键字 保持代码结构的完整性
5.2位置参数
        在对函数进行调用的时候，有几个位置参数就需要传递几个参数，否则会触发异常。并且，传入参数与函数参数列表是一一对应的

 5.3默认参数

默认参数是指带有默认值的参数，在对该函数进行调用的时候，可以不必显示传递给该函数。当不传递值的时候，函数将使用默认值
注意: 默认值只能会执行一次这条规则在默认值为可变对象(列表、字典以及大多数类的实例)时非常重要
官方建议默认参数尽量使用不可变对象! !因为可变对象会存储在后续调用中传递给它的参数
5.4可选参数
5.5可变参数与关键字参数

 

 

6.关键字参数
函数调用时，指定参数名称，称为关键字参数(别和默认参数混淆，这里是函数调用)
注意: 函数调用时，关键字参数必须在普通参数的后面 

7.命名关键字参数

限定关键字形参(命名关键字参数)

特点:必须使用关键字方式传递参数
限定关键字形参，当然就是为了限制后面几个参数只能按关键字传递，这往往是因为后面几个形参名具有十分明显的含义，显式写出有利于可读性，或者后面几个形参随着版本更迭很可能发生变化，强制关键字形式有利于保证跨版本兼容性

 会让后面的c跟d传参，要写参数名传参，如果有很多个传参的值，命名传入会更好

8.可变参数星号加参数

*参数;最常见的变量名是args，看到该变量名，一眼就知道变量args指向一个tuple对象

 自动收集所有未匹配的位置参数到一个tuple对象中，变量名args指向了此tuple对象

 可变参数两个星号加参数名
**参数: 最常见的变量名是kwargs，看到该变量名，一眼就知道变量kwargs指向一个dict对象
自动收集所有未匹配的关键字参数到一个dict对象中，变量名kwargs 指向了此dict对象

 

5.8参数解包

参数数据类型是:字符串/列表元祖/集合/字典的时候可以解包传递实参时，可以在序列类型的参数前添加星号，这样会自动将序列中的元素依次作为参数传递

2.参数解包和可变参数配合使用

注意：**参数只收集未匹配的关键字参数 

 

3.各种参数排列

函数中各种参数排列位置的注意事项：

 1.可变参数，必须定义在普通参数以及默认值参数的后面

2.函数定义时，二者同时存在，一定需要将*args放在**kwargs之前

def abc(普通参数，默认值参数name="y"",*参数，**参数):

        pass

4.return关键字

python中的函数可以使用return返回数据，也可以不用return返回，则默认返回”None "。

5.函数返回函数

函数里面嵌套函数

5.9

1.安装ipython

在管理员方式下打开的cmd输入

python -m pip install --upgrade pip

等一会，继续输入 pip install ipython

输入ipython测试环境

 2.ipython使用技巧

Tab键自动补全

        在shell中输入表达式时，按下Tab键可将当前命名空间中任何与已输入的字符串相匹配的变量（对象、函数等)显示出来

        当输入“"p"，再按下Tab键就可看到所匹配的所有内容，然后通过"!"寻找到所需内容，并按下“Enter""键即可

内省

        当某对象的信息不是很明确时，可以在变量的前面或后面加上问号(?)，有关该对象的-些通用信息就会显示出来

中断正在执行的代码

        当代码正在执行时，需要终止代码运行，则只需按下“Ctrl+C"，就会引发一个KeyboardInterrupt，除一些特殊的情况以外，绝大部分Python程序会立即停止执行

5.11

1.

 

 

 

 

 

2.执行shell命令 

 3.jupyter安装

执行命令︰ pip install jupyter

注意:在Linux环境下普通用户需要在命令前加sudo使用root权限说明（参考了两个）

第一个为主，更换了工作路径之后，我没有用anaconda，而是直接在命令行输入jupyter notebook

Jupyter安装使用详解（Windows版）_jupiter安装_ElenaYu的博客-CSDN博客

 小白都能看懂的Jupyter安装教程，带你绕过很多坑（Windows版） - 知乎 (zhihu.com)

 4.jupyter基本使用

进去这个网页，在cmd输入jupyter notebook

 

 输入代码，enter回车，想执行ctrl+enter或者shiift+enter

5.jupyter编辑模式

当Code cell左边框为绿色时，证明处在编辑模式下，在编辑模式下可正常输入各类文本代码

6.jupyter命令模式

当Code cell左边框为蓝色时，证明处在命令模式下，在命令模式下可在整体上对不同的区块进行编辑（调整位置、增加与删除等)

5.12

1.安装Anconada

配置环境变量时，在系统变量找到PATH进行编辑，再进行添加。

2.管理环境

• 创建新环境

命令:conda create --name <env_name> <package_names>

说明:默认情况下，新创建的环境将会被保存在/Users/<user_name>/ anaconda3/env目录下。其中，<user_name>为当前用户的用户名

oenv_name:即创建的环境名，建议以英文命名，且不加空格，名称两边不加尖括号"<"

opackage_names︰即安装在环境中的包名，名称两边不加尖括号"<>

如果要安装指定的版本号，则只需要在包名后面以=和版本号的形式执行。

如:conda create --name env1 python=2.7，即创建一个名为"python2"的环境，环境中安装版本为2.7的python

如果要在新创建的环境中创建多个包，则直接在<package_names>后以空格隔开，添加多个包名即可。如:conda create --name env2 python=3.7 numpy pandas，即创建一个名为"python3"的环境，环境中安装版本为3.7的python,同时也安装了numpy和pandas

--name :可以替换为-n

•  切换环境

Linux&macOs: conda activate cenv_name >

windows: activate <env_name>

说明:

如果创建环境后安装Python时没有指定Python的版本，那么将会安装与Anaconda版本相同的Python版本，即如果安装Anaconda第2版，则会自动安装Python 2.x;如果安装Anaconda第3版，则会自动安装Python 3.x

当成功切换环境之后在该行行首将以“(env_name)"或“[env_name]"开头。其中,“env_name”为切换到的环境名

退出环境至物理环境
Linux&macOS: conda deactivate
windows: deactivate
显示已创建环境
conda info --envs或conda info -e conda env list说明:结果中星号“*”所在行即为当前所在环境
复制环境
命令: conda create --name <new_env_name> --clone <copied_env_name>copied_env_name:即为被复制/克隆环境名，环境名两边不加尖括号“<>”new_env_name:即为复制之后新环境的名称，环境名两边不加尖括号“<>”
删除环境
命令: conda remove --name <env name> --all

5.17

1.包管理

 

 2.numpy简介
NumPy(Numerical Python)是 Python 语言的一个扩展程序库，持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库
NumPy 的前身 Numeric 最早是由Jim Hugunin 与其它协作者共同开发，2005 年，TravisOliphant在 Numeric 中结合了另一个同性质的程序库 Numarray 的特色，并加入了其它扩展而开发了NumPy。NumPy 为开放源代码并且由许多协作者共同维护开发

作用
NumPy 是一个运行速度非常快的数学库，主要用于数组计算

包含
一个强大的N维数组对象ndarray

广播功能函数
整合C/C++/Fortran 代码的工具
线性代数、傅里叶变换、随机数生成等功能

优势
对于同样的数值计算任务，使用numpy要比直接编写Python代码便捷的多。numpy中的数组的存储效率和输入输出性能均远远优于Python中等价的基本数据结构，且其能够提升性能是与数组中的元素成比例的

安装
可使用pip install numpy或conda install numpy安装

3.Ndarray对象简介

介绍
NumPy 最重要的一个特点是其N 维数组对象ndarray，它是一系列同类型数据的集合，以0下标为开始进行集合中元素的索引
ndarray 对象是用于存放同类型元素的多维数组
ndarray 中的每个元素在内存中都有相同存储大小的区域 

组成

一个指向数据(内存或内存映射文件中的一块数据) 的指针

数据类型或dtype，描述在数组中的固定大小值的格子

一个表示数组形状 (shape) 的元组，表示各维度大小的元组

一个跨度元组 (stride)，其中的整数指的是为了前进到当前维度下一个元素需要”跨过“的字节数

5.23

1.数据类型对象(dtype)
数据类型对象是用来描述与数组对应的内存区域如何使用，这依赖如下几个方面
数据的类型(整数，浮点数或者 Python 对象)
数据的大小(例如，整数使用多少个字节存储)
数据的字节顺序(小端法或大端法) [通过对数据类型预先设定"<"或”>"来决定的。<”意味着小端法(最小值存储在最小的地址，即低位组放在最前面)。">”意味着大端法(最重要的字节存储在最小的地址，即高位组放在最前面)]
在结构化类型的情况下，字段的名称、每个字段的数据类型和每个字段所取的内存块的部分
如果数据类型是子数组，它的形状和数据类型

2.创建数据类型对象

原型: numpy.dtype(object，align，copy)

 

 S20写成s20也会报错

5.24

1.创建Ndarray数组对象

说明
numpy默认ndarray的所有元素的类型是相同的，这一点与Pvthon中的list不同如果传进来的列表中包含不同的类型，则统一为同一类型，优先级: str>float>int

array()函数
原型: numpy.array(object, dtype = None, copy = True, order = None, subok =False，ndmin = 0)
作用：创建Ndarray数组对象

 

 asarray()函数
原型: numpy.asarray(a, dtype = None, order = None)
作用:类似numpy.array，但numpy.asarray 只有三个，比numpy.array 少两个

 

empty()函数
原型: numpy.empty(shape， dtype = float，order ='c')
作用:创建一个指定形状 (shape) 、数据类型 (dtype) 且未初始化的数组

 zeros()函数
原型: numpy.zeros(shape，dtype = float，order =c')

作用:创建指定大小的数组，数组元素以0来填充

ones()函数
原型: numpy.ones(shape，dtype = None，order ='c)

作用:创建指定形状的数组，数组元素以1来填充

full()函数
原型: numpy.full(shape，fill_value，dtype=None，ordr='c')

作用:创建指定形状的数组，数组元素以fill_value 来填充

 

eye()函数
原型: numpy.eye(N，M=None，k=e，dtype=float，order='c')

作用:对角线为1其他的位置为0 

 arange()函数
原型: nympy.arange(start，stop，step，dtype)
作用:创建数值范围并返回ndarray 对象，根据start 与stop 指定的范围以及 step 设定的步长，生成一个ndarray

 

 

frombuffer()函数
原型: numpy.frombuffer(buffer, dtype = float, count = -1, offset = 0)
作用:用于实现动态数组，接受 buffer 输入参数，以流的形式读入转化成 ndarray 对象

注意: buffer 是字符串的时候，Python3 默认str 是 Unicode 类型，所以要转成bytestring在原 str 前加上 b 

 

 

 fromiter()函数
原型: numpy.fromiter(iterable，dtype，count=-1)
用从可迭代对象中建立ndarray 对象，返回一维数组

 

 linspace()函数
原型: numpy.linspace(start, stop， num=50, endpoint=True,retstep=False,dtype=None)
作用:创建一个一维数组，数组是一个等差数列构成的

 

 logspace()函数
原型: numpy.logspace(start，stop，num=50, endpoint=True, base=10.0，dtype=None)
作用:创建一个于等比数列

 random.rand()
原型: rand(d0，d1，..·，dn)

作用:生成[0,1)之间的随机数生成0到1之间随机数

random.random()
原型: random(size=None)
作用:生成[0,1)之间的随机数 

 

 random.randint()
原型: randint(low，high=None，size=None，dtype='I')
作用:生成随机数

 

 

 random.randn()
原型: randn(de,d1,-,dn)
作用:返回一个或一组样本，具有标准正态分布
标准正态分布:又称为u分布，是以0为均值、以1为标准差的正态分布，记为N (0，1)

 random.normal()
原型: normal(loc=B.，scale=1.，size=None)
作用:生成高斯分布的概率密度随机数

2. numpy数组与Python中列表的对比

 

3.Ndarray数组属性

 shape
表示数组的维度，返回一个元组，这个元组的长度就是维度的数目，即 ndim 属性(秩)。比如，一个二维数组，其维度表示”行数"和”列数"，能返回维度，也能改变维度

 

 

 flags
返回 ndarray 对象的内存信息

 5.25

1.切片和索引
ndarray对象的内容可以通过索引或切片来访问和修改，与 Python 中list 的切片操作一样ndarray 数组可以基于0-n的下标进行索引，切片对象可以通过内置的 slice 函数，并设置start,stop 及step 参数进行，从原数组中切割出一个新数组

冒号:的解释
如果只放置一个参数，如[2]，将返回与该索引相对应的单个元案。如果为[2:]，表示从该索引开始以后的所有项都将被提取。如果使用了两个参数，如[2:7]，那么则提取两个索引(不包括停止索引)之间的项 

 

多维数组

 

 切片还可以包括省略号 ...，来使选择元组的长度与数组的维度相同。如果在行位慨使用省略号，它将返回包含行中元素的 ndarray，注意中间的逗号，不是冒号

 2、高级索引
NumPy 比一般的 Python 序列提供更多的索引方式。除了之前看到的用整数和切片的索引外，数组可以由整数数组索引、布尔索引

 

布尔索引

布尔索引通过布尔运算 (如: 比较运算符)来获取符合指定条件的元素的数组

使用了~ (取补运算符) 来过滤 NaN

5.26

1.广播
广播是numpy对不同形状(shape)的数组进行数值计算的方式，对数组的算术运算通常在相应的元素上进行
形状相同
        如果两个数组a和b形状相同，即满足 a.shape == bshape，那么atb 的结果就是a与b数组对应位相加。这要求维数相同，且各维度的长度相同

 

形状不同
        如果两个数组的维数不相同，则元素到元素的操作是不可能的。然而，在 NumPy 中仍然可以对形状不相似的数组进行操作，因为它拥有广播功能。较小的数组会广播到较大数组的大小，以便使它们的形状可兼容

 

  Python中tile函数的用法_小白的进阶的博客-CSDN博客

广播的规则
让所有输入数组都向其中形状最长的数组看齐，形状中不足的部分都通过在前面加1补0
输出数组的形状是输入数组形状的各个维度上的最大值
如果输入数组的某个维度和输出数组的对应维度的长度相同或者其长度为 1 时，这个数组能够用来计算，否则出错
当输入数组的某个维度的长度为 1 时，沿着此维度运算时都用此维度上的第一组值
简单理解
对两个数组，分别比较他们的每一个维度(若其中一个数组没有当前维度则忽略)，满足

        数组拥有相同形状
        当前维度的值相等
        当前维度的值有一个是 1
若条件不满足:抛出“ValueError: frames are not aligned”异常

2.迭代

numpy.nditer基本使用
它是一个有效的多维迭代器对象，可以用在数组上进行迭代。数组的每个元素可使用Python 的标准Iterator接口来访问

不加这个就会换行（有误） 只不过会挤一块 

 a 和 a.T 的遍历顺序是一样的，也就是他们在内存中的存储顺序也是一样的，但是a.T.copy(order=C)的遍历结果是不同的，那是因为它和前两种的存储方式是不一样的，默认是按行访问

 控制遍历顺序

 

 

 外部循环
nditer类的构造器拥有flags参数，它可以接受下列值

 

广播迭代
如果两个数组是可广播的，nditer组合对象能够同时迭代它们。假设数组a具有维度 3X4并且存在维度为 1X4 的另一个数组b，则使用以下类型的迭代器(数组b被广播到a的大小) 

3.修改数组形状

reshape()
原型: reshape(shape，order='c)

作用:不改变数据的条件下修改形状 

 

flat
一个数组元素迭代器 

 flatten()
原型: flatten(order='c')
作用:展平的数组元素并拷贝一份，顺序通常是"C风格注意:修改返回的数组不会对原数组产生影响

ravel()
原型: numpy.ravel(order='C')
作用:展平的数组元素，顺序通常是"C风格”，返回的是数组视图 (view，有点类似
C/C++引用reference的意味)
注意:修改会影响原始数组

3.翻转数组
transpose()
原型:numpy.transpose(a，axes=None)
作用:对换数组的维度
注意:修改会影响原始数组

 

 ndarray.T
类似numpy.transpose

 

 rollaxis()
原型:numpy.rollaxis(a，axis，start=0)作用:向后滚动特定的轴到一个特定位置

 

swapaxes()
原型: numpy.swapaxes(a，axis1，axis2)作用:交换数组的两个轴

 

6.2

1.修改数组维度

broadcast()
用于模仿广播的对象，它返回一个对象，该对象封装了将一个数组广播到另一个数组的结果

 

 broadcast_to()
原型:numpy.broadcast_to(array，shape，subok=False)
作用:将数组广播到新形状。它在原始数组上返回只读视图。 它通常不连续。如果新形状不符合 NumPy的广播规则，该函数可能会抛出ValueError

 expand_dims()
原型: numpy.squeeze(arr，axis=None)

作用:通过在指定位置插入新的轴来扩展数组形状

 

squeeze()
原型: numpy.squeeze(arr，axis)

作用:从给定数组的形状中删除一维的条目 

 

 只删除size为1的，eg(1,1,3,3)->(3,3)

2.连接数组
concatenate()
原型: numpy.concatenate((a1，a2，...)，axis)

作用:用于沿指定轴连接相同形状的两个或多个数组

 stack()
原型:numpy.stack(arrays，axis)

作用:用于沿新轴连接数组序列

 hstack()
是numpy.stack 函数的变体它通过水平堆叠来生成数组

6.4

1.分割数组

split()
原型: numpy.split(ary，indices_or_sections，axis=0)
作用:函数沿特定的轴将数组分割为子数组

 

hsplit()
用于水平分割数组，通过指定要返回的相同形状的数组数量来拆分原数组

 vsplit()
沿着垂直轴分割，其分割方式与hsplit用法相同

 2.数组元素的添加与删除

resize()
原型:numpy.resize(arr，shape)
作用:返回指定大小的新数组（注意resize的数目多了是如何的）

append()
原型: numpy.append(arr，values，axis=None)作用:
在数组的末尾添加值
追加操作会分配整个数组，并把原来的数组复制到新数组中输入数组的维度必须匹配否则将生成ValueError

insert()
原型: numpy.insert(arr，obj，values，axis)作用:在给定索引之前，沿给定轴在输入数组中插入值注意:如果值的类型转换为要插入，则它与输入数组不同。插入没有原地的，函数会返回一个新数组。此外，如果未提供轴，则输入数组会被展开 

 delete()
原型: numpy.delete(arr，obj，axis)
作用:返回从输入数组中删除指定子数组的新数组。与insert()函数的情况一样，如果未提供轴参数，则输入数组将展开

 

 

 unique()
原型: numpy.unique(arr， return_index，return_inverse, return_counts)
作用:去除数组中的重复元素

 

 2.字符串函数

是用于对dtype为numpy.string_或numpy.unicode_的数组执行向量化字符串操作

基于Python内置库中的标准字符串函数在字符数组类(numpy.char) 中定义

add()
对两个数组的元素进行字符串连接

 multiply()
返回按元素多重连接后的字符串

center()
将字符串居中，并使用指定字符在左侧和右侧进行填充

capitalize()
将字符串第一个字母转换为大写 

 lower()
数组元素转换为小写

 upper()
数组元素转换为大写

 split()
指定分隔符对字符串进行分割，并返回数组列表

splitlines()
返回元素中的行列表，以换行符分割 

 strip()
移除元素开头或者结尾处的特定字符

 join()
通过指定分隔符来连接数组中的元素

 replace()
使用新字符串替换字符串中的所有子字符串

 encode()
编码，数组元素依次调用str.encode

 decode()
解码，数组元素依次调用str.decode

3. 数学函数

标准三角函数sin()、cos()、tan()

反三角函数arcsin()、arccos()、arctan() 

 around()
原型:numpy.around(a,decimals=0)

作用:返回指定数字的四舍五入值

floor()
作用:向下取整，反回不大于输入参数的最大整数。即标量x 的下限是最大的整数i使得i <= x。注意在Python中，向下取整总是从0舍入 

ceil()
作用:向上取整，返回输入值的上限，即，标量x的上限是最小的整数i,
使得i>=x

6.6

1.算术函数

add()，subtract0，multiply(), divide()
作用:加减乘除

 reciprocal()
作用:返回参数逐元素的倒数

power()
作用:将第一个输入数组中的元素作为底数，计算它与第二个输入数组中相应元素的幂

mod()、remainder()

作用:计算输入数组中相应元素的相除后的余数 

统计函数
amax()、amin()
作用:计算数组中的元素沿指定轴的最大值、最小值

ptp()
作用:计算数组中元素最大值与最小值的差(最大值-最小值)

 

 percentile()
原型: numpy.percentile(a，q，axis)
作用:百分位数是统计中使用的度量，表示小于这个值的观察值的百分比

 

median()
作用:算数组中元素的中位数 (中值)

 mean()
作用:返回数组中元素的算术平均值。如果提供了轴，则沿其计算

average()
作用:根据在另一个数组中给出的各自的权重计算数组中元素的加权平均值，可以接受一个轴参数。如果没有指定轴，则数组会被展开

 

 

 标准差
标准差是一组数据平均值分散程度的一种度量

标准差是方差的算术平方根

 方差
统计中的方差(样本方差) 是每个样本值与全体样本值的平均数之差的平方值的平均数，即mean((x xmean())** 2)。换句话说，标准差是方差的平方根

 2.排序函数

 sort()
原型:sort(a，axis，kind,order)功能: 返回输入数组的排序副本

argsort()
作用:对输入数组沿给定轴执行间接排序，并使用指定排序类型返回数据的索引数组，这个索引数组用于构造排序后的数组

lexsort()
作用:使用键序列执行间接排序。键可以看作是电子表格中的一列。该函数返回一个索引数组，使用它可以获得排序数据

注意:最后一个键恰好是 sort 的主键举例:小升初考试，重点班录取学生按照总成绩录取。在总成绩相同时，数学成绩高的优先录取，在总成绩和数学成绩都相同时，按照英语成绩录取...... 这里，总成绩排在电子表格的最后一列，数学成绩在倒数第二列，英语成绩在倒数第二列

说明: 排序时首先排 nm，顺序为: amar、anil、raju、ravi。综上排序结果为[3 1 0 2] 

 msort(a)
作用:数组按第一个轴排序，返回排序后的数组副本

说明: np.msort(a) 相等于 np.sort(a,axis=0)

sort_complex(a)
作用:对复数按照先实部后虚部的顺序进行排序

 partition(a, kth[, axis, kind, order])

作用:指定一个数，对数组进行分区

 argpartition(a, kth[, axis, kind, order])作用:可以通过关键字 kind 指定算法沿着指定轴对数组进行分区

 

6.7

1.搜索函数

max()、min0
作用:沿给定轴返回最大和最小值 

 argmax()、argmin()

作用:沿给定轴返回最大和最小元素的索引

 honzero()
作用:返回输入数组中非零元素的索引

 where()
作用:返回输入数组中满足给定条件的元素的索引

extract()
作用:根据某个条件从数组中抽取元素，返回满条件的元素 

2.IO函数

 

numpy.save()
原型: numpy.save(file，arr，allow_pickle=True，fix_imports=True)
作用:将数组保存到以npy 为扩展名的文件中 

 numpy.savez()
原型: numpy.savez(file，*args，**kwds)
作用:将多个数组保存到以npz 为扩展名的文件中

 numpy.savetxt()
原型:
numpy.savetxt(FILENAME，a,fmt="%d"，delimiter=",")

numpy.loadtxt(FILENAME，dtype=int，delimiter=')

作用:以简单的文本文件格式存储数据，对应的使用loadtxt()函数来获数据