Python基础知识点的讲解
你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。
变量类型—数值类型
import math（引入math类库，可以直接对值进行计算）
math.pow(3,10) （第一个是数值，第二个是次幂值，最后的出来的是3**10）
math.floor(2.93827)（向下取整）
math.ceil(2.93827)（向上取整）
math.radians(180)（读数的转换，得出来的是π的值）
min(18,29,98,1)（取最小值1）
max(18,29,98,1)（取最大值98）
sum([18,29,98,1)])（求和要用到列表）
divmod(10，3)（会返回两个值（3，1）返回商和余数）
变量类型—字符串类型
line = “wo shi yi ge cheng xu yuan”;
len(line)（计算字符串的长度）
切片
line[:10]（取前十个字符）
line[:20:2]（取20个字符，隔两个取一个的意思）
line[-10:]（取倒数十个字符）
line[::-1]（字符串翻转）
line[0]（单字符，根据下标进行取值）
line.center(20)（字符串的居中，主要是左右间距）
line.count(‘z’)（计数，主要是计算这个字符在字符串中出现的次数）
字符串首尾判断
line.endswith(‘n’)（判断是否是给与的字符串进行结尾的，是返回True，否则返回False）
line.startswith(‘n’)（判断是否是给与的字符串进行开头的，是返回True，否则返回False）
line.find(‘a’)（返回字符首次出现在字符串中的下标，如果没有则返回-1）
line.index(‘a’)（返回字符首次出现在字符串中的下标，如果没有则报错）
line.upper()（返回所有字符都大写）
line.lower()（返回所有字符都小写）
line.isupper()（判断是否全部是大写，True，False）
line.islower()（判断是否全部是小写，True，False）
line.istitle()（判断是否是标题，首字母大写剩下的都是小写，如果是标题返回True，否则False）
line.strip()（去掉字符串两端的空格，制表符，返回字符串）
line.rstrip()（去掉右端的空格，制表符，返回字符串）
line.lstrip()（去掉左端的空格，制表符，返回字符串）
line.swapcase()（大小写转换，大写变小写，小写变大写）
变量类型列表类型
列表
空列表
gay = []
gay = list()
可以容纳任意类型的对象，任意数量的对象【重点】列表是可变类型的
gay = [1,2,3,‘nihao’,[],[100,200]]
bar = []（定义空列表）
bar.append(1)（列表数据填充，可变）
bar[0] = 10（通过下标改变列表的值）
python是一种动态类型的语言，一个变量是什么类型，要看程序在运行过程中变量所代表的值是什么
序列 列表是一种容器型序列；字符串是一种扁平型的序列
gay.append(1)（修改列表本身）
gay.clear()（清空列表）
new_gay = gay.copy()（copy的作用是将值复制给新的变量，后期改变new_gay
的某个值的时候，gay的值不会跟着变化，新变量是独立存在的）
a = [1,2]
b = [3,4]
a+b（会返回一个新的列表，值都在）
a.extend(b) (这个是上述的是一样的)
a.insert(0,100)（在指定的下标那儿添加值）
a.pop()（如果给定下标会弹出下标对应的值，如果没有给定下标，则弹出最后一个，删除）
a.remove()（这儿给定值，删除第一个匹配到的值【注意】这儿不是下标而是值）
a.sort(reverse=True)（字符翻转，从大到小排序出来）
1 in a（判断a中知否有1，有返回True，否则False）
元组、字典
定义一个元组
var = tuple()
var = ()
简单来说元组就是不可变的列表，他只有count和index属性
定义一个字典
var = dict()
var = {}
有值的字典
var = {
‘1’:100,
‘2’:200
}
取值：var[‘中’]
words = [‘中’,‘左’]
location = [100,200]
取中的值：location[words.index(‘中’)]
拉锁函数(将两个字典进行合并)
list(zip(words,location))
合并以后的样子是：[(‘中’,100),(‘左’,200)]
生成一个字典
students = [‘li’,‘wang’]
money = dict.fromkeys(students,10)（主要的作用是初始化字典的值）
money[‘wang’]（访问字典中的值）
money[‘www’]（访问字典中不存在的值的时候，会进行报错）
money.get(‘wang’)（.get也是访问字典中的值，存在的话就显示，不存在会返回一个None，.get(‘ww’,‘100’)如果找不到可以给定一个值）
money.keys()（返回键列表）
money.values()（返回值列表）
money.items()（返回键值相对应的多个列表）
money.pop(‘wang’)（删除键值对并且将值输出）
money.setdefault(‘haha’,1000)（给字典进行添加键值对，如果键值存在则返回存在的值，如果不存在，就添加进去，并返回添加的值）
条件判断重点：
1、条件判断可以任意组合
第一层意思：elif可以有0到任意多个，else可有可无
第二层意思：条件判断可以进行嵌套
从理解的角度上来讲，一个值被当做bool值，概念上更像是有与没有的区别；
bool值变量做运算
a = True
b = False
print(‘a and b is {}’.format(a and b))（一真为假，二真为真）
print(‘a or b is {}’.format(a or b))（一真为真，二假为假）
非bool值变量做运算
a = ‘你好’
b = [1,2,3]
print(‘a and b is {}’.format(a and b))（只打印出来的是b的值）
print(‘a or b is {}’.format(a or b))（只打印出来a的值）
非bool型变量not运算，永远返回Teue或者False
循环
for 循环 - 遍历循环
while循环 - 条件循环
costs = [3,4,5,6,7,8]
for cost in costs:
print(‘消费 {} 元’.format(cost))
import random
random_numbers = []
while len(random_numbers) < 20:
random_numbers.append(random.randint(1,10))
random 是数字库
randint(1,10)（获取1-10之间的随机数）
len()（获取长度）
能使用for循环就不是用while循环
random_numbers = []
for i in range(20):
random_numbers.append(random.randint(1,10))（结果和上一个是一样的）
什么时候必须用while循环：当循环的条件跟数量没有关系时，只能用while
random = [2,4,5,7,9]
continue 跳过
break 跳出循环
循环中的else：如果在循环的过程中没有碰到break语句，就会执行else里的代码
for number in random:
if number % 2 == 0:
print(’{} is 偶数’.format(number))
else:
continue（这个词的作用是跳出本次循环，不在执行continue后面的）
for循环可以购建推导式
所谓推导式，就是一种从一个数据序列构建另一个数据序列的方法
例子：
random = [1,2,3,4,5,6,7,8,9]
列表推导式
nuw = [number*10 for number in random]
字典推导式
nuw = {number:‘A’ for number in random}
函数
bar = {‘a’:100,‘b’:100,‘c’:200}
[key for key,value in bar.items() if value == 100]
函数-抽象概念
def get_keys(dict_varibal,value):
return [k for k,v in bar.items() if v== value]
get_keys(varibal,200)
函数是组织好的，可重复使用，能够完成特定功能的代码块，它是代码块的抽象
位置参数是不可以交换位置的
get_keys({‘a’: 40},40)
get_keys函数名
（）中为参数；dict_varibal：形参；调用的时候传递的值才是实参；
return 是返回值
关键字参数，可以不按照顺序去写
get_keys(dict_varibal={‘a’: 40},value=40)
参数的收集
例子：
*args【位置参数】
**kwargs【关键字参数】
def test(name, age, *args, **kwargs):
print(name, age, *args, **kwargs)
test(‘wang’,12)
输出：wang 12 （）
test(‘wang’, 12, 23, ‘lkl’, [23,24])
输出：wang 12 23 lkl [23,34]
dict_varibals = {‘weight’: 120, ‘height’: 175}
test(‘wang’, 12, dict_varibals)
输出：wang 12 {‘weight’: 120, ‘height’: 175}
装饰器
a = 10
b = [12, 12]
def test():
peint(‘tese’)
c = test
可以将函数赋值给一个变量
def test(func):
return func
def func():
print(‘func run’)
f = test(func)
f.name
f()
函数可以当做函数的返回值进行返回
python另一个语法糖，装饰器
返回一个从0-1的浮点值
@decorator（相当于decorator(test)的函数调用）
def test():
return random,random()
@decorator（相当于decorator(test_two)的函数调用）
def test_two():
return random,random()*10
def decorator(func):
def wrapper(*args, **kwargs):
# do something
return round(func(*args, **kwargs),2)
return wrapper
类
class Person：
def init(self,name,age):
self._name = name
self,_age = age
def get_name(self):
return self._name
初始化函数中，self后面的是实例化对象的属性，加下划线的意思是，代表这个属性是私有的，不应该访问
p = Person(‘wang’, 12)
p.get_name()
输出：wang
pass代表什么都不做，只是占个位而已
class Student(Person):（这儿相当于是继承的关系）
@property（在函数上面+这个，以后调用的时候直接调用函数名就行）
def set_score(self, score):
self._score = score
def get_score(self, score):
return self._score
s.Student(‘liu’,24)
s.get_name()（这儿是调用的Person的get_name）
s.set_score(100)
s.get_score()
Python操作数据库、python爬虫
推荐一个Python数据结构可视化工具：http://www.pythontutor.com
mysql数据库的基本操作
MariaDB：MariaDB的目的是完全兼容Mysql，包括API和命令行，使之能轻松成为Mysql的代替品
Mysql是关系型数据库
MongoDB，redis是典型的非关系型数据mysql -u root -p（-u是用户名、p的意思是需要用密码登陆数据库）
命令行操作
查看数据库：show databases；
选择数据库：user databases_name；
查看数据库中的table表：show tables；
查看表格的数据结构：desc tables；
查看表中的数据：select * from table_name；
查看数据并限制数量：select * from table_name limit 10；
数据库管理工具：http://http://www.sequelpro.com 创建数据库：create database Examination_copy；（Examination_copy—数据库名称）
删除数据库：drop database Examination_copy；（Examination_copy—数据库名称）
指定字符集和校对集，创建数据库：create database Examination_copy default charset utf8mb4 collate utf8md4_general_ci；
mysql数据类型：http://www.runoob.com/mysql/mysql-data-types.html
用python操作数据库
python安装第三方库
1、pip；举例：pip install pymysql
2、conda；举例：conda install pymysql
import MySQLdb（这儿是引入第三方库，首先的安装第三方库）
DATABASE = {
'host' : '127.0.0.1',
'database' : 'examination_copy',（数据库名称）
'uaer' : 'rooot',
'password' : '12345',
'charset' : 'utf8mb4'（这个有点重要，如果缺少，会出现乱码）
}
db = MySQLdb.connect(host='localhost',user='root',password='12345',db='examination_copy');
等价于
db = MySQLdb.connect('localhost','root','12345','examination_copy');（顺序是固定的）
等价于
db = MySQLdb.connect(**DATABASE);
db就代表我们的数据库游标
cursor = db.cursor();（游标的定义）
**查询**
sql = "select * from class";
cursor.execute(sql);（游标执行sql语句）
result = cursor.fetchall();（循环获取数据库的值）
for row in result:
print(row);
**插入**
sql = "insert into 'class' ('name') value ('高一四班')";
cursor.execute(sql);（游标执行sql语句）（这个可以同时执行多个sql语句，写多个）
db.commit()（这个是执行添加的操作）
**删除**
sql = "de'lete from 'class' where name = '高一三班'";
cursor.execute(sql);（游标执行sql语句）（这个可以同时执行多个sql语句，写多个）
db.commit()（这个是执行添加的操作）
**更新**
sql = "update 'class' set `name` = '高一十四班' where `id` = 4";
cursor.execute(sql);（游标执行sql语句）（这个可以同时执行多个sql语句，写多个）
db.commit()（这个是执行添加的操作）编写python爬虫并保存到数据库;
python库
- requests 用来获取页面的内容
- BeautifulSoup
安装第三方python库
linux环境安装requests：pip install requests；
win10环境安装requests：python -m pip install requests
linux环境安装BeautifulSoup：pip install bs4
win10环境安装BeautifulSoup：python -m pip install bs4案例
import time
import MYSQLdb
import requests;
from bs4 import BeautifulSoup;
### 返回url下的页面内容，返回soup对象（公共部分）
def get_soup(url):
responce = requests.get(url);
soup = BeautifulSoup(responce.text,'lxml');
return soup;
封装成函数，作用是获取列表下面的所有租房信息页面的连接，返回一个连接列表
def get_links(link_url):
soup = get_soup(link_url)
links_div = soup.find_all('div', class_="content__list--item");
links = [div.a.get('href') for div in links_div];
return links;
link_url = 'https://bj.lianjia.com/zufang/';
get_links(link_url);
def = get_house_info(house_url):
soup = get_soup(house_url);
price = soup.find('div', class_="content__aside--title").text;（获取到的价格）
有时候单位是在下一个的span中，用 单位.strip() 去除两边多余的符号
获取房屋的基本信息
houst_info = soup.find_all('li', class_="fl oneline");
print(houst_info[5].text);（这儿用来输出找到自己想要的各种信息）
这儿是想要信息的赋值（大同小异）
area = houst_info[1].text[3:]（根据切片来获取面积的信息）
fangxiang = houst_info[2].text[3:];（根据切片来获取房屋朝向信息）
放入到一个字典中（注意utf-8的使用，否则中文报错）
info = {
'价格':area,
'朝向':fangxiang
}
## 往数据库存放数据
DATABASE = {
'host' : '127.0.0.1',
'database' : 'examination_copy',（数据库名称）
'uaer' : 'rooot',
'password' : '12345',
'charset' : 'utf8mb4'（这个有点重要，如果缺少，会出现乱码）
}
def get_db(**settig):
return MYSQLdb.connect(**settig);
def insert_houst_info(db,houst_info):
values = "'{}',"*2+ "'{}',"
sql_value = values.format(houst_info['价格'], houst_info['朝向'])
sql = """
insert info `hoise`(`area `,`fangxiang`) .values({})
""".format(sql_value);
cursor = db.cursor();
cursor.execute(sql);（游标执行sql语句）（这个可以同时执行多个sql语句，写多个）
db.commit()（这个是执行添加的操作）
### 调用函数
house = get_house_info('https://bj.lianjia.com//zufang/BJ2549799804012339200.html');
db = get_db(DATABASE);
links = get_links(link_url);
for linke in links:
time.sleep(2)
house = get_house_info(linke);
insert_houst_info(db, house);python进阶
安装常用的的第三方类库
pip install matplotlib -i http://pypi.douban.com/simple --trusted-host pypi.douban.com
pip install numpy -i http://pypi.douban.com/simple --trusted-host pypi.douban.com
pip install pandas -i http://pypi.douban.com/simple --trusted-host pypi.douban.com
pip install seaborn scipy -i http://pypi.douban.com/simple --trusted-host pypi.douban.com
NumPy基本操作（主要用来做一些科学运算，主要是矩阵的运算）
数组和列表，列表可以存储任意类型的数据，而数组只能存储一种类型数据
安装第三方python库
linux环境安装numpy：pip3 install numpy；
win10环境安装numpy：pip3 install numpy案例
numpy比array要用的多
import array
a = array.array('i',range(10))
数据类型必须统一
a[1] = 10
print(a)
import numpy as np
从原有的列表转换成数组
a_list = list(range(10))
b = np.array(a_list)
print(b)
生成数组
zeros生成的是0，ones生成的是1，full((3, 3),3.14)（可以输出指定的值）
a = np.zeros(10, dtype=int) （10是个数，dtype是定义数组值的类型）
print(type(a))（这个是打印出a的类型）
a = np.zeros((4, 4), dtype=int) （10是个数，dtype是定义数组值的类型）
print(type(a))（这个是打印出a的类型）
**random随机数**
np.random.random()（生成小于1 的随机数）
np.random.random((3,3))（生成九宫格的小于1随机数数组）
np.random.randint(0,10, (3,3))（生成九宫格的0-10随机数数组）
np.arange(0, 10, 2)（0-10的偶数随机数）
np.linspace(0, 3, 10)(（10个随机数）
np.eye(5)（n维的单位矩阵）访问数组中的元素
**嵌套列表的元素访问**
var = [[1, 2, 3],[3, 4, 5]]
var[0][0]
**数组中元素的访问**
a = np.array(var)
a[-1][0]
**这两种访问方式是等价的**
a[2, 0] a[2][0]
**数组切片是不等价的**
a[:2, :2] a[:2][:2]
**数组的属性**
**维度**
print（a.ndim）
**数组的形状**
print（a.shape）
**数组元素统计**
print（a.size）
**数组值类型**
print（a.dtype）
**每个字节占用的空间**
print（a.itemsize）
**值总字节**
print（a.nbytes）运算
numpy的运算是每个值进行运算
**一维运算**
a = np.array(list(range(10)))
print(a+10)
print(a-10)
print(a*100)
**二维运算**
a = np.full((3, 3), 1.0, dtype=float)
a+10 等价于 np.add(a, 10)统计类型
**求和**
print（sum([1, 2, 3])）
**数组一维求和**
a = np.full(10, 2.3)
print(sum(a))
**数组多维求和**
a = np.full((3, 3), 2.3)
a = np.array([[1, 2],[3, 4]])
print(sum(a))
np.sum 求和
np.sum(a)
np.sum(a, axis=1)
np.max(a, axis=1)notebook使用小技巧
%timeit代码；此方法来判断程序的执行效率
%timeit sum(n)
%timeit np.sum(n)
由上代码可以看出np.sum的执行效率高，求推荐使用比较
a = np.array(range(10))
np.all(a>-1)
np.any(a>-1)
只能出现True和False，全真则True，有一假则False变形
a = np.full((2, 10), 1, dtype=float)
**如果后面不指定dtype的类型则会出现错误**
a.reshape(4,5)（用reshape来变成自己想要的显示类型，但是注意他们的总数应该是一样的）排序
l = [[1,2,3],[32,12,4]]
a = np.array(l)
np.sort(a)
a.sort(axis=0)（不只是行进行排序，也根据列来进行排序啦）拼接
a = np.array([1, 2, 3])
b = np.array([[0,2,3],[1,3,5]])
**按行去连接**
np.concattenate([b,b,b],axis=0)
**按列去连接**
np.concattenate([b,b,b],axis=1)Pandas
新的数据格式—csv
- 纯文本，使用某个字符集，比如ASCLL、Unicode、EBCDIC或GB2312（简体中文环境）等；
- 由记录组成（典型的是每行一条记录）；
- 每条记录被分隔符（英语：Delimiter）分隔为字段（英语：Field（computer science））（典型分隔符有逗号，分号或制表符；有时分隔符可以包括可选的空格）；
- 每条记录都有同样的字段序列
import pandas as pd
df = pd.read_csv()
df.head()（如果括号里面不指定数量，默认显示五行，扩号里面数字是多少就显示多少行）
type(df)（查看数据类型）DataFrame
列名：print(df.columns)
索引：print(df.index)
df.loc[0]（根据下标来获取数据）
**筛选数学成绩大于80**
df[df.数学 > 80]
**复杂筛选**
df[(df.数学 > 80) & (df.语文 > 80)]（里面是不识别and的，只识别&运算符）
**排序**
df.sort_values(['数学'，'语文']).head();
**访问**
按照索引定位
df.loc[1]
**当索引为数字索引的时候，ix和loc是等价的**
访问某一行的数据，错误的写法------df[0]
访问多行数据是可以使用切片的-------df[:2]
**dataframe中的数组**
df.数学。values
**简单的数量统计**
df.数学.value_counts()
**提取多列**
new = df[['数学'],['语文']]
new*2（原来的数据是没有发生改变的）重点
def func(score):
if score>=80:
return "优秀"
else if score>=70:
return "良"
else if score>=60:
return "及格"
else:
return "不及格"
df['数学分类'] = df.数学.map(func)
**上面的函数运行下来，最后会多出来一列，显示数学成绩是什么分类**applymap
对dataframe中所有的数据进行操作的一个函数，非常重要
def func():
return number+10
**等价**
func = lambda number: number+10
df.applymap(lambda x: str(x) + ' -')
**前几行**
df.tail(2)
**最后几行**
df.tail(2)pandas中的dataframe的操作，很大一部分跟numpy中的二维数组的操作是近似的
MATPLOTLIB绘图
import numpy as np
import matplotlib.pyplot as plt
x = np.linspace(0, 10, 100)
y = np.sin(x)
data = np.arange(10)
####
plt.show()
plt.plot(data)
plt.plot(x,y)
plt.plot(x,np.cos(x))
fig = plt.figure()（保存图片的第一步）
plt.plot(x,y,'--')（'--'是用来控制线的样式）
fig.savefig('/Users/MaoJie/Desktop/aaa.png')（这个是执行将图形保存到桌面）
￥￥￥虚线样式
**这是两行，第一个图形**
plt.subplot(2, 1, 1)
plt.plot(x, np.sin(x), '--')
**两行，第二个图形**
plt.subplot(2, 1, 2)
plt.plot(x, np.cos(x))
￥￥￥点状样式（‘o’是用来点图样式，color控制图的颜色,label用来提示坐标说明，但是得与plt.legend()配合使用）
x = np.linspace(0, 10, 20)
plt.plot(x, np.sin(x), 'o', color='black', label='sin(x)')
**legend控制label的显示效果，loc是控制label的位置的显示**
**当遇到一个不熟悉的函数的时候，多使用？号，查看函数的文档**
**plt.plot参数有很多，可以参考文档进行字型添加**
plt.ylim和plt.xlim限定查看的范围
散点图：plt.scatter(x, y, s=100, c='gray')（s-大小，c-颜色）
案例：
plt.style.use('seaborn-whitegrid')（这个是主体的样式，不过一般执行过一次以后就是执行的那个）
x = np.random.randn(100)
y = np.random.randn(100)
colors = np.random.rand(100)
sizes = 1000 * np.random.rand(100)
plt.scatter(x, y, c=colors, s=sizes, alpha=0.4)
plt.colorbar()
plt.show()
####
####之间的是必不可少的Pandas自带绘图
綫型圖示例：
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
df = pd.DataFrame(np.random.rand(100,4).cumsum(0), columns=['A', 'B', 'C', 'D'])
df.plot()
plt.show()柱狀圖示例：
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
df = pd.DataFrame(np.random.randint(10,50,(3,4)), columns=['A', 'B', 'C', 'D'], index=['one', 'two', 'three'])
df.plot.bar() 等价于 df.plot(kind='bar') （s'tacked=True）在括号中写，可以将四个柱状图累加到一块显示
plt.show()直方图示例：
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
df = pd.DataFrame(np.random.randn(100, 4), columns=['A', 'B', 'C', 'D'])
df.hist()
plt.show()密度图示例：
密度图使用首先的安装好scipy
scipy安装教程：1、cmd 找到python环境下的scripts，进入目录中。2、执行pip3 install scipy
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
df = pd.DataFrame(np.random.randn(100, 4), columns=['A', 'B', 'C', 'D'])
df.plot.kde()
plt.show()数据处理与分析
导入数据
import pandas as pd
%matplotlib inline
如果不知道函数名是什么，可以只敲击函数前几个，然后按tab键，就会有下拉框提示
titanic = pd.read_csv('/路徑/文件名.csv')
快速预览
titanic.head()
字段名详解
titanic.info()
把所有的數值類型的數據做一個簡單的統計
titanic.describe()
統計none值得個數
titanic.isnull().sum()处理空值
可以填充整个datafram里面的空值
titanic.fillna(0)
单独选择一列进行空值填充
titanic.Age.fillna(0)
年龄的中位数
titanic.Age.median()
按年龄的中位数去填充，此时是返回一个新的Series
titanic.Age.fillna(titanic.Age.median())
直接填充，并不返回新的Serise
titanic.Age.fillna(titanic.Age.median(), inplace=True)尝试从性别进行分析
做简单的汇总统计,经常用到
titanic.Sex.value_counts()
生还者中，男女的人数
survived = titanic[titanic.Survived==1].Sex.value_counts()
未生还者中，男女的人数
dead = titanic[titanic.Survived==0].Sex.value_counts()
df = pd.DataFrame([survived, dead], index=['survived', 'dead'])
df.plot.bar()（这样就会绘制出来一个柱状图）
绘图成功，但是还有一种
把dataframe转置一下，就是行列替换
df = df.T
df.plot.bar()
还有一种是将两个柱状图叠加起来
df.plot(kind='bar', stacked=True)
男女中生还者的比例情况
df['p_survived'] = df.survived / (df.survived + df.dead)
df['p_dead'] = df.dead / (df.survived + df.dead)
df[['p_survived','p_dead']].plot.bar(stacked=True)
通过上面图片可以看出：性别特征对是否生还的影响还是挺大的从年龄进行分析
简单的统计
titanic.Age.value_counts()
survived = titanic[titanic.Survived==1].Age
dead = titanic[titanic.Survived==0].Age
df = pd.DataFrame([survived, dead], index=['survived', 'dead'])
df = df.T
df.ploat.hist(stacked=True)
直方图柱子显示多一点
df.plot.hist(stacked=True, bins=30)
中间很高的柱子，是因为我们把空值都替换为了中位数
密度图，更直观一点
df.plot.kde()
可以查看年龄的分布，来决定我们图片横轴的取值范围
titanic.Age.describe()
限定范围
df.plot.kde( xlim=(0, 80))
age = 16
young = titanic[titanic.Age<=age]['Survived'].value_counts()
old = titanic[titanic.Age>age]['Survived'].value_counts()
df = pd.DtaFrame([young, old], index=['young', 'old'])
df.columns = ['dead', 'survived']（这个是可以修改table的表头）
df.plot.bar(stacked=True)分析票价
票价跟年龄特征相似
survived = titanic[titanic.Survived==1].Fare
dead = titanic[titanic.Survived==0].Fare
df = pd.DataFrame([survived, dead], index=['survived', 'dead'])
df = df.T
df.ploat.kde()
设定xlim范围，先查看票价的范围
titanic.Fare.describe()
df.plot(kind=‘kde’, xlim(0, 513))
可以看出低票价的人生还率比较低组合特征
同时查看年龄和票价对生还率的影响
import matplotlib.pyplot as plt
plt.scatter(titanic[titanic.Survived==0].Age, titanic[titanic.Survived==0].Fare)
美观：
ax = plt.subplot()
age = titanic[titanic.Survived==0].Age
fare = titanic[titanic.Survived==0].Fare
plt.scatter(age, fare, s=10)
ax.set_xlabel('age')
ax.set_ylabel('fare')隐含特征
titanic['title'] = titanic.Name.apply(lambda name: name.split(',')[1].split('.')[0].strip())
案例：
s = 'Williams , Mr. Howard Hugh "Harry"'
s.split(',')[1].split('.')[0].strip()
统计一下
titanic.title.value_counts()
比如有一个人被称为Mr，而年龄是不知道的，这个时候可以用所有Mr的年龄平均值来替代，而不是我们之前最简单的所有数据的中间值gdp
夜光图，简单用灯光图的亮度来模拟gdp
titanic['family_size'] = titanic.Sibsp + titanic.Parch + 1
titanic.family_size.value_counts()
def func(family_size):
if family_size==1：
return ‘Singleton’
if family_size<=4 and family_size>=2：
return ‘SmallFamily’
family_size>4:
return 'LargFamily'
titanic['family_type'] = titanic.family_size.apply(func)
