Python 基础知识

1.空值

空值是Python中特殊的一个值，用None表示。None不能理解为0，因为0是有意义的也不能理解为 ‘ ’ 。

2.输出 print

print 语句可以连接多个字符串，用逗号“,”隔开，就可以连接成一个字符串输出。print会依次打印每个字符串，遇到逗号“,”会输出一个空格，因此，输出的字符串是这样拼起来的：

 

3.Python中raw字符串与多行字符串

如果一个字符串包含很多需要转义的字符，对每一个字符都进行转义会很麻烦。为了避免这种情况，我们可以在字符串前面加个前缀 r ，表示这是一个 raw 字符串，里面的字符就不需要转义了。例如：

r'\(~_~)/ \(~_~)/'

如果要表示多行字符串，可以用'''...'''表示：

'''Line 1
Line 2
Line 3'''

4.Python中整数和浮点数

和数学运算不同的地方是，Python的整数运算结果仍然是整数，浮点数运算结果仍然是浮点数：

1 + 2 # ==> 整数 3
1.0 + 2.0 # ==> 浮点数 3.0

但是整数和浮点数混合运算的结果就变成浮点数了：
1 + 2.0 # ==> 浮点数 3.0

那整数的除法运算遇到除不尽的时候，结果难道不是浮点数吗？我们来试一下：
11 / 4 # ==> 2

令很多初学者惊讶的是，Python的整数除法，即使除不尽，结果仍然是整数，余数直接被扔掉。不过，Python提供了一个求余的运算 % 可以计算余数：

11 % 4 # ==> 3

如果我们要计算 11 / 4 的精确结果，按照“整数和浮点数混合运算的结果是浮点数”的法则，把两个数中的一个变成浮点数再运算就没问题了：
11.0 / 4 # ==> 2.75

Python 中的布尔类型

与运算：只有两个布尔值都为 True 时，计算结果才为 True。

True and True   # ==> True
True and False   # ==> False
False and True   # ==> False
False and False   # ==> False

或运算：只要有一个布尔值为 True，计算结果就是 True。

True or True   # ==> True
True or False   # ==> True
False or True   # ==> True
False or False   # ==> False

非运算：把True变为False，或者把False变为True：

not True   # ==> False
not False   # ==> True


Python把0、空字符串''和None看成 False，其他数值和非空字符串都看成 True

>>> a = 'python'
>>> print 'hello,', a or 'world'
hello, python
>>> b = ''
>>> print 'hello,', b or 'world'
hello, world

 

5.Python创建list

Python内置的一种数据类型是列表：list。list是一种有序的集合，可以随时添加和删除其中的元素。 　　由于python是动态语言完全可以包含多种数据类型

>>> classmates = ['Michael', 'Bob', 'Tracy']
>>> classmates # 打印classmates变量的内容
['Michael', 'Bob', 'Tracy']

>>> L = ['Michael', 100 ,true]

需要特别注意的是，索引从 0 开始，也就是说，第一个元素的索引是0，第二个元素的索引是1，以此类推。

因此，要打印第一名同学的名字，用 L[0]:

>>> print L[0]
Adam

Bart同学是最后一名，俗称倒数第一，所以，我们可以用 -1 这个索引来表示最后一个元素：

>>> print L[-1]
Bart

Bart同学表示躺枪。

Python之添加新元素

>>> L = ['Adam', 'Lisa', 'Bart']
>>> L.append('Paul')
>>>print L

['Adam', 'Lisa', 'Bart', 'Paul']

append()总是把新的元素添加到 list 的尾部。

方法是用list的 insert()方法，它接受两个参数，第一个参数是索引号，第二个参数是待添加的新元素：

>>> L = ['Adam', 'Lisa', 'Bart']
>>> L.insert(0, 'Paul')
>>> print L
['Paul', 'Adam', 'Lisa', 'Bart']

Python从list删除元素 如果Paul同学排在最后一个，我们可以用list的pop()方法删除：

>>> L = ['Adam', 'Lisa', 'Bart', 'Paul']
>>> L.pop()
'Paul'
>>>print L

