Python 基础语法(一)

Python 基础语法(一)

Python的特色

　　1. 简单

　　　　Python是一种表明简单思想的语言。

　　2. 易学

　　　　Python有极其简单的语法。

　　3. 免费、开源

　　　　Python是FLOSS（自由/开放源码软件）之一。

　　4. 高层语言

　　　　使用Python编写程序时无需考虑如何管理程序使用的内存一类的底层细节。

　　5. 可移植性

　　　　Python已被移植到不少平台，这些平台包括Linux、Windows、FreeBSD、Macintosh、Solaris、OS/二、Amiga、AROS、AS/400、

　　BeOS、OS/390、z/OS、Palm OS、QNX、VMS、Psion、Acom RISC OS、VxWorks、PlayStation、Sharp Zaurus、

　　Windows CE甚至还有PocketPC。

　　6. 解释性

　　　　能够直接从源代码运行。在计算机内部，python解释器把源代码转换为字节码的中间形式，而后再把它翻译成计算机使用的机器语言。

　　7. 面向对象

　　　　Python既支持面向过程编程也支持面向对象编程。

　　8. 可扩展性

　　　　部分程序可使用其余语言编写，如c/c++。

　　9. 可嵌入型

　　　　能够把Python嵌入到c/c++程序中，从而提供脚本功能。

　　10. 丰富的库

　　　　Python标准库确实很庞大。它能够帮助你处理各类工做，包括正则表达式、文档生成、单元测试、线程、数据库、网页浏览器、CGI、FTP、

　　电子邮件、XML、XML-RPC、HTML、WAV文件、密码系统、GUI（图形用户界面）、Tk和其余与系统有关的操做。

 

---------------分割线------------------------如下是Python的基本语法---------------------------------------------------------

1、基本概念

　　1. python中数有四种类型：整数、长整数、浮点数和复数。

• 整数， 如 1

• 长整数 是比较大的整数

• 浮点数 如 1.2三、3E-2

• 复数 如 1 + 2j、 1.1 + 2.2j

　　2. 字符串（字符的序列）

• python中单引号和双引号使用彻底相同。

