Python 数据分析之基础

Python 数据分析之基础

1. Python 基本语法

Python使用Python使用 <变量名>=<表达式> 的方式对变量进行赋值

a=1
a
--------------------
输出 
1
1
2
3
4
5

s = 'hello world'
s
--------------------
输出
'hello world'
1
2
3
4
5

1.1 数据类型

常用数据类型

1.1.1 字符串

(1) 字符串的定义是使用引号来定义，单引号与双引号是等价的

s='hello world'
s
--------------------
输出
'hello world'
1
2
3
4
5

(2) 三引号用来输入包含多行文字的字符串（可以是单引号也可以是双引号）

s='''hello
my
world'''
print(s)
--------------------
输出
hello
my
world
1
2
3
4
5
6
7
8
9

(3) 字符串的加法

s="hello "+"world"
s
--------------------
输出
'hello world'
1
2
3
4
5

(4) 字符串索引(索引号从0开始)

s='hello world'
s[1]
--------------------
输出
'e'
1
2
3
4
5

(5) 字符串的分割（spilt方法，可以按照自己指定的方法分割，默认是空格）

s="hello world"
s.split()
--------------------
输出
['hello', 'world']
1
2
3
4
5

s="hello,world"
s.split(",")
--------------------
输出
['hello', 'world']
1
2
3
4
5

(6) 查看字符串的长度

s="hello world"
len(s)
--------------------
输出
11
1
2
3
4
5

1.1.2 整数

b=100
b
--------------------
输出
100
1
2
3
4
5

1.1.3 浮点数

c=3.8
c
--------------------
输出
3.8
1
2
3
4
5

1.1.4 布尔值

a=True
a
--------------------
输出
True
1
2
3
4
5

a=1>2
a
--------------------
输出
False
1
2
3
4
5

1.1.5 空值

a=''
a
--------------------
输出
''
1
2
3
4
5

len(a)
--------------------
输出
0
1
2
3
4

a = None
a
--------------------
输出

1
2
3
4
5

1.1.6 运算符

运算符：http://www.runoob.com/python/python-operators.html#ysf4

(1) 基本运算符

2**3 #幂运算
--------------------
输出
8
1
2
3
4

9%2 #取余运算
--------------------
输出
1
1
2
3
4

9//2 #取整除-返回商的整数部分
--------------------
输出
4
1
2
3
4

(2) 比较运算

1 != 2
#2 <> 2 #都是不等于的写法，貌似后面这个在3以后的版本里就不支持了
--------------------
输出
True
1
2
3
4
5

1>2
--------------------
输出
False
1
2
3
4

3==3 #等式两边比较
--------------------
输出
True
1
2
3
4

(3) 赋值运算

a=2
a*=3 #a=a*3
a
--------------------
输出
6
1
2
3
4
5
6

(4) 逻辑运算

• & - and

  a&b，只有当ab都是True的时候，结果才是True，否则都是False

  a=True
  b=False
  a&b
  --------------------
  输出
  False
  1
  2
  3
  4
  5
  6

  a=3>2
  b=4>3
  a&b
  --------------------
  输出
  True
  1
  2
  3
  4
  5
  6

• | - or

  a|b，当ab有一个为True的时候，结果就是True，两个都是False的时候结果才是False

  a=1>2
  b=4>3
  a|b
  --------------------
  输出
  True
  1
  2
  3
  4
  5
  6

• not

  取反

  a=True
  not a
  --------------------
  输出
  False
  1
  2
  3
  4
  5

1.2 数据结构

1.2.1 列表 List

Python用 [ ] 来生成列表，也可以用 list 关键字

a=[1,2,3,4,5]
a
--------------------
输出
[1, 2, 3, 4, 5]
1
2
3
4
5

actors=['周迅','章子怡','赵薇']
actors
--------------------
输出
['周迅', '章子怡', '赵薇']
1
2
3
4
5

# 列表中的元素允许各个元素不一样
b=[1,2.3,'a','b']
b 
--------------------
输出
[1, 2.3, 'a', 'b']
1
2
3
4
5
6

# 利用list生成列表
list('abcde')
--------------------
输出
['a', 'b', 'c', 'd', 'e']
1
2
3
4
5

列表操作

列表函数：

列表方法：

(1) 将两个链表链接在一起

# 将两个链表链接在一起
a=[1,2,3,4,5]
b=[1,2.3,'a','b']
a+b       
--------------------
输出
[1, 2, 3, 4, 5, 1, 2.3, 'a', 'b']
1
2
3
4
5
6
7

