Python学习基础系列----了解python

最新推荐文章于 2024-08-16 15:24:13 发布

楠洋0

最新推荐文章于 2024-08-16 15:24:13 发布

阅读量1.2k

点赞数 2

分类专栏： Python 文章标签： Python基础学习

Python 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

了解python

1. 了解Python
Python是一种解释型（这意味着开发过程中没有了编译这个环节）、面向对象（支持面向对象的风格或代码封装在对象的编程技术）、动态数据类型的交互式（可在命令行中通过Python提示符及直接代码执行程序）高级程序设计语言。

2. Python标识符
标识符由字母、数字、下划线组成，但不能以数字开头，且区分大小写。

以下划线开头的标识符是有特殊意义的。以单下划线开头 _foo 的代表不能直接访问的类属性，需通过类提供的接口进行访问，不能用 from xxximport * 而导入；

以双下划线开头的 __foo 代表类的私有成员；以双下划线开头和结尾的 __foo__ 代表 Python 里特殊方法专用的标识，如__init__() 代表类的构造函数。

Python 可以同一行显示多条语句，方法是用分号 ; 分开。

3. Python中的保留字符
这些保留字不能用作常数或变数，或任何其他标识符名称。所有 Python的关键字只包含小写字母。

and

exec

not

assert

finally

break

for

pass

class

from

continue

global

raise

def

return

del

import

try

elif

while

else

with

except

lambda

yield

4. Python的缩进与多行语句写法
4.1 Python中的缩进要求非常严格，必须严格对齐。因为Python的代码块不由{}控制，而是由缩进就可以控制。

4.2 使用斜杠（ \）将一行的语句分为多行显示，如下所示：当然，使用各类括号括起语句之后不需要斜杠换行。

total = item_one + \

item_two + \

item_three

英文三个双引号用在等式中也可以写多行文本，直接使用和三个单引号作用一样，可以做多行注释。

5. Python中的不换行与换行输出
# 换行输出

print(x)

# 不换行输出

print(x,end='')

Python变量类型

创建变量就意味着会在内存中开辟空间，同时变量必须赋值才会被创建。

1. Python中的变量赋值
单变量赋值：

counter = 100#赋值整型变量

miles = 1000.0#浮点型

name = "John"#字符串

多变量赋值：

a = b = c= 1 #三个变量的值都为1

a, b, c =1, 2, "john" #分别为三个变量赋值

2. Python中的数据类型
Python有五个标准的数据类型：

1. Numbers（数字）
1）不可改变的数据类型：
当其类型被改变时，将会赋值给一个新的对象。当对变量赋予了数值后，这个对象就会被创建，可通过del语句删除对这些对象的引用。

2）Python支持的数字类型：
int（有符号整型，如0x69，10）；long（长整型[也可以代表八进制和十六进制]，如-4721885298529L，Python用数字后面的L表示长整型）；float（浮点型，如70.2E-12）；complex（复数，如4.53e-7j）。

3）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 转换为一个列表
chr(x )           将一个整数转换为一个字符
unichr(x )         将一个整数转换为Unicode字符
ord(x )           将一个字符转换为它的整数值
hex(x )           将一个整数转换为一个十六进制字符串
oct(x )           将一个整数转换为一个八进制字符串
4）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的平方根

5）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]范围内。

6） Python三角函数
函数

描述

acos(x)

返回x的反余弦弧度值。

asin(x)

返回x的反正弦弧度值。

atan(x)

返回x的反正切弧度值。

atan2(y, x)

返回给定的 X 及 Y 坐标值的反正切值。

cos(x)

返回x的弧度的余弦值。

hypot(x, y)

返回欧几里德范数 sqrt(x*x + y*y)。

sin(x)

返回的x弧度的正弦值。

tan(x)

返回x弧度的正切值。

degrees(x)

将弧度转换为角度,如degrees(math.pi/2) ，返回90.0

radians(x)

将角度转换为弧度

7） Python数学常量
常量

描述

数学常量 pi（圆周率，一般以π来表示）

数学常量 e，e即自然常数（自然常数）。

2. String（字符串）
由数字、字母、下划线组成。

1）字符串截取
Python字符串从左至右截取：索引范围（0，长度-1），从右至左截取（-1，字符串开头）。

2） Python中不存在单字符
Python中即使有单字符，也会被当作字符串处理。

3） Python转义字符
转义字符

描述

出现在行尾时表现为续行符，出现在行中时，用于“翻译”特殊字符表示特殊含义，如下面选项所示

反斜杠符号

单引号

双引号

响铃

退格(Backspace)

转义

\000

空

换行

纵向制表符

横向制表符

回车

换页

\oyy

八进制数，yy代表的字符，例如：\o12代表换行

\xyy

十六进制数，yy代表的字符，例如：\x0a代表换行

\other

其它的字符以普通格式输出

4） Python字符串运算
下表实例变量 a 值为字符串 "Hello"，b 变量值为 "Python"：

操作符

描述

字符串连接。

重复输出字符串。

[]

通过索引获取字符串中字符

[ : ]

截取字符串中的一部分

成员运算符 - 如果字符串中包含给定的字符返回 True

not in

成员运算符 - 如果字符串中不包含给定的字符返回 True

r/R

原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。原始字符串除在字符串的第一个引号前加上字母"r"（可以大小写）以外，与普通字符串有着几乎完全相同的语法。

a='hello'
b='world'
print(a+b) #helloworld，+号连接字符串
print(a*2) #hellohello，*号重复字符串
print(a[1]) #e，[]索引字符
print(a[1:4]) #ell，[:]截取字符串
print("h" in a) #True，in是否包含
print("M" not in a) #True，not in是否不包含
print(r'\n') #\n，r原始字符串（不解析转义字符）

5）       Python字符串格式化（方便print时定义类型，如C语言中printf字符串时在引号内写%s一样）
    print("My name is %s and weight is %d kg!" % ('Zara', 21) )
输出：
    My name is Zara and weight is 21 kg!
    符  号

描述

格式化字符及其ASCII码

格式化字符串

格式化整数

格式化无符号整型

格式化无符号八进制数

格式化无符号十六进制数

格式化无符号十六进制数（大写）

格式化浮点数字，可指定小数点后的精度

用科学计数法格式化浮点数

作用同%e，用科学计数法格式化浮点数

%f和%e的简写

%f 和 %E的简写

