1. 简单程序
   1. 标识符
      1. 含义
         1. 表示变量或操作名称
      2. 要求
         1. 必须以字母或下划线“_”开头
         2. 后跟字母、数字与下划线
   2. eval
      1. 作用
         1. 将input（‘字符串’）获取的字符串解析为表达式并求值
      2. 例
         1. m=eval(input(‘请输入整数1:’))
         2. n=eval(input(‘请输入整数2:’))
         3. print(‘m和n的差是：’,eval(m)-eval(n))
   3. Unicode编码值
      1. ‘A’65 ‘a’97
      2. ‘B’66 ‘b’98
      3. ‘C’67 ‘c’99
      4. ‘/‘47 ‘+’43
      5. ‘ ’32
   4. 数据输入与输出
      1. 输入函数
         1. 变量=input（‘字符串‘）
      2. 输出函数
         1. print（）
         2. sep
            1. 例(默认之间空格分隔)
            2. print("hello","wold")
            3. hello wold
            4. 例1(让之间有链接符)
            5. print("hello","wold",sep="-")
            6. hello-wold
            7. 例2(紧密相连)
            8. print("hello","wold",sep="")
            9. hellowold
         3. end
            1. 例1(自动换行)
            2. >>>print(1,2,3,4)
            3. >>>print(5,6,7,8)
            4. 1 2 3 4
            5. 5 6 7 8
            6. 例2(不换行)
            7. >>>print(1,2,3,4,end="")
            8. >>>print(5,6,7,8)
            9. 1 2 3 45 6 7 8
            10. 例3(换行)
            11. >>>print(1,2,3,4,end="\n")
            12. >>>print(5,6,7,8)
            13. 1 2 3 4
            14. 5 6 7 8
   5. 变量与赋值语句
      1. 变量的赋值
         1. 语法
            1. 变量=表达式
            2. 例：x=100
      2. 链式赋值语句
         1. 用于多个变量同时赋予相同的值
         2. 例1
            1. >>>x=y=z=200
            2. >>>print(x,y,z)
            3. 200 200 200
         3. 例2
            1. a,b=b,a（交换二者的值）
      3. 解包赋值语句
         1. 例
            1. >>>a,b=100,200
            2. >>>print(a,b)
            3. 100,200
   6. 数值
      1. 类型
         1. 整数类型：int（）
         2. 浮点类型：float（）
      2. 运算符
         1. +
            1. 加
         2. -
            1. 减
         3. *
            1. 乘
         4. /
            1. 实数除法
         5. //
            1. 整数除法
         6. %
            1. 取余
         7. **
            1. 乘方
      3. 函数
         1. abs(x)
            1. 求x的绝对值
         2. divmod(x,y)
            1. 输出（x//y，x%y）
         3. pow(x,y[,z])
            1. 输出（x**y）%z
         4. round(x[,ndigits])
            1. 对x四舍五入，保留ndigits位小数，如ndigits省略，则四舍五入后取整
         5. max(x1,x2……xn)
            1. 返回x1，x2……xn中最大值
         6. min(x1,x2……xn)
            1. 返回x1，x2……xn中最小值
      4. math库
         1. 引用方法
            1. 1
            2. >>>import math
            3. >>>print(math.需要引用的math)
            4. 2
            5. >>>from math import 需引用的math)
            6. >>>print(需引用的math)
         2. math库中的数学常数
            1. pi
            2. 圆周率
            3. e
            4. e
            5. inf
            6. 正无穷大，负无穷大为-inf
            7. man
            8. 非浮点数标记，Not a Number
         3. math库中的数值函数
            1. fabs(x)
            2. x的绝对值
            3. fmod(x,y)
            4. x除y的余数
            5. fsum([x,y……])
            6. 浮点数精确求和
            7. gcd(x,y)
            8. x和y的最大公约数，x和y为整数
            9. trunc(x)
            10. x的整数部分
            11. modf(x)
            12. x的小数和整数部分
            13. ceil(x)
            14. 向上取整，返回不小于x的最小整数
            15. floor(x)
            16. 向下取整，返回不小于x的最大整数
            17. factorial(x)
            18. x的阶乘，x为整数
            19. pow(x,y)
            20. x的y次幂
            21. sqrt(x)
            22. x的平方根
   7. m=‘bird,fish,monkey,rabbit’
   8. n=‘bird,fish,monkey,fish,rabbit’
   9. s=‘Hello Mike’
   10. 混合类型与转换
       1. 类型自动转换
          1. int和float对象可以混合运算，int对象会自动转换（隐式转换）成float对象
          2. 例1
             1. >>>f=24+24.3
             2. >>>type(f)
             3. <class ’float’>
       2. 类型强制转换
          1. >>>int(2.32)
          2. 2
