Python2.x语法

1.字符串 2.数字计算 3.列表 4.元组 5.集合 6.字典 7.逻辑判断 8.流程控制语句 9.函数 10.类

python中所有的一切都是对象，且拷贝默认为浅拷贝，引用为直接引用。涉及变量对象赋值，会指向同一个地址

1.字符串

1.1 python2.x中字符串中有中文，要在字符串前加字符 u

#encoding=utf-8 #文件第一行要添加这个utf-8编码格式 print u"某羊" str="某羊" print str.decode("utf-8").encode("gbk") #运行结果：某羊

1.2 普通字符串用双引号 “” 或单引号 ‘’ 括起来，效果是相同的

print “ABCDEFG” print 'ABCDEFG' #运行结果： #ABCDEFG #ABCDEFG

1.3 反斜杠 \ 是转义字符，它可以将普通字符变成特殊字符，也可以将特殊字符变成普通字符，如果你不希望它是转义字符，那你也可以通过添加前置r来实现

#将普通字符t转义成制表符 print "ABC\tABC" #运行结果：ABC ABC #将特殊字符‘转义成普通字符 print 'ABC\'ABC' #运行结果：ABC'ABC #使所有\变成普通字符 print r"\t\t" #运行结果：\t\t print ur"\t某羊" #运行结果：\t某羊

1.4 多行字符串

print '''123 456 789 101 ''' #运行结果：123 #456 #789 #101 #在行尾加反斜杠 \ 可以去除回车换行符号，如： print '''123\ 456\ 789 101 ''' #运行结果：123456789 #101

1.5 字符串拼接和重复（*）

print "Python"+"3.x" print "Python""3.x" print ("Python" "3.x") #上面语句的输出结果都是：Python3.x #字符串重复语法如下 print 3*"A""B" #运行结果：ABABAB print 3*"A"+"B" print "A"*3+"B" #运行结果：AAAB print (3*"A" "B") #运行结果：ABABAB

注：对于变量值/表达式的字符串，只能用+号进行拼接。

1.6 字符串索引（下标访问）

str="ABCDEFG" print str[0] # A print str[1] # B print str[-1] # G

注：由于0和-0是一样的，所以负数索引从-1开始

1.7字符串切片

切片的语法的左闭右开的。

str="Python" print str[0:2] # [0,2)即运行结果为：Py print str[2:5] # [2,5)即运行结果为：tho print str[:2]+str[2:] # [0,2)+[2,n)即运行结果为：Python print str[-2:] #[-2,n-1)即运行结果为：on print str[42:] #运行结果为空，越界索引会被自动处理

注：切片省略开始索引时默认为0，省略结束索引时默认为到字符串的结束。

1.8 返回字符串长度

str = 'Python' print len(str) #运行结果：6

2.数字计算

2.1 普通加减乘除取余（+ - * / %）

print 3+3.0 # 6.0 print 3-3.0 # 0.0 print 6/4 # 1 print 6.0/4 # 1.5 print 6.0%4.1 # 1.9 print 6**2 # 6^2，即36

注：python2默认除法是整除，而python3默认除法是精确至除尽。

3.列表

3.1 列表的语法

Python支持多种不同的数据类型放到同一列表中。

list=[1,"123",1.5>1.6] print list #运行结果：[1, '123', False]

3.2 列表的索引，切片和拼接

list=[1,"123",4,5,6] #索引 print list[0] # 1 print list[-1] # 6 #切片，也是左闭右开的 print list[0:2] # [1,'123'] #拼接，支持+号拼接 print list[:1]+list[1:2] # [1,'123']

3.3 列表的修改

字符串的数据类型是immutable ,它不允许修改； 列表是一个 mutable 类型，它自己的内容可以改变。

list=[1,2,3,4,5,6] list[0]=7 print list #运行结果：[7,2,3,4,5,6]

使用append()添加新元素

list=[1,2,3,4,5,6] list.append(7) print list #运行结果：[1,2,3,4,5,6,7]

使用切片修改列表

list=[1,2,3,4,5,6] list[0:3]=[] print list list[0:1]=[1,2,3,4] print list list[:]=[] print list #运行结果： #[4, 5, 6] #[1, 2, 3, 4, 5, 6] #[]

3.4 获取列表的长度

list=[1,2,3,4,5,6] print len(list) #运行结果：6

3.5 嵌套列表