用十六进制数格式化变量的地址

6）使用三引号输出一大串带特殊字符的字符串
当使用三引号将字符串框起来时，就不需要再通过转义字符打很多换行符等符号了，可以直接打换行。对比如下：

>>> hi = '''hi

there'''

>>> hi = 'hi\nthere'

这两种输出的结果都是换行的字符串，但是使用单引号时，当转义字符很多时，会很痛苦。

9） String可使用的内建函数
方法

描述

string.capitalize()

把字符串的第一个字符大写

string.center(width)

返回一个原字符串居中,并使用空格填充至长度 width 的新字符串

string.count(str, beg=0, end=len(string))

返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数

string.decode(encoding='UTF-8', errors='strict')

以 encoding 指定的编码格式解码 string，如果出错默认报一个 ValueError 的异常，除非 errors 指定的是 'ignore' 或者'replace'

string.encode(encoding='UTF-8', errors='strict')

以 encoding 指定的编码格式编码 string，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace'

string.endswith(obj, beg=0, end=len(string))

检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.

string.expandtabs(tabsize=8)

把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8。

string.find(str, beg=0, end=len(string))

检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1

string.format()

格式化字符串

string.index(str, beg=0, end=len(string))

跟find()方法一样，只不过如果str不在 string中会报一个异常.

string.isalnum()

如果 string 至少有一个字符并且所有字符都是字母或数字则返

回 True,否则返回 False

string.isalpha()

如果 string 至少有一个字符并且所有字符都是字母则返回 True,

否则返回 False

string.isdecimal()

如果 string 只包含十进制数字则返回 True 否则返回 False.

string.isdigit()

如果 string 只包含数字则返回 True 否则返回 False.

string.islower()

如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False

string.isnumeric()

如果 string 中只包含数字字符，则返回 True，否则返回 False

string.isspace()

如果 string 中只包含空格，则返回 True，否则返回 False.

string.istitle()

如果 string 是标题化的(见 title())则返回 True，否则返回 False

string.isupper()

如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False

string.join(seq)

以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串

string.ljust(width)

返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串

string.lower()

转换 string 中所有大写字符为小写.

string.lstrip()

截掉 string 左边的空格

string.maketrans(intab, outtab])

maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。

max(str)

返回字符串 str 中最大的字母。

min(str)

返回字符串 str 中最小的字母。

string.partition(str)

有点像 find()和 split()的结合体,从 str 出现的第一个位置起,把字符串 string 分成一个 3 元素的元组 (string_pre_str,str,string_post_str),如果 string 中不包含str 则 string_pre_str == string.

string.replace(str1, str2, num=string.count(str1))

把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次.

string.rfind(str, beg=0,end=len(string) )

类似于 find()函数，不过是从右边开始查找.

string.rindex( str, beg=0,end=len(string))

类似于 index()，不过是从右边开始.

string.rjust(width)

返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串

string.rpartition(str)

类似于 partition()函数,不过是从右边开始查找.

string.rstrip()

删除 string 字符串末尾的空格.

string.split(str="", num=string.count(str))

以 str 为分隔符切片 string，如果 num有指定值，则仅分隔 num 个子字符串

string.splitlines([keepends])

按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。

string.startswith(obj, beg=0,end=len(string))

检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查.

string.strip([obj])

在 string 上执行 lstrip()和 rstrip()

string.swapcase()

翻转 string 中的大小写

string.title()

返回"标题化"的 string,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())

string.translate(str, del="")

根据 str 给出的表(包含 256 个字符)转换 string 的字符,

要过滤掉的字符放到 del 参数中

string.upper()

转换 string 中的小写字母为大写

string.zfill(width)

返回长度为 width 的字符串，原字符串 string 右对齐，前面填充0

string.isdecimal()

isdecimal()方法检查字符串是否只包含十进制字符。这种方法只存在于unicode对象。

3. List（列表）
使用非常频繁，支持数字、字符、字符串甚至列表的集合结构。

1）增加或删除列表元素
直接重新赋值给根据索引值取出的值，或通过append（）函数来添加。

通过del 语句删除列表项，如：dellist1[2]

2）列表的脚本操作符
和对字符串的操作类似。

Python 表达式

结果

描述

