python3特有语法及使用总结

以下的东西全为python3版本（python2已经停止版本更新了），主要是python语法特有的东西。

python3特有语法及使用总结

python库的管理

# 安装某模块
pip install somepackage

# 列出已安装模块
pip list

# 升级
pip install --upgrade somepackage

# 卸载
pip uninstall somepackage

# 直接安装下载好的包
pip install somepackage.whl

python基础知识

指定编码，可以依照固定格式输出输入中文

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

多行语句

total = item_one + \
        item_two + \
        item_three

不换行输出

# print 默认输出是换行的，如果要实现不换行需要在变量末尾加上 end=""：
print( x, end=" " )

逻辑

# 比较运算符
== #判断是否等于
!= #判断是否不等于

# 逻辑运算符
and # 表示且
or # 表示或
not # 表示非

成员运算符
in # 在指定序列找到值返回true
not in # 在指定序列没有找到值返回true

身份运算符
is # 两对象是不是一个地址
is not 

package的导入

# 将整个模块(somemodule)导入，格式为： 
import somemodule

# 从某个模块中导入某个函数,格式为： 
from somemodule import somefunction

# 从某个模块中导入多个函数,格式为： 
from somemodule import firstfunc, secondfunc, thirdfunc

# 将某个模块中的全部函数导入，格式为： 
from somemodule import *

if __name__ == '__main__'的意义
if __name__ == '__main__'的意思是：当.py文件被直接运行时，if __name__ == '__main__'之下的代码块将被运行；当.py文件以模块形式被导入时，if __name__ == '__main__'之下的代码块不被运行。

输入

input()

python的自带数据结构

列表

列表中的一些方法

# 在列表的末尾添加一个元素。相当于 a[len(a):] = [x] 。
list.append(x)

# 使用可迭代对象（列表元组等）中的所有元素来扩展列表，就是将迭代对象中的所有数据都放到列表尾部。相当于 a[len(a):] = iterable 。
list.extend(iterable)

# 在给定的位置插入一个元素。第一个参数是要插入的元素的索引，所以 a.insert(0, x) 插入列表头部， a.insert(len(a), x) 等同于 a.append(x) 。
list.insert(i, x)

# 移除列表中第一个值为 x 的元素。如果没有这样的元素，则抛出 ValueError 异常。
list.remove(x)

# 删除列表中给定位置的元素并返回它。如果没有给定位置，a.pop() 将会删除并返回列表中的最后一个元素。
list.pop(i)

# 删除列表中所有的元素。相当于 del a[:] 。
list.clear()

# 返回列表中第一个值为 x 的元素的从零开始的索引。如果没有这样的元素将会抛出 ValueError 异常。
# 可选参数 start 和 end 是切片符号，用于将搜索限制为列表的特定子序列。返回的索引是相对于整个序列的开始计算的，而不是 start 参数。
list.index(x, start, end)

# 返回元素 x 在列表中出现的次数。
list.count(x)

# 对列表中的元素进行排序，可以自定义参数进行排序，使用key去定义排序的方法。
list.sort(key=None, reverse=False)

# 反转列表中的元素。
list.reverse()

# 返回列表的一个浅拷贝。相当于 a[:] 。
list.copy()

列表的创建

# 创建空列表
a = []
a = list()

# 直接创建
a = [1, 2, '3', '的']

