《莫烦Python3基础教程》学习笔记

莫烦python学习链接：https://morvanzhou.github.io/tutorials/python-basic/basic/

目录：

安装  1.1 安装

基本使用  2.1 print 功能 2.2 基础数学运算 2.3 变量 variable 

while 和 for 循环  3.1 while 循环 3.2 for 循环 

if 判断  4.1 if 判断 4.2 if else 判断 4.3 if elif else 判断 

定义功能  5.1 def 函数 5.2 函数参数 5.3 函数默认参数 

变量形式  6.1 全局 & 局部 变量 

模块安装  7.1 模块安装 

文件读取  8.1 读写文件 1      8.2 读写文件 2       8.3 读写文件 3 

class 类  9.1 class 类   9.2 class 类 init 功能 

input 输入  10.1 input 输入 

元组, 列表, 字典  11.1 元组 列表 11.2 list 列表 11.3 多维列表 11.4 dictionary 字典 

模块  12.1 import 模块  12.2 自己的模块 

其他  13.1 continue & break   13.2 try 错误处理   13.3 zip lambda map    13.4 copy & deepcopy 浅复制 & 深复制 

13.5 threading 什么是多线程    13.6 multiprocessing 什么是多进程    13.7 什么是 tkinter 窗口    13.8 pickle 保存数据 

13.9 set 找不同   13.10 正则表达式

安装  1.1 安装

Mac 安装   

Mac用户安装 python会比较方便,直接到官网下载安装包， 下载自己需要的版本，默认路径安装即可。之后的某节会讲到如何给Mac中的python安装其他模块， 比如比较常用的numpy 或者matplotlib

Windows 安装   

请到官网下载需要的版本的安装包， 下载所需(注意自己的系统是32位还是64位)，安装路径最好选择默认, 不然对于新手容易出现各种问题。  Windows 安装附加要点: 设置环境变量（这很重要，不然就要装好再设置比较烦琐就是下面2的操作）: 

1.找到安装路径, 默认 C:\Users\**你的用户名**\AppData\Local\Programs\Python\Python35-32 粘贴路径 

2.我的电脑 - 属性 - 高级 - 环境变量 - 系统变量中的PATH为（复制路径）: C:\Users\**你的用户名**\AppData\Local\Programs\Python\Python35-32;  pip3 设置环境变量:  C:\Users\**你的用户名**\AppData\Local\Programs\Python\Python35-32\Scripts;

基本使用

2.1 print 功能  
    1、字符串叠加：+ 
       例：print('Hello world'+' Hello Hong Kong')
    2、简单运算：加法+,减法-,乘法*,除法/.
       注意：字符串不可以直接和数字相加，否则出现错误
       例：print(1+1)
    3、int() 和 float()；当int()一个浮点型数时，int会保留整数部分,
           例：int(1.9),会输出1,而不是四舍五入。
            print(float('1.2')+3) #float()是浮点型，可以把字符串转换成小数

2.2 基础数学运算
    1、python可以直接运算数字
    2、次方：^与**
       例：3的平方为3**2 , **3表示立方，**4表示4次方
    3、取余：%

2.3 变量 variable 
    1、自变量命名规则
       例：apple=1 #apple为自变量名称，1位自变量

           一次定义多个自变量：a,b,c=11,12,13

while 和 for 循环  3.1 while 循环 3.2 for 循环 （这需要注意点嵌入的内容的缩进，当然如果是自己写的话，直接回车就会生成标准的缩进格式，如果是复制的网上的代码来学习一下的话，就把他删除到和上一列同行之后再回车或者自己记住缩进的格式，自己按空格键）

3.1 while 循环（与我们之前学的C语言差不多的语法结构）

while condition:     

expressions 

其中 condition 为判断条件，在 Python 中就是 True 和 False 其中的一个，如果为 True， 那么将执行 exexpressions 语句,否则将跳过该 while 语句块接着往下执行。

