py3000愉快的开始

摆渡终极鉴黄师

非正经的笔记：PYTHON是所有语言中最容易阅读编写与理解的
                         PYTHON能用少得多的代码写出相同的程序
                         一个优秀的程序猿只能维护两万多行的代码量
                         课后可以看一下bbs.fishc.com/thread-35584-1-1.html
                         PYTHON是应用面最广的语言
                         大家可以学到什么： 0 Python3的所有常用语法
                                                         1 面向对象编程思维
                                                         2 运用模块进行编程
                                                         3 游戏编程
                                                         4 计算机仿真
正经笔记：PYTHON3与前版本PYTHON不兼容【具体改动可以看bbs.fishc.com/forum.php?mod=viewthread&tid=35509&highlight=python3】

摆渡终极鉴黄师

正经笔记:www.python.org/getit上下载Python3或以上的版本
             Python Shell是一个通过键入文本与程序交♀互的途径（外壳）
             >>>这个提示符，Ta的含义是告诉你，可以开♀始了
                >>>printf("I love fishc.com");#杉浦小春（青梅竹马）
                >>>print ("I love fishc.com")#冬马和纱（冬马小三）
                【最后Python选择了小三】
             >>>print(5+3)
             8
             >>>5+3
             8
             >>>233333333333*6666666666
             1555555555397777777778
             >>>print("番茄"+"炒蛋")
             番茄炒蛋
             >>>print("里番"*8)
             里番里番里番里番里番里番里番里番
             >>> print("里番\n"*8)
             里番
             里番
             里番
             里番
             里番
             里番
             里番
             里番
             听完课后可以看这个http://bbs.fishc.com/forum-243-1.html，然后可以惊喜的发现         

摆渡终极鉴黄师

      Ctrl+N新建一个Python
      F5是执行代码
      Python的缩进和C++里的括号一样重要（Tab缩进）
      输入代码时按Tab会弹出一些可能输入的代码供你选择
      if函数的讲解（略）
      >>> dir(__builtins__)，然后>>> help(你想查询的代码)可以查到相应的解释

摆渡终极鉴黄师

         Python并不是把值存储在变量中，而更像是把值贴在值的上边。所以某种意义上说，Python没有变   量，只有名字。
         变量的命名理论可以 取 任何合法的名字，但作为一个优秀的程序猿，请将尽量给变量一个专业一点儿的名字，例如
         >>>t = '小甲鱼'
         >>>xxoo = '小甲鱼'
         >>>teacher = '小甲鱼'     
         第三个就比较标准了
         >>> 3+5
         8
         >>> '3'+'5'
         '35'
          \这个符号是转义字符，例如>>> 'Let\'s go!'
         "Let's go!"（反斜杠也可以对自身进行转义）
         如果碰到很多个反斜杠，加上r即可，加在这个位置上，例如>>> str = r'C:\now\fishc\a'
         >>> print(str)
         C:\now\fishc\a
         如果需要得到一个跨越多行的字符串，这个时候需要用到三重引号！~例如>>> str = """在死之前,
         任何时候努力
         都不晚"""
         >>> print(str)
         在死之前,
         任何时候努力
         都不晚

         

摆渡终极鉴黄师

   1、 Python 的比较操作符 >   左边大于右边
        >=左边大于等于右边
        <左边小于右边
        <=左边小于等于右边
        ==左边等于右边
        !=左边不等于右边
   2、条件分支——Python的条件分支语法
        if  条件 ：
            条件为针（True）执行的操作（注：无论里面有多少行代码，最后都只会返回一个针值）
        else:
            条件为假（False）执行的操作（注：无论里面有多少行代码，最后都只会返回一个假值）例如          temp = input("猜数字")
guess = int(temp)
if guess == 6:
        print("那你很胖哦~")
        print("你被忽悠了，啊哈哈哈什么也没有")
else:
        if guess > 6:
                print("大了大了")
        else:
                print("小了小了")
print("GAME OVER")

