01 机器学习 - Python基础回顾（一）（下）-阿里云开发者社区

4.3 列表的使用

list = [ 'abcd', 786 , 2.23, 'john', 70.2 ]
tinylist = [123, 'john']
print list          # Prints complete list
print list[0]       # Prints first element of the list
print list[1:3]     # Prints elements starting from 2nd till 3rd 
print list[2:]      # Prints elements starting from 3rd element
print tinylist * 2  # Prints list two times
print list + tinylist # Prints concatenated lists
#修改list中的元素
list[0]=”python”
print(list)

将输出以下结果：

['abcd', 786, 2.23, 'john', 70.200000000000003]
abcd
[786, 2.23]
[2.23, 'john', 70.200000000000003]
[123, 'john', 123, 'john']
['abcd', 786, 2.23, 'john', 70.200000000000003, 123, 'john']

4.4 元组使用

元组是类似于列表中的序列数据类型，一个元组由数个逗号分隔的值组成。

列表和元组之间的主要区别是：列表用方括号[]，列表的长度和元素值是可以改变的

而元组用圆括号()，不能被更新。

元组可以被认为是只读列表。

tuple = ( 'abcd', 786 , 2.23, 'john', 70.2)
tinytuple = (123, 'john')
print tuple           # Prints complete list
print tuple[0]        # Prints first element of the list
print tuple[1:3]      # Prints elements starting from 2nd till 3rd 
print tuple[2:]       # Prints elements starting from 3rd element
print tinytuple * 2   # Prints list two times
print tuple + tinytuple # Prints concatenated lists

这将产生以下结果：

('abcd', 786, 2.23, 'john', 70.200000000000003)
abcd
(786, 2.23)
(2.23, 'john', 70.200000000000003)
(123, 'john', 123, 'john')
('abcd', 786, 2.23, 'john', 70.200000000000003, 123, 'john')

4.5 字典

Python字典是一种哈希表型。由“键-值”对组成。

键可以是任何Python类型，但通常是数字或字符串。

值可以是任意Python的对象。

字典是由花括号括号{}，可分配值，并用方括号[]访问。例如：

dict = {}
dict['one'] = "This is one"
dict[2]     = "This is two"
tinydict = {'name': 'john','code':6734, 'dept': 'sales'}
print dict['one']       # Prints value for 'one' key
print dict[2]           # Prints value for 2 key
print tinydict          # Prints complete dictionary
print tinydict.keys()   # Prints all the keys
print tinydict.values() # Prints all the values

输出结果：

This is one
This is two
{'dept': 'sales', 'code': 6734, 'name': 'john'}
['dept', 'code', 'name']
['sales', 6734, 'john']

4.6 数据类型转换

有时候，可能需要执行的内置类型之间的转换。

类型之间的转换，只需使用类名作为函数。

5.Python流程控制语法

5.1 if语句

var1 = 100
if var1:
   print "1 - Got a true expression value"
   print var1
var2 = 0
if var2:
   print "2 - Got a true expression value"
   print var2
print "Good bye!"
#if的条件可以是数字或字符串或者布尔值True和False（布尔表达式）
#如果是数字，则只要不等于0，就为true
#如果是字符串，则只要不是空串，就为true

if else

var = 100
if var == 200:
   print "1 - Got a true expression value"
   print var
elif var == 150:
   print "2 - Got a true expression value"
   print var
elif var == 100:
   print "3 - Got a true expression value"
   print var
else:
   print "4 - Got a false expression value"
   print var
print "Good bye!"

嵌套if else

var = 100
if var < 200:
   print "Expression value is less than 200"
   if var == 150:
      print "Which is 150"
   elif var == 100:
      print "Which is 100"
   elif var == 50:
      print "Which is 50"
elif var < 50:
   print "Expression value is less than 50"
else:
   print "Could not find true expression"
print "Good bye!"

5.2 while循环

count = 0
while count < 5:
   print count, " is  less than 5"
   count = count + 1
else:
   print count, " is not less than 5"

5.3 for循环

for num in range(10,20):   #to iterate between 10 to 20
   for i in range(2,num):   #to iterate on the factors of the number
      if num%i == 0:       #to determine the first factor
         j=num/i           #to calculate the second factor
         print '%d equals %d * %d' % (num,i,j)
         break            #to move to the next number, the #first FOR
   else:                   # else part of the loop
      print num, 'is a prime number'
