Python学习日记2

一 列表和元组

1，序列概述

（1）列表

列表是一种可修改的序列，可以存储多个数据。

特点：使用 [] 表示；元素之间用逗号分隔；可以增加、删除、修改元素。

示例：

edward = ['Edward Gumby', 42]

列表可以嵌套（列表中的元素也可以是列表）

edward = ['Edward Gumby', 42]

john = ['John Smith', 50]

database = [edward, john]

结果：

[
 ['Edward Gumby', 42],
 ['John Smith', 50]
]

（2）元组

元组也是一种序列。

特点：使用 () 表示；不可修改；适合保存固定数据。

因为某些数据结构要求内容不能改变，所以才会有元组的提出

示例：

person = ('Edward Gumby', 42)

两者比较：

（3）容器

Python 中：

可以包含其他对象的数据结构称为容器。

常见容器：

（1）序列：

元素按照顺序排列：

例如：list tuple（元组） str

特点：每个元素有编号（索引）。

a = ['A','B','C']

（2）映射

例如：dict（字典）

特点：通过键访问数据

student = {
    "name":"Tom",
    "age":20
}

访问

student["name"]

（3）集合（set）

集合：不属于序列；不属于映射；元素无序；元素不能重复。

s = {1,2,3}

2，通用的序列操作

2，1 序列索引

（1）正向索引

序列索引从 0 开始

示例：

greeting = "Hello"

对应索引：

索引： 0   1   2   3   4
字符： H   e   l   l   o

访问：

greeting[0]

结果：

'H'

（2）负索引

Python 支持从右向左访问元素

负索引规则：

字符： H   e   l   l   o
正索引 0   1   2   3   4
负索引 -5 -4 -3 -2 -1

（3）字符串也是序列

Python 没有单独的字符类型

示例：

'Hello'[1]

结果：

'e'

说明字符串本质上是由多个字符组成的序列

（4）直接对序列使用索引

示例：

"Python"[0]

'P'

等价于：

s = "Python"
s[0]

（5）函数返回值也可以索引

如果函数返回一个序列，可以直接索引

示例：

fourth = input("Year: ")[3]

输入：

Year: 2005

执行：

fourth

结果：

'5'

（6）实例：根据日期输出月份

输入：

年份
月份
日期

然后根据月份索引列表获取月份名称

months = [
    'January',
    'February',
    'March',
    ...
]

注意索引偏移问题

用户输入：

Month: 8

列表索引：

January   → 0
February  → 1
March     → 2
...
August    → 7

所以：

months[month_number-1]

需要减1.

使用索引生成日期后缀

示例：

endings = ['st','nd','rd'] + 17 * ['th'] \
          + ['st','nd','rd'] + 7 * ['th'] \
          + ['st']

通过

endings[day_number-1]

来获取日期后缀。

总结：

months = [ 
 'January', 
 'February', 
 'March', 
 'April', 
 'May', 
 'June', 
 'July', 
 'August', 
 'September', 
 'October', 
 'November', 
 'December' 
] 
# 一个列表，其中包含数1～31对应的结尾
endings = ['st', 'nd', 'rd'] + 17 * ['th'] \ 
 + ['st', 'nd', 'rd'] + 7 * ['th'] \ 
 + ['st'] 
year = input('Year: ') 
month = input('Month (1-12): ') 
day = input('Day (1-31): ') 
month_number = int(month) 
day_number = int(day) 
# 别忘了将表示月和日的数减1，这样才能得到正确的索引
month_name = months[month_number-1] 
ordinal = day + endings[day_number-1] 
print(month_name + ' ' + ordinal + ', ' + year)

2，2 序列切片

切片格式：

序列[start:end:step]

（1）基本切片

示例：

numbers = [1,2,3,4,5,6,7,8,9,10]

获取索引3到6的元素

numbers[3:6]

结果：

[4,5,6]

（2）省略开始或结束索引

从开头开始

numbers[:3]  等价于  numbers[0:3]

结果：[1,2,3]

到末尾结束

numbers[7:]  等价于 numbers[7:10]

结果：  [8,9,10]

复制整个序列

numbers[:]

结果： [1,2,3,4,5,6,7,8,9,10]

（3）负索引切片

示例：

numbers[-3:]  表示获取最后3个元素
结果： [8,9,10]

注意：

numbers[-3:-1]  不包含-1，只包含-3

结果：[8,9]

（4）切片步长

示例：

numbers[0:10:2]     表示从0开始，每隔2个元素取一次。

结果：[1,3,5,7,9]

（5）使用负步长反向切片

示例：

numbers[::-1]  表示反转序列

结果：[10,9,8,7,6,5,4,3,2,1]

（6）切片边界规则

切片特点：第一个索引包含，第二个索引不包含

示例；

numbers[3:6]  

取 索引 3 4 5
不取 索引 6

（7）步长方向规则

正步长：从左向右

numbers[1:8:2]

结果：[2,4,6,8]

负步长：从右向左

numbers[8:1:-2]

结果：[9,7,5,3]

2，3 序列相加