len([1, 2, 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

迭代

3）列表的截取
Python 表达式

结果

描述

L[2]

'Taobao'

读取列表中第三个元素

L[-2]

'Runoob'

读取列表中倒数第二个元素

L[1:]

['Runoob', 'Taobao']

从第二个元素开始截取列表

4） Python中列表的函数及方法
Python包含以下函数:

函数

描述

cmp(list1, list2)
比较两个列表的元素

len(list)

列表元素个数

max(list)

返回列表元素最大值

min(list)

返回列表元素最小值

list(seq)

将元组转换为列表

Python包含以下方法:

函数

描述

list.append(obj)

在列表末尾添加新的对象

list.count(obj)

统计某个元素在列表中出现的次数

list.extend(seq)

在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）

list.index(obj)

从列表中找出某个值第一个匹配项的索引位置

list.insert(index, obj)

将对象插入列表

list.pop(obj=list[-1])

移除列表中的一个元素（默认最后一个元素），并且返回该元素的值

list.remove(obj)

移除列表中某个值的第一个匹配项

list.reverse()

反向列表中元素

list.sort([func])

对原列表进行排序

4. Tuple（元组）
1）与列表的区别
类似列表，但列表用[ ]标识，元组用()标识，并且列表元素可二次赋值，但元组元素不能。

2）元组的创建
创建空元组：tuple（）。

创建只有一个元素的元组：tuple（a，），必须要在元素后加逗号。

3）元素的访问
虽然创建时用（）包含，但是在访问单个元素时，与列表一样，通过[ 索引号 ]来访问。

4）删除元组
元组中的单个元素不能被删除，但是元组可以通过del语句整个删除。

5）元组运算符（同列表）

6）任意无符号的对象，以逗号隔开，默认为元组（无关闭分隔符）
7）元组内置函数
函数

描述

cmp(tuple1, tuple2)
比较两个元组元素。

len(tuple)
计算元组元素个数。

max(tuple)
返回元组中元素最大值。

min(tuple)
返回元组中元素最小值。

tuple(seq)
将列表转换为元组。

5. Dictionary（字典）
1）与列表的差别
列表是有序的对象集合，字典是无序的对象结合。字典中的元素通过Key来获取，而列表中的元素通过位移来获取。

2）字典的定义
下面是两种定义字典的方法，两种方法都与列表的定义方法类似。

dict = {}

dict['one'] ="This is one"

dict[2] ="This is two"

tinydict = {'name':'john','code':6734,'dept':'sales'}

3）数据类型的转换
函数

描述

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)

将一个整数转换为一个八进制字符串

Python运算符
Python支持以下八种运算符：

1. 算数运算符
假设a=10，b=20

运算符

描述

实例

加 - 两个对象相加

a + b 输出结果 30

减 - 得到负数或是一个数减去另一个数

a - b 输出结果 -10

乘 - 两个数相乘或是返回一个被重复若干次的字符串

a * b 输出结果 200

除 - x除以y

b / a 输出结果 2（整数除整数，只能得整数，要求小数需要将其中一个改为浮点数）

取模 - 返回除法的余数

b % a 输出结果 0

幂 - 返回x的y次幂

a**b 为10的20次方，输出结果 100000000000000000000

取整除 - 返回商的整数部分

9//2 输出结果 4 , 9.0//2.0输出结果 4.0

2. 比较运算符
运算符

描述

实例

等于 - 比较对象是否相等

(a == b) 返回 False。

不等于 - 比较两个对象是否不相等

(a != b) 返回 true.

不等于 - 比较两个对象是否不相等

(a <> b) 返回 true。这个运算符类似 != 。

大于 - 返回x是否大于y

(a > b) 返回 False。

小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。注意，这些变量名的大写。

(a < b) 返回 true。

大于等于 - 返回x是否大于等于y。

(a >= b) 返回 False。

小于等于 - 返回x是否小于等于y。

(a <= b) 返回 true。

3. Python赋值运算符
运算符

描述

实例

简单的赋值运算符

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. Python位运算符
按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如下：

运算符

描述

实例

按位与运算符：参与运算的两个值,如果两个相应位都为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 。~x 类似于 -x-1

(~a ) 输出结果 -61，二进制解释： 1100 0011，在一个有符号二进制数的补码形式。

左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。

a << 2 输出结果 240，二进制解释： 1111 0000

右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数

a >> 2 输出结果 15，二进制解释： 0000 1111

5. Python逻辑运算符
运算符

逻辑表达式

描述

实例

and

x and y

布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。

(a and b) 返回 20。

x or y

布尔"或" - 如果 x 是非 0，它返回 x 的值，否则它返回 y 的计算值。

(a or b) 返回 10。

not

not x

布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。

not(a and b) 返回 False

6. Python成员运算符
运算符

描述

实例

如果在指定的序列中找到值返回 True，否则返回 False。

x 在 y序列中 , 如果 x 在 y 序列中返回 True。

not in

如果在指定的序列中没有找到值返回 True，否则返回 False。

x 不在 y序列中 , 如果 x 不在 y 序列中返回 True。

7. Python身份运算符（判断引用的对象）
1） is与==的区别
==判断两者是否完全相等，而is判断两个对象引用的对象是否是同一个。

运算符

描述

实例

is 是判断两个标识符是不是引用自一个对象

x is y,类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False

is not

is not 是判断两个标识符是不是引用自不同对象

x is not y ，类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。

8. Python运算符优先级
运算符

描述

指数 (最高优先级)

~ + -

按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)

* / % //

乘，除，取模和取整除

+ -

加法减法

>> <<

右移，左移运算符

位 'AND'

^ |

位运算符

<= < > >=

比较运算符

<> == !=

等于运算符

= %= /= //= -= += *= **=

赋值运算符

is is not

身份运算符

in not in

成员运算符

not or and

逻辑运算符

Python语句
1. 条件语句
Python不支持switch语句，因此判断结果对应多种执行方式时，只能用elif来做。

num = 5
if num ==3: #判断num的值
print('boss')
elif num ==2:
print('user')
elif num ==1:
print('worker')
2. 循环语句

Python中没有do while循环。

循环类型

描述

while循环

在给定的判断条件为 true 时执行循环体，否则退出循环体。

for循环

重复执行语句

嵌套循环

你可以在while循环体中嵌套for循环（for中也可以嵌套for吧）

循环控制语句：

控制语句

描述

break语句

在语句块执行过程中终止循环，并且跳出整个循环

continue语句

在语句块执行过程中终止当前循环，跳出该次循环，执行下一次循环。

pass语句

pass是空语句，是为了保持程序结构的完整性。

1）pass语句在函数中的作用
当你在编写一个程序时，执行语句部分思路还没有完成，这时你可以用pass语句来占位，也可以当做是一个标记，是要过后来完成的代码。比如下面这样：

def iplaypython():
pass
定义一个函数iplaypython，但函数体部分暂时还没有完成，又不能空着不写内容，因此可以用pass来替代占个位置。
2）pass语句在循环中的作用
pass也常用于为复合语句编写一个空的主体，比如说你想一个while语句的无限循环，每次迭代时不需要任何操作，你可以这样写：

while True:
pass
以上只是举个例子，现实中最好不要写这样的代码，因为执行代码块为pass也就是空什么也不做，这时python会进入死循环。
3）pass语句用法总结
1、空语句，什么也不做
2、在特别的时候用来保证格式或是语义的完整性

4）While循环（可在循环中使用else语句）
# continue 和 break用法

i=1
while i<10:
i+= 1
if i%2>0: # 非双数时跳过输出
continue
print(i) # 输出双数2、4、6、8、10

i = 1
while 1: # 循环条件为1必定成立
print(i) # 输出1~10
i+= 1
if i>10: # 当i大于10时跳出循环
break
在循环中使用else语句，即当条件不满足之后，结束循环，执行else语句

count = 0
while count <5:
print(count," is less than 5")
count = count +1
else:
print(count," is not less than 5")
5）for循环（可在循环中使用else语句）
可以通过直接取值迭代，也可以通过序列索引迭代

取值迭代：

for letter in 'Python': # 逐个输出字符串中的字符
print('当前字母 :', letter)

fruits = ['banana', 'apple', 'mango']
for fruit in fruits: # 逐个输出列表中的元素
print('当前水果 :', fruit)
print("Good bye!")

索引迭代：

fruits = ['banana','apple','mango']
#通过len（）函数获得列表的长度，通过range（）函数获得了一个值不超过长度-1的索引序列
for index in range(len(fruits)):
print('当前水果 :',fruits[index])
print("Good bye!")

