五、Python 基础数据类型

Python 基础数据类型

1、变量

  1)Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。

  2)在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。

  3)等号（=）用来给变量赋值

  4)等号（=）运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值

counter = 100  # 整型变量
miles = 1000.0  # 浮点型变量
name = "runoob"  # 字符串

print(counter)
print(miles)
print(name)

 

2、多个变量赋值

 Python允许你同时为多个变量赋值,并且类型可以不同

# 2、多个变量赋值
# Python允许你同时为多个变量赋值,并且类型可以不同
print('2、多个变量赋值')
#以上实例，创建一个整型对象，值为 1，从后向前赋值，三个变量被赋予相同的数值
a=b=c=1
#两个整型对象 3 和 4 的分配给变量 e 和 d，字符串对象 "test" 分配给变量 f
e, d, f = 3, 4, "test"
print(str(a)+','+str(b)+','+str(c))
print(str(e)+','+str(d)+','+f)

3、标准数据类型 

Number（数字）

String（字符串）

List（列表）

Tuple（元组）

Set（集合）

Dictionary（字典）

 

Python3 的六个标准数据类型中：

    不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；

    可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

 

 

4.1、Number（数字） 

   1)Python3 支持 int、float、bool、complex（复数）。

    2)在Python 3里，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。 像大多数语言一样，数值类型的赋值和计算都是很直观的。

    3)内置的 type() 函数可以用来查询变量所指的对象类型。

    4)此外还可以用 isinstance 来判断 isinstance 和 type 的区别在于： type()不会认为子类是一种父类类型 isinstance()会认为子类是一种父类类型

 

a, b, c, d = 20, 5.5, True, 4+3j
print(type(a), type(b), type(c), type(d))
print('a是否是整形? '+str(isinstance(a, int)))
'''
使用del语句删除一些对象引用,删除引用后，后面该对象无法使用
del语句的语法是
del var1[,var2[,var3[....,varN]]]
'''
var1 = 10
var2 = 'abc'
del var1,var2

'''
数值运算
注意：
  1、Python可以同时为多个变量赋值，如a, b = 1, 2。
  2、一个变量可以通过赋值指向不同类型的对象。
  3、数值的除法包含两个运算符：/ 返回一个浮点数，// 返回一个整数。
  4、在混合计算时，Python会把整型转换成为浮点数。
'''
print(5 + 4)    # 加法
print(4.3 - 2)  # 减法
print(3 * 7)    # 乘法
print(2 / 4)    # 除法，得到一个浮点数
print(2 // 4)   # 取整除 - 向下取接近除数的整数
print(17 % 3)   # 取余
print(2 ** 5)   # 乘方

 

 4.2 字符串

1) Python中的字符串用单引号 ' 或双引号 " 括起来，同时使用反斜杠 \ 转义特殊字符 .

   如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串：

2) 字符串的截取的语法格式如下

    变量[头下标:尾下标]

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

stra = 'python'
print(stra)  # 输出字符串
print('\'',str,'\'的长度为：',len(stra))  # 输出字符串
print(stra[0:-1])  # 输出第一个到倒数第二个的所有字符
print(stra[0])     # 输出字符串第一个字符
print(stra[2:5])   # 输出从第三个开始到第五个的字符
print(stra[2:])    # 输出从第三个开始的后的所有字符
print(stra * 2)    # 输出字符串两次，也可以写成 print (2 * str)
print(stra + "Test")  # 连接字符串
print('中文'.encode('utf-8'))  #中文转utf-8编码
print ("我叫 %s 今年 %d 岁!" % ('小明', 10))
name = 'Jame'
print(f'Hello {name}')   # 替换变量
print(f'我想要的数字是：{1+2}')         # 使用表达式

 

4.3 List（列表） 

  1) Python 中使用最频繁的数据类型;

  2)大多数集合类的数据结构实现;

  3)列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）;

  4)列表是写在方括号 [] 之间、用逗号分隔开的元素列表;

  5)和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表; 列表截取的语法格式如下： 变量[头下标:尾下标]

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

注意：

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

     2)、和字符串一样，list可以被索引和切片

     3)、List可以使用+操作符进行拼接

     4)、List中的元素是可以改变的

 

 

list = ['abcd', 321, 1.22, 'efgh', 34.9]
tinylist = [123, 'test']

print(list)             # 输出完整列表
print(list[0])          # 输出列表第一个元素
print(list[1:3])        # 从第二个开始输出到第三个元素
print(list[2:])         # 输出从第三个元素开始的所有元素
print(tinylist * 2)     # 输出两次列表
print(list + tinylist)  # 连接列表
x=[list,tinylist]       # 嵌套列表
print('嵌套列表第0个元素：',x[0])
list.append('cc')       # list末尾追加一个元素
print('添加一个元素 cc ,list为：',list)
del list[2]             # 删除下标为2的元素
print('删除后的列表：',end='')   #打印输出后不换行
print(list)

 4.3.1 列表推导式

        列表推导式提供了从序列创建列表的简单途径。通常应用程序将一些操作应用于某个序列的每个元素，
