Python入门笔记（11）

编程语言 评论

人生苦短 我用Python

序列&索引

序列是一个用于存储多个值的连续空间，每个值都对应一个整数的编号，称为索引
序列结构主要有列表、元组、集合、字典和字符串

索引有正向递增索引，取值范围为[0，N-1]
反向递减索引，取值范围[-1,-N]

1
2
3
4
5
6
s='helloworld'
for i in range(0,len(s)):
    print(i,s[i]) # 正向递增索引
for i in range(-10,0):
    print(i,s[i]) # 反向递减索引
# 上述语句会输出字符串s中每一个元素以及其索引，索引在前

序列的相关操作

使用“+”来实现两个同类型序列的相加操作，不会去除重复元素

序列的类型要求是相同的，但序列中元素的类型可以是不同的

使用数字n乘以一个序列，将生成一个新的序列，新序列中的内容将会被重复n次

1
2
3
4
5
6
7
8
9
10
s='hello'
s1='world'
print(s+s1) # 产生一个新的字符串
# -----------
lst=[10,20,30]
print(s+lst)
# 此时会报错“TypeError”，因为序列类型不同，lst序列为列表
# -----------
print(s*5)
print('-'*8) # 序列相乘
  • 序列的相关操作符与函数
操作符 描述
x in s 如果x为s中的元素，结果为True，否则为False
x not in s 如果x不是s中的元素，结果为True，否则为False
len(s) 序列s中元素的个数
max(s) 序列s元素中的最大值
min(s) 序列s元素中的最小值
s.index(x) 序列s中第一次出现元素x的位置
s.count(x) 序列s中出现x的总次数 
1
2
3
s='helloworld'
print('e在hello world中存在吗',('e' in s)) # 输出为True
print('e不在hello world中存在吗',('e' not in s)) # 输出为False

列表

  • 一系列的按特定顺序排列的元素组成
  • Python中内置的可变序列
  • 使用[]定义列表，元素之间使用逗号分隔
  • 元素可以是任意的数据类型

列表的创建

  1. 使用[]直接创建列表
1
2
# List_name=[element1,element2,...elementN]
lst=['hello','world',99.8,100]
  1. 使用内置方法list()创建列表
1
2
3
# List_name=list(序列)
lst=list('hellloworld')
lst1=list(range(1,10,2)) # 输出1-10（不包含），步长为2的列表

列表是序列的一种，对序列可操作的运算符、函数等均能用于列表

列表的删除

1
del List_name

列表元素的遍历

  1. 使用遍历循环for
  2. 遍历循环for与range()函数和len()函数组合遍历
  3. 遍历循环for与enumerate()函数组合遍历元素和索引
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

lst=['hello','world','python','html']
for item in lst:
    print(item)
# ----------
for i in range(len(lst)):
    print(i,'-->',lst[i])
# ----------
for index,item in enumerate(lst): # 序号从0开始
    print(index,item)
# -----
for index,item in enumerate(lst,10): # 序号从10开始
    print(index,item)
# index：用于保存元素的索引(序号)
# item：用于保存获取到的元素值

列表的相关操作方法

方法 描述
lst.append(x) 在列表lst最后增加一个元素
lst.insert(index,x) 在列表lst中第index位置增加一个元素
lst.clear() 清除列表lst中所有元素
lst.pop(index) 将列表lst中第index位置的元素取出，并从列表中将其删除
lst.remove(x) 将列表lst中出现的第一个元素x删除
lst.reverse(x) 将列表lst中的元素反转
lst.copy() 拷贝列表lst中的所有元素，生成一个新的列表

列表排序

  1. 列表对象的sort()方法
    对原列表中的元素进行排序，排序之后原列表中元素的顺序将发生改变
1
2
3
lst.sort(key=None,reverse=False)
# reverse的值为False时为升序排序，为True时降序排序，默认值为False
# key的值为'str.lower'时，对英文字母排序时将忽略大小写（默认排序时按照字母对应的ASC II进行排序）。
  1. 内置的sorted()函数
    使用sorted()函数排序后，原列表不变，排序后产生一个新的列表对象
1
2
3
4
# sorted(iterable,key=None,reverse=False)
lst=[Cat,apple,Orange,banana]
sorted(lst,key=str.lower)
# 此时为忽略大小写的排序

列表生成式

  • 生成指定范围的数值列表
1
2
3
4
5
6
7
8
# lst=[expression for item in range]
lst=[item for item in range(1,11)]
# 得到[1,2,3,4,5,6,7,8,9,10]
lst=[item*item for item in range(1,11)]
# 得到[1,4,9,16,25,36,49,64,81,100]
import random
lst=[random.randint(1,100) for _ in range(10)]
# 此时会得到10个1-100之间的随机数，for in在这里的作用仅仅是确定次数
  • 从列表中选择符合条件的元素组成新的列表
