物联网技术部培训——python基本语法

 
 
 

python - 冉冉升起的高级语言

终于来到激动人心的时刻辣！我们要开始进行对python的学习！
 
python应该是很多小会员的第二门程序设计语言。在开始今天的讲学之前，我们先来解决小会员们心中可能存在的疑惑：python是什么？为什么要学python？python和C/C++有什么区别？
 
对于python，大家应该并不陌生。很多人应该都在大大小小的各种三流网站上看到过“7天学会python“的扯淡广告，虽然这种捷径是不存在的，但至少说明了python的易学性和火热性。（据说，python的发明者因为不喜欢有大括号的编程，就”随手“编出了python）
 
python是当下非常常用且热门的编程语言之一，这张图是HelloGitHub最新的数据，我们可以看到python的使用率正在不断地飙升，已经逐渐超过了老牌强势语言C++，现在排列第三，前两位是Java和C

python语言在数据处理领域确实非常优秀，加上本身语言的简单性，使得python非常适合进行海量数据处理和进行人工智能方面的研究。
 
在详细介绍这门语言之前，我们还要明确一点：python是一门十分高级的语言。何为高级语言？事实上，我们现阶段学习的所有语言都是属于高级语言的范畴，但相较于C等，python还要更加高级一点。高级就体现在，程序员利用python去编程和实现程序十分的轻便和简单；同样，简单也给python带来了一个弊病：那就是其运行速度非常慢。具体有多慢呢？C语言1秒就能实现的程序，Java要2秒，而python需要整整十秒。换言之，人看得懂的东西，机器就不容易看懂。
而且，python的简单性仅仅体现在语法实现的简单性，高级的python语言并不是简单的！
 
那么，相较于我们已经学会的程序设计语言，python和他有什么区别呢？或者说，我们既然已经能够利用计算机编程了，为什么还要再去学习另外的 程序语言呢？
 
首先，python与C，C++等等其他所有语言之间并没有特别本质上的区别，都是通过程序设计，使得计算机在代码的控制下执行一定的指令。绝大多数C，C++能做的（这里的例外就比如操作系统只能用C来写，Android只能用Java来写等等），python一样可以做，而且可能会更加简便的实现。
 
当下python的使用非常的广泛，的确可以说是学了就不用担心没有地方用。很多著名网站比如YouTube就是用python写的，很多游戏后台也可以用python来写。
 
说了这么多，总之是希望能给大家一个python的轮廓，让大家觉得学习这门语言有点意思！这门语言之后还会陪伴很多学习机器学习的同学走很远，这一节课我们首先给大家简单讲解python语法基础。

 
 
 

python入门篇：基本语法

第一个程序：helloworld！

helloworld几乎是我们学习所有语言开始的第一个程序。python如何去实现输出helloworld呢？
 
首先我们打开IDLE。IDLE的主界面是一个简便的变量查看器，适用于我们简单的尝试几个函数，以及测试写好的程序的内容，我们一般不用它来编程。点击左上角的“file”，再点“new file”，我们就建立了一个python文件。按下CTRL+s，保存到指定的路径：没错，简单的语言就连编译器都如此简单（当然不是，我们之后会用到更高级的编译器…）
 
！！要注意，IDLE不是很聪明，写的时候一定要注意中英文输入法的切换，不然一不小心就调出帮助文档了…！！
！！关于字体的修改：点击“Options”，“Configure Idle”就可以调整了！我用的是comic Sans MS！！

 

下面就是见证奇迹的时刻！我们输入

print("helloworld")

不用printf！不用%s！不用分号！不用头文件！不用return 0 ！不用大括号！就是这么任性！
输入好之后，我们按下F5，就可以运行。在我们的shell里，已经打印出了我们的内容。
 

python语法 - 基本数据类型

 
既然已经尝试了输出，我们当然还希望操作python的数据。下面我们就开始基本数据类型的学习。

1.1 变量的定义

变量的定义不需要声明，使用的时候直接丢到程序里面就可以。比如那我们刚刚的程序，我们在helloworld的输出下面加一行

a = 4

然后我们对他进行输出（ 不需要%d，不需要分号都可以不需要）

print(a)

就可以看到，程序正确的输出了4。
此外，在输出界面，也就是我们的shell里面，我们直接输入a，shell会帮我们打印出a的内容。
 