(2) 索引号，从0开始

# 索引号，从0开始
a=[1,2,3,4,5]
a[0] 
--------------------
输出
1
1
2
3
4
5
6

(3) append 方法，在末尾增加一个数

# append 方法，在末尾增加一个数
a.append(6)
a
--------------------
输出
[1, 2, 3, 4, 5, 6]
1
2
3
4
5
6

(4) insert 方法，插入一个数，insert(索引号，值)

# insert 方法，插入一个数，insert(索引号，值)
a.insert(1,10)
a
--------------------
输出
[1, 10, 2, 3, 4, 5, 6]
1
2
3
4
5
6

(5) pop 方法，默认是删除最后一个元素，在里面写数字的话是写索引号

# pop 方法，默认是删除最后一个元素，在里面写数字的话是写索引号
a.pop()
a
--------------------
输出
[1, 10, 2, 3, 4, 5]
1
2
3
4
5
6

a.pop(1)
a
--------------------
输出
[1, 2, 3, 4, 5]
1
2
3
4
5

(6) 数据切片，左闭右开区间

• a=[a ：b]

a=[1,2,3,4,5]
a[0:3] # 数据切片，左闭右开区间
--------------------
输出
[1,2,3]
1
2
3
4
5

a[-1] # -1表示倒数第一个数
--------------------
输出
5
1
2
3
4

a[-3.-1] # 负索引切片，倒数
--------------------
输出
[3,4]
1
2
3
4

a[:3] # 默不写默认第一个数为0
--------------------
输出
[1,2,3]
1
2
3
4

a[-3:] # 不写的话默认从左边第一个开始或者取到右边最后一个
--------------------
输出
[3, 4, 5]
1
2
3
4

• b=[a ：b ：i]

  间隔取值，前面区间仍然是左闭右开，后面为步长，同样也适用于负数的情况

b=[1,2,3,4,5,6,7,8,9]
b[2:9:3]
--------------------
输出
[3, 6, 9]
1
2
3
4
5

b[-1:-9:-3]
--------------------
输出
[9, 6, 3]
1
2
3
4

b[::-1] # 列表分片将步长值设置为-1, 则 相当于反转列表
--------------------
输出
[9, 8, 7, 6, 5, 4, 3, 2, 1]
1
2
3
4

1.2.2 元组 tuple

Python 的元组与列表类似，不同之处在于元组的元素不能修改。

元组使用小括号，列表使用方括号。

元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

元组与字符串类似，下标索引从0开始，可以进行截取，组合等。

(1) 创建元组

tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
tup3 = "a", "b", "c", "d"

tup1=()      # 创建空元组
tup2=(50,)   # 元组中只包含一个元素时，需要在元素后面添加逗号
1
2
3
4
5
6

(2) 访问元组

tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
 
print "tup1[0]: ", tup1[0]
print "tup2[1:5]: ", tup2[1:5]
--------------------
输出
tup1[0]:  physics
tup2[1:5]:  (2, 3, 4, 5)
1
2
3
4
5
6
7
8
9

(3) 修改元组

tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
# 创建一个新的元组
tup3 = tup1 + tup2
print tup3
--------------------
输出
(12, 34.56, 'abc', 'xyz')
1
2
3
4
5
6
7
8

(4) 删除元组

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组

(5) 元组运算符

(6) 元组索引，截取

L = ('spam', 'Spam', 'SPAM!')
1

(7) 元组内置函数

1.2.3 字典 dict

字典是另一种可变容器模型，且可存储任意类型对象。

字典的每个键值 key:value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中

字典里面的数据可以是任何数据类型，也可以是字典

(1) 创建字典

mv = {"name":"肖申克的救赎","actor":"罗宾斯","score":9.6,"country":"USA"}
mv
--------------------
输出
{'name': '肖申克的救赎', 'actor': '罗宾斯', 'score': 9.6, 'country': 'USA'}
1
2
3
4
5

(2) 访问字典里的值

mv["name"]
--------------------
输出
'肖申克的救赎'
1
2
3
4

(3) dict.keys() 以列表返回一个字典所有的键

mv.keys()
--------------------
输出
dict_keys(['name', 'actor', 'score', 'country'])
1
2
3
4

(4) dict.values() 以列表返回字典中的所有值

mv.values()
--------------------
输出
dict_values(['肖申克的救赎', '罗宾斯', 9.6, 'USA'])
1
2
3
4

(5) dict.items() 以列表返回可遍历的(键, 值) 元组数组

