Python 代码结构

一、使用 # 注释　　

每个 # 可以注释一行，可以把注释行作为单独一行，也可以和代码放在同一行

>>> # 60 sec/min * 60 min/hr *24 hr/day
... seconds_per_day = 86400
>>> seconds_per_day
86400
>>> seconds_per_day = 86400 # 60 sec/min * 60 min/hr *24 hr/day
>>> seconds_per_day
86400

Python 中是没有多行注释的符号，你需要明确的在注释部分的每一行开始处加上一个 #

>>> # 有的时候，特别是在 Python 的脚本中，
... # 三个单引号('''像这样''')或者三个双引号（""""像这样""")
... # 会被利用为进行多行注释的方法，不过严格意义上他们并不是
... # 注释符号，尽管这样，我们常常这样使用
...
>>>

二、 使用 \ 反斜线连接

程序代码在合理的长度下是易读的；在 Python 中，有个非强制性的规则，一行程序代码
最大长度应控制在 80 个字符内，如果一行代码字符超过了 80 个，你可以使用 \ 反斜
线来进行连接，Python 会把他们解释为一行代码
>>> a = \
... '我和上一行的 a 是同一行哦'
>>> a
'我和上一行的 a 是同一行哦'
>>> 1 + 2 + \
... 3
6>>>

python中比较运算符的使用

>>> x = 2

>>> y = 3

x == yx 等于 y

x < yx 小于 y

x > yx 大于 y

x >= y x 大于等于 y

x <= y x 小于等于 y

x != yx 不等于 y

x is yx 和 y 是同一个对象

x is not y x 和 y 是不同的对象

x in yx 是 y 容器（例如，序列）的成员

x not in yx 不是 y 容器（例如，序列）的成员

注：如果偶然遇见 x <> y 这样的表达式，它的意思其实就是 x != y ，不建议使用 <> 运算符，应该尽量避免使用它。

 什么是真值 （True）

布尔值   True 和 False

一个假 的赋值不一定明确的用 False 表示，下面的情况也会被认为是 False

在Python 中比较运算和赋值运算一样是可以是可以连接的——几个运算符可以连接在一起使用，

比如：0<num<100，判断变量num的范围为0到100

1）相等运算符

>>> 'Xiguatian' == 'Xiguatian'

False

>>> 'Xiguatian' == 'Xiguatian'

True

>>> 'Xiguatian' != 'Xiguatian'

False

2）大小运算符

>>> 2 > 3

False

>>> 2 <= 3

True

>>> 3 >= 3

True

3）同一性运算  is

字符串不适用

>>> x = y = 1

>>> a = 1

>>> x is a

True

序列适用

>>> x = y = [1,2,3]

>>> a = [1,2,3,]

>>> x is a

False

>>> x == a

True

>>>

主要用来判断序列，字符串是不适用的。is 运算符是判断同一性而不是相等性。

变量x和y都被绑定到同一个列表上，而变量z被绑定在另一个具有相同数值和顺序的列表上。

它们的值可能相等，但却不是同一个对象。

>>> 'P' in 'Python'

True

>>> 'Py' in 'Python'

True

>>> 'Pt' in 'Python'

False

>>>

多条件运算

and      连接两个运算符都为真时，则返回为真，否者为假    

or        连接两个运算符任一为真时，则返回为真，否者为假

not      取反

增量赋值

Python中没有使用shell的x=x+1，而是将表达式运算符放置在赋值运算符=的左边，写成x+=1。这种写法叫做增量赋值，对于* ，/ , % ,等标准运算符都适用

>>> x = 2

>>> x += 1

>>> x

3

>>> x *= 2

>>> x

6

>>> name = 'xiguatian'

+= 自增可以运用到字符和字符之间的操作中

>>> name += 'xiguatian'

而 *= 只看用在 字符 和 数字 之间的操作

>>> name *= 2

>>> name

'xiguatianxigtaitain'

>>> 

四、判断 if elif 和 else

简单预习

在 Python 脚本中写程序，和在 shell 脚本中一样，通常要在第一行声明一下程序的解释器

如：

#!/usr/bin/python3

/usr/bin/python3  指明的 Python3 的二进制可执行文件的绝对路径；

为了 Pthon 程序的可重用性，我们通常这样写

