Python基础：数据类型

数据类型

标识符

• 第一个字符必须是字母表中字母或下划线_。（首字不能为数字）
• 标识符的其他的部分由字母、数字和下划线组成。
• 标识符对大小写敏感。
• 并且python3可以用中文作为变量名。

Python保留字

保留字即关键字，我们不能把它们用作任何标识符名称。Python 的标准库提供了一个 keyword 模块，可以输出当前版本的所有关键字。

Python命名规则

1. 名字具有一定的含义。比如写: n= “Tom”,不如: name="Tom"好。

2. 名字不要误导别人。比如用account_list指一组账号,就会被人误解为是list类型的数据,事实上可能是也可能不是。所以这时候最好换个名称,比如直接用accounts。

3. 名字要有意义的区分,有时候你可能会用到a1, a2之类的名字,最好不要这么做,换个别的方式,通过字面能够看出一定的区分来更好。

4. 最好是名称能够读出来，千万别自己造英文单词，也别不要用汉语拼音缩写来做为名字，更麻烦了，还不如全拼。最好是用完整的单词或者公认的不会引起歧义的缩写。

5. 单个字母和数字就少用了,不仅是显得你太懒惰,还会因为在一段代码中可能有很多个单个的字母和数字,为搜索带来麻烦,别人也更不知道你的i和他理解的i是不是一个含义。

   注释：Python中单行注释以#开头多行注释可以用多个#号,还有"和"“”

一切皆是对象

• 数字型：int, float, complex

• 布尔型: boolean

• 字符型：string

• 序列型：list, tuple, range

• 映射型: dict,集合型：set

• 文件 ：File

  Python3中6个标准数据类型：不可变数据（3个）：Number（数字）、String（字符串）、Tuple（元组）；可变数据（3 个）：List（列表）、Dictionary （字典）、Set（集合）

可变对象不可变对象
可变不可变对象

数字类型

• Python3 支持 int、float、bool、complex
• 最大的特点是整数不限制大小
• 浮点数受到17位有效数字的限制
• 常见的运算包括加、减、乘、除、整除、求余、幂指数等
• 一些常用的数学函数：如sqrt/sin/cos等都在math模块中import mathmath.sqrt(2)
• Python内置对复数的计算
• 支持所有常见的复数计算
• 对复数处理的数学函数在模块 cmath中如：import cmathcmath.sqrt(1+2j)

import math
print(math.sqrt(2))#output:1.4142135623730951
import cmath
print(cmath.sqrt(1+3j))#output:(1.442615274452683+1.0397782600555705j)
print((1+3j).imag)#output:3.0   #获取虚部，返回浮点数
print((1+3j).real)#output:1.0   #获取实部，返回浮点数

a, b = 17, 4
result = divmod(a, b)#(a // b, a % b)
print(result)# Output: (4, 1)

数据类型—布尔

• True

• False

if None or () or "" or () or {}:#或，全假为假
    print("it is True")
else:
    print("it is False")
    #output:it is False

逻辑判断符：

or(或) and(且) not(非)

序列类型

序列

数组

​ 数组是一种数据结构，用于存储和处理大量的数据。将所有的数据存储在一个或多个数组中，然后通过索引下标访问并处理数组的元素，可实现复杂数据处理任务。

注意：Python没有提供直接创建数组的功能，但可以使用内置的序列数据类型（例如列表）实现数组功能。

python内置序列数据类型

​ 序列包含元组、列表、字符串和字节数据，序列数据类型是Python数据数据结构的一组有顺序的元素的集合。序列数据可以包含一个或多个元素（对象，元素也可以是其他序列数据），也可以是一个没有任何元素的空序列。

• 元组：称为定值表，用于存储值固定不变的表
• 列表：称为表，用于存储值可变的表
• 字符串：是包含若干字符的序列数据
• 字节序列：是包含若干字节的序列，Python抓取网页时返回的页面通常为utf-8编码的字节序列。（字节序列可以和字符串相互转换）

序列数据操作

内置函数：

• len() # 获取序列长度
• max()、min() # 获取序列中元素的最大值/最小值
• sum() # 获取列表或元组中各元素之和（若有非数值元素导致TypeError，如果是字符串和字节数据也是TypeError)

