Python

(一)from __future__ import division

导入python支持的语言特征division(精确除法)，当我们没有在程序中导入该特征时，"/"操作符执行的是截断除法(Truncating Division),当我们导入精确除法之后，"/"执行的是精确除法，如下所示：

---------------------------------------------------------------------------------------------

>>> 3/4

0

>>> from __future__ import division

>>> 3/4

0.75

--------------------------------------------------------------------------------------------

导入精确除法后，若要执行截断除法，可以使用"//"操作符：

--------------------------------------------------------------------------------------------

>>> 3//4

0

>>> 

--------------------------------------------------------------------------------------------

(二)input()和raw_input的区别

1、插话

1>python3里面已经把raw_input()给去掉了 
- 事实上是这样的：在 Python 3 内，将 raw_input() 重命名为 input()，这样一来，无须导入也能从标准输入获得数据了。如果您需要保留版本 2.x 的 input() 功能，可以使用 eval(input())，效果基本相同。

2>Python 版本 2.x 中，raw_input() 会从标准输入（sys.stdin）读取一个输入并返回一个字符串，且尾部的换行符从末尾移除

2、区别

注意：使用python2.x版本进行相应的练习

raw_input()随便输都是字符串，而input()必须按照Python的规则来~

1.raw_input()

 

name=raw_input('输入姓名：')

age=raw_input('输入年龄')

 

我们输入汉字的姓名和数字的年龄

 

输入姓名：乖乖

输入年龄：5

乖乖 5

 

***Repl Closed***

 

直接输，效果杠杠的~但是要注意哦，你的年龄的格式是string

 

2.input()

 

name=input('输入姓名：')

age=input('输入年龄：')

 

我们还是输入汉字的姓名和数字的年龄

 

输入姓名：'乖乖

输入年龄：5

乖乖 5

 

***Repl Closed***

 

效果也是杠杠的~但是需要注意input()输入严格按照Python的语法，是字符就自觉的加 ' ' ，数字就是数字~

 

3、适用场景

输入的类型为字符的时候可以用raw_input()，当然不怕麻烦也可以用input()手动加引号

int类型的时候最好用input()

总之，非常的灵活！！！

（三）repr函数介绍

Python 有办法将任意值转为字符串：将它传入repr() 或str() 函数。

函数str() 用于将值转化为适于人阅读的形式，而repr() 转化为供解释器读取的形式

尽管str(),repr()和``运算在特性和功能方面都非常相似，事实上repr()和``做的是完全一样的事情，它们返回的是一个对象的“官方”字符串表示，也就是说绝大多数情况下可以通过求值运算（使用内建函数eval()）重新得到该对象，但str()则有所不同。str()致力于生成一个对象的可读性好的字符串表示，它的返回结果通常无法用于eval()求值，但很适合用于print语句输出。需要再次提醒的是，并不是所有repr()返回的字符串都能够用 eval()内建函数得到原来的对象。 

 

也就是说 repr() 输出对 Python比较友好，而str()的输出对用户比较友好。虽然如此，很多情况下这三者的输出仍然都是完全一样的。 

 

例如：
s = "hello world"
print str(s)
print repr(s)

 

结果：

C:\Python27\python.exe C:/codes/python/pythoncode/reprtest.py

hello world

'hello world'

 

Process finished with exit code 0

（四）Python中的单行、多行、中文注释

一、python单行注释符号(#)

二、批量、多行注释符号

多行注释是用三引号”’ ”’包含的，例如：

'''
三对单引号，多行注释
三对单引号，多行注释
三对单引号，多行注释
'''

"""
三对双引号，注释多行
三对双引号，注释多行
三对双引号，注释多行
三对双引号，注释多行
"""

三、中文注释

py脚本的前两行一般都是：

#!/usr/bin/python

# -*- coding: utf-8 -*-

(五)range() 与 xrange()函数

注意：在 Python3.0中，range转换为xange风格的函数

(1)range([start,] stop[, step])，根据start与stop指定的范围以及step设定的步长，生成一个序列。

>>> range(0,5)

[0, 1, 2, 3, 4]

>>> range(1,5)

[1, 2, 3, 4]

>>> range(0,6,2)

[0, 2, 4]

 

 

(2)xrange用法与 range 完全相同，所不同的是生成的不是一个list对象，而是一个生成器。

>>> xrange(0,5)

xrange(5)

>>> list(xrange(0,5))

[0, 1, 2, 3, 4]

>>> xrange(5)

xrange(5)

>>> list(xrange(5))

[0, 1, 2, 3, 4]

>>> xrange(0,6,2)

xrange(0, 6, 2)

>>> list(xrange(0,6,2))

[0, 2, 4]

由上面的示例可以知道：要生成很大的数字序列的时候，用xrange会比range性能优很多，因为不需要一上来就开辟一块很大的内存空间。

 

 

(3)xrange 和range这两个基本上都是在循环的时候用。

>>> for i in range(0,100):

...     print i

 

>>> for i in xrange(0,100):

...     print i

这两个输出的结果都是一样的，实际上有很多不同，range会直接生成一个list对象：

 

>>> a = range(0,100)

>>> print(type(a))

<type 'list'>

>>> print a

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99]

