Python数据分析 | (1)Python语法基础

本篇博客所有示例使用Jupyter NoteBook演示。

Python数据分析系列笔记基于:利用Python进行数据分析(第2版)  

 

目录

Python语法基础

1.语言的语义

2.函数和对象方法调用

3.变量和参数传递

4.动态引用，强类型

5.属性和方法

6.鸭子类型

7.引入

8.二元运算符和比较运算符

9.可变与不可变对象

10.标量类型

11.数值类型

12.字符串

13.字节和Unicode

14.布尔值

15.类型转换

16.None

17.日期和时间

18.控制流

19.三元表达式

---

Python语法基础

1.语言的语义

Python强调可读性、简洁和清晰。

• 语句块使用缩进而不是大括号

#排序算法的for循环

for x in array:
    if x

冒号标志缩进代码块开始，之后所有代码缩进量必须相同，直到代码块结束。

建议使用四个空格或者tab进行代码缩进。

Python语句不需要用";"结尾，但它可以在同一行进行语句切分,不建议把多条语句放在一行：

a=5;b=6;c=7

• 万物皆对象

Python中每个数字、字符串、数据结构、函数、类、模块等，都被认为是Python对象。

每个对象都有类型和内部数据。

函数也可被当作对象使用。

• 注释

单行注释是一段用“#”开头的文本，注释可以加载代码后，也可以在代码前：

print("hello world!")  #简单输出

#简单输出
print("hello world!")

也可以用“#”注释掉不想执行的代码：

for i in range(5):
    #i+=1
    print(i)

2.函数和对象方法调用

用圆括号调用函数，传递0或多个参数，或把返回值赋给一个变量：

result=f(x,y,z)
g()

Python中的每个对象几乎都有附加的函数（方法），调用形式一般为：

obj.some_method(x,y,z)

函数可以使用位置和关键词参数：

result=f(x,y,z,d=5,e='foo')

3.变量和参数传递

Python中创建变量，相当于为等号右边的部分创建了一个引用：

a=[1,2,3]
b=a  #把a赋给b 在有些语言中只是值的复制 但在Python中2者是同一个对象
a.append(4)
b

赋值也叫绑定，把一个名字绑定给一个对象。

当把对象作为参数传给函数时，新的局部变量创建了对原始对象的引用而不是复制：

def append_element(some_list,element):
    some_list.append(element)
data=[1,2,3]
append_element(data,4)
data

 

4.动态引用，强类型

和许多编译语言（c，java）不同，Python的对象引用不包含附属类型：

a=5
print(type(a))
a='foo'
print(type(a))

变量是特殊命名空间中对象的名字，类型信息和具体的值保存在对象自身中。

Python是强类型化语言，即每个对象都有明确的类型，默认的转换之发生在特定情况下：

'5'+5  #字符串和数字不存在默认的类型转换

a=2
b=2.5
print('a is {0},b is {1}'.format(type(a),type(b)))
b/a    #int类型向上转型为float  再运算  结果为float

知道对象类型很重要，最好让函数能处理多种类型的输入。

可以用isinstance检查对象属于什么类型：

a=5
print(isinstance(a,int))

a=5;b=4.5
print(isinstance(a,(int,float)))  #也可以检查对象 是否在类型元组中
print(isinstance(b,(int,float)))

5.属性和方法

Python的对象一般都有属性（存储在对象内部的Python对象）和方法（对象的方法可访问对象内部数据）。

调用形式：

obj.attribute_name. 
obj.some_method(x,y,z)

a='foo'
a.          #查看对象a的属性和方法 tab

也可以通过getattr函数，通过名字访问对象的属性和方法：

getattr(a,'split')

6.鸭子类型

我们可能不关心对象的类型，只关心它是否有某些属性或方法，成为鸭子类型。

比如：验证一个对象是否可迭代，即它是否有一个__iter__的方法，可使用iter函数判断是否可迭代：

def isiterable(obj):
    try:
        iter(obj)
        return True   #对象可以迭代
    except:
        return False  #不可以迭代
#字符串对象和大多数Pyhton集合对象 都是可迭代的
print(isiterable('a string'))
print(isiterable([1,2,3]))
print(isiterable(5))