摆渡终极鉴黄师

         >>> 3>2 and 1<2
         True
         >>> (3>2) and (1<2)
         True
         >>> (3>2) and (1>2)
         False
         每次运行程序产生的答案是随机的，这需要引入外援：random模块，这个random模块里边有一个函数叫randint()，Ta会返回一个随机的整数，我们可以利用这个整数来改造我们的炉石！哦不，游戏。例如（还有while函数的例子，都写在一起了，例如）
import random
secret = random.randint(0,9)
print('--------成功往往是最后一分钟来访的客人-------')
temp = input("猜数字：")
guess = int(temp)
while guess != secret:
    temp = input("哎呀，猜错了~~不要灰心，再来一次：")
    guess = int(temp)
    if guess == secret:
        print("哎哟不错哟")
        print("""你可以重新打开这个程序再试一次，
因为这个游戏的正确答案是随机生成的一个数字啊哈哈哈~~这可真蠢~""")
    else:
        if guess > secret:
            print("大了~~")
        else:
            print("小了~~")
print("GAME OVER^^")

         

摆渡终极鉴黄师

        python2的话长整型后面要加个l，python3把Ta们结合起来了，所以不用加l了，类似于我们的java的（重放好多遍没听清..）啥啥啥，Ta的长度呢不受限制，如果非要来个限制，那只限制于计算机这个虚拟内存的总数，所以python3很容易进行大数运算
>>> 15e10
150000000000.0
>>> 0.00000000000000000000233
2.33e-21
>>> True +  True
2
>>> True + False
1
>>> True * False
0
>>> a = '520'
>>> b = int(a)
>>> b
520
>>> b = int('小甲鱼')
Traceback (most recent call last):
  File "<pyshell#9>", line 1, in <module>
    b = int('小甲鱼')
ValueError: invalid literal for int() with base 10: '小甲鱼'
>>> a = 5.99
>>> c = int(a)
>>> c
5（如果浮点数，转化为整数，python会采用截断处理，因为这样效率高~记住喔不是四舍五入，是直接舍掉后面的大树，哦不，小树）
>>> a = '520'
>>> b = float(a)
>>> b
520.0
>>> a = 5.99
>>> b = str(a)
>>> b
'5.99'
>>> c = str(5e19)
>>> c
'5e+19'
>>> str = "nope"
>>> str
'nope'
>>> c = str(5e19)
Traceback (most recent call last):
  File "<pyshell#23>", line 1, in <module>
    c = str(5e19)
TypeError: 'str' object is not callable（因为str自从被当做变量名来使用之后，Ta就相当于被赋予了另外一种身份。而当你再度使用Ta的时候，python会认为说，用Ta的新身份来 代替 以前的这个BIF，所以会导致出错，好，就是这么一个原因。简单的来说就是一个只能放一个东西的小盒子里已经放进去的一个东西了，暂时不能再放其他东西了，除非你先取出来才能再放东西）
(int,float,Bool,都是BIF，BIF是内置函数的意思。简单的来说，浮点型float就是有小数点的小数，例如↑，整型int就是整数，这个BIF的作用就是讲 一个字符串啊，浮点数啊，转化为一个整数，例如↑。布尔类型Bool_返回的值就是1或0，就是真值或假值，同时也是一个特殊的整数，True表示1，False表示0，这个数据是可以用来计算的，例如↑。str这个BIF的作用呢，是一个数 或任何其他类型 转化为一个字符串，例如↑。这些是python3的一些数据类型，还有一个e记法不是一个数据类型哈，e记法就是我们平时所说的科学计数法，e的意思就是10的意思，e后面跟的数字就是10的几次方的意思)例如↑

摆渡终极鉴黄师

         type()函数，python提供了Ta，这个内置函数(BIF)能够明确告诉我们变量的类型。例如>>> a = '520'
>>> type(a)
<class 'str'>
>>> type(5.2)
<class 'float'>
>>> type(True)
<class 'bool'>
>>> type(5e15)
<class 'float'>
        isinstance()函数，python文档更建议我们用Ta这个BIF来确定变量的类型。这个BIF有两个参数，第一个是待确定类型的数据，而第二个参数呢是指定一个数据类型，Ta会返回一个布尔类型的值，True表示两个参数类型一致，False表示两个参数类型不一致，例如>>> a = '小甲鱼'