序列的索引访问操作

​ 序列可以通用索引下标来访问可迭代对象，用户可以通过整数下标访问序列s的元素。

序列的切片操作（左闭右开）

​ 通过切片(slice)操作可以截取序列的一部分：s[i:j]或s[i:j:k]

• i 表示从下标i开始(包含s[i])，默认值是序列第一个元素。
• j 表示以下标截止(不包含s[j]), 默认值是序列最后一个元素
• k 表示步长，默认1（如果负数代表每次下标减几）
• 如果截取范围没有数据返回空元组

序列的连接和重复

​ 通过操作符+可以连接两个序列（s1和s2）形成一个新的序列对象；通过重复操作符*可以重复一个序列n次（n为正整数）

s1 和 s2 必须是相同数据类型

s1 + s2 或 s * n 或 n * s

连续操作符+h和重复操作符*也支持复合赋值运算 += 和 *=。

序列成员关系

x in s # 如果x在s中返回True

x not in s # 如果x不在s中返回False

s.count(x) # 返回x在s中出现的次数

序列的拆分

1. 变量个数和序列长度相等

​ 变量1，变量2，…变量n = 序列或可迭代对象

​ 若变量个数和序列元素不同导致ValueError

data = (100, "Lily", (80, 95, 78))
sid, name, scores = data
print(scores)#output:(80, 95, 78)
sid, name, (chinese, math, English) = data
print(math)#output:95

2. 变量个数和序列长度不等

​ 如果序列长度未知，可以使用 * 元组变量，将多个值作为元组赋值给元组变量，* 在一个赋值语句里只能使用一次，否则导致SyntaxError

first, *middles, last = range(10)
print(first)#output:0
print(*middles)#output:12345678
print(last)#output:9
*firsts, middle, last = range(10)
print(*firsts)#output:01234567
first, middle, *lasts = range(10)
print(*lasts)#output:23456789

3. 使用临时变量 _

​ 如果只需要使用部分数据，序列的其他位置可以使用临时变量 _

_, b, _ = (1, 2, 3)
print(b)#output:2
print(_)#output:3
name, _, *phones = ("Tom", "71058@qq.com", "2357999", "911", "110")
print(_)#output:71058@qq.com
print(*phones)#output:2357999 911 110

其他内置函数

• sorted(iterable, key = None, reverse = False) # 返回从小到大序列，reverse = True返回从大到小的序列
• all() # 若序列中所有制全为True返回True，any() # 只要序列中任意值为True返回True

字符串

07字符串
定义：s = “ilovepython”

Python访问字符串的值：

1. 从左到右索引默认0开始的，最大范围是字符串长度少1

2. 从右到左索引默认-1开始的，最大范围是字符串开头

   s[0]#i
   s[1:5]# love
   s[-6:]#python
   s[::-1]#nohtypevoli#等价于s[-1:-1]# step为负数，从左向右截取
   

索引值以0为开始值， -1为从末尾的开始位置

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8kZEjiG3-1688548254018)(…/…/《蓝鲸校园》/image/image-20230626170458765.png)]

#创建空字符串
s = str()
s = ""
s = ''
s = """ """#三引号一般用于多行注释

s = "ilovepython"
print(s.startswith("il"))#output:True
print(s.endswith("on"))#output:True
print(s.count("o"))#output:2
print(s.find("o"))#output:2 #返回找到的第一个"o"的索引
print(s.index("y"))#output:6#和find()区别，find找不到默认返回-1,index找不到ValueError

a_string = " this is a new string\n"
print(a_string)
print(a_string.strip())#去除字符串两端的空格、\t、\n   lstrip()去除左侧的，rstrip()去除右侧的
print(a_string.replace("\n","*"))#output:  this is a new string*
print(a_string.split())#output:['this', 'is', 'a', 'new', 'string']#\n、\t也被当作空格来处理

a_list = ['this', 'is', 'a', 'new', 'string']
print(" ".join(a_list))#output:this is a new string
print("*".join(a_list))#output:this*is*a*new*string

字符串—格式化
占位符
占位符

