Python-基础篇

0 前言

Python-pip指令

Python-字符编码

Python-XML库

Python-openpyxl库

---

1 第一个程序

# -*- coding: UTF-8 -*-

'''
多行注释
创建员工类
'''
class Employee:
# 单行注释，员工类
    empCount = 0
    def __init__(self, name, salary):
        self.name = name
        self.salary = salary
        Employee.empCount += 1

    def displayCount(self):
        print("Total Employee " Employee.empCount)
    
    def displayEmployee(self):
        print("Name : ", self.name,  "Salary: ", self.salary)
 
employee1 = Employee('xiaoming', 2000)
salary = employee1.salary

1.1 Python语言规范

在Python中不遵守编译器的规定，编译器在编译时就会报错，这个规定叫作规则。

1. 默认情况下，Python 3 源码文件以 UTF-8 编码，所有字符串都是 unicode 字符串。当然你也可以为源码文件指定不同的编码。

# -*- coding: UTF-8 -*-

2. Python中单行注释以 # 开头，多行注释用'''注释'''或者"""注释"""。

3. python最具特色的就是使用缩进来表示代码块，不需要使用大括号{} 。缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数。

4. Python 通常是一行写完一条语句，但如果语句很长，我们可以使用反斜杠\来实现多行语句，例如：

total = item_one + \
        item_two + \
        item_three

5. 在 [],{}, 或() 中的多行语句，不需要使用反斜杠\，例如：

total = ['item_one', 'item_two', 'item_three',
        'item_four', 'item_five']

---

2 Python是一门面向对象的语言

2.1 面向对象，类和方法

面向对象是将数据和操作数据相关的方法封装到对象中，组织代码和数据的方式更加接近人的思维：

class MyClass(FatherClass)             # 创建MyClass类，父类为FatherClass
    self.my_attribute = value          # MyClass具有属性my_attribute
    def __init__(self)                 # 创建MyClass时执行初始化操作
        super().__init__()             # 继承FatherClass的初始化操作
        # code                         # MyClass新增的初始化操作

    def myMethod(self)                 # MyClass的方法
        # code

面向对象三大特征：封装（私有），继承，多态。
在Python中，一切内容都是对象，一切函数都是对象的方法。

2.2 查看类的属性与方法

2.2.1 查看内置库的属性与方法

对于Python内置库的标准类，Python提供了查看类信息的方法。在CMD的Python编辑状态或者Pycharm软件的Python Console中可使用。

1. dir()查看类的方法和属性

dir(str)

得到以下结果：

['__add__',
 '__class__',
 '__contains__',
 '__delattr__',
 '__dir__',
 '__doc__',
 '__eq__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__getitem__',
 '__getnewargs__',
 '__gt__',
 '__hash__',
 '__init__',
 '__init_subclass__',
 '__iter__',
 '__le__',
 '__len__',
 '__lt__',
 '__mod__',
 '__mul__',
 '__ne__',
 '__new__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__rmod__',
 '__rmul__',
 '__setattr__',
 '__sizeof__',
 '__str__',
 '__subclasshook__',
 'capitalize',
 'casefold',
 'center',
 'count',
 'encode',
 'endswith',
 'expandtabs',
 'find',
 'format',
 'format_map',
 'index',
 'isalnum',
 'isalpha',
 'isascii',
 'isdecimal',
 'isdigit',
 'isidentifier',
 'islower',
 'isnumeric',
 'isprintable',
 'isspace',
 'istitle',
 'isupper',
 'join',
 'ljust',
 'lower',
 'lstrip',
 'maketrans',
 'partition',
 'replace',
 'rfind',
 'rindex',
 'rjust',
 'rpartition',
 'rsplit',
 'rstrip',
 'split',
 'splitlines',
 'startswith',
 'strip',
 'swapcase',
 'title',
 'translate',
 'upper',
 'zfill']

以上是字符串str类所具有的全部方法，对字符串可以进行的全部操作都由上面的方法定义。

