Python 基础数据类型3

列表

列表常见操作

增加
(1) L.append(object) → 在列表末尾添加新的对象

li = [1, 2, 3]
li.append([5, 5])
print(li)

输出结果：

[1, 2, 3, [5, 5]]

(2) L.extend(iterable) → 用新列表扩展原来的列表

li = [1, 2, 3]
li.extend([5, 5])
print(li)

输出结果：

[1, 2, 3, 5, 5]

(3) L.insert(index, object) → 将对象插入列表

li3 = ['happy', 'year']
li3.insert(1, 'new')
print(li3)

输出结果：

['happy', 'new', 'year']

查询
(1) 查询某个元素出现的次数
L.count(object) → 统计某个元素在列表中出现的次数

li1 = [1, 2, 3, [3, 3]]
print(li1.count(3))

输出结果：

1

(2) 查元素的索引
L.index(value) → 从列表中找出某个值第一个匹配项的索引位置（小的那个）

li2 = [1, 2, 3, 2, 3]
print(li2.index(3))

输出结果：

2

删除
(1) L.pop([index]) → 移除列表中的一个元素（不写索引默认最后一个元素），并且返回该元素的值

li4 = [1, 2, 3, 4, 5]
li4.pop(3)
print(li4)

输出结果：

[1, 2, 3, 5]

(2) L.remove(value) → 移除列表中某个值的第一个匹配项

li4 = [1, 2, 3, 4, 5, 3]
li4.remove(3)
print(li4)

输出结果：

[1, 2, 4, 5, 3]

(3) del → 关键字删除
1.del L 整个删除，输出会报错

li8 = [1, 2, 3, 4, 5]
del li8
print(li8)

输出结果：

NameError: name 'li8' is not defined

2.del L.[index] 指定元素删除

li8 = [1, 2, 3, 4, 5]
del li8[4]
print(li8)

输出结果：

[1, 2, 3, 4]

排序
(1) L.reverse() → 反向列表中元素

li4 = [1, 2, 3, 4, 5]
li4.reverse()
print(li4)

输出结果：

[5, 4, 3, 2, 1]

(2) L.sort(reverse=False) → 对原列表进行排序

li5 = [1, 4, 6, 2, 5, 3]
li5.sort()
print(li5)

输出结果：

[1, 2, 3, 4, 5, 6]

复制（浅拷贝）
L.copy() → 复制列表（浅拷贝）

li6 = [1, 2, 3]
print(li6.copy())  #  浅拷贝相当于赋值（按照PEP8的规则，注释是在代码后空两格写）
li7 = li6
print(li7)

输出结果：

[1, 2, 3]
[1, 2, 3]

清空
L.clear() → 清空列表

li8 = [1, 2, 3, 4, 5]
li8.clear()
print(li8)

输出结果：

[]

例如：

有返回值的 print 本身，print(li2.index(3))；没有返回值的 print 列表，li.append(4) print(li)

元组

元组的创建

1. 展现形式的创建过程

tu = ()  # 创建空元组
print(tu, type(tu))  # <class 'tuple'>

tu4 = (123,)  # 创建有元素的元组
print(tu4)  # (123,)

tu5 = (123)  # 注意：以(,)创建时，若只有一个元素需要后面有一个英文的逗号，否则就是普通的小括号，直接输出int类型 123
print(tu5, type(tu5))  # 123 <class 'int'>

2. 方法的创建过程

tu1 = tuple()  # 创建空元组
print(tu1, type(tu1))  # <class 'tuple'>

tu2 = tuple("12345")  # 创建有元素的元组  tuple(iterable)
print(tu2)  # ('1', '2', '3', '4', '5')

tu3 = tuple(123,)  # 若不是可迭代对象 iterable，则会报错
print(tu3)  # TypeError: 'int' object is not iterable

元组与列表相同的操作

1. 使用方括号加下标访问元素

tu = tuple('12345')
print(tu[1])  # '2'

输出结果：

2

2. 切片（形成新元组对象）

tu = tuple('12345')
print(tu[2:4])  # ('3', '4')

输出结果：

('3', '4')

3. tuple.count() / tuple.index()