#!/usr/bin/env   python3

这样可以利用 Linux 的环境变量，系统自己找到适应程序的python3 的命令文件位置

1)单分支  if  语句的用法

语法：

if    判断条件：

    动作操作语句

if  语句在Python 中每条判断语句结尾必须以冒号  ‘:’ 为结尾

    动作操作语句前面必须缩进。

[root@x201 ~]# vim in.py

#!/usr/bin/env python

name = input("What is your name? ")

if 's' in name:

        print ("Your name contain the letter 's'.")

[root@x201 ~]# ./in.py

What is your name? suwukong

Your name contain the letter 's'.

2）双分支 if 语句的用法

语法格式

if条件测试语句1：

    条件测试操作1

else：

    条件测试操作2

#!/usr/bin/env python

name = input("What is your name? ")

if name.endswith('xiguatian'):

        print ('Hello,Mr.xiguatian')

else:

        print ('Hello,stranger')

注：endswith  是之前讲过的字符串的一种方法，用来判断字符串是否以某个字符串结尾；也许你已经忘了，但这不重要。

执行结果：

[root@localhost ~]# ./if.sh

What is your name? Xiguatian

Hello,Mr.xiguatian

[root@localhost ~]# ./if.sh

What is your name? xiguatian

Hello,stranger

3）多分支if语句

语法格式

if  条件测试语句1：

    条件测试操作1

elif 条件测试语句2：

    条件测试操作2

……

else：

默认执行的操作

例：判断数字的正负

#!/usr/bin/python

num = input("Enter a number: ")

if num > 0:

        print ("The number is positive")

elif num < 0:

        print ("The number is negative")

else:

        print ("The number is zero")

4）if语句的嵌套

语法格式

if  条件测试1：

    if    条件测试语句：

        print条件测试操作

……

else：

#!/usr/bin/env python

name = input("What is your name? ")

if name.endswith('xiguatian'):

        if name.startswith('Mr.'):

                print ("Hello,Mr.xiguatian")

        elif name.startswith('Mrs.'):

                print ("Hello,Mrs.xiguatian")

        else:

                print ("Hello,Xiguatian")

else:

        print ("Hello,stranger")

注：startswith是之前提到的字符串的一种方法，用来判断字符串是否以某个字符串开头，也许你现在忘了吧哈哈

for  循环

术语    迭代

在循环中，每次循环被称为一次迭代(iteration)

for循环的使用

语法格式

for  变量名   in    列表：

循环操作

>>> message = ['Good','morning','Sir']

>>> for word in message:

...     print(word)

...

Good

morning

Sir

range 函数

用来定义一组数字，包含下限，不包含上限，例：range(1,5)代表从1到5（不包含5）,1 就是上限，5 就是下限

>>> range(1,5)

[1, 2, 3, 4]

range函数可以手动指定数字间的间隔

>>> range(1,10,2)#代表从1到10，间隔2（不包含10）

[1, 3, 5, 7, 9]

其中下限可以省略，省略下限的同时数字间隔就不能使用了

>>> range(5)

[0, 1, 2, 3, 4]

通常，for循环可以和range函数结合进行使用

#!/usr/bin/env python

round = [

        'first',

        'second',

        'third',

        'fourth',

        'fifth'

]

for i in range(5):

        print i

        i += 2

        print i

        num = i - 2

        print ("The " ,round[num] ," round end." )

执行的结果：

[root@localhost ~]# python for_range.py

0

2

The first round end.

1

3

The second round end.

2

4

The third round end.

3

5

The fourth round end.

4

6

The fifth round end.

enumerate() 函数 可以对可迭代的对象增加序号

示例代码如下：

 1 [root@x201 ~]# cat enumerate.py
 2 #!/usr/bin/env python3
 3
 4 list_enume = [
 5     ['星期日','Sunday'],
 6     ['星期一','Monday'],
 7     ['星期二','Tuesday'],
 8     ['星期三','Wednesday'],
 9     ['星期四','Thursday'],
10     ['星期五','Friday'],
11     ['星期六','Saturday']
12 ]
13
14 for i,v in enumerate(list_enume):
15     print("%-3s%-5s%-10s"  %(i,v[0],v[1]))
16 [root@x201 ~]# python3 enumerate.py
17 0  星期日  Sunday
18 1  星期一  Monday
19 2  星期二  Tuesday
20 3  星期三  Wednesday
21 4  星期四  Thursday
22 5  星期五  Friday
23 6  星期六  Saturday
24 [root@x201 ~]#

