复习（1~4）

第一天：

Python文件类型：
源代码
Python源代码文件以”py”为扩展名，由Python程序解释，不需要编译
字节代码
- Python源码文件经编译后生成的扩展名为”pyc”的文件
- 编译方法：
import py_compile
py_compile.compile(‘hello.py’)
优化代码
- 经过优化的源码文件，扩展名为”pyo”
- python –O –m py_compile hello.py

Python变量：
变量是计算机内存中的一块区域，变量可以存储规定范围内的值，而且值可以改变。
Python下变量是对一个数据的引用

变量的命名
- 变量名由字母、数字、下划线组成。
- 变量不能以数字开头
- 不可以使用关键字
- a a1 _a
变量的赋值
- 是变量的声明和定义的过程
a = 1
id(a)
Python运算符包括
- 赋值运算符
- 算术运算符
- 关系运算符
- 逻辑运算符
表达式是将不同的数据(包括变量、函数)用运算符号按一定规则连接起来的一种式子。

Python数据类型
数值
字符串
列表
元组
字典

数值类型
- 整型
- 长整型
- 浮点型
- 复数型

整型int
int可以存储2^32个数字，范围-2,147,483,648到2147483647
例如：0，100，-100
长整型long
Long的范围很大，几乎可以说任意大的整数均可以存储。
为了区分普通整型，需要在整数后加L或l。
例如： 2345L，0x34al

浮点型
•例如：0.0，12.0，-18.8，3e+7等

复数型complex
•Python对复数提供内嵌支持，这是其他大部分软件所没有的。
•复数例子：- 3.14j，8.32e-36j
•>>> num = 3.14j
•>>> type(num)
•<type 'complex'>
•>>> num
•3.1400000000000001j
•>>> print num
•3.14j
•>>>

字符串类型--string
•有三种方法定义字符串类型

str = ‘this is a string’
str = “this is a string”
str = ‘’’this is a string’’’
•三重引号（docstring）除了能定义字符串还可以用作注释。
字符串
•字符串索引
字符串是序列，可以通过索引取每个字符

str = ‘abcde’
str[0] + str[1]
•字符串切片

str[1:3]
'bc'
str[:3]
'abc'
str[3:]
'de'
str[::1]
'abcde'
str[::2]
'ace‘
str[-1]
'e'
str[-4:-1]
'bcd‘
str[-2:-4:-1]
'dc'

序列
•字符串、列表和元组都是序列
•序列的两个主要特点是索引操作符和切片操作符

索引操作符让我们可以从序列中抓取一个特定项目
切片操作符让我们能够获取序列的一个切片，即一部分序列。
序列的基本操作
•1. len()： 求序列的长度
•2. +： 连接2个序列
•3. *： 重复序列元素
•4. in： 判断元素是否在序列中
•5. max()： 返回最大值
•6. min()： 返回最小值
•7. cmp(x, y)：比较两个序列是否相等

元组（）
•元组和列表十分相似
•元组和字符串一样是不可变的

元组可以存储一系列的值
元组通常用在用户定义的函数能够安全地采用一组值的时候，即被使用的元组的值不会改变。
•创建元组
•t= ()
•t= (2,)
•t = (‘james’, ‘M’)

元组操作

元组和字符串一样属于序列类型，可以通过索引和切片操作
元组值不可变
•元组的拆分
t = (1,2,3)
a, b, c = t
列表[]
•列表(list)是处理一组有序项目的数据结构， 即可以在列表中存储一个序列的项目。
•列表是可变类型的数据
•创建列表
- list1 = []
- list2 = list()
- list3 = [‘a’,1,2]
列表操作
- 取值
切片和索引
- 添加
list.append()
- 删除
del list[]
list.remove(list[])
- 修改
list[] = x
- 查找
var in list
字典{}
•字典是python中的唯一的映射类型（哈希表）
•字典对象是可变的，但是字典的键必须使用不可变对象，一个字典中可以使用不同类型的键值。
•字典的方法：