比如dir(str)这个函数的效果就是由__dir__方法定义的。

比如str1 + str2这个操作符的效果就是由 __add__方法定义的。

2. help()可以查看类和类方法的说明文档

help(str)        # 查看str类说明和所有方法说明
help(str.__len__)    # 查看方法str.__len__的说明

注意，所有方法都可以采用 类实例名.方法名() 的方式调用，比如：

str.__len__()
str.upper()

但是，len()并不是str类 的方法，而是 __len__ 方法中定义的函数表达式，所以

len(str)   # 正确
str.len()  # 错误

前后双下划线的__方法名__是系统定义的特殊方法，通常对应特殊的语法，运算符和函数。

2.2.2 查看第三方库的属性与方法

对于自己安装的第三方库，无法使用 dir()和 help()查看信息，可以在CMD 控制台和Pycharm软件的Terminal中输入指令：

python -m pydoc -p 1234

浏览器会打开help目录，你所有安装过的第三方库api都可以查看，当然内置标准库也早在这里也可以看到。

2.3 部分方法说明

对于MyClass类，创建类实例 x，如果类具有以下属性，则x从类中获得相应的方法：

x = MyClass()

方法	说明	所写代码
__doc__	类型帮助信息	help(x)
__init__	创建类实例时初始化	x = MyClass()
__str__	类的文本形式	print(x)
__dir__	列出所有属性和方法	dir(x)
__len__	序列的长度	len(x)
__contains__	了解某序列是否包含特定的值	a in x
__eq__	相等	x == y
__ne__	不相等	x != y
__lt__	小于	x < y
__le__	小于或等于	x <= y
__gt__	大于	x > y
__ge__	大于或等于	x >= y
__bool__	布尔上上下文环境中的真值	if x:
__enter__	内存访问资源	open()
__exit__	内存清除资源	close()
__new__	类构造器	x = MyClass()
__del__	类析构器	del x
__add__	加法运算发	x + y
__call__	回调	x()
__getattribute_	属性调用	x.属性

---

3 Python数据类型

3.1 数字Number

3.1.1 创建数字

1. python中数字有四种类型：整数、布尔型、浮点数和复数。

2. Python中定义数字没有字节数限制，无需做int,char等声明，可直接赋值。

3. Python用True/False表示布尔值。

a = 3452
b = True
c = 3E-2
d = 1+2j

4. Python支持链式赋值

x = y = 100

5. Python支持数值交换

x,y = y,x

3.1.2 数字运算符

运算符	说明
+	加
-	减
*	乘
**	幂方
/	除
//	整除
%	求余

3.2 字符串String

3.2.1 字符串方法列表

String类	说明
=self[start:end:step]	字符串的切片只能读取，不能赋值
=self.index(str)	返回子串首位在字符串中的下标 没有则报ValueError
=self.find(str)	返回子串首位在字符串中的下标 没有则返回-1
=self.count(str)	返回字串在字符串中出现次数
=self.replace(str1, str2)	将str1换成str2，返回字符串 找不到str1则返回原字符串
=self.split(tr)	以子串分隔字符串，默认为空格。返回字符串列表
=self.partition(str)	字符串分割为sub前，sub和sub后，默认为空格。返回字符串元组
=self.join(list)	使用字符串连接列表中的字符串。返回字符串 list->字符串列表
=self.capitalize()	全句第一个字符大写
=self.title()	单词第一个字符大写
=self.upper()	全部字符大写
=self.lower()	全部字符小写
=self.swapcase()	全部字符大小写对换
=self.strip(str)	去除字符串首尾的子串，默认为空格
=self.lstrip(str)	去除字符串左边的子串，默认为空格
=self.rstrip(str)	去除字符串右边的子串，默认为空格
=self.center(n, str)	居中对齐，用子串将字符串填充到n位
=self.ljust(n, str)	向左对齐，用子串将字符串填充到n位
=self.rjust(n, str)	向右对齐，用子串将字符串填充到n位
=len(self)	字符串元素数量

