python3 基础 廖雪峰教程笔记-1

廖雪峰教程文档：https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/001432523496782e0946b0f454549c0888d05959b99860f000
1.安装
    安装版本问题
        Python有两个版本，一个是2.x版，一个是3.x版，这两个版本是不兼容的。
        由于3.x版越来越普及，我们的教程将以最新的Python 3.5版本为基础。
        请确保你的电脑上安装的Python版本是最新的3.5.x
2.第一个python程序
    print(xxx,xxx)
    1)直接用命令行来实现代码
        Python的交互式命令行写程序，好处是一下就能得到结果，坏处是没法保存，下次还想运行的时候，还得再敲一遍。
    2)使用文件 xx.py  切换到对应的文件目录下，执行python xx.py
        实际开发的时候，我们总是使用一个文本编辑器来写代码，写完了，保存为一个文件，这样，程序就可以反复运行了。
3.文本编辑工具
    NotePad++、Sublime Text
    绝对不能用Word和Windows自带的记事本。
        Word保存的不是纯文本文件，而记事本会自作聪明地在文件开始的地方加上几个特殊字符（UTF-8 BOM），
        结果会导致程序运行出现莫名其妙的错误。
    保存的python 的代码，必须以 .py结尾

    文件开头：
             #!/usr/bin/env python3
             # -*- coding: utf-8 -*-
                    第一行注释是为了告诉Linux/OS X系统，这是一个Python可执行程序，Windows系统会忽略这个注释
                    第二行注释是为了告诉Python解释器，按照UTF-8编码读取源代码，否则，你在源代码中写的中文输出可能会有乱码

                    申明了UTF-8编码并不意味着你的.py文件就是UTF-8编码的，必须并且要确保文本编辑器正在使用UTF-8 without BOM编码：


4.输出和输入     输入是Input，输出是Output，因此，我们把输入输出统称为Input/Output，或者简写为IO。
    输出：print()   函数也可以接受多个字符串，用逗号“,”隔开，就可以连成一串输出
        用print()在括号中加上字符串，就可以向屏幕上输出指定的文字。比如输出'hello, world'，用代码实现如下：
        eg:print('hello, world')
           print('The quick brown fox', 'jumps over', 'the lazy dog')
    输入：input()  让用户输入字符串，并存放到一个变量里  input("提示的内容，如果不填就为空")
        输入的内容类型都是 字符串 的类型，如果需要用的整数等，需要进行转化
        name = input('please enter your name: ')

5.python基础
    1)Python的语法比较简单，采用缩进方式对齐的方式，进行执行
        Python使用缩进来组织代码块，请务必遵守约定俗成的习惯，坚持使用4个空格的缩进。
        在文本编辑器中，需要设置把Tab自动转换为4个空格，确保不混用Tab和空格
    2)以#开头的语句是注释，注释是给人看的，可以是任意内容，解释器会忽略掉注释。
    其他每一行都是一个语句，当语句以冒号:结尾时，缩进的语句视为代码块。
    3)Python程序是大小写敏感的，如果写错了大小写，程序会报错
6.数据类型
    整数、浮点数、字符串、布尔值、空值、变量、常量、列表、元组、字典、自定义数据类型

    Python支持多种数据类型，在计算机内部，可以把任何数据都看成一个“对象”，
    而变量就是在程序中用来指向这些数据对象的，对变量赋值就是把数据和变量给关联起来。

    注意：Python的整数没有大小限制，而某些语言的整数根据其存储长度是有大小限制的，
    例如Java对32位整数的范围限制在-2147483648-2147483647。

    Python的浮点数也没有大小限制，但是超出一定范围就直接表示为inf（无限大）。

7.整数
    整数：Python可以处理任意大小的整数，当然包括负整数，在程序中的表示方法和数学上的写法一模一样，例如：1，100，-8080，0，等等。
         有时候用十六进制表示整数比较方便，十六进制用0x前缀和0-9，a-f表示，例如：0xff00，0xa5b4c3d2，等等
8.浮点数
    浮点数：浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的，比如，1.23x109和12.3x108是完全相等的。浮点数可以用数学写法，

  整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的（除法难道也是精确的？是的！），而浮点数运算则可能会有四舍五入的误差。

