Python学习笔记数据类型

向右看齐 2022-08-18 14:18 207阅读 0赞

要学习一门语言，首先要看看它的数据类型。由于Python是一门动态语言，所以Python的变量在声明时不需要类型，只要写出名称即可。这里所用的Python版本是目前最新的Python 3.6.1。

## 数字类型 ##

### 整数 ###

在Python中只有一种整数类型，类似Java的BigInteger，可以扩展到无限大位。整数字面量可以是十进制、二进制、八进制或十六进制的。数字在输出的时候会以十进制输出，如果希望以其他形式输出，可以使用oct、hex、bin等几个内置函数转换。

在Python中运算符和其他语言类似。比较特殊的是除法，默认的`/`是小数除，而其他语言中的整除是`//`。乘方则是`**`。下面用一点例子来说明。

print('--------------整数类型--------------')
    print(f'Integer type:{type(100)}')
    print(f'Integer value:{100}')
    
    # 各种进制
    decimal = 100
    binary_number = 0b1100
    octal_number = 0o12374
    hexadecimal = 0xcafe
    
    print(f'八进制:{oct(decimal)}')
    print(f'十六进制:{hex(decimal)}')
    print(f'二进制:{bin(decimal)}')
    
    # 特别的运算符
    result = 5 / 3
    print(f'/ 是小数除:{result}')
    result = 5 // 3
    print(f'// 是整除:{result}')
    result = 5 ** 3
    print(f'**是乘方:{result}')

### 浮点数 ###

Python中的浮点数，就是遵循IEEE 754的双精度浮点数。浮点数也支持科学计数法。这里没什么说的。

print('--------------浮点数类型--------------')
    print(f'Float type:{type(3.14)}')
    print(f'Float value:{3.14}')
    
    # 各种小数
    float_number = 3.1415
    exp_number = 0.31415e1
    print(f'float:{exp_number}')

### 复数 ###

Python还有一个特点，那就是内置了复数的支持。复数字面量使用`a+bj`来表示。复数的实部和虚部分别用real和imag来取得。

print('--------------复数类型--------------')
    complex1 = 1 + 2j
    complex2 = 2 + 3j
    print('复数类型：', type(complex1))
    print('复数：', complex1 + complex2)
    print('复数{0}的实部：{1}，虚部是：{2}'.format(complex1, complex1.real, complex1.imag))
    print('{0}的共轭复数是：{1}'.format(complex1, complex1.conjugate()))

## 布尔类型 ##

Python支持布尔类型，真值和假值分别是`True`和`False`。

print('--------------布尔类型--------------')
    
    print(f'Bool type:{type(True)}')
    print(f'Bool value:{False}')

## 空类型 ##

Python的空类型类似Java中的void或null。

print('--------------空类型--------------')
    print(f'None type:{type(None)}')
    print(f'None value:{None}')

## 字符串 ##

Python字符串可以使用单引号`'`或双引号`"`来包括。它们之间没有任何区别。当使用一种引号的时候，字符串内部的另一种引号不需要转义。所以如果字符串内部要包含单引号，那么我们使用双引号包括更好。需要注意，**Python字符串是不可变的**。

多行字符串使用三个连续的引号来表示。为了美观，多行字符串的第一行往往另起一行，不过这样的话第一行实际上会是个空行。如果希望不要第一行的空行，可以在多行字符串上添加一个反斜杠\\。

如果字符串引号前有一个字母r，说明这个字符串是一个原始（raw）字符串，其中的`\n`这样的字符不会转义，而是以字面量形式输出。

如果字符串引号前有一个字母f，表示这是一个格式化字符串。该字符串中的`{variable}`将会被实际的变量值所替换。该功能是Python 3.6中新增的。原始字符串和格式化字符串也可以混用。

下面是一些例子。

print('--------------字符串类型--------------')
    print(f'String type:{type("")}')
    print(f'string value:{"fuck"}')
    
    multiLineString = '''\ 这是一个多行字符串 首行的\\表示第一行被忽略 '''
    print(multiLineString)
    
    rawString = r"\n不会被转移"
    print(f'原始字符串:{rawString}')
    
    formattedString = f"{3.14}"
    print(f'格式化字符串:{formattedString}')

## 列表 ##

列表也是一种内置可变的数据结构，类似Java的List。Python的列表使用也很简单。新建列表需要空的一对方括号`[]`或者`list()`来新建一个空列表。列表有很多方法可以操作列表中的元素。直接看例子就行了。

print('--------------列表--------------')
    # 新建列表
    list1 = []
    list2 = list()
    
    # 插入元素
    list1.append(1)
    list1.append(2)
    list1.extend(range(3, 6))
    list1.insert(2, 9)
    
    print(f'插入元素 list1:{list1}')
    
    # 删除元素
    list1.remove(5)
    del list1[2]
    print(f'删除元素 list1:{list1}')
    
    # 清除列表
    list1.clear()
    print(f'清除列表 list1:{list1}')
    
    # 栈操作
    list2.append(1)
    list2.append(2)
    list2.pop()
    print(f'list2:{list2}')