#output:I am from Maanshan. Gelinchuntian is my home.
#占位符
print("I am from %s. %s is my home." %("Maanshan", "Gelinchuntian"))#格式化字符串
print("I am from {}. {} is my home.".format("Maanshan", "Gelinchuntian"))#format方法
city, home = "Maanshan", "Gelinchuntian"
print(f"I am from {city}. {home} is my home.")#format方法简写
print(r"\n,\tstring '")#output:\n,\tstring '#r 使字符串里转义字符全都不转义

注意：Python中的字符串不能改变

*字节序列

​ 字节序列是由8位字节数据组成的序列数据类型，即0<=x<256的整数序列。Python内置的字节序列数据类型包括bytes(不可变对象)、bytearray(可变对象)和memoryview

bytes常量

​ 使用字母b加单引号或双引号括起来的内容是bytes常量。Python解释器将自动创建bytes型对象实例，与字符串定义方式类似。

单引号(b' ') #包含在单引号中的字符串可以包含双引号
双引号(b"  ") #包含在双引号中的字符串可以包含单引号
三单引号(b'''  ''') # 包含在三单引号中的字符串，可以跨行
三双引号(b"""   """) # 包含在三双引号中的字符串，可以跨行

注意：在引号中只能包含ASCII码字符，否则将导致SyntaxError

创建bytes对象

• bytes() # 创建空bytes对象
• bytes(n)# 创建长度为n（整数）的bytes对象，各字节为0
• bytes(iterable) # 创建bytes对象，使用iterable中的字节数据
• bytes(object) # 创建bytes对象，复制object字节数据
• bytes([source [ , encoding[, errors]]]) # 创建bytes对象

如果iterable中包括非范围为0 <= x < 256的整数，将导致ValueError

bytes对象是一个不可变序列，包含范围为0 <= x < 256的整数。bytes可以通过字面量、整数、字符串、字节序列或可迭代对象来构造：

# using integer
b1 = bytes(4)  # b'\x00\x00\x00\x00'

# using iterable
b2 = bytes([1, 2, 3, 4])  # b'\x01\x02\x03\x04'

# using string with encoding
b3 = bytes('hello', 'utf-8')  # b'hello'

创建bytearray对象

• bytearray() # 创建空bytearray对象
• bytearray(n) # 创建长度为n(整数)的bytearray对象，各字节为0
• bytearray(iterable) # 创建bytearray对象，使用iterable中的字节整数
• bytearray(object) # 创建bytearray对象，复制object字节数据
• bytearray([source [ , encoding[, errors]]]) # 创建bytearray对象

如果iterable中包括非范围为0 <= x < 256的整数，将导致ValueError

bytearray是一个可变的字节序列，可以进行增删改查等操作：

# create a bytearray object
ba = bytearray([94, 91, 101, 125, 111, 35, 120, 101, 115, 101, 200])

# change an item
ba[1] = 65

​ bytes和bytearray对象提供了字符串的很多方法，如split、replace、translate、strip等，但参数必须也是字节序列，而且不能包含超过一个字节的字符。

​ 另外，它们也提供了一些额外的方法和属性，比如fromhex方法、hex方法，以及decode方法等，用于处理字节序列。

​ 字节序列通常用于处理二进制数据，包括二进制文件、网络数据等。注意，在处理字节序列时，要清楚字节序（big-endian或little-endian）和编码方式。

字符串可以通过str.encode()方法编码为字节码，通过bytes和bytearray的decode()方法解码为字符串。

s = "好好学习"
b = s.encode()
d = b.decode()
print(b)#output:b'\xe5\xa5\xbd\xe5\xa5\xbd\xe5\xad\xa6\xe4\xb9\xa0'
print(d)#output:好好学习

列表

列表的常用操作
数据类型—list

列表是Python中最灵活的可变对象，列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同,它支持数字,字符串甚至可以包含列表(所谓嵌套)。

常用列表方法：

• a.append() # 把对象追加到列表的尾部
• a.extend(b) 或者 a + b# 把b序列附加到a尾部，当a, b 都是列表时才能用+
• a.insert(i, x) # 在下标i位置插入对象x
• a.pop(i) # 移除下标i位置的对象，并返回这个对象 ，省略i时默认为移除最后一个对象，若超出下标 -> IndexError
• a.sort() # 列表从小到大排序，sort(reverse = True)从大到小排序
• a.reverse() # 列表反转，逆序**（和sort(reverse = True)不同）**
• a.remove(x) # 移除列表中出现的第一个x,若对象不存在 -> ValueError
• a.clear() # 删除所有元素相当于del s[:]
• a.index(x) # 返回x在列表的下标，如果找不到 -> TypeError，类似字符串的find方法（但列表没有find方法）
• a.copy() 复制列表
• 深浅拷贝

