python 是一门动态的强类型解释型语言

  • 动态： python的变量在使用的时候不需要指明数据类型，类型在运行中可以发生改变
  • 强类型： python的变量值类型不会自动转换，需要手动转换
  • 解释型： python代码需要解释器解释执行

python 特点

代码块

缩进敏感，通过缩进来区分代码块，同一组缩进为一个代码块

局部和全局作用域

global 关键字可以将局部作用域变量提升为全局作用域
global name

python编程风格

1
2
类名使用  首字母大写，然后驼峰风格
实例名和模块名（文件名）变量名 全部使用小写字母， 下划线_分割

模块

导入模块

import 模块名

as 别名导入

给导入的函数指定别名

from 模块名 import 函数名 as 函数别名

给导入模块指定别名

import A as B

导入模块中所有函数

from A import *

常用模块

  • copy

    • copy.copy()
    • copy.deepcopy()

  • random

    • random.int()

  • sys

    • sys.argv #包含命令行参数

python数据类型

  • 整形int
  • 浮点型float
  • 字符串类型str
  • 布尔类型
    • True 字面量值
    • False 字面量值
  • None 空类型

特殊类型操作符（跟类C语言比较）

逻辑运算符
  • and
  • or
  • not

类型转换函数

  • int()
  • float()
  • str()

类型上的操作

  • + 可以连接两个字符串
  • * 可以复制字符串，str * 3 结果是strstrstr

控制流

if

1
2
3
4
5
6
7
8
9
10
11
12
13
if expression:
	statement
	statement
	....
elif: expression:
	statement
	statement
	...
else:
	statement
	statement
	....

for

1
2
3
4
5
6
7
for i in rang(1,10):
	statement
	statement
	....
	break
	continue

while

1
2
3
4
5
6
7
while expression:
	statement
	statement
	....
	break
	continue

python函数

python函数定义

1
2
3
4
5
6
7
def name(arg1=defaultValue, arg2=defaultValue):
	statement
	statement
	return value
	
如果没有显示返回return 值， 默认 return None， None是
一个特殊值，表示空

关键字参数和位置参数

位置参数，严重依赖实参和形参对应的位置，传递顺序不对就会导致错误

关键字参数， 就是直接指定实参传递给哪个形参，对顺序没有要求

变长参数

在形参前面加上星号 *arg, arg就会成为一个变长参数，在调用这个函数时候可以传递多个实参，这些实参被放到arg中，而arg则是一个元组

而 **arg, 则是任意数量的关键字实参，arg则是一个map,调用的时候应该这样(arg1=”xxxx”,arg2=”xxx”)

1
2
3
4
def name(arg1=defaultValue, arg2=defaultValue, *args):
	statement
	statement
	return value

函数放在模块中

可以把一个函数单独放在一个文件中，在使用的文件中只需要使用import 语句就可以导入要被使用的函数

1
2
3
4
5
6
7
8
9
-------在独立的文件中定义函数--------------
A文件
def test():
    print("test")

-----在其他文件中使用test函数-----------
在B文件中 使用test函数
import A
A.test()

使用as给导入指定别名

from 模块名 import 函数名 as 函数别名

import A as B

python常用函数

  • print()
  • input()
  • len()

python的类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class Animal:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def sit(self):
        print(f"{self.name} is now sitting")

    def walk(self):
        print(f"{self.name} is walking")


# 继承Animal
class Dog(Animal):
    def __init__(self, name, age, type):
        super().__init__(name, age)
        self.type = type

    def roll_over(self):
        print(f"{self.name} is rolling over")

    # 重写父类 walk 方法
    def walk(self):
        print(f"Dog {self.name} is walking")

导入类

导入单个类

from 文件名 import 类名

从一个模块中导入多个类

from car import Car, ElectricCar

导入整个模块

import car

导入模块中的所有类（不建议）

from module_name import *

从一个模块导入到另外一个模块和别名导入跟函数导入类似

异常处理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
try:
	statement
	statement
	....
except 异常类型:
	statement
    异常才会执行的代码
	statement
	....
