python测试（7-8）

1.控制input的输入类型

在python中如果想要求用户在输入时使用特定的数据类型，可以直接在input前加上数据类型

例如：

b = int(input("请输入相关内容："))
print(type(b))

结果：

请输入相关内容：

int

这样input的数据类型就是被设置成为了整型

input如果不做任何的修饰，默认的是字符串str类型

2.range

当数据有很多很多个时，一个一个输入会很麻烦，这时就需要用到range

例如想要打印5000次某个数据，就不用一条一条去写，直接用range:

for c in range(5000):
    print(f"正在执行代码{c}")

这样得到的结果就会从0-4999（从0开始的）

还有一种表示方式：

for c in range(0,5000):
    print(f"正在执行代码{c}")

与切片比较相似，也是取左不取右，0-4999

如果想得到1-5000（都取到）：

for c in range(1,5001):
    print(f"正在执行代码{c}")

range 的形式与切片比较类似

range[start,end,step] step为步长

例如：

or c in range(1,5,2):
    print(f"{c}")
    print(type(c))

结果：

1
<class ‘int’>
3
<class ‘int’>

3.while循环

while和if是一脉相承的，但是在判断条件并进行打印时，满足if只会打印一次，而只要满足while的条件，就会一直打印下去

例如：

a = 18
if a < 19 :
    print('嘻嘻')

a = 18
while a < 19 :
    print('嘻嘻')

if只会打印一遍 嘻嘻 ，而while会一直打印 嘻嘻 ，因为18一直满足小于19的条件

为了阻止while一直打印下去，可以给while里面加条件，所以说while一般都是跟条件的

a = 18
while a < 19 :
    print('嘻嘻')
    a = a+1

这样打印出来的结果就是一边 嘻嘻

因为当18进去后满足条件，进去后加一，于是变成19，19就不符合小于19的这个条件，就会跳出循环

while循环还有一种表示方式：

a = 18
while True :
    print('嘻嘻')
    if a <15:
        break
    a = a-1

该表达式就是说明不管什么条件都能进去，因为恒为True

当不断减小直到小于15时，循环就会停止

4.for循环案例

对列表中的每一个元素进行了相同的的操作

将列表中不同的数据类型全部转化成字符串类型，并且依旧用列表来表示

a = [2,6,'a','8',1]
b =[]
for c in a :
    new_c = str(c)
    b.append(new_c)
print(b)

结果：

[‘2’,‘6’,‘a’,‘8’,‘1’]

因为要用一个列表表示，而且列表里面的数据都是新的，所以要重新定义一个列表b，将列表a中的每一个数据转化成str后，再添加到b中去，最后打印出b

有一种方式更加简便 ，叫做列表推导式：

a = [2,6,3,1]
c = [str(e) for e in a]
print(c)

直接定义一个新的变量c，用列表的形式，前面写想要转变的方式，后面写for循环，最后将其打印出来

如果进行平方操作也是一样

a = [2,6,3,1]
b =[]
for c in a :
    new_c = c*c
    b.append(new_c)
print(b)

[4,36,9,1]

用列表推导式：

a = [2,6,3,1]
c = [e*e for e in a]
print(c)

5.函数

定义一个函数并且调用会方便很多，并且会容易修改

不用函数的缺点：

太繁琐，要不停的粘贴复制

修改麻烦

重复代码

可读性不好

…

例如定义一个洗衣机的系统，但是不使用函数：

print("打开盖子")
print("把衣服放进去")
print("放洗衣粉")
print("关掉盖子")
print("启动")

这些是洗衣的步骤，没有调用函数

如果使用多次，就要复制粘贴多次，所以很繁琐

当使用了多次，代码就有很多的重复

代码很多，当去查看的时候就必须要全部看完才能确定是洗衣服的步骤，所以造成可读性差

当发现代码有问题时，比如洗衣机进行改革，可以省略一些步骤，一个就要删除几步，如果被大量使用，就要一个一个去修改，工程量很大，就造成了修改麻烦

