python中的数据类型

Python中的数据类型：

1、 Number（数字类型）

 Python Number 数据类型用于存储数值。

1.1数值类型（4种）

1）整型(Int) - 通常被称为是整型或整数，是正或负整数，不带小数点。

2）长整型(long integers) - 无限大小的整数，整数最后是一个大写或小写的L （注：只适用于python2，python3不区分，只有一种整数类型Int）

3）浮点型(floating point real values) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示

4）复数(complex numbers) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。

例：

a1 = 2          #整型

a2 = 51924361   #长整型

a3 = 5.2        #浮点型

a4=3.4j         #复数

print(a1, a2,a3, a4)

1.2 数字类型转换

1）int(x) 将x转换为一个整数。

2）float(x) 将x转换到一个浮点数。

3）complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。

4）complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。

例：

# 数字类型转换

a5 = 1.0

int(a5)

a6 = int(a5)

print(a5)   

print(a6)

print(type(a5))

print(type(a6))

1.3 数字运算

1）运算符：+，-， *， / ，//，**，=

2） /  ：返回一个浮点数

3） // ：只想得到整数的结果，丢弃可能的分数部分。// 得到的并不一定是整数类型的数，它与分母分子的数据类型有关系

4）=  ：用于给变量赋值

5）** ：幂运算

6）不同类型的数混合运算时会将整数转换为浮点数。

例：# 数字运算

b1 = 2+4    

b2 = 40-10

b3 = 2*4

b4 = 12/3

b5 = 13/3

b6 = 13//3

b7 = 3*3+1

b8 = 3**4

print(b1, b2, b3, b4, b5, b6, b7, b8)

2、 bool 布尔类型

布尔(bool)是整型的子类型。

Python2 中是没有布尔型，用数字 0 表示 False，用 1 表示 True。

Python3 中，把 True 和 False 定义成关键字，但它们的值还是 1 和 0，它们可以和数字进行相加减乘除。

例：

# 布尔值验证

b1 = 0

print(bool(b1))

b2 = 0.0

print(bool(b2))

b3 = -0.0

print(bool(b3))

b4 = {}

print(bool(b4))

b5 = []

print(bool(b5))

b6 = 1

print(bool(b6))

b7 = -1

print(bool(b7))

b8 = ''

print(bool(b8))

b9 = ""

print(bool(b9))

b10 = "False"

print(bool(b10))

b11 = 'False'

print(bool(b11))

b12 = True

print(bool(b12))

b13 = bool(10 > 9)

print(bool(b13))

2.1布尔类型运算

1）and：与运算，只有所有表达式都为True，and运算的结果才是True

c1 = True and False

print(c1)        #False

c2 = True and True

print(c2)        #True

c3 = False and False

print(c3)        #False

2）or：或运算，只要其中一个表达式为True，or运算的结果就为True

c4 = True or False   

print(c4)         #True

c5 = True or True

print(c5)         #True

c6 = False or False

print(c6)         #False

3）not：非运算，它是单目运算符（只对一个变量进行操作），把True变成False，把False变成True

c7 = not True

print(c7)    #False

c8 = not False

print(c8)    #True

c9 = not 1 > 2

print(c9)    #True

4）四则运算时，True的值为1，False的值为0

b1= True + 1

print(b1)  #2

b2 = False + 1

print(b2)  #1

3.String（字符串）

3.1字符串的创建

1）字符串是Python 中最常用的数据类型。使用引号( ' ' 或 " " )来创建字符串

 str1 = ‘’

 str2 = “”

 str3 = ‘hello world’

 str4 = “python”

3.2 访问字符串中的值

1）访问子字符串，可以使用方括号 [ ] 来截取字符串，格式：变量[头下标:尾下标]

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

str3 = 'hello world'

str4 = "python"

print("str3[0]:", str3[0])      #str3[0]: h

print("str3[1:4]:", str3[1:4])   #str3[1:4]: ell

print("str4[-1]:", str4[-1])    #str4[-1]: n

print("str4[-8:-1]:", str4[-4:-1])    #str4[-8:-1]: tho

