大数据技术之_24_电影推荐系统项目_02_Python 基础语法复习

1.安装 python3（略）

2.安装 python 虚拟环境
> pip install virtualenv -i https://pypi.tuna.tsinghua.edu.cn/simple/
这里用 -i 参数指定了国内源，方便快速下载

3.创建虚拟环境
> virtualenv -p python3 py3
这里创建的是 python3 的虚拟环境，目录名叫 py3，目录名可以任意起！

4.启动 python 虚拟环境
> source py3/bin/activate

5.在虚拟环境中安装 jupyter
(py3)> pip install jupyter -i https://pypi.tuna.tsinghua.edu.cn/simple/

6.安装所需的 python 库
(py3)> pip install numpy -i https://pypi.tuna.tsinghua.edu.cn/simple/           # 数值计算、矩阵运算、向量运算
(py3)> pip install matplotlib -i https://pypi.tuna.tsinghua.edu.cn/simple/      # 画表格和图像
(py3)> pip install pandas -i https://pypi.tuna.tsinghua.edu.cn/simple/          # 数据分析、科学计算
(py3)> pip install sklearn -i https://pypi.tuna.tsinghua.edu.cn/simple/         # 机器学习

7.创建目标目录并进入
(py3)> mkdir algorithm
(py3)> cd algorithm

8.启动 jupyter notebook
(py3)> jupyter notebook

http://192.168.25.102:8888/lab
默认启动端口为 8888，复制链接后可以通过浏览器访问

默认情况下，python3 源文件以 UTF-8 编码，所有字符串都是 unicode 字符串。同时可以指定源文件的不同编码文件开头加上：
    # -*- coding: UTF-8 -*-
    # coding=utf-8(等号两边不能有空格)
允许在源文件中使用 utf-8 字符集中的字符编码，对应的适合语言为中文等。

• 第一个字符必须是字母表中的字母或下划线_
• 标识符中的其他部分由字母、数字和下划线组成
• 标识符对大小写敏感
• 在 python3 中，非 ASCII 标识符 (如中文字符) 也是允许的

• 单行注释：井号 #
• 多行注释：三个单引号'''xxx'''，或者三个双引号"""xxx"""

import keyword
print(len(keyword.kwlist))      # 33
print(keyword.kwlist)           # 打印关键字