一般用这个功能编写可以接收多种输入类型的函数。

比如：编写一个函数可以接受任意类型的序列（列表，数组，元组等）或迭代器，可以先检验对象是否是列表，不是转换为列表：

if not is instance(x, list) and isiterable(x):
    x=list(x)

7.引入

Python中模块就是包含Python代码的文件，有.py的扩展名。

如：以下这个模块

#some_module.py
PI=3.14

def f(x):
    return x+2

def g(a,b):
    return a+b

在同目录下另一个文件访问some_module.py中定义的变量和函数：

import some_module
res=some_module.f(5)
pi=some_module.PI

或者：

from some_module import f,g,PI

res=g(5,PI)

使用as可以给引入更名，是名称更简洁：

import some_module as sm
form some_module import PI as pi,g as gf

r1=sm.f(pi)
r2=gf(6,pi)

8.二元运算符和比较运算符

print(5-7)
print(12+22.5)
print(2>=5)

用is/is not可以判断两个引用是否指向同一个对象：

a=[1,2,3]
b=a
print(a is b)
c=list(a)  #list()创建一个新的列表对象 即只是值的复制
print(a is c)
print(a is not c)

is比较和==比较是不同的：

print(a is c)  #比较两个引用是否指向同一个对象
print(a==c)  #比较两个引用内部的数值是否相等

is/is not常用来判断一个变量是否为None：

a=None
a is None

9.可变与不可变对象

Python中大多数对象如列表、数组、字典，自定义的类都是可变的，即这些对象或包含的值可以被修改：

a_list=[2,3,'foo',(3,4)]
a_list[3]=[3,4]
a_list

典型的字符串和元组是不可变的：

a_tuple(2,3,(4,5))
a_tuple[1]='foo'  #报错

10.标量类型

Python用于处理数值数据、字符串、布尔值和日期时间的内建类型，叫单值/标量类型。

11.数值类型

主要类型int和float。

与其他语言不同，Python的int可以存储任意大的数：

ival=1234567
ival**6

float类型都是双精度（64位）的值：

fval=1.23
fval1=5.76e-5 #科学计数法

不能得到整数的除法得到浮点数：

