Python速成笔记

基础

1.标识符

标识符由字母、数字、下划线组成，不能以数字开头，区分大小写。

以下划线开头的标识符有特殊含义，

单下划线开头的标识符，如：_xxx ，表示不能直接访问的类属性，需通过类提供的接口进行访问，不能用 from xxx import * 导入；

双下划线开头的标识符，如：__ xxx，表示私有成员；双下划线开头和结尾的标识符，如:__ xx，表示 Python 中内置标识，如：init() 表示类的构造函数。

2.关键字

and	exec	not	assert	finally	or
break	for	pass	class	from	print
continue	global	raise	def	if	return
del	import	try	elif	in	while
else	is	with	except	lambda	yield

3.输入输出

Python 输出使用 print()

print('Hello Python')

Python 提供了一个 input()，可以让用户输入字符串，并存放到一个变量里。

name = input()
print('Hi',name)

4.注释

Python 中单行注释使用 #，多行注释使用三个单引号（'''）或三个双引号（"""）。如下所示：

# 我是单行注释

'''
我是多行注释
我是多行注释
'''

"""
我是多行注释
我是多行注释
"""

5.运算符

常用：

#取模
a % b

#幂
a**b 表示 a 的 b 次幂

#取整除
9 // 4 结果为 2

#取反
~a

#异或
a ^ b

#左移动,右移动
a << 3
a >> 3

#布尔类型与,布尔类型或,布尔类型非
a and b
a or b
not a

#判断两个标识符是否引用同一个对象
a is b

#判断两个标识符是否引用不同对象
a is not b

语法

1.条件语句

格式：

f 判断条件1:
    执行语句1...
elif 判断条件2:
    执行语句2...
elif 判断条件3:
    执行语句3...
else:
    执行语句4...

2.循环语句

for 循环

str = 'Python'
for s in str:
    print(s)
结果：
P
y
t
h
o
n

while 循环

函数

自定义函数

Python 使用 def 关键字来声明函数，格式如下所示：

def 函数名(参数):
	函数体
	return 返回值

当我们不确定参数的个数时，可以使用不定长参数，在参数名前加 * 进行声明，格式如下所示：

def 函数名(*参数名):
	函数体

空函数

如果要定义一个无任何功能的空函数，函数体只写 pass 即可。格式如下所示：

def 函数名():
	pass

匿名函数

我们还可以使用 lambda 定义匿名函数，格式如下所示：

lambda 参数 : 表达式

例子：

# 空函数
def my_empty():
    pass

# 无返回值
def my_print(name):
    print('Hello', name)

# 有返回值
def my_sum(x, y):
    s = x + y
    print('s-->', s)
    return s
    
# 不定长参数
def my_variable(*params):
    for p in params:
        print(p)

# 匿名函数
my_sub = lambda x, y: x - y

模块与包

模块

Python 中一个以 .py 结尾的文件就是一个模块，模块中定义了变量、函数等来实现一些类似的功能。Python 有很多自带的模块（标准库）和第三方模块，一个模块可以被其他模块引用，实现了代码的复用性。

包

包是存放模块的文件夹，包中包含 __init__.py 和其他模块，__init__.py 可为空也可定义属性和方法，在 Python3.3 之前的版本，一个文件夹中只有包含 __init__.py，其他程序才能从该文件夹引入相应的模块、函数等，之后的版本没有 __init__.py 也能正常导入，简单来说就是 Python3.3 之前的版本，__init__.py 是包的标识，是必须要有的，之后的版本可以没有。

引用

从包中引入模块有如下两种方式：

import …

import 包名1.包名2...模块名
from ... import ...

from … import …

from 包名1.包名2... import 模块名from 包名1.包名2...模块名 import 变量名/函数名

# a 模块中引入 b 模块
import pg1.b
from pg1 import b

# a 模块中引入 c 模块
import pg2.c
from pg2 import c

# a 模块中引入 c 模块和 d 模块
import pg2.c,pg2.d
from pg2 import c,d

# a 模块中引入包 pg2 下的所有模块
from pg2 import *

# a 模块中引入 d 模块中函数 d()
from pg2.d import d
# 调用函数 d()
d()

面向对象

面向对象相关概念

