Python基本的功能使用
转自:Python 3 入门,看这篇就够了
详情点击: Python 3 入门,看这篇就够了
1.字符串
1.1 字符串函数
1.2 字符串运算符
1.3 格式化符号
1.4 格式化辅助指令
1.5 转义字符
2. 文件操作
2.1 读写模式
2.2 文件对象方法
-
fileObject.close()
close() 方法用于关闭一个已打开的文件。关闭后的文件不能再进行读写操作,否则会触发 ValueError 错误。close() 方法允许调用多次。当 file 对象,被引用到操作另外一个文件时,Python 会自动关闭之前的 file 对象。使用 close() 方法关闭文件是一个好的习惯。
-
fileObject.flush()
flush() 方法是用来刷新缓冲区的,即将缓冲区中的数据立刻写入文件,同时清空缓冲区,不需要是被动的等待输出缓冲区写入。
一般情况下,文件关闭后会自动刷新缓冲区,但有时你需要在关闭前刷新它,这时就可以使用 flush() 方法。
-
fileObject.fileno()
fileno() 方法返回一个整型的文件描述符(file descriptor FD 整型),可用于底层操作系统的 I/O 操作。
-
fileObject.isatty()
isatty() 方法检测文件是否连接到一个终端设备,如果是返回 True,否则返回 False。
-
next(iterator[,default])
Python 3 中的 File 对象不支持 next() 方法。Python 3 的内置函数 next() 通过迭代器调用 next() 方法返回下一项。在循环中,next() 函数会在每次循环中调用,该方法返回文件的下一行,如果到达结尾(EOF),则触发 StopIteration。
-
fileObject.read()
read() 方法用于从文件读取指定的字节数,如果未给定或为负则读取所有。
-
fileObject.readline()
readline() 方法用于从文件读取整行,包括 “\n” 字符。如果指定了一个非负数的参数,则返回指定大小的字节数,包括 “\n” 字符。
-
fileObject.readlines()
readlines() 方法用于读取所有行(直到结束符 EOF)并返回列表,该列表可以由 Python 的 for… in … 结构进行处理。如果碰到结束符 EOF,则返回空字符串。
-
fileObject.seek(offset[, whence])
seek() 方法用于移动文件读取指针到指定位置。
whence 的值, 如果是 0 表示开头, 如果是 1 表示当前位置, 2 表示文件的结尾。whence 值为默认为0,即文件开头。例如:
seek(x, 0):从起始位置即文件首行首字符开始移动 x 个字符
seek(x, 1):表示从当前位置往后移动 x 个字符
seek(-x, 2):表示从文件的结尾往前移动 x 个字符
-
fileObject.tell(offset[, whence])
tell() 方法返回文件的当前位置,即文件指针当前位置。
-
fileObject.truncate([size])
truncate() 方法用于从文件的首行首字符开始截断,截断文件为 size 个字符,无 size 表示从当前位置截断;截断之后 V 后面的所有字符被删除,其中 Widnows 系统下的换行代表2个字符大小。
-
fileObject.write([str])
write() 方法用于向文件中写入指定字符串。
在文件关闭前或缓冲区刷新前,字符串内容存储在缓冲区中,这时你在文件中是看不到写入的内容的。
如果文件打开模式带 b,那写入文件内容时,str (参数)要用 encode 方法转为 bytes 形式,否则报错:TypeError: a bytes-like object is required, not ‘str’。
-
fileObject.writelines([str])
writelines() 方法用于向文件中写入一序列的字符串。这一序列字符串可以是由迭代对象产生的,如一个字符串列表。换行需要指定换行符 \n。
实例
filename = 'data.log'
# 打开文件(a+ 追加读写模式)
# 用 with 关键字的方式打开文件,会自动关闭文件资源
with open(filename, 'w+', encoding='utf-8') as file:
print('文件名称: {}'.format(file.name))
print('文件编码: {}'.format(file.encoding))
print('文件打开模式: {}'.format(file.mode))
print('文件是否可读: {}'.format(file.readable()))
print('文件是否可写: {}'.format(file.writable()))
print('此时文件指针位置为: {}'.format(file.tell()))
# 写入内容
num = file.write("第一行内容\n")
print('写入文件 {} 个字符'.format(num))
# 文件指针在文件尾部,故无内容
print(file.readline(), file.tell())
# 改变文件指针到文件头部
file.seek(0)
# 改变文件指针后,读取到第一行内容
print(file.readline(), file.tell())
# 但文件指针的改变,却不会影响到写入的位置
file.write('第二次写入的内容\n')
# 文件指针又回到了文件尾
print(file.readline(), file.tell())
# file.read() 从当前文件指针位置读取指定长度的字符
file.seek(0)
print(file.read(9))
# 按行分割文件,返回字符串列表
file.seek(0)
print(file.readlines())
# 迭代文件对象,一行一个元素
file.seek(0)
for line in file:
print(line, end='')
# 关闭文件资源
if not file.closed:
file.close()
输出:
文件名称: data.log
文件编码: utf-8
文件打开模式: w+
文件是否可读: True
文件是否可写: True
此时文件指针位置为: 0
写入文件 6 个字符
16
第一行内容
16
41
第一行内容
第二次
['第一行内容\n', '第二次写入的内容\n']
第一行内容
第二次写入的内容
3. 数学模块(math)
3.1 一般方法
3.2 三角函数
3.3 数学常量
4. 命名规范
Python之父Guido推荐的规范
5. 随机数函数(random)
import random
6. 运算符优先级
7. 身份运算符(is | not is)
8. 成员运算符(in | not in)
9. 位运算符(& | ^ ~ << >>)
10. 逻辑运算符(and | or | not)
11. 类的专有方法:
11.1 方法
– | – |
---|---|
函数 | 用法 |
__ init__ | 构造函数,在生成对象时调用 |
__ del__ | 析构函数,释放对象时使用 |
__ repr__ | 打印,转换 |
__ setitem__ | 按照索引赋值 |
__ getitem__ | 按照索引获取值 |
__ len__ | 获得长度 |
__ cmp__ | 比较运算 |
__ call__ | 函数调用 |
__ add__ | 加运算 |
__ sub__ | 减运算 |
__ mul__ | 乘运算 |
__ div__ | 除运算 |
__ mod__ | 求余运算 |
__ pow__ | 乘方 |
类的专有方法也支持重载。
11.2 实例
class Person:
"""人员信息"""
# 姓名(共有属性)
name = ''
# 年龄(共有属性)
age = 0
def __init__(self, name='', age=0):
self.name = name
self.age = age
# 重载专有方法: __str__
def __str__(self):
return "这里重载了 __str__ 专有方法, " + str({'name': self.name, 'age': self.age})
def set_age(self, age):
self.age = age
class Account:
"""账户信息"""
# 账户余额(私有属性)
__balance = 0
# 所有账户总额
__total_balance = 0
# 获取账户余额
# self 必须是方法的第一个参数
def balance(self):
return self.__balance
# 增加账户余额
def balance_add(self, cost):
# self 访问的是本实例
self.__balance += cost
# self.__class__ 可以访问类
self.__class__.__total_balance += cost
# 类方法(用 @classmethod 标识,第一个参数为 cls)
@classmethod
def total_balance(cls):
return cls.__total_balance
# 静态方法(用 @staticmethod 标识,不需要类参数或实例参数)
@staticmethod
def exchange(a, b):
return b, a
class Teacher(Person, Account):
"""教师"""
# 班级名称
_class_name = ''
def __init__(self, name):
# 第一种重载父类__init__()构造方法
# super(子类,self).__init__(参数1,参数2,....)
super(Teacher, self).__init__(name)
def get_info(self):
# 以字典的形式返回个人信息
return {
'name': self.name, # 此处访问的是父类Person的属性值
'age': self.age,
'class_name': self._class_name,
'balance': self.balance(), # 此处调用的是子类重载过的方法
}
# 方法重载
def balance(self):
# Account.__balance 为私有属性,子类无法访问,所以父类提供方法进行访问
return Account.balance(self) * 1.1
class Student(Person, Account):
"""学生"""
_teacher_name = ''
def __init__(self, name, age=18):
# 第二种重载父类__init__()构造方法
# 父类名称.__init__(self,参数1,参数2,...)
Person.__init__(self, name, age)
def get_info(self):
# 以字典的形式返回个人信息
return {
'name': self.name, # 此处访问的是父类Person的属性值
'age': self.age,
'teacher_name': self._teacher_name,
'balance': self.balance(),
}
# 教师 John
john = Teacher('John')
john.balance_add(20)
john.set_age(36) # 子类的实例可以直接调用父类的方法
print("John's info:", john.get_info())
# 学生 Mary
mary = Student('Mary', 18)
mary.balance_add(18)
print("Mary's info:", mary.get_info())
# 学生 Fake
fake = Student('Fake')
fake.balance_add(30)
print("Fake's info", fake.get_info())
# 三种不同的方式调用静态方法
print("john.exchange('a', 'b'):", john.exchange('a', 'b'))
print('Teacher.exchange(1, 2)', Teacher.exchange(1, 2))
print('Account.exchange(10, 20):', Account.exchange(10, 20))
# 类方法、类属性
print('Account.total_balance():', Account.total_balance())
print('Teacher.total_balance():', Teacher.total_balance())
print('Student.total_balance():', Student.total_balance())
# 重载专有方法
print(fake)
输出:
John's info: {'name': 'John', 'age': 36, 'class_name': '', 'balance': 22.0}
Mary's info: {'name': 'Mary', 'age': 18, 'teacher_name': '', 'balance': 18}
Fake's info {'name': 'Fake', 'age': 18, 'teacher_name': '', 'balance': 30}
john.exchange('a', 'b'): ('b', 'a')
Teacher.exchange(1, 2) (2, 1)
Account.exchange(10, 20): (20, 10)
Account.total_balance(): 0
Teacher.total_balance(): 20
Student.total_balance(): 48
这里重载了 __str__ 专有方法, {'name': 'Fake', 'age': 18}
12.序列化
在 Python 中 pickle 模块实现对数据的序列化和反序列化。pickle 支持任何数据类型,包括内置数据类型、函数、类、对象等。
12.1 dump
将数据对象序列化后写入文件
pickle.dump(obj, file, protocol=None, fix_imports=True)
必填参数 obj 表示将要封装的对象。必填参数 file 表示 obj 要写入的文件对象,file 必须以二进制可写模式打开,即wb。可选参数 protocol 表示告知 pickle 使用的协议,支持的协议有 0,1,2,3,默认的协议是添加在 Python 3 中的协议3。
12.2 load
从文件中读取内容并反序列化
pickle.load(file, fix_imports=True, encoding='ASCII', errors='strict')
必填参数 file 必须以二进制可读模式打开,即rb,其他都为可选参数。
12.3 dumps
以字节对象形式返回封装的对象,不需要写入文件中
pickle.dumps(obj, protocol=None, fix_imports=True)
loads
从字节对象中读取被封装的对象,并返回
pickle.loads(bytes_object, fix_imports=True, encoding='ASCII', errors='strict')
12.4 实例
import pickle
data = [1, 2, 3]
# 序列化数据并以字节对象返回
dumps_obj = pickle.dumps(data)
print('pickle.dumps():', dumps_obj)
# 从字节对象中反序列化数据
loads_data = pickle.loads(dumps_obj)
print('pickle.loads():', loads_data)
filename = 'data.log'
# 序列化数据到文件中
with open(filename, 'wb') as file:
pickle.dump(data, file)
# 从文件中加载并反序列化
with open(filename, 'rb') as file:
load_data = pickle.load(file)
print('pickle.load():', load_data)
输出:
pickle.dumps(): b'\x80\x03]q\x00(K\x01K\x02K\x03e.'
pickle.loads(): [1, 2, 3]
pickle.load(): [1, 2, 3]
13. 异常
可以通过创建一个新的异常类来拥有自己的异常。异常类继承自 Exception 类,可以直接继承,或者间接继承。
当创建一个模块有可能抛出多种不同的异常时,一种通常的做法是为这个包建立一个基础异常类,然后基于这个基础类为不同的错误情况创建不同的子类。
大多数的异常的名字都以”Error”结尾,就跟标准的异常命名一样。
实例
import sys
class Error(Exception):
"""Base class for exceptions in this module."""
pass
# 自定义异常
class InputError(Error):
"""Exception raised for errors in the input.
Attributes:
expression -- input expression in which the error occurred
message -- explanation of the error
"""
def __init__(self, expression, message):
self.expression = expression
self.message = message
try:
print('code start running...')
raise InputError('input()', 'input error')
# ValueError
int('a')
# TypeError
s = 1 + 'a'
dit = {'name': 'john'}
# KeyError
print(dit['1'])
except InputError as ex:
print("InputError:", ex.message)
except TypeError as ex:
print('TypeError:', ex.args)
pass
except (KeyError, IndexError) as ex:
"""支持同时处理多个异常, 用括号放到元组里"""
print(sys.exc_info())
except:
"""捕获其他未指定的异常"""
print("Unexpected error:", sys.exc_info()[0])
# raise 用于抛出异常
raise RuntimeError('RuntimeError')
else:
"""当无任何异常时, 会执行 else 子句"""
print('"else" 子句...')
finally:
"""无论有无异常, 均会执行 finally"""
print('finally, ending')
14. 集合(set)
集合是一个无序不重复元素的序列
14.1 创建集合
可以使用大括号 {} 或者 set() 函数创建集合
创建一个空集合必须用 set() 而不是 {},因为 {} 是用来创建一个空字典
set(value) 方式创建集合,value 可以是字符串、列表、元组、字典等序列类型
创建、添加、修改等操作,集合会自动去重
{1, 2, 1, 3} # {} {1, 2, 3}
set('12345') # 字符串 {'3', '5', '4', '2', '1'}
set([1, 'a', 23.4]) # 列表 {1, 'a', 23.4}
set((1, 'a', 23.4)) # 元组 {1, 'a', 23.4}
set({1:1, 'b': 9}) # 字典 {1, 'b'}
14.2 添加元素
将元素 val 添加到集合 set 中,如果元素已存在,则不进行任何操作:
set.add(val)
也可以用 update 方法批量添加元素,参数可以是列表,元组,字典等:
set.update(list1, list2,...)
14.3 移除元素
如果存在元素 val 则移除,不存在就报错:
set.remove(val)
如果存在元素 val 则移除,不存在也不会报错:
set.discard(val)
随机移除一个元素:
set.pop()
14.4 元素个数
与其他序列一样,可以用 len(set) 获取集合的元素个数。
14.5 清空集合
set.clear()
set = set()
14.6 判断元素是否存在
val in set
14.7 其他方法
set.copy()
复制集合
set.difference(set2)
求差集,在 set 中却不在 set2 中
set.intersection(set2)
求交集,同时存在于 set 和 set2 中
set.union(set2)
求并集,所有 set 和 set2 的元素
set.symmetric_difference(set2)
求对称差集,不同时出现在两个集合中的元素
set.isdisjoint(set2)
如果两个集合没有相同的元素,返回 True
set.issubset(set2)
如果 set 是 set2 的一个子集,返回 True
set.issuperset(set2)
如果 set 是 set2 的一个超集,返回 True
14.8集合计算
a = set('abracadabra')
b = set('alacazam')
print(a) # a 中唯一的字母
# {'a', 'r', 'b', 'c', 'd'}
print(a - b) # 在 a 中的字母,但不在 b 中
# {'r', 'd', 'b'}
print(a | b) # 在 a 或 b 中的字母
# {'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
print(a & b) # 在 a 和 b 中都有的字母
# {'a', 'c'}
print(a ^ b) # 在 a 或 b 中的字母,但不同时在 a 和 b 中
# {'r', 'd', 'b', 'm', 'z', 'l'}
14.9 集合推导式
a = {x for x in 'abracadabra' if x not in 'abc'}
print(a)
# {'d', 'r'}
15. __ name __ 属性
每个模块都有一个 __ name __ 属性,当其值是 __ main __ 时,表明该模块自身在运行,否则是被引入。
一个模块被另一个程序第一次引入时,其主程序将运行。如果我们想在模块被引入时,模块中的某一程序块不执行,我们可以用 __ name __ 属性来使该程序块仅在该模块自身运行时执行。
if __name__ == '__main__':
print('程序自身在运行')
else:
print('我来自另一模块')
16. dir 函数
内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回。
如果没有给定参数,那么 dir() 函数会罗列出当前定义的所有名称。
在 Python 中万物皆对象,int、str、float、list、tuple等内置数据类型其实也是类,也可以用 dir(int) 查看 int 包含的所有方法。也可以使用 help(int) 查看 int 类的帮助信息。
17. 包
包是一种管理 Python 模块命名空间的形式,采用”点模块名称”。
比如一个模块的名称是 A.B, 那么他表示一个包 A中的子模块 B 。
就好像使用模块的时候,你不用担心不同模块之间的全局变量相互影响一样,采用点模块名称这种形式也不用担心不同库之间的模块重名的情况。
在导入一个包的时候,Python 会根据 sys.path 中的目录来寻找这个包中包含的子目录。
目录只有包含一个叫做 init.py 的文件才会被认作是一个包,主要是为了避免一些滥俗的名字(比如叫做 string)不小心的影响搜索路径中的有效模块。
最简单的情况,放一个空的 init.py 文件就可以了。当然这个文件中也可以包含一些初始化代码或者为 all 变量赋值。