View Code

判断 for 循环中最后一个元素，并对其进行特殊处理

data = {1:'a',2: 'b',3: 'c',4: 'd',5: 'e'}
previous = None
print "--------"
for k,v in data.iteritems():# print i,kif previous: # 处理上次循环的元素if  previous % 2 : # 处理奇数的元素print previous,v,else:print previous,v# 把上次循环的元素，赋值给 previous        previous = k
# 下面处理最后一个循环的元素
print previous,vprint "--------"

流程控制

break  ：跳出循环当前层的循环

continue  ：结束当前层循环的当次迭代，继续开始当前层循环的下一次迭代

>>> for i in range(1,10):

...     if i == 3:

...             print ("Great,you get your lucky number,which is " + str(i) )

...             continue

...     print ("The number is : %d " % i)

...

The number is : 1

The number is : 2

Great,you get your lucky number,which is 3

The number is : 4

The number is : 5

The number is : 6

The number is : 7

The number is : 8

The number is : 9

while循环语句的使用

例：打印100以内的数字

>>> x = 1

>>> while x <= 100:

...     print x

...     x += 1

编写登录信息验证程序

#!/usr/bin/env   python3

width = 80

title = "Welcome to Hero alliance"

len_width = len(title)

margin_width = (width - len_width - 2 )  // 2

print ('*' * width)

print( '*' * margin_width + ' ' + title + ' ' + '*' * margin_width)

print ('*' * width)

while True:

        input = input("Please input your username: ")

        if input == 'Xiguatian':

                password = input("Please input your password: ")

                p = '123'

                while password != p:

                        print ("Wrong password")

                        password = input("Please input your password again: ")

                else:

                        print (title)

                        break

        else:

                print ("Sorry, user %s not found" % input)

注：在Python中while循环也可以使用else语句进行流程控制

-------后续会有补充------

用 zip() 并行迭代

    zip() 函数可以对多个序列进行并行迭代

 1 >>> english = ['Monday','Tuesday','Thursday','Friday','Wednesday','Saturday','Sunday']
 2 >>> chineses = ['星期一','星期二','星期三','星期四','星期五','星期六','星期日']
 3 >>> shorthands = ['MON''TUE','WED','THU','FRI','SAT','SUN']
 4 >>> for chinese,week,shorthand in zip(chineses,english,shorthands):
 5      print(chinese,'的英文是:',week,'英文简写是:',shorthand)
 6
 7
 8 星期一 的英文是: Monday 英文简写是: MONTUE
 9 星期二 的英文是: Tuesday 英文简写是: WED
10 星期三 的英文是: Thursday 英文简写是: THU
11 星期四 的英文是: Friday 英文简写是: FRI
12 星期五 的英文是: Wednesday 英文简写是: SAT
13 星期六 的英文是: Saturday 英文简写是: SUN
14 >>> 

View Code

注意： zip() 函数会在最短序列迭代（循环）完毕时停止

利用 zip() 函数可以对具有相同数量的元素的序列进行配对，返回的值不是元组，也不是列表，而是一个整合在一起的可迭代变量

1 >>> english = 'Monday','Tuesday','Thursday',
2 >>> chineses = '星期一','星期二','星期三'
3 >>> zip(english,chineses)
4 <zip object at 0x0000000003159C48>
5 >>> dict(zip(english,chineses) )
6 {'Thursday': '星期三', 'Tuesday': '星期二', 'Monday': '星期一'}
7 >>> list(zip(english,chineses))
8 [('Monday', '星期一'), ('Tuesday', '星期二'), ('Thursday', '星期三')]
9 >>> 

View Code

