python3

一、python基础

1、python简介

Python是脚本语言
脚本语言(Scripting language)是电脑编程语言，因此也能让开发者藉以编写出让电脑听命行事的程序。以简单的方式快速完成某些复杂的事情通常是创造脚本语言的重要原则，基于这项原则，使得脚本语言通常比 C语言、C++语言 或 Java 之类的系统编程语言要简单容易。
也让脚本语言另有一些属于脚本语言的特性：

• 语法和结构通常比较简单
• 学习和使用通常比较简单
• 通常以容易修改程序的“解释”作为运行方式，而不需要“编译”
• 程序的开发产能优于运行性能

2、python的灵魂 缩进

3、IDLE

IDLE是一个Python Shell，shell的意思就是“外壳”，基本上来说，就是一个通过键入文本与程序交互的途径！像我们Windows那个cmd窗口，像Linux那个黑乎乎的命令窗口，Mac终端，他们都是shell，利用他们，我们就可以给操作系统下达命令。同样的，我们可以利用IDLE这个shell与Python进行互动。

4、python升级

Mac系统自带python2.7，由于python目前最新已是3.7，所以升级到python3.7，可以到官网下载，下载完成，一系列安装之后会在
/Library/Frameworks/Python.framework/Versions/ 中显示，python在此文件夹中可以共存多个版本，不冲突，可以进行设置需要的版本，2.7也在里面，但是默认不显示出来；
终端打开.bash_profile文件
1、open ~/.bash_profile ／ vim .bash_profile
2、修改文件内容（把里面版本号改为最新版）
PATH=”/Library/Frameworks/Python.framework/Versions/3.7/bin:${PATH}”
export PATH

此时打开终端，输入python3进入对应的python编辑。
输入python进入python编辑会显示出2.7的版本，
3、alias
python=”/Library/Frameworks/Python.framework/Versions/3.7/bin/python3.7”
把此段放在.bash_profile文件 中，指定python版本，这里把它指向3.7。

5、python应用

许多大型网站就是用Python开发的，例如YouTube、Instagram，还有国内的豆瓣。很多大公司，包括Google、Yahoo等，甚至NASA（美国航空航天局）都大量地使用Python。
用途：
首选是网络应用，包括网站、后台服务等等；
其次是许多日常需要的小工具，包括系统管理员需要的脚本任务等等；

6、python缺点

1、运行速度慢
Python是解释型语言，你的代码在执行时会一行一行地翻译成CPU能理解的机器码，这个翻译过程非常耗时，所以很慢。
2、代码不能加密
如果要发布你的Python程序，实际上就是发布源代码，凡是编译型的语言，都没有这个问题，而解释型的语言，则必须把源码发布出去。

千万不要高估自己写的代码真的有非常大的“商业价值“。那些大公司的代码不愿意开放的更重要的原因是代码写得太烂了，一旦开源，就没人敢用他们的产品了

二、python赋值机制

1、简单类型

整型、浮点型、字符串、布尔型、空值
python对于变量来说，不需要定义，不像javaScript一样，需要var；而python直接写就行。

x = 500;
y = x;
y = 'gqk';
b = 'gqk';
你好 = 1234;          #和js一样可以定义中文变量。

• x = 500;

Python分配了一个 PyInt 大小的内存 pos1 用来储存对象 500 ，然后，Python在命名空间中让变量 x 指向了这一块内存，注意，整数是不可变类型，所以这块内存的内容是不可变的。

内存	命名空间
pos1 : PyInt(500) (不可变)	x : pos1

• y = x;

Python并没有使用新的内存来储存变量 y 的值，而是在命名空间中，让变量 y 与变量 x 指向了同一块内存空间。

内存	命名空间
pos1 : PyInt(500) (不可变)	x : pos1、y : pos1

• y = ‘gqk’;

Python此时分配一个 PyStr 大小的内存 pos2 来储存对象 foo ，然后改变变量 y 所指的对象。

内存	命名空间
pos1 : PyInt(500) (不可变)	x : pos1
pos2 : PyStr(‘foo’) (不可变)	y : pos2

对这一过程进行验证，可以使用id 函数。
id(x) 返回变量 x 的内存地址
可以使用 is 来判断是不是指向同一个事物：x is y 判断地址是不是一样
Python会为每个出现的对象进行赋值，哪怕它们的值是一样的

2、容器类型

列表、元组、字典、集合

x = [500, 501, 502];
y = x;
y[1] = 600;
y = [700, 800];

• x = [500, 501, 502];

Python为3个PyInt分配内存 pos1 ， pos2 ， pos3 （不可变），然后为列表分配一段内存 pos4 ，它包含3个位置，分别指向这3个内存，最后再让变量 x 指向这个列表。

内存	命名空间
pos1 : PyInt(500) (不可变)	x[0] : pos1
pos2 : PyInt(501) (不可变)	x[1] : pos2
pos3 : PyInt(502) (不可变)	x[2] : pos3
pos4 : PyList(pos1, pos2, pos3) (可变)	x : pos4

• y = x

并没有创建新的对象，只需要将 y 指向 pos4 即可

内存	命名空间
pos1 : PyInt(500) (不可变)	x[0] : pos1、y[0] : pos1
pos2 : PyInt(501) (不可变)	x[1] : pos2、y[1] : pos2
pos3 : PyInt(502) (不可变)	x[2] : pos3、y[2] : pos3
pos4 : PyList(pos1, pos2, pos3) (可变)	x : pos4、y : pos4

• y[1] = 600

原来 y[1] 这个位置指向的是 pos2 ，由于不能修改 pos2 的值，所以首先为 600 分配新内存 pos5 ，再把 y[1] 指向的位置修改为 pos5 。此时，由于 pos2 位置的对象已经没有用了，Python会自动调用垃圾处理机制将它回收。

内存	命名空间
pos1 : PyInt(500) (不可变)	x[0] : pos1、y[0] : pos1
pos2 : PyInt(501) (不可变)	x[1] : pos2、y[1] : pos2
pos3 : PyInt(502) (不可变)	x[2] : pos3、y[2] : pos3
pos4 : PyList(pos1, pos2, pos3) (可变)	x : pos4、y : pos4
pos5 : PyInt(600) (不可变)	x : pos4、y : pos4

• y = [700, 800]

首先创建这个列表，然后将变量 y 指向它

内存	命名空间
pos1 : PyInt(500) (不可变)	x[0] : pos1
pos5 : PyInt(600) (不可变)	x[1] : pos5
pos3 : PyInt(502) (不可变)	x[2] : pos3
pos4 : PyList(pos1, pos5, pos3) (可变)	x : pos4
pos6 : PyInt(700) (不可变)	y[0] : pos6
pos7 : PyInt(800) (不可变)	y[1] : pos7
pos8 : PyList(pos6, pos7) (不可变)	y : pos8

三、python数据类型

1、整型

a = 1;
b = 2;
c = 0xa5b4c3d2; #16进制0x表示
d = 0o121;      #8进制用0o表示

2、浮点型

a = 1.12;
b = 2.121;
c = 12.3e8;     #科学计数法

整数相加，得到整数：
浮点数相加，得到浮点数：
整数和浮点数相加，得到浮点数：
幂指数 ** eg: 2 ** 5; 2的5次方

3、字符串

    a = '你好，我是gqk';

想打印单引号或者双引号 ''、 ""
1：使用\转义字符转义
2："Let's Go"
原始字符串：
在字符串之前加一个r即可变成原始字符串