>>> isinstance(a, str)
True
>>> isinstance(a, int)
False
>>> isinstance(320, int)
True
>>> isinstance(320.25,float)
True
>>> isinstance(320.25, bool)
False

摆渡终极鉴黄师

>>> a = 5
>>> a = a + 3
>>> a += 3（a = a + 3 的简写形式）
>>> b = 3
>>> b -= 1（b = b - 1 的简写形式）
>>> b
2
>>> a
11
>>> a = b = c = d = 10
>>> a += 1
>>> b -= 3
>>> c *= 10（c = c * 10 的简写形式）
>>> d /= 8 （d = d / 8 的简写形式）
>>> a
11
>>> b
7
>>> c
100
>>> d（现在的python3是真正的除法）
1.25
>>> 10 // 8（地板触发，就是取小于结果的最大整数）
1
>>> 5 % 2（%是取余数的意思）
1
>>> 11 % 2
1
>>> 3 ** 2（**是幂运算的意思）
9
>>> 3 ** 5
243

摆渡终极鉴黄师

>>> -3 * 2 + 5 / -2 - 4
-12.5
>>> ((-3) * 2) + (5 / (-2)) - 4
-12.5
>>> (3 < 4) and (4 < 5)
True
>>> -3 ** 2
-9
>>> -(3 ** 2)
-9
>>> 3 ** -2（负号贴在数字前面的优先级大于这些符号的优先级）
0.1111111111111111
操作符优先级，例如↑
        and操作符只有当Ta的左侧，或右侧，同时为真，就是为True的时候，Ta的结果，才为真，才为True
        那么or操作符的话呢跟and有很大的不同，几乎可以说是反过来的，or操作符的话呢，其实只需要左边，或者，右边，两边任意一边为真，那么结果就为真。or操作符，只有当两边同时为假的时候，结果才为False，才为假
        not操作符呢，Ta是一个一元操作符，因为Ta只有一个操作数。Ta跟着的这个操作数，Ta对它起什么作用呢？Ta就是，把Ta的这个操作数，取这个操作数相反的布尔类型的值，例如
>>> not True
False
>>> not False
True
>>> not 0
True
>>> 3 < 4 < 5（这个表达式在其他编程语言里一般来说是不合法的，但是在python行得通，Ta被解释为>>>(3 < 4) and (4 < 5)
True
幂运算        【排行第一】                          **（当幂运算Ta的左侧是一个一元运算符的时候，Ta的优先级比这个一元运算符高，当幂运算Ta的右侧是一个一元运算符的时候，Ta的优先级比这个一元运算符低）
正负号        【排行第二】                  +x          -x
算术操作符 【排行第三】               *     /     //   +  -（先乘除，在加减，如果是，同一行的，先左边，后右边）
比较操作符 【排行第四】       <   <=   >   >=   ==   !=
逻辑操作符 【排行第五】  not                and                  or （事实上呢，这里的话呢，not的优先级要比and高，and的优先级要比or高，但是呢，把Ta们列在一行，是没有什么差别的）

摆渡终极鉴黄师

加载背景音乐
播放背景音乐（设置单曲循环）
我方飞机诞生
interval = 0

while True:
     if 用户是否点击了关闭按钮:
              退出程序
      interval += 1
      if interval == 50:
               interval = 0
               小飞机诞生
              
     小飞机移动一个位置
     屏幕刷新

     if 用户鼠标产生移动:
               我方飞机中心位置 = 用户鼠标位置
               屏幕刷新

     if 我方飞机与小飞机发生肢体冲突:
                我方挂,播放撞击音乐
                修改我方飞机图案
                打印“Game over”
                停止背景音乐,最好淡出

摆渡终极鉴黄师

score = int(input('请输入您的分数：'))
if 100 >= score >= 90:
    print('A')
if 90 > score >= 80:
    print('B')
if 80 > score >= 60:
    print('C')
if 60 > score >= 0:
    print('D')
if score < 0 or score > 180:
    print('输入错误!')


score = int(input('请输入您的分数：'))
if 100 >= score >= 90:
    print('A')
else:
    if 90 > score >= 80:
        print('B')
    else:
        if 80 > score >= 60:
            print('C')
        else:
            if 60 > score >= 0:
                print('D')
            else:
                print('输入错误!')


