Python基础语法（中）—— python列表、字符串、函数

5. python中的列表

python中的列表，就是C++中的数组，用法是相同的，只是语法上有些差别。但是，python中的列表可以存放不同的数据类型

5.1 列表的初始化

5.1.1 直接初始化

形如：

a = []  # 定义一个空列表
b = [1, 2]  # 含有2个整数的列表
c = [6, "python", 3.14]  # 含有3个不同类型元素的列表
print(a, b, c)

5.1.2 通过append函数初始化

append() 函数可以在 列表末尾 添加一个元素。形如：

a = [] #先定义一个空列表
for i in range(5):
    a.append(0) #初始化出5个0的列表
print(a)

n = 5
a = []
for i in range(n):
    a.append(i ** 2) #初始化成[0, 1, 4, 9, 16]
print(a)
![在这里插入图片描述](https://img-blog.csdnimg.cn/direct/24180aeb4289448aa3e71ed728932a1b.png)

a.append(666) #在列表尾插一个数据
print(a)

5.1.3 通过for语句初始化列表长度和每个位置的数值

形如：

a = [0 for i in range(4)] #初始化 a = [0, 0, 0, 0]
print(a)

n = 3
b = [i ** 3 for i in range(n)] #初始化 b = [0, 1, 8]
print(b)

5.2访问列表元素

与C++中的访问数组一样。可以通过下标读/写列表中的元素，下标从0开始，也可以是负数，负数下标表示的是除以列表长度的余数对应的位置， 即从后往前数。 如果列表长度是 n，那么下标只能取 ?n～n?1 之间的整数，超出范围会报错。

例如：

a = [1, 2, 4, 8]
print(a[0], a[2], a[-4], a[-2])  #输出：1 4 1 4
a[0] = 10  #修个第0个元素的数值
print(a)

5.3使用循环语句遍历列表

例如：

#法一
a = [1, 2, 4, 8, 16]
for i in range(len(a)):
    print(a[i], end=' ')
print()

#法二
b = [1, 2, 4, 8, 16]
for x in b:
    print(x, end=' ')

例题：求斐波那契数列的第n项

n = int(input())
a = [0 for i in range(n + 1)] #a[0] ~ a[n]
a[0] = 0
a[1] = 1
for i in range(2, n + 1):
    a[i] = a[i - 1] + a[i - 2]
print(a[n])

5.4列表的切片操作

列表的切片操作会返回一个新列表。用法：

1. a[begin:end] 会返回包含a[begin], a[begin + 1], …, a[end - 1]的列表。
2. 省略begin时，begin的默认值是0。
3. 省略end时，end的默认值是列表长度。
4. 如果begin或end是负数，表示的是除以列表长度后的余数。（取余运算）

例如：

a = [1, 2, 3, 4]
#注意输出的是一个列表
print(a[1:3]) #输出：[2, 3]
print(a[:3]) #输出：[1, 2, 3]
print(a[1:]) #输出：[2, 3, 4]
print(a[-3:-1]) #输出：[2, 3]

#切片也支持写操作
a[1:] = [4, 3, 2] #输出：[1, 4, 3, 2]
print(a)

5.5列表的复制

列表跟其他变量类型不同，如果用等号复制列表，那么原列表和新列表是同一个列表。 （相当于是深拷贝）对新列表修改，会修改原列表的值。例如：

a = [i for i in range(5)] #a = [0, 1, 2, 3, 4]
b = a
b[0] = 10
print(a) #a = [10, 1, 2, 3, 4]

使用切片，可以得到一个原列表的浅拷贝。此时再修改新列表，原列表就不会发生变化了。例如：

a = [i for i in range(5)] #a = [0, 1, 2, 3, 4]
b = a[:]
b[0] = 10
print(a) #a = [0, 1, 2, 3, 4]
print(b) #b = [10, 1, 2, 3, 4]

5.6列表的运算

1. 列表的加法可以将两个列表拼接起来，得到一个新列表。与字符串的加法是一致的
2. 列表乘以一个整数，可以将若干个自身拼接起来，得到一个新列表。与字符串也是一致的

a = [0, 1, 2]
b = [3, 4]

c = a + b  # c相当于a和b的浅拷贝
print(c)  # 输出[0, 1, 2, 3, 4]

d = a * 3  # d相当于a的浅拷贝
print(d)  # 输出[0, 1, 2, 0, 1, 2, 0, 1, 2]

a += [3]  # 在a的末尾添加一个新元素3
print(a)  # 输出[0, 1, 2, 3]

5.7列表的常用操作

1. len(a) 返回列表长度。
2. a.append(x) 在列表末尾添加一个新元素。
3. a.pop() 删除列表的最后一个元素。
4. a.reverse() 将整个列表翻转。
5. a.sort() 将整个列表从小到大排序。

例如：

a = [0, 1, 2]

print(len(a))  # 输出3

a.append(3)
print(a)  # 输出[0, 1, 2, 3]

a.pop()
print(a)  # 将[0, 1, 2, 3]的最后一个数删掉，所以输出[0, 1, 2]

a.reverse()
print(a)  # 输出[2, 1, 0]

a.sort()
print(a)  # 输出[0, 1, 2]

5.8嵌套列表

列表中的元素也可以是列表，相当于C++中的二维数组。例如：

matrix = [
    [0, 1, 2],
    [3, 4, 5],
    [6, 7, 8],
]
print(matrix)
matrix[0][1] = 99
print(matrix[0][1])

#遍历方法一
for i in range(len(matrix)):
    for j in range(len(matrix[i])):
        print(matrix[i][j], end=' ')
    print() #换行
print()

#遍历方法二
for row in matrix:
    for x in row:
        print(x, end=' ')
    print()

嵌套列表的常用初始化方式有两种。

①类似于一维列表的初始化，采用append()函数初始化：

matrix = []
for i in range(3):
    row = []
    for j in range(3):
        row.append(i * 3 + j)
    matrix.append(row)
print(matrix)

②采用for语句直接初始化（比较复杂，就是套娃），也类似于一维列表，如：a = [i for i in range(3)]：

#第一步：与上面append一样
matrix = []
for i in range(3):
    row = []
    for j in range(3):
        row.append(i * 3 + j)
    matrix.append(row)
print(matrix)

#第二部：把内部的列表初始化，如：
matrix = []
for i in range(3):
    row = [i * 3 + j for j in range(3)]
    matrix.append(row)
print(matrix)

#第三步：把外部的列表再初始化，即把里面的row列表直接放到matrix中取：
matrix = []
for i in range(3):
    matrix.append([i * 3 + j for j in range(3)])
print(matrix)

#第四步：直接写二维列表：
matrix = [[i * 3 + j for j in range(3)] for i in range(3)]

5.9列表其他小知识点

• 当需要读入一行整数时，可以用：a = list(map(int, input().split()))。类似地，当需要读入一行浮点数时，可以用a = list(map(float, input().split()))：
• 两种方法将列表逆转：法①使用reverse内置函数：a.reverse() ; 法②使用：a[::-1]

6.python中的字符串

6.1字符串与整数的关系——ASCII码

每个常用字符都对应一个-128 ~ 127的数字，二者之间可以相互转化。注意：目前负数没有与之对应的字符。

常见的ASCII码：‘A’- 'Z’是65 ~ 90，‘a’ - 'z’是97 - 122，0 - 9是 48 - 57。空格时32，换行时10

• ord()函数可以求一个字符的ASCII码。注意输入是一个字符，而不是字符串。
• chr()函数可以将一个ASCII码转化成对应的字符。

例如：

c = "A"
print(ord(c)) #输出65
print(chr(97)) #输出a

注意： 虽然字符可以跟整数相互转化，但 在Python中，字符不能参与数值运算 ，这一点跟C++、Java等语言是不同的。

6.2字符串常量的写法

注意：在 Python中，字符串既可以用单引号来表示，也可以用双引号来表示，二者完全相同 。这一点跟C++、Java等编程语言是不同的，在这些编程语言中，用单引号来表示字符，用双引号来表示字符串。

两个或多个字符串常量并排写，会被自动合并 ，例如：

c = "I love " "eating ""eggs"
print(c) #输出I love eating eggs

一个字符串如果包含多行，可以采用"“”…“”"或者’‘’…‘’'的初始化方式（三对引号），字符串中将自动包含回车字符，例如：

a = """Usage: thingy [OPTIONS]
     -h                        Display this usage message
     -H hostname               Hostname to connect to"""
print(a)

6.3表示特殊字符——转义

当想在字符串中表示特殊字符时，一般可以在字符前加反斜杠\。常见需要转义的字符有：

例如：

print("My name is:\nSuntong") #\n表示换行
print("My age is \'18\'") #转义引号
print("My favorite sport is \"basketball\"")

6.4访问字符串中的每个字符

与列表一样，可以通过下标读取字符串中的每个字符，下标从0开始，也可以是负数，负数下标表示的是除以字符串长度的余数对应的位置。负数下标相当于将字符串首位相接，然后从0往前数。如果字符串长度是 n，那么下标只能取 ?n～n?1 之间的整数，超出范围会报错。

注意：字符串中的字符是不可以修改的，与C++一样，他们都是常量字符串
例如：

s = "hello world"
print(s[0], ord(s[0])) #输出：h 104
a[0] = s #报错

6.5使用循环语句遍历字符串

①可以通过下标访问，例如：

s = "hello world"
for i in range(len(s)):
    print(s[i], end='')
print()

②可以通过for … in …直接遍历，例如：

s = "hello world"
for i in s:
    print(i, end='')
print()

6.6字符串的切片操作

与列表的切片操作一致，字符串的切片操作会返回一个新字符串。用法：

• a[begin:end] 会返回包含a[begin], a[begin + 1], …, a[end - 1]的字符串。
• 省略begin时，begin的默认值是0。
• 省略end时，end的默认值是字符串长度。
• 如果begin或end是负数，表示的是除以字符串长度后的余数。

例如：

s = "hello world"
print(s[0:5]) #输出：hello
print(s[-11:-6]) #输出：hello
print(s[0:5:2]) #步长是2，输出：hlo

注意：与列表切片的区别，字符串的切片操作不支持写操作，常量字符串不支持写操作

6.7字符串的复制操作

通过上面，我们知道列表的复制是深拷贝，即通过复制，两个列表共用的是一个列表，修改一个列表，另一个列表也会发生改变。而与列表不同，字符串的复制属于浅拷贝，字符串的复制会得到一个新的字符串。

6.8字符串的运算

1. 与列表相同，字符串的加法可以将两个字符串拼接起来，得到一个新字符串。
2. 与列表一致，字符串乘以一个整数，可以将若干个自身拼接起来，得到一个新字符串。
3. 与列表的比较操作一致，字符串也支持比较运算符，按字典序比较大小。即如果两个字符串相同，则表示相等；否则找到两个字符串从左到右数第一个不一样的字符，哪个字符串的字符的ASCII码小，哪个字符串的字典序就小；另外空字符比任何字符都小。

例如：

s1 = "hello"
s2 = "world"
s = s1 + ' ' + s2
print(s) #输出：hello world
s3 = s1 * 3
print(s3) #输出：hellohellohello
print(s1 < s2) #输出：True

6.9字符串的常用操作

pass

7.python中的函数

前提：在python中，函数和变量没有什么区别，函数就是一个特殊的参数，我们可以给函数的参数中传函数。

为什么要定义函数（方法）：当代码中需要重复使用相同的逻辑时，可以使用函数来减少代码量。当代码较长时，可以使用函数来将逻辑分割成若干部分，使代码结构更容易让人看懂。
而所有编程语言的函数的用法都是一致的，只不过是写法不同。

7.1编写函数

Python中一个典型的函数定义包括以下部分：关键字def、函数名称、由0个或多个形参组成的列表以及函数体。

例如：编写一个求阶乘的函数：

def fac(n):
    res = 1
    for i in range(1, n + 1):
        res *= i
    return res


print(fac(10)) #标准格式下，函数的前面与后面要空两格

函数名称是fac，给它传入一个n，会返回n的阶乘。return语句负责结束函数并返回res的值。

7.2函数的实参与形参

实参指调用函数时传入的变量或常量，形参指定义函数时参数列表里的变量。形参在调用完成后会被系统自动回收。形参列表可以为空

7.2.1形参的初始化方式

第一种是用位置实参来初始化形参。顾名思义，实参会按位置关系来初始化形参，第一个实参初始化第一个形参，第二个实参初始化第二个形参，依此类推。形参和实参的个数必须匹配。例如：

def fun(a, b, c, d):
    print("a =", a, end=' ')
    print("b =", b, end=' ')
    print("c =", c, end=' ')
    print("d =", d, end=' ')


fun(1, True, "python", 3.14) #传参的个数必须与函数形参个数相等

第二种是用关键字实参来初始化形参。此时实参 不再按位置关系 来初始化形参，而是按变量名初始化。例如：

f(b=1, c=True, a="Python", d=4.2)  # 输出 a = Python, b = 1, c = True, d = 4.2

注意：两种方式也可以混合使用，但是位置实参一定要放到关键字实参之前。 例如：

# f()的定义如上所述
f(1, 2, d="Python", c=4.2)  # 输出 a = 1, b = 2, c = 4.2, d = Python
f(1, b=3, "Python", d=4.2)  # 会报错，因为位置实参位于关键字实参后面了。

7.2.2带默认值的形参

形参也可以设置默认值，但所有 带默认值的形参必须是最后几个 。当某些形参没有被初始化时，这些形参会使用默认值。例如：

def f(a, b, c=3, d="Python"):
    print("a =", a, end=", ")
    print("b =", b, end=", ")
    print("c =", c, end=", ")
    print("d =", d)


f(1, 2)  # c和d没有被初始化，采用默认值。输出 a = 1, b = 2, c = 3, d = Python
f(1, b=2, d="hello")  # c没有被初始化，采用默认值。输出 a = 1, b = 2, c = 3, d = hello

7.3变量的作用域

函数内定义的变量为局部变量，只能在函数内部使用。当需要修改用全局变量时，需要用 global关键字 在函数内声明全局变量。例如：

x = 1


def fun():
    global x  # 在函数内部声明全局变量
    x = 666
    y = 999
    print(x, y)


fun()  # 输出：666 999
print(x) #发现x变成了666，说明定义在外面的全局变量x也能在函数内部修改了
#print(y) #报错

7.3函数嵌套

函数内部也可以定义函数。例如：

def fun1():
    def fun2(x):
        x += 1
        print(x)
    fun2(5) #调用fun2函数


fun1() #输出6

7.4pass语句

同循环语句一样，当我们还没有想好怎么实现这个函数的时候，可以写个pass语句，之后再来实现这个函数。

7.5函数的参数传递

7.5.1值传递

int、float、bool、字符串等采用值传递。 将实参的初始值拷贝给形参。此时，对形参的改动不会影响实参的初始值。例如：

def fun(y):
    y = 5
    print(y)


x = 10
fun(x)
print(x) # x还是10，不会改变

7.5.2引用传递列表采用引用传递。

类似于C语言中的传地址，C++中的引用（&）；列表采用引用传递。 将实参的引用传给形参，此时对形参的修改会影响实参的初始值。例如：

def fun(x):
    for i in range(len(x)):
        x[i] += 1


a = [1, 2, 3, 4]
fun(a)
print(a) # a的内容会发生改变为[2, 3, 4, 5]

7.6函数return语句

return语句终止当前正在执行的函数并将控制权返回到调用该函数的地方，并返回结果。 与C++不同的是，python的返回值可以有多个。 例如：

def f(x):
    if x == 1:
        return  # 不写返回值时，会返回None
    if x == 2:
        return 3  # 返回一个变量
    if x == 3:
        return 4, 5  # 返回多个变量


a = f(1)
b = f(2)
c, d = f(3)
e = f(4)  # 没写return时，也会返回None
print(a, b, c, d, e)  # 输出 None 3 4 5 None

7.7函数lambda表达式

lambda关键字可以创建匿名函数，目的是为了简化代码。可以对比下面两种写法，会发现lambda表达式的写法更短一些。常与sort()函数配合使用，例如：

我们本来可能会在调用函数的时候，给函数再传递一个函数，例如：

def fun1(a, b, g):
    g()
    return a + b


def fun2():
    print("hello world")


s = fun1(3, 4, fun2)
print("s =", s)

但是，我们使用lambda就可以写的更简洁了。效果等同

def fun1(a, b, g):
    g()
    return a + b


s = fun1(3, 4, lambda: print("hello world"))
print("s =", s)

7.8函数递归

递归讲求在一个函数内部，也可以调用函数自身。这种写法被称为递归。写递归函数可以从集合的角度来思考。理解递归函数的执行顺序可以用树的形式来思考。例如，求解斐波那契数列第 n 项可以采用如下写法：

def fun(n):
    if n <= 2:
        return 1
    return fun(n-1) + fun(n-2)


print(fun(10))