python入门（二）

一、算数运算

>>> 2+3        #加法
5
>>> 2-3        #减法
-1
>>> 2*3        #乘法
6
>>> 2/3        #除法，这是计算机的除法，所以2/3的得数不为0.6666，计算规则请自行搜索
0
>>> 2%3        #取余数
2
>>> 2**3       #2的3次方
8

>>> import math                 #导入math，有点像java包一样
>>> math.pi                     #求π的值
3.141592653589793
>>> math.sqrt(9.0)          #求浮点数的平方根，不是浮点数的会自动强转，在C++中需要手动强制转换类型
3.0
>>> import random
>>> random.random()             #随机生成一个数in[0,1]
0.6479743424406383
>>> random.choice([1,2,3,4])    #在列表1,2,3,4中随机选一个
1

二、字符串

>>> s="Hello"           #不管是字符/字符串，""和''是通用的
>>> len(s)              #计算字符串有多少长度，C语言中类似计算会将\0计算在内，而python不会
5
>>> s[0]                #好强大，竟然还可以当数组用。。。
'H'
>>> s[-1]               #求倒数第一个字符
'o'
>>> s[1:]               #从下标为1的字符开始到结束
'ello'
>>> s[:3]               #从下标为0的字符开始取3-0个字符出来，前面那个空没写就默认为0
'Hel'
>>> s[1:3]              #从下标为1的字符开始取3-1个字符出来
'el'
>>> s+",World!"         #字符串相加
'Hello,World!'
>>> s
'Hello'
>>> s*3                 #打印三遍字符串
'HelloHelloHello'

>>> s[0]='z'
Traceback (most recent call last):     #本想用C语言中的思想试一把的，啊，竟然不给用，出现了错误
File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
>>> s='z'+s[1:]                        #Python中不能通过对某一位进行赋值而改变字符串，但可以通过建立一个新字符串并以同一个变量名对其赋值
>>> s
'zello'
>>> s                          #Python会自动清理旧的对象，改变之后都是zello啦，要记住，不要后面的看不懂了
'zello'
>>> s=s[0:2]+'A'+s[3]          #再来玩一把，高级的哦。。。
>>> s
'zeAl'                         #可恶竟然把o抛弃了，想要带上o可以把s[3]改为s[3:]。

>>> s='zello'                  #还原zello来试下前面说的，这样写直接全部覆盖，并清除旧对象
>>> s
'zello'
>>> s=s[0:2]+'A'+s[3:]         #带上o咯
>>> s
'zeAlo'

>>> s="Hello"                  #还原为Hello，玩下别的
>>> s
'Hello'
>>> s.find("ell")              #这点有点像java啦，返回的是字符串ell的开始字符e的下标
1
>>> s.find('z')                #没找到，返回-1
-1
>>> s.replace("ell","xyz")     #这个是将ell替换为xyz，注意replace操作并不会改变该字符串，而是创建一个新的字符串作为结果。这个先记住后面再总结。
'Hxyzo'
>>> s                          #看吧，还是打印原来的字符串
'Hello'

>>>line="aaa,bbb,cccc,dd"      #上更高级的
>>> line
'aaa,bbb,cccc,dd'
>>> line.split(',')            #根据逗号“,”分割字符串
['aaa', 'bbb', 'cccc', 'dd']
>>>
4000
s.upper()                  #将s的字符串转为大写
'HELLO'
>>> s                          #打印s的字符串，竟然还是不变啊
'Hello'
>>> s                          #根据字符串具有不可变性，s这个字符串不会变的，那s='z'+s[1:]这个为什么变了，因为改变
字符串后，给s重新赋值了
'Hello'
>>> line
'aaa,bbb,cccc,dd'
>>> line+'a'
'aaa,bbb,cccc,dda'
>>> line=line.rstrip()         #返回上一次更改，并重新赋值给line
>>> line                       #所以line又变回原来的样子了
'aaa,bbb,cccc,dd'

三、模式匹配

>>> import re
>>> match = re.match('Hello[\t]*(.*)world','Hello Python world')
>>> match.group(1)
' Python '
>>>
>>> match.group(2)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: no such group
>>>
>>> match=re.match('/(.*)/(.*)/(.*)','/usr/home/zrqsophia')
>>> match.groups()
('usr', 'home', 'zrqsophia')
>>>

