python基础---序列

1. list

1.1 创建列表

1.1.1 使用 [ ] 创建列表

mylist = ['a','b','c','d','b']

1.1.2 使用list函数创建列表

list 函数可以将其他数据类型转换成list类型

1. 将字符串装换成list

list2 = list("hello")

# ['h', 'e', 'l', 'l', 'o']

2. 将元祖转换成list

list2 = list((1,2,3,4))

# [1, 2, 3, 4]

3. 将字典转换成list

list2 = list({"id":1,"name":"zs"})

# ['id', 'name']

4. 将区间转换成list

list2 = list(range(0,3))

# [0, 1, 2]

5. 创建空列表

list2 = list()

1.2 访问列表元素

1.2.1 使用索引访问

list2 = list("hello")
list2[0]

# 'h'

1.2.2 使用切片访问

list2[0:3:1]

# ['h', 'e', 'l']

1.3 删除列表

del list1

1.4 添加元素

1.4.1 append 方法

list2 = list("hello")
list2.append([1,2,3])
list2

# ['h', 'e', 'l', 'l', 'o', [1, 2, 3]]

1.4.2 extend 方法

list2 = list("hello")
list2.extend([1,2,3])
list2

# ['h', 'e', 'l', 'l', 'o', 1, 2, 3]

1.4.3 insert 方法

list2 = list("hello")
list2.insert(0,[1,2,3])
list2

# [[1, 2, 3], 'h', 'e', 'l', 'l', 'o']

1.5 删除元素

1.5.1 del 关键字

list2 = list("hello")
del list2[0]
list2

# ['e', 'l', 'l', 'o']

1.5.2 pop 方法

（默认最后一个元素），并且返回该元素的值。

list2 = list("hello")
list2.pop(0)
list2

# ['e', 'l', 'l', 'o']

1.5.3 remove 方法

list2 = list("hello")
list2.remove('h')
list2

# ['e', 'l', 'l', 'o']

1.5.4 clear 方法

list2.clear()

1.6 修改元素

1.6.1 修改单个元素

nums = [40, 36, 89, 2, 36, 100, 7]
nums[2] = -26  #使用正数索引
nums[-3] = -66.2  #使用负数索引
print(nums)

1.6.2 修改一组元素

nums = [40, 36, 89, 2, 36, 100, 7]
#修改第 1~4 个元素的值（不包括第4个元素）
nums[1: 4] = [45.25, -77, -52.5]
print(nums)

# [40, 45.25, -77, -52.5, 36, 100, 7]

1. 如果对空切片（slice）赋值，就相当于插入一组新的元素：

nums = [40, 36, 89, 2, 36, 100, 7]
#在4个位置插入元素
nums[4: 4] = [-77, -52.5, 999]
print(nums)

# [40, 36, 89, 2, -77, -52.5, 999, 36, 100, 7]

2. 使用切片语法赋值时，Python 不支持单个值，例如下面的写法就是错误的：

nums[4: 4] = -77

3. 但是如果使用字符串赋值，Python 会自动把字符串转换成序列，其中的每个字符都是一个元素，

s = list("Hello")
s[2:4] = "XYZ"
print(s)

# ['H', 'e', 'X', 'Y', 'Z', 'o']

4. 使用切片语法时也可以指定步长（step 参数），但这个时候就要求所赋值的新元素的个数与原有元素的个数相同

nums = [40, 36, 89, 2, 36, 100, 7]
#步长为2，为第1、3、5个元素赋值
nums[1: 6: 2] = [0.025, -99, 20.5]
print(nums)

# [40, 0.025, 89, -99, 36, 20.5, 7]

1.7 查询元素

1.7.1 index 方法

index() 方法用来查找某个元素在列表中出现的位置（也就是索引），如果该元素不存在，则会导致 ValueError错误，所以在查找之前最好使用 count() 方法判断一下。
listname.index(obj, start, end)
return 索引

