Python学习笔记（初识Python）

Python概念学习，初步认识什么是Python。Python目前已经是世界上最流程最易学的编程语言之一。左右的主流操作系统和计算机都可以运行Python，可将其用于从搭建网络服务器到创建桌面应用等所有领域。

Python学习笔记（初识Python）

• 第一部分 编程简介
  • 第1章 初识Python概念
    • 什么是编程？
      • 编程（programming）指的是编写让计算机执行的指令。
      • 让计算机执行的指令被称为代码（code）。
    • 什么是Python？
      • Python是一门开源编程语言，有荷兰程序员吉多·范·罗苏姆发明。
      • Python目前已经是世界上最流程最易学的编程语言之一。左右的主流操作系统和计算机都可以运行Python，可将其用于从搭建网络服务器到创建桌面应用等所有领域。
    • 交互式shell
      • Python自带了一个叫IDLE的程序，全称是交互式开发环境。我们将在IDLE中输入Python代码。
      • IDLE这个程序被称为交互式shell。可以直接在其中键入Python代码，程序就会打印出结果。
    • 文本编辑器
      • 启动IDLE应用，点击“文件”选择“创建新文件”，会打开一个文本编辑器。
      • 文本编辑器中可以编写代码，可以保存以便之后运行。
      • 文本编辑其与交互式shell的区别
        • 1.文本编辑器更适合希望保存并编辑的程序。如果在交互式shell中键入的代码有误，导致出错，就必须重新输入所有的代码。而使用文本编辑器则只用纠正并重新运行即可。
        • 2.是从文件运行程序与从交互式shell运行程序的输出会略有不同。请注意是从哪里运行的程序。
    • 术语表
      • 编程：编写让计算机执行的命令。
      • 代码：程序员编写的、让计算机执行的指令。
      • 底层编程语言：与高级编程语言（读起来更像英语的编程语言）相比，更接近用二进制（0和1）编写指令的编程语言。
      • 汇编语言：一种很难月度的编程语言。
      • 高级编程语言：一种读起来比底层编辑语言更像英语的编程语言。
  • 第2章 编程概述
    • 注释（comment）：使用英文或其他自然语言写的一行（或一部分）代码，行首均有一个特殊标志告知变成语言忽略这行代码。Python用#来创建注释。
      • 注释的目的是解释代码的功能。
      • 只有在代码中执行特别操作，或者代码不清晰易懂的情况下，才需要写注释。
    • 打印（print），程序可以打印任何内容，只要记得加上双引号。
    • 代码行：Python程序是由一行一行的代码组成的。
      • 我们通常用代码所在的行数区别代码。
      • 在IDLE中，可以打开“编辑”菜单，选择“前往行”按钮，即可跳转至程序的指定行。
      • 在交互式shell中，一次只能输入一行代码，无法复制粘贴多行代码。
      • 有时一段代码比较长，超过了一行，可以用三引号、圆括号、方括号或者大括号扩展至新一行。
      • 还可以使用反斜杠\对代码进行换行。
    • 关键字：Python等编程语言中的一些具备特殊意义的字。
    • 间距：缩进可以告诉Python解释器代码块的开始与结束。Python中的缩进距离，都是4个空格符。
    • 数据类型
      • Python将数据划分成不同的类别，即数据类型（data type）。
        • 字符串（str，string的缩写），字符串是由引号包括的一个或多个字符组成的序列。
        • 整型数据（int，全程为integer），整数数据。
        • 浮点数（float，floating-point number），小数（带小数点的数字）的数据类型。
        • 布尔值（bool，boolean），仅有True和False两个值。
        • None Type，其值永远为None，用来表示数据缺失。
      • 在Python中，每一个数据值，被称为对象（object）。
        • 可以把对象看做拥有3个属性的数据值
          • 唯一标识：指的是在计算机内存中的地址，该地址不会变化。
          • 数据类型：是对象所属的数据类别，这决定了对象的属性，也不会变化。
          • 值：表示对象的数据。
    • 常量和变量
      • 常量（constant）是一个永远不会改变的值。
      • 变量（variable）指的是会改变的值。
        • 变量由一个或多个字符组成的名称构成，并使用赋值符（assignment operator）等号赋予了这个名称一个值。
        • 变量命名4条原则
          • 1.变量名不能包含空格符。如果想在变量名中使用两个单词，可以在中间加入下划线。
          • 2.变量名只能使用特定的字母、数字和下划线。
          • 3.变量名不能以数字开头。
          • 4.不能使用Python关键字作为变量名。
    • 语法（syntax）指的是规范一门语言中句子结构，尤其是字词顺序的一套规则及流程。
    • 错误与异常
      • Python中的两种错误：语法错误和异常。
    • 算数操作符
      • Python将操作符（operator）分为多个类型，用于简单的算数计算是算术操作符。
  • 第3章 函数
    • 函数（function）：可接受输入，执行指令并返回输出的复合语句。
    • 调用（call）一个函数，意味着为函数提供执行指令并返回输出所需的输入。
    • 参数（parameter）：函数的每一个输入就是一个参数。当你为函数提供参数时，则被称为“函数传参”。
      • 必选参数（required parameter）：当用户调用函数时，必须传入所有必选参数，否则Python将报告异常错误。
      • 可选参数（optional parameter）：函数只有在需要时才会传入，并不是执行程序所必须的。如果没有传入可选参数，函数将使用其默认值。
    • 定义函数：在Python中创建一个函数，需要选择函数名，并定义其参数、行为和返回值。
      • 函数名：关键字def告诉Python操作者正在定义一个函数。
        • 在def关键字后面，指定函数的名称，名称选择遵循与变量名相同的规则。
          • 按惯例，函数名不应使用大写字母，单词用下划线分隔：like_this。
      • 参数：命名函数之后，在名称后加上一对圆括号，圆括号中则是希望函数接受的参数。
        • 函数可以有一个或多个参数，也可以不接受任何参数。如果定义不需要参数的函数，只需要在定义函数时把圆括号内置为空即可。
      • 定义：在圆括号之后加入冒号，然后换行并缩进4个空格符。冒号之后所有缩进4个空格符的代码，就是函数的定义。
      • 返回值：关键字return指定了调用函数时输出的值，我们称之为函数的返回值。
        • 如果后面在程序中有需要使用函数返回值的地方，建议将函数的返回值保存到一个变量中。
        • 函数必须包含return语句。如果函数没有return语句，则会返回None。
      • 语法：可以使用语法“[函数名]（[逗号分隔的参数])”来调用一个函数。
    • 内置函数：Python编程语言中自带了一个被称为内置函数（builtin function）的函数库，它可以自行各式各样的计算和任务，而不需要任何额外的工作。
      • len内置函数，表示返回对象的长度，如字符串的长度（字符的数量）
      • str内置函数，str接受一个对象作为参数，并返回一个数据类型为str的新对象（字符串）
      • int内置函数，可接受一个对象作为参数，并返回一个整型对象（整数）
      • float内置函数，可接受一个对象作为参数，并返回一个浮点数对象（小数）
      • 注：
        • 传给str、int或float函数的参数，必须要能够转换为字符串、整数或浮点数。
        • str函数可接受大部分对象作为参数，但是int函数只能接受内容为数字的字符串或浮点数。float函数只能接受内容为数字的字符串或整型对象。
      • input内置函数，手机用户信息，接受一个字符串作为参数，并将其展示给使用该程序的用户。
        • 用户在shell中输入回答，程序将回答保存在变量中。
    • 复用函数：函数不仅可以用于计算并返回值，还可以封装我们希望服用的功能。
      • 因为可以对函数进行复用，所以利用函数可以减少代码量。
      • 新程序的功能与前一个程序完全相同，但是由于将功能封装在了一个可随时按需调用的函数中，代码量大幅减少，可读性提高。
    • 作用域（scope）：变量的一个很重要属性。
      • 定义变量时，其作用域指的是哪部分程序可以对其进行读写。
      • 变量的作用域由其定义在程序中所处的位置决定。
        • 在函数或类之外定义一个变量
          • 全局作用域（global scope）：即在程序中任意地方都可以对其进行读写操作。
          • 全局变量（global variable）：带有全局作用域的变量。
        • 在函数或类内部定义一个变量
          • 局部作用域（local scope）：即程序只有在定义该变量的函数内部才可对其进行读写。
          • 局部变量（local variable）：带有局部作用域的变量。
          • 在局部作用域中需稍加注意：必须明确使用global关键字，并在其后协商希望修改的变量。
    • 异常处理：支持测试错误条件，在错误发生时捕获异常，然后决定如何处理。
      • try从句：包含可能会发生的错误。
      • except从句：包含仅在错误发生时执行的代码。
      • 注意：不要在except语句中使用try语句定义的变量。
    • 文档字符串（docstring）：用于解释函数功能，记录所需的参数类型。
  • 第4章 容器
    • 方法（method）
      • 方法是与指定数据类型紧密相关的函数。
      • 方法与函数一样，可以执行代码并返回结果。
      • 与函数不同点：只有在对象上才能调用方法。
      • 可以传递参数给方法。
    • 容器1：列表（list）
      • 概念：列表（list）是以固定顺序保存对象的容器。
      • 表示方法：列表（list）用方括号（[ ]）表示。
      • 创建列表语法：
        • 使用list函数创建空列表。
          • 示例： fruit = list( )
        • 直接使用方括号（ [ ] ）。
          • 示例： fruit = [ ]
        • 列表中如有对象填入，须用逗号分隔。
          • 示例： fruit = ["apple","orange","pear"]
      • 列表的特点
        • 列表中的元素是有序的
          • 除非重新调整列表中元素的顺序，否则列表中元素的顺序是固定的。
          • 可以使用append方法想列表中添加一个新元素，但append方法永远是将新元素添加至列表的末尾。
            • 示例： fruit = ["Apple","Orange","Pear"] fruit.append("Banana") fruit.append("Peach") print(fruit) >>['Apple','Orange','Pear','Banana','Peach']
          • 列表中元素的索引，第一个元素的索引是0，而不是1。
        • 列表可以保存任意数据类型。
        • 列表是可变的（mutable）。 如果一个容器是可变的，则可以向该容器中增删对象。
          • 将列表中某个元素的索引赋给一个新对象，即可改变该元素。
            • 示例： colors = ["blue","green","yellow"] print(colors) colors[2] = "red" print(colors) >>['blue','green','yellow'] >>['blue','green','red']
          • 也可以使用pop方法移除列表中的最后一个元素。
            • 示例： colors = ["blue","green","yellow"] print (colors) item = colors.pop( ) print (item) print (colors) >>['blue','green','yellow'] >>'yellow' >>'blue','green']
            • 不能对空列表使用pop方法。
          • 可以使用加法操作符来合并两个列表
            • 示例： colors1 = ["blue", "green", "yellow"] colors2 = ["orange", "pink", "black"] colors1 + colors2 >> ['blue', 'green', 'yellow', 'orange', 'pink', 'black']
          • 可以使用关键字in检查某个元素是否在列表中
          • 可以使用关键字not检查某个元素是否不在列表中
          • 使用函数len可获得列表的大小（包含元素的个数）
    • 容器2：元祖（tuple）
      • 概念：元祖（tuple）是存储有序对象的一种容器。
      • 表示方法：用圆括号表示元祖，且必须用逗号分隔元祖中的元素。
      • 创建元祖语法：
        • 使用tuple函数
          • 示例： my_tuple = tuple( )
        • 直接使用圆括号
          • 示例： my_tuple = ( )
        • 即使元祖中只有一个元素，也需要在该元素的后面加上逗号。
      • 元祖（tuple）的特点：
        • 创建元祖只有，不能在新增元素或修改已有元素。
        • 可使用与列表一样的方法来获取元祖的元素，即引用其索引：
          • 示例： dys = ("1984","Brave New World","Fahrenheit 452") dys[2] >>'Fahrenheit 451'
        • 可使用关键字in来检查某个元素是否在元祖中。
        • 可在in致歉加上关键字not检查元素是否不存在元祖中。
      • 元祖（tuple）用途：在处理明确永远不会改变的，并且也不希望其他程序对其进行修改的值时，元祖是非常有用的。
    • 容器3：字典（dictionary）
      • 概念： 字典（dictionary）是另一种勇于存储对象的内置容器。它们被用来链接键（key）和值（value）这两个对象。 将一个对象链接至另一个对象，也被称为映射（mapping），结果为产生一个键值对（key-value pair）。 可将键值对添加到字典，然后使用键在字典中查询，可获得其对应的值。但无法使用值来查询。
      • 表示方法：字典用花括号（ { } ）表示。
      • 创建字典的语法：
        • 使用dict函数创建
          • 示例： my_dict = dict( )
        • 直接使用花括号（{ }）创建
          • 示例： my_dict = { }
        • 可以在创建字典时直接添加键值对。上述两种语法都要求用冒号分隔键与值，每个键值对之间用逗号分隔。
          • 示例： fruit = {"Apple":"Red","Banana":"Yellow"}
      • 字典的特点：
        • 字典的键是无需的。
        • 字典时可变的。 创建字典后，可通过语法”[字典名] [[键]]"添加新的键值对，并通过语法"[字典名] [[键]]"查找值。
          • 示例： facts = dict ( ) #添加键-值对 facts ["code"] = "fun" print (facts["code"]) #添加键-值对 facts ["Bill"] = "Gates" #查找键对应的值 print (facts ["Bill"]) #添加键-值对 facts ["founded"] = 1776 #查找键对应的值 print (facts ["founded"])
        • 字典的值可以是任意对象。但是字典的键必须是不可变的。字符串或元祖都可以做字典的键，但是列表或字典不可以。
        • 可以使用关键字检查某个键是否在字典中，但不能用其检查某个值是否在字典中。
          • 示例： bill = dict ({"Bill Gates":"charitable"}) print("Bill Gates" in bill)
        • 在关键字in之前加上关键字not，可检查键是否不在字典中。
        • 使用关键字del删除字典中的键值对。
          • 示例： books = {"Dracula":"Stoker", "1984":"Orwell", "The Trial":"Kafka"} print(books) del books["The Trial"] print (books)
      • 使用字典的程序示例：
        • rhymes = {"1":"fun", "2":"blue", "3":"me", "4":"floor", "5":"live" } n = input("Type a number:") if n in rhymes: rhymes = rhymes[n] print(rhymes) else: print("Not found.")
    • 容器嵌套容器
      • 可以在容器中存储容器。
    • 术语表
      • 方法：与制定数据类型紧密相关的函数。
      • 列表：存储有序对象的一种容器。
      • 可迭代的：如果可使用循环访问对象中的每一个元素，则该对象是可迭代的。
      • 可迭代对象：可迭代的对象，如字符串、列表和元素。
      • 索引：代表元素在可迭代对象中位置的数字。
      • 可变的：容器中的内容可以发生变化。
      • 不可变的：容器中的内容不能改变。
      • 字典：存储对象的一种内置容器，将一个称为键的对象，映射至一个称为值的对象。
      • 键：用来查找字典中对应的值。
      • 值：字典中映射至键的值。
      • 映射：将一个对象链接至另一个对象。
      • 键值对：字典中键映射至值。
  • 第5章 字符串操作
    • 5.1 三引号字符串
      • 如果字符串跨越一行以上，可以使用三引号。
      • 如果使用单引号或双引号定义一个跨行的字符串，Python会报告语法错误。
    • 5.2 索引
      • 与列表和元祖一样，字符串也是可以迭代的。
      • 字符串中第一个字符所在的索引为0，其后每个索引递增1。
      • Python还支持使用负索引（negative index）查找列表中的元素：可用来从右向左查找可迭代对象中元素的搜一年（必须是一个负数）。
    • 5.3 字符串是不可变的
      • 字符串和元祖一样都是不可变的，无法修改字符串中的字符。
      • 如果想要修改，就必须创建一个新的字符串：
        • 示例： ff = "F.Fitzgerald" ff = "F. Scott Fitzgerald"
    • 5.4 字符串拼接
      • 可使用加法操作符，将两个或多个字符串组合在一起，结果就是由第一个字符串中的字符和其他字符串中的字符共同构成的一个新字符串。
        • 示例： "cat"+"in"+"hat"
    • 5.5 字符串乘法
      • 可使用乘法操作符，将字符串与数字相乘。
        • 示例： “Sawyer" * 3 >>SawyerSawyerSawyer
    • 5.6 改变大小写
      • 可使用字符串的upper方法，将字符串中的每个字符改为大写。
        • 示例： "We hold these truths...".upper( ) >>'WE HOLD THESE TRUTHS...'
      • 可使用字符串的lower方法，将字符串中的每个字符改为小写。
        • 示例： "SO IT GOES.".lower( ) >>'so it goes.'
      • 可使用字符串的capitalize方法，将字符串的首字母改为大写。
        • 示例： "four scour and ...".capitalize( ) >>"Four scour and ..."
    • 5.7 格式化
      • 可使用format方法创建新字符串，该方法会把字符串中的“{ }"替换为传入的字符串。
        • 示例： "William { }".format("Faulkner") >>"William Faulkner"
      • 也可以使用format方法把变量作为参数传递：
        • 示例： last = "Faulkner" "William { }".format(last) >>"William Faulkner"
      • 花括号（{ }）可以重复使用：
        • 示例： author = "William Faulkner" year_born = "1897" "{ } was born in { }."format.(author , year_born) >>"William was born in 1897."
      • 如果要根据用户输入来创造字符串，format方法很有用：
        • 示例： n1 = input("Enter a noun:") v = input("Enter a verb:") adj = input("Enter a adj:") n2 = input("Enter a noun:") r = """The { } { } the { } { } """.format(n1, v, adj, n2) print(r) >> Enter a noun:
    • 5.8 分割
      • split的方法，可用来将字符串分割为两个或多个字符串。
      • 需要传入一个字符串作为split方法的参数，并用其将原字符串分割为多个字符串。
        • 示例： "I jumped over the puddle. It was 12 feet!".split(".") >>["I jumped over the puddle","It was 12 feet!"]
      • 分割结果是一个含有两个元素的列表：分别是句号前的所有字符组成的字符串，以及句号后所有字符组成的字符串。
    • 5.9 连接
      • join方法可以在字符串的每个字符间添加新字符。
        • 示例： first_three = "abc" result = "+".join(first_three) print(result) >>"a+b+c"
      • join方法可以在空字符串上或包含空格符的字符串调用，传入一个字符串列表作为参数，从而将这些字符串连接为一个单一字符串。
        • 示例： words = ["The", "fox", "jumped", "over", "the", "fence", "."] one = "".join(words) ones = " ".join(words) print(one) print(ones) >>Thefoxjumpedoverthefence. >>The fox jumped over the fence .
    • 5.10 去除空格
      • 使用strip方法去除字符串开头和末尾的空白字符。
        • 示例： s = " The " s = s.strip() print(s) >>The
    • 5.11 替换
      • replace方法，第一个参数是要被替换的字符串，第二个参数是用来替换的字符串。可使用第二个字符串替换原字符串中所有与第一个字符串一样的内容。
        • 示例： equ = "All animals are equal." equ = equ.replace("a","@") print(equ)
    • 5.12 查找索引
      • 可使用index方法，获得字符串中某个第一次出现的索引。
      • 将希望查找的字符作为参数传入，index方法可以返回该字符串中第一次出现的索引：
        • 示例： print("animals".index("m")) >>3
      • 如果不确定是否有匹配的结果，可使用如下异常处理的方法：
        • 示例： fruits = ["pear","apple","banana","peach","grape"] n = input("Enter a fruit name:") #尝试查找输入的水果名称检索 try: print(fruits.index(n)) except: print("Not found") >>Enter a fruit name:banana >>2
    • 5.13 in关键字
      • 关键字in可检查某个字符串是否在另一个字符串中，返回结果为True或False：
        • 示例： print("Cat" in "Cat in the hat.")
      • 在in前面加上关键字not，即可检查某个字符串是否不在另一个字符串中。
    • 5.14 字符串转义
      • 字符串转义（escaping），指的是在Python中有特殊意义的字符前加上一个符号，告诉Python在本例中该符号代表的是一个字符，而没有特殊意义。
      • 在Python中用反斜杠进行转义。
    • 5.15 换行符
      • 在字符串中加入\n来表示换行：
        • 示例： print("line1\nline2\nline3") >>line1 >>line2 >>line3
    • 5.16 切片
      • 切片（slicing）可将一个可迭代对象中的元素的子集，创建为一个新的可迭代对象。
        • 示例： fict = ["Tolstoy", "Camus", "Orwell", "Huxley", "Austin"] print(fict[0:3]) >>['Tolstoy', 'Camus', 'Orwell']
      • 语法：[可迭代对象】[[起始索引：结束索引]]
        • 起始索引（start index）是开始切片的索引。
        • 结束索引（end index）是结束索引的位置。
      • 注意：1.切片是包含起始索引位置的元素，但不包括结束索引位置的元素； 2.如果起始索引是0，那么可以将起始索引的位置留空； 3.如果结束索引是可迭代对象中最后一个元素的索引，可以将结束索引的位置留空； 4.起始索引和结束索引均留空，则会返回原可迭代对象。
  • 第6章 循环
    • 循环的意义：直到代码中定义的条件满足时才会停止执行的代码。
    • 6.1 for循环
      • 语法：”for [变量名] in [可迭代对象名]：[指令]“
        • [变量名]：是计划赋给可迭代对象中每个元素值的变量名称；
        • [指令]：是每次循环要执行的代码。
      • 功能：
        • 遍历可迭代对象的循环。
          • 示例（使用for循环遍历列表元素）： shows = ["GOT", "Narcos", "vice"] for show in shows: print(show) >>GOT >>Narcos >>vice
        • 也可使用for循环修改可变且可迭代对象中的元素。
          • 示例： tv = ["GOT", "Narcos", "Vice"] i = 0 for show in tv: new = tv[i] new = new.upper() tv[i] = new i += 1 print(tv) >>['GOT', 'NARCOS', 'VICE']
        • 也可以使用for循环在可变可迭代对象之间传递数据。
          • 示例： tv = ["GOT","Narcos","Vice"] coms = ["Arrested","Development","friends","Always Sunny"] all_shows = [] for show in tv: show = show.upper() all_shows.append(show) for show in coms: show = show.upper() all_shows.append(show) print(all_shows) >>['GOT', 'NARCOS', 'VICE', 'ARRESTED', 'DEVELOPMENT', 'FRIENDS', 'ALWAYS SUNNY']
    • 6.2 range函数
      • range函数：和创建一个整数序列的内置函数。
      • 语法：
        • range函数接受两个参数：序列气势数字和结束数字。
        • range函数返回的整数序列包含从第一个参数到第二个参数之间（不含第二个参数）的所有整数。
      • 示例（使用range函数创建数字序列并遍历）： for i in range(1,11): print(i) >>1 ... >>9 >>10
    • 6.3 while循环
      • while循环：它是一种只要表达式的值为True就一直执行代码的循环。
      • 语法：”while [表达式]：[执行代码]“
        • “[表达式]”是决定循环是否继续进行的表达式。
        • “[执行代码]”则是只要循环继续就执行的代码。
      • 死循环（infinite loop)：如果定义的while循环的表达式求值永远为True，循环将不会停止执行。一个不会停止执行的循环也被称为死循环（infinite loop）。
    • 6.4 break 语句
      • break语句：可以用来终止循环。
      • 只要Python遇到break语句，循环就会终止。
        • 示例： qs = ["What is your name?", "What is your fav. color?", "What is your quest?"] n = 0 while True: print("Type q to quit") a = input(qs[n]) if a =="q": break n = (n+1)%3 >>Type q to quit >>What is your name?
          • 每次循环，程序都会问用户一个qs列表中的问题。 其中，n是索引变量。每次循环都会将表达式（n+1）%3的值赋给n，这可以让程序循环调用qs列表中的问题。
    • 6.5 continue 语句
      • continue语句：可使用带关键字continue的语句来终止循环的当前迭代，并进入下一次迭代。
        • 示例1： #通过for循环和continue语句实现“打印从1到5之间除了3以外的所有数字”。 for i in range (1,6): if i == 3: continue print(i) >>1 >>2 >>4 >>5
          • 当i的值等于3时，程序执行continue语句，但不会像break关键字那样让循环完全终止，而是会继续进行下一次迭代，跳过本应该执行的其他代码。 当i等于3时，Python会执行continue语句，而不是打印3。
        • 示例2： #通过while循环和continue语句实现“打印从1到5之间除了3以外的所有数字”。 i=1 while i <= 5: if i == 3: i += 1 continue print(i) i += 1 >>1 >>2 >>4 >>5
    • 6.6 嵌套循环
      • 嵌套循环：可以通过多种方式对循环进行组合。
        • 可以在一个循环里加入另一个循环，甚至在加入的循环里在加一个循环。
        • 循环中可嵌套的循环数量没有限制
        • 内部包含一个循环的循环称为外循环（outer loop）
        • 嵌套的循环称为内循环（inner loop）
        • 当存在嵌套循环时，外循环没遍历一遍，内循环就遍历一次其可迭代对象中的所有元素。
      • 示例： #使用两个for循环将一个列表中的所有数字，于另一个列表中的所有数字相加 list1 = [1,2,3,4] list2 = [5,6,7,8] added = [ ] for i in list1: for j in list2: added.append(i+j) print(added) >>[6, 7, 8, 9, 7, 8, 9, 10, 8, 9, 10, 11, 9, 10, 11, 12]
        • 对于第一个循环遍历列表list1中的每个整数，第二个循环遍历自身可迭代对象中的每个整数，并将其与list1中的数字相加，然后将结果添加至列表added。
    • 6.7 术语表
      • 循环：在代码中定义的条件为满足之前，将持续执行的一段代码。
      • 遍历：使用循环访问可迭代对象中的每个元素。
      • for循环：用来迭代字符串、列表、元祖或字典等可迭代对象的一种循环。
      • 索引变量：变量的值为代表可迭代对象中索引的一个数字。
      • while循环：只要表达式的值为True则持续执行的一种循环。
      • 死循环：永远都不会终止的循环。
      • break语句：带关键字break的语句，用来终止循环。
      • continue语句：带关键字continue的语句，用来终止循环的当前迭代，并进入到下一次迭代。
      • 外循环：内部包含嵌套循环的循环。
      • 内循环：嵌套在另一个循环中的循环。
  • 第7章 模块
    • 模块的意义：
      • 为了方便阅读及检查程序，将大型程序分割成多个包含Python代码的文件，称为模块（module）。
    • 7.1 导入内置模块
      • 导入（import）：使用模块之前，需要先导入模块，意味着要写代码，让Python直到从哪获取模块。
      • 导入语法：import[模块名]。
      • 导入模块之后，即可使用其中的变量和函数。
      • 内置模块（builtin module）：它是Python语言自带的，包含了许多重要的功能。
    • 7.2 导入其他模块
      • 创建模块
        • 在计算机创建一个新文件夹。在文件夹中，新建一个.py的Python文件，在.py的Python文件中添加代码并报村文件。
      • 导入（improt）同上
    • 7.3 术语表
      • 模块：含有代码的Python文件的别称。
      • 内置模块：Python语言中自带的模块，包含诸多重要的功能。
      • 导入：编写代码，告诉Python从哪导入计划使用的模块。
  • 第8章 文件
    • 8.1 写文件操作
      • 处理文件的第一步是使用Python内置的open函数打开文件。
      • open函数有两个参数：
        • 代表要打开文件路径的字符串。
          • 文件路径（file path），指的是文件在计算机中所处的位置。 例如/Users/bob/st.txt是文件st.txt的文件路径。 斜杠分割的每个单词都是一个文件夹的名称。
          • 如果文件路径中只有文件的名称（没有斜杠分割的文件夹），Python将会在当前运行程序所在的目录中查找文件。
          • 为避免程序在不同操作系统中运行出错，应使用内置的os模块来创建文件路径
            • os模块示例： import os os.path.join("Users","bob","st.txt") >>"Users/bob/st.txt
            • 使用path函数创建文件路径，可以确保其在任何早错系统中都可以正常运行。
        • 代表打开文件的模式。
          • 传入open函数的参数模式，决定了对打开的文件执行什么操作：
            • "r"以只读模式打开文件。
            • "w"以只写模式打开文件。 如果文件已存在，会覆盖文件。 如果文件不存在，则会创建一个新文件。
            • "w+"以可读可写模式打开文件。 如果文件已存在，会覆盖文件。 如果文件不存在，则会创建一个新文件。
        • open函数会返回一个叫文件对象（file object）的对象，可用来读/写文件。
        • 可使用文件对象的write方法写入文件，并通过close方法关闭文件。
          • 如果使用了open函数打开文件，就必须要通过close方法关闭。
    • 8.2 自动关闭文件
      • 使用with语句打开文件的语法是： ”with open([文件路径]),[模式]) as [变量名]:[执行代码]“
        • 【文件路径】代表文件所在的位置
        • 【模式】代表以何种模式打开文件
        • 【变量名】代表文件对象被赋予的变量名
        • 【执行代码】则是需要访问文件对象变量的代码
      • 示例： with open ("st.txt","w") as f : f.write("Hi from Python!")
      • 只要还在with语句内，就可以访问文件对象。
    • 8.3 读取文件
      • 如果要读取文件，可传入"r"作为open函数的第二个参数。然后调用文件对象的read方法，会返回一个包含文件所有行的可迭代对象。
    • 8.4 CSV文件
      • CSV文件的后缀为.csv，它使用英文逗号来分割数据（CSV是逗号分隔值的英文简写）。
      • 需要管理如Excel等报表软件的程序员经常使用CSV文件。
      • CSV文件中用逗号分隔的每个数据代表报表中的一个单元格，每行代表一个报表行。
      • 分隔符（delimiter）是CSV文件中用来分割数据的符号，如逗号或竖线"|"。
    • 8.5 术语表
      • 读取：访问文件的内容。
      • 写：添加或修改文件中的数据。
      • 文件路径：文件在计算机中存储的位置。
      • with语句：一种复合语句，当Python退出语句时会自动执行一个操作。
      • 文件对象：可用来读写文件的对象。
      • CSV文件：后缀为.csv的文件，使用逗号分隔数据。常用在管理报表的程序中。
      • 分隔符：用来分割CSV文件中数据的符号，如逗号。