Python 中可以使用 + 运算符连接相同类型的序列，支持元组，列表和字符串

（1）列表连接

使用+可以合并两个列表

>>> [1,2,3] + [4,5,6]
[1,2,3,4,5,6]

结果：两个列表元素按顺序拼接

（2）字符串连接

字符串也属于序列，可以使用+。

>>> "Hello, " + "world!"
'Hello, world!'

（3）不同类型序列不能相加

虽然列表和字符串都是序列，但是类型不同，不能连接

>>> [1,2,3] + "world"  是错误

报错：
TypeError:can only concatenate list (not "str") to list

（4)需要转换类型时

如果想连接不同类型，需要先转换。

[1,2,3] + list("abc")

结果：[1,2,3,'a','b','c']

str(123) + "abc"

结果：'123abc'

2，4 序列乘法

Python 中可以使用 * 运算符重复序列，生成新的序列。

序列 * n

表示将序列重复n次

（1）字符串乘法

示例：

>>> "python" * 5

结果：'pythonpythonpythonpythonpython'

（2）列表乘法

>>> [42] * 10
[42,42,42,42,42,42,42,42,42,42]

（3）使用乘法初始化列表

sequence = [None] * 10

结果：[None,None,None,None,None,
 None,None,None,None,None]

其中：None表示空值，没有具体内容。

（4）注意：不要使用【】*n

错误使用：

sequence = [] * 10

结果：【】

原因：空列表重复多少次仍然为空

(5) 序列乘法规则

序列乘法要求：左边必须是序列；右边必须是整数

示例：

正确："abc" * 3

结果：abcabcabc

错误："abc" * "3"

（6）实例：利用字符串乘法绘制图形

sentence = input("Sentence: ")

screen_width = 80
text_width = len(sentence)

box_width = text_width + 6

left_margin = (screen_width - box_width) // 2

其中：

" " * left_margin

表示生成指定数量的空格，实现居中。

绘制边框：

顶部：

'+' + '-' * (box_width-2) + '+'

中间：

'|' + ' ' * text_width + '|'

2，5 Python序列成员资格

Python 可以使用 in 运算符判断某个元素是否存在于序列中。

元素 in 序列

返回结果：

（1）存在->True

（2）不存在->False

（1）字符串成员判断

permissions = 'rw'

'w' in permissions

结果：True

（2）列表成员判断

users = ['mlh','foo','bar']

'mlh' in users

结果：True

（3）子序列判断

对于字符串：in 判断的是子字符串是否存在

'$$$' in '$$$ Get rich now!!! $$$'

结果：True

注意：列表判断的是完整元素

[1,2] in [[1,2],[3,4]]

结果：True

2 in [[1,2],[3,4]]

结果：False

（4）实例：用户名和密码验证

#数据库
database = [
    ['albert','1234'],
    ['dilbert','4242'],
    ['smith','7524'],
    ['jones','9843']
]
#用户输入
username = input("User name: ")
pin = input("PIN code: ")
#判断
if [username, pin] in database:
    print("Access granted")

原理：

#输入
albert
1234

#形成
['albert','1234']

#然后检查是否存在于database中

（5）长度，最大值，最小值

常用函数：

len（）：获取序列长度

numbers = [100,34,678]

len(numbers)

结果：3

max（）：获取最大值

max(numbers)

结果：678

min（）：获取最小值

min(numbers)

结果：34

max（）和min（）参数除了序列还可以是多个参数

序列：max([2,3])

多个参数：max(2,3)

3，列表

3.1 列表（list）以及基本的列表操作

列表（list）是 Python 中最重要的数据结构之一。

特点：有序；可修改（mutable）； 支持索引、切片、拼接、重复等序列操作

创建列表：

id="1"
names = ['Alice', 'Bob', 'Cecil']

（1）使用list（）创建列表

list() 可以将其他序列转换为列表

格式：list(sequence)

list("hello")

结果：['h','e','l','l','o']

（2)修改列表元素

列表可以通过索引直接修改元素。

list[index] = value


x = [1,1,1]

x[1] = 2

print(x)

结果：[1,2,1]

注意：索引必须存在，否则会报错。

（3）删除列表元素

使用del删除指定元素

格式：del list[index]

示例：names = ['Alice','Beth','Cecil','Dee-Dee','Earl']

del names[2]

结果：['Alice','Beth','Dee-Dee','Earl']  Cecil被删除

（4）切片赋值

列表切片不仅可以读取还可以修改

格式：list[start:end] = new_sequence

替换元素

name = list("Perl")

name[2:] = list("ar")

原列表：P e r l 被替换为 r l → a r

插入元素

切片赋值可以插入不同长度的数据

numbers = [1,5]

numbers[1:1] = [2,3,4]

结果：[1,2,3,4,5]

原因：numbers1:1 表示一个空切片，相当于插入位置

删除切片

将切片赋值为空列表

list[start:end] = []

示例：

numbers = [1,2,3,4,5]

numbers[1:4] = []

结果：[1,5]

等价于del numbers[1:4]

（5）切片赋值特点