['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

简介：
1.and：表示逻辑‘与’
2.del：用于 list 列表操作，删除一个或者连续几个元素
3.from：导入相应的模块，用 import 或者 from...import
4.not：表示逻辑‘非’
5.while：while 循环，允许重复执行一块语句，一般无限循环的情况下用它
6.as：as 单独没有意思，是这样使用：with....as 用来代替传统的 try...finally 语法的
7.elif：和 if 配合使用的，if 语句中的一个分支用 elif 表示
8.global：定义全局变量
    例如：
    name = 10
    age = 20
    def test():
        global name
        age = 30
        name = 'aa'
        # print(name)
    test()
    print(name)     # 'aa'
    print(age)      # 20

9.or：表示逻辑“或”
10.with：和 as 一起用，使用的方法请看 as，见 with
11.assert：表示断言（断言一个条件就是真的，如果断言出错则抛出异常）用于声明某个条件为真，如果该条件不是真的，则抛出异常：AssertionError
    例如：
    v1 = 10
    v2 = 20
    assert(v1 > v2)
12.else：参考下面 if 的解释
13.if：if 语句用于选择分支，依据条件选择执行那个语句块(if语句中最好不要嵌套 if 语句，建议把嵌套的 if 语句写在另一个函数中)
14.pass：pass 的意思就是什么都不做，作用类似于占位符
15.yield：用起来和 return 很像，但它返回的是一个生成器
16.break：作用是终止循环，程序走到 break 的地方就是循环结束的时候
17.except：和 try 一起使用，用来捕获异常
18.import：用来导入模块，有时这样用 from....import
19.class：定义类
20.in：查找列表中是否包含某个元素，或者字符串 a 是否包含字符串 b
21.raise：raise 可以显示地抛出异常。一旦执行 raise 语句，后面的代码就不执行了
22.continue：跳过 continue 后面循环块中的语句，继续进行下一轮循环
23.finally：看到 finally 语句，必然执行 finally 语句的代码块
24.is：Python 中的对象包含三要素：id、type、value，用来判断对象是否相等
25.return：用于跳出函数，也可以在跳出的同时返回一个值
26.def：用于定义方法
27.for：for ... in 一起使用：它在一序列的对象上递归，就是遍历队列中的每个项目
28.lambda：即匿名函数
29.try：出现在异常处理中，使用格式为：try ... except，try 中放想要执行的语句，except 捕获异常
30.nonlocal：nonlocal 关键字用来在函数或其他作用域中使用外层(非全局)变量
    例如：
    def make_counter(): 
        count = 0 
        def counter(): 
            nonlocal count 
            count += 1 
            return count 
        return counter 

    def make_counter_test(): 
        mc = make_counter() 
        print(mc())
        print(mc())
        print(mc())
    make_counter_test()

学习 Python 与其他语言最大的区别就是，Python 的代码块不使用大括号 {} 来控制类，函数以及其他逻辑判断。python 最具特色的就是用缩进来写模块。
缩进的空白数量是可变的，但是所有代码块语句必须包含相同的缩进空白数量，这个必须严格执行。
例如：
    if True:
        print "True"
    else:
        print "False"

Python 语句中一般以新行作为语句的结束符。但是我们可以使用斜杠（ \）将一行的语句分为多行显示，如下所示：

    total = item_one + \
            item_two + \
            item_three
    print('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\
            aaaaaaaaaaaaaaaaaaaa')

    语句中包含 [], {} 或 () 括号就不需要使用多行连接符。如下实例：
    days = ['Monday', 'Tuesday', 'Wednesday',
            'Thursday', 'Friday']

Python 可以使用引号( ' )、双引号( " )、三引号( ''' 或 """ ) 表示字符串，引号的开始与结束必须的相同类型的。
其中三引号可以由多行组成，编写多行文本的快捷语法，常用于文档字符串，在文件的特定地点，被当做注释。

    word = 'word'
    sentence = "这是一个句子。"
    paragraph = """这是一个段落。
    包含了多个语句"""

函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用一行空行分隔，以突出函数入口的开始。空行与代码缩进不同，空行并不是 Python 语法的一部分。书写时不插入空行，Python 解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码，便于日后代码的维护或重构。
记住：空行也是程序代码的一部分。

执行下面的程序在按回车键后就会等待用户输入：
input("\n\n按下 enter 键后退出。")

Python 可以在同一行中使用多条语句，语句之间使用分号(;)分割，以下是一个简单的实例：
    x = 'runoob';print(x + '\n')

缩进相同的一组语句构成一个代码块，我们称之代码组。像 if、while、def 和 class 这样的复合语句，首行以关键字开始，以冒号( : )结束，该行之后的一行或多行代码构成代码组。
我们将首行及后面的代码组称为一个子句(clause)。
例如：
    if expression : 
       suite
    elif expression : 
       suite 
    else : 
       suite

同类型才可以相加
print 默认输出是换行的，如果要实现不换行需要在变量末尾加上 end="" 或者 end=''

    x="a"
    y="b"
    # 换行输出
    print(x)
    print(y)

    print('---------')

    # 不换行输出
    print(x, end="")
    print(y, end="")
    print()

在 python 用 import 或者 from...import 来导入相应的模块。
    a、将整个模块(somemodule)导入，格式为： import somemodule
    b、从某个模块中导入某个函数，格式为： from somemodule import somefunction
    c、从某个模块中导入多个函数，格式为： from somemodule import firstfunc,secondfunc,thirdfunc
    d、将某个模块中的全部函数导入，格式为： from somemodule import *

(1)导入 sys 模块
    import sys
    print('================Python  import  mode==================');
    print ('命令行参数为:')
    for i in sys.argv :
        print (i)
    print('\n python 路径为', sys.path)

(2)导入 sys 模块的 argv,path 成员
    from sys import argv,path  #  导入特定的成员    
    print('================python  from  import=====================')
    print('path:', path)     # 因为已经导入 path 成员，所以引用不需要加 sys.path

    很多程序可以执行一些操作来查看一些基本信息，Python 可以使用 -h 参数查看各参数帮助信息：

$ python -h        
usage: python [option] ... [-c cmd | -m mod | file | -] [arg] ...
Options and arguments (and corresponding environment variables):
-c cmd : program passed in as string (terminates option list)
-d     : debug output from parser (also PYTHONDEBUG=x)
-E     : ignore environment variables (such as PYTHONPATH)
-h     : print this help message and exit

counter = 100        # 整型变量
miles = 1000.0        # 浮点型变量
name = "runoob"        # 字符串

print(counter)
print(miles)
print(name)

Python 允许你同时为多个变量赋值。例如：
    a = b = c = 1
以上实例，创建一个整型对象，值为 1，从后向前赋值，三个变量被赋予相同的数值。

可以为多个对象指定多个变量。例如：
    a, b, c = 1, 2, "runoob"
    a, b = b, a     # 变量的交换
以上实例，两个整型对象 1 和 2 的分配给变量 a 和 b，字符串对象 "runoob" 分配给变量 c。

注意：
    a = 10
    b = 20
    a, b = b, a + 5
    print(a, b)
结果：a=20, b=15

Number（数字）、String（字符串）、Tuple（元组）、List（列表）、Dictionary（字典）、Set（集合）

a、不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）
b、可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）

int、float、bool、complex(复数)
例如：
    a, b, c, d = 20, 5.5, True, 5 + 4j
    print(type(a), type(b), type(c), type(d))

type(a)                    # 判断数据类型
isinstance(a, int)      # 判断数据是否属于某类型
del var1, var2          # 手动 GC

区别:
    (1) type() 不会认为子类是一种父类类型
    (2) isinstance() 会认为子类是一种父类类型
    例如：
        class A:
            pass
        class B(A):
            pass
        print(type(A()) == A)       # True
        print(type(B()) == A)       # False
        print(isinstance(A(), A))   # True
        print(isinstance(B(), A))   # True

二进制：使用 0b 开头    例如：0b1010
八进制：使用 0o 开头    例如：0o555
十六进制：使用 0x 开头  例如：0x52A74（大小写都 OK）

bin()
oct()
hex()

python 中没有数字的大小限制，可以使用任意大的数字；python 可以保证整数运算的精确，但是浮点数运算时可能会得到一个不精确的结果。

函数                    返回值 ( 描述 )
abs(x)                返回数字的绝对值，如 abs(-10) 返回 10
ceil(x)                返回数字的上入整数，如 math.ceil(4.1) 返回 5
(x>y)-(x<y)         如果 x < y 返回 -1
                    如果 x == y 返回 0
                    如果 x > y 返回 1
exp(x)              返回 e 的 x 次幂 (ex)
                    如 math.exp(1) 返回 2.718281828459045
fabs(x)             返回数字的绝对值，如 math.fabs(-10) 返回 10.0
floor(x)            返回数字的下舍整数，如 math.floor(4.9)返回 4
log(x)                如 math.log(math.e) 返回 1.0，
                    如 math.log(100,10) 返回 2.0
log10(x)            返回以 10 为基数的 x 的对数，
                    如 math.log10(100) 返回 2.0
max(x1, x2,...)        返回给定参数的最大值，参数可以为序列
min(x1, x2,...)        返回给定参数的最小值，参数可以为序列
modf(x)                返回 x 的整数部分与小数部分，
                    两部分的数值符号与 x 相同，
                    整数部分以浮点型表示
pow(x, y)            x**y 运算后的值
round(x [,n])       返回浮点数 x 的四舍五入值，如给出 n 值，
                    则代表舍入到小数点后的位数
sqrt(x)                返回数字 x 的平方根

函数                    描述
choice(seq)         从序列的元素中随机挑选一个元素，
                    比如 random.choice(range(10))，表示从0到9中随机挑选一个整数。
randrange ([start,] stop [,step])    从指定范围内，按指定基数递增的集合
                                    中获取一个随机数，基数缺省值为 1
random()            随机生成下一个实数，它在 [0,1) 范围内
seed([x])           改变随机数生成器的种子 seed，
                    如果你不了解其原理，你不必特别去设定 seed，Python 会帮你选择 seed。
shuffle(lst)        将序列的所有元素随机排序
uniform(x, y)       随机生成下一个实数，它在 [x,y] 范围内

函数                    描述
acos(x)                返回 x 的反余弦弧度值。
asin(x)                返回 x 的反正弦弧度值。
atan(x)                返回 x 的反正切弧度值。
atan2(y, x)            返回给定的 X 及 Y 坐标值的反正切值。
cos(x)                返回 x 的弧度的余弦值。
hypot(x, y)            返回欧几里德范数 sqrt(x*x + y*y)。
sin(x)                返回 x 弧度的正弦值。
tan(x)                返回 x 弧度的正切值。
degrees(x)            将弧度转换为角度，如 degrees(math.pi/2) 返回 90.0
radians(x)            将角度转换为弧度

常量                    描述
pi                    数学常量 pi（圆周率，一般以 π 来表示）
e                    数学常量 e，e 即自然常数（自然常数）

Python 中的字符串用 单引号 或 双引号 括起来，同时使用反斜杠 \ 转义特殊字符。下标从 0 开始。
加号 + 是字符串的连接符， 星号 * 表示复制当前字符串，紧跟的数字为复制的次数。

(1) 字符串截取
        变量[头下标:尾下标:步长)

         -6  -5  -4  -3  -2  -1
          0   1   2   3   4   5
        +---+---+---+---+---+---+
        | a | b | c | d | e | f |
        +---+---+---+---+---+---+

        例如：
            str = 'hello world'
            l = str[0:1:1]  # 包头不包尾
            print(l) # h

(2) 字符串打印
    Python 使用反斜杠(\)转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串：

    print('Ru\noob')
    Ru
    oob
    print(r'Ru\noob')
    Ru\noob

(3) 字符串获取
    print(str[0])
    注意：
        1、反斜杠可以用来转义，使用 r 可以让反斜杠不发生转义。
        2、字符串可以用 + 运算符连接在一起，用 * 运算符重复。
        3、Python 中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。
        4、Python 中的字符串不能改变。
            str = 'abcdef'
            str[0] = 's'    # 报错
        5、Python 没有单独的字符类型，一个字符就是长度为1的字符串。

List（列表）是 Python 中使用最频繁的数据类型。列表可以完成大多数集合类的数据结构实现。
列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表(所谓列表的嵌套)。
列表是写在方括号 [] 之间、用逗号分隔开的元素列表。
和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。

定义：
    list = [0, 1, 2, 3, 'c']
    list[0]         # 0
    len(list)       # 长度5
    list[0:3]       # [0, 1, 2]

注意：
    1、List 写在方括号之间，元素用逗号隔开。
    2、和字符串一样，list 可以被索引和切片。
    3、List 可以使用+操作符进行拼接。
    4、List 中的元素是可以改变的。
    5、不支持与或非运算。

元组（tuple）与列表类似，不同之处在于：元组的元素不能修改。
元组写在小括号 () 里，元素之间用逗号隔开。

定义：
    t = (0, 1, 2, 3, 'c')
    t[0]            # 0
    len(list)       # 长度 5
    t[0:3]          # (0, 1, 2)
    t[0] = 2        # 报错

注意：
    1、与字符串一样，元组的元素不能修改。虽然 tuple 的元素不可改变，但它可以包含可变的对象，比如 list 列表。
       注意：元组里面存的是可变对象的地址，因为可变对象的地址是不可以改变的。
        list = [0, 2, 1, 3]
        t = (0, 1, 2, 3, list)
        t[0] = 1            # 报错
        t[4][0] = 1
        print(t[4])         # ok
    2、元组也可以被索引和切片，方法一样。
    3、注意：构造包含 0 或 1 个元素的元组的特殊语法规则。
        tup1 = ()           # 空元组
        tup2 = (20,)        # 一个元素，需要在元素后添加逗号
    4、元组也可以使用 + 或 * 操作符进行拼接。

集合（set）的事物或对象称作元素或是成员。基本功能是进行成员关系测试和删除重复元素。
可以使用大括号 {} 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 {}，因为 {} 是用来创建一个空字典。

创建格式：
    parame = {value01, value02, ...} 或者 set(value)

    s = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}
    print(s)                    # {'Mary', 'Jack', 'Rose', 'Tom', 'Jim'}

    s = set('1b1b2b3b2b')       # {'2', '3', '1', 'b'}  元素不能重复

    set 操作：
    # set 可以进行集合运算
    a = set('abracadabra')
    b = set('alacazam')
    print(a)
    >>> {'b', 'a', 'c', 'r', 'd'}
    print(a - b)     # a 和 b 的差集
    >>> {'b', 'd', 'r'}
    print(a | b)     # a 和 b 的并集
    >>> {'l', 'r', 'a', 'c', 'z', 'm', 'b', 'd'}
    print(a & b)     # a 和 b 的交集
    >>> {'a', 'c'}
    print(a ^ b)     # a 和 b 中不同时存在的元素，注意：(a ^ b) = (a - b)|(b - a)
    >>> {'l', 'r', 'z', 'm', 'b', 'd'}

字典（dictionary）是 Python 中另一个非常有用的内置数据类型。
列表是有序的对象集合，字典是无序的对象集合。
两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
字典是一种映射类型，字典用"{}"标识，它是一个无序的 键(key):值(value)对 集合。
键(key) 必须使用不可变类型。
在同一个字典中，键(key) 必须是唯一的。

字典创建：
    (1) d = {"a":1, "b":2, "c":3}
    (2) d = dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])
    (3) d = {x : x**2 for x in (2, 4, 6)} # 其中 x : x**2  表示键，生成的字典是 {2: 4, 4: 16, 6: 36}
    (4) d = dict(Runoob=1, Google=2, Taobao=3)
字典操作：
    tinydict = {'name': 'guigu', 'code': 1, 'site': 'www.atguigu.com'}

    print (dict['name'])            # 输出键为 'name' 的值
    print (dict['code'])            # 输出键为 'code' 的值
    print (tinydict)                # 输出完整的字典
    print (tinydict.keys())         # 输出所有键 dict_keys(['name', 'code', 'site'])
    print (tinydict.values())       # 输出所有值 dict_values(['guigu', 1, 'www.atguigu.com'])

函数                              描述
int(x [,base])                将 x 转换为一个整数
float(x)                    将 x 转换到一个浮点数
complex(real [,imag])        创建一个复数
str(x)                        将对象 x 转换为字符串
repr(x)                        将对象 x 转换为表达式字符串
eval(str)                    用来计算在字符串中的有效 Python 表达式，并返回一个对象
tuple(s)                    将序列 s 转换为一个元组
list(s)                        将序列 s 转换为一个列表
set(s)                        转换为可变集合
dict(d)                        创建一个字典，d 必须是一个序列 (key, value)元组
frozenset(s)                转换为不可变集合
chr(x)                        将一个整数转换为一个字符（ASCII 码）
ord(x)                        将一个字符转换为它的 ASCII 码值
hex(x)                        将一个整数转换为一个十六进制字符串
oct(x)                        将一个整数转换为一个八进制字符串

Linux/Unix 的系统上，一般默认的 python 版本为 2.x，我们可以将 python3.x 安装在 /usr/local/python3 目录中。
安装完成后，我们可以将路径 /usr/local/python3/bin 添加到您的 Linux/Unix 操作系统的环境变量中，这样您就可以通过 shell 终端输入下面的命令来启动 Python3 。

$ PATH=$PATH:/usr/local/python3/bin/python3    # 设置环境变量
$ python3 --version
Python 3.4.0

在 Window 系统下你可以通过以下命令来设置 Python 的环境变量，假设你的 Python 安装在 C:\Python34 下:
set path=%path%;C:\python34

我们可以在命令提示符中输入"python"（或者"python3"，具体视安装时的命令名称而定）命令来启动 Python 解释器：
$ python3

(1)执行以上命令后，出现如下窗口信息：
$ python3
Python 3.4.0 (default, Apr 11 2014, 13:05:11) 
[GCC 4.8.2] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> 

(2)在 python 提示符中输入以下语句，然后按回车键查看运行效果：
print("Hello, Python!")

(3)以上命令执行结果如下：
Hello, Python!

(4)当键入一个多行结构时，续行是必须的。我们可以看下如下 if 语句：
>>> flag = True
>>> if flag :
...     print("flag 条件为 True!")
... 
flag 条件为 True!

(1) 将如下代码拷贝至 hello.py 文件中：
print("Hello, Python!")

(2)通过以下命令执行该脚本：
python3 hello.py

(3)输出结果为：
Hello, Python!

(4)在 Linux/Unix 系统中，你可以在脚本顶部添加以下命令让 Python 脚本可以像 SHELL 脚本一样可直接执行：
#!/usr/bin/env python3

(5)然后修改脚本权限，使其有执行权限，命令如下：
$ chmod +x hello.py

(6)执行以下命令：
./hello.py

(7)输出结果为：
Hello, Python!

a = 10    b = 21
运算符          描述                    实例
+                加              两个对象相加；a + b 输出结果 31
-                减              得到负数或是一个数减去另一个数；a - b 输出结果 -11
*                乘              两个数相乘或是返回一个被重复若干次的字符串；a * b 输出结果 210
/                除              x 除以 y；b / a 输出结果 2.1
%                取模            返回除法的余数；b % a 输出结果 1
**                幂              返回 x 的 y 次幂；a**b 为 10 的 21 次方
//                取整除          向下取接近除数的整数；9//2    # 4  -9//2  #-5

a = 10, b = 20

运算符          描述                    实例
==              等于            比较对象是否相等，(a == b) 返回 False
!=              不等于          比较两个对象是否不相等，(a != b) 返回 True
>               大于            返回 x 是否大于 y，(a > b) 返回 False
<               小于            返回 x 是否小于 y，(a < b) 返回 True
>=              大于等于        返回 x 是否大于等于 y，(a >= b) 返回 False
<=              小于等于        返回 x 是否小于等于 y，(a <= b) 返回 True

注意：所有比较运算符返回 1 表示真，返回 0 表示假。这分别与特殊的变量 True 和 False 等价。
注意：这些变量名的大写。

运算符              描述                实例
=                简单的赋值运算符    c = a + b 将a + b 的运算结果赋值为 c 
+=                加法赋值运算符      c += a 等效于   c = c + a
-=                减法赋值运算符      c -= a 等效于   c = c - a
*=                乘法赋值运算符      c *= a 等效于   c = c * a
/=                除法赋值运算符      c /= a 等效于   c = c / a
%=                取模赋值运算符      c %= a 等效于   c = c % a
**=                幂赋值运算符        c **= a 等效于  c = c ** a
//=                取整除赋值运算符    c //= a 等效于  c = c // a

a = 60, b = 13
二进制形式：a = 0011 1100, b = 0000 1101

运算符              描述                实例
&               按位与运算符        (a & b) 输出结果 12 ，二进制解释： 0000 1100
|               按位或运算符        (a | b) 输出结果 61 ，二进制解释： 0011 1101
^               按位异或运算符      (a ^ b) 输出结果 49 ，二进制解释： 0011 0001
~               按位取反运算符      (~a )   输出结果 -61 ，二进制解释： 1100 0011
<<              左移动运算符        a << 2  输出结果 240 ，二进制解释： 1111 0000
>>              右移动运算符        a >> 2  输出结果 15 ，二进制解释：0000 1111

a = 10, b = 20

运算符              描述                实例
and    x and y     布尔"与"            如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值，(a and b) 返回 20
or x or y       布尔"或"            如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值，(a or b) 返回 10
not    not x       布尔"非"            如果 x 为 True，返回 False。如果 x 为 False，它返回 True，not(a and b) 返回 False

除了以上的一些运算符之外，Python 还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。

运算符              描述
in          如果在指定的序列中找到值返回 True，否则返回 False，
            即 x 在 y 序列中，如果 x 在 y 序列中返回 True
not in      如果在指定的序列中没有找到值返回 True，否则返回 False，
            即 x 不在 y 序列中，如果 x 不在 y 序列中返回 True

身份运算符用于比较两个对象的存储单元。

运算符                描述
is          is 是判断两个标识符是不是引用自一个对象    
            x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False。
is not      is not 是判断两个标识符是不是引用自不同对象
            x is not y ，类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。

以下表格列出了从最高到最低优先级的所有运算符：

运算符                      描述
**                          指数 (最高优先级)
~ + -                       按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
* / % //                    乘，除，取模和取整除
+ -                            加法减法
>> <<                       右移，左移运算符
&                           位 'AND'
^ |                         位运算符
<= < > >=                   比较运算符
<> == !=                    等于运算符
= %= /= //= -= += *= **=    赋值运算符
is is not                   身份运算符
in not in                   成员运算符
and or not                  逻辑运算符

s = 'abcd'
s = "abcd"
s = '''
    abcd
    efg
    '''
s = """
    abcd
    efg
    """

a = s[0]        # 访问第0个元素
l = len(s)        # 字符串的长度

a = “Hello”, b = “Python”
操作符              描述                                        实例
+               字符串连接                                  a + b 输出结果：HelloPython
*               重复输出字符串                              a*2 输出结果：HelloHello
[]              通过索引获取字符串中字符                    a[1] 输出结果：e
[ : ]           截取字符串中的一部分，遵循左闭右开原则      str[0,2] 是不包含第 3 个字符的
in              成员运算符                                  'H' in a 输出结果：True
not in          成员运算符                                  'M' not in a 输出结果：True
r/R             原始字符串                                  print(r'a\nb') # a\nb
%               格式字符串                                  a=10;print("今年我%s岁" %a) # 今年我10岁

Python 支持格式化字符串的输出。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。

print ("我叫%s今年%d岁!" %('小明', 10)) # 我叫小明今年10岁!
符号                描述
%c                格式化字符及 其ASCII 码
%s                格式化字符串
%d                格式化整数
%u                格式化无符号整型
%o                格式化无符号八进制数
%x                格式化无符号十六进制数
%X                格式化无符号十六进制数（大写）
%f                格式化浮点数字，可指定小数点后的精度
%e                用科学计数法格式化浮点数
%E                作用同 %e，用科学计数法格式化浮点数
%g                %f 和 %e 的简写
%G                %f 和 %E 的简写
%p                用十六进制数格式化变量的地址

方法                                        描述  
capitalize()                            将字符串的第一个字符转换为大写
endswith(suffix,beg=0,end=len(string))  检查字符串是否以 obj 结束
expandtabs(tabsize=8)                    把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8
find(str, beg=0 end=len(string))        检测 str 是否包含在字符串中，如果包含返回开始的索引值，否则返回-1
index(str, beg=0, end=len(string))        跟 find() 方法一样，只不过如果 str 不在字符串中会报一个异常
isalnum()                                如果字符串至少有一个字符并且所有字符都是字母或数字则返回 True，否则返回 False
isdigit()                                如果字符串只包含数字则返回 True，否则返回 False
isnumeric()                                如果字符串中只包含数字字符，则返回 True，否则返回 False
isspace()                                如果字符串中只包含空白，则返回 True，否则返回 False
join(seq)                                以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
len(string)                                返回字符串长度
lower()                                    转换字符串中所有大写字符为小写
lstrip()                                截掉字符串左边的空格或指定字符
max(str)                                返回字符串 str 中最大的字母
min(str)                                返回字符串 str 中最小的字母
replace(old, new [, max])                将字符串中的 str1 替换成 str2，如果 max 指定，则替换不超过 max 次
rfind(str, beg=0,end=len(string))        类似于 find()函数，不过是从右边开始查找
rindex( str, beg=0, end=len(string))    类似于 index()，不过是从右边开始
rstrip()                                删除字符串字符串末尾的空格   
split(str="",num=string.count(str))    num=string.count(str))  以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num 个子字符串
splitlines([keepends])                    按照行('\r', '\r\n', \n')分隔
startswith(str,beg=0,end=len(string))   检查字符串是否是以 obj 开头
strip([chars])                            在字符串上执行 lstrip()和 rstrip()
upper()                                    转换字符串中的小写字母为大写

list = [1, 2, 3, 4, 5, 'atguigu']
[x+1 for x in range(10)]    # range(10) = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]    输出结果是：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[x+1 for x in (1, 1, 2, 3)] # 输出结果是：(2, 2, 3, 4)

l  = list[0]
l1 = list2[1:5]
len(list)        #长度查看

list[0] = 'agg'

del list[0]

表达式                                  结果                            描述
len([1, 2, 3])                          3                               长度
[1, 2, 3] + [4, 5, 6]                   [1, 2, 3, 4, 5, 6]              组合
['Hi!']*4                               ['Hi!', 'Hi!', 'Hi!', 'Hi!']    重复
3 in [1, 2, 3]                          True                            元素是否存在于列表中
for x in [1, 2, 3]: print(x, end=" ")    1 2 3                           迭代

使用嵌套列表即在列表里创建其它列表，例如：

a = ['a', 'b', 'c']
n = [1, 2, 3]
x = [a, n]
# x = [['a', 'b', 'c'], [1, 2, 3]]
# x[0] = ['a', 'b', 'c']
# x[0][1] = 'b'

函数                                    描述
len(list)                                列表元素个数
max(list)                                返回列表元素最大值
min(list)                                返回列表元素最小值
list(seq)                                将元组转换为列表
list.append(obj)                        在列表末尾添加新的对象
list.count(obj)                         统计某个元素在列表中出现的次数
list.extend(seq)                        在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
list.index(obj)                         从列表中找出某个值第一个匹配项的索引位置
list.insert(index, obj)                 将对象插入列表
list.pop([index=-1])                    移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
list.remove(obj)                        移除列表中某个值的第一个匹配项
list.reverse()                          反向列表中元素
list.sort(cmp=None, key=None, reverse=False)        对原列表进行排序
list.clear()                            清空列表
list.copy()                             复制列表

tup1 = ('Google', 'atguigu', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
tup3 = "a", "b", "c", "d";   # 不需要括号也可以

tup1[1]
tup1[1:5]

元组不允许更新！

del tup[0]

表达式                          结果                            描述
len((1, 2, 3))                  3                               计算元素个数
(1, 2, 3) + (4, 5, 6)           (1, 2, 3, 4, 5, 6)              连接
('Hi!',) * 4                    ('Hi!', 'Hi!', 'Hi!', 'Hi!')    复制
3 in (1, 2, 3)                  True                            元素是否存在
for x in (1, 2, 3): print (x,)  1 2 3                           迭代(生成器)

方法                    描述                        实例
len(tuple)              计算元组元素个数            len(tuple1)
max(tuple)              返回元组中元素最大值        max(tuple2)
min(tuple)              返回元组中元素最小值        min(tuple2)
tuple(seq)              将列表转换为元组            示例如下       

list1= ['Google', 'Taobao', 'Runoob', 'Baidu']
tuple1=tuple(list1)     
tuple1 = ('Google', 'Taobao', 'Runoob', 'Baidu')

在字典中，键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行。

dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
dict = {x: x+1 for x in range(10)}  # 输出结果是：{0: 1, 1: 2, 2: 3, 3: 4, 4: 5, 5: 6, 6: 7, 7: 8, 8: 9, 9: 10}

dict['Alice']

dict['Alice'] = 10

del dict['Alice']
del dict

函数                描述
len(dict)           计算字典元素个数，即键的总数。
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
len(dict)

str(dict)           输出字典，以打印的字符串表示。
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
str(dict) 
"{'Name': 'Runoob', 'Class': 'First', 'Age': 7}"

type(variable)      返回输入的变量类型。
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
type(dict)
<class 'dict'>

-----------------------------------------------------

函数                                        描述
radiansdict.clear()                            删除字典内所有元素
radiansdict.copy()                            返回一个字典的浅复制
radiansdict.fromkeys()                        创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值
radiansdict.get(key, default=None)          返回指定键的值，如果值不在字典中返回 default 值
key in dict                                 如果键在字典 dict 里返回 True，否则返回 False
radiansdict.items()                            以列表返回可遍历的 (键, 值) 元组数组
radiansdict.keys()                            返回一个迭代器，可以使用 list() 来转换为列表
radiansdict.setdefault(key, default=None)   和 get() 类似, 但如果键不存在于字典中，将会添加键并将值设为 default
radiansdict.update(dict2)                    把字典 dict2 的键/值对更新到dict里
radiansdict.values()                        返回一个迭代器，可以使用 list() 来转换为列表
pop(key[,default])                          删除字典给定键 key 所对应的值，返回值为被删除的值。key 值必须给出，否则返回 default 值
popitem()                                    随机返回并删除字典中的一对键和值(一般删除末尾对)

-----------------------------------------------------

扩展：
1. 浅拷贝：只拷贝引用地址，未拷贝内容：
    a = [1, 2, 3, 4, 5] 
    b = a
2. 深拷贝：拷贝引用地址和内容：
    a = [1, 2, 3, 4, 5] 
    import copy 
    b = copy.deepcopy(a) 
可以递归拷贝；一拷到底
注意：
    1、对于不可变类型 Number String Tuple，浅复制仅仅是地址指向，不会开辟新空间。
    2、对于可变类型 List、Dictionary、Set，浅复制会开辟新的空间地址(仅仅是最顶层开辟了新的空间，里层的元素地址还是一样的)。
    3、浅拷贝后，改变原始对象中为可变类型的元素的值，会同时影响拷贝对象的；改变原始对象中为不可变类型的元素的值，只有原始类型受影响。

s = {'name', 'aa', 'bb'}
s = set(序列)   # dict序列，值添加 key
s = {x for x in range(10) if x not in range(5,10)}  # 结果是：{0, 1, 2, 3, 4}

s.add(x)        # 添加单个元素
s.update(x)        # 添加序列元素

s.remove(x)        # 移除单个元素
s.discard(x)    # 移除集合(不存在不报错)
s.pop()            # 随机删除集合中的一个元素

方法                            描述
len(s)                            查看集合的长度
s.clear()                        清空集合
x in s                             判断元素是否在集合中

add()                            为集合添加元素
clear()                            移除集合中的所有元素
copy()                            拷贝一个集合
difference()                    返回多个集合的差集
difference_update()                移除集合中的元素，该元素在指定的集合也存在。
discard()                        删除集合中指定的元素
intersection()                    返回集合的交集
intersection_update()            删除集合中的元素，该元素在指定的集合中不存在。
isdisjoint()                    判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
issubset()                        判断指定集合是否为该方法参数集合的子集。
issuperset()                    判断该方法的参数集合是否为指定集合的子集
pop()                            随机移除元素
remove()                        移除指定元素
symmetric_difference()            返回两个集合中不重复的元素集合。
symmetric_difference_update()   移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
union()                            返回两个集合的并集
update()                        给集合添加元素

if condition_1:
    statement_block_1
elif condition_2:
    statement_block_2
else:
    statement_block_3

1、每个条件后面要使用冒号 : 表示接下来是满足条件后要执行的语句块。
2、使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。
3、在 Python 中没有 switch – case 语句。

while bool：
    pass
else:
    pass

练习1：1-100 求和
练习2：输出 9*9 乘法表

for <variable> in <sequence>:
    <statements>

如果你需要遍历数字序列，可以使用内置 range() 函数。它会生成数列：
    range(start, end, step)

(1) break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止，任何对应的循环 else 块将不执行。
(2) continue 语句被用来告诉 Python 跳过当前循环块中的剩余语句，然后继续进行下一轮循环。

Python pass 是空语句，是为了保持程序结构的完整性。pass 不做任何事情，一般用做占位语句。

迭代是 Python 最强大的功能之一，是访问集合元素的一种方式。迭代器是一个可以记住遍历的位置的对象。迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。
迭代器有两个基本的方法：iter() 和 next()。

字符串，列表或元组对象都可用于创建迭代器。

list=[1, 2, 3, 4]
it = iter(list)        # 创建迭代器对象
print(next(it))        # 输出迭代器的下一个元素
print(next(it))

list=[1, 2, 3, 4]
it = iter(list)

(1)for循环
    for i in it:
        print(i)
(2)while循环
    import sys
    while True:
        try:
            print(next(its))
        except StopIteration:
            sys.exit()

把一个类作为一个迭代器使用需要在类中实现两个方法 __iter__() 与 __next__()

例如：
class MyNumbers:
    def __iter__(self):
        self.a = 1
        return self 
    def __next__(self):
        if self.a < 20:
            x = self.a
            self.a += 1
            return x
        else:
            raise StopIteration
    myclass = MyNumbers()
    myiter = iter(myclass) 
    print(next(myiter))
    for x in myiter:
          print(x)

在 Python 中，使用了 yield 的函数被称为生成器(generator)。跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。
在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值，并在下一次执行 next() 方法时从当前位置继续运行。

调用一个生成器函数，返回的是一个迭代器对象。
import sys
def fibonacci(n):                 # 生成器函数 - 斐波那契
    a, b, counter = 0, 1, 0
    while True:
        if (counter > n): 
          return
        yield a
        a, b = b, a + b
        counter += 1
f = fibonacci(10)                 # f 是一个迭代器，由生成器返回生成
while True:
    try:
        print(next(f), end=" ")
    except StopIteration:
        sys.exit()

def 函数名(参数列表):
    函数体

1. 有参数
    (1) 有几个参数，就得传入几个参数
    (2) 在函数调用中输入参数时，参数名称必须对应
            def aa(x):
                print(x)
            aa(x=5)
    (3) 当调用函数时，必须全部定义名称,且名称对应，顺序可以不同
            def aa(x, y):
                print(x)
            aa(y=2, x=5)
    (4) 函数中可以定义默认值
            def aa(x=30, y):
                print(x)
            aa(y=2, x=5)
    (5) 不定长度参数
            def aa(x, y, *args, **kwargs):
                print(x)
                print(args)     # 元组
                print(kwargs)   # 字典
            aa(1, 2, 3, 4, 5, 6, 7, a = 8, b=9)
2. 有返回值
    (1) 单个返回值
        def aa(x):
            return x
        a = aa(10)
    (2) 多个返回值
        def aa(x):
            return x, 10
        a = aa(10)        # a是一个元组
        a, b = aa(10)    # 多个参数接收

基本语法：
    lambda [arg1 [,arg2,.....argn]]:expression

    sum = lambda arg1, arg2: arg1 + arg2
    # 调用 sum 函数
    print("相加后的值为 : ", sum(10, 20))
    print("相加后的值为 : ", sum(20, 20))

L（Local）          局部作用域
E（Enclosing）      闭包函数外的函数中
G（Global）         全局作用域
B（Built-in）       内建作用域
L –> E –> G –>B     (在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，再者去内建中找)

x = int(2.9)                  # 内建作用域
g_count = 0                  # 全局作用域
def outer():
    o_count = 1              # 闭包函数外的函数中
    def inner():
        i_count = 2          # 局部作用域
        o_count += 1
    inner()
outer()

定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。
局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。
调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。

total = 0 # 这是一个全局变量
# 可写函数说明
def sum(arg1, arg2):
    # 返回2个参数的和."
    total = arg1 + arg2     # total 在这里是局部变量
    print("函数内是局部变量：", total)
    return total
#调用 sum 函数
sum(10, 20)
print("函数外是全局变量：", total)