函数的使用包括定义函数和调用函数：

定义函数：

def 函数名称（）：

​ 函数体 #即调用函数时会执行的代码

调用函数：

函数名称（）

def washing():
    print("打开盖子")
    print("把衣服放进去")
    print("放洗衣粉")
    print("关掉盖子")
    print("启动")

washing()
washing()

这就是使用了函数之后的代码

调用的时候也很方便

函数必须先定义后调用

函数的名称定义的规则和变量名称一样，但是函数名在英语中通常是一个动词，而变量名通常是一个名词

6.函数的返回值

具体的一个函数的返回值怎么得到？通过return 后面的值

返回值就是指函数最终得到的结果，而这个结果可以被函数外部接收

def add():
    a = 1+3
    return a
x = add()
print(x)

结果:4

定义一个名为add的函数，return后面的值就是这个函数的返回值，相当于函数最终的结果，用x接收这个结果，并将结果打印出来

如果：

def add():
    a = 1+3
    return 6
x = add()
print(x)

结果：6

因为是用x接收的函数的结果即返回值，而返回值是根据return后面的值来确定，后面是6，所以结果是6

如果：

def add():
    a = 1+3
    
x = add()
print(x)

结果：None

因为没有return,所以就没有返回值，外界得不到，于是就输出None

print和return不冲突：

def add():
    a = 1+3
    print('哈哈')
    return a
x = add()
print(x)

先打印 哈哈 ，后面打印返回值4

易错点：

判断result和a输出结果是否相同：

a = [2,3,4]
result =a.append(5)
print(a)
print(result)

结果：

[2, 3, 4, 5]
None

显然，两者的结果是不相同的，append用法相当于函数，而因为没有return ,所以并没有返回值，只是代表在a中加入5，所以打印result得到的结果是None。在此处经常容易出错，误以为result得到的结果和a一样，实际是不一样的

在一个函数中，return是函数结束的标志，当函数运行到return就会停止

def add():
    a = 1+2
    return a
    print('哈哈哈')

x = add()
print(x)

结果：3

当调用函数add时，返回值为3，遇到return后，函数中return后面的代码就不会再执行了

从上述角度写两个甚至多个return是没有意义的，但是在不同分支中的return就有他的作用：

def add():
    a = 1+2
    if a>4:
        return 6
    else:
        return a

x = add()
print(x)

结果：3

7.函数的参数

如果函数中没有变量，函数里面给定的数据是固定的，当数值发生变化时就不方便，所以会使用到参数

参数包括形参和实参

形参：代表形式参数，在定义时候的变量

实参：代表实际参数，在调用的时候，变量的值

形参和实参是配对的

例如：

def add(b):
    a = 5
    return a+b
print(add(3))

结果：8

上述函数中b为形参，相当于一个变量，值是可以通过实际情况去改变的

a为实参，是a这个变量的值，是不可以在函数外部改变的

如果：

def add():
    a = 5
    return a+b
print(add(3))

或者

def add(a):
    return a+b
print(add(3))

都是会报错的，因为给的变量都不全。第一个，返回a+b，就需要有a和b，而只定义了a,没有b。第二个，只定义了a，没有b

关于位置参数：

def add(a,b):
    return a+b
print(add(3,4))

结果：7

位置参数即函数定义时括号内的参数位置必须与后面调用时一致，a对应3,b对应4，不会说随便对应，并且定义时函数里的参数有多少，调用时的数量就必须要一致，不能多也不能少

def add(a,b,c):
    return a+b
print(add(3,4))

定义时有三个，调用只有两个，所以会报错

def add(a,b,c):
    return a+b
print(add(3,4,9))

结果：7

定义和调用的数量一致，就算c对返回值起不到作用也没有关系，并不会报错

关键字参数：

关键字参数就是在调用函数时，在数据前面加上关键字，代表这个数据的意义。并且这个关键字是形参的名称，如果不是形参的名称就会报错，无法一一对应