Python日期和时间
Python是以时间戳来记录时间的，也就是当前时间距离1970年1月1日过去了多少秒，因此获取时间的方法一般是先获取时间戳，再将时间戳转换为时间元组，再将时间元组转换为不同格式的时间数据。

1.获取时间戳
import time; #引入time模块

ticks = time.time()

2.获取时间
什么是时间元组？

很多Python函数用一个元组装起来的9组数字处理时间，也就是struct_time元组：

属性

字段

值

tm_year
4位数年

2008

tm_mon
月

1 到 12

tm_mday
日

1到31

tm_hour
小时

0到23

tm_min
分钟

0到59

tm_sec
秒

0到61 (60或61 是闰秒)

tm_wday
一周的第几日

0到6 (0是周一)

tm_yday
一年的第几日

1到366 (儒略历)

tm_isdst
夏令时

-1, 0, 1, -1是决定是否为夏令时的旗帜

代码接上，将获取的时间戳转换为时间元组：

localtime = time.localtime(time.time())

print("本地时间为 :", localtime)

3.获取格式化的时间
localtime = time.asctime( time.localtime(time.time()))

print("本地时间为 :", localtime)

4.获取更多格式的格式化时间
time.strftime(format[, t]) #总的代码形式

# 格式化成2016-03-20 11:45:39形式

print(time.strftime("%Y-%m-%d%H:%M:%S", time.localtime()))

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当前时区的名称

· %% %号本身

5.获取某个月的日历
import calendar

cal = calendar.month(2016,1)

6.Time和Calendar模块的函数及属性
函数

描述

time.altzone
返回格林威治西部的夏令时地区的偏移秒数。如果该地区在格林威治东部会返回负值（如西欧，包括英国）。对夏令时启用地区才能使用。

time.asctime([tupletime])
接受时间元组并返回一个可读的形式为"Tue Dec 11 18:07:14 2008"（2008年12月11日周二18时07分14秒）的24个字符的字符串。

time.clock( )
用以浮点数计算的秒数返回当前的CPU时间。用来衡量不同程序的耗时，比time.time()更有用。

time.ctime([secs])
作用相当于asctime(localtime(secs))，未给参数相当于asctime()

time.gmtime([secs])
接收时间辍（1970纪元后经过的浮点秒数）并返回格林威治天文时间下的时间元组t。注：t.tm_isdst始终为0

time.localtime([secs])
接收时间辍（1970纪元后经过的浮点秒数）并返回当地时间下的时间元组t（t.tm_isdst可取0或1，取决于当地当时是不是夏令时）。

time.mktime(tupletime)
接受时间元组并返回时间辍（1970纪元后经过的浮点秒数）。

time.sleep(secs)
推迟调用线程的运行，secs指秒数。

time.strftime(fmt[,tupletime])
接收以时间元组，并返回以可读字符串表示的当地时间，格式由fmt决定。

time.strptime(str,fmt='%a %b %d %H:%M:%S %Y')
根据fmt的格式把一个时间字符串解析为时间元组。

time.time( )
返回当前时间的时间戳（1970纪元后经过的浮点秒数）。

time.tzset()
根据环境变量TZ重新初始化时间相关设置

Time模块包含了以下2个非常重要的属性：

属性

描述

time.timezone
属性time.timezone是当地时区（未启动夏令时）距离格林威治的偏移秒数（>0，美洲;<=0大部分欧洲，亚洲，非洲）。

time.tzname
属性time.tzname包含一对根据情况的不同而不同的字符串，分别是带夏令时的本地时区名称，和不带的。

函数

描述

calendar.calendar(year,w=2,l=1,c=6)
返回一个多行字符串格式的year年年历，3个月一行，间隔距离为c。每日宽度间隔为w字符。每行长度为21* W+18+2* C。l是每星期行数。

calendar.firstweekday( )
返回当前每周起始日期的设置。默认情况下，首次载入caendar模块时返回0，即星期一。

calendar.isleap(year)
是闰年返回True，否则为false。

calendar.leapdays(y1,y2)
返回在Y1，Y2两年之间的闰年总数。

calendar.month(year,month,w=2,l=1)
返回一个多行字符串格式的year年month月日历，两行标题，一周一行。每日宽度间隔为w字符。每行的长度为7* w+6。l是每星期的行数。

calendar.monthcalendar(year,month)
返回一个整数的单层嵌套列表。每个子列表装载代表一个星期的整数。Year年month月外的日期都设为0;范围内的日子都由该月第几日表示，从1开始。

calendar.monthrange(year,month)
返回两个整数。第一个是该月的星期几的日期码，第二个是该月的日期码。日从0（星期一）到6（星期日）;月从1到12。

calendar.prcal(year,w=2,l=1,c=6)
相当于 print calendar.calendar(year,w,l,c).

calendar.prmonth(year,month,w=2,l=1)
相当于 print calendar.calendar（year，w，l，c）。

calendar.setfirstweekday(weekday)
设置每周的起始日期码。0（星期一）到6（星期日）。

calendar.timegm(tupletime)
和time.gmtime相反：接受一个时间元组形式，返回该时刻的时间辍（1970纪元后经过的浮点秒数）。

calendar.weekday(year,month,day)
返回给定日期的日期码。0（星期一）到6（星期日）。月份为 1（一月）到 12（12月）。

7.其他可以处理时间的模块
· datetime模块

· pytz模块

· dateutil模块

Python函数

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

函数能提高应用的模块性，和代码的重复利用率。

1.Python函数定义
def functionname(parameters):

"函数_文档字符串"

function_suite

return [expression]

2.对象创建
在 python 中，类型属于对象，变量是没有类型的：

a=[1,2,3] #赋值后这个对象就已经创建好了

a="Runoob"

以上代码中，[1,2,3] 是 List 类型，"Runoob" 是 String 类型，而变量 a 是没有类型，她仅仅是一个对象的引用（一个指针），可以是 List 类型对象，也可以指向 String 类型对象。

3.可更改对象和不可更改对象
在 python 中，strings,tuples, 和 numbers 是不可更改（重新赋值后，原值不再存在）的对象，而 list,dict等则是可以修改（重新赋值后，原来的值依旧存在，依旧可以获取到）的对象。

· 不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。

· 可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

4.可更改对象和不可更改对象的参数传递
python函数的参数传递：