python语言变量不需要提前声明，也就是说，python语言中变量的类型是没有规定的。上一秒a还是整形，下一秒可以直接用字符串来赋给他，a就变成了一个字符串类型。

print("helloworld")
a = 4
print(a)
a = "helloworld"
print(a)

输出为：
helloworld
4
helloworld

 
但是，这样方便的python同样有要求：那就是使用变量之前必须对该变量进行赋值。没有赋值直接使用是不被允许的。但是没有赋值，却用变量直接承接表达式是被允许的。

a = 4
b = 3
c = a + b
# 没有对c进行初始化的情况下直接进行c = a + b 是允许的
# 井字号是python的单行注释方法

此外，在今后使用一些库或者函数的时候，如果你要是用的变量是该库的特殊变量，则在使用之前也必须进行初始化。比如在tensorflow中，当a，b是张量变量时，不可以直接使用c = a + b

1.2 连续赋值

python可以接受同时多个变量的赋值：

x, y, z = 1, 2, 3
a = b = 123
# 都是python语言允许的定义

1.3 python的基本输入和输出

 
python的输出我们已经见识过了：print即可。
print函数可谓来者不拒，不论要输出整形浮点型双精度字符串列表集合等等等等，只要是变量，统统丢到函数当中即可。python的字符串表达也非常简单，但凡是用引号括起来的内容都是字符串，都可以随意输出。
 
python中，为了方便输入输出的内容带引号，字符串的定义有四种方式：

a = "i love python!"
a = 'really!'
a = '''learning python is good for my hair!''' 
a = """人生苦短，我学python"""

三种定义方式都是允许的。其中，三个连续单引号的定义方式一般用于当作多行注释

'''
   那是因为三个连续引号可以装入回车，
   而其本身是没有任何意义的变量，程序不会做处理
'''

 
python的输入同样非常简单，只需要input即可。不论输入符号，数字，字母，都是允许的。

x = input()

但是要特别注意：这里input的所有内容都是字符串类型。

print(type(x)) # 输出x的类型。结果为：<class 'str'>

如果我们想进行“输入x，计算x的平方”的程序应该怎么做呢？

这里提供两种方法：

# 1.对x进行强制转换 ： 
x = input()
x = int(x) * int(x)
print(x)

# 2.对输入的内容进行去引号处理
x = input()
x = eval(x) * eval(x)
print(x)
# 其中，去引号函数在把引号去掉赋给变量之前，还会自动的根据括号的内容对变量的类型进行分配
print(type(eval(x)))
# 如果输入 5，则会输出 int；如果输入 5.5， 则会输出  float；如果输入[1， 2， 3]，就会输出 list，等等
# 然而eval并不能拆字符串

两种方法都可以使用，但是我们平时使用eval函数更多一点

1.3.1 输入输出语句格式拓展

1. python允许在input括号内通过加字符串的格式来对输入内容进行描述

x = input("please input a integer:")
print(x)

2. python的print输出函数自动计入回车。取消回车的方式是：

print("I don't want an enter",end='')
# 实际上，end=做的事情是将等号后面的字符串加到每一次输出的末尾，默认为回车。

3. 此下，给出了其他可用的输出格式，大家课后自己学习

print("{} is a sb,{} is niubi".format("mcx","zyc"))  # 这样输出时，大括号的顺序和format顺序一一对应
print("{1} is a sb,{0} is niubi".format("zyc","mcx"))  # 这样输出时，大括号顺序按照填写内容进行对应

#1.填充对齐宽度
print("{0:~^20}".format(bstring))
#print("{0:           =        ^      20}".format("bstring"))      ^居中，>右对齐，<左对齐
   #      |           |         |      |       |      |
   #     引导符     填充物      居中   宽度    格式化  目标字符串
print("{0:*>20}".format("bit"))
print("{:20}".format("aa"))  # 将aa放于左边，自动补齐剩余空格
# 2.逗号(千分符，用于财务记账)   点精度(浮点数小数精度或字符串最大输出长度，{:.2f})
#   类型
print("{:,.2f}".format(12345.6789))    # 1 .整数部分放置千分符分割；2.精度补为两位

print("{0:b},{0:c},{0:d},{0:o},{0:x},{0:X}".format(425))  # 用二进制，Unicode编码，十进制，八进制，大小写十六进制表示括号内的数值

print("{0:e},{0:E},{0:f},{0:%}".format(3.14))  # 用小写大写的科学记数法表示，用通常的浮点数表示，用百分数表示

 

