Python程序笔记20230301

2023-04-11 11:34 由 Tauseer 发表于 #后端开发

打印九九乘法表

for i in range(1, 10):
    for j in range(1, i+1):
        print(i, "x", j, "=", i * j, end=' ')
    print("\n")

第三行的 print(i, "x", j, "=", i * j, end=' ') 打印出 i 和 j 的乘积，并在末尾添加一个空格，以便下一个数字可以与其对齐。第四行的 print("\n") 打印一个换行符，以便下一行可以开始打印。

range() 函数的结束值是不包括在范围内的，range(1, 10) 将生成从1到9的数字，但不包括10。

生成从0到5的整数序列：range(6)
生成从2到10的偶数序列：range(2, 11, 2)
生成从10到1的倒序整数序列：range(10, 0, -1)

多种 Hello World

if __name__ == '__main__':
    str_list = ["Hello,","World!"]
    str1 = "Hello,"
    str2 = "World!"
    print("Hello,"+"World!")
    print(''.join(str_list))
    print(str1+str2)
    print('str1'+'str2')

if __name__ == '__main__' 是 Python 中一个常用的条件语句，其作用是检查当前模块是否被直接运行（作为主程序），还是被导入到其他模块中使用。

当一个 Python 文件被执行时，Python 解释器会把该文件作为主程序执行，此时 __name__ 变量的值为 '__main__'。
如果一个Python文件被其他文件导入并使用，__name__变量的值则为该文件的模块名（不包括.py扩展名）。

因此，通过在 Python 代码中使用 if __name__ == '__main__': 条件语句，我们可以在代码中添加一些只有在该模块作为主程序运行时才会执行的代码块，而在该模块被导入到其他模块中时，这些代码块不会被执行。这种做法可以提高代码的复用性和可维护性，也可以避免在模块被导入时产生意外的副作用。

编程语言简史

历史上有很多编程语言，他们在编程语言发展的过程中都起到过重要的作用。

下面的 Python 数组包含了历史上的大部分编程语言。

languages = ["Regional Assembly Language","Autocode","FORTRAN","IPL (LISP的先驱)","FLOW-MATIC (COBOL的先驱)","COMTRAN (COBOL的先驱)","LISP","ALGOL 58","FACT (COBOL的先驱)","COBOL","APL","Simula","SNOBOL","CPL (C的先驱)","BASIC","PL/I","BCPL (C的先驱)","Logo","Pascal","Forth","C语言","Smalltalk","Prolog","ML","Scheme","SQL","Ada","C++","Common Lisp","MATLAB","Eiffel","Objective-C","Erlang","Perl","Tcl","FL (Backus)","Haskell","Python","Visual Basic","HTML","Ruby","Lua","CLOS (part of ANSI Common Lisp)","Java","Delphi (Object Pascal)","JavaScript","PHP","REBOL","D","C#","Visual Basic .NET","F#","Scala","Factor","Windows PowerShell","Rust","Clojure","Go"]

下面的 Python 数组包含了这些编程对应的创建时间。

years = [1951, 1952, 1954, 1954, 1955, 1957, 1958, 1958, 1959, 1959, 1962, 1962, 1962, 1963, 1964, 1964, 1967 ,1968 ,1970 ,1970 ,1972 ,1972 ,1972 ,1973 ,1975 ,1978 ,1980 ,1983 ,1984 ,1984 ,1985 ,1986 ,1986 ,1987 ,1988 ,1989 ,1990 ,1991 ,1991 ,1991 ,1993 ,1993 ,1994 ,1995 ,1995 ,1995 ,1995 ,1997 ,1999 ,2001 ,2001 ,2002 ,2003 ,2003 ,2006 ,2006 ,2007 ,2009]

编写一个 Python 程序，每行打印每个编程语言的名字和对应的创建时间，例如：

Regional Assembly Language : 1951
Autocode : 1952
FORTRAN : 1954
...

补全代码分析

if __name__ == '__main__':
    languages = ...
    years = ...
    i = 0
    while i < len(years):
        language = languages[i]
        year = years[i]
        print(language, ':', year)
        i += 1

if __name__ == '__main__':
    languages = ...
    years = ...
    [print(languages[i], ':', years[i]) for i in range(0, len(languages))]