不可变类型：类似 c++的值传递，如整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a本身。

def ChangeInt(a):
a = 10

b = 2
ChangeInt(b)
print(b) #结果是 2

int2对象指向变量b，而调用changeInt函数时，变量a就是变量b，此时的变量a和变量b都对应int 2对象，但是在之后a被重新赋值为10，此时变量a指向对象int 10，产生了一个新的int型对象，而变量b所指向的对象不变。

可变类型：类似 c++的引用传递，如列表，字典。如 fun（la），则是将 la真正的传过去，修改后fun外部的la也会受影响

python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

def changeme( mylist):
mylist.append([1,2,3,4]);  #"修改传入的列表"
    print("函数内取值: ", mylist)
    return

# 调用changeme函数
mylist = [10,20,30];
changeme(mylist);
print("函数外取值: ", mylist)

因为上面的代码传递的是可变对象，因此在函数内取值和函数外取值都是同样的结果。

5.调用函数时的参数使用
1）必备参数
必须与函数声明时一致的顺序来传递参数。

2）关键字参数
传参数时可与函数声明的顺序不一样，因为Python解释器可以用参数名来匹配参数值。

3）缺省参数
传入参数时未给参数赋值，则保持默认值。

#可写函数说明

def printinfo( name, age=35):
print("Name: ", name);  #"打印任何传入的字符串"
    print("Age ", age);
    return;

#调用printinfo函数
printinfo(age=50,name="miki");
printinfo(name="miki");

这里第二句的age没有输入值，则输出默认值35。

4）不定长参数（也就是包含非必备参数的参数定义）
当不确定会传入参数的个数时，可以对可以不输入的参数名前面加“*”号，按顺序输入时进行对应即可。

def printinfo( arg1,*vartuple):
print("输出: ",arg1)  #"打印任何传入的参数"
    for var in vartuple:
      print var
    return;

# 调用printinfo函数
printinfo(10);
printinfo(70,60,50);

5.匿名函数（使用lambda创建）
python 使用 lambda来创建匿名函数。

lambda只是一个表达式，函数体比def简单很多。

lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。

lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数（只能访问自己的命名空间里的参数）。

虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

# 用一个语句来定义一个Sum函数

sum = lambda arg1, arg2: arg1+ arg2;

# 调用sum函数
print("相加后的值为 : ", sum(10,20))
print("相加后的值为 : ", sum(20,20))

6.变量作用域
1）全局变量
定义在所有函数外则为全局变量，可在所有代码中使用。

当需要在函数内定义全局变量时，必须用global语句。

2）局部变量
定义在函数内则为局部变量，只能在相应的代码块内使用。

total = 0; # 这是一个全局变量
# 可写函数说明
def sum( arg1, arg2):   #返回2个参数的和."
    total = arg1 + arg2; # total在这里是局部变量.
    print("函数内是局部变量 : ", total)
    return(total);

#调用sum函数
sum( 10, 20);
print("函数外是全局变量 : ", total)

在上面的例子中，在函数内部，total是局部变量，而在外部total是全局变量，局部变量的改变不会改变全局变量的值，因此第一个打印结果是30，而第二个是0。

Python模块
Python 模块(Module)，是一个Python 文件，以 .py 结尾，包含了 Python 对象定义和Python语句。

模块让你能够有逻辑地组织你的Python 代码段。

把相关的代码分配到一个模块里能让你的代码更好用，更易懂。

1.导入模块的三种方法的区别
1）import导入
import support # 导入模块，并不导入单个函数

# 现在可以调用模块里包含的函数了，但是必须通过模块名.函数名的方式调用

support.print_func("Runoob")

2）From … import导入
下面的语句可以将模块中的某一部分导入，它只会将里这个部分单个引入到执行这个声明的模块的全局符号表。这个部分可以是某个函数块，也可以是函数块的子函数块。

from modname import name1[, name2[, ... nameN]]
3）From … import * 导入
前两种语句都是导入模块的部分，只是部分导入的位置不同，而使用From …import*则是导入模块的全部项目，尽量少用，太耗内存。

2.命名空间和作用域
变量是拥有匹配对象的名字（标识符）。

命名空间是一个包含了变量名称们（键）和它们各自相应的对象们（值）的字典。每个函数都会有自己的命名空间，当变量出现在函数内部时，Python默认其为局部变量，若存在一个与局部变量重名的全局变量，则由局部变量覆盖全局变量。

Python的命名空间分局部命名空间和全局命名空间。

3.找出模块中所有的模块名、函数名、变量名（dir()函数）
# 导入内置math模块
import math
content = dir(math)
print content;

以上实例输出结果：

['__doc__', '__file__', '__name__', 'acos', 'asin', 'atan',
'atan2', 'ceil', 'cos', 'cosh', 'degrees', 'e', 'exp',
'fabs', 'floor', 'fmod', 'frexp', 'hypot', 'ldexp', 'log',
'log10', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh',
'sqrt', 'tan', 'tanh']
在这里，特殊字符串变量__name__指向模块的名字，__file__指向该模块的导入文件名。

4.查看全局变量和局部变量命名空间
根据调用地方的不同，globals()和 locals()函数可被用来返回全局和局部命名空间里的名字。

如果在函数内部调用 locals()，返回的是所有能在该函数里访问的命名。

如果在函数内部调用 globals()，返回的是所有在该函数里能访问的全局名字。

两个函数的返回类型都是字典。所以名字们能用 keys() 函数摘取。

5. reload() 函数
当一个模块被导入到一个脚本，模块顶层部分的代码只会被执行一次。

因此，如果你想重新执行模块里顶层部分的代码，可以用 reload() 函数。该函数会重新导入之前导入过的模块。语法如下：在这里，module_name要直接放模块的名字，而不是一个字符串形式。

reload(module_name)
Python I/O函数（不只是文件读写）
1.读取键盘输入
读取输入的行：

str = input("请输入：");
print("你输入的内容是: ", str)

input() 函数可以接受Python表达式的输入，并输出表达式的计算结果
请输入：[x*5 for x in range(2,10,2)]
你输入的内容是: [10, 20, 30, 40]
2.打开、关闭读写文件
可以用file对象对大多数文件进行操作。

1）打开文件
你必须先用Python内置的open()函数打开一个文件，创建一个file对象，相关的方法才可以调用它进行读写。

