Python 基本语句 (5) 持续更新

前面几张大家都已经看到了 print语句、import语句、赋值语句。这次主要是深入的了解更多语句。

语句(1) print

用逗号输出

print ------ 无论是字符串还是其他类型都会自动转成字符串并输出，如果需要打印多个，只要用逗号隔开就可以了。

>>> print 'My name is ', 'Zhao'
My name is  Zhao

print 参数并不会构成元组，如果要变成元组，就需要用括号，括起来。

>>> print 1, 2, 3
1 2 3
>>> print (1,2,3)
(1, 2, 3)

如果 print 语句的末尾有逗号，那么接下来的 print 语句会在同一行打印。

print 'Hello',
print 'Python'

输出

Hello Python

语句(2) import

当想调用模块(module)函数(function)的时候，首先要先导入(import)一下。导入的方式有

import module
from module import function
from module import function,anotherfunction,yetfunction
from module import *

如果两个模块当中，都有一个同名的函数如 set 函数，那只要使用第一种方式导入，就可以了。如

import module
import anothermodule
module.set()
anothermodule.set()

还可以给模块起别名。如

import module as fish
fish.eat()

为函数起别名。如

from module import function as fishfun
fishfun()

对于那些同名的函数，那么就可以这样使用如

from module1 import function as function1
from module2 import function as function2

注意有一些模块是分层次安排的，（一个模块在另一个模块的内部）详细的内容，会在后面更新。

语句(3) 赋值

多个变量赋值称为序列解包或递归解包

>>> a, b, c = 1, 2, 3
>>> a,b,c
(1, 2, 3)

交换变量(或多个变量)

>>> a, b = 1, 2
>>> print a, b
1 2
>>> a, b = b, a
>>> print a, b
2 1

当函数或者方法返回元组、序列或可迭代对象时，都可以利用这个特性。

>>> words = {'one':1,'two':2,'three':3}
>>> k,v = words.popitem()
>>> k,v
('three', 3)

注意序列解包赋值时，左边的赋值变量必须与右边的元素数量相同，否则会引发赋值异常。

>>> a, b, c = 1,2
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: need more than 2 values to unpack

Python3.0 当中更新的赋值解包新特性：用 * 运算符，把多余的参数，以列表的形式保存变量中。

>>> a, b, *c = 1,2,3,4,5,6,7,8,9
>>> a,b,c
(1, 2, [3, 4, 5, 6, 7, 8, 9])

一个变量赋值给多变量 ------- 链式赋值

>>> a, b = 1,2
>>> a, b
(1, 2)

表达式运算符( +、-、/、*、| )放在赋值运算符左边(=) -------------- 增量赋值

首先下面的两个语句是相等的

a = a + 1
a += 1

其中第二个语句就是增量赋值，对于其他的类型也一样可以用。

str = 'hello'
str += ' word! '
print str
str *= 2
print str

输出

hello word!
hello word! hello word!

语句(4) 语句块

语句块是在条件语句和循环语句一组语句，它们需要用空格符或tab字符来缩进语句创建语句块。

用 : 表示当前语句块的开始，当回退语句块或闭合语句块缩进时，表示当前语句块结束。如

a = 1
if a == 1 :
    print 'A is equal to 1'
else
    print 'A is not equal to 1'

语句(5) 条件语句

布尔值

下面的值都会Python看作假 (false) :

False None  0 "" ()  [] {}

其他的都解释为真(true)。

换句话说 True 就是 1 ， False 就是 0 看一下代码

>>> "%d" % True
'1'
>>> "%d" % False
'0'
>>> True == 1
True
>>> False == 0
True
>>> a = True + 1
>>> a
2
>>> a = False + 1
>>> a
1

布尔值也有转换函数 bool，它可以把其他类型转换为布尔类型。

>>> bool(42)
True
>>> bool('')
False
>>> bool('1')
True

条件执行

name = raw_input("What is your name?");
if name.endswith('Zhao'):
    print 'Hello , Mr.Zhao'
else
    print 'Hello , stranger'