str = 'C:\now';
#在shell中直接打印str与print(str)是不一样的
#print()会把\n转义变成回车符；
str;    
#'C:\now'
print(str);
#C:
#ow
str = 'C:\\now'#用\转义就可了，或者 
str = r'C:\now'
#加上r会自动在该转义的地方加一个转义字符
#r在字符串最后不能是转义字符，若字符串最后一定要转义字符需要，
str = r'C:\Program Files\FishC\Good' + '\\'

多行输入

”’****”’

a = '''nihoa 
    我是
    ni
    大
    哥
    ''';

字符串格式化 format()

Python用字符串的format()方法来格式化字符串。具体用法是，字符串中花括号 {} 的部分会被format传入的参数替代，传入的值可以是字符串，也可以是数字或者别的对象。

'{} {} {}'.format('a', 'b', 'c')    #'a b c'
#包含{}   "{{0}}".format(''不打印"); {0}
#用数字指定传入参数的相对位置
'{2} {1} {0}'.format('a', 'b', 'c') #'c b a'
'{0:.2f}{1}'.format(30.232, '啥呀')   #30.23啥呀     
#.f定点数
#指定传入参数的位数
'{color} {n} {x}'.format(n=10, x=1.5, color='blue') 
#'blue 10 1.5'
#混用
'{color} {0} {x} {1}'.format(10, 'foo', x = 1.5, color='blue')  #'blue 10 1.5 foo'

字符串格式化符号含义

符号	说明
%c	格式化字符及其 ASCII 码 ‘%c %c’ % (97, 98) -> ‘a b’
%s	格式化字符串 ‘%s love’ % ‘I’ -> ‘I love’ %后面替换掉%s
%d	格式化整数 ‘%d + %d = %d’ % (4, 5 , 4 + 5) -> ‘4 + 5 = 9’
%o	格式化无符号八进制数 ‘%o’ % 10 -> ‘12’
%x	格式化无符号十六进制数 ‘%x’ % 10 -> ‘a’
%X	格式化无符号十六进制数（大写）’%X’ % 10 -> ‘A’
%f	格式化浮点数字，可指定小数点后的精度 ‘%f’ % 27.121 -> ‘27.121000’
%e	用科学计数法格式化浮点数 ‘%e’ % 12121212 -> ‘1.212121e+07’
%E	作用同 %e，用科学计数法格式化浮点数 ‘%E’ % 12121212 -> E

字符串操作

1）分片
var[lower:upper:step]
其范围包括 lower ，但不包括 upper ，即 [lower, upper)， step 表示取值间隔大小，如果没有默认为1。

s = 'hello world';
s[0:5]          #hello
s[0:-1]         #hello worl

2）索引

s = 'hello world';
s[0]            #h
s[-1]           #d

3）分割.split() 返回所有分割得到的字符串 之前的并不变

s.split()       #['hello', 'world']

4）连接.join() 返回连接后得到的新字符串 之前的并不变

s = 'c.ghjkl'; a = ' ' ;a.join(s)   #'c . g h j k l'
a = ['1', '2'];  l = 'l'; l.join(a) #'1l2'

5）替换.replace() 返回新的字符串 之前的并不变

ss = 'hello world';
a = ss.replace('world', 'nidaye');  #'hello nidaye'

6）len() 查看长度

len(ss);

7）字符串与数字相乘

a = 'str';  a * 3                   #'strstrstr';

字符串方法

符号	说明
capitalize()	把字符串的第一个字符改为大写
casefold()	把整个字符串的所有字符改为小写
center(width)	将字符串居中，并使用空格填充至长度 width 的新字符串
count(sub[, start[, end]])	返回 sub 在字符串里边出现的次数，start 和 end 参数表示范围，可选。
encode(encoding=’utf-8’, errors=’strict’)	以 encoding 指定的编码格式对字符串进行编码。
endswith(sub[, start[, end]])	检查字符串是否以 sub 子字符串结束，如果是返回 True，否则返回 False。start 和 end 参数表示范围，可选。
expandtabs([tabsize=8])	把字符串中的 tab 符号（\t）转换为空格，如不指定参数，默认的空格数是 tabsize=8。
find(sub[, start[, end]])	检测 sub 是否包含在字符串中，如果有则返回索引值，否则返回 -1，start 和 end 参数表示范围，可选。
index(sub[, start[, end]])	跟 find 方法一样，不过如果 sub 不在 string 中会产生一个异常。
isalnum()	如果字符串至少有一个字符并且所有字符都是字母或数字则返回 True，否则返回 False。
isalpha()	如果字符串至少有一个字符并且所有字符都是字母则返回 True，否则返回 False。
isdecimal()	如果字符串只包含十进制数字则返回 True，否则返回 False。
isdigit()	如果字符串只包含数字则返回 True，否则返回 False。
islower()	如果字符串中至少包含一个区分大小写的字符，并且这些字符都是小写，则返回 True，否则返回 False。
isnumeric()	如果字符串中只包含数字字符，则返回 True，否则返回 False。
isspace()	如果字符串中只包含空格，则返回 True，否则返回 False。
istitle()	如果字符串是标题化（所有的单词都是以大写开始，其余字母均小写），则返回 True，否则返回 False。
isupper()	如果字符串中至少包含一个区分大小写的字符，并且这些字符都是大写，则返回 True，否则返回 False。
join(sub)	以字符串作为分隔符，插入到 sub 中所有的字符之间。
ljust(width)	返回一个左对齐的字符串，并使用空格填充至长度为 width 的新字符串。
lower()	转换字符串中所有大写字符为小写。
lstrip()	去掉字符串左边的所有空格
partition(sub)	找到子字符串 sub，把字符串分成一个 3 元组 (pre_sub, sub, fol_sub)，如果字符串中不包含 sub 则返回 (‘原字符串’, ”, ”)
replace(old, new[, count])	把字符串中的 old 子字符串替换成 new 子字符串，如果 count 指定，则替换不超过 count 次。
rfind(sub[, start[, end]])	类似于 find() 方法，不过是从右边开始查找。
rindex(sub[, start[, end]])	类似于 index() 方法，不过是从右边开始。
rjust(width)	返回一个右对齐的字符串，并使用空格填充至长度为 width 的新字符串。
rpartition(sub)	类似于 partition() 方法，不过是从右边开始查找。
rstrip()	删除字符串末尾的空格。
split(sep=None, maxsplit=-1)	不带参数默认是以空格为分隔符切片字符串，如果 maxsplit 参数有设置，则仅分隔 maxsplit 个子字符串，返回切片后的子字符串拼接的列表。
splitlines(([keepends]))	在输出结果里是否去掉换行符，默认为 False，不包含换行符；如果为 True，则保留换行符。
startswith(prefix[, start[, end]])	检查字符串是否以 prefix 开头，是则返回 True，否则返回 False。start 和 end 参数可以指定范围检查，可选。
strip([chars])	删除字符串前边和后边所有的空格，chars 参数可以定制删除的字符，可选。
swapcase()	翻转字符串中的大小写。
title()	返回标题化（所有的单词都是以大写开始，其余字母均小写）的字符串。
translate(table)	根据 table 的规则（可以由 str.maketrans(‘a’, ‘b’) 定制）转换字符串中的字符。把a用b替换掉
upper()	转换字符串中的所有小写字符为大写。
zfill(width)	返回长度为 width 的字符串，原字符串右对齐，前边用 0 填充。

4、布尔型

True
False

>>> a = True;
>>> type(a)
<class 'bool'>

5、列表 List

python用[]或list()来生成列表

