python教程／学习笔记

一.python引论

1.1.将Python程序代码保存为以.py结尾的文件

1.2.缩进的一致性

1.3.获取用户输入：

>>>x=raw_input('x:')

# raw_input与input区别，前者获取用户输入后返回的类型是字符串，后者返回初始值。x:2

>>>y=raw_input('y:')

y:3

print x*y

6# 结束

1.4.赋值时要注意，如果赋的是列表、字典和set，那么不能直接用赋值号=，而是要用copy 函数，因为这三种容器本质上赋的是地址。其他情况的赋值无所谓。

二.python基本语法

2.1.python文件类型

2.1.1文件分类：

1）*.py文件，这就是我们常见的py源文件，没什么好说的；

2）*.pyc，py源文件编译成的二进制字节码文件，依然由python加载执行，不过速度会提高，也会隐藏源码；

3）*.pyo，优化编译后的程序，也是二进制文件，适用于嵌入式系统。

2.1.2、生成pyc和pyo文件

1）如何生成pyc文件呢？

假设我们有一个1.py文件需要编译成pyc文件，则在python shell输入

import py_compile

py_https://www.360docs.net/doc/441164700.html,pile('1.py')

这样就可以生成pyc文件了

2）如何生成pyo文件呢？

python -O -m py_compile 1.py

另外，pyc和pyo跟py文件是一样的，依然可以用python 1.pyc等形式执行

2.2.python编码规则(见pdf文件)

2.2.1. 关于缩进：python 是通过缩进来进行代码布局的。使用vi 可以在~/.vimrc 中配置几个空格来代表一个tab，从而来布局python 函数的缩进。可以只用空格，也可以全部使用tab键，这样也不会出错。注意空格与tab不能混用。

2.2.2.关于行长度：反斜杠续行。

2.2.

3.用两行分割顶层函数和类的定义；用一行分割类成员方法的定义；在一个函数内用空行时请注意谨慎使用于一个逻辑段。

2.2.4. 在python 2.4 之后内核已经开始支持Unicode 了。

无论什么情况下，使用UTF-8 才是王道！

1 # -*- coding:utf-8 -*-

2

2.2.5. 导入

通常应该在单独行中使用导入。

例如：No: import sys, os

Yes: import sys

import os

但是这样也是可以的：

from types import StringType, ListType

imports 应该放在文件的顶部，仅在模块注释和文档字符串之后，在模块的全局变量和常量之前。

Imports 也是有顺序的：1)Python 标准库的import；2)第三方库的import；3)自定义的库的import；

并且在每组的import 之间使用一行空行分割。

2.2.6.以下地方不推荐出现空格:

1) 紧挨着圆括号,方括号和花括号的

如:"spam( ham[ 1 ], { eggs: 2 } )".写成"spam(ham[1], {eggs: 2})".

2) 紧贴在逗号,分号或冒号前的

如: "if x == 4 : print x , y ; x , y = y , x". 写成"if x == 4: print x, y; x, y = y, x".

3) 紧贴着函数调用的参数列表前开式括号的

如: "dict ['key'] = list [index]". 写成"dict['key'] = list[index]".

4) 紧贴在索引或切片下标开始的开式括号前

如: "dict ['key'] = list [index]".写成"dict['key'] = list[index]".

5) 在赋值(或其它)运算符周围的用于和其它并排的一个以上的空格,如:

1 x = 1

2 y = 2

3 long_variable = 3

写成

1 x = 1

2 y = 2

3 long_variable = 3

6)始终在这些二元运算符两边放置一个空格:赋值(=), 比较(==, <, >, !=, <>, <=,>=, in, not in, is, isnot), 布尔运算(and, or, not). 按你的看法在算术运算符周围插入空格. 始终保持二元运算符两边空格的一致.一些例子:

1 i = i+1

2 submitted = submitted + 1

3 x = x*2 - 1

4 ypot2 = x*x + y*y

5 c = (a+b) * (a-b)

6 c = (a + b) * (a - b)

7)不要在用于指定关键字参数或默认参数值的'='号周围使用空格,例如:

1 def complex(real, imag=0.0):

2 return magic(r=real, i=imag)

2.2.7. 不要将多条语句写在同一行上.

No: if foo == 'blah': do_blah_thing()

Yes: if foo == 'blah':

do_blah_thing()

