python基础

一，python简介


1.python起源：
1989年，为了打发圣诞节假期，Guido开始写Python语言的编译器；
Python这个名字来自于Guido所挚爱的电视剧——Monty Python’s Flying Circus。
他希望这个新语言Python能够符合他的理想：创造一种介于C和Shell之间，功能全面、易学易用、可拓展的语言。
Guido作为一个语言设计爱好者，已经尝试过设计语言，这次不过是一种纯粹的即兴行为。


   
2.python是什么？
python是一门解释性，面向对象的脚本语言。
1.二进制转换为十进制，或十六进制：比如二进制101110011110111011101111111111011111转化成十六进制baoxiufen
python中一切皆为对象.  python中使用对象属性和方法的记法为：object.attribute （目标.属性）或 object.method() （目标.方法）



面向对象：
比如：盖楼，想到房子要怎么建，房子里哪里要柱子，哪里要有梁，哪里要有楼梯等等 ————————————————这就是面向对象
至于这个柱子怎么选，方的，还是圆的；楼梯多少个台阶，围栏选用材料等等 ————这是面向过程。

在面向对象中，也存在面向过程。

    生活中一切都是对象

3.python有什么特点？为什么要学习python？
简单易学，语法简洁，功能强大，可移植性，应用广泛。


Python在云计算方面的用途很大，比如：
    （1）企业虚拟化平台（CecOS）中的一些计算和自动化任务；
（2）持续交互平台（Spinnaker）中的一些计算和自动化任务；
（3）开源云计算技术（OpenStack）；
（4）在大数据领域，Python的使用也越来越广泛。




5.怎么学习Python？
（1）在写代码时，千万不要用“复制”“粘贴”把代码从页面粘贴到你的电脑上。
（2）写需要一个字母一个字母地把代码敲进去。
（3）在敲代码的过程中，初学者经常会敲错，所以需要仔细检查、对照，这样才能以最快的速度掌握如何写程序。
（4）在编写代码的过程中，宁愿写得慢或多写几遍，刚开始学习或许很吃力，但随着慢慢积累和熟悉，后面会越来越快，越来越顺畅。
（5)若习惯拷贝代码, 或许很长一段时间后依然只会拷贝代码，而不能熟悉相关内容，速度也提升不了。


   
   
 6.python2和python3版本之间的主要区别如下：
（1）. print函数:  
    Python 2中的print语句被Python 3中的print()函数取代;
print --------->print()

#示例：
print 'Hello, World!'
print('Hello, World!')

    （2）通过input()解析用户的输入：
   （Python2的input的到的为int型，
Python2的raw_input得到的为str类型
Python3中input得到的为str；）
 
统一一下：Python3中用input，Python2中用row_input，都输入为str





 安装
1.python安装
  先python3,配置环境变量；
  配置环境变量，;C:\Python33;C:\Python33\Tools\Scripts 


2.编译工具部署
  sublime text3配置


 参考教学网址：http://www.runoob.com/python3/python3-step1.html
 
###################################################################################################################################################
###################################################################################################################################################


二， 输出第一个脚本：
交互式编程： 我们可以在命令提示符中输入"Python"命令来启动Python解释器；
输出第一个脚本：hello Python！


脚本式编程： 将‘hello Python！’代码拷贝至 hello.py文件中

###################################################################################################################################################


三，基本语法：
1. 缩进
2. 函数，if，for等语句后面：
3. 注释： ''''''   """"""  #
4. ''   " "
5.python对缩进有严格要求，默认是4个空格。
###################################################################################################################################################
###################################################################################################################################################


四.变量 
*******************
    常量和变量的区别：身份证和体重
1.什么是变量：各种类型值的名字，以后用到这个值的时候，直接引用名字即可，不用写具体的值。变量的定义：(eg:a=1)赋值号左边是变量名，右边是变量的值。

（1）变量的赋值：
变量赋值的过程就是创建变量的过程，变量一定要先定义才能被引用，变量的类型由值决定。

（2）变量的命名规范：
a, 不可以以数字开头
b, 不可以以系统的关键字命名----关键字查看方法：import keyword   print(keyword.kwlist)
c, 不可以以特殊字符开头
d, 可以包括字母、下划线、数字


2. 变量作用域：
Python中有两种最基本的变量作用域：局部变量和全局变量。


   1.局部变量：在函数内定义的变量名只能被函数内部引用，不能在函数外引用，这个变量的作用域是局部的，也称为局部变量。
例如：
def func(): 
x = 100 
print(x)
func() 
在func函数中，x是在函数体中被定义的，并且是第一次出现，所以x是局部变量。


2.全局变量在函数外，一段代码最开始赋值的变量可以被多个函数引用，这就是全局变量。全局变量可以在整个程序范围内访问。
x = 100
def func(): 
x = 100 
print(x)


print(x+1)

3. 假设要在函数中将某个变量定义为全局变量，在需要被定义的变量
   前加一个关键字global即可。
   在函数体中定义global变量后，在函数体中对变量做的其他操作也是全局性的。
num = 100 
print('函数调用前num的值为：',num) 
def func():     
global num     
num = 200     
num += 100     
print('函数体中num的值为：',num)
func() 
print('函数调用结束后num的值为：',num) #执行了num += 100 


#####################################################################################################################
#####################################################################################################################
五， 运算符：
************************
    运算符有好几种，我们了解一下以下的几种基本的运算符


1.算术运算符 （假设变量a为10，变量b为21）