mv.items()
--------------------
输出
dict_items([('name', '肖申克的救赎'), ('actor', '罗宾斯'), ('score', 9.6), ('country', 'USA')])
1
2
3
4

(6) 修改字典元素

mv["name"] = "泰坦尼克号"
mv
--------------------
输出
{'name': '泰坦尼克号', 'actor': '罗宾斯', 'score': 9.6, 'country': 'USA'}
1
2
3
4
5

(7) 新增字典元素

mv["director"] = "德拉邦特"
mv
--------------------
输出
{'name': '泰坦尼克号',
 'actor': '罗宾斯',
 'score': 9.6,
 'country': 'USA',
 'director': '德拉邦特'}
1
2
3
4
5
6
7
8
9

(8) 删除字典元素

# 删除键是'director'的条目
del mv['director'] 
mv
--------------------
输出
{'name': '泰坦尼克号', 'actor': '罗宾斯', 'score': 9.6, 'country': 'USA'}
1
2
3
4
5
6

# 清空字典所有条目
mv.clear() 
mv
--------------------
输出
{}
1
2
3
4
5
6

# 删除字典
del mv
--------------------
输出
NameError: name 'mv' is not defined     # 因为用del后字典不再存在
1
2
3
4
5

1.2.4 集合set

集合（set）是一个无序的不重复元素序列。

可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

(1) 自动删除重复元素

s = {2,3,4,2}
s
--------------------
输出
{2, 3, 4}
1
2
3
4
5

(2) 计算集合元素个数

s = {2,3,4,2}
len(s)
--------------------
输出
3
1
2
3
4
5

(3) 添加元素

s = {2,3,4,2}
s.add(1)
s
--------------------
输出
{1, 2, 3, 4}
1
2
3
4
5
6

(4) 移除元素

s = {2,3,4,2}
s.remove(4)
s
--------------------
输出
{2, 3}
1
2
3
4
5
6

(5) 清空集合

s = {2,3,4,2}
s.clear()
s
--------------------
输出
set()
1
2
3
4
5
6

(6) 判断元素是否在集合中存在

s = {2,3,4,2}
3 in s
--------------------
输出
True
1
2
3
4
5

(7) 取交集

s = {1,2,3,4,2}
s1 = {2,3,5,6}
s & s1
--------------------
输出
{2, 3}
1
2
3
4
5
6

(8) 取并集

s | s1
--------------------
输出
{1, 2, 3, 4, 5, 6}
1
2
3
4

(9) 差集

s - s1
--------------------
输出
{1, 4}
1
2
3
4

1.3 可以变对象和不可变对象

可变对象可以对其进行插入，删除等操作，不可变对象不可以对其进行有改变的操作。Python中列表，字典，集合等都是可变的，元组，字符串，整型等都是不可变的。

1.3.1 类型转换

int(3.14)
--------------------
输出
3
1
2
3
4

float(3)
--------------------
输出
3.0
1
2
3
4

s = "abcd"
type(s) # type返回数据的类型
--------------------
输出
str
1
2
3
4
5

list(s)
--------------------
输出
['a', 'b', 'c', 'd']
1
2
3
4

1.3.2 判断和循环

2 == 2
--------------------
输出
True
1
2
3
4

97 == 'a'
--------------------
输出
False
1
2
3
4

'a' == 'A'
--------------------
输出
False
1
2
3
4

if 2>1:
    print('hello')
--------------------
输出
hello
1
2
3
4
5

a = 1
b = 2
if a>b:
    print("a大于b")
else:
    print("a小于等于b")
--------------------
输出
a小于等于b
1
2
3
4
5
6
7
8
9

x = 0
if x>0:
    print("x为正")
elif x==0:
    print("x为0")
else:
    print("x为负")
--------------------
输出
x为0
1
2
3
4
5
6
7
8
9
10

for i in range(5):#(1,2,3,4,5):#[1,2,3,4,5]:#[1,2,3,3,4]  #列表元组集合字典字符串都行
    print(i)
--------------------
输出
0
1
2
3
4
1
2
3
4
5
6
7
8
9

i=1
while i<10:
    print(i)
    i=i+1
--------------------
输出
1
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#判断，循环一起连用
for i in [1,2,3,4,5,6,7,8,9]:
    if(i%2)==1:
        print(i)
--------------------
输出
1
3
5
7
9
1
2
3
4
5
6
7
8
9
10
11

1.3.3 列表生成式

列表生成式即List Comprehensions，是Python内置的非常简单却强大的可以用来创建list的生成式

