Python基础编程（第2版）（第一章）

担心自己看Python核心编程吃力，索性先从Python基础编程开始~

准备了两个屏幕，电子书，走起~

开始学习第一章

------------基础知识------------

1、安装python2.7.5：（安装步骤省略）

Python 2.7.5 (default, May 15 2013, 22:44:16) [MSC v.1500 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>print "Hello, World!"

2、输入下面的命令看看它是否正常工作：

>>>print "Hello, World!"

   当按下回车键后，会有下面的输出：

Hello, World!
>>>

  注：代码行最后不用加分号结束，加上分号不会有任何作用

3、数字和表达式

    交互式Python解释器可以当做非常强大的计算器使用

>>>2 + 2
4
>>>12345 + 54321
66666
>>>1/2
0
>>>

 ps:一个整数（无小数部分的数）被另外有一个整数除以，计算结果的小数部分被截取了，只留下整数部分。

解决方案：要用实数（包含小数点的十进制数）而不是整数进行运算，或者让Python改变触发的执行方式。

实数在Python中被称为 浮点数（Float，或者Float-point N）

>>> 1.0 / 2.0
0.5
>>> 1/2.0
0.5
>>> 1.0/2
0.5
>>> 1/2.
0.5

如果希望Python只执行普通的触发，那么可以在程序前加上一下语句，或者直接在编辑器里面执行它：

>>>from __future__ import division
>>> 1/2
0.5
>>>

 现在，单斜线不再用作前面提到的整除了，但Python还提供了另外一种用于实现整除的操作符——双斜线：

>>>1 // 2
0
>>>1.0 // 2.0
0.0

以上就算浮点数，双斜线也会执行整除

============================

下面了解取余（模除）

运算符：x%y的结果为x除以y的余数。

>>> 1 % 2
1
>>> 10 % 3
1
>>> 10 / 3
3.3333333333333335
>>> 9 /3
3.0
>>> 3 % 3
0
>>> 2.75 % 0.5
0.25
>>>

   这里10/3得3是因为结果的小数部分被截除了，而三三得九，所以相应的余数就是1了。

=============================

选数幂运算符（乘方）：

>>> 2 ** 3
8
>>> -3 ** 2
-9
>>> (-3) ** 2
9
>>>

注意，幂运算比取反的优先级要高，所以-3**2等同于 -（3**2）。如果想计算（-3）**2，就需要显式说明。

==============================

长整形

>>> 10000000000000000000
10000000000000000000L

这里发生了什么？数字后面加多了个L。

ps：普通整数不能大于2147483647 （也不能小于-2147483647），如果真的需要大数，可以使用长整形数。长整形数书写方法和普通整数一样，但是结尾有个L。（理论上，用小写的l也可以，但是它看起来太像数字1，所以建议不要用小写l。）

>>> 121231231323434435L * 1231325456354343433L + 23
149275101233726879856440251048315378L

4、变量

变量基本上就是代表（或者引用）某值的名字。举例来说，如果希望用字母k代表数字3只需要执行下面语句即可：

>>> k = 3
>>> print k
3
>>>

 使用变量之前，需要对其赋值，毕竟使用没有值的变量也没有意义。

5、语句

语句和表达式之前的区别在赋值时会表现得更加明显一些。因为语句不是表达式，所以没有值可供交互式解释器打印出来：

>>>x = 3
>>>

6、获取用户输入：input函数

>>> input("The meaning of life: ")
The meaning of life: 77
77
>>> x = input("x: ")
x: 11
>>> y = input("y: ")
y: 22
>>> print x * y
242
>>>

Python提示符（>>>）后面的语句可以算作一个完整程序的组成部分了，输入的值（11和22）由用户提供，而程序就回打印出输入的两个数的乘积242.

7、函数

函数可以代替运算符，pow可以代替幂运算符

>>>2 ** 3
8
>>>pow(2,3)
8

函数就像可以用来实现特定功能的小程序一样。Python的很多函数都能做很奇妙的事情。事实上，也可以自己定义函数（后面的内容会对此展开讲述）。因此，我们通常会吧pow等标准函数称为内建函数。

上例中我使用函数的方式叫作调用函数。可以给它提供参数，它会返回值给用户。

>>> pow(2,3*5)
32768
>>> 10 + pow(2,3*5)/3.0
10932.666666666666

abs函数可以得到数的绝对值，round函数则会把浮点数四舍五入为最接近的整数值：

>>> abs(-10)
10
>>> 1/2
0.5
>>> round(1.0/2.0)
1.0

8、模块

模块可以想象为导入到Python以增强其功能的扩展。需要使用特殊的命令import来导入模块。

>>> import math
>>> math.floor(32.9)
32.0
>>>

用法：用import导入了模块，然后按照“模块.函数”的格式使用这个模块中的函数

如果想把年龄转换为整数（32）而不是浮点数（32.0），可以使用int函数。

>>> int(math.floor(32.9))
32

导入模块的另外一种形式：

>>> from math import sqrt
>>> sqrt(9)
3.0

好处：在使用了“from模块import函数” 这种形式的import命令之后，就可以直接使用函数，而不需要模块名作为前缀 。

提示：事实上，可以使用变量引用函数（或者Python之中大多数的对象）。比如，通过foo=math.sqrt进行赋值，然后就可以使用foo来计算平方根：foo(4)的结果为2.0。

>>> foo = math.sqrt
>>> foo(4)
2.0

9、cmath和复数

sqrt函数用于计算一个数的平方根，原有的办法是无法处理负数的，但真的不可以吗？

>>> foo(-1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: math domain error

当然可以，负数的平方根是虚数。sqrt只能处理浮点数，虚数可以使用cmath的模块来实现这些功能

>>> import cmath
>>> cmath.sqrt(-1)
1j
>>>

注意：这次并没有使用from...import...语句。因为一旦使用了这个语句，就没法使用普通的sqrt函数了。这类命名冲突很讨厌，因此，除非真的需要from这个形式的模块导入语句，否则 应该坚持使用普通的import。

1j是个虚数，虚数均以j结尾（或者J），就像长整形数使用L一样。

注意：Python中没有单独的虚数类型。它们被看作实数部分为0的复数。

10、保存并执行程序

交互式解释器是Python的强项之一，但在交互式解释器中输入的一切都会在退出的时候丢失。我们真正想做的事情是编写自己和他人都能运行的程序。

文本编辑器 

先输入一下内容：

print "Hello, world!"

PS D:\learnpython> python .\1.py
Hello, world!

创建文本输入“print "Hello, world!"然后保存，命名文件为1.py，以py结尾很重要的。然后cmd下进入该文件对应目录，执行 python 1.py，Hello，world！在解释器窗口内打印出来了。

接下来，我们对上述脚本进行扩展，如下例：

name = raw_input("What's your name? ")
print "Hello, " + name + "!"

保存运行这个程序，解释器看到下面提示：

what's your name?

输入字符（如：kk），然后回车，解释器显示内容如下

Hello, kk

11、注释

#（井号）在Python中有些特殊，在代码中输入它的时候，它的邮编的一切都会被忽略

#这是例子
name = raw_input("What's your name? ")
print "Hello, " + name + "!"

这里的第一行称为注释。为了让别人能够更容易的理解程序

12、字符串

“Hello,world!”就是字符串，字符串在几乎所有真实可用的Python程序中都会存在，并且有多种用法，其中最主要的就是表示一些文本。

13、单引号字符串和转义引号

字符串是值，就像数字一样：

>>> "Hello, world!"
'Hello, world!'

有一个疑问，当Python打印出字符串的时候，是用单引号括起来的，但我们在程序中用的是双引号。事实上没有区别。

>>> "Let's go!"
"Let's go!"
>>> '"Hello, world!" she said'
'"Hello, world!" she said'

上面代码第一段字符串包含了单引号（或者叫撇号）这时候就不能单引号将整个字符串括起来了，如果这样做，解释器会抱怨道（它这样做也是正确的）:

>>> 'Let's go!'
  File "<stdin>", line 1
    'Let's go!'
         ^
SyntaxError: invalid syntax

上面代码，Python并不知道如何处理后面的s（也就是该行余下的内容）。

第二段字符串中，句子包含了双引号，所以，出于之前所述原因，就需要单引号把字符串括起来了。

还有另外一种方法：使用反斜线（\）对字符串中的引号进行转义：

>>> 'Let\'s go!'
"Let's go!"

这样Python会明白中间的单引号是字符串中的一个字符，而不是字符串的结束标记。

对双引号也可以使用同样的方法进行转义：

>>> "\"Hello, world!\" she said"
'"Hello, world!" she said'

14、拼接字符串

使用另外一种方式输出同样的字符串：

>>> "Let's say " '"Hello, world!"'
'Let\'s say "Hello, world!"'

一个接一个，Python会自动拼接它们。

但不应用于变量：

>>> x = "Hello, "
>>> y = "world!"
>>> x y
  File "<stdin>", line 1
    x y
      ^
SyntaxError: invalid syntax

这仅仅是书写字符串的一种特殊方法，并不是拼接字符串的一般方法。怎么拼接？就像进行加法运算一样：

>>> "Hello, " + "world!"
'Hello, world!'
>>> x + y
'Hello, world!'

15、字符串表示，str和repr

>>> "Hello, world!"
'Hello, world!'
>>> 10000L
10000L
>>> print "Hello, world!"
Hello, world!
>>> print 10000L
10000

以上代码Python打印值会保持该值的Python代码中状态，而使用print语句，结果就不一样了。

我们这里讨论的实际上是值被转换为字符串的两种机制。可以通过以下两个函数来使用这两种机制：一个是通过str函数，它会把值转换为合理形式的字符串，以便用户可以理解；而repr会创建一个字符串，它以合法的Python表达式的形式来表示值。下面是一些例子：

>>> print repr("Hello, world!")
'Hello, world!'
>>> print repr(10000L)
10000L
>>> print str("Hello, world!")
Hello, world!
>>> priont str(10000L)
  File "<stdin>", line 1
    priont str(10000L)
             ^
SyntaxError: invalid syntax
>>> print str(10000L)
10000

repr（x）的功能可以用`x`实现（注意，`是反引号，而不是单引号）。如果希望打印一个包含数字的句子，那么反引号就很有用了。比如：

>>> temp = 77
>>> print "The temperature is " + temp
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: cannot concatenate 'str' and 'int' objects
>>> print "The temperature is " + `temp`
The temperature is 77
>>> print "The temperature is " + repr(temp)
The temperature is 77

第一个print语句不能工作的原因，那是因为不可以将字符串和数字进行相加。

第二个print则可以正常工作，因为已经通过反引号将temp的值转换为字符串"77"了。

16、input 和 raw_input 的比较

#这是例子
>>> name = input("What's your name? ")
What's your name? kk
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<string>", line 1, in <module>
NameError: name 'kk' is not defined

问题在于input会假设用户输入的是合法的Python表达式（或多或少有些于repr函数相反的意思）。如果以字符串作为输入的名字，程序运行时没有问题的：

>>> name = input("What's your name? ")
What's your name? "kk"
>>> print name
kk

然而，要求用户带有引号输入他们的名字有点过分，因此，这就需要使用raw_input函数，它会把所有的输入当作原始数据（raw date）,然后将其放入字符串中：

>>> input("Enter a number: ")
Enter a number: 3
3
>>> raw_input("Enter a number: ")
Enter a number: 3
'3'

注：除非对input有特殊的要求，否则应该尽可能使用raw_input函数

17、长字符串、原始字符串和Unicode

如果需要些一个非常非常长的字符串，它需要跨多行，那么可以使用三个引号代替普通引号。

>>> print '''This is a very string.'''
This is a very string.
>>> print '''This is a very string.
... It continues here
... And it's not over yet.
... "Hello, world!"
... Still here.'''
This is a very string.
It continues here
And it's not over yet.
"Hello, world!"
Still here.

也可以使用三个双引号，如"""kk""".

注：在这样形似下同时使用单引号和双引号，不需要使用反斜线进行转义。

普通单引号也可以跨行：

>>> print "Hello, \
... world!"
Hello, world!

这个用法也适用于表达式和语句：

>>> 1 + 2 + \
... 4 + 5
12
>>> print\
... "Hello, world!"
Hello, world!

换行符可以写为\n，并放在字符串中：

>>> print 'Hello, \nworld!'
Hello,
world!

希望在字符串中包含反斜线再加上n：我们可以使用反斜线对其本身进行转义

>>> print 'C:\\nwhere'
C:\nwhere

原始字符串r开头，打印出内容都与书写的内容保持一致：

>>> print r'C:\nwhere'
C:\nwhere

注意：不能再原始字符串结尾输入反斜线。

>>> print r'C:\nwhere\'
  File "<stdin>", line 1
    print r'C:\nwhere\'
                      ^
SyntaxError: EOL while scanning string literal

希望原始字符只以一个反斜线作为结尾的话，本质上就是把反斜线单独作为一个字符串处理操作如下：

>>> print r'C:\Program Files\foo\bar' '\\'
C:\Program Files\foo\bar\

Unicode字符串

字符串常量