python3学习笔记：1.基础知识
整理文档发现两年前学习paython3的笔记。当时工作有需要结果也没用上，现在忘的差不多了，在这里整理下。
按 菜鸟编程python3教程编写的demo。链接
基础知识部分：
0.模块（命名空间、作用域、函数、包等）
#模块：建议看完 6.函数 之后再看这个
# ..\Python\Python35\Tools\demo，安装目录下有些demo，看不太懂，囧
# 1.模块：同java
"""
模块让你能够有逻辑地组织你的Python代码段。
把相关的代码分配到一个 模块里能让你的代码更好用，更易懂。
模块也是Python对象，具有随机的名字属性用来绑定或引用。
简单地说，模块就是一个保存了Python代码的文件。模块能定义函数，类和变量。模块里也能包含可执行的代码。
"""
# 2.import ，引入其他Python源文件，同java
"""
说明：
当解释器遇到import语句，如果模块在当前的搜索路径就会被导入。
搜索路径是一个解释器会先进行搜索的所有目录的列表。如想要导入模块hello.py，需要把命令放在脚本的顶端：
语法：
import module1[, module2[,... moduleN]
"""
# From…import 语句：Python的from语句让你从模块中导入一个指定的部分到当前命名空间中。
"""
语法：
from modname import name1[, name2[, ... nameN]]
例子：
要导入模块fib的fibonacci函数，使用如下语句：
from fib import fibonacci
"""
# From…import*：把一个模块的所有内容全都导入到当前的命名空间也是可行的
"""
语法：
from modname import *
"""
# 3.定位模块：模块搜索路径存储在system模块的sys.path变量中。变量里包含当前目录，PYTHONPATH和由安装过程决定的默认目录。
"""
当你导入一个模块，Python解析器对模块位置的搜索顺序是：
1.当前目录。
2.如果不在当前目录，Python 则搜索在 shell 变量 PYTHONPATH 下的每个目录。
3.如果都找不到，Python会察看默认路径。UNIX下，默认路径一般为/usr/local/lib/python/。
"""
# 4.PYTHONPATH变量：即python的环境变量，注意windows和unix平台
"""
在Windows系统，典型的PYTHONPATH如下：
set PYTHONPATH=c:\python20\lib;
在UNIX系统，典型的PYTHONPATH如下：
set PYTHONPATH=/usr/local/lib/python
"""
# 5.命名空间和作用域：变量是拥有匹配对象的名字（标识符）。命名空间是一个包含了变量名称们（键）和它们各自相应的对象们（值）的字典。
"""
变量是拥有匹配对象的名字（标识符）。命名空间是一个包含了变量名称们（键）和它们各自相应的对象们（值）的字典。
一个Python表达式可以访问局部命名空间和全局命名空间里的变量。如果一个局部变量和一个全局变量重名，则局部变量会覆盖全局变量。
每个函数都有自己的命名空间。类的方法的作用域规则和通常函数的一样。
Python会智能地猜测一个变量是局部的还是全局的，它假设任何在函数内赋值的变量都是局部的。
因此，如果要给全局变量在一个函数里赋值，必须使用global语句。 ------重点
global VarName的表达式会告诉Python， VarName是一个全局变量，这样Python就不会在局部命名空间里寻找这个变量了。
"""
Money = 2000
def AddMoney():
# 想改正代码就取消以下注释:
global Money;
Money = Money + 1;
print('使用全局变量需要加global表达式，声明为全局变量 全局Money',Money)
AddMoney();
print('使用全局变量需要加global表达式，声明为全局变量 方法调用后Money',Money)
# 6.dir()函数：dir()函数一个排好序的字符串列表，内容是一个模块里定义过的名字。返回的列表容纳了在一个模块里定义的所有模块，变量和函数。
import math
content = dir(math);
print(content);
# 7.globals()和locals()函数：根据调用地方的不同，globals()和locals()函数可被用来返回全局和局部命名空间里的名字。
"""
如果在函数内部调用locals()，返回的是所有能在该函数里访问的命名。
如果在函数内部调用globals()，返回的是所有在该函数里能访问的全局名字。
两个函数的返回类型都是字典。所以名字们能用keys()函数摘取。
"""
# 8.reload()函数：当一个模块被导入到一个脚本，模块顶层部分的代码只会被执行一次。
"""
说明：
因此，如果你想重新执行模块里顶层部分的代码，可以用reload()函数。该函数会重新导入之前导入过的模块。语法如下：
reload(module_name)
在这里，module_name要直接放模块的名字，而不是一个字符串形式。比如想重载hello模块，如下：
reload(hello)
"""
# 9.Python中的包：包是一个分层次的文件目录结构，它定义了一个由模块及子包，和子包下的子包等组成的Python的应用环境。和java类似。
"""
例子：导入包，执行对应方法：
from Pots import Pots
from Isdn import Isdn
from G3 import G3
import Phone
Phone.Pots()
Phone.Isdn()
Phone.G3()
"""1.基础语法
# python 官网地址: https://www.python.org/ 下载后可以运行python交互式客户端
# 菜鸟教程 Python3 基础语法 ： http://www.runoob.com/python3/python3-tutorial.html
'''
Python的3.0版本，常被称为Python 3000，或简称Py3k。相对于Python的早期版本，这是一个较大的升级。为了不带入过多的累赘，Python 3.0在设计的时候没有考虑向下兼容。
'''
#交互式编程不需要创建脚本文件，是通过 Python 解释器的交互模式进来编写代码。
#print "Hello, Python!" #python2版本中可以这样输出print语句。 python3中，去除了print语句，加入print()函数实现相同的功能。
print("Hello, Python!")
# 编码：默认情况下，Python 3 源码文件以 UTF-8 编码，所有字符串都是 unicode 字符串
# 1.标识符
'''
第一个字符必须是字母表中字母或下划线'_'。
标识符的其他的部分有字母、数字和下划线组成。
标识符对大小写敏感。
'''
print('\n标识符')
_foo =1 #以单下划线开头（_foo）的代表不能直接访问的类属性，需通过类提供的接口进行访问
__foo=2 #以双下划线开头的（__foo）代表类的私有成员
__foo__=3 #以双下划线开头和结尾的（__foo__）代表python里特殊方法专用的标识，如__init__()代表类的构造函数。
__init__=(4)
# 2.行和缩进：python最具特色的就是使用缩进来表示代码块，不需要使用大括号({})。缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数
print('\n行和缩进')
if True:
print("Answer")
print ("True")
else:
print ("Answer")
# 没有严格缩进，在执行时保持
print("False")
# 3.多行语句：可以使用斜杠（ \）将一行的语句分为多行显示，语句中包含[], {} 或 () 括号就不需要使用多行连接符
print('\n多行语句')
total = 1 + \
2 \
+3
str="sad" \
"sadasd" \
"asdasd" \
"11"
days = ['Monday', 'Tuesday', 'Wednesday',
'Thursday', 'Friday']
print(total)
print(str)
print(days)
# 4.引号:
#Python 接收单引号(' )，双引号(" )，三引号(''' """) 来表示字符串，引号的开始与结束必须的相同类型的。
#其中三引号可以由多行组成，编写多行文本的快捷语法，常用语文档字符串，在文件的特定地点，被当做注释。代码中也可以当多行注释使用
print('\n引号')
word = 'word'
sentence = "这是一个句子。"
paragraph = """这是一个段落。
包含了多个语句
aaa"""
print(word)
print(sentence)
print(paragraph)
"""332
多行注释1
"""
'''112
多行注释2
'''
# 5.创建对象，删除对象
a=1
b=2
del a # del a ,b
# 6.变量 ：Python中的变量不需要声明，变量的赋值操作既是变量声明和定义的过程。
"""
同时为多个变量赋值：a = b = c = 1
为多个对象指定多个变量：a, b, c = 1, 2, "bxy"
"""
# 7.标准数据类型，具体后面还有笔记
'''
Numbers（数字）
String（字符串）
List（列表）
Tuple（元组）
Dictionary（字典）
'''
# 8.Python数据类型转换
'''
函数 描述
int(x [,base]) 将x转换为一个整数
long(x [,base] ) 将x转换为一个长整数
float(x) 将x转换到一个浮点数
complex(real [,imag]) 创建一个复数
str(x) 将对象 x 转换为字符串
repr(x) 将对象 x 转换为表达式字符串
eval(str) 用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s) 将序列 s 转换为一个元组
list(s) 将序列 s 转换为一个列表
set(s) 转换为可变集合
dict(d) 创建一个字典。d 必须是一个序列 (key,value)元组。
frozenset(s) 转换为不可变集合
chr(x) 将一个整数转换为一个字符
unichr(x) 将一个整数转换为Unicode字符
ord(x) 将一个字符转换为它的整数值
hex(x) 将一个整数转换为一个十六进制字符串
oct(x) 将一个整数转换为一个八进制字符串
'''
#数据类型：
"""
Numbers（数字）
String（字符串）
List（列表）
Tuple（元组）
Dictionary（字典）
"""
# 1.数字
"""
int（长整型，没有 python2 中的 Long）
float（浮点型）
bool（布尔型）：在Python2中是没有布尔型的，它用数字0表示False，用1表示True。到Python3中，把True和False定义成关键字了，但它们的值还是1和0，它们可以和数字相加。
complex（复数）：复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。
"""
print('')
a = 3.14j
b = 8.32e-36j
print('数字.复数 3.14j',a)
print('数字.复数 8.32e-36j',b)
#Python Number 类型转换
'''
int(x [,base ]) 将x转换为一个整数
long(x [,base ]) 将x转换为一个长整数
float(x ) 将x转换到一个浮点数
complex(real [,imag ]) 创建一个复数
str(x ) 将对象 x 转换为字符串
repr(x ) 将对象 x 转换为表达式字符串
eval(str ) 用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s ) 将序列 s 转换为一个元组
list(s ) 将序列 s 转换为一个列表
chr(x ) 将一个整数转换为一个字符
unichr(x ) 将一个整数转换为Unicode字符
ord(x ) 将一个字符转换为它的整数值
hex(x ) 将一个整数转换为一个十六进制字符串
oct(x ) 将一个整数转换为一个八进制字符串
'''
#Python数学函数：
"""
函数 返回值 ( 描述 )
abs(x) 返回数字的绝对值，如abs(-10) 返回 10
ceil(x) 返回数字的上入整数，如math.ceil(4.1) 返回 5
cmp(x, y) 如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1
exp(x) 返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
fabs(x) 返回数字的绝对值，如math.fabs(-10) 返回10.0
floor(x) 返回数字的下舍整数，如math.floor(4.9)返回 4
log(x) 如math.log(math.e)返回1.0,math.log(100,10)返回2.0
log10(x) 返回以10为基数的x的对数，如math.log10(100)返回 2.0
max(x1, x2,...) 返回给定参数的最大值，参数可以为序列。
min(x1, x2,...) 返回给定参数的最小值，参数可以为序列。
modf(x) 返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
pow(x, y) x**y 运算后的值，幂运算。
round(x [,n]) 返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。
sqrt(x) 返回数字x的平方根，数字可以为负数，返回类型为实数，如math.sqrt(4)返回 2+0j
"""
#Python随机数函数：随机数可以用于数学，游戏，安全等领域中，还经常被嵌入到算法中，用以提高算法效率，并提高程序的安全性。
"""
函数 描述
choice(seq) 从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。
randrange ([start,] stop [,step]) 从指定范围内，按指定基数递增的集合中获取一个随机数，基数缺省值为1
random() 随机生成下一个实数，它在[0,1)范围内。
seed([x]) 改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。
shuffle(lst) 将序列的所有元素随机排序
uniform(x, y) 随机生成下一个实数，它在[x,y]范围内。
"""
#Python三角函数：http://www.runoob.com/python/python-numbers.html
"""
略
"""
#Python数学常量
"""
常量 描述
pi 数学常量 pi（圆周率，一般以π来表示）
e 数学常量 e，e即自然常数（自然常数）。
"""
# 2.字符串
#Python不支持单字符类型，单字符也在Python也是作为一个字符串使用
print('\n字符串')
var1 = 'Hello_World!'
var2 = "你好坏abcdefg"
#[] 方括号截取字符串
print ("截取字符串 任意一位: ", var1[0])
print ("截取字符串 截取区间: ", var1[1:5])
print ("截取字符串 倒序: ", var1[-2]) #注意倒序时，第一位为0，最后一位为-1
print ("截取字符串 倒序: ", var1[-3:])
print ("更新字符串 去头加尾: ", var1[5:] + '_bxy!')
print ("更新字符串 替换尾部: ", var1[:5] + '_bxy!')
print ("更新字符串 跨步取值: ", var1[::2]) #即按间隔取值
print ("更新字符串 跨步取值倒序: ", var1[::-2]) #即按间隔取值
print ("更新字符串 跨步取值截取倒序: ", var1[-1:-5:-2]) #即按间隔取值
#Python转义字符：http://www.runoob.com/python/python-strings.html
#Python字符串运算符：下表实例变量a值为字符串"Hello"，b变量值为"Python"
"""
操作符 描述 实例
+ 字符串连接 a + b 输出结果： HelloPython
* 重复输出字符串 a*2 输出结果：HelloHello
[] 通过索引获取字符串中字符 a[1] 输出结果 e
[ : ] 截取字符串中的一部分 a[1:4] 输出结果 ell
in 成员运算符 - 如果字符串中包含给定的字符返回 True H in a 输出结果 1
not in 成员运算符 - 如果字符串中不包含给定的字符返回 True M not in a 输出结果 1
r/R 原始字符串 - 原始字符串：所有的字符串都是直接按照 print r'\n' 输出 \n 和 print R'\n' 输出 \n
字面的意思来使用，没有转义特殊或不能打印的字符。
原始字符串除在字符串的第一个引号前加上字母"r"（
可以大小写）以外，与普通字符串有着几乎完全相同的语法
% 格式字符串
"""
a = "Hello"
b = "Python"
print('\n字符串运算：')
print ("a + b 输出结果：", a + b)
print ("a * 2 输出结果：", a * 2)
print ("a[1] 输出结果：", a[1] )
print ("a[-0] 倒序读取元素 输出结果：", a[-0] ) #倒序操作时，序号：第一位为-0，最后一位为-1
print ("a[-1] 倒序读取元素 输出结果：", a[-1] )
print ("a[1:4] 输出结果：", a[1:4] )
if( "H" in a) :
print ("H 在变量 a 中" )
else :
print ("H 不在变量 a 中")
if( "M" not in a) :
print ("M 不在变量 a 中")
else :
print ("M 在变量 a 中")
print (r'\n')
print (R'\n')
#Python字符串格式化：个人认为类似java format操作
print ("\n字符串格式化：" + "My name is %s and weight is %+d kg!" % ('BXY', 21) )
"""
python字符串格式化符号:
符号 描述
%c 格式化字符及其ASCII码
%s 格式化字符串
%d 格式化整数
%u 格式化无符号整型
%o 格式化无符号八进制数
%x 格式化无符号十六进制数
%X 格式化无符号十六进制数（大写）
%f 格式化浮点数字，可指定小数点后的精度
%e 用科学计数法格式化浮点数
%E 作用同%e，用科学计数法格式化浮点数
%g %f和%e的简写
%G %f 和 %E 的简写
%p 用十六进制数格式化变量的地址
格式化操作符辅助指令:
符号 功能
* 定义宽度或者小数点精度
- 用做左对齐
+ 在正数前面显示加号( + )
在正数前面显示空格
# 在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X')
0 显示的数字前面填充'0'而不是默认的空格
% '%%'输出一个单一的'%'
(var) 映射变量(字典参数)
m.n. m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话)
"""
#Python三引号（triple quotes）:""" 或 '''，python中三引号可以将复杂的字符串进行复制:python三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。
#三引号让程序员从引号和特殊字符串的泥潭里面解脱出来，自始至终保持一小块字符串的格式是所谓的WYSIWYG（所见即所得）格式的。避免繁琐的字符串转义（如HTML或者SQL）
print('\n三引号：')
errHTML = '''
Friends CGI Demo
ERROR
%s
'''
sql=('''
CREATE TABLE users (
login VARCHAR(8),
uid INTEGER,
prid INTEGER)
''')
print(errHTML);
print(sql);
#Unicode 字符串：引号前小写的"u"表示这里创建的是一个 Unicode 字符串。也可以使用 Python 的 Unicode-Escape 编码。
print('\nUnicode 字符串：')
a=u'Hello World !'
b='Hello\u0020World !'
print(a)
print(b)
#python的字符串内建函数：http://www.runoob.com/python/python-strings.html
print('\n字符串内建函数：')
a = 'pledge_sku_list'
print(a.capitalize()) #把字符串的第一个字符大写
print(a.center(30)) #返回一个原字符串居中,并使用空格填充至长度 width 的新字符串
print(a.count('l') ) #返回 str 在 string 里面出现的次数
print(a.find('list')) #检测 str 是否包含在 string 中，如果是返回开始的索引值，否则返回-1
print(max(a)) # 返回字符串 a 中最大的字母。
# 3.集合：集合（set）是一个无序不重复元素的序列。
'''
基本功能是进行成员关系测试和删除重复元素。
可以使用大括号({})或者 set()函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
'''
student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}
print('集合 输出集合，重复的元素被自动去掉',student) # 输出集合，重复的元素被自动去掉
# 成员测试
if('Rose' in student) :
print('集合 Rose 在集合中')
else :
print('集合 Rose 不在集合中')
# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')
print('集合',a)
print('集合a和b的差集',a - b) # a和b的差集
print('集合a和b的并集',a | b) # a和b的并集
print('集合a和b的交集',a & b) # a和b的交集
print('集合a和b中不同时存在的元素',a ^ b) # a和b中不同时存在的元素
2.2.数据类型(列表、元祖和字典)
# 3.列表
"""
序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。
Python有6个序列的内置类型，但最常见的是列表和元组。
序列都可以进行的操作包括索引，切片，加，乘，检查成员。
此外，Python已经内置确定序列的长度以及确定最大和最小的元素的方法。
列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。
列表的数据项不需要具有相同的类型
操作：
取值：切片和索引，list[]
添加：list.append
删除：del(list[])，list.remove(lise[])
修改：list[]=x
查找：var in list
"""
#访问列表中的值
print('\n列表：')
list1 = ['physics', 'chemistry', 1997, 2000];
list2 = [1, 2, 3, 4, 5 ];
list3 = ["a", "b", "c", "d"];
#列表操作：可以对列表的数据项进行修改或更新；使用append()方法来添加列表项；del 语句来删除列表的的元素。
print ("列表 截取操作和字符串一致：list1[0]: ", list1[0])
print ("列表 截取操作和字符串一致：list2[1:5]: ", list2[1:4])
print ("列表 截取操作和字符串一致：list2[-0]: ", list2[-0])
print ("列表 截取操作和字符串一致：list2[-1]: ", list2[-1])
print ("列表 更新操作 更新前：list1[0]: ", list1[0])
list1[0]=111
print ("列表 更新操作 更新后：list1[0]: ", list1[0])
print ("列表 删除操作 删除前：list1[0]: ", list1[0])
del list1[0]
print ("列表 删除操作 删除后：list1[0]: ", list1[0])
#Python列表脚本操作符 ：列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。
"""
Python 表达式 结果 描述
len([1, 2, 3]) 3 长度
[1, 2, 3] + [4, 5, 6] [1, 2, 3, 4, 5, 6] 组合
['Hi!'] * 4 ['Hi!', 'Hi!', 'Hi!', 'Hi!'] 重复
3 in [1, 2, 3] True 元素是否存在于列表中
for x in [1, 2, 3]: print x, 1 2 3 迭代
"""
#Python列表函数&方法：http://www.runoob.com/python/python-lists.html
"""
Python包含以下函数:
序号 函数
1 cmp(list1, list2) 比较两个列表的元素 注意3.0版本后删除了这个函数
2 len(list) 列表元素个数
3 max(list) 返回列表元素最大值
4 min(list) 返回列表元素最小值
5 list(seq) 将元组转换为列表
Python包含以下方法:
序号 方法
1 list.append(obj) 在列表末尾添加新的对象
2 list.count(obj) 统计某个元素在列表中出现的次数
3 list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
4 list.index(obj) 从列表中找出某个值第一个匹配项的索引位置
5 list.insert(index, obj) 将对象插入列表
6 list.pop(obj=list[-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
7 list.remove(obj) 移除列表中某个值的第一个匹配项
8 list.reverse() 反向列表中元素
9 list.sort([func]) 对原列表进行排序
"""
print('\nPython列表函数&方法')
print ("列表 函数 len：len(list1): ", len(list1))
print ("列表 函数 max：max(list2): ", max(list2))
print ("列表 方法 count：list1.count(1997): ", list1.count(1997))
print ("列表 方法 index：list2.index(2): ", list2.index(2))
# 4.元祖
"""
Python的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号，列表使用方括号。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
如下实例：
"""
print('\n元祖：')
tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
tup3 = "a", "b", "c", "d"
#创建空元组
tupN = ()
#元组中只包含一个元素时，需要在元素后面添加逗号
tupO = (50,)
#元组索引，截取，和字符串和列表一样，
print ("元组 截取操作和字符串、列表一致：tup1[0]: ", tup1[0])
print ("元组 截取操作和字符串、列表一致：tup2[1:4]: ", tup2[1:4])
print ("元组 截取操作和字符串、列表一致：tup2[-0]: ", tup2[-0])
print ("元组 截取操作和字符串、列表一致：tup2[-1]: ", tup2[-1])
#元组访问
print ("元组 访问 tup1[0]: ", tup1[0])
print ("元组 访问 tup2[1:5]: ", tup2[1:5])
#修改元组：元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例:
# 以下修改元组元素操作是非法的。
# tup1[0] = 100;
# 创建一个新的元组
tup3 = tup1 + tup2
print("tup3 = tup1 + tup2：" + str(tup3)) #字符串和数字或其他类型相加，需要通过str的方法转换成字符串的形式
#元祖拆分后分别赋值：
t=('BXY',27,'男')
name,age,gender = t #这样分别给对象按元祖索引赋值，数据和元祖长度必须一致
print("元祖 拆分分别赋值 name：" + name)
print("元祖 拆分分别赋值 age：" + str(age))
print("元祖 拆分分别赋值 gender："+gender)
#删除元组：元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组
tup = ('physics', 'chemistry', 1997, 2000);
print("元组 删除前：")
print(tup)
del tup;
print ("元组 删除后(这里会报defined异常): ")
#print(tup)
#元组运算符：与字符串和列表一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。
"""
Python 表达式 结果 描述
len((1, 2, 3)) 3 计算元素个数
(1, 2, 3) + (4, 5, 6) (1, 2, 3, 4, 5, 6) 连接
['Hi!'] * 4 ['Hi!', 'Hi!', 'Hi!', 'Hi!'] 复制
3 in (1, 2, 3) True 元素是否存在
for x in (1, 2, 3): print x, 1 2 3 迭代
"""
#无关闭分隔符：任意无符号的对象，以逗号隔开，默认为元组
print ('abc', -4.24e93, 18+6.6j, 'xyz')
x, y = 1, 2;
print ("Value of x , y : ", x,y)
#元组内置函数：
"""
1 cmp(tuple1, tuple2) 比较两个元组元素。 3.0版本已取消
2 len(tuple) 计算元组元素个数。
3 max(tuple) 返回元组中元素最大值。
4 min(tuple) 返回元组中元素最小值。
5 tuple(seq) 将列表转换为元组。
"""
# 5.字典
"""
字典是python中惟一的映射类型（哈希表）
类似java中map，键值对对应，键值唯一
值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。
d = {key1 : value1, key2 : value2 }
keys()和values()返回键列表或者值列表
items()返回包含键值对的元祖
创建字典：
使用工厂方法：dict=dict（['x',1],['y',2]）
内建方法：fromkeys(),字典中的元素具有相同的值，默认为None：dict={}.fromkeys(('x','y'),1)
"""
print('\n字典：')
dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
ddict = {}.fromkeys(('x','y'),1)
print("字典 创建字典 工厂方法:",dict)
print("字典 创建字典 内建方法:",ddict)
print ("字典 取值 dict['Age']: ", dict['Age'])
#print ("字典 取值 没有值会报KeyError异常 dict['Alice']: ", dict['Alice'])zz
print ("字典 取值 dict.get('Age'): ", dict.get('Age'))
print ("字典 取值 为空(None) dict.get('Ag1e'): ",dict.get('Ag1e'))
print ("字典 取值 为空时自定义输出 dict.get('Ag1e','hello'): ",dict.get('Ag1e','hello'))
dict['Number'] = 110;
print("字典 新增值后 dict['Number']: ", dict['Number'])
dict['Age'] = 8;
print("字典 修改值后 dict['Age']: ", dict['Age'])
del dict['Name']; # 删除键是'Name'的条目
dict.clear(); # 清空字典所有条目
del dict ; # 删除字典
#字典内置函数&方法：http://www.runoob.com/python/python-dictionary.html
"""
Python字典包含了以下内置函数：
序号 函数及描述
1 cmp(dict1, dict2) 比较两个字典元素。 3.0已取消
2 len(dict),hash(dict) 计算字典元素个数，即键的总数。
3 str(dict) 输出字典可打印的字符串表示。
4 type(variable) 返回输入的变量类型，如果变量是字典就返回字典类型。
Python字典包含了以下内置方法：
序号 函数及描述
1 dict.clear() 删除字典内所有元素
2 dict.copy() 返回一个字典的浅复制
3 dict.fromkeys() 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
4 dict.get(key, default=None) 返回指定键的值，如果值不在字典中返回default值
5 dict.has_key(key) 如果键在字典dict里返回true，否则返回false
6 dict.items() 以列表返回可遍历的(键, 值) 元组数组
7 dict.keys() 以列表返回一个字典所有的键
8 dict.setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
9 dict.update(dict2) 把字典dict2的键/值对更新到dict里，没有Key时新增
10 dict.values() 以列表返回字典中的所有值
11 dict.pop(key, default=None) 同get()，区别是若Key存在，删除并返回dict[key]，若不存在且未指定default值，抛出KeyError异常，类似一个弹出操作
"""
dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
print("字典 内置函数 len(dict): ", len(dict))
print("字典 内置函数 str(dict): ", str(dict))
print("字典 内置方法 dict.get('Name'): ", dict.get('Name'))
print("字典 内置方法 dict.keys(): ", dict.keys())
print("字典 内置方法 dict.values(): ", dict.values())
print("字典 内置方法 dict.items(): ", dict.items())
print("字典 内置方法 dict.pop('Name'): ", dict.pop('Name'))
print("字典 内置方法 dict.get('Name'): ", dict.get('Name'))
# 遍历技巧：在字典中遍历时，关键字和对应的值可以使用 items() 方法同时解读出来：
knights = {'k1': 'v1', 'k2': 'v2'}
for k, v in knights.items():
print(k, v)
#同时遍历两个或更多的序列，可以使用 zip() 组合：
questions = ['q1', 'q1', 'q3']
answers = ['a1', 'a2', 'a3']
explain = ['e1', 'e2', 'e3']
for q, a, e in zip(questions, answers,explain):
print(q, a, e)3.数据结构
#Python3 数据结构
# 1.列表：列表可以修改，而字符串和元组不能。
"""
方法 描述
list.append(x) 把一个元素添加到列表的结尾，相当于 a[len(a):] = [x]。
list.extend(L) 通过添加指定列表的所有元素来扩充列表，相当于 a[len(a):] = L。
list.insert(i, x) 在指定位置插入一个元素。第一个参数是准备插入到其前面的那个元素的索引，例如 a.insert(0, x) 会插入到整个列表之前，而
a.insert(len(a), x) 相当于 a.append(x) 。
list.remove(x) 删除列表中值为 x 的第一个元素。如果没有这样的元素，就会返回一个错误。
list.pop([i]) 从列表的指定位置删除元素，并将其返回。如果没有指定索引，a.pop()返回最后一个元素。元素随即从列表中被删除。（方法中
i 两边的方括号表示这个参数是可选的，而不是要求你输入一对方括号，你会经常在 Python 库参考手册中遇到这样的标记。）
list.clear() 移除列表中的所有项，等于del a[:]。
list.index(x) 返回列表中第一个值为 x 的元素的索引。如果没有匹配的元素就会返回一个错误。
list.count(x) 返回 x 在列表中出现的次数。
list.sort() 对列表中的元素进行排序。
list.reverse() 倒排列表中的元素。
list.copy() 返回列表的浅复制，等于a[:]。
"""
print('数据结构 列表：')
a = [66.25, 333, 333, 1, 1234.5]
print('count：',a.count(333), a.count(66.25), a.count('x'))
a.insert(2, -1),a.append(333);
print('insert，append：',a)
print('index：',a.index(333))
a.remove(333)
print('remove：',a)
a.reverse()
print('reverse：',a)
a.sort()
print('sort：',a)
# 将列表当做堆栈使用：列表方法使得列表可以很方便的作为一个堆栈来使用，堆栈作为特定的数据结构，最先进入的元素最后一个被释放（后进先出）。
# 用 append() 方法可以把一个元素添加到堆栈顶。用不指定索引的 pop() 方法可以把一个元素从堆栈顶释放出来
print('\n列表 堆栈')
stack = [3, 4, 5]
stack.append(6),stack.append(7)
print(stack)
print('pop',stack.pop())
print(stack)
print('pop',stack.pop())
print(stack)
#将列表当作队列使用：也可以把列表当做队列用，只是在队列里第一加入的元素，第一个取出来；但是拿列表用作这样的目的效率不高。在列表的最后添加
# 或者弹出元素速度快，然而在列表里插入或者从头部弹出速度却不快（因为所有其他的元素都得一个一个地移动）。
print('\n列表 队列')
from collections import deque
#Python collections模块实例讲解： http://www.jb51.net/article/48771.htm 比较了下，这个讲的比较好
#deque double-ended queue：双端队列实现了从队列 头部快速增加和取出对象: .popleft(), .appendleft() 。
#list.pop(0)也能实现相关功能，但是时间复杂度是O(n)，deque是O(1)，这点比java强
queue = deque(["BXY1", "BXY2", "BXY3"])
queue.append("BXY4") # Terry arrives
queue.append("BXY5") # Graham arrives
queue.appendleft("BXY6") # BXY arrives
print('queue ：',queue)
print('popleft：',queue.popleft()) # The first to arrive now leaves
print('popleft：',queue.popleft()) # The second to arrive now leaves
print('queue ：',queue)
# 列表推导式：
'''
列表推导式提供了从序列创建列表的简单途径。通常应用程序将一些操作应用于某个序列的每个元素，用其获得的结果作为
生成新列表的元素，或者根据确定的判定条件创建子序列。
每个列表推导式都在 for 之后跟一个表达式，然后有零到多个 for 或 if 子句。返回结果是一个根据表达从其后的 for 和
if 上下文环境中生成出来的列表。如果希望表达式推导出一个元组，就必须使用括号。
'''
print('\n列表推导式：')
vec = [2, 4, 6]
print([x for x in vec])
print([3*x for x in vec])
print([[x, x**2] for x in vec])
#这里我们对序列里每一个元素逐个调用某方法：
freshfruit = [' banana', ' loganberry ', 'passion fruit ']
print([weapon.strip() for weapon in freshfruit])
#我们可以用 if 子句作为过滤器：
print([3*x for x in vec if x > 3])
print([3*x for x in vec if x < 2])
#一些关于循环和其它技巧的演示：
vec1 = [2, 4, 6]
vec2 = [4, 3, -9]
print( range(len(vec1)))
print([x*y for x in vec1 for y in vec2])
print([x+y for x in vec1 for y in vec2])
print([vec1[i]*vec2[i] for i in range(len(vec1))])
#列表推导式可以使用复杂表达式或嵌套函数：
print([str(round(355/113, i)) for i in range(1, 6)])
# 嵌套列表解析：Python的列表还可以嵌套。
print('\n嵌套列表解析：')
'''以下实例展示了3X4的矩阵列表'''
matrix = [
[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12],
]
#将3X4的矩阵列表转换为4X3列表:
print([[row[i] for row in matrix] for i in range(4)])
#也可以写成：
transposed = []
for i in range(4):
transposed.append([row[i] for row in matrix])
print(transposed)
# 或
transposed2 = []
for i in range(4):
transposed_row = []
for row in matrix:
transposed_row.append(row[i])
transposed2.append(transposed_row)
print(transposed2)
# 2.del 语句：使用 del 语句可以从一个列表中依索引而不是值来删除一个元素。这与使用 pop() 返回一个值不同。可以用 del 语句从列表中删除一个切割，或清空整个列表
print('\ndel 语句：')
a = [-1, 1, 66.25, 333, 333, 1234.5]
del a[0]
print(a)
del a[2:4]
print(a)
del a[:]
print(a)
4.运算符
#运算符：
"""
算术运算符
比较（关系）运算符
赋值运算符
逻辑运算符
位运算符
成员运算符
身份运算符
运算符优先级
"""
# 1.算术运算符：a = 10，b = 20
###注意"%"，C(java)是取余运算，Python是取摸运算
"""
运算符 描述 实例
+ 加 - 两个对象相加 a + b 输出结果 30
- 减 - 得到负数或是一个数减去另一个数 a - b 输出结果 -10
* 乘 - 两个数相乘或是返回一个被重复若干次的字符串 a * b 输出结果 200
/ 除 - x除以y b / a 输出结果 2 注意3/2的结果，2.0结果为1，他根据类型匹配，需要写成3.0/2这样才有小数。
% 取模 - 返回除法的余数 b % a 输出结果 0，区别取余和取摸的不同：-1%2=(取余-1，取摸1)，1%-2=(取余1，取摸-1)，
** 幂 - 返回x的y次幂 a**b 为10的20次方， 输出结果 100000000000000000000
// 取整除 - 返回商的整数部分 9//2 输出结果 4 , 9.0//2.0 输出结果 4.0
"""
# 2.比较运算符：a = 10，b = 20
###注意：所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。注意，这些变量名的大写。
'''
运算符 描述 实例
== 等于 - 比较对象是否相等 (a == b) 返回 False。
!= 不等于 - 比较两个对象是否不相等 (a != b) 返回 true.
<> 不等于 - 比较两个对象是否不相等 (a <> b) 返回 true。这个运算符类似 != 。
> 大于 - 返回x是否大于y。 (a > b) 返回 False。
< 小于 - 返回x是否小于y。 (a < b) 返回 true。
>= 大于等于 - 返回x是否大于等于y。 (a >= b) 返回 False。
<= 小于等于 - 返回x是否小于等于y。 (a <= b) 返回 true。
'''
# 3.赋值运算符：
"""
运算符 描述 实例
= 简单的赋值运算符 c = a + b 将 a + b 的运算结果赋值为 c
+= 加法赋值运算符 c += a 等效于 c = c + a
-= 减法赋值运算符 c -= a 等效于 c = c - a
*= 乘法赋值运算符 c *= a 等效于 c = c * a
/= 除法赋值运算符 c /= a 等效于 c = c / a
%= 取模赋值运算符 c %= a 等效于 c = c % a
**= 幂赋值运算符 c **= a 等效于 c = c ** a
//= 取整除赋值运算符 c //= a 等效于 c = c // a
"""
# 4.位运算符：按位运算符是把数字看作二进制来进行计算的， a = 60，b = 13
"""
运算符 描述 实例
& 按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0 (a & b) 输出结果 12 ，二进制解释： 0000 1100
| 按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。 (a | b) 输出结果 61 ，二进制解释： 0011 1101
^ 按位异或运算符：当两对应的二进位相异时，结果为1 (a ^ b) 输出结果 49 ，二进制解释： 0011 0001
~ 按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1 (~a ) 输出结果 -61 ，二进制解释： 1100 0011，
在一个有符号二进制数的补码形式。
<< 左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。 a << 2 输出结果 240 ，二进制解释： 1111 0000
>> 右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数 a >> 2 输出结果 15 ，二进制
"""
# 5.逻辑运算符：a = 10，b = 20
"""
运算符 逻辑表达式 描述 实例
and x and y 布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。 (a and b) 返回 20。
or x or y 布尔"或" - 如果 x 是 True，它返回 True，否则它返回 y 的计算值。 (a or b) 返回 10。
not not x 布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。 not(a and b) 返回 False
"""
a=True
b=20
print('逻辑运算符 a and b a=True',a and b)
print('逻辑运算符 a or b a=True',a or b)
a=False
print('逻辑运算符 a and b a=False',a and b)
print('逻辑运算符 a or b a=False',a or b)
# 6.成员运算符：Python还支持成员运算符,包括字符串，列表或元组。
'''
运算符 描述 实例
in 如果在指定的序列中找到值返回 True，否则返回 False。 x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in 如果在指定的序列中没有找到值返回 True，否则返回 False。 x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。
'''
a = 10
b = 20
list = [1, 2, 3, 4, 5 ];
if ( a in list ):
print ("成员运算符 变量 a 在给定的列表中 list 中")
else:
print ("成员运算符 变量 a 不在给定的列表中 list 中")
if ( b not in list ):
print ("成员运算符 变量 b 不在给定的列表中 list 中")
else:
print ("成员运算符 变量 b 在给定的列表中 list 中")
# 7.身份运算符：用于比较两个对象的存储单元
"""
运算符 描述 实例
is is是判断两个标识符是不是引用自一个对象 x is y, 如果 id(x) 等于 id(y) , is 返回结果 1
is not is not是判断两个标识符是不是引用自不同对象 x is not y, 如果 id(x) 不等于 id(y). is not 返回结果 1
"""
a = 20
b = 20
print('身份运算符 a is b',a is b)
a=2
print('身份运算符 a is b',a is b)
# 运算符优先级：从最高到最低优先级的所有运算符，(括号内优先执行)
"""
运算符 描述
** 指数 (最高优先级)
~ + - 按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
* / % // 乘，除，取模和取整除
+ - 加法减法
>> << 右移，左移运算符
& 位 'AND'
^ | 位运算符
<= < > >= 比较运算符
<> == != 等于运算符
= %= /= //= -= += *= **= 赋值运算符
is is not 身份运算符
in not in 成员运算符
not or and 逻辑运算符
"""
5.流程控制语句
#流程控制语句：
"""
条件语句
循环语句：While循环，for 循环，循环嵌套
break 语句
continue 语句
pass 语句
"""
# 1.条件语句：if ... : elif ... : else
### 注意Python严格要求对齐，if elif else、语句块中每行的空格符数量严格要求，会报IndentationError错误
"""
if 判断条件：
执行语句……
else：
执行语句……
"""
flag = False
name = 'bxy1'
if name == 'python': # 判断变量否为'python'
flag = True # 条件成立时设置标志为真
print ('条件语句 welcome python') # 并输出欢迎信息
elif name == 'bxy ':
print('条件语句 welcome python bxy')
else:
print ('条件语句',name) # 条件不成立时输出变量名称
#python 不支持 switch 语句，多个条件判断，只能用 elif 来实现，如果判断需要多个条件需同时判断时， 可以使用 or （或）和 and （与）
num = 9
if num >= 0 and num <= 10: # 判断值是否在0~10之间
print('条件语句 and ',name,'\n')
# 2.循环语句：Python提供了for循环和while循环（在Python中没有do..while循环）
"""
循环类型 描述
while 循环 在给定的判断条件为 true 时执行循环体，否则退出循环体。
for 循环 重复执行语句
嵌套循环 你可以在while循环体中嵌套for循环
"""
"""
控制语句 描述
break 语句 在语句块执行过程中终止循环，并且跳出整个循环
continue 语句 在语句块执行过程中终止当前循环，跳出该次循环，执行下一次循环。
pass 语句 pass是空语句，是为了保持程序结构的完整性。
"""
# while循环，没有 while do 写法，有 while else 写法，
"""
在 python 中，for … else 表示这样的意思，for 中的语句和普通的没有区别，
else 中的语句会在循环正常执行完（即 for 不是通过 break 跳出而中断的）的情况下执行，while … else 也是一样。
"""
count = 0
while (count < 9):
print ('循环语句 while循环 count:', count)
count = count +1 #没有count ++
else:
print('循环语句 while else循环 count :', count,'\n')
# for循环：一般按照索引迭代，包括字符串和列表等，注意字典 里的元素是无序的（Hash），for else和while else 用法一样
"""
语法： for iterating_var in sequence:
statements(s)
"""
for a in 'baixingyu': #字符串
print ('循环语句 for循环 字符串 :', a)
names = ['baixingyu', 'zhangguangchao', 'fawu','dangzheng','shadouihui']
for name in names: # 列表 对象循环
print ('循环语句 for循环 列表1 :', name)
# range()函数：python 3.0中range函数是一个迭代器，从0开始计数的整数列表，可以截位
for index in range(len(names)): # 列表 索引循环
print ('循环语句 for循环 列表2 :', names[index])
for i in range(5,9) :
print('range()函数',i)
# 也可以指定步长
for i in range(0, 10, 3) :
print('range()函数指定步长 ',i)
for index in range(3,len(names)):
print ('循环语句 for循环 列表3 :', names[index])
else:
print ('循环语句 for循环 完成\n')
# 3.循环嵌套 for for ,while for ,while for for 这样的，用法和java一致，注意可以使用else就行了
# 例子：循环输出2~50之间的素数
i = 2
while(i < 50):
j = 2
while(j <= (i/j)):
if not(i%j): break
j = j + 1
if (j > i/j) : print ('循环嵌套 ', i, " 是素数")
i = i + 1
# 4.break、continue、pass语句，break和continue和java，pass：
# pass：Python pass是空语句，是为了保持程序结构的完整性。pass 不做任何事情，一般用做占位语句。
for letter in 'baixingyu':
if letter == 'i':
pass
print ('pass语句 这是 pass 块')
print ('pass语句 当前字母 :', letter)
# 3.迭代器与生成器
#迭代器：
'''
迭代是Python最强大的功能之一，是访问集合元素的一种方式。。
迭代器是一个可以记住遍历的位置的对象。
迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。
迭代器有两个基本的方法：iter() 和 next()。
'''
#迭代器对象可以使用常规for语句进行遍历：
list=[1,2,3,4]
it = iter(list) # 创建迭代器对象
for x in it:
print ('迭代器iter()：',x)
import sys # 引入 sys 模块
list=[1,2,3,4]
it = iter(list) # 创建迭代器对象
# while True:
# try:
# print ('迭代器next()：',next(it))
# except StopIteration:
# sys.exit()
# 4.生成器：在 Python 中，使用了 yield 的函数被称为生成器（generator）。
'''
跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。
在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回yield的值。并在下一次执行 next()方法时从当前位置继续运行。
'''
import sys
def fibonacci(n): # 生成器函数 - 斐波那契
a, b, counter = 0, 1, 0
while True:
if (counter > n):
return
yield a
a, b = b, a + b
counter += 1
f = fibonacci(10) # f 是一个迭代器，由生成器返回生成
while True:
try:
print (next(f), end=" ")
except StopIteration:
sys.exit()
6.函数
#函数
# 1.定义一个函数：
"""
说明：
函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号起始，并且缩进。
return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
语法：
def functionname( parameters ):
"函数_文档字符串"
function_suite
return [expression]
"""
# 2.函数调用，和java一致
# 3.按值传递参数和按引用传递参数
def changeme(mylist):
"修改传入的列表"
mylist.append([1, 2, 3, 4]);
return mylist;
mylist = [10, 20, 30];
print("函数外取值: ", changeme(mylist))
# 4.参数：和java基本一致，主要是“关键字参数”，
#关键字参数： Python 解释器能够用参数名匹配参数值，这样就允许函数调用时参数的顺序与声明时不一致。
def printinfo(name, age):
"打印任何传入的字符串"
print("关键字参数 Name: ", name)
print("关键字参数 Age ", age);
return;
printinfo(age=50, name="bxy"); #参数名匹配参数值，顺序也不一致
#缺省参数：注意写法。
def printinfo(name, age=35):
"打印任何传入的字符串"
print("缺省参数 Name: ", name)
print("缺省参数 Age ", age);
return;
# 调用printinfo函数
printinfo(age=50, name="bxy1");
printinfo(name="bxy2");
#不定长参数：声明时不会命名参数名
"""
语法：
def functionname([formal_args,] *var_args_tuple ):
"函数_文档字符串"
function_suite
return [expression]
"""
def printinfo(arg1, *vartuple):
"打印任何传入的参数"
print("不定长参数:\n",arg1)
for var in vartuple:
print('不定长参数',var)
return;
printinfo(10);
printinfo(70, 60, 50);
# 5.匿名函数：python 使用 lambda 来创建匿名函数。
"""
说明：
lambda只是一个表达式，函数体比def简单很多。
lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。
虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。
语法：
lambda [arg1 [,arg2,.....argn]]:expression
"""
sum = lambda arg1, arg2: arg1 + arg2;
print("相加后的值为 : ", sum(10, 20))
print("相加后的值为 : ", sum(20, 20))
#return语句：不用定义返回类型
def changeme(mylist):
"修改传入的列表"
mylist.append([1, 2, 3, 4]);
return mylist;
mylist = [10, 20, 30];
print("return语句: ", changeme(mylist))
# 6.变量作用域：全局变量，局部变量。和java 基本一致（命名空间和作用域可以参考 0.模块）
"""
定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。
局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。
"""
total = 0; # 这是一个全局变量
def sum(arg1, arg2):
global total; #加上这个会发现全局变量也被修改了。global已经声明了是全局变量
total = arg1 + arg2; # total在这里是局部变量.
print("函数内是局部变量 : ", total)
return total;
sum(10, 20);
print("函数外是全局变量 : ", total )
7.日期和时间
#日期和时间
"""
Python 程序能用很多方式处理日期和时间，转换日期格式是一个常见的功能。
Python 提供了一个 time 和 calendar 模块可以用于格式化日期和时间。
时间间隔是以秒为单位的浮点小数。
每个时间戳都以自从1970年1月1日午夜（历元）经过了多长时间来表示。
Python 的 time 模块下有很多函数可以转换常见日期格式。如函数time.time()用于获取当前时间戳
"""
# 1.获取当前时间戳，注意Python是以“秒”为单位，java是毫秒，需要引入import time
import time; # 引入time模块
ticks = time.time()
print ("当前时间戳为:", ticks)
# 2.时间元组：很多Python函数用一个元组装起来的9组数字处理时间:
"""
序号 字段 值
0 4位数年 2008
1 月 1 到 12
2 日 1到31
3 小时 0到23
4 分钟 0到59
5 秒 0到61 (60或61 是闰秒)
6 一周的第几日 0到6 (0是周一)
7 一年的第几日 1到366 (儒略历)
8 夏令时 -1, 0, 1, -1是决定是否为夏令时的旗帜
上述也就是struct_time元组。这种结构具有如下属性：
序号 属性 值
0 tm_year 2008
1 tm_mon 1 到 12
2 tm_mday 1 到 31
3 tm_hour 0 到 23
4 tm_min 0 到 59
5 tm_sec 0 到 61 (60或61 是闰秒)
6 tm_wday 0到6 (0是周一)
7 tm_yday 1 到 366(儒略历)
8 tm_isdst -1, 0, 1, -1是决定是否为夏令时的旗帜
"""
# 获取当前时间，localtime()
localtime = time.localtime(time.time())
print ("当前时间 :", localtime)
#获取格式化的时间：asctime()
localtime = time.asctime( time.localtime(time.time()) )
print ("获取格式化的时间 :", localtime)
#格式化时间
print ('格式化时间 ',time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
print ('格式化时间 ',time.strftime("%a %b %d %H:%M:%S %Y", time.localtime()) )
a = "Sat Mar 28 22:24:24 2016"
print ('格式化时间 ',time.mktime(time.strptime(a,"%a %b %d %H:%M:%S %Y")))
"""
python中时间日期格式化符号：
%y 两位数的年份表示（00-99）
%Y 四位数的年份表示（000-9999）
%m 月份（01-12）
%d 月内中的一天（0-31）
%H 24小时制小时数（0-23）
%I 12小时制小时数（01-12）
%M 分钟数（00=59）
%S 秒（00-59）
%a 本地简化星期名称
%A 本地完整星期名称
%b 本地简化的月份名称
%B 本地完整的月份名称
%c 本地相应的日期表示和时间表示
%j 年内的一天（001-366）
%p 本地A.M.或P.M.的等价符
%U 一年中的星期数（00-53）星期天为星期的开始
%w 星期（0-6），星期天为星期的开始
%W 一年中的星期数（00-53）星期一为星期的开始
%x 本地相应的日期表示
%X 本地相应的时间表示
%Z 当前时区的名称
%% %号本身
"""
#日历：Calendar，需要引入import calendar
import calendar
cal = calendar.month(2016, 1)
print ("\n日历 以下输出2016年6月份的日历:",cal)
#Time 内置函数、日历（Calendar）模块、其他相关模块和函数：http://www.runoob.com/python/python-date-time.html
"""
其他相关模块和函数：
datetime模块：https://docs.python.org/3/library/datetime.html#module-datetime
pytz模块：http://www.twinsun.com/tz/tz-link.htm
dateutil模块：http://labix.org/python-dateutil
"""8.文件操作
#文件即IO操作
# 1.打印到屏幕： print() 函数。注意2.0可以直接 print str ，3.0必须print(str)
# 2.读取键盘输入：Python提供了两个内置函数从标准输入读入一行文本
"""
raw_input 3.0版本取消了
input 就这一个了
"""
# str = input("请输入：");
# print ("你输入的内容是: ", str)
# 3.打开和关闭文件：用 file 对象做大部分的文件操作（http://www.runoob.com/python/python-files-io.html）
# open 函数：先用Python内置的open()函数打开一个文件，创建一个file对象，相关的方法才可以调用它进行读写。
"""
语法：
file object = open(file_name [, access_mode][, buffering])
参数的细节：
1.file_name： file_name变量是一个包含了你要访问的文件名称的字符串值。
2.access_mode： access_mode决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。
这个参数是非强制的，默认文件访问模式为只读(r)。
3.buffering: 如果buffering的值被设为0，就不会有寄存。如果buffering的值取1，访问文件时会寄存行。如果将buffering的值设为大于1的整数，
表明了这就是的寄存区的缓冲大小。如果取负值，寄存区的缓冲大小则为系统默认。
不同模式打开文件的完全列表：
模式 描述
r 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
r+ 打开一个文件用于读写。文件指针将会放在文件的开头。
rb+ 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
w 打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
wb 以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
w+ 打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
wb+ 以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
a 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+ 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+ 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。
"""
# 4.File对象的属性：
"""
属性 描述
file.closed 返回true如果文件已被关闭，否则返回false。
file.mode 返回被打开文件的访问模式。
file.name 返回文件的名称。
file.softspace 如果用print输出后，必须跟一个空格符，则返回false。否则返回t
"""
fo = open("6.函数.py", "r")
print ("\nFile对象的属性 文件名: ", fo.name)
print ("File对象的属性 是否已关闭 : ", fo.closed)
print ("File对象的属性 访问模式 : ", fo.mode)
# print ("File对象的属性 末尾是否强制加空格 : ", fo.softspace) #这个属性一般程序员用不着，由程序内部使用。
# close()方法：File 对象的 close（）方法刷新缓冲区里任何还没写入的信息，并关闭该文件，这之后便不能再进行写入。
fo.close()
# 5.读写文件：write()、read()方法，
# 5.1.write()方法：write()方法可将任何字符串写入一个打开的文件。需要重点注意的是，Python字符串可以是二进制数据，而不是仅仅是文字。
"""
fileObject.write(string);
"""
fo_write1 = open("fo_write.txt", "w+") #模式“r”默认文件头操作，文件必须存在，“w”默认文件头操作，没有新建，覆盖源文件，
#“a”是在源文件后追加内容，没有新建，覆盖源文件 seek()函数无效
fo_write1.seek(10) #seek() 方法用于指针定位，注意“a”模式时无效（空操作）
fo_write1.write('__________bxy1_________'); #write() 方法直接写入字符串
fo_write1.writelines(["\nbxy11", "\nbxy111"]); #writelines() 参数是字符串序列，可以是列表、元祖
fo_write1.close();
fo_write2 = open("fo_write.txt", "ab") #“b”是二进制，“a”是追加操作，文件尾
fo_write2.write(bytes('\n__________bxy2_________','utf-8')); #二进制需要使用bytes()内置函数，并指定编码格式
fo_write2.writelines((bytes("\nbxy22",'utf-8'), bytes("\nbxy222",'utf-8')));
fo_write2.close()
# 5.2.read()方法：read（）方法从一个打开的文件中读取一个字符串。需要重点注意的是，Python字符串可以是二进制数据，而不是仅仅是文字。
"""
语法：fileObject.read([count]);
"""
# fo_read = open("6.函数.py", "r+") #这里会报编码错误
fo_read = open("fo_write.txt", "r+",encoding= 'utf-8') #注意制定打开文件编码
str = fo_read.read(50);
print ("读取的字符串是 : ", str)
fo_read.close()
"""
序号 方法 描述
1 file.close() 关闭文件。关闭后文件不能再进行读写操作。
2 file.flush() 刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。
3 file.fileno() 返回一个整型的文件描述符(file descriptor FD 整型), 可以用在如os模块的read方法等一些底层操作上。
4 file.isatty() 如果文件连接到一个终端设备返回 True，否则返回 False。
5 file.next() 返回文件下一行。
6 file.read([size]) 从文件读取指定的字节数，如果未给定或为负则读取所有。
7 file.readline([size]) 读取整行，包括 "\n" 字符。
8 file.readlines([sizehint]) 读取所有行并返回列表，若给定sizeint>0，返回总和大约为sizeint字节的行, 实际读取值可能比sizhint较大, 因为需要填充缓冲区。
9 file.seek(offset[, whence]) 设置文件当前位置
10 file.tell() 返回文件当前位置。
11 file.truncate([size]) 截取文件，截取的字节通过size指定，默认为当前文件位置。
12 file.write(str) 将字符串写入文件，没有返回值。
13 file.writelines(sequence) 向文件写入一个序列字符串列表(元祖)，如果需要换行则要自己加入每行的换行符。
"""9.异常处理
#异常处理
"""
python提供了两个非常重要的功能来处理python程序在运行中出现的异常和错误。
异常处理:
断言(Assertions):
"""
"""
python标准异常：
异常名称 描述
BaseException 所有异常的基类
SystemExit 解释器请求退出
KeyboardInterrupt 用户中断执行(通常是输入^C)
Exception 常规错误的基类
StopIteration 迭代器没有更多的值
GeneratorExit 生成器(generator)发生异常来通知退出
StandardError 所有的内建标准异常的基类
ArithmeticError 所有数值计算错误的基类
FloatingPointError 浮点计算错误
OverflowError 数值运算超出最大限制
ZeroDivisionError 除(或取模)零 (所有数据类型)
AssertionError 断言语句失败
AttributeError 对象没有这个属性
EOFError 没有内建输入,到达EOF 标记
EnvironmentError 操作系统错误的基类
IOError 输入/输出操作失败
OSError 操作系统错误
WindowsError 系统调用失败
ImportError 导入模块/对象失败
LookupError 无效数据查询的基类
IndexError 序列中没有此索引(index)
KeyError 映射中没有这个键
MemoryError 内存溢出错误(对于Python 解释器不是致命的)
NameError 未声明/初始化对象 (没有属性)
UnboundLocalError 访问未初始化的本地变量
ReferenceError 弱引用(Weak reference)试图访问已经垃圾回收了的对象
RuntimeError 一般的运行时错误
NotImplementedError 尚未实现的方法
SyntaxError Python 语法错误
IndentationError 缩进错误
TabError Tab 和空格混用
SystemError 一般的解释器系统错误
TypeError 对类型无效的操作
ValueError 传入无效的参数
UnicodeError Unicode 相关的错误
UnicodeDecodeError Unicode 解码时的错误
UnicodeEncodeError Unicode 编码时错误
UnicodeTranslateError Unicode 转换时错误
Warning 警告的基类
DeprecationWarning 关于被弃用的特征的警告
FutureWarning 关于构造将来语义会有改变的警告
OverflowWarning 旧的关于自动提升为长整型(long)的警告
PendingDeprecationWarning 关于特性将会被废弃的警告
RuntimeWarning 可疑的运行时行为(runtime behavior)的警告
SyntaxWarning 可疑的语法的警告
UserWarning 用户代码生成的警告
"""
# 1.异常处理：注意语法else的逻辑。和java基本类似
"""
捕捉异常可以使用try/except语句。
try/except语句用来检测try语句块中的错误，从而让except语句捕获异常信息并处理。
如果你不想在异常发生时结束你的程序，只需在try里捕获它。
语法：
try....except...else：
try:
<语句> #运行别的代码
except <名字>：
<语句> #如果在try部份引发了'name'异常
except <名字>，<数据>:
<语句> #如果引发了'name'异常，获得附加的数据
else:
<语句> #如果没有异常发生
try的工作原理是，当开始一个try语句后，python就在当前程序的上下文中作标记，这样当异常出现时就可以回到这里，try子句先执行，接下来会发生什么依赖于执行时是否出现异常。
"""
try:
fh = open("testfile.txt", "w")
fh.write("这是一个测试文件，用于测试异常!!")
except IOError:
print ("Error: 没有找到文件或读取文件失败")
else:
print ("内容写入文件成功")
fh.close()
# 使用except可以不带任何异常类型，也可以带多种异常类型：
"""
try:
正常的操作
except:
发生异常，执行这块代码 ------不建议使用，会捕获所有异常
else:
如果没有异常执行这块代码
""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
try:
正常的操作
except(Exception1[, Exception2[,...ExceptionN]]]):
发生以上多个异常中的一个，执行这块代码
else:
如果没有异常执行这块代码
"""
# try-finally 语句：无论是否发生异常都将执行最后的代码。
try:
fh = open("testfile.txt", "r")
try:
fh.write("这是一个测试文件，用于测试异常!!")
finally:
print ("关闭文件")
fh.close()
except IOError:
print ("Error: 没有找到文件或读取文件失败")
# 异常的参数：一个异常可以带上参数，可作为输出的异常信息参数。可以通过except语句来捕获异常的参数，注意3.5版本开始的写法
"""
try:
正常的操作
......................
except ExceptionType, Argument:
你可以在这输出 Argument 的值...
注意：变量接收的异常值通常包含在异常的语句中。在元组的表单中变量可以接收一个或者多个值。元组通常包含错误字符串，错误数字，错误位置。
"""
def temp_convert(var):
try:
return int(var)
# except ValueError, Argument: #3.5之前的写法
except ValueError as Argument: #3.5的写法：异常后面可以接一个类型是instance.args类型的变量，为方便，异常实例使用__str__()类型作为参数类型
print ("参数没有包含数字，异常信息：", Argument)
# 调用函数
temp_convert("bxy");
# 触发异常：使用raise语句自己触发异常，
"""
语法：raise [Exception [, args [, traceback]]]
注意：语句中Exception是异常的类型（例如，NameError）参数是一个异常参数值。该参数是可选的，如果不提供，异常的参数是"None"。
最后一个参数是可选的（在实践中很少使用），跟踪异常对象。
"""
def mye( level ):
if level < 1:
# raise Exception("Invalid level!", level) #python2.0写法
raise Exception("自定义异常名字", level,'值') #python3.0用 raise Exception(args)代替 raise Exception, args语法
# 触发异常后，后面的代码就不会再执行
try:
mye(0) #触发异常
except Exception as e:
print ('触发异常 捕捉自定义异常信息：',e)
else:
print (2)
# 用户自定义异常：
"""
通过创建一个新的异常类，程序可以命名它们自己的异常。异常应该是典型的继承自Exception类，通过直接或间接的方式。
"""
#上面的可以这么使用自定义的异常类，进行处理。（自定义类是网上找的，看不太懂。）
from 学习笔记.基础知识.bxyError import bxyError
def test( level ):
if level < 1:
raise bxyError("bxy")
try:
test(0)
except Exception as e:
print ('触发异常 捕捉自定义异常信息：',e)
else:
print (2)bxyError
class bxyError(RuntimeError):
def __init__(self, arg):
self.args = arg