python语法 - 分支语句，循环语句

 

2.1 分支语句

在进行python程序的编写时，应该格外注意格式的书写。因为python是没有大括号的语言，所以能够判断python语段范围的只有缩进。python的分支表达式为：

if <语句段>:
	# 必须缩进，否则会报错。而且只能缩进一次
	<语句段>

我们来小小的实践一下：

a = eval(input())
if a % 2 == 0 :
	print('ok!')
elif a % 2 == 1:
	print('no!')
# 或者也可以直接else：

 

2.2 循环语句

与分支语句相同，循环语句中的缩进同样非常重要。python的循环表达式为：

for <循环判断>:
	# 必须缩进，否则会报错。而且只能缩进一次
	<语句段>

其中，循环判断的格式为：

	i in <范围>

这个范围可以是一个列表：

list = [1, 2, 3]
for i in list:
	print(i)
	# 则i会遍历整个列表

也可以是一个整数：

for i in range(45):
	print(i,end='  ')
	# 则i会分别被赋值为0， 1， ...， 44

总之，只要是能够进行循环遍历操作的，都用 i in … 来修饰即可
 
 

python语法 - 组合数据类型

 
python的组合数据类型大家完全可以类比C语言中的各种数组。python中，没有严格的数组概念，而是用其他组合数据类型代替。

3.1 集合

python的集合概念与数学概念上的集合非常相像，就是一群有相同意义的数据的集合,在python中常用于数据去重。python的语法表达中，集合的表达形式为：

b = 2
a = {1, 'python', b}
# 集合来者不拒，大多数数据类型都可以直接包含到集合当中

同数学的集合相似，集合中不能有相同的元素.如果出现相同的元素，集合会直接将相同的其他项删除，只保留一项。而且，当集合中包含变量时，集合会直接判断变量的内容是否与集合内容重复。
 
另外，集合在用户进行输入之后会直接自动的对其中所有元素进行排序，但是排序的方法，在不同的操作系统，甚至不同的时刻都有可能不是完全相同。集合的顺序本身就是开发者为了方便查找遍历和使用的，我们程序员不要利用这个顺序。但是基本保持：相同数据类型会被排布在一起，相同数据类型之间会根据大小（或者字符串长短也有可能）来从小到大排序
 
以下给出集合的操作，同学们课后掌握

#-------------------------集合操作符-------------------------#
c = {1,2,3,4,5} ; d = {4,5,6,7,8}
#1.求并集: |
print('1.1 ',c|d)
#2.求集合的差(取前不取后): -
print('1.2 ',c-d)   #输出包含在c中但不在d中的元素
#3.求交集: &
print('1.3 ',c&d)
#4.求两集合中不同的元素: ^
print('1.4 ',c^d)
#5.比较两个元素的包含关系
print('1.5 ',c>=d)
e = {1,2,3}
print('1.6 ',c>=e)


#-------------------------增强操作符-------------------------#
c |= d  #更新集合c，包括c，d中的所有元素
print('2.1 ',c)
c -= d  #同上，讲c，d运算过后的结果赋值给c
print('2.2 ',c)


#------------------------集合处理方法------------------------#
c = {1,2,3,4,5}
#1.如果x不在集合中，将x增加到c
c.add(6)
print('3.1 ',c)

c = {1,2,3,4,5}
#2.如果x在集合中，移除x;如果x不在集合中，不报错
c.discard(5)
print('3.2 ',c)

c = {1,2,3,4,5}
#3.如果x在集合中，移除x;如果x不在集合中，报错
c.remove(5)
print('3.3 ',c)

c = {1,2,3,4,5}
#4.移除所有元素
c.clear()
print('3.4 ',c)

c = {1,2,3,4,5}
#5.为用户随即返回一个集合中的元素并且在几何中删除这个元素。如果集合为空则报错
f = c.pop()
print('3.5 ',f,c)

c = {1,2,3,4,5}
#6.返回一个集合的副本
d = c.copy()
print('3.6 ',d)

c = {1,2,3,4,5}
#7.返回集合元素个数
f = len(c)
print('3.7 ',f)

c = {1,2,3,4,5}
#8.判断x是否在集合中
a = 5 in c
print('3.8 ',a)

c = {1,2,3,4,5}
#9.判断x是否不在集合中
a = 5 not in c
print('3.9 ',a)

