Python第三篇 Python数据序列

半吊子Kyle

已于 2024-03-30 22:35:05 修改

阅读量386

点赞数 1

分类专栏： python 文章标签： python

于 2021-03-17 19:04:28 首次发布

本文链接：https://blog.csdn.net/hell_oword/article/details/114944390

版权

python 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

第一章字符串

1.1 字符串介绍

Python字符串的底层存储结构

字符串类

Python 的数据类型为 str (字符串) <class 'str'>
字符串的创建

① 单个引号创建
```
a = 'hello world'
```

注：如果变量的值使用了特殊符号，例如'，需要使用转译符号

② 双引号创建

b = "abcdefg"

说明：代码使用这种写法较多

③ 三个引号的创建 (支持换行)

# 第一种
a = ''' i am Tom, 
        nice to meet you! '''
# 第二种
b = """ i am Rose, 
        nice to meet you! """

说明：3种写法中，变量的常用命名中使用第2种较多，但是函数的注释说明使用第3种较多

1.2 格式化输出

格式化输出说明

所谓的格式化输出即按照一定的格式输出内容，对输出的内容进行一定格式的转换

格式化符号

① 格式化规范

格式符号	转换
%s	字符串
%d	有符号的十进制整数
%f	浮点数
%c	字符
%u	无符号十进制整数
%o	八进制整数
%x	十六进制整数（小写ox）
%X	十六进制整数（大写OX）
%e	科学计数法（小写’e’）
%E	科学计数法（大写’E’）
%g	%f和%e的简写
%G	%f和%E的简写

② 格式化示例

%06d，表示输出的整数显示位数，不足以0补全，超出当前位数则原样输出
%.2f，表示小数点后显示的小数位数。

代码示例

age = 18 
name = 'TOM'
weight = 75.5
student_id = 1

# 我的名字是TOM
print('我的名字是%s' % name)
# 我的学号是0001
print('我的学号是%4d' % student_id)
# 我的体重是75.50公斤
print('我的体重是%.2f公斤' % weight)
# 我的名字是TOM，今年18岁了
print('我的名字是%s，今年%d岁了' % (name, age))
# 我的名字是TOM，明年19岁了
print('我的名字是%s，明年%d岁了' % (name, age + 1))
# 我的名字是TOM，明年19岁了 注意：f-格式化字符串是Python3.6中新增的格式化方法，该方法更简单易读
print(f'我的名字是{name}, 明年{age + 1}岁了')

print函数换行说明

# print() 函数的默认加了换行符
print('输出的内容')
print('输出的内容', end="\n") 
# 定制print()函数的结尾符,此时不会换行
print(f'Hi,{name}', end='')

1.3 字符串输入

输入介绍

在 Python中，程序接收用户输入的数据的功能即是输入。
输入的语法

① 当程序执行到input，等待用户输入，输入完成之后才继续向下执行。

② 在Python中，input接收用户输入后，一般存储到变量，方便使用。

③ 在Python中，input会把接收到的任意用户输入的数据都当做字符串处理。

代码示例

# 使用变量接收输入内容
password = input('请输入您的密码：')
# 输出password
print(f'您输入的密码是{password}')

1.4 转译符号

Python中的转义符

转义符	描述
\	续行符(在行尾时)
\	反斜杠符号
’	单引号
"	双引号
\a	响铃
\b	退格(Backspace)
\e	转义
\000	空
\n	换行
\v	纵向制表符
\t	横向制表符
\r	回车
\f	换页
\oyy	八进制数yy代表的字符，例如：\o12代表换行
\xyy	十进制数yy代表的字符，例如：\x0a代表换行
\other	其它的字符以普通格式输出

1.5 字符串查找

字符串索引、下标

“下标”又叫“索引”，就是编号。比如火车座位号，座位号的作用：按照编号快速找到对应的座位。同理，下标的作用即是通过下标快速找到对应的数字
```
name = "abcdef"
print(name[1])
print(name[0])
print(name[2])
```
索引查找：find( )

查找子串在字符串中的位置或出现的次数

① find()

检测某个子串是否包含在这个字符串中，如果在返回这个子串开始的位置下标 (上一个字符的位置)，否则则返回 -1

② 语法
```
mystr = "hello world and hello python and hello java"
# 在15-30下标区间查找‘and’
print(mystr.find('and', 15, 30))
# 整个字符串内查找'and'
print(mystr.find('and'))
```