score = int (input('请输入一个分数:'))
if 100 >= score >= 90:
    print('A')
elif 90 > score >= 80:
    print('B')
elif 80 > score >= 60:
    print('C')
elif 60 > score >= 0:
    print('D')
else:
    print('输入错误!')
else:  if 可以合并为elif
python可以有效避免“悬挂else”，因为python可以强制缩进
第三种写法使程序运行起来最快

摆渡终极鉴黄师

        什么叫“悬挂else”？
        例如C语言里的
if( hi > 2 )
        if( hi > 7 )
                printf("真棒！");
else
        printf("的确很棒");（由于C语言的就近匹配原则，这个else会和第二个if进行匹配，初学者的话可能一不小心就弄混淆了，导致很多BUG的出现。Python就不会发生这种情况，Python的缩进使用了强制的规定，通过限制你的选择从而减少了这个不确定性，如果第一个if搭配else，这样就行了，如果第二个if搭配else，需要Tab缩进一下else就可以了，因为在Python中Ta们属于同一个缩进级别，OK）         
         条件表达式（三元操作符，三元操作符有三个操作数，一元操作数有一个操作符，二元操作符有二个操作数）例如
x, y = 4, 5
if x < y:
        small = x（例如我们的赋值号，我们这个赋值号=，Ta有两个操作数，对不对，分别是Ta的左边的small和右边的这个x，分别是Ta的两个操作数，我们就叫Ta为二元操作符，而当我们的一个，这个，减号-，当作符号的时候，Ta就是表示一个一元操作符，Ta只有一个操作数嘛，就是把这个数变成一个负数，那么三元操作符，按照理论来说，就有三个操作数喽，啊~，对的）
else:
        small = y
        例子可以改为
small = x if x < y else y
语法  →   x if 条件 else y（当我们这个条件，if后面的这个条件为真的时候，Ta把x的值给了我们的small，当这个条件为假的时候，把我们的y值给了我们这个small，所以呢，我们就可以把这么多个语句，哈，把这么多个判断和赋值的语句，直接变成一个语句，了事，OK）————条件表达式（三元操作符）
        assert这个关键字我们称之为“断言”，当这个关键字后边的条件为假的时候，程序自动崩溃并抛出AssertionError。反正就是呢，Ta会自己崩溃。例如>>>assert 3 > 4
        一般来说我们可以用Ta在程序中置入检查点，当需要确保程序中的某个条件一定为真才能让程序正常工作的话，assert关键字就非常有用了。例如
>>> assert 3 > 4
Traceback (most recent call last):
  File "<pyshell#0>", line 1, in <module>
    assert 3 > 4
AssertionError（Ta就自爆了）
>>> assert 4 > 3（Ta就pass过去了）————断言assert

摆渡终极鉴黄师

语法：
while 条件:（比如说条件是i = 10）
        循环体 （循环体里边有一条语句是i += 1，那么每执行一次循环体，我的条件的i就会加1，直到什么呢，直到i = 10的时候，OK，那么Ta就是条件为假了，那么Ta就会退出这个循环）————while循环


python的计数器循环
语法：
for        目标         in        表达式：
     循环体
例如
>>> favourite = 'FishC'
>>> for i in favourite:
        print(i, end=' ')

F i s h C


>>> member = ['甲鱼','老甲鱼','小甲鱼']
>>> for each in member:
        print(each, len(each))

       
甲鱼 2
老甲鱼 3
小甲鱼 3                                            ————for循环


语法：
range([strat,]) srop[, step=1]
这个BIF有三个参数，其中用中括号括起来的两个表示这两个参数是可选的。（用中括号括起来的，表示这个是可选的参数，也就是“不是必要的参数”——非必要参数，哈）
step=1表示第三个参数的默认值是1。（就是说你不传任何数据进去的话step的默认值等于1）
range这个bif的作用是生成一个从start参数的值开始到stop参数的值结束的数字序列。（就是说贴在strat,后面的数，如果是1的话就从1开始，贴在,step=1前面的数，如果是5的话，那么就5结束。贴在strat,后面的数是1，贴在,step=1前面的数是5的话呢，Ta就会生成一个1234这么一个序列，注意，哈，不包含5）例如>>> range(5)
range(0, 5)
>>> list(range(5))
[0, 1, 2, 3, 4]