#遍历集合
r=range(10,20)
r={1,2,3,4,5}
r=["aaa",3,"c"]
print(r)
for num in r:
    print(num)
r={"a":9,"b":10}
print(r)
for num in r.values():
    print(num)

当执行上面的代码，产生以下结果：

10 equals 2 * 5
11 is a prime number
12 equals 2 * 6
13 is a prime number
14 equals 2 * 7
15 equals 3 * 5
16 equals 2 * 8
17 is a prime number
18 equals 2 * 9
19 is a prime number

6. Python 函数

6.1 基本形式

#定义函数
def changeme( mylist ):
   "This changes a passed list into this function"
   mylist.append([1,2,3,4]);
   print "Values inside the function: ", mylist
   return
# 调用函数
mylist = [10,20,30];
changeme( mylist );
print "Values outside the function: ", mylist

python的函数调用是引用传递，这将产生以下结果：

Values inside the function:  [10, 20, 30, [1, 2, 3, 4]]
Values outside the function:  [10, 20, 30, [1, 2, 3, 4]]

默认参数和可变参数

# 默认参数
#有默认值的参数后面不能再跟无默认值的参数
def printinfo( name, age = 35 ):
   "This prints a passed info into this function"
   print "Name: ", name;
   print "Age ", age;
   return;
#调用
#如果调换了参数的顺序，则必须把参数名都带上
printinfo( age=50, name="miki" );
printinfo( name="miki" );
#可变参数
def printinfo( arg1, *vartuple ):
   "This prints a variable passed arguments"
   print "Output is: "
   print arg1
   for var in vartuple:
      print var
   return;
# 调用
printinfo( 10 );
printinfo( 70, 60, 50 );

6.2 匿名函数

可以使用lambda关键字来创建小的匿名函数。这些函数被称为匿名，因为它们不是以标准方式通过使用def关键字声明。
Lambda形式可以采取任何数量的参数，但在表现形式上只返回一个值。它们不能包含命令或多个表达式。
匿名函数不能直接调用打印，因为需要lambda表达式。
lambda函数都有自己的命名空间，并且不能访问变量高于在其参数列表和那些在全局命名空间等。

示例：

# 定义
sum = lambda arg1, arg2: arg1 + arg2    #lambda表达式
# 调用
print "Value of total : ", sum( 10, 20 )
print "Value of total : ", sum( 20, 20 )
##返回多个值
tup=lambda x,y:(x+1,y+1)
(a,b)=tup(2,3)
c=tup(2,3)
print a,b
print c[0],c[1]

7. Python模块

简单地说，一个模块是由Python代码的文件。一个模块可以定义函数，类和变量。模块还可以包括可运行的代码。

7.1 模块的定义和导入

例：以下代码定义在support.py文件中

def print_func( par ):
   print "Hello : ", par
   return

在别的模块比如(hello.py)中可以导入以定义好的模块

#!/usr/bin/python
#导入模块
import cn.itcast.test.support
# 使用导入的模块中的函数
cn.itcast.test.support.print_func("Zara")
#------------------------------------------------
#或者
from cn.itcast.test.support import print_func
print_func("Zara")

7.2 模块和包

在python中一个文件可以被看成一个独立模块，而包对应着文件夹，模块把python代码分成一些有组织的代码段，通过导入的方式实现代码重用。

1.模块搜索路径

导入模块时，是按照sys.path变量的值搜索模块，sys.path的值是包含每一个独立路径的列表，包含当前目录、python安装目录、PYTHONPATH环境变量，搜索顺序按照路径在列表中的顺序（一般当前目录优先级最高）。