+ 加 - 两个对象相加                           ## a + b 输出结果 31
- 减 - 得到负数或是一个数减去另一个数 a - b    ## 输出结果 -11
* 乘 - 两个数相乘或是返回一个被重复若干次的字符串 ## a * b 输出结果 210
/ 除 - x 除以 y ## b / a 输出结果 2.1
% 取模 - 返回除法的余数 ## b % a 输出结果 1
** 幂 - 返回x的y次幂 ## a**b 为10的21次方
// 取整除 - 返回商的整数部分 ## 9//2 输出结果 4 , 9.0//2.0 输出结果 4.0
a = 10
b = 20
print("a + b，返回：", a + b)
print("a - b，返回：", a - b)
print("a * b，返回：", a * b)
print("a / b，返回：", a / b)
print("a % b，返回：",a % b)
print("a ** b，返回：",a ** b)
print("a // b，返回：",a // b)

2.比较运算符 （假设变量a为10，变量b为20：）


== 等于 - 比较对象是否相等         ## (a == b) 返回 False。
!= 不等于 - 比较两个对象是否不相等 ## (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。
a = 10
b = 20
print("a + b，返回：", a + b)
print("a - b，返回：", a - b)
print("a * b，返回：", a * b)
print("a / b，返回：", a / b)
print("a % b，返回：",a % b)
print("a ** b，返回：",a ** b)
print("a // b，返回：",a // b)

3.赋值运算符  （假设变量a为10，变量b为20：）


= 简单的赋值运算符 ## 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
a = 10
b = 20
c = a+b
print("a+b:", c)
c += a
print(" c += a 等效于 c = c + a: ",c)
c -= a
print(" c -= a 等效于 c = c - a: ",c)
c *= a
print(" c *= a 等效于 c = c * a: ",c)
c /= a
print(" c /= a 等效于 c = c / a: ",c)
c %= a
print(" c %= a 等效于 c = c % a: ",c)
c **= a
print(" c **= a 等效于 c = c ** a: ",c)
c //= a
print(" c //= a 等效于 c = c // a: ",c)


6. Python运算符优先级


** ## 指数 (最高优先级)
~ + - ## 按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
* / % // ## 乘，除，取模和取整除
+ - ## 加法减法

#####################################################################################################################
#####################################################################################################################
六，常用的数据类型
    number   数字   -1  1
float    小数   0.5  -0.5
string   字符串 string
集合     序列   set =（'str1','str2','str3'）

#####################################################################################################################
#####################################################################################################################
七，列表和元组
**********************************
在Python中，最基本的数据结构是序列，
     #包含6种内建序列：即列表、元组、字符串、Unicode字符串、buffer对象和xrange对象。
本章重点讨论最常用的两种，即列表和元组。
#在讲解列表和元组之前:
#本节先介绍Python中序列的通用操作，这些操作在列表和元组中都会用到。

1.Python中所有序列都可以进行一些特定操作包括：
索引（indexing）；
分片（slicing）；
序列相加（adding）；
乘法（multiplying）；
成员资格、长度、最小值和最大值。


(1)索引：
序列中的每个元素都分配一个数字，代表它在序列中的位置（索引），第一个索引是0，第二个索引是1，以此类推。
    序列中所有元素都是有编号的，从0开始递增。可以通过编号分别对序列的元素进行访问。

    通过编号取元素的例子：
greeting='Hello'#定义变量greeting，并赋值Hello 
print(greeting[0]) #根据编号取元素，使用格式为：在中括号中输入所取元素的编号值 'H' 
print(greeting[1])
print(greeting[2])
   可以看到，序列中的元素从0开始，从左向右依自然顺序编号，元素可以通过编号访问。
   ## 获取元素的方式为：在变量后加中括号，在中括号中输入所取元素的编号值。这个格式需要记住。
   
   上面的示例是从左往右通过编号获取元素的，是否可以从右往左通过编号获取元素呢？
   greeting='Hello'#定义变量greeting，并赋值Hello 
print(greeting[-1]) #根据编号取元素，使用格式为：在中括号中输入所取元素的编号值 'o' 
print(greeting[-2])
print(greeting[-3])    
   可以看到，Python的序列也可以从右开始索引，最右边的元素索引值为-1，从右向左递减。       
   #在Python中，从左向右索引称为正数索引，从右向左索引称为负数索引。    
   #使用负数索引时，Python会从最后一个元素开始计数。最后一个元素的位置编号是-1。 最后一个元素的编号不是-0，跟数学中的
        概念一样，-0=0、-0和0都指向第一个元素。


------------------练习5分钟


（2）分片索引:  
用来对单个元素进行访问，使用分片可以对一定范围内的元素进行访问，分片通过冒号相隔的两个索引实现。
例：
number = [1,2,3,4,5,6,7,8,9,10] 
print(number[1:3] ) #取索引为第一和第二的元素 [2, 3]
print(number[-3:-1]) #负数表明从右开始计数，取得倒数第三和倒数第二的元素 [8, 9] 由操作结果可以看到，分片操作既支持正数索引，也支持负数索引。
print(number[-3: 0])
#这个print(number[-3: 0])输出结果有点奇怪，竟然一个数值都没有，事实上，
#只要在分片中最左边的索引比它右边的索引"晚出现"在序列中，结果就是一个空序列。
#比如上例中，-3代表倒数第3个元素，0代表第一个元素，倒数第3个元素比第一个元素晚出现，即排在第一个元素后面，所以得到的结果是空序列。

我们怎么通过负数索引的方式取得最后一个元素呢？
print(number[-3: ])
print(number[-3: 0])
print(number[0:]) #从第一个元素开始输出，输出全部结果 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] 
print(number[:0]) #最后一个元素为第一个，输出为空 [] 
print(number[:3]) #取得前3 个元素 [1, 2, 3] 由输出结果可以知道也适用于正数索引。
print(number[:])
根据上述输出结果可知，若需要输出整个序列，则可以将两个索引都设置为空。

        问题：如果我们要取序列中不连续的元素如何操作？
比如要取序列number中的所有奇数。


------------------练习5分钟

   （3）步长
在普通分片中，步长是1。分片操作就是按照这个步长逐个遍历序列的元素，遍历后返回开始和结束点之间的所有元素。
也可以理解为默认步长是1。
输入如下：
number = [1,2,3,4,5,6,7,8,9,10]  
print(number[0:10]) #默认步长为1 
print(number[0:10:1]) #步长为1
print(number[0:10:2]) #步长为2 
由结果可知，步长设置为大于1的数时，会得到一个跳过某些元素的序列。

#还可以这样输
print(number[0:10:3])
print(number[2:6:3])
print(number[1:5:3])
由以上输出可以看到，使用步长的方式还是很灵活的。
print(number[::3]) #除了上面的使用方式外，设置前面两个索引为空的捷径也可以使用。

步长设置为0是否可行呢？
print(number[::0]) #ValueError: slice step cannot be zero  --输出结果告诉我们步长不能为0。

步长是否可以为负数呢？
print(number[10:0:-2]) #[10, 8, 6, 4, 2]
print(number[::-2])    #[10, 8, 6, 4, 2]
print(number[5::-2])   #[6, 4, 2]
print(number[:5:-2])   #[10, 8]
print(number[::-1])  
print(number[10:0:-1])  #第二个索引为0，取不到序列中的第一个元素 [10, 9, 8, 7, 6, 5, 4, 3, 2]
print(number[10::-1]) #设置第二个索引为空，可以取到序列的一个元素 [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
print(number[2::-1])    #设置第二个索引为空，可以取到序列的一个元素 [3, 2, 1] 
print(number[2:0:-1])   #取不到第一个元素
print(number[2::-1])    #使用负数步长时，设置第二个索引为空才能取到序列的第一个元素


#正数步长必须让开始点小于结束点，而负数步长必须让开始点大于结束点。 


-----------------------------------练习5分钟----------------------------------

   （4）序列相加：
使用加号可以进行序列的连接操作，输入如下：
例1：
print([1,2,3]+[4,5,6])

例2：
a = [2,4,6]
b = [2,3,5]
print(a+b)

例3：
s='hello,'
w='world'
print(s+w)

由上面的输出结果可以看到，数字序列可以和数字序列通过加号连接，连接后的结果还是数字序列；
字符串序列也可以通过加号连接，连接后的结果还是字符串序列。

数字序列是否可以和字符串序列相加呢？
输入如下：
>>> [1,2]+'hello' 
Traceback (most recent call last):   
File "<pyshell#103>", line 1, in <module>     
[1,2]+'hello' TypeError: can only concatenate list (
not "str") to list 

##由试验结果可以得知：只有类型相同的序列才能通过加号进行序列连接操作，不同类型的序列不能通过加号进行序列连接操作。

（5）乘法用法：
print('hello '*5)
print([7]*5)


（6）长度、最小值和最大值Python为我们提供了长度、最大值和最小值的内建函数，对应的内建函数分别为len、max和min；
    这3个函数该怎么使用呢？
在交互模式输入：
numbers=[300,200,100,800,500] 
print(len(numbers))
print(max(numbers))
print(min(numbers))
print(max(5,3,10,7))
print(min(7,0,3,-1) -1) 
由上面的结果可以看到，
len函数返回序列中所包含元素的数量，
max函数和min函数分别返回序列中最大和最小的元素。


提示：内建函数python在guido开发的时候可能就已经写好了，函数相当于我们定义求长方形面试公式：长方形面积=长×宽  （S = ab),S就是定义的函数


2， 列表List：list是 Python 中使用最频繁的数据类型。
在上面我们在讲索引，切片等的时候，用到了列表以及对列表的一些处理。

(1) 列表可以完成大多数集合类的数据结构实现，列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表；
(2) 列表是写在方括号([])之间、用逗号分隔开的元素列表；
(3) 索引值以 0 为开始值，-1 为从末尾的开始位置;
(4) 加号（+）是列表连接运算符，星号（*）是重复操作.
list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
tinylist = [123, 'runoob']
 
print (list)            # 输出完整列表
print (list[0])         # 输出列表第一个元素
print (list[1:3])       # 从第二个开始输出到第三个元素
print (list[2:])        # 输出从第三个元素开始的所有元素
print (tinylist * 2)    # 输出两次列表
print (list + tinylist) # 连接列表


(6) 与Python字符串不一样的是，列表中的元素是可以改变的：
a = [1, 2, 3, 4, 5, 6]
a[0] = 9  #将1改成9
a[2:5] = ['hello', 14, 15] #将3-5改成hello,14,15
print(a)
a[2:5] = []   # 将3-5元素值设置为 [] 即为空
print(a)



（7）内置方法：
1）append() --添加
#方法是一个用于在列表末尾添加新对象的方法。
 
此语法中list代表列表，obj代表需要添加到list列表末尾的对象。 
append的使用方式是list.append(obj)
示例：
tring=[1,2,3] 
tring.append('test')  #添加字符串 
print(tring)
tring=[1,2,3] 
tring.append('4')  #添加字数字 
print(tring)
   由上面的示例可以得知：可以往数字序列中添加字符串，也可以往字符串序列中添加数字。
       
2) del() --按位置删除值
   #删除指定位置的元素
