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)




###########################################################################################################################################################################
#########################################################################################################################################################
完毕!



没有更多推荐了,返回首页