初学Python笔记 2020.3.30更新

规范

---

内嵌函数

无需import就能之间使用的函数

map(<函数名>,<迭代类型>)	#将第一个参数的功能作用于第二个参数的每一个元素。	对组合数据类型的每个元素都执行一次第一个函数

---

python小细节

• 因为Python的诞生比Unicode标准发布的时间还要早，所以最早的Python只支持ASCII编码，普通的字符串’ABC’在Python内部都是ASCII编码的。但是在Unicode标准发布以后 新版的Python，就开始逐渐基于Unicode码了，但是Unicode码的0-127和ASCII码还是一样的。

---

pip命令

安装第三方库

pip install XXX	//原版
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple XXX	//清华源下载
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple XXX --ignore-installed six		//错误时重新下载
pip download <第三方库名>		//下载但不安装

http://pypi.douban.com/simple/   //豆瓣源地址

更新库

pip list --outdated		//查看可更新的库
pip install --upgrade XXX		//对准备更新的库进行更新
pip insatll -U

卸载库

pip uninstall XXX	//卸载库

其他

pip show <第三方库名>		//列出某个库的详细信息
pip search <关键词>		//根据关键词在名称和介绍中搜索库
pip list			//查看已安装库

---

引用库

import <库名>				#一般导入库
<库名>.<函数名>(<函数参数>)
----------------------------------
from <库名> import <函数名>#省去库名.    可能会有函数重名问题
from <库名> import *		#导入全部函数，省去库名.
<函数名>(<函数参数>)		
-----------------------------------
import <库名> as <库别名>	#起一个小名
<库别名>.<函数名>(<函数参数>)

---

关于开头coding=utf-8

开头的coding=utf-8和coding:utf-8的作用是一样的。

作用是声明python代码的文本格式是utf-8，python按照utf-8的方式来读取程序。

如果不加这个声明，无论代码中还是注释中有中文都会报错。

---

注意事项

IDLE自动屏蔽了\r的光标回到行首的功能

---

txt文件字体编码转换

直接拿txt打开，然后文件>另存为>编码 进行更改

---

Python基本方法

1. # 单行注释