用其获得的结果作为生成新列表的元素，或者根据确定的判定条件创建子序列
如果希望表达式推导出一个元组，就必须使用括号 

print('列表推导式')
vec = [1,2,3,4,5,6]
newVec = [3*x for x in vec if x > 3]
print('列表推导式推出的元组是：',newVec)

4.3.2 嵌套列表解析

# 3x4的矩阵列表
matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
# 转换成 4x3 矩阵
print('4x3矩阵列表：',[[row[i] for row in matrix] for i in range(4)])

 

4.4 Tuple（元组）

元组写在小括号 () 里，元素之间用逗号隔开，list是[] '''

1)元组（tuple）与列表类似，不同之处在于元组的元素不能修改

2)元组中的元素类型也可以不相同 3)引且下标索引从0开始，-1 为从末尾开始的位置。也可以进行截取

4)虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表

5)构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则 tup1 = () # 空元组 tup2 = (20,) # 一个元素，需要在元素后添加逗号

 4.5 Set（集合）

1）定义：集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。

2）基本功能是进行成员关系测试和删除重复元素。

3）可以使用大括号 { } 或者 set() 函数创建集合，

      注意：

      创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典

4）创建格式：

    parame = {value01,value02,...}

    或者 set(value)

 

5、实战代码如下

    

#!/usr/bin/python3        #第一行注释是为了告诉Linux/OS X系统，这是一个Python可执行程序，Windows系统会忽略这个注释
# -*- coding: utf-8 -*-   #Python解释器，按照UTF-8编码读取源代码，否则，你在源代码中写的中文输出可能会有乱码
# 1、变量
print('1、变量')
'''
1)Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
2)在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。
3)等号（=）用来给变量赋值。
4)等号（=）运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值
'''

counter = 100  # 整型变量
miles = 1000.0  # 浮点型变量
name = "runoob"  # 字符串

print(counter)
print(miles)
print(name)

# 2、多个变量赋值
# Python允许你同时为多个变量赋值,并且类型可以不同
print('2、多个变量赋值')
#以上实例，创建一个整型对象，值为 1，从后向前赋值，三个变量被赋予相同的数值
a=b=c=1
#两个整型对象 3 和 4 的分配给变量 e 和 d，字符串对象 "test" 分配给变量 f
e, d, f = 3, 4, "test"
print(str(a)+','+str(b)+','+str(c))
print(str(e)+','+str(d)+','+f)

#3、标准数据类型
print('3、标准数据类型')
'''
Python3 中有六个标准的数据类型：
Number（数字）
String（字符串）
List（列表）
Tuple（元组）
Set（集合）
Dictionary（字典）
Python3 的六个标准数据类型中：
不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。
'''

#4.1、Number（数字）
print('4.1、Number（数字）')
'''
1)Python3 支持 int、float、bool、complex（复数）。
2)在Python 3里，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。
像大多数语言一样，数值类型的赋值和计算都是很直观的。
3)内置的 type() 函数可以用来查询变量所指的对象类型。

4)此外还可以用 isinstance 来判断

isinstance 和 type 的区别在于：
   type()不会认为子类是一种父类类型
   isinstance()会认为子类是一种父类类型
   
'''
a, b, c, d = 20, 5.5, True, 4+3j
print(type(a), type(b), type(c), type(d))
print('a是否是整形? '+str(isinstance(a, int)))
'''
使用del语句删除一些对象引用,删除引用后，后面该对象无法使用
del语句的语法是
del var1[,var2[,var3[....,varN]]]
'''
var1 = 10
var2 = 'abc'
del var1,var2

'''
数值运算
注意：
  1、Python可以同时为多个变量赋值，如a, b = 1, 2。
  2、一个变量可以通过赋值指向不同类型的对象。
  3、数值的除法包含两个运算符：/ 返回一个浮点数，// 返回一个整数。
  4、在混合计算时，Python会把整型转换成为浮点数。
'''
print(5 + 4)    # 加法
print(4.3 - 2)  # 减法
print(3 * 7)    # 乘法
print(2 / 4)    # 除法，得到一个浮点数
print(2 // 4)   # 取整除 - 向下取接近除数的整数
print(17 % 3)   # 取余
print(2 ** 5)   # 乘方

#4.2 字符串
print('4.2、字符串')
'''
    1) Python中的字符串用单引号 ' 或双引号 " 括起来，同时使用反斜杠 \ 转义特殊字符
如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串：
    2) 字符串的截取的语法格式如下