if __name__ == '__main__':
    languages = ...
    years = ...
    for i in range(0, len(languages)):
        language = languages[i]
        year = years[i]
        print(language, ':', year)

第三段代码更好一些，因为它使用了更为 Pythonic 的方式来遍历两个列表。具体来说，它使用了 Python 中常用的 for-in 循环语句，而不是使用 while 循环或列表推导式来实现。

相比于第一段代码，第三段代码使用了更简洁的语法，同时也更易读。使用 for-in 循环可以直接遍历列表中的元素，而不需要额外的计数器变量。此外，使用 range() 函数生成一个整数序列的方式更为常见，也更易于理解。

相比于第二段代码，第三段代码也更为传统，更易于理解。使用列表推导式可以让代码更为紧凑，但在某些情况下可能会牺牲可读性，尤其是当列表推导式中嵌套了复杂的表达式时。而使用 for-in 循环则可以让代码更加自然地表达遍历两个列表的逻辑，也更容易理解和维护。

编程语言发明家

每个编程语言都有其内在的编程范式，体现着编程语言设计者的哲学。编程语言发展史上有许多杰出的人物。下面是一些例子：

programmers = [
  "约翰·巴科斯(JohnWarnerBackus), 创建了Fortran语言",
  "阿兰·库珀(Alan Cooper), 开发了Visual Basic语言",
  "詹姆斯·高斯林(James Gosling), 开发了Java语言",
  "安德斯·海尔斯伯格(Anders Hejlsberg), 开发了Turbo Pascal、Delphi、C#以及TypeScript",
  "丹尼斯·里奇(Dennis MacAlistair Ritchie), 发明了C语言",
  "比雅尼·斯特劳斯特鲁普(Bjarne Stroustrup), 他以创造C++编程语言而闻名，被称为“C++之父”",
  "吉多·范罗苏姆(Guido van Rossum), 创造了 Python"
]

为了进一步对上述文本数据解析，获得如下格式的结构化信息：

[
    {"name_cn": "约翰·巴科斯", "name_en": "JohnWarnerBackus", "achievement": "创建了Fortran语言"}, 
    {"name_cn": "阿兰·库珀", "name_en": "Alan Cooper", "achievement": "开发了Visual Basic语言"},
    ...
]

我们先分析一个例子，解析这个文本数据："吉多·范罗苏姆(Guido van Rossum), 创造了 Python"。

首先，定义一个函数 parse_parts，通过第一个逗号，拆分出发明家的名字信息和成就信息。
其次，定义一个函数 parse_name，通过对name的进一步拆分，获得发明家的中英文名字信息。
最后，定义一个函数 parse_creators，完成解析。

完整的代码模版如下：

def parse_parts(creator):
    index = creator.find(',')
    name, achievement = creator[0:index], creator[index+1:]
    return name.strip(), achievement.strip()

def parse_name(name):
    index = name.find('(')
    name_cn, name_en = name[0:index], name[index:]
    name_en = name_en[1:len(name_en)-1]
    return name_cn, name_en

def parse_creators(creators):
    # TODO(YOU): 请在此处正确实现

if __name__ == '__main__':
    creators = ...
    profiles = parse_creators(creators)
    print(profiles)

前面结构分析

def parse_parts(creator):  
    index = creator.find(',')  
    name, achievement = creator[0:index], creator[index+1:]  
    return name.strip(), achievement.strip()

这段 Python 代码定义了一个名为 parse_parts 的函数，它接收一个字符串类型的参数 creator，这个参数是由一个名字和成就组成的字符串，中间由逗号分隔。函数返回一个包含两个元素的元组，第一个元素是名字，第二个元素是成就，都去掉了开头和结尾的空格。

具体的实现过程如下：

使用字符串方法 find() 查找逗号在字符串 creator 中的位置，并返回它的索引。
使用字符串切片的方式，将名字和成就从 creator 中分离出来。这里使用逗号的索引将字符串 creator 分成了两个部分，前面的部分是名字，后面的部分是成就。
使用字符串方法 strip() 将名字和成就的开头和结尾的空格去掉。
将名字和成就组成一个元组并返回。

例如，如果creator是"张三, 中国科学院院士"，那么函数返回(“张三”, “中国科学院院士”)。