3.2.2 创建字符串

1. Python没有单字符，只有字符串，单引号和双引号等效

x1 = ''  # 空字符串
x2 = 'abc'
x3 = str(123)

2. 三个单引号或者双引号创建多行字符串

a = '''
x
y
z
'''

3.2.3 转义字符

转义字符	说明
\'	单引号‘
\"	双引号“
\\	反斜杠\
\n	换行
\(在行尾)	续行符
\t	TAB键

在print()时，默认在字符串后加上换行符\n，可用end=''取消或者修改

print('sxt1', end='连接')
print('sxt2')
print('sxt3')

结果

sxt1连接sxt2
sxt3

3.2.4 字符串加法和乘法

x = 'a' + 'b'  # x = 'ab'
y = 'ab' * 3   # y = 'ababab'
x = x + 'c'    # x = 'abc'

3.2.5 字符串切片 slice

对字符串x= 'abcde' 的每一个字符有两种定位方式:

字符串	a	b	c	d	e
正序定位	0	1	2	3	4
逆序定位	-5	-4	-3	-2	-1

使用[start:end:step]选择区域，step默认为1，记住包头不包尾（包括start，不包括end）

x = 'abcde'
x = x[1]     # 'b'
x = x[-4]    # 'b'
x = x[:]     # 'abcde'
x = x[2:]    # 'cde'
x = x[:2]    # 'ab'
x = x[:-2]   # 'abc'
x = x[-2:]   # 'de'
x = x[2:4]   # 'cd'
x = x[0:4:2] # 'ac'
x = x[::-1]  # 'edcba'

3.2.6 字符串代替 replace

x = 'abcde'
x = x.replace('c','高')

结果：

x = 'ab高de'

3.2.7 字符串分割 split partition

x = 'ab cde'
x1 = x.split() #默认以空格分隔
x1 = x.split('c')
x2 = x.partition()
x2 = x.partition('c')

结果为：

x1 = ['ab', 'cde']
x1 = ['ab ', 'de']
x2 = ('ab', ' ', 'cde')
x2 = ('ab ', 'c', 'de')

3.2.8 字符串连接 join

x = '*'.join(['good','man'])
y = ''.join(['good','man'])

结果为：

x = 'good*man'
y = 'goodman'

3.2.9 字符串查找 find count

x.find('*') # '*'第一次出现位置
x.count('*') # '*'出现次数

3.2.10 字符串格式化 format

x = '我叫{0}，年龄{1}'.format('小明',18)
y = '我叫{name}，年龄{age}'.format(name = '小明', age = 18)

结果为：

x = '我叫小明，年龄18'
y = '我叫小明，年龄18'

3.2.11 字符串排版

字符串的所有排版，都不改变原变量，要有新变量接收

1. 大小写转换

x = ‘I love you, I LOVE YOU’
# 句首字母大写
y1 = x.capitalize() # y1='I love you, i love you'
# 词首字母大写
y2 = x.title()     # y2='I Love You, I Love You'
# 全大写
y3 = x.upper()     # y3='I LOVE YOU, I LOVE YOU'
# 全小写
y4 = x.lower()     # y4='i love you, i love you'
# 大小写对换
y5 = x.swapcase()  # y5='i LOVE YOU, i love you'

2. 去除收尾信息

x = '*I*love*you*'
y1= x.strip('*')   # y1='I*love*you'
y2= x.lstrip('*')  # y2='I*love*you*'
y3= x.rstrip('*')  # y3='*I*love*you'

3. 填充首尾信息

x = 'Love'
y1= x.center(10, '*')  # y1='***Love***'
y2= x.ljust(10, '*')   # y2='Love******'
y3= x.rjust(10, '*')   # y3='******Love'

3.3 列表List

3.3.1 列表的方法列表