>>> for i in range(2, 9):（传递两个参数，注意哈，没有包含9，第一个数是包含的，最后一个数是不包含的）
        print(i)

       
2
3
4
5
6
7
8

>>> for i in range(1, 10, 2):（传递三个参数，第三个数是步进的数，就是比如说第三个数为2的话就是每一次步进2）
        print(i)

       
1
3
5
7
9                                                          ————range()                              

摆渡终极鉴黄师

break的作用是终止一个循环并跳出一个循环体，并执行下边的代码，例如
bingo = '小甲鱼很大'
answer = input('请输入小甲鱼最想听的一句话：')

while True:
    if answer == bingo:
        break
    answer = input('抱歉，错了，请重新输入（您真不是小甲鱼肚子里的蛔虫啊！）')

print('哎呦，不错喔~')
print('你知道的太多了')


continue在开始下一轮循环之前，Ta会先测试一下循环条件，只有循环条件为True的时候Ta才会开始下一轮循环，如果不会的话，Ta会退出循环，例如
for i in range(10):
    if i%2 != 0:（这里i是奇数的意思，奇数的话执行下面代码）
        print(i)
        continue（如果i不是奇数，那么在符合条件的情况下只能为偶数，偶数的话执行下面的代码）
    i += 2
    print(i)

F5执行
2
1
4
3
6
5
8
7
10
9

摆渡终极鉴黄师

python的数组可以把你一切可以在python里看到的东西打包进去，例如整数、浮点数、字符串、对象（小甲鱼这样比喻：如果数组比作一个集装箱的话，那么python的列表就是一个工厂的厂库了）

如何向列表里添加元素呢？

创建一个普通的列表，例如
>>> member = ['小甲鱼','甲鱼','老甲鱼','123']
>>> member
['小甲鱼', '甲鱼', '老甲鱼', '123']
>>> number = [1, 2, 3, 4, 5]
>>> number
[1, 2, 3, 4, 5]
>>> mix = [1, '小甲鱼', 3.14, [1, 2, 3]]
>>> mix
[1, '小甲鱼', 3.14, [1, 2, 3]]
>>> empty = []（创建一个空列表）
>>> empty
[]（打印出来了空列表）


>>> member = [1, '小甲鱼', 3.14, [1, 2, 3]]
>>> member.append('葫芦娃娃')           （member.append这个点.可以暂且理解为范围的意思。在对象里边，我们把这个属于对象的函数称之为方法，append这个方法呢，是属于我们这个member列表对象的，属于member的一个方法。所以我们用这个点作用域来进行限制）
>>> member
[1, '小甲鱼', 3.14, [1, 2, 3], '葫芦娃娃']
>>> len(member)
5

错误的例子
>>> member.append('竹中半兵卫', '羽柴秀吉')
Traceback (most recent call last):
  File "<pyshell#18>", line 1, in <module>
    member.append('竹中半兵卫', '羽柴秀吉')
TypeError: append() takes exactly one argument (2 given)（意思就是说呢，这个东西Ta确实是需要一个参数而已，但是Ta打了括号给你说，你给Ta两个参数Ta会解释不了）                                                                                              ————append
                                                     


extend是一个扩张的方式，来扩展这个列表，Ta可以同时把两个同学同时加进去
错误的例子
>>> member.extend('竹中半兵卫', '植物大战僵尸')
Traceback (most recent call last):
  File "<pyshell#12>", line 1, in <module>
    member.extend('竹中半兵卫', '植物大战僵尸')
TypeError: extend() takes exactly one argument (2 given)


extend这个方法呢，原理是使用一个列表扩展另一个列表，所以Ta的参数应该是一个列表，也就是说，我们需要用一个列表把这些东西包含进来
正确的例子
>>> member.extend(['竹中半兵卫', '植物大战僵尸'])
>>> member
[1, '小甲鱼', 3.14, [1, 2, 3], '葫芦娃娃', '竹中半兵卫', '植物大战僵尸']
>>> len(member)
7                                                                                                                                          ————extend                                          