• 第二部分 面对对象编程简介
  • 第9章 编程范式
    • 编程范式（program paradigm），即编程风格。
    • 9.1 状态
      • 不同编程范式之间的根本区别之一，就是对状态（state）的处理。
      • 状态，是程序运行时其内部变量的值。
      • 全局状态（global state）是程序运行时其内部全局变量的值。
    • 9.2 过程式编程
      • 过程式编程（procedural programming）：这种编程风格要求你编写一系列补助来解决问题，每步都会改变程序的状态。
      • 在过程式编程时，我们将数据存储在全局变量中，并通过函数进行处理。
      • 由于将程序的状态都保存在全局变量中，如果程序慢慢变大就会碰到问题。
        • 可能会在多个函数中使用全局变量，很难记录都有哪些地方对一个全局变量进行了修改。会严重破坏程序的数据准确性。
        • 随着程序越来越复杂，全局变量的数量也会逐渐增多，再加上程序需要不断添加新的功能，也需要修改全局变量，这样程序很快就会变得无法维护。
      • 过程是编程的副作用（side effects），其中之一就是会改变全局变量的状态。
    • 9.3 函数式编程
      • 函数式编程（functional programming）：世界上最小的通用编程语言。
      • 函数式编程通过消除全局状态，解决了过程式编程中出现的问题。
      • 函数式程序员依靠的是不适用或不改变全局状态的函数，他们唯一使用的状态就是传给函数的参数。
      • 优缺点
        • 优点：在于它消除了所有由全局状态引发的错误（函数式编程中不存在全局状态）。
        • 缺点：即部分问题更容易通过状态进行概念化。
    • 9.4 面向对象编程
      • 面向对象（object-oriented）编程范式也是通过消除全局状态来解决过程式编程引发的问题，但并不是用函数，而是用对象来保存状态。
      • 类（class）定义了一些列相互之间可进行交互的对象。
        • 类是程序员对类似对象进行分类分组的一种手段。
        • 每个对象都是类的实例。
        • 在定义类时，该类的所有实例是类似的：都拥有类中定义的属性，但每个实例的具体属性值时不一样的。
        • 在Python中，类是一个复合语句，包含代码头和主体。
        • 语法：class【类名】：【代码主体】。
          • 【类名】是类的名称。
            • 惯例：Python中的类名都是以大写字母开头，且采用驼峰命名法。
              • 驼峰命名法：即如果类名由多个单词组成，每个单词的第一个字母都应该大写（如LikeThis，而不是用下划线分隔（函数的命名习惯））。
          • 【代码主体】是定义的类的具体代码。
            • 类中的代码主体可以是一个单一语句，或一个叫方法（method）的复合语句。
            • 方法类似于函数，但因为是在类中定义的，只能在类创建的对象上调用方法。
            • 方法的命名则遵循函数命名规则，都是小写，并用下划线分隔。
            • 方法的定义方式与函数定义方式区别：
              • 必须在类的内部定义方法；
              • 必须接受至少一个参数（特殊情况除外）。
              • 按照惯例，方法的第一个参数总是被命名为self。
              • 创建方法时，至少要定义一个参数，因为在对象上调用方法时，Python会自动将调用方法的对象作为参数传入。
    • 9.5 术语表
      • 编程范式：编程风格。
      • 状态：程序运行时其内变量的值。
      • 全局状态：程序运行时其内全局变量的值。
      • 过程式编程：该编程风格要求编写一系列步骤来解决问题，每一步都会改变程序的状态。
      • 函数式编程：函数式编程通过函数传递消除了全局状态，解决了过程式编程出现的问题。
      • 副作用：改变全局变量的值。
      • 面向对象：定义相互之间可交互的对象的编程范式。
      • 类：程序员对类似对象分类分组的一种手段。
      • 方法：类似函数，但其是在类中定义的，只能在类创建的对象上调用方法。
      • 实例：每个对象都是类的一个实例。类的每个实例与该类的其他实例拥有相同的数据类型。
      • 实例变量：属于对象的变量。
      • 魔法方法：Python在特殊情况下使用的方法，如对象初始化。
      • 类的实例化：使用类创建一个新对象。
  • 第10章 面向对象编程的四大支柱
    • 概念。
      • 面向对象编程有四大概念：
        • 封装
          • 封装（encapsulation）包含两个概念。
            • 第一个概念，在面向对象编程中，对象将变量（状态）和方法（用来改变状态或执行涉及状态的计算）集中在一个地方——即对象本身。
            • 第二个概念，指的是隐藏类的内部数据，以避免客户端（client）代码（即类外部的代码）直接进行访问。
        • 抽象
          • 抽象（abstraction）指的是“剥离事物的诸多特征，使其只保留最基本的特质”的过程。在面向对象编程中，使用类进行对象建模时就会用到抽象的技巧。
        • 多态
          • 多态（polymorphism）指的是“为不同的基础形态（数据类型）提供相关接口的能力”。接口，指的是函数或方法。
        • 继承
          • 编程语境中的继承（inheritance），与基因继承类似。在创建类时，该类也可以从另一个类那里继承方法和变量。
            • 被继承的类，成为父类（parent class）
            • 继承的类，被称为子类（child class）
          • 当子类继承父类的方法时，我们可以定义一个与继承的方法名称相同的新方法，从而覆盖父类中的方法。子类改变从父类中继承方法的实现能力，被称为方法覆盖（method overrding）。
      • 组合（composition）：通过组合技巧，将一个对象作为变量保存在另一个对象中，可以模式“拥有”关系。
    • 术语表
      • 面向对象编程的四大支柱：封装、抽象、多态和继承。
      • 继承：在基因继承汇总，子女会从父母那继承眼睛的颜色等特征。类似地，在创建类时，该类也可以从另一个类那里继承方法和变量。
      • 父类：被继承的类。
      • 子类：继承父类的类。
      • 方法覆盖：子类改变从父类中继承方法的实现能力。
      • 多态：指的是为不同的基础形态（数据类型）提供相关接口的能力。
      • 抽象：指的是剥离事物的诸多特征，使其只保留最基本的特质的过程。
      • 客户端代码：适用对象的类之外的代码。
      • 封装：封装包含两个概念。第一个概念是在面向对象编程中对象将变量（状态）和方法（用来改变状态或执行涉及状态的计算）集中在一个地方——即对象本身。第二个概念指的是隐藏类的内部数据，以避免客户端代码直接进行访问。
      • 组合：通过组合技巧，将一个对象作为变量保存在另一个对象中，可以模式“拥有”关系。
  • 第11章 深入面向对象编程
    • 11.1 类变量与实例变量
      • 在Python中，类即对象。 Python中的每个类，都是type类的一个实例对象。
      • 类中有两种类型的变量：
        • 类变量（class variable）
          • 类变量属于Python为每个类定义创建的对象，以及类本身创建的对象。
          • 类变量的定义方式与普通变量相同（但必须在类内部定义），可以通过类对象访问，也可以通过使用类创建的对象访问。
          • 访问方式与实例变量（变量名前面加self.）的访问方式相同。
          • 类变量可以在不适用全局变量的情况下，在类的所有实例之间共享数据。
        • 实例变量（instance variable）
          • 实例变量通过语法 self.[变量名】=[变量值] 定义。
    • 11.2 is
      • 如果两个对象是相同的对象，关键字is返回True，反之则返回False。
      • 可以使用关键字is检查变量是否为None。