运行结果

C:\Users\ChengXu1\Desktop>python aa.py
What is your name?Zhao
Hello , Mr.Zhao

C:\Users\ChengXu1\Desktop>python aa.py
What is your name?Li
Hello , stranger

如果 if 条件为 true，那么就执行 if 后面的语句块，否则执行 else 语句块。如果检查多个条件，可以用elif。如

score = input("Plase input your score:")

if score >= 90:
    print 'excellent'
elif score >= 80:
    print 'passing'
else:
    print 'failed'

比较运算符总结

表达式	描述
x == y	x 等于 y
x < y	x 小于 y
x > y	x 大于 y
x >= y	x 大于等于 y
x <= y	x 小于等于 y
x != y	x 不等于 y
x is y	x 和 y 是否是同一个对象
x is not y	x 和有是否不是同一对象
x in y	x 是否是 y 的元素
x not in y	x 是否不是 y 的元素

如果你看见 x <> y 这样的表达式，它其实和 x != y 是一个意思。建议不要使用它。

同样比较运算符也是可以连接的

0 < score < 90

比较函数 cmp

cmp(x,y) x 是否大于 y 如果大于返回 1，小于返回 -1，等于返回0。

>>> cmp(20,10)
1
>>> cmp(10,20)
-1
>>> cmp(20,20)
0

布尔运算符 and、or 和 not

and 主要是连接两个布尔值，只有两个布尔值都为真，才返回真，否则返回假。

or 也是连接两个布尔值，他只要有一个布尔值为真，就返回真，否则返回假。

not 逻辑判断如果布尔值为True，那么返回False。如果为False，那么返回真。

短路逻辑

and 当第一个布尔值为false的时候，后面布尔值就不在判断了。

or 当第一个布尔值为true的时候，后面布尔也不判断了。

这种行为被称为短路逻辑。

示例

>>> a = raw_input('Input:') or 'unknown'
Input:
>>> a
'unknown'

注意这里在Window下面 raw_input 改成 input，按回车会报

SyntaxError: unexpected EOF while parsing 异常。

原因是Window换行是 \r\n ，Python多读了一个\r，解析不了了。

在Python中实现C语言中的三目运算符的效果

>>> a,b,c = 1,0,3
>>> d = a if b else c
>>> d
3

如果 b 为真，返回 a，否则返回 c。

语句(6) 断言 assert

断言是在编写代码前，检查一些必要条件，如果发现错误条件，那么直接让程序崩溃，检查代码。比如说一个人年龄，不可能为负数，如果为负

数，那就要检查代码了。如

>>> a = -10
>>> assert 0 < age
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AssertionError

使用断言可以更加稳定，品质好，且不易于出错的代码，是维护程序的好方法。

语句(7) 循环

while 条件为真，执行下面语句块，一直遇到假，停止。

x = 1
sum = 0
while x <= 100:
    sum += x
    x += 1
print sum

结果

有的时候，要求用户输入名字的时候

name = ""
while not name.strip() :
    name = raw_input('Plase input your name?')
print 'Hello ',name

结果

C:\Users\ChengXu1\Desktop>python aa.py
Plase input your name?
Plase input your name?Zhao
Hello  Zhao

当你输入的名字一直不正确的时候，程序就一直循环。

for

注意Python的for循环和其他语言如C语言，不一样，需要留意一下。

for循环的时候，它需要一个集合，如 (序列和可迭代的对象)。

languages = ['Python','C','Java','C++','C#']
for language in languages:
    print language

输出

C:\Users\ChengXu1\Desktop>python aa.py
Python
C
Java
C++
C#

还可以

numbers = [0,1,2,3,4,5,6]
for number in numbers:
    print number

输出

C:\Users\ChengXu1\Desktop>python aa.py
0
1
2
3
4
5
6

遍历字典键

d = {'a':1, 'b':2, 'c':3 }
for key in d:
    print key,d[key]

输出

C:\Users\ChengXu1\Desktop>python aa.py
a 1
c 3
b 2

