[Python知识库]Python知识点汇总

基础知识

标识符：
1.必须以英文字母或者下划线开头
2.标识符其它部分必须由字母，数字下划线组成
3.标识符对大小写敏感

运算符：+，-，*，/，%，**（乘方）

注释：单行注释使用#，多行注释使用三个单引号或者三个双引号

数据类型

1.变量不需要声明，每个变量在使用前必须赋值，赋值之后该变量才会被成功创建
2.变量没有类型，变量就是变量，类型指的是变量所指的内存中对象的类型

counter=100
miles=1000.0
name="runoob"
print(counter)
print(miles)
print(name)


'''
多变量赋值
'''
a=b=c=3
print(a,b,c)
a,b,c=3,4,5
print(a,b,c)

标准数据类型

不可变数据类型：Number(数字)，string(字符串)，Tuple(元组)
可变数据类型：list(列表)，dictionary(字典),set(集合)

Number:数字，支持int,float,bool,complex类型

a,b,c,d=1,2.0,False,4+3j
print(type(a),type(b),type(c),type(d))

字符串

string：字符串，字符串应该用单引号或者双引号括起来，使用’'转义特殊字符，如果不想要反斜杠发生转义，就在字符串前面加一个r，
同时反斜杠可以作为一个续行符，表示是上一行的延续，字符串一旦被赋值，则不能修改

字符串截取：变量名[头下标：尾下标]，0为开始值，-1为末尾开始位置
字符串连接：直接使用加号进行连接

字符串运算：
in/not in：判断指定字符或者字符串是否存在于目标字符串

字符串格式化：print(“%s今年%d岁”%(‘小明’，10))

str="liuyang "
print(str[3:])#yang。输出第四个到最后一个
print(str[3:-1])#yan,输出第四个到倒数第二个
print("%s今年%d岁"%(str,22))

str1='love Fanwenhua'
print(str+str1+"\n")#字符串拼接
print(str+str1+" forever")#拼接形式2

print("liuyang\n")
print(r"liuyang\n")#防止\n被转义

print("liuyang love\
    fanwenhua")#反斜杠作为续行符

列表

list(列表)
1.列表中的元素可以是不相同，它支持数字，字符串，甚至列表（嵌套）
list应该写在方括号中间，元素使用逗号隔开，可以被索引和切片，List中的元素与字符串不同，是可以被改变的

2.列表同样可以被索引和截取，列表被截取后返回一个新列表

3.可以使用’+‘连接两个列表，使用’*'可以重复操作

4.列表中的第三个参数可以用于逆向读取

5.列表中的函数，append,del(删除元素)，使用方法为，del 列表名[下标]

6.列表中提供的方法：reverse,sort,clear,copy…

a=['a','b','c','d']
a.append('e')#增加列表元素
del a[3]#删除列表元素
b=a[:-1]
print(a,b)
c=a+b
print(c)#['a', 'b', 'c', 'd', 'a', 'b', 'c']
print(c*2)#重复输出，['a', 'b', 'c', 'd', 'a', 'b', 'c', 'a', 'b', 'c', 'd', 'a', 'b', 'c']

print(a[::-1])#逆向读取
d=a[::-1]
print(d)

元组

Tuple(元组):与列表类似，但是其中的元素不能被修改，与列表的区别在于，元组使用小括号，列表使用中括号
元组虽然不可变，但是其可以包含可变的对象，如list对象

t1=('a','kl','s','s',3.1415926)
t2=(52,"sjs","liuyang",False)
print(t1+t2)#列表拼接,('a', 'kl', 's', 's', 3.1415926, 52, 'sjs', 'liuyang', False)
print(t1[3])#索引，s
print(t1[:4])#截取，('a', 'kl', 's', 's')

t3=(a,b,c)
print(t3)#包含列表的元组
a[3]="liuyang"
print(t3)#通过改变列表中的值，改变元组

集合