• 类：描述具有相同属性和方法的集合，简单来说就是一个模板，通它来创建对象。
• 对象：类的实例。
• 方法：类中定义的函数。
• 类变量：定义在类中且在函数之外的变量，在所有实例化对象中公用。
• 局部变量：方法中定义的变量，只作用于当前实例。

面向对象三大特性

• 封装：隐藏对象的属性和实现细节，仅对外提供公共访问方式，提高复用性和安全性。
• 继承：一个类继承一个基类便可拥有基类的属性和方法，可提高代码的复用性。
• 多态：父类定义的引用变量可以指向子类的实例对象，提高了程序的拓展性

类

Python 中类的定义使用 class 关键字，语法如下所示：

class 类名:	
          属性	...	
          方法	...

比如我们定义一个类 Cat，如下所示：

class Cat:
	# 属性
    color = 'black'
    # 构造方法
    def __init__(self, name):
        self.name = name
    # 自定义方法
    def eat(self, food):
        self.food = food
        print(self.name, '正在吃'+food)

构造方法 __init__() 会在类实例化时自动调用。无论构造方法还是其他方法都需要将 self 作为第一个参数，它代表类的实例。

类创建好后，我们可以直接通过类名访问属性，格式为：类名.属性名，比如我们访问 Cat 类的 color 属性，如下所示：

print('color-->', Cat.color)

上面 Cat 类中定义的属性和方法都是公开的，除此之外我们还可以定义私有属性和方法，声明方式为：在属性名或方法名前加两条下划线，示例如下所示：

class Cat:
    __cid = '1'
    def __run(self):
        pass

对象

创建对象也称类的实例化，比如我们通过 Cat 类创建对象，如下所示：

 # 创建对象
c = Cat('Tom')

访问属性和调用方法了，如下所示：

# 访问属性
print('name-->', c.name)
print('color-->', c.color)
# 调用方法
c.eat('鱼')

**同样对象外部 c 不能访问私有属性 __cid 及调用私有方法 __run，**在内部私有属性和方法是可以被访问和调用的。

继承

Python 支持类的继承，而且支持多继承，语法格式为：

class 基类(子类1, 子类2 ...):	...

示例如下所示：

# 波斯猫类
class PersianCat(Cat):
    def __init__(self, name):
        self.name = name
    def eat(self, food):
        print(self.name, '正在吃'+food)
#加菲猫类
class GarfieldCat(Cat):
    def __init__(self, name):
        self.name = name
    def run(self, speed):
        print(self.name, '正在以'+speed+'的速度奔跑')
# 单继承
class SingleCat(PersianCat):
    pass
# 多继承
class MultiCat(PersianCat, GarfieldCat):
    pass

#调用
sc = SingleCat('波斯猫1号')
sc.eat('鱼')

mc = MultiCat('波斯加菲猫1号')
mc.eat('鱼')
mc.run('50迈')

子类可以重写父类方法：

class SingleCat(PersianCat):
    def eat(self, food ):
        print(self.name, '正在吃'+food, '十分钟后', self.name+'吃饱了')
