[转载]python基础
本文系原创，转载请注明作者姓名及原文地址：
此为[Python基础教程(第2版)].人民邮电出版社
未完成，持续更新
hello world: 字符串.用于表示文本,也是值,就像数字一样
单引号与双引号区别:&&&"let's
&&&&&&&&&&&&&&&&&
"let's go!"
&&&&&&&&&&&&&&&&&&
&&&'"hello,world!"she
&&&&&&&&&&&&&&&&&&
'"hello,word!"she said'
&&&&&&&&&&&&&&&&&&&&&
在字符串内含有单引号的时候,始末不可出现双引号
&&&&&&&&&&&&&&&&&&&&&&&
在字符串内含有双引号的时候,始末可用单引号
&&&&&&&&&&&&&&&&&&&&
也可使用对字符中的引号进行转义
&&&&&&&&&&&&&&&&&&&
&&&'le's go!'
&&&&&&&&&&&&&&&&&&&&&
"let's go!"& 令,单引号表示所有格,也可用/,要放在未结束语句的引号的前面
print: 打印某参数&& print "hello
world！"& 一类语句
他会去掉单引号,达到我们想要的显示
语句不等于表达式，赋值改变了变量，print改变了屏幕显示的内容
拓展:1& 注意此处input和raw_区别
name=raw_input("waht is your name?")
&print"hello,"+name+"!"
有一个问题存在，就是，运行程序并且输入名字之后，看不到结果，窗口就马上关闭了，可以在最后加上以下语句：
("press&enter&")&&
任意字符： raw_input ()
如此即可要多按以下回车键才会关闭
print2*pi*radius&&&&&&
打印圆的周长
3.& user_name=raw_input("what is your
sqrt：求平方根&&&&&&&&
sqrt(4)&&&
会被转换为浮点数，因为他只能处理浮点数
int：吧参数转换成整数时会自动向下取整
from math：导入模块
if：条件语句
**：平方根&& 可用函数pow
表示&& 即为pow（2，3）为内建函数
from_future_import division:&
执行普通的除法，默认的除法时1/2=0&&
1.0/2.0=0.5
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
普通的除法为1/2=0.5，另一种办法（只有linux可用）
注意浮点数与整数的区别&&&&&&&
-qnew，除法即可合理，如果要用整除，可用1//2，就算是浮点数，
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
1.0//2.0=0.0
取余运算：10/3=3&&&
2.75%0.5=0.25，可用于每10分钟检查一次操作，查看取余运算的结果是否为0即可
八进制&& &
x=3 ：赋值语句&
assignement&&
x为变量，变量名可以包括字母，数字和下划线，不能以数字开头
input语句：&& input（"the meaning of
the meaning of& life:42
&&&&&&&&&&&&&&
&&&&&&&&&&&&&&
解释器执行了第一行的input（..）语句打印出了...，并以此作为新的提示符，输入42按回车，input语句就是输入的数字，在最后一行被打印出来
&&&&&&&&&&&&
eg：x=input（"x:"）
&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&
y=input("y:")
&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&
1428&&&&&&&&&&&&&&&&&&&&&&&&
这种语句可用于高级的各种计算，即是获取用户输入
input和raw_input的比较,
& name=input(what is your name?" )
& print"hello,"+name+"!"
& 这个语句，需要用户输入标准的python表达式，即为"***"
raw_input("enter a number:")
number:3&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
nput("enter a number:")
enter a number:3
&而raw_input
则可以将字符转换为表达式.除非对input有特别需要,否则一般用raw_input函数
&& &if语句：
if 1==2: print
'.......'&&&
两次回车&&&&&&&&&
if语句，条件为真则显示2222，为假则什么都不发生
if 1==1: print'2222' &
则会显示22222&&&&&&&&&&&&&&&&&&&&&&&
如果if time`==0：print 'one the hour!'
abs（-10）&&&&&&&&&&&&&&
求数的绝对值
round&&&&&&&&&&&&&&&&&&
把浮点数四舍五入到最为接近的整数值
floor&&&&&&&&&&&&&&&&&&
把浮点数向下取值
ceil&&&&&&&&&&&&&&&&&&
ceiling的简写, 与floor相反,把浮点数向上取值
int: 用于把浮点数转换成整数&&
eg:&&&int(math.floor(32.9))&&&&
import& 为 导入插件，&
floor函数就在名为math的模块中
&&&import math
&&&math.floor(32.9)
32.0&&&&&&&&&&&&&&&&&&&&
用import导入了模块，然后按照“模块.函数”的格式使用这个模块的函数,在确定自己不会导入多个同名函数(从不同模块导入)的情况下,可以用importat的另一个形式:
&&&from math import
&&&sqrt(9)
3.0&&&&&&&&&&&&&&&&&&
在使用了 "from模块import函数"这种 形式的import命令之后,就可以直接使用函数,而不需要模块名作为前缀
nan:是一个特殊值的简写,意思是not 啊number 非数值
负数的平方根为虚数.复数，即实数和虚数之和，令外一个cmath（即complex
math，复数）的模块可实现这个功能，用简便语句表现即为
from cmath import sqrt&&
sqrt（-1）&&&&&&&&&&&
注意，一旦使用了这个语句，就没法使用普通的sqrt函数了，会冲突，除非真的需要from这个形式的模块导入语句，否则应该坚持使用普通的import。
1j:是个虚数,虚数均以j结尾,类似于长数L.不会算虚数啊卧槽....
(1+3j)*(9+4j)
#！/usr/bin/env python&&
把这个加在整个脚本的前端，把脚本像普通程序一样运行，如果装了多个版本 则需要指定更完整的目录：
#！/usr/bin/python2&&&
具体的路径根据实际改变
￥chmod a+x hello.py& 运行脚本之前，必须让脚本具有可执行的属性
.pyw&& 为windows&
专用的文件类型，但是为何双击后什么都没有？
#：这个符号可以忽略右边的所有代码，因而一般用来注释
书写字符串:&&&"hello,"+"world!"
&&&&&&&&&&&&&&
'hello,world!'
&&&&&&&&&&
&&&x="hello,"
&&&&&&&&&&
&&&y="word!"
&&&&&&&&&&
&&&&&&&&&&
'hello,world!'
三种字符串的转换的方法，str和repr
&&&&&&&&&&&
str，会把值转换为合理形式的字符串，以便用户理解eg（str）
&&&&&&&&&&&
repr，以合法的python表达式的形式来表示值，eg：repr（）
&&&&&&&&&&&
repr也可用`x`来表示(反引号)
&&& print"the
temperature is"+temp
Traceback (most recent call last):
"&pyshell#7&", line 1, in
&&& print"the
temperature is"+temp
TypeError: cannot concatenate 'str' and 'int' objects
&&& print"the
temperature is"+`temp`
the temperature is42
因为,不可以将字符串和数字进行相加,&
可以通过反引号将temp的值转换为字符串"42"了.
长字符串:要需要非常长的字符串,需要跨多行,可以使用三个引号代表普通引号.
print'''this is a very long string.
it continues here.
and it's not over yet.
"hello.world!"
still here.'''
也可以使用三个双引号，但是因为这种与众不同的引用方式，可以在字符差之中同时使用单引号和双引号，不需要反斜线进行转义
&普通字符串也可以跨行，如果一行之中最后一个字符是反斜线，那么，换行符本身就“转义“了，也就是被忽略了，eg：
print”hello.
这句会打印出hello.world!.同样适用于表达式 和语句:
'hello,world'
hello,world
原始字符串
其中的反斜线会转义，可以在字符串中加入通常情况下不能直接加入的内容，例如换行符可以写为n.并可放于字符串中
'hello.nworld'
但是如果出现路径的话.
path='c:nowherer'
&&& print path
因此可以使用双斜线:
print'c:\nowherer'
c:nowherer
对于长路径.为了避免麻烦,出现原始字符串
r'c:nowherer'
c:nowherer
原始字符串以r开头.看起来可以在原始字符串中放入任何字符,而这种说法基本是正确的,当然,我们也要像平常一样对引号进行转义,但是最后输出的字符串包含了转义所用的反斜线:
&&& print r'let's
不能在原始字符串结尾输入反斜线.,原始字符串最后的一个字符不能是反斜线,除非对反斜线进行转义.(用于转义的反斜线会也会成为字符串的一部分)如果最后一个字符(位于结束引号前的那个)是反斜线.python就不清楚是否应该结束字符串
&&& print r'c:program
filesfoobar''\'
c:program filesfoobar
& unicode字符串
字符串常量的最后一种类型就是unicode字符串,python中的普通字符串在内部是以8位ascii村春的,而unicode字符串则存储为16为unicode字符,这样就能表示更多的字符集了,包括世界上大多数语言的特殊字符,
u'hello,world!'
u'hello,world!'
可以看到,unicode字符串使用u前缀,就像原始字符串使用r一样
在python3.0中,所有字符串都是unicode
2,列表和元组
&&& edward=['edward
Gumby',42]
&&& john=['john
smith',50]
database=[edward,john]
&&& database
[['edward Gumby', 42], ['john smith', 50]]
greeting='hello'
&&& greeting[0]
&&& greeting[-1]
'january',
'february',
'september',
'october',
'novermber',
'december'
endings=['st','nd','rd']+17*['th']+['st','nd','rd']+7*['th']+['st']
year=raw_input('year:')
month=raw_input('month(1-12):')
day=raw_input('day(1-31):')
month_number=int(month)
day_number=int(day)
month_name=months[month_number-1]
ordinal=day+endings[day_number-1]
print month_name+' '+ordinal+','+year
raw_input(pleas"enter)
month(1-12):8
day(1-31):16
2.2.2 分片
href="http:www.python.org"&python web
'http:www.python.org'
tag[32:-4]
'python web site'
第一个索引的元素包含在分片内的,而第二个则不包含在分片内,即向做靠原则
numbers=[1,2,3,4,5,6,7,8,9,10]
numbers[3:6]
numbers[0:1]
numbers[7:10]
numbers[-3:-1]
numbers[-3:0]
numbers[-3:]
numbers[:3]
numbers[;]
[1,2,3,4,5,6,7,8,9,10]
url=raw_input('please enter the url:')
domain=url[11:-4]
print"domain name:"+domain
please enter the url:http://www.python.org
domain name:pyhton
更大的步长：
numbers[0:10:1]
[1,2,3,4,5,6,7,8,9,10]
numbers[0:10:2]
[1,3,5,7,9]
numbers[3:6:3]
numbers[::4]
numbers[8:3:-1]
[9,8,7,6,5]
numbers[10:0:-2]
[10,8,6,4,2]
numbers[0:10:-2]
numbers[::-2]
[10,8,6,4,2]
numbers[5::-2]
numbers[:5:-2]
序列相加：
&&&&[1,2,3]+[4,5,6]
[1,2,3,4,5,6]
&&&'hello,'+'world!'
'hello,world!'
&&&[1,2,3]+'world!'
算不出来，要相同类型
&&&'python'*5
'pythonpythonpythonpythonpython'
&&&[42]*10
[42,42,42,42,42,42,42,42,42,42]
&&&sequence=[none]*10
&&&sequence
[none,none,none,none,none,none,none,none,none,none]
序列字符串 乘法在居中的"盒子"内打印一个句子
此为以正确的宽度
//代码可能看起来很复杂，但只是用基本的算法，计算出有多少空格，破折号等字符，然后将他们放置到合适位置
//定义sentence的输入
//定义宽度，为80，
//使用len函得到sentence的元素数量
//定义box 的宽度比文字宽6
//定义left为80-box的宽度.除以2
//len函数返回序列中所包含元素的数量,min函数和max函数则分别返回序列中最大和最小的元素
sentence = raw_input("sentence: ")
screen_width = 80
text_width = len(sentence)
box_width = text_width + 4
left_margin = (screen_width - box_width) // 2
print ' ' * left_margin + '+'& + '-' *
(box_width-2) +& '+'
print ' ' * left_margin + '| ' + ' ' *
text_width&&& +
print ' ' * left_margin + '| '
sentence&&&&&
print ' ' * left_margin + '| ' + ' ' *
text_width&&& +
print ' ' * left_margin + '+'& + '-' *
(box_width-2) +& '+'
sentence:he's a very naughty boy!
成员资格；检查这个值是否在序列中；
&&&permissions =
permissipns
permissions
&&&users =
['mlh','foo','bar']
&&&raw_input('enter
your user name :')in users
enter your user name:mlh
&&&subject='$$$ get
rich now!!!$$$'
&&&'$$$' in
这玩意可以作为垃圾邮件过滤器的一部分，检查某段邮件中是否含有这个字段，也可用于某些安全策略的检查
检查用户名和pin码
databse = [
['albert',& '1234'],
&&& ['dilbert',
['smith',&& '7524'],
['jones',&& '9843']
username = raw_input ('User name:')
pin=raw_input('PIN code: ')
if[username,pin] in database:print 'access granted'
这里是max函数和min函数与len函数的区别
&&&numbers=[100,34,678]
&&&len(numbers)
&&&max(numbers)
&&&min(numbers)
&&&max(2,3)
&&&min(9,3,2,5)
&&&list('hello')
['h','e','l','l','o']
将一个由字符组成的列表传唤为字符串
又见不懂，
''.join(somelist)
&&&x=[1,1,1]
删除元素:使用del语句
&&&names=['alice','beth','cecil','dee-dee','earl']
&&&del names[2]
['alice', 'beth', 'dee-dee', 'earl']
&&& name =
list('perl')
['p', 'e', 'r', 'l']
name[2:]=list('ar')
['p', 'e', 'a', 'r']
name=list('perl')
name[1:]=list('ython')
['p', 'y', 't', 'h', 'o', 'n']
numbers=[1,5]
numbers[1:1]=[2,3,4]
&&& numbers
[1, 2, 3, 4, 5]
&&& numbers
[1, 2, 3, 4, 5]
numbers[1:4]=[]
&&& numbers
此结果与del numbers[1:4]相同
append 函数,用于在列表末尾追加新的对象
&&&lst=[1,2,3]
&&&lst.append(4)
count函数,统计某个元素在列表中出现的次数
['to','be','or','not','to','be'].count('to')
x=[[1,2],1,1,[2,1,[1,2]]]
&&& x.count(1)
x.count([1,2])
extend 函数,可以在列表的末尾一次性追加另一个序列中的多个值,可以用新列表扩展原有的列表
&&& a=[1,2,3]
&&& b=[4,5,6]
&&& a.extend(b)
[1, 2, 3, 4, 5, 6]
&&& a=[1,2,3]
&&& b=[4,5,6]
&&& a[len(a):]=b
[1, 2, 3, 4, 5, 6]
index函数，用于从列表中找出某个值第一个匹配项的索引位置：
[1, 2, 3, 4, 5, 6]
knights=['we','are','the','knights','who','say','ni']
knights.index('who')
&&& knights[4]
insert 函数 ，用于将对象插入到列表中：
numbers=[1,2,3,4,5,6,7]
numbers.insert(3,'four')
&&& numbers
[1, 2, 3, 'four', 4, 5, 6, 7]
同样可利用分片赋值实现，可读性不如insert
numbers=[1,2,3,4,5,6,7]
numbers[3:3]=['four']
&&& numbers
[1, 2, 3, 'four', 4, 5, 6, 7]
pop，会移除列表中个的一个元素（默认是最后一个），并且返回该元素的值
&&& x=[1,2,3]
&&& x.pop()
&&& x.pop(0)
lifo 后进先出&
入栈push&& 出栈pop
&&& x=[1,2,3]
x.append(x.pop())
remove 用于移除列表中某个值的第一个匹配项
x=['to','be','or','not','to','be']
x.remove('be')
['to', 'or', 'not', 'to', 'be']
reverse 函数，将列表中元素反向存放
&&& x=[1,2,3]
&&& x.reverse()
&&& x=[1,2,3]
list(reversed(x))
sort函数，用于在原位置对列表进行排序，在原位置排序意味着改变原来的列表，从而让其中的元素能按一定的顺序排列，而不是简单的返回一个已经排序的列表副本
修改了x却反悔了空值，那么最后得到的是已经排序的x以及值为none的y，实现这个功能的正确的方式是，首先把x的副本赋值给y，然后对y进行排序
x=[4,6,2,1,7,9]
&&& y=x[:]
&&& y.sort()
[4, 6, 2, 1, 7, 9]
[1, 2, 4, 6, 7, 9]
sorted('python')
['h', 'n', 'o', 'p', 't', 'y']
sorted('Python')
['P', 'h', 'n', 'o', 't', 'y']
，x&y返回负数，x&y大于负数，x=y时0
&&& cmp(42,32)
&&& cmp(99,100)
&&& cmp(10,10)
numbers=[5,2,9,7]
numbers.sort(cmp)
&&& numbers
[2, 5, 7, 9]
类似以cmp 的key用法，关键字，按照元素多少排序
x=['aardvark','abalone','acme','add','aerate']
x.sort(key=len)
['add', 'acme', 'aerate', 'abalone', 'aardvark']
元祖：不可变序列，元组可以在映射中当做键使用，而列表则不行。元组作为很多内建函数和方法的返回值存在，也就是说你必须的元组进行处理，只要不尝试修改元组，那么。处理元组在绝大多数情况下把他们当做列表进行操作，一般说，列表可能更能满足对序列的所有需求，除非需要使用一些元组没有的方法，例如index和count
用了逗号，就是元祖
&&& {1,2,3}
set([1, 2, 3])
&&& 3*(40+2)
&&& 3*(40+2,)
(42, 42, 42)
tuple函数，他并不是一个函数，只是一种类型，
tuple功能与list函数相同，以一个序列作为参数并把它转换为元组。
tuple([1,2,3])
&&& tuple('abc')
('a', 'b', 'c')
tuple((1,2,3))
基本元组操作，
&&& x=1,2,3
&&& x[0:2]
序列：序列是一种数据结构，他包含的元素都进行了编号，典型的序列包括列表，字符串和元组，其中，列表时可变的，而元组和字符串是不可变的，通过分片操作可以访问的序列的一部分，其中分片需要两个索引号来指出分片的七尺和结束为止，要想改变列表，则要对相应的位置进行赋值，或者使用赋值语句重写整个分片
成员资格，in操作符可以检查一个值是否存在于序列，对字符串使用in操作符是一个特列，他可以查找子字符串
方法，一些内建类型，例如列表和字符串，元组则不在其中，具有很多有用的方法，这些防范有些像函数，不过他们于特定值联系的更密切，方法是面向对象编程的一个必要的概念
cmp（x，y）& 比较两个值
len（seq）&&&
返回序列的长度
list（seq）& 把序列转换为列表
max（args）& 返回序列或者参数集合中的最大值
min（args）& 返回序列或者参数集合中的最小值
reversed（seq）& 对序列进行反向迭代
sorted（seq）&&
返回已排序的包含seq所有元素的列表
tuple（seq）&& 把序列转换为元组
字符串格式化
%可以用作求余操作符
format="hello,%s,%s enough for ya?"
values=('world','hot')
format%values
hello,world,hot enough for ya?
格式化字符串的%s部分称为转换说明符,他们标记了需要插入转换值的位置,s表示值会被格式化为字符串,如果不是字符串,则会用str将其转换为字符串,这个方法对大多数值都有效.
如果要在格式化字符串里面包括百分号,那么必须使用%%,这样python就不会将百分号认为是转换说明符
如果要格式化浮点数,可以使用f说明浮点数类型,同时提供所需要的精度,一个据点再加上希望保留的小数位数,因为格式化说明符总是以表示类型的字符结束,所以精度应该放在类型符前面
&&& format="Pi with
three decimals:%.3f"
&&& from math import
&&& print format %
Pi with three decimals:3.142
模板字符串:
string模块提供另外一种格式化值的方法,模板字符串,她的工作方式类似于很多UNIXxshell里的变量替换,substitute这个模板方法会用传递进来的关键字参数foo替换字符串中的$foo
&&& from string import
&&& s = Template
('$x.glorious $x!')
s.substitute(x='slurm')
'slurm.glorious slurm!'
如果替换字段是单词的一部分，那么参数名就必须用括号括起来，从而准确指明结尾:
&&& s=Template("it's
${x}tastic!")
s.substitute(x='slurm')
"it's slurmtastic!"
可以使用$$插入美元符号
&&& s=Template("make
$$ selling $x!")
s.substitute(x='slurm')
'make $ selling slurm!'
除了关键字参数之外，还可以使用字典变量提供值/名称对
&&& s=Template('A
$ting must never $action.')
d['ting']='gentleman'
&&& d['action']='show
his cocks'
s.substitute(d)
'A gentleman must never show his cocks.'
方法safe_substitute不会缺少值或者不正确使用$字符而出错
这一切都是格式问题
字符串格式化:完整版
&&& '%s plus %s equals
%s' %(1,1,2)
'1 plus 1 equals 2'
1，%字符：标记转换说明符的开始
2，转换标志 ：-表示左对齐；+表示在转换值之前要加上正负号；“”空白字符，表示正数之前保留空格，0表示转换至若位数
不够则用0填充
3，最小字段宽度，转换后的字符串至少应该具有该值定的宽度。如果是*，则宽度会从值元组中读出
4，点（.）后跟精度值：如果转换的是实数，精度值就表示出现小数点后的位数，如果转换的是字符串，那么该数字就表示最大字段宽度。如果是*，那么精度将会从元组中读出
&带符号的十进制正数
&不带符号的八进制
&不带符号的十进制
&不带符号的十六进制
&不带符号的十六进制
&科学计数法表示的浮点数
&科学计数法表示的浮点数
&十进制浮点数
&如果指数大于-4或者小于精度值则和e相同，其她情况与f相同
&如果指数大于-4或者小于精度值则和E相同。其他情况则与F相同
&单字符，接受正数或者单字符字符串
&字符串，使用repr转换任意pythobn对象
&字符串，使用str转换任意python对象
&&& 'price of eggs
:$%d' % 42
'price of eggs :$42'
&&& 'hexadecimal price
of eggs: %x' % 42
'hexadecimal price of eggs: 2a'
&&& from math import
'pi: 3.141593...'
&&& 'very inexact
estimate of pi:%i'%pi
'very inexact estimate of pi:3'
&&& 'using str
'using str :42'
&&& 'using repr
'using repr :42L'
字符宽度和精度
转换说明符可以包括字段宽度和精度，字段宽度是转换后的值保留的最小字符个数，精度则是结果中应该包含的小数位数，或者是转换后的值所能包含的最大字符个数
这两个参数都是正数，通过点好（.）分割，虽然都是可选的参数，但如果只给出精度，就必须包含点数
'f'%pi&& #字段宽10
'& 3.141593'
'.2f'%pi&& #字段宽为10，精度为2
'%.2f'%pi&&&
&&& '%.5s'% ' Guido
van Rossum'
可以使用*作为字段宽度或者精度，此时数值会从元组参数中读出：
&&& '%.*s'%(5,'guido
van rossum')
符号,对齐,和0填充
在字段宽度和精度值之前还可以放置"标志",该标表可以是零,加号.减号,或空格.
零表示数字将会用0进行填充
&&& '0.2f'%pi
注意,在010中开头的那个0并不意味着字段宽度说明符为八进制数,它只是个普通的python数值.当使用010作为字段宽度说明符的时候,表示字段宽度为10，并且用0进行填充空位,而不是说字段宽度为8;
减号(-)用来左对齐数值:
&&& from math import
&&& '%-10.2f'%pi
在数字的右侧多出了额外的空格
而空白("")意味着在正数前加上空格.这在需要对齐正负数时会很有用:
(']')+'n'+(']'%-10)
不懂 ,为什么在末尾加了F就错误
加号(+),它表示不管是正数还是负数都标示出符号(同样是在对其时很有用)
print('%+5d')+'n'+('%+5d'%-10)
以下代码将使用星号字段宽度说明符来格式化一张包含水果价格的表格,表格的总宽度由用户输入,因为是由用户提供信息,所以就不能在转换说明符中将字段宽度硬编码,使用星号运算符就可以从转换元祖中读出字段宽度
#读取用户想要的总宽度
width=input('please enter wdth:')
#定义width为10
price_width =10
#定义价格宽度
item_width=width-price_width
#关键,用来算空格保持对其的
header_format ='%-*s%*s'
format& =&&
'%-*s%*.2f'
#第一行==========================
print'='*width
#总宽度+item+空格宽度+price
print header_format %(item_width,'item',price_width,'price')
#一行----------------
print '-'*width
#总宽度+显示+空格宽度+价格
print format % (item_width,'apples',price_width,0.4)
print format % (item_width,'pears',price_width,0.5)
print format % (item_width,'cantaloupes',price_width,1.92)
print format % (item_width,'dried apriconts(16
oz.)',price_width,8)
print format % (item_width,'prunes(4 lbs.)',price_width,12)
print'='*width
raw_input("press&enter&")
3.4字符串方法
字符串方法完全来源于string模块,但是这个模块还包括一些不能作为字符串方法使用的常量和函数,maketrans函数就是其中之一,后面会将它和translate方法一起介绍,下面是一些有用的字符串常量
string.digits:包含数字0～9的字符串
string.letters:包含所有字母(大写或小写)的字符串
string.lowercase:包含所有小写字母的字符串
string.printable:包含所有可打印字符的字符串
string.punctuation:包含所有标点的字符串
string.uppercase:包含所有大写字母的字符串
字母字符串常量与地区有关,(也就是说,其具体值取决于python所配置的语言)如果可以确定自己使用的是ASCII,那么可以在变量中使用ascii前缀,例如string.ascii_letters.
3.4.1 find
find方法可以再一拐较长的字符串中查找子字符串,它返回子串所在位置的最左端索引,如果没有找到则返回-1
&&& 'with a moo-moo
here,and a moo-moo there'.find('moo')
&&& title="monty
python's flying circus"
title.find('monty')
title.find('python')
title.find('flying')
title.find('zirquss')
注意:在python 3.0
中,string.letters和祥光内容都会被移除,如果需要则应该使用string.ascii_letters常量代替.
在subject 中使用了'$$$'表达式建立了一个垃圾邮件过滤器,也可以使用find方法中(python
2.3以前的版本中也可用,但是in操作符只能用来查找字符串中的单个字符):
&&& subject ='$$$ get
rich now!!! $$$'
subject.find('$$$')
&&& subject='$$$ get
rich now!!!$$$'
subject.find('$$$')
subject.find('$$$',1)
subject.find('!!!')
subject.find('!!!',0,16)
注意,由起始和终止值指定的范围(第二和第三个参数)包含第一个索引,但不包含第二个索引.不懂
3.4.2 join
join方法是非常重要的字符串方法.它是split方法的逆方法,用来在队列中添加元素:
seq=[1,2,3,4,5]
&&& sep='+'
sep.join(seq)
Traceback (most recent call last):
"&pyshell#14&", line 1, in
sep.join(seq)
TypeError: sequence item 0: expected string, int found
seq=['1','2','3','4','5']
sep.join(seq)
'1+2+3+4+5'
dirs='','usr','bin','env'
'/'.join(dirs)
'/usr/bin/env'
print'c:'+'\'.join(dirs)
c:usrbinenv
需要添加的队列元素必须都是字符串,注意最后两个例子中使用了目录的列表,而在格式化的时候,根据unix和dos/windows的约定,使用了不同的分隔符号
3.4.3 lower
lower方法返回字符串的小写字母版
&&& 'Trondheim Hammer
Dance'.lower()
'trondheim hammer dance'
如果想要编写'不区分大小写'的代码的话,那么这个方法就派上用场了,代码会忽略大小写状态,例如,如果想在列表中查找一个用户名是否存在:列表半酣字符串'Gumby',而用户输入的'gumby'就找不到了:
&&& if 'gumby' in
['gumby','smith','jones']:print 'Found it'
&&& if 'Gumby' in
['gumby','smith','jones']:print 'Found it'
解决方法就是在存储和搜索时把所有名字都转换为小写,
&&& name='gumby'
names=['gumby','smith','jones']
&&& if name.lower()in
names:print 'Found it!'
和lower方法相关的是title方法,他会将字符串转换为标题,也就是所有单词的首字母大写,而其他字母小写,但是他使用的单词划分方法可能会得到并不自然的结果:
&&& "that';
folks".title()
"That'S A;; Folks"
另外一个string模块的capwords函数:
&&& import
string.capwords("that's all,folks")
"That's All,folks"
当然,如果要得到正确首字母大写的标题,(这要根据你的风格而定,可能要小些冠词,连词和5个字母以下的介词等),那么还是得自己把握.
3.4.4,replace
replace方法返回某字符串的所有匹配项均被替换之后得到字符串,就是文本文档中的"查找并替换"
&&& 'this is a
test'.replace('is','eez')
'theez eez a test'
3.4.5 split
这是一个非常重要的字符串方法,它是join的逆方法,用来将字符串分割成序列
'1+2+3+4+5'.split('+')
['1', '2', '3', '4', '5']
'/usr/bin/env'.split('/')
['', 'usr', 'bin', 'env']
&&& 'Using the
default'.split()
['Using', 'the', 'default']
注意,如果不提供任何分隔符,程序会把所有空格作为分隔符(空格,制表,换行等)
3.4.6strip
strip方法返回去除两侧(不包括内部)空格的字符串:
'&&&&&&&&&&
internal whiterspace is
kept&&&&&&&&&&
'internal whiterspace is kept'
它和lower方法一起使用话就可以很方便的对比输入的和存储的值,让我们回到lower部份中的用户名和例子,假设用户在输入名字式无意中在名字后面加上了空格
names=['gumby','smith','jones']
name='gumby& '
&&& if name in
names:print'Found it!'
也可以指定需要去除的字符,将他们列为参数即可
SPAM*for*everyone!!!***'.strip('*!')
' SPAM*for*everyone'
这个方法智慧去除两侧的字符,所以字符串中的星号没有被去掉
3.4.7 translate
translate方法和replace方法一样,可以替换字符串中的某些部分,但是和前者不同的是,translate方法只处理单个字符,它的优势在于同时进行多个替换,有些时候比replace效率高的多.
使用这个方法的方式有很多(比如替换换行符或者其他因平台而异的特殊字符).但是,假设需要将纯正的英文文本转换为带有德国口音的版本,为此,需要把字符c替换为k,把s替换为z
在使用translate转换之前,需要先完成一张转换表,转换表中是以某字符替换某字符的对应关系,因为这个表,事实上是字符串有多达256个项目,我们还是不要自己写了,使用string模块里面的maketrans函数就行
maketrans函数接受两个参数:两个等长的字符串,表示第一个字符串中每个字符都用第二个字符串中相同位置的字符替换.
&&& from string import
=maketrans('cs','kz')
&&& len(table)
table[97:123]
'abkdefghijklmnopqrztuvwxyz'
maketrans('','')[97:123]
'abcdefghijklmnopqrstuvwxyz'
这已经把小写字母部分的表提取出来了,字母c和s分别被替换为k和z
创建这个表以后,可以将它用作translate方法的参数,进行字符串的转换如下:
&&& 'this is an
incredible test'.translate(table)
'thiz iz an inkredible tezt'
translate的第二个参数是可选的,这个参数是用来指定需要删除的字符,例如,如果想要模拟一句语速超快的德国语,可以删除所有空格:
&&& 'this is an
incredible test'.translate(table,' ')
'thizizaninkredibletezt'
非英语字符串的问题
&有些时候类俗语lower这样的字符串方法并不能如我们所愿的进行工作,比如要使用一个非英语字母的字母表,假设我们想将大写挪威字母:B@LLEFR@转换为小写字母：
'B@LLEFR@'.lower()
可惜并未成功，因为python没有把@当做真正的字母，本例中，可以使用translate方法完成转换：
table=maketrans('a','b')
&&& word='c'
word.lower()
word.translate(table)
word.translate(table).lower()
接下来使用unicode
u"d".upper()
4，字典，当索引不好用时
加入有一个名字的列表如下
names=['Alice','Beth','Cecil','Dee-Dee','Earl']
numbers=['2341','9102','3158','0142','5551']
numbers[names.index('Cecil')]
names[numbers.index('9102')]
numbers[names.index('Dee-Dee')]
真正的效果：
phonebook['Cecil']
4.2 创建字典：
phonebook={‘Alice’：‘2341’，‘Beth’:'9102',‘Ceclo’:'3258'}
字典由多个键及与其对应的值构成对组成（我们也把键/值对称为项）。在上例中，名字是键，电话号码是值。每个键和它的值之间用冒号（：）隔开，项之间用逗号（，）隔开，而整个字典是由一对大括号起来。空字典（不包括任何项）由两个大括号组成，
像这样：{}
4.2.1 dict函数：
可以用dict函数，通过其他映射，或者（键，值）这样的序列对建立字典
{'age': 42, 'name': 'Gumby'}
items=[('name','Gumby'),('age',42)]
d=dict(items)
{'age': 42, 'name': 'Gumby'}
&&& d['name']
dict函数也可以通过关键字参数来创建字典，如下例所示：
d=dict(name='Gumby',age=42)
{'age': 42, 'name': 'Gumby'}
这是dict函数最有用的功能，但是还能隐射作为dict函数的参数，以建立其项与映射相同的字典（如果不带任何参数，则dict函数返回一个新的空字典，就像list，tuple以及str等函数一样）。如果另一个映射也是字典（毕竟这是唯一内建的映射类型），dict函数不是真正的函数，是个类型，就像list，tuple和str一样.
4.2.2 基本字典操作
字典的基本行为izai很多方面与序列（sequence）类似
len（d）返回d中项（键-值对）的数量；
d[k]返回关联到键k上的值
d[k]=v将值v关联到键k上.
del d[k]删除键位k的项
k in d检查d中是否有含有键位k的项
尽管字典和列表有很多特性相同,但也有下面一些重要的区别
键类型:字典的键不一定为整型数据(但也可能是),也可能是其他不可变类型.比如浮点型,字符串,或者元组
自动添加:及时那个键起初在字典中并不存在,也可以为它分配一个值,这样字典就会建立新的项,而(在不使用append方法或者其他类似操作的情况下)不能将值关联到列表范围之外的索引上.
成员资格:表达式k in d (d为字典)查找的是键,而不是值,表达式v in l
(l为列表)则用来查找值,而不是索引,这样看起来好想有些不太一致,但是当习惯以后就会感觉非常自然了,毕竟,如果字典含有指定的键,查找相应的值也就很容易了
第一点,键可以为任何不可变类型,是字典最强大的地方,2,看下面的区别.
x[42]='foobar'
Traceback (most recent call last):
"&pyshell#1&", line 1, in
x[42]='foobar'
IndexError: list assignment index out of range
x[42]='foobar'
{42: 'foobar'}
首先，程序试图将字符串‘foobar’关联到一个空列表42号位置上,这显然是不可能的,因为这个位置根本不存在,为了将其变为可能,我必须用[none]*43或者其他方法初始化x.而不能仅使用[],但是,下一个例子工作的很好,将'foobar'关联到空字典的键42上
电话本例子的代码:
#使用人名作为键的字典,每个人用另一个字典来表示,其键'phone'和'addr'分别表示他们的电话号码和地址.
&'Alice':{
&'phone':'2341',
&'addr':'foo drive 23'
&'phone':'9102',
&'addr':'Bar street 42'
&'Cecil':{
&'phone':'3158',
&'addr':'Baz avenue 90'
#针对电话号码和地址使用的描述性标签,会在打印输出的时候用到
&'phone':'phone number',
&'addr':'address'
name=raw_input('Name:')
#查找电话还是地址?使用正确的键:
request=raw_input('phone number(p) or address (a)?')
#使用正确的键：
if request =='p':key='phone'
if request =='a':key='addr'
#如果名字是字典中的有效键才打印信息：
if name in people:print"%s's %s is %s."%
(name,labels[key],people[name][key])
raw_input("press&enter&")
4.2.3字典的格式化字符串（p76）
使用字符串格式化功能来格式化元组中的所有值，如果使用字典而不是元组来做这个工作，在每个转换说明符中的%字符后面，可以加上（用圆括号括起来的）键，后面再跟上其他说明元素。
phonebook=dict(Beth='9102',Alice='2341',Cecil='3258')
&&& phonebook
{'Beth': '9102', 'Cecil': '3258', 'Alice': '2341'}
&&& "Cecil's phone
number is %(Cecil)s."% phonebook
"Cecil's phone number is 3258."
除了增加的字符串之外，转换说明符还是像以前一样工作，当以这种方式使用字典的时候，只要所有的给出的键都能在字典中找到，就可以获得任意数量的转换说明符，这类字符串格式化在模板系统中非常有用（本例中使用html）
template='''&html&
&head&&title&%(title)s&/title&&head&
&hl&%(title)s&/hl&
&p&%(text)s&/p&
&/body&'''
&&& data={'title':'my
home page','text':'welcome to my home page!'}
&&& print template %
&head&&title&my
page&/title&&head&
&hl&my home
&p&welcome to my home
4.2.4字典方法
&1，clear方法，清除字典中的所有项，这是个原地操作（类似于list.sort）所以无返回值（或者说返回none）
d['name']='Gumby'
&&& d['age']=42
{'age': 42, 'name': 'Gumby'}
returned_value=d.clear()
returned_value
为什么会有用呢，考虑下面两种情况:
x['key']='value'
{'key': 'value'}
{'key': 'value'}
x['key']='value'
{'key': 'value'}
&&& x.clear()
两种情况中，x和y最初对应同一个字典，情况1中，通过将x关联到一个新的空字典来“清空”它，这对y一点影响也没有，它还关联到原先的字典，这可能是所需要的行为，但是如果真的想清空原始字典中的所有的元素，必须使用clear方法，正如在情况2所看到的，y虽有也被清空了
2.copy copy方法返回一个具有相同键-值对的新字典，（这个方法实现的是浅复制，因为值本身就是相同的，而不是副本）
x={'username':'admin','machines':['foo','bar','baz']}
&&& y=x.copy()
y['username']='mlh'
y['machines'].remove('bar')
{'username': 'mlh', 'machines': ['foo', 'baz']}
{'username': 'admin', 'machines': ['foo', 'baz']}
当在副本中替换的时候，原始字典不受影响，但是，如果修改了某个值（原地修改，而不是替换），原始的字典也会改变，因为同样的值夜存储在院子点中。（就像上面例子中的“machines”列表一样）
避免这个问题的一种方法就是使用深复制，复制其包含的所有的值，可以使用copy模块的deepcopy函数来完成操作：
&&& from copy import
d['names']=['Alfred','Bertrand']
{'names': ['Alfred', 'Bertrand']}
&&& c=d.copy()
{'names': ['Alfred', 'Bertrand']}
dc=deepcopy(d)
d['names'].append('Clive')
{'names': ['Alfred', 'Bertrand', 'Clive']}
{'names': ['Alfred', 'Bertrand', 'Clive']}
{'names': ['Alfred', 'Bertrand']}
注意，引入deepcopy后，原先的copy变为实时的.而使用deepcopy的值是固定的.原先的copy并不是实时的
3.fromkeys这个方法使用给定的键建立新的字典,每个键默认对应的值为none
{}.fromkeys(['name','age'])
{'age': None, 'name': None}
这个例子中首先构造
了一个空字典,然后调用它的fromkeys方法,建立另外一个词典,有些多余,也可以直接在所有字典的类型dict上面调用方法
dict.fromkeys(['name','age'])
{'age': None, 'name': None}
如果不使用none作为默认值,也可以自己提供默认值
dict.fromkeys(['name','age'],'(unknown)')
{'age': '(unknown)', 'name': '(unknown)'}
get方法是个更宽松的访问字典项的方法,一般来说,如果试图访问字典中不存在的项会出错,但使用get就不会
&&& print d
Traceback (most recent call last):
"&pyshell#12&", line 1, in
&&& print d
KeyError: 'name'
d.get('name')
另外可以自定义none的值
d.get('name','N/A')
如果键存在,get用起来就像普通的字典查询一样
d['name']='Eric'
d.get('name')
这是一个代码清单程序的修改版本,它使用get方法访问'数据库'实体(不懂,还未完全理解)
#使用get（）的简单数据库
&'Alice':{
&'phone':'2341',
&'addr':'foo drive 23'
&'phone':'9102',
&'addr':'Bar street 42'
&'Cecil':{
&'phone':'3158',
&'addr':'Baz avenue 90'
&'phone':'phone number',
&'addr':'address'
name=raw_input('name:')
request=raw_input('phone number(p) or address (a)?')
key = request
if request=='p':key='phone'
if request=='a':key='addr'
#使用get（）提供默认值
person=people.get(name,{})
label=labels.get(key,key)
result=person.get(key,'not available')
print"%s's %s is %s."%(name,label,result)
raw_input ()
5 .has_key
has_key方法可以检查字典中是否含有给出的键,表达式d.has_key(k)相当于表达式k in
d.使用哪个方式很大程度上取决于个人的喜好,python3.0中不包括这个函数
d.has_key('name')
d['name']='Eric'
d.has_key('name')
6.items和iteritems
items方法将所有的子典项以列表方式,这些列表项中的每一项都来自与(键,值).但是项在返回时并没有特殊的顺序
d={'title':'pythong web
site','ur':'http//www.python.org','spam':0}
&&& d.items()
[('spam', 0), ('ur', 'http//www.python.org'), ('title', 'pythong
web site')]
iteritems方法的作用大致相同,但是会返回一个迭代器对象而不是列表
it=d.iteritems()
&dictionary-itemiterator object at
&&& list(it)
[('spam', 0), ('ur', 'http//www.python.org'), ('title', 'pythong
web site')]
7.keys和iterkeys
keys方法将字典中的键以列表形式返回,而iterkeys则返回针对键的迭代器
pop方法用来获得对应于给定键的值,然后将这个键-值对从字典中移除
d={'x':1,'y':2}
&&& d.pop('x')
此方法类似于list.pop,后者会弹出列表的最后一个元素,但不同的是,popitem弹出随机的项,因为字典并没有'最后的元素'或者其他有关顺序的概念,若想一个接一个地移除并处理项,这个方法就非常有效了(因为不用首先获取键的列表).
d=dict(url='http//www.python.org',spam=0,title='python web
{'url': 'http//www.python.org', 'title': 'python web site', 'spam':
&&& d.popitem()
('url', 'http//www.python.org')
{'title': 'python web site', 'spam': 0}
尽管popitem和列表的pop方法很类似,但字典中没有与append等价的方法,因为字典是无序的,类似于append的方法无任何意义
10.setdefault
setdefault方法在某种程度上类似于get方法,就是能够获得与给定键相关联的值,除此之外,setdefault还能在字典中不含有给定键的情况下设定相应的键值
d.setdefault('name','N/A')
{'name': 'N/A'}
d['name']='Gumby'
d.setdefault('name','N/A')
{'name': 'Gumby'}
可以看到,当键不存在的时候,setdefault返回默认值并且对应地更新字典,如果键存在,那么就返回与其对应的值,但不改变字典,默认值是可选的,这点和get一样,如果不设定,会默认的使用none
d.setdefault('name')
{'name': None}
update方法可以利用一个字典项更新另外一个字典:&&&
&'title':'python web site',
&'url':'http://www.python.org',
&'changed':'mar 14 22:09:15 met 2008'
&&& x={'title':'python
language website'}
&&& d.update(x)
{'url': 'http://www.python.org', 'changed': 'mar 14 22:09:15 met
2008', 'title': 'python language website'}
提供的字典中的项会被添加到旧的字典中,若有相同的键则会进行覆盖.
update方法可以使用与调用dict函数,或者(类型构造函数)同样的方式进行调用,这点在本章前面已经讨论,这就意味着update可以喝映射.拥有(键,值)对的队列(或者其他可迭代的对象爱那个)以及关键字参数一起调用.
12.values和iterbalues
values方法以列表的形式返回字典中的值(itervalues返回值的迭代器).与返回键的列表不同的是,返回值的列表中可以包含重复的元素
&&& d[1]=1
&&& d[2]=2
&&& d[3]=3
&&& d[4]=1
&&& d.values()
[1, 2, 3, 1]
5.条件,循环和其他语句
5.1.1使用逗号输出
print'age:42'
print'age:',42
注意,printer的参数并不能像我们预期那样构成一个元组,在3.0中,print不再是语句,而是函数,但功能不变
&&& print 1,2,3
&&& print(1, 2,
如果想要同时输出文本和变量值,却又不希望使用字符串格式化的话,那这个特性就非常有用了:
&&& name='gumby'
greeting='hello,'
salutation='mr,'
greeting,salutation,name
hello, mr, gumby
注意,如果greeting字符串不带逗号,那么结果中怎么才能得到逗号呢,想下面这样做是不行的
greeting,','salutation,name
SyntaxError: invalid syntax
因为上面的语句会在逗号前加入空格,下面是一种解决方案:
greeting+',',salutation,name
hello,, mr, gumby
如果在结尾处加上逗号,那么接下来的语句会与前一条语句在同一行打印:
print'hello,',
print'world!'
输出,hello,world!.
5.1.2把某件事作为另一件事导入
从模块导入函数的时候,可以使用
import somemodule
from somemodule import somefunction
from somemodule import
somefunction,anotherfunction,yetanotherfunction
from somemodule import *
只有确定自己想要从给定的模块导入所有功能时,才应该使用最后一个版本,但是如果两个模块都有open函数怎么办?之需要使用个第一种方式导入,然后像下面这样使用函数:
module1.open(...)
module2.0open(...)
但还有另外的选择,可以再语句末尾增加一个as子句,在该子句厚给出名字,或为整个模块提供别名:
&&& import math as
foobar.sqrt(4)
也可以为函数提供别名:
&&& from math import
sqrt as foobar
&&& foobar(4)
对于open函数,可以像下面这样使用:
from module1 import open as open1
from module2 import open as open2
注意:这只在脚本中起作用,而在交互式python会话中则没有效果,在交互式胡话中,所有语句都会被单独执行,(并且会打印出内容),有些模块,例如os.path是分层次安排的(一个模块在另一个模块的内部)
5.2赋值魔法
5.2.1序列解包
多个赋值操作可以同时进行:
&&& x,y,z=1,2,3
&&& print x,y,z
可以交换两个(或更多个)变量
&&& x,y=y,x
&&& print x,y,z
这个叫做序列解包,或可选代解包,将多个值的序列解开,然后放到变量的序列中,更形象一点的表示出来就是:
&&& values=1,2,3
&&& values
&&& x,y,z=values
当函数或者方法返回元组时,这个特性尤其有用,假设需要获取字典中任意的键-值对,可以使用popitem方法,这个方法将键-值作为元组返回,那么个这个元组就可以直接赋值到两个变量中
scoundrel={'name':'robin','grilfriend':'marion'}
key,value=scoundrel.popitem()
'grilfriend'
它允许函数返回一个以上的值并且打包成元组,然后通过一个赋值语句很容易进行访问,所解包的序列中的元素数量必须和放置在赋值符号=左边的变量数量完全一致,否则python会在赋值时引发异常:
&&& x,y,z=1,2
Traceback (most recent call last):
"&pyshell#136&", line 1, in
ValueError: need more than 2 values to unpack
x,y,z=1,2,3,4
Traceback (most recent call last):
"&pyshell#137&", line 1, in
x,y,z=1,2,3,4
ValueError: too many values to unpack
注意:3.0中另外有一个解包的特性,可以像在函数的参数列表中一样使用星号运算符,例如a,b,rest*=[1,2,3,4]最终会在a和b都被赋值之后将所有其他的参数都收集到rest中,本例中,rest的结果将会是[3,4]
,使用星号的变量也可以放在第一个位置,这样他就会总会包含一个列表,右侧的赋值语句可以使可迭代对象.
5.2.2链式赋值(不懂,无法执行?)
是将同一个值赋给多个变量的捷径,他看起来有些像桑杰中的并行赋值,不过这里只处理一个值:
x=y=somefunction()
和下面语句效果是一样的:
y=somefunction()
注意上面的语句和下面的语句不一定等价:
x=somefunction()
y=somefunction()
5.2.3增量赋值
这里没有将赋值表达式写为x=x+1,而是将表达式运算符(本例中式土)放置在赋值运算符=的左边,写成x+=1.这种写法叫做增量赋值,对于*,/,%等标准运算符都适用:
对于其他数据类型也使用(只要二元运算符本身适用于这些数据类型即可)
&&& found='foo'
&&& found+='bar'
&&& found*=2
'foobarfoobar'
5.3语句块:缩排的乐趣
语句块并非一种语句,而是在掌握后面两节的内容之前应该了解的知识
语句块是在条件为真(条件语句)时执行多次(循环语句)的一组语句,在代码前防止空格来缩进语句即可创建语句块(使用tab字符也可以缩进语句块,python将一个tab字符解释为到下一个tab字符位置的移动.而一个tab字符位置为8个空格,但是标准且推荐的方式是只用空格,尤其是在每个缩进需要4个空格的时候)
块中的每行都应该缩进同样的量,下面的伪代码(并非真正的python代码)展示了缩进的工作方式:
this is a line
this is another line
&&& this is
another block
&&& continuing
the same block
&&& the last
line of this block
phew,there we escaaped the inner block
很多语言使用特殊单词或者字符,(比如begin或{})来表示一个语句块的开始,用另外的单词或者字符(比如end或者})表示语句块的结束,在python中,冒号(:)用来标识语句块的开始,块中的每一个语句都是缩进的(缩进量相同).当回退到和已经闭合的块一样的缩进量时,就表示当前块已经结束了(很多程序编辑器)和ide都知道如何缩进语句块,可以帮助用户轻松把握缩进)
5.4条件和条件语句
5.4.1 布尔变量
真值:也叫布尔值
下面的值在座位布尔表达式的时候,会被解释器其看做假
false none 0 "" () [] {}
换句话说,也就是标准值false和none
.所有类型的数字0(包括浮点型,长整型和其他类型),空序列(比如空字符串,元组,和列表)以及空的字典都为假其他的一切都被解释为真,包裹特殊值true
"标准的"的真值为true和false.在一些语言中,例如c和python2.3以前的版本.标准的真值为0(表示假)和1(表示真).事实上,true和false只不过是1和0的一种华丽的说法而已,看起来不同,作用相同
&&& True==1
&&& False ==0
True+False+42
如果。某个逻辑表达式返回1或0.那么它实际的意思是返回True或False
布尔值True和False属于布尔类型,bool函数可以用来(和list,str以及tuple一样)转换其他值.
&&& bool('t
think,therefore i am')
&&& bool(42)
&&& bool('')
&&& bool(0)
因为所有值都可以用作布尔值,所以几乎不需要对他们进行显示转换(可以说python会自动转换这些值)
尽管[]和""都是假值(也即是说bool([])==bool("")==Fales),他们本身却并不相等(也就是说[!=""]).对于其他不同类型的假值对象也是如此(例如()!=Flase)
5.4.2条件执行和if语句
真值可以联合使用.(为何要加空格)
name=raw_input('what is your name?')
if name.endswith('Gumby'):
&&& print 'Hello
,mr,Gumby'
raw_input()
这就是if语句，他可以实现条件执行，如果条件（在if和冒号之间的表达式）判定为真，后面的语句块就会被执行，如果为假。语句块就不会被执行
5.4.3else子句。之所以叫做子句，是因为他不是独立的语句，而只能作为if语句的一部分
name=raw_input('what is your name?')
if name.endswith('Gumby'):
&&& print 'Hello
,mr,Gumby'
‘hello，stranger’
raw_input()
5.4.4elif子句
如果需要检查多个条件。就可以使用elif，他是else的简写。也是if和else子句的联合使用。也就是具有条件的else子句
num=input('Enter a number:')
&&& print'the
number is positive'
elif num&0:
&&& print'the
number is negative'
&& print 'The number is
注意:可以使用int(raw_input(...))函数来代替input(...)
5.4.5嵌套代码块
name =raw_input('what is your name')
if name.endswith('gumby'):
name.startswith('Mr.'):
print 'hello,Mrs.Gumby'
name.startwith('Mrs,'):
print'hello.Mrs,gumby'
print 'Hello,gumby'
print'hello,stranger'
如果名字是以'Gumby'结尾的话,还要检查名字的开头.在第一个语句块中的单独的if语句中,注意这里是elif的使用,最后一个选项中(else子句)没有条件.如果其他的条件都不满足就使用最后一个,可以把任何一个else子句放在语句块歪,如果把里面的else子句放在外面的话,那么不以'Mr.'或者'Mrs.'开头(假设这个名字是'Gumby')的名字都被忽略掉了.如果不写最后一个else子句,那么陌生人就被忽略掉.
5.4.6更复杂的条件
1,比较运算符
x==y&&&&&&&&&&&&&&&&&
x&y&&&&&&&&&&&&&&&&&&
x&y&&&&&&&&&&&&&&&&&&
x&=y&&&&&&&&&&&&&&&&&
x大于等于y
x&=y&&&&&&&&&&&&&&&&&
x小于等于y
x！=y&&&&&&&&&&&&&&&&
y&&&&&&&&&&&&&&&
x和y是用一个对象
y&&&&&&&&&&&
x和y是不同的对象
y&&&&&&&&&&&&&&&
x是y容器（例如，序列）的成员
y&&&&&&&&&&&
x不是y容器（例如，序列）的成员
2.相等运算符
两个等号是相等，一个是赋值
3，is：同一性运算符
&&& x=y=[1,2,3]
&&& z=[1,2,3]
&&& x is y
&&& x is z
因为is运算符是判定同一性而不是相等性的,变量x和y都被绑定到同一个列表上,而变量z被绑定在另外一个具有相同数值和顺序的列表上.他们的值可能相等,但是却不是同一个对象
&&& x=[1,2,3]
&&& y=[2,4]
&&& x is not y
&&& del x[2]
&&& y[1]=1
&&& y.reverse()
&&& x is y
使用==运算符来判定两个对象是否相等.使用is判定两者是否等同(同一个对象)
4.in:成员资格运算符
他可以像其他比较运算符一样在条件语句中使用
name=raw_input('what is your name?')
if 's' in name:
&&& print 'your
name contains the letter "s".'
&&& print'your
name does not contain the letter"s".'
5.字符串和序列比较
字符串可以按照字母顺序排列进行比较
'alpha'&'beta'
如果字符串内包括大写字母,那么结果就会乱,字符是按照本身的顺序值排列的,一个字母的顺序值可以用ord函数查到.ord函数与chr函数功能相反,如果要忽略大小写字母的区别,可以使用字符串方法upper和lower
'FnOrD'.lower()=='Fnord'.lower()
其他的序列也可以用同样的方式来进行比较,不过比较的不是字符而是元素的其他类型.
[1,2]&[2,1]
如果一个序列中包括其他序列元素,比较规则也同样适用于序列元素
[2,[1,4]]&[2,[1,5]]
6,布尔运算符
有时想要检查一个一上的条件,例如,如果需要别写读取数字并且判断该数字是否位于1~10之间(包括10)的程序,可以这么做:
number=input('Enter a number between 1 and 10:')
if number&=10:
&&& if number
print'great!'
&print'Wrong!'
print'Wrong!'
下面是更简单的方法:
number=input('Enter a number between 1 and 10:')
if number&=10 and numb &=1:
print'great!'
print'Wrong!'
and运算符就是所谓的布尔运算符,他连接两个布尔值,并且在亮着都为真时返回真,否则返回假,与它同类的还有两个运算符,or和not,使用这个3个运算符就可以随意结合真值(下面不懂).
if((cash&price) or cutomer_has_good_credit) and not
out_of_stock:
give_goods()
a if b else c
如果b为真.返回a,否则,返回c.(注意,这个运算符不用引入临时变量,就可以直接使用,从而得到与raw_input粒子中同样的结果)
短路逻辑和条件表达式
&布尔运算符:只有在需要求值时才进行求值.举例就是,表达式x and y
需要两个变量都为真时才为真,所以如果x为假,表达式就会like返回false,而不管y的值,实际上,如果x为假,表达式会返回x的值,否则他就会返回y的值,这种行为被称为短路逻辑,或者惰性求值,布尔运算符通常被称为逻辑运算符,就像你看到的那样第2个值有时"被短路了",这种行为对于or来说也同样适用,在表达式x
or y中,x为真时,他直接返回x值,否则返回y值,助于,这意味着在布尔运算之后的所有代码都不会执行
&这主要避免了无用的执行代码,可以作为一种技巧适用,假设用户应该输入他的名字,但也可以选择什么都不输入,这时可以使用默认值'&unknow&'.可以使用if语句,但是可以很简洁的方式
name=raw_input('please enter your
name:')or'&unknow&'
换句话说,如果raw_input
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。