- 列表-----序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - （它的位置），或索引，第一个索引是0，第二个索引是1，以此类推。
创建列表方式
- name1=[]
- name2=list()
python列表各种操作方式
#创建带元素的列表
names=["Dave","Mark","Ann","Phil"]
print ("names=%s"% names) #打印列表所有成员
a=names[2]
print ("a=%s"%a) #打印下标为2的元素(下标从0开始)
names[0]="Jeff" #替换下标为0的位置的元素内容
print ("names[0]=%s" % names[0])
names.append("paula") #追加到末尾
print ("names=%s" % names)
#插入到指定位置
names.insert(2,"Thomas")
print ("names=%s" % names)
#只打印前两个值 取值范围为0<=i<2 包含左不包含右
b=names[0:2]
print ("b=%s" % b)
c=names[2:] #打印从下标2开始到最后一个元素
print ("c=%s" % c)
替换从0开始到2的元素，不包括2位置，，元素多的也会顺便插入再当前位置，
即0和1是Dave Mark，则2为Jeff，之前2位置往后的元素顺延至下一位
names[:2]=["Dave","Mark","Jeff"]
print ("--------names=%s" % names)
代码执行截图
列表高级的操作
#列表连接 d=[1,2,3]+[4,5] print ("d=%s" % d) #列表可以包含任意的Python对象 f=[1,"Dave",3.14,["Mark",7,9,[100,101]],10] #这种打印可以根据括号找对应的对象，一个括号对应列表的最外围的括号，两个就向内扩展一个依次。 print ("f[1] =%s"% f[1]) print ("f[3][2] =%d"% f[3][2]) print ("f[3][3][1] =%d" %f[3][3][1]) #列表高级属性 import sys if len(sys.argv) !=2: print ("please supply a filname") raise SystemExit(1) f =open(sys.argv[1]) lines=f.readlines() f.close() fvalues=[float(line)for line in lines] print ("The minimum value is ", min(fvalues)) print ("The maximum value value is ",max(fvalues))
- 元组----Python的元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号，列表使用方括号。元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可
#coding=utf-8 stock=("Good",100,49.10) address=('www.python.org',80) #person=(first_name,last_name,phone) #没有圆括号python也能是元组 stock="Good",100,49.10 address='www.python.org',80 #person=first_name,last_name,phone #也可以使用数字下表来提取元组的内容 #元组和列表操作基本相同，但是元组一旦创建里面的元素内容就不能被改变了 #案例将元组作为对象存放近列表 filename="foo.txt" portfolio=[]#创建一个列表 for line in open(filename): fileds=line.split(",") name =fileds[0] print (" %s %s %s"% (fileds[0],fileds[1],fileds[2])) shares=int(fileds[1]) price=float(fileds[2]) stock=(name,shares,price) #创建一个元组 portfolio.append(stock) #添加元素到列表 print (portfolio)
- 集合、字典
字典是另一种可变容器模型，且可存储任意类型对象字典的每个键值 key=>value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中
#coding=utf-8 #创建集合使用set()函数 集合支持标准操作，并集、交集、差集、对称差集 s=set([3,5,9,10]) t=set("Hello") #注：集合元素是无顺序的、切不能重复，不能通过数字索引找到 print ("t=%s"% t) #打印纸会打印出一个 l 因为不会打印出重复的值 a= t | s #t和s并集 b= t & s #交集 c= t - s #差集 d= t ^ s #对称差集 print ("a=%s b=%s c=%s d=%s"%(a,b,c,d)) # add() update() remove() t.add('x') print ('t=%s'%t) s.update([10,37,42]) print ('s=%s'% s) t.remove('H') print ('t=%s'%t)
################################
#字典 Dictionary
#字典是一个关联数组或散列表，通过关键字索引对象
stock={ "name" : "GooG",
"shares" : 100,
"price" : 490.10
}
print (stock)
#插入 修改
stock["shares"]=75
stock["date"] ="June 7,2007"
print (stock)
#创建一个空字典
prices={}
prices=dict()
##字典快速查找
prices ={
"GOOG" : 490.10,
"AAPL" : 123.50,
"IBM" : 91.50,
"MSFT" : 52.13
}
print (prices)
#使用in运算符测试某个内容是不是字典成员
if 'SCOX' in prices:
p=prices['SCOX']
else:
p=0.0
print (p)
#下面也是检测SCOX在不在字典里面的方式。不在就给p赋值 0.0
p=prices.get('SCOX',0.0)
print (p)
#获得字典的关键字列表，将字典转为列表即可
syms=list(prices)
print (syms) #输出的是字典的关键字即 : 前面的值
#del删除字典元素
del prices['MSFT']
print (prices)
- 迭代器----迭代和循环是Python中很重要的
#coding=utf-8
#迭代和循环是Python中很重要的
for n in [1,2,3,4,5,6]:
print ("2 to the %d power is %d" % (n,2**n))
print (n)
for n in range(1,10):
print ("2 to the %d power is %d" % (n,2**n))
#range(i,j,k) 表示创建的从i到j-1的以k值递进的整数值
a=range(0,10,2)
print (a)
b=range(0,10)
print (b)
c=range(10)
print (c)
d=range(10,1,-1)
print (d)
#处理字符串
e='hello world'
for f in a:
print (f)
h=["Dave","Mark","Ann","Phil"]
for name in h:
print (name)
i={'GOOG':490.10,'IBM': 91.50,'AAPl':123.15}
for key in i:
print (key,i[key])
f=open('foo.txt')
for line in f:
print (line)
- 生成器---在Python中，一边循环一边计算的机制，称为生成器
#coding=utf-8
#使用yield 可以使函数生成一个结果序列
def countdown(n):
print ("Counting down")
while n>0:
yield n
n-=1
c=countdown(5)
for n in range(0,5):
print ("c.next()=%d"% next(c)) #3.x后生成器的下一个需要next(C) 2.X版本是 C.next()
#一般调用Yield生成器生成的函数会使用循环
for i in countdown(5):
print (i)
#生成器是基于处理管道、数据流的一种更强大的编码方式
#1.监控日志文件的 UNIX tail -f命令
import time
def tail(f):
f.seek(0,2)
while True:
line=f.readline()
if not line:
time.sleep(0,1)
continue
yield line
#2.使用生成器在多行中查找特定字符处啊
def grep(lines,searchtext):
for line in lines:
if searchtext in line:
yield line
#合并1、2创建一个简单的管道
#UNIX "tail -f | grep python python " 命令的python实现
#wwlog=tail(open("access-log"))
#pylines=grep(wwwlog,"python")
#for line in pylines:
# print line
#协程
#####函数在使用时要输入一组参数，可以将函数编写为一个任务，从而能处理发送给他的一系列输入，该类函数称为协程使用Yield语句可以创建协程
def print_maches(matchtext):
print ("Looking for",matchtext)
while True:
line=(yield) #获得一行文本
if matchtext in line:
print (line)
matcher=print_maches("python")
next(matcher) #向前执行第一条(Yield)语句
matcher.send("Hello World")
matcher.send("python is cool")
matcher.close() #匹配器函数调用结束
#基于生产者-消费者模型编写并发程序，协程很有用。 共同使用生成器和协程的例子如下
#一组匹配器协程
matchers=[print_maches("python"),print_maches("guido"),print_maches("jython")]
#通过调用next()准备所有的匹配器
for m in matchers:
next(m)
#为所有匹配器提供一个活动日志文件，必须有一台活动的web服务器将数据写入
wwwlog=tail(open("access-log"))
for line in wwwlog:
for m in matchers:
m.send(line) #将数据发送到每个匹配器协程中
- 字符串
#coding=utf-8
a= 'hello world'
b="Python is groovy"
c=""" Computer says No """
print (''' Content-type: text/html
<h1> Hello <h1>
Click <A href="http://www.python.org">here</a>
''')
#切片运算符 s[i:j] 提取字符串中索引 K 处的字符 i<=k<j
#省略i 则从字符串起始位置s[:j] 0 <= k<j
d=a[:5]
e=a[:6]
f=a[3:8]
print ("d=%s e=%s f=%s" % (d ,e ,f))
# +连接两个字符串
d= d+e
print ("d=%s" % d)
#执行数学运算 只能转数字字符串
z=int("23")+int("23")
print ("z=%d"% z)
- 条件判断
#coding=utf-8 a=1;b=2; if a<b: print ("computer say yes") else: print ("computer say no") product ="game"; type="pirate memory"; age =5; if product == "game" and type == "pirate memory" \ and not (age < 4 or age >8): print ("I'll take it") #python not have switch case suffix= ".jpg" if suffix == ".htm": content="text/html" elif suffix == ".jpg": content="image/jpeg" elif suffix == ".png": content="image/png" else: raise RuntimeReeor("Unknown content type") print ("content =%s" % content) #if 条件语句如果要表示为空的话可以使用pass语句 if a: pass else: pass
- 异常
#coding=utf-8 #使用def 创建函数 def remainder(a,b): q=a//b #截断除法运算符 r=a-q*b return r #调用函数只需result=remainder(31,15) #要让函数返回多个值，可以使用元组(...) def divide(a,b): q=a//b print ("q=%d"% q) r=a-q*b print ("r=%d"% r) return (q,r) #使用元组返回多个值时，可以容易的江边来那个放到单独的变量中 quot,remd=divide(1456,33) print (quot,remd) #给函数参数提供一个默认值 调用时可以省略该参数 #def connect(hostnaem,port,timeout=300): #函数体 # connect("www.python.org",80) #也可以使用函数参数名称去任意顺序填写参数,前提得知道函数的参数名称 # connect(port=80,hostname="www.python.org",timeout=30) #在函数内部修改某个全局变量的名称使用global count=0 def foo(): global count count += 1 print ("count=%d"%count) foo() print ("count=%d"%count)
- 异常
#coding=utf-8 #如果程序中出现异常，就会引发一系列的错误 使用try catch语句可以追踪并处理异常 try: f=open("file.txt","r") except IOError as e: print (e) #上述中如果出现异常会将错误信息放置在对象e中然后将控制权传递给except代码块 #python中的模块 #在python中 随着代码的越来越多，为了便于维护需要分为多个文件 然后在其他文件或者脚本中导入使用 #在其他文件中使用某个模块可以这样 import filename 例： # 模块文件div.py def divide(a,b): q=a/b r=a-q*b return (q,r) #在另一个文件中使用 import div a,b=div.divide(2,3) #使用不同的名称导入到当前文件 可以使用as限定符 import div as foo a,b=foo.divide(2,3) #要将具体的定义导入到当前的命名空间中可以使用from 如果要将divide函数导入另一个文件 from div import divide a,b=divide(2,3) #导入所有的模块到另一个文件中 from div import *
- 文件输入输出
# -*- coding: UTF-8 -*- f=open("foo.txt") line=f.readline() while line: print line, line=f.readline() f.close() for line in open("foo.txt"): print line, #重定向输出打印到out文件中，类似于打印log #redirect print to a out file,likes print log to fle year =1; principal=1;numyears=5;rate=0.2 f=open("out","w") while year <= numyears: principal = principal *(1+rate) print >> f,"%3d %0.2f " % (year,principal) #python 2 f.write("%3d %0.2f \n" % (year,principal)) #也是将内容写入文件 #print("%3d %0.2f" % (year,principal),file=f) #python 3 year+=1 f.close() #标准文件输入输出 import sys sys.stdout.write("Enter your name:") name=sys.stdin.readline() #在python 2 中上述输入等价于--->name1=raw_input("Enter your name:") #在python 3 中上述输入等价于--->name2=input("Enter your name:")