1
2
3
# lst=[expression for item in 列表 if condition]
lst=[i for i in range(10) if i%2==0]
# 此时会得到列表[0,2,4,6,8]

二维列表

二维列表也称为表格数据，由行和列组成

1
2
3
4
5
6
7
8
9
10
11
12
# 建立一个二维列表
lst=[
    ['city','环比','同比'],
    ['北京',101,103],
    ['上海',101,103],
    ['深圳',101,103]
]
for row in lst:
    for item in row:
        print(item,end='\t')
    print()
# 外层循环为行，内层循环为列

列表生成一个四行五列的列表：

1
2
lst=[(j for j in range(5)) for i in range(4)]
print(lst)

组合数据类型——元组

元组：

  • 一系列按特定顺序排列的元素组成
  • Python中的不可变序列
  • 使用()定义，元素之间使用逗号分隔
  • 元组中的数据可以是任意数据类型

元组的创建：

  • 使用()直接创建元组
  • 使用内置函数tuple()创建元组

元组的删除：

1
del 元组名
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
# 使用()创建元组
t=('hello',[10,20,30],'python','world')
print(t)
# 此时会得到：('hello',[10,20,30],'python','world')
# ------------
# 使用tuple()创建元组
t=tuple('helloworld')
print(t)
# 此时会得到：('h','e','l','l','o','w','o','r','l','d')
# ------------
t=tuple([10,20,30,40])
print(t)
# 此时会得到：(10,20,30,40)
# ------------
t=tuple(range(1,10))
print(t)
# 此时会得到：(1,2,3,4,5,6,7,8,9)
# ************
# 元组也是一种序列，也可以使用序列的相关操作。如：
print('10在元组中是否存在：',(10 in t))
print('10在元组中不存在：',(10 not in t))
print('max:',max(t))
print('min:',min(t))
print('len:',len(t))
print('t.index:',t.index(1))
print('t.count:',t.count(3))
# ************
# 元组中只有一个元素时，应加上“,”
x=(10)
y=(10,)
print(x,type(x))
print(y,type(y))
# 会得到：
# 10 <class 'int'>
# (10,) <class 'tuple'>

元组与列表的区别

列表 元组
可变序列 不可变序列
append(),inset(),remove(),pop()等方法实现添加和删除列表元素 没有这几个方法，无法实现添加删除和修改元素等操作
支持切片访问和修改列表中的元素 支持切片访问元素，不支持修改操作
访问和处理速度慢 访问处理速度快
不能作为字典的键 可以作为字典的键

组合数据类型——字典

  • 键对值
    根据一个信息查找另一个信息的方式构成了“键对值”，它对表示索引用的的键和对应的值构成的成对关系

  • 字典的特征

    • 通过键从字典中获取指定的项，但不能通过索引来获取
    • 字典是无序的，也被称为hash表（散列表）
    • 是Python中的可变序列
    • 字典中的键必须唯一，如果出现两次，后出现的将覆盖先出现的
    • 字典中的键要求是不可变序列

  • 字典的创建

  1. 使用{}直接创建字典
1
d={key1:value1,key2:value2......}
  1. 使用内置函数dict()创建字典
1
2
3
4
# 通过映射函数创建字典
zip(lst1,lst2)
# 通过给定关键字创建字典
dict(key1=value1,key2=value2......)

demo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
# 直接使用{}创建
d={10:'cat',20:'dog',30:'pet',20:'zoo'}
print(d)
# 输出结果：{10:'cat',20:'zoo',30:'pet'}
# -----------
# 使用内置函数dict()创建
# zip函数
lst1=[10,20,30,40]
lst2=['cat','dog','car','zoo']
zipobj=zip(lst1,lst2)
print(zipobj) 
# 此时会得到一个zipobject，我理解为一个压缩包
print(list(zipobj)) 
# 将zipobj转化为列表去查看，just like 解压
# 会得到[(10,'cat'),(20,'dog'),(30,'car'),(40,'zoo')]
d=dict(zipobj)
print(d)
# 此时会输出字典d
# -----------
# 使用参数创建字典
d=dict(cat=10,dog=20) # 参数相当于变量，变量名不加引号
print(d)
# 输出结果：{'cat':10,'dog':20}
# ***********
# 元组可做键
t=(10,20,30)
print({t:10})
# 输出结果为：{(10,20,30):10}
# 列表不可做键
lst=[10,20,30]
print({lst:10})
# TypeError
# ***********
# 字典属于序列类型，可以使用序列的相关操作

Paneer一个成熟稳重的沙雕网友

搬砖永无止境