第二课 初识Python & 变量的故事

一 Python与PyCharm的安装

1 关于版本

学习Python目前有两个版本可选,Python 2.x和Python 3.x(http://wiki.python.org/moin/Python2orPython3上有较详细的介绍),Python 2.x已经停止开发,最后一个版本为Python 2.7.5,虽然已经停止开发,但这个版本目前应用得最为广泛,Rhino5上的Python版本便是Python 2.7.x(因为IronPython还没有更新到Python 3.x)。Python 3.x的开发代号为Python 3000,相对于Python 2.x有较大的升级,而且并不向下兼容(有一个2to3的脚本,但大部分情况下都不太好用) ,是Python社区目前主要维护的版本和未来的开发方向。虽然Python 3.x目前的第三方库并不丰富,但Python 3.x的改变是朝向更为简洁、更易理解和更为准确的方向,而且相对于最新的Python 2.7.x如Rhino5上的Python 2.7.x,语法和基本库上矛盾的地方不多(从Python 2.6.x开始,开发组就考虑了用户向Python 3.x的过渡),本教程以Python基于目前最新版Python 3.3.2(2013.07.**),因为很多同学学习Python的目的是使用Rhino.Python,因此遇到语法特别之处我会指出。

2 下载和安装Python

如果你使用的是今年发布的Mac OS X操作系统的苹果电脑或者Ubuntu、Red Hat、openSUSE等主流的Linux操作系统,系统里已经预装好了Python 3.x,如果你使用的是Windows 操作系统,你需要下载一个Python副本安装到系统当中,如果你想在Android平板或者Ipad上学习Python那也是可以的,你可以下载Python for IOS和Python for Android。同样还有Sun Solaris、AS/400、BeOS等非主流平台上的版本。因此Python是一个跨平台的计算机语言,一次编写,随处可用,但本教程将基于Windows 7系统。Windows、Mac OS X和Linux用户可在http://www.python.org/getit/下载最新的Python版本(初学者不建议到其他地方下载山寨版,除非有特殊需要),同时也提供了源代码下载,用户可自己编译。

Windows用户下载以下页面当中的前两项,其中64位系统最好下载第二项,32位系统用户最好下载第一项。然后一路下一步即可,其中在安装组件选择页面可勾选最后一项,设置系统变量,Python将默认安装在C:\Python33目录下,建议不要更改(方便IDE识别到Python安装的位置),还可以在同一个系统下安装多个版本的Python,这些版本互不冲突。

clip_image002clip_image004

Python3.3.2 安装包选择与安装界面

clip_image006

添加系统路径

clip_image008安装完成之后,在Python开始程序目录下(用Windows8的同学估计只有到安装目录下去找)如右图的一些文件,其中IDLE是一个交互式的代码编辑器,是Python初学者最主要使用的编辑器,基于自带图形库TK GUI,另外一个编辑器(Python command line)是一个命令行下的编辑器,不建议使用,并且,这里还有一些用户文档和Pydoc的模块引擎。

IDLE(以下简称Shell)是一个可见即可得的Python文本编辑器,具有简单的语法高亮功能(程序内置函数,特殊字符等用不同颜色予以显示),虽然它并不太好用,对于管理项目来说不免麻烦了点,但Shell提供了不错的交互式编程环境,而且具有完整的Debug功能,是一个不错的探索Python的互动环境。

请尝试一下在Shell中输入一些东西,然后按下回车(一次只能输入一行代码),例如输入一个数值,它将返回一个数值,输入一个有效的计算式,可以返回一个值,输入一个字符串。返回一个字符串(字符串必须加上引号),或者随便输入一些字母符号,如果不是运气够好的话,一般会返回一个错误,如下:

Python 3.3.2 (v3.3.2:d047928ae3f6, May 16 2013, 00:06:53) [MSC v.1600 64 bit (AMD64)] on win32

Type “copyright”, “credits” or “license()” for more information.

>>> 123

123

>>> 1*5+6-(2/3)

10.333333333333334

>>> ‘love’

‘love’

>>> asdfa

Traceback (most recent call last):

File “<pyshell#3>”, line 1, in <module>

asdfa

NameError: name ‘asdfa’ is not defined

>>> ‘sdfdf’*‘sdfdf’

Traceback (most recent call last):

File “<pyshell#4>”, line 1, in <module>

‘sdfdf’*‘sdfdf’

TypeError: can’t multiply sequence by non-int of type ‘str’

>>>

clip_image010

从上面的例子可以看出Python并不是智能的语言,所有的输入都必须遵循一定的语法它才能理解并按之正确的执行。以上的两个错误都属于静态错误,前者是语法错误,即“asdfa”是一个并不存在的语法定义,后一个是静态语义错误,即语言意义上的错误,两个字符串是无法相乘的(但在Python中字符串和数值是可以相乘的),除此之外,另一种错误是动态错误,在程序执行过程中出现的错误,一个优秀的IDE很容易识别出程序员所犯的静态错误,但动态错误难以识别,甚至有些时候可以通过编译,便形成了一个程序的Bug,程序语言的语法有些时候相当苛刻,而有的时候却大而化之,例如Python允许字符串和数值相乘,但一个优秀的程序员一定会有一个良好的编程风格,不会在自己代码中带有太多有歧义的东西,我们在后面的过程中再来慢慢的学习这些东西。

Shell中的优秀交互功能还包含了即时的帮助功能,输入help()或help(object)来获得编程过程中遇到的问题。例如我们输入help(print)可获得print()函数的相关说明,包含了函数的参数,缺省值,输入和返回值的数据类型等,如果你还不懂这些,没关系,往下学就行了。如果你输入的是一个Python标准库中不存在函数、模块或关键字,将返回一句语法错误。

输入help()之后,注意提示符从>>> 改变为 help>,进入交互帮助模式,在该模式下是无法进行程序本身的编写的,例如定义一个变量,创建一个函数等,在help>什么也不输入直接回车即可退出帮助交互模式。

>>> help

Type help() for interactive help, or help(object) for help about object.

>>> help()

Welcome to Python 3.3! This is the interactive help utility.

If this is your first time using Python, you should definitely check out

the tutorial on the Internet at http://docs.python.org/3.3/tutorial/.

Enter the name of any module, keyword, or topic to get help on writing

Python programs and using Python modules. To quit this help utility and

return to the interpreter, just type “quit”.

To get a list of available modules, keywords, or topics, type “modules”,

“keywords”, or “topics”. Each module also comes with a oneline summary

of what it does; to list the modules whose summaries contain a given word

such as “spam”, type “modules spam”.

help> print

Help on builtin function print in module builtins:

print(…)

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 filelike 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.

help> asdfggf

no Python documentation found for ‘asdfggf’

在Shell新建窗口中进行,这里我们可以一次输入多行代码,然后按F5返回Shell并运行。现在我们来学习刚才的print()函数,这个函数在Python3.x中做了巨大的改变,在Python2.x中print是一个语句,例如写一个hello world程序直接是使用print ‘hello world’即可,而在Python3.x中print变为一个函数,必须加上()并在内传递一个合法的参数才可以将其显示出来。现在我们尝试一下在Shell中写hello world程序和做一些其他的尝试,以下代码本次教程附件文件中的1_print exercise.py。

clip_image012

## 打印‘Hello world!’

print(‘Hello world!’)

## 打印出数值与字符串组合

print(‘I am’,25,‘years old.’)

## 打印出两个数值

print(2,3)

## 打印出一个数组

print((2,3))

## 不换行即打印下一个数据

print(‘Hello world!’,end=)

print(‘Hello world!’)

>>> ================================ RESTART ================================

>>>

Hello world!

I am 25 years old.

2 3

(2, 3)

Hello world!Hello world!

>>>

在这段代码中我们可以看到“## 打印出两个数值”这样的描述,这是一行注释,注释是对程序中某些部分的注解,不会影响程序进行,主要帮助程序员对代码的理解和控制,Python中的单行注释一般使用“#”(个人习惯采用两个##,这没有任何影响),多行注释可用”’ ”’(各三个单引号)把注释内容包起来。另一个就是采用中文的问题,Python默认采用UTF-8编码,可用任意使用中文,甚至是中文变量,但为了养成良好习惯我们一般在第一行处可加上,这样我们在Rhino.Python中就不会遇到问题。

#-*- coding:utf-8 -*-

>>> 世界您好 = ‘Hello world!’

>>> print(世界您好)

Hello world!

3 PyCharm的安装和使用

要使用Python来编写程序,自带的Shell并不算好,目前优秀的语言编辑器(以下简称IDE,即语言集成开发环境)能够智能输入补充,高亮语法、变量和各种关键字、静态错误自动判断等,http://wiki.python.org/moin/IntegratedDevelopmentEnvironments这个页面有一个Python目前可用的IDE清单,其中JetBrains PyCharm、NetBeansWing IDE、Eclipse比较推荐,我使用的是JetBrains PyCharm 2.6.3。使用搜索引擎搜索这个IDE很容易找到。

在安装完成PyCharm后第一次通过一个Welcome页面设置,设置代码高亮样式和显示风格,我个人偏向使用的是Eclipse代码样式,twlight显示风格。

clip_image014

设置完成后,PyCharm的整个外观如下,整个IDE可分为五个部分,1菜单区,包含如项目建立,管理,程序设置,debug,版本管理等等;2 主要工具栏,包含文件打开储存,程序运行等;3 项目文件管理;4 代码部分;5程序辅助区,错误提示,项目结构管理,debug辅助等等。当然这些窗体如图Rhino一样并不是一成不变的,可以自己按偏好调整。

clip_image016

PyCharm强大但功能复杂,作为我们初学者而言并不需要用到大部分的功能,我们最需要的是在写代码时的一系列代码补全,错误提示,自动错误修正建议等功能。如下:

clip_image018

变量补全

clip_image020

导入库名字补全

clip_image022

自动错误提示

在File-setting下面有一系列需要我们注意的地方,首先如果第一次通过欢迎页面设置的显示效果令你不满,可以再Code Style下重新设置整个显示风格。另外在Project Interpreter下我们可以管理多个版本的Python。

clip_image024 clip_image026

clip_image028

现在我们用PyCharm来运行我们第一个真正意义上的程序,代码如下,见课程附件文件中的2_smile.py,相比起前面的Hello World,这算是一个完整的程序,它导入了Python标准库中的tkinter GUI模块,这是一个比较简单的程序界面开发和二维绘图库,用它来绘制一个经典笑脸并显示Hello World,并且可以在画布上用蓝色笔自由绘制,你可以修改里面的一些参数结果将会发生变化。程序结构详见注释。作为初学者而言,这里面的内容可能你大部分不懂,没有关系,这或许是你第一个直接从代码运行的程序,我的第一个程序也相当弱智,大概用了两个星期四次上机课的时间用LOGO语言绘制了一只虫子在爬,让我们从一个笑脸开始来正式学习Python编程。

#-*- coding:utf-8 -*-

__author__ = ‘Wang Dachuan @ChongQing Univercity’

__copyright__ = ‘<共享,非商业,署名>’

## 导入tkinter GUI模块

from tkinter import *

## 定义变量

lastx, lasty = 0, 0

## 绘制笑脸

def addFace():

canvas.create_arc(154.04, 70.23, 245.96, 162.16, start=0,extent=-180,width=6,style=ARC)

canvas.create_oval(122.22, 38.41, 277.78, 193.98, width=6,)

canvas.create_oval(163.73, 77.10, 176.01, 89.37, width=3,fill=‘black’)

canvas.create_oval(223.99, 77.10, 236.27, 89.37, width=3,fill=‘black’)

## Hello world文字部分

def addWord():

word = ‘Hello world!’

canvas.create_text(199.67, 240.92,text=word ,font=‘Helvetica -36 bold’)

## 画笔绘图部分

def addLine(event):

global lastx, lasty

x, y = canvas.canvasx(event.x), canvas.canvasy(event.y)

canvas.create_line((lastx, lasty, x, y), fill=‘blue’, width=2, tags=‘currentline’)

lastx, lasty = x, y

def xy(event):

global lastx, lasty

lastx, lasty = canvas.canvasx(event.x), canvas.canvasy(event.y)

## 创建窗口,在窗口中调用之前的绘图和文字部分

root = Tk()

root.title(‘Hello world!’)

canvas = Canvas(root,width=400,height=350)

canvas.grid(column=0, row=0, sticky=(N, W, E, S))

canvas.bind(addFace())

canvas.bind(addWord())

canvas.bind(“<Button-1>”, xy)

canvas.bind(“<B1-Motion>”, addLine)

root.mainloop()

 

clip_image030

二 变量的故事

1变量的定义

程序语言中的变量与我们之前政治生物所学的用于对研究对象进行定量稍有不同,也没有自变量、因变量之分。程序语言中的变量很好理解,就是程序语言运行时储存在计算机内存中的,且值可修改的一个储存空间。如下图,在程序运行时,将为一个变量分配一个内存单元,在用到这个变量时,将调用这个内存单元中的值。内存地址是通过变量名联系起来的。

clip_image032

一般来说变量具有以下的属性:

• 数据类型:变量所储存的数据具有类型特征,例如数值、字符串

• 名字/别名:变量允许是空值,但必须有一个名字(或称作标识符),如果用名字去传递一个变量,那个这个变量就具有一个别名,例如下面代码片段中,变量b即是a的别名,它们都指向内存中的同一个地址。

a = 10

b = a

print(b)

• 存储属性:存储该变量的存储器类型,例如自动型、静态型、寄存器型、外部型,一般同的语言具有不同的变量存储类型。

• 生命周期:该变量的存在时间,当该变量不再使用时,其先前所占用的内存空间将回收

• 作用域:变量的有效区域,分为全局变量或局部变量。例如在Python中以下一段代码将报错,因为a这个变量是Variable()子函数中的局部变量。

def Variable():

a = 10

print(a)

Variable()

print(a)

————————————–

NameError: name ‘a’ is not defined

Process finished with exit code 1

变量的命名规则:

• 变量的名字只能由字母、数值和下划线三类字符构成,且首个字符必须是字母或下划线,例如a1是合法的变量名,而1a则是不合法的变量名

• 变量名具有大小写之分,A和a是两个不同的变量名字

• 变量名具有255位字符长度的限制

• 在变量所处的作用域内

• 对于Python而言,其有一系列内置的关键字,这些关键字不能作为变量名

False class finally is return

None continue for lambda try

True def from nonlocal while

and del global not with

as elif if or yield

assert else import pass

break except in raise

以上内容就不多介绍,这些底层的知识需要你在后续学习中慢慢理解,现在看得越多反而越晕,初学者需要了解的便是,变量是a=10这个整体,而不是a,它是计算机中内存单元在语言中的抽象,是编程语言中最基本的概念,它具有以上一些基本的属性,这些属性在Python大部分时候都是自动实现的,并不需要我们进行特别的定义,需要注意的是变量命名的规则和其适用的代码范围,下面我们来看Python中的基本数据类型。

2 Python中的基本数据类型

在当代计算机语言的概念当中,一切皆为对象,从基本数值、字符串到函数、类、模块都可以理解为数据类型,对于一些处理特定问题的编程语言来说,数据内型的概念更是丰富多样,例如RhinoPython中的点、线、面都属于数据类型。数据类型的存在是因为不同类型的数据可以做不同的事,例如数值可以做加减乘除,而字符串则不能。作为编程的初学者,我们需要理解程序语言最基本的一些数据类型,对于Python而言,以下数据类型是必须理解的:

① Number数值型 123(整数), 2.0(浮点数), 0.2345(浮点数), math.pi(三角函数), Fraction(2, 3)(分数)

② String字符串型 ‘love’, ‘Chongqing University’

③ Booleans布尔型 True, False

③ Bytes字节型

④ 数据集合 包括:元组、列表、集合、字典等

2.1 数值型数据

讲第一种数据类型之前先比较一下VB语言,VB这类需要声明变量类型的语言用数值简直是可畏的,数值分为整数和实数,整数又分为整型和长整型、实数分为单精度型和双精度型,在创建一个数值变量时,必须声明它的类型,例如 Dim a as Int,就声明了一个整数变量,如果需要有小数,则要用到 Dim a as Double,而在Python中,变量是无需声明的,Python帮你搞定一切,在程序运行时,它会自动识别数据类型,自动进行数据间的转换,像VB这类语言需要强制定义变量类型,称作静态类型语言。Python这类无需定义变量类型的语言称作动态类型语言,虽然这一定程度上有损运行速度,但这就是Python异常简洁,适合初学者学习的特点之一。

Python中的基本数值类型包含整数、浮点数和其他数值,通过小数点进行区分,也可利用特殊的函数相互转换。请看以下例子(位于3_number.py):

## 创建一个整数变量

a = 1

## 创建一个浮点数变量

b = 3.5

## 整数与浮点数相加,用type()函数取得该变量类型

c = a + b + b

print()

print(‘c=’,c,‘c的类型’,type(c))

## 整数转换成浮点数

d = float(a)

print(‘d=’,d,‘d的类型’,type(d))

## 浮点数转换成整数

e = int(b)

print(‘e=’,e,‘e的类型’,type(e))

>>> ================================ RESTART ================================

c= 8.0 c的类型 <class ‘float’>

d= 1.0 d的类型 <class ‘float’>

e= 3 e的类型 <class ‘int’>

可以看到,当Python遇到一个整数型数值和浮点数型数值进行运算时,会将整数自动转换为浮点数进行预算,然后结果返回一个浮点数类型c=8.0,可以通过int()函数和float()函数强制将数值转换为整数和浮点数,当浮点数转换为整数时,并不是四舍五入的法则,而是砍掉小数部分,例如int(3.2) = 3,int(-2.8) = -2。

就我经验,取整在参数化建模的一些过程中也常常用到,下面来看看这些函数(4_quzheng.py):

from math import *

a = 1.5

b = 1.5

c = 1.3

d = 1.7

e = 1.3

## int取整直接砍掉小数部分

print(‘int函数结果:a=’,int(a),‘ b=’,int(b),‘ c=’,int(c),‘ d=’,int(d),‘ e=’,int(e))

## round函数四舍五入,可用一个参数选择保留小数点位数,如round(a,1)将返回1.5

print(’round函数结果:a=’,round(a),‘ b=’,round(b),‘ c=’,round(c),‘ d=’,round(d),‘ e=’,round(e))

##floor取小于或等于该数的最大整数

print(‘floor函数结果:a=’,floor(a),‘ b=’,floor(b),‘ c=’,floor(c),‘ d=’,floor(d),‘ e=’,floor(e))

>>> ================================ RESTART ================================

int函数结果:a= 1 b= -1 c= 1 d= -1 e= -1

round函数结果:a= 2 b= -2 c= 1 d= -2 e= -1

floor函数结果:a= 1 b= -2 c= 1 d= -2 e= -2

其他数值类型包括分数、pi、随机数和复数等,抱歉复数的知识我差不多搞忘了,这些也不太常用,简单看一下(5_other number.py):

## 导入分数、数学和随机模块

from fractions import *

import math

import random

##定义分数与分数运算

x = Fraction(1, 3)

y = Fraction(2, 3)

z = x * y

print(‘z=’,z)

##三角函数,随机数等

a = math.pi/2

b = random.random()

c = random.choice([5,3,6,1])

print(‘a=’,a,‘ b=’,b,‘ c=’,c)

##复数为实数部分和虚数部分构成,real + imag(J/j后缀),是j不是i

aComplex = 3 + 2j

bComplex = 3 + 2j

cComplex = aComplex*bComplex

print(‘cComplex=’,cComplex)

>>> ================================ RESTART ================================

z= 2/9

a= 1.5707963267948966 b= 0.9468646011445573 c= 1

cComplex= (5+12j)

2.2 字符串型数据

字符串是用来记录文本信息的一系列字符的集合,需要注意的是,定义一个字符串时,必须用”单引号将其引起来,这是Python用来区分字符串与数值和变量名的。字符串严格意义上来说与数值无法相互操作或转换,但在Python中也允许将字符串与整数相乘,将纯数字的字符串转换为数值,这也是许多老派程序员不喜欢Python 的地方。在Shell中来看下面的例子。

>>> a = ‘love’

>>> b = 4

>>> a + b

Traceback (most recent call last):

File “<pyshell#3>”, line 1, in <module>

a + b

TypeError: Can’t convert ‘int’ object to str implicitly

>>> a * b

‘lovelovelovelove’

>>> c = ‘1.45’

>>> c + b

Traceback (most recent call last):

File “<pyshell#6>”, line 1, in <module>

c + b

TypeError: Can’t convert ‘int’ object to str implicitly

>>> float(c)+b

5.45

字符串的基本操作如下:

• len()函数取得字符串的长度

• str[x]:x为正时,用来取得该字符串中的第x+1个字符,x从0开始计数,x为负时,用来取得该字符串中的倒数第/x/个字符,x从-1开始计数

• str[x:y]:通过一个切片取值(都为负值时较大值在右边)

• max()和min()找到ASCII编码中字符串中的最大字符和最小字符

• str.index()找到某字符的索引位置,为str[x]的反向操作

• str.count()统计某个字符出现的次数

例如(6_string.py):

city = ‘Chongqing’

##len()函数取得字符串的长度

print(len(city))

##str[x]:x为正时,用来取得该字符串中的第x+1个字符,x从0开始计数

##x为负时,用来取得该字符串中的倒数第/x/个字符,x从-1开始计数

print(city[0],city[5])

print(city[-1],city[-3])

##str[x:y]:通过一个切片取值,负值时较大值在右边

print(city[0:5])

print(city[-3:-1])

##max()和min()找到ASCII编码中字符串中的最大字符和最小字符

print(min(city))

print(max(city))

##str.index()找到某字符的索引位置,为str[x]的反向操作

print(city.index(‘n’))

##str.count()统计某个字符出现的次数

print(city.count(‘g’))

>>> ================================ RESTART ================================

9

C q

g i

Chong

in

C

q

3

2

2.3 布尔类型

布尔是一种逻辑数据,它只有真(True )和假(False )两种原始类型,布尔数据来源于逻辑代数这一同属于逻辑学和数学分支的学科,我们目前使用的计算机的一切运算便是基于布尔值之间的五种基本运算(与、或、非、与非、或非),(未来可能出现的量子计算机则是基于量子理论,到时候必然有全新的编程语言和算法逻辑出现,朋友们以后也一定要跟上时代步伐)。

绝大部分程序语言用True和非零来代表真,用False和0来代表假, 在Python中也是如此,注意首字母大写,例如可以用While 1或While True来表达一个恒为真的条件,用While 0或While False来表达一个恒为假的条件。

while 1:

print(‘True’)

break

while 0:

print(‘False’)

break

>>> ================================ RESTART ================================

>>>

True

>>>

在Python中对于布尔值的相互运算有and、or、not三种基本运算符号,分别代表与,或,非,高中数学应该学过,当两个条件同为True时,使用and运算返回True,其他情况返回False,不多介绍,请在Shell中尝试一下:

>>> True and True

True

>>> True and False

False

>>> True or False

True

>>> False or False

False

>>> not True

False

>>> not (True and False)

True

数值类型和字符串类型的对比也将返回布尔值;布尔在编程语言中通常用来判断某一条件是否成立,如果成立则执行相应的代码,如果不成立则执行另外的代码。请看下面例子(7_bool.py):

x = 12.4

y = 12.3

##符号’==’用于判断两个数是否相等,这条语句的result=False,注意和赋值符号=的区别,这里用的两个“=”

print(x==y)

##这条语句的result = True

x= 12.3

print(x == y)

##符号’!=’用于判断两个数是否不相等,这条语句的result=False

print(x != y)

a = 12

b = 14

##符号’>=’用于判断a是否大于等于b,这条语句的result=False

print(a >= b)

##符号'<=’用于判断a是否小于等于b,这条语句的result=True

print(a <= b)

##符号’>’用于判断a是否大于b,这条语句的result=False

print(a > b)

##符号'<‘用于判断a是否小于b,这条语句的result=True

print(a < b)

##也可以对两个字符串进行大小的判断,判断的依据是该字符串首字母在ASCII码的位置靠前靠后

a= ‘aaa’

b= ‘bbb’

print(a > b)

print(a < b)

>>> ================================ RESTART ================================

>>>

False

True

False

False

True

False

True

False

True

>>>

Python中的布尔值True和False也可以直接当作1和0进行数值运算,当然这是所有程序员都不推荐使用的,这会导致代码混乱和理解混乱。

>>> True*True

1

>>> (True+True)**10

1024

>>> True/True

1.0

>>> True+3

4

>>> False *1000

0

>>> False / 5

0.0

>>> True/False

Traceback (most recent call last):

File “<pyshell#6>”, line 1, in <module>

True/False

ZeroDivisionError: division by zero

>>>

oops!!最后一句报错,千万别用一个数除以零。

2.4 Bytes字节型

说到Bytes之前先来简单看看Unicode。世界上有这么多文字和符号,中文、日文、韩文难道每一个语言单字和符号都要储存在一个字典中计算机来调用么,Unicode的存在便是将世界上不同语言和符号统一用数字和英文符号表示,不同的计算机接收到的编码符号,只要对应Unicode的字典就可将其“翻译”出来,其中UTF-8编码是Unicode用得最为广泛的一种编码,具体内容请参照维基百科上的条目,http://zh.wikipedia.org/wiki/Unicode。

clip_image034Python3默认采用的便是UTF-8编码,因此天生就支持中文,在Python2.x中进行编程如果要用到中文,需要在代码加一句#-*- coding:utf-8 -*-。(本课程的源文件中大部分都加上这一句,为了适应不同环境的差异,某些经过特殊设置的Python3编程环境可能不支持中文,另外Rhino.Python中编程如果注释要用到中文,请加上这一句。)在Python中Bytes字节型数据便是将编码字符还原,用得不多,主要是在处理不同编码文件上使用到,字符串可以使用encode()参数将其转换为Bytes字节数据,用decode()参数将字节还原(8_bytes.py)。

chinese = ‘重庆大学’

byte = chinese.encode(‘Utf-8’)

print (byte)

print (byte.decode(‘Utf-8’))

>>> ================================ RESTART ================================

>>>

b’\xe9\x87\x8d\xe5\xba\x86\xe5\xa4\xa7\xe5\xad\xa6′

重庆大学

2.5 数据集合

数据集合顾名思义便是一系列数据储存在一个变量中,也可以有多重数据集合的形式,熟悉GH的同学知道,运算器支持输入一个数据,也支持输入多个数据,通过树型数据的方式储存。在代码编程中一般不用树型数据这玩意儿,相对来说要好理解一些,GH主要是因为无法完成循环、迭代、递归等方法因此采用树型数据来传递数据。

Python中有四种数据集合的方式,分别为元组(Tuples)、列表[List]、集合{Sets}和字典{Dict},此处作简单介绍,刚入门Python还未理解基本的逻辑和循环运算就深入接触数据集合恐怕有点困难,如同学习GH一上来就学习树型数据,后面的内容会深入接触这些内容。

• 元组(Tuples)是一系列一旦生成就不可变的数据有序集合,可以读取其内的值,取得其长度等操作,但不能改变。元组支持空元组和单个元素,tuple()函数支持将一个字符串转换为元组。

>>> a = (1,2,3,4,‘a’)

>>> a[4]

‘a’

>>> len(a)

5

>>> b = ‘asdfgsdfg’

>>> tuple(b)

(‘a’, ‘s’, ‘d’, ‘f’, ‘g’, ‘s’, ‘d’, ‘f’, ‘g’)

 

• 列表[List]也是任意对象的有序集合,与元组不同的是,列表中的元素是可变的,其长度可变,可以进行插入,偏移,删除某些元素等操作。

>>> l = [‘a’, ‘b’, ‘c’]

>>> len(l)

3

>>> l + [‘d’]

[‘a’, ‘b’, ‘c’, ‘d’]

>>> l * 2

[‘a’, ‘b’, ‘c’, ‘a’, ‘b’, ‘c’]

##索引和切片等操作与前面介绍的字符串相同,不详细介绍,另外添加,排序,删除等操作后面的内容再介绍。

• 集合{Sets}是一系列无序且元素不重合的数据集合,同样支持空集合和单个元素,集合中可以添加和删除数据,但由于是无序的不能索引,只能用in来测试某元素是否在集合中,集合与集合可以做布尔运算,使用set()函数可以将一个元组或列表转换成集合。

>>> a = {‘good’,‘bad’,1,3,4,5,‘yes’}

>>> len(a)

7

>>> ‘good’ in a

True

>>> ‘no’ in a

False

##将元组转换为集合

>>> b = (‘good’,1,2,6)

>>> b = set(b)

>>> b

{1, ‘good’, 2, 6}

##集合的布尔运算

>>> a & b #交集

{1, ‘good’}

>>> a | b #并集

{‘bad’, 2, 3, 4, 5, 6, 1, ‘good’, ‘yes’}

>>> a b #差集

{‘bad’, 3, 4, 5, ‘yes’}

>>> b a

{2, 6}

##集合中添加删除元素

>>> a.add(‘no’)

>>> a

{‘bad’, 3, 4, 5, 1, ‘good’, ‘yes’, ‘no’}

>>> a.remove(3)

>>> a

{‘bad’, 4, 5, 1, ‘good’, ‘yes’, ‘no’}

>>>

 

• 字典{Dict}如图其字面意义,一个字对应一个含义,字典本身没有固定序号,但字典中的每个元素Value必须人为给定一个索引Key,通过使用索引来进行字典查询。

##创建一个字典,其格式为{‘key1′:’value1′,’key2’:’value2’…}

>>> a_dict={‘school’:‘Chongqing University’,‘degree’:‘doctor’,‘name’:‘Wangdachuan’,‘magor’:‘Architecture’}

>>> a_dict

{‘magor’: ‘Architecture’, ‘school’: ‘Chongqing University’, ‘name’: ‘Wangdachuan’, ‘degree’: ‘doctor’}

##索引字典

>>> a_dict[‘name’]

‘Wangdachuan’

##修改字典

>>> a_dict[‘name’]=‘Wangxiaochuan’

>>> a_dict

{‘magor’: ‘Architecture’, ‘school’: ‘Chongqing University’, ‘name’: ‘Wangxiaochuan’, ‘degree’: ‘doctor’}

 

3 变量赋值与变量运算

3.1 变量赋值

看了前面内容的同学应该已经了如何进行变量赋值,在包括Python在内的绝大多数编程语言中,使用”=”进行变量赋值,”=”左边为该变量的名字,右边为变量的类型和值,Python的变量赋值有以下几个特点:

• 变量无需声明

• 变量无需指定类型

• 变量不再使用时,无需关心回收变量

在此再次提醒一下变量赋值的概念,变量赋值不是把一个值赋给一个变量,在Python中变量赋值是初始化一个名字并在内存中创建一个值,变量包含了这个名字与这个名字到内存中相应值的引用。例如:

>>> a = 100

>>> b = 100

>>> c = 100

>>> a is b

True

>>> b is c

True

>>> c is a

True

>>> id(a)

507101952

>>> id(b)

507101952

>>> id(c)

507101952

 

创建的a、b、c三个变量其实都是指向内存中100这个值,三个变量是等价的,这样做的好处在于可以节省空间的占用。如果你非要用之前的理解认为变量赋值就是将一个值附给一个变量在绝大部分其实也不会出现问题,这就相当于你非要认为地球是平的而生活也不会遇到什么阻挠,但有些情况下如果这么理解则会让你困惑。例如:

def aplus(a):

a += 1

return a

a = 4

b = aplus(a)

print(a)

>>> ================================ RESTART ================================

>>>

4

 

Python的变量赋值的右边可以是一个数值计算式或其他变量的计算式,赋值语句不会返回一个值,因此不能进行C语言中的返回值式赋值的语句。如:

a = 2*2+1

b = a**(2+1)

## 以下语句相当于a = a+1

a += 1

##以下语句在C中合法,但在Python中不合法

a = (b = a+1)

##链式赋值和多变量赋值是允许的

a = b = a+1

a,b,c,d = 1,2,3,4

另外要提一下的就是变量命名风格,一个好的程序员在进行变量命名时总是要保持良好的风格,一来保证代码结构的清晰合理,不至于发生混淆,二来也方便别人阅读,同理注释也应该如此。以下一些命名风格建议初学者采纳:

• 变量名要突出变量的类型和用途,用下划线进行分割,例如定义一个作为人名的字符串变量可用:str_name;定义一个表示层高的数值变量可用:num_floor。

• 一般不要使用__doc__这样的变量命名方式,这是Python的系统自有变量名。

• 学到有函数和模块的时候,全局变量名使用大写,局部变量名使用小写。

• 变量名不要太长,一般不超过10个字符,否则会降低编程效率。

3.2变量的运算

变量的运算由变量和运算符构成,”=”其实也算一种运算符,引用赋值符。下表为Python中的自带运算符。

运算符

描述

x+y,x-y

加、减,“+”号可重载为连接符

x*y,x**y,x/y,x%y

相乘、求平方、相除、求余,“*”号可重载为重复,“%”号可重载为格式化

<,<=,>,>=,==,<>,!=

比较运算符

+=,-=,*=,/=,%=,**=,<<=,>>=,&=,^=,|=

自变运算符

x|y

按位或

x^y

按位异或

x&y

按位与

~x

按位取反

x<<,x>>y

x向左或向右移y位

is, is not

等同测试

in, not in

是否为成员测试

or,and,not

逻辑运算符

x[i],x[i:j],x.y,x(…)

索引,分片,限定引用,函数调用

(…),[…],{…},’…’

元组,列表,字典,转化为字符串

运算符的优先级如下,从上往下为优先级从高到低。

运算符

描述

Lambda

字符串转换

{key:expr,…}

字典

[expr1,expr2…]

列表

(expr1,expr2,…)

元组

function(expr,…)

函数调用

x[index:index]

切片

x[index]

下标索引取值

x.attribute

属性引用

~x

按位取反

+x,-x

正,负

x**y

x*y,x/y,x%y

乘,除,取模

x+y,x-y

加,减

x<<y,x>>y

移位

x&y

按位与

x^y

按位异或

x|y

按位或

x<y,x<=y,x==y,x!=y,x>=y,x>y

比较

x is y,x is not y

等同测试

x in y,x not in y

成员判断

not x

逻辑否

x and y

逻辑与

x or y

逻辑或

lambda arg,…:expr

匿名函数

注意有些符号只适用与某些特定类型的变量,有些则适用不不同类型的变量,例如

常用的真值表如下*可以用整数乘以一个字符串,+则不行,位运算可以计算两个集合,也可以计算整数的二进位运算,这些知识属于数学范畴,看看下面例子,我这里就不多讲了,请各位练习一下,祝你们进步。

>>> a = 1

>>> b = 2

>>> c = {1,2,3,4}

>>> d = {2,3,4,5}

>>> a & b

0

>>> c & d

{2, 3, 4}

>>> e = ‘a’

## 字符串与数字无法做加法运算但可以与整数做乘法运算

>>> e * b

‘aa’

>>> e + b

Traceback (most recent call last):

File “<pyshell#21>”, line 1, in <module>

e + b

TypeError: Can’t convert ‘int’ object to str implicitly

>>> e ** b

Traceback (most recent call last):

File “<pyshell#22>”, line 1, in <module>

e ** b

TypeError: unsupported operand type(s) for ** or pow(): ‘str’ and ‘int’

>>> e * (b**b)

‘aaaa’

>>> a < b

True

>>> a == b

False

>>> ~a

2

>>> ~ b

3

“””

and,or 用于数值的比较运算有点抽象,对于and如果每一个表达式都不是假

的话,那么返回最后一个,因为需要一直匹配直到最后一个。如果有一个是假,

那么返回假。在纯or语句中,只要有一个表达式不是假的话,那么就返回这个

表达式的值。只有所有都是假,才返回假。而Python中的数值表示真假,0恒为

假,非零恒为真。对于and、or如果一起存在不加括号决定优先顺序就很难懂了,

碰到and就往后匹配,碰到or如果左为真取左值,如果左为假取右值。请自己网

上查阅相关资料,不管怎样,这种计算式不加括号是一种不好的做法。

“””

>>> a = 1

>>> b = 2

>>> a and b

2

>>> a = 0

>>> a and b

0

>>> a or b

2

>>> a and a or b

2

>>> a and (a or b)

0

本课练习:1 熟悉各种变量类型的基本内涵,建立方法和运算

2 不断的使用打印print()来学习上述内容

发表评论

电子邮件地址不会被公开。 必填项已用*标注