python基础--基本数据类型、条件循环语句、函数、面向对象、文件读取、bug语句

 一、语法基础

1.1  输入和输出

1，输出：print()函数

语法结构：print(objects, sep=' ', end='\n', file=None, flush=False)

objects：要打印的对象，可以是一个或多个参数。它们将按顺序打印在一行上。使用逗号分隔多个对象。

sep=' '（可选）：用于分隔多个对象之间的字符串。默认情况下，它是一个空格字符。

end='\n'（可选）：用于表示打印的结尾字符串。默认情况下，它是一个换行符 \n，表示在输出内容

的末尾打印一个换行符，使下一行输出位于新的行。

file=sys.stdout（可选）：指定要将输出发送到的文件对象。默认情况下，输出被发送到标准输出流（通常是控制台）。可以将其设置为一个文件对象，以将输出写入文件。

flush=False（可选）：控制是否刷新输出缓冲区。默认情况下，缓冲区会自动刷新。如果将其设

置为 True，则立即刷新缓冲区，将内容输出到目标文件或终端。

#print()函数
a=3
b='hello'
print(a,b,'word')
print(a,b,'word',end='!')
print(a,b,'word',sep=',')

2，输入：input()函数

语法结构：x=input('提示文字')

#无论输入什么，x的数据类型都是字符串类型

#input()函数
x=input('请输入：')
print('输入为：',x,'\n')

1.2  注释

注释：不会被执行的内容

1，单行注释

语法结构：#注释内容

2，多行注释（本质就是字符串）

语法结构："""注释内容"""或者'''注释内容''' （三个英文单引号/三个英文双引号包含的内容）

3，中文文档声明注释，说明编码格式（python的编码格式必须正确）

语法结构（通常在第一行设置）：#coding=编码格式

1.3  缩进

缩进：每行代码开始的前面空白区域

#python中严格执行缩进，缩进错误会报IndentationError错误

a=2
b=3
 print(a,b)#缩进错误

#缩进用来表示代码间的层次和包含关系

#类定义、函数定义、流程控制语句以及异常处理语句的行尾的冒号和下一行的缩进表示一个代码块的开始；缩进结束表示下一个代码块的结束。

1.4  模块（module）

导入模块：

（1）语法结构：import math

说明：导入math模块，使用math中函数或变量语法结构：math.函数()或math.变量

（2）语法结构：import numpy as np

说明：导入numpy模块，通过np.函数()或np.变量使用numpy模块中的函数或变量

（3）语法结构：for math import sqrt

说明：单独导入math模块中的sqrt()函数，使用：sqrt()或math.sqrt()可以调用该函数

1.5  关键字/保留字

python中被赋予特定意义的一些单词，在开发程序时，不可以把这些关键词作为作为变量、函数、类、模块和其他对象名称使用

模块keyword：

#打印关键字：keyword.kwlist

#查看是非为保留字：keyword.iskeyword(x)

import keyword
print(keyword.kwlist)
print(keyword.iskeyword('False'))
print(keyword.iskeyword('false'))

1.6  运算符

1，算术运算符：+（加）、-（减）、*（乘）、/（除）、//（整除）、%（取余）、**（幂运算）

#/除、//整除、%取余中分母不为0，会报ZeroDivisionError错误

#算术运算符'/'中分母不为0
3/0

2，赋值运算符

简单赋值运算符：=

符合赋值运算符：+=、-=、*=、/=、%=、**=、//=

#python支持链式赋值

#python支持系列解包赋值

#支持字符串分解赋值

#python支持链式赋值
a=b=c=100
print('a=',a,'b=',b,'c=',c)
#python支持系列解包赋值
b=200
print('a=',a,'b=',b,'c=',c)
a,b=b,a
print('a=',a,'b=',b,'c=',c)
#支持字符串分解赋值
a,b,c='cat'
print('a=',a,'b=',b,'c=',c)

3，比较运算符：>、>=、==、!=（不等于）、<=、<

#成立返回布尔值：True，不成立返回布尔值：False

4，逻辑运算符（对布尔数据的运算）：and、or、not

表达式1	表达式2	表达式1 and 表达式2	表达式1 or 表达式2	not 表达式1
True	True	True	True	False
True	False	False	True	False
False	False	False	False	True
False	True	False	True	True

#注意惰性求值：在逻辑运算符and中，表达式1为False则结果必为False，表达式2不会被执行；在逻辑运算符or中，表达式1为True则结果必为True，表达式2不会被执行