['Adam', 'Lisa', 'Bart']

List中删除指定元素 pop(2) 删掉第三个元素

>>> L = ['Adam', 'Lisa', 'Paul', 'Bart']

>>> L.pop(2)

'Paul'
>>> print L
['Adam', 'Lisa', 'Bart']

Python中替换元素  对list中的某一个索引赋值，就可以直接用新的元素替换掉原来的元素，list包含的元素个数保持不变。

L = ['Adam', 'Lisa', 'Bart']
>>> L[2] = 'Paul'
>>> print L
L = ['Admin', 'Lisa', 'Paul']

由于Bart还可以用 -1 做索引，因此，下面的代码也可以完成同样的替换工作：

>>> L[-1] = 'Paul'

Python之创建tuple

tuple是另一种有序的列表，中文翻译为“ 元组 ”。tuple 和 list 非常类似，但是，tuple一旦创建完毕，就不能修改了。 创建tuple和创建list唯一不同之处是用( )替代了[ ]。

同样是表示班里同学的名称，用tuple表示如下：

>>> t = ('Admin', 'Lisa', 'Bart')

 

因为用()定义单元素的tuple有歧义，所以 Python 规定，单元素 tuple 要多加一个逗号“,”，这样就避免了歧义：

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

当tuple中包含一个list时，由于List可以改变导致Tuple‘也可以改变’

>>> t = ('a', 'b', ['A', 'B'])

注意到 t 有 3 个元素：'a'，'b'和一个list：['A', 'B']。list作为一个整体是tuple的第3个元素。list对象可以通过 t[2] 拿到：

>>> L = t[2]

然后，我们把list的两个元素改一改：

>>> L[0] = 'X'
>>> L[1] = 'Y'

再看看tuple的内容：

>>> print t
('a', 'b', ['X', 'Y'])

 

 

6.Python之什么是dict

Python的 dict 就是专门干这件事的。用 dict 表示“名字”-“成绩”的查找表如下：

d = {
    'Adam': 95,
    'Lisa': 85,
    'Bart': 59
}

我们把名字称为key，对应的成绩称为value，dict就是通过 key 来查找 value。

注意: 通过 key 访问 dict 的value，只要 key 存在，dict就返回对应的value。如果key不存在，会直接报错：KeyError。

要避免 KeyError 发生，有两个办法：

一是先判断一下 key 是否存在，用 in 操作符：

if 'Paul' in d:
    print d['Paul']

如果 'Paul' 不存在，if语句判断为False，自然不会执行 print d['Paul'] ，从而避免了错误。

 

二是使用dict本身提供的一个 get 方法，在Key不存在的时候，返回None： （推荐使用第二种方法）

>>> print d.get('Bart')
59
>>> print d.get('Paul')
None


Python循环遍历字典元素

d = {
'Adma' : 95,
'Lisa' : 85,
'Bart' : 59
}

for key, value in d.items():
print key, ':', value

 

Python更新dict

dict是可变的，也就是说，我们可以随时往dict中添加新的 key-value。比如已有dict：

d = {
    'Adam': 95,
    'Lisa': 85,
    'Bart': 59
}

要把新同学'Paul'的成绩 72 加进去，用赋值语句：

>>> d['Paul'] = 72

再看看dict的内容：

>>> print d
{'Lisa': 85, 'Paul': 72, 'Adam': 95, 'Bart': 59}

Python中什么是set

dict的作用是建立一组 key 和一组 value 的映射关系，dict的key是不能重复的。

有的时候，我们只想要 dict 的 key，不关心 key 对应的 value，目的就是保证这个集合的元素不会重复，这时，set就派上用场了。

set 持有一系列元素，这一点和 list 很像，但是set的元素没有重复，而且是无序的，这点和 dict 的 key很像。

创建 set 的方式是调用 set() 并传入一个 list，list的元素将作为set的元素：

 

>>> s = set(['A', 'B', 'C'])

 

