Python笔记

PART 1 基本定义

变量

• 定义：用来储存值的元素
• 命名时只能包括字母、数字、下划线
• 变量对应的值以最近一次更新为主

变量类型

使用type(变量)函数查询类型

- 非数字型

1. 字符串 str

• 一系列字符，用引号括起来，是编程语言中表示文本的数据类型

• 用+号拼接字符串，如果有数字，需要对数字使用str()函数
  //格式化输出
  通过使用 格式化操作符% 来实现信息的整体输出
  1）% 和不同的 字符 连用构成不同类型的格式化操作符，%起一个占位的作用，常见类型如下：
  %s → 字符串
  %d → 十进制整数
  //（%06d表示表示输出的整数显示位数，不足的地方使用 0 补全）
  //（%16d表示d左边会有空白，数字表示长度，但好像不是16个空格）
  //（%-6d 是左对齐，这个测试出来也看不出来？）
  %f → 浮点数，%.2f 表示小数点后只显示两位
  %% → 输出 %
  注意：如果不知道使用什么占位符接收变量，可以都用 %s

  2）语法：
  print("XX格式化字符串XX" % 变量1)
  print("XX格式化字符串XX" % (变量1, 变量2...))

• 字符串的格式修改：
  1）修改大小写
  变量.title() → 首字母大写
  变量.upper() → 全部大写
  变量.lower() → 全部小写
  2）增加空白行
  ‘\t字符串' →缩进（制表符）
  '\n字符串' → 换行
  那条杠别搞反了，而且是在字符串内部使用

  3. 删除空白
     变量.strip() → 删除两端空白
     变量.rstip() → 删除尾部/右边空白
     变量.lstrip() → 删除头部/左边空白

• 字符串的判断
  1）字符串.isalpha()：如果 string 至少有一个字符并且所有字符都是字母则返回 True
  2）字符串.isdecimal()：如果 string 只包含数字则返回 True
  3）字符串.string.islower()：如果 string 至少有一个字符并且所有字符都是小写字母则返回 True
  4）字符串.isupper()：如果 string 至少有一个字符并且所有字符都是大写字母则返回 True
  5）字符串.startswith(str)：检查字符串是否是以 str 开头，是则返回 True
  6）字符串.endswith(str)：检查字符串是否是以 str 结束，是则返回 True

• 字符串的查找和替换
  1）字符串.find(str, x, y)：检查str是否包含在字符串[x,y)范围内，如果是返回出现的的第一索引值，否则返回-1，其中x,y表示索引值，y<=len(字符串)
  2）字符串.rfind(str, x,y)：类似于 find()，不过是从右边开始查找
  3）字符串.index(str, x, y)：跟 find() 方法类似，不过如果 str 不在 string 会报错
  4）字符串.rindex(str, x, y)：类似于 index()，不过是从右边开始
  5）字符串.replace(old_str, new_str, num)：把 string 中的 old_str 替换成 new_str，如果 num 指定，则替换不超过 num 次，num<=字符串.count(old_str)

• 字符串的拆分和连接
  1）字符串.partition(str,num)：返回元组，把字符串 string 分成3个元素的元组 (str前面, str, str后面)
  2）字符串.rpartition(str)：类似于 partition() 方法，不过是从右边开始查找
  3）字符串.split(str, num)：返回列表，以 str 为分隔符拆分 string，如果str为空，则以空格为分隔符拆分·
  · 如果 num 有指定值，则仅分隔 num + 1 个子字符串
  · num不写默认为str重复出现的次数
  · str 默认包含 '\r', '\t', '\n' 和空格
  · 如果连续两个str，则显示元素 ‘’

a='1233436'
b = a.split('3')
print(b)

b = a.split('3',1)
print(b)

b = a.split('3',2)
print(b)

输出：
['12', '', '4', '6']
['12', '3436']
['12', '', '436']

4）字符串.splitlines()：返回列表，按照行('\r', '\n', '\r\n')分隔
5）字符串1+字符串2：拼接两个字符串
6）字符串.join(seq)：返回字符串，以 字符串作为分隔符，将 seq 中所有的元素（的字符串表示）合并为一个新的字符串

a='1233436'
b = a.join('abc')
print(b)

