足球盘口软件
当前位置: 足球盘口软件 > 前端 >
Python基础学习总结,判断语句

写好Python之If语句

基本用法

判断,基于一定的条件,决定是否要执行特定的一段代码,例如判断一个数是不是正数:

x = 0.5
if x > 0:
    print("Hey!")
    print("x is positive")

Hey!
x is positive
在这里,如果 x > 0 为 False ,那么程序将不会执行两条 print 语句。

虽然都是用 if 关键词定义判断,但与C,Java等语言不同,Python不使用 {} 将 if 语句控制的区域包含起来。Python使用的是缩进方法。同时,也不需要用 () 将判断条件括起来。

上面例子中的这两条语句:

print ("Hey!")
print ("x is positive")

就叫做一个代码块,同一个代码块使用同样的缩进值,它们组成了这条 if 语句的主体。

不同的缩进值表示不同的代码块,例如:

x = 0.5
if x > 0:
    print("Hey!")
    print("x is positive")
    print("This is still part of the block")
print("This isn't part of the block, and will always print.")

Hey!
x is positive
This is still part of the block
This isn't part of the block, and will always print.
在这两个例子中,最后一句并不是if语句中的内容,所以不管条件满不满足,它都会被执行。

一个完整的 if 结构通常如下所示(注意:条件后的 : 是必须要的,缩进值需要一样):

if <condition 1>:
    <statement 1>
    <statement 2>
elif <condition 2>: 
    <statements>
else:
    <statements>

当条件1被满足时,执行 if 下面的语句,当条件1不满足的时候,转到 elif ,看它的条件2满不满足,满足执行 elif 下面的语句,不满足则执行 else 下面的语句。

开篇废话

这是在美国Amazon上评价很不错的一本书,其实严格来说这可能不算书,而是一本小册子。就像书名一样,里面的内容主要是用一些例子讲述地道的Python的代码是怎样写的。书中把很多例子用不良风格和地道Python写法作对比,内容覆盖谈不上很全,但是每一条都很有代表性。总体而言非常适合新手,同时里面有些条目老手看了或许也会有豁然开朗的感觉。作者Jeff Knupp曾在全球最牛B的高盛和其他银行里做过金融系统开发,在北美Python社区里也很有活跃度。

自己用Python也有些年头了,做过一年多的商业开发,不过其他大部分还是以科研和预研期的算法为主。最近因为又开始用Python做商业开发,所以想着顺便找些书看看,无意中看到了这本小书,觉得很不错,国内没有卖的,更别提中文版了。翻译这本书,算是复习和重新思考下Python,同时也会有少量自己的见解(C++风格注释绿色粗体),希望能坚持下去吧。我看的版本主要分为四部分:Control Structures and Functions(控制结构和函数)、Working with Data(数据和类型)、Organizing Your Code(代码组织)、General Advice(一般性建议)。每一部分里又分为不同的小章节,一共二十几个。我会按这个顺序不定期放出数目不定的章节。本人英文水平尚可,不过没有翻译经验,虽然不知道会不会有人关注这个系列,还是希望如果有看官,请轻拍指正:)

原书参考:

下一篇:翻译《Writing Idiomatic Python》(二):函数、异常


4.if语句

  If语句可以检查判定当前条件,并执行相应措施。

1 if a in A:
2     if a 条件:
3     执行命令1
4   else:
5       执行命令2
6 
7 if判断条件还可以简写
8 if x:
9     print('True')

  只要x是非零数值、非空字符串、非空list等,就判断为True,否则为False。

避免将分支代码放在冒后后相同行

使用缩进来区分作用域(和你在Python其他地方一样)更容易判断条件所要执行的部分。if, elif, 和else里语句应该总是在新行。不应该将代码跟在:后。

值的测试

Python不仅仅可以使用布尔型变量作为条件,它可以直接在if中使用任何表达式作为条件:
大部分表达式的值都会被当作True,但以下表达式值会被当作False:

  • False
  • None
  • 0
  • 空字符串,空列表,空字典,空集合
