在 SegmentFault，学习技能、解决问题
每个月，我们帮助 1000 万的开发者解决各种各样的技术问题。并助力他们在技术能力、职业生涯、影响力上获得提升。
问题对人有帮助，内容完整，我也想知道答案
问题没有实际价值，缺少关键内容，没有改进余地
python3如何实现从终端输入数据，比如终端输入10 3 5，将此数据保存到一个列表中，即得到列表[10, 3, 5]
答案对人有帮助，有参考价值
答案没帮助，是错误的答案，答非所问
创建一个py文件：a.pyimport sysa = sys.argv[1:]print(a)在终端输入 python3 a.py 10 2 39 5就行类
答案对人有帮助，有参考价值
答案没帮助，是错误的答案，答非所问
[int(i) for i in input().split()]
分享到微博？
关闭理由：
删除理由：
忽略理由：
推广（招聘、广告、SEO 等）方面的内容
与已有问题重复（请编辑该提问指向已有相同问题）
答非所问，不符合答题要求
宜作评论而非答案
带有人身攻击、辱骂、仇恨等违反条款的内容
无法获得确切结果的问题
非开发直接相关的问题
非技术提问的讨论型问题
其他原因（请补充说明）
我要该，理由是：
在 SegmentFault，学习技能、解决问题
每个月，我们帮助 1000 万的开发者解决各种各样的技术问题。并助力他们在技术能力、职业生涯、影响力上获得提升。python 键盘输入数字的计算
文件的读写
学习python，开贴记录。
获取键盘输入值的函数：input（‘这里是提示’）
count0 = input("请输入：")
用这个函数获取的内容都是字符串，如果键入的数字要进行运算，需要将其转变成数字。
count0=input("请输入：")#比如输入5
count=int(count0)这时，键入的数字就可以用于计算了
使用 open(filename, mode)
f = open("C:/Users/lenovo/Desktop/新建文件夹/foo.txt", "r")
这样就创建了一个名为f的只能用于读取文件内容的对象
然后利用对象的方法来操作
# 打开一个文件
f = open("C:/Users/lenovo/Desktop/新建文件夹/foo.txt", "r")
str = f.read()
print(str)
# 关闭打开的文件
这样就读取了桌面新建文件夹中foo.txt第内容。其他操作方式也类似。
引入 pywin32（下载安装，需选择版本） 与 xlwings（pip安装） 可以操作excel。下面这段代码可以将excel表格中内容写入xml文件。
import xlwings as xw
wb = xw.Book('new.xlsx')
# Creates a connection with a new workbook
#xw.apps[0].books['new.xlsx']
sht = wb.sheets['Sheet1']
#sht.range('A1').value = 'I love N baby very much'
##sht.range((2,2)).value = [['Foo 1', 'Foo 2', 'Foo 3'], [10.0, 20.0, 30.0]]
##print(sht.range((2,2)).expand().value)
f = open("test.xml", "w")
while sht.range(i,1).value != None:
f.write(str(sht.range(i,1).value) + ' ')
print('ok')
没有更多推荐了，python 学习笔记
我的图书馆
python 学习笔记
&11.概括: Python确实是一种十分精彩又强大的语言。它合理地结合了高性能与使得编写程序简单有趣的特色。& 12.规范的代码: Python采用强制缩进的方式使得代码具有极佳的可读性。Python 下载地址&&& http://www.python.org/download/Python 安装：&&& windows时，运行安装文件之后，还需要配置环境变量，在环境变量的“Path”后面加上英文的分号及python安装目录&&& 如：“;C:\promg\python2.6”&&& 不配置环境变量的话，没法在命令行直接使用python有两种使用Python运行你的程序的方式&& 1.使用交互式的带提示符的解释器&&&& 直接双击运行“python.exe”，在里面输入内容，如： print 'haha...'&& 2.使用源文件&&&& 在Python的安装目录下，建一个批处理(test.bat)，写入：&&&& @echo off&&&& python.exe test.py&&&& pause&&&& 而“test.py”里面的内容是需要执行的程序Python命令行选项&&& 选项&&&&& 作用&&& -c cmd&& 在命令行直接执行python代码。如python -c 'print "hello world"'。&&& -d&&&&&& 脚本编译后从解释器产生调试信息。同PYTHONDEBUG=1。&&& -E&&&&&& 忽略环境变量。&&& -h&&&&&& 显示python命令行选项帮助信息。&&& -i&&&&&& 脚本执行后马上进入交互命令行模式。同PYTHONINSPECT=1。&&& -O&&&&&& 在执行前对解释器产生的字节码进行优化。同 PYTHONOPTIMIZE=1。&&& -OO&&&&& 在执行前对解释器产生的字节码进行优化，并删除优化代码中的嵌入式文档字符串。&&& -Q arg&& 除法规则选项，-Qold(default)，-Qwarn，-Qwarnall，-Qnew。&&& -S&&&&&& 解释器不自动导入site.py模块。&&& -t&&&&&& 当脚本的tab缩排格式不一致时产生警告。&&& -u&&&&&& 不缓冲stdin、stdout和stderr，默认是缓冲的。同PYTHONUNBUFFERED=1。&&& -v&&&&&& 产生每个模块的信息。如果两个-v选项，则产生更详细的信息。同PYTHONVERBOSE=x。&&& -V&&&&&& 显示Python的版本信息。&&& -W arg&& 出错信息控制。(arg is action:message:category:module:lineno)&&& -x&&&&&& 忽略源文件的首行。要在多平台上执行脚本时有用。&&& file&&&& 执行file里的代码。&&& -&&&&&&& 从stdin里读取执行代码。easy_install&&& 这是个很常用的python安装工具&&& 可以直接安装ez_setup.py脚本(下载网址： http://peak.telecommunity.com/dist/ez_setup.py):&&&&&&& python ez_setup.py&&& windows 下的使用：&&&&& 安装：&&&&&&& 下载: http://peak.telecommunity.com/dist/ez_setup.py&&&&&&& 执行: python ez_setup.py&&&&& 使用：&&&&&&& easy_install.exe -U %modal%& # %modal% 是模块名&&& linux 下：&&&&& 安装：&&&&&&& sudo apt-get install python-setuptools&&&&& 或者：&&&&&&& wget -q http://peak.telecommunity.com/dist/ez_setup.py&&&&&&& sudo python ez_setup.py&&&&& 使用：&&&&&&& sudo easy_install 模块名&&&&&&& 安装完后，最好确保easy_install所在目录已经被加到PATH环境变量里:&&&&&&& Windows: C:\Python25\Scripts&&&&&&& Linux: /usr/local/bin&&& 不能使用easy_install的特殊情况：&&&&&&& a、安装默认版本的MySQL-python会报错，需要指定版本如下：easy_install "MySQL-python==1.2.2"&&&&&&& b、有些包直接easy_install会失败，需要自行下载安装：&&&&&&&&&& wxpython，pil要下载exe安装程序&&&&&&&&&& robotide因为在pypi上找不到，要下载后再easy_install&&& 通过easy_install安装软件，相关安装信息会保存到easy-install.pth文件里，路径类似如下形式：&&& Windows：C:\Python25\Lib\site-packages\easy-install.pth&&& Linux：/usr/local/lib/python25/site-packages/easy-install.pth&&& 如果想删除通过easy_install安装的软件包，比如说：MySQL-python，可以执行命令：&&&&&&& easy_install -m MySQL-python&&& 此操作会从easy-install.pth文件里把MySQL-python的相关信息抹去，剩下的egg文件，你可以手动删除。版本问题&& python3.0版本较之前的有很大变动，而且不向下兼容。&& Python 2.6作为一个过渡版本，基本使用了Python 2.x的语法和库，同时考虑了向Python 3.0的迁移。即2.6版本兼容2.x和3.0的语法&&&&&& Python 2.6保持了对之前版本的全兼容，而且还包含了Python 3.0的新玩意(一些新特性需要通过“from __future__ import”来启用)。&&&&&& 如，在Python2.6要使用3.0的打印,得写上“ from __future__ import print_function”&& 基于早期Python版本而能正常运行于Python 2.6并无警告的程序可以通过一个2 to 3的转换工具无缝迁移到Python 3.0。&& 部分函数和语句的改变&&&&& 最引人注意的改变是print语句没有了，取而代之的是print函数&&&&& 同样的还有exec语句，已经改为exec()函数。去除了&&，全部改用!=。&&&&&&& 在python2.x版本中&&&&&&&&& #!/usr/bin/env python&&&&&&&&& # 或者上句写: #!/usr/bin/python&&&&&&&&& print "Hello, world!"&&&&&&&&& 或者：&&&&&&&&& import sys&&&&&&&&& sys.stdout.write("Hello, world\n")&&&&&&& 在python3.x中&&&&&&&&& print('Hello world!')&& 用迭代器来替代列表&&&&& 一些知名的API将不再返回列表。&&&&& 而字典的dict.iterkeys()、dict.itervalues()和dict.iteritems()方法将会移除，而你可以使用.keys()、.values()和.items()，它们会返回更轻量级的、类似于集合的容器对象，而不是返回一个列表来复制键值。&&&&& 这样做的优点是，可以直接在键和条目上进行集合操作，而不需要再复制一次。&& 整型数&&&&& 移除了含糊的除法符号('/')，而只返回浮点数。&&&&& 在以前的版本中，如果参数是int或者是long的话，就会返回相除后结果的向下取整(floor)，而如果参数是float或者是complex的话，那么就会返回相除后结果的一个恰当的近似。&&&&& 在2.6版本中可以通过from __future__ import division来启用这项特性。python2 to python3 问题&&& 1.print 语句&&&&&&&&&& 2.x&&&&&&&&&&&&&&&&&&&&&&& 3.x&&&&&&&&&&&&&&&&&&&&&&&&&& 说明&&&&&& ① print&&&&&&&&&&&&&&&&&&&&& print()&&&&&&&&&&&&&&&&&&&&& # 输出一个空白行&&&&&& ② print 1&&&&&&&&&&&&&&&&&&& print(1)&&&&&&&&&&&&&&&&&&&& # 输出一个单独的值&&&&&& ③ print 1, 2&&&&&&&&&&&&&&&& print(1, 2)&&&&&&&&&&&&&&&&& # 输出多个值，以空格分割&&&&&& ④ print 1, 2,&&&&&&&&&&&&&&& print(1, 2, end=' ')&&&&&&&& # 输出时取消在末尾输出回车符。&&&&&& ⑤ print &&sys.stderr, 1, 2&& print(1, 2, file=sys.stderr) # 把输出重定向到一个管道&&& 2.被重命名或者重新组织的模块&&&&& 1)http&&&&&&& 在Python 3里，几个相关的HTTP模块被组合成一个单独的包，即http。&&&&&&&&&&&& 2.x&&&&&&&&&&&&&&&&&&&& 3.x&&&&&&& ①& import httplib&&&&&&&&& import http.client&&&& # http.client 模块实现了一个底层的库，可以用来请求HTTP资源，解析HTTP响应。&&&&&&& ②& import Cookie&&&&&&&&&& import http.cookies&&& # http.cookies 模块提供一个蟒样的(Pythonic)接口来获取通过HTTP头部(HTTP header)Set-Cookie发送的cookies&&&&&&& ③& import cookielib&&&&&&& import http.cookiejar& # 常用的流行的浏览器会把cookies以文件形式存放在磁盘上，http.cookiejar 模块可以操作这些文件。&&&&&&& ④& import BaseHTTPServer&& import http.server&&&& # http.server 模块实现了一个基本的HTTP服务器&&&&&&&&&&& import SimpleHTTPServer&&&&&&&&&&& import CGIHttpServer&&&&& 2)urllib&&&&&&& Python 2有一些用来分析，编码和获取URL的模块，但是这些模块就像老鼠窝一样相互重叠。在Python 3里，这些模块被重构、组合成了一个单独的包，即urllib。&&&&&&&&&&&& 2.x&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& 3.x&&&&&&& ①& import urllib&&&&&&&&&&&&&&&&&&&&&& import urllib.request, urllib.parse, urllib.error&&&&&&& ②& import urllib2&&&&&&&&&&&&&&&&&&&&& import urllib.request, urllib.error&&&&&&& ③& import urlparse&&&&&&&&&&&&&&&&&&&& import urllib.parse&&&&&&& ④& import robotparser&&&&&&&&&&&&&&&&& import urllib.robotparser&&&&&&& ⑤& from urllib import FancyURLopener&& from urllib.request import FancyURLopener&&&&&&&&&&& from urllib import urlencode&&&&&&& from urllib.parse import urlencode&&&&&&& ⑥& from urllib2 import Request&&&&&&&& from urllib.request import Request&&&&&&&&&&& from urllib2 import HTTPError&&&&&& from urllib.error import HTTPError&&&&&&& 以前，Python 2里的 urllib 模块有各种各样的函数，包括用来获取数据的 urlopen()，还有用来将URL分割成其组成部分的 splittype(), splithost()和 splituser()函数。&&&&&&& 在python3的 urllib 包里，这些函数被组织得更有逻辑性。2to3将会修改这些函数的调用以适应新的命名方案。&&&&&&& 在Python 3里，以前的 urllib2 模块被并入了 urllib 包。同时，以 urllib2 里各种你最喜爱的东西将会一个不缺地出现在Python 3的 urllib 模块里，比如 build_opener()方法, Request 对象， HTTPBasicAuthHandler 和 friends 。&&&&&&& Python 3里的 urllib.parse 模块包含了原来Python 2里 urlparse 模块所有的解析函数。&&&&&&& urllib.robotparse 模块解析 robots.txt 文件。&&&&&&& 处理HTTP重定向和其他状态码的 FancyURLopener 类在Python 3里的 urllib.request 模块里依然有效。 urlencode()函数已经被转移到了 urllib.parse 里。&&&&&&& Request 对象在 urllib.request 里依然有效，但是像HTTPError这样的常量已经被转移到了 urllib.error 里。&&&&& 3)dbm&&&&&&& 所有的DBM克隆(DBM clone)现在在单独的一个包里，即dbm。如果你需要其中某个特定的变体，比如GNU DBM，你可以导入dbm包中合适的模块。&&&&&&&&&&&&& 2.x&&&&&&&&&&&&&&& 3.x&&&&&&&& ①& import dbm&&&&&&&& import dbm.ndbm&&&&&&&& ②& import gdbm&&&&&&& import dbm.gnu&&&&&&&& ③& import dbhash&&&&& import dbm.bsd&&&&&&&& ④& import dumbdbm&&&& import dbm.dumb&&&&&&&& ⑤& import anydbm&&&&& import dbm&&&&&&&&&&&& import whichdb&&&&& 4)xmlrpc&&&&&&& XML-RPC是一个通过HTTP协议执行远程RPC调用的轻重级方法。一些XML-RPC客户端和XML-RPC服务端的实现库现在被组合到了独立的包，即xmlrpc。&&&&&&&&&&&&& 2.x&&&&&&&&&&&&&&&&&&&&&&& 3.x&&&&&&&& ①& import xmlrpclib&&&&&&&&&& import xmlrpc.client&&&&&&&& ②& import DocXMLRPCServer&&&& import xmlrpc.server&&&&&&&&&&&& import SimpleXMLRPCServer&&&&& 5)其他模块&&&&&&&&&&&& 2.x&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& 3.x&&&&&&& ①& try:&&&&&&&&&&&&&&&&&&&&&&&&&&&&& import io&&&&&&&&&&&&&&& import cStringIO as StringIO& # 在Python 2里，你通常会这样做，首先尝试把cStringIO导入作为StringIO的替代，如果失败了，再导入StringIO。&&&&&&&&&&& except ImportError:&&&&&&&&&&&&&& # 不要在Python 3里这样做；io模块会帮你处理好这件事情。它会找出可用的最快实现方法，然后自动使用它。&&&&&&&&&&&&&&& import StringIO&&&&&&& ②& try:&&&&&&&&&&&&&&&&&&&&&&&&&&&&& import pickle&&&&&&&&&&&&&&& import cPickle as pickle&&&&& # 在Python 2里，导入最快的pickle实现也与上边 io 相似。在Python 3里，pickle模块会自动为你处理，所以不要再这样做。&&&&&&&&&&& except ImportError:&&&&&&&&&&&&&&& import pickle&&&&&&& ③& import __builtin__&&&&&&&&&&&&&&& import builtins&&&&&&& ④& import copy_reg&&&&&&&&&&&&&&&&&& import copyreg # copyreg模块为用C语言定义的用户自定义类型添加了pickle模块的支持。&&&&&&& ⑤& import Queue&&&&&&&&&&&&&&&&&&&&& import queue&& # queue模块实现一个生产者消费者队列(multi-producer, multi-consumer queue)。&&&&&&& ⑥& import SocketServer&&&&&&&&&&&&&& import socketserver # socketserver模块为实现各种socket server提供了通用基础类。&&&&&&& ⑦& import ConfigParser&&&&&&&&&&&&&& import configparser # configparser模块用来解析INI-style配置文件。&&&&&&& ⑧& import repr&&&&&&&&&&&&&&&&&&&&&& import reprlib # reprlib 模块重新实现了内置函数 repr()，并添加了对字符串表示被截断前长度的控制。&&&&&&& ⑨& import commands&&&&&&&&&&&&&&&&&& import subprocess # subprocess 模块允许你创建子进程，连接到他们的管道，然后获取他们的返回值。&&&&&&& builtins模块包含了在整个Python语言里都会使用的全局函数，类和常量。重新定义builtins模块里的某个函数意味着在每处都重定义了这个全局函数。这听起来很强大，但是同时也是很可怕的。注释& “#”后面的内容数据类型&& 共4种: 整数、长整数、浮点数和复数。&& 1.整数,如:2&& 2.长整数,如:22L& # 长整数不过是大一些的整数。Python 3已经取消这种类型,被int取代了。&& 3.浮点数,如:3.23 和 52.3E-4& # E标记表示10的幂。在这里，52.3E-4表示52.3 * 10-4。&& 4.复数,如:(-5+4j) 和 (2.3-4.6j)&& 在Python 2和Python 3的变化:&& 1.八进制(octal)数:&&&& Python 2: x = 0755&& # 0开头&&&& Python 3: x = 0o755& # 0o开头&& 2.long 类型&&&& Python 2有为非浮点数准备的 int 和 long 类型。 int 类型的最大值不能超过 sys.maxint,而且这个最大值是平台相关的。&&&&&& 整数可以通过在数字的末尾附上一个L来定义长整型，显然，它比 int 类型表示的数字范围更大。&&&& Python 3里，只有一种整数类型 int,大多数情况下，它很像Python 2里的长整型。&&&&&& 由于已经不存在两种类型的整数，所以就没有必要使用特殊的语法去区别他们。&&&& 由于 long 类型在Python 3的取消,引起以下改变&&&&&&&&& Python 2&&&&&&&&&&&&& Python 3&&&&&&&&&&& 说明&&&&& ① x = 0L&&& x = 0&& # 十进制的普通整数&&&&& ② x = 0xFFFFFFFFFFFFL&& x = 0xFFFFFFFFFFFF& # 十六进制的普通整数&&&&& ③ long(x)&&&&&&&&&&&&&& int(x)&&&&&&&&&&&&& # long()函数没有了。可以使用int()函数强制转换一个变量到整型。&&&&& ④ type(x) is long&&&&&& type(x) is int&&&&& # 检查一个变量是否是整型&&&&& ⑤ isinstance(x, long)&& isinstance(x, int)& # 也可以使用 isinstance()函数来检查数据类型&& 3.sys.maxint(sys.maxsize)&&&& 由于长整型和整型被整合在一起了, sys.maxint常量不再精确。&&&& 因为这个值对于检测特定平台的能力还是有用处的，所以它被Python 3保留，并且重命名为 sys.maxsize。&&&&&&&& Python 2&&&&&&&&&&&&&&& Python 3&&&& ① from sys import maxint& from sys import maxsize& # maxint变成了maxsize。&&&& ② a_function(sys.maxint)& a_function(sys.maxsize)& # 所有的sys.maxint都变成了sys.maxsize。& int 是 types.IntType 的代名词&&& print(id(int)) # 打印如：&&&print(id(types.IntType)) # 打印如：标识符的命名&&& 变量是标识符的例子。 标识符 是用来标识 某样东西 的名字。在命名标识符的时候，你要遵循这些规则：&&& 1.标识符的第一个字符必须是字母表中的字母(大写或小写)或者一个下划线(‘_’)。&&& 2.标识符名称的其他部分可以由字母(大写或小写)、下划线(‘_’)或数字(0-9)组成。&&& 3.标识符名称是对大小写敏感的。例如，myname和myName不是一个标识符。&&& 有效 标识符名称的例子有i、__my_name、name_23和a1b2_c3。&&& 无效 标识符名称的例子有2things、this is spaced out和my-name。&逻辑行与物理行& 物理行是在编写程序时文本的一行。逻辑行是程序的一个语句。& Python假定每个 物理行 对应一个 逻辑行 。 他希望每行都只使用一个语句，这样使得代码更加易读。& 1. 如果你想要在一个物理行中使用多于一个逻辑行，那么你需要使用分号(;)来特别地标明这种用法。&&&& 分号表示一个逻辑行/语句的结束。&&&& 如: i = 5; # 强烈建议你坚持在每个物理行只写一句逻辑行。 让程序见不到分号，而更容易阅读。& 2. 明确的行连接&&&& 在多个物理行中写一个逻辑行,行结尾用反斜杠标明&&&& 如: s = 'This is a string. \&&&&&&&& This continues the string.'&&&&&&&& # 上面这两行是一个逻辑行,打印是: This is a string. This continues the string.&&&&&&&& print \&&&&&&&& i&&&&&&&& # 上面这两行也是一个逻辑行, 等同于: print i& 3. 暗示的行连接&&&& 在多个物理行中写一个逻辑行,行结尾不需要使用反斜杠标明。&&&& 这种情况出现在逻辑行中使用了圆括号、方括号或波形括号的时候。& 4. 缩进&&&& 行首的空白是重要的。在逻辑行首的空白(空格和tab符)用来决定逻辑行的缩进层次，从而用来决定语句的分组。&&&& 同一层次的语句必须有相同的缩进。每一组这样的语句称为一个块。&&&& 不要混合使用tab符和空格来缩进，因为这在跨越不同的平台的时候，无法正常工作。强烈建议只使用一种风格来缩进。语法规则&& 1.缩进规则&&&& 一个模块的界限，完全是由每行的首字符在这一行的位置来决定的(而不是花括号{})。这一点曾经引起过争议。&&&& 不过不可否认的是，通过强制程序员们缩进，Python确实使得程序更加清晰和美观。&&&& 在逻辑行首的空白(空格和tab)用来决定逻辑行的缩进层次，从而用来决定语句的分组。错误的缩进会引发错误。&&&& 注意: 强制缩进的问题,最常见的情况是tab符和空格的混用会导致错误，而这是用肉眼无法分别的。&& 2.变量没有类型&&&& 使用变量时只需要给它们赋值。 不需要声明或定义数据类型。&& 3.单语句块&&&& 如果你的语句块只包含一句语句，那么你可以在条件语句或循环语句的同一行指明它。如: if 1!=2: print('Yes')&&&& 强烈建议不要使用这种缩略方法。这会破坏Python清晰美观的代码风格,违背设计者的初衷。&&&& 如果是在Python解释器输入,它的把提示符会改变为...以表示语句还没有结束。这时按回车键用来确认语句已经完整了。然后，Python完成整个语句的执行，并且返回原来的提示符来等待下一句输入。&运算符与表达式:运算符&& 运算符&& 名称&&&&&&&&& 说明&&&& +&&&&&& 加&&&&&&&&& 两个对象相加,也可以字符串拼接&&&& -&&&&&& 减&&&&&&&&& 得到负数或是一个数减去另一个数&&&& *&&&&&& 乘&&&&&&&&& 两个数相乘 或是返回一个被重复若干次的字符串&&&& **&&&&& 幂&&&&&&&&& 返回x的y次幂&&&& /&&&&&& 除&&&&&&&&& x除以y&&&& //&&&&& 取整除&&&&& 返回商的整数部分&&&& %&&&&&& 取模&&&&&&& 返回除法的余数& # 8%3得到2。 -25.5%2.25得到1.5&&&& &&&&&&& 左移&&&&&&& 把一个数的二进制向左移一定数目 # 2 && 2得到8&&&& &&&&&&& 右移&&&&&&& 把一个数的二进制向右移一定数目 # 11 && 1得到5&&&& &&&&&&& 按位与&&&&& 数的按位与 # 5 & 3得到1。&&&& |&&&&&& 按位或&&&&& 数的按位或 # 5 | 3得到7。&&&& ^&&&&&& 按位异或&&& 数的按位异或 # 5 ^ 3得到6&&&& ~&&&&&& 按位翻转&&& x的按位翻转是-(x+1) # ~5得到6。&&&& &&&&&&& 小于&&&&&&& 返回x是否小于y&&&& &&&&&&& 大于&&&&&&& 返回x是否大于y&&&& &=&&&&& 小于等于&&& 返回x是否小于等于y&&&& &=&&&&& 大于等于&&& 返回x是否大于等于y&&&& ==&&&&& 等于&&&&&&& 比较对象是否相等&&&& !=&&&&& 不等于&&&&& 比较两个对象是否不相等(python3删除了“&&”符号)&&&& not&&&& 布尔“非”& 如果x为True，返回False。如果x为False，它返回True。 # x = T not x返回False。&&&& and&&&& 布尔“与”& 如果x为False，x and y返回False，否则它返回y的计算值。 # x=F y=T x and y返回False。&&&& or&&&&& 布尔“或”& 如果x是True，它返回True，否则它返回y的计算值。# x = T y = F x or y返回True。&&&& in, not in&&&&&&&&& 成员测试 (由类里面的 __contains__ 函数指定返回值)&&&& is, is not&&&&&&&&& 同性测试 (两值的 is 运算是判断引用,与“==”的比较有所不同)&& 说明:&&&& 1.加号“+”:有数学相加，也有字符串拼接作用,注意:不能字符串和数字相加。如: 3 + 5得到8; 'a' + 'b'得到'ab'。&&&& 2.乘号“*”:两个数相乘，也可以把字符串重复拼接若干次,如: 2 * 3得到6; 'la' * 3得到'lalala'。&&&& 3.幂“**” :这种写法,其他语言好像没见到过,如: 3 ** 4得到81(即3 * 3 * 3 * 3)&&&& 4.除号“/”:整数的除法得到整数结果,浮点数的得到浮点数,如:4/3得到1(返回相除后结果的向下取整(floor)); 4.0/3或4/3.0得到1.333...&&&&&& 注意:Python 3.0开始,移除了含糊的除法符号('/')，而只返回浮点数。如:4/3得到1.333...&&&& 5.取整除“//”:将两数相除,然后对结果取整,如: 7 // 3得到2; 4 // 3.0得到1.0&&&& 6.比较运算符:所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量 True 和 False 等价。注意大小写。&&&&&& 如果两个操作数都是数字，它们首先被转换为一个共同的类型(如double)。否则，它总是返回 False 。&&&&&& 5 & 3返回0(即False); 而3 & 5返回1(即True)。比较可以被任意连接: 3 & 5 & 7返回True。&&&&&& 大于、小于、小于等于、大于等于时:数字跟数字可以比较，字符串跟字符串可以比较，但数字不能跟字符串比较。&&&&&& 等于、不等于时: 数字跟数字可以比较，字符串跟字符串可以比较，数字跟字符串比较返回 False (表示不相等)&&&&&& 等于: Python 使用“==”来做比较，用“=”来赋值。但不允许内嵌的赋值，所以不会出现你本以为在做比较而意外的写成赋值的情况。&&&& 7.布尔运算: and 和 or 都是短路运算,没有非短路运算的运算符。&&&&&& 短路运算:当前面一个表达式可以决定结果时，后面的语句不用再判断。非短路运算时，还照样判断后面的。&&&&&& 注意：在 and or 运算中，空字符串'',数字0,空列表[],空字典{},空元组(), None,在逻辑运算中都被当作假来处理。&&&& 8.and 和 or 的特殊用法:&&&&&& 由于语言的松散性,用 and 和 or 在赋值语句时有判断作用。&&&&&& 1) or 用在赋值语句里，返回第一个逻辑为真的值, 没有逻辑为真的返回最后一个。(如下这写法比较常用)&&&&&&&&& 如:ss = False or None or 0 or '' or -1 or 'sss'; print(ss) # 打印:-1 (-1作if判断时返回 True)&&&&&&&&& 设定预设值的写法: edittype = edittype or "text"; # 如果 edittype 之前有值,则取之前的值; 之前为空,则取默认值&&&&&& 2) and 用在赋值语句里，与 or 刚好相反，返回第一个逻辑为假的值, 没有逻辑为假的返回最后一个。&&&&&&&&& 如: a = 0 and 1; print(a) # 打印: 0&&&&&&&&& a = 2 and 1; print(a) # 打印: 1&&&&&&&&& 应用： valid = T valid = valid and checkLength(name, 16); valid = valid and checkLength(name, 16); # 如果前面的验证不通过，则后面的不再验证&&&&&& 简便的记忆是: and 偏 False, or 偏 True&&&&&& 要理解 and 和 or 的这种写法，得考虑到它的短路运算特性。它是在做逻辑判断，但返回的是前或后一个的值，而不是返回 True 或 False 。&&&& 9.三目运算符：&&&&&& Python 没有三目运算符“cond ? a : b”,但可以使用 and 和 or 来代替(需理解前面的 and 和 or 的特殊用法)，如下：&&&&&& 1) c = cond and a or b&& # 这多数情况下是正确的，但当 a 是空字符串''、数字0等逻辑运算为假的情况下会出错。&&&&&& 2) c = (cond and [a] or [b])[0] # 即使 a或者b为一个逻辑假的值，将他放入集合中后，就为真了，也就是[False] [None]都不为假。&&&&&& 3) c = (b, a)[cond and 1 or 0] # 注意 a和b的位置是颠倒的,将表达式结果转成1和0来作为元组下标而选择结果。&&&&&& 4) c = a if cond else b # 使用 if else 写条件(python特有的写法,建议使用,前3种写法难理解也容易出错)&&&& 10.自增,自减:&&&&&& Python 没有“++”和“--”两个语法,自增自减时只能写: i = i + 1 或者 i += 1, 不能用 i++&&&&&& 这在一定程度上避免出错，因为新手经常搞错“++”放前面还是放后面; 但这也导致 for 循环的写法与其它语言很不同&&&& 11.switch/case 语句&&&&&&& Python现在不支持这语句，但可以用 range(N) 生成一个 列表&&&& 12.一次性的多比较&&&&&&& “ if (0 & n & 4000) ”这种写法在python是允许的，它等价于“ if ((0 & n) and (n & 4000)) ”但前者更适合阅读。运算符优先级&&& 下面这个表给出Python的运算符优先级，从最低的优先级(最松散地结合)到最高的优先级(最紧密地结合)。&&& 在一个表达式中，Python会首先计算下表中较下面的运算符，然后在计算列在下表上部的运算符。&&& 在下表中列在同一行的运算符具有 相同优先级 。例如，+和-有相同的优先级。&&& 建议使用圆括号来分组运算符和操作数，以便能够明确地指出运算的先后顺序，使程序尽可能地易读。例如，2 + (3 * 4)显然比2 + 3 * 4清晰。&&& 运算符&&&&&&&&&&&&&&&&&& 描述&&& lambda&&&&&&&&&&&&&&&&& Lambda表达式&&& or&&&&&&&&&&&&&&&&&&&&& 布尔“或”&&& and&&&&&&&&&&&&&&&&&&&& 布尔“与”&&& not x&&&&&&&&&&&&&&&&&& 布尔“非”&&& in，not in&&&&&&&&&&&&& 成员测试&&& is，is not&&&&&&&&&&&&& 同一性测试&&& &，&=，&，&=，!=，==&&& 比较&&& |&&&&&&&&&&&&&&&&&&&&&& 按位或&&& ^&&&&&&&&&&&&&&&&&&&&&& 按位异或&&& &&&&&&&&&&&&&&&&&&&&&&& 按位与&&& &&，&&&&&&&&&&&&&&&&&&& 移位&&& +，-&&&&&&&&&&&&&&&&&&& 加法与减法&&& *，/，%&&&&&&&&&&&&&&&& 乘法、除法与取余&&& +x，-x&&&&&&&&&&&&&&&&& 正负号&&& ~x&&&&&&&&&&&&&&&&&&&&& 按位翻转&&& **&&&&&&&&&&&&&&&&&&&&& 指数&&& x.attribute&&&&&&&&&&&& 属性参考&&& x[index]&&&&&&&&&&&&&&& 下标&&& x[index:index]&&&&&&&&& 寻址段&&& f(arguments...)&&&&&&&& 函数调用&&& (experession,...)&&&&&& 绑定或元组显示&&& [,...]&&&&&&& 列表显示&&& {key:datum,...}&&&&&&&& 字典显示&&& ',...'&&&&&&& 字符串转换计算顺序&&& 默认地，运算符优先级表决定了哪个运算符在别的运算符之前计算。然而，如果要改变它们的计算顺序，得使用圆括号。&&& 例如，你想要在一个表达式中让加法在乘法之前计算，那么你就得写成类似(2 + 3) * 4的样子。结合规律&&& 运算符通常由左向右结合，即具有相同优先级的运算符按照从左向右的顺序计算。例如，2 + 3 + 4被计算成(2 + 3) + 4。&&& 一些如赋值运算符那样的运算符是由右向左结合的，即a = b + c被处理为a = (b + c)。对象&&& Python 将 "一切皆对象" 贯彻得非常彻底，不区分什么 "值类型" 和 "引用类型"。所谓变量，实质就是一个通用类型指针 (PyObject*)，它仅仅负责指路，至于目标是谁，一概不管。&&& Python Object 对象的自身结构了。任何对象，就算一个最简单的整数，它的头部都会拥有 2 个特殊的附加信息，分别是："引用计数" 和 "类型 (type) 指针" 。前者指示 GC 何时回收，而后者标明了对象的身份，如此我们就可以在运行期动态执行对象成员调用。&&& 连同附加头，一个 "普通" 的整数起码得 12 字节：&&& a = 8; print(sys.getsizeof(a)) # 打印： 12& (python3.2中，打印的是14)&&& print(sys.getsizeof(None)) # 打印： 8字符串&& 1.使用单引号“'”引起来: 'Quote me on this'&& 2.使用双引号“"”引起来: "What's your name?"&& 3.使用三引号('''或"""): 可以指示一个多行的字符串。你可以在三引号中自由的使用单引号和双引号。 /'''&&&& 如:&&&& """This is a multi-line string. This is the first line.&&&& "What's your name?," I asked.&&&& He said "Bond, James Bond."&&&& """&& 4.转义符“\”&&&& \\& 指示反斜杠本身&&&& \'& 指示单引号&&&& \"& 指示双引号&&&& 注意: 行末的单独一个反斜杠表示字符串在下一行继续，而不是开始一个新的行。&& 5.自然字符串&&&& 自然字符串通过给字符串加上前缀r或R来指定，取消转义符的功能。例如: r"Newlines are indicated by \n"。&&&& 三引号的字符串也可以同样用法，如：R'''Newlines are indicated by \n'''&& 6.Unicode字符串&&&& Python允许你处理Unicode文本(超过拉丁文字范围的)——只需要在字符串前加上前缀u或U。&&&& 例如，u"This is a Unicode string.哈哈.."。(Python3.x之后不需要这样了,可以直接写中文;而这样写会报错)&&&& Python 3.0开始对unicode全面支持，所有的文本(str)都是Unicode的；并引入了一个叫做bytes的新类型来处理字节序列。而编码过的Unicode会以二进制的数据来表示。&&&& 因为在2.x的世界里，大量的bug都是因为已编码的文本和未编码的文本混杂在一起而产生的。&& 7.按字面意义级连字符串&&&& 如果你把两个字符串按字面意义相邻放着，他们会被Python自动级连。&&&& 例如，"What's" ' your name?'会被自动转为"What's your name?"。&&&& 即是说，两个字符串放在一起，会有字符拼接的效果。加号“+”也有字符拼接的效果。&& 8.字符串拼接&&&& 可以使用“str1.__add__(str2)”或者“str1 + str2”或者直接两个字符串放一起,来拼接字符串&&&& 但字符串与其它类型拼接时，得先把其它类型转成字符串类型，否则会出错。如“str1 + 2”就会出错，需要“str1 + str(2)”&& 9.格式化&&&& 使用“%控制符”可以格式化字符串,非常方便。如: str1 = "Swaroop's age is %d, weight is %f" % (5, 65.5)&&&& “%(name)控制符”可按名称传参数(不写名称是按位置传参数)，如: str = "%(row)d Rows is %(value)s" % { 'value': 'kkkk', 'row': 22 }&&&& 格式化的符号用法参考下面的“字符串格式化控制表”&&&& 另外，string.format()函数也可以格式化字符串&&&& 例如：'subtracting {0}, adding {1}'.format(1, 'haha') # 参数讲对应到“{number}”的位置上&& 10.字符串序列(索引和切片)&&&& 字符串可以使用下标来获取字符串中某个项目，以及截取字符串。详情参考“序列”&&&& 用法如: name = 'swaroop'; name[1]; name[1:3]; name[1:-1]&& 11.str(anything)函数和 unicode(anything)函数&&&& Python 2有两个全局函数可以把对象强制转换成字符串:unicode()把对象转换成Unicode字符串，还有 str()把对象转换为非Unicode字符串。&&&& Python 3只有一种字符串类型，Unicode字符串，所以 str()函数即可完成所有的功能。(unicode()函数在Python 3里不再存在了。)&& 另外:&&&& 没有专门的char数据类型，确实没有需要有这个类型。&&&& 单引号和双引号字符串是完全相同的——它们没有在任何方面有不同。&&&& 正则表达式: 一定要用自然字符串处理正则表达式。否则会需要使用很多的反斜杠。&&&& 使用 help(str) 可查看字符串对象定义的所有方法及属性。&&&& 由于百分号有特殊作用，所以字符串里面要用百分号的话需要使用“%%”，如："select * from my_table where name like '%%测试%%'"字符串格式化控制：(未参考帮助文档，只是个人猜测)&& 转义符 (Escape Sequence)：&& \ddd&&&& 1到3位8进制数指定Unicode字符输出(如：“\127”显示“W”)&& \uxxxx&& 1到4位16进制数指定Unicode字符输出(Python3.x开始支持此写法,如: \u54C8 显示“哈”字)&& \xhh&&&& 16进制数指定Unicode字符输出(如：“\xe5\x93\x88”显示“哈”)&& \\&&&&&& \&& \&&&&&&& \ (单独的一个斜杠也显示斜杠,即不后接有转移作用的字符时，作为斜杠使用)&& \'&&&&&& '&& \"&&&&&& "&& \a&&&&&& 字符：0x07&&& 响铃(ASCII控制字符)&& \b&&&&&& 字符：0x08&&& 退格(光标向左走一格)(ASCII控制字符)&& \f&&&&&& 字符：0x0c&&& Formfeed(FF)(走纸转页,换页)(ASCII控制字符)&& \n&&&&&& 字符：0x0a&&& 换行(ASCII控制字符)&& \N{name} Unicode字符&& 只能针对Unicode&& \r&&&&&& 字符：0x0d&&& 回车&& \t&&&&&& 字符：0x09&&& 跳格(tab符号),水平制表符&& \v&&&&&& 字符：0x0b&&& 垂直制表符&& %%&&&&&& %&& %d&&&&&& 输出10进制整数，只能是数字类型，输出字符串类型会出错；浮点类型的数字将被取整(直接删除小数部分)。&& %f,%F&&& 以10进制输出浮点数，只能是数字类型，输出字符串类型会出错。&& %e,%E&&& 以科学计数法输出10进制的浮点数，大小写的“e”反应在显示时科学计数法的“e/E”上，只能是数字类型。&& %a&&&&&& Python3.0开始支持此写法，原样输出结果，字符串类型会加上单引号引起来。&& %o&&&&&& (字母o)以8进制整数方式输出，只能是数字类型；浮点类型的数字将被取整(直接删除小数部分)。&& %x,%X&&& 将数字以16进制方式输出，只能是数字类型；浮点类型的数字将被取整(直接删除小数部分)。&& %s&&&&&& 将字符串格式化输出(可输出任何类型)&& %c&&&&&& 以字符方式输出，提供的类型必须是 char 或 int 。&& 注：布尔类型的 True 或 False,用数字类型输出是 1或0,字符串输出是 True 或 False。&& 字符串转换成数字&&& float(str)&&&& 转换成浮点数,如, float("1e-1") 结果：0.1&&& int(str)&&&&&& 转换成整数,如, int("12") 结果：12&&& int(str,base)& 转换成base进制的整数,如, int("11",2) 转换成2进制的整数,结果：3&&& long(str)&&&&& 转换成长整数,Python3取消此语法,如, long("12L") 结果：12L&&& long(str,base) 转换成base进制的长整数,Python3取消此语法,如, long("11L",2) 结果：3L字符串用例&&& name = 'Swaroop' # This is a string object&&& # 检查字符串的开头部分&&& if name.startswith('Swa'):& # 类似函数如 endswith()&&&&&&& print('Yes, the string starts with "Swa"')&&& # 检查是否包含有此内容&&& if 'a' in name:&&&&&&& print('Yes, it contains the string "a"')&&& # 找出给定字符串的位置,找不到则返回-1&&& if name.find('war') != -1:&&&&&&& print('Yes, it contains the string "war"', 's')&&& # join()函数把列表拼接起来&&& delimiter = '; '&&& mylist = ['Brazil', 'Russia', 'India', 'China']&&& print(delimiter.join(mylist)) # 打印: B R I China&&& # 大小写转换&&& print("THIS IS TEST".lower())&&& # 转换成小写,打印：this is test&&& print("this is test".upper())&&& # 转换成大写,打印：THIS IS TEST&&& print("This Is Test".swapcase()) # 大小写互换,打印：tHIS iS tEST&&& print("& This Is Test& ".strip()) # 去掉前后空格,打印：This Is Test&&& # 常用 string 函数&&& replace(string,old,new[,maxsplit])&&&&&&& 字符串的替换函数，把字符串中的old替换成new。默认是把string中所有的old值替换成new值，如果给出maxsplit值，还可控制替换的个数，如果maxsplit为1，则只替换第一个old值。&&&&&&& 如： a="";print(string.replace(a,"1","one")) # 打印： oneone2223344&&&&&&&&&&&& print(string.replace(a,"1","one",1)) # 打印： one&&&&&&& b = "dfsdf&& dfsdfsd dfsdf& ";print(a.replace(' ', '')) # 打印: dfsdfdfsdfsddfsdf&&& capitalize(string)&&&&&&& 该函数可把字符串的首个字符替换成大字。&&& 如： print(string.capitalize("python")) # 打印： Python&&& split(string,sep=None,maxsplit=-1)&&&&&&& 从string字符串中返回一个列表，以sep的值为分界符。&&& 如： ip="192.168.3.3"; print(string.split(ip,'.')) # 打印： ['192', '168', '3', '3']控制台输入&&& 使用 raw_input()函数 或者 input()函数 能够很方便的控从制台读入数据，得到的是字符串。&&& Python2.x时,raw_input()和 input()的区别:&&&&&&& 当输入为纯数字时:input()返回的是数值类型，如:int, raw_input()返回的是字符串类型&&&&&&& input()会计算在字符串中的数字表达式，而 raw_input()不会。如输入“57+3”: input()得到整数60,raw_input()得到字符串'57+3'&&& 注:Python3.0将 raw_input()函数去除了,而用 input() 取代它的功能。另外,input()获取的字符串会包括结尾的换行符。&&& 例:(此处是Python2.6的写法，3.x时应该把 raw_input() 改成 input())&&&&& 1.输入字符串&&&&&&& nID = raw_input("Input your id plz:\n"); print('your id is %s' % (nID))&&&&& 2.输入整数&&&&&&& nAge = int(raw_input("input your age plz:\n")); print('your age is %d\n' % nAge)&&&&& 3.输入浮点型&&&&&&& fWeight = float(raw_input("input your weight:\n")); print('your weight is %f' % fWeight)&&&&& 4.输入16进制数据&&&&&&& nHex = int(raw_input('input hex value(like 0x20):\n'),16); print('nHex = %x,nOct = %d\n' %(nHex,nHex))&&&&& 5.输入8进制数据&&&&&&& nOct = int(raw_input('input oct value(like 020):\n'),8); print('nOct = %o,nDec = %d\n' % (nOct,nOct))&&& 注:打印字符串时，“%”作为特殊符号，两个百分号才能打印出一个百分号&&& Python 2 与 Python 3 的比较&&&&&& Python 2&&&&&&&&&&&& Python 3&&& ① raw_input()&&&&&&&&& input()&&&&&&&&& # 最简单的形式，raw_input()被替换成input()。&&& ② raw_input('prompt')& input('prompt')& # 可以指定一个提示符作为参数&&& ③ input()&&&&&&&&&&&&& eval(input())&&& # 如果想要请求用户输入一个Python表达式，计算结果&控制流:if 语句&&& 写法: if ... elif ... else ...& # if后面不用圆括号&&& 注:在Python中没有switch语句。你可以使用 if..elif..else 语句来完成同样的工作(在某些场合，使用字典会更加快捷。)&&& 在C/C++里面可以使用 else if ,但这里不行，得写成: else :\n\t if,故此增加关键字 elif&&& 例:&&& number = 23&&& # int是一个类，不过这里它只是把一个字符串转换为一个整数(假设这个字符串含有一个有效的整数文本信息)。&&& guess = int(raw_input('Enter an integer : '))&&& if guess == number:&&&&&&& print('Congratulations, you guessed it.')&&& elif guess & number:&&&&&&& print('No, it is a little higher than that') # Another block&&& else:&&&&&&& print('No, it is a little lower than that')while 语句&&& 只要条件为真，while语句允许你重复执行一块语句。&&& 注:while语句有一个可选的else从句。else块事实上是多余的，因为可以把其中的语句跟在while语句里面。&&& 例:&&& number = 23&&& running = True&&& while running:&&&&&&& guess = int(raw_input('Enter an integer : '))&&&&&&& if guess == number:&&&&&&&&&&& print('Congratulations, you guessed it.')&&&&&&&&&&& running = False # this causes the while loop to stop&&&&&&& elif guess & number:&&&&&&&&&&& print('No, it is a little higher than that')&&&&&&& else:&&&&&&&&&&& print('No, it is a little lower than that')&&& else:&&&&&&& # Do anything else you want to do here&&&&&&& print('The while loop is over.')for 循环&&& for..in 是另外一个循环语句，它在一序列的对象上 递归 即逐一使用队列中的每个项目。&&& else 部分是可选的。如果包含 else,它总是在 for 循环结束后执行一次，除非遇到 break 语句。&&& 例:&&& for i in range(1, 5):&&&&&&& print(i)&&& else:&&&&&&& print('The for loop is over')&&& # 打印结果: 1 至 4 以及 else 的内容&&& # range(1,5)给出序列[1, 2, 3, 4]。range默认步长为1,第三个参数是步长。如，range(1,5,2)给出[1,3]。&&& # 记住，range包含第一个数,但不包含第二个数。&&& 注:&&& Python的 for 循环从根本上不同于C/C++的 for 循环。类似 foreach 循环。&&& 在C/C++中，如果你想要写 for (int i = 0; i & 5; i++)，那么用Python，你写成 for i in range(0,5)。&&& # 范例：九九乘法表&&& # 由于Python2 与Python3的 print 语法不相同，改用string来打印，保证两个版本的输出结果相同。&&& str = ''&&& for i in range(1,10):&&&&&&& for j in range(1, i+1):&&&&&&&&&&& str += ('%d * %d = %d \t' % (j, i, i*j))&&&&&&& str += '\n'&&& print(str)break 语句&&& break 语句是用来 终止 循环语句的，即哪怕循环条件没有称为 False 或序列还没有被完全递归，也停止执行循环语句。&&& 一个重要的注释是，如果你从 for 或 while 循环中 终止 ，任何对应的循环 else 块将不执行。continue 语句&&& continue 语句被用来告诉Python跳过当前循环块中的剩余语句，然后 继续 进行下一轮循环。&&& break 语句 和 continue 语句 对于 while 循环 和 for 循环 都有效。&&& 例(2.x写法):&&& while True:&&&&&&& s = raw_input('Enter something : ')&&&&&&& if s == 'quit':&&&&&&&&&&& break&&&&&&& if len(s) & 3:&&&&&&&&&&& print 'Input is not of sufficient length'&&&&&&&&&&& continue&&&&&&& # Do other kinds of processing here...&&&&&&& print 'Length of the string is', len(s)&&& 例(3.x写法):&&& while True:&&&&&&& s = input('Enter something : ')& # 3.x用input()代替raw_input(),且会获取结尾输入的换行符&&&&&&& s = s[:-1] # 去掉结尾的换行符&&&&&&& if s == 'quit':&&&&&&&&&&& break&&&&&&& if len(s) & 3:&&&&&&&&&&& print('Input is not of sufficient length')&&&&&&&&&&& continue&&&&&&& # Do other kinds of processing here...&&&&&&& print('Length of the string is', len(s))函数:定义函数&&& 函数通过def关键字定义。&&& def关键字后跟一个函数的 标识符 名称，然后跟一对圆括号。圆括号之中可以包括一些变量名，该行以冒号结尾。&&& 接下来是一块语句，它们是函数体。&&& 例:&&& def sayHello():&&&&&&& print('Hello World!') # block belonging to the function&&& sayHello() # call the function函数形参&&& 函数中的参数名称为 形参 而你提供给函数调用的值称为 实参 。局部变量&&& 当你在函数定义内声明变量的时候，它们与函数外具有相同名称的其他变量没有任何关系，即变量名称对于函数来说是 局部 的。&&& 这称为变量的 作用域 。所有变量的作用域是它们被定义的块，从它们的名称被定义的那点开始。&&& 例:&&& x = 50&&& def func(x):&&&&&&& print('x is', x)&&&&&&& x = 2&&&&&&& print('Changed local x to', x) # 打印: 2&&& func(x)&&& print('x is still', x) # 打印: 50, 值没有变global 语句&&& 如果要为一个定义在函数外的变量赋值，那么你就得告诉Python这个变量名不是局部的，而是 全局 的。使用global语句完成这一功能。&&& 没有global语句，是不可能为定义在函数外的变量赋值的。&&& 你可以使用定义在函数外的变量的值(假设在函数内没有同名的变量)。然而，应避免这样做，因为这降低程序的可读性,不清楚变量在哪里定义的。&&& 使用global语句可以清楚地表明变量是在外面的块定义的。&&& 注:可以使用同一个global语句指定多个全局变量。例如 global x, y, z。&&& 例:&&& def func():&&&&&&& global x&&&&&&& print('x is', x)&&&&&&& x = 2&&&&&&& print('Changed local x to', x)& # 打印: 2&&& x = 50&&& func()&&& print('Value of x is', x)& # 打印: 2, 值被改变了默认参数值&&& 如果希望一些参数是 可选 的，这些参数可使用默认值。&&& 可以在函数定义的形参名后加上赋值运算符(=)和默认值，从而给形参指定默认参数值。&&& 注意，默认参数值应该是一个参数。&&& 例:&&& def say(message, times = 2):&&&&&&& print(message * times)&&& say('Hello ')&&&& # 打印:Hello Hello&&& say('World ', 5)& # 打印:World World World World World&&& 重要:&&& 只有在形参表末尾的那些参数可以有默认参数值，即不能在声明函数形参的时候，先声明有默认值的形参而后声明没有默认值的形参。&&& 这是因为赋给形参的值是根据位置而赋值的。例如，def func(a, b=5)是有效的，但是def func(a=5, b)是 无效 的。关键参数&&& 如果某个函数有许多参数，而你只想指定其中的一部分，那么可以通过命名来为这些参数赋值&&& ——这被称作 关键参数 ——使用名字(关键字)而不是位置来给函数指定实参。&&& 这样做有两个优势:&&&&& 一、由于我们不必担心参数的顺序，使用函数变得更加简单了。&&&&& 二、假设其他参数都有默认值，我们可以只给我们想要的那些参数赋值。&&& 例:&&& def func(a, b=5, c=10):&&&&&&& print('a is', a, 'and b is', b, 'and c is', c)&&& func(3, 7)&&&&&&& # 参数a得到值3，参数b得到值7，而参数c使用默认值10。&&& func(25, c=24)&&& # 根据实参的位置,变量a得到值25。根据命名，即关键参数，参数c得到值24。变量b根据默认值，为5。&&& func(c=50, a=100) # 使用关键参数来完全指定参数值。a得到值100,c得到值50。变量b根据默认值，为5。return 语句&&& return语句用来从一个函数 返回 即跳出函数。我们也可选从函数 返回一个值 。&&& 例:&&& def maximum(x, y):&&&&&&& if x & y:&&&&&&&&&&& return x&&&&&&& else:&&&&&&&&&&& return y&&& print(maximum(2, 3)) # 打印 3None&&& None 是Python中表示没有任何东西的特殊类型(相当于java的 null)。例如，如果一个变量的值为None，可以表示它没有值。&&& 注意:函数没有返回值的,等价于最后返回return None。通过运行print someFunction()，你可以明白这一点。&&& 例:&&& def someFunction():&&&&&&& # pass语句在Python中表示一个空的语句块。它后面的代码会照常运行。&&&&&&& pass&&& print(someFunction())DocStrings&&& DocStrings:文档字符串。它是一个重要的工具，帮助你的程序文档更加简单易懂，应该尽量使用它。甚至可以在程序运行的时候，从函数恢复文档字符串！&&& 在函数的第一个逻辑行的字符串是这个函数的 文档字符串 。注意，DocStrings也适用于模块和类。&&& 文档字符串的惯例是一个多行字符串，它的首行以大写字母开始，句号结尾。第二行是空行，从第三行开始是详细的描述。 强烈建议遵循这个惯例。&&& 例:&&& def printMax(x, y):&&&&&&& '''Prints the maximum of two numbers.&&&&&&& The two values must be integers.'''&&&&&&& x = int(x) # convert to integers, if possible&&&&&&& y = int(y)&&&&&&& if x & y:&&&&&&&&&&& print(x, 'is maximum')&&&&&&& else:&&&&&&&&&&& print(y, 'is maximum')&&& printMax(3, 5)& # 打印: 5 is maximum&&& print(printMax.__doc__)&& # 打印: Prints the maximum ... must be integers.&&& 注:&&& 使用__doc__(注意是两个下划线)调用printMax函数的文档字符串属性。请记住Python把 每一样东西 都作为对象，包括这个函数。&&& Python中help()函数即是使用DocStings的了,它只是抓取函数的__doc__属性，然后整洁地展示给你。可以对上面的函数尝试一下: help(printMax)。记住按q退出help。&&& 自动化工具也可以以同样的方式从你的程序中提取文档。因此强烈建议你对你所写的任何正式函数编写文档字符串。函数属性 func_*&&& 在Python 2里，函数的里的代码可以访问到函数本身的特殊属性。在Python 3里，为了一致性，这些特殊属性被重新命名了。&&& Python 2 与 Python 3 的比较&&&&&&&&& Python 2&&&&&&&&&&&&&&&&& Python 3&&&&&&&&&&&&&&& 说明&&&&& ① a_function.func_name&&&&& a_function.__name__&&&& # 包含了函数的名字。&&&&& ② a_function.func_doc&&&&&& a_function.__doc__&&&&& # 包含了在函数源代码里定义的文档字符串(docstring)。&&&&& ③ a_function.func_defaults& a_function.__defaults__ # 是一个保存参数默认值的元组。&&&&& ④ a_function.func_dict&&&&& a_function.__dict__&&&& # 一个支持任意函数属性的名字空间。&&&&& ⑤ a_function.func_closure&& a_function.__closure__& # 一个由cell对象组成的元组，包含了函数对自由变量(free variable)的绑定。&&&&& ⑥ a_function.func_globals&& a_function.__globals__& # 一个对模块全局名字空间的引用，函数本身在这个名字空间里被定义。&&&&& ⑦ a_function.func_code&&&&& a_function.__code__&&&& # 一个代码对象，表示编译后的函数体。&模块:&&& 如果要在其他程序中重用很多函数，那么你该使用模块。&&& 模块基本上就是一个包含了所有你定义的函数和变量的文件。&&& 为了在其他程序中重用模块，模块的文件名必须以.py为扩展名。sys模块(标准库模块)&&& sys模块包含了与Python解释器和它的环境有关的函数。&&& 例:&&& import sys& # 输入 sys模块。基本上，这句语句告诉Python，我们想要使用这个模块。&&& print('The command line arguments are:')&&& # 打印调用文件的命令行参数&&& for i in sys.argv:&&&&&&& print(i)&&& print('\nThe PYTHONPATH is', sys.path)&&& 输出:&&& $ python using_sys.py we are arguments&&& The command line arguments are:&&& using_sys.py&&& we&&& are&&& arguments&&& The PYTHONPATH is ['/home/swaroop/byte/code', '/usr/lib/python23.zip',&&& '/usr/lib/python2.3', '/usr/lib/python2.3/plat-linux2',&&& '/usr/lib/python2.3/lib-tk', '/usr/lib/python2.3/lib-dynload',&&& '/usr/lib/python2.3/site-packages', '/usr/lib/python2.3/site-packages/gtk-2.0']&&& 注:&&& 执行 import sys 语句的时候，它在 sys.path 变量中所列目录中寻找 sys.py 模块。&&& 如果找到了这个文件，这个模块的主块中的语句将被运行，然后这个模块将能够被你使用。&&& 注意，初始化过程仅在我们 第一次 输入模块的时候进行。另外，“sys”是“system”的缩写。&&& 脚本的名称总是sys.argv列表的第一个参数。所以，在这里，'using_sys.py'是sys.argv[0]、'we'是sys.argv[1]。&&& sys.path包含输入模块的目录名列表。&&& 可以观察到sys.path的第一个字符串是空的——这个空的字符串表示当前目录也是sys.path的一部分，这与PYTHONPATH环境变量是相同的。&&& 这意味着你可以直接输入位于当前目录的模块。否则，你得把你的模块放在sys.path所列的目录之一。&&& 另外:&&& sys.exit() # 程序结束&&& sys.stdin、 sys.stdout 和 sys.stderr 分别对应你的程序的标准输入、标准输出和标准错误流。字节编译的.pyc文件&&& 输入一个模块相对来说是一个比较费时的事情，所以Python做了一些技巧，以便使输入模块更加快一些。&&& 一种方法是创建 字节编译的文件，这些文件以.pyc作为扩展名。另外，这些字节编译的文件也是与平台无关的。&&& 当你在下次从别的程序输入这个模块的时候，.pyc文件是十分有用的——它会快得多，因为一部分输入模块所需的处理已经完成了。from ... import 语句&&& 如果你想要直接输入 argv 变量到你的程序中(避免在每次使用它时打sys.)，那么你可以使用 from sys import argv 语句。&&& 如果你想要输入所有 sys 模块使用的名字，那么你可以使用 from sys import *语句。&&& 这对于所有模块都适用。&&& 注意:&&&&&&& 1.使用 from package import item 方式导入包时，这个子项(item)既可以是包中的一个子模块(或一个子包)，也可以是包中定义的其它命名，像函数、类或变量。&&&&&&&&& import 语句首先核对是否包中有这个子项，如果没有，它假定这是一个模块，并尝试加载它。如果没有找到它，会引发一个 ImportError 异常。&&&&&&& 2.使用像 import item.subitem.subsubitem 这样的语句时，这些子项必须是包，最后的子项可以是包或模块，但不能是前面子项中定义的类、函数或变量。&&&&&&& 3.应该避免使用 from...import 而使用 import 语句，因为这样可以使你的程序更加易读，也可以避免名称的冲突。import ... as&&& 为 import 的模块起一个简称。如: import cPickle as p&&& 起简称后,下面的语句即可使用简称,如原本的 cPickle.dump() 可写成 p.dump()模块的 __name__&&& 每个模块都有一个名称，在模块中可以通过语句来找出模块的名称。&&& 这在一个场合特别有用——就如前面所提到的，当一个模块被第一次输入的时候，这个模块的主块将被运行。&&& 假如我们只想在程序本身被使用的时候运行主块，而在它被别的模块输入的时候不运行主块，我们该怎么做呢？这可以通过模块的__name__属性完成。&&& 每个Python模块都有它的__name__，如果它是'__main__'，这说明这个模块被用户单独运行，我们可以进行相应的恰当操作。&&& 例:&&& # Filename: using_name.py&&& if __name__ == '__main__':&&&&&&& print('This program is being run by itself')&&& else:&&&&&&& print('I am being imported from another module')&&& 输出:&&& $ python using_name.py&&& This program is being run by itself&&& $ python&&& &&& import using_name&&& I am being imported from another module自定义模块&&& 每个Python程序也是一个模块。&&& 模块,例:&&& # Filename: mymodule.py&&& def sayhi():&&&&&&& print('Hi, this is mymodule speaking.')&&& version = '0.1'&&& # End of mymodule.py&& 上面是一个 模块 的例子。你已经看到，它与我们普通的Python程序相比并没有什么特别之处。&& 记住这个模块应该被放置在我们输入它的程序的同一个目录中，或者在 sys.path 所列目录之一。&&& 用例1:&&& import mymodule&&& mymodule.sayhi()&&& print('Version', mymodule.version)&&& 注:函数和成员都以点号来使用。&&& 用例2:& 使用from..import语法的版本。&&& from mymodule import sayhi, version& # 或者写: from mymodule import *&&& sayhi()&&& print('Version', version)包(Packages)&&& 包通常是使用用“圆点模块名”的结构化模块命名空间。例如， A.B 表示名为"A" 的包中含有名为"B"的子模块。&&& 使用圆点模块名保存不同类库的包可以避免模块之间的命名冲突。(如同用模块来保存不同的模块架构可以避免变量之间的命名冲突)&&& 包目录必须要有一个 __init__.py 文件的存在；这是为了防止命名冲突而无意中在随后的模块搜索路径中覆盖了正确的模块。&&& 最简单的情况下， __init__.py 可以只是一个空文件，不过它也可能包含了包的初始化代码，或者设置了 __all__ 变量。dir()函数&&& 使用内建的dir函数来列出模块定义的标识符。标识符有函数、类和变量。&&& 当你为 dir()提供一个模块名的时候，它返回模块定义的名称列表。如果不提供参数，它返回当前模块中定义的名称列表。&&& $ python&&& &&& import sys&&& &&& dir(sys) # get list of attributes for sys module&&& ['__displayhook__', '__doc__', '__excepthook__', '__name__', '__stderr__',&&& '__stdin__', '__stdout__', '_getframe', 'api_version', 'argv',&&& 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats',&&& 'copyright', 'displayhook', 'exc_clear', 'exc_info', 'exc_type',&&& 'excepthook', 'exec_prefix', 'executable', 'exit', 'getcheckinterval',&&& 'getdefaultencoding', 'getdlopenflags', 'getfilesystemencoding',&&& 'getrecursionlimit', 'getrefcount', 'hexversion', 'maxint', 'maxunicode',&&& 'meta_path','modules', 'path', 'path_hooks', 'path_importer_cache',&&& 'platform', 'prefix', 'ps1', 'ps2', 'setcheckinterval', 'setdlopenflags',&&& 'setprofile', 'setrecursionlimit', 'settrace', 'stderr', 'stdin', 'stdout',&&& 'version', 'version_info', 'warnoptions']&&& &&& dir() # get list of attributes for current module&&& ['__builtins__', '__doc__', '__name__', 'sys']&&& &&&&&& &&& a = 5 # create a new variable 'a'&&& &&& dir()&&& ['__builtins__', '__doc__', '__name__', 'a', 'sys']&&& &&&&&& &&& del a # delete/ 这个得留意&&& &&&&&& &&& dir()&&& ['__builtins__', '__doc__', '__name__', 'sys']&&& &&&数据结构&&& 可以处理一些 数据 的 结构 。或者说，它们是用来存储一组相关数据的。&&& 在Python中有三种内建的数据结构——列表、元组和字典。列表(list, 有的语言称为:数组)&&& 是处理一组有序项目的数据结构，即你可以在一个列表中存储一个 序列 的项目。&&& 列表中的项目应该包括在方括号中，每个项目之间用逗号分割。&&& 可以添加、删除或是搜索列表中的项目。列表是 可变的 数据类型。&&& 列表对象定义的所有方法可以通过 help(list) 获得完整的知识。我比较习惯称它为“数组”。&&& 例:&&& shoplist = ['apple', 'mango', 'carrot', 'banana']&&& #查看长度&&& print('I have', len(shoplist),'items to purchase.')&&& #遍历&&& print('These items are:', end=' ') # 注意这行的结尾,打印时可以不换行,python 2.x应该用逗号结尾&&& for item in shoplist:&&&&&&& print(item, end=' ') # python 2.x 此行应该写：“print item,”&&& #添加&&& print('\nI also have to buy rice.')&&& shoplist.append('rice')&&& print('My shopping list is now:', shoplist)&&& #排序&&& print('I will sort my list now')&&& shoplist.sort()&&& print('Sorted shopping list is:', shoplist)&&& #删除,以及使用下标&&& print('The first item I will buy is:', shoplist[0])&&& olditem = shoplist[0]&&& del shoplist[0]&&& print('I bought the', olditem)&&& print('My shopping list is now:', shoplist)&&& #多维列表时,保存的对象只是引用&&& newlist = ['waa','dd']&&& shoplist.append(newlist)&&& print('My shopping list is now:', shoplist)&&& del newlist[0]&&& print('My shopping list is now', shoplist)&&& # 删除重复, 用 set (对元组也可以这样写)&&& L = [1,1,1,2,2]&&& print(list(set(L))) # 打印：[1, 2]&&& l = [(1, 2), (1, 2), 3, 5, 4, 3, 4, (1, 2), 0, 5]&&& l = list(set(l))&&& print(l) # 打印: [(1, 2), 0, 3, 4, 5]&&& # 复制列表(浅拷贝)&&& c = shoplist[:]&&& # 复制(深拷贝)&&& import copy&&& c = copy.deepcopy(shoplist)元组(tuple)&&& 元组和列表十分类似，只不过元组和字符串一样是 不可变的 即你不能修改元组。&&& 元组通过圆括号中用逗号分割的项目定义。&&& 元组通常用在使语句或用户定义的函数能够安全地采用一组值的时候，即被使用的元组的值不会改变。&&& 如果你想要知道元组对象定义的所有方法，可以通过 help(tuple) 获得完整的知识。&&& 例:&&& #一维元组&&& zoo = ('wolf', 'elephant', 'penguin')&&& print('Number of animals in the zoo is %s' % len(zoo))& # 打印: 3&&& newlist = ['waa','dd']&&& #多维元组&&& new_zoo = ('monkey', 'dolphin', zoo, newlist)&&& print('Number of animals in the new zoo is %s' % len(new_zoo))& # 打印: 3&&& print('All animals in new zoo are %s' % str(new_zoo))& # 打印: ('monkey','dolphin',('wolf','elephant','penguin'),['waa','dd'])&&& print('Animals brought from old zoo are %s' % str(new_zoo[2]))& # 打印: ('wolf', 'elephant', 'penguin')&&& print('Last animal brought from old zoo is %s' % new_zoo[2][2]) # 打印: penguin&&& #多维元组时,保存的对象只是引用&&& del newlist[0]&&& print('new_zoo is now:' + str(new_zoo) )& # 打印: ('monkey','dolphin',('wolf','elephant','penguin'),['dd'])&&& 注意:含有0个或1个项目的元组&&& 一个空的元组(含有0个项目)由一对空的圆括号组成，如myempty = ()。&&& 含有单个元素的元组必须在第一个(唯一一个)项目后跟一个逗号。如: singleton = (2 , )。&&& 如果小括号里面只有唯一一个项目,而这个项目后面又没有跟一个逗号的话,Python会认为它是一个表达式。字典(dict, 有的语言称为:json)&&& 字典把键(名字)和值(详细情况)联系在一起。&&& 注意，键必须是唯一的，且只能使用不可变的对象(比如字符串)来作为字典的键，但字典的值没有此限制。应该说只能使用简单的对象作为键。&&& 键值对在字典中以这样的方式标记：d = {key1 : value1, key2 : value2 }。&&& 键值对用冒号分割，而各个对用逗号分割，所有这些都包括在花括号中。&&& 记住字典中的键/值对是没有顺序的。如果要一个特定的顺序，那么应该在使用前自己对它们排序。&&& 字典是dict类的实例/对象，可以用 help(dict) 来查看其属性和函数。&&& 例:&&& ab = { 'Swaroop': 'swar',&&&&&&&&&& 'Larry'& : 'larry',&&&&&&&&&& 'Spammer': 'spammer'&&&&&&&& }&&& print(ab) # 打印: {'Swaroop':'swar', 'Larry':'larry', 'Spammer':'spammer'}&&& print("Swaroop's address is %s" % ab['Swaroop'])& # 打印: swar&&& # 添加值,或者设值&&& ab['Guido'] = 'guido'&&& # 删除值&&& del ab['Spammer']&&& # ab.pop('Spammer') # 也可以用 pop 来删除，但建议后面的这种写法，避免没有这个键时会报错： ab.pop('Spammer', None)&&& print('\nThere are %d contacts in the address-book\n' % len(ab)) # 打印: 3&&& # 遍历(这写法得留意)&&& for name, address in ab.items():&&&&&&& print('Contact %s at %s' % (name, address))&&& # 包含key&&& if 'Guido' in ab: # 或者写： if ab.has_key('Guido'):&&&&&&& print("\nGuido's address is %s" % ab['Guido'])&&& # 原字典上创建新字典&&& print(ab) # 打印: {'Swaroop':'swar', 'Larry':'larry', 'Guido':'guido'}&&& dd = dict(ab, slug_field='slug', test=5) # 创建新字典,字典作为参数的只能放第一个，其余不能再是字典；字典参数可省略&&& print(dd) # 打印: {'Swaroop':'swar', 'test':5, 'slug_field':'slug', 'Larry':'larry', 'Guido':'guido'}&&& # 建议的取值方法&&& print( ab['test'] )& # 这样取值，当字典里面没有对应的key时会报错:“KeyError”&&& print( ab.get('test', 'default_value') )& # get取值，当字典里面没有对应的key时可取后面的预设值,预设值是可选的(默认是 None)&&& # 所有的键和值&&& print(ab.keys())&& # 所有的键&&& print(ab.values()) # 所有的值&&& # 复制(浅拷贝)&&& print(ab.copy())&&& # 复制(深拷贝)&&& import copy&&& c = copy.deepcopy(ab)序列&&& 列表、元组和字符串都是序列，序列的两个主要特点是“索引”操作符和“切片”操作符。&&& 索引操作符让我们可以从序列中抓取一个特定项目。(即使用下标)&&& 切片操作符让我们能够获取序列的一个切片，即一部分序列。(即在下标的中括号里面使用冒号)&&& 例:&&& shoplist = ['apple', 'mango', 'carrot', 'banana']&&& # Indexing or 'Subscription' operation&&& print('Item 0 is %s' % shoplist[0])&&& print('Item 3 is %s' % shoplist[3])&&& print('Item -1 is %s' % shoplist[-1])&& # 打印:banana&& 即倒数第一个&&& print('Item -2 is %s' % shoplist[-2])&& # 打印:carrot&& 即倒数第二个&&& # Slicing on a list&&& print('Item 1 to 3 is %s' % shoplist[1:3])&&&&& # 打印:['mango', 'carrot']&& 即下标[1]到[3],包括开始但不包括结束&&& print('Item 2 to end is %s' % shoplist[2:])&&&& # 打印:['carrot', 'banana']& 即下标[2]到结束,包括最后一个&&& print('Item 1 to -1 is %s' % shoplist[1:-1])&&& # 打印:['mango', 'carrot']&& 即下标[1]到[-1],包括开始但不包括结束&&& print('Item start to end is %s' % shoplist[:])& # 打印整个列表,跟直接写“shoplist”效果一样&&& # Slicing on a string (string与列表有同样的操作,)&&& name = 'swaroop'&&& print('characters 1 to 3 is %s' % name[1:3])&&&& # 打印:wa&&& print('characters 2 to end is %s' % name[2:])&&& # 打印:aroop&&& print('characters 1 to -1 is %s' % name[1:-1])&& # 打印:waroo&&& print('characters start to end is %s' % name[:]) # 打印:swaroop& 跟直接写这个字符串一样参考(引用)&&& 当你创建一个对象并给它赋一个变量的时候，这个变量仅仅 参考 那个对象，而不是表示这个对象本身！&&& 也就是说，变量名指向你计算机中存储那个对象的内存。&&& 这被称作名称到对象的绑定。&&& 例:&&& shoplist = ['apple', 'mango', 'carrot', 'banana']&&& mylist = shoplist # mylist 只是对象的另一个名称,他们指向相同的内存空间&&& del shoplist[0]&&& # 他们此时打印相同的内容,都少了'apple'&&& print('shoplist is', shoplist)&&& print('mylist is', mylist)&&& # 深拷贝,复制成另一个对象(得记住用切片操作符来取得拷贝)&&& mylist = shoplist[:] # make a copy by doing a full slice&&& del mylist[0] # remove first item&&& # 注意，现在他们打印出不同的内容&&& print('shoplist is', shoplist)&&& print('mylist is', mylist)列表综合&&& 通过列表综合，可以从一个已有的列表导出一个新的列表。&&& [返回值 for 元素 in 列表 if 条件] 比如 [num for num in xrange(100) if num%2==0] 返回0～99之间的偶数列表&&& # 例如，你有一个数的列表，而你想要得到一个对应的列表，使其中所有大于2的数都是原来的2倍。对于这种应用，列表综合是最理想的方法。&&& listone = [2, 3, 4]&&& listtwo = [2*i for i in listone if i & 2] # 为满足条件(if i & 2)的数指定了一个操作(2*i)，从而导出一个新的列表。&&& print(listtwo) # 打印: [6, 8]&&& ls=[1,3,5,7] # reduce 在python3去掉了&&& print(reduce(lambda x,y:x+y,ls)) # 计算过程就是 1+3=4 然后4+5得到结果9，再加7，以此类推，最后返回最终计算的结果(总和)；打印：16&&& # 将字典的key，value倒过来的写法：&&& a_dict = {'a': 1, 'b': 2, 'c': 3}&&& # python3 的写法:&&& b_dict = {value:key for key, value in a_dict.items()}&&& # python2 时的写法：&&& b_dict = {}&&& for key, value in a_dict.iteritems():&&&&&&& b_dict[value] = key&&& print(b_dict) # key与value翻转，打印: {1:'a', 2:'b', 3:'c'}&&& 说明:&&& 注意原来的列表并没有发生变化。&&& 在很多时候，我们都是使用循环来处理列表中的每一个元素，而使用列表综合可以用一种更加精确、简洁、清楚的方法完成相同的工作。&&& 小心 list 的 += 操作(python2时可以用，python3不可以再这样用)集合&&& Python3 开始有这写法,跟之前的差不多,只是用大括号括起来,如： a = {1, 'aa', 3, 5, 6}&&& 集合同样可以使用综合计算，如： a = {x for x in range(10) if x % 2 == 0}&成员测试 in, not in&&& 检查是否包含有此内容,返回 True 或者 False, 例如：&&& # 1.对字符串&&& if 'a' in 'Swaroop':&&&&&&& print('Yes, it contains the string "a"')&&& # 2.对集合(列表、元组和字典)&&& if 'genre' in ('genre', 'jazz'):&&&&&&& print('Yes, it contains the genre')&&& print('genre' in ('genre', 'jazz')) # 元组,打印： True&&& print('genre' in ['genre', 'jazz']) # 列表,打印： True&&& print('genre' in {'genre':'sss', 'jazz':'dddd'}) # 字典,检查key，打印： True&&& print('sss' in {'genre':'sss', 'jazz':'dddd'}) # 字典,打印： False排序&&& 1.sort方法&&&&& Python语言内置了sort方法，可以很方便地对某个List进行排序&&&&& 例如：&&&&&&& L = [6, 5, 1, 3, 4, 2]&&&&&&& L.sort()&&&&&&& print(L) # 打印：[1, 2, 3, 4, 5, 6]&&&&&&& li=[(2,'a'),(4,'b'),(1,'d')]&&&&&&& li.sort() # 元组列表排序&&&&&&& print(li) # 打印： [(1, 'd'), (2, 'a'), (4, 'b')]&&& 2.自定义排序(例如，按关键词的权重排序，按人的年龄排序，等等)&&&&& 若List中每个元素都是2-tuple，tuple中第一个元素为String类型的keyword，第二个元素为该字符串对应的权重(int类型)，希望按照权重排序(从高到低)，则可以这样：&&&&&&& L = [('b', 1), ('a', 0), ('c', 2), ('d', 3)]&&&&&&& # L.sort(lambda E1, E2: -cmp(E1[1], E2[1])) # cmp函数里面是需比较的两个值，负号表示倒序。(python2 的写法)&&&&&&& L.sort(key=lambda d:-d[1]) # Python3的写法，由于去掉了cmp()函数,得传入key参数； python2也可以这样用；负号表示倒序&&&&&&& print(L) # 打印：[('d', 3), ('c', 2), ('b', 1), ('a', 0)]&&& 3.dict排序&&&&& 对字典的排序，因为每一个项包括一个键值对，所以要选择可比较的键或值进行排序&&&&&&& sorted(iterable[, cmp[, key[, reverse]]])&&&&&&& # cmp 和 key 一般使用 lambda&&&&&&& 如：&&&&&&& d={"ok":1,"no":2}&&&&&&& # 对字典按键排序，用元组列表的形式返回&&&&&&& print(sorted(d.items(), key=lambda a:a[0])) # 打印： [('no', 2), ('ok', 1)]&&&&&&& print(sorted(d)) # 打印：['no', 'ok']&&&&&&& print(d) # 原字典并未改变，打印：{'ok':1, 'no':2}&&&&&&& # 对字典按值排序，用元组列表的形式返回&&&&&&& print(sorted(d.items(), key=lambda d:d[1])) # 打印：[('ok', 1), ('no', 2)]&&&&&&& # 排序后再转成字典，就无法再保证排序了&&&&&&& b = sorted(d.items(), key=lambda v:v[0])&&&&&&& print(b) # 打印： [('no', 2), ('ok', 1)]&&&&&&& print(dict(b)) # (排序又乱了)打印： {'ok': 1, 'no': 2}&&& 4.类的排序&&&&&&& class test:&&&&&&&&&&& def __init__(self,a,b):&&&&&&&&&&&&&&& self.a = a&&&&&&&&&&&&&&& self.b = b&&&&&&& test1 = test(5,25)&&&&&&& test2 = test(50,35)&&&&&&& test3 = test(10,15)&&&&&&& tests = [test1, test2, test3]&&&&&&& # 以 cmp 来指定排序方式, python3不可以这样写(没有cmp参数及cmp函数)&&&&&&& result = sorted(tests,cmp = lambda x,y: cmp(x.a, y.a))&&&&&&& # 遍历排序结果，结果是已排序的： a:5& a:10& a:50&&&&&&& for item in result:&&&&&&&&&&& print("a:%s" % item.a)&&&&&&& # 以 key 来排序，结果也是可以的&&&&&&& result2 = sorted(tests,key = lambda d:d.a)&&&&&&& for item in result2:&&&&&&&&&&& print("a:%s" % item.a)&&&&&&& # 遍历原资料，原资料的顺序没有改变&&&&&&& for item in tests:&&&&&&&&&&& print("a:%s" % item.a)&&& 5.注意：&&&&& python3 由于去掉了 cmp() 函数，可以用“(a & b) - (a & b)”代替“ cmp(a, b) ”&&& 6.冒泡算法，如下：&&&&&&& num = [23,2,3,6,18,9,33,13,24,19]&&&&&&& for i in range(len(num)-1):&&&&&&&&&&& for j in range(len(num)-i-1):&&&&&&&&&&&&&&& if (num[j] & num[j+1]):&&&&&&&&&&&&&&&&&&& num[j], num[j+1] = num[j+1], num[j] # 置换，这样写比较简便，不需再用临时变量&&&&&&& print(num)综合实例：&&& 在Python中对列表，元组，字典等内置的数据结构的处理是很方便的事情，python借鉴了Lisp中的很多函数式计算的方法来处理列表，可以极大的简化我们的代码。&&& 1. set():& 将元组，列表 转化成没有重复项的集合&&& 2. list(): 将集合，元组转化成列表&&& 3. tuple(): 将集合，列表转化成元组&&& 4. map(func,list):将list的每一个元素传递给func的函数，这个函数有一个参数，且返回一个值，map将每一次调用函数返回的值组成一个新列表返回&&& 5. filter(func,list):将list的每一个元素传递给func的函数，这个函数有一个参数，返回bool类型的值，filter将返回True的元素组成新列表返回&&& 6. reduce(func,list):将list的元素，挨个取出来和下一个元素通过func计算后将结果和再下一个元素继续计算&&& 一、列表去重&&&&&&& ls = [1,3,2,5,2,1,3,4,6]&&&&&&& ls = list(set(ls)) # 最简单的列表去除重复&&&&&&& L = [1, 8, 3, 4, 6, 2, 3, 4, 5]&&&&&&& kk = [x for x in L if x not in locals()['_[1]']] # 保留原顺序的去除重复,只有 2.6 上可以, 2.7 以上版本不能这样写&&&&&&& # '_[1]' 是个内部临时变量，可查看:& [x for x, y in locals().items()]&&& 二、假如有列表：&&&&&&& books = [&&&&&&&&&&& {"name":"C#从入门到精通",& "price":23.7,& "store":"卓越"},&&&&&&&&&&& {"name":"ASP.NET高级编程", "price":44.5,& "store":"卓越"},&&&&&&&&&&& {"name":"C#从入门到精通",& "price":24.7,& "store":"当当"},&&&&&&&&&&& {"name":"ASP.NET高级编程", "price":45.7,& "store":"当当"},&&&&&&&&&&& {"name":"C#从入门到精通",& "price":26.7,& "store":"新华书店"},&&&&&&&&&&& {"name":"ASP.NET高级编程", "price":55.7,& "store":"新华书店"},&&&&&&& ]&&&&&&& 2.1 求《ASP.NET高级编程》价格最便宜的店：&&&&&&& storename=min([b for b in books if b['name']=="ASP.NET高级编程"],key=lambda b:b['price'])["store"]&&&&&&& 过程：先用列表解析取出《ASP.NET高级编程》的列表，通过min函数，比较字典的price键获取price最小的项&&&&&&& 2.2 求在新华书店购买两本书一样一本要花的钱：&&&&&&& price=sum([b['price'] for b in books if b['store']=="新华书店"])&&&&&&& 2.3 求列表中有那几本书：&&&&&&& booknames=list(set([b['name'] for b in books]))&&&&&&& 2.4 列表里的书都打5折：&&&&&&& books=map(lambda b:dict(name=b['name'],price=b['price']*0.5,store=b['store']),books)&&&&&&& 2.5 《C#从入门到精通》的平均价格：&&&&&&& avg=(lambda ls:sum(ls)/len(ls))([b['price'] for b in books if b['name']=="C#从入门到精通"])&&&&&&& 2.6 求每本书的平均价格：&&&&&&& book_avg=map(lambda bookname:dict(name=bookname,avg=(lambda ls:sum(ls)/len(ls))([b['price'] for b in books if b['name']==bookname])),list(set([b['name'] for b in books])))&&&&&&& 这段代码放在一行比较难看懂，但是格式化一下就很好懂了，构建的过程如下：&&&&&&&&&&& step1: 要求每本书的平均价格，首先要得到共有几本书，方法见2.3，得到去重的书名列表&&&&&&&&&&& list(set([b['name'] for b in books])) #去重后的书名列表&&&&&&&&&&& step2: 要求每一本书的均价，需要将计算均价的函数映射到每一本书上，于是&&&&&&&&&&& map(&&&&&&&&&&&&&&& #计算均价的函数，&&&&&&&&&&&&&&& list(set([b['name'] for b in books])) #去重后的书名列表&&&&&&&&&&& )&&&&&&&&&&& step3: 加入计算单本书均价的函数，参考2.5的方法，由于只用一行，所以用lambda来搞定：&&&&&&&&&&& func=lambda bookname:(lambda ls:sum(ls)/len(ls))([b.price for b in books if b['name']==bookname])&&&&&&&&&&& step4: 将计算单本均价的lambda函数加入map中，得到最终结果：&&&&&&&&&&& 经过格式化后的结果，前面的单行代码可以格式化为下面容易阅读的形式&&&&&&&&&&& book_avg=map(&&&&&&&&&&&&&&& lambda bookname:&&&&&&&&&&&&&&&&&&& dict(&&&&&&&&&&&&&&&&&&&&&&& name = bookname,&&&&&&&&&&&&&&&&&&&&&&& # 计算单本书均价的函数&&&&&&&&&&&&&&&&&&&&&&& avg& = (lambda ls:sum(ls)/len(ls)) ([b['price'] for b in books if b['name']==bookname])&&&&&&&&&&&&&&&&&&& ),&&&&&&&&&&&&&&& #去重后的书名列表&&&&&&&&&&&&&&& list(&&&&&&&&&&&&&&&&&&&& set(&&&&&&&&&&&&&&&&&&&&&&&& [b['name'] for b in books]&&&&&&&&&&&&&&&&&&&& )&&&&&&&&&&&&&&& )&&&&&&&&&&& )在函数中接收元组和列表(函数的参数数量可以变动,即可变长参数)&&& 当要使函数接收元组或字典形式的参数的时候，有一种特殊的方法，它分别使用*和**前缀。&&& 这种方法在函数需要获取可变数量的参数的时候特别有用。&&& 而且，使用*和**前缀的参数还可以传递给其它函数。&&& 例:&&& # 由于在args变量前有*前缀，所有多余的函数参数都会作为一个元组存储在args中&&& def sum(message, *args):&&&&&&& '''Return the sum of each argument.'''&&&&&&& total = 0&&&&&&& # 除了用循环,也可以用下标来读取参数,如: args[0]&&&&&&& for i in args:&&&&&&&&&&& total += i&&&&&&& print (str(type(args)) + '& ' + message + ":" + str(total))&&&&&&& sum2(args) # 这样传过去的 args 是一个元组；打印如： ((3, 5.5),)&&&&&&& sum2(*args) # 这样传过去的 *args 表示多个参数；打印如：(3, 5.5)&&& def sum2(*args):&&&&&&& print(args)&&& sum('hight', 3, 5.5) # 打印: &type 'tuple'&& hight:8.5&&& sum('weight', 10)&&& # 打印: &type 'tuple'&& weight:10&&& # 函数参数接收字典用法。使用的是**前缀，多余的参数则会被认为是一个字典的键/值对。&&& def printDict(message, **args):&&&&&&& print(str(type(args)) + '& ' + message + ':' + str(args))&&&&&&& printDict2(args = args) # 可这样，把 args 当做一个值(里面是字典)，传过去；打印如: {'args': {'a': 3, 'b': 'dd'}}&&&&&&& printDict2(**args) # 也可这样，把 **args 看做传过来的多个键/值对，传过去；打印如：{'a': 3, 'b': 'dd'}&&& def printDict2(**args):&&&&&&& print(args)&&& # 注意:参数为字典时,参数里面必须使用等号,否则运行出错&&& printDict('hight', a=3, b='dd') # 打印: &type 'dict'&& hight:{'a': 3, 'b': 'dd'}&&& # 可以混合使用*和**前缀的参数, 但是必须 *args 在前, **args 在后,否则编译不通过&&& def printMul(message, *args1, **args2):&&&&&&& print(message + '& args1:' + str(args1) + '& args2:' + str(args2))&&& printMul('hello', 5, 4, a=2, b=3) # 打印： hello& args1:(5, 4)& args2:{'a': 2, 'b': 3}面向对象的编程&&& 面向过程的编程:根据操作数据的函数或语句块来设计程序的。&&& 面向对象的编程:把数据和功能结合起来，用称为对象的东西包裹起来组织程序的方法。&&& 类和对象是面向对象编程的两个主要方面。“类”创建一个新类型，而“对象”是这个类的实例。&&& 域:属于一个对象或类的变量。&&& 方法:属于类的函数，被称为类的方法。&&& 域和方法可以合称为类的属性。&&& 域有两种类型——属于每个实例/类的对象或属于类本身。它们分别被称为实例变量和类变量。&&& 类使用class关键字创建。类的域和方法被列在一个缩进块中。self 参数&&& 类的方法与普通的函数只有一个特别的区别——它们“必须”有一个额外的第一个参数名称，但是在调用这个方法的时候你不为这个参数赋值，Python会提供这个值。这个特别的变量指对象本身，按照惯例它的名称是self。&&& 虽然你可以给这个参数任何名称，但是“强烈建议”使用self这个名称——其他名称都是不赞成使用的。&&& 使用一个标准的名称有很多优点——1.方便别人阅读；2.有些IDE(集成开发环境)也可以帮助你。&&& Python中的self等价于C++中的self指针和Java、C#中的this参考。&&& 例:&&& class Person:&&&&&&& def sayHi(self):& # self参数必须写&&&&&&&&&&& print('Hello, how are you?')&&& p = Person()&&& p.sayHi() # self参数不需赋值&&& print(p)& # 打印: &__main__.Person instance at 0xf6fcb18c&&& (已经在__main__模块中有了一个Person类的实例)类的变量和对象的变量&&& 类的变量: 由一个类的所有对象(实例)共享使用。当某个对象对类的变量做了改动的时候，这个}