>>> print(a[0],a[1])

(0, 1)

以下为xrange的：而xrange则不会直接生成一个list，而是每次调用返回其中的一个值：

>>> xrange(0,100)

xrange(100)

>>> a = xrange(0,100)

>>> print(type(a))

<type 'xrange'>

>>> print(a)

xrange(100)

>>> print(a[0],a[1])

(0, 1)

故此，尤其是返回很大的时候，尽量用xrange吧。

(六)Python3---函数的作用域，闭包及递归

1)函数的作用域：

全局变量和局部变量

定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。

（1）函数内部的变量，作用域只在函数内部,函数内部不可以直接更改函数外部的变量

（2）函数内部如果需要改变全局变量，就需要使用global修饰变量

（3）在函数嵌套函数的情况下，同样也有函数作用域的问题，但是python3中提供了方便，只需要使用nonlocal就可以在里层函数内部修改外部函数变量

x = 1    #全局变量
def fun():
    y =2   #局部变量
    print(x,y)

global关键字：

想要在函数里修改全局变量，需要使用关键字global

x = 1 #全局变量
def fun():
    y = 2 #局部变量
    global x
    x += 1
    print(x,y)

想要在函数外访问函数里的变量，也需要使用关键字global

不加global的时候：

当函数外变量和函数里变量同名，且函数里使用了global关键字，优先使用函数里的变量

a = 10
def f1():
    global a
    a += 1
    print(a)
def f2():
    global a
    a = 1
    print(a)
f1()
f2()

#运行结果

11
1

nonlocal关键字：

如果要修改嵌套作用域（enclosing 作用域，外层非全局作用域）中的变量则需要 nonlocal 关键字了

def fun2():
    q = 10
    print("外层q:",q)
    def fun3():
        w = 20
        nonlocal q
        q += 1
        print("里层q值：",q)
        print("里层w值:",w)
    fun3()
    
fun2()

结果：

外层q: 10
里层q值： 11
里层w值: 20

二.闭包

1.内嵌函数：函数里又嵌套一个函数

def fun1():
    print("fun1()在被调用")
    def fun2():
        print("fun2()在被调用")
    fun2()
fun1()

结果：

fun1()在被调用
fun2()在被调用

2.闭包

闭包是函数里面嵌套函数，外层函数返回里层函数，这种情况称之为闭包

闭包是概念，不是某种函数类型，和递归的概念类似，就是种特殊的函数调用

闭包可以得到外层函数的局部变量，是函数内部和函数外部沟通的桥梁

def fun4(a):
    print(a)
    def fun5():
        print(a,11)
    return fun5   #调用不执行
a = fun4(3)
a()  #相当于fun4(3)()调用fun5

结果：

3
3 11

三.回调函数

#回调函数
def fun6():
    print("第一个函数")
def fun7(a):  #把上一个函数体当作参数
    a()
    print("第二个函数")

fun7(fun6)

结果：

第一个函数
第二个函数

四.递归函数

即自己调用自己

递归中可以函数自身调用自身，但是使用时类似于条件循环一样，要有递归的终止条件

#阶乘 5! = 5*4*3*2*1
def factorial(n):
    if n == 1:
        return 1
    else:
        return factorial(n-1) * n

 

优点：使用递归时，常常可以让代码更加简洁

缺点：递归会占用比较多的内存，当递归次数比较多时，性能就会降低，因此不建议多使用递归

(七)下一个