Python之基础知识

参考文献：老师博客：http://www.cnblogs.com/wupeiqi/articles/4943406.html

范例一：

练习：元素分类

有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中。

即： {'k1': 大于66 , 'k2': 小于66}

#!/usr/bin/env pyton 

#coding:utf-8 

a = [11,22,33,44,55,66,77,88,99,90] 

dic = {} 

for item in a: 

 if item > 66: 

 if 'k2' in dic.keys(): 

 dic['k2'].append(item) 

 else: 

 dic['k2'] = [item,] #创建只有一项的元素列表 

else: 

 if 'k1' in dic.keys(): 

 dic['k1'].append(item) 

 else: 

 dic['k1'] = [item,] 

print dic 

范例二：

#!/usr/bin/env pyton 

#coding:utf-8 

 

file_read = file('L1.txt','r') 

file_list = file_read.readlines() 

file_read.close() 

 

#print file_list ['alex|123|1\n', 'eric|123|1\n', 'tony|123|1'] 

dic = {} 

for item in file_list: 

 line = item.strip() #strip空格和换行去掉 

line_value = line.split('|') #split分隔 

#print line_value #['alex', '123', '1'] 

 for i in line_value: 

 dic[line_value[0]] = line_value[1:] #line_value[1:]就是下标为1和后面的左右的值 

 

print dic 

一：collection系列

1：计数器：（Counter ）

Counter是对字典类型的补充，用于追踪值的出现次数。

#!/usr/bin/env python

# -*- coding:utf-8 -*-

#导入模块

import collections

collections.Counter

#传一个字符串

c = collections.Counter('fegfdsagerqfads') 
print c 
#结果：Counter({'f': 3, 'a': 2, 'e': 2, 'd': 2, 'g': 2, 's': 2, 'q': 1, 'r': 1}) 

#传一个列表

d1 = [11,22,33,111,22,33,11]

d = collections.Counter(d1)

print d

#传一个元组

e = ('aa','bbb','aa','b')

e1 = collections.Counter(e)

print e1

#迭代器

for item in c.elements():

print item

2：有序字典

有序字典和字典是一样的，只不过有序字典在内部使用

它是将他所有的KEY放在一个列表中，列表是有序的，这样有序字典输出的内容就是有序的。

有序字典支队第一层生效。但是你可以把内部的字典继续进行

3、默认字典(defaultdict)

 

obj_file = open('1.txt','r+') 

obj_file.seek(3) 

obj_file.truncate() 

#不加则是将指针后面的全部删除 

read_lines = obj_file.readlines() 

print read_lines 

结果： 

['123'] 

#使用默认字典，定义默认类型为list,

dic1 = {'k1':[]} 
dic2 = collections.defaultdict(list) #可以定义list,元组，字典都行 
dic1['k1'].append(1) 

4、可命名元组(namedtuple)

import collections

#创建一个扩展元组tuple的类（主要用在坐标上）

Mytuple = collections.namedtuple('Mytuple',['x', 'y']) 

new = Mytuple(1,2) 

print new 

print new.x 

print new.y 

#原始的元组的创建

old = tuple([1,2]) 

print old 

''' 

Mytuple(x=1, y=2) 

1 

2 

(1, 2) 

''' 

5、双向队列(deque)

两端都可以取、插。

线程安全。

import collections 

q = collections.deque() 

q.append(1) 

q.append(12) 

q.append(13) 

q.append(14) 

print q 

print q.pop() 

print q 

print q.popleft() 

print q 

''' 

结果 

deque([1, 12, 13, 14]) 

14 

deque([1, 12, 13]) 

1 

deque([12, 13]) 

''' 

6：单向队列

队列，FIFO

栈，弹夹

线程安全的

import Queue 

#最多放几条数据，10条 

a = Queue.Queue(10) 

a.put(1) 

a.put(21) 

a.put(12) 

print a.get() 

print a.get() 

print a.get() 

print a.get() 

二：迭代器和生成器

1：迭代器

对于Python 列表的 for 循环，他的内部原理：查看下一个元素是否存在，如果存在，则取出，如果不存在，则报异常 StopIteration。（python内部对异常已处理）

class listiterator(object) 

 | Methods defined here: 

 | 

 | __getattribute__(...) 

 | x.__getattribute__('name') <==> x.name 

 | 

 | __iter__(...) 

 | x.__iter__() <==> iter(x) 

 | 

 | __length_hint__(...) 

 | Private method returning an estimate of len(list(it)). 

 | 

 | next(...) 

 | x.next() -> the next value, or raise StopIteration 