insert  Ta有两个参数，第一个参数代表在列表中的位置，第二个参数表示在第一个参数的位置插入一个元素，例如
>>> member.insert(1, '牡丹')
>>> member
[1, '牡丹', '小甲鱼', 3.14, [1, 2, 3], '葫芦娃娃', '竹中半兵卫', '植物大战僵尸']
（但凡是顺序索引我们均是从0开始。因为计算机本身是二进制的，0是二进制里边的第一个数，10进制的第一个数也是0，秉承着这种传统，0也就习惯用于第一个数的一个形式）                                                                                                  ————insert

摆渡终极鉴黄师

跟数组一样，我们可以通过元素的索引值（index）从列表获取单个元素，注意，列表索引值是从0开始的
例如我们可以把小甲鱼放到最前面，例如
>>> member = [1,'小甲鱼','小飞碟','竹子']
>>> member[0]
1
>>> member[1]
'小甲鱼'
>>> temp = member[0]
>>> member[0] = member[1]
>>> member
['小甲鱼', '小甲鱼', '小飞碟', '竹子']
>>> member[1] = temp
>>> member
['小甲鱼', 1, '小飞碟', '竹子']


从列表删除元素
remove()
remove只需要知道这个元素具体的名字，不需要知道Ta的位置，但是Ta的名字你可能不能搞错
例如
>>> member.remove(1)
>>> member
['小甲鱼', '小飞碟', '竹子']


del
Ta呢，这个呢不是一个列表的方法，Ta是一个语句，哈，del语句（Ta不是一个函数，也不是一个方法，所以不用括号，Ta是黄色的）
例如
>>> del member[1]
>>> member
['小甲鱼', '竹子']


pop
pop方法呢是从列表中取出一个元素并返回给你，所以呢你可以这么干，例如
>>> member.pop()          （那么这个member.pop()呢Ta会返回一个值，就是你剔除哪一个，Ta就会返回哪一个）
'竹子'
>>> member
['小甲鱼']

我们还可以吧出来的朋友给Ta赋值（因为Ta有返回值）例如
>>> name = member.pop()
>>> name
'小甲鱼'
>>> member
[]

其实pop方法，Ta还可以加上一个参数，例如
>>> member = ['naive', '基本法', '搞个大新闻', '图样图森破', '+1s']
>>> member.pop(4)
'+1s'
然后这个列表就少了+1s

这就是从列表删除元素的三个方式


列表分片（Slice）（也叫做切片，不过大多数情况下叫分片）
利用索引值，每次我们可以从列表获取一个元素，但是我们总是贪心的，如果一次性需要获取多个元素，有没有办法实现呢？利用列表分片，我们可以简单的实现这个要求，例如
del member               （删除列表）
>>> member = ['naive', '基本法', '搞个大新闻', '图样图森破', '+1s']
>>> member[1:3]     （我们只是利用了一个冒号隔开了两个索引值，左边的那个索引值呢 表示 这个 需要开始的位置，开始的下标，例如说这个1基本法是位于这个下标为1的索引值的位置，右边的那个呢 是结束的位置，01234，'+1s'是4，但是呢 4是不包含的，注意，Ta是不包含的，3-1是等于2，那么Ta就会分片分出两个元素出来，利用列表分片，我们可以得到的是一个原来列表的拷贝。）
['基本法', '搞个大新闻']

原来的列表并没有发生任何的改变，例如
>>> member
['naive', '基本法', '搞个大新闻', '图样图森破', '+1s']（还是5个元素）

Ta还可以这样，把后边的索引值去掉，例如
>>> member[1:]
['基本法', '搞个大新闻', '图样图森破', '+1s']

或是这样，把前面的索引值去掉，例如
>>> member[:3]
['naive', '基本法', '搞个大新闻']

或是这样，把两个索引值都去掉，例如
>>> member[:]
['naive', '基本法', '搞个大新闻', '图样图森破', '+1s']      （我们就会得到一个原来列表的拷贝）

如果你想对列表进行某些修改，但是同时你又想保持原来的列表，那么你直接使用冒号，我们就可以获得原来列表的拷贝，例如
>>> member2 = member[:]
>>> member2
['naive', '基本法', '搞个大新闻', '图样图森破', '+1s']    （现在的member2就等于member的一个拷贝了）