索引查找：index( )

① index() 方法介绍

检测某个子串是否包含在这个字符串中，如果在返回这个子串开始的位置下标，否则则报异常

② 语法

mystr = "hello world and itcast and itheima and Python"
# 在15-30下标区间查找‘and’
print(mystr.index('and', 15, 30))
# 整个字符串内查找'ands',如果不存在报错
print(mystr.index('ands'))# 报错

从右查找

① 方法介绍

和原方法使用相同，从右开始查找

② 使用语法

# 和find()功能相同，但查找方向为==右侧==开始。
rfind()
# 和index()功能相同，但查找方向为==右侧==开始
rindex()

字符串并统计：count( )

① 方法介绍

返回某个子串在字符串中出现的次数

② 使用语法

mystr = "hello world and itcast and itheima and Python"
# 在15-30下标区间查找‘and’出现的次数
print(mystr.count('and', 0, 20))  # 1
# 整个字符串内查找'ands'的次数
print(mystr.count('and'))  # 3
print(mystr.count('ands'))  # 0

1.6 字符串切片

字符串切片说明

切片是指对操作的对象截取其中一部分的操作，字符串、列表、元组都支持切片操作
字符串切片语法(左闭右开)

序列 [开始位置下标 : 结束位置下标 : 步长]

① 不包含结束位置下标对应的数据，正负整数均可

② 步长是选取间隔，正负整数均可，默认步长为1

代码示例

name = "abcdefg"
print(name[2:5:1])  # cde
print(name[2:5])    # cde
print(name[:5])     # abcde
print(name[1:])     # bcdefg
print(name[:])      # abcdefg
print(name[::2])    # aceg
print(name[:-1])    # abcdef, 负1表示倒数第一个数据
print(name[-4:-1])  # def
print(name[::-1])   # gfedcba

1.7 字符串修改

注：字符串类型的数据修改的时候不能改变原有字符串，属于不能直接修改数据的类型即是不可变类型

replace( )

① 介绍

替换目标字符串中的符合条件的字符串片段，替换后生成一个新的字符串，目标字符串不变

# 替换次数为字符串片段在字符串中出现的次数，如果不指定次数则替换所有符合条件的字符串片段
字符串序列.replace(旧子串, 新子串, 替换次数)

② 使用语法

mystr = "hello world and itcast and itheima and Python"
# 不指定次数，替换所有符合条件的字符串片段
print(mystr.replace('and', 'he'))# 结果：hello world he itcast he itheima he Python

print(mystr.replace('and', 'he', 1))
# 结果：hello world and itcast and itheima and Python
print(mystr)

split()

① 使用说明

按照指定字符分割字符串

② 使用语法

#　使用语法(num表示的是分割字符出现的次数，即将来返回数据个数为num+1个)
字符串序列.split(分割字符, num)
# 使用案例
mystr = "hello world and itcast and itheima and Python"
# 不带切割次数：会切割所有匹配的字符串
mystr.split('and')    # 结果：['hello world ', ' itcast ', ' itheima ', ' Python']
# 带切割次数：按照切割次数从左到右进行切割
mystr.split('and', 1) # 结果：['hello world ', ' itcast and itheima and Python']

③ 注意事项

如果分割字符是原有字符串中的子串，分割后则丢失该子串

join()

① 使用说明

用一个字符或子串合并字符串，即是将多个字符串合并为一个新的字符串

② 使用语法

# 使用语法
字符或子串.join(多字符串组成的序列)
# 使用案例：将字符串组合到元组或者集合中，得到一个新的字符串
list1 = ['chuan', 'zhi', 'bo', 'ke']
t1 = ('aa', 'b', 'cc', 'ddd')
'_'.join(list1)    # 结果：chuan_zhi_bo_ke
'...'.join(t1)     # 结果：aa...b...cc...ddd
# 使用案例：将两个字符传进行组合，会先把目标字符串拆分为集合，然后进行拼接
mystr='hello'
mystr1='-'
mystr1.join(mystr)  # 结果：h-e-l-l-o

capitalize()

① 使用说明

将字符串第一个字符转换成大写

② 使用语法
```
mystr='hello'
mystr.capitalize() # 结果：Hello
```

title()

① 使用说明

将字符串每个单词首字母转换成大写

② 使用语法

mystr = "hello world and itcast and itheima and Python"
mystr.title() # 结果：Hello World And Itcast And Itheima And Python

lower()

① 使用说明