2. 字符串
   1. 数据类型
      1. 单引号（‘ ’）
      2. 双引号（” ”）
      3. 三单引号(‘’’ ‘’’)
      4. 三双引号(“““ ”””)
      5. 可跨行
   2. 索引与切片
      1. 索引
         1. 从左到右：0 —— n-1
         2. 从右到左：-n —— -1
         3. 语法
            1. 变量[序号]
         4. 例
            1. >>>s[0]
            2. ‘H’
      2. 切片
         1. 变量[头下标: 尾下标] （含头不含尾）
            1. 例1
            2. >>>print(s[0:5])
            3. ‘Hello’
            4. 例2（正反可一起使用）
            5. >>>s[6:-1]
            6. ‘Mik’
            7. 例3（省前则从头开始）
            8. >>>s[:5]
            9. ‘Hello’
            10. 例4（省后则坚持最后）
            11. >>>s[6:]
            12. ‘Mike’
            13. 例5（全省就从头到尾）
            14. >>>s[:]
            15. ‘Hello Mike’
         2. 步长
            1. >0
            2. 从左向右，每n个字符取一次
            3. 例
            4. >>>s[0:5:1]
            5. hello
            6. <0
            7. 从右向左，｜步长｜-1，需头>尾，否则为空格
            8. 例
            9. >>>[4:0:-1]
            10. olle
   3. 处理与操作
      1. 运算符
         1. +
            1. 字符串拼接
            2. “ab”+“123”——“ab123”
         2. *
            1. 字符串复制
            2. “ab”*3——ababab
         3. in
            1. 判断是否为字串
            2. “h” in “Hello”——False
            3. “H” in “Hello”——True
      2. 处理函数（直接）
         1. len(x)
            1. 返回字符串x的长度
            2. >>>len(s)
            3. 10
         2. str(x)
            1. 将任意类型x转换为字符串类型
            2. 例1
            3. >>>str(123)
            4. ‘123’
            5. 例2
            6. >>>str(3+2)
            7. ‘5’
         3. chr(x)
            1. 返回Unicode编码为x的字符
            2. >>>chr(65)
            3. ‘A’
         4. ord(x)
            1. 返回字符x的Unicode编码值
            2. >>>ord(‘A’)
            3. 65
         5. 相互转换
      3. 处理办法（变量.）
         1. 查找
            1. find()
            2. 指定范围（默认整个）首次出现的位置
            3. >>>m.find(‘fish’)
            4. 5
            5. rfind()
            6. 指定范围（默认整个）最后出现的位置
            7. >>>m.rfind(‘b’)
            8. 20
            9. index()
            10. 指定范围（默认整个）首次出现的位置
            11. >>>m.index(‘bird’)
            12. 0
            13. rindex()
            14. 指定范围（默认整个）最后出现的位置
            15. >>>m.rindex(‘i’)
            16. 21
            17. count()
            18. 出现次数
            19. >>>m.counnt(‘b’)
            20. 3
            21. 不存在则返回0
            22. 不存在则返回-1
            23. 不存在则返回异常
         2. 分隔
            1. split()
            2. 左端开始
            3. 例1
            4. >>>m.split(‘,’)
            5. [‘bird’,’fish’,’monkey’,’rabbit’]
            6. 例2
            7. >>>m.split(‘:’)
            8. [‘bird,fish,monkey,rabbit’]
            9. 例3
            10. >>>m.split(‘b’)
            11. [‘’,‘ird,fish,monkey,ra’,‘’,‘it’]
            12. rsplit()
            13. 右端开始
            14. 最大分隔次数
            15. 例：
            16. >>>m.rsplit(‘,’,maxsplit=2)
            17. [‘bird,fish’ ,‘monkey’ ,‘rabbit’]
            18. 不管是split和rsplit，都用maxsplit
            19. partition()
            20. 左端开始的第一个分隔串开始分隔
            21. >>>n.partition(‘fish’)
            22. (‘bird’,‘fish’，‘monkey，fish，rabbit’)
            23. rpartition()
            24. 右端开始的第一个分隔串开始分隔
            25. >>>n.rpartition(‘fish’)
            26. (‘bird，fish，monkey’，‘fish’，‘rabbit’)
            27. 以(‘字符’)为分界点，去除字符，其他为整体，默认按空白分隔，不存在则返回原串
            28. 分隔符不存在则返回原串和两个空串
         3. 连接
            1. join()
            2. 用‘字符串’作连接符
            3. 例1
            4. >>>li='fish,monkey,bird'
            5. >>>‘:’.join(li)
            6. ‘f:i:s:h:,:m:o:n:k:e:y:,:b:i:r:d’
            7. 例2
            8. >>>li=['fish,monkey,bird']
            9. >>>‘:’.join(li)
            10. 'fish,monkey,bird'
            11. 例3
            12. >>>li=[‘fish’,‘monkey’,‘bird’]
            13. >>>‘:’.join(li)
            14. ‘fish’:‘monkey’:‘bird’
         4. 大小写转换
            1. lower()
            2. 转小写
            3. upper()
            4. 转大写
            5. capitalize()
            6. 首字母大写
            7. title()
            8. 每个单词首字母大写
            9. swapcase()
            10. 大小写转换
         5. 替换
            1. replace()
            2. 替换指定字符（每次只能替换一个，生成新字符串）
            3. >>>q=‘你是我的小呀小苹果’
            4. >>>q.replace(‘小’,’small’)
            5. ‘你是我的small呀small苹果’
         6. 删除
            1. strip()
            2. 删除两端
            3. rstrip()
            4. 删除右端
            5. lstrip()
            6. 删除左端
         7. 判断开始或结束点
            1. startswich()
            2. 检测开始
            3. endswich()
            4. 检测结束
         8. 判断字符串类型
            1. isupper()
            2. 判断是否全为大写
            3. islower()
            4. 判断是否全为小写
            5. isdigit()
            6. 判断是否全为数字
            7. isalnum()
            8. 判断是否为数字或汉字
            9. isalpha()
            10. 判断是否全为字母或汉字
         9. 排版
            1. center()
            2. 居中对齐
            3. ljust()
            4. 居左对齐
            5. rjust()
            6. 居右对齐
            7. zfill()
            8. 输出宽度为（），在左侧以0填充
   4. 格式化方法
      1. {}
         1. 不指定位置
            1. ’字符串{}字符串{}’.format(‘插入’,’插入’)
            2. 例
            3. >>>‘我是{}班{}号的学生’.format(‘2’,’3’)
            4. ‘我是2班3号的学生’
         2. 指定位置(从0开始)
            1. ’字符串{0}字符串{1}’.format(‘插入0’,’插入1’)
            2. 例
            3. >>>‘我是{1}班{0}号的学生’.format(‘2’,3)
            4. 我是3班2号的学生
      2. %
         1. '%d'%填充字符串
      3. 格式设置项
         1. ‘{:填充字符对齐字符数字}’.format(‘字符串’)
         2. 设置项
            1. 填充字符
            2. ‘*’,’=’,’-’等，只能一个字符，默认空格
            3. 对齐方式
            4. ‘^’居中，’<‘左对齐，‘>’右对齐
            5. 宽度
            6. 一个整数，指格式话后整个字符串的字符个数
         3. 例1（*填充，居中，宽10）
            1. >>>’{:*^10}’.format(‘Mike’)
            2. ‘***Mike***’
         4. 例2 （保留4位小数）
            1. >>>’{:.4f}’.format(3.14159)
            2. ‘3.1415’
         5. 例3（空格填充，整数默认右对齐，宽5，整数形式输出）
            1. ‘{:5d}’.format(24)
            2. ‘ 24’
         6. 例4（=填充，居中，宽30，保留4位小数)
            1. >>>’{:=^20.4f}’.format(3.14159)
            2. ‘=======3.1415=======’
