Python学习笔记

绝大多数Linux和Unix系统只要安装完毕Python,Python解释器已经默认存在了，运行python命令启动交互式解释器，要退出可使用快捷键Ctrl+D。

1、定义函数

>>>def print_lyrics():

...            print "I am a worker."

函数定义的第一行为函数头，其他部分为函数体，函数头以冒号结束，函数体整体缩进一级，缩进总是使用4个空格。 如果在交互模式里输入函数定义，则解释器会输出省略号，提示当前输入还没结束，若要结束则需输入一个空行。然后直接调用函数名即可。

 

2、for语句的语法和函数定义类似。也是有一个以冒号结束的语句投，并有一个缩进的语句体。

 

3、读取文件函数open()

内置函数iopen接受文件名作为参数，并返回一个文件对象，可以用来读取文件。

例：打印出本地文件words.txt中长度大于20的单词

fin=open("words.txt")
for line in fin:
    word=line.strip()
    if len(word)>20:
            print word

 

4、列表操作

例：t=['a','b','c','d','e','f']

1）列表切片t[m:n]

t[m:n]的结果为输出下表大约等于m且小于n的元素，ptint t[1:3] 结果为：['b','c']

2）在末尾追加元素t.append()

t.append('g')，print t的结果为：['a','b','c','d','e','f','g']

3）追加元素t1.extend(t2)

t2=['x','y']

t1.extend(t2)的输出结果为：['a','b','c','d','e','f','x','y']

4）删除末尾元素pop()

x=t.pop(1)

print t的结果为：['a','c','d','e','f']

print x的结果为：b

5）删除元素del()

del t[1]

print t的结果为：['a','c','d','e','f']

6）删除元素remove()

t.remove('b')

print t的结果为：['a','c','d','e','f']

7）排序函数 sort()

8）高级排序 .sort(cmp)

 

5、列表函数list

若要将一个字符串转换成一个字符的列表可以使用list函数

s='spam'

t=list(s)

print t的结果为：['s','p','a','m']

6、分隔函数split

list函数会将字符串产分成单个字母，如果想要将字符串拆分成单词，可以使用split方法

s='I love china'

t=s.split()

print t的结果为：['I','love','china']

split还可以接受一个可选的形参，成为分隔符，用于指定用哪个字符来分隔单词

s='spam-spam-spam'

delimiter='-'

t=s.split(delimiter)

print t的结果为：['spam','spam','spam']

7、拼接函数join

join是split的逆操作，它接收字符串列表，并拼接每个元素，join是字符串的方法，所以必须在分隔符上调用它，并传入列表作为实参。

例：t=['i','am','a','boy']

delimiter=' '

s=delimiter.join(t)

print s的结果为：'i am a boy'

8、列表

letters=['a','b','c','d','e','f']

这样，letters就是一个列表。元组和列表的区别是元组不允许修改。

9、字典(键值对)

字典是下标(键)集合与值集合之间的映射，即键值对，每个键值对称为一项。

eng2sp={'one':'a','two':'b','three':'c'}

print eng2sp 的结果为：{'three': 'c', 'two': 'b', 'one': 'a'}   (注：这个顺序是按字典顺序输出的)

print eng2sp.keys() 的结果为：['three', 'two', 'one']

print eng2sp.values() 的结果为：['c', 'b', 'a']

元组样式：('a','b','c','d','e','f','g') 或 ([2,3],[4,5])

列表样式：['a','b','c','d','e','f','g']

字典样式：{'zhangsan':'23','lisi':'25','wangwu':'28'}

10、生成随机数的函数random()

使用这个函数要先导入模块对象 random

import random

random.randint(5,10)

生成一个在5到10之间的随机数

 

11、从序列中随机选择一个元素用函数choice()

使用这个函数要先导入模块对象 random

import random

t=[1,2,3,4]

random.choice(t)

12、文件持久化(write写入)

例：fout=open('words.txt','w')      #以下操作如果words.tx存在则会覆盖原内容，如果没有会新建一个

       line1="This here's the wattle,\n"

       fout.write(line1)

       line2="the emblem of our land.\n"

       fout.write(line2)

       fout.close()

13、格式操作符

write的参数必须是字符串，如果写入的值是其他类型，必须先转为字符串。有两种方法