nums = [40, 36, 89, 2, 36, 100, 7, -20.5, -999]
#检索列表中的所有元素
print( nums.index(2) )
#检索3~7之间的元素
print( nums.index(100, 3, 7) )
#检索4之后的元素
print( nums.index(7, 4) )
#检索一个不存在的元素
print( nums.index(55) )

1.7.2 count 方法

count() 方法用来统计某个元素在列表中出现的次数，基本语法格式为：
listname.count(obj)

nums = [40, 36, 89, 2, 36, 100, 7, -20.5, 36]
#统计元素出现的次数
print("36出现了%d次" % nums.count(36))
#判断一个元素是否存在
if nums.count(100):
    print("列表中存在100这个元素")
else:
    print("列表中不存在100这个元素")

2. tuple

2.1 创建元祖

2.1.1 使用 () 创建

num = (7, 14, 21, 28, 35)
course = ("Python教程", "http://c.biancheng.net/python/")
abc = ( "Python", 19, [1,2], ('c',2.0) )

1. 元组通常都是使用一对小括号将所有元素包围起来的，但小括号不是必须的，只要将各元素用逗号隔开，Python 就会将其视为元组

course = "Python教程", "http://c.biancheng.net/python/"
print(course)

# ('Python教程', 'http://c.biancheng.net/python/')

2. 当创建的元组中只有一个字符串类型的元素时，该元素后面必须要加一个逗号,，否则 Python 解释器会将它视为字符串

#最后加上逗号
a =("http://c.biancheng.net/cplus/",)
print(type(a))
print(a)
#最后不加逗号
b = ("http://c.biancheng.net/socket/")
print(type(b))
print(b)

# <class 'tuple'>
# ('http://c.biancheng.net/cplus/',)
# <class 'str'>
# http://c.biancheng.net/socket/

2.1.2 使用 tuple 函数创建

tuple(data)
data 表示可以转化为元组的数据，包括字符串、元组、range 对象等。

#将字符串转换成元组
tup1 = tuple("hello")
print(tup1)
#将列表转换成元组
list1 = ['Python', 'Java', 'C++', 'JavaScript']
tup2 = tuple(list1)
print(tup2)
#将字典转换成元组
dict1 = {'a':100, 'b':42, 'c':9}
tup3 = tuple(dict1)
print(tup3)
#将区间转换成元组
range1 = range(1, 6)
tup4 = tuple(range1)
print(tup4)
#创建空元组
print(tuple())

2.2 访问元祖元素

2.2.1 使用索引访问

url = tuple("http://c.biancheng.net/shell/")
#使用索引访问元组中的某个元素
print(url[3])  #使用正数索引
print(url[-4])  #使用负数索引

2.2.2 使用切片访问

#使用切片访问元组中的一组元素
print(url[9: 18])  #使用正数切片
print(url[9: 18: 3])  #指定步长
print(url[-6: -1])  #使用负数切片

2.3 修改元祖

元组是不可变序列，元组中的元素不能被修改，所以我们只能创建一个新的元组去替代旧的元组。

tup = (100, 0.5, -36, 73)
print(tup)
#对元组进行重新赋值
tup = ('Shell脚本',"http://c.biancheng.net/shell/")
print(tup)

2.4 删除元祖

3. dict

3.1 字典特征

1. 通过键而不是通过索引来读取元素
2. 字典是任意数据类型的无序集合
3. 字典是可变的，并且可以任意嵌套
4. 字典中的键必须唯一
   不支持同一个键出现多次，否则只会保留最后一个键值对。
5. 字典中的键必须不可变
   字典中的键是不可变的，只能使用数字、字符串或者元组，不能使用列表。

3.2 创建字典

3.2.1 使用 {}

#使用字符串作为key
scores = {'数学': 95, '英语': 92, '语文': 84}
print(scores)
#使用元组和数字作为key
dict1 = {(20, 30): 'great', 30: [1,2,3]}
print(dict1)
#创建空元组
dict2 = {}
print(dict2)

字典的键可以是整数、字符串或者元组，只要符合唯一和不可变的特性就行；字典的值可以是 Python 支持的任意数据类型。

