python基础知识实用.docx
《python基础知识实用.docx》由会员分享，可在线阅读，更多相关《python基础知识实用.docx（46页珍藏版）》请在冰豆网上搜索。
python基础知识实用
Python基础知识
前言：
什么是python：
官方解释：
一种解释型的、面向对象的、带有动态语义的高级程序设计语言。
优点：
简单、强大，程序员在编程时能够保持自己的风格，容易实现自己想要的功能，程序清晰易懂。
历史：
GuidovanRossum在20世纪90年代初创造了这门语言。
一、基础知识
1.1安装
1.使用包管理器安装python，如通过yum安装；
2.从源文件编译安装python：
（1）下载源代码；下载扩展名为.tgz的文件保存到本地某一目录下；
（2）进入该目录，使用tar–xzvfpython-；
（3）进入已解压的文件目录，cdpython-
./configure--prefix=$（pwd）
make
makeinstall
（4）将当前文件夹路径放到环境变量PYTH中。
在python脚本首行写上“#!
/usr/bin/envpython”后，不管python二进制文件在哪里，程序都会自动执行。
若系统中安装了新版本的python，同时旧版本仍然存在，那么应该直接指明新版本路径，如：
#!
/usr/bin/python2.6
1.2交互式解释器
安装了python并设置了环境变量后，输入python进入交互式解释器。
在交互式解释器中可以直接计算出表达式的值，如
输入1+1后按回车，输出2
输入1/2，输出0（因为计算结果的小数部分被截除了）
输入1/21.0/2，输出0.5
输入1//2，输出0；输入1.0//2.0，输出0.0（//双斜线表示进行整除）
1.3函数、变量、模块
内建函数：
input（）:
使用input函数接收输入值，如x=input（），输入12，则x=12
pow（2,3）=8
abs（-10）=10
round（1.8/2）=1.0,四舍五入了
模块：
（1）math.floor（1.8/2）=0.0,向下取整
floor函数不能直接用，要先加载math模块:
importmath
importmath
int（math.floor（32.9））
输出：
32
（2）另外用下面的方式直接import函数，不需要在函数前加上模块名了：
frommathimportfloor
int（floor（32.9））
变量：
可以使用变量来引用函数，即将某个函数赋给一个变量：
foo=math.sqrt
foo（4）
输出：
2.0
1.4字符串
（1）字符串拼接：
+
x="I'mx!
"
y="I'my!
"
x+y
输出：
"I'mx!
I'my!
"
（2）数值转化成字符串
str、repr与反引号``：
可将数值转化成字符串
str会把值转换为合理形式的字符串；
repr会创建一个字符串，以合法的python表达式的形式来表示值。
如：
printstr（"Helloworld!
"）输出：
Helloworld!
printrepr（"Helloworld!
"）输出：
'Helloworld!
'
反引号：
``（python3.0中已不再使用反引号，建议用repr）
可以将数字与字母连接在一起，如：
temp=42
print"tempis:
"+`temp`输出：
tempis:
42
print`temp`+"and"+`123`输出：
42and123
使用用repr或str：
print"tempis:
"+repr（temp）输出：
tempis:
42
print"tempis:
"+repr（temp）+str（"123"）输出：
tempis:
42123
（3）多行字符串
长字符串跨多行时，用三个单引号或三个双引号，这样在字符串中可以同时使用单引号和双引号。
普通字符串跨多行时，也可在行尾用反斜线”\”，如：
print“Hello,\
howareyou?
“
输出：
Hello,howareyou?
（4）原始字符串
输出原始字符串时字符串前面带’r’，如：
printr'C:
\programefile\now\new'输出：
C:
\programefile\now\new
printr"C:
\newlet'sgo!
"输出：
C:
\newlet'sgo!
二、列表
Python中最基本的数据结构是序列（sequence），序列中每个元素被分配一个序号——即元素的位置，也称为索引，第一个索引是0，最后一个元素索引标记为-1。
Python中包含6种内建序列：
列表、元组、字符串、unicode字符串、buffer对象、xrange对象。
2.1序列的操作
所有序列类型都可以进行的特定操作如下：
索引（indexing）
分片（sliceing）
加（adding）
乘（multiplying）
成员资格（检查某个元素是否属于序列）
2.1.1.1索引
序列中所有元素都是有编号的，从0开始递增。
元素可以通过编号进入访问。
实例：
#!
/usr/bin/python
months=['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sept','Oct','Nov','Dec']
endings=['st','nd','rd']+17*['th']+['st','nd','rd']+7*['th']+['st']
year=raw_input（"year:
"）
month=raw_input（"month:
"）
day=raw_input（"day:
"）
month_num=int（month）
day_num=int（day）
month_name=months[month_num-1]#索引
day_ord=day+endings[day_num-1]#索引
printmonth_name+''+day_ord+''+year
输入year:
2011
month:
12
day:
21
输出：
Dec21st2011
2.1.1.2分片
使用索引可以访问单个元素，使用分片可以访问一定范围内的元素。
分片需要提供两个索引作为边界，用冒号分隔两个索引，第1个索引的元素包含在分片内，第二个索引的元素不包含在分片内，如：
tag=''
tag[7:
21]
输出：
'
注：
tag[7:
21]，取第7到第20个字符。
若想包含从第一个开始（或直到最后一个结束）的字符串，可以将前一个（或后一个）索引置空，如：
tag[:
5],tag[7:
],tag[:
]
步长：
分片中的第三个值（开始与结束索引之后）
如：
idx=[1,2,3,4,5,6,7,8,9,10]
idx[:
:
2]输出：
[1,3,5,7,9]
idx[:
:
-1]输出：
[10,9,8,7,6,5,4,3,2,1]
2.1.1.3序列加法
两种相同类型的序列才能进行连接操作，如：
[1,2,3]+[4,5,6]输出：
[1,2,3,4,5,6]
‘hello’+’_’+‘world’输出：
’hello_world’
不同类型序列不能相加，如：
[1,2,3]+‘hello’提示出错
2.1.1.4序列乘法
数字x与序列相乘后，原序列被重复x次。
[12]*10输出：
列表初始化，创建10个元素空间但没有值：
[None]*10
2.1.1.5成员资格
in运算，检查一个值是否在序列中。
例1：
users=['taobao','alibaba','root']
input_name=raw_input（'Enteryourusername:
'）
ifinput_nameinusers:
printinput_name+'isinusers!
'
else:
print'Warning!
'+input_name+'isnotinusers!
'
例2：
db=[
['smith','4309'],
['jones','0921'],
['alber','8745'],
]
username=raw_input（'username:
'）
pin=raw_input（'pincode:
'）
if[username,pin]indb:
print'Accessgranted!
'
else:
print'Warning:
usernameorpiniserror!
'
2.2列表的基本操作
列表与元组的区别：
列表可以修改，元组不可以修改。
列表的元素写在方括号中，元素间用逗号隔开，如：
edward=[‘Edward’,29,’hangzhou’]
（1）元素赋值：
如x[1]=0
（2）删除元素：
names=[‘Alice’,‘Beth’,‘Earl’,‘Dimdo’]
delnames[2]
结果names=[‘Alice’,‘Beth’,‘Dimdo’]
（3）分片赋值：
可以一次为多个元素赋值：
name=list（‘perl’）
name[1:
]=list（‘ython’）
结果name=[‘p’,‘y’,‘t’,‘h’,‘o’,‘n’]
可以实现插入元素：
num=[1,5]
num[1:
1]=[2,3,4]
结果num=[1,2,3,4,5]
可以实现删除元素：
num=[1,2,3,4,5]
num[2:
4]=[]
结果num=[1,2,5]
2.3列表的方法
（1）append
num=[1,2,3]
num.append（4）
结果num=[1,2,3,4]
（2）count
x=[‘to’,‘be’,‘or’,‘not’,‘to’,‘be’]
x.count（‘to’）
结果为2
（3）extend
a=[1,2,3]
b=[4,5,6]
a.extend（b）
结果a=[1,2,3,4,5,6]
（4）index
a=['who','am','i','?
']
a.index（'?
'）
结果为3
（5）insert
num=[1,2,3,4,5]
num.insert（3,‘four’）
结果num=[1,2,3,‘four’,4,5]
（6）pop：
移除列表中的一个元素，并且返回该元素的值，如：
x=[1,2,3]
x.pop（）返回3
x.pop
（1）返回2
（7）remove：
移除表中某个值
x=[‘to’,‘be’,‘or’,‘not’,‘to’,‘be’]
x.remove（‘be’）
结果x=[‘to’,‘or’,‘not’,‘to’,‘be’]
（8）reverse：
将列表中的元素反向存放
x=[1,2,3]
x.reverse（）
结果x=[3,2,1]
（9）sort：
对原列表进行排序，返回值为空
x=[5,1,2,4,3,6]
y=x.sort（）
结果x=[1,2,3,4,5,6]
y无值
sorted（）函数：
x=[5,1,2,4,3,6]
y=sorted（x）
结果x=[5,1,2,4,3,6]
y=[1,2,3,4,5,6]
（10）比较函数cmp（）：
cmp（1,2）返回-1
cmp（1,1）返回0
cmp（2,1）返回1
三、元组
元组是不可变序列。
空元组：
（）
一个值的元组：
1,或（1,）其中逗号不可省略
多个值的元组：
1,2,3或（1,2,3）
2*（2+3）输出10#没有逗号，普通的值计算
2*（2+3,）输出（5,5）#有逗号，表示是一个元组，相乘后得到一个新的元组，有两个值
3.1元组的操作
1.创建元组：
X=1,2,3
2.访问元组元素：
X[1]输出：
2
X[0:
2]输出：
（1,2）
3.2tuple函数
将序列转换为元组：
tuple（[1,2,3]）输出（1,2,3）#列表
tuple（‘abc’）输出（'a','b','c'）#字符串
tuple（（1,2,3））输出（1,2,3）#元组
四、字符串
字符串是不可改变的，不能对一个字符串重新赋值。
4.1字符串格式化
用%分隔，%左侧放置一个字符串的格式，在%右侧放置希望格式化的字符串值。
如：
str=（1,2,3,4,5）
print"%s%s%s%s%s"%str
输出：
12345
例：
x=1.0
y=3.0
z=x/y
print"%.5f"%z
输出：
0.33333
字符串宽度、精度、符号、对齐、0填充：
'%-10.2f'%3.1415926输出：
'3.14'-表示左对齐
'%10.2f'%3.1415926输出：
'3.14'默认右对齐
'%+10.2f'%3.1415926输出：
'+3.14'+表示显示正负数
'%+10.2f'%-3.1415926输出：
'-3.14'
'%+-10.2f'%-3.1415926输出：
'-3.14'
'%+-10.2f'%3.1415926输出：
'+3.14'
'%010.2f'%3.1415926输出：
'0000003.14'0表示开头不足部分用0补全
4.2字符串的方法
1.find（）：
在母串中查找子串，找到后返回索引值，找不到返回-1.
2.join（）:
连接字符串列表：
如
str=[‘1’,‘2’,‘3’]
sep=‘+’
sep.join（str）输出：
’1+2+3’
dirs=‘’,’usr’,‘bin’,‘env’
‘/’.join（dirs）输出：
’/usr/bin/env’
3.lower（）:
返回字符串的小写字母，如：
‘ABC’.lower（）输出：
’abc’
4.replace（）:
将字符串的所有匹配项都替换，再返回替换后的字符串。
如：
'Iamastudent'.replace（'Iam','I\'m'）输出：
"I'mastudent"
5.split（）:
join的逆方法，将字符串分割成序列，如：
’1+2+3’.split（‘+’）输出：
['1','2','3']
6.strip（）:
去除一个字符串的前后空格，再返回去除空格后的字符串。
7.translate（）:
只处理单个字符，可以同时进行多个替换。
fromstringimportmaketrans
table=maketrans（'cs','kz'）//创建转换表，格式string.maketrans（from,to）
printtable[97:
123]输出：
abkdefghijklmnopqrztuvwxyz
str='thisisanincredibletest'.translate（table）
printstr输出：
thizizaninkredibletezt
五、字典
键/值对之间用冒号隔开，项之间用逗号隔开，整个字典用大括号括起来。
如：
phonebook={'宁波':
'0574','台州':
'0576','杭州':
'0571'}
phonebook['宁波']输出：
'0574'
5.1dict（）函数
可以使用该函数通过其他映射或（键，值）对序列建立字典，如：
items=[（'name','Alice'）,（'age',28）]
d=dict（items）
printd输出字典：
{'age':
28,'name':
'Alice'}
或者用关键字参数形式
d=dict（name='Alice',age=28）
printd输出字典：
{'age':
28,'name':
'Alice'}
5.2字典基本操作
与序列（sequence）类似。
字典：
phonebook={'宁波':
'0574','台州':
'0576','杭州':
'0571'}
len（phonebook）
phonebook['宁波']
phonebook['绍兴']='0573'//增加一个字典项
delphonebook['台州']//删除一个字典项
'绍兴'inphonebook//返回true
'台州'inphonebook//返回false
5.3字典的格式化字符串
"hangzhou'sareanumberis%（杭州）s"%phonebook
输出：
"hangzhou'sareanumberis0571"
5.4字典的方法
（1）clear（）:
清除字典中所有项目，如：
phonebook={'宁波':
'0574','台州':
'0576','杭州':
'0571'}
x=phonebook.clear（）
printphonebook输出：
{}
printx输出：
None
（2）copy（）:
浅复制，返回一个具有相同键-值对的新字典。
如：
phonebook={'nibo':
'0574','taizhou':
'0576','hangzhou':
'0571'}
x=phonebook.copy（）
x['taizhou']='0576-0576'//修改value
x输出：
{'nibo':
'0574','hangzhou':
'0571','taizhou':
'0576-0576'}
phonebook输出：
{'nibo':
'0574','hangzhou':
'0571','taizhou':
'0576'}
x.clear（）
x输出：
{}//删除字典
phonebook输出：
{'nibo':
'0574','hangzhou':
'0571','taizhou':
'0576'}
（3）fromkeys（）:
使用给定的键建立新的字典，键的默认值为None，如：
x={}
y=x.fromkeys（['name','age']）
x输出：
{}
y输出：
{'age':
None,'name':
None}
（4）get（）:
访问字典中的项，即使项不存在时，也不会出错，如：
x={'name':
'Alice','age':
28}
printx.get（'name'）输出：
Alice
printx.get（'addr'）输出：
None
printx.get（'name','N/A'）输出：
Alice//键存在，返回对应值
printx.get（'addr','N/A'）输出：
N/A//自定义默认值为'N/A'，替换None
（5）has_key（）:
检查字典中是否包含给出的键，相当于表达式kindict，
注：
python3.0不包括这个函数
x.has_key（'name'）输出：
True
x.has_key（'addr'）输出：
False
（6）items（）:
将字典的所有项以列表方式返回，如：
x.items（）输出：
[（'age',28）,（'name','Alice'）]
（7）keys（）:
将字典的所有关键字以列表方式返回，如：
x.keys（）输出：
['age','name']
（8）values（）:
将字典的所有values值以列表方式返回，如：
x.values（）输出：
[28,'Alice']
（9）pop（）:
返回对应给定键的值，再将该键值对从原字典中删除，如
x.pop（'name'）输出：
'Alice'
x输出：
{'age':
28}//原来的（'name','Alice'）已被删除
（10）popitem（）:
弹出字典的项，如：
x={'no.1':
1,'no.2':
2,'no.5':
5,'no.4':
4,'no.3':
3}
x输出：
{'no.5':
5,'no.4':
4,'no.3':
3,'no.2':
2,'no.1':
1}
x.popitem（）输出：
（'no.5',5）
x.popitem（）输出：
（'no.4',4）
x输出：
{'no.3':
3,'no.2':
2,'no.1':
1}
（11）setdefault（）:
与get（）类似，键存在返回对应值，但给定键不存在时，返回默认值后更新了字典，如：
x={'name':
'Alice','age':
28}
printx.setdefault（'name'）输出：
Alice
x输出：
{'age':
28,'name':
'Alice'}
printx.setdefault（'addr'）输出：
None
x输出：
{'age':
28,'name':
'Alice','addr':
None}
printx.setdefault（'name','N/A'）输出：
Alice
x输出：
{'age':
28,'name':
'Alice','addr':
None}
printx.setdefault（'addr','N/A'）输出：
None
x输出：
{'age':
28,'name':
'Alice','addr':
None}
printx.setdefault（'phone','N/A'）输出：
N/A
x输出：
{'phone':
'N/A','age':
28,'name':
'Alice','addr':
None}
//用自定义值'N/A'，替换默认值None
（12）update（）:
可以用一个字典项更新另外一个字典，关键字存在时改变其对应值，关键字不存在时添加新项，如：
x={'name':
'Alice','age':
28}
y={'age':
25,'phone':
'0571-12345'}
x.update（y）
x输出：
{'phone':
'0571-12345','age':
25,'name':
'Alice'}
六、条件、循环和其他语句
6.1模块导入
（1）import
（2）fromimport,,…
（3）fromimport*
（4）importas
升级会员 