#range(1,11)迭代器,左闭右开，只有一个参数从0开始，两个参数是区间，三个参数最后一个数是跨度，不写的时候默认跨度为1
list(range(1,11)) 
--------------------
输出
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
1
2
3
4
5

#列表生成平方
[x**2 for x in range(1,10)]
--------------------
输出
[1, 4, 9, 16, 25, 36, 49, 64, 81]
1
2
3
4
5

[i for i in range(1,100) if i%10 == 0]
--------------------
输出
[10, 20, 30, 40, 50, 60, 70, 80, 90]
1
2
3
4

[str(x) for x in range(1,10)]
--------------------
输出
['1', '2', '3', '4', '5', '6', '7', '8', '9']
1
2
3
4

[int(x) for x in list("123456789")]
--------------------
输出
[1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 0]
1
2
3
4

2. Python 函数

2.1 内置函数

(1) 绝对值

abs(-1)
--------------------
输出
1
1
2
3
4

(2) 求最大值

a =[2,3,1,-4,12,6]
max(a)
--------------------
输出
12
1
2
3
4
5

(3) 求最小值

min(a)
--------------------
输出
-4
1
2
3
4

(4) 求和

sum(a)
--------------------
输出
20
1
2
3
4

2.2 自定义函数

函数function，通常接受输入参数，并有返回值

它负责完成某项特定任务，而且相较于其他代码，具备相对的独立性。

函数通常有以下几个特征：

• 使用def关键词来定义一个函数
• def后面是函数的名称，括号中是函数的参数，不同的参数用,隔开，def func():的形式是必须要有的，参数可以为空
• 使用缩进来划分函数的内容
• return返回特定的值，如果省略，返回None

(1) 使用函数时，只需要讲参数换成特定的值传给参数。

def add(x,y):
    a = x+y
    return a
1
2
3

print(add(2,3))
--------------------
输出
5
1
2
3
4

(2) Python并没有限定参数的类型，因此可以使用不同的参数类型

print(add(1,2.3))
--------------------
输出
3.3
1
2
3
4

(3) 在这个例子中，如果传入的两个参数不可以相加，那么Python将会报错

#print(add(2,'a'))  # 报错，因为参数不可以相加
print(add('2','a'))
--------------------
输出
2a
1
2
3
4
5

(4) 如果传入的参数与实际不符合，也会报错

add(1) # 报错，因为add有两个参数
1

(5) 可以在函数定义的时候给参数设定默认值，例如

def func(x,a=1,b=0,c=0):
    return a*x**2+b**x+c
1
2

func(10)
--------------------
输出
102
1
2
3
4

func(10,1,1,1)
--------------------
输出
102
1
2
3
4

(6) 一个函数也可以返回多个返回值

def f(x):
    return x**2,x**3
1
2

f(2)    # 返回元组
--------------------
输出
(4, 8)
1
2
3
4

function，通常接受输入参数，并有返回值

它负责完成某项特定任务，而且相较于其他代码，具备相对的独立性。

函数通常有以下几个特征：

• 使用def关键词来定义一个函数
• def后面是函数的名称，括号中是函数的参数，不同的参数用,隔开，def func():的形式是必须要有的，参数可以为空
• 使用缩进来划分函数的内容
• return返回特定的值，如果省略，返回None

(1) 使用函数时，只需要讲参数换成特定的值传给参数。

def add(x,y):
    a = x+y
    return a
1
2
3

print(add(2,3))
--------------------
输出
5
1
2
3
4

(2) Python并没有限定参数的类型，因此可以使用不同的参数类型

print(add(1,2.3))
--------------------
输出
3.3
1
2
3
4

(3) 在这个例子中，如果传入的两个参数不可以相加，那么Python将会报错

#print(add(2,'a'))  # 报错，因为参数不可以相加
print(add('2','a'))
--------------------
输出
2a
1
2
3
4
5

(4) 如果传入的参数与实际不符合，也会报错

add(1) # 报错，因为add有两个参数
1

(5) 可以在函数定义的时候给参数设定默认值，例如

def func(x,a=1,b=0,c=0):
    return a*x**2+b**x+c
1
2

func(10)
--------------------
输出
102
1
2
3
4

func(10,1,1,1)
--------------------
输出
102
1
2
3
4

(6) 一个函数也可以返回多个返回值

def f(x):
    return x**2,x**3
1
2

f(2)    # 返回元组
--------------------
输出
(4, 8)
1
2
3
4