python基础学习笔记

1、python注释

# 单行注释
"""
多行注释
多行注释
python，一行代码结束可以加分号，也可以不加分号
"""

2、标识符

开头字符必须是字母或下划线 _ 。
标识符的其他的部分由字母、数字和下划线组成。
标识符对大小写敏感。

3、python书写规范

python最具特色的就是使用缩进来表示代码块。如果不按照规定写，将会报错

4、python关键字

False      class      finally    is         return

None       continue   for        lambda     try

True       def        from       nonlocal   while

and        del        global     not        with 

as         elif       if         or         yield

assert     else       import     pass

break      except     in         raise

跟java等语言一样，在python中有33个关键字，注意在python中，False、None和True的首字母大写，其他关键字全部小写。

5、python的数据类型

python有6种主要的内置数据类型：数字、字符串、列表、元组、集合、字典

python中有4种数字类型：整数类型、浮点类型、复数类型、布尔类型

0b二进制（零b或B）
0o八进制（零o或O）
0x十六进制（零x或X）

5.1、int、float、string

#整数类型（int）（两种写法均可）
counter = 100 # 赋值整型变量
counter = int(100)# 赋值整型变量

#浮点型（Float）（两种写法均可）
miles = 1000.0 # 赋值浮点型变量
miles = float(100)# 赋值浮点型变量

#字符串型（str）（两种写法均可）
name = '100' # 赋值字符串型变量（单引号双引号效果一样）
name = "100" # 赋值字符串型变量（单引号双引号效果一样）
name = str(100)# 赋值字符串型变量
#注意双引号优先级大于单引号
name = "'中国'+'中华'"

5.2、布尔类型

布尔型数据只有两个取值：True和False，分别对应整型的1和0。

比较运算：
等于 == 不等于 ！=
小于等于 <= 大于等于>=
大于 > 小于 <

逻辑运算：
与运算 and 一假则假
或运算 or 一真则真
非运算 not 取反，真为假，假为真

短路问题

5.3、算数运算

print(10+2)#12
print(10-2)#8

print(10*2)#20
print(10*-2)#-20

print(10/2)#5.0
print(10/-2)#-5.0

#取余（取除完的余数）
print(10%2)#0

#幂
print(10**1)#10
print(10**2)#100 （10**2=10*10）
print(10**3)#1000 （10**3=10*10*10）
print(5**2)#25

