Python入门实例

转载自：http://blog.csdn.net/qq_15437629/article/details/45893523

相关基础

Python数据类型：

#-*-encoding:utf-8-*-#列表（list）:可修改s1=['a','s','d']s1[2]='z'print s1[2]#元组（tuple）:不可修改. tuple也是一种lists2=(1,2,3)print s2[2]#集合(set)a=set('asdfghdd')b=set('zxdfvb')print a&bprint a|bprint a-bprint set(a)    #去除重复元素#字典（dict）：关联数组d={1:'Zhang',2:'Li'}d['three']='Wang'      #添加字典项目print d

关于list和sorted函数用法：

#-*-encoding:utf-8-*-classmates = ['Michael', 'Bob', 'Tracy']classmates.append('Adam')                 #list是一个可变的有序表，可以往list中追加元素到末尾print classmates[-1]                      #可以用-1做索引，直接获取最后一个元素classmates.insert(1, 'Jack')               #把元素插入到指定的位置，比如索引号为1的位置classmates.pop(1)                         #要删除指定位置的元素，用pop(i)方法，其中i是索引位置def reversed_cmp(x, y):                 #反序排序(通常规定，对于两个元素x和y，如果认为x < y，则返回-1，如果认为x == y，则返回0，如果认为x > y，则返回1，这样，排序算法就不用关心具体的比较过程，而是根据比较结果直接排序)    if x > y:        return -1    if x < y:        return 1    return 0s=sorted(classmates, reversed_cmp)         #排序sorted()函数是一个高阶函数，它还可以接收一个比较函数来实现自定义的排序print s#列表过滤介绍[elem for elem in s if elem != "Bob"]         # 过滤掉特殊值Bob，每次Bob出来过滤表达式都不成立[elem for elem in s if s.count(elem) == 1]     #过滤出出现一次的元素

高级特性：

#-*-encoding:utf-8-*-#切片l=range(2,100)          #创建2-99的数列print l[3:6]print l[:6]           #从下标0开始print l[-5:-1]         #-1表示最后一个元素print l[:10:2]         #前10个数，每两个取一个print l[::10]          #每10个数取一个#迭代d = {'a': 1, 'b': 2, 'c': 3}for v in d.itervalues():               #迭代value    print vfrom collections import Iterable       #通过collections模块的Iterable类型判断一个对象是否可迭代print isinstance('abc', Iterable)      # str是否可迭代print isinstance([1,2,3], Iterable)    # list是否可迭代print isinstance(123, Iterable)        # 整数是否可迭代for i, value in enumerate(['A', 'B', 'C']):   print i, value

定义类并创建实例

#-*-encoding:utf-8-*-class Person(object):      #按照 Python 的编程习惯，类名以大写字母开头，紧接着是(object)，表示该类是从哪个类继承下来的    passp1 = Person()              #有了Person类的定义，就可以创建出具体的p1,p2实例。创建实例使用 类名+()p1.name = 'Bart'           #由于Python是动态语言，对每一个实例，都可以直接给他们的属性赋值 p1.gender = 'Male'p2 = Person()p2.name = 'Adam'p3 = Person()p3.name = 'Lisa'L1 = [p1, p2, p3]                               #创建包含两个Person类的实例的listL2 = sorted(L1, lambda p1, p2: cmp(p1.name, p2.name))                  #sorted() 是高阶函数，接受一个比较函数按照name进行排序。print L2[0].nameprint L2[1].nameprint L2[2].name

初始化实例属性和数据封装

#-*-encoding:utf-8-*-class Student(object):    def __init__(self, name, score):                 #初始化使用__init__() 方法的第一个参数必须是 self，后续参数则可以自由指定，和定义函数没有任何区别。相应地，创建实例时，就必须要提供除 self 以外的参数        self.name = name                                self.score = score    def print_score(self):                           #直接在Student类的内部定义访问数据的函数，实现数据封装。这些封装数据的函数是和Student类本身是关联起来的，我们称之为类的方法        print '%s: %s' %(self.name, self.score)    def get_grade(self):                         #封装的另一个好处是可以给Student类增加新的方法.可以直接在实例变量上调用，不需要知道内部实现细节        if self.score >= 90:            return 'A'        elif self.score >= 60:            return 'B'        else:            return 'C's=Student('Zhang',100)s.print_score()print s.get_grade()

