一、输出

打印函数需要输出函数：下面介绍python中常见输出函数

1. print()函数，作用：直接把信息打印到控制台，变量之间适用括号隔开（添加空格），自动换行
保留固定小数位的方法

num = 1.2345
print('%.2f'%num)
#保留小数点后2位

2. format函数，适用于规范化格式：
示例：

name = "John"
age = 30
print("My name is {} and I am {} years old.".format(name, age))

输出为：

My name is John and I am 30 years old.

对于format函数保留小数的方式（两位小数）

print('{:.2f}'.format(num))

3. f-strings函数，相较于format更简洁的规范化输出
 

name = "John"
age = 30
print(f"My name is {name} and I am {age} years old.")

输出为

My name is John and I am 30 years old.

{}内你前面设置的变量
4.

sys.stdout.write("Hello, World!")

在使用这个函数之前需要导入sys库，此函数相对于print函数不会添加换行符

对于精度控制总结下来大概就是使用m.n的形式，前面的m代表控制宽度，后面的.n代表精度，会进行小数的四舍五入，小数点也算一位宽度

二、%以及其它运算符

 python中的取余操作不同于我们的认知，它属于模运算，每当做运算两个数符号不一样的时候，结果是不同于C++的

#这是一段python代码示例
def main():
    print(-7 % 5)
    print(7 % -5)
    print(7 % 5)
    print(-7 % -5)


if __name__ == '__main__':
    main()

#运行结果为
3
-3
2
-2

正常的结果应该是-2 2 2 -2
在python中想要计算正确的结果可以使用-abs
如下所示
 

def main():
    # 对于被取余的数是负数，取余的数为正数，使用
    print(-(abs(-7) % 5))
    # 对于取余的数为正数，使用
    print(7 % abs(-5))
    # 通过判断语句
    a = -7
    b = 5
    c = 7
    d = -5
    if a < 0 and b > 0:
        print(-(abs(a) % b))
    if c > 0 and d < 0:
        print(c % abs(d))


if __name__ == '__main__':
    main()

结果如下

-2
2
-2
2

而对于python中的divmod函数，其取余运算依然是模运算
 

def main():
    a, b = divmod(7, 5)
    print(a, b)
    a, b = divmod(-7, 5)
    print(a, b)
    a, b = divmod(7, -5)
    print(a, b)
    a, b = divmod(-7, -5)
    print(a, b)



if __name__ == '__main__':
    main()

结果为

1 2
-2 3
-2 -3
1 -2

实例：
 

请编写一个简单程序，用户输入2组整型数据存储在变量中，并输出两组数相除的余数。

def main():
    #code here
    user_input = input()
    num1,num2 = map(int,user_input.split())
    User_input = input()
    num3,num4 = map(int,User_input.split())
    if num1*num2 > 0:
        print(f"{num1}%{num2}={num1%num2}")
    elif num1<0:
        print(f"{num1}%{num2}={-(abs(num1)%num2)}")
    else :
        print(f"{num1}%{num2}={num1%abs(num2)}")

    if num3*num4 > 0:
        print(f"{num3}%{num4}={num3%num4}")
    elif num3<0:
        print(f"{num3}%{num4}={-(abs(num3)%num4)}")
    else :
        print(f"{num3}%{num4}={num3%abs(num4)}")
    
    pass


if __name__ == '__main__':
    main();

欢迎留言python中正确的取余方法
运算符
 

运算符	描述	示例
+	简单加法
-	简单减法
*	简单乘法
//	取整除，返回结果的整数部分
**	指数运算	2**4 = 16

其它赋值运算符 

+=	自加	a+=b ->a=a+b
-=	自减	a-=b ->a=a-b
*=	自乘	a*=b ->a=a*b
/=	自除	a/=b ->a=a/b
%=	自取余	a%=b ->a=a%b
**=	自幂运算	a**=b ->a=a**b
//=	取整	a//=b ->a=a//b

&	按位与	对应二进制位都为1，结果为1，否则为0
|	按位或	对应二进制位有一个为1，结果为1，否则为0
^	按位异或	对应二进制位不同为1，否则为0
~	按位取反	对应二进制位由1->0,0->1
<<	左移	对应二进制位向左移，高位丢弃，低位补0
>>	右移	对应二进制位向右移，低位丢弃，高位补0

and	相当于&&	都成立才成立
or	相当于||	一个成立就成立
not	相当于否	非

in	在...里面	找到为True，否则为False
not in	不在...里面	没找到为True