实例   比如要打印出 0 - 9 的所有数据  

condition = 0 

while condition < 10:     

  print(condition)     

  condition = condition + 1 

输出的结果将是 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 第一行设置 condition 的 初始值为 0，在进行 while 判断的时候 0 < 10 为 True, 将会执行 while 内部 的代码，首先先打印出该值，然后将 condition 值加 1，至此将完成一次循环；再 condition 的值与 10 进行比较，仍然为 True, 重复如上过程，至到 condiiton 等于 10 后，不满足 condition < 10 的条件（False），将不执行 while 内部的内容 所以 10 不会被打印

需要注意下面这个条件是个恒成立的程序，他的 while 部分 将永远执行下去，可以按ctrl+c来结束

while(true) 

在使用 while 句法的时候一定要注意在循环内部一定要修改判断条件的值，否则程序的 while 部分 将永远执行下去。  

 # 除了0(0.0)返回false其余数字返回true、Noen返回false、list|tuple|dict|set集合元素数量为0返回false

高级主题 

在 Python 中除了常规比较操作  如：小于（<)   大于 (>)   不大于 (<=)  不小于 (>=)  等于 (==)  不等于 (!=)

会返回 True 和 False值，例如其他也会返回 True 和 False

1 数字  

整数和浮点数也能进行 Boolean 数据操作, 具体规则，如果该值等于 0 或者 0.0 将会返回 False 其余的返回 True

condiiton = 10
while condiiton:
    print(condiiton)
    condiiton -= 1

输出的结果将会是 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 在这里 condition 在 while 语句中，如果该值 大于0，那么将会返回为 True,执行循环内部语句，直至 condition 等于0，返回 False。

2 None 类型

如果 while 后面接着的语句数据类型 None, 将会返回 False。

3 集合类型

在 Python 中集合类型有 list、 tuple 、dict 和 set 等，如果该集合对象作为 while 判断语句， 如果集合中的元素数量为 0，那么将会返回 False, 否则返回 True。

a = range(10)
while a:
    print(a[-1])
    a = a[:len(a)-1]

上述程序将会返回 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 程序首先判断列表是否空，如果不为空，则 打印出最后一个内容，然后使用切片操作去掉最后一个元素，并更新列表；如此重复，直至列表为空。

  3.2 for 循环 （与while差不多，就语法上有差异，不同编程语言都有 for 语言，都一样） 用法如下：

 for item in sequence:

    expressions

for item in sequence:  # sequence 为可迭代的对象，item 为序列中的每个对象。

  实例

example_list = [1,2,3,4,5,6,7,12,543,876,12,3,2,5]

for i in example_list:

    print(i)

输出的结果为 1,2,3,4,5,6,7,12,543,876,12,3,2,5, 内容依次为 example_list 中的每一个元素 注意 Python 是使用缩进表示程序的结构，如果程序这样编写，

example_list = [1,2,3,4,5,6,7,12,543,876,12,3,2,5]

for i in example_list:

    print(i)

    print('inner of for')

print('outer of for')

那么每次循环都会输出 inner of for,在循环结束后，输出 outer of for 一次。

       2）进阶：range使用：range 函数将会返回一个序列
        a、range(start, stop)：类似 数学中的表达 [start, stop),左边为闭区间，右边为开区间
           例：for i in range(1, 10):    
                       print(i)                         # 将会返回 1-9 所有整数，但不包含 10
        b、range(stop)：默认从0开始，相当于range(0, stop)

        c、range(start, stop, step)：step 代表的为步长。从 start 开始，依次增加 step 的值，直至等于或者大于 stop

for i in range(0,13, 5):

    print(i)

将会输出 0, 5, 10。

       3）高级：Python 共内置了 list、 tuple 、dict 和 set 四种基本集合

tuple 类型

tup = ('python', 2.7, 64)

for i in tup:

    print(i)

程序将以此按行输出 ‘python’, 2.7 和 64。