print(3/2)
print(3//2) #地板除法 c语言中的除法 向下取整

12.字符串

可以用''或""包括，有换行符的字符串用三引号'''或"""包括：

a='string s1'
b="string s2"

c="""
this is a longer string that
spans multiple lines
"""

c中有四行文本，统计c中的换行符：

c="""
This is a longer string that
spans multiple lines
"""
c.count('\n')

Python的字符串不可变：

a='this is a string'
a[10]='f'  #报错

a='this is a string'
b=a.replace('string','longer string')
print(b)
print(a) #a的值并没有变

许多Python对象可以用str()转化为字符串：

a=5.6
s=str(a)
s

字符串是字符的序列，可以像其他序列，如列表、元组等一样处理：

s='python'
print(list(s))
print(s[0])  #取值
print(s[:3]) #切片

反斜杠可以用来转义：

#输出带有反斜杠的字符串
s='12\\34'
print(s)
s=r'this\is\a\string'  #如果一个字符串有很多\，但没有一个是特殊字符 可以加一个r 表示就是字符串自身
s

字符串合并：

a='first string! '
b='second string'
a+b

字符串对象的format方法：

template='{0:.2f}{1:s} are worth USDollar${2:d}'.format(4.5560,'AP',1)
template

13.字节和Unicode

将unicode字符串编码成utf-8字节格式

val='español'
print(val)
val_utf8=val.encode('utf-8') #把unicode字符串 编码成utf-8字节文本 encode编码
print(val_utf8)
print(type(val_utf8))
val_utf8.decode('utf-8')  #decode 解码 将字节文本解码成字符串

将unicode字符串编码成其他字节格式：

print(val.encode('utf-16'))
print(val.encode('utf-16le'))

字符串前加b表示字节文本：

bytes_val = b'this is bytes'  #字节文本
print(bytes_val)
decoded=bytes_val.decode('utf-8')  #解码成unicode string
print(decoded)

14.布尔值

布尔值只有True和False。

条件表达式和比较用True和False判断。

布尔值可以与and or结合使用

True and True,False or False

15.类型转换

 str、float、int、bool这些函数可用来转换类型：

s='3.14'
fval=float(s)
print(type(fval))
print(int(fval))
print(bool(fval))  #非0True
bool(0)  #0False

16.None

Python空值类型，一个函数如果没有明确的返回值，则默认返回None：

a=None
print(a is None)
b=5
print(b is not None)

None经常作为函数的默认参数：

def add_maybe_multiply(a,b,c=None):
    res=a+b
    if c is not None:
        res*=c
    return res

None是唯一的NoneType实例：

17.日期和时间

Python内建的datetime模块提供了datetime、date和time类型。

datetime是date和time的结合，最常使用：

from datetime import datetime,date,time
dt=datetime(2018,11,10,14,20,31) #创建一个时间和日期的实例
print(dt)
print(dt.day)  #取天数
print(dt.hour) #取小时数
print(dt.date()) #取出date对象
print(dt.time())  #取出time对象
print(dt.strftime("%m/%d/%Y %H:%M")) #日期转换成字符串
print(datetime.strptime('20091031','%Y%m%d'))  #字符串转换日期

格式化命令：

聚类或对时间序列进行分组时，替换datetime的time字段很有用，如用0替换秒和分：

dt.replace(minute=0,second=0)  #datetime类型不可变 dt是不变的  此时会返回一个新的对象

两个datetime对象做差，产生datetime.timedelta对象：

dt2=datetime(2018,12,11,11,11)
delta=dt2-dt
print(delta)
print(type(delta))
print(dt2)
print(dt+delta)

18.控制流

• if、elif和else

if x<0:
    print('negative')

一个if后可跟多个elif,所有条件都是False，还可以添加一个else：

if x<0:
    print('negative')
elif x==0:
    print('zero')
elif 0=5')

某个条件为True，后面elif就不会执行。

使用and和or时，复合条件语句从左至右执行。

短路效应：如果前面一个条件已经满足，后一个就不会再执行判断了：

a=5;b=7
c=8;d=4
if ad:  #c>d不会执行  a

比较式可以连写：

• for循环

for循环在一个集合（列表、元组等）或i 个迭代器中进行迭代：

for value in collection:
    do sth

continue可以跳过for循环剩下的部分，进入下一次循环：

sequence = [1, 2, None, 4, None, 5]
total = 0
for value in sequence:
    if value is None:
        continue
    total += value
total

break可以跳出for循环：

sequence = [1, 2, 0, 4, 6, 5, 2, 1]
total_until_5 = 0
for value in sequence:
    if value == 5:
        break
    total_until_5 += value

break只能中断最内层的for循环，其余for循环仍会运行：

for i in range(4):
    for j in range(4):
        if j>i:
            break
        print((i,j))

如果集合或迭代器中的元素是元组或列表，可以用for把它拆分为变量：

for a,b,c in iterator:
    do sth

• While循环

指定条件和代码块，只有当条件为false，或使用break时，才会退出：

 x = 256
  total = 0
  while x > 0:
      if total > 500:
          break
      total += x
      x = x // 2

• pass

非操作语句，代码块不需要任何动作时可以使用：

if x<0:
    print('negative')
elif x==0:
    pass
else
    print('positive')

• range

返回一个迭代器：

print(range(10))  #均匀分布的整数序列
print(list(range(10)))
print(list(range(0,20,2))) #三个参数 起点 终点（不包括） 步长（默认为1）
print(list(range(5,0,-1))) #负步长 相反方向

range常用于用序号迭代序列：

seq=[1,2,3,4]
for i in range(len(seq)):
    print(seq[i])

for i in seq:
    print(i)

sum = 0
for i in range(100000):
      # % is the modulo operator
      if i % 3 == 0 or i % 5 == 0:
            sum += i

19.三元表达式

把if-else语句放在一行中 ：

 value = true-expr if condition else false-expr

true-expr和false-expr可以是任何Python语句。

等价于：

  if condition:
      value = true-expr
  else:
      value = false-expr

x=5
"negative" if x<0 else 'positive'

三元表达式可以压缩代码，但是降低了可读性。