c = (1,2,3,4,5,5,5)
#10.将其他类型转化为集合类型
c = set(c)
print('3.10 ',c)

3.2 列表

列表的概念非常接近于我们C/C++中的数组。它的内容可以重复，有固定的顺序。列表定义只需要中括号即可，用逗号分隔

a = [1, 2, 'hello!']
# 或者可以用下面的方法快速定义
b = [i for i in range(10)]

对于列表a，我们有可以对其进行遍历，也可以访问列表的下标

for i in a:
	print(i)
for i in range(len(a)):
	print(a[i])

这里给出list的操作。希望大家不要尝试全部背诵，可以把这篇博客当作百科书，随用随查

len(a)  # 返回列表元素个数

a.append('dove')  # append用于单个元素的加入

a.extend(['i','love','dove']) # extend用于整个列表的加入

max(a)  min(a)  # max(a),min(a)返回列表的最大值最小值。在使用时，需要元素可以比较

a.insert(0,'hello')  # insert的两个参数：要插入的顺序，要插入的内容

a.index(123)  # 从第一个元素遍历，输出第一次出现123这个元素的位置
a.index(123,1,3)  # 从第一个到第三个元素中，第一次出现123这个元素的位置
a.count(123)  # 序列中出现123的次数

sort(a)  # 排序
reverse(a) # 逆序输出

a.clear()  # 清空列表

del a[2]  # 指定删除a下标为2的元素

3.3 元组

元组就是不能够修改的list，一般很少使用，下面给出方法

#将一些值用逗号分隔
a=1,2,3
print(a)

#常用做法
a=(1,2,3)

#调用函数tuple:它将一个序列作为参数，并将其转换为元组
a=tuple([1,2,3])
b=tuple("abc")
print(a,b,sep='\n')

#特殊情况：表示只包含一个值的元组
a=42,
b=(42,)
print(a,b,sep='\n')

3.4 字典

字典类型是很特殊的一种类型。它的元素是一对数据，也可以叫一组关系
每一个元素表示为 <键>:<值>
元素之间用逗号隔开。可以认为，列表是用数字作索引标准，字典用我们自己定义的元素作索引。
字典类型就可以类比我们现实中的字典，我们在知道键的情况下，可以通过目录的索引找到值；python语法中同样可以这样理解

zidian = {'outside':'green','inside':'blue'}
print(zidian['outside'])

同样，在C/C++中对数组的操作，在python中对list的操作同样可以类比，只不过在表达上有些许区别而已。以下给出字典的操作

#字典类型操作函数和方法
dic = {1:'mcx',2:'zyc',3:'ch',4:'ylx',5:'ljw'}
print('0.最初定义的字典变量',dic)
del  dic[1]
print('1.删除第一项',dic)

print('2.判断键“1”是否在字典中(已在上一步删除)',1 in dic)

dic = {1:'mcx',2:'zyc',3:'ch',4:'ylx',5:'ljw'}
print('3.返回所有键的信息',dic.keys())
print('4.返回所有值的信息',dic.values())
print('5.返回所有键值对的信息',dic.items())
dic = dict(((1,'mcx'),(2,'zyc'),(3,'ch'),(4,'ylx'),(5,'ljw'),(6,'wb'),(7,'dsp')))
print('5+.利用dict创建一个字典',dic)

print('6.若存在该键,则返回对应的值，否则返回<default>',dic.get(6,'wb'))
print('7.若存在该键,则去除并返回对应的值，否则返回<default>',dic.pop(6,'wb'))
print('8.随机取出一个键值对并以元组形式返回',dic.popitem())
print('9.删除所有键值对',dic.clear())

dic = {1:'mcx',2:'zyc',3:'ch',4:'ylx',5:'ljw'}
print('10.返回字典元素个数',len(dic))

字典类型在进行对应数据处理时非常重要，但对于前期学习的同学们，能够熟练掌握list就已经足够，因为list就是C/C++数组的超级加强版

 
 
 

python语法 - 字符串

考虑到字符串的重要地位，以及python中字符串的特殊形式，我们字符串单独拿出来讲。

4.1 字符串的定义

字符串的定义我们在最上面就已经解释过，直接利用单引号/双引号/三连单引号，双引号括起来，就已经做好了一个字符串。python的字符串非常“宽松”，即，基于python的保护机制，在使用字符串时完全不用考虑越界，超范围等等C语言中很麻烦的问题