keys()
values()
items()

#创建字典
dic = {}
dic = dict()
help(dict)
dict((['a',1],['b',2]))
dict(a=1, b=2)
fromkeys()，
#字典元素有相同的值，默认为None。
ddict = {}.fromkeys((‘x’,’y’), 100)

#访问字典
直接使用key访问：key不存在会报错，可以使用has_key()或者in和not in判断。
循环遍历：
例：for k in dic.keys():
for k in dic:
for k, v in dic.items():
更新
直接用键值访问更新
内建方法update()
•删除
del dic[‘a’]
dic.pop[‘a’]
dic.clear()
del dict

第二天：

# Python程序语言指定任何非0和非空（null）值为true，0 或者 null为false。
#
# Python 编程中 if 语句用于控制程序的执行，基本形式为：
#
# if 判断条件：
#     执行语句……
# else：
#     执行语句……
# 其中"判断条件"成立时（非零），则执行后面的语句，而执行内容可以多行，以缩进来区分表示同一范围。
#
# else 为可选语句，当需要在条件不成立时执行内容则可以执行相关语句
a=1
if a>0:
    print('a= %d' %a)
print('the end')

#if else条件判断
a=1
if a<0:
    print('a是负数')
elif a>0:
    print('a是正数')
else:
    print('a=0')

#while循环
# Python 编程中 while 语句用于循环执行程序，即在某条件下，循环执行某段程序，以处理需要重复处理的相同任务。其基本形式为：
# 
# while 判断条件：
#     执行语句……
# 执行语句可以是单个语句或语句块。判断条件可以是任何表达式，任何非零、或非空（null）的值均为true。
# 
# 当判断条件假false时，循环结束。
b=10
while b>0:
    print('b= %d' %b)
    b-=1
print('the end')

#for循环
# Python for循环可以遍历任何序列的项目，如一个列表或者一个字符串。
#
# 语法：
#
# for循环的语法格式如下：
#
# for iterating_var in sequence:
#    statements(s)
print(range(1,51))
for i in xrange(1,52):
    print('i=%d' % i)
test=dict(a=1,b=2,c=3,d=4)
for i,j in enumerate(test):
    print(i,j)
#enymerate函数中默认分离key和value，在for循环中通过i，j自动赋值key，value，将所有元素遍历出来
#如果是列表就自动遍历下标和列表元素。

for i in xrange(1,11):
    if i==3:
        print('aaaaa')
        continue
    print('i=%d' %i)
for i in xrange(1,11):
    if i==3:
        print('aaaaa')
        break
    print('i=%d' %i)

# 
# 循环控制语句
# 循环控制语句可以更改语句执行的顺序。Python支持以下循环控制语句：
#
# 控制语句    描述
# break语句    在语句块执行过程中终止循环，并且跳出整个循环
# continue语句    在语句块执行过程中终止当前循环，跳出该次循环，执行下一次循环。
# pass语句    pass是空语句，是为了保持程序结构的完整性。

第三天：

2.6
# 使用for循环遍历文件

fd = open('/tmp/hello.txt')
　　for line in fd:
    　　　　print line,

# 2.7
# 使用while循环遍历文件

fd = open('/tmp/hello.txt')
while True:
    　　line = fd.readline()
　　if not line:
    　　　　break
　　　　print line,
fd.close()

# 2.8
# 统计系统剩余的内存
with open('/proc/meminfo') as fd:
    # 查看内存的文件 /proc/meminfo
   for line in fd:
       if line.startswith('MemTotal'):
            # line.startswith(‘a’) 匹配以a开头的行
            total =  line.split()[1]
            # line.split()[1]   以空格为分隔符,形式列表,去第二段
            continue
        if line.startswith('MemFree'):
            free = line.split()[1]
            break