[‘/home/zhoujh/study_workspace/studynotes/python/python_base’, ‘/usr/local/lib/python2.6/site-packages/setuptools-0.6c11-py2.6.egg’, ‘/usr/local/lib/python2.6/site-packages/redis-2.2.1-py2.6.egg’, ‘/usr/local/lib/python2.6/site-packages/Flask-0.8-py2.6.egg’, ‘/usr/local/lib/python2.6/site-packages/Jinja2-2.6-py2.6.egg’, ‘/usr/local/lib/python2.6/site-packages/Werkzeug-0.8.3-py2.6.egg’, ‘/usr/local/lib/python2.6/site-packages/tornado-2.2.1-py2.6.egg’, ‘/usr/local/lib/python2.6/site-packages/MySQL_python-1.2.3-py2.6-linux-x86_64.egg’, ‘/usr/local/lib/python2.6/site-packages/PIL-1.1.7-py2.6-linux-x86_64.egg’, ‘/usr/local/lib/python2.6/site-packages/SQLAlchemy-0.7.8-py2.6-linux-x86_64.egg’, ‘/home/zhoujh/python_workspace/python_app’, ‘/usr/local/lib/python26.zip’, ‘/usr/local/lib/python2.6’, ‘/usr/local/lib/python2.6/plat-linux2’, ‘/usr/local/lib/python2.6/lib-tk’, ‘/usr/local/lib/python2.6/lib-old’, ‘/usr/local/lib/python2.6/lib-dynload’, ‘/usr/local/lib/python2.6/site-packages’]

2.使用import语句导入模块

有下面两种方式

import module1
import module2
import module3
import module1,module2,module3

这两种方式的效果是一样的，但是第一种可读性比第二种好，推荐按照下面的顺序导入模块，并且一般在文件首部导入所有的模块

python标准库
第三方模块
应用程序自定义模块

也可以在函数内部导入模块，这样被导入的模块作用域是局部的

3.使用from-import语句导入模块的属性

单行导入

from module import name1,name2,name3

多行导入

from module import name1,name2,\
                   name3

导入全部属性（由于容易覆盖当前名称空间中现有的名字，所以一般不推荐使用，适合模块中变量名很长并且变量很多的情况）

from module import *

如果你不想某个模块的属性被以上方法导入，可以给该属性名称前加一个下划线(_test)，如果需要取消隐藏，可以显示的导入该属性（from module import _test）

4.扩展的import语句

使用自定义的名称替换模块的原始名称

import simplejson as json

模块被导入时，加载的时候模块顶层代码会被执行，如：设定全局变量、类和函数的声明等，所以应该把代码尽量封装到类和函数中。一个模块无论被导入多少次，只加载一次，可以防止多次导入时代码被多次执行。

5.重新导入模块

reload(module)

内建函数reload可以重新导入一个已经存在的模块

6.包

包将有联系的模块组织在一起，有效避免模块名称冲突问题，让应用组织结构更加清晰。

一个普通的python应用程序目录结构：

app是最顶层的包，a和b是它的子包，可以这样导入：

from app.a import a
from app.b.b import test
a.test()
test()

上面代码表示：导入app包的子包a和子包b的属性test，然后分别调用test方法。

每个目录下都有__init__.py文件，这个是初始化模块，from-import语句导入子包时需要它，可以在里面做一些初始化工作，也可以是空文件。ps：__init__.py定义的属性直接使用顶层包.子包的方式导入，如在目录a的__init__.py文件中定义init_db()方法，调用如下：

from app import a
a.init_db()

7.指定python文件编码方式

python默认是使用ASCII编码，可以指定编码方式，如

#!/usr/bin/env python
#coding=utf-8
或者
#!/usr/bin/env python
# -*- coding:utf-8 -*-

8.解决导入循环问题

有下面两个模块，a.py和b.py

a.py
#!/usr/bin/env python
#coding=utf-8
import b
if __name__ == '__main':
    print 'hello,I'm a'
1
b.py
#!/usr/bin/env python
#coding=utf-8
import a
if __name__ == '__main':
    print 'hello,I'm b'

在这里a尝试导入b，而b也尝试导入a，导入一个先前没有完全导入的模块，会导致导入失败。解决办法：移除一个导入语句，把导入语句放到函数内部，在需要的时候导入。

b.py

#!/usr/bin/env python
#coding=utf-8
if __name__ == '__main':
    import a
    print 'hello,I'm b'

9.使用技巧

创建一个目录python_apps，编辑~/.bashrc，设定环境变量PYTHONPATH的值为该目录的路径。

export PYTHONPATH=/home/zhoujh/python_apps:$PYTHONPATH

然后在python_apps目录下做一个软链接至应用的目录，假如要运行的应用路径为：/home/zhoujh/python_workspace/app

ln -s /home/zhoujh/python_workspace/app ./app

这样以后添加新的应用，只需在该目录下创建一个链接就行。

8.Python文件IO

可以参考我的博客：Python模块

9.Python 面向对象