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

这个文章就是放Python笔记的 会有部分与之前文章一样
博主是因为经常有朋友问要笔记所以发的。

Python

list列表

定义格式

a=[1,2,'X']

修改

a[1]=3

添加

append()

会在后面直接插入元素 元素如果是个地址(如列表)，会直接不进行拆分直接添加地址

extend()

会在后面直接插入元素 元素如果是个地址(如列表)，会进行拆分并逐个添加地址内元素

a3=[1,2]
a4=[1,3]
a4.extend(a3)
print(a4)#[1, 3, 1, 2]
a5=[1,5]
a4.append(a5)
print(a4)#[1, 3, 1, 2, [1, 5]]

但是 如内元素内依然有地址则不会拆分

a2=[1,2]
a3=[1,a2]
a4=[1,3]
a4.extend(a3)
a4.extend(a3)
print(a4)#[1, 3, 1, [1, 2]]

删除

pop()

输入角标 删除指定角标处元素

如不输入删除最后一个

a1=[1,2,1,3,1,3]
a1.pop(0)
print(a1)#[2, 1, 3, 1, 3]
a1.pop()
print(a1)#[2, 1, 3, 1]

remove()

删除指定元素 如有多个删除第一个

a2=[1,2,1,3,1,3]
a2.remove(1)
print(a2)[2, 1, 3, 1, 3]

切块

arr[X:Y]获取列表中从x到y(有x无y)中的元素

a1[1:3]

获取地址

id(a1)

复制

直接使用等于获取的是地址

修改列表时原列表也会发生改变

用copy方法获取的是新的指针方向

但是如果列表内嵌套了列表

修改 嵌套内的列表时 原列表也会发生改变

属于浅copy

a3=[1,2]
a4=[1,a3]
print(a4)#[1, [1, 2]]
a5=a4.copy()
a5[1].append(5)
print(a4)#[1, [1, 2, 5]]

使用 deepcopy()方法可进行深copy

即使修改列表内的列表值原列表也不会发生改变

需要导包（from copy import deepcopy）

from copy import deepcopy
a6 = deepcopy(a4)
a6[1].append(3)
print(a6)#[1, [1, 2, 5, 3]]
print(a4)#[1, [1, 2, 5]]

遍历

简单列表
例如

list1=[“a”,“b”,“c”,“d”]

for i in list1:
	print(i)
#1
#2

列表中元素为元组时：
例如

list2=[(“a”,1),(“b”,2),(“c”,3),(“d”,4)]

for x,y in list2:
	print(x,y)

输出为：

a 1

b 2

c 3

d 4

列表中元素为集合时：
例如：

list3=[{“a”,1},{“b”,2},{“c”,3},{“d”,4}]

for x,y in list3:
    print(x,y)

输出为：

1 a

2 b

3 c

4 d

注意：集合中的元素是无序的，所以打印出来也是随机排列的。

列表中的元素为字典时：
例如：

list4=[{“a”:1},{“b”:2},{“c”:3},{“d”:4}]

for x in list4:
    print(x)

输出结果为：

{“a”:1}

{“b”:2}

{“c”:3}

{“d”:4}

方法

population 随机数

random.sample(population, k)

• population：列表
• k：随机返回的个数

reverse()内元素倒置

a1 = [1, 2, 1, 3, 1, 3]
a1.reverse()
print(a1)#[3, 1, 3, 1, 2, 1]

sort 排序

如果元素为数字按数字大小排序

a1 = [1, 2, 1, 3, 1, 3]
a1.sort()#默认等同a1.sort(reverse=False)
print(a1)#[1, 1, 1, 2, 3, 3]
a1 = [1, 2, 1, 3, 1, 3]
a1.sort(reverse=Ture)
print(a1)#[3, 3, 2, 1, 1, 1]

如果元素为字符按字符第一个大小排序顺延

a1 = ['SDS','AC','AAD','ASDASD','SDS']
a1.sort()
print(a1)#['AAD', 'AC', 'ASDASD', 'SDS', 'SDS']

不可数字字符混用

有更加具体的排序请自行搜索 以上只是一部分

count 计数

获取指定字符出现的次数

index 角标索引

获取指定字符第一次出现的位置

index(x,y,z)

获取指定字符x 从y到z区域中第一次出现的位置

a=(1,2,1,1,1)
print(a.count(1))#4
print(a.index(2))#1
print(a.index(1,0,3))#0

字典

定义

用大括号包住

key 对应 元素

a1={1:2,
    3:4}
print(a1)

获取