#创建空列表
l = list()
l1 = []

friuts = ["apple", "bear", "peach"]
new_friuts = ["葡萄", "西瓜"]
friuts.extend(new_friuts)
print(friuts)
big_friuts = friuts + new_friuts
print(big_friuts)
#output
#['apple', 'bear', 'peach', '葡萄', '西瓜']
#['apple', 'bear', 'peach', '葡萄', '西瓜', '葡萄', '西瓜']

列表索引切片

fruits = ["apple", "bear", "peach"]
big_fruits = [list(fruits) for i in range(3)]
print(big_fruits)
print(big_fruits[2][1])#打印第3个子列表的第2个元素
big_fruits[2][1] = "orange"
print(big_fruits)
#output
#[['apple', 'bear', 'peach'], ['apple', 'bear', 'peach'], ['apple', 'bear', 'peach']]
#bear
#[['apple', 'bear', 'peach'], ['apple', 'bear', 'peach'], ['apple', 'orange', 'peach']]

列表推导式
列表推导式demo

#list comprehension
fruits = ["apple", "bear", "peach"]
big_fruits = [list(fruits) for i in range(3)]
print(big_fruits)
print(fruits)# fruits没有变化，list(fruits)创造了一个包含相同元素的fruits副本，不改变原列表
odd = [i for i in range(10) if i % 2 != 0]
print(odd)
#output
[['apple', 'bear', 'peach'], ['apple', 'bear', 'peach'], ['apple', 'bear', 'peach']]
['apple', 'bear', 'peach']
[1, 3, 5, 7, 9]

注意：

1. List写在方括号之间，元素用逗号隔开。

2. 和字符串一样,list可以被索引和切片。

3. List可以使用+操作符进行拼接。

4. List中的元素是可以改变的。

元组

元组的常用操作

数据类型—tuple

Tuple（元组）：操作特性和list类似,但元组时不可变对象，即用户不能修改、添加或删除元组中项目，但是可以访问元组中的项目

string、 list 和 tuple 都属于 sequence（序列）。

# 创建空元组
t = tuple()
t1 = ()
#创建只含一个元素的元组
t2 = ("a")
t3 = ("a",)#注意！必须加,否则默认为()里面元素的类型
print(type(t2))
print(type(t3))
#output
#<class 'str'>
#<class 'tuple'>

注意：

1. 与字符串一样,元组的元素不能修改。
2. 元组也可以被索引和切片，方法一样。
3. 注意构造包含0或1个元素的元组的特殊语法规则。
4. 元组也可以使用+操作符进行拼接。

集合类型

集合的常用操作

数据类型—set(集合)

集合数据类型是没有顺序的简单对象的聚集，且集合中的元素不重复包含可变对象（set)和不可变对象(frozenset)frozenset

集合类型（set)通过花括号中用逗号分隔的项目定义，基本形式：{x1, x2, x3, …xn } (x1-xn是任意可hash对象)可hash对象

集合（set）是一个无序的不重复元素序列。1.可以使用大括号{} 或者 set() 函数创建集合，注意：创建一个空集合必须用 set（） 而不是{}，因为{} 是用来创建一个空字典。

# 创建一个空集合
s = set()#空的可变集合
#创建一个非空集合
s1 = {3, 3, 4}#自动去除重复元素
print(s1)
#output
#{3, 4}

in / not in成员资格运算符

# 数学上定义
s = {2, "a"}
print(2 in s)
print(3 not in s)
#output
#True
#True

基本操作

# 基本操作
s = {2, "a"}
s.add(5)# 添加
print(s)
s.remove(5)# 删除
print(s)
#output
# {2, 5, 'a'}
# {2, 'a'}

位运算符位运算符