file object = open(file_name [, access_mode][, buffering])
· file_name：file_name变量是一个包含了你要访问的文件名称的字符串值。

· access_mode：access_mode决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。

· buffering:如果buffering的值被设为0，就不会有寄存。如果buffering的值取1，访问文件时会寄存行。如果将buffering的值设为大于1的整数，表明了这就是的寄存区的缓冲大小。如果取负值，寄存区的缓冲大小则为系统默认。

· 当文件不存在但通过open函数打开时，如果是写入则会自动创建文件，如果是读取内容则会报错。

打开文件的模式

描述

以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。

以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。

打开一个文件用于读写。文件指针将会放在文件的开头。

rb+

以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。

打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。

以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。

打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。

wb+

以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。

打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。

以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。

打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾（不然怎么追加呢）。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。

ab+

以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

2）File对象的属性
文件被打开后就会创建一个File对象。

对象属性

描述

file.closed

返回true如果文件已被关闭，否则返回false。

file.mode

返回被打开文件的访问模式。

file.name

返回文件的名称。

file.softspace

如果用print输出后，必须跟一个空格符，则返回false。否则返回true。

3）关闭文件
当一个文件对象的引用被重新指定给另一个文件时，Python 会关闭之前的文件（Python会自动地关闭之前的文件对象，这样不那么耗费内存）。用close（）方法关闭文件是一个很好的习惯。

4）读写文件
无论读、写、还是关闭文件，都需要先用open打开文件。

# 写一个文件
fo = open("foo.txt", "wb")
fo.write( "www.runoob.com!\nVery good site!\n");

# 关闭打开的文件
fo.close()

# 读一个文件
fo = open("foo.txt", "r+")
str = fo.read(10); #这里的参数10表示的是被读取的字节数
print("读取的字符串是 : ", str)
# 关闭打开的文件
fo.close()
5）文件内定位
tell()方法告诉你文件内的当前位置（那应该就是告诉你文件指针在哪个位置）；换句话说，下一次的读写会发生在文件开头这么多字节之后。

seek(offset [,from])方法改变当前文件的位置。Offset变量表示要移动的字节数。From变量指定开始移动字节的参考位置。如果from被设为0，这意味着将文件的开头作为移动字节的参考位置。如果设为1，则使用当前的位置作为参考位置。如果它被设为2，那么该文件的末尾将作为参考位置。

# 打开一个文件
fo = open("foo.txt", "r+")
str = fo.read(10);
print("读取的字符串是 : ", str)

# 查找当前位置
position = fo.tell();
print("当前文件位置 : ", position)

# 把指针再次重新定位到文件开头
position = fo.seek(0, 0);
str = fo.read(10);
print("重新读取字符串 : ", str)
# 关闭打开的文件
fo.close()
3.文件File对象的方法
方法

描述

file.close()
关闭文件。关闭后文件不能再进行读写操作。

file.flush()
刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。

file.fileno()
返回一个整型的文件描述符(file descriptor FD 整型), 可以用在如os模块的read方法等一些底层操作上。

file.isatty()
如果文件连接到一个终端设备返回 True，否则返回 False。

file.next()
返回文件下一行。

file.read([size])
从文件读取指定的字节数，如果未给定或为负则读取所有。

file.readline([size])
读取整行，包括 "\n" 字符。

file.readlines([sizehint])
读取所有行并返回列表，若给定sizeint>0，返回总和大约为sizeint字节的行, 实际读取值可能比sizhint较大, 因为需要填充缓冲区。

file.seek(offset[, whence])
设置文件当前位置

file.tell()
返回文件当前位置。

file.truncate([size])
截取文件，截取的字节通过size指定，默认为当前文件位置。

file.write(str)
将字符串写入文件，没有返回值。

file.writelines(sequence)
向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符。

4.文件OS（Python中处理文件和目录的模块）
方法

描述

os.access(path, mode)
检验权限模式

os.chdir(path)
改变当前工作目录

os.chflags(path, flags)
设置路径的标记为数字标记。

os.chmod(path, mode)
更改权限

os.chown(path, uid, gid)
更改文件所有者

os.chroot(path)
改变当前进程的根目录

os.close(fd)
关闭文件描述符 fd

os.closerange(fd_low, fd_high)
关闭所有文件描述符，从 fd_low (包含) 到 fd_high (不包含), 错误会忽略

os.dup(fd)
复制文件描述符 fd

os.dup2(fd, fd2)
将一个文件描述符 fd 复制到另一个 fd2

os.fchdir(fd)
通过文件描述符改变当前工作目录

os.fchmod(fd, mode)
改变一个文件的访问权限，该文件由参数fd指定，参数mode是Unix下的文件访问权限。

os.fchown(fd, uid, gid)
修改一个文件的所有权，这个函数修改一个文件的用户ID和用户组ID，该文件由文件描述符fd指定。

os.fdatasync(fd)
强制将文件写入磁盘，该文件由文件描述符fd指定，但是不强制更新文件的状态信息。

os.fdopen(fd[, mode[, bufsize]])
通过文件描述符 fd 创建一个文件对象，并返回这个文件对象

os.fpathconf(fd, name)
返回一个打开的文件的系统配置信息。name为检索的系统配置的值，它也许是一个定义系统值的字符串，这些名字在很多标准中指定（POSIX.1, Unix 95, Unix 98, 和其它）。

os.fstat(fd)
返回文件描述符fd的状态，像stat()。

os.fstatvfs(fd)
返回包含文件描述符fd的文件的文件系统的信息，像 statvfs()

os.fsync(fd)
强制将文件描述符为fd的文件写入硬盘。

os.ftruncate(fd, length)
裁剪文件描述符fd对应的文件, 所以它最大不能超过文件大小。

os.getcwd()
返回当前工作目录

os.getcwdu()
返回一个当前工作目录的Unicode对象

os.isatty(fd)
如果文件描述符fd是打开的，同时与tty(-like)设备相连，则返回true, 否则False。

os.lchflags(path, flags)
设置路径的标记为数字标记，类似 chflags()，但是没有软链接

os.lchmod(path, mode)
修改连接文件权限

os.lchown(path, uid, gid)
更改文件所有者，类似 chown，但是不追踪链接。

os.link(src, dst)
创建硬链接，名为参数 dst，指向参数 src

os.listdir(path)
返回path指定的文件夹包含的文件或文件夹的名字的列表。