访问限制

#-*-encoding:utf-8-*-class Student(object):    def __init__(self, name, score):                         self.__name = name                        #访问限制：如果一个属性由双下划线开头(__)，该属性就是private变量.但是，如果一个属性以"__xxx__"的形式定义，那它又可以被外部访问了        self.__score = score    def get_name(self):                    #如果外部代码要修改或获取私有变量可以使用set,get方法        return self.__name    def get_score(self):        return self.__score    def set_score(self, score):             #可以对参数做检查，避免传入无效的参数        if 0 <= score <= 100:            self.__score = score        else:            raise ValueError('bad score')s=Student('Zhang',100)s.set_score(200)print s.get_name()print s.get_score()

继承和多态

#-*-encoding:utf-8-*-class Runnable(object):    def run(self):        print 'Animal is running...'class Flyable(object):    def fly(self):        print 'Animal is flying...'class Dog(Runnable,Flyable):              #多重继承，子类获得了父类的全部功能    def run(self):                       #代码运行时调用子类的run()。这样就获得了继承的另一个好处：多态        print 'Dog is running...'    def eat(self):        print 'Eating meat...'dog = Dog()dog.run()dog.fly()dog.eat()print isinstance(dog, Flyable)           #判断一个变量是否是某个类型可以用isinstance()判断

特殊方法(str)和slots

#-*-encoding:utf-8-*-class Student(object):     __slots__ = ('name', 'age','set_age')       #__slots__是指一个类允许的属性列表     def __init__(self, name):        self.name = name     def __str__(self):                         #print内置特殊方法，默认 print s 返回地址（还有__len__,__cmp__等）        return '(name:%s,age:%s)' % (self.name,self.age)s = Student('Zhang')s.age = 18                 # 动态给实例绑定一个属性print s                    #自动调用s.__str__()方法def set_age(self, age):    # 定义一个外部函数作为实例方法     self.age = agefrom types import MethodTypes.set_age = MethodType(set_age, s, Student)      # MethodType给该实例绑定一个方法#Student.set_age = MethodType(set_age, None, Student)      #给所有实例绑定一个方法s.set_age(25) # 调用实例方法print s.age 

IO编程

文件操作：

#-*-encoding:utf-8-*-try:                                 #使用try ... finally来保证无论是否出错都能正确地关闭文件  f = open('/home/zlk/test.txt', 'w')     #写入ASCII编码的文本文件  f.write('Hello World')finally:  if f:     f.close#更为简介的方法：with语句和前面的try ... finally一样，并且不必调用f.close()方法。with open('/home/zlk/test.txt', 'r') as f:       for line in f.readlines():    print(line.strip())                      # 调用readline()可以每次读取一行内容 .strip(）把末尾的'\n'删掉f = open('/home/zlk/test.jpg', 'rb')       #读取二进制文件，比如图片、视频等用'rb'模式打开f.read()

序列化：

我们把变量从内存中变成可存储或传输的过程称之为序列化，在Python中叫pickling。
序列化之后，就可以把序列化后的内容写入磁盘，或者通过网络传输到别的机器上。
反过来，把变量内容从序列化的对象重新读到内存里称之为反序列化，即unpickling。
Python提供两个模块来实现序列化：cPickle和pickle。这两个模块功能是一样的，区别在于cPickle是C语言写的，速度快，pickle是纯Python写的，速度慢，跟cStringIO和StringIO一个道理。用的时候，先尝试导入cPickle，如果失败，再导入pickle

#-*-encoding:utf-8-*-try:    import cPickle as pickleexcept ImportError:    import pickle#dumps(Object)将对象序列化a = dict(name='Bob', age=20, score=88)b = pickle.dumps(a)print b#loads(String)原样恢复c = pickle.loads(b)print c#dump(Object,file)将对象存储到文件中序列化a = dict(name='Bob', age=20, score=88)f1=file('test.txt','wb')b = pickle.dump(a,f1,True)f1.close()print b#load()恢复f2=file('test.txt','rb')c = pickle.load(f2)f2.close()print c#JSONimport jsonb=json.dumps(a)          #把Python对象变成一个JSONprint bprint json.loads(b)       #把JSON反序列化为Python对象，用loads()或者对应的load()方法.反序列化得到的所有字符串对象默认都是unicode而不是str