tu1 = (1, 2, 3, 4, 5, 5, 5, 4)
print(tu1.count(5))  # 3
print(tu1.index(5))  # 4 从元组中找出5的第一个匹配项的索引位置（小的那个）

输出结果：

3
4

4. python内置函数：reversed()，sorted()

# tuple类型只有以上两种方法，那如果想实现反转以及排序，需用python内置函数
tu2 = (3, 2, 5)
print(tu2[::-1])  # (5, 2, 3)
print(tuple(reversed(tu2)))  # reversed：内置的反转类  (5, 2, 3)
print(list(reversed(tu2)))  # reversed：内置的反转类  [5, 2, 3]

print(sorted(tu2))  # 升序，返回list  [2, 3, 5]

输出结果：

(5, 2, 3)
(5, 2, 3)
[5, 2, 3]
[2, 3, 5]

5. 加法及乘法

tu3 = (1, 2, 3)
tu4 = (2, 2, 3)
print(tu3 + tu4)  # 拼接  (1, 2, 3, 2, 2, 3)
# print(tu3 * tu4)  # 不能元组与元组相乘，会报错

print(tu3 * 2)  # 扩展  (1, 2, 3, 1, 2, 3)

输出结果：

(1, 2, 3, 2, 2, 3)
(1, 2, 3, 1, 2, 3)

元组中不允许的操作

元组没有任何会对内部元素发生修改动作的方法。例如：元组没有 remove，append，pop 等方法

1. 不允许修改、新增元素。（一级）

tu = (1, 2, 3)
tu[1] = 5  # 元素不可修改，会报错
print(tu)

tu1 = tu + (4,)  # 只能创建新的元组，而不能修改元组
print(id(tu))  # 2754087443984
print(id(tu1))  # 2754086532824
print(tu1)  # (1, 2, 3, 4)

tu1 = (1, 2, 3, ['amy', 5])  # 可改：不许修改仅在一级元素是元组
tu1[3][0] = 4
print(tu1)  # (1, 2, 3, [4, 5])

tu2 = (1, 2, 3, ('amy', 5))  # 不可改，会报错
tu2[3][0] = 4
print(tu2)

2. 不允许删除某个元素（但可以删除整个元组）

tu3 = (1, 2, 3, 4, 5)
del tu3[2]
print(tu3)  # 不允许删除元组内某个元素，会报错  TypeError: 'tuple' object doesn't support item deletion

del tu3
print(tu3)  # 但可以删除整个元组 NameError: name 'tu3' is not defined

总结：到底是用元组还是列表

元组所消耗的内存比列表要少
当你的元素不需要改变的时候，推荐使用元组
当你的元素需要改变的时候，推荐使用列表

元组与列表之间的转换

list → tuple

li = [4, 5, 6]
print(tuple(li))  # (4, 5, 6)

tuple → list

tu3 = (1, 2, 3)
print(list(tu3))  # [1, 2, 3]

字典

字典介绍

字典采用键值对{key: value}的形式，根据 key 的值计算 value 的地址，具有非常快的查取和插入速度。它是一种可变对象，所以支持修改、插入、删除等操作。

字典创建

1. {}
   {key1: value1, key2: value2}

dic = {}
print(dic)  # {}
print(type(dic))  # <class 'dict'>

# 创建字典 元素不限 值可以为任意类型
cgt_infor = {'addr': 'hunan', 'age': '18', 'hobbit': ['study python', 'badminton']}

# 注意1：键只能是不可变数据类型
cgt_infor = {['addr']: 'hunan'}  # 报错，因为[]是可变类型
cgt_infor = {('addr'): 'hunan'}  # 可以，因为()是不可变类型

# 注意2：键需要唯一，但是有重复键时，覆盖。
cgt_infor = {'addr': 'hunan', 'addr': '深圳','addr': '北京'}
print(cgt_infor)  # {'addr': '北京'}

2. dict()
   dict(**kwargs)
   dict(mapping)

dic2 = dict()
print(dic2)  # {}
print(type(dic2))  # <class 'dict'>

# dict(**kwargs) 键值对
dic3 = dict(name='amy', age=18)
print(dic3)  # {'name': 'amy', 'age': 18}

