Python入门实例

相关基础

Python数据类型：

#-*-encoding:utf-8-*-

#列表（list）:可修改
s1=['a','s','d']
s1[2]='z'
print s1[2]

#元组（tuple）:不可修改. tuple也是一种list
s2=(1,2,3)
print s2[2]

#集合(set)
a=set('asdfghdd')
b=set('zxdfvb')
print a&b
print a|b
print a-b
print 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 0

s=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 v

from 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)，表示该类是从哪个类继承下来的
    pass

p1 = 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类的实例的list
L2 = sorted(L1, lambda p1, p2: cmp(p1.name, p2.name))                  #sorted() 是高阶函数，接受一个比较函数按照name进行排序。

print L2[0].name
print L2[1].name
print 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 = age

from types import MethodType
s.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 pickle
except 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

#JSON
import json
b=json.dumps(a)          #把Python对象变成一个JSON
print b
print 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().name

print 'thread %s is running...' % threading.current_thread().name
t = 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, threading

lock = 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().name
t = 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 socket
import threading
import time

s = 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.' % addr


while 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()