# {2, 'a'}
#%%
s1 = set(range(3))
s2 = set(range(2, 5))
print(s1, s2)
#交集
print(s1 & s2)
#并集
print(s1 | s2)
#差集
print(s1 - s2)
#对称差
print(s1 ^ s2)
# output:
# {0, 1, 2} {2, 3, 4}
# {2}
# {0, 1, 2, 3, 4}
# {0, 1}

集合的对象方法

• s1.isdisjoint(s2) # 如果集合s1和s2没有共同元素，返回True,否则返回False

• s1.issubset(s2) # 如果集合s1是s的子集，返回True，否则返回False

• s1.issuperset(s2) # 如果集合s1是s2的超集，返回True,否则返回False

• s1.union(s2, …) # 返回s1,s2…的并集

• s1.intersection(s2, …) # 返回s1, s2…的交集

• s1.difference(s2, …) # 返回s1,s2…的差集

• s1.symmetric_difference(s2) # 返回s1和s2的对称差集

可变集合的方法

• s1.update(s2, …) # s1,s2…求并集 (s1…sn得是可迭代对象)
• s1.intersection_update(s2, …) # s1,s2…求交集
• s1.difference_update(s2,…) # s1-s2-…求差集
• s1.symmetric_difference_update(s2) # 对称差集
• s.discard(x) # 从集合s中移除对象x(如果x存在)
• s.pop() # 从集合s中随机弹出一个元素，返回弹出的元素，如果s为空，则导致KeyError
• s.clear() # 清空集合