match函数，其第一部分定义了模式，后一部分是要匹配的文本content。

比如这个模式match = re.match(‘Hello[\t](.)world’,’Hello Python world’)，就是以Hello开头，连上n个’\t’，再接着任意字符并将其保存至匹配的group中，最后以‘world’结尾的模式在’Hello Python world’中匹配的结果。

四、列表[]，Python数据类型

python列表是一个与任意类型的对象位置相关的有序集合。列表最大的特点就是，没有固定类型的约束：

>>> L = [123, "Space", 1.23]         #列表，可以存放多种类型的对象
>>> len(L)                           #对象个数
3
>>> L[0]                             #取下标为0的对象
123
>>> L[:-1]                           #取0到-1个对象，就像把这些对象连结成一个圈，然后倒着数，这点和字符串那边有点区别，后面做下对比
[123, 'Space']
>>>
>>> L+[4,5,6]                        #列表可以加上另一个列表
[123, 'Space', 1.23, 4, 5, 6]
>>> L
[123, 'Space', 1.23]                 #没进行赋值操作，所以还是原来的那个列表
>>>

特定类型的操作：与string不同，list是可变的（相对于字符串的不可变性而言），但是有的方法是有针对性类型的，比如append函数只接受字符串：

>>> L.append("NT")                   #接着用上面的L，并在后面添加字符串NT
>>> L
[123, 'Space', 1.23, 'NT']           #啊~，没赋值啊，NT怎么呆在上面了，这里就要注意啦，这个和字符串是不同的，根据字符串具有不可变性
>>> L.append(5)                      #再添加一个5试试
>>> L
[123, 'Space', 1.23, 'NT', 5]        #还真是，这可以当作是字符串与列表的一个区别吧
>>> L.pop(2)                         #取出下标为2的对象
1.23
>>> L
[123, 'Space', 'NT', 5]              #取出的对象木有了
>>>

>>> M=["bb", "aa", "cc"]
>>> M.sort()
>>> M
['aa', 'bb', 'cc']
>>> M.reverse()
>>> M
['cc', 'bb', 'aa']
>>>

列表嵌套

>>> M=[[1,2],
... [3,4],
... [5,6]]
>>> M
[[1, 2], [3, 4], [5, 6]]
>>> M[1]
[3, 4]
>>> M
[[1, 2], [3, 4], [5, 6]]
>>> M[1][1]                          #有点C语言中的二维数组的味道啊
4
>>>

列表解析

>>> M
[[1, 2], [3, 4], [5, 6]]
>>> M[1][1]
4
>>> [row[1]+1 for row in M]                 #下标为1行的数都+1，然后再打印
[3, 5, 7]
>>> [row[1] for row in M if row[1]%3==0]    #下标为1行的数，如果可以被3整除，则打印出来
[6]
>>> diag = [M[i][i] for i in [0,1]]
>>> diag
[1, 4]
>>> str = [c*2 for c in 'spam']
>>> str
['ss', 'pp', 'aa', 'mm']
>>>

五、字典{}，Python数据类型，注意字典不能像列表那样进行像数组那样操作

字典的赋值方式

>>> D = {"fooditem":2,"zrqsophia":"s.w.","color":"#CCFFEE"}
>>> D["zrqsophia"]                         #字典字典，说白了就可可以查的东西嘛，zrqsophia其实就像是s.w.的标识符
's.w.'
>>> D["fooditem"]+=1                       #和下面加了分号的进行对比下
>>> D
{'zrqsophia': 's.w.', 'fooditem': 3, 'color': '#CCFFEE'}
>>> D["fooditem"]+=1;                      #加了分号下面的输出3竟然变成了4
>>> D
{'zrqsophia': 's.w.', 'fooditem': 4, 'color': '#CCFFEE'}
>>> D={}
>>> D["name"] = "sophia"                   #进行字典赋值
>>> D["job"] = "coder"
>>> D["age"] = 21
>>> D                                      #字典插入，是从前面插入的
{'age': 21, 'job': 'coder', 'name': 'sophia'}
>>>

嵌套

>>> D={"name":"Sophia","property":["coder",21,"acmer"]}
>>> D["property"]
['coder', 21, 'acmer']
>>>

键的排序：for循环

怎么变得这么难了，一定要撑住。。。。。。