3. 流程控制
   1. 条件表达式
      1. 关系运算符
         1. !=
            1. 不等于
         2. ==
            1. 等于
         3. >
            1. 大于
         4. <
            1. 小于
         5. >=
            1. 大于等于
         6. <=
            1. 小于等于
      2. 逻辑运算符
         1. and
            1. 并且
         2. or
            1. 或者
         3. not
            1. 取反
      3. 条件表达式
         1. 变量%2==0
            1. 偶数
         2. 变量%3==0 and 变量%10==5
            1. 3的倍数且个位上为5
         3. (a+b>c) and (b+c>c) and (a+c>b)
            1. a、b、c为能构成三角形的三段线
   2. 结构选择
      1. 单分支结构：if语句（一种情况）
         1. 语法
            1. if 条件表达式：
            2. 语句块
         2. 例1（用文件式）
            1. a,b=1,2
            2. if a<b:
            3. a,b=b,a
            4. print(a,b)
         3. 语法（短）
            1. if 条件表达式：语句块
         4. 例2（短的可写一排）
            1. a,b=1,2
            2. if a<b:a,b=b,a
            3. print(a,b)
      2. 双分支结构：if-else语句（两种情况，非一即二）
         1. 语法
            1. if 条件表达式：
            2. 语句块1
            3. else：
            4. 语句块2
         2. 例1
            1. str=input(‘请输入字符串：’)
            2. if (str==str[::-1])：
            3. print(str+‘为回文串’)
            4. else：
            5. print(str+‘非回文串’)
         3. 语法（短）
            1. 语句块1 if 条件表达式 else 语句块2
         4. 例2（短可写一排）
            1. str=input(‘请输入字符串：’)
            2. print(str+‘为回文串’) if str==str[::-1] else print(str+’非回文串’)
      3. 多分支结构：if-elif-else语句（多种情况的一种）
         1. 语法
            1. if 条件表达式1:
            2. 语句块1
            3. elif 条件表达式2:
            4. 语句块2
            5. elif 条件表达式3:
            6. 语句块3
            7. …
            8. else:
            9. 语句块n
      4. 嵌套的if结构
         1. 例
            1. num=int(input(‘请输入三位数’))
            2. a=str(num)[0]
            3. #取百位
            4. b=str(num)[1]
            5. #取十位
            6. c=str(num)[2]
            7. #取个位
            8. if a>b:
            9. if a>c:
            10. max_num=a
            11. else:
            12. max_num=c
            13. else:
            14. if b>c:
            15. max_num=b
            16. else:
            17. max_num=c
            18. print(str(num)+’中最大的数字是：’+max_num)
   3. 循环结构
      1. for语句
         1. 语法
            1. for 变量 in 迭代器：
            2. 语句块
         2. 字符串作为迭代器
            1. 例
            2. for s in ‘abide’:
            3. print(s,end=‘ ’)
            4. a b i d e
         3. range()函数生成迭代序列
            1. 语法1
            2. range（n）
            3. 从0开始，到n-1结束
            4. 语法2
            5. range（m，n）
            6. 从m开始，到n-1结束
            7. 语法3
            8. range（m，n，d）
            9. 从m开始，每隔d-1个取(正增负减)，到n-1结束
            10. 例1(求1～100的整数和)
            11. sum=0
            12. for i in range(1,100+1):
            13. sum=sum+i
            14. print(‘sum=’,sum)
            15. sum=5050
            16. 例2（求1～100的奇偶和）
            17. sum_old=0
            18. sum_even=0
            19. for i in range(1,100+1):
            20. if i%2==1: #i为奇数
            21. sum_old=sum_old+i
            22. else: #i为偶数
            23. sum_even=sum_even+i
            24. print(‘1~100中奇数和为：’,sum_old)
            25. print(‘1~100中偶数和为：’,sum_even)
      2. while语句
         1. 语法
            1. while 条件表达式：
            2. 语句块
         2. 用法：先求条件表达式的值，若值为True则重复执行至出现False。需要自己管理循环中的变量
         3. 例(求1～100的整数和)
            1. sum=0
            2. i=1
            3. while i<=100:
            4. sum=sum+i
            5. i=i+1
            6. print(‘sum=’,sum)
      3. break和continue语句
         1. break #遇到即结束
            1. 例(求1～10不能对3取余的数)
            2. for i in range(1,11):
            3. if i%3==0:
            4. break
            5. print(i,end=‘ ‘)
            6. 1 2
         2. continue #遇到跳过继续
            1. 例(1～10不能对3取余的数)
            2. for i in range(1,11):
            3. if i%3==0:
            4. continue
            5. print(i,end=‘ ‘)
            6. 1 2 4 5 7 8 10
         3. #用法：只能出现在循环内，且只能控制包含着它们的最内层循环
      4. 循环结构中的else子句
         1. break可以阻断else语句
         2. 例
            1. for i in range(5):
            2. print(i,end=‘ ‘)
            3. if i>=3:break
            4. else:
            5. print(‘for 循环正常结束’)
            6. 0 1 2 3
      5. 循环的嵌套
         1. 例1
            1. for m in range(2):
            2. for i in range(10):
            3. print(‘*’,end=‘ ‘)
            4. print()
            5. * * * * * * * * * *
            6. * * * * * * * * * *
         2. 例2
            1. for m in range(1,3+1):
            2. for i in range(1,m+1):
            3. print(‘*’,end=‘ ‘)
            4. print()
            5. for m in range(1,3+1):
            6. for i in range(4-m):
            7. print(‘*’,end=‘ ‘)
            8. print()
            9. *
            10. * *
            11. * * *
            12. * * *
            13. * *
            14. *
   4. random库
      1. 函数
         1. random()
            1. 在[0.0,1.0)中抽一个随机浮点数
         2. randrange(n)、randrange(n,m)
            1. 返回给定区间中一个随机整数
         3. randint(n,m)
            1. 相当于randrange(n,m+1)
         4. choise(s)
            1. 从序列s中随机选择一个元素
         5. uniform(n,m)
            1. 生成一个[n,m]之间的随机小数
         6. sample(pop,n)
            1. 从pop类型中随机抽取n个元素，以列表类型返回
         7. shuffle(n)
            1. 将序列中的元素随机排列后返回
         8. seed(n)
            1. 用整数n重制随机数生成器。利用系统时间。
      2. 例1
         1. >>>from random import*
            1. # ” * “代表所有对象
         2. >>>random()
         3. 0.2559038928926731
      3. 例2
         1. >>>randrange(0,10,2)
         2. 0