set(集合)：无序的不重复元素集合，基本功能是进行成员关系测试和删除重复元素，可以使用大括号{}或者set()函数创建集合（创建空集合必须使用set()函数，因为使用{}创建的是一个空字典）
集合添加元素：使用 集合名.add(元素)

移除集合中的元素：remove函数

parame={'liuyang','love','fanwenhua','liuyang','abc'}
p2=set("liuyang")#set()函数最多支持一个元素
print(parame)#重复元素自动被去除
parame.remove('abc')
print(p2)

字典

dictionary(字典)：跟map差不多，由key和value组成，key值必须是唯一的，并且key必须是不可变数据类型
使用{}来创建空字典，或者使用dict()创建字典，访问字典的值：使用 字典名[key]

更新字典：
字典名[key]=value

删除元素：del 字典名[key]

dic={'name':"liuyang",'age':20,'add':"sichuan"}
print(dic)
print(dic.keys())#dict_keys(['name', 'age', 'add'])
print(dic.values())#dict_values(['liuyang', 20, 'sichuan'])
dic['sex']='male'#添加元素进入列表
print(dic)#{'name': 'liuyang', 'age': 20, 'add': 'sichuan', 'sex': 'male'}

数据类型转换

Python数据类型转换：1.隐式类型转换 2.显式类型转换（使用类型函数来转换）
隐式转换：python自动将一种数据类型转换为另一种数据类型，两种不同类型进行运算，则自动转换为较高的数据类型以避免数据丢失
但是数字类型和字符串等类型运算，会报错，所以必须使用显式类型转换，使用int（）,float(),str()等预定义函数

num_int=123
num_flo=1.23
new=num_int+num_flo
print(new)#124.23,自动转换成float类型

print(int("3"))#3
print(int(2.8))#向下取整，2

推导式

1.列表推导式：[表达式 for 变量 in 列表]
2.字典推导式：{key:value for value in collection}
…其余推导式类似

name=['liuyang','fanwenhua']
td1=[i for i in range(30) if i%3==0]#[0, 3, 6, 9, 12, 15, 18, 21, 24, 27]
td2=[i for i in t2]#[52, 'sjs', 'liuyang', False]
print(td1)
print(td2)

#字典推导式
dtd={key:len(key) for key in name}
dtd2={key:key for key in parame}
print(dtd,dtd2)

条件控制与循环结构

条件控制：

if condition:
    statement
elif condition2:
    statement
else:
    statement

循环语句：

while 判断条件:
    statement

无限循环：设置判断语句永远为真，使用ctrl+c退出无限循环

while循环使用else语句：当while后面的条件语句为false时，则执行else中的语句块，可以使用break和continue终止或者提前开始
下一次循环

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

for语句：

for variable in sequence:
    statement
else:
    statement

range()函数：当需要遍历数字序列，可以使用range()函数生成数列，如：for i in range(5),range的第三个参数叫做步长
for i in range(0,10,3)#三个参数分别为起始，终止，步长

迭代器与生成器

迭代器：访问集合元素的一种方式，从集合的第一个元素开始访问，直到所有元素被访问完成，迭代器只能往前不能后退
迭代器两个基本方法：iter(),next(),可以为字符串，列表，元组创建迭代器

list=[1,2,3,4,5,6]
it=iter(list)#为list创建迭代器
for i in it:#迭代器对象可以使用for循环进行访问
    print(i,end=' ')#end=用于将输出放到同一行并设置间隔符

list2=[5,3,6,4,7,9]
it2=iter(list2)
print(it2)#<list_iterator object at 0x0000012D1C0DFDF0>,单纯输出迭代器是地址
print(next(it2))#5，使用next(迭代器)可以输出迭代器的下一个元素
print(next(it2))#3
print(next(it2))#6

把一个类作为迭代器，需要在类中实现两个方法，iter(),next()
StopIteration异常用于标识迭代的完成，防止出现无限循环