1） str函数

      x=52

      f.write(str(x)) 

2）格式操作符%

当用于整数时，%是求余操作符，但若第一个操作对象是字符串时，%则是格式操作符

例1  camels=42

           '%d' % camels

例2‘In %d years I have spotted %g %s.’% (3,0.1,'camels')

             'In   3  years I have spotted 0.1 camels.

14、文件名和路径

os模块提供了用于操作文件和目录的函数

import os

1)返回当前目录名称：os.getcwd()

2)寻找文件绝对路径：os.path.abspath('abc.txt')

3)检查一个文件或目录是否存在：os.path.exists('abc.txt')

4)检查是否为目录：os.path.isdir('abc.txt')  os.path.isdir('XYZ')

5)检查是否为文件：os.path.isfile('abc.txt')  os.path.isfile('XYZ')

6)返回指定目录中文件列表：os.listdir('XYZ')

15、捕获异常 try.....except.....

try:
    fin=open('abx.txt')
    for line in fin:
            print line
    fin.close()
except:

    print 'Something went wrong'

16、数据库

anydbm模块提供了接口用于创建和更新数据库文件

import anydbm

db=anydbm.open('captions.db','c')  #模式c代表数据库应当被创建，如果不存在会创建一个数据库对象

db['cleese.png']='Photo of John Cleese'

17、封存

anydbm的限制之一是键和值都必须是字符串，如果是其他类型，pickle模块可以帮忙，它可以将几乎所有类型的对象转换为适合保存到数据库的字符串形式，并可以将字符串转换回来成对象

import pickle

t=[1,2,3]

t1=pickle.dumps(t)

t2=pickle.loads(t1)

print t1: '(lp0\nI1\naI2\naI3\na.'

print t2: [1, 2, 3]

18、编写模块

任何包含Python代码的文件都可以作为模块导入，作为模块导入的程序，通常使用如下模式：

if __name__=='__main__':

    print linecount('wc.py')

__name__== 是一个内置变量，当程序启动时就会被设置。如果程序作为脚本执行，__name__的值是__main__；此时测试代码会被执行，否则，如果程序作为模块被导入，测试代码就被跳过了。

19、调试

当读取和写入文件时，可能会遇到空表字符问题，因为空格、制表符和换行符不可见

s='1 2\t 3\n 4'

print s

1 2    3

4

这时内置函数repr可以帮忙，它接收任何对象作为参数，并返回对象的字符串表达形式。

>>> print repr(s) 结果为：'1 2\t 3\n 4'

20、用户自定义类型--类

类：

class Point(object):

        """Represents a point in 2-D space."""

print Point 的结果为：class '__main__.Point'

对象：

blank=Point()  #这是一个Point对象的引用，我们将它复制给变量blank

print blank 的结果为：__main__.Point object at 0x7f36d2365ed0

21、del语句可以直接释放资源，变量名删除，引用计数减1

22、指定编码在文件开头加入 # -- coding:UTF-8 或 #coding=utf-8  (否则代码中有中文会报错)

23、注释

单行注释：行首加#

多行注释：要注释的代码开始和结尾处分别加"""和"""

24、单引号，双引号，三引号

1）三种引号都可以定义字符串：

str1='abc'

str2="abc"

str2="""abc"""

2）文本中包含“”

str4="hello \"dear!\""

str5='hello "dear"'

str6='''hello "dear"'''

str7="hello 'dear'"

str8='''"hello 'word!'"'''

25.获取用户输入

如果是数值型一般用input，字符型一般用raw_input。除非对input有别的需要，否则应该尽可能使用raw_input函数

26.长字符串，原始字符串和Unicode字符串

长字符串：用三个引号或者三个双引号代替普通引号

原始字符串：在原字符串前加 r

Unicode字符串：在原字符串前加 u(Python 3.0中所有字符串都是Unicode字符串)

27.python内置函数详解：http://www.cnblogs.com/nulige/p/6121079.html

28. yield

任何包含yield语句的函数成为生成器。作用就是把一个函数变成生成器。

1）把一个函数改写为一个 generator 就获得了迭代能力，比起用类的实例保存状态来计算下一个 next() 的值，不仅代码简洁，而且执行流程异常清晰。