9.字符串
    1)字符串是以单引号'或双引号"括起来的任意文本 (使用单引号和使用双引号没有区别，但是必须成对出现)
    2)''或""本身只是一种表示方式，不是字符串的一部分
    3)如果字符串内部既包含'又包含"怎么办？可以用转义字符\来标识，比如：
        'I\'m \"OK\"!'
        转义字符\可以转义很多字符，比如\n表示换行，\t表示制表符，字符\本身也要转义，所以\\表示的字符就是\
    4)如果字符串里面有很多字符都需要转义，就需要加很多\，
            为了简化，Python还允许用r''表示''内部的字符串默认不转义

    5)如果字符串内部有很多换行，用\n写在一行里不好阅读，为了简化，Python允许用'''...'''的格式表示多行内容

10.布尔值
    1)布尔值和布尔代数的表示完全一致，一个布尔值只有True、False两种值，要么是True，要么是False，
    2)在Python中，可以直接用True、False表示布尔值（请注意大小写），也可以通过布尔运算计算出来
    3)布尔值可以用and、or和not运算。
       and运算是与运算，只有所有都为True，and运算结果才是True：
       or运算是或运算，只要其中有一个为True，or运算结果就是True：
       not运算是非运算，它是一个单目运算符，把True变成False，False变成True：
    4)布尔值经常用在条件判断中

11.空值
    空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。

12.变量
    变量名必须是大小写英文、数字和_的组合，且不能用数字开头

    在Python中，等号=是赋值语句，可以把任意数据类型赋值给变量，同一个变量可以反复赋值，而且可以是不同类型的变量
    (这种变量本身类型不固定的语言称之为动态语言，与之对应的是静态语言。
        静态语言在定义变量时必须指定变量类型，如果赋值的时候类型不匹配，就会报错。
        例如Java是静态语言，赋值语句)

13.常量
    常量就是不能变的变量，比如常用的数学常数π就是一个常量。在Python中，通常用全部大写的变量名表示常量：
        PI = 3.14159265359
    但事实上PI仍然是一个变量，Python根本没有任何机制保证PI不会被改变，
    所以，用全部大写的变量名表示常量只是一个习惯上的用法，如果你一定要改变变量PI的值，也没人能拦住你。

    Python中，有两种除法，
      1)  /除法计算结果是浮点数，即使是两个整数恰好整除，结果也是浮点数：
      2)  //，称为地板除，两个整数的除法仍然是整数
                整数的地板除//永远是整数，即使除不尽。要做精确的除法，使用/就可以。
                因为//除法只取结果的整数部分，所以Python还提供一个余数运算，可以得到两个整数相除的余数：

14.字符串和编码
    1)字符串也是一种数据类型，但是，字符串比较特殊的是还有一个编码问题

    2)%运算符就是用来格式化字符串的。在字符串内部，%s表示用字符串替换
        常见的占位符
            %d 整数
            %f 浮点数
            %s 字符串
            %x 十六进制整数
        如果你不太确定应该用什么，%s永远起作用，它会把任何数据类型转换为字符串
    3)如果字符串中包含有 %,如何处理：
     有些时候，字符串里面的%是一个普通字符怎么办？这个时候就需要转义，用%%来表示一个%
    4)文件开头：
             #!/usr/bin/env python3
             # -*- coding: utf-8 -*-
                    第一行注释是为了告诉Linux/OS X系统，这是一个Python可执行程序，Windows系统会忽略这个注释
                    第二行注释是为了告诉Python解释器，按照UTF-8编码读取源代码，否则，你在源代码中写的中文输出可能会有乱码

                    申明了UTF-8编码并不意味着你的.py文件就是UTF-8编码的，必须并且要确保文本编辑器正在使用UTF-8 without BOM编码：