a = ['a', 'b', 'c'] n = [1, 2, 3] x = [a, n] print x #运行结果：[['a', 'b', 'c'], [1, 2, 3]] print x[0] #运行结果：['a', 'b', 'c'] print x[0][1] #运行结果：'b'

3.6 列表的常用函数

list.append(x) #在列表的末尾添加一个元素，等同于a[len(a):] = [x] list.extend(iterable)#使用可迭代对象中的所有元素来扩展列表，等同于 a[len(a):] = iterable list.insert(i, x)#在索引为i的位置插入元素x list.remove(x)#移除列表中第一个值为 x 的元素 list.pop(i)#删除列表中给定位置的元素并返回它 list.pop() #删除并返回列表中的最后一个元素。 list.clear()#移除列表中的所有元素。等价于 del a[:] list.index(x,start,end)#返回列表中第一个值为 x 的索引。可选参数 start 和 end 是切片符号 list.count(x) #返回元素 x 在列表中出现的次数。 list.sort(key=None, reverse=False)#对列表中的元素进行排序 list.reverse()#翻转列表中的元素 list.copy()#返回列表的一个浅拷贝，等价于 a[:]

3.7 列表推导式

如果我们要创建一个列表[0,2,4,6,8,10],那我们可能要执行如下语句：

list=[] for i in range(6) list.append(i*2)

但其实我们可以用更加简洁的语句来完成这个工作

#1 list=[2*i for i in range(6)] #2 list = list(map(lambda i: i*2, range(6)))

将多个for组合成元组元素

list=[(x, y) for x in [1,2,3] for y in [3,1,4] if x != y] #list=[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)] 在这里插入代码片

4.元组

4.1 元组的语法

元组的成员元素可以被索引，但不能被修改。创建一个元组的语法如下：

#1 用一堆括号括起来 t=(1,2,3,4,5) #2 t=1,2,3,4,5,

5.集合

5.1 集合的语法

Python集合相当于Java中的< Set >，存放不重复的无序单一元素。创建一个集合的语法如下：

#1 set={"a","x",1,2,5} #2 set=set('abracadabra') #set={'a', 'r', 'b', 'c', 'd'}

注：空集合只能用set()来创建，而不能用{}（因为{}表示的是空字典）。集合也支持推导式形式。

5.2 集合的运算

集合支持:减(-)、或(|)、与(&)、异或(^)。

a={'a','b','c','d'} b={1,2,3,4,'a'} print a-b #set（['b','c','d']） print a|b #set(['a','b','c','d',1,2,3,4]) print a&b #set(['a']) print a^b #set(['b','c','d',1,2,3,4])

6.字典

6.1 字典的语法

Python字典相当于Java中的Map，存储的是键值对。创建字典的语法如下： key和value都支持任意数据类型的数据。

dis = {'a': 1, 'b': 2，3:'c'}

6.2 字典成员元素的增删查改

#增,改 dis["e"]=8 #删 del dis['a'] #查 'a' in dis #查询是否存在 for k, v in dis.items(): #遍历字典 print(k, v)

6.3 字典的常用函数

1.items()，去除关键字和对应值

for k, v in dis.items(): #遍历字典 print(k, v)

7.逻辑判断

7.1 逻辑判断符号

python中的逻辑判断符号跟C语言是一样的。

> #大于 < #小于 == #等于 >= #大于等于 <= #小于等于 != #不等于

8.流程控制语句

8.1 if

python的if语句中elseif有点像C语言中switch…case…的存在。

x=0 if x<0 : print("x小于0") elif x==0: print("x等于0") elif x==1: print("x等于1") else: print("x大于1")

8.2 for

Python中的for语句跟其他与语言有很大的不同，它主要用于序列的迭代。

list=[1,2,3,4,5,6] #遍历整个list for i in list: print i ‘’‘ 运行结果： 1 2 3 4 5 6 ’‘’ #只遍历[2,5)那部分 for i in list[2:5]: print i ''' 运行结果： 3 4 5 '''

8.3 range()函数

range()函数会根据参数生成一个数字列表。

#一个参数(n)，代表取值范围[0,n) range(10) # [0,1,2,3,4,5,6,7,8,9] range(-5) # [] #两个参数(x,y)，代表取值范围[x,y) range(5,10) # [5,6,7,8,9] #三个参数(a,b,c)，代表从[a,b)中找出所有x，x满足条件 x%c==0

8.4 break

用于跳出循环，这个跟C是一样的，简单演示一下。