# dict(mapping) 映射 ('name', 'amy')
dic4 = dict([('name', 'amy'), ('age', 18)])
print(dic4)  # {'name': 'amy', 'age': 18}

dic5 = {'name': 'amy', 'age': 18}
print(dic3 == dic4 == dic5)  # True

注意：
在 python 3.6 开始，字典对象会保持键值插入时的顺序，并且其包含的元素个数不限，值的类型也可以是其它任何数据类型。
字典的 key 必须是不可变的对象，例如：整数、字符串、bytes 和元组，但使用最多的还是字符串。列表、字典、集合等就不可以作为 key。同时，同一个字典内的 key 必须是唯一的（若有重复键时，则会覆盖），但值则不必。

字典创建拓展

map(func, *iterables):
将 iterables 里的元素逐个传到 func 里面做处理

zip(iter1 [,iter2 […]]):
将 iter1 iter2 中对应的元素打包成一个个元组，然后返回由这些元组组成的列表

思考：
list(‘1234’) → [1, 2, 3, 4]
li_k = [‘name’, ‘age’] 与 li_v = [‘amy’, 18] 怎么组合成键值对的字典？

# 需求 list('1234') --> [1, 2, 3, 4] --> 将li中的每个元素转为int类型
li = list('1234')
# map(func, *iterables)
print(map(int, li))  # map对象：映射，将li当中的每个元素传到了int()当中，再返回  <map object at 0x000002497984DC88>
print(list(map(int, li)))  # 将map对象转为list呈现  [1, 2, 3, 4]

ipt = input('请输入：')  # 1 3 5 9
print(list(map(int, ipt.split(' '))))  # [1, 3, 5, 9]

# li_k = ['name', 'age'] 与 li_v = ['amy', 18] 怎么组合成键值对的字典？  目标：[('name', 'amy'), ('age', 18)]
li_k = ['name', 'age']
li_v = ['amy', 18]

# 方法一：
print(zip(li_k, li_v))  # zip对象：打包，将可迭代对象里面一一对应的元素打包元组进行返回  <zip object at 0x0000024979850CC8>
print(dict(list(zip(li_k, li_v))))  # {'name': 'amy', 'age': 18}


# 方法二：
def f_map(key_a, value_b):
    return (key_a, value_b)


print(list(map(f_map, li_k, li_v)))  # [('name', 'amy'), ('age', 18)]

字典的增加、修改、删除与查询（访问）

1. 访问字典
   字典是集合类型，不是序列类型，因此没有索引下标的概念，更没有切片的说法。但是，与 list 类似，字典采用把相应的键放入方括号内获取对应值的方式取值。
   如：
   dict[exit_key]
   思考：
   当 key 值不存在时，程序会怎么样呢？ 会报错

dic1 = {'name': 'amy', 'age': 18}
# 查询值
print(dic1[0])  # 报错，dict它是集合类型，集合类型没有下标说法。
print(dic1['name'])  # dict[exit_key]  amy
print(dic1['sex'])  # 注意：当key值不存在时，访问则报错

2. 增加
   往字典插入新的键值对

dic1 = {'name': 'amy', 'age': 18}
# 增加值，取出赋值
dic1['gender'] = 'female'
print(dic1)  # {'name': 'amy', 'age': 18, 'gender': 'female'}

3. 修改
   给原有的键赋予新的值。由于一个 key 只能对应一个值，所以，多次对一个 key 赋值，后面的值会把前面的值覆盖掉。

dic1 = {'name': 'amy', 'age': 18, 'gender': 'female'}
# 修改值，取出重新赋值
dic1['gender'] = 'male'
print(dic1)  # {'name': 'amy', 'age': 18, 'gender': 'male'}

4. 一系列删除
   删除字典元素：del dic[exit_key] 或 dic.pop(exit_key)
   删除整个字典：del dic
   清空整个字典：dic.clear()

dic1 = {'name': 'amy', 'age': 18}
# 删除指定的值
del dic1['name']
print(dic1)  # {'age': 18}

dic1.pop()  # 报错，dict.pop 必须传参数
print(dic1)

dic1.pop('age')
print(dic1)  # {'name': 'amy'}

# 删除整个字典
del dic1

