Python基础笔记(三)

发表于 | 分类于

类和示例

用__init__初始化参数，相当于Java的构造函数。

注意到__init__方法的第一个参数永远是self，表示创建的实例本身，因此，在__init__方法内部，就可以把各种属性绑定到self，因为self就指向创建的实例本身。

获取对象信息

拿到一个对象的引用时，如何知道这个对象是什么类型、有哪些方法呢？

使用type()。判断基本类型较方便。

使用isinstance()。判断class类型较方便。也可以判断基本类型。

使用dir()。如果要获得一个对象的所有属性和方法，可以使用dir()函数，它返回一个包含字符串的list，比如，获得一个str对象的所有属性和方法：

1
2
>>> dir('ABC')
['__add__', '__class__',..., '__subclasshook__', 'capitalize', 'casefold',..., 'zfill']

@property

Python内置的@property装饰器就是负责把一个方法变成属性调用的。

把一个getter方法变成属性，只需要加上@property就可以了，此时，@property本身又创建了另一个装饰器@s_width.setter，负责把一个setter方法变成属性赋值。举例如下，请利用@property给一个Screen对象加上width和height属性，以及一个只读属性resolution，其中width和height可以设置为私有实例变量：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
class Screen(object):
	@property
	def s_width(self):
		return self.width
	@s_width.setter
	def s_width(self, value):
		self.width = value
	@property
	def s_height(self):
		return self.height
	@s_height.setter
	def s_height(self, value):
		self.height = value
	@property
	def resoluton(self):
		return self.width * self.height

	
>>> s = Screen()
>>> s.s_width = 1024
>>> s.s_height = 768
>>> s.resolution
Traceback (most recent call last):
  File "<pyshell#28>", line 1, in <module>
    s.resolution
AttributeError: 'Screen' object has no attribute 'resolution'
>>> s.resoluton
786432

注意到这个神奇的@property，我们在对实例属性操作的时候，就知道该属性很可能不是直接暴露的，而是通过getter和setter方法来实现的。

文件读写

在Python中，文件读写是通过open()函数打开的文件对象完成的。使用with语句操作文件IO是个好习惯。

1
2
3
4
>>> fpath = r'C:Windows\system.ini'
>>> with open(fpath, 'r') as f:
	s = f.read()
	print(s)

StringIO和BytesIO

StringIO和BytesIO是在内存中操作str和bytes的方法，使得和读写文件具有一致的接口。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
>>> from io import StringIO
>>> f = StringIO()
>>> f.write('hello')
5
>>> f.write(' ')
1
>>> f.write('world!')
6
>>> print(f.getvalue())
hello world!

>>> from io import StringIO
>>> f = StringIO('Hello!\nHi!\nGoodbye!')
>>> while True:
...     s = f.readline()
...     if s == '':
...         break
...     print(s.strip())
...
Hello!
Hi!
Goodbye!
1
2
3
4
5
6
7
8
9
10
11
>>> from io import BytesIO
>>> f = BytesIO()
>>> f.write('中文'.encode('utf-8'))
6
>>> print(f.getvalue())
b'\xe4\xb8\xad\xe6\x96\x87'

>>> from io import BytesIO
>>> f = BytesIO(b'\xe4\xb8\xad\xe6\x96\x87')
>>> f.read()
b'\xe4\xb8\xad\xe6\x96\x87'

操作文件和目录

操作文件和目录的函数一部分放在os模块中，一部分放在os.path模块中，这一点要注意一下。查看、创建和删除目录可以这么调用：

1
2
3
4
5
6
7
8
9
10
# 查看当前目录的绝对路径:
>>> os.path.abspath('.')
'/Users/michael'
# 在某个目录下创建一个新目录，首先把新目录的完整路径表示出来:
>>> os.path.join('/Users/michael', 'testdir')
'/Users/michael/testdir'
# 然后创建一个目录:
>>> os.mkdir('/Users/michael/testdir')
# 删掉一个目录:
>>> os.rmdir('/Users/michael/testdir')