将字符串转为小写

② 使用语法

mystr = "HELLO"
mystr.lower() # 结果：hello world and itcast and itheima and python

upper()

① 使用说明

将字符串转为大写

② 使用语法

mystr = "hello world and itcast and itheima and Python"
mystr.upper() # 结果：HELLO WORLD AND ITCAST AND ITHEIMA AND PYTHON

strip()

① strip()

删除字符串两侧的空白字符

② lstrip()

删除字符串左侧的空白字符

③ rstrip()

删除字符串右侧的空白字符
rjust()、ljust()、center()

① ljust()

返回一个原字符串左对齐,并使用指定字符(默认空格)填充至对应长度的新字符串

② rjust()

返回一个原字符串右对齐,并使用指定字符(默认空格)填充至对应长度的新字符串，语法和ljust()相同

③ center()

返回一个原字符串居中对齐,并使用指定字符(默认空格)填充至对应长度的新字符串，语法和ljust()相同
```
mystr='hello'
# ljust()
mystr.ljust(10,'.')  # 结果：'hello.....'
# rjust()
mystr.rjust(10,'.')  # 结果：'.....hello'
# center()
mystr.center(10,'.') # 结果：'..hello...'
```

1.8 判断

startswith()、endswith()

如果设置开始和结束位置下标，则在指定范围内检查

① startswith()

检查字符串是否是以指定子串开头，是则返回 True，否则返回 False

② endswith()

检查字符串是否是以指定子串结尾，是则返回 True，否则返回 False

③ 使用方法
```
mystr = "hello world and itcast and itheima and Python"

# 结果：True
print(mystr.endswith('Python'))

# 结果：False
print(mystr.endswith('python'))

# 结果：False
print(mystr.endswith('Python', 2, 20))
```
isalpha()、isdigit()、isalnum()

① isalpha()

如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False

② isdigit()

如果字符串只包含数字则返回 True 否则返回 False

③ isalnum()

如果字符串至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False

④ 使用方法
```
mystr1 = 'aaa12345'
mystr2 = '12345-'

# 结果：True
print(mystr1.isalnum())

# 结果：False
print(mystr2.isalnum())
```
isspace()

如果字符串中只包含空白，则返回 True，否则返回 False

1.9 正则表达式

正则表达式

正则表达式就是记录文本规则的代码

re模块的使用

import re


# 使用match方法进行匹配操作
result = re.match("hundsun","com.hundsun")
# 获取匹配结果
info = result.group()
print(info) # hundsun

匹配单个字符

代码	功能
.	匹配任意1个字符（除了\n）
[ ]	匹配[ ]中列举的字符
\d	匹配数字，即0-9
\D	匹配非数字，即不是数字
\s	匹配空白，即空格，tab键
\S	匹配非空白
\w	匹配非特殊字符，即a-z、A-Z、0-9、_、汉字
\W	匹配特殊字符，即非字母、非数字、非汉字

import re

ret = re.match("t.o","too")
print(ret.group()) # too

# 匹配0到9第一种写法
ret = re.match("[0123456789]Hello Python","7Hello Python")
print(ret.group()) # 7Hello Python

# 匹配0到9第二种写法
ret = re.match("[0-9]Hello Python","7Hello Python")
print(ret.group()) # 7Hello Python

ret = re.match("嫦娥\d号","嫦娥2号发射成功") 
print(ret.group()) # 嫦娥2号

ret = re.match("嫦娥\d号","嫦娥3号发射成功") 
print(ret.group())  # 嫦娥3号

match_obj = re.match("\D", "f")
print(match_obj.group()) # f
  
# 匹配非特殊字符中的一位
match_obj = re.match("\w", "A")
print(match_obj.group()) # A

匹配多个字符

代码	功能
*	匹配前一个字符出现0次或者无限次，即可有可无
+	匹配前一个字符出现1次或者无限次，即至少有1次
?	匹配前一个字符出现1次或者0次，即要么有1次，要么没有
{m}	匹配前一个字符出现m次
{m,n}	匹配前一个字符出现从m到n次

# 匹配出一个字符串第一个字母为大小字符，后面都是小写字母并且这些小写字母可 有可无
ret = re.match("[A-Z][a-z]*","Aabcdef")
print(ret.group()) # Aabcdef

# 匹配一个字符串，第一个字符是t,最后一个字符串是o,中间至少有一个字符
match_obj = re.match("t.+o", "two")
print(match_obj.group()) # two

