目录
一、序列和索引
1，序列和索引定义
序列是一个用于存储多个值的连续空间，每个值都对应一个整数的编号，成为索引。
2，索引分类
- 正向递增索引：0，1，2，...，N-1
- 反向递减索引：-N...-3，-2，-1
#正向递增
s = 'helloworld'
for i in range(0,len(s)):
print(i,s[i],end='\t\t')
print('\n-------------------')
#反向递减
for i in range(-len(s),0):
print(i,s[i],end='\t\t')0 h 1 e 2 l 3 l 4 o 5 w 6 o 7 r 8 l 9 d
-------------------
-10 h -9 e -8 l -7 l -6 o -5 w -4 o -3 r -2 l -1 d
3，切片操作的语法结构
序列[start:end:step]
start：切片的开始索引，包含
end：切片的结束索引，不包含
step：步长，默认为1，步长为-1时字符串逆序输出
s = 'helloworld'
#切片换片
s1 = s[0:5:2]
print(s1)
#省略开始位置，默认start从0开始
print(s[:5:1])
#省略开始位置，省略步长，默认步长为1
print(s[:5:])
#省略结束位置,stop不写，默认取到最后一个元素
print(s[0::1])
#省略结束位置和步长，默认取到最后一个元素
print(s[0::])
print(s[0:])hlo
hello
hello
helloworld
helloworld
helloworld
s = 'helloworld'
#切片换片
s1 = s[::-1]
print(s1)dlrowolleh
4，序列的相加和相乘操作
s1 = 'hello'
s2 = 'world'
print(s1+s2)
print(s1*5)helloworld
hellohellohellohellohello
5，序列的操作符/函数
| 操作符/函数 | 描述说明 |
|---|---|
| x 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，列表定义
列表是指一系列的按特定顺序排列的元素组成。
列表是Python中内置的可变序列。
可变序列：具有增、删、改、查功能的序列，列表是Python中第一个学习的可变数据类型。
列表在Python中使用[]定义列表，元素与元素之间使用英文逗号分隔。
列表中的元素可以是任意的数据类型。
2，列表的创建方式
（1）使用[]直接创建列表
列表名 = [element1,element2,...]
（2）使用内置函数list()创建列表
列表名 = list(序列)
#每一个序列的元素作为列表的元素单独输出
lst1 = ['hello','world',98,20]
print(lst1)
lst2 = list('hello world')#每一个元素单独输出
lst3 = list(range(1,10,2))
print(lst2)
print(lst3)['hello', 'world', 98, 20]
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']
[1, 3, 5, 7, 9]
列表也可以用上面序列的操作符号/函数
3，列表的删除
del 列表名
4，列表的遍历 (枚举——enumerate枚举函数)
1，遍历元素item
for item in lst:
print(item)
2，遍历索引i
for i in range(0,len(列表)):
print((列表[i])
3，enumerate()函数
for index,index in enumerate(列表)
输出index和item
index是序号，不是索引，索引不能修改起始值，序号可以修改起始值
item是元素
lst = ['hello','world','python','php']
#使用遍历循环for循环遍历列表元素
for item in lst:
print(item)
#使用for循环，range()函数，len()函数，根据索引进行遍历
for i in range(0,len(lst)):
print(i,'-->',lst[i])
#第三种遍历方式enumwrate()函数
for index,item in enumerate(lst):
print(index,item)#index 是序号，不是索引
print('修改序号的起始值')
#index是序号，那么就可以手动修改序号的起始值，索引就不能修改了
for index,item in enumerate(lst,start = 2):
print(index,item)hello
world
python
php
0 --> hello
1 --> world
2 --> python
3 --> php
0 hello
1 world
2 python
3 php
修改序号的起始值
2 hello
3 world
4 python
5 php进程已结束,退出代码0
5，列表的相关操作方法
| 列表的方法 | 描述说明 |
| lst.append(x) | 在列表l最后增加一个元素 |
| lst.insert(index,x) | 在列表中第index位置增加一个元素 |
| lst.clear() | 清除列表中的所有元素 |
| lst.pop(inddex) | 将列表中第index位置的元素取出，并从列表中将其删除 |
| lst.remove(x) | 将列表中出现的第一个元素x删除 |
| lst.reverse() | 将列表中的元素反转，没有返回值 |
| lst.copy() | 拷贝列表中的所有元素，生成一个新的列表 |
lst = ['hello','world','python']
#输出原列表及原列表的内存地址
print('原列表：',lst,id(lst))
#在最后增加元素
lst.append('sql')
print('增加元素之后：',lst,id(list))
#在中间插入元素，在索引值为2的地方增加一个字整型100
lst.insert(2,100)
print(lst)
#将列表中某个索引对应的元素取出，并从列表中删除该元素
lst.pop(1)
print(lst)
#将列表中第一次出现的100删除
lst.remove(100)
print(lst)
#将列表中的某个元素反转
lst.reverse()#在原列表的基础上进行，不会产生新的列表
print(lst)
#列表的复制
lst_2 = lst.copy()
print(lst_2)
#根据索引修改列表元素的修改操作
lst[0] = 'Java'
print(lst)
#列表的清空
lst.clear()
print(lst)原列表： ['hello', 'world', 'python'] 1587900600840
增加元素之后： ['hello', 'world', 'python', 'sql'] 140708863819056
['hello', 'world', 100, 'python', 'sql']
['hello', 100, 'python', 'sql']
['hello', 'python', 'sql']
['sql', 'python', 'hello']
['sql', 'python', 'hello']
['Java', 'python', 'hello']
[]
6，列表的排序操作
1，列表排序的两种方式
（1）列表对象的sort方法
lst.sort(key=None,reverse=False)
key表示排序的规则；reverse表示排序方式，默认升序
（2）内置函数sorted()
sorted(iterable,key=None,reverse=False)
iterable表示的是排序的对象
2，数值排序sort
lst = [21,54,13,19,89,52,24,19]
print('原列表：',lst)
#排序，默认是升序
lst.sort()#排序是在原列表的基础上进行的，不会产生新的列表对象
print('升序：',lst)
#排序，降序
lst.sort(reverse=True)
print('降序：',lst)原列表： [21, 54, 13, 19, 89, 52, 24, 19]
升序： [13, 19, 19, 21, 24, 52, 54, 89]
降序： [89, 54, 52, 24, 21, 19, 19, 13]
3，英文字母排序sort
按照ASCII码值进行排序，英文单词也是按照首字母排序
升序排序：先排大写，因为大写比小写的ASCII码小32
lst = ['banana','apple','Cat','Orange']
print('原列表：',lst)
#升序排序，先排大写后排小写
lst.sort()
print('升序',lst)
#降序排序
lst.sort(reverse = True)
print("降序：",lst)原列表： ['banana', 'apple', 'Cat', 'Orange']
升序 ['Cat', 'Orange', 'apple', 'banana']
降序： ['banana', 'apple', 'Orange', 'Cat']
4，自己设定规则排序sort
lst = ['banana','apple','Cat','Orange']
print('原列表：',lst)
#自己指定规则：忽略大小写进行比较
lst.sort(key = str.lower)#将单词全都转成小写
print('忽略大小写：',lst)原列表： ['banana', 'apple', 'Cat', 'Orange']
忽略大小写： ['apple', 'banana', 'Cat', 'Orange']
5，数值排序sorted
使用内置的sorted函数进行排序，会生成一个新的列表对象。
lst = [4,56,3,78,40,56,89]
print('原列表：',lst)
#sorted函数会生成一个新的列表对象，所以使用sorted函数需要赋值给另一个新的列表对象
#升序
asc_lst = sorted(lst)
print("升序",asc_lst)
#原列表没有任何改变
print('原列表：',lst)
#降序
desc_lst = sorted(lst,reverse=True)
print('降序：',desc_lst)
print('原列表：',lst)原列表： [4, 56, 3, 78, 40, 56, 89]
升序 [3, 4, 40, 56, 56, 78, 89]
原列表： [4, 56, 3, 78, 40, 56, 89]
降序： [89, 78, 56, 56, 40, 4, 3]
原列表： [4, 56, 3, 78, 40, 56, 89]
6，英文字母排序sorted
lst = ['banana','apple','Cat','Orange']
print('原列表：',lst)
#忽略大小写进行排序
asc_lst = sorted(lst,key = str.lower)
print('升序：',asc_lst)
print('原列表：',lst)原列表： ['banana', 'apple', 'Cat', 'Orange']
升序： ['apple', 'banana', 'Cat', 'Orange']
原列表： ['banana', 'apple', 'Cat', 'Orange']
7，列表生成式
使用列表生成式创建列表，列表生成式的语法结构如下：
lst = [expression for item in range]
lst = [expression for item in range if condition]
import random
lst = [item for item in range(1,11)]
print(lst)
lst = [item*item for item in range(1,11)]
print(lst)
lst = [random.randint(1,100)for _ in range(1,11)]
print(lst)
#从列表中选择符合条件的元素组成新的列表
lst = [i for i in range(10) if i%2==0]
print(lst)[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
[61, 18, 4, 74, 50, 80, 30, 59, 96, 41]
[0, 2, 4, 6, 8]
8，二维列表
二维列表：表格数据，在一个列表中嵌套了很多个列表
二维列表的遍历：
for row in 二维列表：
for item in row:
pass
#创建二维列表
lst = [
['城市','环比','同比'],
['北京',104,103],
['上海',104,504],
['深圳',100,39]
]
print(lst)
#遍历二维列表使用双层for循环
for row in lst:#行
for item in row:#列
print(item,end = '\t')#打印每一行中所有列的元素
print()
#用列表生成式生成一个4行5列的二维列表
lst = [[j for j in range(5)] for i in range(4)]
print(lst)[['城市', '环比', '同比'], ['北京', 104, 103], ['上海', 104, 504], ['深圳', 100, 39]]
城市 环比 同比
北京 104 103
上海 104 504
深圳 100 39
[[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]
三、元组
1，元组的定义
元组是Python中的不可变序列，没有增删改的操作，只能访问
使用()定义元组，元素与元素之间使用英文逗号分隔
元组中只有一个元素的时候，逗号也不能省略
2，元组的创建方式
（1）使用()直接创建元组
元组名 = （element1,element2,...elementN）
（2）使用内置函数tuple()创建元组
元组名 = tuple(序列)
3，删除元组
del 元组名
元组是一种序列，所以序列的操作对于元组同样适用。
#使用小括号创建元组
t = ('hello','world',[10,20,30,'python'])
print(t)
#使用内置函数创建元组
t = tuple('helloword')
print(t)
t = tuple([10,20,30])
print(t)
print('10在元组中是否存在：',(10 in t))
print('10在元组中是否不存在：',(10 not in t))
print('最大值：',max(t))
print('最小值：',min(t))
print('长度：',len(t))
print('查找元素对应的索引下标：',t.index(10))
print('统计10出现的次数:',t.count(10))
#如果元组中只有一个元素
t = (10,)
print(t)
del t
print(t)('hello', 'world', [10, 20, 30, 'python'])
('h', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'd')
(10, 20, 30)
10在元组中是否存在： True
10在元组中是否不存在： False
最大值： 30
最小值： 10
长度： 3
查找元素对应的索引下标： 0
统计10出现的次数: 1
(10,)
Traceback (most recent call last):
File "E:/Pycharm projects/chap4/元组的创建与删除.py", line 26, in <module>
print(t)
NameError: name 't' is not defined
4，元组的访问与遍历
t = ('python','hello','world')
#根据索引访问元素
print(t[0])
#元组的切片操作
t2 = t[0:3:2]
print(t2)
#元组的遍历
for item in t:
print(item)
for i in range(len(t)):
print(i,t[i])
for index,item in enumerate(t,start = 11):
print(index,'------>',item)python
('python', 'world')
python
hello
world
0 python
1 hello
2 world
11 ------> python
12 ------> hello
13 ------> world进程已结束,退出代码0
四、字典
字典类型是根据一个信息查找另一个信息的方式构成了“键值对”，它表示索引用的键的对应的值构成的成对关系。
字典和列表一样，都是可变数据类型。键是不可变数据类型，值可以变。键相同时，值会覆盖。
元组可以作为列表中的键，但列表不可以作为列表中的键。元组是不可以变数据类型，列表是可变数据类型。
字典属于序列，序列中的操作字典同样适用。
1，字典的创建方式
（1）使用{}直接创建字典
d={key1:value1,key2:value2......}
（2）使用内置函数dict()创建字典
①通过映射函数创建字典
zip(lst1,lst2)
lst1是键，lst2是值
②dict(key1=value1,key2=value2...)
#（1）创建字典
d = {10:'cat',20:'dog',30:'pet',20:'zoo'}
print(d)#当键有重复时，后面键对应的值对前面键对应的值进行了一个覆盖
#（2）zip函数
lst1=[10,20,30,40]
lst2=['cat','dog','pet','zoo','car']
zipobj=zip(lst1,lst2)
print(zipobj)#输出是一个zip对象
#print(list(zipobj))#将zip映射对象转成列表类型
#将映射对象转成字典
d=dict(zipobj)
print(d)
#使用参数创建字典
d=dict(cat=10,dog=20)#左边的是键，右边的是值
print(d)
#元组可以作为字典中的键
t=(10,20,30)
print({t:10})#t是key，10是value
#字典属于序列
print('max:',max(d))
print('min:',min(d))
print('len',len(d))
#字典的删除
del d
print(d){10: 'cat', 20: 'zoo', 30: 'pet'}
<zip object at 0x0000021DE56F7648>
{10: 'cat', 20: 'dog', 30: 'pet', 40: 'zoo'}
{'cat': 10, 'dog': 20}
{(10, 20, 30): 10}
max: dog
min: cat
len 2
Traceback (most recent call last):
File "E:/Pycharm projects/chap4/字典的创建与删除.py", line 31, in <module>
print(d)
NameError: name 'd' is not defined
2，字典元素的取值
字典是没有整数索引值的，不能通过整数索引来取值。
d[key]或d.get(key)
二者之间有区别，如果键key不存在，d[key]会报错，但是d.get(key)可以指定默认值。
3，字典元素的遍历
（1）遍历出key与value的元组：
for element in d.items():
pass
（2）分别遍历出key和value
for key,value in d.items():
pass
d = {'hello':10,'world':20,'python:':30}
#访问字典中的元素
#（1）使用d[key]
print(d['world'])
#（2）d.get(key)
print(d.get('hello'))
#字典的遍历
for item in d.items():
print(item)#由key和value组成的元组
#在使用for循环遍历时，分别获取key,value
for key,value in d.items():
print(key,'----->',value)20
10
('hello', 10)
('world', 20)
('python:', 30)
hello -----> 10
world -----> 20
python: -----> 30
3，字典的相关操作
字典是可变数据类型。下面表格中的d指的是字典名。
| 字典的方法 | 描述说明 |
| d.keys() | 获取所有的key数据 |
| d.values() | 获取所有的value数据 |
| d.pop(key,default) | key存在获取相应的value，同时删除key-value对，否则获取默认值 |
| d.popitem() | 随机从字典中取出一个key-value对，结果为元组类型，同时将该key-value从字典删除 |
| d.clear() | 清空字典中所有的key-value操作 |
| d.items() | 以列表的形式返回可遍历的元组数组 |
dd = {1001:'李梅',1002:'王华',1003:'张峰'}
print(dd)
#向字典中添加元素
dd[1004]='张丽'#直接使用赋值的方式向字典中添加元素
print(dd)
#获取字典中所有的key
keys=dd.keys()
print(keys)#得到一个对象dict_keys
#将对象转成一个列表类型查看元素
print(list(dd))#转成列表是[]
#将对象转成一个元组类型查看元素
print(tuple(dd))#转成元组是()
#获取字典中所有的值
values=dd.values()
print(list(values))
#如何将字典中的数据转成key-value的形式，以元组的方式进行展现。以列表的形式返回可遍历的元组数组
lst=list(dd.items())
print(lst)
#将列表转成字典
dd=dict(lst)
print(dd)
#d.pop函数通过key取出value，然后将key-value删除
print(dd.pop(1001))
print(dd)
#删除一个不存在的key
print(dd.pop(1008,'不存在'))
#随机删除
print(dd.popitem())
print(dd)
#清空字典中所有的元素
dd.clear()
print(dd)
#python中一切皆对象，每一个对象都有一个布尔值
print(bool(dd))#空字典的布尔值为false{1001: '李梅', 1002: '王华', 1003: '张峰'}
{1001: '李梅', 1002: '王华', 1003: '张峰', 1004: '张丽'}
dict_keys([1001, 1002, 1003, 1004])
[1001, 1002, 1003, 1004]
(1001, 1002, 1003, 1004)
['李梅', '王华', '张峰', '张丽']
[(1001, '李梅'), (1002, '王华'), (1003, '张峰'), (1004, '张丽')]
{1001: '李梅', 1002: '王华', 1003: '张峰', 1004: '张丽'}
李梅
{1002: '王华', 1003: '张峰', 1004: '张丽'}
不存在
(1004, '张丽')
{1002: '王华', 1003: '张峰'}
{}
False
空列表的布尔值为False
空元组的布尔值为False
空字典的布尔值为False
4，字典生成式
d = {key:value for item in range}
d = {key:value for key,value in zip(lst1,lst2}
import random
d = {item:random.randint(1,100) for item in range(4)}
print(d)
#创建两个列表
lst1 = [10001,1002,1003]
lst2 = ['王艺艺','李涛','李华']
d = {key:value for key,value in zip(lst1,lst2)}
print(d){0: 78, 1: 16, 2: 41, 3: 94}
{10001: '王艺艺', 1002: '李涛', 1003: '李华'}
五、集合
1，集合的概念
Python中的集合与数学中集合的概念一致
集合是一个无序的不重复元素序列
集合只能存储不可变数据类型，不能存储列表和存储
集合使用{}定义
集合与列表、字典一样，都是Python中的可变数据类型
2，集合的创建方式
（1）使用{}直接创建集合
s = {element1,element2,...}
（2）使用内置函数set()创建集合
s = set(可迭代对象）
3，集合的删除
del 集合名
#使用{}创建集合
s = {10,20,30,40}
print(s)
s = {}
print(s,type(s))#创建的是字典
#使用set创建集合
s = set()#创建空集合，空集合的布尔值是False
print(s)
s = set('hello world')
print(s)#无序且不重复
s2 = set([10,20,30])#列表中的元素是不可变数据类型
print(s2)
s3 = set(range(1,10))
print(s3)
#集合是序列当中的一种
print('max:',max(s3))
print('min:',min(s3))
print('len:',len(s3))
print('9在集合的当中存在吗？',(9 in s3))
print('9在集合的当中不存在吗？',(9 not in s3))
#集合的删除操作
del s3
print(s3){40, 10, 20, 30}
{} <class 'dict'>
set()
{'r', 'o', ' ', 'd', 'w', 'h', 'l', 'e'}
{10, 20, 30}
{1, 2, 3, 4, 5, 6, 7, 8, 9}
max: 9
min: 1
len: 9
9在集合的当中存在吗？ True
9在集合的当中不存在吗？ False
Traceback (most recent call last):
File "E:/Pycharm projects/chap4/集合的创建与删除.py", line 30, in <module>
print(s3)
NameError: name 's3' is not defined进程已结束,退出代码1
4，集合的相关操作
| 操作符 | 描述 |
| A&B | 交集 |
| A|B | 并集 |
| A-B | 差集 |
| A^B | 补集 |
A = {10,20,30,40,50}
B = {30,50,88,76,20}
print(A&B)
print(A|B)
print(A-B)
print(A^B){50, 20, 30}
{40, 10, 76, 50, 20, 88, 30}
{40, 10}
{10, 88, 40, 76}
5，集合的增删改
| s.add(x) | 若x没有在集合中，增加x到集合中 |
| s.remove(x) | 若x在集合中，删除x；若x没有在集合中，程序报错 |
| s.clear() | 清空集合中所有元素 |
A = {10,20,30,40,50}
A.add(100)
print(A)
A.remove(20)
print(A)
A.clear()
print(A){100, 40, 10, 50, 20, 30}
{100, 40, 10, 50, 30}
set()
6，集合的遍历
for item in 集合:
print(item)
for index,item in enumerate(集合)or(集合，start=xxx)
print(index,item)
这里的index是序号，不是索引，序号可以指定默认初始值，默认从0开始。
A = {10,20,30,40,50}
for item in A:
print(item)
for index,item in enumerate(A,start=10):
print(index,'------>',item)40
10
50
20
30
10 ------> 40
11 ------> 10
12 ------> 50
13 ------> 20
14 ------> 30进程已结束,退出代码0
7，集合的生成式
A = {i for i in range(1,11}
其中，range()表示循环次数
A = (i for i in range(1,11))
print(A)#A是一个集合对象
#集合列表化
print(list(A))<generator object <genexpr> at 0x000001AA72396448>
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
六、几种数据类型的区别
| 数据类型 | 序列类型 | 元素是否可重复 | 是否有序 | 定义符号 |
| 列表list | 可变序列 | 可重复 | 有序 | [] |
| 元组tuple | 不可变序列 | 可重复 | 有序 | {} |
| 字典dict | 可变序列 | Key不可重复 | 无序 | {key:value} |
| 集合set | 可变序列 | 不可重复 | 无序 | {} |
1041
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
