笨办法学python3 学习笔记 习题25

习题25 更多更多的练习

# 定义break_words函数
def break_words(stuff):
    # 加注释
    """This function will break up words for us."""
    # 将sutff按空格分隔——words
    words = stuff.split(' ')
    return words

# 定义sort_words函数
def sort_words(words):
    """sorts the words."""
    # 将words内的元素排序，并将排序后的内容返回
    return sorted(words)

# 定义print_first_words函数
def print_first_word(words):
    """prints the first word after popping it off."""
    # 将words的第一个元素删除，并将该元素赋值给word
    word = words.pop(0)
    print(word)

# 定义print_first_words函数
def print_last_word(words):
    """prints the last word after popping it off."""
    # 将words的最后一个元素删除，并将该元素赋值给word
    word = words.pop(-1)
    print(word)

# 定义sort_sentence函数
def sort_sentence(sentence):
    """Takes in a full sentence and returens the sorted words."""
    # sentence为参数，运行行1的函数，赋值给words
    words = break_words(sentence)
    # words为参数，运行行11的函数，并返回
    return sort_words(words)

# 定义print_first_and_last函数
def print_first_and_last(sentence):
    """Prints the first and last words of the sentence."""
    # sentence为参数，运行行1的函数，赋值给words
    words = break_words(sentence)
    # words为参数，运行行17的函数
    print_first_word(words)
    # words为参数，运行行25的函数
    print_last_word(words)

# 定义print_first_and_last_sorted函数
def print_first_and_last_sorted(sentence):
    """Sorts the words then prints the first and last one."""
    # sentence为参数，运行行33的函数，结果赋值给words
    words = sort_sentence(sentence)
    # words为参数，运行行17的函数
    print_first_word(words)
    # words为参数，运行行25的函数
    print_last_word(words)