# 匹配出这样的数据，但是https 这个s可能有，也可能是http 这个s没有
match_obj = re.match("https?", "http")
print(match_obj.group()) # https

# 匹配出，8到20位的密码，可以是大小写英文字母、数字、下划线
ret = re.match("[a-zA-Z0-9_]{8,20}","1ad12f23s34455ff66")
print(ret.group()) # 1ad12f23s34455ff66

匹配开头和结尾

代码	功能
^	匹配字符串开头
$	匹配字符串结尾

# 匹配以数字结尾的数据
match_obj = re.match(".*\d$", "hello5")
print(match_obj.group()) # hello5

# 匹配以数字开头中间内容不管以数字结尾
match_obj = re.match("^\d.*\d$", "4hello4")
print(match_obj.group()) # 4hello4

# 第一个字符除了aeiou的字符都匹配
match_obj = re.match("[^aeiou]", "h")
print(match_obj.group()) # h

匹配分组

代码	功能
\|	匹配左右任意一个表达式
(ab)	将括号中字符作为一个分组
`\num`	引用分组num匹配到的字符串
`(?P<name>)`	分组起别名
(?P=name)	引用别名为name分组匹配到的字符串

# 在列表中["apple", "banana", "orange", "pear"]，匹配apple和pear
fruit_list = ["apple", "banana", "orange", "pear"]
# 遍历数据
for value in fruit_list:
    # |    匹配左右任意一个表达式
    match_obj = re.match("apple|pear", value)
    if match_obj:
        print("%s是我想要的" % match_obj.group())
    else:
        print("%s不是我要的" % value)
        
# 匹配出163、126、qq等邮箱
match_obj = re.match("[a-zA-Z0-9_]{4,20}@(163|126|qq|sina|yahoo)\.com", "hello@163.com")
if match_obj:
    print(match_obj.group())
    # 获取分组数据
    print(match_obj.group(1))
else:
    print("匹配失败")

# 匹配qq:10567这样的数据，提取出来qq文字和qq号码
match_obj = re.match("(qq):([1-9]\d{4,10})", "qq:10567")

if match_obj:
    print(match_obj.group())
    # 分组:默认是1一个分组，多个分组从左到右依次加1
    print(match_obj.group(1))
    # 提取第二个分组数据
    print(match_obj.group(2))
else:
    print("匹配失败")
    
# 匹配出<html><h1>www.itcast.cn</h1></html>
match_obj = re.match("<([a-zA-Z1-6]+)><([a-zA-Z1-6]+)>.*</\\2></\\1>", "<html><h1>www.itcast.cn</h1></html>")

if match_obj:
    print(match_obj.group())
else:
    print("匹配失败")
    
# 匹配出<html><h1>www.itcast.cn</h1></html>
match_obj = re.match("<(?P<name1>[a-zA-Z1-6]+)><(?P<name2>[a-zA-Z1-6]+)>.*</(?P=name2)></(?P=name1)>", "<html><h1>www.itcast.cn</h1></html>")

if match_obj:
    print(match_obj.group())
else:
    print("匹配失败")

在这里插入图片描述

第二章列表

2.1 列表介绍

列表介绍

① 可以存储多个数据，按序存

② 可以存储不同类型的数据，可重复（存储的数据不是结构化，太灵活）

③ 列表有正序、倒序两种索引

2.2 获取列表中的信息

index()

在指定的下标范围内查找符合条件的元素的下标

注意：如果查找的数据不存在则报错

# 语法
列表序列.index(数据, 开始位置下标, 结束位置下标)
# 示例
name_list = ['Tom', 'Lily', 'Rose']
name_list.index('Lily', 0, 2)  # 1

count()

统计指定数据在当前列表中出现的次数

name_list = ['Tom', 'Lily', 'Rose']
name_list.count('Lily')  # 1

len()

访问列表长度，即列表中数据的个数

name_list = ['Tom', 'Lily', 'Rose']
len(name_list)  # 3

2.3 判断元素是否存在

判断指定数据在某个列表序列，如果在返回True，否则返回False

name_list = ['Tom', 'Lily', 'Rose']
# 结果：True
print('Lily' in name_list)
# 结果：False
print('Lilys' in name_list)

not in

判断指定数据不在某个列表序列，如果不在返回True，否则返回False

name_list = ['Tom', 'Lily', 'Rose']
# 结果：False
print('Lily' not in name_list)
# 结果：True
print('Lilys' not in name_list)

