Python基础知识.docx
《Python基础知识.docx》由会员分享，可在线阅读，更多相关《Python基础知识.docx（31页珍藏版）》请在冰豆网上搜索。
Python基础知识
1.1Python基础
Python是用标准C语言写成的一种面向对象的脚本语言，语法相对简单，符合人的思维习惯，通过集成环境或解释器直接执行源程序。
它可以运行在windows、linux等操作系统平台上，具有丰富的功能库以处理各种工作，包括正则表达式、文档生成、单元测试、线程、数据库、网页浏览器、CGI、FTP、电子邮件、GUI（图形用户界面）等。
Python程序中可以使用C/C++语言编写的程序，也可以将Python程序嵌入到C/C++程序中。
Python是开源自由软件，容易获得，可以阅读它的源程序并修改它。
Python在编程领域的占有率近年上升很快，应用也日渐广泛，可以用于系统编程、图形处理、数学处理、文本处理、数据库编程、网络编程、多媒体编程等方面。
也被一些公司应用于产品开发上，如Google在其网络搜索系统中广泛应用了Python；YouTube视频分享系统大部分使用Python编写的，甚至NASA使用Python完成科学计算任务。
1.1.1Python中数据的表示和输入输出
1.字面量
字面量，即字面意义上的常量。
一个字面意义上的常量的例子是如同15、1.823、10.25E-3这样的数，或者如同"Howareyou"、"It'sasquare!
"这样的字符串。
它们具备字面的意义，按照它们的字面意义使用它们的值。
数2总是代表它自己，而不会是别的什么东西——它是一个常量，因为不能改变它的值。
因此，所有这些都被称为字面意义上的常量。
Python中逻辑常量为true（真）和false（假）。
2.数据类型
Python中将组成程序的元素称为对象，对象的类型有数字（number）、字符串（string）、列表（list）、字典（dictionary）、元组（tuple）和文件（file）。
在Python中有四种类型的数（number）——整数（int）、浮点数（float）和复数（）。
29是一个整数。
长整数是大一些的整数。
8.23和19.3E-4是浮点数。
E标记表示10的幂，这里，19.3E-4表示19.3*10-4。
（-5+4j）和（2.3-4.6j）是复数。
3.字符串
字符串是字符的序列，如上面的"Howareyou"。
字符串基本上就是一组单词，一对单引号或一对双引号之间的字符序列表示一个字符串。
用一对三引号引起来表示一段文本。
（1）使用单引号（'）
用单引号指示字符串，就如同'Quotemeonthis'这样。
所有的空白，即空格和制表符都照原样保留。
（2）使用双引号（"）
在双引号中的字符串与单引号中的字符串的使用完全相同，例如"What'syourname?
"。
（3）使用三引号（'''或"""）
使用三个连续的引号标记的内容称为文档字符串。
利用三引号，可以指示一个多行的字符串。
还可以在三引号中自由地使用单引号和双引号。
文档字符串可以方便地保留文本中的换行信息，用来在代码中书写大段的说明很方便，所以它经常用于块注释。
例如：
doc1="""namezhang
tel8765234
"""
doc1="""SpringFestivalisnotonlyatimeforfamilyreunions,butitalsobringswithitastringofentertainment,fromtraditionaltomodern.
PiYing,or"shadowplay"usedtobeoneofthemostpopularperformingartsacrossChina.
Combiningfinearts,opera,musicanddrama,it'sseenbysomeasarudimentaryformofthemotionpicture.
"""
4.转义符
如果想要在一个字符串中包含一个单引号（'），例如，这个字符串是What'syourname?
。
如果用'What'syourname?
'来指示它，Python会弄不明白这个字符串从何处开始，何处结束，因为这里的’都被认为是字符串的标识符，但又不成对。
所以，要指明单引号而不是字符串的标识，可以通过“\”来完成,如,'What\'syourname?
'。
第2个'前有一个“\”表示它就是单引号，而不是字符串的标识符。
这里的“\”就是转义符。
另一个表示这种字符串的方法是"What'syourname?
"，即用双引号。
类似地，要在双引号字符串中使用双引号本身的时候，也可以借助于转义符。
另外，你可以用转义符\\来指示反斜杠本身。
5.变量
变量是代表数据的符号，它的值可以改变。
Python中，变量的使用不需要说明，变量类型根据值的类型确定，而且变量可以随时赋不同类型的值。
变量命名符合标识符命名规定。
例如
A=3
B=5
C=A+B
print（C）
6.标识符的命名
变量是标识符的例子。
标识符是用来标识某样东西的名字。
变量外，使用标识符的例子还有函数名、类名等。
在命名标识符的时候，要遵循下列规则：
①第一个字符必须是字母表中的字母（大写或小写）或者一个下划线（‘_’）。
②其他部分可以由字母（大写或小写）、下划线（‘_’）或数字（0-9）组成。
③python标识符对大小写是敏感的。
例如，name和Name被认为是两个标识符。
7.缩进
空白在Python中非常重要。
行首的空白称为缩进，它决定逻辑行的缩进层次，从而用来决定语句的分组。
同一层次的语句必须有相同的缩进量（缩进几个字符）。
每一组这样的语句称为一个块。
语句块是进行处理的同一批语句。
简言之，python是用连续相同层次缩进表示语句块的。
例如for语句后相同缩进量相同的连续语句是其循环体。
注意，不要混合使用制表符和空格来缩进，因为这在跨越不同的平台的时候，无法正常工作。
建议在每个缩进层次使用单个制表符或两个或四个空格。
8.注释
在Python中，#号开始至行末的文字为注释。
没有多行注释。
10.输入输出
从键盘输入数据使用input函数，格式为：
x=input（"Pleaseinputadata"）
从键盘输入一行字符串，赋值给x，是字符串类型，即使输入的是一个整数,其中的“Pleaseinputadata”是提示信息，可以根据需要改变。
要想改变数据的类型，使用：
x=int（input（"Pleaseinputadata"））
其中int表示将后面的字符串类型的数转换为整数类型的数。
还可以是float,complex，表示将输入的字符串转换为实数和复数。
Python的输出使用print函数，格式为：
print（<表达式列表>）
其中“表达式列表”是用逗号隔开的表达式，如：
A=4
B=5
C=A+B
print（“A+B=”,C）
结果为：
A+B=9
1.1.2运算符及字符串的运算
1.运算符
Python的运算符见表4-1
表4-1python的运算符
运算符
名称
说明
例子
+
加
两个对象相加
3+5得到8。
'a'+'b'得到'ab'。
-
减
得到负数或是一个数减去另一个数
-5.2得到一个负数。
50-24得到26。
*
乘
两个数相乘或是返回一个被重复若干次的字符串
2*3得到6。
'la'*3得到'lalala'。
**
幂
返回x的y次幂
3**4得到81（即3*3*3*3）
/
除
x除以y
4/3得到1（整数的除法得到整数结果）。
4.0/3或4/3.0得到1.3333333333333333
//
取整除
返回商的整数部分
4//3.0得到1.0
%
取模
返回除法的余数
8%3得到2。
-25.5%2.25得到1.5
<<
左移
把一个数的比特向左移一定数目（每个数在内存中都表示为比特或二进制数字，即0和1）
2<<2得到8。
——2按比特表示为10
>>
右移
把一个数的比特向右移一定数目
11>>1得到5。
——11按比特表示为1011，向右移动1比特后得到101，即十进制的5。
&
按位与
数的按位与
5&3得到1。
|
按位或
数的按位或
5|3得到7。
^
按位异或
数的按位异或
5^3得到6
~
按位翻转
x的按位翻转是-（x+1）
~5得到6。
<
小于
返回x是否小于y。
所有比较运算符返回1表示真，返回0表示假。
这分别与特殊的变量True和False等价。
注意，这些变量名的大写。
5<3返回0（即False）而3<5返回1（即True）。
比较可以被任意连接：
3<5<7返回True。
>
大于
返回x是否大于y
5>3返回True。
如果两个操作数都是数字，它们首先被转换为一个共同的类型。
否则，它总是返回False。
<=
小于等于
返回x是否小于等于y
x=3;y=6;x<=y返回True。
>=
大于等于
返回x是否大于等于y
x=4;y=3;x>=y返回True。
==
等于
比较对象是否相等
x=2;y=2;x==y返回True。
x='str';y='stR';x==y返回False。
x='str';y='str';x==y返回True。
!
=
不等于
比较两个对象是否不相等
x=2;y=3;x!
=y返回True。
not
布尔“非”
如果x为True，返回False。
如果x为False，它返回True。
x=True;noty返回False。
and
布尔“与”
如果x为False，xandy返回False，否则它返回y的计算值。
x=False;y=True;xandy，由于x是False，返回False。
在这里，Python不会计算y，因为它知道这个表达式的值肯定是False（因为x是False）。
这个现象称为短路计算。
or
布尔“或”
如果x是True，它返回True，否则它返回y的计算值。
x=True;y=False;xory返回True。
短路计算在这里也适用。
2.运算符优先级
表4-2给出Python的运算符优先级，从最低的优先级（最松散地结合）到最高的优先级（最紧密地结合）。
这意味着在一个表达式中，如果没有括号，Python会首先计算表中较下面的运算符，然后在再计算列在表上部的运算符。
建议使用圆括号来对运算符和操作数进行分组，以便能够明确地指出运算的先后顺序，使程序尽可能地易读。
表4-2运算符优先级
运算符
描述
lambda
Lambda表达式
or
布尔“或”
and
布尔“与”
notx
布尔“非”
in，notin
成员测试
is，isnot
同一性测试
<，<=，>，>=，!
=，==
比较
|
按位或
^
按位异或
&
按位与
<<，>>
移位
+，-
加法与减法
*，/，%
乘法、除法与取余
+x，-x
正负号
~x
按位翻转
**
指数
x.attribute
属性参考
x[index]
下标
x[index:
index]
寻址段
f（arguments...）
函数调用
（experession,...）
绑定或元组显示
[expression,...]
列表显示
{key:
datum,...}
字典显示
'expression,...'
字符串转换
3.计算顺序
默认地，运算符优先级表决定了哪个运算符在别的运算符之前计算。
具有相同优先级的运算符按照从左向右的顺序计算。
通常可以使用圆括号改变计算次序，例如，在表达式12+3*4中乘法先进行运算，而表达式（12+3）*4中，加先进行运算。
4.字符串的运算
字符串是程序中经常使用的元素，字符串的运算也很多，包括连接两个字符串，取一个字符串中的一部分，称为取子字符串，大小写转换，字符串与数值的转换等。
（1）字符串的连接：
s0="Python"
s1='C++'
s2=s0+""+s1
S2的值为：
'PythonC++'
（2）取部分字符串
<字符串名>[<起始位置>:
<终止位置>:
<步长>]
得到从<起始位置>开始，间隔<步长>，到<终止位置>前一个字符结束的字符串。
其中
<起始位置>可省略，表示从起始位置为0。
<终止位置>可省略，表示从终止位置为末尾。
<步长>省略表示步长为1。
例如：
f='abcdefghijklmnopqrstuvwxyz'
则
f[5]的值为'f'
f[0:
10:
2]的值为'acegi'
f[0:
10:
2]的值为'acegi'
f[0:
10]的值为'abcdefghij'
f[:
10]的值为'abcdefghij'
f[10:
]的值为'klmnopqrstuvwxyz'
len（f）#字符串的长度，本例结果为26
（3）其他的字符串处理函数
其他的字符串处理函数还有：
ord（'a'）#返回字符的ASCII的十进制值
chr（97）#返回整数对应的字符
（4）库中的字符串处理函数
上面的字符串处理函数可以直接使用，而要使用字符串的大小写转换、查找等功能，需要引入string库，方法是在程序开头写“importstring”，例如：
importstring
f='abcdefghijklmnopqrstuvwxyz'#定义一个字符串
f.upper（）#转换为大写，不改变f
f.find（'f'）#返回f的索引值（即在字符串中从0开始的序号）
f.replace（'b','boy'）#返回b被boy替换的字符串，不改变f
其他的字符串处理函数见表4-3
表4-3string库中的字符串处理函数
S.capitalize（）
S.ljust（width[,fill]）
S.center（width[,fill]）
S.lower（）
S.count（sub[,start[,end]]）
S.lstrip（[chars]）
S.encode（[encoding[,errors]]）
S.maketrans（x[,y[,z]]）
S.endswith（suffix[,start[,end]]）
S.partition（sep）
S.expandtabs（[tabsize]）
S.replace（old,new[,count]）
S.find（sub[,start[,end]]）
S.rfind（sub[,start[,end]]）
S.format（fmtstr,*args,**kwargs）
S.rindex（sub[,start[,end]]）
S.index（sub[,start[,end]]）
S.rjust（width[,fill]）
S.isalnum（）
S.rpartition（sep）
S.isalpha（）
S.rsplit（[sep[,maxsplit]]）
S.isdecimal（）
S.rstrip（[chars]）
S.isdigit（）
S.split（[sep[,maxsplit]]）
S.isidentifier（）
S.splitlines（[keepends]）
S.islower（）
S.startswith（prefix[,start[,end]]）
S.isnumeric（）
S.strip（[chars]）
S.isprintable（）
S.swapcase（）
S.isspace（）
S.title（）
S.istitle（）
S.translate（map）
S.isupper（）
S.upper（）
S.join（iterable）
S.zfill（width）
1.1.3序列
数据元素的集合在Python中称为序列（）
1.列表（list）
列表时对象的有序集合。
列表的内容可以修改，列表的长度可变。
列表的定义：
<列表名称>[<列表项>]
其中多个列表项用逗号隔开，它们的类型可以相同，也可以不同，还可以是其列表。
例如
date=[2011,2,9,9,54]
day=['sun','mon','tue','wed','thi','fri','sat']
today=[2011,2,9,"wed"]
data=[date,day]
均是合法的列表。
使用时，通过
<列表名>[索引号]
的形式应用，索引号从0开始，即0是第1项的索引号。
例如date[0]的值是2011，day[1]得到“mon”，data[1][3]的到“wed”。
下列程序：
date=[2011,2,9,9,54]
day=['sun','mon','tue','wed','thi','fri','sat']
today=[2011,2,9,"wed"]
data=[date,day]
print（date[0]）
print（day[1]）
print（data[1][3]）
的运行结果为：
2011
mon
wed
列表可以整体输出，如print（data）
列表的其他运算见表1-2。
表1-2列表的运算
运算格式/举例
说明/结果
L1=[]
空列表
L2=[2011,2,9,19,54]
5项，整数列表，索引号0-4
L3=['sun',['mon','tue','wed']]
嵌套的列表
L2[i],L3[i][j]
索引,L2[1]的值为2，L3[1][1]的值为'tue'
L2[i:
j]
分片，取i到j-1的项
Len（L2）
求列表的长度
L1+L2
合并
L2*3
重复,L2重复3次
forxinL2
循环,x取L2中的每个成员执行循环体
19inL2
19是否是L2的成员
L2.append（4）
增加4作为其成员，即增加一项
L2.sort（）
排序,L2结果变为[2,9,19,54,2011]
L2.index（9）
得到9在列表中的索引号，结果为2
L2.reverse（）
逆序，L2的结果为[2011,54,19,9,2]
DelL2[k]
删除索引号为k的项
L2[i:
j]=[]
删除i到j-1的项
L2[i]=1
修改索引号为i的项的值
L2[i:
j]=[4,5,6]
修改i到j-1的项的值，如果项数多，则自动插入
L4=range（5,20,3）
生成整数列表L4实际为[5,8,11,14,17]
2.元组（tuple）
元组和列表十分类似，只不过元组和字符串一样是不可变的，即不能修改元组。
元组通过圆括号中用逗号分割的项目定义。
当一组数据，只使用，不修改时使用元组。
元组的使用与列表相同，只是不能修改、删除、增加其元素。
例如：
#useoftuple
#filename:
tuple.py
garden=（"BirdofParadise","rose","tulip","lotus","olive","Sunflower"）
print（'Numberofflowersinthegardenis',len（garden））
i=2;
print（'flower',i,'is',garden[i-1]）
new_garden=（'Phlox','PeachBlossom',garden）
i=1;
print（'flower',i,'is',garden[i-1]）
运行结果如下:
C:
\Python31>pythontuple.py
Numberofflowersinthegardenis6
flower2isrose
flower1isBirdofParadise
元组的运算见表1-3
表1-3元组的运算
运算格式/举例
说明/结果
T1（）
空元组
T2=（2011,）
有一项的元组
T3=（2011,2,9,19,54）
5项，整数元组，索引号0-4
T4=（'sun',（'mon','tue','wed'））
嵌套的元组
T3[i],T4[i][j]
索引,T3[1]的值为2，T4[1][1]的值为'tue'
T3[i:
j]
分片，取i到j-1的项
Len（T3）
求元组的长度
T3+T4
合并
T3*3
重复,T3重复3次
forxinT3
循环,x取T3中的每个成员执行循环体
19inT3
19是否是L2的成员
注意：
元组与列表的最大不同：
一是定义时用一对圆括号，二是内容不能修改。
3.字典（dictionaries）
字典是无序的对象的集合，通过键进行操作。
类似于通讯录，通过姓名来查找电话、地址等信息，则姓名就是键。
一定要没有同名的人。
字典的定义为：
<字典名>={键1:
值2,键2:
值2,键3:
值3,…}
其中，键1，键2，键3不相同，值可以是任何类型的数据，可以是列表或元组。
注意，字典定义中使用的是大括号，项通过逗号隔开，每个项有键部分和值部分，键和值之间用冒号隔开。
只可使用简单的对象作为键,而且不能改变，但可以用不可变或可变的对象作为字典的值。
例如：
#useofdictionaries
#filename:
dict.py
address1={'zhang':
'**************',
'wang':
'*************',
'lily':
'******************',
'sam':
'***************'
}
print（'mailofzhang',address1['zhang']）
address2={'zhang':
['**************','shaanxi'],
'wang':
['*************','beijing'],
'lily':
['******************','shanghai'],
'sam':
['***************','hubei']
}
print（'mailofzhang',address2['lily'][0]）
print（'provinceofzhang',address2['lily'][0]）
运行结果如下：
C:
\Python31>pythondict.py
mailofzhang**************
mailofzhang******************
provinceofzhang*************
升级会员 