Python语言基础（1）

    1. 基础语法

1.1 第一个Python程序

In [1]:

a = 'Hello, world!'
a

Out[1]:

'Hello, world!'

In [2]:

print(a)

Hello, world!

notebook环境下，输出变量的值或表达式的结果的方法：直接使用变量名或表达式,或print()函数

在.py文件的运行环境下，使用print()函数输出

In [3]:

a = 'Hello, world!'
print(a)

Hello, world!

1.2 import引入标准Python库

In [4]:

import os
import numpy as np
import matplotlib.pyplot as plt
from numpy.random import randn
from pandas import *

1.3 空格缩进，而不是大括号

Python编程风格，用空格缩进来表示程序块，而不是Java风格的大括号

for x in a_list:
    if x < y:
        a.append(x)
    else:
        b.append(x)

1.4 注释

用 # 号表示程序注释

In [5]:

arr = [1, -2, 3, -4, 5]
result = 0

for a in arr:
    # keep the empty lines for now
    # if a <= 0:
    #   continue
    result = result + a

2. 面向对象

2.1 一切皆为对象

Python的一切变量都是面向对象的，都有自己的属性和方法。

2.2 属性和方法

对象都已自己的属性和方法，使用对象最主要的就是使用对象的属性和方法。下面是Python最简单的数据类型字符串和整数，即便是这样简单的数据类型，也有自己的属性和方法。

In [6]:

a = 'hello'

以下调用字符串对象a的一个方法upper()，输出字符串的大写形式。

In [7]:

a.upper()

Out[7]:

'HELLO'

Python可以自定义类，并且定义类的属性和方法。这里不详细讲，后面遇到了再介绍。

3. 简单运算和数据类型

3.1 二元运算符和比较符

下面的表格列出了Python的二元运算符及其含义

运算符	说明
a + b	a加b
a - b	a减b
a * b	a乘以b
a / b	a除以b
a // b	a除以b后向下取整，丢弃小数部分
a ** b	a的b次方
a & b	如果a和b均为True,则结果为True。对于整数，执行按位与操作
a ｜ b	如果a和b任何一个为True，则结果为True。对于整数，执行按位或操作
a ^ b	对于布尔值，如果a或b为True(但不都为True)，则结果为True。对于整数，执行按位异或操作
a == b	如果3寸j b，则纟p果为True
a != b	如果a不等于b，则结果为True
a <= b、a < b	如果a小于等于（或小于）b，则结果为True
a > b、a >= b	如果a大于（或大于等于）b，则结果为Tme
a is b	如果引用a和b指向同一个Python对象，则结果为True
a is not b	如果引用a和b指向不同的Python对象，则结果为True

最简单的加减乘除四则运算符

In [8]:

5 - 7

Out[8]:

-2

In [9]:

12 + 21.5

Out[9]:

33.5

逻辑运算符。

In [10]:

5 <= 2

Out[10]:

False

Pythn有一个比较特殊的逻辑运算符：is。is用于判断两者是不是同一个对象引用。is与==的区别在于，==比较两者的值，而is比较两者的内存地址。在下面的例子中，arr1和arr2虽然值是一样的，但它们是两个不同的对象，内存地址不同。但arr3和arr1经过对象赋值，指向同一个内存地址。

In [11]:

arr1 = [1, 2, 3]
arr2 = [1, 2, 3]
arr3 = arr1

In [12]:

arr1 is arr2

Out[12]:

False

In [13]:

arr1 == arr2

Out[13]:

True

In [14]:

arr1 is arr3

Out[14]:

True

3.2 简单数据类型（标量数据）

下表列出了标准的Python的简单数据类型（标量）

类型	说明
None	Python的“null”值（None只存在一个实例对象）
str	字符串类型。Python 2.x中只有ASCII值，而Python 3中则是Unicode
Unicode	Unicode字符串类型
float	双精度（64位）浮点数。注意，这里没有专门的double类型
bool	True 或 False
int	有符号整数
long	任意精度的有符号整数。大的int值会被自动转换为long

3.2.1 数值类型

整形数据

In [15]:

ival = 9876543210
ival**6