把两个路径合成一个时，不要直接拼字符串，而要通过os.path.join()函数，这样可以正确处理不同操作系统的路径分隔符。同样的道理，要拆分路径时，也不要直接去拆字符串，而要通过os.path.split()函数，这样可以把一个路径拆分为两部分，后一部分总是最后级别的目录或文件名：

1
2
>>> os.path.split('/Users/michael/testdir/file.txt')
('/Users/michael/testdir', 'file.txt')

os.path.splitext()可以直接让你得到文件扩展名，很多时候非常方便：

1
2
>>> os.path.splitext('/path/to/file.txt')
('/path/to/file', '.txt')

这些合并、拆分路径的函数并不要求目录和文件要真实存在，它们只对字符串进行操作。

JSON

Python内置的json模块提供了非常完善的Python对象到JSON格式的转换。我们先看看如何把Python对象变成一个JSON：

1
2
3
4
>>> import json
>>> d = dict(name='Bob', age=20, score=88)
>>> json.dumps(d)
'{"age": 20, "score": 88, "name": "Bob"}'

dumps()方法返回一个str，内容就是标准的JSON。类似的，dump()方法可以直接把JSON写入一个file-like Object。

要把JSON反序列化为Python对象，用loads()或者对应的load()方法，前者把JSON的字符串反序列化，后者从file-like Object中读取字符串并反序列化：

1
2
3
>>> json_str = '{"age": 20, "score": 88, "name": "Bob"}'
>>> json.loads(json_str)
{'age': 20, 'score': 88, 'name': 'Bob'}

python正则表达式

  • 用\d可以匹配一个数字，\w可以匹配一个字母或数字
  • . 可以匹配任意一个字符
  • \* 通配符匹配零个或多个字符
  • ?表示0个或1个字符
  • +表示至少一个字符
  • 用{n}表示n个字符，用{n,m}表示n-m个字符
1
2
3
4
5
6
7
8
9
复杂的例子：\d{3}\s+\d{3,8}。

从左到右解读一下：

1.\d{3}表示匹配3个数字，例如'010'；

2.\s可以匹配一个空格（也包括Tab等空白符），所以\s+表示至少有一个空格，例如匹配' '，' '等；

3.\d{3,8}表示3-8个数字，例如'1234567'。

要做更精确地匹配，可以用[]表示范围，比如：

  • [0-9a-zA-Z\_]可以匹配一个数字、字母或者下划线；
  • [0-9a-zA-Z\_]+可以匹配至少由一个数字、字母或者下划线组成的字符串，比如’a100’，’0_Z’，’Py3000’等等；
  • [a-zA-Z\_][0-9a-zA-Z\_]*可以匹配由字母或下划线开头，后接任意个由一个数字、字母或者下划线组成的字符串，也就是Python合法的变量；
  • [a-zA-Z\_][0-9a-zA-Z\_]{0, 19}更精确地限制了变量的长度是1-20个字符（前面1个字符+后面最多19个字符）。

A|B可以匹配A或B，所以(P|p)ython可以匹配’Python’或者’python’。

\^表示行的开头，^\d表示必须以数字开头。

$表示行的结束，\d$表示必须以数字结束。

py也可以匹配’python’，但是加上^py$就变成了整行匹配，就只能匹配'py'了。

分组

除了简单地判断是否匹配之外，正则表达式还有提取子串的强大功能。用()表示的就是要提取的分组（Group）。比如：

^(\d{3})-(\d{3,8})$分别定义了两个组，可以直接从匹配的字符串中提取出区号和本地号码：

1
2
3
4
5
6
7
8
9
>>> m = re.match(r'^(\d{3})-(\d{3,8})$', '010-12345')
>>> m
<_sre.SRE_Match object; span=(0, 9), match='010-12345'>
>>> m.group(0)
'010-12345'
>>> m.group(1)
'010'
>>> m.group(2)
'12345'

如果正则表达式中定义了组，就可以在Match对象上用group()方法提取出子串来。

注意到group(0)永远是原始字符串，group(1)、group(2)……表示第1、2、……个子串。

学习资料

菜鸟教程Python3

廖雪峰的官方网站Python3