sc = SingleCat('波斯猫1号')
sc.eat('鱼'）

文件基本操作

创建

Python 使用 open() 函数创建或打开文件，语法格式如下所示：

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

参数说明如下所示：

• file：表示将要打开的文件的路径，也可以是要被封装的整数类型文件描述符。
• mode：是一个可选字符串，用于指定打开文件的模式，默认值是 'r'（以文本模式打开并读取）。可选模式如下：

模式	描述
r	读取（默认）
w	写入，并先截断文件
x	排它性创建，如果文件已存在则失败
a	写入，如果文件存在则在末尾追加
b	二进制模式
t	文本模式（默认）
+	更新磁盘文件（读取并写入）

• buffering：是一个可选的整数，用于设置缓冲策略。
• encoding：用于解码或编码文件的编码的名称。
• errors：是一个可选的字符串，用于指定如何处理编码和解码错误（不能在二进制模式下使用）。
• newline：区分换行符。
• closefd：如果 closefd 为 False 并且给出了文件描述符而不是文件名，那么当文件关闭时，底层文件描述符将保持打开状态；如果给出文件名，closefd 为 True （默认值），否则将引发错误。
• opener：可以通过传递可调用的 opener 来使用自定义开启器。

以 txt 格式文件为例，我们不手动创建文件，通过代码方式来创建，如下所示：

open('test.txt', mode='w',encoding='utf-8')

写入

函数	描述
write(str)	将字符串写入文件，返回写入字符长度
writelines(s)	向文件写入一个字符串列表

我们使用这两个函数向文件中写入一些信息，如下所示：

wf = open('test.txt', 'w', encoding='utf-8')
wf.write('Tom\n')
wf.writelines(['Hello\n', 'Python'])
# 关闭
wf.close()

上面我们使用了 close() 函数进行关闭操作，如果打开的文件忘记了关闭，可能会对程序造成一些隐患，为了避免这个问题的出现，可以使用 with as 语句，通过这种方式，程序执行完成后会自动关闭已经打开的文件。如下所示：

with open('test.txt', 'w', encoding='utf-8') as wf:
    wf.write('Tom\n')
    wf.writelines(['Hello\n', 'Python'])

读取

函数	描述
read(size)	读取指定的字节数，参数可选，无参或参数为负时读取所有
readline()	读取一行
readlines()	读取所有行并返回列表

with open('test.txt', 'r', encoding='utf-8') as rf:
    print('readline-->', rf.readline())
    print('read-->', rf.read(6))
    print('readlines-->', rf.readlines())

定位

函数	描述
tell()	返回文件对象在文件中的当前位置
file.seek(offset[, whence])	将文件对象移动到指定的位置；offset 表示移动的偏移量；whence 为可选参数，值为 0 表示从文件开头起算（默认值）、值为 1 表示使用当前文件位置、值为 2 表示使用文件末尾作为参考点

with open('test.txt', 'rb+') as f:
    f.write(b'123456789')
    # 文件对象位置
    print(f.tell())
    # 移动到文件的第四个字节
    f.seek(3)
    # 读取一个字节，文件对象向后移动一位
    print(f.read(1))
    print(f.tell())
    # 移动到倒数第二个字节
    f.seek(-2, 2)
    print(f.tell())
    print(f.read(1))

os 模块

os.getcwd()

查看当前路径。

import osprint(os.getcwd())

os.listdir(path)

返回指定目录下包含的文件和目录名列表。

import osprint(os.listdir('E:/'))

os.path.abspath(path)

返回路径 path 的绝对路径。

import os# 当前路径（相对路径方式）print(os.path.abspath('.'))

os.path.split(path)

将路径 path 拆分为目录和文件两部分，返回结果为元组类型。

import osprint(os.path.split('E:/tmp.txt'))

os.path.join(path, *paths)

将一个或多个 path（文件或目录） 进行拼接。

import osprint(os.path.join('E:/', 'tmp.txt'))

os.path.getctime(path)

返回 path（文件或目录） 在系统中的创建时间。

import osimport datetimeprint(datetime.datetime.utcfromtimestamp(os.path.getctime('E:/tmp.txt')))

os.path.getmtime(path)

返回 path（文件或目录）的最后修改时间。

import osimport datetimeprint(datetime.datetime.utcfromtimestamp(os.path.getmtime('E:/tmp.txt')))

os.path.getatime(path)

返回 path（文件或目录）的最后访问时间。

import osimport datetimeprint(datetime.datetime.utcfromtimestamp(os.path.getatime('E:/tmp.txt')))

os.path.exists(path)

判断 path（文件或目录）是否存在，存在返回 True，否则返回 False。

import osprint(os.path.exists('E:/tmp.txt'))

os.path.isdir(path)

判断 path 是否为目录。

import osprint(os.path.isdir('E:/'))

os.path.isfile(path)

判断 path 是否为文件。

import osprint(os.path.isfile('E:/tmp.txt'))

os.path.getsize(path)

返回 path 的大小，以字节为单位，若 path 是目录则返回 0。

import osprint(os.path.getsize('E:/tmp.txt'))print(os.path.getsize('E:/work'))

os.mkdir()

创建一个目录。

import osos.mkdir('E:/test')

os.makedirs()

创建多级目录。

import osos.makedirs('E:/test1/test2')

目录 test1、test2 均不存在，此时使用 os.mkdir() 创建会报错，也就是说 os.mkdir() 创建目录时要保证末级目录之前的目录是存在的。

os.chdir(path)

将当前工作目录更改为 path。

import osprint(os.getcwd())os.chdir('/test')print(os.getcwd())

os.system(command)

调用 shell 脚本。

import osprint(os.system('ping www.baidu.com'))