2.4 列表添加

append()

列表结尾追加数据，如果数据为一个列表，则追加整个列表到列表

注意：列表追加数据的时候，直接在原列表里面追加了指定数据，即修改了原列表，故列表为可变类型数据

name_list = ['Tom', 'Lily', 'Rose']
# 追加普通数据
name_list.append('xiaoming')
# 结果：['Tom', 'Lily', 'Rose', 'xiaoming']

# 追加列表
name_list.append(['xiaoming', 'xiaohong'])
# 结果：['Tom', 'Lily', 'Rose', ['xiaoming', 'xiaohong']]

extend()

列表结尾追加数据，如果数据是一个序列，则将这个序列的数据逐一添加到列表

个人理解：把追加的元素拆分成最小的元素，然后逐一添加到列表中

name_list = ['Tom', 'Lily', 'Rose']
# 添加单个数据
name_list.extend('xiaoming')
# 结果：['Tom', 'Lily', 'Rose', 'x', 'i', 'a', 'o', 'm', 'i', 'n', 'g']

# 添加列表
name_list.extend(['xiaoming', 'xiaohong'])
# 结果：['Tom', 'Lily', 'Rose', 'xiaoming', 'xiaohong']

insert()

指定位置新增数据

# 语法
列表序列.insert(位置下标, 数据)
# 案例
name_list = ['Tom', 'Lily', 'Rose']
name_list.insert(1, 'xiaoming')
# 结果：['Tom', 'xiaoming', 'Lily', 'Rose']

2.5 列表删除

del()

删除列表中的指定数据，会直接对列表进行修改，不会生成新的列表

name_list = ['Tom', 'Lily', 'Rose']
# 删除列表
del name_list
# 结果：报错提示：name 'name_list' is not defined

# 删除列表中指定数据
del name_list[0]
# 结果：['Lily', 'Rose']

pop()

删除指定下标的数据(默认为最后一个)，并返回该数据

name_list = ['Tom', 'Lily', 'Rose']
del_name = name_list.pop(1)
# 结果：Lily
print(del_name)

# 结果：['Tom', 'Rose']
print(name_list)

remove()

移除列表中某个数据的第一个匹配项

# 语法
列表序列.remove(数据)

# 案例
name_list = ['Tom', 'Lily', 'Rose']
name_list.remove('Rose')
# 结果：['Tom', 'Lily']
print(name_list)

clear()

列表清空

name_list = ['Tom', 'Lily', 'Rose']
name_list.clear()
print(name_list) # 结果： []

2.6 列表修改

修改指定下标数据

name_list = ['Tom', 'Lily', 'Rose']
name_list[0] = 'aaa'
# 结果：['aaa', 'Lily', 'Rose']
print(name_list)

reverse()

逆置列表

num_list = [1, 5, 2, 3, 6, 8]
num_list.reverse()
# 结果：[8, 6, 3, 2, 5, 1]
print(num_list)

sort()

对列表中的数据排序

注意：reverse表示排序规则，reverse = True 降序， reverse = False 升序（默认）
```
num_list = [1, 5, 2, 3, 6, 8]

num_list.sort()

# 结果：[1, 2, 3, 5, 6, 8]
print(num_list)
```

2.7 列表复制

copy()

根据目标列表复制出新的列表

name_list = ['Tom', 'Lily', 'Rose']

name_li2 = name_list.copy()

# 结果：['Tom', 'Lily', 'Rose']
print(name_li2)

2.8 列表循环遍历

While循环

name_list = ['Tom', 'Lily', 'Rose']

i = 0
while i < len(name_list):
    print(name_list[i])
    i += 1

For循环

name_list = ['Tom', 'Lily', 'Rose']

for i in name_list:
    print(i)

2.9 列表嵌套

列表嵌套

列表嵌套指的就是一个列表里面包含了其他的子列表

案例

name_list = [['小明', '小红', '小绿'], ['Tom', 'Lily', 'Rose'], ['张三', '李四', '王五']]

# 寻找李四数据

# 第一步：按下标查找到李四所在的列表
print(name_list[2])

# 第二步：从李四所在的列表里面，再按下标找到数据李四
print(name_list[2][1])

第三章元组

3.1 元组介绍

元组介绍

① 可以存储多个数据

② 数据定义后不可修改 (如果元组中的元素类型为类表，数据仍然可以改变，注意该数据不可变的相对性)

