python-基础知识（函数、列表、元组）

函数

定义：

def 函数名（形参列表）：

    函数体

    return 返回值

形参列表中可以有多个形参，多个形参之间用逗号分隔开。

函数体带一级缩进，带有缩进的代码才是函数内部的语句。

return语句并不是必须的

调用

函数名(实参列表) 

实参的个数必须与形参个数相同，通常使用位置传参，也可以使用关键字传参，也可两者混合使用，混合使用时要求位置参数在前，关键字参数在后。 

#定义一个求和函数
def calcSum(beg, end):
    theSum = 0
    for i in range(beg,end+1):
        theSum += i
    print(theSum)



def calc_sum(beg,end):
    the_sum = 0
    for i in range(beg,end):
        the_sum +=i
    return the_sum
        
    
#调用函数
calcSum(1,100)
calcSum(300,400)
calcSum(1,1000)

a1 = calc_sum(1,100)
a2 = calc_sum(300,400)
a3 = calc_sum(1,1000)

在实际编程中，calc_sum( )函数更适合应用。交互性更强，提高代码的健壮性。

关键字传参，可以按照形参的名字传参，顺序可更改。

def test(x,y):
    print(f'x = {x}')
    print(f'y = {y}')
    
test(x=10,y=20)
test(y=50,x=90)

函数中可以有多个return 语句，当执行到return 语句后，函数会立即结束，回到调用位置。

形参的默认值，带有默认值的形参就可以在调用函数的时候，不必传参。要求带有默认值的形参得在形参列表的后面。

def add(x,y,debug=False):
    if debug:
        print(f'x = {x},y = {y}')
    return x+y

result = add(10,20)
print(result)

python中的一个函数可以返回多个返回值，各个返回值之间用逗号隔开，也可以直接赋值多个变量，也可以使用下划线占位。

#写一个函数，返回平面上的坐标
#横坐标，纵坐标
import random


def getPoint():
    x = 40
    y = 9
    return x,y


a,b = getPoint()
_,c = getPoint()

print(a,b)

函数的调用

函数的链式调用：用一个函数的返回值，作为另一个函数的参数。

def isOdd(num):
    if num % 2 == 0:
        return False
    return True

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

print(isOdd(add(3,4)))
#先执行（）里面的函数，后执行外面的函数
#换句话说，调用 一个函数，就需要先对他的参数求值

嵌套调用，函数内部调用其他函数。

def a():
    print('函数 a')

def b():
    print('函数 b ')
    a()

def c():
    print('函数 c ')
    b()

def d():
    print('函数 d ')
    c()

d()

函数的栈帧

先打断点，然后右键开始调试，按F7进入函数内部，调试器左下能够看到函数之间的“调用栈”，调用栈里面描述了当前这个代码的函数之间调用关系，每一层这个调用关系就被成为“函数的栈帧”，每个函数的局部变量就在这个栈帧中体现。

每一层栈帧，选中后可以看到里面的局部变量，每个函数的局部变量就保存在对应的栈帧中。调用函数则生成对应的栈帧，函数结束，则对应的栈帧消亡，局部变量也随之消亡。

函数递归

函数自己调用自己。

递归的两个要素：1、递归的结束条件；2、递归的递推公式。

求n的阶乘，非递归法：

#写一个函数，求n的阶乘（n是正整数）

def factor(n):
    result = 1
    for i in range(1,n+1):
        result *= i
    return result

print(factor(5))

 求n的阶乘，递归法：

#用递归求n的阶乘（n为正整数）

def factor(n):
    if n == 1:
        return 1
    return n * factor(n-1)

print(factor(5))

列表、元组

列表和元组的基本概念 ：用一个变量来表示多个数据。类似于数组。

列表和元组大部分功能相同，唯一区别在于：

列表是可变的（散装物品）：创建好了之后，随时能改。

元组是不可变的（包装物品）：创建好了之后，不可修改，只能丢弃旧的，创建个新的元组。

创建列表

1、直接使用字面值来创建。[ ] 就表示一个空的列表

2、使用  list( )  来创建

3、可以在创建列表的时候，在[ ] 中指定列表的初始值，元素之间使用，来分割。可以在同一个列表中存放不同类型的元素。

a = []
print(type(a))

b = list()
print(type(b))

c = [2,3,5,6,[3,5,6]]
print(type(c))
print(c)

用列表名+ [ ] 下表访问运算符来访问列表中的元素可读可修改，[ ] 中间写的整数就被称为“下标”或“索引”，从0开始计数，下标的有效范围是从0到长度-1。下标支持负数，[-1]等价于 len(a)-1。-1就是倒数第一个元素。

可以使用内建函数 len 来获取到列表的长度（元素个数），和字符串类似。

 列表的切片

切片操作时一个较为高级的操作，切片的时候只是取出了原有列表的一个部分，并不涉及到“数据的拷贝”，即速度较快。

通过下标操作是一次取出里面的一个元素。

通过切片，则是一次取出一组连续的元素，相当于得到一个子列表。

使用 [ : ] 的方式进行切片操作。[ ] 里面有两个数字，表示了一段区间。[1:3] 1表示开始区间的下标，3表示结束区间的下标，表示取下标为1 一直到下标为3的元素（包含1，不包含3）是前闭后开的区间[1,3)。