4. 列表与元组
   1. 元组tuple()
      1. 1. 1. 列表list()
   2. 列表
      1. 内容
         1. 注
            1. 列表，字典，集合本身可变
            2. 字符串，元组，集合的元素，字典的键不可变
         2. 表示
            1. [列表]，之间用 ”,“ 隔开
            2. 可存放不同类的元素
            3. 列表元素类型不受限制
      2. 操作
         1. 元素
            1. 索引
            2. 列表名[索引]
            3. 列表名.index(元素)
            4. 查找指定元素，在则返回元素索引，不存在则报错，存在多个返回最小的索引
            5. 修改
            6. 列表名[索引]=新值
            7. 增加
            8. 列表名.append(新元素)
            9. 相当于“[列表+新元素]“，在尾部添加
            10. 列表名.insert(索引，新元素)
            11. 可插入指定位置
            12. 删除
            13. 列表名.pop(索引)
            14. 删除并返回该元素
            15. 缺乏索引时默认删除最后的元素
            16. 列表名.remove(元素)
            17. 可直接删除该元素
            18. 重复时删排在前面的
            19. del 列表名[索引]
            20. [:]清空元素
            21. 列表名.clear()
            22. 清空元素
            23. 其他
            24. len(列表名)
            25. 用于统计和返回列表长度
            26. 列表名.count(元素)
            27. 统计并返回其中指定元素的个数，没有时返回0
            28. 检测
            29. 元素 in 列表
            30. 判断元素是否在列表，在则True，不在则False
            31. 元素 not in 列表
            32. 与以上相反
         2. 整体
            1. 遍历
            2. range()函数
            3. 例
            4. >>>l=[1,2,3,4]
            5. >>>for i in range(2):
            6. print('hello,{}.'.format(s[i]))
            7. hello,1.
            8. hello,2.
            9. for 元素 in 列表
            10. 例（小偷问题）
            11. t=['A','B','C','D']
            12. for x in t:
            13. if (x!='A')+(x!='D')+(x=='C')+(x!='C')==3:)
            14. print('小偷是：',x)
            15. break
            16. 排序
            17. 列表名.sort()
            18. 元素从小到大排序，基于编码值
            19. 默认元素第一个元素的关键字来排序
            20. 原地排序，改变原来列表
            21. sorted(列表名,reverse)
            22. 与以上不同就是生成新列表
            23. 切片
            24. 列表[起始：终止：步长（可省）]
            25. 扩充
            26. +
            27. 列1+列2
            28. 生成新列表，原来的不变
            29. 列表.extend(新列表)
            30. 将新列表添加到列表尾部，改变原来的列表
            31. *
            32. 列表*数字
            33. 生成新列表，原来的不变
            34. 复制
            35. 深拷贝(独立)
            36. 切片方法
            37. 语法
            38. 列Copy=列[:]
            39. 例
            40. >>>l=1,2,3,4
            41. >>>lCopy=l[:]
            42. >>>lCopy
            43. [1,2,3,4]
            44. Copy方法
            45. 语法
            46. 列Copy=列.copy()
            47. 例
            48. >>>l=[1,2,3,4]
            49. >>>lCopy=l.copy()
            50. >>>lCopy
            51. [1,2,3,4]
            52. 浅拷贝(共享)
            53. 赋值
            54. 语法
            55. 列1=列
            56. 例
            57. >>>l=[1,2,3,4]
            58. >>>l1=l
            59. >>>l1
            60. [1,2,3,4]
            61. 删除
            62. del 列
      3. 数值列表
         1. 创建
            1. input()输入
            2. 语法
            3. 列=eval(input())
            4. 例
            5. >>>l=eval(input())
            6. [1,3,4,2]
            7. >>>l
            8. [1,3,4,2]
            9. list()转换
         2. 生成
            1. range()生成
            2. 语法
            3. 列=[循环变量式 for 循环变量 in range（数）]
            4. 例
            5. >>>l=[i for i in range(1,5)]
            6. >>>l
            7. [1,2,3,4]
   3. 元组
      1. 内容
         1. 定义
            1. （元组）
            2. 可直接用“，”定义元组
         2. 注
            1. 元素不可修改
            2. 只有一个元素时，一定要加“，”
      2. 操作
         1. 对列表元素修改的都不能使用
         2. sorted()排序结果位列表
         3. 深拷贝可以，浅拷贝不行
         4. 元组可充当列表元素
