python特色 这是不同于java的地方
- python是若类型的语言特色。是以数据为中心，无需声明数据类型，上来就把要存储的数据放到内存，然后再去用一个变量名引用这个数据。
- python每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
- python每个变量在内存中创建，都包括变量的标识，名称和数据这些信息。 **创建的时候就自动判断这个数据的标识(类型),引用名,数据.
- python的多个变量赋值 可以这样赋值 a, b, c = 1, 2, “john”
- python删掉数据引用 用del del var1,var2,…
- python中的列表 类型可以不固定 list = [ ‘runoob’, 786 , 2.23, ‘john’, 70.2 ]
- python中的字符串切割、列表、元组切割 规则从左到右索引默认 0 开始，从右到左索引默认 -1 开始，下标可以为空表示取到头或尾
- python中一下划线开头的标识符
- 单下划线开头是 类的保护protected成员变量（从java上来说）只有类对象和子类对象自己能访问到这些变量。
- 双下划线开头是 类的私有private成员变量（从java上来说）意思是只有类对象自己能访问，连子类对象也不能访问到这个数据。
- 双下划线开头和结尾是 类的构造函数（从java上来说）
python最大特色是 不用大括号来控制类 函数的 逻辑判断 用缩进来控制的 缩进的空白数量是可变的，但是所有代码块语句必须包含相同的缩进空白数量，这个必须严格执行。
if True: print "True" else: print "False"print相当于java上的printfln 自动换行 要想不换行需要加逗号
# 不换行输出 print x, print y, # 不换行输出 print x,ypython支持成员运算符
# -*- coding: UTF-8 -*- a = 10 b = 20 list = [1, 2, 3, 4, 5 ]; if ( a in list ): print "1 - 变量 a 在给定的列表中 list 中" else: print "1 - 变量 a 不在给定的列表中 list 中" if ( b not in list ): print "2 - 变量 b 不在给定的列表中 list 中" else: print "2 - 变量 b 在给定的列表中 list 中" # 修改变量 a 的值 a = 2 if ( a in list ): print "3 - 变量 a 在给定的列表中 list 中" else: print "3 - 变量 a 不在给定的列表中 list 中" 1 - 变量 a 不在给定的列表中 list 中 2 - 变量 b 不在给定的列表中 list 中 3 - 变量 a 在给定的列表中 list 中python支持身份运算符 其实就是内存地址 相当于java上的equals比较的是hashcode 所以is和==的不同就跟equals和==的不同 一个是地址 一个是数值
# -*- coding: UTF-8 -*- a = 20 b = 20 if ( a is b ): print "1 - a 和 b 有相同的标识" else: print "1 - a 和 b 没有相同的标识" if ( a is not b ): print "2 - a 和 b 没有相同的标识" else: print "2 - a 和 b 有相同的标识" # 修改变量 b 的值 b = 30 if ( a is b ): print "3 - a 和 b 有相同的标识" else: print "3 - a 和 b 没有相同的标识" if ( a is not b ): print "4 - a 和 b 没有相同的标识" else: print "4 - a 和 b 有相同的标识" 1 - a 和 b 有相同的标识 2 - a 和 b 有相同的标识 3 - a 和 b 没有相同的标识 4 - a 和 b 没有相同的标识- Python不支持单字符类型，单字符也在Python也是作为一个字符串使用。
python基础语法
- python标识符 这个与java相同 标识符由字母、数字、下划线组成，所有标识符可以包括英文、数字以及下划线(_)，但不能以数字开头。标识符是区分大小写的
注:**以下划线开头的标识符是有特殊意义的。
以单下划线开头 _foo 的代表不能直接访问的类属性，需通过类提供的接口进行访问，不能用 from xxx import * 而导入；
以双下划线开头的 __foo 代表类的私有成员；
以双下划线开头和结尾的 foo 代表 Python 里特殊方法专用的标识，如 init() 代表类的构造函数。** - python保留字：
- python的行和缩进 Python 的代码块不使用大括号 {} 来控制类，函数以及其他逻辑判断。python 最具特色的就是用缩进来写模块。
python的多行语句：Python语句中一般以新行作为为语句的结束符。但是我们可以使用斜杠（ \）将一行的语句分为多行显示，如下所示：语句中包含 [], {} 或 () 括号就不需要使用多行连接符
total = item_one + \ item_two + \ item_three days = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']- python的引号：Python 可以使用引号( ’ )、双引号( ” )、三引号( ”’ 或 “”” ) 来表示字符串，引号的开始与结束必须的相同类型的。我习惯按java的来(‘) (“) (“”“) 其中三引号可以多行组成 一般用双引号表示字符串 三引号来多行注释 单引号表示字符
- python的注释 # 表示单行注释 “”” “”” 三引号表示多行注释
- python空行：函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用一行空行分隔，以突出函数入口的开始。空行与代码缩进不同，空行并不是Python语法的一部分。书写时不插入空行，Python解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码，便于日后代码的维护或重构。记住：空行也是程序代码的一部分。
- python同一行显示多条语句 要用分号隔开print 默认输出是换行的，如果要实现不换行需要在变量末尾加上逗号
- python代码组：缩进相同的一组语句构成一个代码块，我们称之代码组。像if、while、def和class这样的复合语句，首行以关键字开始，以冒号( : )结束，该行之后的一行或多行代码构成代码组。我们将首行及后面的代码组称为一个子句(clause)。
- python脚本的第一行：脚本语言的第一行，目的就是指出，你想要你的这个文件中的代码用什么可执行程序去运行它，就这么简单。
“#!/usr/bin/python” : 是告诉操作系统执行这个脚本的时候，调用 /usr/bin 下的 python 解释器；
“#!/usr/bin/env python”(推荐）: 这种用法是为了防止操作系统用户没有将 python 装在默认的 /usr/bin 路径里。当系统看到这一行的时候，首先会到 env 设置里查找 python 的安装路径，再调用对应路径下的解释器程序完成操作。
“#!/usr/bin/python” 相当于写死了python路径;
“#!/usr/bin/env python” 会去环境设置寻找 python 目录,推荐这种写法
python数据类型
- Numbers (数字) int(有符号整型) long(长整型[也可以代表八进制和十六进制]) float(浮点型) complex(复数 实部+虚部组成的复数)
- String (字符串) 注意字符串 也可以乘法运算 字符串的切割是 str = ‘Hello World!’ str[2:5] 第三个到第六个 str[2:] 从第三个到最后
- List (列表) 列表用 [ ] 标识 列表中值的切割也可以用到变量 [头下标:尾下标] 类似java上的list 有序可重复集合
- Tuple (元组) 元组用”()”标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表 类似java上的数组
- Dictionary (字典) 字典用”{ }”标识。字典由索引(key)和它对应的值value组成。 字典是无序的且key键不能重复的 后面会覆盖前面的对象集合 类似于java上的map
数据类型转换内置的几个转换函数如图：
数据类型的判断: 可以通过 type() isinstance() 来查看数据类型
isinstance 和 type 的区别在于： type()不会认为子类是一种父类类型。isinstance()会认为子类是一种父类类型
>>> class A: pass
>>> class B(A): pass
>>> isinstance(A(), A)
True
>>> type(A()) == A
False
>>> isinstance(B(), A)
True
>>> type(B()) == A
False
python运算符
- 算术运算符 +、-、、/、%、、//(加 减 乘 除 取余 幂运算 取整)幂运算 取整java上没有取整 浮点类型的也可以取整9.0//2.0输出结果 4.0*
- 关系运算符 ==、!=、<>、>、<、>=、<=（等于 不等于 不等于 大于 小于 大于等于 小于等于）不等于 <> 可以用这个表示 但是还是用！=表示比较好 因为同java
- 赋值运算符 = += -= = /= %= *= //=(等于 加等于 减等于 乘等于 除等于 取余等于 幂等于 取整等于)
- 位运算符 & | ^ ~ << >> 没有java的带符号的移动
- 逻辑运算符 and or not（与 或 非）不同于java上的 && || ！
- 成员运算符 Python还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。
- 身份运算符 * 身份运算符用于比较两个对象的存储单元 类似于 java上的equlas 比较的是hashcode*
运算符的优先级：最简单的解决方式 不清楚的时候 直接加括号 从最高到最低如下图 ：
python语句
- 条件语句 If else 注意由于 python 并不支持 switch 语句，所以多个条件判断，只能用 elif 来实现，python 复合布尔表达式计算采用短路规则，即如果通过前面的部分已经计算出整个表达式的值，则后面的部分不再计算。同java 、
- 循环语句 while循环 for循环 循环控制语句 break continue ** 不同于java的 是有个pass语句**pass是空语句，是为了保持程序结构的完整性。pass 不做任何事情，一般用做占位语句。
python常见的函数
- 数字（Number）
- 类型转换函数 上面 截图里有介绍 pi 数学常量 pi（圆周率，一般以π来表示） e 数学常量 e，e即自然常数（自然常数
- 数学函数:
- 随机数函数：
- 三角函数：
- 字符串（String）
- 转义字符：
- 字符串运算符：
- 字符串格式化：
- 内建函数：
- 转义字符：
- 列表（List）
- 列表脚本操作符：列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表
- 内建函数和方法：
- 列表脚本操作符：列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表
- 元组（tuples）
- 元组运算符：
- 内置函数：
- 元组运算符：
- 字典（dictionary）
- 内置函数：
- 内置方法：
- 内置函数：
- 日期和时间
提供了一个 time 和 calendar 模块可以用于格式化日期和时间。时间间隔是以秒为单位的浮点小数。每个时间戳都以自从1970年1月1日午夜（历元）经过了多长时间来表示。和java类似
- 时间元组：Python函数用一个元组装起来的9组数字处理时间:
- python中时间日期格式化符号：
- Time模块内置函数：
- Calendar模块内置函数：
- 时间元组：Python函数用一个元组装起来的9组数字处理时间:
python自定义函数
定义函数的简单规则
- 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
- 任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
- 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
- 函数内容以冒号起始，并且缩进。
return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
def functionname( parameters ): "函数_文档字符串" function_suite return [expression]
- 参数传递 区分java上的传址和传值 在python上叫区分传不可变对象和传可变对象
参数类型
- 必备参数 须以正确的顺序传入函数。调用时的数量必须和声明时的一样
关键字参数 关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值
#!/usr/bin/python # -*- coding: UTF-8 -*- #可写函数说明 def printinfo( name, age ): "打印任何传入的字符串" print "Name: ", name; print "Age ", age; return; #调用printinfo函数 printinfo( age=50, name="miki" );默认参数 调用函数时，缺省参数的值如果没有传入，则被认为是默认值。
#!/usr/bin/python # -*- coding: UTF-8 -*- #可写函数说明 def printinfo( name, age = 35 ): "打印任何传入的字符串" print "Name: ", name; print "Age ", age; return; #调用printinfo函数 printinfo( age=50, name="miki" ); printinfo( name="miki" ); Name: miki Age 50 Name: miki Age 35不定长参数 你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述2种参数不同，声明时不会命名。
#!/usr/bin/python # -*- coding: UTF-8 -*- # 可写函数说明 def printinfo( arg1, *vartuple ): "打印任何传入的参数" print "输出: " print arg1 for var in vartuple: print var return; # 调用printinfo 函数 printinfo( 10 ); printinfo( 70, 60, 50 );注： 函数调用的时候写上关键字就可以不用管顺序了 但是不写关键字必须按顺序 传入具体的参数
匿名函数
- python 使用 lambda 来创建匿名函数。
- lambda只是一个表达式，函数体比def简单很多。
- lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
- lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。（同java的匿名函数）
语法 lambda [arg1 [,arg2,…..argn]]:expression
#!/usr/bin/python # -*- coding: UTF-8 -*- # 可写函数说明 sum = lambda arg1, arg2: arg1 + arg2; # 调用sum函数 print "相加后的值为 : ", sum( 10, 20 ) print "相加后的值为 : ", sum( 20, 20 )
变量作用域
- 全局变量 定义在函数外的拥有全局作用域。全局变量可以在整个程序范围内访问。全局变量想作用于函数内，需加 global一个global语句可以同时定义多个变量，如 global x, y, z。
局部变量 定义在函数内部的变量拥有一个局部作用域。局部变量只能在其被声明的函数内部访问。 同java
#!/usr/bin/python # -*- coding: UTF-8 -*- globvar = 0 def set_globvar_to_one(): global globvar # 使用 global 声明全局变量 globvar = 1 def print_globvar(): print(globvar) # 没有使用 global set_globvar_to_one() print globvar # 输出 1 print_globvar() # 输出 1，函数内的 globvar 已经是全局变量
return fun 和 return fun() 的区别
>>> def funx(x): def funy(y): return x * y return funy #return funy返回的是一个对象，可理解为funx是funy的一个对象 >>> funx(7)(8) 56 >>> def funx(x): def funy(y): return x * y return funy() #return funy()返回的是funy的函数返回值，但是这个函数调用是错误的没有传递参数 所以此处报错 >>> funx(7)(8) Traceback (most recent call last): File "<pyshell#5>", line 1, in <module> funx(7)(8) File "<pyshell#4>", line 4, in funx return funy() TypeError: funy() takes exactly 1 argument (0 given) >>> def funx(x): def funy(y): return x * y return funy(8) >>> funx(7) 56
python 模块
- 定义：Python 模块(Module)，是一个 Python 文件，以 .py 结尾，包含了 Python 对象定义和Python语句。
- 之所以使用模块是因为 模块让你能够有逻辑地组织你的 Python 代码段。把相关的代码分配到一个模块里能让你的代码更好用，更易懂。
- 模块能定义函数，类和变量，模块里也能包含可执行的代码。
- import语句 我们可以使用 import 语句来引入模块 但是调用的时候必须 模块名.函数名。
- 一个模块只会被导入一次，不管你执行了多少次import。这样可以防止导入模块被一遍又一遍地执行。想重新导入的时候需要用reload(模块名)
- Python 的 from…import语句让你从模块中导入一个指定的部分到当前命名空间中。语法如下： from modname import name1[, name2[, … nameN]] from… import * 导入的是整个模块
- 当你导入一个模块，Python 解析器对模块位置的搜索顺序是：
- 当前目录
- 如果不在当前目录，Python 则搜索在 shell 变量 PYTHONPATH 下的每个目录。**在 Windows 系统，典型的 PYTHONPATH 如下：set PYTHONPATH=c:\python27\lib;
- 如果都找不到，Python会察看默认路径。UNIX下，默认路径一般为/usr/local/lib/python/。
- 命名空间和作用域
- 命名空间是一个包含了变量名称们（键）和它们各自相应的对象们（值）的字典。 同java
- 一个局部变量和一个全局变量重名，则局部变量会覆盖全局变量。 同java
- 每个函数都有自己的命名空间。类的方法的作用域规则和通常函数的一样。
- 如果要给函数内的全局变量赋值，必须使用 global 语句。
- dir() 函数一个排好序的字符串列表，内容是一个模块里定义过的名字。 可以用这个函数查看某个模块里面的所有函数 dir(math)
globals() 和 locals() 函数
- 根据调用地方的不同，globals() 和 locals() 函数可被用来返回全局和局部命名空间里的名字。
- 如果在函数内部调用 locals()，返回的是所有能在该函数里访问的命名。
- 如果在函数内部调用 globals()，返回的是所有在该函数里能访问的全局名字。
两个函数的返回类型都是字典。所以名字们能用 keys() 函数摘取。
def aa(slef): aaa = 10 print aaa+a # return globals() return locals().get("aaa") print aa(this) #10
- python中的包
- 包是一个分层次的文件目录结构，它定义了一个由模块及子包，和子包下的子包等组成的 Python 的应用环境。
- 包就是文件夹，但该文件夹下必须存在 __init__.py 文件, 该文件的内容可以为空。 （一般就是作为调用该包里的模块 必然会调用这几个初始化文件 作为调用该包摸块前的预处理文件)
- __int__.py用于标识当前文件夹是一个包。
- 往往都是在文件里面定义类 然后为这些类创建包 同java
python I/O
- 打印到屏幕 直接用print
读取键盘上的输入
raw_input raw_input([prompt]) 函数从标准输入读取一个行，并返回一个字符串（去掉结尾的换行符）
#!/usr/bin/python # -*- coding: UTF-8 -*- str = raw_input("请输入：") print "你输入的内容是: ", str 请输入：Hello Python！ 你输入的内容是: Hello Python！input input([prompt]) 函数和 raw_input([prompt]) 函数基本类似，但是 input 可以接收一个Python表达式作为输入，并将运算结果返回。
#!/usr/bin/python # -*- coding: UTF-8 -*- str = input("请输入：") print "你输入的内容是: ", str 请输入：[x*5 for x in range(2,10,2)] 你输入的内容是: [10, 20, 30, 40]
- 打开和关闭文件
- 提供了必要的函数和方法进行默认情况下的文件基本操作。你可以用 file 对象做大部分的文件操作。
- open() 语法 file object = open(file_name [, access_mode][, buffering]) 类似java上的new File(“filename”).createFile 这并是虚拟的 真实的去创建了
- file_name：file_name变量是一个包含了你要访问的文件名称的字符串值。
- access_mode：access_mode决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。
- buffering:如果buffering的值被设为0，就不会有寄存。如果buffering的值取1，访问文件时会寄存行。如果将buffering的值设为大于1的整数，表明了这就是的寄存区的缓冲大小。如果取负值，寄存区的缓冲大小则为系统默认。
- 不同模式打开文件的完全列表：
- File对象的属性
- file.closed 返回true如果文件已被关闭，否则返回false。 是否已关闭
- file.mode 返回被打开文件的访问模式。 访问模式
- file.name 返回文件的名称。 文件名
- file.softspace 如果用print输出后，必须跟一个空格符，则返回false。否则返回true。 末尾是否强制加空格我
- file.write(“xxx”) write()方法可将任何字符串写入一个打开的文件。需要重点注意的是，Python字符串可以是二进制数据，而不是仅仅是文字。write()方法不会在字符串的结尾添加换行符(‘\n’)
- file.read(count) read（）方法从一个打开的文件中读取一个字符串。需要重点注意的是，Python字符串可以是二进制数据，而不是仅仅是文字。被传递的参数是要从已打开文件中读取的字节计数。该方法从文件的开头开始读入，如果没有传入count，它会尝试尽可能多地读取更多的内容，很可能是直到文件的末尾。
- file.tell()方法告诉你文件内的当前位置, 换句话说，下一次的读写会发生在文件开头这么多字节之后。
- file.seek（offset [,from]）方法改变当前文件的位置。Offset变量表示要移动的字节数。From变量指定开始移动字节的参考位置。
如果from被设为0，这意味着将文件的开头作为移动字节的参考位置。如果设为1，则使用当前的位置作为参考位置。如果它被设为2，那么该文件的末尾将作为参考位置。 - file.truncate([size])截取文件，截取的字节通过size指定，默认为当前文件位置。
- file.writelines(sequence)向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符。
- file.readlines([sizehint])读取所有行并返回列表，若给定sizeint>0，则是设置一次读多少字节，这是为了减轻读取压力。
- file.readline([size]) 读取整行，包括 “\n” 字符。
- file.isatty()如果文件连接到一个终端设备返回 True，否则返回 False。
- file.next()返回文件下一行。
- file.flush()刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。
- file.fileno()返回一个整型的文件描述符(file descriptor FD 整型), 可以用在如os模块的read方法等一些底层操作上。
- os.rename(current_file_name, new_file_name) os模块 重命名
- os.remove(file_name) 需要提供要删除的文件名作为参数。
- os.mkdir(“newdir”) 创建文件目录
- os.chdir(“newdir”) 改变当前的目录。chdir()方法需要的一个参数是你想设成当前目录的目录名称。
- os.rmdir(‘dirname’) rmdir()方法删除目录，目录名称以参数传递。在删除这个目录之前，它的所有内容应该先被清除。
python 异常
- 在Python无法正常处理程序时就会发生一个异常。异常是Python对象，表示一个错误。 不同于java上的Error 对象(jvm 出现的问题)
捕捉异常可以使用try/except语句。 不同于java上的 try catch
try: <语句> #运行别的代码 except <名字>： <语句> #如果在try部份引发了'name'异常 except <名字>，<数据>: <语句> #如果引发了'name'异常，获得附加的数据 else: <语句> #如果没有异常发生try的工作原理是：* 同java 无非是没有else*
- 如果当try后的语句执行时发生异常，python就跳回到try并执行第一个匹配该异常的except子句，异常处理完毕，控制流就通过整个try语句（除非在处理异常时又引发新的异常）。
- 如果在try后的语句里发生了异常，却没有匹配的except子句，异常将被递交到上层的try，或者到程序的最上层（这样将结束程序，并打印缺省的出错信息）。
- 如果在try子句执行时没有发生异常，python将执行else语句后的语句（如果有else的话），然后控制流通过整个try语句。
- try-finally 语句无论是否发生异常都将执行最后的代码。
带参数的异常
try: 正常的操作 ...................... except ExceptionType, Argument: 你可以在这输出 Argument 的值...触发异常
- 我们可以使用raise语句自己触发异常
raise [Exception [, args [, traceback]]]
- 语句中Exception是异常的类型（例如，NameError）参数是一个异常参数值。该参数是可选的，如果不提供，异常的参数是”None”。
- 最后一个参数是可选的（在实践中很少使用），如果存在，是跟踪异常对象。
注意：为了能够捕获异常，”except”语句必须有用相同的异常来抛出类对象或者字符串。
#!/usr/bin/python # -*- coding: UTF-8 -*- # 定义函数 def mye( level ): if level < 1: raise Exception("Invalid level!", level) # 触发异常后，后面的代码就不会再执行 try: mye(0) // 触发异常 except "Invalid level!": print 1 else: print 2 $ python test.py Traceback (most recent call last): File "test.py", line 11, in <module> mye(0) File "test.py", line 7, in mye raise Exception("Invalid level!", level) Exception: ('Invalid level!', 0)
用户自定义异常
通过创建一个新的异常类，程序可以命名它们自己的异常。异常应该是典型的继承自Exception类，通过直接或间接的方式。
class Networkerror(RuntimeError): def __init__(self, arg): self.args = arg try: raise Networkerror("Bad hostname") except Networkerror,e: print e.args- 异常列表