List类	说明
=self[start:end:step] self[start:end:step]=	列表的切片的可以读取或赋值
=self.index(elem)	返回元素在列表中的下标，没有则报ValueError
=self.count(elem)	返回元素在字符串中出现次数
self.append(elem)	向列表末尾追加单个元素
self.extend(list)	向列表末尾追加列表
self.clear()	清空列表
self.insert(index, elem)	在指定位置插入元素
self.remove(elem)	删除第一次出现的元素
self.pop([index])	弹出指定下标的元素，缺省时弹出最后一个
self.reverse()	列表的反转，改变原列表的先后顺序
self.sort(reverse = False)	将列表中的元素进行排序 默认按升序排列
=len(self)	列表元素数量
=max(self)	列表最大元素
=min(self)	列表最小元素
=sum(self)	列表元素和

3.3.2 创建列表

x1 = []  # 空列表
x2 = list()
x3 = [10, 20, 'abc', True]
x4 = list('abcde')
x5 = list(range(10))
x6 = [range(10)]

结果为：

x1 = []
x2 = []
x3 = [10, 20, 'abc', True]
x4 = ['a', 'b', 'c', 'd', 'e']
x5 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
x6 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

3.3.3 列表解包

接受解包的变量数必须和列表元素数量相同

x = [10, 20, 30]
a, b, c = x
print a, b, c  # 10, 20 ,30

3.3.4 列表切片

x = [0, 1, 2, 3, 4]
x = x[1:4]
print(x)  # x=[1, 2, 3]

3.3.5 列表加法

列表+运算两端必须都是列表

x = [0]
x = x + [1]
print(x)  # [0, 1]

3.3.6 增加列表元素操作 append extend insert

1. append在末尾添加元素，对列表的修改直接反映在原数据上，没有返回值

x = [10, 20]
y = x.append('*') # 元素添加到x尾部

结果为：

x = [10, 20, '*']
y = None

2. extend在末尾添加另一个列表中的所有元素，对列表的修改直接反映在原数据上，没有返回值

x = [10, 20]
b = [30, 40]
x.extend(b)   # x=[10, 20, 30, 40]

3. insert在指定位置添加元素，对列表的修改直接反映在原数据上，没有返回值

x = [10, 20, 30]
x.insert(2, 25)     # 在index=2处插入值25, x=[10, 20, 25, 30]

3.3.7 删除列表元素操作 remove pop clear

列表删除都是在原变量直接修改，不需要新变量接收结果

x = [10, 20, 30]
x.remove(20)       # 删除x中首个元素20
print('x1 = ', x)

x = [10, 20, 30]
x.pop(1)    #删除 index=1 处的元素，可用列表多选
print('x2 = ', x)

x.clear()     #删除所有元素，变为空列表
print('x3 = ', x)

结果如下：

x1 = [10, 30]
x2 = [10, 30]
x3 = []

3.3.8 列表元素访问 index count len

x = [10, 20 ,30]
y1 = x.index(20)     #返回第一个元素20的index
y2 = x.count(20)     #返回元素20的个数
y3 = len(x)          #返回x的长度
y4 = max(x)          #返回最大元素
y5 = min(x)          #返回最小元素
y6 = sum(x)          #返回元素和

3.3.9 列表排列 sort reverse [::-1]

升序/降序

x = [20, 10, 30, 40]
x.sort()
print('x1 = ', x)
x.sort(reverse=True)
print('x2 = ', x)
x = [20, 10, 30, 40]
x3 = x[::-1]
print('x3 = ', x3)

结果如下：

x1 = [10, 20, 30, 40]
x2 = [40, 30, 20, 10]
x3 = [40, 30, 10, 20]

3.4 元组Tuple

元组是不可变序列，列表是可变序列
元组不能修改、增加、删除

3.4.1 元组的方法列表