dictionary 类型

dic = {}

dic['lan'] = 'python'

dic['version'] = 2.7

dic['platform'] = 64

for key in dic:

    print(key, dic[key])

输出的结果为：platform 64，lan python, version 2.7, 字典在迭代的过程 中将 key 作为可迭代的对象返回。注意字典中 key 是乱序的，也就是说和插入 的顺序是不一致的。如果想要使用顺序一致的字典，请使用 collections 模块 中的 OrderedDict 对象。

set 类型

s = set(['python', 'python2', 'python3','python'])

for item in s:

    print(item)

将会输出 python, python3, python2 set 集合将会去除重复项，注意输出的 结果也不是按照输入的顺序。

4.2 迭代器

Python 中的 for 句法实际上实现了设计模式中的迭代器模式 ，所以我们自己也可以按照迭代器的要求自己生成迭代器对象，以便在 for 语句中使用。 只要类中实现了 __iter__ 和 next 函数，那么对象就可以在 for 语句中使用。 现在创建 Fibonacci 迭代器对象,

# define a Fib class

class Fib(object):

    def __init__(self, max):

        self.max = max

        self.n, self.a, self.b = 0, 0, 1

    def __iter__(self):

        return self

    def __next__(self):

        if self.n < self.max:

            r = self.b

            self.a, self.b = self.b, self.a + self.b

            self.n = self.n + 1

            return r

        raise StopIteration()

# using Fib object

for i in Fib(5):

    print(i)

将会输出前 5 个 Fibonacci 数据 1，1, 2, 3, 5

        每个集合对象都可以迭代
        注意：
              字典中 key 是乱序的，也就是说和插入 的顺序是不一致的。如果想要使用顺序一致的字典，请使用 collections 模块 中的 OrderedDict 对象。
       4）迭代器
        for语法实现了迭代器模式， 只要类中实现了 __iter__ 和 next 函数，那么对象就可以在 for 语句中使用

4.3 生成器

除了使用迭代器以外，Python 使用 yield 关键字也能实现类似迭代的效果，yield 语句每次 执行时，立即返回结果给上层调用者，而当前的状态仍然保留，以便迭代器下一次循环调用。这样做的 好处是在于节约硬件资源，在需要的时候才会执行，并且每次只执行一次。

def fib(max):

    a, b = 0, 1

    while max:

        r = b

        a, b = b, a+b

        max -= 1

        yield r

# using generator

for i in fib(5):

    print(i)

将会输出前 5 个 Fibonacci 数据 1，1, 2, 3, 5

       5）生成器

            Python 使用 yield 关键字也能实现类似迭代的效果，yield 语句每次 执行时，立即返回结果给上层调用者，而当前的状态仍然保留，以便迭代器下一次循环调用。
        这样做的 好处是在于节约硬件资源，在需要的时候才会执行，并且每次只执行一次

              set 集合将会去除重复项，注意输出的 结果也不是按照输入的顺序

if 判断  4.1 if 判断 4.2 if else 判断 4.3 if elif else 判断 

    1、python 语言中等号的判断使用 ==     
    2、python 中并没有类似 condition ? value1 : value2 三目操作符
        使用if-else 的行内表达式完成类似的功能
       例：var = var1 if condition else var2 #如果 condition 的值为 True, 那么将 var1 的值赋给 var;如果为 False 则将 var2 的值赋给 var
    3、elif 语句添加多个判断条件

