(1) Python优缺点:
优点:
1.Python有非常完善的基础代码库,覆盖了网络、文件、GUI、数据库、文本等大量内容,除了内置的库外,Python还有大量的第三方库;
2.Python应用: 首选是网络应用,包括网站、后台服务等等;其次是许多日常需要的小工具,包括系统管理员需要的脚本任务等等;另外就是把其他语言开发的程序再包装起来,方便使用.
缺点:
1. 第一个缺点就是运行速度慢,和C程序相比非常慢;
2. 第二个缺点就是代码不能加密;
(2) Python安装
采用Python2.7,下面是第一个程序:
# hello.py print 'hello, world!' print '100+200 =', 100+200 name = raw_input('please enter your name:') print '------------------\n', 'hello,', name # ################################# # print absolute value of an integer: a = 100 if a >= 0: print a else: print -a # #################################
(3)Python数据类型
1. 整数
2. 浮点数
3. 字符串:
# 转义字符\. 'I\'m \"OK\"!' # 表示的字符串内容是: I'm "OK"! # 如果字符串内部有很多换行,用\n写在一行里不好阅读,为了简化,Python允许用'''...'''的格式表示多行内容 >>> print '''line1 ... line2 ... line3''' # 上面是在交互式命令行内输入,如果写成程序,就是: print '''line1 line2 line3'''
4. 布尔值: True, False;布尔值可以用
and
、or
和not
运算;
5. 空值: 一个特殊的值,用None
表示。None
不能理解为0
,因为0
是有意义的,而None
是一个特殊的空值;
6. 变量:
在Python中,等号=
是赋值语句,可以把任意数据类型赋值给变量,同一个变量可以反复赋值,而且可以是不同类型的变量;这种变量本身类型不固定的语言称之为动态语言,与之对应的是静态语言;
# a是整数 a = 123 print a # a变为字符串 a = 'ABC' print a
理解变量在计算机内存中的表示也非常重要。当我们写:
a = ‘ABC‘
时,Python解释器干了两件事情:
1. 在内存中创建了一个‘ABC‘
的字符串;
2. 在内存中创建了一个名为a
的变量,并把它指向‘ABC‘
。
也可以把一个变量a
赋值给另一个变量b
,这个操作实际上是把变量b
指向变量a
所指向的数据,例如下面的代码:
a = 'ABC' b = a a = 'XYZ' print b
最后一行打印出变量
b
的内容到底是‘ABC‘
呢还是‘XYZ‘
?如果从数学意义上理解,就会错误地得出b
和a
相同,也应该是‘XYZ‘
,但实际上b
的值是‘ABC‘
,让我们一行一行地执行代码,就可以看到到底发生了什么事:
执行a = ‘ABC‘
,解释器创建了字符串‘ABC‘
和变量a
,并把a
指向‘ABC‘
:
执行b = a
,解释器创建了变量b
,并把b
指向a
指向的字符串‘ABC‘
:
执行a = ‘XYZ‘
,解释器创建了字符串‘XYZ‘,并把a
的指向改为‘XYZ‘
,但b
并没有更改:
所以,最后打印变量b
的结果自然是‘ABC‘
了。
7. 常量
所谓常量就是不能变的变量,比如常用的数学常数π就是一个常量。在Python中,通常用全部大写的变量名表示常量:
PI = 3.14159265359
但事实上PI
仍然是一个变量,Python根本没有任何机制保证PI
不会被改变,所以,用全部大写的变量名表示常量只是一个习惯上的用法,如果你一定要改变变量PI
的值,也没人能拦住你。
最后解释一下整数的除法为什么也是精确的,可以试试:
>>> 10 / 3
3
你没有看错,整数除法永远是整数,即使除不尽。要做精确的除法,只需把其中一个整数换成浮点数做除法就可以:
>>> 10.0 / 3
3.3333333333333335
因为整数除法只取结果的整数部分,所以Python还提供一个余数运算,可以得到两个整数相除的余数:
>>> 10 % 3
1
无论整数做除法还是取余数,结果永远是整数,所以,整数运算结果永远是精确的。
(4) 字符串和编码
1. 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 |
2. 在计算机内存中,统一使用Unicode编码,当需要保存到硬盘或者需要传输的时候,就转换为UTF-8编码。
用记事本编辑的时候,从文件读取的UTF-8字符被转换为Unicode字符到内存里,编辑完成后,保存的时候再把Unicode转换为UTF-8保存到文件:
浏览网页的时候,服务器会把动态生成的Unicode内容转换为UTF-8再传输到浏览器:
所以你看到很多网页的源码上会有类似<meta charset="UTF-8" />
的信息,表示该网页正是用的UTF-8编码。
3. Python提供了ord()和chr()函数,可以把字母和对应的数字相互转换:
>>> ord('A') 65 >>> chr(65) 'A'
4. 把u‘xxx‘
转换为UTF-8编码的‘xxx‘
用encode(‘utf-8‘)
方法:
>>> u‘ABC‘.encode(‘utf-8‘)
‘ABC‘
>>> u‘中文‘.encode(‘utf-8‘)
‘\xe4\xb8\xad\xe6\x96\x87‘
5. 反过来,把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‘)
中文
6. 由于Python源代码也是一个文本文件,所以,当你的源代码中包含中文的时候,在保存源代码时,就需要务必指定保存为UTF-8编码。当Python解释器读取源代码时,为了让它按UTF-8编码读取,我们通常在文件开头写上这两行:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
第一行注释是为了告诉Linux/OS X系统,这是一个Python可执行程序,Windows系统会忽略这个注释;
第二行注释是为了告诉Python解释器,按照UTF-8编码读取源代码,否则,你在源代码中写的中文输出可能会有乱码。
7. 格式化字符串的方式
# %d 整数 # %f 浮点数 # %s 字符串 # %x 十六进制整数 # 如果只有一个%?,括号可以省略 print 'Hello, %s' % 'world' print 'Hi, %s, you have $%d.' % ('xiaotian', 1000000) print '%10d-%08d' % (3, 1) print '%.4f' % 3.1415926 # 用%%来表示一个% print 'growth rate: %d%%' % 7 # 对于Unicode字符串,用法完全一样 print u'Hi, %s' % u'xiaotian'
(5) list和tuple
Python内置的一种数据类型是列表:list。list是一种有序的集合,可以随时添加和删除其中的元素:
>>> classmates = ['Michael', 'Bob', 'Tracy'] >>> classmates # ['Michael', 'Bob', 'Tracy'] # 变量classmates就是一个list。用len()函数可以获得list元素的个数: >>> len(classmates) # 3 # 用索引来访问list中每一个位置的元素,记得索引是从0开始的: >>> classmates[0] # 'Michael' # 记得最后一个元素的索引是len(classmates) - 1。 # 如果要取最后一个元素,除了计算索引位置外,还可以用-1做索引,直接获取最后一个元素: >>> classmates[-1] # 'Tracy' # 以此类推,可以获取倒数第2个、倒数第3个: >>> classmates[-2] # 'Bob' # list是一个可变的有序表,所以,可以往list中追加元素到末尾: >>> classmates.append('Adam') >>> classmates # ['Michael', 'Bob', 'Tracy', 'Adam'] # 也可以把元素插入到指定的位置,比如索引号为1的位置: >>> classmates.insert(1, 'Jack') >>> classmates # ['Michael', 'Jack', 'Bob', 'Tracy', 'Adam'] # 要删除list末尾的元素,用pop()方法: >>> classmates.pop() # 'Adam' >>> classmates # ['Michael', 'Jack', 'Bob', 'Tracy'] # 要删除指定位置的元素,用pop(i)方法,其中i是索引位置: >>> classmates.pop(1) # 'Jack' >>> classmates # ['Michael', 'Bob', 'Tracy'] # 要把某个元素替换成别的元素,可以直接赋值给对应的索引位置: >>> classmates[1] = 'Sarah' >>> classmates # ['Michael', 'Sarah', 'Tracy'] # list里面的元素的数据类型也可以不同,比如: >>> L = ['Apple', 123, True] # list元素也可以是另一个list,比如: >>> s = ['python', 'java', ['asp', 'php'], 'scheme'] >>> len(s) # 4 # 要注意s只有4个元素,其中s[2]又是一个list,如果拆开写就更容易理解了: >>> p = ['asp', 'php'] >>> s = ['python', 'java', p, 'scheme'] # 要拿到'php'可以写p[1]或者s[2][1],因此s可以看成是一个二维数组,类似的还有三维、四维……数组,不过很少用到。 # 如果一个list中一个元素也没有,就是一个空的list,它的长度为0: >>> L = [] >>> len(L) # 0
tuple
另一种有序列表叫元组:tuple。tuple和list非常类似,但是tuple一旦初始化就不能修改,比如同样是列出同学的名字:
>>> classmates = ('Michael', 'Bob', 'Tracy') # 现在,classmates这个tuple不能变了,它也没有append(),insert()这样的方法。其他获取元素的方法和list是一样的,你可以正常地使用classmates[0],classmates[-1],但不能赋值成另外的元素。 # 不可变的tuple有什么意义?因为tuple不可变,所以代码更安全。如果可能,能用tuple代替list就尽量用tuple。 # tuple的陷阱:当你定义一个tuple时,在定义的时候,tuple的元素就必须被确定下来,比如: >>> t = (1, 2) >>> t # (1, 2) # 如果要定义一个空的tuple,可以写成(): >>> t = () >>> t # () # 但是,要定义一个只有1个元素的tuple,如果你这么定义: >>> t = (1) >>> t # 1 # 定义的不是tuple,是1这个数!这是因为括号()既可以表示tuple,又可以表示数学公式中的小括号,这就产生了歧义,因此,Python规定,这种情况下,按小括号进行计算,计算结果自然是1。 # 所以,只有1个元素的tuple定义时必须加一个逗号,,来消除歧义: >>> t = (1,) >>> t # (1,) # Python在显示只有1个元素的tuple时,也会加一个逗号,,以免你误解成数学计算意义上的括号。 # 最后来看一个“可变的”tuple: >>> 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本身是可变的!
(6) 条件判断和循环
if <条件判断1>: <执行1> elif <条件判断2>: <执行2> elif <条件判断3>: <执行3> else: <执行4>
if
语句执行有个特点,它是从上往下判断,如果在某个判断上是True
,把该判断对应的语句执行后,就忽略掉剩下的elif
和else
,所以,请测试并解释为什么下面的程序打印的是teenager
:
age = 20
if age >= 6:
print ‘teenager‘
elif age >= 18:
print ‘adult‘
else:
print ‘kid‘
循环
Python的循环有两种,一种是for...in循环,依次把list或tuple中的每个元素迭代出来,看例子:
names = [‘Michael‘, ‘Bob‘, ‘Tracy‘]
for name in names:
print name
执行这段代码,会依次打印names
的每一个元素.for x in ...
循环就是把每个元素代入变量x
,然后执行缩进块的语句。
range(101)就可以生成0-100的整数序列,计算如下:
sum = 0
for x in range(101):
sum = sum + x
print sum
第二种循环是while循环,只要条件满足,就不断循环,条件不满足时退出循环。比如我们要计算100以内所有奇数之和,可以用while循环实现:
sum = 0
n = 99
while n > 0:
sum = sum + n
n = n - 2
print sum
在循环内部变量n
不断自减,直到变为-1
时,不再满足while条件,循环退出。
最后看一个有问题的条件判断。很多同学会用raw_input()
读取用户的输入,这样可以自己输入,程序运行得更有意思:
birth = raw_input(‘birth: ‘)
if birth < 2000:
print ‘00前‘
else:
print ‘00后‘
输入1982
,结果却显示00后
,这么简单的判断Python也能搞错?
当然不是Python的问题,在Python的交互式命令行下打印birth
看看:
>>> birth
‘1982‘
>>> ‘1982‘ < 2000
False
>>> 1982 < 2000
True
原因找到了!原来从raw_input()
读取的内容永远以字符串的形式返回,把字符串和整数比较就不会得到期待的结果,必须先用int()
把字符串转换为我们想要的整型:
birth = int(raw_input(‘birth: ‘))
再次运行,就可以得到正确地结果。当然了,输入的数据是要可以转换成数字的.
(7) 使用dict和set
dict
Python内置了字典:dict的支持,dict全称dictionary,在其他语言中也称为map,使用键-值(key-value)存储,具有极快的查找速度。由于一个key只能对应一个value,所以,多次对一个key放入value,后面的值会把前面的值冲掉:
>>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85} >>> d['Michael'] # 95 >>> d['Jack'] = 90 >>> d['Jack'] # 90 >>> d['Jack'] = 88 >>> d['Jack'] # 88
如果key不存在,dict就会报错.
要避免key不存在的错误,有两种办法,一是通过in
判断key是否存在:
>>> ‘Thomas‘ in d
False
二是通过dict提供的get方法,如果key不存在,可以返回None,或者自己指定的value:
>>> d.get(‘Thomas‘)
>>> d.get(‘Thomas‘, -1)
-1
注意:返回None的时候Python的交互式命令行不显示结果。
要删除一个key,用pop(key)
方法,对应的value也会从dict中删除:
>>> d.pop(‘Bob‘)
75
>>> d
{‘Michael‘: 95, ‘Tracy‘: 85}
请务必注意,dict内部存放的顺序和key放入的顺序是没有关系的。
和list比较,dict有以下几个特点:
- 查找和插入的速度极快,不会随着key的增加而增加;
- 需要占用大量的内存,内存浪费多。
而list相反:
- 查找和插入的时间随着元素的增加而增加;
- 占用空间小,浪费内存很少。
所以,dict是用空间来换取时间的一种方法。
dict可以用在需要高速查找的很多地方,在Python代码中几乎无处不在,正确使用dict非常重要,需要牢记的第一条就是dict的key必须是不可变对象。
set
set和dict类似,也是一组key的集合,但不存储value。由于key不能重复,所以,在set中,没有重复的key。
要创建一个set,需要提供一个list作为输入集合:
>>> s = set([1, 2, 3])
>>> s
set([1, 2, 3])
注意,传入的参数[1, 2, 3]
是一个list,而显示的set([1, 2, 3])
只是告诉你这个set内部有1,2,3这3个元素,显示的[]不表示这是一个list。
重复元素在set中自动被过滤:
>>> s = set([1, 1, 2, 2, 3, 3])
>>> s
set([1, 2, 3])
通过add(key)
方法可以添加元素到set中,可以重复添加,但不会有效果:
>>> s.add(4)
>>> s
set([1, 2, 3, 4])
>>> s.add(4)
>>> s
set([1, 2, 3, 4])
通过remove(key)
方法可以删除元素:
>>> s.remove(4)
>>> s
set([1, 2, 3])
set可以看成数学意义上的无序和无重复元素的集合,因此,两个set可以做数学意义上的交集、并集等操作:
>>> s1 = set([1, 2, 3])
>>> s2 = set([2, 3, 4])
>>> s1 & s2
set([2, 3])
>>> s1 | s2
set([1, 2, 3, 4])
set和dict的唯一区别仅在于没有存储对应的value,但是,set的原理和dict一样,所以,同样不可以放入可变对象,因为无法判断两个可变对象是否相等,也就无法保证set内部“不会有重复元素”。试试把list放入set,看看是否会报错。
再议不可变对象
上面我们讲了,str是不变对象,而list是可变对象。
对于可变对象,比如list,对list进行操作,list内部的内容是会变化的,比如:
>>> a = [‘c‘, ‘b‘, ‘a‘]
>>> a.sort()
>>> a
[‘a‘, ‘b‘, ‘c‘]
而对于不可变对象,比如str,对str进行操作呢:
>>> a = ‘abc‘
>>> a.replace(‘a‘, ‘A‘)
‘Abc‘
>>> a
‘abc‘
虽然字符串有个replace()
方法,也确实变出了‘Abc‘
,但变量a
最后仍是‘abc‘
,应该怎么理解呢?
我们先把代码改成下面这样:
>>> a = ‘abc‘
>>> b = a.replace(‘a‘, ‘A‘)
>>> b
‘Abc‘
>>> a
‘abc‘
要始终牢记的是,a
是变量,而‘abc‘
才是字符串对象!有些时候,我们经常说,对象a
的内容是‘abc‘
,但其实是指,a
本身是一个变量,它指向的对象的内容才是‘abc‘
:
当我们调用a.replace(‘a‘, ‘A‘)
时,实际上调用方法replace
是作用在字符串对象‘abc‘
上的,而这个方法虽然名字叫replace
,但却没有改变字符串‘abc‘
的内容。相反,replace
方法创建了一个新字符串‘Abc‘
并返回,如果我们用变量b
指向该新字符串,就容易理解了,变量a
仍指向原有的字符串‘abc‘
,但变量b
却指向新字符串‘Abc‘
了:
所以,对于不变对象来说,调用对象自身的任意方法,也不会改变该对象自身的内容。相反,这些方法会创建新的对象并返回,这样,就保证了不可变对象本身永远是不可变的。
[截自]http://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000