• 使用三引号('''或""")能够指定一个多行字符串。

• 转义符 '\'

• 天然字符串， 经过在字符串前加r或R。 如 r"this is a line with \n" 则\n会显示，并非换行。

• python容许处理unicode字符串，加前缀u或U， 如 u"this is an unicode string"。

• 字符串是不可变的。

• 按字面意义级联字符串，如"this " "is " "string"会被自动转换为this is string。

　　3. 标识符的命名

• 第一个字符必须是字母表中字母或下划线'_'。

• 标识符的其余的部分有字母、数字和下划线组成。

• 标识符对大小写敏感。

　　4. 对象

　　　　python程序中用到的任何“东西”都成为“对象”。

　　5. 逻辑行和物理行

　　　　物理行是咱们在编写程序时看到的，逻辑行则是python看到的。

　　　　python中分号;标识一个逻辑行的结束，可是实际中通常每一个物理行只写一个逻辑行，能够避免使用分号。

　　　　多个物理行中能够写一个逻辑行，以下：

s = "peter is \

writing this article"

　　　　上面\的使用被称为‘明确的行链接’， 又如：

 \

　　6. 缩进

　　　　空白在python是很是重要的，行首的空白是最重要的，又称为缩进。行首的空白（空格和制表符）用来决定逻辑行的缩进层次，从而决定语句

　　分组。这意味着同一层次的语句必须有相同的缩进，每一组这样的语句称为一个块。

　　注意：不要混合使用空格和制表符来缩进，由于在跨越不一样的平台时没法正常工做。

2、运算符与表达式

　　1. 运算符与其用法

运算符	名称	说明	例子
+	加	两个对象相加	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; not y返回False。
and	布尔“与”	若是x为False，x and y返回False，不然它返回y的计算值。	x = False; y = True; x and y，因为x是False，返回False。在这里，Python不会计算y，由于它知道这个表达式的值确定是False（由于x是False）。这个现象称为短路计算。
or	布尔“或”	若是x是True，它返回True，不然它返回y的计算值。	x = True; y = False; x or y返回True。短路计算在这里也适用。

 　　2. 运算符优先级（从低到高）

运算符	描述
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,...)	绑定或元组显示
[expression,...]	列表显示
{key:datum,...}	字典显示
'expression,...'	字符串转换

 　　3. python 控制台输出 使用print

   　　  %   　　  % (, )  　　

3、控制流

　　1. if 语句

i = 10
n = int(raw_input())

 n == i:
     
 n < i:
     
:

 　　2. while语句

 True:
    
:

　　3. for 循环 for..in

 i  range(0, 5):
     i
:

　　注：当for循环结束后执行else语句；

　　　　range(a, b)返回一个序列，从a开始到b为止，但不包括b，range默认步长为1，能够指定步长，range(0,10,2)；

　　4. break语句

　　　　终止循环语句，若是从for或while中终止，任何对应循环的else将不执行。

　　5. continue语句

　　　　continue语句用来调过当前循环的剩余语句，而后继续下一轮循环。

4、函数

　　函数经过def定义。def关键字后跟函数的标识符名称，而后跟一对圆括号，括号以内能够包含一些变量名，该行以冒号结尾；接下来是一块语句，即函数体。

 sumOf(a, b):
     a + b

　　1. 函数形参

　　　　函数中的参数名称为‘形参’，调用函数时传递的值为‘实参’

　　2. 局部变量

　　　　在函数内定义的变量与函数外具备相同名称的其余变量没有任何关系，即变量名称对于函数来讲是局部的。这称为变量的做用域。

　　　　global语句， 为定义在函数外的变量赋值时使用global语句。

 func():
     x
     , x
    x = 1

x = 3
func()
 x

　　3. 默认参数

　　　　经过使用默认参数可使函数的一些参数是‘可选的’。

 say(msg, times =  1):
     msg * times

say()
say(, 3)

　　　　注意：只有在形参表末尾的那些参数能够有默认参数值，即不能在声明函数形参的时候，先声明有默认值的形参然后声明没有默认值的形参，只是由于赋给形参的值是根据位置而赋值的。

　　4. 关键参数

　　　　若是某个函数有不少参数，而如今只想指定其中的部分，那么能够经过命名为这些参数赋值（称为‘关键参数’）。

　　　　优势：没必要担忧参数的顺序，使函数变的更加简单；假设其余参数都有默认值，能够只给咱们想要的那些参数赋值。

 func(a, b=2, c=3):
      % (a, b, c)

func(1) func(1, 5) func(1, c = 10) func(c = 20, a = 30)

　　5. return 语句

　　　　return语句用来从一个函数返回，即跳出函数。可从函数返回一个值。

　　　　没有返回值的return语句等价于return None。None表示没有任何东西的特殊类型。

　　6. DocStrings (文档字符串)

 func():
    
    

 func.

5、模块

　　模块就是一个包含了全部你定义的函数和变量的文件，模块必须以.py为扩展名。模块能够从其余程序中‘输入’(import)以便利用它的功能。

　　在python程序中导入其余模块使用'import', 所导入的模块必须在sys.path所列的目录中，由于sys.path第一个字符串是空串''即当前目录，因此程序中可导入当前目录的模块。

 　　1. 字节编译的.pyc文件

　　　　导入模块比较费时，python作了优化，以便导入模块更快些。一种方法是建立字节编译的文件，这些文件以.pyc为扩展名。

　　　　pyc是一种二进制文件，是py文件经编译后产生的一种byte code，并且是跨平台的（平台无关）字节码，是有python虚拟机执行的，相似于

　　java或.net虚拟机的概念。pyc的内容，是跟python的版本相关的，不一样版本编译后的pyc文件是不一样的。

　　2. from .. import

　　　　若是想直接使用其余模块的变量或其余，而不加'模块名+.'前缀，可使用from .. import。

　　　　例如想直接使用sys的argv，from sys import argv 或 from sys import *

　　3. 模块的__name__

　　　　每一个模块都有一个名称，py文件对应模块名默认为py文件名，也可在py文件中为__name__赋值；若是是__name__，说明这个模块被用户

　　单独运行。

　　4. dir()函数

　　　　dir(sys)返回sys模块的名称列表；若是不提供参数，即dir()，则返回当前模块中定义名称列表。

　　　　del -> 删除一个变量/名称，del以后，该变量就不能再使用。

6、数据结构

　　python有三种内建的数据结构：列表、元组和字典。

　　1. 列表

　　　　list是处理一组有序项目的数据结构，列表是可变的数据结构。列表的项目包含在方括号[]中，eg: [1, 2, 3]， 空列表[]。判断列表中是否包含某项可使用in， 好比 l = [1, 2, 3]; print 1 in l; #True；支持索引和切片操做；索引时若超出范围，则IndexError；使用函数len()查看长度；使用del能够删除列表中的项，eg: del l[0] # 若是超出范围，则IndexError

　　　　list函数以下：

　　　　append（value）　　---向列表尾添加项value

l = [1, 2, 2]
l.append(3)

　　　　count(value)　　---返回列表中值为value的项的个数

l = [1, 2, 2]
 l.count(2)

　　　　extend(list2)　　---向列表尾添加列表list2

l = [1, 2, 2]
l1 = [10, 20]
l.extend(l1)
 l

　　　　index(value, [start, [stop]])　　---返回列表中第一个出现的值为value的索引，若是没有，则异常 ValueError

l = [1, 2, 2]
a = 4
:
     l.index(a)
 ValueError, ve:
      % a

　　　　insert(i, value)　　---向列表i位置插入项vlaue，若是没有i，则添加到列表尾部

l = [1, 2, 2]

l.insert(1, 100)
 l 
l.insert(100, 1000)
 l

　　　　pop([i])　　---返回i位置项，并从列表中删除；若是不提供参数，则删除最后一个项；若是提供，可是i超出索引范围，则异常IndexError

l = [0, 1, 2, 3, 4, 5]

 l.pop()  l 
 l.pop(1)  l 
:
    l.pop(100)
 IndexError, ie:

　　　　remove(value)　　---删除列表中第一次出现的value，若是列表中没有vlaue，则异常ValueError

l = [1, 2, 3, 1, 2, 3]

l.remove(2)
 l 
:
    l.remove(10)
 ValueError, ve:

　　　　reverse()　　---列表反转

l = [1, 2, 3]
l.reverse()
 l

　　　　sort(cmp=None, key=None, reverse=False)　　---列表排序

【Python Library Reference】
cmp:cmp specifies a custom comparison function of two arguments (iterable elements) which should return a negative, zero or positive number depending on whether the first argument is considered smaller than, equal to, or larger than the second argument: 
"cmp=lambda x,y: cmp(x.lower(), y.lower())" 
key:key specifies a function of one argument that is used to extract a comparison key from each list element: "key=str.lower"
reverse:reverse is a boolean value. If set to True, then the list elements are sorted as if each comparison were reversed.In general, the key and reverse conversion processes are much faster than specifying an 
equivalent cmp function. This is because cmp is called multiple times for each list element while key and reverse touch each element only once.

l5 = [10, 5, 20, 1, 30]
l5.sort()
 l5 
l6 = [, , , ]
l6.sort(cmp =  s1, s2: cmp(s1[0],s2[1]))
 l6 
l7 = [, , , , ]
l7.sort(key =  s: s[1])
 l7