初识python第一天

一.python简介

1.1 python的诞生

python的创始人吉多.范罗苏姆（Guido van Rossum）,他在开发python语言之前曾使用过几年的ABC语言，ABC是一门主要用于教学的语言（教计算机系的学生如何设计一门开发语言），Guido在开发python时借鉴了很多ABC语言的特性，所以后来人们包括Guido自己也认为，python语言的前生就是ABC语言，关于创作python语言的初衷，Guido在1996年写的到：

在六年前的1989.12月份，我为了在圣诞假期打发无聊时间找点事干（估计是写代码找不到对象，哈哈），决定为我最近一直在构思的一门新语言写个解释器，这门语言的前生ABC（就Guido本人看来，ABC这种语言非常优美和强大，是专门为专业的程序设计师使用的，但是ABC语言没有成功，究其原因，吉多认为是非开放造成的，吉多决心在python中避免这一错误，并取得非常好的效果，完美结合了C和其他一些语言）语言更多是被UNIX/C黑客使用，我选择python这个名字做为这个开发项目的名字，起这个名字的一个原因是因为我是Month Python's Flying Circus(英国的一个电视喜剧)的超级粉丝。就这样，python在Guido手中诞生了。

1.2  常见编程语言的分类

编译型和解释型，静态语言和动态语言，强类型定义语言和弱类型定义语言，那么每个语言代表什么意思呢，我们一起来看看吧！

编译型和解释型：

（1）我们先看看编译型，其实它和其他汇编语言是一样的，也是有一个负责翻译的程序来对我们的源代码进行转换，生产相对应的可执行代码，这个过程说得专业一点，就称为编译（Compile）,而负责编译的程序就称为编译器（Compiler）,编译型语言在程序执行之前，有一个单独的编译过程，将程序翻译成机器语言，以后执行这个程序的时候就不用在进行翻译了。

（2）解释型语言，是在运行的时候将程序翻译成机器语言，所以运行速度相对应编译型语言要慢。

两者的区别：编译型语言就是一次把所有的代码转换成机器语言，然后写成可执行文件，而解释型语言在运行程序的前一刻，还只有程序源而没有可执行文件，而程序每执行到源程序的某一条指令，则会有一个称之为解释程序的外壳程序将源代码转换成二进制代码以供执行，总而言之，就是不断地解释，执行，解释，执行......所以解释型程序离不开解释程序的。编译型和解释型两者各有利有弊，前者由于程序执行速度快，同等条件下对系统要求较低，因此像开发操作系统，大型应用程序，数据库系统等时都采用它，像c/c++，Pascal/Object Pascal(Delphi),VB等基本都可以视为编译语言，而一些网页脚本，服务器脚本挤辅助开发借口这样的对速度要求不高，对不同系统平台间的兼容性有一定要求的程序则通常使用解释型语言，如java,javaScript,VBScript,Perl,Python等。随着设计技术与硬件的不断发展，编译型与解释型两种方式界限正在不断变的模糊。

动态语言和静态语言：

（1）动态语言：动态类型语言是指在运行期间才去做数据类型检查的语言，也就是说，在用动态语言编程时，永远也不用给任何变量指定数据类型，该语言会在你第一次赋值给变量时，在内部将数据类型记录下来，python和Ruby就是一种典型的动态类型语言，其他的各种脚本语言如VBScript也多少属于动态类型语言。

（2）静态类型语言：静态类型语言和动态类型语言刚好相反，它的数据类型是在编译期间检查的，也就是说在写程序时要声明所有变量的数据类型，C/C++就是静态语言的典型代表，其他静态类型语言还有C#,JAVA等。

强类型定义语言和弱类型定义语言：

（1）强类型定义语言：强制数据类型定义的语言。也就是说，一旦一个变量被指定了某个数据类型，如果不经过强制转换，那么它就用于是这个数据类型了，举个例子：如果你定义了一个整型变量a，那么程序不可能将a当作字符串类型处理，强类型定义语言是类型安全的语言。