三、注释
 

 python中的注释分为单行注释和多行注释对程序代码进行解释说明
单行注释
使用#开头，#右边的所有文字均为注释

# 单行注释，通常在#与注释文字之间用一个空格隔开，不隔也没有关系，警告罢了

 多行注释：
以一对三引号引起来的内容，支持换行
 

'''
多行注释
'''

注释的快捷键
ctrl  + /
可以把你所选的文字都进行注释

此时使用ctrl + /就会把所有文字都注释了

四、输入 

 对于python的输入，我们大多数使用的是input函数
对于input语句的用法
1.会暂停程序，等待你输入内容，按回车后输入结束，程序继续运行
2.自身可以给出提示
 

name = input("我的账号是：")
#这里会先打印出input内的内容
print(name)
#这里打印你的输出

我的账号是：wjm041006
wjm041006

3.input函数的返回值是str字符串

name = input("我的账号是：")
#这里会先打印出input内的内容
print("你账号的类型是:",type(name))
#这里打印你的输出

我的账号是：123
你账号的类型是: <class 'str'>
#可以看到你输入数字，这个返回值类型依然是字符串

五、判断语句

 布尔类型：True and False
True代表1，False代表0

bool_1 = True
bool_2 = False
print("bool_1 的类型是",type(bool_1))
print("bool_2 的类型是",type(bool_2))

bool_1 的类型是 <class 'bool'>
bool_2 的类型是 <class 'bool'>

我们大多数时候通过比较运算符来得到布尔量
六个比较运算符分别是：==，!=, > , < ,>=, <=

if 语句的基本形式

if 条件：
    条件成立时执行

条件的结果为布尔类型，if条件成立时执行的为下面的代码块，可以有多个语句，注意缩进
if else 语句

if 条件:
    条件成立执行的代码
else:
    条件不成立时执行的代码

if elif else语句

if 条件1:
    条件1成立执行的代码
elif 条件2:
    条件1不成立，条件2成立执行的代码
else:
    条件1，2都不成立执行的代码

中间的elif可以有多个，python从上到下依此去判断（即判断时互斥且有序的），else可以省略不写
判断语句的嵌套使用

if 条件1:
    条件1成立时执行
    if 条件2:
        条件2成立时执行
#当第一个条件成立时执行条件1下面的代码，而条件2判断语句在条件1成立执行的代码中
#故有当条件1和条件2都成立时才执行条件2下面的代码

同时else 和 elif 也要和所对应的if保持一致的缩进

六、循环语句

 while循环的基础语法
条件的结果为布尔类型（True，Flase）

#条件为真执行下面的工作，执行过后再次判断条件，直到条件为假
while 条件:
    条件满足时的工作

'''这里给读者一个实际案例吧'''
dianzan = 10

while dianzan:
    dianzan -= 1
    print("我的账号是wjm041006")

运行结果如下 

我的账号是wjm041006
我的账号是wjm041006
我的账号是wjm041006
我的账号是wjm041006
我的账号是wjm041006
我的账号是wjm041006
我的账号是wjm041006
我的账号是wjm041006
我的账号是wjm041006
我的账号是wjm041006

note：如果不设置终止条件，程序就会一直运行下去。例如 while True:
while循环的嵌套，无非就是在while循环中加入while循环

while 条件1：
    事情1
    事情2
    while 条件2：
        事情3

while循环中的条件自定义
for循环：是对内容进行挨个处理，当内容遍历完成后，循环结束

for 临时变量 in 待处理内容:
    循环满足条件执行代码

下面举一个例子

zhanghao = "wjm041006"
for w in zhanghao:
    print(w)

结果为

w
j
m
0
4
1
0
0
6

note: 可以注意到，for循环中的条件我们无法定义，只能从内容中逐个取出条件
range函数：功能：生成一个简单的数字序列
例如
1.range(num)生成一个从0开始到num的序列（不包含num）
2.range(num1,num2)获取一个从num1开始到num2结束的数字序列
note ：不包含num2
3.range(num1,num2,step)
获取一个从num1开始到num2结束每隔step取一个数的序列
最后一个给出示例

for wjm041006 in range(10,20,2):
    print(wjm041006)

结果为
10
12
14
16
18

note:理论上在循环外部也可以访问内部的临时变量，但不规范，建议在循环之前就定义好临时变量
for循环的嵌套和while循环的嵌套相差不大，这里不做介绍
接下来介绍两个关键字：break和continue
continue:中断本次循环，直接进入下一轮