变量[头下标:尾下标]
索引值以 0 为开始值，-1 为从末尾的开始位置
    3)字符串格式化 用%
    4）使用f-string格式化  
       python3.6 之后版本添加的，称之为字面量格式化字符串，是新的格式化字符串的语法。

'''
stra = 'python'
print(stra)  # 输出字符串
print('\'',str,'\'的长度为：',len(stra))  # 输出字符串
print(stra[0:-1])  # 输出第一个到倒数第二个的所有字符
print(stra[0])     # 输出字符串第一个字符
print(stra[2:5])   # 输出从第三个开始到第五个的字符
print(stra[2:])    # 输出从第三个开始的后的所有字符
print(stra * 2)    # 输出字符串两次，也可以写成 print (2 * str)
print(stra + "Test")  # 连接字符串
print('中文'.encode('utf-8'))  #中文转utf-8编码
print ("我叫 %s 今年 %d 岁!" % ('小明', 10))
name = 'Jame'
print(f'Hello {name}')   # 替换变量
print(f'我想要的数字是：{1+2}')         # 使用表达式


#4.3 List（列表）
print('4.3 List（列表）')
'''
1) Python 中使用最频繁的数据类型;
2)大多数集合类的数据结构实现;
3)列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）;
4)列表是写在方括号 [] 之间、用逗号分隔开的元素列表;
5)和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表;
   列表截取的语法格式如下：
   变量[头下标:尾下标]
6)索引值以 0 为开始值，-1 为从末尾的开始位置;

注意：
1、List写在方括号之间，元素用逗号隔开
2、和字符串一样，list可以被索引和切片
3、List可以使用+操作符进行拼接
4、List中的元素是可以改变的
'''
list = ['abcd', 321, 1.22, 'efgh', 34.9]
tinylist = [123, 'test']

print(list)             # 输出完整列表
print(list[0])          # 输出列表第一个元素
print(list[1:3])        # 从第二个开始输出到第三个元素
print(list[2:])         # 输出从第三个元素开始的所有元素
print(tinylist * 2)     # 输出两次列表
print(list + tinylist)  # 连接列表
x=[list,tinylist]       # 嵌套列表
print('嵌套列表第0个元素：',x[0])
list.append('cc')       # list末尾追加一个元素
print('添加一个元素 cc ,list为：',list)
del list[2]             # 删除下标为2的元素
print('删除后的列表：',end='')   #打印输出后不换行
print(list)

#列表推导式
'''
列表推导式提供了从序列创建列表的简单途径。通常应用程序将一些操作应用于某个序列的每个元素，
用其获得的结果作为生成新列表的元素，或者根据确定的判定条件创建子序列
如果希望表达式推导出一个元组，就必须使用括号
'''
print()
print('列表推导式')
vec = [1,2,3,4,5,6]
newVec = [3*x for x in vec if x > 3]
print('列表推导式推出的元组是：',newVec)


#嵌套列表解析
print()
print('嵌套列表解析')

# 3x4的矩阵列表
matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
# 转换成 4x3 矩阵
print('4x3矩阵列表：',[[row[i] for row in matrix] for i in range(4)])

#4.4 Tuple（元组）
print()
print('4.4 Tuple（元组）')
# 元组写在小括号 () 里，需要括号也行，元素之间用逗号隔开，list是[]
'''
1、元组（tuple）与列表类似，不同之处在于元组的元素不能修改  所谓元组的不可变指的是元组所指向的内存中的内容不可变。
2、元组中的元素类型也可以不相同
3、引且下标索引从0开始，-1 为从末尾开始的位置。也可以进行截取
4、虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表
5、构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则
   tup1 = ()      # 空元组
   tup2 = (20,)   # 一个元素，需要在元素后添加逗号
'''
tuple = ('abcd', 321, 1.22, 'efgh', 34.9)
tinyTuple = (123, 'test')
testTuple = 'a','b',1


print('元组tuple:',tuple)                              # 输出完整列表
print('元组tuple[0]:',tuple[0])                        # 输出列表第一个元素
print('元组tuple[1,3]:',tuple[1:3])                    # 从第二个开始输出到第三个元素
print('元组tuple[2:]:',tuple[2:])                      # 输出从第三个元素开始的所有元素
print('元组tinyTuple输出两次:',tinyTuple * 2)           # 输出两次列表
print('连接元组tuple，tinyTuple：',tuple + tinyTuple)  # 连接2个元组
print('元组testTuple：',testTuple)                     # 输出完整列表testTuple
del testTuple                                          # 删除元组

#4.5 Set（集合）
print()
print('4.5 Set（集合')
'''
1）定义：集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。
2）基本功能是进行成员关系测试和删除重复元素。
3）可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典
4）创建格式：
   parame = {value01,value02,...}
   或者
   set(value)
