花有重开日，人无再少年
趁当下年轻，学习Python
——Lungcen
目录
什么是序列
Python中应用最广泛的数据类型就是序列，序列包括元组、列表、集合、字典、字符串
其中的列表属于可变数据类型
序列特性——索引
序列中，每个元素都有属于自己的编号（索引），从起始元素开始，索引值从 0 开始递增
还支持索引值是负数，此类索引是从右向左计，除了从头开始，序列的索引还支持从最后一个元素开始计数，索引值从-1开始
序列特性——切片
切片操作是访问序列中元素的另一种方法，它可以访问一定范围内的元素，通过切片操作，可以生成一个新的序列。不过需要注意的是，这些都是含头不含尾
sname[start : end : step]
sname：表示序列的名称
start：表示切片的开始索引位置（包括该位置），此参数也可以不指定，会默认为 0
end：表示切片的结束索引位置（不包括该位置），如果不指定，则默认为序列的长度
step：表示在切片过程中，隔几个存储位置（包含当前位置）取一次元素，也就是说，
如果 step 的值大于 1，则在进行切片去序列元素时，会“跳跃式”的取元素
str1 = '好好学习，天天向上' print(str1[:2]) # 取索引区间为[0,2]之间（不包括索引2处的字符）的字符串 print(str1[::2]) # 隔 1 个字符取一个字符，区间是整个字符串 print(str1[:]) # 取整个字符串，此时 [] 中只需一个冒号即可 print(str1[1:7:2]) # 取从第一个（逻辑位置）到第六个（逻辑位置），并且两个一组选第二个
序列连接——相加
Python 中支持两种类型相同的序列使用“+”运算符做相加操作，它会将两个序列进行连接，但不会去除重复的元素。
捕获关键字两种类型相同的序列，可知它需要类型相同，并且需要是序列。
不能是一个列表 + 一个字符串，因为两者虽然是序列，但是他们的类型不相同
不能是一个数值 + 一个数值，两者类型相同，但是不是序列，所以不会进行连接
序列连接——相乘
使用数字 n 乘以一个序列会生成新的序列，其内容为原来序列被重复 n 次的结果。
str = '好好学习，天天向上' print(str * 5) #可以输出五个str
检查元素是否包含在序列中
使用 in 关键字 检查某元素是否为序列的成员
使用 not in 关键字 检查某个元素是否不包含在指定的序列中
str = 'www.baidu.com' print("baidu" in str) #True print("baidu" not in str) #False
序列相关的内置函数
相关的内置函数中比较重要的是：
len()、list()、str()、sorted()、reversed()、enumerate()
len()，可以获取序列的长度，返回序列中有多少个元素，常用于for循坏
list()，将序列转化为列表
str()，将序列转化为字符串
sorted()，对序列中元素进行排序，但是返回的值是列表（list）
对list进行排序的还有一个方法sort，这个是直接再已经存在的表进行操作，无返回值
list1 = ['2', '1', '3'] tuple1 = ("2", "1") dict1 = {"2": 2, "1": 1} print(type(list1), list1) print(type(tuple1), tuple1) print(type(dict1), dict1) list2 = sorted(list1) tuple2 = sorted(tuple1) dict2 = sorted(dict1) print(list2) print(tuple2) print(dict2)reversed()，反向排序序列中的元素，也就是逆排序，这个的返回值是一个迭代器
既然是迭代器就需要可以进行迭代的类型来迭代它，将其中的元素输出。
可以用列表（list）、元组（tuple），集合（set）
但是不可以用字典（dict），因为无法用dict（）来转化为一个字典，eval（）也不可以将一个迭代器转化为一个字典，因为eavl（）要求参数是一个字符串
list1 = ['2', '1', '3'] tuple1 = ("2", "1") dict1 = {"2": 2, "1": 1} print(reversed(list1)) print(tuple(reversed(list1))) print(list(reversed(list1))) print(dict(reversed(list1))) # 这是错误的enumerate()，将序列组合为一个索引序列，返回的是枚举对象，多用再for循坏中，可以看作一个迭代器。返回的枚举对象中的内容是（元素下标，元素值），这个形式和字典的内容（key： value）很类似，所以可以用字典来接收这个枚举对象。
list1 = ['2', '1', '3'] tuple1 = ("2", "1") dict1 = {"2": 2, "1": 1} print(list(enumerate(list1))) print(tuple(enumerate(list1))) print(dict(enumerate(list1))) for i in enumerate(list1): print(i, end=" ")还有一些其他的内置函数，其中有求最大值、最小值，还有一个可以求和。但是在sum()函数中需要参数中全是数值，不能是其他类型。
str1 = '81576174091815' print(max(str1)) # 找出最大的字符 print(min(str1)) # 找出最小的字符 list2 = [2, 1, 3] print(sum(list2)) print(sum(list2, 4)) # 在前面列表计算总和后再加上4
Python 列表（list）
lt = ["好好学习，天天向上", 68, 3.14, [5, 3, 8], True]
列表可以存储整数、小数、字符串、列表、元组等任何类型的数据，并且同一个列表 中元素的类型也可以不同。list 代指列表，这是因为列表的数据类型就是 list
1、使用[ ]创建列表
可以在[ ]中赋值，也可以不赋值为空
2、 使用 list() 函数创建列表
str = '好好学习，天天向上'
print(list(str))
访问列表元素
列表是 Python 序列的一种，我们可以使用索引（Index）访问列表中的某个元素（得到的是一个 元素的值），也可以使用切片访问列表中的一组元素（得到的是一个新的子列表）
str = 'http://www.baidu.com' print(len(str)) # 得知str的长度 lt = list(str) # 将字符串转为列表 # 使用索引访问列表中的某个元素 print(lt[2]) print(lt[-20]) # 使用切片访问列表中的一组元素 print(lt[1:15]) print(lt[1:15:3]) print(lt[-20:-5:5])
列表添加元素——（+）
使用 + 运算符可以将多个序列连接起来；列表是序列的一种，所以也可以使用 + 进行连接，这样就相当于在第一个列表的末尾添加了另一个列表。
list1 = [1, 2, 3, '好好学习'] list2 = ['天天向上',5, 6, 7] list3 = list1 + list2 print(list1) print(list2) print(list3)
列表添加元素——（append）
append() 方法用于在列表的末尾追加元素，这个方法是没有返回值的，都是再已有的基础上进行添加
lt = ['你', '我', '他'] lt.append('它') # 追加元素 print(lt) t = ('塔', '踏', '塌') # 追加元组，整个元组被当成一个元素 lt.append(t) print(lt) lt.append(['铊', '沓']) # 追加列表，整个列表也被当成一个元素 print(lt)
列表添加元素——（extend）
extend() 和 append() 的不同之处在于：extend() 不会把列表或者元祖视为一个整体，而是把它们包含的元素逐个添加到列表中。
如果添加的元素只有一个，例如添加"PTYTHON"，那么将会拆成一个一个的，也就是'P','Y','T','H','O','N'
如果添加的元素不止一个，例如添加["PYTHON","python"]，那么则会被拆成两个单词，而不是很多个一个一个的字母
lt = ['你', '我', '他'] lt.extend('它') # 追加元素 print(lt) t = ('塔', '踏', '塌') # 追加元组 lt.extend(t) print(lt) lt.extend(['铊', '沓']) # 追加列表 print(lt) lt.extend("PYTHON") # 它会将PYTHON拆'P', 'Y', 'T', 'H', 'O', 'N' print(lt)
列表添加元素——（insert）
append() 和 extend() 方法只能在列表末尾插入元素，如果希望在列表中间某个位置插入元素，那么可以使用 insert() 方法。
当插入列表或者元祖时，insert() 也会将它们视为一个整体，作为一个元素插入到列表中，这一点 和 append() 是一样的。
lt = ['你', '我', '他'] lt.insert(1, "它") # 插入元素 print(lt) tup = (1, "塔", 2) lt.insert(3, tup)# 插入元组，整个元祖被当成一个元素 print(lt) lt.insert(4, ["Hello", "World", 5, "好好学习"])# 插入列表，整个列表被当成一个元素 print(lt) lt.insert(6, "天天向上") # 插入字符串，整个字符串被当成一个元素 print(lt)
使用“+”号连接的列表，是将 lt1 中的元素放在 lt 的后面得到的 lt2，所以会产生一个新的序列，所以lt2 是一个重新生成的列表。
使用extend 进行连接，这个方法是没有返回值的，所以并不能使用赋值（=）表达式。 即 extend 千万不能放在等式的右侧
使用append 进行连接，这个方法的作用是将 lt1 整体当成一个元素追加到 lt 后面，这与 extend 和“+”号的功能完全不同
删除列表、删除列表元素
对于已经创建的列表，如果不再使用，可以使用 del 关键字将其删除
lt = [1, 2, 3, 4, 5, 6] del lt[1] # 删除lt表中指定的位置 del lt[:] # 删除lt表中的全部数据 del lt # 删除lt
pop() 方法用来删除列表中指定索引处的元素
lt = ['你', '我', '他'] lt.pop() #如果不写 index 参数，默认会删除列表中的最后一个元素，类似于数据结构中的“出栈”操作。 print(lt) lt.pop(1)# 使用pop函数弹出指定位置元素 print(lt)
remove() 方法，该方法会根据元素本身的值来进行删除操作。 需要注意的是，remove() 方法只会删除第一个和指定值相同的元素，而且必须保证该元素是存在 的，否则会引发错误。一般情况下都是先用 in 进行判断（或者使用count（）统计该元素有没有出现过来判断），然后再用remove（）进行删除，防止出现错误
clear() 用来删除列表的所有元素，也即清空列表
lt = ['你', '我', '他'] lt.remove('你') print(lt) lt.clear() print(lt)
列表修改元素
修改单个元素非常简单，直接对元素赋值即可。
通过切片语法来修改一个范围内的值
lt = ['你', '我', '他'] print(lt) lt[0] = 'ta' print(lt) lt[0:2]=['tamen', 'women'] print(lt) lt[1:1] = ['dd', 'mm', 'gg'] # 相当于插入一组新的元素 print(lt) # lt[1:1] = 44 # 用切片语法赋值时，Python 不支持单个值 print(lt) lt[2:2] = "444" # 每个字符都是一个元素,分割成了三个字符 print(lt)
列表查找元素
index() 方法用来查找某个元素在列表中出现的位置（也就是索引）
如果该元素不存在，则会导致错误，所以在查找之前最好使用count()方法判断一下。
listname.index(obj, start, end)
listname 表示列表名称，
obj 表示要查找的元素，
start 表示起始位置，
end 表示结束位置。
start 和 end 参数用来指定检索范围
start 和 end 可以都不写，此时会检索整个列表
如果只写 start 不写 end，那么表示检索从 start 到末尾的元素
如果 start 和 end 都写，那么表示检索 start 和 end 之间的元素。
lt = ['你', '我', '你', '他', '你', '他'] print(lt.index('你')) print(lt.index('你', 1)) print(lt.index('你', 3, 5))
count() 方法用来统计某个元素在列表中出现的次数
count() 返回 0，就表示列表中不存在该元素，所以 count() 也可以用来判断列表中的某个元 素是否存在。
lt = ['你', '我', '你', '他', '你', '他'] print(lt.count('你'))
列表实现栈和队列
队列和栈是两种数据结构，其内部都是按照固定顺序来存放变量的，
二者的区别在于对数据的存取顺序：
队列是，先存入的数据最先取出，即“先进先出”
栈是，最后存入的数据最先取出，即“后进先出”
考虑到 list 类型数据本身的存放就是有顺序的，而且内部元素又可以是各不相同的类型，非常适合用于队列和栈的实现。
使用 list 列表模拟队列功能的实现方法是，定义一个 list 变量
存入数据时使用 insert() 方法，设置其第一个参数为 0，即表示每次都从最前面插入数据
读取数据时，使用 pop() 方法，即将队列的最 后一个元素弹出
如此 list 列表中数据的存取顺序就符合“先进先出”的特点
# 定义一个空列表充当队列，队列特点：先进先出 queue = [] # 元素入队 queue.insert(0, "好好学习") queue.insert(0, 110) queue.insert(0, "天天向上") # 打印队列 print(queue) # 取出队列元素 print(queue.pop()) print(queue.pop()) print(queue.pop())
使用 list 列表模拟栈功能的实现方法是
使用 append() 方法存入数据
使用 pop() 方法读取数据
append() 方法向 list 中存入数据时，每次都在最后面添加数据，这和前面程序中的 insert() 方法正好相反。
# 创建一个空列表，充当栈，栈的特点：先进后出 stack = [] # 元素入栈，通过append函数添加 stack.append("好好学习") stack.append("110") stack.append("天天向上") # 打印栈内容 print(stack) # 元素出栈 print(stack.pop()) print(stack.pop()) print(stack.pop())
Python 元组（tuple）
（tuple）元组与（list）列表的不同之处
元组和列表（list）的不同之处在于：
列表的元素是可以更改的，包括修改元素值，删除和插入元素，所以列表是可变序列
而元组一旦被创建，它的元素就不可更改了，所以元组是不可变序列。
元组的所有元素都放在一对小括号 ( ) 中，相邻元素之间用逗号 , 分隔
元组可以存储整数、实数、字符串、列表、元组等任何类型的数据，并且在同一 个元组中，元素的类型可以不同
创建元组
1) 使用 ( ) 直接创建
元组通常都是使用一对小括号将所有元素包围起来的，但小括号不是必须的，只要将各元素用逗号隔开，Python 就会将其视为元组
需要注意的一点是，当创建的元组中只有一个字符串类型的元素时，该元素后面必须要加一个逗号，否则 Python 解释器会将它视为字符串。
tuple1 = (1, 2, 3) # 合法的 tuple2 = ("好好学习", "天天向上") # 合法的 tuple3 = (1, 2, 3, 4, "好好学习", "天天向上", [5, 8, 6], ("Hello")) # 合法的 tuple4 = "Hello", 1, 3.14, [5, "Python"], (1, 5), "Java" # 合法的 # 当元素内容只有一个时不加逗号 tp1 = ("Hello") print(type(tp1), tp1) # 当元素内容只有一个时加上逗号 tp2 = ("Hello",) print(type(tp2), tp2)2) 使用tuple()函数创建元组
str = "http://www.baidu.com" tp1 = tuple(str) # 将字符串转换成元组 print(tp1) lt = [1, 5, 9, "1", ["2", "3"]] tp2 = tuple(lt) # 将列表转换成元组 print(tp2) tp3 = tuple(str[2:8]) # 将区间转换成元组 print(tp3) tp4 = tuple() # 创建空元组 print(tp4)
访问元组元素
使用索引（Index）访问元组中的某个元素（得到的是一个元素的值）
也可以使用切片访问元组中的一组元素（得到的是一个新的子元组）
类同list（列表）
修改元组、删除元组
元组是不可变序列，元组中的元素不能被修改
但是我们只能创建一个新的元组去替代旧的元组
当创建的元组不再使用时，可以通过 del 关键字将其删除
Python 字典（dict）
（dict）字典简介
Python字典（dict）是一种无序的、可变的序列，它的元素以“键值对（key-value）”的形式存储。
相对地，列表（list）和元组（tuple）都是有序的序列，它们的元素在底层是挨着存放的。 字典类型是 Python 中唯一的映射类型。
“映射”是数学中的术语，简单理解，它指的是元素之间相互对应的关系，即通过一个元素，可以唯一找到另一个元素。
字典中，习惯将各元素对应的索引称为键（key），各个键对应的元素称为值（value），键及其关联的值称为“键值对”。
| 通过键而不是 通过索引来读 取元素 | 字典类型有时也称为关联数组或者散列表（hash）。它是通过键将一系列的值 联系起来的，这样就可以通过键从字典中获取指定项，但不能通过索引来获 取。 |
| 字典是任意数 据类型的无序 集合 | 和列表、元组不同，通常会将索引值 0 对应的元素称为第一个元素，而字典中 的元素是无序的。 |
| 字典是可变 的，并且可以 任意嵌套 | 字典可以在原处增长或者缩短（无需生成一个副本），并且它支持任意深度的 嵌套，即字典存储的值也可以是列表或其它的字典。 |
| 字典中的键必 须唯一 | 字典中，不支持同一个键出现多次，否则只会保留最后一个键值对。 |
| 字典中的键必 须不可变 | 字典中每个键值对的键是不可变的，只能使用数字、字符串或者元组，不能使 用列表。 |
创建字典
1) 使用 { } 创建字典
于字典中每个元素都包含两部分，分别是键（key）和值（value），因此在创建字典时，键和值 之间使用冒号 : 分隔，相邻元素之间使用逗号 , 分隔，所有元素放在大括号 { } 中。
# 使用字符串作为key dict1 = {"k1":"val1", "k2":[1,"Hello"], "k3":("Python", 1991)} print(dict1) # 使用元组作为key dict2 = {("好好学习", 2008):"天天向上", (1, "Python"):["天天向上", 2019]} print(dict2) # 创建空的字典 dict3 = {} print(dict3) dict1["dd"] = "wsdd" print(dict1)2) 通过 fromkeys() 方法创建字典
可以使用 dict 字典类型提供的 fromkeys() 方法创建带有默认值的字典
# 创建列表 lt1 = [1, "Hello", ("好好学习", 2008)] # 使用fromkeys函数创建字典 dt = dict.fromkeys(lt1, 2008) print(dt)3) 通过 dict() 映射函数创建字典
# 通过 dict() 函数创建字典 a = dict(str1=value1, str2=value2, str3=value3) dt1 = dict(Hello="人生苦短", 你好="Python") print(dt1) demo1 = [('two',2), ('one',1), ('three',3)] demo2 = [['two',2], ['one',1], ['three',3]] demo3 = (('two',2), ('one',1), ('three',3)) demo4 = (['two',2], ['one',1], ['three',3]) dt2 = dict(demo1) print(dt2) dt3 = dict(demo2) print(dt3) dt4 = dict(demo3) print(dt4) dt5 = dict(demo4) print(dt5)
访问字典、删除字典
列表和元组是通过下标来访问元素的，而字典不同，它通过键来访问对应的值。
因为字典中的元素是无序的，每个元素的位置都不固定，所以字典也不能像列表和元组那样，采用切片的方式一次性访问多个元素。
和删除列表、元组一样，手动删除字典也可以使用 del 关键字。不过Python 自带垃圾回收功能，会自动销毁不用的字典，所以一般不需要通过 del 来手动删除。
dict1 = {"k1": "val1", "k2": [1, "Hello"], "k3": ("Python", 1991)}
val = dict1["k1"]
print(val)
# val = dict1["k4"] #若输入的key值不存在会报错
# print(val)
val = dict1.get("k1")
print(val)
val = dict1.get("k4") # 若输入的key值不存在则会输出None
print(val)字典基本操作
添加键值对、修改键值对、删除键值对
添加键值对：dictname[key] = value 对各个部分的说明： dictname 表示字典名称。 key 表示新的键。 value 表示新的值，只要是 Python 支持的数据类型都可以。
修改键值对：Python 字典中键（key）的名字不能被修改，我们只能修改值（value）。
字典中各元素的键必须是唯一的，因此，如果新添加元素的键与已存在元素的键相同，那么键所对应的值就会被新的值替换掉，以此达到修改元素值的目的。
删除键值对：del 语句，del dt[ key ]
判断字典中是否存在指定键值对
判断字典中是否存在指定键值对，首先应判断字典中是否有对应的键。判断字典是否包含指 定键值对的键，可以使用 in 或 not in 运算符。in 或 not in 运算符都是基于 key 来判断。
dict1 = {"k1": "val1", "k2": [1, "Hello"], "k3": ("Python", 1991)}
print("k1" in dict1)
print("k2" not in dict1)获取字典中的特定数据
keys() 方法用于返回字典中的所有键（key）；
values() 方法用于返回字典中所有键对应的值（value）；
items() 用于返回字典中所有的键值对（key-value）。
如果要使用获得的数据，需要使用 list() 函数将它们返回的数据转换成列表
dict1 = {"k1": "val1", "k2": [1, "Hello"], "k3": ("Python", 1991)}
print(dict1.values()) # 获取values值
print(dict1.keys()) # 获取keys值
print(dict1.items()) # 遍历
values = dict1.values() # 将类型转换为list
keys = dict1.keys()
items = dict1.items()
print(list(values))
print(list(keys))
print(list(items))使用 for in 循环遍历它们的返回值
dict1 = {"k1": "val1", "k2": [1, "Hello"], "k3": ("Python", 1991)}
for k in dict1:
print(k, "->", dict1[k])
print("<----------->") # dict1[k] 和 dict1.get(k))是一样的
for k in dict1:
print(k, "->", dict1.get(k))
print("<----------->")
for k, v in dict1.items():
print(k, "->", v)
copy() 方法、setdefault() 方法
字典的拷贝copy() 方法
dict1 = {"k1": "val1", "k2": [1, "Hello"], "k3": ("Python", 1991)} dict2 = dict1.copy() print(dict1) print(dict2) dict1["k4"] = "123" # 添加新的元素不影响拷贝的 print(dict1) print(dict2) dict1["k2"].remove(1) # 更改"k2"对应的地址中的值，则会影响拷贝的 print(dict1) # 因为拷贝的"k2"中的内容是对应的地址值，不是对应地址的内容 print(dict2)setdefault() 方法：dictname.setdefault(key, defaultvalue)
dictname 表示字典名称，key 表示键，defaultvalue 表示默认值（可以不写，默认None）
1、如果该 key 存在，那么直接返回该 key 对应的 value
2、如果该 key 不存在，那么先为该 key 设置默认的 defaultvalue
a = {'数学': 95, '语文': 89, '英语': 90} print(a) # key不存在，指定默认值 val = a.setdefault('物理', 100) print(a) # key不存在，不指定默认值 a.setdefault('化学') print(a) # key存在，指定默认值 a.setdefault('数学', 100) # 已存在的返回原先的值 print(a)
Python 集合（set）
创建set集合
1) 使用 {} 创建
setname = {element1,element2,...,elementn}
创建一个空集合，不能用 setname = {}，这个会被解释为dict（字典）
需要用setname = set()，这个才能创建一个空集合
2) set()函数创建集合
set() 函数为 Python 的内置函数，其功能是将字符串、列表、元组、range 对象等可迭代对象转换成集合。
访问、删除集合、添加元素、删除集合的元素
集合中的元素是无序的，因此无法向列表那样使用下标访问元素。
使用循环结构，将集合中的数据逐一读取出来。
a = {1, 2, 3, "2", 'qq', '3434'} for e in a: print(e, end=' ') # end是分隔符 print("\n<----->") for e in a: print(e, end='-')
使用 add() 方法添加的元素，只能是数字、字符串、元组或者布尔类型（True 和 False）值，不能添加列表、字典、集合这类可变的数据
删除现有 set 集合中的指定元素，可以使用 remove() 方法。使用此方法删除集合中元素，需要注意的是，如果被删除元素本就不包含在集合中，则此方法会抛出KeyError 错误
使用 discard() 方法，此方法和 remove() 方法的用法完全相同，唯一的区别就是，当删除集合中元素失败时，此方法不会抛出任何错误
a = {1, 2, 3, "2", 'qq', '3434'} a.remove('qq') print(a) a.discard('d') # 这个不会报错 print(a) a.remove('d') # 这个会报错的
花有重开日，人无再少年
趁当下年轻，学习Python
——Lungcen