嵌入式 python基本语法二

2. 元组

　　　　tuple和list十分相似，但是tuple是不可变的，即不能修改tuple，元组通过圆括号中用逗号分割的项定义；支持索引和切片操作；可以使用 in

　　查看一个元素是否在tuple中。空元组()；只含有一个元素的元组("a",) #需要加个逗号

　　　　优点：tuple比list速度快；对不需要修改的数据进行‘写保护’，可以是代码更安全

　　　　tuple与list可以相互转换，使用内置的函数list()和tuple()。

l = [1, 2, 3]print l # [1, 2, 3]t = tuple(l)print t # (1, 2, 3)l1 = list(t)print l1 #[1, 2, 3]

　　　　元组最通常的用法是用在打印语句，如下例：

name = "Peter Zhang"age = 25print "Name: %s; Age: %d" % (name, age)# Name: Peter Zhang; Age: 25

　　　　函数如下：

　　　　count(value)　　---返回元组中值为value的元素的个数

t = (1, 2, 3, 1, 2, 3)print t.count(2) # 2

　　　　index(value, [start, [stop]])　　---返回列表中第一个出现的值为value的索引，如果没有，则异常 ValueError

t = (1, 2, 3, 1, 2, 3)print t.index(3) # 2try:    print t.index(4)except ValueError, ve:    print "there is no 4 in tuple"  # there is no 4 in tuple

 　　3. 字典

　　　　字典由键值对组成，键必须是唯一的；eg: d = {key1:value1, key2:value2}；空字典用{}表示；字典中的键值对是没有顺序的，如果想要

　　一个特定的顺序，那么使用前需要对它们排序；d[key] = value，如果字典中已有key，则为其赋值为value，否则添加新的键值对key/value；使

　　用del d[key] 可以删除键值对；判断字典中是否有某键，可以使用in 或 not in；

d = {}d["1"] = "one"d["2"] = "two"d["3"] = "three"del d["3"]for key, value in d.items():    print "%s --> %s" % (key, value)#1 --> one#2 --> two

　　　　dict函数如下:

　　　　clear()　　---删除字典中所有元素

d1 = {"1":"one", "2":"two"}d1.clear()print d1 # {}

　　　　copy()　　---返回字典的一个副本(浅复制)

d1 = {"1":"one", "2":"two"}d2 = d1.copy()print d2 #{'1': 'one', '2': 'two'}

　　　　dict.fromkeys(seq,val=None) ---创建并返回一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值(默认为None)

l = [1, 2, 3]t = (1, 2, 3)d3 = {}.fromkeys(l)print d3 #{1: None, 2: None, 3: None}d4 = {}.fromkeys(t, "default")print d4 #{1: 'default', 2: 'default', 3: 'default'}

　　　　get(key,[default])　　---返回字典dict中键key对应值，如果字典中不存在此键，则返回default 的值(default默认值为None)

d5 = {1:"one", 2:"two", 3:"three"}print d5.get(1) #oneprint d5.get(5) #Noneprint d5.get(5, "test") #test

　　　　has_key(key)　　---判断字典中是否有键key

d6 = {1:"one", 2:"two", 3:"three"}print d6.has_key(1)  #Trueprint d6.has_key(5)  #False

　　　　items()　　---返回一个包含字典中(键, 值)对元组的列表

d7 = {1:"one", 2:"two", 3:"three"}for item in d7.items():    print item#(1, 'one')#(2, 'two')#(3, 'three')for key, value in d7.items():    print "%s -- %s" % (key, value)#1 -- one#2 -- two#3 -- three

　　　　keys()　　---返回一个包含字典中所有键的列表

d8 = {1:"one", 2:"two", 3:"three"}for key in d8.keys():    print key#1#2#3

　　　　values()　　---返回一个包含字典中所有值的列表

d8 = {1:"one", 2:"two", 3:"three"}for value in d8.values():    print value#one#two#three

　　　　pop(key, [default])　　---若字典中key键存在，删除并返回dict[key]，若不存在，且未给出default值，引发KeyError异常

