python学习5

原创不让过？？？

一、函数

把可以重复使用的代码标记起来，当需要使用时把标记进行调用。

不多说

1.1 python中的函数

• 内置函数

• 标准库函数

• 第三方库函数

• 用户自定义函数

1.2 python中函数的定义与调用

1.2.1 函数的定义

语法：

def 函数名():
	函数体...

def 函数名(形参1,形参2,...):
	函数体...
	
def 函数名(形参1,形参2,...):
	函数体...
	return 值

1.2.2 函数的调用

语法

函数名()
函数名( 参数1，)

return 后马上结束

形参和实参

• 形参：函数内的参数

• 实参：传进函数的参数

命名参数
在函数调用时，实际参数根据形式参数命名进行传递
例：

def _sum(x,y)
_sum(y=200,x=100)

默认参数
函数定义时，形参可以设置默认值，这样在调用时就是可选。
注意默认值都是形式参数列表的最后

练习：

输入两个数进行比较，打印较大的数的值

# 函数实现输入两数，打印大数
def compare(x,y):
    print("比较大的数是",end=" ")
    if x>y:
        print('x='+str(x))
    elif y>x:
        print('y=:'+str(y))
    else:
        print('x=y')
while True:
    x=int(input("x: "))
    y=int(input("y: "))
    compare(x,y)

函数计算x的阶乘

#阶乘
def factorial(x):
    i=1
    mult=1
    while i<=x:
        mult*=i
        i+=1
    return mult

while True:
    x=int(input("x:"))
    print(factorial(x))

还可以使用递归的思想，小心死循环！

def mult(i):
	if i == 0:
		sum = 1
	else:
		sum = i*mult(i-1)
	return sum

mult(5)

通过递归的方式实现输入一个字符串，把字符串倒序输出。

def re(str,l)
	if l == 0:
		return
	print(str[l-1],end='')
	re(str,l-1)

1.2.3变量

• 全局变量
  定义在函数外、循环外的，作用范围：定义开始到文件结束
  
  需要定义全局变量的关键字：global

• 局部变量
  定义在函数中，与全局变量同名是，用局部变量
  
  

• 作用域
  全局变量：字面意思
  局部变量：只在定义的区域内使用

二、作业

1. 输入一个整数，判断这个整数有多少位，再逆序输出

def countbit(x,i):
    while x/10>=1 :
        x=x/10
        i+=1
    return i

while True:
    x=int(input("X: "))
    i=1
    print(countbit(x,i))
    re(x变体,i)
    # re函数在上面,将x的每一位通过除或模得出来就变成了字符串x变体

2. 输入一个数，得到这个数的二进制的4~7位
   注意：
   数：0 1 0 1 0 1 0 1 = 85
   位：7 6 5 4 3 2 1 0

def binaral(x):
    b=[]
    # x/2=1时及之前能除尽都商1余0，除不尽余1
    while x//2>=1:
        if x%2!=0:
            x=x//2
            b.append(1)
        else:
            x = x // 2
            b.append(0)
    # 除不尽时余1，该情况下只有1
    b.append(1)
    # 不足8位的补齐8位
    while len(b)<8:
        b.append(0)
    return b
x=int(input("x: "))
c=[]
c=binaral(x)
# 只显示前4（7~4位）
print(c[:3:-1])

还可以使用位运算的左移右移操作，直接将0~3位移走
py自带的二进制转换方法

3. 输入十个数存在列表中，按从小到大的顺序排序
思路：使用冒泡法排序，可以不限制列表大小，以键入特殊键结束

def sortoflist(list1):
    n = len(list1)
    for i in range(n):
        for j in range(0, n - i - 1):
            if list1[j] > list1[j + 1]:
                list1[j], list1[j + 1] = list1[j + 1], list1[j]
                # 交换的简易写法：二元赋值，传统写法如下
                # z = list1[j]
                # list1[j] = list1[j + 1]
                # list1[j + 1] = z
list1=[]
for i in range(10):
    list1.append(int(input()))
    i += 1
print(list1)
sortoflist(list1)
print(list1)

4. 在有序的列表中添加一个数据，保证有序
   思路：相当于插入法排序，要注意插入后不要越界

l = [0, 5, 10, 15, 20, 25, 30, 35, 40]
def linsert(l,x):
	# 先把数加入进来，直接就变成了插入法排序
    l.append(x)
    for i in range(len(l) - 1):
        if l[i] >= x:
            for j in range(i, len(l)):
                z=0
                z=l[j]
                l[j]=l[-1]
                l[-1]=z
            break
    print(l)
x=int(input("x:"))
linsert(l,x)

5. 有两个⼆维列表x,y实现对应位置的数据相加，得到⼀个新列表

x=[[1,2,3],[4,5,6],[7,8,9]]
y=[[10,2,6],[7,8,9],[16,9,4]]
def plus(x,y):
    z=[[0,0,0],[0,0,0],[0,0,0]]
    for i in range(len(x)):
        for j in range(len(y)):
            z[i][j]=x[i][j]+y[i][j]
    return z

plus(x,y)
print(plus(x,y))

实现的不是很好，呆板

6. 有n个数的列表[1,2,3,…,n-1,n]，输⼊⼀个m，让列表中的数按顺序依次移动m个位置，如：
   [1,2,3,4,5]—m = 3=====>[3,4,5,1,2]
   思路：见注释

def move(l,x):
    # 先添加跟移动位数x相同的空格
    i=x
    oldlen=len(l)
    while i>0:
        l.append('')
        i-=1
    # 在统一向后移x格
    for j in range(oldlen):
        l[len(l)-j-1]=l[len(l)-j-x-1]
        j+=1
    # 后x位覆盖前x位
    k=0
    while k<x:
        l[k]=l[oldlen+k]
        k+=1
    # 直接不显示越过原界限的x位
    print(l[0:oldlen])

# 不定义列表的具体元素个数，但C/C++中一定要小心越界
l=[]
times=int(input("列表位数:"))
while times>0:
    l.append(int(input("第"+str(times)+"位")))
    times-=1
x=int(input("移动几位："))
move(l,x)

三、多文件

关键字：from 文件 import 方法

1. 只有import，为最简单的引入对应的包。例如：
   import os #引入 os包

2. from A import B
   这种方式意味着从文件A中引入方法B。相当于：import A， b=A.b，例如：
   from numpy import matrix

3. import A as B
   这种方式为给引入的包A定义一个别名B，例如
   import numpy as np