Tuple类	说明
=self[start:end:step]	元组的切片只能读取
=self.index(elem)	返回元素在元组中的下标 没有则报ValueError
=self.count(elem)	返回元素在字符串中出现次数
=len(self)	元组元素数量
=max(self)	元组最大元素
=min(self)	元组最小元素
=sum(self)	元组元素和
del self	删除元组

3.4.1 创建元组

x = (10, 20, 30) 
x = 10, 20, 30
x = (10,)      #只有一个元素的元组要加逗号
x = tuple([10])

3.4.2 元组的切片

元组的访问操作和列表相同
元组不能增加、删除、排序元素，但是可以切片slice

x = (0, 1, 2, 3, 4)
x = x[1:4]
print(x)  # x=(1, 2, 3)

元组的切片不能赋值

x = (0, 1, 2, 3, 4)
x[1] = 5  # 错误

3.5 集合Set

集合是无序列表，元素不可重复
集合元素没有index，没有切片

3.5.1 集合的方法列表

Set类	说明
self.add(elem)	添加一个元素
self.update(set)	合并一个集合
self.remove(elem)	删除一个元素

3.5.2 创建集合

x = set() #空集合
x = {
     10, 20, 30}
x = set([10, 20, 30])

注意，空集合是x=set()，空字典是x={}

3.5.3 操作集合元素 add remove

x = {
     10, 20, 30}
x.add(40)
x.remove(20)

3.5.4 集合的交并差集

集合操作符	说明
x | y	并集
x & y	交集
x - y	差集

3.6 字典Dictionary

字典是键（key）值（value）成对的无序可变序列，其中键不可重复不可变，值可重复可变

3.6.1 字典的方法列表

Dictionary类	说明
=self[key] self[key]=	按键读取或写入对应的值
=self.get(key) self.get(key)=	按键读取或写入对应的值
self.pop(key)	删除指定键值对
self.clear()	清空字典
self.update(dict)	合并一个字典，同键的值覆盖
=self.keys()	返回所有键组成的列表
=self.values()	返回所有值组成的列表
=self.items()	返回(键,值)元组组成的列表

3.6.2 创建字典

以下创建方式等效：

x = {
     }  #空字典
x = {
     'key1':10, 'key2':20, 'key3':30}
x = dict(key1 = 10, key2 = 20, key3 = 30)
x = dict([('key1', 10), ('key2', 20), ('key3', 30)])
x = dict(zip(['key1', 'key2', 'key3'], [10, 20, 30]))

3.6.3 访问字典 get keys values

x = {
     'key1':10, 'key2':20, 'key3':30}
x.get('key1') = 10
x.get('key4', '不存在')    # 输出‘不存在’
y = [x.keys()]        # y = ['key1', 'key2', 'key3']
y = [x.values()]      # y = [10, 20, 30]

3.6.4 修改字典 update pop clear

x = {
     'key1':10, 'key2':20, 'key3':30}
x['key1'] = 15    # 修改
x.update({
     'key4': 40})   # 添加或覆盖
x.pop('key2')     # 删除
clear(x)          # 清除

3.6.5 字典解包 items keys values

x = {
     'key1':10, 'key2':20, 'key3':30}
a1,a2,a3 = x.items()     # 键值对解包
b1,b2,b3 = x.keys()      # 键解包
c1,c2,c3 = x.values()    # 值解包

结果：