3.2.2 使用fromkeys()方法

dict.fromkeys(keys, value)

knowledge = {'语文', '数学', '英语'}
scores = dict.fromkeys(knowledge, 60)
print(scores)

这种创建方式通常用于初始化字典，设置 value 的默认值。

3.2.3 通过 dict() 映射函数

1. dict(str1 = value1, str2 = value2)

a = dict(id = 1,name = 'zs') # 键不能加引号
a

# {'id': 1, 'name': 'zs'}

2. 向 dict 函数传入列表或元祖

mylist1 = [('id',1),('name','zs')]
dict(mylist1)

mylist2 = [['id',1],['name','zs']]
dict(mylist2)

mylist3 = (['id',1],['name','zs'])
dict(mylist3)

mylist4 = (('id',1),('name','zs'))
dict(mylist4)

# {'id': 1, 'name': 'zs'}

第一个元素作为键, 第二个元素作为值

3. dict() 函数和 zip()函数

keys = ['id', 'name']
values = [1, 'zs']
dict(zip(keys, values))

keys = '123'
values = ('a','b','c')
dict(zip(keys, values))

# {'1': 'a', '2': 'b', '3': 'c'}
# key 和 value 都可以是 list, tuple, str

3.3 访问字典

3.3.1 [键] 访问

dict1 = {'1': 'a', '2': 'b', '3': 'c'}
dict1['1']

3.3.2 get(键) 访问

dict1.get('2')

dict1.get('10',"none")

3.4 删除字典

del 关键字

3.5 字典基本操作

3.5.1 添加键值对

直接给不存在的 key 赋值即可，具体语法格式如下：

dictname[key] = value

3.5.2 修改键值对

dictName[key] = new_value

3.5.3 删除键值对

del dictName[key]

3.5.4 判读是否存在键值对

key in dictName

3.6 字典方法

3.6.1 keys(), values(), items()

• keys() 方法用于返回字典中的所有键（key）return dict_keys；
• values() 方法用于返回字典中所有键对应的值（value）return dict_values；
• items() 用于返回字典中所有的键值对（key-value）return dict_items。

scores = {'数学': 95, '语文': 89, '英语': 90}
print(scores.keys())
print(scores.values())
print(scores.items())

# dict_keys(['数学', '语文', '英语'])
# dict_values([95, 89, 90])
# dict_items([('数学', 95), ('语文', 89), ('英语', 90)])

1. 使用 list 将他们返回的数据转换成列表
2. 使用 for 循环遍历

list(scores.keys())
​
# ['数学', '语文', '英语']
list(scores.values())
# [95, 89, 90]
list(scores.items())
# [('数学', 95), ('语文', 89), ('英语', 90)]
for key in scores.keys():
    print(key)
# 数学
# 语文
# 英语
value
for value in scores.values():
    print(value)
# 95
# 89
# 90
tem
for item in scores.items():
    print(item)
# ('数学', 95)
# ('语文', 89)
# ('英语', 90)

3.6.2 copy()

a = {'one': 1, 'two': 2, 'three': [1,2,3]}
b = a.copy()
print(b)

注意，copy() 方法所遵循的拷贝原理，既有深拷贝，也有浅拷贝。拿拷贝字典 a 为例，copy() 方法只会对最表层的键值对进行深拷贝，也就是说，它会再申请一块内存用来存放 {‘one’: 1, ‘two’: 2, ‘three’: []}；而对于某些列表类型的值来说，此方法对其做的是浅拷贝，也就是说，b 中的 [1,2,3] 的值不是自己独有，而是和 a 共有。

a = {'one': 1, 'two': 2, 'three': [1,2,3]}
b = a.copy()
#向 a 中添加新键值对，由于b已经提前将 a 所有键值对都深拷贝过来，因此 a 添加新键值对，不会影响 b。
a['four']=100
print(a)
print(b)
#由于 b 和 a 共享[1,2,3]（浅拷贝），因此移除 a 中列表中的元素，也会影响 b。
a['three'].remove(1)
print(a)
print(b)