a = [1,2,4, '21s', 'str', 'number'];
#列表加法
a + a = [1,2,4, '21s', 'str', 'number',1,2,4, '21s', 'str', 'number'];
#列表索引
a[0]            #1
#列表长度
len(a)          #6
#添加元素
a.append('nihao')   #会添加在最末尾 [1,2,4, '21s', 'str', 'number', 'nihao']
#分片/切片(slice)：
#列表可以通过索引和分片来修改。
lista = listb[:]            #列表拷贝：
a = [10, 11, 12, 13, 14]
a[1:3] = [1, 2, 3, 4]       #a为[10, 1, 2, 3, 4, 13, 14]；
a = [10, 1, 2, 11, 12]
a[1:3] = []                 #a为[10, 11, 12]
#Python提供了删除列表中元素的方法 'del'。
del a[0];   del a[1:];  del a[::2];
#in 来看某个元素是否在某个序列（不仅仅是列表）中，用not in来判断是否不在某个序列中
print(10 in a)      print(10 not in a)
#也可以作用于字符串
s = 'hello world'   
print('he' in s)        print('world' not in s)

列表方法

不改变列表的方法

1）count()列表中某个元素个数
a = [11, 12, 13, 12, 11] a.count(11) 2
2）index()列表中某个元素位置
index(12, 2,5) a.index(12) 1
不存在的元素会报错：

改变列表的方法

1）append(ob)向列表添加单个元素，将元素 添加到列表 的最后 a.append(11)
append每次只添加一个元素，并不会因为这个元素是序列而将其展开
2）extend(lst) 向列表添加序列，将序列 lst 的元素依次添加到列表 l 的最后，作用相当于 l += lst
a = [10, 11, 12, 11] a.extend([1, 2]) a = [10, 11, 12, 11, 1, 2]
3）insert(idx, ob) 插入元素，在索引idx 处插入 ob ，之后的元素依次后移
a = [10, 11, 12, 13, 11]
在索引 3 插入 ‘a’ a.insert(3, ‘a’) [10, 11, 12, ‘a’, 13, 11]
4）remove(ob) 移除元素，会将列表中第一个出现的 ob 删除，如果 ob 不在 l 中会报错
a = [10, 11, 12, 13, 11]
移除了第一个 11 a.remove(11) [10, 12, 13, 11]
5）删除 del语句
del lista[1]
6）pop(idx) 弹出元素，会将索引 idx 处的元素删除，并返回这个元素。没有idx会删除最后一个
7）sort() 排序，会将列表中的元素按照一定的规则排序
a.sort();默认从小到大
a.sort(reverse = True)反转从大到小
如果不想改变原来列表中的值，可以使用 sorted 函数：b = sorted(a);
8）reverse() 列表反向，会将列表中的元素从后向前排列。 a.reverse();
如果不想改变原来列表中的值，可以使用这样的方法： b = a[::-1]
查询列表的所有bif dir(list)
‘append’, ‘clear’, ‘copy’, ‘count’, ‘extend’, ‘index’, ‘insert’, ‘pop’, ‘remove’, ‘reverse’, ‘sort’

列表的操作符

比较操作符 > < == list1 > list2
逻辑操作符 and or not list1 and list2
链接操作符+ - list3 = list1 + list2 list 2 * 3
重复操作符* *=
成员关系操作符 in not in 1 in list1
list1 = [123]; list2 = [456]; list1 < list2 True
和字符串一样，只对ascci码表进行比较
a = ‘str’; b = ‘abc’; a > b True

列表推导式

#用循环生成列表
values = [10, 21, 4, 7, 12]
squares = []
for x in values:
    squares.append(x**2)
print(squares)              
[100, 441, 16, 49, 144]
#简化
values = [10, 21, 4, 7, 12]
squares = [x**2 for x in values]
print(squares)              
[100, 441, 16, 49, 144]
#还可以在列表推导式中加入条件进行筛选。
squares = [x**2 for x in values if x <= 10] 
[100, 16, 49]
#也可以使用推导式生成集合和字典：
square_set = {x**2 for x in values if x <= 10}
print(square_set)           
set([16, 49, 100])
square_dict = {x: x**2 for x in values if x <= 10}
print(square_dict)          
{10: 100, 4: 16, 7: 49}
#求和
total = sum([x**2 for x in values if x <= 10])
#但是，Python会生成这个列表，然后在将它放到垃圾回收机制中（因为没有变量指向它），这毫无疑问是种浪费。
#为了解决这种问题，与xrange()类似，Python使用产生式表达式来解决这个问题：
total = sum(x**2 for x in values if x <= 10)
#只是去掉了括号，但这里并不会一次性的生成这个列表。
dataa = [(f, os.stat(f)) for f in glob.glob('*test*.py')]

6、元组 tuple

元组Tuple也是个有序序列，但是元组是不可变的，大部分用()生成,逗号’,’起决定性作用，也可以索引，切片；但是元组是不可变的。
改变会报错 t[0] = 1 #报错
只含有单个元素的元组容易和表达式混淆 。 a = (10,)
将列表转换为元组：
a = [10, 11, 12, 13, 14]
tuple(a)
列表与元组的速度比较
元组的生成速度要比列表的生成速度快得多，相差大概一个数量级;
在遍历上，元组和列表的速度表现差不多;
元组的生成速度会比列表快很多，迭代速度快一点，索引速度差不多;
更新和删除一个元组
temp = [1,2,3,4,5]
temp = temp(:2) + (‘new’, ) + temp(2:); #插入数据
用切片的方式删除或者其他操作，或者del删除

7、集合

可以用set()函数来显示的生成空集合
Python用{}来生成集合，集合中不含有相同元素
列表[]去重，转为集合
或者

for i in arr:
    if i not i brr:
        brr.append(i);

创建空集合的时候只能用set()来创建，因为在Python中{}创建的是一个空的字典
集合会自动去除重复元素

set([1, 2, 3, 1])       {1, 2, 3}
s = {2, 3, 4, 2}        {2, 3, 4}
#添加元素
s.add(5)                {2,3,4,5}
#删除 没有这个元素报错
s.remove(2)
a = {1,2,3,4}
b = {2, 3, 4, 5}
#集合的交           
a.intersection(b) 
a & b           {1,2,3,4,5}
#集合的并           
a.union(b)
a | b           {2,3,4}
#集合的差           
a.difference(b)
a - b               {1}
#集合的对称差     
a.symmetric_difference(b)
a ^ b           {1,5}
#包含关系           
b.issubset(a)   #判断b是不是a的子集
b <= a  
#被包含            
a.issuperset(b) #a是不是包含b
a >= b
a <= a  True    a < a False
#集合方法
#add 方法向集合添加单个元素            s.add(a)
#update 方法向集合添加多个元素     s.update(seq)
#remove 方法移除单个元素          s.remove(ob)  不存在报错
#pop方法弹出元素                  t.pop()     没有元素会报错
#discard 方法与 remove 一样，但是当元素在集合中不存在的时候不会报错  t.discard(3)
#difference_update方法        a.difference_update(b)   从a中去除所有属于b的元素
#frozenset()    不可变集合
#frozenset([1,3,4])     #不可变
#clear()        清空集合
#解析
{x**2 for x in a_set}
{x for x in a_set ifx%2==0}

8、字典 Dictionary

字典没有顺序
Python用{key:value}来生成Dictionary。
在一些编程语言中也称为 hash ， map ，是一种由键值对组成的数据结构。
字典中键 key 对应的值，如果没有这个键，返回 default 指定的值（默认是 None ）
Python 使用 {} 或者 dict() 来创建一个空的字典：
dicts = dict(((‘f’, 3), (’s’, 22)))
dict4 = dict(我=’你好’, sb=’google’) 关键字定义