a = 'I love esta'
b = ' I love'
print(a + b) # 如果想进行字符串连接的操作，直接 + 就可以

4.2 字符串的各种操作

在C语言中，字符串其实是利用数组去模拟的一种便捷数组表达。而python中，字符串更像一个变量。因此对字符串的操作十分自由。

a = 'I love esta'
b = 'I love'
print(a + b) # 上文已经讲过，加法代表两个字符串连接
c = '人类的本质是复读机'
print(c*5) # 直接乘法代表字符串重复多少次
d = '人类'
print(d in c) # 利用in判断d是否是后者的子串

a.upper()  # 将字符串的所有字母改为大写
a.lower()  # 将字符串的所有字母改为小写 
a.split(' ') # 将字符串根据括号内的内容分隔开，返回保存在列表中
a.count('e')
a.replace('esta','Esta')

除了字符串整体的操作，python还支持字符串的切片。

a = 'I love esta'
print(a[0])  # 返回第一个字符
print(a[-1]) # 返回最后一个字符
print(a[3:6])# 获取字符串切片，左闭右开
print(a[1:9:2])  #指从第一位开始，到第九位之前，每隔两个取一个
print(a[::-1])  #字符串的逆序

print(fstring.center(20,"="))  #将目标字符串放在宽度为20的居中位，其余用=填充
print("= python= ".strip(" =np"))  #删掉字符串两侧的“ ”，“=”，“n”，“p”，直到左右不出现这四个字符为止
print("|".join(estring))  #将目标字符串夹在join括号内字符串的出最后一位的字符后边

 
 

python语法 - 函数

python的函数定义同样十分简单。python定义函数时，不需要考虑参量的类型，返回值类型等等问题。直接使用def就可以定义函数；同样，函数必须缩进。

def hello():     #参数括号中可以写入你的参数
    print('hello!')
        
def hello2(a):   #这里我们想要调入一个列表，但我们不用事先说明他是个列表
    print(a)
    
hello2([1,2,3]) # 当然也是没有任何问题的
hello2("hi,I'm a string!") #字符串也没有问题
# 虽然python很好用，但是要注意，你传入的内容应该符合函数的操作！

此外，python还接受这样的操作：

def hello(name,greeting='Hello',punctuation='!'):
    print('{},{}{}'.format(greeting,name,punctuation))
hello('python','Hi','^_^')
hello('python',punctuation='^_^')
hello('python',greeting='Glad to see you')


#星号收集余下的位置参数并存放在一个元组中
def print_params1(title,*params):
    print(title,end=' ')
    print(params)
print_params1('Params:',1,2,3)   

#收集关键字参数需要**,得到的为一个字典
def print_params2(**params):
    print(params)
print_params2(x=1,y=2,z=3)


#1、拆分序列*
def add(x,y):
    return x+y
params=1,2
print(add(*params))

def mutiply(x,y,z):
    return x+y*z
params1=[2,3]
print(mutiply(1,*params1))   #星号部分必须位于参数列表末尾

#2、拆分字典**
def hello(greeting="Hello",name='World'):
    print(greeting+',',name)
dic={'name':'MMS','greeting':'Glad to see you'}
hello(**dic)

 
 

python语法 - 常用库

如同C/C++允许加入include，python同样可以使用库。不如说，python的灵魂就是这些各种各样的库，他们极大的丰富了python的功能。后人不用再造轮子，可以方便的实现很多功能。
这节课不会详细讲解每一个库的作用，大家只需要用的时候来找一找即可。

5.1 库的调用

#导入一个模块
import somemodule(模块)
somemodule.somefunction()   #调用该模块的某个函数

#从模块中导入（一些）函数
from somemodule import somefunction[,anotherfunction,...]
somefunction()    

 #给模块指定别名
import somemodule as m
m.somefunction()

#导入模块中的一切函数
from somemodule import *
somefunction()

#导入一个函数并指定别名
from somemodule import somefuntion as f
f()

一般，我们用前三种表达方式更多一些
 

5.2 常用库：time库

要使用time库，我们首先应该将time库导入到我们的程序中

import time

关于time库，我们首先给出常用方法

#1.0获得当前时间戳，是从1970年某一个时刻到今天的秒数
print(time.time())
#1.1易于阅读的时间：(被保存为字符串形式)
print(time.ctime())
#1.2易于计算机阅读的时间(保存为struct结构)
print(time.gmtime())