③ 数据类型可以不同

④ 使用索引读取数据

元组的定义

① 单个数据元组

注意：如果定义的元组只有一个数据，那么这个数据后面也好添加逗号，否则数据类型为唯一的这个数据的数据类型

# 单个数据元组
t2 = (10,)
print(type(t2))  # tuple

# 不带 ',' 号的元组
t3 = (20)
print(type(t3))  # int

② 多数据元组

# 单一类型元组
t1 = (10, 20, 30)
# 多类型元组
t1: tuple = (['01', '02'], '23', 45)
print(t1)

3.2 元组的常见操作

元素查找

① 根据下标查找数据
```
tuple1 = ('aa', 'bb', 'cc', 'bb')
print(tuple1[0])  # aa
```
② 根据数据查找下标

注意：查找某个数据，如果数据存在返回对应的下标，否则报错，语法和列表、字符串的index方法相同
```
tuple1 = ('aa', 'bb', 'cc', 'bb')
print(tuple1.index('aa'))  # 0
```

count()

统计某个数据在当前元组出现的次数

tuple1 = ('aa', 'bb', 'cc', 'bb')
print(tuple1.count('bb'))  # 2

第四章字典

4.1 字典介绍

字典的使用场景

主要用来存储多个键值对，数据存储更加灵活
字典的使用特点

① 字典数据和数据的顺序没有关系，字典不支持下标查找，只支持按照 key 去查找 value

② 存储多个键值对

③ 数据可变 (可变类型)

字典的创建方式

① 有数据的字典

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

② 空字典

dict2 = {}

③ 函数创建

dict3 = dict()

4.2 字典基础操作

查询字典项

① 根据 key 值查找

注意 : 如果不存在会报错

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1['name'])  # Tom
print(dict1['id'])  # 报错

② get() 查找

注意：存在则返回，不存在则返回None，有默认值则返回默认值

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

# key存在返回value
print(dict1.get('name'))  # Tom

# key不存在返回设置的默认值
print(dict1.get('id', 110))  # 110

# key不存在返回None
print(dict1.get('id'))  # None

③ keys() : 返回字典的key列表

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
dict1_list = dict1.keys()
print(dict1_list)

④ values()：返回字典的值列表

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
keys_list = dict1.keys()
print(keys_list) # keys_list(['name', 'age', 'gender'])

⑤ items()：返回字典内容

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.items())  # dict_items([('name', 'Tom'), ('age', 20), ('gender', '男')])

新增字典项

# 示例一 : 存在则修改
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
dict1['name'] = 'Rose'
print(dict1) # {'name': 'Rose', 'age': 20, 'gender': '男'}

# 示例二 : 不存在则新增
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
dict1['id'] = 110
print(dict1) # {'name': 'Rose', 'age': 20, 'gender': '男', 'id': 110}

删除字典项

① del() / del：删除字典或删除字典中指定键值对

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
# 第一种删除
del dict1['gender']
# 第二种删除
del (dict1['age'])
print(dict1) # {'name': 'Tom', 'age': 20}

② clear()：清空字典

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
dict1.clear()
print(dict1)  # {}

4.3 升级操作

循环遍历

① 遍历字典key列表

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
# 遍历字典key列表
for key in dict1.keys():
    print(key)

② 遍历值列表

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for value in dict1.values():
    print(value)

③ 遍历字典元素(内容)

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for item in dict1.items():
    print(item)

④ 遍历键值对

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for key, value in dict1.items():
    print(f'{key} = {value}')

第五章集合

4.1 集合介绍

集合介绍

集合在实际使用场景的效率没有 list、dict、tuple 的场景那么多，使用的场景比较单一
集合特点

① 集合可以去掉重复数据

② 集合数据是无序的，故不支持下标

③ 可变，与之对应的不可变的为 frozenset

集合的创建

# 非空集合的创建
set1 = {10, 20, 30, 30, 50}
# 空集合的创建
set2 = set()
# 空字典的创建（注意区分）
dict1 = {}

4.2 集合的常见操作

增加数据

集合有去重功能，所以，当向集合内追加的数据是当前集合已有数据的话，则不进行任何操作

# add()
s1 = {10, 20}
s1.add(100)
s1.add(10)
print(s1)  # {100, 10, 20}
# update():只能添加有 iterable 的元素
set1 = {10, 20, 30, 40, 50}
set1.update('abc')
set1.update([10, 20, 30])

