Python的语法基础以及Jupyter NoteBook的使用指南
由于本人使用Jupyter更多所以就不再记录IPython的内容
2.1python解释器
Python作为解释语言,解释器同一时刻只能运行一个程序的一条语句指令。标准的Python解释器可以在命令行中输入python
命令打开:
(base) C:\Users\zhouxiaoyu>python
Python 3.7.0 (default, Jun 28 2018, 08:04:48) [MSC v.1912 64 bit (AMD64)] :: Anaconda, Inc. on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> zxy = 10
>>> zxy
10
>>>
提示输入代码,如果要推出解释器,可以输入exit()或者按Ctrl+D。
通过使用Python命令,可以把以.py
结尾的文件作为第一个参数输入,就能很方便的运行我们以及保存好的代码。例如我现在写好了一个Hello_World.py
的文件,其中内容如下:
print('Hello World !!!')
你可以通过以下命令执行这个文件(首先你的Hello_World.py
文件必须保存在终端的工作目录下):
python Hello_World.py
Hello World !!!
2.2Jupter NoteBook
notebook是Jupyter项目的重要组件,是一款交互式的文档,可以用于编写代码、文本(可带标记)、数据可视化以及其他输出内容。Jupyter notebook 与内核交互,内核是Jupyter与其他编程语言的交互编程协议。Python的Jupyter内核使用IPython系统进行内部活动。
需要启动Jupyter的时候,在命令行中输入jupyter notebook
命令:
(base) D:\Code>jupyter notebook
[I 12:22:44.759 NotebookApp] JupyterLab extension loaded from D:\anaconda\lib\site-packages\jupyterlab
[I 12:22:44.759 NotebookApp] JupyterLab application directory is D:\anaconda\share\jupyter\lab
[I 12:22:44.762 NotebookApp] Serving notebooks from local directory: D:\Code
[I 12:22:44.762 NotebookApp] The Jupyter Notebook is running at:
[I 12:22:44.763 NotebookApp] http://localhost:8888/?token=15bb843f6019a0d0daac4a1fe8f7c4fc617a293b05c65e44
[I 12:22:44.763 NotebookApp] Use Control-C to stop this server and shut down all kernels (twice to skip confirmation).
[C 12:22:45.065 NotebookApp]
Copy/paste this URL into your browser when you connect for the first time,
to login with a token:
http://localhost:8888/?token=15bb843f6019a0d0daac4a1fe8f7c4fc617a293b05c65e44
[I 12:22:45.506 NotebookApp] Accepting one-time-token-authenticated connection from ::1
Jupyter会默认自动打开浏览器。或者可以可以在启动notebook后,手动打开网页http://localhost:8888/
。图2-1展示了Edge中的notebook。
图2-1 Jupyter notebook启动页面
要新建一个notebook,点击按钮New,选择“Python3”或“conda[默认项]”。如果是第一次,点击空格,输入一行Python代码。然后按Shift-Enter执行。
图2-2 upyter新notebook页面
当保存notebook时(File目录下的Save and Checkpoint),会创建一个后缀名为.ipynb
的文件。这是一个自包含文件格式,包含当前笔记本中的所有内容(包括所有已评估的代码输出)。可以被其它Jupyter用户加载和编辑。要加载存在的notebook,把它放到启动notebook进程的相同目录内。你可以用本书的示例代码练习,见图2-3。
虽然Jupyter notebook和IPython shell使用起来不同,本章中几乎所有的命令和工具都可以通用。
图2-3 Jupyter查看一个存在的notebook的页面
Tab补全
对于已经输入的变量(对象、函数等等)会对命名空间内部的已存在的名称进行搜索,帮助用户快速完成代码编写。
除了补全命名、对象和模块属性,Tab还可以补全其它的。当输入看似文件路径时(即使是Python字符串),按下Tab也可以补全电脑上对应的文件信息。
自省
在变量前后使用问号?,可以显示对象的信息:
In [8]: b = [1, 2, 3]
In [9]: b?
Type: list
String Form:[1, 2, 3]
Length: 3
Docstring:
list() -> new empty list
list(iterable) -> new list initialized from iterable's items
In [10]: print?
Docstring:
print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
Prints the values to a stream, or to sys.stdout by default.
Optional keyword arguments:
file: a file-like object (stream); defaults to the current sys.stdout.
sep: string inserted between values, default a space.
end: string appended after the last value, default a newline.
flush: whether to forcibly flush the stream.
Type: builtin_function_or_method
使用??会显示函数的源码:
In [12]: add_numbers??
Signature: add_numbers(a, b)
Source:
def add_numbers(a, b):
"""
Add two numbers together
Returns
-------
the_sum : type of arguments
"""
return a + b
File: <ipython-input-9-6a548a216e27>
Type: function
快捷键
图2-4 IPython的标准快捷键
当然Jupyter还有很多功能,需要查看详细功能可以查询官方文档进行学习,这里就不再赘述过多。
2.3Python语法基础
python的语言十分简介,可读性比较强,更加的贴近英语语法。
使用缩进
在python中更多的会使用缩进空白字符(tab和空格)来进行代码的整理,而不是和其他语言,比如Java、C++等使用括号来区分语义。下面看一个排序算法的for循环代码:
for x in array:
if x > pivot:
less.append(x)
else:
greater.append(x)
冒号是标式代码块的开始,相同缩进的代码块表示为同执行顺序的代码段,顺序执行直到代码块结束。在我看来这样简介的缩进方式更加方便代码的阅读,经过一段时间的学习,你也会更快的适应这种代码方式的书写。
你应该已经看到,Python的语句不需要用分号结尾。但是,分号却可以用来给同在一行的语句切分:
a = 5; b = 6; c = 7
但是python并不建议这样书写,这样会降低代码的可阅读性。
万物皆对象
Python语言的一个重要特性就是它的对象模型的一致性。每个数字、字符串、数据结构、函数、类、模块等等,都是在Python解释器的自有“盒子”内,它被认为是Python对象。每个对象都有类型(例如,字符串或函数)和内部数据。在实际中,这可以让语言非常灵活,因为函数也可以被当做对象使用。
注释
任何前面带有井号#的文本都会被Python解释器忽略。这通常被用来添加注释。有时,你会想排除一段代码,但并不删除。简便的方法就是将其注释掉:
results = []
for line in file_handle:
# keep the empty lines for now
# if len(line) == 0:
# continue
results.append(line.replace('foo', 'bar'))
也可以在执行过的代码后面添加注释。一些人习惯在代码之前添加注释,前者这种方法有时也是有用的:
print("Reached this line") # Simple status report
函数和对象方法调用
你可以用圆括号调用函数,传递零个或几个参数,或者将返回值给一个变量:
result = f(x, y, z)
g()
几乎Python中的每个对象都有附加的函数,称作方法,可以用来访问对象的内容。可以用下面的语句调用:
obj.some_method(x, y, z)
函数可以使用位置和关键词参数:
result = f(a, b, c, d=5, e='foo')
变量和参数传递
当在Python中创建变量(或名字),你就在等号右边创建了一个对这个变量的引用。考虑一个整数列表:
In [8]: a = [1, 2, 3]
假设将a赋值给变量b:
In [9]: b = a
在有些方法中,这个赋值会将数据[1, 2, 3]也复制。在Python中,a和b实际上是同一个对象,即原有列表[1, 2, 3](见图2-7)。你可以在a中添加一个元素,然后检查b:
In [10]: a.append(4)
In [11]: b
Out[11]: [1, 2, 3, 4]
理解Python的引用的含义,数据是何时、如何、为何复制的,是非常重要的。尤其是当你用Python处理大的数据集时。
当你将对象作为参数传递给函数时,新的局域变量创建了对原始对象的引用,而不是复制。如果在函数里绑定一个新对象到一个变量,这个变动不会反映到上一层。因此可以改变可变参数的内容。假设有以下函数:
def append_element(some_list, element):
some_list.append(element)
然后有:
In [27]: data = [1, 2, 3]
In [28]: append_element(data, 4)
In [29]: data
Out[29]: [1, 2, 3, 4]
动态引用、强类型
与许多编译语言(如JAVA和C++)对比,Python中的对象引用不包含附属的类型。下面的代码是没有问题的:
In [12]: a = 5
In [13]: type(a)
Out[13]: int
In [14]: a = 'foo'
In [15]: type(a)
Out[15]: str
变量是在特殊命名空间中的对象的名字,类型信息保存在对象自身中。一些人可能会说Python不是“类型化语言”。这是不正确的,看下面的例子:
In [16]: '5' + 5
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-16-f9dbf5f0b234> in <module>()
----> 1 '5' + 5
TypeError: must be str, not int
在某些语言中,例如Visual Basic,字符串‘5’可能被默许转换(或投射)为整数,因此会产生10。但在其它语言中,例如JavaScript,整数5会被投射成字符串,结果是联结字符串‘55’。在这个方面,Python被认为是强类型化语言,意味着每个对象都有明确的类型(或类),默许转换只会发生在特定的情况下,例如:
In [17]: a = 4.5
In [18]: b = 2
# String formatting, to be visited later
In [19]: print('a is {0}, b is {1}'.format(type(a), type(b)))
a is <class 'float'>, b is <class 'int'>
In [20]: a / b
Out[20]: 2.25
知道对象的类型很重要,最好能让函数可以处理多种类型的输入。你可以用isinstance
函数检查对象是某个类型的实例:
In [21]: a = 5
In [22]: isinstance(a, int)
Out[22]: True
isinstance
可以用类型元组,检查对象的类型是否在元组中:
In [23]: a = 5; b = 4.5
In [24]: isinstance(a, (int, float))
Out[24]: True
In [25]: isinstance(b, (int, float))
Out[25]: True
属性和方法
Python的对象通常都有属性(其它存储在对象内部的Python对象)和方法(对象的附属函数可以访问对象的内部数据)。可以用obj.attribute_name
访问属性和方法:
In [1]: a = 'foo'
In [2]: a.<Press Tab>
a.capitalize a.format a.isupper a.rindex a.strip
a.center a.index a.join a.rjust a.swapcase
a.count a.isalnum a.ljust a.rpartition a.title
a.decode a.isalpha a.lower a.rsplit a.translate
a.encode a.isdigit a.lstrip a.rstrip a.upper
a.endswith a.islower a.partition a.split a.zfill
a.expandtabs a.isspace a.replace a.splitlines
a.find a.istitle a.rfind a.startswith
也可以用getattr
函数,通过名字访问属性和方法:
In [27]: getattr(a, 'split')
Out[27]: <function str.split>
在其它语言中,访问对象的名字通常称作“反射”。本书不会大量使用getattr
函数和相关的hasattr
和setattr
函数,使用这些函数可以高效编写原生的、可重复使用的代码。
引入
在Python中,模块就是一个有.py
扩展名、包含Python代码的文件。假设有以下模块:
# some_module.py
PI = 3.14159
def f(x):
return x + 2
def g(a, b):
return a + b
如果想从同目录下的另一个文件访问some_module.py
中定义的变量和函数,可以:
import some_module
result = some_module.f(5)
pi = some_module.PI
或者:
from some_module import f, g, PI
result = g(5, PI)
使用as
关键词,你可以给引入起不同的变量名:
import some_module as sm
from some_module import PI as pi, g as gf
r1 = sm.f(pi)
r2 = gf(6, pi)
二元运算符和比较运算符
大多数二元数学运算和比较都不难想到:
In [32]: 5 - 7
Out[32]: -2
In [33]: 12 + 21.5
Out[33]: 33.5
In [34]: 5 <= 2
Out[34]: False
要判断两个引用是否指向同一个对象,可以使用is
方法。is not
可以判断两个对象是不同的:
In [35]: a = [1, 2, 3]
In [36]: b = a
In [37]: c = list(a)
In [38]: a is b
Out[38]: True
In [39]: a is not c
Out[39]: True
因为list
总是创建一个新的Python列表(即复制),我们可以断定c是不同于a的。使用is
比较与==
运算符不同,如下:
In [40]: a == c
Out[40]: True
is
和is not
常用来判断一个变量是否为None
,因为只有一个None
的实例:
In [41]: a = None
In [42]: a is None
Out[42]: True
可变与不可变对象
Python中的大多数对象,比如列表、字典、NumPy数组,和用户定义的类型(类),都是可变的。意味着这些对象或包含的值可以被修改:
In [43]: a_list = ['foo', 2, [4, 5]]
In [44]: a_list[2] = (3, 4)
In [45]: a_list
Out[45]: ['foo', 2, (3, 4)]
其它的,例如字符串和元组,是不可变的:
In [46]: a_tuple = (3, 5, (4, 5))
In [47]: a_tuple[1] = 'four'
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-47-b7966a9ae0f1> in <module>()
----> 1 a_tuple[1] = 'four'
TypeError: 'tuple' object does not support item assignment
记住,可以修改一个对象并不意味就要修改它。这被称为副作用。例如,当写一个函数,任何副作用都要在文档或注释中写明。如果可能的话,我推荐避免副作用,采用不可变的方式,即使要用到可变对象。
标量类型
Python的标准库中有一些内建的类型,用于处理数值数据、字符串、布尔值,和日期时间。这些单值类型被称为标量类型,本书中称其为标量。表2-4列出了主要的标量。日期和时间处理会另外讨论,因为它们是标准库的datetime
模块提供的。
数值类型
Python的主要数值类型是int
和float
。int
可以存储任意大的数:
In [48]: ival = 17239871
In [49]: ival ** 6
Out[49]: 26254519291092456596965462913230729701102721
浮点数使用Python的float
类型。每个数都是双精度(64位)的值。也可以用科学计数法表示:
In [50]: fval = 7.243
In [51]: fval2 = 6.78e-5
不能得到整数的除法会得到浮点数:
In [52]: 3 / 2
Out[52]: 1.5
要获得C-风格的整除(去掉小数部分),可以使用底除运算符//:
In [53]: 3 // 2
Out[53]: 1
字符串
许多人是因为Python强大而灵活的字符串处理而使用Python的。你可以用单引号或双引号来写字符串:
a = 'one way of writing a string'
b = "another way"
对于有换行符的字符串,可以使用三引号,‘’'或"""都行:
c = """
This is a longer string that
spans multiple lines
"""
字符串c
实际包含四行文本,“”"后面和lines后面的换行符。可以用count
方法计算c
中的新的行:
In [55]: c.count('\n')
Out[55]: 3
Python的字符串是不可变的,不能修改字符串:
In [56]: a = 'this is a string'
In [57]: a[10] = 'f'
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-57-5ca625d1e504> in <module>()
----> 1 a[10] = 'f'
TypeError: 'str' object does not support item assignment
In [58]: b = a.replace('string', 'longer string')
In [59]: b
Out[59]: 'this is a longer string'
许多Python对象使用str
函数可以被转化为字符串:
In [61]: a = 5.6
In [62]: s = str(a)
In [63]: print(s)
5.6
字符串是一个序列的Unicode字符,因此可以像其它序列,比如列表和元组(下一章会详细介绍两者)一样处理:
In [64]: s = 'python'
In [65]: list(s)
Out[65]: ['p', 'y', 't', 'h', 'o', 'n']
In [66]: s[:3]
Out[66]: 'pyt'
语法s[:3]
被称作切片,适用于许多Python序列。后面会更详细的介绍,本书中用到很多切片。
反斜杠是转义字符,意思是它备用来表示特殊字符,比如换行符\n或Unicode字符。要写一个包含反斜杠的字符串,需要进行转义:
In [67]: s = '12\34'
In [68]: print(s)
12\34
如果字符串中包含许多反斜杠,但没有特殊字符,这样做就很麻烦。幸好,可以在字符串前面加一个r,表明字符就是它自身:
In [69]: s = r'this\has\no\special\characters'
In [70]: s
Out[70]: 'this\has\no\special\characters'
r表示raw。
将两个字符串合并,会产生一个新的字符串:
In [71]: a = 'this is the first half '
In [72]: b = 'and this is the second half'
In [73]: a + b
Out[73]: 'this is the first half and this is the second half'
字符串的模板化或格式化,是另一个重要的主题。Python 3拓展了此类的方法,这里只介绍一些。字符串对象有format
方法,可以替换格式化的参数为字符串,产生一个新的字符串:
In [74]: template = '{0:.2f} {1:s} are worth US${2:d}'
在这个字符串中,
{0:.2f}
表示格式化第一个参数为带有两位小数的浮点数。
{1:s}
表示格式化第二个参数为字符串。
{2:d}
表示格式化第三个参数为一个整数。
要替换参数为这些格式化的参数,我们传递format
方法一个序列:
In [75]: template.format(4.5560, 'Argentine Pesos', 1)
Out[75]: '4.56 Argentine Pesos are worth US$1'
字符串格式化是一个很深的主题,有多种方法和大量的选项,可以控制字符串中的值是如何格式化的。推荐参阅Python官方文档。
布尔值
Python中的布尔值有两个,True和False。比较和其它条件表达式可以用True和False判断。布尔值可以与and和or结合使用:
In [89]: True and True
Out[89]: True
In [90]: False or True
Out[90]: True
类型转换
str、bool、int和float也是函数,可以用来转换类型:
In [91]: s = '3.14159'
In [92]: fval = float(s)
In [93]: type(fval)
Out[93]: float
In [94]: int(fval)
Out[94]: 3
In [95]: bool(fval)
Out[95]: True
In [96]: bool(0)
Out[96]: False
None
None是Python的空值类型。如果一个函数没有明确的返回值,就会默认返回None:
In [97]: a = None
In [98]: a is None
Out[98]: True
In [99]: b = 5
In [100]: b is not None
Out[100]: True
None也常常作为函数的默认参数:
def add_and_maybe_multiply(a, b, c=None):
result = a + b
if c is not None:
result = result * c
return result
另外,None不仅是一个保留字,还是唯一的NoneType的实例:
In [101]: type(None)
Out[101]: NoneType
日期和时间
Python内建的datetime
模块提供了datetime
、date
和time
类型。datetime
类型结合了date
和time
,是最常使用的:
In [102]: from datetime import datetime, date, time
In [103]: dt = datetime(2011, 10, 29, 20, 30, 21)
In [104]: dt.day
Out[104]: 29
In [105]: dt.minute
Out[105]: 30
根据datetime
实例,你可以用date
和time
提取出各自的对象:
In [106]: dt.date()
Out[106]: datetime.date(2011, 10, 29)
In [107]: dt.time()
Out[107]: datetime.time(20, 30, 21)
strftime
方法可以将datetime格式化为字符串:
In [108]: dt.strftime('%m/%d/%Y %H:%M')
Out[108]: '10/29/2011 20:30'
strptime
可以将字符串转换成datetime
对象:
In [109]: datetime.strptime('20091031', '%Y%m%d')
Out[109]: datetime.datetime(2009, 10, 31, 0, 0)
当你聚类或对时间序列进行分组,替换datetimes的time字段有时会很有用。例如,用0替换分和秒:
In [110]: dt.replace(minute=0, second=0)
Out[110]: datetime.datetime(2011, 10, 29, 20, 0)
因为datetime.datetime
是不可变类型,上面的方法会产生新的对象。
两个datetime对象的差会产生一个datetime.timedelta
类型:
In [111]: dt2 = datetime(2011, 11, 15, 22, 30)
In [112]: delta = dt2 - dt
In [113]: delta
Out[113]: datetime.timedelta(17, 7179)
In [114]: type(delta)
Out[114]: datetime.timedelta
结果timedelta(17, 7179)
指明了timedelta
将17天、7179秒的编码方式。
将timedelta
添加到datetime
,会产生一个新的偏移datetime
:
In [115]: dt
Out[115]: datetime.datetime(2011, 10, 29, 20, 30, 21)
In [116]: dt + delta
Out[116]: datetime.datetime(2011, 11, 15, 22, 30)
逻辑控制
Python有若干内建的关键字进行条件逻辑、循环和其它控制流操作。
if、elif和else
if是最广为人知的控制流语句。它检查一个条件,如果为True,就执行后面的语句:
if x < 0:
print('It's negative')
if
后面可以跟一个或多个elif
,所有条件都是False时,还可以添加一个else
:
if x < 0:
print('It's negative')
elif x == 0:
print('Equal to zero')
elif 0 < x < 5:
print('Positive but smaller than 5')
else:
print('Positive and larger than or equal to 5')
如果某个条件为True,后面的elif
就不会被执行。当使用and和or时,复合条件语句是从左到右执行:
In [117]: a = 5; b = 7
In [118]: c = 8; d = 4
In [119]: if a < b or c > d:
.....: print('Made it')
Made it
在这个例子中,c > d
不会被执行,因为第一个比较是True:
也可以把比较式串在一起:
In [120]: 4 > 3 > 2 > 1
Out[120]: True
for循环
for循环是在一个集合(列表或元组)中进行迭代,或者就是一个迭代器。for循环的标准语法是:
for value in collection:
# do something with value
你可以用continue使for循环提前,跳过剩下的部分。看下面这个例子,将一个列表中的整数相加,跳过None:
sequence = [1, 2, None, 4, None, 5]
total = 0
for value in sequence:
if value is None:
continue
total += value
可以用break
跳出for循环。下面的代码将各元素相加,直到遇到5:
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循环仍会运行:
In [121]: for i in range(4):
.....: for j in range(4):
.....: if j > i:
.....: break
.....: print((i, j))
.....:
(0, 0)
(1, 0)
(1, 1)
(2, 0)
(2, 1)
(2, 2)
(3, 0)
(3, 1)
(3, 2)
(3, 3)
如果集合或迭代器中的元素序列(元组或列表),可以用for循环将其方便地拆分成变量:
for a, b, c in iterator:
# do something
While循环
while循环指定了条件和代码,当条件为False或用break退出循环,代码才会退出:
x = 256
total = 0
while x > 0:
if total > 500:
break
total += x
x = x // 2
PASS
pass是Python中的非操作语句。代码块不需要任何动作时可以使用(作为未执行代码的占位符);因为Python需要使用空白字符划定代码块,所以需要pass:
if x < 0:
print('negative!')
elif x == 0:
# TODO: put something smart here
pass
else:
print('positive!')
RANGE
range函数返回一个迭代器,它产生一个均匀分布的整数序列:
In [122]: range(10)
Out[122]: range(0, 10)
In [123]: list(range(10))
Out[123]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
range的三个参数是(起点,终点,步进):
In [124]: list(range(0, 20, 2))
Out[124]: [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
In [125]: list(range(5, 0, -1))
Out[125]: [5, 4, 3, 2, 1]
可以看到,range产生的整数不包括终点。range的常见用法是用序号迭代序列:
seq = [1, 2, 3, 4]
for i in range(len(seq)):
val = seq[i]
可以使用list来存储range在其他数据结构中生成的所有整数,默认的迭代器形式通常是你想要的。下面的代码对0到99999中3或5的倍数求和:
sum = 0
for i in range(100000):
# % is the modulo operator
if i % 3 == 0 or i % 5 == 0:
sum += i
虽然range可以产生任意大的数,但任意时刻耗用的内存却很小。
三元表达式
Python中的三元表达式可以将if-else语句放到一行里。语法如下:
value = true-expr if condition else false-expr
true-expr
或false-expr
可以是任何Python代码。它和下面的代码效果相同:
if condition:
value = true-expr
else:
value = false-expr
和if-else一样,只有一个表达式会被执行。因此,三元表达式中的if和else可以包含大量的计算,但只有True的分支会被执行。因此,三元表达式中的if和else可以包含大量的计算,但只有True的分支会被执行。
虽然三元表达式可以压缩代码,但是同时也会加大代码的复杂性,降低可读性。
其他关于python的详细信息大家可以阅读官方文档进一步了解。