Python对大小写敏感。
在 Windows 下可以不写第一行注释:
#!/usr/bin/python3
第一行注释标的是指向 python 的路径，告诉操作系统执行这个脚本的时候，调用 /usr/bin 下的 python 解释器。
此外还有以下形式（推荐写法）：
#!/usr/bin/env python3
这种用法先在 env（环境变量）设置里查找 python 的安装路径，再调用对应路径下的解释器程序完成操作
函数帮助：
# 如下两种方法实例，查看 max 内置函数的参数列表和规范的文档
>>> help(max)
……显示帮助信息……
>>> max?
Python介绍
Python是一种解释性语⾔。Python语⾔的⼀个重要特性就是它的对象模型的⼀致性。每个数字、字符串、数据结构、函数、类、模块等等，都是在Python解释器的自有“盒⼦”内，它被认为是Python对象。每个对象都有类型（例如，字符串或函数）和内部数据。在实际中，这可以让语言⾮常灵活，因为函数也可以被当做对象使⽤。
下载包package
若想安装不在Anaconda中的 Python包，通常可以⽤以下命令安装：
conda install package_name
如果这个命令不⾏，也可以⽤pip包管理⼯具：
pip install package_name
你可以⽤conda update命令升级包：
conda update package_name
pip可以⽤--upgrade升级：
pip install --upgrade package_name
查看版本
import matplotlib.pyplot as plt
import pandas as pd #导入pandas的常规做法
import sys #导入sys库只是为了确认一下Python的版本
import matplotlib #这样导入matplotlib只是为了显示一下其版本号
print('Python version ' + sys.version) #查看python版本
print('Pandas version ' + pd.__version__) #查看pandas版本
print('Matplotlib version ' + matplotlib.__version__)
import 用法
关于 import 的小结，以 time 模块为例：
1、将整个模块导入，例如：import time，在引用时格式为：time.sleep(1)。
2、将整个模块中全部函数导入，例如：from time import *，在引用时格式为：sleep(1)。
3、将模块中特定函数导入，例如：from time import sleep，在引用时格式为：sleep(1)。
4、将模块换个别名，例如：import time as abc，在引用时格式为：abc.sleep(1)。
5、从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc
import 模块和from 模块 import *；两种写法的区别是第二种调用函数时不需要模块前缀
Python在linux下的进入与退出
进入Python交互模式，提示符是>>>
[ch@bdos02 ~]$ python
>>>
在Python交互模式下输入exit()并回车，就退出了Python交互模式。
>>> exit()
在Python交互式模式下，可以直接输入代码，然后执行，并立刻得到结果。
在命令行模式下，可以直接运行.py文件。
数据类型和变量
Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。
等号（=）用来给变量赋值，变量名区分大小写。
等号（=）运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值。
#!/usr/bin/python3
counter = 100 # 整型变量
miles = 1000.0 # 浮点型变量
name = "runoob" # 字符串
Python3 的六个标准数据类型中：
- 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
- 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。
常用的数据类型有：整型（int）、浮点型（Float）、字符串(string)
数字(Number)
python中数字有四种类型：整数、布尔型、浮点数和复数。
|
int |
整数 |
如1,只有一种整数类型int，表示为长整型，没有python2中的Long。 |
|
bool |
布尔 |
如True。 |
|
Float |
浮点数 |
如1.23、2.0 |
|
complex |
复数 |
如1+2j、1.1+2.2j |
不同类型的数混合运算时会将整数转换为浮点数：>>> 3 * 3.75 / 1.5
字符串(string)
- python中单引号和双引号使用完全相同。
- 使用三引号('''或""")可以指定一个多行字符串。
- 转义符 '\'。比如\n表示换行，\t表示制表符，字符\本身也要转义，所以\\表示的字符就是\;
- 反斜杠可以用来转义，使用r可以让反斜杠不发生转义。如 r"this is a line with \n" 则\n会显示，并不是换行。
- 按字面意义级联字符串，如"this " "is " "string"会被自动转换为this is string。
- 字符串可以用 + 运算符连接在一起，用 * 运算符重复。
- Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。
- Python中的字符串不能改变。
- Python 没有单独的字符类型，一个字符就是长度为 1 的字符串。
- 字符串的截取的语法格式如下：变量[头下标:尾下标:步长]
实例(Python 3.0+)
#!/usr/bin/python3
str='Runoob'
print(str) # 输出字符串
print(str[0:-1]) # 输出第一个到倒数第二个的所有字符
print(str[0]) # 输出字符串第一个字符
print(str[2:5]) # 输出从第三个开始到第五个的字符
print(str[2:]) # 输出从第三个开始后的所有字符
print(str[1:5:2]) # 输出从第二个开始到第五个且每隔两个的字符
print(str * 2) # 输出字符串两次
print(str + '你好') # 连接字符串
print('------------------------------')
print('hello\nrunoob') # 使用反斜杠(\)+n转义特殊字符
print(r'hello\nrunoob') # 在字符串前面添加r，表示原始字符串，不会发生转义
Python 的字符串内建函数：https://www.runoob.com/python3/python3-string.html
List[列表]
列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。
列表是写在方括号 [] 之间、用逗号分隔开的元素列表。
和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。
列表截取的语法格式如下：
变量[头下标:尾下标:步长(默认1，可省略)]
实例：
#!/usr/bin/python3
list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
tinylist = [123, 'runoob']
print (list) # 输出完整列表
print (list[0]) # 输出列表第一个元素
print (list[1:3]) # 从第二个开始输出到第三个元素
print (list[2:]) # 输出从第三个元素开始的所有元素
print (tinylist * 2) # 输出两次列表
print (list + tinylist) # 连接列表
与Python字符串不一样的是，列表中的元素是可以改变的：
a = [1, 2, 3, 4, 5, 6]
a[2:5] = [] # 将对应的元素值设置为 []
列表推导式书写形式：
[表达式 for 变量 in 列表]
或者
[表达式 for 变量 in 列表 if 条件]
[表达式]：最后执行的结果
[for变量 in 列表]：这个可以是一个多层循环
[if 条件]：两个for间是不能有判断语句的，判断语句只能在最后；顺序不定，默认是左到右。
li = [1,2,3,4,5,6,7,8,9]
print ([x**2 for x in li])
print ([x**2 for x in li if x>5])
清空列表中的多项空值：
test = ['a','','b','','c','','']
test = [i for i in test if i != '']
print(test)
输出结果为:
['a', 'b', 'c']
Python列表包含以下函数:
|
序号 |
函数 |
|
1 |
len(list) 列表元素个数 |
|
2 |
max(list) 返回列表元素最大值 |
|
3 |
min(list) 返回列表元素最小值 |
|
4 |
list(seq) 将元组转换为列表 |
|
5 |
cmp(list1, list2) 比较两个列表的元素 |
Python列表包含以下方法:
|
方法 |
描述 |
|
list.append(x) |
把一个元素添加到列表的结尾，相当于 a[len(a):] = [x]。 |
|
list.extend(L) |
用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表），相当于 a[len(a):] = L。 |
|
list.insert(i, x) |
在指定位置插入一个元素。第一个参数是准备插入到其前面的那个元素的索引，例如 a.insert(0, x) 会插入到整个列表之前，而 a.insert(len(a), x) 相当于 a.append(x) 。 |
|
list.remove(x) |
删除列表中值为 x 的第一个元素。如果没有这样的元素，就会返回一个错误。 |
|
list.pop([i]) |
从列表的指定位置移除元素，并将其返回。如果没有指定索引，a.pop()返回最后一个元素。元素随即从列表中被移除。（方法中 i 两边的方括号表示这个参数是可选的，而不是要求你输入一对方括号，你会经常在 Python 库参考手册中遇到这样的标记。） |
|
list.clear() |
移除列表中的所有项，等于del a[:]。 |
|
list.index(x) |
返回列表中第一个值为 x 的元素的索引。如果没有匹配的元素就会返回一个错误。 |
|
list.count(x) |
返回 x 在列表中出现的次数。 |
|
list.sort() |
对列表中的元素进行排序。 |
|
list.reverse() |
倒排列表中的元素。 |
|
list.copy() |
返回列表的浅复制，等于a[:]。 |
遍历嵌套的列表：
num_list = [[1,2,3],[4,5,6]]
for i in num_list:
for j in i:
print(j)
输出结果：
1
2
3
4
5
6
Tuple（元组）
元组写在小括号 () 里，元素之间用逗号隔开。
虽然tuple的元素不可改变，但它可以包含可变的对象，元组可以包含多种类型的数据，比如list列表。
string、list 和 tuple 都属于 sequence（序列）。
注意：
1、与字符串一样，元组的元素不能修改。
>>> tuple[0] = 11 # 修改元组元素的操作是非法的
2、元组与列表类似也可以被索引和切片，方法一样。
3、注意构造包含 0 或 1 个元素的元组的特殊语法规则。
tup1 = () # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号
4、元组也可以使用+操作符进行拼接。
元组内置函数
Python元组包含了以下内置函数
|
序号 |
方法及描述 |
|
1 |
cmp(tuple1, tuple2) 比较两个元组元素。 |
|
2 |
len(tuple) 计算元组元素个数。 |
|
3 |
max(tuple) 返回元组中元素最大值。 |
|
4 |
min(tuple) 返回元组中元素最小值。 |
|
5 |
tuple(seq) 将列表转换为元组。 |
Dictionary{字典}
字典是一种映射类型，字典用 { } 标识，它是一个无序的键(key) : 值(value)集合。
字典是无序的对象集合，列表是有序的对象集合。字典于列表的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
1、字典是一种映射类型，它的元素是键值对。
2、字典的键必须为不可变类型，且不能重复。
3、创建空字典使用 { }。
4、字典列表，即在列表中嵌套字典
字典推导式：{key:value for variable in iterable [if expression]}
如调换k,v值：
reverse = {v: k for k, v in dic.items()}
print(reverse)
字典内置函数&方法
Python字典包含了以下内置函数：
|
序号 |
函数及描述 |
|
1 |
cmp(dict1, dict2) 比较两个字典元素。 |
|
2 |
len(dict) 计算字典元素个数，即键的总数。 |
|
3 |
str(dict) 输出字典可打印的字符串表示。 |
|
4 |
type(variable) 返回输入的变量类型，如果变量是字典就返回字典类型。 |
Python字典包含了以下内置方法：
|
序号 |
函数及描述 |
|
1 |
dict.clear() 删除字典内所有元素 |
|
2 |
dict.copy() 返回一个字典的浅复制 |
|
3 |
dict.fromkeys(seq[, val]) |
|
4 |
dict.get(key, default=None) 返回指定键的值，如果值不在字典中返回default值 |
|
5 |
dict.has_key(key) 如果键在字典dict里返回true，否则返回false |
|
6 |
dict.items() 以列表返回可遍历的(键, 值) 元组数组 |
|
7 |
dict.keys() 以列表返回一个字典所有的键 |
|
8 |
dict.values() 以列表返回字典中的所有值 |
|
9 |
dict.setdefault(key, default=None) |
|
10 |
dict.update(dict2) 把字典dict2的键/值对更新到dict里 |
|
11 |
pop(key[,default]) 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。 |
|
12 |
popitem() 返回并删除字典中的最后一对键和值。 |
#!/usr/bin/python3
dict = {}
dict['one'] = "1 - 菜鸟教程"
dict[2] = "2 - 菜鸟工具"
tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'}
print (dict['one']) # 输出键为 'one' 的值
print (dict[2]) # 输出键为 2 的值
print (tinydict) # 输出完整的字典
print (tinydict.keys()) # 输出所有键
print (tinydict.values()) # 输出所有值
print (tinydict.items()) # 输出所有键值对
构造函数 dict() 可以直接从键值对序列中构建字典如下：
>>> dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])
{'Runoob': 1, 'Google': 2, 'Taobao': 3}
>>> dict(Runoob=1, Google=2, Taobao=3)
{'Runoob': 1, 'Google': 2, 'Taobao': 3}
# dict(d)，d不一定必须为一个序列元组：
>>> dict_1 = dict([('a',1),('b',2),('c',3)]) #元素为元组的列表
>>> dict_1
{'a': 1, 'b': 2, 'c': 3}
>>> dict_2 = dict({('a',1),('b',2),('c',3)})#元素为元组的集合
>>> dict_2
{'b': 2, 'c': 3, 'a': 1}
>>> dict_3 = dict([['a',1],['b',2],['c',3]])#元素为列表的列表
>>> dict_3
{'a': 1, 'b': 2, 'c': 3}
>>> dict_4 = dict((('a',1),('b',2),('c',3)))#元素为元组的元组
>>> dict_4
{'a': 1, 'b': 2, 'c': 3}
字典是支持无限极嵌套的，如下面代码：
cities={
'北京':{
'朝阳':['国贸','CBD','天阶','我爱我家','链接地产'],
'海淀':['圆明园','苏州街','中关村','北京大学'],
'昌平':['沙河','南口','小汤山',],
'怀柔':['桃花','梅花','大山'],
'密云':['密云A','密云B','密云C']
},
'河北':{
'石家庄':['石家庄A','石家庄B','石家庄C','石家庄D','石家庄E'],
'张家口':['张家口A','张家口B','张家口C'],
'承德':['承德A','承德B','承德C','承德D']
}
}
for i in cities['北京']:
print(i)
将列出如下结果：可是为什么呢？
朝阳
海淀
昌平
怀柔
密云
for i in cities['北京']['海淀']:
print(i)
输出如下结果：
圆明园
苏州街
中关村
北京大学
补充：
空值
空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。
常量
注意：
1、Python可以同时为多个变量赋值，如a, b = 1, 2。
2、一个变量可以通过赋值指向不同类型的对象。
3、数值的除法包含两个运算符：/ 返回一个浮点数，// 返回一个整数。
4、在混合计算时，Python会把整型转换成为浮点数。
Set{集合}
集合基本功能是进行元素关系测试和删除重复元素。可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
创建格式：
parame = {value01,value02,...}
或者
set(value)
实例：
#!/usr/bin/python3
sites = {'Google', 'Taobao', 'Runoob', 'Facebook', 'Zhihu', 'Baidu'}
print(sites) # 输出集合，重复的元素被自动去掉
# 成员测试
if 'Runoob' in sites :
print('Runoob 在集合中')
else :
print('Runoob 不在集合中')
# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')
print(a)
print(a - b) # a 和 b 的差集
print(a | b) # a 和 b 的并集
print(a & b) # a 和 b 的交集
print(a ^ b) # a 和 b 中不同时存在的元素
以上实例输出结果：
{'Zhihu', 'Baidu', 'Taobao', 'Runoob', 'Google', 'Facebook'}
Runoob 在集合中
{'b', 'c', 'a', 'r', 'd'}
{'r', 'b', 'd'}
{'b', 'c', 'a', 'z', 'm', 'r', 'l', 'd'}
{'c', 'a'}
{'z', 'b', 'm', 'r', 'l', 'd'}
集合内置方法完整列表：https://www.runoob.com/python3/python3-set.html
可变和不可变数据类型
可变数据类型：指其值可以直接修改、删除和添加；不可变数据类型则相反。
- 字符串是不可变数据类型，改变字符串的正确方式是使用切片和连接构造新的变量，直接修改会报错TypeError
- 列表[]是可变数据类型
- 元祖是列表数据类型的不可变形式，是不可改变数据类型，使用()，而不是[]
#列表举例
name=[1,2,3]
name[1]=10 #直接修改
print(name) #返回[1, 10, 3]
#元祖举例
egg=('a', 'b', 'c', 'd', 12, 13.0) #元组可以包含多种类型的数据
type(('hello',)) #只有一个值时最后加个逗号表明是元组
type(('hello'))
python数据类型转换
对数据内置的类型进行转换，你只需要将数据类型作为函数名即可。
以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象，表示转换的值。
|
函数 |
描述 |
|
int(x) |
将x转换为一个整数 |
|
将x转换到一个浮点数 |
|
|
创建一个复数 |
|
|
将对象 x 转换为字符串 |
|
|
将对象 x 转换为表达式字符串 |
|
|
用来计算在字符串中的有效Python表达式,并返回一个对象 |
|
|
将序列 s 转换为一个元组 |
|
|
将序列 s 转换为一个列表 |
|
|
转换为可变集合 |
|
|
创建一个字典。 |
|
|
转换为不可变集合 |
|
|
将一个整数转换为一个字符 |
|
|
将一个字符转换为它的整数值 |
Python3 运算符
算术运算符
以下假设变量a为10，变量b为21：
|
运算符 |
描述 |
实例 |
|
+ |
加 - 两个对象相加 Ps:加号还可以用于连接两个字符串：print('a'+'b') Ps:加号还可以用于两个数字相加：print(2.3+2.1) 但不能让数字+字符串：print(2.3+'a')，错误写法 连接数字+字符串正确写法：print(str(2.3)+'a') |
a + b 输出结果 31 |
|
- |
减 - 得到负数或是一个数减去另一个数 |
a - b 输出结果 -11 |
|
* |
乘 - 两个数相乘或是返回一个被重复若干次的字符串 *用于字符串和数字n之间表示复制字符串n次：print('a'*5) |
a * b 输出结果 210 |
|
/ |
除 - x 除以 y |
b / a 输出结果 2.1 |
|
% |
取模 - 返回除法的余数 |
b % a 输出结果 1 |
|
** |
幂 - 返回x的y次幂 |
a**b 为10的21次方 |
|
// |
取整除 - 向下取接近商的整数 |
>>> 9//2 4 >>> -9//2 -5 |
比较运算符
以下假设变量a为10，变量b为20：
|
运算符 |
描述 |
实例 |
|
== |
等于 - 比较对象是否相等 |
(a == b) 返回 False。 |
|
!= |
不等于 - 比较两个对象是否不相等 |
(a != b) 返回 True。 |
|
> |
大于 - 返回x是否大于y |
(a > b) 返回 False。 |
|
< |
小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。注意，变量大写。 |
(a < b) 返回 True。 |
|
>= |
大于等于 - 返回x是否大于等于y。 |
(a >= b) 返回 False。 |
|
<= |
小于等于 - 返回x是否小于等于y。 |
(a <= b) 返回 True。 |
赋值运算符
以下假设变量a为10，变量b为20：
|
运算符 |
描述 |
实例 |
|
= |
简单的赋值运算符 |
c = a + b 将 a + b 的运算结果赋值为 c |
|
list.append(x) |
加法赋值运算符 |
c += a 等效于 c = c + a |
|
-= |
减法赋值运算符 |
c -= a 等效于 c = c - a |
|
*= |
乘法赋值运算符 |
c *= a 等效于 c = c * a |
|
/= |
除法赋值运算符 |
c /= a 等效于 c = c / a |
|
%= |
取模赋值运算符 |
c %= a 等效于 c = c % a |
|
**= |
幂赋值运算符 |
c **= a 等效于 c = c ** a |
|
//= |
取整除赋值运算符 |
c //= a 等效于 c = c // a |
|
:= |
海象运算符，可在表达式内部为变量赋值。Python3.8 版本新增运算符。 |
在这个示例中，赋值表达式可以避免调用 len() 两次: if (n := len(a)) > 10: print(f"List is too long ({n} elements, expected <= 10)") |
逻辑运算符not/and/or
优先级：()>not>and>or
以下假设变量 a 为 10, b为 20:
|
运算符 |
逻辑表达式 |
描述 |
实例 |
|
and |
x and y |
布尔"与" - 如果 x 为 False，x and y 返回 x 的值，否则返回 y 的计算值。 |
(a and b) 返回 20。 |
|
or |
x or y |
布尔"或" - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。 |
(a or b) 返回 10。 |
|
not |
not x |
布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。 |
not(a and b) 返回 False |
In/not in运算符
|
运算符 |
描述 |
实例 |
|
in |
如果在指定的序列中找到值返回 True，否则返回 False。 |
x 在 y 序列中 , 如果 x 在 y 序列中返回 True。 |
|
not in |
如果在指定的序列中没有找到值返回 True，否则返回 False。 |
x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。 |
Is/is not运算符
身份运算符用于比较两个对象的存储单元
|
运算符 |
描述 |
实例 |
|
is |
is 是判断两个标识符是不是引用自一个对象 |
x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False |
|
is not |
is not 是判断两个标识符是不是引用自不同对象 |
x is not y ， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。 |
注： id() 函数用于获取对象内存地址。
is 与 == 区别：
is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。
Python运算符优先级：https://www.runoob.com/python3/python3-basic-operators.html#ysf1
时间与日期转换
|
符号 |
含义 |
|
%y |
两位数的年份表示（00-99） |
|
%Y |
四位数的年份表示（000-9999） |
|
%m |
月份（01-12） |
|
%d |
月内中的一天（0-31） |
|
%H |
24小时制小时数（0-23） |
|
%I |
12小时制小时数（01-12） |
|
%M |
分钟数（00-59） |
|
%S |
秒（00-59） |
|
%a |
本地简化星期名称 |
|
%A |
本地完整星期名称 |
|
%b |
本地简化的月份名称 |
|
%B |
本地完整的月份名称 |
|
%c |
本地相应的日期表示和时间表示 |
|
%j |
年内的一天（001-366） |
|
%p |
本地A.M.或P.M.的等价符 |
|
%U |
一年中的星期数（00-53）星期天为星期的开始 |
|
%w |
星期（0-6），星期天为星期的开始 |
|
%W |
一年中的星期数（00-53）星期一为星期的开始 |
|
%x |
本地相应的日期表示 |
|
%X |
本地相应的时间表示 |
|
%Z |
当前时区的名称 |
|
%% |
%号本身 |
Time 模块包含了以下内置函数，既有时间处理的，也有转换时间格式的：
|
1 |
time.localtime([secs]) |
|
2 |
time.time( ) 返回当前时间的时间戳（1970纪元后经过的浮点秒数）。 |
|
3 |
time.strftime(fmt[,tupletime]) |
我们可以使用 time 模块的 strftime 方法来格式化日期，：
time.strftime(format[, t])
#!/usr/bin/python
import time
# 格式化成2021-01-15 14:11:37形式
print time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
控制流
D:\personal_file\python\code\ python编程快速上手.py 控制流章节
函数
更多见：D:\personal_file\python\code\ python编程快速上手.py 第3章：函数章节
语法
#!/usr/bin/python
def functionname( parameters ):
函数体
[return [expression]] #用def创建函数时，可以用return指定返回什么值
#如果函数没有return语句(或者只有return本身），其返回值为None
参数
以下是调用函数时可使用的正式参数类型：
- 必备参数
- 关键字参数
- 默认参数
- 不定长参数
必备参数：
#!/usr/bin/python
#可写函数说明
def printme(name):
print('hello '+name)
return
#调用printme函数
pyy= 'pengyuanyuan'
printme(pyy) #实际调用时一般传入的是内容或者任意变量名，不一定命名为name
关键字参数：
关键字参数顺序不重要(传递多个参数)：
#!/usr/bin/python
#可写函数说明
def printinfo(name,age):
print("Name:", name)
print("Age", age)
return
#调用printinfo函数
printinfo( age=50, name="miki" )
不定长参数
你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述2种参数不同，声明时不会命名。基本语法如下：
#!/usr/bin/python
def functionname([formal_args,] *var_args_tuple ):
"函数_文档字符串"
function_suite
return [expression]
加了星号（*）的变量名会存放所有未命名的变量参数。不定长参数实例如下：
#!/usr/bin/python
# 可写函数说明
def printinfo( arg1, *vartuple ):
"打印任何传入的参数"
print "输出: "
print arg1
for var in vartuple:
print var
return
# 调用printinfo 函数
printinfo( 10 )
printinfo( 70, 60, 50 )
导入模块
#导入整个模块
import module1[, module2[,... moduleN]]
#导入模块的部分函数
from modname import name1[, name2[, ... nameN]]
#导入一个模块中的所有项目
from modname import *
文件I/O
读取键盘输入
Python提供了两个内置函数从标准输入读入一行文本，默认的标准输入是键盘。如下：
- raw_input
- input
raw_input函数
raw_input([prompt]) 函数从标准输入读取一个行，并返回一个字符串（去掉结尾的换行符）：
str = raw_input("请输入：")
print "你输入的内容是: ", str
input函数
input([prompt]) 函数和 raw_input([prompt]) 函数基本类似，但是 input 可以接收一个Python表达式作为输入，并将运算结果返回。
这会产生如下的对应着输入的结果：
请输入：[x*5 for x in range(2,10,2)]
你输入的内容是: [10, 20, 30, 40]
open 函数
你必须先用Python内置的open()函数打开一个文件，创建一个file对象，相关的方法才可以调用它进行读写。完整的语法格式为：
file object =open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
参数说明:
- file: 必需，文件路径（相对或者绝对路径）。
- mode: 可选，文件打开模式
- buffering: 设置缓冲
- encoding: 一般使用utf8
- errors: 报错级别
- newline: 区分换行符
- closefd: 传入的file参数类型
- opener: 设置自定义开启器，开启器的返回值必须是一个打开的文件描述符。
mode：
File对象的属性
一个文件被打开后，你有一个file对象，你可以得到有关该文件的各种信息。
以下是和file对象相关的所有属性的列表：
|
属性 |
描述 |
|
file.closed |
返回true如果文件已被关闭，否则返回false。 |
|
file.mode |
返回被打开文件的访问模式。 |
|
file.name |
返回文件的名称。 |
|
file.softspace |
如果用print输出后，必须跟一个空格符，则返回false。否则返回true。 |
# 打开一个文件
fo = open("foo.txt", "w")
# 关闭打开的文件
fo.close()
一些函数
apply
DataFrame.apply(func, axis=0, broadcast=False, raw=False, reduce=None, args=(), **kwds)
1.该函数最有用的是第一个参数，这个参数是函数.
apply(func [, args [, kwargs ]]) 函数用于当函数参数已经存在于一个元组或字典中时，间接地调用函数。args是一个包含将要提供给函数的按位置传递的参数的元组。如果省略了args，任何参数都不会被传递，kwargs是一个包含关键字参数的字典。简单说apply()的返回值就是func()的返回值，apply()的元素参数是有序的，元素的顺序必须和func()形式参数的顺序一致，与map的区别是前者针对column，后者针对元素
lambda匿名函数
lambda是匿名函数，即不再使用def的形式，可以简化脚本，使结构不冗余何简洁。匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果。
通过对比可以看出，匿名函数lambda x: x * x实际上就是：
def f(x):
return x * x
用匿名函数有个好处，因为函数没有名字，不必担心函数名冲突。此外，匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数：
f = lambda x: x * x
f(5)
apply和lambda两者结合可以做很多事情，比如split在series里很多功能不可用，而index就可以做
transform()方法
transform() 里面不能跟自定义的特征交互函数，因为transform是针对每一元素（即每一列特征操作）进行计算，也就是说在使用 transform() 方法时，需要记得三点：
1、它只能对每一列进行计算，所以在groupby()之后，.transform()之前是要指定要操作的列，这点也与apply有很大的不同。
2、由于是只能对每一列计算，所以方法的通用性相比apply()就局限了很多，例如只能求列的最大/最小/均值/方差/分箱等操作
3、transform还有什么用呢?最简单的情况是试图将函数的结果分配回原始的dataframe。也就是说返回的shape是（len(df)，1）。注：如果与groupby()方法联合使用，需要对值进行去重
https://www.cnblogs.com/wkang/p/9794678.html
info()查看DataFrame数据信息
df.info()
isinstance()函数检查对象是某个类型
a=5
isinstance(a,int)
Out[2]: True
isinstance可以⽤类型元组，检查对象的类型是否在元组中：
a = 5; b = 4.5
isinstance(a, (int, float))
Out[24]: True
Python 异常处理
捕捉异常可以使用try/except语句。
try/except语句用来检测try语句块中的错误，从而让except语句捕获异常信息并处理。如果你不想在异常发生时结束你的程序，只需在try里捕获它。
Pandas库学习
安装和导入
1.安装pandas库：安装Anaconda安装会自带安装；
若未安装Anaconda，使用Python自带的包管理工具pip来安装：pip install pandas。
2.导入pandas库：
import numpy as np # pandas和numpy常常结合在一起使用，导入numpy库
import pandas as pd # 导入pandas库
print(pd.__version__) # 打印pandas版本信息
pandas数据类型pd.series、pd.dataframe
pandas包含两种数据类型：series和dataframe。
series是一种一维数据结构，每一个元素都带有一个索引，与一维数组的含义相似，其中索引可以为数字或字符串。series结构名称
dataframe是一种二维数据结构，数据以表格形式（与excel类似）存储，有对应的行和列。dataframe结构名称：
Pandas基础操作见：D:\personal_file\python\code\pandas_base.py
Pandas函数
import pandas as pd
pd. to_numeric():将参数转换为数字类型
pd.to_numeric(arg, errors='raise', downcast=None)
默认返回dtype为float64或int64， 具体取决于提供的数据。使用downcast参数获取其他dtype。
- arg ： 数据
- errors ： {'ignore'，'raise'，'coerce'}，默认为'raise'。如果为‘raise’，则无效的解析将引发异常。如果为 ‘coerce’，则将无效解析设置为NaN。如果为 ‘ignore’，则无效的解析将返回输入
- downcast ： {'integer'，'signed'，'unsigned'，'float'}，默认为None
import pandas as pd
df = pd.DataFrame({'区域' : ['西安', '太原', '西安', '太原', '郑州', '太原'],
'10月份销售' : ['0.477468', '0.195046', '0.015964', '0.259654', '0.856412', '0.259644'],
'9月份销售' : ['0.347705', '0.151220', '0.895599', '0236547', '0.569841', '0.254784']})
print(df.dtypes)
#将object对象转换成将数字类型
df['10月份销售']=pd.to_numeric(df['10月份销售'],errors='coerce')
df['9月份销售']=pd.to_numeric(df['9月份销售'],errors='coerce')
pd.date_range()创建时间序列
help(pd.date_range)
date_range(start=None, end=None, periods=None, freq=None, tz=None, normalize=False, name=None, closed=None, **kwargs)
start:开始时间
end:结束时间
periods：间隔，整数或None。如果你只使用了起始或结束的时间戳，那么就需要使用period来告知一个范围。
freq：日期偏移量，也就是频率,默认D表示1天。这个是一个非常重要的参数，可以通过设置这个参数得到自定义的时间频率，见图1
closed：closed=None包含开始和结束时间，若closed=‘left’表示取左开右闭的结果，若closed='right'左做闭右开的结果。
normalize：若参数为True表示将start、end参数值正则化到午夜时间戳。
图1：
示例：https://blog.csdn.net/kancy110/article/details/77131539
pd.date_range(start='2017-01-01', end='2017-01-04', closed='right')
pd.date_range(start='20170101',periods=10)
pd.date_range(start='20170101',end='20170110',freq='3D')
pd.date_range(start='2017-01-01 08:10:50',periods=10,freq='s',normalize=True
pd.Timestamp返回时间戳
pd.Timestamp('2013-01-02')
df.dropna()函数:去掉包含缺失值的行
df.fillna()函数:对缺失值进行填充
df.fillna(method="ffill",inplace=True)
inplace参数的取值：True、False
True：直接修改原对象
False：创建一个副本，修改副本，原对象不变（缺省默认）
method参数的取值 ： {‘pad’, ‘ffill’,‘backfill’, ‘bfill’, None}, default None
pad/ffill：用前一个非缺失值去填充该缺失值
backfill/bfill：用下一个非缺失值填充该缺失值
None：指定一个值去替换缺失值（缺省默认这种方式）
df.value_counts():统计数据出现的频率
value_counts(ascending=True, normalize=True)
value_counts()返回的结果是一个Series数组，可以跟别的数组进行计算。
1. Series 情况下：
pandas 的 value_counts() 函数可以对Series里面的每个值进行计数并且排序。
import pandas as pd
df = pd.DataFrame({'区域' : ['西安', '太原', '西安', '太原', '郑州', '太原'],
'10月份销售' : ['0.477468', '0.195046', '0.015964', '0.259654', '0.856412', '0.259644'],
'9月份销售' : ['0.347705', '0.151220', '0.895599', '0236547', '0.569841', '0.254784']})
print(df)
统计：
print(df['区域'].value_counts()) #统计每个区域出现多少次，默认从高到低排序
print(df['区域'].value_counts(ascending=True)) #每个区域出现多少次，升序排序
#每个区域出现次数占比
print(df['区域'].value_counts(normalize=True))
resample() 重采样
重新采样是指将时间序列从一个频率转换为另一个频率的过程，将更高频率的数据聚合到低频率被称为向下采样，而从低频率转换为高频率被称为向上采样，但是还有一种是同频之间的切换，比如W-WED(weekly on Wednesday 每周三)转换到W-FRI(每周五）
参数：
freq.resample(rule, how=None, axis=0, fill_method=None, closed=None, label=None, convention='start',
kind=None, loffset=None, limit=None, base=0, on=None, level=None)
https://zhuanlan.zhihu.com/p/70353374
zip() 函数
用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
函数语法：
zip([iterable, …]) ->iterabl – 一个或多个迭代器;
->返回元组列表
set_index( )设置索引列
1、函数体及主要参数解释：
- DataFrame.set_index(keys, drop=True, append=False, inplace=False, verify_integrity=False)
- 参数解释：
- keys：列标签或列标签/数组列表，需要设置为索引的列
- drop：默认为True，删除用作新索引的列
- append：是否将列附加到现有索引，默认为False。
- inplace：输入布尔值，表示当前操作是否对原数据生效，默认为False。
- verify_integrity：检查新索引的副本。否则，请将检查推迟到必要时进行。将其设置为false将提高该方法的性能，默认为false。
reset_index( ) 还原索引
1、函数体及主要参数解释：
DataFrame.reset_index(level=None, drop=False, inplace=False, col_level=0, col_fill='')
参数解释：
- level：数值类型可以为：int、str、tuple或list，默认无，仅从索引中删除给定级别。默认情况下移除所有级别。控制了具体要还原的那个等级的索引 。
- drop：当指定drop=False时，则索引列会被还原为普通列；否则，经设置后的新索引值被会丢弃。默认为False。
- inplace：输入布尔值，表示当前操作是否对原数据生效，默认为False。
- col_level：数值类型为int或str，默认值为0，如果列有多个级别，则确定将标签插入到哪个级别。默认情况下，它将插入到第一级。
- col_fill：对象，默认''，如果列有多个级别，则确定其他级别的命名方式。如果没有，则重复索引名。
注意~~~reset_index（）还原可分为两种类型，第一种是对原来的数据表进行reset；第二种是对使用过set_index()函数的数据表进行reset
https://zhuanlan.zhihu.com/p/110819220?from_voters_page=true
df.index.get_level_values() 复合索引指定搜索索引级数
pct_change()计算当前元素与先前元素之间的百分比变化
Pandas dataframe.pct_change()函数计算当前元素与先前元素之间的百分比变化。默认计算前一行的百分比变化，计算环比。
注意：此功能在时间序列数据中最有用。
用法： DataFrame.pct_change(periods=1, fill_method=’pad’, limit=None, freq=None, **kwargs)
参数：
periods:形成百分比变化所需的时间。periods=1，与前一行比较
fill_method:在计算百分比变化之前如何处理资产净值。
limit:停止前要填充的连续NA数
freq:时间序列API中使用的增量(例如“ M”或BDay())。
**kwargs:其他关键字参数将传递到DataFrame.shift或Series.shift中。
举例：
#增加一列，表示为每一年比上一年变化的百分比
year['yr_pct_change']=year['max'].pct_change(periods=1)
stack和unstack函数
stack()即“堆叠”，作用是将列转行
unstack()即stack()的反操作，将行转列
https://blog.csdn.net/qq_42874547/article/details/89056000
pandas中Series对象下的str方法汇总
pandas的str方法和原生python语法区别：多一个.str
对DataFrame的某一列进行操作，一般都会使用df[“xx”].str下的方法, xx这一列必须是字符串类型，在pandas里面是object
https://blog.csdn.net/weixin_43750377/article/details/107979607
1.one hot 独热编码,get_dummies
series=data['列名'].str.get_dummies(sep=',')
实现DataFrame中列有多值，且想把这列one hot下
2.切分字符串，split()
split(pat=None,n=-1,expand=False)
# 不指定分隔符pat，默认就是一个列表
# 指定n，表示分隔次数，默认是-1，全部分隔
# expand，默认是False，得到是一个列表，如果指定为True，会将列表打开，变成多列，变成DATAFrame
# 列名是按照0 1 2 3····的顺序，并且默认None值分隔后还是为None
举例：
series=data['列名'].str.split(',')
把DataFrame列中字符串以','分隔开，每个元素分开后存入一个列表里。
rsplit（和split用法一致，只不过默认是从右往左分隔）
3.替换，replace()
series=data['列名'].str.replace(',','-')
用‘-’代替‘，’
4.是否包含表达式，contains()
series=data['列名'].str.contains('we')
返回的是布尔值series
5.查找所有符合正则表达式的字符findall()
series=data['列名'].str.findall("[a-z]")
以数组的形式返回
6.计算字符串的长度，len()
series=data['列名'].str.len()
7.去除前后的空白字符，strip()
series=data['列名'].str.strip()
rstrip() 去除后面的空白字符
lstrip() 去除前面的空白字符
8.是否判断 is***
例如：df["attack"].str. isalnum();
isalnum() 是否全部是数字和字母组成
isalpha() 是否全部是字母
isdigit() 是否全部都是数字
isnumeric()是否全部都是数字
isspace() 是否空格
islower() 是否全部小写
isupper() 是否全部大写
istitle() 是否只有首字母为大写，其他字母为小写。
9. get（获取指定位置的字符，只能获取1个）
df["attack"].str.get(3)
# 获取指定索引的字符，只能传入int
10.slice_replace（从名字也能看出来，slice筛选出来之后替换）
df["attack"].str.slice_replace(1,3, "distance")
# 将slice为[1:3]的内容换成"distance"，既然替换，所以这里不支持步长。
11.join（将每个字符之间使用指定字符相连，相当于sep.join(list(value))）
df["ultimate"].str.join("a")
12.contains（判断字符串是否含有指定子串，返回的是bool类型）
df["country"].str.contains("国")
# 指定na=False，那么就会变成False了，也可以指定为其他的值，但是类型会变
df["country"].str.contains("国", na=False)
13.startswith（是否某个子串开头）
df["attack"].str.startswith("近")
14. endswith（判断是否以某个子串结尾）
df["attack"].str.endswith("离")
15.match（从头开始匹配的。返回布尔型，表示是否匹配给定的模式）
df["attack"].str.match(".{2}距") # 开头两个字符任意，第三个字符为"距"
16. replace（替换指定的字符）
# 将2011-11-23替换成23/11/2011这种格式
df["date"].str.replace("(\d+)-(\d+)-(\d+)",r"\3/\2/\1")
# 这里面的replace是支持正则的。
# 并且一般我们会加上r表示原生的，这是在正则中
# 对于pandas来说，第一个参数是不需要加的，如match。但是第二个参数是要加上r的
# 尤其是分组替换，但如果只是简单字符串替换就不需要了。
17. repeat（重复字符串）几次
df["date"].str.repeat(3)
18. pad（将每一个元素都用指定的字符填充，只能是一个字符）
# 表示最后字符串要占5个长度，用">"填充，默认填充在左边
df["name"].str.pad(5, fillchar=">")
## 指定side从哪边开始填充，left,right,both
df["name"].str.pad(5, fillchar="<", side="right")
19.zfill（填充，只能是0填充，从左边填充）
df["name"].str.zfill(10)
20. encode decode（字符串编码、解码）
df["attack"].str.encode("utf-8")#编码
df["attack"].str.encode("utf-8").str.decode("utf-8")#解码
21.strip（按照指定内容，从两边去除，和python字符串内置的strip一样）
df["attack"].str.strip("中远近离")
22. translate（指定部分替换）
trans = str.maketrans({"距": "ju", "离": "li"})#距替换成ju,离替换成li
print(df["attack"].str.translate(trans))
23.extract（分组捕获）
# 必须匹配指定pattern，否则为NaN
# 而且必须要有分组，否则报错，结果是一个DataFrame，每一个分组对应一列
df["date"].str.extract("\d{4}-(\d{2})-(\d{2})")
24. find（查找指定字符第一次出现的位置）
df["date"].str.find("-")# 找不到的话，返回-1
python把几个DataFrame合并成一个DataFrame
- concat：可以沿一条轴将多个对象连接到一起
- join：inner是交集，outer是并集。
- merge：可以根据一个或多个键将不同的DataFrame中的行连接起来。
merge行数不变列数增加,相当于左右内连接
merge 函数通过一个或多个键将数据集的行连接起来。默认以相同的列名进行内连接。
场景：针对同一个主键存在的两张包含不同特征的表，通过主键的链接，将两张表进行合并。合并之后，两张表的行数不增加，列数是两张表的列数之和。
pd.merge(left, right, how='inner', on=None, left_on=None, right_on=None,
left_index=False, right_index=False, sort=True,
suffixes=('_x', '_y'), copy=True, indicator=False)
- left：对象DataFrame1
- right：对象DataFrame2
|
参数 |
描述 |
|---|---|
|
how |
数据融合的方法，方式（inner、outer、left、right），默认’inner’ |
|
on |
用来对齐的列名，一定要保证左表和右表存在相同的列名。类似于sql的join key |
|
left_on |
左表对齐的列，可以是列名。也可以是DataFrame同长度的arrays |
|
right_on |
右表对齐的列，可以是列名。 |
|
left_index |
将左表的index用作连接键 |
|
right_index |
将右表的index用作连接键 |
|
suffixes |
左右对象中存在重名列，结果区分的方式，后缀名。 |
|
sort |
通过联接键按字典顺序对结果进行排序，默认值为True，设置为False在许多情况下将极大地提高性能 |
|
copy |
默认：True。将数据复制到数据结构中，设置为False提高性能。 |
1.result = pd.merge(left, right) #默认以相同的键进行内连接
1.result = pd.merge(left, right, on='key')
2.result = pd.merge(left, right, on=['key1', 'key2'])
3.result = pd.merge(left, right, how='left', on=['key1', 'key2'])
4.result = pd.merge(left, right, how='right', on=['key1', 'key2'])
示例：
df1 = pd.DataFrame({'key': ['one', 'two', 'three'],
'value': ['a', 'b', 'c'],
'data1': np.arange(3)})
df2 = pd.DataFrame({'key': ['one', 'two', 'three'],
'value': ['a', 'c', 'c'],
'data2': np.arange(3)})
df3 = pd.merge(df1, df2) # 默认以相同的键进行内连接
df4 = pd.merge(df1, df2, how='left') # 左连接，默认以相同名的键进行
df5 = pd.merge(df1, df2, on=['key', 'value'], how='outer')
print(df5)
append:将一行连接到一个DataFrame 上
append只有按行合并，相当于concat按行合并的简写形式
语法：dataframe.append(other, ignore_index)
示例1：
df1 = pd.DataFrame({'A': ['A0', 'A1', 'A1'],
'B': ['B0', 'B1', 'B2']},
index=['K0', 'K1', 'K2'])
s2 = pd.Series(['X0','X1'], index=['A','B'])
result = df1.append(s2, ignore_index= True)
print(result)
s2先行转列，再按列合并到df1
join
join方法将两个DataFrame中不同的列索引合并成为一个DataFrame
参数的意义与merge基本相同，只是join方法默认左外连接how=left
left.join(right, on=key_or_keys)
result = left.join(right, on='key') #左连接
result = left.join(right, on=['key1', 'key2'], how='inner')
示例：
df1 = pd.DataFrame({'A': ['A0', 'A1', 'A1'],
'B': ['B0', 'B1', 'B2']},
index=['K0', 'K1', 'K2'])
df2 = pd.DataFrame({'C': ['C1', 'C2', 'C3'],
'D': ['D0', 'D1', 'D2']},
index=['K0', 'K1', 'K3'])
df3 = df1.join(df2) # 默认左连接
df5 = df1.join(df2, how='inner')
concat
指定按某个轴进行连接（axis=0/1），也可以指定join方法。
pd.concat(objs, axis=0, join='outer', join_axes=None, ignore_index=False,
keys=None, levels=None, names=None, verify_integrity=False,
copy=True)
说明：
|
属性 |
描述 |
|
objs |
合并的对象集合。可以是Series、DataFrame |
|
axis |
合并方法。默认0纵向按行合并，1横向按列合并 |
|
join |
默认outer并集，inner交集。只有这两种 |
|
join_axes |
按哪些对象的索引保存. 有的版本不存在此参数 |
|
ignore_index |
默认Fasle忽略。是否忽略原index |
|
keys |
为原始DataFrame添加一个键，默认无 |
示例1：
s1 = pd.Series(['a', 'b'])
s2 = pd.Series(['c', 'd'])
pd.concat([s1, s2])
pd.concat([s1, s2], ignore_index=True) # 忽略原index
Pandas透视表（pivot_table）
pd.pivot_table(data, values=None, index=None, columns=None, aggfunc='mean', fill_value=None, margins=False, dropna=True, margins_name='All')
- index：相当于sql里的group by后面的列,用于分组的列,相当于行索引
- values：相当于sql里的聚合函数操作的列,放在聚合函数里的列。默认聚合是求平均
- aggfunc：相当于sql里的聚合函数,如果不指明,默认求平均.可以接受列表,即对values作不同的聚合,也可以接受字典,即对不同的values作不同的操作,也可以将字典里的值改为列表形式的,即对某列作几种不同的操作.切记,对于aggfunc,操作的是values后面的值,而不是columns后面的值.
- columns:相当于列索引,就是更细化地展示一些内容.
- fill_value:用于填充NAN
- margins:不是简单地求和，而是与 aggfunc 的规则相同,为True时会添加行/列的总计
https://zhuanlan.zhihu.com/p/127811410
groupby分组
根据表本身的某一列或多列内容进行分组聚合
one =df.groupby('letter').sum()
letterone =df.groupby(['letter','one']).sum()
你可能不想把用来分组的列名字作为索引，像下面的做法很容易实现。
letterone =df.groupby(['letter','one'],as_index=False).sum()
groupby首先要指定分组原则，这也是groupby函数的第一步，其常用参数包括：
- by，分组字段，可以是单（多）列/series/字典/函数，常用为列名
- axis，指定按哪个轴进行分组，默认为0，表示沿着行分组
- as_index，是否将分组列名作为索引，默认为True
- sort，指定是否对输出结果按索引排序
pandas的groupby遵从split、apply、combine模式
NumPy 参考手册
numPy是使用Python进行科学计算的基础软件包。除其他外，它包括：
- 功能强大的N维数组对象。
- 精密广播功能函数。
- 集成 C/C+和Fortran 代码的工具。
- 强大的线性代数、傅立叶变换和随机数功能。
https://www.numpy.org.cn/reference/
numpy里random总结
1) np.random.rand()
numpy.random.rand(d0,d1,…,dn)：返回[0,1)之间的数，包含0不包含1，rand()返回一个数字，rand(1)返回一个一维的一个数字数组，rand(2)返回一个一维的2个数字数组，以此类推。rand(3,4)返回3行4列的二维array数组。 比如
np.random.rand(2)
np.random.rand(2,1)
2）np.random.randn()
numpy.random.randn(d0,d1,…,dn)：用法同np.random.rand()一样，只是服从正态分布。用法同上。标准正态分布又称为u分布，是以0为均值、以1为标准差的正态分布，记为N（0，1）。
3）np.random.randint()
numpy.random.randint(low, high=None, size=None, dtype=’l’)
参数：low为最小值，high为最大值，size为数组维度大小，dtype为数据类型，默认的数据类型是np.int。
返回随机整数，范围区间为[low,high），包含low，不包含high。high没有填写时，默认生成随机数的范围是[0，low)
y1 = np.random.randint(1,size=4)
print(y1) #所有输出为：[0 0 0 0]
y2 = np.random.randint(-2,3,size=(2,3))
4）np.random.random(size=None)
通过size参数来指定维数，生成[0,1)之间的浮点数
z1 = np.random.random()
print(z1) #输出：0.5496674667621851
z2 = np.random.random(1)
print(z2) #输出：[0.03831152]
z3 = np.random.random(2) 等价于 np.random.random(size=(1,2))
print(z3) #输出：[0.67638162 0.72296213]
z4 = np.random.random((2,3)) 或者z4 = np.random.random(size=(2,3))
print(z4)
5) numpy.random.RandomState()
可以通过numpy工具包生成模拟数据集，使用RandomState获得随机数生成器
from numpy.random import RandomState
rdm = RandomState(1)
注意：这里1为随机数种子，只要随机数种子seed相同，产生的随机数系列就相同
a = rdm.uniform(1,2,(3,4))
print(a)
np.cumsum()
dates=pd.date_range('20130101',periods=6)
df=pd.DataFrame(np.random.randn(6,4),index=dates,columns=list('ABCD'))
df.cumsum()#按列逐行累加，返回arrary
ndim、shape、dtype、astype的用法
1. ndim返回的是数组的维度，返回的只有一个数，该数即表示数组的维度。
arr=np.array[1,2,3]
arr.ndim
2. shape：表示各位维度大小的元组，返回的是一个元组。
arr.shape
3. dtype：一个用于说明数组数据类型的对象。返回的是该数组的数据类型。
arr.dtype
4. astype：转换的数据类型
arr.astype(int)
绘图包matplotlib.plot()
|
参数 |
说明 |
|---|---|
|
label |
用于图例的标签 |
|
ax |
要在其上进行绘制的matplotlib subplot对象。如果没有设置，则使用当前matplotlib subplot |
|
style |
将要传给matplotlib的风格字符串(for example: ‘ko–’) |
|
alpha |
图表的填充不透明(0-1) |
|
kind |
可以是’line’, ‘bar’, ‘barh’, ‘kde’,point,scatter |
|
logy |
在Y轴上使用对数标尺 |
|
use_index |
将对象的索引用作刻度标签 |
|
rot |
旋转刻度标签(0-360) |
|
xticks |
用作X轴刻度的值 |
|
yticks |
用作Y轴刻度的值 |
|
xlim |
X轴的界限 |
|
ylim |
Y轴的界限 |
|
grid |
显示轴网格线 |
kind参数说明——'line', 'bar', 'barh', 'kde':
- 直方图：是一种可以对值频率离散化显示的柱状图。通过调用Series.hist()方法即可创建。
- 密度图：与直方图相关的一种类型图，是通过计算“可能会产生观测数据的连续概率分布的估计”而产生的，通过给plot传入参数kind = 'kde' 即可。
- 散布图：是观测两个一维数据序列之间关系的有效手段，使用pd.scatter_matrix()即可建立。
遇到报错
SyntaxError: (unicode error) 'unicodeescape' codec can't decode bytes in position
解决：
方法1:双斜杠代替单斜杠
pd.read_csv('C:\\Users\\18308\\Desktop\\test.csv')
方法2:前边加个字母r
pd.read_csv(r'C:\\Users\\18308\\Desktop\\test.csv')
方法3:使用Linux的路径/
pd.read_csv('C:/Users/18308/Desktop/test.csv')
标签：返回,None,pd,Python,列表,print,str,整理,自学 From： https://www.cnblogs.com/lizixi/p/17487176.html