进程和线程

进程是由若干线程组成的，一个进程至少有一个线程(主线程)。
启动一个线程就是把一个函数传入并创建Thread实例，然后调用start()开始执行

#-*-encoding:utf-8-*-import time, threading# 新线程执行的代码:def loop():    print 'thread %s is running...' % threading.current_thread().name    n = 0    while n < 5:        n = n + 1        print 'thread %s >>> %s' % (threading.current_thread().name, n)        time.sleep(1)    print 'thread %s ended.' % threading.current_thread().nameprint 'thread %s is running...' % threading.current_thread().namet = threading.Thread(target=loop, name='LoopThread')t.start()t.join()                                     #一直执行子进程print 'thread %s ended.' % threading.current_thread().name

为线程加锁，其他线程不能同时执行，只能等待，直到锁被释放后，获得该锁以后才能改。由于锁只有一个，无论多少线程，同一时刻最多只有一个线程持有该锁，所以，不会造成修改的冲突。创建一个锁就是通过threading.Lock()来实现

#-*-encoding:utf-8-*-import time, threadinglock = threading.Lock()# 新线程执行的代码:def loop():# 先要获取锁:  lock.acquire()  try:        print 'thread %s is running...' % threading.current_thread().name        n = 0        while n < 5:            n = n + 1            print 'thread %s >>> %s' % (threading.current_thread().name, n)            time.sleep(1)        print 'thread %s ended.' % threading.current_thread().name  finally:            # 改完了一定要释放锁:            lock.release()print 'thread %s is running...' % threading.current_thread().namet = threading.Thread(target=loop, name='AThread')t1 = threading.Thread(target=loop, name='BThread')t.start()t1.start()t.join()t1.join()      #一直执行子进程print 'thread %s ended.' % threading.current_thread().name

TCP编程

server.py:

#-*-encoding:utf-8-*-import socketimport threadingimport times = socket.socket(socket.AF_INET, socket.SOCK_STREAM)# 监听端口:s.bind(('127.0.0.1', 9995))s.listen(5)                                            #调用listen()方法开始监听端口，传入的参数指定等待连接的最大数量print 'Waiting for connection...'def tcplink(sock, addr):    print 'Accept new connection from %s:%s...' % addr    sock.send('Welcome!')    while True:        data = sock.recv(1024)        time.sleep(1)        if data == 'exit' or not data:            break        sock.send('Hello, %s!' % data)    sock.close()    print 'Connection from %s:%s closed.' % addrwhile True:    # 接受一个新连接:    sock, addr = s.accept()                         #accept()会等待并返回一个客户端的连接    # 创建新线程来处理TCP连接:    t = threading.Thread(target=tcplink, args=(sock, addr))    t.start()

client.py:

import socket   s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)# 建立连接:s.connect(('127.0.0.1', 9995))# 接收欢迎消息:print s.recv(1024)for data in ['Michael', 'Tracy', 'Sarah']:    # 发送数据:    s.send(data)    print s.recv(1024)s.send('exit')s.close()

UDP编程

使用UDP协议时，不需要建立连接，只需要知道对方的IP地址和端口号，就可以直接发数据包。但是，能不能到达就不知道了。
虽然用UDP传输数据不可靠，但它的优点是和TCP比，速度快，对于不要求可靠到达的数据，就可以使用UDP协议。

server.py:

#-*-encoding:utf-8-*-# 导入socket库import socket             s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)       #SOCK_DGRAM指定了这个Socket的类型是UDP# 绑定端口s.bind(('127.0.0.1', 9995))                print 'Bind UDP on 9995...'while True:    # 接收数据:    data, addr = s.recvfrom(1024)    print 'Received from %s:%s.' % addr    s.sendto('Hello, %s!' % data, addr)

client.py:

import socket   s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)for data in ['Michael', 'Tracy', 'Sarah']:    # 发送数据:    s.sendto(data, ('127.0.0.1', 9995))    # 接收数据:    print s.recv(1024)s.close()