Python基础01 Hello World!

Python命令行

假设你已经安装好了Python, 那么在命令提示符输入:

python

将直接进入python。然后在 命令行提示符>>> 后面输入:

>>>print('Hello World!')

可以看到，随后在屏幕上输出:

print 是一个常用函数，其功能就是输出括号中得字符串。

（在Python 2.x中，print还可以是一个关键字，可写成 print 'Hello World!' ，但这在3.x中行不通 ）

写一段小程序

另一个使用Python的方法，是写一个Python程序。用文本编辑器 写一个.py结尾的文件 ，比如说 hello.py

在 hello.py 中写入如下，并保存:

print('Hello World!')

退出文本编辑器，然后在命令行输入:

$python hello.py

来运行hello.py。可以看到Python随后输出

Hello World!

Python基础02 基本数据类型

变量不需要声明

Python的变量不需要声明，你可以直接输入：

>>>a = 10

那么你的内存里就有了一个变量a， 它的值是10，它的类型是integer (整数)。 在此之前你不需要做什么特别的声明，而数据类型是Python自动决定的。

>>>print(a)

>>>print(type(a))

那么会有如下输出：

10

这里，我们学到一个内置函数 type() , 用以查询变量的类型。

回收变量名

如果你想让a存储不同的数据，你不需要删除原有变量就可以直接赋值。

>>>a = 1.3

>>>print(a,type(a))

会有如下输出

1.3

我们看到 print的另一个用法 ，也就是print后跟多个输出，以逗号分隔。

基本数据类型

a=10 # int 整数

a=1.3 # float 浮点数

a=True # 真值 (True/False)

a='Hello!' # 字符串。字符串也可以用双引号。

以上是最常用的数据类型。此外还有分数，字符，复数等其他类型，有兴趣的可以学习一下。

变量不需要声明，不需要删除，可以直接回收适用。

type(): 查询数据类型

整数，浮点数，真值，字符串

Python基础03 序列

sequence 序列

sequence(序列)是一组 有顺序 的 元素 的 集合

(严格的说，是对象的集合，但鉴于我们还没有引入“对象”概念，暂时说元素)

序列可以包含一个或多个 元素 ，也可以没有任何元素。

我们之前所说的基本数据类型，都可以作为序列的元素。元素还可以是另一个序列，以及我们以后要介绍的其他对象。

序列有两种：tuple（ 定值表 ； 也有翻译为 元组 ） 和 list ( 表 )

>>>s1 = (2, 1.3, 'love', 5.6, 9, 12, False) # s1是一个tuple

>>>s2 = [True, 5, 'smile'] # s2是一个list

>>>print(s1,type(s1))

>>>print(s2,type(s2))

tuple和list的主要区别在于，一旦建立， tuple的各个元素不可再变更，而list的各个元素可以再变更 。

一个序列作为另一个序列的元素

>>>s3 = [1,[3,4,5]]

空序列

>>>s4 = []

元素的引用

序列元素的 下标 从0开始：

>>>print(s1[0])

>>>print(s2[2])

>>>print(s3[1][2])

由于list的元素可变更，你可以对list的某个元素赋值：

>>>s2[1] = 3.0

>>>print(s2)

如果你对tuple做这样的操作，会得到错误提示。

所以，可以看到，序列的引用通过 s[ ] 实现， int为下标

其他引用方式

范围引用： 基本样式 [下限:上限:步长]

>>>print(s1[:5]) # 从开始到下标4 （下标5的元素 不包括在内）

>>>print(s1[2:]) # 从下标2到最后

>>>print(s1[0:5:2]) # 从下标0到下标4 (下标5不包括在内)，每隔2取一个元素 （下标为0，2，4的元素）

>>>print(s1[2:0:-1]) # 从下标2到下标1

从上面可以看到，在范围引用的时候，如果写明上限，那么这个 上限本身不包括在内 。

尾部元素引用

>>>print(s1[-1]) # 序列最后一个元素

>>>print(s1[-3]) # 序列倒数第三个元素

同样，如果s1[0:-1], 那么最后一个元素不会被引用 （再一次， 不包括上限元素本身 ）

字符串是元组

字符串是一种特殊的元组，因此可以执行元组的相关操作。

>>>str = 'abcdef'

>>>print(str[2:4])

tuple元素不可变，list元素可变

序列的引用 s[2], s[1:8:2]

字符串是一种tuple

Python基础04 运算

数学运算

>>>print 1+9 # 加法

>>>print 1.3-4 # 减法

>>>print 3*5 # 乘法

>>>print 4.5/1.5 # 除法

>>>print 3**2 # 乘方

>>>print 10%3 # 求余数

判断

判断是真还是假，返回True/False

>>>print 5==6 # =， 相等

>>>print 8.0!=8.0 # !=, 不等

>>>print 3<3, 3<=3 #

>>>print 4>5, 4>=0 # >, 大于; >=, 大于等于

>>>print 5 in [1,3,5] # 5是list [1,3,5]的一个元素

（还有is, is not等, 暂时不深入）

逻辑运算

True/False之间的运算

>>>print True and True, True and False # and, “与”运算， 两者都为真才是真

>>>print True or False # or, "或"运算， 其中之一为真即为真

>>>print not True # not, “非”运算， 取反

可以和上一部分结合做一些练习，比如：

>>>print 5==6 or 3>=3

数学 +, -, *, /, **, %

判断 ==, !=, >, >=,

逻辑 and, or, not

Python基础05 缩进和选择

缩进

Python最具特色的是用缩进来标明成块的代码。我下面以if选择结构来举例。if后面跟随条件，如果条件成立，则执行归属于if的一个代码块。