示例1：
tring=['a','b','c','d','e'] 
print(len(tring)) 
del tring[1] 
print('删除第二个元素：',tring) #删除第二个元素： ['a', 'c', 'd', 'e'] 
print(len(tring)) 

   示例2：
num=[1,2,3] 
print(len(num)) 
del num[2] 
print('删除第3 个元素后：',num) #删除第3 个元素后：[1, 2] 
print(len(num))

   由上面的示例看到，可以使用del删除列表中的元素。  
   
3）count() --统计
   #方法用于统计某个元素在列表中出现的次数。
   list.count(obj) 
   
  #示例：
field=list('hello,world') 
print(field)
print('列表field 中，字母o 的个数：',field.count('o')) #统计列表中的字符个数 列表field 中，字母o 的个数： 2 
print('列表field 中，字母l的个数：',field.count('l'))   #列表field 中，字母l的个数： 3 
print('列表field 中，字母a 的个数：',field.count('a'))  #列表field 中，字母a 的个数： 0 
listobj = [123, 'hello', 'world', 123] 
listobj = [26, 'hello', 'world', 26] 
print('数字26 的个数：',listobj.count(26)) # 数字26 的个数： 2 
print('hello 的个数：',listobj.count('hello'))#统计字符串个数 hello的个数： 1 
print(['a','c','a','f','a'].count('a')) 
mix=[[1,3],5,6,[1,3],2,] 
print('嵌套列表mix中列表[1,3]的个数为：',mix.count([1,3])) #嵌套列表mix 中列表[1,3]的个数为： 2 