os.lseek(fd, pos, how)
设置文件描述符 fd当前位置为pos, how方式修改: SEEK_SET 或者 0 设置从文件开始的计算的pos; SEEK_CUR或者 1 则从当前位置计算; os.SEEK_END或者2则从文件尾部开始. 在unix，Windows中有效

os.lstat(path)
像stat(),但是没有软链接

os.major(device)
从原始的设备号中提取设备major号码 (使用stat中的st_dev或者st_rdev field)。

os.makedev(major, minor)
以major和minor设备号组成一个原始设备号

os.makedirs(path[, mode])
递归文件夹创建函数。像mkdir(), 但创建的所有intermediate-level文件夹需要包含子文件夹。

os.minor(device)
从原始的设备号中提取设备minor号码 (使用stat中的st_dev或者st_rdev field )。

os.mkdir(path[, mode])
以数字mode的mode创建一个名为path的文件夹.默认的 mode 是 0777 (八进制)。

os.mkfifo(path[, mode])
创建命名管道，mode 为数字，默认为 0666 (八进制)

os.mknod(filename[, mode=0600, device])
创建一个名为filename文件系统节点（文件，设备特别文件或者命名pipe）。

os.open(file, flags[, mode])
打开一个文件，并且设置需要的打开选项，mode参数是可选的

os.openpty()
打开一个新的伪终端对。返回 pty 和 tty的文件描述符。

os.pathconf(path, name)
返回相关文件的系统配置信息。

os.pipe()
创建一个管道. 返回一对文件描述符(r, w) 分别为读和写

os.popen(command[, mode[, bufsize]])
从一个 command 打开一个管道

os.read(fd, n)
从文件描述符 fd 中读取最多 n 个字节，返回包含读取字节的字符串，文件描述符 fd对应文件已达到结尾, 返回一个空字符串。

os.readlink(path)
返回软链接所指向的文件

os.remove(path)
删除路径为path的文件。如果path 是一个文件夹，将抛出OSError; 查看下面的rmdir()删除一个 directory。

os.removedirs(path)
递归删除目录。

os.rename(src, dst)
重命名文件或目录，从 src 到 dst

os.renames(old, new)
递归地对目录进行更名，也可以对文件进行更名。

os.rmdir(path)
删除path指定的空目录，如果目录非空，则抛出一个OSError异常。

os.stat(path)
获取path指定的路径的信息，功能等同于C API中的stat()系统调用。

os.stat_float_times([newvalue])
决定stat_result是否以float对象显示时间戳

os.statvfs(path)
获取指定路径的文件系统统计信息

os.symlink(src, dst)
创建一个软链接

os.tcgetpgrp(fd)
返回与终端fd（一个由os.open()返回的打开的文件描述符）关联的进程组

os.tcsetpgrp(fd, pg)
设置与终端fd（一个由os.open()返回的打开的文件描述符）关联的进程组为pg。

os.tempnam([dir[, prefix]])
返回唯一的路径名用于创建临时文件。

os.tmpfile()
返回一个打开的模式为(w+b)的文件对象 .这文件对象没有文件夹入口，没有文件描述符，将会自动删除。

os.tmpnam()
为创建一个临时文件返回一个唯一的路径

os.ttyname(fd)
返回一个字符串，它表示与文件描述符fd 关联的终端设备。如果fd 没有与终端设备关联，则引发一个异常。

os.unlink(path)
删除文件路径

os.utime(path, times)
返回指定的path文件的访问和修改的时间。

os.walk(top[, topdown=True[, οnerrοr=None[, followlinks=False]]])
输出在文件夹中的文件名通过在树中游走，向上或者向下。

os.write(fd, str)
写入字符串到文件描述符 fd中. 返回实际写入的字符串长度

Python中的异常处理
1.异常类型
异常名称

描述

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

用户代码生成的警告

2.异常处理
1）try/except语句
捕捉异常通常用try（捕捉错误）/except（处理错误）语句。如果你不想在异常发生时结束你的程序，只需在try里捕获它。异常可带参数，用于说明异常原因

try:
fh = open("testfile", "w")
fh.write("这是一个测试文件，用于测试异常!!")
except (IOError,RuntimeError): # 当出现这两种error中的一种时，执行except后面的操作
print("Error: 没有找到文件或读取文件失败")
except Exception as e: # 使用异常基类捕获
print("Error: 出错")
else:
print("内容写入文件成功")
fh.close()

2）try/finally语句
try-finally 语句无论是否发生异常都将执行最后的代码。

try:
fh = open("testfile", "w")
fh.write("这是一个测试文件，用于测试异常!!")
finally:
print("Error: 没有找到文件或读取文件失败")
3.自己设置异常（用于bug修改、错误检查）
我们可以使用raise语句自己触发异常

raise语法格式如下：

raise [Exception [, args [, traceback]]]
语句中Exception是异常的类型（例如，NameError）参数是一个异常参数值。该参数是可选的，如果不提供，异常的参数是"None"。

最后一个参数是可选的（在实践中很少使用），如果存在，是跟踪异常对象。例子如下：

def functionName( level ):
if level < 1:
raise Exception("Invalid level!", level)
# 触发异常后，后面的代码就不会再执行
对于自定义的异常，在使用except语句处理异常时，一定要将Exception中的异常名作为except语句的一个参数。例子如下：

try:
#正常逻辑
except "Invalid level!":
#触发自定义异常
else:
#其余代码

4.自己创建异常类型，用于常见异常复用
一个异常可以是一个字符串，类或对象。

class Networkerror(RuntimeError): # 基于RuntimeError类创建一个新的类
def __init__(self, arg): # 定义一个函数
self.args = arg

try:
raise Networkerror("Bad hostname") #抛出一个Networkerror异常
except Networkerror as e: #匹配异常的类型，当出现了Networkerror型异常时，执行该except语句，并传递变量e，变量 e 是用于创建Networkerror类的实例，这里的e应该就是这个异常对象？
print(e.args)

Python内置函数
内置函数

abs()

divmod()

input()

open()

staticmethod()

all()

enumerate()

int()

ord()

str()

any()

eval()

isinstance()

pow()

sum()

basestring()

execfile()

issubclass()

print()

super()

bin()

file()

iter()

property()

tuple()

bool()

filter()

len()

range()

type()

bytearray()

float()

list()

raw_input()

unichr()

callable()

format()

locals()

reduce()

unicode()

chr()

frozenset()