print(a1[1])#{1:2,3:4}

方法

删除相关

pop()

若无参数则报错

若有会返回对应值

popitem()

删除最后一个元素并返回元素（元组）

a={
    1:2,
    2:5
}
a.pop(1)
print(a)#{2: 5}

a={
    1:2,
    2:5
}
print(a.popitem())#(2, 5)

clear() 删除

删除全部

a={
    1:2,
    2:5
}
a.clear()
print(a)#{}

获取相关

keys()获取钥匙

valus()获取值

get() 获取对应值

通过键获取值 可以防止报错

.get(X,若无返回的值默认none)

a={
    1:2,
    2:5
}
print(a.keys())#dict_keys([1, 2])
print(a.values())#dict_values([2, 5])
print(a.get(3))#None

items()获取

获取字典中所有元素 以元组返回

list() 可以将类似的转换为list

setdefault()获取传入

获取对应值若有则获取若无则传入传入默认为None

setdefault(key,valus)

a={
    1:2,
    2:5
}
print(a.setdefault(3))#None
print(a)#{1: 2, 2: 5, 3: None'}

添加相关

update()

将元素添加入字典

或将其他字典里的元素添加进入

a={
    1:2,
    2:5
}
b={}
b.update(a)
b.update([(5,6),(9,7)])
print(b)#{1: 2, 2: 5, 5: 6, 9: 7}
b[8]=7
print(b)#{1: 2, 2: 5, 5: 6, 9: 7, 8: 7}

b[key]=valus

可以直接添加

集合

定义

无序不重复

b={1,2,3,4,2}
print(b)#{1, 2, 3, 4}

因为无序直接获取会报错

print(b[0])#TypeError: 'set' object is not subscriptable

定义空集合方法

a=set()#空集合
print(a,type(a))#set() <class 'set'>

直接为空是字典

c={}
print(c,type(c))#{} <class 'dict'>

方法

传入相关

add()

b={1,2,3,4,2}
d=(1,2)
e={5:6}
f=[7,8]
b.add(d)#
print(b)#{1, 2, (1, 2), 3, 4}
#传入字典和列表时候会报错

删除相关

clear() 删除

删除全部

discard()

删除一个

fruits = {"apple", "banana", "cherry"}

fruits.discard("banana") 

print(fruits)#{'cherry', 'apple'}

获取相关

update()并集合

实例

把集合 y 中的项目插入集合 x：

