莫烦python之python基础学习备忘

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

目录

一、print功能

二、基础数学运算

三、变量variable

四、while和for循环

五、if判断

六、定义功能

七、变量形式

八、模块安装

九、文件读取

十、class类

十一、input输入

十二、元祖|列表|字典

十三、模块

十四、其他


一、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()是浮点型，可以把字符串转换成小数

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

三、变量variable
    1、自变量命名规则
       例：apple=1 #apple为自变量名称，1位自变量
           一次定义多个自变量：a,b,c=11,12,13

四、while和for循环
    1、while(true)    # 除了0(0.0)返回false其余数字返回true、Noen返回false、list|tuple|dict|set集合元素数量为0返回false
         内容
    2、for item in sequence:  # sequence 为可迭代的对象，item 为序列中的每个对象。
             expressions
       2）进阶：range使用：range 函数将会返回一个序列
        a、range(start, stop)：类似 数学中的表达 [start, stop),左边为闭区间，右边为开区间
           例：for i in range(1, 10):    # 将会返回 1-9 所有整数，但不包含 10
                 print(i)
        b、range(stop)：默认从0开始，相当于range(0, stop)
        c、range(start, stop, step)：step 代表的为步长。从 start 开始，依次增加 step 的值，直至等于或者大于 stop
       3）高级：Python 共内置了 list、 tuple 、dict 和 set 四种基本集合
        每个集合对象都可以迭代
        注意：
              字典中 key 是乱序的，也就是说和插入 的顺序是不一致的。如果想要使用顺序一致的字典，请使用 collections 模块 中的 OrderedDict 对象。
       4）迭代器
        for语法实现了迭代器模式， 只要类中实现了 __iter__ 和 next 函数，那么对象就可以在 for 语句中使用
       5）生成器
            Python 使用 yield 关键字也能实现类似迭代的效果，yield 语句每次 执行时，立即返回结果给上层调用者，而当前的状态仍然保留，以便迭代器下一次循环调用。
        这样做的 好处是在于节约硬件资源，在需要的时候才会执行，并且每次只执行一次
              set 集合将会去除重复项，注意输出的 结果也不是按照输入的顺序

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

六、定义功能
    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) 表达。

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

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


九、文件读取
    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类
    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输入
    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:

十二、元祖|列表|字典
    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}

十三、模块
    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，同样，我们自己建的模块也可以放到这个路径，最后不会影响到自建模块的调用

十四、其他
    1、break：当符合跳出条件时，会直接结束循环
        continue：会直接进入下一次循环
    2、try 错误处理：try:, except ... as ...
       例：try:
             file=open('eeee.txt','r')  #会报错的代码
           except Exception as e:  # 将报错存储在 e 中
             print(e)
    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
    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窗口视窗设计的模块
    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