long()

reload()

vars()

classmethod()

getattr()

map()

repr()

xrange()

cmp()

globals()

max()

reversed()

zip()

compile()

hasattr()

memoryview()

round()

__import__()

complex()

hash()

min()

set()

delattr()

help()

next()

setattr()

dict()

hex()

object()

slice()

dir()

id()

oct()

sorted()

exec内置表达式

Python面向对象
1.面向对象技术简介
· 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例（对象是类实例化之后的结果）。

· 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。

· 数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。

· 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。

· 实例变量：定义在方法中的变量，只作用于当前实例的类。

· 继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。

· 实例化：创建一个类的实例，类的具体对象。

· 方法：类中定义的函数。

· 对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

2.创建类

· empCount变量是一个类变量，它的值将在这个类的所有实例之间共享。你可以在内部类或外部类使用 Employee.empCount访问。

· 第一种方法__init__()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法

· self代表类的实例，self在定义类的方法时是必须有的，虽然在调用时不必传入相应的参数。Self代表了一件事情，那就是：类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称,按照惯例它的名称是 self。

3.创建实例对象
实例化类其他编程语言中一般用关键字 new，但是在 Python中并没有这个关键字，类的实例化类似函数调用方式。

以下使用类的名称Employee 来实例化，并通过 __init__ 方法接受参数。

"创建 Employee类的第一个对象"
emp1 = Employee("Zara",2000)
"创建 Employee类的第二个对象"
emp2 = Employee("Manni",5000)

4.操作对象属性
下面是读取对象属性的实例：

'所有员工的基类'
class Employee:
empCount = 0
def __init__(self, name, salary): #构造函数
self.name = name # 添加实例属性
self.salary = salary # 添加实例属性
Employee.empCount += 1 # 修改类属性
def displayCount(self): # 添加实例方法
print("TotalEmployee %d" % Employee.empCount) # 读取类属性

def displayEmployee(self): # 添加实例方法
print("Name:", self.name, ", Salary:", self.salary) # 读取实例属性

# "创建 Employee 类的第一个对象"
emp1 =Employee("Zara",2000)
# "创建 Employee 类的第二个对象"
emp2 =Employee("Manni",5000)
emp1.displayEmployee()
emp2.displayEmployee()
print("TotalEmployee %d" %Employee.empCount)

以下函数还可以对属性进行读取之外的操作：

· getattr(obj,name[, default]) :访问对象的属性。

· hasattr(obj,name):检查是否存在一个属性。

· setattr(obj,name,value):设置一个属性。如果属性不存在，会创建一个新属性。

· delattr(obj,name) :删除属性。

5.Python内置的类属性
· __dict__ :类的属性（包含一个字典，由类的数据属性组成）

· __doc__ :类的文档字符串

· __name__:类名

· __module__:类定义所在的模块（类的全名是'__main__.className'，如果类位于一个导入模块mymod中，那么className.__module__ 等于 mymod）

· __bases__ :类的所有父类构成元素（包含了一个由所有父类组成的元组）

6.类的继承
面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过继承机制。继承完全可以理解成类之间的类型和子类型关系。

在python中继承中的一些特点：

· 1：在继承中基类的构造（__init__()方法）不会被自动调用，它需要在其派生类的构造中亲自专门调用。

· 2：在调用基类的方法时，需要加上基类的类名前缀，且需要带上self参数变量。区别于在类中调用普通函数时并不需要带上self参数

· 3：Python总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。（先在本类中查找调用的方法，找不到才去基类中找）。

如果在继承元组中列了一个以上的类，那么它就被称作"多重继承" 。

class Parent:
# 定义父类
parentAttr =100
def __init__(self):
print("调用父类构造函数")
def parentMethod(self):
print('调用父类方法')
def setAttr(self,attr):
Parent.parentAttr =attr
def getAttr(self):
print("父类属性 :",Parent.parentAttr)

class Child(Parent):
# 定义子类
def __init__(self):
print("调用子类构造方法") #无论子类还是父类，都要单独写一次_init_
def childMethod(self):
print('调用子类方法')
def getAttr (self):
print('重写父类方法，因为父类方法不能满足需求')

c = Child() #实例化子类
c.childMethod()#调用子类的方法
c.parentMethod()#调用父类方法
c.setAttr(200) #再次调用父类的方法 -设置属性值
c.getAttr()#再次调用父类的方法 -获取属性值

你可以使用issubclass()或者isinstance()方法来检测，一个类或对象是否为其他类或对象的子类。

· issubclass() -布尔函数判断一个类是另一个类的子类或者子孙类，语法：issubclass(sub,sup)

· isinstance(obj, Class)布尔函数如果obj是Class类的实例对象或者是一个Class子类的实例对象则返回true。

7.运算符重载
Python同样支持运算符重载，实例如下：

class Vector:
def __init__(self, a, b):
self.a = a
self.b = b
def __str__(self):
return 'Vector(%d, %d)' % (self.a, self.b)
def __add__(self, other):
return Vector(self.a + other.a, self.b + other.b)

v1 = Vector(2, 10)
v2 = Vector(5, -2)
print(v1 + v2)

以上代码执行结果如下所示:

Vector(7, 8)

8.类的私有属性及方法
1）类的私有属性
__private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用是self.__private_attrs。

2）类的私有方法
__private_method：两个下划线开头，声明该方法为私有方法，不能在类地外部调用。在类的内部调用self.__private_methods

3）实例
class JustCounter:
__secretCount = 0
# 私有变量
publicCount = 0
# 公开变量
def count(self):
self.__secretCount += 1
self.publicCount += 1
print(self.__secretCount) # 在内部使用私有化属性，不会产生错误

counter = JustCounter()
counter.count()
counter.count()
print(counter.publicCount)
print(counter.__secretCount)
# 报错，实例不能访问私有变量

9.单下划线、双下划线、头尾双下划线说明：
· __foo__:定义的是特列方法，类似 __init__() 之类的。

· _foo:以单下划线开头的表示的是 protected类型的变量，即保护类型只能允许其本身与子类进行访问，不能用于 from module import *

· __foo:双下划线的表示的是私有类型(private)的变量,只能是允许这个类本身进行访问了。

---------------------
作者：数据架构师
来源：CSDN
原文：https://blog.csdn.net/luanpeng825485697/article/details/78387573
版权声明：本文为博主原创文章，转载请附上博文链接！