3.3 字符串更新

# 字符串更新

str4 = "python"

str5 = str4[:4] + "Update"

print(str5)    #pythUpdate

4.List（列表）

List 可以修改可以删除，可以访问查询。

4.1 列表创建

1）列表使用方括号 [ ]

l1 = [‘python’, ‘pycharm’, 2003, 2023]

4.2 访问列表中的值

1）列表索引从 0 开始，依次1，2，依此类推。通过索引列表可以进行截取、组合等操作。

2）索引也可以从尾部开始，最后一个元素的索引为 -1，往前一位为 -2，依此类推。

3）支持使用 [] 截取字符

#查询字符

l1 = ['python', 'pycharm', 2003, 2023]

print(l1[1])    #pycharm

print(l1[-2])   #2003



# 截取字符

l2 = [10, 20, 30, 40, 50, 60, 70, 80, 90]

print(l2[1:4])   #[20, 30, 40]

4.3 更新/删除列表

# 更新列表

l1 = ['python', 'pycharm', 2003, 2023]

l2 = [10, 20, 30, 40, 50, 60, 70, 80, 90]

l2[2] = 'update list'

print(l2)     #[10, 20, 'update list', 40, 50, 60, 70, 80, 90]

l1.append('test update')

print(l1)    #['python', 'pycharm', 2003, 2023, 'test update']

# 删除

del l1[2]

print(l1)    #['python', 'pycharm', 2023, 'test update']

5.Tuple（元组）

Tuple 元素值不允许修改，不允许删除，可以访问查询

5.1 元组创建

1）元组使用小括号 ( )，逗号隔开；不需要括号也可以。

2）元组中只包含一个元素时，需要在元素后面添加逗号 “,” ，否则括号会被当作运算符使用。

t0 = ()

t1 = ('python', 'pycharm', 2003, 2023)

t2 = (0, 1, 2, 3, 4, 5)

t3 = "a", "b", "c", "d"  # 不需要括号也可以

t4 = ('red', 'green', 'blue', 'yellow', 'white', 'black')

t5 = (50)

t6 = (50,)

print(type(t5))  # 

print(type(t6))  # 

5.2 访问元组中的值

1）正向索引：索引从 0 开始，依次1，2，依此类推。可以进行截取、组合等操作。

2）反向索引：索引也可以从尾部开始，最后一个元素的索引为 -1，往前一位为 -2，依此类推。

3）截取使用 []

#查询字符

t1 = ('python', 'pycharm', 2003, 2023)

print(t1[0])  # python

print(t1[-2])  # 2003

# 截取字符

t4 = ('red', 'green', 'blue', 'yellow', 'white', 'black')

t7 = (10, 20, 30, 40, 50, 60, 70, 80, 90)

print(t7[0:4])  # (10, 20, 30, 40)

print("l4[1:-2]: ", t4[1:-2])  #l4[1:-2]:  ('green', 'blue', 'yellow')

5.3 元组运算

1）元组之间可以使用 + 号和 * 号进行运算。

#查询字符长度len

tup1 = len((1, 2, 3))

print(tup1)  # 3



tup2 = (1, 2, 3) + (4, 5, 6)

print(tup2)  # (1, 2, 3, 4, 5, 6)



tup3 = ('Hi!',) * 4

print(tup3)  # ('Hi!', 'Hi!', 'Hi!', 'Hi!')



3 in (1, 2, 3)

for x in (1, 2, 3):

    print(x, end=" ")  # 1 2 3

6.Set（集合）

6.1 集合创建

1）集合（set）是一个无序的不重复元素序列。

2）使用大括号 { } 或者 set() 函数创建集合。

3）创建空集合用 set() ，不能用 { }。

s1 = {'python', 'pycharm', 2003, 2023}

6.2 集合操作

6.2.1 添加元素

1）s.add( x ) ：将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。

2）s.update( x ) ：也可以添加元素，且参数可以是列表，元组，字典等。x 可以有多个，用逗号分开。

s1 = {'python', 'pycharm', 2003, 2023}