先看C语言的表达方式（注意， 这是C，不是Python! ）

如果i > 0的话，我们将进行括号中所包括的两个赋值操作。括号中包含的就是块操作，它隶属于if。

在Python中，同样的目的，这段话是这样的

在Python中， 去掉了i > 0周围的括号，去除了每个语句句尾的分号，表示块的花括号也消失了。

多出来了 if ... 之后的 :(冒号) , 还有就是x = 1 和 y =2前面有 四个空格的缩进 。通过缩进，Python识别出这两个语句是隶属于if。

Python这样设计的理由纯粹是为了程序好看。

if语句

写一个完整的程序，命名为ifDemo.py。这个程序用于实现if结构。

$python ifDemo.py # 运行

程序运行到if的时候，条件为True，因此执行 x = x+1 ,。

print x 语句没有缩进，那么就是if之外。

如果将第一句改成i = -1，那么if遇到假值 (False), x = x+1 隶属于if, 这一句跳过。 print x 没有缩进，是if之外，不跳过，继续执行。

这种以 四个空格 的缩进来表示 隶属关系 的书写方式，以后还会看到。强制缩进增强了程序的 可读性 。

复杂一些的if选择：

这里有三个块，分别属于 if, elif, else 引领。
Python检测条件，如果发现if的条件为假，那么跳过后面紧跟的块，检测下一个elif的条件； 如果还是假，那么执行else块。
通过上面的结构将程序分出三个分支。程序根据条件，只执行三个分支中的一个。

整个if可以放在另一个if语句中，也就是if结构的嵌套使用：

if i > 2 后面的块相对于该if缩进了四个空格，以表明其隶属于该if，而不是外层的if。

if语句之后的冒号

以四个空格的缩进来表示隶属关系, Python中不能随意缩进

if  :

statement

elif :

statement

elif ：

statement

else:

statement

Python基础07 函数

函数最重要的目的是方便我们 重复使用 相同的一段程序。

将一些操作 隶属 于一个函数，以后你想实现相同的操作的时候，只用调用函数名就可以，而不需要重复敲所有的语句。

函数的定义

首先，我们要定义一个函数, 以说明这个函数的功能。

def square_sum(a,b):
    c = a**2 + b**2    return c

这个函数的功能是求两个数的平方和。

首先，def，这个关键字通知python：我在定义一个函数。square_sum是函数名。

括号中的a, b是函数的 参数 ，是对函数的 输入 。参数可以有多个，也可以完全没有（但括号要保留）。

我们已经在循环和选择中见过 冒号 和 缩进 来表示的隶属关系。

c = a**2 + b**2 # 这一句是函数内部进行的运算

return c # 返回c的值，也就是输出的功能。Python的函数允许不返回值，也就是不用return。

return可以 返回多个值 ，以逗号分隔。相当于返回一个tuple(定值表)。

return a,b,c # 相当于 return (a,b,c)

在Python中，当程序执行到return的时候，程序将 停止执行函数内余下的语句 。return并不是必须的，当没有return, 或者return后面没有返回值时，函数将自动返回 None 。None是Python中的一个特别的数据类型，用来表示 什么都没有 ，相当于C中的NULL。None多用于关键字参数传递的默认值。

函数调用和参数传递

定义过函数后，就可以在后面程序中使用这一函数

print square_sum(3,4)

Python通过 位置 ，知道3对应的是函数定义中的第一个参数a， 4对应第二个参数b，然后把 参数传递 给函数square_sum。

（Python有丰富的参数传递方式，还有关键字传递、表传递、字典传递等，基础教程将只涉及位置传递）

函数经过运算，返回值25, 这个25被print打印出来。

我们再看下面两个例子

第一个例子，我们将一个 整数变量传递给函数 ，函数对它进行操作，但 原整数变量a不发生变化 。

第二个例子，我们将一个 表传递给函数 ，函数进行操作， 原来的表b发生变化 。

对于基本数据类型的变量，变量传递给函数后，函数会在内存中复制一个新的变量，从而不影响原来的变量。（我们称此为 值传递 ）

但是对于表来说，表传递给函数的是一个指针，指针指向序列在内存中的位置，在函数中对表的操作将在原有内存中进行，从而影响原有变量。 （我们称此为 指针传递 ）

Python基础09 面向对象的进一步拓展

调用类的其它信息

上一讲中提到，在定义方法时，必须有self这一参数。这个参数表示某个对象。对象拥有类的所有性质，那么我们可以 通过self，调用类属性 。

这里有一个类属性laugh。在方法show_laugh()中，通过self.laugh，调用了该属性的值。

还可以用相同的方式调用其它方法。方法show_laugh()，在方法laugh_100th中()被调用。

通过对象可以修改类属性值。但这是危险的。类属性被所有同一类及其子类的对象共享。类属性值的改变会影响所有的对象。

__init__()方法

__init__() 是一个 特殊方法(special method) 。Python有一些特殊方法。Python会特殊的对待它们。特殊方法的特点是名字前后有 两个下划线 。

如果你在类中定义了__init__()这个方法，创建对象时，Python会 自动调用 这个方法。这个过程也叫 初始化 。

这里继承了Bird类，它的定义见上一讲。

屏幕上打印：

We are happy birds.Happy,Happy!

我们看到，尽管我们只是创建了summer对象，但__init__()方法被自动调用了。最后一行的语句(summer = happyBird...)先创建了对象，然后执行：

summer.__init__(more_words)

'Happy,Happy!' 被传递给了__init__()的参数more_words