Python的一些小知识
Python 第一个版本于1989年圣诞节发布
Python2.0 2000年发布
Python3 2008年发布 不兼容python2，目前两者共存
通常所说的python由C开发，除此之外还有jython（java开发），ironpython(运行在.net平台上，兼容.net库)
pypy（由python写的python）
此篇博客主要运用python2.7
第一个简单的python程序
直接使用交互式Python
1 | root@tonglele /mnt # python |
使用vim编辑一个python程序，并用python指令运行
vim test.py1
2#!/usr/bin/env python
print "hello world"
此时：第一行 #!/usr/bin/env python 表示引用环境变量里自定义的python版本，具有可移植性，推荐这种写法
也可以写成 #!/usr/bin/python 这种写法直接引用系统默认的python版本，这样此程序移植到其他机子上运行的时候可能和你预期使用的版本不同
结果：1
2root@tonglele /mnt # python test.py
hello world
或者：1
2
3
4
5
6root@tonglele /mnt # ll
total 4.0K
-rw-r--r-- 1 root root 42 Jun 4 21:10 test.py
root@tonglele /mnt # chmod +x test.py
root@tonglele /mnt # ./test.py
hello world
输出汉字的问题
由于python2的发布在unicode发布之前，所以它默认的是ascii编码，在我们想要显示汉字时应该显示的指定编码1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 root@tonglele /mnt # cat test.py :(
#!/usr/bin/env python
print "hello world"
print "你好！世界！"
root@tonglele /mnt # ./test.py
File "./test.py", line 4
SyntaxError: Non-ASCII character '\xe4' in file ./test.py on line 4, but no encoding declared; see http://www.python.org/peps/pep-0263.html for details
)
root@tonglele /mnt # cat test.py
#!/usr/bin/env python
# coding=utf-8
print "hello world"
print "你好！世界！"
root@tonglele /mnt # ./test.py
hello world
你好！世界！
基本概念
变量
指向内存中一段区域的符号（类似于C中的指针）
命名规范：由字母，数字，下划线，组成，不以数字开头，关键字不能作为变量名
python中的所有变量都是引用
数据类型
首先介绍一个函数type（），它可以查看变量或常量的数据类型1
2
3
4
5
6
7
8
9
10
11>>> type(1)
<type 'int'>
>>> a = 1
>>> type(1)
<type 'int'>
>>> type(2)
<type 'int'>
>>> type(2.0)
<type 'float'>
>>> type(True)
<type 'bool'>
python是一种强类型的动态语言,每一个数据都有一个类型,不同类型之间的数据不能做运算,如数字和字符不能相加.所谓的动态语言是指,数据类型可以
在运算时改变
在python中数据类型分为字符串型和数字型（整型，浮点型，长整型）1
2
3
4
5
6
7
8
9
10
11>>> a = 'tonglele' #字符串型
>>> b = 10 #整型
>>> c = 2.3 #浮点型
>>> b + c
12.3 #都是数字型则可以相加
>>> a +b #一个数字型一个字符串型，相加会报错
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: cannot concatenate 'str' and 'int' objects
>>> int(c) #c为浮点型，精度比整型高，所以在从高精度向低精度转化时会有数据损失
2
运算符和表达式
算术运算符 + / * // %
位操作运算符<< >> & | ^ ~
比较运算符 < <= >= == > !=
逻辑运算符 and or not
赋值运算符 =
其他运算符1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20>>> 7 / 2 #两个整型相除得到一个整型，精度丢失问题
3
>>> 7 /2.0 #将其中一个换为float类型，得到的为float类型
3.5
>>> 3 ** 2 #幂运算
9
>>> 10 // 3 #除法取整
3
>>> 10 % 3 #取余
1
>>> 2 << 3 #左移位 （效率高）
16
>>> 8 >> 2 #右移位（效率高）
2
>>> 3 & 2 #按位与
2
>>> 3 | 2 #按位或
3
>>> 3 ^ 2 #异或
1
优先级
单目运算符高于双目运算符,not例外; 单目运算符,只有一个数的运算符,如正负号,按位取反,not .python里没有三目运算符
算数运算符高于位运算符
位运算符高于比较运算符
比较运算符高于逻辑运算符
赋值运算符优先级最低
（）提示运算符的优先级
程序结构
if-else语句
if condition:
expression1
2
3
4
5
6
7
8root@tonglele /mnt # cat if.py
#!/usr/bin/env python
if 3 < 4:
print "3 less than 5"
else:
print "4 less than 3"
root@tonglele /mnt # python if.py
3 less than 5
elif语句
python中没有switch case语句，但我们可以用很多个elif语句，完成的效果相同1
2
3
4
5
6
7
8
9
#!/usr/bin/env python
a = 1
if a == 1:
print "a is 1"
elif a == 2: #可以有多个elif
print "a is 2"
else:
print "a is ?"
循环结构
while 语句
1 | vim while.py |
for语句
for item in iterator:
expression1
2
3
4
5
6
7
8
9
10
11
12
13
14
15#!/usr/bin/env python
for i in range(1,10): #in 后跟一个迭代器
print i
======结果=====
root@tonglele /mnt # python for.py
1
2
3
4
5
6
7
8
9
python内置容器
列表
列表是我们常用的一种内置的容器，它可以将不同数据类型的值存储再一个列表中。
初始化一个列表
1 | >>> li = [] |
列表的下标
列表是有序的，下标从0开始1
2
3
4
5
6
7>>> li = [1,2,3,4]
>>> li[0]
1
>>> li[2]
3
>>> len(li) #len()函数，得到list的长度
4
一些简单的操作
1 | >>> li |
列表（list 对象）的一些方法
1 | >>> dir(li) #查看li的方法 |
append
在原列表后追加元素1
2
3
4
5
6
7
8>>> li
[1, 2, 3, 4, 5, 5]
>>> li.append(100)
>>> li
[1, 2, 3, 4, 5, 5, 100]
>>> li.append([90,89])
>>> li
[1, 2, 3, 4, 5, 5, 100, [90, 89]]
extend
在列表后扩展1
2
3
4
5
6>>> li = [1,4,5]
>>> li
[1, 4, 5]
>>> li.extend([9,80,777])
>>> li
[1, 4, 5, 9, 80, 777]
insert
向列表中插入元素1
2
3
4
5>>> li
[1, 2, 3, 222, 4]
>>> li.insert(1,'hello') #第一个参数为插入的位置的下标，第二个参数为要插入的元素
>>> li
[1, 'hello', 2, 3, 222, 4]
remove
删除列表中的元素1
2
3
4
5
6
7
8>>> li
[1, 1, 2, 4]
>>> li.remove(1) #如果这个元素在列表中出现多次，默认删除下标值小的那个
>>> li
[1, 2, 4]
>>> li.remove(4)
>>> li
[1, 2]
pop
返回一个列表中的元素，可以指定下标，若未指定则默认为最后一个,并将其从列表中删除1
2
3
4
5
6
7
8
9
10
11>>> li
[2, 3, 5, 6]
>>> a = li.pop()
>>> a
6
>>> li
[2, 3, 5]
>>>
>>> b = li.pop(1)
>>> b
3
count
返回某个值在列表中出现的次数1
2
3
4
5
6>>> li
['a', 'a', 1, 1, 7]
>>> li.count('a')
2
>>> li.count(7)
1
index
返回第一个所查值的下标:1
2
3
4
5
6
7
8>>> li
['a', 'a', 1, 1, 7]
>>> li.index(1)
2
>>> li.index('a')
0
>>> li.index(7)
4
sort
对列表按升序排列1
2
3
4>>> li = [2,6,3,7,10]
>>> li.sort()
>>> li
[2, 3, 6, 7, 10]
reverse
将列表反转
1 | >>> li |
list切片
1 | >>> li |
列表的切片操作是一个复制操作,并不对原始列表进行修改。
列表解析
[expression for item in iterator]
此处只做简要介绍，具体使用我会再开一篇博文1
2
3
4
5
6
7
8
9
10
11
12>>> li
[10, 7, 6, 3, 2, 1000]
>>> [x + 1 for x in li]
[11, 8, 7, 4, 3, 1001]
>>> t = (x + 1 for x in li) #得到一个生成器
>>> t.next()
11
>>> t.next()
8
>>> t.next()
7
元组
元组是有序的，元组的元素是不可改变的，元组的元素也支持下标操作
定义和初始化元祖（tuple）
1 | >>> t = () |
元组的切片操作
1 | >>> t |
元组中列表元素的修改
1 | >>> t |
元组的count,index
1 | >>> t = (1,1,'a','hello',[1,2]) |
集合
集合是无序的，集合中的元素不重复，python根据合中的每个元素的hash值来判断是否重复,所以集合中的每个元素必须是可hash的对象。在python中如果一个对象有一个hash 的方法,
表示该对象可hash
集合不支持切片操作1
2
3
4
5
6
7
8
9
10
11
12
13
14
15>>> s = set() #集合的定义方式
>>> type(s)
<type 'set'>
>>> s1 = {} #不能这样定义集合，这样的定义为字典
>>> type(s1)
<type 'dict'>
>>> s = {1,1,1,3,'a','hello'}
>>> s
set(['a', 1, 3, 'hello']) #集合中的元素不重复，无序
>>> s = {1,1,1,3,'a','hello',[1,2]}
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list' #集合中的元素必须可哈希
集合的一些简单操作
add
向集合中增加元素1
2
3
4
5>>> s
set(['a', 1, 3, 'hello'])
>>> s.add(23)
>>> s
set(['a', 1, 3, 'hello', 23])
update
迭代器作为参数,将迭代器中的所有元素追加到集合中1
2
3
4
5>>> s
set(['a', 1, 3, 'hello', 23])
>>> s.update([4,67,'hu'])
>>> s
set(['a', 1, 3, 4, 'hu', 67, 23, 'hello'])
remove
删除集合中的某个元素，若不存在则报错1
2
3
4
5
6
7
8
9
10>>> s
set(['a', 1, 3, 4, 'hu', 67, 23, 'hello'])
>>> s.remove(1)
>>> s
set(['a', 3, 4, 'hu', 67, 23, 'hello'])
>>> s.remove(100)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 100
"</stdin>"
discard
删除某个元素,若该元素不存在则不做任何操作。1
2
3
4
5
6
7
8>>> s
set(['a', 3, 4, 'hu', 67, 23, 'hello'])
>>> s.discard(4)
>>> s
set(['a', 3, 'hu', 67, 23, 'hello'])
>>> s.discard(100)
>>> s
set(['a', 3, 'hu', 67, 23, 'hello'])
pop
随机删除某个元素,并返回该元素
1 | >>> s |
clear
清空集合1
2
3
4
5>>> s
set(['hu', 67, 23, 'hello'])
>>> s.clear()
>>> s
set([])
集合的运算
difference
两个集合的差集，不修改原来两个集合1
2
3
4
5
6
7
8>>> s1 = {1,2,3,4}
>>> s2 = {4,5,6,7}
>>> s1.difference(s2)
set([1, 2, 3])
>>> s2.difference(s1)
set([5, 6, 7])
>>> s1 -s2 #也可直接用减号
set([1, 2, 3])
difference_update
两个集合的差集,但修改原来的集合,不返回值1
2
3
4
5
6
7>>> s1
set([1, 2, 3, 4])
>>> s2
set([4, 5, 6, 7])
>>> s1.difference_update(s2)
>>> s1
set([1, 2, 3])
intersection intersection_update
intersection 两个集合的交集,返回值,不修改原来的集合
intersection_update 两个集合的交集,无返回值,修改原来的集合
具体实现参见difference difference_update
其他
1 | >>> s1 |
字典
初始化
1 | >>> t = {} |
字典的一些操作
keys
将字典的所有key作为一个列表返回1
2
3
4>>> t
{'name': 'tonglele', 'age': 18}
>>> t.keys()
['name', 'age']
iterkeys
将字典的所有key作为一个迭代器返回1
2
3
4
5
6
7
8
9
10
11
12
13>>> t
{'name': 'tonglele', 'age': 18}
>>> t.iterkeys()
<dictionary-keyiterator object at 0x7f295c40ec00>
>>> it = t.iterkeys()
>>> it.next()
'name'
>>> it.next()
'age'
>>> it.next()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration
values
返回一个列表,该列表是所有元素的值1
2
3
4>>> t
{'name': 'tonglele', 'age': 18}
>>> t.values()
['tonglele', 18]
items
返回一个列表,列表中的每个元素是一个元组,元组中的两个值分别是key和value1
2
3
4
5
6
7
8
9
10
11
12
13>>> t
{'name': 'tonglele', 'age': 18}
>>> t.values()
['tonglele', 18]
>>> t
{'name': 'tonglele', 'age': 18}
>>> t.items()
[('name', 'tonglele'), ('age', 18)]
>>> for i,j in t.items():
... print i,j
...
name tonglele
age 18
get
按照key取值,若存在则返回,否则返回None
可以给get 传递第二个参数,表示若key不存在,则返回这个值。1
2
3
4
5
6
7>>> t
{'name': 'tonglele', 'age': 18}
>>> t.get('name')
'tonglele'
>>> t.get('num')
>>> t.get('num',9)
9
has_key
判断某个key是否存在,返回True/False1
2
3
4
5
6>>> t
{'name': 'tonglele', 'age': 18}
>>> t.has_key('name')
True
>>> t.has_key('num')
False
给字典一个键值对
1 | >>> t |
Python 字典为引用传值
1 | >>> t1 = t |
字典的复制
1 | >>> t |
感谢阅读，欢迎指正。