Out[15]:

928174876062568344886276434309304233312286289266821921000000

浮点型数据

In [16]:

fval1 = 1.234
fval2 = 7.65e-4
fval1, fval2

Out[16]:

(1.234, 0.000765)

In [17]:

3 / 2    # Python3与Java不同，整型数据相除，可以得到浮点型结果

Out[17]:

1.5

In [18]:

3 // 2

Out[18]:

1

3.2.2 字符串

编写字符串时，可以用单引号，也可以用双引号

In [19]:

str1 = '这是一个字符串'
str1

Out[19]:

'这是一个字符串'

In [20]:

str2 = "another string"
str2

Out[20]:

'another string'

遇到有换行的多行字符串时，可以用三重引号

In [21]:

str3 = """
这是一个更长的字符串
有换行的字符串
换行
"""
str3

Out[21]:

'\n这是一个更长的字符串\n有换行的字符串\n换行\n'

Python的字符串是不可变的，要修改只能创建一个新的字符串

In [22]:

str2[10] = 'f'

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
 in ()
----> 1 str2[10] = 'f'

TypeError: 'str' object does not support item assignment

In [23]:

str4 = str2.replace('string', '字符串')
str4

Out[23]:

'another 字符串'

Python字符串实际上是一个字符序列。关于序列切片的知识在后面会讲到。

In [24]:

str2[1]

Out[24]:

'n'

In [25]:

str2[:3]

Out[25]:

'ano'

字符串连接

In [26]:

str1 + str2

Out[26]:

'这是一个字符串another string'

字符串的长度

In [27]:

len(str1)

Out[27]:

7

3.2.3 布尔值

布尔运算

In [28]:

True and True

Out[28]:

True

In [29]:

False or True

Out[29]:

True

Python的大部分对象都有True和False的概念，例如，空的序列就被当作False处理。

In [30]:

a = [1, 2, 3]
if a:
    print('I found something!')

b = []
if not b:
    print('Empty!')

I found something!
Empty!

用bool()函数验证对象的True or False

In [31]:

bool([]), bool([1, 2, 3])

Out[31]:

(False, True)

In [32]:

bool('Hello world!'), bool('')

Out[32]:

(True, False)

In [33]:

bool(0), bool(1)

Out[33]:

(False, True)

3.2.4 类型转换

用str()、bool()、int()和float()等函数，可以把对象的类型强制转换。

In [34]:

fval = 3.14
type(fval)

Out[34]:

float

In [35]:

int(fval)

Out[35]:

3

In [36]:

str(fval)

Out[36]:

'3.14'

3.3.5 None值

None在Python中表示空值。一个对象赋值为None，与赋值为0是不一样的。0是一个具体的值，是有特定含义的。而None表示“没有值”，所以也不能表示任何含义。在数据分析实践中，经常用None来表示数据缺失（可能是没有采集到）。

举一个例子，班上某位同学请病假没有参加考试，那么他的成绩就应该记为None，而不是0分，在计算全班平均分时这位同学不应该被计算在内。

In [37]:

a = None
a is None

Out[37]:

True

In [38]:

b = 5
b is not None

Out[38]:

True

4. 流程控制

4.1 分支结构

Python中的分支结构，采用if, elif, else等关键字实现,注意判断语句末的冒号':'。

In [39]:

x = -1
if x < 0:
    print('负数') #注意行的缩进

负数

In [40]:

x = 10

if x < 0:
    print('负数')    #注意行的缩进
elif x == 0:
    print('等于零')
elif 0 < x < 5:
    print('正数，且小于5')
else:
    print('正数，且大于或等于5')

正数，且大于或等于5

In [41]:

a = 5; b = 7
c = 8; d = 4
if a < b or c > d:
    print('Made it')  #注意行的缩进

Made it

4.2 for循环

for循环的语法结构如下，注意for语句末尾的冒号':'

for value in collection:
    #do something with value

如果集合或迭代器的元素是序列类型（比如元组或列表），那么还可以非常方便地将这些元素拆散成 for语句中的多个变量

for a, b, c in iterator:
    #do something