5. 字典与集合
   1. 字典dict()
      1. 1. 2. 集合set()
   2. 字典
      1. 内容
         1. 定义
            1. {键：值}，之间用“，”隔开
         2. 注
            1. 键不可改，唯一；值可改，不唯一
            2. {}只能为字典
            3. 只可用键访问值，不可用值访问键
      2. 访问
         1. 语法
            1. 字典[键]
            2. 不能用数字
         2. 例
            1. >>>d={'z':100,'y':299,'x':399}
            2. >>>d['y']
            3. 299
      3. 操作
         1. 条目
            1. 添加
            2. 字典[键]=值
            3. 修改
            4. 字典[键]=值
            5. #必须为存在的条目，否则为添加
            6. 删除
            7. 指定删除
            8. del 字典[键]
            9. 字典.pop(键，默认值)
            10. 例1（可返回被删除的值）
            11. >>>d={'z':100,'y':299,'x':399}
            12. >>>d.pop（'z'）
            13. 100
            14. 例2（键不存在时需给默认值）
            15. >>>d={'z':100,'y':299,'x':399}
            16. >>>d.pop('c',400)
            17. 400
            18. 例3（必须要有参数）
            19. >>>={'z':100,'y':299,'x':399}
            20. >>>d.pop()
            21. 报错
            22. 随机删除
            23. 字典.popitem()
            24. 以元组形式返回被删除的条目
            25. 查找
            26. 键 in 字典
            27. 存在True，不存在False
            28. 字典.get(键，默认值)
            29. 存在则返回键对应的值，不存在则返回默认值
         2. 整体
            1. 遍历
            2. 键
            3. 字典.keys()
            4. 例
            5. >>>d={'z':100,'y':299,'x':399}
            6. >>>d.keys()
            7. dict_keys(['z', 'y', 'x'])
            8. for key in 字典.keys()
            9. 例
            10. >>>d={'z':100,'y':299,'x':399}
            11. >>>for key in d.keys():
            12. print(key)
            13. z
            14. y
            15. x
            16. 值
            17. 字典.values()
            18. 例
            19. >>>d={'z':100,'y':299,'x':399}
            20. >>>d.values()
            21. dict_values([100, 299, 399])
            22. for value in 字典.values()
            23. 例
            24. >>>d={'z':100,'y':299,'x':399}
            25. >>>for value in d.values():
            26. print(value)
            27. 100
            28. 299
            29. 399
            30. 条目
            31. 字典.items()
            32. 例
            33. >>>d={'z':100,'y':299,'x':399}
            34. >>>d.items()
            35. dict_items([('z', 100), ('y', 299), ('x', 399)])
            36. for item in 字典.items()
            37. 例
            38. >>>d={'z':100,'y':299,'x':399}
            39. >>>for item in d.items():
            40. print(item)
            41. ('z', 100)
            42. ('y', 299)
            43. ('x', 399)
            44. 排序
            45. 语法
            46. sorted(字典)
            47. 例（按键的Unicode值从小到大）
            48. >>>d={'z':100,'y':299,'x':399}
            49. >>>sorted(d)
            50. ['x', 'y', 'z']
            51. 删除
            52. 字典.clear()
            53. 清空所有条目，只剩{}
            54. del 字典
            55. 删除字典
            56. 合并
            57. for循环
            58. 例
            59. >>>d1={'z':100,'y':299,'x':399}
            60. >>>d2={'m':2,'n':1}
            61. >>>for k,v in d2.items():
            62. d1[k]=v
            63. >>>d1
            64. {'z':100,'y':299,'x':399,'m':2,'n':1}
            65. >>>d2
            66. {'m':2,'n':1}
            67. 字典1.update(字典2)
            68. 例（只变字典1）
            69. >>>d1={'z':100,'y':299,'x':399}
            70. >>>d2={'m':2,'n':1}
            71. >>>d1.uptade(d2)
            72. >>>d1
            73. {'z':100,'y':299,'x':399,'m':2,'n':1}
            74. >>>d2
            75. {'m':2,'n':1}
            76. dict（）
            77. 例1（先列后典）
            78. >>>d1={'z':100,'y':299,'x':399}
            79. >>>d2={'m':2,'n':1}
            80. >>>ls=list(d1.items())+list(d2.items())
            81. #变为列表相加
            82. >>>dict(ls)
            83. #使ls变为字典
            84. >>>ls
            85. {'z':100,'y':299,'x':399,'m':2,'n':1}
            86. >>>d2
            87. {'m':2,'n':1}
            88. 例2
            89. >>>d1={'z':100,'y':299,'x':399}
            90. >>>d2={'m':2,'n':1}
            91. >>>d1=dict(d1,**d2)
            92. >>>d1
            93. {'z':100,'y':299,'x':399,'m':2,'n':1}
            94. >>>d2
            95. {'m':2,'n':1}
   3. 集合
      1. 内容
         1. 定义
            1. {元素}，之间用“，”隔开
         2. 注
            1. {}不为集合
            2. 确定性，互异性，无序性
            3. 集合元素不可变
      2. 操作
         1. 访问
            1. for遍历
            2. 例（生成10个0~20之间的随机数）
            3. >>>ls=[]
            4. #创建列表
            5. >>> for i in range(20):
            6. ls.append(random.randint(0,20))
            7. #添加列表元素
            8. >>> s=set(ls)
            9. >>> print(s)
            10. {6, 0, 19, 11, 19, 17, 7, 17, 16, 10, 19, 15, 10, 20, 11, 20, 1, 12, 2, 11}
            11. 全输出
         2. 添加
            1. 集合.add(不可变数据元素)
            2. #将元素直接加到集合中
            3. 集合.update(可变数据元素)
            4. #将元素拆分重组后加入
         3. 删除
            1. 集合.remove(元素)
            2. #元素不存在会报错
            3. 集合.discard(元素)
            4. #元素不存在则无反应
            5. 集合.pop()
            6. #从中随机删除并返回一个元素
            7. 集合.clear()
            8. #清空元素
         4. 判断
            1. 元素 in集合
            2. #存在为True，不存在False
      3. 运算
         1. 交集
            1. A|B
            2. #二者相同的元素
            3. A.union(B)
         2. 并集
            1. A&B
            2. #二者一起的元素
            3. A.intersection(B)
         3. 差集
            1. A-B
            2. #二者重复的元素
            3. A.difference(B)
         4. 对称差集
            1. A^B
            2. #二者不同的元素
            3. A.symmetric_difference(B)