L = ['Adam', 'Lisa', 'Bart', 'Paul']
s = set(L)

 

Python之 访问set

由于set存储的是无序集合，所以我们没法通过索引来访问，但是可以通过in操作符判断

>>> s = set(['Adam', 'Lisa', 'Bart', 'Paul'])

我们可以用 in 操作符判断：

Bart是该班的同学吗？

>>> 'Bart' in s
True

Bill是该班的同学吗？

>>> 'Bill' in s
False

bart是该班的同学吗？

>>> 'bart' in s
False

Python之 遍历set

由于 set 也是一个集合，所以，遍历 set 和遍历 list 类似，都可以通过 for 循环实现。

直接使用 for 循环可以遍历 set 的元素：

直接使用 for 循环可以遍历 set 的元素：

>>> s = set(['Adam', 'Lisa', 'Bart'])
>>> for name in s:
...     print name
... 
Lisa
Adam
Bart

Python之 更新set    注：用add()可以直接添加，而remove()前需要判断。

由于set存储的是一组不重复的无序元素，因此，更新set主要做两件事：

一是把新的元素添加到set中，二是把已有元素从set中删除。

添加元素时，用set的add()方法：  如果添加的元素已经存在于set中，add()不会报错，但是不会加进去了：

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

删除set中的元素时，用set的remove()方法： 如果删除的元素不存在set中，remove()会报错：

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

Python之调用函数

 int()函数可以把其他数据类型转换为整数：     str()函数把其他类型转换成 str：

可以在交互式命令行通过 help(abs) 查看abs函数的帮助信息。

调用 abs 函数：

>>> abs(100)
100
>>> abs(-20)
20
>>> abs(12.34)
12.34

而比较函数 cmp(x, y) 就需要两个参数，如果 x<y，返回 -1，如果 x==y，返回 0，如果 x>y，返回 1：

>>> cmp(1, 2)
-1
>>> cmp(2, 1)
1
>>> cmp(3, 3)
0

Python之编写函数

如果没有return语句，函数执行完毕后也会返回结果，只是结果为 None。 return None可以简写为return。

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

我们以自定义一个求绝对值的 my_abs 函数为例：

def my_abs(x):
    if x >= 0:
        return x
    else:
        return -x

Python之定义默认参数

定义函数的时候，还可以有默认参数。

例如Python自带的 int() 函数，其实就有两个参数，我们既可以传一个参数，又可以传两个参数：    

int()函数的第二个参数是转换进制，如果不传，默认是十进制 (base=10)，如果传了，就用传入的参数。

>>> int('123')
123
>>> int('123', 8)
83

Python之定义可变参数

如果想让一个函数能接受任意个参数，我们就可以定义一个可变参数：

 def fn(*args):
　　 print args

>>> fn()
()
>>> fn('a')
('a',)
>>> fn('a', 'b')
('a', 'b')
>>> fn('a', 'b', 'c')
('a', 'b', 'c')

对list进行切片

取一个list的部分元素是非常常见的操作。比如，一个list如下：

>>> L = ['Adam', 'Lisa', 'Bart', 'Paul']
取前3个元素，用一行代码就可以完成切片：
>>> L[0::3]
L[0:3]表示，从索引0开始取，直到索引3为止，但不包括索引3。即索引0，1，2，正好是3个元素。如果第一个数字是0还可以省略。 L[:3]
也可以从索引1开始，取出2个元素出来：
>>>L[1:3]
只用一个 : ，表示从头到尾：
>>>L[:] 相当于复制一份list

切片操作还可以指定第三个参数： 第三个参数表示每N个取一个，上面的 L[::2] 会每两个元素取出一个来，也就是隔一个取一个

>>> L[::2]
['Adam', 'Bart']

倒序切片

对于list，既然Python支持L[-1]取倒数第一个元素，那么它同样支持倒数切片，试试：

>>> L = ['Adam', 'Lisa', 'Bart', 'Paul']

>>> L[-2:]
['Bart', 'Paul']

>>> L[:-2]
['Adam', 'Lisa']