实例：next函数的应用

#!/usr/bin/python 

 

# Open a file 

fo = open("foo.txt", "r") 

print "Name of the file: ", fo.name 

 

# Assuming file has following 5 lines 

# This is 1st line 

# This is 2nd line 

# This is 3rd line 

# This is 4th line 

# This is 5th line 

 

for index in range(5): 

 line = fo.next() 

 print "Line No %d - %s" % (index, line) 

 

# Close opend file 

fo.close() 

这将产生以下结果: 

Name of the file: foo.txt 

Line No 0 - This is 1st line 

Line No 1 - This is 2nd line 

Line No 2 - This is 3rd line 

Line No 3 - This is 4th line 

Line No 4 - This is 5th line 

2：生成器

range不是生成器 和 xrange 是生成器

readlines不是生成器 和 xreadlines 是生成器

生成器内部基于yield创建，即：对于生成器只有使用时才创建，从而不避免内存浪费

print range(10) 

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 

print xrange(10) 

xrange(10) 

3：冒泡算法

有如下列表

[13, 22, 6, 99, 11]

请按照一下规则计算：

13 和 22 比较，将大的值放在右侧，即：[13, 22, 6, 99, 11]

22 和 6 比较，将大的值放在右侧，即：[13, 6, 22, 99, 11]

22 和 99 比较，将大的值放在右侧，即：[13, 6, 22, 99, 11]

99 和 42 比较，将大的值放在右侧，即：[13, 6, 22, 11, 99,]

13 和 6 比较，将大的值放在右侧，即：[6, 13, 22, 11, 99,]

3.1思考

a = 1 , b = 2 , 如何才能让a与b的赋值相互转换呢？

a = 1 

b = 2 

tmp = a 

a = b 

b = tmp 

print a ,b 

3.2：实例

li = [13, 22, 6, 99, 11] 

for m in range(len(li)-1): 

 for n in range(m+1,len(li)): 

 if li[m] > li[n]: 

 tmp = li[n] 

 li[n] = li[m] 

 li[m] = tmp 

print li 

三：函数

种类：内置函数、自定义函数、导入（第三方）函数

函数声明，不自动执行；调用后才执行

函数的参数

vars()=====当前模块的所有变量 
print vars() 
print __doc__ #打印当前文件的注释 
print __name__ 
if __name__ == '__main__': #确认是不是主函数 
print '这是主函数' 
print __file__ #打印文件的路径 
all()接受一个序列，判断所有的值都是真则返回值，否则为假 
any()只要有一个是真就是真，全部是假才为假 
li = ['ccc',' ',15] 
print all(li) 
print any(li) 
lli = [''] 
print any(lli) 
enumerate() 
li = [11,22,33,44,55] 
for k,v in enumerate(li): 
 print k,v 
#默认从0开始，指定从1开始 
for k,v in enumerate(li,1): 
 print k,v 

1：常用的内置函数

函数式编程和面向过程编程的区别：

函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可

面向对象：对函数进行分类和封装，让开发"更快更好更强..."

函数式编程最重要的是增强代码的重用性和可读性

2：函数的定义和使用

def 函数名（参数）:

函数体

函数的定义主要有如下要点

1：def：表示函数的关键字

2：函数名：函数的名称，日后根据函数名调用函数

3：函数体：函数中进行一系列的逻辑的计算

4：参数：为函数体提供数据

5：返回值：当函数执行完毕后，可以给调用者返回数据

3：参数：（形参和实参）

普通参数

普通参数必须传参

# ######### 定义函数 ######### 
# name 叫做函数func的形式参数，简称：形参 
def func(name): 
 print name 
# ######### 执行函数 ######### 
# '曹小贱' 叫做函数func的实际参数，简称：实参 
func('曹小贱') 

默认参数

1：不传；则使用默认值

2：默认参数必须放在参数列表的最后，也可以有多个默认参数

def func(name, age = 18): 
 print "%s:%s" %(name,age) 
# 指定参数 
func('曹小贱', 19) 
# 使用默认参数 
func('曹小贱') 

注：默认参数需要放在参数列表最后

动态参数

1：def func(*args): 可以接收元组和列表

2：内部自动构造元组

3：如果传递的是序列，可以使用*来避免内部构造元组

4：def func(**kwargs): 可以接收字典

动态参数1：

def func(*args): 

 print args 

#执行方式一 

func(11,22,33,44,55,6) 

#执行方式二 

li = [11,22,33,434,55] 

func(*li) 

结果： 

(11, 22, 33, 44, 55, 6) 

(11, 22, 33, 434, 55) 