#地板除法（能整除就整除，不行则不取余数）
print(10//1)#10
print(10//2)#5
print(10//3)#3
print(10//4)#2
print(10//5)#2

5.4、位运算符

先将10进制 转换成 2进制然后在进行运算，运算完成后，在将2进制转换成10进制

位异或（只有两位相反时才为1，否则为0）

5.5、赋值运算符

5.6、运算优先级

不确定优先级的时候，就多打（）

6、导入模块

在 python 用 import 或者 from…import 来导入相应的模块。

将整个模块(somemodule)导入，格式为： import somemodule

从某个模块中导入某个函数,格式为： from somemodule import somefunction

从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc

将某个模块中的全部函数导入，格式为： from somemodule import *

将某个模块改名(改为s)，格式为：import somemodule as s
as s 是取别名的意思

7、条件判断语句if

注意写的时候要注意缩进格式。

# 实例1
a=0
b=1
if a>b: 
    print(a,">",b)


# 实例 2
a=1
b=0
if a>b: 
    print(a,">",b)
else: 
    print(a,"<",b)


# 实例 3
num = 5 
if num == 3:# 判断num的值 
    print 'boss' 
elif num == 2:
    print 'user'
elif num == 1:
    print 'worker'
elif num < 0: # 值小于零时输出
    print 'error' 
else: 
    print 'roadman' # 条件均不成立时输出

8、While 循环语句

count = 0 
while (count < 9): 
    print( 'The count is:', count)
    count = count + 1
print("Good bye!")

#运行结果
#The count is: 0
#The count is: 1
#The count is: 2
#The count is: 3
#The count is: 4
#The count is: 5
#The count is: 6
#The count is: 7
#The count is: 8
#Good bye!

8.1、While 循环语句 else

while … else 在循环条件为 false 时执行 else 语句块：

count = 0 
while count < 5:
    print(count, " is less than 5") 
    count = count + 1 
else:
    print(count, " is not less than 5")

#运行结果
#0  is less than 5
#1  is less than 5
#2  is less than 5
#3  is less than 5
#4  is less than 5
#5  is not less than 5

9、for循环语句

for循环可以遍历任何序列的项目，如一个列表或者一个字符串。

# 实例 3
for letter in 'Python': # 第一个实例 
    print("当前字母: %s" % letter)
    
fruits = ['banana', 'apple', 'mango']
for fruit in fruits: # 第二个实例 
    print('当前水果: %s'% fruit)
    
print("Good bye!")

#运行结果
当前字母: P
当前字母: y
当前字母: t
当前字母: h
当前字母: o
当前字母: n
当前水果: banana
当前水果: apple
当前水果: mango
Good bye!

9.1、for 循环语句 else

for 中的语句和普通的没有区别，else 中的语句会在循环正常执行完

for num in range(10,20): # 迭代 10 到 20 之间的数字 
    print('for',num) 
else: # 循环的 else 部分 
    print('else',num)

#运行结果
for 10
for 11
for 12
for 13
for 14
for 15
for 16
for 17
for 18
for 19
else 19

9.2、for 循环语句 else + break

break结束后，for循环和else都不会执行了

for num in range(10,20): # 迭代 10 到 20 之间的数字
    if (num==15):
        break 
    print('for',num) 
else: # 循环的 else 部分 
    print('else',num)
    
#运行结果
for 10
for 11
for 12
for 13
for 14

9.3、for 循环语句 else + continue

continue：跳过本次循环，进入下一次循环。

for num in range(10,20): # 迭代 10 到 20 之间的数字
    if (num==15):
        continue  
    print('for',num) 
else: # 循环的 else 部分 
    print('else',num)

#运行结果
for 10
for 11
for 12
for 13
for 14
for 16
for 17
for 18
for 19
else 19

9.4、 pass 语句

pass 是空语句，是为了保持程序结构的完整性。
pass 不做任何事情，一般用做占位语句。

for letter in 'Python':
    if letter == 'h':
        pass 
        print('这是 pass 块')
    print('当前字母 :', letter) 
print("Good bye!")

#代码运行结果
当前字母 : P
当前字母 : y
当前字母 : t
这是 pass 块
当前字母 : h
当前字母 : o
当前字母 : n
Good bye!

10、Python 循环嵌套

在一个循环体里面嵌入另一个循环。

while与while嵌套
for与for嵌套

11、Number(数字)

Python Number 数据类型用于存储数值。
数据类型是不允许改变的,这就意味着如果改变 Number 数据类型的值，将重新分配内存空间。
以下实例在变量赋值时 Number 对象将被创建：

var1 = 5
var2 = 10

#可以通过使用del语句删除单个或多个对象，例如：
del var
del var1,var2, ...... , varN

支持四种不同的数值类型：
1、整型(Int) - 通常被称为是整型或整数，是正或负整数，不带小数点。
2、长整型(long integers) - 无限大小的整数，整数最后是一个大写或小写的L。
3、浮点型(floating point real values) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）
4、复数(complex numbers) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。

#Number 类型转换
int(x [,base ])         将x转换为一个整数  
long(x [,base ])        将x转换为一个长整数  
float(x )               将x转换到一个浮点数  
complex(real [,imag ])  创建一个复数  
str(x )                 将对象 x 转换为字符串  
repr(x )                将对象 x 转换为表达式字符串  
eval(str )              用来计算在字符串中的有效Python表达式,并返回一个对象  
tuple(s )               将序列 s 转换为一个元组  
list(s )                将序列 s 转换为一个列表  
chr(x )                 将一个整数转换为一个字符  
unichr(x )              将一个整数转换为Unicode字符  
ord(x )                 将一个字符转换为它的整数值  
hex(x )                 将一个整数转换为一个十六进制字符串  
oct(x )                 将一个整数转换为一个八进制字符串  

12、列表

列表都可以进行的操作包括索引，切片，加，乘，检查成员。

创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。

List1 = ['a','b',1,2]#列表的数据项不需要具有相同的类型。

#索引
List = ['index1', 'index2', 'index3', 'index4', 'index5']
print("这是第一个索引",List[0])  
print("这是第二个索引",List[1])  
print("这是第三个索引",List[2])
print("这是倒数第一个索引",List[-1])  
print("这是倒数第二个",List[-2])  
print("这是倒数第三个",List[-3])
print('------------------------------------------')

#切片
# 实例 3
List1 = ['a','b',1,2]#列表的数据项不需要具有相同的类型。

#索引
List = ['index1', 'index2', 'index3', 'index4', 'index5']
print("这是第一个索引",List[0])  
print("这是第二个索引",List[1])  
print("这是第三个索引",List[2])
print("这是倒数第一个索引",List[-1])  
print("这是倒数第二个",List[-2])  
print("这是倒数第三个",List[-3])
print('------------------------------------------')

#切片
# 实例 3
nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]  
print(nums[1:8])

nums2 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]  
print(nums2[1:-3])
print('------------------------------------------')

#添加列表元素
List2 = ['spring', 'summer', 'fall']
List2.append('winter')
print ("更新后的列表 : ", List2)
print('------------------------------------------')

#删除列表元素
# 实例 5
List3 = ['spring', 'summer', 'fall','winter']
del List3[1]
print ("更新后的列表 : ", List3)

#代码运行结果
这是第一个索引 index1
这是第二个索引 index2
这是第三个索引 index3
这是倒数第一个索引 index5
这是倒数第二个 index4
这是倒数第三个 index3
------------------------------------------
[2, 3, 4, 5, 6, 7, 8]
[2, 3, 4, 5, 6, 7]
------------------------------------------
更新后的列表 :  ['spring', 'summer', 'fall', 'winter']
------------------------------------------
更新后的列表 :  ['spring', 'fall', 'winter']

13、元组

元组与列表类似，不同之处在于元组的元素不能修改。

元组使用小括号 ( )，列表使用方括号 [ ]。

元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

#索引（元组可以使用下标索引来访问元组中的值。）
tup1 = ('一', '二', '三', '四','五')
tup2 = (1, 2, 3, 4, 5 )

print ("tup1[0]: ", tup1[0]) 
print ("tup2[1:5]: ", tup2[1:5])#不包含1，但包含5
print("-----------------------------------------------")

#修改元组（元组中的元素值是不允许修改的，但我们可以对元组进行连接组合。）
# 实例 2
tup3 = (12, 34.56)
tup4 = ('abc', 'xyz') 
#tup3[0] = 100 # 元组元素是不可修改的。
# 创建一个新的元组将两个元组组合
tup5 = tup3 + tup4 
print (tup5)
print("-----------------------------------------------")

#删除元组（元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组。）
tup = ('一', '二', '三', '四','五')
print (tup)
del tup 
print ("删除后的元组 tup : ") 
#print (tup)#会报错 name 'tup' is not defined
print("-----------------------------------------------")

#与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。
print(len((tup1,tup2,tup3)))#计算元素个数
print((1, 2, 3) + (4, 5, 6))#连接
print(('Hi!',) * 4)#复制
print(3 in (1, 2, 3))#元素是否存在
for x in (1, 2, 3): print (x, end=" ")#迭代（就是循环打印）
print("-----------------------------------------------")

#元组索引，截取
# 实例 4
tup11 = ('1', '2', '3', '4','5')
print(tup11[1])
print(tup11[-1])
print(tup11[1:-2])
print("-----------------------------------------------")

#元组内置函数
print(len(tup11))#计算元组元素个数。
print(max(tup11))#返回元组中元素最大值。
print(min(tup11))#返回元组中元素最小值。
print(tuple(tup11))#打印全部元组

#代码运行结果
tup1[0]:  一
tup2[1:5]:  (2, 3, 4, 5)
-----------------------------------------------
(12, 34.56, 'abc', 'xyz')
-----------------------------------------------
('一', '二', '三', '四', '五')
删除后的元组 tup : 
-----------------------------------------------
3
(1, 2, 3, 4, 5, 6)
('Hi!', 'Hi!', 'Hi!', 'Hi!')
True
1 2 3 -----------------------------------------------
2
5
('2', '3')
-----------------------------------------------
5
5
1
('1', '2', '3', '4', '5')

14、集合

集合（set）是一个无序的不重复元素序列。

#可以使用大括号 { } 或者 set() 函数创建集合。
#注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

# set()集合函数（是一个无序的不重复元素序列。）
a = set('abcccd')
print(a)#可以看出输出结果不是固定的，是个无序的不重复元素序列。
b = set('ab')
c = a-b 
print(c)#可以看出输出结果不是固定的，是个无序的不重复元素序列。
print("----------------------------------------------")

#添加元素
#add()函数，将元素添加到集合中，如果元素已存在，则不进行任何操作。
#update()函数，添加元素，且参数可以是列表，元组，字典等。
fruit = set(("apple", "orange", "pear"))
fruit.add("banana")
print(fruit)
fruit.update({1,2,3})
print(fruit)
print("----------------------------------------------")

#移除元素
#remove()函数，将元素从集合中移除，如果元素不存在，则会发生错误。
#discard()函数，将元素从集合中移除，且如果元素不存在，不会发生错误。
#pop()函数，将集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除。
fruit1 = set(("apple", "orange", "pear","banana"))
fruit1.remove("apple")
print(fruit1)
fruit1.discard("banana")
print(fruit1)
fruit1.pop()
print(fruit1)
print("----------------------------------------------")

#计算集合元素个数
#len()函数，计算集合元素个数。
fruit2 = set(("apple", "orange", "pear","banana"))
print(len(fruit2))
print("----------------------------------------------")

#清空集合
#clear()函数，清空集合。
fruit3 = set(("apple", "orange", "pear","banana"))
fruit3.clear()
print(fruit3)
print("----------------------------------------------")

#判断元素是否在集合中存在
#in,判断元素是否在集合中，存在返回 True，不存在返回 False。
fruit4 = set(("apple", "orange", "pear","banana"))
print("apple" in fruit4)
print("peach" in fruit4)
print("----------------------------------------------")

#拷贝一个集合
#copy()函数可以拷贝一个集合
fruit5 = set(("apple", "orange", "pear","banana"))
fruit6=fruit5.copy()
print(fruit5)
print(fruit6)


#集合内置方法完整列表
#[add()]	为集合添加元素
#[clear()]	移除集合中的所有元素
#[copy()]	拷贝一个集合
#[difference()]	返回多个集合的差集
#[difference_update()]	移除集合中的元素，该元素在指定的集合也存在。
#[discard()]	删除集合中指定的元素
#[intersection()]	返回集合的交集
#[intersection_update()]	返回集合的交集。
#[isdisjoint()]	判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
#[issubset()]	判断指定集合是否为该方法参数集合的子集。
#[issuperset()]	判断该方法的参数集合是否为指定集合的子集
#[pop()]	随机移除元素
#[remove()]	移除指定元素
#[symmetric_difference()]	返回两个集合中不重复的元素集合。
#[symmetric_difference_update()]symmetric_difference_update.html)	移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
#[union()]	返回两个集合的并集
#[update()]	给集合添加元素


#代码运行结果
{'c', 'b', 'a', 'd'}
{'c', 'd'}
----------------------------------------------
{'apple', 'pear', 'orange', 'banana'}
{'apple', 'pear', 1, 2, 'orange', 3, 'banana'}
----------------------------------------------
{'pear', 'orange', 'banana'}
{'pear', 'orange'}
{'orange'}
----------------------------------------------
4
----------------------------------------------
set()
----------------------------------------------
True
False
----------------------------------------------
{'apple', 'pear', 'orange', 'banana'}
{'apple', 'pear', 'orange', 'banana'}

15、字典

字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号( , )分割，整个字典包括在花括号 {} 中 。
dict 作为 Python 的关键字和内置函数，变量名不建议命名为 dict。
键必须是唯一的，但值则不必。
值可以取任何数据类型，但键必须是不可变的，如字符串，数字。

15.1、字典键的特性

字典值可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。
两个重要的点需要记住：
不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住。
键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行。

#字典的创建
tinydict = {'name': 'zhangsan', 'grade': 1, 'url': 'www.baidu.com'}
print(tinydict)
print("------------------------------------------")

#使用大括号 { } 创建空字典。
emptyDict = {'name': 'zhangsan', 'grade': 1, 'url': 'www.baidu.com'}     
print(emptyDict)# 打印字典       
print("Length:", len(emptyDict))# 查看字典的数量      
print(type(emptyDict))# 查看类型
print("------------------------------------------")

#使用内建函数 dict()
emptyDict = dict(a='a', b='b', t='t')
emptyDict1=dict(zip(['one', 'two', 'three'], [1, 2, 3]))# 映射函数方式来构造字典
emptyDict2=dict([('one', 1), ('two', 2), ('three', 3)])# 可迭代对象方式来构造字
print(emptyDict)# 打印字典
print(emptyDict1)# 打印字典
print(emptyDict2)# 打印字典   
print("Length:",len(emptyDict))# 查看字典的数量    
print(type(emptyDict))# 查看类型  
print("------------------------------------------")

#访问字典里的值
# 实例 4
tinydict = {'Name': 'zhangsan', 'Age': 7, 'Class': 'First'}
print("tinydict['Name']: ", tinydict['Name'])
print("tinydict['Age']: ", tinydict['Age'])
#如果用字典里没有的键访问数据，会输出错误。
print("------------------------------------------")

#修改字典
tinydict1 = {'Name': 'zhangsan', 'Age': 7, 'Class': 'First'}
tinydict1['Age'] = 8 # 更新 Age 
tinydict1['School'] = "X大学" # 添加信息
print(tinydict1)
print("tinydict1['Age']: ", tinydict1['Age'])
print("tinydict1['School']: ", tinydict1['School'])
print("------------------------------------------")

#删除字典元素
# 实例 7
aa = {'Name': 'zhangsan', 'Age': 7, 'Class': 'First'}
del aa['Name'] # 删除键 'Name' 
aa.clear() # 清空字典 
del aa # 删除字典
#print("tinydict2['Age']: ", aa['Age'])#name 'tinydict2' is not defined
#print("tinydict2['School']: ", aa['School'])#name 'tinydict2' is not defined
print("------------------------------------------")

#Python字典包含了以下内置方法：
print(len(tinydict1))#len(dict) 计算字典元素个数，即键的总数。
print(str(tinydict1))#str(dict) 输出字典，可以打印的字符串表示。
print(type(tinydict1)) #返回输入的变量类型，如果变量是字典就返回字典类型。

#1	[dict.clear()] 删除字典内所有元素
#2	[dict.copy()] 返回一个字典的浅复制
#3	[dict.fromkeys()]创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
#4	[dict.get(key, default=None)] 返回指定键的值，如果键不在字典中返回 default 设置的默认值
#5	[key in dict] 如果键在字典dict里返回true，否则返回false
#6	[dict.items()] 以列表返回一个视图对象
#7	[dict.keys()]返回一个视图对象
#8	[dict.setdefault(key, default=None)] 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
#9	[dict.update(dict2)]把字典dict2的键/值对更新到dict里
#10	[dict.values()] 返回一个视图对象
#11	[pop(key[,default])]l) 删除字典 key（键）所对应的值，返回被删除的值。
#12	[popitem()] 返回并删除字典中的最后一对键和值。

#代码运行结果
{'name': 'zhangsan', 'grade': 1, 'url': 'www.baidu.com'}
------------------------------------------
{'name': 'zhangsan', 'grade': 1, 'url': 'www.baidu.com'}
Length: 3
<class 'dict'>
------------------------------------------
{'a': 'a', 'b': 'b', 't': 't'}
{'one': 1, 'two': 2, 'three': 3}
{'one': 1, 'two': 2, 'three': 3}
Length: 3
<class 'dict'>
------------------------------------------
tinydict['Name']:  zhangsan
tinydict['Age']:  7
------------------------------------------
{'Name': 'zhangsan', 'Age': 8, 'Class': 'First', 'School': 'X大学'}
tinydict1['Age']:  8
tinydict1['School']:  X大学
------------------------------------------
------------------------------------------
4
{'Name': 'zhangsan', 'Age': 8, 'Class': 'First', 'School': 'X大学'}
<class 'dict'>

16、字符串

字符串有三种表示方式：普通字符串、原始字符串和长字符串。
***普通字符串：***用单引号（'）或双引号（＂）括起来的字符串。
***原始字符串：***原始字符串中的特殊字符不需要被转义，按照字符串本来的样子呈现。

print(r'hello\nwored')#原始字符串
print(r"hello\nwored")#原始字符串
#代码运行结果
#hello\nwored
#hello\nwored

***长字符串：***如果使用字符串表示一篇文章，其中包含了换行、缩进等排版字符，则可以使用长字符串表示。对于长字符串，要使用三个单引号（‘’'）或三个双引号（＂＂＂）括起来。

s='''一二三四五六七八九十
一二三四五六七八九十
一二三四五六七八九十
一二三四五六七八九十
'''
a="""一二三四五六七八九十
一二三四五六七八九十
一二三四五六七八九十
一二三四五六七八九十
"""
print(s)
print(a)
#代码运行结果
一二三四五六七八九十
一二三四五六七八九十
一二三四五六七八九十
一二三四五六七八九十

一二三四五六七八九十
一二三四五六七八九十
一二三四五六七八九十
一二三四五六七八九十

16.1、转义字符

16.2、数字与字符串相互转换

将字符串转换为数字，可以使用int（）和float（）实现，如果成功则返回数字，否则引发异常。

将数字转换为字符串，可以使用str（）函数，str（）函数可以将很多类型的数据都转换为字符串。

a=10
b='10'

print(str(a))#数字转字符串
print(int(b)+5)#字符串转数字

16.3、 使用占位符

要想将表达式的计算结果插入字符串中，则需要用到占位符。对于占位符，使用一对大括号（{}）表示。

i=32
print('i*i={}'.format(i*i))
print('{0}*{0}={1}'.format(i,i*i))#0=i,1=i*i
print('{p1}*{p1}={p2}'.format(p1=i,p2=i*i))

16.4、格式化控制符

print("今天学的是%s第%d天!" % ('Python', 12))#今天学的是Python第12天!


%c	格式化字符及其ASCII码
%s	格式化字符串
%d	格式化整数
%u	格式化无符号整型
%o	格式化无符号八进制数
%x	格式化无符号十六进制数
%X	格式化无符号十六进制数（大写）
%f	格式化浮点数字，可指定小数点后的精度
%e	用科学计数法格式化浮点数
%E	作用同%e，用科学计数法格式化浮点数
%g	%f和%e的简写
%G	%f 和 %E 的简写
%p	用十六进制数格式化变量的地址

16.5、字符串查找、替换、分割

#字符串查找
a='hello world'
print(a.find('l'))#找到了返回对应的位数值
print(a.find('k'))#没找到返回-1
print(a.find('l',2,5))#从2-5找l
print("----------------------")

#字符串替换
print(a.replace('e','t',2))
print(a.replace('h','f'))

b=a.replace('h','f')
c=a.replace('e','t',2)
print(b)
print(c)
print("----------------------")

#字符串分割
aa = "www.gziscas.com.cn"
print(aa.split('.'))#以’ . '为分隔符
print(aa.split('.',2))#以’ . '为分隔符,分割两次
print(aa.split('.',2)[1])#分割两次，并取序列为1的项

#分割两次，并把分割后的3个部分保存到3个文件
u1, u2, u3 =aa.split('.',2)
print(u1)   #输出：www
print(u2)   #输出：gziscas
print(u3)   #输出：com.cn

#代码输出结果
2
-1
2
----------------------
htllo world
fello world
fello world
htllo world
----------------------
['www', 'gziscas', 'com', 'cn']
['www', 'gziscas', 'com.cn']
gziscas
www
gziscas
com.cn
>>> 

16.6、访问字符串中的值

var1 = 'Hello!'
var2 = "World!" 
print ("var1[0]: ", var1[0]) 
print ("var2[1:5]: ", var2[1:5])

#代码运行结果
var1[0]:  H
var2[1:5]:  orld

16.7、字符串运算符

# 实例 1
a = 'Hello!'
b = "World!"

print(a+b)#字符串连接
print(a*2)#重复输出字符串
print(a[1])#通过索引获取字符串中字符
print(a[1:3])#通过索引获取字符串中字符
print('W' in b)#成员运算符 - 如果字符串中包含给定的字符返回 True
print('w' in b)#是区分大小写的
print('W' not in b)#成员运算符 - 如果字符串中不包含给定的字符返回 True
print('w' not in b)#是区分大小写的
print (r'\n')#原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。
print (R'\n')

#代码运行结果
Hello!World!
Hello!Hello!
e
el
True
False
False
True
\n
\n

17、函数

17.1、函数定义

形参：函数定义时的参数
实参：函数调用时给的参数

17.2、函数调用

17.3、可变参数和不可变参数

在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。

不可变类型： 变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。
可变类型： 变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

17.3.1、python 函数的参数传递：

不可变类型： 类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。
可变类型： 类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响。

#python 传不可变对象实例
def func(a):
   a = 10
   
b = 2
func(b)
print(b)

实例中有 int 对象 2，指向它的变量是 b，在传递给 ChangeInt 函数时，按传值的方式复制了变量 b，a 和 b 都指向了同一个 Int 对象，在 a=10 时，则新生成一个 int 值对象 10，并让 a 指向它。

#传可变对象实例
def changeme(mylist):
   "修改传入的列表"
   mylist.append([1,2,3,4])
   print ("函数内取值: ", mylist)
   return
 
# 调用changeme函数
mylist = [10,20,30]
changeme(mylist)
print ("函数外取值: ", mylist)

#代码运行结果
函数内取值:  [10, 20, 30, [1, 2, 3, 4]]
函数外取值:  [10, 20, 30, [1, 2, 3, 4]]

17.4、参数

以下是调用函数时可使用的正式参数类型：

1. 必备参数
2. 关键字参数
3. 默认参数
4. 不定长参数

17.4.1、必备参数

必备参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。调用printme()函数，你必须传入一个参数，不然会出现语法错误：

def printme( str ):
   "打印任何传入的字符串"
   print(str)
   return
 
#调用printme函数
printme()#必须写参数，否则会报错

17.4.2、关键字参数

关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。
使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。
以下实例在函数 printme() 调用时使用参数名：

def printinfo( name, age ):
   "打印任何传入的字符串"
   print ("Name: ", name)
   print ("Age ", age)
   return
 
#调用printinfo函数
printinfo( age=50, name="miki" )

#代码结果
Name:  miki
Age  50

17.4.3、默认参数

调用函数时，默认参数的值如果没有传入，则被认为是默认值。下例会打印默认的age，如果age没有被传入：

def printinfo( name, age = 35 ):
   "打印任何传入的字符串"
   print ("Name: ", name)
   print ("Age ", age)
   return
 
#调用printinfo函数
printinfo( age=50, name="miki" )
print("-------------------------")
printinfo( name="miki" )

#代码运行结果
Name:  miki
Age  50
-------------------------
Name:  miki
Age  35

17.4.4、不定长参数

你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述2种参数不同，声明时不会命名。基本语法如下：

def printinfo( arg1, *vartuple ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   for var in vartuple:
      print (var)
   return
 
# 调用printinfo 函数
printinfo( 10 )
printinfo( 70, 60, 50 )

#代码运行结果
输出: 
10
输出: 
70
60
50

17.5、匿名函数（lambda）

python 使用 lambda 来创建匿名函数。

lambda只是一个表达式，函数体比def简单很多。
lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。
虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

sum = lambda arg1, arg2: arg1 + arg2
 
# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))

#代码运行结果
相加后的值为 :  30
相加后的值为 :  40

17.6、return 语句

return语句[表达式]退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None。

def sum( arg1, arg2 ):
   # 返回2个参数的和."
   total = arg1 + arg2
   print ("函数内 : ", total)
   return total
 
# 调用sum函数
total = sum( 10, 20 )

17.7、变量作用域（全部变量、局部变量）

定义在函数内部的变量拥有一个局部作用域
定义在函数外的拥有全局作用域

局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。

total = 0 # 这是一个全局变量
def sum( arg1, arg2 ):
   #返回2个参数的和."
   total = arg1 + arg2 # total在这里是局部变量.
   print ("函数内是局部变量 : ", total)
   return total
 
#调用sum函数
sum( 10, 20 )
print ("函数外是全局变量 : ", total)
#代码运行结果
函数内是局部变量 :  30
函数外是全局变量 :  0

17.8、过滤函数filter()

过滤掉规定的数
filter(函数,可迭代对象)

def f1(x):
    return x>50

data1=[66,45,55,88,99,77,33]
a=filter(f1,data1)
data2=list(a)#转换为列表
print(data2)
#代码运行结果
#[66, 55, 88, 99, 77]

17.9、映射函数map()

map映射函数是一种常用的函数式编程工具,它可以将一个集合转换成另一个集合。

map(函数,可迭代对象)

def f1(x):
    return x*2

data1=[40,50,60,70,80,90,100]
a=map(f1,data1)
data2=list(a)#转换为列表
print(data2)
#代码运行结果
#[80, 100, 120, 140, 160, 180, 200]

18、面向对象

18.1、定义类

18.2、创建对象

18.3、类的成员

类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。

类变量： 类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。

数据成员： 类变量或者实例变量, 用于处理类及其实例对象的相关的数据。

方法重写： 如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。

局部变量： 定义在方法中的变量，只作用于当前实例的类。

实例变量： 在类的声明中，属性是用变量来表示的。这种变量就称为实例变量，是在类声明的内部但是在类的其他成员方法之外声明的。

继承： 即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。

实例化： 创建一个类的实例，类的具体对象。

方法： 类中定义的函数。

对象： 通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

18.3.1、实例变量

实例变量是对象个体特有的“数据”，列如狗的名字和年龄等。

#__init__是构造方法（在实例化的时候调用），__init__前后都是两个下划线
#第一个参数为self是固定写法
class Dog(object):
    def __init__(self,name,age):
        print('调用了构造方法')
        self.name=name
        self.age=age
dog = Dog('狗',3)#创建对象
print(dog.name)
print(dog.age)

18.3.2、构造方法

类中的__init__（）方法是一个非常特殊的方法，用来创建和初始化实例变量，这种方法就是“构造方法”。在定义__init__（）方法时，它的第1个参数应该是self，之后的参数用来初始化实例变量。调用构造时不需要传入self参数

#__init__是构造方法（在实例化的时候调用），__init__前后都是两个下划线
#第一个参数为self是固定写法
class Dog:
    def __init__(self,name,age,sex='雄'):
        self.name=name#创建和初始化实例变量name
        self.age=age#创建和初始化实例变量age
        self.sex=sex#创建和初始化实例变量sex
        
dog1 = Dog('狗',3)#创建对象
dog2 = Dog('狗2',3,'雌')#创建对象
dog3 = Dog(name='狗3',age=3,sex='雌')#创建对象
print(dog1.name,dog1.age,dog1.sex)
print(dog2.name,dog2.age,dog2.sex)
print(dog3.name,dog3.age,dog3.sex)

#代码运行结果
狗 3 雄
狗2 3 雌
狗3 3 雌

18.3.3、实列方法

实例方法与实例变量一样，都是某个实例（或对象）个体特有的方法。

定义实例方法时，它的第1个参数也应该是self，这会将当前实例与
该方法绑定起来，这也说明该方法属于实例。在调用方法时不需要传入
self，类似于构造方法。

18.3.4、类变量

类变量是属于类的变量，不属于单个对象。

18.3.5、类方法

类方法与类变量类似，属于类，不属于个体实例。在定义类方法时，它的第1个参数不是self，而是类本身。

18.4、封装

封装性是面向对象重要的基本特性之一。封装隐藏了对象的内部细节，只保留有限的对外接口，外部调用者不用关心对象的内部细节，使得操作对象变得简单。

18.4.1、私有变量

为了防止外部调用者随意存取类的内部数据（成员变量），内部数据（成员变量）会被封装为“私有变量”。外部调用者只能通过方法调用私有变量。

在默认情况下，Python中的变量是公有的，可以在类的外部访问它们。
如果想让它们成为私有变量，则***在变量前加上双下画线（__）***即可。

18.4.2、私有方法

私有方法与私有变量的封装是类似的，在方法前加上双下画线（__）就是私有方法了。

18.4.3、 使用属性

为了实现对象的封装，在一个类中不应该有公有的成员变量，这些成员变量应该被设计为私有的，然后通过公有的set （赋值）和get（取值）方法访问。

18.5、继承

继承性也是面向对象重要的基本特性之一。
在现实世界中继承关系无处不在。例如猫与动物之间的关系：猫是一种特殊动物，具有动物的全部特征和行为，即数据和操作。在面向对象中动物是一般类，被称为“父类”；猫是特殊类，被称为“子类”。特殊类拥有一般类的全部数据和操作，可称之为子类继承父类。

18.5.1、python中的继承

在Python中声明子类继承父类，语法很简单，定义类时在类的后面使用一对小括号指定它的父类就可以了。

在子类构造方法中会调用父类构造方法

18.5.2、多继承

在Python中，当子类继承多个父类时，如果在多个父类中有相同的成员方法或成员变量，则子类优先继承左边父类中的成员方法或成员变量，从左到右继承级别从高到低。

18.5.3、方法重写

如果子类的方法名与父类的方法名相同，则在这种情况下，子类的方法会重写（Override）父类的同名方法。

18.5、多态性

多态性也是面向对象重要的基本特性之一。“多态”指对象可以表现出多种形态。
例如，猫、狗、鸭子都属于动物，它们有“叫”和“动”等行为，但是叫的方式不同，动的方式也不同。

18.5.1、继承与多态

在多个子类继承父类，并重写父类方法后，这些子类所创建的对象之间就是多态的。这些对象采用不同的方式实现父类方法。

19、异常

异常捕获是通过try-except语句实现的，基本的try-except语句的语法如下。

在try代码块中包含在执行过程中可能引发异常的语句，如果没有发生异常，则跳到except代码块执行，这就是异常捕获。try-except语句的执行流程如下

while True:
    try:
        x=int(input("请输入一个数字："))
        break
    except ValueError:
        print("您输入的不是数字，请再次尝试输入")

19.1、try-except语句嵌套

19.2、使用finally代码块释放资源

有时在try-except语句中会占用一些资源，例如打开的文件、网络连接、打开的数据库及数据结果集等都会占用计算机资源，需要程序员释放这些资源。为了确保这些资源能够被释放，可以使用finally代码块。

19.3、自定义异常类

19.4、捕获所有异常

try:
     <语句>
 
except:
 
      print('异常说明')

19.5、捕获所有异常捕获指定异常

try:
     <语句>
 
except <异常名>:
 
      print('异常说明')

19.6、捕获所有异常捕获指定异常捕获多个异常

try:
     <语句>
 
except (<异常名1>, <异常名2>, ...):
 
      print('异常说明')

try:
     <语句>
 
except <异常名1>:
 
      print('异常说明1')
 
except <异常名2>:
 
      print('异常说明2')
 
except <异常名3>:
 
      print('异常说明3')

19.6、异常中的else

try:
     <语句>
 
except <异常名1>:
 
      print('异常说明1')
 
except <异常名2>:
 
      print('异常说明2')
 
else:
 
      <语句>  # try语句中没有异常则执行此段代码

19.7、异常中的finally

str1 = 'hello world'
try:
    int(str1)
except IndexError as e:
    print(e)
except KeyError as e:
    print(e)
except ValueError as e:
    print(e)
else:
    print('try内没有异常')
finally:
    print('无论异常与否,都会执行我')

try:  
    execution block  ##正常执行模块  
except A:  
    exc A block ##发生A错误时执行  
except B:  
    exc B block ##发生B错误时执行  
except:  
    other block ##发生除了A,B错误以外的其他错误时执行  
else:  
    if no exception, jump to here ##没有错误时执行  
finally:  
    final block  ##总是执行  

19.8、raise主动触发异常

raise [Exception [, args [, traceback]]]
#语句中Exception是异常的类型（例如ValueError），参数是一个异常参数值。
#该参数是可选的，如果不提供，异常的参数是"None"。
#最后一个参数是跟踪异常对象，也是可选的（在实践中很少使用）。

def not_zero(num):
    try:
        if num == 0:
            raise ValueError('参数错误')
        return num
    except Exception as e:
        print(e)
 
not_zero(0)
 

19.9、采用traceback模块查看异常

try:
    block
 
except:
 
    traceback.print_exc()

import traceback
 
try:
    1/0
except Exception as e:
    traceback.print_exc()

#会报出指定的错误
#Traceback (most recent call last):
#  File "C:\Users\YYH\Desktop\a.py", line 4, in <module>
#    1/0
#ZeroDivisionError: division by zero

20、数学计算模块——math

在math模块中包含数学运算相关的函数等，例如指数、对数、平方根和三角函数等。

import math
from math import floor

a=math.ceil(10.2)#向上取整
print(a)

a=floor(10.2)#向下取整
print(a)

#math.sqrt(9)返回9的平方根
print(math.sqrt(9))

#math.pow(2,3)返回2的3次幂的值，就是2的三次方
print(math.pow(2,3))

print(math.fabs(-20))#返回一个数的绝对值，绝对值就是负数是正的，正数还是正的

print(math.gcd(20,50))#返回两个数的最大公约数

print(math.modf(5.4))#返回x的小数和整数部分

print(math.trunc(5.4))#返回x的整数部分

a=0.1 + 0.2 + 0.3
print(a)#0.6000000000000001

a=math.fsum([0.1, 0.2, 0.3])#浮点数精确求和
print(a)#0.6

21、日期时间模块

Python官方提供的日期和时间模块主要是datetime模块。在datetime模块中提供了右侧几个类。
datetime：包含时间和日期。
date：只包含日期。
time：只包含时间。
timedelta：计算时间跨度。
tzinfo：时区信息。

21.1、 date（日期类型）

date 类表示一个由年、月、日组成的日期。

格式：datetime.date(year, month, day)。

year 范围为：[1, 9999]
month 范围为：[1, 12]
day 范围为 [1, 给定年月对应的天数]

import datetime
 
# date 日期类，包含年、月、日。精确度到天
print("***这是类方法***")
print(datetime.date)
print(datetime.date.today())#获取当前时间
print(datetime.date.fromtimestamp(0))   # 参数是时间戳
 
print("***这是实例方法***")
t = datetime.date(2021,5,10)
print(t)
print(t.today())
print(t.ctime())    # 返回一个ctime格式的日期字符串
print(t.isoformat())    # 返回一个iso格式的日期字符串
print(t.strftime("%Y-%m-%d %a"))    # 返回一个自定义格式的日期字符串

21.2、time（时间类型）

time 类表示由时、分、秒、微秒组成的时间。

格式：time(hour=0, minute=0, second=0, microsecond=0, tzinfo=None, *, fold=0)

hour 小时，范围为：[0, 24)
minute 分钟，范围为：[0, 60)
second 秒，范围为：[0, 60)
microsecond 微秒，范围为：[0, 1000000)
tzinfo 时区
fold 范围为： [0, 1]

import time
import datetime
 
# time 时间类，包含时、分、秒、微秒。精确到微秒，而且可以具有时区(tzinfo)属性。
print("***这是类方法***")
print(datetime.time)
 
print("***这是实例方法***")
t = datetime.time(17,47,50)
print(t.hour)#返回小时
print(t.isoformat())    # 返回一个iso格式的时间字符串
print(t.strftime('%H:%M:%S %p'))    # 返回一个自定义格式的时间字符串
 

import datetime 
 
# datetime 日期时间类，包含date和time的所有信息
print("***这是类方法***")
print(datetime.datetime)#<class 'datetime.datetime'>
print(datetime.datetime.today())#返回当前时间
print(datetime.datetime.now())      # 返回当前本地时间
print(datetime.datetime.utcnow())   # 返回当前utc时间
print(datetime.datetime.fromtimestamp(0))       # 根据时间戳返回本地时间
print(datetime.datetime.utcfromtimestamp(0))    #根据时间戳返回UTC时间
 
print("***这是实例方法***")
t = datetime.datetime(year=2020,month=5,day=10,hour=18,minute=32,second=30) # 实例化对象，年月日必填
print(t)
print(t.date())     # 返回date对象
print(t.time())     # 返回time对象
print(t.ctime())    # 返回一个ctime格式的日期时间字符串
print(t.isoformat())    # 返回一个iso格式的日期时间字符串
print(t.strftime("%Y-%m-%d"))
 

21.3、tzinfo（时区类型）

几种时间：

本地时间（北京时间）
UTC时间（格林尼治时间）
DST时间（夏时令时间）
zinfo是一个抽象类，所以不能直接被实例化。子类必须重写name（）、utcoffset（）和dst（）方法

推荐使用pytz模块，里面自带了适合各个国家和时区的tzinfo对象，我们可以直接使用。

21.4、timedelta（时间差类型）

timedelta 对象表示两个datetime 对象的时间差值。
格式：datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0)其中参数都是可选，默认值为0

import datetime
 
# timedelta 时间差
era_time = datetime.datetime.fromtimestamp(0)
now_time = datetime.datetime.now()
print(era_time)
print(now_time)
#计算当前时间到纪元时间的时间差
delta_time = now_time - era_time
print(type(delta_time))
print(delta_time)
print(delta_time.days)  # 差了多少天
#当前日期往后加一天
new_time = now_time + datetime.timedelta(days=1)
print(type(new_time))
print(new_time)

21、文件读写

我们在使用文件之前要先将文件打开，这通过open（）函数实现。open（）函数的语法如下：

open（）函数中的参数还有很多，这里介绍4个常用参数，这些参数的含义如下。

1.file参数
file参数用于表示要打开的文件，可以是字符串或整数。如果file是字符串，则表示文件名，文件名既可以是当前目录的相对路径，也可以是绝对路径；如果file是整数，则表示一个已经打开的文件。

2.mode参数
mode参数用于设置文件打开模式，用字符串表示，例如rb表示以只读模式打开二进制文件。用于设置文件打开模式的字符串中的每一个字符都表示不同的含义，对这些字符的具体说明如下。

t：以文本文件模式打开文件。

b：以二进制文件模式打开文件。

r：以只读模式打开文件。

w：以只写模式打开文件，不能读内容。如果文件不存在，则创建文件；如果文件存在，则覆盖文件的内容。

x：以独占创建模式打开文件，如果文件不存在，则创建并以写入模式打开；如果文件已存在，则引发FileExistsError异常。

a：以追加模式打开文件，不能读内容。如果文件不存在，则创建文件；如果文件存在，则在文件末尾追加。

+：以更新（读写）模式打开文件，必须与r、w或a组合使用，才能设置文件为读写模式。

这些字符可以进行组合，以表示不同类型的文件的打开模式，如下表所示。

3.encoding参数
encoding用来指定打开文件时的文件编码，默认是UTF-8编码，主要用于打开文本文件。

4.errors参数
errors参数用来指定在文本文件发生编码错误时如何处理。推荐errors参数的取值为’ignore’，表示在遇到编码错误时忽略该错误，程序会继续执行，不会退出。

#mode:文件打开类型
#encoding：打开文件时的文件编码
#errors：文本文件发生编码错误时如何处理
fo = open("E:\\aa.txt", mode="w",encoding="UTF-8",errors="ignore")
print ("文件名: ", fo.name)
print ("是否已关闭 : ", fo.closed)
print ("访问模式 : ", fo.mode)

#文件名:  E:\aa.txt
#是否已关闭 :  False
#访问模式 :  w

21.1、读取文本

读写文本文件的相关方法如下。
read（size=-1）：读取所有，不会读取格式。size限制读取的字符数，size=-1指对读取的字符数没有限制。

readline（size=-1）：只能读取一行。size限制读取的字符数，size=-1指对读取的字符数没有限制。

readlines（）：读取所有，还会读取格式。

# 打开 hello.txt 文件，指定「只读模式」
hello = open('E:\\aa.txt', 'r')

# 使用 for 循环，将读到的内容，打印出来
num = 1
for con in hello:
    print('第 %d 行：' % num, con)
    num += 1

# 获取文件指针的位置
print(hello.tell())

# 将文本文件的指针，复位,如果不复位则会读取不到东西
hello.seek(0)

# 使用 read()
con = hello.read()
print("---- 使用 read() -----")

print(con)

# 最后需要将文件关闭
hello.close()

使用read（）

try:
    # 打开 hello.txt 文件，指定「只读模式」
    hello = open('E:\\aa.txt', 'r')

    # 使用 readlines()，读取全部信息（不会读取格式）
    con = hello.read()
    print(con)

finally:
    print('出问题了')
    # 最后需要将文件关闭
    hello.close()

使用readlines（）

try:
    # 打开 hello.txt 文件，指定「只读模式」
    hello = open('E:\\aa.txt', 'r')

    # 使用 readlines()，读取全部信息（会读取格式）
    con = hello.readlines()
    print(con)

finally:
    print('出问题了')
    # 最后需要将文件关闭
    hello.close()

#['hello!\n', 'world!\n']

21.2、写入文本

***write（s）：***将字符串s写入文件中，并返回写入的字符数。

***writelines（lines）：***向文件中写入一个字符串列表。不添加行分隔符，因此通常为每一行末尾都提供行分隔符。

***flush（）：***刷新写缓冲区，在文件没有关闭的情况下将数据写入文件中。

使用write

file_address = 'E:\\aa.txt'
with open(file_address,mode='w',encoding="UTF-8",errors="ignore") as hello :
    hello.write("I Love You")

file_address = 'E:\\aa.txt'
try:
    # 打开 hello.txt 文件，指定「只读模式」
    hello = open(file_address,mode='w',encoding="UTF-8",errors="ignore")

    # 使用 readlines()，读取全部信息（会读取格式）
    con = hello.write("I Love You")
    print(con)#返回写入的字符数量

finally:
    print('出问题了')
    # 最后需要将文件关闭
    hello.close()

使用writelines

file_address = 'E:\\aa.txt'
txtlist = ['Python 私教\n', 'Java 私教\n', 'C++ 私教\n']
with open(file_address,mode='w',encoding="UTF-8",errors="ignore") as hello :
    hello.writelines(txtlist)

file_address = 'E:\\aa.txt'
txtlist = ['Python 私教\n', 'Java 私教\n', 'C++ 私教\n']
try:

    hello = open(file_address,mode='w',encoding="UTF-8",errors="ignore")

    # 使用 readlines()，读取全部信息（会读取格式）
    con = hello.writelines(txtlist)
    print(con)#返回写入的字符数量

finally:
    print('出问题了')
    # 最后需要将文件关闭
    hello.close()

flush（）
hello.flush()：将文件立即从缓冲区刷新到磁盘

file_address = 'E:\\aa.txt'
txtlist = ['Python 私教\n', 'Java 私教\n', 'C++ 私教\n']
try:

    hello = open(file_address,mode='w',encoding="UTF-8",errors="ignore")

    # 使用 readlines()，读取全部信息（会读取格式）
    con = hello.writelines(txtlist)
    hello.flush()#将文件立即从缓冲区刷新到磁盘
    hello.writelines(txtlist)
    print(con)#返回写入的字符数量

finally:
    print('出问题了')
    # 最后需要将文件关闭
    hello.close()

21.3、关闭文件

在打开文件后，如果不再使用该文件，则应该将其关闭，会用到close（）方法。

21.3.1、在finally代码块中关闭文件

#mode:文件打开类型
#encoding：打开文件时的文件编码
#errors：文本文件发生编码错误时如何处理

f_name ="E:\\aa.txt"
file = None

try:
    file = open(f_name, mode="w",encoding="UTF-8",errors="ignore")
    print("打开文件")
    # print ("文件名: ", file.name)
    # print ("是否已关闭 : ", file.closed)
    # print ("访问模式 : ", file.mode)
    content = file.read();
    print (content)
except FileNotFoundError as e:
    print ("文件不存在")
except OSError as e:
    print ("处理OSError异常")
finally:
    if file is not None:
        file.close()
        print ("关闭文件成功")

21.3.2、在with as代码块中关闭文件

with…as，就是个python控制流语句，像 if ，while一样。
with…as可以认为是简化版的try except finally语句。如打开文件可以自动关闭。

with 对象1 as 返回值1, 对象2 as 返回值2:
do something with 返回值1，返回值2

with expression [as target]:
	with_body
	
#expression ：是一个需要执行的表达式；
#target ：是一个变量或者元组，存储的是expression表达式执行返回的结果，[]表示该参数为可选参数。

f_name ="E:\\aa.txt"
#使用with as 自动资源管理
with open(f_name) as f:
    content = f.read()
    print(content)
#with as提供了一个代码块，在as后面声明一个资源变量，在with as代码块结束之后自动释放资源。