mylist = [3, 1, 4, 1, 5, 9]
if mylist:
    print("The first element is:", mylist[0])
else:
    print("There is no first element.")

The first element is: 3
修改为空列表:

mylist = []
if mylist:
    print("The first element is:", mylist[0])
else:
    print("There is no first element.")

There is no first element.
然这种用法并不推荐,推荐使用 if len(mylist) > 0: 来判断一个列表是否为空。

1. 控制结构和函数

4.1条件测试(条件判断)

  1.每个if语句的核心都是条件判断True或False,这种表达式称为条件测试

  2.Python根据条件测试的值True或False来判断是否执行下面的代码,如果if语句的判断为True,就执行下面代码,判断为False会忽略下面的代码。

  3.在python中,任何不为0,Null或空对象的东西都为True。

糟糕的

name = 'Aidan'
address = 'GuangDong, ShenZhen'

if name: print(name)
print(address

1.1 if语句

4.2检查是否相等

  1.Python比较大小是区分大小写

  2.!= 表示不相等,感叹号表示不,可以比较数字,字符。

推荐的

name = 'Aidan'
address = 'GuangDong, ShenZhen'

if name: 
    print(name)
print(address

1.1.1 通过链式比较让语句更加简明

当使用if语句时,优先使用链式比较操作,不仅会让语句更加简明,也会让执行效率更好。

不良风格:

1 if x <= y and y <= z:
2     return True

地道Python:

1 if x <= y <= z:
2     return True

// Python解释执行以上两种不同的比较方式时,其实都是先比较x<=y,如果为真,再比较y<=z。主要的区别在于,链式比较时,会先取y的值,然后复制压栈,整个过程中y的求值只执行了一次,而用and的方式时,y的求值会执行两次,也就是说,如果比较的是三个函数或者复杂的对象的话,链式比较只会求值三次,而通过and比较的方式则会求值4次。这大概就是为什么作者说执行效率会更好,但实际上如果只是简单的变量进行比较,效率未必会有提高。

4.3检查多个条件

  1.使用关键词and连接,都满足为True,一个没有满足都为False。为改善可读性,可将每个测试写在( )中。

  2.使用关键词or连接,满足一个就为True,都不满足才为False。

避免在If语言中重复出现变量

当你想检查变量是否为一系列值时,重复检查该值是不必的冗长。使用iterable(迭代)让代码更简单,并具有可读性

1.1.2 避免将条件分支中的代码和冒号放在同一行

使用缩进来表示代码块的结构会让人更容易判断条件分支的代码结构。ifelifelse语句应该都总是独占一行,在冒号后没有代码。

不良风格:

1 name = 'Jeff'
2 address = 'New York, NY'
3 
4 if name: print(name)
5 print(address)

地道Python:

1 name = 'Jeff'
2 address = 'New York, NY'
3 
4 if name:
5     print(name)
6 print(address)

// 文件中的代码应该遵循这个规则,在控制台下放一行也未尝不可

4.4检查特定的值是否包含在列表中

  1.使用关键词in来判断包含关系。

  2.使用关键词 not in 来判断不包含关系。

糟糕的

is_generic_name = False
name = 'Tom'

if name == 'Tom' or name == 'Dick' or name == 'Harry':
    is_generic_name = True

1.1.3 避免在复合的if语句中重复出现同一个变量名

当想用if语句检查一个变量是否和许多值中的一个相等时,用==or重复写许多遍是否相等的检查会显得代码很冗长。简洁的写法是判断该变量是否在一个可遍历的结构中。

不良风格:

1 is_generic_name = False
2 name = 'Tom'
3 if name == 'Tom' or name == 'Dick' or name == 'Harry':
4     is_generic_name = True

地道Python:

1 name = 'Tom'
2 is_generic_name = name in ('Tom', 'Dick', 'Harry')

4.5布尔表达式

  1.布尔表达式是条件测试的别名,结果一样都是True或False。布尔值和布尔代数的表示完全一致,一个布尔值只有True、False两种值,要么是True,要么是False,在Python中,可以直接用True、False表示布尔值(请注意大小写

  2.布尔值可以用and、or和not运算。布尔操作符。

>>> True and True
True
>>> True and False
False
>>> False and False
False
>>> not True
False

推荐的

name = 'Tom'
is_generic_name = name in ('Tom', 'Dick', 'Harry')

1.1.4 避免直接与True, False或者None直接比较

对于任意Python中的对象,无论是内建的还是用户定义的,本身都会关联一个内部的“真值”(truthiness)。所以很自然地,当判断一个条件是否为真的时候,尽量在条件判断语句中优先依靠这个隐式的“真值”。下面列举的是“真值”为False的情况:

None
False
数值0
空的序列(列表,元组等)
空的字典
当__len__或者__nonzero__被调用后返回的0值或者False

按照上面的最后一条,通过检查调用__len__或者__nonzero__后返回的值的方式,我们也可以定义自己创建的类型的“真值”。除了上面列举的这些,其他的情况都被认为“真值”为True

在Python中if语句隐式地使用“真值”,所以你的代码中也应该这样做。比如对于下面这种写法:

if foo == True:

更简单而直接的写法是:

if foo:

这样做的理由有很多。最明显的一条理由是,如果你的代码发生了变化,比如当foo变成了一个int型而不是TrueFalseif语句在判断是否为0时仍然正确。在更深的层面上,这是基于相等性(equality)和等价性(identity)的差别。使用==检查的是两个对象是否有相等或是等效的值(由_eq属性定义),而is语句则检查的是两个对象在底层是否同一个对象。

// Python对相等的实现在C代码中实现将比较对象用PyInt_AS_LONG转化成long型,然后再用C中的==进行比较,而is的实现是直接==比较。

所以对FalseNone和和空的序列比如[], {},以及()应该避免直接进行比较。如果一个叫my_list的列表为空, if my_list 会判断为False。当然有些情况下,虽然不推荐,但是直接和None比较是必须的。当在一个函数中需要判断一个默认值为None的参数是否被赋值的时候,比如:

1 def insert_value(value, position=None):
2     """向自定义的容器中插入一个值,插入值
3     的位置作为可选参数,默认值为None"""
4     if position is not None:
5         ...

如果使用 if position: 的话,哪里会出错呢?设想如果有人想在0位置插入一个值,那么函数会认为position这个参数没有设置,因为 if 0: 会判定为False。注意这里使用的是is not,根据PEP8,和None比较应该总是用is或者is not而不是==

总之,就让Python的“真值”代替你做比较的工作。

不良风格:

 1 def number_of_evil_robots_attacking():
 2     return 10
 3     
 4 def should_raise_shields():
 5     # 只有当一只以上的巨型机器人进攻时才打开防护罩
 6     # 所以我只需要返回巨型机器人的数量,如果不为零会自动判断为真
 7     return number_of_evil_robots_attacking()
 8 
 9 if should_raise_shields() == True:
10     raise_shields()
11     print('防护罩已打开')
12 else:
13     print('安全!并没有巨型机器人在进攻')

地道Python:

 1 def number_of_evil_robots_attacking():
 2     return 10
 3     
 4 def should_raise_shields():
 5     # 只有当一只以上的巨型机器人进攻时才打开防护罩
 6     # 所以我只需要返回巨型机器人的数量,如果不为零会自动判断为真
 7     return number_of_evil_robots_attacking()
 8 
 9 if should_raise_shields():
10     raise_shields()
11     print('防护罩已打开')
12 else:
13     print('安全!并没有巨型机器人在进攻')

4.6if 语句

  1.简单if语句,一个测试,一个操作,注意缩进,和冒号。

  2.if-else语句  一个条件测试,2个操作。

  3.if-elif-else结构 多条件测试,elif是else if的缩写,完全可以有多个elif。

1 if <条件判断1>:
2     <执行1
3 elif <条件判断2>:
4     <执行2>
5 elif <条件判断3>:
6     <执行3>
7 else:
8     <执行4>

  4.if语句执行有个特点,它是从上往下判断,如果在某个判断上是True,把该判断对应的语句执行后,就忽略掉剩下的elif和else。

  5.可省略else,用elif代替,避免引入更多错误信息。

  6.语法格式== 、>= 和<= 等比较运算符两边各添加一个空格,例如,if age < 4: 要比 if age<4: 好。

避免直接True, False, 或None进行比较

对于任何对象,内建还是用户定义,都具有相关的布尔特性,当检查一个条件是否为真时,如果不是在语句中严格判断其对象布尔特性,判断规则有点让人奇怪。以下将被视为False:

  • None
  • False
  • 数值0
  • 空序列
  • 空字典
  • 对象方法_len_nonzore返回值为0或者False

除了这些其他都会视为True(或隐示为True)。最后的条件是通过检查对象的lennonzero,来判断布尔值。

if语句中隐示使用布尔值,你应该不使用:

if foo == True:

简单使用 if foo:.

有几个原因。最首要的是当foo变为int类型时,if语句仍然有效。更深层的原因在于equalityindentity。使用==判断两个对象爱嗯是否是相同值(_eq属性)。使用is来判断两个对象是否时相同对象。

在判断中,避免直接与FalseNone或者空序列(例如:[], {})进行比较。如果my_lists是个空列表,使用if mylist: 将返回False

有时,虽不推荐和None进行直接比较,但有时又时必须的。函数检查某个参数默认值是否None,例如:

def insert_value(value, position=None):
    """INserts a value into my container, optionally at the
    specified position"""
    if position is not None:
        ...

这里if position:?做了什么呢,当有人想插入到指定0位置,当函数没有设置position参数,由于0等于False,我们就使用is 或is not来进行None比较, 而不是 ==.

1.1.5 使用if 和 else作为三元操作符的替代

和许多其他语言不同,Python没有三元操作符(比如: x ? true : false)。不过Python可以将赋值推迟到条件判断之后,所以在Python中三元操作可以用条件判断来替代。当然需要注意的是,除非是很简单的语句,否则三元操作的替代方案会让语句的可读性降低。

不良风格:

1 foo = True
2 value = 0
3 
4 if foo:
5     value = 1
6 
7 print(value)

地道Python:

1 foo = True
2 
3 value = 1 if foo else 0
4 
5 print(value)

5.字典

  Python内置了字典:dict的支持,dict全称dictionary,在其他语言中也称为map,使用键-值(key-value)存储,具有极快的查找速度。

糟糕的

def number_of_evil_robots_attacking():
    reutrn 10

def should_raise_shields():
    # "We only raise Shields when one or more giant robots attack,
    # so I can just return that value..."
    return number_of_evil_robots_attacking()

if should_raise_shields() == True:
    raise_shields()
    print("Shields raised")  
else:
    print("Safe! No giant orbots attacking")

1.2 For循环

特点:

  1.无序的,字典是动态数据,字典由{ }组成,分号隔开。字典包含键和值,一 一对应。

  2.与键相关联的值可以是数字、字符串、列表乃至字典,可将任何Python对象用作字典中的值。

  3.正确使用dict非常重要,需要牢记的第一条就是dict的key必须是不可变对象。

推荐的

def number_of_evil_robots_attacking():
    reutrn 10

def should_raise_shields():
    # "We only raise Shields when one or more giant robots attack,
    # so I can just return that value..."
    return number_of_evil_robots_attacking()

if should_raise_shields():
    raise_shields()
    print("Shields raised")  
else:
    print("Safe! No giant orbots attacking")

避免将分支代码放在冒后后相同行 使用缩进来区分作用域(和你在Python其他地方一样)更容易判断条件所要执行的部分。...

1.2.1 在循环中使用enumerate函数来创建计数或索引

在许多其他语言中,开发者习惯显式地声明一个变量用来作为循环中的计数或者相关容器的索引。例如在C++中:

1 for ( int i = 0; i < container.size(); ++i )
2 {
3     // Do stuff
4 }

在Python中,内置的enumerate函数就可以很自然地处理这种需要。

不良风格:

1 my_container = ['Larry', 'Moe', 'Curly']
2 index = 0
3 for element in my_container:
4     print('{} {}'.format(index, element))
5     index += 1

地道Python:

1 my_container = ['Larry', 'Moe', 'Curly']
2 for index, element in enumerate(my_container):
3     print('{} {}'.format(index, element))

set:

  1. set和dict类似,也是一组key的集合,但不存储value。由于key不能重复,所以,在set中,没有重复的key。

  2.set可以看成数学意义上的无序和无重复元素的集合,因此,两个set可以做数学意义上的交集、并集等操作:&交集;  | 并集

  3.set和dict的唯一区别仅在于没有存储对应的value,但是,set的原理和dict一样,所以,同样不可以放入可变对象,因为无法判断两个可变对象是否相等,也就无法保证set内部“不会有重复元素”。试试把list放入set,看看是否会报错。

  4.通过add(key)方法可以添加元素到set中,可以重复添加,但不会有效果。

  5.通过remove(key)方法可以删除元素。

1.2.2 使用in关键字遍历可迭代结构

在没有for_each风格的语言中,开发者习惯于用索引(下标)来遍历一个容器中的元素。而在Python中,这种操作可以通过in关键字来更为优雅地实现。

不良风格:

1 my_list = ['Larry', 'Moe', 'Curly']
2 index = 0
3 while index < len(my_list):
4     print(my_list[index])
5     index += 1

地道Python:

1 my_list = ['Larry', 'Moe', 'Curly']
2 for element in my_list:
3     print(element)

list和dict对比

和list比较,dict有以下几个特点:

    1.查找和插入的速度极快,不会随着key的增加而变慢;

    2.需要占用大量的内存,内存浪费多。

而list相反:

    1.查找和插入的时间随着元素的增加而增加;

    2.占用空间小,浪费内存很少。

所以,dict是用空间来换取时间的一种方法。

1.2.3 使用else去执行一个for循环全部遍历结束后的代码

在Python的for循环中可以包含一个else分句,这是一个不多人知道的技巧。else语句块会在for循环中的迭代结束后执行,除非在迭代过程中循环因为break语句结束。利用这种写法我们可以在循环中执行条件检查。要么在要检查的条件语句为真时用break语句停止循环,要么在循环结束后进入else语句块并执行条件未被满足的情况下要执行的动作。这样做避免了在循环中单独使用一个标示变量来检查条件是否被满足。

不良风格:

 1 for user in get_all_users():
 2     has_malformed_email_address = False
 3     print('检查 {}'.format(user))
 4     for email_address in user.get_all_email_addresses():
 5         if email_is_malformed(email_address):
 6             has_malformed_email_address = True
 7             print('包含恶意email地址!')
 8             break
 9     if not has_malformed_email_address:
10         print('所有email地址均有效!')

地道Python:

1 for user in get_all_users():
2     print('检查 {}'.format(user))
3     for email_address in user.get_all_email_addresses():
4         if email_is_malformed(email_address):
5             print('包含恶意email地址!')
6             break
7     else:
8         print('所有email地址均有效!')

转载请注明出处:達聞西@博客園

下一篇:翻译《Writing Idiomatic Python》(二):函数、异常

5.1访问字典的值

1.键值访问

  知道键值可以访问值:

>>> test = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
>>> test['a']
1
>>> test['b']
2

  要避免key不存在的错误,有两种办法,一是通过in判断key是否存在:

>>> 'a' in test
True
>>> 'b' in test
True
>>> 'e' in test
False

2.get方法

  是通过dict提供的get方法,如果key不存在,可以返回None,或者自己指定的value:

>>>d.get('Thomas')
>>>d.get('Thomas', -1) #在d中不存在'Thomas',返回-1
-1

>>> picnicItems = {'apples': 5, 'cups': 2}
>>> 'I am bringing ' + str(picnicItems.get('cups', 0)) + ' cups.'
'I am bringing 2 cups.'
>>> 'I am bringing ' + str(picnicItems.get('eggs', 0)) + ' eggs.'
 'I am bringing 0 eggs.

  注意:返回None的时候Python的交互式命令行不显示结果。

3.setdefault()方法

  setdefault()方法提供了一种方式,在一行中完成这件事。传递给该方法的第一个参数,是要检查的键。第二个参数,是如果该键不存在时要设置的值。如果该键确实存在,方法就会返回键的值。

>>> spam = {'name': 'Pooka', 'age': 5}
>>> spam.setdefault('color', 'black') #键不存在,返回'black'
'black'

4.pprint 模块

  导入 pprint 模块,就可以使用 pprint()和pformat()函数,它们将“漂亮 打印”一个字典的字。

pprint.pprint(someDictionaryValue)
print(pprint.pformat(someDictionaryValue))

5.2添加键和值

  字典是动态数据,可以随时在其中添加键和值,通过key加入数据:

1 alien_0 = {'color': 'green', 'points': 5} 
2 alien_0['x_position'] = 0
3 alien_0['y_position'] = 25
4 print(alien_0)
5 {'color': 'green', 'points': 5, 'x_position': 0, 'y_position': 25}

5.3删除键和值

  1.要删除一个key,用pop(key)方法,对应的value也会从dict中删除:

>>> test = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
>>> test.pop('a')
1
>>> test
{'b': 2, 'c': 3, 'd': 4}

  2.使用del :

>>> del test['c']
>>> test
{'b': 2, 'd': 4}

5.4遍历字典 item()

  Python 字典(Dictionary) items() 函数以列表返回可遍历的(键, 值) 元组数组。

  for key, value in user_0.items():

  实际:

  for name, language in favorite_languages.items():

  简单变量名:

  for k, v in user_0.items()

  注意,即便遍历字典时,键—值对的返回顺序也与存储顺序不同。Python不关心键—值对的存储顺序,而只跟踪键和值之间的关联关系。

  判断一个对象是可迭代对象,方法是通过collections模块的Iterable类型判断

>>> from collections import Iterable
>>> isinstance('abc', Iterable) # str是否可迭代

  Python内置的enumerate函数可以把一个list变成索引-元素对,这样就可以在for循环中同时迭代索引和元素本身。

  使用内建的isinstance函数可以判断一个变量是不是字符串。

5.4.1遍历字典所有的键(for循环)

  Python的循环有两种,一种是for...in循环,依次把list或tuple中的每个元素迭代出来,看例子:

for name in favorite_languages.keys():

  遍历字典时,会默认遍历所有的键,因此,如果将上述代码中的for name in favorite_languages.keys(): 替换为for name in favorite_languages: ,输出将不变。 如果显式地使用方法keys() 可让代码更容易理解,你可以选择这样做,但如果你愿意,也可省略它。

5.4.2按顺序遍历字典所有的键

sorted() 

  使用函数sorted() 来获得按特定顺序排列的键列表的副本。

按首字母排序:

  一种办法是在for 循环中对返回的键进行排序。为此,可使用函数sorted() 来获得按特定顺序排列的键列表的副本。

5.4.3遍历字典中所有的值

values()

使用方法values() ,它返回一个值列表,而不包含任何键。

for language in favorite_languages.values():

为剔除重复项,可使用集 合set()。集合 类似于列表,但每个元素都必须是独一无二的:

for language in set(favorite_languages.values()):

5.5嵌套

  还可以使用两层循环,可以生成全排列。

>>> a = [1, 2, 3]
>>> for n in a:
...     for m in a:
...         print(n, m)
...
1 1
1 2
1 3
2 1
2 2
2 3
3 1
3 2
3 3

5.5.1字典列表

1 alien_0 = {'color': 'green', 'points': 5} 
2 alien_1 = {'color': 'yellow', 'points': 10} 
3 alien_2 = {'color': 'red', 'points': 15}
4 aliens = [alien_0, alien_1, alien_2]

5.5.2在字典中存储字典

  字典中嵌套字典

5.6退出循环(break)

  在循环中,break语句可以提前退出循环。这个语句通常必须配合if语句使用。

5.7continue

  在循环过程中,也可以通过continue语句,跳过当前的这次循环,直接开始下一次循环。这个语句通常也必须配合if语句使用。

 

返回顶部