No: do_one(); do_two(); do_three()

Yes: do_one()

do_two()

do_three()

2.2.8. 注释

1)注释必须跟代码保持一致，当你想修改代码时，建议优先修改注释。

2)注释以'#'和一个空格开始，必须用英语，可以是句子或短语,首字母应大写。

3)如果注释很短，建议省略句末的句号

4)注释块通常由一个或多个由完整句子构成的段落组成，每个句子应该以句号结尾。

5)注释块通常应用于跟随着一些(或者全部)代码并和这些代码有着相同的缩进层次。

6)注释块中每行都是以'#'和一个空格开始(除非他是注释内的缩进文本)。

7)注释块内的段落以仅含单个'#'的行分割。

8)注释块上下方最好有一空行包围(或上方两行下方一行，对一个新函数定义段的注释)。

9)行内注释应该至少用两个空格和语句分开. 它们应该以'#'和单个空格开始.

x = x+1 # Increment x

10)约定使用统一的文档化注释格式有助于良好的习惯和团队的进步。

2.2.9.为配合pydoc;epydoc,Doxygen 等等文档化工具的使用，应该一直遵守编写好的文档字符串的约定。

2.2.10.多行文档字符串结尾的""" 应该单独成行，例如:

"""Return a foobang

Optional plotz says to frobnicate the bizbaz first.

"""

对单行的文档字符串,结尾的"""在同一行也可以。

2.2.11.版本注解

1 __version__ = "$Revision: 1.0.0.0 $"

这个行应该包含在模块的文档字符串之后,所有代码之前,上下用一个空行分割。

当然也可以这样：

1 ‘’’

2 @version: 1.0.0.0

3 ‘’’

跟其他相关信息（如author、copyright、date 等）一起。

2.2.12.命名规则

1）单下划线作为前导，如：_single_begin，这是弱的内部使用标识，例如使用“from M import*”的时候不会被导入；

2）单下划线作为结尾的，如：single_end_，这一般用于跟python 关键词冲突；

3）双下划线前导，如：__double_begin，类私有名；

4）双下划线前导+结尾，如：__double_begin_and_end__，特殊对象或属性，存在于用户控制的命名空间中，如：__init__，__import__等。有时可以被用户定义，用于触发某个特殊行为，如运算符重载。

5）模块名应该是不含下划线的，简短的，小写的名字

6）类名总是使用首字母大写、驼峰命名（第一个单词以小写字母开始；第二个单词的首字母大写或每一个单词的首字母都采用大写字母）单词串的约定。

7）函数名函数名应该为小写、动宾短语，可能用下划线风格单词以增加可读性。如：open_file()

2.3.变量和常量

2.3.1.数字常量，如下是python的一些常量表示形式：

2 整数

3.23 浮点数

52.3e-4 科学技术法表示的浮点数

-5 -4.6j 复数

和C类的语法不同的是，Python是内置了复数的。

2.3.2.布尔常量：布尔值的表示方式是True和False