定义功能  5.1 def 函数 5.2 函数参数 5.3 函数默认参数 

 1、def function_name(parameters): # Python 使用 def 开始函数定义，紧接着是函数名，括号内部为函数的参数
            expressions            # 内部为函数的具体功能实现代码，return有返回值
    2、函数调用的过程中给指明特定的参数 func(a=1, b=2), 这样的话，参数的位置将不受影响，所以 func(b=2,a=1)是同样的 的效果
    3、默认参数：函数声明只需要在需要默认参数的地方用 = 号给定即可, 但是要注意所有的默认参数都不能出现在非默认参数的前面。
    4、自调用：if __name__ == '__main__':   # 该 if 判断语句将会是 True,那么内部的代码将会执行。 如果外部调用该脚本，if 判断语句则为 False,内部代码将不会执行
                #code_here        # 测试代码被调用时不希望被执行
    5、可变参数：def report(name, *grades):  #  后面的参数 *grades 使用了 * 修饰，表明该参数是一个可变参数，这是一个可迭代的对象
        注意可变参数在函数定义不能出现在特定参数和默认参数前面
    6、关键字参数：def portrait(name, **kw): # 使用了 ** 修饰。表明该参数是关键字参数。参数在函数内部自动封装成一个字典(dict).

    通过可变参数和关键字参数，任何函数都可以用 universal_func(*args, **kw) 表达。

变量形式  6.1 全局 & 局部 变量 

   1、def 中, 我们可以定义一个局部变量
    2、首先我们在外部定义一个全局变量 a=None, 然后再 fun() 中声明 这个 a 是来自外部的 a. 声明方式就是 global a. 然后对这个外部的 a 修改后, 修改的效果会被施加到外部的 a 上

模块安装  7.1 模块安装 

1、外部模块就是在你 import 什么东西去python 脚本的时候会用到的.

import numpy as np

import matplotlib.pyplot as plt

这里的 Numpy 和 matplotlib 都是外部模块, 需要安装以后才会有的. 他不属于 python 自带的模块.

只要你在里面输入这种形式就可以安装了.

$ pip install 你要的模块名

比如

$ pip install numpy   # 这是 python2+ 版本的用法

$ pip3 install numpy   # 这是 python3+ 版本的用法

更新外部模块 

使用 pip 更新外部模块会十分简单. 主需要在 Terminal （终端）中输入下面的指令就行. 这里的 -U 就是 update 意思.

$ pip install -U numpy   # 这是 python2+ 版本的用法

$ pip3 install -U numpy   # 这是 python3+ 版本的用法

文件读取  8.1 读写文件 1      8.2 读写文件 2       8.3 读写文件 3 

 1、\n 换行命令、\t tab 对齐
    2、打开一个文件
        例子：    my_file=open('my file.txt','w')   #用法: open('文件名','形式'), 其中形式有'w':write;'r':read.
            my_file.write(text)               #该语句会写入先前定义好的 text
            my_file.close()                   #关闭文件
    3、给文件增加内容：
        例子：  append_text='\nThis is appended file.'  # 为这行文字提前空行 "\n"
            my_file=open('my file.txt','a')   # 'a'=append 以增加内容的形式打开
            my_file.write(append_text)
    4、读取文件内容
        例子：content=file.read()  #读取到文本的所有内容.
              content=file.readline()  # 读取第一行
              content=file.readlines() # 读取所有行，python_list 形式
            # 之后如果使用 for 来迭代输出:
            for item in content:
                  print(item)

class 类  9.1 class 类   9.2 class 类 init 功能 

  1、class Calculator:       #首字母要大写，冒号不能缺
            name='Good Calculator'  #该行为class的属性
    2、cal=Calculator()  #注意这里运行class的时候要加"()"
    3、init：相当于构造函数，__init__可以理解成初始化class的变量，可以在运行时，给初始值附值
        def __init__(self,name,price,height,width,weight):
        c=Calculator('bad calculator',18,17,16,15)

input 输入  10.1 input 输入 

1、variable=input()： 表示运行后，可以在屏幕中输入一个数字，该数字会赋值给自变量
    2、input()应用在if语句中
        a_input=int(input('please input a number:'))#注意这里要定义一个整数型
        if a_input==1:
    3、input扩展
        score=int(input('Please input your score: \n'))
        if score>=90:

元组, 列表, 字典  11.1 元组 列表 11.2 list 列表 11.3 多维列表 11.4 dictionary 字典 

 1、Tuple：用小括号、或者无括号来表述，是一连串有顺序的数字
       例：    a_tuple = (12, 3, 5, 15 , 6)
        another_tuple = 12, 3, 5, 15 , 6
    2、list：是以中括号来命名的
       例：a_list = [12, 3, 67, 7, 82]
    
    3、tuple和list对比：他们的元素可以一个一个地被迭代、输出、运用、定位取值
    4、list添加：a.append(0)  # 在a的最后面追加一个0
             a.insert(1,0) # 在位置1处添加0
       list移除：a.remove(2) # 删除列表中第一个出现的值为2的项
       list索引：a[0]           # a的第0位的值
             a[-1]           # a的最末位的值
             a[0:3]          # a的从第0位 到 第2位(第3位之前) 的所有项的值
             a[5:]           # a的第5位及以后的所有项的值
             a[-3:]          # a的倒数第3位及以后的所有项的值
                 a.index(2)     # a中第一次出现的值为2的项的索引
             count(-1)      # 统计列表中某值出现的次数
       list排序：a.sort()             # 默认从小到大排序
             a.sort(reverse=True)     # 从大到小排序
    5、多维列表：一个一维的List是线性的List，多维List是一个平面的List
       例：multi_dim_a = [[1,2,3],
                  [2,3,4],
                  [3,4,5]] # 三行三列
        索引：multi_dim_a[0][1]
    6、dictionary 字典：无需顺序的
       创建字典：d1 = {'apple':1, 'pear':2, 'orange':3}

模块  12.1 import 模块  12.2 自己的模块

     1、import time
    2、mport time as __,__下划线缩写部分可以自己定义，在代码中把time 定义成 t
       例：    import time as t
        print(t.localtime()) # 需要加t.前缀来引出功能
    3、from time import time,localtime：只import自己想要的功能.
    4、from time import *： 输入模块的所有功能
    5、模块写好后保存在默认文件夹：balance.py
        import balance
       下载的python模块会被存储到外部路径site-packages，同样，我们自己建的模块也可以放到这个路径，最后不会影响到自建模块的调用

其他  13.1 continue & break   13.2 try 错误处理   13.3 zip lambda map    13.4 copy & deepcopy 浅复制 & 深复制 

13.5 threading 什么是多线程    13.6 multiprocessing 什么是多进程    13.7 什么是 tkinter 窗口    13.8 pickle 保存数据 

13.9 set 找不同   13.10 正则表达式

 13.1   break：当符合跳出条件时，会直接结束循环

        continue：会直接进入下一次循环
  13.  2、try 错误处理：try:, except ... as ...
       例：try:
             file=open('eeee.txt','r')  #会报错的代码
           except Exception as e:  # 将报错存储在 e 中
             print(e)
  13.  3、zip：zip函数接受任意多个（包括0个和1个）序列作为参数，合并后返回一个tuple列表
           例：    a=[1,2,3]
            b=[4,5,6]
            ab=zip(a,b)
            print(list(ab))  #需要加list来可视化这个功能
          zip 中的运算
           例：    for i,j in zip(a,b):
                      print(i/2,j*2)
       lambda：简化代码的功能
           例：fun = lambda x,y : x+y, 冒号前的x,y为自变量，冒号后x+y为具体运算
           fun= lambda x,y:x+y
           x=int(input('x='))    #这里要定义int整数，否则会默认为字符串
           y=int(input('y='))
           print(fun(x,y))
       map：把函数和参数绑定在一起
        def fun(x,y):
           return (x+y)
        print(list(map(fun,[1,2],[3,4]))) #输出4,6