4）extend() --追加新列表
   语法：list.extend(seq) 此语法中list代表列表，seq代表元素列表。
  #方法用于在列表末尾一次性追加另一个序列中的多个值。
  #示例：
a=['hello','world'] 
b=['python','is','funny'] 
a.extend(b) 
print(a)

5）index() --位置索引
   语法：list.index(obj) 语法中list代表列表，obj代表查找的对象。
   #用于从列表中找出某个值第一个匹配项的索引位置；
   #示例：
field=['hello', 'world', 'python', 'is', 'funny'] 
print('hello 的索引位置为：',field.index('hello'))  #hello 的索引位置为： 0 
print('python 的索引位置为：',field.index('python')) #python的索引位置为： 2 
print('abc 的索引位置为：',field.index('abc')) #ValueError: 'abc' is not in list 

6）insert() --插入值
   语法：list.insert(index,obj) 语法中list代表列表，index代表对象obj需要插入的索引位置，obj代表要插入列表中的对象。
   #示例：
num=[1,2,3] 
print('插入之前的num：',num) #插入之前的num： [1, 2, 3] 
num.insert(2,'插入位置在2 之后，3 之前') 
print('插入之后的num：',num) #插入之后的num： [1, 2, '插入位置在2 之后，3 之前', 3] 
   
7）pop() --移除最后一个值
  #语法：list.pop(obj=list[-1]) 此语法中list代表列表，obj为可选择的参数，代表要移除列表元素的对象。
  #方法用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
  #示例：
field=['hello', 'world', 'python', 'is', 'funny'] 
field.pop() #不传参数，默认移除最后一个元素 'funny' 
print('移除元素后的field：',field) #移除元素后的field： ['hello', 'world', 'python', 'is'] 
field.pop(3) #移除编号为3 的元素 'is'


8）reverse() --反向列表中的元素
  #语法：list.reverse() 此语法中list代表列表，该方法不需要传入参数
  #用于反向列表中的元素
  #示例：
num=[1,2,3] 
print('列表反转前num：',num) #列表反转前num： [1, 2, 3] 
num.reverse() 
print('列表反转后：',num) #列表反转后： [3, 2, 1]

9）sort() --列表进行排
  # 语法： list.sort(func) 此语法中list代表列表，func为可选参数
  #用于对原列表进行排序
  #示例：
num=[5,8,1,3,6] 
num.sort() 
print('num 调用sort 方法后：',num) #num调用sort 方法后： [1, 3, 5, 6, 8] 

10）clear() --清空列表
#语法：list.clear() 此语法中list代表列表，不需要传入参数。
#方法用于清空列表
#示例：
field=['study','python','is','happy'] 
field.clear() 
print(field)

(8) 列表其他操作：
test = (5,2,2,2) 
print(sum(test)) ---求和
    

 
注意：
1、List写在方括号之间，元素用逗号隔开。
2、和字符串一样，list可以被索引和切片。
3、List可以使用+操作符进行拼接。
4、List中的元素是可以改变的。

-----------------------------------练习5分钟----------------------------------

3. 元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。
元组的基本操作和列表一样，元组也有一些基本操作，如访问元组、修改元组、删除元组、索引和截取等操作。
当然，这里的修改、删除和截取等操作和列表的操作不太一样。


(1) 元组中的元素类型也可以不相同;
tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2  )
tinytuple = (123, 'runoob')
(2)元组与字符串类似，可以被索引且下标索引从0开始，-1 为从末尾开始的位置;
(3)虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表;
(4)构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则:
如：tup1 = ()    # 空元组；
tup2 = (20,) # 一个元素，需要在元素后添加逗号。

1）#修改元组元组中的元素值不允许修改，但可以对元组进行连接组合，
field = ('hello', 'world') 
num = (2015, 2016) 
print ("合并结果为: ", field+num) #合并结果为:   ('hello', 'world', 2015, 2016) 

2）不能删除元祖
field = ('hello', 'world') 
del field[0]
print(field) #TypeError: 'tuple' object doesn't support item deletion

3）元组索引、截取因为元组也是一个序列,所以可以访问元组中指定位置的元素，也可以截取索引中的一段元素
field = ('hello', 'world', 'welcome') 
print(field [2] ) 
print(field [-2] )
print(field [1:] )


(5) 元组内置函数Python元组提供了一些内置函数，如计算元素个数、返回最大值、返回最小值、列表转换等函数。

1) len(tuple)用于计算元组元素个数。
使用方式如下：
tup = ('hello', 'world', 'welcome') 
print(len(tup)) 
2) max(tuple)用于返回元组中元素的最大值。
使用方式如下：
tup = ('6', '3', '8') 
print(max(tup))
3) min(tuple)用于返回元组中元素的最小值。
使用方式如下：
tup = ('6', '3', '8') 
print(min(tup))
4) tuple(seq)用于将列表转换为元组。
使用方式如下：
field= ['hello', 'world', 'welcome'] 
tup=tuple(field) 
print(tup)
以上为Python中常见的一些元组的内置函数，大家可以自行操作其他函数尝试。


注意：
1、元组的元素不能修改；
2、元组也可以被索引和切片，方法一样；
3、注意构造包含0或1个元素的元组的特殊语法规则；
4、元组也可以使用+操作符进行拼接。