s1.add('10086')

print(s1)  # 无序 {2023, 'pycharm', 'python', '10086', 2003}

s1.update('gks')

print(s1)  # {2023, 's', 'pycharm', 'python', '10086', 2003, 'k', 'g'}

s1.update({11, 33})

print(s1)  # {33, 2023, 11, 's', 'pycharm', 'python', '10086', 2003, 'k', 'g'}

s1.update([1, 4], [5, 6])

print(s1)  # {33, 1, 4, 5, 6, 2023, 11, 's', 'pycharm', 'python', '10086', 2003, 'k', 'g'}

6.2.2 移除元素

1）s.remove( x ) ：将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。

2）s.discard( x )：如果元素不存在，不会发生错误。

3）s.pop()：随机删除集合中的一个元素。pop 方法会对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除。

s1.remove(2003)

print(s1)   #{'pycharm', 'python', 2023}

s1.discard(33)

s1.discard('33')  # '33'不存在 移除不报错

print(s1)   #{'pycharm', 'python', 2023}



s2 = s1.pop()  # 随机删除

print(s2)   #pycharm

6.2.3 计算集合元素个数

1）len(s) ：计算集合元素个数

s1 = {'python', 'pycharm', 2003, 2023}

s3 = len(s1)

print(s3)  # 4

6.2.4 判断元素是否在集合中存在

1） x  in  s ：判断元素 x 是否在集合 s 中，存在返回 True，不存在返回 False。

s1 = {'python', 'pycharm', 2003, 2023}

print('python' in s1)  # True

print('2021' in s1)  # False

6.2.5 清空集合

1）s.clear() ：清空集合 s。

s1 = {'python', 'pycharm', 2003, 2023}

s1.clear()

print(s1)  # set()

6.3 集合运算

a = set('abracadabra')

b = set('alacazam')

print(a)  # {'r', 'd', 'b', 'a', 'c'}



s4 = a - b  # 集合a中包含而集合b中不包含的元素

print(s4)  # {'r', 'd', 'b'}

s5 = a | b  # 集合a或b中包含的所有元素

print(s5)  # {'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}

s6 = a & b  # 集合a和b中都包含了的元素

print(s6)  # {'a', 'c'}

s7 = a ^ b  # 不同时包含于a和b的元素

print(s7)  # {'r', 'd', 'b', 'm', 'z', 'l'}

7.Dictionary（字典）

7.1 字典创建

1）d = {key1 : value1, key2 : value2, key3 : value3 }：字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在 {} 中。

2）键必须是唯一的，但值则不必。

3）值可以取任何数据类型，但键必须是不可变的，如字符串，数字，不可以用列表。

4）d ={ } ：空字典。

5）d = dict() ：使用函数dict()创建字典。

d = {}  # 空字典

print(type(d))  # 



d1 = dict()

print(type(d1))  # 



d2 = {"loginName": "0002",

      "password": "123456",

      "returnUrl": "",

      "operation": True,

      "validateCode": "688699",

      "deviceId": None}

7.2 访问字典里的值

d2 = {"loginName": "0002",

      "password": "123456",

      "returnUrl": "",

      "operation": True,

      "validateCode": "688699",

      "deviceId": None}

print(d2["operation"])  # True

# print(d2["pwd"])  # 访问不存在的报错

7.3 修改字典

d2 = {"loginName": "0002",

      "password": "123456",

      "returnUrl": "",

      "operation": True,

      "validateCode": "688699",

      "deviceId": None}

#更改

d2["loginName"] = "0006"

print(d2["loginName"])  # 0006

#增加

d2["tel"] = "6886888"

print(d2) #{'loginName': '0006', 'password': '123456', 'returnUrl': '', 'operation': True, 'validateCode': '688699', 'deviceId': None, 'tel': '6886888'}

7.4 删除字典元素

   del d2["deviceId"]  # 删除键 "deviceId"

   d2.clear()  # 清空字典

   del d2  # 删除字典

   # print(d2["deviceId"] ) # 删除后访问会引发异常