>>> D={"name":"Sophia","property":["coder",21,"acmer"]}
>>> D["property"]
['coder', 21, 'acmer']                  #不知不觉怎么把""输成''好了，不管了，风格变就变吧，后面整理的时候再统一下风格。
>>> Ks=D.keys()                         #查找D的关键字，也就是前面所说的像标识符的东西
>>> Ks
['property', 'name']                    #从后往前打印出来所有的关键字
>>> Ks.sort()                           #从前往后打印，Oracle/MySQL反正是SQL语句里也有这个东西，忘了是什么意思了。。。无语
>>> Ks
['name', 'property']
>>> for key in Ks:
...     print key,"=>",D[key]           #注意啦，注意啦~ print前面是有tab键的，为什么呢，先放着后面整理规划的时候，
再说得更详细些
...                                     #直接回车就可以退出这个...等待输入啦
name => Sophia
property => ['coder', 21, 'acmer']
>>> D
{'property': ['coder', 21, 'acmer'], 'name': 'Sophia'}
>>> for key in sorted(D):
...     print key, "=>",D[key]
...
name => Sophia
property => ['coder', 21, 'acmer']
>>> for a in D:
...     print a, "->",D[a]             #这个->咋回事？其实就是前
b97e
面和前面的=>的一样的，只是我没说而已，循环打印的时候，就可以看到啦。
...
property -> ['coder', 21, 'acmer']
name -> Sophia
>>>

迭代

>>> s = [x **2 for x in[1,2,3,4,5]]    #循环打印出in里面元素的平方
>>> s
[1, 4, 9, 16, 25]
>>>

if测试

>>> D = {'a':1,'c':3,'b':2}
>>> D
{'a': 1, 'c': 3, 'b': 2}
>>> D['e'] = 5                         #添加一个关键字和数值
>>> D
{'a': 1, 'c': 3, 'b': 2, 'e': 5}
>>> D['f']                             #查找f，木有啊，就报错了
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'f'
>>> D.has_key('f')                     #查看D中是否有f，没有就返回False
False
>>> if not D.has_key('f'):             #if not False 代表的就是True啦，所以打印missing，这样写有点怪怪的
...     print 'missing'
...
missing
>>>

六、元组

元组的最大特点是不可变，也就是说元组是不可变的序列。

>>> T = (1,2,3,4)                     #其实和字符串挺像的，现在就不介绍了
>>> len(T)
4
>>> T+(5,6)
(1, 2, 3, 4, 5, 6)
>>> T
(1, 2, 3, 4)
>>> T = T+(5,6)
>>> T
(1, 2, 3, 4, 5, 6)
>>> T[0]
1
>>> T[0]=2
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>>

七、文件

>>> f = open ('E:\\a.txt','w')      #注意啦注意啦，r是打开存在的文件，否则报错，w是可以不存在的，不存在则创建一个，\\一定要写两个斜杠
>>> f.write('Hello\n')              #看下E盘文本是不是多了Hello，对的写进去了
>>> f.write('World!\n')
>>> f.close()
>>>
>>> f = open ('E:\\a.txt')              #python默认文件打开方式为读'r'
>>> bytes = f.read()
>>> bytes
'Hello\nWorld!\n'
>>> print bytes
Hello
World!
>>> bytes.split('\n')
['Hello', 'World!', '']
>>> bytes.split()
['Hello', 'World!']
>>>

当然，除了open函数，python还有高级的文件类工具：pipes、fifos、sockets、keyed-access files等。例如文件描述符（descriptor file）支持文件锁定和其他底层工具，而sockets提供网络和进程间接口。

八、用户自定义类

>>> class Worker:
...      def __init__(self,name,pay):
...              self.name = name
...              self.pay = pay
...      def lastName(self):
...              return self.name.split()[-1]
...      def giveRaise(self,percent):
...             self.pay *= (1.0+percent)
...
>>>bob = Worker('Bob Smith,20000)
>>>sue = Worker('Sue Jones',40000)
>>>bob.laseName()
'Smith'
>>>sue.giveRaise(.10)
>>>sue.pay
44000.0

类中成员默认类型是public的（虽然python中我们还没有介绍成员变量的类型），“self”对象时我们把这叫做面向对象模型的原因，即一个函数总有一个隐含的对象，这和C++非常相似。