4，位运算符：将数字看作二进制数来计算

按”位与“运算（&）：1010&1001=1000（当且仅当同时为1时结果为1）

按”位或“运算（|）：1010|1001=1011（当且仅当其中至少一个为1时结果为1）

按”位异或“运算（^）：1010^1001=0011（当且仅当值不同时结果为1）

按”位取反“运算（~）：~1010=0101

”左移位“运算（<<）：将一个二进制数向左移动指定位数，左边溢出位数丢弃，右端空位用0补齐

”右移位“运算（>>）：将一个二进制数向右移动指定位数，右边溢出位数丢弃，若最高位为0，则左端空位用0补齐，若最高位为1，则左端空位用1补齐

5，运算优先级：从上到下递减

运算符	运算说明
**	幂运算
~、+、-	取反、正号、负号
*、/、%、//	算术运算符
+、-	算术运算符
<<、>>	位运算符中的左移位和右移位
&	位运算符中按位与
^	位运算中异或
|	位运算中按位或
<、<=、==、!=、>、>=	比较运算符
=	赋值运算符

1.7  变量variable、对象object、数据类型type、类class

#python是面向对象的程序设计语言，变量variable可以看做对象object，每一个对象都有一个特定的数据类型type，数据类型可以看做是类class。

#对象就是实际中操作处理的数据，如13、3.14、'Hello word！'，他们属于一个特定的类，如13是整数，3.14是浮点数，'Hello word!'是字符串，这些都是python中自带的，也可以自己定义类。

1，变量名的命名法则：

（1）变量名只能包含字母、数字、下划线，且不能以数字开头。

（2）变量名不能包含空格。

（3）不能将python中关键字和函数名作为变量名。

（4）python中对大小写敏感，比如Hello和hello，是两个不同的变量。

2，说明：对于赋值语句：cat=13

13是对象，存储空间中实际存储的东西；cat可以看作是名字或者标签；赋值语句看作将cat这个名字与13对象绑定，通过操作cat可以操作13；

一个对象可以有多个名字/标签，他们指向的是同一地址。如下代码，名字cat和dog都是与对象13绑定的，因此查看他们的地址就是相当于查看赋给对象13的地址

cat = 13
dog = 13 
print('id(cat):',id(cat))
print('id(dog):',id(dog))
print('id(13):',id(13))

#id()函数为查看对象的地址

3，“垃圾回收机制”：当一个对象没有名字与他绑定时，计算机会自动回收地址。

#python中的数据类型根据是否可修改分为两种：不可变数据类型和可变数据类型，若通过名字来’修改‘对象，会出现两种情况：

对于不可变数据类型来说：

如下代码，当试图cat名字通过修改13值时，由于该对象13是不可变数据类型，他并不能修改对象13，即cat=11这个操作的意思并不是将13改为12，而是取消对象13与名字cat的绑定，并将对象12与名字cat绑定

cat = 13
dog = 13
print('id(cat):',id(cat))
print('id(dog):',id(dog))
print('id(13) :',id(13))
cat = 12
print('\nid(cat):',id(cat),'#重新绑定')
print('id(12) :',id(12))
print('id(dog):',id(dog))
print('id(13) :',id(13))

可变数据类型来说：对于可变数据类型，可以通过名字修改其值，修改后任是和该对象绑定

lst=[1,2,3]#列表为可变数据类型
print('lst=',lst,'id(lst)',id(lst))
lst[0]='a'
print('lst=',lst,'id(lst)',id(lst))

4，is和==

==：判断两个值是否相等

is：判断两个是否完全一致，包括地址

a=3
b=3.0
print('a==b:',a==b)
print('a is b:',a is b)
print('id(a)',id(a),'\nid(b)',id(b))

1.8  简单数据结构类型

#type(x)函数：查看x的数据类型

print('1:',type(1))
print('1.1:',type(1.1))
print('"hello":',type("hello"))
print('True:',type(True))

1，整数int：（不可变数据类型）表示数值没有小数部分的数值

进制	引导符	描述
十进制	无	默认为十进制，如：327、38
二进制	0b或0B	由0和1组成，如0b100011、0B0111001
八进制	0o或0O	由0到7组成，如0o7241、0O32735
十六进制	0x或0X	由0到9，a到f或A到F组成，如0x147A、0X236A