>>> L[-3:-1]
['Lisa', 'Bart']

>>> L[-4:-1:2]
['Adam', 'Bart']

记住倒数第一个元素的索引是-1。倒序切片包含起始索引，不包含结束索引。

对字符串切片

取除首字母外的字符串用[1:]

s = 'abcdefg'

s[1:]>>'bcdefg'

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

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

注意：字符串有个方法 upper() 可以把字符变成大写字母：

>>> 'abc'.upper()
'ABC'

什么是迭代

在Python中，如果给定一个list或tuple，我们可以通过for循环来遍历这个list或tuple，这种遍历我们成为迭代（Iteration）。

 

注意: 集合是指包含一组元素的数据结构，我们已经介绍的包括：
1. 有序集合：list，tuple，str和unicode；
2. 无序集合：set
3. 无序集合并且具有 key-value 对：dict

 

索引迭代

Python中，迭代永远是取出元素本身，而非元素的索引。

对于有序集合，元素确实是有索引的。有的时候，我们确实想在 for 循环中拿到索引，怎么办？

方法是使用 enumerate() 函数：

>>> L = ['Adam', 'Lisa', 'Bart', 'Paul']
>>> for index, name in enumerate(L):
...     print index, '-', name
... 
0 - Adam
1 - Lisa
2 - Bart
3 - Paul

zip()函数可以把两个 list 变成一个 list：

>>> zip([10, 20, 30], ['A', 'B', 'C'])
[(10, 'A'), (20, 'B'), (30, 'C')]

迭代dict的value

dict 对象有一个 values() 方法，或者 itervalues()这个方法把dict转换成一个包含所有value的list，这样，我们迭代的就是 dict的每一个 value：

d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
print d.values()
# [85, 95, 59]
for v in d.values():
 print v # 85 # 95 # 59

那这两个方法有何不同之处呢？

1. values() 方法实际上把一个 dict 转换成了包含 value 的list。

2. 但是 itervalues() 方法不会转换，它会在迭代过程中依次从 dict 中取出 value，所以 itervalues() 方法比 values() 方法节省了生成 list 所需的内存。

3. 打印 itervalues() 发现它返回一个 <dictionary-valueiterator> 对象，这说明在Python中，for 循环可作用的迭代对象远不止 list，tuple，str，unicode，dict等，任何可迭代对象都可以作用于for循环，而内部如何迭代我们通常并不用关心。

 

 

迭代dict的key和value

 

我们了解了如何迭代 dict 的key和value，那么，在一个 for 循环中，能否同时迭代 key和value？答案是肯定的。

items()或者iteritems() 方法把dict对象转换成了包含tuple的list，我们对这个list进行迭代，可以同时获得key和value：

iteritems() 不把dict转换成list，而是在迭代过程中不断给出 tuple，所以， iteritems() 不占用额外的内存。

>>> for key, value in d.items():
...     print key, ':', value
... 
Lisa : 85
Adam : 95
Bart : 59

生成列表（列表生成式）

提示：range(1, 100, 2) 可以生成list [1, 3, 5, 7, 9,...]

要生成list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]，我们可以用range(1, 11)：

>>> range(1, 11)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
但如果要生成[1x1, 2x2, 3x3, ..., 10x10]怎么做？方法一是循环

但是循环太繁琐，而列表生成式则可以用一行语句代替循环生成的list：

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

字符串的join()方法可以把一个 list 拼接成一个字符串。

条件过滤

列表生成式的 for 循环后面还可以加上 if 判断。例如：

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

有了 if 条件，只有 if 判断为 True 的时候，才把循环的当前元素添加到列表中。

 

1. isinstance(x, str) 可以判断变量 x 是否是字符串；

2. 字符串的 upper() 方法可以返回大写的字母。

 

多层表达式

for循环可以嵌套，因此，在列表生成式中，也可以用多层 for 循环来生成列表。

对于字符串 'ABC' 和 '123'，可以使用两层循环，生成全排列：

>>> [m + n for m in 'ABC' for n in '123']
['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3']