2.3.3.字符串常量：字符串常量有三种表示显示：单引号（'）双引号（"）三引号（'''或"""）其中单引号和双引号功能完全相同，和C的双引号表示字符串方式一样，主要是新增了一个三引号的多行模式，在三引号的模式中，可以使用单引号和双引号，也可以接收换行符号，对于表示多行来说非常方便。

'''This is a multi-line string. This is the first line.

This is the second line.

"What's your name?," I asked.

He said "Bond, James Bond."

'''

2.3.4.None常量

None是一个特殊的常量。

None和False不同。

None不是0。

None不是空字符串。#想判断字符串是否为空if s.strip()=='':或者if not s.strip():

None和任何其他的数据类型比较永远返回False。

None有自己的数据类型NoneType。

你可以将None复制给任何变量，但是你不能创建其他NoneType对象。

（具体None用法在下文中查找即可）

2.3.4.转义符

转义符的功能基本上和C语言系统相同，以'\+转义字符'的显示来表示引号，换行等特殊字符

\n 换行

\t tab

2.3.5.取消转义符

转义字符很多时候给使用带来的不便，如文件路径，正则表达式等。对于无需转义的字符串中可以通过r前缀会取消转义符，从而方便阅读。

r"C:\Python27\python.exe"

Unicode字符串

Python默认的编码是不支持中文的：

>>> print '中文abc'

???–?abc

对于中文字符串，我们需要加u前缀来转换为unicode形式：

>>> print u'中文abc'

中文abc

2.3.6.连接字符串

相邻放置的字符串会自动级连。例如，'What\'s' 'your name?'会被自动转为"What's your name?"

2.3.7.变量命名规范：Python变量命名规范基本和C语言一样，感兴趣的可以看看：

标识符的第一个字符必须是字母表中的字母（大写或小写）或者一个下划线（' _ '）。

标识符名称的其他部分可以由字母（大写或小写）、下划线（' _ '）或数字（0-9）组成。

标识符名称是对大小写敏感的。例如，myname和myName不是一个标识符。注意前者中的小写n和后者中的大写N。

有效标识符名称的例子有i、__my_name、name_23和a1b2_c3。

无效标识符名称的例子有2things、this is spaced out和my-name。

2.3.8.变量赋值语法

变量赋值语法如下：

>>> i = 123

从中可以看出，python是没有变量类型这个概念的，如下方式也是合法的：

>>> i = 123

>>> i = 'hello world'

2.3.9.数学运算符

数学运算基本上和C一样

2.4.数据类型

python中的基本数据类型有：整数，浮点数，字符串，布尔类型（True 或False），空（None）由于python中变量名是区分大小写的，所以布尔类型中的True和False也是要区分大小写，当然None也是的！（None并不等于数字0！）

python中的扩展数据类型：列表（list），元组（tuple），字典（dict），集合（set）

a=3

import types

type(a)

int(a) #转换为整型str(a) #转换为字符串

2.5.运算符和表达式

#!/usr/bin/python

# Filename: expression.py

length = 5

breadth = 2

area = length * breadth

print 'Area is', area

print 'Perimeter is', 2 * (length + breadth)

（源文件：code/expression.py）

输出

$ python expression.py

Area is 10

Perimeter is 14

下面看看它如何工作：矩形的长度与宽度存储在以它们命名的变量中。我们借助表达式使用它们计算矩形的面积和边长。我们表达式length * breadth的结果存储在变量area中，然后用print语句打印。在另一个打印语句中，我们直接使用表达式2 * (length + breadth)的值。另外，注意Python如何打印“漂亮的”输出。尽管我们没有在'Area is'和变量area之间指定空格，Python自动在那里放了一个空格，这样我们就可以得到一个清晰漂亮的输出，而程序也变得更加易读（因为我们不需要担心输出之间的空格问题）。这是Python如何使程序员的生活变得更加轻松的一个例子。

三.控制语句

3.1语句基本知识

（1）print打印多个表达式时中间用逗号隔开即可，打印出来时会把逗号替换成空格>>> print 1,2,3# 此逗号不会形成元组

1 2 3

若希望打印出来的结果带逗号，可以用+',',例如：

>>> print '1'+',','2'+',','3'

1, 2, 3

在结尾加上逗号，下一行打印的内容会与前一条语句在同一行打印

print 'hello,',

print 'world'

输出hello,world #这只在脚本中起作用，在Python shell(交互式会话)所有语句会被立即单独执行，所以此做法不起作用

（2）import从模块导入函数

可以用from 模块名import 函数名

或者用from 模块名import 函数名1,函数名2,函数名3

或者用from 模块名import* # 导入所有功能

（3）若好几个模块（module1，module2）有同一函数，用：

import module1 然后以module1.function1() 和module2.function2()的方式用函数即可（4）多个变量同时赋值：

>>>x,y,z=1,2,3

>>> print x, y,z

1 2 3

（5）语句块：条件语句中条件为真执行的一组语句，或循环语句中多次执行的一组语句。在代码前放置空格可以创建语句块。

Python中前一句末尾的冒号（:）表示一个语句块的开始。

语句块中每个语句都缩进且缩进量相同。

当取消此语句块的缩进量时，当前语句块结束

3.2.结构化程序设计

（1）自顶向下、逐步求精；

（2）把需要的问题分解成若干那个小问题，对每个小问题设计求解

（3）三种基本结构，顺序结构，条件语句（选择结构），循环结构（满足某条件时，让程序重复执行同一个代码块）

3.3.条件语句

（1）if 条件：当条件（if与冒号之间的表达式）为真时，后面的语句块将被执行。

（2）else子句，例如

if a==x:

print 'shit'

else:

print'fuck'

（3）elif子句

num=input('enter a number')

if num>0:

print 'the number is positive'

elif num<0:

print'the number is negative'

else:

print 'the number is zero'

（4）嵌套代码块

if 条件1：

if 条件2：

print...

elif条件3：

print...

else:

print...

else:

print...

（5）比较运算符：

== 等于；！= 不等于；>=大于等于；<=小于等于；

x is（not）y x,y（不）是同一个对象；x（not）in y x（不）在y中

# 是is一定是==，但反之不一定，is不仅有相等性（==），还有同一性，例如：

>>> x=[1,2,3]

>>> y=[1,2,3]

>>> x==y结果为True

>>> x is y结果为False

（6）布尔运算符and or not # 它们可以随意组合，让if 直接包含多个条件，用()将优先计算的括起来

if number<=10 and number>=1: # 也可以直接1<=number<=10

print 'good'

else:

print 'wrong'

3.4.循环语句

3.4.1.while循环

（1）while基本操作

while 条件：

执行# 直到不满足此条件，才会跳出

（2）break与continue

break跳出最近的整个循环

continue跳出本次循环

3.4.2.for循环（特别在对序列或其他可迭代对象，对每个元素都执行代码块）（1）基本形式：

for 对象in 对相集合

if 条件1：

语句块1

break；#终止此for循环

if条件2：

语句块2

continue；# 跳过下面语句，进入下一循环

语句块3

else: # 如果for循环未被break终止，则执行else块中的语句语句块4

（2）依次输出列表中所有元素方法一：

numbers=[0,1,2,3,4,5,6]

for x in numbers:

print x

（3）对列表中的数字求和

numbers=[0,1,2,3,4,5,6]

sum=0

for x in numbers:

sum+=x

print 'sum='+str(sum)

（4）依次输出一个字符串内每一个字符

s="python"

for c in s:

print c，# print后面加上逗号，为了使输出的字符在同一行。

（5）for遍历字典元素，例如：

a={'x':1,'y':2,'z':3}

for key in a:

print key,'corresponds to',a[key]

（5）range()函数# for 循环经常和range()一起用

语法：range(初始值，结束值，步长)

初始值不是必须，默认为0

结束值是必须

步长不是必须，默认值为1

range应用举例1：>>> range(10) #默认起始值为0，步长为1

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> range(3,8) #默认步长为1

[3, 4, 5, 6, 7]

>>>range(3,8,1)

[3, 4, 5, 6, 7]

>>> range(3,8,2)#指定步长为2

[3, 5, 7]

>>>range(5,-5,-1)

[5, 4, 3, 2, 1, 0, -1, -2, -3, -4]

>>>range(5,-5)

[]

range应用举例2：依次输出列表中的每个元素方法二：

aList=['apple','orange','banana']; #定义一个列表

#每次循环都将列表中的一个元素赋值给目标对象x

for x in range(len(aList)):

print aList[x]; #输出目标对象

range应用举例3：在0～99的数中查找用户输入的值

sx=raw_input("输入x的值");

x=int(sx);

for y in range(0,100):

if x==y:

print "find the number "+str(x);

break;

else:

print "did't find the number"

四.内置数据结构

（注意，把一个列表，字典或set赋值给另一个时，要用copy号，而不能用=，因为它们本质上赋的是地址）

4.1.序列

序列中最常用的是列表，元组和字符串，列表可以更改，元组和字符串不可更改（比如字典的键不能修改，所以用元组）

以下特征是列表元组和字符串共有的

4.1.1.序列引索，例如day[2]

4.1.2.序列分片，例如day[2:6] #从第2 个开始，从第6个开始不算

访问前三个，day[:3]

访问后三个，day[-3:]

访问所有，day[:]

等间距访问（步长）day[0:9:3] # 其中3就是步长

每隔一个访问所有元素day[::2]

步长可为负，倒过来访问day[::-1]

4.1.3.序列相加，例如

[1,2,3]+[4,5,6] 得到[1,2,3,4,5,6]

'hello,'+'world!' 得到'hello,world'

[1,2,3]+'hello' 会报错#只有相同类型的序列才能进行相加，所以列表和字符串不能相加。

4.1.4.序列乘法

>>> 'python'*5

'pythonpythonpythonpythonpython'

>>> [42,43]*3

[42, 43, 42, 43, 42, 43]

4.1.

5.空列表：[]

占用十个元素空间却没有任何内容的列表：[None]*10

# None是一个python内建值，表示里面什么也没有

4.1.6.成员资格：用in（布尔运算符），真返回true，假返回false，true为布尔值，例如：>>> bibi=['you','i','he']

>>>'you' in bibi

True

>>> raw_input('please enter your name, son of bitch:') in bibi

please enter your name, son of bitch:he

True

4.1.7.len,min,max分别返回序列长度，序列中最小元素，序列中最大元素。对元组来说，比较第一个元素，返回第一个元组最大的元组。

4.2.列表（列表是可变的）

4.2.1.list函数可以把任意类型的序列变成列表。(用join函数可以把字符串、元组、列表中的元素以指定的字符(分隔符)连接生成一个新的字符串，例如''.join9(day)可以把列表转换为字符串)

>>>list('Hello')得到['H','e','l','l','o']

4.2.2.基本的列表操作：元素赋值，元素删除，分片赋值，列表方法。

4.2.3.元素赋值，例如，x[1]=2,即把列表中第二个元素变为了2。

4.2.4.元素删除，例如，del[0]是删除第一个元素，del[:2]是删除前两个元素，delx 是把整个列表删除。（字典与字符串中元素删除也可以使用del）

4.2.

5.分片赋值可以进行替换，插入，删除（与del效果相同）等功能。

替换：

>>>name=list('perl')

>>>name[1:]=list('ython') #分片赋值可以用不等长的列表来替换原分片

>>>name

得到结果['p','y','t','h','o','n']

插入：>>>numbers[1,5]

>>>numbers[1:1]=[2,3,4]

>>>numbers

[1,2,3,4,5]

删除：number[1:4]=[]

>>>numbers

[1,5]

4.2.6.列表方法：方法是作用于某些对象的函数，对象可以是列表、数字、字符串等等。

列表使用方法：对象.方法(参数). 以下为几种列表方法：

(1).append在列表末尾追加新对象。#append是直接修改原表

>>>lst=[1,2,3]

>>>lst.append(4)

>>>lst

[1,2,3,4]

(2).count统计某元素在列表中出现的次数。

>>>['to','be','or','not','to','be'].count('to') 结果是2

>>>x=[[1,2],1,1,2]

>>>x.count(1) 结果是2

>>>x.count([1,2]) 结果是1

(3).extend在列表某末尾追加另一个列表# 注意，加法+不改变原列表a, extend改变a

a.extend(b) 在a末尾加上b

a.extend([1,2]) 同理。#也可用分片赋值，但可读性不如extend

(4).index找到某元素最先出现的位置,例如：

>>>knight=['we','are','the',knights'','ha','ha','ha']

>>>knight.index('ha') 结果为4

(5).insert方法将对象插入列表中，例如：

>>>numbers=[1,2,3,5,6,7]

>>>numbers.insert(3,'four')

>>>numbers 结果为[1,2,3,'four',5,6,7]#也可用分片赋值，但可读性不如insert

(6).pop方法移除列表中的一个元素，（不写是哪个就默认最后一个），并返回该元素值。

# pop是唯一一个既能修改列表又返回元素值的列表方法。

>>>x=[1,2,3]

>>>x.pop() 结果为3

>>>x 结果为[1,2]

>>>x.pop(0) 结果为1

>>>x 结果为[2]

# pop可以实现一种常见数据结构——栈。后进先出，就像一堆盘子，先从上面拿。栈操作分为出栈（pop）和入栈（push），入栈用append。>>>x.append(x.pop())得到的还是原来的栈。若要先进先出，insert（0，...）加上pop() 或者用append 加上pop(0)

(7).remove移除某元素在列表中出现的第一次匹配项。例如x.remove('be')

(8).reverse将列表中元素反向存放。例如x.reverse()

(9).sort对列表中元素排序，但无返回值。正向排序加上reverse即可

>>>x=[4,6,2,1,7,9]

>>>x.sort()

>>>x

[1,2,4,6,7,9]

错误做法：

>>>x=[4,6,2,1,7,9]

>>>y=x.sort() # sort只能改变x,但没有返回值（返回空值）。

>>>print y

None

正确做法：

>>>x=[4,6,2,1,7,9]

>>>y=x[:] #把x的副本赋给y,注意不能把x直接赋给y,因为那样的话使x,y指向同一个列表>>>y.sort()

>>>

正确做法2：用sorted函数# sorted不改变原序列，sorted用于任何序列总是可以返回一个列表，例如sorted('python')

>>>x=[4,6,2,1,7,9]

>>>y=sorted(x)

(10).用sort进行高级排序

关键字参数cmp #python中不常用，不跟你玩了。

关键字参数key 例如x.sort(key=len) 按元素长度排序# key需要先提供一个函数，该函数为每个元素创建一个键，所有元素根据键来排序。在上例中len就是键函数

关键字参数reverse 例如x.sort(reverse=True)，reverse为布尔值True即说明进行反向排序。

(11)copy与deepcopy,把一个序列的值赋给另一个（对字典也同样适用）

# 注意序列a的值给b,不能直接用赋值语句，不然的话改变b也会带来a的变化

应该引入copy模块

a=[1,2] b=[]

import copy

b=copy.copy(a) # 也可以用b=a[:],但列表套列表时没用,此时用deepcopy:

x=[[1,2],[3,4]] y=[]

y=copy.deepcopy(x)

(12)any,all对列表，元祖都可以

any有一个不空，为True，全空，为False

>>>any('123')

True

>>>any([0, 1])

True

>>>any([0, ''])

False

all全不为空，为True, 有空，为False

>>>all('123')

True

>>>all([0, 1])

False

>>>all([1, 2])

True

4.2.7.列表解析

在一个序列的值上应用一个任意表达式，将其结果收集到一个新的列表中并返回。它的基本形式是一个方括号里面包含一个for语句对一个iterable对象迭代

例如：

>>> res=[ord(x) for x in 'spam']

>>> res

[115, 112, 97, 109]

>>> [x**2 for x in range(10)]

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

对列表迭代时也可以加上条件：

>>> doubled_odds = [n * 2 for n in numbers if n % 2 == 1]

4.3.元组（元组是不可变的）

4.3.1.用逗号分隔开一些值可以自动创建元组,例如：>>>1,2,3 得到(1,2,3)

4.3.2.元组大部分情况通过圆括号括起来：>>>(1,2,3)得到(1,2,3)

一个值的元组，加个逗号实现：>>>42, 得到(42,) 或者>>>(42,) 得到(42,)

4.3.3.tuple函数可以把任意序列转换为元组。例如：>>>tuple([1,2,3]) 得到(1,2,3)

4.3.4.基本元组操作——创建元组，访问元组，其他没了。

>>>x=1,2,3

>>>x[1] 得到2

>>>x[0:2] 得到(1,2)

4.3.5元组存在的意义：

第一，元组在映射（和集合的成员）中可以当做键使用，而列表不行。

第二，一些方法和函数的返回值是元组。

4.4.0.Python值转为字符串有三种方式，str, repr, 反引号（与repr相同，可忽视）。str让字符串更易读。repr让字符串转换为合法的Python值。

4.4.1字符串基本操作：所有标准的序列操作（索引、分片、乘法、判断成员资格，求长度，取最小值和最大值），但由于字符串不可变，类似分片赋值什么的并不合法。

4.4.2.字符串格式化操作符(%)只适用于字符串类型

4.4.2.1操作符(%)只适用于字符串类型

4.4.2.2.将需要与不需要格式化的字符(需要部分设为a)输入同一个字符串b,例如：

b='hello, %s. %d enough for you?'

a=('world',9)

print b % a

hello, world. 9 enough for you?

#格式化字符串时，python使用字符串b作为模板，%s与%d为两个格式符，a为一个tuple 值（元组），模板和Tuple之间有一个分隔符%，它代表了格式化操作。

4.4.2.3.字符串格式化符号（转义字符号）

%s 字符串(采用str()的显示)

%r 字符串(采用repr()的显示)

%c 单个字符

%b 二进制整数

%d / %i 十进制整数

%o 八进制整数

%x 十六进制整数

%e 指数(基底写为e)

%E 指数(基底写为E)

%f /%F 浮点数

%g 指数(e)或浮点数(根据显示长度)

%G 指数(E)或浮点数(根据显示长度)

%% 输出字符"%"

4.4.2.4.辅助符号：

辅助符号说明

- 靠左对齐(不给左边留空格)

+ 表示给数字加上正负号

0 若转换值位数不够，显示的数字前面填充“0”

# 在八进制数前面显示零(0)，在十六进制前面显示“0x”或者“0X”（取决于用的是“x”还是“X”）

m.n m 是显示的最小总宽度，n 在转换实数时表示小数点后的位数（在表示字符串时表示最大字段宽度）

* 定义宽度或者小数点精度。用法示范"%.*s" % (5, 'food fed')

4.4.2.

5.辅助符号与字符串格式化符号的顺序：

（1）%符号，表示转换说明符的开始。（2）转换标志（可选）-,+," ",0,#。（3）最小字段宽度，若加*，宽度值从元组中读出（可选）。（4）点.与后面跟的精度值（可选），若加*，宽度值从元组中读出。（5）转换类型d,s啥的......

4.4.2.6.字段宽度，点号，精度与星号的用法举例：

from math import pi

>>>'%10F' % pi # 字段宽10 结果为' 3.141593'

>>>'%10.2f'%pi # 字段宽10，精度2 结果为' 3.14'

>>>'%.2f'%pi # 精度2结果为'3.14'

>>>'%.5s'%'guido van rossum' #字段宽5 结果为'guido'

>>> '%5s'%'guido van rossum' #字段宽不小于5 结果为'guido van rossum'

4.4.2.7.正负号和0的用法举例：

在字段宽度和精度值前面可以放置0.加减号或空格。

0表示字符串内有空格时用0来填充。

>>>'%010.2f'%pi

'0000003.14' # 表示字段宽度为10，并且用0填充空位

4.4.2.8.应用总范例，做一个物价表：pdf page66

4.4.2.9.希望反斜线不产生转义功能的方法：

(1).用双反斜线\\

(2).在字符串前加r,表示原始字符串。

4.4.3.字符串方法：

（1）.find:在一个字符串a='...'中找某个字符串'b...'：a.find('b...'),存在的话返回最左端索引的位置，不存在的话返回-1.

a.find('

b...',1)表示从下标1开始查找。

rfind表示从末尾开始查找

（2）.join(split的逆方法):在队列a的各元素之间中添加同一个元素c='b'

c.join(a)或者'b'.join(a)

（3）.lower全改为小写：a='Gumpy',b=a.lower(),则结果为gumpy.

（4）.replace:把字符串a中所有的'b'替换为'c':a.replace('b','c')

（5）split(join的逆方法):以某种分隔符(或元素)为断点来把原字符串分割成字符串序列：

a='1+1+2+1+3'

a.split('+') 结果是['1', '1', '2', '1', '3']# 字符串中每出现一个"+"就断开产生新元素

a.split('1')结果是['', '+', '+2+', '+3'] # 以'1'为分隔符

（6）.strip去除字符串两边的指定字符（默认删除多余的字符空格、\n换行、\r回车、\t 横向制表符）：

a=' gumpy ',b=a.strip(),结果为gumpy.

'*!!!***!*d79*hiy!8*!!!*!**!!*!'.strip('*!')结果为'd79*hiy!8'

4.4.4. String模块中的常量：

string.digits：数字0~9

string.letters：所有字母（大小写）

string.lowercase：所有小写字母

string.printable：可打印字符的字符串

string.punctuation：所有标点

string.uppercase：所有大写字母

应用举例：

>>> import string

>>> string.digits

'0123456789'

4.5.1简介：列表是通过编号对值进行引用的数据结构。

而映射是通过名字引用值的数据结构。字典是python中唯一的映射类型。

字典中的值没有特定顺序，储存在键（key）里，键可以是数字、字符串、元组

4.5.2.字典：phonebook={'alice':'2341','beth':'9102','cecil':'3258'}

字典中每一项由键，冒号和值组成，项之间用逗号隔开。空字典没有项，只有大括号。4.5.3.创建字典的三种方法：

（1）直接用{}写,例如：

>>> dict1={}

>>> dict1[1]=213768

>>> dict1['1']=213

>>> dict1

{'1': 213, 1: 213768}

（2）用dict函数：通过(键,值)或[键,值]组成项，项组成元组或序列，把此元组或序列放到dict函数中。例如：

y=(("a", "1"), ("b", "2"))

x = dict(y)得到结果{'a': '1', 'b': '2'} # 共有2*2=4中选择，只记住元组套元组就够了吧

（3）以映射为dict()的参数：

>>> x = dict(a="1", b="2")

>>> print x结果为{'a': '1', 'b': '2'}

（4）用方法fromkeys() 来创建一个"默认"字典, 字典中元素具有相同的值(如果没有给出，默认为None)，例如:

>>> ddict = {}.fromkeys(('x', 'y'), -1)

>>> ddict 结果为{'y': -1, 'x': -1}

>>> edict = {}.fromkeys(('foo', 'bar'))

>>> edict结果为{'foo': None, 'bar': None}

4.5.4.如何访问字典中的值

（1）用for循环遍历，比如：

>>>dict1={'name': 'earth', 'port': 80}

>>>for key in dict:

print' key=%s, value=%s' % (key,dict1[key])

结果为

key=name, value=earth

key=port,value=80

（2）得到某一个键a值,用x[a]即可。例如，得到字典dict1中name的值：dict1['name'] （3）看某个值是否在字典中。用in和not in 就行了，返回结果是布尔值，例如：

'name' in dict1 结果是True

4.5.5.基本字典操作:

4.5.5.1.与序列类似的操作：

len(x)返回x中项的数量

x[a]返回键a上的值# 查询某个键对应的值

x[a]=b将值b对应到键a上# 以此可以更改字典中键的值或给字典中加入新项

del x[a]删除键为a的项

键a in x 或者值b in x，检查键是否在字典中，返回布尔值。# 不能检查值是否在

4.5.5.2.与列表不同的操作

（1）键类型：可为任意不可变类型，可以是整型数据、浮点型、字符串、元组。

#这是字典最强大的地方

（2）自动添加：给一个原来不存在的键赋值，自动把这个项加进字典中了。

（3）成员资格：列表中用in查的是值，而字典中查键不查值。

#数据结构规模特别大时，字典中查键的成员资格比列表中查值的成员资格更高效。

4.5.6.字典的格式化字符串

用字符串将元组格式化见过了，格式化字典也行。

%后加上圆括号括起来的键，再跟上其他说明元素，例如：

>>>dict1={'name': 'earth', 'port': 80}

>>>'he is an %(name)s' % dict1

'he is an earth'

4.5.7.字典方法

（1）clear，清空字典所有项，例如，x.clear(),x返回None

（2）fromkeys,创建一个新字典，所有键等于同一个值，例如：

方法一>>> ddict = {}.fromkeys(('x', 'y'), -1)

>>> ddict返回结果为{'y': -1, 'x': -1}

方法二>>> ddict = dict.fromkeys(('x', 'y'), -1)

>>> ddict返回结果为{'y': -1, 'x': -1}

两种方法结果相同

（3）get用来访问字典

>>>d={}

>>>print d.get('name') 返回结果为None # 如果键不存在返回None,

>>>d.get('name','NA') 返回结果为'NA' # 如果键不存在，也可以令其返回某特定值>>>d['name']='eric'

>>>d.get('name') 返回结果为'eric' # 键存在时，get用起来跟普通的字典查询一样（4）items将字典中的项以列表形式返回，列表中每一项为（键，值），无特定顺序。>>>d={'a':'234f','b':'243d','c':'342g'}

>>>d.items()

[('a', '234f'), ('c', '342g'), ('b', '243d')]

（5）keys将字典中的键以列表形式返回，例如，上文中的d:

>>>d.keys()

['a', 'c', 'b']

（6）pop以键为参数，先返回这个键的值，再将此键存在的项删除，

例如，上文中的d：

>>> d.pop('a')

'234f'

>>> d

{'c': '342g', 'b': '243d'}

（7）update可用一个字典来更新另一个：

a.update(b) #新字典b中的项将被加到旧字典a中，键相同值不同时，新字典值会覆盖旧的

（8）values以列表形式返回字典中的值，例如，上文中的d:

>>>d.values()

['234f', '342g', '243d']

4.6.集合（set）（与列表、字典一样，是可变的/元素无次序/不可重复）

set算是list和dict特点的结合：

含有dict的特点——可用{}定义；元素没有顺序；元素不可重复，类似于键

含有list的特点有一种集合可以原处修改

4.6.1.创建集合

集合通过调用集合的构造函数set来创建。

set构造函数至多有1个参数（可迭代参数），若没有参数，set会创建空集