删除数据

# remove():删除集合中的指定数据，如果数据不存在则报错
set1 = {10, 20, 30, 40, 50}
set1.remove(60)
# discard()，删除集合中的指定数据，如果数据不存在不会报错
set1 = {10, 20, 30, 40, 50}
set1.discard(60)
# pop()，随机删除集合中的某个数据，并返回这个数据
set1 = {10, 20, 30, 40, 50}
set1.pop()

查询数据

set1 = {10, 20, 30, 40, 50}
# in：判断数据在集合序列
print(10 in s1)
# not in：判断数据不在集合序列
print(10 not in s1)

第六章公共操作

6.1 运算符

常用的运算符

运算符	描述	支持的容器类型
+	合并	字符串、列表、元组
*	复制	字符串、列表、元组
in	元素是否存在	字符串、列表、元组、字典
not in	元素是否不存在	字符串、列表、元组、字典

# 1. 字符串 
str1 = 'aa'
str2 = 'bb'
str3 = str1 + str2
print(str3)  # aabb

# 2. 列表 
list1 = [1, 2]
list2 = [10, 20]
list3 = list1 + list2
print(list3)  # [1, 2, 10, 20]

# 3. 元组 
t1 = (1, 2)
t2 = (10, 20)
t3 = t1 + t2
print(t3)  # (10, 20, 100, 200)

# 1. 字符串
print('-' * 10)  # ----------

# 2. 列表
list1 = ['hello']
print(list1 * 4)  # ['hello', 'hello', 'hello', 'hello']

# 3. 元组
t1 = ('world',)
print(t1 * 4)  # ('world', 'world', 'world', 'world')

in或not in

# 1. 字符串
print('a' in 'abcd')  # True
print('a' not in 'abcd')  # False

# 2. 列表
list1 = ['a', 'b', 'c', 'd']
print('a' in list1)  # True
print('a' not in list1)  # False

# 3. 元组
t1 = ('a', 'b', 'c', 'd')
print('aa' in t1)  # False
print('aa' not in t1)  # True

6.2 公共方法

len()：计算容器中的元素个数

# 1. 字符串
str1 = 'abcdefg'
print(len(str1))  # 7

# 2. 列表
list1 = [10, 20, 30, 40]
print(len(list1))  # 4

# 3. 元组
t1 = (10, 20, 30, 40, 50)
print(len(t1))  # 5

# 4. 集合
s1 = {10, 20, 30}
print(len(s1))  # 3

# 5. 字典
dict1 = {'name': 'Rose', 'age': 18}
print(len(dict1))  # 2

del 或 del()：删除元素

# 1. 字符串
str1 = 'abcdefg'
del str1   # python有GC机制，所以，del语句作用在变量上，删除的是变量，内存中的数据仍然存在
print(str1)

# 2. 列表
list1 = [10, 20, 30, 40]
del(list1[0]) # del list1[0]
print(list1)  # [20, 30, 40]

max()：返回容器中元素最大值

# 1. 字符串
str1 = 'abcdefg'
print(max(str1))  # g

# 2. 列表
list1 = [10, 20, 30, 40]
print(max(list1))  # 40

min()：返回容器中元素最小值

# 1. 字符串
str1 = 'abcdefg'
print(min(str1))  # a

# 2. 列表
list1 = [10, 20, 30, 40]
print(min(list1))  # 10

range():生成从start到end的数字，步长为 step，供for循环使用

注：range()生成的序列不包含end数字

# 1 2 3 4 5 6 7 8 9
for i in range(1, 10, 1):
    print(i)

# 1 3 5 7 9
for i in range(1, 10, 2):
    print(i)

# 0 1 2 3 4 5 6 7 8 9
for i in range(10):
    print(i)

enumerate()

# 语法：start参数用来设置遍历数据的下标的起始值，默认为0
enumerate(可遍历对象, start=0)
# 使用方法
list1 = ['a', 'b', 'c', 'd', 'e']

for i in enumerate(list1):
    print(i)

for index, char in enumerate(list1, start=1):
    print(f'下标是{index}, 对应的字符是{char}')

6.3 容器类型转换

tuple():将某个序列转换成元组

list1 = [10, 20, 30, 40, 50, 20]
s1 = {100, 200, 300, 400, 500}
print(tuple(list1))
print(tuple(s1))

list():将某个序列转换成列表

t1 = ('a', 'b', 'c', 'd', 'e')
s1 = {100, 200, 300, 400, 500}