切片操作中可以省略前后边界。当切片中的范围超出有效下标之后不会出现异常，而是尽可能的把符合要求的元素给获取到。

切片操作还可以指定“步长”，也就是“每访问一个元素后，下标自增几步”。步长也可为负数，表示从后往前取。

a = [1,2,3,4]
print(a[1:3])#打印下标[1，3)的元素
print(a[1:])#省略后面下标的操作，打印下标[1,3]的元素
print(a[:2])#省略前面下标的操作，打印下标[0,2)的元素
print(a[:-1])#-1表示最后一个元素，打印[0,3)的元素
print(a[:])#表示取所有元素

b = [1,2,3,4,5,6,7,8,9,0,10,11,22,33,44]
print(b[::2])#2表示步长，每隔两个元素取一个元素
print(b[::-2])#从后往前取元素，每两个元素取一个元素

 

列表元素的遍历操作

遍历：把一个列表里面的每个元素都依次取出来并进行某种操作。

1、用for循环遍历，elem =>element 元素

#使用for循环遍历
a = [1,2,3,4,5,6,7,8,9,0]
for elem in a:
    print(elem)

2、使用for循环遍历，通过下标的方式，还可对列表元素进行修改

#使用for循环遍历，通过下标的方式
a = [1,2,3,4,5]
for i in range(0,len(a)):
    print(a[i])
    a[i] = a[i] + 10
print(a)

 3、使用while 循环，通过下标遍历

a = [1,2,4]
i = 0
while i < len(a):
    print(a[i])
    i +=1

 列表的插入操作

使用 append 方法，向列表末尾插入一个元素（尾插）。

此处的append是搭配列表对象来一起使用的，而不是作为一个独立的函数。type、print、input、len，自定义函数等都是独立的函数。要搭配对象（即变量）来使用的函数（function），也叫做方法（method）。

alist = [1,2,3,4]
alist.append("hello")
print(alist)

 

 

使用 insert 方法，向任意位置插入一个元素。insert 第一个参数表示要插入元素的下标。

alist = ["hello","word","!",4,5]
alist.insert(-1,"wangwnag")
print(alist)

 列表的查找和删除

查找元素

使用 in 操作符，判定元素是否在列表中存在，返回值是布尔类型。

alist = [1,2,3,4,5]
print( 2 in alist) # 运行结果：True
print("hello" in alist)# 运行结果False
print(2 not in alist)#运行结果 False

使用 index 方法，查找元素在列表中的下标，返回值是一个整数。如果元素不存在，则会抛出异常。

alist =  [0,1,2,3,"hello"]
print(alist.index(2))   # 运行结果为： 2
print(alist.index("hello"))  #运行结果为：  4

删除元素

使用pop 方法删除最末尾元素。

alist = [1,2,3,4,5]
alist.pop()
print(alist)
#运行结果为[1,2,3,4]

pop 也能按照下标来删除元素。

alist = [0,1,2,3,4,"hello"]
alist.pop(-1)
print(alist)
#运行结果为[0,1,2,,3,4]

使用 remove 方法，可以按照值来进行删除。

alist = ["aa","bb",'cc','dd']
alist.remove("aa")
print(alist)
#运行结果为：['bb', 'cc', 'dd']

列表的拼接

使用 + 能够把两个列表拼接在一起，会生成一个新的列表，而不会影响旧列表的内容。

a = ['hello']
b = ['word']
print(a + b)
#运行结果：['hello', 'word']

使用  extend 方法，相当于把一个列表拼接到另一个列表的后面，会修改被拼接的列表，而不该表拼接列表的内容。

a = [0,1,2,3]
b = [3,4,5,6]
a.extend(b)
print(b)
print(a)
#运行结果为：
#[3, 4, 5, 6]
#[0, 1, 2, 3, 3, 4, 5, 6]

元组的操作

创建元组，元组中元素可以为任意类型。

#1.创建元组
a = ()
print(type(a))
b = tuple()
print(type(b))
#2.创建元组时，指定初始值
c = (1,2,3,4)
print(type(c))
print(c)
#运行结果为：<class 'tuple'>
#<class 'tuple'>
#<class 'tuple'>
#(1, 2, 3, 4)

可以通过下标访问元组中的元素，下标是从0开始到len-1结束，也可为负数，取倒数元素。

a = (0,1,2,3,4,5)
print(a[2])
print(a[-1])
#运行结果： 2   5

通过切片来获取元组中的一部分，操作和列表相同。

a = (1,2,3,4)
print(a[1:3])
#运行结果为为：(2, 3)

可以用 for循环等方式来进行遍历。

a = (1,2,3,4,5,6)
for elem in a:
    print(elem)

可以使用 in 来判定元素是否存在，使用 index 查找元素的下标。

a = (0,1,2,3,'hello',4)
print(3 in a)
print( a.index(4))

#运行结果：True
# 5

可以使用 + 来拼接两个元组，同列表操作。

a = (1,2,3,4)
b = (5,6,7,8)
print(a+b)

元组只支持“读”操作，不支持“修改操作”。因此 append、pop、extend方法等在元组中不存在。

当进行多元赋值的时候，其实本质上是按照元组的方式来进行工作的。

def getPoint():
    x = 10
    y = 30
    return x,y

a , b = getPoint()
print(type(getPoint()))

#运行结果为：<class 'tuple'>