（2）弱类型定义语言：数据类型可以被忽略的语言，它与强类型定义语言相反，一个变量可以赋不同数据 类型的值。

强类型定义语言在速度上略逊色与弱类型定义语言，但是强类型定义语言带来的严谨性能够有效的避免许多错误，另外“这门语言是不是动态语言”和“这么语言是否类型安全”之间是完全没有联系的！

例如：python是动态语言，是强类型定义语言，VBScript是动态语言，是弱类型定义语言，JAVA是静态语言，是强类型定义语言，

通过上面这些介绍，我们可以看出，python是一门动态解释型的强类型定义语言。

1.3 python的优缺点

python的优点：

（1）python入门简单：python的定位是"优雅，明确，简单”，所有python程序看上去总是简单易懂，初学者学习python，不但入门容易，而且将来深入下去，可以编写那些非常非常复杂的程序。

（2）开发效率高：python有非常强大的第三方库，基本上你想通过计算机实现任何功能，python官方库里都有相应的模块进行支持，直接下载调用后，在基础库的基础上在进行开发，大大降低了开发周期，避免重复造轮子 。

（3）高级语言：当你用python语言编写程序的时候，你无需考虑诸如如何管理你的程序使用的内存一类的底层细节。

（4）可移植性：由于它的开源本质，python已经被移植在许多平台上（经过改动使它能够工作在不同平台上）。

（5）可扩展性：如果你需要你的一段关键代码运行得更快或者希望某些算法不公开，你可以把你的部分用C或C++编写，然后在你的python程序中使用它们。

（6）可嵌入性：你可以把python嵌入到你的C/C++程序，从而像你的程序用户提供脚本功能。

python的缺点：

（1）速度慢：python的运行速度先比C,JAVA语言确实要慢很多，其实这里所指的运行速度慢在大多数情况下用户是无法直接感知的，必须借助测试工具才能体现出来，其实在大多数情况下python已经完全可以满足你多程序速度的要求，除非你要写对速度要求极高的搜索引擎等，这种情况下，当然还是建议你用C去实现。

（2）代码不能加密：因为python是解释型语言，它的源码都是以明文形式存放的。

（3）线程不能利用多CUP问题：这是python被人诟病最多的一个缺点，GIL即全局解释器锁，是计算机程序设计语言解释器用于同步线程的工具，使得如何时刻仅有一个线程在执行，python的线程操作系统是原生线程，在Linux上为pthread,在Windows上为win thread，完全有操作系统调度线程执行，一个python解释器进程内有一条主线程，以及多条用户程序的执行线程，即使在多核CPU平台上，由于GIL的存在，所以禁止多线程的并行执行。

二：常见的python解释器

当我们编写python代码时，我们得到的是一个包含python代码的以.py为扩展名的文本文件，要运行代码，就需要python解释器去执行.py文件。

CPython--这个解释器是用C语言开发的，在命令行下运行python就可启动CPython解释器。CPython是使用最广泛的python解释器。

IPython--IPython是基于CPython之上的一个交互解释器，IPython只是在交互方式上有所增强，但是执行python代码的功能和CPython是完全一样的。

PYPY--PYPY是另一个python解释器，它的目标是执行速度，PYPY采用JIT技术，对python代码进行动态翻译（注意不是解释），所以可以显著提高python代码的执行速度。

Jython--Jython是运行在JAVA平台上的python解释器，可以直接把python代码编译成JAVA字节码执行。

IronPython--IronPython和Jython类型，只不过IronPython是运行在微软.net平台上的Python解释器，可以直接把Python代码编译成.net的字节码。

三：python版本间 的差异

3.1：2.x和3.x版本对比

version	2.x	3.x
print	print""或者print()打印都可以正常输出	只能print()这种形式打印，否则会出现 SyntaxError类型错误
input raw_input	input：输出原生的数据类型，输出什么类型的值，就输出什么类型 raw_input:全部以字符串形式输出	3.x版本取消了raw_input方法，只能使用input方式提示输入字符串，该方法和2.x版本的raw_input()相同 如果想要实现与2.x input()输出原生数据类型值，可以使用eval(input())
class	2.x支持新式类和经典类，使用新式类时，类继承顺序会影响最终继承的结果	必须使用新式类，解决了类之间继承顺序的问题
/	例如：1/2 2.x输出的值为0	例如：1/2 3.x输入的值为0.5

3.2 python的数据类型

int 符号整型	如：1，12，13，-1......  , 在2.x版本中范围在-2**31~2**31-1之间， 取值决定于操作系统，不会下于这个范围
float浮点型	有小数点的，如;1.1  1.2 -1.2......
str字符串	如：“hello world”,"python","1".....,注意,字符串需要用引号，单双引号都可以（“hello world”） 如果不用引号引起来，python就不能把这个值识别为字符串而是识别为一个变量值
bool布尔类型	只有两个值，真：True 假：False ,任何非零的数据类型，结果都为真，当结果为int 0时，则为假
long	这个类型只存在2.x版本中，取值范围无限大，取决于可用的虚拟内存
complex 复数	如：3.34j, 3.453e-7j......
元组tuple	如： （“a”,"hell", "python", "2"）元组中值是不可以改变的
列表list	如：["a","hello", "python", "2"]列表中的值是可以改变的
字典dict	如：｛“name”:"LaiYing","age":25，"job“:”IT"｝字典中的值也是可以改变的

3.3 python编码

python2.x	默认使用string字符编码，1个字符只能存8bit,可以使用内置函数，chr()和ord()进行字符转换
Python3.x	默认使用unicode编码格式，可以使用内置函数unichr()和ord()进行字符转换

3.4 Python的命名规范

（1）所有的Python程序命名规范都应该以.py结尾。这样别人才能一看你的文件后缀名就知道这个是Python程序

（2）在程序的第一行声明要使用的解释器类型

#!/usr/bin/env python      #声明使用python的解释器

（3）Python变量名（标识符）只能以字母，下划线开头，且不能包含特殊字符，注意Python保留关键字不能当作变量名，这样等于重写Python的内置方法，可能会影响其他方法的调用，具体Python关键字如下

#通过导入keyword模块，我们可以查看当前Python保留了哪些关键字
import keyword
 
#查看Python保留的关键字
print(keyword.kwlist)   #在3.x版本中需要print打印出结果
 
#3.x输出以下关键字
['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
 
#2.x输出以下关键字
['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
 
#注意，3.x新增了['False','None','True','nonlocal']同时去除了2.x ['exec']的关键字，大家在命名规范时，应该遵循3.x的关键字，便于向后兼容
 
#如果不确定变量名是否为关键字，也可以通过下面这种方法，检查是否为关键字
 
print(keyword.iskeyword("name"))  #检查name是否为关键字，如果返回值为False就说明该变量名不是系统保留的关键字，即可用

3.5 Python的注释

Python有两种方式注释，一种是当行注释，在语句前加#，也可以多行注释，在你需要注释代码的一行开头和最后一行结尾加上三个 单引号，，也可以使用三个连续的双引号，或者选中需要注释的行然后ctrl+c就即可，例如：

'''import keyword
print(keyword.kwlist)
print(keyword.iskeyword("name"))'''
 
"""f = open("test.log","w")
f.write("This is the first line\n")
f.write("This is the second line\n")
f.write("This is the 3 line\n")
f.write("This is the 4 line\n")
f.write("This is the 5 line\n")"""

3.6 python的语法

Python以简洁著称，摒弃了其他如C的{}夸括号方式书写方式，以及为了追求语言的可读性，强制要求语法缩进，同一个语句块的代码缩进必须相同，否则会出现缩进错误IndentationError,如果想一行写多条语句，可以使用;隔开

3.7Python运算符

算术运算

以下例子 a=10 b=20

运算符	描述	示例
+	加法运算	a+b得30
-	减法运算	a-b得-10
*	乘法运算	a*b得200
/	除法运算	b/a得2
%	取模，将%号左边的值除以%号右边的值并且 将得到结果的余数返回	10%5得0，10%3得1 20%得6
**	幂，返回x的y次幂，就是返回多少次方	2**8得256
//	取整除，返回x除以y的商的整数部分	9//2得4，9.0//2.0得4.0

比较运算

以下例子a=10 b=20

运算符	描述	示例
==	判断两个对象是否相等	（a==b）is not true
!=	判断两个对象是否不相等	（a != b）is true
<>  在3.x版本中已取消	判断两个对象是否不相等	（a<>b）is true与!=运算符一样
>	大于，返回a是否大于b	(a>b)is not true
<	小于，返回a是否小于b	(a<b)is true
>=	大于等于，返回a是否大于等于b	(a>=b)is not true
<=	小于等于，返回a是否小于等于b	(a<=b)is true

赋值运算

以下例子 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

按位运算（二进制运算）

二进制位数	8	7	6	5	4	3	2	1
每位所代表的数字	128	64	32	16	8	4	2	1
60	0	0	1	1	1	1	0	0
13	0	0	0	0	1	1	0	1

好了，我们刚刚知道了10进制如何转2进制了，接下来我们看看如何进行2个10进制数字的位运算

运算符	描述	示例
&	与运算，这个二进制为必须都在2组数中都为真 结果才返回为真	（a & b）得12，二进制位; 0000 1100
|	或运算，这个二进制位只需要在其中一组数据中为真即返回真	（a | b）得61，二进制位； 0011 1101
^	异或运算，只有这个二进制位在两组数据中不相同就返回真	( a ^ b )得49，二进制位； 0011 0001
<<	左移运算，将a整体向左移2位	a << 2得240，二进制位； 1111 0000
>>	右移运算，将a整体向左移3位	a >> 3得7，二进制位； 0000 0111

我们来看看下面的运算过程

二进制位	8	7	6	5	4	3	2	1	结果
每位所代表的数字	128	64	32	16	8	4	2	1
60	0	0	1	1	1	1	0	0
13	0	0	0	0	1	1	0	1
&与运算	0	0	0	0	1	1	0	0	12
|或运算	0	0	1	1	1	1	0	1	61
^异或运算	0	0	1	1	0	0	0	1	49
a<<2	1	1	1	1	0	0	0	0	240
a >>3	0	0	0	0	0	1	1	1	7

逻辑运算符

运算符	描述	示例
and	且，必须左右两个条件都为真，假如一个为假就为假	1 and 0 ,1为真，0为假，其结果为假
or	或，只要一个为真就为真，否则就为假	1 or  0,， 1 为真就为真，只要有一个条件为真就不 继续判断后面的条件了
not	非，取反

四.Python的数据类型操作

4.1 变量赋值操作

什么是变量：变量就是可变的量，就是我们先在内存里开辟一块空间，并给这块空间赋一个名称就是变量名，变量名 = 变量值，这个变量值就是我们往这个空间里存的数据啦，以后我们想再调用这个数据的话，直接通过这个变量名就可以找到了，

#想查看当前的两个变量是否指向同一个内存地址时，可以使用id()方法
a = 3    #将3赋值给a
print(id(a))
#打印结果为1675835664
 
b = a
print(id(b))
#打印结果为1675835664
#可见，a和b指向的都是同一块地址空间，注：以上两个值与使用平台有关，不一定都是一样的数值，但是这两个数值一定是相等的
 
a = 5
print(id(a))
#打印结果为1713125712
 
print(id()b)
#打印结果为1675835664
 
#通过观察两个变量的指针变化，可以发现，a值的改变并不会影响到已经被赋值的的b

4.2 元组（tuple）

#定义一个元组
a = ("a", "b", "python", "")
#打印结果
print(a)
#输出打印结果
('a', 'b', 'python', '')
 
 #查看元组的内置方法
print(dir(a))
#将会输出一个列表形式的方法名称
#2.x 输出['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getslice__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']
#3.x输出['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']
 
#元组提供了两个公用方法给我们使用
a.count("b‘)  #统计这个元组里面有多少个相同的元素"b“，这里只有一个，所以输出结果为1
 
a.index(”b") #返回元素"b“的索引位置，Python的索引位置是从0开始的，所以这里的”b“元素的索引值是1，而不是2
 
#元组的访问方式
a[1]  #显示下标为1的元素，因为元组的下标是从0开始的，所有会显示元素'b'
a[2]  #这里会显示’Python'这个元素
a[0：1] #这里显示元素位置0（包括0）到1（不包括1），即显示'a'
a[0：2] #这里显示元素位置0（包括0）到2（不包括2），即显示（'a', 'b')
a[-1] #显示倒数第一个元素。即‘1'
a[-2] #显示倒是第二个元素，即'python'
a[:-2] #显示元素从位置0（包括）,到位置倒数第二个（不包括倒数第二个），之前的元素都显示出来，即（'a','b'）
a[-2:] :显示元素从位置倒是第二个（包括）到最后一个（包括），即('python', '')
a[0:4:2]  #该方式先将前面的[0:4]条件先筛选出来，然后再进行后面的:2,j即每隔一位取一个值，所以这里将显示('a', 'python')

4.3 列表

列表和元组相似，不同之处在于，元组的值是固定的，不可变的，而列表的值是可以通过其自身的公用方法改变的

#定义一个列表
b = ["a", "b","python", ""]
#查看列表的内置方法
print(dir(b))
#2.x输出['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
 
#3.x输出['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
b.append('tail')  #在列表末尾追加一个元素'tail'
b.count('python') #统计列表中有多少个相同的元素'python'
b.extend('lai')  #在列表后面追加三个字符串'l','a','b'
b.index('python')  #显示元素'python'的索引值，这里将输出2
b.insert(1,'niubi')  #在索引的位置插入元素'niubi'，及原来的元素从1往后加1
b.pop()  #将列表最后一个元素删除
b.remove('python')  #删除指定元素，即将指定的'python'元素删除
b.reverse()  #将列表的元素由原来的从左到右顺序变成了从右到左的方式排序
b.sort()  #将列表按照assci顺序排序，注意！3.x版本的排序是不能同时有多个数据类型一起排序的
b.clear()  #将列表b情况，这个方法3.x才有
a = b.copy()  #将列表b复制给a,这个属性也是只有3.x版本才有

列表的访问方式和元组一样，这里就不在累述了，请参照本章4.2小节内容

4.4 数据类型转换

列表转换成元组

 #定义一个列表
 a = ['a', 'b', 'c']
 #通过type查看变量类型
 print(type(a))
 #输出显示结果为
 <class 'list'>   #类型为列表
 
 #通过tuple函数，将列表转换成元组，我们把新生成的元组赋值给c
 c = tuple(a)
 #现在我们在通过type来查看c的数据类型
 print(type(c))
 #输出显示结果
 <class 'tuple'>   #类型为元组，说明我们现在已经把列表转换为一个新的元组了

元组转换成列表

#由于元组默认是不可更改的，当我们想更改时，应该要怎么办呢？只能将元组转换成列表，将其修改后，再转换成元组形式
#定义一个元组
a = ('a', 'b', 'c')
 
#使用list函数将元组转换成列表，然后赋值给一个新的变量名为c，这样c就有了list函数所拥有的属性了
c = list(a)
#通过type查看c的数据类型
print(type(c))
#输出查看结果，已转换为列表类型了
<class 'list'>
 #我们现在在打印一下c，看看它的输出结果是什么
print(c)
#输出打印结果
['a', 'b', 'c']
 
#通过这种方法，如果我们想在现有的元组基础上做操作修改，可以先转换成列表，列表是可以直接修改元素的，修改完成后，我们再将它转换成元组，重新赋值给a，就可以啦

五 条件判断及循环语句控制

5.1.if...elif...else

if语句语法规则，如果if语句判断为True就会执行它下面的子代码（下层缩进代码），elif的意思就是，如果不满足第一个if条件，那么程序就会继续往下走，在判断是否满足elif条件，如果不满足，就再继续往下走（这里可以加多个elif判断），只要有遇到满足elif的停下来执行它后面的代码，然后结束，如果最后都没有碰到满足的条件，就最终执行else语法（else也不是必须要加的，如果不加else的话，那if条件判断为False的话，那它就什么都不做）

 #if语句语法示例
 
 if  expression:       #表达式
       statement(s)    #代码块
 
 #例如
  if 1 < 2:             #判断1是否小于2
       print('yes")     #如果判断条件为真就打印yes
 
 #也可以执行多个模块
 if 1 < 2:
      print("yes")
      print("hello")
 
  #else语句是结合if或者elif并用的，语法格式如下
 if expression:
      statement(s)
 else:
      statement（s）
 
 if 1 > 2:           #判断1是否大于2
      print("yes")  #如果判断条件为真就打印yes
 else:                #如果以上判断条件为假，就执行else语法
      print("no")    #打印no
 
 #elif多重判断，elif必须与if结合使用的，不能单独直接使用，例如
  if 1 > 2：     #判断条件1是否大于2
     print("yes")  #如果条件为真，1大于2，就打印yes,如果条件为假就执行elif语法
 
 elif 3 >2:       #多重判断，判断3是否大于2
      print("yes") #如果条件为真就打印yes,如果条件为假就执行else语法
 else：
      print("no")   

5.1.1.if...elif...else嵌套使用

 #if嵌套使用语法示例，注意;嵌套判断的语法缩进问题。
 if 1 < 2:           #判断1是否小于2，如果为真就打印yes
     print('yes')
     if 2 > 3:      #嵌套判断，判断2是否大于3，如果判断结果为真就打印yes,如果判断结果为假的执行下一个判断语句elif
         print('yes')
     elif 2 < 3:     #判断2是否小于3，如果判断结果为真就打印yes,如果判断结果为假就执行下一个判断语句else,并输出打印结果
         print('yes')
     else:
         print('no')
 elif 1 > 2:       #判断1是否大于2，如果判断结果为真，就打印yes,如果判断结果为假，就执行下一个判断语句else，并输出打印结果
     print('yes')
 else:
     print('no')    

5.2 循环,while...for

 #while循环语法
 while expression:
     statements(s)
 #例如，当条件为真，则打印yes,是一个无限循环语句
 while True:     #如果对这的True不明白的，比如说要判断1 == 1，如果这个条件为真True，就打印yes
     print('yes')
 
 #通过添加适当的判断语句来结束这个循环语句执行
 #定义一个变量，标记退出
 flag = True
 while flag:
     print("yes")
     if flag:
         flag=False   #把falg的值改为False,这样条件就不满足了，就不会循环执行了
 
 #也可以通过break,或continue关键字去控制语句的输出，break是结束整个循环，而continue是结束当前循环,继续下一个循环，例如
 count = 0
 while True:
     if count >2:    #当条件满足时，则使用break终端语句的执行
         break
     count +=1      #每一次循环都在count基础上加1

 #for循环与while循环，for循环是可以预知循环次数的，不需要人为中断，也能自己结束，而while是需要有一个结束条件的，例如
 
 for iterating_var in sequence:
     statements(s)
 
 #例如
 for number in range(3):   #循环3次
     print(number)
 
 #将会打印出0-2

5.3  and...or...not

 #and(与)，or(或)，not(非)
 
 a = 1
 b = 2
 #and，必须左右两边的条件都为真，如果有一个为假就为假
 if a > 0 and b > a:
     print(a+b)
 
 #  打印结果将输出3，只要其中一个条件不满足，则不会执行语句块的代码
 
 #or，只要有一个为真就为真，否则就为假
 if a < 0 or b>a:
      print(a+b)
 
 #打印结果将输出3，只要有其中任一个条件满足，就执行语句代码块
 
 #not，取反
 if not a:
     print(a+b)
 #这里不会输出任何东西，因为a大于0，为真，只有条件为假，才会执行代码块语句

六 文件操作

6.1 文件操作语法

file object = open(file_name,[access_mode],[buffering])

• file_name:file_name参数是一个字符串值，包含要访问的文件名称
• access_mode:access_mode确定该文件已被打开，即模式，读，写等追加，可能值的一个完整列表在下表中给出，这是可选的参数，默认文件文件访问模式是读（r）
• buffering:如果缓冲值被设置为0，没有缓冲将发生，如果该缓冲值是1，将在访问一个文件进行缓冲，如果指定的缓冲值作为大于1的整数，那么缓冲操作将被用指定缓冲器大小进行，这是可选的参数

6.2 文件访问模式

模式	描述
r	以只读方式打开文件，文件指针放在文件开头，这个是默认模式
rb	以二进制格式读取，文件指针放在文件开头
r+	以读取和写入方式打开文件，文件指针在文件开头
rb+	已二进制读取和写入方式打开文件
w	以只写方式打开文件，如果文件存在，则覆盖文件内容，不存在则创建一个新文件
wb	打开文件以二进制方式写人和读取文件，如果文件存在则覆盖，不存在则创建一个新文件
w+	以写入和读取方式打开文件，如果文件存在则覆盖，不存在则创建一个新文件
wb+	以二进制方式写入和读取文件，如果文件存在则覆盖，不存在则创建一个新文件
a	以追加方式写入文件末尾，如果不存在则创建该文件
ab	以二进制格式追加在文件末尾，不存在则创建该文件
a+	以追加和读取方式打开文件，如果文件存在，文件指针在文件的末尾，如果不存在，则创建新文件并写入和读取

6.3 文件的操作示例

 open_file = open('/root/file.txt',r+)  #以读取和写入方式打开文件
 
 open_file.write('hello world \n')  #写入内容，加上换行符
 
 open_file.close()   #打开文件后，不做操作需要关闭
 
 #文件操作有以下几种方式
 #查看open文件操作的内置方法
 print(dir(open))
 
 #2.x 方法 ['__class__', '__delattr__', '__doc__', '__enter__', '__exit__', '__format__', '__getattribute__', '__hash__', '__init__', '__iter__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'close', 'closed', 'encoding', 'errors', 'fileno', 'flush', 'isatty', 'mode', 'name', 'newlines', 'next', 'read', 'readinto', 'readline', 'readlines', 'seek', 'softspace', 'tell', 'truncate', 'write', 'writelines', 'xreadlines']
 
 #3.x 方法['__call__', '__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__self__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__text_signature__']

 f = open('li.py','r+',encoding='utf-8')
 # f.closed  #判断文件是否关闭，是返回True，不是返回False
 # f.seek(3) # 将光标移动到文件第几个字节处
 # f.tell()  # 查询当前光标在第一个字节处
 # f.encoding # 编码
 # f.truncate(8)  # 从文件第0个字节处到第几个字节处截断，往后的内容丢弃
 # f.flush()  #  刷新，将文件从内存刷到硬盘
#

 class file(object):
 
     def close(self): # real signature unknown; restored from __doc__
         关闭文件
         """
         close() -> None or (perhaps) an integer.  Close the file.
 
         Sets data attribute .closed to True.  A closed file cannot be used for
         further I/O operations.  close() may be called more than once without
         error.  Some kinds of file objects (for example, opened by popen())
         may return an exit status upon closing.
         """
 
     def fileno(self): # real signature unknown; restored from __doc__
         文件描述符
          """
         fileno() -> integer "file descriptor".
 
         This is needed for lower-level file interfaces, such os.read().
         """
         return 0    
 
     def flush(self): # real signature unknown; restored from __doc__
         刷新文件内部缓冲区
         """ flush() -> None.  Flush the internal I/O buffer. """
         pass
 
     def isatty(self): # real signature unknown; restored from __doc__
         判断文件是否是同意tty设备
         """ isatty() -> true or false.  True if the file is connected to a tty device. """
         return False
 
     def next(self): # real signature unknown; restored from __doc__
         获取下一行数据，不存在，则报错
         """ x.next() -> the next value, or raise StopIteration """
         pass
 
     def read(self, size=None): # real signature unknown; restored from __doc__
         读取指定字节数据
         """
         read([size]) -> read at most size bytes, returned as a string.
 
         If the size argument is negative or omitted, read until EOF is reached.
         Notice that when in non-blocking mode, less data than what was requested
         may be returned, even if no size parameter was given.
         """
         pass
 
     def readinto(self): # real signature unknown; restored from __doc__
         读取到缓冲区，不要用，将被遗弃
         """ readinto() -> Undocumented.  Don't use this; it may go away. """
         pass
 
     def readline(self, size=None): # real signature unknown; restored from __doc__
         仅读取一行数据
         """
         readline([size]) -> next line from the file, as a string.
 
         Retain newline.  A non-negative size argument limits the maximum
         number of bytes to return (an incomplete line may be returned then).
         Return an empty string at EOF.
         """
         pass
 
     def readlines(self, size=None): # real signature unknown; restored from __doc__
         读取所有数据，并根据换行保存值列表
         """
         readlines([size]) -> list of strings, each a line from the file.
 
         Call readline() repeatedly and return a list of the lines so read.
         The optional size argument, if given, is an approximate bound on the
         total number of bytes in the lines returned.
         """
         return []
 
     def seek(self, offset, whence=None): # real signature unknown; restored from __doc__
         指定文件中指针位置
         """
         seek(offset[, whence]) -> None.  Move to new file position.
 
         Argument offset is a byte count.  Optional argument whence defaults to
         0 (offset from start of file, offset should be >= 0); other values are 1
         (move relative to current position, positive or negative), and 2 (move
         relative to end of file, usually negative, although many platforms allow
         seeking beyond the end of a file).  If the file is opened in text mode,
         only offsets returned by tell() are legal.  Use of other offsets causes
         undefined behavior.
         Note that not all file objects are seekable.
         """
         pass
 
     def tell(self): # real signature unknown; restored from __doc__
         获取当前指针位置
         """ tell() -> current file position, an integer (may be a long integer). """
         pass
 
     def truncate(self, size=None): # real signature unknown; restored from __doc__
         截断数据，仅保留指定之前数据
         """
         truncate([size]) -> None.  Truncate the file to at most size bytes.
 
         Size defaults to the current file position, as returned by tell().
         """
         pass
 
     def write(self, p_str): # real signature unknown; restored from __doc__
         写内容
         """
         write(str) -> None.  Write string str to file.
 
         Note that due to buffering, flush() or close() may be needed before
         the file on disk reflects the data written.
         """
         pass
 
     def writelines(self, sequence_of_strings): # real signature unknown; restored from __doc__
         将一个字符串列表写入文件
         """
         writelines(sequence_of_strings) -> None.  Write the strings to the file.
 
         Note that newlines are not added.  The sequence can be any iterable object
         producing strings. This is equivalent to calling write() for each string.
         """
         pass
 
     def xreadlines(self): # real signature unknown; restored from __doc__
         可用于逐行读取文件，非全部
         """
         xreadlines() -> returns self.
 
         For backward compatibility. File objects now include the performance
         optimizations previously implemented in the xreadlines module.
         """
         pass