python基础

      作为稍有经验的运维人员，没听说python的恐怕是极少的，有很多做运维的同事已经将python应用到日常的维护工作中。为了赶上时代的步伐，我也开始学习python，并将学习过的知识稍作总结，一来在日后的复习过程中节省时间，二来分享给志同道合的朋友，以求共同进步。下面开始正题。

 目录:

    1.python简介

    2.编译器和解释器

    3.获取帮助

    4.字符编码

    5.变量和基本数据类型

    6.输入与输出

    7.条件判断与循环

    8.文件

第一部分：python简介

        python是一种面向对象的解释型计算机程序设计语言，由荷兰人Guido van Rossum与1989年发明，并与1991年产生第一个公开发行版。python是一门优雅且健壮的编程语言，它易用且功能强大，只要你能想到的事情，python都可以做。

 

第二部分：编译器和解释器

 

第三部分：获取帮助

        python之所以非常强大,几乎可以做任何事情,和它拥有大量的内置模块和第三方外部模块是非常相关的.一个模块有很多相关的功能,我们引入该模块有就可以使用模块中的功能函数实现相关的操作.看下面的例子

>>>import socket
>>>dir(socket)
['AF_APPLETALK',...,'socker'....,'timeout']
>>>help(socket.socket)
Help on class socket in module socket:
class socket(_socket.socket)
 |  A subclass of _socket.socket adding the makefile() method.
 |  
 |  Method resolution order:
 |      socket
 |      _socket.socket
 |      builtins.object
 |  
 |  Methods defined here:
......

        以上部分,第一行,我们导入了'socket'模块,这是一个使用socket传输数据相关模块.接着我们使用内置函数 dir(module_name) 来查看了socket模块包含的以一些功能,这些功能通俗的讲叫方法.我们发现了一个"socket"方法.我们还想继续了解如何使用"socket.socket".寻求某个方法的使用通过python内置函数 help(method_name)来实现.紧接着屏幕上打印了"socket.socket"的一些用法.这样我们就一步步的获取到了帮助文档。

        这里希望你对import 语句有一个大致的了解,知道它是干什么的.并且需要记住dir()和help()函数,并清除他们的用法。

   

第四部分：字符编码

        ASCII，单字节(8个二进制位),可以表示256个不同字符。可表示所有英文字符和许多控制符号。最开始发明计算机的时候，这些字符足够使用。

        UNICODE，计算机相对的普及后，256个字符不能够描述所有语言字符，因此国际组织制定了可以容纳世界上所有文字和符号的字符编码方案。这被称为UNICODE，UNICODE长度至少是2字节(16个二进制位)，可变长度，因此在存放原来ASCII编码那一部分字符时浪费了空间。

        UTF-8，压缩版的UNICODE，兼容ASCII，可变长度，最少1字节,"UTF-8"中,一个中文至少需要3个字节表示。

        gbk，一种汉字编码标准,通常2个字节表示一个汉字。

        这里需要注意的是平时工作中,使用何种编码保存的文件需要使用何种编码打开,如果两个编码不同,一般会出现问题.比如我们写的程序中包含中文,并使用"UTF-8"编码存储。由上面的知识我们知道"UTF-8"中一个中文占3个字节。当我们再读取文件时使用的是"gbk"编码格式读取的,从上面我们知道gbk用2个字节表示一个中文,和"UTF-8"存储中文的字节数不想等,这样就造成了中文乱码的情况。

>>>name='齐得龙东强'
>>>name.encode(encoding='utf-8')
b'\xe9\xbd\x90\xe5\xbe\x97\xe9\xbe\x99\xe4\xb8\x9c\xe5\xbc\xba'
>>>name.encode(encoding='gbk')
b'\xc6\xeb\xb5\xc3\xc1\xfa\xb6\xab\xc7\xbf'

        上面举了个代码实现的例字,可以非常清楚的看出差异.

       

>>>s='李'
#unicode  -->  encode  -->  utf-8(bytes)
#bytes(utf-8)  --> decode --->unicode

>>>s.encode(encoding='utf-8')   
b'\xe6\x9d\x8e'

 

       知识点:

        在python3 中,所有的字符串都被识别并编码成 unicode.在python3中共有两种形式的字符串: str 即 unicode  . bytes 即 str.encode()   的结果.

第五部分：变量和基本数据类型

        变量

        编程语言中，你能够把程序中准备使用的每一段数据都赋给一个简短、易于记忆的名字，这个名字统称变量，下面写个例子。

>>>x = 3
>>>y = x * 5
>>>y
15

        以上x和y就是一个变量，x,y叫做变量名，3,15是变量的值，以后可以用x来代替3，因此我们输入y=x*5 得到 3×5的结果 15。

        变量的值可以是任意可表达的数据类型，但是变量名就有限制了，python中的变量名需要遵循一下规则：

        1).变量名只能包含 字母、数字和下划线，且只能以字母或下划线开头，比如 strings、i、_name、try_3_time都是合法的变量,但 3times、5_trys就不是合法变量名，因为它们以数字开头了。

        2).不能和系统的内置关键字重名，内置关键字可以通过导入keyword模块获取，如下：

>>>import keyword                               #导入keyword模块
>>>_buildin_keyword=keyword.kwlist              #将关键字赋值给_buildin_keyword变量
>>>print(_buildin_keyword)                      #打印变量
4 ['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']  

        变量代表的值有类型，可以通过python内置函数type()查看变量所代表的值的类型.      

x = 3              #type(x)=<class 'int'>     整形
y='hello,world'    #type(y)=<class 'str'>      字符串型
z=False            #type(z)=<class 'bool'>     bool型
h=None             #type(h)=<class 'NoneType'> NoneType

        变量赋值后就可以使用，如下：

>>>strings='hello,world'                        #将'hello,world'赋值给变量'strings'
>>>print('the output strings is :',strings)     #输出一段话,其中包含'strings'变量,python中的',(逗号)'可以起到连接两个字符串的作用.
the output strings is: hello,world

        基本数据类型

        python的基本数据类型包括:字符串、布尔类型、数字类型、列表、元组、字典、集合和日期(之后的课程中讲)类型.下面分别举例字:

       

>>>Name=’maidangna’                                   #字符串型
>>>one_word=’a’                                       #字符串型,但是只有一个字符'a'
>>>count=3                                            #数字类型  整形
>>>price=3.50                                         #数字类型  浮点型
>>>login_state=False                                  #bool类型，是数字类型的一个子集
>>>goods=[‘apple’,’waltermellon’,’pear’,’peach’]      #列表
>>>params=(‘lina’,’123’,7)                            #元组
>>>Persion={‘name’:’lina’,age:23,‘address’:’BJ’}      #字典
>>>numbers={1,2,5,7,0}                                #集合

         字符串

         下面来看字符串的例子,并结合介绍一些常用的字符串的方法(功能):

>>>string_example="this is a test string"       #给变量string_example赋值
>>>string_example.title()                       #将string_example的各个单词首字母大写
   'This Is A Test String'
>>>string_example.capitalize()                  #将string_example的第一个单词字母大写
   'This is a test string'
>>>string_example.split(patten)                 #将string_example以"patten"分割开,如果"patten"为空,则成了['this','is','a','test','string'](一个列表)
   ['this','is','a','test','string']
>>>string_example.index('a')             #在string_example中查找"new_string"中第一次出现的位置,若没有,则返回ValueError异常
   8
>>>string_example.find('z')              #发现string_example中的"new_string"第一次出现的位置,若没有,则返回"-1"
   -1
>>>string_example.count('s')                    #查找's'在string_example中出现的次数   
    4    
>>>string_example.replace('a','A')              #将string_example中的'a'替换为'A'
   'this is A test string'
>>>string_example.join('*-')                    #返回备'*'和'-'包围的string_example
    '*this is a test string-'
>>>string_example.isupper()                     #返回string_example的全部大写字母形式
    False
>>>string_example.islower()                     #返回string_example的全部小写字母形式
    True
>>>string_example.center(50)                    #返回50个长度的字符串,string_example位于中间
    '              this is a test string               '
>>>string_example.strip()                       #如果字符两侧有空格,则去掉两端的空格
    'this is a test string'
>>>string_example.startswith('th')              #判断string_example是否以'th'开头
    True
>>>string_example.endswith('ing')               #判断string_example是否以'ing'结尾
    True
>>>string_example.upper()                       #将string_example的所有字母都大写
    'THIS IS A TEST STRING'
>>>string_example.lower()                       #将string_example的所有字母都小写
    'this is a test string'
>>>string_example.isalnum()                     #判断string_example是否都是可识别字符串
    True
>>>string_example.isalpha()                     #判断string_example是否是字母组成
    False
>>>string_example.isdigit()                     #判断string_example是否是数字组成
    False
>>>string_example.isspace()                     #判断string_example是否是空格组成
    False
>>>string_example.istitle()                     #判断string_example是否每个单词首字母大写
    False 

         bool类型

        我们有时需要对结果进行"是"与"不是"的判断,比如,返回值等于10,5大于3等等.总之结果只有两种情况:"是"与"不是" ,在编程中我们将做"真"与"假", "是"的情况就是"真",程序中用"True"表示,相反的就"不是",是"假",程序中用"False"表示.如下面的例子:

>>>5>3                 #5大于3,所以返回值为"真",即True
True
>>>1>10                #1小于10,所以返回是"假",即False
False
>>>2==2                #2等于2,所以返回值是"真",即True
True
>>>a=2                  #赋值,变量a赋值为2
>>>b=2                  #赋值,变量b赋值为2
>>>a == b               #a等于b,因为a,b都是2,所以返回"真",即True
True
>>>a != b               #a和b都是2,所以a不等于b是"假",即返回Flase
False

 

         数字

        相信数字大家最不陌生了,平时少不了和数字打交道.在计算机编程语言中,数字分为"整形","浮点型","科学型",下面举例字学习:

>>>a = 10                           #a赋值10
>>>b = 3                             #b赋值3
>>>a / b                            #a处以b
3.3333333333333335
>>>a//b                             #a除以b,只留下整数部分
3
>>>a%b                              #a与b取余数
1

        整数类型常用函数:bit_length()

>>>a = 37                            #将37 赋值给a
>>>a.bit_length()                    #a用至少多少个二进制位表示
6                                    #100101

 

         列表

        示例：

1 >>> li = [1,2,False,'xiaoming']

        很多时候我们需要一个数据结构能够存储相同或不同类型的多个值。比如，描述一个果篮，果篮中有苹果、梨、桃子、西瓜等等。并且果篮中可以随时放进其他水果。python中有了一个这样的数据结构：列表(list)。以上面的果篮为例子，我可以这样写：

1 >>>fruit_basket=['apple','pear','peach','watermelon']  

        好了一个果篮的列表就创建好了，列表两侧由’ [ ‘ 和 ’ ] ‘ 扩起来，在python中有' [ ' 和 ' ] '包含的元素就形成一个列表。

        下面就结合例子学习下列表的常用属性：

1 >>>fruit_basket[0]      #访问列表的第一个元素，列表的索引从0开始，即返回索引为0处的元素
2  ’apple'                                                 
3 >>>fruit_basket[0:2]     #访问列表的第一个和第二个元素，到索引为2时结束，不包含索引2,
4 ['apple','pear']
5 >>>fruit_basket[0:3:2]     #访问列表第一个元素到第三个元素，隔一个元素显示一个元素，即只返回第一个元素，第三个元素，fruit_basket[0] fruit_basket[2]
6 ['apple','peach'] 
7 >>>fruit_basket.append('kiwi')       # 向fruit_brasket中 添加 “猕猴桃”          ['apple',pear','peach','watermelon','kiwi']
8 >>>del fruit_basket[0]       #删除列表索引为0的元素，删除'apple‘，列表现在成为 ['pear','peach','watermelon','kiwi']

        列表几个常用的方法append(),copy(),count(),extend(),index(),insert(),remove(),reverse(),sort(). 下面举例子：

>>>a=[1,2,3,4,5,6,7,8,9]                          #初始化a为列表
>>>a.append(0)                                    #给a追加元素0
>>>a
[1,2,3,4,5,6,7,8,9,0]
>>>b=a.copy()                                      #将a的元素拷贝给b
>>>b
[1,2,3,4,5,6,7,8,9,0]
>>>a.count(1)                                      #计算a中数字1的个数
1
>>>a.extend(b)                                     #为列表a追加列表b
>>>a
[1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0]
>>>a.index(4)                                      #获得a中第一个数字4的索引
3 
>>>a.insert(0,100)                                 #在a[0]处添加数字100
>>>a
[100,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0]
>>>a.remove(100)                                    #删除a中的数字100
>>>a
[1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0]
>>>a.reverse()                                       #反转a的元素
>>>a
[0,9,8,7,6,5,4,3,2,1,0,9,8,7,6,5,4,3,2,1]
>>>a.sort()                                           #对a进行排序
>>>a
[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9]

            遍历列表：

1 >>>for value in nums:
2 . . .  print(value,end=',')
3 >>>1,3,5,7,9,2,4,6,8,

         元组

        示例：

1 tu = (1,2,'name','xiaoming',False)

        元组和列表外表看起来很相似，不同的是列表用放括号扩起来，元组用元括号扩起来。元组是不可变的，即元组不能增加元素也不能删除元素。

        元组几个常用的方法count() . index()  下面举例子:

 

1 >>> tu = ('a','b','user','name','a',1,100)
2 >>> tu.count('a')             #获得‘a'的数量
3 2
4 >>> tu.index('a')              #获取第一个’a'的索引
5 0 

         字典

        示例：

1 >>> dic = {'name':'xiaoming','age':15,'address':['Beijing','Chaoyang','Sanlitun'] }       

      字典是一种包含  键:值  对的数据结构。其中键 必须是不可变的(可hash）的。

      字典添加元素：

 1 >>>dic={'name':'xiao ming','age':15,'address':['Beijing','Chaoyang','Sanlitun']}
 2 >>>dic['new_value'] = 'new value'        #向字典添加元素
 3 >>>del dic['new_value']                       #删除dic中的 new_value
 4 #遍历字典的键
 5 >>>for key in dic.keys():
 6 . . .     print(key,end='|')
 7 name|age|address|
 8 
 9 #遍历字典的值
10 >>>for value in dic.values():
11 . . .     print(value,end='|')
12 
13 xiao ming|15|['Beijing','Chaoyang','Sanlitun']|

 

第六部分：输入与输出

        1. 输出

        python3中的输出由内置函数print()来执行，如下例子：

>>>print('this is a test')
this is a test

        还可以结合上面说的变量来格式化字符串输出：

>>>name='xiao ming'
>>>print('my name is %s' % name)
my name is xiao ming

        上面例子"%s"可以理解为"占位符"，说明后面的变量要输出在这里，字符串后面的 ' %' 是不可缺少的，它告诉python，用后面对应的变量放到"占位符"位置。下面在列举其他print()的几个例子

>>>name='xiao ming'
>>>age=15
>>>print("My name is %s,I'm %d years old" % (name,age))
My name is xiao ming,I'm 15 years old

        2.输入

        python3中输入可以由内置函数input()实现，input中可以设置输入前要输出的字符串,input()函数默认返回一个字符串，如果想转换返回为其他类型，使用其他工厂函数转换。如下例子

>>>age=input('Input your age here: ')
Input your age here: 15          #age='15',现在age是一个字符串，需要int()函数转换为整数
>>>print('Your are %d years old' % int(age))
Your are 15 years old
>>>password=input('Input your password here: ')
Input your password here: 123456 #输出的密码显示出来了，大家都可以看到

         针对输入密码这类问题，python内置了一个模块来处理，这个模块是getpass，getpass模块的getpass()函数会解决输入密码显示的问题。如下：

>>>import getpass
>>>password=getpass.getpass('Input your password here: ')
Input your password here:            #现在输入密码不会显示出来了

        例子：

        提示输入用户名、密码和年龄，最后将用户名和年龄打印出来。

>>>import getpass                   #导入getpass模块
>>>name=input('Input your name: ')
Input your name: xiao ming     #输入姓名
>>>password=getpass.getpass('Input your password: ')
Input your password:              #输入密码
>>>age=input('Input your age: ')
Input your age: 15                 #输入年龄
>>>print('Your name is %s,your are %d years old' % (name,int(age))
Your name is xiao ming,your are 15 years old

第七部分：条件判断与循环

        1.条件判断

            python中的条件判断有if-else执行，语法如下：

if expression_1:
    do_some_things_1
elif expression_2:
    do_some_things_2
... ...
else:
    do_other_things

            如上 expression_1 成立，则执行 do_some_things_1语句块， 如果 expression_2 成立，则执行 do_some_things_2，以此类推，如果所有的条件都不成立，则执行 do_other_things 语句块。

             举个例子，输入分数，60分以下为“不及格”，60-70为“差”，70-80为“可”，80-90为“良”，90-100为“优”

score=int(input('Input score: '))                #提示用户输入分数
    if score < 60:
        print('不及格')
    elif 60 <= score < 70:
        print('差')
    elif 70 <= score <80:
        print('可')
    elif 80 <= score < 90:
        print('良')
    elif 90 <= score <=100:
        print('优')
    else:
        print('输入不识别')

        2.循环

         循环有for循环和while循环，for循环一般用于确定知道循环次数的情况，while循环一般用于无法计算循环次数的情况

         for循环语法如下：

for iter_var in iterable:
    suite_to_repeat

          例子如下：

>>>for value in range(10):
. . .  print(value,end=' ')
3 0 1 2 3 4 5 6 7 8 9

        while循环语法如下:

while expression:
    suite_to_repeat

           例子如下,用户输入不是‘q’的情况下，要求用户一直输入：

choice=input('Input your choice (q to quit): ')
while True:
    if choice!='q':
        print('continue')
    elif choice=='q':
        print('break')
        break
    choice=input('Input your choice (q to quit): ')

       

 第七步分：文件

编程免不了要和文件打交道，下面介绍一些关于文件的操作。

filename = 'config.ini'             #文件名称
f=open(filename,mode='r',encoding='utf-8')                #以‘读’的方式打开文件
content=f.read()                    #将文件内容赋值给content变量
f.close()                           #读完的文件需要关闭

此处给了open()函数两个参数：文件名称和打开方式(r)还有其他模式(写:w,二进制打开:b,追加模式:a)，其他详细的描述可以使用 help(open) 来查看。open()打开的文件，需要在执行 close(),否则容易导致读写出现问题。还可以使用另一种比较优雅且安全的方式打开文件，读取内容：

with open(filename,'r',encoding='utf-8') as f:
    content=f.read()

print(content)

 写文件的例子：

a='this is a new string'
with open(filename,'w',encoding='utf-8') as f:
    f.write(a)

文件的其他操作的例子:

　　　同时打开两个文件:

with open('a.txt',mode='r',encoding='utf-8') as r_f,open('b.txt','w') as w_f:
    w_f.write(r_f.read())

 f.read(bytes),f.seek(offset,whence)

with open('f.txt','r',encoding='utf-8') as f:
    first_byte=f.read(1)      #f.read(int_num)   从f中读取int_num个字节
    f.seek(0,2)                  #f.seek(0,2) 从文件末尾开始读
    while True:
        content=f.read()     #从文件末尾开始读文件,实现linux类似 'tail -f file'   的效果
        print(content)
    

 做一个例子,模拟shell中'tail -f 文件'的效果

#!/usr/bin/env python
import time

with open('a.txt','r',encoding='utf-8') as f:
    f.seek(0,2)                  #到文件末尾
    while True:
        content=f.read().strip()  #获取新加入a.txt文件的字符
        print(content)
        time.sleep(3)               #sleep 3 seconds