2，浮点数float：（不可变数据类型）通常意义上的小数。在计算机中受限于有效位数，浮点数的精度会受到限制，如下代码：

x=0.278
y=100*x
print('y=',y)

#可以使用科学计算法表示（e/E）

3，字符串str：（不可变数据类型）有序的字符序列

#单引号/双引号定义一个字符串

#三个单引号/三个双引号定义多行字符串

转义字符：

转义字符	描述说明
\n	换行符
\t	水平制表位，用于横向跳转到下一个制表位
\"	双引号
\'	单引号
\\	一个反斜杠

4，布尔型bool：（不可变数据类型）表示”真“和”假“值得数据类型；只取两个值：Ture和False。

#在逻辑运算结果中遵循非0即真Ture

#True表示整数1，False表示整数0

1.9  数据类型转换

1，显性转换

函数	描述说明
int(x)	将x转换整数类型；注意要能可转化为整数，否则会报错
float(x)	将x转换为浮点数类型
str(x)	将x转换为字符串
chr(x)	将整数（ascll码）x转换为一个字符
ord(x)	将一个字符x转换为其对应数值（ascll码）
hex(x)	将一个整数x转换成一个十六进制字符串
oct(x)	将一个整数x转换成一个八进制字符串
bin(x)	将一个整数x转换成一个二进制字符串

2，隐形转换：

整数/整数--->浮点数

1.10  eval()函数

python中内置函数；去掉字符串最外侧的引号，并按照python语句方式执行去掉引号后的字符串。

语法格式：变量=eval(字符串)

#eval()函数
str='3+4'
age=eval(str)
print('age=',age)

二、主要数据类型

2.1  序列

是一个用于存储多个值的连续空间，每个值对应一个整数编号，这个整数编号称为索引

1，索引：正向递增索引和反向递减索引

通过索引访问或修改：序列[index]

2，序列的相关操作

操作符/函数	描述说明
x in s	如果x是s的元素，结果为True，否则结果为False
x not in s	如果x不是s的元素，结果为True，否则结果为False
len(s)	序列s中元素的个数（序列的长度）
max(s)	序列s中元素的最大值
min(s)	序列s中元素的最小值
s.index(x)	序列s中第一次出现元素x的位置，若找不到会报错
s.count(x)	序列s中出现x的总次数

3，序列的切片操作

语法结构：序列[start:end:step]

#start：切片开始索引，包含

#end：切片结束索引，不包含

#step：步长

#逆序：序列[::-1]

#序列逆序
x=[1,2,3,4,5,6,7,8]
print(x[::-1])

#凡是是序列的数据结构都有以上操作

2.2  列表list

（可变数据类型，有序，序列）指一系列的按特定顺序排列的元素组成的

#列表元素中可以是任意数据类型

1，创建

（1）使用[]直接创建列表，元素与元素之间用英文逗号分隔

语法结构：列表名=[element1，element2，……elementN]

（2）使用内置函数list()转换成列表

