两万字python基础以及部分进阶知识（写python看这个就ok）

Python为我们提供了强大的内置函数和格式化数字的方法去实现进制转换的功能，下面一一介绍。
先将所有的函数罗列出来，如下：

↓ 2进制 8进制 10进制 16进制
2进制 - bin(int(n,8)) bin(int(n,10)) bin(int(n,16))
8进制 oct(int(n,2)) - oct(int(n,10)) oct(int(n,16))
10进制 int(n,2) int(n,8) - int(n,16)
16进制 hex(int(n,2) hex(int(n,8) hex(int(n,10)) -

2进制转换成其他进制：

n=input()
print(oct(int(n,2)))
1
2
输入: 1010
输出: 0o12

n=input()
print(int(n,2))
1
2
输入：1010
输出：10

n=input()
print(hex(int(n,2)))
1
2
输入：1010
输出：0xa

8进制转换成其他进制：

n=input()
print(bin(int(n,8)))
1
2
输入：1010
输出：0b1000001000

n=input()
print(int(n,8))
1
2
输入：1010
输出：520

n=input()
print(hex(int(n,8)))
1
2
输入：1010
输出：0x208

10进制转换成其他进制：
说明：10进制转换可以直接采取上述表格中的形式，读入字符串，先转换为10进制的数，再用函数进行 *** 作转换成其他进制。
但同时可以这样 *** 作，读入的时候直接进行强制类型转换 *** 作，转为int类型(python中的int类型的数据就是10进制)

n=int(input())
print(bin(n))
1
2
输入：10
输出：0b1010

n=int(input())
print(oct(n))
1
2
输入：10
输出：0o12

n=int(input())
print(hex(n))
1
2
输入：10
输出：0xa

16进制转换成其他进制：

n=input()
print(bin(int(n,16)))
1
2
输入：a
输出：0b1010

n=input()
print(oct(int(n,16)))
1
2
输入：a
输出：0o12

n=input()
print((int(n,16)))
1
2
输入：a
输出：10

注意：我们可以发现，除了转换成10进制的数，其他的进制转换结果都带有前缀，2进制是0b，8进制是0o，16进制是0x。但是我们在绝大部分使用进制转换后的数据时，是不需要它的前缀的。所以笔者这里介绍两种方法，去掉它的前缀。

原理：就是将进制转换后得到的结果对其进行字符串切片 *** 作，将得到的结果从第三个字符开始取结果即可，这样我们可以得到不带前缀的结果

举例：

//10进制转换成2进制
n=int(input())
print(bin(n)[2:])//切片 *** 作
1
2
3
输入：10
输出：1010

//10进制转换成8进制
n=int(input())
print(oct(n)[2:])//切片 *** 作
1
2
3
输入：10
输出：12

//10进制转换成16进制
n=int(input())
print(hex(n)[2:])//切片 *** 作
1
2
3
输入：10
输出：a

笔者这里以10进制转换其他进制进行了举例，其他的情况类比即可。

说明：首先，笔者在前面说过，不同类型的进制转换的原理时先转换为十进制，然后再用相关的函数进行禁止转换 *** 作，而format函数里面有格式化数字的方法可以直接实现进制转换的功能，下面一一介绍：

其他类型转换为2进制：
*** 作：在format函数的槽中添加一个b 即可实现其他类型对2进制的转换，下面举例说明

n=input()
print("{:b}".format(int(n,8)))
//先将8进制的数转换为10进制，
//然后在format的槽中添加一个b，等价于实现了bin函数的功能
//但是此结果是不带有0b前缀的

1
2
3
4
5
6
输入：1010
输出：1000001000

其他类型转换为8进制：

*** 作：在format函数的槽中添加一个o 即可实现其他类型对8进制的转换，下面举例说明

n=input()
print("{}".format(int(n,16)))
//先将一个16进制数转换为10进制
//然后利用format函数格式化数字方法转换即可

1
2
3
4
5
输入：a
输出：12

其他类型转换为16进制：
*** 作：在format函数的槽中添加一个x 即可实现其他类型对2进制的转换，下面举例说明

n=input()
print("{:x}".format(int(n,8)))
//先将一个8进制的数转换为16进制
//然后原理同上

1
2
3
4
5
输入：1010
输出：208

注意：由于转换成10进制本来就是不带前缀的，无需用format格式化数字方法控制

以下是 print() 方法的语法:

print(*objects, sep=' ', end='n', file=sys.stdout, flush=False)

• objects – 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。
• sep – 用来间隔多个对象，默认值是一个空格。
• end – 用来设定以什么结尾。默认值是换行符 n，我们可以换成其他字符串。
• file – 要写入的文件对象。
• flush – 输出是否被缓存通常决定于 file，但如果 flush 关键字参数为 True，流会被强制刷新。

range(X,Y,Z)

X到Y 隔z个

for i in  range(9,0,-1):
    print(i)
   9
8
7
6
5
4
3
2
1

是不可运行的 在运行之前就会报错 通常是语法错误

编译失败 不可被处理

可以运行到异常地点 之后报错

可以被处理

被除数为0

1/0
#ZeroDivisionError: division by zero

try 获取异常0

try:
    要执行语句
except 异常类型 as 给异常改名:
    处理异常的语句
else:
    没有遇到异常执行语句
finally:
    无论如何都执行的语句

excent 处理任意异常

as 给异常改名

finally 结束输出

try:
    1/0
except:
    print('分母不能为0')

Exception 处理

try:
    print(111)
    1/0
except Exception:
    print('分母不能为0')

1. 列表超出索引
2. 元组不可改变
3. 字典 key不存在

oprn:打开
open(file,encoding=“编码格式”,)
以什么演的形式打开 读或写 read ,write
r 以读的方式 默认的
w 以写的方式打开
x 创建一个新文件,并以写的方式打开
a 以追加的方式去写
b 二进制方式
t 文本方式 默认的

/ +以读或者写打开一个磁盘

file(*): 文件，路径+文件名
mode(*): 模式
buffering: 保存
encoding(*) 编码  如 UTF-8
errors:  错误处理方式
newline  新行
closefd  关闭文件描述符

fi=open("file.txt",encoding="UTF-8")
da=fi.read()
print(da)
fi.close()

注意

fi=open("file.txt",encoding="UTF-8")
da=fi.read()
da1=fi.read()
print(da)#你好啊
print(da1)# 空  因为已经读到了文章末尾
fi.close()

write

writelines

多行输入

f2.writelines("n".join(["1","2"]))

w 会直接删除 并写入

fa=open("file.txt","w",encoding="UTF-8")
fa2=fa.write("111111")
print(fa2)
fa.close()

a 会追加 并写入

fa=open("file.txt","a",encoding="UTF-8")
fa2=fa.write("2222")
print(fa2)
fa.close()

/ + 加号不可以单独使用

f1=open("1.png","rb")
F1=f1.read()
f2=open("6.png","wb")
f2.write(F1)
f2.close()
f1.close()

或者

f1=open("1.png","rb")
F1=f1.read()
with open("5.png","wb") as  f2:
    f2.write(F1)
    f2.close()
 f1.close()

read 读取全部

read(n) /*读取n个字节

readline() //读取一行

readlines()//读取所有行

readlines(n) 根据字节读取整行 且第二次读取从下一行开始

#如 第一行有6个 字节第二行有8个 字节
#n=8则读取了两行 小于等于6+1则只有第一行
f1=open("file.txt","rb")
F1=f1.readlines(8)
print(F1)#[b'222210rn', b'22221022rn']
f1.close()

间接用

import python2
print(python2.a)

可以直接用

from python2 import a
print(a)

导入*

from python2 import *

获取除了下划线开头的所有属性

(无空格)

一个模块被另一个程序第一次引入时，其主程序将运行。如果我们想在模块被引入时，模块中的某一程序块不执行，我们可以用_ _name__属性来使该程序块仅在该模块自身运行时执行。

#!/usr/bin/python3
# Filename: using_name.py

if __name__ == '__main__':
   print('程序自身在运行')
else:
   print('我来自另一模块')

使用 os

import os

xxx=input("XXXXX")

读取到一定是字符串，如果想使用实际数据类型，需要做类型转换

int(), float(), tuple(), list()

print("XXXX","SSSS")#屏幕输出
print("XXXX","file.txt")#文件内输出

占位符号

%d:digit 整形

%f:float 浮点型

%s: string 字符串

date=1
date1=1.1
date2="11"
print("date is %d,date2 is %.1f,date2 is %s"%(date,date1,date2))
#date is 1,date2 is 1.1,date2 is 11

固定输出占位

%4d 右对齐 占4位

%-4d 左对齐 占4位

%8.4f 右对齐 占8位 有效数字小数后4位

%+10d 右对齐 占10位输出带加号

date=1
date1=1.1
date2="11"
print(f"date is {date},date2 is {date1},date2 is {date2}")
#date is 1,date2 is 1.1,date2 is 11

{date:4} 占4位右对齐 默认等同{date:>4}

{date:<4} 占4位左对齐

{date:^4} 占4位中间对齐

{date:*^4}占4位中间对齐 空白用 * 号填充 此处星号可变为单字符

{date:x^4}占4位中间对齐 空白用 x 填充

date = ["张三", 20, "西安的"]
print("姓名：{a},年龄：{b},家庭地址:{c}".format(a=date[1],b=date[1],c=date[2]))#姓名：20,年龄：西安的,家庭地址:张三

注 此处date 为变量名 可灵活改变

a. 使用切片倒序输出
b. 使用切片取出偶数的数字
c. 使用切片取出奇数的数字
d. 取出后5位字符

s = "123456789"
print(s[::-1])#987654321
print(s[::2])#13579
print(s[1::2])#2468
print(s[-5:])#56789

x::y

从x开始 每隔y个获取 x默认为0 y默认为1

字符串小写

str="aBcD"
print(str.lower())#abcd

字符串大写

str="aBcD"
print(str.upper())#ABCD

首字母大写

str="aBcD"
print(str.capitalize())#Abcd

str="aBcD"
print(str.center(10,"*"))#占位居中对齐填充***aBcD***
print(str.ljust(10,"*"))#占位左对齐填充aBcD******
print(str.rjust(10,"*"))#占位右对齐填充******aBcD

字符串中某字符个数

str="aBcD"
print(str.count("a"))#1

字符串中从第二个字符以后某字符个数

str="aBcD"
print(str.count("a",2))#0
print(str.count("c",2))#1

获取字符创的长度

str="aBcD"
print(len(str))#4

获取字符串下标为1的字符

str="aBcD"
print(str[1])#B

字符串是否以什么什么结尾的

str="aBcD"
print(str.endswith("D"))#True

去除末尾的字符或者特定符号

str="aBcD"
print(str.rstrip("cD"))#aB

把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次.

str="zzsaixuexi"
print(str.replace('z','a',1))#azsaixuexi

date = ["王五五五五五五五五", 280, "山西的老百姓"]
print("{},{},{}".format(date[0],date[1],date[2])) #传入参数格式化输出
print("{1},{0},{2}".format(date[0],date[1],date[2])) #按照下标顺序输入

结果

王五五五五五五五五,280,山西的老百姓
280,王五五五五五五五五,山西的老百姓

把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次.

str="zzsaixuexi"
print(str.replace('z','a',1))#azsaixuexi

join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串。

srg=["ZZS","AI","XUEXI"]
str = "-";
print(str.join(srg))

如果字符串只包含数字则返回 True 否则返回 False。

str="zzsaixuexi"
print(str.isdigit())#False

如果字符串至少有一个字符并且所有字符都是字母则返回 True，否则返回 False。

str="zzsaixuexi"
print(str.isalpha())#True

如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False

str="zzsaixuexi"
print(str.isalnum())#True

返回移除字符串头尾指定的字符生成的新字符串。

str = "00000003210ZZSAXX01230000000";
print(str.strip('0'))  # 去除首尾字符 0
#3210ZZSAXX0123
str2 = "   ZZSAIXX      "  # 去除首尾空格
print(str2.strip())
#ZZSAIXX

参数
str – 分隔符，默认为所有的空字符，包括空格、换行(n)、制表符(t)等。
num – 分割次数。默认为 -1, 即分隔所有。
返回值
返回分割后的字符串列表。

str = "Line1-abcdef nLine2-abc nLine4-abcd"
print(str)
print(str.split( ))     # 以空格为分隔符，包含 n
print(str.split(' ', 1 ))# 以空格为分隔符，分隔成两个

結果

Line1-abcdef 
Line2-abc 
Line4-abcd
['Line1-abcdef', 'Line2-abc', 'Line4-abcd']
['Line1-abcdef', 'nLine2-abc nLine4-abcd']

参数
keepends – 在输出结果里是否保留换行符(’r’, ‘rn’, n’)，默认为 False，不包含换行符，如果为 True，则保留换行符。
返回值
返回一个包含各行作为元素的列表。

print(str2.strip())
str1 = 'ab cnde fgnkl'
print(str1)
print(str1.splitlines())
print(str1.splitlines(True))

结果

ab c
de fg
kl
['ab c', 'de fg', 'kl']
['ab cn', 'de fgn', 'kl']

无返回值

def print_123():#定义函数
    print("123")
print_123()#调用函数 输出123

一个返回值

def jiachen(A):
    return A+1,A+2
print(jiachen(1),type(jiachen(1)))#2 
date,date1=jiachen(1)
print(date,date1)#2 3

多个返回值

返回时候用逗号隔开

def jiachen1(A):
    return A+1
print(jiachen1(1),type(jiachen1(1)))#(2, 3) 

定义函数时候用到的定义参数

真正运行时候用到的参数

def zzs(arg,arg1=1):
    print(arg,arg1)
zzs(1)#11
zzs(1,2)#11

有默认值的调用时候可以只输入没默认值的

如果输入默认值的默认值会更换

默认值参数需要放后面

因为数要根据位置去匹配

也可以通过调用时候输入来确定

def zzs(arg,arg1=1,arg2=1):
    print(arg,arg1,arg2)
zzs(arg1=2,arg=1,arg2=5)

会按照输入参数来确定输入

一个或者多个参数 aegs 名字可以改 重点是星号

def zzs(arg,*args):
    print(arg,*args )#1 2 3 4 5
    print(args,type(args))#(2, 3, 4, 5) 
	#	print(type(*args)) 会报错 因为他是多个数
zzs(1,2,3,4,5)

一个或者多个关键字参数

一言概之，*主要使用在函数参数中，在定义函数中添加是为了在调用该函数时直接将多个参数转换成一个元组，而在调用函数时参数添加，是为了将列表/元组转化成多个参数。

也主要使用在函数参数中，在定义函数中添加是为了在调用该函数时可以添加任意个键值对转出一个字典，而在调用函数时在列表中添加，是为了将字典转化成多个参数。

如例子：

def func1(*a):
	print(a)
	
def func2(**b):
	print(b)
func1(1,2,3,4,5)			#这样可以将多个参数变成一个元组
func2(name='mr',age='22')	#这样可以将多个键值对变成一个字典
	
def f1(a,b,c):
	print(a)
def f2(name,age,sex):
	print(name)
l = [1,2,3]
d = {"name":'mr',"age":22,"sex":'boy'}
f1(*l)						#将列表、元组变成多个参数`
`f2(**d)						#将字典转成赋值参数，name='mr',age=22,sex='boy'`

func1(*l)					#先将参数转成多个参数，在函数参数中又转成元组`		
func2(**d)					#先将参数转成多个键值对，在函数参数中又转成字典`

结果：

(1, 2, 3, 4, 5)
{'age': '22', 'name': 'mr'}
1
mr
(1, 2, 3)
{'age': 22, 'sex': 'boy', 'name': 'mr'}

作用 在它之前的参数只能以位置参数形式传入

def hunhe(X1,Y1,/,X=None,Y=None):
    return X1,Y1,X,Y
print(hunhe(X1=1,Y1=2,X=3,Y=2))
#报错因为x1y1不是以位置参数传入的

作用 在它之后的参数只能以关键字参数形式传入

def hunhe(*,X1,Y1,X=None,Y=None):
    return X1,Y1,X,Y
print(hunhe(X1=1,Y1=2,X=3,Y=2))#（1,2,3,4）
print(hunhe(1,2,3,4))#报错

def print_123():
    print("123")
print_123()#调用函数 输出123
PPPP=print_123 #获取函数
PPPP()#调用函数 输出123

def outer():
    def inner():
        print("inner")
    print("outer")
    return inner()
outer()
#outer
#inner

函数自身调用自身

累加

def num(N):
    if N==1:
        return 1
    else:
        return num(N-1)+N
print(num(100))#5050

class 类名:

注意 类名 尽量使用驼峰命名 单词首字符大写

class Person:
    name="张三"
    age=18
    gender="男"
    def  test():
        print("this is test")
    pass

定义在 初始化类 _ init_ 中

注 外部的是类变量 如果一个修改了 就全修改了需要实例化

class Person:
    def __init__(self,name,age,gender):
        self.name=name
        self.agr=age
        self.gender=gender
    def  print(self):
        return self.name,self.agr,self.gender
student1=Person("li",18,"男")
student2=Person("si",18,"nv")
print(student1.print())#('li', 18, '男')
print(student2.print())#('si', 18, 'nv')

实例化前

class delivery:
    location="beixin"
    def __init__(self, id, from1, to, type):
        self.id=id
        self.from1 = from1
        self.to=to
        self.type = type
    pass
kuaiid1=delivery
kuaiid2=delivery
kuaiid1.location=2
print(kuaiid1.location)#2
print(kuaiid2.location)#2

实例化后

class delivery:
    location="beixin"
    def __init__(self, id, from1, to, type):
        self.id=id
        self.from1 = from1
        self.to=to
        self.type = type
kuaiid1=delivery(1,1,1,1)#实例化
kuaiid2=delivery
kuaiid1.location=2
print(kuaiid1.location)#2
print(kuaiid2.location)#beixin

若实例化后 无对象类变量继续修改实例化类变量类变量不会改变

但是修改其他的类变量 实例化类变量类变量也会改变

kuaiid1=delivery(1,1,1,1)
kuaiid2=delivery
kuaiid1.location=2
print(kuaiid1.location)#2
print(kuaiid2.location)#beixin

修改未实例化的类变量

kuaiid1=delivery(1,1,1,1)
kuaiid2=delivery
kuaiid2.location=2
print(kuaiid1.location)#2
print(kuaiid2.location)#2

父类默认为object

class delivery(object):
    pass

寻找父类方法

suber(A，c)

从A类之后开始寻找

具体百度

在类中实现私有和不被继承

_name 即外部人直接调用时候 用 . . 不出来

但是如果全拼的时候还是可以找到的

_ _funt()

双下划线方法 被调用时候 会被改名为类名加_ _funt()

达到不被调用效果 但是全拼还是可以调用的

注：python中没有私有的概念：这是约定的东西 是希望可以遵守

date=1
def txt():
    date=2
    print(date)#2
print(date)#1
txt()
print(date)#1

@ 叫语法糖

def decorate(text):
    def innter():
        print("内部1")
        text()
        print("内部2")
    return innter
@decorate
def fund():
    print("东西")

fund()

下面更无敌 上面的不可传参数

def decorate(text):
    def innter(*args,**kwargs):
        print("内部1")
        text(*args,**kwargs)
        print("内部2")
    return innter
@decorate
def fund(i):
    print(f"东西{i}")

fund(1)

存储1到10的平方

原方法

list=[]
for i in range(1,11):
    list.append(i**2)
print(list)

推导式方法

list=[i**2 for i in range(1,11)]
print(list)

结果相同都为

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

将两个列表所有组合方式输出

原方法

color=['red','blue','black']
size=['S','m','L']
for i in color:
    for j in size:
        print(i,j,end=" ")

结果

red S red m red L blue S blue m blue L black S black m black L 

推导式

color=['red','blue','black']
size=['S','m','L']

list=[(i,j) for i in color for j in size]
print(list)

结果

[('red', 'S'), ('red', 'm'), ('red', 'L'), ('blue', 'S'), ('blue', 'm'), ('blue', 'L'), ('black', 'S'), ('black', 'm'), ('black', 'L')]

输出10以内奇数

原方法

list=[]
for i in range(1,11):
    if i%2!=0:
        list.append(i)
print(list)

推导式

list=[i for i in range(1,11) if i%2!=0]
print(list)

结果都为

[1, 3, 5, 7, 9]

10以内平方大于10的数

list1=[i for i in range(1,11) if i*i>10]
print(list1)#[4, 5, 6, 7, 8, 9, 10]

获取10以内数 且偶数变为0

list=[i  if i%2 else 0  for i in range(1,11)   ]
print(list)

结果

[1, 0, 3, 0, 5, 0, 7, 0, 9, 0]

获取10以内 key对应的 valus为key’平平方

data={i:i*i for i in range(1,11)}
print(data)

结果

{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81, 10: 100}

导入包 re

import re
str="abc"
str2="abc"
bool=re.fullmatch(str,str2)#是否相同
str3="abcssabcabcabcabcabcabcabc"
bool2=re.findall(str,str3)##返回所有的str   #['abc', 'abc', 'abc', 'abc', 'abc', 'abc', 'abc', 'abc']
str4=".a..."#匹配字符
str5="sasaa"
print(re.match(str4,str5))