15.列表 list
    1)list是一种有序的集合，可以随时添加和删除其中的元素。
        >>> classmates = ['Michael', 'Bob', 'Tracy']
    2)len()函数可以获得list元素的个数
    3)索引来访问list中每一个位置的元素，记得索引是从0开始的
        >>> classmates[0]
        'Michael'
        >>> classmates[1]
        'Bob'
        >>> classmates[2]
        'Tracy'
        >>> classmates[3]
        Traceback (most recent call last):
          File "<stdin>", line 1, in <module>
        IndexError: list index out of range
    4)当索引超出了范围时，Python会报一个IndexError错误，
        所以，要确保索引不要越界，记得最后一个元素的索引是len(classmates) - 1
    5)如果要取最后一个元素，除了计算索引位置外，还可以用-1做索引，直接获取最后一个元素
        >>> classmates[-1]
        'Tracy'
    6)list是一个可变的有序表，所以，可以往list中追加元素到末尾
        >>> classmates.append('Adam')
        >>> classmates.insert(1, 'Jack')
    7)要删除list末尾的元素，用pop()方法：
        >>> classmates.pop()
      要删除指定位置的元素，用pop(i)方法，其中i是索引位置
        >>> classmates.pop(1)
    8)要把某个元素替换成别的元素，可以直接赋值给对应的索引位置:
        >>> classmates[1] = 'Sarah'

16.元组 tuple
    1)另一种有序列表叫元组：tuple。tuple和list非常类似，但是tuple一旦初始化就不能修改
     (tuple 是只读的 list )
    >>> classmates = ('Michael', 'Bob', 'Tracy')

        如果要定义一个空的tuple，可以写成()：>>> t = ()
        要定义一个只有1个元素的tuple ：>>> t = (1,)
            Python在显示只有1个元素的tuple时，也会加一个逗号,，以免你误解成数学计算意义上的括号。

            >>> t = (1)
                定义的不是tuple，是1这个数！这是因为括号()既可以表示tuple，
                又可以表示数学公式中的小括号，这就产生了歧义，因此，Python规定，这种情况下，
                按小括号进行计算，计算结果自然是1。

    只有1个元素的tuple定义时必须加一个逗号,

    2)最后来看一个“可变的”tuple：
        >>> t = ('a', 'b', ['A', 'B'])
        >>> t[2][0] = 'X'
        >>> t[2][1] = 'Y'
        >>> t
        ('a', 'b', ['X', 'Y'])

      表面上看，tuple的元素确实变了，但其实变的不是tuple的元素，而是list的元素。
      tuple一开始指向的list并没有改成别的list，
      所以，tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。即指向'a'，就不能改成指向'b'，
      指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！

      理解了“指向不变”后，要创建一个内容也不变的tuple怎么做？那就必须保证tuple的每一个元素本身也不能变。

17.条件判断
    1)根据Python的缩进规则，如果if语句判断是True，就把缩进的两行print语句执行了，否则，什么也不做。
        age = 20
        if age >= 18:
            print('your age is', age)
            print('adult')
    也可以给if添加一个else语句，意思是，如果if判断是False，不要执行if的内容，去把else执行了：
        age = 3

    当然上面的判断是很粗略的，完全可以用elif做更细致的判断
        age = 3
        if age >= 18:
            print('adult')
        elif age >= 6:
            print('teenager')
        else:
            print('kid')

    2)if语句的完整形式:
        if <条件判断1>:
            <执行1>
        elif <条件判断2>:
            <执行2>
        elif <条件判断3>:
            <执行3>
        else:
            <执行4>
    3)if判断条件还可以简写
        if x:
            print('True')

        只要x是非零数值、非空字符串、非空list等，就判断为True，否则为False。

18.循环
    Python的循环有两种，一种是for...in循环，依次把list或tuple中的每个元素迭代出来
    1)for...in循环
        names = ['Michael', 'Bob', 'Tracy']
        for name in names:
            print(name)
      Python提供一个range()函数，可以生成一个整数序列，再通过list()函数可以转换为list。
      比如range(5)生成的序列是从0开始小于5的整数：
        >>> list(range(5))

        range(101)就可以生成0-100的整数序列
            sum = 0
            for x in range(101):
                sum = sum + x
            print(sum)
    2）while循环， 只要条件满足，就不断循环，条件不满足时退出循环。
        sum = 0
        n = 99
        while n > 0:
            sum = sum + n
            n = n - 2
        print(sum)
    3)break
        在循环中，break语句可以提前退出循环
    4)continue
        在循环过程中，也可以通过continue语句，跳过当前的这次循环，直接开始下一次循环

    break语句可以在循环过程中直接退出循环，而continue语句可以提前结束本轮循环，
    并直接开始下一轮循环。这两个语句通常都必须配合if语句使用。

    如果代码写得有问题，会让程序陷入“死循环”，也就是永远循环下去。这时可以用Ctrl+C退出程序，或者强制结束Python进程。