动态参数2：

def func(**kwargs): 

 print kwargs 

#执行方式一 

func(name='caoxiaojian',age=18) 

#执行方式二 

li = {'name':'caoxiaojian','age':18,'sex':'man'} 

func(**li) 

结果： 

{'age': 18, 'name': 'caoxiaojian'} 

{'age': 18, 'name': 'caoxiaojian', 'sex': 'man'} 

动态参数3：

def func(*args, **kwargs): 

 print args 

 print kwargs 

func(11,3243,12,31) 

print '==========' 

func(k1=111,k2=222) 

print '==========' 

func(1,2,43,45,k3=333,k4=444) 

结果： 

(11, 3243, 12, 31) 

{} 

========== 

() 

{'k2': 222, 'k1': 111} 

========== 

(1, 2, 43, 45) 

{'k3': 333, 'k4': 444} 

4：邮件报警

范例一：

def email(arg): 

 print arg 

if __name__ == '__main__': 

 cpu = 100 

 disk = 500 

 ram = 50 

 for i in range(2): 

 if cpu > 90: 

 alert = 'CPU出问题' 

email(alert) 

 #要发送的内容，将这个alert的值传到函数email中作为arg使用 

if disk > 90: 

 alert = '硬盘出问题' 

email(alert) 

 if ram > 80: 

 alert = '内存出问题' 

email(alert) 

范例二：

#!/usr/bin/env python 

# -*- coding:utf-8 -*- 

import smtplib 

from email.mime.text import MIMEText 

from email.utils import formataddr 

 

def email(message): #message邮件内容 

msg = MIMEText(message, 'plain', 'utf-8') 

 msg['From'] = formataddr(["曹高田",'cs901129@163.com']) 

 msg['To'] = formataddr(["CGT",'1063578149@qq.com']) 

 msg['Subject'] = "曹高田监控" 

server = smtplib.SMTP("smtp.163.com", 25) 

 server.login("cs901129@163.com", "caogaotian-0608") 

 server.sendmail('cs901129@163.com', ['1063578149@qq.com',], msg.as_string()) 

 server.quit() 

 

if __name__ == '__main__': 

 cpu = 100 

 disk = 500 

 ram = 50 

 for i in range(2): 

if cpu > 90: 

 alert = 'CPU出问题' 

email(alert) 

 #要发送的内容，将这个alert的值传到函数email中作为arg使用 

if disk > 90: 

 alert = '硬盘出问题' 

email(alert) 

 if ram > 80: 

 alert = '内存出问题' 

email(alert) 

四：文件操作

1：基础知识

操作文件的步骤：

打开文件-----操作文件-----关闭文件

打开方式：

obj_file = open('path','mode')

也有file的方式打开，但是open是调用file方式来执行的，推荐使用open

打开模式：

r：只读模式（默认）

w：只写模式，不可读；不存在则创建文件，存在则删除其中的内容

a：追加模式，可读，不存在则创建，存在则追加，但是会在指针的位置后面添加（下面会讲到指针的位置）

r+：可读写文件，还可以追加（一般常用）

U：表示在读取时，可以将\r\n \r\n自动转换成\n（一般与r、r+一起使用）

2：操作文档

class file(object): 

 def close(self): # real signature unknown; restored from __doc__ 

关闭文件 

""" 

close() -> None or (perhaps) an integer. Close the file. 

 Sets data attribute .closed to True. A closed file cannot be used for 

 further I/O operations. close() may be called more than once without 

error. Some kinds of file objects (for example, opened by popen()) 

 may return an exit status upon closing. 

 """ 

 def fileno(self): # real signature unknown; restored from __doc__ 

文件描述符 

""" 

fileno() -> integer "file descriptor". 

 This is needed for lower-level file interfaces, such os.read(). 

 """ 

 return 0 

 def flush(self): # real signature unknown; restored from __doc__ 

刷新文件内部缓冲区 

""" flush() -> None. Flush the internal I/O buffer. """ 

 pass 

 def isatty(self): # real signature unknown; restored from __doc__ 

判断文件是否是同意tty设备 

""" isatty() -> true or false. True if the file is connected to a tty device. """ 

 return False 

 def next(self): # real signature unknown; restored from __doc__ 

获取下一行数据，不存在，则报错 

""" x.next() -> the next value, or raise StopIteration """ 

 pass 

 def read(self, size=None): # real signature unknown; restored from __doc__ 

读取指定字节数据 