推导式

    推到试是从一个或者多个迭代器快速简洁地创建数据结构的一种方法。

    > 可以将循环和条件判断相结合，从而避免语法冗长的代码

    > 实际上使用推导式更像Python的风格

    1. 列表推导式

    格式：

    [expression   for  item  in iterable ]

    > expression  表达式，比如 单独的变量名，变量名 - 1

    > item  循环变量

    > iterable  可迭代对象   其后面可以跟判断条件，如：[expression   for  item  in iterable if  condition]

 1 # 一般传统的方法
 2 >>> number_list = list(range(1,5))
 3 >>> number_list
 4 [1, 2, 3, 4]
 5 >>>
 6 # 列表推导式
 7 >>> number_list = [number for number in range(1,7)]
 8 >>> number_list
 9 [1, 2, 3, 4, 5, 6]
10 # 添加有表达式的列表推导式
11 >>> number_list = [number-1 for number in range(1,7)]
12 >>> number_list
13 [0, 1, 2, 3, 4, 5]
14
15 #  有条件判断的一般传统的方法
16 >>> a_list = []
17 >>> for number in range(1,6):
18 ...     if number % 2 == 1:
19 ...         a_list.append(number)
20 ...
21 >>> a_list
22 [1, 3, 5]
23
24 # 使用有条件判断的列表推导式
25 >>> a_list = [number for number in range(1,6) if number % 2 == 1]
26 >>> a_list
27 [1, 3, 5]
28
29 #  含有嵌套循环的一般方法
30 >>> rows = range(1,4)
31 >>> cols = range(1,3)
32 >>> for row in rows:
33 ...         for col in cols:
34 ...             print(row,col)
35 ...
36 (1, 1)
37 (1, 2)
38 (2, 1)
39 (2, 2)
40 (3, 1)
41 (3, 2)
42
43 # 嵌套循环的列表推导式
44 >>> rows = range(1,4)
45 >>> cols = range(1,3)
46 >>> cells = [(row,col) for row in rows for col in cols]
47 >>> for cell in cells:
48 ...     print(cell)
49 ...
50 (1, 1)
51 (1, 2)
52 (2, 1)
53 (2, 2)
54 (3, 1)
55 (3, 2)
56 >>>

View Code

    2. 字典推导式

    格式：

    {key_expression:value_expression for  expression in iterable}

 1 # 一个简单的例子
 2 >>> word = 'letters'
 3 >>> letter_counts = {letter:word.count(letter) for letter in word}
 4 >>> letter_counts
 5 {'s': 1, 'r': 1, 'e': 2, 'l': 1, 't': 2}
 6
 7 # 利用 set 集合去重，以减少 word.count(letter) 的次数，以节约资源和时间
 8 >>> letter_counts = {letter:word.count(letter) for letter in set(word)}
 9 >>> letter_counts
10 {'s': 1, 'r': 1, 'e': 2, 'l': 1, 't': 2}
11 >>> 

View Code

    3. 集合推导式

    格式和列表、字典推导式的格式一样

1 >>> a_set = {number for number in range(1,6) if number % 3 == 1}
2 >>> a_set
3 {1, 4}
4 >>> 

View Code

    4. 生成器推导式

    也许机智的你已经发现了以上的规律，如果将列表推导式的方括号变成圆括号就可以定义一个元组推导式；

    不幸的是，元组是没有推导式的，其实它是一个生成器推导式，它返回的是一个生成器对象，可以直接对其进行迭代。

注意： 一个生成器只能运行一次。list/set/str/dict 都是存储在内存里的，但生成器仅在运行时产生值，不会被保存下来，当然也不能对其备份。

 1 >>> number_thing = (number for number in range(1,6) if number % 2 == 1)
 2 >>> number_thing
 3 <generator object <genexpr> at 0x7f25d59f1820>
 4 >>> type(number_thing)
 5 <type 'generator'>
 6
 7 # 可以直接对生成器对象进行迭代
 8 >>> for number in number_thing:
 9 ...     print(number)
10 ...
11 1
12 3
13 5
14
15 # 可以对其调用 linst()函数，但是由于上面已经迭代一次了，由于其是无法保存的，所以
16 # 再次进行迭代，发现它已经不存在了
17 >>> list(number_thing)
18 []
19
20 # 再次生成
21 >>> number_thing = (number for number in range(1,6) if number % 2 == 1)
22 >>> list(number_thing)
23 [1, 3, 5]
24 >>> 

View Code

你可以使用生成器推导式产生一个生成器，也可以用生成器的函数，以后会提到。