b = a.join('ab')
print(b)

#输出：
a1233436b1233436c
a1233436b

• 字符串的文本对齐
  1）字符串.ljust(width)：返回新字符串，基于原字符串左对齐，并使用空格填充至长度 width

a = 'hello'
b = 'he'
print(a.ljust(10)+'x'+'\n'+b.ljust(10)+'y')

#输出：
hello     x
he        y

2）字符串.rjust(width)：返回新字符串，基于原字符串右对齐，并使用空格填充至长度 width
3）字符串.center(width) ：返回新字符串，基于原字符串居中，并使用空格填充至长度 width

- 数字型

1. 整数 int、浮点数 float

• 算数运算符：+ 、 - 、*、/、
  **（乘方）
  // （返回除法的整数部分（商） 9 // 2 输出结果 4）
  %（返回除法的余数 9 % 2 = 1）
  *还可以作用于字符串，表示重复实现次数

2. 布尔 bool

• 真 True 数学运算时表示 1
• 假 False 数学运算时表示 0

列表

由一系列按照特定顺序排列的元素组成，用 [ ] 来表示，并用 , 来分隔其中的元素。
//索引，元素在列表的位置，从0开始，-1表示倒数第一个

1. 操作
· 查询
1）根据位置查询元素：变量 = 列表名[索引]
2）根据元素查询位置：列表名.index(值)
如果查询元素有多个相同值只会返回第一个值出现的记录
3）查询值出现的次数：列表名.count(值)

· 修改元素
列表名[索引] = 新值

· 增加元素
1）在末尾增加元素： 列表名.append(值)
2）在列表中插入元素：列表名.insert(索引，值)
3）在列表中插入另一个表的元素：列表1.exten(列表2)

· 删除元素
1）del 列表名[索引]
2）列表名.pop(索引)，若不写索引，则默认从末尾删除
可用变量来接收被删的元素，变量 = 列表名.pop(X)
3）列表名.remove(值)，只删除出现的第一个值，如有多个，结合while循环语句
4）清空列表：列表.clear

· 列表永久排序：列表名.sort()，默认按照字母顺序，若指定相反顺序，可使用列表名.sort(reverse=Ture)
· 列表非永久排序：sorted(列表名)，若指定相反顺序，sorted(列表名,reverse=True)
· 倒着输出：列表名.reverse()
· 确定列表长度：len(列表名)

2.切片
列表的部分元素称之为切片，切片 = 列表[X:Y:步长]，// X、Y为索引位置，左闭右开，步长不写默认为1
· 没有指定X，默认从头开始；没有指定Y，默认到尾结束。列表[ : ] 表示整个列表，故复制表 = 原表[ : ]
· 负数索引返回离列表相应距离的元素，-1表示倒数第一个
· 列表[::-1] 表示逆序输出
· 支持字符串、列表、元组

元组 tuple

不能修改的列表，用（）括起来
· 元组只具有查询功能，操作同列表
· 元组不可修改，但元组内的元素是列表、字典，则可通过修改列表、字典来实现修改元组
· 元组中 只包含一个元素 时，需要 在元素后面添加逗号，不加就不是元组了
元组名 = (a，)
· 组包，赋值的右侧有多个数据时，会自动组包成元组，如果赋值的左侧接收的变量和右侧的变量的个数一致，就会自动解包，一一对应赋值

(a,b)=(x,y)
c = (x,y)
print (a)
print (b)
print (c)

//输出：
x
y
(x,y)

· 元组和列表之间的转换
1）元组 → 列表：list(元组)
2）列表 → 元组：tuple(列表)

字典

储存多对元素，是一系列键-值对，键和值之间用冒号隔开，而键-值对之间用逗号分隔，整体用{}括起来

1.操作
· 查询
字典[键]，如果不存在会报错
字典.get(key,默认值)，如果不存在，返回None 默认值

· 添加
字典[新键] = 新值
字典.setdefault(key,value)：如果key存在，不修改，如果key不存在，新增
字典1.update(字典2)：将字典2的数据合并到字典1 ，如果键值对存在就修改，不存在就增加

· 修改
字典[键] = 新值

· 删除
del 字典[键]
字典.pop(key)，key不存在会报错
字典.popitem()，随机删除一个键值对
字典.clear()，清空

