切片

比如一个list去前3个元素,取指定索引范围的操作，用循环十分繁琐，因此，Python提供了切片（Slice）操作符，能大大简化这种操作。

1
2
3

>>> r = ['a','b','c','d','e','f','g']
>>> r[0:3]
['a', 'b', 'c']

L[0:3]表示，从索引0开始取，直到索引3为止，但不包括索引3。即索引0，1，2，正好是3个元素。
记住倒数最后一个元素的索引是-1。

切片操作十分有用。我们先创建一个0-99的数列：

1
2
3

>>> L = range(100)
>>> L
[0, 1, 2, 3, ..., 99]

可以通过切片轻松取出某一段数列。比如前10个数：

1
2

>>> L[:10]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

后10个数：

1
2

>>> L[-10:]
[90, 91, 92, 93, 94, 95, 96, 97, 98, 99]

前11-20个数：

1
2

>>> L[10:20]
[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

前10个数，每两个取一个：

1
2

>>> L[:10:2]
[0, 2, 4, 6, 8]

所有数，每5个取一个：

1
2

>>> L[::5]
[0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95]

甚至什么都不写，只写[:]就可以原样复制一个list：

1
2

>>> L[:]
[0, 1, 2, 3, ..., 99]

tuple也是一种list，唯一区别是tuple不可变。因此，tuple也可以用切片操作，只是操作的结果仍是tuple：

1
2

>>> (0, 1, 2, 3, 4, 5)[:3]
(0, 1, 2)

字符串’xxx’或Unicode字符串u’xxx’也可以看成是一种list，每个元素就是一个字符。因此，字符串也可以用切片操作，只是操作结果仍是字符串：

1
2
3
4

>>> 'ABCDEFG'[:3]
'ABC'
>>> 'ABCDEFG'[::2]
'ACEG'

迭代

因为Python的for循环不仅可以用在list或tuple上，还可以作用在其他可迭代对象上。

list这种数据类型虽然有下标，但很多其他数据类型是没有下标的，但是，只要是可迭代对象，无论有无下标，都可以迭代，比如dict就可以迭代：

1
2
3
4
5
6
7

>>> d = {'a': 1, 'b': 2, 'c': 3}
>>> for key in d:
...     print key
...
a
c
b

默认情况下，dict迭代的是key。如果要迭代value，可以用for value in d.itervalues()，如果要同时迭代key和value，可以用for k, v in d.iteritems()。

1
2
3
4
5
6
7
8
9
10
11
12
13

>>> d = {'a': 1, 'b': 2, 'c': 3}
>>> for value in d.itervalues():
...     print value
... 
1
3
2
>>> for k,v in d.iteritems():
...     print k,v
... 
a 1
c 3
b 2

如何判断一个对象是可迭代对象呢？方法是通过collections模块的Iterable类型判断：

1
2
3
4
5
6
7

>>> from collections import Iterable
>>> isinstance('abc', Iterable) #  str是否可迭代
True
>>> isinstance([1,2,3], Iterable) #  list是否可迭代
True
>>> isinstance(123, Iterable) #  整数是否可迭代
False

Python内置的enumerate函数可以把一个list变成索引-元素对，这样就可以在for循环中同时迭代索引和元素本身：

1
2
3
4
5
6

>>> for i, value in enumerate(['A', 'B', 'C']):
...     print i, value
...
0 A
1 B
2 C

for循环里，同时引用了两个变量，在Python里是很常见的，比如下面的代码：

1
2
3
4
5
6

>>> for x, y in [(1, 1), (2, 4), (3, 9)]:
...     print x, y
...
1 1
2 4
3 9

列表生成式

列表生成式即List Comprehensions，是Python内置的非常简单却强大的可以用来创建list的生成式。
举个例子，要生成list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]可以用range(1, 11)：

1
2

>>> range(1, 11)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

如果要生成[1x1, 2x2, 3x3, …, 10x10]怎么做？

1
2