strip() 函数的作用是移除字符串头尾指定的字符（默认为空格或换行符）或字符序列。例如，如果 s 是" hello world “，那么s.strip()返回"hello world”，去除了首尾的空格。如果 s 是"000123000"，那么s.strip(‘0’)返回"123"，去除了首尾的0。

def parse_name(name):  
    index = name.find('(')  
    name_cn, name_en = name[0:index], name[index:]  
    name_en = name_en[1:len(name_en)-1]  
    return name_cn, name_en

这段 Python 代码定义了一个名为 parse_name 的函数，用于解析程序员的名字。下面是代码的详细解释：

def parse_name(name):：定义函数 parse_name，它接收一个名字字符串 name 作为参数。
index = name.find('(')：查找名字字符串中左括号 ( 的位置，返回其索引值，赋值给变量 index。
name_cn, name_en = name[0:index], name[index:]：使用括号中的索引值 index 将名字字符串分割为中文名和英文名两部分，中文名存储在变量 name_cn 中，英文名存储在变量 name_en 中。
name_en = name_en[1:len(name_en)-1]：将英文名字符串的第一个字符和最后一个字符（即左右括号）去除，得到真正的英文名。
return name_cn, name_en：返回名字的中文名和英文名，用元组的形式返回。

例如，如果 name 是"张三(Sam)"，那么函数返回(“张三”, “Sam”)。

补全代码分析

def parse_creators(creators):
    profiles = []
    for creator in creators:
        name, achievement = parse_parts(creator)
        name_cn, name_en = parse_name(name)
        profiles.append({ 'name_cn': name_cn, 'name_en': name_en, 'achievement': achievement })
    return profiles

这段 Python 代码实现了一个函数 parse_creators，该函数接收一个字符串列表 creators 作为参数，每个字符串都代表了一个编程语言创始人的姓名和成就，函数的作用是将这些字符串解析成字典类型的数据，并将这些字典组成的列表作为函数的返回值。

具体而言，函数中使用了一个for循环，对于每个字符串creator，首先调用parse_parts函数将其解析成姓名和成就两个部分，然后调用parse_name函数将姓名解析成中文名和英文名两个部分，最后将中英文姓名和成就组成一个字典，并将该字典添加到profiles列表中。最终，函数返回这个列表，其中包含了所有编程语言创始人的信息。

append() 函数是 Python 列表中的一种方法，用于在列表末尾添加元素。在上面的代码中，profiles 列表通过 append() 方法向其末尾添加字典元素，每个字典元素包含了一个编程语言的创建者的名字、成就和中英文名字。每次循环迭代时，都会创建一个新的字典元素，并将其添加到 profiles 列表中，最终返回一个包含所有编程语言创建者信息的列表。

append() 函数的作用是在列表的末尾添加一个新的元素。例如，如果 a 是[1, 2, 3]，那么a.append(4)会使 a 变成[1, 2, 3, 4]。注意，append()函数没有返回值，但是会修改原来的列表。

def parse_profile(creator):
    name, achievement = parse_parts(creator)
    name_cn, name_en = parse_name(name)
    return { 'name_cn': name_cn, 'name_en': name_en, 'achievement': achievement }

def parse_creators(creators):
    return [ parse_profile(creator) for  creator in creators]

这里的列表解析式 [ parse_profile(creator) for creator in creators] 将 parse_profile(creator) 应用于 creators 列表中的每个元素 creator，并将解析结果组成一个新的列表。这种写法更加简洁明了，避免了使用循环语句的繁琐。

def parse_profile(creator):
    name, achievement = parse_parts(creator)
    name_cn, name_en = parse_name(name)
    return { 'name_cn': name_cn, 'name_en': name_en, 'achievement': achievement }

def parse_creators(creators):
    profiles = []
    for creator in creators:
        profile = parse_profile(creator)
        profiles.append(profile)
    return profiles

使用了列表推导式，将 for 循环和列表追加合并为一行代码，使得代码更加简洁和可读性更高。此外，它也更加函数化，将创建每个开发者简介的过程分离到单独的函数中，提高了代码的可维护性和可扩展性。

热门相关：骑士归来素描少女仗剑高歌仗剑高歌别那么骄傲