PS D:\pythonp> python
Python 3.8.1 (tags/v3.8.1:1b293b6, Dec 18 2019, 23:11:46) [MSC v.1916 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.

>>> import ex25
>>> sentence = "All good things come to those who wait."
>>> words = ex25.break_words(sentence)
>>> words
['All', 'good', 'things', 'come', 'to', 'those', 'who', 'wait.']
>>> sorted_words = ex25.sort_words(words)
>>> sorted_words
['All', 'come', 'good', 'things', 'those', 'to', 'wait.', 'who']
>>> ex25.print_first_word(words)
All
>>> ex25.print_last_word(words)
wait.
>>> words
['good', 'things', 'come', 'to', 'those', 'who']
>>> ex25.print_first_word(sorted_words)
All
>>> ex25.print_last_word(sorted_words)
who
>>> sorted_words
['come', 'good', 'things', 'those', 'to', 'wait.']
>>> sorted_words = ex25.sort_sentence(sentence)
>>> sorted_words
['All', 'come', 'good', 'things', 'those', 'to', 'wait.', 'who']
>>> ex25.print_first_and_last(sentence)
All
wait.
>>> ex25.print_first_and_last_sorted(sentence)
All
who
>>>

三引号的用法

1. 跨 多行、换行符、制表符

2. 加注释

3. 加多行注释（#：加单行注释）

   ……

split()函数

描述

split()函数 通过指定分隔符对字符串进行切片，如果参数 num 有指定值，则分隔num次，即分隔 num+1 个子字符串

语法

str.split(str="", num=string.count(str)).

参数

• str – 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。
• num – 分割次数。默认为 -1, 即分隔每一处分隔符存在的位置。

返回值

• 返回分割后的字符串列表
  • 会自动舍弃字符串中的分隔符。

实例

以下实例展示了 split() 函数的使用方法：

str = "Line1-abcdef \nLine2-abc \nLine4-abcd"; 

print str.split( );       # 以空格为分隔符，包含 \n 
print str.split(' ', 1 ); # 以空格为分隔符，分隔成两个

['Line1-abcdef', 'Line2-abc', 'Line4-abcd']
['Line1-abcdef', '\nLine2-abc \nLine4-abcd']

以下实例以 # 号为分隔符，指定第二个参数为 1，返回两个参数列表。

txt = "Google#Runoob#Taobao#Facebook"  
# 第二个参数为 1，返回两个参数列表 
x = txt.split("#", 1)  
print x

['Google', 'Runoob#Taobao#Facebook']

sorted() 函数

描述

sorted() 函数对所有可迭代的对象进行排序操作。

sort 与 sorted 区别：

• sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
  • list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值
  • 内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

语法

sorted(iterable, cmp=None, key=None, reverse=False)

• 参数说明

  • iterable——可迭代对象。
  • cmp——比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。
  • key——主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
  • reverse—— 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。

• key 和 reverse 比一个等价的 cmp 函数处理速度要快。这是因为对于每个列表元素，cmp 都会被调用多次，而 key 和 reverse 只被调用一次

返回值

返回重新排序的列表。

实例

以下实例展示了 sorted 的使用方法：

>>>a = [5,7,6,3,4,1,2]
# 保留原列表
>>> b = sorted(a)       
>>> a 
[5, 7, 6, 3, 4, 1, 2]
>>> b
[1, 2, 3, 4, 5, 6, 7]
 
>>> L=[('b',2),('a',1),('c',3),('d',4)]
# 利用cmp函数
>>> sorted(L, cmp=lambda x,y:cmp(x[1],y[1]))  
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
# 利用key
>>> sorted(L, key=lambda x:x[1])               
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
 
 
>>> students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
# 按年龄排序
>>> sorted(students, key=lambda s: s[2])            
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

# 按降序
>>> sorted(students, key=lambda s: s[2], reverse=True)       
[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]

匿名函数 lambda

• python 使用 lambda 来创建匿名函数。

• lambda只是一个表达式，函数体比def简单很多。

• lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。

• lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。

• 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

语法

lambda函数的语法只包含一个语句

lambda [arg1 [,arg2,.....argn]]:expression

实例

# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2

# 调用sum函数
print "相加后的值为 : ", sum( 10, 20 )
print "相加后的值为 : ", sum( 20, 20 )

# 相加后的值为 :  30
# 相加后的值为 :  40

关于上述形如 [] 的内容

• Python 没有内置对数组的支持，但可以使用 Python 列表代替。
• 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。
• [-1]的用法是取最后一个元素

现在先了解这点就好了，之后遇到再说

pop()函数

描述

pop() 函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。

语法

list.pop([index=-1])

参数

• obj – 可选参数，要移除列表元素的索引值，不能超过列表总长度，默认为 index=-1，删除最后一个列表值。

返回值

该方法返回从列表中移除的元素对象。

实例

以下实例展示了 pop()函数的使用方法：

实例

list1 = ['Google', 'Runoob', 'Taobao'] 
list_pop=list1.pop(1) 
print "删除的项为 :", list_pop
print "列表现在为 : ", list1

# 删除的项为 : Runoob
# 列表现在为 :  ['Google', 'Taobao']

• 以上参数默认index = -1，[-1]的用法是取最后一个元素

1. 研究“应该看到的结果”中没有分析过的行，研究它们的作用，确认自己明白了如何运行模块ex25中定义的函数。

​ 以下为自己理解的运行过程：

• 行5：将ex25作为一个模块（module）利用import导入进来，所以不需要加后缀“.py”。在ex25中定义的函数可以直接调用出来。
• 行6：定义sentence字符串
• 行7：以sentence运行ex25中的第一个函数。利用ex25.break_words告诉计算机调用ex25中的该函数
• 行8：输入words
• 行9：打印出的words内容
• 行10-12：以words运行ex25的sorted_words函数，结果赋给sorted_words，并打印出来
• 行13-14：以words运行ex25的print_first_word函数
• 行15-16：以words运行ex25的print_last_word函数
• 行17-18：输入words
• 行19-20：以sorted_words运行ex25的print_first_word函数
• 行21-22：以sorted_words运行ex25的print_last_word函数
• 行23-24：输入sorted_words
• 行25-27：以sentence运行ex25的sorted_sentence函数，结果赋给sorted_words
• 行28-30：以sentence运行ex25的print_first_and_last函数
• 行31-33：以sentence运行ex25的print_first_and_last_sorted函数

2. 试着执行help（ex25）和help（ex25. break words）。这是得到模块帮助文档的方式。所谓帮助文档就是定义函数时放在"""之间的字符串，这些特殊的字符串也被称作文档注释（documentation comment），后面还会出现更多类似的东西。

3. 重复键入ex25。是很烦的一件事情。有一个捷径就是用from ex25 import*的方式导入模块。这相当于说：“我要把ex25中所有的东西导入进来。”程序员喜欢说这样的倒装句。开启一个新的会话，看看所有的函数是不是已经在那里了。

• 所有的函数全都被导入进来，即时可用，不需要每次键入ex25

• 行1的*个人理解为序列解包用法，实质是指将ex25中的每个内容都导入进来

>>> from ex25 import *
>>> sentence = "All good things come to those who wait."
>>> words = break_words(sentence)
>>> words
['All', 'good', 'things', 'come', 'to', 'those', 'who', 'wait.']
>>> sorted_words = sort_words(words)
>>> sorted_words
['All', 'come', 'good', 'things', 'those', 'to', 'wait.', 'who']
>>> print_first_word(words)
All
>>> print_last_word(words)
wait.
>>> words
['good', 'things', 'come', 'to', 'those', 'who']
>>> print_first_word(sorted_words)
All
>>> print_last_word(sorted_words)
who
>>> sorted_words
['come', 'good', 'things', 'those', 'to', 'wait.']
>>> sorted_words = sort_sentence(sentence)
>>> sorted_words
['All', 'come', 'good', 'things', 'those', 'to', 'wait.', 'who']
>>> print_first_and_last(sentence)
All
wait.
>>> print_first_and_last_sorted(sentence)
All
who
>>>

4. 试着将代码文件分解，看看 Python使用你的代码文件时是怎样的状况。如果要重新加载代码文件，你必须先用quit（）退出 Python。

对代码做适当处理，将直接打印变量改成利用print()函数打印变量，就可以查看python如何使用代码文件

• 在进行这一步操作时发现了一个很有趣的现象，嗯，起码对我来说是的

  • 当代码直接添加到ex25中而不是另外新建一个文件的话

  • from ex25 import * 这句代码会让文件重复运行两次

  • import ex25 也会造成这个现象

  • 以这句代码本身为分界线，先重复运行该代码以前的代码两次，再重复运行该代码之后的代码两次

  • 我仔细想了想，过程应该如下：

    ​ 在powershell中使文件运行，至import语句所在的位置，这段过程表现为“第一次运行该代码以前的代码”；然后将ex25作为包导入，也会运行整段代码，这段过程表现为“第二次运行该代码以前的代码” + “第一次运行该代码之后的代码”；之后继续在powershell里运行文件，则表现为“第二次运行该代码之后的代码”。

    ​ 解释完毕！开心！o(￣▽￣)ブ