3.6.3 update()

update() 方法可以使用一个字典所包含的键值对来更新己有的字典。

在执行 update() 方法时，如果被更新的字典中己包含对应的键值对，那么原 value 会被覆盖；如果被更新的字典中不包含对应的键值对，则该键值对被添加进去。

3.6.4 pop(), popitem()

pop() 和 popitem() 都用来删除字典中的键值对，不同的是，pop() 用来删除指定的键值对，而 popitem() 用来随机删除一个键值对，它们的语法格式如下：

dictname.pop(key)
dictname.popitem()

3.6.5 setdefault()

setdefault() 方法用来返回某个 key 对应的 value，其语法格式如下：

dictname.setdefault(key, defaultvalue)

当指定的 key 不存在时，setdefault() 会先为这个不存在的 key 设置一个默认的 defaultvalue，然后再返回 defaultvalue。

也就是说，setdefault() 方法总能返回指定 key 对应的 value：

• 如果该 key 存在，那么直接返回该 key 对应的 value；
• 如果该 key 不存在，那么先为该 key 设置默认的 defaultvalue，然后再返回该 key 对应的 defaultvalue。

a = {'数学': 95, '语文': 89, '英语': 90}
print(a)
#key不存在，指定默认值
a.setdefault('物理', 94)
print(a)
#key不存在，不指定默认值
a.setdefault('化学')
print(a)
#key存在，指定默认值
a.setdefault('数学', 100)
print(a)

4. set

4.1 set 特点

无序, 不可重复

同一集合中，只能存储不可变的数据类型，包括整形、浮点型、字符串、元组，无法存储列表、字典、集合这些可变的数据类型，否则 Python 解释器会抛出 TypeError 错误。

4.2 创建 set

4.2.1 {}

a = {1,'c',1,(1,2,3),'c'}
print(a)

# {1, 'c', (1, 2, 3)}

a = {1,2,3,3,3,4,5,5,4,[1,2,3]}
a # 报错

4.2.2 set 函数

set() 函数为 Python 的内置函数，其功能是将字符串、列表、元组、range 对象等可迭代对象转换成集合。该函数的语法格式如下:

set(iteration)
iteration 就表示字符串、列表、元组、range 对象等数据。

set1 = set("c.biancheng.net")
set2 = set([1,2,3,4,5])
set3 = set((1,2,3,4,5))
print("set1:",set1)
print("set2:",set2)
print("set3:",set3)

# set1: {'a', 'g', 'b', 'c', 'n', 'h', '.', 't', 'i', 'e'}
# set2: {1, 2, 3, 4, 5}
# set3: {1, 2, 3, 4, 5}

注意，如果要创建空集合，只能使用 set() 函数实现。因为直接使用一对 {}，Python 解释器会将其视为一个空字典

4.3 访问 set 集合元素

因为 set 无序, 所以不可通过索引访问, 使用 for 循环

a = {1,'c',1,(1,2,3),'c'}
for ele in a:
    print(ele,end=' ')

4.4 删除 set 集合

4.5 set 集合基本操作

4.5.1 添加

setname.add(element)

a = {1,2,3}
a.add((1,2))
print(a)
a.add([1,2]) # 报错
print(a)

需要注意的是，使用 add() 方法添加的元素，只能是数字、字符串、元组或者布尔类型（True 和 False）值，不能添加列表、字典、集合这类可变的数据，否则 Python 解释器会报 TypeError 错误

4.5.2 删除

setname.remove(element)
使用此方法删除集合中元素，需要注意的是，如果被删除元素本就不包含在集合中，则此方法会抛出 KeyError 错误，

setname.discard(element)
如果我们不想在删除失败时令解释器提示 KeyError 错误，还可以使用 discard() 方法，此方法和 remove() 方法的用法完全相同，唯一的区别就是，当删除集合中元素失败时，此方法不会抛出任何错误。