生成器：使用了yield的函数称为生成器，生成器是一个返回迭代器的函数，只能用于迭代操作（生成器就是一个迭代器）
在调用生成器运行时，每次遇到yield时函数会暂停并保存当前运行信息，返回yield的值，并在下一次执行next()时回到当前位置继续执行

def fibonacci(n):
    a,b,cnt=0,1,0
    while True:
        if (cnt>n):
            return#超过n结束运行
        yield a#返回a的值
        a,b=b,a+b
        cnt+=1

f=fibonacci(10)#f是一个迭代器，由生成器返回生成
while True:
    try:
        print(next(f),end='\t')#遇到next()，回到yield继续执行,0,1,1,2,3,5,8,13,21,34,55,
    except StopIteration:
        sys.exit()

函数

函数代码块必须以def关键字开头，后接函数标识符和圆括号，传入的参数和变量必须放在圆括号中间，圆括号之间可以用于定义参数
函数的第一行语句可以选择性的使用文档字符串存放函数说明
函数内容使用：起始，并且缩进
使用return 表达式结束函数，选择性返回一个值，不带表达式则表示返回一个none

参数：
必须参数：必须参数必须以正确顺序传入函数，调用时的数量必须和声明的一样
关键字参数：使用关键字匹配，调用是不一定需要按照顺序传入参数
默认参数：如果调用函数时没有传递参数，则会使用默认参数
不定长参数:一个函数能够处理比声明时更多的参数，这些参数称为不定长参数，语法格式：def func(变量1，*变量组)，加一个星号的是一个变量组（元组），存放所有未命名的变量参数,它也可以是一个空元组，只要不向它传入参数就可以，加两个星号的参数将会以字典形式导入

匿名函数：
使用lambda函数创建匿名函数，不再使用def声明函数，lambda是一个表达式，不是代码块，只能封装有限的逻辑进去
语法：lambda 参数一，参数二:输出值

def max(a,b):#必须参数
    '''用于比较大小'''
    if a>=b:
        return a
    else:
        return b
print("最大值：",max(b=4,a=9))#关键字参数

def alterlist(a):#可变类型作为参数
    a[3]=20
    print(a)

tlist=[1,5,6,8,3]
alterlist(tlist)
print(tlist)

def chage(a):
    print(id(a))#2175101698288
    a=10
    print(a,id(a))#2175101698576，指向的是一个新对象
num_a=1
print(id(num_a))#2175101698288
chage(num_a)
print(num_a)#1,并没有被改变，所以只能通过函数修改可变类型的变量

def printinfo(name,age=20,*other):#如果没有传入age,则使用默认参数
    print(name,age,other)
printinfo("liuyang",20,30,"djskkws")#liuyang 20 (30, 'djskkws'),可变参数都存放在元组other中

def ttt(age=20,**dictionary):
    print(age,dictionary)
ttt(dtd)#传入字典作为参数（两个星）

sum=lambda a,b:a+b#匿名函数
print(sum(5,6))#11

Python数据结构

列表：
1.列表是可变的，python提供了多种列表的操作方法
2.可以将列表当作栈使用，利用append和pop方法可以实现先进后出，后进先出

a=[1,2,2,5,8,46,8,9,3]
a.append(89)#在a末尾添加89
print(a)#[1, 2, 2, 5, 8, 46, 8, 9, 3, 89]

b=[3.15,3.14,3.12]
a.extend(b)#添加指定列表b来扩充列表a
print(a)#[1, 2, 2, 5, 8, 46, 8, 9, 3, 89, 3.15, 3.14, 3.12]

a.insert(3,2228)#把2228插入到a中下标为3的位置之前
print(a)#[1, 2, 2, 2228, 5, 8, 46, 8, 9, 3, 89, 3.15, 3.14, 3.12]

a.remove(2)#移除a中第一个值为2的元素，如果a中没有这样一个数，则返回一个错误
print(a)#[1, 2, 2228, 5, 8, 46, 8, 9, 3, 89, 3.15, 3.14, 3.12]