d9 = {1:"one", 2:"two", 3:"three"}print d9.pop(1) #oneprint d9 #{2: 'two', 3: 'three'}print d9.pop(5, None) #Nonetry:    d9.pop(5)  # raise KeyErrorexcept KeyError, ke:    print  "KeyError:", ke #KeyError:5

　　　　popitem()　　---删除任意键值对，并返回该键值对，如果字典为空，则产生异常KeyError

d10 = {1:"one", 2:"two", 3:"three"}print d10.popitem()  #(1, 'one')print d10  #{2: 'two', 3: 'three'}

　　　　setdefault(key,[default])　　---若字典中有key，则返回vlaue值，若没有key，则加上该key，值为default，默认None

d = {1:"one", 2:"two", 3:"three"}print d.setdefault(1)  #oneprint d.setdefault(5)  #Noneprint d  #{1: 'one', 2: 'two', 3: 'three', 5: None}print d.setdefault(6, "six") #sixprint d  #{1: 'one', 2: 'two', 3: 'three', 5: None, 6: 'six'}

　　　　update(dict2)　　---把dict2的元素加入到dict中去，键字重复时会覆盖dict中的键值

d = {1:"one", 2:"two", 3:"three"}d2 = {1:"first", 4:"forth"}d.update(d2)print d  #{1: 'first', 2: 'two', 3: 'three', 4: 'forth'}

　　　　viewitems()　　---返回一个view对象，（key, value）pair的列表，类似于视图。优点是，如果字典发生变化，view会同步发生变化。在

　　迭代过程中，字典不允许改变，否则会报异常

d = {1:"one", 2:"two", 3:"three"}for key, value in d.viewitems():    print "%s - %s" % (key, value)#1 - one#2 - two#3 - three

　　　　viewkeys()　　---返回一个view对象，key的列表

d = {1:"one", 2:"two", 3:"three"}for key in d.viewkeys():    print key#1#2#3

　　　　viewvalues()　　---返回一个view对象，value的列表

d = {1:"one", 2:"two", 3:"three"}for value in d.viewvalues():    print value#one#two#three

　　4. 序列

　　　　序列类型是指容器内的元素从0开始的索引顺序访问，一次可以访问一个或者多个元素；列表、元组和字符串都是序列；序列的两个主要特点是

　　索引操作符和切片操作符；索引可以得到特定元素；切片可以得到部分序列；

 1 numbers = ["zero", "one", "two", "three", "four"] 2  3 print numbers[1] # one 4 print numbers[-1] # four 5 #print numbers[5] # raise IndexError 6  7 print numbers[:] # ['zero', 'one', 'two', 'three', 'four'] 8 print numbers[3:] # ['three', 'four'] 9 print numbers[:2] # ['zero', 'one']10 print numbers[2:4] # ['two', 'three']11 print numbers[1:-1] # ['one', 'two', 'three'] 

　　　　切片操作符中的第一个数（冒号之前）表示切片开始的位置，第二个数（冒号之后）表示切片到哪里结束。 如果不指定第一个数，Python就从

　　序列首开始。如果没有指定第二个数，则Python会停止在序列尾。 注意，返回的序列从开始位置 开始 ，刚好在结束位置之前 结束。即开始位置是

　　包含在序列切片中的，而结束位置被排斥在切片外。 可以用负数做切片。负数用在从序列尾开始计算的位置。
　　5. 绑定

　　　　当创建一个对象并给它赋一个变量的时候，这个变量仅仅“指向”那个对象，而不是表示这个对象本身！ 也就是说，变量名指向计算机中存储那个

　　对象的内存，这被称作名称到对象的绑定。

　　　　如果要复制一个列表或者类似的序列或者其他复杂的对象（不是如整数那样的简单对象），那么必须使用切片操作符来取得拷贝。

 