# 此外，python还提供了时间的标准化输出。
t = time.gmtime()
strtime = time.strftime("%Y-%m-%d %H:%M:%S",t)

# time库通过time.perf_counter来获得当前时间戳，保存为浮点型
start = time.perf_counter()
# 用这个函数，我们可以计算程序执行的过程中的时间
time.sleep(2)
end = time.perf_counter()
print(end - start)

下面，我们利用已经学过的time库来看看python运行速度和C的区别

5.3 常用库：jieba库

jieba库是python中非常强的中文分词库。但jieba并不是python自带的库，我们要通过下载才能使用。
首先按下win+R，在对话框中输入cmd。
然后将这一段拷贝到命令行中，回车安装（确保联网）
pip install jieba -i https://pypi.douban.com/simple/

以下给出jieba库的用法：

#jieba库的使用
import jieba
s = '弛弛学长喜欢python'
t = "弛弛学长先吃苹果然后喝可乐"
print(jieba.lcut(s))    #精确模式：返回一个列表的分词结果
print(jieba.lcut(t,cut_all=True))    #全模式：返回所有有关联的分词结果
print(jieba.lcut_for_search(s))    #搜索模式：更为智能的分词结果
jieba.add_word('弛弛学长')  #向搜索模式中添加新词
print(jieba.lcut(s))    #精确模式：返回一个列表的分词结果

 
 
课后作业：

我们将给出一段台本，请根据jieba库进行分词，统计文本的词的频率，并将出现次数最多的10个词打印出来。

numpy简介

NumPy(Numerical Python) 是 Python 语言的一个扩展程序库，支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。
 
NumPy 是一个运行速度非常快的数学库，主要用于数组计算，包含：
1、一个强大的N维数组对象 ndarray
2、广播功能函数
3、线性代数、傅里叶变换、随机数生成等功能

numpy 安装

使用pip安装：
在cmd中输入

pip install numpy

安装验证：打开idle，输入以下代码，运行不报错即说明安装完成。可以通过第二行代码查看numpy版本，版本号达到1.12以上就不存在兼容性的问题

import numpy
numpy.__version__

由于之后我们会经常使用numpy，为了使用方便，通常在导入numpy库的时候，给numpy一个别名np，之后即可直接使用np代表numpy这个库

import numpy as np
np.__version__

为什么使用numpy中的array

python list 的特点

L = [i for i in range(10)]
L

结果：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

L[5] #访问其中元素
L[5] = 100 #为元素赋值
L[5] = "machine learning"
L

结果：[0, 1, 2, 3, 4, ‘Machine Learning’, 6, 7, 8, 9]
在list类型中，每个数据的类型可以不一样，既有好处，增强了程序的灵活性，同时也有不可避免的问题，在list类型的底层，有自动检测类型并转换的功能，这也就会耗费大量时间。

array类型

import array
arr = array.array('i', [i for i in range(10)])
arr