# 使用其他的可迭代对象
# 使用字符串
a = list('hello world')
# 使用元组
a = list((1,2,3,4))
# 使用循环
a = list(range(1, 10, 2)
result: [1, 3, 5, 7, 9]

列表的增加

# 直接加，但是很慢
a = [1, 2, 3]
b = a + [4]

# 使用一些列表自带的方法

列表的删除

a = [1, 2, 3, 4]
del a[0]
result: [2, 3, 4]
del a[:2]
result: [4]

列表切片等操作

# 使用in，not in方法来判断是否是列表成员
a = [1, 2 ,3]
3 in a

# 列表的切片
a = [1, 2, 3, 4, 5]
# 第一个冒号代表开始位置，第二个冒号代表终止位置，第三个冒号代表表示步长
# 如下代表整个列表
a[::]
# 列表的翻转，
a[::-1]
#切片返回的是列表的浅复制

# 列表的自定义排序
a = [1, 22, 3, 11, 33]
a.sort(key=lambda x : len(str(x)))
result: [1, 3, 22, 11, 33]

# 列表推导式，其中还能调用函数
#生成范围内的序列
a = [x*x for x in range(10)]
result: [1,2,3,4,5,6,7,8,9]

# 列表平铺
a = [[1,2,3],[4,5,6],[7,8,9]]
[num for elem in a for num in elem]
result: [1,2,3,4,5,6,7,8,9]

元组

元组和列表最大的区别就是元组是不可变的序列，一但创建不可改变，但是当元组里面的元素可以改变时（如是个列表），则就可以改变这个列表中的元素。

元组的创建

# 如果要生成一个单个元素的元组，则我们需要加个,
a = ('1',)

# 创建空元组
a= ()

字典

字典就是键值对，所有元素放在{}中

字典的创建

# 直接创建
a = {1:'a', 2:'b', 3:'c', 4:'d'}

# 通过其他对象创建
a = [1, 2, 3, 4, 5]
b = ['a', 'b', 'c', 'd', 'e']
c = dict(zip(a,b))
result: {1: 'a', 2: 'b', 3: 'c', 4: 'd', 5: 'e'}

# 创建空字典
a = dict()
a = {}

# 通过dict方法
a = dict(name = 'aaa', age = 37)

字典的读增删

# 直接通过键值来读
a = {1:'a', 2:'b', 3:'c', 4:'d'}
print(a[1])

# 通过get方法来操作，如果无值，则返回None
a.get(1)

# 使用字典的items()方法可以返回键值对
a = {1:'a', 2:'b', 3:'c', 4:'d'}
for i in a.items():
	print(i)
result:
(1, 'a')
(2, 'b')
(3, 'c')
(4, 'd')
# 输出的就是所有的键值对

# 修改则就是通过=直接修改
a = {1:'a', 2:'b', 3:'c', 4:'d'}
a[1] = 'e'

集合

集合是一个无序可变序列，但是集合中的元素是唯一的

集合的创建等操作

# 直接创建
a = {2, 3}
a.add(4)

# 使用set方法
a = set(range(8, 14))

# 集合可以使用pop方法来删除第一个元素
a.pop()

集合特有的操作

a = {1, 2, 4, 5}
b = {1, 2, 4}

# 集合的交
a & b

# 集合的并
a | b

# 集合的差
a - b

序列数据结构中特有的方法

# 使用cmp函数来比较两个序列的大小, 从第一个元素开始比
cmp(a, b)

# 使用len获取长度
len(a)

# 使用max，min，sum等方法来获取最大值等
max(a)

# 使用zip来合并列表，为元组
a = [1, 2, 3]
b = [4, 5, 6]
c = zip(a,b)
print(list(c))
result: [(1,4), (2, 5), (3, 6)]

# 使用enumerate方法，来返回每个元素的下标和元素的元组
c = [(1,4), (2, 5), (3, 6)]
for i in enumerate(c):
	print(i)
result: 
(0, (1, 4))
(1, (2, 5))
(2, (3, 6))

# 序列解包
x, y, z = 1, 2, 3
c = [(1,4), (2, 5), (3, 6)]

a = [1, 2, 3]
b = [4, 5, 6]
for x, y in zip(a,b):
	print(x, y)
result:
1 4
2 5
3 6

python的字符串

字符串属于不可变序列类型，提供的对字符串修改的方法一般是重新创建一个对象。
字符串创建放在静态常量区，所以如果有重复的字符串，一般都会指向同一个字符串。

# 使用str()方法将一个对象转换为字符串
str(12232)

# 字符串格式化：
print ("我叫 %s 今年 %d 岁!" % ('小明', 10))
result: 我叫 小明 今年 10 岁!

# python三引号支持跨行
print ('''我叫 %s 今年
%d 岁!''' % ('小明', 10))
result:
我叫 小明 今年
10 岁!

# 使用format来格式化,而且可以使用一些方法
print('{}： "{}岁!"'.format('小明', 12))
result: 小明： "12岁!"

a = [1, 2, 3]
print("x:{0[0]}; y:{0[1]}; z:{0[2]}".format(a))
result: x:1; y:2; z:3

# 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
count(str, beg= 0,end=len(string))

# 检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1           
find(str, beg=0 end=len(string))
rfind则是从尾部向前查找

# 使用spilt()来分割字符串,如果不指定分隔符，则就使用默认的空白符来分割
s = "apple,peach,banana,pear"
li = s.split(",")
print(li)
result: ["apple","peach","banana","pear"]

# 可以使用join()方法来连接出一个字符串
a = ["apple","peach","banana","pear"]
sep = ','
s = sep.join(a)
print(s)
result: "apple,peach,banana,pear"

# 转换字符串中所有大写字符为小写.
lower()

# 把字符串中的old替换成new ,如果max指定，则替换不超过max 次。
replace(old, new [, max])

# 使用strip()方法来删除指定字符
s = "   a bc  "
s.strip(' ')
print(s)
result: "abc"

# 使用eval方法去直接计算一个字符串
eval("3+4")

python中函数的使用

python中参数传递，如果是基本变量，则就是形参，如果是序列，则函数内修改，函数外也会发生改变。

# python使用默认参数的时候，必须要从右边开始填满
def say(message, times = 1):
	print(message,times)
say("12")
result: 12 1

# 可变长参数
def demo(*p):
	print(p)
demo(1, 2, 3, 4)
result: (1, 2, 3, 4)

# 传入的是字典
def demo(**p):
	for i in p.items():
		print(i)
demo(x = 1, y = 2, z = 3)
result:
('x', 1)
('y', 2)
('z', 3)

# lambda表达式
f = lambda x, y, z : x + y + z
print(f(1, 2, 3)
result: 6

#map加lambda对列表中每个元素进行函数调用
a = [1, 2, 3, 4]
print(list(map(lambda(x : x+10), a)))
[11, 12, 13, 14]

python的面向对象

一个类的例子
# 类定义
class People:
    # 定义基本属性
    name = ''
    age = 0
    # 定义私有类型属性,私有属性在类外部无法直接进行访问
    __weight = 0
    # 定义保护类型属性
    _protected = 1
    # 定义构造方法, self代表这个对象自己
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
	
	def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
	
	# 类方法
	@classmethod
	def classShow(cls):
		print(cls.__weight)
	
	# 静态方法
	@staticmethod
	def staticShow():
		print("static")
	
	# 将方法变为属性
	@property
	def getvalue(self):
		return self.__weight
 
#单继承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
 
#另一个类，多重继承之前的准备
class speaker():
    topic = ''
    name = ''
    def __init__(self,n,t):
        self.name = n
        self.topic = t
    def speak(self):
        print("我叫 %s，我是一个演说家，我演讲的主题是 %s"%(self.name,self.topic))
 
#多重继承
class sample(speaker,student):
    a =''
    def __init__(self,n,a,w,g,t):
        student.__init__(self,n,a,w,g)
        speaker.__init__(self,n,t)
 
test = sample("Tim",25,80,4,"Python")
test.speak()   #方法名同，默认调用的是在括号中排前地父类的方法

# 一个运算符重载的例子
class Vector:
   def __init__(self, a, b):
      self.a = a
      self.b = b
       
   def __str__(self):
      return 'Vector (%d, %d)' % (self.a, self.b)
  
   def __add__(self,other):
      return Vector(self.a + other.a, self.b + other.b)
 
v1 = Vector(2,10)
v2 = Vector(5,-2)
print (v1 + v2)
result: Vector (7, 8)

python的文件操作

文件操作的方法
文件对象名 = open(文件名, 打开方式, 缓冲区)

文件打开的模式

模式	说明
r	读模式
w	写模式
a	追加模式
b	二进制模式（可组合使用）
+	读写模式（可组合使用）

文件中常用的方法

方法	功能说明
flush()	把缓冲区的内容写入文件
close()	缓冲区的内容写入文件，同时关闭文件，释放文件对象
read(size)	如果不加size，则就是读取文件中所有的数据，加的话，就是从文件中读取size个字符
readline()	读取一行
readlines()	把每行文本都作为一个字符串存入列表中，返回列表
seek(offset, whence)	将文件指针移动到新的位置，offset表示相对于whence的位置，如果省略，则就是默认从头开始
tell()	返回当前文件指针的位置
write(s)	将字符串s中的内容写入到文件中
writeline(s)	将字符串列表s写入到文本文件中，不添加换行符

#-*-coding:utf-8-*-
# 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
path='c:/users/zy/desktop/2.txt'
path1='c:/users/zy/desktop/4.txt'
f=open(path,'r')
f1=open(path1,'a')
while(1):
    line=f.readline()
    if not line:
        break
    f1.write(line[12:18]+'\n')
f.close()
f1.close()

python中的异常处理

异常处理try/except语句用来检测try语句块中的错误，从而让except语句捕获异常信息并处理。

try:
	# 运行别的代码
	语句
except name:
	# 如果在try部份引发了'name'异常
	语句
else:
	# 如果没有异常发生
	语句

# 举个栗子
try:
	fh = open("testfile", "w")
	fh.write("这是一个测试文件，用于测试异常!!")
except IOError:
	print("Error: 没有找到文件或读取文件失败")
else:
	print("内容写入文件成功")
	fh.close()

# 使用except而带多种异常类型
# 你也可以使用相同的except语句来处理多个异常信息，如下所示：
try:
	正常的操作
except(Exception1[, Exception2[,...ExceptionN]]]):
	发生以上多个异常中的一个，执行这块代码                
else:
	如果没有异常执行这块代码

# try-finally 语句无论是否发生异常都将执行最后的代码。
try:
	语句
finally:
	# 退出try时总会执行
	语句

# 举个例子
try:
    fh = open("testfile", "w")
    fh.write("这是一个测试文件，用于测试异常!!")
finally:
    print "Error: 没有找到文件或读取文件失败"

# 异常的参数
# 一个异常可以带上参数，可作为输出的异常信息参数。
# 你可以通过except语句来捕获异常的参数，如下所示：
try:
    正常的操作
except:ExceptionType, Argument:
    你可以在这输出 Argument 的值

# 函数中做异常检测
def try_exception(num):
	try:
		return int(num)
	except ValueError, arg:
		print(arg,"is not a number")
	else:
		print("this is a number inputs")
try_exception('xxx')
result:
Invalide literal for int() with base 10: 'xxx' is not a number

# assert可以判断一个语句是否为真，为假的话则抛出异常
assert 1 == 2, "1 is not equal 2"
result: AssertionError: 1 is not equal 2

参考书籍

[1] python程序设计 董付国 清华大学出版社
[2] 官方文档