1. 1.python是一个解释性语言：  
2. 一个用编译性语言比如C或C++写的程序可以从源文件（即C或C++语言）转换到一个你的计算机使用的语言（二进制代码，即0和1）。这个过程通过编译器和不同的标记、选项完成。当你运行你的程序的时候，连接/转载器软件把你的程序从硬盘复制到内存中并且运行。  
3. 而Python语言写的程序不需要编译成二进制代码。你可以直接从源代码 运行 程序。在计算机内部，Python解释器把源代码转换成称为字节码的中间形式，然后再把它翻译成计算机使用的机器语言并运行。事实上，由于你不再需要担心如何编译程序，如何确保连接转载正确的库等等，所有这一切使得使用Python更加简单。由于你只需要把你的Python程序拷贝到另外一台计算机上，它就可以工作了，这也使得你的Python程序更加易于移植。  
4.   
5. 2.查询机器是否安装python成功：python -V  
6.   
7. 3.得到类的帮助文档：  
8. help('str')#得到str类的文档  
9. help（list）#得到list类的文档字符串  
10.   
11. 4.python中有4中类型的数：整数、长整数、浮点数和复数。   #(-5+4j)和(2.3-4.6j)是复数的例子。  
12.   
13. 5.自然字符串通过在字符串全面添加前缀r或者R来指定。一定要用自然字符串处理正则表达式  
14. 例如：r"Newlines are indicated by \n"。  
15.   
16. 6.字符串自动级连，例如，'What\'s' 'your name?'会被自动转为"What's your name?"。  
17.   
18. 7.在多个物理行写一个逻辑行的例子：  
19. s = 'This is a string. \  
20. This continues the string.'  
21. print s   
22. 它的输出：This is a string. This continues the string.   
23.   
24. 8.有一个特殊的运算符号：//  表示取整除。例如：4 // 3.0得到1.0   
25. lambda运算符！！  
26.   
27. 9.python自动为字符串中间添加一个空格：  
28. print 'Area is', area  
29.   
30. 10.得到用户在屏幕的输入：raw_input('Enter an integer : ')  
31. 例如：guess = int(raw_input('Enter an integer : '))  将输入的数据转换为int  
32.   
33. 11.在python中没有switch语句！使用  
34.              if  True：   
35.              elif 条件二：     
36.              else：  
37. 注意最后没有end if！！  
38.   
39. 12.while 条件：  
40.        语句  
41.    else：  
42.         语句  
43.      在while可以使用else从句，有点多余。  
44.   
45.     13.for语句：  
46.      for i in range(1, 5):  
47.         print i  
48.      else:      #也有else语句，有点多余。  
49.         print 'The for loop is over'   
50.   
51.     14.得到字符串的长度：len（str）  
52.   
53.     15.在循环中可以使用continue语句。。  
54.   
55.     16.在函数中定义全局变量：使用global关键字。  
56.       def func():  
57.         global x  #全局的x变量。同一个global语句指定多个全局变量。例如global x, y, z  
58.     参数中可以有默认的值，但是在形参末尾的那些参数才可以有默认参数：def func(a, b=5)是有效的，但是def func(a=5, b)是 无效 的。   
59.     函数的参数调用可以使用关键参数，使用名字来给函数指定实参。  
60.   
61.     17.文档字符串的管理：它的首行以大写字母开始，句号结尾。第二行是空行，从第三行开始是详细的描述  
62.    例如：  
63.     '''''Prints the maximum of two numbers. 
64.  
65.        The two values must be integers.'''  
66.     查看文档字符串的方法：print printMax.__doc__ #调用文档字符串的属性！！注意双下划线！或者help（printMax）  
67.   
68.    18.使用python的标准库：import  sys  
69.      可以通过help（sys）查看模块的内容！  
70.      常用：sys.argv包含了 命令行参数   
71.   
72.    19..pyc文件：字节编译的文件  与平台无关，与python变换程序的中间态有关。  
73.   
74.    20.from .. import语句：可以from sys import argv  #这样就只引入一个sys.argv这个变量。  
75.   
76.    21.小技巧：使用模块的__name__：  
77.       if __name__ == '__main__':  做一些事情。。。。  
78.   
79.    22.dir（）：可以列出模块里面的定义的标识符。包括函数，类，变量等。  
80.       提供一个模块名的时候，它返回模块定义的名称列表。如果不提供参数，它返回当前模块中定义的名称列表。  
81.   
82.    23.del 变量  #删除变量  
83.   
84.    24.python中有三种内建的数据结构：列表（list），元组，字典  
85.   
86.    25.元组：元组通过圆括号中用逗号分割的项目定义。元组通常用在使语句或用户定义的函数能够安全地采用一组值的时候，即被使用的元组的值不会改变。  
87.    元组也是一个“序列”！（列表，字符串，元组都是序列！！字典不是。。）  
88.    一个空的元组由一对空的圆括号组成，如myempty = ()  
89.    只有一个成员的元组，必须在一个元素后面再加一个逗号，这样就“Python才能区分元组和表达式中一个带圆括号的对象”  
90.   元组使用的示例：  
91.   age = 22  
92.   name = 'Swaroop'  
93.   print '%s is %d years old' % (name, age)  
94.   print ‘name is %s’%name    #注意这里只有一个变量的时候，可以这样使用，不用括号。     
95.   
96.    26.在python中使用汉字：在最上面写，#coding=gbk   
97.     
98.    27.序列：主要两个特点是索引，切片。序列的索引是负数的话，表示取倒数第几个元素。  
99.       shoplist[1:3]:从位置1开始，包括位置2，但是停止在位置3的一个序列切片。只有两个元素。  
100.   
101.    28.关于对象的引用的老问题，创建一个对象并给它赋一个变量的时候，这个变量仅仅“参考”那个对象，而不是对象本身！如果要拷贝序列的话，就应该使用切片操作来进行序列的拷贝。  
102.   
103.    29.输出python中的全部汉字：  
104. for ch in xrange(0x4e00, 0x9fa6):  
105.   print unichr(ch)  
106.   
107.    30.str类是字符串的类。help(str)  
108.    常用方法：len(str),str.endswith('q'),S.find(sub [,start [,end]]),S.index(sub [,start [,end]]),S.isdigit()#是否数字  
109.   
110.    31.对于时间的格式化函数：import time  然后就：time.strftime('%Y%m%d%H%M%S')     可以从python参考手册得到。  
111.   
112.    32.执行一个命令，import os  然后： os.system(“命令字符串”)   如果命令执行成功返回0，否则返回错误号！注意执行成功的时候返回0！！  
113.        判断目录是不是存在，os.path.exists(目录名)   创建目录：os.mkdir(新目录名)    得到文件分割符：os.sep  
114.   
115.    33.面向对象基本概念：  
116.       类创建一个新类型，对象是这个类的实例；  
117.       属于一个对象或者类的变量被称为域；  
118.       属于类的函数称为类的方法；  
119.       域有两种类型，属于每个实例/类的对象或者属于类本身，分别被称为实例变量和类变量；  
120.       类使用关键字class创建。  
121.     
122.    34.self：在类的方法中，必须有一个额外的第一个参数，在调用这个方法的时候不为这个参数赋值，有Python自动进行赋值，类似于java的this。这个变量一般建议命名使用self。  
123.       注意：这也意味着如果你有一个不需要参数的方法，你还是得给这个方法定义一个self参数。  
124.   
125.    35.空白语句：pass  
126.   
127.    36.类的定义：  
128.    class Person:  
129.    def sayHi(self):  
130.         print 'Hello, how are you?'  
131.    p = Person()  
132.    p.sayHi()  
133.   
134.    37.类里面的初始化函数：__init__(self,参数。。。)  
135.       对应的还有一个__del__方法！  
136.      
137.    38.类的变量（由一个类的所有对象（实例）共享使用），对象的变量（由类的每个对象/实例拥有）。  
138.   
139.    39.类的继承：class Student(SchoolMember):#括号里面是基类。python支持多重继承！  
140.   
141.    40.类的存储：使用cPickle模块进行类对象到文件的存储和从文件的加载一个对象。  
142.     简单示例：import cPickle  
143.                        存储：f= file(文件名,'w');      o=对象;          cPickle.dump(对象,f)  
144.                        取存储：f=file(文件名);         o=cPickle.load(f) ;         使用对象。。。。  
145.   
146.     41.关于异常:  
147. try:  
148.     s=raw_input('请输入一些东西：')  
149.     if len(s)<</span>3:  
150.         raise ShortInputException(len(s),3)                        #触发自定义异常  
151. except EOFError:  
152.     print '\n为什么要强制结束？'  
153. except ShortInputException,x:  
154.     print '遇到ShortInputException异常，输入的长度是%d,\  
155. 不触发至少要输入位数是%d'%(x.length,x.atleast)  
156. else:  
157.     print '没有异常被捕获。'  
158. finally:  
159.     print '无论是否异常都要执行这个语句！'  
160. 自定义异常:  
161. class ShortInputException(Exception):  
162.     def __init__(self,length,atleast):  
163.         Exception.__init__(self)  
164.         self.length=length  
165.         self.atleast=atleast  
166.   
167.     42.使代码停留一会再执行  time.sleep(2)  #要先import time  
168.   
169.     43.查看变量的类型：  
170.     from types import *  
171.    再调用type(item)        #返回的值是NoneType ，TypeType ，BooleanType ，IntType等等。详细见python自带的文档。  
172.    注意：布尔类型是True，False！首字母大写！！  
173.    也有一个方法 if isinstance(item, int):看这个变量item是不是int类型  
174.   
175.     44.sys模块：  
176.       option = sys.argv[1][2:]#比较特别的写法！！ fetch sys.argv[1] but without the first two characters  
177.   
178.     45. python中的一些特殊的方法  
179.         名称 说明   
180. __init__(self,...) 这个方法在新建对象恰好要被返回使用之前被调用。   
181. __del__(self) 恰好在对象要被删除之前调用。   
182. __str__(self) 在我们对对象使用print语句或是使用str()的时候调用。   
183. __lt__(self,other) 当使用 小于 运算符（<）的时候调用。类似地，对于所有的运算符（+，>等等）都有特殊的方法。   
184. __getitem__(self,key) 使用x[key]索引操作符的时候调用。   
185. __len__(self) 对序列对象使用内建的len()函数的时候调用。   
186.   
187.     46.列表综合：将一个列表映射为例外一个列表的快速方法：  
188.    listone = [2, 3, 4]  
189.    listtwo = [2*i for i in listone if i > 2]      #新的列表中将原列表大于2的元素乘以2倍  
190.    print listtwo   #[6, 8]   
191.   
192.    47.函数参数使用*和**分别代表为列表或者元组。这个比较有用。  
193. def powersum(power, *args):  
194. ...     '''''Return the sum of each argument raised to specified power.'''  
195. ...     total = 0  
196. ...     for i in args:  
197. ...          total += pow(i, power)  
198. ...     return total  
199. 实例： powersum(2, 3, 4)  
200.              输出：25  
201.   
202.    48.lamdba语句：（用来创建函数的语句！！）很有特色的python语句！  
203. def make_repeater(n):  
204.     return lambda s: s*n  
205. twice = make_repeater(2)  
206. print twice('string')  
207. print twice(2)  
208.   
209. threeTimes = make_repeat(3)  
210. print threeTimes('string')  
211. print threeTimes(2)  
212.   
213.     49.动态执行python语句：exec 'print "Hello World"'      注意，这里没有括号！！  
214.         eval用来计算存储在python中的表达式！  eval_r('3*3')     这也是可以的： print eval_r('"str1"+"str2"')  
215.      
216.     50.断言：assert语句，用来声明某个条件是真的。如果失败，就引发AssertionError。  
217.   
218.     51.repr函数：用来取得对象的规范化字符串表示，反引号也可以完成相同的功能。  
219.         大多数有：eval_r(repr(object))==object