list=[1,2,3,4,5,6] for i in range(len(list)): if i>0: break print list[i] #运行结果：1

8.5 continue

借鉴于C语言，用于跳过后面的语句，直接进入下一次循环。

list=[1,2,3,4,5,6] for i in range(len(list)): if i==1: continue print list[i] ‘’‘ 运行结果： 1 3 4 5 6 ’‘’

8.6 pass

pass语句是在语法上需要一个语句，但不需要做什么的时候用的，比如：

if True: pass while True: pass class MyEmptyClass: pass def initlog(*args): pass

9.函数

9.1 函数定义

python定义函数的语法如下：

def 函数名(参数列表)： 函数体 return 返回值 #不能没有return

注：函数在定义时也可以给参数赋初始值，但不能将没初始值的参数放在有初始值的参数后面（会报错）。

9.2 函数调用

#定义一个函数 def fib(a,b,c=1): return #全部传参调用 fib(1,2,3) #不传参有默认值的参数 fib(1,2) fib(b=2,a=1)

10.类

以下摘自官方文档： Python 的类提供了面向对象编程的所有标准特性：类继承机制允许多个基类，派生类可以覆盖它基类的任何方法，一个方法可以调用基类中相同名称的的方法。对象可以包含任意数量和类型的数据。和模块一样，类也拥有 Python 天然的动态特性：它们在运行时创建，可以在创建后修改。

10.1 类的定义

class 类名: pass

10.1 构造函数

在Python中类的构造函数是定义一个名为 __ init__(init的左右两边都两道下划线，总共4道)的函数，函数的第一个参数为self。构造函数不需要return

class User: def __init__(self,其它参数): pass

10.2 成员变量

Python的成员变量不需要实现定义好，在需要用到的时候直接使用语法： self.变量名 定义并初始化即可(在Python中不允许出现未初始化的变量)。

class User: def __init__(self,a,b): self.name=a self.age=b

10.2 成员函数

Python中成员函数（也包括构造函数），它们的第一个参数一定是self,指向对象本身，这个参数在函数调用赋值的时候会被忽略，只传参给后面的参数。普通成员函数是需要return的。

class User: ...... def setName(self,name): self.name=name return

10.3 对象的创建和操作

假设有一个类是下面这样子的：

class User: def __init__(self,name,age): self.name=name self.age=age def setName(self,name): self.name=name return

利用这个类，我们可以创建如下对象：

user1=User("MouYang",20) #name="MouYang" age=20

调用成员变量

print user1.name # MouYang print user1.age # 19

调用成员函数（在Python中，隶属于对象的函数称为方法）

#方法1：直接调用 user1.setName("Mouyang") #方法二：创建方法对象 userName=user1.setName #创建 userName("Mouyang") #调用

10.4 继承

单继承 类的继承是在类定义中实现的，语法如下：

class 当前类名(父类名): pass

如果弗列在另外一个文件(模块)中,则需要用一下语法实现：

class 当前类名(模块名.父类名): pass

多继承：python与C++相同，允许一个子类同时继承多个父类，语法如下：

class 当前类(父类1, 父类2, 父类3): pass

在Python中，如果子类想要调用父类的方法，是通过super()函数来实现的，具体如下：

class Parent1: def setName(self,name): pass class Parent2: def setAge(self,age): pass class child(Parent1,Parent2): super(Parent1,self).setName("Mouyang") #super(父类名，self).父类方法()

10.5 关于访问权限

在Pyhton中没有私有成员(仅能从内部访问)的存在，所有成员都是对外开放访问的。但是，官方有这样一个说法： 大多数 Python 代码都遵循这样一个约定：带有一个下划线的名称 (例如 _spam) 应该被当作是 API 的非公有部分 (无论它是函数、方法或是数据成员)。 这应当被视为一个实现细节，可能不经通知即加以改变。 即默认以 _ 开头的成员被当成私有的。如：

class User: _name="" def _abc(): pass

10.5 名称改写

类中任何以两个下划线开头的变量（如__spam）都会被改写成 单下划线+类名+单下划线+标识符的形式（如 _类名_spam）。这种改写是隐式的，不会直接修改代码部分。 改写规则的设计主要是为了避免意外冲突；访问或修改被视为私有的变量仍然是可能的。这在特殊情况下甚至会很有用，例如在调试器中。

10.6 结构体

如果你想定义一个像C一样的结构体(struct)，直接定义一个空类就行