c=a.pop()#默认返回最后一个元素，随即在a中移除此元素，还可以指定移除的下标
c=a.pop(3)#弹出下标为3的元素
print(a)#[1, 2, 2228, 8, 46, 8, 9, 3, 89, 3.15, 3.14]

print(a.index(2228))#index用于查找目标数字的下标，2

print(a.count(2))#统计2在列表中出现的次数

a.sort()#对列表进行排序,[1, 2, 3, 3.14, 3.15, 8, 8, 9, 46, 89, 2228]
print(a)

a.reverse()#翻转列表a,[2228, 89, 46, 9, 8, 8, 3.15, 3.14, 3, 2, 1]
print(a)

a.clear()#清空列表a,[]
print(a)

3.遍历技巧，在字典中遍历时，关键字和对应的键值可以使用items()方法同时解读出来,
遍历序列时，可以使用enumerate()同时得到索引位置和对应值
4.想要同时遍历两个序列，可以使用zip()组合
5.反向遍历，指定序列使用reversed()

dic={'name':'liuyang','age':20}
for i,v in dic.items():
    print(i,v)#name liuyang age 20

for i,v in enumerate(a):
    print(i,v)

question=['name','age','home']
ans=['liuyang','22','sichuan']
for q,a in zip(question,ans):
    print("what's your %s?\n%s"%(q,a) )
'''
what's your name?
liuyang
what's your age?
22
what's your home?
sichuan
'''

Python模块

如果从python解释器退出再进入，那么此时定义的方法和变量都消失，为此python允许将这些定义存放在文件夹中，
为一些脚本或者交互式的解释器使用，这个文件夹就被称为模块，模块可以被别的程序引入，以使用该模块中的函数等功能
如：import sys表示引入了python标准库中的sys.py模块

import语句：解释器遇到import语句，如果模块在当前搜索路径则会被导入，如果想要导入模块support,就需要把
命令放在脚本顶端

#Filename:support.py
import support

然后就可以调用其中的函数了
一个模块只会被导入一次

from … import 语句：从模块中导入一个指定的部分到当前命名空间

_name_属性：一个模块被另一个程序引入时，其主程序将会运行。如果想要在模块引入时模块中的某一程序块不执行，我们可以使用_name_属性来使该程序块仅在自身运行时执行，每个模块都有一个_name_属性，当其值为’main’时，表明这个模块正在运行，否则其为正被引入

dir()函数，使用dir()函数可以找到模块内定义的所有名称，返回一个字符串列表

import sys
print(sys.path)#['c:\\Users\\YANG LIU\\Desktop\\python_code', 'C:\\Users\\YANG LIU\\AppData\\Local\\Programs\\Python\\Python310\\python310.zip', 'C:\\Users\\YANG LIU\\AppData\\Local\\Programs\\Python\\Python310\\DLLs', 'C:\\Users\\YANG LIU\\AppData\\Local\\Programs\\Python\\Python310\\lib', 'C:\\Users\\YANG LIU\\AppData\\Local\\Programs\\Python\\Python310', 'C:\\Users\\YANG LIU\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages']

输入输出

输出：str.format(),基本使用：print(‘{}是{}’.format(‘刘洋’，‘大学生’))

输入：使用input函数完成键盘输入
str=input(“请输入：”)

hight=175
print('{}是{}，身高{}cm'.format('刘洋','大学生',175))#新式格式化输出
print("%s是%s,身高%dcm"%('刘洋','大学生',175))#旧式格式化输出

age=input("请输入年龄：")
print("年龄为：",age)

读写文件

**open()**将会返回一个file对象，基本语法格式如下：open(filename,mode)
filename:要打开的文件名称和路径
mode:打开文件的模式，只读，写入，追加（r,rb,r+,rb+,w,wb,w+,a,a+,ab,ab+）,其中w系列模式，原文件存在会清空从头开始写文件
f=open()

