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

文章目录

    • 5. python中的列表
      • 5.1 列表的初始化
        • 5.1.1 直接初始化
        • 5.1.2 通过append函数初始化
        • 5.1.3 通过for语句初始化列表长度和每个位置的数值
      • 5.2访问列表元素
      • 5.3使用循环语句遍历列表
      • 5.4列表的切片操作
      • 5.5列表的复制
      • 5.6列表的运算
      • 5.7列表的常用操作
      • 5.8嵌套列表
      • 5.9列表其他小知识点
    • 6.python中的字符串
      • 6.1字符串与整数的关系——ASCII码
      • 6.2字符串常量的写法
      • 6.3表示特殊字符——转义
      • 6.4访问字符串中的每个字符
      • 6.5使用循环语句遍历字符串
      • 6.6字符串的切片操作
      • 6.7字符串的复制操作
      • 6.8字符串的运算
      • 6.9字符串的常用操作
    • 7.python中的函数
      • 7.1编写函数
      • 7.2函数的实参与形参
        • 7.2.1形参的初始化方式
        • 7.2.2带默认值的形参
      • 7.3变量的作用域
      • 7.3函数嵌套
      • 7.4pass语句
      • 7.5函数的参数传递
        • 7.5.1值传递
        • 7.5.2引用传递列表采用引用传递。
      • 7.6函数return语句
      • 7.7函数lambda表达式
      • 7.8函数递归

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)

Python基础语法(中)—— python列表、字符串、函数_第1张图片

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()

Python基础语法(中)—— python列表、字符串、函数_第2张图片
嵌套列表的常用初始化方式有两种。

①类似于一维列表的初始化,采用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)

Python基础语法(中)—— python列表、字符串、函数_第3张图片

6.3表示特殊字符——转义

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

Python基础语法(中)—— python列表、字符串、函数_第4张图片
例如:

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

Python基础语法(中)—— python列表、字符串、函数_第5张图片

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)

Python基础语法(中)—— python列表、字符串、函数_第6张图片
但是,我们使用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))

你可能感兴趣的:(Django项目,python,开发语言)