d = {'dogs':5, 'cats':4}    {'cats': 4, 'dogs': 5}
#大小
len(d)          2
#修改键值：
d["dogs"] = 2           {'cats': 4, 'dogs': 2}
#插入键值：
d["pigs"] = 7
#所有的键：
d.keys();
#所有的值：
d.values();
#所有的键值对：
d.items()
inventory = dict(
    [('foozelator', 123),
     ('frombicator', 18), 
     ('spatzleblock', 34), 
     ('snitzelhogen', 23)
    ])
{'foozelator': 123, 'frombicator': 18, 'snitzelhogen': 23, 'spatzleblock': 34}
#字典方法：
#get 方法     d.get(key, default = None)(改变为空的默认值)        
a.get("three")
#推荐使用get方法查找对应的key，没有会返回设置的default默认值，直接取值的话，没有会抛出异常。
#pop 方法删除元素 d.pop(key, default = None)  会改变原先值
popItem()       #弹出item
setdefault(key, default = None) #设置值
update(b)       #用b来更新前面dict的key值
#与列表一样，del 函数可以用来删除字典中特定的键值对，例如del a["one"]
#update方法更新字典   
d.update(newd)
person_modifications = {'first': 'James', 'middle': 'Clerk'}
person.update(person_modifications)
#in查询字典中是否有该键
barn = {'cows': 1, 'dogs': 5, 'cats': 3}    'chickens' in barn  False
formKeys(s,[val])   #把迭代对象s里面的每一个key都赋值为val,没有为None
dict1 = {}
dict1.formkeys((1,2,3)) #{1:None, 2:None, 3:None}
dict1.formkeys((1,2), (1,2)) # {1: (1,2), 2: (1,2)}#不智能，只是把后面参数给每一个都赋值
copy()  #浅拷贝
#解析
#1、
{f:os.stat(f) for f in glob.glob('*')}
#2、
a_dict = {'a': 1, 'b': 2, 'c': 3}
b_dict = {value:key for key, value in a_dict.items()}       
{1: 'a', 2: 'b', 3: 'c'}

lista = [['user', 'pilgrim'], ['database', 'master'],['password', 'PapayaWhip']]
a_dict = dict(lista)
a_dict  {'password': 'PapayaWhip', 'user': 'pilgrim', 'database': 'master'}

四、常用的BIF

BIF = Built-in functions(内置函数);

名称	用法
input()	输入框
sum()	求和
int()	变为整型 int(‘FF’, 16)以16进制转位10进制
float()	转为浮点型
help(bif)	查看使用方法
dir(builtins)	查看所有bif
abs()	绝对值
round()	取整
min()max()	最值
str(ob)	强制将ob转化成字符串 str(1.1 + 2.2) ‘3.3’
repr(ob)	强制将ob转化成字符串 repr(1.1 + 2.2) ‘3.3000000000000003’(python3以前版本， 3以后都为3.3)
hex()	转为16进制
oct()	转为8进制
bin()	转为2进制
tuple()	将列表转为元组
type()	判断类型
isinstance()	判断类型 isinstance(520, int)
format()	格式化字符串 字符串中花括号 {} 的部分会被format传入的参数替代
set()	生成新的集合
dict()	生成新的字典
range([start], end, [step])	生成一个列表 range(100) 长度为100的列表 默认从0开始
list()	变成列表 list(range(2, 30, 3))
reload()	重新导入加载的模块
filter(fun/None, 可迭代数据)	过滤器过滤函数返回值为True的数据
map(fun, 可迭代数据)	映射，加工数据之后返回加工后的数据
issubclass(class, classinfo)	如果前面的class是后面class的子类返回true

filter(None, [1, 0, True, False])   #1, true返回为True的内容
def jiou(item):
    return item % 2
lista = [0,1,2,3,4,5,6];
print(list(filter(jiou, lista)))    #fliter筛选奇数
print(list(filter(lambda lista : lista % 2 == 0, lista)))   #filter 筛选偶数 通过lambda关键字
#lambda表达式
#lambda表达式创建匿名函数
lambda x : 2 * x + 1;
#lambda关键字；在 : 的前边是函数参数，在 : 后面是return返回值；和js 的箭头函数一样 () => {}
g = lambda X : 2 * X + 1;
g(5)  # 11
#多个参数用逗号, 隔开
g = lambda x, y : x * y
g(2,3)   # 6

五、判断、循环、断言

1、判断

x = 0.5
if x > 0:
    print "Hey!"    
#虽然都是用 if 关键词定义判断，但与C，Java，javaScript等语言不同，
#Python不使用 {} 将 if 语句控制的区域包含起来。Python使用的是缩进方法。
#同时，也不需要用 () 将判断条件括起来。
#条件后的 : 是必须要的，缩进 值需要一样

#当条件1被满足时，执行 if 下面的语句，当条件1不满足的时候，转到 elif ，
#看它的条件2满不满足，满足执行 elif 下面的语句，不满足则执行 else 下面的语句。
#elif 的个数没有限制，可以是1个或者多个，也可以没有。
#else 最多只有1个，也可以没有。
x = 0
if x > 0:
    print "x is positive"
elif x == 0:
    print "x is zero"
else:
    print "x is negative"
#可以使用 and ， or , not 等关键词结合多个判断条件
#假如想判断一个年份是不是闰年，按照闰年的定义，这里只需要判断这个年份是不是能被4整除，但是不能被100整除，或者正好被400整除：
year = 1900
if year % 400 == 0:
    print "This is a leap year!"
# 两个条件都满足才执行
elif year % 4 == 0 and year % 100 != 0:
    print "This is a leap year!"
else:
    print "This is not a leap year."            #This is not a leap year
#值的测试
#Python不仅仅可以使用布尔型变量作为条件，它可以直接在if中使用任何表达式作为条件：
#大部分表达式的值都会被当作True，但以下表达式值会被当作False：
 # False
 # None
 # 0
 # 空字符串，空列表，空字典，空集合
mylist = [3, 1, 4, 1, 5, 9]
if mylist:                  #True
    print "The first element is:", mylist[0]
else:
    print "There is no first element."  The first element is: 3
mylist = []
if mylist:                  #False
    print "The first element is:", mylist[0]
else:
    print "There is no first element."  There is no first element.
#当然这种用法并不推荐，推荐使用 if len(mylist) > 0: 来判断一个列表是否为空
#三元操作符/三目操作符:
x, y = 4,5;
small = x if x < y else y;

2、循环

#循环的作用在于将一段代码重复执行多次。
#while 循环
while :
    
#Python会循环执行，直到不满足为止
#计算0～1000000的和
i = 0
total = 0
while i < 1000000:
    total += i
    i += 1
print(total)
#空容器会被当成 False ，因此可以用 while 循环来读取容器中的所有元素：
plays = set(['Hamlet', 'Macbeth', 'King Lear'])
while plays:
    play = plays.pop()
    print 'Perform', play
Perform King Lear
Perform Macbeth
Perform Hamlet
#循环每次从 plays 中弹出一个元素，一直到 plays 为空为止。

#for 循环
for  in :
    

#for 循环会遍历完中所有元素为止
plays = set(['Hamlet', 'Macbeth', 'King Lear'])
for play in plays:
    print 'Perform', play;
total = 0
for i in range(100000):
    total += i