13.    4、浅|深拷贝
       id：一个对象的id值在CPython解释器里就代表它在内存中的`地址
        a=[1,2,3]    # 此次是数组
        b=a        # a、b的id一致，改变b则a也会改变
       浅拷贝：拷贝了最外围的对象本身，内部的元素都只是拷贝了一个引用
        import copy
        a=[1,2,3]
        c=copy.copy(a)  #拷贝了a的外围对象本身,
        print(id(a)==id(c))  #id 改变 为false
        c[1]=22222   #此时，我去改变c的第二个值时，a不会被改变
       深拷贝：deepcopy对外围和内部元素都进行了拷贝对象本身，而不是对象的引用
           e中内部元素[]列表的值不会因为a中的值改变而改变
       注：对于多层结构，深拷贝对于深层也拷贝了，深层值改变不会导致其他的对象改变
        而浅拷贝会改变
         如：a = [1, 2, [3, 4]] 中的 [3,4],两种拷贝方式会有不同情况
  {  5、threading多线程6、multiprocessing 多进程 7、Tkinter窗口视窗设计的模块}这几个莫烦的网站上是专题讲的
13.  8、pickle 是一个 python 中, 压缩/保存/提取 文件的模块
        import pickle
        a_dict = {'da': 111, 2: [23,1,4], '23': {1:2,'d':'sad'}}
        # pickle a variable to a file
        file = open('pickle_example.pickle', 'wb') # wb 是以写的形式打开 ‘pickle_example.pickle’ 这个文件
        pickle.dump(a_dict, file) # pickle.dump 你要保存的东西去这个打开的 file
        file.close() # 会发现你的文件目录里多了一个 ‘pickle_example.pickle’ 文件, 这就是那个字典了.
        # reload a file to a variable 提取
        #读的形式打开那个文件, 然后 load 进一个 python 的变量
        #with所求值的对象必须有一个__enter__()方法，一个__exit__()方法。
        with open('pickle_example.pickle', 'rb') as file:
            a_dict1 =pickle.load(file)
        print(a_dict1)
    9、set找不同：最主要的功能就是寻找一个句子或者一个 list 当中不同的元素
        char_list = ['a', 'b', 'c', 'c', 'd', 'd', 'd']
        print(set(char_list))        # {'b', 'd', 'a', 'c'}
        sentence = 'Welcome Back to This Tutorial'
       set添加元素
        unique_char = set(char_list)
        unique_char.add('x')
        # unique_char.add(['y', 'z']) this is wrong
       清除一个元素可以用 remove 或者 discard, 而清除全部可以用 clear.
       筛选操作： 看看原来的 set 里有没有和他不同的 (difference). 或者对比另一个东西, 看看 set 里有没有相同的 (intersection).
    10、正则（有专门讲这个的）
        导入模块：import re
        用正则寻找配对：re.search(patter1,string)
        patter1 = r"r[au]n" #r表示为一个正则，[au]表示a或u，[A-Z]表示A到Z，[0-9a-z]
            \d : 任何数字
            \D : 不是数字
            \s : 任何 white space, 如 [\t\n\r\f\v]
            \S : 不是 white space
            \w : 任何大小写字母, 数字和 “” [a-zA-Z0-9]
            \W : 不是 \w
            \b : 空白字符 (只在某个字的开头或结尾)
            \B : 空白字符 (不在某个字的开头或结尾)
           \\ : 匹配 \
            . : 匹配任何字符 (除了 \n)
            ^ : 匹配开头
            $ : 匹配结尾
            ? : 前面的字符可有可无
        re.search(r"^I",string,flags=re.M) #flags规定每一行为一句，每行句首匹配
        *出现0或多次  +出现1或多次 {2，10}可选次数
        group组：也可以通过 ?P<名字>给组加名字
            match = re.search(r"(\d+), Date: (.+)", "ID: 021523, Date: Feb/12/2017")
            print(match.group())                   # 021523, Date: Feb/12/2017
            print(match.group(1))                  # 021523
            print(match.group(2))                  # Date: Feb/12/2017
        re.findall():寻找所有匹配
        re.sub():替换
        re.split(）:切割
        re.compile（）：先编译re然后search