2. ''' 多行注释，多行字符串

3. not true = false

4. type(target) 返回target的类型

5. open("a.txt","r",encoding="utf-8").read() （r.可读）打开文件

6. print(x,end="")

   end=""表示不换行，无end则默认为换行，最后加信息在end=“信息”

7. ; 一行显示多行代码，之间用;分隔

8. \ 一行代码分成多行，之间用\分隔

9. r"\String" 字符串前加r，反转义

---

turtle库

import turtle as t
t.title("画画程序")	#设置窗口标题栏的信息
t.setup(800,600,100,100)#设置窗体800*600，位置在(100,100)
t.penup()		#起笔
t.pendown()		#落笔
t.fd(100)		#向前移动100单位
t.seth(30)		#绝对角度30度，逆时针
t.right(90)		#向右转90度
t.left(90)		#向左转90度
t.write('秒',font=('Arial',18,'normal'))#绘制文字(设置字体)
t.goto(-50,100)	#画笔到(-50,100)的位置
t.pensize(2)	#笔的大小为2
t.pencolor('blue')	#设置笔的颜色为blue

t.speed(10)		#设置画笔速度(1慢~10快)
t.hideturtle()	#隐藏海龟
t.done()		#绘制结束不退出窗口

---

基本数据类型

数字类型及操作

• 整数

  可正可负，无取值范围限制

  • 4种进制表示形式

    1. 十进制

       1010,99,-217

    2. 二进制

       以0b/0B（零b）开头：0b010,-0B101

    3. 八进制

       以0o/0O开头：0o123,-0O456

    4. 十六进制

       以0x/0X开头：0x9a,-0X89

  • 函数（可嵌套）

    pow(x,y)	x的y次方，x**y
    

• 浮点数

  带有小数点，取值约±10**308，基本无限制

  精度数量级为10**-16，存在不确定尾数

  • 科学计数法：使用e/E为幂的符号

    e 表示a*10**b

    4.3e-3 值为0.0043 9.6E5 值为960000.0

  • 函数

    round(x,d)		对x四舍五入，保留d位小数
    

• 复数

  -a+bj为复数，a是实部，b是虚部

  • 函数

    z.real		获得实部
    z.imag		获得虚部
    

• 操作符

  类型间可进行混合运算，生成结果为"最宽"类型

  整数->浮点数->复数 123+4.0=127.0

  x+y
  x-y
  x*y
  x/y		除，10/3结果为3.3333333333333335
  x//y	整数除，向下取整，10/3结果为3
  +x		x本身
  -y		y的负值
  x%y		求余，为整数，-7%3=2
  x**y	x的y次方（y为小数即开方）
  

• 运算函数

  abs(x)			返回x的绝对值
  divmod(x,y)		返回商和余数(x//y,x%y)的二元数
  				#divmod(10,3) -> (3,1)
  pow(x,y[,z])	计算x的y次方，如果z在存在，则再对结果进行取模，其结果等效于pow(x,y) %z。
  				#让范围在余数范围内，加快运行速度
  round(x[,d])	四舍五入，d是保留小数位，默认为0取整
  max(a,b,c..)	返回序列最大值
  min(a,b,c..)	返回序列最小值
  ------------------------------------------
  int(x)			变为整数，舍弃小数部分，x可以是字符串
  float(x)		变为浮点数，增加小数部分，x可以是字符串
  				#float(1)->1.0;float('1.2')->1.2
  complex(x)		变为复数，增加虚数部分
  				#complex(4) -> 4+0j
  

字符串类型及操作

• 表示方式

  单行字符串：'字符串'/"字符串" （为了字符串中可以出现引号）

  多行字符串：'''多行\n字符串'''/"""多行\n字符串""" （单双都能出现）

• 序号

  

• 表示

  • 索引

    <字符串>[M] 返回单个字符

  • 切片

    <字符串>[M:N] 返回一段字符子串[M:N)

  • 切片高级用法

    <字符串>[M:N:K] M缺失表示至开头，N缺失表示至结尾

    ​ K为步长，加K取一个

    “〇一二三四五六七八九十”[1:8:2] -> “一三五七”

    [::-1] 字符串逆序

    “〇一二三四五六七八九十”[::-1] -> “十九八七六五四三二一〇”

  • 转义符\

    \b 回退

    \n 换行（到下行首）

    \r 回车（光标到本行首)

• 操作符

  x+y			连接两个字符串x和y
  n*x或x*n		复制n次字符串x
  x in s 		判断x是否为s的子串，返回T/F
  

• 处理函数

  len(x)		返回字符串长度，字符的个数
  str(x)		变成字符串类型，加引号，对应eval()
  			#str(1.23)->"1.23";str([1,2])->"[1,2]"
  hex(x)/oct(x)	整数x变为十六进制/八进制小写类型字符串
  			#hex(425)->"0x1a9"
  chr(u)		Unicode编码 -> 字符（有引号''）
  ord(x)		字符 -> Unicode编码(万国码)（无引号''）
  		#0~1114111(0x10FFFF)空间，几乎有全世界字符
  

• 方法

  str.lower()/str.upper()#返回全小写/大写的字符串副本
  str.split(sep=None)
  		#返回一个列表，由str根据sep被分隔的部分组成
  		#"A,B,C".split(",") -> ['A','B','C']
  str.count(sbu)		#返回子串sub出现的次数，计数
  str.replace(old,new)	#返回所有old子串替换为new
  str.center(width[,fillchar])
  	#返回str根据宽度width居中，其余部分用fillchar填充
      	#'a'.center(5,'=') -> '==a=='
  str.strip(chars)	#在str去除左右两侧chars列出的字符
  str.join(iter)	#在iter中每个元素之间加一个str
      	#格式化字符串输出，",".join("123")->'1,2,3'
  

• 格式化

  <模板字符串>.format(<逗号分隔的参数>)

  槽 { } {0}对应.format后参数的序号

  {<参数序号>:<格式控制标记>} 槽内部对格式化的配置方式：

  

  <,> #输出数字是字符串的情况下，表示是否要千位分隔符

  >>>"{0:=^20}".format("YALY")   #0是槽的序号，可以重复
  '========YALY========'
  >>>"{0:*>15}".format("滑稽")
  '*************滑稽'
  >>>"{:10}".format("爬")
  '爬         '	#默认填充空格
  >>>'{:.1f}'.format(3.16)	#四舍五入，保留一位小数
  '3.2'
  
  #b二进制、c字符Unicode形式、d十进制、o八进制、x十六进制、X大写的十六进制
  >>>'{0:b},{0:c},{0:d},{0:o},{0:x},{0:X}'.format(425)
  '110101001,Ʃ,425,651,1a9,1A9'
  
  #e/E是e/E形式科学计数法、f是通常非科学计数法、%百分号表示
  '{0:e},{0:E},{0:f},{0:%}'.format(3.14)
  '3.140000e+00,3.140000E+00,3.140000,314.000000%'
  

---

程序的控制结构

分支结构

• 单分支

  if <条件>:
  	<语句块>
  

• 二分支

  if <条件/True>:
      <语句块1>
  else :
      <语句块2>
     
  #紧凑形式：适用于简单表达式的二分支结构
  <表达式1> if <条件> else <表达式2>
  #表达式!=语句 不支持赋值
  guess = eval(input())
  print('猜{}看'.format('对' if gusee==99 else '错'))
  

• 多分支

  if <条件>:
      <语句块1>
  elif <条件>:		#True执行
  	<语句块2>
      ......
  else:
      <语句块2>
  

• 条件判断和组合

  x and y		//逻辑与
  x or y		//逻辑或
  not x		//逻辑非
  

• 异常处理

  try:
      <语句块1>
  except:
      <语句块2>
  ------------------------------------------    
  try:
      <语句块1>
  except:<异常类型>   #异常提醒里的名称
      <语句块2>
      
  try:
      num = eval(input('请输入一个整数：'))
     	print(num**2)	#平方
      except NameError:
          print('输入的不是整数')
      #标注异常类型后，仅响应该异常，异常类型名字等同于变量
  

• 异常处理的高级用法

  try:		#先执行语句块1
      <语句块1>
  except:		#发生异常后执行语句块2
      <语句块2>
  else:		#不发生异常时执行语句块3，奖励语句块
      <语句块3>
  finally:	#最后再执行语句块4
      <语句块4>
  

循环结构

• 遍历循环

  for <循环变量> in <遍历结构>:
      <语句块>
      
  #计数循环（N次）   默认从0开始，执行N次
  #遍历range()函数产生的数字序列，从[M开始到N)，K为步长
  for i in range([M,]N[,K]):		
      <语句块>
      
  #字符串遍历循环
  for <每个字符> in <字符串>:
      <语句块>
      
  for c in '鸭梨亚':
      print(c,end=',')
  >>>鸭,梨,亚,
  
  #列表遍历循环
  for tiem in ls:
      <语句块>
      
  #文件遍历循环
  for line in fi:	#fi文件标识符，遍历fi文件每行，产生循环
      <语句块>
  

• 无限循环（条件控制）

  while <条件>:
      <语句块>		#直到条件不满足
  

• 循环控制保留字

  break		#跳出并结束当前整个循环，执行循环后的语句
  			#一个break只能跳出一层循环
  
  continue	#结束档次循环，继续执行后续次数循环
  

• 循环的高级用法

  for <遍历变量> in <遍历结构>:
      <语句块1>
  else:		#没有被break退出时，执行else后的语句块
      <语句块2>	#奖励语句块
  -----------------------------------------    
  
  while <条件>:
      <语句块1>
  else:		#没有被break退出时，执行else后的语句块
      <语句块2>	#奖励语句块  可以判断是否执行break
  

---

函数和代码复用

函数的定义与使用

• 作用：降低编程难度和代码复用

• 定义：

  一般用def定义函数，而不用lambda，一般是固定搭配

  def <函数名>(<参数(0或多个)>):	#参数可以没有
      <函数体>
      return <返回值>
  #参数是一种占位符，形参
  #不经过调用，就不会执行
  #参数是函数的输入，函数体是处理，return是输出
  #函数是IPO的实现
  def fact():
      print('hello world')
  

• 调用：

  def fact(n):	#函数的定义
      s = 1
      for i in range(1,n+1):
          s *= i
      return s
  a = fact(10)	#调用函数，给予实参替换形参
  print(a)
  

• 可选参数传递：

  #定义函数时可以为某些参数指定默认值，构成可选参数
  #可选参数必须在非可选参数后
  def <函数名>(<必选参数>,<可选参数>):
      <函数体>
      return <返回值>
  
  #n!//m	n的阶乘整除m
  def fact(n,m=1):
      s = 1
      for i in range(1,n+1):
          s *= i
      return s//m
  fact(10)
  >>>3628800
  fact(10,5)
  >>>725760
  

• 可变参数传递：

  #定义时可以设计可变数量的函数，既不确定参数总数量
  def <函数名>(<参数>,*b):	#*b可以没有，也可以多个
      <函数体>
      return <返回值>
  
  #计算n的阶乘，结果乘b
  def fact(n,*b):
      s = 1
      for i in range(i,n+1):
          s *=i
      for item in b:	#b是个组合数据类型，一个或多个数
          s *= item
      return s
  fact(10,3)
  >>>10886400
  fact(10,3,5,7)
  >>>381024000
  

• 参数的传递的两种方式

  1. 按照形参的前后位置

     fact(10,5)

  2. 形参的名称传递
     fact(m=5,n=10)

返回值

• return保留字来传递返回值

  可以有return，也可以没有return，也可以有多个返回值（元组）

  return后可以有返回值，也可以没有返回值

局部变量和全局变量

• 局部变量

  局部变量是函数内部的占位符，可能与全局变量名字相同，但不一样

  函数结束后，局部变量被释放

  局部变量为组合数据类型且未被创建，等同于全局变量

  如果在函数内部真实创建，则为局部变量

• 全局变量

  函数外面的是全局变量

  可以用global保留字在函数内部使用全局变量，会被函数修改

n,s = 10,100	#n,s是全局变量
def fact(n):
    s = 1		#s是局部变量
    for i in range(1,n+1):
        s *= i
    return s	#s=3628800
print(fact(n),s)	#(3628800,100)
>>>3628800 100
----------------------------------------------------
n,s = 10,100	#n,s是全局变量
def fact(n):
    global s		#s是全句变量
    for i in range(1,n+1):
        s *= i
    return s	#s=3628800
print(fact(n),s)	#(362880000,362880000) s被函数修改
>>>362880000 362880000
---------------------------------------------------
ls = ['F','f']	#通过[]真实创建了个全局变量列表ls
def func(a):
    ls.append(a)	#ls是列表类型，未真实创建，则等同于全局变量
    return
func('C')	#在ls里增加一个'C'
print(ls)
>>>['F','f','C']
--------------------------------------------------
ls = ['F','f']	#通过[]真实创建了个全局变量列表ls
def func(a):
    ls = []			#在函数里创建一个列表ls
    ls.append(a)	#ls为局部变量
    return
func('C')	#在ls里增加一个'C'
print(ls)
>>>['F','f']

lambda函数

lambda函数是一种匿名函数，即没有名字的函数

lambda保留字定义，函数名是返回结果

用于定义简单，能在一行内表示的函数

主要是用作一些特定函数或方法的参数（特殊情况采用）

<函数名> = lambda <参数>:<表达式>	#只能用表达式，不能用函数体
#	等同于↓↓↓↓↓↓↓↓↓
def <函数名>(<参数>):
    <函数体>
    return <返回值>

f = lambda x,y :x + y	#函数名是f
f(10,15)
>>>25
-------------------------
f = lambda : 'lambda是个函数'
print(f())
>>>lambda是个函数

代码复用

函数和对象是代码复用的两种主要形式

• 函数：将代码命名，在代码层面建立了初步抽象

  对象：属性和方法，在函数之上进一步抽象.和.()

• 紧耦合：两个部分之间交流很多，无法独立存在

  模块内部紧耦合

  松耦合：两个部分之间交流较少，可以独立存在

  模块之间松耦合

函数递归

函数中调用函数自身的方式

• 链条：计算过程存在递归链条 n!和n(n-1)!构成链条

• 基例：存在一个或多个不需要再次递归的基例 当n=0，为1，是基例

• 递归的调用方法：函数+分支语句

  函数+分支语句
  def fact(n):	#根据数学函数写
      if:
      	基例
      else：
      	链条		#反复调用
  -------------------------------------------
  def fact(n):        #n的阶乘n!
      if n == 0:
          return 1
      else:
          return n*fact(n-1)#调用自身代码不同的复制版本
  -------------------------------------------
  #汉诺塔
  def hanoi(n,src,dst,mid):   #圆盘数，原柱子，目的柱子，中间柱子，
      global count    #使用全局变量
      if n == 1:
          print('{}:{}->{}'.format(1,src,dst))
          count += 1
      else:
          hanoi(n-1,src,mid,dst)#n为对第n个圆盘操作
          print("{}:{}->{}".format(n,src,dst))    #n表示第n个圆盘
          count += 1
          hanoi(n-1,mid,dst,src)  #借助中间柱子，将原柱子的最后一个搬到目的柱子
          
  count = 0	#必须给全局变量赋初值
  hanoi(10,'A','C','B')	#一共10个圆盘
  print(count)
  

---

Pyinstaller库

第三方库

Python利用pyinstaller打包为可执行文件（各个系统文件）

#在命令行中执行
#路径>pyinstaller -F -w 文件名.py
G:\Python\workspace>pyinstaller -F -w pig.py
路径>pyinstaller -i curve.ico -F pig.py

• -F ，--onefile 是用于将所有的支持文件全部都打包在一起，不显示其他的依赖文件，独立文件（如果没有这个属性，你会发现所有生成的、所需支持的依赖文件会全部在文件夹下）

• -w 在程序运行的过程中隐藏后台控制的黑窗口

• -h 查看帮助

• --clean 清理打包过程中的临时文件

• -D , --onedir 默认值，生成dist文件夹，和-F相反

• -i <图标文件名.ico> 指定打包程序使用的图标.icon文件

• input('Press Enter to exit...')  #防止出来结果直接关闭窗口
  

---

组合数据类型

集合类型

1. 多个元素的无序组合、和数学集合一致、无序唯一、不可修改

2. 用{}表示，元素间用逗号分隔

   建立集合类型用{}或set()   #空集合必须用set()
   A={1,2,('lalala',b)}    #用{}之间建立
   >>>{1,2,('lalala',b)} 
   B=set('ppp123')    #用set()建立，相同被去掉
   >>>{'p','3','1','0'}	#元素无序
   

3. 集合运算：六个操作符（并|，差-，交&，补^，=<>关系操作符）

4. 更新集合：四个增强操作符（修改前面集合S）

   

5. 十个方法

   S.add(x)  #添加
   S.discard(x)  #移除（丢弃），无不异常
   S.remove(x)  #移除，无则异常
   S.clear()  #清空全部
   S.pop()  #随机返回S的一个元素，更新S，空则异常
   S.copy()  #返回S副本
   len(S)  #返回元素个数
   x in S  #判断在T/F
   x not in S  #判断不在T/F
   set(x)  #其他转变为集合类型
   set() #生成空集合
   

6. #方法一：利用异常判断 遍历
   >>> try:
   	while True:
   		print(B.pop(),end='')
   except:
   	pass
   
   312
   #B.pop()取完之后B为空
   >>> B  #B=print(B)
   set()  #B为空
   
   #方法二：利用for in遍历
   >>> for i in B:
   	print(i,end='')
   
   123
   

7. 关系比较

8. 数据去重

   #由有重复元素的列表变为无重复元素的列表
   >>> ls=[1,1,2,2,'py']  
   >>> S=set(ls)
   >>> S
   {'py', 1, 2}	#列表->集合
   >>>lt=list(S)
   >>>lt
   ['py',1,2]		#集合->列表
   

序列类型：

1. 有先后关系，可以相同，是一维元素向量

2. 类似数学的序列，有下标，可通过下标访问

3. 序号：正向递增序号0->4…

   ​ 反向递减序号…-5<-1

4. 六个操作符

   x in s		#判断有T/F
   x not in s	#判断无T/F
   s+t			#连接
   s*n或n*s		#复制n次
   s[i]		#索引，返回第i个元素
   s[i:j]或s[i:j:k]		
   #切片，返回第i到j以k为步长的元素子序列
   #[0:5]取[0:5)
   #步长，从i开始每隔k-1取一下
   

5. #ls[::-1]  取反
   >>> a="鸭梨亚是王"
   >>> a[::-1]
   '王是亚梨鸭'
   

6. 五个函数和方法

   len(s)	#列表长度  总个数
   min(s)	#最小元素
   max(s)	#最大元素   字母则按字母序比较
   s.index(x)		#返回第一个x的位置
   s.index(x,i,j)	#返回从i到j,第一个x的位置
   s.count(x)	#返回出现x的总次数
   

• 字符串类型

• 元组类型

  • 元组是序列类型的一种扩展

    1. 创建不能被修改，因此没有特殊操作

    2. 使用()或tuple()创建，元素间用,分隔

    3. 可以不使用()

       def func():
       	return 1,2  #返回的1,2是个元组类型
       

    4. 继承序列的全部通用操作

  • >>>animal="cat","dog","tiger","human"
    >>> animal
    ('cat', 'dog', 'tiger', 'human')
    #可以套娃
    >>>color=(0x001100,"blue",animal)
    >>>color[-1][2]
    'tiger'#[]索引的二重操作
    

• 列表类型

  • 列表是序列类型的一种扩展

    1. 可以被随意修改

    2. 用[]或list()创建，元素用,分隔

       >>>ls=[""cat","dog","tiger","human""]
       >>>ls
       ["cat","dog","tiger","human"]
       >>>lt=ls  #赋值并不生成新列表
       

    3. 元素类型可以不同，无长度限制

  • 操作函数和方法

    ls[i] = x#替换列表ls第i元素为x
    ls[i:j:k] = lt#用lt替换ls切片后的子列表
    del ls[i]#删除ls中的i元素
    del ls[i:j:k]#删除ls中i到j以k为步长的元素
    ls += lt#更新ls=ls+lt
    ls *=n#更新ls=ls重复n次
    

    实例

    >>> ls=['a', 'b', 'c', 'd']
    >>> ls[1:2]   #切片[1,2)
    ['b']
    >>>ls[1:2]=[1,2,3,4]
    ['a', 1, 2, 3, 4, 'c', 'd']  #替换
    >>> del ls[::3]  			#从0每隔3步长（k-1）删除
    [1, 2, 4, 'c']
    >>> ls*=2
    [1, 2, 4, 'c', 1, 2, 4, 'c']
    

  • 其他方法

    ls.append(x)#ls最后加元素x
    ls.clear()#删除全部元素
    ls.copy()#生成一个新列表,并赋值
    ls.insert(i,x)#在第i位置加x
    ls.pop(i)#删除第i位置元素
    ls.remove(x)#删除第一个出现的x
    ls.reverse()#反转全部元素
    sorted(ls)#可对列表进行排序 升序
    

• 序列的应用场景

  • 元组用于元素不改变的场景，固定搭配场景
  • 列表更加灵活，最常用
  • 最主要作用：表达一组有序数据
  • 数据保护用元组 #用tuple()转换

  

• 基本统计值

  

字典类型

1. 映射：键keys(索引)->值values(数据)

2. 字典是键值对的集合，键值对之间无序

3. 采用{}和dict()创建，键值对用:表示，元素之间用,分隔

4. 用[key]索引或增加元素（每个键值对）

5. 生成空字典 de = {}

   >>>d={"山西":"太原","山东":"济南"}
   >>>d
   {"山西":"太原","山东":"济南"}
   >>>d["山西"]     	#索引
   '太原'
   >>>d["山西"]="朔州"   #改变元素
   >>>d["2"]="b";d["1"]="a"	#用;隔开，增加元素
   >>>d
   {"山西":"朔州","山东":"济南","2":"b","1":"a"}
   

6. 方法

   del d[k]	#删除字典d中k对应的值
   k in d		#判断k是否在d中，在Trun,不在False
   d.keys()	#返回d的所有键
   d.values()	#返回d的所有值
   d.items()	#返回d的所有键值对  
   >>>dict_items([('a', '1'), ('b', '2')])
   #返回的不是列表类型，需要拿for in来遍历
   d.get(k,<default>)#键k存在，则返回对应值，不在则返回默认值
   d.pop(k,<default>)#键k存在，则取出对应值，不在则返回默认值
   d.popitem()#随机取出一个键值对，以元组形式返回
   d.clear()	#清除所有键值对
   len(d)		#返回元素（键值对）个数
   

   >>> d.get("山西","莫得")#返回对应值
   '太原'
   >>> d.get("河南","莫得")#返回默认值
   '莫得'
   >>> d.popitem()		#随机取出一个键值对
   ('山东', '济南')
   >>> d		#删去取出来的键值对
   {'河北': '石家庄', '山西': '太原'}
   

---

文件和数据格式化

文件的使用

文件是数据存储的一种形式（本质上是二进制形式存储）

以文本文件和二进制文件展示

• 文件的两种展示类型

  • 文本文件

    由单一特定编码组成，如 UTF-8

    存在编码，也被看成存储着的长字符串，如 .txt文件、.py文件

  • 二进制文件

    直接由比特0/1组成，没有统一字符编码，如 .png文件、.avi文件

    bf = open('china.txt','rt',encoding='UTF-8')
    print(bf.readline())
    bf.close()
    >>>中国是个伟大的国家！
    
    br = open('china.txt','rb')
    print(br.readline())
    br.close()
    >>>b'\xe4\xb8\xad\xe5\x9b\xbd\xe6\x98\xaf\xe4\xb8\xaa\xe4\xbc\x9f\xe5\xa4\xa7\xe7\x9a\x84\xe5\x9b\xbd\xe5\xae\xb6!'
    

• 文件的打开和关闭

  文件处理的步骤：打开->操作->关闭

  存储状态 a = open( , ) <-> a.close() 占用状态

  变量名（文件句柄）

  打开文件:
  <变量名> = open(<文件名(路径和名称)>,<打开模式>)
  绝对路径：斜杠"D:/PYE/f.txt"或反斜杠"D:\\PYE\\f.txt"
  相对路径："./PYE/f.txt"或"f.txt"

  打开模式：
  "r"只读模式，默认值，不存在返回FileNotFoundError

  "w"覆盖写模式，不存在则创建，存在则完全覆盖

  "x"创建写模式，不存在则创建，存在返回FileExistsError

  "a"追加写模式，不存在则创建，存在则在文件后追加内容

  "b"二进制打开模式

  "t"文本打开模式，默认值

  "+"与r/w/x/a一同使用，在原功能基础上增加同时读写功能

  *“w+”*为读和覆盖写 文本打开模式

  文件关闭：

  <变量名>.close()

  不关闭则一直打开，直到程序退出

• 文件的读取

  .read(size=-1)读入全部内容，如果给出参数，读入前size长度

  .readline(size=-1)读入一行内容，如果给出参数，读入该行前size长度

  .readlines(hint=-1)读入文件所有行，以每行为元素形成列表，如果给出参数，读入前hint行

  >>>s = f.read(2)
  中国
  >>>s = f.readline()
  中国是个伟大的国家！
  >>>s = f.readlines()
  ["中国是一个伟大的国家！"]
  

  遍历全文本

  #方法一
  fo = open(fname,"r")
  txt = fo.read()			#一次读入，统一处理
  fo.close()
  #方法二
  fo = open(fname,"r")
  txt = fo.read()
  while txt != "":		#处理大文件
      txt = fo.read(2)	#按数量读入，逐步处理
  fo.close()
  

  逐行遍历文本

  #方法一
  fo = open(fname,"r")
  for line in fo.readlines():#列表里每个元素是一行
      print(line)				#一次读入，分行处理
  fo.close()
  #方法二
  fo = open(fname,"r")	#处理大文件
  for line in fo:			#分行读入，逐行处理
      print(line)
  fo.close()
  

• 数据的文件写入

  .write(s)向文件写入一个字符串或字节流

  .writelines(lines)向一个元素全为字符串的列表写入文件

  .seek(offset)改变当前文件操作指针(光标)的位置，offset含义如下：

  0-文件开头(默认)；1-当前位置；2-文件结尾；123456-到第123456为

  >>>f.write("中国是个伟大的国家！")
  
  >>>ls = ["中国","法国","美国"]
  >>>f.writelines(ls)		#列表中元素拼接写入，无换行空格
  中国法国美国
  
  >>>f.seek(0)		#回到文件开头
  -------------------------------------------------
  fo = open("output.txt","w+")	#w+覆盖写+读取+文本
  ls = ["中国","法国","美国"]
  fo.writelines(ls)	#写入
  fo.seek(0)		#不加seek的话，则无输出，因为指针在最后
  for line in fo:	#遍历全文的每一行
      print(line)	#逐行输出
  fo.close()
  >>>中国法国美国
  

自动化脚本

1. 定义数据文件格式（接口），程序和数据之间的一种规范
2. 编写程序，根据文件接口解析参数绘制图形
3. 编制数据文件

自动化思维：数据和功能分离，数据驱动的自动运行

接口化设计：格式化设计接口，清晰明了

二维数据应用：应用维度组织数据，二维数据最常用

一维数据的格式化和处理

一维数据：有序或无序数据构成，采用线性方式组织

对应列表、数组和集合等概念

二维数据：由多个一维数据构成，是一维数据的组合形式

表格是典型的二维数据

多维数据：由一维或二维数据在新维度上扩展形成

时间不同的多个表格

高维数据：利用最基本的二元关系展示数据间的复杂结构

键值对

• 数据的操作周期

  存储（格式）<->表示（类型）<->操作（方式）

• 一维数据的表示：有序（列表），无序（集合）

• 一维数据的存储：空格分隔，逗号分隔，其他方式（推荐用特殊符号）

• 一维数据的处理：file.split()<->str.join()

  #空格分隔	文件->列表
  #中国 美国 日本 德国 法国 英国 意大利
  txt = open(fname).read()
  ls = txt.split()	#分割
  f.close()
  >>>ls
  ['中国','美国','日本','德国','法国','英国','意大利']
  
  #列表->文件
  ls = ['中国','美国','日本']
  txt = open(fname,"w")
  txt.write(" ".join(ls))	#str.join()每元素之间加空格
  f.close()
  

二维数据的格式化和处理

使用列表类型表达二维数据，二维列表，[[a],[b]]

遍历每个元素：两层for循环

外层列表中每个元素对应行/列，一般索引习惯：ls[row][column]先行后列

• CSV数据存储格式：Comma-Separataed Values以逗号分割值，国家通用

  .csv 扩展名 Excel软件可读入输出

  元素缺失，逗号仍要保留

  表头可以作为数据存储，也可以另行存储

• 二维数据的处理：

  #从CSV格式文件->列表
  fo = open(fname)
  ls = []
  for line in fo:
      linr = line.replace("\n","")	#换行->空格
      ls.append(line.split(","))#ls后加用,分隔的line
  fo.close()
  
  #列表->文件
  ls = [[],[],[]]		#二维列表
  f = open(fname,"w")
  for item in ls:	#行内元素加逗号，行的最后加个换行，w覆盖
      f.write(",".join(item)+"\n")
  f.close()
  
  #遍历每个元素   二层循环
  ls = [[],[],[]]		#二维列表
  for row in ls:
      for column in row:
          print(ls[row][column])	#二维索引方式
  

---

wordcloud库

词云展示第三方库

wordcloud.WordCloud()代表一个文本对应的词云对象

w = wordcloud.WordCloud()	#以WordCloud对象为基础

#两个常规方法
w.generate(txt)#向WordCloud对象w中加载文本txt
>>>w.generate("Python and WordCloud")
w.to_file(filename)
>>>w.to_file("outfile.png")#将词云输出为图像文件，.png/.jpg
							#默认400*200

• 绘制词云三步走：
  1. 配置对象参数
  2. 加载词云文本
  3. 输出词云文件

以空格分割，单词出现多则尺寸大，单词短则可能被过滤

import wordcloud					#c是词云对象
c = wordcloud.WordCloud()			#配置对象参数
c.generate("wordcloud by Python")	#加载词云文本
c.to_file("wc.png")					#输出文件

• 配置对象参数

  w = wordcloud.WordCloud(<参数>)

  width 生成图片的宽度，默认400px

  height 生成图片的高度，默认200px

  min_font_size 字体的最小字号，默认4号

  max_font_size 字体的最大字号根据高度自动调节

  font_step 字体字号的步进间隔，默认为1

  font_path 指定字体文件的路径（文件名），默认None，.ttc字体文件格式

  max_words 最大单词数量，默认200

  stop_words 排除词列表，一般通过集合类型{}

  background_color 指定词云图片的背景颜色，默认为黑色

  mask 词云遮罩，默认为长方形，需要引用imread()函数，白色蒙版

  from imageio import imread	#import scipy.misc
  mk = imread("pic.png")
  ......
  w = wordcloud.WordCloud(mask=mk)#配置的时候加mask
  

• 利用jieba库对中文绘制词云

  import jieba
  import wordcloud
  txt = "程序设计语言是计算机能够理解和\
  识别用户操作意图的一种交互体系，它按照\
  特定规则组织计算机指令，使计算机能够自\
  动进行各种运算处理。"
  w = wordcloud.WordCloud(width=1000,\#微软雅黑.ttc
                          font_path="msyh.ttc",\
                          height=700)#必须要加字体
  w.generate(" ".join(jieba.lcut(txt)))
  w.to_file("chinesewordcloud.png")
  

  

  #阿里旺旺的皮囊
  import jieba
  import wordcloud
  from imageio import imread
  mk = imread("阿里旺旺.jpg")	#必须是jpg，白色遮罩
  f = open("皮囊.txt",encoding="UTF-8")
  essay = f.read()
  f.close()
  ls = jieba.lcut(essay)
  txt = " ".join(ls)
  w = wordcloud.WordCloud(
      height=800,
      width=800,
      background_color="white",
      font_path="msyh.ttc",
      mask=mk
  )
  w.generate(txt)
  w.to_file("阿里旺旺的皮囊.png")
  

  

  

---

程序设计方法学

自顶向下（设计）：总问题->若干小问题 分而治之

自底向上（执行）：分单元测试，逐步组装 模块化集成

体育竞技分析 main()

1. 打印程序的介绍性信息式 -printInfo()

2. 获得程序运行参数：proA,proB,n - getInputs()

3. 利用球员A和B的能力值pro，模拟n局比赛 -simNGames()

   模拟一局比赛，循环n次 -simOneGame()

   一局比赛结束的判断标准 -gameOver()

4. 输出球员A和B获胜比赛的场次及概率 -printSummary()

程序设计思维

计算思维：抽象问题的计算过程，利用计算机自动化求解

计算生态：开源思想的深入演化和发展，形成了计算生态

用户体验：实现功能->关注体验，编程只是手段，不是目的

​ 软件程序->软件产品 关键环节就是用户体验

1. 进度展示
   1. 可能产生等待，请增加进度展示
   2. 若有若干步骤，需要提醒用户，请增加进度展示
   3. 可能存在大量循环，请增加进度展示
2. 异常处理
   1. 获得用户输入，对合规性需要检查，需要异常处理
   2. 当读写文件时，对结果进行判断，需要异常处理
   3. 当进行输入输出时，对运算结果进行判断，需要异常处理
3. 其他类方法
   1. 打印输出：特定位置，输出程序运行的过程信息
   2. 日志文件：对程序异常及用户使用进行定期记录
   3. 帮助信息：给用户多种方式提供帮助信息

基本程序设计模式

1. IPO：Input-Process-Output
2. 模块化设计：通过函数或对象封装程序，高内聚，低耦合
3. 配置化设计：将数据（配置）和程序（引擎）分离，将可选参数配置化，不修改程序，关键在接口设计。

应用开发

1. 产品定义
2. 系统架构
3. 设计与实现
4. 用户体验

第三方库的安装

Python社区：https://pypi.org/

PyPI：Python Package Index

Anaconda：集成安装800个第三方库，多个主流工具，适合数据计算领域开发

• 文件安装方法：某些库pip下载后，但无法安装，需要编译再安装

• UCI页面：http://www.lfd.uci.edu/~gonhlke/pythonlibs/

  在wins下直接编译后的版本

  pip install <文件名> 进行安装

---

OS库

标准库

os库提供通用的。基本的操作系统交互功能

• 路径操作：os.path子库，处理文件路径及信息

  #以path为入口，用户操作和处理文件路径
  import os.path
  import os.path as op	#op为别名
  os.path.abspath(path)#返回path在当前系统中的绝对路径
  os.path.onormpath(path)#归一化path的表示形式，统一用\\分隔路径，//变成\\
  >>>op.onormpath("D://PYE//file.txt")
  "D:\\PYE\\file.txt"
  os.path.relpath(path)#返回当前程序与文件之间的相对路径（relative path）
  os.path.dirname(path)#返回path中的目录名称
  os.path.basename(path)#返回path中最后的文件名称
  os.path.join(path,*paths)#组合path与paths，返回一个路径字符串
  >>>op.join("D://"，"PYE/file.txt")
  "D:/PYE/file.txt"
  os.path.exists(path)#判断path对应文件或目录是否存在，返回True或Flase
  os.path.isflie(path)#判断path对应是否为已存在的文件，返回True或False
  os.path.isdir(path)#判断path对应是否为已存在的目录,返回True或False
  >>>op.isdir("D://PYE//file.txt")
  False		#file.txt不是目录，则返回False
  os.path.getatime(path)#返回上一次访问时间access
  os.path.getmtime(path)#返回修改时间modify
  os.path.getctime(paeh)#返回创建时间creat
  >>>time.ctime(op.getctime("D:/file.txt"))
  "Sum Fel 11 21:43:53 2018"
  os.path.getsize(path)#返回path对应文件的大小，字节单位
  >>>op.getsize(D:/PYE/file.txt)
  180768
  

• 进程管理：启动系统中其他程序

  os.system(command)#执行程序或命令command，wins中返回值为cmd的调用返回信息
  >>>os.system("C:\\Windows\\System32\\calc.exe")
  0	#返回一个0，表示正确运行
  >>>os.system("C:\\Windows\\System32\\mspaint.exe \
  			D:\\PYECourse\\grwordcloud.png")
  0	#用画图软件打开grwordclouod.png文件，空格隔开
  

• 环境参数：获得系统软硬件信息等环境参数

  os.chdir(path)#修改当前程序操作的路径
  >>>os.chdir("D:")
  os.getcwd()#返回程序的当前路径
  >>>os.getcwd()
  "E:\\"
  os.getlogin()#返回当前系统登录用户名称
  os.cpu_count()#返回当前系统的CPU数量
  os.urandom(n)#获得n个字节长度的随机字符串，通常用于加解密
  

第三方库自动安装脚本

import os
libs = {"sklearn","wheel","networkx","sympy","django",\
        "flask","werobot","pandas","docopt","docopt"}
try:
    for lib in libs:
        os.system("pip install "+lib)
    print("Successful")
except:
    print("Failed Somehow")

---

random库

使用随机数的Python标准库

• 伪随机数（梅森选择算法）
• 基本随机数函数：seed(),random()
• 扩展随机数函数：

import random as r	#需要再现，可以设置种子
r.seed(a=None)		#初始化给定随机数种子，默认为当前系统时间
r.random()			#产生一个[0.0,1.0)之间的随机小数
----------------------------------------------
r.randint(a,b)		#生成一个[a,b]之间的整数
r.randrange(m,n[,k])#生成一个[m,n)之间以k为步长的随机整数
r.getrandbits(k)	#生成一个k比特长的随机整数  [0,2^k]
r.uniform(a,b)		#生成一个[a,b]之间的随机小数
r.choice(seq)		#从序列seq中随机选择一个元素
r.shuffle(seq)		#对序列seq中元素随机排列，返回打乱后的序列

---

jieba库分词

1. 精确模式：无冗余，常用 jieba.lcut(String,)
2. 全模式：冗余 jieba.lcut(String,cut_all=True)
3. 搜索引擎模式：冗余，长词切短词 jieba.lcut_for_search(String,)
4. 向分词词典增加新词w：jieba.add_word("李泽亚")

---

time库

时间获取 time(),ctime(),gmtime()

import time	as t	#1970/1/1/0:0:0开始 以秒s为单位的数值
t.time()			#获取当前时间戳，计算机内部时间值，浮点数
>>>1583941082.6089659
t.ctime()			#获取当前时间并以易读方式表示，返回字符串
>>>'Wed Mar 11 23:38:24 2020'
t.gmtime()			#获取当前时间，计算机可处理的格式
			#世界标准时间（即格林尼治时间），中国晚8小时	
t.localtime()		#获取本地时间
>>>time.struct_time(tm_year=2020, tm_mon=3, tm_mday=11, tm_hour=15, tm_min=40, tm_sec=58, tm_wday=2, tm_yday=71, tm_isdst=0)

时间格式化 strftime(),strptime()

import time as t					#gmyime格式↓
t.strftime(tpl,ts)	#tpl格式化模板字符串，ts是内部时间类型变量
					#返回字符串
    
t.strptime(str,tpl)	#str是字符串形式的时间值，tpl是模板字符串
					#返回时间类型
#   %Y年份1900,		%m月份01,			%B月份名称April,
#	%b月份名称缩写Apr, %d日期02,	 	 %A星期Monday,
#	%a星期缩写Mon,	  %H二十四小时制22,	%h十二小时制06,
#	%p上/下午PM,	   %M分钟38,			%S秒26

>>>a=t.gmtime()
>>>t.strftime("%Y-%m-%d %H:%M:%S",a)		#格式化
'2020-03-11 15:47:12'
>>>timeStr = '2020-03-11 15:47:12'
>>>t.strptime(timeStr,"%Y-%m-%d %H:%M:%S")	#解析
time.struct_time(tm_year=2020, tm_mon=3, tm_mday=11, tm_hour=15, tm_min=47, tm_sec=12, tm_wday=2, tm_yday=71, tm_isdst=-1)

程序计时 sleep(),perf_counter()

from time import perf_counter,sleep	#单位为秒，精确到纳秒
perf_counter()	#测量时间
sleep(s)		#拟休眠的时间，单位是秒，可以是浮点数

#对程序运行进行计时
>>>start = perf_counter()		#记录开始时间
>>>time = per_counter() - start#开始时间-结束时间=所用时间

#程序等待3.3秒再退出
>>>def wait():
    time.sleep(3.3)
>>>wait()

---

计算生态概述

数据分析

• numpy：表达N维数组的最基础库
• Pandas：数据分析高层次应用库
• SciPy：数学、科学和工程计算功能库（类似Matlab）

数据可视化

• Matplotlib：高质量的二维数据可视化功能库
• Seaborn：统计类数据可视化功能库
• Mayavi：三维科学数据可视化功能库

文本处理

• PyPDF2：处理PDF文件的工具集
• NLTK：自然语言文本处理第三方库
• Python-docx：创建或更新Microsoft Word文件的第三方库

机器学习

• Scikit-learn：机器学习方法工具集
• TensorFlow：AlphaGo背后的机器学习技术框架
• MXNet：基于神经网络的深度学习计算框架

Web解析

• Requests：最友好的网络爬虫功能库
• Scrapy：优秀的网络爬虫框架，数据分析高层次应用库
• pyspider：强大的Web页面爬取系统

Web信息提取

• Beautiful Soup：HTML和XML的解析库
• Re：regular expression正则表达式解析和处理功能库，标准库之一
• Python-Goose：提取文章类型Web页面的功能库

Web网站开发

• Django：最流行的Web应用框架，略辅助
• Pyramid：规模适中的Web应用框架
• Flask：Web应用开发微框架

网络应用开发

• WeRoBot：微信公众号开发框架，微信消息反馈，微信机器人
• aip：百度AI开放平台接口
• MyQR：二维码生成第三方库

图形用户界面GUI

• PyQt5：Qt开发框架的Python接口，推荐，跨平台
• wxPython：跨平台GUI开发框架
• PyGObject：使用GTK+开发GUI的功能库

游戏开发

• PyGame：简单的游戏开发功能库，最主要
• Panda3D：开源、跨平台的3D渲染和游戏开发库，3D游戏引擎
• cocos2d：构建2D游戏和图形界面交互式应用的框架

虚拟现实

• VR Zero：在树莓派上开发VR应用的Python库，初学者
• pyovr：Oculus Rift的Python开发接口
• Vizard：基于Python的通用VR开发引擎

图形艺术

• Quads：迭代的艺术，四分迭代，像素风
• ascii_art：ASCII艺术库
• turtle：海龟绘图体系

---

字符串转换，去""

#功能形式1表现
#列表字符串
s = '[[1,2],[3,4]]'
b = eval(s)				#eval()去''
print(b)				#[[1, 2], [3, 4]]
print(type(eval(s)))	#
print(type(s))			#

#功能形式2表现
a = 10
b = 20
c = eval( "a+b")
print(c)   #运行了‘a+b’  输出：30

功能形式：

1. b = eval(s),去掉字符串 str 类型外套，恢复里面内容类型赋给 b，但不改变s的类型
2. 将字符串 str 当成有效的表达式来求值并返回计算结果

---

split() 方法

#str.split(str="", num=string.count(str)).
i="1,2,3"
a=i.split(",",1)
print(a)
#输出['1', '2,3']

• str – 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。
• num – 分割次数。默认为 -1, 即分隔所有。

---

Flask框架-python里的Web框架

• Django,Flask

---

openCV

认识图像

1. 图片格式

   • .bmp无损、老格式、体积大

   • .jpg(jpeg)用最少的磁盘空间得到较好的图片质量

   • .png无损压缩的位图片行格式（首选）

2. 图片类型

   • 黑白
   • 彩色

3. 图片本质

   • 由像素点组成，就是一个矩阵
   • 每个元素（像素点）都是在[0,255]

黑白图像

1. 位图模式（黑白图像）

   仅仅只有1位深度的图像 用0,1表示 一个像素点一位，非0即1

   0->纯黑色

   1->纯白色

2. 灰度图像[0,255]

   有八位深度的图像 一个像素点八位

   (0,0,0,0,0,0,0,0)->2^0=1->(纯黑色)

   (1,1,1,1,1,1,1,1)->2^8=256(纯白色)

   Python从0开始计数

   [1,256]->[0,255]

彩色图像

1. 三个通道RGB

   • R->red
   • G->green
   • B->blue

2. 每个通道8个深度

   256^3个颜色

读取图像

• 所有路径必须是英文路径，中文报错
• 储存类型：uint8->无符号8位整型(0,1,0,1,0,1,0,1)

CV2.imshow()

cv2.imshow('image2',img)   #（'打开窗口的名字'，引用文件）
#图片未响应时的解决方案
cv2.waitKey()
cv2.destroyAllWindows()

用numpy进行拼接

import numpy as np
new_w = img_white[:100,:100]
new_b = img_black[:100,:100]
#垂直拼接   Vertival  
new_v = np.vstack((new_w,new_b))#白上黑下
cv2.imshow('垂直拼接',new_v)
#水平拼接    Horizontal
new_h = np.hstack((new_w,new_b))#白左黑右
cv2.imshow('水平拼接',new_h)

cv2读取和保存图像

• 读取

cv2.imread(path,0)   # path路径 0代表灰度图 1代表彩色图

• 保存

cv2.imwrite(path,target)  #path包含[文件名.png/.jpg]   

输出图片的形状

print img.shape
>>>(774, 1200, 3)    #H-W*3  三通道

---

python 执行终端/控制台命令

import os
os.system()
os.popen().read().strip()

#上面2种方法 是python 执行终端/控制台 命令的常见方法
#os.system('ping www.baidu.com') 执行成功 返回 0 
#ping = os.popen('pint www.baidu.com').read().strip()  返回输出结果
#注：os.system() 执行完成 会关闭 所以当执行后续 命令需要依赖前面的命令时，请将多条命令写到一个 os.system() 内


#但 这个方法执行的时候 是无法交互的 比如说  命令权限不够 需要输入登陆密码 可使用下面这种方法
import pexpect
ch = pepect.spwn('命令')
ch.expect('Password:')
ch.sendline('密码')

---

selenium库

Selenium是一个用于Web应用程序测试的工具，直接运行在浏览器中,就像真正的用户在操作一样

不同浏览器需要下载不同的驱动文件driver.exe

from selenium import webdriver
#打开驱动
driver = webdriver.Chrome(r'G:\Python\stuff\chromedriver.exe')
#打开淘宝网
driver.get('https://www.taobao.com')
#根据xpath找到标签，点击
driver.find_element_by_xpath('/html/body').click()
#根据文字找到标签，点击
driver.find_element_by_link_text('结 算').click()

---

easygui库

import easygui as g
--------------------'按钮选择框'-----------------------
#消息框，一个按钮
g.msgbox("我一定要学会编程!", ok_button="加油!")
#单选框，两个按钮，返回布尔型
if g.ccbox('要再来一次吗？', choices=('要啊要啊^_^', '算了吧T_T')):
    g.msgbox('不给玩了，再玩就玩坏了......')
#单选框，多个按钮
buttonbox(msg='', title=' ', choices=('Button1', 'Button2', 'Button3'), image=None, root=None)
--------------------'列表选项框'-----------------------
#单选列表型，提供一系列选项
g.choicebox('你的性别？',choices = ['男','女'])
#多选列表型,提供一系列选项
g.multchoicebox(msg='选择你爱吃的，可多选', title='选择食物', choices=['梨','橙','杏'])
----------------------'输入框'------------------------
#一个显式文本输入框，返回值为用户输入的字符串。默认返回的值会自动去除首尾的空格，如果需要保留首尾空格的话请设置参数 strip=False。
g.enterbox(msg='Enter something.', title=' ', default='', strip=True, image=None, root=None)
#多个显式文本输入框，返回值列表，feilds条目名，values是默认值
g.multenterbox(msg=' ', title=' ', fields=['用户名','密码','验证码'], values=())
#一个隐式*文本输入框，返回输入文本
g.passwordbox(msg=' ', title=' ', default=' ', image=None, root=None)
#多个显式文本输入框，最后一个隐式文本输入框
g.multpasswordbox()
-------------------'展示文本框'------------------------
g.textbox(msg='', title=' ', text= open('E:\\TheThreeKingdom.txt','r'), codebox=0)#1为等宽
-------------------'目录与文件'------------------------
#选择一个目录，返回目录路径，选择"Cancel"则返回 None
g.diropenbox(msg=None, title=None, default=None)
#选择一个文件，返回文件路径，default 参数指定一个默认路径
g.fileopenbox(msg=None, title=None, default=None,filetypes=None)
#保存一个文件
g.filesavebox(msg=None, title=None, default='', filetypes=None)
#如果设置了 default 参数，fileopenbox() 显示默认的文件路径和格式。
#default="c:/fishc/*.py" 即显示 C:\fishc 文件夹下所有的 Python 文件。
#default="c:/fishc/test*.py" 即显示 C:\fishc 文件夹下所有的名字以 test 开头的 Python 文件。
#filetypes = ["*.txt"]列表的最后一项字符串是文件类型的描述，例如：filetypes = ["*.css", ["*.htm", "*.html", "HTML files"]]
---------------------'异常捕获'------------------------
#出现异常，弹出异常框，里面显示异常的信息
g.exceptionbox()
例子 try:
            print('I Love FishC.com!')
            int('FISHC') # 这里会产生异常
    except:
            exceptionbox()

#msg='输入一个数'   显示消息
#title='记事本'    定义弹出框名字
#image='a.jpg'    框内图片
#root=None    主窗口
'''
使用tkinter.Tk() 生成主窗口（root=tkinter.Tk()）；
root.title('标题名')  修改框体的名字,也可在创建时使用className参数来命名；
root.resizable(0,0)  框体大小可调性，分别表示x,y方向的可变性
root.geometry('250x150')　　指定主框体大小；
root.quit()        　　　　 　　 退出；
root.update_idletasks()
root.update()        　　　　　刷新页面；
root.iconbitmap('小鸡.ico')		窗口图标
'''

---

main主函数

• __name__是Python的内置变量，用于指代当前模块。
• 当我们把模块A中的代码在模块B中进行import A时，只要B模块代码运行到该import语句，模块A的代码会被执行。if __name__==’__main__:可以避免导入模块而直接执行。
• 当运行if __name__=='__main__':语句时，如果当前模块时被直接执行，name__的值就是__main，条件判断的结果为True，if __name__=='__main__':下面的代码块就会被执行。

# 模块A
print('你好，我是模块A……')
print('模块A中__name__的值：{}'.format(__name__))
print('-------------------------')
# 模块B
from package01 import A
print('你好，我是模块B……')
print('模块B中__name__的值：{}'.format(__name__))
------------------------------------------------------
执行A模块时，输出结果：
　　你好，我是模块A……
　　模块A中__name__的值：__main__
　　-------------------------
执行B模块时，输出结果：
　　你好，我是模块A……
　　模块A中__name__的值：package01.A
　　-------------------------
　　你好，我是模块B……
　　模块B中__name__的值：__main__

---

正则表达式

---

爬虫

---