## 元组 ##

元组和列表类似，不过需要注意，**元组是不可变的**。元组的主要作用就是让函数方便的返回多个值。创建空元组，可以使用`()`或者`tuple()`来创建。需要注意假如元组只有一个元素，那么需要在后面添加一个逗号。元组的值也可以方便的解构出来。

print('--------------元组--------------') print(f'tuple type:{ type((5,))}') tuple1 = () tuple1 = tuple() tuple2 = (1, 2, 3, 4, 5) tuple3 = (50,) tuple2 = (5, 6) a, b = tuple2 print(f'a={a},b={b}')

## 集合 ##

集合表示不重复的元素组合。要创建集合，只要把元素放到一对花括号中即可。如果需要空集合，不能使用`{}`，而应该使用`set()`来创建。如果需要不可变集合，使用`frozenset`。集合的简单使用列在下面了。

print('--------------集合--------------')
    print(f'set type:{type(set())}')
    
    set1 = set()
    set2 = {
       1, 2, 3, 4}
    
    # 添加元素
    set1.add(3)
    set1.add(4)
    set1.add(9)
    print(f'set1 :{set1}')
    
    # 删除元素
    set1.remove(4)
    
    # 不可变集合
    set1 = frozenset(set1)
    
    # 集合操作
    print(f'交:{set1 & set2}')
    print(f'并:{set1 | set2}')
    print(f'差:{set1 - set2}')
    print(f'对称差集:{set1 ^ set2}')

## 字典 ##

字典是键值对的集合，类似于Java中的Map类型。需要注意的是Python的字典的键必须是不可变类型，也就是说键必须是数字、元组、字符串这样的对象才行。由于列表等类型是可变的，所以它们不能用作键。

创建字典使用空花括号对`{}`或者`dict()`构造函数。字典也包含了各种方法用于对元素进行操作。值得注意的几个字典的函数：`keys()`返回键列表；`values()`返回值列表；`items()`返回键值对组成的列表。

print('--------------字典--------------')
    print(f'dict type:{type({})}')
    
    # 创建字典
    dict1 = {}
    dict2 = dict()
    dict2 = {
       1: 2, 2: 4, 3: 6}
    
    # 字典操作
    dict1[1] = 1
    dict1[2] = 2
    print(f'dict1:{dict1}')
    
    dict1[2] = 3
    print(f'dict1:{dict1}')
    
    del dict1[2]
    print(f'dict1:{dict1}')
    
    # 键值集合
    print(f'dict2.keys:{dict2.keys()}')
    print(f'dict2.values{dict2.values()}')
    for k, v in dict2.items():
        print(f"[{k}:{v}]", end=' ')
    print()

## 集合操作 ##

### 序列类型 ###

前面说的列表、元组、字符串这些都是序列类型。它们支持功能强大的切片操作。切片操作使用切片操作符`[:]`，会返回对应开闭区间的元素集合。如果只指定了一边的索引，那么另外一边自动扩展到端点处。

索引还可以是负数，表示从后往前数，最后一个元素索引是-1，倒数第二个是-2，以此类推。另外如果索引超出序列范围也不用担心，解释器会忽略多余的长度。

print('--------------序列类型--------------')
    longString = 'abcdefghijklnm'
    
    print(f'整个序列:{longString[:]}')
    print(f'前5个:{longString[0:5]}')
    print(f'后5个:{longString[-6:-1]}')
    print(f'前五个之后的所有:{longString[6:]}')
    print(f'后五个前面所有的:{longString[:-6]}')
    print(f'所有元素:{longString[0:1000]}')

字符串、元组都是不可变的对象。所以它们的切片只能用来读取。如果是列表的话，我们还可以修改切片的值。下面的代码就将列表的一个切片修改为另一个列表。

longList = [1, 2, 2, 3, 4, 56, 6, 7, 8, 9, 0]
    
    print(f'longList:{longList}')
    longList[0:3] = [5]
    print(f'longList:{longList}')

### 列表解析 ###

python的列表还支持一种复杂的操作，叫做列表解析。它可以使用一个序列生成另一个列表，灵活使用的话功能非常强大。列表解析需要使用for循环语法。下面是一个将列表转换为平方列表的例子。

squareList = [i * i for i in range(1, 10)]

它与下面的for循环等价，但是写法更简洁。

for i in range(1,10):
        squareList.append(i*i)

Python官方教程上有几个更复杂的例子。例如，列表解析还可以解析多个变量，以及if表达式。

[(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]

上面的列表解析表达式与下面的等价。

>>> for x in [1,2,3]:
    ...     for y in [3,1,4]:
    ...         if x != y:
    ...             combs.append((x, y))