print total
#然而这种写法有一个缺点：在循环前，它会生成一个长度为 100000 的临时列表。
#生成列表的问题在于，会有一定的时间和内存消耗，当数字从 100000 变得更大时，时间和内存的消耗会更加明显。
#为了解决这个问题，我们可以使用 xrange 来代替 range 函数，其效果与range函数相同，但是 xrange 并不会一次性的产生所有的数据：

#continue 语句

#遇到 continue 的时候，程序会返回到循环的最开始重新执行
#循环中忽略一些特定的值：
values = [7, 6, 4, 7, 19, 2, 1]
for i in values:
    if i % 2 != 0:
        # 忽略奇数
        continue
    print(i/2)          #3 2 1

#break 语句

#遇到 break 的时候，程序会跳出循环，不管循环条件是不是满足
insertStr = '帅';
answer = input('请输入说的话：');
while True:
    if answer == insertStr:
        break;
    else:
        answer = input('说错了哦，继续：');
print('客气客气');
#else语句
#与 if 一样， while 和 for 循环后面也可以跟着 else 语句，不过要和break一起连用。
     #当循环正常结束时，循环条件不满足， else 被执行；
     #当循环被 break 结束时，循环条件仍然满足， else 不执行。
values = [7, 6, 4, 7, 19, 2, 1]
for x in values:
    if x <= 10:
        print('Found:', x)
        break
else:
    print('All values greater than 10')     #Found: 7
values = [11, 12, 13, 100]
for x in values:
    if x <= 10:
        print('Found:', x)
        break
else:
    print('All values greater than 10'  All values greater than 10)

丰富的else语句

1、if else
2、for else
3、while else
4、try :
except :
else :

3、断言 assert

assert关键字称之为断言，当这个关键字后面为假时，程序自动崩溃，并抛出异常；

六、函数

Python用关键词def来定义函数。
只有函数，没有过程
函数通常有一下几个特征：

• 使用 def 关键词来定义一个函数。
• def 后面是函数的名称，括号中是函数的参数，不同的参数用 , 隔开， def foo(): 的形式是必须要有的，参数可以为空；
• 使用缩进来划分函数的内容；
• docstring 用 “”” 包含的字符串，用来解释函数的用途，可省略；
• return 返回特定的值，如果省略，返回 None 。
• 多个值默认返回一个元组

变量作用域

局部变量、全局变量
函数在执行的时候存到栈里面，执行完毕，清空此栈，所以里面的局部变量就访问不到，在执行，又会重新存到一个新的栈里面；
如果在函数内想修改全局变量的话，python会在函数内创建一个新的局部变量代替，名字和全局变量一样，函数内部想修改，用global 修饰一下。

#Python并没有限定参数的类型，因此可以使用不同的参数类型
def poly(x, a, b, c):
    y = a * x ** 2 + b * x + c
    return y
x = 1
poly(x, 1, 2, 3)
def add(x, y):
    """Add two numbers"""
    a = x + y
    return a
#传参方式
print add(x=2, y=3)
print add(y="foo", x="bar")
#也可以混合
print add(2, y=3)
#设定关键字参数，按照关键字找参数
#只要你有一个命名参 数，它右边的所有参数也都需要是命名参数
def saysome(name, words):
    print(name + 'says' + words);
saysome('gqk', 'good');
saysome(words = 'good', name = 'gqk');
#设定参数默认值
def quad(x, a=1, b=0, c=0):
    return a*x**2 + b*x + c
print quad(2.0) #可以省略有默认值的参数
#接收不定参数
#*args 表示参数数目不定，可以看成一个元组，把第一个参数后面的参数当作元组中的元素。
def add(x, *args):
    total = x
    for arg in args:
        total += arg
    return total
def test(*parmars, arg):
print(parmars[1], arg);
test(0,2,3,4,4, arg = 'argument');
#**kwargs 表示参数数目不定，相当于一个字典，关键词和值对应于键值对。
def add(x, **kwargs):
    total = x
    for arg, value in kwargs.items():
        print "adding ", arg
        total += value
    return total
#可以接收任意数目的位置参数和键值对参数
#不过要按顺序传入参数，先传入位置参数 args ，在传入关键词参数 kwargs
def foo(*args, **kwargs):
    print(args, kwargs)
foo(2, 3, x='bar', z=10)        (2, 3) {'x': 'bar', 'z': 10}
#返回多个值
from math import atan2
def to_polar(x, y):
    r = (x**2 + y**2) ** 0.5
    theta = atan2(y, x)
    return r, theta
r, theta = to_polar(3, 4)
print(r, theta)
#Python将返回的两个值变成了元组

#内嵌/部函数和闭包
#global关键字；
#一般来说，函数中是可以直接使用全局变量的值的：
#但是要在函数中修改全局变量的值，需要加上 global 关键字：
#如果不加上这句 global 那么全局变量的值不会改变：
x = 15                      x = 15
def print_newx():           def print_new():
    global x                    x = 18;
    x = 18                      
print(x)            #18     print(x);           #18
print_newx()        #18     print_new();        #18
print(x)            #18     print(x);           #15
#闭包：一种编程方式
#如果在一个内部函数里，对外部作用域(但不是在全局作用域的变量进行引用)，那么内部函数就被认为闭包；
def funX(x):
    def funY(y):        #funY是一个闭包
        return x * y
    return funY
i = funX(8)     #i 是function
i(5)            #40
funX(8)(5)      #40
#nonlocal关键字
def funX():
    x = 4;
    def funY():
        nonlocal x;     //定义为不是局部变量
        x *= x;
        return x;
    return funY();
print(funX());
#lambda表达式
#lambda表达式创建匿名函数
#lambda x : 2 * x + 1;
#lambda关键字；在 : 的前边是函数参数，在 : 后面是return返回值；
#和js 的箭头函数一样 () => {}
g = lambda X : 2 * X + 1;
g(5)  # 11
#多个参数用逗号, 隔开
g = lambda x, y : x * y
g(2,3)   # 6

七、类Class

OO 面向对象 Object Oriented
OOA 面向对象分析
OOD 面向对象设计
OOP 面向对象编程

OO的特征
1、封装 ->封装了属性和方法；
2、继承 ->子类自动共享父类属性和方法的机制；
3、多态 ->不同对象对同一方法响应不同的行动；

封装：

python中的类名以大写字母开头

class Tuple:            
    #属性
    color = '绿色';
    weight = 10;
    legs = 4;
    shell = True;
    mouse = '大嘴';

    #方法                 都有一个self
    def say(self):              slef    类似于 js里面的this
    print('叫');
    def jump(self):
    print('跑');
定义对象
tt = Tuple();   #类名()
tt.say();
tt.jump();
tt.color;

#类         类对象      实例对象
Tuple     Tuple()         tt

继承：

          子类    父类、基类、超类
class MyclassA(MyclassB):
#如果子类中定义和父类同名的方法和属性，则会覆盖继承父类的子类实例化之后的方法和属性；原先父类的方法和属性并不会变；

#多重继承
class ChildClass(Parent1, Parent2, Parent3):

多态：

class A:                    class B:
    def fun(self):              def fun(self):
    print('A');                 print('B')
a = A();                    b = B();
a.fun();                    b.fun();
同一方法，响应不同

特殊方法

#__init__(self) 构造方法；实例化的时候该方法会自动调用，js构造函数
class Ball:
    def __init__(self, name):
        self.name = name;
    def say(self):
        print('%s' % self.name)
a = Ball('球A'); #此时实例化的时候需要传入参数；
a.say();            #球A;