continue关键字使 for 循环提前进入下一次迭代（即跳过循环体代码块的剩余部分）。

In [42]:

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

Out[42]:

12

思考：在双重循环结构中，在内循环或外循环使用continue关键字，分别会得到什么结果？

break关键字用于使 for 循环完全退出。

In [43]:

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

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
 in ()
      1 lst2 = [1, 2, 0, 4, 6, 5, 2, 1]
      2 total_until_5 = 0
----> 3 for value in sequence:
      4     if value == 5:
      5         break

NameError: name 'sequence' is not defined

思考：在双重循环结构中，在内循环或外循环使用break关键字，分别会得到什么结果？

4.3 while循环

只要循环条件不为False或循环没有被break显式终止，则循环体内的代码块将一直不断地执行下去

In [44]:

x = 256
total = 0
while x > 0:
    print('total = %d' % total)
    if total > 500:
        break
    total += x
    x = x // 2
    print('x = %d' % x)

total = 0
x = 128
total = 256
x = 64
total = 384
x = 32
total = 448
x = 16
total = 480
x = 8
total = 496
x = 4
total = 504

4.4 pass关键字

空操作，有时程序中必须有一个代码块，但不用做任何操作，这时可以用pass关键字

In [45]:

x = 1
if x < 0:
    print('负数!')
elif x == 0:
    pass
else:
    print('正数!')

正数!

In [46]:

def f(x, y, z):
    # TODO: implement this function!
    pass

4.5 异常错误处理

我们在前面的Python程序运行中，出现过几次程序错误，显示一堆错误提示的情况，这就是“异常错误”。在大型软件开放实践中，优雅地处理Python错误或异常是构建健壮程序的重要环节。如果在程序中没有对异常错误进行处理，会导致程序非正常地退出运行，对业务功能造成影响。

Python异常处理的语法结构为：

try:

    程序块

except(希望捕获的异常，为空则捕获所有异常):

    捕获异常后所做的处理

finally:

    无论如何都要执行的任务

比如下面的操作，把一个abc转换为浮点类型，就会造成异常错误，造成程序运行中止：

In [47]:

print(float('abc'))
print('程序正常结束')  # 该行代码没有被执行

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
 in ()
----> 1 print(float('abc'))
      2 print('程序正常结束')  # 该行代码没有被执行

ValueError: could not convert string to float: 'abc'

In [48]:

import traceback
def try_float(x):
    try:
        return float(x)
    except: 
        return "出现异常错误！"

In [49]:

print(try_float('1.23'))
print('程序正常结束')

1.23
程序正常结束

In [50]:

print(try_float('abc'))
print('程序正常结束')

出现异常错误！
程序正常结束

有时候，我们不仅要捕获异常，还希望知道具体是什么情况导致异常发生。可以在except关键字后面加上期望捕获的异常类型：

In [51]:

def try_float(x):
    try:
        return float(x)
    except (ValueError):
        return '异常错误：ValueError'
    except (TypeError):
        return '异常错误：TypeError'

In [52]:

print(try_float('abc'))
print('程序正常结束')

异常错误：ValueError
程序正常结束

In [53]:

print(try_float([1,2,3]))
print('程序正常结束')

异常错误：TypeError
程序正常结束

在文件处理中，通常在finally模块中，关闭文件句柄，避免内存泄漏。

In [54]:

f = open('path', 'r')

try:
    f.readlines()
    print('文件处理成功')
except:
    print('文件处理失败')
finally:
    f.close()

文件处理成功

4.6 循环控制中常用的range函数

range()函数生产一组等差的整数数列，常用在循环控制中。

In [55]:

for i in range(5):
    print(i)

0
1
2
3
4

增加参数，可以设置起始值、结束值和步长

In [56]:

for i in range(0, 20, 4):
    print(i)

0
4
8
12
16

4.7 三元表达式

Python的三元表达式（ternaryexpression）允许你将产生一个值的if-else块写到一行或一个表达式中。其语法如下所示：

value = true-expr if condition else false-expr

In [57]:

x = 5
value = '非负数' if x >= 0 else '负数'
value

Out[57]:

'非负数'