python使用手册
Python
简介
Python是纯粹的自由软件， 源代码和解释器CPython遵循 GPL （GNU General Public License)协议。Python语法简洁清晰，特色之一是强制用空白符(white space)作为语句缩进。
Python具有丰富和强大的库。它常被昵称为胶水语言，能够把用其他语言制作的各种模块（尤其是C/C++）很轻松地联结在一起。常见的一种应用情形是，使用Python快速生成程序的原型（有时甚至是程序的最终界面），然后对其中有特别要求的部分，用更合适的语言改写，比如3D游戏中的图形渲染模块，性能要求特别高，就可以用C/C++重写，而后封装为Python可以调用的扩展类库。需要注意的是在您使用扩展类库时可能需要考虑平台问题，某些可能不提供跨平台的实现。
7月20日，IEEE发布2017年编程语言排行榜：Python高居首位 2() 。
2018年3月，该语言作者在邮件列表上宣布 Python 2.7将于2020年1月1日终止支持。用户如果想要在这个日期之后继续得到与Python 2.7有关的支持，则需要付费给商业供应商。
目录
区分
运算符优先级
引号使用
数字类型转换
数学函数
随机函数
三角函数
字符串
列表
元组
字典
集合
条件控制语句
自定义函数
类
模块
文件
目录
异常处理
属性
数组维度变换
数组的类型转换
数组的索引和切片
随机数函数
统计函数
画图
导入
导出
创建对象
查看/检查数据
数据选取
数据清洗
区分
| 名称 | 结构 |
|---|---|
| 列表 | ['physics', 'chemistry', 1997, 2000] |
| 元组 | ('physics', 'chemistry', 1997, 2000) |
| 字典 | {'a': 1, 'b': 2, 'b': '3'} |
运算符优先级
| 运算符 | 描述 |
|---|---|
| ** | 指数 (最高优先级) |
| ~ + - | 按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@) |
| * / % // | 乘，除，取模和取整除 |
| + - | 加法减法 |
| >> << | 右移，左移运算符 |
| & | 位 'AND' |
| ^ | | 位运算符 |
| <= < > >= | 比较运算符 |
| <> == != | 等于运算符 |
| = %= /= //= -= += *= **= | 赋值运算符 |
| is is not | 身份运算符 |
| in not in | 成员运算符 |
| not or and | 逻辑运算符 |
引号使用
单引，双引 ：保留原样
三引号： 多行字符串
数字类型转换
int(x) 转为整数
float(x)转为浮点
complex(x)转为复数 实数为x ,虚数为0
complex(x,y)转为复数 实数为x ,虚数为y
>>>complex(x,y) (3+5j)
数学函数
abs()
返回绝对值数值
>>>abs(-2) 2
ceil()
上入整
>>>math.ceil(2.2) 3
floor()
下入整
>>>math.floor(2.6) 2
log()
对数，e为底
import math >>>math.log(100,10) 2.0
max(val,val,val)
字符串中找出ASCII码中最大的
>>>max("happy")
'y'
mix(val,val,val)
最小数
>>>min([2,5,77,1,3,51]) 1
round(float,[n])
四舍五入保留n位小数
>>>round(3.1415926,2) 3.14
sqrt(val)
返回平方根，val不能为负数
>>>math.sqrt(81) 9.0
随机函数
choice(seq)
import random #只能有序序列 random.choice(range(10))
randrange([start,] stop[,step])
random.randrange(100) #开始，结束，步长 random.randrange(0,100,2)
random()
#生成0-1之间的实数 random.random()
seed([])
random.seed(123)
shuffle()
#随机排序 lst=[1,2,3,4,5] random.shuffle(lst)
uniform(x,y)
#生成实数 random.uniform(1,100)
三角函数
sin(x)
x弧度的正弦值 #30°正弦值 import math math.sin(math.pi/6)
cos(x)
x弧度的余弦值 #90°余弦值 import math math.sin(math.pi/2)
tan(x)
x弧度的正切值 #45°正切值 import math math.tan(math.pi/4)
asin(x)
x的反正弦弧度值 #0.5反正弦弧度值 import math math.asin(0.5)
acos(x)
x的反余弦弧度值
atan(x)
x的反正切弧度值
hypot(x,y)
欧几里德范数 import math #勾三股四玄五 math.hypot(3,4)
degrees(x)
将弧度转换为角度
radians(x)
将角度转换为弧度
字符串
截取
var1 = "Python Runoob" print(var1[1:5])
转义字符
| 转义字符 | 描述 |
|---|---|
| \ (在行尾时) | 续行符 |
| \ \ | 反斜杠符号 |
| \' | 单引号 |
| \" | 双引号 |
| \a | 响铃 |
| \b | 退格(Backspace) |
| \e | 转义 |
| \000 | 空 |
| \n | 换行 |
| \v | 纵向制表符 |
| \t | 横向制表符 |
| \r | 回车 |
| \f | 换页 |
| \oyy | 八进制数，yy代表的字符，例如：\o12代表换行 |
| \xyy | 十六进制数，yy代表的字符，例如：\x0a代表换行 |
| \other | 其它的字符以普通格式输出 |
逻辑运算符
| 运算符 | 表达式 | 描述 | 实例 |
|---|---|---|---|
| and | x and y | 与：x 为 0或 false 返回 x 反之 y | 8 and 9 返回 9 |
| or | x or y | 或：x 为 0或 false 返回 y 反之 x | 8 and 9 返回 8 |
| not | not x | 非：x 为 0或 false 返回 True 反之 False | not 0 返回 True |
成员运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| in | 在内 如果找到值 返回 True 否则返回 false | "a" in "abc" 返回True |
| not in | 不在内 如果找到值 返回Ture 否则false | 1 not in [2,3] 返回True |
身份运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| is | 引用一个对象 返回 True 否则返回 false | "a" is"a" 返回True |
| is not | 不是引用一个对象 返回Ture 否则false | 1 not in 2 返回True |
函数
format()
#按位填充
"a{}cd{}f1{}345{}7".format("b","e",2,6)
isalnum()
#判断至少有一个数字 "Python Runoob".isalnum() >>>False
isalpha()
#判断至少有一个字符串 "Python Runoob".isalpha() >>>True
isdigit()
#判断全是数字 "123".isdigit() >>>True
lower()
#大转小 "SKHGJSDOHG".lower() >>>skhgjsdohg
upper()
#小转大 "skhgjsdohg".upper() >>>SKHGJSDOHG
max(str)
#最大的字母
max("ABCDEFG")
>>>G
min(str)
#最小的字母
max("ABCDEFG")
>>>A
count(str,beg,end)
#返回出现次数 beg开始位，end结束位
"skhgjsdohg".count("s",0,3)
>>>1
"skhgjsdohg".count("s",0,6)
>>>2
find
#返回索引值 否则返回-1 beg开始位，end结束位
"skhgjsdohg".find("h",0,3)
>>>2
join(seq)
#选择字符串作为分隔符 "%".join(["a","b","c","d"]) >>>'a%b%c%d'
len(str)
#字符串长度
len("skhgjsdohg")
>>>10
replace()
#替换字符串
"skhgjsdohg".replace("s","S")
>>>'SkhgjSdohg'
split(str,num,count)
#根据字符串截取数组
"skh gjsd ohg".split(" ")
>>>['skh', 'gjsd', 'ohg']
strip([chars])
#删除首尾空格，或chars指定首尾字符
" skh gjsd ohg ".strip(" ")
>>>'skh gjsd ohg'
"skh gjsd ohg".strip("s")
>>>'kh gjsd ohg'
| 方法 | 描述 |
|---|---|
| string.capitalize() | 把字符串的第一个字符大写 |
| string.center(width) | 返回一个原字符串居中,并使用空格填充至长度 width 的新字符串 |
| string.count(str, beg=0, end=len(string)) | 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数 |
| string.decode(encoding='UTF-8', errors='strict') | 以 encoding 指定的编码格式解码 string，如果出错默认报一个 ValueError 的 异 常 ， 除非 errors 指 定 的 是 'ignore' 或 者'replace' |
| string.encode(encoding='UTF-8', errors='strict') | 以 encoding 指定的编码格式编码 string，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace' |
| string.endswith(obj, beg=0, end=len(string)) | 检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False. |
| string.expandtabs(tabsize=8) | 把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8。 |
| string.find(str, beg=0, end=len(string)) | 检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1 |
| string.format() | 格式化字符串 |
| string.index(str, beg=0, end=len(string)) | 跟find()方法一样，只不过如果str不在 string中会报一个异常. |
| string.isalnum() | 如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False |
| string.isalpha() | 如果 string 至少有一个字符并且所有字符都是字母则返回 True,否则返回 False |
| string.isdecimal() | 如果 string 只包含十进制数字则返回 True 否则返回 False. |
| string.isdigit() | 如果 string 只包含数字则返回 True 否则返回 False. |
| string.islower() | 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False |
| string.isnumeric() | 如果 string 中只包含数字字符，则返回 True，否则返回 False |
| string.isspace() | 如果 string 中只包含空格，则返回 True，否则返回 False. |
| string.istitle() | 如果 string 是标题化的(见 title())则返回 True，否则返回 False |
| string.isupper() | 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False |
| string.join(seq) | 以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串 |
| string.ljust(width) | 返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串 |
| string.lower() | 转换 string 中所有大写字符为小写. |
| string.lstrip() | 截掉 string 左边的空格 |
| string.maketrans(intab, outtab]) | maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。 |
| max(str) | 返回字符串 str 中最大的字母。 |
| min(str) | 返回字符串 str 中最小的字母。 |
| string.partition(str) | 有点像 find()和 split()的结合体,从 str 出现的第一个位置起,把 字 符 串 string 分 成 一 个 3 元 素 的 元 组 (string_pre_str,str,string_post_str),如果 string 中不包含str 则 string_pre_str == string. |
| string.replace(str1, str2, num=string.count(str1)) | 把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次. |
| string.rfind(str, beg=0,end=len(string) ) | 类似于 find()函数，不过是从右边开始查找. |
| string.rindex( str, beg=0,end=len(string)) | 类似于 index()，不过是从右边开始. |
| string.rjust(width) | 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串 |
| string.rpartition(str) | 类似于 partition()函数,不过是从右边开始查找. |
| string.rstrip() | 删除 string 字符串末尾的空格. |
| string.split(str="", num=string.count(str)) | 以 str 为分隔符切片 string，如果 num有指定值，则仅分隔 num 个子字符串 |
| [string.splitlines(keepends]) | 按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。 |
| string.startswith(obj, beg=0,end=len(string)) | 检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查. |
| string.strip([obj]) | 在 string 上执行 lstrip()和 rstrip() |
| string.swapcase() | 翻转 string 中的大小写 |
| string.title() | 返回"标题化"的 string,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle()) |
| string.translate(str, del="") | 根据 str 给出的表(包含 256 个字符)转换 string 的字符,要过滤掉的字符放到 del 参数中 |
| string.upper() | 转换 string 中的小写字母为大写 |
| string.zfill(width) | 返回长度为 width 的字符串，原字符串 string 右对齐，前面填充0 |
| string.isdecimal() | isdecimal()方法检查字符串是否只包含十进制字符。这种方法只存在于unicode对象。 |
列表
len(obj)
#列表值个数 len([1,2,3]) >>>3
max(obj)
#最大值 max([1,2,3]) >>>3
min(obj)
#最小值 min([1,2,3]) >>>1
list()
#元组转换为列表
list((1,2,3))
>>>[1,2,3]
list("abc")
>>>['a','b','c']
append(obj)
#追加列表元素 lst = [1,2,3] lst.append(4) lst >>>[1, 2, 3, 4] ----------------------------------- lst = [1,2,3] lst.append([4,5]) lst >>>[1, 2, 3, [4, 5]]
count(obj)
#元素在列表中出现的次数 lst = [1,2,3,1] lst.count(1) >>>2
extend(seq)
#追加列表 olst = [1,2,3] nlst = [4,5] olst.extend(nlst) olst >>>[1, 2, 3, 4, 5]
index(obj)
#元素在列表中第一次出现的位置 lst = [1,2,3,1] lst.index(1) >>>0
insert(index,obj)
#列表中插入元素 lst = [1,2,3] lst.insert(1,1.5) lst >>>[1, 1.5, 2, 3]
pop(obj=list[-1])
#列表中移除一个指定元素，默认值是最后一个 lst = [1,2,3,4,5,6] lst.pop(0) lst >>>[2, 3, 4, 5, 6]
remove(obj)
#移除某个元素第一次出现的位置 lst = [1,1,2,3,4,5,6] lst.remove(1) lst >>>[1, 2, 3, 4, 5, 6]
reverse()
#翻转 lst = [1,1,2,3,4,5,6] lst.reverse() lst >>>[6, 5, 4, 3, 2, 1, 1]
sort([func])
#升序 lst = [3,6,2,9,6,7,0,9] lst.sort() lst >>>[0, 2, 3, 6, 6, 7, 9, 9] -------------------------------------- #降序 lst = [3,6,2,9,6,7,0,9] lst.sort(reverse=True) lst >>>[9, 9, 7, 6, 6, 3, 2, 0]
clear()
#清空列表 lst = [3,6,2,9,6,7,0,9] lst.clear() lst >>>[]
copy()
#勤拷贝，地址不同，不修改原列表值 olst = [3,6,2,9,6,7,0,9] nlst = olist.copy()
增删改查
#查
list1 = ['physics', 'chemistry', 1997, 2000]
list2 = [1, 2, 3, 4, 5, 6, 7 ]
-----------------------------------------------
print "list1[0]: ", list1[0]
print "list2[1:5]: ", list2[1:5]
#增
list = [] ## 空列表
list.append('Google') ## 使用 append() 添加元素
list.append('Runoob')
-------------------------------------------------
print list
['Google', 'Runoob']
#删
list1 = ['physics', 'chemistry', 1997, 2000]
-------------------------------------------------
print list1
del list1[2]
print "After deleting value at index 2 : "
print list1
元组
字典
add
staff = {'name':'bob','age':25}
staff['sex'] = 'm'
staff
>>>{'age': 25, 'name': 'bob', 'sex': 'm'}
del
staff = {'name':'bob','age':25}
del staff['age']
staff
>>>{'name': 'bob'}
update
staff = {'name':'bob','age':25}
staff['age']=1
staff
>>>{'age': 1, 'name': 'bob'}
select
staff = {'name':'bob','age':25}
staff['age']
>>>25
clear
staff = {'name':'bob','age':25}
staff.clear()
staff
>>>{}
delete
staff = {'name':'bob','age':25}
del staff
json
#转换成json和字符串
import json
staff = {'name':'bob','age':25}
json.dumps(staff)
>>>'{"name": "bob", "age": 25}'
-----------------------------------------
json.loads(staff)
>>>{'age': 25, 'name': 'bob'}
dict.copy()
#潜复制
staff = {'name':'bob','age':25}
staff.copy()
staffcopy = staff.copy()
id(staff),id(staffcopy)
>>>(92578008, 92506656)
dict.fromkeys(seq,val)
#创建字典，以seq元素作为键名，val作为键值 dict.fromkeys(range(10),1)
dict.get()
#键名寻找键值，不存在返回default值
staff = {'name':'bob','age':25}
staff.get("sex","none")
>>>'none'
dict.items()
#返回可遍历的元组数组
staff = {'name':'bob','age':25}
for k,v in staff.items():
print(k,v)
>>>name bob
age 25
key in dict
#找键名返回True，不存在返回False
staff = {'name':'bob','age':25}
"sex"in staff
>>>False
dict.keys()
#返回所有键名
staff = {'name':'bob','age':25}
staff.keys()
>>>dict_keys(['name', 'age'])
dict.values()
#返回所有键值
staff = {'name':'bob','age':25}
staff.values()
>>>dict_values(['bob', 25])
dict.setdefault(key,default)
#新增键，存在则不新增
staff = {'name':'bob','age':25}
staff.setdefault('name':'bob',"sex","m")
staff
>>>{'age': 25, 'name': 'bob', 'sex': 'm'}
dict.update(dict2)
#更新nstaff更新到ostaff
ostaff = {'name':'bob','age':25}
nstaff = {'name':'bob','sex':'m'}
ostaff.update(nstaff)
ostaff
>>>{'age': 25, 'name': 'bob', 'sex': 'm'}
dict.pop(key,default)
#删除键名所指的键值对,无此键名则返回default设定的值
staff = {'name':'bob','age':25}
staff.pop("age","")
>>>25
dict.popitem()
#随机删除
staff = {'name':'bob','age':25}
staff.popitem()
>>>('age', 25)
集合
集合运算
set1 = set("abcxyzcba")
set2 = set("idea")
| 符号 | 描述 | 过程 | 结果 |
|---|---|---|---|
| - | 差集 | set1-set2 | {'b', 'c', 'x', 'y', 'z'} |
| | | 并集 | set1|set2 | {'a', 'b', 'c', 'd', 'e', 'i', 'x', 'y', 'z'} |
| & | 交集 | set1&set2 | {'a'} |
| ^ | 去同集（去掉相同） | set1^set2 | {'b', 'c', 'd', 'e', 'i', 'x', 'y', 'z'} |
条件控制语句
if...elif...else
if 条件: do elif 条件: do else: do
while
cai = int(input("1-100"))
key = 20
while cai != key:
if cai > key:
print("大了")
else:
print("小了")
cai = int(input("1-100"))
print("中了")
for
a = ['a','b','c']
for e in a:
print(e)
>>> a
b
c
break
a = ['a','b','c']
for e in a:
if e == "b":
print(e)
break
print("no")
>>> no
b
continue
a = [1,2,3,4]
for e in a:
if e >= 3:
continue
print(e)
>>> 1
2
| 符号 | 描述 |
|---|---|
| < | 小于 |
| <= | 小于等于 |
| > | 大于 |
| >= | 大于等于 |
| == | 恒等 |
| != | 不等 |
| in | 属于 |
| not in | 不属于 |
自定义函数
def
def 函数名(参数)
语句
例：
def afunc(sex):
if sex == 0:
return("man")
else:
return("woman")
afunc(1)
def 函数名(*参数) 语句 例： def average(*args): s = 0 for i in args s += i return s/len(args) average(1,2,3,4,5)
lambda
常规： def fun(x,y): return x*y fun(1,2) lambda: fun = lambda x,y:x*y fun(1,2)
全局变量
name = "a" #全局变量 def changeName(): global name #加上global则修改name name = "b" changeName() name
类
Class
class Human:
age = 1
def language(self):
return "CH"
H = Human()
print("Human的age:",H.age,"Human的language:",H.language())
Construction Class
extend
class 子类(父类)
private
class Human: __age = 0 Human.__age >>>AttributeError: type object 'Human' has no attribute '__age'
模块
import module #导入某个模块 from module import function #导入模块中某个函数 from module inport func1,func2 #导入模块中多个函数 from module import * #导入模块中所有函数
文件
file object = open(file_name[,access_mode][,buffering])
| 模式 | 描述 |
|---|---|
| r | 只读/指针开头/默认 |
| rb | 二进制只读/指针开头/默认/非文本 |
| r+ | 读写/指针开头 |
| rb+ | 二进制/读写/指针开头/非文本 |
| w | 写入/覆盖/建新 |
| wb | 二进制/写入/覆盖/创建非文本 |
| w+ | 读写/覆盖/创建 |
| wb+ | 二进制/读写/覆盖/创建/非文本 |
| a | 追加/指针结尾/创建 |
| ab | 二进制/追加/指针结尾/创建 |
| a+ | 读写/指针结尾/追加/创建 |
| ab+ | 二进制/追加/指针/结尾/创建 |
open()
fo = open("D:/foo.txt","wb")
print(fo.name,fo.closed,fo.mode)
close()
fo = open("D:/foo.txt","wb")
fo.close()
with open("D:/foo.txt","wb") as fo:
fo.write(b"hello")
write()
with open("D:/foo.txt","w") as fo:
fo.write("www.baidu.com!\naaa!\n")
read()
#读取到
with open("D:/foo.txt","r+") as fo:
str = fo.read(10)
print(str)
>>>www.baidu.
tell()
#获取当前文件位置
with open("D:/foo.txt","w") as fo:
fo.write("www.baidu.com!\naaa!\n")
line = fo.read()
print "读取的数据为: %s" % (line)
# 获取当前文件位置
pos = fo.tell()
print "当前位置: %d" % (pos)
fo.close()
seek()
#调整指针位置
#seek(offset[, whence])
#offset -- 开始的偏移量，也就是代表需要移动偏移的字节数
#whence：可选，默认值为 0。给offset参数一个定义，表示要从哪个位置开始偏移；0代表从文件开头开始算起，1代表从当前位置开始算起，2代表从文件末尾算起。
# 重新设置文件读取指针到开头
with open("D:/foo.txt","w") as fo:
fo.write("www.baidu.com!\naaa!\n")
line = fo.read()
print "读取的数据为: %s" % (line)
fo.seek(0, 0)
line = fo.read()
print "读取的数据为: %s" % (line)
fo.close()
rename()
import os
os.rename("D:/foo.txt","D:/too.txt")
remove()
import os
os.remove("D:/too.txt")
目录
mkdir()
import os
os.mkdir("D:/too")
rmdir()
#内含文件不能删
import os
os.rmdir("D:/too")
walk()
#遍历文件夹和文件
import os
os.walk("D:/too")
#删除文件夹下的所有文件夹和文件
for i in os.walk("D:/too"):
for fname in i[2]:
full_name = os.path.join(i[0],fname)
os.remove(full_name)
for dirc in i[1]:
full_dir = os.path.join(i[0],dirc)
remove_dir(full_dir)
os.rmdir("D:/too")
getcwd()
os.getcwd()
异常处理
示例
numpy
属性
a.ndim
#维度 import numpy as np
a.shape
#各维度尺度
a.size
#元素的个数
a.dtype
#元素的类型
a.itemsize
#元素大小
np.arange(n)
#从0到n-1的ndarray类型 import numpy as np a = np.arange(10) a >>>array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
np.ones(shape)
#生成1的数组
import numpy as np
np.ones((3,4))
>>>array([[1., 1., 1., 1.],
[1., 1., 1., 1.],
[1., 1., 1., 1.]])
np.zeros((shape),dtype=np.int32)
#生成int32型的0
import numpy as np
np.zeros((3,4),dtype=np.int32)
>>>array([[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0]])
np.full(shape,val)
#生成val
import numpy as np
np.full((2,3),6)
>>>array([[6, 6, 6],
[6, 6, 6]])
np.eye(n)
#生成单位矩阵
import numpy as np
np.eye(5)
>>>array([[1., 0., 0., 0., 0.],
[0., 1., 0., 0., 0.],
[0., 0., 1., 0., 0.],
[0., 0., 0., 1., 0.],
[0., 0., 0., 0., 1.]])
np.ones_like(arr)
#按照数组形状生成1的数组
import numpy as np
a = np.eye(5)
np.ones_like(a)
>>>array([[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.]])
np.zeros_like(arr)
#按照数组形状生成0的数组
import numpy as np
a = np.eye(5)
np.zeros_like(a)
>>>array([[0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0.]])
np.full_like(arr,val)
#按照数组形状生成定值的数组
import numpy as np
a = np.eye(5)
np.full_like(a,6)
>>>array([[6., 6., 6., 6., 6.],
[6., 6., 6., 6., 6.],
[6., 6., 6., 6., 6.],
[6., 6., 6., 6., 6.],
[6., 6., 6., 6., 6.]])
np.linspace(start,end,isometry)
#范围内等距生成数组 import numpy as np np.linspace(1,9,3) >>>array([1., 5., 9.])
数组维度变换
a.reshape(shape)
#生成行列
import numpy as np
a=np.arange(27)
a.reshape(3,9)
>>>array([[ 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]])
a.resize(shape)
a.swpaxes(ax1,ax2)
#轴交换
import numpy as np
a=np.arange(27).reshape(3,9)
a.swapaxes(0,1)
>>>array([[ 0, 9, 18],
[ 1, 10, 19],
[ 2, 11, 20],
[ 3, 12, 21],
[ 4, 13, 22],
[ 5, 14, 23],
[ 6, 15, 24],
[ 7, 16, 25],
[ 8, 17, 26]])
a.flatten()
#数组压扁 import numpy as np a=np.arange(24).reshape((2,3,4)) a.flatten() >>>array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,17, 18, 19, 20, 21, 22, 23])
数组的类型转换
a.astype(new_type)
import numpy as np a=np.arange(24).reshape((2,3,4)) a.astype(float)
a.tolist()
import numpy as np a=np.arange(24).reshape((2,3,4)) a.tolist()
数组的索引和切片
一维数组切片
#arr[起始:结束(不含):步长] import numpy as np a = np.arange(10) a[1:4:2]
多维数组索引和切片
#索引 #arr[起始:结束(不含):步长] import numpy as np a=np.arange(24).reshape((2,3,4)) a[1,2,3] >>>23
#切片
#arr[起始:结束:步长]
import numpy as np
a=np.arange(24).reshape((2,3,4))
a[:,:,::2]
>>>array([[[ 0, 2],
[ 4, 6],
[ 8, 10]],
[[12, 14],
[16, 18],
[20, 22]]])
随机数函数
np.random.rand(int0,int1...intN)
#随机浮点数 import numpy as np np.random.rand(2,3)
np.random.randn(int0,int1...intN)
#标准正态分布 import numpy as np np.random.randn(2,3)
np.random.randint(low,high,(shape))
#随机整数或整数数组 import numpy as np np.random.randint(1,10,(2,3))
统计函数
np.sum
#求和 import numpy as np a=np.arange(24).reshape((2,3,4)) np.sum(a) np.sum(a,axis=1)
np.mean
#总体平均值 import numpy as np a=np.arange(24).reshape((2,3,4)) np.mean(a) np.mean(a,axis=1)
np.std
#
np.var
#
np.min
#最小值 a=np.arange(24).reshape((2,3,4)) np.min(a) np.min(a,axis=1)
np.max
#最大值 a=np.arange(24).reshape((2,3,4)) np.max(a) np.max(a,axis=1)
np.argmin
#最小值的下标（一维）
np.argmax
#最大值的下标（一维）
np.median()
#中值
画图
import numpy as np import matplotlib.pyplot as plt %matplotlib inline
x = np.linspace(0,2*np.pi,100) y = np.sin(x) plt.plot(x,y) plt.axhline(0,linestyle="--")
pandas
import pandas as pd
导入
pd.read_csv(filename)
c = pd.read_csv("D://a.csv",encoding="UTF-8")
pd.read_table(filename)
c = pd.read_table("D://a.csv")
pd.read_execl(filename)
c = pd.read_excel("D://BTC-buy.xls",encoding="UTF-8")
pd.read_sql(query,connection_object)
[提示] 需要cmd里找pip.exe安装install pymysql
import pymysql conn = pymysql.Connect( host='127.0.0.1', port=3306, user='root', passwd='root', db='test', charset='utf8mb4' ) conn
query = "select * from salse" df = pd.read_sql(query,conn) df
conn.close()
pd.read_json()
json_str = '{"name":["jack","tom"],"age":[18,20]}'
df = pd.read_json(json_str)
df
pd.read_html(url)
url="http://quote.stockstar.com/"
dfs = pd.read_html(url,attrs={'id':'table1'})
dfs[0]
pd.read_clipboard()
a,1 b,2 c,3 df = pd.read_clipboard(seq=",")
pd.DataFrame(dict)
dict1 = {"name":["jack","tom"],"age":[18,20]}
df = pd.DataFrame(dict1)
df
导出
df.to_cvs(filename)
dict1 = {"name":["jack","tom"],"age":[18,20]}
df = pd.DataFrame(dict1)
df.to_csv("D://csv1.csv",index=False)
df.to_excel(filename)
dict1 = {"name":["jack","tom"],"age":[18,20]}
df = pd.DataFrame(dict1)
df.to_excel("D://xls1.xls",index=False)
df.to_sql(table_name,connection_object)
import pandas as pd
from sqlalchemy import create_engine
conn = create_engine('mysql+pymysql://root:root@localhost:3306/test?charset=utf8mb4')
pd.io.sql.to_sql(df,"BTC_buy",con=conn,if_exists='append',index=False)
df.to_json(filename)
import pandas as pd
dict1 = {"name":["jack","tom"],"age":[18,20]}
df = pd.DataFrame(dict1)
df.to_json("D://json1.json")
创建对象
pd.DataFrame(np.random.rand(row,column),column=list)
#创建DataFrame对象 import numpy as np df = pd.DataFrame(np.random.rand(5,2),columns=['a','b']) df
pd.Series(list)
#创建索引 import numpy as np arr = np.array([1,2,3,4]) s = pd.Series(arr) s
pd.date_range()
#日期索引
import numpy as np
df = pd.DataFrame(np.random.rand(5,2),columns=['a','b'])
df.index = pd.date_range("2018-5-28",periods=df.shape[0])
df
查看/检查数据
df.head(n)
#查看DataFrame前N行 import numpy as np df = pd.DataFrame(np.random.rand(5,2),columns=['a','b']) df.head(2)
df.tail(n)
#查看DataFrame倒数N行 import numpy as np df = pd.DataFrame(np.random.rand(5,2),columns=['a','b']) df.tail(2)
df.shape
#查看行，列数 import numpy as np df = pd.DataFrame(np.random.rand(5,2),columns=['a','b']) df.shape
df.info()
#查看索引类型、数据类型、内存信息 import numpy as np df = pd.DataFrame(np.random.rand(5,2),columns=['a','b']) df.info()
df.describe()
#查看数值列的汇总统计 import numpy as np df = pd.DataFrame(np.random.rand(5,2),columns=['a','b']) df.describe()
s.value_counts(dropna=False)
#查看Series的唯一值和计数
conn = pymysql.Connect(
host='127.0.0.1',
port=3306,
user='root',
passwd='root',
db='test',
charset='utf8mb4'
)
conn
pd.read_sql("select 位置 from salse",conn)["位置"].value_counts()
conn.close()
df.apply(pd.Series.value_counts)
#查看DataFrame中每列的唯一值 import numpy as np df = pd.DataFrame(np.random.rand(5,2),columns=['a','b'])
数据选取
df[col]
#根据列，以Series形式返回列
conn = pymysql.Connect(
host='127.0.0.1',
port=3306,
user='root',
passwd='root',
db='test',
charset='utf8mb4'
)
conn
query = "select * from salse"
df = pd.read_sql(query,conn)
df['位置']
df[[col1,col2]]
#以DataFrame返回多列 df[['位置','价格']]
s.iloc[0]
#按位选取数据 df.iloc[0] df['位置'].iloc[0]
s.iloc['index_one']
#按索引选取数据 df['价格'].iloc[1]
df.iloc[0,:]
#返回第一行 df.iloc[0,:]
df.iloc[0,0]
#返回第一列第一个元素 df.iloc[0,0]
df.loc['index_one','column_one']
#按索引，列选取数据 df.loc[0,'成交量']
df.ix[0,'column_one']
#返回第一行的某一列对应元素 df.ix[0,'成交量']
数据清洗
df.columns=['a','b','c']
#重命名列名 import numpy as np df = pd.DataFrame(np.random.rand(5,2),columns=['a','b']) df.columns=['val1','val2'] df
df.isnull()
#检查DataFrame中空值，返回boolean数组 import numpy as np df = pd.DataFrame(np.random.rand(5,2),columns=['a','b']) df.isnull()
df.notnull()
#检查DataFrame中非空值，返回boolean数组 import numpy as np df = pd.DataFrame(np.random.rand(5,2),columns=['a','b']) df.notnull()
df.dropna()
#删除所有包含空值的行 import numpy as np df = pd.DataFrame(np.random.rand(5,2),columns=['a','b']) df.dropna()
df.dropna(axis=1)
#删除所有包含空值的列 import numpy as np df = pd.DataFrame(np.random.rand(5,2),columns=['a','b']) df.dropna(axis=1)
df.dropna(axis=1,thresh=n)
#删除所有小于n的非空值的列 import numpy as np df = pd.DataFrame(np.random.rand(5,2),columns=['a','b']) df.dropna(axis=1,thresh=n)
df.fillna(x)
#用x替换DataFrame中所有空值 import numpy as np df = pd.DataFrame(np.random.rand(5,2),columns=['a','b']) df.fillna(x)
df.rename(columns=lambda x:x+'1')
#批量更改列名 import numpy as np df = pd.DataFrame(np.random.rand(5,2),columns=['a','b']) df.rename(columns=lambda x:x+'1')
df.rename(columns={'old_name':"new_name"})
#有选取的更改列名
import numpy as np
df = pd.DataFrame(np.random.rand(5,2),columns=['a','b'])
df.rename(columns={'b':'c'})
df.set_index('column_one')
#更改索引列
import numpy as np
df = pd.DataFrame(np.random.rand(5,2),columns=['a','b'])
df.set_index('a')
df.rename(index=lambda x:x+1)
#批量重命名索引名 import numpy as np df = pd.DataFrame(np.random.rand(5,2),columns=['a','b']) df.rename(index=lambda x:x+1)
s.replace(1,'one')
#用one代替所有等于1, import numpy as np s = pd.DataFrame(np.random.rand(5,2),columns=['a','b']) s.replace(1,'one')
s.replace([1,3],['one','three'])
#用one代替所有等于1的，用three代替所有等于3的 import numpy as np s = pd.DataFrame(np.random.rand(5,2),columns=['a','b']) s.replace([1,3],['one','three'])
s.astype(float)
#将Series数据类型改为float类型
import numpy as np
df = pd.DataFrame({"name":["A","B"],"score":[1,2]})
df.score = df.score.astype(float)
df.info()
s.fillna(s.mean())
#用某列的均值 填充 某列的空值 import numpy as np df = pd.DataFrame(np.random.rand(5,2),columns=['a','b'])
5-10-3
解决matplotlib中文乱码问题（Windows）http://www.pythoner.com/200.html