普通赋值只能替换一个元素

x[1] = 10

切片赋值可以：替换多个元素；插入多个元素；删除多个元素。

x[1:3] = [10,20,30]

3.2 列表方法

列表（list）是 Python 中最常用的数据结构之一。列表是可变序列，可以通过方法直接修改内容。

格式：

list.method(arguments)

（1）append()：添加元素

在列表末尾添加一个元素

格式：list.append(value)

示例：
lst = [1,2,3]

lst.append(4)

print(lst)

结果：[1,2,3,4]

特点：直接修改原列表；不返回新列表。

（2）clear()：清空列表

删除列表中的所有元素

示例：lst = [1,2,3]

lst.clear()

print(lst)

结果：[]  等价于  lst[:] = []

（3）copy()：复制列表

创建列表副本

示例：
a = [1,2,3]

b = a.copy()

b[1] = 4

结果：
a = [1,2,3]

b = [1,4,3]

区别：直接赋值是两个变量指向同一个列表；复制是创建新的列表

（4）count()：统计元素出现次数

格式：

list.count(value)

示例：

x = ['a','b','a','c']

x.count('a')

结果：2

（5）extend()：扩展列表

将另一个序列中的元素逐个加入列表

示例：
a = [1,2,3]

b = [4,5,6]

a.extend(b)

结果：[1,2,3,4,5,6]

extend() 与 + 的区别

使用 +：创建新列表；原列表不变。

使用extend()：直接修改原列表；效率更高。

（6）index()：查找元素位置

返回元素第一次出现的索引

格式：

list.index(value)

示例：

names = ['we','are','the','knights']

names.index('the')

结果：2

如果元素不存在，那么就会报错

names.index('abc')

报错：ValueError

（7）insert()：插入元素

格式：

list.insert(index,value)

示例：

numbers = [1,2,3,5,6]

numbers.insert(3,4)

结果：[1,2,3,4,5,6]

也可以使用切片，效果是相同的

numbers[3:3] = [4]

（8）pop()：删除并返回元素

删除列表元素，并返回删除的值

默认删除最后一个

x = [1,2,3]

x.pop()

返回：3
列表变为：[1,2]

指定位置删除

x.pop(0)

pop() 应用：栈结构

栈：后进先出

示例：

stack = []

stack.append(1)
stack.append(2)

stack.pop()

返回：2

（9）remove()：删除指定值

格式：

list.remove(value)

示例：

x = ['a','b','c']

x.remove('b')

结果：['a','c']

注意：只删除第一次出现的值，不存在会报错

（10）reverse()：反转列表

原地反转列表

示例：

x = [1,2,3]

x.reverse()

结果：[3,2,1]

特点：修改原列表；不返回结果

如果不想修改原列表可以使用

reversed()

示例：list(reversed(x))

（11）sort()：排序

对列表进行排序

示例：

x = [4,6,2,1,7]

x.sort()

结果：[1,2,4,6,7]

特点：修改原列表；返回 None

如果不想修改原先的列表，可以使用sorted()：生成排序副本

y = sorted(x)

特点：返回新列表；原列表不变

（12）sort() 高级参数

reverse

降序：

x.sort(reverse=True)

结果：[7,6,4,2,1]

key

指定排序规则

格式：list.sort(key=function)

示例：按照字符串的长度排序
words = ['add','a','aaaa']

words.sort(key=len)

结果：['a','add','aaaa']

4，元组

元组（tuple）是一种不可修改的序列。

与列表（list）类似：有序；支持索引和切片；可以存储多个元素。

4,1 创建元组

（1）使用逗号创建

元组最重要的标志是：逗号 （，）

1,2,3

结果：(1,2,3)

（2）使用括号创建

(1,2,3)

结果：(1,2,3)

注意：括号不是元组的核心，逗号才是。

4,2 空元组

创建空元组：()

结果：（）

4,3 单元素元组

(42)

结果：42

这不是元组而是普通整数。

原因：Python 认为(42)只是数学括号

正确写法：

(42,)

结果：(42,)

单元素元组必须加逗号

4,4 元组拆包

元组可以直接赋值给多个变量

x,y,z = 1,2,3  等价于  (x,y,z) = (1,2,3)

访问：x[ ]

4,5 tuple() 函数

tuple() 可以将序列转换为元组

格式：

tuple(sequence)

字符串转换

tuple("abc")

结果：('a','b','c')

列表转换

tuple([1,2,3])
结果：(1,2,3)

如果参数本身是元组：

tuple((1,2,3))

不会复制，直接返回原元组

4,6 元组索引和切片

索引

x = (1,2,3)

x[1]

结果：2

切片

x[0:2]

结果：(1,2)

返回的仍然是元组

4,7 元组为什么不能修改

错误：

x = (1,2,3)

x[1] = 5

报错：TypeError

因为：元组不可变；创建后元素固定。

4,8 元组的应用场景

（1）字典key

字典的 key 必须不可变

point = (3,5)

# 可以作为key

（2）保护固定数据

point = (10,20)

这些不希望被修改的数据