print "%.2f" % (int(free)/1024.0)+'M'
#"%.2f" 格式化字符串
print "%.2f" % (int(total)/1024.0)+'M'
c =  float(free) / float(total)*100
print "%.2f" % c+'%'
print "%.2f" % (float(free)/float(total)*100)+'%'

# cat meminfo.py
# python meminfo.py
# free -m

# 2.9
# 数据类型转换计算（计算mac地址）
mac_addr = '00:16:31:02:D2:1C'
last_two = mac_addr[-2:]
plus_one = hex(int(last_two,16)+1)[2:]
if len(plus_one) == 1:
    plus_one = '0'+plus_one
else:
    pass
next_addr = mac_addr[:-2]+plus_one.upper()
print next_addr
#
# 3.0
# 数据类型转换（列表与字典相互转换）
#
# 对元组进行转换
fruits = ('apple', 'banana', 'orange')

# 元组转换为列表：
list(fruit)

# 元组不能直接转换为字典，附：
# 元组转换为字符串：
fruits.__str__()
#
# 对列表的转换
fruit_list = ['apple', 'banana', 'orange']

# 列表转换为元组：
tuple(fruit_list)

# 列表不能直接转换为字典，附：
# 列表转换为字符串：
str(fruit_list)
#
# 对字典的转换
fruit_dict = {'apple': 1, 'banana': 2, 'orange': 3}
# 将字典的key转换为元组:
tuple(fruit_dict)
# 将字典的value转换为元组:
tuple(fruit_dict.value())

# 将字典的key转换为列表:
list(fruit_dict)
# 将字典的value转换为列表:
list(fruit_dict.value())
# 附：
# 将字典转换为字符串：
str(fruit_dict)
# 对字符串的转换
# 将字符串转换为元组：
str = "(1,2,3)"
tuple(eval(str))
# 将字符串转换为列表：
str = "(1,2,3)"
list(eval(str))
# 将字符串转换为字典：
str = "{'a':1 ,'b',2}"
eval(str)

第四天：

#复习

# 函数定义
# 函数就是完成特定功能的一个语句组，这组语句可以作为一个单位使用，并且给它取一个名字。
# 可以通过函数名在程序的不同地方多次执行（这通常叫函数调用）。
# 为什么使用函数
# 降低编程难度
# - 通常将一个复杂的大问题分解成一系列的小问题，然后将小问题划分成更小的问题，当问题细化为足够简单时，我们就可以分而治之。各个小问题解决了，大问题就迎刃而解了。
# 代码重用
# - 避免重复劳作，提供效率

# 函数的定义和调用
# - def 函数名([参数列表]): //定义
# - 函数名([参数列表]) //调用

# 函数的参数
# 形式参数和实际参数
# - 在定义函数时，函数名后面括号中的变量名称叫做“形式参数”，或者称为“形参”
# - 在调用函数时，函数名后面括号中的变量名称叫做“实际参数”，或者称为“实参”
# 缺省参数（默认参数）
# def fun(x, y=100):
# print x,y
# fun(1,2)
# fun(1)

# 函数的变量
# 局部变量和全局变量
# - Python中的任何变量都有特定的作用域
# - 在函数中定义的变量一般只能在该函数内部使用，这些只能在程序的特定部分使用的变量我们称之为局部变量
# - 在一个文件顶部定义的变量可以供文件中的任何函数调用，这些可以为整个程序所使用的变量称为全局变量
#
# global语句
# - global 变量名
# 强制声明为全局变量
#
# 函数返回值
# - 函数被调用后会返回一个指定的值
# - 函数调用后默认返回None
# - return 返回值
# - 返回值可以是任意类型
# - return执行后，函数终止
# - return与print区别
#
# 多类型传值和冗余参数
#
# 向函数传元组和字典
# 处理多余实参
def fun(x,y,*args,**kwargs)


# 递归调用
# 计算5的阶乘
def factorial(n):
if n == 0:
return 1
else:
return n * factorial(n-1)

print factorial(5)