'''
student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}
print(student)  # 输出集合，重复的元素被自动去掉
# 成员测试
if 'Rose' in student:
    print('Rose 在集合中')
else:
    print('Rose 不在集合中')

# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')
print('打印集合a:',a)
a.add('yyy')                      # 添加元素  也可以用 a.update('yyy')
print('a集合中添加元素 yyy：',a)  # a 和 b 的差集
print('a 和 b 的差集a-b:',a - b)  # a 和 b 的差集
print('a 和 b 的并集a|b:',a | b)  # a 和 b 的并集
print('a 和 b 的交集:',a & b)  # a 和 b 的交集
print('a 和 b 中不同时存在的元素:',a ^ b)  # a 和 b 中不同时存在的元素

#4.6 Dictionary（字典）
print()
print('4.6 Dictionary（字典）')
'''
1)字典（dictionary）是Python中另一个非常有用的内置数据类型
2)列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取
字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合
3)键(key)必须使用不可变类型 例如：数字、字符串、元组
4)在同一个字典中，键(key)必须是唯一的 
'''
dict = {}
dict['one'] = "这是第一个元素"
dict[2] = "这是第二个元素"
tinydict = {'name': 'jake', 'code': 131, 'web': 'www.baidu.com'}
del tinydict['name']
print('输出键为 one 的值',dict['one'])                    # 输出键为 'one' 的值
print('输出键为 2 的值',dict[2])                          # 输出键为 2 的值
print('输出完整的字典tinydict:',tinydict)                 # 输出完整的字典
print('输出完整的字典tinydict所有键',tinydict.keys())     # 输出所有键
print('输出完整的字典tinydict所有值',tinydict.values())   # 输出所有值
print('删除key=name的字典：',tinydict)                    # 删除

    结果输出：

C:\Users\Administrator\AppData\Local\Programs\Python\Python38-32\python.exe F:/python-space/test/BaseDataType.py
1、变量
100
1000.0
runoob
2、多个变量赋值
1,1,1
3,4,test
3、标准数据类型
4.1、Number（数字）
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>
a是否是整形? True
9
2.3
21
0.5
0
2
32
4.2、字符串
python
' <class 'str'> '的长度为： 6
pytho
p
tho
thon
pythonpython
pythonTest
b'\xe4\xb8\xad\xe6\x96\x87'
我叫 小明 今年 10 岁!
Hello Jame
我想要的数字是：3
4.3 List（列表）
['abcd', 321, 1.22, 'efgh', 34.9]
abcd
[321, 1.22]
[1.22, 'efgh', 34.9]
[123, 'test', 123, 'test']
['abcd', 321, 1.22, 'efgh', 34.9, 123, 'test']
嵌套列表第0个元素： ['abcd', 321, 1.22, 'efgh', 34.9]
添加一个元素 cc ,list为： ['abcd', 321, 1.22, 'efgh', 34.9, 'cc']
删除后的列表：['abcd', 321, 'efgh', 34.9, 'cc']

列表推导式
列表推导式推出的元组是： [12, 15, 18]

嵌套列表解析
4x3矩阵列表： [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
4.4 Tuple（元组）
元组tuple: ('abcd', 321, 1.22, 'efgh', 34.9)
元组tuple[0]: abcd
元组tuple[1,3]: (321, 1.22)
元组tuple[2:]: (1.22, 'efgh', 34.9)
元组tinyTuple输出两次: (123, 'test', 123, 'test')
连接元组tuple，tinyTuple： ('abcd', 321, 1.22, 'efgh', 34.9, 123, 'test')
元组testTuple： ('a', 'b', 1)
4.5 Set（集合
{'Jim', 'Tom', 'Mary', 'Rose', 'Jack'}
Rose 在集合中
打印集合a: {'d', 'a', 'b', 'c', 'r'}
a集合中添加元素 yyy： {'d', 'yyy', 'a', 'b', 'c', 'r'}
a 和 b 的差集a-b: {'d', 'r', 'b', 'yyy'}
a 和 b 的并集a|b: {'d', 'z', 'yyy', 'a', 'b', 'm', 'c', 'r', 'l'}
a 和 b 的交集: {'a', 'c'}
a 和 b 中不同时存在的元素: {'d', 'z', 'yyy', 'b', 'm', 'r', 'l'}
4.6 Dictionary（字典）
输出键为 one 的值 这是第一个元素
输出键为 2 的值 这是第二个元素
输出完整的字典tinydict: {'code': 131, 'web': 'www.baidu.com'}
输出完整的字典tinydict所有键 dict_keys(['code', 'web'])
输出完整的字典tinydict所有值 dict_values([131, 'www.baidu.com'])
删除key=name的字典： {'code': 131, 'web': 'www.baidu.com'}

Process finished with exit code 0