python基础--核心数据类型3

最新推荐文章于 2021-10-26 21:28:22 发布

庄AC

最新推荐文章于 2021-10-26 21:28:22 发布

阅读量869

点赞数

分类专栏： Python 基础文章标签： python

本文链接：https://blog.csdn.net/zyz1431/article/details/115010645

版权

Python 基础专栏收录该内容

14 篇文章 2 订阅

订阅专栏

python 的核心数据类型：

Number 数字（整数，浮点数，复数，布尔型数）
String 字符串
List 列表
Tuple 元组
Dictionary 字典
Set 集合

1. 列表的定义：（与元素的类型无关）

1、列表是由一系列特定元素组成的，元素与元素之间可能没有任何的关联关系，但他们之间有先后的顺序关系
2、列表是一种容器
3、列表是序列的一种
4、列表是可以被改变的序列

2. `序列` 的类型：（有先后顺序关系）

字符串    str
列表      list
元组      teple
字节串     bytes
字节数组   bytearray

3. 创建列表的方法：

创建空列表字面值：

L = []   # 方括号表示列表

创建非空列表

L = [1, 2, 3, 4]
L = ['beijing', 'shanghai', 'shenzhen']
L = [1, 'two', 3.14, 'four']
L = [1, 2, [3.1, 3.2], 4]

列表的构造函数

list()           # 生成一个空列表，等同于 []
list(iterable)   # 用可迭代对象初始化一个列表
L = list('hello')
s = "Holle"
L = list(s)
L = list(range(1, 10, 2))
len(L)           # 返回元素个数

4. 列表的运算：

算术运算：

+   +=   *   *=

+ 加号用于拼接出新列表（生成一个新列表，原列表不变，列表只能加列表）

x = [1, 2, 3]
y = [4, 5, 6]
print(x, y)
z = x + y
print(x, y, z)

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

+= 用于原列表与右侧可迭代对象拼接，并用变量重新绑定新列表

x = [1, 2, 3]
y = [4, 5, 6]
print(x, y)
x += y
print(x, y)

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

* 生成一个新的重复的列表

x = [1, 2]
y = x * 3
print(x, y)

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

*= 生成重复列表后并用原变量绑定

x = [1, 2, 3]
x *= 4
print(x)

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

比较运算符：（同类型才能进行比较）

<   <=   >   >=   ==   !=

[1, 2, 3] < [1, 2, 4]

True

[1, 3, 2] < [1, 2, 4]

False

[1, 2, 3] != [3, 2, 1]

True

[1, 2, 3] > [1, 4]

False

# 以下规则与字符串不同，因为列表可以存任意类型的数据
[1, "two"] > ["two", 2] # TypeError 类型错误

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-12-88804b70ba43> in <module>
      1 # 以下规则与字符串不同，因为列表可以存任意类型的数据
----> 2 [1, "two"] > ["two", 2] # TypeError 类型错误


TypeError: '>' not supported between instances of 'int' and 'str'

练习：输入三行文字，将这三行文字保存于一个列表L中，并打印再打印列表中字符串所有字符的个数, 如：

请输入：abc<回车>
请输入：1234<回车>
请输入：您好<回车>
生成如下列表：
    ['abc', '1234', '您好']
总字符数是：9

s1 = input("请输入: abc<回车> ")
s2 = input("请输入: 1234<回车> ")
s3 = input("请输入: 您好<回车> ")

x = 0
for s in [s1, s2, s3]:
    x += len(s)
print(x)

请输入: abc<回车> abc
请输入: 1234<回车> 1234
请输入: 您好<回车> 您好
9

列表的 in/not in 运算符

作用：

判断一个元素是否存在于列表中，如果存在则返回True，否则返回False 和字符串的in运算符规则相同

语法：

对象 in 列表

L = [None, True, 3.14, 10, 1+2j, "hello"]
print(3.14 in L)
print("3.14" in L)
print("10.0" in L)
print(5 not in L)

True
False
False
True

5. 列表的索引操作

语法：

列表[整数表达式]

用法：

等同于字符串索引
索引分为正向索引(从0开始)和反向索引(从-1开始)，规则与字符串完全相同

L = [1, 2.3, "Four"]
print(L[1])

2.3

列表的索引赋值

与字符串不同，字符串是不能被改变序列，所有没有索引赋值, 列表是可变的，可以通过索引赋值改变列表的元素(修改列表)

L = [1, 2.2, 3.14, "Four"]
print(L)
L[1] = 2
L[-1] = 4
L[-2] = 3
print(L)

[1, 2.2, 3.14, 'Four']
[1, 2, 3, 4]

6. 列表的切片 slice （取值操作）

列表的切片规则等同于字符串切片的规则

L = [1, 2.2, 3.14, "four", "五", "陆"]
L1 = L[::2]
print(L, L1, L1[: : -1])

[1, 2.2, 3.14, 'four', '五', '陆'] [1, 3.14, '五'] ['五', 3.14, 1]

列表的切片赋值操作：

作用：