>>> [x * x for x in range(1, 11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

for循环后面还可以加上if判断，这样我们就可以筛选出仅偶数的平方：

1
2

>>> [x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]

还可以使用两层循环，可以生成全排列：

1
2

>>> [m + n for m in 'ABC' for n in 'XYZ']
['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']

运用列表生成式，可以写出非常简洁的代码。例如，列出当前目录下的所有文件和目录名，可以通过一行代码实现：

1
2
3

>>> import os #  导入os模块
>>> [d for d in os.listdir('.')] #  os.listdir可以列出文件和目录
['.emacs.d', '.ssh', '.Trash', 'Adlm', 'Applications', 'Desktop', 'Documents', 'Downloads', 'Library', 'Movies', 'Music', 'Pictures', 'Public', 'VirtualBox VMs', 'Workspace', 'XCode']

内建的isinstance函数可以判断一个变量是不是字符串：

1
2
3
4
5
6

>>> x = 'abc'
>>> y = 123
>>> isinstance(x, str)
True
>>> isinstance(y, str)
False

生成器

列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器（Generator）。

1
2
3

>>> g = (x * x for x in range(10))
>>> g
<generator object <genexpr> at 0x104feab40>

如果要一个一个打印出来，可以通过generator的next()方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

>>> g.next()
0
>>> g.next()
1
>>> g.next()
4
>>> g.next()
9
>>> g.next()
16
>>> g.next()
25
>>> g.next()
36
>>> g.next()
49
>>> g.next()
64
>>> g.next()
81
>>> g.next()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

generator保存的是算法，每次调用next()，就计算出下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出StopIteration的错误。

generator非常强大。如果推算的算法比较复杂，用类似列表生成式的for循环无法实现的时候，还可以用函数来实现。

比如，著名的斐波拉契数列（Fibonacci），除第一个和第二个数外，任意一个数都可由前两个数相加得到：

1, 1, 2, 3, 5, 8, 13, 21, 34, …

斐波拉契数列用列表生成式写不出来，但是，用函数把它打印出来却很容易：

1
2
3
4
5
6

def fab(max):
    n, a, b = 0, 0, 1
    while n < max:
        print b
        a, b = b, a + b
        n = n + 1

上面的函数可以输出斐波那契数列的前N个数：

1
2
3
4
5
6
7

>>> fab(6)
1
1
2
3
5
8

仔细观察，可以看出，fab函数实际上是定义了斐波拉契数列的推算规则，可以从第一个元素开始，推算出后续任意的元素，这种逻辑其实非常类似generator。

也就是说，上面的函数和generator仅一步之遥。要把fab函数变成generator，只需要把print b改为yield b就可以了：

1
2
3
4
5
6

def fab(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a + b
        n = n + 1

这就是定义generator的另一种方法。如果一个函数定义中包含yield关键字，那么这个函数就不再是一个普通函数，而是一个generator：

1
2

>>> fab(6)
<generator object fab at 0x104feaaa0>

这里，最难理解的就是generator和函数的执行流程不一样。函数是顺序执行，遇到return语句或者最后一行函数语句就返回。而变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

>>> def fun():
...     print 'step1'
...     yield
...     print 'step2'
...     yield
...     print 'step3'
...     yield
... 
>>> o = fun()
>>> o.next()
step1
>>> o.next()
step2
>>> o.next()
step3
>>> o.next()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

• padding 控件的内容相对控件边缘的边距

• margin 控件边缘相对父控件的边距

• android:gravity 该view内容的限定限定位置

• android:layout_gravity 设置该view中的子view相对于父view的限定位置

list 和 tuple

list

list是Python内置的一种数据类型是列表，为一种有序的集合，可以随时添加和删除其中的元素。
例如，列出班级中所有同学的名字：

1
2

classmates = ['Michael','Bob','Tracy']
print classmates

可以用len()函数获取list元素的个数

1
2

>>> len(classmates)
3

用索引来访问list中每一个位置的元素，记得索引是从0开始的：

1
2
3
4
5
6
7
8
9
10

>>> classmates[0]
'Michael'
>>> classmates[1]
'Bob'
>>> classmates[2]
'Tracy'
>>> classmates[3]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

当索引超出了范围时，Python会报一个IndexError错误，所以，要确保索引不要越界，记得最后一个元素的索引是len(classmates) - 1。

如果要取最后一个元素，除了计算索引位置外，还可以用-1做索引，直接获取最后一个元素：

1
2

>>> classmates[-1]
'Tracy'

以此类推，可以获取倒数第2个、倒数第3个：

1
2
3
4
5
6
7
8

>>> classmates[-2]
'Bob'
>>> classmates[-3]
'Michael'
>>> classmates[-4]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

当然，倒数第4个就越界了。

list是一个可变的有序表，所以，可以往list中追加元素到末尾：

1
2
3

>>> classmates.append('Adam')
>>> classmates
['Michael', 'Bob', 'Tracy', 'Adam']

也可以把元素插入到指定的位置，比如索引号为1的位置：

1
2
3

>>> classmates.insert(1, 'Jack')
>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy', 'Adam']

要删除list末尾的元素，用pop()方法：

1
2
3
4

>>> classmates.pop()
'Adam'
>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy']

要删除指定位置的元素，用pop(i)方法，其中i是索引位置：

1
2
3
4

>>> classmates.pop(1)
'Jack'
>>> classmates
['Michael', 'Bob', 'Tracy']

要把某个元素替换成别的元素，可以直接赋值给对应的索引位置：

1
2
3

>>> classmates[1] = 'Sarah'
>>> classmates
['Michael', 'Sarah', 'Tracy']

list里面的元素的数据类型也可以不同，比如：

1

>>> L = ['Apple', 123, True]

list元素也可以是另一个list，比如：

1
2
3

>>> s = ['python', 'java', ['asp', 'php'], 'scheme']
>>> len(s)
4

要注意s只有4个元素，其中s[2]又是一个list，如果拆开写就更容易理解了：

1
2

>>> p = ['asp', 'php']
>>> s = ['python', 'java', p, 'scheme']

要拿到’php’可以写p[1]或者s[2][1]，因此s可以看成是一个二维数组，类似的还有三维、四维……数组，不过很少用到。

如果一个list中一个元素也没有，就是一个空的list，它的长度为0：

1
2
3

>>> L = []
>>> len(L)
0

tuple

另一种有序列表叫元组：tuple。tuple和list非常类似，但是tuple一旦初始化就不能修改，比如同样是列出同学的名字：

1

>>> classmates = ('Michael', 'Bob', 'Tracy')

现在，classmates这个tuple不能变了，它也没有append()，insert()这样的方法。其他获取元素的方法和list是一样的，你可以正常地使用classmates[0]，classmates[-1]，但不能赋值成另外的元素。

不可变的tuple有什么意义？因为tuple不可变，所以代码更安全。如果可能，能用tuple代替list就尽量用tuple。

tuple的陷阱：当你定义一个tuple时，在定义的时候，tuple的元素就必须被确定下来，比如：

1
2
3

>>> t = (1, 2)
>>> t
(1, 2)

如果要定义一个空的tuple，可以写成()：

1
2
3

>>> t = ()
>>> t
()

但是，要定义一个只有1个元素的tuple，如果你这么定义：

1
2
3

>>> t = (1)
>>> t
1

定义的不是tuple，是1这个数！这是因为括号()既可以表示tuple，又可以表示数学公式中的小括号，这就产生了歧义，因此，Python规定，这种情况下，按小括号进行计算，计算结果自然是1。
所以，只有1个元素的tuple定义时必须加一个逗号,，来消除歧义：

1
2
3

>>> t = (1,)
>>> t
(1,)

Python在显示只有1个元素的tuple时，也会加一个逗号,，以免你误解成数学计算意义上的括号。

最后来看一个“可变的”tuple：

1
2
3
4
5

>>> t = ('a', 'b', ['A', 'B'])
>>> t[2][0] = 'X'
>>> t[2][1] = 'Y'
>>> t
('a', 'b', ['X', 'Y'])

这个tuple定义的时候有3个元素，分别是’a’，’b’和一个list。不是说tuple一旦定义后就不可变了吗？怎么后来又变了？

别急，我们先看看定义的时候tuple包含的3个元素：

当我们把list的元素’A’和’B’修改为’X’和’Y’后，tuple变为：

表面上看，tuple的元素确实变了，但其实变的不是tuple的元素，而是list的元素。tuple一开始指向的list并没有改成别的list，所以，tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。即指向’a’，就不能改成指向’b’，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！

小结

list和tuple是Python内置的有序集合，一个可变，一个不可变。根据需要来选择使用它们。

条件判断和循环

条件判断

根据Python的缩进规则，如果if语句判断是True,就把缩进的语句执行，否则不执行。
也可以给if添加一个else语句，如果if判断是False，就不执行if的内容，而执行else的内容

1
2
3
4

if(3>2):
	print '执行这里'
else:
	print '没执行这里'

注意不要少写冒号":"

1
2
3
4
5
6
7
8
9

elif是else if的缩写，完全可以有多个elif，所以if语句的完整形式就是：
if <条件判断1>:
    <执行1>
elif <条件判断2>:
    <执行2>
elif <条件判断3>:
    <执行3>
else:
    <执行4>

循环

Python的循环有两种，一种是for…in循环，用于遍历list或者tuple

1
2
3

colors = ['red','blue','green']
for color in colors:
	print color

执行这段代码会依次打印colors的每一个元素

1
2
3

red
blue
green

Python提供了一个range()函数，可以生成一个整数序列，我们可以计算一个1-100的整数之和

1
2
3
4

sum = 0
for x in range(101):
	sum = sum + x
print sum

第二种循环是while循环，和C语言一样，只要条件为True，就会执行循环体

1
2
3
4
5
6

sum = 0
n = 1
while n <= 100:
	sum = sum + n
	n = n + 1
print sum

如果死循环了，记得用Ctrl + C退出循环

dict和set

dict

dict就是dictionary，在Java里也成为map，使用键值对（key-value）存储，具有极快的查找速度
例如记录同学们的成绩

1
2

d = {'Michael':95,'Bob':75,'Tracy':85}
print d['Micheal']

除了初始化时指定外，存储value时，通过key放入(相同的key赋值的话，会覆盖掉之前的value)：

1

>>> d['Adam'] = 76

如果key不存在dict会报错，为了避免这种错误，可以通过in判断key是否存在，或者使用dict的get方法，获取value，不存在的话会返回None

1
2
3

dic = {"a":67,"c":12,"b":1}
print 'd' in dic
print dic.get("d")

要删除一个key，使用pop(key)方法
与list相比，dict有以下几个特点

1. 查找和插入的速度极快，不会随着key的增加而增加
2. 需要占用大量内存，内存浪费多
   而list相反
3. 查找和插入的时间随着元素的增加而增加
4. 占用空间小，浪费内存很小

Set

Set和dict类似，但是不存在value，只存一组key,而且key不能重复，所以Set中没有重复的key

1
2
3

>>> s = set([1,2,3,4,5,1,2,3,4,5])
>>> s
set([1, 2, 3, 4, 5])

重复的元素会被自动过滤掉
添加元素可以使用set的add(key)方法，可以重复添加，但不会有效果，删除元素使用remove(key)方法

1
2
3
4
5
6
7
8

>>> s = set([])
>>> s.add(1)
>>> s.add(2)
>>> s.add(3)
>>> s.add(4)
>>> s.remove(3)
>>> s
set([1, 2, 4])

注意删除的元素必须存在，否则报错
set可以看成数学上的无序和无重复元素的集合，所以也可以做交集和并集的运算操作

1
2
3
4
5
6

>>> s1 = set([1,2,3,4])
>>> s2 = set([2,4,6,8])
>>> s1 & s2
set([2, 4])
>>> s1 | s2
set([1, 2, 3, 4, 6, 8])

函数

Python内置了很多很有用的函数，我们可以直接调用。可以在Python的官网上查看文档
可以在命令行通过help()查看某个函数的帮助信息

1
2
3
4
5
6
7

help(abs)
Help on built-in function abs in module __builtin__:

abs(...)
    abs(number) -> number
    
    Return the absolute value of the argument.

数据类型转换

Python内置常用的函数，比如int()函数就可以把其他数据类型转换为整数：

1
2

>>> int('123')
123

函数名其实就是函数对象的引用，所以可以用一个变量指向该引用，实现别名的效果

1
2
3

>>> a = abs
>>> a(-1)
1

主要使用函数时，一定要传入正确的参数，否则会出错。

函数的定义

在Python中，定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回。

1
2

def fun(x,y):
  return x+y

空函数

定义一个什么事也不做的空函数，可以使用pass语句

1
2

def nop():
  pass

参数检查

Python会进行参数个数的检查，如果不对会抛出TypeError，但是类型并不会进行检查

默认参数

在定义时为某个参数初始化一个值，若调用时，该参数缺省时，便会使用默认的值

1
2
3
4
5
6

def power(x,n = 2):
  s = 1
  while n > 0:
    n = n - 1
    s = s * x
  return s

可变参数

函数参数个数可变时，我们可以通过list或者tuple包装参数，传入函数，函数会接收到tuple

1
2
3
4
5
6
7

def add(numbers):
  sum = 0
  for number in numbers:
    sum = sum + number
  return sum

add([1,2,3,4,5])

1
2
3
4
5

def calc(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum

如果已经有一个list或者tuple，要调用一个可变参数怎么办？可以这样做：

1
2
3

>>> nums = [1, 2, 3]
>>> calc(nums[0], nums[1], nums[2])
14

关键字参数

关键字参数允许传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装成为一个dict

1
2

def person(name,age,**kw):
  print 'name:',name,'age':,age,'other:',kw

函数person除了参数name和age外，还接受关键字参数kw。在调用该函数时，可以之传入必选参数，或者任意个关键字参数

1
2
3
4
5
6

>>> person('Michael', 30)
name: Michael age: 30 other: {}
>>> person('Bob', 35, city='Beijing')
name: Bob age: 35 other: {'city': 'Beijing'}
>>> person('Adam', 45, gender='M', job='Engineer')
name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}

参数组合

在Python中定义函数，可以用必选参数、默认参数、可变参数和关键字参数，这4种参数都可以一起使用，或者只用其中的一部分，但定义的顺序必须是：必选参数、默认参数、可变参数和关键字参数。
比如：

1
2

def fun(a,b,c=0,*args,**kw)
  print 'a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw

调用时，Python接收器自动按照参数位置和参数名把对应的参数传进去

1
2
3
4
5
6
7
8

>>> func(1, 2)
a = 1 b = 2 c = 0 args = () kw = {}
>>> func(1, 2, c=3)
a = 1 b = 2 c = 3 args = () kw = {}
>>> func(1, 2, 3, 'a', 'b')
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {}
>>> func(1, 2, 3, 'a', 'b', x=99)
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {'x': 99}

最神奇的是通过一个tuple和dict，你也可以调用该函数：

1
2
3
4

>>> args = (1, 2, 3, 4)
>>> kw = {'x': 99}
>>> func(*args, **kw)
a = 1 b = 2 c = 3 args = (4,) kw = {'x': 99}

递归函数

如果一个函数在内部调用自身，这个函数就是递归函数。
在Python中使用递归函数要注意栈溢出,在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。
解决递归调用栈溢出的方法是通过尾递归优化，事实上尾递归和循环的效果是一样的，所以，把循环看成是一种特殊的尾递归函数也是可以的。

• 尾递归是指，在函数返回的时候，调用自身本身，并且，return语句不能包含表达式。这样，编译器或者解释器就可以把尾递归做优化，使递归本身无论调用多少次，都只占用一个栈帧，不会出现栈溢出的情况。

断断续续的学了几次Python了，所谓不求甚解，语法过了一遍没去用忘了，又过一遍又没去用又忘了。虽然现在用Python的机会不多，还是真心喜欢这门语言。所以还是另起门户，把学习笔记记下来，免得自己捡起来又扔掉了。

Python是著名的“龟叔”Guido van Russum在1989年圣诞节期间，为了打发无聊的圣诞节而编写的一个编程语言（我的天。。。）。
牛逼闪闪的“龟叔”

Python提供了非常完善的基础代码库，覆盖了网络、文件、GUI、数据库、文本等大量内容，还有大量的第三方库。

Python的定位是优雅、明确、简单，Python是不能加密的，发布Python程序就相当于发布了源代码（到处都能看源代码，想想都有点小激动呢）。

安装Python

Mac

Python是Mac上的一等公民，天生自带。

Windows

1.从Python官网在下2.7.X版本
2.运行.MSI安装包，一路Nest即可
3.添加环境变量，即把Python的安装路径添加到系统环境变量path中去

Linux

没实践过不表，相信google、百度一大把

First Blood

国际惯例，我们编写一个Hello,World

在命令行里计入Python交互环境（Python，回车）：

1
2

>>> print "Hello,world"
Hello,world

完成。

输入与输出

输出

用print加上字符串，就可以向屏幕上输出指定的文字。比如输出'hello, world'，用代码实现如下：

1

>>> print 'hello, world'

print语句也可以跟上多个字符串，用逗号“,”隔开，就可以连成一串输出：

1
2

>>> print 'The quick brown fox', 'jumps over', 'the lazy dog'
The quick brown fox jumps over the lazy dog

输入

Python提供了一个raw_input，可以让用户输入字符串，并存放到一个变量里。比如输入用户的名字：

1
2
3
4

>>> name = raw_input()
zoe
>>> name
'zoe'

当你输入name = raw_input()并按下回车后，Python交互式命令行就在等待你的输入了。这时，你可以输入任意字符，然后按回车后完成输入。
我们在文本编辑器中编写一个完整版的试试：

1
2
3
4
5

# !/usr/bin/env python

name = raw_input('please enter your name:')
print 'hello,',name

在终端运行，切换到文件的目录(注意权限，可能需要chmod a+x)

1
2
3

./hello.py
please enter your name:zoe
hello, zoe

Python基础

Python以# 开头的语句是注解，注解是给人看的，所以解释器会忽略掉注释。其他没一行都是一个语句，当语句以冒号":"结尾时，所接的语句视为代码块。
还有一点值得注意，Python是大小写敏感的，大小写区分，如果写错了大小写，程序会报错

数据类型

整数

Python可以处理任意大小的整数，包括负整数，如：1,1000,-1000,0等，十六进度也使用0x前缀和0-9、a-f表示，如：0xffff,0xabcd1234等

浮点数

数学写法，如1.23、-4.5、3.1415926，科学计数法，把10用e表示，即1.23e9或13.54e-6。

字符串

字符串是以’’或””括起来的任意文本，比如”abc”,’123xyz’.Python也有转义字符，如\n、\t、\'等等。
Python 还允许用r''表示’’内的字符串默认不转义：

1
2
3
4

>>> print '\\\t\\'
\	\
>>> print r'\\\t\\'
\\\t\\

Python允许使用'''...'''表示多行内容

1
2
3
4
5
6
7
8

>>> print '''line1
... line2
... line3
... line4'''
line1
line2
line3
line4

布尔值

布尔只存在True、False两种值（注意大小写）
通过布尔运算：

1
2
3
4
5
6

>>> 3 > 3
False
>>> 3 >= 3
True
>>> 3 > 2
True

布尔值可以用and、or和not运算。

and运算是与运算，只有所有都为True，and运算结果才是True;
or运算是或运算，只要其中有一个为True，or运算结果就是True;
not运算是非运算，它是一个单目运算符，把True变成False，False变成True;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

>>> True and True
True
>>> True and False
False
>>> False and False
False
>>> True or True
True
>>> True or False
True
>>> False or False
False
>>> not True
False
>>> not False
True

空值

空值在Python里用None表示

变量

Python里的变量貌似缺少定义的过程，而且不限制数据类型，可以是任意的数据类型，命名方式与C相同：必须是大小写英文、数字和_的组合，且不能用数字开头

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

>>> a = 2
>>> b = 5
>>> c = a
>>> a = b
>>> b = c
>>> print a,b,c
5 2 2
``

### 常量

常量即不可变的量，但是Python根本没有任何机制保证常量不可变，通常使用全部大写的变量名，表示常量，而不去改变它。

### Python数据之我见

Python其实是把任何数据都当作对象，变量只是指向这些数据对象

### 字符编码

#### 字符编码

字符串也是一种数据类型，但是，字符串比较特殊的是还有一个编码问题。

因为计算机只能处理数字，如果要处理文本，就必须先把文本转换为数字才能处理。最早的计算机在设计时采用8个比特（bit）作为一个字节（byte），所以，一个字节能表示的最大的整数就是255（二进制11111111=十进制255），如果要表示更大的整数，就必须用更多的字节。比如两个字节可以表示的最大整数是65535，4个字节可以表示的最大整数是4294967295。

由于计算机是美国人发明的，因此，最早只有127个字母被编码到计算机里，也就是大小写英文字母、数字和一些符号，这个编码表被称为ASCII编码，比如大写字母A的编码是65，小写字母z的编码是122。

但是要处理中文显然一个字节是不够的，至少需要两个字节，而且还不能和ASCII编码冲突，所以，中国制定了GB2312编码，用来把中文编进去。

你可以想得到的是，全世界有上百种语言，日本把日文编到Shift_JIS里，韩国把韩文编到Euc-kr里，各国有各国的标准，就会不可避免地出现冲突，结果就是，在多语言混合的文本中，显示出来会有乱码。
因此，Unicode应运而生。Unicode把所有语言都统一到一套编码里，这样就不会再有乱码问题了。

Unicode标准也在不断发展，但最常用的是用两个字节表示一个字符（如果要用到非常偏僻的字符，就需要4个字节）。现代操作系统和大多数编程语言都直接支持Unicode。

现在，捋一捋ASCII编码和Unicode编码的区别：ASCII编码是1个字节，而Unicode编码通常是2个字节。

字母A用ASCII编码是十进制的65，二进制的01000001；

字母0用ASCII编码是十进制的48，二进制的00110000，注意字母'0'和整数0是不同的；

汉字中已经超出了ASCII编码的范围，用Unicode编码是十进制的20013，二进制的01001110 00101101。

你可以猜测，如果把ASCII编码的A用Unicode编码，只需要在前面补0就可以，因此，A的Unicode编码是00000000 01000001。

新的问题又出现了：如果统一成Unicode编码，乱码问题从此消失了。但是，如果你写的文本基本上全部是英文的话，用Unicode编码比ASCII编码需要多一倍的存储空间，在存储和传输上就十分不划算。

所以，本着节约的精神，又出现了把Unicode编码转化为“可变长编码”的UTF-8编码。UTF-8编码把一个Unicode字符根据不同的数字大小编码成1-6个字节，常用的英文字母被编码成1个字节，汉字通常是3个字节，只有很生僻的字符才会被编码成4-6个字节。如果你要传输的文本包含大量英文字符，用UTF-8编码就能节省空间：

|**字符**|**ASCII**|**Unicode**|**UTF-8**|
|---|---|---|---|
|A|01000001|00000000 01000001|01000001
|中|x|01001110|00101101	11100100|10111000 10101101|
从上面的表格还可以发现，UTF-8编码有一个额外的好处，就是ASCII编码实际上可以被看成是UTF-8编码的一部分，所以，大量只支持ASCII编码的历史遗留软件可以在UTF-8编码下继续工作。
用记事本编辑的时候，从文件读取的UTF-8字符被转换为Unicode字符到内存里，编辑完成后，保存的时候再把Unicode转换为UTF-8保存到文件：
![](https://github.com/zt1991616/blog/raw/master/Image/14031402.png)
浏览网页的时候，服务器会把动态生成的Unicode内容转换为UTF-8再传输到浏览器：
![](https://github.com/zt1991616/blog/raw/master/Image/14031403.png)

#### Python的字符串

Python提供了ord()和chr()函数，可以把字母和对应的数字相互转换：

ord(‘A’)
65

chr(65)
‘A’

1

Python在后来添加了对Unicode的支持，以Unicode表示的字符串用u'...'表示，比如：

print u’中文’
中文

u’中’
u’\u4e2d’

1
2

把u'xxx'转换为UTF-8编码的'xxx'用encode('utf-8')方法：

u’ABC’.encode(‘utf-8’)
‘ABC’

u’中文’.encode(‘utf-8’)
‘\xe4\xb8\xad\xe6\x96\x87’

1
2

len()函数可以返回字符串的长度：

len(u’ABC’)
3

len(‘ABC’)
3

len(u’中文’)
2

len(‘\xe4\xb8\xad\xe6\x96\x87’)
6

1
2

反过来，把UTF-8编码表示的字符串'xxx'转换为Unicode字符串u'xxx'用decode('utf-8')方法：

‘abc’.decode(‘utf-8’)
u’abc’

‘\xe4\xb8\xad\xe6\x96\x87’.decode(‘utf-8’)
u’\u4e2d\u6587’

print ‘\xe4\xb8\xad\xe6\x96\x87’.decode(‘utf-8’)
中文

1

由于Python源代码也是一个文本文件，所以，当你的源代码中包含中文的时候，在保存源代码时，就需要务必指定保存为UTF-8编码。当Python解释器读取源代码时，为了让它按UTF-8编码读取，我们通常在文件开头写上这两行：

!/usr/bin/env python

-- coding: utf-8 --

1
2
3
4
5
6
7
8

第一行注释是为了告诉Linux/OS X系统，这是一个Python可执行程序，Windows系统会忽略这个注释；

第二行注释是为了告诉Python解释器，按照UTF-8编码读取源代码，否则，你在源代码中写的中文输出可能会有乱码。

#### 格式化

格式化方式与C语言抑制，用`%`实现
例如：

‘Hello, %s’ % ‘world’
‘Hello, world’

‘Hi, %s, you have $%d.’ % (‘Zoe’, 1000000)
‘Hi, Zoe, you have $1000000.’

|%d|整数|
|---|---|
|%f|浮点数|
|%s|字符串|
|%x|十六进制数|