print(list(t1))
print(list(s1))

set():将某个序列转换成集合

list1 = [10, 20, 30, 40, 50, 20]
t1 = ('a', 'b', 'c', 'd', 'e')

print(set(list1))
print(set(t1))

6.4 推导式（生成式）

推导式介绍

用一个表达式创建一个有规律的列表或控制一个有规律列表

列表推导式（列表生成式）

# 使用一般方式创建
list1 = []
for item in range(1, 10):
    list1.append(item)
print(list1)

# 使用推导式创建
list1 = [i for i in range(10)]
print(list1)

# 只增加偶数:步长实现
list1 = [i for i in range(0, 10, 2)]
print(list1)

# 只增加偶数:if实现
list1 = [i for i in range(10) if i % 2 == 0]
print(list1)

# 多个for循环实现列表推导式
# [(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
list1 = [(i, j) for i in range(1, 3) for j in range(3)]
print(list1)

字典推导式

快速合并列表为字典或提取字典中目标数据

list6 = ['MBP', 'HP', 'DELL', 'Lenovo', 'acer']
list7 = [268, 125, 201, 199, 99]
# 语法
dict1 = {list6[i]: list7[i] for i in range(len(list6))}
# {'MBP': 268, 'HP': 125, 'DELL': 201, 'Lenovo': 199, 'acer': 99}

集合推导式

快速生成集合

list1 = ['MBP', 'HP', 'DELL', 'Lenovo', 'acer']
set1 = {list1[i] for i in range(len(list1))}
print(set1)
# {'DELL', 'Lenovo', 'HP', 'acer', 'MBP'}
# <class 'set'>

6.4 生成器

生成器介绍

根据程序员制定的规则循环生成数据，当条件不成立时则生成数据结束。数据不是一次性全部生成处理，而是使用一个，再生成一个，可以节约大量的内存
生成器的创建方式

① 生成器推导式

与列表推导式类似，只不过生成器推导式使用小括号

② yield关键字

生成器推导式

# 创建生成器
my_generator = (i * 2 for i in range(5))
print(my_generator)

# next获取生成器下一个值
# value = next(my_generator)
# print(value)

# 遍历生成器
for value in my_generator:
    print(value)

yiled关键字

def mygenerater(n):
    for i in range(n):
        print('开始生成...')
        yield i
        print('完成一次...')


if __name__ == '__main__':

    g = mygenerater(2)
    # 获取生成器中下一个值
    # result = next(g)
    # print(result)

    # while True:
    #     try:
    #         result = next(g)
    #         print(result)
    #     except StopIteration as e:  # 生成完成后会报异常
    #         break

    # # for遍历生成器, for 循环内部自动处理了停止迭代异常，使用起来更加方便
    for i in g:
        print(i)

yiled 的执行原理

代码执行到 yield 会暂停，然后把结果返回出去，下次启动生成器会在暂停的位置继续往下执行

生成器如果把数据生成完成，再次获取生成器中的下一个数据会抛出一个StopIteration 异常，表示停止迭代异常

while 循环内部没有处理异常操作，需要手动添加处理异常操作

for 循环内部自动处理了停止迭代异常，使用起来更加方便，推荐大家使用

斐波拉契数列通过生成器实现

def fibonacci(num):
    a = 0
    b = 1

    # 记录生成fibonacci数字的下标
    current_index = 0

    while current_index < num:
        result = a
        a, b = b, a + b
        current_index += 1
        # 代码执行到yield会暂停，然后把结果返回出去，下次启动生成器会在暂停的位置继续往下执行
        yield result


fib = fibonacci(5)
# 遍历生成的数据
for value in fib:
    print(value)

半吊子Kyle

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
Python第三篇 Python数据序列

Python第三篇 Python数据序列及函数第一章字符串1.1 字符串介绍1.2 格式化输出1.3 字符串输入1.4 转译符号1.5 字符串查找1.6 字符串切片1.7 字符串修改1.7 判断第二章列表2.1 列表介绍2.2 获取列表中的信息2.3 判断元素是否存在2.4 列表添加2.5 列表删除2.6 列表修改2.7 列表复制2.8 列表循环遍历2.9 列表嵌套第三章元组3.1 元组介绍3.2 元组的常见操作第四章字典4.1 字典介绍4.2 字典基础操作4.3 升级操作第五章集合4.1 集合介
复制链接

扫一扫