文件对象的方法

1.f.read(size):读取一定大小的数据，然后作为字符串或者字节对象返回，size如果忽略或者设置为负数，则将读取全部内容然后返回
2.f.readline():读取文件中单独的一行，若f,readline返回空字符串，说明已经读取到最后一行
3.f.readlines():读取文件中的全部行
4.f.write(string):将string写入到txt文件中，然后返回写入的字符数
5.f.tell():返回文件对象当前所处的位置
6**.f.seek()**:改变当前文件对象的指针位置，f,seek(x,0),0:文件开头往后移动x个字符，1：当前位置往后移动x个字符，2：文件末尾往前移动x个
7.f.close()
8.with open():不需要手动关闭文件

f=open('test.txt')
print(f.read())
f.close()

类和对象

1.类：用来描述具有相同属性和方法的对象的集合
2.方法：类中定义的函数
3.方法重写：父类中的方法无法满足子类需求，可以对其进行改写，此过程称为覆写
4.继承：一个派生类继承基类的字段和方法
5.对象：类的实例化
类定义：

class classname:
    statement
    ...

类对象支持两种操作：属性引用，实例化

在类中，有一个叫做__init__()的特殊方法（构造方法），与其它语言中的构造函数类似，在类的实例化中自动调用
init方法同样可以有参数，参数通过__init__()传递到类的实例化操作上

class person:
    def __init__(self,name,address,age):
        self.n=name
        self.add=address
        self.a=age
    def printinfo(self):
        print("姓名：",self.n)
        print("年龄：{}".format(self.a))
        print("地址：%s"%(self.add))

p1=person("刘洋","四川",30)#使用参数初始化类对象
p1.printinfo()

在类中的函数参数与普通函数参数有所不同，它必须有一个额外的一个参数"self"，一般放在第一个参数位置，self代表的是当前对象的地址,也可以认为代表的是当前实例

class stu:
    def __init__(self):
        age=30
        name="default"
        print('init调用')
    def f(self):
        return 'hello'
x=stu()#init调用
print(x.f())#hello

类的继承

类的派生类定义如下：

class derivedclassname(basename):
    stetement
    ...

子类会继承父类（基类）的所有属性和方法

super函数：用于调用父类的一个方法

类属性与方法：
1.私有属性：__name,两个下划线开头的属性，声明该属性为私有属性，不能在类的外部使用或者直接访问，在类内部使用self.__name进行访问，同理，私有方法，也使用双下划线作为方法名称，只允许在类内部使用
2.类的方法必须包含参数self,并且必须为第一个参数

class p:
    __secretCount=0
    publicCount=23
    def plus(self):
        self.__secretCount+=2
        self.publicCount+=1
    def printinfo(self):
        print(self.__secretCount,self.publicCount)

p4=p()
p4.printinfo()
print(p4.publicCount)
print(p4.__secretCount)#报错，无法访问

单继承

只继承一个基类，比较简单，可以使用super()函数进行继承，或者使用基类名().init

class student(person):#单继承
    def __init__(self, name, address, age,school):
        super().__init__(name, address, age)#python3中直接写super().init表示继承来的
        self.scl=school
p2=student("liuyang","sichaun",30,"sanxia")
p2.printinfo()

多继承

继承多个基类，同时可以进行方法覆写

class title:
    def __init__(self,name,t):
        self.lecture=t
        self.n=name

class multi(student,title):#多继承
    def __init__(self, name, address, age, school,t):
        student.__init__(self,name, address, age, school)#继承的初始化函数
        title.__init__(self,name,t)
    def printinfo(self):#方法重写
        print("我叫{}，今年{}岁，来自{}，毕业于{}，我的演讲题目是{}".format(self.n,self.a,self.add,self.scl,self.lecture))

p3=multi("刘洋","四川",22,"三峡大学","《老人与海》")
p3.printinfo()