元祖与列表的区别：元祖不可以改变，列表可以改变。
不可变的元组有什么意义？
因为元组不可变，所以代码更安全。
如果可能，能用元组代替列表就尽量用元组。
我们看下面的示例：
二维数组
c = ['A',['B']]
t = ('a', 'b', c) 
print(t[2][1])
t[2][0] = 'x'
t[2][1] = 'y'
print(t)
此处使用了嵌套列表，一个列表中包含另一个列表，也可以称为二维数组。
先取得二维数组里嵌套的数组，如上例中的t[2]，取得的是['A', 'B']，t[2]是一个一维数组.






练习
温故知新，学以致用本章主要讲解了列表和元组，在本章结束前回顾一下学到的概念。
（1）通用序列的基本操作有哪些？
（2）列表有哪些操作和方法？
（3）元组有哪些基本操作？内置函数如何使用？
（4）列表与元组的区别是什么？
尝试思考并解决如下问题：
（1）用负数步长对列表和元组进行分片。
（2）用索引取出下面list的指定元素：
field = [     ['hello', 'world', 'welcome'],     ['study', 'Python', 'is', 'funny'],     ['good', 'better', 'best'] ] 
# 输出hello: print(?) 
# 输出Python: print(?) 
# 输出best: print(?)
-----------------------------------练习10分钟----------------------------------

#####################################################################################################################
#####################################################################################################################
八，字符串
我们前面已经接触过字符串，也了解了一些基本操作，对字符串的创建、索引和分片等操作已经有了初步理解。
本章将介绍字符串的格式化、分割、搜索等方法。


1. 字符串格式化符号：字符串格式化使用操作符百分号（%）实现。 %也可以用作模运（求余）操作符。
   例如：
    print ('hello,%s' % 'world') 
······· print ('小智今年%s 岁了' % 10) 
print ('hello,%s' % 'world') 
print ('小智今年%s 岁了' % 10) 
print ('小智今年%d 岁了' % 10)  #使用%d 作为10 的占位符 小智今年10岁了 
print ('圆周率PI 的值为：%f' % 3.14) 
        s%，d%，f%  标记了需要放置转换值的位置，通用术语为占位符。
 
    2.  字符串的方法比列表还多，这里只介绍一些特别有用的方法：   
（1）find()  --方法用于检测字符串中是否包含子字符串str。
find()方法的语法如下：
str.find(str, beg=0, end=len(string)) 
此语法中str代表指定检索的字符串，beg代表开始索引，默认为0；end代表结束索引，默认为字符串的长度。
作用：返回结果为子串所在位置的最左端索引，如果没有找到，就返回-1。
示例：
field='do it now' 
print(field.find('do')) 
print(field.find('now') )
print(field.find('python') ) #不存在返回-1

（2）lower()方法 -----------作用：返回结果为字符串中所有大写字符转换为小写后生成的字符串
lower()方法的语法如下：
str.lower() 此语法中str代表指定检索的字符串，该方法不需要参数。

该方法使用示例如下：
field='DO IT NOW' 
print('调用lower 得到字符串：',field.lower()) #调用lower 得到字符串： do it now 
greeting='Hello,World' 
print('调用lower 得到字符串：',greeting.lower()) #调用lower 得到字符串： hello,world 
由输出结果看到，字符串中的大写字母全部转换为小写字母了。

（3）upper()方法  --------- 作用：返回结果为小写字母转换为大写字母的字符串
    语法如下：
str.upper() 此语法中str代表指定检索的字符串，该方法不需要参数。
#示例：
field='do it now' 
print('调用upper 得到字符串：',field.upper()) #调用upper 得到字符串： DO IT NOW 
greeting='Hello,World' 
print('调用upper 得到字符串：',greeting.upper()) #调用upper 得到字符串： HELLO,WORL


（4）swapcase()方法 ---------作用：用于对字符串的大小写字母进行转换，将字符串中大写转换为小写、小写转换为大写。
语法如下：
str.swapcase() 此语法中str代表指定检索的字符串，该方法不需要参数。
#示例：
field='Just do it,NOW' 
print('原字符串：',field) #原字符串： Just do   it,NOW 
print('调用swapcase 方法后得到的字符串：',field.swapcase()) #调用swapcase 方法后得到的字符串： jUST DO   IT,now 


（5）replace()方法 --------作用：replace()方法把字符串中的old（旧字符串）替换成new（新字符串），如果指定第3个参数max，替换次数就不超过max次。
语法如下：
str.replace(old, new[, max]) 
此语法中str代表指定检索的字符串；
old代表将被替换的子字符串；
new代表新字符串，用于替换old子字符串；
max代表可选字符串，替换次数不超过max次。

该方法使用示例如下：
field='do it now,do right now' 
print('原字符串：',field) #原字符串： do it now,do right now 
print('新字符串：',field.replace('do','Just do')) #新字符串： Just do it now,Just do right now 
print('新字符串：',field.replace('o','Just',1)) #新字符串： dJust it now,do right now 
print('新字符串：',field.replace('o','Just',2)) #新字符串： dJust it nJustw,do right now 
print('新字符串：',field.replace('o','Just',3)) #新字符串： dJust it nJustw,dJust right now 


（6）split()方法 ------ 作用：通过指定分隔符对字符串进行切片，如果参数num有指定值，就只分隔num个子字符串。
    语法：str.split(st="", num=string.count(str)) 
此语法中str代表指定检索的字符串；
st代表分隔符，默认为空格；
num代表分割次数。

该方法使用示例如下：
field='do it now'
print('不提供任何分割符分隔后的字符串：',field.split()) #不提供任何分割符分隔后的字符串： ['do', 'it', 'now'] 
print('根据o 分隔1 次后的字符串：',field.split('o',1)) #根据o 分隔1 次后的字符串： ['d',' it now']  

由输出结果看到，如果不提供分隔符，程序就会把所有空格作为分割符。


    （7）strip()方法 ------作用：返回结果为移除字符串头尾指定的字符，并生成的新字符串
语法：str.strip([chars]) 
此语法中str代表指定检索的字符串，
chars代表移除字符串头尾指定的字符。