语法结构：列表名=list(序列）

#列表创建
lst1=[1,2,3,4]#使用[]创建
print('lst1=',lst1,'\t','type(lst1)=',type(lst1))
str='abcdef'
lst2=list(str)#使用list()函数创建
print('lst2=',lst2,'\t','type(lst2)=',type(lst2))

2，访问和修改

列表可以通过索引访问和修改

访问：lst[index]

修改：lst[index]=y

3，添加：

（1）append

语法结构：lst.append(x)

说明：在列表lst最后增加一位元素x，无论x是什么，都将x作为一个元素加入列表中

（2）extend

语法结构：lst.insert(index,x)

说明：在列表的第index位置添加一个元素

#列表添加
lst=[1,2,3,4]
x1=5
x2=[1,2]
print('lst:',lst)
lst.append(x1)
print('lst.append(x1):',lst)
lst.append(x2)
print('lst.append(x2):',lst)
lst.insert(0,x2)
print('lst.insert(0,x2):',lst)

3，删除：

（1）pop

语法结构：lst.pop(index)

将列表lst的第index位置的元素取出来，并从列表中将其删除，返回删除的元素

（2）remove

语法结构：lst.remove(x)

说明：将列表lst中出现的第一个元素删除，找不到元素会报错

（3）clear

语法结构：lst.clear()

说明：清空列表中所有元素，列表为空，列表任存在

（4）def

语法结构：def 列表

说明：删除列表，列表不存在

#列表元素删除
lst=[1,2,3,4,5,4]
print('lst:',lst)
lst.pop(1)
print('lst.pop(1):',lst)
lst.remove(4)
print('lst.remove(4):',lst)
lst.clear()
print('lst.clear():',lst)

#列表删除
lst=[1,2,3,4]
print('lst:',lst)
del lst
print('lst:',lst)

4，数值列表

range()函数：生成数值列表

语法结构：range(x)或range(x,y)或range(x,y,z)

#range()函数生成数值列表
x1=range(5)
x2=range(1,5)
x3=range(1,5,2)
print(x1,type(x1),list(x1))
print(x2,type(x2),list(x2))
print(x3,type(x3),list(x3))

5，元素排序

（1）sort

语法结构：lst.sort(key=None,reverse=False)

说明：按key值进行排序，reverse为True时递减排序，原地操作，是列表的成员函数

（2）sorted()函数

语法结构：sorted(lst,key=None,reverse=False)

说明：按key值进行排序，reverse为True时递减排序，返回一个新的列表

#列表排序
lst1=[3,4,5,2,1]
lst1.sort()
print('lst1=',lst1)
lst2=['s','w','a','c','v','d']
sorted_lst2=sorted(lst2)
print('lst2=',lst2,'\n','sorted_lst2=',sorted_lst2,sep='')

（3）reverse

语法结构：lst.reverse()

说明：对列表元素进行颠倒，原地操作，是列表的成员函数

（4）reversed

语法结构：reversed(lst)

 说明：对列表元素进行颠倒，返回一个可迭代对象

#列表颠倒
lst1=[3,4,5,2,1]
lst1.reverse()
print('lst1=',lst1)
lst2=['s','w','a','c','v','d']
reversed_lst2=reversed(lst2)
print(reversed_lst2)
print('lst2=',lst2,'\n','reversed_lst2=',list(reversed_lst2),sep='')

6，遍历列表

（1）直接切片遍历

（2）range切片和索引遍历

（3）enumerate()函数遍历

For index,iterm in enumerate(lst):

#列表遍历
lst=['a','b','c','d','e','f']
#直接切片遍历
for x in lst[::-1]:
    print(x,end=',')
print()
#range切片和索引遍历
for i in range(0,len(lst)):
    print(lst[i],end=',')
print()
#enumerate()函数遍历
for index,item in enumerate(lst):
    print(index,':',item,sep='',end=',')

7，列表生成式

语法结构：

Lst=[expression for iterm in range]

Lst=[expression for iterm in range if condition]

#列表生成式
lst1=[x+1 for x in range(5)]
lst2=[x+1 for x in range(5) if x%2==0]
print('lst1=',lst1,'\n','lst2=',lst2,sep='')

8，列表运算：+、*

#列表运算
lst1=[1,2]
lst2=[3,4]
lst=lst1+lst2
print('lst1+lst2:',lst)#＋：连接
print('lst*3:',lst*3)#*：重复n次

9，二维列表的遍历与生成

（1）二维列表遍历

语法结构：

for row in lst：

        for iterm in row：

                pass

（2）二维列表生成

#二维列表生成遍历
lst=[[j for j in range(5)] for i in range(4)]#生成
print(lst)
for row in lst:#遍历
    for item in row:
        print(item,end=',')

10，列表复制

复制操作符复制：不会生成副本，相当于将列表与一个新的名字绑定，修改时原列表也会被修改

copy()函数复制：生成一个列表并返回

切片复制：lst[::]

#列表复制
lst=[1,2,3,4]
lst1=lst
copy_lst=lst.copy()
lst2=lst[::]
print(lst,id(lst))
print(lst1,id(lst1),'#赋值运算符复制')
print(copy_lst,id(copy_lst),'#copy()函数赋值')
print(lst2,id(lst2),'#切片赋值')

深拷贝copy.deepcopy()

import copy
a=[1,2,3,[2,3,4]]
b=a.copy()#浅拷贝copy
b1=copy.deepcopy(a)#深拷贝deepcopy
print('id(a)',id(a),'\tid(b)',id(b),'\tid(b1)',id(b1))
print('id(a[3])',id(a[3]),'\tid(b[3])',id(b[3]),'\tid(b1[3])',id(b1[3]))

2.3  元组tuple

(不可变数据类型，有序，序列)

#只读，不可修改，可以通过索引访问

1，创建

（1）使用()定义元组，元素与元素之间用英文逗号分隔

#元组中只有一个元素时，逗号不能省略

语法结构：元组名=(element1,element2,……,elementN)

（2）使用内置函数tuple()创建元组

语法结构：元组名=tuple(序列)

2，元组遍历

（1）直接遍历

（2）切片索引遍历

（3）enumerate()函数遍历

#元组遍历
tup=(1,2,3,4,5,6,7,8)
#直接切片遍历
for x in tup[::-1]:
    print(x,end=',')
print()
#range切片和索引遍历
for i in range(0,len(tup)):
    print(tup[i],end=',')
print()
#enumerate()函数遍历
for index,iterm in enumerate(tup):
    print(index,':',iterm,sep='',end=',')

3，元组生成式（是生成器对象，需要转化成可见的）

#元组生成式
tup=(i for i in range(5))
print(tup)
print(tuple(tup))

 2.4  集合set

（可变数据类型，序列）一个无序的不重复元素序列

#无序，元素不能重复，元素必须为可哈希类型

#由于集合无序，故不能使用索引进行相关操作

1，集合的创建与删除

（1）使用{}直接创建

语法结构：s={element1,element2,……elementN}

（2）使用内置函数set()创建函数

语法结构：s=set(可迭代对象）

#不能用{}创建空集合，{}创建的是空字典，可以使用set([])创建空集合

2，集合操作符

3，子集和超集

若s2为s1子集，则s1为s2的超集

判断s2是否为s1子集：s1.issubset(s2)

判断s1是否为s2超集：s2.issuperset(s1)

4，集合的增添和删除

删除集合操作：del 集合名

5，遍历

（1）for直接遍历

（2）enumerate()函数遍历

#元组遍历
x={1,2,3,4,5,6}
#for直接遍历
for item in x:
    print(item,end=',')
print()
#使用enumerate()函数遍历
for index,item in enumerate(x):
    print(index,':',item,sep='',end=',')

#由于集合无序，即不能使用索引遍历

6，集合生成式

s={expression for iterm in range}

s={expression for iterm in range if condition}

2.5  字典dict

(可变数据类型，无序）根据一个信息查找另一个信息的方式构成”键值对“，表示索引用的键和对应的值构成的成对关系

#键key只能是不可变数据，且不能有重复；值value没有限制

1，字典创建

（1）直接创建{}

语法结构：d={key1:value1,key2:value2a……}

#空字典：{}

（2）使用内置函数dict()创建字典：将元组键值对的元组或列表转化为字典，或者使用dict实参列表生成字典dict（key1=value1,key2=value2,……）

（3）通过映射函数：zip(lst1,lst2)

#字典创建
#直接创建
dic1={0:'a',1:'b',2:'c',3:'d'}
#dict()函数转换
dic2=dict([(0,'e'),(1,'f'),(2,'g'),(3,'h')])
#映射函数zip()进行创建
lst1=[0,1,2,3]
lst2=['i','j','k','l']
dic3=dict(zip(lst1,lst2))
print('dic1=',dic1,'\ndic2=',dic2,'\ndic3=',dic3,sep='')

2，访问、修改、取值、删除

字典的访问：name_dict["key"]，找不到key键会报错

字典值的修改：name_dict["key"]=value，找不到key键会重新添加

字典元素取值：dict[key]或dict.get(key,default=None)

键值对删除：del key，删除键值对，找不到会报错

len(dict)：求字典dict中的键值对数

"key" in dict：判断键是否在字典中

3，字典元素遍历：

4，字典成员函数

字典成员方法	说明
d.keys()	获取所有的key数据
d.values()	获取所有的value数据
d.pop(key,default)	key存在时获取对应value，同时删除key-value对，否则获取默认值default
d.popitem()	随机从字典中取出一个key-value对，结果为元组类型，同时将key-value从字典中删除
d.clear()	清空字典中所有的key-value对
d.copy()	拷贝字典
d.fromkeys(序列，值)	建立一个字典，键为序列，所有键的值为第二个参数
dict1.update(dict2)	用字典dict2来更新dict1

5，字典生成式

2.6  总结

 三、条件、循环

3.1  条件

1，if-else语句

语法结构：

if <条件>:

        <语句块>

else:

        <语句块>

2，if-elif-else语句

if <条件>:

        <语句块>

elif <条件>:

        <语句块>

else:

        <语句块>

#嵌套使用

3，条件语句

语法结构：x=语句块1 if 条件 else 语句块2

#条件语句
x=8
y=x+1 if x==8 else x-1
print('y=',y)

4，断言assert

语法结构：assert 条件

当条件不成立时程序会报错并停止执行

3.2  循环

1，for循环结构

for 循环变量 in 遍历对象:

        语句块1

else:

        语句块2

#当语句块1正常执行结束时，执行else后的部分，else部分可不写

2，while循环结构

while 表达式:

        语句块1

else:

        语句块2

#当语句块1正常执行结束时，执行else后的部分，else部分可不写

#嵌套使用

3.3  其他语句

1，break结束循环

#在for/while循环中与if搭配使用

#位于内循环时只退出内循环

2，continue结束本次循环

#在for/while循环中与if搭配使用

3，空语句pass

#在语法结构中起到占位符的作用，使语法结构完整，不报错

 四、函数

4.1  函数定义

函数：一段实现功能的完整代码，使用函数名称进行封装，通过函数名进行调用。

函数定义语法结构：

def 函数名称  (参数列表):

        函数体

        [return 返回值列表]

函数调用：

函数名(参数列表)

#返回值可有可无，可以返回一个或多个值，多个值以元组返回

#callable()函数：检测一个变量/对象是否可执行，即是否为函数

4.2  函数参数

#位置传参和关键字传参可以混合使用，位置传参在前，关键字传参在后。

#默认值传参，不传参时使用默认值

#个数可变的位置参数

def fun(*para):
    print(type(para))
    for x in para:
        print(x)
fun(10,20,30,40)
fun(10)
fun(*[20,30,40])#对于序列，调用时加一个*：系列解包

#个数可变的关键字参数

def fun(**kwpara):
    print(type(kwpara))
    for key,value in kwpara.items():
        print(key,':',value)
fun(a=0,b=1,c=2)
fun(**{'a':0,'b':1,'c':2,'d':3})#调用时加**：系列解包

4.3  函数作用域

#全局变量适用整个代码文件

#当全局变量和局部变量名字相同时，局部变量优先级高。

vars()函数：返回作用域或者名字空间

global()函数：返回全局变量的字典；

global()[“x”]：访问全局变量x的值

4.4  说明文档

说明文档：函数定义代码中第一个注释

通过help(fun)函数返回函数fun的说明文档

4.5 递归函数

递归函数：在一个函数的函数体内调用该函数本身，该函数就是递归函数

4.6 匿名函数

f=lambda x,y:x*y
print(type(f))
print(f(10,10))

4.7 常用函数

1，常用内置函数

2，常用数学函数

#round中d为负数是对整数部分四舍五入

3，常用迭代器操作函数

五、字符串进阶

3.1  常用操作

方法	说明
str.lower()	将str字符串全部转成小写字母，结果为一个新的字符串
str.upper()	将str字符串全部转成大写字母，结果为一个新的字符串
str.split(sep=None)	把str按照指定的分隔符sep进行分隔，结果为列表类型
str.count(sub)	结果为sub字符串在str中出现的次数
str.find(sub)	查询sub这个字符串在str中是否存在，如果不存在结果为-1，存在返回首次出现的索引
str.index(sub)	功能与find()相同，但若找不到子串程序会报错
str.startswith(s)	查询字符串str是否以s开头
str.endswith(s)	查询字符串str是否以s结尾
str.replace(old,news)	使用news替换字符串str中所有old字符串，结果为一个新的字符串
str.center(width,fillchar)	字符串str在指定范围width居中，可使用fillchar填充
str.join(iter)	在item中每个元素加一个字符串str
str.strip(chars)	从字符串中去掉左侧和右侧chars中列出的字符串
str.lstrip(chars)	从字符串中去掉左侧chars中列出的字符串
str.rstrip(chars)	从字符串中去掉右侧chars中列出的字符串

3.2  格式化字符串

#格式化字符串
#（1）占位符
a=8
b='hello'
print('%d,%s word!'%(a,b))
#（2）f-string
print(f'{b} {a} word!')
#（3）str.format()方法
print('{1} word! {0}'.format(a,b))

格式化详细

#格式化字符串
s='helloword'
print('{0:*<20}'.format(s))
print('{0:*>20}'.format(s))
print('{0:*^20}'.format(s))
print('{0:,}'.format(23484833))
print('{0:.4f}'.format(3.1415926))
print('{0:.5}'.format(s))

3.3  字符串的编码解码

#编码与解码使用的方式一致相同

#gpk编码中中文字符占两个

3.4  数据的验证

方法	说明
str.isdigit()	所有字符都是数字（阿拉伯数字）
str.isnumeric()	所有字符都是数字
str.isalpha()	所有字符都是字母（包含中文字符）
str.isalnum()	所有字符都是数字或字母（包含中文字符）
str.islower()	所有字符都是小写
str.isupper()	所有字符都是大写
str.istitle()	所有字符都是首字母大写
str.issapce()	所有字符都是空白字符（\t、\n等）

3.5  数据的处理

#字符串拼接
s1='hello'
s2='word'
#（1）join()方法拼接
print(''.join([s1,s2]))
#（2）+拼接
print(s1+s2)
#（3）格式化字符串拼接
print('%s%s'%(s1,s2))
print(f'{s1}{s2}')
print('{0}{1}'.format(s1,s2))
#（4）直接拼接
print('hello''word')

3.6  字符串的去重

#字符串去重
s='hellowordhellowordasddk'
#字符串拼接+not in
new_s=''
for item in s:
    if item not in new_s:
        new_s+=item
print('new_s:',new_s)
#字符串索引+not in
new_s1=''
for i in range(len(s)):
    if s[i] not in new_s1:
        new_s1+=s[i]
print('new_s1:',new_s1)
#集合去重
new_s2=set(s)
lst=list(new_s2)
print('new_s2:',''.join(lst))

六、面向对象编程

6.1  类和对象

类：就是一个模板，模板里可以包含多个函数，函数里实现一些功能

对象：根据模板创建的实例，通过实例可以执行类中的函数

1，类的定义

2，成员方法定义

#方法内部：访问成员变量：self.name

#访问外部的变量，直接传入即可

3，创建对象

6.2  __int__()方法

6.3  魔术方法

6.4  封装

2，私有成员

私有成员变量和方法都是以__（两个下划线）开头

#类对象不可访问私有成员，但类其他成员可访问私有成员

6.5  继承

继承：一个类继承另一个类的成员变量和成员方法

语法结构：

class   类(夫类[,父类2,父类3……,父类n]):

        类内容体

子类构建的类对象：有自己的成员变量和成员方法，使用父类的成员变量和成员方法。

单继承：一个类继承另一个类

多继承：一个类继承多个类，按照顺序从左向右依次继承

多继承中，如果父类有同名方法或属性，先继承的优先级高于后继承

6.6  复写

子类继承父类的成员属性和成员方法后，在子类中重新定义同名的属性或方法称为复写。

七、文件读写

打开模式：

模式	描述
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
w	打开一个文件只用于写入。如果该文件已存在则打开文件，并从头开始编辑，原有内容会被删除。如果该文件不存在，创建新文件。
a	打开一个文件用于追加。如果该文件已存在，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。

1，打开文件

内置函数：open()

语法：open(file_name [, access_mode][, buffering])

2，写入文件

使用文件对象方法：file.write(byte)

参数byte：代写入文件的字符串或字节

3，关闭文件

使用文件对象方法：file.close()

#文件处理完以后，都要关闭文件，否则会被一直占用；

4，读取文件

file.read([count])：默认读整个文件。如果设置了参数count，则读取count个字节，返回值为字符串。

#文件读取都是从上次位置开始

file.readline()：从当前位置开始，读取文件中的一行，返回值为字符串。

file.readlines()：从当前位置开始读取文件的所有行，返回值为列表，每行为列表的一项。

5，文件指针：用来记录当前位于指针的那个位置

#read读取文件后再次读取，读取的是空白，因为再次读取时文件指针会指着文件末尾。

#调整指针位置：seek（）

语法结构：file.seek(offset(，whence))

#参数offset：偏远量，字节数

#可选参数whence：指点位置，默认为0（文件头）；1（当前位置），2（文件尾）。

6，注意：file.flush():刷新内容到硬盘

八、异常处理和单元测试

try-except-except-else-finally

#解释器会执行try子句的内容，如果try子句没有发现异常，会执行else子句，然后执行finally语句

try:

        语句块

except (错误类型) as e:

        语句块

except (错误类型) as e:

        语句块

else:

        语句块

finally:

        语句块