x = {"apple", "banana", "cherry"}
y = {fruits = {"apple", "banana", "cherry"}
x.update(y)
print(x)#{'banana', 'google', 'microsoft', 'cherry', 'apple'}

intersection()返回交集

x = {"apple", "banana", "cherry"}
y = {"google", "microsoft", "apple"}

z = x.intersection(y) 

print(z)#{'apple'}

issubest()

如果集合 y 中存在集合 x 中的所有项目，则返回 True：

x = {"a", "b", "c"}
y = {"f", "e", "d", "c", "b", "a"}

z = x.issubset(y) 

print(z)#True

基本运用

字符串去重

S = 'lsdljfjaldfaowioueroiuwoe'
A = set(S)
print(A)#{'d', 'j', 'l', 'w', 'a', 'i', 'e', 'r', 'f', 'o', 'u', 's'}
B = list(A)
print(''.join(A))#djlwaierfous
B.sort(key=S.index)
print(B)#['l', 's', 'd', 'j', 'f', 'a', 'o', 'w', 'i', 'u', 'e', 'r']
print(''.join(B))#lsdjfaowiuer

运算符

Python 在以下组中划分运算符：

• 算术运算符
• 赋值运算符
• 比较运算符
• 逻辑运算符
• 身份运算符
• 成员运算符
• 位运算符

Python 算术运算符

算术运算符与数值一起使用来执行常见的数学运算：

运算符	名称	实例
+	加 add	x + y
-	减 sub	x - y
*	乘 mul	x * y
/	除 floordiv	x / y
%	取模 mod	x % y
**	幂 pow	x ** y
//	地板除（取整除）div	x // y

Python 赋值运算符

赋值运算符用于为变量赋值：

运算符	实例	等同于
=	x = 5	x = 5
+=	x += 3	x = x + 3
-=	x -= 3	x = x - 3
*=	x *= 3	x = x * 3
/=	x /= 3	x = x / 3
%=	x %= 3	x = x % 3
//=	x //= 3	x = x // 3
**=	x **= 3	x = x ** 3
&=	x &= 3	x = x & 3

Python 比较运算符

比较运算符用于比较两个值：

运算符	名称	实例
==	等于 eq	x == y
!=	不等于 ne	x != y
>	大于gt	x > y
<	小于lt	x < y
>=	大于或等于ge	x >= y
<=	小于或等于le	x <= y

Python 逻辑运算符

逻辑运算符用于组合条件语句：

运算符	描述	实例
and	如果两个语句都为真，则返回 True。	x > 3 and x < 10
or	如果其中一个语句为真，则返回 True。	x > 3 or x < 4
not	反转结果，如果结果为 true，则返回 False	not(x > 3 and x < 10)

Python 身份运算符

身份运算符用于比较对象，不是比较它们是否相等，但如果它们实际上是同一个对象，则具有相同的内存位置：

运算符	描述	实例
is	如果两个变量是同一个对象，则返回 true。	x is y
is not	如果两个变量不是同一个对象，则返回 true。	x is not y

Python 成员运算符

成员资格运算符用于测试序列是否在对象中出现：

运算符	描述	实例
in	如果对象中存在具有指定值的序列，则返回 True。	x in y
not in	如果对象中不存在具有指定值的序列，则返回 True。	x not in y

Python 位运算符

位运算符用于比较（二进制）数字：

运算符	描述	实例
&	AND	如果两个位均为 1，则将每个位设为 1。
|	OR	如果两位中的一位为 1，则将每个位设为 1。
^	XOR	如果两个位中只有一位为 1，则将每个位设为 1。
~	NOT	反转所有位。
<<	Zero fill left shift	通过从右侧推入零来向左移动，推掉最左边的位。
>>	Signed right shift	通过从左侧推入最左边的位的副本向右移动，推掉最右边的位。

数据

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进制

2进制转换成其他进制：

2进制转换成8进制：oct(int(n,2))

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

2进制转换成10进制：int(n,2)

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

2进制转换成16进制：hex(int(n,2))

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

8进制

8进制转换成其他进制：

8进制转换成2进制：bin(int(n,8))

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

8进制转换成10进制：int(n,8)

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

8进制转换成16进制：hex(int(n,16))

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

10进制

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

10进制转换成2进制：bin(n)

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

10进制转换成8进制：oct(n)

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

10进制转换成16进制：hex(n)

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

16进制

16进制转换成其他进制：

16进制转换成2进制：bin(int(n,16))

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

16进制转换成8进制：oct(int(n,16))

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

16进制转换成10进制：int(n,16)

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函数进行格式化数字操作

说明：首先，笔者在前面说过，不同类型的进制转换的原理时先转换为十进制，然后再用相关的函数进行禁止转换操作，而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格式化数字方法控制

方法

python格式化输出内容

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

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

参数

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

range

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

错误与异常

错误

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

编译失败 不可被处理

异常

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

可以被处理

例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 读取全部

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'222210\r\n', b'22221022\r\n']
f1.close()

模块

导入全部

间接用

import python2
print(python2.a)

导入局部

可以直接用

from python2 import a
print(a)

导入*

from python2 import *

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

主运行

_ name_

(无空格)

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

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

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

os

语法

使用 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

lower

字符串小写

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

upper

字符串大写

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

capitalize

首字母大写

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

对齐方式

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

count

字符串中某字符个数

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

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

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

len

获取字符创的长度

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

字符串下标

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

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

endswith

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

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

rstrip

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

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

replace

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

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

format

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

结果

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

replace(self, old, new, count=-1, /)

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

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

join(self, iterable, /)

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

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

isdigit

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

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

isalpha

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

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

isalnum

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

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

strip

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

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

split

参数
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']

splitlines

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

print(str2.strip())
str1 = 'ab c\nde fg\nkl'
print(str1)
print(str1.splitlines())
print(str1.splitlines(True))

结果

ab c
de fg
kl
['ab c', 'de fg', 'kl']
['ab c\n', 'de fg\n', 'kl']

函数

语法

定义

无返回值

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

一个返回值

def jiachen(A):
    return A+1,A+2
print(jiachen(1),type(jiachen(1)))#2 <class 'int'>
date,date1=jiachen(1)
print(date,date1)#2 3

多个返回值

返回时候用逗号隔开

def jiachen1(A):
    return A+1
print(jiachen1(1),type(jiachen1(1)))#(2, 3) <class 'tuple'>

形参

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

实参

真正运行时候用到的参数

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)

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

特殊参数

*args

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

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

**kwargs

一个或者多个关键字参数

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

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

如例子：

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()

寻找父类方法

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))