结果：array(‘i’, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

arr[5] #True
arr[5]=100 #True
arr[5] = 'machine learning'  #False

报错：TypeError: an integer is required (got type str)
刚刚定义的array类型中，声明过类型只能是整型，所以将字符串给其中元素赋值将会报错
array类型没有list那样智能，它不会在底层自动检测数据类型并转换，但是它的效率很高很快。
 
但是在array中，数据只是以单一的类型存放，但是并没有将其视为向量或者矩阵，自身也没有相应的函数用以处理向量和矩阵。
因此，最终出现了numpy.array进行向量和矩阵的处理，在array的基础上，添加了许多处理向量和矩阵的方法。

numpy.array

nparr = np.array([i for i in range(10)])
nparr

结果：array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

nparr[5] #True
nparr[5] = 100 #True
nparr[5] = 'machine learning' #False
nparr.dtype #查看你的数据类型

numpy.array的创建方法

整体创建

np.zeros(10)
np.zeros(10).dtype  #默认float
np.zeros(10, dtype=int) #创建整型
np.zeros((3, 5))  #创建3行5列的全部为0的二维数组（矩阵）
np.zeros(shape=(3, 5), dtype=int) #另一种方式
np.ones(10)
np.ones((3, 5))
np.full((3, 5), 666) 
np.full((3, 5), 666.0) 
np.full(shape=(3, 5), fill_value=666.0)
np.full(fill_value=12, shape=10)

arange

[i for i in range(0, 20, 2)] #创建列表
np.arange(0, 20 ,2) #创建数组
[i for i in range(0, 1, 0.2)] #False
np.arange(0, 1, 0.2)
np.arange(0, 10)
np.arange(10)

linspace

np.linspace(0, 20, 10)
np.linspace(0, 20 ,11)

random

在机器学习算法中，我们常常需要定义一些随机的向量或者矩阵，但是如果每次创建的都是随机的，每次随机的值都不一样，那会造成每次算法的结果都不一样，为我们调试算法带来麻烦
所有计算机中的随机数其实都是伪随机数，其实都是内部的随机数生成算法来完成的，运行这个算法都是会有一个随机种子seed，这个seed也就决定了随机数的值

np.random.randint(0, 10)
np.random.randint(0, 10, 10)
np.random.randint(0, 1, 10)
np.random.randint(4, 8, size=10)
np.random.randint(4, 8, size=(3, 5))
np.random.seed(666)
np.random.random()
np.random.random(10)
np.random.random((3, 5))
np.random.normal()
np.random.normal(10, 100)
np.random.normal(0, 1, (3, 5))

numpy.array 的基本操作

import numpy as np
x = np.arange(10)
X = np.arange(15).reshape(3, 5)

查看基本属性

x.ndim
X.nidm

x.shape
X,shape

x.size
X.size

数据访问

x
x[0]
x[-1]

X
X[0][0]
X[(2, 2)]
X[2, 2]

x[0:5]
x[:5]
x[5:]
x[::2]
x[::-1]

X
X[:2. :3]
X[:2][:3]
X[::-1, ::-1]
X[0]
X[0, :]
X[0, :].ndim
X[:, 0]
X[:, 0].ndim


subX = X[:2, :3]
subX
subX[0, 0] = 100
subX
X
X[0, 0] = 0
subX

subX = X[:2, :3].copy()
subX
subX[0, 0] = 100
X

reshape

x.rehsape(2, 5)
x
A = x.reshape(2, 5)
A
B = x.reshape(1, 10)
B.ndim
B.shape
x.shape
x.reshape(10, -1)
x.reshape(-1, 10)
x.reshape(2, -1)
x.reshape(3, -1)

合并操作

x = np.array([1, 2, 3])
y = np.array([3, 2, 1])
z = np.array([666, 666, 666])
np.concatenate([x, y])
np.concatenate([x, y, z])
A = np.array([[1, 2, 3],
			  [4, 5, 6]])
np.concatenate([A, A])
np.concatenate([A, A], axis=1)
np.concatenate([A, z]) #False
np.concatenate([A, z.reshape(1, -1)])

np.vstack([A, z])

B = np.full((2, 2), 100)
np.hstack([A, B])
np.hstack([A, z]) #False

分割操作

划分特征和标签

x = np.arange(10)
x1, x2, x3 = np.split(x, [3, 7])
x1, x2, x3
x1, x2 = np.split(x, [5])
x1, x2

A = np.arange(16).reshape((4, 4))
A
A1, A2 = np.split(A, [2])
A1, A2

A1, A2 = np.split(A, [2], axis=1)
A1, A2

data = np.arange(16).reshape((4, 4))
data
X, y = np.hsplit(data, [-1])
X, y

运算操作

问题：给定一个向量，让向量中的每一个数乘以2
a = (0, 1, 2)
a*2 = (0, 2, 4)

L1 = [0， 1， 2]
2 * L1
L2 = np.array([0, 1, 2])
2 * L2

Universal Functions

X = np.arange(1, 16).reshape((3,5))
X
X + 1
X - 1
X / 2
X // 2
X * 2
X ** 2
X % 2
1 / X
np.abs(X)
np.sin(X)
np.cos(X)
np.tan(X)
np.power(3, X)
np.log(X)
np.log2(X)

矩阵运算

A = np.arange(4).reshape(2, 2)
A
B = np.full((2, 2), 10)
B
C = np.full((3, 3), 666)

A + B
A - B
A * B
A / B

A.dot(B)
A.T

A + C #False
A.dot(C)#False

向量和矩阵的运算

v = np.array([1, 2])
A
v + A
np.vstack([v] * A.shape[0])
np.vstack([v] * A.shape[0]) + A

np.tile(v, (2, 1))
np.tile(v, (2, 1)) + A

v * A
v.dot(A)
A.dot(v)