公有和私有

#在python中定义私有的只需要在函数名或者变量名前加 __ 即为私有，名称后面不能在加 __ 
class Person:
    __name = 'gqk';
    def getName(self):
        return self.__name;
p = Person();
p.__name;       #报错
p.name;         #报错
p.getName()     #gqk
p._Person__name #gqk        类名前面一个_，属性名前面两个__

一些相关的BIF

BIF	介绍
issubclass(class, classinfo)	如果前面的class是后面class的子类返回true，一个类是被认为是自身的子类，classinfo可以是各个类组合的元组，只有满足一个就是true
isinstance(object, classinfo)	object实例对象是否属于classinfo，classinfo 可以是元组，第一个不是object的话永远是False
hasattr(object, name)	测试对象是否有指定的属性
getattr(object, name[,default])	返回对象制定的属性值，找不到返回设置的默认值，没有默认值，报错
setattr(object, name, value)	设置对象属性，没有新建一个
delattr(object, name)	删除指定属性，没有抛出异常

魔法方法：总是被双下划线包围

第一个被调用的是__new__方法

魔法方法	含义
基本的魔法方法
__new__(cls[, ...])	1.__new__ 是在一个对象实例化的时候所调用的第一个方法2. 它的第一个参数是这个类，其他的参数是用来直接传递给 __init__ 方法3.__new__ 决定是否要使用该 __init__ 方法，因为 __new__ 可以调用其他类的构造方法或者直接返回别的实例对象来作为本类的实例，如果 __new__ 没有返回实例对象，则 __init__ 不会被调用4. __new__主要是用于继承一个不可变的类型比如一个 tuple 或者 string
__init__(self[, ...])	构造器，当一个实例被创建的时候调用的初始化方法
__del__(self)	析构器，当一个实例被销毁的时候调用的方法
__call__(self[, args...])	允许一个类的实例像函数一样被调用：x(a, b) 调用 x.__call__(a, b)
__len__(self)	定义当被 len() 调用时的行为
__repr__(self)	定义当被 repr() 调用时的行为
__str__(self)	定义当被 str() 调用时的行为
__bytes__(self)	定义当被 bytes() 调用时的行为
__hash__(self)	定义当被 hash() 调用时的行为
__bool__(self)	定义当被 bool() 调用时的行为，应该返回 True 或 False
__format__(self, format_spec)	定义当被 format() 调用时的行为
有关属性
__getattr__(self, name)	定义当用户试图获取一个不存在的属性时的行为
__getattribute__(self, name)	定义当该类的属性被访问时的行为
__setattr__(self, name, value)	定义当一个属性被设置时的行为
__delattr__(self, name)	定义当一个属性被删除时的行为
__dir__(self)	定义当 dir() 被调用时的行为
__get__(self, instance, owner)	定义当描述符的值被取得时的行为
__set__(self, instance, value)	定义当描述符的值被改变时的行为
__delete__(self, instance)	定义当描述符的值被删除时的行为
比较操作符
__lt__(self, other)	定义小于号的行为：x < y 调用 x.__lt__(y)
__le__(self, other)	定义小于等于号的行为
__eq__(self, other)	定义等于号的行为
__ne__(self, other)	定义不等号的行为
__gt__(self, other)	定义大于号的行为
__ge__(self, other)	定义大于等于号的行为
算数运算符
反运算符
增量赋值运算
一元操作符
类型转换
上下文管理（with 语句）
容器类型

八、模块、包

模块就是代码的封装

容器 -> 数据的封装
函数 -> 语句的封装
类 -> 方法和属性的封装
模块 -> 模块就是程序

下载模块
pip3 install module
和node中npm install module一样的用法

导入模块
1、import name
2、from 模块名 import 函数名
3、import 模块名 as 新名字
作用：
1、有功能性的封装代码
2、代码的复用

模块：
1、if__name__ == '__main__':
只有在模块作为本地测试或者单独跑文件的时候调用；
在.py中，此 __name__为__main__，在模块引入之后，此模块的__name__为模块名；
import template as tl;
在 template.py中__name__为__main__，在引入之后，tl.__name__为 template
2、搜索路径 import sys; sys.path
3、包
1）创建一个文件夹，创建文件init.py，把相关的.py文件放在里面
2）import 包名.(点)模块名 as 新名字
import foo.addNew as ad;
ad.addNew();

引入一个python内置或者下载的模块之后
可以通过 .__doc__查看文档、dir(name)查看帮助、help(name)
如果有__all__，可以调用看一下，返回的是作者想让外部调用的方法或者类，可以使用的
如果有__all__，通过 from name import * 倒入的，只会导入__all__里面的属性；

包

假设我们有这样的一个文件夹：
foo/

• __init__.py
• bar.py (defines func)
• baz.py (defines zap)
  这意味着 foo 是一个包，我们可以这样导入其中的内容：
  from foo.bar import func
  from foo.baz import zap

bar 和 baz 都是 foo 文件夹下的 .py 文件。
导入包要求：

• 文件夹 foo 在Python的搜索路径中
• __init__.py 表示 foo 是一个包，它可以是个空文件。

常用的模块

1）os 模块
import os
使用：os.方法名()
os模块中关于文件/目录常用的函数使用方法

函数名	使用方法
getcwd()	返回当前工作目录
chdir(path)	改变工作目录
listdir(path=’.’)	列举指定目录中的文件名（’.’表示当前目录，’..’表示上一级目录）
mkdir(path)	创建单层目录，如该目录已存在抛出异常
makedirs(path)	递归创建多层目录，如该目录已存在抛出异常，注意：’E:\a\b’和’E:\a\c’并不会冲突
remove(path)	删除文件
rmdir(path)	删除单层目录，如该目录非空则抛出异常
removedirs(path)	递归删除目录，从子目录到父目录逐层尝试删除，遇到目录非空则抛出异常
rename(old, new)	将文件old重命名为new
system(command)	运行系统的shell命令
walk(top)	遍历top路径以下所有的子目录，返回一个三元组：(路径, [包含目录], [包含文件])
os.curdir	指代当前目录（’.’）
os.pardir	指代上一级目录（’..’）
os.sep	输出操作系统特定的路径分隔符（Win下为’\’，Linux下为’/’）
os.linesep	当前平台使用的行终止符（Win下为’\r\n’，Linux下为’\n’）
os.name	指代当前使用的操作系统（包括：’posix’, ‘nt’, ‘mac’, ‘os2’, ‘ce’, ‘java’）

九、文件操作File IO

文件打开模式

打开模式	执行操作
‘r’	以只读方式打开文件（默认）
‘w’	以写入的方式打开文件，会覆盖已存在的文件
‘x’	如果文件已经存在，使用此模式打开将引发异常
‘a’	以写入模式打开，如果文件存在，则在末尾追加写入
‘b’	以二进制模式打开文件
‘t’	以文本模式打开（默认）
‘+’	可读写模式（可添加到其他模式中使用）
‘U’	通用换行符支持

f = open('myfile.txt', 'w');
f的文件对象方法

文件对象方法	执行操作
f.close()	关闭文件
f.read([size=-1])	从文件读取size个字符，当未给定size或给定负值的时候，读取剩余的所有字符，然后作为字符串返回
f.readline([size=-1])	从文件中读取并返回一行（包括行结束符），如果有size有定义则返回size个字符
f.write(str)	将字符串str写入文件
f.writelines(seq)	向文件写入字符串序列seq，seq应该是一个返回字符串的可迭代对象
f.seek(offset, from)	在文件中移动文件指针，从from（0代表文件起始位置，1代表当前位置，2代表文件末尾）偏移offset个字节
f.tell()	返回当前在文件中的位置
f.truncate([size=file.tell()])	截取文件到size个字节，默认是截取到文件指针当前位置