6. 函数
   1. 基本概念
      1. 名称
         1. 例
            1. abs（x）
            2. #电脑内置函数，求绝对值
            3. #函数名abs
            4. #形式参数x
            5. #函数返回值：x的绝对值
            6. abs（-1）
            7. #实际参数-1
      2. 分类
         1. 内置函数
            1. abs()、len()
         2. 标准库函数
            1. math、random
         3. 第三方库函数
            1. jieba、numpy、requests
         4. 自定义函数
   2. 使用
      1. 内容
         1. 语法
            1. def 函数名([参数列表])：
            2. 函数体
         2. 注
            1. 圆括号内是形参，如有多个参数则用“，”分开
            2. 函数体可使用return语句返回值。
            3. return可以有多条，但一旦第一条被执行，函数终止（=break）。可出现在函数体任何位置
      2. 调用
         1. 语法
            1. 函数名([实参])
         2. 注
            1. 实参必须与形参一一对应（顺序，数量）
            2. 函数如果有返回值，则可以在表达式中继续使用，没有则可以单独做表达式使用
            3. 需要调用才能运行函数
         3. 例
            1. >>>def f(a,b):
            2. return a+b
            4. >>>f(12,13)
            5. 25
         4. 例2(return返回)
            1. def get_max(a,b):
            2. #定义函数，在a，b中谁大
            3. v=a
            4. if b>a:
            5. v=b
            6. return v
            7. #把v值返回给外界
            8. i=get_max(5,8)
            9. #相当于i=8
            10. print(i)
      3. 参数
         1. 默认值参数
         2. 名称传递参数
         3. 可变参数
      4. 返回多个值
   3. lambda()函数
      1. 内容
         1. 定义
         2. 注
   4. 变量的作用域
      1. 局部变量
      2. 全局变量
   5. 递归函数
      1. 定义
      2. 注