""" 

read([size]) -> read at most size bytes, returned as a string. 

 If the size argument is negative or omitted, read until EOF is reached. 

 Notice that when in non-blocking mode, less data than what was requested 

 may be returned, even if no size parameter was given. 

 """ 

 pass 

 def readinto(self): # real signature unknown; restored from __doc__ 

读取到缓冲区，不要用，将被遗弃 

""" readinto() -> Undocumented. Don't use this; it may go away. """ 

 pass 

 def readline(self, size=None): # real signature unknown; restored from __doc__ 

仅读取一行数据 

""" 

readline([size]) -> next line from the file, as a string. 

 Retain newline. A non-negative size argument limits the maximum 

 number of bytes to return (an incomplete line may be returned then). 

 Return an empty string at EOF. 

 """ 

 pass 

 def readlines(self, size=None): # real signature unknown; restored from __doc__ 

读取所有数据，并根据换行保存值列表 

""" 

readlines([size]) -> list of strings, each a line from the file. 

 Call readline() repeatedly and return a list of the lines so read. 

 The optional size argument, if given, is an approximate bound on the 

 total number of bytes in the lines returned. 

 """ 

 return [] 

 def seek(self, offset, whence=None): # real signature unknown; restored from __doc__ 

指定文件中指针位置 

""" 

seek(offset[, whence]) -> None. Move to new file position. 

 Argument offset is a byte count. Optional argument whence defaults to 

 0 (offset from start of file, offset should be >= 0); other values are 1 

 (move relative to current position, positive or negative), and 2 (move 

 relative to end of file, usually negative, although many platforms allow 

 seeking beyond the end of a file). If the file is opened in text mode, 

 only offsets returned by tell() are legal. Use of other offsets causes 

 undefined behavior. 

 Note that not all file objects are seekable. 

 """ 

 pass 

 def tell(self): # real signature unknown; restored from __doc__ 

获取当前指针位置 

""" tell() -> current file position, an integer (may be a long integer). """ 

 pass 

 def truncate(self, size=None): # real signature unknown; restored from __doc__ 

截断数据，仅保留指定之前数据 

""" 

truncate([size]) -> None. Truncate the file to at most size bytes. 

 Size defaults to the current file position, as returned by tell(). 

 """ 

 pass 

 def write(self, p_str): # real signature unknown; restored from __doc__ 

写内容 

""" 

write(str) -> None. Write string str to file. 

 Note that due to buffering, flush() or close() may be needed before 

 the file on disk reflects the data written. 

 """ 

 pass 

 def writelines(self, sequence_of_strings): # real signature unknown; restored from __doc__ 

将一个字符串列表写入文件 

""" 

writelines(sequence_of_strings) -> None. Write the strings to the file. 

 Note that newlines are not added. The sequence can be any iterable object 

 producing strings. This is equivalent to calling write() for each string. 

 """ 

 pass 

 def xreadlines(self): # real signature unknown; restored from __doc__ 

可用于逐行读取文件，非全部 

""" 

xreadlines() -> returns self. 

 For backward compatibility. File objects now include the performance 

 optimizations previously implemented in the xreadlines module. 

 """ 

 pass 

3：例子

file.tell

显示指针所在的位置

''' 

文件内容是：123456 

''' 

obj_file = open('1.txt','r') 

print obj_file.tell() 

read_lines = obj_file.readlines() 

print obj_file.tell() 

file.seek

将指针放在执行的位置

obj_file.seek(3) 

print obj_file.tell() 

file.truncate

截取数据

原文件内容是：1234567

方式一：

obj_file = open('1.txt','r+') 

obj_file.truncate() 

#不加则是将指针后面的全部删除 

read_lines = obj_file.readlines() 

print read_lines 

结果： 

[]空 

方式二：

obj_file = open('1.txt','r+') 

obj_file.seek(3) 

obj_file.truncate() 

#不加则是将指针后面的全部删除 

read_lines = obj_file.readlines() 

print read_lines 

结果 

[] 

方式三：

obj_file = open('1.txt','r+') 

obj_file.seek(3) 

obj_file.truncate() 

#不加则是将指针后面的全部删除 

read_lines = obj_file.readlines() 

print read_lines 

结果： 

['123'] 

 

解析：

方式一是从文件开始，使用truncate，没有指定size，则将指针后面的全部删除。

方式二是从指针位置3开始删除。但是原文件中的前面的123还存在

方式三是指定size大小，仅仅保留前三个位置，打印出前面的123，且还存在在原文件中

4：with

with的出现是为了避免打开文件后忘记关闭文件，而造成进程占用。

使用方式：

with open('db',r) as read_file:

with open('db1') as read_file1,open('db2') as read_file2: