Python编程中常用的12种基础知识总结 - 文章 - 伯乐在线
& Python编程中常用的12种基础知识总结
Python编程中常用的12种基础知识总结：正则表达式替换，遍历目录方法，列表按列排序、去重，字典排序，字典、列表、字符串互转，时间对象操作，命令行参数解析(getopt)，print 格式化输出，进制转换，Python调用系统命令或者脚本，Python 读写文件。
1、正则表达式替换
目标: 将字符串line中的 overview.gif 替换成其他字符串
&&& line = '&IMG ALIGN="middle" SRC=\'#\'" /span&
&&& pile(r'(?&=SRC=)"([\w+\.]+)"',re.I)
&&& mo.sub(r'"\1****"',line)
'&IMG ALIGN="middle" SRC=\'#\'" /span&
&&& mo.sub(r'replace_str_\1',line)
'&IMG ALIGN="middle" replace_str_overview.gif BORDER="0" ALT=""&'& /span&
&&& mo.sub(r'"testetstset"',line)
'&IMG ALIGN="middle" SRC=\'#\'" /span&
1234567891011
&&& line = '&IMG ALIGN="middle" SRC=\'#\'" /span& &&& pile(r'(?&=SRC=)"([\w+\.]+)"',re.I)&&&&&& mo.sub(r'"\1****"',line)&&'&IMG ALIGN="middle" SRC=\'#\'" /span& &&&& mo.sub(r'replace_str_\1',line)&&'&IMG ALIGN="middle" replace_str_overview.gif BORDER="0" ALT=""&'& /span& &&&& mo.sub(r'"testetstset"',line)&&'&IMG ALIGN="middle" SRC=\'#\'" /span&
注意: 其中 \1 是匹配到的数据，可以通过这样的方式直接引用
2、遍历目录方法
在某些时候，我们需要遍历某个目录找出特定的文件列表，可以通过os.walk方法来遍历，非常方便
fileList = []
rootdir = "/data"
for root, subFolders, files in os.walk(rootdir):
if '.svn' in subFolders: subFolders.remove('.svn')
# 排除特定目录
for file in files:
if file.find(".t2t") != -1:# 查找特定扩展名的文件
file_dir_path = os.path.join(root,file)
fileList.append(file_dir_path)
print fileList
1234567891011
import osfileList = []rootdir = "/data"for root, subFolders, files in os.walk(rootdir):if '.svn' in subFolders: subFolders.remove('.svn')&&# 排除特定目录for file in files:&&if file.find(".t2t") != -1:# 查找特定扩展名的文件&&&&&&file_dir_path = os.path.join(root,file)&&&&&&fileList.append(file_dir_path)&&&print fileList
3、列表按列排序(list sort)
如果列表的每个元素都是一个元组(tuple),我们要根据元组的某列来排序的化，可参考如下方法
下面例子我们是根据元组的第2列和第3列数据来排序的,而且是倒序(reverse=True)
&&& a = [('', '2.26', 6429600, '0.0'), ('', '2.26', , '-3.0'),
('', '2.33', ,'-19.1')]
&&& print a[0][0]
&&& b = sorted(a, key=lambda result: result[1],reverse=True)
&&& print b
[('', '2.33', , '-19.1'), ('', '2.26', 6429600, '0.0'),
('', '2.26', , '-3.0')]
&&& c = sorted(a, key=lambda result: result[2],reverse=True)
&&& print c
[('', '2.33', , '-19.1'), ('', '2.26', , '-3.0'),
('', '2.26', 6429600, '0.0')]
123456789101112
&&& a = [('', '2.26', 6429600, '0.0'), ('', '2.26', , '-3.0'), ('', '2.33', ,'-19.1')]&&& print a[0][0]2011-03-17&&& b = sorted(a, key=lambda result: result[1],reverse=True)&&& print b[('', '2.33', , '-19.1'), ('', '2.26', 6429600, '0.0'),('', '2.26', , '-3.0')]&&& c = sorted(a, key=lambda result: result[2],reverse=True)&&& print c[('', '2.33', , '-19.1'), ('', '2.26', , '-3.0'),('', '2.26', 6429600, '0.0')]
4、列表去重(list uniq)
有时候需要将list中重复的元素删除，就要使用如下方法
&&& lst= [(1,'sss'),(2,'fsdf'),(1,'sss'),(3,'fd')]
&&& set(lst)
set([(2, 'fsdf'), (3, 'fd'), (1, 'sss')])
&&& lst = [1, 1, 3, 4, 4, 5, 6, 7, 6]
&&& set(lst)
set([1, 3, 4, 5, 6, 7])
&&& lst= [(1,'sss'),(2,'fsdf'),(1,'sss'),(3,'fd')]&&& set(lst)set([(2, 'fsdf'), (3, 'fd'), (1, 'sss')])&&&&&& lst = [1, 1, 3, 4, 4, 5, 6, 7, 6]&&& set(lst)set([1, 3, 4, 5, 6, 7])
5、字典排序(dict sort)
一般来说，我们都是根据字典的key来进行排序，但是我们如果想根据字典的value值来排序，就使用如下方法
&&& from operator import itemgetter
&&& aa = {"a":"1","sss":"2","ffdf":'5',"ffff2":'3'}
&&& sort_aa = sorted(aa.items(),key=itemgetter(1))
&&& sort_aa
[('a', '1'), ('sss', '2'), ('ffff2', '3'), ('ffdf', '5')]
&&& from operator import itemgetter&&& aa = {"a":"1","sss":"2","ffdf":'5',"ffff2":'3'}&&& sort_aa = sorted(aa.items(),key=itemgetter(1))&&& sort_aa[('a', '1'), ('sss', '2'), ('ffff2', '3'), ('ffdf', '5')]
从上面的运行结果看到，按照字典的value值进行排序的
6、字典,列表,字符串互转
以下是生成数据库连接字符串,从字典转换到字符串
&&& params = {"server":"mpilgrim", "database":"master", "uid":"sa", "pwd":"secret"}
&&& ["%s=%s" % (k, v) for k, v in params.items()]
['server=mpilgrim', 'uid=sa', 'database=master', 'pwd=secret']
&&& ";".join(["%s=%s" % (k, v) for k, v in params.items()])
'server=uid=database=pwd=secret'
&&& params = {"server":"mpilgrim", "database":"master", "uid":"sa", "pwd":"secret"}&&& ["%s=%s" % (k, v) for k, v in params.items()]['server=mpilgrim', 'uid=sa', 'database=master', 'pwd=secret']&&& ";".join(["%s=%s" % (k, v) for k, v in params.items()])'server=uid=database=pwd=secret'
下面的例子 是将字符串转化为字典
&&& a = 'server=uid=database=pwd=secret'
&&& aa = {}
&&& for i in a.split(';'):aa[i.split('=',1)[0]] = i.split('=',1)[1]
{'pwd': 'secret', 'database': 'master', 'uid': 'sa', 'server': 'mpilgrim'}
&&& a = 'server=uid=database=pwd=secret'&&& aa = {}&&& for i in a.split(';'):aa[i.split('=',1)[0]] = i.split('=',1)[1]...&&& aa{'pwd': 'secret', 'database': 'master', 'uid': 'sa', 'server': 'mpilgrim'}
7、时间对象操作
将时间对象转换成字符串
&&& import datetime
&&& datetime.datetime.now().strftime("%Y-%m-%d %H:%M")
时间大小比较
&&& import time
&&& t1 = time.strptime(' 14:05',"%Y-%m-%d %H:%M")
&&& t2 = time.strptime(' 16:05',"%Y-%m-%d %H:%M")
&&& t1 & t2
&&& t1 & t2
时间差值计算,计算8小时前的时间
&&& datetime.datetime.now().strftime("%Y-%m-%d %H:%M")
&&& (datetime.datetime.now() - datetime.timedelta(hours=8)).strftime("%Y-%m-%d %H:%M")
将字符串转换成时间对象
&&& endtime=datetime.datetime.strptime('',"%Y%m%d")
&&& type(endtime)
&type 'datetime.datetime'&
&&& print endtime
00:00:00 UTC 到现在的秒数，格式化输出
&&& import time
&&& time.strftime("%Y-%m-%d %H:%M:%S",time.localtime(a))
' 13:23:48'
123456789101112131415161718192021222324252627282930313233
将时间对象转换成字符串&&& import datetime&&& datetime.datetime.now().strftime("%Y-%m-%d %H:%M")&&' 14:05' &时间大小比较&&& import time&&& t1 = time.strptime(' 14:05',"%Y-%m-%d %H:%M")&&& t2 = time.strptime(' 16:05',"%Y-%m-%d %H:%M")&&& t1 & t2&&False&&& t1 & t2&&True &时间差值计算,计算8小时前的时间&&& datetime.datetime.now().strftime("%Y-%m-%d %H:%M")&&' 15:02'&&& (datetime.datetime.now() - datetime.timedelta(hours=8)).strftime("%Y-%m-%d %H:%M")&&' 07:03' &将字符串转换成时间对象&&& endtime=datetime.datetime.strptime('',"%Y%m%d")&&& type(endtime)&&&type 'datetime.datetime'&&&& print endtime&&2010-07-01 00:00:00 &将从 1970-01-01 00:00:00 UTC 到现在的秒数，格式化输出&& &&&& import time&&& a = &&& time.strftime("%Y-%m-%d %H:%M:%S",time.localtime(a))&&' 13:23:48'
8、命令行参数解析(getopt)
通常在编写一些日运维脚本时，需要根据不同的条件，输入不同的命令行选项来实现不同的功能 在Python中提供了getopt模块很好的实现了命令行参数的解析,下面距离说明。请看如下程序:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys,os,getopt
def usage():
print '''''
Usage: analyse_stock.py [options...]
-e : Exchange Name
-c : User-Defined Category Name
-f : Read stock info from file and save to db
-d : delete from db by stock code
-n : stock name
-s : stock code
-h : this help info
test.py -s haha -n "HA Ha"
opts, args = getopt.getopt(sys.argv[1:],'he:c:f:d:n:s:')
except getopt.GetoptError:
sys.exit()
if len(opts) == 0:
sys.exit()
for opt, arg in opts:
if opt in ('-h', '--help'):
sys.exit()
elif opt == '-d':
print "del stock %s" % arg
elif opt == '-f':
print "read file %s" % arg
elif opt == '-c':
print "user-defined %s " % arg
elif opt == '-e':
print "Exchange Name %s" % arg
elif opt == '-s':
print "Stock code %s" % arg
elif opt == '-n':
print "Stock name %s" % arg
sys.exit()
1234567891011121314151617181920212223242526272829303132333435363738394041424344
#!/usr/bin/env python# -*- coding: utf-8 -*-import sys,os,getoptdef usage():print '''''Usage: analyse_stock.py [options...]Options:-e : Exchange Name-c : User-Defined Category Name-f : Read stock info from file and save to db-d : delete from db by stock code-n : stock name-s : stock code-h : this help infotest.py -s haha -n "HA Ha"''' &try:opts, args = getopt.getopt(sys.argv[1:],'he:c:f:d:n:s:')except getopt.GetoptError:usage()sys.exit()if len(opts) == 0:usage()sys.exit()&&&for opt, arg in opts:if opt in ('-h', '--help'):&&usage()&&sys.exit()elif opt == '-d':&&print "del stock %s" % argelif opt == '-f':&&print "read file %s" % argelif opt == '-c':&&print "user-defined %s " % argelif opt == '-e':&&print "Exchange Name %s" % argelif opt == '-s':&&print "Stock code %s" % argelif opt == '-n':&&print "Stock name %s" % arg&&&sys.exit()
9、print 格式化输出
9.1、格式化输出字符串
截取字符串输出,下面例子将只输出字符串的前3个字母
&&& str="abcdefg"
&&& print "%.3s" % str
按固定宽度输出，不足使用空格补全,下面例子输出宽度为10
&&& str="abcdefg"
&&& print "%10s" % str
截取字符串，按照固定宽度输出
&&& str="abcdefg"
&&& print "%10.3s" % str
浮点类型数据位数保留
&&& import fpformat
&&& a= 0.5
&&& b=fpformat.fix(a,6)
&&& print b
对浮点数四舍五入,主要使用到round函数
&&& from decimal import *
&&& a ="2.26"
&&& b ="2.29"
&&& c = Decimal(a) - Decimal(b)
&&& print c
&&& c / Decimal(a) * 100
Decimal('-1.177')
&&& Decimal(str(round(c / Decimal(a) * 100, 2)))
Decimal('-1.33')
1234567891011121314151617181920212223242526272829
截取字符串输出,下面例子将只输出字符串的前3个字母&&& str="abcdefg"&&& print "%.3s" % str&&abc按固定宽度输出，不足使用空格补全,下面例子输出宽度为10&&& str="abcdefg"&&& print "%10s" % str&&&& abcdefg截取字符串，按照固定宽度输出&&& str="abcdefg"&&& print "%10.3s" % str&&&&&&&& abc浮点类型数据位数保留&&& import fpformat&&& a= 0.5&&& b=fpformat.fix(a,6)&&& print b&&0.003000对浮点数四舍五入,主要使用到round函数&&& from decimal import *&&& a ="2.26"&&& b ="2.29"&&& c = Decimal(a) - Decimal(b)&&& print c&&-0.03&&& c / Decimal(a) * 100&&Decimal('-1.177')&&& Decimal(str(round(c / Decimal(a) * 100, 2)))&&Decimal('-1.33')
9.2、进制转换
有些时候需要作不同进制转换，可以参考下面的例子(%x 十六进制,%d 十进制,%o 八进制)
&&& num = 10
&&& print "Hex = %x,Dec = %d,Oct = %o" %(num,num,num)
Hex = a,Dec = 10,Oct = 12
&&& num = 10&&& print "Hex = %x,Dec = %d,Oct = %o" %(num,num,num)&&Hex = a,Dec = 10,Oct = 12
10、Python调用系统命令或者脚本
使用 os.system() 调用系统命令 , 程序中无法获得到输出和返回值
&&& import os
&&& os.system('ls -l /proc/cpuinfo')
&&& os.system("ls -l /proc/cpuinfo")
-r--r--r-- 1 root root 0
3月 29 16:53 /proc/cpuinfo
使用 os.popen() 调用系统命令, 程序中可以获得命令输出，但是不能得到执行的返回值
&&& out = os.popen("ls -l /proc/cpuinfo")
&&& print out.read()
-r--r--r-- 1 root root 0
3月 29 16:59 /proc/cpuinfo
使用 commands.getstatusoutput() 调用系统命令, 程序中可以获得命令输出和执行的返回值
&&& import commands
&&& commands.getstatusoutput('ls /bin/ls')
(0, '/bin/ls')
12345678910111213141516
使用 os.system() 调用系统命令 , 程序中无法获得到输出和返回值&&& import os&&& os.system('ls -l /proc/cpuinfo')&&& os.system("ls -l /proc/cpuinfo")&&-r--r--r-- 1 root root 0&&3月 29 16:53 /proc/cpuinfo&&0 &使用 os.popen() 调用系统命令, 程序中可以获得命令输出，但是不能得到执行的返回值&&& out = os.popen("ls -l /proc/cpuinfo")&&& print out.read()&&-r--r--r-- 1 root root 0&&3月 29 16:59 /proc/cpuinfo&&&使用 commands.getstatusoutput() 调用系统命令, 程序中可以获得命令输出和执行的返回值&&& import commands&&& commands.getstatusoutput('ls /bin/ls')&&(0, '/bin/ls')
11、Python 捕获用户 Ctrl+C ,Ctrl+D 事件
有些时候，需要在程序中捕获用户键盘事件，比如ctrl+c退出，这样可以更好的安全退出程序
do_some_func()
except KeyboardInterrupt:
print "User Press Ctrl+C,Exit"
except EOFError:
print "User Press Ctrl+D,Exit"
try:&&&&do_some_func()except KeyboardInterrupt:&&&&print "User Press Ctrl+C,Exit"except EOFError:&&&&print "User Press Ctrl+D,Exit"
12、Python 读写文件
一次性读入文件到列表，速度较快，适用文件比较小的情况下
track_file = "track_stock.conf"
fd = open(track_file)
content_list = fd.readlines()
fd.close()
for line in content_list:
print line
逐行读入，速度较慢,适用没有足够内存读取整个文件(文件太大)
fd = open(file_path)
fd.seek(0)
title = fd.readline()
keyword = fd.readline()
uuid = fd.readline()
fd.close()
写文件 write 与 writelines 的区别
Fd.write(str) : 把str写到文件中，write()并不会在str后加上一个换行符
Fd.writelines(content) : 把content的内容全部写到文件中,原样写入，不会在每行后面加上任何东西
1234567891011121314151617181920
一次性读入文件到列表，速度较快，适用文件比较小的情况下track_file = "track_stock.conf"fd = open(track_file)content_list = fd.readlines()fd.close()for line in content_list:&&&&print line&&&逐行读入，速度较慢,适用没有足够内存读取整个文件(文件太大)fd = open(file_path)fd.seek(0)title = fd.readline()keyword = fd.readline()uuid = fd.readline()fd.close()&&&写文件 write 与 writelines 的区别&& &Fd.write(str) : 把str写到文件中，write()并不会在str后加上一个换行符Fd.writelines(content) : 把content的内容全部写到文件中,原样写入，不会在每行后面加上任何东西
可能感兴趣的话题
9.2 进制转换，“有些时候需要作不同进制转换，可以参考下面的例子(%x 十六进制,%d 十进制,%o 十进制)” ，"%o"是指的八进制呢
关于伯乐在线博客
在这个信息爆炸的时代，人们已然被大量、快速并且简短的信息所包围。然而，我们相信：过多“快餐”式的阅读只会令人“虚胖”，缺乏实质的内涵。伯乐在线内容团队正试图以我们微薄的力量，把优秀的原创文章和译文分享给读者，为“快餐”添加一些“营养”元素。
新浪微博：
推荐微信号
（加好友请注明来意）
– 好的话题、有启发的回复、值得信赖的圈子
– 分享和发现有价值的内容与观点
– 为IT单身男女服务的征婚传播平台
– 优秀的工具资源导航
– 翻译传播优秀的外文文章
– 国内外的精选文章
– UI,网页，交互和用户体验
– 专注iOS技术分享
– 专注Android技术分享
– JavaScript, HTML5, CSS
– 专注Java技术分享
– 专注Python技术分享
& 2017 伯乐在线有一定的基础，如何学python？ - 知乎492被浏览29463分享邀请回答pypi.python.org/pypi提交你的Package吧！研究研究Python大型开源项目源代码。研究CPython的编码实现，可从Python C API开始。Coding! Coding!...（不行我已经编不下去了，现在我还处在刷reference/pep doc的阶段）感谢你的阅读，如有用，请点赞；如无用，请喷之！963 条评论分享收藏感谢收起/notes/python/)我实在很难想象有比这本书更合适的入门教程。100页左右，覆盖了Python最重要的主线知识点，几乎没有一句废话。代码熟练工大约3、4个小时就可以收工，成就感斐然！ (书中末尾给出了深入学习Python的方案，欢迎继续升级！)---------------------------------------------------------------------------------------------------------------------------我自己自学Python的时候走了两次弯路。1. Learn Python the Hard Way2. Dive into Python第一种方法花费的时间长，成效慢，而且没有实效性的学习（你只是学了来用啊，不是为了学而学啊）让人难以坚持。给人的感觉就像是中国农民几千年的生活和耕作总结出了的经验，最后发现外国研究者几个月或几年的抽象归纳得出了同样的结论。第二种方法，Dive into Python是一本好书无须置疑，十分仔细和明了，但坏就坏在太多细节。对于入门者最重要的是一整个框架的知识，然后在不断实践中补充细节。就像拿着一本C++ Primer来入门C++我不知道你会有什么感觉（当然这本书远没Primer这么变态）。---------------------------------------------------------------------------------------------------------------------------这是中文翻译译者 沈洁元 先生的原话：Swaroop C. H.的这本书是我学习Python时的第一本教材。它简单明晰,可以在最短的时间内把你领进Python的世界。它不是很长,但是覆盖了几乎所有重要的Python知识。在第一次读本书的时候,我就深切的感到这是给Python初学者的一本极佳教材,应该是每一位Python初学者的第一本教材。欢迎你加入Python的世界！3714 条评论分享收藏感谢收起查看更多回答Python基础知识
1.1.1 特点
Python是一种面向对象、解释型计算机程序设计语言。语法简洁清晰，强制用空白符作为语句缩进。
Python具有丰富和强大的库，又被称为胶水语言。能把其他语言（主要C/C++）写的模块很轻松的结合在一起。
1.1.2 应用领域
Web网站：有很多优秀的开源Web框架，比如Django（最流行）、Tornado（轻量级、异步）、Flask（微型）、Web.py（简单）等。
数据采集：有好用的http库，比如urllib2、requests等。还有高级的屏幕爬取及网页采集框架scrapy。并对网页解析也有很多库，比如lxml、xpath、BeautifulSoup等。
大数据分析：常用模块有Numpy、Pandas。并支持写MapReduce、PySpark处理Spark RDD（弹性分布式数据集）。
运维自动化：编写脚本、Web平台，自动化日常工作。
科学计算：在科学计算也应用越来越广泛，常用的模块有Numpy、SciPy。
等等...可见Python是一门通用语言！
1.1.3 为什么选择Python？
运维的目的呢，主要还是学习Python用来实现运维自动化了。大多数人除了shell脚本外有其他语言基础的应该占少数。
我们以Python作为第一门语言是很好的选择。为什么呢？
1) 语法简洁，易于学习。
2) 广泛的标准库，适合快速开发，不就追求极快处理速度。
3) 跨平台，基本所有的所有的操作系统都能运行。
4) 运维领域Python最流行。
1.2 安装Python
操作系统采用CentOS6.5，默认安装了Python2.6.6，那我们升级到Python2.7最新版Python2.7.12
1. 安装Python2.7
# wget https://www.python.org/ftp/python/2.7.12/Python-2.7.12.tgz
# tar zxvf Python-2.7.12.tgz
# cd Python-2.7.12
# ./configure
# make && make install
# mv /usr/bin/python /usr/bin/python2.6.6
# ln -s /usr/local/bin/python2.7 /usr/bin/python
# python -V
Python 2.7.12
注意：软链接指向Python2.7版本后，yum将不能正常工作，因为yum不兼容2.7的，所有需要指定下yum命令里默认Python版本为2.6.6版本
# sed -i '1s/$/2.6.6/' /usr/bin/yum
2. 安装setuptools
# yum install python-devel zlib-devel openssl-devel -y
# wget https://pypi.python.org/packages/32/3c/e853a68b703f347f5ed28ac70578/setuptools-26.1.1.tar.gz
# tar zxvf setuptools-26.1.1.tar.gz
# cd setuptools-26.1.1
# python setup.py install
"Compression requires the (missing) zlib module"
RuntimeError: Compression requires the (missing) zlib module
解决方法，进入刚解压的Python2.7目录重新编译安装:
# cd ../Python-2.7.12
# make && make install
# python setup.py install
3. 安装pip2.7
# wget https://pypi.python.org/packages/e7/a8/add8d1a54c0b14aeff0acb03c6ecd5/pip-8.1.2.tar.gz
# tar zxvf pip-8.1.2.tar.gz
# cd pip-8.1.2
# python setup.py install
1.3 解释器
1.3.1 Python解释器几种实现版本
1) CPython
当我们装完Python后，其默认解释就是CPython，也是官方默认解释器。CPython是C语言写的，当执行代码时会将代码转化成字节码（ByteCode）。
2) IPython
基于CPython之上的一个交互式解释器，相当于默认解释器的一个增强版，最显著的功能就是自动补全，挺好用的。
PyPy本身是由Python编写的，使用了JIT编译器（即时编译器）技术，当执行代码时JIT编译器将代码翻译成机器码。性能相比CPython要好。JAVA也采用了JIT编译器。
Jython是由JAVA编写的一个解释器，可以把JAVA模块加载到Python的模块中使用，也可以把Python代码打包成JAR包，意味着允许用Python写JAVA程序了。当执行代码时会将代码转化成JAVA字节码，然后使用JRE执行。
5) IronPython
在.NET平台上工作的Python语言。
1.3.2 Python代码执行过程
大致流程：源代码编译成字节码（.pyc文件）--& Python虚拟机 --& 执行编译好的字节码 --& Python虚拟机将字节码翻译成对应的机器指令（机器码）
运行Python程序时，先编译成字节码并保存到内存中，当程序运行结束后，Python解释器将内存中字节码对象写到.pyc文件中。
第二次再运行此程序时，先回从硬盘中寻找.pyc文件，如果找到，则直接载入，否则就重复上面的过程。
这样好处是，不重复编译，提供执行效率。
字节码是一种包含执行程序、由一序列op代码/数据对组成的二进制文件。字节码是一种中间码，比机器码更抽象。
机器码是一种指令集，让CPU可直接解读的数据。也称为原生码。
1.4 代码风格
1.4.1 代码风格有毛用？
个人觉得有以下几个作用：
1) 团队协作
在企业中，一个团队开发一个项目很正常不过了，刚入职是不是会先让你熟悉本公司的编码规范文档呢，作为纯开发来说，我相信大多数公司都会这么做，其中目的是让团队中的每个成员，写代码时能够统一，避免项目中出现几个编码风格版本，不利用后期维护和交接。
2) 有利于解决问题
草泥马，又出问题了，代码运行不起来了，怎么办？百度、谷歌无解...是时候求助大神了，来看看我的代码吧！大神一看，琢磨了一会，你想多了，不是再想你的问题，而是在梳理你的代码实现的功能和逻辑关系。结果发现，多了括号。擦，我怎么就没看到呢！~
3) 未雨绸缪
功能终于实现了，发布到线上运行也挺正常，过了半年后，突然跑不起来了，赶紧排查问题，代码看着看着自己就懵逼了，这还是自己写的代码嘛，长的这么不像我，是亲生的嘛！
小结：只要人人都献出一点爱，世界将会变成美好的人间。
1.4.2 编写代码怎么能更规范化？
Python以空白符作为语句缩进，意味着语句没有结尾符，给往往因为少写个fi的人带来了福利，在Python中最好以4个空格作为缩进符。
2) 代码注释
据说优质的代码，注释说明要比代码量多，详细的代码说明不管对自己后期维护还是开源，都是有必要的。就像一个流行的软件，如果没有丰富的使用文档，你认为会有多少耐心的人去花大把的时间研究它呢！
3) 空格使用
在操作符两边，以及逗号后面，加1个空格。但是在括号左右不加空格。
在函数、类、以及某些功能代码块，空出一行，来分隔它们。
模块：自己写的模块，文件名全部小写，长名字单词以下划线分隔。
类：大/小驼峰命名。我一般采用大驼峰命名，也就是每个单词首字母大写。类中私有属性、私有方法，以双下划线作为前缀。
函数：首单词小写，其余首字母大写。
变量：都小写，单词以下划线分隔。
提醒：所有的命名必须能简要说明此代码意义。
5) 代码换行
按照语法规则去换行，比如一个很长的表达式，可以在其中某个小表达式两边进行换行，而不是将小表达式拆分，这样更容易阅读。
1.5 交互式解释器
直接执行Python命令就启动默认的CPython解释器：
Python 2.7.12 (default, Sep
[GCC 4.4.7
(Red Hat 4.4.7-17)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
&&& print "Hello World"
Hello World
配置自动补全：
# pip2.7 install readline
# pip2.7 install rlcompleter2
&&& import readline, rlcompleter
&&& readline.parse_and_bind("tab: complete")
1.6 运算操作符
2 ** 1 = 2
1.7 赋值操作符
a += b 等同于 a = a + b
a -= b 等同于 a = a - b
a *= b 等同于 a = a * b
a /= b 等同于 a = a / b
a %= b 等同于 a = a % b
a **= b 等同于 a = a ** b
赋值操作符，操作符左边运算右边，然后将结果赋值给操作符左边。
博客地址：http://lizhenliang. and /u/lizhenliang
QQ群：（Shell/Python运维开发群）
1.8.1 变量赋值
&&& xxoo = 2
&&& print xxoo
说明：等号左边是变量名，等号右边是值
# 多重赋值
&&& xx, oo = 1, 2
&&& print xx
&&& print oo
&&& xx = oo = 2
&&& print xx
&&& print oo
1. 8.2 变量引用
上面打印时就是在引用变量了，可见Python引用变量不用加$什么特殊字符，不像Shell、PHP那样，还要加$。
的确，直接用变量名即是引用，下面说一种常用的字符串格式输出时引用变量的方法。
&&& xxoo = 2
&&& print "xxoo: %d" % xxoo
&&& xxoo = "xo"
&&& print "xxoo: %s" % xxoo
&&& x = "abc"
&&& o = 123
&&& print "str: %s, int: %d" %(x, o)
str: abc, int: 123
说明：双引号里面%操作符算是占位符吧，d代表数字，s代表字符串。双引号外面%加上后面的变量名对应里面的第一个%。
下面同时引用了两个变量，外面%()里变量名位置对应双引号里面的%位置。
1.8.3 局部变量
&&& xxoo = 2
&&& print xxoo
1.8.4 全局变量
&&& global xxoo
# 声明为全局变量
&&& print xxoo
说明：从上面并不能看出什么区别，后续在函数章节中会讲解局部变量和全局变量的区别和使用。
1.9 转义字符（列出一些常用的）
字符串太长，换一行接着输入
单引号和双引号
横向制表符（tab键）
纵向制表符
换行符，打印到下一行
&&& print "Hello \
... World"
Hello World
&&& print "Hello \"World!"
Hello "World!
&&& print "Hello \rWorld!"
&&& print "Hello\tWorld!"
&&& print "Hello \vWorld!"
&&& print "Hello \nWorld!"
如果不想让转义字符生效，可以用r指定显示原始字符串：
&&& print r"Hello \nWorld!"
Hello \nWorld!
&&& print "Hello \nWorld!"
1.10 获取用户输入
1.10.1 raw_input()
&&& name = raw_input("My name is: ")
My name is: xiaoming
&&& print name
1.10.2 input()
&&& name = input("My name is: ")
My name is: xiaoming
Traceback (most recent call last):
File "&stdin&", line 1, in &module&
File "&string&", line 1, in &module&
NameError: name 'xiaoming' is not defined
&&& name = input("My name is: ")
My name is: "xiaoming"
&&& print name
&&& name = input("My name is: ")
My name is: 1 + 2
&&& print name
1.10.3 raw_input()与input()函数区别
可以看到两个函数用同样的方式输入，结果input()报错！
原因是因为raw_input()把任何输入的都转成字符串存储。
而input()接受输入的是一个表达式，否则就报错。
1.11 运行第一个程序
# vi test.py
#!/usr/bin/env python
# 说明用什么可执行程序运行它，env会自动寻找python解释器的绝对路径
print "Hello World!"
# python test.py
Hello World!
easy！打印Hello world已经没什么难度了，那改进下刚学接受用户输入。
# vi test.py
#!/usr/bin/env python
name = raw_input("My name is: ")
print name
# python test.py
My name is: xiaoming
单行注释：井号（"#"）开头
多行注释：三单引号或三双引号
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# 设置解释器默认编码，下一章会讲到
# 单行注释}