该方法使用示例如下：
field='----do it now----' 
print('原字符串：',field) #原字符串： ----do it now---- 
print('新字符串：',field.strip('-')) #新字符串： do it now 

st='----do -- it -- now----' 
print('原字符串：',st) #原字符串： ----do -- it -- now---- 
print('新字符串：',st.strip('-')) #新字符串： do -- it -- now


-----------------------------------练习10分钟----------------------------------
#####################################################################################################################
#####################################################################################################################
九,字典：
字典是Python中唯一内建的映射类型，字典指定值并没有特殊顺序，都存储在一个特殊的键（Key）里，键可以是数字、字符串或元组。
字典的使用字典这个数据结构的功能就跟它的名字一样，可以像《汉语字典》一样使用。
在使用汉语字典时，我们可以从头到尾一页一页查找某个字，也可以通过拼音索引或笔画索引快速找到某个字，在汉语字典中找拼音索引和笔画索引非常轻松简单。
在Python中对字典进行了构造，让我们可以轻松查到某个特定的键（类似拼音或笔画索引），从而通过键找到对应的值（类似具体某个字）。


假如需要创建一个可以存储学生姓名和学号的小型数据库，应该怎么做呢？
我们尝试使用之前学习过的列表实现，
例如：students=['小萌','小智','小强','小张','小李'] 
numbers=['1001','1002','1003','1004','1005'] 
print('小智的学号是：',numbers[students.index('小智')]) 
 
输出结果是我们想要的，但是当数据量比较大时，显然不适用。


    1.创建和使用字典字典的创建格式如下：
d = {key1 : value1, key2 : value2 } 字典由多个键及其对应的值构成的对组成（把键／值对称为项）。
字典的每个键／值（key/value）对用冒号（:）分割，每个项之间用逗号（,）分割，整个字典包括在花括号({})中
键必须是唯一的，但值不必。值可以取任何数据类型，键必须是不可变的，如字符串、数字或元组。

下面是一个简单的字典示例：
dict = {'小萌': '1001', '小智': '1002', '小强': '1003'} 
dict1 = { 'abc': 456 } 
dict2 = { 'abc': 123, 98.6: 37 } 


2. dict函数可以用dict函数，通过其他映射（如其他字典）或键／值序列对建立字典，
  例如：
student=[('name','小萌'),('number','1001')] 
detail=dict(student) 
print('学生详细信息：',detail) #学生详细信息： {'name': '小萌', 'number': '1001'} 
print('学生姓名：',detail['name']) #学生姓名： 小萌 
print('学生学号：',detail['number']) #学生学号： 1001

由输出结果看到，dict函数可以将序列转换为字典。

3. dict函数可以通过关键字参数创建字典，
例如：
detail=dict(name='小智',number='1002') 
print('学生详细信息：',detail) #学生详细信息： {'name': '小智', 'number': '1002'} 
由输出结果看到，通过关键字参数创建了字典。
通过关键字创建字典功能是dict函数非常有用的一个功能，可以多加运用。

4. 字典的基本操作字典的基本操作在很多方面与序列（sequence）类似，支持修改、删除等操作。下面进行具体的讲解。
   修改字典向字典添加新内容的方法是增加新键／值对，修改或删除已有键／值对，
   （1）添加字典元素
#例如：
student={'小萌':'1001','小智':'1002','小强':'1003'} 
student['小强']='1005' #更新小强的学号 
print('小强的学号是：%(小强)s' % student) #小强的学号是：1005 
student['小张']='1006' #添加一个学生 
print('小张的学号是：%(小张)s' % student) #小张的学号是：1006 由输出结果看到，修改和添加均操作成功。
            。

   （2）. 删除字典元素
此处的删除指的是显式删除，显式删除一个字典用del命令，
例如：
student={'小强': '1005', '小萌': '1001', '小智': '1002', '小张': '1006'} 
print('删除前:',student) #删除前: {'小强': '1005', '小萌': '1001', '小智': '1002', '小张': '1006'} 
del student['小张'] #删除键“小张” 
print('删除后:',student) #删除后: {'小强': '1005', '小萌': '1001', '小智': '1002'} 由输出结果看到对应键／值被正确删除了。

除了删除键，还可以删除整个字典，
例如：
student={'小强': '1005', '小萌': '1001', '小智': '1002', '小张': '1006'} 
print('删除前:',student) #删除前: {'小强': '1005', '小萌': '1001', '小智': '1002', '小张': '1006'}
del student #删除字典 
print('删除后:',student) #NameError: name 'student' is not defined

如果同一个键被赋值两次，后面的值会被记住。
例如：
student={'小萌': '1001', '小智': '1002', '小萌': '1005'} 
print('学生信息：',student) #学生信息： {'小萌': '1005', '小智': '1002'} 

由输出结果看到，一个键被赋值两次，后面的值会被记住。

（3）len函数len（dict）函数用于计算字典元素的个数，即键的总数，
例如：
student={'小萌': '1001', '小智': '1002', '小强': '1005','小张': '1006'} 
print('字典元素个数为：%d 个' % len(student)) #字典元素个数为：4 个 输出结果得到字典元素的个数为4。

（4） type 函数type（variable）函数返回输入的变量类型，如果输入变量是字典就返回字典类型，
例如：
student={'小萌': '1001', '小智': '1002', '小强': '1005','小张': '1006'} 
print('字典的类型为：',type(student))
字典的类型为： <class 'dict'> 输出结果为字典（dict）类型。

5. 字典方法像其他内建类型一样，字典也有方法，这些方法非常有用，不过可能不像使用列表或字符串一样频繁使用。
   
   （1）clear()方法clear()
语法：dict.clear()
      作用：方法用于删除字典内的所有项。此语法中dict代表指定字典，该方法不需要参数。
  
#该方法使用示例如下：
student={'小萌': '1001', '小智': '1002', '小强': '1005','小张': '1006'} 
print('字典元素个数为：%d 个' % len(student)) #字典元素个数为：4 个 
student.clear() 
print('字典删除后元素个数为：%d 个' % len(student)) #字典删除后元素个数为：0 个 

    #由输出结果可知，字典调用clear方法后整个字典内所有项都被删除。
 