else:
    statement
    没有异常需要执行的代码
    statement
    ....

列表和元组

列表可变可以修改元素个数和元素值，元组不可变，字符串的操作也可以类似列表，但是不可变

定义

1
2
3
list_1 = ["lucy", "john", 1234, True, 3.234]  #列表
tuple_1 = ("lucy", "john", 1234, True, 3.234)  #元组
字符串的操作也可以类似列表，只不过字符串也是不可变的

操作

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
29
30
31
32
33
注意: 列表序号从0开始

list_1 = ["lucy", "john", 1234, True, 3.234]
list_2 = ["lucy", "john", 1234, True, 3.234]
list_1[0]
list_1[-1] # 倒数第一个元素
total_list = list_1 + list_2 # 列表合并
total_list = list_1 * 3   # 列表复制
slice_list = list_1[1:3] #列表切片，从序号1 到3 不包括3
slice_list = list_1[:2] #从序号0 到2
len(list_1) #取其长度

del list_1[0] #删除列表中的元素，后面元素向前移动

#列表用于循环
for e in list_1:
    print(e)
    
in 和 not in 操作符 
"lucy" in list_1  #"lucy"这个元素在list_1中吗

列表解构赋值
str1, str2, str3, str4, str5 = list_1

#列表中的方法
list_1.index("test")
list_1.append("test")
list_1.insert(1, "test")
list_1.remove("test")
list_1.pop() #删除尾部
list_1.pop(0) #指定索引位置删除
list_1.sort() #会修改列表
list_1.sorted() #不会修改列表

转换函数

  • list()
  • tuple()

字典

定义

1
2
lucy = {'name': "lucy", "age": 10, "address": "china"}

操作

1
2
3
4
5
6
7
8
9
10
11
in或者 not in 判断是否存在key
in 判断key 在不在 map 中
lucy = {'name': "lucy", "age": 10, "address": "china"}

"name" in lucy

# get 根据键取值，可以设置默认值
lucy.get("dog", "doggy")

#setdefault(), 为某个键设置值，当这个键没有值的时候
lucy.setdefault("dog", "doggy")

方法

  • 这三个方法将会返回类似列表的值，元素分别对应map的key,value,key-value

    • keys()

    • values()

    • items()

  • get()

  • setdefault()

字符串操作

定义字符串

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
"hello world"
'hello world'
r'hello world\n'  #在字符串定义前面加上r,使其成为原始字符串，即忽略字符转义
f"{表达式}"  #f串，可以通过{}插值

# 多行字符串

'''
dear lucy
	Eve's cat has been arrested for catnapping, cat burglary, and extortion.
Sincerely,
Bob
'''

# 多行注释

"""
comment line1
comment line2
comment line3
"""

操作

1
2
3
1. 下标 见列表
2. 切片 见列表
3. in not in 判断 "str" in "strstr" 判断A串是否在B串中