读文件

#使用 open 函数或者 file 函数来读文件，使用文件名的字符串作为输入参数：
f = open('test.txt')
f = file('test.txt')
#默认以读的方式打开文件，如果文件不存在会报错
#可以使用 read 方法来读入文件中的所有内容：
f.read()
#也可以按照行读入内容，readlines 方法返回一个列表，每个元素代表文件中每一行的内容
#使用完文件之后，需要将文件关闭。           
f.close()
#可以将 f 放在一个循环中，得到它每一行的内容
f = open('test.txt')
for line in f:
    print(line)
f.close()
#删除刚才创建的文件：
import os
os.remove('test.txt')

写文件

#我们使用 open 函数的写入模式来写文件：
f = open('myfile.txt', 'w')
f.write('hello world!')
f.close()

#使用 w 模式时，如果文件不存在会被创建，我们可以查看是否真的写入成功：
print(open('myfile.txt').read())
#hello world!

#如果文件已经存在， w 模式会覆盖之前写的所有内容：
f = open('myfile.txt', 'w')
f.write('another hello world!')
f.close()
print(open('myfile.txt').read())
#another hello world!
#除了写入模式，还有追加模式 a ，追加模式不会覆盖之前已经写入的内容，而是在之后继续写入：
f = open('myfile.txt', 'a')
f.write('... and more')
f.close()
print(open('myfile.txt').read())
#another hello world!... and more
#写入结束之后一定要将文件关闭，否则可能出现内容没有完全写入文件中的情况。
#还可以使用读写模式 w+：
f = open('myfile.txt', 'w+')
f.write('hello world!')
f.seek(6)
print(f.read())
f.close()
world!
#这里 f.seek(6) 移动到文件的第6个字符处，然后 f.read() 读出剩下的内容。
import os
os.remove('myfile.txt')

#####二进制文件 图片也是二进制写入

#二进制读写模式 b：
import os
f = open('binary.bin', 'wb')
f.write(os.urandom(16))
f.close()

f = open('binary.bin', 'rb')
print repr(f.read())
f.close()

'\x86H\x93\xe1\xd8\xef\xc0\xaa(\x17\xa9\xc9\xa51\xf1\x98'
import os
os.remove('binary.bin')

关闭文件

在Python中，如果一个打开的文件不再被其他变量引用时，它会自动关闭这个文件。
所以正常情况下，如果一个文件正常被关闭了，忘记调用文件的 close 方法不会有什么问题。
关闭文件可以保证内容已经被写入文件，而不关闭可能会出现意想不到的结果

with 语句和上下文管理器

with open('my_file', 'w') as fp:
    data = fp.write("Hello world")
#这等效于下面的代码，但是要更简便：
fp = open('my_file', 'w')
try:
    data = fp.write("Hello world")
finally:
    fp.close()

十、异常机制

try & except 块

一旦报错，程序就会停止执行，如果不希望程序停止执行，那么我们可以添加一对 try & except：

一旦 try 块中的内容出现了异常，那么 try 块后面的内容会被忽略，Python会寻找 except 里面有没有对应的内容，如果找到，就执行对应的块，没有则抛出这个异常。

捕捉不同的错误类型

1、捕捉所有异常
将except 的值改成 Exception 类，来捕获所有的异常;

try:
    pass
except Exception:
    pass

2、指定特定值
把 ZeroDivisionError 加入 except，就是把特定错误值加入except中

try:
    pass
except (ValueError, ZeroDivisionError): #所需的错误类型
    pass
或者有几个写几个
except ValueError:
    pass
except ZeroDivisionError:

得到异常的具体信息

exc.message

except Exception as exc:
    print("error:", exc.message)

finally

try/catch 块还有一个可选的关键词 finally。
不管 try 块有没有异常， finally 块的内容总是会被执行，而且会在抛出异常前执行，因此可以用来作为安全保证，比如确保打开的文件被关闭。

python异常标准

异常名称	异常
AssertionError	断言语句（assert）失败
AttributeError	尝试访问未知的对象属性
EOFError	用户输入文件末尾标志EOF（Ctrl+d）
FloatingPointError	浮点计算错误
GeneratorExit	generator.close()方法被调用的时候
ImportError	导入模块失败的时候
IndexError	索引超出序列的范围
KeyError	字典中查找一个不存在的关键字
KeyboardInterrupt	用户输入中断键（Ctrl+c）
MemoryError	内存溢出（可通过删除对象释放内存）
NameError	尝试访问一个不存在的变量
NotImplementedError	尚未实现的方法
OSError	操作系统产生的异常（例如打开一个不存在的文件）
OverflowError	数值运算超出最大限制
ReferenceError	弱引用（weak reference）试图访问一个已经被垃圾回收机制回收了的对象
RuntimeError	一般的运行时错误
StopIteration	迭代器没有更多的值
SyntaxError	Python的语法错误
IndentationError	缩进错误
TabError	Tab和空格混合使用
SystemError	Python编译器系统错误
SystemExit	Python编译器进程被关闭
TypeError	不同类型间的无效操作
UnboundLocalError	访问一个未初始化的本地变量（NameError的子类）
UnicodeError	Unicode相关的错误（ValueError的子类）
UnicodeEncodeError	Unicode编码时的错误（UnicodeError的子类）
UnicodeDecodeError	Unicode解码时的错误（UnicodeError的子类）
UnicodeTranslateError	Unicode转换时的错误（UnicodeError的子类）
ValueError	传入无效的参数
ZeroDivisionError	除数为零

十一、easygui图形用户界面编程

easygui 官网

用法

#引用：
import easygui as g
g.msgbox('Hello, world!');  
g.msgbox('Hello, World!','我是标题呀！= =')
g.choicebox('你喜欢我吗？', choices = ['喜欢','很喜欢','非常喜欢'])
g.msgbox(msg = ”, title = ”, ok_button = ‘OK’, image = None, root = None)
g.ccbox(msg = ‘continue?’, title = ”, choices = (‘choice1’, ‘choice2’), image = None)
#ccbox()提供一个选择：Continue或者Cancel, 并相应的返回1(选中Continue)或者0(选中Cancel)。
#注意：ccbox()是返回整型的1或0，不是布尔型的True或False。
import sys
if g.ccbox('和我交往吗？', choices = ('不要，你长得太丑了~','算了吧，要找个比你更好看的~')):
    g.msgbox('那我们绝交吧！哼~')
else:
    sys.exit(0)