　 （2）copy()方法copy()方法返回一个具有相同键/值对的新字典。
语法：dict.copy()
此语法中dict代表指定字典，该方法不需要参数。返回结果为一个字典的浅复制。
该方法使用示例如下：
student={'小萌': '1001', '小智': '1002', '小强': '1005'} 
st=student.copy() 
print('复制后得到的st为：',st) 

#由输出结果看到，使用copy方法可以将字典复制给另一个变量。

   
（3）get()方法
语法：dict.get(key, default=None) 
此语法中：
dict代表指定字典，
key代表字典中要查找的键，
default代表指定键的值不存在时返回默认值。

#该方法返回结果为指定键的值，如果值不在字典中，就返回默认值None。

该方法使用示例如下：
student={'小萌': '1001', '小智': '1002'} 
print ('小萌的学号为: %s' %  student.get('小萌')) #小萌的学号为: 1001

（4）keys()方法
语法：dict.keys() 此语法中dict代表指定字典，该方法不需要参数

    #返回结果为一个字典所有键。

该方法使用示例如下：
student={'小萌': '1001', '小智': '1002'} 
print('字典student所有键为：%s'% student.keys()) #字典student 所有键为：dict_keys(['小萌', '小智'])

(5) values()方法
语法：dict.values() 此语法中dict代表指定字典，该方法不需要参数。

#返回结果为字典中的所有值。

该方法使用示例如下：
student={'小萌': '1001', '小智': '1002','小李':'1001'} 
print('student 字典所有值为：%s'% list(student.values())) #student 字典所有值为：['1001', '1001', '1002'] 


温故知新，学以致用本章主要讲解了字典，在本章结束前回顾一下学到的概念。
（1）如何创建字典，字典有哪些基本操作？
（2）字典常用的方法有哪些，该怎么使用？


尝试思考并解决如下问题：
1）用dict函数实现存储一个人的姓名、手机号和地址信息，字符串名称和值由自己定义和赋值。
2）创建一个字典，里面元素的键／值全部为字符串，然后更改某个元素，更改其值为非字符串形式，如整数、浮点数或元组。
-----------------------------------练习10分钟----------------------------------


#####################################################################################################################
#####################################################################################################################
十，输入和输出
input()  输入
print()  输出


   1，语法结构：
   input
str = input("请输入：");
输入：hsjhdshjhd
print ("你输入的内容是: ", str)

    2，示例：
num=int(input("输入一个数字："))
if num%2==0:
if num%3==0:
print ("你输入的数字可以整除 2 和 3")
else:
print ("你输入的数字可以整除 2，但不能整除 3")
else:
if num%3==0:
print ("你输入的数字可以整除 3，但不能整除 2")
else:
print  ("你输入的数字不能整除 2 和 3")
-----------------------------------练习5分钟----------------------------------
#####################################################################################################################
#####################################################################################################################
十一， 文件
（1）读和写文件
open() 将会返回一个 file 对象，基本语法格式：open(filename, mode)
a, filename：包含了你要访问的文件名称的字符串值。
b, mode：决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。
    mode：
{r 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。
r+ 打开一个文件用于读写。文件指针将会放在文件的开头。
rb+ 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
w 打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
wb 以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
w+ 打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
wb+ 以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
a 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+ 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+ 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。}


# 打开一个文件
f = open("D:/教学\PythonSelenium/001班自动化课件/testfile.txt", "w")
f.write( "Python 是一个非常好的语言。\n是的，的确非常好!!\n" )
# 关闭打开的文件
f.close()

（2）文件对象的方法：
f.read() 为了读取一个文件的内容，调用 f.read(size), 这将读取一定数目的数据, 然后作为字符串或字节对象返回；
size 是一个可选的数字类型的参数。 当 size 被忽略了或者为负, 那么该文件的所有内容都将被读取并且返回.
f = open("D:/教学\PythonSelenium/001班自动化课件/testfile.txt", "r")
str = f.read()
print(str)

（3）f.readline() 会从文件中读取单独的一行。换行符为 '\n'。f.readline() 如果返回一个空字符串, 说明已经已经读取到最后一行。
# 打开一个文件
f = open("D:/教学\PythonSelenium/001班自动化课件/testfile.txt", "r")
str = f.readline()
print(str)


# 关闭打开的文件
f.close()
（4）f.readlines() 将返回该文件中包含的所有行。
# 打开一个文件
f = open("D:/教学\PythonSelenium/001班自动化课件/testfile.txt", "r")
str = f.readlines()
print(str)


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

（5）f.write() f.write(string) 将 string 写入到文件中, 然后返回写入的字符数 。
f = open("D:/教学\PythonSelenium/001班自动化课件/testfile.txt", "w")
num = f.write("baoxiufen鲍秀芬")
print(num)


# 关闭打开的文件
f.close()
-----------------------------------练习10分钟----------------------------------
#####################################################################################################################
#####################################################################################################################
十二，条件控制：
Python条件语句是通过一条或多条语句的执行结果（True或者False）来决定执行的代码块。

1.if...elif语句：


if   判断条件1: 
执行语句1……
elif 判断条件2:
执行语句2…… 
elif 判断条件3: 
执行语句3…… 
else: 
执行语句4……
注意：
1、每个条件后面要使用冒号 :，表示接下来是满足条件后要执行的语句块。
2、使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。
3、在Python中没有switch – case语句。

# 该实例演示了数字猜谜游戏
number = 7
guess = -1
print("数字猜谜游戏!")
while guess != number:
guess = int(input("请输入你猜的数字："))
 
if guess == number:
print("恭喜，你猜对了！")
elif guess < number:
print("猜的数字小了...")
elif guess > number:
print("猜的数字大了...")



if 嵌套：在嵌套 if 语句中，可以把 if...elif...else 结构放在另外一个 if...elif...else 结构中。