摆渡终极鉴黄师

比较操作符
列表也可以比大小，例如
>>> list1 = [123]
>>> list2 = [234]
>>> list1 > list2
False

放两个元素会这样比较大小，例如            
>>> list1 = [123, 456]
>>> list2 = [234, 123]
>>> list1 > list2（我们发现了，当有多个元素的时候，我们是从第0个元素开始比较的，只要有一个PK赢了，就算整个列表赢了，不用考虑后边的元素，这个 跟我们 字符串的比较是同一个道理，字符串比较的话 就是比较ascll码的 这个大小，其实 可以把逻辑操作符也加入进去，例如）
False
>>> list3 = [123, 456]
>>> (list1 < list2) and (list1 == list3)      （这个括号不用也可以，我们为了使整个程序看起来比较优雅，比较容易读懂，读你的代码的人不费劲，所以有一些必要的括号还是加上比较好）
True

我们知道字符串呢，用加号可以去拼接，用乘号来复制若干次，那么在列表身上，也可以实现的
>>> list4 = list1 + list2
>>> list4
[123, 456, 234, 123]   （类似于我们之前的list.extend()   extend方法，extend方法扩展列表会显得这个语法更为规范，不要随便用这个+，来扩展列表，因为 使用这个+的话呢有一些操作是违规的，这里必须要指出的是 连接操作符，也就是这个加号，不能实现添加一个新元素的操作，否则Ta会报错，例如）
>>> list1 + '热心的小甲鱼'
Traceback (most recent call last):
  File "<pyshell#10>", line 1, in <module>
    list1 + '热心的小甲鱼'
TypeError: can only concatenate list (not "str") to list    （因为 加号两边必须对象的类型是一致的，左边是一个列表，右边就必须是一个列表，然后进行一个拼接的操作，所以 如果你想要添加一个元素到列表中 我们用append方法 或者 用insert方法）

也可以用重复操作符 星号*    例如
>>> list3
[123, 456]
>>> list3 * 3
[123, 456, 123, 456, 123, 456]

也可以复合到赋值操作符里边去运行的    例如
>>> list3 *= 3
>>> list3
[123, 456, 123, 456, 123, 456]    （Ta原地改变了list3的值）
>>> list3 *= 5
>>> list3
[123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456]（也改变了，对不对）


成员关系操作符
成员关系操作符有两个，in  和  not in  例如
>>> 123 in list3
True
>>> '小甲鱼'not in list3
True
>>> 123 not in list3
False

列表里边还可以包含着一个列表，对于列表里边的列表里边的元素，不能直接用in和not in来进行这个测试并返回True和False，例如
>>> list5 = [123, ['小甲鱼', '小埋'], 456]
>>> '小甲鱼' in list5
False    （那我们明明看到了列表里边有只小甲鱼啊，但是呢，小甲鱼是在列表里边的列表，所以这看起来 in和not in呢只能判断一个层次的成员关系了呀，这跟我们的break和continue只影响一层的循环 的道理是一样的）

那我们要判断列表里边的列表与元素，应该先人为的，引入一层，例如
>>> '小甲鱼' in list5[1]
True
（那么对于列表中的列表中的值，我们应该用两个框框来访问，例如）
>>> list5[1][1]
'小埋'
                                                                                                                       ————列表的一些常用操作符

摆渡终极鉴黄师

>>> dir(list)
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

count是计算Ta的参数在列表中出现的次数，例如
>>> list3 = [123, 456]
>>> list3 *= 15
>>> list3
[123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456]
>>> list3.count(123)
15
（123出现了15次）

index是索引的意思，这个方法呢会返回Ta的参数在列表中的位置，例如
>>> list3.count(123)
15
>>> list3.index(123)
0                     （其实Ta还有两个默认的参数，两个参数呢就是 提供你需要找到Ta这个第一个出现的位置的一个范围，例如）

>>> list3.index(123, 3, 7)
4
（这两个方法其实不是很重要，知道就行了）