#ynbox()    与ccbox()作用一样
g.ynbox(msg = ‘continue?’, title = ”, choices = (‘choice1’, ‘choice2’), image = None)
#buttonbox()    当用户点击按钮时，buttonbox()返回按钮的文本内容。如果用户取消或者关闭窗口，那么会返回默认选项(第一个选项)。
g.buttonbox(msg = '你叫什么名字？', choices = ('小花', '小芳', '小明'))
#indexbox()与buttonbox()差不多，只不过返回的是索引值
g.indexbox(msg = ‘continue?’, title = ”, choices = (‘Yes’, ‘No’), image = None)
#boolbox()  如果第一个按钮被选中返回1，否则返回0.
g.boolbox(msg = ‘continue?’, title = ”, choices = (‘Yes’, ‘No’), image = None)
#buttonbox中显示图片 。 当调用buttonbox 函数(例如：msgbox(), ynbox(), indexbox() 等等)的时候，还可以为关键字参数image赋值。仅支持gif图片
g.buttonbox("喂喂喂，你是谁？",image = r'*.jpg', choices = ('小白', '小黄', '小绿'))
#choicebox()多选框
choicebox(msg = ‘Pick something’, title = ”, choices = ())
choices = ['喜欢','很喜欢','非常喜欢', '以上答案都是，/(ㄒoㄒ)/~~']
choicebox(msg = '你喜欢编程吗？', title = '大胆说出你真心话！', choices = choices)
#multchoicebox()提供一个可选择的列表，与choicebox()不同的是，multchoicebox()支持用户选择0个，1个或者同事选择多个选项。返回值为，选择项组成的列表（无选择项时，列表为空）。
choices = ['喜欢','很喜欢','非常喜欢', '喜欢得不得了']
multchoicebox(msg = '你喜欢编程吗？', title = '大胆说出来', choices = choices)
#enterbox()提供简单的输入框，返回值为用户输入的字符串。默认返回的值会自动去除首尾的空格，如果需要保留首尾空格，设置参数strip=False，   其中，参数default为输入框默认显示值。
enterbox(msg = ‘enter something.’, title = ”, default = ”, strip = True, image = None, root =None)
#integerbox()为用户提供一个简单的输入框，用户只能输入范围内（lowerbound参数设置最小值，upperbound参数设置最大值）的整型数值 ，否则会要求用户重新输入。输入的为int型。
integerbox(msg = ”, title = ”, default = ”, lowerbound = 0, upperbound = 99, image = None, root = None, **invalidKeywordArguments)
15、multenterbox()
multenterbox(mag = ‘Fill in values for the fields.’, title = ”, fields = (), values = ())
#提供多个简单的输入框，注意：
    #1.如果用户输入的值比选项少，则返回列表中的值用空字符串填充用户为输入的选项；
    #2.如果用户输入的值比选项多，则返回列表中的值将截断为选项的数量；
    #3.如果用户取消操作，则返回域中的列表的值或者None值；
fields_list = ['*用户名','*手机号','QQ','*E-mail']
values_list = ['Shirley','','','']
multenterbox(msg = '带*号的为必填项', title = '123', fields = fields_list, values = values_list)
#passwordbox()用户密码输入
passwordbox(msg = ‘Enter your password.’, title = ”, default = ”, image = None, root = None)
#passwordbox()跟enterbox()样式一样，不同的是用户输入的内容用”*“显示出来，返回用户输入的字符串。
#multpasswordbox()
multpasswordbox(msg = ‘Fill in values for the fields.’, title = ”,fields = (), values = ())
multpasswordbox(msg = '请输入用户名和密码', title = '登录',fields = ('用户名：','密码'), values = ('Shirley',))
#textbox()显示文本      
textbox(msg = ”, title = ”, text = ”, codebox = 0) 
#函数默认会以比例字体（参数codebox = 1设置为等宽字体）来显示文本内容（会自动换行），这个函数适合用于显示一般的书面文字，参数text可以是字符串类型，列表类型，或者元组类型
textbox(msg = '文本内容如下：', title = '文本文件', text = text, codebox = 1)
#codebox(msg = ”, title = ”, text = ”)以等宽字体显示文本内容，相当于textbox(codebox=1)
#目录与文件
#当需要用户输入目录及文件名的时候，需要有浏览文件系统，让用户选择
#diropenbox()   打开文件夹
diropenbox(msg = None, title = None, default = None)
#用于提供一个对话框，返回用户选择的目录名（完整路径），如果用户选择“Cancel”则返回None，default参数用于设置默认的打开目录（需是存在的目录）
#fileopenbox()  打开文件
fileopenbox(msg = None, title = None, default = ‘*’, filetypes = None)
#filesavebox()
filesavebox(msg = None, title = None, default = ”, filetypes = None)

十二、爬虫

python访问互联网

url + lib -> urllib;
urllib.request
在下载好的IDLE中 -> Help -> python Docs，点进去；
都是python的文挡，所有python内置的东西都在里面能找到用法、含义等。
搜索 urllib.request;

请求方法

urllib.request.urlopen(url, data=None, [timeout, ]*, cafile=None, capath=None, cadefault=False, context=None)
#如果data参数没有值，默认用get方式提交，如果有值，以post方式提交
#要用 urllib.parse.urlencode()的编码格式，把data进行编码
urllib.request.Request(url, data=None, headers={}, origin_req_host=None, unverifiable=False, method=None)
#url应该是包含有效URL的字符串。

对一个页面进行爬取

#读取elementUI中返回的文档
import urllib.request as req        #引入urllib.request
res = req.urlopen('http://element-cn.eleme.io/#/zh-CN/component/input');                #打开链接
html = res.read();                  #读取返回值
print(html);
html = html.decode('utf-8');        #解析，根据页面的格式进行解析
print(html)

下载图片

import urllib.request as req;           #引入 urllib.request
res = req.urlopen('http://placekitten.com/500/600');    #打开对应的图片链接

cat_img = res.read();                   #读取请求回来的数据
with open('cat_imng.jpg', 'wb') as f:   #创建文件并用二进制写入图片 使用with语句
    f.write(cat_img);

传参

import urllib.request as reqs;
import urllib.parse;        #引入编码
url = 'http://eledata.superboss.cc/business/businessAnalysis.rjson';
data = {
    "endDate":"2018-08-11",
    "startDate":"2018-08-11"
}
data = urllib.parse.urlencode(data).encode('utf-8');    #把参数进行编码
print(data);
res = reqs.urlopen(url, data);
html = res.read().decode('utf-8');
print(html);

headers头

一般浏览器正常请求在network里的 Request Headers中，
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.99 Safari/537.36，而在python里面请求为python，很多服务端会根据这个判断是不是浏览器请求而拒绝访问。python可以在headers里面添加对应的User-Agent即可。
两种方式添加：
1）直接在urllib.request.Request(data, headers)添加headers
2）用add_header()方法添加；

#直接用urllib.request.urlopen()其实python在内部做了两部处理：
#req = urllib.request.Request(url, data, headers);
#res = urllib.request.urlopen(req);
url = 'https://eledata.superboss.cc/business/businessAnalysis.rjson';
data = {"startDate":"2018-08-12","endDate":"2018-08-12"}
head = {
    'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.99 Safari/537.36'
}
data = par.urlencode(data).encode('utf-8');
print(data);
req = reqs.Request(url, data, head);        #添加headers和data
#req.add_header('user-agent', '****');
res = reqs.urlopen(req);
html = res.read().decode('utf-8');
print(json.loads(html));
print(reqss.headers)

HTTPS

https一种网络协议，python对直接请求https的网站会抛出异常；
两种简单的解决方案：
1）
import ssl
ssl._create_default_https_context = ssl._create_unverified_context
2）
import ssl
context = ssl._create_unverified_context()
res = urllib.request.urlopen(url, data, context=context);

cookie

一般性网站都是通过cookie来进行用户登陆以及一些信息处理，简单的页面爬取的话，如果有cookie限制，可以直接在headers里面添加对应页面的cookie即可。

十三、Beautiful Soup

Beautiful Soup 是一个可以从HTML或XML文件中提取数据的Python库，它能够通过你喜欢的转换器实现惯用的文档导航、查找、修改文档的方式，Beautiful Soup会帮你节省数小时甚至数天的工作时间。
一个强大的html解析模块，python中的jQuery。
官方文档