for wjm041006 in range(10,20,2):
    if wjm041006 == 14:
        continue
    print(wjm041006)

10
12
16
18

break:跳出循环，使循环结束：

for wjm041006 in range(10,20,2):
    if wjm041006 == 14:
        break
    print(wjm041006)

10
12

七、文件

 1.文件编码：

文本内容通过编码技术将内容翻译为0和1存入
对于不同的编码技术，对于相同内容编译出来的内容不同
目前最常用的编码UTF-8，电脑也默认为UTF-8

2.文件定义

操作系统以文件为单位管理磁盘中的数据，文本文件，图像文件，视频文件。。。
对文件进行操作包含打开，关闭，读，写等
在python中对文件进行操作：打开->读写->关闭

2.1文件打开和关闭

在python中，使用open函数可以打开一个已经存在的文件，或者创建一个新文件
格式为 open(name,mode,encoding)
name:要打开目标文件名的字符串（可以包含文件所在的具体路径）
mode:设置打开的文件模式
encoding:编码格式
#encoding 的顺序不是第三位，所以不能使用位置参数，用关键字参数直接指定
关于mode的介绍
1.'r' 模式，只读文件，文件指针放在开头
2.'w' 模式，用于写入文件，文件不存在，创建新文件，如果文件存在，从开头开始编辑文件内容，原有内容会被删除
3.'a' 模式，打开一个文件用于追加，新的内容将会被写入已有内容之后，可创建新文件

关于name的介绍
1.如果和python.py文件在同一个目录下，那么可以直接使用文件名
2.如果和python.py文件不在同一个目录下，那么应该使用文件绝对路径

在文件打开的时候，注意到我们无法删除和重命名文件
文件关闭：
方法1：在想要关闭文件的时候使用：文件对象.close()
方法2：with open()  as 文件对象 当执行完成with下面的语句后，就很关闭文件
 

2.2文件方法

1.文件对象.read(num)方法，num表示从文件中读取数据的长度,如果没有传入num，就表示读取所有数据，如果两次读取的话，第二次read会从第一次读取结束的位置开始
2.文件对象.readlines()方法，可以按照行的方式把整个文件中的内容进行一次性读取，并返回一个列表，其中每一行的数据为一个元素
note：实际上就是指针的问题，每一次读取都是从上一次读到的尾部开始

for循环读取文件行：

for wjm in 你的文件对象:
    print(wjm)

2.3 文件的写出与追加

1.写出

关于写的方法：注意打开的时候需要用'w'，
文件写入使用 
 文件对象.write(写入内容)，这个是写入内存中
 文件对象.flash()，这是将内容写到硬盘中
顺序为 open->write->flash
note；close内置flash功能，当你close的时候，会将内存中的内容写到硬盘中

2.追加

与上述写出方法基本一致，只不过是w被替换为a

八、函数

一、函数入门

函数：可重复使用的具有特定功能的代码块
python中存在内置函数，可以直接使用：比如
input，len，print等等
python中也自己定义函数
函数定义：关键字：def
形式为

def 函数名(参数):
    函数体(所要实现的功能)
    return 返回值

这是一个简单的示例 ：

def len_wjm(string_wjm):
    count = 0
    for wjm in string_wjm:
        count+=1
    print(count)
'''这个函数实现了字符串长度的计算'''
#这个是使用
len_wjm('wjm041006')

输出结果为9
note:先定义函数，才能调用函数，参数可以省略，返回值可以省略
函数的参数：函数运行时候，从外界接收的数据
例如：

def add_wjm(wjm,wjm_1):
    print(wjm + wjm_1)
'''这个函数实现加法运算'''
#这个是使用
len_add(1,2)

 输出结果为3
函数返回值：函数可以使用return关键字将函数运行中的部分内容返回
 

def add_wjm(wjm,wjm_1):
    return wjm + wjm_1
'''这个函数实现加法运算'''
#这个是使用
wjm = add_wjm(1,2)
print(wjm)
#这个的输出结果为3

note：函数体在遇到return后就结束了，不会再运行return后面的代码
如果函数中没有return语句，那么函数默认返回None，代表函数返回空
即不使用return语句也存在返回值
 

def add_wjm(wjm,wjm_1):
    T = wjm + wjm_1
'''这个函数实现加法运算'''
#此时没有使用
wjm = add_wjm(1,2)
print(wjm)
print(type(wjm))
#结果为
#None
#<class 'NoneType'>

有时可以在定义时将None赋值给变量，稍后再做处理

函数的说明文档
使用:param对说明文档进行编辑
 