def add(a,b):
    return a+b
print(add(a=1,b=1))  #关键字参数

结果：2

他相对于位置参数，对应关系更加明显，位置参数还需要一个个去对应，当数据比较多的时候就会比较麻烦。

如果关键字不是形参的名称：

def add(a,b):
    return a+b
print(add(x=1,b=1))

结果：

因为形参内没有一个名为x的参数，所以会报错

关键字参数里面的参数是可以交换位置的，和位置参数有一定的区别，不需要一个一个去对应，因为关键字参数在调用的时候就已经明确知道了哪个数字对应哪个，而位置参数只能通过位置关系来判断

def add(a,b,c):
    return a+b
print(add(b=1,c=5,a=6))

结果：7

判断以下代码是否会报错：

def add(a,b,c):
    return a+b
print(add(1,c=5,a=6))

结果：

会报错，因为该代码既使用了位置参数又使用了关键字参数。1代表的是a的值，然而后面又对应给了一个a的值，a就有了两个值，就会报错

判断以下代码是否会报错：

def add(a,b,c):
    return a+b
print(add(3,b=4,c=5))

结果：7

该代码和上一个代码一样，既有位置参数又有关键字参数，该地的3就是对应a，也没有别的问题，所以并不会报错，得到的答案为7。

判断以下代码是否会报错：

def add(a,b,c):
    return a+b
print(add(b=3,4,c=5))

结果：

默认参数：

默认参数就是指在定义函数的时候，给指定的形式参数一个默认的值，在函数调用的时候可以不传这个值，在调用的时候也可以对这个参数进行修改

优点：假如在函数定义的时候，参数很多的情况下，在对函数进行定义的时候可以不传那么多参数，使用默认的值。而且在需要对数据进行修改的时候可以直接修改，结果会以修改后的数据为准

判断以下代码：

def add(a=3,b=6):
    return a+b
print(add())

结果：9

a和b用的都是默认参数的数值

def add(a=3,b):
    return a+b
print(add(b=3))

结果：报错

因为在函数定义中，有默认值的参数必须在没有默认参数的后面

在函数定义中，带有默认值的参数必须放在没有默认值的参数之后

def add(a=3,b=10,c=1):
    return a+b
print(add(a=5))

结果：15

因为指定的a的值可以替换掉原来定义时a的默认参数

位置参数在写的时候，必须写在关键字参数和默认参数的前面，不然会报错！

函数的不定长参数：

函数的不定长参数分为两种：位置参数的不定长参数和关键字参数的不定长参数

位置参数的不定长参数一般是在函数进行定义的时候加上*和名称，打印得到的结果是以元组的形式。而关键字参数的的不定长参数是在定义的时候加上**和名称，打印的结果是以字典的形式。不传任何数据就是空元组、空字典

def add(*a,**b):
    print(a)
    print(b)
add()

结果：

()

{}

没有传任何的数据，所以得到的是空元组和空字典

如果既有位置参数的不定长参数又有关键字参数的不定长参数，那么位置参数的不定长参数要放在关键字参数之前，并且在调用的时候，位置参数的不定长参数也要在关键字参数的不定长参数之前

def add(*a,**b):
    print(a)
    print(b)
add(wyj='zhubajie',wmd='dameinv')

结果：

()
{‘wyj’: ‘zhubajie’, ‘wmd’: ‘dameinv’}

def add(*a,**b):
    print(a)
    print(b)
add(1,2,3,4,5,6,wyj='zhubajie',wmd='dameinv')

结果：

(1, 2, 3, 4, 5, 6)
{‘wyj’: ‘zhubajie’, ‘wmd’: ‘dameinv’}

ps:如何写一个函数:

先写函数的名称

在函数体中写入函数运行所需要的代码

考虑函数应该返回什么

考虑参数有哪些，哪些数据是可以变的，而哪些数据是不能变的，能变的可以当作形参，不可变的就做实参