改变原列表，可以插入（不切出元素，切片为空）、替换（切出元素，对应替换）和删除（切出元素赋值为空）列表中的元素

语法：

列表[切片] = 可迭代对象

说明：

切片赋值时，切片切出块数大于1时(步长大于1)，切片块数必须与可迭代对象取出数据的个数相同（替换）

L = [2, 3, 4]
print(L)

L[0: 1] = [1.1, 2.2]
print(L)

L[2: ] = [3.3, 4.4, 5.5]
print(L)

L[: ] = [3, 4]
print(L)

L[0: 0] = [1, 2]
print(L)

L[4: ] = [5, 6]
print(L)

L[6: ] = "AB"
print(L)

L[8: ] = range(7, 10)
print(L)

L[0: 1] = []
print(L)

# 切片步长大于1的切片赋值：（替换）
print(L[::2])
L[::2] = [1, 1, 1, 1, 1]
print(L)
L[::2] = [1, ]
print(L)

[2, 3, 4]
[1.1, 2.2, 3, 4]
[1.1, 2.2, 3.3, 4.4, 5.5]
[3, 4]
[1, 2, 3, 4]
[1, 2, 3, 4, 5, 6]
[1, 2, 3, 4, 5, 6, 'A', 'B']
[1, 2, 3, 4, 5, 6, 'A', 'B', 7, 8, 9]
[2, 3, 4, 5, 6, 'A', 'B', 7, 8, 9]
[2, 4, 6, 'B', 8]
[1, 3, 1, 5, 1, 'A', 1, 7, 1, 9]



---------------------------------------------------------------------------

ValueError                                Traceback (most recent call last)

<ipython-input-29-4b0b4c044603> in <module>
     30 L[::2] = [1, 1, 1, 1, 1]
     31 print(L)
---> 32 L[::2] = [1, ]
     33 print(L)


ValueError: attempt to assign sequence of size 1 to extended slice of size 5

L1=L 与 L2=L[:] 有什么区别？

L1=L是把L所指的对象绑定到名字L1上，而L2=L[:]则是把L通过切片运算取得的新列表对象绑定到L2上。前者两个名字指向同一个对象，后者两个名字指向不同对象。换句话说，L1和L是指的同一个东西，那么修改L1也就修改了L；L2则是不同的东西，修改L2不会改变L。注意这个引用的概念对于所有的东西都成立，例如容器内部存储的都是引用……

L = [1, 2, 3, 4, 5]
print(id(L), L)
L1 = L
print(id(L1), L1)
L1[0] = 0
print(L, L1)
print()
L = [1, 2, 3, 4, 5]
print(id(L), L)
L2 = L[:]
print(id(L2), L2)
L2[0] = 0
print(L, L1)

4477123848 [1, 2, 3, 4, 5]
4477123848 [1, 2, 3, 4, 5]
[0, 2, 3, 4, 5] [0, 2, 3, 4, 5]

4477123080 [1, 2, 3, 4, 5]
4477123656 [1, 2, 3, 4, 5]
[1, 2, 3, 4, 5] [0, 2, 3, 4, 5]

del语句（用于删除列表的元素）

L = [0, 1, 2, 3, 4, 5, 6]
print(L)
del L[0]
print(L)
del L[::2]
print(L)

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

7. 常用的列表方法（method）

假设列表对象为L

L.count(x)     返回列表中元素的个数
L.index(v[, begin[, end]])   返回对应元素的索引下标，begin为开始索引，end 为结束索引，当v值不存在时，触发ValueError错误
L.reverse()     列表的反转，用来改变原列表的先后顺序
list.sort(*, key=None, reverse=False)   
    将列表中的元素进行排列，默认按值从小到大的顺序排列，reverse=True 按从大到小顺序排列

L.append(x)    在列表中追加一个任意类型的元素, 相当于 a[len(a):] = [x] 
L.extend(list) 向列表追加另一个列表（将list列表中的元素分别追加到原列表中）, 相当于 a[len(a):] = iterable
L.insert(index, obj)   
    将某个元素插放到列表指定位置之前, 第一个参数是要插入的元素的索引，所以 a.insert(0, x) 插入列表头部， a.insert(len(a), x) 等同于 a.append(x) 。

L.remove(x)    从列表中删除第一个出现在列表中的值, 如果没有这样的元素，则抛出 ValueError 异常
L.clear()      清空列表，等同于L[:] = []
L.pop([索引])   删除索引对应的元素，如果不加索引，默认删除最后元素，同时返回删除元素的引用关系, 如果元素不存在则抛出 IndexError 异常

L.copy()   复制此列表（只复制一层，不会复制深层对象），L1 = L.copy()相当于 L1 = L[:]

8. 浅拷贝与深拷贝

浅拷贝（shallow copy）：浅拷贝是指在复制过程中，只复制一层变量，不会复制深层变量绑定的对象的复制过程

L = [3.1, 3.2]
L1 = [1, 2, L]
L2 = L1.copy()   # 浅拷贝 等同于 L2 =L1[:]
L2[2][0] = 3.14
print(L1)
print(L2)