s.update(“字符串”）与 s.update({“字符串”}） 含义不同：

• s.update（{“字符串”}）将字符串添加到集合中，有重复的会忽略。

• s.update( “字符串” )将字符串拆分单个字符后,然后再一个个添加到集合中,有重复的会忽略。

对于python中列表list\tuple类型中的元素，转换为集合后，会去掉重复的元素

注意：

​ 对于是字典和字符转换的集合是随机删除元素的。当集合是由列表和元组组成时、set.pop（）是从左边删除元素的。

集合推导式

print({i for i in range(5)})
print({2 ** i for i in range(5)})
#output:
# {0, 1, 2, 3, 4}
# {1, 2, 4, 8, 16}

字典类型

字典的常规操作

数据类型—dict

字典是一组键/值对的数据结构。每个键对应一个值。在字典中，键不能重复，根据键可以查询到值。

字典通过花括号中用逗号分隔的项目（键/值。键值对使用冒号分隔）定义，基本形式为： {键1：值1 ，键2：值2…,键n:值n } （键必须是可hash对象可hash对象，值可以为任意对象，字典中键是唯一的，不能重复

hash("ab")# 获取对象hash值
# output:-8195748682623672102

• 字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型。
• 列表是有序的对象集合，字典是无序的对象集合。(py3.7以后字典是有序的)字典有序
• 两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
• 字典用"{}"标识。字典由索引(key)和它对应的值value组成

基本操作

# 创建空字典
a = {}
a = dict()
#创建非空字典
a = dict(abc = 123) # 等号左边只能用变量名
a = {"abc": 123, 95: 37, (1, 2): "hzh"}
print(a["abc"]) # 取值
a["abc"] = 321# 修改
print(a)
del a["abc"]
print(a)

# output:
# 123
# {'abc': 321, 95: 37, (1, 2): 'hzh'}
# {95: 37, (1, 2): 'hzh'}

字典特性

#字典不允许同一个键出现两次.创建时如果同一个键被赋值两次,后一个会被记住
a = {"a": 1, "a": 2}
print(a)#  output:{'a': 2}
#键必须不可变,所以可以用数字,字符串或元组充当
a = {"abc": 123, 95: 37, (1, 2): "hzh"}

注意:一个对象能不能作为字典的key,就取决于其有没有一hash一方法。所以所有python自带类型中,目前我已知的除了list, dict, set和内部带有以上三种类型的tuple之外,其余的对象都能当key。

字典的视图对象

• d.keys() # 返回字典d的键key的列表
• d.values() # 返回字典d的值value的列表
• d.items() # 返回字典d的(key, value)对的列表

字典d及其视图都是可迭代对象

字典推导式

d = {char: num for char in "abc" for num in range(1, 4)}
print(d)# output:{'a': 3, 'b': 3, 'c': 3}

​ 外层循环是for char in "abc"，内层循环是for num in range(1, 4)。对于每个字符char，都会遍历num in range(1, 4)。这样，每个字符键都会和1，2，3相对应，但是由于字典键的唯一性，只有最后一次的键值对会保留下来，也就是每个键对应的数值都是3。

d = {char: num for char, num in zip("abc", range(1, 4))}
print(d)  # output: {'a': 1, 'b': 2, 'c': 3}

​ zip函数将字符串"abc"和range(1, 4)中的元素一一对应起来，然后用字典推导式将对应的元素作为键值对添加到字典中。

字典对象的方法

• d.clear() # 删除所有元素
• d.copy() # 浅复制字典 深浅拷贝
• d.get(k, v)/d.get(k) # 返回键k对应的值，如果key不存在，返回v。如果没有参数v则返回None
• d.pop(k, v) # 如果键k存在，返回其值，并删除该项目；否则将返回v。如果没有参数v则导致KeyError
• d.setdefault(k, v) # 如果键k存在，返回其值，否则添加项目k = v，v默认为None
• d.update([other]) # 使用字典或键值对，更新或添加项目到字典中

注意：在Python中，可以使用列表或集合作为字典的值，以便将多个值与单个键关联起来。

1. 使用列表作为字典的值：

my_dict = {}
key = 'my_key'

# 方法1: 使用字典.setdefault()方法
my_dict.setdefault(key, []).append(value1)
my_dict.setdefault(key, []).append(value2)

# 方法2: 使用if-else语句
if key not in my_dict:
    my_dict[key] = []
my_dict[key].append(value1)
my_dict[key].append(value2)

2. 使用集合作为字典的值：

my_dict = {}
key = 'my_key'

# 方法1: 使用字典.setdefault()方法
my_dict.setdefault(key, set()).add(value1)
my_dict.setdefault(key, set()).add(value2)

# 方法2: 使用if-else语句
if key not in my_dict:
    my_dict[key] = set()
my_dict[key].add(value1)
my_dict[key].add(value2)

在这些示例中，my_dict是一个字典，key是要关联值的键，value1和value2是要添加到键的值列表或集合中的值。

请注意，在使用setdefault()方法时，如果键不存在于字典中，它将在字典中创建一个新的键，并将其与给定的默认值关联起来。如果键已经存在于字典中，setdefault()方法将返回与该键关联的现有值。

文件与对象

数据类型—文件

文件可以看作数据的集合，一般保存在磁盘或其他存储介质。

文件对象

f = open(file, mode = “r”, buffering = -1, encoding = None)

open()函数默认打开模式为：“rt”，即文本读取，模式

f = open("md5.txt")
print(f)#output:<_io.TextIOWrapper name='md5.txt' mode='r' encoding='cp936'>

注意：文本操作容易产生异常，而且最后需要关闭打开的文件，故一般使用try…except…finally语句，在try语句块中执行文件的相关操作，使用except捕获可能发生的异常，在finally语句块中确保关闭打开的文件。

try:
    f = open(file, mode) #打开文件
    #操作打开的文件
except:
    #发生异常时执行的操作
finally:
    f.close() #关闭打开的文件

文件属性

• f.name # 文件名

• f.mode # modes:r, w, a, x

print(f.name) #output:md5.txt
print(f.mode) #output:r

读取文件内容

f.read() # 获取md5.txt里的内容
f.read(100) # 读取100个字节内容
f.readline() # 读取一行内容
f.readlines() # 读取每一行内容
f.seek(0) # 将文件指针移动到文件开头

写入文件

f.write("some_contents")

关闭文件
flush

f.flush()# f.flush() 是用于将文件对象 f 的缓冲区内容立即写入到文件中的方法。
f.close()

with语句和上下文管理协议

使用try…except…finally语句可以确保在try语句块中获得的资源（例如打开的文件）在finally语块中释放。为了简化操作，Python语言中与资源相关的对象可以实现上下文管理协议。实现上下文管理协议的对象可以使用with语句。（确保打开的文件自动关闭）

with context [as var]

​ 操作语句

with open("md5.txt") as f:
    for line in f:
        print(line)
#output:hello words

with open("md5.txt") as f:
    for line in f:
        print(line)
#output:hello words