遍历键，也可以用 d.keys 。遍历值，d.values 。遍历键 / 值用 d.items 。

d.items 将键、值作为元组返回。

d = {'a':1, 'b':2, 'c':3 }
for k,v in d.items():
    print k,v

输出

C:\Users\ChengXu1\Desktop>python aa.py
a 1
c 3
b 2

for 也支持序列解包。

range 返回列表的一个函数

range([start,] stop[, step]) start 与 stop 指定的范围，step指定步长。

>>> range(0,10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

那么我们计算从1到100的和，就可以这样写：

sum = 0
for num in range(1,101):
    sum += num
print sum

xrange 用法和 range 一样，区别返回的是一个生成器。

用xrange会比range性能优很多，因为不需要一上来就开辟一块很大的内存空间，xrange一次只创建一个数。

sum = 0
for num in xrange(1,101):
    sum += num
print sum

提示在Python3.0 中，range 会被转换成 xrange 函数。

并行迭代

name = ['zhao','li','zhang']
age = [20,17,16]
for i in range(len(name)):
    print name[i],age[i]

输出

C:\Users\ChengXu1\Desktop>python aa.py
zhao 20
li 17
zhang 16

还可以利用zip函数，实现并行迭代。

首先看一下 zip 函数，使用和返回的值。

>>> name = ['zhao','li','zhang']
>>> age = [20,17,16]
>>> zip(name,age)
[('zhao', 20), ('li', 17), ('zhang', 16)]

返回的是两个参数的序列，那么我们就可以直接遍历了。

name = ['zhao','li','zhang']
age = [20,17,16]
for n,a in zip(name,age):
    print n,a

zip函数还有一个重要的一点，可以处理不等长的序列，当最短的序列结束的时候，就会停止。

>>> zip(range(2),range(100))
[(0, 0), (1, 1)]

索引迭代

index = 0
languages = ['Python','C','Java','C++','C#']
for language in languages:
    if 'C' in language:
        languages[index] = 'D'
    index += 1
print languages

输出

C:\Users\ChengXu1\Desktop>python aa.py
['Python', 'D', 'Java', 'D', 'D']

我们可以用内建函数 enumerate 实现一样效果

languages = ['Python','C','Java','C++','C#']
for index,language in enumerate(languages):
    if 'C' in language:
        languages[index] = 'D'
print languages

enumerate 可以返回迭代索引和值。

翻转迭代

numbers = [1,2,3,4,5,6,7,8]
for num in reversed(numbers):
    print num

输出

C:\Users\ChengXu1\Desktop>python aa.py
8
7
6
5
4
3
2
1

排序迭代

numbers = [8,20,7,4,32,3,110]
for num in sorted(numbers):
    print num

输出

C:\Users\ChengXu1\Desktop>python aa.py
3
4
7
8
20
32
110

跳出循环 break continue

break 　　　　中断当前循环

from math import sqrt
for n in range(99,0,-1):
    root = sqrt(n)
    if root == int(root):
        print n
        break

输出

C:\Users\ChengXu1\Desktop>python aa.py
81

continue 　　进行下一轮迭代

for n in range(1,10):
    if (n % 2) == 0:
        print n

输出

C:\Users\ChengXu1\Desktop>python aa.py
2
4
6
8

While True Break 循环

while True:
    name = raw_input('Please input password?')
    if name.strip() and name == 'zhao' :
        print 'Welcome Mr.zhao'
        break
    else:
        print 'Wrong password'

输出

C:\Users\ChengXu1\Desktop>python aa.py
Please input password?ssf
Wrong password
Please input password?
Wrong password
Please input password?zhao
Welcome Mr.zhao

循环中的else子句

在循环内使用break语句时，一般是 "找到了" 某项，那么怎么判断有没有找到呢

isfind = False
numbers = [1,2,3,4]
for number in numbers:
    if number == 5:
        isfind = True;
        print number;
        break;
if not isfind:
    print "Did't find it"

还有一个更简单的方式

numbers = [1,2,3,4]
for number in numbers:
    if number == 5:
        print number;
        break;
else:
    print "Did't find it"

for…else 和 while…else，都可以支持循环else子句。

语句(8) 列表推导式

列表推导式利用其它列表创建新列表。

类似数学术语中的集合推导式。

先看一个简单例子

>>> [ x * x for x in range(10) ]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

如果只想打印被3整除的平方数。

>>> [ x * x for x in range(10) if x % 3 == 0 ]
[0, 9, 36, 81]

还可以增加一个for语句

>>> [ (x,y) for x in range(3) for y in range(3) ]
[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

它实现的功能和下方一样

result = []
for x in range(3):
    for y in range(3):
        result.append((x,y))
print result

还可以联合if子句使用

data1 = ['A11_1','B22_1','C33_1']
data2 = ['C11_2','A22_2','B33_2']
print [(a,b) for a in data1 for b in data2 if a[0] == b[0]]

输出

C:\Users\ChengXu1\Desktop>python aa.py
[('A11_1', 'A22_2'), ('B22_1', 'B33_2'), ('C33_1', 'C11_2')]

如果把中括号改成小括号的话，不会得到 '元组推导式' 。会的得到一个生成器，可以用 tuple 转换成元组。

data1 = ['A11_1','B22_1','C33_1']
data2 = ['C11_2','A22_2','B33_2']
__tuple = tuple((a,b) for a in data1 for b in data2 if a[0] == b[0])
print __tuple

输出

C:\Users\ChengXu1\Desktop>python aa.py
(('A11_1', 'A22_2'), ('B22_1', 'B33_2'), ('C33_1', 'C11_2'))

更好的写法

data1 = ['A11_1','B22_1','C33_1']
data2 = ['C11_2','A22_2','B33_2']
letterData1 = {}
for one in data1:
    letterData1.setdefault(one[0],[]).append(one)
print [one + "  " + two for two in data2 for one in letterData1[two[0]] ]

语句(9) 什么事情都不用做 pass

当我写好条件语句的时候，还没有想好，语句块怎么写的时候，这个时候，还不需要做任何事情，需要一个占位符 pass

name = raw_input('Input name:\n')
if name == 'li':
    pass
else:
    print name

输出

C:\Users\ChengXu1\Desktop>python aa.py
Input name:
li

语句(10) del 删除引用

当我们有不对的变量时，我们就可以删除了。

x = None
del x

个人推荐使用 del 函数，当执行过后，x变量就无法使用了。下面看看区别

>>> x = None
>>> x
>>> del x
>>> x
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'x' is not defined

删除过会，Python解释器会负责内存回收。

语句(11) exec 和 eval 黑色魔法函数

此类似函数，一定要慎之又慎，仔细考虑。尤其是不能让用户输入的字符串作为代码执行，否则用户就可以随意控制了。

exec 可以执行一段字符串Python语句。

>>> exec("print 'Hello World!'")
Hello World!

输出

Hello World!

函数 python chr()、unichr()和ord()

ord()函数是chr()函数（对于8位的ASCII字符串）或unichr()函数（对于Unicode对象）的配对函数，它以一个字符（长度为1的字符串）作为参数，返回对应的ASCII数值，或者Unicode数值，如果所给的Unicode字符超出了你的Python定义范围，则会引发一个TypeError的异常。

>>> chr(65)
'A'
>>> ord('a')
97
>>> unichr(12345)
u'\u3039'
>>> chr(12345)
Traceback (most recent call last):
   File "<stdin>", line 1, in ?    
     chr(12345)
ValueError: chr() arg not in range(256)
>>> ord(u'\ufffff')
Traceback (most recent call last):
   File "<stdin>", line 1, in ?
     ord(u'\ufffff')
TypeError: ord() expected a character, but string of length 2 found
>>> ord(u'\u2345')
9029

posted @ 2016-07-21 20:19 笨重的石头阅读(424) 评论(0) 编辑收藏举报

刷新页面返回顶部

励志成为优秀程序员

非淡泊无以明志,非宁静无以致远！