方法

  • 返回新的字符串

    • upper()
    • lower()

  • removeprefix()

    • str.removeprefix(‘https://‘)

  • isXX()

    • islower()
    • isupper()
    • isalpha()
    • isalnum()
    • isdecimal() #如果字符串只包含数字字符，并且非空
    • isspace() # 如果字符串只包含空格、制表符和换行，并且非空
    • istitle()

  • startswith()

  • endswith()

  • join()

    • ', '.join(['cats', 'rats', 'bats']) # cats, rats, bats

  • split()

    • 'My name is Simon'.split() # [‘My’, ‘name’, ‘is’, ‘Simon’]
    • 'MyABCnameABCisABCSimon'.split('ABC') #[‘My’, ‘name’, ‘is’, ‘Simon’]

  • 对齐文本

    • 字符串方法返回调用它们的字符串的填充版本，通过插入空格来
      对齐文本。这两个方法的第一个参数是一个整数长度，用于对齐字符串
    • rjust()
      • 'Hello'.rjust(10) # ‘ Hello’
      • 'Hello'.rjust(20, '*') #’***************Hello’
    • ljust()
    • center()

  • 用 strip()、rstrip()和 lstrip()删除空白字符

    • ' Hello World '.strip() # ‘Hello World’

pyperclip 模块拷贝粘贴字符串

1
2
3
4
import pyperclip
pyperclip.copy('Hello world!')  #把“hello world” 放到剪贴板
pyperclip.paste() #从剪贴板取字符串

正则表达式

在python中使用正则步骤

  • 用 import re 导入正则表达式模块
  • 用 re.compile()函数创建一个 Regex 对象（记得使用原始字符串 r””）
    • Regex对象包含的方法
    • sub(“替换字符串”, “被搜索的字符串”)
  • re.IGNORECASE 作为re.complile的第二个参数值，表示忽略大小写
  • 向 Regex 对象的 search()方法传入想查找的字符串。它返回一个 Match 对象
  • 调用 Match 对象的 group()方法，返回实际匹配文本的字符串
  • 调用 Match 对象的 groups()方法，获得一个元组，元组中元素是每个正则分组的匹配
  • Regex对象也有一个findall()方法,search返回一个Match对象，包含被查找字符串中的“第一次”匹配的文本，而findall则是所有
    • 如果调用在一个没有分组的正则表达式上，findall()将返回一个匹配字符串的列表
    • 如果调用在一个有分组的正则表达式上，方法 findall()将返回一个字符串的元组的列表（每个分组对应一个字符串），例如[(‘415’, ‘555’, ‘1122’), (‘212’, ‘555’, ‘0000’)]

贪心和非贪心匹配

Python 的正则表达式默认是“贪心”的 ， 用问号？ 可以声明贪心或者非贪心

r'(Ha){3,5}' 贪心， 尽可能多的匹配Ha

r'(Ha){3,5}?' 懒惰，尽可能少的匹配Ha

请注意，问号在正则表达式中可能有两种含义：声明非贪心匹配或表示可选的分组。这两种含义是完全无关的

正则表达式在线测试网站

读写文件

处理文件和目录相关方法

  • os.path.join() 方法可以方便的处理路径分隔符
    • 如果将单个文件和路径上的文件夹名称的字符串传递给它，os.path.join()就会返回一个文件路径的字符串，包含正确的路径分隔符
  • os.getcwd() #获得当前工作路径
  • os.chdir() #改变当前工作路径
  • os.makedirs() #创建目录
  • 调用 os.path.abspath(path)将返回参数的绝对路径的字符串。这是将相对路径转换为绝对路径的简便方法
  • 调用 os.path.isabs(path) #判断绝对或者相对路径
  • 调用 os.path.relpath(path, start)将返回从 start 路径到 path 的相对路径的字符串。如果没有提供 start，就使用当前工作目录作为开始路径
  • os.path.basename(path) #文件所在的文件名
  • os.path.dirname(path) #文件所在的目录名
  • os.path.split(calcFilePath) #返回文件路径元组 (‘C:\Windows\System32’, ‘calc.exe’)
  • os.path.getsize(path)将返回 path 参数中文件的字节数
  • 调用 os.listdir(path)将返回文件名字符串的列表
  • os.path.exists(path)
  • os.path.isfile(path)
  • os.path.isdir(path)

开始读写文件

  1. 调用 open()函数，返回一个 File 对象
  2. 调用 File 对象的 read()或 write()方法
  3. 调用 File 对象的 close()方法，关闭该文件
读取文件内容
  • File对象方法
    • readlines()
写入文件内容

要想写入文件，open()函数时候，要注意打开文件模式，不要以只读模式打开

  • File对象方法
    • write()

pathlib 模块

使用pathlib模块读写文件

1
2
3
4
5
path1 = pathlib.Path("pi.txt") #Path可以使用相对或者绝对路径，路径不管什么平台使用/分割就可以
#然后可以调用path1实例上的方法，读写文件或者创建文件
path1.write_text("hello world")
content = path1.read_text(encoding="utf-8")
....

操作文件

shutil 模块

  • 复制文件和文件夹
    • shutil.copy(source, destination)，将路径 source 处的文件复制到路径 destination处的文件夹（source 和 destination 都是字符串）
    • shutil.copy()将复制一个文件，shutil.copytree()将复制整个文件夹
  • 文件和文件夹的移动与改名
  • shutil.move(source, destination)
  • 永久删除文件和文件夹
  • 利用 os 模块中的函数，可以删除一个文件或一个空文件夹。但利用 shutil 模块，可以删除一个文件夹及其所有的内容
    • 用 os.unlink(path)将删除 path 处的文件
    • 调用 os.rmdir(path)将删除 path 处的文件夹。该文件夹必须为空，其中没有任何文件和文件夹
    • 调用 shutil.rmtree(path)将删除 path 处的文件夹，它包含的所有文件和文件夹都会被删除

send2trash 模块安全地删除

利用 send2trash，比 Python 常规的删除函数要安全得多，因为它会将文件夹和文件发送到计算机的垃圾箱或回收站，而不是永久删除它们

遍历目录树

os.walk()函数被传入一个字符串值，即一个文件夹的路径

os.walk()在循环的每次迭代中，返回 3 个值：

  1. 当前文件夹名称的字符串。
  2. 当前文件夹中子文件夹的字符串的列表。
  3. 当前文件夹中文件的字符串的列表

用 zipfile 模块压缩文件

zipfile 模块

JSON处理

json模块用来处理json

1
2
3
name_list = ["lucy", "john", "lily"]
name_json = json.dumps(name_list) # list to json string
original_list = json.loads(name_json) #json string to list

安装第三方模块

除了 Python 自带的标准库，其他开发者写了一些自己的模
块，进一步扩展了 Python 的功能。安装第三方模块的主要方法是使用 Python 的 pip 工具

  • pip 工具的可执行文件在 Windows 上称为 pip
    • Windows 上，pip 位于 C:\Python34\Scripts\pip.exe
  • 在 OS X 和 Linux 上称为 pip3
    • OS X
      • 位于/Library/Frameworks/Python.framework/Versions/3.4/bin/pip3
    • Linux
      • 位于/usr/bin/pip3
      • 在Linux上需要单独安装

安装第三方模块

pip install send2trash or pip3 install send2trash

运行程序

所有 Python 程序的第一行应该是#!行,它告诉计算机你想让 Python 来执行这个程序。该行以#!开始，但剩下的内容取决于操作系统

  • 在 Windows 上，第一行是 #! python3
  • 在 OS X，第一行是 #! /usr/bin/env python3
  • 在 Linux 上，第一行是 #! /usr/bin/python3

在 Windows 上运行 Python 程序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
在 Windows 上，Python3.4 的解释程序位于 C:\Python34\python.exe或者，方
便的 py.exe 程序将读取.py 文件源代码顶部的#!行，并针对该脚本运行相应的 Python
版本。如果计算机上安装了多个版本的 Python，py.exe 程序确保运行正确版本的Python 程序

为了方便运行你的 Python 程序，可以创建一个.BAT 批处理文件，用 py.exe 来
运行 Python 程序。要创建一个批处理文件，就创建一个新的文本文件，包含一行内
容，类似下面这样：

@py.exe C:\path\to\your\pythonScript.py %*

用你自己的程序的绝对路径替换该路径，将这个文件以.bat 文件扩展名保存（例
如，pythonScript.bat）。这个处理文件将使你不必在每次运行时，都输入 Python 程序完
整的绝对路径。我建议将所有的批处理文件和.py 文件放在一个文件夹中，如
C:\MyPythonScripts 或 C:\Users\YourName\PythonScripts

在 Windows 上，C:\MyPythonScripts 文件夹应该添加到系统路径中，这样就可以从
Run 对话框中运行其中的批处理文件。要做到这一点，请修改 PATH 环境变量

OS x 和 Linux上运行python程序

1
在OS X 和 Linux上运行python程序，只需要给.py 文件执行权限，然后在命令行上以绝对或者相对路径执行即可

参考书籍

Python编程 从入门到实践

Python编程快速上手 让繁琐工作自动化

Python极客项目编程