[1, 2, [3.14, 3.2]]
[1, 2, [3.14, 3.2]]

深拷贝 deep copy（列表中有可变对象才需要考虑是否要用深拷贝）

import copy   #导入copy模块
L = [3.1, 3.2]
L1 = [1, 2, L]
L2 = copy.deepcopy(L1)
L2[2][0] = 3.14
print(L1)
print(L2)

[1, 2, [3.1, 3.2]]
[1, 2, [3.14, 3.2]]

9. 字符串处理方法split() 和 join()

字符串切分：假设字符串为S

str.split(sep=None, maxsplit=-1); str.rsplit(sep=None, maxsplit=-1)

返回一个由字符串内单词组成的列表，使用 sep 作为分隔字符串。 如果给出了 maxsplit，则最多进行 maxsplit 次拆分（因此，列表最多会有 maxsplit+1 个元素）。 如果 maxsplit 未指定或为 -1，则不限制拆分次数（进行所有可能的拆分）。

如果给出了 sep，则连续的分隔符不会被组合在一起而是被视为分隔空字符串 (例如 '1,,2'.split(',') 将返回 ['1', '', '2'])。 sep 参数可能由多个字符组成 (例如 '1<>2<>3'.split('<>') 将返回 ['1', '2', '3'])。 使用指定的分隔符拆分空字符串将返回 ['']。

如果 sep 未指定或为 None，则会应用另一种拆分算法：连续的空格会被视为单个分隔符，其结果将不包含开头或末尾的空字符串，如果字符串包含前缀或后缀空格的话。 因此，使用 None 拆分空字符串或仅包含空格的字符串将返回 []。

rsplit() 的其他行为都类似于 split(), 只是在从 最右边 开始切分

s = "Beijing is capital"
L = s.split(" ")    # L = ['Beijing', 'is', 'capital']
L1 = s.split() 
print(L, L1)

['Beijing', 'is', 'capital'] ['Beijing', 'is', 'capital']

str.splitlines([keepends])

按照行('\r', '\r\n', \n')等分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符

字符串拼接：假设字符串为S

str.join(iterable)

返回一个由 iterable 中的字符串拼接而成的字符串。 如果 iterable 中存在任何非字符串值包括 bytes 对象则会引发 TypeError。 调用该方法的字符串将作为元素之间的分隔

print('\\'.join(["C:", "Programe Files", "Python3"]))

C:\Programe Files\Python3

练习：有字符串“hello”，生成“h e l l o”和“h-e-l-l-o”

print(' '.join("hello"))
print('-'.join("hello"))

h e l l o
h-e-l-l-o

练习: 有一些数，存于列表中，如：L = [1, 3, 2, 1, 6, 4, 2, 7, 99] 要求将列表中只出现一次的元素存入到另一个列表L2中？

L = [1, 3, 2, 1, 6, 4, 2, 7, 99]
L1 = []
for x in L:
    if x not in L1:
        L1.append(x)
print(L, L1)

[1, 3, 2, 1, 6, 4, 2, 7, 99] [1, 3, 2, 6, 4, 7, 99]

练习：生成100个斐波那契数(Fibonacci sequence), fibs = (1, 1, 2, 3, 5, ........)存在列表fibs里并打印

L = [1, 1]
for x in range(0, 50):
    s = 0
    s += L[x] + L[x + 1]
    L.append(s)
print(L)

[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025, 121393, 196418, 317811, 514229, 832040, 1346269, 2178309, 3524578, 5702887, 9227465, 14930352, 24157817, 39088169, 63245986, 102334155, 165580141, 267914296, 433494437, 701408733, 1134903170, 1836311903, 2971215073, 4807526976, 7778742049, 12586269025, 20365011074, 32951280099]

10. 列表推导式 list comprehension

作用：

用可迭代对象生成列表

语法：

[表达式 for 变量 in 可迭代对象]
或
[表达式 for 变量 in 可迭代对象 if 真值表达式]

练习：用列表推导式生成 [1, 4, 9, 16, 25, 36, 49, 64, 81]

L = [x**2 for x in range(1, 10)]
print(L)

[1, 4, 9, 16, 25, 36, 49, 64, 81]

练习：用列表推导式生成实例生成0-100之间所有奇数的列表

L = [x for x in range(100) if x % 2 == 1]
print(L)

[1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, 41, 43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 63, 65, 67, 69, 71, 73, 75, 77, 79, 81, 83, 85, 87, 89, 91, 93, 95, 97, 99]

11. 列表推导式的嵌套：

语法：

[表达式1
for 变量1 in 可迭代对象1 (if 真值表达式1)
for 变量2 in 可迭代对象2 (if 真值表达式)]
注：()小括号内容可省

s = "ABC"
s2 = "123"
# 循环来实现
L = []
for y in s:
    for x in s2:
        L.append(y + x)
print(L)

# 用列表推导式来实现
L = [y + x
     for y in s
     for x in s2
     ]
print(L)

['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3']
['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3']

同名公众号庄AC

庄AC

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录