def add_wjm(wjm,wjm_1):
    '''
    :param 将传入参数相加
    '''
    T = wjm + wjm_1
    return T

#此时没有使用
wjm = add_wjm(1,2)

当把鼠标停留在add_wjm(1,2)时

会在下面显示对文档的说明 
函数的嵌套调用：在一个函数内部调用了另一个函数

def wjm_1():
    print("wjm")
def wjm_2():
    wjm_1()
    print("041006")

wjm_2()

wjm
041006

在函数1中调用函数2，当执行到函数2时，函数1执行暂停，执行函数2，一定会等函数2执行完成，才会继续执行函数1
函数中变量的作用域（变量的作用范围）：局部变量，全局变量
局部变量，当函数执行完成后变量就会销毁，出了函数无法使用
全局变量，在函数内外均可以使用，使用global 变量名即可声明

二、函数进阶

1.函数多返回值

写两个return的时候会默认执行第一个return

def wjm():
    return 1
    return 2

if __name__ == "__main__":
    print(wjm())
'''
结果为
1
'''

多个返回值的正确做法
观察到return后面的值应该用逗号隔开，返回的是一个元组，接收可以使用几个变量用逗号隔开即可

def wjm():
    return 1,2

if __name__ == "__main__":
    print(wjm())
    w,j = wjm()
    print(w)
    print(j)
'''
结果为
(1, 2)
1
2
'''

note：支持各种类型的return

2.函数的各种传参方式

常见四种参数包括：位置参数，关键字参数，缺省参数，不定长参数

1.位置参数

定义：调用函数时根据函数定义的参数位置来传递参数
note:传递参数与定义参数的顺序及个数必须一致

def wjm(w,j,m):
    print(w)
    print(j)
    print(m)

if __name__ == "__main__":
    wjm(1,2,3)
'''
结果为
1
2
3
'''

2.关键字参数

定义：函数调用时候使用 键 = 值 的形式传递参数，这一做法对参数顺序没有要求
就是把形式参数作为key，把实际参数作为value

def wjm(w,j,m):
    print(w)
    print(j)
    print(m)

if __name__ == "__main__":
    wjm(w = 1,m = 2,j = 3)
#这里将就j和m调换了位置，可以看到结果有所不同
'''
结果为
1
3
2
'''

note：位置参数和关键参数可以混用，但是位置参数要放在前面，函数定义和使用时候都是

3.缺省参数

定义：在定义函数时候，为参数提供默认值，调用函数时可不进行该默认参数的传递，如果传递的话，那么就会按照默认参数进行
note：所有位置参数必须出现在默认参数之前，函数使用时对于键值参数没有位置要求

def wjm(w,j,m = 4):
    print(w)
    print(j)
    print(m)

if __name__ == "__main__":
    wjm(w = 1,m = 2,j = 3)
'''
结果为
1
3
2
'''
def wjm_1(w,j,m = 4):
    print(w)
    print(j)
    print(m)

if __name__ == "__main__":
    wjm_1(1,2,3)
'''
结果为
1
2
3
'''

4.不定长参数

位置传递，传递的所有参数都会被收集，形成一个元组，此时的形参为1个*号，一般命名为args

def wjm(*www):
    print(www)

wjm("wjm","041006")
'''
结果为
('wjm', '041006')
'''

关键字传递，利用 键 = 值 的方式，所有的参数都被接收，组成字典，此时的形参为**，一般命名为kwargs，但是我这里就用www了，任性

def wjm(**www):
    print(www)

wjm(w = 20,j = 20,m = 20)
'''
结果为
{'w': 20, 'j': 20, 'm': 20}
'''

3.函数作为参数传递

函数也可以作为参数传递：传递的为一个逻辑

def add(x,y):
    return x+y

def wjm(add):
    print(add(1,2))

wjm(add)

'''
结果为
3
'''

同样的，如果你不是用函数作为参数传递，只是调用也是可以的

def add(x,y):
    return x+y

def wjm():
    print(add(1,2))

wjm()

'''
结果为
3
'''

4.匿名函数

关键字lambda定义匿名函数语法
def定义带有名称的函数，对应的lambda可以定义匿名函数，而匿名函数只可以临时使用一次
语法：

lambda 传入参数:函数体(一行代码)
#note：代码只能写一行，无法写多行代码

def wjm(add):
    print(add(1,2))

wjm(lambda x,y:1+2)

'''
结果为
3
'''

这个的写法无法二次使用，只能应用在这里
它的优势在于简洁