2）另一个 yield 的例子来源于文件读取。如果直接对文件对象调用 read() 方法，会导致不可预测的内存占用。好的方法是利用固定长度的缓冲区来不断读取文件内容。通过 yield，我们不再需要编写读文件的迭代类，就可以轻松实现文件读取：

29. range和xrange的区别

1）range([start,] stop[, step])，根据start与stop指定的范围以及step设定的步长，生成一个序列。

2）xrange 用法与 range 完全相同，所不同的是生成的不是一个list对象，而是一个生成器。

3）由上面的示例可以知道：要生成很大的数字序列的时候，用xrange会比range性能优很多，因为不需要一上来就开辟一块很大的内存空间。

30.  Python字符串、元组、列表、字典互转

1).字典

dict = {'name':'zhangsan','age':26,'class':'first'}

a)字典转为字符串：print str(dict)             返回：{'age': 26, 'name': 'zhangsan', 'class': 'first'}

b)字典转为元组：  print tuple(dict)   返回：('age','name','class')

     print tuple(dict.keys()) 返回：('age','name','class')

     print tuple(dict.values())     返回：(26, 'zhangsan', 'first')

     print tuple(dict.items() 返回：(('age', 26), ('name', 'zhangsan'), ('class', 'first'))

c)字典转为列表：  print list(dict) 返回：['age', 'name', 'class']

     print list(dict.keys())   返回：['age', 'name', 'class']

     print list(dict.values()   返回: [26, 'zhangsan', 'first']

     print list(dict.items())   返回：[('age', 26), ('name', 'zhangsan'), ('class', 'first')]

2).元组

tup=(1,2,3,4,5)

a)元组转为字符串：print str(tup) 返回：(1,2,3,4,5)  或者 print tup.__str__()

b)元组转为列表：   print list(tup) 返回：[1,2,3,4,5]

c)元组不可转为字典

3)列表

nums = [1,3,5,7,8,13,20]

a)列表转为字符串：print str(nums) 返回：[1,3,5,7,8,13,20]     或者 print nums.__str__()

b)列表转为元组：   print tuple(nums)      返回：(1, 3, 5, 7, 8, 13, 20)

c)列表不能为字典

4)字符串

string1='1,2,3,4,5'

stirng2="{'a':1,'b':2,'c':3}"

a)字符串转为元组： print tuple(eval_r(string1))  返回：(1,2,3,4,5)

b)字符串转为列表： print list(eval_r(string1))     返回：[1,2,3,4,5]

c)字符串转为字典： print eval_r(string2)             返回：{'a':1,'b':2,'c':3}

31. Python时间车日期相互转换（time模块）

参考：http://www.cnblogs.com/my1e3/p/6493163.html

1）时间戳：就是从 1970 年 1 月 1 日 00:00:00 到现在的秒数

2）常用函数：

time.time()：获取当前时间戳 例 1500978060.184446

time.localtime(): 将时间戳(秒)转换为日期元组 例 time.struct_time(tm_year=2017, tm_mon=7, tm_mday=25, tm_hour=18, tm_min=22, tm_sec=10, tm_wday=1, tm_yday=206, tm_isdst=0)

time.strftime(('%Y%m%d %H:%M:%S',time.localtime()):将日期元组转为格式化的日期字符串 例：2017-07-25 18:24:10

(不常用)time.asctime([tuple]):将日期元组转为日期字符串：例 Tue Jul 25 18:24:10 2017

time.strptime(string[,format]):将字符串解析为时间元组

time.mktime(tuple):将时间元组转换为时间戳

3）实例

a=time.time()  ----------------------------------------> 1500979025.89

b=time.localtime(a) ---------------------------------->time.struct_time(tm_year=2017, tm_mon=7, tm_mday=25, tm_hour=18, tm_min=37, tm_sec=5, tm_wday=1, tm_yday=206, tm_isdst=0)

c=time.strftime('%Y-%m-%d %H:%M:%S',b)-------->2017-07-25 18:37:05

d=time.asctime(b)--------------------------------->Tue Jul 25 18:37:05 2017

e=time.strptime(d)--------------------------------->time.struct_time(tm_year=2017, tm_mon=7, tm_mday=25, tm_hour=18, tm_min=37, tm_sec=5, tm_wday=1, tm_yday=206, tm_isdst=-1)

f=time.mktime(e)----------------------------------->1500979025.0