a1 = ('key1', 10)
a2 = ('key2', 20)
a3 = ('key3', 30
b1 = 'key1'
b2 = 'key2'
b3 = 'key3'
c1 = 10
c2 = 20
c3 = 30

---

4 迭代器与关键字 in

4.1 迭代器和生成器

在Python中，能够使用in关键字提取成分的是迭代器（Iterable）。

5 in range(10)     # True

迭代器包括两类，一类是集合数据类型，如list、tuple、dict、set、str等；一类是生成器（generator）。

生成器记录列表的生成规律，但不创建和保存完整的列表，从而节省大量的空间。

range()是最简单的生成器：

g = range(10)
g = range(0, 10, 2)

生成器不能用下标g[0]表达，但是能用for...in 语句迭代。通过迭代能在range()基础上生成更复杂的生成器

g = (x * x for x in range(10))
for n in g:
    print(n)

生成器可使用 if筛选

g = (x * x for x in range(10) if x % 2 == 0)

生成器可以两层迭代

g = (m+n for m in 'ABC' for n in '123')

4.2 列表生成式

生成器可以随时转为列表

1. 对已有的生成器，使用list()方法：

g = list(range(10))

2. 生成生成器过程中，将最外（）换成[ ]可直接得到列表：

g = [x for x in range(10)]

4.3 打包 zip

zip()将多个迭代器的相同位置元素组成元组，形成新的列表用于迭代。

与两层迭代对比：

x = [a+b for a in 'ABC' for b in '123']   # 两层迭代
y = [a+b for a, b in zip('ABC', '123')]   # 打包迭代

结果为：

x = ['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3']
y = ['A1', 'B2', 'C3']

4.4 枚举 enumerate

enumerate()函数将可遍历的数据对象(如列表、元组或字符串)的下标和元素对应打包

for index, value in enumerate('ABC'):
    print index, value
    

结果为：

0 A
1 B
2 C

5 上下文管理语句

5.1 open 语句

文件平时放在电脑的硬盘中，而CPU只能读写内存中的数据。所以电脑处理文件需要分为3步：

1. 将硬盘中的文件复制进内存，并设置文件指针，对应__enter__方法
2. 移动指针，将内存中文件数据转为字符串，或将字符串传入文件数据
3. 使用完毕后清除内存中文件数据，对应__exit__方法。如果允许写入，则同时修改硬盘数据

注意项：

1. 硬盘中的文件数据只能复制到内存中，或者被内存中数据覆盖，不能修改
2. 内存中的文件数据是_io.TextIOWrapper格式，只能使用文件指针进行操作，对应read()和write()方法
3. read()可以将内存中文件数据转换成字符串赋值给变量

f = open('/tmp/simple.txt', 'r', encoding='utf-8', errors='ignore') # f是_io.TextIOWrapper格式
data = f.read()               # 将_io.TextIOWrapper格式转为字符串赋值给data
f.close()                     # 清除_io.TextIOWrapper格式数据，释放内存

Python内置函数open()用于打开文件或创建文件对象

f = open(file_name, mode, encoding, errors)

• file_name：文件名或文件地址
• mode：指定文件的打开模式

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

• encoding：编码格式，通常'utf-8'
• f：文件指针，有以下方法
  • f.read(n)：读取n个字节，n缺省时把文件读完，文件指针会随着读取移动
  • f.close()：关闭文件
  • f.write(s)：在文件指针处写入字符串

5.2 with open语句

open()语句之后一定要有close()，否则内存会一直被占用。Python提供了上下文管理器with，程序在退出with语句块时自动调用close()。

即使with语句中发生错误导致程序中断，程序依然会调用close()保护内存。

with open('/tmp/simple.txt', 'r', encoding='utf-8', errors='ignore') as f:
    data = f.read()

5.2.1 数据有效范围

with open('textsimple.txt', 'w+', encoding='utf-8', errors='ignore') as f:
    f.write('[新建text内容]')

with open('textsimple.txt', 'r', encoding='utf-8', errors='ignore') as f:
    data1 = f.read()   # data1在with语句外有效，f在with语句外无效

with open('textsimple.txt', 'r', encoding='utf-8', errors='ignore') as f:
data2 = f.read()  # 在with语句外已经无法再读取，data2错误

5.2.2 文件指针位置

1. read()和write()的同时会移动指针

with open('textsimple.txt', 'w+', encoding='utf-8', errors='ignore') as f:
    f.write('[新建text内容，内容需要写的比较长]')

with open('textsimple.txt', 'r', encoding='utf-8', errors='ignore') as f:
    data1 = f.read()
    data2 = f.read()

print(data1)   # data1能读出数据
print(data2)   # data2时指针已在末尾，数据为空

2. r+方式从头写入，覆盖原数据，会导致乱码

with open('textsimple.txt', 'w+', encoding='utf-8', errors='ignore') as f:
    f.write('[新建text内容，内容需要写的比较长]')

with open('textsimple.txt', 'r+', encoding='utf-8', errors='ignore') as f:
    f.write('[r+]方式写入的内容')
    

3) w+方式会先清空原数据