if 表达式1:
语句
if 表达式2:
语句
elif 表达式3:
语句
else:
语句
elif 表达式4:
语句
else:
语句

示例1：
num=int(input("输入一个数字："))
if num%2==0:
if num%3==0:
print ("你输入的数字可以整除 2 和 3")
else:
print ("你输入的数字可以整除 2，但不能整除 3")
else:
if num%3==0:
print ("你输入的数字可以整除 3，但不能整除 2")
else:
print  ("你输入的数字不能整除 2 和 3")







3.注意事项：
a)需要多个条件判断时，可以使用 elif 子句
b)一个if语句中可以包含多个 elif 子句，但是结尾只能有一个 else 子句
c) else为可选语句，表示增加一种选择。当在前面条件不成立时可以执行相关语句
d)elif 和 else 不可以单独使用

-----------------------------------练习10分钟----------------------------------
练习：
1.如果输入数字为1-5的数，输出一句话：明星是：陈龙
如果输入不是1-5的数，输出一句话：其他明星

2.判断三角形的满足条件；


#####################################################################################################################
#####################################################################################################################   


十三， 循环语句 for

#for循环基本格式:  
for  变量  in  序列：
语句块


#for循环计数循环
for index in ['python','java','php','C++','ruby','javascript']:
print (index ,len(index))


#for循环遍历字典（key====value）
dic={'name':"chenglong",'age':250,'address':'beijing'}
for key,value in dic.items():
print (key,'<====>',value)
--------------------------------------------------------------------------
range()和xrange()生成器：默认从零开始，包头不包尾（递增）。
range生成器一般用于迭代数量较小的场景。
range(10)  ===>  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

xrange生成器用于迭代数量较大的场景。
>>> xrange(1000) ===>  xrange(1000)

    示例：
# 九九乘法表  （\t是换行）
for i in range(1, 10):
for j in range(1, i+1):
print('{}x{}={}\t'.format(i, j, i*j), end='')
print()
-----------------------------------练习10分钟----------------------------------
练习：
计算1到100的累加和


#####################################################################################################################
#####################################################################################################################
十四，函数：
定义：函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。
作用：函数能提高应用的模块性，和代码的重复利用率。（你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。）


1，定义一个函数:你可以定义一个由自己想要功能的函数，以下是简单的规则：
(1)函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ();
(2)任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数;
(3)函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明;
(4)函数内容以冒号起始，并且缩进;
(5)return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
语法：
def 函数名（参数列表）:
函数体

# 计算面积函数
def area(width, height):
return width * height


a = area(2,3) ----调用函数
print(area(2,3))


# 传可变对象实例
def changeme( mylist ):
   "修改传入的列表"
   mylist.append([1,2,3,4])
   print ("函数内取值: ", mylist)
   return   
# 调用changeme函数
mylist = [10,20,30]
changeme( mylist )
print ("函数外取值: ", mylist)
---------------------------------------------------------
---------------------------------------------------------
函数参数：必须参数，关键字参数，默认参数


1. 必须参数：必须以正确的顺序传入函数。调用时数量必须和声明时一样。
示例：
#我是一个传入参数，我的值是：',str
def paramone(str):          
print('the param is:',str)    
paramone('hello,world') #传入参数为 hello,world


2.关键字参数：
关键字参数和函数调用关系紧密，函数调用使用关键字参数确定传入的参数值。
使用关键字参数允许调用函数时参数的顺序与声明时不一致，因为Python解释器能够用参数名匹配参数值。
示例：
def personinfo(age,name):     
print('年龄：',age)     
print('名称：',name)     
return 
print('-------按参数顺序传入参数-------') 
personinfo(21,'小萌') #不按参数顺序传入参数，指定参数名
personinfo(name='小萌',age=21) #按参数顺序传入参数，并指定参数名


3.默认参数：
调用函数时，如果没有传递参数，就会使用默认参数。
使用默认参数，就是在定义函数时，给参数一个默认值。
def defaultparam(name,age=23):     
print('hi，我叫：',name)     
print('我今年：',age)     
return 
defaultparam('小萌')
-----------------------------------练习10分钟----------------------------------
定义一个函数,输入一个人的名字,返回你好xxx！

#####################################################################################################################
#####################################################################################################################


十五， 类(Class): 
用来描述具有相同的属性和方法的对象的集合。
它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
对象：通过类定义的数据结构实例。
对象包括两个数据成员（类变量和实例变量）和方法。

示例：
class Student(object):
def __init__(self, name, score):
self.name = name
self.score = score


def get_grade(self):
if self.score >= 90:
return 'A'
elif self.score >= 60:
return 'B'
else:
return 'C'


if __name__ == '__main__':
   print(Student('a',95).get_grade())


###########################################################################################################################################################################
###########################################################################################################################################################################


十六，模块
1.定义：在python中，一个.py文件就是一个模块。
2.组成：
a.表达式
b.语句(包含表达式)
c.包和模块(windows下面的文件夹---->包     文件夹下面的文件---->模块(.py文件)
d.程序


3.使用模块的好处：
1.写代码不必从0开始
2.方便调用
3.提高脚本的维护性


4.第三方模块：
selenium  库（一个模块）
BeautifulSoap    爬虫相关
urllib2                和网络相关
urllib3                和网络相关
requests             接口测试相关库 
.......


5.Python模块引用的几种方式
#第一种方式： from 模块名 import 函数或者方法
from  time import ctime,sleep #ctime:获取系统当前显示的时间  sleep：休眠
print ctime() #打印系统当前时间
sleep(5)        #休眠5S


#第二种方式： from 模块名 import *  (* 代表该模块下面的所有的方法或者函数)
from  time import *
print ctime() #打印系统当前时间
sleep(5)      #休眠5S


#第三种方式：  import 模块名 
import  time #导入时间模块
print time.ctime()
time.sleep(5)




###########################################################################################################################################################################
#########################################################################################################################################################
完毕！