· 遍历
1）遍历键-值对

for X,Y in 字典.items():
      执行语句

2）遍历键

for X in 字典.keys():
      执行语句

· keys()返回的其实是一个列表
· 按顺序遍历字典中的所有键

for X in 字典.sorted(keys()):
      执行语句

2.嵌套

3）遍历值

for X in 字典.values():
      执行语句

PART 2 函数

- 内置函数

1.print()
· 在默认情况下，print 函数输出内容之后，会自动在内容末尾增加换行
· 如果不希望末尾增加换行，可以在 print 函数输出内容的后面增加 , end=""
· 其中 "" 中间可以指定 print 函数输出内容之后，继续希望显示的内容

2.input() 输入函数

• 获取用户输入的函数，并将信息转化成字符串类型，如果输入数字，需使用类型转换函数进行转换
• 类型转换函数：
  1）int(X) → 将X转换成一个整数 //不能转换浮点数形式的字符串
  2）float(X) → 将X转换成一个浮点数

3.range()
生产范围内的系列数字
· range(X,Y,步长），左闭右开 X <= <Y；步长不写，默认为1
· 与list()函数嵌套使用可生成数字列表：list(range(X,步长,Y))
· 与for循环一起使用，可生成表达式列表

列表名 = []
for a in range(X,Y):
        b = 针对a的表达式
        列表名.append(b)
print(列表名）

// 列表解析/列表推导式
·基本for循环操作

列表名 = [ 表达式 for a in range(X,Y)]

· 在循环的过程中使用if

列表名 = [ 表达式 for a in range(X,Y) if a的判断式]

· 两个for

列表名 = [ (a的表达式，b的表达式) for a in range(X1,Y1)  b in range(X2,Y2) ]

- 自定义函数

函数是带名字的代码块，用于完成具体的工作，主要是为了在开发程序时，使用函数可以提高编写的效率以及代码的重用

• 语法

def 函数名(
        形参1，形参2，形参2，
        形参3，形参4):
    ```注释定义函数```
      执行语句

#调用定义函数
函数名()

// 编写指南
1）应给函数指定性描述名称，且只在其中使用小写字母和下划线
2）每个函数都应该包含其功能注释，并紧跟在函数定义后面，用文档字符串格式
3）如果形参很多，可在函数定义中输入左括号后按回车键，并在下一行按两次Tab键，从而将形参列表和只缩进一层的函数体区分开

• 形参与实参
  · 形参，定义函数的变量，是给真实数据占位用的；实参，调用函数的变量，是传递到 函数内部 的 真实数据；形参、实参一一对应
  // def 函数名(形参):
  // 函数名(实参)

· 实参类型
1）位置实参：实参根据形参的顺序一一输入
2）关键词实参：传递给函数的形参名字-值对，无需考虑定义函数里的形参顺序

3）默认值：在定义函数中，给予形参默认值，如果调用函数时，没有指定对应实参，则使用默认值；默认值只能存在于形参列表末尾
def 函数名(形参1，形参2=默认值)：
// 调用函数
函数名(实参1) 表示 形参1=实参1，形参2=默认值
函数名(实参1，实参2)表示 形参1=实参1，形参2=实参2
调用函数时，未指定默认值的形参，可以采用位置实参、关键词实参调用

4）传递任意数量的实参
def 函数名(形参1，*形参2) // *形参需放在形参列表末尾，类似创建了一个空元组（形参2 = [ 形参2-1，形参2-2 ]）
// 调用函数
函数名(实参1，实参2-1，实参2-2)

5）传递任意数量的关键词实参
def 函数名(形参1，**形参2) // **形参类似创建了一个空字典（形参2 = { '形参2-1' : 待指定,'形参2-2' : '待指定' }
// 调用函数
函数名(实参1，形参2-1=实参2-1，形参2-2=实参2-2)

• 局部变量和全局变量
  · 局部变量，函数内部定义的变量，目的是临时保存数据，仅影响函数内部
  · 全局变量，函数外边定义的变量，能在所有函数里进行访问
  · 函数内修改全局变量，使用global进行声明

a =1
print(a)

def f():
    global a
    a=2
    print(a)

f()
print(a)

#输出：
1
2
2

• 函数除了可返回print输出外，还可通过return返回值

def 函数名():
      执行代码
      变量名 = 返回值表达式
      return 变量名

#调用函数
接收值的变量 = 函数名()
print(接收值的变量)

· 当return后没跟值/变量名时，调用函数后，接收值的变量输出为 None

· return 表示返回，后续的代码都不会被执行

· 一个函数中可以有多个return语句，但是只要有一个return语句被执行，那么这个函数就会结束

· return 可返回多个值，当返回多个数据时，python会自动将数据 组包 成元组；如果使用多个变量接收返回值，python会自动将元组 拆包 成单个数据

def f():
      return 1,2,3

a = f()
print(a)

(a,b,c) = f()
print(a)
print(b)
print(c)

#输出：
(1, 2, 3)
1
2
3

• 匿名函数：省略了用def声明函数的标准步骤的函数定义
  语法：
  1）采用函数名来接受函数定义
  // 定义函数
  函数名 = lambda 参数1，参数2 ：表达式
  // 调用函数
  函数名(实参1，实参2)
  2）函数定义后直接调用，无函数名
  (lambda 参数1，参数2 ：表达式)(实参1，实参2)

用处：
作为函数的参数
// 示例：通过关键词的字典列表里的排序

stus = [
    {"name": "zhangsan", "age": 18}, 
    {"name": "lisi", "age": 19}, 
    {"name": "wangwu", "age": 17}
]
stus.sort(key = lambda x: x['name'])
print(stus)

#输出：
[{'age': 19, 'name': 'lisi'}, {'age': 17, 'name': 'wangwu'}, {'age': 18, 'name': 'zhangsan'}]

// 示例：自己定义函数

def fun(a, b, opt):
     print("a = %s" % a)
     print("b = %s" % b)
     print("result =%s" % opt(a, b)

# 调用函数
fun(1, 2, lambda x,y:x+y)

#输出：
a = 1 
b = 2 
result = 3

- 模块

储存函数等的文件，通过import导入到主程序

• 语法
  1）import 模块名 as 模块别名👉 导入整个模块，如果要使用模块里的函数，则需要限定模块名，如 模块名.函数名() 或者 模块别名.函数名()
  2）from 模块名 import 函数名 as 函数别名 👉 导入模块中的指定函数，使用时无需限定模块名，直接使用函数名/函数别名，如 函数名() 或者 函数别名()
  3）from 模块名 import * 👉 导入模块里所有函数，使用时无需限定模块名
  // 并不建议采用，因为可能会跟主程序里其它函数名重复

PART 3 Python 语句

for 循环 语句

遍历列表中的元素，并执行相同代码
· 语法

for 变量 in 列表：
      执行语句

1）for 变量 in 列表后要加冒号，下一行要缩进，所有循环执行语句都需要缩进

if 语句

进行条件判断的语句，每条if语句的核心都是一个值为 Ture 或 False 的表达式，Python根据值来决定是否执行相应代码

• 常见检查条件
  1）是否相等 ==
  2）不考虑大小写时的是否相等 通过大小写转换函数来比较
  3）是否不相等 ！=
  4）比较数字
  5）比较多个条件：and、or
  6）是否包含在特定列表中：in
  7）是否不包含在特定列表中：not in

• 语法
  1）if/else/elif + 判断式 后跟冒号，下一行要缩进
  2）else 表示不满足上面条件时，需要执行的代码，但一般会省略，因为包罗万象，可能会产生很多恶意数据
  3）elif 在不止两个条件时使用，可使用多个elif，通常if、elif后的条件都互斥
  4）if后直接接列表名：，则表示，如果列表不为空，判断为Ture，为空，判断为False
  5）if将数字型数据直接作为判断条件时，非0数即为True, 0为False

6. 布尔表达式，定义布尔型变量，然后直接跟在if后加冒号判断

test = True
if test:
  执行语句

while 语句

满足特定条件时，不断循环指定代码，直至条件不被满足时
· 语法

赋值变量
while 判断式：
        执行代码

1）while + 判断式 后跟冒号，下一行要缩进
2）判断式里的变量要先赋值，如果没有，可为空字符串‘’，这样才便于第一次循环开启
3）当无明确判断式时，可建立标志，用于判断程序是否进行

标志名 = Ture
while 标志名：
      执行代码
      if 判断式：
              标志名 = False
      else：
              执行代码

4）while + break，在while循环里，满足某个条件就跳出循环，结束
5）while + Ture，可直接运行，但要确保退出机制，比如增加 break
6）while + continue，在while循环里，满足某个条件就忽略余下代码，并返回到循坏开头
需要注意：使用 continue 时，条件处理部分的代码，需要特别注意，不小心会出现 死循环

7）避免无线循环，当while判断式是基于变量时，执行代码后需要重新赋值该变量
// 赋值运算符：+= → a += b 等于 a = a+b；-= 、=、/=、//=、%=、*=同理

· 作用 p110
1）在列表之间移动元素
2）删除包含特定值的所有列表元素
3）使用用户输入来填充字典

PART 4 文件与异常

- 文件

• 文件的打开与关闭
  1）语法1：

变量 = open(文件名，访问模式)
执行语句
变量.close()

· open 和 close 必须同时出现，最好写完open就写close
· 缺陷，如果程序存在bug，导致close()语句未执行，文件将不会关闭，可能会导致错误

2）语法2：

with open(文件名，访问模式) as 变量名：
    执行语句

· 无需写close语句，让python负责妥善地打开和关闭文件

• 文件访问模式
  ~ r 👉 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式
  ~ w 👉 打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件
  ~ a 👉 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入
  ~ r+ 👉 打开一个文件用于读写。文件指针将会放在文件的开头
  ~ w+ 👉 打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件
  ~ a+ 👉 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写
  ~ rb 👉 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式
  ~ wb 👉 以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件
  ~ ab 👉 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入
  ~ rb+ 👉 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头
  ~ wb+ 👉 以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件
  ~ ab+ 👉 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写

• 文件的写入 'w'

with open(文件名,'w') as 变量名：
    变量名.write('字符串1\n')
    变量名.write('字符串2\n')

# 文件打开出现：
字符串1
字符串2

· write()语句后要加冒号，下一行要缩进
· write()不会在写入的文本末尾添加换行符，所以需要手动增加 \n

• 附加到文件 'a'

with open(文件名,'a') as 变量名：
    变量名.write('字符串1\n')

# 文件打开出现：
这里是文件原内容
字符串1

• 文件的读取 'r'

1. 整个读取

with open(文件名,'r') as 变量名：
    变量名2 = 变量名.read()
    print(变量名2)

· read(num)，num表示要从文件中读取的数据的长度（单位是字节），如果没有传入num，那么就表示读取文件中所有的数据
· 如果使用读了多次，那么后面读取的数据是从上次读完后的位置开始的

# test.txt 内容为 'hello world, i am here!'

with open(test.txt) as t:
        a = t.read(5)
        print(a)

        b = t.read()
        print(b)

# 输出：
hello
 world, i am here!

2）逐行读取

with open(文件名,'r') as 变量名：
    for line in 变量名:
    print(line)

3）readlines()按照行的方式把整个文件中的内容进行一次性读取，并且返回的是一个列表，其中每一行的数据为一个元素

with open(文件名,'r') as 变量名：
        a = 变量名.readlines()
    
for line in a:
    print(line)

4）readline()每次只阅读一行，如果多次使用，那么后面读取的数据是从上次读完后的位置开始的

• 文件的定位读写
  1）获取当前读写的位置：文件名/变量名.tell()

2）定位到某个位置：文件名/变量名.seek(偏移量,方向)，
· 0:表示文件开头
·1:表示当前位置
·2:表示文件末尾
// 只有方向为0时，才设置偏移量

• 文件和文件夹的操作
  导入os模块可进行重命名、删除等一些操作
  import os
  1）重命名

import os
os.rname('原文件名','新文件名')

2）删除

import os
os.remove('文件名')

3）创建文件夹

import os
os.mkdir('文件夹名')

4）获取当前目录

import os
os.getcwd()

5）改变默认目录

import os
os.chdir("test")  # 跳转到当前路径的test子目录中

6）获取目录列表

import os
os.listdir()

7）删除文件夹

import os
os.rmdir("张三")

· 目录非空不能使用，可以使用递归的方式进行删除