reverse的意思就是逆袭，Ta的作用呢是将整个列表原地翻转，就是说 把排到最后的拍到了最前面，把排到最前面的元素放到最后，例如
>>> list3.reverse()
>>> list3
[456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123]

sort方法就是，用指定的方式对列表的成员进行排序，默认的话呢也是跟reverse一样不需要参数的，默认的话Ta是从小到大进行排队，例如
>>> list6 = [4, 2, 5, 1, 9, 23, 32, 0]
>>> list6.sort()
>>> list6
[0, 1, 2, 4, 5, 9, 23, 32]

sort这个方法呢其实有三个参数，另外一个参数呢，另外一个参数呢叫做func 就是指定排序的算法，还有一个参数呢叫做key 就是跟这个算法搭配的关键字，这个默认使用的话呢 是使用归并排序，这两个都是默认的我们不用去管Ta，默认知道是归并排序就可以了
第三个参数是叫什么呢，是叫reverse，跟这个reverse方法一个名字，但这个是一个参数，Ta默认的话呢Ta是等于False的，就是等于没有逆袭的，如果改成True的话呢，那问题就简单了，例如
>>> list6.sort(reverse=True)
>>> list6
[32, 23, 9, 5, 4, 2, 1, 0]
>>> list6.sort(reverse=False)
>>> list6
[0, 1, 2, 4, 5, 9, 23, 32]
>>> list6.sort(reverse=False)
>>> list6
[0, 1, 2, 4, 5, 9, 23, 32]

上节课补充——
>>> list7 = [0, 1]
>>> list7
[0, 1]
>>> list8 = list7
>>> list8
[0, 1]
>>> list9 = list7[:]
>>> list9
[0, 1]
>>> list7.sort(reverse=True)
>>> list7
[1, 0]
>>> list8
[1, 0]
>>> list9
[0, 1]
（简单的来说，这里的等于就类似于给一个固定的东西多加了一个标签，等于加冒号才是实实在在的进行拷贝）

摆渡终极鉴黄师

元组和列表，最大的区别，是列表你可以任意修改其中的元素，Ta的权限非常大，可以任意的插入或者删除一个元素，非常的灵活，而元祖是不行的，元祖显得比较古板，对于元祖来说，元祖是不可以任意插入或者删除一个元素的，元祖是不可改变的，就像我们这个字符串一样，所以也不能指望可以对远祖进行原地排序等等的高级操作，不行，noway，另外一个显著的区别就是，创建列表用的是中括号，创建元祖的时候，大部分用的是小括号，例如
>>> tuple1 = (1, 2, 3, 4, 5, 6, 7, 8)
>>> tuple1
(1, 2, 3, 4, 5, 6, 7, 8)
>>> tuple1[1]
2
>>> tuple1[5:]
(6, 7, 8)
>>> tuple1[:5]
(1, 2, 3, 4, 5)
>>> tuple2 = tuple1[:]
>>> tuple2
(1, 2, 3, 4, 5, 6, 7, 8)             （这些和列表都是一样的，要不怎么说是亲兄弟呢）

元祖是不可以被修改的，例如
>>> tuple1[1] = 3
Traceback (most recent call last):
  File "<pyshell#7>", line 1, in <module>
    tuple1[1] = 3
TypeError: 'tuple' object does not support item assignment

就算加上了小括号，Ta也不一定是元祖，例如
>>> temp = (1)
>>> temp
1
>>> type(temp)
<class 'int'>

就算没有小括号的话，temp2还是元组类型，例如
>>> temp2 = 2, 3, 4
>>> type(temp2)
<class 'tuple'>

所以呢，是不是元祖，逗号是关键，小括号不是关键，例如
>>> temp = (1,)
>>> type(temp)
<class 'tuple'>

>>> temp = 1,
>>> type(temp)
<class 'tuple'>

如果想创建一个空元祖的话呢，直接用一个小括号，例如
>>> temp = ()
>>> type(temp)
<class 'tuple'>

——————————————————————————————————————————————————
>>> 8 * (8)
64
>>> 8 * (8,)
(8, 8, 8, 8, 8, 8, 8, 8)
加了逗号，说明括号里边的内容是个元祖，所以这个乘号不再是乘号了，Ta在这里是重复操作符