with open('textsimple.txt', 'w+', encoding='utf-8', errors='ignore') as f:
    f.write('[新建text内容，内容需要写的比较长]')

with open('textsimple.txt', 'w+', encoding='utf-8', errors='ignore') as f:
    f.write('[w+]方式写入的内容')
    

4) a+方式在原数据后面补充

with open('textsimple.txt', 'w+', encoding='utf-8', errors='ignore') as f:
    f.write('[新建text内容，内容需要写的比较长]')

with open('textsimple.txt', 'a+', encoding='utf-8', errors='ignore') as f:
    f.write('[a+]方式写入的内容')
    

6 常用函数

6.1 isinstance()

Python中的 isinstance() 函数，是Python中的一个内置函数，用来判断一个函数是否是一个已知的类型，类似 type()

• isinstance() 会认为子类是一种父类类型，考虑继承关系
• type() 不会认为子类是一种父类类型，不考虑继承关系

isinstance('a', str)  # True

6.2 eval()

eval(str)作用是将字符串转换成表达式，并且执行

x = input()
print(eval(x))
# 在命令行输入1+2，并按回车，输出3

6.3 匿名函数 lambda

用于写简短的处理语句，配合下面其他函数使用

lambda x:f(x)
lambda x,y:f(x,y)

6.4 sorted()

sorted()函数可以对任何可迭代对象进行排序，并返回列表

# 对列表升序操作
a = sorted([1,9,7,3,5,4,6])
print(a)
# 输出：[1, 3, 4, 5, 6, 7, 9]

# 对元组倒序操作
a = sorted((1,9,8,7,3,4), reverse=True)
print(a)
# 输出：[9, 8, 7, 4, 3, 1]

# 使用参数key，根据自定义，按字符串长度来排序：
a = ['dog', 'monkey', 'bird', 'elephant']
b = sorted(a, key=lambda x:len(x))
print(b)
# 输出：['dog', 'bird', 'monkey', 'elephant']

# 先按照第二个元素再按照第一个元素排序
 a=[[12, 34],[23, 56],[47, 12],[23, 90]]
>>> b=sorted(a, key=lambda x:(x[1],x[0]))

6.5 reversed()

reversed()函数接受一个序列，将序列里的元素反转，并最终返回迭代器

a = reversed('good morning')
print(list(a))
# 输出：['g', 'n', 'i', 'n', 'r', 'o', 'm', ' ', 'd', 'o', 'o', 'g']

6.6 map()

map()函数会把序列里的每一个元素用指定的方法加工一遍，最终返回给你加工好的序列

a = ['dog', 'monkey', 'bird', 'elephant']
b = map(lambda x:x.upper(), a)
print(list(b))
# 输出：['DOG', 'MONKEY', 'BIRD', 'ELEPHANT'

6.7 reduce()

educe()会对参数序列中元素进行累积。第一、第二个元素先进行函数操作，生成的结果再和第三个元素进行函数操作，以此类推，最终生成所有元素累积运算的结果

from functools import reduce
a = [1,2,3,4,5,6]
b = reduce(lambda x,y:x*y, a)
print(b)
# 输出：720

6.8 filter()

filter()函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器

a = ['dog', 'cat', 'monkey', 'elephant', 'donkey', 'duck']
b = filter(lambda x:'o' in x, a)
print(list(b))
# 输出：['dog', 'monkey', 'donkey']