19.字典 dict
    1)Python内置了字典：dict的支持，dict全称dictionary，
        在其他语言中也称为map，使用键-值（key-value）存储，具有极快的查找速度。
            d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
    2)数据放入dict的方法，除了初始化时指定外，还可以通过key放入
        >>> d['Adam'] = 67
    3)由于一个key只能对应一个value，所以，多次对一个key放入value，后面的值会把前面的值冲掉
        >>> d['Jack'] = 90
        >>> d['Jack']
        90
        >>> d['Jack'] = 88
        >>> d['Jack']
        88
    4)如果key不存在，dict就会报错：
        >>> d['Thomas']
        Traceback (most recent call last):
          File "<stdin>", line 1, in <module>
        KeyError: 'Thomas'
    5)要避免key不存在的错误，有两种办法，
      一是通过in判断key是否存在：
        >>> 'Thomas' in d
        False
      二是通过dict提供的get方法，如果key不存在，可以返回None，或者自己指定的value：
        >>> d.get('Thomas')
        >>> d.get('Thomas', -1)
        -1
    6)返回None的时候Python的交互式命令行不显示结果。

    7)请务必注意，dict内部存放的顺序和key放入的顺序是没有关系的。

        和list比较，dict有以下几个特点：

        查找和插入的速度极快，不会随着key的增加而变慢；
        需要占用大量的内存，内存浪费多。
        而list相反：

        查找和插入的时间随着元素的增加而增加；
        占用空间小，浪费内存很少。
        所以，dict是用空间来换取时间的一种方法。

        所以，dict是用空间来换取时间的一种方法。

        dict可以用在需要高速查找的很多地方，在Python代码中几乎无处不在，正确使用dict非常重要，需要牢记的第一条就是dict的key必须是不可变对象。

        这是因为dict根据key来计算value的存储位置，如果每次计算相同的key得出的结果不同，那dict内部就完全混乱了。这个通过key计算位置的算法称为哈希算法（Hash）。

        要保证hash的正确性，作为key的对象就不能变。在Python中，字符串、整数等都是不可变的，因此，可以放心地作为key。而list是可变的，就不能作为key：

20.set集合
    1)set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。
    2)要创建一个set，需要提供一个list作为输入集合：
        >>> s = set([1, 2, 3])
        >>> s
        {1, 2, 3}

       注意，传入的参数[1, 2, 3]是一个list，而显示的{1, 2, 3}只是告诉你这个set内部有1，2，3这3个元素，显示的顺序也不表示set是有序的。。

    3)重复元素在set中自动被过滤：
        >>> s = set([1, 1, 2, 2, 3, 3])
        >>> s
        {1, 2, 3}
    4)通过add(key)方法可以添加元素到set中，可以重复添加，但不会有效果：
        >>> s.add(4)
        >>> s
        {1, 2, 3, 4}
        >>> s.add(4)
        >>> s
        {1, 2, 3, 4}
    5)通过remove(key)方法可以删除元素：
        >>> s.remove(4)
        >>> s
        {1, 2, 3}
    6)set可以看成数学意义上的无序和无重复元素的集合，因此，两个set可以做数学意义上的交集、并集等操作：
        >>> s1 = set([1, 2, 3])
        >>> s2 = set([2, 3, 4])
        >>> s1 & s2
        {2, 3}
        >>> s1 | s2
        {1, 2, 3, 4}

    7)set和dict的唯一区别仅在于没有存储对应的value，但是，set的原理和dict一样，所以，同样不可以放入可变对象，因为无法判断两个可变对象是否相等，也就无法保证set内部“不会有重复元素”。试试把list放入set，看看是否会报错。