# 清空字典
dic1.clear()
print(dic1)  # {}

字典常见操作

D.get(k[,d]) → 返回指定键的值，如果值不在字典中，则返回 default 值

dic1 = {'name': 'amy', 'age': 18}
print(dic1.get('name'))  # amy
print(dic1.get('gender'))  # None 直接用方括号通过不存在的键获取值会报错，但是使用get获取返回None

D.items() → 以列表返回可遍历的(键, 值)元组对

dic1 = {'name': 'amy', 'age': 18}
# 获取所有的键值对
print(dic1.items())  # dict_items([('name', 'amy'), ('age', 18)])

D.keys() → 以列表返回字典所有的键

dic1 = {'name': 'amy', 'age': 18}
# 获取所有的key
print(dic1.keys())  # dict_keys(['name', 'age'])

D.values() → 以列表返回字典所有的值

dic1 = {'name': 'amy', 'age': 18}
# 获取所有的value
print(dic1.values())  # dict_values(['amy', 18])

作业

作业1
lis1 = [“name”, “author”, “introduce”]
lis2 = [“NORWEGIAN WOOD”, “Haruki Murakami”, “balalalalal…”]
将lis1与lis2以键值对的形式呈现。

方法一：

lis1 = ["name", "author", "introduce"]
lis2 = ["NORWEGIAN WOOD", "Haruki Murakami", "balalalalal..."]
print(dict(zip(lis1, lis2)))

输出结果：

{'name': 'NORWEGIAN WOOD', 'author': 'Haruki Murakami', 'introduce': 'balalalalal...'}

方法二：

lis1 = ["name", "author", "introduce"]
lis2 = ["NORWEGIAN WOOD", "Haruki Murakami", "balalalalal..."]


def f_map(key_n, value_n):
    return (key_n, value_n)


print(dict(map(f_map, lis1, lis2)))

输出结果：

{'name': 'NORWEGIAN WOOD', 'author': 'Haruki Murakami', 'introduce': 'balalalalal...'}

作业2
Amy_info={ 'name’: 'amy’, 'addr’: ’hunan’, 'weight’: 90} 获取 amy_info 的 key，value

Amy_info = {'name': 'amy', 'addr': 'hunan', 'weight': 90}
print(Amy_info.keys())
print(Amy_info.values())

输出结果：

dict_keys(['name', 'addr', 'weight'])
dict_values(['amy', 'hunan', 90])

作业3(扩展)
生成了N个1~1000之间的随机整数(N<=1000)，N是用户输入的，
对于其中重复的数字，只保留一个，把其余相同的数字去掉，然后再把这些数从小到大排序。
(注意：此处需要使用随机整数。可了解random模块具体方法、for循环、range()函数等结合使用，作为预习)

import random  # 导入随机模块

N = int(input('请输入N个1~1000之间的随机整数：'))
num = 0
list1 = []
for i in range(N):  # 循环N次
    num = random.randint(1, 1001)  # 随机出1~1000之间的随机整数(N<=1000)
    list1.append(num)  # 将随机出的N个随机整数添加到列表中
set1 = set(tuple(list1))  # 将列表转换成不可变类型用集合去重
list2 = list(set1)  # 再转换成列表
list2.sort()  # 排序
print(list2)

输出结果：

请输入N个1~1000之间的随机整数：10
[121, 202, 234, 297, 411, 649, 674, 736, 890, 983]

作业4
字节如何转字符串，字符串如何转字节

字节转字符串

b = b'bytes'
print(b, type(b))
str1 = str(b, encoding='utf-8')
print(str1, type(str1))

输出结果：

b'bytes' <class 'bytes'>
bytes <class 'str'>

字符串转字节

str2 = 'string'
print(str2, type(str2))
b = bytes(str2, encoding='utf-8')
print(b, type(b))

输出结果：

string <class 'str'>
b'string' <class 'bytes'>

作业5
总结数据类型哪些为可变的哪些为不可变的

可变数据类型：列表、字典、集合
不可变数据类型：字符串、元组、数值、字节

标签：name,Python,数据类型,基础,元组,amy,dic1,print,li
来源： https://blog.csdn.net/LYUJVing/article/details/111827430